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