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