drivers/pci/hotplug/cpci_hotplug_pci.c

   1 /*
   2  * CompactPCI Hot Plug Driver PCI functions
   3  *
   4  * Copyright (C) 2002,2005 by SOMA Networks, Inc.
   5  *
   6  * All rights reserved.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or (at
  11  * your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  16  * NON INFRINGEMENT.  See the GNU General Public License for more
  17  * details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  * Send feedback to <scottm@somanetworks.com>
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/kernel.h>
  28 #include <linux/pci.h>
  29 #include <linux/pci_hotplug.h>
  30 #include <linux/proc_fs.h>
  31 #include "../pci.h"
  32 #include "cpci_hotplug.h"
  33
  34 #define MY_NAME "cpci_hotplug"
  35
  36 extern int cpci_debug;
  37
  38 #define dbg(format, arg...)                                     \
  39         do {                                                    \
  40                 if (cpci_debug)                                 \
  41                         printk (KERN_DEBUG "%s: " format "\n",  \
  42                                 MY_NAME , ## arg);              \
  43         } while (0)
  44 #define err(format, arg...) printk(KERN_ERR "%s: " format "\n", MY_NAME , ## arg)
  45 #define info(format, arg...) printk(KERN_INFO "%s: " format "\n", MY_NAME , ## arg)
  46 #define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n", MY_NAME , ## arg)
  47
  48
  49 u8 cpci_get_attention_status(struct slot* slot)
  50 {
  51         int hs_cap;
  52         u16 hs_csr;
  53
  54         hs_cap = pci_bus_find_capability(slot->bus,
  55                                          slot->devfn,
  56                                          PCI_CAP_ID_CHSWP);
  57         if (!hs_cap)
  58                 return 0;
  59
  60         if (pci_bus_read_config_word(slot->bus,
  61                                      slot->devfn,
  62                                      hs_cap + 2,
  63                                      &hs_csr))
  64                 return 0;
  65
  66         return hs_csr & 0x0008 ? 1 : 0;
  67 }
  68
  69 int cpci_set_attention_status(struct slot* slot, int status)
  70 {
  71         int hs_cap;
  72         u16 hs_csr;
  73
  74         hs_cap = pci_bus_find_capability(slot->bus,
  75                                          slot->devfn,
  76                                          PCI_CAP_ID_CHSWP);
  77         if (!hs_cap)
  78                 return 0;
  79         if (pci_bus_read_config_word(slot->bus,
  80                                      slot->devfn,
  81                                      hs_cap + 2,
  82                                      &hs_csr))
  83                 return 0;
  84         if (status)
  85                 hs_csr |= HS_CSR_LOO;
  86         else
  87                 hs_csr &= ~HS_CSR_LOO;
  88         if (pci_bus_write_config_word(slot->bus,
  89                                       slot->devfn,
  90                                       hs_cap + 2,
  91                                       hs_csr))
  92                 return 0;
  93         return 1;
  94 }
  95
  96 u16 cpci_get_hs_csr(struct slot* slot)
  97 {
  98         int hs_cap;
  99         u16 hs_csr;
 100
 101         hs_cap = pci_bus_find_capability(slot->bus,
 102                                          slot->devfn,
 103                                          PCI_CAP_ID_CHSWP);
 104         if (!hs_cap)
 105                 return 0xFFFF;
 106         if (pci_bus_read_config_word(slot->bus,
 107                                      slot->devfn,
 108                                      hs_cap + 2,
 109                                      &hs_csr))
 110                 return 0xFFFF;
 111         return hs_csr;
 112 }
 113
 114 int cpci_check_and_clear_ins(struct slot* slot)
 115 {
 116         int hs_cap;
 117         u16 hs_csr;
 118         int ins = 0;
 119
 120         hs_cap = pci_bus_find_capability(slot->bus,
 121                                          slot->devfn,
 122                                          PCI_CAP_ID_CHSWP);
 123         if (!hs_cap)
 124                 return 0;
 125         if (pci_bus_read_config_word(slot->bus,
 126                                      slot->devfn,
 127                                      hs_cap + 2,
 128                                      &hs_csr))
 129                 return 0;
 130         if (hs_csr & HS_CSR_INS) {
 131                 /* Clear INS (by setting it) */
 132                 if (pci_bus_write_config_word(slot->bus,
 133                                               slot->devfn,
 134                                               hs_cap + 2,
 135                                               hs_csr))
 136                         ins = 0;
 137                 else
 138                         ins = 1;
 139         }
 140         return ins;
 141 }
 142
 143 int cpci_check_ext(struct slot* slot)
 144 {
 145         int hs_cap;
 146         u16 hs_csr;
 147         int ext = 0;
 148
 149         hs_cap = pci_bus_find_capability(slot->bus,
 150                                          slot->devfn,
 151                                          PCI_CAP_ID_CHSWP);
 152         if (!hs_cap)
 153                 return 0;
 154         if (pci_bus_read_config_word(slot->bus,
 155                                      slot->devfn,
 156                                      hs_cap + 2,
 157                                      &hs_csr))
 158                 return 0;
 159         if (hs_csr & HS_CSR_EXT)
 160                 ext = 1;
 161         return ext;
 162 }
 163
 164 int cpci_clear_ext(struct slot* slot)
 165 {
 166         int hs_cap;
 167         u16 hs_csr;
 168
 169         hs_cap = pci_bus_find_capability(slot->bus,
 170                                          slot->devfn,
 171                                          PCI_CAP_ID_CHSWP);
 172         if (!hs_cap)
 173                 return -ENODEV;
 174         if (pci_bus_read_config_word(slot->bus,
 175                                      slot->devfn,
 176                                      hs_cap + 2,
 177                                      &hs_csr))
 178                 return -ENODEV;
 179         if (hs_csr & HS_CSR_EXT) {
 180                 /* Clear EXT (by setting it) */
 181                 if (pci_bus_write_config_word(slot->bus,
 182                                               slot->devfn,
 183                                               hs_cap + 2,
 184                                               hs_csr))
 185                         return -ENODEV;
 186         }
 187         return 0;
 188 }
 189
 190 int cpci_led_on(struct slot* slot)
 191 {
 192         int hs_cap;
 193         u16 hs_csr;
 194
 195         hs_cap = pci_bus_find_capability(slot->bus,
 196                                          slot->devfn,
 197                                          PCI_CAP_ID_CHSWP);
 198         if (!hs_cap)
 199                 return -ENODEV;
 200         if (pci_bus_read_config_word(slot->bus,
 201                                      slot->devfn,
 202                                      hs_cap + 2,
 203                                      &hs_csr))
 204                 return -ENODEV;
 205         if ((hs_csr & HS_CSR_LOO) != HS_CSR_LOO) {
 206                 hs_csr |= HS_CSR_LOO;
 207                 if (pci_bus_write_config_word(slot->bus,
 208                                               slot->devfn,
 209                                               hs_cap + 2,
 210                                               hs_csr)) {
 211                         err("Could not set LOO for slot %s",
 212                             slot->hotplug_slot->name);
 213                         return -ENODEV;
 214                 }
 215         }
 216         return 0;
 217 }
 218
 219 int cpci_led_off(struct slot* slot)
 220 {
 221         int hs_cap;
 222         u16 hs_csr;
 223
 224         hs_cap = pci_bus_find_capability(slot->bus,
 225                                          slot->devfn,
 226                                          PCI_CAP_ID_CHSWP);
 227         if (!hs_cap)
 228                 return -ENODEV;
 229         if (pci_bus_read_config_word(slot->bus,
 230                                      slot->devfn,
 231                                      hs_cap + 2,
 232                                      &hs_csr))
 233                 return -ENODEV;
 234         if (hs_csr & HS_CSR_LOO) {
 235                 hs_csr &= ~HS_CSR_LOO;
 236                 if (pci_bus_write_config_word(slot->bus,
 237                                               slot->devfn,
 238                                               hs_cap + 2,
 239                                               hs_csr)) {
 240                         err("Could not clear LOO for slot %s",
 241                             slot->hotplug_slot->name);
 242                         return -ENODEV;
 243                 }
 244         }
 245         return 0;
 246 }
 247
 248
 249 /*
 250  * Device configuration functions
 251  */
 252
 253 <<<<<<< HEAD:drivers/pci/hotplug/cpci_hotplug_pci.c
 254 int cpci_configure_slot(struct slot* slot)
 255 =======
 256 int __ref cpci_configure_slot(struct slot *slot)
 257 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/pci/hotplug/cpci_hotplug_pci.c
 258 {
 259         struct pci_bus *parent;
 260         int fn;
 261
 262         dbg("%s - enter", __FUNCTION__);
 263
 264         if (slot->dev == NULL) {
 265                 dbg("pci_dev null, finding %02x:%02x:%x",
 266                     slot->bus->number, PCI_SLOT(slot->devfn), PCI_FUNC(slot->devfn));
 267                 slot->dev = pci_get_slot(slot->bus, slot->devfn);
 268         }
 269
 270         /* Still NULL? Well then scan for it! */
 271         if (slot->dev == NULL) {
 272                 int n;
 273                 dbg("pci_dev still null");
 274
 275                 /*
 276                  * This will generate pci_dev structures for all functions, but
 277                  * we will only call this case when lookup fails.
 278                  */
 279                 n = pci_scan_slot(slot->bus, slot->devfn);
 280                 dbg("%s: pci_scan_slot returned %d", __FUNCTION__, n);
 281                 slot->dev = pci_get_slot(slot->bus, slot->devfn);
 282                 if (slot->dev == NULL) {
 283                         err("Could not find PCI device for slot %02x", slot->number);
 284                         return -ENODEV;
 285                 }
 286         }
 287         parent = slot->dev->bus;
 288
 289         for (fn = 0; fn < 8; fn++) {
 290                 struct pci_dev *dev;
 291
 292                 dev = pci_get_slot(parent, PCI_DEVFN(PCI_SLOT(slot->devfn), fn));
 293                 if (!dev)
 294                         continue;
 295                 if ((dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) ||
 296                     (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)) {
 297                         /* Find an unused bus number for the new bridge */
 298                         struct pci_bus *child;
 299                         unsigned char busnr, start = parent->secondary;
 300                         unsigned char end = parent->subordinate;
 301
 302                         for (busnr = start; busnr <= end; busnr++) {
 303                                 if (!pci_find_bus(pci_domain_nr(parent),
 304                                                   busnr))
 305                                         break;
 306                         }
 307                         if (busnr >= end) {
 308                                 err("No free bus for hot-added bridge\n");
 309                                 pci_dev_put(dev);
 310                                 continue;
 311                         }
 312                         child = pci_add_new_bus(parent, dev, busnr);
 313                         if (!child) {
 314                                 err("Cannot add new bus for %s\n",
 315                                     pci_name(dev));
 316                                 pci_dev_put(dev);
 317                                 continue;
 318                         }
 319                         child->subordinate = pci_do_scan_bus(child);
 320                         pci_bus_size_bridges(child);
 321                 }
 322                 pci_dev_put(dev);
 323         }
 324
 325         pci_bus_assign_resources(parent);
 326         pci_bus_add_devices(parent);
 327         pci_enable_bridges(parent);
 328
 329         dbg("%s - exit", __FUNCTION__);
 330         return 0;
 331 }
 332
 333 int cpci_unconfigure_slot(struct slot* slot)
 334 {
 335         int i;
 336         struct pci_dev *dev;
 337
 338         dbg("%s - enter", __FUNCTION__);
 339         if (!slot->dev) {
 340                 err("No device for slot %02x\n", slot->number);
 341                 return -ENODEV;
 342         }
 343
 344         for (i = 0; i < 8; i++) {
 345                 dev = pci_get_slot(slot->bus,
 346                                     PCI_DEVFN(PCI_SLOT(slot->devfn), i));
 347                 if (dev) {
 348                         pci_remove_bus_device(dev);
 349                         pci_dev_put(dev);
 350                 }
 351         }
 352         pci_dev_put(slot->dev);
 353         slot->dev = NULL;
 354
 355         dbg("%s - exit", __FUNCTION__);
 356         return 0;
 357 }