drivers/rapidio/rio_cm.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * rio_cm - RapidIO Channelized Messaging Driver
   4  *
   5  * Copyright 2013-2016 Integrated Device Technology, Inc.
   6  * Copyright (c) 2015, Prodrive Technologies
   7  * Copyright (c) 2015, RapidIO Trade Association
   8  */
   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 */
  35 enum {
  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 DEBUG
  51 #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 #else
  58 #define riocm_debug(level, fmt, arg...) \
  59                 no_printk(KERN_DEBUG pr_fmt(DRV_NAME fmt "\n"), ##arg)
  60 #endif
  61
  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
  69 static int cmbox = 1;
  70 module_param(cmbox, int, S_IRUGO);
  71 MODULE_PARM_DESC(cmbox, "RapidIO Mailbox number (default 1)");
  72
  73 static int chstart = 256;
  74 module_param(chstart, int, S_IRUGO);
  75 MODULE_PARM_DESC(chstart,
  76                  "Start channel number for dynamic allocation (default 256)");
  77
  78 #ifdef DEBUG
  79 static u32 dbg_level = DBG_NONE;
  80 module_param(dbg_level, uint, S_IWUSR | S_IRUGO);
  81 MODULE_PARM_DESC(dbg_level, "Debugging output level (default 0 = none)");
  82 #endif
  83
  84 MODULE_AUTHOR(DRV_AUTHOR);
  85 MODULE_DESCRIPTION(DRV_DESC);
  86 MODULE_LICENSE("GPL");
  87 MODULE_VERSION(DRV_VERSION);
  88
  89 #define RIOCM_TX_RING_SIZE      128
  90 #define RIOCM_RX_RING_SIZE      128
  91 #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        0
  95 #define RIOCM_MAX_EP_COUNT      0x10000 /* Max number of endpoints */
  96
  97 enum 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
 107 enum rio_cm_pkt_type {
 108         RIO_CM_SYS      = 0xaa,
 109         RIO_CM_CHAN     = 0x55,
 110 };
 111
 112 enum rio_cm_chop {
 113         CM_CONN_REQ,
 114         CM_CONN_ACK,
 115         CM_CONN_CLOSE,
 116         CM_DATA_MSG,
 117 };
 118
 119 struct rio_ch_base_bhdr {
 120         u32 src_id;
 121         u32 dst_id;
 122 #define RIO_HDR_LETTER_MASK 0xffff0000
 123 #define RIO_HDR_MBOX_MASK   0x0000ffff
 124         u8  src_mbox;
 125         u8  dst_mbox;
 126         u8  type;
 127 } __attribute__((__packed__));
 128
 129 struct 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
 138 struct tx_req {
 139         struct list_head node;
 140         struct rio_dev   *rdev;
 141         void             *buffer;
 142         size_t           len;
 143 };
 144
 145 struct 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
 165 struct 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
 176 struct 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
 196 struct cm_peer {
 197         struct list_head node;
 198         struct rio_dev *rdev;
 199 };
 200
 201 struct rio_cm_work {
 202         struct work_struct work;
 203         struct cm_dev *cm;
 204         void *data;
 205 };
 206
 207 struct 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_CDEV
 216  * @cdev        Character device
 217  * @dev         Associated device object
 218  */
 219 struct channel_dev {
 220         struct cdev     cdev;
 221         struct device   *dev;
 222 };
 223
 224 static struct rio_channel *riocm_ch_alloc(u16 ch_num);
 225 static void riocm_ch_free(struct kref *ref);
 226 static int riocm_post_send(struct cm_dev *cm, struct rio_dev *rdev,
 227                            void *buffer, size_t len);
 228 static int riocm_ch_close(struct rio_channel *ch);
 229
 230 static DEFINE_SPINLOCK(idr_lock);
 231 static DEFINE_IDR(ch_idr);
 232
 233 static LIST_HEAD(cm_dev_list);
 234 static DECLARE_RWSEM(rdev_sem);
 235
 236 static const struct class dev_class = {
 237         .name = DRV_NAME,
 238 };
 239 static unsigned int dev_major;
 240 static unsigned int dev_minor_base;
 241 static dev_t dev_number;
 242 static 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
 250 static 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
 260 static 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
 273 static 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
 285 static 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
 297 static void riocm_put_channel(struct rio_channel *ch)
 298 {
 299         kref_put(&ch->ref, riocm_ch_free);
 300 }
 301
 302 static 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 device
 326  * @cm: cm_dev object
 327  * @nent: max number of entries to fill
 328  *
 329  * Returns: none
 330  */
 331 static 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 device
 352  * @cm: cm_dev object
 353  *
 354  * Returns: none
 355  */
 356 static 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 handler
 370  * @cm: cm_dev object
 371  * @req_data: pointer to the request packet
 372  *
 373  * Returns: 0 if success, or
 374  *          -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 request
 377  */
 378 static 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 handler
 419  * @resp_data: pointer to the response packet
 420  *
 421  * Returns: 0 if success, or
 422  *          -EINVAL if channel is not in correct state,
 423  *          -ENODEV if cannot find a channel with specified ID,
 424  */
 425 static 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 handler
 451  * @req_data: pointer to the request packet
 452  *
 453  * Returns: 0 if success, or
 454  *          -ENODEV if cannot find a channel with specified ID,
 455  *            + error codes returned by riocm_ch_close.
 456  */
 457 static 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) packets
 485  * @cm: cm_dev object
 486  * @data: pointer to the packet
 487  */
 488 static 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         }
 514 out:
 515         kfree(data);
 516 }
 517
 518 /*
 519  * rio_rx_data_handler - received data packet handler
 520  * @cm: cm_dev object
 521  * @buf: data packet
 522  *
 523  * Returns: 0 if success, or
 524  *          -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  */
 528 static 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 handler
 581  */
 582 static 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                 else
 615                         rio_cm_handler(cm, data);
 616         }
 617 }
 618
 619 static 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 handler
 630  * @cm: cm_dev object
 631  * @slot: TX queue slot
 632  *
 633  * TX completion handler also ensures that pending request packets are placed
 634  * into transmit queue as soon as a free slot becomes available. This is done
 635  * to give higher priority to request packets during high intensity data flow.
 636  */
 637 static 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 buffer
 642          * transfer is implemented. At this moment only correct tracking
 643          * 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 queue
 672          */
 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
 696 static 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
 705 static 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 queue
 727  * @cm: cm_dev object
 728  * @rdev: target RapidIO device object (required by outbound msg interface)
 729  * @buffer: pointer to a packet buffer to send
 730  * @len: length of data to transfer
 731  * @req: request priority flag
 732  *
 733  * Returns: 0 if success, or error code otherwise.
 734  */
 735 static 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
 764 err_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 device
 771  * @ch_id: local channel ID
 772  * @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 PACKET
 776  *
 777  * Returns: 0 if success, or
 778  *          -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  */
 783 static 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 data
 806          */
 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 underlying
 820          * HW-specific add_outb_message() routine copies TX data into its own
 821          * internal transfer buffer (true for all RIONET compatible mport
 822          * 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);
 828 err_out:
 829         riocm_put_channel(ch);
 830         return ret;
 831 }
 832
 833 static 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 channel
 858  * @ch: local channel ID
 859  * @buf: pointer to a packet buffer
 860  * @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  */
 868 static 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 upper
 881                  * 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         else
 896                 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);
 926 out:
 927         *buf = rxmsg;
 928         return ret;
 929 }
 930
 931 /*
 932  * riocm_ch_connect - sends a connect request to a remote device
 933  * @loc_ch: local channel ID
 934  * @cm: CM device to send connect request
 935  * @peer: target RapidIO device
 936  * @rem_ch: remote channel ID
 937  *
 938  * Returns: 0 if success, or
 939  *          -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  */
 944 static 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 device
 969          */
 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 underlying
 987          * HW-specific add_outb_message() routine copies TX data into its
 988          * internal transfer buffer. Must be reviewed if mport driver uses
 989          * 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         else
