Merge tag 'armsoc-drivers' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc
[sfrench/cifs-2.6.git] / drivers / soc / qcom / apr.c
1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2011-2017, The Linux Foundation. All rights reserved.
3 // Copyright (c) 2018, Linaro Limited
4
5 #include <linux/kernel.h>
6 #include <linux/module.h>
7 #include <linux/device.h>
8 #include <linux/spinlock.h>
9 #include <linux/idr.h>
10 #include <linux/slab.h>
11 #include <linux/of_device.h>
12 #include <linux/soc/qcom/apr.h>
13 #include <linux/rpmsg.h>
14 #include <linux/of.h>
15
16 struct apr {
17         struct rpmsg_endpoint *ch;
18         struct device *dev;
19         spinlock_t svcs_lock;
20         struct idr svcs_idr;
21         int dest_domain_id;
22 };
23
24 /**
25  * apr_send_pkt() - Send a apr message from apr device
26  *
27  * @adev: Pointer to previously registered apr device.
28  * @pkt: Pointer to apr packet to send
29  *
30  * Return: Will be an negative on packet size on success.
31  */
32 int apr_send_pkt(struct apr_device *adev, struct apr_pkt *pkt)
33 {
34         struct apr *apr = dev_get_drvdata(adev->dev.parent);
35         struct apr_hdr *hdr;
36         unsigned long flags;
37         int ret;
38
39         spin_lock_irqsave(&adev->lock, flags);
40
41         hdr = &pkt->hdr;
42         hdr->src_domain = APR_DOMAIN_APPS;
43         hdr->src_svc = adev->svc_id;
44         hdr->dest_domain = adev->domain_id;
45         hdr->dest_svc = adev->svc_id;
46
47         ret = rpmsg_trysend(apr->ch, pkt, hdr->pkt_size);
48         spin_unlock_irqrestore(&adev->lock, flags);
49
50         return ret ? ret : hdr->pkt_size;
51 }
52 EXPORT_SYMBOL_GPL(apr_send_pkt);
53
54 static void apr_dev_release(struct device *dev)
55 {
56         struct apr_device *adev = to_apr_device(dev);
57
58         kfree(adev);
59 }
60
61 static int apr_callback(struct rpmsg_device *rpdev, void *buf,
62                                   int len, void *priv, u32 addr)
63 {
64         struct apr *apr = dev_get_drvdata(&rpdev->dev);
65         uint16_t hdr_size, msg_type, ver, svc_id;
66         struct apr_device *svc = NULL;
67         struct apr_driver *adrv = NULL;
68         struct apr_resp_pkt resp;
69         struct apr_hdr *hdr;
70         unsigned long flags;
71
72         if (len <= APR_HDR_SIZE) {
73                 dev_err(apr->dev, "APR: Improper apr pkt received:%p %d\n",
74                         buf, len);
75                 return -EINVAL;
76         }
77
78         hdr = buf;
79         ver = APR_HDR_FIELD_VER(hdr->hdr_field);
80         if (ver > APR_PKT_VER + 1)
81                 return -EINVAL;
82
83         hdr_size = APR_HDR_FIELD_SIZE_BYTES(hdr->hdr_field);
84         if (hdr_size < APR_HDR_SIZE) {
85                 dev_err(apr->dev, "APR: Wrong hdr size:%d\n", hdr_size);
86                 return -EINVAL;
87         }
88
89         if (hdr->pkt_size < APR_HDR_SIZE || hdr->pkt_size != len) {
90                 dev_err(apr->dev, "APR: Wrong packet size\n");
91                 return -EINVAL;
92         }
93
94         msg_type = APR_HDR_FIELD_MT(hdr->hdr_field);
95         if (msg_type >= APR_MSG_TYPE_MAX) {
96                 dev_err(apr->dev, "APR: Wrong message type: %d\n", msg_type);
97                 return -EINVAL;
98         }
99
100         if (hdr->src_domain >= APR_DOMAIN_MAX ||
101                         hdr->dest_domain >= APR_DOMAIN_MAX ||
102                         hdr->src_svc >= APR_SVC_MAX ||
103                         hdr->dest_svc >= APR_SVC_MAX) {
104                 dev_err(apr->dev, "APR: Wrong APR header\n");
105                 return -EINVAL;
106         }
107
108         svc_id = hdr->dest_svc;
109         spin_lock_irqsave(&apr->svcs_lock, flags);
110         svc = idr_find(&apr->svcs_idr, svc_id);
111         if (svc && svc->dev.driver)
112                 adrv = to_apr_driver(svc->dev.driver);
113         spin_unlock_irqrestore(&apr->svcs_lock, flags);
114
115         if (!adrv) {
116                 dev_err(apr->dev, "APR: service is not registered\n");
117                 return -EINVAL;
118         }
119
120         resp.hdr = *hdr;
121         resp.payload_size = hdr->pkt_size - hdr_size;
122
123         /*
124          * NOTE: hdr_size is not same as APR_HDR_SIZE as remote can include
125          * optional headers in to apr_hdr which should be ignored
126          */
127         if (resp.payload_size > 0)
128                 resp.payload = buf + hdr_size;
129
130         adrv->callback(svc, &resp);
131
132         return 0;
133 }
134
135 static int apr_device_match(struct device *dev, struct device_driver *drv)
136 {
137         struct apr_device *adev = to_apr_device(dev);
138         struct apr_driver *adrv = to_apr_driver(drv);
139         const struct apr_device_id *id = adrv->id_table;
140
141         /* Attempt an OF style match first */
142         if (of_driver_match_device(dev, drv))
143                 return 1;
144
145         if (!id)
146                 return 0;
147
148         while (id->domain_id != 0 || id->svc_id != 0) {
149                 if (id->domain_id == adev->domain_id &&
150                     id->svc_id == adev->svc_id)
151                         return 1;
152                 id++;
153         }
154
155         return 0;
156 }
157
158 static int apr_device_probe(struct device *dev)
159 {
160         struct apr_device *adev = to_apr_device(dev);
161         struct apr_driver *adrv = to_apr_driver(dev->driver);
162
163         return adrv->probe(adev);
164 }
165
166 static int apr_device_remove(struct device *dev)
167 {
168         struct apr_device *adev = to_apr_device(dev);
169         struct apr_driver *adrv;
170         struct apr *apr = dev_get_drvdata(adev->dev.parent);
171
172         if (dev->driver) {
173                 adrv = to_apr_driver(dev->driver);
174                 if (adrv->remove)
175                         adrv->remove(adev);
176                 spin_lock(&apr->svcs_lock);
177                 idr_remove(&apr->svcs_idr, adev->svc_id);
178                 spin_unlock(&apr->svcs_lock);
179         }
180
181         return 0;
182 }
183
184 static int apr_uevent(struct device *dev, struct kobj_uevent_env *env)
185 {
186         struct apr_device *adev = to_apr_device(dev);
187         int ret;
188
189         ret = of_device_uevent_modalias(dev, env);
190         if (ret != -ENODEV)
191                 return ret;
192
193         return add_uevent_var(env, "MODALIAS=apr:%s", adev->name);
194 }
195
196 struct bus_type aprbus = {
197         .name           = "aprbus",
198         .match          = apr_device_match,
199         .probe          = apr_device_probe,
200         .uevent         = apr_uevent,
201         .remove         = apr_device_remove,
202 };
203 EXPORT_SYMBOL_GPL(aprbus);
204
205 static int apr_add_device(struct device *dev, struct device_node *np,
206                           const struct apr_device_id *id)
207 {
208         struct apr *apr = dev_get_drvdata(dev);
209         struct apr_device *adev = NULL;
210         int ret;
211
212         adev = kzalloc(sizeof(*adev), GFP_KERNEL);
213         if (!adev)
214                 return -ENOMEM;
215
216         spin_lock_init(&adev->lock);
217
218         adev->svc_id = id->svc_id;
219         adev->domain_id = id->domain_id;
220         adev->version = id->svc_version;
221         if (np)
222                 snprintf(adev->name, APR_NAME_SIZE, "%pOFn", np);
223         else
224                 strscpy(adev->name, id->name, APR_NAME_SIZE);
225
226         dev_set_name(&adev->dev, "aprsvc:%s:%x:%x", adev->name,
227                      id->domain_id, id->svc_id);
228
229         adev->dev.bus = &aprbus;
230         adev->dev.parent = dev;
231         adev->dev.of_node = np;
232         adev->dev.release = apr_dev_release;
233         adev->dev.driver = NULL;
234
235         spin_lock(&apr->svcs_lock);
236         idr_alloc(&apr->svcs_idr, adev, id->svc_id,
237                   id->svc_id + 1, GFP_ATOMIC);
238         spin_unlock(&apr->svcs_lock);
239
240         dev_info(dev, "Adding APR dev: %s\n", dev_name(&adev->dev));
241
242         ret = device_register(&adev->dev);
243         if (ret) {
244                 dev_err(dev, "device_register failed: %d\n", ret);
245                 put_device(&adev->dev);
246         }
247
248         return ret;
249 }
250
251 static void of_register_apr_devices(struct device *dev)
252 {
253         struct apr *apr = dev_get_drvdata(dev);
254         struct device_node *node;
255
256         for_each_child_of_node(dev->of_node, node) {
257                 struct apr_device_id id = { {0} };
258
259                 if (of_property_read_u32(node, "reg", &id.svc_id))
260                         continue;
261
262                 id.domain_id = apr->dest_domain_id;
263
264                 if (apr_add_device(dev, node, &id))
265                         dev_err(dev, "Failed to add apr %d svc\n", id.svc_id);
266         }
267 }
268
269 static int apr_probe(struct rpmsg_device *rpdev)
270 {
271         struct device *dev = &rpdev->dev;
272         struct apr *apr;
273         int ret;
274
275         apr = devm_kzalloc(dev, sizeof(*apr), GFP_KERNEL);
276         if (!apr)
277                 return -ENOMEM;
278
279         ret = of_property_read_u32(dev->of_node, "reg", &apr->dest_domain_id);
280         if (ret) {
281                 dev_err(dev, "APR Domain ID not specified in DT\n");
282                 return ret;
283         }
284
285         dev_set_drvdata(dev, apr);
286         apr->ch = rpdev->ept;
287         apr->dev = dev;
288         spin_lock_init(&apr->svcs_lock);
289         idr_init(&apr->svcs_idr);
290         of_register_apr_devices(dev);
291
292         return 0;
293 }
294
295 static int apr_remove_device(struct device *dev, void *null)
296 {
297         struct apr_device *adev = to_apr_device(dev);
298
299         device_unregister(&adev->dev);
300
301         return 0;
302 }
303
304 static void apr_remove(struct rpmsg_device *rpdev)
305 {
306         device_for_each_child(&rpdev->dev, NULL, apr_remove_device);
307 }
308
309 /*
310  * __apr_driver_register() - Client driver registration with aprbus
311  *
312  * @drv:Client driver to be associated with client-device.
313  * @owner: owning module/driver
314  *
315  * This API will register the client driver with the aprbus
316  * It is called from the driver's module-init function.
317  */
318 int __apr_driver_register(struct apr_driver *drv, struct module *owner)
319 {
320         drv->driver.bus = &aprbus;
321         drv->driver.owner = owner;
322
323         return driver_register(&drv->driver);
324 }
325 EXPORT_SYMBOL_GPL(__apr_driver_register);
326
327 /*
328  * apr_driver_unregister() - Undo effect of apr_driver_register
329  *
330  * @drv: Client driver to be unregistered
331  */
332 void apr_driver_unregister(struct apr_driver *drv)
333 {
334         driver_unregister(&drv->driver);
335 }
336 EXPORT_SYMBOL_GPL(apr_driver_unregister);
337
338 static const struct of_device_id apr_of_match[] = {
339         { .compatible = "qcom,apr"},
340         { .compatible = "qcom,apr-v2"},
341         {}
342 };
343 MODULE_DEVICE_TABLE(of, apr_of_match);
344
345 static struct rpmsg_driver apr_driver = {
346         .probe = apr_probe,
347         .remove = apr_remove,
348         .callback = apr_callback,
349         .drv = {
350                 .name = "qcom,apr",
351                 .of_match_table = apr_of_match,
352         },
353 };
354
355 static int __init apr_init(void)
356 {
357         int ret;
358
359         ret = bus_register(&aprbus);
360         if (!ret)
361                 ret = register_rpmsg_driver(&apr_driver);
362         else
363                 bus_unregister(&aprbus);
364
365         return ret;
366 }
367
368 static void __exit apr_exit(void)
369 {
370         bus_unregister(&aprbus);
371         unregister_rpmsg_driver(&apr_driver);
372 }
373
374 subsys_initcall(apr_init);
375 module_exit(apr_exit);
376
377 MODULE_LICENSE("GPL v2");
378 MODULE_DESCRIPTION("Qualcomm APR Bus");