[SCSI] megaraid_sas: Fix FastPath I/O to work on degraded raid 1
[linux-2.6.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         extern void scsi_requeue_run_queue(struct work_struct *work);
246
247         sdev = kzalloc(sizeof(*sdev) + shost->transportt->device_size,
248                        GFP_ATOMIC);
249         if (!sdev)
250                 goto out;
251
252         sdev->vendor = scsi_null_device_strs;
253         sdev->model = scsi_null_device_strs;
254         sdev->rev = scsi_null_device_strs;
255         sdev->host = shost;
256         sdev->queue_ramp_up_period = SCSI_DEFAULT_RAMP_UP_PERIOD;
257         sdev->id = starget->id;
258         sdev->lun = lun;
259         sdev->channel = starget->channel;
260         sdev->sdev_state = SDEV_CREATED;
261         INIT_LIST_HEAD(&sdev->siblings);
262         INIT_LIST_HEAD(&sdev->same_target_siblings);
263         INIT_LIST_HEAD(&sdev->cmd_list);
264         INIT_LIST_HEAD(&sdev->starved_entry);
265         INIT_LIST_HEAD(&sdev->event_list);
266         spin_lock_init(&sdev->list_lock);
267         INIT_WORK(&sdev->event_work, scsi_evt_thread);
268         INIT_WORK(&sdev->requeue_work, scsi_requeue_run_queue);
269
270         sdev->sdev_gendev.parent = get_device(&starget->dev);
271         sdev->sdev_target = starget;
272
273         /* usually NULL and set by ->slave_alloc instead */
274         sdev->hostdata = hostdata;
275
276         /* if the device needs this changing, it may do so in the
277          * slave_configure function */
278         sdev->max_device_blocked = SCSI_DEFAULT_DEVICE_BLOCKED;
279
280         /*
281          * Some low level driver could use device->type
282          */
283         sdev->type = -1;
284
285         /*
286          * Assume that the device will have handshaking problems,
287          * and then fix this field later if it turns out it
288          * doesn't
289          */
290         sdev->borken = 1;
291
292         sdev->request_queue = scsi_alloc_queue(sdev);
293         if (!sdev->request_queue) {
294                 /* release fn is set up in scsi_sysfs_device_initialise, so
295                  * have to free and put manually here */
296                 put_device(&starget->dev);
297                 kfree(sdev);
298                 goto out;
299         }
300         blk_get_queue(sdev->request_queue);
301         sdev->request_queue->queuedata = sdev;
302         scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
303
304         scsi_sysfs_device_initialize(sdev);
305
306         if (shost->hostt->slave_alloc) {
307                 ret = shost->hostt->slave_alloc(sdev);
308                 if (ret) {
309                         /*
310                          * if LLDD reports slave not present, don't clutter
311                          * console with alloc failure messages
312                          */
313                         if (ret == -ENXIO)
314                                 display_failure_msg = 0;
315                         goto out_device_destroy;
316                 }
317         }
318
319         return sdev;
320
321 out_device_destroy:
322         scsi_device_set_state(sdev, SDEV_DEL);
323         transport_destroy_device(&sdev->sdev_gendev);
324         put_device(&sdev->sdev_dev);
325         put_device(&sdev->sdev_gendev);
326 out:
327         if (display_failure_msg)
328                 printk(ALLOC_FAILURE_MSG, __func__);
329         return NULL;
330 }
331
332 static void scsi_target_destroy(struct scsi_target *starget)
333 {
334         struct device *dev = &starget->dev;
335         struct Scsi_Host *shost = dev_to_shost(dev->parent);
336         unsigned long flags;
337
338         transport_destroy_device(dev);
339         spin_lock_irqsave(shost->host_lock, flags);
340         if (shost->hostt->target_destroy)
341                 shost->hostt->target_destroy(starget);
342         list_del_init(&starget->siblings);
343         spin_unlock_irqrestore(shost->host_lock, flags);
344         put_device(dev);
345 }
346
347 static void scsi_target_dev_release(struct device *dev)
348 {
349         struct device *parent = dev->parent;
350         struct scsi_target *starget = to_scsi_target(dev);
351
352         kfree(starget);
353         put_device(parent);
354 }
355
356 static struct device_type scsi_target_type = {
357         .name =         "scsi_target",
358         .release =      scsi_target_dev_release,
359 };
360
361 int scsi_is_target_device(const struct device *dev)
362 {
363         return dev->type == &scsi_target_type;
364 }
365 EXPORT_SYMBOL(scsi_is_target_device);
366
367 static struct scsi_target *__scsi_find_target(struct device *parent,
368                                               int channel, uint id)
369 {
370         struct scsi_target *starget, *found_starget = NULL;
371         struct Scsi_Host *shost = dev_to_shost(parent);
372         /*
373          * Search for an existing target for this sdev.
374          */
375         list_for_each_entry(starget, &shost->__targets, siblings) {
376                 if (starget->id == id &&
377                     starget->channel == channel) {
378                         found_starget = starget;
379                         break;
380                 }
381         }
382         if (found_starget)
383                 get_device(&found_starget->dev);
384
385         return found_starget;
386 }
387
388 /**
389  * scsi_alloc_target - allocate a new or find an existing target
390  * @parent:     parent of the target (need not be a scsi host)
391  * @channel:    target channel number (zero if no channels)
392  * @id:         target id number
393  *
394  * Return an existing target if one exists, provided it hasn't already
395  * gone into STARGET_DEL state, otherwise allocate a new target.
396  *
397  * The target is returned with an incremented reference, so the caller
398  * is responsible for both reaping and doing a last put
399  */
400 static struct scsi_target *scsi_alloc_target(struct device *parent,
401                                              int channel, uint id)
402 {
403         struct Scsi_Host *shost = dev_to_shost(parent);
404         struct device *dev = NULL;
405         unsigned long flags;
406         const int size = sizeof(struct scsi_target)
407                 + shost->transportt->target_size;
408         struct scsi_target *starget;
409         struct scsi_target *found_target;
410         int error;
411
412         starget = kzalloc(size, GFP_KERNEL);
413         if (!starget) {
414                 printk(KERN_ERR "%s: allocation failure\n", __func__);
415                 return NULL;
416         }
417         dev = &starget->dev;
418         device_initialize(dev);
419         starget->reap_ref = 1;
420         dev->parent = get_device(parent);
421         dev_set_name(dev, "target%d:%d:%d", shost->host_no, channel, id);
422         dev->bus = &scsi_bus_type;
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(dev);
463                 return found_target;
464         }
465         /* Unfortunately, we found a dying target; need to
466          * wait until it's dead before we can get a new one */
467         put_device(&found_target->dev);
468         flush_scheduled_work();
469         goto retry;
470 }
471
472 static void scsi_target_reap_usercontext(struct work_struct *work)
473 {
474         struct scsi_target *starget =
475                 container_of(work, struct scsi_target, ew.work);
476
477         transport_remove_device(&starget->dev);
478         device_del(&starget->dev);
479         scsi_target_destroy(starget);
480 }
481
482 /**
483  * scsi_target_reap - check to see if target is in use and destroy if not
484  * @starget: target to be checked
485  *
486  * This is used after removing a LUN or doing a last put of the target
487  * it checks atomically that nothing is using the target and removes
488  * it if so.
489  */
490 void scsi_target_reap(struct scsi_target *starget)
491 {
492         struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
493         unsigned long flags;
494         enum scsi_target_state state;
495         int empty = 0;
496
497         spin_lock_irqsave(shost->host_lock, flags);
498         state = starget->state;
499         if (--starget->reap_ref == 0 && list_empty(&starget->devices)) {
500                 empty = 1;
501                 starget->state = STARGET_DEL;
502         }
503         spin_unlock_irqrestore(shost->host_lock, flags);
504
505         if (!empty)
506                 return;
507
508         BUG_ON(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         scsi_autopm_get_target(starget);
1517
1518         mutex_lock(&shost->scan_mutex);
1519         if (!shost->async_scan)
1520                 scsi_complete_async_scans();
1521
1522         if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
1523                 scsi_probe_and_add_lun(starget, lun, NULL, &sdev, 1, hostdata);
1524                 scsi_autopm_put_host(shost);
1525         }
1526         mutex_unlock(&shost->scan_mutex);
1527         scsi_autopm_put_target(starget);
1528         scsi_target_reap(starget);
1529         put_device(&starget->dev);
1530
1531         return sdev;
1532 }
1533 EXPORT_SYMBOL(__scsi_add_device);
1534
1535 int scsi_add_device(struct Scsi_Host *host, uint channel,
1536                     uint target, uint lun)
1537 {
1538         struct scsi_device *sdev = 
1539                 __scsi_add_device(host, channel, target, lun, NULL);
1540         if (IS_ERR(sdev))
1541                 return PTR_ERR(sdev);
1542
1543         scsi_device_put(sdev);
1544         return 0;
1545 }
1546 EXPORT_SYMBOL(scsi_add_device);
1547
1548 void scsi_rescan_device(struct device *dev)
1549 {
1550         struct scsi_driver *drv;
1551         
1552         if (!dev->driver)
1553                 return;
1554
1555         drv = to_scsi_driver(dev->driver);
1556         if (try_module_get(drv->owner)) {
1557                 if (drv->rescan)
1558                         drv->rescan(dev);
1559                 module_put(drv->owner);
1560         }
1561 }
1562 EXPORT_SYMBOL(scsi_rescan_device);
1563
1564 static void __scsi_scan_target(struct device *parent, unsigned int channel,
1565                 unsigned int id, unsigned int lun, int rescan)
1566 {
1567         struct Scsi_Host *shost = dev_to_shost(parent);
1568         int bflags = 0;
1569         int res;
1570         struct scsi_target *starget;
1571
1572         if (shost->this_id == id)
1573                 /*
1574                  * Don't scan the host adapter
1575                  */
1576                 return;
1577
1578         starget = scsi_alloc_target(parent, channel, id);
1579         if (!starget)
1580                 return;
1581         scsi_autopm_get_target(starget);
1582
1583         if (lun != SCAN_WILD_CARD) {
1584                 /*
1585                  * Scan for a specific host/chan/id/lun.
1586                  */
1587                 scsi_probe_and_add_lun(starget, lun, NULL, NULL, rescan, NULL);
1588                 goto out_reap;
1589         }
1590
1591         /*
1592          * Scan LUN 0, if there is some response, scan further. Ideally, we
1593          * would not configure LUN 0 until all LUNs are scanned.
1594          */
1595         res = scsi_probe_and_add_lun(starget, 0, &bflags, NULL, rescan, NULL);
1596         if (res == SCSI_SCAN_LUN_PRESENT || res == SCSI_SCAN_TARGET_PRESENT) {
1597                 if (scsi_report_lun_scan(starget, bflags, rescan) != 0)
1598                         /*
1599                          * The REPORT LUN did not scan the target,
1600                          * do a sequential scan.
1601                          */
1602                         scsi_sequential_lun_scan(starget, bflags,
1603                                                  starget->scsi_level, rescan);
1604         }
1605
1606  out_reap:
1607         scsi_autopm_put_target(starget);
1608         /* now determine if the target has any children at all
1609          * and if not, nuke it */
1610         scsi_target_reap(starget);
1611
1612         put_device(&starget->dev);
1613 }
1614
1615 /**
1616  * scsi_scan_target - scan a target id, possibly including all LUNs on the target.
1617  * @parent:     host to scan
1618  * @channel:    channel to scan
1619  * @id:         target id to scan
1620  * @lun:        Specific LUN to scan or SCAN_WILD_CARD
1621  * @rescan:     passed to LUN scanning routines
1622  *
1623  * Description:
1624  *     Scan the target id on @parent, @channel, and @id. Scan at least LUN 0,
1625  *     and possibly all LUNs on the target id.
1626  *
1627  *     First try a REPORT LUN scan, if that does not scan the target, do a
1628  *     sequential scan of LUNs on the target id.
1629  **/
1630 void scsi_scan_target(struct device *parent, unsigned int channel,
1631                       unsigned int id, unsigned int lun, int rescan)
1632 {
1633         struct Scsi_Host *shost = dev_to_shost(parent);
1634
1635         if (strncmp(scsi_scan_type, "none", 4) == 0)
1636                 return;
1637
1638         mutex_lock(&shost->scan_mutex);
1639         if (!shost->async_scan)
1640                 scsi_complete_async_scans();
1641
1642         if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
1643                 __scsi_scan_target(parent, channel, id, lun, rescan);
1644                 scsi_autopm_put_host(shost);
1645         }
1646         mutex_unlock(&shost->scan_mutex);
1647 }
1648 EXPORT_SYMBOL(scsi_scan_target);
1649
1650 static void scsi_scan_channel(struct Scsi_Host *shost, unsigned int channel,
1651                               unsigned int id, unsigned int lun, int rescan)
1652 {
1653         uint order_id;
1654
1655         if (id == SCAN_WILD_CARD)
1656                 for (id = 0; id < shost->max_id; ++id) {
1657                         /*
1658                          * XXX adapter drivers when possible (FCP, iSCSI)
1659                          * could modify max_id to match the current max,
1660                          * not the absolute max.
1661                          *
1662                          * XXX add a shost id iterator, so for example,
1663                          * the FC ID can be the same as a target id
1664                          * without a huge overhead of sparse id's.
1665                          */
1666                         if (shost->reverse_ordering)
1667                                 /*
1668                                  * Scan from high to low id.
1669                                  */
1670                                 order_id = shost->max_id - id - 1;
1671                         else
1672                                 order_id = id;
1673                         __scsi_scan_target(&shost->shost_gendev, channel,
1674                                         order_id, lun, rescan);
1675                 }
1676         else
1677                 __scsi_scan_target(&shost->shost_gendev, channel,
1678                                 id, lun, rescan);
1679 }
1680
1681 int scsi_scan_host_selected(struct Scsi_Host *shost, unsigned int channel,
1682                             unsigned int id, unsigned int lun, int rescan)
1683 {
1684         SCSI_LOG_SCAN_BUS(3, shost_printk (KERN_INFO, shost,
1685                 "%s: <%u:%u:%u>\n",
1686                 __func__, channel, id, lun));
1687
1688         if (((channel != SCAN_WILD_CARD) && (channel > shost->max_channel)) ||
1689             ((id != SCAN_WILD_CARD) && (id >= shost->max_id)) ||
1690             ((lun != SCAN_WILD_CARD) && (lun > shost->max_lun)))
1691                 return -EINVAL;
1692
1693         mutex_lock(&shost->scan_mutex);
1694         if (!shost->async_scan)
1695                 scsi_complete_async_scans();
1696
1697         if (scsi_host_scan_allowed(shost) && scsi_autopm_get_host(shost) == 0) {
1698                 if (channel == SCAN_WILD_CARD)
1699                         for (channel = 0; channel <= shost->max_channel;
1700                              channel++)
1701                                 scsi_scan_channel(shost, channel, id, lun,
1702                                                   rescan);
1703                 else
1704                         scsi_scan_channel(shost, channel, id, lun, rescan);
1705                 scsi_autopm_put_host(shost);
1706         }
1707         mutex_unlock(&shost->scan_mutex);
1708
1709         return 0;
1710 }
1711
1712 static void scsi_sysfs_add_devices(struct Scsi_Host *shost)
1713 {
1714         struct scsi_device *sdev;
1715         shost_for_each_device(sdev, shost) {
1716                 if (!scsi_host_scan_allowed(shost) ||
1717                     scsi_sysfs_add_sdev(sdev) != 0)
1718                         __scsi_remove_device(sdev);
1719         }
1720 }
1721
1722 /**
1723  * scsi_prep_async_scan - prepare for an async scan
1724  * @shost: the host which will be scanned
1725  * Returns: a cookie to be passed to scsi_finish_async_scan()
1726  *
1727  * Tells the midlayer this host is going to do an asynchronous scan.
1728  * It reserves the host's position in the scanning list and ensures
1729  * that other asynchronous scans started after this one won't affect the
1730  * ordering of the discovered devices.
1731  */
1732 static struct async_scan_data *scsi_prep_async_scan(struct Scsi_Host *shost)
1733 {
1734         struct async_scan_data *data;
1735         unsigned long flags;
1736
1737         if (strncmp(scsi_scan_type, "sync", 4) == 0)
1738                 return NULL;
1739
1740         if (shost->async_scan) {
1741                 printk("%s called twice for host %d", __func__,
1742                                 shost->host_no);
1743                 dump_stack();
1744                 return NULL;
1745         }
1746
1747         data = kmalloc(sizeof(*data), GFP_KERNEL);
1748         if (!data)
1749                 goto err;
1750         data->shost = scsi_host_get(shost);
1751         if (!data->shost)
1752                 goto err;
1753         init_completion(&data->prev_finished);
1754
1755         mutex_lock(&shost->scan_mutex);
1756         spin_lock_irqsave(shost->host_lock, flags);
1757         shost->async_scan = 1;
1758         spin_unlock_irqrestore(shost->host_lock, flags);
1759         mutex_unlock(&shost->scan_mutex);
1760
1761         spin_lock(&async_scan_lock);
1762         if (list_empty(&scanning_hosts))
1763                 complete(&data->prev_finished);
1764         list_add_tail(&data->list, &scanning_hosts);
1765         spin_unlock(&async_scan_lock);
1766
1767         return data;
1768
1769  err:
1770         kfree(data);
1771         return NULL;
1772 }
1773
1774 /**
1775  * scsi_finish_async_scan - asynchronous scan has finished
1776  * @data: cookie returned from earlier call to scsi_prep_async_scan()
1777  *
1778  * All the devices currently attached to this host have been found.
1779  * This function announces all the devices it has found to the rest
1780  * of the system.
1781  */
1782 static void scsi_finish_async_scan(struct async_scan_data *data)
1783 {
1784         struct Scsi_Host *shost;
1785         unsigned long flags;
1786
1787         if (!data)
1788                 return;
1789
1790         shost = data->shost;
1791
1792         mutex_lock(&shost->scan_mutex);
1793
1794         if (!shost->async_scan) {
1795                 printk("%s called twice for host %d", __func__,
1796                                 shost->host_no);
1797                 dump_stack();
1798                 mutex_unlock(&shost->scan_mutex);
1799                 return;
1800         }
1801
1802         wait_for_completion(&data->prev_finished);
1803
1804         scsi_sysfs_add_devices(shost);
1805
1806         spin_lock_irqsave(shost->host_lock, flags);
1807         shost->async_scan = 0;
1808         spin_unlock_irqrestore(shost->host_lock, flags);
1809
1810         mutex_unlock(&shost->scan_mutex);
1811
1812         spin_lock(&async_scan_lock);
1813         list_del(&data->list);
1814         if (!list_empty(&scanning_hosts)) {
1815                 struct async_scan_data *next = list_entry(scanning_hosts.next,
1816                                 struct async_scan_data, list);
1817                 complete(&next->prev_finished);
1818         }
1819         spin_unlock(&async_scan_lock);
1820
1821         scsi_host_put(shost);
1822         kfree(data);
1823 }
1824
1825 static void do_scsi_scan_host(struct Scsi_Host *shost)
1826 {
1827         if (shost->hostt->scan_finished) {
1828                 unsigned long start = jiffies;
1829                 if (shost->hostt->scan_start)
1830                         shost->hostt->scan_start(shost);
1831
1832                 while (!shost->hostt->scan_finished(shost, jiffies - start))
1833                         msleep(10);
1834         } else {
1835                 scsi_scan_host_selected(shost, SCAN_WILD_CARD, SCAN_WILD_CARD,
1836                                 SCAN_WILD_CARD, 0);
1837         }
1838 }
1839
1840 static int do_scan_async(void *_data)
1841 {
1842         struct async_scan_data *data = _data;
1843         struct Scsi_Host *shost = data->shost;
1844
1845         do_scsi_scan_host(shost);
1846         scsi_finish_async_scan(data);
1847         scsi_autopm_put_host(shost);
1848         return 0;
1849 }
1850
1851 /**
1852  * scsi_scan_host - scan the given adapter
1853  * @shost:      adapter to scan
1854  **/
1855 void scsi_scan_host(struct Scsi_Host *shost)
1856 {
1857         struct task_struct *p;
1858         struct async_scan_data *data;
1859
1860         if (strncmp(scsi_scan_type, "none", 4) == 0)
1861                 return;
1862         if (scsi_autopm_get_host(shost) < 0)
1863                 return;
1864
1865         data = scsi_prep_async_scan(shost);
1866         if (!data) {
1867                 do_scsi_scan_host(shost);
1868                 scsi_autopm_put_host(shost);
1869                 return;
1870         }
1871
1872         p = kthread_run(do_scan_async, data, "scsi_scan_%d", shost->host_no);
1873         if (IS_ERR(p))
1874                 do_scan_async(data);
1875         /* scsi_autopm_put_host(shost) is called in do_scan_async() */
1876 }
1877 EXPORT_SYMBOL(scsi_scan_host);
1878
1879 void scsi_forget_host(struct Scsi_Host *shost)
1880 {
1881         struct scsi_device *sdev;
1882         unsigned long flags;
1883
1884  restart:
1885         spin_lock_irqsave(shost->host_lock, flags);
1886         list_for_each_entry(sdev, &shost->__devices, siblings) {
1887                 if (sdev->sdev_state == SDEV_DEL)
1888                         continue;
1889                 spin_unlock_irqrestore(shost->host_lock, flags);
1890                 __scsi_remove_device(sdev);
1891                 goto restart;
1892         }
1893         spin_unlock_irqrestore(shost->host_lock, flags);
1894 }
1895
1896 /**
1897  * scsi_get_host_dev - Create a scsi_device that points to the host adapter itself
1898  * @shost: Host that needs a scsi_device
1899  *
1900  * Lock status: None assumed.
1901  *
1902  * Returns:     The scsi_device or NULL
1903  *
1904  * Notes:
1905  *      Attach a single scsi_device to the Scsi_Host - this should
1906  *      be made to look like a "pseudo-device" that points to the
1907  *      HA itself.
1908  *
1909  *      Note - this device is not accessible from any high-level
1910  *      drivers (including generics), which is probably not
1911  *      optimal.  We can add hooks later to attach.
1912  */
1913 struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
1914 {
1915         struct scsi_device *sdev = NULL;
1916         struct scsi_target *starget;
1917
1918         mutex_lock(&shost->scan_mutex);
1919         if (!scsi_host_scan_allowed(shost))
1920                 goto out;
1921         starget = scsi_alloc_target(&shost->shost_gendev, 0, shost->this_id);
1922         if (!starget)
1923                 goto out;
1924
1925         sdev = scsi_alloc_sdev(starget, 0, NULL);
1926         if (sdev)
1927                 sdev->borken = 0;
1928         else
1929                 scsi_target_reap(starget);
1930         put_device(&starget->dev);
1931  out:
1932         mutex_unlock(&shost->scan_mutex);
1933         return sdev;
1934 }
1935 EXPORT_SYMBOL(scsi_get_host_dev);
1936
1937 /**
1938  * scsi_free_host_dev - Free a scsi_device that points to the host adapter itself
1939  * @sdev: Host device to be freed
1940  *
1941  * Lock status: None assumed.
1942  *
1943  * Returns:     Nothing
1944  */
1945 void scsi_free_host_dev(struct scsi_device *sdev)
1946 {
1947         BUG_ON(sdev->id != sdev->host->this_id);
1948
1949         __scsi_remove_device(sdev);
1950 }
1951 EXPORT_SYMBOL(scsi_free_host_dev);
1952