← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/scsi/sd.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/scsi/sd.c
 
1
/*
 
2
 *      sd.c Copyright (C) 1992 Drew Eckhardt
 
3
 *           Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
 
4
 *
 
5
 *      Linux scsi disk driver
 
6
 *              Initial versions: Drew Eckhardt
 
7
 *              Subsequent revisions: Eric Youngdale
 
8
 *      Modification history:
 
9
 *       - Drew Eckhardt <drew@colorado.edu> original
 
10
 *       - Eric Youngdale <eric@andante.org> add scatter-gather, multiple 
 
11
 *         outstanding request, and other enhancements.
 
12
 *         Support loadable low-level scsi drivers.
 
13
 *       - Jirka Hanika <geo@ff.cuni.cz> support more scsi disks using 
 
14
 *         eight major numbers.
 
15
 *       - Richard Gooch <rgooch@atnf.csiro.au> support devfs.
 
16
 *       - Torben Mathiasen <tmm@image.dk> Resource allocation fixes in 
 
17
 *         sd_init and cleanups.
 
18
 *       - Alex Davis <letmein@erols.com> Fix problem where partition info
 
19
 *         not being read in sd_open. Fix problem where removable media 
 
20
 *         could be ejected after sd_open.
 
21
 *       - Douglas Gilbert <dgilbert@interlog.com> cleanup for lk 2.5.x
 
22
 *       - Badari Pulavarty <pbadari@us.ibm.com>, Matthew Wilcox 
 
23
 *         <willy@debian.org>, Kurt Garloff <garloff@suse.de>: 
 
24
 *         Support 32k/1M disks.
 
25
 *
 
26
 *      Logging policy (needs CONFIG_SCSI_LOGGING defined):
 
27
 *       - setting up transfer: SCSI_LOG_HLQUEUE levels 1 and 2
 
28
 *       - end of transfer (bh + scsi_lib): SCSI_LOG_HLCOMPLETE level 1
 
29
 *       - entering sd_ioctl: SCSI_LOG_IOCTL level 1
 
30
 *       - entering other commands: SCSI_LOG_HLQUEUE level 3
 
31
 *      Note: when the logging level is set by the user, it must be greater
 
32
 *      than the level indicated above to trigger output.       
 
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 <asm/uaccess.h>
 
54
#include <asm/unaligned.h>
 
55
 
 
56
#include <scsi/scsi.h>
 
57
#include <scsi/scsi_cmnd.h>
 
58
#include <scsi/scsi_dbg.h>
 
59
#include <scsi/scsi_device.h>
 
60
#include <scsi/scsi_driver.h>
 
61
#include <scsi/scsi_eh.h>
 
62
#include <scsi/scsi_host.h>
 
63
#include <scsi/scsi_ioctl.h>
 
64
#include <scsi/scsicam.h>
 
65
 
 
66
#include "sd.h"
 
67
#include "scsi_logging.h"
 
68
 
 
69
MODULE_AUTHOR("Eric Youngdale");
 
70
MODULE_DESCRIPTION("SCSI disk (sd) driver");
 
71
MODULE_LICENSE("GPL");
 
72
 
 
73
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK0_MAJOR);
 
74
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK1_MAJOR);
 
75
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK2_MAJOR);
 
76
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK3_MAJOR);
 
77
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK4_MAJOR);
 
78
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK5_MAJOR);
 
79
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK6_MAJOR);
 
80
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK7_MAJOR);
 
81
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK8_MAJOR);
 
82
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK9_MAJOR);
 
83
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK10_MAJOR);
 
84
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK11_MAJOR);
 
85
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK12_MAJOR);
 
86
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK13_MAJOR);
 
87
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK14_MAJOR);
 
88
MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK15_MAJOR);
 
89
MODULE_ALIAS_SCSI_DEVICE(TYPE_DISK);
 
90
MODULE_ALIAS_SCSI_DEVICE(TYPE_MOD);
 
91
MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC);
 
92
 
 
93
#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
 
94
#define SD_MINORS       16
 
95
#else
 
96
#define SD_MINORS       0
 
97
#endif
 
98
 
 
99
static void sd_config_discard(struct scsi_disk *, unsigned int);
 
100
static int  sd_revalidate_disk(struct gendisk *);
 
101
static void sd_unlock_native_capacity(struct gendisk *disk);
 
102
static int  sd_probe(struct device *);
 
103
static int  sd_remove(struct device *);
 
104
static void sd_shutdown(struct device *);
 
105
static int sd_suspend(struct device *, pm_message_t state);
 
106
static int sd_resume(struct device *);
 
107
static void sd_rescan(struct device *);
 
108
static int sd_done(struct scsi_cmnd *);
 
109
static void sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer);
 
110
static void scsi_disk_release(struct device *cdev);
 
111
static void sd_print_sense_hdr(struct scsi_disk *, struct scsi_sense_hdr *);
 
112
static void sd_print_result(struct scsi_disk *, int);
 
113
 
 
114
static DEFINE_SPINLOCK(sd_index_lock);
 
115
static DEFINE_IDA(sd_index_ida);
 
116
 
 
117
/* This semaphore is used to mediate the 0->1 reference get in the
 
118
 * face of object destruction (i.e. we can't allow a get on an
 
119
 * object after last put) */
 
120
static DEFINE_MUTEX(sd_ref_mutex);
 
121
 
 
122
static struct kmem_cache *sd_cdb_cache;
 
123
static mempool_t *sd_cdb_pool;
 
124
 
 
125
static const char *sd_cache_types[] = {
 
126
        "write through", "none", "write back",
 
127
        "write back, no read (daft)"
 
128
};
 
129
 
 
130
static ssize_t
 
131
sd_store_cache_type(struct device *dev, struct device_attribute *attr,
 
132
                    const char *buf, size_t count)
 
133
{
 
134
        int i, ct = -1, rcd, wce, sp;
 
135
        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
136
        struct scsi_device *sdp = sdkp->device;
 
137
        char buffer[64];
 
138
        char *buffer_data;
 
139
        struct scsi_mode_data data;
 
140
        struct scsi_sense_hdr sshdr;
 
141
        int len;
 
142
 
 
143
        if (sdp->type != TYPE_DISK)
 
144
                /* no cache control on RBC devices; theoretically they
 
145
                 * can do it, but there's probably so many exceptions
 
146
                 * it's not worth the risk */
 
147
                return -EINVAL;
 
148
 
 
149
        for (i = 0; i < ARRAY_SIZE(sd_cache_types); i++) {
 
150
                len = strlen(sd_cache_types[i]);
 
151
                if (strncmp(sd_cache_types[i], buf, len) == 0 &&
 
152
                    buf[len] == '\n') {
 
153
                        ct = i;
 
154
                        break;
 
155
                }
 
156
        }
 
157
        if (ct < 0)
 
158
                return -EINVAL;
 
159
        rcd = ct & 0x01 ? 1 : 0;
 
160
        wce = ct & 0x02 ? 1 : 0;
 
161
        if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT,
 
162
                            SD_MAX_RETRIES, &data, NULL))
 
163
                return -EINVAL;
 
164
        len = min_t(size_t, sizeof(buffer), data.length - data.header_length -
 
165
                  data.block_descriptor_length);
 
166
        buffer_data = buffer + data.header_length +
 
167
                data.block_descriptor_length;
 
168
        buffer_data[2] &= ~0x05;
 
169
        buffer_data[2] |= wce << 2 | rcd;
 
170
        sp = buffer_data[0] & 0x80 ? 1 : 0;
 
171
 
 
172
        if (scsi_mode_select(sdp, 1, sp, 8, buffer_data, len, SD_TIMEOUT,
 
173
                             SD_MAX_RETRIES, &data, &sshdr)) {
 
174
                if (scsi_sense_valid(&sshdr))
 
175
                        sd_print_sense_hdr(sdkp, &sshdr);
 
176
                return -EINVAL;
 
177
        }
 
178
        revalidate_disk(sdkp->disk);
 
179
        return count;
 
180
}
 
181
 
 
182
static ssize_t
 
183
sd_store_manage_start_stop(struct device *dev, struct device_attribute *attr,
 
184
                           const char *buf, size_t count)
 
185
{
 
186
        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
187
        struct scsi_device *sdp = sdkp->device;
 
188
 
 
189
        if (!capable(CAP_SYS_ADMIN))
 
190
                return -EACCES;
 
191
 
 
192
        sdp->manage_start_stop = simple_strtoul(buf, NULL, 10);
 
193
 
 
194
        return count;
 
195
}
 
196
 
 
197
static ssize_t
 
198
sd_store_allow_restart(struct device *dev, struct device_attribute *attr,
 
199
                       const char *buf, size_t count)
 
200
{
 
201
        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
202
        struct scsi_device *sdp = sdkp->device;
 
203
 
 
204
        if (!capable(CAP_SYS_ADMIN))
 
205
                return -EACCES;
 
206
 
 
207
        if (sdp->type != TYPE_DISK)
 
208
                return -EINVAL;
 
209
 
 
210
        sdp->allow_restart = simple_strtoul(buf, NULL, 10);
 
211
 
 
212
        return count;
 
213
}
 
214
 
 
215
static ssize_t
 
216
sd_show_cache_type(struct device *dev, struct device_attribute *attr,
 
217
                   char *buf)
 
218
{
 
219
        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
220
        int ct = sdkp->RCD + 2*sdkp->WCE;
 
221
 
 
222
        return snprintf(buf, 40, "%s\n", sd_cache_types[ct]);
 
223
}
 
224
 
 
225
static ssize_t
 
226
sd_show_fua(struct device *dev, struct device_attribute *attr, char *buf)
 
227
{
 
228
        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
229
 
 
230
        return snprintf(buf, 20, "%u\n", sdkp->DPOFUA);
 
231
}
 
232
 
 
233
static ssize_t
 
234
sd_show_manage_start_stop(struct device *dev, struct device_attribute *attr,
 
235
                          char *buf)
 
236
{
 
237
        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
238
        struct scsi_device *sdp = sdkp->device;
 
239
 
 
240
        return snprintf(buf, 20, "%u\n", sdp->manage_start_stop);
 
241
}
 
242
 
 
243
static ssize_t
 
244
sd_show_allow_restart(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, 40, "%d\n", sdkp->device->allow_restart);
 
250
}
 
251
 
 
252
static ssize_t
 
253
sd_show_protection_type(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->protection_type);
 
259
}
 
260
 
 
261
static ssize_t
 
262
sd_show_protection_mode(struct device *dev, struct device_attribute *attr,
 
263
                        char *buf)
 
264
{
 
265
        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
266
        struct scsi_device *sdp = sdkp->device;
 
267
        unsigned int dif, dix;
 
268
 
 
269
        dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
 
270
        dix = scsi_host_dix_capable(sdp->host, sdkp->protection_type);
 
271
 
 
272
        if (!dix && scsi_host_dix_capable(sdp->host, SD_DIF_TYPE0_PROTECTION)) {
 
273
                dif = 0;
 
274
                dix = 1;
 
275
        }
 
276
 
 
277
        if (!dif && !dix)
 
278
                return snprintf(buf, 20, "none\n");
 
279
 
 
280
        return snprintf(buf, 20, "%s%u\n", dix ? "dix" : "dif", dif);
 
281
}
 
282
 
 
283
static ssize_t
 
284
sd_show_app_tag_own(struct device *dev, struct device_attribute *attr,
 
285
                    char *buf)
 
286
{
 
287
        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
288
 
 
289
        return snprintf(buf, 20, "%u\n", sdkp->ATO);
 
290
}
 
291
 
 
292
static ssize_t
 
293
sd_show_thin_provisioning(struct device *dev, struct device_attribute *attr,
 
294
                          char *buf)
 
295
{
 
296
        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
297
 
 
298
        return snprintf(buf, 20, "%u\n", sdkp->lbpme);
 
299
}
 
300
 
 
301
static const char *lbp_mode[] = {
 
302
        [SD_LBP_FULL]           = "full",
 
303
        [SD_LBP_UNMAP]          = "unmap",
 
304
        [SD_LBP_WS16]           = "writesame_16",
 
305
        [SD_LBP_WS10]           = "writesame_10",
 
306
        [SD_LBP_ZERO]           = "writesame_zero",
 
307
        [SD_LBP_DISABLE]        = "disabled",
 
308
};
 
309
 
 
310
static ssize_t
 
311
sd_show_provisioning_mode(struct device *dev, struct device_attribute *attr,
 
312
                          char *buf)
 
313
{
 
314
        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
315
 
 
316
        return snprintf(buf, 20, "%s\n", lbp_mode[sdkp->provisioning_mode]);
 
317
}
 
318
 
 
319
static ssize_t
 
320
sd_store_provisioning_mode(struct device *dev, struct device_attribute *attr,
 
321
                           const char *buf, size_t count)
 
322
{
 
323
        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
324
        struct scsi_device *sdp = sdkp->device;
 
325
 
 
326
        if (!capable(CAP_SYS_ADMIN))
 
327
                return -EACCES;
 
328
 
 
329
        if (sdp->type != TYPE_DISK)
 
330
                return -EINVAL;
 
331
 
 
332
        if (!strncmp(buf, lbp_mode[SD_LBP_UNMAP], 20))
 
333
                sd_config_discard(sdkp, SD_LBP_UNMAP);
 
334
        else if (!strncmp(buf, lbp_mode[SD_LBP_WS16], 20))
 
335
                sd_config_discard(sdkp, SD_LBP_WS16);
 
336
        else if (!strncmp(buf, lbp_mode[SD_LBP_WS10], 20))
 
337
                sd_config_discard(sdkp, SD_LBP_WS10);
 
338
        else if (!strncmp(buf, lbp_mode[SD_LBP_ZERO], 20))
 
339
                sd_config_discard(sdkp, SD_LBP_ZERO);
 
340
        else if (!strncmp(buf, lbp_mode[SD_LBP_DISABLE], 20))
 
341
                sd_config_discard(sdkp, SD_LBP_DISABLE);
 
342
        else
 
343
                return -EINVAL;
 
344
 
 
345
        return count;
 
346
}
 
347
 
 
348
static struct device_attribute sd_disk_attrs[] = {
 
349
        __ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
 
350
               sd_store_cache_type),
 
351
        __ATTR(FUA, S_IRUGO, sd_show_fua, NULL),
 
352
        __ATTR(allow_restart, S_IRUGO|S_IWUSR, sd_show_allow_restart,
 
353
               sd_store_allow_restart),
 
354
        __ATTR(manage_start_stop, S_IRUGO|S_IWUSR, sd_show_manage_start_stop,
 
355
               sd_store_manage_start_stop),
 
356
        __ATTR(protection_type, S_IRUGO, sd_show_protection_type, NULL),
 
357
        __ATTR(protection_mode, S_IRUGO, sd_show_protection_mode, NULL),
 
358
        __ATTR(app_tag_own, S_IRUGO, sd_show_app_tag_own, NULL),
 
359
        __ATTR(thin_provisioning, S_IRUGO, sd_show_thin_provisioning, NULL),
 
360
        __ATTR(provisioning_mode, S_IRUGO|S_IWUSR, sd_show_provisioning_mode,
 
361
               sd_store_provisioning_mode),
 
362
        __ATTR_NULL,
 
363
};
 
364
 
 
365
static struct class sd_disk_class = {
 
366
        .name           = "scsi_disk",
 
367
        .owner          = THIS_MODULE,
 
368
        .dev_release    = scsi_disk_release,
 
369
        .dev_attrs      = sd_disk_attrs,
 
370
};
 
371
 
 
372
static struct scsi_driver sd_template = {
 
373
        .owner                  = THIS_MODULE,
 
374
        .gendrv = {
 
375
                .name           = "sd",
 
376
                .probe          = sd_probe,
 
377
                .remove         = sd_remove,
 
378
                .suspend        = sd_suspend,
 
379
                .resume         = sd_resume,
 
380
                .shutdown       = sd_shutdown,
 
381
        },
 
382
        .rescan                 = sd_rescan,
 
383
        .done                   = sd_done,
 
384
};
 
