drivers/misc/enclosure.c

   1 /*
   2  * Enclosure Services
   3  *
   4  * Copyright (C) 2008 James Bottomley <James.Bottomley@HansenPartnership.com>
   5  *
   6 **-----------------------------------------------------------------------------
   7 **
   8 **  This program is free software; you can redistribute it and/or
   9 **  modify it under the terms of the GNU General Public License
  10 **  version 2 as published by the Free Software Foundation.
  11 **
  12 **  This program is distributed in the hope that it will be useful,
  13 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 **  GNU General Public License for more details.
  16 **
  17 **  You should have received a copy of the GNU General Public License
  18 **  along with this program; if not, write to the Free Software
  19 **  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 **
  21 **-----------------------------------------------------------------------------
  22 */
  23 #include <linux/device.h>
  24 #include <linux/enclosure.h>
  25 #include <linux/err.h>
  26 #include <linux/list.h>
  27 #include <linux/kernel.h>
  28 #include <linux/module.h>
  29 #include <linux/mutex.h>
  30
  31 static LIST_HEAD(container_list);
  32 static DEFINE_MUTEX(container_list_lock);
  33 static struct class enclosure_class;
  34
  35 /**
  36  * enclosure_find - find an enclosure given a device
  37  * @dev:        the device to find for
  38  *
  39  * Looks through the list of registered enclosures to see
  40  * if it can find a match for a device.  Returns NULL if no
  41  * enclosure is found. Obtains a reference to the enclosure class
  42  * device which must be released with device_put().
  43  */
  44 struct enclosure_device *enclosure_find(struct device *dev)
  45 {
  46         struct enclosure_device *edev;
  47
  48         mutex_lock(&container_list_lock);
  49         list_for_each_entry(edev, &container_list, node) {
  50                 if (edev->edev.parent == dev) {
  51                         get_device(&edev->edev);
  52                         mutex_unlock(&container_list_lock);
  53                         return edev;
  54                 }
  55         }
  56         mutex_unlock(&container_list_lock);
  57
  58         return NULL;
  59 }
  60 EXPORT_SYMBOL_GPL(enclosure_find);
  61
  62 /**
  63  * enclosure_for_each_device - calls a function for each enclosure
  64  * @fn:         the function to call
  65  * @data:       the data to pass to each call
  66  *
  67  * Loops over all the enclosures calling the function.
  68  *
  69  * Note, this function uses a mutex which will be held across calls to
  70  * @fn, so it must have non atomic context, and @fn may (although it
  71  * should not) sleep or otherwise cause the mutex to be held for
  72  * indefinite periods
  73  */
  74 int enclosure_for_each_device(int (*fn)(struct enclosure_device *, void *),
  75                               void *data)
  76 {
  77         int error = 0;
  78         struct enclosure_device *edev;
  79
  80         mutex_lock(&container_list_lock);
  81         list_for_each_entry(edev, &container_list, node) {
  82                 error = fn(edev, data);
  83                 if (error)
  84                         break;
  85         }
  86         mutex_unlock(&container_list_lock);
  87
  88         return error;
  89 }
  90 EXPORT_SYMBOL_GPL(enclosure_for_each_device);
  91
  92 /**
  93  * enclosure_register - register device as an enclosure
  94  *
  95  * @dev:        device containing the enclosure
  96  * @components: number of components in the enclosure
  97  *
  98  * This sets up the device for being an enclosure.  Note that @dev does
  99  * not have to be a dedicated enclosure device.  It may be some other type
 100  * of device that additionally responds to enclosure services
 101  */
 102 struct enclosure_device *
 103 enclosure_register(struct device *dev, const char *name, int components,
 104                    struct enclosure_component_callbacks *cb)
 105 {
 106         struct enclosure_device *edev =
 107                 kzalloc(sizeof(struct enclosure_device) +
 108                         sizeof(struct enclosure_component)*components,
 109                         GFP_KERNEL);
 110         int err, i;
 111
 112         BUG_ON(!cb);
 113
 114         if (!edev)
 115                 return ERR_PTR(-ENOMEM);
 116
 117         edev->components = components;
 118
 119         edev->edev.class = &enclosure_class;
 120         edev->edev.parent = get_device(dev);
 121         edev->cb = cb;
 122         dev_set_name(&edev->edev, "%s", name);
 123         err = device_register(&edev->edev);
 124         if (err)
 125                 goto err;
 126
 127         for (i = 0; i < components; i++)
 128                 edev->component[i].number = -1;
 129
 130         mutex_lock(&container_list_lock);
 131         list_add_tail(&edev->node, &container_list);
 132         mutex_unlock(&container_list_lock);
 133
 134         return edev;
 135
 136  err:
 137         put_device(edev->edev.parent);
 138         kfree(edev);
 139         return ERR_PTR(err);
 140 }
 141 EXPORT_SYMBOL_GPL(enclosure_register);
 142
 143 static struct enclosure_component_callbacks enclosure_null_callbacks;
 144
 145 /**
 146  * enclosure_unregister - remove an enclosure
 147  *
 148  * @edev:       the registered enclosure to remove;
 149  */
 150 void enclosure_unregister(struct enclosure_device *edev)
 151 {
 152         int i;
 153
 154         mutex_lock(&container_list_lock);
 155         list_del(&edev->node);
 156         mutex_unlock(&container_list_lock);
 157
 158         for (i = 0; i < edev->components; i++)
 159                 if (edev->component[i].number != -1)
 160                         device_unregister(&edev->component[i].cdev);
 161
 162         /* prevent any callbacks into service user */
 163         edev->cb = &enclosure_null_callbacks;
 164         device_unregister(&edev->edev);
 165 }
 166 EXPORT_SYMBOL_GPL(enclosure_unregister);
 167
 168 #define ENCLOSURE_NAME_SIZE     64
 169
 170 static void enclosure_link_name(struct enclosure_component *cdev, char *name)
 171 {
 172         strcpy(name, "enclosure_device:");
 173         strcat(name, dev_name(&cdev->cdev));
 174 }
 175
 176 static void enclosure_remove_links(struct enclosure_component *cdev)
 177 {
 178         char name[ENCLOSURE_NAME_SIZE];
 179
 180         enclosure_link_name(cdev, name);
 181         sysfs_remove_link(&cdev->dev->kobj, name);
 182         sysfs_remove_link(&cdev->cdev.kobj, "device");
 183 }
 184
 185 static int enclosure_add_links(struct enclosure_component *cdev)
 186 {
 187         int error;
 188         char name[ENCLOSURE_NAME_SIZE];
 189
 190         error = sysfs_create_link(&cdev->cdev.kobj, &cdev->dev->kobj, "device");
 191         if (error)
 192                 return error;
 193
 194         enclosure_link_name(cdev, name);
 195         error = sysfs_create_link(&cdev->dev->kobj, &cdev->cdev.kobj, name);
 196         if (error)
 197                 sysfs_remove_link(&cdev->cdev.kobj, "device");
 198
 199         return error;
 200 }
 201
 202 static void enclosure_release(struct device *cdev)
 203 {
 204         struct enclosure_device *edev = to_enclosure_device(cdev);
 205
 206         put_device(cdev->parent);
 207         kfree(edev);
 208 }
 209
 210 static void enclosure_component_release(struct device *dev)
 211 {
 212         struct enclosure_component *cdev = to_enclosure_component(dev);
 213
 214         if (cdev->dev) {
 215                 enclosure_remove_links(cdev);
 216                 put_device(cdev->dev);
 217         }
 218         put_device(dev->parent);
 219 }
 220
 221 static struct attribute_group *enclosure_groups[];
 222
 223 /**
 224  * enclosure_component_register - add a particular component to an enclosure
 225  * @edev:       the enclosure to add the component
 226  * @num:        the device number
 227  * @type:       the type of component being added
 228  * @name:       an optional name to appear in sysfs (leave NULL if none)
 229  *
 230  * Registers the component.  The name is optional for enclosures that
 231  * give their components a unique name.  If not, leave the field NULL
 232  * and a name will be assigned.
 233  *
 234  * Returns a pointer to the enclosure component or an error.
 235  */
 236 struct enclosure_component *
 237 enclosure_component_register(struct enclosure_device *edev,
 238                              unsigned int number,
 239                              enum enclosure_component_type type,
 240                              const char *name)
 241 {
 242         struct enclosure_component *ecomp;
 243         struct device *cdev;
 244         int err;
 245
 246         if (number >= edev->components)
 247                 return ERR_PTR(-EINVAL);
 248
 249         ecomp = &edev->component[number];
 250
 251         if (ecomp->number != -1)
 252                 return ERR_PTR(-EINVAL);
 253
 254         ecomp->type = type;
 255         ecomp->number = number;
 256         cdev = &ecomp->cdev;
 257         cdev->parent = get_device(&edev->edev);
 258         if (name && name[0])
 259                 dev_set_name(cdev, "%s", name);
 260         else
 261                 dev_set_name(cdev, "%u", number);
 262
 263         cdev->release = enclosure_component_release;
 264         cdev->groups = enclosure_groups;
 265
 266         err = device_register(cdev);
 267         if (err)
 268                 ERR_PTR(err);
 269
 270         return ecomp;
 271 }
 272 EXPORT_SYMBOL_GPL(enclosure_component_register);
 273
 274 /**
 275  * enclosure_add_device - add a device as being part of an enclosure
 276  * @edev:       the enclosure device being added to.
 277  * @num:        the number of the component
 278  * @dev:        the device being added
 279  *
 280  * Declares a real device to reside in slot (or identifier) @num of an
 281  * enclosure.  This will cause the relevant sysfs links to appear.
 282  * This function may also be used to change a device associated with
 283  * an enclosure without having to call enclosure_remove_device() in
 284  * between.
 285  *
 286  * Returns zero on success or an error.
 287  */
 288 int enclosure_add_device(struct enclosure_device *edev, int component,
 289                          struct device *dev)
 290 {
 291         struct enclosure_component *cdev;
 292
 293         if (!edev || component >= edev->components)
 294                 return -EINVAL;
 295
 296         cdev = &edev->component[component];
 297
 298         if (cdev->dev)
 299                 enclosure_remove_links(cdev);
 300
 301         put_device(cdev->dev);
 302         cdev->dev = get_device(dev);
 303         return enclosure_add_links(cdev);
 304 }
 305 EXPORT_SYMBOL_GPL(enclosure_add_device);
 306
 307 /**
 308  * enclosure_remove_device - remove a device from an enclosure
 309  * @edev:       the enclosure device
 310  * @num:        the number of the component to remove
 311  *
 312  * Returns zero on success or an error.
 313  *
 314  */
 315 int enclosure_remove_device(struct enclosure_device *edev, int component)
 316 {
 317         struct enclosure_component *cdev;
 318
 319         if (!edev || component >= edev->components)
 320                 return -EINVAL;
 321
 322         cdev = &edev->component[component];
 323
 324         device_del(&cdev->cdev);
 325         put_device(cdev->dev);
 326         cdev->dev = NULL;
 327         return device_add(&cdev->cdev);
 328 }
 329 EXPORT_SYMBOL_GPL(enclosure_remove_device);
 330
 331 /*
 332  * sysfs pieces below
 333  */
 334
 335 static ssize_t enclosure_show_components(struct device *cdev,
 336                                          struct device_attribute *attr,
 337                                          char *buf)
 338 {
 339         struct enclosure_device *edev = to_enclosure_device(cdev);
 340
 341         return snprintf(buf, 40, "%d\n", edev->components);
 342 }
 343
 344 static struct device_attribute enclosure_attrs[] = {
 345         __ATTR(components, S_IRUGO, enclosure_show_components, NULL),
 346         __ATTR_NULL
 347 };
 348
 349 static struct class enclosure_class = {
 350         .name                   = "enclosure",
 351         .owner                  = THIS_MODULE,
 352         .dev_release            = enclosure_release,
 353         .dev_attrs              = enclosure_attrs,
 354 };
 355
 356 static const char *const enclosure_status [] = {
 357         [ENCLOSURE_STATUS_UNSUPPORTED] = "unsupported",
 358         [ENCLOSURE_STATUS_OK] = "OK",
 359         [ENCLOSURE_STATUS_CRITICAL] = "critical",
 360         [ENCLOSURE_STATUS_NON_CRITICAL] = "non-critical",
 361         [ENCLOSURE_STATUS_UNRECOVERABLE] = "unrecoverable",
 362         [ENCLOSURE_STATUS_NOT_INSTALLED] = "not installed",
 363         [ENCLOSURE_STATUS_UNKNOWN] = "unknown",
 364         [ENCLOSURE_STATUS_UNAVAILABLE] = "unavailable",
 365 };
 366
 367 static const char *const enclosure_type [] = {
 368         [ENCLOSURE_COMPONENT_DEVICE] = "device",
 369         [ENCLOSURE_COMPONENT_ARRAY_DEVICE] = "array device",
 370 };
 371
 372 static ssize_t get_component_fault(struct device *cdev,
 373                                    struct device_attribute *attr, char *buf)
 374 {
 375         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
 376         struct enclosure_component *ecomp = to_enclosure_component(cdev);
 377
 378         if (edev->cb->get_fault)
 379                 edev->cb->get_fault(edev, ecomp);
 380         return snprintf(buf, 40, "%d\n", ecomp->fault);
 381 }
 382
 383 static ssize_t set_component_fault(struct device *cdev,
 384                                    struct device_attribute *attr,
 385                                    const char *buf, size_t count)
 386 {
 387         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
 388         struct enclosure_component *ecomp = to_enclosure_component(cdev);
 389         int val = simple_strtoul(buf, NULL, 0);
 390
 391         if (edev->cb->set_fault)
 392                 edev->cb->set_fault(edev, ecomp, val);
 393         return count;
 394 }
 395
 396 static ssize_t get_component_status(struct device *cdev,
 397                                     struct device_attribute *attr,char *buf)
 398 {
 399         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
 400         struct enclosure_component *ecomp = to_enclosure_component(cdev);
 401
 402         if (edev->cb->get_status)
 403                 edev->cb->get_status(edev, ecomp);
 404         return snprintf(buf, 40, "%s\n", enclosure_status[ecomp->status]);
 405 }
 406
 407 static ssize_t set_component_status(struct device *cdev,
 408                                     struct device_attribute *attr,
 409                                     const char *buf, size_t count)
 410 {
 411         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
 412         struct enclosure_component *ecomp = to_enclosure_component(cdev);
 413         int i;
 414
 415         for (i = 0; enclosure_status[i]; i++) {
 416                 if (strncmp(buf, enclosure_status[i],
 417                             strlen(enclosure_status[i])) == 0 &&
 418                     (buf[strlen(enclosure_status[i])] == '\n' ||
 419                      buf[strlen(enclosure_status[i])] == '\0'))
 420                         break;
 421         }
 422
 423         if (enclosure_status[i] && edev->cb->set_status) {
 424                 edev->cb->set_status(edev, ecomp, i);
 425                 return count;
 426         } else
 427                 return -EINVAL;
 428 }
 429
 430 static ssize_t get_component_active(struct device *cdev,
 431                                     struct device_attribute *attr, char *buf)
 432 {
 433         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
 434         struct enclosure_component *ecomp = to_enclosure_component(cdev);
 435
 436         if (edev->cb->get_active)
 437                 edev->cb->get_active(edev, ecomp);
 438         return snprintf(buf, 40, "%d\n", ecomp->active);
 439 }
 440
 441 static ssize_t set_component_active(struct device *cdev,
 442                                     struct device_attribute *attr,
 443                                     const char *buf, size_t count)
 444 {
 445         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
 446         struct enclosure_component *ecomp = to_enclosure_component(cdev);
 447         int val = simple_strtoul(buf, NULL, 0);
 448
 449         if (edev->cb->set_active)
 450                 edev->cb->set_active(edev, ecomp, val);
 451         return count;
 452 }
 453
 454 static ssize_t get_component_locate(struct device *cdev,
 455                                     struct device_attribute *attr, char *buf)
 456 {
 457         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
 458         struct enclosure_component *ecomp = to_enclosure_component(cdev);
 459
 460         if (edev->cb->get_locate)
 461                 edev->cb->get_locate(edev, ecomp);
 462         return snprintf(buf, 40, "%d\n", ecomp->locate);
 463 }
 464
 465 static ssize_t set_component_locate(struct device *cdev,
 466                                     struct device_attribute *attr,
 467                                     const char *buf, size_t count)
 468 {
 469         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
 470         struct enclosure_component *ecomp = to_enclosure_component(cdev);
 471         int val = simple_strtoul(buf, NULL, 0);
 472
 473         if (edev->cb->set_locate)
 474                 edev->cb->set_locate(edev, ecomp, val);
 475         return count;
 476 }
 477
 478 static ssize_t get_component_type(struct device *cdev,
 479                                   struct device_attribute *attr, char *buf)
 480 {
 481         struct enclosure_component *ecomp = to_enclosure_component(cdev);
 482
 483         return snprintf(buf, 40, "%s\n", enclosure_type[ecomp->type]);
 484 }
 485
 486
 487 static DEVICE_ATTR(fault, S_IRUGO | S_IWUSR, get_component_fault,
 488                     set_component_fault);
 489 static DEVICE_ATTR(status, S_IRUGO | S_IWUSR, get_component_status,
 490                    set_component_status);
 491 static DEVICE_ATTR(active, S_IRUGO | S_IWUSR, get_component_active,
 492                    set_component_active);
 493 static DEVICE_ATTR(locate, S_IRUGO | S_IWUSR, get_component_locate,
 494                    set_component_locate);
 495 static DEVICE_ATTR(type, S_IRUGO, get_component_type, NULL);
 496
 497 static struct attribute *enclosure_component_attrs[] = {
 498         &dev_attr_fault.attr,
 499         &dev_attr_status.attr,
 500         &dev_attr_active.attr,
 501         &dev_attr_locate.attr,
 502         &dev_attr_type.attr,
 503         NULL
 504 };
 505
 506 static struct attribute_group enclosure_group = {
 507         .attrs = enclosure_component_attrs,
 508 };
 509
 510 static struct attribute_group *enclosure_groups[] = {
 511         &enclosure_group,
 512         NULL
 513 };
 514
 515 static int __init enclosure_init(void)
 516 {
 517         int err;
 518
 519         err = class_register(&enclosure_class);
 520         if (err)
 521                 return err;
 522
 523         return 0;
 524 }
 525
 526 static void __exit enclosure_exit(void)
 527 {
 528         class_unregister(&enclosure_class);
 529 }
 530
 531 module_init(enclosure_init);
 532 module_exit(enclosure_exit);
 533
 534 MODULE_AUTHOR("James Bottomley");
 535 MODULE_DESCRIPTION("Enclosure Services");
 536 MODULE_LICENSE("GPL v2");