1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31#include <linux/blkdev.h>
32#include <linux/dma-mapping.h>
33#include <linux/module.h>
34#include <linux/mutex.h>
35
36#include <scsi/scsi.h>
37#include <scsi/scsi_cmnd.h>
38#include <scsi/scsi_devinfo.h>
39#include <scsi/scsi_device.h>
40#include <scsi/scsi_eh.h>
41
42#include "usb.h"
43#include "scsiglue.h"
44#include "debug.h"
45#include "transport.h"
46#include "protocol.h"
47
48
49
50
51
52#define VENDOR_ID_NOKIA 0x0421
53#define VENDOR_ID_NIKON 0x04b0
54#define VENDOR_ID_PENTAX 0x0a17
55#define VENDOR_ID_MOTOROLA 0x22b8
56
57
58
59
60
61static const char* host_info(struct Scsi_Host *host)
62{
63 struct us_data *us = host_to_us(host);
64 return us->scsi_name;
65}
66
67static int slave_alloc (struct scsi_device *sdev)
68{
69 struct us_data *us = host_to_us(sdev->host);
70 int maxp;
71
72
73
74
75
76
77 sdev->inquiry_len = 36;
78
79
80
81
82
83
84
85 maxp = usb_maxpacket(us->pusb_dev, us->recv_bulk_pipe, 0);
86 blk_queue_virt_boundary(sdev->request_queue, maxp - 1);
87
88
89
90
91
92 blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1));
93
94
95 if (us->protocol == USB_PR_BULK && us->max_lun > 0)
96 sdev->sdev_bflags |= BLIST_FORCELUN;
97
98 return 0;
99}
100
101static int slave_configure(struct scsi_device *sdev)
102{
103 struct us_data *us = host_to_us(sdev->host);
104 struct device *dev = us->pusb_dev->bus->sysdev;
105
106
107
108
109
110
111 if (us->fflags & (US_FL_MAX_SECTORS_64 | US_FL_MAX_SECTORS_MIN)) {
112 unsigned int max_sectors = 64;
113
114 if (us->fflags & US_FL_MAX_SECTORS_MIN)
115 max_sectors = PAGE_SIZE >> 9;
116 if (queue_max_hw_sectors(sdev->request_queue) > max_sectors)
117 blk_queue_max_hw_sectors(sdev->request_queue,
118 max_sectors);
119 } else if (sdev->type == TYPE_TAPE) {
120
121
122
123
124
125 blk_queue_max_hw_sectors(sdev->request_queue, 0x7FFFFF);
126 } else if (us->pusb_dev->speed >= USB_SPEED_SUPER) {
127
128
129
130
131 blk_queue_max_hw_sectors(sdev->request_queue, 2048);
132 }
133
134
135
136
137
138 blk_queue_max_hw_sectors(sdev->request_queue,
139 min_t(size_t, queue_max_hw_sectors(sdev->request_queue),
140 dma_max_mapping_size(dev) >> SECTOR_SHIFT));
141
142
143
144
145
146
147
148 if (!us->pusb_dev->bus->controller->dma_mask)
149 blk_queue_bounce_limit(sdev->request_queue, BLK_BOUNCE_HIGH);
150
151
152
153
154
155
156 if (sdev->type == TYPE_DISK) {
157
158
159
160
161
162
163
164
165
166 switch (le16_to_cpu(us->pusb_dev->descriptor.idVendor)) {
167 case VENDOR_ID_NOKIA:
168 case VENDOR_ID_NIKON:
169 case VENDOR_ID_PENTAX:
170 case VENDOR_ID_MOTOROLA:
171 if (!(us->fflags & (US_FL_FIX_CAPACITY |
172 US_FL_CAPACITY_OK)))
173 us->fflags |= US_FL_CAPACITY_HEURISTICS;
174 break;
175 }
176
177
178
179
180
181
182 if (us->subclass != USB_SC_SCSI && us->subclass != USB_SC_CYP_ATACB)
183 sdev->use_10_for_ms = 1;
184
185
186
187
188
189 sdev->use_192_bytes_for_3f = 1;
190
191
192
193
194
195
196
197
198
199
200 if (us->fflags & US_FL_NO_WP_DETECT)
201 sdev->skip_ms_page_3f = 1;
202
203
204
205
206
207 sdev->skip_ms_page_8 = 1;
208
209
210
211
212
213 sdev->skip_vpd_pages = !sdev->try_vpd_pages;
214
215
216 sdev->no_report_opcodes = 1;
217
218
219 sdev->no_write_same = 1;
220
221
222
223
224
225
226 if (us->fflags & US_FL_FIX_CAPACITY)
227 sdev->fix_capacity = 1;
228
229
230
231
232
233
234 if (us->fflags & US_FL_CAPACITY_HEURISTICS)
235 sdev->guess_capacity = 1;
236
237
238 if (us->fflags & US_FL_NO_READ_CAPACITY_16)
239 sdev->no_read_capacity_16 = 1;
240
241
242
243
244
245
246
247 if (!(us->fflags & US_FL_NEEDS_CAP16))
248 sdev->try_rc_10_first = 1;
249
250
251
252
253
254 if (sdev->scsi_level > SCSI_SPC_2 &&
255 !(us->fflags & US_FL_BAD_SENSE))
256 us->fflags |= US_FL_SANE_SENSE;
257
258
259
260
261
262
263
264
265
266 sdev->retry_hwerror = 1;
267
268
269
270
271
272 sdev->allow_restart = 1;
273
274
275
276
277
278
279 sdev->last_sector_bug = 1;
280
281
282
283
284
285
286 if (!(us->fflags & (US_FL_FIX_CAPACITY | US_FL_CAPACITY_OK |
287 US_FL_SCM_MULT_TARG)) &&
288 us->protocol == USB_PR_BULK)
289 us->use_last_sector_hacks = 1;
290
291
292 if (us->fflags & US_FL_WRITE_CACHE)
293 sdev->wce_default_on = 1;
294
295
296 if (us->fflags & US_FL_BROKEN_FUA)
297 sdev->broken_fua = 1;
298
299
300 if (us->fflags & US_FL_ALWAYS_SYNC) {
301
302 sdev->skip_ms_page_8 = 1;
303 sdev->skip_ms_page_3f = 1;
304
305 sdev->wce_default_on = 1;
306 }
307 } else {
308
309
310
311
312
313
314 sdev->use_10_for_ms = 1;
315
316
317 if (us->fflags & US_FL_NO_READ_DISC_INFO)
318 sdev->no_read_disc_info = 1;
319 }
320
321
322
323
324
325
326
327
328 if ((us->protocol == USB_PR_CB || us->protocol == USB_PR_CBI) &&
329 sdev->scsi_level == SCSI_UNKNOWN)
330 us->max_lun = 0;
331
332
333
334
335
336 if (us->fflags & US_FL_NOT_LOCKABLE)
337 sdev->lockable = 0;
338
339
340
341
342
343 return 0;
344}
345
346static int target_alloc(struct scsi_target *starget)
347{
348 struct us_data *us = host_to_us(dev_to_shost(starget->dev.parent));
349
350
351
352
353
354
355
356 starget->no_report_luns = 1;
357
358
359
360
361
362
363
364
365
366
367 if (us->subclass == USB_SC_UFI)
368 starget->pdt_1f_for_no_lun = 1;
369
370 return 0;
371}
372
373
374
375static int queuecommand_lck(struct scsi_cmnd *srb,
376 void (*done)(struct scsi_cmnd *))
377{
378 struct us_data *us = host_to_us(srb->device->host);
379
380
381 if (us->srb != NULL) {
382 printk(KERN_ERR USB_STORAGE "Error in %s: us->srb = %p\n",
383 __func__, us->srb);
384 return SCSI_MLQUEUE_HOST_BUSY;
385 }
386
387
388 if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
389 usb_stor_dbg(us, "Fail command during disconnect\n");
390 srb->result = DID_NO_CONNECT << 16;
391 done(srb);
392 return 0;
393 }
394
395 if ((us->fflags & US_FL_NO_ATA_1X) &&
396 (srb->cmnd[0] == ATA_12 || srb->cmnd[0] == ATA_16)) {
397 memcpy(srb->sense_buffer, usb_stor_sense_invalidCDB,
398 sizeof(usb_stor_sense_invalidCDB));
399 srb->result = SAM_STAT_CHECK_CONDITION;
400 done(srb);
401 return 0;
402 }
403
404
405 srb->scsi_done = done;
406 us->srb = srb;
407 complete(&us->cmnd_ready);
408
409 return 0;
410}
411
412static DEF_SCSI_QCMD(queuecommand)
413
414
415
416
417
418
419static int command_abort(struct scsi_cmnd *srb)
420{
421 struct us_data *us = host_to_us(srb->device->host);
422
423 usb_stor_dbg(us, "%s called\n", __func__);
424
425
426
427
428
429 scsi_lock(us_to_host(us));
430
431
432 if (us->srb != srb) {
433 scsi_unlock(us_to_host(us));
434 usb_stor_dbg(us, "-- nothing to abort\n");
435 return FAILED;
436 }
437
438
439
440
441
442
443
444
445 set_bit(US_FLIDX_TIMED_OUT, &us->dflags);
446 if (!test_bit(US_FLIDX_RESETTING, &us->dflags)) {
447 set_bit(US_FLIDX_ABORTING, &us->dflags);
448 usb_stor_stop_transport(us);
449 }
450 scsi_unlock(us_to_host(us));
451
452
453 wait_for_completion(&us->notify);
454 return SUCCESS;
455}
456
457
458
459
460
461static int device_reset(struct scsi_cmnd *srb)
462{
463 struct us_data *us = host_to_us(srb->device->host);
464 int result;
465
466 usb_stor_dbg(us, "%s called\n", __func__);
467
468
469 mutex_lock(&(us->dev_mutex));
470 result = us->transport_reset(us);
471 mutex_unlock(&us->dev_mutex);
472
473 return result < 0 ? FAILED : SUCCESS;
474}
475
476
477static int bus_reset(struct scsi_cmnd *srb)
478{
479 struct us_data *us = host_to_us(srb->device->host);
480 int result;
481
482 usb_stor_dbg(us, "%s called\n", __func__);
483
484 result = usb_stor_port_reset(us);
485 return result < 0 ? FAILED : SUCCESS;
486}
487
488
489
490
491
492
493void usb_stor_report_device_reset(struct us_data *us)
494{
495 int i;
496 struct Scsi_Host *host = us_to_host(us);
497
498 scsi_report_device_reset(host, 0, 0);
499 if (us->fflags & US_FL_SCM_MULT_TARG) {
500 for (i = 1; i < host->max_id; ++i)
501 scsi_report_device_reset(host, 0, i);
502 }
503}
504
505
506
507
508
509
510void usb_stor_report_bus_reset(struct us_data *us)
511{
512 struct Scsi_Host *host = us_to_host(us);
513
514 scsi_lock(host);
515 scsi_report_bus_reset(host, 0);
516 scsi_unlock(host);
517}
518
519
520
521
522
523static int write_info(struct Scsi_Host *host, char *buffer, int length)
524{
525
526 return length;
527}
528
529static int show_info (struct seq_file *m, struct Scsi_Host *host)
530{
531 struct us_data *us = host_to_us(host);
532 const char *string;
533
534
535 seq_printf(m, " Host scsi%d: usb-storage\n", host->host_no);
536
537
538 if (us->pusb_dev->manufacturer)
539 string = us->pusb_dev->manufacturer;
540 else if (us->unusual_dev->vendorName)
541 string = us->unusual_dev->vendorName;
542 else
543 string = "Unknown";
544 seq_printf(m, " Vendor: %s\n", string);
545 if (us->pusb_dev->product)
546 string = us->pusb_dev->product;
547 else if (us->unusual_dev->productName)
548 string = us->unusual_dev->productName;
549 else
550 string = "Unknown";
551 seq_printf(m, " Product: %s\n", string);
552 if (us->pusb_dev->serial)
553 string = us->pusb_dev->serial;
554 else
555 string = "None";
556 seq_printf(m, "Serial Number: %s\n", string);
557
558
559 seq_printf(m, " Protocol: %s\n", us->protocol_name);
560 seq_printf(m, " Transport: %s\n", us->transport_name);
561
562
563 seq_printf(m, " Quirks:");
564
565#define US_FLAG(name, value) \
566 if (us->fflags & value) seq_printf(m, " " #name);
567US_DO_ALL_FLAGS
568#undef US_FLAG
569 seq_putc(m, '\n');
570 return 0;
571}
572
573
574
575
576
577
578static ssize_t max_sectors_show(struct device *dev, struct device_attribute *attr, char *buf)
579{
580 struct scsi_device *sdev = to_scsi_device(dev);
581
582 return sprintf(buf, "%u\n", queue_max_hw_sectors(sdev->request_queue));
583}
584
585
586static ssize_t max_sectors_store(struct device *dev, struct device_attribute *attr, const char *buf,
587 size_t count)
588{
589 struct scsi_device *sdev = to_scsi_device(dev);
590 unsigned short ms;
591
592 if (sscanf(buf, "%hu", &ms) > 0) {
593 blk_queue_max_hw_sectors(sdev->request_queue, ms);
594 return count;
595 }
596 return -EINVAL;
597}
598static DEVICE_ATTR_RW(max_sectors);
599
600static struct device_attribute *sysfs_device_attr_list[] = {
601 &dev_attr_max_sectors,
602 NULL,
603};
604
605
606
607
608
609static const struct scsi_host_template usb_stor_host_template = {
610
611 .name = "usb-storage",
612 .proc_name = "usb-storage",
613 .show_info = show_info,
614 .write_info = write_info,
615 .info = host_info,
616
617
618 .queuecommand = queuecommand,
619
620
621 .eh_abort_handler = command_abort,
622 .eh_device_reset_handler = device_reset,
623 .eh_bus_reset_handler = bus_reset,
624
625
626 .can_queue = 1,
627
628
629 .this_id = -1,
630
631 .slave_alloc = slave_alloc,
632 .slave_configure = slave_configure,
633 .target_alloc = target_alloc,
634
635
636 .sg_tablesize = SG_MAX_SEGMENTS,
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656 .max_sectors = 240,
657
658
659 .emulated = 1,
660
661
662 .skip_settle_delay = 1,
663
664
665 .sdev_attrs = sysfs_device_attr_list,
666
667
668 .module = THIS_MODULE
669};
670
671void usb_stor_host_template_init(struct scsi_host_template *sht,
672 const char *name, struct module *owner)
673{
674 *sht = usb_stor_host_template;
675 sht->name = name;
676 sht->proc_name = name;
677 sht->module = owner;
678}
679EXPORT_SYMBOL_GPL(usb_stor_host_template_init);
680
681
682unsigned char usb_stor_sense_invalidCDB[18] = {
683 [0] = 0x70,
684 [2] = ILLEGAL_REQUEST,
685 [7] = 0x0a,
686 [12] = 0x24
687};
688EXPORT_SYMBOL_GPL(usb_stor_sense_invalidCDB);
689