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