1 /* 2 * remote processor messaging bus 3 * 4 * Copyright (C) 2011 Texas Instruments, Inc. 5 * Copyright (C) 2011 Google, Inc. 6 * 7 * Ohad Ben-Cohen <ohad@wizery.com> 8 * Brian Swetland <swetland@google.com> 9 * 10 * This software is licensed under the terms of the GNU General Public 11 * License version 2, as published by the Free Software Foundation, and 12 * may be copied, distributed, and modified under those terms. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 */ 19 20 #define pr_fmt(fmt) "%s: " fmt, __func__ 21 22 #include <linux/kernel.h> 23 #include <linux/module.h> 24 #include <linux/rpmsg.h> 25 #include <linux/of_device.h> 26 #include <linux/slab.h> 27 28 #include "rpmsg_internal.h" 29 30 /** 31 * rpmsg_create_ept() - create a new rpmsg_endpoint 32 * @rpdev: rpmsg channel device 33 * @cb: rx callback handler 34 * @priv: private data for the driver's use 35 * @chinfo: channel_info with the local rpmsg address to bind with @cb 36 * 37 * Every rpmsg address in the system is bound to an rx callback (so when 38 * inbound messages arrive, they are dispatched by the rpmsg bus using the 39 * appropriate callback handler) by means of an rpmsg_endpoint struct. 40 * 41 * This function allows drivers to create such an endpoint, and by that, 42 * bind a callback, and possibly some private data too, to an rpmsg address 43 * (either one that is known in advance, or one that will be dynamically 44 * assigned for them). 45 * 46 * Simple rpmsg drivers need not call rpmsg_create_ept, because an endpoint 47 * is already created for them when they are probed by the rpmsg bus 48 * (using the rx callback provided when they registered to the rpmsg bus). 49 * 50 * So things should just work for simple drivers: they already have an 51 * endpoint, their rx callback is bound to their rpmsg address, and when 52 * relevant inbound messages arrive (i.e. messages which their dst address 53 * equals to the src address of their rpmsg channel), the driver's handler 54 * is invoked to process it. 55 * 56 * That said, more complicated drivers might do need to allocate 57 * additional rpmsg addresses, and bind them to different rx callbacks. 58 * To accomplish that, those drivers need to call this function. 59 * 60 * Drivers should provide their @rpdev channel (so the new endpoint would belong 61 * to the same remote processor their channel belongs to), an rx callback 62 * function, an optional private data (which is provided back when the 63 * rx callback is invoked), and an address they want to bind with the 64 * callback. If @addr is RPMSG_ADDR_ANY, then rpmsg_create_ept will 65 * dynamically assign them an available rpmsg address (drivers should have 66 * a very good reason why not to always use RPMSG_ADDR_ANY here). 67 * 68 * Returns a pointer to the endpoint on success, or NULL on error. 69 */ 70 struct rpmsg_endpoint *rpmsg_create_ept(struct rpmsg_device *rpdev, 71 rpmsg_rx_cb_t cb, void *priv, 72 struct rpmsg_channel_info chinfo) 73 { 74 if (WARN_ON(!rpdev)) 75 return NULL; 76 77 return rpdev->ops->create_ept(rpdev, cb, priv, chinfo); 78 } 79 EXPORT_SYMBOL(rpmsg_create_ept); 80 81 /** 82 * rpmsg_destroy_ept() - destroy an existing rpmsg endpoint 83 * @ept: endpoing to destroy 84 * 85 * Should be used by drivers to destroy an rpmsg endpoint previously 86 * created with rpmsg_create_ept(). As with other types of "free" NULL 87 * is a valid parameter. 88 */ 89 void rpmsg_destroy_ept(struct rpmsg_endpoint *ept) 90 { 91 if (ept) 92 ept->ops->destroy_ept(ept); 93 } 94 EXPORT_SYMBOL(rpmsg_destroy_ept); 95 96 /** 97 * rpmsg_send() - send a message across to the remote processor 98 * @ept: the rpmsg endpoint 99 * @data: payload of message 100 * @len: length of payload 101 * 102 * This function sends @data of length @len on the @ept endpoint. 103 * The message will be sent to the remote processor which the @ept 104 * endpoint belongs to, using @ept's address and its associated rpmsg 105 * device destination addresses. 106 * In case there are no TX buffers available, the function will block until 107 * one becomes available, or a timeout of 15 seconds elapses. When the latter 108 * happens, -ERESTARTSYS is returned. 109 * 110 * Can only be called from process context (for now). 111 * 112 * Returns 0 on success and an appropriate error value on failure. 113 */ 114 int rpmsg_send(struct rpmsg_endpoint *ept, void *data, int len) 115 { 116 if (WARN_ON(!ept)) 117 return -EINVAL; 118 if (!ept->ops->send) 119 return -ENXIO; 120 121 return ept->ops->send(ept, data, len); 122 } 123 EXPORT_SYMBOL(rpmsg_send); 124 125 /** 126 * rpmsg_sendto() - send a message across to the remote processor, specify dst 127 * @ept: the rpmsg endpoint 128 * @data: payload of message 129 * @len: length of payload 130 * @dst: destination address 131 * 132 * This function sends @data of length @len to the remote @dst address. 133 * The message will be sent to the remote processor which the @ept 134 * endpoint belongs to, using @ept's address as source. 135 * In case there are no TX buffers available, the function will block until 136 * one becomes available, or a timeout of 15 seconds elapses. When the latter 137 * happens, -ERESTARTSYS is returned. 138 * 139 * Can only be called from process context (for now). 140 * 141 * Returns 0 on success and an appropriate error value on failure. 142 */ 143 int rpmsg_sendto(struct rpmsg_endpoint *ept, void *data, int len, u32 dst) 144 { 145 if (WARN_ON(!ept)) 146 return -EINVAL; 147 if (!ept->ops->sendto) 148 return -ENXIO; 149 150 return ept->ops->sendto(ept, data, len, dst); 151 } 152 EXPORT_SYMBOL(rpmsg_sendto); 153 154 /** 155 * rpmsg_send_offchannel() - send a message using explicit src/dst addresses 156 * @ept: the rpmsg endpoint 157 * @src: source address 158 * @dst: destination address 159 * @data: payload of message 160 * @len: length of payload 161 * 162 * This function sends @data of length @len to the remote @dst address, 163 * and uses @src as the source address. 164 * The message will be sent to the remote processor which the @ept 165 * endpoint belongs to. 166 * In case there are no TX buffers available, the function will block until 167 * one becomes available, or a timeout of 15 seconds elapses. When the latter 168 * happens, -ERESTARTSYS is returned. 169 * 170 * Can only be called from process context (for now). 171 * 172 * Returns 0 on success and an appropriate error value on failure. 173 */ 174 int rpmsg_send_offchannel(struct rpmsg_endpoint *ept, u32 src, u32 dst, 175 void *data, int len) 176 { 177 if (WARN_ON(!ept)) 178 return -EINVAL; 179 if (!ept->ops->send_offchannel) 180 return -ENXIO; 181 182 return ept->ops->send_offchannel(ept, src, dst, data, len); 183 } 184 EXPORT_SYMBOL(rpmsg_send_offchannel); 185 186 /** 187 * rpmsg_send() - send a message across to the remote processor 188 * @ept: the rpmsg endpoint 189 * @data: payload of message 190 * @len: length of payload 191 * 192 * This function sends @data of length @len on the @ept endpoint. 193 * The message will be sent to the remote processor which the @ept 194 * endpoint belongs to, using @ept's address as source and its associated 195 * rpdev's address as destination. 196 * In case there are no TX buffers available, the function will immediately 197 * return -ENOMEM without waiting until one becomes available. 198 * 199 * Can only be called from process context (for now). 200 * 201 * Returns 0 on success and an appropriate error value on failure. 202 */ 203 int rpmsg_trysend(struct rpmsg_endpoint *ept, void *data, int len) 204 { 205 if (WARN_ON(!ept)) 206 return -EINVAL; 207 if (!ept->ops->trysend) 208 return -ENXIO; 209 210 return ept->ops->trysend(ept, data, len); 211 } 212 EXPORT_SYMBOL(rpmsg_trysend); 213 214 /** 215 * rpmsg_sendto() - send a message across to the remote processor, specify dst 216 * @ept: the rpmsg endpoint 217 * @data: payload of message 218 * @len: length of payload 219 * @dst: destination address 220 * 221 * This function sends @data of length @len to the remote @dst address. 222 * The message will be sent to the remote processor which the @ept 223 * endpoint belongs to, using @ept's address as source. 224 * In case there are no TX buffers available, the function will immediately 225 * return -ENOMEM without waiting until one becomes available. 226 * 227 * Can only be called from process context (for now). 228 * 229 * Returns 0 on success and an appropriate error value on failure. 230 */ 231 int rpmsg_trysendto(struct rpmsg_endpoint *ept, void *data, int len, u32 dst) 232 { 233 if (WARN_ON(!ept)) 234 return -EINVAL; 235 if (!ept->ops->trysendto) 236 return -ENXIO; 237 238 return ept->ops->trysendto(ept, data, len, dst); 239 } 240 EXPORT_SYMBOL(rpmsg_trysendto); 241 242 /** 243 * rpmsg_poll() - poll the endpoint's send buffers 244 * @ept: the rpmsg endpoint 245 * @filp: file for poll_wait() 246 * @wait: poll_table for poll_wait() 247 * 248 * Returns mask representing the current state of the endpoint's send buffers 249 */ 250 unsigned int rpmsg_poll(struct rpmsg_endpoint *ept, struct file *filp, 251 poll_table *wait) 252 { 253 if (WARN_ON(!ept)) 254 return 0; 255 if (!ept->ops->poll) 256 return 0; 257 258 return ept->ops->poll(ept, filp, wait); 259 } 260 EXPORT_SYMBOL(rpmsg_poll); 261 262 /** 263 * rpmsg_send_offchannel() - send a message using explicit src/dst addresses 264 * @ept: the rpmsg endpoint 265 * @src: source address 266 * @dst: destination address 267 * @data: payload of message 268 * @len: length of payload 269 * 270 * This function sends @data of length @len to the remote @dst address, 271 * and uses @src as the source address. 272 * The message will be sent to the remote processor which the @ept 273 * endpoint belongs to. 274 * In case there are no TX buffers available, the function will immediately 275 * return -ENOMEM without waiting until one becomes available. 276 * 277 * Can only be called from process context (for now). 278 * 279 * Returns 0 on success and an appropriate error value on failure. 280 */ 281 int rpmsg_trysend_offchannel(struct rpmsg_endpoint *ept, u32 src, u32 dst, 282 void *data, int len) 283 { 284 if (WARN_ON(!ept)) 285 return -EINVAL; 286 if (!ept->ops->trysend_offchannel) 287 return -ENXIO; 288 289 return ept->ops->trysend_offchannel(ept, src, dst, data, len); 290 } 291 EXPORT_SYMBOL(rpmsg_trysend_offchannel); 292 293 /* 294 * match an rpmsg channel with a channel info struct. 295 * this is used to make sure we're not creating rpmsg devices for channels 296 * that already exist. 297 */ 298 static int rpmsg_device_match(struct device *dev, void *data) 299 { 300 struct rpmsg_channel_info *chinfo = data; 301 struct rpmsg_device *rpdev = to_rpmsg_device(dev); 302 303 if (chinfo->src != RPMSG_ADDR_ANY && chinfo->src != rpdev->src) 304 return 0; 305 306 if (chinfo->dst != RPMSG_ADDR_ANY && chinfo->dst != rpdev->dst) 307 return 0; 308 309 if (strncmp(chinfo->name, rpdev->id.name, RPMSG_NAME_SIZE)) 310 return 0; 311 312 /* found a match ! */ 313 return 1; 314 } 315 316 struct device *rpmsg_find_device(struct device *parent, 317 struct rpmsg_channel_info *chinfo) 318 { 319 return device_find_child(parent, chinfo, rpmsg_device_match); 320 321 } 322 EXPORT_SYMBOL(rpmsg_find_device); 323 324 /* sysfs show configuration fields */ 325 #define rpmsg_show_attr(field, path, format_string) \ 326 static ssize_t \ 327 field##_show(struct device *dev, \ 328 struct device_attribute *attr, char *buf) \ 329 { \ 330 struct rpmsg_device *rpdev = to_rpmsg_device(dev); \ 331 \ 332 return sprintf(buf, format_string, rpdev->path); \ 333 } 334 335 /* for more info, see Documentation/ABI/testing/sysfs-bus-rpmsg */ 336 rpmsg_show_attr(name, id.name, "%s\n"); 337 rpmsg_show_attr(src, src, "0x%x\n"); 338 rpmsg_show_attr(dst, dst, "0x%x\n"); 339 rpmsg_show_attr(announce, announce ? "true" : "false", "%s\n"); 340 341 static ssize_t modalias_show(struct device *dev, 342 struct device_attribute *attr, char *buf) 343 { 344 struct rpmsg_device *rpdev = to_rpmsg_device(dev); 345 346 return sprintf(buf, RPMSG_DEVICE_MODALIAS_FMT "\n", rpdev->id.name); 347 } 348 349 static struct device_attribute rpmsg_dev_attrs[] = { 350 __ATTR_RO(name), 351 __ATTR_RO(modalias), 352 __ATTR_RO(dst), 353 __ATTR_RO(src), 354 __ATTR_RO(announce), 355 __ATTR_NULL 356 }; 357 358 /* rpmsg devices and drivers are matched using the service name */ 359 static inline int rpmsg_id_match(const struct rpmsg_device *rpdev, 360 const struct rpmsg_device_id *id) 361 { 362 return strncmp(id->name, rpdev->id.name, RPMSG_NAME_SIZE) == 0; 363 } 364 365 /* match rpmsg channel and rpmsg driver */ 366 static int rpmsg_dev_match(struct device *dev, struct device_driver *drv) 367 { 368 struct rpmsg_device *rpdev = to_rpmsg_device(dev); 369 struct rpmsg_driver *rpdrv = to_rpmsg_driver(drv); 370 const struct rpmsg_device_id *ids = rpdrv->id_table; 371 unsigned int i; 372 373 if (rpdev->driver_override) 374 return !strcmp(rpdev->driver_override, drv->name); 375 376 if (ids) 377 for (i = 0; ids[i].name[0]; i++) 378 if (rpmsg_id_match(rpdev, &ids[i])) 379 return 1; 380 381 return of_driver_match_device(dev, drv); 382 } 383 384 static int rpmsg_uevent(struct device *dev, struct kobj_uevent_env *env) 385 { 386 struct rpmsg_device *rpdev = to_rpmsg_device(dev); 387 388 return add_uevent_var(env, "MODALIAS=" RPMSG_DEVICE_MODALIAS_FMT, 389 rpdev->id.name); 390 } 391 392 /* 393 * when an rpmsg driver is probed with a channel, we seamlessly create 394 * it an endpoint, binding its rx callback to a unique local rpmsg 395 * address. 396 * 397 * if we need to, we also announce about this channel to the remote 398 * processor (needed in case the driver is exposing an rpmsg service). 399 */ 400 static int rpmsg_dev_probe(struct device *dev) 401 { 402 struct rpmsg_device *rpdev = to_rpmsg_device(dev); 403 struct rpmsg_driver *rpdrv = to_rpmsg_driver(rpdev->dev.driver); 404 struct rpmsg_channel_info chinfo = {}; 405 struct rpmsg_endpoint *ept = NULL; 406 int err; 407 408 if (rpdrv->callback) { 409 strncpy(chinfo.name, rpdev->id.name, RPMSG_NAME_SIZE); 410 chinfo.src = rpdev->src; 411 chinfo.dst = RPMSG_ADDR_ANY; 412 413 ept = rpmsg_create_ept(rpdev, rpdrv->callback, NULL, chinfo); 414 if (!ept) { 415 dev_err(dev, "failed to create endpoint\n"); 416 err = -ENOMEM; 417 goto out; 418 } 419 420 rpdev->ept = ept; 421 rpdev->src = ept->addr; 422 } 423 424 err = rpdrv->probe(rpdev); 425 if (err) { 426 dev_err(dev, "%s: failed: %d\n", __func__, err); 427 if (ept) 428 rpmsg_destroy_ept(ept); 429 goto out; 430 } 431 432 if (rpdev->ops->announce_create) 433 err = rpdev->ops->announce_create(rpdev); 434 out: 435 return err; 436 } 437 438 static int rpmsg_dev_remove(struct device *dev) 439 { 440 struct rpmsg_device *rpdev = to_rpmsg_device(dev); 441 struct rpmsg_driver *rpdrv = to_rpmsg_driver(rpdev->dev.driver); 442 int err = 0; 443 444 if (rpdev->ops->announce_destroy) 445 err = rpdev->ops->announce_destroy(rpdev); 446 447 rpdrv->remove(rpdev); 448 449 if (rpdev->ept) 450 rpmsg_destroy_ept(rpdev->ept); 451 452 return err; 453 } 454 455 static struct bus_type rpmsg_bus = { 456 .name = "rpmsg", 457 .match = rpmsg_dev_match, 458 .dev_attrs = rpmsg_dev_attrs, 459 .uevent = rpmsg_uevent, 460 .probe = rpmsg_dev_probe, 461 .remove = rpmsg_dev_remove, 462 }; 463 464 static void rpmsg_release_device(struct device *dev) 465 { 466 struct rpmsg_device *rpdev = to_rpmsg_device(dev); 467 468 kfree(rpdev); 469 } 470 471 int rpmsg_register_device(struct rpmsg_device *rpdev) 472 { 473 struct device *dev = &rpdev->dev; 474 int ret; 475 476 dev_set_name(&rpdev->dev, "%s.%s.%d.%d", dev_name(dev->parent), 477 rpdev->id.name, rpdev->src, rpdev->dst); 478 479 rpdev->dev.bus = &rpmsg_bus; 480 rpdev->dev.release = rpmsg_release_device; 481 482 ret = device_register(&rpdev->dev); 483 if (ret) { 484 dev_err(dev, "device_register failed: %d\n", ret); 485 put_device(&rpdev->dev); 486 } 487 488 return ret; 489 } 490 EXPORT_SYMBOL(rpmsg_register_device); 491 492 /* 493 * find an existing channel using its name + address properties, 494 * and destroy it 495 */ 496 int rpmsg_unregister_device(struct device *parent, 497 struct rpmsg_channel_info *chinfo) 498 { 499 struct device *dev; 500 501 dev = rpmsg_find_device(parent, chinfo); 502 if (!dev) 503 return -EINVAL; 504 505 device_unregister(dev); 506 507 put_device(dev); 508 509 return 0; 510 } 511 EXPORT_SYMBOL(rpmsg_unregister_device); 512 513 /** 514 * __register_rpmsg_driver() - register an rpmsg driver with the rpmsg bus 515 * @rpdrv: pointer to a struct rpmsg_driver 516 * @owner: owning module/driver 517 * 518 * Returns 0 on success, and an appropriate error value on failure. 519 */ 520 int __register_rpmsg_driver(struct rpmsg_driver *rpdrv, struct module *owner) 521 { 522 rpdrv->drv.bus = &rpmsg_bus; 523 rpdrv->drv.owner = owner; 524 return driver_register(&rpdrv->drv); 525 } 526 EXPORT_SYMBOL(__register_rpmsg_driver); 527 528 /** 529 * unregister_rpmsg_driver() - unregister an rpmsg driver from the rpmsg bus 530 * @rpdrv: pointer to a struct rpmsg_driver 531 * 532 * Returns 0 on success, and an appropriate error value on failure. 533 */ 534 void unregister_rpmsg_driver(struct rpmsg_driver *rpdrv) 535 { 536 driver_unregister(&rpdrv->drv); 537 } 538 EXPORT_SYMBOL(unregister_rpmsg_driver); 539 540 541 static int __init rpmsg_init(void) 542 { 543 int ret; 544 545 ret = bus_register(&rpmsg_bus); 546 if (ret) 547 pr_err("failed to register rpmsg bus: %d\n", ret); 548 549 return ret; 550 } 551 postcore_initcall(rpmsg_init); 552 553 static void __exit rpmsg_fini(void) 554 { 555 bus_unregister(&rpmsg_bus); 556 } 557 module_exit(rpmsg_fini); 558 559 MODULE_DESCRIPTION("remote processor messaging bus"); 560 MODULE_LICENSE("GPL v2"); 561