Merge branch 'pending' of master.kernel.org:/pub/scm/linux/kernel/git/vxy/lksctp-dev
[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 class_device_put().
44  */
45 struct enclosure_device *enclosure_find(struct device *dev)
46 {
47         struct enclosure_device *edev = NULL;
48
49         mutex_lock(&container_list_lock);
50         list_for_each_entry(edev, &container_list, node) {
51                 if (edev->cdev.dev == dev) {
52                         class_device_get(&edev->cdev);
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->cdev.class = &enclosure_class;
121         edev->cdev.dev = get_device(dev);
122         edev->cb = cb;
123         snprintf(edev->cdev.class_id, BUS_ID_SIZE, "%s", name);
124         err = class_device_register(&edev->cdev);
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->cdev.dev);
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                         class_device_unregister(&edev->component[i].cdev);
162
163         /* prevent any callbacks into service user */
164         edev->cb = &enclosure_null_callbacks;
165         class_device_unregister(&edev->cdev);
166 }
167 EXPORT_SYMBOL_GPL(enclosure_unregister);
168
169 static void enclosure_release(struct class_device *cdev)
170 {
171         struct enclosure_device *edev = to_enclosure_device(cdev);
172
173         put_device(cdev->dev);
174         kfree(edev);
175 }
176
177 static void enclosure_component_release(struct class_device *cdev)
178 {
179         if (cdev->dev)
180                 put_device(cdev->dev);
181         class_device_put(cdev->parent);
182 }
183
184 /**
185  * enclosure_component_register - add a particular component to an enclosure
186  * @edev:       the enclosure to add the component
187  * @num:        the device number
188  * @type:       the type of component being added
189  * @name:       an optional name to appear in sysfs (leave NULL if none)
190  *
191  * Registers the component.  The name is optional for enclosures that
192  * give their components a unique name.  If not, leave the field NULL
193  * and a name will be assigned.
194  *
195  * Returns a pointer to the enclosure component or an error.
196  */
197 struct enclosure_component *
198 enclosure_component_register(struct enclosure_device *edev,
199                              unsigned int number,
200                              enum enclosure_component_type type,
201                              const char *name)
202 {
203         struct enclosure_component *ecomp;
204         struct class_device *cdev;
205         int err;
206
207         if (number >= edev->components)
208                 return ERR_PTR(-EINVAL);
209
210         ecomp = &edev->component[number];
211
212         if (ecomp->number != -1)
213                 return ERR_PTR(-EINVAL);
214
215         ecomp->type = type;
216         ecomp->number = number;
217         cdev = &ecomp->cdev;
218         cdev->parent = class_device_get(&edev->cdev);
219         cdev->class = &enclosure_component_class;
220         if (name)
221                 snprintf(cdev->class_id, BUS_ID_SIZE, "%s", name);
222         else
223                 snprintf(cdev->class_id, BUS_ID_SIZE, "%u", number);
224
225         err = class_device_register(cdev);
226         if (err)
227                 ERR_PTR(err);
228
229         return ecomp;
230 }
231 EXPORT_SYMBOL_GPL(enclosure_component_register);
232
233 /**
234  * enclosure_add_device - add a device as being part of an enclosure
235  * @edev:       the enclosure device being added to.
236  * @num:        the number of the component
237  * @dev:        the device being added
238  *
239  * Declares a real device to reside in slot (or identifier) @num of an
240  * enclosure.  This will cause the relevant sysfs links to appear.
241  * This function may also be used to change a device associated with
242  * an enclosure without having to call enclosure_remove_device() in
243  * between.
244  *
245  * Returns zero on success or an error.
246  */
247 int enclosure_add_device(struct enclosure_device *edev, int component,
248                          struct device *dev)
249 {
250         struct class_device *cdev;
251
252         if (!edev || component >= edev->components)
253                 return -EINVAL;
254
255         cdev = &edev->component[component].cdev;
256
257         class_device_del(cdev);
258         if (cdev->dev)
259                 put_device(cdev->dev);
260         cdev->dev = get_device(dev);
261         return class_device_add(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 class_device *cdev;
276
277         if (!edev || component >= edev->components)
278                 return -EINVAL;
279
280         cdev = &edev->component[component].cdev;
281
282         class_device_del(cdev);
283         if (cdev->dev)
284                 put_device(cdev->dev);
285         cdev->dev = NULL;
286         return class_device_add(cdev);
287 }
288 EXPORT_SYMBOL_GPL(enclosure_remove_device);
289
290 /*
291  * sysfs pieces below
292  */
293
294 static ssize_t enclosure_show_components(struct class_device *cdev, char *buf)
295 {
296         struct enclosure_device *edev = to_enclosure_device(cdev);
297
298         return snprintf(buf, 40, "%d\n", edev->components);
299 }
300
301 static struct class_device_attribute enclosure_attrs[] = {
302         __ATTR(components, S_IRUGO, enclosure_show_components, NULL),
303         __ATTR_NULL
304 };
305
306 static struct class enclosure_class = {
307         .name                   = "enclosure",
308         .owner                  = THIS_MODULE,
309         .release                = enclosure_release,
310         .class_dev_attrs        = enclosure_attrs,
311 };
312
313 static const char *const enclosure_status [] = {
314         [ENCLOSURE_STATUS_UNSUPPORTED] = "unsupported",
315         [ENCLOSURE_STATUS_OK] = "OK",
316         [ENCLOSURE_STATUS_CRITICAL] = "critical",
317         [ENCLOSURE_STATUS_NON_CRITICAL] = "non-critical",
318         [ENCLOSURE_STATUS_UNRECOVERABLE] = "unrecoverable",
319         [ENCLOSURE_STATUS_NOT_INSTALLED] = "not installed",
320         [ENCLOSURE_STATUS_UNKNOWN] = "unknown",
321         [ENCLOSURE_STATUS_UNAVAILABLE] = "unavailable",
322 };
323
324 static const char *const enclosure_type [] = {
325         [ENCLOSURE_COMPONENT_DEVICE] = "device",
326         [ENCLOSURE_COMPONENT_ARRAY_DEVICE] = "array device",
327 };
328
329 static ssize_t get_component_fault(struct class_device *cdev, char *buf)
330 {
331         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
332         struct enclosure_component *ecomp = to_enclosure_component(cdev);
333
334         if (edev->cb->get_fault)
335                 edev->cb->get_fault(edev, ecomp);
336         return snprintf(buf, 40, "%d\n", ecomp->fault);
337 }
338
339 static ssize_t set_component_fault(struct class_device *cdev, const char *buf,
340                                    size_t count)
341 {
342         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
343         struct enclosure_component *ecomp = to_enclosure_component(cdev);
344         int val = simple_strtoul(buf, NULL, 0);
345
346         if (edev->cb->set_fault)
347                 edev->cb->set_fault(edev, ecomp, val);
348         return count;
349 }
350
351 static ssize_t get_component_status(struct class_device *cdev, char *buf)
352 {
353         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
354         struct enclosure_component *ecomp = to_enclosure_component(cdev);
355
356         if (edev->cb->get_status)
357                 edev->cb->get_status(edev, ecomp);
358         return snprintf(buf, 40, "%s\n", enclosure_status[ecomp->status]);
359 }
360
361 static ssize_t set_component_status(struct class_device *cdev, const char *buf,
362                                    size_t count)
363 {
364         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
365         struct enclosure_component *ecomp = to_enclosure_component(cdev);
366         int i;
367
368         for (i = 0; enclosure_status[i]; i++) {
369                 if (strncmp(buf, enclosure_status[i],
370                             strlen(enclosure_status[i])) == 0 &&
371                     (buf[strlen(enclosure_status[i])] == '\n' ||
372                      buf[strlen(enclosure_status[i])] == '\0'))
373                         break;
374         }
375
376         if (enclosure_status[i] && edev->cb->set_status) {
377                 edev->cb->set_status(edev, ecomp, i);
378                 return count;
379         } else
380                 return -EINVAL;
381 }
382
383 static ssize_t get_component_active(struct class_device *cdev, char *buf)
384 {
385         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
386         struct enclosure_component *ecomp = to_enclosure_component(cdev);
387
388         if (edev->cb->get_active)
389                 edev->cb->get_active(edev, ecomp);
390         return snprintf(buf, 40, "%d\n", ecomp->active);
391 }
392
393 static ssize_t set_component_active(struct class_device *cdev, const char *buf,
394                                    size_t count)
395 {
396         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
397         struct enclosure_component *ecomp = to_enclosure_component(cdev);
398         int val = simple_strtoul(buf, NULL, 0);
399
400         if (edev->cb->set_active)
401                 edev->cb->set_active(edev, ecomp, val);
402         return count;
403 }
404
405 static ssize_t get_component_locate(struct class_device *cdev, char *buf)
406 {
407         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
408         struct enclosure_component *ecomp = to_enclosure_component(cdev);
409
410         if (edev->cb->get_locate)
411                 edev->cb->get_locate(edev, ecomp);
412         return snprintf(buf, 40, "%d\n", ecomp->locate);
413 }
414
415 static ssize_t set_component_locate(struct class_device *cdev, const char *buf,
416                                    size_t count)
417 {
418         struct enclosure_device *edev = to_enclosure_device(cdev->parent);
419         struct enclosure_component *ecomp = to_enclosure_component(cdev);
420         int val = simple_strtoul(buf, NULL, 0);
421
422         if (edev->cb->set_locate)
423                 edev->cb->set_locate(edev, ecomp, val);
424         return count;
425 }
426
427 static ssize_t get_component_type(struct class_device *cdev, char *buf)
428 {
429         struct enclosure_component *ecomp = to_enclosure_component(cdev);
430
431         return snprintf(buf, 40, "%s\n", enclosure_type[ecomp->type]);
432 }
433
434
435 static struct class_device_attribute enclosure_component_attrs[] = {
436         __ATTR(fault, S_IRUGO | S_IWUSR, get_component_fault,
437                set_component_fault),
438         __ATTR(status, S_IRUGO | S_IWUSR, get_component_status,
439                set_component_status),
440         __ATTR(active, S_IRUGO | S_IWUSR, get_component_active,
441                set_component_active),
442         __ATTR(locate, S_IRUGO | S_IWUSR, get_component_locate,
443                set_component_locate),
444         __ATTR(type, S_IRUGO, get_component_type, NULL),
445         __ATTR_NULL
446 };
447
448 static struct class enclosure_component_class =  {
449         .name                   = "enclosure_component",
450         .owner                  = THIS_MODULE,
451         .class_dev_attrs        = enclosure_component_attrs,
452         .release                = enclosure_component_release,
453 };
454
455 static int __init enclosure_init(void)
456 {
457         int err;
458
459         err = class_register(&enclosure_class);
460         if (err)
461                 return err;
462         err = class_register(&enclosure_component_class);
463         if (err)
464                 goto err_out;
465
466         return 0;
467  err_out:
468         class_unregister(&enclosure_class);
469
470         return err;
471 }
472
473 static void __exit enclosure_exit(void)
474 {
475         class_unregister(&enclosure_component_class);
476         class_unregister(&enclosure_class);
477 }
478
479 module_init(enclosure_init);
480 module_exit(enclosure_exit);
481
482 MODULE_AUTHOR("James Bottomley");
483 MODULE_DESCRIPTION("Enclosure Services");
484 MODULE_LICENSE("GPL v2");