drivers/pci/hotplug/pci_hotplug_core.c

   1 /*
   2  * PCI HotPlug Controller Core
   3  *
   4  * Copyright (C) 2001-2002 Greg Kroah-Hartman (greg@kroah.com)
   5  * Copyright (C) 2001-2002 IBM Corp.
   6  *
   7  * All rights reserved.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or (at
  12  * your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  17  * NON INFRINGEMENT.  See the GNU General Public License for more
  18  * details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  *
  24  * Send feedback to <kristen.c.accardi@intel.com>
  25  *
  26  */
  27
  28 #include <linux/module.h>       /* try_module_get & module_put */
  29 #include <linux/moduleparam.h>
  30 #include <linux/kernel.h>
  31 #include <linux/types.h>
  32 #include <linux/list.h>
  33 #include <linux/kobject.h>
  34 #include <linux/sysfs.h>
  35 #include <linux/pagemap.h>
  36 #include <linux/init.h>
  37 #include <linux/mount.h>
  38 #include <linux/namei.h>
  39 #include <linux/mutex.h>
  40 #include <linux/pci.h>
  41 #include <linux/pci_hotplug.h>
  42 #include <asm/uaccess.h>
  43 #include "../pci.h"
  44 #include "cpci_hotplug.h"
  45
  46 #define MY_NAME "pci_hotplug"
  47
  48 #define dbg(fmt, arg...) do { if (debug) printk(KERN_DEBUG "%s: %s: " fmt, MY_NAME, __func__, ## arg); } while (0)
  49 #define err(format, arg...) printk(KERN_ERR "%s: " format, MY_NAME, ## arg)
  50 #define info(format, arg...) printk(KERN_INFO "%s: " format, MY_NAME, ## arg)
  51 #define warn(format, arg...) printk(KERN_WARNING "%s: " format, MY_NAME, ## arg)
  52
  53
  54 /* local variables */
  55 static bool debug;
  56
  57 #define DRIVER_VERSION  "0.5"
  58 #define DRIVER_AUTHOR   "Greg Kroah-Hartman <greg@kroah.com>, Scott Murray <scottm@somanetworks.com>"
  59 #define DRIVER_DESC     "PCI Hot Plug PCI Core"
  60
  61
  62 static LIST_HEAD(pci_hotplug_slot_list);
  63 static DEFINE_MUTEX(pci_hp_mutex);
  64
  65 /* Weee, fun with macros... */
  66 #define GET_STATUS(name, type)  \
  67 static int get_##name(struct hotplug_slot *slot, type *value)           \
  68 {                                                                       \
  69         struct hotplug_slot_ops *ops = slot->ops;                       \
  70         int retval = 0;                                                 \
  71         if (!try_module_get(ops->owner))                                \
  72                 return -ENODEV;                                         \
  73         if (ops->get_##name)                                            \
  74                 retval = ops->get_##name(slot, value);                  \
  75         else                                                            \
  76                 *value = slot->info->name;                              \
  77         module_put(ops->owner);                                         \
  78         return retval;                                                  \
  79 }
  80
  81 GET_STATUS(power_status, u8)
  82 GET_STATUS(attention_status, u8)
  83 GET_STATUS(latch_status, u8)
  84 GET_STATUS(adapter_status, u8)
  85
  86 static ssize_t power_read_file(struct pci_slot *pci_slot, char *buf)
  87 {
  88         int retval;
  89         u8 value;
  90
  91         retval = get_power_status(pci_slot->hotplug, &value);
  92         if (retval)
  93                 return retval;
  94
  95         return sprintf(buf, "%d\n", value);
  96 }
  97
  98 static ssize_t power_write_file(struct pci_slot *pci_slot, const char *buf,
  99                                 size_t count)
 100 {
 101         struct hotplug_slot *slot = pci_slot->hotplug;
 102         unsigned long lpower;
 103         u8 power;
 104         int retval = 0;
 105
 106         lpower = simple_strtoul(buf, NULL, 10);
 107         power = (u8)(lpower & 0xff);
 108         dbg("power = %d\n", power);
 109
 110         if (!try_module_get(slot->ops->owner)) {
 111                 retval = -ENODEV;
 112                 goto exit;
 113         }
 114         switch (power) {
 115         case 0:
 116                 if (slot->ops->disable_slot)
 117                         retval = slot->ops->disable_slot(slot);
 118                 break;
 119
 120         case 1:
 121                 if (slot->ops->enable_slot)
 122                         retval = slot->ops->enable_slot(slot);
 123                 break;
 124
 125         default:
 126                 err("Illegal value specified for power\n");
 127                 retval = -EINVAL;
 128         }
 129         module_put(slot->ops->owner);
 130
 131 exit:
 132         if (retval)
 133                 return retval;
 134         return count;
 135 }
 136
 137 static struct pci_slot_attribute hotplug_slot_attr_power = {
 138         .attr = {.name = "power", .mode = S_IFREG | S_IRUGO | S_IWUSR},
 139         .show = power_read_file,
 140         .store = power_write_file
 141 };
 142
 143 static ssize_t attention_read_file(struct pci_slot *pci_slot, char *buf)
 144 {
 145         int retval;
 146         u8 value;
 147
 148         retval = get_attention_status(pci_slot->hotplug, &value);
 149         if (retval)
 150                 return retval;
 151
 152         return sprintf(buf, "%d\n", value);
 153 }
 154
 155 static ssize_t attention_write_file(struct pci_slot *pci_slot, const char *buf,
 156                                     size_t count)
 157 {
 158         struct hotplug_slot_ops *ops = pci_slot->hotplug->ops;
 159         unsigned long lattention;
 160         u8 attention;
 161         int retval = 0;
 162
 163         lattention = simple_strtoul(buf, NULL, 10);
 164         attention = (u8)(lattention & 0xff);
 165         dbg(" - attention = %d\n", attention);
 166
 167         if (!try_module_get(ops->owner)) {
 168                 retval = -ENODEV;
 169                 goto exit;
 170         }
 171         if (ops->set_attention_status)
 172                 retval = ops->set_attention_status(pci_slot->hotplug, attention);
 173         module_put(ops->owner);
 174
 175 exit:
 176         if (retval)
 177                 return retval;
 178         return count;
 179 }
 180
 181 static struct pci_slot_attribute hotplug_slot_attr_attention = {
 182         .attr = {.name = "attention", .mode = S_IFREG | S_IRUGO | S_IWUSR},
 183         .show = attention_read_file,
 184         .store = attention_write_file
 185 };
 186
 187 static ssize_t latch_read_file(struct pci_slot *pci_slot, char *buf)
 188 {
 189         int retval;
 190         u8 value;
 191
 192         retval = get_latch_status(pci_slot->hotplug, &value);
 193         if (retval)
 194                 return retval;
 195
 196         return sprintf(buf, "%d\n", value);
 197 }
 198
 199 static struct pci_slot_attribute hotplug_slot_attr_latch = {
 200         .attr = {.name = "latch", .mode = S_IFREG | S_IRUGO},
 201         .show = latch_read_file,
 202 };
 203
 204 static ssize_t presence_read_file(struct pci_slot *pci_slot, char *buf)
 205 {
 206         int retval;
 207         u8 value;
 208
 209         retval = get_adapter_status(pci_slot->hotplug, &value);
 210         if (retval)
 211                 return retval;
 212
 213         return sprintf(buf, "%d\n", value);
 214 }
 215
 216 static struct pci_slot_attribute hotplug_slot_attr_presence = {
 217         .attr = {.name = "adapter", .mode = S_IFREG | S_IRUGO},
 218         .show = presence_read_file,
 219 };
 220
 221 static ssize_t test_write_file(struct pci_slot *pci_slot, const char *buf,
 222                                size_t count)
 223 {
 224         struct hotplug_slot *slot = pci_slot->hotplug;
 225         unsigned long ltest;
 226         u32 test;
 227         int retval = 0;
 228
 229         ltest = simple_strtoul(buf, NULL, 10);
 230         test = (u32)(ltest & 0xffffffff);
 231         dbg("test = %d\n", test);
 232
 233         if (!try_module_get(slot->ops->owner)) {
 234                 retval = -ENODEV;
 235                 goto exit;
 236         }
 237         if (slot->ops->hardware_test)
 238                 retval = slot->ops->hardware_test(slot, test);
 239         module_put(slot->ops->owner);
 240
 241 exit:
 242         if (retval)
 243                 return retval;
 244         return count;
 245 }
 246
 247 static struct pci_slot_attribute hotplug_slot_attr_test = {
 248         .attr = {.name = "test", .mode = S_IFREG | S_IRUGO | S_IWUSR},
 249         .store = test_write_file
 250 };
 251
 252 static bool has_power_file(struct pci_slot *pci_slot)
 253 {
 254         struct hotplug_slot *slot = pci_slot->hotplug;
 255
 256         if ((!slot) || (!slot->ops))
 257                 return false;
 258         if ((slot->ops->enable_slot) ||
 259             (slot->ops->disable_slot) ||
 260             (slot->ops->get_power_status))
 261                 return true;
 262         return false;
 263 }
 264
 265 static bool has_attention_file(struct pci_slot *pci_slot)
 266 {
 267         struct hotplug_slot *slot = pci_slot->hotplug;
 268
 269         if ((!slot) || (!slot->ops))
 270                 return false;
 271         if ((slot->ops->set_attention_status) ||
 272             (slot->ops->get_attention_status))
 273                 return true;
 274         return false;
 275 }
 276
 277 static bool has_latch_file(struct pci_slot *pci_slot)
 278 {
 279         struct hotplug_slot *slot = pci_slot->hotplug;
 280
 281         if ((!slot) || (!slot->ops))
 282                 return false;
 283         if (slot->ops->get_latch_status)
 284                 return true;
 285         return false;
 286 }
 287
 288 static bool has_adapter_file(struct pci_slot *pci_slot)
 289 {
 290         struct hotplug_slot *slot = pci_slot->hotplug;
 291
 292         if ((!slot) || (!slot->ops))
 293                 return false;
 294         if (slot->ops->get_adapter_status)
 295                 return true;
 296         return false;
 297 }
 298
 299 static bool has_test_file(struct pci_slot *pci_slot)
 300 {
 301         struct hotplug_slot *slot = pci_slot->hotplug;
 302
 303         if ((!slot) || (!slot->ops))
 304                 return false;
 305         if (slot->ops->hardware_test)
 306                 return true;
 307         return false;
 308 }
 309
 310 static int fs_add_slot(struct pci_slot *pci_slot)
 311 {
 312         int retval = 0;
 313
 314         /* Create symbolic link to the hotplug driver module */
 315         pci_hp_create_module_link(pci_slot);
 316
 317         if (has_power_file(pci_slot)) {
 318                 retval = sysfs_create_file(&pci_slot->kobj,
 319                                            &hotplug_slot_attr_power.attr);
 320                 if (retval)
 321                         goto exit_power;
 322         }
 323
 324         if (has_attention_file(pci_slot)) {
 325                 retval = sysfs_create_file(&pci_slot->kobj,
 326                                            &hotplug_slot_attr_attention.attr);
 327                 if (retval)
 328                         goto exit_attention;
 329         }
 330
 331         if (has_latch_file(pci_slot)) {
 332                 retval = sysfs_create_file(&pci_slot->kobj,
 333                                            &hotplug_slot_attr_latch.attr);
 334                 if (retval)
 335                         goto exit_latch;
 336         }
 337
 338         if (has_adapter_file(pci_slot)) {
 339                 retval = sysfs_create_file(&pci_slot->kobj,
 340                                            &hotplug_slot_attr_presence.attr);
 341                 if (retval)
 342                         goto exit_adapter;
 343         }
 344
 345         if (has_test_file(pci_slot)) {
 346                 retval = sysfs_create_file(&pci_slot->kobj,
 347                                            &hotplug_slot_attr_test.attr);
 348                 if (retval)
 349                         goto exit_test;
 350         }
 351
 352         goto exit;
 353
 354 exit_test:
 355         if (has_adapter_file(pci_slot))
 356                 sysfs_remove_file(&pci_slot->kobj,
 357                                   &hotplug_slot_attr_presence.attr);
 358 exit_adapter:
 359         if (has_latch_file(pci_slot))
 360                 sysfs_remove_file(&pci_slot->kobj, &hotplug_slot_attr_latch.attr);
 361 exit_latch:
 362         if (has_attention_file(pci_slot))
 363                 sysfs_remove_file(&pci_slot->kobj,
 364                                   &hotplug_slot_attr_attention.attr);
 365 exit_attention:
 366         if (has_power_file(pci_slot))
 367                 sysfs_remove_file(&pci_slot->kobj, &hotplug_slot_attr_power.attr);
 368 exit_power:
 369         pci_hp_remove_module_link(pci_slot);
 370 exit:
 371         return retval;
 372 }
 373
 374 static void fs_remove_slot(struct pci_slot *pci_slot)
 375 {
 376         if (has_power_file(pci_slot))
 377                 sysfs_remove_file(&pci_slot->kobj, &hotplug_slot_attr_power.attr);
 378
 379         if (has_attention_file(pci_slot))
 380                 sysfs_remove_file(&pci_slot->kobj,
 381                                   &hotplug_slot_attr_attention.attr);
 382
 383         if (has_latch_file(pci_slot))
 384                 sysfs_remove_file(&pci_slot->kobj, &hotplug_slot_attr_latch.attr);
 385
 386         if (has_adapter_file(pci_slot))
 387                 sysfs_remove_file(&pci_slot->kobj,
 388                                   &hotplug_slot_attr_presence.attr);
 389
 390         if (has_test_file(pci_slot))
 391                 sysfs_remove_file(&pci_slot->kobj, &hotplug_slot_attr_test.attr);
 392
 393         pci_hp_remove_module_link(pci_slot);
 394 }
 395
 396 static struct hotplug_slot *get_slot_from_name(const char *name)
 397 {
 398         struct hotplug_slot *slot;
 399
 400         list_for_each_entry(slot, &pci_hotplug_slot_list, slot_list) {
 401                 if (strcmp(hotplug_slot_name(slot), name) == 0)
 402                         return slot;
 403         }
 404         return NULL;
 405 }
 406
 407 /**
 408  * __pci_hp_register - register a hotplug_slot with the PCI hotplug subsystem
 409  * @bus: bus this slot is on
 410  * @slot: pointer to the &struct hotplug_slot to register
 411  * @devnr: device number
 412  * @name: name registered with kobject core
 413  * @owner: caller module owner
 414  * @mod_name: caller module name
 415  *
 416  * Registers a hotplug slot with the pci hotplug subsystem, which will allow
 417  * userspace interaction to the slot.
 418  *
 419  * Returns 0 if successful, anything else for an error.
 420  */
 421 int __pci_hp_register(struct hotplug_slot *slot, struct pci_bus *bus,
 422                       int devnr, const char *name,
 423                       struct module *owner, const char *mod_name)
 424 {
 425         int result;
 426         struct pci_slot *pci_slot;
 427
 428         if (slot == NULL)
 429                 return -ENODEV;
 430         if ((slot->info == NULL) || (slot->ops == NULL))
 431                 return -EINVAL;
 432         if (slot->release == NULL) {
 433                 dbg("Why are you trying to register a hotplug slot without a proper release function?\n");
 434                 return -EINVAL;
 435         }
 436
 437         slot->ops->owner = owner;
 438         slot->ops->mod_name = mod_name;
 439
 440         mutex_lock(&pci_hp_mutex);
 441         /*
 442          * No problems if we call this interface from both ACPI_PCI_SLOT
 443          * driver and call it here again. If we've already created the
 444          * pci_slot, the interface will simply bump the refcount.
 445          */
 446         pci_slot = pci_create_slot(bus, devnr, name, slot);
 447         if (IS_ERR(pci_slot)) {
 448                 result = PTR_ERR(pci_slot);
 449                 goto out;
 450         }
 451
 452         slot->pci_slot = pci_slot;
 453         pci_slot->hotplug = slot;
 454
 455         list_add(&slot->slot_list, &pci_hotplug_slot_list);
 456
 457         result = fs_add_slot(pci_slot);
 458         kobject_uevent(&pci_slot->kobj, KOBJ_ADD);
 459         dbg("Added slot %s to the list\n", name);
 460 out:
 461         mutex_unlock(&pci_hp_mutex);
 462         return result;
 463 }
 464 EXPORT_SYMBOL_GPL(__pci_hp_register);
 465
 466 /**
 467  * pci_hp_deregister - deregister a hotplug_slot with the PCI hotplug subsystem
 468  * @slot: pointer to the &struct hotplug_slot to deregister
 469  *
 470  * The @slot must have been registered with the pci hotplug subsystem
 471  * previously with a call to pci_hp_register().
 472  *
 473  * Returns 0 if successful, anything else for an error.
 474  */
 475 int pci_hp_deregister(struct hotplug_slot *slot)
 476 {
 477         struct hotplug_slot *temp;
 478         struct pci_slot *pci_slot;
 479
 480         if (!slot)
 481                 return -ENODEV;
 482
 483         mutex_lock(&pci_hp_mutex);
 484         temp = get_slot_from_name(hotplug_slot_name(slot));
 485         if (temp != slot) {
 486                 mutex_unlock(&pci_hp_mutex);
 487                 return -ENODEV;
 488         }
 489
 490         list_del(&slot->slot_list);
 491
 492         pci_slot = slot->pci_slot;
 493         fs_remove_slot(pci_slot);
 494         dbg("Removed slot %s from the list\n", hotplug_slot_name(slot));
 495
 496         slot->release(slot);
 497         pci_slot->hotplug = NULL;
 498         pci_destroy_slot(pci_slot);
 499         mutex_unlock(&pci_hp_mutex);
 500
 501         return 0;
 502 }
 503 EXPORT_SYMBOL_GPL(pci_hp_deregister);
 504
 505 /**
 506  * pci_hp_change_slot_info - changes the slot's information structure in the core
 507  * @slot: pointer to the slot whose info has changed
 508  * @info: pointer to the info copy into the slot's info structure
 509  *
 510  * @slot must have been registered with the pci
 511  * hotplug subsystem previously with a call to pci_hp_register().
 512  *
 513  * Returns 0 if successful, anything else for an error.
 514  */
 515 int pci_hp_change_slot_info(struct hotplug_slot *slot,
 516                             struct hotplug_slot_info *info)
 517 {
 518         if (!slot || !info)
 519                 return -ENODEV;
 520
 521         memcpy(slot->info, info, sizeof(struct hotplug_slot_info));
 522
 523         return 0;
 524 }
 525 EXPORT_SYMBOL_GPL(pci_hp_change_slot_info);
 526
 527 static int __init pci_hotplug_init(void)
 528 {
 529         int result;
 530
 531         result = cpci_hotplug_init(debug);
 532         if (result) {
 533                 err("cpci_hotplug_init with error %d\n", result);
 534                 return result;
 535         }
 536
 537         info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
 538         return result;
 539 }
 540 device_initcall(pci_hotplug_init);
 541
 542 /*
 543  * not really modular, but the easiest way to keep compat with existing
 544  * bootargs behaviour is to continue using module_param here.
 545  */
 546 module_param(debug, bool, 0644);
 547 MODULE_PARM_DESC(debug, "Debugging mode enabled or not");