385
 
 
386
/*
 
387
 * Device no to disk mapping:
 
388
 * 
 
389
 *       major         disc2     disc  p1
 
390
 *   |............|.............|....|....| <- dev_t
 
391
 *    31        20 19          8 7  4 3  0
 
392
 * 
 
393
 * Inside a major, we have 16k disks, however mapped non-
 
394
 * contiguously. The first 16 disks are for major0, the next
 
395
 * ones with major1, ... Disk 256 is for major0 again, disk 272 
 
396
 * for major1, ... 
 
397
 * As we stay compatible with our numbering scheme, we can reuse 
 
398
 * the well-know SCSI majors 8, 65--71, 136--143.
 
399
 */
 
400
static int sd_major(int major_idx)
 
401
{
 
402
        switch (major_idx) {
 
403
        case 0:
 
404
                return SCSI_DISK0_MAJOR;
 
405
        case 1 ... 7:
 
406
                return SCSI_DISK1_MAJOR + major_idx - 1;
 
407
        case 8 ... 15:
 
408
                return SCSI_DISK8_MAJOR + major_idx - 8;
 
409
        default:
 
410
                BUG();
 
411
                return 0;       /* shut up gcc */
 
412
        }
 
413
}
 
414
 
 
415
static struct scsi_disk *__scsi_disk_get(struct gendisk *disk)
 
416
{
 
417
        struct scsi_disk *sdkp = NULL;
 
418
 
 
419
        if (disk->private_data) {
 
420
                sdkp = scsi_disk(disk);
 
421
                if (scsi_device_get(sdkp->device) == 0)
 
422
                        get_device(&sdkp->dev);
 
423
                else
 
424
                        sdkp = NULL;
 
425
        }
 
426
        return sdkp;
 
427
}
 
428
 
 
429
static struct scsi_disk *scsi_disk_get(struct gendisk *disk)
 
430
{
 
431
        struct scsi_disk *sdkp;
 
432
 
 
433
        mutex_lock(&sd_ref_mutex);
 
434
        sdkp = __scsi_disk_get(disk);
 
435
        mutex_unlock(&sd_ref_mutex);
 
436
        return sdkp;
 
437
}
 
438
 
 
439
static struct scsi_disk *scsi_disk_get_from_dev(struct device *dev)
 
440
{
 
441
        struct scsi_disk *sdkp;
 
442
 
 
443
        mutex_lock(&sd_ref_mutex);
 
444
        sdkp = dev_get_drvdata(dev);
 
445
        if (sdkp)
 
446
                sdkp = __scsi_disk_get(sdkp->disk);
 
447
        mutex_unlock(&sd_ref_mutex);
 
448
        return sdkp;
 
449
}
 
450
 
 
451
static void scsi_disk_put(struct scsi_disk *sdkp)
 
452
{
 
453
        struct scsi_device *sdev = sdkp->device;
 
454
 
 
455
        mutex_lock(&sd_ref_mutex);
 
456
        put_device(&sdkp->dev);
 
457
        scsi_device_put(sdev);
 
458
        mutex_unlock(&sd_ref_mutex);
 
459
}
 
460
 
 
461
static void sd_prot_op(struct scsi_cmnd *scmd, unsigned int dif)
 
462
{
 
463
        unsigned int prot_op = SCSI_PROT_NORMAL;
 
464
        unsigned int dix = scsi_prot_sg_count(scmd);
 
465
 
 
466
        if (scmd->sc_data_direction == DMA_FROM_DEVICE) {
 
467
                if (dif && dix)
 
468
                        prot_op = SCSI_PROT_READ_PASS;
 
469
                else if (dif && !dix)
 
470
                        prot_op = SCSI_PROT_READ_STRIP;
 
471
                else if (!dif && dix)
 
472
                        prot_op = SCSI_PROT_READ_INSERT;
 
473
        } else {
 
474
                if (dif && dix)
 
475
                        prot_op = SCSI_PROT_WRITE_PASS;
 
476
                else if (dif && !dix)
 
477
                        prot_op = SCSI_PROT_WRITE_INSERT;
 
478
                else if (!dif && dix)
 
479
                        prot_op = SCSI_PROT_WRITE_STRIP;
 
480
        }
 
481
 
 
482
        scsi_set_prot_op(scmd, prot_op);
 
483
        scsi_set_prot_type(scmd, dif);
 
484
}
 
485
 
 
486
static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
 
487
{
 
488
        struct request_queue *q = sdkp->disk->queue;
 
489
        unsigned int logical_block_size = sdkp->device->sector_size;
 
490
        unsigned int max_blocks = 0;
 
491
 
 
492
        q->limits.discard_zeroes_data = sdkp->lbprz;
 
493
        q->limits.discard_alignment = sdkp->unmap_alignment *
 
494
                logical_block_size;
 
495
        q->limits.discard_granularity =
 
496
                max(sdkp->physical_block_size,
 
497
                    sdkp->unmap_granularity * logical_block_size);
 
498
 
 
499
        switch (mode) {
 
500
 
 
501
        case SD_LBP_DISABLE:
 
502
                q->limits.max_discard_sectors = 0;
 
503
                queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, q);
 
504
                return;
 
505
 
 
506
        case SD_LBP_UNMAP:
 
507
                max_blocks = min_not_zero(sdkp->max_unmap_blocks, 0xffffffff);
 
508
                break;
 
509
 
 
510
        case SD_LBP_WS16:
 
511
                max_blocks = min_not_zero(sdkp->max_ws_blocks, 0xffffffff);
 
512
                break;
 
513
 
 
514
        case SD_LBP_WS10:
 
515
                max_blocks = min_not_zero(sdkp->max_ws_blocks, (u32)0xffff);
 
516
                break;
 
517
 
 
518
        case SD_LBP_ZERO:
 
519
                max_blocks = min_not_zero(sdkp->max_ws_blocks, (u32)0xffff);
 
520
                q->limits.discard_zeroes_data = 1;
 
521
                break;
 
522
        }
 
523
 
 
524
        q->limits.max_discard_sectors = max_blocks * (logical_block_size >> 9);
 
525
        queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);
 
526
 
 
527
        sdkp->provisioning_mode = mode;
 
528
}
 
529
 
 
530
/**
 
531
 * scsi_setup_discard_cmnd - unmap blocks on thinly provisioned device
 
532
 * @sdp: scsi device to operate one
 
533
 * @rq: Request to prepare
 
534
 *
 
535
 * Will issue either UNMAP or WRITE SAME(16) depending on preference
 
536
 * indicated by target device.
 
537
 **/
 
538
static int scsi_setup_discard_cmnd(struct scsi_device *sdp, struct request *rq)
 
539
{
 
540
        struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
 
541
        struct bio *bio = rq->bio;
 
542
        sector_t sector = bio->bi_sector;
 
543
        unsigned int nr_sectors = bio_sectors(bio);
 
544
        unsigned int len;
 
545
        int ret;
 
546
        char *buf;
 
547
        struct page *page;
 
548
 
 
549
        if (sdkp->device->sector_size == 4096) {
 
550
                sector >>= 3;
 
551
                nr_sectors >>= 3;
 
552
        }
 
553
 
 
554
        rq->timeout = SD_TIMEOUT;
 
555
 
 
556
        memset(rq->cmd, 0, rq->cmd_len);
 
557
 
 
558
        page = alloc_page(GFP_ATOMIC | __GFP_ZERO);
 
559
        if (!page)
 
560
                return BLKPREP_DEFER;
 
561
 
 
562
        switch (sdkp->provisioning_mode) {
 
563
        case SD_LBP_UNMAP:
 
564
                buf = page_address(page);
 
565
 
 
566
                rq->cmd_len = 10;
 
567
                rq->cmd[0] = UNMAP;
 
568
                rq->cmd[8] = 24;
 
569
 
 
570
                put_unaligned_be16(6 + 16, &buf[0]);
 
571
                put_unaligned_be16(16, &buf[2]);
 
572
                put_unaligned_be64(sector, &buf[8]);
 
573
                put_unaligned_be32(nr_sectors, &buf[16]);
 
574
 
 
575
                len = 24;
 
576
                break;
 
577
 
 
578
        case SD_LBP_WS16:
 
579
                rq->cmd_len = 16;
 
580
                rq->cmd[0] = WRITE_SAME_16;
 
581
                rq->cmd[1] = 0x8; /* UNMAP */
 
582
                put_unaligned_be64(sector, &rq->cmd[2]);
 
583
                put_unaligned_be32(nr_sectors, &rq->cmd[10]);
 
584
 
 
585
                len = sdkp->device->sector_size;
 
586
                break;
 
587
 
 
588
        case SD_LBP_WS10:
 
589
        case SD_LBP_ZERO:
 
590
                rq->cmd_len = 10;
 
591
                rq->cmd[0] = WRITE_SAME;
 
592
                if (sdkp->provisioning_mode == SD_LBP_WS10)
 
593
                        rq->cmd[1] = 0x8; /* UNMAP */
 
594
                put_unaligned_be32(sector, &rq->cmd[2]);
 
595
                put_unaligned_be16(nr_sectors, &rq->cmd[7]);
 
596
 
 
597
                len = sdkp->device->sector_size;
 
598
                break;
 
599
 
 
600
        default:
 
601
                ret = BLKPREP_KILL;
 
602
                goto out;
 
603
        }
 
604
 
 
605
        blk_add_request_payload(rq, page, len);
 
606
        ret = scsi_setup_blk_pc_cmnd(sdp, rq);
 
607
        rq->buffer = page_address(page);
 
608
 
 
609
out:
 
610
        if (ret != BLKPREP_OK) {
 
611
                __free_page(page);
 
612
                rq->buffer = NULL;
 
613
        }
 
614
        return ret;
 
615
}
 
616
 
 
617
static int scsi_setup_flush_cmnd(struct scsi_device *sdp, struct request *rq)
 
618
{
 
619
        rq->timeout = SD_FLUSH_TIMEOUT;
 
620
        rq->retries = SD_MAX_RETRIES;
 
621
        rq->cmd[0] = SYNCHRONIZE_CACHE;
 
622
        rq->cmd_len = 10;
 
623
 
 
624
        return scsi_setup_blk_pc_cmnd(sdp, rq);
 
625
}
 
626
 
 
627
static void sd_unprep_fn(struct request_queue *q, struct request *rq)
 
628
{
 
629
        if (rq->cmd_flags & REQ_DISCARD) {
 
630
                free_page((unsigned long)rq->buffer);
 
631
                rq->buffer = NULL;
 
632
        }
 
633
}
 
634
 
 
635
/**
 
636
 *      sd_init_command - build a scsi (read or write) command from
 
637
 *      information in the request structure.
 
638
 *      @SCpnt: pointer to mid-level's per scsi command structure that
 
639
 *      contains request and into which the scsi command is written
 
640
 *
 
641
 *      Returns 1 if successful and 0 if error (or cannot be done now).
 
642
 **/
 
643
static int sd_prep_fn(struct request_queue *q, struct request *rq)
 
644
{
 
645
        struct scsi_cmnd *SCpnt;
 
646
        struct scsi_device *sdp = q->queuedata;
 
647
        struct gendisk *disk = rq->rq_disk;
 
648
        struct scsi_disk *sdkp;
 
649
        sector_t block = blk_rq_pos(rq);
 
650
        sector_t threshold;
 
651
        unsigned int this_count = blk_rq_sectors(rq);
 
652
        int ret, host_dif;
 
653
        unsigned char protect;
 
654
 
 
655
        /*
 
656
         * Discard request come in as REQ_TYPE_FS but we turn them into
 
657
         * block PC requests to make life easier.
 
658
         */
 
659
        if (rq->cmd_flags & REQ_DISCARD) {
 
660
                ret = scsi_setup_discard_cmnd(sdp, rq);
 
661
                goto out;
 
662
        } else if (rq->cmd_flags & REQ_FLUSH) {
 
663
                ret = scsi_setup_flush_cmnd(sdp, rq);
 
664
                goto out;
 
665
        } else if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
 
666
                ret = scsi_setup_blk_pc_cmnd(sdp, rq);
 
667
                goto out;
 
668
        } else if (rq->cmd_type != REQ_TYPE_FS) {
 
669
                ret = BLKPREP_KILL;
 
670
                goto out;
 
671
        }
 
672
        ret = scsi_setup_fs_cmnd(sdp, rq);
 
673
        if (ret != BLKPREP_OK)
 
674
                goto out;
 
675
        SCpnt = rq->special;
 
676
        sdkp = scsi_disk(disk);
 
677
 
 
678
        /* from here on until we're complete, any goto out
 
679
         * is used for a killable error condition */
 
680
        ret = BLKPREP_KILL;
 
681
 
 
682
        SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,
 
683
                                        "sd_init_command: block=%llu, "
 
684
                                        "count=%d\n",
 
685
                                        (unsigned long long)block,
 
686
                                        this_count));
 
687
 
 
688
        if (!sdp || !scsi_device_online(sdp) ||
 
689
            block + blk_rq_sectors(rq) > get_capacity(disk)) {
 
690
                SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
 
691
                                                "Finishing %u sectors\n",
 
692
                                                blk_rq_sectors(rq)));
 
693
                SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
 
694
                                                "Retry with 0x%p\n", SCpnt));
 
695
                goto out;
 
696
        }
 
697
 
 
698
        if (sdp->changed) {
 
699
                /*
 
700
                 * quietly refuse to do anything to a changed disc until 
 
701
                 * the changed bit has been reset
 
702
                 */
 
703
                /* printk("SCSI disk has been changed or is not present. Prohibiting further I/O.\n"); */
 
704
                goto out;
 
705
        }
 
706
 
 
707
        /*
 
708
         * Some SD card readers can't handle multi-sector accesses which touch
 
709
         * the last one or two hardware sectors.  Split accesses as needed.
 
710
         */
 
711
        threshold = get_capacity(disk) - SD_LAST_BUGGY_SECTORS *
 
712
                (sdp->sector_size / 512);
 
713
 
 
714
        if (unlikely(sdp->last_sector_bug && block + this_count > threshold)) {
 
715
                if (block < threshold) {
 
716
                        /* Access up to the threshold but not beyond */
 
717
                        this_count = threshold - block;
 
718
                } else {
 
719
                        /* Access only a single hardware sector */
 
720
                        this_count = sdp->sector_size / 512;
 
721
                }
 
722
        }
 
723
 
 
724
        SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "block=%llu\n",
 
725
                                        (unsigned long long)block));
 
726
 
 
727
        /*
 
728
         * If we have a 1K hardware sectorsize, prevent access to single
 
729
         * 512 byte sectors.  In theory we could handle this - in fact
 
730
         * the scsi cdrom driver must be able to handle this because
 
731
         * we typically use 1K blocksizes, and cdroms typically have
 
732
         * 2K hardware sectorsizes.  Of course, things are simpler
 
733
         * with the cdrom, since it is read-only.  For performance
 
734
         * reasons, the filesystems should be able to handle this
 
735
         * and not force the scsi disk driver to use bounce buffers
 
736
         * for this.
 
737
         */
 
738
        if (sdp->sector_size == 1024) {
 
739
                if ((block & 1) || (blk_rq_sectors(rq) & 1)) {
 
740
                        scmd_printk(KERN_ERR, SCpnt,
 
741
                                    "Bad block number requested\n");
 
742
                        goto out;
 
743
                } else {
 
744
                        block = block >> 1;
 
745
                        this_count = this_count >> 1;
 
746
                }
 
747
        }
 
748
        if (sdp->sector_size == 2048) {
 
749
                if ((block & 3) || (blk_rq_sectors(rq) & 3)) {
 
750
                        scmd_printk(KERN_ERR, SCpnt,
 
751
                                    "Bad block number requested\n");
 
752
                        goto out;
 
753
                } else {
 
754
                        block = block >> 2;
 
755
                        this_count = this_count >> 2;
 
756
                }
 
757
        }
 
