1157 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * RapidIO enumeration and discovery support4 *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 handling11 *12 * Copyright 2009 Sysgo AG13 * Thomas Moll <thomas.moll@sysgo.com>14 * - Added Input- Output- enable functionality, to allow full communication15 */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 network50 * @net: RIO network51 *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 } else68 destid = RIO_INVALID_DESTID;69 70 spin_unlock(&idtab->lock);71 return (u16)destid;72}73 74/**75 * rio_destid_reserve - Reserve the specified destID76 * @net: RIO network77 * @destid: destID to reserve78 *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 destID96 * @net: RIO network97 * @destid: destID to free98 *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 use113 * @net: RIO network114 */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 else125 destid += idtab->start;126 spin_unlock(&idtab->lock);127 return (u16)destid;128}129 130/**131 * rio_destid_next - return next destID in use132 * @net: RIO network133 * @from: destination ID from which search shall continue134 */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 else145 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 device152 * @port: RIO master port153 * @destid: Destination ID of device154 * @hopcount: Hopcount to device155 *156 * Reads the base/extended device id from a device. Returns the157 * 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 device170 * @port: RIO master port171 * @destid: Destination ID of device172 * @hopcount: Hopcount to device173 * @did: Device ID value to be written174 *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 complete185 * @net: RIO network to run on186 *187 * Marks the component tag CSR on each device with the enumeration188 * complete flag. When complete, it then release the host locks on189 * 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_INFO204 "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_INFO214 "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 ID234 * @port: Master port to issue transaction235 *236 * Sets the local host master port lock and destination ID register237 * with the host device ID value. The host device ID value is provided238 * 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 register259 * @port: Master port to issue transaction260 * @src_ops: RIO device source operations261 * @dst_ops: RIO device destination operations262 *263 * Checks the provided @src_ops and @dst_ops for the necessary transaction264 * capabilities that indicate whether or not a device will implement a265 * 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 struct277 * @dev: LDM device associated with a RIO device struct278 *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 capabilities292 * @rdev: RIO device293 *294 * Gets the RIO device Processing Element Features register295 * contents and tests for switch capabilities. Returns 1 if296 * 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 device308 * @net: RIO network309 * @port: Master port to send transactions310 * @destid: Current destination ID311 * @hopcount: Current hopcount312 * @do_enum: Enumeration/Discovery mode flag313 *314 * Allocates a RIO device and configures fields based on configuration315 * space contents. If device has a destination ID register, a destination316 * ID is either assigned in enumeration mode or read from configuration317 * space in discovery mode. If the device has switch capabilities, then318 * a switch is allocated and configured appropriately. Returns a pointer319 * 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 } else406 rdev->destid = rio_get_device_id(port, destid, hopcount);407 408 rdev->hopcount = 0xff;409 } else {410 /* Switch device has an associated destID which411 * will be adjusted later412 */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 object479 * @sp: Switch port number480 *481 * Reads the port error status CSR for a particular switch port to482 * determine if the port has an active link. Returns483 * %RIO_PORT_N_ERR_STS_PORT_OK if the port is active or %0 if it is484 * inactive.485 */486static int487rio_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 device499 * @port: Master port to send transaction500 * @hopcount: Number of hops to the device501 *502 * Used during enumeration to read the Host Device ID Lock CSR on a503 * 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 port517 * @net: RIO network being enumerated518 * @port: Master port to send transactions519 * @hopcount: Number of hops into the network520 * @prev: Previous RIO device connected to the enumerated one521 * @prev_port: Port on previous RIO device522 *523 * Recursively enumerates a RIO network. Transactions are sent via the524 * 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 another543 * 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 } else590 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 port669 */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 } else694 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 complete702 * @port: Master port to send transaction703 *704 * Tests the PGCCSR discovered bit for non-zero value (enumeration705 * complete flag). Return %1 if enumeration is complete or %0 if706 * 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 port719 * @net: RIO network being discovered720 * @port: Master port to send transactions721 * @destid: Current destination ID in network722 * @hopcount: Number of hops into the network723 * @prev: previous rio_dev724 * @prev_port: previous port number725 *726 * Recursively discovers a RIO network. Transactions are sent via the727 * master port passed in @port.728 */729static int730rio_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 } else743 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 } else786 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 active794 * @port: Master port to test795 *796 * Reads the port error status CSR for the master port to797 * determine if the port has an active link. Returns798 * %RIO_PORT_N_ERR_STS_PORT_OK if the master port is active799 * 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 network829 * @mport: Master port associated with the RIO network830 * @do_enum: Enumeration/Discovery mode flag831 * @start: logical minimal start id for new net832 *833 * Allocates a new RIO network structure and initializes enumerator-specific834 * 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 switches882 * @net: RIO network to run update on883 *884 * For each enumerated device, ensure that each switch in a system885 * has correct routing entries. Add routes for devices that where886 * 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 device924 *925 * For each enumerated switch, call device-specific error management926 * 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 port938 * @mport: Master port to send transactions939 * @flags: Enumeration control flags940 *941 * Starts the enumeration process. If somebody has enumerated our942 * master port device, then give up. If not and we have an active943 * link, then start recursive peer enumeration. Returns %0 if944 * 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 supported956 * by this method) check if enumeration/discovery was performed for this957 * mport: if mport was added into the list of mports for a net exit958 * 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_INFO966 "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_INFO996 "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 entries1019 * @net: RIO network to run route tables scan on1020 *1021 * For each switch device, generate a route table by copying existing1022 * 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 port1051 * @mport: Master port to send transactions1052 * @flags: discovery control flags1053 *1054 * Starts the discovery process. If we have an active link,1055 * then wait for the signal that enumeration is complete (if wait1056 * is allowed).1057 * When enumeration completion is signaled, start recursive1058 * peer discovery. Returns %0 if discovery succeeds or %-EBUSY1059 * 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_INFO1106 "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 function1134 * registers its specific enumeration and discover routines for all available1135 * RapidIO mport devices. The "scan" command line parameter controls ability of1136 * 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 not1141 * 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