drivers/pci/slot.c

   1 /*
   2  * drivers/pci/slot.c
   3  * Copyright (C) 2006 Matthew Wilcox <matthew@wil.cx>
   4  * Copyright (C) 2006-2009 Hewlett-Packard Development Company, L.P.
   5  *      Alex Chiang <achiang@hp.com>
   6  */
   7
   8 #include <linux/kobject.h>
   9 #include <linux/slab.h>
  10 #include <linux/pci.h>
  11 #include <linux/err.h>
  12 #include "pci.h"
  13
  14 struct kset *pci_slots_kset;
  15 EXPORT_SYMBOL_GPL(pci_slots_kset);
  16
  17 static ssize_t pci_slot_attr_show(struct kobject *kobj,
  18                                         struct attribute *attr, char *buf)
  19 {
  20         struct pci_slot *slot = to_pci_slot(kobj);
  21         struct pci_slot_attribute *attribute = to_pci_slot_attr(attr);
  22         return attribute->show ? attribute->show(slot, buf) : -EIO;
  23 }
  24
  25 static ssize_t pci_slot_attr_store(struct kobject *kobj,
  26                         struct attribute *attr, const char *buf, size_t len)
  27 {
  28         struct pci_slot *slot = to_pci_slot(kobj);
  29         struct pci_slot_attribute *attribute = to_pci_slot_attr(attr);
  30         return attribute->store ? attribute->store(slot, buf, len) : -EIO;
  31 }
  32
  33 static const struct sysfs_ops pci_slot_sysfs_ops = {
  34         .show = pci_slot_attr_show,
  35         .store = pci_slot_attr_store,
  36 };
  37
  38 static ssize_t address_read_file(struct pci_slot *slot, char *buf)
  39 {
  40         if (slot->number == 0xff)
  41                 return sprintf(buf, "%04x:%02x\n",
  42                                 pci_domain_nr(slot->bus),
  43                                 slot->bus->number);
  44         else
  45                 return sprintf(buf, "%04x:%02x:%02x\n",
  46                                 pci_domain_nr(slot->bus),
  47                                 slot->bus->number,
  48                                 slot->number);
  49 }
  50
  51 /* these strings match up with the values in pci_bus_speed */
  52 static char *pci_bus_speed_strings[] = {
  53         "33 MHz PCI",           /* 0x00 */
  54         "66 MHz PCI",           /* 0x01 */
  55         "66 MHz PCI-X",         /* 0x02 */
  56         "100 MHz PCI-X",        /* 0x03 */
  57         "133 MHz PCI-X",        /* 0x04 */
  58         NULL,                   /* 0x05 */
  59         NULL,                   /* 0x06 */
  60         NULL,                   /* 0x07 */
  61         NULL,                   /* 0x08 */
  62         "66 MHz PCI-X 266",     /* 0x09 */
  63         "100 MHz PCI-X 266",    /* 0x0a */
  64         "133 MHz PCI-X 266",    /* 0x0b */
  65         "Unknown AGP",          /* 0x0c */
  66         "1x AGP",               /* 0x0d */
  67         "2x AGP",               /* 0x0e */
  68         "4x AGP",               /* 0x0f */
  69         "8x AGP",               /* 0x10 */
  70         "66 MHz PCI-X 533",     /* 0x11 */
  71         "100 MHz PCI-X 533",    /* 0x12 */
  72         "133 MHz PCI-X 533",    /* 0x13 */
  73         "2.5 GT/s PCIe",        /* 0x14 */
  74         "5.0 GT/s PCIe",        /* 0x15 */
  75         "8.0 GT/s PCIe",        /* 0x16 */
  76 };
  77
  78 static ssize_t bus_speed_read(enum pci_bus_speed speed, char *buf)
  79 {
  80         const char *speed_string;
  81
  82         if (speed < ARRAY_SIZE(pci_bus_speed_strings))
  83                 speed_string = pci_bus_speed_strings[speed];
  84         else
  85                 speed_string = "Unknown";
  86
  87         return sprintf(buf, "%s\n", speed_string);
  88 }
  89
  90 static ssize_t max_speed_read_file(struct pci_slot *slot, char *buf)
  91 {
  92         return bus_speed_read(slot->bus->max_bus_speed, buf);
  93 }
  94
  95 static ssize_t cur_speed_read_file(struct pci_slot *slot, char *buf)
  96 {
  97         return bus_speed_read(slot->bus->cur_bus_speed, buf);
  98 }
  99
 100 static void remove_sysfs_files(struct pci_slot *slot)
 101 {
 102         char func[10];
 103         struct list_head *tmp;
 104
 105         list_for_each(tmp, &slot->bus->devices) {
 106                 struct pci_dev *dev = pci_dev_b(tmp);
 107                 if (PCI_SLOT(dev->devfn) != slot->number)
 108                         continue;
 109                 sysfs_remove_link(&dev->dev.kobj, "slot");
 110
 111                 snprintf(func, 10, "function%d", PCI_FUNC(dev->devfn));
 112                 sysfs_remove_link(&slot->kobj, func);
 113         }
 114 }
 115
 116 static int create_sysfs_files(struct pci_slot *slot)
 117 {
 118         int result;
 119         char func[10];
 120         struct list_head *tmp;
 121
 122         list_for_each(tmp, &slot->bus->devices) {
 123                 struct pci_dev *dev = pci_dev_b(tmp);
 124                 if (PCI_SLOT(dev->devfn) != slot->number)
 125                         continue;
 126
 127                 result = sysfs_create_link(&dev->dev.kobj, &slot->kobj, "slot");
 128                 if (result)
 129                         goto fail;
 130
 131                 snprintf(func, 10, "function%d", PCI_FUNC(dev->devfn));
 132                 result = sysfs_create_link(&slot->kobj, &dev->dev.kobj, func);
 133                 if (result)
 134                         goto fail;
 135         }
 136
 137         return 0;
 138
 139 fail:
 140         remove_sysfs_files(slot);
 141         return result;
 142 }
 143
 144 static void pci_slot_release(struct kobject *kobj)
 145 {
 146         struct pci_dev *dev;
 147         struct pci_slot *slot = to_pci_slot(kobj);
 148
 149         dev_dbg(&slot->bus->dev, "dev %02x, released physical slot %s\n",
 150                 slot->number, pci_slot_name(slot));
 151
 152         list_for_each_entry(dev, &slot->bus->devices, bus_list)
 153                 if (PCI_SLOT(dev->devfn) == slot->number)
 154                         dev->slot = NULL;
 155
 156         remove_sysfs_files(slot);
 157
 158         list_del(&slot->list);
 159
 160         kfree(slot);
 161 }
 162
 163 static struct pci_slot_attribute pci_slot_attr_address =
 164         __ATTR(address, (S_IFREG | S_IRUGO), address_read_file, NULL);
 165 static struct pci_slot_attribute pci_slot_attr_max_speed =
 166         __ATTR(max_bus_speed, (S_IFREG | S_IRUGO), max_speed_read_file, NULL);
 167 static struct pci_slot_attribute pci_slot_attr_cur_speed =
 168         __ATTR(cur_bus_speed, (S_IFREG | S_IRUGO), cur_speed_read_file, NULL);
 169
 170 static struct attribute *pci_slot_default_attrs[] = {
 171         &pci_slot_attr_address.attr,
 172         &pci_slot_attr_max_speed.attr,
 173         &pci_slot_attr_cur_speed.attr,
 174         NULL,
 175 };
 176
 177 static struct kobj_type pci_slot_ktype = {
 178         .sysfs_ops = &pci_slot_sysfs_ops,
 179         .release = &pci_slot_release,
 180         .default_attrs = pci_slot_default_attrs,
 181 };
 182
 183 static char *make_slot_name(const char *name)
 184 {
 185         char *new_name;
 186         int len, max, dup;
 187
 188         new_name = kstrdup(name, GFP_KERNEL);
 189         if (!new_name)
 190                 return NULL;
 191
 192         /*
 193          * Make sure we hit the realloc case the first time through the
 194          * loop.  'len' will be strlen(name) + 3 at that point which is
 195          * enough space for "name-X" and the trailing NUL.
 196          */
 197         len = strlen(name) + 2;
 198         max = 1;
 199         dup = 1;
 200
 201         for (;;) {
 202                 struct kobject *dup_slot;
 203                 dup_slot = kset_find_obj(pci_slots_kset, new_name);
 204                 if (!dup_slot)
 205                         break;
 206                 kobject_put(dup_slot);
 207                 if (dup == max) {
 208                         len++;
 209                         max *= 10;
 210                         kfree(new_name);
 211                         new_name = kmalloc(len, GFP_KERNEL);
 212                         if (!new_name)
 213                                 break;
 214                 }
 215                 sprintf(new_name, "%s-%d", name, dup++);
 216         }
 217
 218         return new_name;
 219 }
 220
 221 static int rename_slot(struct pci_slot *slot, const char *name)
 222 {
 223         int result = 0;
 224         char *slot_name;
 225
 226         if (strcmp(pci_slot_name(slot), name) == 0)
 227                 return result;
 228
 229         slot_name = make_slot_name(name);
 230         if (!slot_name)
 231                 return -ENOMEM;
 232
 233         result = kobject_rename(&slot->kobj, slot_name);
 234         kfree(slot_name);
 235
 236         return result;
 237 }
 238
 239 static struct pci_slot *get_slot(struct pci_bus *parent, int slot_nr)
 240 {
 241         struct pci_slot *slot;
 242         /*
 243          * We already hold pci_bus_sem so don't worry
 244          */
 245         list_for_each_entry(slot, &parent->slots, list)
 246                 if (slot->number == slot_nr) {
 247                         kobject_get(&slot->kobj);
 248                         return slot;
 249                 }
 250
 251         return NULL;
 252 }
 253
 254 /**
 255  * pci_create_slot - create or increment refcount for physical PCI slot
 256  * @parent: struct pci_bus of parent bridge
 257  * @slot_nr: PCI_SLOT(pci_dev->devfn) or -1 for placeholder
 258  * @name: user visible string presented in /sys/bus/pci/slots/<name>
 259  * @hotplug: set if caller is hotplug driver, NULL otherwise
 260  *
 261  * PCI slots have first class attributes such as address, speed, width,
 262  * and a &struct pci_slot is used to manage them. This interface will
 263  * either return a new &struct pci_slot to the caller, or if the pci_slot
 264  * already exists, its refcount will be incremented.
 265  *
 266  * Slots are uniquely identified by a @pci_bus, @slot_nr tuple.
 267  *
 268  * There are known platforms with broken firmware that assign the same
 269  * name to multiple slots. Workaround these broken platforms by renaming
 270  * the slots on behalf of the caller. If firmware assigns name N to
 271  * multiple slots:
 272  *
 273  * The first slot is assigned N
 274  * The second slot is assigned N-1
 275  * The third slot is assigned N-2
 276  * etc.
 277  *
 278  * Placeholder slots:
 279  * In most cases, @pci_bus, @slot_nr will be sufficient to uniquely identify
 280  * a slot. There is one notable exception - pSeries (rpaphp), where the
 281  * @slot_nr cannot be determined until a device is actually inserted into
 282  * the slot. In this scenario, the caller may pass -1 for @slot_nr.
 283  *
 284  * The following semantics are imposed when the caller passes @slot_nr ==
 285  * -1. First, we no longer check for an existing %struct pci_slot, as there
 286  * may be many slots with @slot_nr of -1.  The other change in semantics is
 287  * user-visible, which is the 'address' parameter presented in sysfs will
 288  * consist solely of a dddd:bb tuple, where dddd is the PCI domain of the
 289  * %struct pci_bus and bb is the bus number. In other words, the devfn of
 290  * the 'placeholder' slot will not be displayed.
 291  */
 292 struct pci_slot *pci_create_slot(struct pci_bus *parent, int slot_nr,
 293                                  const char *name,
 294                                  struct hotplug_slot *hotplug)
 295 {
 296         struct pci_dev *dev;
 297         struct pci_slot *slot;
 298         int err = 0;
 299         char *slot_name = NULL;
 300
 301         down_write(&pci_bus_sem);
 302
 303         if (slot_nr == -1)
 304                 goto placeholder;
 305
 306         /*
 307          * Hotplug drivers are allowed to rename an existing slot,
 308          * but only if not already claimed.
 309          */
 310         slot = get_slot(parent, slot_nr);
 311         if (slot) {
 312                 if (hotplug) {
 313                         if ((err = slot->hotplug ? -EBUSY : 0)
 314                              || (err = rename_slot(slot, name))) {
 315                                 kobject_put(&slot->kobj);
 316                                 slot = NULL;
 317                                 goto err;
 318                         }
 319                 }
 320                 goto out;
 321         }
 322
 323 placeholder:
 324         slot = kzalloc(sizeof(*slot), GFP_KERNEL);
 325         if (!slot) {
 326                 err = -ENOMEM;
 327                 goto err;
 328         }
 329
 330         slot->bus = parent;
 331         slot->number = slot_nr;
 332
 333         slot->kobj.kset = pci_slots_kset;
 334
 335         slot_name = make_slot_name(name);
 336         if (!slot_name) {
 337                 err = -ENOMEM;
 338                 goto err;
 339         }
 340
 341         err = kobject_init_and_add(&slot->kobj, &pci_slot_ktype, NULL,
 342                                    "%s", slot_name);
 343         if (err)
 344                 goto err;
 345
 346         INIT_LIST_HEAD(&slot->list);
 347         list_add(&slot->list, &parent->slots);
 348
 349         create_sysfs_files(slot);
 350
 351         list_for_each_entry(dev, &parent->devices, bus_list)
 352                 if (PCI_SLOT(dev->devfn) == slot_nr)
 353                         dev->slot = slot;
 354
 355         dev_dbg(&parent->dev, "dev %02x, created physical slot %s\n",
 356                 slot_nr, pci_slot_name(slot));
 357
 358 out:
 359         kfree(slot_name);
 360         up_write(&pci_bus_sem);
 361         return slot;
 362 err:
 363         kfree(slot);
 364         slot = ERR_PTR(err);
 365         goto out;
 366 }
 367 EXPORT_SYMBOL_GPL(pci_create_slot);
 368
 369 /**
 370  * pci_renumber_slot - update %struct pci_slot -> number
 371  * @slot: &struct pci_slot to update
 372  * @slot_nr: new number for slot
 373  *
 374  * The primary purpose of this interface is to allow callers who earlier
 375  * created a placeholder slot in pci_create_slot() by passing a -1 as
 376  * slot_nr, to update their %struct pci_slot with the correct @slot_nr.
 377  */
 378 void pci_renumber_slot(struct pci_slot *slot, int slot_nr)
 379 {
 380         struct pci_slot *tmp;
 381
 382         down_write(&pci_bus_sem);
 383
 384         list_for_each_entry(tmp, &slot->bus->slots, list) {
 385                 WARN_ON(tmp->number == slot_nr);
 386                 goto out;
 387         }
 388
 389         slot->number = slot_nr;
 390 out:
 391         up_write(&pci_bus_sem);
 392 }
 393 EXPORT_SYMBOL_GPL(pci_renumber_slot);
 394
 395 /**
 396  * pci_destroy_slot - decrement refcount for physical PCI slot
 397  * @slot: struct pci_slot to decrement
 398  *
 399  * %struct pci_slot is refcounted, so destroying them is really easy; we
 400  * just call kobject_put on its kobj and let our release methods do the
 401  * rest.
 402  */
 403 void pci_destroy_slot(struct pci_slot *slot)
 404 {
 405         dev_dbg(&slot->bus->dev, "dev %02x, dec refcount to %d\n",
 406                 slot->number, atomic_read(&slot->kobj.kref.refcount) - 1);
 407
 408         down_write(&pci_bus_sem);
 409         kobject_put(&slot->kobj);
 410         up_write(&pci_bus_sem);
 411 }
 412 EXPORT_SYMBOL_GPL(pci_destroy_slot);
 413
 414 #if defined(CONFIG_HOTPLUG_PCI) || defined(CONFIG_HOTPLUG_PCI_MODULE)
 415 #include <linux/pci_hotplug.h>
 416 /**
 417  * pci_hp_create_link - create symbolic link to the hotplug driver module.
 418  * @pci_slot: struct pci_slot
 419  *
 420  * Helper function for pci_hotplug_core.c to create symbolic link to
 421  * the hotplug driver module.
 422  */
 423 void pci_hp_create_module_link(struct pci_slot *pci_slot)
 424 {
 425         struct hotplug_slot *slot = pci_slot->hotplug;
 426         struct kobject *kobj = NULL;
 427         int no_warn;
 428
 429         if (!slot || !slot->ops)
 430                 return;
 431         kobj = kset_find_obj(module_kset, slot->ops->mod_name);
 432         if (!kobj)
 433                 return;
 434         no_warn = sysfs_create_link(&pci_slot->kobj, kobj, "module");
 435         kobject_put(kobj);
 436 }
 437 EXPORT_SYMBOL_GPL(pci_hp_create_module_link);
 438
 439 /**
 440  * pci_hp_remove_link - remove symbolic link to the hotplug driver module.
 441  * @pci_slot: struct pci_slot
 442  *
 443  * Helper function for pci_hotplug_core.c to remove symbolic link to
 444  * the hotplug driver module.
 445  */
 446 void pci_hp_remove_module_link(struct pci_slot *pci_slot)
 447 {
 448         sysfs_remove_link(&pci_slot->kobj, "module");
 449 }
 450 EXPORT_SYMBOL_GPL(pci_hp_remove_module_link);
 451 #endif
 452
 453 static int pci_slot_init(void)
 454 {
 455         struct kset *pci_bus_kset;
 456
 457         pci_bus_kset = bus_get_kset(&pci_bus_type);
 458         pci_slots_kset = kset_create_and_add("slots", NULL,
 459                                                 &pci_bus_kset->kobj);
 460         if (!pci_slots_kset) {
 461                 printk(KERN_ERR "PCI: Slot initialization failure\n");
 462                 return -ENOMEM;
 463         }
 464         return 0;
 465 }
 466
 467 subsys_initcall(pci_slot_init);