1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/types.h>
22#include <linux/kernel.h>
23
24#include <linux/delay.h>
25#include <linux/dma-mapping.h>
26#include <linux/init.h>
27#include <linux/rio.h>
28#include <linux/rio_drv.h>
29#include <linux/rio_ids.h>
30#include <linux/rio_regs.h>
31#include <linux/module.h>
32#include <linux/spinlock.h>
33#include <linux/timer.h>
34#include <linux/sched.h>
35#include <linux/jiffies.h>
36#include <linux/slab.h>
37
38#include "rio.h"
39
40static void rio_init_em(struct rio_dev *rdev);
41
42static int next_destid = 0;
43static int next_comptag = 1;
44
45static int rio_mport_phys_table[] = {
46 RIO_EFB_PAR_EP_ID,
47 RIO_EFB_PAR_EP_REC_ID,
48 RIO_EFB_SER_EP_ID,
49 RIO_EFB_SER_EP_REC_ID,
50 -1,
51};
52
53
54
55
56
57
58
59
60
61
62static u16 rio_destid_alloc(struct rio_net *net)
63{
64 int destid;
65 struct rio_id_table *idtab = &net->destid_table;
66
67 spin_lock(&idtab->lock);
68 destid = find_first_zero_bit(idtab->table, idtab->max);
69
70 if (destid < idtab->max) {
71 set_bit(destid, idtab->table);
72 destid += idtab->start;
73 } else
74 destid = RIO_INVALID_DESTID;
75
76 spin_unlock(&idtab->lock);
77 return (u16)destid;
78}
79
80
81
82
83
84
85
86
87
88static int rio_destid_reserve(struct rio_net *net, u16 destid)
89{
90 int oldbit;
91 struct rio_id_table *idtab = &net->destid_table;
92
93 destid -= idtab->start;
94 spin_lock(&idtab->lock);
95 oldbit = test_and_set_bit(destid, idtab->table);
96 spin_unlock(&idtab->lock);
97 return oldbit;
98}
99
100
101
102
103
104
105
106
107static void rio_destid_free(struct rio_net *net, u16 destid)
108{
109 struct rio_id_table *idtab = &net->destid_table;
110
111 destid -= idtab->start;
112 spin_lock(&idtab->lock);
113 clear_bit(destid, idtab->table);
114 spin_unlock(&idtab->lock);
115}
116
117
118
119
120
121static u16 rio_destid_first(struct rio_net *net)
122{
123 int destid;
124 struct rio_id_table *idtab = &net->destid_table;
125
126 spin_lock(&idtab->lock);
127 destid = find_first_bit(idtab->table, idtab->max);
128 if (destid >= idtab->max)
129 destid = RIO_INVALID_DESTID;
130 else
131 destid += idtab->start;
132 spin_unlock(&idtab->lock);
133 return (u16)destid;
134}
135
136
137
138
139
140
141static u16 rio_destid_next(struct rio_net *net, u16 from)
142{
143 int destid;
144 struct rio_id_table *idtab = &net->destid_table;
145
146 spin_lock(&idtab->lock);
147 destid = find_next_bit(idtab->table, idtab->max, from);
148 if (destid >= idtab->max)
149 destid = RIO_INVALID_DESTID;
150 else
151 destid += idtab->start;
152 spin_unlock(&idtab->lock);
153 return (u16)destid;
154}
155
156
157
158
159
160
161
162
163
164
165static u16 rio_get_device_id(struct rio_mport *port, u16 destid, u8 hopcount)
166{
167 u32 result;
168
169 rio_mport_read_config_32(port, destid, hopcount, RIO_DID_CSR, &result);
170
171 return RIO_GET_DID(port->sys_size, result);
172}
173
174
175
176
177
178
179
180
181
182
183static void rio_set_device_id(struct rio_mport *port, u16 destid, u8 hopcount, u16 did)
184{
185 rio_mport_write_config_32(port, destid, hopcount, RIO_DID_CSR,
186 RIO_SET_DID(port->sys_size, did));
187}
188
189
190
191
192
193
194
195
196static void rio_local_set_device_id(struct rio_mport *port, u16 did)
197{
198 rio_local_write_config_32(port, RIO_DID_CSR, RIO_SET_DID(port->sys_size,
199 did));
200}
201
202
203
204
205
206
207
208
209
210static int rio_clear_locks(struct rio_net *net)
211{
212 struct rio_mport *port = net->hport;
213 struct rio_dev *rdev;
214 u32 result;
215 int ret = 0;
216
217
218 rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR,
219 port->host_deviceid);
220 rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result);
221 if ((result & 0xffff) != 0xffff) {
222 printk(KERN_INFO
223 "RIO: badness when releasing host lock on master port, result %8.8x\n",
224 result);
225 ret = -EINVAL;
226 }
227 list_for_each_entry(rdev, &net->devices, net_list) {
228 rio_write_config_32(rdev, RIO_HOST_DID_LOCK_CSR,
229 port->host_deviceid);
230 rio_read_config_32(rdev, RIO_HOST_DID_LOCK_CSR, &result);
231 if ((result & 0xffff) != 0xffff) {
232 printk(KERN_INFO
233 "RIO: badness when releasing host lock on vid %4.4x did %4.4x\n",
234 rdev->vid, rdev->did);
235 ret = -EINVAL;
236 }
237
238
239 rio_read_config_32(rdev,
240 rdev->phys_efptr + RIO_PORT_GEN_CTL_CSR,
241 &result);
242 result |= RIO_PORT_GEN_DISCOVERED | RIO_PORT_GEN_MASTER;
243 rio_write_config_32(rdev,
244 rdev->phys_efptr + RIO_PORT_GEN_CTL_CSR,
245 result);
246 }
247
248 return ret;
249}
250
251
252
253
254
255
256
257
258
259static int rio_enum_host(struct rio_mport *port)
260{
261 u32 result;
262
263
264 rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR,
265 port->host_deviceid);
266
267 rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result);
268 if ((result & 0xffff) != port->host_deviceid)
269 return -1;
270
271
272 rio_local_set_device_id(port, port->host_deviceid);
273 return 0;
274}
275
276
277
278
279
280
281
282
283
284
285
286static int rio_device_has_destid(struct rio_mport *port, int src_ops,
287 int dst_ops)
288{
289 u32 mask = RIO_OPS_READ | RIO_OPS_WRITE | RIO_OPS_ATOMIC_TST_SWP | RIO_OPS_ATOMIC_INC | RIO_OPS_ATOMIC_DEC | RIO_OPS_ATOMIC_SET | RIO_OPS_ATOMIC_CLR;
290
291 return !!((src_ops | dst_ops) & mask);
292}
293
294
295
296
297
298
299
300
301static void rio_release_dev(struct device *dev)
302{
303 struct rio_dev *rdev;
304
305 rdev = to_rio_dev(dev);
306 kfree(rdev);
307}
308
309
310
311
312
313
314
315
316
317
318static int rio_is_switch(struct rio_dev *rdev)
319{
320 if (rdev->pef & RIO_PEF_SWITCH)
321 return 1;
322 return 0;
323}
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341static struct rio_dev *rio_setup_device(struct rio_net *net,
342 struct rio_mport *port, u16 destid,
343 u8 hopcount, int do_enum)
344{
345 int ret = 0;
346 struct rio_dev *rdev;
347 struct rio_switch *rswitch = NULL;
348 int result, rdid;
349 size_t size;
350 u32 swpinfo = 0;
351
352 size = sizeof(struct rio_dev);
353 if (rio_mport_read_config_32(port, destid, hopcount,
354 RIO_PEF_CAR, &result))
355 return NULL;
356
357 if (result & (RIO_PEF_SWITCH | RIO_PEF_MULTIPORT)) {
358 rio_mport_read_config_32(port, destid, hopcount,
359 RIO_SWP_INFO_CAR, &swpinfo);
360 if (result & RIO_PEF_SWITCH) {
361 size += (RIO_GET_TOTAL_PORTS(swpinfo) *
362 sizeof(rswitch->nextdev[0])) + sizeof(*rswitch);
363 }
364 }
365
366 rdev = kzalloc(size, GFP_KERNEL);
367 if (!rdev)
368 return NULL;
369
370 rdev->net = net;
371 rdev->pef = result;
372 rdev->swpinfo = swpinfo;
373 rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_ID_CAR,
374 &result);
375 rdev->did = result >> 16;
376 rdev->vid = result & 0xffff;
377 rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_INFO_CAR,
378 &rdev->device_rev);
379 rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_ID_CAR,
380 &result);
381 rdev->asm_did = result >> 16;
382 rdev->asm_vid = result & 0xffff;
383 rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_INFO_CAR,
384 &result);
385 rdev->asm_rev = result >> 16;
386 if (rdev->pef & RIO_PEF_EXT_FEATURES) {
387 rdev->efptr = result & 0xffff;
388 rdev->phys_efptr = rio_mport_get_physefb(port, 0, destid,
389 hopcount);
390
391 rdev->em_efptr = rio_mport_get_feature(port, 0, destid,
392 hopcount, RIO_EFB_ERR_MGMNT);
393 }
394
395 rio_mport_read_config_32(port, destid, hopcount, RIO_SRC_OPS_CAR,
396 &rdev->src_ops);
397 rio_mport_read_config_32(port, destid, hopcount, RIO_DST_OPS_CAR,
398 &rdev->dst_ops);
399
400 if (do_enum) {
401
402 if (next_comptag >= 0x10000) {
403 pr_err("RIO: Component Tag Counter Overflow\n");
404 goto cleanup;
405 }
406 rio_mport_write_config_32(port, destid, hopcount,
407 RIO_COMPONENT_TAG_CSR, next_comptag);
408 rdev->comp_tag = next_comptag++;
409 rdev->do_enum = true;
410 } else {
411 rio_mport_read_config_32(port, destid, hopcount,
412 RIO_COMPONENT_TAG_CSR,
413 &rdev->comp_tag);
414 }
415
416 if (rio_device_has_destid(port, rdev->src_ops, rdev->dst_ops)) {
417 if (do_enum) {
418 rio_set_device_id(port, destid, hopcount, next_destid);
419 rdev->destid = next_destid;
420 next_destid = rio_destid_alloc(net);
421 } else
422 rdev->destid = rio_get_device_id(port, destid, hopcount);
423
424 rdev->hopcount = 0xff;
425 } else {
426
427
428
429 rdev->destid = destid;
430 rdev->hopcount = hopcount;
431 }
432
433
434 if (rio_is_switch(rdev)) {
435 rswitch = rdev->rswitch;
436 rswitch->port_ok = 0;
437 spin_lock_init(&rswitch->lock);
438 rswitch->route_table = kzalloc(sizeof(u8)*
439 RIO_MAX_ROUTE_ENTRIES(port->sys_size),
440 GFP_KERNEL);
441 if (!rswitch->route_table)
442 goto cleanup;
443
444 for (rdid = 0; rdid < RIO_MAX_ROUTE_ENTRIES(port->sys_size);
445 rdid++)
446 rswitch->route_table[rdid] = RIO_INVALID_ROUTE;
447 dev_set_name(&rdev->dev, "%02x:s:%04x", rdev->net->id,
448 rdev->comp_tag & RIO_CTAG_UDEVID);
449
450 if (do_enum)
451 rio_route_clr_table(rdev, RIO_GLOBAL_TABLE, 0);
452
453 list_add_tail(&rswitch->node, &net->switches);
454
455 } else {
456 if (do_enum)
457
458 rio_enable_rx_tx_port(port, 0, destid, hopcount, 0);
459
460 dev_set_name(&rdev->dev, "%02x:e:%04x", rdev->net->id,
461 rdev->comp_tag & RIO_CTAG_UDEVID);
462 }
463
464 rio_attach_device(rdev);
465
466 device_initialize(&rdev->dev);
467 rdev->dev.release = rio_release_dev;
468 rio_dev_get(rdev);
469
470 rdev->dma_mask = DMA_BIT_MASK(32);
471 rdev->dev.dma_mask = &rdev->dma_mask;
472 rdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
473
474 if (rdev->dst_ops & RIO_DST_OPS_DOORBELL)
475 rio_init_dbell_res(&rdev->riores[RIO_DOORBELL_RESOURCE],
476 0, 0xffff);
477
478 ret = rio_add_device(rdev);
479 if (ret)
480 goto cleanup;
481
482 return rdev;
483
484cleanup:
485 if (rswitch)
486 kfree(rswitch->route_table);
487
488 kfree(rdev);
489 return NULL;
490}
491
492
493
494
495
496
497
498
499
500
501
502
503
504static int
505rio_sport_is_active(struct rio_mport *port, u16 destid, u8 hopcount, int sport)
506{
507 u32 result = 0;
508 u32 ext_ftr_ptr;
509
510 ext_ftr_ptr = rio_mport_get_efb(port, 0, destid, hopcount, 0);
511
512 while (ext_ftr_ptr) {
513 rio_mport_read_config_32(port, destid, hopcount,
514 ext_ftr_ptr, &result);
515 result = RIO_GET_BLOCK_ID(result);
516 if ((result == RIO_EFB_SER_EP_FREE_ID) ||
517 (result == RIO_EFB_SER_EP_FREE_ID_V13P) ||
518 (result == RIO_EFB_SER_EP_FREC_ID))
519 break;
520
521 ext_ftr_ptr = rio_mport_get_efb(port, 0, destid, hopcount,
522 ext_ftr_ptr);
523 }
524
525 if (ext_ftr_ptr)
526 rio_mport_read_config_32(port, destid, hopcount,
527 ext_ftr_ptr +
528 RIO_PORT_N_ERR_STS_CSR(sport),
529 &result);
530
531 return result & RIO_PORT_N_ERR_STS_PORT_OK;
532}
533
534
535
536
537
538
539
540
541
542static u16 rio_get_host_deviceid_lock(struct rio_mport *port, u8 hopcount)
543{
544 u32 result;
545
546 rio_mport_read_config_32(port, RIO_ANY_DESTID(port->sys_size), hopcount,
547 RIO_HOST_DID_LOCK_CSR, &result);
548
549 return (u16) (result & 0xffff);
550}
551
552
553
554
555
556
557
558
559
560
561
562
563static int rio_enum_peer(struct rio_net *net, struct rio_mport *port,
564 u8 hopcount, struct rio_dev *prev, int prev_port)
565{
566 struct rio_dev *rdev;
567 u32 regval;
568 int tmp;
569
570 if (rio_mport_chk_dev_access(port,
571 RIO_ANY_DESTID(port->sys_size), hopcount)) {
572 pr_debug("RIO: device access check failed\n");
573 return -1;
574 }
575
576 if (rio_get_host_deviceid_lock(port, hopcount) == port->host_deviceid) {
577 pr_debug("RIO: PE already discovered by this host\n");
578
579
580
581
582 rio_mport_read_config_32(port, RIO_ANY_DESTID(port->sys_size),
583 hopcount, RIO_COMPONENT_TAG_CSR, ®val);
584
585 if (regval) {
586 rdev = rio_get_comptag((regval & 0xffff), NULL);
587
588 if (rdev && prev && rio_is_switch(prev)) {
589 pr_debug("RIO: redundant path to %s\n",
590 rio_name(rdev));
591 prev->rswitch->nextdev[prev_port] = rdev;
592 }
593 }
594
595 return 0;
596 }
597
598
599 rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size),
600 hopcount,
601 RIO_HOST_DID_LOCK_CSR, port->host_deviceid);
602 while ((tmp = rio_get_host_deviceid_lock(port, hopcount))
603 < port->host_deviceid) {
604
605 mdelay(1);
606
607 rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size),
608 hopcount,
609 RIO_HOST_DID_LOCK_CSR,
610 port->host_deviceid);
611 }
612
613 if (rio_get_host_deviceid_lock(port, hopcount) > port->host_deviceid) {
614 pr_debug(
615 "RIO: PE locked by a higher priority host...retreating\n");
616 return -1;
617 }
618
619
620 rdev = rio_setup_device(net, port, RIO_ANY_DESTID(port->sys_size),
621 hopcount, 1);
622 if (rdev) {
623
624 list_add_tail(&rdev->net_list, &net->devices);
625 rdev->prev = prev;
626 if (prev && rio_is_switch(prev))
627 prev->rswitch->nextdev[prev_port] = rdev;
628 } else
629 return -1;
630
631 if (rio_is_switch(rdev)) {
632 int sw_destid;
633 int cur_destid;
634 int sw_inport;
635 u16 destid;
636 int port_num;
637
638 sw_inport = RIO_GET_PORT_NUM(rdev->swpinfo);
639 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
640 port->host_deviceid, sw_inport, 0);
641 rdev->rswitch->route_table[port->host_deviceid] = sw_inport;
642
643 destid = rio_destid_first(net);
644 while (destid != RIO_INVALID_DESTID && destid < next_destid) {
645 if (destid != port->host_deviceid) {
646 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
647 destid, sw_inport, 0);
648 rdev->rswitch->route_table[destid] = sw_inport;
649 }
650 destid = rio_destid_next(net, destid + 1);
651 }
652 pr_debug(
653 "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n",
654 rio_name(rdev), rdev->vid, rdev->did,
655 RIO_GET_TOTAL_PORTS(rdev->swpinfo));
656 sw_destid = next_destid;
657 for (port_num = 0;
658 port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo);
659 port_num++) {
660 if (sw_inport == port_num) {
661 rio_enable_rx_tx_port(port, 0,
662 RIO_ANY_DESTID(port->sys_size),
663 hopcount, port_num);
664 rdev->rswitch->port_ok |= (1 << port_num);
665 continue;
666 }
667
668 cur_destid = next_destid;
669
670 if (rio_sport_is_active
671 (port, RIO_ANY_DESTID(port->sys_size), hopcount,
672 port_num)) {
673 pr_debug(
674 "RIO: scanning device on port %d\n",
675 port_num);
676 rio_enable_rx_tx_port(port, 0,
677 RIO_ANY_DESTID(port->sys_size),
678 hopcount, port_num);
679 rdev->rswitch->port_ok |= (1 << port_num);
680 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
681 RIO_ANY_DESTID(port->sys_size),
682 port_num, 0);
683
684 if (rio_enum_peer(net, port, hopcount + 1,
685 rdev, port_num) < 0)
686 return -1;
687
688
689 destid = rio_destid_next(net, cur_destid + 1);
690 if (destid != RIO_INVALID_DESTID) {
691 for (destid = cur_destid;
692 destid < next_destid;) {
693 if (destid != port->host_deviceid) {
694 rio_route_add_entry(rdev,
695 RIO_GLOBAL_TABLE,
696 destid,
697 port_num,
698 0);
699 rdev->rswitch->
700 route_table[destid] =
701 port_num;
702 }
703 destid = rio_destid_next(net,
704 destid + 1);
705 }
706 }
707 } else {
708
709
710
711 if (rdev->em_efptr)
712 rio_set_port_lockout(rdev, port_num, 1);
713
714 rdev->rswitch->port_ok &= ~(1 << port_num);
715 }
716 }
717
718
719 if ((rdev->src_ops & RIO_SRC_OPS_PORT_WRITE) &&
720 (rdev->em_efptr)) {
721 rio_write_config_32(rdev,
722 rdev->em_efptr + RIO_EM_PW_TGT_DEVID,
723 (port->host_deviceid << 16) |
724 (port->sys_size << 15));
725 }
726
727 rio_init_em(rdev);
728
729
730 if (next_destid == sw_destid)
731 next_destid = rio_destid_alloc(net);
732
733 rdev->destid = sw_destid;
734 } else
735 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n",
736 rio_name(rdev), rdev->vid, rdev->did);
737
738 return 0;
739}
740
741
742
743
744
745
746
747
748
749static int rio_enum_complete(struct rio_mport *port)
750{
751 u32 regval;
752
753 rio_local_read_config_32(port, port->phys_efptr + RIO_PORT_GEN_CTL_CSR,
754 ®val);
755 return (regval & RIO_PORT_GEN_DISCOVERED) ? 1 : 0;
756}
757
758
759
760
761
762
763
764
765
766
767
768
769
770static int
771rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid,
772 u8 hopcount, struct rio_dev *prev, int prev_port)
773{
774 u8 port_num, route_port;
775 struct rio_dev *rdev;
776 u16 ndestid;
777
778
779 if ((rdev = rio_setup_device(net, port, destid, hopcount, 0))) {
780
781 list_add_tail(&rdev->net_list, &net->devices);
782 rdev->prev = prev;
783 if (prev && rio_is_switch(prev))
784 prev->rswitch->nextdev[prev_port] = rdev;
785 } else
786 return -1;
787
788 if (rio_is_switch(rdev)) {
789
790 rdev->destid = destid;
791
792 pr_debug(
793 "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n",
794 rio_name(rdev), rdev->vid, rdev->did,
795 RIO_GET_TOTAL_PORTS(rdev->swpinfo));
796 for (port_num = 0;
797 port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo);
798 port_num++) {
799 if (RIO_GET_PORT_NUM(rdev->swpinfo) == port_num)
800 continue;
801
802 if (rio_sport_is_active
803 (port, destid, hopcount, port_num)) {
804 pr_debug(
805 "RIO: scanning device on port %d\n",
806 port_num);
807
808 rio_lock_device(port, destid, hopcount, 1000);
809
810 for (ndestid = 0;
811 ndestid < RIO_ANY_DESTID(port->sys_size);
812 ndestid++) {
813 rio_route_get_entry(rdev,
814 RIO_GLOBAL_TABLE,
815 ndestid,
816 &route_port, 0);
817 if (route_port == port_num)
818 break;
819 }
820
821 if (ndestid == RIO_ANY_DESTID(port->sys_size))
822 continue;
823 rio_unlock_device(port, destid, hopcount);
824 if (rio_disc_peer(net, port, ndestid,
825 hopcount + 1, rdev, port_num) < 0)
826 return -1;
827 }
828 }
829 } else
830 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n",
831 rio_name(rdev), rdev->vid, rdev->did);
832
833 return 0;
834}
835
836
837
838
839
840
841
842
843
844
845static int rio_mport_is_active(struct rio_mport *port)
846{
847 u32 result = 0;
848 u32 ext_ftr_ptr;
849 int *entry = rio_mport_phys_table;
850
851 do {
852 if ((ext_ftr_ptr =
853 rio_mport_get_feature(port, 1, 0, 0, *entry)))
854 break;
855 } while (*++entry >= 0);
856
857 if (ext_ftr_ptr)
858 rio_local_read_config_32(port,
859 ext_ftr_ptr +
860 RIO_PORT_N_ERR_STS_CSR(port->index),
861 &result);
862
863 return result & RIO_PORT_N_ERR_STS_PORT_OK;
864}
865
866
867
868
869
870
871
872
873
874
875
876
877static struct rio_net *rio_alloc_net(struct rio_mport *port,
878 int do_enum, u16 start)
879{
880 struct rio_net *net;
881
882 net = kzalloc(sizeof(struct rio_net), GFP_KERNEL);
883 if (net && do_enum) {
884 net->destid_table.table = kcalloc(
885 BITS_TO_LONGS(RIO_MAX_ROUTE_ENTRIES(port->sys_size)),
886 sizeof(long),
887 GFP_KERNEL);
888
889 if (net->destid_table.table == NULL) {
890 pr_err("RIO: failed to allocate destID table\n");
891 kfree(net);
892 net = NULL;
893 } else {
894 net->destid_table.start = start;
895 net->destid_table.max =
896 RIO_MAX_ROUTE_ENTRIES(port->sys_size);
897 spin_lock_init(&net->destid_table.lock);
898 }
899 }
900
901 if (net) {
902 INIT_LIST_HEAD(&net->node);
903 INIT_LIST_HEAD(&net->devices);
904 INIT_LIST_HEAD(&net->switches);
905 INIT_LIST_HEAD(&net->mports);
906 list_add_tail(&port->nnode, &net->mports);
907 net->hport = port;
908 net->id = port->id;
909 }
910 return net;
911}
912
913
914
915
916
917
918
919
920
921static void rio_update_route_tables(struct rio_net *net)
922{
923 struct rio_dev *rdev, *swrdev;
924 struct rio_switch *rswitch;
925 u8 sport;
926 u16 destid;
927
928 list_for_each_entry(rdev, &net->devices, net_list) {
929
930 destid = rdev->destid;
931
932 list_for_each_entry(rswitch, &net->switches, node) {
933
934 if (rio_is_switch(rdev) && (rdev->rswitch == rswitch))
935 continue;
936
937 if (RIO_INVALID_ROUTE == rswitch->route_table[destid]) {
938 swrdev = sw_to_rio_dev(rswitch);
939
940
941 if (swrdev->destid == destid)
942 continue;
943
944 sport = RIO_GET_PORT_NUM(swrdev->swpinfo);
945
946 rio_route_add_entry(swrdev, RIO_GLOBAL_TABLE,
947 destid, sport, 0);
948 rswitch->route_table[destid] = sport;
949 }
950 }
951 }
952}
953
954
955
956
957
958
959
960
961static void rio_init_em(struct rio_dev *rdev)
962{
963 if (rio_is_switch(rdev) && (rdev->em_efptr) &&
964 rdev->rswitch->ops && rdev->rswitch->ops->em_init) {
965 rdev->rswitch->ops->em_init(rdev);
966 }
967}
968
969
970
971
972
973
974static void rio_pw_enable(struct rio_mport *port, int enable)
975{
976 if (port->ops->pwenable)
977 port->ops->pwenable(port, enable);
978}
979
980
981
982
983
984
985
986
987
988
989
990static int rio_enum_mport(struct rio_mport *mport, u32 flags)
991{
992 struct rio_net *net = NULL;
993 int rc = 0;
994
995 printk(KERN_INFO "RIO: enumerate master port %d, %s\n", mport->id,
996 mport->name);
997
998
999
1000
1001
1002
1003
1004 if (mport->nnode.next || mport->nnode.prev)
1005 return -EBUSY;
1006
1007
1008 if (rio_enum_host(mport) < 0) {
1009 printk(KERN_INFO
1010 "RIO: master port %d device has been enumerated by a remote host\n",
1011 mport->id);
1012 rc = -EBUSY;
1013 goto out;
1014 }
1015
1016
1017 if (rio_mport_is_active(mport)) {
1018 net = rio_alloc_net(mport, 1, 0);
1019 if (!net) {
1020 printk(KERN_ERR "RIO: failed to allocate new net\n");
1021 rc = -ENOMEM;
1022 goto out;
1023 }
1024
1025
1026 rio_destid_reserve(net, mport->host_deviceid);
1027
1028
1029 rio_enable_rx_tx_port(mport, 1, 0, 0, 0);
1030
1031
1032 rio_local_write_config_32(mport, RIO_COMPONENT_TAG_CSR,
1033 next_comptag++);
1034
1035 next_destid = rio_destid_alloc(net);
1036
1037 if (rio_enum_peer(net, mport, 0, NULL, 0) < 0) {
1038
1039 printk(KERN_INFO
1040 "RIO: master port %d device has lost enumeration to a remote host\n",
1041 mport->id);
1042 rio_clear_locks(net);
1043 rc = -EBUSY;
1044 goto out;
1045 }
1046
1047 rio_destid_free(net, next_destid);
1048 rio_update_route_tables(net);
1049 rio_clear_locks(net);
1050 rio_pw_enable(mport, 1);
1051 } else {
1052 printk(KERN_INFO "RIO: master port %d link inactive\n",
1053 mport->id);
1054 rc = -EINVAL;
1055 }
1056
1057 out:
1058 return rc;
1059}
1060
1061
1062
1063
1064
1065
1066
1067
1068static void rio_build_route_tables(struct rio_net *net)
1069{
1070 struct rio_switch *rswitch;
1071 struct rio_dev *rdev;
1072 int i;
1073 u8 sport;
1074
1075 list_for_each_entry(rswitch, &net->switches, node) {
1076 rdev = sw_to_rio_dev(rswitch);
1077
1078 rio_lock_device(net->hport, rdev->destid,
1079 rdev->hopcount, 1000);
1080 for (i = 0;
1081 i < RIO_MAX_ROUTE_ENTRIES(net->hport->sys_size);
1082 i++) {
1083 if (rio_route_get_entry(rdev, RIO_GLOBAL_TABLE,
1084 i, &sport, 0) < 0)
1085 continue;
1086 rswitch->route_table[i] = sport;
1087 }
1088
1089 rio_unlock_device(net->hport, rdev->destid, rdev->hopcount);
1090 }
1091}
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105static int rio_disc_mport(struct rio_mport *mport, u32 flags)
1106{
1107 struct rio_net *net = NULL;
1108 unsigned long to_end;
1109
1110 printk(KERN_INFO "RIO: discover master port %d, %s\n", mport->id,
1111 mport->name);
1112
1113
1114 if (rio_mport_is_active(mport)) {
1115 if (rio_enum_complete(mport))
1116 goto enum_done;
1117 else if (flags & RIO_SCAN_ENUM_NO_WAIT)
1118 return -EAGAIN;
1119
1120 pr_debug("RIO: wait for enumeration to complete...\n");
1121
1122 to_end = jiffies + CONFIG_RAPIDIO_DISC_TIMEOUT * HZ;
1123 while (time_before(jiffies, to_end)) {
1124 if (rio_enum_complete(mport))
1125 goto enum_done;
1126 msleep(10);
1127 }
1128
1129 pr_debug("RIO: discovery timeout on mport %d %s\n",
1130 mport->id, mport->name);
1131 goto bail;
1132enum_done:
1133 pr_debug("RIO: ... enumeration done\n");
1134
1135 net = rio_alloc_net(mport, 0, 0);
1136 if (!net) {
1137 printk(KERN_ERR "RIO: Failed to allocate new net\n");
1138 goto bail;
1139 }
1140
1141
1142 rio_local_read_config_32(mport, RIO_DID_CSR,
1143 &mport->host_deviceid);
1144 mport->host_deviceid = RIO_GET_DID(mport->sys_size,
1145 mport->host_deviceid);
1146
1147 if (rio_disc_peer(net, mport, RIO_ANY_DESTID(mport->sys_size),
1148 0, NULL, 0) < 0) {
1149 printk(KERN_INFO
1150 "RIO: master port %d device has failed discovery\n",
1151 mport->id);
1152 goto bail;
1153 }
1154
1155 rio_build_route_tables(net);
1156 }
1157
1158 return 0;
1159bail:
1160 return -EBUSY;
1161}
1162
1163static struct rio_scan rio_scan_ops = {
1164 .owner = THIS_MODULE,
1165 .enumerate = rio_enum_mport,
1166 .discover = rio_disc_mport,
1167};
1168
1169static bool scan;
1170module_param(scan, bool, 0);
1171MODULE_PARM_DESC(scan, "Start RapidIO network enumeration/discovery "
1172 "(default = 0)");
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188static int __init rio_basic_attach(void)
1189{
1190 if (rio_register_scan(RIO_MPORT_ANY, &rio_scan_ops))
1191 return -EIO;
1192 if (scan)
1193 rio_init_mports();
1194 return 0;
1195}
1196
1197late_initcall(rio_basic_attach);
1198
1199MODULE_DESCRIPTION("Basic RapidIO enumeration/discovery");
1200MODULE_LICENSE("GPL");
1201