758
        if (sdp->sector_size == 4096) {
 
759
                if ((block & 7) || (blk_rq_sectors(rq) & 7)) {
 
760
                        scmd_printk(KERN_ERR, SCpnt,
 
761
                                    "Bad block number requested\n");
 
762
                        goto out;
 
763
                } else {
 
764
                        block = block >> 3;
 
765
                        this_count = this_count >> 3;
 
766
                }
 
767
        }
 
768
        if (rq_data_dir(rq) == WRITE) {
 
769
                if (!sdp->writeable) {
 
770
                        goto out;
 
771
                }
 
772
                SCpnt->cmnd[0] = WRITE_6;
 
773
                SCpnt->sc_data_direction = DMA_TO_DEVICE;
 
774
 
 
775
                if (blk_integrity_rq(rq) &&
 
776
                    sd_dif_prepare(rq, block, sdp->sector_size) == -EIO)
 
777
                        goto out;
 
778
 
 
779
        } else if (rq_data_dir(rq) == READ) {
 
780
                SCpnt->cmnd[0] = READ_6;
 
781
                SCpnt->sc_data_direction = DMA_FROM_DEVICE;
 
782
        } else {
 
783
                scmd_printk(KERN_ERR, SCpnt, "Unknown command %x\n", rq->cmd_flags);
 
784
                goto out;
 
785
        }
 
786
 
 
787
        SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
 
788
                                        "%s %d/%u 512 byte blocks.\n",
 
789
                                        (rq_data_dir(rq) == WRITE) ?
 
790
                                        "writing" : "reading", this_count,
 
791
                                        blk_rq_sectors(rq)));
 
792
 
 
793
        /* Set RDPROTECT/WRPROTECT if disk is formatted with DIF */
 
794
        host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
 
795
        if (host_dif)
 
796
                protect = 1 << 5;
 
797
        else
 
798
                protect = 0;
 
799
 
 
800
        if (host_dif == SD_DIF_TYPE2_PROTECTION) {
 
801
                SCpnt->cmnd = mempool_alloc(sd_cdb_pool, GFP_ATOMIC);
 
802
 
 
803
                if (unlikely(SCpnt->cmnd == NULL)) {
 
804
                        ret = BLKPREP_DEFER;
 
805
                        goto out;
 
806
                }
 
807
 
 
808
                SCpnt->cmd_len = SD_EXT_CDB_SIZE;
 
809
                memset(SCpnt->cmnd, 0, SCpnt->cmd_len);
 
810
                SCpnt->cmnd[0] = VARIABLE_LENGTH_CMD;
 
811
                SCpnt->cmnd[7] = 0x18;
 
812
                SCpnt->cmnd[9] = (rq_data_dir(rq) == READ) ? READ_32 : WRITE_32;
 
813
                SCpnt->cmnd[10] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
 
814
 
 
815
                /* LBA */
 
816
                SCpnt->cmnd[12] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
 
817
                SCpnt->cmnd[13] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
 
818
                SCpnt->cmnd[14] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
 
819
                SCpnt->cmnd[15] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
 
820
                SCpnt->cmnd[16] = (unsigned char) (block >> 24) & 0xff;
 
821
                SCpnt->cmnd[17] = (unsigned char) (block >> 16) & 0xff;
 
822
                SCpnt->cmnd[18] = (unsigned char) (block >> 8) & 0xff;
 
823
                SCpnt->cmnd[19] = (unsigned char) block & 0xff;
 
824
 
 
825
                /* Expected Indirect LBA */
 
826
                SCpnt->cmnd[20] = (unsigned char) (block >> 24) & 0xff;
 
827
                SCpnt->cmnd[21] = (unsigned char) (block >> 16) & 0xff;
 
828
                SCpnt->cmnd[22] = (unsigned char) (block >> 8) & 0xff;
 
829
                SCpnt->cmnd[23] = (unsigned char) block & 0xff;
 
830
 
 
831
                /* Transfer length */
 
832
                SCpnt->cmnd[28] = (unsigned char) (this_count >> 24) & 0xff;
 
833
                SCpnt->cmnd[29] = (unsigned char) (this_count >> 16) & 0xff;
 
834
                SCpnt->cmnd[30] = (unsigned char) (this_count >> 8) & 0xff;
 
835
                SCpnt->cmnd[31] = (unsigned char) this_count & 0xff;
 
836
        } else if (block > 0xffffffff) {
 
837
                SCpnt->cmnd[0] += READ_16 - READ_6;
 
838
                SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
 
839
                SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0;
 
840
                SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0;
 
841
                SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0;
 
842
                SCpnt->cmnd[5] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0;
 
843
                SCpnt->cmnd[6] = (unsigned char) (block >> 24) & 0xff;
 
844
                SCpnt->cmnd[7] = (unsigned char) (block >> 16) & 0xff;
 
845
                SCpnt->cmnd[8] = (unsigned char) (block >> 8) & 0xff;
 
846
                SCpnt->cmnd[9] = (unsigned char) block & 0xff;
 
847
                SCpnt->cmnd[10] = (unsigned char) (this_count >> 24) & 0xff;
 
848
                SCpnt->cmnd[11] = (unsigned char) (this_count >> 16) & 0xff;
 
849
                SCpnt->cmnd[12] = (unsigned char) (this_count >> 8) & 0xff;
 
850
                SCpnt->cmnd[13] = (unsigned char) this_count & 0xff;
 
851
                SCpnt->cmnd[14] = SCpnt->cmnd[15] = 0;
 
852
        } else if ((this_count > 0xff) || (block > 0x1fffff) ||
 
853
                   scsi_device_protection(SCpnt->device) ||
 
854
                   SCpnt->device->use_10_for_rw) {
 
855
                if (this_count > 0xffff)
 
856
                        this_count = 0xffff;
 
857
 
 
858
                SCpnt->cmnd[0] += READ_10 - READ_6;
 
859
                SCpnt->cmnd[1] = protect | ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0);
 
860
                SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff;
 
861
                SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff;
 
862
                SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff;
 
863
                SCpnt->cmnd[5] = (unsigned char) block & 0xff;
 
864
                SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0;
 
865
                SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff;
 
866
                SCpnt->cmnd[8] = (unsigned char) this_count & 0xff;
 
867
        } else {
 
868
                if (unlikely(rq->cmd_flags & REQ_FUA)) {
 
869
                        /*
 
870
                         * This happens only if this drive failed
 
871
                         * 10byte rw command with ILLEGAL_REQUEST
 
872
                         * during operation and thus turned off
 
873
                         * use_10_for_rw.
 
874
                         */
 
875
                        scmd_printk(KERN_ERR, SCpnt,
 
876
                                    "FUA write on READ/WRITE(6) drive\n");
 
877
                        goto out;
 
878
                }
 
879
 
 
880
                SCpnt->cmnd[1] |= (unsigned char) ((block >> 16) & 0x1f);
 
881
                SCpnt->cmnd[2] = (unsigned char) ((block >> 8) & 0xff);
 
882
                SCpnt->cmnd[3] = (unsigned char) block & 0xff;
 
883
                SCpnt->cmnd[4] = (unsigned char) this_count;
 
884
                SCpnt->cmnd[5] = 0;
 
885
        }
 
886
        SCpnt->sdb.length = this_count * sdp->sector_size;
 
887
 
 
888
        /* If DIF or DIX is enabled, tell HBA how to handle request */
 
889
        if (host_dif || scsi_prot_sg_count(SCpnt))
 
890
                sd_prot_op(SCpnt, host_dif);
 
891
 
 
892
        /*
 
893
         * We shouldn't disconnect in the middle of a sector, so with a dumb
 
894
         * host adapter, it's safe to assume that we can at least transfer
 
895
         * this many bytes between each connect / disconnect.
 
896
         */
 
897
        SCpnt->transfersize = sdp->sector_size;
 
898
        SCpnt->underflow = this_count << 9;
 
899
        SCpnt->allowed = SD_MAX_RETRIES;
 
900
 
 
901
        /*
 
902
         * This indicates that the command is ready from our end to be
 
903
         * queued.
 
904
         */
 
905
        ret = BLKPREP_OK;
 
906
 out:
 
907
        return scsi_prep_return(q, rq, ret);
 
908
}
 
909
 
 
910
/**
 
911
 *      sd_open - open a scsi disk device
 
912
 *      @inode: only i_rdev member may be used
 
913
 *      @filp: only f_mode and f_flags may be used
 
914
 *
 
915
 *      Returns 0 if successful. Returns a negated errno value in case 
 
916
 *      of error.
 
917
 *
 
918
 *      Note: This can be called from a user context (e.g. fsck(1) )
 
919
 *      or from within the kernel (e.g. as a result of a mount(1) ).
 
920
 *      In the latter case @inode and @filp carry an abridged amount
 
921
 *      of information as noted above.
 
922
 *
 
923
 *      Locking: called with bdev->bd_mutex held.
 
924
 **/
 
925
static int sd_open(struct block_device *bdev, fmode_t mode)
 
926
{
 
927
        struct scsi_disk *sdkp = scsi_disk_get(bdev->bd_disk);
 
928
        struct scsi_device *sdev;
 
929
        int retval;
 
930
 
 
931
        if (!sdkp)
 
932
                return -ENXIO;
 
933
 
 
934
        SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n"));
 
935
 
 
936
        sdev = sdkp->device;
 
937
 
 
938
        retval = scsi_autopm_get_device(sdev);
 
939
        if (retval)
 
940
                goto error_autopm;
 
941
 
 
942
        /*
 
943
         * If the device is in error recovery, wait until it is done.
 
944
         * If the device is offline, then disallow any access to it.
 
945
         */
 
946
        retval = -ENXIO;
 
947
        if (!scsi_block_when_processing_errors(sdev))
 
948
                goto error_out;
 
949
 
 
950
        if (sdev->removable || sdkp->write_prot)
 
951
                check_disk_change(bdev);
 
952
 
 
953
        /*
 
954
         * If the drive is empty, just let the open fail.
 
955
         */
 
956
        retval = -ENOMEDIUM;
 
957
        if (sdev->removable && !sdkp->media_present && !(mode & FMODE_NDELAY))
 
958
                goto error_out;
 
959
 
 
960
        /*
 
961
         * If the device has the write protect tab set, have the open fail
 
962
         * if the user expects to be able to write to the thing.
 
963
         */
 
964
        retval = -EROFS;
 
965
        if (sdkp->write_prot && (mode & FMODE_WRITE))
 
966
                goto error_out;
 
967
 
 
968
        /*
 
969
         * It is possible that the disk changing stuff resulted in
 
970
         * the device being taken offline.  If this is the case,
 
971
         * report this to the user, and don't pretend that the
 
972
         * open actually succeeded.
 
973
         */
 
974
        retval = -ENXIO;
 
975
        if (!scsi_device_online(sdev))
 
976
                goto error_out;
 
977
 
 
978
        if ((atomic_inc_return(&sdkp->openers) == 1) && sdev->removable) {
 
979
                if (scsi_block_when_processing_errors(sdev))
 
980
                        scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT);
 
981
        }
 
982
 
 
983
        return 0;
 
984
 
 
985
error_out:
 
986
        scsi_autopm_put_device(sdev);
 
987
error_autopm:
 
988
        scsi_disk_put(sdkp);
 
989
        return retval;  
 
990
}
 
991
 
 
992
/**
 
993
 *      sd_release - invoked when the (last) close(2) is called on this
 
994
 *      scsi disk.
 
995
 *      @inode: only i_rdev member may be used
 
996
 *      @filp: only f_mode and f_flags may be used
 
997
 *
 
998
 *      Returns 0. 
 
999
 *
 
1000
 *      Note: may block (uninterruptible) if error recovery is underway
 
1001
 *      on this disk.
 
1002
 *
 
1003
 *      Locking: called with bdev->bd_mutex held.
 
1004
 **/
 
1005
static int sd_release(struct gendisk *disk, fmode_t mode)
 
1006
{
 
1007
        struct scsi_disk *sdkp = scsi_disk(disk);
 
1008
        struct scsi_device *sdev = sdkp->device;
 
1009
 
 
1010
        SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_release\n"));
 
1011
 
 
1012
        if (atomic_dec_return(&sdkp->openers) == 0 && sdev->removable) {
 
1013
                if (scsi_block_when_processing_errors(sdev))
 
1014
                        scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW);
 
1015
        }
 
1016
 
 
1017
        /*
 
1018
         * XXX and what if there are packets in flight and this close()
 
1019
         * XXX is followed by a "rmmod sd_mod"?
 
1020
         */
 
1021
 
 
1022
        scsi_autopm_put_device(sdev);
 
1023
        scsi_disk_put(sdkp);
 
1024
        return 0;
 
1025
}
 
1026
 
 
1027
static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 
1028
{
 
1029
        struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
 
1030
        struct scsi_device *sdp = sdkp->device;
 
1031
        struct Scsi_Host *host = sdp->host;
 
1032
        int diskinfo[4];
 
1033
 
 
1034
        /* default to most commonly used values */
 
1035
        diskinfo[0] = 0x40;     /* 1 << 6 */
 
1036
        diskinfo[1] = 0x20;     /* 1 << 5 */
 
1037
        diskinfo[2] = sdkp->capacity >> 11;
 
1038
        
 
1039
        /* override with calculated, extended default, or driver values */
 
1040
        if (host->hostt->bios_param)
 
1041
                host->hostt->bios_param(sdp, bdev, sdkp->capacity, diskinfo);
 
1042
        else
 
1043
                scsicam_bios_param(bdev, sdkp->capacity, diskinfo);
 
1044
 
 
1045
        geo->heads = diskinfo[0];
 
1046
        geo->sectors = diskinfo[1];
 
1047
        geo->cylinders = diskinfo[2];
 
1048
        return 0;
 
1049
}
 
1050
 
 
1051
/**
 
1052
 *      sd_ioctl - process an ioctl
 
1053
 *      @inode: only i_rdev/i_bdev members may be used
 
1054
 *      @filp: only f_mode and f_flags may be used
 
1055
 *      @cmd: ioctl command number
 
1056
 *      @arg: this is third argument given to ioctl(2) system call.
 
1057
 *      Often contains a pointer.
 
1058
 *
 
1059
 *      Returns 0 if successful (some ioctls return positive numbers on
 
1060
 *      success as well). Returns a negated errno value in case of error.
 
1061
 *
 
1062
 *      Note: most ioctls are forward onto the block subsystem or further
 
1063
 *      down in the scsi subsystem.
 
1064
 **/
 
1065
static int sd_ioctl(struct block_device *bdev, fmode_t mode,
 
1066
                    unsigned int cmd, unsigned long arg)
 
1067
{
 
1068
        struct gendisk *disk = bdev->bd_disk;
 
1069
        struct scsi_disk *sdkp = scsi_disk(disk);
 
1070
        struct scsi_device *sdp = sdkp->device;
 
1071
        void __user *p = (void __user *)arg;
 
1072
        int error;
 
1073
    
 
1074
        SCSI_LOG_IOCTL(1, sd_printk(KERN_INFO, sdkp, "sd_ioctl: disk=%s, "
 
1075
                                    "cmd=0x%x\n", disk->disk_name, cmd));
 
1076
 
 
1077
        /*
 
1078
         * If we are in the middle of error recovery, don't let anyone
 
1079
         * else try and use this device.  Also, if error recovery fails, it
 
1080
         * may try and take the device offline, in which case all further
 
1081
         * access to the device is prohibited.
 
1082
         */
 
1083
        error = scsi_nonblockable_ioctl(sdp, cmd, p,
 
1084
                                        (mode & FMODE_NDELAY) != 0);
 
1085
        if (!scsi_block_when_processing_errors(sdp) || !error)
 
1086
                goto out;
 
1087
 
 
1088
        /*
 
1089
         * Send SCSI addressing ioctls directly to mid level, send other
 
1090
         * ioctls to block level and then onto mid level if they can't be
 
1091
         * resolved.
 
1092
         */
 
1093
        switch (cmd) {
 
1094
                case SCSI_IOCTL_GET_IDLUN:
 
1095
                case SCSI_IOCTL_GET_BUS_NUMBER:
 
1096
                        error = scsi_ioctl(sdp, cmd, p);
 
1097
                        break;
 
1098
                default:
 
1099
                        error = scsi_cmd_ioctl(disk->queue, disk, mode, cmd, p);
 
1100
                        if (error != -ENOTTY)
 
1101
                                break;
 
1102
                        error = scsi_ioctl(sdp, cmd, p);
 
1103
                        break;
 
1104
        }
 
1105
out:
 
1106
        return error;
 
1107
}
 
