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