4 * Copyright (C) 2008 James Bottomley <James.Bottomley@HansenPartnership.com>
6 **-----------------------------------------------------------------------------
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.
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.
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.
21 **-----------------------------------------------------------------------------
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 #include <linux/slab.h>
32 static LIST_HEAD(container_list
);
33 static DEFINE_MUTEX(container_list_lock
);
34 static struct class enclosure_class
;
37 * enclosure_find - find an enclosure given a parent device
38 * @dev: the parent to match against
39 * @start: Optional enclosure device to start from (NULL if none)
41 * Looks through the list of registered enclosures to find all those
42 * with @dev as a parent. Returns NULL if no enclosure is
43 * found. @start can be used as a starting point to obtain multiple
44 * enclosures per parent (should begin with NULL and then be set to
45 * each returned enclosure device). Obtains a reference to the
46 * enclosure class device which must be released with device_put().
47 * If @start is not NULL, a reference must be taken on it which is
48 * released before returning (this allows a loop through all
49 * enclosures to exit with only the reference on the enclosure of
50 * interest held). Note that the @dev may correspond to the actual
51 * device housing the enclosure, in which case no iteration via @start
54 struct enclosure_device
*enclosure_find(struct device
*dev
,
55 struct enclosure_device
*start
)
57 struct enclosure_device
*edev
;
59 mutex_lock(&container_list_lock
);
60 edev
= list_prepare_entry(start
, &container_list
, node
);
62 put_device(&start
->edev
);
64 list_for_each_entry_continue(edev
, &container_list
, node
) {
65 struct device
*parent
= edev
->edev
.parent
;
66 /* parent might not be immediate, so iterate up to
67 * the root of the tree if necessary */
70 get_device(&edev
->edev
);
71 mutex_unlock(&container_list_lock
);
74 parent
= parent
->parent
;
77 mutex_unlock(&container_list_lock
);
81 EXPORT_SYMBOL_GPL(enclosure_find
);
84 * enclosure_for_each_device - calls a function for each enclosure
85 * @fn: the function to call
86 * @data: the data to pass to each call
88 * Loops over all the enclosures calling the function.
90 * Note, this function uses a mutex which will be held across calls to
91 * @fn, so it must have non atomic context, and @fn may (although it
92 * should not) sleep or otherwise cause the mutex to be held for
95 int enclosure_for_each_device(int (*fn
)(struct enclosure_device
*, void *),
99 struct enclosure_device
*edev
;
101 mutex_lock(&container_list_lock
);
102 list_for_each_entry(edev
, &container_list
, node
) {
103 error
= fn(edev
, data
);
107 mutex_unlock(&container_list_lock
);
111 EXPORT_SYMBOL_GPL(enclosure_for_each_device
);
114 * enclosure_register - register device as an enclosure
116 * @dev: device containing the enclosure
117 * @components: number of components in the enclosure
119 * This sets up the device for being an enclosure. Note that @dev does
120 * not have to be a dedicated enclosure device. It may be some other type
121 * of device that additionally responds to enclosure services
123 struct enclosure_device
*
124 enclosure_register(struct device
*dev
, const char *name
, int components
,
125 struct enclosure_component_callbacks
*cb
)
127 struct enclosure_device
*edev
=
128 kzalloc(sizeof(struct enclosure_device
) +
129 sizeof(struct enclosure_component
)*components
,
136 return ERR_PTR(-ENOMEM
);
138 edev
->components
= components
;
140 edev
->edev
.class = &enclosure_class
;
141 edev
->edev
.parent
= get_device(dev
);
143 dev_set_name(&edev
->edev
, "%s", name
);
144 err
= device_register(&edev
->edev
);
148 for (i
= 0; i
< components
; i
++) {
149 edev
->component
[i
].number
= -1;
150 edev
->component
[i
].slot
= -1;
151 edev
->component
[i
].power_status
= -1;
154 mutex_lock(&container_list_lock
);
155 list_add_tail(&edev
->node
, &container_list
);
156 mutex_unlock(&container_list_lock
);
161 put_device(edev
->edev
.parent
);
165 EXPORT_SYMBOL_GPL(enclosure_register
);
167 static struct enclosure_component_callbacks enclosure_null_callbacks
;
170 * enclosure_unregister - remove an enclosure
172 * @edev: the registered enclosure to remove;
174 void enclosure_unregister(struct enclosure_device
*edev
)
178 mutex_lock(&container_list_lock
);
179 list_del(&edev
->node
);
180 mutex_unlock(&container_list_lock
);
182 for (i
= 0; i
< edev
->components
; i
++)
183 if (edev
->component
[i
].number
!= -1)
184 device_unregister(&edev
->component
[i
].cdev
);
186 /* prevent any callbacks into service user */
187 edev
->cb
= &enclosure_null_callbacks
;
188 device_unregister(&edev
->edev
);
190 EXPORT_SYMBOL_GPL(enclosure_unregister
);
192 #define ENCLOSURE_NAME_SIZE 64
193 #define COMPONENT_NAME_SIZE 64
195 static void enclosure_link_name(struct enclosure_component
*cdev
, char *name
)
197 strcpy(name
, "enclosure_device:");
198 strcat(name
, dev_name(&cdev
->cdev
));
201 static void enclosure_remove_links(struct enclosure_component
*cdev
)
203 char name
[ENCLOSURE_NAME_SIZE
];
205 enclosure_link_name(cdev
, name
);
208 * In odd circumstances, like multipath devices, something else may
209 * already have removed the links, so check for this condition first.
211 if (cdev
->dev
->kobj
.sd
)
212 sysfs_remove_link(&cdev
->dev
->kobj
, name
);
214 if (cdev
->cdev
.kobj
.sd
)
215 sysfs_remove_link(&cdev
->cdev
.kobj
, "device");
218 static int enclosure_add_links(struct enclosure_component
*cdev
)
221 char name
[ENCLOSURE_NAME_SIZE
];
223 error
= sysfs_create_link(&cdev
->cdev
.kobj
, &cdev
->dev
->kobj
, "device");
227 enclosure_link_name(cdev
, name
);
228 error
= sysfs_create_link(&cdev
->dev
->kobj
, &cdev
->cdev
.kobj
, name
);
230 sysfs_remove_link(&cdev
->cdev
.kobj
, "device");
235 static void enclosure_release(struct device
*cdev
)
237 struct enclosure_device
*edev
= to_enclosure_device(cdev
);
239 put_device(cdev
->parent
);
243 static void enclosure_component_release(struct device
*dev
)
245 struct enclosure_component
*cdev
= to_enclosure_component(dev
);
248 enclosure_remove_links(cdev
);
249 put_device(cdev
->dev
);
251 put_device(dev
->parent
);
254 static struct enclosure_component
*
255 enclosure_component_find_by_name(struct enclosure_device
*edev
,
260 struct enclosure_component
*ecomp
;
262 if (!edev
|| !name
|| !name
[0])
265 for (i
= 0; i
< edev
->components
; i
++) {
266 ecomp
= &edev
->component
[i
];
267 cname
= dev_name(&ecomp
->cdev
);
268 if (ecomp
->number
!= -1 &&
270 !strcmp(cname
, name
))
277 static const struct attribute_group
*enclosure_component_groups
[];
280 * enclosure_component_alloc - prepare a new enclosure component
281 * @edev: the enclosure to add the component
282 * @num: the device number
283 * @type: the type of component being added
284 * @name: an optional name to appear in sysfs (leave NULL if none)
286 * The name is optional for enclosures that give their components a unique
287 * name. If not, leave the field NULL and a name will be assigned.
289 * Returns a pointer to the enclosure component or an error.
291 struct enclosure_component
*
292 enclosure_component_alloc(struct enclosure_device
*edev
,
294 enum enclosure_component_type type
,
297 struct enclosure_component
*ecomp
;
300 char newname
[COMPONENT_NAME_SIZE
];
302 if (number
>= edev
->components
)
303 return ERR_PTR(-EINVAL
);
305 ecomp
= &edev
->component
[number
];
307 if (ecomp
->number
!= -1)
308 return ERR_PTR(-EINVAL
);
311 ecomp
->number
= number
;
313 cdev
->parent
= get_device(&edev
->edev
);
315 if (name
&& name
[0]) {
316 /* Some hardware (e.g. enclosure in RX300 S6) has components
317 * with non unique names. Registering duplicates in sysfs
318 * will lead to warnings during bootup. So make the names
319 * unique by appending consecutive numbers -1, -2, ... */
321 snprintf(newname
, COMPONENT_NAME_SIZE
,
323 while (enclosure_component_find_by_name(edev
, newname
))
324 snprintf(newname
, COMPONENT_NAME_SIZE
,
326 dev_set_name(cdev
, "%s", newname
);
328 dev_set_name(cdev
, "%u", number
);
330 cdev
->release
= enclosure_component_release
;
331 cdev
->groups
= enclosure_component_groups
;
335 EXPORT_SYMBOL_GPL(enclosure_component_alloc
);
338 * enclosure_component_register - publishes an initialized enclosure component
339 * @ecomp: component to add
341 * Returns 0 on successful registration, releases the component otherwise
343 int enclosure_component_register(struct enclosure_component
*ecomp
)
349 err
= device_register(cdev
);
358 EXPORT_SYMBOL_GPL(enclosure_component_register
);
361 * enclosure_add_device - add a device as being part of an enclosure
362 * @edev: the enclosure device being added to.
363 * @num: the number of the component
364 * @dev: the device being added
366 * Declares a real device to reside in slot (or identifier) @num of an
367 * enclosure. This will cause the relevant sysfs links to appear.
368 * This function may also be used to change a device associated with
369 * an enclosure without having to call enclosure_remove_device() in
372 * Returns zero on success or an error.
374 int enclosure_add_device(struct enclosure_device
*edev
, int component
,
377 struct enclosure_component
*cdev
;
380 if (!edev
|| component
>= edev
->components
)
383 cdev
= &edev
->component
[component
];
385 if (cdev
->dev
== dev
)
389 enclosure_remove_links(cdev
);
390 put_device(cdev
->dev
);
392 cdev
->dev
= get_device(dev
);
393 err
= enclosure_add_links(cdev
);
395 put_device(cdev
->dev
);
400 EXPORT_SYMBOL_GPL(enclosure_add_device
);
403 * enclosure_remove_device - remove a device from an enclosure
404 * @edev: the enclosure device
405 * @num: the number of the component to remove
407 * Returns zero on success or an error.
410 int enclosure_remove_device(struct enclosure_device
*edev
, struct device
*dev
)
412 struct enclosure_component
*cdev
;
418 for (i
= 0; i
< edev
->components
; i
++) {
419 cdev
= &edev
->component
[i
];
420 if (cdev
->dev
== dev
) {
421 enclosure_remove_links(cdev
);
422 device_del(&cdev
->cdev
);
425 return device_add(&cdev
->cdev
);
430 EXPORT_SYMBOL_GPL(enclosure_remove_device
);
436 static ssize_t
components_show(struct device
*cdev
,
437 struct device_attribute
*attr
, char *buf
)
439 struct enclosure_device
*edev
= to_enclosure_device(cdev
);
441 return snprintf(buf
, 40, "%d\n", edev
->components
);
443 static DEVICE_ATTR_RO(components
);
445 static ssize_t
id_show(struct device
*cdev
,
446 struct device_attribute
*attr
,
449 struct enclosure_device
*edev
= to_enclosure_device(cdev
);
451 if (edev
->cb
->show_id
)
452 return edev
->cb
->show_id(edev
, buf
);
455 static DEVICE_ATTR_RO(id
);
457 static struct attribute
*enclosure_class_attrs
[] = {
458 &dev_attr_components
.attr
,
462 ATTRIBUTE_GROUPS(enclosure_class
);
464 static struct class enclosure_class
= {
466 .owner
= THIS_MODULE
,
467 .dev_release
= enclosure_release
,
468 .dev_groups
= enclosure_class_groups
,
471 static const char *const enclosure_status
[] = {
472 [ENCLOSURE_STATUS_UNSUPPORTED
] = "unsupported",
473 [ENCLOSURE_STATUS_OK
] = "OK",
474 [ENCLOSURE_STATUS_CRITICAL
] = "critical",
475 [ENCLOSURE_STATUS_NON_CRITICAL
] = "non-critical",
476 [ENCLOSURE_STATUS_UNRECOVERABLE
] = "unrecoverable",
477 [ENCLOSURE_STATUS_NOT_INSTALLED
] = "not installed",
478 [ENCLOSURE_STATUS_UNKNOWN
] = "unknown",
479 [ENCLOSURE_STATUS_UNAVAILABLE
] = "unavailable",
480 [ENCLOSURE_STATUS_MAX
] = NULL
,
483 static const char *const enclosure_type
[] = {
484 [ENCLOSURE_COMPONENT_DEVICE
] = "device",
485 [ENCLOSURE_COMPONENT_ARRAY_DEVICE
] = "array device",
488 static ssize_t
get_component_fault(struct device
*cdev
,
489 struct device_attribute
*attr
, char *buf
)
491 struct enclosure_device
*edev
= to_enclosure_device(cdev
->parent
);
492 struct enclosure_component
*ecomp
= to_enclosure_component(cdev
);
494 if (edev
->cb
->get_fault
)
495 edev
->cb
->get_fault(edev
, ecomp
);
496 return snprintf(buf
, 40, "%d\n", ecomp
->fault
);
499 static ssize_t
set_component_fault(struct device
*cdev
,
500 struct device_attribute
*attr
,
501 const char *buf
, size_t count
)
503 struct enclosure_device
*edev
= to_enclosure_device(cdev
->parent
);
504 struct enclosure_component
*ecomp
= to_enclosure_component(cdev
);
505 int val
= simple_strtoul(buf
, NULL
, 0);
507 if (edev
->cb
->set_fault
)
508 edev
->cb
->set_fault(edev
, ecomp
, val
);
512 static ssize_t
get_component_status(struct device
*cdev
,
513 struct device_attribute
*attr
,char *buf
)
515 struct enclosure_device
*edev
= to_enclosure_device(cdev
->parent
);
516 struct enclosure_component
*ecomp
= to_enclosure_component(cdev
);
518 if (edev
->cb
->get_status
)
519 edev
->cb
->get_status(edev
, ecomp
);
520 return snprintf(buf
, 40, "%s\n", enclosure_status
[ecomp
->status
]);
523 static ssize_t
set_component_status(struct device
*cdev
,
524 struct device_attribute
*attr
,
525 const char *buf
, size_t count
)
527 struct enclosure_device
*edev
= to_enclosure_device(cdev
->parent
);
528 struct enclosure_component
*ecomp
= to_enclosure_component(cdev
);
531 for (i
= 0; enclosure_status
[i
]; i
++) {
532 if (strncmp(buf
, enclosure_status
[i
],
533 strlen(enclosure_status
[i
])) == 0 &&
534 (buf
[strlen(enclosure_status
[i
])] == '\n' ||
535 buf
[strlen(enclosure_status
[i
])] == '\0'))
539 if (enclosure_status
[i
] && edev
->cb
->set_status
) {
540 edev
->cb
->set_status(edev
, ecomp
, i
);
546 static ssize_t
get_component_active(struct device
*cdev
,
547 struct device_attribute
*attr
, char *buf
)
549 struct enclosure_device
*edev
= to_enclosure_device(cdev
->parent
);
550 struct enclosure_component
*ecomp
= to_enclosure_component(cdev
);
552 if (edev
->cb
->get_active
)
553 edev
->cb
->get_active(edev
, ecomp
);
554 return snprintf(buf
, 40, "%d\n", ecomp
->active
);
557 static ssize_t
set_component_active(struct device
*cdev
,
558 struct device_attribute
*attr
,
559 const char *buf
, size_t count
)
561 struct enclosure_device
*edev
= to_enclosure_device(cdev
->parent
);
562 struct enclosure_component
*ecomp
= to_enclosure_component(cdev
);
563 int val
= simple_strtoul(buf
, NULL
, 0);
565 if (edev
->cb
->set_active
)
566 edev
->cb
->set_active(edev
, ecomp
, val
);
570 static ssize_t
get_component_locate(struct device
*cdev
,
571 struct device_attribute
*attr
, char *buf
)
573 struct enclosure_device
*edev
= to_enclosure_device(cdev
->parent
);
574 struct enclosure_component
*ecomp
= to_enclosure_component(cdev
);
576 if (edev
->cb
->get_locate
)
577 edev
->cb
->get_locate(edev
, ecomp
);
578 return snprintf(buf
, 40, "%d\n", ecomp
->locate
);
581 static ssize_t
set_component_locate(struct device
*cdev
,
582 struct device_attribute
*attr
,
583 const char *buf
, size_t count
)
585 struct enclosure_device
*edev
= to_enclosure_device(cdev
->parent
);
586 struct enclosure_component
*ecomp
= to_enclosure_component(cdev
);
587 int val
= simple_strtoul(buf
, NULL
, 0);
589 if (edev
->cb
->set_locate
)
590 edev
->cb
->set_locate(edev
, ecomp
, val
);
594 static ssize_t
get_component_power_status(struct device
*cdev
,
595 struct device_attribute
*attr
,
598 struct enclosure_device
*edev
= to_enclosure_device(cdev
->parent
);
599 struct enclosure_component
*ecomp
= to_enclosure_component(cdev
);
601 if (edev
->cb
->get_power_status
)
602 edev
->cb
->get_power_status(edev
, ecomp
);
604 /* If still uninitialized, the callback failed or does not exist. */
605 if (ecomp
->power_status
== -1)
606 return (edev
->cb
->get_power_status
) ? -EIO
: -ENOTTY
;
608 return snprintf(buf
, 40, "%s\n", ecomp
->power_status
? "on" : "off");
611 static ssize_t
set_component_power_status(struct device
*cdev
,
612 struct device_attribute
*attr
,
613 const char *buf
, size_t count
)
615 struct enclosure_device
*edev
= to_enclosure_device(cdev
->parent
);
616 struct enclosure_component
*ecomp
= to_enclosure_component(cdev
);
619 if (strncmp(buf
, "on", 2) == 0 &&
620 (buf
[2] == '\n' || buf
[2] == '\0'))
622 else if (strncmp(buf
, "off", 3) == 0 &&
623 (buf
[3] == '\n' || buf
[3] == '\0'))
628 if (edev
->cb
->set_power_status
)
629 edev
->cb
->set_power_status(edev
, ecomp
, val
);
633 static ssize_t
get_component_type(struct device
*cdev
,
634 struct device_attribute
*attr
, char *buf
)
636 struct enclosure_component
*ecomp
= to_enclosure_component(cdev
);
638 return snprintf(buf
, 40, "%s\n", enclosure_type
[ecomp
->type
]);
641 static ssize_t
get_component_slot(struct device
*cdev
,
642 struct device_attribute
*attr
, char *buf
)
644 struct enclosure_component
*ecomp
= to_enclosure_component(cdev
);
647 /* if the enclosure does not override then use 'number' as a stand-in */
648 if (ecomp
->slot
>= 0)
651 slot
= ecomp
->number
;
653 return snprintf(buf
, 40, "%d\n", slot
);
656 static DEVICE_ATTR(fault
, S_IRUGO
| S_IWUSR
, get_component_fault
,
657 set_component_fault
);
658 static DEVICE_ATTR(status
, S_IRUGO
| S_IWUSR
, get_component_status
,
659 set_component_status
);
660 static DEVICE_ATTR(active
, S_IRUGO
| S_IWUSR
, get_component_active
,
661 set_component_active
);
662 static DEVICE_ATTR(locate
, S_IRUGO
| S_IWUSR
, get_component_locate
,
663 set_component_locate
);
664 static DEVICE_ATTR(power_status
, S_IRUGO
| S_IWUSR
, get_component_power_status
,
665 set_component_power_status
);
666 static DEVICE_ATTR(type
, S_IRUGO
, get_component_type
, NULL
);
667 static DEVICE_ATTR(slot
, S_IRUGO
, get_component_slot
, NULL
);
669 static struct attribute
*enclosure_component_attrs
[] = {
670 &dev_attr_fault
.attr
,
671 &dev_attr_status
.attr
,
672 &dev_attr_active
.attr
,
673 &dev_attr_locate
.attr
,
674 &dev_attr_power_status
.attr
,
679 ATTRIBUTE_GROUPS(enclosure_component
);
681 static int __init
enclosure_init(void)
685 err
= class_register(&enclosure_class
);
692 static void __exit
enclosure_exit(void)
694 class_unregister(&enclosure_class
);
697 module_init(enclosure_init
);
698 module_exit(enclosure_exit
);
700 MODULE_AUTHOR("James Bottomley");
701 MODULE_DESCRIPTION("Enclosure Services");
702 MODULE_LICENSE("GPL v2");