1108
 
 
1109
static void set_media_not_present(struct scsi_disk *sdkp)
 
1110
{
 
1111
        if (sdkp->media_present)
 
1112
                sdkp->device->changed = 1;
 
1113
 
 
1114
        if (sdkp->device->removable) {
 
1115
                sdkp->media_present = 0;
 
1116
                sdkp->capacity = 0;
 
1117
        }
 
1118
}
 
1119
 
 
1120
static int media_not_present(struct scsi_disk *sdkp,
 
1121
                             struct scsi_sense_hdr *sshdr)
 
1122
{
 
1123
        if (!scsi_sense_valid(sshdr))
 
1124
                return 0;
 
1125
 
 
1126
        /* not invoked for commands that could return deferred errors */
 
1127
        switch (sshdr->sense_key) {
 
1128
        case UNIT_ATTENTION:
 
1129
        case NOT_READY:
 
1130
                /* medium not present */
 
1131
                if (sshdr->asc == 0x3A) {
 
1132
                        set_media_not_present(sdkp);
 
1133
                        return 1;
 
1134
                }
 
1135
        }
 
1136
        return 0;
 
1137
}
 
1138
 
 
1139
/**
 
1140
 *      sd_check_events - check media events
 
1141
 *      @disk: kernel device descriptor
 
1142
 *      @clearing: disk events currently being cleared
 
1143
 *
 
1144
 *      Returns mask of DISK_EVENT_*.
 
1145
 *
 
1146
 *      Note: this function is invoked from the block subsystem.
 
1147
 **/
 
1148
static unsigned int sd_check_events(struct gendisk *disk, unsigned int clearing)
 
1149
{
 
1150
        struct scsi_disk *sdkp = scsi_disk(disk);
 
1151
        struct scsi_device *sdp = sdkp->device;
 
1152
        struct scsi_sense_hdr *sshdr = NULL;
 
1153
        int retval;
 
1154
 
 
1155
        SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_check_events\n"));
 
1156
 
 
1157
        /*
 
1158
         * If the device is offline, don't send any commands - just pretend as
 
1159
         * if the command failed.  If the device ever comes back online, we
 
1160
         * can deal with it then.  It is only because of unrecoverable errors
 
1161
         * that we would ever take a device offline in the first place.
 
1162
         */
 
1163
        if (!scsi_device_online(sdp)) {
 
1164
                set_media_not_present(sdkp);
 
1165
                goto out;
 
1166
        }
 
1167
 
 
1168
        /*
 
1169
         * Using TEST_UNIT_READY enables differentiation between drive with
 
1170
         * no cartridge loaded - NOT READY, drive with changed cartridge -
 
1171
         * UNIT ATTENTION, or with same cartridge - GOOD STATUS.
 
1172
         *
 
1173
         * Drives that auto spin down. eg iomega jaz 1G, will be started
 
1174
         * by sd_spinup_disk() from sd_revalidate_disk(), which happens whenever
 
1175
         * sd_revalidate() is called.
 
1176
         */
 
1177
        retval = -ENODEV;
 
1178
 
 
1179
        if (scsi_block_when_processing_errors(sdp)) {
 
1180
                sshdr  = kzalloc(sizeof(*sshdr), GFP_KERNEL);
 
1181
                retval = scsi_test_unit_ready(sdp, SD_TIMEOUT, SD_MAX_RETRIES,
 
1182
                                              sshdr);
 
1183
        }
 
1184
 
 
1185
        /* failed to execute TUR, assume media not present */
 
1186
        if (host_byte(retval)) {
 
1187
                set_media_not_present(sdkp);
 
1188
                goto out;
 
1189
        }
 
1190
 
 
1191
        if (media_not_present(sdkp, sshdr))
 
1192
                goto out;
 
1193
 
 
1194
        /*
 
1195
         * For removable scsi disk we have to recognise the presence
 
1196
         * of a disk in the drive.
 
1197
         */
 
1198
        if (!sdkp->media_present)
 
1199
                sdp->changed = 1;
 
1200
        sdkp->media_present = 1;
 
1201
out:
 
1202
        /*
 
1203
         * sdp->changed is set under the following conditions:
 
1204
         *
 
1205
         *      Medium present state has changed in either direction.
 
1206
         *      Device has indicated UNIT_ATTENTION.
 
1207
         */
 
1208
        kfree(sshdr);
 
1209
        retval = sdp->changed ? DISK_EVENT_MEDIA_CHANGE : 0;
 
1210
        sdp->changed = 0;
 
1211
        return retval;
 
1212
}
 
1213
 
 
1214
static int sd_sync_cache(struct scsi_disk *sdkp)
 
1215
{
 
1216
        int retries, res;
 
1217
        struct scsi_device *sdp = sdkp->device;
 
1218
        struct scsi_sense_hdr sshdr;
 
1219
 
 
1220
        if (!scsi_device_online(sdp))
 
1221
                return -ENODEV;
 
1222
 
 
1223
 
 
1224
        for (retries = 3; retries > 0; --retries) {
 
1225
                unsigned char cmd[10] = { 0 };
 
1226
 
 
1227
                cmd[0] = SYNCHRONIZE_CACHE;
 
1228
                /*
 
1229
                 * Leave the rest of the command zero to indicate
 
1230
                 * flush everything.
 
1231
                 */
 
1232
                res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
 
1233
                                       SD_FLUSH_TIMEOUT, SD_MAX_RETRIES, NULL);
 
1234
                if (res == 0)
 
1235
                        break;
 
1236
        }
 
1237
 
 
1238
        if (res) {
 
1239
                sd_print_result(sdkp, res);
 
1240
                if (driver_byte(res) & DRIVER_SENSE)
 
1241
                        sd_print_sense_hdr(sdkp, &sshdr);
 
1242
        }
 
1243
 
 
1244
        if (res)
 
1245
                return -EIO;
 
1246
        return 0;
 
1247
}
 
1248
 
 
1249
static void sd_rescan(struct device *dev)
 
1250
{
 
1251
        struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
 
1252
 
 
1253
        if (sdkp) {
 
1254
                revalidate_disk(sdkp->disk);
 
1255
                scsi_disk_put(sdkp);
 
1256
        }
 
1257
}
 
1258
 
 
1259
 
 
1260
#ifdef CONFIG_COMPAT
 
1261
/* 
 
1262
 * This gets directly called from VFS. When the ioctl 
 
1263
 * is not recognized we go back to the other translation paths. 
 
1264
 */
 
1265
static int sd_compat_ioctl(struct block_device *bdev, fmode_t mode,
 
1266
                           unsigned int cmd, unsigned long arg)
 
1267
{
 
1268
        struct scsi_device *sdev = scsi_disk(bdev->bd_disk)->device;
 
1269
 
 
1270
        /*
 
1271
         * If we are in the middle of error recovery, don't let anyone
 
1272
         * else try and use this device.  Also, if error recovery fails, it
 
1273
         * may try and take the device offline, in which case all further
 
1274
         * access to the device is prohibited.
 
1275
         */
 
1276
        if (!scsi_block_when_processing_errors(sdev))
 
1277
                return -ENODEV;
 
1278
               
 
1279
        if (sdev->host->hostt->compat_ioctl) {
 
1280
                int ret;
 
1281
 
 
1282
                ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user *)arg);
 
1283
 
 
1284
                return ret;
 
1285
        }
 
1286
 
 
1287
        /* 
 
1288
         * Let the static ioctl translation table take care of it.
 
1289
         */
 
1290
        return -ENOIOCTLCMD; 
 
1291
}
 
1292
#endif
 
1293
 
 
1294
static const struct block_device_operations sd_fops = {
 
1295
        .owner                  = THIS_MODULE,
 
1296
        .open                   = sd_open,
 
1297
        .release                = sd_release,
 
1298
        .ioctl                  = sd_ioctl,
 
1299
        .getgeo                 = sd_getgeo,
 
1300
#ifdef CONFIG_COMPAT
 
1301
        .compat_ioctl           = sd_compat_ioctl,
 
1302
#endif
 
1303
        .check_events           = sd_check_events,
 
1304
        .revalidate_disk        = sd_revalidate_disk,
 
1305
        .unlock_native_capacity = sd_unlock_native_capacity,
 
1306
};
 
1307
 
 
1308
static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
 
1309
{
 
1310
        u64 start_lba = blk_rq_pos(scmd->request);
 
1311
        u64 end_lba = blk_rq_pos(scmd->request) + (scsi_bufflen(scmd) / 512);
 
1312
        u64 bad_lba;
 
1313
        int info_valid;
 
1314
        /*
 
1315
         * resid is optional but mostly filled in.  When it's unused,
 
1316
         * its value is zero, so we assume the whole buffer transferred
 
1317
         */
 
1318
        unsigned int transferred = scsi_bufflen(scmd) - scsi_get_resid(scmd);
 
1319
        unsigned int good_bytes;
 
1320
 
 
1321
        if (scmd->request->cmd_type != REQ_TYPE_FS)
 
1322
                return 0;
 
1323
 
 
1324
        info_valid = scsi_get_sense_info_fld(scmd->sense_buffer,
 
1325
                                             SCSI_SENSE_BUFFERSIZE,
 
1326
                                             &bad_lba);
 
1327
        if (!info_valid)
 
1328
                return 0;
 
1329
 
 
1330
        if (scsi_bufflen(scmd) <= scmd->device->sector_size)
 
1331
                return 0;
 
1332
 
 
1333
        if (scmd->device->sector_size < 512) {
 
1334
                /* only legitimate sector_size here is 256 */
 
1335
                start_lba <<= 1;
 
1336
                end_lba <<= 1;
 
1337
        } else {
 
1338
                /* be careful ... don't want any overflows */
 
1339
                u64 factor = scmd->device->sector_size / 512;
 
1340
                do_div(start_lba, factor);
 
1341
                do_div(end_lba, factor);
 
1342
        }
 
1343
 
 
1344
        /* The bad lba was reported incorrectly, we have no idea where
 
1345
         * the error is.
 
1346
         */
 
1347
        if (bad_lba < start_lba  || bad_lba >= end_lba)
 
1348
                return 0;
 
1349
 
 
1350
        /* This computation should always be done in terms of
 
1351
         * the resolution of the device's medium.
 
1352
         */
 
1353
        good_bytes = (bad_lba - start_lba) * scmd->device->sector_size;
 
1354
        return min(good_bytes, transferred);
 
1355
}
 
1356
 
 
1357
/**
 
1358
 *      sd_done - bottom half handler: called when the lower level
 
1359
 *      driver has completed (successfully or otherwise) a scsi command.
 
1360
 *      @SCpnt: mid-level's per command structure.
 
1361
 *
 
1362
 *      Note: potentially run from within an ISR. Must not block.
 
1363
 **/
 
1364
static int sd_done(struct scsi_cmnd *SCpnt)
 
1365
{
 
1366
        int result = SCpnt->result;
 
1367
        unsigned int good_bytes = result ? 0 : scsi_bufflen(SCpnt);
 
1368
        struct scsi_sense_hdr sshdr;
 
1369
        struct scsi_disk *sdkp = scsi_disk(SCpnt->request->rq_disk);
 
1370
        int sense_valid = 0;
 
1371
        int sense_deferred = 0;
 
1372
        unsigned char op = SCpnt->cmnd[0];
 
1373
 
 
1374
        if ((SCpnt->request->cmd_flags & REQ_DISCARD) && !result)
 
1375
                scsi_set_resid(SCpnt, 0);
 
1376
 
 
1377
        if (result) {
 
1378
                sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr);
 
1379
                if (sense_valid)
 
1380
                        sense_deferred = scsi_sense_is_deferred(&sshdr);
 
1381
        }
 
1382
#ifdef CONFIG_SCSI_LOGGING
 
1383
        SCSI_LOG_HLCOMPLETE(1, scsi_print_result(SCpnt));
 
1384
        if (sense_valid) {
 
1385
                SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, SCpnt,
 
1386
                                                   "sd_done: sb[respc,sk,asc,"
 
1387
                                                   "ascq]=%x,%x,%x,%x\n",
 
1388
                                                   sshdr.response_code,
 
1389
                                                   sshdr.sense_key, sshdr.asc,
 
1390
                                                   sshdr.ascq));
 
1391
        }
 
1392
#endif
 
1393
        if (driver_byte(result) != DRIVER_SENSE &&
 
1394
            (!sense_valid || sense_deferred))
 
1395
                goto out;
 
1396
 
 
1397
        switch (sshdr.sense_key) {
 
1398
        case HARDWARE_ERROR:
 
1399
        case MEDIUM_ERROR:
 
1400
                good_bytes = sd_completed_bytes(SCpnt);
 
1401
                break;
 
1402
        case RECOVERED_ERROR:
 
1403
                good_bytes = scsi_bufflen(SCpnt);
 
1404
                break;
 
1405
        case NO_SENSE:
 
1406
                /* This indicates a false check condition, so ignore it.  An
 
1407
                 * unknown amount of data was transferred so treat it as an
 
1408
                 * error.
 
1409
                 */
 
1410
                scsi_print_sense("sd", SCpnt);
 
1411
                SCpnt->result = 0;
 
1412
                memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
 
1413
                break;
 
1414
        case ABORTED_COMMAND:
 
1415
                if (sshdr.asc == 0x10)  /* DIF: Target detected corruption */
 
1416
                        good_bytes = sd_completed_bytes(SCpnt);
 
1417
                break;
 
1418
        case ILLEGAL_REQUEST:
 
1419
                if (sshdr.asc == 0x10)  /* DIX: Host detected corruption */
 
1420
                        good_bytes = sd_completed_bytes(SCpnt);
 
1421
                /* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */
 
1422
                if ((sshdr.asc == 0x20 || sshdr.asc == 0x24) &&
 
1423
                    (op == UNMAP || op == WRITE_SAME_16 || op == WRITE_SAME))
 
1424
                        sd_config_discard(sdkp, SD_LBP_DISABLE);
 
1425
                break;
 
1426
        default:
 
1427
                break;
 
1428
        }
 
1429
 out:
 
1430
        if (rq_data_dir(SCpnt->request) == READ && scsi_prot_sg_count(SCpnt))
 
1431
                sd_dif_complete(SCpnt, good_bytes);
 
1432
 
 
1433
        if (scsi_host_dif_capable(sdkp->device->host, sdkp->protection_type)
 
1434
            == SD_DIF_TYPE2_PROTECTION && SCpnt->cmnd != SCpnt->request->cmd) {
 
1435
 
 
1436
                /* We have to print a failed command here as the
 
1437
                 * extended CDB gets freed before scsi_io_completion()
 
1438
                 * is called.
 
1439
                 */
 
1440
                if (result)
 
1441
                        scsi_print_command(SCpnt);
 
1442
 
 
1443
                mempool_free(SCpnt->cmnd, sd_cdb_pool);
 
1444
                SCpnt->cmnd = NULL;
 
1445
                SCpnt->cmd_len = 0;
 
1446
        }
 
1447
 
 
1448
        return good_bytes;
 
1449
}
 
1450
 
 
1451
/*
 
1452
 * spinup disk - called only in sd_revalidate_disk()
 
1453
 */
 
1454
static void
 
1455
sd_spinup_disk(struct scsi_disk *sdkp)
 
