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