Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
rio-scan.c
Go to the documentation of this file.
1 /*
2  * RapidIO enumeration and discovery support
3  *
4  * Copyright 2005 MontaVista Software, Inc.
5  * Matt Porter <[email protected]>
6  *
7  * Copyright 2009 Integrated Device Technology, Inc.
8  * Alex Bounine <[email protected]>
9  * - Added Port-Write/Error Management initialization and handling
10  *
11  * Copyright 2009 Sysgo AG
12  * Thomas Moll <[email protected]>
13  * - Added Input- Output- enable functionality, to allow full communication
14  *
15  * This program is free software; you can redistribute it and/or modify it
16  * under the terms of the GNU General Public License as published by the
17  * Free Software Foundation; either version 2 of the License, or (at your
18  * option) any later version.
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 
40 LIST_HEAD(rio_devices);
41 
42 static void rio_init_em(struct rio_dev *rdev);
43 
44 DEFINE_SPINLOCK(rio_global_list_lock);
45 
46 static int next_destid = 0;
47 static int next_comptag = 1;
48 
49 static int rio_mport_phys_table[] = {
50  RIO_EFB_PAR_EP_ID,
51  RIO_EFB_PAR_EP_REC_ID,
52  RIO_EFB_SER_EP_ID,
53  RIO_EFB_SER_EP_REC_ID,
54  -1,
55 };
56 
57 
66 static u16 rio_destid_alloc(struct rio_net *net)
67 {
68  int destid;
69  struct rio_id_table *idtab = &net->destid_table;
70 
71  spin_lock(&idtab->lock);
72  destid = find_first_zero_bit(idtab->table, idtab->max);
73 
74  if (destid < idtab->max) {
75  set_bit(destid, idtab->table);
76  destid += idtab->start;
77  } else
78  destid = RIO_INVALID_DESTID;
79 
80  spin_unlock(&idtab->lock);
81  return (u16)destid;
82 }
83 
92 static int rio_destid_reserve(struct rio_net *net, u16 destid)
93 {
94  int oldbit;
95  struct rio_id_table *idtab = &net->destid_table;
96 
97  destid -= idtab->start;
98  spin_lock(&idtab->lock);
99  oldbit = test_and_set_bit(destid, idtab->table);
100  spin_unlock(&idtab->lock);
101  return oldbit;
102 }
103 
111 static void rio_destid_free(struct rio_net *net, u16 destid)
112 {
113  struct rio_id_table *idtab = &net->destid_table;
114 
115  destid -= idtab->start;
116  spin_lock(&idtab->lock);
117  clear_bit(destid, idtab->table);
118  spin_unlock(&idtab->lock);
119 }
120 
125 static u16 rio_destid_first(struct rio_net *net)
126 {
127  int destid;
128  struct rio_id_table *idtab = &net->destid_table;
129 
130  spin_lock(&idtab->lock);
131  destid = find_first_bit(idtab->table, idtab->max);
132  if (destid >= idtab->max)
133  destid = RIO_INVALID_DESTID;
134  else
135  destid += idtab->start;
136  spin_unlock(&idtab->lock);
137  return (u16)destid;
138 }
139 
145 static u16 rio_destid_next(struct rio_net *net, u16 from)
146 {
147  int destid;
148  struct rio_id_table *idtab = &net->destid_table;
149 
150  spin_lock(&idtab->lock);
151  destid = find_next_bit(idtab->table, idtab->max, from);
152  if (destid >= idtab->max)
153  destid = RIO_INVALID_DESTID;
154  else
155  destid += idtab->start;
156  spin_unlock(&idtab->lock);
157  return (u16)destid;
158 }
159 
169 static u16 rio_get_device_id(struct rio_mport *port, u16 destid, u8 hopcount)
170 {
171  u32 result;
172 
173  rio_mport_read_config_32(port, destid, hopcount, RIO_DID_CSR, &result);
174 
175  return RIO_GET_DID(port->sys_size, result);
176 }
177 
187 static void rio_set_device_id(struct rio_mport *port, u16 destid, u8 hopcount, u16 did)
188 {
189  rio_mport_write_config_32(port, destid, hopcount, RIO_DID_CSR,
190  RIO_SET_DID(port->sys_size, did));
191 }
192 
200 static void rio_local_set_device_id(struct rio_mport *port, u16 did)
201 {
202  rio_local_write_config_32(port, RIO_DID_CSR, RIO_SET_DID(port->sys_size,
203  did));
204 }
205 
214 static int rio_clear_locks(struct rio_net *net)
215 {
216  struct rio_mport *port = net->hport;
217  struct rio_dev *rdev;
218  u32 result;
219  int ret = 0;
220 
221  /* Release host device id locks */
222  rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR,
223  port->host_deviceid);
224  rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result);
225  if ((result & 0xffff) != 0xffff) {
226  printk(KERN_INFO
227  "RIO: badness when releasing host lock on master port, result %8.8x\n",
228  result);
229  ret = -EINVAL;
230  }
231  list_for_each_entry(rdev, &net->devices, net_list) {
232  rio_write_config_32(rdev, RIO_HOST_DID_LOCK_CSR,
233  port->host_deviceid);
234  rio_read_config_32(rdev, RIO_HOST_DID_LOCK_CSR, &result);
235  if ((result & 0xffff) != 0xffff) {
236  printk(KERN_INFO
237  "RIO: badness when releasing host lock on vid %4.4x did %4.4x\n",
238  rdev->vid, rdev->did);
239  ret = -EINVAL;
240  }
241 
242  /* Mark device as discovered and enable master */
243  rio_read_config_32(rdev,
244  rdev->phys_efptr + RIO_PORT_GEN_CTL_CSR,
245  &result);
246  result |= RIO_PORT_GEN_DISCOVERED | RIO_PORT_GEN_MASTER;
247  rio_write_config_32(rdev,
248  rdev->phys_efptr + RIO_PORT_GEN_CTL_CSR,
249  result);
250  }
251 
252  return ret;
253 }
254 
263 static int rio_enum_host(struct rio_mport *port)
264 {
265  u32 result;
266 
267  /* Set master port host device id lock */
268  rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR,
269  port->host_deviceid);
270 
271  rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result);
272  if ((result & 0xffff) != port->host_deviceid)
273  return -1;
274 
275  /* Set master port destid and init destid ctr */
276  rio_local_set_device_id(port, port->host_deviceid);
277  return 0;
278 }
279 
290 static int rio_device_has_destid(struct rio_mport *port, int src_ops,
291  int dst_ops)
292 {
293  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;
294 
295  return !!((src_ops | dst_ops) & mask);
296 }
297 
305 static void rio_release_dev(struct device *dev)
306 {
307  struct rio_dev *rdev;
308 
309  rdev = to_rio_dev(dev);
310  kfree(rdev);
311 }
312 
322 static int rio_is_switch(struct rio_dev *rdev)
323 {
324  if (rdev->pef & RIO_PEF_SWITCH)
325  return 1;
326  return 0;
327 }
328 
338 static void rio_switch_init(struct rio_dev *rdev, int do_enum)
339 {
340  struct rio_switch_ops *cur = __start_rio_switch_ops;
341  struct rio_switch_ops *end = __end_rio_switch_ops;
342 
343  while (cur < end) {
344  if ((cur->vid == rdev->vid) && (cur->did == rdev->did)) {
345  pr_debug("RIO: calling init routine for %s\n",
346  rio_name(rdev));
347  cur->init_hook(rdev, do_enum);
348  break;
349  }
350  cur++;
351  }
352 
353  if ((cur >= end) && (rdev->pef & RIO_PEF_STD_RT)) {
354  pr_debug("RIO: adding STD routing ops for %s\n",
355  rio_name(rdev));
356  rdev->rswitch->add_entry = rio_std_route_add_entry;
357  rdev->rswitch->get_entry = rio_std_route_get_entry;
358  rdev->rswitch->clr_table = rio_std_route_clr_table;
359  }
360 
361  if (!rdev->rswitch->add_entry || !rdev->rswitch->get_entry)
362  printk(KERN_ERR "RIO: missing routing ops for %s\n",
363  rio_name(rdev));
364 }
365 
374 static int __devinit rio_add_device(struct rio_dev *rdev)
375 {
376  int err;
377 
378  err = device_add(&rdev->dev);
379  if (err)
380  return err;
381 
382  spin_lock(&rio_global_list_lock);
383  list_add_tail(&rdev->global_list, &rio_devices);
384  spin_unlock(&rio_global_list_lock);
385 
386  rio_create_sysfs_dev_files(rdev);
387 
388  return 0;
389 }
390 
403 inline int rio_enable_rx_tx_port(struct rio_mport *port,
404  int local, u16 destid,
405  u8 hopcount, u8 port_num) {
406 #ifdef CONFIG_RAPIDIO_ENABLE_RX_TX_PORTS
407  u32 regval;
408  u32 ext_ftr_ptr;
409 
410  /*
411  * enable rx input tx output port
412  */
413  pr_debug("rio_enable_rx_tx_port(local = %d, destid = %d, hopcount = "
414  "%d, port_num = %d)\n", local, destid, hopcount, port_num);
415 
416  ext_ftr_ptr = rio_mport_get_physefb(port, local, destid, hopcount);
417 
418  if (local) {
419  rio_local_read_config_32(port, ext_ftr_ptr +
420  RIO_PORT_N_CTL_CSR(0),
421  &regval);
422  } else {
423  if (rio_mport_read_config_32(port, destid, hopcount,
424  ext_ftr_ptr + RIO_PORT_N_CTL_CSR(port_num), &regval) < 0)
425  return -EIO;
426  }
427 
428  if (regval & RIO_PORT_N_CTL_P_TYP_SER) {
429  /* serial */
430  regval = regval | RIO_PORT_N_CTL_EN_RX_SER
431  | RIO_PORT_N_CTL_EN_TX_SER;
432  } else {
433  /* parallel */
434  regval = regval | RIO_PORT_N_CTL_EN_RX_PAR
435  | RIO_PORT_N_CTL_EN_TX_PAR;
436  }
437 
438  if (local) {
439  rio_local_write_config_32(port, ext_ftr_ptr +
440  RIO_PORT_N_CTL_CSR(0), regval);
441  } else {
442  if (rio_mport_write_config_32(port, destid, hopcount,
443  ext_ftr_ptr + RIO_PORT_N_CTL_CSR(port_num), regval) < 0)
444  return -EIO;
445  }
446 #endif
447  return 0;
448 }
449 
466 static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
467  struct rio_mport *port, u16 destid,
468  u8 hopcount, int do_enum)
469 {
470  int ret = 0;
471  struct rio_dev *rdev;
472  struct rio_switch *rswitch = NULL;
473  int result, rdid;
474  size_t size;
475  u32 swpinfo = 0;
476 
477  size = sizeof(struct rio_dev);
478  if (rio_mport_read_config_32(port, destid, hopcount,
479  RIO_PEF_CAR, &result))
480  return NULL;
481 
482  if (result & (RIO_PEF_SWITCH | RIO_PEF_MULTIPORT)) {
483  rio_mport_read_config_32(port, destid, hopcount,
484  RIO_SWP_INFO_CAR, &swpinfo);
485  if (result & RIO_PEF_SWITCH) {
486  size += (RIO_GET_TOTAL_PORTS(swpinfo) *
487  sizeof(rswitch->nextdev[0])) + sizeof(*rswitch);
488  }
489  }
490 
491  rdev = kzalloc(size, GFP_KERNEL);
492  if (!rdev)
493  return NULL;
494 
495  rdev->net = net;
496  rdev->pef = result;
497  rdev->swpinfo = swpinfo;
498  rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_ID_CAR,
499  &result);
500  rdev->did = result >> 16;
501  rdev->vid = result & 0xffff;
502  rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_INFO_CAR,
503  &rdev->device_rev);
504  rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_ID_CAR,
505  &result);
506  rdev->asm_did = result >> 16;
507  rdev->asm_vid = result & 0xffff;
508  rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_INFO_CAR,
509  &result);
510  rdev->asm_rev = result >> 16;
511  if (rdev->pef & RIO_PEF_EXT_FEATURES) {
512  rdev->efptr = result & 0xffff;
513  rdev->phys_efptr = rio_mport_get_physefb(port, 0, destid,
514  hopcount);
515 
516  rdev->em_efptr = rio_mport_get_feature(port, 0, destid,
517  hopcount, RIO_EFB_ERR_MGMNT);
518  }
519 
520  rio_mport_read_config_32(port, destid, hopcount, RIO_SRC_OPS_CAR,
521  &rdev->src_ops);
522  rio_mport_read_config_32(port, destid, hopcount, RIO_DST_OPS_CAR,
523  &rdev->dst_ops);
524 
525  if (do_enum) {
526  /* Assign component tag to device */
527  if (next_comptag >= 0x10000) {
528  pr_err("RIO: Component Tag Counter Overflow\n");
529  goto cleanup;
530  }
531  rio_mport_write_config_32(port, destid, hopcount,
532  RIO_COMPONENT_TAG_CSR, next_comptag);
533  rdev->comp_tag = next_comptag++;
534  } else {
535  rio_mport_read_config_32(port, destid, hopcount,
536  RIO_COMPONENT_TAG_CSR,
537  &rdev->comp_tag);
538  }
539 
540  if (rio_device_has_destid(port, rdev->src_ops, rdev->dst_ops)) {
541  if (do_enum) {
542  rio_set_device_id(port, destid, hopcount, next_destid);
543  rdev->destid = next_destid;
544  next_destid = rio_destid_alloc(net);
545  } else
546  rdev->destid = rio_get_device_id(port, destid, hopcount);
547 
548  rdev->hopcount = 0xff;
549  } else {
550  /* Switch device has an associated destID which
551  * will be adjusted later
552  */
553  rdev->destid = destid;
554  rdev->hopcount = hopcount;
555  }
556 
557  /* If a PE has both switch and other functions, show it as a switch */
558  if (rio_is_switch(rdev)) {
559  rswitch = rdev->rswitch;
560  rswitch->switchid = rdev->comp_tag & RIO_CTAG_UDEVID;
561  rswitch->port_ok = 0;
562  rswitch->route_table = kzalloc(sizeof(u8)*
563  RIO_MAX_ROUTE_ENTRIES(port->sys_size),
564  GFP_KERNEL);
565  if (!rswitch->route_table)
566  goto cleanup;
567  /* Initialize switch route table */
568  for (rdid = 0; rdid < RIO_MAX_ROUTE_ENTRIES(port->sys_size);
569  rdid++)
570  rswitch->route_table[rdid] = RIO_INVALID_ROUTE;
571  dev_set_name(&rdev->dev, "%02x:s:%04x", rdev->net->id,
572  rswitch->switchid);
573  rio_switch_init(rdev, do_enum);
574 
575  if (do_enum && rswitch->clr_table)
576  rswitch->clr_table(port, destid, hopcount,
577  RIO_GLOBAL_TABLE);
578 
579  list_add_tail(&rswitch->node, &net->switches);
580 
581  } else {
582  if (do_enum)
583  /*Enable Input Output Port (transmitter reviever)*/
584  rio_enable_rx_tx_port(port, 0, destid, hopcount, 0);
585 
586  dev_set_name(&rdev->dev, "%02x:e:%04x", rdev->net->id,
587  rdev->destid);
588  }
589 
590  rdev->dev.bus = &rio_bus_type;
591  rdev->dev.parent = &rio_bus;
592 
593  device_initialize(&rdev->dev);
594  rdev->dev.release = rio_release_dev;
595  rio_dev_get(rdev);
596 
597  rdev->dma_mask = DMA_BIT_MASK(32);
598  rdev->dev.dma_mask = &rdev->dma_mask;
599  rdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
600 
601  if (rdev->dst_ops & RIO_DST_OPS_DOORBELL)
602  rio_init_dbell_res(&rdev->riores[RIO_DOORBELL_RESOURCE],
603  0, 0xffff);
604 
605  ret = rio_add_device(rdev);
606  if (ret)
607  goto cleanup;
608 
609  return rdev;
610 
611 cleanup:
612  if (rswitch)
613  kfree(rswitch->route_table);
614 
615  kfree(rdev);
616  return NULL;
617 }
618 
631 static int
632 rio_sport_is_active(struct rio_mport *port, u16 destid, u8 hopcount, int sport)
633 {
634  u32 result = 0;
635  u32 ext_ftr_ptr;
636 
637  ext_ftr_ptr = rio_mport_get_efb(port, 0, destid, hopcount, 0);
638 
639  while (ext_ftr_ptr) {
640  rio_mport_read_config_32(port, destid, hopcount,
641  ext_ftr_ptr, &result);
642  result = RIO_GET_BLOCK_ID(result);
643  if ((result == RIO_EFB_SER_EP_FREE_ID) ||
644  (result == RIO_EFB_SER_EP_FREE_ID_V13P) ||
645  (result == RIO_EFB_SER_EP_FREC_ID))
646  break;
647 
648  ext_ftr_ptr = rio_mport_get_efb(port, 0, destid, hopcount,
649  ext_ftr_ptr);
650  }
651 
652  if (ext_ftr_ptr)
653  rio_mport_read_config_32(port, destid, hopcount,
654  ext_ftr_ptr +
655  RIO_PORT_N_ERR_STS_CSR(sport),
656  &result);
657 
658  return result & RIO_PORT_N_ERR_STS_PORT_OK;
659 }
660 
671 static int
672 rio_lock_device(struct rio_mport *port, u16 destid, u8 hopcount, int wait_ms)
673 {
674  u32 result;
675  int tcnt = 0;
676 
677  /* Attempt to acquire device lock */
678  rio_mport_write_config_32(port, destid, hopcount,
679  RIO_HOST_DID_LOCK_CSR, port->host_deviceid);
680  rio_mport_read_config_32(port, destid, hopcount,
681  RIO_HOST_DID_LOCK_CSR, &result);
682 
683  while (result != port->host_deviceid) {
684  if (wait_ms != 0 && tcnt == wait_ms) {
685  pr_debug("RIO: timeout when locking device %x:%x\n",
686  destid, hopcount);
687  return -EINVAL;
688  }
689 
690  /* Delay a bit */
691  mdelay(1);
692  tcnt++;
693  /* Try to acquire device lock again */
694  rio_mport_write_config_32(port, destid,
695  hopcount,
696  RIO_HOST_DID_LOCK_CSR,
697  port->host_deviceid);
698  rio_mport_read_config_32(port, destid,
699  hopcount,
700  RIO_HOST_DID_LOCK_CSR, &result);
701  }
702 
703  return 0;
704 }
705 
714 static int
715 rio_unlock_device(struct rio_mport *port, u16 destid, u8 hopcount)
716 {
717  u32 result;
718 
719  /* Release device lock */
720  rio_mport_write_config_32(port, destid,
721  hopcount,
722  RIO_HOST_DID_LOCK_CSR,
723  port->host_deviceid);
724  rio_mport_read_config_32(port, destid, hopcount,
725  RIO_HOST_DID_LOCK_CSR, &result);
726  if ((result & 0xffff) != 0xffff) {
727  pr_debug("RIO: badness when releasing device lock %x:%x\n",
728  destid, hopcount);
729  return -EINVAL;
730  }
731 
732  return 0;
733 }
734 
750 static int
751 rio_route_add_entry(struct rio_dev *rdev,
752  u16 table, u16 route_destid, u8 route_port, int lock)
753 {
754  int rc;
755 
756  if (lock) {
757  rc = rio_lock_device(rdev->net->hport, rdev->destid,
758  rdev->hopcount, 1000);
759  if (rc)
760  return rc;
761  }
762 
763  rc = rdev->rswitch->add_entry(rdev->net->hport, rdev->destid,
764  rdev->hopcount, table,
765  route_destid, route_port);
766  if (lock)
767  rio_unlock_device(rdev->net->hport, rdev->destid,
768  rdev->hopcount);
769 
770  return rc;
771 }
772 
788 static int
789 rio_route_get_entry(struct rio_dev *rdev, u16 table,
790  u16 route_destid, u8 *route_port, int lock)
791 {
792  int rc;
793 
794  if (lock) {
795  rc = rio_lock_device(rdev->net->hport, rdev->destid,
796  rdev->hopcount, 1000);
797  if (rc)
798  return rc;
799  }
800 
801  rc = rdev->rswitch->get_entry(rdev->net->hport, rdev->destid,
802  rdev->hopcount, table,
803  route_destid, route_port);
804  if (lock)
805  rio_unlock_device(rdev->net->hport, rdev->destid,
806  rdev->hopcount);
807 
808  return rc;
809 }
810 
819 static u16 rio_get_host_deviceid_lock(struct rio_mport *port, u8 hopcount)
820 {
821  u32 result;
822 
823  rio_mport_read_config_32(port, RIO_ANY_DESTID(port->sys_size), hopcount,
824  RIO_HOST_DID_LOCK_CSR, &result);
825 
826  return (u16) (result & 0xffff);
827 }
828 
840 static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
841  u8 hopcount, struct rio_dev *prev, int prev_port)
842 {
843  struct rio_dev *rdev;
844  u32 regval;
845  int tmp;
846 
847  if (rio_mport_chk_dev_access(port,
848  RIO_ANY_DESTID(port->sys_size), hopcount)) {
849  pr_debug("RIO: device access check failed\n");
850  return -1;
851  }
852 
853  if (rio_get_host_deviceid_lock(port, hopcount) == port->host_deviceid) {
854  pr_debug("RIO: PE already discovered by this host\n");
855  /*
856  * Already discovered by this host. Add it as another
857  * link to the existing device.
858  */
859  rio_mport_read_config_32(port, RIO_ANY_DESTID(port->sys_size),
860  hopcount, RIO_COMPONENT_TAG_CSR, &regval);
861 
862  if (regval) {
863  rdev = rio_get_comptag((regval & 0xffff), NULL);
864 
865  if (rdev && prev && rio_is_switch(prev)) {
866  pr_debug("RIO: redundant path to %s\n",
867  rio_name(rdev));
868  prev->rswitch->nextdev[prev_port] = rdev;
869  }
870  }
871 
872  return 0;
873  }
874 
875  /* Attempt to acquire device lock */
876  rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size),
877  hopcount,
878  RIO_HOST_DID_LOCK_CSR, port->host_deviceid);
879  while ((tmp = rio_get_host_deviceid_lock(port, hopcount))
880  < port->host_deviceid) {
881  /* Delay a bit */
882  mdelay(1);
883  /* Attempt to acquire device lock again */
884  rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size),
885  hopcount,
886  RIO_HOST_DID_LOCK_CSR,
887  port->host_deviceid);
888  }
889 
890  if (rio_get_host_deviceid_lock(port, hopcount) > port->host_deviceid) {
891  pr_debug(
892  "RIO: PE locked by a higher priority host...retreating\n");
893  return -1;
894  }
895 
896  /* Setup new RIO device */
897  rdev = rio_setup_device(net, port, RIO_ANY_DESTID(port->sys_size),
898  hopcount, 1);
899  if (rdev) {
900  /* Add device to the global and bus/net specific list. */
901  list_add_tail(&rdev->net_list, &net->devices);
902  rdev->prev = prev;
903  if (prev && rio_is_switch(prev))
904  prev->rswitch->nextdev[prev_port] = rdev;
905  } else
906  return -1;
907 
908  if (rio_is_switch(rdev)) {
909  int sw_destid;
910  int cur_destid;
911  int sw_inport;
912  u16 destid;
913  int port_num;
914 
915  sw_inport = RIO_GET_PORT_NUM(rdev->swpinfo);
916  rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
917  port->host_deviceid, sw_inport, 0);
918  rdev->rswitch->route_table[port->host_deviceid] = sw_inport;
919 
920  destid = rio_destid_first(net);
921  while (destid != RIO_INVALID_DESTID && destid < next_destid) {
922  if (destid != port->host_deviceid) {
923  rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
924  destid, sw_inport, 0);
925  rdev->rswitch->route_table[destid] = sw_inport;
926  }
927  destid = rio_destid_next(net, destid + 1);
928  }
929  pr_debug(
930  "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n",
931  rio_name(rdev), rdev->vid, rdev->did,
932  RIO_GET_TOTAL_PORTS(rdev->swpinfo));
933  sw_destid = next_destid;
934  for (port_num = 0;
935  port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo);
936  port_num++) {
937  if (sw_inport == port_num) {
938  rio_enable_rx_tx_port(port, 0,
939  RIO_ANY_DESTID(port->sys_size),
940  hopcount, port_num);
941  rdev->rswitch->port_ok |= (1 << port_num);
942  continue;
943  }
944 
945  cur_destid = next_destid;
946 
947  if (rio_sport_is_active
948  (port, RIO_ANY_DESTID(port->sys_size), hopcount,
949  port_num)) {
950  pr_debug(
951  "RIO: scanning device on port %d\n",
952  port_num);
953  rio_enable_rx_tx_port(port, 0,
954  RIO_ANY_DESTID(port->sys_size),
955  hopcount, port_num);
956  rdev->rswitch->port_ok |= (1 << port_num);
957  rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
958  RIO_ANY_DESTID(port->sys_size),
959  port_num, 0);
960 
961  if (rio_enum_peer(net, port, hopcount + 1,
962  rdev, port_num) < 0)
963  return -1;
964 
965  /* Update routing tables */
966  destid = rio_destid_next(net, cur_destid + 1);
967  if (destid != RIO_INVALID_DESTID) {
968  for (destid = cur_destid;
969  destid < next_destid;) {
970  if (destid != port->host_deviceid) {
971  rio_route_add_entry(rdev,
972  RIO_GLOBAL_TABLE,
973  destid,
974  port_num,
975  0);
976  rdev->rswitch->
977  route_table[destid] =
978  port_num;
979  }
980  destid = rio_destid_next(net,
981  destid + 1);
982  }
983  }
984  } else {
985  /* If switch supports Error Management,
986  * set PORT_LOCKOUT bit for unused port
987  */
988  if (rdev->em_efptr)
989  rio_set_port_lockout(rdev, port_num, 1);
990 
991  rdev->rswitch->port_ok &= ~(1 << port_num);
992  }
993  }
994 
995  /* Direct Port-write messages to the enumeratiing host */
996  if ((rdev->src_ops & RIO_SRC_OPS_PORT_WRITE) &&
997  (rdev->em_efptr)) {
998  rio_write_config_32(rdev,
999  rdev->em_efptr + RIO_EM_PW_TGT_DEVID,
1000  (port->host_deviceid << 16) |
1001  (port->sys_size << 15));
1002  }
1003 
1004  rio_init_em(rdev);
1005 
1006  /* Check for empty switch */
1007  if (next_destid == sw_destid)
1008  next_destid = rio_destid_alloc(net);
1009 
1010  rdev->destid = sw_destid;
1011  } else
1012  pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n",
1013  rio_name(rdev), rdev->vid, rdev->did);
1014 
1015  return 0;
1016 }
1017 
1026 static int rio_enum_complete(struct rio_mport *port)
1027 {
1028  u32 regval;
1029 
1030  rio_local_read_config_32(port, port->phys_efptr + RIO_PORT_GEN_CTL_CSR,
1031  &regval);
1032  return (regval & RIO_PORT_GEN_DISCOVERED) ? 1 : 0;
1033 }
1034 
1047 static int __devinit
1048 rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid,
1049  u8 hopcount, struct rio_dev *prev, int prev_port)
1050 {
1051  u8 port_num, route_port;
1052  struct rio_dev *rdev;
1053  u16 ndestid;
1054 
1055  /* Setup new RIO device */
1056  if ((rdev = rio_setup_device(net, port, destid, hopcount, 0))) {
1057  /* Add device to the global and bus/net specific list. */
1058  list_add_tail(&rdev->net_list, &net->devices);
1059  rdev->prev = prev;
1060  if (prev && rio_is_switch(prev))
1061  prev->rswitch->nextdev[prev_port] = rdev;
1062  } else
1063  return -1;
1064 
1065  if (rio_is_switch(rdev)) {
1066  /* Associated destid is how we accessed this switch */
1067  rdev->destid = destid;
1068 
1069  pr_debug(
1070  "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n",
1071  rio_name(rdev), rdev->vid, rdev->did,
1072  RIO_GET_TOTAL_PORTS(rdev->swpinfo));
1073  for (port_num = 0;
1074  port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo);
1075  port_num++) {
1076  if (RIO_GET_PORT_NUM(rdev->swpinfo) == port_num)
1077  continue;
1078 
1079  if (rio_sport_is_active
1080  (port, destid, hopcount, port_num)) {
1081  pr_debug(
1082  "RIO: scanning device on port %d\n",
1083  port_num);
1084 
1085  rio_lock_device(port, destid, hopcount, 1000);
1086 
1087  for (ndestid = 0;
1088  ndestid < RIO_ANY_DESTID(port->sys_size);
1089  ndestid++) {
1090  rio_route_get_entry(rdev,
1091  RIO_GLOBAL_TABLE,
1092  ndestid,
1093  &route_port, 0);
1094  if (route_port == port_num)
1095  break;
1096  }
1097 
1098  if (ndestid == RIO_ANY_DESTID(port->sys_size))
1099  continue;
1100  rio_unlock_device(port, destid, hopcount);
1101  if (rio_disc_peer(net, port, ndestid,
1102  hopcount + 1, rdev, port_num) < 0)
1103  return -1;
1104  }
1105  }
1106  } else
1107  pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n",
1108  rio_name(rdev), rdev->vid, rdev->did);
1109 
1110  return 0;
1111 }
1112 
1122 static int rio_mport_is_active(struct rio_mport *port)
1123 {
1124  u32 result = 0;
1125  u32 ext_ftr_ptr;
1126  int *entry = rio_mport_phys_table;
1127 
1128  do {
1129  if ((ext_ftr_ptr =
1130  rio_mport_get_feature(port, 1, 0, 0, *entry)))
1131  break;
1132  } while (*++entry >= 0);
1133 
1134  if (ext_ftr_ptr)
1135  rio_local_read_config_32(port,
1136  ext_ftr_ptr +
1137  RIO_PORT_N_ERR_STS_CSR(port->index),
1138  &result);
1139 
1140  return result & RIO_PORT_N_ERR_STS_PORT_OK;
1141 }
1142 
1154 static struct rio_net __devinit *rio_alloc_net(struct rio_mport *port,
1155  int do_enum, u16 start)
1156 {
1157  struct rio_net *net;
1158 
1159  net = kzalloc(sizeof(struct rio_net), GFP_KERNEL);
1160  if (net && do_enum) {
1161  net->destid_table.table = kcalloc(
1162  BITS_TO_LONGS(RIO_MAX_ROUTE_ENTRIES(port->sys_size)),
1163  sizeof(long),
1164  GFP_KERNEL);
1165 
1166  if (net->destid_table.table == NULL) {
1167  pr_err("RIO: failed to allocate destID table\n");
1168  kfree(net);
1169  net = NULL;
1170  } else {
1171  net->destid_table.start = start;
1172  net->destid_table.max =
1173  RIO_MAX_ROUTE_ENTRIES(port->sys_size);
1174  spin_lock_init(&net->destid_table.lock);
1175  }
1176  }
1177 
1178  if (net) {
1179  INIT_LIST_HEAD(&net->node);
1180  INIT_LIST_HEAD(&net->devices);
1181  INIT_LIST_HEAD(&net->switches);
1182  INIT_LIST_HEAD(&net->mports);
1183  list_add_tail(&port->nnode, &net->mports);
1184  net->hport = port;
1185  net->id = port->id;
1186  }
1187  return net;
1188 }
1189 
1198 static void rio_update_route_tables(struct rio_net *net)
1199 {
1200  struct rio_dev *rdev, *swrdev;
1201  struct rio_switch *rswitch;
1202  u8 sport;
1203  u16 destid;
1204 
1205  list_for_each_entry(rdev, &net->devices, net_list) {
1206 
1207  destid = rdev->destid;
1208 
1209  list_for_each_entry(rswitch, &net->switches, node) {
1210 
1211  if (rio_is_switch(rdev) && (rdev->rswitch == rswitch))
1212  continue;
1213 
1214  if (RIO_INVALID_ROUTE == rswitch->route_table[destid]) {
1215  swrdev = sw_to_rio_dev(rswitch);
1216 
1217  /* Skip if destid ends in empty switch*/
1218  if (swrdev->destid == destid)
1219  continue;
1220 
1221  sport = RIO_GET_PORT_NUM(swrdev->swpinfo);
1222 
1223  if (rswitch->add_entry) {
1224  rio_route_add_entry(swrdev,
1225  RIO_GLOBAL_TABLE, destid,
1226  sport, 0);
1227  rswitch->route_table[destid] = sport;
1228  }
1229  }
1230  }
1231  }
1232 }
1233 
1241 static void rio_init_em(struct rio_dev *rdev)
1242 {
1243  if (rio_is_switch(rdev) && (rdev->em_efptr) &&
1244  (rdev->rswitch->em_init)) {
1245  rdev->rswitch->em_init(rdev);
1246  }
1247 }
1248 
1254 static void rio_pw_enable(struct rio_mport *port, int enable)
1255 {
1256  if (port->ops->pwenable)
1257  port->ops->pwenable(port, enable);
1258 }
1259 
1269 int __devinit rio_enum_mport(struct rio_mport *mport)
1270 {
1271  struct rio_net *net = NULL;
1272  int rc = 0;
1273 
1274  printk(KERN_INFO "RIO: enumerate master port %d, %s\n", mport->id,
1275  mport->name);
1276  /* If somebody else enumerated our master port device, bail. */
1277  if (rio_enum_host(mport) < 0) {
1278  printk(KERN_INFO
1279  "RIO: master port %d device has been enumerated by a remote host\n",
1280  mport->id);
1281  rc = -EBUSY;
1282  goto out;
1283  }
1284 
1285  /* If master port has an active link, allocate net and enum peers */
1286  if (rio_mport_is_active(mport)) {
1287  net = rio_alloc_net(mport, 1, 0);
1288  if (!net) {
1289  printk(KERN_ERR "RIO: failed to allocate new net\n");
1290  rc = -ENOMEM;
1291  goto out;
1292  }
1293 
1294  /* reserve mport destID in new net */
1295  rio_destid_reserve(net, mport->host_deviceid);
1296 
1297  /* Enable Input Output Port (transmitter reviever) */
1298  rio_enable_rx_tx_port(mport, 1, 0, 0, 0);
1299 
1300  /* Set component tag for host */
1301  rio_local_write_config_32(mport, RIO_COMPONENT_TAG_CSR,
1302  next_comptag++);
1303 
1304  next_destid = rio_destid_alloc(net);
1305 
1306  if (rio_enum_peer(net, mport, 0, NULL, 0) < 0) {
1307  /* A higher priority host won enumeration, bail. */
1308  printk(KERN_INFO
1309  "RIO: master port %d device has lost enumeration to a remote host\n",
1310  mport->id);
1311  rio_clear_locks(net);
1312  rc = -EBUSY;
1313  goto out;
1314  }
1315  /* free the last allocated destID (unused) */
1316  rio_destid_free(net, next_destid);
1317  rio_update_route_tables(net);
1318  rio_clear_locks(net);
1319  rio_pw_enable(mport, 1);
1320  } else {
1321  printk(KERN_INFO "RIO: master port %d link inactive\n",
1322  mport->id);
1323  rc = -EINVAL;
1324  }
1325 
1326  out:
1327  return rc;
1328 }
1329 
1337 static void rio_build_route_tables(struct rio_net *net)
1338 {
1339  struct rio_switch *rswitch;
1340  struct rio_dev *rdev;
1341  int i;
1342  u8 sport;
1343 
1344  list_for_each_entry(rswitch, &net->switches, node) {
1345  rdev = sw_to_rio_dev(rswitch);
1346 
1347  rio_lock_device(net->hport, rdev->destid,
1348  rdev->hopcount, 1000);
1349  for (i = 0;
1350  i < RIO_MAX_ROUTE_ENTRIES(net->hport->sys_size);
1351  i++) {
1352  if (rio_route_get_entry(rdev, RIO_GLOBAL_TABLE,
1353  i, &sport, 0) < 0)
1354  continue;
1355  rswitch->route_table[i] = sport;
1356  }
1357 
1358  rio_unlock_device(net->hport, rdev->destid, rdev->hopcount);
1359  }
1360 }
1361 
1372 int __devinit rio_disc_mport(struct rio_mport *mport)
1373 {
1374  struct rio_net *net = NULL;
1375  unsigned long to_end;
1376 
1377  printk(KERN_INFO "RIO: discover master port %d, %s\n", mport->id,
1378  mport->name);
1379 
1380  /* If master port has an active link, allocate net and discover peers */
1381  if (rio_mport_is_active(mport)) {
1382  pr_debug("RIO: wait for enumeration to complete...\n");
1383 
1384  to_end = jiffies + CONFIG_RAPIDIO_DISC_TIMEOUT * HZ;
1385  while (time_before(jiffies, to_end)) {
1386  if (rio_enum_complete(mport))
1387  goto enum_done;
1388  msleep(10);
1389  }
1390 
1391  pr_debug("RIO: discovery timeout on mport %d %s\n",
1392  mport->id, mport->name);
1393  goto bail;
1394 enum_done:
1395  pr_debug("RIO: ... enumeration done\n");
1396 
1397  net = rio_alloc_net(mport, 0, 0);
1398  if (!net) {
1399  printk(KERN_ERR "RIO: Failed to allocate new net\n");
1400  goto bail;
1401  }
1402 
1403  /* Read DestID assigned by enumerator */
1404  rio_local_read_config_32(mport, RIO_DID_CSR,
1405  &mport->host_deviceid);
1406  mport->host_deviceid = RIO_GET_DID(mport->sys_size,
1407  mport->host_deviceid);
1408 
1409  if (rio_disc_peer(net, mport, RIO_ANY_DESTID(mport->sys_size),
1410  0, NULL, 0) < 0) {
1411  printk(KERN_INFO
1412  "RIO: master port %d device has failed discovery\n",
1413  mport->id);
1414  goto bail;
1415  }
1416 
1417  rio_build_route_tables(net);
1418  }
1419 
1420  return 0;
1421 bail:
1422  return -EBUSY;
1423 }
Generated on Thu Jan 10 2013 14:16:27 for Linux Kernel by   doxygen 1.8.2