1456
{
 
1457
        unsigned char cmd[10];
 
1458
        unsigned long spintime_expire = 0;
 
1459
        int retries, spintime;
 
1460
        unsigned int the_result;
 
1461
        struct scsi_sense_hdr sshdr;
 
1462
        int sense_valid = 0;
 
1463
 
 
1464
        spintime = 0;
 
1465
 
 
1466
        /* Spin up drives, as required.  Only do this at boot time */
 
1467
        /* Spinup needs to be done for module loads too. */
 
1468
        do {
 
1469
                retries = 0;
 
1470
 
 
1471
                do {
 
1472
                        cmd[0] = TEST_UNIT_READY;
 
1473
                        memset((void *) &cmd[1], 0, 9);
 
1474
 
 
1475
                        the_result = scsi_execute_req(sdkp->device, cmd,
 
1476
                                                      DMA_NONE, NULL, 0,
 
1477
                                                      &sshdr, SD_TIMEOUT,
 
1478
                                                      SD_MAX_RETRIES, NULL);
 
1479
 
 
1480
                        /*
 
1481
                         * If the drive has indicated to us that it
 
1482
                         * doesn't have any media in it, don't bother
 
1483
                         * with any more polling.
 
1484
                         */
 
1485
                        if (media_not_present(sdkp, &sshdr))
 
1486
                                return;
 
1487
 
 
1488
                        if (the_result)
 
1489
                                sense_valid = scsi_sense_valid(&sshdr);
 
1490
                        retries++;
 
1491
                } while (retries < 3 && 
 
1492
                         (!scsi_status_is_good(the_result) ||
 
1493
                          ((driver_byte(the_result) & DRIVER_SENSE) &&
 
1494
                          sense_valid && sshdr.sense_key == UNIT_ATTENTION)));
 
1495
 
 
1496
                if ((driver_byte(the_result) & DRIVER_SENSE) == 0) {
 
1497
                        /* no sense, TUR either succeeded or failed
 
1498
                         * with a status error */
 
1499
                        if(!spintime && !scsi_status_is_good(the_result)) {
 
1500
                                sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
 
1501
                                sd_print_result(sdkp, the_result);
 
1502
                        }
 
1503
                        break;
 
1504
                }
 
1505
                                        
 
1506
                /*
 
1507
                 * The device does not want the automatic start to be issued.
 
1508
                 */
 
1509
                if (sdkp->device->no_start_on_add)
 
1510
                        break;
 
1511
 
 
1512
                if (sense_valid && sshdr.sense_key == NOT_READY) {
 
1513
                        if (sshdr.asc == 4 && sshdr.ascq == 3)
 
1514
                                break;  /* manual intervention required */
 
1515
                        if (sshdr.asc == 4 && sshdr.ascq == 0xb)
 
1516
                                break;  /* standby */
 
1517
                        if (sshdr.asc == 4 && sshdr.ascq == 0xc)
 
1518
                                break;  /* unavailable */
 
1519
                        /*
 
1520
                         * Issue command to spin up drive when not ready
 
1521
                         */
 
1522
                        if (!spintime) {
 
1523
                                sd_printk(KERN_NOTICE, sdkp, "Spinning up disk...");
 
1524
                                cmd[0] = START_STOP;
 
1525
                                cmd[1] = 1;     /* Return immediately */
 
1526
                                memset((void *) &cmd[2], 0, 8);
 
1527
                                cmd[4] = 1;     /* Start spin cycle */
 
1528
                                if (sdkp->device->start_stop_pwr_cond)
 
1529
                                        cmd[4] |= 1 << 4;
 
1530
                                scsi_execute_req(sdkp->device, cmd, DMA_NONE,
 
1531
                                                 NULL, 0, &sshdr,
 
1532
                                                 SD_TIMEOUT, SD_MAX_RETRIES,
 
1533
                                                 NULL);
 
1534
                                spintime_expire = jiffies + 100 * HZ;
 
1535
                                spintime = 1;
 
1536
                        }
 
1537
                        /* Wait 1 second for next try */
 
1538
                        msleep(1000);
 
1539
                        printk(".");
 
1540
 
 
1541
                /*
 
1542
                 * Wait for USB flash devices with slow firmware.
 
1543
                 * Yes, this sense key/ASC combination shouldn't
 
1544
                 * occur here.  It's characteristic of these devices.
 
1545
                 */
 
1546
                } else if (sense_valid &&
 
1547
                                sshdr.sense_key == UNIT_ATTENTION &&
 
1548
                                sshdr.asc == 0x28) {
 
1549
                        if (!spintime) {
 
1550
                                spintime_expire = jiffies + 5 * HZ;
 
1551
                                spintime = 1;
 
1552
                        }
 
1553
                        /* Wait 1 second for next try */
 
1554
                        msleep(1000);
 
1555
                } else {
 
1556
                        /* we don't understand the sense code, so it's
 
1557
                         * probably pointless to loop */
 
1558
                        if(!spintime) {
 
1559
                                sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n");
 
1560
                                sd_print_sense_hdr(sdkp, &sshdr);
 
1561
                        }
 
1562
                        break;
 
1563
                }
 
1564
                                
 
1565
        } while (spintime && time_before_eq(jiffies, spintime_expire));
 
1566
 
 
1567
        if (spintime) {
 
1568
                if (scsi_status_is_good(the_result))
 
1569
                        printk("ready\n");
 
1570
                else
 
1571
                        printk("not responding...\n");
 
1572
        }
 
1573
}
 
1574
 
 
1575
 
 
1576
/*
 
1577
 * Determine whether disk supports Data Integrity Field.
 
1578
 */
 
1579
static void sd_read_protection_type(struct scsi_disk *sdkp, unsigned char *buffer)
 
1580
{
 
1581
        struct scsi_device *sdp = sdkp->device;
 
1582
        u8 type;
 
1583
 
 
1584
        if (scsi_device_protection(sdp) == 0 || (buffer[12] & 1) == 0)
 
1585
                return;
 
1586
 
 
1587
        type = ((buffer[12] >> 1) & 7) + 1; /* P_TYPE 0 = Type 1 */
 
1588
 
 
1589
        if (type == sdkp->protection_type || !sdkp->first_scan)
 
1590
                return;
 
1591
 
 
1592
        sdkp->protection_type = type;
 
1593
 
 
1594
        if (type > SD_DIF_TYPE3_PROTECTION) {
 
1595
                sd_printk(KERN_ERR, sdkp, "formatted with unsupported " \
 
1596
                          "protection type %u. Disabling disk!\n", type);
 
1597
                sdkp->capacity = 0;
 
1598
                return;
 
1599
        }
 
1600
 
 
1601
        if (scsi_host_dif_capable(sdp->host, type))
 
1602
                sd_printk(KERN_NOTICE, sdkp,
 
1603
                          "Enabling DIF Type %u protection\n", type);
 
1604
        else
 
1605
                sd_printk(KERN_NOTICE, sdkp,
 
1606
                          "Disabling DIF Type %u protection\n", type);
 
1607
}
 
1608
 
 
1609
static void read_capacity_error(struct scsi_disk *sdkp, struct scsi_device *sdp,
 
1610
                        struct scsi_sense_hdr *sshdr, int sense_valid,
 
1611
                        int the_result)
 
1612
{
 
1613
        sd_print_result(sdkp, the_result);
 
1614
        if (driver_byte(the_result) & DRIVER_SENSE)
 
1615
                sd_print_sense_hdr(sdkp, sshdr);
 
1616
        else
 
1617
                sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n");
 
1618
 
 
1619
        /*
 
1620
         * Set dirty bit for removable devices if not ready -
 
1621
         * sometimes drives will not report this properly.
 
1622
         */
 
1623
        if (sdp->removable &&
 
1624
            sense_valid && sshdr->sense_key == NOT_READY)
 
1625
                set_media_not_present(sdkp);
 
1626
 
 
1627
        /*
 
1628
         * We used to set media_present to 0 here to indicate no media
 
1629
         * in the drive, but some drives fail read capacity even with
 
1630
         * media present, so we can't do that.
 
1631
         */
 
1632
        sdkp->capacity = 0; /* unknown mapped to zero - as usual */
 
1633
}
 
1634
 
 
1635
#define RC16_LEN 32
 
1636
#if RC16_LEN > SD_BUF_SIZE
 
1637
#error RC16_LEN must not be more than SD_BUF_SIZE
 
1638
#endif
 
1639
 
 
1640
#define READ_CAPACITY_RETRIES_ON_RESET  10
 
1641
 
 
1642
static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
 
1643
                                                unsigned char *buffer)
 
1644
{
 
1645
        unsigned char cmd[16];
 
1646
        struct scsi_sense_hdr sshdr;
 
1647
        int sense_valid = 0;
 
1648
        int the_result;
 
1649
        int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET;
 
1650
        unsigned int alignment;
 
1651
        unsigned long long lba;
 
1652
        unsigned sector_size;
 
1653
 
 
1654
        if (sdp->no_read_capacity_16)
 
1655
                return -EINVAL;
 
1656
 
 
1657
        do {
 
1658
                memset(cmd, 0, 16);
 
1659
                cmd[0] = SERVICE_ACTION_IN;
 
1660
                cmd[1] = SAI_READ_CAPACITY_16;
 
1661
                cmd[13] = RC16_LEN;
 
1662
                memset(buffer, 0, RC16_LEN);
 
1663
 
 
1664
                the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
 
1665
                                        buffer, RC16_LEN, &sshdr,
 
1666
                                        SD_TIMEOUT, SD_MAX_RETRIES, NULL);
 
1667
 
 
1668
                if (media_not_present(sdkp, &sshdr))
 
1669
                        return -ENODEV;
 
1670
 
 
1671
                if (the_result) {
 
1672
                        sense_valid = scsi_sense_valid(&sshdr);
 
1673
                        if (sense_valid &&
 
1674
                            sshdr.sense_key == ILLEGAL_REQUEST &&
 
1675
                            (sshdr.asc == 0x20 || sshdr.asc == 0x24) &&
 
1676
                            sshdr.ascq == 0x00)
 
1677
                                /* Invalid Command Operation Code or
 
1678
                                 * Invalid Field in CDB, just retry
 
1679
                                 * silently with RC10 */
 
1680
                                return -EINVAL;
 
1681
                        if (sense_valid &&
 
1682
                            sshdr.sense_key == UNIT_ATTENTION &&
 
1683
                            sshdr.asc == 0x29 && sshdr.ascq == 0x00)
 
1684
                                /* Device reset might occur several times,
 
1685
                                 * give it one more chance */
 
1686
                                if (--reset_retries > 0)
 
1687
                                        continue;
 
1688
                }
 
1689
                retries--;
 
1690
 
 
1691
        } while (the_result && retries);
 
1692
 
 
1693
        if (the_result) {
 
1694
                sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY(16) failed\n");
 
1695
                read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
 
1696
                return -EINVAL;
 
1697
        }
 
1698
 
 
1699
        sector_size = get_unaligned_be32(&buffer[8]);
 
1700
        lba = get_unaligned_be64(&buffer[0]);
 
1701
 
 
1702
        sd_read_protection_type(sdkp, buffer);
 
1703
 
 
1704
        if ((sizeof(sdkp->capacity) == 4) && (lba >= 0xffffffffULL)) {
 
1705
                sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use a "
 
1706
                        "kernel compiled with support for large block "
 
1707
                        "devices.\n");
 
1708
                sdkp->capacity = 0;
 
1709
                return -EOVERFLOW;
 
1710
        }
 
1711
 
 
1712
        /* Logical blocks per physical block exponent */
 
1713
        sdkp->physical_block_size = (1 << (buffer[13] & 0xf)) * sector_size;
 
1714
 
 
1715
        /* Lowest aligned logical block */
 
1716
        alignment = ((buffer[14] & 0x3f) << 8 | buffer[15]) * sector_size;
 
1717
        blk_queue_alignment_offset(sdp->request_queue, alignment);
 
1718
        if (alignment && sdkp->first_scan)
 
1719
                sd_printk(KERN_NOTICE, sdkp,
 
1720
                          "physical block alignment offset: %u\n", alignment);
 
1721
 
 
1722
        if (buffer[14] & 0x80) { /* LBPME */
 
1723
                sdkp->lbpme = 1;
 
1724
 
 
1725
                if (buffer[14] & 0x40) /* LBPRZ */
 
1726
                        sdkp->lbprz = 1;
 
1727
 
 
1728
                sd_config_discard(sdkp, SD_LBP_WS16);
 
1729
        }
 
1730
 
 
1731
        sdkp->capacity = lba + 1;
 
1732
        return sector_size;
 
1733
}
 
1734
 
 
1735
static int read_capacity_10(struct scsi_disk *sdkp, struct scsi_device *sdp,
 
1736
                                                unsigned char *buffer)
 
1737
{
 
1738
        unsigned char cmd[16];
 
1739
        struct scsi_sense_hdr sshdr;
 
1740
        int sense_valid = 0;
 
1741
        int the_result;
 
1742
        int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET;
 
1743
        sector_t lba;
 
1744
        unsigned sector_size;
 
1745
 
 
1746
        do {
 
1747
                cmd[0] = READ_CAPACITY;
 
1748
                memset(&cmd[1], 0, 9);
 
1749
                memset(buffer, 0, 8);
 
1750
 
 
1751
                the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE,
 
1752
                                        buffer, 8, &sshdr,
 
1753
                                        SD_TIMEOUT, SD_MAX_RETRIES, NULL);
 
1754
 
 
1755
                if (media_not_present(sdkp, &sshdr))
 
1756
                        return -ENODEV;
 
1757
 
 
1758
                if (the_result) {
 
1759
                        sense_valid = scsi_sense_valid(&sshdr);
 
1760
                        if (sense_valid &&
 
1761
                            sshdr.sense_key == UNIT_ATTENTION &&
 
1762
                            sshdr.asc == 0x29 && sshdr.ascq == 0x00)
 
1763
                                /* Device reset might occur several times,
 
1764
                                 * give it one more chance */
 
1765
                                if (--reset_retries > 0)
 
1766
                                        continue;
 
1767
                }
 
1768
                retries--;
 
1769
 
 
1770
        } while (the_result && retries);
 
1771
 
 
1772
        if (the_result) {
 
1773
                sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY failed\n");
 
1774
                read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result);
 
1775
                return -EINVAL;
 
1776
        }
 
1777
 
 
1778
        sector_size = get_unaligned_be32(&buffer[4]);
 
1779
        lba = get_unaligned_be32(&buffer[0]);
 
1780
 
 
1781
        if (sdp->no_read_capacity_16 && (lba == 0xffffffff)) {
 
1782
                /* Some buggy (usb cardreader) devices return an lba of
 
1783
                   0xffffffff when the want to report a size of 0 (with
 
1784
                   which they really mean no media is present) */
 
1785
                sdkp->capacity = 0;
 
1786
                sdkp->physical_block_size = sector_size;
 
1787
                return sector_size;
 
1788
        }
 
1789
 
 
1790
        if ((sizeof(sdkp->capacity) == 4) && (lba == 0xffffffff)) {
 
1791
                sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use a "
 
1792
                        "kernel compiled with support for large block "
 
1793
                        "devices.\n");
 
1794
                sdkp->capacity = 0;
 
1795
                return -EOVERFLOW;
 
1796
        }
 
1797
 
 
1798
        sdkp->capacity = lba + 1;
 
1799
        sdkp->physical_block_size = sector_size;
 
1800
        return sector_size;
 
1801
}
 
1802
 
 
1803
static int sd_try_rc16_first(struct scsi_device *sdp)
 
1804
{
 
1805
        if (sdp->host->max_cmd_len < 16)
 
1806
                return 0;
 
1807
        if (sdp->scsi_level > SCSI_SPC_2)
 
1808
                return 1;
 
1809
        if (scsi_device_protection(sdp))
 
1810
                return 1;
 
1811
        return 0;
 
1812
}
 
