scsi: core: add new RDAC LENOVO/DE_Series device
[muen/linux.git] / drivers / scsi / scsi_dh.c
1 /*
2  * SCSI device handler infrastruture.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of the GNU General Public License as published by the
6  * Free Software Foundation; either version 2 of the License, or (at your
7  * option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with this program; if not, write to the Free Software Foundation, Inc.,
16  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17  *
18  * Copyright IBM Corporation, 2007
19  *      Authors:
20  *               Chandra Seetharaman <sekharan@us.ibm.com>
21  *               Mike Anderson <andmike@linux.vnet.ibm.com>
22  */
23
24 #include <linux/slab.h>
25 #include <linux/module.h>
26 #include <scsi/scsi_dh.h>
27 #include "scsi_priv.h"
28
29 static DEFINE_SPINLOCK(list_lock);
30 static LIST_HEAD(scsi_dh_list);
31
32 struct scsi_dh_blist {
33         const char *vendor;
34         const char *model;
35         const char *driver;
36 };
37
38 static const struct scsi_dh_blist scsi_dh_blist[] = {
39         {"DGC", "RAID",                 "emc" },
40         {"DGC", "DISK",                 "emc" },
41         {"DGC", "VRAID",                "emc" },
42
43         {"COMPAQ", "MSA1000 VOLUME",    "hp_sw" },
44         {"COMPAQ", "HSV110",            "hp_sw" },
45         {"HP", "HSV100",                "hp_sw"},
46         {"DEC", "HSG80",                "hp_sw"},
47
48         {"IBM", "1722",                 "rdac", },
49         {"IBM", "1724",                 "rdac", },
50         {"IBM", "1726",                 "rdac", },
51         {"IBM", "1742",                 "rdac", },
52         {"IBM", "1745",                 "rdac", },
53         {"IBM", "1746",                 "rdac", },
54         {"IBM", "1813",                 "rdac", },
55         {"IBM", "1814",                 "rdac", },
56         {"IBM", "1815",                 "rdac", },
57         {"IBM", "1818",                 "rdac", },
58         {"IBM", "3526",                 "rdac", },
59         {"IBM", "3542",                 "rdac", },
60         {"IBM", "3552",                 "rdac", },
61         {"SGI", "TP9300",               "rdac", },
62         {"SGI", "TP9400",               "rdac", },
63         {"SGI", "TP9500",               "rdac", },
64         {"SGI", "TP9700",               "rdac", },
65         {"SGI", "IS",                   "rdac", },
66         {"STK", "OPENstorage",          "rdac", },
67         {"STK", "FLEXLINE 380",         "rdac", },
68         {"STK", "BladeCtlr",            "rdac", },
69         {"SUN", "CSM",                  "rdac", },
70         {"SUN", "LCSM100",              "rdac", },
71         {"SUN", "STK6580_6780",         "rdac", },
72         {"SUN", "SUN_6180",             "rdac", },
73         {"SUN", "ArrayStorage",         "rdac", },
74         {"DELL", "MD3",                 "rdac", },
75         {"NETAPP", "INF-01-00",         "rdac", },
76         {"LSI", "INF-01-00",            "rdac", },
77         {"ENGENIO", "INF-01-00",        "rdac", },
78         {"LENOVO", "DE_Series",         "rdac", },
79         {NULL, NULL,                    NULL },
80 };
81
82 static const char *
83 scsi_dh_find_driver(struct scsi_device *sdev)
84 {
85         const struct scsi_dh_blist *b;
86
87         if (scsi_device_tpgs(sdev))
88                 return "alua";
89
90         for (b = scsi_dh_blist; b->vendor; b++) {
91                 if (!strncmp(sdev->vendor, b->vendor, strlen(b->vendor)) &&
92                     !strncmp(sdev->model, b->model, strlen(b->model))) {
93                         return b->driver;
94                 }
95         }
96         return NULL;
97 }
98
99
100 static struct scsi_device_handler *__scsi_dh_lookup(const char *name)
101 {
102         struct scsi_device_handler *tmp, *found = NULL;
103
104         spin_lock(&list_lock);
105         list_for_each_entry(tmp, &scsi_dh_list, list) {
106                 if (!strncmp(tmp->name, name, strlen(tmp->name))) {
107                         found = tmp;
108                         break;
109                 }
110         }
111         spin_unlock(&list_lock);
112         return found;
113 }
114
115 static struct scsi_device_handler *scsi_dh_lookup(const char *name)
116 {
117         struct scsi_device_handler *dh;
118
119         if (!name || strlen(name) == 0)
120                 return NULL;
121
122         dh = __scsi_dh_lookup(name);
123         if (!dh) {
124                 request_module("scsi_dh_%s", name);
125                 dh = __scsi_dh_lookup(name);
126         }
127
128         return dh;
129 }
130
131 /*
132  * scsi_dh_handler_attach - Attach a device handler to a device
133  * @sdev - SCSI device the device handler should attach to
134  * @scsi_dh - The device handler to attach
135  */
136 static int scsi_dh_handler_attach(struct scsi_device *sdev,
137                                   struct scsi_device_handler *scsi_dh)
138 {
139         int error, ret = 0;
140
141         if (!try_module_get(scsi_dh->module))
142                 return -EINVAL;
143
144         error = scsi_dh->attach(sdev);
145         if (error != SCSI_DH_OK) {
146                 switch (error) {
147                 case SCSI_DH_NOMEM:
148                         ret = -ENOMEM;
149                         break;
150                 case SCSI_DH_RES_TEMP_UNAVAIL:
151                         ret = -EAGAIN;
152                         break;
153                 case SCSI_DH_DEV_UNSUPP:
154                 case SCSI_DH_NOSYS:
155                         ret = -ENODEV;
156                         break;
157                 default:
158                         ret = -EINVAL;
159                         break;
160                 }
161                 if (ret != -ENODEV)
162                         sdev_printk(KERN_ERR, sdev, "%s: Attach failed (%d)\n",
163                                     scsi_dh->name, error);
164                 module_put(scsi_dh->module);
165         } else
166                 sdev->handler = scsi_dh;
167
168         return ret;
169 }
170
171 /*
172  * scsi_dh_handler_detach - Detach a device handler from a device
173  * @sdev - SCSI device the device handler should be detached from
174  */
175 static void scsi_dh_handler_detach(struct scsi_device *sdev)
176 {
177         sdev->handler->detach(sdev);
178         sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", sdev->handler->name);
179         module_put(sdev->handler->module);
180 }
181
182 void scsi_dh_add_device(struct scsi_device *sdev)
183 {
184         struct scsi_device_handler *devinfo = NULL;
185         const char *drv;
186
187         drv = scsi_dh_find_driver(sdev);
188         if (drv)
189                 devinfo = __scsi_dh_lookup(drv);
190         /*
191          * device_handler is optional, so ignore errors
192          * from scsi_dh_handler_attach()
193          */
194         if (devinfo)
195                 (void)scsi_dh_handler_attach(sdev, devinfo);
196 }
197
198 void scsi_dh_release_device(struct scsi_device *sdev)
199 {
200         if (sdev->handler)
201                 scsi_dh_handler_detach(sdev);
202 }
203
204 /*
205  * scsi_register_device_handler - register a device handler personality
206  *      module.
207  * @scsi_dh - device handler to be registered.
208  *
209  * Returns 0 on success, -EBUSY if handler already registered.
210  */
211 int scsi_register_device_handler(struct scsi_device_handler *scsi_dh)
212 {
213         if (__scsi_dh_lookup(scsi_dh->name))
214                 return -EBUSY;
215
216         if (!scsi_dh->attach || !scsi_dh->detach)
217                 return -EINVAL;
218
219         spin_lock(&list_lock);
220         list_add(&scsi_dh->list, &scsi_dh_list);
221         spin_unlock(&list_lock);
222
223         printk(KERN_INFO "%s: device handler registered\n", scsi_dh->name);
224
225         return SCSI_DH_OK;
226 }
227 EXPORT_SYMBOL_GPL(scsi_register_device_handler);
228
229 /*
230  * scsi_unregister_device_handler - register a device handler personality
231  *      module.
232  * @scsi_dh - device handler to be unregistered.
233  *
234  * Returns 0 on success, -ENODEV if handler not registered.
235  */
236 int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh)
237 {
238         if (!__scsi_dh_lookup(scsi_dh->name))
239                 return -ENODEV;
240
241         spin_lock(&list_lock);
242         list_del(&scsi_dh->list);
243         spin_unlock(&list_lock);
244         printk(KERN_INFO "%s: device handler unregistered\n", scsi_dh->name);
245
246         return SCSI_DH_OK;
247 }
248 EXPORT_SYMBOL_GPL(scsi_unregister_device_handler);
249
250 /*
251  * scsi_dh_activate - activate the path associated with the scsi_device
252  *      corresponding to the given request queue.
253  *     Returns immediately without waiting for activation to be completed.
254  * @q    - Request queue that is associated with the scsi_device to be
255  *         activated.
256  * @fn   - Function to be called upon completion of the activation.
257  *         Function fn is called with data (below) and the error code.
258  *         Function fn may be called from the same calling context. So,
259  *         do not hold the lock in the caller which may be needed in fn.
260  * @data - data passed to the function fn upon completion.
261  *
262  */
263 int scsi_dh_activate(struct request_queue *q, activate_complete fn, void *data)
264 {
265         struct scsi_device *sdev;
266         int err = SCSI_DH_NOSYS;
267
268         sdev = scsi_device_from_queue(q);
269         if (!sdev) {
270                 if (fn)
271                         fn(data, err);
272                 return err;
273         }
274
275         if (!sdev->handler)
276                 goto out_fn;
277         err = SCSI_DH_NOTCONN;
278         if (sdev->sdev_state == SDEV_CANCEL ||
279             sdev->sdev_state == SDEV_DEL)
280                 goto out_fn;
281
282         err = SCSI_DH_DEV_OFFLINED;
283         if (sdev->sdev_state == SDEV_OFFLINE)
284                 goto out_fn;
285
286         if (sdev->handler->activate)
287                 err = sdev->handler->activate(sdev, fn, data);
288
289 out_put_device:
290         put_device(&sdev->sdev_gendev);
291         return err;
292
293 out_fn:
294         if (fn)
295                 fn(data, err);
296         goto out_put_device;
297 }
298 EXPORT_SYMBOL_GPL(scsi_dh_activate);
299
300 /*
301  * scsi_dh_set_params - set the parameters for the device as per the
302  *      string specified in params.
303  * @q - Request queue that is associated with the scsi_device for
304  *      which the parameters to be set.
305  * @params - parameters in the following format
306  *      "no_of_params\0param1\0param2\0param3\0...\0"
307  *      for example, string for 2 parameters with value 10 and 21
308  *      is specified as "2\010\021\0".
309  */
310 int scsi_dh_set_params(struct request_queue *q, const char *params)
311 {
312         struct scsi_device *sdev;
313         int err = -SCSI_DH_NOSYS;
314
315         sdev = scsi_device_from_queue(q);
316         if (!sdev)
317                 return err;
318
319         if (sdev->handler && sdev->handler->set_params)
320                 err = sdev->handler->set_params(sdev, params);
321         put_device(&sdev->sdev_gendev);
322         return err;
323 }
324 EXPORT_SYMBOL_GPL(scsi_dh_set_params);
325
326 /*
327  * scsi_dh_attach - Attach device handler
328  * @q - Request queue that is associated with the scsi_device
329  *      the handler should be attached to
330  * @name - name of the handler to attach
331  */
332 int scsi_dh_attach(struct request_queue *q, const char *name)
333 {
334         struct scsi_device *sdev;
335         struct scsi_device_handler *scsi_dh;
336         int err = 0;
337
338         sdev = scsi_device_from_queue(q);
339         if (!sdev)
340                 return -ENODEV;
341
342         scsi_dh = scsi_dh_lookup(name);
343         if (!scsi_dh) {
344                 err = -EINVAL;
345                 goto out_put_device;
346         }
347
348         if (sdev->handler) {
349                 if (sdev->handler != scsi_dh)
350                         err = -EBUSY;
351                 goto out_put_device;
352         }
353
354         err = scsi_dh_handler_attach(sdev, scsi_dh);
355
356 out_put_device:
357         put_device(&sdev->sdev_gendev);
358         return err;
359 }
360 EXPORT_SYMBOL_GPL(scsi_dh_attach);
361
362 /*
363  * scsi_dh_attached_handler_name - Get attached device handler's name
364  * @q - Request queue that is associated with the scsi_device
365  *      that may have a device handler attached
366  * @gfp - the GFP mask used in the kmalloc() call when allocating memory
367  *
368  * Returns name of attached handler, NULL if no handler is attached.
369  * Caller must take care to free the returned string.
370  */
371 const char *scsi_dh_attached_handler_name(struct request_queue *q, gfp_t gfp)
372 {
373         struct scsi_device *sdev;
374         const char *handler_name = NULL;
375
376         sdev = scsi_device_from_queue(q);
377         if (!sdev)
378                 return NULL;
379
380         if (sdev->handler)
381                 handler_name = kstrdup(sdev->handler->name, gfp);
382         put_device(&sdev->sdev_gendev);
383         return handler_name;
384 }
385 EXPORT_SYMBOL_GPL(scsi_dh_attached_handler_name);