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