1813
 
 
1814
/*
 
1815
 * read disk capacity
 
1816
 */
 
1817
static void
 
1818
sd_read_capacity(struct scsi_disk *sdkp, unsigned char *buffer)
 
1819
{
 
1820
        int sector_size;
 
1821
        struct scsi_device *sdp = sdkp->device;
 
1822
        sector_t old_capacity = sdkp->capacity;
 
1823
 
 
1824
        if (sd_try_rc16_first(sdp)) {
 
1825
                sector_size = read_capacity_16(sdkp, sdp, buffer);
 
1826
                if (sector_size == -EOVERFLOW)
 
1827
                        goto got_data;
 
1828
                if (sector_size == -ENODEV)
 
1829
                        return;
 
1830
                if (sector_size < 0)
 
1831
                        sector_size = read_capacity_10(sdkp, sdp, buffer);
 
1832
                if (sector_size < 0)
 
1833
                        return;
 
1834
        } else {
 
1835
                sector_size = read_capacity_10(sdkp, sdp, buffer);
 
1836
                if (sector_size == -EOVERFLOW)
 
1837
                        goto got_data;
 
1838
                if (sector_size < 0)
 
1839
                        return;
 
1840
                if ((sizeof(sdkp->capacity) > 4) &&
 
1841
                    (sdkp->capacity > 0xffffffffULL)) {
 
1842
                        int old_sector_size = sector_size;
 
1843
                        sd_printk(KERN_NOTICE, sdkp, "Very big device. "
 
1844
                                        "Trying to use READ CAPACITY(16).\n");
 
1845
                        sector_size = read_capacity_16(sdkp, sdp, buffer);
 
1846
                        if (sector_size < 0) {
 
1847
                                sd_printk(KERN_NOTICE, sdkp,
 
1848
                                        "Using 0xffffffff as device size\n");
 
1849
                                sdkp->capacity = 1 + (sector_t) 0xffffffff;
 
1850
                                sector_size = old_sector_size;
 
1851
                                goto got_data;
 
1852
                        }
 
1853
                }
 
1854
        }
 
1855
 
 
1856
        /* Some devices are known to return the total number of blocks,
 
1857
         * not the highest block number.  Some devices have versions
 
1858
         * which do this and others which do not.  Some devices we might
 
1859
         * suspect of doing this but we don't know for certain.
 
1860
         *
 
1861
         * If we know the reported capacity is wrong, decrement it.  If
 
1862
         * we can only guess, then assume the number of blocks is even
 
1863
         * (usually true but not always) and err on the side of lowering
 
1864
         * the capacity.
 
1865
         */
 
1866
        if (sdp->fix_capacity ||
 
1867
            (sdp->guess_capacity && (sdkp->capacity & 0x01))) {
 
1868
                sd_printk(KERN_INFO, sdkp, "Adjusting the sector count "
 
1869
                                "from its reported value: %llu\n",
 
1870
                                (unsigned long long) sdkp->capacity);
 
1871
                --sdkp->capacity;
 
1872
        }
 
1873
 
 
1874
got_data:
 
1875
        if (sector_size == 0) {
 
1876
                sector_size = 512;
 
1877
                sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, "
 
1878
                          "assuming 512.\n");
 
1879
        }
 
1880
 
 
1881
        if (sector_size != 512 &&
 
1882
            sector_size != 1024 &&
 
1883
            sector_size != 2048 &&
 
1884
            sector_size != 4096 &&
 
1885
            sector_size != 256) {
 
1886
                sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n",
 
1887
                          sector_size);
 
1888
                /*
 
1889
                 * The user might want to re-format the drive with
 
1890
                 * a supported sectorsize.  Once this happens, it
 
1891
                 * would be relatively trivial to set the thing up.
 
1892
                 * For this reason, we leave the thing in the table.
 
1893
                 */
 
1894
                sdkp->capacity = 0;
 
1895
                /*
 
1896
                 * set a bogus sector size so the normal read/write
 
1897
                 * logic in the block layer will eventually refuse any
 
1898
                 * request on this device without tripping over power
 
1899
                 * of two sector size assumptions
 
1900
                 */
 
1901
                sector_size = 512;
 
1902
        }
 
1903
        blk_queue_logical_block_size(sdp->request_queue, sector_size);
 
1904
 
 
1905
        {
 
1906
                char cap_str_2[10], cap_str_10[10];
 
1907
                u64 sz = (u64)sdkp->capacity << ilog2(sector_size);
 
1908
 
 
1909
                string_get_size(sz, STRING_UNITS_2, cap_str_2,
 
1910
                                sizeof(cap_str_2));
 
1911
                string_get_size(sz, STRING_UNITS_10, cap_str_10,
 
1912
                                sizeof(cap_str_10));
 
1913
 
 
1914
                if (sdkp->first_scan || old_capacity != sdkp->capacity) {
 
1915
                        sd_printk(KERN_NOTICE, sdkp,
 
1916
                                  "%llu %d-byte logical blocks: (%s/%s)\n",
 
1917
                                  (unsigned long long)sdkp->capacity,
 
1918
                                  sector_size, cap_str_10, cap_str_2);
 
1919
 
 
1920
                        if (sdkp->physical_block_size != sector_size)
 
1921
                                sd_printk(KERN_NOTICE, sdkp,
 
1922
                                          "%u-byte physical blocks\n",
 
1923
                                          sdkp->physical_block_size);
 
1924
                }
 
1925
        }
 
1926
 
 
1927
        /* Rescale capacity to 512-byte units */
 
1928
        if (sector_size == 4096)
 
1929
                sdkp->capacity <<= 3;
 
1930
        else if (sector_size == 2048)
 
1931
                sdkp->capacity <<= 2;
 
1932
        else if (sector_size == 1024)
 
1933
                sdkp->capacity <<= 1;
 
1934
        else if (sector_size == 256)
 
1935
                sdkp->capacity >>= 1;
 
1936
 
 
1937
        blk_queue_physical_block_size(sdp->request_queue,
 
1938
                                      sdkp->physical_block_size);
 
1939
        sdkp->device->sector_size = sector_size;
 
1940
}
 
1941
 
 
1942
/* called with buffer of length 512 */
 
1943
static inline int
 
1944
sd_do_mode_sense(struct scsi_device *sdp, int dbd, int modepage,
 
1945
                 unsigned char *buffer, int len, struct scsi_mode_data *data,
 
1946
                 struct scsi_sense_hdr *sshdr)
 
1947
{
 
1948
        return scsi_mode_sense(sdp, dbd, modepage, buffer, len,
 
1949
                               SD_TIMEOUT, SD_MAX_RETRIES, data,
 
1950
                               sshdr);
 
1951
}
 
1952
 
 
1953
/*
 
1954
 * read write protect setting, if possible - called only in sd_revalidate_disk()
 
1955
 * called with buffer of length SD_BUF_SIZE
 
1956
 */
 
1957
static void
 
1958
sd_read_write_protect_flag(struct scsi_disk *sdkp, unsigned char *buffer)
 
1959
{
 
1960
        int res;
 
1961
        struct scsi_device *sdp = sdkp->device;
 
1962
        struct scsi_mode_data data;
 
1963
        int old_wp = sdkp->write_prot;
 
1964
 
 
1965
        set_disk_ro(sdkp->disk, 0);
 
1966
        if (sdp->skip_ms_page_3f) {
 
1967
                sd_printk(KERN_NOTICE, sdkp, "Assuming Write Enabled\n");
 
1968
                return;
 
1969
        }
 
1970
 
 
1971
        if (sdp->use_192_bytes_for_3f) {
 
1972
                res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 192, &data, NULL);
 
1973
        } else {
 
1974
                /*
 
1975
                 * First attempt: ask for all pages (0x3F), but only 4 bytes.
 
1976
                 * We have to start carefully: some devices hang if we ask
 
1977
                 * for more than is available.
 
1978
                 */
 
1979
                res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 4, &data, NULL);
 
1980
 
 
1981
                /*
 
1982
                 * Second attempt: ask for page 0 When only page 0 is
 
1983
                 * implemented, a request for page 3F may return Sense Key
 
1984
                 * 5: Illegal Request, Sense Code 24: Invalid field in
 
1985
                 * CDB.
 
1986
                 */
 
1987
                if (!scsi_status_is_good(res))
 
1988
                        res = sd_do_mode_sense(sdp, 0, 0, buffer, 4, &data, NULL);
 
1989
 
 
1990
                /*
 
1991
                 * Third attempt: ask 255 bytes, as we did earlier.
 
1992
                 */
 
1993
                if (!scsi_status_is_good(res))
 
1994
                        res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 255,
 
1995
                                               &data, NULL);
 
1996
        }
 
1997
 
 
1998
        if (!scsi_status_is_good(res)) {
 
1999
                sd_printk(KERN_WARNING, sdkp,
 
2000
                          "Test WP failed, assume Write Enabled\n");
 
2001
        } else {
 
2002
                sdkp->write_prot = ((data.device_specific & 0x80) != 0);
 
2003
                set_disk_ro(sdkp->disk, sdkp->write_prot);
 
2004
                if (sdkp->first_scan || old_wp != sdkp->write_prot) {
 
2005
                        sd_printk(KERN_NOTICE, sdkp, "Write Protect is %s\n",
 
2006
                                  sdkp->write_prot ? "on" : "off");
 
2007
                        sd_printk(KERN_DEBUG, sdkp,
 
2008
                                  "Mode Sense: %02x %02x %02x %02x\n",
 
2009
                                  buffer[0], buffer[1], buffer[2], buffer[3]);
 
2010
                }
 
2011
        }
 
2012
}
 
2013
 
 
2014
/*
 
2015
 * sd_read_cache_type - called only from sd_revalidate_disk()
 
2016
 * called with buffer of length SD_BUF_SIZE
 
2017
 */
 
2018
static void
 
2019
sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
 
2020
{
 
2021
        int len = 0, res;
 
2022
        struct scsi_device *sdp = sdkp->device;
 
2023
 
 
2024
        int dbd;
 
2025
        int modepage;
 
2026
        int first_len;
 
2027
        struct scsi_mode_data data;
 
2028
        struct scsi_sense_hdr sshdr;
 
2029
        int old_wce = sdkp->WCE;
 
2030
        int old_rcd = sdkp->RCD;
 
2031
        int old_dpofua = sdkp->DPOFUA;
 
2032
 
 
2033
        first_len = 4;
 
2034
        if (sdp->skip_ms_page_8) {
 
2035
                if (sdp->type == TYPE_RBC)
 
2036
                        goto defaults;
 
2037
                else {
 
2038
                        if (sdp->skip_ms_page_3f)
 
2039
                                goto defaults;
 
2040
                        modepage = 0x3F;
 
2041
                        if (sdp->use_192_bytes_for_3f)
 
2042
                                first_len = 192;
 
2043
                        dbd = 0;
 
2044
                }
 
2045
        } else if (sdp->type == TYPE_RBC) {
 
2046
                modepage = 6;
 
2047
                dbd = 8;
 
2048
        } else {
 
2049
                modepage = 8;
 
2050
                dbd = 0;
 
2051
        }
 
2052
 
 
2053
        /* cautiously ask */
 
2054
        res = sd_do_mode_sense(sdp, dbd, modepage, buffer, first_len,
 
2055
                        &data, &sshdr);
 
2056
 
 
2057
        if (!scsi_status_is_good(res))
 
2058
                goto bad_sense;
 
2059
 
 
2060
        if (!data.header_length) {
 
2061
                modepage = 6;
 
2062
                first_len = 0;
 
2063
                sd_printk(KERN_ERR, sdkp, "Missing header in MODE_SENSE response\n");
 
2064
        }
 
2065
 
 
2066
        /* that went OK, now ask for the proper length */
 
2067
        len = data.length;
 
2068
 
 
2069
        /*
 
2070
         * We're only interested in the first three bytes, actually.
 
2071
         * But the data cache page is defined for the first 20.
 
2072
         */
 
2073
        if (len < 3)
 
2074
                goto bad_sense;
 
2075
        else if (len > SD_BUF_SIZE) {
 
2076
                sd_printk(KERN_NOTICE, sdkp, "Truncating mode parameter "
 
2077
                          "data from %d to %d bytes\n", len, SD_BUF_SIZE);
 
2078
                len = SD_BUF_SIZE;
 
2079
        }
 
2080
        if (modepage == 0x3F && sdp->use_192_bytes_for_3f)
 
2081
                len = 192;
 
2082
 
 
2083
        /* Get the data */
 
2084
        if (len > first_len)
 
2085
                res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len,
 
2086
                                &data, &sshdr);
 
2087
 
 
2088
        if (scsi_status_is_good(res)) {
 
2089
                int offset = data.header_length + data.block_descriptor_length;
 
2090
 
 
2091
                while (offset < len) {
 
2092
                        u8 page_code = buffer[offset] & 0x3F;
 
2093
                        u8 spf       = buffer[offset] & 0x40;
 
2094
 
 
2095
                        if (page_code == 8 || page_code == 6) {
 
2096
                                /* We're interested only in the first 3 bytes.
 
2097
                                 */
 
2098
                                if (len - offset <= 2) {
 
2099
                                        sd_printk(KERN_ERR, sdkp, "Incomplete "
 
2100
                                                  "mode parameter data\n");
 
2101
                                        goto defaults;
 
2102
                                } else {
 
2103
                                        modepage = page_code;
 
2104
                                        goto Page_found;
 
2105
                                }
 
2106
                        } else {
 
2107
                                /* Go to the next page */
 
2108
                                if (spf && len - offset > 3)
 
2109
                                        offset += 4 + (buffer[offset+2] << 8) +
 
2110
                                                buffer[offset+3];
 
2111
                                else if (!spf && len - offset > 1)
 
2112
                                        offset += 2 + buffer[offset+1];
 
2113
                                else {
 
2114
                                        sd_printk(KERN_ERR, sdkp, "Incomplete "
 
2115
                                                  "mode parameter data\n");
 
2116
                                        goto defaults;
 
2117
                                }
 
2118
                        }
 
2119
                }
 
2120
 
 
2121
                if (modepage == 0x3F) {
 
2122
                        sd_printk(KERN_ERR, sdkp, "No Caching mode page "
 
2123
                                  "present\n");
 
2124
                        goto defaults;
 
2125
                } else if ((buffer[offset] & 0x3f) != modepage) {
 
2126
                        sd_printk(KERN_ERR, sdkp, "Got wrong page\n");
 
2127
                        goto defaults;
 
2128
                }
 
2129
        Page_found:
 
2130
                if (modepage == 8) {
 
2131
                        sdkp->WCE = ((buffer[offset + 2] & 0x04) != 0);
 
2132
                        sdkp->RCD = ((buffer[offset + 2] & 0x01) != 0);
 
2133
                } else {
 
2134
                        sdkp->WCE = ((buffer[offset + 2] & 0x01) == 0);
 
2135
                        sdkp->RCD = 0;
 
2136
                }
 
2137
 
 
2138
                sdkp->DPOFUA = (data.device_specific & 0x10) != 0;
 
2139
                if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw) {
 
2140
                        sd_printk(KERN_NOTICE, sdkp,
 
2141
                                  "Uses READ/WRITE(6), disabling FUA\n");
 
2142
                        sdkp->DPOFUA = 0;
 
2143
                }
 
2144
 
 
2145
                if (sdkp->first_scan || old_wce != sdkp->WCE ||
 
2146
                    old_rcd != sdkp->RCD || old_dpofua != sdkp->DPOFUA)
 
2147
                        sd_printk(KERN_NOTICE, sdkp,
 
2148
                                  "Write cache: %s, read cache: %s, %s\n",
 
2149
                                  sdkp->WCE ? "enabled" : "disabled",
 
2150
                                  sdkp->RCD ? "disabled" : "enabled",
 
2151
                                  sdkp->DPOFUA ? "supports DPO and FUA"
 
2152
                                  : "doesn't support DPO or FUA");
 
2153
 
 
2154
                return;
 
2155
        }
 
