drivers/rpmsg/rpmsg_core.c

   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  */
  63 struct 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 }
  72 EXPORT_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  */
  82 void rpmsg_destroy_ept(struct rpmsg_endpoint *ept)
  83 {
  84         if (ept && ept->ops)
  85                 ept->ops->destroy_ept(ept);
  86 }
  87 EXPORT_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  */
 107 int 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 }
 116 EXPORT_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  */
 136 int 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 }
 145 EXPORT_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  */
 167 int 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 }
 177 EXPORT_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  */
 196 int 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 }
 205 EXPORT_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  */
 224 int 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 }
 233 EXPORT_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 }
 253 EXPORT_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  */
 274 int 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 }
 284 EXPORT_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  */
 291 static 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
 309 struct 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 }
 315 EXPORT_SYMBOL(rpmsg_find_device);
 316
 317 /* sysfs show configuration fields */
 318 #define rpmsg_show_attr(field, path, format_string)                     \
 319 static ssize_t                                                          \
 320 field##_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 }                                                                       \
 327 static DEVICE_ATTR_RO(field);
 328
 329 #define rpmsg_string_attr(field, member)                                \
 330 static ssize_t                                                          \
 331 field##_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 }                                                                       \
 357 static ssize_t                                                          \
 358 field##_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 }                                                                       \
 365 static DEVICE_ATTR_RW(field)
 366
 367 /* for more info, see Documentation/ABI/testing/sysfs-bus-rpmsg */
 368 rpmsg_show_attr(name, id.name, "%s\n");
 369 rpmsg_show_attr(src, src, "0x%x\n");
 370 rpmsg_show_attr(dst, dst, "0x%x\n");
 371 rpmsg_show_attr(announce, announce ? "true" : "false", "%s\n");
 372 rpmsg_string_attr(driver_override, driver_override);
 373
 374 static 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 }
 386 static DEVICE_ATTR_RO(modalias);
 387
 388 static 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 };
 397 ATTRIBUTE_GROUPS(rpmsg_dev);
 398
 399 /* rpmsg devices and drivers are matched using the service name */
 400 static 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 */
 407 static 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
 425 static 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  */
 446 static 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
 490 remove_rpdev:
 491         if (rpdrv->remove)
 492                 rpdrv->remove(rpdev);
 493 destroy_ept:
 494         if (ept)
 495                 rpmsg_destroy_ept(ept);
 496 out:
 497         return err;
 498 }
 499
 500 static 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
 520 static 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  */
 533 int 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 }
 569 EXPORT_SYMBOL(rpmsg_register_device_override);
 570
 571 int rpmsg_register_device(struct rpmsg_device *rpdev)
 572 {
 573         return rpmsg_register_device_override(rpdev, NULL);
 574 }
 575 EXPORT_SYMBOL(rpmsg_register_device);
 576
 577 /*
 578  * find an existing channel using its name + address properties,
 579  * and destroy it
 580  */
 581 int 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 }
 596 EXPORT_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  */
 605 int __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 }
 611 EXPORT_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  */
 619 void unregister_rpmsg_driver(struct rpmsg_driver *rpdrv)
 620 {
 621         driver_unregister(&rpdrv->drv);
 622 }
 623 EXPORT_SYMBOL(unregister_rpmsg_driver);
 624
 625
 626 static 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 }
 636 postcore_initcall(rpmsg_init);
 637
 638 static void __exit rpmsg_fini(void)
 639 {
 640         bus_unregister(&rpmsg_bus);
 641 }
 642 module_exit(rpmsg_fini);
 643
 644 MODULE_DESCRIPTION("remote processor messaging bus");
 645 MODULE_LICENSE("GPL v2");