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 <linux/async.h>
52#include <linux/slab.h>
53#include <linux/pm_runtime.h>
54#include <asm/uaccess.h>
55#include <asm/unaligned.h>
56
57#include <scsi/scsi.h>
58#include <scsi/scsi_cmnd.h>
59#include <scsi/scsi_dbg.h>
60#include <scsi/scsi_device.h>
61#include <scsi/scsi_driver.h>
62#include <scsi/scsi_eh.h>
63#include <scsi/scsi_host.h>
64#include <scsi/scsi_ioctl.h>
65#include <scsi/scsicam.h>
66
67#include "sd.h"
68#include "scsi_priv.h"
69#include "scsi_logging.h"
70
71MODULE_AUTHOR("Eric Youngdale");
72MODULE_DESCRIPTION("SCSI disk (sd) driver");
73MODULE_LICENSE("GPL");
74
75MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK0_MAJOR);
76MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK1_MAJOR);
77MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK2_MAJOR);
78MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK3_MAJOR);
79MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK4_MAJOR);
80MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK5_MAJOR);
81MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK6_MAJOR);
82MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK7_MAJOR);
83MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK8_MAJOR);
84MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK9_MAJOR);
85MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK10_MAJOR);
86MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK11_MAJOR);
87MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK12_MAJOR);
88MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK13_MAJOR);
89MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK14_MAJOR);
90MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK15_MAJOR);
91MODULE_ALIAS_SCSI_DEVICE(TYPE_DISK);
92MODULE_ALIAS_SCSI_DEVICE(TYPE_MOD);
93MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC);
94
95#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
96#define SD_MINORS 16
97#else
98#define SD_MINORS 0
99#endif
100
101static void sd_config_discard(struct scsi_disk *, unsigned int);
102static void sd_config_write_same(struct scsi_disk *);
103static int sd_revalidate_disk(struct gendisk *);
104static void sd_unlock_native_capacity(struct gendisk *disk);
105static int sd_probe(struct device *);
106static int sd_remove(struct device *);
107static void sd_shutdown(struct device *);
108static int sd_suspend(struct device *);
109static int sd_resume(struct device *);
110static void sd_rescan(struct device *);
111static int sd_done(struct scsi_cmnd *);
112static int sd_eh_action(struct scsi_cmnd *, unsigned char *, int, int);
113static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
114static void scsi_disk_release(struct device *cdev);
115static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
116static void sd_print_result(struct scsi_disk *, int);
117
118static DEFINE_SPINLOCK(sd_index_lock);
119static DEFINE_IDA(sd_index_ida);
120
121
122
123
124static DEFINE_MUTEX(sd_ref_mutex);
125
126static struct kmem_cache *sd_cdb_cache;
127static mempool_t *sd_cdb_pool;
128
129static const char *sd_cache_types[] = {
130 "write through", "none", "write back",
131 "write back, no read (daft)"
132};
133
134static ssize_t
135sd_store_cache_type(struct device *dev, struct device_attribute *attr,
136 const char *buf, size_t count)
137{
138 int i, ct = -1, rcd, wce, sp;
139 struct scsi_disk *sdkp = to_scsi_disk(dev);
140 struct scsi_device *sdp = sdkp->device;
141 char buffer[64];
142 char *buffer_data;
143 struct scsi_mode_data data;
144 struct scsi_sense_hdr sshdr;
145 static const char temp[] = "temporary ";
146 int len;
147
148 if (sdp->type != TYPE_DISK)
149
150
151
152 return -EINVAL;
153
154 if (strncmp(buf, temp, sizeof(temp) - 1) == 0) {
155 buf += sizeof(temp) - 1;
156 sdkp->cache_override = 1;
157 } else {
158 sdkp->cache_override = 0;
159 }
160
161 for (i = 0; i < ARRAY_SIZE(sd_cache_types); i++) {
162 len = strlen(sd_cache_types[i]);
163 if (strncmp(sd_cache_types[i], buf, len) == 0 &&
164 buf[len] == '\n') {
165 ct = i;
166 break;
167 }
168 }
169 if (ct < 0)
170 return -EINVAL;
171 rcd = ct & 0x01 ? 1 : 0;
172 wce = ct & 0x02 ? 1 : 0;
173
174 if (sdkp->cache_override) {
175 sdkp->WCE = wce;
176 sdkp->RCD = rcd;
177 return count;
178 }
179
180 if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT,
181 SD_MAX_RETRIES, &data, NULL))
182 return -EINVAL;
183 len = min_t(size_t, sizeof(buffer), data.length - data.header_length -
184 data.block_descriptor_length);
185 buffer_data = buffer + data.header_length +
186 data.block_descriptor_length;
187 buffer_data[2] &= ~0x05;
188 buffer_data[2] |= wce << 2 | rcd;
189 sp = buffer_data[0] & 0x80 ? 1 : 0;
190
191 if (scsi_mode_select(sdp, 1, sp, 8, buffer_data, len, SD_TIMEOUT,
192 SD_MAX_RETRIES, &data, &sshdr)) {
193 if (scsi_sense_valid(&sshdr))
194 sd_print_sense_hdr(sdkp, &sshdr);
195 return -EINVAL;
196 }
197 revalidate_disk(sdkp->disk);
198 return count;
199}
200
201static ssize_t
202sd_store_manage_start_stop(struct device *dev, struct device_attribute *attr,
203 const char *buf, size_t count)
204{
205 struct scsi_disk *sdkp = to_scsi_disk(dev);
206 struct scsi_device *sdp = sdkp->device;
207
208 if (!capable(CAP_SYS_ADMIN))
209 return -EACCES;
210
211 sdp->manage_start_stop = simple_strtoul(buf, NULL, 10);
212
213 return count;
214}
215
216static ssize_t
217sd_store_allow_restart(struct device *dev, struct device_attribute *attr,
218 const char *buf, size_t count)
219{
220 struct scsi_disk *sdkp = to_scsi_disk(dev);
221 struct scsi_device *sdp = sdkp->device;
222
223 if (!capable(CAP_SYS_ADMIN))
224 return -EACCES;
225
226 if (sdp->type != TYPE_DISK)
227 return -EINVAL;
228
229 sdp->allow_restart = simple_strtoul(buf, NULL, 10);
230
231 return count;
232}
233
234static ssize_t
235sd_show_cache_type(struct device *dev, struct device_attribute *attr,
236 char *buf)
237{
238 struct scsi_disk *sdkp = to_scsi_disk(dev);
239 int ct = sdkp->RCD + 2*sdkp->WCE;
240
241 return snprintf(buf, 40, "%s\n", sd_cache_types[ct]);
242}
243
244static ssize_t
245sd_show_fua(struct device *dev, struct device_attribute *attr, char *buf)
246{
247 struct scsi_disk *sdkp = to_scsi_disk(dev);
248
249 return snprintf(buf, 20, "%u\n", sdkp->DPOFUA);
250}
251
252static ssize_t
253sd_show_manage_start_stop(struct device *dev, struct device_attribute *attr,
254 char *buf)
255{
256 struct scsi_disk *sdkp = to_scsi_disk(dev);
257 struct scsi_device *sdp = sdkp->device;
258
259 return snprintf(buf, 20, "%u\n", sdp->manage_start_stop);
260}
261
262static ssize_t
263sd_show_allow_restart(struct device *dev, struct device_attribute *attr,
264 char *buf)
265{
266 struct scsi_disk *sdkp = to_scsi_disk(dev);
267
268 return snprintf(buf, 40, "%d\n", sdkp->device->allow_restart);
269}
270
271static ssize_t
272sd_show_protection_type(struct device *dev, struct device_attribute *attr,
273 char *buf)
274{
275 struct scsi_disk *sdkp = to_scsi_disk(dev);
276
277 return snprintf(buf, 20, "%u\n", sdkp->protection_type);
278}
279
280static ssize_t
281sd_store_protection_type(struct device *dev, struct device_attribute *attr,
282 const char *buf, size_t count)
283{
284 struct scsi_disk *sdkp = to_scsi_disk(dev);
285 unsigned int val;
286 int err;
287
288 if (!capable(CAP_SYS_ADMIN))
289 return -EACCES;
290
291 err = kstrtouint(buf, 10, &val);
292
293 if (err)
294 return err;
295
296 if (val >= 0 && val <= SD_DIF_TYPE3_PROTECTION)
297 sdkp->protection_type = val;
298
299 return count;
300}
301
302static ssize_t
303sd_show_protection_mode(struct device *dev, struct device_attribute *attr,
304 char *buf)
305{
306 struct scsi_disk *sdkp = to_scsi_disk(dev);
307 struct scsi_device *sdp = sdkp->device;
308 unsigned int dif, dix;
309
310 dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
311 dix = scsi_host_dix_capable(sdp->host, sdkp->protection_type);
312
313 if (!dix && scsi_host_dix_capable(sdp->host, SD_DIF_TYPE0_PROTECTION)) {
314 dif = 0;
315 dix = 1;
316 }
317
318 if (!dif && !dix)
319 return snprintf(buf, 20, "none\n");
320
321 return snprintf(buf, 20, "%s%u\n", dix ? "dix" : "dif", dif);
322}
323
324static ssize_t
325sd_show_app_tag_own(struct device *dev, struct device_attribute *attr,
326 char *buf)
327{
328 struct scsi_disk *sdkp = to_scsi_disk(dev);
329
330 return snprintf(buf, 20, "%u\n", sdkp->ATO);
331}
332
333static ssize_t
334sd_show_thin_provisioning(struct device *dev, struct device_attribute *attr,
335 char *buf)
336{
337 struct scsi_disk *sdkp = to_scsi_disk(dev);
338
339 return snprintf(buf, 20, "%u\n", sdkp->lbpme);
340}
341
342static const char *lbp_mode[] = {
343 [SD_LBP_FULL] = "full",
344 [SD_LBP_UNMAP] = "unmap",
345 [SD_LBP_WS16] = "writesame_16",
346 [SD_LBP_WS10] = "writesame_10",
347 [SD_LBP_ZERO] = "writesame_zero",
348 [SD_LBP_DISABLE] = "disabled",
349};
350
351static ssize_t
352sd_show_provisioning_mode(struct device *dev, struct device_attribute *attr,
353 char *buf)
354{
355 struct scsi_disk *sdkp = to_scsi_disk(dev);
356
357 return snprintf(buf, 20, "%s\n", lbp_mode[sdkp->provisioning_mode]);
358}
359
360static ssize_t
361sd_store_provisioning_mode(struct device *dev, struct device_attribute *attr,
362 const char *buf, size_t count)
363{
364 struct scsi_disk *sdkp = to_scsi_disk(dev);
365 struct scsi_device *sdp = sdkp->device;
366
367 if (!capable(CAP_SYS_ADMIN))
368 return -EACCES;
369
370 if (sdp->type != TYPE_DISK)
371 return -EINVAL;
372
373 if (!strncmp(buf, lbp_mode[SD_LBP_UNMAP], 20))
374 sd_config_discard(sdkp, SD_LBP_UNMAP);
375 else if (!strncmp(buf, lbp_mode[SD_LBP_WS16], 20))
376 sd_config_discard(sdkp, SD_LBP_WS16);
377 else if (!strncmp(buf, lbp_mode[SD_LBP_WS10], 20))
378 sd_config_discard(sdkp, SD_LBP_WS10);
379 else if (!strncmp(buf, lbp_mode[SD_LBP_ZERO], 20))
380 sd_config_discard(sdkp, SD_LBP_ZERO);
381 else if (!strncmp(buf, lbp_mode[SD_LBP_DISABLE], 20))
382 sd_config_discard(sdkp, SD_LBP_DISABLE);
383 else
384 return -EINVAL;
385
386 return count;
387}
388
389static ssize_t
390sd_show_max_medium_access_timeouts(struct device *dev,
391 struct device_attribute *attr, char *buf)
392{
393 struct scsi_disk *sdkp = to_scsi_disk(dev);
394
395 return snprintf(buf, 20, "%u\n", sdkp->max_medium_access_timeouts);
396}
397
398static ssize_t
399sd_store_max_medium_access_timeouts(struct device *dev,
400 struct device_attribute *attr,
401 const char *buf, size_t count)
402{
403 struct scsi_disk *sdkp = to_scsi_disk(dev);
404 int err;
405
406 if (!capable(CAP_SYS_ADMIN))
407 return -EACCES;
408
409 err = kstrtouint(buf, 10, &sdkp->max_medium_access_timeouts);
410
411 return err ? err : count;
412}
413
414static ssize_t
415sd_show_write_same_blocks(struct device *dev, struct device_attribute *attr,
416 char *buf)
417{
418 struct scsi_disk *sdkp = to_scsi_disk(dev);
419
420 return snprintf(buf, 20, "%u\n", sdkp->max_ws_blocks);
421}
422
423static ssize_t
424sd_store_write_same_blocks(struct device *dev, struct device_attribute *attr,
425 const char *buf, size_t count)
426{
427 struct scsi_disk *sdkp = to_scsi_disk(dev);
428 struct scsi_device *sdp = sdkp->device;
429 unsigned long max;
430 int err;
431
432 if (!capable(CAP_SYS_ADMIN))
433 return -EACCES;
434
435 if (sdp->type != TYPE_DISK)
436 return -EINVAL;
437
438 err = kstrtoul(buf, 10, &max);
439
440 if (err)
441 return err;
442
443 if (max == 0)
444 sdp->no_write_same = 1;
445 else if (max <= SD_MAX_WS16_BLOCKS) {
446 sdp->no_write_same = 0;
447 sdkp->max_ws_blocks = max;
448 }
449
450 sd_config_write_same(sdkp);
451
452 return count;
453}
454
455static struct device_attribute sd_disk_attrs[] = {
456 __ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
457 sd_store_cache_type),
458 __ATTR(FUA, S_IRUGO, sd_show_fua, NULL),
459 __ATTR(allow_restart, S_IRUGO|S_IWUSR, sd_show_allow_restart,
460 sd_store_allow_restart),
461 __ATTR(manage_start_stop, S_IRUGO|S_IWUSR, sd_show_manage_start_stop,
462 sd_store_manage_start_stop),
463 __ATTR(protection_type, S_IRUGO|S_IWUSR, sd_show_protection_type,
464 sd_store_protection_type),
465 __ATTR(protection_mode, S_IRUGO, sd_show_protection_mode, NULL),
466 __ATTR(app_tag_own, S_IRUGO, sd_show_app_tag_own, NULL),
467 __ATTR(thin_provisioning, S_IRUGO, sd_show_thin_provisioning, NULL),
468 __ATTR(provisioning_mode, S_IRUGO|S_IWUSR, sd_show_provisioning_mode,
469 sd_store_provisioning_mode),
470 __ATTR(max_write_same_blocks, S_IRUGO|S_IWUSR,
471 sd_show_write_same_blocks, sd_store_write_same_blocks),
472 __ATTR(max_medium_access_timeouts, S_IRUGO|S_IWUSR,
473 sd_show_max_medium_access_timeouts,
474 sd_store_max_medium_access_timeouts),
475 __ATTR_NULL,
476};
477
478static struct class sd_disk_class = {
479 .name = "scsi_disk",
480 .owner = THIS_MODULE,
481 .dev_release = scsi_disk_release,
482 .dev_attrs = sd_disk_attrs,
483};
484
485static const struct dev_pm_ops sd_pm_ops = {
486 .suspend = sd_suspend,
487 .resume = sd_resume,
488 .poweroff = sd_suspend,
489 .restore = sd_resume,
490 .runtime_suspend = sd_suspend,
491 .runtime_resume = sd_resume,
492};
493
494static struct scsi_driver sd_template = {
495 .owner = THIS_MODULE,
496 .gendrv = {
497 .name = "sd",
498 .probe = sd_probe,
499 .remove = sd_remove,
500 .shutdown = sd_shutdown,
501 .pm = &sd_pm_ops,
502 },
503 .rescan = sd_rescan,
504 .done = sd_done,
505 .eh_action = sd_eh_action,
506};
507
508
509
510
511
512
513static struct kobject *sd_default_probe(dev_t devt, int *partno, void *data)
514{
515 return NULL;
516}
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532static int sd_major(int major_idx)
533{
534 switch (major_idx) {
535 case 0:
536 return SCSI_DISK0_MAJOR;
537 case 1 ... 7:
538 return SCSI_DISK1_MAJOR + major_idx - 1;
539 case 8 ... 15:
540 return SCSI_DISK8_MAJOR + major_idx - 8;
541 default:
542 BUG();
543 return 0;
544 }
545}
546
547static struct scsi_disk *__scsi_disk_get(struct gendisk *disk)
548{
549 struct scsi_disk *sdkp = NULL;
550
551 if (disk->private_data) {
552 sdkp = scsi_disk(disk);
553 if (scsi_device_get(sdkp->device) == 0)
554 get_device(&sdkp->dev);
555 else
556 sdkp = NULL;
557 }
558 return sdkp;
559}
560
561static struct scsi_disk *scsi_disk_get(struct gendisk *disk)
562{
563 struct scsi_disk *sdkp;
564
565 mutex_lock(&sd_ref_mutex);
566 sdkp = __scsi_disk_get(disk);
567 mutex_unlock(&sd_ref_mutex);
568 return sdkp;
569}
570
571static struct scsi_disk *scsi_disk_get_from_dev(struct device *dev)
572{
573 struct scsi_disk *sdkp;
574
575 mutex_lock(&sd_ref_mutex);
576 sdkp = dev_get_drvdata(dev);
577 if (sdkp)
578 sdkp = __scsi_disk_get(sdkp->disk);
579 mutex_unlock(&sd_ref_mutex);
580 return sdkp;
581}
582
583static void scsi_disk_put(struct scsi_disk *sdkp)
584{
585 struct scsi_device *sdev = sdkp->device;
586
587 mutex_lock(&sd_ref_mutex);
588 put_device(&sdkp->dev);
589 scsi_device_put(sdev);
590 mutex_unlock(&sd_ref_mutex);
591}
592
593static void sd_prot_op(struct scsi_cmnd *scmd, unsigned int dif)
594{
595 unsigned int prot_op = SCSI_PROT_NORMAL;
596 unsigned int dix = scsi_prot_sg_count(scmd);
597
598 if (scmd->sc_data_direction == DMA_FROM_DEVICE) {
599 if (dif && dix)
600 prot_op = SCSI_PROT_READ_PASS;
601 else if (dif && !dix)
602 prot_op = SCSI_PROT_READ_STRIP;
603 else if (!dif && dix)
604 prot_op = SCSI_PROT_READ_INSERT;
605 } else {
606 if (dif && dix)
607 prot_op = SCSI_PROT_WRITE_PASS;
608 else if (dif && !dix)
609 prot_op = SCSI_PROT_WRITE_INSERT;
610 else if (!dif && dix)
611 prot_op = SCSI_PROT_WRITE_STRIP;
612 }
613
614 scsi_set_prot_op(scmd, prot_op);
615 scsi_set_prot_type(scmd, dif);
616}
617
618static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
619{
620 struct request_queue *q = sdkp->disk->queue;
621 unsigned int logical_block_size = sdkp->device->sector_size;
622 unsigned int max_blocks = 0;
623
624 q->limits.discard_zeroes_data = sdkp->lbprz;
625 q->limits.discard_alignment = sdkp->unmap_alignment *
626 logical_block_size;
627 q->limits.discard_granularity =
628 max(sdkp->physical_block_size,
629 sdkp->unmap_granularity * logical_block_size);
630
631 sdkp->provisioning_mode = mode;
632
633 switch (mode) {
634
635 case SD_LBP_DISABLE:
636 q->limits.max_discard_sectors = 0;
637 queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, q);
638 return;
639
640 case SD_LBP_UNMAP:
641 max_blocks = min_not_zero(sdkp->max_unmap_blocks,
642 (u32)SD_MAX_WS16_BLOCKS);
643 break;
644
645 case SD_LBP_WS16:
646 max_blocks = min_not_zero(sdkp->max_ws_blocks,
647 (u32)SD_MAX_WS16_BLOCKS);
648 break;
649
650 case SD_LBP_WS10:
651 max_blocks = min_not_zero(sdkp->max_ws_blocks,
652 (u32)SD_MAX_WS10_BLOCKS);
653 break;
654
655 case SD_LBP_ZERO:
656 max_blocks = min_not_zero(sdkp->max_ws_blocks,
657 (u32)SD_MAX_WS10_BLOCKS);
658 q->limits.discard_zeroes_data = 1;
659 break;
660 }
661
662 q->limits.max_discard_sectors = max_blocks * (logical_block_size >> 9);
663 queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
664}
665
666
667
668
669
670
671
672
673
674static int sd_setup_discard_cmnd(struct scsi_device *sdp, struct request *rq)
675{
676 struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
677 sector_t sector = blk_rq_pos(rq);
678 unsigned int nr_sectors = blk_rq_sectors(rq);
679 unsigned int nr_bytes = blk_rq_bytes(rq);
680 unsigned int len;
681 int ret;
682 char *buf;
683 struct page *page;
684
685 sector >>= ilog2(sdp->sector_size) - 9;
686 nr_sectors >>= ilog2(sdp->sector_size) - 9;
687 rq->timeout = SD_TIMEOUT;
688
689 memset(rq->cmd, 0, rq->cmd_len);
690
691 page = alloc_page(GFP_ATOMIC | __GFP_ZERO);
692 if (!page)
693 return BLKPREP_DEFER;
694
695 switch (sdkp->provisioning_mode) {
696 case SD_LBP_UNMAP:
697 buf = page_address(page);
698
699 rq->cmd_len = 10;
700 rq->cmd[0] = UNMAP;
701 rq->cmd[8] = 24;
702
703 put_unaligned_be16(6 + 16, &buf[0]);
704 put_unaligned_be16(16, &buf[2]);
705 put_unaligned_be64(sector, &buf[8]);
706 put_unaligned_be32(nr_sectors, &buf[16]);
707
708 len = 24;
709 break;
710
711 case SD_LBP_WS16:
712 rq->cmd_len = 16;
713 rq->cmd[0] = WRITE_SAME_16;
714 rq->cmd[1] = 0x8;
715 put_unaligned_be64(sector, &rq->cmd[2]);
716 put_unaligned_be32(nr_sectors, &rq->cmd[10]);
717
718 len = sdkp->device->sector_size;
719 break;
720
721 case SD_LBP_WS10:
722 case SD_LBP_ZERO:
723 rq->cmd_len = 10;
724 rq->cmd[0] = WRITE_SAME;
725 if (sdkp->provisioning_mode == SD_LBP_WS10)
726 rq->cmd[1] = 0x8;
727 put_unaligned_be32(sector, &rq->cmd[2]);
728 put_unaligned_be16(nr_sectors, &rq->cmd[7]);
729
730 len = sdkp->device->sector_size;
731 break;
732
733 default:
734 ret = BLKPREP_KILL;
735 goto out;
736 }
737
738 blk_add_request_payload(rq, page, len);
739 ret = scsi_setup_blk_pc_cmnd(sdp, rq);
740 rq->buffer = page_address(page);
741 rq->__data_len = nr_bytes;
742
743out:
744 if (ret != BLKPREP_OK) {
745 __free_page(page);
746 rq->buffer = NULL;
747 }
748 return ret;
749}
750
751static void sd_config_write_same(struct scsi_disk *sdkp)
752{
753 struct request_queue *q = sdkp->disk->queue;
754 unsigned int logical_block_size = sdkp->device->sector_size;
755
756 if (sdkp->device->no_write_same) {
757 sdkp->max_ws_blocks = 0;
758 goto out;
759 }
760
761
762
763
764
765
766 if (sdkp->max_ws_blocks > SD_MAX_WS10_BLOCKS)
767 sdkp->max_ws_blocks = min_not_zero(sdkp->max_ws_blocks,
768 (u32)SD_MAX_WS16_BLOCKS);
769 else if (sdkp->ws16 || sdkp->ws10 || sdkp->device->no_report_opcodes)
770 sdkp->max_ws_blocks = min_not_zero(sdkp->max_ws_blocks,
771 (u32)SD_MAX_WS10_BLOCKS);
772 else {
773 sdkp->device->no_write_same = 1;
774 sdkp->max_ws_blocks = 0;
775 }
776
777out:
778 blk_queue_max_write_same_sectors(q, sdkp->max_ws_blocks *
779 (logical_block_size >> 9));
780}
781
782
783
784
785
786
787
788
789
790static int sd_setup_write_same_cmnd(struct scsi_device *sdp, struct request *rq)
791{
792 struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
793 struct bio *bio = rq->bio;
794 sector_t sector = blk_rq_pos(rq);
795 unsigned int nr_sectors = blk_rq_sectors(rq);
796 unsigned int nr_bytes = blk_rq_bytes(rq);
797 int ret;
798
799 if (sdkp->device->no_write_same)
800 return BLKPREP_KILL;
801
802 BUG_ON(bio_offset(bio) || bio_iovec(bio)->bv_len != sdp->sector_size);
803
804 sector >>= ilog2(sdp->sector_size) - 9;
805 nr_sectors >>= ilog2(sdp->sector_size) - 9;
806
807 rq->__data_len = sdp->sector_size;
808 rq->timeout = SD_WRITE_SAME_TIMEOUT;
809 memset(rq->cmd, 0, rq->cmd_len);
810
811 if (sdkp->ws16 || sector > 0xffffffff || nr_sectors > 0xffff) {
812 rq->cmd_len = 16;
813 rq->cmd[0] = WRITE_SAME_16;
814 put_unaligned_be64(sector, &rq->cmd[2]);
815 put_unaligned_be32(nr_sectors, &rq->cmd[10]);
816 } else {
817 rq->cmd_len = 10;
818 rq->cmd[0] = WRITE_SAME;
819 put_unaligned_be32(sector, &rq->cmd[2]);
820 put_unaligned_be16(nr_sectors, &rq->cmd[7]);
821 }
822
823 ret = scsi_setup_blk_pc_cmnd(sdp, rq);
824 rq->__data_len = nr_bytes;
825
826 return ret;
827}
828
829static int scsi_setup_flush_cmnd(struct scsi_device *sdp, struct request *rq)
830{
831 rq->timeout = SD_FLUSH_TIMEOUT;
832 rq->retries = SD_MAX_RETRIES;
833 rq->cmd[0] = SYNCHRONIZE_CACHE;
834 rq->cmd_len = 10;
835
836 return scsi_setup_blk_pc_cmnd(sdp, rq);
837}
838
839static void sd_unprep_fn(struct request_queue *q, struct request *rq)
840{
841 struct scsi_cmnd *SCpnt = rq->special;
842
843 if (rq->cmd_flags & REQ_DISCARD) {
844 free_page((unsigned long)rq->buffer);
845 rq->buffer = NULL;
846 }
847 if (SCpnt->cmnd != rq->cmd) {
848 mempool_free(SCpnt->cmnd, sd_cdb_pool);
849 SCpnt->cmnd = NULL;
850 SCpnt->cmd_len = 0;
851 }
852}
853
854
855
856
857
858
859
860
861
862static int sd_prep_fn(struct request_queue *q, struct request *rq)
863{
864 struct scsi_cmnd *SCpnt;
865 struct scsi_device *sdp = q->queuedata;
866 struct gendisk *disk = rq->rq_disk;
867 struct scsi_disk *sdkp;
868 sector_t block = blk_rq_pos(rq);
869 sector_t threshold;
870 unsigned int this_count = blk_rq_sectors(rq);
871 int ret, host_dif;
872 unsigned char protect;
873
874
875
876
877
878 if (rq->cmd_flags & REQ_DISCARD) {
879 ret = sd_setup_discard_cmnd(sdp, rq);
880 goto out;
881 } else if (rq->cmd_flags & REQ_WRITE_SAME) {
882 ret = sd_setup_write_same_cmnd(sdp, rq);
883 goto out;
884 } else if (rq->cmd_flags & REQ_FLUSH) {
885 ret = scsi_setup_flush_cmnd(sdp, rq);
886 goto out;
887 } else if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
888 ret = scsi_setup_blk_pc_cmnd(sdp, rq);
889 goto out;
890 } else if (rq->cmd_type != REQ_TYPE_FS) {
891 ret = BLKPREP_KILL;
892 goto out;
893 }
894 ret = scsi_setup_fs_cmnd(sdp, rq);
895 if (ret != BLKPREP_OK)
896 goto out;
897 SCpnt = rq->special;
898 sdkp = scsi_disk(disk);
899
900
901
902 ret = BLKPREP_KILL;
903
904 SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,
905 "sd_prep_fn: block=%llu, "
906 "count=%d\n",
907 (unsigned long long)block,
908 this_count));
909
910 if (!sdp || !scsi_device_online(sdp) ||
911 block + blk_rq_sectors(rq) > get_capacity(disk)) {
912 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
913 "Finishing %u sectors\n",
914 blk_rq_sectors(rq)));
915 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
916 "Retry with 0x%p\n", SCpnt));
917 goto out;
918 }
919
920 if (sdp->changed) {
921
922
923
924
925
926 goto out;
927 }
928
929
930
931
932
933 threshold = get_capacity(disk) - SD_LAST_BUGGY_SECTORS *
934 (sdp->sector_size / 512);
935
936 if (unlikely(sdp->last_sector_bug && block + this_count > threshold)) {
937 if (block < threshold) {
938
939 this_count = threshold - block;
940 } else {
941
942 this_count = sdp->sector_size / 512;
943 }
944 }
945
946 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "block=%llu\n",
947 (unsigned long long)block));
948
949
950
951
952
953
954
955
956
957
958
959
960 if (sdp->sector_size == 1024) {
961 if ((block & 1) || (blk_rq_sectors(rq) & 1)) {
962 scmd_printk(KERN_ERR, SCpnt,
963 "Bad block number requested\n");
964 goto out;
965 } else {
966 block = block >> 1;
967 this_count = this_count >> 1;
968 }
969 }
970 if (sdp->sector_size == 2048) {
971 if ((block & 3) || (blk_rq_sectors(rq) & 3)) {
972 scmd_printk(KERN_ERR, SCpnt,
973 "Bad block number requested\n");
974 goto out;
975 } else {
976 block = block >> 2;
977 this_count = this_count >> 2;
978 }
979 }
980 if (sdp->sector_size == 4096) {
981 if ((block & 7) || (blk_rq_sectors(rq) & 7)) {
982 scmd_printk(KERN_ERR, SCpnt,
983 "Bad block number requested\n");
984 goto out;
985 } else {
986 block = block >> 3;
987 this_count = this_count >> 3;
988 }
989 }
990 if (rq_data_dir(rq) == WRITE) {
991 if (!sdp->writeable) {
992 goto out;
993 }
994 SCpnt->cmnd[0] = WRITE_6;
995 SCpnt->sc_data_direction = DMA_TO_DEVICE;
996
997 if (blk_integrity_rq(rq))
998 sd_dif_prepare(rq, block, sdp->sector_size);
999
1000 } else if (rq_data_dir(rq) == READ) {
1001 SCpnt->cmnd[0] = READ_6;
1002 SCpnt->sc_data_direction = DMA_FROM_DEVICE;
1003 } else {
1004 scmd_printk(KERN_ERR, SCpnt, "Unknown command %x\n", rq->cmd_flags);
1005 goto out;
1006 }
1007
1008 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
1009 "%s %d/%u 512 byte blocks.\n",
1010 (rq_data_dir(rq) == WRITE) ?
1011 "writing" : "reading", this_count,
1012 blk_rq_sectors(rq)));
1013
1014
1015 host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
1016 if (host_dif)
1017 protect = 1 << 5;
1018 else
1019 protect = 0;
1020
1021 if (host_dif == SD_DIF_TYPE2_PROTECTION) {
1022 SCpnt->cmnd = mempool_alloc(sd_cdb_pool, GFP_ATOMIC);
1023
1024 if (unlikely(SCpnt->cmnd == NULL)) {
1025 ret = BLKPREP_DEFER;
1026 goto out;
1027 }
1028
1029 SCpnt->cmd_len = SD_EXT_CDB_SIZE;
1030 memset(SCpnt->cmnd, 0, SCpnt->cmd_len);
1031 SCpnt->cmnd[0] = VARIABLE_LENGTH_CMD;
1032 SCpnt->cmnd[7] = 0x18;
1033 SCpnt->cmnd[9] = (rq_data_dir(rq) == READ) ? READ_32 : WRITE_32;
1034 SCpnt->cmnd[10] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
1035
1036
1037 SCpnt->cmnd[12] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
1038 SCpnt->cmnd[13] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
1039 SCpnt->cmnd[14] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
1040 SCpnt->cmnd[15] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
1041 SCpnt->cmnd[16] = (unsigned char) (block >> 24) & 0xff;
1042 SCpnt->cmnd[17] = (unsigned char) (block >> 16) & 0xff;
1043 SCpnt->cmnd[18] = (unsigned char) (block >> 8) & 0xff;
1044 SCpnt->cmnd[19] = (unsigned char) block & 0xff;
1045
1046
1047 SCpnt->cmnd[20] = (unsigned char) (block >> 24) & 0xff;
1048 SCpnt->cmnd[21] = (unsigned char) (block >> 16) & 0xff;
1049 SCpnt->cmnd[22] = (unsigned char) (block >> 8) & 0xff;
1050 SCpnt->cmnd[23] = (unsigned char) block & 0xff;
1051
1052
1053 SCpnt->cmnd[28] = (unsigned char) (this_count >> 24) & 0xff;
1054 SCpnt->cmnd[29] = (unsigned char) (this_count >> 16) & 0xff;
1055 SCpnt->cmnd[30] = (unsigned char) (this_count >> 8) & 0xff;
1056 SCpnt->cmnd[31] = (unsigned char) this_count & 0xff;
1057 } else if (sdp->use_16_for_rw) {
1058 SCpnt->cmnd[0] += READ_16 - READ_6;
1059 SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
1060 SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
1061 SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
1062 SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
1063 SCpnt->cmnd[5] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
1064 SCpnt->cmnd[6] = (unsigned char) (block >> 24) & 0xff;
1065 SCpnt->cmnd[7] = (unsigned char) (block >> 16) & 0xff;
1066 SCpnt->cmnd[8] = (unsigned char) (block >> 8) & 0xff;
1067 SCpnt->cmnd[9] = (unsigned char) block & 0xff;
1068 SCpnt->cmnd[10] = (unsigned char) (this_count >> 24) & 0xff;
1069 SCpnt->cmnd[11] = (unsigned char) (this_count >> 16) & 0xff;
1070 SCpnt->cmnd[12] = (unsigned char) (this_count >> 8) & 0xff;
1071 SCpnt->cmnd[13] = (unsigned char) this_count & 0xff;
1072 SCpnt->cmnd[14] = SCpnt->cmnd[15] = 0;
1073 } else if ((this_count > 0xff) || (block > 0x1fffff) ||
1074 scsi_device_protection(SCpnt->device) ||
1075 SCpnt->device->use_10_for_rw) {
1076 if (this_count > 0xffff)
1077 this_count = 0xffff;
1078
1079 SCpnt->cmnd[0] += READ_10 - READ_6;
1080 SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
1081 SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
1082 SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
1083 SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
1084 SCpnt->cmnd[5] = (unsigned char) block & 0xff;
1085 SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0;
1086 SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
1087 SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
1088 } else {
1089 if (unlikely(rq->cmd_flags & REQ_FUA)) {
1090
1091
1092
1093
1094
1095
1096 scmd_printk(KERN_ERR, SCpnt,
1097 "FUA write on READ/WRITE(6) drive\n");
1098 goto out;
1099 }
1100
1101 SCpnt->cmnd[1] |= (unsigned char) ((block >> 16) & 0x1f);
1102 SCpnt->cmnd[2] = (unsigned char) ((block >> 8) & 0xff);
1103 SCpnt->cmnd[3] = (unsigned char) block & 0xff;
1104 SCpnt->cmnd[4] = (unsigned char) this_count;
1105 SCpnt->cmnd[5] = 0;
1106 }
1107 SCpnt->sdb.length = this_count * sdp->sector_size;
1108
1109
1110 if (host_dif || scsi_prot_sg_count(SCpnt))
1111 sd_prot_op(SCpnt, host_dif);
1112
1113
1114
1115
1116
1117
1118 SCpnt->transfersize = sdp->sector_size;
1119 SCpnt->underflow = this_count << 9;
1120 SCpnt->allowed = SD_MAX_RETRIES;
1121
1122
1123
1124
1125
1126 ret = BLKPREP_OK;
1127 out:
1128 return scsi_prep_return(q, rq, ret);
1129}
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146static int sd_open(struct block_device *bdev, fmode_t mode)
1147{
1148 struct scsi_disk *sdkp = scsi_disk_get(bdev->bd_disk);
1149 struct scsi_device *sdev;
1150 int retval;
1151
1152 if (!sdkp)
1153 return -ENXIO;
1154
1155 SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
1156
1157 sdev = sdkp->device;
1158
1159
1160
1161
1162
1163 retval = -ENXIO;
1164 if (!scsi_block_when_processing_errors(sdev))
1165 goto error_out;
1166
1167 if (sdev->removable || sdkp->write_prot)
1168 check_disk_change(bdev);
1169
1170
1171
1172
1173 retval = -ENOMEDIUM;
1174 if (sdev->removable && !sdkp->media_present && !(mode & FMODE_NDELAY))
1175 goto error_out;
1176
1177
1178
1179
1180
1181 retval = -EROFS;
1182 if (sdkp->write_prot && (mode & FMODE_WRITE))
1183 goto error_out;
1184
1185
1186
1187
1188
1189
1190
1191 retval = -ENXIO;
1192 if (!scsi_device_online(sdev))
1193 goto error_out;
1194
1195 if ((atomic_inc_return(&sdkp->openers) == 1) && sdev->removable) {
1196 if (scsi_block_when_processing_errors(sdev))
1197 scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
1198 }
1199
1200 return 0;
1201
1202error_out:
1203 scsi_disk_put(sdkp);
1204 return retval;
1205}
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220static void sd_release(struct gendisk *disk, fmode_t mode)
1221{
1222 struct scsi_disk *sdkp = scsi_disk(disk);
1223 struct scsi_device *sdev = sdkp->device;
1224
1225 SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_release\n"));
1226
1227 if (atomic_dec_return(&sdkp->openers) == 0 && sdev->removable) {
1228 if (scsi_block_when_processing_errors(sdev))
1229 scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
1230 }
1231
1232
1233
1234
1235
1236
1237 scsi_disk_put(sdkp);
1238}
1239
1240static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1241{
1242 struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
1243 struct scsi_device *sdp = sdkp->device;
1244 struct Scsi_Host *host = sdp->host;
1245 int diskinfo[4];
1246
1247
1248 diskinfo[0] = 0x40;
1249 diskinfo[1] = 0x20;
1250 diskinfo[2] = sdkp->capacity >> 11;
1251
1252
1253 if (host->hostt->bios_param)
1254 host->hostt->bios_param(sdp, bdev, sdkp->capacity, diskinfo);
1255 else
1256 scsicam_bios_param(bdev, sdkp->capacity, diskinfo);
1257
1258 geo->heads = diskinfo[0];
1259 geo->sectors = diskinfo[1];
1260 geo->cylinders = diskinfo[2];
1261 return 0;
1262}
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278static int sd_ioctl(struct block_device *bdev, fmode_t mode,
1279 unsigned int cmd, unsigned long arg)
1280{
1281 struct gendisk *disk = bdev->bd_disk;
1282 struct scsi_disk *sdkp = scsi_disk(disk);
1283 struct scsi_device *sdp = sdkp->device;
1284 void __user *p = (void __user *)arg;
1285 int error;
1286
1287 SCSI_LOG_IOCTL(1, sd_printk(KERN_INFO, sdkp, "sd_ioctl: disk=%s, "
1288 "cmd=0x%x\n", disk->disk_name, cmd));
1289
1290 error = scsi_verify_blk_ioctl(bdev, cmd);
1291 if (error < 0)
1292 return error;
1293
1294
1295
1296
1297
1298
1299
1300 error = scsi_nonblockable_ioctl(sdp, cmd, p,
1301 (mode & FMODE_NDELAY) != 0);
1302 if (!scsi_block_when_processing_errors(sdp) || !error)
1303 goto out;
1304
1305
1306
1307
1308
1309
1310 switch (cmd) {
1311 case SCSI_IOCTL_GET_IDLUN:
1312 case SCSI_IOCTL_GET_BUS_NUMBER:
1313 error = scsi_ioctl(sdp, cmd, p);
1314 break;
1315 default:
1316 error = scsi_cmd_blk_ioctl(bdev, mode, cmd, p);
1317 if (error != -ENOTTY)
1318 break;
1319 error = scsi_ioctl(sdp, cmd, p);
1320 break;
1321 }
1322out:
1323 return error;
1324}
1325
1326static void set_media_not_present(struct scsi_disk *sdkp)
1327{
1328 if (sdkp->media_present)
1329 sdkp->device->changed = 1;
1330
1331 if (sdkp->device->removable) {
1332 sdkp->media_present = 0;
1333 sdkp->capacity = 0;
1334 }
1335}
1336
1337static int media_not_present(struct scsi_disk *sdkp,
1338 struct scsi_sense_hdr *sshdr)
1339{
1340 if (!scsi_sense_valid(sshdr))
1341 return 0;
1342
1343
1344 switch (sshdr->sense_key) {
1345 case UNIT_ATTENTION:
1346 case NOT_READY:
1347
1348 if (sshdr->asc == 0x3A) {
1349 set_media_not_present(sdkp);
1350 return 1;
1351 }
1352 }
1353 return 0;
1354}
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365static unsigned int sd_check_events(struct gendisk *disk, unsigned int clearing)
1366{
1367 struct scsi_disk *sdkp = scsi_disk(disk);
1368 struct scsi_device *sdp = sdkp->device;
1369 struct scsi_sense_hdr *sshdr = NULL;
1370 int retval;
1371
1372 SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_check_events\n"));
1373
1374
1375
1376
1377
1378
1379
1380 if (!scsi_device_online(sdp)) {
1381 set_media_not_present(sdkp);
1382 goto out;
1383 }
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394 retval = -ENODEV;
1395
1396 if (scsi_block_when_processing_errors(sdp)) {
1397 sshdr = kzalloc(sizeof(*sshdr), GFP_KERNEL);
1398 retval = scsi_test_unit_ready(sdp, SD_TIMEOUT, SD_MAX_RETRIES,
1399 sshdr);
1400 }
1401
1402
1403 if (host_byte(retval)) {
1404 set_media_not_present(sdkp);
1405 goto out;
1406 }
1407
1408 if (media_not_present(sdkp, sshdr))
1409 goto out;
1410
1411
1412
1413
1414
1415 if (!sdkp->media_present)
1416 sdp->changed = 1;
1417 sdkp->media_present = 1;
1418out:
1419
1420
1421
1422
1423
1424
1425 kfree(sshdr);
1426 retval = sdp->changed ? DISK_EVENT_MEDIA_CHANGE : 0;
1427 sdp->changed = 0;
1428 return retval;
1429}
1430
1431static int sd_sync_cache(struct scsi_disk *sdkp)
1432{
1433 int retries, res;
1434 struct scsi_device *sdp = sdkp->device;
1435 struct scsi_sense_hdr sshdr;
1436
1437 if (!scsi_device_online(sdp))
1438 return -ENODEV;
1439
1440
1441 for (retries = 3; retries > 0; --retries) {
1442 unsigned char cmd[10] = { 0 };
1443
1444 cmd[0] = SYNCHRONIZE_CACHE;
1445
1446
1447
1448
1449 res = scsi_execute_req_flags(sdp, cmd, DMA_NONE, NULL, 0,
1450 &sshdr, SD_FLUSH_TIMEOUT,
1451 SD_MAX_RETRIES, NULL, REQ_PM);
1452 if (res == 0)
1453 break;
1454 }
1455
1456 if (res) {
1457 sd_print_result(sdkp, res);
1458 if (driver_byte(res) & DRIVER_SENSE)
1459 sd_print_sense_hdr(sdkp, &sshdr);
1460 }
1461
1462 if (res)
1463 return -EIO;
1464 return 0;
1465}
1466
1467static void sd_rescan(struct device *dev)
1468{
1469 struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
1470
1471 if (sdkp) {
1472 revalidate_disk(sdkp->disk);
1473 scsi_disk_put(sdkp);
1474 }
1475}
1476
1477
1478#ifdef CONFIG_COMPAT
1479
1480
1481
1482
1483static int sd_compat_ioctl(struct block_device *bdev, fmode_t mode,
1484 unsigned int cmd, unsigned long arg)
1485{
1486 struct scsi_device *sdev = scsi_disk(bdev->bd_disk)->device;
1487 int ret;
1488
1489 ret = scsi_verify_blk_ioctl(bdev, cmd);
1490 if (ret < 0)
1491 return ret;
1492
1493
1494
1495
1496
1497
1498
1499 if (!scsi_block_when_processing_errors(sdev))
1500 return -ENODEV;
1501
1502 if (sdev->host->hostt->compat_ioctl) {
1503 ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
1504
1505 return ret;
1506 }
1507
1508
1509
1510
1511 return -ENOIOCTLCMD;
1512}
1513#endif
1514
1515static const struct block_device_operations sd_fops = {
1516 .owner = THIS_MODULE,
1517 .open = sd_open,
1518 .release = sd_release,
1519 .ioctl = sd_ioctl,
1520 .getgeo = sd_getgeo,
1521#ifdef CONFIG_COMPAT
1522 .compat_ioctl = sd_compat_ioctl,
1523#endif
1524 .check_events = sd_check_events,
1525 .revalidate_disk = sd_revalidate_disk,
1526 .unlock_native_capacity = sd_unlock_native_capacity,
1527};
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542static int sd_eh_action(struct scsi_cmnd *scmd, unsigned char *eh_cmnd,
1543 int eh_cmnd_len, int eh_disp)
1544{
1545 struct scsi_disk *sdkp = scsi_disk(scmd->request->rq_disk);
1546
1547 if (!scsi_device_online(scmd->device) ||
1548 !scsi_medium_access_command(scmd))
1549 return eh_disp;
1550
1551
1552
1553
1554
1555
1556
1557
1558 if (host_byte(scmd->result) == DID_TIME_OUT && eh_disp == SUCCESS &&
1559 eh_cmnd_len && eh_cmnd[0] == TEST_UNIT_READY)
1560 sdkp->medium_access_timed_out++;
1561
1562
1563
1564
1565
1566
1567 if (sdkp->medium_access_timed_out >= sdkp->max_medium_access_timeouts) {
1568 scmd_printk(KERN_ERR, scmd,
1569 "Medium access timeout failure. Offlining disk!\n");
1570 scsi_device_set_state(scmd->device, SDEV_OFFLINE);
1571
1572 return FAILED;
1573 }
1574
1575 return eh_disp;
1576}
1577
1578static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
1579{
1580 u64 start_lba = blk_rq_pos(scmd->request);
1581 u64 end_lba = blk_rq_pos(scmd->request) + (scsi_bufflen(scmd) / 512);
1582 u64 bad_lba;
1583 int info_valid;
1584
1585
1586
1587
1588 unsigned int transferred = scsi_bufflen(scmd) - scsi_get_resid(scmd);
1589 unsigned int good_bytes;
1590
1591 if (scmd->request->cmd_type != REQ_TYPE_FS)
1592 return 0;
1593
1594 info_valid = scsi_get_sense_info_fld(scmd->sense_buffer,
1595 SCSI_SENSE_BUFFERSIZE,
1596 &bad_lba);
1597 if (!info_valid)
1598 return 0;
1599
1600 if (scsi_bufflen(scmd) <= scmd->device->sector_size)
1601 return 0;
1602
1603 if (scmd->device->sector_size < 512) {
1604
1605 start_lba <<= 1;
1606 end_lba <<= 1;
1607 } else {
1608
1609 u64 factor = scmd->device->sector_size / 512;
1610 do_div(start_lba, factor);
1611 do_div(end_lba, factor);
1612 }
1613
1614
1615
1616
1617 if (bad_lba < start_lba || bad_lba >= end_lba)
1618 return 0;
1619
1620
1621
1622
1623 good_bytes = (bad_lba - start_lba) * scmd->device->sector_size;
1624 return min(good_bytes, transferred);
1625}
1626
1627
1628
1629
1630
1631
1632
1633
1634static int sd_done(struct scsi_cmnd *SCpnt)
1635{
1636 int result = SCpnt->result;
1637 unsigned int good_bytes = result ? 0 : scsi_bufflen(SCpnt);
1638 struct scsi_sense_hdr sshdr;
1639 struct scsi_disk *sdkp = scsi_disk(SCpnt->request->rq_disk);
1640 struct request *req = SCpnt->request;
1641 int sense_valid = 0;
1642 int sense_deferred = 0;
1643 unsigned char op = SCpnt->cmnd[0];
1644 unsigned char unmap = SCpnt->cmnd[1] & 8;
1645
1646 if (req->cmd_flags & REQ_DISCARD || req->cmd_flags & REQ_WRITE_SAME) {
1647 if (!result) {
1648 good_bytes = blk_rq_bytes(req);
1649 scsi_set_resid(SCpnt, 0);
1650 } else {
1651 good_bytes = 0;
1652 scsi_set_resid(SCpnt, blk_rq_bytes(req));
1653 }
1654 }
1655
1656 if (result) {
1657 sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr);
1658 if (sense_valid)
1659 sense_deferred = scsi_sense_is_deferred(&sshdr);
1660 }
1661#ifdef CONFIG_SCSI_LOGGING
1662 SCSI_LOG_HLCOMPLETE(1, scsi_print_result(SCpnt));
1663 if (sense_valid) {
1664 SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, SCpnt,
1665 "sd_done: sb[respc,sk,asc,"
1666 "ascq]=%x,%x,%x,%x\n",
1667 sshdr.response_code,
1668 sshdr.sense_key, sshdr.asc,
1669 sshdr.ascq));
1670 }
1671#endif
1672 if (driver_byte(result) != DRIVER_SENSE &&
1673 (!sense_valid || sense_deferred))
1674 goto out;
1675
1676 sdkp->medium_access_timed_out = 0;
1677
1678 switch (sshdr.sense_key) {
1679 case HARDWARE_ERROR:
1680 case MEDIUM_ERROR:
1681 good_bytes = sd_completed_bytes(SCpnt);
1682 break;
1683 case RECOVERED_ERROR:
1684 good_bytes = scsi_bufflen(SCpnt);
1685 break;
1686 case NO_SENSE:
1687
1688
1689
1690
1691 scsi_print_sense("sd", SCpnt);
1692 SCpnt->result = 0;
1693 memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1694 break;
1695 case ABORTED_COMMAND:
1696 if (sshdr.asc == 0x10)
1697 good_bytes = sd_completed_bytes(SCpnt);
1698 break;
1699 case ILLEGAL_REQUEST:
1700 if (sshdr.asc == 0x10)
1701 good_bytes = sd_completed_bytes(SCpnt);
1702
1703 if (sshdr.asc == 0x20 || sshdr.asc == 0x24) {
1704 switch (op) {
1705 case UNMAP:
1706 sd_config_discard(sdkp, SD_LBP_DISABLE);
1707 break;
1708 case WRITE_SAME_16:
1709 case WRITE_SAME:
1710 if (unmap)
1711 sd_config_discard(sdkp, SD_LBP_DISABLE);
1712 else {
1713 sdkp->device->no_write_same = 1;
1714 sd_config_write_same(sdkp);
1715
1716 good_bytes = 0;
1717 req->__data_len = blk_rq_bytes(req);
1718 req->cmd_flags |= REQ_QUIET;
1719 }
1720 }
1721 }
1722 break;
1723 default:
1724 break;
1725 }
1726 out:
1727 if (rq_data_dir(SCpnt->request) == READ && scsi_prot_sg_count(SCpnt))
1728 sd_dif_complete(SCpnt, good_bytes);
1729
1730 return good_bytes;
1731}
1732
1733
1734
1735
1736static void
1737sd_spinup_disk(struct scsi_disk *sdkp)
1738{
1739 unsigned char cmd[10];
1740 unsigned long spintime_expire = 0;
1741 int retries, spintime;
1742 unsigned int the_result;
1743 struct scsi_sense_hdr sshdr;
1744 int sense_valid = 0;
1745
1746 spintime = 0;
1747
1748
1749
1750 do {
1751 retries = 0;
1752
1753 do {
1754 cmd[0] = TEST_UNIT_READY;
1755 memset((void *) &cmd[1], 0, 9);
1756
1757 the_result = scsi_execute_req(sdkp->device, cmd,
1758 DMA_NONE, NULL, 0,
1759 &sshdr, SD_TIMEOUT,
1760 SD_MAX_RETRIES, NULL);
1761
1762
1763
1764
1765
1766
1767 if (media_not_present(sdkp, &sshdr))
1768 return;
1769
1770 if (the_result)
1771 sense_valid = scsi_sense_valid(&sshdr);
1772 retries++;
1773 } while (retries < 3 &&
1774 (!scsi_status_is_good(the_result) ||
1775 ((driver_byte(the_result) & DRIVER_SENSE) &&
1776 sense_valid && sshdr.sense_key == UNIT_ATTENTION)));
1777
1778 if ((driver_byte(the_result) & DRIVER_SENSE) == 0) {
1779
1780
1781 if(!spintime && !scsi_status_is_good(the_result)) {
1782 sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
1783 sd_print_result(sdkp, the_result);
1784 }
1785 break;
1786 }
1787
1788
1789
1790
1791 if (sdkp->device->no_start_on_add)
1792 break;
1793
1794 if (sense_valid && sshdr.sense_key == NOT_READY) {
1795 if (sshdr.asc == 4 && sshdr.ascq == 3)
1796 break;
1797 if (sshdr.asc == 4 && sshdr.ascq == 0xb)
1798 break;
1799 if (sshdr.asc == 4 && sshdr.ascq == 0xc)
1800 break;
1801
1802
1803
1804 if (!spintime) {
1805 sd_printk(KERN_NOTICE, sdkp, "Spinning up disk...");
1806 cmd[0] = START_STOP;
1807 cmd[1] = 1;
1808 memset((void *) &cmd[2], 0, 8);
1809 cmd[4] = 1;
1810 if (sdkp->device->start_stop_pwr_cond)
1811 cmd[4] |= 1 << 4;
1812 scsi_execute_req(sdkp->device, cmd, DMA_NONE,
1813 NULL, 0, &sshdr,
1814 SD_TIMEOUT, SD_MAX_RETRIES,
1815 NULL);
1816 spintime_expire = jiffies + 100 * HZ;
1817 spintime = 1;
1818 }
1819
1820 msleep(1000);
1821 printk(".");
1822
1823
1824
1825
1826
1827
1828 } else if (sense_valid &&
1829 sshdr.sense_key == UNIT_ATTENTION &&
1830 sshdr.asc == 0x28) {
1831 if (!spintime) {
1832 spintime_expire = jiffies + 5 * HZ;
1833 spintime = 1;
1834 }
1835
1836 msleep(1000);
1837 } else {
1838
1839
1840 if(!spintime) {
1841 sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
1842 sd_print_sense_hdr(sdkp, &sshdr);
1843 }
1844 break;
1845 }
1846
1847 } while (spintime && time_before_eq(jiffies, spintime_expire));
1848
1849 if (spintime) {
1850 if (scsi_status_is_good(the_result))
1851 printk("ready\n");
1852 else
1853 printk("not responding...\n");
1854 }
1855}
1856
1857
1858
1859
1860
1861static int sd_read_protection_type(struct scsi_disk *sdkp, unsigned char *buffer)
1862{
1863 struct scsi_device *sdp = sdkp->device;
1864 u8 type;
1865 int ret = 0;
1866
1867 if (scsi_device_protection(sdp) == 0 || (buffer[12] & 1) == 0)
1868 return ret;
1869
1870 type = ((buffer[12] >> 1) & 7) + 1;
1871
1872 if (type > SD_DIF_TYPE3_PROTECTION)
1873 ret = -ENODEV;
1874 else if (scsi_host_dif_capable(sdp->host, type))
1875 ret = 1;
1876
1877 if (sdkp->first_scan || type != sdkp->protection_type)
1878 switch (ret) {
1879 case -ENODEV:
1880 sd_printk(KERN_ERR, sdkp, "formatted with unsupported" \
1881 " protection type %u. Disabling disk!\n",
1882 type);
1883 break;
1884 case 1:
1885 sd_printk(KERN_NOTICE, sdkp,
1886 "Enabling DIF Type %u protection\n", type);
1887 break;
1888 case 0:
1889 sd_printk(KERN_NOTICE, sdkp,
1890 "Disabling DIF Type %u protection\n", type);
1891 break;
1892 }
1893
1894 sdkp->protection_type = type;
1895
1896 return ret;
1897}
1898
1899static void read_capacity_error(struct scsi_disk *sdkp, struct scsi_device *sdp,
1900 struct scsi_sense_hdr *sshdr, int sense_valid,
1901 int the_result)
1902{
1903 sd_print_result(sdkp, the_result);
1904 if (driver_byte(the_result) & DRIVER_SENSE)
1905 sd_print_sense_hdr(sdkp, sshdr);
1906 else
1907 sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n");
1908
1909
1910
1911
1912
1913 if (sdp->removable &&
1914 sense_valid && sshdr->sense_key == NOT_READY)
1915 set_media_not_present(sdkp);
1916
1917
1918
1919
1920
1921
1922 sdkp->capacity = 0;
1923}
1924
1925#define RC16_LEN 32
1926#if RC16_LEN > SD_BUF_SIZE
1927#error RC16_LEN must not be more than SD_BUF_SIZE
1928#endif
1929
1930#define READ_CAPACITY_RETRIES_ON_RESET 10
1931
1932static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
1933 unsigned char *buffer)
1934{
1935 unsigned char cmd[16];
1936 struct scsi_sense_hdr sshdr;
1937 int sense_valid = 0;
1938 int the_result;
1939 int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET;
1940 unsigned int alignment;
1941 unsigned long long lba;
1942 unsigned sector_size;
1943
1944 if (sdp->no_read_capacity_16)
1945 return -EINVAL;
1946
1947 do {
1948 memset(cmd, 0, 16);
1949 cmd[0] = SERVICE_ACTION_IN;
1950 cmd[1] = SAI_READ_CAPACITY_16;
1951 cmd[13] = RC16_LEN;
1952 memset(buffer, 0, RC16_LEN);
1953
1954 the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
1955 buffer, RC16_LEN, &sshdr,
1956 SD_TIMEOUT, SD_MAX_RETRIES, NULL);
1957
1958 if (media_not_present(sdkp, &sshdr))
1959 return -ENODEV;
1960
1961 if (the_result) {
1962 sense_valid = scsi_sense_valid(&sshdr);
1963 if (sense_valid &&
1964 sshdr.sense_key == ILLEGAL_REQUEST &&
1965 (sshdr.asc == 0x20 || sshdr.asc == 0x24) &&
1966 sshdr.ascq == 0x00)
1967
1968
1969
1970 return -EINVAL;
1971 if (sense_valid &&
1972 sshdr.sense_key == UNIT_ATTENTION &&
1973 sshdr.asc == 0x29 && sshdr.ascq == 0x00)
1974
1975
1976 if (--reset_retries > 0)
1977 continue;
1978 }
1979 retries--;
1980
1981 } while (the_result && retries);
1982
1983 if (the_result) {
1984 sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY(16) failed\n");
1985 read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
1986 return -EINVAL;
1987 }
1988
1989 sector_size = get_unaligned_be32(&buffer[8]);
1990 lba = get_unaligned_be64(&buffer[0]);
1991
1992 if (sd_read_protection_type(sdkp, buffer) < 0) {
1993 sdkp->capacity = 0;
1994 return -ENODEV;
1995 }
1996
1997 if ((sizeof(sdkp->capacity) == 4) && (lba >= 0xffffffffULL)) {
1998 sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use a "
1999 "kernel compiled with support for large block "
2000 "devices.\n");
2001 sdkp->capacity = 0;
2002 return -EOVERFLOW;
2003 }
2004
2005
2006 sdkp->physical_block_size = (1 << (buffer[13] & 0xf)) * sector_size;
2007
2008
2009 alignment = ((buffer[14] & 0x3f) << 8 | buffer[15]) * sector_size;
2010 blk_queue_alignment_offset(sdp->request_queue, alignment);
2011 if (alignment && sdkp->first_scan)
2012 sd_printk(KERN_NOTICE, sdkp,
2013 "physical block alignment offset: %u\n", alignment);
2014
2015 if (buffer[14] & 0x80) {
2016 sdkp->lbpme = 1;
2017
2018 if (buffer[14] & 0x40)
2019 sdkp->lbprz = 1;
2020
2021 sd_config_discard(sdkp, SD_LBP_WS16);
2022 }
2023
2024 sdkp->capacity = lba + 1;
2025 return sector_size;
2026}
2027
2028static int read_capacity_10(struct scsi_disk *sdkp, struct scsi_device *sdp,
2029 unsigned char *buffer)
2030{
2031 unsigned char cmd[16];
2032 struct scsi_sense_hdr sshdr;
2033 int sense_valid = 0;
2034 int the_result;
2035 int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET;
2036 sector_t lba;
2037 unsigned sector_size;
2038
2039 do {
2040 cmd[0] = READ_CAPACITY;
2041 memset(&cmd[1], 0, 9);
2042 memset(buffer, 0, 8);
2043
2044 the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
2045 buffer, 8, &sshdr,
2046 SD_TIMEOUT, SD_MAX_RETRIES, NULL);
2047
2048 if (media_not_present(sdkp, &sshdr))
2049 return -ENODEV;
2050
2051 if (the_result) {
2052 sense_valid = scsi_sense_valid(&sshdr);
2053 if (sense_valid &&
2054 sshdr.sense_key == UNIT_ATTENTION &&
2055 sshdr.asc == 0x29 && sshdr.ascq == 0x00)
2056
2057
2058 if (--reset_retries > 0)
2059 continue;
2060 }
2061 retries--;
2062
2063 } while (the_result && retries);
2064
2065 if (the_result) {
2066 sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY failed\n");
2067 read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
2068 return -EINVAL;
2069 }
2070
2071 sector_size = get_unaligned_be32(&buffer[4]);
2072 lba = get_unaligned_be32(&buffer[0]);
2073
2074 if (sdp->no_read_capacity_16 && (lba == 0xffffffff)) {
2075
2076
2077
2078 sdkp->capacity = 0;
2079 sdkp->physical_block_size = sector_size;
2080 return sector_size;
2081 }
2082
2083 if ((sizeof(sdkp->capacity) == 4) && (lba == 0xffffffff)) {
2084 sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use a "
2085 "kernel compiled with support for large block "
2086 "devices.\n");
2087 sdkp->capacity = 0;
2088 return -EOVERFLOW;
2089 }
2090
2091 sdkp->capacity = lba + 1;
2092 sdkp->physical_block_size = sector_size;
2093 return sector_size;
2094}
2095
2096static int sd_try_rc16_first(struct scsi_device *sdp)
2097{
2098 if (sdp->host->max_cmd_len < 16)
2099 return 0;
2100 if (sdp->try_rc_10_first)
2101 return 0;
2102 if (sdp->scsi_level > SCSI_SPC_2)
2103 return 1;
2104 if (scsi_device_protection(sdp))
2105 return 1;
2106 return 0;
2107}
2108
2109
2110
2111
2112static void
2113sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer)
2114{
2115 int sector_size;
2116 struct scsi_device *sdp = sdkp->device;
2117 sector_t old_capacity = sdkp->capacity;
2118
2119 if (sd_try_rc16_first(sdp)) {
2120 sector_size = read_capacity_16(sdkp, sdp, buffer);
2121 if (sector_size == -EOVERFLOW)
2122 goto got_data;
2123 if (sector_size == -ENODEV)
2124 return;
2125 if (sector_size < 0)
2126 sector_size = read_capacity_10(sdkp, sdp, buffer);
2127 if (sector_size < 0)
2128 return;
2129 } else {
2130 sector_size = read_capacity_10(sdkp, sdp, buffer);
2131 if (sector_size == -EOVERFLOW)
2132 goto got_data;
2133 if (sector_size < 0)
2134 return;
2135 if ((sizeof(sdkp->capacity) > 4) &&
2136 (sdkp->capacity > 0xffffffffULL)) {
2137 int old_sector_size = sector_size;
2138 sd_printk(KERN_NOTICE, sdkp, "Very big device. "
2139 "Trying to use READ CAPACITY(16).\n");
2140 sector_size = read_capacity_16(sdkp, sdp, buffer);
2141 if (sector_size < 0) {
2142 sd_printk(KERN_NOTICE, sdkp,
2143 "Using 0xffffffff as device size\n");
2144 sdkp->capacity = 1 + (sector_t) 0xffffffff;
2145 sector_size = old_sector_size;
2146 goto got_data;
2147 }
2148 }
2149 }
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161 if (sdp->fix_capacity ||
2162 (sdp->guess_capacity && (sdkp->capacity & 0x01))) {
2163 sd_printk(KERN_INFO, sdkp, "Adjusting the sector count "
2164 "from its reported value: %llu\n",
2165 (unsigned long long) sdkp->capacity);
2166 --sdkp->capacity;
2167 }
2168
2169got_data:
2170 if (sector_size == 0) {
2171 sector_size = 512;
2172 sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, "
2173 "assuming 512.\n");
2174 }
2175
2176 if (sector_size != 512 &&
2177 sector_size != 1024 &&
2178 sector_size != 2048 &&
2179 sector_size != 4096 &&
2180 sector_size != 256) {
2181 sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n",
2182 sector_size);
2183
2184
2185
2186
2187
2188
2189 sdkp->capacity = 0;
2190
2191
2192
2193
2194
2195
2196 sector_size = 512;
2197 }
2198 blk_queue_logical_block_size(sdp->request_queue, sector_size);
2199
2200 {
2201 char cap_str_2[10], cap_str_10[10];
2202 u64 sz = (u64)sdkp->capacity << ilog2(sector_size);
2203
2204 string_get_size(sz, STRING_UNITS_2, cap_str_2,
2205 sizeof(cap_str_2));
2206 string_get_size(sz, STRING_UNITS_10, cap_str_10,
2207 sizeof(cap_str_10));
2208
2209 if (sdkp->first_scan || old_capacity != sdkp->capacity) {
2210 sd_printk(KERN_NOTICE, sdkp,
2211 "%llu %d-byte logical blocks: (%s/%s)\n",
2212 (unsigned long long)sdkp->capacity,
2213 sector_size, cap_str_10, cap_str_2);
2214
2215 if (sdkp->physical_block_size != sector_size)
2216 sd_printk(KERN_NOTICE, sdkp,
2217 "%u-byte physical blocks\n",
2218 sdkp->physical_block_size);
2219 }
2220 }
2221
2222 sdp->use_16_for_rw = (sdkp->capacity > 0xffffffff);
2223
2224
2225 if (sector_size == 4096)
2226 sdkp->capacity <<= 3;
2227 else if (sector_size == 2048)
2228 sdkp->capacity <<= 2;
2229 else if (sector_size == 1024)
2230 sdkp->capacity <<= 1;
2231 else if (sector_size == 256)
2232 sdkp->capacity >>= 1;
2233
2234 blk_queue_physical_block_size(sdp->request_queue,
2235 sdkp->physical_block_size);
2236 sdkp->device->sector_size = sector_size;
2237}
2238
2239
2240static inline int
2241sd_do_mode_sense(struct scsi_device *sdp, int dbd, int modepage,
2242 unsigned char *buffer, int len, struct scsi_mode_data *data,
2243 struct scsi_sense_hdr *sshdr)
2244{
2245 return scsi_mode_sense(sdp, dbd, modepage, buffer, len,
2246 SD_TIMEOUT, SD_MAX_RETRIES, data,
2247 sshdr);
2248}
2249
2250
2251
2252
2253
2254static void
2255sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer)
2256{
2257 int res;
2258 struct scsi_device *sdp = sdkp->device;
2259 struct scsi_mode_data data;
2260 int old_wp = sdkp->write_prot;
2261
2262 set_disk_ro(sdkp->disk, 0);
2263 if (sdp->skip_ms_page_3f) {
2264 sd_printk(KERN_NOTICE, sdkp, "Assuming Write Enabled\n");
2265 return;
2266 }
2267
2268 if (sdp->use_192_bytes_for_3f) {
2269 res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 192, &data, NULL);
2270 } else {
2271
2272
2273
2274
2275
2276 res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 4, &data, NULL);
2277
2278
2279
2280
2281
2282
2283
2284 if (!scsi_status_is_good(res))
2285 res = sd_do_mode_sense(sdp, 0, 0, buffer, 4, &data, NULL);
2286
2287
2288
2289
2290 if (!scsi_status_is_good(res))
2291 res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 255,
2292 &data, NULL);
2293 }
2294
2295 if (!scsi_status_is_good(res)) {
2296 sd_printk(KERN_WARNING, sdkp,
2297 "Test WP failed, assume Write Enabled\n");
2298 } else {
2299 sdkp->write_prot = ((data.device_specific & 0x80) != 0);
2300 set_disk_ro(sdkp->disk, sdkp->write_prot);
2301 if (sdkp->first_scan || old_wp != sdkp->write_prot) {
2302 sd_printk(KERN_NOTICE, sdkp, "Write Protect is %s\n",
2303 sdkp->write_prot ? "on" : "off");
2304 sd_printk(KERN_DEBUG, sdkp,
2305 "Mode Sense: %02x %02x %02x %02x\n",
2306 buffer[0], buffer[1], buffer[2], buffer[3]);
2307 }
2308 }
2309}
2310
2311
2312
2313
2314
2315static void
2316sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
2317{
2318 int len = 0, res;
2319 struct scsi_device *sdp = sdkp->device;
2320
2321 int dbd;
2322 int modepage;
2323 int first_len;
2324 struct scsi_mode_data data;
2325 struct scsi_sense_hdr sshdr;
2326 int old_wce = sdkp->WCE;
2327 int old_rcd = sdkp->RCD;
2328 int old_dpofua = sdkp->DPOFUA;
2329
2330
2331 if (sdkp->cache_override)
2332 return;
2333
2334 first_len = 4;
2335 if (sdp->skip_ms_page_8) {
2336 if (sdp->type == TYPE_RBC)
2337 goto defaults;
2338 else {
2339 if (sdp->skip_ms_page_3f)
2340 goto defaults;
2341 modepage = 0x3F;
2342 if (sdp->use_192_bytes_for_3f)
2343 first_len = 192;
2344 dbd = 0;
2345 }
2346 } else if (sdp->type == TYPE_RBC) {
2347 modepage = 6;
2348 dbd = 8;
2349 } else {
2350 modepage = 8;
2351 dbd = 0;
2352 }
2353
2354
2355 res = sd_do_mode_sense(sdp, dbd, modepage, buffer, first_len,
2356 &data, &sshdr);
2357
2358 if (!scsi_status_is_good(res))
2359 goto bad_sense;
2360
2361 if (!data.header_length) {
2362 modepage = 6;
2363 first_len = 0;
2364 sd_printk(KERN_ERR, sdkp, "Missing header in MODE_SENSE response\n");
2365 }
2366
2367
2368 len = data.length;
2369
2370
2371
2372
2373
2374 if (len < 3)
2375 goto bad_sense;
2376 else if (len > SD_BUF_SIZE) {
2377 sd_printk(KERN_NOTICE, sdkp, "Truncating mode parameter "
2378 "data from %d to %d bytes\n", len, SD_BUF_SIZE);
2379 len = SD_BUF_SIZE;
2380 }
2381 if (modepage == 0x3F && sdp->use_192_bytes_for_3f)
2382 len = 192;
2383
2384
2385 if (len > first_len)
2386 res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len,
2387 &data, &sshdr);
2388
2389 if (scsi_status_is_good(res)) {
2390 int offset = data.header_length + data.block_descriptor_length;
2391
2392 while (offset < len) {
2393 u8 page_code = buffer[offset] & 0x3F;
2394 u8 spf = buffer[offset] & 0x40;
2395
2396 if (page_code == 8 || page_code == 6) {
2397
2398
2399 if (len - offset <= 2) {
2400 sd_printk(KERN_ERR, sdkp, "Incomplete "
2401 "mode parameter data\n");
2402 goto defaults;
2403 } else {
2404 modepage = page_code;
2405 goto Page_found;
2406 }
2407 } else {
2408
2409 if (spf && len - offset > 3)
2410 offset += 4 + (buffer[offset+2] << 8) +
2411 buffer[offset+3];
2412 else if (!spf && len - offset > 1)
2413 offset += 2 + buffer[offset+1];
2414 else {
2415 sd_printk(KERN_ERR, sdkp, "Incomplete "
2416 "mode parameter data\n");
2417 goto defaults;
2418 }
2419 }
2420 }
2421
2422 if (modepage == 0x3F) {
2423 sd_printk(KERN_ERR, sdkp, "No Caching mode page "
2424 "present\n");
2425 goto defaults;
2426 } else if ((buffer[offset] & 0x3f) != modepage) {
2427 sd_printk(KERN_ERR, sdkp, "Got wrong page\n");
2428 goto defaults;
2429 }
2430 Page_found:
2431 if (modepage == 8) {
2432 sdkp->WCE = ((buffer[offset + 2] & 0x04) != 0);
2433 sdkp->RCD = ((buffer[offset + 2] & 0x01) != 0);
2434 } else {
2435 sdkp->WCE = ((buffer[offset + 2] & 0x01) == 0);
2436 sdkp->RCD = 0;
2437 }
2438
2439 sdkp->DPOFUA = (data.device_specific & 0x10) != 0;
2440 if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw) {
2441 sd_printk(KERN_NOTICE, sdkp,
2442 "Uses READ/WRITE(6), disabling FUA\n");
2443 sdkp->DPOFUA = 0;
2444 }
2445
2446 if (sdkp->first_scan || old_wce != sdkp->WCE ||
2447 old_rcd != sdkp->RCD || old_dpofua != sdkp->DPOFUA)
2448 sd_printk(KERN_NOTICE, sdkp,
2449 "Write cache: %s, read cache: %s, %s\n",
2450 sdkp->WCE ? "enabled" : "disabled",
2451 sdkp->RCD ? "disabled" : "enabled",
2452 sdkp->DPOFUA ? "supports DPO and FUA"
2453 : "doesn't support DPO or FUA");
2454
2455 return;
2456 }
2457
2458bad_sense:
2459 if (scsi_sense_valid(&sshdr) &&
2460 sshdr.sense_key == ILLEGAL_REQUEST &&
2461 sshdr.asc == 0x24 && sshdr.ascq == 0x0)
2462
2463 sd_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n");
2464 else
2465 sd_printk(KERN_ERR, sdkp, "Asking for cache data failed\n");
2466
2467defaults:
2468 if (sdp->wce_default_on) {
2469 sd_printk(KERN_NOTICE, sdkp, "Assuming drive cache: write back\n");
2470 sdkp->WCE = 1;
2471 } else {
2472 sd_printk(KERN_ERR, sdkp, "Assuming drive cache: write through\n");
2473 sdkp->WCE = 0;
2474 }
2475 sdkp->RCD = 0;
2476 sdkp->DPOFUA = 0;
2477}
2478
2479
2480
2481
2482
2483static void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer)
2484{
2485 int res, offset;
2486 struct scsi_device *sdp = sdkp->device;
2487 struct scsi_mode_data data;
2488 struct scsi_sense_hdr sshdr;
2489
2490 if (sdp->type != TYPE_DISK)
2491 return;
2492
2493 if (sdkp->protection_type == 0)
2494 return;
2495
2496 res = scsi_mode_sense(sdp, 1, 0x0a, buffer, 36, SD_TIMEOUT,
2497 SD_MAX_RETRIES, &data, &sshdr);
2498
2499 if (!scsi_status_is_good(res) || !data.header_length ||
2500 data.length < 6) {
2501 sd_printk(KERN_WARNING, sdkp,
2502 "getting Control mode page failed, assume no ATO\n");
2503
2504 if (scsi_sense_valid(&sshdr))
2505 sd_print_sense_hdr(sdkp, &sshdr);
2506
2507 return;
2508 }
2509
2510 offset = data.header_length + data.block_descriptor_length;
2511
2512 if ((buffer[offset] & 0x3f) != 0x0a) {
2513 sd_printk(KERN_ERR, sdkp, "ATO Got wrong page\n");
2514 return;
2515 }
2516
2517 if ((buffer[offset + 5] & 0x80) == 0)
2518 return;
2519
2520 sdkp->ATO = 1;
2521
2522 return;
2523}
2524
2525
2526
2527
2528
2529static void sd_read_block_limits(struct scsi_disk *sdkp)
2530{
2531 unsigned int sector_sz = sdkp->device->sector_size;
2532 const int vpd_len = 64;
2533 unsigned char *buffer = kmalloc(vpd_len, GFP_KERNEL);
2534
2535 if (!buffer ||
2536
2537 scsi_get_vpd_page(sdkp->device, 0xb0, buffer, vpd_len))
2538 goto out;
2539
2540 blk_queue_io_min(sdkp->disk->queue,
2541 get_unaligned_be16(&buffer[6]) * sector_sz);
2542 blk_queue_io_opt(sdkp->disk->queue,
2543 get_unaligned_be32(&buffer[12]) * sector_sz);
2544
2545 if (buffer[3] == 0x3c) {
2546 unsigned int lba_count, desc_count;
2547
2548 sdkp->max_ws_blocks = (u32)get_unaligned_be64(&buffer[36]);
2549
2550 if (!sdkp->lbpme)
2551 goto out;
2552
2553 lba_count = get_unaligned_be32(&buffer[20]);
2554 desc_count = get_unaligned_be32(&buffer[24]);
2555
2556 if (lba_count && desc_count)
2557 sdkp->max_unmap_blocks = lba_count;
2558
2559 sdkp->unmap_granularity = get_unaligned_be32(&buffer[28]);
2560
2561 if (buffer[32] & 0x80)
2562 sdkp->unmap_alignment =
2563 get_unaligned_be32(&buffer[32]) & ~(1 << 31);
2564
2565 if (!sdkp->lbpvpd) {
2566
2567 if (sdkp->max_unmap_blocks)
2568 sd_config_discard(sdkp, SD_LBP_UNMAP);
2569 else
2570 sd_config_discard(sdkp, SD_LBP_WS16);
2571
2572 } else {
2573
2574 if (sdkp->lbpu && sdkp->max_unmap_blocks)
2575 sd_config_discard(sdkp, SD_LBP_UNMAP);
2576 else if (sdkp->lbpws)
2577 sd_config_discard(sdkp, SD_LBP_WS16);
2578 else if (sdkp->lbpws10)
2579 sd_config_discard(sdkp, SD_LBP_WS10);
2580 else
2581 sd_config_discard(sdkp, SD_LBP_DISABLE);
2582 }
2583 }
2584
2585 out:
2586 kfree(buffer);
2587}
2588
2589
2590
2591
2592
2593static void sd_read_block_characteristics(struct scsi_disk *sdkp)
2594{
2595 unsigned char *buffer;
2596 u16 rot;
2597 const int vpd_len = 64;
2598
2599 buffer = kmalloc(vpd_len, GFP_KERNEL);
2600
2601 if (!buffer ||
2602
2603 scsi_get_vpd_page(sdkp->device, 0xb1, buffer, vpd_len))
2604 goto out;
2605
2606 rot = get_unaligned_be16(&buffer[4]);
2607
2608 if (rot == 1)
2609 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, sdkp->disk->queue);
2610
2611 out:
2612 kfree(buffer);
2613}
2614
2615
2616
2617
2618
2619static void sd_read_block_provisioning(struct scsi_disk *sdkp)
2620{
2621 unsigned char *buffer;
2622 const int vpd_len = 8;
2623
2624 if (sdkp->lbpme == 0)
2625 return;
2626
2627 buffer = kmalloc(vpd_len, GFP_KERNEL);
2628
2629 if (!buffer || scsi_get_vpd_page(sdkp->device, 0xb2, buffer, vpd_len))
2630 goto out;
2631
2632 sdkp->lbpvpd = 1;
2633 sdkp->lbpu = (buffer[5] >> 7) & 1;
2634 sdkp->lbpws = (buffer[5] >> 6) & 1;
2635 sdkp->lbpws10 = (buffer[5] >> 5) & 1;
2636
2637 out:
2638 kfree(buffer);
2639}
2640
2641static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer)
2642{
2643 struct scsi_device *sdev = sdkp->device;
2644
2645 if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, INQUIRY) < 0) {
2646 sdev->no_report_opcodes = 1;
2647
2648
2649
2650
2651
2652 if (!scsi_get_vpd_page(sdev, 0x89, buffer, SD_BUF_SIZE))
2653 sdev->no_write_same = 1;
2654 }
2655
2656 if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, WRITE_SAME_16) == 1)
2657 sdkp->ws16 = 1;
2658
2659 if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, WRITE_SAME) == 1)
2660 sdkp->ws10 = 1;
2661}
2662
2663static int sd_try_extended_inquiry(struct scsi_device *sdp)
2664{
2665
2666
2667
2668
2669
2670 if (sdp->scsi_level > SCSI_SPC_2 && !sdp->skip_vpd_pages)
2671 return 1;
2672 return 0;
2673}
2674
2675
2676
2677
2678
2679
2680static int sd_revalidate_disk(struct gendisk *disk)
2681{
2682 struct scsi_disk *sdkp = scsi_disk(disk);
2683 struct scsi_device *sdp = sdkp->device;
2684 unsigned char *buffer;
2685 unsigned flush = 0;
2686
2687 SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp,
2688 "sd_revalidate_disk\n"));
2689
2690
2691
2692
2693
2694 if (!scsi_device_online(sdp))
2695 goto out;
2696
2697 buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL);
2698 if (!buffer) {
2699 sd_printk(KERN_WARNING, sdkp, "sd_revalidate_disk: Memory "
2700 "allocation failure.\n");
2701 goto out;
2702 }
2703
2704 sd_spinup_disk(sdkp);
2705
2706
2707
2708
2709
2710 if (sdkp->media_present) {
2711 sd_read_capacity(sdkp, buffer);
2712
2713 if (sd_try_extended_inquiry(sdp)) {
2714 sd_read_block_provisioning(sdkp);
2715 sd_read_block_limits(sdkp);
2716 sd_read_block_characteristics(sdkp);
2717 }
2718
2719 sd_read_write_protect_flag(sdkp, buffer);
2720 sd_read_cache_type(sdkp, buffer);
2721 sd_read_app_tag_own(sdkp, buffer);
2722 sd_read_write_same(sdkp, buffer);
2723 }
2724
2725 sdkp->first_scan = 0;
2726
2727
2728
2729
2730
2731 if (sdkp->WCE) {
2732 flush |= REQ_FLUSH;
2733 if (sdkp->DPOFUA)
2734 flush |= REQ_FUA;
2735 }
2736
2737 blk_queue_flush(sdkp->disk->queue, flush);
2738
2739 set_capacity(disk, sdkp->capacity);
2740 sd_config_write_same(sdkp);
2741 kfree(buffer);
2742
2743 out:
2744 return 0;
2745}
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759static void sd_unlock_native_capacity(struct gendisk *disk)
2760{
2761 struct scsi_device *sdev = scsi_disk(disk)->device;
2762
2763 if (sdev->host->hostt->unlock_native_capacity)
2764 sdev->host->hostt->unlock_native_capacity(sdev);
2765}
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789static int sd_format_disk_name(char *prefix, int index, char *buf, int buflen)
2790{
2791 const int base = 'z' - 'a' + 1;
2792 char *begin = buf + strlen(prefix);
2793 char *end = buf + buflen;
2794 char *p;
2795 int unit;
2796
2797 p = end - 1;
2798 *p = '\0';
2799 unit = base;
2800 do {
2801 if (p == begin)
2802 return -EINVAL;
2803 *--p = 'a' + (index % unit);
2804 index = (index / unit) - 1;
2805 } while (index >= 0);
2806
2807 memmove(begin, p, end - p);
2808 memcpy(buf, prefix, strlen(prefix));
2809
2810 return 0;
2811}
2812
2813
2814
2815
2816static void sd_probe_async(void *data, async_cookie_t cookie)
2817{
2818 struct scsi_disk *sdkp = data;
2819 struct scsi_device *sdp;
2820 struct gendisk *gd;
2821 u32 index;
2822 struct device *dev;
2823
2824 sdp = sdkp->device;
2825 gd = sdkp->disk;
2826 index = sdkp->index;
2827 dev = &sdp->sdev_gendev;
2828
2829 gd->major = sd_major((index & 0xf0) >> 4);
2830 gd->first_minor = ((index & 0xf) << 4) | (index & 0xfff00);
2831 gd->minors = SD_MINORS;
2832
2833 gd->fops = &sd_fops;
2834 gd->private_data = &sdkp->driver;
2835 gd->queue = sdkp->device->request_queue;
2836
2837
2838 sdp->sector_size = 512;
2839 sdkp->capacity = 0;
2840 sdkp->media_present = 1;
2841 sdkp->write_prot = 0;
2842 sdkp->cache_override = 0;
2843 sdkp->WCE = 0;
2844 sdkp->RCD = 0;
2845 sdkp->ATO = 0;
2846 sdkp->first_scan = 1;
2847 sdkp->max_medium_access_timeouts = SD_MAX_MEDIUM_TIMEOUTS;
2848
2849 sd_revalidate_disk(gd);
2850
2851 blk_queue_prep_rq(sdp->request_queue, sd_prep_fn);
2852 blk_queue_unprep_rq(sdp->request_queue, sd_unprep_fn);
2853
2854 gd->driverfs_dev = &sdp->sdev_gendev;
2855 gd->flags = GENHD_FL_EXT_DEVT;
2856 if (sdp->removable) {
2857 gd->flags |= GENHD_FL_REMOVABLE;
2858 gd->events |= DISK_EVENT_MEDIA_CHANGE;
2859 }
2860
2861 add_disk(gd);
2862 if (sdkp->capacity)
2863 sd_dif_config_host(sdkp);
2864
2865 sd_revalidate_disk(gd);
2866
2867 sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n",
2868 sdp->removable ? "removable " : "");
2869 blk_pm_runtime_init(sdp->request_queue, dev);
2870 scsi_autopm_put_device(sdp);
2871 put_device(&sdkp->dev);
2872}
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892static int sd_probe(struct device *dev)
2893{
2894 struct scsi_device *sdp = to_scsi_device(dev);
2895 struct scsi_disk *sdkp;
2896 struct gendisk *gd;
2897 int index;
2898 int error;
2899
2900 error = -ENODEV;
2901 if (sdp->type != TYPE_DISK && sdp->type != TYPE_MOD && sdp->type != TYPE_RBC)
2902 goto out;
2903
2904 SCSI_LOG_HLQUEUE(3, sdev_printk(KERN_INFO, sdp,
2905 "sd_probe\n"));
2906
2907 error = -ENOMEM;
2908 sdkp = kzalloc(sizeof(*sdkp), GFP_KERNEL);
2909 if (!sdkp)
2910 goto out;
2911
2912 gd = alloc_disk(SD_MINORS);
2913 if (!gd)
2914 goto out_free;
2915
2916 do {
2917 if (!ida_pre_get(&sd_index_ida, GFP_KERNEL))
2918 goto out_put;
2919
2920 spin_lock(&sd_index_lock);
2921 error = ida_get_new(&sd_index_ida, &index);
2922 spin_unlock(&sd_index_lock);
2923 } while (error == -EAGAIN);
2924
2925 if (error) {
2926 sdev_printk(KERN_WARNING, sdp, "sd_probe: memory exhausted.\n");
2927 goto out_put;
2928 }
2929
2930 error = sd_format_disk_name("sd", index, gd->disk_name, DISK_NAME_LEN);
2931 if (error) {
2932 sdev_printk(KERN_WARNING, sdp, "SCSI disk (sd) name length exceeded.\n");
2933 goto out_free_index;
2934 }
2935
2936 sdkp->device = sdp;
2937 sdkp->driver = &sd_template;
2938 sdkp->disk = gd;
2939 sdkp->index = index;
2940 atomic_set(&sdkp->openers, 0);
2941 atomic_set(&sdkp->device->ioerr_cnt, 0);
2942
2943 if (!sdp->request_queue->rq_timeout) {
2944 if (sdp->type != TYPE_MOD)
2945 blk_queue_rq_timeout(sdp->request_queue, SD_TIMEOUT);
2946 else
2947 blk_queue_rq_timeout(sdp->request_queue,
2948 SD_MOD_TIMEOUT);
2949 }
2950
2951 device_initialize(&sdkp->dev);
2952 sdkp->dev.parent = dev;
2953 sdkp->dev.class = &sd_disk_class;
2954 dev_set_name(&sdkp->dev, "%s", dev_name(dev));
2955
2956 if (device_add(&sdkp->dev))
2957 goto out_free_index;
2958
2959 get_device(dev);
2960 dev_set_drvdata(dev, sdkp);
2961
2962 get_device(&sdkp->dev);
2963 async_schedule_domain(sd_probe_async, sdkp, &scsi_sd_probe_domain);
2964
2965 return 0;
2966
2967 out_free_index:
2968 spin_lock(&sd_index_lock);
2969 ida_remove(&sd_index_ida, index);
2970 spin_unlock(&sd_index_lock);
2971 out_put:
2972 put_disk(gd);
2973 out_free:
2974 kfree(sdkp);
2975 out:
2976 return error;
2977}
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990static int sd_remove(struct device *dev)
2991{
2992 struct scsi_disk *sdkp;
2993 dev_t devt;
2994
2995 sdkp = dev_get_drvdata(dev);
2996 devt = disk_devt(sdkp->disk);
2997 scsi_autopm_get_device(sdkp->device);
2998
2999 async_synchronize_full_domain(&scsi_sd_probe_domain);
3000 blk_queue_prep_rq(sdkp->device->request_queue, scsi_prep_fn);
3001 blk_queue_unprep_rq(sdkp->device->request_queue, NULL);
3002 device_del(&sdkp->dev);
3003 del_gendisk(sdkp->disk);
3004 sd_shutdown(dev);
3005
3006 blk_register_region(devt, SD_MINORS, NULL,
3007 sd_default_probe, NULL, NULL);
3008
3009 mutex_lock(&sd_ref_mutex);
3010 dev_set_drvdata(dev, NULL);
3011 put_device(&sdkp->dev);
3012 mutex_unlock(&sd_ref_mutex);
3013
3014 return 0;
3015}
3016
3017
3018
3019
3020
3021
3022
3023
3024
3025
3026static void scsi_disk_release(struct device *dev)
3027{
3028 struct scsi_disk *sdkp = to_scsi_disk(dev);
3029 struct gendisk *disk = sdkp->disk;
3030
3031 spin_lock(&sd_index_lock);
3032 ida_remove(&sd_index_ida, sdkp->index);
3033 spin_unlock(&sd_index_lock);
3034
3035 disk->private_data = NULL;
3036 put_disk(disk);
3037 put_device(&sdkp->device->sdev_gendev);
3038
3039 kfree(sdkp);
3040}
3041
3042static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
3043{
3044 unsigned char cmd[6] = { START_STOP };
3045 struct scsi_sense_hdr sshdr;
3046 struct scsi_device *sdp = sdkp->device;
3047 int res;
3048
3049 if (start)
3050 cmd[4] |= 1;
3051
3052 if (sdp->start_stop_pwr_cond)
3053 cmd[4] |= start ? 1 << 4 : 3 << 4;
3054
3055 if (!scsi_device_online(sdp))
3056 return -ENODEV;
3057
3058 res = scsi_execute_req_flags(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
3059 SD_TIMEOUT, SD_MAX_RETRIES, NULL, REQ_PM);
3060 if (res) {
3061 sd_printk(KERN_WARNING, sdkp, "START_STOP FAILED\n");
3062 sd_print_result(sdkp, res);
3063 if (driver_byte(res) & DRIVER_SENSE)
3064 sd_print_sense_hdr(sdkp, &sshdr);
3065 }
3066
3067 return res;
3068}
3069
3070
3071
3072
3073
3074
3075static void sd_shutdown(struct device *dev)
3076{
3077 struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
3078
3079 if (!sdkp)
3080 return;
3081
3082 if (pm_runtime_suspended(dev))
3083 goto exit;
3084
3085 if (sdkp->WCE) {
3086 sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
3087 sd_sync_cache(sdkp);
3088 }
3089
3090 if (system_state != SYSTEM_RESTART && sdkp->device->manage_start_stop) {
3091 sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
3092 sd_start_stop_device(sdkp, 0);
3093 }
3094
3095exit:
3096 scsi_disk_put(sdkp);
3097}
3098
3099static int sd_suspend(struct device *dev)
3100{
3101 struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
3102 int ret = 0;
3103
3104 if (!sdkp)
3105 return 0;
3106
3107 if (sdkp->WCE) {
3108 sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
3109 ret = sd_sync_cache(sdkp);
3110 if (ret)
3111 goto done;
3112 }
3113
3114 if (sdkp->device->manage_start_stop) {
3115 sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
3116 ret = sd_start_stop_device(sdkp, 0);
3117 }
3118
3119done:
3120 scsi_disk_put(sdkp);
3121 return ret;
3122}
3123
3124static int sd_resume(struct device *dev)
3125{
3126 struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
3127 int ret = 0;
3128
3129 if (!sdkp->device->manage_start_stop)
3130 goto done;
3131
3132 sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
3133 ret = sd_start_stop_device(sdkp, 1);
3134
3135done:
3136 scsi_disk_put(sdkp);
3137 return ret;
3138}
3139
3140
3141
3142
3143
3144
3145
3146static int __init init_sd(void)
3147{
3148 int majors = 0, i, err;
3149
3150 SCSI_LOG_HLQUEUE(3, printk("init_sd: sd driver entry point\n"));
3151
3152 for (i = 0; i < SD_MAJORS; i++) {
3153 if (register_blkdev(sd_major(i), "sd") != 0)
3154 continue;
3155 majors++;
3156 blk_register_region(sd_major(i), SD_MINORS, NULL,
3157 sd_default_probe, NULL, NULL);
3158 }
3159
3160 if (!majors)
3161 return -ENODEV;
3162
3163 err = class_register(&sd_disk_class);
3164 if (err)
3165 goto err_out;
3166
3167 sd_cdb_cache = kmem_cache_create("sd_ext_cdb", SD_EXT_CDB_SIZE,
3168 0, 0, NULL);
3169 if (!sd_cdb_cache) {
3170 printk(KERN_ERR "sd: can't init extended cdb cache\n");
3171 goto err_out_class;
3172 }
3173
3174 sd_cdb_pool = mempool_create_slab_pool(SD_MEMPOOL_SIZE, sd_cdb_cache);
3175 if (!sd_cdb_pool) {
3176 printk(KERN_ERR "sd: can't init extended cdb pool\n");
3177 goto err_out_cache;
3178 }
3179
3180 err = scsi_register_driver(&sd_template.gendrv);
3181 if (err)
3182 goto err_out_driver;
3183
3184 return 0;
3185
3186err_out_driver:
3187 mempool_destroy(sd_cdb_pool);
3188
3189err_out_cache:
3190 kmem_cache_destroy(sd_cdb_cache);
3191
3192err_out_class:
3193 class_unregister(&sd_disk_class);
3194err_out:
3195 for (i = 0; i < SD_MAJORS; i++)
3196 unregister_blkdev(sd_major(i), "sd");
3197 return err;
3198}
3199
3200
3201
3202
3203
3204
3205static void __exit exit_sd(void)
3206{
3207 int i;
3208
3209 SCSI_LOG_HLQUEUE(3, printk("exit_sd: exiting sd driver\n"));
3210
3211 scsi_unregister_driver(&sd_template.gendrv);
3212 mempool_destroy(sd_cdb_pool);
3213 kmem_cache_destroy(sd_cdb_cache);
3214
3215 class_unregister(&sd_disk_class);
3216
3217 for (i = 0; i < SD_MAJORS; i++) {
3218 blk_unregister_region(sd_major(i), SD_MINORS);
3219 unregister_blkdev(sd_major(i), "sd");
3220 }
3221}
3222
3223module_init(init_sd);
3224module_exit(exit_sd);
3225
3226static void sd_print_sense_hdr(struct scsi_disk *sdkp,
3227 struct scsi_sense_hdr *sshdr)
3228{
3229 sd_printk(KERN_INFO, sdkp, " ");
3230 scsi_show_sense_hdr(sshdr);
3231 sd_printk(KERN_INFO, sdkp, " ");
3232 scsi_show_extd_sense(sshdr->asc, sshdr->ascq);
3233}
3234
3235static void sd_print_result(struct scsi_disk *sdkp, int result)
3236{
3237 sd_printk(KERN_INFO, sdkp, " ");
3238 scsi_show_result(result);
3239}
3240
3241