Merge tag 'devfreq-next-for-5.12' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux.git] / drivers / scsi / sr.c
CommitLineData
09c434b8 1// SPDX-License-Identifier: GPL-2.0-only
1da177e4
LT
2/*
3 * sr.c Copyright (C) 1992 David Giller
4 * Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale
5 *
6 * adapted from:
7 * sd.c Copyright (C) 1992 Drew Eckhardt
8 * Linux scsi disk driver by
9 * Drew Eckhardt <drew@colorado.edu>
10 *
11 * Modified by Eric Youngdale ericy@andante.org to
12 * add scatter-gather, multiple outstanding request, and other
13 * enhancements.
14 *
15 * Modified by Eric Youngdale eric@andante.org to support loadable
16 * low-level scsi drivers.
17 *
18 * Modified by Thomas Quinot thomas@melchior.cuivre.fdn.fr to
19 * provide auto-eject.
20 *
21 * Modified by Gerd Knorr <kraxel@cs.tu-berlin.de> to support the
22 * generic cdrom interface
23 *
24 * Modified by Jens Axboe <axboe@suse.de> - Uniform sr_packet()
25 * interface, capabilities probe additions, ioctl cleanups, etc.
26 *
27 * Modified by Richard Gooch <rgooch@atnf.csiro.au> to support devfs
28 *
29 * Modified by Jens Axboe <axboe@suse.de> - support DVD-RAM
30 * transparently and lose the GHOST hack
31 *
32 * Modified by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
33 * check resource allocation in sr_init and some cleanups
34 */
35
36#include <linux/module.h>
37#include <linux/fs.h>
38#include <linux/kernel.h>
1da177e4
LT
39#include <linux/mm.h>
40#include <linux/bio.h>
d320a955 41#include <linux/compat.h>
1da177e4
LT
42#include <linux/string.h>
43#include <linux/errno.h>
44#include <linux/cdrom.h>
45#include <linux/interrupt.h>
46#include <linux/init.h>
47#include <linux/blkdev.h>
bca6b067 48#include <linux/blk-pm.h>
0b950672 49#include <linux/mutex.h>
5a0e3ad6 50#include <linux/slab.h>
6c7f1e2f 51#include <linux/pm_runtime.h>
7c0f6ba6 52#include <linux/uaccess.h>
1da177e4 53
655da8e5
BVA
54#include <asm/unaligned.h>
55
1da177e4
LT
56#include <scsi/scsi.h>
57#include <scsi/scsi_dbg.h>
58#include <scsi/scsi_device.h>
59#include <scsi/scsi_driver.h>
820732b5 60#include <scsi/scsi_cmnd.h>
1da177e4
LT
61#include <scsi/scsi_eh.h>
62#include <scsi/scsi_host.h>
63#include <scsi/scsi_ioctl.h> /* For the door lock/unlock commands */
1da177e4
LT
64
65#include "scsi_logging.h"
66#include "sr.h"
67
68
f018fa55
RH
69MODULE_DESCRIPTION("SCSI cdrom (sr) driver");
70MODULE_LICENSE("GPL");
71MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_CDROM_MAJOR);
d7b8bcb0
MT
72MODULE_ALIAS_SCSI_DEVICE(TYPE_ROM);
73MODULE_ALIAS_SCSI_DEVICE(TYPE_WORM);
f018fa55 74
1da177e4
LT
75#define SR_DISKS 256
76
1da177e4
LT
77#define SR_CAPABILITIES \
78 (CDC_CLOSE_TRAY|CDC_OPEN_TRAY|CDC_LOCK|CDC_SELECT_SPEED| \
79 CDC_SELECT_DISC|CDC_MULTI_SESSION|CDC_MCN|CDC_MEDIA_CHANGED| \
6a2900b6 80 CDC_PLAY_AUDIO|CDC_RESET|CDC_DRIVE_STATUS| \
1da177e4
LT
81 CDC_CD_R|CDC_CD_RW|CDC_DVD|CDC_DVD_R|CDC_DVD_RAM|CDC_GENERIC_PACKET| \
82 CDC_MRW|CDC_MRW_W|CDC_RAM)
83
84static int sr_probe(struct device *);
85static int sr_remove(struct device *);
159b2cbf 86static blk_status_t sr_init_command(struct scsi_cmnd *SCpnt);
7b3d9545 87static int sr_done(struct scsi_cmnd *);
6c7f1e2f
AL
88static int sr_runtime_suspend(struct device *dev);
89
a816b4c6 90static const struct dev_pm_ops sr_pm_ops = {
6c7f1e2f
AL
91 .runtime_suspend = sr_runtime_suspend,
92};
1da177e4
LT
93
94static struct scsi_driver sr_template = {
1da177e4
LT
95 .gendrv = {
96 .name = "sr",
3af6b352 97 .owner = THIS_MODULE,
1da177e4
LT
98 .probe = sr_probe,
99 .remove = sr_remove,
6c7f1e2f 100 .pm = &sr_pm_ops,
1da177e4 101 },
a1b73fc1 102 .init_command = sr_init_command,
7b3d9545 103 .done = sr_done,
1da177e4
LT
104};
105
106static unsigned long sr_index_bits[SR_DISKS / BITS_PER_LONG];
107static DEFINE_SPINLOCK(sr_index_lock);
108
109/* This semaphore is used to mediate the 0->1 reference get in the
110 * face of object destruction (i.e. we can't allow a get on an
111 * object after last put) */
0b950672 112static DEFINE_MUTEX(sr_ref_mutex);
1da177e4
LT
113
114static int sr_open(struct cdrom_device_info *, int);
115static void sr_release(struct cdrom_device_info *);
116
117static void get_sectorsize(struct scsi_cd *);
118static void get_capabilities(struct scsi_cd *);
119
93aae17a
TH
120static unsigned int sr_check_events(struct cdrom_device_info *cdi,
121 unsigned int clearing, int slot);
1da177e4
LT
122static int sr_packet(struct cdrom_device_info *, struct packet_command *);
123
853fe1bf 124static const struct cdrom_device_ops sr_dops = {
1da177e4
LT
125 .open = sr_open,
126 .release = sr_release,
127 .drive_status = sr_drive_status,
93aae17a 128 .check_events = sr_check_events,
1da177e4
LT
129 .tray_move = sr_tray_move,
130 .lock_door = sr_lock_door,
131 .select_speed = sr_select_speed,
132 .get_last_session = sr_get_last_session,
133 .get_mcn = sr_get_mcn,
134 .reset = sr_reset,
135 .audio_ioctl = sr_audio_ioctl,
1da177e4
LT
136 .capability = SR_CAPABILITIES,
137 .generic_packet = sr_packet,
138};
139
140static void sr_kref_release(struct kref *kref);
141
142static inline struct scsi_cd *scsi_cd(struct gendisk *disk)
143{
144 return container_of(disk->private_data, struct scsi_cd, driver);
145}
146
6c7f1e2f
AL
147static int sr_runtime_suspend(struct device *dev)
148{
149 struct scsi_cd *cd = dev_get_drvdata(dev);
150
13b43891
AS
151 if (!cd) /* E.g.: runtime suspend following sr_remove() */
152 return 0;
153
6c7f1e2f
AL
154 if (cd->media_present)
155 return -EBUSY;
156 else
157 return 0;
158}
159
1da177e4
LT
160/*
161 * The get and put routines for the struct scsi_cd. Note this entity
162 * has a scsi_device pointer and owns a reference to this.
163 */
164static inline struct scsi_cd *scsi_cd_get(struct gendisk *disk)
165{
166 struct scsi_cd *cd = NULL;
167
0b950672 168 mutex_lock(&sr_ref_mutex);
1da177e4
LT
169 if (disk->private_data == NULL)
170 goto out;
171 cd = scsi_cd(disk);
172 kref_get(&cd->kref);
6627b38f
AL
173 if (scsi_device_get(cd->device)) {
174 kref_put(&cd->kref, sr_kref_release);
175 cd = NULL;
176 }
1da177e4 177 out:
0b950672 178 mutex_unlock(&sr_ref_mutex);
1da177e4
LT
179 return cd;
180}
181
858119e1 182static void scsi_cd_put(struct scsi_cd *cd)
1da177e4
LT
183{
184 struct scsi_device *sdev = cd->device;
185
0b950672 186 mutex_lock(&sr_ref_mutex);
1da177e4
LT
187 kref_put(&cd->kref, sr_kref_release);
188 scsi_device_put(sdev);
0b950672 189 mutex_unlock(&sr_ref_mutex);
1da177e4
LT
190}
191
93aae17a
TH
192static unsigned int sr_get_events(struct scsi_device *sdev)
193{
194 u8 buf[8];
195 u8 cmd[] = { GET_EVENT_STATUS_NOTIFICATION,
196 1, /* polled */
197 0, 0, /* reserved */
198 1 << 4, /* notification class: media */
199 0, 0, /* reserved */
200 0, sizeof(buf), /* allocation length */
201 0, /* control */
202 };
203 struct event_header *eh = (void *)buf;
204 struct media_event_desc *med = (void *)(buf + 4);
205 struct scsi_sense_hdr sshdr;
206 int result;
207
208 result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buf, sizeof(buf),
209 &sshdr, SR_TIMEOUT, MAX_RETRIES, NULL);
210 if (scsi_sense_valid(&sshdr) && sshdr.sense_key == UNIT_ATTENTION)
211 return DISK_EVENT_MEDIA_CHANGE;
212
213 if (result || be16_to_cpu(eh->data_len) < sizeof(*med))
214 return 0;
215
216 if (eh->nea || eh->notification_class != 0x4)
217 return 0;
218
219 if (med->media_event_code == 1)
220 return DISK_EVENT_EJECT_REQUEST;
221 else if (med->media_event_code == 2)
222 return DISK_EVENT_MEDIA_CHANGE;
223 return 0;
224}
225
1da177e4 226/*
93aae17a
TH
227 * This function checks to see if the media has been changed or eject
228 * button has been pressed. It is possible that we have already
229 * sensed a change, or the drive may have sensed one and not yet
230 * reported it. The past events are accumulated in sdev->changed and
231 * returned together with the current state.
1da177e4 232 */
93aae17a
TH
233static unsigned int sr_check_events(struct cdrom_device_info *cdi,
234 unsigned int clearing, int slot)
1da177e4
LT
235{
236 struct scsi_cd *cd = cdi->handle;
93aae17a
TH
237 bool last_present;
238 struct scsi_sense_hdr sshdr;
239 unsigned int events;
240 int ret;
1da177e4 241
93aae17a
TH
242 /* no changer support */
243 if (CDSL_CURRENT != slot)
244 return 0;
245
246 events = sr_get_events(cd->device);
79b9677d
KS
247 cd->get_event_changed |= events & DISK_EVENT_MEDIA_CHANGE;
248
249 /*
250 * If earlier GET_EVENT_STATUS_NOTIFICATION and TUR did not agree
251 * for several times in a row. We rely on TUR only for this likely
252 * broken device, to prevent generating incorrect media changed
253 * events for every open().
254 */
255 if (cd->ignore_get_event) {
256 events &= ~DISK_EVENT_MEDIA_CHANGE;
257 goto do_tur;
258 }
259
93aae17a
TH
260 /*
261 * GET_EVENT_STATUS_NOTIFICATION is enough unless MEDIA_CHANGE
262 * is being cleared. Note that there are devices which hang
263 * if asked to execute TUR repeatedly.
264 */
79b9677d
KS
265 if (cd->device->changed) {
266 events |= DISK_EVENT_MEDIA_CHANGE;
267 cd->device->changed = 0;
268 cd->tur_changed = true;
269 }
93aae17a 270
79b9677d
KS
271 if (!(clearing & DISK_EVENT_MEDIA_CHANGE))
272 return events;
273do_tur:
93aae17a
TH
274 /* let's see whether the media is there with TUR */
275 last_present = cd->media_present;
276 ret = scsi_test_unit_ready(cd->device, SR_TIMEOUT, MAX_RETRIES, &sshdr);
1da177e4 277
638428ec
TH
278 /*
279 * Media is considered to be present if TUR succeeds or fails with
280 * sense data indicating something other than media-not-present
281 * (ASC 0x3a).
282 */
93aae17a
TH
283 cd->media_present = scsi_status_is_good(ret) ||
284 (scsi_sense_valid(&sshdr) && sshdr.asc != 0x3a);
1da177e4 285
93aae17a 286 if (last_present != cd->media_present)
79b9677d
KS
287 cd->device->changed = 1;
288
93aae17a
TH
289 if (cd->device->changed) {
290 events |= DISK_EVENT_MEDIA_CHANGE;
291 cd->device->changed = 0;
79b9677d
KS
292 cd->tur_changed = true;
293 }
294
295 if (cd->ignore_get_event)
296 return events;
297
298 /* check whether GET_EVENT is reporting spurious MEDIA_CHANGE */
299 if (!cd->tur_changed) {
300 if (cd->get_event_changed) {
301 if (cd->tur_mismatch++ > 8) {
96eefad2
HR
302 sr_printk(KERN_WARNING, cd,
303 "GET_EVENT and TUR disagree continuously, suppress GET_EVENT events\n");
79b9677d
KS
304 cd->ignore_get_event = true;
305 }
306 } else {
307 cd->tur_mismatch = 0;
308 }
1da177e4 309 }
79b9677d
KS
310 cd->tur_changed = false;
311 cd->get_event_changed = false;
285e9670 312
93aae17a 313 return events;
1da177e4 314}
93aae17a 315
1da177e4 316/*
7b3d9545 317 * sr_done is the interrupt routine for the device driver.
1da177e4 318 *
7b3d9545 319 * It will be notified on the end of a SCSI read / write, and will take one
1da177e4
LT
320 * of several actions based on success or failure.
321 */
7b3d9545 322static int sr_done(struct scsi_cmnd *SCpnt)
1da177e4
LT
323{
324 int result = SCpnt->result;
30b0c37b 325 int this_count = scsi_bufflen(SCpnt);
1da177e4
LT
326 int good_bytes = (result == 0 ? this_count : 0);
327 int block_sectors = 0;
328 long error_sector;
329 struct scsi_cd *cd = scsi_cd(SCpnt->request->rq_disk);
330
331#ifdef DEBUG
96eefad2 332 scmd_printk(KERN_INFO, SCpnt, "done: %x\n", result);
1da177e4
LT
333#endif
334
335 /*
336 * Handle MEDIUM ERRORs or VOLUME OVERFLOWs that indicate partial
337 * success. Since this is a relatively rare error condition, no
338 * care is taken to avoid unnecessary additional work such as
339 * memcpy's that could be avoided.
340 */
341 if (driver_byte(result) != 0 && /* An error occurred */
342 (SCpnt->sense_buffer[0] & 0x7f) == 0x70) { /* Sense current */
343 switch (SCpnt->sense_buffer[2]) {
344 case MEDIUM_ERROR:
345 case VOLUME_OVERFLOW:
346 case ILLEGAL_REQUEST:
347 if (!(SCpnt->sense_buffer[0] & 0x90))
348 break;
655da8e5
BVA
349 error_sector =
350 get_unaligned_be32(&SCpnt->sense_buffer[3]);
1da177e4
LT
351 if (SCpnt->request->bio != NULL)
352 block_sectors =
353 bio_sectors(SCpnt->request->bio);
354 if (block_sectors < 4)
355 block_sectors = 4;
356 if (cd->device->sector_size == 2048)
357 error_sector <<= 2;
358 error_sector &= ~(block_sectors - 1);
83096ebf
TH
359 good_bytes = (error_sector -
360 blk_rq_pos(SCpnt->request)) << 9;
1da177e4
LT
361 if (good_bytes < 0 || good_bytes >= this_count)
362 good_bytes = 0;
363 /*
364 * The SCSI specification allows for the value
365 * returned by READ CAPACITY to be up to 75 2K
366 * sectors past the last readable block.
367 * Therefore, if we hit a medium error within the
368 * last 75 2K sectors, we decrease the saved size
369 * value.
370 */
371 if (error_sector < get_capacity(cd->disk) &&
372 cd->capacity - error_sector < 4 * 75)
373 set_capacity(cd->disk, error_sector);
374 break;
375
376 case RECOVERED_ERROR:
1da177e4
LT
377 good_bytes = this_count;
378 break;
379
380 default:
381 break;
382 }
383 }
384
7b3d9545 385 return good_bytes;
1da177e4
LT
386}
387
159b2cbf 388static blk_status_t sr_init_command(struct scsi_cmnd *SCpnt)
1da177e4 389{
242f9dcb 390 int block = 0, this_count, s_size;
7f9a6bc4 391 struct scsi_cd *cd;
a1b73fc1 392 struct request *rq = SCpnt->request;
159b2cbf 393 blk_status_t ret;
7f9a6bc4 394
7007e9dd 395 ret = scsi_alloc_sgtables(SCpnt);
159b2cbf 396 if (ret != BLK_STS_OK)
7007e9dd 397 return ret;
7f9a6bc4
JB
398 cd = scsi_cd(rq->rq_disk);
399
96eefad2
HR
400 SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt,
401 "Doing sr request, block = %d\n", block));
1da177e4
LT
402
403 if (!cd->device || !scsi_device_online(cd->device)) {
96eefad2
HR
404 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
405 "Finishing %u sectors\n", blk_rq_sectors(rq)));
406 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
407 "Retry with 0x%p\n", SCpnt));
7f9a6bc4 408 goto out;
1da177e4
LT
409 }
410
411 if (cd->device->changed) {
412 /*
413 * quietly refuse to do anything to a changed disc until the
414 * changed bit has been reset
415 */
7f9a6bc4 416 goto out;
1da177e4
LT
417 }
418
1da177e4 419 s_size = cd->device->sector_size;
1da177e4 420 if (s_size != 512 && s_size != 1024 && s_size != 2048) {
3bf743e7 421 scmd_printk(KERN_ERR, SCpnt, "bad sector size %d\n", s_size);
7f9a6bc4 422 goto out;
1da177e4
LT
423 }
424
aebf526b
CH
425 switch (req_op(rq)) {
426 case REQ_OP_WRITE:
fd2eb903 427 if (!cd->writeable)
7f9a6bc4 428 goto out;
1da177e4 429 SCpnt->cmnd[0] = WRITE_10;
96eefad2 430 cd->cdi.media_written = 1;
aebf526b
CH
431 break;
432 case REQ_OP_READ:
1da177e4 433 SCpnt->cmnd[0] = READ_10;
aebf526b
CH
434 break;
435 default:
7f9a6bc4
JB
436 blk_dump_rq_flags(rq, "Unknown sr command");
437 goto out;
1da177e4
LT
438 }
439
440 {
30b0c37b
BH
441 struct scatterlist *sg;
442 int i, size = 0, sg_count = scsi_sg_count(SCpnt);
1da177e4 443
30b0c37b
BH
444 scsi_for_each_sg(SCpnt, sg, sg_count, i)
445 size += sg->length;
446
447 if (size != scsi_bufflen(SCpnt)) {
3bf743e7
JG
448 scmd_printk(KERN_ERR, SCpnt,
449 "mismatch count %d, bytes %d\n",
30b0c37b
BH
450 size, scsi_bufflen(SCpnt));
451 if (scsi_bufflen(SCpnt) > size)
452 SCpnt->sdb.length = size;
1da177e4
LT
453 }
454 }
455
456 /*
457 * request doesn't start on hw block boundary, add scatter pads
458 */
83096ebf 459 if (((unsigned int)blk_rq_pos(rq) % (s_size >> 9)) ||
30b0c37b 460 (scsi_bufflen(SCpnt) % s_size)) {
3bf743e7 461 scmd_printk(KERN_NOTICE, SCpnt, "unaligned transfer\n");
7f9a6bc4 462 goto out;
1da177e4
LT
463 }
464
30b0c37b 465 this_count = (scsi_bufflen(SCpnt) >> 9) / (s_size >> 9);
1da177e4
LT
466
467
96eefad2
HR
468 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
469 "%s %d/%u 512 byte blocks.\n",
470 (rq_data_dir(rq) == WRITE) ?
1da177e4 471 "writing" : "reading",
96eefad2 472 this_count, blk_rq_sectors(rq)));
1da177e4
LT
473
474 SCpnt->cmnd[1] = 0;
83096ebf 475 block = (unsigned int)blk_rq_pos(rq) / (s_size >> 9);
1da177e4
LT
476
477 if (this_count > 0xffff) {
478 this_count = 0xffff;
30b0c37b 479 SCpnt->sdb.length = this_count * s_size;
1da177e4
LT
480 }
481
655da8e5 482 put_unaligned_be32(block, &SCpnt->cmnd[2]);
1da177e4 483 SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0;
655da8e5 484 put_unaligned_be16(this_count, &SCpnt->cmnd[7]);
1da177e4
LT
485
486 /*
487 * We shouldn't disconnect in the middle of a sector, so with a dumb
488 * host adapter, it's safe to assume that we can at least transfer
489 * this many bytes between each connect / disconnect.
490 */
491 SCpnt->transfersize = cd->device->sector_size;
492 SCpnt->underflow = this_count << 9;
1da177e4 493 SCpnt->allowed = MAX_RETRIES;
9120ac54 494 SCpnt->cmd_len = 10;
1da177e4 495
1da177e4 496 /*
7007e9dd 497 * This indicates that the command is ready from our end to be queued.
1da177e4 498 */
7007e9dd 499 return BLK_STS_OK;
7f9a6bc4 500 out:
7007e9dd
CH
501 scsi_free_sgtables(SCpnt);
502 return BLK_STS_IOERR;
1da177e4
LT
503}
504
38a2b557
CH
505static void sr_revalidate_disk(struct scsi_cd *cd)
506{
507 struct scsi_sense_hdr sshdr;
508
509 /* if the unit is not ready, nothing more to do */
510 if (scsi_test_unit_ready(cd->device, SR_TIMEOUT, MAX_RETRIES, &sshdr))
511 return;
512 sr_cd_check(&cd->cdi);
513 get_sectorsize(cd);
514}
515
40cc51be 516static int sr_block_open(struct block_device *bdev, fmode_t mode)
1da177e4 517{
6e9624b8 518 struct scsi_cd *cd;
1214fd7b 519 struct scsi_device *sdev;
40cc51be 520 int ret = -ENXIO;
1da177e4 521
1214fd7b
BVA
522 cd = scsi_cd_get(bdev->bd_disk);
523 if (!cd)
524 goto out;
525
526 sdev = cd->device;
527 scsi_autopm_get_device(sdev);
afd35c4f 528 if (bdev_check_media_change(bdev))
38a2b557 529 sr_revalidate_disk(cd);
2bbea6e1 530
51a85881 531 mutex_lock(&cd->lock);
1214fd7b 532 ret = cdrom_open(&cd->cdi, bdev, mode);
51a85881 533 mutex_unlock(&cd->lock);
1214fd7b
BVA
534
535 scsi_autopm_put_device(sdev);
536 if (ret)
537 scsi_cd_put(cd);
538
539out:
1da177e4
LT
540 return ret;
541}
542
db2a144b 543static void sr_block_release(struct gendisk *disk, fmode_t mode)
1da177e4 544{
40cc51be 545 struct scsi_cd *cd = scsi_cd(disk);
72655c0e 546
51a85881 547 mutex_lock(&cd->lock);
40cc51be 548 cdrom_release(&cd->cdi, mode);
51a85881 549 mutex_unlock(&cd->lock);
72655c0e
BVA
550
551 scsi_cd_put(cd);
1da177e4
LT
552}
553
40cc51be 554static int sr_block_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
1da177e4
LT
555 unsigned long arg)
556{
40cc51be 557 struct scsi_cd *cd = scsi_cd(bdev->bd_disk);
1da177e4 558 struct scsi_device *sdev = cd->device;
6a2900b6
CH
559 void __user *argp = (void __user *)arg;
560 int ret;
1da177e4 561
51a85881 562 mutex_lock(&cd->lock);
8a6cfeb6 563
906d15fb
CH
564 ret = scsi_ioctl_block_when_processing_errors(sdev, cmd,
565 (mode & FMODE_NDELAY) != 0);
566 if (ret)
567 goto out;
568
1214fd7b
BVA
569 scsi_autopm_get_device(sdev);
570
6a2900b6
CH
571 /*
572 * Send SCSI addressing ioctls directly to mid level, send other
573 * ioctls to cdrom/block level.
574 */
575 switch (cmd) {
576 case SCSI_IOCTL_GET_IDLUN:
577 case SCSI_IOCTL_GET_BUS_NUMBER:
8a6cfeb6 578 ret = scsi_ioctl(sdev, cmd, argp);
1214fd7b 579 goto put;
1da177e4 580 }
6a2900b6 581
40cc51be 582 ret = cdrom_ioctl(&cd->cdi, bdev, mode, cmd, arg);
6397256b 583 if (ret != -ENOSYS)
1214fd7b 584 goto put;
6a2900b6 585
8a6cfeb6
AB
586 ret = scsi_ioctl(sdev, cmd, argp);
587
1214fd7b
BVA
588put:
589 scsi_autopm_put_device(sdev);
590
8a6cfeb6 591out:
51a85881 592 mutex_unlock(&cd->lock);
8a6cfeb6 593 return ret;
1da177e4
LT
594}
595
d320a955
AB
596#ifdef CONFIG_COMPAT
597static int sr_block_compat_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
598 unsigned long arg)
599{
600 struct scsi_cd *cd = scsi_cd(bdev->bd_disk);
601 struct scsi_device *sdev = cd->device;
602 void __user *argp = compat_ptr(arg);
603 int ret;
604
51a85881 605 mutex_lock(&cd->lock);
d320a955
AB
606
607 ret = scsi_ioctl_block_when_processing_errors(sdev, cmd,
608 (mode & FMODE_NDELAY) != 0);
609 if (ret)
610 goto out;
611
612 scsi_autopm_get_device(sdev);
613
614 /*
615 * Send SCSI addressing ioctls directly to mid level, send other
616 * ioctls to cdrom/block level.
617 */
618 switch (cmd) {
619 case SCSI_IOCTL_GET_IDLUN:
620 case SCSI_IOCTL_GET_BUS_NUMBER:
621 ret = scsi_compat_ioctl(sdev, cmd, argp);
622 goto put;
623 }
624
64cbfa96
AB
625 ret = cdrom_ioctl(&cd->cdi, bdev, mode, cmd, (unsigned long)argp);
626 if (ret != -ENOSYS)
d320a955
AB
627 goto put;
628
629 ret = scsi_compat_ioctl(sdev, cmd, argp);
630
631put:
632 scsi_autopm_put_device(sdev);
633
634out:
51a85881 635 mutex_unlock(&cd->lock);
d320a955
AB
636 return ret;
637
638}
639#endif
640
93aae17a
TH
641static unsigned int sr_block_check_events(struct gendisk *disk,
642 unsigned int clearing)
1da177e4 643{
2d097c50
JA
644 unsigned int ret = 0;
645 struct scsi_cd *cd;
6c7f1e2f 646
2d097c50
JA
647 cd = scsi_cd_get(disk);
648 if (!cd)
6627b38f 649 return 0;
6c7f1e2f 650
2d097c50
JA
651 if (!atomic_read(&cd->device->disk_events_disable_depth))
652 ret = cdrom_check_events(&cd->cdi, clearing);
653
654 scsi_cd_put(cd);
655 return ret;
93aae17a
TH
656}
657
83d5cde4 658static const struct block_device_operations sr_bdops =
1da177e4
LT
659{
660 .owner = THIS_MODULE,
40cc51be
AV
661 .open = sr_block_open,
662 .release = sr_block_release,
8a6cfeb6 663 .ioctl = sr_block_ioctl,
d320a955 664#ifdef CONFIG_COMPAT
03264ddd 665 .compat_ioctl = sr_block_compat_ioctl,
d320a955 666#endif
93aae17a 667 .check_events = sr_block_check_events,
1da177e4
LT
668};
669
670static int sr_open(struct cdrom_device_info *cdi, int purpose)
671{
672 struct scsi_cd *cd = cdi->handle;
673 struct scsi_device *sdev = cd->device;
674 int retval;
675
676 /*
677 * If the device is in error recovery, wait until it is done.
678 * If the device is offline, then disallow any access to it.
679 */
680 retval = -ENXIO;
681 if (!scsi_block_when_processing_errors(sdev))
682 goto error_out;
683
1da177e4
LT
684 return 0;
685
686error_out:
687 return retval;
688}
689
690static void sr_release(struct cdrom_device_info *cdi)
691{
1da177e4
LT
692}
693
694static int sr_probe(struct device *dev)
695{
696 struct scsi_device *sdev = to_scsi_device(dev);
697 struct gendisk *disk;
698 struct scsi_cd *cd;
699 int minor, error;
700
6fe8c1db 701 scsi_autopm_get_device(sdev);
1da177e4
LT
702 error = -ENODEV;
703 if (sdev->type != TYPE_ROM && sdev->type != TYPE_WORM)
704 goto fail;
705
706 error = -ENOMEM;
24669f75 707 cd = kzalloc(sizeof(*cd), GFP_KERNEL);
1da177e4
LT
708 if (!cd)
709 goto fail;
1da177e4
LT
710
711 kref_init(&cd->kref);
712
713 disk = alloc_disk(1);
714 if (!disk)
715 goto fail_free;
51a85881 716 mutex_init(&cd->lock);
1da177e4
LT
717
718 spin_lock(&sr_index_lock);
719 minor = find_first_zero_bit(sr_index_bits, SR_DISKS);
720 if (minor == SR_DISKS) {
721 spin_unlock(&sr_index_lock);
722 error = -EBUSY;
723 goto fail_put;
724 }
725 __set_bit(minor, sr_index_bits);
726 spin_unlock(&sr_index_lock);
727
728 disk->major = SCSI_CDROM_MAJOR;
729 disk->first_minor = minor;
730 sprintf(disk->disk_name, "sr%d", minor);
731 disk->fops = &sr_bdops;
d4dc210f 732 disk->flags = GENHD_FL_CD | GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE;
93aae17a 733 disk->events = DISK_EVENT_MEDIA_CHANGE | DISK_EVENT_EJECT_REQUEST;
c92e2f04 734 disk->event_flags = DISK_EVENT_FLAG_POLL | DISK_EVENT_FLAG_UEVENT;
1da177e4 735
242f9dcb
JA
736 blk_queue_rq_timeout(sdev->request_queue, SR_TIMEOUT);
737
1da177e4
LT
738 cd->device = sdev;
739 cd->disk = disk;
740 cd->driver = &sr_template;
741 cd->disk = disk;
742 cd->capacity = 0x1fffff;
1da177e4 743 cd->device->changed = 1; /* force recheck CD type */
93aae17a 744 cd->media_present = 1;
1da177e4
LT
745 cd->use = 1;
746 cd->readcd_known = 0;
747 cd->readcd_cdda = 0;
748
749 cd->cdi.ops = &sr_dops;
750 cd->cdi.handle = cd;
751 cd->cdi.mask = 0;
752 cd->cdi.capacity = 1;
753 sprintf(cd->cdi.name, "sr%d", minor);
754
755 sdev->sector_size = 2048; /* A guess, just in case */
756
757 /* FIXME: need to handle a get_capabilities failure properly ?? */
758 get_capabilities(cd);
759 sr_vendor_init(cd);
760
1da177e4
LT
761 set_capacity(disk, cd->capacity);
762 disk->private_data = &cd->driver;
763 disk->queue = sdev->request_queue;
1da177e4 764
a711d91c 765 if (register_cdrom(disk, &cd->cdi))
6555781b 766 goto fail_minor;
1da177e4 767
6627b38f
AL
768 /*
769 * Initialize block layer runtime PM stuffs before the
770 * periodic event checking request gets started in add_disk.
771 */
772 blk_pm_runtime_init(sdev->request_queue, dev);
773
1da177e4
LT
774 dev_set_drvdata(dev, cd);
775 disk->flags |= GENHD_FL_REMOVABLE;
38a2b557 776 sr_revalidate_disk(cd);
fef912bf 777 device_add_disk(&sdev->sdev_gendev, disk, NULL);
1da177e4 778
9ccfc756
JB
779 sdev_printk(KERN_DEBUG, sdev,
780 "Attached scsi CD-ROM %s\n", cd->cdi.name);
6c7f1e2f
AL
781 scsi_autopm_put_device(cd->device);
782
1da177e4
LT
783 return 0;
784
6555781b
SA
785fail_minor:
786 spin_lock(&sr_index_lock);
787 clear_bit(minor, sr_index_bits);
788 spin_unlock(&sr_index_lock);
1da177e4
LT
789fail_put:
790 put_disk(disk);
a247e07f 791 mutex_destroy(&cd->lock);
1da177e4
LT
792fail_free:
793 kfree(cd);
794fail:
6fe8c1db 795 scsi_autopm_put_device(sdev);
1da177e4
LT
796 return error;
797}
798
799
800static void get_sectorsize(struct scsi_cd *cd)
801{
802 unsigned char cmd[10];
62858dac 803 unsigned char buffer[8];
1da177e4
LT
804 int the_result, retries = 3;
805 int sector_size;
165125e1 806 struct request_queue *queue;
1da177e4 807
1da177e4
LT
808 do {
809 cmd[0] = READ_CAPACITY;
810 memset((void *) &cmd[1], 0, 9);
62858dac 811 memset(buffer, 0, sizeof(buffer));
1da177e4
LT
812
813 /* Do the command and wait.. */
820732b5 814 the_result = scsi_execute_req(cd->device, cmd, DMA_FROM_DEVICE,
62858dac 815 buffer, sizeof(buffer), NULL,
f4f4e47e 816 SR_TIMEOUT, MAX_RETRIES, NULL);
1da177e4 817
1da177e4
LT
818 retries--;
819
820 } while (the_result && retries);
821
822
1da177e4
LT
823 if (the_result) {
824 cd->capacity = 0x1fffff;
825 sector_size = 2048; /* A guess, just in case */
1da177e4 826 } else {
5915136d
TH
827 long last_written;
828
655da8e5 829 cd->capacity = 1 + get_unaligned_be32(&buffer[0]);
5915136d
TH
830 /*
831 * READ_CAPACITY doesn't return the correct size on
832 * certain UDF media. If last_written is larger, use
833 * it instead.
834 *
835 * http://bugzilla.kernel.org/show_bug.cgi?id=9668
836 */
837 if (!cdrom_get_last_written(&cd->cdi, &last_written))
838 cd->capacity = max_t(long, cd->capacity, last_written);
839
655da8e5 840 sector_size = get_unaligned_be32(&buffer[4]);
1da177e4
LT
841 switch (sector_size) {
842 /*
843 * HP 4020i CD-Recorder reports 2340 byte sectors
844 * Philips CD-Writers report 2352 byte sectors
845 *
846 * Use 2k sectors for them..
847 */
848 case 0:
849 case 2340:
850 case 2352:
851 sector_size = 2048;
df561f66 852 fallthrough;
1da177e4
LT
853 case 2048:
854 cd->capacity *= 4;
df561f66 855 fallthrough;
1da177e4
LT
856 case 512:
857 break;
858 default:
96eefad2
HR
859 sr_printk(KERN_INFO, cd,
860 "unsupported sector size %d.", sector_size);
1da177e4 861 cd->capacity = 0;
1da177e4
LT
862 }
863
864 cd->device->sector_size = sector_size;
865
866 /*
867 * Add this so that we have the ability to correctly gauge
868 * what the device is capable of.
869 */
1da177e4
LT
870 set_capacity(cd->disk, cd->capacity);
871 }
872
873 queue = cd->device->request_queue;
e1defc4f 874 blk_queue_logical_block_size(queue, sector_size);
1da177e4 875
62858dac 876 return;
1da177e4
LT
877}
878
879static void get_capabilities(struct scsi_cd *cd)
880{
881 unsigned char *buffer;
882 struct scsi_mode_data data;
820732b5 883 struct scsi_sense_hdr sshdr;
a00a7862 884 unsigned int ms_len = 128;
38582a62 885 int rc, n;
1da177e4 886
0ad78200 887 static const char *loadmech[] =
1da177e4
LT
888 {
889 "caddy",
890 "tray",
891 "pop-up",
892 "",
893 "changer",
894 "cartridge changer",
895 "",
896 ""
897 };
898
1da177e4
LT
899
900 /* allocate transfer buffer */
901 buffer = kmalloc(512, GFP_KERNEL | GFP_DMA);
902 if (!buffer) {
96eefad2 903 sr_printk(KERN_ERR, cd, "out of memory.\n");
1da177e4
LT
904 return;
905 }
906
38582a62 907 /* eat unit attentions */
9f8a2c23 908 scsi_test_unit_ready(cd->device, SR_TIMEOUT, MAX_RETRIES, &sshdr);
1da177e4
LT
909
910 /* ask for mode page 0x2a */
a00a7862 911 rc = scsi_mode_sense(cd->device, 0, 0x2a, buffer, ms_len,
1cf72699 912 SR_TIMEOUT, 3, &data, NULL);
1da177e4 913
a00a7862
MP
914 if (!scsi_status_is_good(rc) || data.length > ms_len ||
915 data.header_length + data.block_descriptor_length > data.length) {
1da177e4
LT
916 /* failed, drive doesn't have capabilities mode page */
917 cd->cdi.speed = 1;
918 cd->cdi.mask |= (CDC_CD_R | CDC_CD_RW | CDC_DVD_R |
bcc1e382
CE
919 CDC_DVD | CDC_DVD_RAM |
920 CDC_SELECT_DISC | CDC_SELECT_SPEED |
921 CDC_MRW | CDC_MRW_W | CDC_RAM);
1da177e4 922 kfree(buffer);
96eefad2 923 sr_printk(KERN_INFO, cd, "scsi-1 drive");
1da177e4
LT
924 return;
925 }
926
927 n = data.header_length + data.block_descriptor_length;
655da8e5 928 cd->cdi.speed = get_unaligned_be16(&buffer[n + 8]) / 176;
1da177e4
LT
929 cd->readcd_known = 1;
930 cd->readcd_cdda = buffer[n + 5] & 0x01;
931 /* print some capability bits */
96eefad2
HR
932 sr_printk(KERN_INFO, cd,
933 "scsi3-mmc drive: %dx/%dx %s%s%s%s%s%s\n",
655da8e5 934 get_unaligned_be16(&buffer[n + 14]) / 176,
96eefad2
HR
935 cd->cdi.speed,
936 buffer[n + 3] & 0x01 ? "writer " : "", /* CD Writer */
937 buffer[n + 3] & 0x20 ? "dvd-ram " : "",
938 buffer[n + 2] & 0x02 ? "cd/rw " : "", /* can read rewriteable */
939 buffer[n + 4] & 0x20 ? "xa/form2 " : "", /* can read xa/from2 */
940 buffer[n + 5] & 0x01 ? "cdda " : "", /* can read audio data */
941 loadmech[buffer[n + 6] >> 5]);
1da177e4
LT
942 if ((buffer[n + 6] >> 5) == 0)
943 /* caddy drives can't close tray... */
944 cd->cdi.mask |= CDC_CLOSE_TRAY;
945 if ((buffer[n + 2] & 0x8) == 0)
946 /* not a DVD drive */
947 cd->cdi.mask |= CDC_DVD;
96eefad2 948 if ((buffer[n + 3] & 0x20) == 0)
1da177e4
LT
949 /* can't write DVD-RAM media */
950 cd->cdi.mask |= CDC_DVD_RAM;
951 if ((buffer[n + 3] & 0x10) == 0)
952 /* can't write DVD-R media */
953 cd->cdi.mask |= CDC_DVD_R;
954 if ((buffer[n + 3] & 0x2) == 0)
955 /* can't write CD-RW media */
956 cd->cdi.mask |= CDC_CD_RW;
957 if ((buffer[n + 3] & 0x1) == 0)
958 /* can't write CD-R media */
959 cd->cdi.mask |= CDC_CD_R;
960 if ((buffer[n + 6] & 0x8) == 0)
961 /* can't eject */
962 cd->cdi.mask |= CDC_OPEN_TRAY;
963
964 if ((buffer[n + 6] >> 5) == mechtype_individual_changer ||
965 (buffer[n + 6] >> 5) == mechtype_cartridge_changer)
966 cd->cdi.capacity =
967 cdrom_number_of_slots(&cd->cdi);
968 if (cd->cdi.capacity <= 1)
969 /* not a changer */
970 cd->cdi.mask |= CDC_SELECT_DISC;
971 /*else I don't think it can close its tray
972 cd->cdi.mask |= CDC_CLOSE_TRAY; */
973
974 /*
975 * if DVD-RAM, MRW-W or CD-RW, we are randomly writable
976 */
977 if ((cd->cdi.mask & (CDC_DVD_RAM | CDC_MRW_W | CDC_RAM | CDC_CD_RW)) !=
978 (CDC_DVD_RAM | CDC_MRW_W | CDC_RAM | CDC_CD_RW)) {
fd2eb903 979 cd->writeable = 1;
1da177e4
LT
980 }
981
1da177e4
LT
982 kfree(buffer);
983}
984
985/*
986 * sr_packet() is the entry point for the generic commands generated
96eefad2 987 * by the Uniform CD-ROM layer.
1da177e4
LT
988 */
989static int sr_packet(struct cdrom_device_info *cdi,
990 struct packet_command *cgc)
991{
8e04d805
HG
992 struct scsi_cd *cd = cdi->handle;
993 struct scsi_device *sdev = cd->device;
994
995 if (cgc->cmd[0] == GPCMD_READ_DISC_INFO && sdev->no_read_disc_info)
996 return -EDRIVE_CANT_DO_THIS;
997
1da177e4
LT
998 if (cgc->timeout <= 0)
999 cgc->timeout = IOCTL_TIMEOUT;
1000
8e04d805 1001 sr_do_ioctl(cd, cgc);
1da177e4
LT
1002
1003 return cgc->stat;
1004}
1005
1006/**
1007 * sr_kref_release - Called to free the scsi_cd structure
1008 * @kref: pointer to embedded kref
1009 *
0b950672 1010 * sr_ref_mutex must be held entering this routine. Because it is
1da177e4
LT
1011 * called on last put, you should always use the scsi_cd_get()
1012 * scsi_cd_put() helpers which manipulate the semaphore directly
1013 * and never do a direct kref_put().
1014 **/
1015static void sr_kref_release(struct kref *kref)
1016{
1017 struct scsi_cd *cd = container_of(kref, struct scsi_cd, kref);
1018 struct gendisk *disk = cd->disk;
1019
1020 spin_lock(&sr_index_lock);
f331c029 1021 clear_bit(MINOR(disk_devt(disk)), sr_index_bits);
1da177e4
LT
1022 spin_unlock(&sr_index_lock);
1023
1024 unregister_cdrom(&cd->cdi);
1025
1026 disk->private_data = NULL;
1027
1028 put_disk(disk);
1029
51a85881
MW
1030 mutex_destroy(&cd->lock);
1031
1da177e4
LT
1032 kfree(cd);
1033}
1034
1035static int sr_remove(struct device *dev)
1036{
1037 struct scsi_cd *cd = dev_get_drvdata(dev);
1038
6c7f1e2f
AL
1039 scsi_autopm_get_device(cd->device);
1040
1da177e4 1041 del_gendisk(cd->disk);
13b43891 1042 dev_set_drvdata(dev, NULL);
1da177e4 1043
0b950672 1044 mutex_lock(&sr_ref_mutex);
1da177e4 1045 kref_put(&cd->kref, sr_kref_release);
0b950672 1046 mutex_unlock(&sr_ref_mutex);
1da177e4
LT
1047
1048 return 0;
1049}
1050
1051static int __init init_sr(void)
1052{
1053 int rc;
1054
1055 rc = register_blkdev(SCSI_CDROM_MAJOR, "sr");
1056 if (rc)
1057 return rc;
da3962fe
AM
1058 rc = scsi_register_driver(&sr_template.gendrv);
1059 if (rc)
1060 unregister_blkdev(SCSI_CDROM_MAJOR, "sr");
1061
1062 return rc;
1da177e4
LT
1063}
1064
1065static void __exit exit_sr(void)
1066{
1067 scsi_unregister_driver(&sr_template.gendrv);
1068 unregister_blkdev(SCSI_CDROM_MAJOR, "sr");
1069}
1070
1071module_init(init_sr);
1072module_exit(exit_sr);
1073MODULE_LICENSE("GPL");
This page took 2.734577 seconds and 4 git commands to generate.