1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2011-2017, The Linux Foundation. All rights reserved.
3 // Copyright (c) 2018, Linaro Limited
5 #include <linux/kernel.h>
6 #include <linux/module.h>
7 #include <linux/device.h>
8 #include <linux/spinlock.h>
10 #include <linux/slab.h>
11 #include <linux/workqueue.h>
12 #include <linux/of_device.h>
13 #include <linux/soc/qcom/apr.h>
14 #include <linux/soc/qcom/pdr.h>
15 #include <linux/rpmsg.h>
22 struct packet_router {
23 struct rpmsg_endpoint *ch;
30 struct pdr_handle *pdr;
31 struct workqueue_struct *rxwq;
32 struct work_struct rx_work;
33 struct list_head rx_list;
37 struct list_head node;
43 * apr_send_pkt() - Send a apr message from apr device
45 * @adev: Pointer to previously registered apr device.
46 * @pkt: Pointer to apr packet to send
48 * Return: Will be an negative on packet size on success.
50 int apr_send_pkt(struct apr_device *adev, struct apr_pkt *pkt)
52 struct packet_router *apr = dev_get_drvdata(adev->dev.parent);
57 spin_lock_irqsave(&adev->svc.lock, flags);
60 hdr->src_domain = APR_DOMAIN_APPS;
61 hdr->src_svc = adev->svc.id;
62 hdr->dest_domain = adev->domain_id;
63 hdr->dest_svc = adev->svc.id;
65 ret = rpmsg_trysend(apr->ch, pkt, hdr->pkt_size);
66 spin_unlock_irqrestore(&adev->svc.lock, flags);
68 return ret ? ret : hdr->pkt_size;
70 EXPORT_SYMBOL_GPL(apr_send_pkt);
72 static void apr_dev_release(struct device *dev)
74 struct apr_device *adev = to_apr_device(dev);
79 static int apr_callback(struct rpmsg_device *rpdev, void *buf,
80 int len, void *priv, u32 addr)
82 struct packet_router *apr = dev_get_drvdata(&rpdev->dev);
83 struct apr_rx_buf *abuf;
86 if (len <= APR_HDR_SIZE) {
87 dev_err(apr->dev, "APR: Improper apr pkt received:%p %d\n",
92 abuf = kzalloc(sizeof(*abuf) + len, GFP_ATOMIC);
97 memcpy(abuf->buf, buf, len);
99 spin_lock_irqsave(&apr->rx_lock, flags);
100 list_add_tail(&abuf->node, &apr->rx_list);
101 spin_unlock_irqrestore(&apr->rx_lock, flags);
103 queue_work(apr->rxwq, &apr->rx_work);
108 static int apr_do_rx_callback(struct packet_router *apr, struct apr_rx_buf *abuf)
110 uint16_t hdr_size, msg_type, ver, svc_id;
111 struct pkt_router_svc *svc;
112 struct apr_device *adev;
113 struct apr_driver *adrv = NULL;
114 struct apr_resp_pkt resp;
117 void *buf = abuf->buf;
121 ver = APR_HDR_FIELD_VER(hdr->hdr_field);
122 if (ver > APR_PKT_VER + 1)
125 hdr_size = APR_HDR_FIELD_SIZE_BYTES(hdr->hdr_field);
126 if (hdr_size < APR_HDR_SIZE) {
127 dev_err(apr->dev, "APR: Wrong hdr size:%d\n", hdr_size);
131 if (hdr->pkt_size < APR_HDR_SIZE || hdr->pkt_size != len) {
132 dev_err(apr->dev, "APR: Wrong packet size\n");
136 msg_type = APR_HDR_FIELD_MT(hdr->hdr_field);
137 if (msg_type >= APR_MSG_TYPE_MAX) {
138 dev_err(apr->dev, "APR: Wrong message type: %d\n", msg_type);
142 if (hdr->src_domain >= APR_DOMAIN_MAX ||
143 hdr->dest_domain >= APR_DOMAIN_MAX ||
144 hdr->src_svc >= APR_SVC_MAX ||
145 hdr->dest_svc >= APR_SVC_MAX) {
146 dev_err(apr->dev, "APR: Wrong APR header\n");
150 svc_id = hdr->dest_svc;
151 spin_lock_irqsave(&apr->svcs_lock, flags);
152 svc = idr_find(&apr->svcs_idr, svc_id);
153 if (svc && svc->dev->driver) {
154 adev = svc_to_apr_device(svc);
155 adrv = to_apr_driver(adev->dev.driver);
157 spin_unlock_irqrestore(&apr->svcs_lock, flags);
159 if (!adrv || !adev) {
160 dev_err(apr->dev, "APR: service is not registered (%d)\n",
166 resp.payload_size = hdr->pkt_size - hdr_size;
169 * NOTE: hdr_size is not same as APR_HDR_SIZE as remote can include
170 * optional headers in to apr_hdr which should be ignored
172 if (resp.payload_size > 0)
173 resp.payload = buf + hdr_size;
175 adrv->callback(adev, &resp);
180 static void apr_rxwq(struct work_struct *work)
182 struct packet_router *apr = container_of(work, struct packet_router, rx_work);
183 struct apr_rx_buf *abuf, *b;
186 if (!list_empty(&apr->rx_list)) {
187 list_for_each_entry_safe(abuf, b, &apr->rx_list, node) {
190 apr_do_rx_callback(apr, abuf);
195 spin_lock_irqsave(&apr->rx_lock, flags);
196 list_del(&abuf->node);
197 spin_unlock_irqrestore(&apr->rx_lock, flags);
203 static int apr_device_match(struct device *dev, struct device_driver *drv)
205 struct apr_device *adev = to_apr_device(dev);
206 struct apr_driver *adrv = to_apr_driver(drv);
207 const struct apr_device_id *id = adrv->id_table;
209 /* Attempt an OF style match first */
210 if (of_driver_match_device(dev, drv))
216 while (id->domain_id != 0 || id->svc_id != 0) {
217 if (id->domain_id == adev->domain_id &&
218 id->svc_id == adev->svc.id)
226 static int apr_device_probe(struct device *dev)
228 struct apr_device *adev = to_apr_device(dev);
229 struct apr_driver *adrv = to_apr_driver(dev->driver);
231 return adrv->probe(adev);
234 static int apr_device_remove(struct device *dev)
236 struct apr_device *adev = to_apr_device(dev);
237 struct apr_driver *adrv;
238 struct packet_router *apr = dev_get_drvdata(adev->dev.parent);
241 adrv = to_apr_driver(dev->driver);
244 spin_lock(&apr->svcs_lock);
245 idr_remove(&apr->svcs_idr, adev->svc.id);
246 spin_unlock(&apr->svcs_lock);
252 static int apr_uevent(struct device *dev, struct kobj_uevent_env *env)
254 struct apr_device *adev = to_apr_device(dev);
257 ret = of_device_uevent_modalias(dev, env);
261 return add_uevent_var(env, "MODALIAS=apr:%s", adev->name);
264 struct bus_type aprbus = {
266 .match = apr_device_match,
267 .probe = apr_device_probe,
268 .uevent = apr_uevent,
269 .remove = apr_device_remove,
271 EXPORT_SYMBOL_GPL(aprbus);
273 static int apr_add_device(struct device *dev, struct device_node *np,
274 u32 svc_id, u32 domain_id)
276 struct packet_router *apr = dev_get_drvdata(dev);
277 struct apr_device *adev = NULL;
278 struct pkt_router_svc *svc;
281 adev = kzalloc(sizeof(*adev), GFP_KERNEL);
285 adev->svc_id = svc_id;
292 spin_lock_init(&svc->lock);
294 adev->domain_id = domain_id;
297 snprintf(adev->name, APR_NAME_SIZE, "%pOFn", np);
301 dev_set_name(&adev->dev, "aprsvc:%s:%x:%x", adev->name,
308 adev->dev.bus = &aprbus;
309 adev->dev.parent = dev;
310 adev->dev.of_node = np;
311 adev->dev.release = apr_dev_release;
312 adev->dev.driver = NULL;
314 spin_lock(&apr->svcs_lock);
315 ret = idr_alloc(&apr->svcs_idr, svc, svc_id, svc_id + 1, GFP_ATOMIC);
316 spin_unlock(&apr->svcs_lock);
318 dev_err(dev, "idr_alloc failed: %d\n", ret);
322 /* Protection domain is optional, it does not exist on older platforms */
323 ret = of_property_read_string_index(np, "qcom,protection-domain",
324 1, &adev->service_path);
325 if (ret < 0 && ret != -EINVAL) {
326 dev_err(dev, "Failed to read second value of qcom,protection-domain\n");
330 dev_info(dev, "Adding APR dev: %s\n", dev_name(&adev->dev));
332 ret = device_register(&adev->dev);
334 dev_err(dev, "device_register failed: %d\n", ret);
335 put_device(&adev->dev);
342 static int of_apr_add_pd_lookups(struct device *dev)
344 const char *service_name, *service_path;
345 struct packet_router *apr = dev_get_drvdata(dev);
346 struct device_node *node;
347 struct pdr_service *pds;
350 for_each_child_of_node(dev->of_node, node) {
351 ret = of_property_read_string_index(node, "qcom,protection-domain",
356 ret = of_property_read_string_index(node, "qcom,protection-domain",
359 dev_err(dev, "pdr service path missing: %d\n", ret);
364 pds = pdr_add_lookup(apr->pdr, service_name, service_path);
365 if (IS_ERR(pds) && PTR_ERR(pds) != -EALREADY) {
366 dev_err(dev, "pdr add lookup failed: %ld\n", PTR_ERR(pds));
375 static void of_register_apr_devices(struct device *dev, const char *svc_path)
377 struct packet_router *apr = dev_get_drvdata(dev);
378 struct device_node *node;
379 const char *service_path;
382 for_each_child_of_node(dev->of_node, node) {
387 * This function is called with svc_path NULL during
388 * apr_probe(), in which case we register any apr devices
389 * without a qcom,protection-domain specified.
391 * Then as the protection domains becomes available
392 * (if applicable) this function is again called, but with
393 * svc_path representing the service becoming available. In
394 * this case we register any apr devices with a matching
395 * qcom,protection-domain.
398 ret = of_property_read_string_index(node, "qcom,protection-domain",
401 /* skip APR services that are PD independent */
405 /* skip APR services whose PD paths don't match */
406 if (strcmp(service_path, svc_path))
409 /* skip APR services whose PD lookups are registered */
414 if (of_property_read_u32(node, "reg", &svc_id))
417 domain_id = apr->dest_domain_id;
419 if (apr_add_device(dev, node, svc_id, domain_id))
420 dev_err(dev, "Failed to add apr %d svc\n", svc_id);
424 static int apr_remove_device(struct device *dev, void *svc_path)
426 struct apr_device *adev = to_apr_device(dev);
428 if (svc_path && adev->service_path) {
429 if (!strcmp(adev->service_path, (char *)svc_path))
430 device_unregister(&adev->dev);
432 device_unregister(&adev->dev);
438 static void apr_pd_status(int state, char *svc_path, void *priv)
440 struct packet_router *apr = (struct packet_router *)priv;
443 case SERVREG_SERVICE_STATE_UP:
444 of_register_apr_devices(apr->dev, svc_path);
446 case SERVREG_SERVICE_STATE_DOWN:
447 device_for_each_child(apr->dev, svc_path, apr_remove_device);
452 static int apr_probe(struct rpmsg_device *rpdev)
454 struct device *dev = &rpdev->dev;
455 struct packet_router *apr;
458 apr = devm_kzalloc(dev, sizeof(*apr), GFP_KERNEL);
462 ret = of_property_read_u32(dev->of_node, "qcom,domain", &apr->dest_domain_id);
463 if (ret) /* try deprecated apr-domain property */
464 ret = of_property_read_u32(dev->of_node, "qcom,apr-domain",
465 &apr->dest_domain_id);
466 apr->type = PR_TYPE_APR;
468 dev_err(dev, "Domain ID not specified in DT\n");
472 dev_set_drvdata(dev, apr);
473 apr->ch = rpdev->ept;
475 apr->rxwq = create_singlethread_workqueue("qcom_apr_rx");
477 dev_err(apr->dev, "Failed to start Rx WQ\n");
480 INIT_WORK(&apr->rx_work, apr_rxwq);
482 apr->pdr = pdr_handle_alloc(apr_pd_status, apr);
483 if (IS_ERR(apr->pdr)) {
484 dev_err(dev, "Failed to init PDR handle\n");
485 ret = PTR_ERR(apr->pdr);
489 INIT_LIST_HEAD(&apr->rx_list);
490 spin_lock_init(&apr->rx_lock);
491 spin_lock_init(&apr->svcs_lock);
492 idr_init(&apr->svcs_idr);
494 ret = of_apr_add_pd_lookups(dev);
498 of_register_apr_devices(dev, NULL);
503 pdr_handle_release(apr->pdr);
505 destroy_workqueue(apr->rxwq);
509 static void apr_remove(struct rpmsg_device *rpdev)
511 struct packet_router *apr = dev_get_drvdata(&rpdev->dev);
513 pdr_handle_release(apr->pdr);
514 device_for_each_child(&rpdev->dev, NULL, apr_remove_device);
515 flush_workqueue(apr->rxwq);
516 destroy_workqueue(apr->rxwq);
520 * __apr_driver_register() - Client driver registration with aprbus
522 * @drv:Client driver to be associated with client-device.
523 * @owner: owning module/driver
525 * This API will register the client driver with the aprbus
526 * It is called from the driver's module-init function.
528 int __apr_driver_register(struct apr_driver *drv, struct module *owner)
530 drv->driver.bus = &aprbus;
531 drv->driver.owner = owner;
533 return driver_register(&drv->driver);
535 EXPORT_SYMBOL_GPL(__apr_driver_register);
538 * apr_driver_unregister() - Undo effect of apr_driver_register
540 * @drv: Client driver to be unregistered
542 void apr_driver_unregister(struct apr_driver *drv)
544 driver_unregister(&drv->driver);
546 EXPORT_SYMBOL_GPL(apr_driver_unregister);
548 static const struct of_device_id pkt_router_of_match[] = {
549 { .compatible = "qcom,apr"},
550 { .compatible = "qcom,apr-v2"},
553 MODULE_DEVICE_TABLE(of, pkt_router_of_match);
555 static struct rpmsg_driver packet_router_driver = {
557 .remove = apr_remove,
558 .callback = apr_callback,
561 .of_match_table = pkt_router_of_match,
565 static int __init apr_init(void)
569 ret = bus_register(&aprbus);
571 ret = register_rpmsg_driver(&packet_router_driver);
573 bus_unregister(&aprbus);
578 static void __exit apr_exit(void)
580 bus_unregister(&aprbus);
581 unregister_rpmsg_driver(&packet_router_driver);
584 subsys_initcall(apr_init);
585 module_exit(apr_exit);
587 MODULE_LICENSE("GPL v2");
588 MODULE_DESCRIPTION("Qualcomm APR Bus");