2375 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * rio_cm - RapidIO Channelized Messaging Driver4 *5 * Copyright 2013-2016 Integrated Device Technology, Inc.6 * Copyright (c) 2015, Prodrive Technologies7 * Copyright (c) 2015, RapidIO Trade Association8 */9 10#include <linux/module.h>11#include <linux/kernel.h>12#include <linux/dma-mapping.h>13#include <linux/delay.h>14#include <linux/sched.h>15#include <linux/rio.h>16#include <linux/rio_drv.h>17#include <linux/slab.h>18#include <linux/idr.h>19#include <linux/interrupt.h>20#include <linux/cdev.h>21#include <linux/fs.h>22#include <linux/poll.h>23#include <linux/reboot.h>24#include <linux/bitops.h>25#include <linux/printk.h>26#include <linux/rio_cm_cdev.h>27 28#define DRV_NAME "rio_cm"29#define DRV_VERSION "1.0.0"30#define DRV_AUTHOR "Alexandre Bounine <alexandre.bounine@idt.com>"31#define DRV_DESC "RapidIO Channelized Messaging Driver"32#define DEV_NAME "rio_cm"33 34/* Debug output filtering masks */35enum {36 DBG_NONE = 0,37 DBG_INIT = BIT(0), /* driver init */38 DBG_EXIT = BIT(1), /* driver exit */39 DBG_MPORT = BIT(2), /* mport add/remove */40 DBG_RDEV = BIT(3), /* RapidIO device add/remove */41 DBG_CHOP = BIT(4), /* channel operations */42 DBG_WAIT = BIT(5), /* waiting for events */43 DBG_TX = BIT(6), /* message TX */44 DBG_TX_EVENT = BIT(7), /* message TX event */45 DBG_RX_DATA = BIT(8), /* inbound data messages */46 DBG_RX_CMD = BIT(9), /* inbound REQ/ACK/NACK messages */47 DBG_ALL = ~0,48};49 50#ifdef DEBUG51#define riocm_debug(level, fmt, arg...) \52 do { \53 if (DBG_##level & dbg_level) \54 pr_debug(DRV_NAME ": %s " fmt "\n", \55 __func__, ##arg); \56 } while (0)57#else58#define riocm_debug(level, fmt, arg...) \59 no_printk(KERN_DEBUG pr_fmt(DRV_NAME fmt "\n"), ##arg)60#endif61 62#define riocm_warn(fmt, arg...) \63 pr_warn(DRV_NAME ": %s WARNING " fmt "\n", __func__, ##arg)64 65#define riocm_error(fmt, arg...) \66 pr_err(DRV_NAME ": %s ERROR " fmt "\n", __func__, ##arg)67 68 69static int cmbox = 1;70module_param(cmbox, int, S_IRUGO);71MODULE_PARM_DESC(cmbox, "RapidIO Mailbox number (default 1)");72 73static int chstart = 256;74module_param(chstart, int, S_IRUGO);75MODULE_PARM_DESC(chstart,76 "Start channel number for dynamic allocation (default 256)");77 78#ifdef DEBUG79static u32 dbg_level = DBG_NONE;80module_param(dbg_level, uint, S_IWUSR | S_IRUGO);81MODULE_PARM_DESC(dbg_level, "Debugging output level (default 0 = none)");82#endif83 84MODULE_AUTHOR(DRV_AUTHOR);85MODULE_DESCRIPTION(DRV_DESC);86MODULE_LICENSE("GPL");87MODULE_VERSION(DRV_VERSION);88 89#define RIOCM_TX_RING_SIZE 12890#define RIOCM_RX_RING_SIZE 12891#define RIOCM_CONNECT_TO 3 /* connect response TO (in sec) */92 93#define RIOCM_MAX_CHNUM 0xffff /* Use full range of u16 field */94#define RIOCM_CHNUM_AUTO 095#define RIOCM_MAX_EP_COUNT 0x10000 /* Max number of endpoints */96 97enum rio_cm_state {98 RIO_CM_IDLE,99 RIO_CM_CONNECT,100 RIO_CM_CONNECTED,101 RIO_CM_DISCONNECT,102 RIO_CM_CHAN_BOUND,103 RIO_CM_LISTEN,104 RIO_CM_DESTROYING,105};106 107enum rio_cm_pkt_type {108 RIO_CM_SYS = 0xaa,109 RIO_CM_CHAN = 0x55,110};111 112enum rio_cm_chop {113 CM_CONN_REQ,114 CM_CONN_ACK,115 CM_CONN_CLOSE,116 CM_DATA_MSG,117};118 119struct rio_ch_base_bhdr {120 u32 src_id;121 u32 dst_id;122#define RIO_HDR_LETTER_MASK 0xffff0000123#define RIO_HDR_MBOX_MASK 0x0000ffff124 u8 src_mbox;125 u8 dst_mbox;126 u8 type;127} __attribute__((__packed__));128 129struct rio_ch_chan_hdr {130 struct rio_ch_base_bhdr bhdr;131 u8 ch_op;132 u16 dst_ch;133 u16 src_ch;134 u16 msg_len;135 u16 rsrvd;136} __attribute__((__packed__));137 138struct tx_req {139 struct list_head node;140 struct rio_dev *rdev;141 void *buffer;142 size_t len;143};144 145struct cm_dev {146 struct list_head list;147 struct rio_mport *mport;148 void *rx_buf[RIOCM_RX_RING_SIZE];149 int rx_slots;150 struct mutex rx_lock;151 152 void *tx_buf[RIOCM_TX_RING_SIZE];153 int tx_slot;154 int tx_cnt;155 int tx_ack_slot;156 struct list_head tx_reqs;157 spinlock_t tx_lock;158 159 struct list_head peers;160 u32 npeers;161 struct workqueue_struct *rx_wq;162 struct work_struct rx_work;163};164 165struct chan_rx_ring {166 void *buf[RIOCM_RX_RING_SIZE];167 int head;168 int tail;169 int count;170 171 /* Tracking RX buffers reported to upper level */172 void *inuse[RIOCM_RX_RING_SIZE];173 int inuse_cnt;174};175 176struct rio_channel {177 u16 id; /* local channel ID */178 struct kref ref; /* channel refcount */179 struct file *filp;180 struct cm_dev *cmdev; /* associated CM device object */181 struct rio_dev *rdev; /* remote RapidIO device */182 enum rio_cm_state state;183 int error;184 spinlock_t lock;185 void *context;186 u32 loc_destid; /* local destID */187 u32 rem_destid; /* remote destID */188 u16 rem_channel; /* remote channel ID */189 struct list_head accept_queue;190 struct list_head ch_node;191 struct completion comp;192 struct completion comp_close;193 struct chan_rx_ring rx_ring;194};195 196struct cm_peer {197 struct list_head node;198 struct rio_dev *rdev;199};200 201struct rio_cm_work {202 struct work_struct work;203 struct cm_dev *cm;204 void *data;205};206 207struct conn_req {208 struct list_head node;209 u32 destid; /* requester destID */210 u16 chan; /* requester channel ID */211 struct cm_dev *cmdev;212};213 214/*215 * A channel_dev structure represents a CM_CDEV216 * @cdev Character device217 * @dev Associated device object218 */219struct channel_dev {220 struct cdev cdev;221 struct device *dev;222};223 224static struct rio_channel *riocm_ch_alloc(u16 ch_num);225static void riocm_ch_free(struct kref *ref);226static int riocm_post_send(struct cm_dev *cm, struct rio_dev *rdev,227 void *buffer, size_t len);228static int riocm_ch_close(struct rio_channel *ch);229 230static DEFINE_SPINLOCK(idr_lock);231static DEFINE_IDR(ch_idr);232 233static LIST_HEAD(cm_dev_list);234static DECLARE_RWSEM(rdev_sem);235 236static const struct class dev_class = {237 .name = DRV_NAME,238};239static unsigned int dev_major;240static unsigned int dev_minor_base;241static dev_t dev_number;242static struct channel_dev riocm_cdev;243 244#define is_msg_capable(src_ops, dst_ops) \245 ((src_ops & RIO_SRC_OPS_DATA_MSG) && \246 (dst_ops & RIO_DST_OPS_DATA_MSG))247#define dev_cm_capable(dev) \248 is_msg_capable(dev->src_ops, dev->dst_ops)249 250static int riocm_cmp(struct rio_channel *ch, enum rio_cm_state cmp)251{252 int ret;253 254 spin_lock_bh(&ch->lock);255 ret = (ch->state == cmp);256 spin_unlock_bh(&ch->lock);257 return ret;258}259 260static int riocm_cmp_exch(struct rio_channel *ch,261 enum rio_cm_state cmp, enum rio_cm_state exch)262{263 int ret;264 265 spin_lock_bh(&ch->lock);266 ret = (ch->state == cmp);267 if (ret)268 ch->state = exch;269 spin_unlock_bh(&ch->lock);270 return ret;271}272 273static enum rio_cm_state riocm_exch(struct rio_channel *ch,274 enum rio_cm_state exch)275{276 enum rio_cm_state old;277 278 spin_lock_bh(&ch->lock);279 old = ch->state;280 ch->state = exch;281 spin_unlock_bh(&ch->lock);282 return old;283}284 285static struct rio_channel *riocm_get_channel(u16 nr)286{287 struct rio_channel *ch;288 289 spin_lock_bh(&idr_lock);290 ch = idr_find(&ch_idr, nr);291 if (ch)292 kref_get(&ch->ref);293 spin_unlock_bh(&idr_lock);294 return ch;295}296 297static void riocm_put_channel(struct rio_channel *ch)298{299 kref_put(&ch->ref, riocm_ch_free);300}301 302static void *riocm_rx_get_msg(struct cm_dev *cm)303{304 void *msg;305 int i;306 307 msg = rio_get_inb_message(cm->mport, cmbox);308 if (msg) {309 for (i = 0; i < RIOCM_RX_RING_SIZE; i++) {310 if (cm->rx_buf[i] == msg) {311 cm->rx_buf[i] = NULL;312 cm->rx_slots++;313 break;314 }315 }316 317 if (i == RIOCM_RX_RING_SIZE)318 riocm_warn("no record for buffer 0x%p", msg);319 }320 321 return msg;322}323 324/*325 * riocm_rx_fill - fills a ring of receive buffers for given cm device326 * @cm: cm_dev object327 * @nent: max number of entries to fill328 *329 * Returns: none330 */331static void riocm_rx_fill(struct cm_dev *cm, int nent)332{333 int i;334 335 if (cm->rx_slots == 0)336 return;337 338 for (i = 0; i < RIOCM_RX_RING_SIZE && cm->rx_slots && nent; i++) {339 if (cm->rx_buf[i] == NULL) {340 cm->rx_buf[i] = kmalloc(RIO_MAX_MSG_SIZE, GFP_KERNEL);341 if (cm->rx_buf[i] == NULL)342 break;343 rio_add_inb_buffer(cm->mport, cmbox, cm->rx_buf[i]);344 cm->rx_slots--;345 nent--;346 }347 }348}349 350/*351 * riocm_rx_free - frees all receive buffers associated with given cm device352 * @cm: cm_dev object353 *354 * Returns: none355 */356static void riocm_rx_free(struct cm_dev *cm)357{358 int i;359 360 for (i = 0; i < RIOCM_RX_RING_SIZE; i++) {361 if (cm->rx_buf[i] != NULL) {362 kfree(cm->rx_buf[i]);363 cm->rx_buf[i] = NULL;364 }365 }366}367 368/*369 * riocm_req_handler - connection request handler370 * @cm: cm_dev object371 * @req_data: pointer to the request packet372 *373 * Returns: 0 if success, or374 * -EINVAL if channel is not in correct state,375 * -ENODEV if cannot find a channel with specified ID,376 * -ENOMEM if unable to allocate memory to store the request377 */378static int riocm_req_handler(struct cm_dev *cm, void *req_data)379{380 struct rio_channel *ch;381 struct conn_req *req;382 struct rio_ch_chan_hdr *hh = req_data;383 u16 chnum;384 385 chnum = ntohs(hh->dst_ch);386 387 ch = riocm_get_channel(chnum);388 389 if (!ch)390 return -ENODEV;391 392 if (ch->state != RIO_CM_LISTEN) {393 riocm_debug(RX_CMD, "channel %d is not in listen state", chnum);394 riocm_put_channel(ch);395 return -EINVAL;396 }397 398 req = kzalloc(sizeof(*req), GFP_KERNEL);399 if (!req) {400 riocm_put_channel(ch);401 return -ENOMEM;402 }403 404 req->destid = ntohl(hh->bhdr.src_id);405 req->chan = ntohs(hh->src_ch);406 req->cmdev = cm;407 408 spin_lock_bh(&ch->lock);409 list_add_tail(&req->node, &ch->accept_queue);410 spin_unlock_bh(&ch->lock);411 complete(&ch->comp);412 riocm_put_channel(ch);413 414 return 0;415}416 417/*418 * riocm_resp_handler - response to connection request handler419 * @resp_data: pointer to the response packet420 *421 * Returns: 0 if success, or422 * -EINVAL if channel is not in correct state,423 * -ENODEV if cannot find a channel with specified ID,424 */425static int riocm_resp_handler(void *resp_data)426{427 struct rio_channel *ch;428 struct rio_ch_chan_hdr *hh = resp_data;429 u16 chnum;430 431 chnum = ntohs(hh->dst_ch);432 ch = riocm_get_channel(chnum);433 if (!ch)434 return -ENODEV;435 436 if (ch->state != RIO_CM_CONNECT) {437 riocm_put_channel(ch);438 return -EINVAL;439 }440 441 riocm_exch(ch, RIO_CM_CONNECTED);442 ch->rem_channel = ntohs(hh->src_ch);443 complete(&ch->comp);444 riocm_put_channel(ch);445 446 return 0;447}448 449/*450 * riocm_close_handler - channel close request handler451 * @req_data: pointer to the request packet452 *453 * Returns: 0 if success, or454 * -ENODEV if cannot find a channel with specified ID,455 * + error codes returned by riocm_ch_close.456 */457static int riocm_close_handler(void *data)458{459 struct rio_channel *ch;460 struct rio_ch_chan_hdr *hh = data;461 int ret;462 463 riocm_debug(RX_CMD, "for ch=%d", ntohs(hh->dst_ch));464 465 spin_lock_bh(&idr_lock);466 ch = idr_find(&ch_idr, ntohs(hh->dst_ch));467 if (!ch) {468 spin_unlock_bh(&idr_lock);469 return -ENODEV;470 }471 idr_remove(&ch_idr, ch->id);472 spin_unlock_bh(&idr_lock);473 474 riocm_exch(ch, RIO_CM_DISCONNECT);475 476 ret = riocm_ch_close(ch);477 if (ret)478 riocm_debug(RX_CMD, "riocm_ch_close() returned %d", ret);479 480 return 0;481}482 483/*484 * rio_cm_handler - function that services request (non-data) packets485 * @cm: cm_dev object486 * @data: pointer to the packet487 */488static void rio_cm_handler(struct cm_dev *cm, void *data)489{490 struct rio_ch_chan_hdr *hdr;491 492 if (!rio_mport_is_running(cm->mport))493 goto out;494 495 hdr = data;496 497 riocm_debug(RX_CMD, "OP=%x for ch=%d from %d",498 hdr->ch_op, ntohs(hdr->dst_ch), ntohs(hdr->src_ch));499 500 switch (hdr->ch_op) {501 case CM_CONN_REQ:502 riocm_req_handler(cm, data);503 break;504 case CM_CONN_ACK:505 riocm_resp_handler(data);506 break;507 case CM_CONN_CLOSE:508 riocm_close_handler(data);509 break;510 default:511 riocm_error("Invalid packet header");512 break;513 }514out:515 kfree(data);516}517 518/*519 * rio_rx_data_handler - received data packet handler520 * @cm: cm_dev object521 * @buf: data packet522 *523 * Returns: 0 if success, or524 * -ENODEV if cannot find a channel with specified ID,525 * -EIO if channel is not in CONNECTED state,526 * -ENOMEM if channel RX queue is full (packet discarded)527 */528static int rio_rx_data_handler(struct cm_dev *cm, void *buf)529{530 struct rio_ch_chan_hdr *hdr;531 struct rio_channel *ch;532 533 hdr = buf;534 535 riocm_debug(RX_DATA, "for ch=%d", ntohs(hdr->dst_ch));536 537 ch = riocm_get_channel(ntohs(hdr->dst_ch));538 if (!ch) {539 /* Discard data message for non-existing channel */540 kfree(buf);541 return -ENODEV;542 }543 544 /* Place pointer to the buffer into channel's RX queue */545 spin_lock(&ch->lock);546 547 if (ch->state != RIO_CM_CONNECTED) {548 /* Channel is not ready to receive data, discard a packet */549 riocm_debug(RX_DATA, "ch=%d is in wrong state=%d",550 ch->id, ch->state);551 spin_unlock(&ch->lock);552 kfree(buf);553 riocm_put_channel(ch);554 return -EIO;555 }556 557 if (ch->rx_ring.count == RIOCM_RX_RING_SIZE) {558 /* If RX ring is full, discard a packet */559 riocm_debug(RX_DATA, "ch=%d is full", ch->id);560 spin_unlock(&ch->lock);561 kfree(buf);562 riocm_put_channel(ch);563 return -ENOMEM;564 }565 566 ch->rx_ring.buf[ch->rx_ring.head] = buf;567 ch->rx_ring.head++;568 ch->rx_ring.count++;569 ch->rx_ring.head %= RIOCM_RX_RING_SIZE;570 571 complete(&ch->comp);572 573 spin_unlock(&ch->lock);574 riocm_put_channel(ch);575 576 return 0;577}578 579/*580 * rio_ibmsg_handler - inbound message packet handler581 */582static void rio_ibmsg_handler(struct work_struct *work)583{584 struct cm_dev *cm = container_of(work, struct cm_dev, rx_work);585 void *data;586 struct rio_ch_chan_hdr *hdr;587 588 if (!rio_mport_is_running(cm->mport))589 return;590 591 while (1) {592 mutex_lock(&cm->rx_lock);593 data = riocm_rx_get_msg(cm);594 if (data)595 riocm_rx_fill(cm, 1);596 mutex_unlock(&cm->rx_lock);597 598 if (data == NULL)599 break;600 601 hdr = data;602 603 if (hdr->bhdr.type != RIO_CM_CHAN) {604 /* For now simply discard packets other than channel */605 riocm_error("Unsupported TYPE code (0x%x). Msg dropped",606 hdr->bhdr.type);607 kfree(data);608 continue;609 }610 611 /* Process a channel message */612 if (hdr->ch_op == CM_DATA_MSG)613 rio_rx_data_handler(cm, data);614 else615 rio_cm_handler(cm, data);616 }617}618 619static void riocm_inb_msg_event(struct rio_mport *mport, void *dev_id,620 int mbox, int slot)621{622 struct cm_dev *cm = dev_id;623 624 if (rio_mport_is_running(cm->mport) && !work_pending(&cm->rx_work))625 queue_work(cm->rx_wq, &cm->rx_work);626}627 628/*629 * rio_txcq_handler - TX completion handler630 * @cm: cm_dev object631 * @slot: TX queue slot632 *633 * TX completion handler also ensures that pending request packets are placed634 * into transmit queue as soon as a free slot becomes available. This is done635 * to give higher priority to request packets during high intensity data flow.636 */637static void rio_txcq_handler(struct cm_dev *cm, int slot)638{639 int ack_slot;640 641 /* ATTN: Add TX completion notification if/when direct buffer642 * transfer is implemented. At this moment only correct tracking643 * of tx_count is important.644 */645 riocm_debug(TX_EVENT, "for mport_%d slot %d tx_cnt %d",646 cm->mport->id, slot, cm->tx_cnt);647 648 spin_lock(&cm->tx_lock);649 ack_slot = cm->tx_ack_slot;650 651 if (ack_slot == slot)652 riocm_debug(TX_EVENT, "slot == ack_slot");653 654 while (cm->tx_cnt && ((ack_slot != slot) ||655 (cm->tx_cnt == RIOCM_TX_RING_SIZE))) {656 657 cm->tx_buf[ack_slot] = NULL;658 ++ack_slot;659 ack_slot &= (RIOCM_TX_RING_SIZE - 1);660 cm->tx_cnt--;661 }662 663 if (cm->tx_cnt < 0 || cm->tx_cnt > RIOCM_TX_RING_SIZE)664 riocm_error("tx_cnt %d out of sync", cm->tx_cnt);665 666 WARN_ON((cm->tx_cnt < 0) || (cm->tx_cnt > RIOCM_TX_RING_SIZE));667 668 cm->tx_ack_slot = ack_slot;669 670 /*671 * If there are pending requests, insert them into transmit queue672 */673 if (!list_empty(&cm->tx_reqs) && (cm->tx_cnt < RIOCM_TX_RING_SIZE)) {674 struct tx_req *req, *_req;675 int rc;676 677 list_for_each_entry_safe(req, _req, &cm->tx_reqs, node) {678 list_del(&req->node);679 cm->tx_buf[cm->tx_slot] = req->buffer;680 rc = rio_add_outb_message(cm->mport, req->rdev, cmbox,681 req->buffer, req->len);682 kfree(req->buffer);683 kfree(req);684 685 ++cm->tx_cnt;686 ++cm->tx_slot;687 cm->tx_slot &= (RIOCM_TX_RING_SIZE - 1);688 if (cm->tx_cnt == RIOCM_TX_RING_SIZE)689 break;690 }691 }692 693 spin_unlock(&cm->tx_lock);694}695 696static void riocm_outb_msg_event(struct rio_mport *mport, void *dev_id,697 int mbox, int slot)698{699 struct cm_dev *cm = dev_id;700 701 if (cm && rio_mport_is_running(cm->mport))702 rio_txcq_handler(cm, slot);703}704 705static int riocm_queue_req(struct cm_dev *cm, struct rio_dev *rdev,706 void *buffer, size_t len)707{708 unsigned long flags;709 struct tx_req *treq;710 711 treq = kzalloc(sizeof(*treq), GFP_KERNEL);712 if (treq == NULL)713 return -ENOMEM;714 715 treq->rdev = rdev;716 treq->buffer = buffer;717 treq->len = len;718 719 spin_lock_irqsave(&cm->tx_lock, flags);720 list_add_tail(&treq->node, &cm->tx_reqs);721 spin_unlock_irqrestore(&cm->tx_lock, flags);722 return 0;723}724 725/*726 * riocm_post_send - helper function that places packet into msg TX queue727 * @cm: cm_dev object728 * @rdev: target RapidIO device object (required by outbound msg interface)729 * @buffer: pointer to a packet buffer to send730 * @len: length of data to transfer731 * @req: request priority flag732 *733 * Returns: 0 if success, or error code otherwise.734 */735static int riocm_post_send(struct cm_dev *cm, struct rio_dev *rdev,736 void *buffer, size_t len)737{738 int rc;739 unsigned long flags;740 741 spin_lock_irqsave(&cm->tx_lock, flags);742 743 if (cm->mport == NULL) {744 rc = -ENODEV;745 goto err_out;746 }747 748 if (cm->tx_cnt == RIOCM_TX_RING_SIZE) {749 riocm_debug(TX, "Tx Queue is full");750 rc = -EBUSY;751 goto err_out;752 }753 754 cm->tx_buf[cm->tx_slot] = buffer;755 rc = rio_add_outb_message(cm->mport, rdev, cmbox, buffer, len);756 757 riocm_debug(TX, "Add buf@%p destid=%x tx_slot=%d tx_cnt=%d",758 buffer, rdev->destid, cm->tx_slot, cm->tx_cnt);759 760 ++cm->tx_cnt;761 ++cm->tx_slot;762 cm->tx_slot &= (RIOCM_TX_RING_SIZE - 1);763 764err_out:765 spin_unlock_irqrestore(&cm->tx_lock, flags);766 return rc;767}768 769/*770 * riocm_ch_send - sends a data packet to a remote device771 * @ch_id: local channel ID772 * @buf: pointer to a data buffer to send (including CM header)773 * @len: length of data to transfer (including CM header)774 *775 * ATTN: ASSUMES THAT THE HEADER SPACE IS RESERVED PART OF THE DATA PACKET776 *777 * Returns: 0 if success, or778 * -EINVAL if one or more input parameters is/are not valid,779 * -ENODEV if cannot find a channel with specified ID,780 * -EAGAIN if a channel is not in CONNECTED state,781 * + error codes returned by HW send routine.782 */783static int riocm_ch_send(u16 ch_id, void *buf, int len)784{785 struct rio_channel *ch;786 struct rio_ch_chan_hdr *hdr;787 int ret;788 789 if (buf == NULL || ch_id == 0 || len == 0 || len > RIO_MAX_MSG_SIZE)790 return -EINVAL;791 792 ch = riocm_get_channel(ch_id);793 if (!ch) {794 riocm_error("%s(%d) ch_%d not found", current->comm,795 task_pid_nr(current), ch_id);796 return -ENODEV;797 }798 799 if (!riocm_cmp(ch, RIO_CM_CONNECTED)) {800 ret = -EAGAIN;801 goto err_out;802 }803 804 /*805 * Fill buffer header section with corresponding channel data806 */807 hdr = buf;808 809 hdr->bhdr.src_id = htonl(ch->loc_destid);810 hdr->bhdr.dst_id = htonl(ch->rem_destid);811 hdr->bhdr.src_mbox = cmbox;812 hdr->bhdr.dst_mbox = cmbox;813 hdr->bhdr.type = RIO_CM_CHAN;814 hdr->ch_op = CM_DATA_MSG;815 hdr->dst_ch = htons(ch->rem_channel);816 hdr->src_ch = htons(ch->id);817 hdr->msg_len = htons((u16)len);818 819 /* ATTN: the function call below relies on the fact that underlying820 * HW-specific add_outb_message() routine copies TX data into its own821 * internal transfer buffer (true for all RIONET compatible mport822 * drivers). Must be reviewed if mport driver uses the buffer directly.823 */824 825 ret = riocm_post_send(ch->cmdev, ch->rdev, buf, len);826 if (ret)827 riocm_debug(TX, "ch %d send_err=%d", ch->id, ret);828err_out:829 riocm_put_channel(ch);830 return ret;831}832 833static int riocm_ch_free_rxbuf(struct rio_channel *ch, void *buf)834{835 int i, ret = -EINVAL;836 837 spin_lock_bh(&ch->lock);838 839 for (i = 0; i < RIOCM_RX_RING_SIZE; i++) {840 if (ch->rx_ring.inuse[i] == buf) {841 ch->rx_ring.inuse[i] = NULL;842 ch->rx_ring.inuse_cnt--;843 ret = 0;844 break;845 }846 }847 848 spin_unlock_bh(&ch->lock);849 850 if (!ret)851 kfree(buf);852 853 return ret;854}855 856/*857 * riocm_ch_receive - fetch a data packet received for the specified channel858 * @ch: local channel ID859 * @buf: pointer to a packet buffer860 * @timeout: timeout to wait for incoming packet (in jiffies)861 *862 * Returns: 0 and valid buffer pointer if success, or NULL pointer and one of:863 * -EAGAIN if a channel is not in CONNECTED state,864 * -ENOMEM if in-use tracking queue is full,865 * -ETIME if wait timeout expired,866 * -EINTR if wait was interrupted.867 */868static int riocm_ch_receive(struct rio_channel *ch, void **buf, long timeout)869{870 void *rxmsg = NULL;871 int i, ret = 0;872 long wret;873 874 if (!riocm_cmp(ch, RIO_CM_CONNECTED)) {875 ret = -EAGAIN;876 goto out;877 }878 879 if (ch->rx_ring.inuse_cnt == RIOCM_RX_RING_SIZE) {880 /* If we do not have entries to track buffers given to upper881 * layer, reject request.882 */883 ret = -ENOMEM;884 goto out;885 }886 887 wret = wait_for_completion_interruptible_timeout(&ch->comp, timeout);888 889 riocm_debug(WAIT, "wait on %d returned %ld", ch->id, wret);890 891 if (!wret)892 ret = -ETIME;893 else if (wret == -ERESTARTSYS)894 ret = -EINTR;895 else896 ret = riocm_cmp(ch, RIO_CM_CONNECTED) ? 0 : -ECONNRESET;897 898 if (ret)899 goto out;900 901 spin_lock_bh(&ch->lock);902 903 rxmsg = ch->rx_ring.buf[ch->rx_ring.tail];904 ch->rx_ring.buf[ch->rx_ring.tail] = NULL;905 ch->rx_ring.count--;906 ch->rx_ring.tail++;907 ch->rx_ring.tail %= RIOCM_RX_RING_SIZE;908 ret = -ENOMEM;909 910 for (i = 0; i < RIOCM_RX_RING_SIZE; i++) {911 if (ch->rx_ring.inuse[i] == NULL) {912 ch->rx_ring.inuse[i] = rxmsg;913 ch->rx_ring.inuse_cnt++;914 ret = 0;915 break;916 }917 }918 919 if (ret) {920 /* We have no entry to store pending message: drop it */921 kfree(rxmsg);922 rxmsg = NULL;923 }924 925 spin_unlock_bh(&ch->lock);926out:927 *buf = rxmsg;928 return ret;929}930 931/*932 * riocm_ch_connect - sends a connect request to a remote device933 * @loc_ch: local channel ID934 * @cm: CM device to send connect request935 * @peer: target RapidIO device936 * @rem_ch: remote channel ID937 *938 * Returns: 0 if success, or939 * -EINVAL if the channel is not in IDLE state,940 * -EAGAIN if no connection request available immediately,941 * -ETIME if ACK response timeout expired,942 * -EINTR if wait for response was interrupted.943 */944static int riocm_ch_connect(u16 loc_ch, struct cm_dev *cm,945 struct cm_peer *peer, u16 rem_ch)946{947 struct rio_channel *ch = NULL;948 struct rio_ch_chan_hdr *hdr;949 int ret;950 long wret;951 952 ch = riocm_get_channel(loc_ch);953 if (!ch)954 return -ENODEV;955 956 if (!riocm_cmp_exch(ch, RIO_CM_IDLE, RIO_CM_CONNECT)) {957 ret = -EINVAL;958 goto conn_done;959 }960 961 ch->cmdev = cm;962 ch->rdev = peer->rdev;963 ch->context = NULL;964 ch->loc_destid = cm->mport->host_deviceid;965 ch->rem_channel = rem_ch;966 967 /*968 * Send connect request to the remote RapidIO device969 */970 971 hdr = kzalloc(sizeof(*hdr), GFP_KERNEL);972 if (hdr == NULL) {973 ret = -ENOMEM;974 goto conn_done;975 }976 977 hdr->bhdr.src_id = htonl(ch->loc_destid);978 hdr->bhdr.dst_id = htonl(peer->rdev->destid);979 hdr->bhdr.src_mbox = cmbox;980 hdr->bhdr.dst_mbox = cmbox;981 hdr->bhdr.type = RIO_CM_CHAN;982 hdr->ch_op = CM_CONN_REQ;983 hdr->dst_ch = htons(rem_ch);984 hdr->src_ch = htons(loc_ch);985 986 /* ATTN: the function call below relies on the fact that underlying987 * HW-specific add_outb_message() routine copies TX data into its988 * internal transfer buffer. Must be reviewed if mport driver uses989 * this buffer directly.990 */991 ret = riocm_post_send(cm, peer->rdev, hdr, sizeof(*hdr));992 993 if (ret != -EBUSY) {994 kfree(hdr);995 } else {996 ret = riocm_queue_req(cm, peer->rdev, hdr, sizeof(*hdr));997 if (ret)998 kfree(hdr);999 }1000 1001 if (ret) {1002 riocm_cmp_exch(ch, RIO_CM_CONNECT, RIO_CM_IDLE);1003 goto conn_done;1004 }1005 1006 /* Wait for connect response from the remote device */1007 wret = wait_for_completion_interruptible_timeout(&ch->comp,1008 RIOCM_CONNECT_TO * HZ);1009 riocm_debug(WAIT, "wait on %d returns %ld", ch->id, wret);1010 1011 if (!wret)1012 ret = -ETIME;1013 else if (wret == -ERESTARTSYS)1014 ret = -EINTR;1015 else1016 ret = riocm_cmp(ch, RIO_CM_CONNECTED) ? 0 : -1;1017 1018conn_done:1019 riocm_put_channel(ch);1020 return ret;1021}1022 1023static int riocm_send_ack(struct rio_channel *ch)1024{1025 struct rio_ch_chan_hdr *hdr;1026 int ret;1027 1028 hdr = kzalloc(sizeof(*hdr), GFP_KERNEL);1029 if (hdr == NULL)1030 return -ENOMEM;1031 1032 hdr->bhdr.src_id = htonl(ch->loc_destid);1033 hdr->bhdr.dst_id = htonl(ch->rem_destid);1034 hdr->dst_ch = htons(ch->rem_channel);1035 hdr->src_ch = htons(ch->id);1036 hdr->bhdr.src_mbox = cmbox;1037 hdr->bhdr.dst_mbox = cmbox;1038 hdr->bhdr.type = RIO_CM_CHAN;1039 hdr->ch_op = CM_CONN_ACK;1040 1041 /* ATTN: the function call below relies on the fact that underlying1042 * add_outb_message() routine copies TX data into its internal transfer1043 * buffer. Review if switching to direct buffer version.1044 */1045 ret = riocm_post_send(ch->cmdev, ch->rdev, hdr, sizeof(*hdr));1046 1047 if (ret == -EBUSY && !riocm_queue_req(ch->cmdev,1048 ch->rdev, hdr, sizeof(*hdr)))1049 return 0;1050 kfree(hdr);1051 1052 if (ret)1053 riocm_error("send ACK to ch_%d on %s failed (ret=%d)",1054 ch->id, rio_name(ch->rdev), ret);1055 return ret;1056}1057 1058/*1059 * riocm_ch_accept - accept incoming connection request1060 * @ch_id: channel ID1061 * @new_ch_id: local mport device1062 * @timeout: wait timeout (if 0 non-blocking call, do not wait if connection1063 * request is not available).1064 *1065 * Returns: pointer to new channel struct if success, or error-valued pointer:1066 * -ENODEV - cannot find specified channel or mport,1067 * -EINVAL - the channel is not in IDLE state,1068 * -EAGAIN - no connection request available immediately (timeout=0),1069 * -ENOMEM - unable to allocate new channel,1070 * -ETIME - wait timeout expired,1071 * -EINTR - wait was interrupted.1072 */1073static struct rio_channel *riocm_ch_accept(u16 ch_id, u16 *new_ch_id,1074 long timeout)1075{1076 struct rio_channel *ch;1077 struct rio_channel *new_ch;1078 struct conn_req *req;1079 struct cm_peer *peer;1080 int found = 0;1081 int err = 0;1082 long wret;1083 1084 ch = riocm_get_channel(ch_id);1085 if (!ch)1086 return ERR_PTR(-EINVAL);1087 1088 if (!riocm_cmp(ch, RIO_CM_LISTEN)) {1089 err = -EINVAL;1090 goto err_put;1091 }1092 1093 /* Don't sleep if this is a non blocking call */1094 if (!timeout) {1095 if (!try_wait_for_completion(&ch->comp)) {1096 err = -EAGAIN;1097 goto err_put;1098 }1099 } else {1100 riocm_debug(WAIT, "on %d", ch->id);1101 1102 wret = wait_for_completion_interruptible_timeout(&ch->comp,1103 timeout);1104 if (!wret) {1105 err = -ETIME;1106 goto err_put;1107 } else if (wret == -ERESTARTSYS) {1108 err = -EINTR;1109 goto err_put;1110 }1111 }1112 1113 spin_lock_bh(&ch->lock);1114 1115 if (ch->state != RIO_CM_LISTEN) {1116 err = -ECANCELED;1117 } else if (list_empty(&ch->accept_queue)) {1118 riocm_debug(WAIT, "on %d accept_queue is empty on completion",1119 ch->id);1120 err = -EIO;1121 }1122 1123 spin_unlock_bh(&ch->lock);1124 1125 if (err) {1126 riocm_debug(WAIT, "on %d returns %d", ch->id, err);1127 goto err_put;1128 }1129 1130 /* Create new channel for this connection */1131 new_ch = riocm_ch_alloc(RIOCM_CHNUM_AUTO);1132 1133 if (IS_ERR(new_ch)) {1134 riocm_error("failed to get channel for new req (%ld)",1135 PTR_ERR(new_ch));1136 err = -ENOMEM;1137 goto err_put;1138 }1139 1140 spin_lock_bh(&ch->lock);1141 1142 req = list_first_entry(&ch->accept_queue, struct conn_req, node);1143 list_del(&req->node);1144 new_ch->cmdev = ch->cmdev;1145 new_ch->loc_destid = ch->loc_destid;1146 new_ch->rem_destid = req->destid;1147 new_ch->rem_channel = req->chan;1148 1149 spin_unlock_bh(&ch->lock);1150 riocm_put_channel(ch);1151 ch = NULL;1152 kfree(req);1153 1154 down_read(&rdev_sem);1155 /* Find requester's device object */1156 list_for_each_entry(peer, &new_ch->cmdev->peers, node) {1157 if (peer->rdev->destid == new_ch->rem_destid) {1158 riocm_debug(RX_CMD, "found matching device(%s)",1159 rio_name(peer->rdev));1160 found = 1;1161 break;1162 }1163 }1164 up_read(&rdev_sem);1165 1166 if (!found) {1167 /* If peer device object not found, simply ignore the request */1168 err = -ENODEV;1169 goto err_put_new_ch;1170 }1171 1172 new_ch->rdev = peer->rdev;1173 new_ch->state = RIO_CM_CONNECTED;1174 spin_lock_init(&new_ch->lock);1175 1176 /* Acknowledge the connection request. */1177 riocm_send_ack(new_ch);1178 1179 *new_ch_id = new_ch->id;1180 return new_ch;1181 1182err_put_new_ch:1183 spin_lock_bh(&idr_lock);1184 idr_remove(&ch_idr, new_ch->id);1185 spin_unlock_bh(&idr_lock);1186 riocm_put_channel(new_ch);1187 1188err_put:1189 if (ch)1190 riocm_put_channel(ch);1191 *new_ch_id = 0;1192 return ERR_PTR(err);1193}1194 1195/*1196 * riocm_ch_listen - puts a channel into LISTEN state1197 * @ch_id: channel ID1198 *1199 * Returns: 0 if success, or1200 * -EINVAL if the specified channel does not exists or1201 * is not in CHAN_BOUND state.1202 */1203static int riocm_ch_listen(u16 ch_id)1204{1205 struct rio_channel *ch = NULL;1206 int ret = 0;1207 1208 riocm_debug(CHOP, "(ch_%d)", ch_id);1209 1210 ch = riocm_get_channel(ch_id);1211 if (!ch)1212 return -EINVAL;1213 if (!riocm_cmp_exch(ch, RIO_CM_CHAN_BOUND, RIO_CM_LISTEN))1214 ret = -EINVAL;1215 riocm_put_channel(ch);1216 return ret;1217}1218 1219/*1220 * riocm_ch_bind - associate a channel object and an mport device1221 * @ch_id: channel ID1222 * @mport_id: local mport device ID1223 * @context: pointer to the additional caller's context1224 *1225 * Returns: 0 if success, or1226 * -ENODEV if cannot find specified mport,1227 * -EINVAL if the specified channel does not exist or1228 * is not in IDLE state.1229 */1230static int riocm_ch_bind(u16 ch_id, u8 mport_id, void *context)1231{1232 struct rio_channel *ch = NULL;1233 struct cm_dev *cm;1234 int rc = -ENODEV;1235 1236 riocm_debug(CHOP, "ch_%d to mport_%d", ch_id, mport_id);1237 1238 /* Find matching cm_dev object */1239 down_read(&rdev_sem);1240 list_for_each_entry(cm, &cm_dev_list, list) {1241 if ((cm->mport->id == mport_id) &&1242 rio_mport_is_running(cm->mport)) {1243 rc = 0;1244 break;1245 }1246 }1247 1248 if (rc)1249 goto exit;1250 1251 ch = riocm_get_channel(ch_id);1252 if (!ch) {1253 rc = -EINVAL;1254 goto exit;1255 }1256 1257 spin_lock_bh(&ch->lock);1258 if (ch->state != RIO_CM_IDLE) {1259 spin_unlock_bh(&ch->lock);1260 rc = -EINVAL;1261 goto err_put;1262 }1263 1264 ch->cmdev = cm;1265 ch->loc_destid = cm->mport->host_deviceid;1266 ch->context = context;1267 ch->state = RIO_CM_CHAN_BOUND;1268 spin_unlock_bh(&ch->lock);1269err_put:1270 riocm_put_channel(ch);1271exit:1272 up_read(&rdev_sem);1273 return rc;1274}1275 1276/*1277 * riocm_ch_alloc - channel object allocation helper routine1278 * @ch_num: channel ID (1 ... RIOCM_MAX_CHNUM, 0 = automatic)1279 *1280 * Return value: pointer to newly created channel object,1281 * or error-valued pointer1282 */1283static struct rio_channel *riocm_ch_alloc(u16 ch_num)1284{1285 int id;1286 int start, end;1287 struct rio_channel *ch;1288 1289 ch = kzalloc(sizeof(*ch), GFP_KERNEL);1290 if (!ch)1291 return ERR_PTR(-ENOMEM);1292 1293 if (ch_num) {1294 /* If requested, try to obtain the specified channel ID */1295 start = ch_num;1296 end = ch_num + 1;1297 } else {1298 /* Obtain channel ID from the dynamic allocation range */1299 start = chstart;1300 end = RIOCM_MAX_CHNUM + 1;1301 }1302 1303 idr_preload(GFP_KERNEL);1304 spin_lock_bh(&idr_lock);1305 id = idr_alloc_cyclic(&ch_idr, ch, start, end, GFP_NOWAIT);1306 spin_unlock_bh(&idr_lock);1307 idr_preload_end();1308 1309 if (id < 0) {1310 kfree(ch);1311 return ERR_PTR(id == -ENOSPC ? -EBUSY : id);1312 }1313 1314 ch->id = (u16)id;1315 ch->state = RIO_CM_IDLE;1316 spin_lock_init(&ch->lock);1317 INIT_LIST_HEAD(&ch->accept_queue);1318 INIT_LIST_HEAD(&ch->ch_node);1319 init_completion(&ch->comp);1320 init_completion(&ch->comp_close);1321 kref_init(&ch->ref);1322 ch->rx_ring.head = 0;1323 ch->rx_ring.tail = 0;1324 ch->rx_ring.count = 0;1325 ch->rx_ring.inuse_cnt = 0;1326 1327 return ch;1328}1329 1330/*1331 * riocm_ch_create - creates a new channel object and allocates ID for it1332 * @ch_num: channel ID (1 ... RIOCM_MAX_CHNUM, 0 = automatic)1333 *1334 * Allocates and initializes a new channel object. If the parameter ch_num > 01335 * and is within the valid range, riocm_ch_create tries to allocate the1336 * specified ID for the new channel. If ch_num = 0, channel ID will be assigned1337 * automatically from the range (chstart ... RIOCM_MAX_CHNUM).1338 * Module parameter 'chstart' defines start of an ID range available for dynamic1339 * allocation. Range below 'chstart' is reserved for pre-defined ID numbers.1340 * Available channel numbers are limited by 16-bit size of channel numbers used1341 * in the packet header.1342 *1343 * Return value: PTR to rio_channel structure if successful (with channel number1344 * updated via pointer) or error-valued pointer if error.1345 */1346static struct rio_channel *riocm_ch_create(u16 *ch_num)1347{1348 struct rio_channel *ch = NULL;1349 1350 ch = riocm_ch_alloc(*ch_num);1351 1352 if (IS_ERR(ch))1353 riocm_debug(CHOP, "Failed to allocate channel %d (err=%ld)",1354 *ch_num, PTR_ERR(ch));1355 else1356 *ch_num = ch->id;1357 1358 return ch;1359}1360 1361/*1362 * riocm_ch_free - channel object release routine1363 * @ref: pointer to a channel's kref structure1364 */1365static void riocm_ch_free(struct kref *ref)1366{1367 struct rio_channel *ch = container_of(ref, struct rio_channel, ref);1368 int i;1369 1370 riocm_debug(CHOP, "(ch_%d)", ch->id);1371 1372 if (ch->rx_ring.inuse_cnt) {1373 for (i = 0;1374 i < RIOCM_RX_RING_SIZE && ch->rx_ring.inuse_cnt; i++) {1375 if (ch->rx_ring.inuse[i] != NULL) {1376 kfree(ch->rx_ring.inuse[i]);1377 ch->rx_ring.inuse_cnt--;1378 }1379 }1380 }1381 1382 if (ch->rx_ring.count)1383 for (i = 0; i < RIOCM_RX_RING_SIZE && ch->rx_ring.count; i++) {1384 if (ch->rx_ring.buf[i] != NULL) {1385 kfree(ch->rx_ring.buf[i]);1386 ch->rx_ring.count--;1387 }1388 }1389 1390 complete(&ch->comp_close);1391}1392 1393static int riocm_send_close(struct rio_channel *ch)1394{1395 struct rio_ch_chan_hdr *hdr;1396 int ret;1397 1398 /*1399 * Send CH_CLOSE notification to the remote RapidIO device1400 */1401 1402 hdr = kzalloc(sizeof(*hdr), GFP_KERNEL);1403 if (hdr == NULL)1404 return -ENOMEM;1405 1406 hdr->bhdr.src_id = htonl(ch->loc_destid);1407 hdr->bhdr.dst_id = htonl(ch->rem_destid);1408 hdr->bhdr.src_mbox = cmbox;1409 hdr->bhdr.dst_mbox = cmbox;1410 hdr->bhdr.type = RIO_CM_CHAN;1411 hdr->ch_op = CM_CONN_CLOSE;1412 hdr->dst_ch = htons(ch->rem_channel);1413 hdr->src_ch = htons(ch->id);1414 1415 /* ATTN: the function call below relies on the fact that underlying1416 * add_outb_message() routine copies TX data into its internal transfer1417 * buffer. Needs to be reviewed if switched to direct buffer mode.1418 */1419 ret = riocm_post_send(ch->cmdev, ch->rdev, hdr, sizeof(*hdr));1420 1421 if (ret == -EBUSY && !riocm_queue_req(ch->cmdev, ch->rdev,1422 hdr, sizeof(*hdr)))1423 return 0;1424 kfree(hdr);1425 1426 if (ret)1427 riocm_error("ch(%d) send CLOSE failed (ret=%d)", ch->id, ret);1428 1429 return ret;1430}1431 1432/*1433 * riocm_ch_close - closes a channel object with specified ID (by local request)1434 * @ch: channel to be closed1435 */1436static int riocm_ch_close(struct rio_channel *ch)1437{1438 unsigned long tmo = msecs_to_jiffies(3000);1439 enum rio_cm_state state;1440 long wret;1441 int ret = 0;1442 1443 riocm_debug(CHOP, "ch_%d by %s(%d)",1444 ch->id, current->comm, task_pid_nr(current));1445 1446 state = riocm_exch(ch, RIO_CM_DESTROYING);1447 if (state == RIO_CM_CONNECTED)1448 riocm_send_close(ch);1449 1450 complete_all(&ch->comp);1451 1452 riocm_put_channel(ch);1453 wret = wait_for_completion_interruptible_timeout(&ch->comp_close, tmo);1454 1455 riocm_debug(WAIT, "wait on %d returns %ld", ch->id, wret);1456 1457 if (wret == 0) {1458 /* Timeout on wait occurred */1459 riocm_debug(CHOP, "%s(%d) timed out waiting for ch %d",1460 current->comm, task_pid_nr(current), ch->id);1461 ret = -ETIMEDOUT;1462 } else if (wret == -ERESTARTSYS) {1463 /* Wait_for_completion was interrupted by a signal */1464 riocm_debug(CHOP, "%s(%d) wait for ch %d was interrupted",1465 current->comm, task_pid_nr(current), ch->id);1466 ret = -EINTR;1467 }1468 1469 if (!ret) {1470 riocm_debug(CHOP, "ch_%d resources released", ch->id);1471 kfree(ch);1472 } else {1473 riocm_debug(CHOP, "failed to release ch_%d resources", ch->id);1474 }1475 1476 return ret;1477}1478 1479/*1480 * riocm_cdev_open() - Open character device1481 */1482static int riocm_cdev_open(struct inode *inode, struct file *filp)1483{1484 riocm_debug(INIT, "by %s(%d) filp=%p ",1485 current->comm, task_pid_nr(current), filp);1486 1487 if (list_empty(&cm_dev_list))1488 return -ENODEV;1489 1490 return 0;1491}1492 1493/*1494 * riocm_cdev_release() - Release character device1495 */1496static int riocm_cdev_release(struct inode *inode, struct file *filp)1497{1498 struct rio_channel *ch, *_c;1499 unsigned int i;1500 LIST_HEAD(list);1501 1502 riocm_debug(EXIT, "by %s(%d) filp=%p",1503 current->comm, task_pid_nr(current), filp);1504 1505 /* Check if there are channels associated with this file descriptor */1506 spin_lock_bh(&idr_lock);1507 idr_for_each_entry(&ch_idr, ch, i) {1508 if (ch && ch->filp == filp) {1509 riocm_debug(EXIT, "ch_%d not released by %s(%d)",1510 ch->id, current->comm,1511 task_pid_nr(current));1512 idr_remove(&ch_idr, ch->id);1513 list_add(&ch->ch_node, &list);1514 }1515 }1516 spin_unlock_bh(&idr_lock);1517 1518 if (!list_empty(&list)) {1519 list_for_each_entry_safe(ch, _c, &list, ch_node) {1520 list_del(&ch->ch_node);1521 riocm_ch_close(ch);1522 }1523 }1524 1525 return 0;1526}1527 1528/*1529 * cm_ep_get_list_size() - Reports number of endpoints in the network1530 */1531static int cm_ep_get_list_size(void __user *arg)1532{1533 u32 __user *p = arg;1534 u32 mport_id;1535 u32 count = 0;1536 struct cm_dev *cm;1537 1538 if (get_user(mport_id, p))1539 return -EFAULT;1540 if (mport_id >= RIO_MAX_MPORTS)1541 return -EINVAL;1542 1543 /* Find a matching cm_dev object */1544 down_read(&rdev_sem);1545 list_for_each_entry(cm, &cm_dev_list, list) {1546 if (cm->mport->id == mport_id) {1547 count = cm->npeers;1548 up_read(&rdev_sem);1549 if (copy_to_user(arg, &count, sizeof(u32)))1550 return -EFAULT;1551 return 0;1552 }1553 }1554 up_read(&rdev_sem);1555 1556 return -ENODEV;1557}1558 1559/*1560 * cm_ep_get_list() - Returns list of attached endpoints1561 */1562static int cm_ep_get_list(void __user *arg)1563{1564 struct cm_dev *cm;1565 struct cm_peer *peer;1566 u32 info[2];1567 void *buf;1568 u32 nent;1569 u32 *entry_ptr;1570 u32 i = 0;1571 int ret = 0;1572 1573 if (copy_from_user(&info, arg, sizeof(info)))1574 return -EFAULT;1575 1576 if (info[1] >= RIO_MAX_MPORTS || info[0] > RIOCM_MAX_EP_COUNT)1577 return -EINVAL;1578 1579 /* Find a matching cm_dev object */1580 down_read(&rdev_sem);1581 list_for_each_entry(cm, &cm_dev_list, list)1582 if (cm->mport->id == (u8)info[1])1583 goto found;1584 1585 up_read(&rdev_sem);1586 return -ENODEV;1587 1588found:1589 nent = min(info[0], cm->npeers);1590 buf = kcalloc(nent + 2, sizeof(u32), GFP_KERNEL);1591 if (!buf) {1592 up_read(&rdev_sem);1593 return -ENOMEM;1594 }1595 1596 entry_ptr = (u32 *)((uintptr_t)buf + 2*sizeof(u32));1597 1598 list_for_each_entry(peer, &cm->peers, node) {1599 *entry_ptr = (u32)peer->rdev->destid;1600 entry_ptr++;1601 if (++i == nent)1602 break;1603 }1604 up_read(&rdev_sem);1605 1606 ((u32 *)buf)[0] = i; /* report an updated number of entries */1607 ((u32 *)buf)[1] = info[1]; /* put back an mport ID */1608 if (copy_to_user(arg, buf, sizeof(u32) * (info[0] + 2)))1609 ret = -EFAULT;1610 1611 kfree(buf);1612 return ret;1613}1614 1615/*1616 * cm_mport_get_list() - Returns list of available local mport devices1617 */1618static int cm_mport_get_list(void __user *arg)1619{1620 int ret = 0;1621 u32 entries;1622 void *buf;1623 struct cm_dev *cm;1624 u32 *entry_ptr;1625 int count = 0;1626 1627 if (copy_from_user(&entries, arg, sizeof(entries)))1628 return -EFAULT;1629 if (entries == 0 || entries > RIO_MAX_MPORTS)1630 return -EINVAL;1631 buf = kcalloc(entries + 1, sizeof(u32), GFP_KERNEL);1632 if (!buf)1633 return -ENOMEM;1634 1635 /* Scan all registered cm_dev objects */1636 entry_ptr = (u32 *)((uintptr_t)buf + sizeof(u32));1637 down_read(&rdev_sem);1638 list_for_each_entry(cm, &cm_dev_list, list) {1639 if (count++ < entries) {1640 *entry_ptr = (cm->mport->id << 16) |1641 cm->mport->host_deviceid;1642 entry_ptr++;1643 }1644 }1645 up_read(&rdev_sem);1646 1647 *((u32 *)buf) = count; /* report a real number of entries */1648 if (copy_to_user(arg, buf, sizeof(u32) * (count + 1)))1649 ret = -EFAULT;1650 1651 kfree(buf);1652 return ret;1653}1654 1655/*1656 * cm_chan_create() - Create a message exchange channel1657 */1658static int cm_chan_create(struct file *filp, void __user *arg)1659{1660 u16 __user *p = arg;1661 u16 ch_num;1662 struct rio_channel *ch;1663 1664 if (get_user(ch_num, p))1665 return -EFAULT;1666 1667 riocm_debug(CHOP, "ch_%d requested by %s(%d)",1668 ch_num, current->comm, task_pid_nr(current));1669 ch = riocm_ch_create(&ch_num);1670 if (IS_ERR(ch))1671 return PTR_ERR(ch);1672 1673 ch->filp = filp;1674 riocm_debug(CHOP, "ch_%d created by %s(%d)",1675 ch_num, current->comm, task_pid_nr(current));1676 return put_user(ch_num, p);1677}1678 1679/*1680 * cm_chan_close() - Close channel1681 * @filp: Pointer to file object1682 * @arg: Channel to close1683 */1684static int cm_chan_close(struct file *filp, void __user *arg)1685{1686 u16 __user *p = arg;1687 u16 ch_num;1688 struct rio_channel *ch;1689 1690 if (get_user(ch_num, p))1691 return -EFAULT;1692 1693 riocm_debug(CHOP, "ch_%d by %s(%d)",1694 ch_num, current->comm, task_pid_nr(current));1695 1696 spin_lock_bh(&idr_lock);1697 ch = idr_find(&ch_idr, ch_num);1698 if (!ch) {1699 spin_unlock_bh(&idr_lock);1700 return 0;1701 }1702 if (ch->filp != filp) {1703 spin_unlock_bh(&idr_lock);1704 return -EINVAL;1705 }1706 idr_remove(&ch_idr, ch->id);1707 spin_unlock_bh(&idr_lock);1708 1709 return riocm_ch_close(ch);1710}1711 1712/*1713 * cm_chan_bind() - Bind channel1714 * @arg: Channel number1715 */1716static int cm_chan_bind(void __user *arg)1717{1718 struct rio_cm_channel chan;1719 1720 if (copy_from_user(&chan, arg, sizeof(chan)))1721 return -EFAULT;1722 if (chan.mport_id >= RIO_MAX_MPORTS)1723 return -EINVAL;1724 1725 return riocm_ch_bind(chan.id, chan.mport_id, NULL);1726}1727 1728/*1729 * cm_chan_listen() - Listen on channel1730 * @arg: Channel number1731 */1732static int cm_chan_listen(void __user *arg)1733{1734 u16 __user *p = arg;1735 u16 ch_num;1736 1737 if (get_user(ch_num, p))1738 return -EFAULT;1739 1740 return riocm_ch_listen(ch_num);1741}1742 1743/*1744 * cm_chan_accept() - Accept incoming connection1745 * @filp: Pointer to file object1746 * @arg: Channel number1747 */1748static int cm_chan_accept(struct file *filp, void __user *arg)1749{1750 struct rio_cm_accept param;1751 long accept_to;1752 struct rio_channel *ch;1753 1754 if (copy_from_user(¶m, arg, sizeof(param)))1755 return -EFAULT;1756 1757 riocm_debug(CHOP, "on ch_%d by %s(%d)",1758 param.ch_num, current->comm, task_pid_nr(current));1759 1760 accept_to = param.wait_to ?1761 msecs_to_jiffies(param.wait_to) : 0;1762 1763 ch = riocm_ch_accept(param.ch_num, ¶m.ch_num, accept_to);1764 if (IS_ERR(ch))1765 return PTR_ERR(ch);1766 ch->filp = filp;1767 1768 riocm_debug(CHOP, "new ch_%d for %s(%d)",1769 ch->id, current->comm, task_pid_nr(current));1770 1771 if (copy_to_user(arg, ¶m, sizeof(param)))1772 return -EFAULT;1773 return 0;1774}1775 1776/*1777 * cm_chan_connect() - Connect on channel1778 * @arg: Channel information1779 */1780static int cm_chan_connect(void __user *arg)1781{1782 struct rio_cm_channel chan;1783 struct cm_dev *cm;1784 struct cm_peer *peer;1785 int ret = -ENODEV;1786 1787 if (copy_from_user(&chan, arg, sizeof(chan)))1788 return -EFAULT;1789 if (chan.mport_id >= RIO_MAX_MPORTS)1790 return -EINVAL;1791 1792 down_read(&rdev_sem);1793 1794 /* Find matching cm_dev object */1795 list_for_each_entry(cm, &cm_dev_list, list) {1796 if (cm->mport->id == chan.mport_id) {1797 ret = 0;1798 break;1799 }1800 }1801 1802 if (ret)1803 goto err_out;1804 1805 if (chan.remote_destid >= RIO_ANY_DESTID(cm->mport->sys_size)) {1806 ret = -EINVAL;1807 goto err_out;1808 }1809 1810 /* Find corresponding RapidIO endpoint device object */1811 ret = -ENODEV;1812 1813 list_for_each_entry(peer, &cm->peers, node) {1814 if (peer->rdev->destid == chan.remote_destid) {1815 ret = 0;1816 break;1817 }1818 }1819 1820 if (ret)1821 goto err_out;1822 1823 up_read(&rdev_sem);1824 1825 return riocm_ch_connect(chan.id, cm, peer, chan.remote_channel);1826err_out:1827 up_read(&rdev_sem);1828 return ret;1829}1830 1831/*1832 * cm_chan_msg_send() - Send a message through channel1833 * @arg: Outbound message information1834 */1835static int cm_chan_msg_send(void __user *arg)1836{1837 struct rio_cm_msg msg;1838 void *buf;1839 int ret;1840 1841 if (copy_from_user(&msg, arg, sizeof(msg)))1842 return -EFAULT;1843 if (msg.size > RIO_MAX_MSG_SIZE)1844 return -EINVAL;1845 1846 buf = memdup_user((void __user *)(uintptr_t)msg.msg, msg.size);1847 if (IS_ERR(buf))1848 return PTR_ERR(buf);1849 1850 ret = riocm_ch_send(msg.ch_num, buf, msg.size);1851 1852 kfree(buf);1853 return ret;1854}1855 1856/*1857 * cm_chan_msg_rcv() - Receive a message through channel1858 * @arg: Inbound message information1859 */1860static int cm_chan_msg_rcv(void __user *arg)1861{1862 struct rio_cm_msg msg;1863 struct rio_channel *ch;1864 void *buf;1865 long rxto;1866 int ret = 0, msg_size;1867 1868 if (copy_from_user(&msg, arg, sizeof(msg)))1869 return -EFAULT;1870 1871 if (msg.ch_num == 0 || msg.size == 0)1872 return -EINVAL;1873 1874 ch = riocm_get_channel(msg.ch_num);1875 if (!ch)1876 return -ENODEV;1877 1878 rxto = msg.rxto ? msecs_to_jiffies(msg.rxto) : MAX_SCHEDULE_TIMEOUT;1879 1880 ret = riocm_ch_receive(ch, &buf, rxto);1881 if (ret)1882 goto out;1883 1884 msg_size = min(msg.size, (u16)(RIO_MAX_MSG_SIZE));1885 1886 if (copy_to_user((void __user *)(uintptr_t)msg.msg, buf, msg_size))1887 ret = -EFAULT;1888 1889 riocm_ch_free_rxbuf(ch, buf);1890out:1891 riocm_put_channel(ch);1892 return ret;1893}1894 1895/*1896 * riocm_cdev_ioctl() - IOCTL requests handler1897 */1898static long1899riocm_cdev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)1900{1901 switch (cmd) {1902 case RIO_CM_EP_GET_LIST_SIZE:1903 return cm_ep_get_list_size((void __user *)arg);1904 case RIO_CM_EP_GET_LIST:1905 return cm_ep_get_list((void __user *)arg);1906 case RIO_CM_CHAN_CREATE:1907 return cm_chan_create(filp, (void __user *)arg);1908 case RIO_CM_CHAN_CLOSE:1909 return cm_chan_close(filp, (void __user *)arg);1910 case RIO_CM_CHAN_BIND:1911 return cm_chan_bind((void __user *)arg);1912 case RIO_CM_CHAN_LISTEN:1913 return cm_chan_listen((void __user *)arg);1914 case RIO_CM_CHAN_ACCEPT:1915 return cm_chan_accept(filp, (void __user *)arg);1916 case RIO_CM_CHAN_CONNECT:1917 return cm_chan_connect((void __user *)arg);1918 case RIO_CM_CHAN_SEND:1919 return cm_chan_msg_send((void __user *)arg);1920 case RIO_CM_CHAN_RECEIVE:1921 return cm_chan_msg_rcv((void __user *)arg);1922 case RIO_CM_MPORT_GET_LIST:1923 return cm_mport_get_list((void __user *)arg);1924 default:1925 break;1926 }1927 1928 return -EINVAL;1929}1930 1931static const struct file_operations riocm_cdev_fops = {1932 .owner = THIS_MODULE,1933 .open = riocm_cdev_open,1934 .release = riocm_cdev_release,1935 .unlocked_ioctl = riocm_cdev_ioctl,1936};1937 1938/*1939 * riocm_add_dev - add new remote RapidIO device into channel management core1940 * @dev: device object associated with RapidIO device1941 * @sif: subsystem interface1942 *1943 * Adds the specified RapidIO device (if applicable) into peers list of1944 * the corresponding channel management device (cm_dev).1945 */1946static int riocm_add_dev(struct device *dev, struct subsys_interface *sif)1947{1948 struct cm_peer *peer;1949 struct rio_dev *rdev = to_rio_dev(dev);1950 struct cm_dev *cm;1951 1952 /* Check if the remote device has capabilities required to support CM */1953 if (!dev_cm_capable(rdev))1954 return 0;1955 1956 riocm_debug(RDEV, "(%s)", rio_name(rdev));1957 1958 peer = kmalloc(sizeof(*peer), GFP_KERNEL);1959 if (!peer)1960 return -ENOMEM;1961 1962 /* Find a corresponding cm_dev object */1963 down_write(&rdev_sem);1964 list_for_each_entry(cm, &cm_dev_list, list) {1965 if (cm->mport == rdev->net->hport)1966 goto found;1967 }1968 1969 up_write(&rdev_sem);1970 kfree(peer);1971 return -ENODEV;1972 1973found:1974 peer->rdev = rdev;1975 list_add_tail(&peer->node, &cm->peers);1976 cm->npeers++;1977 1978 up_write(&rdev_sem);1979 return 0;1980}1981 1982/*1983 * riocm_remove_dev - remove remote RapidIO device from channel management core1984 * @dev: device object associated with RapidIO device1985 * @sif: subsystem interface1986 *1987 * Removes the specified RapidIO device (if applicable) from peers list of1988 * the corresponding channel management device (cm_dev).1989 */1990static void riocm_remove_dev(struct device *dev, struct subsys_interface *sif)1991{1992 struct rio_dev *rdev = to_rio_dev(dev);1993 struct cm_dev *cm;1994 struct cm_peer *peer;1995 struct rio_channel *ch, *_c;1996 unsigned int i;1997 bool found = false;1998 LIST_HEAD(list);1999 2000 /* Check if the remote device has capabilities required to support CM */2001 if (!dev_cm_capable(rdev))2002 return;2003 2004 riocm_debug(RDEV, "(%s)", rio_name(rdev));2005 2006 /* Find matching cm_dev object */2007 down_write(&rdev_sem);2008 list_for_each_entry(cm, &cm_dev_list, list) {2009 if (cm->mport == rdev->net->hport) {2010 found = true;2011 break;2012 }2013 }2014 2015 if (!found) {2016 up_write(&rdev_sem);2017 return;2018 }2019 2020 /* Remove remote device from the list of peers */2021 found = false;2022 list_for_each_entry(peer, &cm->peers, node) {2023 if (peer->rdev == rdev) {2024 riocm_debug(RDEV, "removing peer %s", rio_name(rdev));2025 found = true;2026 list_del(&peer->node);2027 cm->npeers--;2028 kfree(peer);2029 break;2030 }2031 }2032 2033 up_write(&rdev_sem);2034 2035 if (!found)2036 return;2037 2038 /*2039 * Release channels associated with this peer2040 */2041 2042 spin_lock_bh(&idr_lock);2043 idr_for_each_entry(&ch_idr, ch, i) {2044 if (ch && ch->rdev == rdev) {2045 if (atomic_read(&rdev->state) != RIO_DEVICE_SHUTDOWN)2046 riocm_exch(ch, RIO_CM_DISCONNECT);2047 idr_remove(&ch_idr, ch->id);2048 list_add(&ch->ch_node, &list);2049 }2050 }2051 spin_unlock_bh(&idr_lock);2052 2053 if (!list_empty(&list)) {2054 list_for_each_entry_safe(ch, _c, &list, ch_node) {2055 list_del(&ch->ch_node);2056 riocm_ch_close(ch);2057 }2058 }2059}2060 2061/*2062 * riocm_cdev_add() - Create rio_cm char device2063 * @devno: device number assigned to device (MAJ + MIN)2064 */2065static int riocm_cdev_add(dev_t devno)2066{2067 int ret;2068 2069 cdev_init(&riocm_cdev.cdev, &riocm_cdev_fops);2070 riocm_cdev.cdev.owner = THIS_MODULE;2071 ret = cdev_add(&riocm_cdev.cdev, devno, 1);2072 if (ret < 0) {2073 riocm_error("Cannot register a device with error %d", ret);2074 return ret;2075 }2076 2077 riocm_cdev.dev = device_create(&dev_class, NULL, devno, NULL, DEV_NAME);2078 if (IS_ERR(riocm_cdev.dev)) {2079 cdev_del(&riocm_cdev.cdev);2080 return PTR_ERR(riocm_cdev.dev);2081 }2082 2083 riocm_debug(MPORT, "Added %s cdev(%d:%d)",2084 DEV_NAME, MAJOR(devno), MINOR(devno));2085 2086 return 0;2087}2088 2089/*2090 * riocm_add_mport - add new local mport device into channel management core2091 * @dev: device object associated with mport2092 *2093 * When a new mport device is added, CM immediately reserves inbound and2094 * outbound RapidIO mailboxes that will be used.2095 */2096static int riocm_add_mport(struct device *dev)2097{2098 int rc;2099 int i;2100 struct cm_dev *cm;2101 struct rio_mport *mport = to_rio_mport(dev);2102 2103 riocm_debug(MPORT, "add mport %s", mport->name);2104 2105 cm = kzalloc(sizeof(*cm), GFP_KERNEL);2106 if (!cm)2107 return -ENOMEM;2108 2109 cm->mport = mport;2110 2111 rc = rio_request_outb_mbox(mport, cm, cmbox,2112 RIOCM_TX_RING_SIZE, riocm_outb_msg_event);2113 if (rc) {2114 riocm_error("failed to allocate OBMBOX_%d on %s",2115 cmbox, mport->name);2116 kfree(cm);2117 return -ENODEV;2118 }2119 2120 rc = rio_request_inb_mbox(mport, cm, cmbox,2121 RIOCM_RX_RING_SIZE, riocm_inb_msg_event);2122 if (rc) {2123 riocm_error("failed to allocate IBMBOX_%d on %s",2124 cmbox, mport->name);2125 rio_release_outb_mbox(mport, cmbox);2126 kfree(cm);2127 return -ENODEV;2128 }2129 2130 cm->rx_wq = create_workqueue(DRV_NAME "/rxq");2131 if (!cm->rx_wq) {2132 rio_release_inb_mbox(mport, cmbox);2133 rio_release_outb_mbox(mport, cmbox);2134 kfree(cm);2135 return -ENOMEM;2136 }2137 2138 /*2139 * Allocate and register inbound messaging buffers to be ready2140 * to receive channel and system management requests2141 */2142 for (i = 0; i < RIOCM_RX_RING_SIZE; i++)2143 cm->rx_buf[i] = NULL;2144 2145 cm->rx_slots = RIOCM_RX_RING_SIZE;2146 mutex_init(&cm->rx_lock);2147 riocm_rx_fill(cm, RIOCM_RX_RING_SIZE);2148 INIT_WORK(&cm->rx_work, rio_ibmsg_handler);2149 2150 cm->tx_slot = 0;2151 cm->tx_cnt = 0;2152 cm->tx_ack_slot = 0;2153 spin_lock_init(&cm->tx_lock);2154 2155 INIT_LIST_HEAD(&cm->peers);2156 cm->npeers = 0;2157 INIT_LIST_HEAD(&cm->tx_reqs);2158 2159 down_write(&rdev_sem);2160 list_add_tail(&cm->list, &cm_dev_list);2161 up_write(&rdev_sem);2162 2163 return 0;2164}2165 2166/*2167 * riocm_remove_mport - remove local mport device from channel management core2168 * @dev: device object associated with mport2169 *2170 * Removes a local mport device from the list of registered devices that provide2171 * channel management services. Returns an error if the specified mport is not2172 * registered with the CM core.2173 */2174static void riocm_remove_mport(struct device *dev)2175{2176 struct rio_mport *mport = to_rio_mport(dev);2177 struct cm_dev *cm;2178 struct cm_peer *peer, *temp;2179 struct rio_channel *ch, *_c;2180 unsigned int i;2181 bool found = false;2182 LIST_HEAD(list);2183 2184 riocm_debug(MPORT, "%s", mport->name);2185 2186 /* Find a matching cm_dev object */2187 down_write(&rdev_sem);2188 list_for_each_entry(cm, &cm_dev_list, list) {2189 if (cm->mport == mport) {2190 list_del(&cm->list);2191 found = true;2192 break;2193 }2194 }2195 up_write(&rdev_sem);2196 if (!found)2197 return;2198 2199 flush_workqueue(cm->rx_wq);2200 destroy_workqueue(cm->rx_wq);2201 2202 /* Release channels bound to this mport */2203 spin_lock_bh(&idr_lock);2204 idr_for_each_entry(&ch_idr, ch, i) {2205 if (ch->cmdev == cm) {2206 riocm_debug(RDEV, "%s drop ch_%d",2207 mport->name, ch->id);2208 idr_remove(&ch_idr, ch->id);2209 list_add(&ch->ch_node, &list);2210 }2211 }2212 spin_unlock_bh(&idr_lock);2213 2214 if (!list_empty(&list)) {2215 list_for_each_entry_safe(ch, _c, &list, ch_node) {2216 list_del(&ch->ch_node);2217 riocm_ch_close(ch);2218 }2219 }2220 2221 rio_release_inb_mbox(mport, cmbox);2222 rio_release_outb_mbox(mport, cmbox);2223 2224 /* Remove and free peer entries */2225 if (!list_empty(&cm->peers))2226 riocm_debug(RDEV, "ATTN: peer list not empty");2227 list_for_each_entry_safe(peer, temp, &cm->peers, node) {2228 riocm_debug(RDEV, "removing peer %s", rio_name(peer->rdev));2229 list_del(&peer->node);2230 kfree(peer);2231 }2232 2233 riocm_rx_free(cm);2234 kfree(cm);2235 riocm_debug(MPORT, "%s done", mport->name);2236}2237 2238static int rio_cm_shutdown(struct notifier_block *nb, unsigned long code,2239 void *unused)2240{2241 struct rio_channel *ch;2242 unsigned int i;2243 LIST_HEAD(list);2244 2245 riocm_debug(EXIT, ".");2246 2247 /*2248 * If there are any channels left in connected state send2249 * close notification to the connection partner.2250 * First build a list of channels that require a closing2251 * notification because function riocm_send_close() should2252 * be called outside of spinlock protected code.2253 */2254 spin_lock_bh(&idr_lock);2255 idr_for_each_entry(&ch_idr, ch, i) {2256 if (ch->state == RIO_CM_CONNECTED) {2257 riocm_debug(EXIT, "close ch %d", ch->id);2258 idr_remove(&ch_idr, ch->id);2259 list_add(&ch->ch_node, &list);2260 }2261 }2262 spin_unlock_bh(&idr_lock);2263 2264 list_for_each_entry(ch, &list, ch_node)2265 riocm_send_close(ch);2266 2267 return NOTIFY_DONE;2268}2269 2270/*2271 * riocm_interface handles addition/removal of remote RapidIO devices2272 */2273static struct subsys_interface riocm_interface = {2274 .name = "rio_cm",2275 .subsys = &rio_bus_type,2276 .add_dev = riocm_add_dev,2277 .remove_dev = riocm_remove_dev,2278};2279 2280/*2281 * rio_mport_interface handles addition/removal local mport devices2282 */2283static struct class_interface rio_mport_interface __refdata = {2284 .class = &rio_mport_class,2285 .add_dev = riocm_add_mport,2286 .remove_dev = riocm_remove_mport,2287};2288 2289static struct notifier_block rio_cm_notifier = {2290 .notifier_call = rio_cm_shutdown,2291};2292 2293static int __init riocm_init(void)2294{2295 int ret;2296 2297 /* Create device class needed by udev */2298 ret = class_register(&dev_class);2299 if (ret) {2300 riocm_error("Cannot create " DRV_NAME " class");2301 return ret;2302 }2303 2304 ret = alloc_chrdev_region(&dev_number, 0, 1, DRV_NAME);2305 if (ret) {2306 class_unregister(&dev_class);2307 return ret;2308 }2309 2310 dev_major = MAJOR(dev_number);2311 dev_minor_base = MINOR(dev_number);2312 riocm_debug(INIT, "Registered class with %d major", dev_major);2313 2314 /*2315 * Register as rapidio_port class interface to get notifications about2316 * mport additions and removals.2317 */2318 ret = class_interface_register(&rio_mport_interface);2319 if (ret) {2320 riocm_error("class_interface_register error: %d", ret);2321 goto err_reg;2322 }2323 2324 /*2325 * Register as RapidIO bus interface to get notifications about2326 * addition/removal of remote RapidIO devices.2327 */2328 ret = subsys_interface_register(&riocm_interface);2329 if (ret) {2330 riocm_error("subsys_interface_register error: %d", ret);2331 goto err_cl;2332 }2333 2334 ret = register_reboot_notifier(&rio_cm_notifier);2335 if (ret) {2336 riocm_error("failed to register reboot notifier (err=%d)", ret);2337 goto err_sif;2338 }2339 2340 ret = riocm_cdev_add(dev_number);2341 if (ret) {2342 unregister_reboot_notifier(&rio_cm_notifier);2343 ret = -ENODEV;2344 goto err_sif;2345 }2346 2347 return 0;2348err_sif:2349 subsys_interface_unregister(&riocm_interface);2350err_cl:2351 class_interface_unregister(&rio_mport_interface);2352err_reg:2353 unregister_chrdev_region(dev_number, 1);2354 class_unregister(&dev_class);2355 return ret;2356}2357 2358static void __exit riocm_exit(void)2359{2360 riocm_debug(EXIT, "enter");2361 unregister_reboot_notifier(&rio_cm_notifier);2362 subsys_interface_unregister(&riocm_interface);2363 class_interface_unregister(&rio_mport_interface);2364 idr_destroy(&ch_idr);2365 2366 device_unregister(riocm_cdev.dev);2367 cdev_del(&(riocm_cdev.cdev));2368 2369 class_unregister(&dev_class);2370 unregister_chrdev_region(dev_number, 1);2371}2372 2373late_initcall(riocm_init);2374module_exit(riocm_exit);2375