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