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, &regval);
 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				 &regval);
 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");