About Kernel Documentation Linux Kernel Contact Linux Resources Linux Blog

Documentation / rpmsg.txt




Custom Search

Based on kernel version 3.15.4. Page generated on 2014-07-07 09:04 EST.

1	Remote Processor Messaging (rpmsg) Framework
2	
3	Note: this document describes the rpmsg bus and how to write rpmsg drivers.
4	To learn how to add rpmsg support for new platforms, check out remoteproc.txt
5	(also a resident of Documentation/).
6	
7	1. Introduction
8	
9	Modern SoCs typically employ heterogeneous remote processor devices in
10	asymmetric multiprocessing (AMP) configurations, which may be running
11	different instances of operating system, whether it's Linux or any other
12	flavor of real-time OS.
13	
14	OMAP4, for example, has dual Cortex-A9, dual Cortex-M3 and a C64x+ DSP.
15	Typically, the dual cortex-A9 is running Linux in a SMP configuration,
16	and each of the other three cores (two M3 cores and a DSP) is running
17	its own instance of RTOS in an AMP configuration.
18	
19	Typically AMP remote processors employ dedicated DSP codecs and multimedia
20	hardware accelerators, and therefore are often used to offload CPU-intensive
21	multimedia tasks from the main application processor.
22	
23	These remote processors could also be used to control latency-sensitive
24	sensors, drive random hardware blocks, or just perform background tasks
25	while the main CPU is idling.
26	
27	Users of those remote processors can either be userland apps (e.g. multimedia
28	frameworks talking with remote OMX components) or kernel drivers (controlling
29	hardware accessible only by the remote processor, reserving kernel-controlled
30	resources on behalf of the remote processor, etc..).
31	
32	Rpmsg is a virtio-based messaging bus that allows kernel drivers to communicate
33	with remote processors available on the system. In turn, drivers could then
34	expose appropriate user space interfaces, if needed.
35	
36	When writing a driver that exposes rpmsg communication to userland, please
37	keep in mind that remote processors might have direct access to the
38	system's physical memory and other sensitive hardware resources (e.g. on
39	OMAP4, remote cores and hardware accelerators may have direct access to the
40	physical memory, gpio banks, dma controllers, i2c bus, gptimers, mailbox
41	devices, hwspinlocks, etc..). Moreover, those remote processors might be
42	running RTOS where every task can access the entire memory/devices exposed
43	to the processor. To minimize the risks of rogue (or buggy) userland code
44	exploiting remote bugs, and by that taking over the system, it is often
45	desired to limit userland to specific rpmsg channels (see definition below)
46	it can send messages on, and if possible, minimize how much control
47	it has over the content of the messages.
48	
49	Every rpmsg device is a communication channel with a remote processor (thus
50	rpmsg devices are called channels). Channels are identified by a textual name
51	and have a local ("source") rpmsg address, and remote ("destination") rpmsg
52	address.
53	
54	When a driver starts listening on a channel, its rx callback is bound with
55	a unique rpmsg local address (a 32-bit integer). This way when inbound messages
56	arrive, the rpmsg core dispatches them to the appropriate driver according
57	to their destination address (this is done by invoking the driver's rx handler
58	with the payload of the inbound message).
59	
60	
61	2. User API
62	
63	  int rpmsg_send(struct rpmsg_channel *rpdev, void *data, int len);
64	   - sends a message across to the remote processor on a given channel.
65	     The caller should specify the channel, the data it wants to send,
66	     and its length (in bytes). The message will be sent on the specified
67	     channel, i.e. its source and destination address fields will be
68	     set to the channel's src and dst addresses.
69	
70	     In case there are no TX buffers available, the function will block until
71	     one becomes available (i.e. until the remote processor consumes
72	     a tx buffer and puts it back on virtio's used descriptor ring),
73	     or a timeout of 15 seconds elapses. When the latter happens,
74	     -ERESTARTSYS is returned.
75	     The function can only be called from a process context (for now).
76	     Returns 0 on success and an appropriate error value on failure.
77	
78	  int rpmsg_sendto(struct rpmsg_channel *rpdev, void *data, int len, u32 dst);
79	   - sends a message across to the remote processor on a given channel,
80	     to a destination address provided by the caller.
81	     The caller should specify the channel, the data it wants to send,
82	     its length (in bytes), and an explicit destination address.
83	     The message will then be sent to the remote processor to which the
84	     channel belongs, using the channel's src address, and the user-provided
85	     dst address (thus the channel's dst address will be ignored).
86	
87	     In case there are no TX buffers available, the function will block until
88	     one becomes available (i.e. until the remote processor consumes
89	     a tx buffer and puts it back on virtio's used descriptor ring),
90	     or a timeout of 15 seconds elapses. When the latter happens,
91	     -ERESTARTSYS is returned.
92	     The function can only be called from a process context (for now).
93	     Returns 0 on success and an appropriate error value on failure.
94	
95	  int rpmsg_send_offchannel(struct rpmsg_channel *rpdev, u32 src, u32 dst,
96								void *data, int len);
97	   - sends a message across to the remote processor, using the src and dst
98	     addresses provided by the user.
99	     The caller should specify the channel, the data it wants to send,
100	     its length (in bytes), and explicit source and destination addresses.
101	     The message will then be sent to the remote processor to which the
102	     channel belongs, but the channel's src and dst addresses will be
103	     ignored (and the user-provided addresses will be used instead).
104	
105	     In case there are no TX buffers available, the function will block until
106	     one becomes available (i.e. until the remote processor consumes
107	     a tx buffer and puts it back on virtio's used descriptor ring),
108	     or a timeout of 15 seconds elapses. When the latter happens,
109	     -ERESTARTSYS is returned.
110	     The function can only be called from a process context (for now).
111	     Returns 0 on success and an appropriate error value on failure.
112	
113	  int rpmsg_trysend(struct rpmsg_channel *rpdev, void *data, int len);
114	   - sends a message across to the remote processor on a given channel.
115	     The caller should specify the channel, the data it wants to send,
116	     and its length (in bytes). The message will be sent on the specified
117	     channel, i.e. its source and destination address fields will be
118	     set to the channel's src and dst addresses.
119	
120	     In case there are no TX buffers available, the function will immediately
121	     return -ENOMEM without waiting until one becomes available.
122	     The function can only be called from a process context (for now).
123	     Returns 0 on success and an appropriate error value on failure.
124	
125	  int rpmsg_trysendto(struct rpmsg_channel *rpdev, void *data, int len, u32 dst)
126	   - sends a message across to the remote processor on a given channel,
127	     to a destination address provided by the user.
128	     The user should specify the channel, the data it wants to send,
129	     its length (in bytes), and an explicit destination address.
130	     The message will then be sent to the remote processor to which the
131	     channel belongs, using the channel's src address, and the user-provided
132	     dst address (thus the channel's dst address will be ignored).
133	
134	     In case there are no TX buffers available, the function will immediately
135	     return -ENOMEM without waiting until one becomes available.
136	     The function can only be called from a process context (for now).
137	     Returns 0 on success and an appropriate error value on failure.
138	
139	  int rpmsg_trysend_offchannel(struct rpmsg_channel *rpdev, u32 src, u32 dst,
140								void *data, int len);
141	   - sends a message across to the remote processor, using source and
142	     destination addresses provided by the user.
143	     The user should specify the channel, the data it wants to send,
144	     its length (in bytes), and explicit source and destination addresses.
145	     The message will then be sent to the remote processor to which the
146	     channel belongs, but the channel's src and dst addresses will be
147	     ignored (and the user-provided addresses will be used instead).
148	
149	     In case there are no TX buffers available, the function will immediately
150	     return -ENOMEM without waiting until one becomes available.
151	     The function can only be called from a process context (for now).
152	     Returns 0 on success and an appropriate error value on failure.
153	
154	  struct rpmsg_endpoint *rpmsg_create_ept(struct rpmsg_channel *rpdev,
155			void (*cb)(struct rpmsg_channel *, void *, int, void *, u32),
156			void *priv, u32 addr);
157	   - every rpmsg address in the system is bound to an rx callback (so when
158	     inbound messages arrive, they are dispatched by the rpmsg bus using the
159	     appropriate callback handler) by means of an rpmsg_endpoint struct.
160	
161	     This function allows drivers to create such an endpoint, and by that,
162	     bind a callback, and possibly some private data too, to an rpmsg address
163	     (either one that is known in advance, or one that will be dynamically
164	     assigned for them).
165	
166	     Simple rpmsg drivers need not call rpmsg_create_ept, because an endpoint
167	     is already created for them when they are probed by the rpmsg bus
168	     (using the rx callback they provide when they registered to the rpmsg bus).
169	
170	     So things should just work for simple drivers: they already have an
171	     endpoint, their rx callback is bound to their rpmsg address, and when
172	     relevant inbound messages arrive (i.e. messages which their dst address
173	     equals to the src address of their rpmsg channel), the driver's handler
174	     is invoked to process it.
175	
176	     That said, more complicated drivers might do need to allocate
177	     additional rpmsg addresses, and bind them to different rx callbacks.
178	     To accomplish that, those drivers need to call this function.
179	     Drivers should provide their channel (so the new endpoint would bind
180	     to the same remote processor their channel belongs to), an rx callback
181	     function, an optional private data (which is provided back when the
182	     rx callback is invoked), and an address they want to bind with the
183	     callback. If addr is RPMSG_ADDR_ANY, then rpmsg_create_ept will
184	     dynamically assign them an available rpmsg address (drivers should have
185	     a very good reason why not to always use RPMSG_ADDR_ANY here).
186	
187	     Returns a pointer to the endpoint on success, or NULL on error.
188	
189	  void rpmsg_destroy_ept(struct rpmsg_endpoint *ept);
190	   - destroys an existing rpmsg endpoint. user should provide a pointer
191	     to an rpmsg endpoint that was previously created with rpmsg_create_ept().
192	
193	  int register_rpmsg_driver(struct rpmsg_driver *rpdrv);
194	   - registers an rpmsg driver with the rpmsg bus. user should provide
195	     a pointer to an rpmsg_driver struct, which contains the driver's
196	     ->probe() and ->remove() functions, an rx callback, and an id_table
197	     specifying the names of the channels this driver is interested to
198	     be probed with.
199	
200	  void unregister_rpmsg_driver(struct rpmsg_driver *rpdrv);
201	   - unregisters an rpmsg driver from the rpmsg bus. user should provide
202	     a pointer to a previously-registered rpmsg_driver struct.
203	     Returns 0 on success, and an appropriate error value on failure.
204	
205	
206	3. Typical usage
207	
208	The following is a simple rpmsg driver, that sends an "hello!" message
209	on probe(), and whenever it receives an incoming message, it dumps its
210	content to the console.
211	
212	#include <linux/kernel.h>
213	#include <linux/module.h>
214	#include <linux/rpmsg.h>
215	
216	static void rpmsg_sample_cb(struct rpmsg_channel *rpdev, void *data, int len,
217							void *priv, u32 src)
218	{
219		print_hex_dump(KERN_INFO, "incoming message:", DUMP_PREFIX_NONE,
220							16, 1, data, len, true);
221	}
222	
223	static int rpmsg_sample_probe(struct rpmsg_channel *rpdev)
224	{
225		int err;
226	
227		dev_info(&rpdev->dev, "chnl: 0x%x -> 0x%x\n", rpdev->src, rpdev->dst);
228	
229		/* send a message on our channel */
230		err = rpmsg_send(rpdev, "hello!", 6);
231		if (err) {
232			pr_err("rpmsg_send failed: %d\n", err);
233			return err;
234		}
235	
236		return 0;
237	}
238	
239	static void rpmsg_sample_remove(struct rpmsg_channel *rpdev)
240	{
241		dev_info(&rpdev->dev, "rpmsg sample client driver is removed\n");
242	}
243	
244	static struct rpmsg_device_id rpmsg_driver_sample_id_table[] = {
245		{ .name	= "rpmsg-client-sample" },
246		{ },
247	};
248	MODULE_DEVICE_TABLE(rpmsg, rpmsg_driver_sample_id_table);
249	
250	static struct rpmsg_driver rpmsg_sample_client = {
251		.drv.name	= KBUILD_MODNAME,
252		.drv.owner	= THIS_MODULE,
253		.id_table	= rpmsg_driver_sample_id_table,
254		.probe		= rpmsg_sample_probe,
255		.callback	= rpmsg_sample_cb,
256		.remove		= rpmsg_sample_remove,
257	};
258	
259	static int __init init(void)
260	{
261		return register_rpmsg_driver(&rpmsg_sample_client);
262	}
263	module_init(init);
264	
265	static void __exit fini(void)
266	{
267		unregister_rpmsg_driver(&rpmsg_sample_client);
268	}
269	module_exit(fini);
270	
271	Note: a similar sample which can be built and loaded can be found
272	in samples/rpmsg/.
273	
274	4. Allocations of rpmsg channels:
275	
276	At this point we only support dynamic allocations of rpmsg channels.
277	
278	This is possible only with remote processors that have the VIRTIO_RPMSG_F_NS
279	virtio device feature set. This feature bit means that the remote
280	processor supports dynamic name service announcement messages.
281	
282	When this feature is enabled, creation of rpmsg devices (i.e. channels)
283	is completely dynamic: the remote processor announces the existence of a
284	remote rpmsg service by sending a name service message (which contains
285	the name and rpmsg addr of the remote service, see struct rpmsg_ns_msg).
286	
287	This message is then handled by the rpmsg bus, which in turn dynamically
288	creates and registers an rpmsg channel (which represents the remote service).
289	If/when a relevant rpmsg driver is registered, it will be immediately probed
290	by the bus, and can then start sending messages to the remote service.
291	
292	The plan is also to add static creation of rpmsg channels via the virtio
293	config space, but it's not implemented yet.
Hide Line Numbers
About Kernel Documentation Linux Kernel Contact Linux Resources Linux Blog

Information is copyright its respective author. All material is available from the Linux Kernel Source distributed under a GPL License. This page is provided as a free service by mjmwired.net.