2156
 
 
2157
bad_sense:
 
2158
        if (scsi_sense_valid(&sshdr) &&
 
2159
            sshdr.sense_key == ILLEGAL_REQUEST &&
 
2160
            sshdr.asc == 0x24 && sshdr.ascq == 0x0)
 
2161
                /* Invalid field in CDB */
 
2162
                sd_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n");
 
2163
        else
 
2164
                sd_printk(KERN_ERR, sdkp, "Asking for cache data failed\n");
 
2165
 
 
2166
defaults:
 
2167
        sd_printk(KERN_ERR, sdkp, "Assuming drive cache: write through\n");
 
2168
        sdkp->WCE = 0;
 
2169
        sdkp->RCD = 0;
 
2170
        sdkp->DPOFUA = 0;
 
2171
}
 
2172
 
 
2173
/*
 
2174
 * The ATO bit indicates whether the DIF application tag is available
 
2175
 * for use by the operating system.
 
2176
 */
 
2177
static void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer)
 
2178
{
 
2179
        int res, offset;
 
2180
        struct scsi_device *sdp = sdkp->device;
 
2181
        struct scsi_mode_data data;
 
2182
        struct scsi_sense_hdr sshdr;
 
2183
 
 
2184
        if (sdp->type != TYPE_DISK)
 
2185
                return;
 
2186
 
 
2187
        if (sdkp->protection_type == 0)
 
2188
                return;
 
2189
 
 
2190
        res = scsi_mode_sense(sdp, 1, 0x0a, buffer, 36, SD_TIMEOUT,
 
2191
                              SD_MAX_RETRIES, &data, &sshdr);
 
2192
 
 
2193
        if (!scsi_status_is_good(res) || !data.header_length ||
 
2194
            data.length < 6) {
 
2195
                sd_printk(KERN_WARNING, sdkp,
 
2196
                          "getting Control mode page failed, assume no ATO\n");
 
2197
 
 
2198
                if (scsi_sense_valid(&sshdr))
 
2199
                        sd_print_sense_hdr(sdkp, &sshdr);
 
2200
 
 
2201
                return;
 
2202
        }
 
2203
 
 
2204
        offset = data.header_length + data.block_descriptor_length;
 
2205
 
 
2206
        if ((buffer[offset] & 0x3f) != 0x0a) {
 
2207
                sd_printk(KERN_ERR, sdkp, "ATO Got wrong page\n");
 
2208
                return;
 
2209
        }
 
2210
 
 
2211
        if ((buffer[offset + 5] & 0x80) == 0)
 
2212
                return;
 
2213
 
 
2214
        sdkp->ATO = 1;
 
2215
 
 
2216
        return;
 
2217
}
 
2218
 
 
2219
/**
 
2220
 * sd_read_block_limits - Query disk device for preferred I/O sizes.
 
2221
 * @disk: disk to query
 
2222
 */
 
2223
static void sd_read_block_limits(struct scsi_disk *sdkp)
 
2224
{
 
2225
        unsigned int sector_sz = sdkp->device->sector_size;
 
2226
        const int vpd_len = 64;
 
2227
        unsigned char *buffer = kmalloc(vpd_len, GFP_KERNEL);
 
2228
 
 
2229
        if (!buffer ||
 
2230
            /* Block Limits VPD */
 
2231
            scsi_get_vpd_page(sdkp->device, 0xb0, buffer, vpd_len))
 
2232
                goto out;
 
2233
 
 
2234
        blk_queue_io_min(sdkp->disk->queue,
 
2235
                         get_unaligned_be16(&buffer[6]) * sector_sz);
 
2236
        blk_queue_io_opt(sdkp->disk->queue,
 
2237
                         get_unaligned_be32(&buffer[12]) * sector_sz);
 
2238
 
 
2239
        if (buffer[3] == 0x3c) {
 
2240
                unsigned int lba_count, desc_count;
 
2241
 
 
2242
                sdkp->max_ws_blocks =
 
2243
                        (u32) min_not_zero(get_unaligned_be64(&buffer[36]),
 
2244
                                           (u64)0xffffffff);
 
2245
 
 
2246
                if (!sdkp->lbpme)
 
2247
                        goto out;
 
2248
 
 
2249
                lba_count = get_unaligned_be32(&buffer[20]);
 
2250
                desc_count = get_unaligned_be32(&buffer[24]);
 
2251
 
 
2252
                if (lba_count && desc_count)
 
2253
                        sdkp->max_unmap_blocks = lba_count;
 
2254
 
 
2255
                sdkp->unmap_granularity = get_unaligned_be32(&buffer[28]);
 
2256
 
 
2257
                if (buffer[32] & 0x80)
 
2258
                        sdkp->unmap_alignment =
 
2259
                                get_unaligned_be32(&buffer[32]) & ~(1 << 31);
 
2260
 
 
2261
                if (!sdkp->lbpvpd) { /* LBP VPD page not provided */
 
2262
 
 
2263
                        if (sdkp->max_unmap_blocks)
 
2264
                                sd_config_discard(sdkp, SD_LBP_UNMAP);
 
2265
                        else
 
2266
                                sd_config_discard(sdkp, SD_LBP_WS16);
 
2267
 
 
2268
                } else {        /* LBP VPD page tells us what to use */
 
2269
 
 
2270
                        if (sdkp->lbpu && sdkp->max_unmap_blocks)
 
2271
                                sd_config_discard(sdkp, SD_LBP_UNMAP);
 
2272
                        else if (sdkp->lbpws)
 
2273
                                sd_config_discard(sdkp, SD_LBP_WS16);
 
2274
                        else if (sdkp->lbpws10)
 
2275
                                sd_config_discard(sdkp, SD_LBP_WS10);
 
2276
                        else
 
2277
                                sd_config_discard(sdkp, SD_LBP_DISABLE);
 
2278
                }
 
2279
        }
 
2280
 
 
2281
 out:
 
2282
        kfree(buffer);
 
2283
}
 
2284
 
 
2285
/**
 
2286
 * sd_read_block_characteristics - Query block dev. characteristics
 
2287
 * @disk: disk to query
 
2288
 */
 
2289
static void sd_read_block_characteristics(struct scsi_disk *sdkp)
 
2290
{
 
2291
        unsigned char *buffer;
 
2292
        u16 rot;
 
2293
        const int vpd_len = 64;
 
2294
 
 
2295
        buffer = kmalloc(vpd_len, GFP_KERNEL);
 
2296
 
 
2297
        if (!buffer ||
 
2298
            /* Block Device Characteristics VPD */
 
2299
            scsi_get_vpd_page(sdkp->device, 0xb1, buffer, vpd_len))
 
2300
                goto out;
 
2301
 
 
2302
        rot = get_unaligned_be16(&buffer[4]);
 
2303
 
 
2304
        if (rot == 1)
 
2305
                queue_flag_set_unlocked(QUEUE_FLAG_NONROT, sdkp->disk->queue);
 
2306
 
 
2307
 out:
 
2308
        kfree(buffer);
 
2309
}
 
2310
 
 
2311
/**
 
2312
 * sd_read_block_provisioning - Query provisioning VPD page
 
2313
 * @disk: disk to query
 
2314
 */
 
2315
static void sd_read_block_provisioning(struct scsi_disk *sdkp)
 
2316
{
 
2317
        unsigned char *buffer;
 
2318
        const int vpd_len = 8;
 
2319
 
 
2320
        if (sdkp->lbpme == 0)
 
2321
                return;
 
2322
 
 
2323
        buffer = kmalloc(vpd_len, GFP_KERNEL);
 
2324
 
 
2325
        if (!buffer || scsi_get_vpd_page(sdkp->device, 0xb2, buffer, vpd_len))
 
2326
                goto out;
 
2327
 
 
2328
        sdkp->lbpvpd    = 1;
 
2329
        sdkp->lbpu      = (buffer[5] >> 7) & 1; /* UNMAP */
 
2330
        sdkp->lbpws     = (buffer[5] >> 6) & 1; /* WRITE SAME(16) with UNMAP */
 
2331
        sdkp->lbpws10   = (buffer[5] >> 5) & 1; /* WRITE SAME(10) with UNMAP */
 
2332
 
 
2333
 out:
 
2334
        kfree(buffer);
 
2335
}
 
2336
 
 
2337
static int sd_try_extended_inquiry(struct scsi_device *sdp)
 
2338
{
 
2339
        /*
 
2340
         * Although VPD inquiries can go to SCSI-2 type devices,
 
2341
         * some USB ones crash on receiving them, and the pages
 
2342
         * we currently ask for are for SPC-3 and beyond
 
2343
         */
 
2344
        if (sdp->scsi_level > SCSI_SPC_2)
 
2345
                return 1;
 
2346
        return 0;
 
2347
}
 
2348
 
 
2349
/**
 
2350
 *      sd_revalidate_disk - called the first time a new disk is seen,
 
2351
 *      performs disk spin up, read_capacity, etc.
 
2352
 *      @disk: struct gendisk we care about
 
2353
 **/
 
2354
static int sd_revalidate_disk(struct gendisk *disk)
 
2355
{
 
2356
        struct scsi_disk *sdkp = scsi_disk(disk);
 
2357
        struct scsi_device *sdp = sdkp->device;
 
2358
        unsigned char *buffer;
 
2359
        unsigned flush = 0;
 
2360
 
 
2361
        SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp,
 
2362
                                      "sd_revalidate_disk\n"));
 
2363
 
 
2364
        /*
 
2365
         * If the device is offline, don't try and read capacity or any
 
2366
         * of the other niceties.
 
2367
         */
 
2368
        if (!scsi_device_online(sdp))
 
2369
                goto out;
 
2370
 
 
2371
        buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL);
 
2372
        if (!buffer) {
 
2373
                sd_printk(KERN_WARNING, sdkp, "sd_revalidate_disk: Memory "
 
2374
                          "allocation failure.\n");
 
2375
                goto out;
 
2376
        }
 
2377
 
 
2378
        sd_spinup_disk(sdkp);
 
2379
 
 
2380
        /*
 
2381
         * Without media there is no reason to ask; moreover, some devices
 
2382
         * react badly if we do.
 
2383
         */
 
2384
        if (sdkp->media_present) {
 
2385
                sd_read_capacity(sdkp, buffer);
 
2386
 
 
2387
                if (sd_try_extended_inquiry(sdp)) {
 
2388
                        sd_read_block_provisioning(sdkp);
 
2389
                        sd_read_block_limits(sdkp);
 
2390
                        sd_read_block_characteristics(sdkp);
 
2391
                }
 
2392
 
 
2393
                sd_read_write_protect_flag(sdkp, buffer);
 
2394
                sd_read_cache_type(sdkp, buffer);
 
2395
                sd_read_app_tag_own(sdkp, buffer);
 
2396
        }
 
2397
 
 
2398
        sdkp->first_scan = 0;
 
2399
 
 
2400
        /*
 
2401
         * We now have all cache related info, determine how we deal
 
2402
         * with flush requests.
 
2403
         */
 
2404
        if (sdkp->WCE) {
 
2405
                flush |= REQ_FLUSH;
 
2406
                if (sdkp->DPOFUA)
 
2407
                        flush |= REQ_FUA;
 
2408
        }
 
2409
 
 
2410
        blk_queue_flush(sdkp->disk->queue, flush);
 
2411
 
 
2412
        set_capacity(disk, sdkp->capacity);
 
2413
        kfree(buffer);
 
2414
 
 
2415
 out:
 
2416
        return 0;
 
2417
}
 
2418
 
 
2419
/**
 
2420
 *      sd_unlock_native_capacity - unlock native capacity
 
2421
 *      @disk: struct gendisk to set capacity for
 
2422
 *
 
2423
 *      Block layer calls this function if it detects that partitions
 
2424
 *      on @disk reach beyond the end of the device.  If the SCSI host
 
2425
 *      implements ->unlock_native_capacity() method, it's invoked to
 
2426
 *      give it a chance to adjust the device capacity.
 
2427
 *
 
2428
 *      CONTEXT:
 
2429
 *      Defined by block layer.  Might sleep.
 
2430
 */
 
2431
static void sd_unlock_native_capacity(struct gendisk *disk)
 
2432
{
 
2433
        struct scsi_device *sdev = scsi_disk(disk)->device;
 
2434
 
 
2435
        if (sdev->host->hostt->unlock_native_capacity)
 
2436
                sdev->host->hostt->unlock_native_capacity(sdev);
 
2437
}
 
2438
 
 
2439
/**
 
2440
 *      sd_format_disk_name - format disk name
 
2441
 *      @prefix: name prefix - ie. "sd" for SCSI disks
 
2442
 *      @index: index of the disk to format name for
 
2443
 *      @buf: output buffer
 
2444
 *      @buflen: length of the output buffer
 
2445
 *
 
2446
 *      SCSI disk names starts at sda.  The 26th device is sdz and the
 
2447
 *      27th is sdaa.  The last one for two lettered suffix is sdzz
 
2448
 *      which is followed by sdaaa.
 
2449
 *
 
2450
 *      This is basically 26 base counting with one extra 'nil' entry
 
2451
 *      at the beginning from the second digit on and can be
 
2452
 *      determined using similar method as 26 base conversion with the
 
2453
 *      index shifted -1 after each digit is computed.
 
2454
 *
 
2455
 *      CONTEXT:
 
2456
 *      Don't care.
 
2457
 *
 
2458
 *      RETURNS:
 
2459
 *      0 on success, -errno on failure.
 
2460
 */
 
2461
static int sd_format_disk_name(char *prefix, int index, char *buf, int buflen)
 
2462
{
 
2463
        const int base = 'z' - 'a' + 1;
 
2464
        char *begin = buf + strlen(prefix);
 
2465
        char *end = buf + buflen;
 
2466
        char *p;
 
2467
        int unit;
 
2468
 
 
2469
        p = end - 1;
 
2470
        *p = '\0';
 
2471
        unit = base;
 
2472
        do {
 
2473
                if (p == begin)
 
2474
                        return -EINVAL;
 
2475
                *--p = 'a' + (index % unit);
 
2476
                index = (index / unit) - 1;
 
2477
        } while (index >= 0);
 
2478
 
 
2479
        memmove(begin, p, end - p);
 
2480
        memcpy(buf, prefix, strlen(prefix));
 
2481
 
 
2482
        return 0;
 
2483
}
 
2484
 
 
2485
/*
 
2486
 * The asynchronous part of sd_probe
 
2487
 */
 
2488
static void sd_probe_async(void *data, async_cookie_t cookie)
 
2489
{
 
2490
        struct scsi_disk *sdkp = data;
 
2491
        struct scsi_device *sdp;
 
2492
        struct gendisk *gd;
 
2493
        u32 index;
 
2494
        struct device *dev;
 
2495
 
 
2496
        sdp = sdkp->device;
 
2497
        gd = sdkp->disk;
 
2498
        index = sdkp->index;
 
2499
        dev = &sdp->sdev_gendev;
 
2500
 
 
2501
        gd->major = sd_major((index & 0xf0) >> 4);
 
2502
        gd->first_minor = ((index & 0xf) << 4) | (index & 0xfff00);
 
2503
        gd->minors = SD_MINORS;
 
2504
 
 
2505
        gd->fops = &sd_fops;
 
2506
        gd->private_data = &sdkp->driver;
 
2507
        gd->queue = sdkp->device->request_queue;
 
2508
 
 
2509
        /* defaults, until the device tells us otherwise */
 
2510
        sdp->sector_size = 512;
 
2511
        sdkp->capacity = 0;
 
2512
        sdkp->media_present = 1;
 
2513
        sdkp->write_prot = 0;
 
2514
        sdkp->WCE = 0;
 
2515
        sdkp->RCD = 0;
 
2516
        sdkp->ATO = 0;
 
2517
        sdkp->first_scan = 1;
 
2518
 
 
2519
        sd_revalidate_disk(gd);
 
2520
 
 
2521
        blk_queue_prep_rq(sdp->request_queue, sd_prep_fn);
 
2522
        blk_queue_unprep_rq(sdp->request_queue, sd_unprep_fn);
 
2523
 
 
2524
        gd->driverfs_dev = &sdp->sdev_gendev;
 
2525
        gd->flags = GENHD_FL_EXT_DEVT;
 
2526
        if (sdp->removable) {
 
2527
                gd->flags |= GENHD_FL_REMOVABLE;
 
2528
                gd->events |= DISK_EVENT_MEDIA_CHANGE;
 
2529
        }
 
2530
 
 
2531
        add_disk(gd);
 
2532
        sd_dif_config_host(sdkp);
 
2533
 
 
2534
        sd_revalidate_disk(gd);
 
2535
 
 
2536
        sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n",
 
2537
                  sdp->removable ? "removable " : "");
 
