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