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