2538
        scsi_autopm_put_device(sdp);
 
2539
        put_device(&sdkp->dev);
 
2540
}
 
2541
 
 
2542
/**
 
2543
 *      sd_probe - called during driver initialization and whenever a
 
2544
 *      new scsi device is attached to the system. It is called once
 
2545
 *      for each scsi device (not just disks) present.
 
2546
 *      @dev: pointer to device object
 
2547
 *
 
2548
 *      Returns 0 if successful (or not interested in this scsi device 
 
2549
 *      (e.g. scanner)); 1 when there is an error.
 
2550
 *
 
2551
 *      Note: this function is invoked from the scsi mid-level.
 
2552
 *      This function sets up the mapping between a given 
 
2553
 *      <host,channel,id,lun> (found in sdp) and new device name 
 
2554
 *      (e.g. /dev/sda). More precisely it is the block device major 
 
2555
 *      and minor number that is chosen here.
 
2556
 *
 
2557
 *      Assume sd_attach is not re-entrant (for time being)
 
2558
 *      Also think about sd_attach() and sd_remove() running coincidentally.
 
2559
 **/
 
2560
static int sd_probe(struct device *dev)
 
2561
{
 
2562
        struct scsi_device *sdp = to_scsi_device(dev);
 
2563
        struct scsi_disk *sdkp;
 
2564
        struct gendisk *gd;
 
2565
        int index;
 
2566
        int error;
 
2567
 
 
2568
        error = -ENODEV;
 
2569
        if (sdp->type != TYPE_DISK && sdp->type != TYPE_MOD && sdp->type != TYPE_RBC)
 
2570
                goto out;
 
2571
 
 
2572
        SCSI_LOG_HLQUEUE(3, sdev_printk(KERN_INFO, sdp,
 
2573
                                        "sd_attach\n"));
 
2574
 
 
2575
        error = -ENOMEM;
 
2576
        sdkp = kzalloc(sizeof(*sdkp), GFP_KERNEL);
 
2577
        if (!sdkp)
 
2578
                goto out;
 
2579
 
 
2580
        gd = alloc_disk(SD_MINORS);
 
2581
        if (!gd)
 
2582
                goto out_free;
 
2583
 
 
2584
        do {
 
2585
                if (!ida_pre_get(&sd_index_ida, GFP_KERNEL))
 
2586
                        goto out_put;
 
2587
 
 
2588
                spin_lock(&sd_index_lock);
 
2589
                error = ida_get_new(&sd_index_ida, &index);
 
2590
                spin_unlock(&sd_index_lock);
 
2591
        } while (error == -EAGAIN);
 
2592
 
 
2593
        if (error) {
 
2594
                sdev_printk(KERN_WARNING, sdp, "sd_probe: memory exhausted.\n");
 
2595
                goto out_put;
 
2596
        }
 
2597
 
 
2598
        error = sd_format_disk_name("sd", index, gd->disk_name, DISK_NAME_LEN);
 
2599
        if (error) {
 
2600
                sdev_printk(KERN_WARNING, sdp, "SCSI disk (sd) name length exceeded.\n");
 
2601
                goto out_free_index;
 
2602
        }
 
2603
 
 
2604
        sdkp->device = sdp;
 
2605
        sdkp->driver = &sd_template;
 
2606
        sdkp->disk = gd;
 
2607
        sdkp->index = index;
 
2608
        atomic_set(&sdkp->openers, 0);
 
2609
 
 
2610
        if (!sdp->request_queue->rq_timeout) {
 
2611
                if (sdp->type != TYPE_MOD)
 
2612
                        blk_queue_rq_timeout(sdp->request_queue, SD_TIMEOUT);
 
2613
                else
 
2614
                        blk_queue_rq_timeout(sdp->request_queue,
 
2615
                                             SD_MOD_TIMEOUT);
 
2616
        }
 
2617
 
 
2618
        device_initialize(&sdkp->dev);
 
2619
        sdkp->dev.parent = dev;
 
2620
        sdkp->dev.class = &sd_disk_class;
 
2621
        dev_set_name(&sdkp->dev, dev_name(dev));
 
2622
 
 
2623
        if (device_add(&sdkp->dev))
 
2624
                goto out_free_index;
 
2625
 
 
2626
        get_device(dev);
 
2627
        dev_set_drvdata(dev, sdkp);
 
2628
 
 
2629
        get_device(&sdkp->dev); /* prevent release before async_schedule */
 
2630
        async_schedule(sd_probe_async, sdkp);
 
2631
 
 
2632
        return 0;
 
2633
 
 
2634
 out_free_index:
 
2635
        spin_lock(&sd_index_lock);
 
2636
        ida_remove(&sd_index_ida, index);
 
2637
        spin_unlock(&sd_index_lock);
 
2638
 out_put:
 
2639
        put_disk(gd);
 
2640
 out_free:
 
2641
        kfree(sdkp);
 
2642
 out:
 
2643
        return error;
 
2644
}
 
2645
 
 
2646
/**
 
2647
 *      sd_remove - called whenever a scsi disk (previously recognized by
 
2648
 *      sd_probe) is detached from the system. It is called (potentially
 
2649
 *      multiple times) during sd module unload.
 
2650
 *      @sdp: pointer to mid level scsi device object
 
2651
 *
 
2652
 *      Note: this function is invoked from the scsi mid-level.
 
2653
 *      This function potentially frees up a device name (e.g. /dev/sdc)
 
2654
 *      that could be re-used by a subsequent sd_probe().
 
2655
 *      This function is not called when the built-in sd driver is "exit-ed".
 
2656
 **/
 
2657
static int sd_remove(struct device *dev)
 
2658
{
 
2659
        struct scsi_disk *sdkp;
 
2660
 
 
2661
        sdkp = dev_get_drvdata(dev);
 
2662
        scsi_autopm_get_device(sdkp->device);
 
2663
 
 
2664
        async_synchronize_full();
 
2665
        blk_queue_prep_rq(sdkp->device->request_queue, scsi_prep_fn);
 
2666
        blk_queue_unprep_rq(sdkp->device->request_queue, NULL);
 
2667
        device_del(&sdkp->dev);
 
2668
        del_gendisk(sdkp->disk);
 
2669
        sd_shutdown(dev);
 
2670
 
 
2671
        mutex_lock(&sd_ref_mutex);
 
2672
        dev_set_drvdata(dev, NULL);
 
2673
        put_device(&sdkp->dev);
 
2674
        mutex_unlock(&sd_ref_mutex);
 
2675
 
 
2676
        return 0;
 
2677
}
 
2678
 
 
2679
/**
 
2680
 *      scsi_disk_release - Called to free the scsi_disk structure
 
2681
 *      @dev: pointer to embedded class device
 
2682
 *
 
2683
 *      sd_ref_mutex must be held entering this routine.  Because it is
 
2684
 *      called on last put, you should always use the scsi_disk_get()
 
2685
 *      scsi_disk_put() helpers which manipulate the semaphore directly
 
2686
 *      and never do a direct put_device.
 
2687
 **/
 
2688
static void scsi_disk_release(struct device *dev)
 
2689
{
 
2690
        struct scsi_disk *sdkp = to_scsi_disk(dev);
 
2691
        struct gendisk *disk = sdkp->disk;
 
2692
        
 
2693
        spin_lock(&sd_index_lock);
 
2694
        ida_remove(&sd_index_ida, sdkp->index);
 
2695
        spin_unlock(&sd_index_lock);
 
2696
 
 
2697
        disk->private_data = NULL;
 
2698
        put_disk(disk);
 
2699
        put_device(&sdkp->device->sdev_gendev);
 
2700
 
 
2701
        kfree(sdkp);
 
2702
}
 
2703
 
 
2704
static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
 
2705
{
 
2706
        unsigned char cmd[6] = { START_STOP };  /* START_VALID */
 
2707
        struct scsi_sense_hdr sshdr;
 
2708
        struct scsi_device *sdp = sdkp->device;
 
2709
        int res;
 
2710
 
 
2711
        if (start)
 
2712
                cmd[4] |= 1;    /* START */
 
2713
 
 
2714
        if (sdp->start_stop_pwr_cond)
 
2715
                cmd[4] |= start ? 1 << 4 : 3 << 4;      /* Active or Standby */
 
2716
 
 
2717
        if (!scsi_device_online(sdp))
 
2718
                return -ENODEV;
 
2719
 
 
2720
        res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
 
2721
                               SD_TIMEOUT, SD_MAX_RETRIES, NULL);
 
2722
        if (res) {
 
2723
                sd_printk(KERN_WARNING, sdkp, "START_STOP FAILED\n");
 
2724
                sd_print_result(sdkp, res);
 
2725
                if (driver_byte(res) & DRIVER_SENSE)
 
2726
                        sd_print_sense_hdr(sdkp, &sshdr);
 
2727
        }
 
2728
 
 
2729
        return res;
 
2730
}
 
2731
 
 
2732
/*
 
2733
 * Send a SYNCHRONIZE CACHE instruction down to the device through
 
2734
 * the normal SCSI command structure.  Wait for the command to
 
2735
 * complete.
 
2736
 */
 
2737
static void sd_shutdown(struct device *dev)
 
2738
{
 
2739
        struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
 
2740
 
 
2741
        if (!sdkp)
 
2742
                return;         /* this can happen */
 
2743
 
 
2744
        if (sdkp->WCE) {
 
2745
                sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
 
2746
                sd_sync_cache(sdkp);
 
2747
        }
 
2748
 
 
2749
        if (system_state != SYSTEM_RESTART && sdkp->device->manage_start_stop) {
 
2750
                sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
 
2751
                sd_start_stop_device(sdkp, 0);
 
2752
        }
 
2753
 
 
2754
        scsi_disk_put(sdkp);
 
2755
}
 
2756
 
 
2757
static int sd_suspend(struct device *dev, pm_message_t mesg)
 
2758
{
 
2759
        struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
 
2760
        int ret = 0;
 
2761
 
 
2762
        if (!sdkp)
 
2763
                return 0;       /* this can happen */
 
2764
 
 
2765
        if (sdkp->WCE) {
 
2766
                sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n");
 
2767
                ret = sd_sync_cache(sdkp);
 
2768
                if (ret)
 
2769
                        goto done;
 
2770
        }
 
2771
 
 
2772
        if ((mesg.event & PM_EVENT_SLEEP) && sdkp->device->manage_start_stop) {
 
2773
                sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n");
 
2774
                ret = sd_start_stop_device(sdkp, 0);
 
2775
        }
 
2776
 
 
2777
done:
 
2778
        scsi_disk_put(sdkp);
 
2779
        return ret;
 
2780
}
 
2781
 
 
2782
static int sd_resume(struct device *dev)
 
2783
{
 
2784
        struct scsi_disk *sdkp = scsi_disk_get_from_dev(dev);
 
2785
        int ret = 0;
 
2786
 
 
2787
        if (!sdkp->device->manage_start_stop)
 
2788
                goto done;
 
2789
 
 
2790
        sd_printk(KERN_NOTICE, sdkp, "Starting disk\n");
 
2791
        ret = sd_start_stop_device(sdkp, 1);
 
2792
 
 
2793
done:
 
2794
        scsi_disk_put(sdkp);
 
2795
        return ret;
 
2796
}
 
2797
 
 
2798
/**
 
2799
 *      init_sd - entry point for this driver (both when built in or when
 
2800
 *      a module).
 
2801
 *
 
2802
 *      Note: this function registers this driver with the scsi mid-level.
 
2803
 **/
 
2804
static int __init init_sd(void)
 
2805
{
 
2806
        int majors = 0, i, err;
 
2807
 
 
2808
        SCSI_LOG_HLQUEUE(3, printk("init_sd: sd driver entry point\n"));
 
2809
 
 
2810
        for (i = 0; i < SD_MAJORS; i++)
 
2811
                if (register_blkdev(sd_major(i), "sd") == 0)
 
2812
                        majors++;
 
2813
 
 
2814
        if (!majors)
 
2815
                return -ENODEV;
 
2816
 
 
2817
        err = class_register(&sd_disk_class);
 
2818
        if (err)
 
2819
                goto err_out;
 
2820
 
 
2821
        err = scsi_register_driver(&sd_template.gendrv);
 
2822
        if (err)
 
2823
                goto err_out_class;
 
2824
 
 
2825
        sd_cdb_cache = kmem_cache_create("sd_ext_cdb", SD_EXT_CDB_SIZE,
 
2826
                                         0, 0, NULL);
 
2827
        if (!sd_cdb_cache) {
 
2828
                printk(KERN_ERR "sd: can't init extended cdb cache\n");
 
2829
                goto err_out_class;
 
2830
        }
 
2831
 
 
2832
        sd_cdb_pool = mempool_create_slab_pool(SD_MEMPOOL_SIZE, sd_cdb_cache);
 
2833
        if (!sd_cdb_pool) {
 
2834
                printk(KERN_ERR "sd: can't init extended cdb pool\n");
 
2835
                goto err_out_cache;
 
2836
        }
 
2837
 
 
2838
        return 0;
 
2839
 
 
2840
err_out_cache:
 
2841
        kmem_cache_destroy(sd_cdb_cache);
 
2842
 
 
2843
err_out_class:
 
2844
        class_unregister(&sd_disk_class);
 
2845
err_out:
 
2846
        for (i = 0; i < SD_MAJORS; i++)
 
2847
                unregister_blkdev(sd_major(i), "sd");
 
2848
        return err;
 
2849
}
 
2850
 
 
2851
/**
 
2852
 *      exit_sd - exit point for this driver (when it is a module).
 
2853
 *
 
2854
 *      Note: this function unregisters this driver from the scsi mid-level.
 
2855
 **/
 
2856
static void __exit exit_sd(void)
 
2857
{
 
2858
        int i;
 
2859
 
 
2860
        SCSI_LOG_HLQUEUE(3, printk("exit_sd: exiting sd driver\n"));
 
2861
 
 
2862
        mempool_destroy(sd_cdb_pool);
 
2863
        kmem_cache_destroy(sd_cdb_cache);
 
2864
 
 
2865
        scsi_unregister_driver(&sd_template.gendrv);
 
2866
        class_unregister(&sd_disk_class);
 
2867
 
 
2868
        for (i = 0; i < SD_MAJORS; i++)
 
2869
                unregister_blkdev(sd_major(i), "sd");
 
2870
}
 
2871
 
 
2872
module_init(init_sd);
 
2873
module_exit(exit_sd);
 
2874
 
 
2875
static void sd_print_sense_hdr(struct scsi_disk *sdkp,
 
2876
                               struct scsi_sense_hdr *sshdr)
 
2877
{
 
2878
        sd_printk(KERN_INFO, sdkp, " ");
 
2879
        scsi_show_sense_hdr(sshdr);
 
2880
        sd_printk(KERN_INFO, sdkp, " ");
 
2881
        scsi_show_extd_sense(sshdr->asc, sshdr->ascq);
 
2882
}
 
2883
 
 
2884
static void sd_print_result(struct scsi_disk *sdkp, int result)
 
2885
{
 
2886
        sd_printk(KERN_INFO, sdkp, " ");
 
2887
        scsi_show_result(result);
 
2888
}
 
2889