rio-scan.c revision e274e0ed0a2ac31d5eaf7c891e4e1d99197517b2
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_mport_chk_dev_access(port, 766 RIO_ANY_DESTID(port->sys_size), hopcount)) { 767 pr_debug("RIO: device access check failed\n"); 768 return -1; 769 } 770 771 if (rio_get_host_deviceid_lock(port, hopcount) == port->host_deviceid) { 772 pr_debug("RIO: PE already discovered by this host\n"); 773 /* 774 * Already discovered by this host. Add it as another 775 * master port for the current network. 776 */ 777 rio_net_add_mport(net, port); 778 return 0; 779 } 780 781 /* Attempt to acquire device lock */ 782 rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size), 783 hopcount, 784 RIO_HOST_DID_LOCK_CSR, port->host_deviceid); 785 while ((tmp = rio_get_host_deviceid_lock(port, hopcount)) 786 < port->host_deviceid) { 787 /* Delay a bit */ 788 mdelay(1); 789 /* Attempt to acquire device lock again */ 790 rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size), 791 hopcount, 792 RIO_HOST_DID_LOCK_CSR, 793 port->host_deviceid); 794 } 795 796 if (rio_get_host_deviceid_lock(port, hopcount) > port->host_deviceid) { 797 pr_debug( 798 "RIO: PE locked by a higher priority host...retreating\n"); 799 return -1; 800 } 801 802 /* Setup new RIO device */ 803 rdev = rio_setup_device(net, port, RIO_ANY_DESTID(port->sys_size), 804 hopcount, 1); 805 if (rdev) { 806 /* Add device to the global and bus/net specific list. */ 807 list_add_tail(&rdev->net_list, &net->devices); 808 rdev->prev = prev; 809 if (prev && rio_is_switch(prev)) 810 prev->rswitch->nextdev[prev_port] = rdev; 811 } else 812 return -1; 813 814 if (rio_is_switch(rdev)) { 815 next_switchid++; 816 sw_inport = RIO_GET_PORT_NUM(rdev->swpinfo); 817 rio_route_add_entry(port, rdev->rswitch, RIO_GLOBAL_TABLE, 818 port->host_deviceid, sw_inport, 0); 819 rdev->rswitch->route_table[port->host_deviceid] = sw_inport; 820 821 for (destid = 0; destid < next_destid; destid++) { 822 if (destid == port->host_deviceid) 823 continue; 824 rio_route_add_entry(port, rdev->rswitch, RIO_GLOBAL_TABLE, 825 destid, sw_inport, 0); 826 rdev->rswitch->route_table[destid] = sw_inport; 827 } 828 829 pr_debug( 830 "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n", 831 rio_name(rdev), rdev->vid, rdev->did, 832 RIO_GET_TOTAL_PORTS(rdev->swpinfo)); 833 sw_destid = next_destid; 834 for (port_num = 0; 835 port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo); 836 port_num++) { 837 /*Enable Input Output Port (transmitter reviever)*/ 838 rio_enable_rx_tx_port(port, 0, 839 RIO_ANY_DESTID(port->sys_size), 840 hopcount, port_num); 841 842 if (sw_inport == port_num) { 843 rdev->rswitch->port_ok |= (1 << port_num); 844 continue; 845 } 846 847 cur_destid = next_destid; 848 849 if (rio_sport_is_active 850 (port, RIO_ANY_DESTID(port->sys_size), hopcount, 851 port_num)) { 852 pr_debug( 853 "RIO: scanning device on port %d\n", 854 port_num); 855 rdev->rswitch->port_ok |= (1 << port_num); 856 rio_route_add_entry(port, rdev->rswitch, 857 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(port, rdev->rswitch, 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->rswitch->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 tag_csr; 929 930 rio_local_read_config_32(port, RIO_COMPONENT_TAG_CSR, &tag_csr); 931 return (tag_csr & 0xffff) ? 1 : 0; 932} 933 934/** 935 * rio_disc_peer- Recursively discovers a RIO network through a master port 936 * @net: RIO network being discovered 937 * @port: Master port to send transactions 938 * @destid: Current destination ID in network 939 * @hopcount: Number of hops into the network 940 * 941 * Recursively discovers a RIO network. Transactions are sent via the 942 * master port passed in @port. 943 */ 944static int __devinit 945rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid, 946 u8 hopcount) 947{ 948 u8 port_num, route_port; 949 struct rio_dev *rdev; 950 u16 ndestid; 951 952 /* Setup new RIO device */ 953 if ((rdev = rio_setup_device(net, port, destid, hopcount, 0))) { 954 /* Add device to the global and bus/net specific list. */ 955 list_add_tail(&rdev->net_list, &net->devices); 956 } else 957 return -1; 958 959 if (rio_is_switch(rdev)) { 960 next_switchid++; 961 962 /* Associated destid is how we accessed this switch */ 963 rdev->rswitch->destid = destid; 964 965 pr_debug( 966 "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n", 967 rio_name(rdev), rdev->vid, rdev->did, 968 RIO_GET_TOTAL_PORTS(rdev->swpinfo)); 969 for (port_num = 0; 970 port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo); 971 port_num++) { 972 if (RIO_GET_PORT_NUM(rdev->swpinfo) == port_num) 973 continue; 974 975 if (rio_sport_is_active 976 (port, destid, hopcount, port_num)) { 977 pr_debug( 978 "RIO: scanning device on port %d\n", 979 port_num); 980 981 rio_lock_device(port, destid, hopcount, 1000); 982 983 for (ndestid = 0; 984 ndestid < RIO_ANY_DESTID(port->sys_size); 985 ndestid++) { 986 rio_route_get_entry(port, rdev->rswitch, 987 RIO_GLOBAL_TABLE, 988 ndestid, 989 &route_port, 0); 990 if (route_port == port_num) 991 break; 992 } 993 994 rio_unlock_device(port, destid, hopcount); 995 if (rio_disc_peer 996 (net, port, ndestid, hopcount + 1) < 0) 997 return -1; 998 } 999 } 1000 } else 1001 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n", 1002 rio_name(rdev), rdev->vid, rdev->did); 1003 1004 return 0; 1005} 1006 1007/** 1008 * rio_mport_is_active- Tests if master port link is active 1009 * @port: Master port to test 1010 * 1011 * Reads the port error status CSR for the master port to 1012 * determine if the port has an active link. Returns 1013 * %RIO_PORT_N_ERR_STS_PORT_OK if the master port is active 1014 * or %0 if it is inactive. 1015 */ 1016static int rio_mport_is_active(struct rio_mport *port) 1017{ 1018 u32 result = 0; 1019 u32 ext_ftr_ptr; 1020 int *entry = rio_mport_phys_table; 1021 1022 do { 1023 if ((ext_ftr_ptr = 1024 rio_mport_get_feature(port, 1, 0, 0, *entry))) 1025 break; 1026 } while (*++entry >= 0); 1027 1028 if (ext_ftr_ptr) 1029 rio_local_read_config_32(port, 1030 ext_ftr_ptr + 1031 RIO_PORT_N_ERR_STS_CSR(port->index), 1032 &result); 1033 1034 return result & RIO_PORT_N_ERR_STS_PORT_OK; 1035} 1036 1037/** 1038 * rio_alloc_net- Allocate and configure a new RIO network 1039 * @port: Master port associated with the RIO network 1040 * 1041 * Allocates a RIO network structure, initializes per-network 1042 * list heads, and adds the associated master port to the 1043 * network list of associated master ports. Returns a 1044 * RIO network pointer on success or %NULL on failure. 1045 */ 1046static struct rio_net __devinit *rio_alloc_net(struct rio_mport *port) 1047{ 1048 struct rio_net *net; 1049 1050 net = kzalloc(sizeof(struct rio_net), GFP_KERNEL); 1051 if (net) { 1052 INIT_LIST_HEAD(&net->node); 1053 INIT_LIST_HEAD(&net->devices); 1054 INIT_LIST_HEAD(&net->mports); 1055 list_add_tail(&port->nnode, &net->mports); 1056 net->hport = port; 1057 net->id = next_net++; 1058 } 1059 return net; 1060} 1061 1062/** 1063 * rio_update_route_tables- Updates route tables in switches 1064 * @port: Master port associated with the RIO network 1065 * 1066 * For each enumerated device, ensure that each switch in a system 1067 * has correct routing entries. Add routes for devices that where 1068 * unknown dirung the first enumeration pass through the switch. 1069 */ 1070static void rio_update_route_tables(struct rio_mport *port) 1071{ 1072 struct rio_dev *rdev; 1073 struct rio_switch *rswitch; 1074 u8 sport; 1075 u16 destid; 1076 1077 list_for_each_entry(rdev, &rio_devices, global_list) { 1078 1079 destid = (rio_is_switch(rdev))?rdev->rswitch->destid:rdev->destid; 1080 1081 list_for_each_entry(rswitch, &rio_switches, node) { 1082 1083 if (rio_is_switch(rdev) && (rdev->rswitch == rswitch)) 1084 continue; 1085 1086 if (RIO_INVALID_ROUTE == rswitch->route_table[destid]) { 1087 /* Skip if destid ends in empty switch*/ 1088 if (rswitch->destid == destid) 1089 continue; 1090 1091 sport = RIO_GET_PORT_NUM(rswitch->rdev->swpinfo); 1092 1093 if (rswitch->add_entry) { 1094 rio_route_add_entry(port, rswitch, 1095 RIO_GLOBAL_TABLE, destid, 1096 sport, 0); 1097 rswitch->route_table[destid] = sport; 1098 } 1099 } 1100 } 1101 } 1102} 1103 1104/** 1105 * rio_init_em - Initializes RIO Error Management (for switches) 1106 * @rdev: RIO device 1107 * 1108 * For each enumerated switch, call device-specific error management 1109 * initialization routine (if supplied by the switch driver). 1110 */ 1111static void rio_init_em(struct rio_dev *rdev) 1112{ 1113 if (rio_is_switch(rdev) && (rdev->em_efptr) && 1114 (rdev->rswitch->em_init)) { 1115 rdev->rswitch->em_init(rdev); 1116 } 1117} 1118 1119/** 1120 * rio_pw_enable - Enables/disables port-write handling by a master port 1121 * @port: Master port associated with port-write handling 1122 * @enable: 1=enable, 0=disable 1123 */ 1124static void rio_pw_enable(struct rio_mport *port, int enable) 1125{ 1126 if (port->ops->pwenable) 1127 port->ops->pwenable(port, enable); 1128} 1129 1130/** 1131 * rio_enum_mport- Start enumeration through a master port 1132 * @mport: Master port to send transactions 1133 * 1134 * Starts the enumeration process. If somebody has enumerated our 1135 * master port device, then give up. If not and we have an active 1136 * link, then start recursive peer enumeration. Returns %0 if 1137 * enumeration succeeds or %-EBUSY if enumeration fails. 1138 */ 1139int __devinit rio_enum_mport(struct rio_mport *mport) 1140{ 1141 struct rio_net *net = NULL; 1142 int rc = 0; 1143 1144 printk(KERN_INFO "RIO: enumerate master port %d, %s\n", mport->id, 1145 mport->name); 1146 /* If somebody else enumerated our master port device, bail. */ 1147 if (rio_enum_host(mport) < 0) { 1148 printk(KERN_INFO 1149 "RIO: master port %d device has been enumerated by a remote host\n", 1150 mport->id); 1151 rc = -EBUSY; 1152 goto out; 1153 } 1154 1155 /* If master port has an active link, allocate net and enum peers */ 1156 if (rio_mport_is_active(mport)) { 1157 if (!(net = rio_alloc_net(mport))) { 1158 printk(KERN_ERR "RIO: failed to allocate new net\n"); 1159 rc = -ENOMEM; 1160 goto out; 1161 } 1162 1163 /* Enable Input Output Port (transmitter reviever) */ 1164 rio_enable_rx_tx_port(mport, 1, 0, 0, 0); 1165 1166 if (rio_enum_peer(net, mport, 0, NULL, 0) < 0) { 1167 /* A higher priority host won enumeration, bail. */ 1168 printk(KERN_INFO 1169 "RIO: master port %d device has lost enumeration to a remote host\n", 1170 mport->id); 1171 rio_clear_locks(mport); 1172 rc = -EBUSY; 1173 goto out; 1174 } 1175 rio_update_route_tables(mport); 1176 rio_clear_locks(mport); 1177 rio_pw_enable(mport, 1); 1178 } else { 1179 printk(KERN_INFO "RIO: master port %d link inactive\n", 1180 mport->id); 1181 rc = -EINVAL; 1182 } 1183 1184 out: 1185 return rc; 1186} 1187 1188/** 1189 * rio_build_route_tables- Generate route tables from switch route entries 1190 * 1191 * For each switch device, generate a route table by copying existing 1192 * route entries from the switch. 1193 */ 1194static void rio_build_route_tables(void) 1195{ 1196 struct rio_dev *rdev; 1197 int i; 1198 u8 sport; 1199 1200 list_for_each_entry(rdev, &rio_devices, global_list) 1201 if (rio_is_switch(rdev)) { 1202 rio_lock_device(rdev->net->hport, rdev->rswitch->destid, 1203 rdev->rswitch->hopcount, 1000); 1204 for (i = 0; 1205 i < RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size); 1206 i++) { 1207 if (rio_route_get_entry 1208 (rdev->net->hport, rdev->rswitch, 1209 RIO_GLOBAL_TABLE, i, &sport, 0) < 0) 1210 continue; 1211 rdev->rswitch->route_table[i] = sport; 1212 } 1213 1214 rio_unlock_device(rdev->net->hport, 1215 rdev->rswitch->destid, 1216 rdev->rswitch->hopcount); 1217 } 1218} 1219 1220/** 1221 * rio_enum_timeout- Signal that enumeration timed out 1222 * @data: Address of timeout flag. 1223 * 1224 * When the enumeration complete timer expires, set a flag that 1225 * signals to the discovery process that enumeration did not 1226 * complete in a sane amount of time. 1227 */ 1228static void rio_enum_timeout(unsigned long data) 1229{ 1230 /* Enumeration timed out, set flag */ 1231 *(int *)data = 1; 1232} 1233 1234/** 1235 * rio_disc_mport- Start discovery through a master port 1236 * @mport: Master port to send transactions 1237 * 1238 * Starts the discovery process. If we have an active link, 1239 * then wait for the signal that enumeration is complete. 1240 * When enumeration completion is signaled, start recursive 1241 * peer discovery. Returns %0 if discovery succeeds or %-EBUSY 1242 * on failure. 1243 */ 1244int __devinit rio_disc_mport(struct rio_mport *mport) 1245{ 1246 struct rio_net *net = NULL; 1247 int enum_timeout_flag = 0; 1248 1249 printk(KERN_INFO "RIO: discover master port %d, %s\n", mport->id, 1250 mport->name); 1251 1252 /* If master port has an active link, allocate net and discover peers */ 1253 if (rio_mport_is_active(mport)) { 1254 if (!(net = rio_alloc_net(mport))) { 1255 printk(KERN_ERR "RIO: Failed to allocate new net\n"); 1256 goto bail; 1257 } 1258 1259 pr_debug("RIO: wait for enumeration complete..."); 1260 1261 rio_enum_timer.expires = 1262 jiffies + CONFIG_RAPIDIO_DISC_TIMEOUT * HZ; 1263 rio_enum_timer.data = (unsigned long)&enum_timeout_flag; 1264 add_timer(&rio_enum_timer); 1265 while (!rio_enum_complete(mport)) { 1266 mdelay(1); 1267 if (enum_timeout_flag) { 1268 del_timer_sync(&rio_enum_timer); 1269 goto timeout; 1270 } 1271 } 1272 del_timer_sync(&rio_enum_timer); 1273 1274 pr_debug("done\n"); 1275 1276 /* Read DestID assigned by enumerator */ 1277 rio_local_read_config_32(mport, RIO_DID_CSR, 1278 &mport->host_deviceid); 1279 mport->host_deviceid = RIO_GET_DID(mport->sys_size, 1280 mport->host_deviceid); 1281 1282 if (rio_disc_peer(net, mport, RIO_ANY_DESTID(mport->sys_size), 1283 0) < 0) { 1284 printk(KERN_INFO 1285 "RIO: master port %d device has failed discovery\n", 1286 mport->id); 1287 goto bail; 1288 } 1289 1290 rio_build_route_tables(); 1291 } 1292 1293 return 0; 1294 1295 timeout: 1296 pr_debug("timeout\n"); 1297 bail: 1298 return -EBUSY; 1299} 1300