?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/tests: hdmi: Fix memory leaks in drm_display_mode_from_cea_vic()
[drm/drm-misc.git] / drivers / rapidio / rio_cm.c
blob9135227301c8d6117cd590f6c4eaed78a4da8036
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);
Kernel DRM miscellaneous fixes and cross-tree changes