2 * remote processor messaging bus
4 * Copyright (C) 2011 Texas Instruments, Inc.
5 * Copyright (C) 2011 Google, Inc.
7 * Ohad Ben-Cohen <ohad@wizery.com>
8 * Brian Swetland <swetland@google.com>
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.
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.
20 #define pr_fmt(fmt) "%s: " fmt, __func__
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>
28 #include "rpmsg_internal.h"
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
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.
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
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).
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.
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.
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).
68 * Returns a pointer to the endpoint on success, or NULL on error.
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
)
75 return ERR_PTR(-EINVAL
);
77 return rpdev
->ops
->create_ept(rpdev
, cb
, priv
, chinfo
);
79 EXPORT_SYMBOL(rpmsg_create_ept
);
82 * rpmsg_destroy_ept() - destroy an existing rpmsg endpoint
83 * @ept: endpoing to destroy
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.
89 void rpmsg_destroy_ept(struct rpmsg_endpoint
*ept
)
92 ept
->ops
->destroy_ept(ept
);
94 EXPORT_SYMBOL(rpmsg_destroy_ept
);
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
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.
110 * Can only be called from process context (for now).
112 * Returns 0 on success and an appropriate error value on failure.
114 int rpmsg_send(struct rpmsg_endpoint
*ept
, void *data
, int len
)
121 return ept
->ops
->send(ept
, data
, len
);
123 EXPORT_SYMBOL(rpmsg_send
);
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
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.
139 * Can only be called from process context (for now).
141 * Returns 0 on success and an appropriate error value on failure.
143 int rpmsg_sendto(struct rpmsg_endpoint
*ept
, void *data
, int len
, u32 dst
)
147 if (!ept
->ops
->sendto
)
150 return ept
->ops
->sendto(ept
, data
, len
, dst
);
152 EXPORT_SYMBOL(rpmsg_sendto
);
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
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.
170 * Can only be called from process context (for now).
172 * Returns 0 on success and an appropriate error value on failure.
174 int rpmsg_send_offchannel(struct rpmsg_endpoint
*ept
, u32 src
, u32 dst
,
179 if (!ept
->ops
->send_offchannel
)
182 return ept
->ops
->send_offchannel(ept
, src
, dst
, data
, len
);
184 EXPORT_SYMBOL(rpmsg_send_offchannel
);
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
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.
199 * Can only be called from process context (for now).
201 * Returns 0 on success and an appropriate error value on failure.
203 int rpmsg_trysend(struct rpmsg_endpoint
*ept
, void *data
, int len
)
207 if (!ept
->ops
->trysend
)
210 return ept
->ops
->trysend(ept
, data
, len
);
212 EXPORT_SYMBOL(rpmsg_trysend
);
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
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.
227 * Can only be called from process context (for now).
229 * Returns 0 on success and an appropriate error value on failure.
231 int rpmsg_trysendto(struct rpmsg_endpoint
*ept
, void *data
, int len
, u32 dst
)
235 if (!ept
->ops
->trysendto
)
238 return ept
->ops
->trysendto(ept
, data
, len
, dst
);
240 EXPORT_SYMBOL(rpmsg_trysendto
);
243 * rpmsg_send_offchannel() - send a message using explicit src/dst addresses
244 * @ept: the rpmsg endpoint
245 * @src: source address
246 * @dst: destination address
247 * @data: payload of message
248 * @len: length of payload
250 * This function sends @data of length @len to the remote @dst address,
251 * and uses @src as the source address.
252 * The message will be sent to the remote processor which the @ept
253 * endpoint belongs to.
254 * In case there are no TX buffers available, the function will immediately
255 * return -ENOMEM without waiting until one becomes available.
257 * Can only be called from process context (for now).
259 * Returns 0 on success and an appropriate error value on failure.
261 int rpmsg_trysend_offchannel(struct rpmsg_endpoint
*ept
, u32 src
, u32 dst
,
266 if (!ept
->ops
->trysend_offchannel
)
269 return ept
->ops
->trysend_offchannel(ept
, src
, dst
, data
, len
);
271 EXPORT_SYMBOL(rpmsg_trysend_offchannel
);
274 * match an rpmsg channel with a channel info struct.
275 * this is used to make sure we're not creating rpmsg devices for channels
276 * that already exist.
278 static int rpmsg_device_match(struct device
*dev
, void *data
)
280 struct rpmsg_channel_info
*chinfo
= data
;
281 struct rpmsg_device
*rpdev
= to_rpmsg_device(dev
);
283 if (chinfo
->src
!= RPMSG_ADDR_ANY
&& chinfo
->src
!= rpdev
->src
)
286 if (chinfo
->dst
!= RPMSG_ADDR_ANY
&& chinfo
->dst
!= rpdev
->dst
)
289 if (strncmp(chinfo
->name
, rpdev
->id
.name
, RPMSG_NAME_SIZE
))
292 /* found a match ! */
296 struct device
*rpmsg_find_device(struct device
*parent
,
297 struct rpmsg_channel_info
*chinfo
)
299 return device_find_child(parent
, chinfo
, rpmsg_device_match
);
302 EXPORT_SYMBOL(rpmsg_find_device
);
304 /* sysfs show configuration fields */
305 #define rpmsg_show_attr(field, path, format_string) \
307 field##_show(struct device *dev, \
308 struct device_attribute *attr, char *buf) \
310 struct rpmsg_device *rpdev = to_rpmsg_device(dev); \
312 return sprintf(buf, format_string, rpdev->path); \
315 /* for more info, see Documentation/ABI/testing/sysfs-bus-rpmsg */
316 rpmsg_show_attr(name
, id
.name
, "%s\n");
317 rpmsg_show_attr(src
, src
, "0x%x\n");
318 rpmsg_show_attr(dst
, dst
, "0x%x\n");
319 rpmsg_show_attr(announce
, announce
? "true" : "false", "%s\n");
321 static ssize_t
modalias_show(struct device
*dev
,
322 struct device_attribute
*attr
, char *buf
)
324 struct rpmsg_device
*rpdev
= to_rpmsg_device(dev
);
326 return sprintf(buf
, RPMSG_DEVICE_MODALIAS_FMT
"\n", rpdev
->id
.name
);
329 static struct device_attribute rpmsg_dev_attrs
[] = {
338 /* rpmsg devices and drivers are matched using the service name */
339 static inline int rpmsg_id_match(const struct rpmsg_device
*rpdev
,
340 const struct rpmsg_device_id
*id
)
342 return strncmp(id
->name
, rpdev
->id
.name
, RPMSG_NAME_SIZE
) == 0;
345 /* match rpmsg channel and rpmsg driver */
346 static int rpmsg_dev_match(struct device
*dev
, struct device_driver
*drv
)
348 struct rpmsg_device
*rpdev
= to_rpmsg_device(dev
);
349 struct rpmsg_driver
*rpdrv
= to_rpmsg_driver(drv
);
350 const struct rpmsg_device_id
*ids
= rpdrv
->id_table
;
353 if (rpdev
->driver_override
)
354 return !strcmp(rpdev
->driver_override
, drv
->name
);
357 for (i
= 0; ids
[i
].name
[0]; i
++)
358 if (rpmsg_id_match(rpdev
, &ids
[i
]))
361 return of_driver_match_device(dev
, drv
);
364 static int rpmsg_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
366 struct rpmsg_device
*rpdev
= to_rpmsg_device(dev
);
368 return add_uevent_var(env
, "MODALIAS=" RPMSG_DEVICE_MODALIAS_FMT
,
373 * when an rpmsg driver is probed with a channel, we seamlessly create
374 * it an endpoint, binding its rx callback to a unique local rpmsg
377 * if we need to, we also announce about this channel to the remote
378 * processor (needed in case the driver is exposing an rpmsg service).
380 static int rpmsg_dev_probe(struct device
*dev
)
382 struct rpmsg_device
*rpdev
= to_rpmsg_device(dev
);
383 struct rpmsg_driver
*rpdrv
= to_rpmsg_driver(rpdev
->dev
.driver
);
384 struct rpmsg_channel_info chinfo
= {};
385 struct rpmsg_endpoint
*ept
= NULL
;
388 if (rpdrv
->callback
) {
389 strncpy(chinfo
.name
, rpdev
->id
.name
, RPMSG_NAME_SIZE
);
390 chinfo
.src
= rpdev
->src
;
391 chinfo
.dst
= RPMSG_ADDR_ANY
;
393 ept
= rpmsg_create_ept(rpdev
, rpdrv
->callback
, NULL
, chinfo
);
395 dev_err(dev
, "failed to create endpoint\n");
401 rpdev
->src
= ept
->addr
;
404 err
= rpdrv
->probe(rpdev
);
406 dev_err(dev
, "%s: failed: %d\n", __func__
, err
);
408 rpmsg_destroy_ept(ept
);
412 if (rpdev
->ops
->announce_create
)
413 err
= rpdev
->ops
->announce_create(rpdev
);
418 static int rpmsg_dev_remove(struct device
*dev
)
420 struct rpmsg_device
*rpdev
= to_rpmsg_device(dev
);
421 struct rpmsg_driver
*rpdrv
= to_rpmsg_driver(rpdev
->dev
.driver
);
424 if (rpdev
->ops
->announce_destroy
)
425 err
= rpdev
->ops
->announce_destroy(rpdev
);
427 rpdrv
->remove(rpdev
);
430 rpmsg_destroy_ept(rpdev
->ept
);
435 static struct bus_type rpmsg_bus
= {
437 .match
= rpmsg_dev_match
,
438 .dev_attrs
= rpmsg_dev_attrs
,
439 .uevent
= rpmsg_uevent
,
440 .probe
= rpmsg_dev_probe
,
441 .remove
= rpmsg_dev_remove
,
444 static void rpmsg_release_device(struct device
*dev
)
446 struct rpmsg_device
*rpdev
= to_rpmsg_device(dev
);
451 int rpmsg_register_device(struct rpmsg_device
*rpdev
)
453 struct device
*dev
= &rpdev
->dev
;
456 dev_set_name(&rpdev
->dev
, "%s:%s",
457 dev_name(dev
->parent
), rpdev
->id
.name
);
459 rpdev
->dev
.bus
= &rpmsg_bus
;
460 rpdev
->dev
.release
= rpmsg_release_device
;
462 ret
= device_register(&rpdev
->dev
);
464 dev_err(dev
, "device_register failed: %d\n", ret
);
465 put_device(&rpdev
->dev
);
470 EXPORT_SYMBOL(rpmsg_register_device
);
473 * find an existing channel using its name + address properties,
476 int rpmsg_unregister_device(struct device
*parent
,
477 struct rpmsg_channel_info
*chinfo
)
481 dev
= rpmsg_find_device(parent
, chinfo
);
485 device_unregister(dev
);
491 EXPORT_SYMBOL(rpmsg_unregister_device
);
494 * __register_rpmsg_driver() - register an rpmsg driver with the rpmsg bus
495 * @rpdrv: pointer to a struct rpmsg_driver
496 * @owner: owning module/driver
498 * Returns 0 on success, and an appropriate error value on failure.
500 int __register_rpmsg_driver(struct rpmsg_driver
*rpdrv
, struct module
*owner
)
502 rpdrv
->drv
.bus
= &rpmsg_bus
;
503 rpdrv
->drv
.owner
= owner
;
504 return driver_register(&rpdrv
->drv
);
506 EXPORT_SYMBOL(__register_rpmsg_driver
);
509 * unregister_rpmsg_driver() - unregister an rpmsg driver from the rpmsg bus
510 * @rpdrv: pointer to a struct rpmsg_driver
512 * Returns 0 on success, and an appropriate error value on failure.
514 void unregister_rpmsg_driver(struct rpmsg_driver
*rpdrv
)
516 driver_unregister(&rpdrv
->drv
);
518 EXPORT_SYMBOL(unregister_rpmsg_driver
);
521 static int __init
rpmsg_init(void)
525 ret
= bus_register(&rpmsg_bus
);
527 pr_err("failed to register rpmsg bus: %d\n", ret
);
531 postcore_initcall(rpmsg_init
);
533 static void __exit
rpmsg_fini(void)
535 bus_unregister(&rpmsg_bus
);
537 module_exit(rpmsg_fini
);
539 MODULE_DESCRIPTION("remote processor messaging bus");
540 MODULE_LICENSE("GPL v2");