]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/scsi/scsi_scan.c
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[karo-tx-linux.git] / drivers / scsi / scsi_scan.c
1 /*
2  * scsi_scan.c
3  *
4  * Copyright (C) 2000 Eric Youngdale,
5  * Copyright (C) 2002 Patrick Mansfield
6  *
7  * The general scanning/probing algorithm is as follows, exceptions are
8  * made to it depending on device specific flags, compilation options, and
9  * global variable (boot or module load time) settings.
10  *
11  * A specific LUN is scanned via an INQUIRY command; if the LUN has a
12  * device attached, a scsi_device is allocated and setup for it.
13  *
14  * For every id of every channel on the given host:
15  *
16  *      Scan LUN 0; if the target responds to LUN 0 (even if there is no
17  *      device or storage attached to LUN 0):
18  *
19  *              If LUN 0 has a device attached, allocate and setup a
20  *              scsi_device for it.
21  *
22  *              If target is SCSI-3 or up, issue a REPORT LUN, and scan
23  *              all of the LUNs returned by the REPORT LUN; else,
24  *              sequentially scan LUNs up until some maximum is reached,
25  *              or a LUN is seen that cannot have a device attached to it.
26  */
27
28 #include <linux/module.h>
29 #include <linux/moduleparam.h>
30 #include <linux/init.h>
31 #include <linux/blkdev.h>
32 #include <linux/delay.h>
33 #include <linux/kthread.h>
34 #include <linux/spinlock.h>
35 #include <linux/async.h>
36 #include <linux/slab.h>
37
38 #include <scsi/scsi.h>
39 #include <scsi/scsi_cmnd.h>
40 #include <scsi/scsi_device.h>
41 #include <scsi/scsi_driver.h>
42 #include <scsi/scsi_devinfo.h>
43 #include <scsi/scsi_host.h>
44 #include <scsi/scsi_transport.h>
45 #include <scsi/scsi_eh.h>
46
47 #include "scsi_priv.h"
48 #include "scsi_logging.h"
49
50 #define ALLOC_FAILURE_MSG       KERN_ERR "%s: Allocation failure during" \
51         " SCSI scanning, some SCSI devices might not be configured\n"
52
53 /*
54  * Default timeout
55  */
56 #define SCSI_TIMEOUT (2*HZ)
57
58 /*
59  * Prefix values for the SCSI id's (stored in sysfs name field)
60  */
61 #define SCSI_UID_SER_NUM 'S'
62 #define SCSI_UID_UNKNOWN 'Z'
63
64 /*
65  * Return values of some of the scanning functions.
66  *
67  * SCSI_SCAN_NO_RESPONSE: no valid response received from the target, this
68  * includes allocation or general failures preventing IO from being sent.
69  *
70  * SCSI_SCAN_TARGET_PRESENT: target responded, but no device is available
71  * on the given LUN.
72  *
73  * SCSI_SCAN_LUN_PRESENT: target responded, and a device is available on a
74  * given LUN.
75  */
76 #define SCSI_SCAN_NO_RESPONSE           0
77 #define SCSI_SCAN_TARGET_PRESENT        1
78 #define SCSI_SCAN_LUN_PRESENT           2
79
80 static const char *scsi_null_device_strs = "nullnullnullnull";
81
82 #define MAX_SCSI_LUNS   512
83
84 #ifdef CONFIG_SCSI_MULTI_LUN
85 static unsigned int max_scsi_luns = MAX_SCSI_LUNS;
86 #else
87 static unsigned int max_scsi_luns = 1;
88 #endif
89
90 module_param_named(max_luns, max_scsi_luns, uint, S_IRUGO|S_IWUSR);
91 MODULE_PARM_DESC(max_luns,
92                  "last scsi LUN (should be between 1 and 2^32-1)");
93
94 #ifdef CONFIG_SCSI_SCAN_ASYNC
95 #define SCSI_SCAN_TYPE_DEFAULT "async"
96 #else
97 #define SCSI_SCAN_TYPE_DEFAULT "sync"
98 #endif
99
100 static char scsi_scan_type[6] = SCSI_SCAN_TYPE_DEFAULT;
101
102 module_param_string(scan, scsi_scan_type, sizeof(scsi_scan_type), S_IRUGO);
103 MODULE_PARM_DESC(scan, "sync, async or none");
104
105 /*
106  * max_scsi_report_luns: the maximum number of LUNS that will be
107  * returned from the REPORT LUNS command. 8 times this value must
108  * be allocated. In theory this could be up to an 8 byte value, but
109  * in practice, the maximum number of LUNs suppored by any device
110  * is about 16k.
111  */
112 static unsigned int max_scsi_report_luns = 511;
113
114 module_param_named(max_report_luns, max_scsi_report_luns, uint, S_IRUGO|S_IWUSR);
115 MODULE_PARM_DESC(max_report_luns,
116                  "REPORT LUNS maximum number of LUNS received (should be"
117                  " between 1 and 16384)");
118
119 static unsigned int scsi_inq_timeout = SCSI_TIMEOUT/HZ + 18;
120
121 module_param_named(inq_timeout, scsi_inq_timeout, uint, S_IRUGO|S_IWUSR);
122 MODULE_PARM_DESC(inq_timeout, 
123                  "Timeout (in seconds) waiting for devices to answer INQUIRY."
124                  " Default is 20. Some devices may need more; most need less.");
125
126 /* This lock protects only this list */
127 static DEFINE_SPINLOCK(async_scan_lock);
128 static LIST_HEAD(scanning_hosts);
129
130 struct async_scan_data {
131         struct list_head list;
132         struct Scsi_Host *shost;
133         struct completion prev_finished;
134 };
135
136 /**
137  * scsi_complete_async_scans - Wait for asynchronous scans to complete
138  *
139  * When this function returns, any host which started scanning before
140  * this function was called will have finished its scan.  Hosts which
141  * started scanning after this function was called may or may not have
142  * finished.
143  */
144 int scsi_complete_async_scans(void)
145 {
146         struct async_scan_data *data;
147
148         do {
149                 if (list_empty(&scanning_hosts))
150                         return 0;
151                 /* If we can't get memory immediately, that's OK.  Just
152                  * sleep a little.  Even if we never get memory, the async
153                  * scans will finish eventually.
154                  */
155                 data = kmalloc(sizeof(*data), GFP_KERNEL);
156                 if (!data)
157                         msleep(1);
158         } while (!data);
159
160         data->shost = NULL;
161         init_completion(&data->prev_finished);
162
163         spin_lock(&async_scan_lock);
164         /* Check that there's still somebody else on the list */
165         if (list_empty(&scanning_hosts))
166                 goto done;
167         list_add_tail(&data->list, &scanning_hosts);
168         spin_unlock(&async_scan_lock);
169
170         printk(KERN_INFO "scsi: waiting for bus probes to complete ...\n");
171         wait_for_completion(&data->prev_finished);
172
173         spin_lock(&async_scan_lock);
174         list_del(&data->list);
175         if (!list_empty(&scanning_hosts)) {
176                 struct async_scan_data *next = list_entry(scanning_hosts.next,
177                                 struct async_scan_data, list);
178                 complete(&next->prev_finished);
179         }
180  done:
181         spin_unlock(&async_scan_lock);
182
183         kfree(data);
184         return 0;
185 }
186
187 /* Only exported for the benefit of scsi_wait_scan */
188 EXPORT_SYMBOL_GPL(scsi_complete_async_scans);
189
190 #ifndef MODULE
191 /*
192  * For async scanning we need to wait for all the scans to complete before
193  * trying to mount the root fs.  Otherwise non-modular drivers may not be ready
194  * yet.
195  */
196 late_initcall(scsi_complete_async_scans);
197 #endif
198
199 /**
200  * scsi_unlock_floptical - unlock device via a special MODE SENSE command
201  * @sdev:       scsi device to send command to
202  * @result:     area to store the result of the MODE SENSE
203  *
204  * Description:
205  *     Send a vendor specific MODE SENSE (not a MODE SELECT) command.
206  *     Called for BLIST_KEY devices.
207  **/
208 static void scsi_unlock_floptical(struct scsi_device *sdev,
209                                   unsigned char *result)
210 {
211         unsigned char scsi_cmd[MAX_COMMAND_SIZE];
212
213         printk(KERN_NOTICE "scsi: unlocking floptical drive\n");
214         scsi_cmd[0] = MODE_SENSE;
215         scsi_cmd[1] = 0;
216         scsi_cmd[2] = 0x2e;
217         scsi_cmd[3] = 0;
218         scsi_cmd[4] = 0x2a;     /* size */
219         scsi_cmd[5] = 0;
220         scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE, result, 0x2a, NULL,
221                          SCSI_TIMEOUT, 3, NULL);
222 }
223
224 /**
225  * scsi_alloc_sdev - allocate and setup a scsi_Device
226  * @starget: which target to allocate a &scsi_device for
227  * @lun: which lun
228  * @hostdata: usually NULL and set by ->slave_alloc instead
229  *
230  * Description:
231  *     Allocate, initialize for io, and return a pointer to a scsi_Device.
232  *     Stores the @shost, @channel, @id, and @lun in the scsi_Device, and
233  *     adds scsi_Device to the appropriate list.
234  *
235  * Return value:
236  *     scsi_Device pointer, or NULL on failure.
237  **/
238 static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget,
239                                            unsigned int lun, void *hostdata)
240 {
241         struct scsi_device *sdev;
242         int display_failure_msg = 1, ret;
243         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
244         extern void scsi_evt_thread(struct work_struct *work);
245
246         sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
247                        GFP_ATOMIC);
248         if (!sdev)
249                 goto out;
250
251         sdev->vendor = scsi_null_device_strs;
252         sdev->model = scsi_null_device_strs;
253         sdev->rev = scsi_null_device_strs;
254         sdev->host = shost;
255         sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;
256         sdev->id = starget->id;
257         sdev->lun = lun;
258         sdev->channel = starget->channel;
259         sdev->sdev_state = SDEV_CREATED;
260         INIT_LIST_HEAD(&sdev->siblings);
261         INIT_LIST_HEAD(&sdev->same_target_siblings);
262         INIT_LIST_HEAD(&sdev->cmd_list);
263         INIT_LIST_HEAD(&sdev->starved_entry);
264         INIT_LIST_HEAD(&sdev->event_list);
265         spin_lock_init(&sdev->list_lock);
266         INIT_WORK(&sdev->event_work, scsi_evt_thread);
267
268         sdev->sdev_gendev.parent = get_device(&starget->dev);
269         sdev->sdev_target = starget;
270
271         /* usually NULL and set by ->slave_alloc instead */
272         sdev->hostdata = hostdata;
273
274         /* if the device needs this changing, it may do so in the
275          * slave_configure function */
276         sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;
277
278         /*
279          * Some low level driver could use device->type
280          */
281         sdev->type = -1;
282
283         /*
284          * Assume that the device will have handshaking problems,
285          * and then fix this field later if it turns out it
286          * doesn't
287          */
288         sdev->borken = 1;
289
290         sdev->request_queue = scsi_alloc_queue(sdev);
291         if (!sdev->request_queue) {
292                 /* release fn is set up in scsi_sysfs_device_initialise, so
293                  * have to free and put manually here */
294                 put_device(&starget->dev);
295                 kfree(sdev);
296                 goto out;
297         }
298
299         sdev->request_queue->queuedata = sdev;
300         scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
301
302         scsi_sysfs_device_initialize(sdev);
303
304         if (shost->hostt->slave_alloc) {
305                 ret = shost->hostt->slave_alloc(sdev);
306                 if (ret) {
307                         /*
308                          * if LLDD reports slave not present, don't clutter
309                          * console with alloc failure messages
310                          */
311                         if (ret == -ENXIO)
312                                 display_failure_msg = 0;
313                         goto out_device_destroy;
314                 }
315         }
316
317         return sdev;
318
319 out_device_destroy:
320         scsi_device_set_state(sdev, SDEV_DEL);
321         transport_destroy_device(&sdev->sdev_gendev);
322         put_device(&sdev->sdev_dev);
323         put_device(&sdev->sdev_gendev);
324 out:
325         if (display_failure_msg)
326                 printk(ALLOC_FAILURE_MSG, __func__);
327         return NULL;
328 }
329
330 static void scsi_target_destroy(struct scsi_target *starget)
331 {
332         struct device *dev = &starget->dev;
333         struct Scsi_Host *shost = dev_to_shost(dev->parent);
334         unsigned long flags;
335
336         transport_destroy_device(dev);
337         spin_lock_irqsave(shost->host_lock, flags);
338         if (shost->hostt->target_destroy)
339                 shost->hostt->target_destroy(starget);
340         list_del_init(&starget->siblings);
341         spin_unlock_irqrestore(shost->host_lock, flags);
342         put_device(dev);
343 }
344
345 static void scsi_target_dev_release(struct device *dev)
346 {
347         struct device *parent = dev->parent;
348         struct scsi_target *starget = to_scsi_target(dev);
349
350         kfree(starget);
351         put_device(parent);
352 }
353
354 static struct device_type scsi_target_type = {
355         .name =         "scsi_target",
356         .release =      scsi_target_dev_release,
357 };
358
359 int scsi_is_target_device(const struct device *dev)
360 {
361         return dev->type == &scsi_target_type;
362 }
363 EXPORT_SYMBOL(scsi_is_target_device);
364
365 static struct scsi_target *__scsi_find_target(struct device *parent,
366                                               int channel, uint id)
367 {
368         struct scsi_target *starget, *found_starget = NULL;
369         struct Scsi_Host *shost = dev_to_shost(parent);
370         /*
371          * Search for an existing target for this sdev.
372          */
373         list_for_each_entry(starget, &shost->__targets, siblings) {
374                 if (starget->id == id &&
375                     starget->channel == channel) {
376                         found_starget = starget;
377                         break;
378                 }
379         }
380         if (found_starget)
381                 get_device(&found_starget->dev);
382
383         return found_starget;
384 }
385
386 /**
387  * scsi_alloc_target - allocate a new or find an existing target
388  * @parent:     parent of the target (need not be a scsi host)
389  * @channel:    target channel number (zero if no channels)
390  * @id:         target id number
391  *
392  * Return an existing target if one exists, provided it hasn't already
393  * gone into STARGET_DEL state, otherwise allocate a new target.
394  *
395  * The target is returned with an incremented reference, so the caller
396  * is responsible for both reaping and doing a last put
397  */
398 static struct scsi_target *scsi_alloc_target(struct device *parent,
399                                              int channel, uint id)
400 {
401         struct Scsi_Host *shost = dev_to_shost(parent);
402         struct device *dev = NULL;
403         unsigned long flags;
404         const int size = sizeof(struct scsi_target)
405                 + shost->transportt->target_size;
406         struct scsi_target *starget;
407         struct scsi_target *found_target;
408         int error;
409
410         starget = kzalloc(size, GFP_KERNEL);
411         if (!starget) {
412                 printk(KERN_ERR "%s: allocation failure\n", __func__);
413                 return NULL;
414         }
415         dev = &starget->dev;
416         device_initialize(dev);
417         starget->reap_ref = 1;
418         dev->parent = get_device(parent);
419         dev_set_name(dev, "target%d:%d:%d", shost->host_no, channel, id);
420 #ifndef CONFIG_SYSFS_DEPRECATED
421         dev->bus = &scsi_bus_type;
422 #endif
423         dev->type = &scsi_target_type;
424         starget->id = id;
425         starget->channel = channel;
426         starget->can_queue = 0;
427         INIT_LIST_HEAD(&starget->siblings);
428         INIT_LIST_HEAD(&starget->devices);
429         starget->state = STARGET_CREATED;
430         starget->scsi_level = SCSI_2;
431         starget->max_target_blocked = SCSI_DEFAULT_TARGET_BLOCKED;
432  retry:
433         spin_lock_irqsave(shost->host_lock, flags);
434
435         found_target = __scsi_find_target(parent, channel, id);
436         if (found_target)
437                 goto found;
438
439         list_add_tail(&starget->siblings, &shost->__targets);
440         spin_unlock_irqrestore(shost->host_lock, flags);
441         /* allocate and add */
442         transport_setup_device(dev);
443         if (shost->hostt->target_alloc) {
444                 error = shost->hostt->target_alloc(starget);
445
446                 if(error) {
447                         dev_printk(KERN_ERR, dev, "target allocation failed, error %d\n", error);
448                         /* don't want scsi_target_reap to do the final
449                          * put because it will be under the host lock */
450                         scsi_target_destroy(starget);
451                         return NULL;
452                 }
453         }
454         get_device(dev);
455
456         return starget;
457
458  found:
459         found_target->reap_ref++;
460         spin_unlock_irqrestore(shost->host_lock, flags);
461         if (found_target->state != STARGET_DEL) {
462                 put_device(parent);
463                 kfree(starget);
464                 return found_target;
465         }
466         /* Unfortunately, we found a dying target; need to
467          * wait until it's dead before we can get a new one */
468         put_device(&found_target->dev);
469         flush_scheduled_work();
470         goto retry;
471 }
472
473 static void scsi_target_reap_usercontext(struct work_struct *work)
474 {
475         struct scsi_target *starget =
476                 container_of(work, struct scsi_target, ew.work);
477
478         transport_remove_device(&starget->dev);
479         device_del(&starget->dev);
480         scsi_target_destroy(starget);
481 }
482
483 /**
484  * scsi_target_reap - check to see if target is in use and destroy if not
485  * @starget: target to be checked
486  *
487  * This is used after removing a LUN or doing a last put of the target
488  * it checks atomically that nothing is using the target and removes
489  * it if so.
490  */
491 void scsi_target_reap(struct scsi_target *starget)
492 {
493         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
494         unsigned long flags;
495         enum scsi_target_state state;
496         int empty;
497
498         spin_lock_irqsave(shost->host_lock, flags);
499         state = starget->state;
500         empty = --starget->reap_ref == 0 &&
501                 list_empty(&starget->devices) ? 1 : 0;
502         spin_unlock_irqrestore(shost->host_lock, flags);
503
504         if (!empty)
505                 return;
506
507         BUG_ON(state == STARGET_DEL);
508         starget->state = STARGET_DEL;
509         if (state == STARGET_CREATED)
510                 scsi_target_destroy(starget);
511         else
512                 execute_in_process_context(scsi_target_reap_usercontext,
513                                            &starget->ew);
514 }
515
516 /**
517  * sanitize_inquiry_string - remove non-graphical chars from an INQUIRY result string
518  * @s: INQUIRY result string to sanitize
519  * @len: length of the string
520  *
521  * Description:
522  *      The SCSI spec says that INQUIRY vendor, product, and revision
523  *      strings must consist entirely of graphic ASCII characters,
524  *      padded on the right with spaces.  Since not all devices obey
525  *      this rule, we will replace non-graphic or non-ASCII characters
526  *      with spaces.  Exception: a NUL character is interpreted as a
527  *      string terminator, so all the following characters are set to
528  *      spaces.
529  **/
530 static void sanitize_inquiry_string(unsigned char *s, int len)
531 {
532         int terminated = 0;
533
534         for (; len > 0; (--len, ++s)) {
535                 if (*s == 0)
536                         terminated = 1;
537                 if (terminated || *s < 0x20 || *s > 0x7e)
538                         *s = ' ';
539         }
540 }
541
542 /**
543  * scsi_probe_lun - probe a single LUN using a SCSI INQUIRY
544  * @sdev:       scsi_device to probe
545  * @inq_result: area to store the INQUIRY result
546  * @result_len: len of inq_result
547  * @bflags:     store any bflags found here
548  *
549  * Description:
550  *     Probe the lun associated with @req using a standard SCSI INQUIRY;
551  *
552  *     If the INQUIRY is successful, zero is returned and the
553  *     INQUIRY data is in @inq_result; the scsi_level and INQUIRY length
554  *     are copied to the scsi_device any flags value is stored in *@bflags.
555  **/
556 static int scsi_probe_lun(struct scsi_device *sdev, unsigned char *inq_result,
557                           int result_len, int *bflags)
558 {
559         unsigned char scsi_cmd[MAX_COMMAND_SIZE];
560         int first_inquiry_len, try_inquiry_len, next_inquiry_len;
561         int response_len = 0;
562         int pass, count, result;
563         struct scsi_sense_hdr sshdr;
564
565         *bflags = 0;
566
567         /* Perform up to 3 passes.  The first pass uses a conservative
568          * transfer length of 36 unless sdev->inquiry_len specifies a
569          * different value. */
570         first_inquiry_len = sdev->inquiry_len ? sdev->inquiry_len : 36;
571         try_inquiry_len = first_inquiry_len;
572         pass = 1;
573
574  next_pass:
575         SCSI_LOG_SCAN_BUS(3, sdev_printk(KERN_INFO, sdev,
576                                 "scsi scan: INQUIRY pass %d length %d\n",
577                                 pass, try_inquiry_len));
578
579         /* Each pass gets up to three chances to ignore Unit Attention */
580         for (count = 0; count < 3; ++count) {
581                 int resid;
582
583                 memset(scsi_cmd, 0, 6);
584                 scsi_cmd[0] = INQUIRY;
585                 scsi_cmd[4] = (unsigned char) try_inquiry_len;
586
587                 memset(inq_result, 0, try_inquiry_len);
588
589                 result = scsi_execute_req(sdev,  scsi_cmd, DMA_FROM_DEVICE,
590                                           inq_result, try_inquiry_len, &sshdr,
591                                           HZ / 2 + HZ * scsi_inq_timeout, 3,
592                                           &resid);
593
594                 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: INQUIRY %s "
595                                 "with code 0x%x\n",
596                                 result ? "failed" : "successful", result));
597
598                 if (result) {
599                         /*
600                          * not-ready to ready transition [asc/ascq=0x28/0x0]
601                          * or power-on, reset [asc/ascq=0x29/0x0], continue.
602                          * INQUIRY should not yield UNIT_ATTENTION
603                          * but many buggy devices do so anyway. 
604                          */
605                         if ((driver_byte(result) & DRIVER_SENSE) &&
606                             scsi_sense_valid(&sshdr)) {
607                                 if ((sshdr.sense_key == UNIT_ATTENTION) &&
608                                     ((sshdr.asc == 0x28) ||
609                                      (sshdr.asc == 0x29)) &&
610                                     (sshdr.ascq == 0))
611                                         continue;
612                         }
613                 } else {
614                         /*
615                          * if nothing was transferred, we try
616                          * again. It's a workaround for some USB
617                          * devices.
618                          */
619                         if (resid == try_inquiry_len)
620                                 continue;
621                 }
622                 break;
623         }
624
625         if (result == 0) {
626                 sanitize_inquiry_string(&inq_result[8], 8);
627                 sanitize_inquiry_string(&inq_result[16], 16);
628                 sanitize_inquiry_string(&inq_result[32], 4);
629
630                 response_len = inq_result[4] + 5;
631                 if (response_len > 255)
632                         response_len = first_inquiry_len;       /* sanity */
633
634                 /*
635                  * Get any flags for this device.
636                  *
637                  * XXX add a bflags to scsi_device, and replace the
638                  * corresponding bit fields in scsi_device, so bflags
639                  * need not be passed as an argument.
640                  */
641                 *bflags = scsi_get_device_flags(sdev, &inq_result[8],
642                                 &inq_result[16]);
643
644                 /* When the first pass succeeds we gain information about
645                  * what larger transfer lengths might work. */
646                 if (pass == 1) {
647                         if (BLIST_INQUIRY_36 & *bflags)
648                                 next_inquiry_len = 36;
649                         else if (BLIST_INQUIRY_58 & *bflags)
650                                 next_inquiry_len = 58;
651                         else if (sdev->inquiry_len)
652                                 next_inquiry_len = sdev->inquiry_len;
653                         else
654                                 next_inquiry_len = response_len;
655
656                         /* If more data is available perform the second pass */
657                         if (next_inquiry_len > try_inquiry_len) {
658                                 try_inquiry_len = next_inquiry_len;
659                                 pass = 2;
660                                 goto next_pass;
661                         }
662                 }
663
664         } else if (pass == 2) {
665                 printk(KERN_INFO "scsi scan: %d byte inquiry failed.  "
666                                 "Consider BLIST_INQUIRY_36 for this device\n",
667                                 try_inquiry_len);
668
669                 /* If this pass failed, the third pass goes back and transfers
670                  * the same amount as we successfully got in the first pass. */
671                 try_inquiry_len = first_inquiry_len;
672                 pass = 3;
673                 goto next_pass;
674         }
675
676         /* If the last transfer attempt got an error, assume the
677          * peripheral doesn't exist or is dead. */
678         if (result)
679                 return -EIO;
680
681         /* Don't report any more data than the device says is valid */
682         sdev->inquiry_len = min(try_inquiry_len, response_len);
683
684         /*
685          * XXX Abort if the response length is less than 36? If less than
686          * 32, the lookup of the device flags (above) could be invalid,
687          * and it would be possible to take an incorrect action - we do
688          * not want to hang because of a short INQUIRY. On the flip side,
689          * if the device is spun down or becoming ready (and so it gives a
690          * short INQUIRY), an abort here prevents any further use of the
691          * device, including spin up.
692          *
693          * On the whole, the best approach seems to be to assume the first
694          * 36 bytes are valid no matter what the device says.  That's
695          * better than copying < 36 bytes to the inquiry-result buffer
696          * and displaying garbage for the Vendor, Product, or Revision
697          * strings.
698          */
699         if (sdev->inquiry_len < 36) {
700                 printk(KERN_INFO "scsi scan: INQUIRY result too short (%d),"
701                                 " using 36\n", sdev->inquiry_len);
702                 sdev->inquiry_len = 36;
703         }
704
705         /*
706          * Related to the above issue:
707          *
708          * XXX Devices (disk or all?) should be sent a TEST UNIT READY,
709          * and if not ready, sent a START_STOP to start (maybe spin up) and
710          * then send the INQUIRY again, since the INQUIRY can change after
711          * a device is initialized.
712          *
713          * Ideally, start a device if explicitly asked to do so.  This
714          * assumes that a device is spun up on power on, spun down on
715          * request, and then spun up on request.
716          */
717
718         /*
719          * The scanning code needs to know the scsi_level, even if no
720          * device is attached at LUN 0 (SCSI_SCAN_TARGET_PRESENT) so
721          * non-zero LUNs can be scanned.
722          */
723         sdev->scsi_level = inq_result[2] & 0x07;
724         if (sdev->scsi_level >= 2 ||
725             (sdev->scsi_level == 1 && (inq_result[3] & 0x0f) == 1))
726                 sdev->scsi_level++;
727         sdev->sdev_target->scsi_level = sdev->scsi_level;
728
729         return 0;
730 }
731
732 /**
733  * scsi_add_lun - allocate and fully initialze a scsi_device
734  * @sdev:       holds information to be stored in the new scsi_device
735  * @inq_result: holds the result of a previous INQUIRY to the LUN
736  * @bflags:     black/white list flag
737  * @async:      1 if this device is being scanned asynchronously
738  *
739  * Description:
740  *     Initialize the scsi_device @sdev.  Optionally set fields based
741  *     on values in *@bflags.
742  *
743  * Return:
744  *     SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device
745  *     SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized
746  **/
747 static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
748                 int *bflags, int async)
749 {
750         int ret;
751
752         /*
753          * XXX do not save the inquiry, since it can change underneath us,
754          * save just vendor/model/rev.
755          *
756          * Rather than save it and have an ioctl that retrieves the saved
757          * value, have an ioctl that executes the same INQUIRY code used
758          * in scsi_probe_lun, let user level programs doing INQUIRY
759          * scanning run at their own risk, or supply a user level program
760          * that can correctly scan.
761          */
762
763         /*
764          * Copy at least 36 bytes of INQUIRY data, so that we don't
765          * dereference unallocated memory when accessing the Vendor,
766          * Product, and Revision strings.  Badly behaved devices may set
767          * the INQUIRY Additional Length byte to a small value, indicating
768          * these strings are invalid, but often they contain plausible data
769          * nonetheless.  It doesn't matter if the device sent < 36 bytes
770          * total, since scsi_probe_lun() initializes inq_result with 0s.
771          */
772         sdev->inquiry = kmemdup(inq_result,
773                                 max_t(size_t, sdev->inquiry_len, 36),
774                                 GFP_ATOMIC);
775         if (sdev->inquiry == NULL)
776                 return SCSI_SCAN_NO_RESPONSE;
777
778         sdev->vendor = (char *) (sdev->inquiry + 8);
779         sdev->model = (char *) (sdev->inquiry + 16);
780         sdev->rev = (char *) (sdev->inquiry + 32);
781
782         if (*bflags & BLIST_ISROM) {
783                 sdev->type = TYPE_ROM;
784                 sdev->removable = 1;
785         } else {
786                 sdev->type = (inq_result[0] & 0x1f);
787                 sdev->removable = (inq_result[1] & 0x80) >> 7;
788         }
789
790         switch (sdev->type) {
791         case TYPE_RBC:
792         case TYPE_TAPE:
793         case TYPE_DISK:
794         case TYPE_PRINTER:
795         case TYPE_MOD:
796         case TYPE_PROCESSOR:
797         case TYPE_SCANNER:
798         case TYPE_MEDIUM_CHANGER:
799         case TYPE_ENCLOSURE:
800         case TYPE_COMM:
801         case TYPE_RAID:
802         case TYPE_OSD:
803                 sdev->writeable = 1;
804                 break;
805         case TYPE_ROM:
806         case TYPE_WORM:
807                 sdev->writeable = 0;
808                 break;
809         default:
810                 printk(KERN_INFO "scsi: unknown device type %d\n", sdev->type);
811         }
812
813         if (sdev->type == TYPE_RBC || sdev->type == TYPE_ROM) {
814                 /* RBC and MMC devices can return SCSI-3 compliance and yet
815                  * still not support REPORT LUNS, so make them act as
816                  * BLIST_NOREPORTLUN unless BLIST_REPORTLUN2 is
817                  * specifically set */
818                 if ((*bflags & BLIST_REPORTLUN2) == 0)
819                         *bflags |= BLIST_NOREPORTLUN;
820         }
821
822         /*
823          * For a peripheral qualifier (PQ) value of 1 (001b), the SCSI
824          * spec says: The device server is capable of supporting the
825          * specified peripheral device type on this logical unit. However,
826          * the physical device is not currently connected to this logical
827          * unit.
828          *
829          * The above is vague, as it implies that we could treat 001 and
830          * 011 the same. Stay compatible with previous code, and create a
831          * scsi_device for a PQ of 1
832          *
833          * Don't set the device offline here; rather let the upper
834          * level drivers eval the PQ to decide whether they should
835          * attach. So remove ((inq_result[0] >> 5) & 7) == 1 check.
836          */ 
837
838         sdev->inq_periph_qual = (inq_result[0] >> 5) & 7;
839         sdev->lockable = sdev->removable;
840         sdev->soft_reset = (inq_result[7] & 1) && ((inq_result[3] & 7) == 2);
841
842         if (sdev->scsi_level >= SCSI_3 ||
843                         (sdev->inquiry_len > 56 && inq_result[56] & 0x04))
844                 sdev->ppr = 1;
845         if (inq_result[7] & 0x60)
846                 sdev->wdtr = 1;
847         if (inq_result[7] & 0x10)
848                 sdev->sdtr = 1;
849
850         sdev_printk(KERN_NOTICE, sdev, "%s %.8s %.16s %.4s PQ: %d "
851                         "ANSI: %d%s\n", scsi_device_type(sdev->type),
852                         sdev->vendor, sdev->model, sdev->rev,
853                         sdev->inq_periph_qual, inq_result[2] & 0x07,
854                         (inq_result[3] & 0x0f) == 1 ? " CCS" : "");
855
856         if ((sdev->scsi_level >= SCSI_2) && (inq_result[7] & 2) &&
857             !(*bflags & BLIST_NOTQ))
858                 sdev->tagged_supported = 1;
859
860         /*
861          * Some devices (Texel CD ROM drives) have handshaking problems
862          * when used with the Seagate controllers. borken is initialized
863          * to 1, and then set it to 0 here.
864          */
865         if ((*bflags & BLIST_BORKEN) == 0)
866                 sdev->borken = 0;
867
868         if (*bflags & BLIST_NO_ULD_ATTACH)
869                 sdev->no_uld_attach = 1;
870
871         /*
872          * Apparently some really broken devices (contrary to the SCSI
873          * standards) need to be selected without asserting ATN
874          */
875         if (*bflags & BLIST_SELECT_NO_ATN)
876                 sdev->select_no_atn = 1;
877
878         /*
879          * Maximum 512 sector transfer length
880          * broken RA4x00 Compaq Disk Array
881          */
882         if (*bflags & BLIST_MAX_512)
883                 blk_queue_max_hw_sectors(sdev->request_queue, 512);
884
885         /*
886          * Some devices may not want to have a start command automatically
887          * issued when a device is added.
888          */
889         if (*bflags & BLIST_NOSTARTONADD)
890                 sdev->no_start_on_add = 1;
891
892         if (*bflags & BLIST_SINGLELUN)
893                 scsi_target(sdev)->single_lun = 1;
894
895         sdev->use_10_for_rw = 1;
896
897         if (*bflags & BLIST_MS_SKIP_PAGE_08)
898                 sdev->skip_ms_page_8 = 1;
899
900         if (*bflags & BLIST_MS_SKIP_PAGE_3F)
901                 sdev->skip_ms_page_3f = 1;
902
903         if (*bflags & BLIST_USE_10_BYTE_MS)
904                 sdev->use_10_for_ms = 1;
905
906         /* set the device running here so that slave configure
907          * may do I/O */
908         ret = scsi_device_set_state(sdev, SDEV_RUNNING);
909         if (ret) {
910                 ret = scsi_device_set_state(sdev, SDEV_BLOCK);
911
912                 if (ret) {
913                         sdev_printk(KERN_ERR, sdev,
914                                     "in wrong state %s to complete scan\n",
915                                     scsi_device_state_name(sdev->sdev_state));
916                         return SCSI_SCAN_NO_RESPONSE;
917                 }
918         }
919
920         if (*bflags & BLIST_MS_192_BYTES_FOR_3F)
921                 sdev->use_192_bytes_for_3f = 1;
922
923         if (*bflags & BLIST_NOT_LOCKABLE)
924                 sdev->lockable = 0;
925
926         if (*bflags & BLIST_RETRY_HWERROR)
927                 sdev->retry_hwerror = 1;
928
929         transport_configure_device(&sdev->sdev_gendev);
930
931         if (sdev->host->hostt->slave_configure) {
932                 ret = sdev->host->hostt->slave_configure(sdev);
933                 if (ret) {
934                         /*
935                          * if LLDD reports slave not present, don't clutter
936                          * console with alloc failure messages
937                          */
938                         if (ret != -ENXIO) {
939                                 sdev_printk(KERN_ERR, sdev,
940                                         "failed to configure device\n");
941                         }
942                         return SCSI_SCAN_NO_RESPONSE;
943                 }
944         }
945
946         sdev->max_queue_depth = sdev->queue_depth;
947
948         /*
949          * Ok, the device is now all set up, we can
950          * register it and tell the rest of the kernel
951          * about it.
952          */
953         if (!async && scsi_sysfs_add_sdev(sdev) != 0)
954                 return SCSI_SCAN_NO_RESPONSE;
955
956         return SCSI_SCAN_LUN_PRESENT;
957 }
958
959 #ifdef CONFIG_SCSI_LOGGING
960 /** 
961  * scsi_inq_str - print INQUIRY data from min to max index, strip trailing whitespace
962  * @buf:   Output buffer with at least end-first+1 bytes of space
963  * @inq:   Inquiry buffer (input)
964  * @first: Offset of string into inq
965  * @end:   Index after last character in inq
966  */
967 static unsigned char *scsi_inq_str(unsigned char *buf, unsigned char *inq,
968                                    unsigned first, unsigned end)
969 {
970         unsigned term = 0, idx;
971
972         for (idx = 0; idx + first < end && idx + first < inq[4] + 5; idx++) {
973                 if (inq[idx+first] > ' ') {
974                         buf[idx] = inq[idx+first];
975                         term = idx+1;
976                 } else {
977                         buf[idx] = ' ';
978                 }
979         }
980         buf[term] = 0;
981         return buf;
982 }
983 #endif
984
985 /**
986  * scsi_probe_and_add_lun - probe a LUN, if a LUN is found add it
987  * @starget:    pointer to target device structure
988  * @lun:        LUN of target device
989  * @bflagsp:    store bflags here if not NULL
990  * @sdevp:      probe the LUN corresponding to this scsi_device
991  * @rescan:     if nonzero skip some code only needed on first scan
992  * @hostdata:   passed to scsi_alloc_sdev()
993  *
994  * Description:
995  *     Call scsi_probe_lun, if a LUN with an attached device is found,
996  *     allocate and set it up by calling scsi_add_lun.
997  *
998  * Return:
999  *     SCSI_SCAN_NO_RESPONSE: could not allocate or setup a scsi_device
1000  *     SCSI_SCAN_TARGET_PRESENT: target responded, but no device is
1001  *         attached at the LUN
1002  *     SCSI_SCAN_LUN_PRESENT: a new scsi_device was allocated and initialized
1003  **/
1004 static int scsi_probe_and_add_lun(struct scsi_target *starget,
1005                                   uint lun, int *bflagsp,
1006                                   struct scsi_device **sdevp, int rescan,
1007                                   void *hostdata)
1008 {
1009         struct scsi_device *sdev;
1010         unsigned char *result;
1011         int bflags, res = SCSI_SCAN_NO_RESPONSE, result_len = 256;
1012         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1013
1014         /*
1015          * The rescan flag is used as an optimization, the first scan of a
1016          * host adapter calls into here with rescan == 0.
1017          */
1018         sdev = scsi_device_lookup_by_target(starget, lun);
1019         if (sdev) {
1020                 if (rescan || !scsi_device_created(sdev)) {
1021                         SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO
1022                                 "scsi scan: device exists on %s\n",
1023                                 dev_name(&sdev->sdev_gendev)));
1024                         if (sdevp)
1025                                 *sdevp = sdev;
1026                         else
1027                                 scsi_device_put(sdev);
1028
1029                         if (bflagsp)
1030                                 *bflagsp = scsi_get_device_flags(sdev,
1031                                                                  sdev->vendor,
1032                                                                  sdev->model);
1033                         return SCSI_SCAN_LUN_PRESENT;
1034                 }
1035                 scsi_device_put(sdev);
1036         } else
1037                 sdev = scsi_alloc_sdev(starget, lun, hostdata);
1038         if (!sdev)
1039                 goto out;
1040
1041         result = kmalloc(result_len, GFP_ATOMIC |
1042                         ((shost->unchecked_isa_dma) ? __GFP_DMA : 0));
1043         if (!result)
1044                 goto out_free_sdev;
1045
1046         if (scsi_probe_lun(sdev, result, result_len, &bflags))
1047                 goto out_free_result;
1048
1049         if (bflagsp)
1050                 *bflagsp = bflags;
1051         /*
1052          * result contains valid SCSI INQUIRY data.
1053          */
1054         if (((result[0] >> 5) == 3) && !(bflags & BLIST_ATTACH_PQ3)) {
1055                 /*
1056                  * For a Peripheral qualifier 3 (011b), the SCSI
1057                  * spec says: The device server is not capable of
1058                  * supporting a physical device on this logical
1059                  * unit.
1060                  *
1061                  * For disks, this implies that there is no
1062                  * logical disk configured at sdev->lun, but there
1063                  * is a target id responding.
1064                  */
1065                 SCSI_LOG_SCAN_BUS(2, sdev_printk(KERN_INFO, sdev, "scsi scan:"
1066                                    " peripheral qualifier of 3, device not"
1067                                    " added\n"))
1068                 if (lun == 0) {
1069                         SCSI_LOG_SCAN_BUS(1, {
1070                                 unsigned char vend[9];
1071                                 unsigned char mod[17];
1072
1073                                 sdev_printk(KERN_INFO, sdev,
1074                                         "scsi scan: consider passing scsi_mod."
1075                                         "dev_flags=%s:%s:0x240 or 0x1000240\n",
1076                                         scsi_inq_str(vend, result, 8, 16),
1077                                         scsi_inq_str(mod, result, 16, 32));
1078                         });
1079
1080                 }
1081
1082                 res = SCSI_SCAN_TARGET_PRESENT;
1083                 goto out_free_result;
1084         }
1085
1086         /*
1087          * Some targets may set slight variations of PQ and PDT to signal
1088          * that no LUN is present, so don't add sdev in these cases.
1089          * Two specific examples are:
1090          * 1) NetApp targets: return PQ=1, PDT=0x1f
1091          * 2) USB UFI: returns PDT=0x1f, with the PQ bits being "reserved"
1092          *    in the UFI 1.0 spec (we cannot rely on reserved bits).
1093          *
1094          * References:
1095          * 1) SCSI SPC-3, pp. 145-146
1096          * PQ=1: "A peripheral device having the specified peripheral
1097          * device type is not connected to this logical unit. However, the
1098          * device server is capable of supporting the specified peripheral
1099          * device type on this logical unit."
1100          * PDT=0x1f: "Unknown or no device type"
1101          * 2) USB UFI 1.0, p. 20
1102          * PDT=00h Direct-access device (floppy)
1103          * PDT=1Fh none (no FDD connected to the requested logical unit)
1104          */
1105         if (((result[0] >> 5) == 1 || starget->pdt_1f_for_no_lun) &&
1106             (result[0] & 0x1f) == 0x1f &&
1107             !scsi_is_wlun(lun)) {
1108                 SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO
1109                                         "scsi scan: peripheral device type"
1110                                         " of 31, no device added\n"));
1111                 res = SCSI_SCAN_TARGET_PRESENT;
1112                 goto out_free_result;
1113         }
1114
1115         res = scsi_add_lun(sdev, result, &bflags, shost->async_scan);
1116         if (res == SCSI_SCAN_LUN_PRESENT) {
1117                 if (bflags & BLIST_KEY) {
1118                         sdev->lockable = 0;
1119                         scsi_unlock_floptical(sdev, result);
1120                 }
1121         }
1122
1123  out_free_result:
1124         kfree(result);
1125  out_free_sdev:
1126         if (res == SCSI_SCAN_LUN_PRESENT) {
1127                 if (sdevp) {
1128                         if (scsi_device_get(sdev) == 0) {
1129                                 *sdevp = sdev;
1130                         } else {
1131                                 __scsi_remove_device(sdev);
1132                                 res = SCSI_SCAN_NO_RESPONSE;
1133                         }
1134                 }
1135         } else
1136                 __scsi_remove_device(sdev);
1137  out:
1138         return res;
1139 }
1140
1141 /**
1142  * scsi_sequential_lun_scan - sequentially scan a SCSI target
1143  * @starget:    pointer to target structure to scan
1144  * @bflags:     black/white list flag for LUN 0
1145  * @scsi_level: Which version of the standard does this device adhere to
1146  * @rescan:     passed to scsi_probe_add_lun()
1147  *
1148  * Description:
1149  *     Generally, scan from LUN 1 (LUN 0 is assumed to already have been
1150  *     scanned) to some maximum lun until a LUN is found with no device
1151  *     attached. Use the bflags to figure out any oddities.
1152  *
1153  *     Modifies sdevscan->lun.
1154  **/
1155 static void scsi_sequential_lun_scan(struct scsi_target *starget,
1156                                      int bflags, int scsi_level, int rescan)
1157 {
1158         unsigned int sparse_lun, lun, max_dev_lun;
1159         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
1160
1161         SCSI_LOG_SCAN_BUS(3, printk(KERN_INFO "scsi scan: Sequential scan of"
1162                                     "%s\n", dev_name(&starget->dev)));
1163
1164         max_dev_lun = min(max_scsi_luns, shost->max_lun);
1165         /*
1166          * If this device is known to support sparse multiple units,
1167          * override the other settings, and scan all of them. Normally,
1168          * SCSI-3 devices should be scanned via the REPORT LUNS.
1169          */
1170         if (bflags & BLIST_SPARSELUN) {
1171                 max_dev_lun = shost->max_lun;
1172                 sparse_lun = 1;
1173         } else
1174                 sparse_lun = 0;
1175
1176         /*
1177          * If less than SCSI_1_CSS, and no special lun scaning, stop
1178          * scanning; this matches 2.4 behaviour, but could just be a bug
1179          * (to continue scanning a SCSI_1_CSS device).
1180          *
1181          * This test is broken.  We might not have any device on lun0 for
1182          * a sparselun device, and if that's the case then how would we
1183          * know the real scsi_level, eh?  It might make sense to just not
1184          * scan any SCSI_1 device for non-0 luns, but that check would best
1185          * go into scsi_alloc_sdev() and just have it return null when asked
1186          * to alloc an sdev for lun > 0 on an already found SCSI_1 device.
1187          *
1188         if ((sdevscan->scsi_level < SCSI_1_CCS) &&
1189             ((bflags & (BLIST_FORCELUN | BLIST_SPARSELUN | BLIST_MAX5LUN))
1190              == 0))
1191                 return;
1192          */
1193         /*
1194          * If this device is known to support multiple units, override
1195          * the other settings, and scan all of them.
1196          */
1197         if (bflags & BLIST_FORCELUN)
1198                 max_dev_lun = shost->max_lun;
1199         /*
1200          * REGAL CDC-4X: avoid hang after LUN 4
1201          */
1202         if (bflags & BLIST_MAX5LUN)
1203                 max_dev_lun = min(5U, max_dev_lun);
1204         /*
1205          * Do not scan SCSI-2 or lower device past LUN 7, unless
1206          * BLIST_LARGELUN.
1207          */
1208         if (scsi_level < SCSI_3 && !(bflags & BLIST_LARGELUN))
1209                 max_dev_lun = min(8U, max_dev_lun);
1210
1211         /*
1212          * We have already scanned LUN 0, so start at LUN 1. Keep scanning
1213          * until we reach the max, or no LUN is found and we are not
1214          * sparse_lun.
1215          */
1216         for (lun = 1; lun < max_dev_lun; ++lun)
1217                 if ((scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan,
1218                                             NULL) != SCSI_SCAN_LUN_PRESENT) &&
1219                     !sparse_lun)
1220                         return;
1221 }
1222
1223 /**
1224  * scsilun_to_int: convert a scsi_lun to an int
1225  * @scsilun:    struct scsi_lun to be converted.
1226  *
1227  * Description:
1228  *     Convert @scsilun from a struct scsi_lun to a four byte host byte-ordered
1229  *     integer, and return the result. The caller must check for
1230  *     truncation before using this function.
1231  *
1232  * Notes:
1233  *     The struct scsi_lun is assumed to be four levels, with each level
1234  *     effectively containing a SCSI byte-ordered (big endian) short; the
1235  *     addressing bits of each level are ignored (the highest two bits).
1236  *     For a description of the LUN format, post SCSI-3 see the SCSI
1237  *     Architecture Model, for SCSI-3 see the SCSI Controller Commands.
1238  *
1239  *     Given a struct scsi_lun of: 0a 04 0b 03 00 00 00 00, this function returns
1240  *     the integer: 0x0b030a04
1241  **/
1242 int scsilun_to_int(struct scsi_lun *scsilun)
1243 {
1244         int i;
1245         unsigned int lun;
1246
1247         lun = 0;
1248         for (i = 0; i < sizeof(lun); i += 2)
1249                 lun = lun | (((scsilun->scsi_lun[i] << 8) |
1250                               scsilun->scsi_lun[i + 1]) << (i * 8));
1251         return lun;
1252 }
1253 EXPORT_SYMBOL(scsilun_to_int);
1254
1255 /**
1256  * int_to_scsilun: reverts an int into a scsi_lun
1257  * @lun:        integer to be reverted
1258  * @scsilun:    struct scsi_lun to be set.
1259  *
1260  * Description:
1261  *     Reverts the functionality of the scsilun_to_int, which packed
1262  *     an 8-byte lun value into an int. This routine unpacks the int
1263  *     back into the lun value.
1264  *     Note: the scsilun_to_int() routine does not truly handle all
1265  *     8bytes of the lun value. This functions restores only as much
1266  *     as was set by the routine.
1267  *
1268  * Notes:
1269  *     Given an integer : 0x0b030a04,  this function returns a
1270  *     scsi_lun of : struct scsi_lun of: 0a 04 0b 03 00 00 00 00
1271  *
1272  **/
1273 void int_to_scsilun(unsigned int lun, struct scsi_lun *scsilun)
1274 {
1275         int i;
1276
1277         memset(scsilun->scsi_lun, 0, sizeof(scsilun->scsi_lun));
1278
1279         for (i = 0; i < sizeof(lun); i += 2) {
1280                 scsilun->scsi_lun[i] = (lun >> 8) & 0xFF;
1281                 scsilun->scsi_lun[i+1] = lun & 0xFF;
1282                 lun = lun >> 16;
1283         }
1284 }
1285 EXPORT_SYMBOL(int_to_scsilun);
1286
1287 /**
1288  * scsi_report_lun_scan - Scan using SCSI REPORT LUN results
1289  * @starget: which target
1290  * @bflags: Zero or a mix of BLIST_NOLUN, BLIST_REPORTLUN2, or BLIST_NOREPORTLUN
1291  * @rescan: nonzero if we can skip code only needed on first scan
1292  *
1293  * Description:
1294  *   Fast scanning for modern (SCSI-3) devices by sending a REPORT LUN command.
1295  *   Scan the resulting list of LUNs by calling scsi_probe_and_add_lun.
1296  *
1297  *   If BLINK_REPORTLUN2 is set, scan a target that supports more than 8
1298  *   LUNs even if it's older than SCSI-3.
1299  *   If BLIST_NOREPORTLUN is set, return 1 always.
1300  *   If BLIST_NOLUN is set, return 0 always.
1301  *
1302  * Return:
1303  *     0: scan completed (or no memory, so further scanning is futile)
1304  *     1: could not scan with REPORT LUN
1305  **/
1306 static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
1307                                 int rescan)
1308 {
1309         char devname[64];
1310         unsigned char scsi_cmd[MAX_COMMAND_SIZE];
1311         unsigned int length;
1312         unsigned int lun;
1313         unsigned int num_luns;
1314         unsigned int retries;
1315         int result;
1316         struct scsi_lun *lunp, *lun_data;
1317         u8 *data;
1318         struct scsi_sense_hdr sshdr;
1319         struct scsi_device *sdev;
1320         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
1321         int ret = 0;
1322
1323         /*
1324          * Only support SCSI-3 and up devices if BLIST_NOREPORTLUN is not set.
1325          * Also allow SCSI-2 if BLIST_REPORTLUN2 is set and host adapter does
1326          * support more than 8 LUNs.
1327          */
1328         if (bflags & BLIST_NOREPORTLUN)
1329                 return 1;
1330         if (starget->scsi_level < SCSI_2 &&
1331             starget->scsi_level != SCSI_UNKNOWN)
1332                 return 1;
1333         if (starget->scsi_level < SCSI_3 &&
1334             (!(bflags & BLIST_REPORTLUN2) || shost->max_lun <= 8))
1335                 return 1;
1336         if (bflags & BLIST_NOLUN)
1337                 return 0;
1338
1339         if (!(sdev = scsi_device_lookup_by_target(starget, 0))) {
1340                 sdev = scsi_alloc_sdev(starget, 0, NULL);
1341                 if (!sdev)
1342                         return 0;
1343                 if (scsi_device_get(sdev)) {
1344                         __scsi_remove_device(sdev);
1345                         return 0;
1346                 }
1347         }
1348
1349         sprintf(devname, "host %d channel %d id %d",
1350                 shost->host_no, sdev->channel, sdev->id);
1351
1352         /*
1353          * Allocate enough to hold the header (the same size as one scsi_lun)
1354          * plus the max number of luns we are requesting.
1355          *
1356          * Reallocating and trying again (with the exact amount we need)
1357          * would be nice, but then we need to somehow limit the size
1358          * allocated based on the available memory and the limits of
1359          * kmalloc - we don't want a kmalloc() failure of a huge value to
1360          * prevent us from finding any LUNs on this target.
1361          */
1362         length = (max_scsi_report_luns + 1) * sizeof(struct scsi_lun);
1363         lun_data = kmalloc(length, GFP_ATOMIC |
1364                            (sdev->host->unchecked_isa_dma ? __GFP_DMA : 0));
1365         if (!lun_data) {
1366                 printk(ALLOC_FAILURE_MSG, __func__);
1367                 goto out;
1368         }
1369
1370         scsi_cmd[0] = REPORT_LUNS;
1371
1372         /*
1373          * bytes 1 - 5: reserved, set to zero.
1374          */
1375         memset(&scsi_cmd[1], 0, 5);
1376
1377         /*
1378          * bytes 6 - 9: length of the command.
1379          */
1380         scsi_cmd[6] = (unsigned char) (length >> 24) & 0xff;
1381         scsi_cmd[7] = (unsigned char) (length >> 16) & 0xff;
1382         scsi_cmd[8] = (unsigned char) (length >> 8) & 0xff;
1383         scsi_cmd[9] = (unsigned char) length & 0xff;
1384
1385         scsi_cmd[10] = 0;       /* reserved */
1386         scsi_cmd[11] = 0;       /* control */
1387
1388         /*
1389          * We can get a UNIT ATTENTION, for example a power on/reset, so
1390          * retry a few times (like sd.c does for TEST UNIT READY).
1391          * Experience shows some combinations of adapter/devices get at
1392          * least two power on/resets.
1393          *
1394          * Illegal requests (for devices that do not support REPORT LUNS)
1395          * should come through as a check condition, and will not generate
1396          * a retry.
1397          */
1398         for (retries = 0; retries < 3; retries++) {
1399                 SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: Sending"
1400                                 " REPORT LUNS to %s (try %d)\n", devname,
1401                                 retries));
1402
1403                 result = scsi_execute_req(sdev, scsi_cmd, DMA_FROM_DEVICE,
1404                                           lun_data, length, &sshdr,
1405                                           SCSI_TIMEOUT + 4 * HZ, 3, NULL);
1406
1407                 SCSI_LOG_SCAN_BUS(3, printk (KERN_INFO "scsi scan: REPORT LUNS"
1408                                 " %s (try %d) result 0x%x\n", result
1409                                 ?  "failed" : "successful", retries, result));
1410                 if (result == 0)
1411                         break;
1412                 else if (scsi_sense_valid(&sshdr)) {
1413                         if (sshdr.sense_key != UNIT_ATTENTION)
1414                                 break;
1415                 }
1416         }
1417
1418         if (result) {
1419                 /*
1420                  * The device probably does not support a REPORT LUN command
1421                  */
1422                 ret = 1;
1423                 goto out_err;
1424         }
1425
1426         /*
1427          * Get the length from the first four bytes of lun_data.
1428          */
1429         data = (u8 *) lun_data->scsi_lun;
1430         length = ((data[0] << 24) | (data[1] << 16) |
1431                   (data[2] << 8) | (data[3] << 0));
1432
1433         num_luns = (length / sizeof(struct scsi_lun));
1434         if (num_luns > max_scsi_report_luns) {
1435                 printk(KERN_WARNING "scsi: On %s only %d (max_scsi_report_luns)"
1436                        " of %d luns reported, try increasing"
1437                        " max_scsi_report_luns.\n", devname,
1438                        max_scsi_report_luns, num_luns);
1439                 num_luns = max_scsi_report_luns;
1440         }
1441
1442         SCSI_LOG_SCAN_BUS(3, sdev_printk (KERN_INFO, sdev,
1443                 "scsi scan: REPORT LUN scan\n"));
1444
1445         /*
1446          * Scan the luns in lun_data. The entry at offset 0 is really
1447          * the header, so start at 1 and go up to and including num_luns.
1448          */
1449         for (lunp = &lun_data[1]; lunp <= &lun_data[num_luns]; lunp++) {
1450                 lun = scsilun_to_int(lunp);
1451
1452                 /*
1453                  * Check if the unused part of lunp is non-zero, and so
1454                  * does not fit in lun.
1455                  */
1456                 if (memcmp(&lunp->scsi_lun[sizeof(lun)], "\0\0\0\0", 4)) {
1457                         int i;
1458
1459                         /*
1460                          * Output an error displaying the LUN in byte order,
1461                          * this differs from what linux would print for the
1462                          * integer LUN value.
1463                          */
1464                         printk(KERN_WARNING "scsi: %s lun 0x", devname);
1465                         data = (char *)lunp->scsi_lun;
1466                         for (i = 0; i < sizeof(struct scsi_lun); i++)
1467                                 printk("%02x", data[i]);
1468                         printk(" has a LUN larger than currently supported.\n");
1469                 } else if (lun > sdev->host->max_lun) {
1470                         printk(KERN_WARNING "scsi: %s lun%d has a LUN larger"
1471                                " than allowed by the host adapter\n",
1472                                devname, lun);
1473                 } else {
1474                         int res;
1475
1476                         res = scsi_probe_and_add_lun(starget,
1477                                 lun, NULL, NULL, rescan, NULL);
1478                         if (res == SCSI_SCAN_NO_RESPONSE) {
1479                                 /*
1480                                  * Got some results, but now none, abort.
1481                                  */
1482                                 sdev_printk(KERN_ERR, sdev,
1483                                         "Unexpected response"
1484                                         " from lun %d while scanning, scan"
1485                                         " aborted\n", lun);
1486                                 break;
1487                         }
1488                 }
1489         }
1490
1491  out_err:
1492         kfree(lun_data);
1493  out:
1494         scsi_device_put(sdev);
1495         if (scsi_device_created(sdev))
1496                 /*
1497                  * the sdev we used didn't appear in the report luns scan
1498                  */
1499                 __scsi_remove_device(sdev);
1500         return ret;
1501 }
1502
1503 struct scsi_device *__scsi_add_device(struct Scsi_Host *shost, uint channel,
1504                                       uint id, uint lun, void *hostdata)
1505 {
1506         struct scsi_device *sdev = ERR_PTR(-ENODEV);
1507         struct device *parent = &shost->shost_gendev;
1508         struct scsi_target *starget;
1509
1510         if (strncmp(scsi_scan_type, "none", 4) == 0)
1511                 return ERR_PTR(-ENODEV);
1512
1513         starget = scsi_alloc_target(parent, channel, id);
1514         if (!starget)
1515                 return ERR_PTR(-ENOMEM);
1516
1517         mutex_lock(&shost->scan_mutex);
1518         if (!shost->async_scan)
1519                 scsi_complete_async_scans();
1520
1521         if (scsi_host_scan_allowed(shost))
1522                 scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);
1523         mutex_unlock(&shost->scan_mutex);
1524         scsi_target_reap(starget);
1525         put_device(&starget->dev);
1526
1527         return sdev;
1528 }
1529 EXPORT_SYMBOL(__scsi_add_device);
1530
1531 int scsi_add_device(struct Scsi_Host *host, uint channel,
1532                     uint target, uint lun)
1533 {
1534         struct scsi_device *sdev = 
1535                 __scsi_add_device(host, channel, target, lun, NULL);
1536         if (IS_ERR(sdev))
1537                 return PTR_ERR(sdev);
1538
1539         scsi_device_put(sdev);
1540         return 0;
1541 }
1542 EXPORT_SYMBOL(scsi_add_device);
1543
1544 void scsi_rescan_device(struct device *dev)
1545 {
1546         struct scsi_driver *drv;
1547         
1548         if (!dev->driver)
1549                 return;
1550
1551         drv = to_scsi_driver(dev->driver);
1552         if (try_module_get(drv->owner)) {
1553                 if (drv->rescan)
1554                         drv->rescan(dev);
1555                 module_put(drv->owner);
1556         }
1557 }
1558 EXPORT_SYMBOL(scsi_rescan_device);
1559
1560 static void __scsi_scan_target(struct device *parent, unsigned int channel,
1561                 unsigned int id, unsigned int lun, int rescan)
1562 {
1563         struct Scsi_Host *shost = dev_to_shost(parent);
1564         int bflags = 0;
1565         int res;
1566         struct scsi_target *starget;
1567
1568         if (shost->this_id == id)
1569                 /*
1570                  * Don't scan the host adapter
1571                  */
1572                 return;
1573
1574         starget = scsi_alloc_target(parent, channel, id);
1575         if (!starget)
1576                 return;
1577
1578         if (lun != SCAN_WILD_CARD) {
1579                 /*
1580                  * Scan for a specific host/chan/id/lun.
1581                  */
1582                 scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL);
1583                 goto out_reap;
1584         }
1585
1586         /*
1587          * Scan LUN 0, if there is some response, scan further. Ideally, we
1588          * would not configure LUN 0 until all LUNs are scanned.
1589          */
1590         res = scsi_probe_and_add_lun(starget, 0, &bflags, NULL, rescan, NULL);
1591         if (res == SCSI_SCAN_LUN_PRESENT || res == SCSI_SCAN_TARGET_PRESENT) {
1592                 if (scsi_report_lun_scan(starget, bflags, rescan) != 0)
1593                         /*
1594                          * The REPORT LUN did not scan the target,
1595                          * do a sequential scan.
1596                          */
1597                         scsi_sequential_lun_scan(starget, bflags,
1598                                                  starget->scsi_level, rescan);
1599         }
1600
1601  out_reap:
1602         /* now determine if the target has any children at all
1603          * and if not, nuke it */
1604         scsi_target_reap(starget);
1605
1606         put_device(&starget->dev);
1607 }
1608
1609 /**
1610  * scsi_scan_target - scan a target id, possibly including all LUNs on the target.
1611  * @parent:     host to scan
1612  * @channel:    channel to scan
1613  * @id:         target id to scan
1614  * @lun:        Specific LUN to scan or SCAN_WILD_CARD
1615  * @rescan:     passed to LUN scanning routines
1616  *
1617  * Description:
1618  *     Scan the target id on @parent, @channel, and @id. Scan at least LUN 0,
1619  *     and possibly all LUNs on the target id.
1620  *
1621  *     First try a REPORT LUN scan, if that does not scan the target, do a
1622  *     sequential scan of LUNs on the target id.
1623  **/
1624 void scsi_scan_target(struct device *parent, unsigned int channel,
1625                       unsigned int id, unsigned int lun, int rescan)
1626 {
1627         struct Scsi_Host *shost = dev_to_shost(parent);
1628
1629         if (strncmp(scsi_scan_type, "none", 4) == 0)
1630                 return;
1631
1632         mutex_lock(&shost->scan_mutex);
1633         if (!shost->async_scan)
1634                 scsi_complete_async_scans();
1635
1636         if (scsi_host_scan_allowed(shost))
1637                 __scsi_scan_target(parent, channel, id, lun, rescan);
1638         mutex_unlock(&shost->scan_mutex);
1639 }
1640 EXPORT_SYMBOL(scsi_scan_target);
1641
1642 static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel,
1643                               unsigned int id, unsigned int lun, int rescan)
1644 {
1645         uint order_id;
1646
1647         if (id == SCAN_WILD_CARD)
1648                 for (id = 0; id < shost->max_id; ++id) {
1649                         /*
1650                          * XXX adapter drivers when possible (FCP, iSCSI)
1651                          * could modify max_id to match the current max,
1652                          * not the absolute max.
1653                          *
1654                          * XXX add a shost id iterator, so for example,
1655                          * the FC ID can be the same as a target id
1656                          * without a huge overhead of sparse id's.
1657                          */
1658                         if (shost->reverse_ordering)
1659                                 /*
1660                                  * Scan from high to low id.
1661                                  */
1662                                 order_id = shost->max_id - id - 1;
1663                         else
1664                                 order_id = id;
1665                         __scsi_scan_target(&shost->shost_gendev, channel,
1666                                         order_id, lun, rescan);
1667                 }
1668         else
1669                 __scsi_scan_target(&shost->shost_gendev, channel,
1670                                 id, lun, rescan);
1671 }
1672
1673 int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,
1674                             unsigned int id, unsigned int lun, int rescan)
1675 {
1676         SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,
1677                 "%s: <%u:%u:%u>\n",
1678                 __func__, channel, id, lun));
1679
1680         if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||
1681             ((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||
1682             ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun)))
1683                 return -EINVAL;
1684
1685         mutex_lock(&shost->scan_mutex);
1686         if (!shost->async_scan)
1687                 scsi_complete_async_scans();
1688
1689         if (scsi_host_scan_allowed(shost)) {
1690                 if (channel == SCAN_WILD_CARD)
1691                         for (channel = 0; channel <= shost->max_channel;
1692                              channel++)
1693                                 scsi_scan_channel(shost, channel, id, lun,
1694                                                   rescan);
1695                 else
1696                         scsi_scan_channel(shost, channel, id, lun, rescan);
1697         }
1698         mutex_unlock(&shost->scan_mutex);
1699
1700         return 0;
1701 }
1702
1703 static void scsi_sysfs_add_devices(struct Scsi_Host *shost)
1704 {
1705         struct scsi_device *sdev;
1706         shost_for_each_device(sdev, shost) {
1707                 if (!scsi_host_scan_allowed(shost) ||
1708                     scsi_sysfs_add_sdev(sdev) != 0)
1709                         __scsi_remove_device(sdev);
1710         }
1711 }
1712
1713 /**
1714  * scsi_prep_async_scan - prepare for an async scan
1715  * @shost: the host which will be scanned
1716  * Returns: a cookie to be passed to scsi_finish_async_scan()
1717  *
1718  * Tells the midlayer this host is going to do an asynchronous scan.
1719  * It reserves the host's position in the scanning list and ensures
1720  * that other asynchronous scans started after this one won't affect the
1721  * ordering of the discovered devices.
1722  */
1723 static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost)
1724 {
1725         struct async_scan_data *data;
1726         unsigned long flags;
1727
1728         if (strncmp(scsi_scan_type, "sync", 4) == 0)
1729                 return NULL;
1730
1731         if (shost->async_scan) {
1732                 printk("%s called twice for host %d", __func__,
1733                                 shost->host_no);
1734                 dump_stack();
1735                 return NULL;
1736         }
1737
1738         data = kmalloc(sizeof(*data), GFP_KERNEL);
1739         if (!data)
1740                 goto err;
1741         data->shost = scsi_host_get(shost);
1742         if (!data->shost)
1743                 goto err;
1744         init_completion(&data->prev_finished);
1745
1746         mutex_lock(&shost->scan_mutex);
1747         spin_lock_irqsave(shost->host_lock, flags);
1748         shost->async_scan = 1;
1749         spin_unlock_irqrestore(shost->host_lock, flags);
1750         mutex_unlock(&shost->scan_mutex);
1751
1752         spin_lock(&async_scan_lock);
1753         if (list_empty(&scanning_hosts))
1754                 complete(&data->prev_finished);
1755         list_add_tail(&data->list, &scanning_hosts);
1756         spin_unlock(&async_scan_lock);
1757
1758         return data;
1759
1760  err:
1761         kfree(data);
1762         return NULL;
1763 }
1764
1765 /**
1766  * scsi_finish_async_scan - asynchronous scan has finished
1767  * @data: cookie returned from earlier call to scsi_prep_async_scan()
1768  *
1769  * All the devices currently attached to this host have been found.
1770  * This function announces all the devices it has found to the rest
1771  * of the system.
1772  */
1773 static void scsi_finish_async_scan(struct async_scan_data *data)
1774 {
1775         struct Scsi_Host *shost;
1776         unsigned long flags;
1777
1778         if (!data)
1779                 return;
1780
1781         shost = data->shost;
1782
1783         mutex_lock(&shost->scan_mutex);
1784
1785         if (!shost->async_scan) {
1786                 printk("%s called twice for host %d", __func__,
1787                                 shost->host_no);
1788                 dump_stack();
1789                 mutex_unlock(&shost->scan_mutex);
1790                 return;
1791         }
1792
1793         wait_for_completion(&data->prev_finished);
1794
1795         scsi_sysfs_add_devices(shost);
1796
1797         spin_lock_irqsave(shost->host_lock, flags);
1798         shost->async_scan = 0;
1799         spin_unlock_irqrestore(shost->host_lock, flags);
1800
1801         mutex_unlock(&shost->scan_mutex);
1802
1803         spin_lock(&async_scan_lock);
1804         list_del(&data->list);
1805         if (!list_empty(&scanning_hosts)) {
1806                 struct async_scan_data *next = list_entry(scanning_hosts.next,
1807                                 struct async_scan_data, list);
1808                 complete(&next->prev_finished);
1809         }
1810         spin_unlock(&async_scan_lock);
1811
1812         scsi_host_put(shost);
1813         kfree(data);
1814 }
1815
1816 static void do_scsi_scan_host(struct Scsi_Host *shost)
1817 {
1818         if (shost->hostt->scan_finished) {
1819                 unsigned long start = jiffies;
1820                 if (shost->hostt->scan_start)
1821                         shost->hostt->scan_start(shost);
1822
1823                 while (!shost->hostt->scan_finished(shost, jiffies - start))
1824                         msleep(10);
1825         } else {
1826                 scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD,
1827                                 SCAN_WILD_CARD, 0);
1828         }
1829 }
1830
1831 static int do_scan_async(void *_data)
1832 {
1833         struct async_scan_data *data = _data;
1834         do_scsi_scan_host(data->shost);
1835         scsi_finish_async_scan(data);
1836         return 0;
1837 }
1838
1839 /**
1840  * scsi_scan_host - scan the given adapter
1841  * @shost:      adapter to scan
1842  **/
1843 void scsi_scan_host(struct Scsi_Host *shost)
1844 {
1845         struct task_struct *p;
1846         struct async_scan_data *data;
1847
1848         if (strncmp(scsi_scan_type, "none", 4) == 0)
1849                 return;
1850
1851         data = scsi_prep_async_scan(shost);
1852         if (!data) {
1853                 do_scsi_scan_host(shost);
1854                 return;
1855         }
1856
1857         p = kthread_run(do_scan_async, data, "scsi_scan_%d", shost->host_no);
1858         if (IS_ERR(p))
1859                 do_scan_async(data);
1860 }
1861 EXPORT_SYMBOL(scsi_scan_host);
1862
1863 void scsi_forget_host(struct Scsi_Host *shost)
1864 {
1865         struct scsi_device *sdev;
1866         unsigned long flags;
1867
1868  restart:
1869         spin_lock_irqsave(shost->host_lock, flags);
1870         list_for_each_entry(sdev, &shost->__devices, siblings) {
1871                 if (sdev->sdev_state == SDEV_DEL)
1872                         continue;
1873                 spin_unlock_irqrestore(shost->host_lock, flags);
1874                 __scsi_remove_device(sdev);
1875                 goto restart;
1876         }
1877         spin_unlock_irqrestore(shost->host_lock, flags);
1878 }
1879
1880 /*
1881  * Function:    scsi_get_host_dev()
1882  *
1883  * Purpose:     Create a scsi_device that points to the host adapter itself.
1884  *
1885  * Arguments:   SHpnt   - Host that needs a scsi_device
1886  *
1887  * Lock status: None assumed.
1888  *
1889  * Returns:     The scsi_device or NULL
1890  *
1891  * Notes:
1892  *      Attach a single scsi_device to the Scsi_Host - this should
1893  *      be made to look like a "pseudo-device" that points to the
1894  *      HA itself.
1895  *
1896  *      Note - this device is not accessible from any high-level
1897  *      drivers (including generics), which is probably not
1898  *      optimal.  We can add hooks later to attach 
1899  */
1900 struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
1901 {
1902         struct scsi_device *sdev = NULL;
1903         struct scsi_target *starget;
1904
1905         mutex_lock(&shost->scan_mutex);
1906         if (!scsi_host_scan_allowed(shost))
1907                 goto out;
1908         starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id);
1909         if (!starget)
1910                 goto out;
1911
1912         sdev = scsi_alloc_sdev(starget, 0, NULL);
1913         if (sdev)
1914                 sdev->borken = 0;
1915         else
1916                 scsi_target_reap(starget);
1917         put_device(&starget->dev);
1918  out:
1919         mutex_unlock(&shost->scan_mutex);
1920         return sdev;
1921 }
1922 EXPORT_SYMBOL(scsi_get_host_dev);
1923
1924 /*
1925  * Function:    scsi_free_host_dev()
1926  *
1927  * Purpose:     Free a scsi_device that points to the host adapter itself.
1928  *
1929  * Arguments:   SHpnt   - Host that needs a scsi_device
1930  *
1931  * Lock status: None assumed.
1932  *
1933  * Returns:     Nothing
1934  *
1935  * Notes:
1936  */
1937 void scsi_free_host_dev(struct scsi_device *sdev)
1938 {
1939         BUG_ON(sdev->id != sdev->host->this_id);
1940
1941         __scsi_remove_device(sdev);
1942 }
1943 EXPORT_SYMBOL(scsi_free_host_dev);
1944