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
32
33
34
35#include <linux/module.h>
36#include <linux/fs.h>
37#include <linux/kernel.h>
38#include <linux/mm.h>
39#include <linux/bio.h>
40#include <linux/genhd.h>
41#include <linux/hdreg.h>
42#include <linux/errno.h>
43#include <linux/idr.h>
44#include <linux/interrupt.h>
45#include <linux/init.h>
46#include <linux/blkdev.h>
47#include <linux/blkpg.h>
48#include <linux/delay.h>
49#include <linux/mutex.h>
50#include <linux/string_helpers.h>
51#include <asm/uaccess.h>
52
53#include <scsi/scsi.h>
54#include <scsi/scsi_cmnd.h>
55#include <scsi/scsi_dbg.h>
56#include <scsi/scsi_device.h>
57#include <scsi/scsi_driver.h>
58#include <scsi/scsi_eh.h>
59#include <scsi/scsi_host.h>
60#include <scsi/scsi_ioctl.h>
61#include <scsi/scsicam.h>
62
63#include "sd.h"
64#include "scsi_logging.h"
65
66MODULE_AUTHOR("Eric Youngdale");
67MODULE_DESCRIPTION("SCSI disk (sd) driver");
68MODULE_LICENSE("GPL");
69
70MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK0_MAJOR);
71MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK1_MAJOR);
72MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK2_MAJOR);
73MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK3_MAJOR);
74MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK4_MAJOR);
75MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK5_MAJOR);
76MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK6_MAJOR);
77MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK7_MAJOR);
78MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK8_MAJOR);
79MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK9_MAJOR);
80MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK10_MAJOR);
81MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK11_MAJOR);
82MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK12_MAJOR);
83MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK13_MAJOR);
84MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK14_MAJOR);
85MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK15_MAJOR);
86MODULE_ALIAS_SCSI_DEVICE(TYPE_DISK);
87MODULE_ALIAS_SCSI_DEVICE(TYPE_MOD);
88MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC);
89
90#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
91#define SD_MINORS 16
92#else
93#define SD_MINORS 0
94#endif
95
96static int sd_revalidate_disk(struct gendisk *);
97static int sd_probe(struct device *);
98static int sd_remove(struct device *);
99static void sd_shutdown(struct device *);
100static int sd_suspend(struct device *, pm_message_t state);
101static int sd_resume(struct device *);
102static void sd_rescan(struct device *);
103static int sd_done(struct scsi_cmnd *);
104static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
105static void scsi_disk_release(struct device *cdev);
106static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
107static void sd_print_result(struct scsi_disk *, int);
108
109static DEFINE_IDA(sd_index_ida);
110
111
112
113
114static DEFINE_MUTEX(sd_ref_mutex);
115
116static const char *sd_cache_types[] = {
117 "write through", "none", "write back",
118 "write back, no read (daft)"
119};
120
121static ssize_t
122sd_store_cache_type(struct device *dev, struct device_attribute *attr,
123 const char *buf, size_t count)
124{
125 int i, ct = -1, rcd, wce, sp;
126 struct scsi_disk *sdkp = to_scsi_disk(dev);
127 struct scsi_device *sdp = sdkp->device;
128 char buffer[64];
129 char *buffer_data;
130 struct scsi_mode_data data;
131 struct scsi_sense_hdr sshdr;
132 int len;
133
134 if (sdp->type != TYPE_DISK)
135
136
137
138 return -EINVAL;
139
140 for (i = 0; i < ARRAY_SIZE(sd_cache_types); i++) {
141 const int len = strlen(sd_cache_types[i]);
142 if (strncmp(sd_cache_types[i], buf, len) == 0 &&
143 buf[len] == '\n') {
144 ct = i;
145 break;
146 }
147 }
148 if (ct < 0)
149 return -EINVAL;
150 rcd = ct & 0x01 ? 1 : 0;
151 wce = ct & 0x02 ? 1 : 0;
152 if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT,
153 SD_MAX_RETRIES, &data, NULL))
154 return -EINVAL;
155 len = min_t(size_t, sizeof(buffer), data.length - data.header_length -
156 data.block_descriptor_length);
157 buffer_data = buffer + data.header_length +
158 data.block_descriptor_length;
159 buffer_data[2] &= ~0x05;
160 buffer_data[2] |= wce << 2 | rcd;
161 sp = buffer_data[0] & 0x80 ? 1 : 0;
162
163 if (scsi_mode_select(sdp, 1, sp, 8, buffer_data, len, SD_TIMEOUT,
164 SD_MAX_RETRIES, &data, &sshdr)) {
165 if (scsi_sense_valid(&sshdr))
166 sd_print_sense_hdr(sdkp, &sshdr);
167 return -EINVAL;
168 }
169 revalidate_disk(sdkp->disk);
170 return count;
171}
172
173static ssize_t
174sd_store_manage_start_stop(struct device *dev, struct device_attribute *attr,
175 const char *buf, size_t count)
176{
177 struct scsi_disk *sdkp = to_scsi_disk(dev);
178 struct scsi_device *sdp = sdkp->device;
179
180 if (!capable(CAP_SYS_ADMIN))
181 return -EACCES;
182
183 sdp->manage_start_stop = simple_strtoul(buf, NULL, 10);
184
185 return count;
186}
187
188static ssize_t
189sd_store_allow_restart(struct device *dev, struct device_attribute *attr,
190 const char *buf, size_t count)
191{
192 struct scsi_disk *sdkp = to_scsi_disk(dev);
193 struct scsi_device *sdp = sdkp->device;
194
195 if (!capable(CAP_SYS_ADMIN))
196 return -EACCES;
197
198 if (sdp->type != TYPE_DISK)
199 return -EINVAL;
200
201 sdp->allow_restart = simple_strtoul(buf, NULL, 10);
202
203 return count;
204}
205
206static ssize_t
207sd_show_cache_type(struct device *dev, struct device_attribute *attr,
208 char *buf)
209{
210 struct scsi_disk *sdkp = to_scsi_disk(dev);
211 int ct = sdkp->RCD + 2*sdkp->WCE;
212
213 return snprintf(buf, 40, "%s\n", sd_cache_types[ct]);
214}
215
216static ssize_t
217sd_show_fua(struct device *dev, struct device_attribute *attr, char *buf)
218{
219 struct scsi_disk *sdkp = to_scsi_disk(dev);
220
221 return snprintf(buf, 20, "%u\n", sdkp->DPOFUA);
222}
223
224static ssize_t
225sd_show_manage_start_stop(struct device *dev, struct device_attribute *attr,
226 char *buf)
227{
228 struct scsi_disk *sdkp = to_scsi_disk(dev);
229 struct scsi_device *sdp = sdkp->device;
230
231 return snprintf(buf, 20, "%u\n", sdp->manage_start_stop);
232}
233
234static ssize_t
235sd_show_allow_restart(struct device *dev, struct device_attribute *attr,
236 char *buf)
237{
238 struct scsi_disk *sdkp = to_scsi_disk(dev);
239
240 return snprintf(buf, 40, "%d\n", sdkp->device->allow_restart);
241}
242
243static ssize_t
244sd_show_protection_type(struct device *dev, struct device_attribute *attr,
245 char *buf)
246{
247 struct scsi_disk *sdkp = to_scsi_disk(dev);
248
249 return snprintf(buf, 20, "%u\n", sdkp->protection_type);
250}
251
252static ssize_t
253sd_show_app_tag_own(struct device *dev, struct device_attribute *attr,
254 char *buf)
255{
256 struct scsi_disk *sdkp = to_scsi_disk(dev);
257
258 return snprintf(buf, 20, "%u\n", sdkp->ATO);
259}
260
261static struct device_attribute sd_disk_attrs[] = {
262 __ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
263 sd_store_cache_type),
264 __ATTR(FUA, S_IRUGO, sd_show_fua, NULL),
265 __ATTR(allow_restart, S_IRUGO|S_IWUSR, sd_show_allow_restart,
266 sd_store_allow_restart),
267 __ATTR(manage_start_stop, S_IRUGO|S_IWUSR, sd_show_manage_start_stop,
268 sd_store_manage_start_stop),
269 __ATTR(protection_type, S_IRUGO, sd_show_protection_type, NULL),
270 __ATTR(app_tag_own, S_IRUGO, sd_show_app_tag_own, NULL),
271 __ATTR_NULL,
272};
273
274static struct class sd_disk_class = {
275 .name = "scsi_disk",
276 .owner = THIS_MODULE,
277 .dev_release = scsi_disk_release,
278 .dev_attrs = sd_disk_attrs,
279};
280
281static struct scsi_driver sd_template = {
282 .owner = THIS_MODULE,
283 .gendrv = {
284 .name = "sd",
285 .probe = sd_probe,
286 .remove = sd_remove,
287 .suspend = sd_suspend,
288 .resume = sd_resume,
289 .shutdown = sd_shutdown,
290 },
291 .rescan = sd_rescan,
292 .done = sd_done,
293};
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309static int sd_major(int major_idx)
310{
311 switch (major_idx) {
312 case 0:
313 return SCSI_DISK0_MAJOR;
314 case 1 ... 7:
315 return SCSI_DISK1_MAJOR + major_idx - 1;
316 case 8 ... 15:
317 return SCSI_DISK8_MAJOR + major_idx - 8;
318 default:
319 BUG();
320 return 0;
321 }
322}
323
324static struct scsi_disk *__scsi_disk_get(struct gendisk *disk)
325{
326 struct scsi_disk *sdkp = NULL;
327
328 if (disk->private_data) {
329 sdkp = scsi_disk(disk);
330 if (scsi_device_get(sdkp->device) == 0)
331 get_device(&sdkp->dev);
332 else
333 sdkp = NULL;
334 }
335 return sdkp;
336}
337
338static struct scsi_disk *scsi_disk_get(struct gendisk *disk)
339{
340 struct scsi_disk *sdkp;
341
342 mutex_lock(&sd_ref_mutex);
343 sdkp = __scsi_disk_get(disk);
344 mutex_unlock(&sd_ref_mutex);
345 return sdkp;
346}
347
348static struct scsi_disk *scsi_disk_get_from_dev(struct device *dev)
349{
350 struct scsi_disk *sdkp;
351
352 mutex_lock(&sd_ref_mutex);
353 sdkp = dev_get_drvdata(dev);
354 if (sdkp)
355 sdkp = __scsi_disk_get(sdkp->disk);
356 mutex_unlock(&sd_ref_mutex);
357 return sdkp;
358}
359
360static void scsi_disk_put(struct scsi_disk *sdkp)
361{
362 struct scsi_device *sdev = sdkp->device;
363
364 mutex_lock(&sd_ref_mutex);
365 put_device(&sdkp->dev);
366 scsi_device_put(sdev);
367 mutex_unlock(&sd_ref_mutex);
368}
369
370
371
372
373
374
375
376
377
378static int sd_prep_fn(struct request_queue *q, struct request *rq)
379{
380 struct scsi_cmnd *SCpnt;
381 struct scsi_device *sdp = q->queuedata;
382 struct gendisk *disk = rq->rq_disk;
383 struct scsi_disk *sdkp;
384 sector_t block = rq->sector;
385 sector_t threshold;
386 unsigned int this_count = rq->nr_sectors;
387 int ret, host_dif;
388
389 if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
390 ret = scsi_setup_blk_pc_cmnd(sdp, rq);
391 goto out;
392 } else if (rq->cmd_type != REQ_TYPE_FS) {
393 ret = BLKPREP_KILL;
394 goto out;
395 }
396 ret = scsi_setup_fs_cmnd(sdp, rq);
397 if (ret != BLKPREP_OK)
398 goto out;
399 SCpnt = rq->special;
400 sdkp = scsi_disk(disk);
401
402
403
404 ret = BLKPREP_KILL;
405
406 SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,
407 "sd_init_command: block=%llu, "
408 "count=%d\n",
409 (unsigned long long)block,
410 this_count));
411
412 if (!sdp || !scsi_device_online(sdp) ||
413 block + rq->nr_sectors > get_capacity(disk)) {
414 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
415 "Finishing %ld sectors\n",
416 rq->nr_sectors));
417 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
418 "Retry with 0x%p\n", SCpnt));
419 goto out;
420 }
421
422 if (sdp->changed) {
423
424
425
426
427
428 goto out;
429 }
430
431
432
433
434
435 threshold = get_capacity(disk) - SD_LAST_BUGGY_SECTORS *
436 (sdp->sector_size / 512);
437
438 if (unlikely(sdp->last_sector_bug && block + this_count > threshold)) {
439 if (block < threshold) {
440
441 this_count = threshold - block;
442 } else {
443
444 this_count = sdp->sector_size / 512;
445 }
446 }
447
448 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "block=%llu\n",
449 (unsigned long long)block));
450
451
452
453
454
455
456
457
458
459
460
461
462 if (sdp->sector_size == 1024) {
463 if ((block & 1) || (rq->nr_sectors & 1)) {
464 scmd_printk(KERN_ERR, SCpnt,
465 "Bad block number requested\n");
466 goto out;
467 } else {
468 block = block >> 1;
469 this_count = this_count >> 1;
470 }
471 }
472 if (sdp->sector_size == 2048) {
473 if ((block & 3) || (rq->nr_sectors & 3)) {
474 scmd_printk(KERN_ERR, SCpnt,
475 "Bad block number requested\n");
476 goto out;
477 } else {
478 block = block >> 2;
479 this_count = this_count >> 2;
480 }
481 }
482 if (sdp->sector_size == 4096) {
483 if ((block & 7) || (rq->nr_sectors & 7)) {
484 scmd_printk(KERN_ERR, SCpnt,
485 "Bad block number requested\n");
486 goto out;
487 } else {
488 block = block >> 3;
489 this_count = this_count >> 3;
490 }
491 }
492 if (rq_data_dir(rq) == WRITE) {
493 if (!sdp->writeable) {
494 goto out;
495 }
496 SCpnt->cmnd[0] = WRITE_6;
497 SCpnt->sc_data_direction = DMA_TO_DEVICE;
498
499 if (blk_integrity_rq(rq) &&
500 sd_dif_prepare(rq, block, sdp->sector_size) == -EIO)
501 goto out;
502
503 } else if (rq_data_dir(rq) == READ) {
504 SCpnt->cmnd[0] = READ_6;
505 SCpnt->sc_data_direction = DMA_FROM_DEVICE;
506 } else {
507 scmd_printk(KERN_ERR, SCpnt, "Unknown command %x\n", rq->cmd_flags);
508 goto out;
509 }
510
511 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
512 "%s %d/%ld 512 byte blocks.\n",
513 (rq_data_dir(rq) == WRITE) ?
514 "writing" : "reading", this_count,
515 rq->nr_sectors));
516
517
518 host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
519 if (host_dif)
520 SCpnt->cmnd[1] = 1 << 5;
521 else
522 SCpnt->cmnd[1] = 0;
523
524 if (block > 0xffffffff) {
525 SCpnt->cmnd[0] += READ_16 - READ_6;
526 SCpnt->cmnd[1] |= blk_fua_rq(rq) ? 0x8 : 0;
527 SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
528 SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
529 SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
530 SCpnt->cmnd[5] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
531 SCpnt->cmnd[6] = (unsigned char) (block >> 24) & 0xff;
532 SCpnt->cmnd[7] = (unsigned char) (block >> 16) & 0xff;
533 SCpnt->cmnd[8] = (unsigned char) (block >> 8) & 0xff;
534 SCpnt->cmnd[9] = (unsigned char) block & 0xff;
535 SCpnt->cmnd[10] = (unsigned char) (this_count >> 24) & 0xff;
536 SCpnt->cmnd[11] = (unsigned char) (this_count >> 16) & 0xff;
537 SCpnt->cmnd[12] = (unsigned char) (this_count >> 8) & 0xff;
538 SCpnt->cmnd[13] = (unsigned char) this_count & 0xff;
539 SCpnt->cmnd[14] = SCpnt->cmnd[15] = 0;
540 } else if ((this_count > 0xff) || (block > 0x1fffff) ||
541 scsi_device_protection(SCpnt->device) ||
542 SCpnt->device->use_10_for_rw) {
543 if (this_count > 0xffff)
544 this_count = 0xffff;
545
546 SCpnt->cmnd[0] += READ_10 - READ_6;
547 SCpnt->cmnd[1] |= blk_fua_rq(rq) ? 0x8 : 0;
548 SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
549 SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
550 SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
551 SCpnt->cmnd[5] = (unsigned char) block & 0xff;
552 SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0;
553 SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
554 SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
555 } else {
556 if (unlikely(blk_fua_rq(rq))) {
557
558
559
560
561
562
563 scmd_printk(KERN_ERR, SCpnt,
564 "FUA write on READ/WRITE(6) drive\n");
565 goto out;
566 }
567
568 SCpnt->cmnd[1] |= (unsigned char) ((block >> 16) & 0x1f);
569 SCpnt->cmnd[2] = (unsigned char) ((block >> 8) & 0xff);
570 SCpnt->cmnd[3] = (unsigned char) block & 0xff;
571 SCpnt->cmnd[4] = (unsigned char) this_count;
572 SCpnt->cmnd[5] = 0;
573 }
574 SCpnt->sdb.length = this_count * sdp->sector_size;
575
576
577 if (host_dif || scsi_prot_sg_count(SCpnt))
578 sd_dif_op(SCpnt, host_dif, scsi_prot_sg_count(SCpnt),
579 sdkp->protection_type);
580
581
582
583
584
585
586 SCpnt->transfersize = sdp->sector_size;
587 SCpnt->underflow = this_count << 9;
588 SCpnt->allowed = SD_MAX_RETRIES;
589
590
591
592
593
594 ret = BLKPREP_OK;
595 out:
596 return scsi_prep_return(q, rq, ret);
597}
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612static int sd_open(struct block_device *bdev, fmode_t mode)
613{
614 struct scsi_disk *sdkp = scsi_disk_get(bdev->bd_disk);
615 struct scsi_device *sdev;
616 int retval;
617
618 if (!sdkp)
619 return -ENXIO;
620
621 SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
622
623 sdev = sdkp->device;
624
625
626
627
628
629 retval = -ENXIO;
630 if (!scsi_block_when_processing_errors(sdev))
631 goto error_out;
632
633 if (sdev->removable || sdkp->write_prot)
634 check_disk_change(bdev);
635
636
637
638
639 retval = -ENOMEDIUM;
640 if (sdev->removable && !sdkp->media_present && !(mode & FMODE_NDELAY))
641 goto error_out;
642
643
644
645
646
647 retval = -EROFS;
648 if (sdkp->write_prot && (mode & FMODE_WRITE))
649 goto error_out;
650
651
652
653
654
655
656
657 retval = -ENXIO;
658 if (!scsi_device_online(sdev))
659 goto error_out;
660
661 if (!sdkp->openers++ && sdev->removable) {
662 if (scsi_block_when_processing_errors(sdev))
663 scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
664 }
665
666 return 0;
667
668error_out:
669 scsi_disk_put(sdkp);
670 return retval;
671}
672
673
674
675
676
677
678
679
680
681
682
683
684static int sd_release(struct gendisk *disk, fmode_t mode)
685{
686 struct scsi_disk *sdkp = scsi_disk(disk);
687 struct scsi_device *sdev = sdkp->device;
688
689 SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_release\n"));
690
691 if (!--sdkp->openers && sdev->removable) {
692 if (scsi_block_when_processing_errors(sdev))
693 scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
694 }
695
696
697
698
699
700 scsi_disk_put(sdkp);
701 return 0;
702}
703
704static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
705{
706 struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
707 struct scsi_device *sdp = sdkp->device;
708 struct Scsi_Host *host = sdp->host;
709 int diskinfo[4];
710
711
712 diskinfo[0] = 0x40;
713 diskinfo[1] = 0x20;
714 diskinfo[2] = sdkp->capacity >> 11;
715
716
717 if (host->hostt->bios_param)
718 host->hostt->bios_param(sdp, bdev, sdkp->capacity, diskinfo);
719 else
720 scsicam_bios_param(bdev, sdkp->capacity, diskinfo);
721
722 geo->heads = diskinfo[0];
723 geo->sectors = diskinfo[1];
724 geo->cylinders = diskinfo[2];
725 return 0;
726}
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742static int sd_ioctl(struct block_device *bdev, fmode_t mode,
743 unsigned int cmd, unsigned long arg)
744{
745 struct gendisk *disk = bdev->bd_disk;
746 struct scsi_device *sdp = scsi_disk(disk)->device;
747 void __user *p = (void __user *)arg;
748 int error;
749
750 SCSI_LOG_IOCTL(1, printk("sd_ioctl: disk=%s, cmd=0x%x\n",
751 disk->disk_name, cmd));
752
753
754
755
756
757
758
759 error = scsi_nonblockable_ioctl(sdp, cmd, p,
760 (mode & FMODE_NDELAY) != 0);
761 if (!scsi_block_when_processing_errors(sdp) || !error)
762 return error;
763
764
765
766
767
768
769 switch (cmd) {
770 case SCSI_IOCTL_GET_IDLUN:
771 case SCSI_IOCTL_GET_BUS_NUMBER:
772 return scsi_ioctl(sdp, cmd, p);
773 default:
774 error = scsi_cmd_ioctl(disk->queue, disk, mode, cmd, p);
775 if (error != -ENOTTY)
776 return error;
777 }
778 return scsi_ioctl(sdp, cmd, p);
779}
780
781static void set_media_not_present(struct scsi_disk *sdkp)
782{
783 sdkp->media_present = 0;
784 sdkp->capacity = 0;
785 sdkp->device->changed = 1;
786}
787
788
789
790
791
792
793
794
795
796static int sd_media_changed(struct gendisk *disk)
797{
798 struct scsi_disk *sdkp = scsi_disk(disk);
799 struct scsi_device *sdp = sdkp->device;
800 struct scsi_sense_hdr *sshdr = NULL;
801 int retval;
802
803 SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_media_changed\n"));
804
805 if (!sdp->removable)
806 return 0;
807
808
809
810
811
812
813
814 if (!scsi_device_online(sdp)) {
815 set_media_not_present(sdkp);
816 retval = 1;
817 goto out;
818 }
819
820
821
822
823
824
825
826
827
828
829 retval = -ENODEV;
830
831 if (scsi_block_when_processing_errors(sdp)) {
832 sshdr = kzalloc(sizeof(*sshdr), GFP_KERNEL);
833 retval = scsi_test_unit_ready(sdp, SD_TIMEOUT, SD_MAX_RETRIES,
834 sshdr);
835 }
836
837
838
839
840
841
842
843 if (retval || (scsi_sense_valid(sshdr) &&
844
845 sshdr->asc == 0x3a)) {
846 set_media_not_present(sdkp);
847 retval = 1;
848 goto out;
849 }
850
851
852
853
854
855
856 sdkp->media_present = 1;
857
858 retval = sdp->changed;
859 sdp->changed = 0;
860out:
861 if (retval != sdkp->previous_state)
862 sdev_evt_send_simple(sdp, SDEV_EVT_MEDIA_CHANGE, GFP_KERNEL);
863 sdkp->previous_state = retval;
864 kfree(sshdr);
865 return retval;
866}
867
868static int sd_sync_cache(struct scsi_disk *sdkp)
869{
870 int retries, res;
871 struct scsi_device *sdp = sdkp->device;
872 struct scsi_sense_hdr sshdr;
873
874 if (!scsi_device_online(sdp))
875 return -ENODEV;
876
877
878 for (retries = 3; retries > 0; --retries) {
879 unsigned char cmd[10] = { 0 };
880
881 cmd[0] = SYNCHRONIZE_CACHE;
882
883
884
885
886 res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
887 SD_TIMEOUT, SD_MAX_RETRIES);
888 if (res == 0)
889 break;
890 }
891
892 if (res) {
893 sd_print_result(sdkp, res);
894 if (driver_byte(res) & DRIVER_SENSE)
895 sd_print_sense_hdr(sdkp, &sshdr);
896 }
897
898 if (res)
899 return -EIO;
900 return 0;
901}
902
903static void sd_prepare_flush(struct request_queue *q, struct request *rq)
904{
905 rq->cmd_type = REQ_TYPE_BLOCK_PC;
906 rq->timeout = SD_TIMEOUT;
907 rq->cmd[0] = SYNCHRONIZE_CACHE;
908 rq->cmd_len = 10;
909}
910
911static void sd_rescan(struct device *dev)
912{
913 struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
914
915 if (sdkp) {
916 revalidate_disk(sdkp->disk);
917 scsi_disk_put(sdkp);
918 }
919}
920
921
922#ifdef CONFIG_COMPAT
923
924
925
926
927static int sd_compat_ioctl(struct block_device *bdev, fmode_t mode,
928 unsigned int cmd, unsigned long arg)
929{
930 struct scsi_device *sdev = scsi_disk(bdev->bd_disk)->device;
931
932
933
934
935
936
937
938 if (!scsi_block_when_processing_errors(sdev))
939 return -ENODEV;
940
941 if (sdev->host->hostt->compat_ioctl) {
942 int ret;
943
944 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
945
946 return ret;
947 }
948
949
950
951
952 return -ENOIOCTLCMD;
953}
954#endif
955
956static struct block_device_operations sd_fops = {
957 .owner = THIS_MODULE,
958 .open = sd_open,
959 .release = sd_release,
960 .locked_ioctl = sd_ioctl,
961 .getgeo = sd_getgeo,
962#ifdef CONFIG_COMPAT
963 .compat_ioctl = sd_compat_ioctl,
964#endif
965 .media_changed = sd_media_changed,
966 .revalidate_disk = sd_revalidate_disk,
967};
968
969static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
970{
971 u64 start_lba = scmd->request->sector;
972 u64 end_lba = scmd->request->sector + (scsi_bufflen(scmd) / 512);
973 u64 bad_lba;
974 int info_valid;
975
976 if (!blk_fs_request(scmd->request))
977 return 0;
978
979 info_valid = scsi_get_sense_info_fld(scmd->sense_buffer,
980 SCSI_SENSE_BUFFERSIZE,
981 &bad_lba);
982 if (!info_valid)
983 return 0;
984
985 if (scsi_bufflen(scmd) <= scmd->device->sector_size)
986 return 0;
987
988 if (scmd->device->sector_size < 512) {
989
990 start_lba <<= 1;
991 end_lba <<= 1;
992 } else {
993
994 u64 factor = scmd->device->sector_size / 512;
995 do_div(start_lba, factor);
996 do_div(end_lba, factor);
997 }
998
999
1000
1001
1002 if (bad_lba < start_lba || bad_lba >= end_lba)
1003 return 0;
1004
1005
1006
1007
1008 return (bad_lba - start_lba) * scmd->device->sector_size;
1009}
1010
1011
1012
1013
1014
1015
1016
1017
1018static int sd_done(struct scsi_cmnd *SCpnt)
1019{
1020 int result = SCpnt->result;
1021 unsigned int good_bytes = result ? 0 : scsi_bufflen(SCpnt);
1022 struct scsi_sense_hdr sshdr;
1023 int sense_valid = 0;
1024 int sense_deferred = 0;
1025
1026 if (result) {
1027 sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr);
1028 if (sense_valid)
1029 sense_deferred = scsi_sense_is_deferred(&sshdr);
1030 }
1031#ifdef CONFIG_SCSI_LOGGING
1032 SCSI_LOG_HLCOMPLETE(1, scsi_print_result(SCpnt));
1033 if (sense_valid) {
1034 SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, SCpnt,
1035 "sd_done: sb[respc,sk,asc,"
1036 "ascq]=%x,%x,%x,%x\n",
1037 sshdr.response_code,
1038 sshdr.sense_key, sshdr.asc,
1039 sshdr.ascq));
1040 }
1041#endif
1042 if (driver_byte(result) != DRIVER_SENSE &&
1043 (!sense_valid || sense_deferred))
1044 goto out;
1045
1046 switch (sshdr.sense_key) {
1047 case HARDWARE_ERROR:
1048 case MEDIUM_ERROR:
1049 good_bytes = sd_completed_bytes(SCpnt);
1050 break;
1051 case RECOVERED_ERROR:
1052
1053
1054
1055 scsi_print_sense("sd", SCpnt);
1056 SCpnt->result = 0;
1057 memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1058 good_bytes = scsi_bufflen(SCpnt);
1059 break;
1060 case NO_SENSE:
1061
1062
1063
1064
1065 scsi_print_sense("sd", SCpnt);
1066 SCpnt->result = 0;
1067 memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1068 break;
1069 case ABORTED_COMMAND:
1070 if (sshdr.asc == 0x10) {
1071 scsi_print_result(SCpnt);
1072 scsi_print_sense("sd", SCpnt);
1073 good_bytes = sd_completed_bytes(SCpnt);
1074 }
1075 break;
1076 case ILLEGAL_REQUEST:
1077 if (sshdr.asc == 0x10) {
1078 scsi_print_result(SCpnt);
1079 scsi_print_sense("sd", SCpnt);
1080 good_bytes = sd_completed_bytes(SCpnt);
1081 }
1082 break;
1083 default:
1084 break;
1085 }
1086 out:
1087 if (rq_data_dir(SCpnt->request) == READ && scsi_prot_sg_count(SCpnt))
1088 sd_dif_complete(SCpnt, good_bytes);
1089
1090 return good_bytes;
1091}
1092
1093static int media_not_present(struct scsi_disk *sdkp,
1094 struct scsi_sense_hdr *sshdr)
1095{
1096
1097 if (!scsi_sense_valid(sshdr))
1098 return 0;
1099
1100 if (sshdr->sense_key != NOT_READY &&
1101 sshdr->sense_key != UNIT_ATTENTION)
1102 return 0;
1103 if (sshdr->asc != 0x3A)
1104 return 0;
1105
1106 set_media_not_present(sdkp);
1107 return 1;
1108}
1109
1110
1111
1112
1113static void
1114sd_spinup_disk(struct scsi_disk *sdkp)
1115{
1116 unsigned char cmd[10];
1117 unsigned long spintime_expire = 0;
1118 int retries, spintime;
1119 unsigned int the_result;
1120 struct scsi_sense_hdr sshdr;
1121 int sense_valid = 0;
1122
1123 spintime = 0;
1124
1125
1126
1127 do {
1128 retries = 0;
1129
1130 do {
1131 cmd[0] = TEST_UNIT_READY;
1132 memset((void *) &cmd[1], 0, 9);
1133
1134 the_result = scsi_execute_req(sdkp->device, cmd,
1135 DMA_NONE, NULL, 0,
1136 &sshdr, SD_TIMEOUT,
1137 SD_MAX_RETRIES);
1138
1139
1140
1141
1142
1143
1144 if (media_not_present(sdkp, &sshdr))
1145 return;
1146
1147 if (the_result)
1148 sense_valid = scsi_sense_valid(&sshdr);
1149 retries++;
1150 } while (retries < 3 &&
1151 (!scsi_status_is_good(the_result) ||
1152 ((driver_byte(the_result) & DRIVER_SENSE) &&
1153 sense_valid && sshdr.sense_key == UNIT_ATTENTION)));
1154
1155 if ((driver_byte(the_result) & DRIVER_SENSE) == 0) {
1156
1157
1158 if(!spintime && !scsi_status_is_good(the_result)) {
1159 sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
1160 sd_print_result(sdkp, the_result);
1161 }
1162 break;
1163 }
1164
1165
1166
1167
1168 if (sdkp->device->no_start_on_add) {
1169 break;
1170 }
1171
1172
1173
1174
1175
1176 if (sense_valid &&
1177 sshdr.sense_key == NOT_READY &&
1178 sshdr.asc == 4 && sshdr.ascq == 3) {
1179 break;
1180
1181
1182
1183
1184 } else if (sense_valid && sshdr.sense_key == NOT_READY) {
1185 if (!spintime) {
1186 sd_printk(KERN_NOTICE, sdkp, "Spinning up disk...");
1187 cmd[0] = START_STOP;
1188 cmd[1] = 1;
1189 memset((void *) &cmd[2], 0, 8);
1190 cmd[4] = 1;
1191 if (sdkp->device->start_stop_pwr_cond)
1192 cmd[4] |= 1 << 4;
1193 scsi_execute_req(sdkp->device, cmd, DMA_NONE,
1194 NULL, 0, &sshdr,
1195 SD_TIMEOUT, SD_MAX_RETRIES);
1196 spintime_expire = jiffies + 100 * HZ;
1197 spintime = 1;
1198 }
1199
1200 msleep(1000);
1201 printk(".");
1202
1203
1204
1205
1206
1207
1208 } else if (sense_valid &&
1209 sshdr.sense_key == UNIT_ATTENTION &&
1210 sshdr.asc == 0x28) {
1211 if (!spintime) {
1212 spintime_expire = jiffies + 5 * HZ;
1213 spintime = 1;
1214 }
1215
1216 msleep(1000);
1217 } else {
1218
1219
1220 if(!spintime) {
1221 sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
1222 sd_print_sense_hdr(sdkp, &sshdr);
1223 }
1224 break;
1225 }
1226
1227 } while (spintime && time_before_eq(jiffies, spintime_expire));
1228
1229 if (spintime) {
1230 if (scsi_status_is_good(the_result))
1231 printk("ready\n");
1232 else
1233 printk("not responding...\n");
1234 }
1235}
1236
1237
1238
1239
1240
1241void sd_read_protection_type(struct scsi_disk *sdkp, unsigned char *buffer)
1242{
1243 struct scsi_device *sdp = sdkp->device;
1244 u8 type;
1245
1246 if (scsi_device_protection(sdp) == 0 || (buffer[12] & 1) == 0)
1247 type = 0;
1248 else
1249 type = ((buffer[12] >> 1) & 7) + 1;
1250
1251 sdkp->protection_type = type;
1252
1253 switch (type) {
1254 case SD_DIF_TYPE0_PROTECTION:
1255 case SD_DIF_TYPE1_PROTECTION:
1256 case SD_DIF_TYPE3_PROTECTION:
1257 break;
1258
1259 case SD_DIF_TYPE2_PROTECTION:
1260 sd_printk(KERN_ERR, sdkp, "formatted with DIF Type 2 " \
1261 "protection which is currently unsupported. " \
1262 "Disabling disk!\n");
1263 goto disable;
1264
1265 default:
1266 sd_printk(KERN_ERR, sdkp, "formatted with unknown " \
1267 "protection type %d. Disabling disk!\n", type);
1268 goto disable;
1269 }
1270
1271 return;
1272
1273disable:
1274 sdkp->capacity = 0;
1275}
1276
1277
1278
1279
1280static void
1281sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer)
1282{
1283 unsigned char cmd[16];
1284 int the_result, retries;
1285 int sector_size = 0;
1286
1287 int longrc = scsi_device_protection(sdkp->device) ? 1 : 0;
1288 struct scsi_sense_hdr sshdr;
1289 int sense_valid = 0;
1290 struct scsi_device *sdp = sdkp->device;
1291
1292repeat:
1293 retries = 3;
1294 do {
1295 if (longrc) {
1296 memset((void *) cmd, 0, 16);
1297 cmd[0] = SERVICE_ACTION_IN;
1298 cmd[1] = SAI_READ_CAPACITY_16;
1299 cmd[13] = 13;
1300 memset((void *) buffer, 0, 13);
1301 } else {
1302 cmd[0] = READ_CAPACITY;
1303 memset((void *) &cmd[1], 0, 9);
1304 memset((void *) buffer, 0, 8);
1305 }
1306
1307 the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
1308 buffer, longrc ? 13 : 8, &sshdr,
1309 SD_TIMEOUT, SD_MAX_RETRIES);
1310
1311 if (media_not_present(sdkp, &sshdr))
1312 return;
1313
1314 if (the_result)
1315 sense_valid = scsi_sense_valid(&sshdr);
1316 retries--;
1317
1318 } while (the_result && retries);
1319
1320 if (the_result && !longrc) {
1321 sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY failed\n");
1322 sd_print_result(sdkp, the_result);
1323 if (driver_byte(the_result) & DRIVER_SENSE)
1324 sd_print_sense_hdr(sdkp, &sshdr);
1325 else
1326 sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n");
1327
1328
1329
1330 if (sdp->removable &&
1331 sense_valid && sshdr.sense_key == NOT_READY)
1332 sdp->changed = 1;
1333
1334
1335
1336
1337 sdkp->capacity = 0;
1338
1339 return;
1340 } else if (the_result && longrc) {
1341
1342 sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY(16) failed\n");
1343 sd_print_result(sdkp, the_result);
1344 sd_printk(KERN_NOTICE, sdkp, "Use 0xffffffff as device size\n");
1345
1346 sdkp->capacity = 1 + (sector_t) 0xffffffff;
1347 goto got_data;
1348 }
1349
1350 if (!longrc) {
1351 sector_size = (buffer[4] << 24) |
1352 (buffer[5] << 16) | (buffer[6] << 8) | buffer[7];
1353 if (buffer[0] == 0xff && buffer[1] == 0xff &&
1354 buffer[2] == 0xff && buffer[3] == 0xff) {
1355 if(sizeof(sdkp->capacity) > 4) {
1356 sd_printk(KERN_NOTICE, sdkp, "Very big device. "
1357 "Trying to use READ CAPACITY(16).\n");
1358 longrc = 1;
1359 goto repeat;
1360 }
1361 sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use "
1362 "a kernel compiled with support for large "
1363 "block devices.\n");
1364 sdkp->capacity = 0;
1365 goto got_data;
1366 }
1367 sdkp->capacity = 1 + (((sector_t)buffer[0] << 24) |
1368 (buffer[1] << 16) |
1369 (buffer[2] << 8) |
1370 buffer[3]);
1371 } else {
1372 sdkp->capacity = 1 + (((u64)buffer[0] << 56) |
1373 ((u64)buffer[1] << 48) |
1374 ((u64)buffer[2] << 40) |
1375 ((u64)buffer[3] << 32) |
1376 ((sector_t)buffer[4] << 24) |
1377 ((sector_t)buffer[5] << 16) |
1378 ((sector_t)buffer[6] << 8) |
1379 (sector_t)buffer[7]);
1380
1381 sector_size = (buffer[8] << 24) |
1382 (buffer[9] << 16) | (buffer[10] << 8) | buffer[11];
1383
1384 sd_read_protection_type(sdkp, buffer);
1385 }
1386
1387
1388
1389 if (sdp->fix_capacity) {
1390 --sdkp->capacity;
1391
1392
1393
1394
1395 } else {
1396 if (sdp->guess_capacity)
1397 if (sdkp->capacity & 0x01)
1398 --sdkp->capacity;
1399 }
1400
1401got_data:
1402 if (sector_size == 0) {
1403 sector_size = 512;
1404 sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, "
1405 "assuming 512.\n");
1406 }
1407
1408 if (sector_size != 512 &&
1409 sector_size != 1024 &&
1410 sector_size != 2048 &&
1411 sector_size != 4096 &&
1412 sector_size != 256) {
1413 sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n",
1414 sector_size);
1415
1416
1417
1418
1419
1420
1421 sdkp->capacity = 0;
1422
1423
1424
1425
1426
1427
1428 sector_size = 512;
1429 }
1430 blk_queue_hardsect_size(sdp->request_queue, sector_size);
1431
1432 {
1433 char cap_str_2[10], cap_str_10[10];
1434 u64 sz = (u64)sdkp->capacity << ilog2(sector_size);
1435
1436 string_get_size(sz, STRING_UNITS_2, cap_str_2,
1437 sizeof(cap_str_2));
1438 string_get_size(sz, STRING_UNITS_10, cap_str_10,
1439 sizeof(cap_str_10));
1440
1441 sd_printk(KERN_NOTICE, sdkp,
1442 "%llu %d-byte hardware sectors: (%s/%s)\n",
1443 (unsigned long long)sdkp->capacity,
1444 sector_size, cap_str_10, cap_str_2);
1445 }
1446
1447
1448 if (sector_size == 4096)
1449 sdkp->capacity <<= 3;
1450 else if (sector_size == 2048)
1451 sdkp->capacity <<= 2;
1452 else if (sector_size == 1024)
1453 sdkp->capacity <<= 1;
1454 else if (sector_size == 256)
1455 sdkp->capacity >>= 1;
1456
1457 sdkp->device->sector_size = sector_size;
1458}
1459
1460
1461static inline int
1462sd_do_mode_sense(struct scsi_device *sdp, int dbd, int modepage,
1463 unsigned char *buffer, int len, struct scsi_mode_data *data,
1464 struct scsi_sense_hdr *sshdr)
1465{
1466 return scsi_mode_sense(sdp, dbd, modepage, buffer, len,
1467 SD_TIMEOUT, SD_MAX_RETRIES, data,
1468 sshdr);
1469}
1470
1471
1472
1473
1474
1475static void
1476sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer)
1477{
1478 int res;
1479 struct scsi_device *sdp = sdkp->device;
1480 struct scsi_mode_data data;
1481
1482 set_disk_ro(sdkp->disk, 0);
1483 if (sdp->skip_ms_page_3f) {
1484 sd_printk(KERN_NOTICE, sdkp, "Assuming Write Enabled\n");
1485 return;
1486 }
1487
1488 if (sdp->use_192_bytes_for_3f) {
1489 res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 192, &data, NULL);
1490 } else {
1491
1492
1493
1494
1495
1496 res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 4, &data, NULL);
1497
1498
1499
1500
1501
1502
1503
1504 if (!scsi_status_is_good(res))
1505 res = sd_do_mode_sense(sdp, 0, 0, buffer, 4, &data, NULL);
1506
1507
1508
1509
1510 if (!scsi_status_is_good(res))
1511 res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 255,
1512 &data, NULL);
1513 }
1514
1515 if (!scsi_status_is_good(res)) {
1516 sd_printk(KERN_WARNING, sdkp,
1517 "Test WP failed, assume Write Enabled\n");
1518 } else {
1519 sdkp->write_prot = ((data.device_specific & 0x80) != 0);
1520 set_disk_ro(sdkp->disk, sdkp->write_prot);
1521 sd_printk(KERN_NOTICE, sdkp, "Write Protect is %s\n",
1522 sdkp->write_prot ? "on" : "off");
1523 sd_printk(KERN_DEBUG, sdkp,
1524 "Mode Sense: %02x %02x %02x %02x\n",
1525 buffer[0], buffer[1], buffer[2], buffer[3]);
1526 }
1527}
1528
1529
1530
1531
1532
1533static void
1534sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
1535{
1536 int len = 0, res;
1537 struct scsi_device *sdp = sdkp->device;
1538
1539 int dbd;
1540 int modepage;
1541 struct scsi_mode_data data;
1542 struct scsi_sense_hdr sshdr;
1543
1544 if (sdp->skip_ms_page_8)
1545 goto defaults;
1546
1547 if (sdp->type == TYPE_RBC) {
1548 modepage = 6;
1549 dbd = 8;
1550 } else {
1551 modepage = 8;
1552 dbd = 0;
1553 }
1554
1555
1556 res = sd_do_mode_sense(sdp, dbd, modepage, buffer, 4, &data, &sshdr);
1557
1558 if (!scsi_status_is_good(res))
1559 goto bad_sense;
1560
1561 if (!data.header_length) {
1562 modepage = 6;
1563 sd_printk(KERN_ERR, sdkp, "Missing header in MODE_SENSE response\n");
1564 }
1565
1566
1567 len = data.length;
1568
1569
1570
1571
1572
1573 if (len < 3)
1574 goto bad_sense;
1575 if (len > 20)
1576 len = 20;
1577
1578
1579 len += data.header_length + data.block_descriptor_length;
1580 if (len > SD_BUF_SIZE)
1581 goto bad_sense;
1582
1583
1584 res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len, &data, &sshdr);
1585
1586 if (scsi_status_is_good(res)) {
1587 int offset = data.header_length + data.block_descriptor_length;
1588
1589 if (offset >= SD_BUF_SIZE - 2) {
1590 sd_printk(KERN_ERR, sdkp, "Malformed MODE SENSE response\n");
1591 goto defaults;
1592 }
1593
1594 if ((buffer[offset] & 0x3f) != modepage) {
1595 sd_printk(KERN_ERR, sdkp, "Got wrong page\n");
1596 goto defaults;
1597 }
1598
1599 if (modepage == 8) {
1600 sdkp->WCE = ((buffer[offset + 2] & 0x04) != 0);
1601 sdkp->RCD = ((buffer[offset + 2] & 0x01) != 0);
1602 } else {
1603 sdkp->WCE = ((buffer[offset + 2] & 0x01) == 0);
1604 sdkp->RCD = 0;
1605 }
1606
1607 sdkp->DPOFUA = (data.device_specific & 0x10) != 0;
1608 if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw) {
1609 sd_printk(KERN_NOTICE, sdkp,
1610 "Uses READ/WRITE(6), disabling FUA\n");
1611 sdkp->DPOFUA = 0;
1612 }
1613
1614 sd_printk(KERN_NOTICE, sdkp,
1615 "Write cache: %s, read cache: %s, %s\n",
1616 sdkp->WCE ? "enabled" : "disabled",
1617 sdkp->RCD ? "disabled" : "enabled",
1618 sdkp->DPOFUA ? "supports DPO and FUA"
1619 : "doesn't support DPO or FUA");
1620
1621 return;
1622 }
1623
1624bad_sense:
1625 if (scsi_sense_valid(&sshdr) &&
1626 sshdr.sense_key == ILLEGAL_REQUEST &&
1627 sshdr.asc == 0x24 && sshdr.ascq == 0x0)
1628
1629 sd_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n");
1630 else
1631 sd_printk(KERN_ERR, sdkp, "Asking for cache data failed\n");
1632
1633defaults:
1634 sd_printk(KERN_ERR, sdkp, "Assuming drive cache: write through\n");
1635 sdkp->WCE = 0;
1636 sdkp->RCD = 0;
1637 sdkp->DPOFUA = 0;
1638}
1639
1640
1641
1642
1643
1644void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer)
1645{
1646 int res, offset;
1647 struct scsi_device *sdp = sdkp->device;
1648 struct scsi_mode_data data;
1649 struct scsi_sense_hdr sshdr;
1650
1651 if (sdp->type != TYPE_DISK)
1652 return;
1653
1654 if (sdkp->protection_type == 0)
1655 return;
1656
1657 res = scsi_mode_sense(sdp, 1, 0x0a, buffer, 36, SD_TIMEOUT,
1658 SD_MAX_RETRIES, &data, &sshdr);
1659
1660 if (!scsi_status_is_good(res) || !data.header_length ||
1661 data.length < 6) {
1662 sd_printk(KERN_WARNING, sdkp,
1663 "getting Control mode page failed, assume no ATO\n");
1664
1665 if (scsi_sense_valid(&sshdr))
1666 sd_print_sense_hdr(sdkp, &sshdr);
1667
1668 return;
1669 }
1670
1671 offset = data.header_length + data.block_descriptor_length;
1672
1673 if ((buffer[offset] & 0x3f) != 0x0a) {
1674 sd_printk(KERN_ERR, sdkp, "ATO Got wrong page\n");
1675 return;
1676 }
1677
1678 if ((buffer[offset + 5] & 0x80) == 0)
1679 return;
1680
1681 sdkp->ATO = 1;
1682
1683 return;
1684}
1685
1686
1687
1688
1689
1690
1691static int sd_revalidate_disk(struct gendisk *disk)
1692{
1693 struct scsi_disk *sdkp = scsi_disk(disk);
1694 struct scsi_device *sdp = sdkp->device;
1695 unsigned char *buffer;
1696 unsigned ordered;
1697
1698 SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp,
1699 "sd_revalidate_disk\n"));
1700
1701
1702
1703
1704
1705 if (!scsi_device_online(sdp))
1706 goto out;
1707
1708 buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL);
1709 if (!buffer) {
1710 sd_printk(KERN_WARNING, sdkp, "sd_revalidate_disk: Memory "
1711 "allocation failure.\n");
1712 goto out;
1713 }
1714
1715
1716 sdp->sector_size = 512;
1717 sdkp->capacity = 0;
1718 sdkp->media_present = 1;
1719 sdkp->write_prot = 0;
1720 sdkp->WCE = 0;
1721 sdkp->RCD = 0;
1722 sdkp->ATO = 0;
1723
1724 sd_spinup_disk(sdkp);
1725
1726
1727
1728
1729
1730 if (sdkp->media_present) {
1731 sd_read_capacity(sdkp, buffer);
1732 sd_read_write_protect_flag(sdkp, buffer);
1733 sd_read_cache_type(sdkp, buffer);
1734 sd_read_app_tag_own(sdkp, buffer);
1735 }
1736
1737
1738
1739
1740
1741
1742
1743 if (sdkp->WCE)
1744 ordered = sdkp->DPOFUA
1745 ? QUEUE_ORDERED_DRAIN_FUA : QUEUE_ORDERED_DRAIN_FLUSH;
1746 else
1747 ordered = QUEUE_ORDERED_DRAIN;
1748
1749 blk_queue_ordered(sdkp->disk->queue, ordered, sd_prepare_flush);
1750
1751 set_capacity(disk, sdkp->capacity);
1752 kfree(buffer);
1753
1754 out:
1755 return 0;
1756}
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780static int sd_format_disk_name(char *prefix, int index, char *buf, int buflen)
1781{
1782 const int base = 'z' - 'a' + 1;
1783 char *begin = buf + strlen(prefix);
1784 char *end = buf + buflen;
1785 char *p;
1786 int unit;
1787
1788 p = end - 1;
1789 *p = '\0';
1790 unit = base;
1791 do {
1792 if (p == begin)
1793 return -EINVAL;
1794 *--p = 'a' + (index % unit);
1795 index = (index / unit) - 1;
1796 } while (index >= 0);
1797
1798 memmove(begin, p, end - p);
1799 memcpy(buf, prefix, strlen(prefix));
1800
1801 return 0;
1802}
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822static int sd_probe(struct device *dev)
1823{
1824 struct scsi_device *sdp = to_scsi_device(dev);
1825 struct scsi_disk *sdkp;
1826 struct gendisk *gd;
1827 u32 index;
1828 int error;
1829
1830 error = -ENODEV;
1831 if (sdp->type != TYPE_DISK && sdp->type != TYPE_MOD && sdp->type != TYPE_RBC)
1832 goto out;
1833
1834 SCSI_LOG_HLQUEUE(3, sdev_printk(KERN_INFO, sdp,
1835 "sd_attach\n"));
1836
1837 error = -ENOMEM;
1838 sdkp = kzalloc(sizeof(*sdkp), GFP_KERNEL);
1839 if (!sdkp)
1840 goto out;
1841
1842 gd = alloc_disk(SD_MINORS);
1843 if (!gd)
1844 goto out_free;
1845
1846 do {
1847 if (!ida_pre_get(&sd_index_ida, GFP_KERNEL))
1848 goto out_put;
1849
1850 error = ida_get_new(&sd_index_ida, &index);
1851 } while (error == -EAGAIN);
1852
1853 if (error)
1854 goto out_put;
1855
1856 error = sd_format_disk_name("sd", index, gd->disk_name, DISK_NAME_LEN);
1857 if (error)
1858 goto out_free_index;
1859
1860 sdkp->device = sdp;
1861 sdkp->driver = &sd_template;
1862 sdkp->disk = gd;
1863 sdkp->index = index;
1864 sdkp->openers = 0;
1865 sdkp->previous_state = 1;
1866
1867 if (!sdp->request_queue->rq_timeout) {
1868 if (sdp->type != TYPE_MOD)
1869 blk_queue_rq_timeout(sdp->request_queue, SD_TIMEOUT);
1870 else
1871 blk_queue_rq_timeout(sdp->request_queue,
1872 SD_MOD_TIMEOUT);
1873 }
1874
1875 device_initialize(&sdkp->dev);
1876 sdkp->dev.parent = &sdp->sdev_gendev;
1877 sdkp->dev.class = &sd_disk_class;
1878 strncpy(sdkp->dev.bus_id, sdp->sdev_gendev.bus_id, BUS_ID_SIZE);
1879
1880 if (device_add(&sdkp->dev))
1881 goto out_free_index;
1882
1883 get_device(&sdp->sdev_gendev);
1884
1885 if (index < SD_MAX_DISKS) {
1886 gd->major = sd_major((index & 0xf0) >> 4);
1887 gd->first_minor = ((index & 0xf) << 4) | (index & 0xfff00);
1888 gd->minors = SD_MINORS;
1889 }
1890 gd->fops = &sd_fops;
1891 gd->private_data = &sdkp->driver;
1892 gd->queue = sdkp->device->request_queue;
1893
1894 sd_revalidate_disk(gd);
1895
1896 blk_queue_prep_rq(sdp->request_queue, sd_prep_fn);
1897
1898 gd->driverfs_dev = &sdp->sdev_gendev;
1899 gd->flags = GENHD_FL_EXT_DEVT | GENHD_FL_DRIVERFS;
1900 if (sdp->removable)
1901 gd->flags |= GENHD_FL_REMOVABLE;
1902
1903 dev_set_drvdata(dev, sdkp);
1904 add_disk(gd);
1905 sd_dif_config_host(sdkp);
1906
1907 sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n",
1908 sdp->removable ? "removable " : "");
1909
1910 return 0;
1911
1912 out_free_index:
1913 ida_remove(&sd_index_ida, index);
1914 out_put:
1915 put_disk(gd);
1916 out_free:
1917 kfree(sdkp);
1918 out:
1919 return error;
1920}
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933static int sd_remove(struct device *dev)
1934{
1935 struct scsi_disk *sdkp = dev_get_drvdata(dev);
1936
1937 device_del(&sdkp->dev);
1938 del_gendisk(sdkp->disk);
1939 sd_shutdown(dev);
1940
1941 mutex_lock(&sd_ref_mutex);
1942 dev_set_drvdata(dev, NULL);
1943 put_device(&sdkp->dev);
1944 mutex_unlock(&sd_ref_mutex);
1945
1946 return 0;
1947}
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958static void scsi_disk_release(struct device *dev)
1959{
1960 struct scsi_disk *sdkp = to_scsi_disk(dev);
1961 struct gendisk *disk = sdkp->disk;
1962
1963 ida_remove(&sd_index_ida, sdkp->index);
1964
1965 disk->private_data = NULL;
1966 put_disk(disk);
1967 put_device(&sdkp->device->sdev_gendev);
1968
1969 kfree(sdkp);
1970}
1971
1972static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
1973{
1974 unsigned char cmd[6] = { START_STOP };
1975 struct scsi_sense_hdr sshdr;
1976 struct scsi_device *sdp = sdkp->device;
1977 int res;
1978
1979 if (start)
1980 cmd[4] |= 1;
1981
1982 if (sdp->start_stop_pwr_cond)
1983 cmd[4] |= start ? 1 << 4 : 3 << 4;
1984
1985 if (!scsi_device_online(sdp))
1986 return -ENODEV;
1987
1988 res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
1989 SD_TIMEOUT, SD_MAX_RETRIES);
1990 if (res) {
1991 sd_printk(KERN_WARNING, sdkp, "START_STOP FAILED\n");
1992 sd_print_result(sdkp, res);
1993 if (driver_byte(res) & DRIVER_SENSE)
1994 sd_print_sense_hdr(sdkp, &sshdr);
1995 }
1996
1997 return res;
1998}
1999
2000
2001
2002
2003
2004
2005static void sd_shutdown(struct device *dev)
2006{
2007 struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
2008
2009 if (!sdkp)
2010 return;
2011
2012 if (sdkp->WCE) {
2013 sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
2014 sd_sync_cache(sdkp);
2015 }
2016
2017 if (system_state != SYSTEM_RESTART && sdkp->device->manage_start_stop) {
2018 sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
2019 sd_start_stop_device(sdkp, 0);
2020 }
2021
2022 scsi_disk_put(sdkp);
2023}
2024
2025static int sd_suspend(struct device *dev, pm_message_t mesg)
2026{
2027 struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
2028 int ret = 0;
2029
2030 if (!sdkp)
2031 return 0;
2032
2033 if (sdkp->WCE) {
2034 sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
2035 ret = sd_sync_cache(sdkp);
2036 if (ret)
2037 goto done;
2038 }
2039
2040 if ((mesg.event & PM_EVENT_SLEEP) && sdkp->device->manage_start_stop) {
2041 sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
2042 ret = sd_start_stop_device(sdkp, 0);
2043 }
2044
2045done:
2046 scsi_disk_put(sdkp);
2047 return ret;
2048}
2049
2050static int sd_resume(struct device *dev)
2051{
2052 struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
2053 int ret = 0;
2054
2055 if (!sdkp->device->manage_start_stop)
2056 goto done;
2057
2058 sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
2059 ret = sd_start_stop_device(sdkp, 1);
2060
2061done:
2062 scsi_disk_put(sdkp);
2063 return ret;
2064}
2065
2066
2067
2068
2069
2070
2071
2072static int __init init_sd(void)
2073{
2074 int majors = 0, i, err;
2075
2076 SCSI_LOG_HLQUEUE(3, printk("init_sd: sd driver entry point\n"));
2077
2078 for (i = 0; i < SD_MAJORS; i++)
2079 if (register_blkdev(sd_major(i), "sd") == 0)
2080 majors++;
2081
2082 if (!majors)
2083 return -ENODEV;
2084
2085 err = class_register(&sd_disk_class);
2086 if (err)
2087 goto err_out;
2088
2089 err = scsi_register_driver(&sd_template.gendrv);
2090 if (err)
2091 goto err_out_class;
2092
2093 return 0;
2094
2095err_out_class:
2096 class_unregister(&sd_disk_class);
2097err_out:
2098 for (i = 0; i < SD_MAJORS; i++)
2099 unregister_blkdev(sd_major(i), "sd");
2100 return err;
2101}
2102
2103
2104
2105
2106
2107
2108static void __exit exit_sd(void)
2109{
2110 int i;
2111
2112 SCSI_LOG_HLQUEUE(3, printk("exit_sd: exiting sd driver\n"));
2113
2114 scsi_unregister_driver(&sd_template.gendrv);
2115 class_unregister(&sd_disk_class);
2116
2117 for (i = 0; i < SD_MAJORS; i++)
2118 unregister_blkdev(sd_major(i), "sd");
2119}
2120
2121module_init(init_sd);
2122module_exit(exit_sd);
2123
2124static void sd_print_sense_hdr(struct scsi_disk *sdkp,
2125 struct scsi_sense_hdr *sshdr)
2126{
2127 sd_printk(KERN_INFO, sdkp, "");
2128 scsi_show_sense_hdr(sshdr);
2129 sd_printk(KERN_INFO, sdkp, "");
2130 scsi_show_extd_sense(sshdr->asc, sshdr->ascq);
2131}
2132
2133static void sd_print_result(struct scsi_disk *sdkp, int result)
2134{
2135 sd_printk(KERN_INFO, sdkp, "");
2136 scsi_show_result(result);
2137}
2138