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