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 36 static void rio_init_em(struct rio_dev *rdev); 37 38 struct 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[0]; 43 }; 44 45 static int next_destid = 0; 46 static 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 */ 56 static 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 */ 82 static 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 */ 101 static 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 */ 115 static 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 */ 135 static 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 */ 159 static 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 */ 177 static 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 */ 191 static 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 */ 240 static 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 */ 267 static 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 */ 282 static 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 */ 299 static 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 */ 322 static 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(struct rio_dev); 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 += (RIO_GET_TOTAL_PORTS(swpinfo) * 343 sizeof(rswitch->nextdev[0])) + sizeof(*rswitch); 344 } 345 } 346 347 rdev = kzalloc(size, GFP_KERNEL); 348 if (!rdev) 349 return NULL; 350 351 rdev->net = net; 352 rdev->pef = result; 353 rdev->swpinfo = swpinfo; 354 rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_ID_CAR, 355 &result); 356 rdev->did = result >> 16; 357 rdev->vid = result & 0xffff; 358 rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_INFO_CAR, 359 &rdev->device_rev); 360 rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_ID_CAR, 361 &result); 362 rdev->asm_did = result >> 16; 363 rdev->asm_vid = result & 0xffff; 364 rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_INFO_CAR, 365 &result); 366 rdev->asm_rev = result >> 16; 367 if (rdev->pef & RIO_PEF_EXT_FEATURES) { 368 rdev->efptr = result & 0xffff; 369 rdev->phys_efptr = rio_mport_get_physefb(port, 0, destid, 370 hopcount, &rdev->phys_rmap); 371 pr_debug("RIO: %s Register Map %d device\n", 372 __func__, rdev->phys_rmap); 373 374 rdev->em_efptr = rio_mport_get_feature(port, 0, destid, 375 hopcount, RIO_EFB_ERR_MGMNT); 376 if (!rdev->em_efptr) 377 rdev->em_efptr = rio_mport_get_feature(port, 0, destid, 378 hopcount, RIO_EFB_ERR_MGMNT_HS); 379 } 380 381 rio_mport_read_config_32(port, destid, hopcount, RIO_SRC_OPS_CAR, 382 &rdev->src_ops); 383 rio_mport_read_config_32(port, destid, hopcount, RIO_DST_OPS_CAR, 384 &rdev->dst_ops); 385 386 if (do_enum) { 387 /* Assign component tag to device */ 388 if (next_comptag >= 0x10000) { 389 pr_err("RIO: Component Tag Counter Overflow\n"); 390 goto cleanup; 391 } 392 rio_mport_write_config_32(port, destid, hopcount, 393 RIO_COMPONENT_TAG_CSR, next_comptag); 394 rdev->comp_tag = next_comptag++; 395 rdev->do_enum = true; 396 } else { 397 rio_mport_read_config_32(port, destid, hopcount, 398 RIO_COMPONENT_TAG_CSR, 399 &rdev->comp_tag); 400 } 401 402 if (rio_device_has_destid(port, rdev->src_ops, rdev->dst_ops)) { 403 if (do_enum) { 404 rio_set_device_id(port, destid, hopcount, next_destid); 405 rdev->destid = next_destid; 406 next_destid = rio_destid_alloc(net); 407 } else 408 rdev->destid = rio_get_device_id(port, destid, hopcount); 409 410 rdev->hopcount = 0xff; 411 } else { 412 /* Switch device has an associated destID which 413 * will be adjusted later 414 */ 415 rdev->destid = destid; 416 rdev->hopcount = hopcount; 417 } 418 419 /* If a PE has both switch and other functions, show it as a switch */ 420 if (rio_is_switch(rdev)) { 421 rswitch = rdev->rswitch; 422 rswitch->port_ok = 0; 423 spin_lock_init(&rswitch->lock); 424 rswitch->route_table = 425 kzalloc(RIO_MAX_ROUTE_ENTRIES(port->sys_size), 426 GFP_KERNEL); 427 if (!rswitch->route_table) 428 goto cleanup; 429 /* Initialize switch route table */ 430 for (rdid = 0; rdid < RIO_MAX_ROUTE_ENTRIES(port->sys_size); 431 rdid++) 432 rswitch->route_table[rdid] = RIO_INVALID_ROUTE; 433 dev_set_name(&rdev->dev, "%02x:s:%04x", rdev->net->id, 434 rdev->comp_tag & RIO_CTAG_UDEVID); 435 436 if (do_enum) 437 rio_route_clr_table(rdev, RIO_GLOBAL_TABLE, 0); 438 } else { 439 if (do_enum) 440 /*Enable Input Output Port (transmitter receiver)*/ 441 rio_enable_rx_tx_port(port, 0, destid, hopcount, 0); 442 443 dev_set_name(&rdev->dev, "%02x:e:%04x", rdev->net->id, 444 rdev->comp_tag & RIO_CTAG_UDEVID); 445 } 446 447 rdev->dev.parent = &net->dev; 448 rio_attach_device(rdev); 449 rdev->dev.release = rio_release_dev; 450 rdev->dma_mask = DMA_BIT_MASK(32); 451 rdev->dev.dma_mask = &rdev->dma_mask; 452 rdev->dev.coherent_dma_mask = DMA_BIT_MASK(32); 453 454 if (rdev->dst_ops & RIO_DST_OPS_DOORBELL) 455 rio_init_dbell_res(&rdev->riores[RIO_DOORBELL_RESOURCE], 456 0, 0xffff); 457 458 ret = rio_add_device(rdev); 459 if (ret) 460 goto cleanup; 461 462 rio_dev_get(rdev); 463 464 return rdev; 465 466 cleanup: 467 if (rswitch) 468 kfree(rswitch->route_table); 469 470 kfree(rdev); 471 return NULL; 472 } 473 474 /** 475 * rio_sport_is_active- Tests if a switch port has an active connection. 476 * @rdev: RapidIO device object 477 * @sp: Switch port number 478 * 479 * Reads the port error status CSR for a particular switch port to 480 * determine if the port has an active link. Returns 481 * %RIO_PORT_N_ERR_STS_PORT_OK if the port is active or %0 if it is 482 * inactive. 483 */ 484 static int 485 rio_sport_is_active(struct rio_dev *rdev, int sp) 486 { 487 u32 result = 0; 488 489 rio_read_config_32(rdev, RIO_DEV_PORT_N_ERR_STS_CSR(rdev, sp), 490 &result); 491 492 return result & RIO_PORT_N_ERR_STS_PORT_OK; 493 } 494 495 /** 496 * rio_get_host_deviceid_lock- Reads the Host Device ID Lock CSR on a device 497 * @port: Master port to send transaction 498 * @hopcount: Number of hops to the device 499 * 500 * Used during enumeration to read the Host Device ID Lock CSR on a 501 * RIO device. Returns the value of the lock register. 502 */ 503 static u16 rio_get_host_deviceid_lock(struct rio_mport *port, u8 hopcount) 504 { 505 u32 result; 506 507 rio_mport_read_config_32(port, RIO_ANY_DESTID(port->sys_size), hopcount, 508 RIO_HOST_DID_LOCK_CSR, &result); 509 510 return (u16) (result & 0xffff); 511 } 512 513 /** 514 * rio_enum_peer- Recursively enumerate a RIO network through a master port 515 * @net: RIO network being enumerated 516 * @port: Master port to send transactions 517 * @hopcount: Number of hops into the network 518 * @prev: Previous RIO device connected to the enumerated one 519 * @prev_port: Port on previous RIO device 520 * 521 * Recursively enumerates a RIO network. Transactions are sent via the 522 * master port passed in @port. 523 */ 524 static int rio_enum_peer(struct rio_net *net, struct rio_mport *port, 525 u8 hopcount, struct rio_dev *prev, int prev_port) 526 { 527 struct rio_dev *rdev; 528 u32 regval; 529 int tmp; 530 531 if (rio_mport_chk_dev_access(port, 532 RIO_ANY_DESTID(port->sys_size), hopcount)) { 533 pr_debug("RIO: device access check failed\n"); 534 return -1; 535 } 536 537 if (rio_get_host_deviceid_lock(port, hopcount) == port->host_deviceid) { 538 pr_debug("RIO: PE already discovered by this host\n"); 539 /* 540 * Already discovered by this host. Add it as another 541 * link to the existing device. 542 */ 543 rio_mport_read_config_32(port, RIO_ANY_DESTID(port->sys_size), 544 hopcount, RIO_COMPONENT_TAG_CSR, ®val); 545 546 if (regval) { 547 rdev = rio_get_comptag((regval & 0xffff), NULL); 548 549 if (rdev && prev && rio_is_switch(prev)) { 550 pr_debug("RIO: redundant path to %s\n", 551 rio_name(rdev)); 552 prev->rswitch->nextdev[prev_port] = rdev; 553 } 554 } 555 556 return 0; 557 } 558 559 /* Attempt to acquire device lock */ 560 rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size), 561 hopcount, 562 RIO_HOST_DID_LOCK_CSR, port->host_deviceid); 563 while ((tmp = rio_get_host_deviceid_lock(port, hopcount)) 564 < port->host_deviceid) { 565 /* Delay a bit */ 566 mdelay(1); 567 /* Attempt to acquire device lock again */ 568 rio_mport_write_config_32(port, RIO_ANY_DESTID(port->sys_size), 569 hopcount, 570 RIO_HOST_DID_LOCK_CSR, 571 port->host_deviceid); 572 } 573 574 if (rio_get_host_deviceid_lock(port, hopcount) > port->host_deviceid) { 575 pr_debug( 576 "RIO: PE locked by a higher priority host...retreating\n"); 577 return -1; 578 } 579 580 /* Setup new RIO device */ 581 rdev = rio_setup_device(net, port, RIO_ANY_DESTID(port->sys_size), 582 hopcount, 1); 583 if (rdev) { 584 rdev->prev = prev; 585 if (prev && rio_is_switch(prev)) 586 prev->rswitch->nextdev[prev_port] = rdev; 587 } else 588 return -1; 589 590 if (rio_is_switch(rdev)) { 591 int sw_destid; 592 int cur_destid; 593 int sw_inport; 594 u16 destid; 595 int port_num; 596 597 sw_inport = RIO_GET_PORT_NUM(rdev->swpinfo); 598 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE, 599 port->host_deviceid, sw_inport, 0); 600 rdev->rswitch->route_table[port->host_deviceid] = sw_inport; 601 602 destid = rio_destid_first(net); 603 while (destid != RIO_INVALID_DESTID && destid < next_destid) { 604 if (destid != port->host_deviceid) { 605 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE, 606 destid, sw_inport, 0); 607 rdev->rswitch->route_table[destid] = sw_inport; 608 } 609 destid = rio_destid_next(net, destid + 1); 610 } 611 pr_debug( 612 "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n", 613 rio_name(rdev), rdev->vid, rdev->did, 614 RIO_GET_TOTAL_PORTS(rdev->swpinfo)); 615 sw_destid = next_destid; 616 for (port_num = 0; 617 port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo); 618 port_num++) { 619 if (sw_inport == port_num) { 620 rio_enable_rx_tx_port(port, 0, 621 RIO_ANY_DESTID(port->sys_size), 622 hopcount, port_num); 623 rdev->rswitch->port_ok |= (1 << port_num); 624 continue; 625 } 626 627 cur_destid = next_destid; 628 629 if (rio_sport_is_active(rdev, port_num)) { 630 pr_debug( 631 "RIO: scanning device on port %d\n", 632 port_num); 633 rio_enable_rx_tx_port(port, 0, 634 RIO_ANY_DESTID(port->sys_size), 635 hopcount, port_num); 636 rdev->rswitch->port_ok |= (1 << port_num); 637 rio_route_add_entry(rdev, RIO_GLOBAL_TABLE, 638 RIO_ANY_DESTID(port->sys_size), 639 port_num, 0); 640 641 if (rio_enum_peer(net, port, hopcount + 1, 642 rdev, port_num) < 0) 643 return -1; 644 645 /* Update routing tables */ 646 destid = rio_destid_next(net, cur_destid + 1); 647 if (destid != RIO_INVALID_DESTID) { 648 for (destid = cur_destid; 649 destid < next_destid;) { 650 if (destid != port->host_deviceid) { 651 rio_route_add_entry(rdev, 652 RIO_GLOBAL_TABLE, 653 destid, 654 port_num, 655 0); 656 rdev->rswitch-> 657 route_table[destid] = 658 port_num; 659 } 660 destid = rio_destid_next(net, 661 destid + 1); 662 } 663 } 664 } else { 665 /* If switch supports Error Management, 666 * set PORT_LOCKOUT bit for unused port 667 */ 668 if (rdev->em_efptr) 669 rio_set_port_lockout(rdev, port_num, 1); 670 671 rdev->rswitch->port_ok &= ~(1 << port_num); 672 } 673 } 674 675 /* Direct Port-write messages to the enumeratiing host */ 676 if ((rdev->src_ops & RIO_SRC_OPS_PORT_WRITE) && 677 (rdev->em_efptr)) { 678 rio_write_config_32(rdev, 679 rdev->em_efptr + RIO_EM_PW_TGT_DEVID, 680 (port->host_deviceid << 16) | 681 (port->sys_size << 15)); 682 } 683 684 rio_init_em(rdev); 685 686 /* Check for empty switch */ 687 if (next_destid == sw_destid) 688 next_destid = rio_destid_alloc(net); 689 690 rdev->destid = sw_destid; 691 } else 692 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n", 693 rio_name(rdev), rdev->vid, rdev->did); 694 695 return 0; 696 } 697 698 /** 699 * rio_enum_complete- Tests if enumeration of a network is complete 700 * @port: Master port to send transaction 701 * 702 * Tests the PGCCSR discovered bit for non-zero value (enumeration 703 * complete flag). Return %1 if enumeration is complete or %0 if 704 * enumeration is incomplete. 705 */ 706 static int rio_enum_complete(struct rio_mport *port) 707 { 708 u32 regval; 709 710 rio_local_read_config_32(port, port->phys_efptr + RIO_PORT_GEN_CTL_CSR, 711 ®val); 712 return (regval & RIO_PORT_GEN_DISCOVERED) ? 1 : 0; 713 } 714 715 /** 716 * rio_disc_peer- Recursively discovers a RIO network through a master port 717 * @net: RIO network being discovered 718 * @port: Master port to send transactions 719 * @destid: Current destination ID in network 720 * @hopcount: Number of hops into the network 721 * @prev: previous rio_dev 722 * @prev_port: previous port number 723 * 724 * Recursively discovers a RIO network. Transactions are sent via the 725 * master port passed in @port. 726 */ 727 static int 728 rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid, 729 u8 hopcount, struct rio_dev *prev, int prev_port) 730 { 731 u8 port_num, route_port; 732 struct rio_dev *rdev; 733 u16 ndestid; 734 735 /* Setup new RIO device */ 736 if ((rdev = rio_setup_device(net, port, destid, hopcount, 0))) { 737 rdev->prev = prev; 738 if (prev && rio_is_switch(prev)) 739 prev->rswitch->nextdev[prev_port] = rdev; 740 } else 741 return -1; 742 743 if (rio_is_switch(rdev)) { 744 /* Associated destid is how we accessed this switch */ 745 rdev->destid = destid; 746 747 pr_debug( 748 "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n", 749 rio_name(rdev), rdev->vid, rdev->did, 750 RIO_GET_TOTAL_PORTS(rdev->swpinfo)); 751 for (port_num = 0; 752 port_num < RIO_GET_TOTAL_PORTS(rdev->swpinfo); 753 port_num++) { 754 if (RIO_GET_PORT_NUM(rdev->swpinfo) == port_num) 755 continue; 756 757 if (rio_sport_is_active(rdev, port_num)) { 758 pr_debug( 759 "RIO: scanning device on port %d\n", 760 port_num); 761 762 rio_lock_device(port, destid, hopcount, 1000); 763 764 for (ndestid = 0; 765 ndestid < RIO_ANY_DESTID(port->sys_size); 766 ndestid++) { 767 rio_route_get_entry(rdev, 768 RIO_GLOBAL_TABLE, 769 ndestid, 770 &route_port, 0); 771 if (route_port == port_num) 772 break; 773 } 774 775 if (ndestid == RIO_ANY_DESTID(port->sys_size)) 776 continue; 777 rio_unlock_device(port, destid, hopcount); 778 if (rio_disc_peer(net, port, ndestid, 779 hopcount + 1, rdev, port_num) < 0) 780 return -1; 781 } 782 } 783 } else 784 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n", 785 rio_name(rdev), rdev->vid, rdev->did); 786 787 return 0; 788 } 789 790 /** 791 * rio_mport_is_active- Tests if master port link is active 792 * @port: Master port to test 793 * 794 * Reads the port error status CSR for the master port to 795 * determine if the port has an active link. Returns 796 * %RIO_PORT_N_ERR_STS_PORT_OK if the master port is active 797 * or %0 if it is inactive. 798 */ 799 static int rio_mport_is_active(struct rio_mport *port) 800 { 801 u32 result = 0; 802 803 rio_local_read_config_32(port, 804 port->phys_efptr + 805 RIO_PORT_N_ERR_STS_CSR(port->index, port->phys_rmap), 806 &result); 807 return result & RIO_PORT_N_ERR_STS_PORT_OK; 808 } 809 810 static void rio_scan_release_net(struct rio_net *net) 811 { 812 pr_debug("RIO-SCAN: %s: net_%d\n", __func__, net->id); 813 kfree(net->enum_data); 814 } 815 816 static void rio_scan_release_dev(struct device *dev) 817 { 818 struct rio_net *net; 819 820 net = to_rio_net(dev); 821 pr_debug("RIO-SCAN: %s: net_%d\n", __func__, net->id); 822 kfree(net); 823 } 824 825 /* 826 * rio_scan_alloc_net - Allocate and configure a new RIO network 827 * @mport: Master port associated with the RIO network 828 * @do_enum: Enumeration/Discovery mode flag 829 * @start: logical minimal start id for new net 830 * 831 * Allocates a new RIO network structure and initializes enumerator-specific 832 * part of it (if required). 833 * Returns a RIO network pointer on success or %NULL on failure. 834 */ 835 static struct rio_net *rio_scan_alloc_net(struct rio_mport *mport, 836 int do_enum, u16 start) 837 { 838 struct rio_net *net; 839 840 net = rio_alloc_net(mport); 841 842 if (net && do_enum) { 843 struct rio_id_table *idtab; 844 size_t size; 845 846 size = sizeof(struct rio_id_table) + 847 BITS_TO_LONGS( 848 RIO_MAX_ROUTE_ENTRIES(mport->sys_size) 849 ) * sizeof(long); 850 851 idtab = kzalloc(size, GFP_KERNEL); 852 853 if (idtab == NULL) { 854 pr_err("RIO: failed to allocate destID table\n"); 855 rio_free_net(net); 856 net = NULL; 857 } else { 858 net->enum_data = idtab; 859 net->release = rio_scan_release_net; 860 idtab->start = start; 861 idtab->max = RIO_MAX_ROUTE_ENTRIES(mport->sys_size); 862 spin_lock_init(&idtab->lock); 863 } 864 } 865 866 if (net) { 867 net->id = mport->id; 868 net->hport = mport; 869 dev_set_name(&net->dev, "rnet_%d", net->id); 870 net->dev.parent = &mport->dev; 871 net->dev.release = rio_scan_release_dev; 872 rio_add_net(net); 873 } 874 875 return net; 876 } 877 878 /** 879 * rio_update_route_tables- Updates route tables in switches 880 * @net: RIO network to run update on 881 * 882 * For each enumerated device, ensure that each switch in a system 883 * has correct routing entries. Add routes for devices that where 884 * unknown during the first enumeration pass through the switch. 885 */ 886 static void rio_update_route_tables(struct rio_net *net) 887 { 888 struct rio_dev *rdev, *swrdev; 889 struct rio_switch *rswitch; 890 u8 sport; 891 u16 destid; 892 893 list_for_each_entry(rdev, &net->devices, net_list) { 894 895 destid = rdev->destid; 896 897 list_for_each_entry(rswitch, &net->switches, node) { 898 899 if (rio_is_switch(rdev) && (rdev->rswitch == rswitch)) 900 continue; 901 902 if (RIO_INVALID_ROUTE == rswitch->route_table[destid]) { 903 swrdev = sw_to_rio_dev(rswitch); 904 905 /* Skip if destid ends in empty switch*/ 906 if (swrdev->destid == destid) 907 continue; 908 909 sport = RIO_GET_PORT_NUM(swrdev->swpinfo); 910 911 rio_route_add_entry(swrdev, RIO_GLOBAL_TABLE, 912 destid, sport, 0); 913 rswitch->route_table[destid] = sport; 914 } 915 } 916 } 917 } 918 919 /** 920 * rio_init_em - Initializes RIO Error Management (for switches) 921 * @rdev: RIO device 922 * 923 * For each enumerated switch, call device-specific error management 924 * initialization routine (if supplied by the switch driver). 925 */ 926 static void rio_init_em(struct rio_dev *rdev) 927 { 928 if (rio_is_switch(rdev) && (rdev->em_efptr) && 929 rdev->rswitch->ops && rdev->rswitch->ops->em_init) { 930 rdev->rswitch->ops->em_init(rdev); 931 } 932 } 933 934 /** 935 * rio_enum_mport- Start enumeration through a master port 936 * @mport: Master port to send transactions 937 * @flags: Enumeration control flags 938 * 939 * Starts the enumeration process. If somebody has enumerated our 940 * master port device, then give up. If not and we have an active 941 * link, then start recursive peer enumeration. Returns %0 if 942 * enumeration succeeds or %-EBUSY if enumeration fails. 943 */ 944 static int rio_enum_mport(struct rio_mport *mport, u32 flags) 945 { 946 struct rio_net *net = NULL; 947 int rc = 0; 948 949 printk(KERN_INFO "RIO: enumerate master port %d, %s\n", mport->id, 950 mport->name); 951 952 /* 953 * To avoid multiple start requests (repeat enumeration is not supported 954 * by this method) check if enumeration/discovery was performed for this 955 * mport: if mport was added into the list of mports for a net exit 956 * with error. 957 */ 958 if (mport->nnode.next || mport->nnode.prev) 959 return -EBUSY; 960 961 /* If somebody else enumerated our master port device, bail. */ 962 if (rio_enum_host(mport) < 0) { 963 printk(KERN_INFO 964 "RIO: master port %d device has been enumerated by a remote host\n", 965 mport->id); 966 rc = -EBUSY; 967 goto out; 968 } 969 970 /* If master port has an active link, allocate net and enum peers */ 971 if (rio_mport_is_active(mport)) { 972 net = rio_scan_alloc_net(mport, 1, 0); 973 if (!net) { 974 printk(KERN_ERR "RIO: failed to allocate new net\n"); 975 rc = -ENOMEM; 976 goto out; 977 } 978 979 /* reserve mport destID in new net */ 980 rio_destid_reserve(net, mport->host_deviceid); 981 982 /* Enable Input Output Port (transmitter receiver) */ 983 rio_enable_rx_tx_port(mport, 1, 0, 0, 0); 984 985 /* Set component tag for host */ 986 rio_local_write_config_32(mport, RIO_COMPONENT_TAG_CSR, 987 next_comptag++); 988 989 next_destid = rio_destid_alloc(net); 990 991 if (rio_enum_peer(net, mport, 0, NULL, 0) < 0) { 992 /* A higher priority host won enumeration, bail. */ 993 printk(KERN_INFO 994 "RIO: master port %d device has lost enumeration to a remote host\n", 995 mport->id); 996 rio_clear_locks(net); 997 rc = -EBUSY; 998 goto out; 999 } 1000 /* free the last allocated destID (unused) */ 1001 rio_destid_free(net, next_destid); 1002 rio_update_route_tables(net); 1003 rio_clear_locks(net); 1004 rio_pw_enable(mport, 1); 1005 } else { 1006 printk(KERN_INFO "RIO: master port %d link inactive\n", 1007 mport->id); 1008 rc = -EINVAL; 1009 } 1010 1011 out: 1012 return rc; 1013 } 1014 1015 /** 1016 * rio_build_route_tables- Generate route tables from switch route entries 1017 * @net: RIO network to run route tables scan on 1018 * 1019 * For each switch device, generate a route table by copying existing 1020 * route entries from the switch. 1021 */ 1022 static void rio_build_route_tables(struct rio_net *net) 1023 { 1024 struct rio_switch *rswitch; 1025 struct rio_dev *rdev; 1026 int i; 1027 u8 sport; 1028 1029 list_for_each_entry(rswitch, &net->switches, node) { 1030 rdev = sw_to_rio_dev(rswitch); 1031 1032 rio_lock_device(net->hport, rdev->destid, 1033 rdev->hopcount, 1000); 1034 for (i = 0; 1035 i < RIO_MAX_ROUTE_ENTRIES(net->hport->sys_size); 1036 i++) { 1037 if (rio_route_get_entry(rdev, RIO_GLOBAL_TABLE, 1038 i, &sport, 0) < 0) 1039 continue; 1040 rswitch->route_table[i] = sport; 1041 } 1042 1043 rio_unlock_device(net->hport, rdev->destid, rdev->hopcount); 1044 } 1045 } 1046 1047 /** 1048 * rio_disc_mport- Start discovery through a master port 1049 * @mport: Master port to send transactions 1050 * @flags: discovery control flags 1051 * 1052 * Starts the discovery process. If we have an active link, 1053 * then wait for the signal that enumeration is complete (if wait 1054 * is allowed). 1055 * When enumeration completion is signaled, start recursive 1056 * peer discovery. Returns %0 if discovery succeeds or %-EBUSY 1057 * on failure. 1058 */ 1059 static int rio_disc_mport(struct rio_mport *mport, u32 flags) 1060 { 1061 struct rio_net *net = NULL; 1062 unsigned long to_end; 1063 1064 printk(KERN_INFO "RIO: discover master port %d, %s\n", mport->id, 1065 mport->name); 1066 1067 /* If master port has an active link, allocate net and discover peers */ 1068 if (rio_mport_is_active(mport)) { 1069 if (rio_enum_complete(mport)) 1070 goto enum_done; 1071 else if (flags & RIO_SCAN_ENUM_NO_WAIT) 1072 return -EAGAIN; 1073 1074 pr_debug("RIO: wait for enumeration to complete...\n"); 1075 1076 to_end = jiffies + CONFIG_RAPIDIO_DISC_TIMEOUT * HZ; 1077 while (time_before(jiffies, to_end)) { 1078 if (rio_enum_complete(mport)) 1079 goto enum_done; 1080 msleep(10); 1081 } 1082 1083 pr_debug("RIO: discovery timeout on mport %d %s\n", 1084 mport->id, mport->name); 1085 goto bail; 1086 enum_done: 1087 pr_debug("RIO: ... enumeration done\n"); 1088 1089 net = rio_scan_alloc_net(mport, 0, 0); 1090 if (!net) { 1091 printk(KERN_ERR "RIO: Failed to allocate new net\n"); 1092 goto bail; 1093 } 1094 1095 /* Read DestID assigned by enumerator */ 1096 rio_local_read_config_32(mport, RIO_DID_CSR, 1097 &mport->host_deviceid); 1098 mport->host_deviceid = RIO_GET_DID(mport->sys_size, 1099 mport->host_deviceid); 1100 1101 if (rio_disc_peer(net, mport, RIO_ANY_DESTID(mport->sys_size), 1102 0, NULL, 0) < 0) { 1103 printk(KERN_INFO 1104 "RIO: master port %d device has failed discovery\n", 1105 mport->id); 1106 goto bail; 1107 } 1108 1109 rio_build_route_tables(net); 1110 } 1111 1112 return 0; 1113 bail: 1114 return -EBUSY; 1115 } 1116 1117 static struct rio_scan rio_scan_ops = { 1118 .owner = THIS_MODULE, 1119 .enumerate = rio_enum_mport, 1120 .discover = rio_disc_mport, 1121 }; 1122 1123 static bool scan; 1124 module_param(scan, bool, 0); 1125 MODULE_PARM_DESC(scan, "Start RapidIO network enumeration/discovery " 1126 "(default = 0)"); 1127 1128 /** 1129 * rio_basic_attach: 1130 * 1131 * When this enumeration/discovery method is loaded as a module this function 1132 * registers its specific enumeration and discover routines for all available 1133 * RapidIO mport devices. The "scan" command line parameter controls ability of 1134 * the module to start RapidIO enumeration/discovery automatically. 1135 * 1136 * Returns 0 for success or -EIO if unable to register itself. 1137 * 1138 * This enumeration/discovery method cannot be unloaded and therefore does not 1139 * provide a matching cleanup_module routine. 1140 */ 1141 1142 static int __init rio_basic_attach(void) 1143 { 1144 if (rio_register_scan(RIO_MPORT_ANY, &rio_scan_ops)) 1145 return -EIO; 1146 if (scan) 1147 rio_init_mports(); 1148 return 0; 1149 } 1150 1151 late_initcall(rio_basic_attach); 1152 1153 MODULE_DESCRIPTION("Basic RapidIO enumeration/discovery"); 1154 MODULE_LICENSE("GPL"); 1155