rio-scan.c revision a93192a5d245a262dc52fa426de5b20467308a77
1/* 2 * RapidIO enumeration and discovery support 3 * 4 * Copyright 2005 MontaVista Software, Inc. 5 * Matt Porter <mporter@kernel.crashing.org> 6 * 7 * Copyright 2009 Integrated Device Technology, Inc. 8 * Alex Bounine <alexandre.bounine@idt.com> 9 * - Added Port-Write/Error Management initialization and handling 10 * 11 * Copyright 2009 Sysgo AG 12 * Thomas Moll <thomas.moll@sysgo.com> 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/jiffies.h> 35#include <linux/slab.h> 36 37#include "rio.h" 38 39LIST_HEAD(rio_devices); 40static LIST_HEAD(rio_switches); 41 42static void rio_enum_timeout(unsigned long); 43 44static void rio_init_em(struct rio_dev *rdev); 45 46DEFINE_SPINLOCK(rio_global_list_lock); 47 48static int next_destid = 0; 49static int next_switchid = 0; 50static int next_net = 0; 51static int next_comptag = 1; 52 53static struct timer_list rio_enum_timer = 54TIMER_INITIALIZER(rio_enum_timeout, 0, 0); 55 56static int rio_mport_phys_table[] = { 57 RIO_EFB_PAR_EP_ID, 58 RIO_EFB_PAR_EP_REC_ID, 59 RIO_EFB_SER_EP_ID, 60 RIO_EFB_SER_EP_REC_ID, 61 -1, 62}; 63 64/** 65 * rio_get_device_id - Get the base/extended device id for a device 66 * @port: RIO master port 67 * @destid: Destination ID of device 68 * @hopcount: Hopcount to device 69 * 70 * Reads the base/extended device id from a device. Returns the 71 * 8/16-bit device ID. 72 */ 73static u16 rio_get_device_id(struct rio_mport *port, u16 destid, u8 hopcount) 74{ 75 u32 result; 76 77 rio_mport_read_config_32(port, destid, hopcount, RIO_DID_CSR, &result); 78 79 return RIO_GET_DID(port->sys_size, result); 80} 81 82/** 83 * rio_set_device_id - Set the base/extended device id for a device 84 * @port: RIO master port 85 * @destid: Destination ID of device 86 * @hopcount: Hopcount to device 87 * @did: Device ID value to be written 88 * 89 * Writes the base/extended device id from a device. 90 */ 91static void rio_set_device_id(struct rio_mport *port, u16 destid, u8 hopcount, u16 did) 92{ 93 rio_mport_write_config_32(port, destid, hopcount, RIO_DID_CSR, 94 RIO_SET_DID(port->sys_size, did)); 95} 96 97/** 98 * rio_local_set_device_id - Set the base/extended device id for a port 99 * @port: RIO master port 100 * @did: Device ID value to be written 101 * 102 * Writes the base/extended device id from a device. 103 */ 104static void rio_local_set_device_id(struct rio_mport *port, u16 did) 105{ 106 rio_local_write_config_32(port, RIO_DID_CSR, RIO_SET_DID(port->sys_size, 107 did)); 108} 109 110/** 111 * rio_clear_locks- Release all host locks and signal enumeration complete 112 * @port: Master port to issue transaction 113 * 114 * Marks the component tag CSR on each device with the enumeration 115 * complete flag. When complete, it then release the host locks on 116 * each device. Returns 0 on success or %-EINVAL on failure. 117 */ 118static int rio_clear_locks(struct rio_mport *port) 119{ 120 struct rio_dev *rdev; 121 u32 result; 122 int ret = 0; 123 124 /* Release host device id locks */ 125 rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR, 126 port->host_deviceid); 127 rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result); 128 if ((result & 0xffff) != 0xffff) { 129 printk(KERN_INFO 130 "RIO: badness when releasing host lock on master port, result %8.8x\n", 131 result); 132 ret = -EINVAL; 133 } 134 list_for_each_entry(rdev, &rio_devices, global_list) { 135 rio_write_config_32(rdev, RIO_HOST_DID_LOCK_CSR, 136 port->host_deviceid); 137 rio_read_config_32(rdev, RIO_HOST_DID_LOCK_CSR, &result); 138 if ((result & 0xffff) != 0xffff) { 139 printk(KERN_INFO 140 "RIO: badness when releasing host lock on vid %4.4x did %4.4x\n", 141 rdev->vid, rdev->did); 142 ret = -EINVAL; 143 } 144 145 /* Mark device as discovered and enable master */ 146 rio_read_config_32(rdev, 147 rdev->phys_efptr + RIO_PORT_GEN_CTL_CSR, 148 &result); 149 result |= RIO_PORT_GEN_DISCOVERED | RIO_PORT_GEN_MASTER; 150 rio_write_config_32(rdev, 151 rdev->phys_efptr + RIO_PORT_GEN_CTL_CSR, 152 result); 153 } 154 155 return ret; 156} 157 158/** 159 * rio_enum_host- Set host lock and initialize host destination ID 160 * @port: Master port to issue transaction 161 * 162 * Sets the local host master port lock and destination ID register 163 * with the host device ID value. The host device ID value is provided 164 * by the platform. Returns %0 on success or %-1 on failure. 165 */ 166static int rio_enum_host(struct rio_mport *port) 167{ 168 u32 result; 169 170 /* Set master port host device id lock */ 171 rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR, 172 port->host_deviceid); 173 174 rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result); 175 if ((result & 0xffff) != port->host_deviceid) 176 return -1; 177 178 /* Set master port destid and init destid ctr */ 179 rio_local_set_device_id(port, port->host_deviceid); 180 181 if (next_destid == port->host_deviceid) 182 next_destid++; 183 184 return 0; 185} 186 187/** 188 * rio_device_has_destid- Test if a device contains a destination ID register 189 * @port: Master port to issue transaction 190 * @src_ops: RIO device source operations 191 * @dst_ops: RIO device destination operations 192 * 193 * Checks the provided @src_ops and @dst_ops for the necessary transaction 194 * capabilities that indicate whether or not a device will implement a 195 * destination ID register. Returns 1 if true or 0 if false. 196 */ 197static int rio_device_has_destid(struct rio_mport *port, int src_ops, 198 int dst_ops) 199{ 200 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; 201 202 return !!((src_ops | dst_ops) & mask); 203} 204 205/** 206 * rio_release_dev- Frees a RIO device struct 207 * @dev: LDM device associated with a RIO device struct 208 * 209 * Gets the RIO device struct associated a RIO device struct. 210 * The RIO device struct is freed. 211 */ 212static void rio_release_dev(struct device *dev) 213{ 214 struct rio_dev *rdev; 215 216 rdev = to_rio_dev(dev); 217 kfree(rdev); 218} 219 220/** 221 * rio_is_switch- Tests if a RIO device has switch capabilities 222 * @rdev: RIO device 223 * 224 * Gets the RIO device Processing Element Features register 225 * contents and tests for switch capabilities. Returns 1 if 226 * the device is a switch or 0 if it is not a switch. 227 * The RIO device struct is freed. 228 */ 229static int rio_is_switch(struct rio_dev *rdev) 230{ 231 if (rdev->pef & RIO_PEF_SWITCH) 232 return 1; 233 return 0; 234} 235 236/** 237 * rio_switch_init - Sets switch operations for a particular vendor switch 238 * @rdev: RIO device 239 * @do_enum: Enumeration/Discovery mode flag 240 * 241 * Searches the RIO switch ops table for known switch types. If the vid 242 * and did match a switch table entry, then call switch initialization 243 * routine to setup switch-specific routines. 244 */ 245static void rio_switch_init(struct rio_dev *rdev, int do_enum) 246{ 247 struct rio_switch_ops *cur = __start_rio_switch_ops; 248 struct rio_switch_ops *end = __end_rio_switch_ops; 249 250 while (cur < end) { 251 if ((cur->vid == rdev->vid) && (cur->did == rdev->did)) { 252 pr_debug("RIO: calling init routine for %s\n", 253 rio_name(rdev)); 254 cur->init_hook(rdev, do_enum); 255 break; 256 } 257 cur++; 258 } 259 260 if ((cur >= end) && (rdev->pef & RIO_PEF_STD_RT)) { 261 pr_debug("RIO: adding STD routing ops for %s\n", 262 rio_name(rdev)); 263 rdev->rswitch->add_entry = rio_std_route_add_entry; 264 rdev->rswitch->get_entry = rio_std_route_get_entry; 265 rdev->rswitch->clr_table = rio_std_route_clr_table; 266 } 267 268 if (!rdev->rswitch->add_entry || !rdev->rswitch->get_entry) 269 printk(KERN_ERR "RIO: missing routing ops for %s\n", 270 rio_name(rdev)); 271} 272 273/** 274 * rio_add_device- Adds a RIO device to the device model 275 * @rdev: RIO device 276 * 277 * Adds the RIO device to the global device list and adds the RIO 278 * device to the RIO device list. Creates the generic sysfs nodes 279 * for an RIO device. 280 */ 281static int __devinit rio_add_device(struct rio_dev *rdev) 282{ 283 int err; 284 285 err = device_add(&rdev->dev); 286 if (err) 287 return err; 288 289 spin_lock(&rio_global_list_lock); 290 list_add_tail(&rdev->global_list, &rio_devices); 291 spin_unlock(&rio_global_list_lock); 292 293 rio_create_sysfs_dev_files(rdev); 294 295 return 0; 296} 297 298/** 299 * rio_enable_rx_tx_port - enable input reciever and output transmitter of 300 * given port 301 * @port: Master port associated with the RIO network 302 * @local: local=1 select local port otherwise a far device is reached 303 * @destid: Destination ID of the device to check host bit 304 * @hopcount: Number of hops to reach the target 305 * @port_num: Port (-number on switch) to enable on a far end device 306 * 307 * Returns 0 or 1 from on General Control Command and Status Register 308 * (EXT_PTR+0x3C) 309 */ 310inline int rio_enable_rx_tx_port(struct rio_mport *port, 311 int local, u16 destid, 312 u8 hopcount, u8 port_num) { 313#ifdef CONFIG_RAPIDIO_ENABLE_RX_TX_PORTS 314 u32 regval; 315 u32 ext_ftr_ptr; 316 317 /* 318 * enable rx input tx output port 319 */ 320 pr_debug("rio_enable_rx_tx_port(local = %d, destid = %d, hopcount = " 321 "%d, port_num = %d)\n", local, destid, hopcount, port_num); 322 323 ext_ftr_ptr = rio_mport_get_physefb(port, local, destid, hopcount); 324 325 if (local) { 326 rio_local_read_config_32(port, ext_ftr_ptr + 327 RIO_PORT_N_CTL_CSR(0), 328 ®val); 329 } else { 330 if (rio_mport_read_config_32(port, destid, hopcount, 331 ext_ftr_ptr + RIO_PORT_N_CTL_CSR(port_num), ®val) < 0) 332 return -EIO; 333 } 334 335 if (regval & RIO_PORT_N_CTL_P_TYP_SER) { 336 /* serial */ 337 regval = regval | RIO_PORT_N_CTL_EN_RX_SER 338 | RIO_PORT_N_CTL_EN_TX_SER; 339 } else { 340 /* parallel */ 341 regval = regval | RIO_PORT_N_CTL_EN_RX_PAR 342 | RIO_PORT_N_CTL_EN_TX_PAR; 343 } 344 345 if (local) { 346 rio_local_write_config_32(port, ext_ftr_ptr + 347 RIO_PORT_N_CTL_CSR(0), regval); 348 } else { 349 if (rio_mport_write_config_32(port, destid, hopcount, 350 ext_ftr_ptr + RIO_PORT_N_CTL_CSR(port_num), regval) < 0) 351 return -EIO; 352 } 353#endif 354 return 0; 355} 356 357/** 358 * rio_setup_device- Allocates and sets up a RIO device 359 * @net: RIO network 360 * @port: Master port to send transactions 361 * @destid: Current destination ID 362 * @hopcount: Current hopcount 363 * @do_enum: Enumeration/Discovery mode flag 364 * 365 * Allocates a RIO device and configures fields based on configuration 366 * space contents. If device has a destination ID register, a destination 367 * ID is either assigned in enumeration mode or read from configuration 368 * space in discovery mode. If the device has switch capabilities, then 369 * a switch is allocated and configured appropriately. Returns a pointer 370 * to a RIO device on success or NULL on failure. 371 * 372 */ 373static struct rio_dev __devinit *rio_setup_device(struct rio_net *net, 374 struct rio_mport *port, u16 destid, 375 u8 hopcount, int do_enum) 376{ 377 int ret = 0; 378 struct rio_dev *rdev; 379 struct rio_switch *rswitch = NULL; 380 int result, rdid; 381 382 rdev = kzalloc(sizeof(struct rio_dev), GFP_KERNEL); 383 if (!rdev) 384 return NULL; 385 386 rdev->net = net; 387 rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_ID_CAR, 388 &result); 389 rdev->did = result >> 16; 390 rdev->vid = result & 0xffff; 391 rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_INFO_CAR, 392 &rdev->device_rev); 393 rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_ID_CAR, 394 &result); 395 rdev->asm_did = result >> 16; 396 rdev->asm_vid = result & 0xffff; 397 rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_INFO_CAR, 398 &result); 399 rdev->asm_rev = result >> 16; 400 rio_mport_read_config_32(port, destid, hopcount, RIO_PEF_CAR, 401 &rdev->pef); 402 if (rdev->pef & RIO_PEF_EXT_FEATURES) { 403 rdev->efptr = result & 0xffff; 404 rdev->phys_efptr = rio_mport_get_physefb(port, 0, destid, 405 hopcount); 406 407 rdev->em_efptr = rio_mport_get_feature(port, 0, destid, 408 hopcount, RIO_EFB_ERR_MGMNT); 409 } 410 411 if (rdev->pef & (RIO_PEF_SWITCH | RIO_PEF_MULTIPORT)) { 412 rio_mport_read_config_32(port, destid, hopcount, 413 RIO_SWP_INFO_CAR, &rdev->swpinfo); 414 } 415 416 rio_mport_read_config_32(port, destid, hopcount, RIO_SRC_OPS_CAR, 417 &rdev->src_ops); 418 rio_mport_read_config_32(port, destid, hopcount, RIO_DST_OPS_CAR, 419 &rdev->dst_ops); 420 421 if (do_enum) { 422 /* Assign component tag to device */ 423 if (next_comptag >= 0x10000) { 424 pr_err("RIO: Component Tag Counter Overflow\n"); 425 goto cleanup; 426 } 427 rio_mport_write_config_32(port, destid, hopcount, 428 RIO_COMPONENT_TAG_CSR, next_comptag); 429 rdev->comp_tag = next_comptag++; 430 } 431 432 if (rio_device_has_destid(port, rdev->src_ops, rdev->dst_ops)) { 433 if (do_enum) { 434 rio_set_device_id(port, destid, hopcount, next_destid); 435 rdev->destid = next_destid++; 436 if (next_destid == port->host_deviceid) 437 next_destid++; 438 } else 439 rdev->destid = rio_get_device_id(port, destid, hopcount); 440 441 rdev->hopcount = 0xff; 442 } else { 443 /* Switch device has an associated destID which 444 * will be adjusted later 445 */ 446 rdev->destid = destid; 447 rdev->hopcount = hopcount; 448 } 449 450 /* If a PE has both switch and other functions, show it as a switch */ 451 if (rio_is_switch(rdev)) { 452 rswitch = kzalloc(sizeof(*rswitch) + 453 RIO_GET_TOTAL_PORTS(rdev->swpinfo) * 454 sizeof(rswitch->nextdev[0]), 455 GFP_KERNEL); 456 if (!rswitch) 457 goto cleanup; 458 rswitch->switchid = next_switchid; 459 rswitch->port_ok = 0; 460 rswitch->route_table = kzalloc(sizeof(u8)* 461 RIO_MAX_ROUTE_ENTRIES(port->sys_size), 462 GFP_KERNEL); 463 if (!rswitch->route_table) 464 goto cleanup; 465 /* Initialize switch route table */ 466 for (rdid = 0; rdid < RIO_MAX_ROUTE_ENTRIES(port->sys_size); 467 rdid++) 468 rswitch->route_table[rdid] = RIO_INVALID_ROUTE; 469 rdev->rswitch = rswitch; 470 rswitch->rdev = rdev; 471 dev_set_name(&rdev->dev, "%02x:s:%04x", rdev->net->id, 472 rdev->rswitch->switchid); 473 rio_switch_init(rdev, do_enum); 474 475 if (do_enum && rdev->rswitch->clr_table) 476 rdev->rswitch->clr_table(port, destid, hopcount, 477 RIO_GLOBAL_TABLE); 478 479 list_add_tail(&rswitch->node, &rio_switches); 480 481 } else { 482 if (do_enum) 483 /*Enable Input Output Port (transmitter reviever)*/ 484 rio_enable_rx_tx_port(port, 0, destid, hopcount, 0); 485 486 dev_set_name(&rdev->dev, "%02x:e:%04x", rdev->net->id, 487 rdev->destid); 488 } 489 490 rdev->dev.bus = &rio_bus_type; 491 rdev->dev.parent = &rio_bus; 492 493 device_initialize(&rdev->dev); 494 rdev->dev.release = rio_release_dev; 495 rio_dev_get(rdev); 496 497 rdev->dma_mask = DMA_BIT_MASK(32); 498 rdev->dev.dma_mask = &rdev->dma_mask; 499 rdev->dev.coherent_dma_mask = DMA_BIT_MASK(32); 500 501 if ((rdev->pef & RIO_PEF_INB_DOORBELL) && 502 (rdev->dst_ops & RIO_DST_OPS_DOORBELL)) 503 rio_init_dbell_res(&rdev->riores[RIO_DOORBELL_RESOURCE], 504 0, 0xffff); 505 506 ret = rio_add_device(rdev); 507 if (ret) 508 goto cleanup; 509 510 return rdev; 511 512cleanup: 513 if (rswitch) { 514 kfree(rswitch->route_table); 515 kfree(rswitch); 516 } 517 kfree(rdev); 518 return NULL; 519} 520 521/** 522 * rio_sport_is_active- Tests if a switch port has an active connection. 523 * @port: Master port to send transaction 524 * @destid: Associated destination ID for switch 525 * @hopcount: Hopcount to reach switch 526 * @sport: Switch port number 527 * 528 * Reads the port error status CSR for a particular switch port to 529 * determine if the port has an active link. Returns 530 * %RIO_PORT_N_ERR_STS_PORT_OK if the port is active or %0 if it is 531 * inactive. 532 */ 533static int 534rio_sport_is_active(struct rio_mport *port, u16 destid, u8 hopcount, int sport) 535{ 536 u32 result = 0; 537 u32 ext_ftr_ptr; 538 539 ext_ftr_ptr = rio_mport_get_efb(port, 0, destid, hopcount, 0); 540 541 while (ext_ftr_ptr) { 542 rio_mport_read_config_32(port, destid, hopcount, 543 ext_ftr_ptr, &result); 544 result = RIO_GET_BLOCK_ID(result); 545 if ((result == RIO_EFB_SER_EP_FREE_ID) || 546 (result == RIO_EFB_SER_EP_FREE_ID_V13P) || 547 (result == RIO_EFB_SER_EP_FREC_ID)) 548 break; 549 550 ext_ftr_ptr = rio_mport_get_efb(port, 0, destid, hopcount, 551 ext_ftr_ptr); 552 } 553 554 if (ext_ftr_ptr) 555 rio_mport_read_config_32(port, destid, hopcount, 556 ext_ftr_ptr + 557 RIO_PORT_N_ERR_STS_CSR(sport), 558 &result); 559 560 return result & RIO_PORT_N_ERR_STS_PORT_OK; 561} 562 563/** 564 * rio_lock_device - Acquires host device lock for specified device 565 * @port: Master port to send transaction 566 * @destid: Destination ID for device/switch 567 * @hopcount: Hopcount to reach switch 568 * @wait_ms: Max wait time in msec (0 = no timeout) 569 * 570 * Attepts to acquire host device lock for specified device 571 * Returns 0 if device lock acquired or EINVAL if timeout expires. 572 */ 573static int 574rio_lock_device(struct rio_mport *port, u16 destid, u8 hopcount, int wait_ms) 575{ 576 u32 result; 577 int tcnt = 0; 578 579 /* Attempt to acquire device lock */ 580 rio_mport_write_config_32(port, destid, hopcount, 581 RIO_HOST_DID_LOCK_CSR, port->host_deviceid); 582 rio_mport_read_config_32(port, destid, hopcount, 583 RIO_HOST_DID_LOCK_CSR, &result); 584 585 while (result != port->host_deviceid) { 586 if (wait_ms != 0 && tcnt == wait_ms) { 587 pr_debug("RIO: timeout when locking device %x:%x\n", 588 destid, hopcount); 589 return -EINVAL; 590 } 591 592 /* Delay a bit */ 593 mdelay(1); 594 tcnt++; 595 /* Try to acquire device lock again */ 596 rio_mport_write_config_32(port, destid, 597 hopcount, 598 RIO_HOST_DID_LOCK_CSR, 599 port->host_deviceid); 600 rio_mport_read_config_32(port, destid, 601 hopcount, 602 RIO_HOST_DID_LOCK_CSR, &result); 603 } 604 605 return 0; 606} 607 608/** 609 * rio_unlock_device - Releases host device lock for specified device 610 * @port: Master port to send transaction 611 * @destid: Destination ID for device/switch 612 * @hopcount: Hopcount to reach switch 613 * 614 * Returns 0 if device lock released or EINVAL if fails. 615 */ 616static int 617rio_unlock_device(struct rio_mport *port, u16 destid, u8 hopcount) 618{ 619 u32 result; 620 621 /* Release device lock */ 622 rio_mport_write_config_32(port, destid, 623 hopcount, 624 RIO_HOST_DID_LOCK_CSR, 625 port->host_deviceid); 626 rio_mport_read_config_32(port, destid, hopcount, 627 RIO_HOST_DID_LOCK_CSR, &result); 628 if ((result & 0xffff) != 0xffff) { 629 pr_debug("RIO: badness when releasing device lock %x:%x\n", 630 destid, hopcount); 631 return -EINVAL; 632 } 633 634 return 0; 635} 636 637/** 638 * rio_route_add_entry- Add a route entry to a switch routing table 639 * @rdev: RIO device 640 * @table: Routing table ID 641 * @route_destid: Destination ID to be routed 642 * @route_port: Port number to be routed 643 * @lock: lock switch device flag 644 * 645 * Calls the switch specific add_entry() method to add a route entry 646 * on a switch. The route table can be specified using the @table 647 * argument if a switch has per port routing tables or the normal 648 * use is to specific all tables (or the global table) by passing 649 * %RIO_GLOBAL_TABLE in @table. Returns %0 on success or %-EINVAL 650 * on failure. 651 */ 652static int 653rio_route_add_entry(struct rio_dev *rdev, 654 u16 table, u16 route_destid, u8 route_port, int lock) 655{ 656 int rc; 657 658 if (lock) { 659 rc = rio_lock_device(rdev->net->hport, rdev->destid, 660 rdev->hopcount, 1000); 661 if (rc) 662 return rc; 663 } 664 665 rc = rdev->rswitch->add_entry(rdev->net->hport, rdev->destid, 666 rdev->hopcount, table, 667 route_destid, route_port); 668 if (lock) 669 rio_unlock_device(rdev->net->hport, rdev->destid, 670 rdev->hopcount); 671 672 return rc; 673} 674 675/** 676 * rio_route_get_entry- Read a route entry in a switch routing table 677 * @rdev: RIO device 678 * @table: Routing table ID 679 * @route_destid: Destination ID to be routed 680 * @route_port: Pointer to read port number into 681 * @lock: lock switch device flag 682 * 683 * Calls the switch specific get_entry() method to read a route entry 684 * in a switch. The route table can be specified using the @table 685 * argument if a switch has per port routing tables or the normal 686 * use is to specific all tables (or the global table) by passing 687 * %RIO_GLOBAL_TABLE in @table. Returns %0 on success or %-EINVAL 688 * on failure. 689 */ 690static int 691rio_route_get_entry(struct rio_dev *rdev, u16 table, 692 u16 route_destid, u8 *route_port, int lock) 693{ 694 int rc; 695 696 if (lock) { 697 rc = rio_lock_device(rdev->net->hport, rdev->destid, 698 rdev->hopcount, 1000); 699 if (rc) 700 return rc; 701 } 702 703 rc = rdev->rswitch->get_entry(rdev->net->hport, rdev->destid, 704 rdev->hopcount, table, 705 route_destid, route_port); 706 if (lock) 707 rio_unlock_device(rdev->net->hport, rdev->destid, 708 rdev->hopcount); 709 710 return rc; 711} 712 713/** 714 * rio_get_host_deviceid_lock- Reads the Host Device ID Lock CSR on a device 715 * @port: Master port to send transaction 716 * @hopcount: Number of hops to the device 717 * 718 * Used during enumeration to read the Host Device ID Lock CSR on a 719 * RIO device. Returns the value of the lock register. 720 */ 721static u16 rio_get_host_deviceid_lock(struct rio_mport *port, u8 hopcount) 722{ 723 u32 result; 724 725 rio_mport_read_config_32(port, RIO_ANY_DESTID(port->sys_size), hopcount, 726 RIO_HOST_DID_LOCK_CSR, &result); 727 728 return (u16) (result & 0xffff); 729} 730 731/** 732 * rio_enum_peer- Recursively enumerate a RIO network through a master port 733 * @net: RIO network being enumerated 734 * @port: Master port to send transactions 735 * @hopcount: Number of hops into the network 736 * @prev: Previous RIO device connected to the enumerated one 737 * @prev_port: Port on previous RIO device 738 * 739 * Recursively enumerates a RIO network. Transactions are sent via the 740 * master port passed in @port. 741 */ 742static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port, 743 u8 hopcount, struct rio_dev *prev, int prev_port) 744{ 745 int port_num; 746 int cur_destid; 747 int sw_destid; 748 int sw_inport; 749 struct rio_dev *rdev; 750 u16 destid; 751 u32 regval; 752 int tmp; 753 754 if (rio_mport_chk_dev_access(port, 755 RIO_ANY_DESTID(port->sys_size), hopcount)) { 756 pr_debug("RIO: device access check failed\n"); 757 return -1; 758 } 759 760 if (rio_get_host_deviceid_lock(port, hopcount) == port->host_deviceid) { 761 pr_debug("RIO: PE already discovered by this host\n"); 762 /* 763 * Already discovered by this host. Add it as another 764 * link to the existing device. 765 */ 766 rio_mport_read_config_32(port, RIO_ANY_DESTID(port->sys_size), 767 hopcount, RIO_COMPONENT_TAG_CSR, ®val); 768 769 if (regval) { 770 rdev = rio_get_comptag((regval & 0xffff), NULL); 771 772 if (rdev && prev && rio_is_switch(prev)) { 773 pr_debug("RIO: redundant path to %s\n", 774 rio_name(rdev)); 775 prev->rswitch->nextdev[prev_port] = rdev; 776 } 777 } 778 779 return 0; 780 } 781 782 /* Attempt to acquire device lock */ 783 rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size), 784 hopcount, 785 RIO_HOST_DID_LOCK_CSR, port->host_deviceid); 786 while ((tmp = rio_get_host_deviceid_lock(port, hopcount)) 787 < port->host_deviceid) { 788 /* Delay a bit */ 789 mdelay(1); 790 /* Attempt to acquire device lock again */ 791 rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size), 792 hopcount, 793 RIO_HOST_DID_LOCK_CSR, 794 port->host_deviceid); 795 } 796 797 if (rio_get_host_deviceid_lock(port, hopcount) > port->host_deviceid) { 798 pr_debug( 799 "RIO: PE locked by a higher priority host...retreating\n"); 800 return -1; 801 } 802 803 /* Setup new RIO device */ 804 rdev = rio_setup_device(net, port, RIO_ANY_DESTID(port->sys_size), 805 hopcount, 1); 806 if (rdev) { 807 /* Add device to the global and bus/net specific list. */ 808 list_add_tail(&rdev->net_list, &net->devices); 809 rdev->prev = prev; 810 if (prev && rio_is_switch(prev)) 811 prev->rswitch->nextdev[prev_port] = rdev; 812 } else 813 return -1; 814 815 if (rio_is_switch(rdev)) { 816 next_switchid++; 817 sw_inport = RIO_GET_PORT_NUM(rdev->swpinfo); 818 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE, 819 port->host_deviceid, sw_inport, 0); 820 rdev->rswitch->route_table[port->host_deviceid] = sw_inport; 821 822 for (destid = 0; destid < next_destid; destid++) { 823 if (destid == port->host_deviceid) 824 continue; 825 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE, 826 destid, sw_inport, 0); 827 rdev->rswitch->route_table[destid] = sw_inport; 828 } 829 830 pr_debug( 831 "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n", 832 rio_name(rdev), rdev->vid, rdev->did, 833 RIO_GET_TOTAL_PORTS(rdev->swpinfo)); 834 sw_destid = next_destid; 835 for (port_num = 0; 836 port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo); 837 port_num++) { 838 /*Enable Input Output Port (transmitter reviever)*/ 839 rio_enable_rx_tx_port(port, 0, 840 RIO_ANY_DESTID(port->sys_size), 841 hopcount, port_num); 842 843 if (sw_inport == port_num) { 844 rdev->rswitch->port_ok |= (1 << port_num); 845 continue; 846 } 847 848 cur_destid = next_destid; 849 850 if (rio_sport_is_active 851 (port, RIO_ANY_DESTID(port->sys_size), hopcount, 852 port_num)) { 853 pr_debug( 854 "RIO: scanning device on port %d\n", 855 port_num); 856 rdev->rswitch->port_ok |= (1 << port_num); 857 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE, 858 RIO_ANY_DESTID(port->sys_size), 859 port_num, 0); 860 861 if (rio_enum_peer(net, port, hopcount + 1, 862 rdev, port_num) < 0) 863 return -1; 864 865 /* Update routing tables */ 866 if (next_destid > cur_destid) { 867 for (destid = cur_destid; 868 destid < next_destid; destid++) { 869 if (destid == port->host_deviceid) 870 continue; 871 rio_route_add_entry(rdev, 872 RIO_GLOBAL_TABLE, 873 destid, 874 port_num, 875 0); 876 rdev->rswitch-> 877 route_table[destid] = 878 port_num; 879 } 880 } 881 } else { 882 /* If switch supports Error Management, 883 * set PORT_LOCKOUT bit for unused port 884 */ 885 if (rdev->em_efptr) 886 rio_set_port_lockout(rdev, port_num, 1); 887 888 rdev->rswitch->port_ok &= ~(1 << port_num); 889 } 890 } 891 892 /* Direct Port-write messages to the enumeratiing host */ 893 if ((rdev->src_ops & RIO_SRC_OPS_PORT_WRITE) && 894 (rdev->em_efptr)) { 895 rio_write_config_32(rdev, 896 rdev->em_efptr + RIO_EM_PW_TGT_DEVID, 897 (port->host_deviceid << 16) | 898 (port->sys_size << 15)); 899 } 900 901 rio_init_em(rdev); 902 903 /* Check for empty switch */ 904 if (next_destid == sw_destid) { 905 next_destid++; 906 if (next_destid == port->host_deviceid) 907 next_destid++; 908 } 909 910 rdev->destid = sw_destid; 911 } else 912 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n", 913 rio_name(rdev), rdev->vid, rdev->did); 914 915 return 0; 916} 917 918/** 919 * rio_enum_complete- Tests if enumeration of a network is complete 920 * @port: Master port to send transaction 921 * 922 * Tests the Component Tag CSR for non-zero value (enumeration 923 * complete flag). Return %1 if enumeration is complete or %0 if 924 * enumeration is incomplete. 925 */ 926static int rio_enum_complete(struct rio_mport *port) 927{ 928 u32 regval; 929 930 rio_local_read_config_32(port, port->phys_efptr + RIO_PORT_GEN_CTL_CSR, 931 ®val); 932 return (regval & RIO_PORT_GEN_MASTER) ? 1 : 0; 933} 934 935/** 936 * rio_disc_peer- Recursively discovers a RIO network through a master port 937 * @net: RIO network being discovered 938 * @port: Master port to send transactions 939 * @destid: Current destination ID in network 940 * @hopcount: Number of hops into the network 941 * 942 * Recursively discovers a RIO network. Transactions are sent via the 943 * master port passed in @port. 944 */ 945static int __devinit 946rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid, 947 u8 hopcount) 948{ 949 u8 port_num, route_port; 950 struct rio_dev *rdev; 951 u16 ndestid; 952 953 /* Setup new RIO device */ 954 if ((rdev = rio_setup_device(net, port, destid, hopcount, 0))) { 955 /* Add device to the global and bus/net specific list. */ 956 list_add_tail(&rdev->net_list, &net->devices); 957 } else 958 return -1; 959 960 if (rio_is_switch(rdev)) { 961 next_switchid++; 962 963 /* Associated destid is how we accessed this switch */ 964 rdev->destid = destid; 965 966 pr_debug( 967 "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n", 968 rio_name(rdev), rdev->vid, rdev->did, 969 RIO_GET_TOTAL_PORTS(rdev->swpinfo)); 970 for (port_num = 0; 971 port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo); 972 port_num++) { 973 if (RIO_GET_PORT_NUM(rdev->swpinfo) == port_num) 974 continue; 975 976 if (rio_sport_is_active 977 (port, destid, hopcount, port_num)) { 978 pr_debug( 979 "RIO: scanning device on port %d\n", 980 port_num); 981 982 rio_lock_device(port, destid, hopcount, 1000); 983 984 for (ndestid = 0; 985 ndestid < RIO_ANY_DESTID(port->sys_size); 986 ndestid++) { 987 rio_route_get_entry(rdev, 988 RIO_GLOBAL_TABLE, 989 ndestid, 990 &route_port, 0); 991 if (route_port == port_num) 992 break; 993 } 994 995 if (ndestid == RIO_ANY_DESTID(port->sys_size)) 996 continue; 997 rio_unlock_device(port, destid, hopcount); 998 if (rio_disc_peer 999 (net, port, ndestid, hopcount + 1) < 0) 1000 return -1; 1001 } 1002 } 1003 } else 1004 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n", 1005 rio_name(rdev), rdev->vid, rdev->did); 1006 1007 return 0; 1008} 1009 1010/** 1011 * rio_mport_is_active- Tests if master port link is active 1012 * @port: Master port to test 1013 * 1014 * Reads the port error status CSR for the master port to 1015 * determine if the port has an active link. Returns 1016 * %RIO_PORT_N_ERR_STS_PORT_OK if the master port is active 1017 * or %0 if it is inactive. 1018 */ 1019static int rio_mport_is_active(struct rio_mport *port) 1020{ 1021 u32 result = 0; 1022 u32 ext_ftr_ptr; 1023 int *entry = rio_mport_phys_table; 1024 1025 do { 1026 if ((ext_ftr_ptr = 1027 rio_mport_get_feature(port, 1, 0, 0, *entry))) 1028 break; 1029 } while (*++entry >= 0); 1030 1031 if (ext_ftr_ptr) 1032 rio_local_read_config_32(port, 1033 ext_ftr_ptr + 1034 RIO_PORT_N_ERR_STS_CSR(port->index), 1035 &result); 1036 1037 return result & RIO_PORT_N_ERR_STS_PORT_OK; 1038} 1039 1040/** 1041 * rio_alloc_net- Allocate and configure a new RIO network 1042 * @port: Master port associated with the RIO network 1043 * 1044 * Allocates a RIO network structure, initializes per-network 1045 * list heads, and adds the associated master port to the 1046 * network list of associated master ports. Returns a 1047 * RIO network pointer on success or %NULL on failure. 1048 */ 1049static struct rio_net __devinit *rio_alloc_net(struct rio_mport *port) 1050{ 1051 struct rio_net *net; 1052 1053 net = kzalloc(sizeof(struct rio_net), GFP_KERNEL); 1054 if (net) { 1055 INIT_LIST_HEAD(&net->node); 1056 INIT_LIST_HEAD(&net->devices); 1057 INIT_LIST_HEAD(&net->mports); 1058 list_add_tail(&port->nnode, &net->mports); 1059 net->hport = port; 1060 net->id = next_net++; 1061 } 1062 return net; 1063} 1064 1065/** 1066 * rio_update_route_tables- Updates route tables in switches 1067 * @port: Master port associated with the RIO network 1068 * 1069 * For each enumerated device, ensure that each switch in a system 1070 * has correct routing entries. Add routes for devices that where 1071 * unknown dirung the first enumeration pass through the switch. 1072 */ 1073static void rio_update_route_tables(struct rio_mport *port) 1074{ 1075 struct rio_dev *rdev; 1076 struct rio_switch *rswitch; 1077 u8 sport; 1078 u16 destid; 1079 1080 list_for_each_entry(rdev, &rio_devices, global_list) { 1081 1082 destid = rdev->destid; 1083 1084 list_for_each_entry(rswitch, &rio_switches, node) { 1085 1086 if (rio_is_switch(rdev) && (rdev->rswitch == rswitch)) 1087 continue; 1088 1089 if (RIO_INVALID_ROUTE == rswitch->route_table[destid]) { 1090 /* Skip if destid ends in empty switch*/ 1091 if (rswitch->rdev->destid == destid) 1092 continue; 1093 1094 sport = RIO_GET_PORT_NUM(rswitch->rdev->swpinfo); 1095 1096 if (rswitch->add_entry) { 1097 rio_route_add_entry(rswitch->rdev, 1098 RIO_GLOBAL_TABLE, destid, 1099 sport, 0); 1100 rswitch->route_table[destid] = sport; 1101 } 1102 } 1103 } 1104 } 1105} 1106 1107/** 1108 * rio_init_em - Initializes RIO Error Management (for switches) 1109 * @rdev: RIO device 1110 * 1111 * For each enumerated switch, call device-specific error management 1112 * initialization routine (if supplied by the switch driver). 1113 */ 1114static void rio_init_em(struct rio_dev *rdev) 1115{ 1116 if (rio_is_switch(rdev) && (rdev->em_efptr) && 1117 (rdev->rswitch->em_init)) { 1118 rdev->rswitch->em_init(rdev); 1119 } 1120} 1121 1122/** 1123 * rio_pw_enable - Enables/disables port-write handling by a master port 1124 * @port: Master port associated with port-write handling 1125 * @enable: 1=enable, 0=disable 1126 */ 1127static void rio_pw_enable(struct rio_mport *port, int enable) 1128{ 1129 if (port->ops->pwenable) 1130 port->ops->pwenable(port, enable); 1131} 1132 1133/** 1134 * rio_enum_mport- Start enumeration through a master port 1135 * @mport: Master port to send transactions 1136 * 1137 * Starts the enumeration process. If somebody has enumerated our 1138 * master port device, then give up. If not and we have an active 1139 * link, then start recursive peer enumeration. Returns %0 if 1140 * enumeration succeeds or %-EBUSY if enumeration fails. 1141 */ 1142int __devinit rio_enum_mport(struct rio_mport *mport) 1143{ 1144 struct rio_net *net = NULL; 1145 int rc = 0; 1146 1147 printk(KERN_INFO "RIO: enumerate master port %d, %s\n", mport->id, 1148 mport->name); 1149 /* If somebody else enumerated our master port device, bail. */ 1150 if (rio_enum_host(mport) < 0) { 1151 printk(KERN_INFO 1152 "RIO: master port %d device has been enumerated by a remote host\n", 1153 mport->id); 1154 rc = -EBUSY; 1155 goto out; 1156 } 1157 1158 /* If master port has an active link, allocate net and enum peers */ 1159 if (rio_mport_is_active(mport)) { 1160 if (!(net = rio_alloc_net(mport))) { 1161 printk(KERN_ERR "RIO: failed to allocate new net\n"); 1162 rc = -ENOMEM; 1163 goto out; 1164 } 1165 1166 /* Enable Input Output Port (transmitter reviever) */ 1167 rio_enable_rx_tx_port(mport, 1, 0, 0, 0); 1168 1169 /* Set component tag for host */ 1170 rio_local_write_config_32(mport, RIO_COMPONENT_TAG_CSR, 1171 next_comptag++); 1172 1173 if (rio_enum_peer(net, mport, 0, NULL, 0) < 0) { 1174 /* A higher priority host won enumeration, bail. */ 1175 printk(KERN_INFO 1176 "RIO: master port %d device has lost enumeration to a remote host\n", 1177 mport->id); 1178 rio_clear_locks(mport); 1179 rc = -EBUSY; 1180 goto out; 1181 } 1182 rio_update_route_tables(mport); 1183 rio_clear_locks(mport); 1184 rio_pw_enable(mport, 1); 1185 } else { 1186 printk(KERN_INFO "RIO: master port %d link inactive\n", 1187 mport->id); 1188 rc = -EINVAL; 1189 } 1190 1191 out: 1192 return rc; 1193} 1194 1195/** 1196 * rio_build_route_tables- Generate route tables from switch route entries 1197 * 1198 * For each switch device, generate a route table by copying existing 1199 * route entries from the switch. 1200 */ 1201static void rio_build_route_tables(void) 1202{ 1203 struct rio_dev *rdev; 1204 int i; 1205 u8 sport; 1206 1207 list_for_each_entry(rdev, &rio_devices, global_list) 1208 if (rio_is_switch(rdev)) { 1209 rio_lock_device(rdev->net->hport, rdev->destid, 1210 rdev->hopcount, 1000); 1211 for (i = 0; 1212 i < RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size); 1213 i++) { 1214 if (rio_route_get_entry(rdev, 1215 RIO_GLOBAL_TABLE, i, &sport, 0) < 0) 1216 continue; 1217 rdev->rswitch->route_table[i] = sport; 1218 } 1219 1220 rio_unlock_device(rdev->net->hport, 1221 rdev->destid, 1222 rdev->hopcount); 1223 } 1224} 1225 1226/** 1227 * rio_enum_timeout- Signal that enumeration timed out 1228 * @data: Address of timeout flag. 1229 * 1230 * When the enumeration complete timer expires, set a flag that 1231 * signals to the discovery process that enumeration did not 1232 * complete in a sane amount of time. 1233 */ 1234static void rio_enum_timeout(unsigned long data) 1235{ 1236 /* Enumeration timed out, set flag */ 1237 *(int *)data = 1; 1238} 1239 1240/** 1241 * rio_disc_mport- Start discovery through a master port 1242 * @mport: Master port to send transactions 1243 * 1244 * Starts the discovery process. If we have an active link, 1245 * then wait for the signal that enumeration is complete. 1246 * When enumeration completion is signaled, start recursive 1247 * peer discovery. Returns %0 if discovery succeeds or %-EBUSY 1248 * on failure. 1249 */ 1250int __devinit rio_disc_mport(struct rio_mport *mport) 1251{ 1252 struct rio_net *net = NULL; 1253 int enum_timeout_flag = 0; 1254 1255 printk(KERN_INFO "RIO: discover master port %d, %s\n", mport->id, 1256 mport->name); 1257 1258 /* If master port has an active link, allocate net and discover peers */ 1259 if (rio_mport_is_active(mport)) { 1260 if (!(net = rio_alloc_net(mport))) { 1261 printk(KERN_ERR "RIO: Failed to allocate new net\n"); 1262 goto bail; 1263 } 1264 1265 pr_debug("RIO: wait for enumeration complete..."); 1266 1267 rio_enum_timer.expires = 1268 jiffies + CONFIG_RAPIDIO_DISC_TIMEOUT * HZ; 1269 rio_enum_timer.data = (unsigned long)&enum_timeout_flag; 1270 add_timer(&rio_enum_timer); 1271 while (!rio_enum_complete(mport)) { 1272 mdelay(1); 1273 if (enum_timeout_flag) { 1274 del_timer_sync(&rio_enum_timer); 1275 goto timeout; 1276 } 1277 } 1278 del_timer_sync(&rio_enum_timer); 1279 1280 pr_debug("done\n"); 1281 1282 /* Read DestID assigned by enumerator */ 1283 rio_local_read_config_32(mport, RIO_DID_CSR, 1284 &mport->host_deviceid); 1285 mport->host_deviceid = RIO_GET_DID(mport->sys_size, 1286 mport->host_deviceid); 1287 1288 if (rio_disc_peer(net, mport, RIO_ANY_DESTID(mport->sys_size), 1289 0) < 0) { 1290 printk(KERN_INFO 1291 "RIO: master port %d device has failed discovery\n", 1292 mport->id); 1293 goto bail; 1294 } 1295 1296 rio_build_route_tables(); 1297 } 1298 1299 return 0; 1300 1301 timeout: 1302 pr_debug("timeout\n"); 1303 bail: 1304 return -EBUSY; 1305} 1306