1016                 ret = riocm_cmp(ch, RIO_CM_CONNECTED) ? 0 : -1;
1017
1018 conn_done:
1019         riocm_put_channel(ch);
1020         return ret;
1021 }
1022
1023 static 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 underlying
1042          * add_outb_message() routine copies TX data into its internal transfer
1043          * 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 request
1060  * @ch_id: channel ID
1061  * @new_ch_id: local mport device
1062  * @timeout: wait timeout (if 0 non-blocking call, do not wait if connection
1063  *           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  */
1073 static 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
1182 err_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
1188 err_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 state
1197  * @ch_id: channel ID
1198  *
1199  * Returns: 0 if success, or
1200  *          -EINVAL if the specified channel does not exists or
1201  *                  is not in CHAN_BOUND state.
1202  */
1203 static 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 device
1221  * @ch_id: channel ID
1222  * @mport_id: local mport device ID
1223  * @context: pointer to the additional caller's context
1224  *
1225  * Returns: 0 if success, or
1226  *          -ENODEV if cannot find specified mport,
1227  *          -EINVAL if the specified channel does not exist or
1228  *                  is not in IDLE state.
1229  */
1230 static 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);
1269 err_put:
1270         riocm_put_channel(ch);
1271 exit:
1272         up_read(&rdev_sem);
1273         return rc;
1274 }
1275
1276 /*
1277  * riocm_ch_alloc - channel object allocation helper routine
1278  * @ch_num: channel ID (1 ... RIOCM_MAX_CHNUM, 0 = automatic)
1279  *
1280  * Return value: pointer to newly created channel object,
1281  *               or error-valued pointer
1282  */
1283 static 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 it
1332  * @ch_num: channel ID (1 ... RIOCM_MAX_CHNUM, 0 = automatic)
1333  *
1334  * Allocates and initializes a new channel object. If the parameter ch_num > 0
1335  * and is within the valid range, riocm_ch_create tries to allocate the
1336  * specified ID for the new channel. If ch_num = 0, channel ID will be assigned
1337  * automatically from the range (chstart ... RIOCM_MAX_CHNUM).
1338  * Module parameter 'chstart' defines start of an ID range available for dynamic
1339  * allocation. Range below 'chstart' is reserved for pre-defined ID numbers.
1340  * Available channel numbers are limited by 16-bit size of channel numbers used
1341  * in the packet header.
1342  *
1343  * Return value: PTR to rio_channel structure if successful (with channel number
1344  *               updated via pointer) or error-valued pointer if error.
1345  */
1346 static 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         else
1356                 *ch_num = ch->id;
1357
1358         return ch;
1359 }
1360
1361 /*
1362  * riocm_ch_free - channel object release routine
1363  * @ref: pointer to a channel's kref structure
1364  */
1365 static 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
1393 static 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 device
1400          */
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 underlying
1416          * add_outb_message() routine copies TX data into its internal transfer
1417          * 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 closed
1435  */
1436 static 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 device
1481  */
1482 static 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 device
1495  */
1496 static 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 network
1530  */
1531 static 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 endpoints
1561  */
1562 static 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
1588 found:
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 devices
1617  */
1618 static 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 channel
1657  */
1658 static 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 channel
1681  * @filp:       Pointer to file object
1682  * @arg:        Channel to close
1683  */
1684 static 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 channel
1714  * @arg:        Channel number
1715  */
1716 static 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 channel
1730  * @arg:        Channel number
1731  */
1732 static 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 connection
1745  * @filp:       Pointer to file object
1746  * @arg:        Channel number
1747  */
1748 static 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(&param, 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, &param.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, &param, sizeof(param)))
1772                 return -EFAULT;
1773         return 0;
1774 }
1775
1776 /*
1777  * cm_chan_connect() - Connect on channel
1778  * @arg:        Channel information
1779  */
1780 static 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);
1826 err_out:
1827         up_read(&rdev_sem);
1828         return ret;
1829 }
1830
1831 /*
1832  * cm_chan_msg_send() - Send a message through channel
1833  * @arg:        Outbound message information
1834  */
1835 static 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 channel
1858  * @arg:        Inbound message information
1859  */
1860 static 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);
1890 out:
1891         riocm_put_channel(ch);
1892         return ret;
1893 }
1894
1895 /*
1896  * riocm_cdev_ioctl() - IOCTL requests handler
1897  */
1898 static long
1899 riocm_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
1931 static 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 core
1940  * @dev: device object associated with RapidIO device
1941  * @sif: subsystem interface
1942  *
1943  * Adds the specified RapidIO device (if applicable) into peers list of
1944  * the corresponding channel management device (cm_dev).
1945  */
1946 static 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
1973 found:
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 core
1984  * @dev: device object associated with RapidIO device
1985  * @sif: subsystem interface
1986  *
1987  * Removes the specified RapidIO device (if applicable) from peers list of
1988  * the corresponding channel management device (cm_dev).
1989  */
1990 static 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 peer
2040          */
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 device
2063  * @devno: device number assigned to device (MAJ + MIN)
2064  */
2065 static 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 core
2091  * @dev: device object associated with mport
2092  *
2093  * When a new mport device is added, CM immediately reserves inbound and
2094  * outbound RapidIO mailboxes that will be used.
2095  */
2096 static 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 ready
2140          * to receive channel and system management requests
2141          */
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 core
2168  * @dev: device object associated with mport
2169  *
2170  * Removes a local mport device from the list of registered devices that provide
2171  * channel management services. Returns an error if the specified mport is not
2172  * registered with the CM core.
2173  */
2174 static 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
2238 static 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 send
2249          * close notification to the connection partner.
2250          * First build a list of channels that require a closing
2251          * notification because function riocm_send_close() should
2252          * 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 devices
2272  */
2273 static 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 devices
2282  */
2283 static 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
2289 static struct notifier_block rio_cm_notifier = {
2290         .notifier_call = rio_cm_shutdown,
2291 };
2292
2293 static 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 about
2316          * 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 about
2326          * 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;
2348 err_sif:
2349         subsys_interface_unregister(&riocm_interface);
2350 err_cl:
2351         class_interface_unregister(&rio_mport_interface);
2352 err_reg:
2353         unregister_chrdev_region(dev_number, 1);
2354         class_unregister(&dev_class);
2355         return ret;
2356 }
2357
2358 static 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
2373 late_initcall(riocm_init);
2374 module_exit(riocm_exit);