drivers/rpmsg/rpmsg_core.c

   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 static DEVICE_ATTR_RO(field);
 335
 336 /* for more info, see Documentation/ABI/testing/sysfs-bus-rpmsg */
 337 rpmsg_show_attr(name, id.name, "%s\n");
 338 rpmsg_show_attr(src, src, "0x%x\n");
 339 rpmsg_show_attr(dst, dst, "0x%x\n");
 340 rpmsg_show_attr(announce, announce ? "true" : "false", "%s\n");
 341
 342 static ssize_t modalias_show(struct device *dev,
 343                              struct device_attribute *attr, char *buf)
 344 {
 345         struct rpmsg_device *rpdev = to_rpmsg_device(dev);
 346         ssize_t len;
 347
 348         len = of_device_modalias(dev, buf, PAGE_SIZE);
 349         if (len != -ENODEV)
 350                 return len;
 351
 352         return sprintf(buf, RPMSG_DEVICE_MODALIAS_FMT "\n", rpdev->id.name);
 353 }
 354 static DEVICE_ATTR_RO(modalias);
 355
 356 static struct attribute *rpmsg_dev_attrs[] = {
 357         &dev_attr_name.attr,
 358         &dev_attr_modalias.attr,
 359         &dev_attr_dst.attr,
 360         &dev_attr_src.attr,
 361         &dev_attr_announce.attr,
 362         NULL,
 363 };
 364 ATTRIBUTE_GROUPS(rpmsg_dev);
 365
 366 /* rpmsg devices and drivers are matched using the service name */
 367 static inline int rpmsg_id_match(const struct rpmsg_device *rpdev,
 368                                   const struct rpmsg_device_id *id)
 369 {
 370         return strncmp(id->name, rpdev->id.name, RPMSG_NAME_SIZE) == 0;
 371 }
 372
 373 /* match rpmsg channel and rpmsg driver */
 374 static int rpmsg_dev_match(struct device *dev, struct device_driver *drv)
 375 {
 376         struct rpmsg_device *rpdev = to_rpmsg_device(dev);
 377         struct rpmsg_driver *rpdrv = to_rpmsg_driver(drv);
 378         const struct rpmsg_device_id *ids = rpdrv->id_table;
 379         unsigned int i;
 380
 381         if (rpdev->driver_override)
 382                 return !strcmp(rpdev->driver_override, drv->name);
 383
 384         if (ids)
 385                 for (i = 0; ids[i].name[0]; i++)
 386                         if (rpmsg_id_match(rpdev, &ids[i]))
 387                                 return 1;
 388
 389         return of_driver_match_device(dev, drv);
 390 }
 391
 392 static int rpmsg_uevent(struct device *dev, struct kobj_uevent_env *env)
 393 {
 394         struct rpmsg_device *rpdev = to_rpmsg_device(dev);
 395         int ret;
 396
 397         ret = of_device_uevent_modalias(dev, env);
 398         if (ret != -ENODEV)
 399                 return ret;
 400
 401         return add_uevent_var(env, "MODALIAS=" RPMSG_DEVICE_MODALIAS_FMT,
 402                                         rpdev->id.name);
 403 }
 404
 405 /*
 406  * when an rpmsg driver is probed with a channel, we seamlessly create
 407  * it an endpoint, binding its rx callback to a unique local rpmsg
 408  * address.
 409  *
 410  * if we need to, we also announce about this channel to the remote
 411  * processor (needed in case the driver is exposing an rpmsg service).
 412  */
 413 static int rpmsg_dev_probe(struct device *dev)
 414 {
 415         struct rpmsg_device *rpdev = to_rpmsg_device(dev);
 416         struct rpmsg_driver *rpdrv = to_rpmsg_driver(rpdev->dev.driver);
 417         struct rpmsg_channel_info chinfo = {};
 418         struct rpmsg_endpoint *ept = NULL;
 419         int err;
 420
 421         if (rpdrv->callback) {
 422                 strncpy(chinfo.name, rpdev->id.name, RPMSG_NAME_SIZE);
 423                 chinfo.src = rpdev->src;
 424                 chinfo.dst = RPMSG_ADDR_ANY;
 425
 426                 ept = rpmsg_create_ept(rpdev, rpdrv->callback, NULL, chinfo);
 427                 if (!ept) {
 428                         dev_err(dev, "failed to create endpoint\n");
 429                         err = -ENOMEM;
 430                         goto out;
 431                 }
 432
 433                 rpdev->ept = ept;
 434                 rpdev->src = ept->addr;
 435         }
 436
 437         err = rpdrv->probe(rpdev);
 438         if (err) {
 439                 dev_err(dev, "%s: failed: %d\n", __func__, err);
 440                 if (ept)
 441                         rpmsg_destroy_ept(ept);
 442                 goto out;
 443         }
 444
 445         if (rpdev->ops->announce_create)
 446                 err = rpdev->ops->announce_create(rpdev);
 447 out:
 448         return err;
 449 }
 450
 451 static int rpmsg_dev_remove(struct device *dev)
 452 {
 453         struct rpmsg_device *rpdev = to_rpmsg_device(dev);
 454         struct rpmsg_driver *rpdrv = to_rpmsg_driver(rpdev->dev.driver);
 455         int err = 0;
 456
 457         if (rpdev->ops->announce_destroy)
 458                 err = rpdev->ops->announce_destroy(rpdev);
 459
 460         rpdrv->remove(rpdev);
 461
 462         if (rpdev->ept)
 463                 rpmsg_destroy_ept(rpdev->ept);
 464
 465         return err;
 466 }
 467
 468 static struct bus_type rpmsg_bus = {
 469         .name           = "rpmsg",
 470         .match          = rpmsg_dev_match,
 471         .dev_groups     = rpmsg_dev_groups,
 472         .uevent         = rpmsg_uevent,
 473         .probe          = rpmsg_dev_probe,
 474         .remove         = rpmsg_dev_remove,
 475 };
 476
 477 int rpmsg_register_device(struct rpmsg_device *rpdev)
 478 {
 479         struct device *dev = &rpdev->dev;
 480         int ret;
 481
 482         dev_set_name(&rpdev->dev, "%s.%s.%d.%d", dev_name(dev->parent),
 483                      rpdev->id.name, rpdev->src, rpdev->dst);
 484
 485         rpdev->dev.bus = &rpmsg_bus;
 486
 487         ret = device_register(&rpdev->dev);
 488         if (ret) {
 489                 dev_err(dev, "device_register failed: %d\n", ret);
 490                 put_device(&rpdev->dev);
 491         }
 492
 493         return ret;
 494 }
 495 EXPORT_SYMBOL(rpmsg_register_device);
 496
 497 /*
 498  * find an existing channel using its name + address properties,
 499  * and destroy it
 500  */
 501 int rpmsg_unregister_device(struct device *parent,
 502                             struct rpmsg_channel_info *chinfo)
 503 {
 504         struct device *dev;
 505
 506         dev = rpmsg_find_device(parent, chinfo);
 507         if (!dev)
 508                 return -EINVAL;
 509
 510         device_unregister(dev);
 511
 512         put_device(dev);
 513
 514         return 0;
 515 }
 516 EXPORT_SYMBOL(rpmsg_unregister_device);
 517
 518 /**
 519  * __register_rpmsg_driver() - register an rpmsg driver with the rpmsg bus
 520  * @rpdrv: pointer to a struct rpmsg_driver
 521  * @owner: owning module/driver
 522  *
 523  * Returns 0 on success, and an appropriate error value on failure.
 524  */
 525 int __register_rpmsg_driver(struct rpmsg_driver *rpdrv, struct module *owner)
 526 {
 527         rpdrv->drv.bus = &rpmsg_bus;
 528         rpdrv->drv.owner = owner;
 529         return driver_register(&rpdrv->drv);
 530 }
 531 EXPORT_SYMBOL(__register_rpmsg_driver);
 532
 533 /**
 534  * unregister_rpmsg_driver() - unregister an rpmsg driver from the rpmsg bus
 535  * @rpdrv: pointer to a struct rpmsg_driver
 536  *
 537  * Returns 0 on success, and an appropriate error value on failure.
 538  */
 539 void unregister_rpmsg_driver(struct rpmsg_driver *rpdrv)
 540 {
 541         driver_unregister(&rpdrv->drv);
 542 }
 543 EXPORT_SYMBOL(unregister_rpmsg_driver);
 544
 545
 546 static int __init rpmsg_init(void)
 547 {
 548         int ret;
 549
 550         ret = bus_register(&rpmsg_bus);
 551         if (ret)
 552                 pr_err("failed to register rpmsg bus: %d\n", ret);
 553
 554         return ret;
 555 }
 556 postcore_initcall(rpmsg_init);
 557
 558 static void __exit rpmsg_fini(void)
 559 {
 560         bus_unregister(&rpmsg_bus);
 561 }
 562 module_exit(rpmsg_fini);
 563
 564 MODULE_DESCRIPTION("remote processor messaging bus");
 565 MODULE_LICENSE("GPL v2");