1 /* 2 * RapidIO enumeration and discovery support 3 * 4 * Copyright 2005 MontaVista Software, Inc. 5 * Matt Porter <mporter@kernel.crashing.org> 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License as published by the 9 * Free Software Foundation; either version 2 of the License, or (at your 10 * option) any later version. 11 */ 12 13 #include <linux/config.h> 14 #include <linux/types.h> 15 #include <linux/kernel.h> 16 17 #include <linux/delay.h> 18 #include <linux/dma-mapping.h> 19 #include <linux/init.h> 20 #include <linux/rio.h> 21 #include <linux/rio_drv.h> 22 #include <linux/rio_ids.h> 23 #include <linux/rio_regs.h> 24 #include <linux/module.h> 25 #include <linux/spinlock.h> 26 #include <linux/timer.h> 27 28 #include "rio.h" 29 30 LIST_HEAD(rio_devices); 31 static LIST_HEAD(rio_switches); 32 33 #define RIO_ENUM_CMPL_MAGIC 0xdeadbeef 34 35 static void rio_enum_timeout(unsigned long); 36 37 DEFINE_SPINLOCK(rio_global_list_lock); 38 39 static int next_destid = 0; 40 static int next_switchid = 0; 41 static int next_net = 0; 42 43 static struct timer_list rio_enum_timer = 44 TIMER_INITIALIZER(rio_enum_timeout, 0, 0); 45 46 static int rio_mport_phys_table[] = { 47 RIO_EFB_PAR_EP_ID, 48 RIO_EFB_PAR_EP_REC_ID, 49 RIO_EFB_SER_EP_ID, 50 RIO_EFB_SER_EP_REC_ID, 51 -1, 52 }; 53 54 static int rio_sport_phys_table[] = { 55 RIO_EFB_PAR_EP_FREE_ID, 56 RIO_EFB_SER_EP_FREE_ID, 57 -1, 58 }; 59 60 /** 61 * rio_get_device_id - Get the base/extended device id for a device 62 * @port: RIO master port 63 * @destid: Destination ID of device 64 * @hopcount: Hopcount to device 65 * 66 * Reads the base/extended device id from a device. Returns the 67 * 8/16-bit device ID. 68 */ 69 static u16 rio_get_device_id(struct rio_mport *port, u16 destid, u8 hopcount) 70 { 71 u32 result; 72 73 rio_mport_read_config_32(port, destid, hopcount, RIO_DID_CSR, &result); 74 75 return RIO_GET_DID(result); 76 } 77 78 /** 79 * rio_set_device_id - Set the base/extended device id for a device 80 * @port: RIO master port 81 * @destid: Destination ID of device 82 * @hopcount: Hopcount to device 83 * @did: Device ID value to be written 84 * 85 * Writes the base/extended device id from a device. 86 */ 87 static void rio_set_device_id(struct rio_mport *port, u16 destid, u8 hopcount, u16 did) 88 { 89 rio_mport_write_config_32(port, destid, hopcount, RIO_DID_CSR, 90 RIO_SET_DID(did)); 91 } 92 93 /** 94 * rio_local_set_device_id - Set the base/extended device id for a port 95 * @port: RIO master port 96 * @did: Device ID value to be written 97 * 98 * Writes the base/extended device id from a device. 99 */ 100 static void rio_local_set_device_id(struct rio_mport *port, u16 did) 101 { 102 rio_local_write_config_32(port, RIO_DID_CSR, RIO_SET_DID(did)); 103 } 104 105 /** 106 * rio_clear_locks- Release all host locks and signal enumeration complete 107 * @port: Master port to issue transaction 108 * 109 * Marks the component tag CSR on each device with the enumeration 110 * complete flag. When complete, it then release the host locks on 111 * each device. Returns 0 on success or %-EINVAL on failure. 112 */ 113 static int rio_clear_locks(struct rio_mport *port) 114 { 115 struct rio_dev *rdev; 116 u32 result; 117 int ret = 0; 118 119 /* Write component tag CSR magic complete value */ 120 rio_local_write_config_32(port, RIO_COMPONENT_TAG_CSR, 121 RIO_ENUM_CMPL_MAGIC); 122 list_for_each_entry(rdev, &rio_devices, global_list) 123 rio_write_config_32(rdev, RIO_COMPONENT_TAG_CSR, 124 RIO_ENUM_CMPL_MAGIC); 125 126 /* Release host device id locks */ 127 rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR, 128 port->host_deviceid); 129 rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result); 130 if ((result & 0xffff) != 0xffff) { 131 printk(KERN_INFO 132 "RIO: badness when releasing host lock on master port, result %8.8x\n", 133 result); 134 ret = -EINVAL; 135 } 136 list_for_each_entry(rdev, &rio_devices, global_list) { 137 rio_write_config_32(rdev, RIO_HOST_DID_LOCK_CSR, 138 port->host_deviceid); 139 rio_read_config_32(rdev, RIO_HOST_DID_LOCK_CSR, &result); 140 if ((result & 0xffff) != 0xffff) { 141 printk(KERN_INFO 142 "RIO: badness when releasing host lock on vid %4.4x did %4.4x\n", 143 rdev->vid, rdev->did); 144 ret = -EINVAL; 145 } 146 } 147 148 return ret; 149 } 150 151 /** 152 * rio_enum_host- Set host lock and initialize host destination ID 153 * @port: Master port to issue transaction 154 * 155 * Sets the local host master port lock and destination ID register 156 * with the host device ID value. The host device ID value is provided 157 * by the platform. Returns %0 on success or %-1 on failure. 158 */ 159 static int rio_enum_host(struct rio_mport *port) 160 { 161 u32 result; 162 163 /* Set master port host device id lock */ 164 rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR, 165 port->host_deviceid); 166 167 rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result); 168 if ((result & 0xffff) != port->host_deviceid) 169 return -1; 170 171 /* Set master port destid and init destid ctr */ 172 rio_local_set_device_id(port, port->host_deviceid); 173 174 if (next_destid == port->host_deviceid) 175 next_destid++; 176 177 return 0; 178 } 179 180 /** 181 * rio_device_has_destid- Test if a device contains a destination ID register 182 * @port: Master port to issue transaction 183 * @src_ops: RIO device source operations 184 * @dst_ops: RIO device destination operations 185 * 186 * Checks the provided @src_ops and @dst_ops for the necessary transaction 187 * capabilities that indicate whether or not a device will implement a 188 * destination ID register. Returns 1 if true or 0 if false. 189 */ 190 static int rio_device_has_destid(struct rio_mport *port, int src_ops, 191 int dst_ops) 192 { 193 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; 194 195 return !!((src_ops | dst_ops) & mask); 196 } 197 198 /** 199 * rio_release_dev- Frees a RIO device struct 200 * @dev: LDM device associated with a RIO device struct 201 * 202 * Gets the RIO device struct associated a RIO device struct. 203 * The RIO device struct is freed. 204 */ 205 static void rio_release_dev(struct device *dev) 206 { 207 struct rio_dev *rdev; 208 209 rdev = to_rio_dev(dev); 210 kfree(rdev); 211 } 212 213 /** 214 * rio_is_switch- Tests if a RIO device has switch capabilities 215 * @rdev: RIO device 216 * 217 * Gets the RIO device Processing Element Features register 218 * contents and tests for switch capabilities. Returns 1 if 219 * the device is a switch or 0 if it is not a switch. 220 * The RIO device struct is freed. 221 */ 222 static int rio_is_switch(struct rio_dev *rdev) 223 { 224 if (rdev->pef & RIO_PEF_SWITCH) 225 return 1; 226 return 0; 227 } 228 229 /** 230 * rio_route_set_ops- Sets routing operations for a particular vendor switch 231 * @rdev: RIO device 232 * 233 * Searches the RIO route ops table for known switch types. If the vid 234 * and did match a switch table entry, then set the add_entry() and 235 * get_entry() ops to the table entry values. 236 */ 237 static void rio_route_set_ops(struct rio_dev *rdev) 238 { 239 struct rio_route_ops *cur = __start_rio_route_ops; 240 struct rio_route_ops *end = __end_rio_route_ops; 241 242 while (cur < end) { 243 if ((cur->vid == rdev->vid) && (cur->did == rdev->did)) { 244 pr_debug("RIO: adding routing ops for %s\n", rio_name(rdev)); 245 rdev->rswitch->add_entry = cur->add_hook; 246 rdev->rswitch->get_entry = cur->get_hook; 247 } 248 cur++; 249 } 250 251 if (!rdev->rswitch->add_entry || !rdev->rswitch->get_entry) 252 printk(KERN_ERR "RIO: missing routing ops for %s\n", 253 rio_name(rdev)); 254 } 255 256 /** 257 * rio_add_device- Adds a RIO device to the device model 258 * @rdev: RIO device 259 * 260 * Adds the RIO device to the global device list and adds the RIO 261 * device to the RIO device list. Creates the generic sysfs nodes 262 * for an RIO device. 263 */ 264 static void __devinit rio_add_device(struct rio_dev *rdev) 265 { 266 device_add(&rdev->dev); 267 268 spin_lock(&rio_global_list_lock); 269 list_add_tail(&rdev->global_list, &rio_devices); 270 spin_unlock(&rio_global_list_lock); 271 272 rio_create_sysfs_dev_files(rdev); 273 } 274 275 /** 276 * rio_setup_device- Allocates and sets up a RIO device 277 * @net: RIO network 278 * @port: Master port to send transactions 279 * @destid: Current destination ID 280 * @hopcount: Current hopcount 281 * @do_enum: Enumeration/Discovery mode flag 282 * 283 * Allocates a RIO device and configures fields based on configuration 284 * space contents. If device has a destination ID register, a destination 285 * ID is either assigned in enumeration mode or read from configuration 286 * space in discovery mode. If the device has switch capabilities, then 287 * a switch is allocated and configured appropriately. Returns a pointer 288 * to a RIO device on success or NULL on failure. 289 * 290 */ 291 static struct rio_dev *rio_setup_device(struct rio_net *net, 292 struct rio_mport *port, u16 destid, 293 u8 hopcount, int do_enum) 294 { 295 struct rio_dev *rdev; 296 struct rio_switch *rswitch; 297 int result, rdid; 298 299 rdev = kmalloc(sizeof(struct rio_dev), GFP_KERNEL); 300 if (!rdev) 301 goto out; 302 303 memset(rdev, 0, sizeof(struct rio_dev)); 304 rdev->net = net; 305 rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_ID_CAR, 306 &result); 307 rdev->did = result >> 16; 308 rdev->vid = result & 0xffff; 309 rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_INFO_CAR, 310 &rdev->device_rev); 311 rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_ID_CAR, 312 &result); 313 rdev->asm_did = result >> 16; 314 rdev->asm_vid = result & 0xffff; 315 rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_INFO_CAR, 316 &result); 317 rdev->asm_rev = result >> 16; 318 rio_mport_read_config_32(port, destid, hopcount, RIO_PEF_CAR, 319 &rdev->pef); 320 if (rdev->pef & RIO_PEF_EXT_FEATURES) 321 rdev->efptr = result & 0xffff; 322 323 rio_mport_read_config_32(port, destid, hopcount, RIO_SRC_OPS_CAR, 324 &rdev->src_ops); 325 rio_mport_read_config_32(port, destid, hopcount, RIO_DST_OPS_CAR, 326 &rdev->dst_ops); 327 328 if (rio_device_has_destid(port, rdev->src_ops, rdev->dst_ops) 329 && do_enum) { 330 rio_set_device_id(port, destid, hopcount, next_destid); 331 rdev->destid = next_destid++; 332 if (next_destid == port->host_deviceid) 333 next_destid++; 334 } else 335 rdev->destid = rio_get_device_id(port, destid, hopcount); 336 337 /* If a PE has both switch and other functions, show it as a switch */ 338 if (rio_is_switch(rdev)) { 339 rio_mport_read_config_32(port, destid, hopcount, 340 RIO_SWP_INFO_CAR, &rdev->swpinfo); 341 rswitch = kmalloc(sizeof(struct rio_switch), GFP_KERNEL); 342 if (!rswitch) { 343 kfree(rdev); 344 rdev = NULL; 345 goto out; 346 } 347 rswitch->switchid = next_switchid; 348 rswitch->hopcount = hopcount; 349 rswitch->destid = 0xffff; 350 /* Initialize switch route table */ 351 for (rdid = 0; rdid < RIO_MAX_ROUTE_ENTRIES; rdid++) 352 rswitch->route_table[rdid] = RIO_INVALID_ROUTE; 353 rdev->rswitch = rswitch; 354 sprintf(rio_name(rdev), "%02x:s:%04x", rdev->net->id, 355 rdev->rswitch->switchid); 356 rio_route_set_ops(rdev); 357 358 list_add_tail(&rswitch->node, &rio_switches); 359 360 } else 361 sprintf(rio_name(rdev), "%02x:e:%04x", rdev->net->id, 362 rdev->destid); 363 364 rdev->dev.bus = &rio_bus_type; 365 366 device_initialize(&rdev->dev); 367 rdev->dev.release = rio_release_dev; 368 rio_dev_get(rdev); 369 370 rdev->dma_mask = DMA_32BIT_MASK; 371 rdev->dev.dma_mask = &rdev->dma_mask; 372 rdev->dev.coherent_dma_mask = DMA_32BIT_MASK; 373 374 if ((rdev->pef & RIO_PEF_INB_DOORBELL) && 375 (rdev->dst_ops & RIO_DST_OPS_DOORBELL)) 376 rio_init_dbell_res(&rdev->riores[RIO_DOORBELL_RESOURCE], 377 0, 0xffff); 378 379 rio_add_device(rdev); 380 381 out: 382 return rdev; 383 } 384 385 /** 386 * rio_sport_is_active- Tests if a switch port has an active connection. 387 * @port: Master port to send transaction 388 * @destid: Associated destination ID for switch 389 * @hopcount: Hopcount to reach switch 390 * @sport: Switch port number 391 * 392 * Reads the port error status CSR for a particular switch port to 393 * determine if the port has an active link. Returns 394 * %PORT_N_ERR_STS_PORT_OK if the port is active or %0 if it is 395 * inactive. 396 */ 397 static int 398 rio_sport_is_active(struct rio_mport *port, u16 destid, u8 hopcount, int sport) 399 { 400 u32 result; 401 u32 ext_ftr_ptr; 402 403 int *entry = rio_sport_phys_table; 404 405 do { 406 if ((ext_ftr_ptr = 407 rio_mport_get_feature(port, 0, destid, hopcount, *entry))) 408 409 break; 410 } while (*++entry >= 0); 411 412 if (ext_ftr_ptr) 413 rio_mport_read_config_32(port, destid, hopcount, 414 ext_ftr_ptr + 415 RIO_PORT_N_ERR_STS_CSR(sport), 416 &result); 417 418 return (result & PORT_N_ERR_STS_PORT_OK); 419 } 420 421 /** 422 * rio_route_add_entry- Add a route entry to a switch routing table 423 * @mport: Master port to send transaction 424 * @rdev: Switch device 425 * @table: Routing table ID 426 * @route_destid: Destination ID to be routed 427 * @route_port: Port number to be routed 428 * 429 * Calls the switch specific add_entry() method to add a route entry 430 * on a switch. The route table can be specified using the @table 431 * argument if a switch has per port routing tables or the normal 432 * use is to specific all tables (or the global table) by passing 433 * %RIO_GLOBAL_TABLE in @table. Returns %0 on success or %-EINVAL 434 * on failure. 435 */ 436 static int rio_route_add_entry(struct rio_mport *mport, struct rio_dev *rdev, 437 u16 table, u16 route_destid, u8 route_port) 438 { 439 return rdev->rswitch->add_entry(mport, rdev->rswitch->destid, 440 rdev->rswitch->hopcount, table, 441 route_destid, route_port); 442 } 443 444 /** 445 * rio_route_get_entry- Read a route entry in a switch routing table 446 * @mport: Master port to send transaction 447 * @rdev: Switch device 448 * @table: Routing table ID 449 * @route_destid: Destination ID to be routed 450 * @route_port: Pointer to read port number into 451 * 452 * Calls the switch specific get_entry() method to read a route entry 453 * in a switch. The route table can be specified using the @table 454 * argument if a switch has per port routing tables or the normal 455 * use is to specific all tables (or the global table) by passing 456 * %RIO_GLOBAL_TABLE in @table. Returns %0 on success or %-EINVAL 457 * on failure. 458 */ 459 static int 460 rio_route_get_entry(struct rio_mport *mport, struct rio_dev *rdev, u16 table, 461 u16 route_destid, u8 * route_port) 462 { 463 return rdev->rswitch->get_entry(mport, rdev->rswitch->destid, 464 rdev->rswitch->hopcount, table, 465 route_destid, route_port); 466 } 467 468 /** 469 * rio_get_host_deviceid_lock- Reads the Host Device ID Lock CSR on a device 470 * @port: Master port to send transaction 471 * @hopcount: Number of hops to the device 472 * 473 * Used during enumeration to read the Host Device ID Lock CSR on a 474 * RIO device. Returns the value of the lock register. 475 */ 476 static u16 rio_get_host_deviceid_lock(struct rio_mport *port, u8 hopcount) 477 { 478 u32 result; 479 480 rio_mport_read_config_32(port, RIO_ANY_DESTID, hopcount, 481 RIO_HOST_DID_LOCK_CSR, &result); 482 483 return (u16) (result & 0xffff); 484 } 485 486 /** 487 * rio_get_swpinfo_inport- Gets the ingress port number 488 * @mport: Master port to send transaction 489 * @destid: Destination ID associated with the switch 490 * @hopcount: Number of hops to the device 491 * 492 * Returns port number being used to access the switch device. 493 */ 494 static u8 495 rio_get_swpinfo_inport(struct rio_mport *mport, u16 destid, u8 hopcount) 496 { 497 u32 result; 498 499 rio_mport_read_config_32(mport, destid, hopcount, RIO_SWP_INFO_CAR, 500 &result); 501 502 return (u8) (result & 0xff); 503 } 504 505 /** 506 * rio_get_swpinfo_tports- Gets total number of ports on the switch 507 * @mport: Master port to send transaction 508 * @destid: Destination ID associated with the switch 509 * @hopcount: Number of hops to the device 510 * 511 * Returns total numbers of ports implemented by the switch device. 512 */ 513 static u8 rio_get_swpinfo_tports(struct rio_mport *mport, u16 destid, 514 u8 hopcount) 515 { 516 u32 result; 517 518 rio_mport_read_config_32(mport, destid, hopcount, RIO_SWP_INFO_CAR, 519 &result); 520 521 return RIO_GET_TOTAL_PORTS(result); 522 } 523 524 /** 525 * rio_net_add_mport- Add a master port to a RIO network 526 * @net: RIO network 527 * @port: Master port to add 528 * 529 * Adds a master port to the network list of associated master 530 * ports.. 531 */ 532 static void rio_net_add_mport(struct rio_net *net, struct rio_mport *port) 533 { 534 spin_lock(&rio_global_list_lock); 535 list_add_tail(&port->nnode, &net->mports); 536 spin_unlock(&rio_global_list_lock); 537 } 538 539 /** 540 * rio_enum_peer- Recursively enumerate a RIO network through a master port 541 * @net: RIO network being enumerated 542 * @port: Master port to send transactions 543 * @hopcount: Number of hops into the network 544 * 545 * Recursively enumerates a RIO network. Transactions are sent via the 546 * master port passed in @port. 547 */ 548 static int rio_enum_peer(struct rio_net *net, struct rio_mport *port, 549 u8 hopcount) 550 { 551 int port_num; 552 int num_ports; 553 int cur_destid; 554 struct rio_dev *rdev; 555 u16 destid; 556 int tmp; 557 558 if (rio_get_host_deviceid_lock(port, hopcount) == port->host_deviceid) { 559 pr_debug("RIO: PE already discovered by this host\n"); 560 /* 561 * Already discovered by this host. Add it as another 562 * master port for the current network. 563 */ 564 rio_net_add_mport(net, port); 565 return 0; 566 } 567 568 /* Attempt to acquire device lock */ 569 rio_mport_write_config_32(port, RIO_ANY_DESTID, hopcount, 570 RIO_HOST_DID_LOCK_CSR, port->host_deviceid); 571 while ((tmp = rio_get_host_deviceid_lock(port, hopcount)) 572 < port->host_deviceid) { 573 /* Delay a bit */ 574 mdelay(1); 575 /* Attempt to acquire device lock again */ 576 rio_mport_write_config_32(port, RIO_ANY_DESTID, hopcount, 577 RIO_HOST_DID_LOCK_CSR, 578 port->host_deviceid); 579 } 580 581 if (rio_get_host_deviceid_lock(port, hopcount) > port->host_deviceid) { 582 pr_debug( 583 "RIO: PE locked by a higher priority host...retreating\n"); 584 return -1; 585 } 586 587 /* Setup new RIO device */ 588 if ((rdev = rio_setup_device(net, port, RIO_ANY_DESTID, hopcount, 1))) { 589 /* Add device to the global and bus/net specific list. */ 590 list_add_tail(&rdev->net_list, &net->devices); 591 } else 592 return -1; 593 594 if (rio_is_switch(rdev)) { 595 next_switchid++; 596 597 for (destid = 0; destid < next_destid; destid++) { 598 rio_route_add_entry(port, rdev, RIO_GLOBAL_TABLE, 599 destid, rio_get_swpinfo_inport(port, 600 RIO_ANY_DESTID, 601 hopcount)); 602 rdev->rswitch->route_table[destid] = 603 rio_get_swpinfo_inport(port, RIO_ANY_DESTID, 604 hopcount); 605 } 606 607 num_ports = 608 rio_get_swpinfo_tports(port, RIO_ANY_DESTID, hopcount); 609 pr_debug( 610 "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n", 611 rio_name(rdev), rdev->vid, rdev->did, num_ports); 612 for (port_num = 0; port_num < num_ports; port_num++) { 613 if (rio_get_swpinfo_inport 614 (port, RIO_ANY_DESTID, hopcount) == port_num) 615 continue; 616 617 cur_destid = next_destid; 618 619 if (rio_sport_is_active 620 (port, RIO_ANY_DESTID, hopcount, port_num)) { 621 pr_debug( 622 "RIO: scanning device on port %d\n", 623 port_num); 624 rio_route_add_entry(port, rdev, 625 RIO_GLOBAL_TABLE, 626 RIO_ANY_DESTID, port_num); 627 628 if (rio_enum_peer(net, port, hopcount + 1) < 0) 629 return -1; 630 631 /* Update routing tables */ 632 if (next_destid > cur_destid) { 633 for (destid = cur_destid; 634 destid < next_destid; destid++) { 635 rio_route_add_entry(port, rdev, 636 RIO_GLOBAL_TABLE, 637 destid, 638 port_num); 639 rdev->rswitch-> 640 route_table[destid] = 641 port_num; 642 } 643 rdev->rswitch->destid = cur_destid; 644 } 645 } 646 } 647 } else 648 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n", 649 rio_name(rdev), rdev->vid, rdev->did); 650 651 return 0; 652 } 653 654 /** 655 * rio_enum_complete- Tests if enumeration of a network is complete 656 * @port: Master port to send transaction 657 * 658 * Tests the Component Tag CSR for presence of the magic enumeration 659 * complete flag. Return %1 if enumeration is complete or %0 if 660 * enumeration is incomplete. 661 */ 662 static int rio_enum_complete(struct rio_mport *port) 663 { 664 u32 tag_csr; 665 int ret = 0; 666 667 rio_local_read_config_32(port, RIO_COMPONENT_TAG_CSR, &tag_csr); 668 669 if (tag_csr == RIO_ENUM_CMPL_MAGIC) 670 ret = 1; 671 672 return ret; 673 } 674 675 /** 676 * rio_disc_peer- Recursively discovers a RIO network through a master port 677 * @net: RIO network being discovered 678 * @port: Master port to send transactions 679 * @destid: Current destination ID in network 680 * @hopcount: Number of hops into the network 681 * 682 * Recursively discovers a RIO network. Transactions are sent via the 683 * master port passed in @port. 684 */ 685 static int 686 rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid, 687 u8 hopcount) 688 { 689 u8 port_num, route_port; 690 int num_ports; 691 struct rio_dev *rdev; 692 u16 ndestid; 693 694 /* Setup new RIO device */ 695 if ((rdev = rio_setup_device(net, port, destid, hopcount, 0))) { 696 /* Add device to the global and bus/net specific list. */ 697 list_add_tail(&rdev->net_list, &net->devices); 698 } else 699 return -1; 700 701 if (rio_is_switch(rdev)) { 702 next_switchid++; 703 704 /* Associated destid is how we accessed this switch */ 705 rdev->rswitch->destid = destid; 706 707 num_ports = rio_get_swpinfo_tports(port, destid, hopcount); 708 pr_debug( 709 "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n", 710 rio_name(rdev), rdev->vid, rdev->did, num_ports); 711 for (port_num = 0; port_num < num_ports; port_num++) { 712 if (rio_get_swpinfo_inport(port, destid, hopcount) == 713 port_num) 714 continue; 715 716 if (rio_sport_is_active 717 (port, destid, hopcount, port_num)) { 718 pr_debug( 719 "RIO: scanning device on port %d\n", 720 port_num); 721 for (ndestid = 0; ndestid < RIO_ANY_DESTID; 722 ndestid++) { 723 rio_route_get_entry(port, rdev, 724 RIO_GLOBAL_TABLE, 725 ndestid, 726 &route_port); 727 if (route_port == port_num) 728 break; 729 } 730 731 if (rio_disc_peer 732 (net, port, ndestid, hopcount + 1) < 0) 733 return -1; 734 } 735 } 736 } else 737 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n", 738 rio_name(rdev), rdev->vid, rdev->did); 739 740 return 0; 741 } 742 743 /** 744 * rio_mport_is_active- Tests if master port link is active 745 * @port: Master port to test 746 * 747 * Reads the port error status CSR for the master port to 748 * determine if the port has an active link. Returns 749 * %PORT_N_ERR_STS_PORT_OK if the master port is active 750 * or %0 if it is inactive. 751 */ 752 static int rio_mport_is_active(struct rio_mport *port) 753 { 754 u32 result = 0; 755 u32 ext_ftr_ptr; 756 int *entry = rio_mport_phys_table; 757 758 do { 759 if ((ext_ftr_ptr = 760 rio_mport_get_feature(port, 1, 0, 0, *entry))) 761 break; 762 } while (*++entry >= 0); 763 764 if (ext_ftr_ptr) 765 rio_local_read_config_32(port, 766 ext_ftr_ptr + 767 RIO_PORT_N_ERR_STS_CSR(port->index), 768 &result); 769 770 return (result & PORT_N_ERR_STS_PORT_OK); 771 } 772 773 /** 774 * rio_alloc_net- Allocate and configure a new RIO network 775 * @port: Master port associated with the RIO network 776 * 777 * Allocates a RIO network structure, initializes per-network 778 * list heads, and adds the associated master port to the 779 * network list of associated master ports. Returns a 780 * RIO network pointer on success or %NULL on failure. 781 */ 782 static struct rio_net __devinit *rio_alloc_net(struct rio_mport *port) 783 { 784 struct rio_net *net; 785 786 net = kmalloc(sizeof(struct rio_net), GFP_KERNEL); 787 if (net) { 788 memset(net, 0, sizeof(struct rio_net)); 789 INIT_LIST_HEAD(&net->node); 790 INIT_LIST_HEAD(&net->devices); 791 INIT_LIST_HEAD(&net->mports); 792 list_add_tail(&port->nnode, &net->mports); 793 net->hport = port; 794 net->id = next_net++; 795 } 796 return net; 797 } 798 799 /** 800 * rio_enum_mport- Start enumeration through a master port 801 * @mport: Master port to send transactions 802 * 803 * Starts the enumeration process. If somebody has enumerated our 804 * master port device, then give up. If not and we have an active 805 * link, then start recursive peer enumeration. Returns %0 if 806 * enumeration succeeds or %-EBUSY if enumeration fails. 807 */ 808 int rio_enum_mport(struct rio_mport *mport) 809 { 810 struct rio_net *net = NULL; 811 int rc = 0; 812 813 printk(KERN_INFO "RIO: enumerate master port %d, %s\n", mport->id, 814 mport->name); 815 /* If somebody else enumerated our master port device, bail. */ 816 if (rio_enum_host(mport) < 0) { 817 printk(KERN_INFO 818 "RIO: master port %d device has been enumerated by a remote host\n", 819 mport->id); 820 rc = -EBUSY; 821 goto out; 822 } 823 824 /* If master port has an active link, allocate net and enum peers */ 825 if (rio_mport_is_active(mport)) { 826 if (!(net = rio_alloc_net(mport))) { 827 printk(KERN_ERR "RIO: failed to allocate new net\n"); 828 rc = -ENOMEM; 829 goto out; 830 } 831 if (rio_enum_peer(net, mport, 0) < 0) { 832 /* A higher priority host won enumeration, bail. */ 833 printk(KERN_INFO 834 "RIO: master port %d device has lost enumeration to a remote host\n", 835 mport->id); 836 rio_clear_locks(mport); 837 rc = -EBUSY; 838 goto out; 839 } 840 rio_clear_locks(mport); 841 } else { 842 printk(KERN_INFO "RIO: master port %d link inactive\n", 843 mport->id); 844 rc = -EINVAL; 845 } 846 847 out: 848 return rc; 849 } 850 851 /** 852 * rio_build_route_tables- Generate route tables from switch route entries 853 * 854 * For each switch device, generate a route table by copying existing 855 * route entries from the switch. 856 */ 857 static void rio_build_route_tables(void) 858 { 859 struct rio_dev *rdev; 860 int i; 861 u8 sport; 862 863 list_for_each_entry(rdev, &rio_devices, global_list) 864 if (rio_is_switch(rdev)) 865 for (i = 0; i < RIO_MAX_ROUTE_ENTRIES; i++) { 866 if (rio_route_get_entry 867 (rdev->net->hport, rdev, RIO_GLOBAL_TABLE, i, 868 &sport) < 0) 869 continue; 870 rdev->rswitch->route_table[i] = sport; 871 } 872 } 873 874 /** 875 * rio_enum_timeout- Signal that enumeration timed out 876 * @data: Address of timeout flag. 877 * 878 * When the enumeration complete timer expires, set a flag that 879 * signals to the discovery process that enumeration did not 880 * complete in a sane amount of time. 881 */ 882 static void rio_enum_timeout(unsigned long data) 883 { 884 /* Enumeration timed out, set flag */ 885 *(int *)data = 1; 886 } 887 888 /** 889 * rio_disc_mport- Start discovery through a master port 890 * @mport: Master port to send transactions 891 * 892 * Starts the discovery process. If we have an active link, 893 * then wait for the signal that enumeration is complete. 894 * When enumeration completion is signaled, start recursive 895 * peer discovery. Returns %0 if discovery succeeds or %-EBUSY 896 * on failure. 897 */ 898 int rio_disc_mport(struct rio_mport *mport) 899 { 900 struct rio_net *net = NULL; 901 int enum_timeout_flag = 0; 902 903 printk(KERN_INFO "RIO: discover master port %d, %s\n", mport->id, 904 mport->name); 905 906 /* If master port has an active link, allocate net and discover peers */ 907 if (rio_mport_is_active(mport)) { 908 if (!(net = rio_alloc_net(mport))) { 909 printk(KERN_ERR "RIO: Failed to allocate new net\n"); 910 goto bail; 911 } 912 913 pr_debug("RIO: wait for enumeration complete..."); 914 915 rio_enum_timer.expires = 916 jiffies + CONFIG_RAPIDIO_DISC_TIMEOUT * HZ; 917 rio_enum_timer.data = (unsigned long)&enum_timeout_flag; 918 add_timer(&rio_enum_timer); 919 while (!rio_enum_complete(mport)) { 920 mdelay(1); 921 if (enum_timeout_flag) { 922 del_timer_sync(&rio_enum_timer); 923 goto timeout; 924 } 925 } 926 del_timer_sync(&rio_enum_timer); 927 928 pr_debug("done\n"); 929 if (rio_disc_peer(net, mport, RIO_ANY_DESTID, 0) < 0) { 930 printk(KERN_INFO 931 "RIO: master port %d device has failed discovery\n", 932 mport->id); 933 goto bail; 934 } 935 936 rio_build_route_tables(); 937 } 938 939 return 0; 940 941 timeout: 942 pr_debug("timeout\n"); 943 bail: 944 return -EBUSY; 945 } 946