drivers/rapidio/rio-scan.c

   1 /*
   2  * RapidIO enumeration and discovery support
   3  *
   4  * Copyright 2005 MontaVista Software, Inc.
   5  * Matt Porter <mporter@kernel.crashing.org>
   6  *
   7  * This program is free software; you can redistribute  it and/or modify it
   8  * under  the terms of  the GNU General  Public License as published by the
   9  * Free Software Foundation;  either version 2 of the  License, or (at your
  10  * option) any later version.
  11  */
  12
  13 #include <linux/config.h>
  14 #include <linux/types.h>
  15 #include <linux/kernel.h>
  16
  17 #include <linux/delay.h>
  18 #include <linux/dma-mapping.h>
  19 #include <linux/init.h>
  20 #include <linux/rio.h>
  21 #include <linux/rio_drv.h>
  22 #include <linux/rio_ids.h>
  23 #include <linux/rio_regs.h>
  24 #include <linux/module.h>
  25 #include <linux/spinlock.h>
  26 #include <linux/timer.h>
  27
  28 #include "rio.h"
  29
  30 LIST_HEAD(rio_devices);
  31 static LIST_HEAD(rio_switches);
  32
  33 #define RIO_ENUM_CMPL_MAGIC     0xdeadbeef
  34
  35 static void rio_enum_timeout(unsigned long);
  36
  37 DEFINE_SPINLOCK(rio_global_list_lock);
  38
  39 static int next_destid = 0;
  40 static int next_switchid = 0;
  41 static int next_net = 0;
  42
  43 static struct timer_list rio_enum_timer =
  44 TIMER_INITIALIZER(rio_enum_timeout, 0, 0);
  45
  46 static int rio_mport_phys_table[] = {
  47         RIO_EFB_PAR_EP_ID,
  48         RIO_EFB_PAR_EP_REC_ID,
  49         RIO_EFB_SER_EP_ID,
  50         RIO_EFB_SER_EP_REC_ID,
  51         -1,
  52 };
  53
  54 static int rio_sport_phys_table[] = {
  55         RIO_EFB_PAR_EP_FREE_ID,
  56         RIO_EFB_SER_EP_FREE_ID,
  57         -1,
  58 };
  59
  60 /**
  61  * rio_get_device_id - Get the base/extended device id for a device
  62  * @port: RIO master port
  63  * @destid: Destination ID of device
  64  * @hopcount: Hopcount to device
  65  *
  66  * Reads the base/extended device id from a device. Returns the
  67  * 8/16-bit device ID.
  68  */
  69 static u16 rio_get_device_id(struct rio_mport *port, u16 destid, u8 hopcount)
  70 {
  71         u32 result;
  72
  73         rio_mport_read_config_32(port, destid, hopcount, RIO_DID_CSR, &result);
  74
  75         return RIO_GET_DID(result);
  76 }
  77
  78 /**
  79  * rio_set_device_id - Set the base/extended device id for a device
  80  * @port: RIO master port
  81  * @destid: Destination ID of device
  82  * @hopcount: Hopcount to device
  83  * @did: Device ID value to be written
  84  *
  85  * Writes the base/extended device id from a device.
  86  */
  87 static void rio_set_device_id(struct rio_mport *port, u16 destid, u8 hopcount, u16 did)
  88 {
  89         rio_mport_write_config_32(port, destid, hopcount, RIO_DID_CSR,
  90                                   RIO_SET_DID(did));
  91 }
  92
  93 /**
  94  * rio_local_set_device_id - Set the base/extended device id for a port
  95  * @port: RIO master port
  96  * @did: Device ID value to be written
  97  *
  98  * Writes the base/extended device id from a device.
  99  */
 100 static void rio_local_set_device_id(struct rio_mport *port, u16 did)
 101 {
 102         rio_local_write_config_32(port, RIO_DID_CSR, RIO_SET_DID(did));
 103 }
 104
 105 /**
 106  * rio_clear_locks- Release all host locks and signal enumeration complete
 107  * @port: Master port to issue transaction
 108  *
 109  * Marks the component tag CSR on each device with the enumeration
 110  * complete flag. When complete, it then release the host locks on
 111  * each device. Returns 0 on success or %-EINVAL on failure.
 112  */
 113 static int rio_clear_locks(struct rio_mport *port)
 114 {
 115         struct rio_dev *rdev;
 116         u32 result;
 117         int ret = 0;
 118
 119         /* Write component tag CSR magic complete value */
 120         rio_local_write_config_32(port, RIO_COMPONENT_TAG_CSR,
 121                                   RIO_ENUM_CMPL_MAGIC);
 122         list_for_each_entry(rdev, &rio_devices, global_list)
 123             rio_write_config_32(rdev, RIO_COMPONENT_TAG_CSR,
 124                                 RIO_ENUM_CMPL_MAGIC);
 125
 126         /* Release host device id locks */
 127         rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR,
 128                                   port->host_deviceid);
 129         rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result);
 130         if ((result & 0xffff) != 0xffff) {
 131                 printk(KERN_INFO
 132                        "RIO: badness when releasing host lock on master port, result %8.8x\n",
 133                        result);
 134                 ret = -EINVAL;
 135         }
 136         list_for_each_entry(rdev, &rio_devices, global_list) {
 137                 rio_write_config_32(rdev, RIO_HOST_DID_LOCK_CSR,
 138                                     port->host_deviceid);
 139                 rio_read_config_32(rdev, RIO_HOST_DID_LOCK_CSR, &result);
 140                 if ((result & 0xffff) != 0xffff) {
 141                         printk(KERN_INFO
 142                                "RIO: badness when releasing host lock on vid %4.4x did %4.4x\n",
 143                                rdev->vid, rdev->did);
 144                         ret = -EINVAL;
 145                 }
 146         }
 147
 148         return ret;
 149 }
 150
 151 /**
 152  * rio_enum_host- Set host lock and initialize host destination ID
 153  * @port: Master port to issue transaction
 154  *
 155  * Sets the local host master port lock and destination ID register
 156  * with the host device ID value. The host device ID value is provided
 157  * by the platform. Returns %0 on success or %-1 on failure.
 158  */
 159 static int rio_enum_host(struct rio_mport *port)
 160 {
 161         u32 result;
 162
 163         /* Set master port host device id lock */
 164         rio_local_write_config_32(port, RIO_HOST_DID_LOCK_CSR,
 165                                   port->host_deviceid);
 166
 167         rio_local_read_config_32(port, RIO_HOST_DID_LOCK_CSR, &result);
 168         if ((result & 0xffff) != port->host_deviceid)
 169                 return -1;
 170
 171         /* Set master port destid and init destid ctr */
 172         rio_local_set_device_id(port, port->host_deviceid);
 173
 174         if (next_destid == port->host_deviceid)
 175                 next_destid++;
 176
 177         return 0;
 178 }
 179
 180 /**
 181  * rio_device_has_destid- Test if a device contains a destination ID register
 182  * @port: Master port to issue transaction
 183  * @src_ops: RIO device source operations
 184  * @dst_ops: RIO device destination operations
 185  *
 186  * Checks the provided @src_ops and @dst_ops for the necessary transaction
 187  * capabilities that indicate whether or not a device will implement a
 188  * destination ID register. Returns 1 if true or 0 if false.
 189  */
 190 static int rio_device_has_destid(struct rio_mport *port, int src_ops,
 191                                  int dst_ops)
 192 {
 193         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;
 194
 195         return !!((src_ops | dst_ops) & mask);
 196 }
 197
 198 /**
 199  * rio_release_dev- Frees a RIO device struct
 200  * @dev: LDM device associated with a RIO device struct
 201  *
 202  * Gets the RIO device struct associated a RIO device struct.
 203  * The RIO device struct is freed.
 204  */
 205 static void rio_release_dev(struct device *dev)
 206 {
 207         struct rio_dev *rdev;
 208
 209         rdev = to_rio_dev(dev);
 210         kfree(rdev);
 211 }
 212
 213 /**
 214  * rio_is_switch- Tests if a RIO device has switch capabilities
 215  * @rdev: RIO device
 216  *
 217  * Gets the RIO device Processing Element Features register
 218  * contents and tests for switch capabilities. Returns 1 if
 219  * the device is a switch or 0 if it is not a switch.
 220  * The RIO device struct is freed.
 221  */
 222 static int rio_is_switch(struct rio_dev *rdev)
 223 {
 224         if (rdev->pef & RIO_PEF_SWITCH)
 225                 return 1;
 226         return 0;
 227 }
 228
 229 /**
 230  * rio_route_set_ops- Sets routing operations for a particular vendor switch
 231  * @rdev: RIO device
 232  *
 233  * Searches the RIO route ops table for known switch types. If the vid
 234  * and did match a switch table entry, then set the add_entry() and
 235  * get_entry() ops to the table entry values.
 236  */
 237 static void rio_route_set_ops(struct rio_dev *rdev)
 238 {
 239         struct rio_route_ops *cur = __start_rio_route_ops;
 240         struct rio_route_ops *end = __end_rio_route_ops;
 241
 242         while (cur < end) {
 243                 if ((cur->vid == rdev->vid) && (cur->did == rdev->did)) {
 244                         pr_debug("RIO: adding routing ops for %s\n", rio_name(rdev));
 245                         rdev->rswitch->add_entry = cur->add_hook;
 246                         rdev->rswitch->get_entry = cur->get_hook;
 247                 }
 248                 cur++;
 249         }
 250
 251         if (!rdev->rswitch->add_entry || !rdev->rswitch->get_entry)
 252                 printk(KERN_ERR "RIO: missing routing ops for %s\n",
 253                        rio_name(rdev));
 254 }
 255
 256 /**
 257  * rio_add_device- Adds a RIO device to the device model
 258  * @rdev: RIO device
 259  *
 260  * Adds the RIO device to the global device list and adds the RIO
 261  * device to the RIO device list.  Creates the generic sysfs nodes
 262  * for an RIO device.
 263  */
 264 static void __devinit rio_add_device(struct rio_dev *rdev)
 265 {
 266         device_add(&rdev->dev);
 267
 268         spin_lock(&rio_global_list_lock);
 269         list_add_tail(&rdev->global_list, &rio_devices);
 270         spin_unlock(&rio_global_list_lock);
 271
 272         rio_create_sysfs_dev_files(rdev);
 273 }
 274
 275 /**
 276  * rio_setup_device- Allocates and sets up a RIO device
 277  * @net: RIO network
 278  * @port: Master port to send transactions
 279  * @destid: Current destination ID
 280  * @hopcount: Current hopcount
 281  * @do_enum: Enumeration/Discovery mode flag
 282  *
 283  * Allocates a RIO device and configures fields based on configuration
 284  * space contents. If device has a destination ID register, a destination
 285  * ID is either assigned in enumeration mode or read from configuration
 286  * space in discovery mode.  If the device has switch capabilities, then
 287  * a switch is allocated and configured appropriately. Returns a pointer
 288  * to a RIO device on success or NULL on failure.
 289  *
 290  */
 291 static struct rio_dev *rio_setup_device(struct rio_net *net,
 292                                         struct rio_mport *port, u16 destid,
 293                                         u8 hopcount, int do_enum)
 294 {
 295         struct rio_dev *rdev;
 296         struct rio_switch *rswitch;
 297         int result, rdid;
 298
 299         rdev = kmalloc(sizeof(struct rio_dev), GFP_KERNEL);
 300         if (!rdev)
 301                 goto out;
 302
 303         memset(rdev, 0, sizeof(struct rio_dev));
 304         rdev->net = net;
 305         rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_ID_CAR,
 306                                  &result);
 307         rdev->did = result >> 16;
 308         rdev->vid = result & 0xffff;
 309         rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_INFO_CAR,
 310                                  &rdev->device_rev);
 311         rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_ID_CAR,
 312                                  &result);
 313         rdev->asm_did = result >> 16;
 314         rdev->asm_vid = result & 0xffff;
 315         rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_INFO_CAR,
 316                                  &result);
 317         rdev->asm_rev = result >> 16;
 318         rio_mport_read_config_32(port, destid, hopcount, RIO_PEF_CAR,
 319                                  &rdev->pef);
 320         if (rdev->pef & RIO_PEF_EXT_FEATURES)
 321                 rdev->efptr = result & 0xffff;
 322
 323         rio_mport_read_config_32(port, destid, hopcount, RIO_SRC_OPS_CAR,
 324                                  &rdev->src_ops);
 325         rio_mport_read_config_32(port, destid, hopcount, RIO_DST_OPS_CAR,
 326                                  &rdev->dst_ops);
 327
 328         if (rio_device_has_destid(port, rdev->src_ops, rdev->dst_ops)
 329             && do_enum) {
 330                 rio_set_device_id(port, destid, hopcount, next_destid);
 331                 rdev->destid = next_destid++;
 332                 if (next_destid == port->host_deviceid)
 333                         next_destid++;
 334         } else
 335                 rdev->destid = rio_get_device_id(port, destid, hopcount);
 336
 337         /* If a PE has both switch and other functions, show it as a switch */
 338         if (rio_is_switch(rdev)) {
 339                 rio_mport_read_config_32(port, destid, hopcount,
 340                                          RIO_SWP_INFO_CAR, &rdev->swpinfo);
 341                 rswitch = kmalloc(sizeof(struct rio_switch), GFP_KERNEL);
 342                 if (!rswitch) {
 343                         kfree(rdev);
 344                         rdev = NULL;
 345                         goto out;
 346                 }
 347                 rswitch->switchid = next_switchid;
 348                 rswitch->hopcount = hopcount;
 349                 rswitch->destid = 0xffff;
 350                 /* Initialize switch route table */
 351                 for (rdid = 0; rdid < RIO_MAX_ROUTE_ENTRIES; rdid++)
 352                         rswitch->route_table[rdid] = RIO_INVALID_ROUTE;
 353                 rdev->rswitch = rswitch;
 354                 sprintf(rio_name(rdev), "%02x:s:%04x", rdev->net->id,
 355                         rdev->rswitch->switchid);
 356                 rio_route_set_ops(rdev);
 357
 358                 list_add_tail(&rswitch->node, &rio_switches);
 359
 360         } else
 361                 sprintf(rio_name(rdev), "%02x:e:%04x", rdev->net->id,
 362                         rdev->destid);
 363
 364         rdev->dev.bus = &rio_bus_type;
 365
 366         device_initialize(&rdev->dev);
 367         rdev->dev.release = rio_release_dev;
 368         rio_dev_get(rdev);
 369
 370         rdev->dma_mask = DMA_32BIT_MASK;
 371         rdev->dev.dma_mask = &rdev->dma_mask;
 372         rdev->dev.coherent_dma_mask = DMA_32BIT_MASK;
 373
 374         if ((rdev->pef & RIO_PEF_INB_DOORBELL) &&
 375             (rdev->dst_ops & RIO_DST_OPS_DOORBELL))
 376                 rio_init_dbell_res(&rdev->riores[RIO_DOORBELL_RESOURCE],
 377                                    0, 0xffff);
 378
 379         rio_add_device(rdev);
 380
 381       out:
 382         return rdev;
 383 }
 384
 385 /**
 386  * rio_sport_is_active- Tests if a switch port has an active connection.
 387  * @port: Master port to send transaction
 388  * @destid: Associated destination ID for switch
 389  * @hopcount: Hopcount to reach switch
 390  * @sport: Switch port number
 391  *
 392  * Reads the port error status CSR for a particular switch port to
 393  * determine if the port has an active link.  Returns
 394  * %PORT_N_ERR_STS_PORT_OK if the port is active or %0 if it is
 395  * inactive.
 396  */
 397 static int
 398 rio_sport_is_active(struct rio_mport *port, u16 destid, u8 hopcount, int sport)
 399 {
 400         u32 result;
 401         u32 ext_ftr_ptr;
 402
 403         int *entry = rio_sport_phys_table;
 404
 405         do {
 406                 if ((ext_ftr_ptr =
 407                      rio_mport_get_feature(port, 0, destid, hopcount, *entry)))
 408
 409                         break;
 410         } while (*++entry >= 0);
 411
 412         if (ext_ftr_ptr)
 413                 rio_mport_read_config_32(port, destid, hopcount,
 414                                          ext_ftr_ptr +
 415                                          RIO_PORT_N_ERR_STS_CSR(sport),
 416                                          &result);
 417
 418         return (result & PORT_N_ERR_STS_PORT_OK);
 419 }
 420
 421 /**
 422  * rio_route_add_entry- Add a route entry to a switch routing table
 423  * @mport: Master port to send transaction
 424  * @rdev: Switch device
 425  * @table: Routing table ID
 426  * @route_destid: Destination ID to be routed
 427  * @route_port: Port number to be routed
 428  *
 429  * Calls the switch specific add_entry() method to add a route entry
 430  * on a switch. The route table can be specified using the @table
 431  * argument if a switch has per port routing tables or the normal
 432  * use is to specific all tables (or the global table) by passing
 433  * %RIO_GLOBAL_TABLE in @table. Returns %0 on success or %-EINVAL
 434  * on failure.
 435  */
 436 static int rio_route_add_entry(struct rio_mport *mport, struct rio_dev *rdev,
 437                                u16 table, u16 route_destid, u8 route_port)
 438 {
 439         return rdev->rswitch->add_entry(mport, rdev->rswitch->destid,
 440                                         rdev->rswitch->hopcount, table,
 441                                         route_destid, route_port);
 442 }
 443
 444 /**
 445  * rio_route_get_entry- Read a route entry in a switch routing table
 446  * @mport: Master port to send transaction
 447  * @rdev: Switch device
 448  * @table: Routing table ID
 449  * @route_destid: Destination ID to be routed
 450  * @route_port: Pointer to read port number into
 451  *
 452  * Calls the switch specific get_entry() method to read a route entry
 453  * in a switch. The route table can be specified using the @table
 454  * argument if a switch has per port routing tables or the normal
 455  * use is to specific all tables (or the global table) by passing
 456  * %RIO_GLOBAL_TABLE in @table. Returns %0 on success or %-EINVAL
 457  * on failure.
 458  */
 459 static int
 460 rio_route_get_entry(struct rio_mport *mport, struct rio_dev *rdev, u16 table,
 461                     u16 route_destid, u8 * route_port)
 462 {
 463         return rdev->rswitch->get_entry(mport, rdev->rswitch->destid,
 464                                         rdev->rswitch->hopcount, table,
 465                                         route_destid, route_port);
 466 }
 467
 468 /**
 469  * rio_get_host_deviceid_lock- Reads the Host Device ID Lock CSR on a device
 470  * @port: Master port to send transaction
 471  * @hopcount: Number of hops to the device
 472  *
 473  * Used during enumeration to read the Host Device ID Lock CSR on a
 474  * RIO device. Returns the value of the lock register.
 475  */
 476 static u16 rio_get_host_deviceid_lock(struct rio_mport *port, u8 hopcount)
 477 {
 478         u32 result;
 479
 480         rio_mport_read_config_32(port, RIO_ANY_DESTID, hopcount,
 481                                  RIO_HOST_DID_LOCK_CSR, &result);
 482
 483         return (u16) (result & 0xffff);
 484 }
 485
 486 /**
 487  * rio_get_swpinfo_inport- Gets the ingress port number
 488  * @mport: Master port to send transaction
 489  * @destid: Destination ID associated with the switch
 490  * @hopcount: Number of hops to the device
 491  *
 492  * Returns port number being used to access the switch device.
 493  */
 494 static u8
 495 rio_get_swpinfo_inport(struct rio_mport *mport, u16 destid, u8 hopcount)
 496 {
 497         u32 result;
 498
 499         rio_mport_read_config_32(mport, destid, hopcount, RIO_SWP_INFO_CAR,
 500                                  &result);
 501
 502         return (u8) (result & 0xff);
 503 }
 504
 505 /**
 506  * rio_get_swpinfo_tports- Gets total number of ports on the switch
 507  * @mport: Master port to send transaction
 508  * @destid: Destination ID associated with the switch
 509  * @hopcount: Number of hops to the device
 510  *
 511  * Returns total numbers of ports implemented by the switch device.
 512  */
 513 static u8 rio_get_swpinfo_tports(struct rio_mport *mport, u16 destid,
 514                                  u8 hopcount)
 515 {
 516         u32 result;
 517
 518         rio_mport_read_config_32(mport, destid, hopcount, RIO_SWP_INFO_CAR,
 519                                  &result);
 520
 521         return RIO_GET_TOTAL_PORTS(result);
 522 }
 523
 524 /**
 525  * rio_net_add_mport- Add a master port to a RIO network
 526  * @net: RIO network
 527  * @port: Master port to add
 528  *
 529  * Adds a master port to the network list of associated master
 530  * ports..
 531  */
 532 static void rio_net_add_mport(struct rio_net *net, struct rio_mport *port)
 533 {
 534         spin_lock(&rio_global_list_lock);
 535         list_add_tail(&port->nnode, &net->mports);
 536         spin_unlock(&rio_global_list_lock);
 537 }
 538
 539 /**
 540  * rio_enum_peer- Recursively enumerate a RIO network through a master port
 541  * @net: RIO network being enumerated
 542  * @port: Master port to send transactions
 543  * @hopcount: Number of hops into the network
 544  *
 545  * Recursively enumerates a RIO network.  Transactions are sent via the
 546  * master port passed in @port.
 547  */
 548 static int rio_enum_peer(struct rio_net *net, struct rio_mport *port,
 549                          u8 hopcount)
 550 {
 551         int port_num;
 552         int num_ports;
 553         int cur_destid;
 554         struct rio_dev *rdev;
 555         u16 destid;
 556         int tmp;
 557
 558         if (rio_get_host_deviceid_lock(port, hopcount) == port->host_deviceid) {
 559                 pr_debug("RIO: PE already discovered by this host\n");
 560                 /*
 561                  * Already discovered by this host. Add it as another
 562                  * master port for the current network.
 563                  */
 564                 rio_net_add_mport(net, port);
 565                 return 0;
 566         }
 567
 568         /* Attempt to acquire device lock */
 569         rio_mport_write_config_32(port, RIO_ANY_DESTID, hopcount,
 570                                   RIO_HOST_DID_LOCK_CSR, port->host_deviceid);
 571         while ((tmp = rio_get_host_deviceid_lock(port, hopcount))
 572                < port->host_deviceid) {
 573                 /* Delay a bit */
 574                 mdelay(1);
 575                 /* Attempt to acquire device lock again */
 576                 rio_mport_write_config_32(port, RIO_ANY_DESTID, hopcount,
 577                                           RIO_HOST_DID_LOCK_CSR,
 578                                           port->host_deviceid);
 579         }
 580
 581         if (rio_get_host_deviceid_lock(port, hopcount) > port->host_deviceid) {
 582                 pr_debug(
 583                     "RIO: PE locked by a higher priority host...retreating\n");
 584                 return -1;
 585         }
 586
 587         /* Setup new RIO device */
 588         if ((rdev = rio_setup_device(net, port, RIO_ANY_DESTID, hopcount, 1))) {
 589                 /* Add device to the global and bus/net specific list. */
 590                 list_add_tail(&rdev->net_list, &net->devices);
 591         } else
 592                 return -1;
 593
 594         if (rio_is_switch(rdev)) {
 595                 next_switchid++;
 596
 597                 for (destid = 0; destid < next_destid; destid++) {
 598                         rio_route_add_entry(port, rdev, RIO_GLOBAL_TABLE,
 599                                             destid, rio_get_swpinfo_inport(port,
 600                                                                            RIO_ANY_DESTID,
 601                                                                            hopcount));
 602                         rdev->rswitch->route_table[destid] =
 603                             rio_get_swpinfo_inport(port, RIO_ANY_DESTID,
 604                                                    hopcount);
 605                 }
 606
 607                 num_ports =
 608                     rio_get_swpinfo_tports(port, RIO_ANY_DESTID, hopcount);
 609                 pr_debug(
 610                     "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n",
 611                     rio_name(rdev), rdev->vid, rdev->did, num_ports);
 612                 for (port_num = 0; port_num < num_ports; port_num++) {
 613                         if (rio_get_swpinfo_inport
 614                             (port, RIO_ANY_DESTID, hopcount) == port_num)
 615                                 continue;
 616
 617                         cur_destid = next_destid;
 618
 619                         if (rio_sport_is_active
 620                             (port, RIO_ANY_DESTID, hopcount, port_num)) {
 621                                 pr_debug(
 622                                     "RIO: scanning device on port %d\n",
 623                                     port_num);
 624                                 rio_route_add_entry(port, rdev,
 625                                                     RIO_GLOBAL_TABLE,
 626                                                     RIO_ANY_DESTID, port_num);
 627
 628                                 if (rio_enum_peer(net, port, hopcount + 1) < 0)
 629                                         return -1;
 630
 631                                 /* Update routing tables */
 632                                 if (next_destid > cur_destid) {
 633                                         for (destid = cur_destid;
 634                                              destid < next_destid; destid++) {
 635                                                 rio_route_add_entry(port, rdev,
 636                                                                     RIO_GLOBAL_TABLE,
 637                                                                     destid,
 638                                                                     port_num);
 639                                                 rdev->rswitch->
 640                                                     route_table[destid] =
 641                                                     port_num;
 642                                         }
 643                                         rdev->rswitch->destid = cur_destid;
 644                                 }
 645                         }
 646                 }
 647         } else
 648                 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n",
 649                     rio_name(rdev), rdev->vid, rdev->did);
 650
 651         return 0;
 652 }
 653
 654 /**
 655  * rio_enum_complete- Tests if enumeration of a network is complete
 656  * @port: Master port to send transaction
 657  *
 658  * Tests the Component Tag CSR for presence of the magic enumeration
 659  * complete flag. Return %1 if enumeration is complete or %0 if
 660  * enumeration is incomplete.
 661  */
 662 static int rio_enum_complete(struct rio_mport *port)
 663 {
 664         u32 tag_csr;
 665         int ret = 0;
 666
 667         rio_local_read_config_32(port, RIO_COMPONENT_TAG_CSR, &tag_csr);
 668
 669         if (tag_csr == RIO_ENUM_CMPL_MAGIC)
 670                 ret = 1;
 671
 672         return ret;
 673 }
 674
 675 /**
 676  * rio_disc_peer- Recursively discovers a RIO network through a master port
 677  * @net: RIO network being discovered
 678  * @port: Master port to send transactions
 679  * @destid: Current destination ID in network
 680  * @hopcount: Number of hops into the network
 681  *
 682  * Recursively discovers a RIO network.  Transactions are sent via the
 683  * master port passed in @port.
 684  */
 685 static int
 686 rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid,
 687               u8 hopcount)
 688 {
 689         u8 port_num, route_port;
 690         int num_ports;
 691         struct rio_dev *rdev;
 692         u16 ndestid;
 693
 694         /* Setup new RIO device */
 695         if ((rdev = rio_setup_device(net, port, destid, hopcount, 0))) {
 696                 /* Add device to the global and bus/net specific list. */
 697                 list_add_tail(&rdev->net_list, &net->devices);
 698         } else
 699                 return -1;
 700
 701         if (rio_is_switch(rdev)) {
 702                 next_switchid++;
 703
 704                 /* Associated destid is how we accessed this switch */
 705                 rdev->rswitch->destid = destid;
 706
 707                 num_ports = rio_get_swpinfo_tports(port, destid, hopcount);
 708                 pr_debug(
 709                     "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n",
 710                     rio_name(rdev), rdev->vid, rdev->did, num_ports);
 711                 for (port_num = 0; port_num < num_ports; port_num++) {
 712                         if (rio_get_swpinfo_inport(port, destid, hopcount) ==
 713                             port_num)
 714                                 continue;
 715
 716                         if (rio_sport_is_active
 717                             (port, destid, hopcount, port_num)) {
 718                                 pr_debug(
 719                                     "RIO: scanning device on port %d\n",
 720                                     port_num);
 721                                 for (ndestid = 0; ndestid < RIO_ANY_DESTID;
 722                                      ndestid++) {
 723                                         rio_route_get_entry(port, rdev,
 724                                                             RIO_GLOBAL_TABLE,
 725                                                             ndestid,
 726                                                             &route_port);
 727                                         if (route_port == port_num)
 728                                                 break;
 729                                 }
 730
 731                                 if (rio_disc_peer
 732                                     (net, port, ndestid, hopcount + 1) < 0)
 733                                         return -1;
 734                         }
 735                 }
 736         } else
 737                 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n",
 738                     rio_name(rdev), rdev->vid, rdev->did);
 739
 740         return 0;
 741 }
 742
 743 /**
 744  * rio_mport_is_active- Tests if master port link is active
 745  * @port: Master port to test
 746  *
 747  * Reads the port error status CSR for the master port to
 748  * determine if the port has an active link.  Returns
 749  * %PORT_N_ERR_STS_PORT_OK if the  master port is active
 750  * or %0 if it is inactive.
 751  */
 752 static int rio_mport_is_active(struct rio_mport *port)
 753 {
 754         u32 result = 0;
 755         u32 ext_ftr_ptr;
 756         int *entry = rio_mport_phys_table;
 757
 758         do {
 759                 if ((ext_ftr_ptr =
 760                      rio_mport_get_feature(port, 1, 0, 0, *entry)))
 761                         break;
 762         } while (*++entry >= 0);
 763
 764         if (ext_ftr_ptr)
 765                 rio_local_read_config_32(port,
 766                                          ext_ftr_ptr +
 767                                          RIO_PORT_N_ERR_STS_CSR(port->index),
 768                                          &result);
 769
 770         return (result & PORT_N_ERR_STS_PORT_OK);
 771 }
 772
 773 /**
 774  * rio_alloc_net- Allocate and configure a new RIO network
 775  * @port: Master port associated with the RIO network
 776  *
 777  * Allocates a RIO network structure, initializes per-network
 778  * list heads, and adds the associated master port to the
 779  * network list of associated master ports. Returns a
 780  * RIO network pointer on success or %NULL on failure.
 781  */
 782 static struct rio_net __devinit *rio_alloc_net(struct rio_mport *port)
 783 {
 784         struct rio_net *net;
 785
 786         net = kmalloc(sizeof(struct rio_net), GFP_KERNEL);
 787         if (net) {
 788                 memset(net, 0, sizeof(struct rio_net));
 789                 INIT_LIST_HEAD(&net->node);
 790                 INIT_LIST_HEAD(&net->devices);
 791                 INIT_LIST_HEAD(&net->mports);
 792                 list_add_tail(&port->nnode, &net->mports);
 793                 net->hport = port;
 794                 net->id = next_net++;
 795         }
 796         return net;
 797 }
 798
 799 /**
 800  * rio_enum_mport- Start enumeration through a master port
 801  * @mport: Master port to send transactions
 802  *
 803  * Starts the enumeration process. If somebody has enumerated our
 804  * master port device, then give up. If not and we have an active
 805  * link, then start recursive peer enumeration. Returns %0 if
 806  * enumeration succeeds or %-EBUSY if enumeration fails.
 807  */
 808 int rio_enum_mport(struct rio_mport *mport)
 809 {
 810         struct rio_net *net = NULL;
 811         int rc = 0;
 812
 813         printk(KERN_INFO "RIO: enumerate master port %d, %s\n", mport->id,
 814                mport->name);
 815         /* If somebody else enumerated our master port device, bail. */
 816         if (rio_enum_host(mport) < 0) {
 817                 printk(KERN_INFO
 818                        "RIO: master port %d device has been enumerated by a remote host\n",
 819                        mport->id);
 820                 rc = -EBUSY;
 821                 goto out;
 822         }
 823
 824         /* If master port has an active link, allocate net and enum peers */
 825         if (rio_mport_is_active(mport)) {
 826                 if (!(net = rio_alloc_net(mport))) {
 827                         printk(KERN_ERR "RIO: failed to allocate new net\n");
 828                         rc = -ENOMEM;
 829                         goto out;
 830                 }
 831                 if (rio_enum_peer(net, mport, 0) < 0) {
 832                         /* A higher priority host won enumeration, bail. */
 833                         printk(KERN_INFO
 834                                "RIO: master port %d device has lost enumeration to a remote host\n",
 835                                mport->id);
 836                         rio_clear_locks(mport);
 837                         rc = -EBUSY;
 838                         goto out;
 839                 }
 840                 rio_clear_locks(mport);
 841         } else {
 842                 printk(KERN_INFO "RIO: master port %d link inactive\n",
 843                        mport->id);
 844                 rc = -EINVAL;
 845         }
 846
 847       out:
 848         return rc;
 849 }
 850
 851 /**
 852  * rio_build_route_tables- Generate route tables from switch route entries
 853  *
 854  * For each switch device, generate a route table by copying existing
 855  * route entries from the switch.
 856  */
 857 static void rio_build_route_tables(void)
 858 {
 859         struct rio_dev *rdev;
 860         int i;
 861         u8 sport;
 862
 863         list_for_each_entry(rdev, &rio_devices, global_list)
 864             if (rio_is_switch(rdev))
 865                 for (i = 0; i < RIO_MAX_ROUTE_ENTRIES; i++) {
 866                         if (rio_route_get_entry
 867                             (rdev->net->hport, rdev, RIO_GLOBAL_TABLE, i,
 868                              &sport) < 0)
 869                                 continue;
 870                         rdev->rswitch->route_table[i] = sport;
 871                 }
 872 }
 873
 874 /**
 875  * rio_enum_timeout- Signal that enumeration timed out
 876  * @data: Address of timeout flag.
 877  *
 878  * When the enumeration complete timer expires, set a flag that
 879  * signals to the discovery process that enumeration did not
 880  * complete in a sane amount of time.
 881  */
 882 static void rio_enum_timeout(unsigned long data)
 883 {
 884         /* Enumeration timed out, set flag */
 885         *(int *)data = 1;
 886 }
 887
 888 /**
 889  * rio_disc_mport- Start discovery through a master port
 890  * @mport: Master port to send transactions
 891  *
 892  * Starts the discovery process. If we have an active link,
 893  * then wait for the signal that enumeration is complete.
 894  * When enumeration completion is signaled, start recursive
 895  * peer discovery. Returns %0 if discovery succeeds or %-EBUSY
 896  * on failure.
 897  */
 898 int rio_disc_mport(struct rio_mport *mport)
 899 {
 900         struct rio_net *net = NULL;
 901         int enum_timeout_flag = 0;
 902
 903         printk(KERN_INFO "RIO: discover master port %d, %s\n", mport->id,
 904                mport->name);
 905
 906         /* If master port has an active link, allocate net and discover peers */
 907         if (rio_mport_is_active(mport)) {
 908                 if (!(net = rio_alloc_net(mport))) {
 909                         printk(KERN_ERR "RIO: Failed to allocate new net\n");
 910                         goto bail;
 911                 }
 912
 913                 pr_debug("RIO: wait for enumeration complete...");
 914
 915                 rio_enum_timer.expires =
 916                     jiffies + CONFIG_RAPIDIO_DISC_TIMEOUT * HZ;
 917                 rio_enum_timer.data = (unsigned long)&enum_timeout_flag;
 918                 add_timer(&rio_enum_timer);
 919                 while (!rio_enum_complete(mport)) {
 920                         mdelay(1);
 921                         if (enum_timeout_flag) {
 922                                 del_timer_sync(&rio_enum_timer);
 923                                 goto timeout;
 924                         }
 925                 }
 926                 del_timer_sync(&rio_enum_timer);
 927
 928                 pr_debug("done\n");
 929                 if (rio_disc_peer(net, mport, RIO_ANY_DESTID, 0) < 0) {
 930                         printk(KERN_INFO
 931                                "RIO: master port %d device has failed discovery\n",
 932                                mport->id);
 933                         goto bail;
 934                 }
 935
 936                 rio_build_route_tables();
 937         }
 938
 939         return 0;
 940
 941       timeout:
 942         pr_debug("timeout\n");
 943       bail:
 944         return -EBUSY;
 945 }