rpmsg: rpc: introduce a new rpmsg_rpc driver
[rpmsg/rpmsg.git] / drivers / rpmsg / rpmsg_rpc.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Remote Processor Procedure Call Driver
4  *
5  * Copyright (C) 2012-2019 Texas Instruments Incorporated - http://www.ti.com/
6  *      Erik Rainey <erik.rainey@ti.com>
7  *      Suman Anna <s-anna@ti.com>
8  */
10 #define pr_fmt(fmt) "%s: " fmt, __func__
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/slab.h>
15 #include <linux/idr.h>
16 #include <linux/poll.h>
17 #include <linux/mutex.h>
18 #include <linux/sched.h>
19 #include <linux/fdtable.h>
20 #include <linux/remoteproc.h>
21 #include <linux/rpmsg.h>
22 #include <linux/rpmsg_rpc.h>
23 #include <linux/rpmsg/virtio_rpmsg.h>
24 #include <linux/sched/signal.h>
26 #include "rpmsg_rpc_internal.h"
28 #define RPPC_MAX_DEVICES        (8)
29 #define RPPC_MAX_REG_FDS        (10)
31 #define RPPC_SIG_NUM_PARAM(sig) ((sig).num_param - 1)
33 /* TODO: remove these fields */
34 #define RPPC_JOBID_DISCRETE     (0)
35 #define RPPC_POOLID_DEFAULT     (0x8000)
37 static struct class *rppc_class;
38 static dev_t rppc_dev;
40 /* store all remote rpc connection services (usually one per remoteproc) */
41 static DEFINE_IDR(rppc_devices);
42 static DEFINE_MUTEX(rppc_devices_lock);
44 /*
45  * Retrieve the rproc instance so that it can be used for performing
46  * address translations
47  */
48 static inline struct rproc *rpdev_to_rproc(struct rpmsg_device *rpdev)
49 {
50         return rproc_get_by_child(&rpdev->dev);
51 }
53 /*
54  * A wrapper function to translate local physical addresses to the remote core
55  * device addresses (virtual addresses that a code on remote processor can use
56  * directly.
57  *
58  * XXX: Fix this to return negative values on errors to follow normal kernel
59  *      conventions, and since 0 can also be a valid remote processor address
60  *
61  * Returns a remote processor device address on success, 0 otherwise
62  */
63 dev_addr_t rppc_local_to_remote_da(struct rppc_instance *rpc, phys_addr_t pa)
64 {
65         int ret;
66         struct rproc *rproc;
67         u64 da = 0;
68         dev_addr_t rda;
69         struct device *dev = rpc->rppcdev->dev;
71         if (mutex_lock_interruptible(&rpc->rppcdev->lock))
72                 return 0;
74         rproc = rpdev_to_rproc(rpc->rppcdev->rpdev);
75         if (!rproc) {
76                 dev_err(dev, "error getting rproc for rpdev 0x%x\n",
77                         (u32)rpc->rppcdev->rpdev);
78         } else {
79                 ret = rproc_pa_to_da(rproc, pa, &da);
80                 if (ret) {
81                         dev_err(dev, "error from rproc_pa_to_da, rproc = %p, pa = %pa ret = %d\n",
82                                 rproc, &pa, ret);
83                 }
84         }
85         rda = (dev_addr_t)da;
87         mutex_unlock(&rpc->rppcdev->lock);
89         return rda;
90 }
92 static void rppc_print_msg(struct rppc_instance *rpc, char *prefix,
93                            char buffer[512])
94 {
95         struct rppc_msg_header *hdr = (struct rppc_msg_header *)buffer;
96         struct rppc_instance_handle *hdl = NULL;
97         struct rppc_query_function *info = NULL;
98         struct rppc_packet *packet = NULL;
99         struct rppc_param_data *param = NULL;
100         struct device *dev = rpc->rppcdev->dev;
101         u32 i = 0, paramsz = sizeof(*param);
103         dev_dbg(dev, "%s HDR: msg_type = %d msg_len = %d\n",
104                 prefix, hdr->msg_type, hdr->msg_len);
106         switch (hdr->msg_type) {
107         case RPPC_MSGTYPE_CREATE_RESP:
108         case RPPC_MSGTYPE_DELETE_RESP:
109                 hdl = RPPC_PAYLOAD(buffer, rppc_instance_handle);
110                 dev_dbg(dev, "%s endpoint = %d status = %d\n",
111                         prefix, hdl->endpoint_address, hdl->status);
112                 break;
113         case RPPC_MSGTYPE_FUNCTION_INFO:
114                 info = RPPC_PAYLOAD(buffer, rppc_query_function);
115                 dev_dbg(dev, "%s (info not yet implemented)\n", prefix);
116                 break;
117         case RPPC_MSGTYPE_FUNCTION_CALL:
118                 packet = RPPC_PAYLOAD(buffer, rppc_packet);
119                 dev_dbg(dev, "%s PACKET: desc = %04x msg_id = %04x flags = %08x func = 0x%08x result = %d size = %u\n",
120                         prefix, packet->desc, packet->msg_id,
121                         packet->flags, packet->fxn_id,
122                         packet->result, packet->data_size);
123                 param = (struct rppc_param_data *)packet->data;
124                 for (i = 0; i < (packet->data_size / paramsz); i++) {
125                         dev_dbg(dev, "%s param[%u] size = %zu data = %zu (0x%08x)",
126                                 prefix, i, param[i].size, param[i].data,
127                                 param[i].data);
128                 }
129                 break;
130         default:
131                 break;
132         }
135 /* free any outstanding function calls */
136 static void rppc_delete_fxns(struct rppc_instance *rpc)
138         struct rppc_function_list *pos, *n;
140         if (!list_empty(&rpc->fxn_list)) {
141                 mutex_lock(&rpc->lock);
142                 list_for_each_entry_safe(pos, n, &rpc->fxn_list, list) {
143                         list_del(&pos->list);
144                         kfree(pos->function);
145                         kfree(pos);
146                 }
147                 mutex_unlock(&rpc->lock);
148         }
151 static
152 struct rppc_function *rppc_find_fxn(struct rppc_instance *rpc, u16 msg_id)
154         struct rppc_function *function = NULL;
155         struct rppc_function_list *pos, *n;
156         struct device *dev = rpc->rppcdev->dev;
158         mutex_lock(&rpc->lock);
159         list_for_each_entry_safe(pos, n, &rpc->fxn_list, list) {
160                 dev_dbg(dev, "looking for msg %u, found msg %u\n",
161                         msg_id, pos->msg_id);
162                 if (pos->msg_id == msg_id) {
163                         function = pos->function;
164                         list_del(&pos->list);
165                         kfree(pos);
166                         break;
167                 }
168         }
169         mutex_unlock(&rpc->lock);
171         return function;
174 static int rppc_add_fxn(struct rppc_instance *rpc,
175                         struct rppc_function *function, u16 msg_id)
177         struct rppc_function_list *fxn = NULL;
178         struct device *dev = rpc->rppcdev->dev;
180         fxn = kzalloc(sizeof(*fxn), GFP_KERNEL);
181         if (!fxn)
182                 return -ENOMEM;
184         fxn->function = function;
185         fxn->msg_id = msg_id;
186         mutex_lock(&rpc->lock);
187         list_add(&fxn->list, &rpc->fxn_list);
188         mutex_unlock(&rpc->lock);
189         dev_dbg(dev, "added msg id %u to list", msg_id);
191         return 0;
194 static
195 void rppc_handle_create_resp(struct rppc_instance *rpc, char *data, int len)
197         struct device *dev = rpc->rppcdev->dev;
198         struct rppc_msg_header *hdr = (struct rppc_msg_header *)data;
199         struct rppc_instance_handle *hdl;
200         u32 exp_len = sizeof(*hdl) + sizeof(*hdr);
202         if (len != exp_len) {
203                 dev_err(dev, "invalid response message length %d (expected %d bytes)",
204                         len, exp_len);
205                 rpc->state = RPPC_STATE_STALE;
206                 return;
207         }
209         hdl = RPPC_PAYLOAD(data, rppc_instance_handle);
211         mutex_lock(&rpc->lock);
212         if (rpc->state != RPPC_STATE_STALE && hdl->status == 0) {
213                 rpc->dst = hdl->endpoint_address;
214                 rpc->state = RPPC_STATE_CONNECTED;
215         } else {
216                 rpc->state = RPPC_STATE_STALE;
217         }
218         rpc->in_transition = 0;
219         dev_dbg(dev, "creation response: status %d addr 0x%x\n",
220                 hdl->status, hdl->endpoint_address);
222         complete(&rpc->reply_arrived);
223         mutex_unlock(&rpc->lock);
226 static
227 void rppc_handle_delete_resp(struct rppc_instance *rpc, char *data, int len)
229         struct device *dev = rpc->rppcdev->dev;
230         struct rppc_msg_header *hdr = (struct rppc_msg_header *)data;
231         struct rppc_instance_handle *hdl;
232         u32 exp_len = sizeof(*hdl) + sizeof(*hdr);
234         if (len != exp_len) {
235                 dev_err(dev, "invalid response message length %d (expected %d bytes)",
236                         len, exp_len);
237                 rpc->state = RPPC_STATE_STALE;
238                 return;
239         }
240         if (hdr->msg_len != sizeof(*hdl)) {
241                 dev_err(dev, "disconnect message was incorrect size!\n");
242                 rpc->state = RPPC_STATE_STALE;
243                 return;
244         }
246         hdl = RPPC_PAYLOAD(data, rppc_instance_handle);
247         dev_dbg(dev, "deletion response: status %d addr 0x%x\n",
248                 hdl->status, hdl->endpoint_address);
249         mutex_lock(&rpc->lock);
250         rpc->dst = 0;
251         rpc->state = RPPC_STATE_DISCONNECTED;
252         rpc->in_transition = 0;
253         complete(&rpc->reply_arrived);
254         mutex_unlock(&rpc->lock);
257 /*
258  * store the received message and wake up any blocking processes,
259  * waiting for new data. The allocated buffer would be freed after
260  * the user-space reads the packet.
261  */
262 static void rppc_handle_fxn_resp(struct rppc_instance *rpc, char *data, int len)
264         struct rppc_msg_header *hdr = (struct rppc_msg_header *)data;
265         struct sk_buff *skb;
266         char *skbdata;
268         /* TODO: need to check the response length? */
269         skb = alloc_skb(hdr->msg_len, GFP_KERNEL);
270         if (!skb)
271                 return;
272         skbdata = skb_put(skb, hdr->msg_len);
273         memcpy(skbdata, hdr->msg_data, hdr->msg_len);
275         mutex_lock(&rpc->lock);
276         skb_queue_tail(&rpc->queue, skb);
277         mutex_unlock(&rpc->lock);
279         wake_up_interruptible(&rpc->readq);
282 /*
283  * callback function for processing the different responses
284  * from the remote processor on a particular rpmsg channel
285  * instance.
286  */
287 static int rppc_cb(struct rpmsg_device *rpdev,
288                    void *data, int len, void *priv, u32 src)
290         struct rppc_msg_header *hdr = data;
291         struct rppc_instance *rpc = priv;
292         struct device *dev = rpc->rppcdev->dev;
293         char *buf = (char *)data;
295         dev_dbg(dev, "<== incoming msg src %d len %d msg_type %d msg_len %d\n",
296                 src, len, hdr->msg_type, hdr->msg_len);
297         rppc_print_msg(rpc, "RX:", buf);
299         if (len <= sizeof(*hdr)) {
300                 dev_err(dev, "message truncated\n");
301                 rpc->state = RPPC_STATE_STALE;
302                 return -EINVAL;
303         }
305         switch (hdr->msg_type) {
306         case RPPC_MSGTYPE_CREATE_RESP:
307                 rppc_handle_create_resp(rpc, data, len);
308                 break;
309         case RPPC_MSGTYPE_DELETE_RESP:
310                 rppc_handle_delete_resp(rpc, data, len);
311                 break;
312         case RPPC_MSGTYPE_FUNCTION_CALL:
313         case RPPC_MSGTYPE_FUNCTION_RET:
314                 rppc_handle_fxn_resp(rpc, data, len);
315                 break;
316         default:
317                 dev_warn(dev, "unexpected msg type: %d\n", hdr->msg_type);
318                 break;
319         }
321         return 0;
324 /*
325  * send a connection request to the remote rpc connection service. Use
326  * the new local address created during .open for this instance as the
327  * source address to complete the connection.
328  */
329 static int rppc_connect(struct rppc_instance *rpc,
330                         struct rppc_create_instance *connect)
332         int ret = 0;
333         u32 len = 0;
334         char kbuf[512];
335         struct rppc_device *rppcdev = rpc->rppcdev;
336         struct rppc_msg_header *hdr = (struct rppc_msg_header *)&kbuf[0];
338         if (rpc->state == RPPC_STATE_CONNECTED) {
339                 dev_dbg(rppcdev->dev, "endpoint already connected\n");
340                 return -EISCONN;
341         }
343         hdr->msg_type = RPPC_MSGTYPE_CREATE_REQ;
344         hdr->msg_len = sizeof(*connect);
345         memcpy(hdr->msg_data, connect, hdr->msg_len);
346         len = sizeof(struct rppc_msg_header) + hdr->msg_len;
348         init_completion(&rpc->reply_arrived);
349         rpc->in_transition = 1;
350         ret = rpmsg_send_offchannel(rppcdev->rpdev->ept, rpc->ept->addr,
351                                     rppcdev->rpdev->dst, (char *)kbuf, len);
352         if (ret > 0) {
353                 dev_err(rppcdev->dev, "rpmsg_send failed: %d\n", ret);
354                 return ret;
355         }
357         ret = wait_for_completion_interruptible_timeout(&rpc->reply_arrived,
358                                                         msecs_to_jiffies(5000));
359         if (rpc->state == RPPC_STATE_CONNECTED)
360                 return 0;
362         if (rpc->state == RPPC_STATE_STALE)
363                 return -ENXIO;
365         if (ret > 0) {
366                 dev_err(rppcdev->dev, "premature wakeup: %d\n", ret);
367                 return -EIO;
368         }
370         return -ETIMEDOUT;
373 static void rppc_disconnect(struct rppc_instance *rpc)
375         int ret;
376         size_t len;
377         char kbuf[512];
378         struct rppc_device *rppcdev = rpc->rppcdev;
379         struct rppc_msg_header *hdr = (struct rppc_msg_header *)&kbuf[0];
380         struct rppc_instance_handle *handle =
381                                 RPPC_PAYLOAD(kbuf, rppc_instance_handle);
383         if (rpc->state != RPPC_STATE_CONNECTED)
384                 return;
386         hdr->msg_type = RPPC_MSGTYPE_DELETE_REQ;
387         hdr->msg_len = sizeof(u32);
388         handle->endpoint_address = rpc->dst;
389         handle->status = 0;
390         len = sizeof(struct rppc_msg_header) + hdr->msg_len;
392         dev_dbg(rppcdev->dev, "disconnecting from RPC service at %d\n",
393                 rpc->dst);
394         ret = rpmsg_send_offchannel(rppcdev->rpdev->ept, rpc->ept->addr,
395                                     rppcdev->rpdev->dst, kbuf, len);
396         if (ret)
397                 dev_err(rppcdev->dev, "rpmsg_send failed: %d\n", ret);
399         /*
400          * TODO: should we wait for a message to come back?
401          * For now, no.
402          */
403         wait_for_completion_interruptible(&rpc->reply_arrived);
406 static int rppc_register_buffers(struct rppc_instance *rpc,
407                                  unsigned long arg)
409         struct rppc_buf_fds data;
410         int *fds = NULL;
411         struct rppc_dma_buf **bufs = NULL;
412         struct rppc_dma_buf *tmp;
413         int i = 0, ret = 0;
415         if (copy_from_user(&data, (char __user *)arg, sizeof(data)))
416                 return -EFAULT;
418         /* impose a maximum number of buffers for now */
419         if (data.num > RPPC_MAX_REG_FDS)
420                 return -EINVAL;
422         fds = kcalloc(data.num, sizeof(*fds), GFP_KERNEL);
423         if (!fds)
424                 return -ENOMEM;
426         if (copy_from_user(fds, (char __user *)data.fds,
427                            sizeof(*fds) * data.num)) {
428                 ret = -EFAULT;
429                 goto free_fds;
430         }
432         for (i = 0; i < data.num; i++) {
433                 rcu_read_lock();
434                 if (!fcheck(fds[i])) {
435                         rcu_read_unlock();
436                         ret = -EBADF;
437                         goto free_fds;
438                 }
439                 rcu_read_unlock();
441                 tmp = rppc_find_dmabuf(rpc, fds[i]);
442                 if (!IS_ERR_OR_NULL(tmp)) {
443                         ret = -EEXIST;
444                         goto free_fds;
445                 }
446         }
448         bufs = kcalloc(data.num, sizeof(*bufs), GFP_KERNEL);
449         if (!bufs) {
450                 ret = -ENOMEM;
451                 goto free_fds;
452         }
454         for (i = 0; i < data.num; i++) {
455                 bufs[i] = rppc_alloc_dmabuf(rpc, fds[i], false);
456                 if (IS_ERR(bufs[i])) {
457                         ret = PTR_ERR(bufs[i]);
458                         break;
459                 }
460         }
461         if (i == data.num)
462                 goto free_bufs;
464         for (i -= 1; i >= 0; i--)
465                 rppc_free_dmabuf(bufs[i]->id, bufs[i], rpc);
467 free_bufs:
468         kfree(bufs);
469 free_fds:
470         kfree(fds);
471         return ret;
474 static int rppc_unregister_buffers(struct rppc_instance *rpc,
475                                    unsigned long arg)
477         struct rppc_buf_fds data;
478         int *fds = NULL;
479         struct rppc_dma_buf **bufs = NULL;
480         int i = 0, ret = 0;
482         if (copy_from_user(&data, (char __user *)arg, sizeof(data)))
483                 return -EFAULT;
485         /* impose a maximum number of buffers for now */
486         if (data.num > RPPC_MAX_REG_FDS)
487                 return -EINVAL;
489         fds = kcalloc(data.num, sizeof(*fds), GFP_KERNEL);
490         if (!fds)
491                 return -ENOMEM;
493         if (copy_from_user(fds, (char __user *)data.fds,
494                            sizeof(*fds) * data.num)) {
495                 ret = -EFAULT;
496                 goto free_fds;
497         }
499         bufs = kcalloc(data.num, sizeof(*bufs), GFP_KERNEL);
500         if (!bufs) {
501                 ret = -ENOMEM;
502                 goto free_fds;
503         }
505         for (i = 0; i < data.num; i++) {
506                 rcu_read_lock();
507                 if (!fcheck(fds[i])) {
508                         rcu_read_unlock();
509                         ret = -EBADF;
510                         goto free_bufs;
511                 }
512                 rcu_read_unlock();
514                 bufs[i] = rppc_find_dmabuf(rpc, fds[i]);
515                 if (IS_ERR_OR_NULL(bufs[i])) {
516                         ret = -EEXIST;
517                         goto free_bufs;
518                 }
519         }
521         for (i = 0; i < data.num; i++)
522                 rppc_free_dmabuf(bufs[i]->id, bufs[i], rpc);
524 free_bufs:
525         kfree(bufs);
526 free_fds:
527         kfree(fds);
528         return ret;
531 /*
532  * create a new rpc instance that a user-space client can use to invoke
533  * remote functions. A new local address would be created and tied with
534  * this instance for uniquely identifying the messages communicated by
535  * this instance with the remote side.
536  *
537  * The function is blocking if there is no underlying connection manager
538  * channel, unless the device is opened with non-blocking flags specifically.
539  */
540 static int rppc_open(struct inode *inode, struct file *filp)
542         struct rppc_device *rppcdev;
543         struct rppc_instance *rpc;
544         struct rpmsg_channel_info chinfo = {};
546         rppcdev = container_of(inode->i_cdev, struct rppc_device, cdev);
548         if (!rppcdev->rpdev)
549                 if ((filp->f_flags & O_NONBLOCK) ||
550                     wait_for_completion_interruptible(&rppcdev->comp))
551                         return -EBUSY;
553         rpc = kzalloc(sizeof(*rpc), GFP_KERNEL);
554         if (!rpc)
555                 return -ENOMEM;
557         mutex_init(&rpc->lock);
558         skb_queue_head_init(&rpc->queue);
559         init_waitqueue_head(&rpc->readq);
560         INIT_LIST_HEAD(&rpc->fxn_list);
561         idr_init(&rpc->dma_idr);
562         rpc->in_transition = 0;
563         rpc->msg_id = 0;
564         rpc->state = RPPC_STATE_DISCONNECTED;
565         rpc->rppcdev = rppcdev;
567         chinfo.src = RPMSG_ADDR_ANY;
568         chinfo.dst = RPMSG_ADDR_ANY;
569         rpc->ept = rpmsg_create_ept(rppcdev->rpdev, rppc_cb, rpc, chinfo);
570         if (!rpc->ept) {
571                 dev_err(rppcdev->dev, "create ept failed\n");
572                 kfree(rpc);
573                 return -ENOMEM;
574         }
575         filp->private_data = rpc;
577         mutex_lock(&rppcdev->lock);
578         list_add(&rpc->list, &rppcdev->instances);
579         mutex_unlock(&rppcdev->lock);
581         dev_dbg(rppcdev->dev, "local addr assigned: 0x%x\n", rpc->ept->addr);
583         return 0;
586 /*
587  * release and free all the resources associated with a particular rpc
588  * instance. This includes the data structures maintaining the current
589  * outstanding function invocations, and all the buffers registered for
590  * use with this instance. Send a disconnect message and cleanup the
591  * local end-point only if the instance is in a normal state, with the
592  * remote connection manager functional.
593  */
594 static int rppc_release(struct inode *inode, struct file *filp)
596         struct rppc_instance *rpc = filp->private_data;
597         struct rppc_device *rppcdev = rpc->rppcdev;
599         dev_dbg(rppcdev->dev, "releasing Instance %p, in state %d\n", rpc,
600                 rpc->state);
602         if (rpc->state != RPPC_STATE_STALE) {
603                 if (rpc->ept) {
604                         rppc_disconnect(rpc);
605                         rpmsg_destroy_ept(rpc->ept);
606                         rpc->ept = NULL;
607                 }
608         }
610         rppc_delete_fxns(rpc);
612         mutex_lock(&rpc->lock);
613         idr_for_each(&rpc->dma_idr, rppc_free_dmabuf, rpc);
614         idr_destroy(&rpc->dma_idr);
615         mutex_unlock(&rpc->lock);
617         mutex_lock(&rppcdev->lock);
618         list_del(&rpc->list);
619         mutex_unlock(&rppcdev->lock);
621         dev_dbg(rppcdev->dev, "instance %p has been deleted!\n", rpc);
622         if (list_empty(&rppcdev->instances))
623                 dev_dbg(rppcdev->dev, "all instances have been removed!\n");
625         kfree(rpc);
626         return 0;
629 static long rppc_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
631         struct rppc_instance *rpc = filp->private_data;
632         struct rppc_device *rppcdev = rpc->rppcdev;
633         struct rppc_create_instance connect;
634         int ret = 0;
636         dev_dbg(rppcdev->dev, "%s: cmd %d, arg 0x%lx\n", __func__, cmd, arg);
638         if (_IOC_TYPE(cmd) != RPPC_IOC_MAGIC)
639                 return -ENOTTY;
641         if (_IOC_NR(cmd) > RPPC_IOC_MAXNR)
642                 return -ENOTTY;
644         switch (cmd) {
645         case RPPC_IOC_CREATE:
646                 ret = copy_from_user(&connect, (char __user *)arg,
647                                      sizeof(connect));
648                 if (ret) {
649                         dev_err(rppcdev->dev, "%s: %d: copy_from_user fail: %d\n",
650                                 __func__, _IOC_NR(cmd), ret);
651                         ret = -EFAULT;
652                 } else {
653                         connect.name[sizeof(connect.name) - 1] = '\0';
654                         ret = rppc_connect(rpc, &connect);
655                 }
656                 break;
657         case RPPC_IOC_BUFREGISTER:
658                 ret = rppc_register_buffers(rpc, arg);
659                 break;
660         case RPPC_IOC_BUFUNREGISTER:
661                 ret = rppc_unregister_buffers(rpc, arg);
662                 break;
663         default:
664                 dev_err(rppcdev->dev, "unhandled ioctl cmd: %d\n", cmd);
665                 break;
666         }
668         return ret;
671 static ssize_t rppc_read(struct file *filp, char __user *buf, size_t len,
672                          loff_t *offp)
674         struct rppc_instance *rpc = filp->private_data;
675         struct rppc_packet *packet = NULL;
676         struct rppc_param_data *parameters = NULL;
677         struct rppc_function *function = NULL;
678         struct rppc_function_return returned;
679         struct sk_buff *skb = NULL;
680         int ret = 0;
681         int use = sizeof(returned);
682         DEFINE_WAIT(wait);
684         if (mutex_lock_interruptible(&rpc->lock))
685                 return -ERESTARTSYS;
687         /* instance is invalid */
688         if (rpc->state == RPPC_STATE_STALE) {
689                 mutex_unlock(&rpc->lock);
690                 return -ENXIO;
691         }
693         /* not yet connected to the remote side */
694         if (rpc->state == RPPC_STATE_DISCONNECTED) {
695                 mutex_unlock(&rpc->lock);
696                 return -ENOTCONN;
697         }
699         if (len > use) {
700                 mutex_unlock(&rpc->lock);
701                 return -EOVERFLOW;
702         }
703         if (len < use) {
704                 mutex_unlock(&rpc->lock);
705                 return -EINVAL;
706         }
708         /* TODO: Use the much simpler wait_event_interruptible API */
709         while (skb_queue_empty(&rpc->queue)) {
710                 mutex_unlock(&rpc->lock);
711                 /* non-blocking requested ? return now */
712                 if (filp->f_flags & O_NONBLOCK)
713                         return -EAGAIN;
715                 prepare_to_wait_exclusive(&rpc->readq, &wait,
716                                           TASK_INTERRUPTIBLE);
717                 if (skb_queue_empty(&rpc->queue) &&
718                     rpc->state != RPPC_STATE_STALE)
719                         schedule();
720                 finish_wait(&rpc->readq, &wait);
721                 if (signal_pending(current))
722                         return -ERESTARTSYS;
724                 ret = mutex_lock_interruptible(&rpc->lock);
725                 if (ret < 0)
726                         return -ERESTARTSYS;
728                 if (rpc->state == RPPC_STATE_STALE) {
729                         mutex_unlock(&rpc->lock);
730                         return -ENXIO;
731                 }
733                 /* make sure state is sane while we waited */
734                 if (rpc->state != RPPC_STATE_CONNECTED) {
735                         mutex_unlock(&rpc->lock);
736                         ret = -EIO;
737                         goto out;
738                 }
739         }
741         skb = skb_dequeue(&rpc->queue);
742         if (WARN_ON(!skb)) {
743                 mutex_unlock(&rpc->lock);
744                 ret = -EIO;
745                 goto out;
746         }
748         mutex_unlock(&rpc->lock);
750         packet = (struct rppc_packet *)skb->data;
751         parameters = (struct rppc_param_data *)packet->data;
753         /*
754          * pull the function memory from the list and untranslate
755          * the remote device address pointers in the packet back
756          * to MPU pointers.
757          */
758         function = rppc_find_fxn(rpc, packet->msg_id);
759         if (function && function->num_translations > 0) {
760                 ret = rppc_xlate_buffers(rpc, function, RPPC_RPA_TO_UVA);
761                 if (ret < 0) {
762                         dev_err(rpc->rppcdev->dev, "failed to translate back pointers from remote core!\n");
763                         goto failure;
764                 }
765         }
766         returned.fxn_id = RPPC_FXN_MASK(packet->fxn_id);
767         returned.status = packet->result;
769         if (copy_to_user(buf, &returned, use)) {
770                 dev_err(rpc->rppcdev->dev, "%s: copy_to_user fail\n", __func__);
771                 ret = -EFAULT;
772         } else {
773                 ret = use;
774         }
776 failure:
777         kfree(function);
778         kfree_skb(skb);
779 out:
780         return ret;
783 static ssize_t rppc_write(struct file *filp, const char __user *ubuf,
784                           size_t len, loff_t *offp)
786         struct rppc_instance *rpc = filp->private_data;
787         struct rppc_device *rppcdev = rpc->rppcdev;
788         struct device *dev = rppcdev->dev;
789         struct rppc_msg_header *hdr = NULL;
790         struct rppc_function *function = NULL;
791         struct rppc_packet *packet = NULL;
792         struct rppc_param_data *parameters = NULL;
793         char kbuf[512];
794         int use = 0, ret = 0, param = 0;
795         u32 sig_idx = 0;
796         u32 sig_prm = 0;
797         static u32 rppc_atomic_size[RPPC_PARAM_ATOMIC_MAX] = {
798                 0, /* RPPC_PARAM_VOID */
799                 1, /* RPPC_PARAM_S08 */
800                 1, /* RPPC_PARAM_U08 */
801                 2, /* RPPC_PARAM_S16 */
802                 2, /* RPPC_PARAM_U16 */
803                 4, /* RPPC_PARAM_S32 */
804                 4, /* RPPC_PARAM_U32 */
805                 8, /* RPPC_PARAM_S64 */
806                 8  /* RPPC_PARAM_U64 */
807         };
809         if (len < sizeof(*function)) {
810                 ret = -ENOTSUPP;
811                 goto failure;
812         }
814         if (len > (sizeof(*function) + RPPC_MAX_TRANSLATIONS *
815                                 sizeof(struct rppc_param_translation))) {
816                 ret = -ENOTSUPP;
817                 goto failure;
818         }
820         if (rpc->state != RPPC_STATE_CONNECTED) {
821                 ret = -ENOTCONN;
822                 goto failure;
823         }
825         function = kzalloc(len, GFP_KERNEL);
826         if (!function) {
827                 ret = -ENOMEM;
828                 goto failure;
829         }
831         if (copy_from_user(function, ubuf, len)) {
832                 ret = -EMSGSIZE;
833                 goto failure;
834         }
836         /* increment the message id and wrap if needed */
837         rpc->msg_id = (rpc->msg_id + 1) & 0xFFFF;
839         memset(kbuf, 0, sizeof(kbuf));
840         sig_idx = function->fxn_id + 1;
841         hdr = (struct rppc_msg_header *)kbuf;
842         hdr->msg_type = RPPC_MSGTYPE_FUNCTION_CALL;
843         hdr->msg_len = sizeof(*packet);
844         packet = RPPC_PAYLOAD(kbuf, rppc_packet);
845         packet->desc = RPPC_DESC_EXEC_SYNC;
846         packet->msg_id = rpc->msg_id;
847         packet->flags = (RPPC_JOBID_DISCRETE << 16) | RPPC_POOLID_DEFAULT;
848         packet->fxn_id = RPPC_SET_FXN_IDX(function->fxn_id);
849         packet->result = 0;
850         packet->data_size = sizeof(*parameters) * function->num_params;
852         /* check the signatures against what were published */
853         if (RPPC_SIG_NUM_PARAM(rppcdev->signatures[sig_idx]) !=
854                 function->num_params) {
855                 dev_err(dev, "number of parameters mismatch! params = %u expected = %u\n",
856                         function->num_params,
857                         RPPC_SIG_NUM_PARAM(rppcdev->signatures[sig_idx]));
858                 ret = -EINVAL;
859                 goto failure;
860         }
862         /*
863          * compute the parameter pointer changes last since this will cause the
864          * cache operations
865          */
866         parameters = (struct rppc_param_data *)packet->data;
867         for (param = 0; param < function->num_params; param++) {
868                 u32 param_type;
870                 sig_prm = param + 1;
871                 param_type = rppcdev->signatures[sig_idx].params[sig_prm].type;
872                 /*
873                  * check to make sure the parameter description matches the
874                  * signature published from the other side.
875                  */
876                 if (function->params[param].type == RPPC_PARAM_TYPE_PTR &&
877                     !RPPC_IS_PTR(param_type)) {
878                         dev_err(dev, "parameter %u Pointer Type Mismatch sig type:%x func %u\n",
879                                 param, param_type, sig_idx);
880                         ret = -EINVAL;
881                         goto failure;
882                 } else if (param > 0 && function->params[param].type ==
883                         RPPC_PARAM_TYPE_ATOMIC) {
884                         if (!RPPC_IS_ATOMIC(param_type)) {
885                                 dev_err(dev, "parameter Atomic Type Mismatch\n");
886                                 ret = -EINVAL;
887                                 goto failure;
888                         } else {
889                                 if (rppc_atomic_size[param_type] !=
890                                         function->params[param].size) {
891                                         dev_err(dev, "size mismatch! u:%u sig:%u\n",
892                                                 function->params[param].size,
893                                                 rppc_atomic_size[param_type]);
894                                         ret = -EINVAL;
895                                         goto failure;
896                                 }
897                         }
898                 }
900                 parameters[param].size = function->params[param].size;
902                 /* check the type and lookup if it's a pointer */
903                 if (function->params[param].type == RPPC_PARAM_TYPE_PTR) {
904                         /*
905                          * internally the buffer translations takes care of the
906                          * offsets.
907                          */
908                         int fd = function->params[param].fd;
910                         parameters[param].data = (size_t)rppc_buffer_lookup(rpc,
911                                 (virt_addr_t)function->params[param].data,
912                                 (virt_addr_t)function->params[param].base, fd);
913                 } else if (function->params[param].type ==
914                            RPPC_PARAM_TYPE_ATOMIC) {
915                         parameters[param].data = function->params[param].data;
916                 } else {
917                         ret = -ENOTSUPP;
918                         goto failure;
919                 }
920         }
922         /* compute the size of the rpmsg packet */
923         use = sizeof(*hdr) + hdr->msg_len + packet->data_size;
925         /* failed to provide the translation data */
926         if (function->num_translations > 0 &&
927             len < (sizeof(*function) + (function->num_translations *
928                                 sizeof(struct rppc_param_translation)))) {
929                 ret = -EINVAL;
930                 goto failure;
931         }
933         /*
934          * if there are pointers to translate for the user, do so now.
935          * alter our copy of function and the user's parameters so that
936          * the proper pointers can be sent to remote cores
937          */
938         if (function->num_translations > 0) {
939                 ret = rppc_xlate_buffers(rpc, function, RPPC_UVA_TO_RPA);
940                 if (ret < 0) {
941                         dev_err(dev, "failed to translate all pointers for remote core!\n");
942                         goto failure;
943                 }
944         }
946         ret = rppc_add_fxn(rpc, function, rpc->msg_id);
947         if (ret < 0) {
948                 rppc_xlate_buffers(rpc, function, RPPC_RPA_TO_UVA);
949                 goto failure;
950         }
952         rppc_print_msg(rpc, "TX:", kbuf);
954         ret = rpmsg_send_offchannel(rppcdev->rpdev->ept, rpc->ept->addr,
955                                     rpc->dst, kbuf, use);
956         if (ret) {
957                 dev_err(dev, "rpmsg_send failed: %d\n", ret);
958                 rppc_find_fxn(rpc, rpc->msg_id);
959                 rppc_xlate_buffers(rpc, function, RPPC_RPA_TO_UVA);
960                 goto failure;
961         }
962         dev_dbg(dev, "==> sent msg to remote endpoint %u\n", rpc->dst);
964 failure:
965         if (ret >= 0)
966                 ret = len;
967         else
968                 kfree(function);
970         return ret;
973 static __poll_t rppc_poll(struct file *filp, struct poll_table_struct *wait)
975         struct rppc_instance *rpc = filp->private_data;
976         __poll_t mask = 0;
978         poll_wait(filp, &rpc->readq, wait);
979         if (rpc->state == RPPC_STATE_STALE) {
980                 mask = EPOLLERR;
981                 goto out;
982         }
984         /* if the queue is not empty set the poll bit correctly */
985         if (!skb_queue_empty(&rpc->queue))
986                 mask |= (EPOLLIN | EPOLLRDNORM);
988         /* TODO: writes are deemed to be successful always, fix this later */
989         if (true)
990                 mask |= EPOLLOUT | EPOLLWRNORM;
992 out:
993         return mask;
996 static const struct file_operations rppc_fops = {
997         .owner = THIS_MODULE,
998         .open = rppc_open,
999         .release = rppc_release,
1000         .unlocked_ioctl = rppc_ioctl,
1001         .read = rppc_read,
1002         .write = rppc_write,
1003         .poll = rppc_poll,
1004 };
1006 /*
1007  * send a function query message, the sysfs entry will be created
1008  * during the processing of the response message
1009  */
1010 static int rppc_query_function(struct rpmsg_device *rpdev)
1012         int ret = 0;
1013         u32 len = 0;
1014         char kbuf[512];
1015         struct rppc_device *rppcdev = dev_get_drvdata(&rpdev->dev);
1016         struct rppc_msg_header *hdr = (struct rppc_msg_header *)&kbuf[0];
1017         struct rppc_query_function *fxn_info =
1018                                 (struct rppc_query_function *)hdr->msg_data;
1020         if (rppcdev->cur_func >= rppcdev->num_funcs)
1021                 return -EINVAL;
1023         hdr->msg_type = RPPC_MSGTYPE_FUNCTION_QUERY;
1024         hdr->msg_len = sizeof(*fxn_info);
1025         len = sizeof(*hdr) + hdr->msg_len;
1026         fxn_info->info_type = RPPC_INFOTYPE_FUNC_SIGNATURE;
1027         fxn_info->fxn_id = rppcdev->cur_func++;
1029         dev_dbg(&rpdev->dev, "sending function query type %u for function %u\n",
1030                 fxn_info->info_type, fxn_info->fxn_id);
1031         ret = rpmsg_send(rpdev->ept, (char *)kbuf, len);
1032         if (ret) {
1033                 dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
1034                 return ret;
1035         }
1037         return 0;
1040 static void
1041 rppc_handle_devinfo_resp(struct rpmsg_device *rpdev, char *data, int len)
1043         struct rppc_device *rppcdev = dev_get_drvdata(&rpdev->dev);
1044         struct rppc_device_info *info;
1045         u32 exp_len = sizeof(*info) + sizeof(struct rppc_msg_header);
1047         if (len != exp_len) {
1048                 dev_err(&rpdev->dev, "invalid message length %d (expected %d bytes)",
1049                         len, exp_len);
1050                 return;
1051         }
1053         info = RPPC_PAYLOAD(data, rppc_device_info);
1054         if (info->num_funcs > RPPC_MAX_NUM_FUNCS) {
1055                 rppcdev->num_funcs = 0;
1056                 dev_err(&rpdev->dev, "number of functions (%d) exceeds the limit supported(%d)\n",
1057                         info->num_funcs, RPPC_MAX_NUM_FUNCS);
1058                 return;
1059         }
1061         rppcdev->num_funcs = info->num_funcs;
1062         rppcdev->signatures = kcalloc(rppcdev->num_funcs,
1063                                       sizeof(struct rppc_func_signature),
1064                                       GFP_KERNEL);
1065         if (!rppcdev->signatures)
1066                 return;
1068         dev_info(&rpdev->dev, "published functions = %u\n", info->num_funcs);
1070         /* send the function query for first function */
1071         if (rppc_query_function(rpdev) == -EINVAL)
1072                 dev_err(&rpdev->dev, "failed to get a reasonable number of functions!\n");
1075 static void
1076 rppc_handle_fxninfo_resp(struct rpmsg_device *rpdev, char *data, int len)
1078         struct rppc_device *rppcdev = dev_get_drvdata(&rpdev->dev);
1079         struct rppc_query_function *fxn_info;
1080         struct rppc_func_signature *signature;
1081         u32 exp_len = sizeof(*fxn_info) + sizeof(struct rppc_msg_header);
1082         int i;
1084         if (len != exp_len) {
1085                 dev_err(&rpdev->dev, "invalid message length %d (expected %d bytes)",
1086                         len, exp_len);
1087                 return;
1088         }
1090         fxn_info = RPPC_PAYLOAD(data, rppc_query_function);
1091         dev_dbg(&rpdev->dev, "response for function query of type %u\n",
1092                 fxn_info->info_type);
1094         switch (fxn_info->info_type) {
1095         case RPPC_INFOTYPE_FUNC_SIGNATURE:
1096                 if (fxn_info->fxn_id >= rppcdev->num_funcs) {
1097                         dev_err(&rpdev->dev, "function(%d) is out of range!\n",
1098                                 fxn_info->fxn_id);
1099                         break;
1100                 }
1102                 memcpy(&rppcdev->signatures[fxn_info->fxn_id],
1103                        &fxn_info->info.signature, sizeof(*signature));
1105                 /* TODO: delete these debug prints later */
1106                 dev_dbg(&rpdev->dev, "received info for func(%d); name = %s #params = %u\n",
1107                         fxn_info->fxn_id, fxn_info->info.signature.name,
1108                         fxn_info->info.signature.num_param);
1109                 signature = &rppcdev->signatures[fxn_info->fxn_id];
1110                 for (i = 0; i < signature->num_param; i++) {
1111                         dev_dbg(&rpdev->dev, "param[%u] type = %x dir = %u\n",
1112                                 i, signature->params[i].type,
1113                                 signature->params[i].direction);
1114                 }
1116                 /* query again until we've hit our limit */
1117                 if (rppc_query_function(rpdev) == -EINVAL) {
1118                         dev_dbg(&rpdev->dev, "reached end of function list!\n");
1119                         rppc_create_sysfs(rppcdev);
1120                 }
1121                 break;
1122         default:
1123                 dev_err(&rpdev->dev, "unrecognized fxn query response %u\n",
1124                         fxn_info->info_type);
1125                 break;
1126         }
1129 static int rppc_driver_cb(struct rpmsg_device *rpdev, void *data, int len,
1130                           void *priv, u32 src)
1132         struct rppc_msg_header *hdr = data;
1133         char *buf = (char *)data;
1135         dev_dbg(&rpdev->dev, "<== incoming drv msg src %d len %d msg_type %d msg_len %d\n",
1136                 src, len, hdr->msg_type, hdr->msg_len);
1138         if (len <= sizeof(*hdr)) {
1139                 dev_err(&rpdev->dev, "message truncated\n");
1140                 return -EINVAL;
1141         }
1143         switch (hdr->msg_type) {
1144         case RPPC_MSGTYPE_DEVINFO_RESP:
1145                 rppc_handle_devinfo_resp(rpdev, buf, len);
1146                 break;
1147         case RPPC_MSGTYPE_FUNCTION_INFO:
1148                 rppc_handle_fxninfo_resp(rpdev, buf, len);
1149                 break;
1150         default:
1151                 dev_err(&rpdev->dev, "unrecognized message type %u\n",
1152                         hdr->msg_type);
1153                 break;
1154         }
1156         return 0;
1159 static int find_rpccdev_by_name(int id, void *p, void *data)
1161         struct rppc_device *rppcdev = p;
1163         return strcmp(dev_name(rppcdev->dev), data) ? 0 : (int)p;
1166 /*
1167  * send a device info query message, the device will be created
1168  * during the processing of the response message
1169  */
1170 static int rppc_device_create(struct rpmsg_device *rpdev)
1172         int ret;
1173         u32 len;
1174         char kbuf[512];
1175         struct rppc_msg_header *hdr = (struct rppc_msg_header *)&kbuf[0];
1177         hdr->msg_type = RPPC_MSGTYPE_DEVINFO_REQ;
1178         hdr->msg_len = 0;
1179         len = sizeof(*hdr);
1180         ret = rpmsg_send(rpdev->ept, (char *)kbuf, len);
1181         if (ret) {
1182                 dev_err(&rpdev->dev, "rpmsg_send failed: %d\n", ret);
1183                 return ret;
1184         }
1186         return 0;
1189 static int rppc_probe(struct rpmsg_device *rpdev)
1191         int ret, major, minor;
1192         struct rppc_device *rppcdev = NULL;
1193         dev_t dev;
1194         char namedesc[RPMSG_NAME_SIZE];
1196         dev_info(&rpdev->dev, "probing service %s with src %u dst %u\n",
1197                  rpdev->desc, rpdev->src, rpdev->dst);
1199         mutex_lock(&rppc_devices_lock);
1200         snprintf(namedesc, sizeof(namedesc), "%s", rpdev->desc);
1201         rppcdev = (struct rppc_device *)idr_for_each(&rppc_devices,
1202                                                 find_rpccdev_by_name, namedesc);
1203         if (rppcdev) {
1204                 rppcdev->rpdev = rpdev;
1205                 dev_set_drvdata(&rpdev->dev, rppcdev);
1206                 goto serv_up;
1207         }
1209         rppcdev = kzalloc(sizeof(*rppcdev), GFP_KERNEL);
1210         if (!rppcdev) {
1211                 ret = -ENOMEM;
1212                 goto exit;
1213         }
1215         minor = idr_alloc(&rppc_devices, rppcdev, 0, 0, GFP_KERNEL);
1216         if (minor < 0) {
1217                 ret = minor;
1218                 dev_err(&rpdev->dev, "failed to get a minor number: %d\n", ret);
1219                 goto free_rppcdev;
1220         }
1222         INIT_LIST_HEAD(&rppcdev->instances);
1223         mutex_init(&rppcdev->lock);
1224         init_completion(&rppcdev->comp);
1226         rppcdev->minor = minor;
1227         rppcdev->rpdev = rpdev;
1228         dev_set_drvdata(&rpdev->dev, rppcdev);
1230         major = MAJOR(rppc_dev);
1231         cdev_init(&rppcdev->cdev, &rppc_fops);
1232         rppcdev->cdev.owner = THIS_MODULE;
1233         dev = MKDEV(major, minor);
1234         ret = cdev_add(&rppcdev->cdev, dev, 1);
1235         if (ret) {
1236                 dev_err(&rpdev->dev, "cdev_add failed: %d\n", ret);
1237                 goto free_id;
1238         }
1240         rppcdev->dev = device_create(rppc_class, &rpdev->dev, dev, NULL,
1241                                      namedesc);
1242         if (IS_ERR(rppcdev->dev)) {
1243                 int ret = PTR_ERR(rppcdev->dev);
1245                 dev_err(&rpdev->dev, "device_create failed: %d\n", ret);
1246                 goto free_cdev;
1247         }
1248         dev_set_drvdata(rppcdev->dev, rppcdev);
1250 serv_up:
1251         ret = rppc_device_create(rpdev);
1252         if (ret) {
1253                 dev_err(&rpdev->dev, "failed to query channel info: %d\n", ret);
1254                 dev = MKDEV(MAJOR(rppc_dev), rppcdev->minor);
1255                 goto free_dev;
1256         }
1258         complete_all(&rppcdev->comp);
1260         dev_dbg(&rpdev->dev, "new RPPC connection srv channel: %u -> %u!\n",
1261                 rpdev->src, rpdev->dst);
1263         mutex_unlock(&rppc_devices_lock);
1264         return 0;
1266 free_dev:
1267         device_destroy(rppc_class, dev);
1268 free_cdev:
1269         cdev_del(&rppcdev->cdev);
1270 free_id:
1271         idr_remove(&rppc_devices, rppcdev->minor);
1272 free_rppcdev:
1273         kfree(rppcdev);
1274 exit:
1275         mutex_unlock(&rppc_devices_lock);
1276         return ret;
1279 static void rppc_remove(struct rpmsg_device *rpdev)
1281         struct rppc_device *rppcdev = dev_get_drvdata(&rpdev->dev);
1282         struct rppc_instance *rpc = NULL;
1283         int major = MAJOR(rppc_dev);
1285         dev_dbg(&rpdev->dev, "removing rpmsg-rpc device %u.%u\n",
1286                 major, rppcdev->minor);
1288         mutex_lock(&rppc_devices_lock);
1290         rppc_remove_sysfs(rppcdev);
1291         rppcdev->cur_func = 0;
1292         kfree(rppcdev->signatures);
1294         /* if there are no instances in the list, just teardown */
1295         if (list_empty(&rppcdev->instances)) {
1296                 dev_dbg(&rpdev->dev, "no instances, removing device!\n");
1297                 device_destroy(rppc_class, MKDEV(major, rppcdev->minor));
1298                 cdev_del(&rppcdev->cdev);
1299                 idr_remove(&rppc_devices, rppcdev->minor);
1300                 kfree(rppcdev);
1301                 mutex_unlock(&rppc_devices_lock);
1302                 return;
1303         }
1305         /*
1306          * if there are rpc instances that means that this is a recovery
1307          * operation. Don't clean the rppcdev, and retain it for reuse.
1308          * mark each instance as invalid, and complete any on-going transactions
1309          */
1310         init_completion(&rppcdev->comp);
1311         mutex_lock(&rppcdev->lock);
1312         list_for_each_entry(rpc, &rppcdev->instances, list) {
1313                 dev_dbg(&rpdev->dev, "instance %p in state %d\n",
1314                         rpc, rpc->state);
1315                 if (rpc->state == RPPC_STATE_CONNECTED && rpc->in_transition)
1316                         complete_all(&rpc->reply_arrived);
1317                 rpc->state = RPPC_STATE_STALE;
1318                 wake_up_interruptible(&rpc->readq);
1319         }
1320         rppcdev->rpdev = NULL;
1321         mutex_unlock(&rppcdev->lock);
1322         mutex_unlock(&rppc_devices_lock);
1323         dev_dbg(&rpdev->dev, "removed rpmsg rpmsg-rpc service %s\n",
1324                 rpdev->desc);
1327 static struct rpmsg_device_id rppc_id_table[] = {
1328         {.name = "rpmsg-rpc"},
1329         {},
1330 };
1332 static struct rpmsg_driver rppc_driver = {
1333         .drv.name = KBUILD_MODNAME,
1334         .id_table = rppc_id_table,
1335         .probe = rppc_probe,
1336         .remove = rppc_remove,
1337         .callback = rppc_driver_cb,
1338 };
1340 static int __init rppc_init(void)
1342         int ret;
1344         ret = alloc_chrdev_region(&rppc_dev, 0, RPPC_MAX_DEVICES,
1345                                   KBUILD_MODNAME);
1346         if (ret) {
1347                 pr_err("alloc_chrdev_region failed: %d\n", ret);
1348                 goto out;
1349         }
1351         rppc_class = class_create(THIS_MODULE, KBUILD_MODNAME);
1352         if (IS_ERR(rppc_class)) {
1353                 ret = PTR_ERR(rppc_class);
1354                 pr_err("class_create failed: %d\n", ret);
1355                 goto unreg_region;
1356         }
1358         ret = register_rpmsg_driver(&rppc_driver);
1359         if (ret) {
1360                 pr_err("register_rpmsg_driver failed: %d\n", ret);
1361                 goto destroy_class;
1362         }
1363         return 0;
1365 destroy_class:
1366         class_destroy(rppc_class);
1367 unreg_region:
1368         unregister_chrdev_region(rppc_dev, RPPC_MAX_DEVICES);
1369 out:
1370         return ret;
1373 static void __exit rppc_exit(void)
1375         unregister_rpmsg_driver(&rppc_driver);
1376         class_destroy(rppc_class);
1377         unregister_chrdev_region(rppc_dev, RPPC_MAX_DEVICES);
1380 module_init(rppc_init);
1381 module_exit(rppc_exit);
1382 MODULE_DEVICE_TABLE(rpmsg, rppc_id_table);
1384 MODULE_AUTHOR("Suman Anna <s-anna@ti.com>");
1385 MODULE_AUTHOR("Erik Rainey <erik.rainey@ti.com>");
1386 MODULE_DESCRIPTION("Remote Processor Procedure Call Driver");
1387 MODULE_ALIAS("rpmsg:rpmsg-rpc");
1388 MODULE_LICENSE("GPL v2");