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"); 379