blob: d9128a9ae3f802130915c8389e47823a5760fc20 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/ide/ide-cd.c
3 *
4 * Copyright (C) 1994, 1995, 1996 scott snyder <snyder@fnald0.fnal.gov>
5 * Copyright (C) 1996-1998 Erik Andersen <andersee@debian.org>
6 * Copyright (C) 1998-2000 Jens Axboe <axboe@suse.de>
7 *
8 * May be copied or modified under the terms of the GNU General Public
9 * License. See linux/COPYING for more information.
10 *
11 * ATAPI CD-ROM driver. To be used with ide.c.
12 * See Documentation/cdrom/ide-cd for usage information.
13 *
14 * Suggestions are welcome. Patches that work are more welcome though. ;-)
15 * For those wishing to work on this driver, please be sure you download
16 * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI
17 * (SFF-8020i rev 2.6) standards. These documents can be obtained by
18 * anonymous ftp from:
19 * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
20 * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
21 *
22 * Drives that deviate from these standards will be accommodated as much
23 * as possible via compile time or command-line options. Since I only have
24 * a few drives, you generally need to send me patches...
25 *
26 * ----------------------------------
27 * TO DO LIST:
28 * -Make it so that Pioneer CD DR-A24X and friends don't get screwed up on
29 * boot
30 *
Bartlomiej Zolnierkiewicz03553352008-02-01 23:09:18 +010031 * For historical changelog please see:
32 * Documentation/ide/ChangeLog.ide-cd.1994-2004
33 */
34
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#define IDECD_VERSION "4.61"
36
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/module.h>
38#include <linux/types.h>
39#include <linux/kernel.h>
40#include <linux/delay.h>
41#include <linux/timer.h>
42#include <linux/slab.h>
43#include <linux/interrupt.h>
44#include <linux/errno.h>
45#include <linux/cdrom.h>
46#include <linux/ide.h>
47#include <linux/completion.h>
Arjan van de Vencf8b8972006-03-23 03:00:45 -080048#include <linux/mutex.h>
Bartlomiej Zolnierkiewicz9a6dc662008-02-01 23:09:22 +010049#include <linux/bcd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
51#include <scsi/scsi.h> /* For SCSI -> ATAPI command conversion */
52
53#include <asm/irq.h>
54#include <asm/io.h>
55#include <asm/byteorder.h>
56#include <asm/uaccess.h>
57#include <asm/unaligned.h>
58
59#include "ide-cd.h"
60
Arjan van de Vencf8b8972006-03-23 03:00:45 -080061static DEFINE_MUTEX(idecd_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
63#define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref)
64
65#define ide_cd_g(disk) \
66 container_of((disk)->private_data, struct cdrom_info, driver)
67
68static struct cdrom_info *ide_cd_get(struct gendisk *disk)
69{
70 struct cdrom_info *cd = NULL;
71
Arjan van de Vencf8b8972006-03-23 03:00:45 -080072 mutex_lock(&idecd_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 cd = ide_cd_g(disk);
74 if (cd)
75 kref_get(&cd->kref);
Arjan van de Vencf8b8972006-03-23 03:00:45 -080076 mutex_unlock(&idecd_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 return cd;
78}
79
80static void ide_cd_release(struct kref *);
81
82static void ide_cd_put(struct cdrom_info *cd)
83{
Arjan van de Vencf8b8972006-03-23 03:00:45 -080084 mutex_lock(&idecd_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 kref_put(&cd->kref, ide_cd_release);
Arjan van de Vencf8b8972006-03-23 03:00:45 -080086 mutex_unlock(&idecd_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087}
88
89/****************************************************************************
90 * Generic packet command support and error handling routines.
91 */
92
93/* Mark that we've seen a media change, and invalidate our internal
94 buffers. */
95static void cdrom_saw_media_change (ide_drive_t *drive)
96{
Bartlomiej Zolnierkiewicz0ba11212008-02-01 23:09:21 +010097 struct cdrom_info *cd = drive->driver_data;
98
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +010099 cd->cd_flags |= IDE_CD_FLAG_MEDIA_CHANGED;
100 cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
Bartlomiej Zolnierkiewicz0ba11212008-02-01 23:09:21 +0100101 cd->nsectors_buffered = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102}
103
104static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
105 struct request_sense *sense)
106{
107 int log = 0;
108
Jens Axboe4aff5e22006-08-10 08:44:47 +0200109 if (!sense || !rq || (rq->cmd_flags & REQ_QUIET))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 return 0;
111
112 switch (sense->sense_key) {
113 case NO_SENSE: case RECOVERED_ERROR:
114 break;
115 case NOT_READY:
116 /*
117 * don't care about tray state messages for
118 * e.g. capacity commands or in-progress or
119 * becoming ready
120 */
121 if (sense->asc == 0x3a || sense->asc == 0x04)
122 break;
123 log = 1;
124 break;
125 case ILLEGAL_REQUEST:
126 /*
127 * don't log START_STOP unit with LoEj set, since
128 * we cannot reliably check if drive can auto-close
129 */
130 if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
Alan Coxdbe217a2006-06-25 05:47:44 -0700131 break;
132 log = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 break;
134 case UNIT_ATTENTION:
135 /*
136 * Make good and sure we've seen this potential media
137 * change. Some drives (i.e. Creative) fail to present
138 * the correct sense key in the error register.
139 */
140 cdrom_saw_media_change(drive);
141 break;
142 default:
143 log = 1;
144 break;
145 }
146 return log;
147}
148
149static
150void cdrom_analyze_sense_data(ide_drive_t *drive,
151 struct request *failed_command,
152 struct request_sense *sense)
153{
Alan Coxdbe217a2006-06-25 05:47:44 -0700154 unsigned long sector;
155 unsigned long bio_sectors;
156 unsigned long valid;
157 struct cdrom_info *info = drive->driver_data;
158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 if (!cdrom_log_sense(drive, failed_command, sense))
160 return;
161
162 /*
163 * If a read toc is executed for a CD-R or CD-RW medium where
164 * the first toc has not been recorded yet, it will fail with
165 * 05/24/00 (which is a confusing error)
166 */
167 if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
168 if (sense->sense_key == 0x05 && sense->asc == 0x24)
169 return;
170
Alan Coxdbe217a2006-06-25 05:47:44 -0700171 if (sense->error_code == 0x70) { /* Current Error */
172 switch(sense->sense_key) {
173 case MEDIUM_ERROR:
174 case VOLUME_OVERFLOW:
175 case ILLEGAL_REQUEST:
176 if (!sense->valid)
177 break;
178 if (failed_command == NULL ||
179 !blk_fs_request(failed_command))
180 break;
181 sector = (sense->information[0] << 24) |
182 (sense->information[1] << 16) |
183 (sense->information[2] << 8) |
184 (sense->information[3]);
185
186 bio_sectors = bio_sectors(failed_command->bio);
187 if (bio_sectors < 4)
188 bio_sectors = 4;
189 if (drive->queue->hardsect_size == 2048)
190 sector <<= 2; /* Device sector size is 2K */
191 sector &= ~(bio_sectors -1);
192 valid = (sector - failed_command->sector) << 9;
193
194 if (valid < 0)
195 valid = 0;
196 if (sector < get_capacity(info->disk) &&
197 drive->probed_capacity - sector < 4 * 75) {
198 set_capacity(info->disk, sector);
199 }
200 }
201 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
Bartlomiej Zolnierkiewicz972560f2008-02-01 23:09:23 +0100203 ide_cd_log_error(drive->name, failed_command, sense);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204}
205
206/*
207 * Initialize a ide-cd packet command request
208 */
209static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq)
210{
211 struct cdrom_info *cd = drive->driver_data;
212
213 ide_init_drive_cmd(rq);
Jens Axboecea28852006-10-12 15:08:45 +0200214 rq->cmd_type = REQ_TYPE_ATA_PC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 rq->rq_disk = cd->disk;
216}
217
218static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
219 struct request *failed_command)
220{
221 struct cdrom_info *info = drive->driver_data;
222 struct request *rq = &info->request_sense_request;
223
224 if (sense == NULL)
225 sense = &info->sense_data;
226
227 /* stuff the sense request in front of our current request */
228 cdrom_prepare_request(drive, rq);
229
230 rq->data = sense;
231 rq->cmd[0] = GPCMD_REQUEST_SENSE;
232 rq->cmd[4] = rq->data_len = 18;
233
Jens Axboe4aff5e22006-08-10 08:44:47 +0200234 rq->cmd_type = REQ_TYPE_SENSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235
236 /* NOTE! Save the failed command in "rq->buffer" */
237 rq->buffer = (void *) failed_command;
238
239 (void) ide_do_drive_cmd(drive, rq, ide_preempt);
240}
241
242static void cdrom_end_request (ide_drive_t *drive, int uptodate)
243{
244 struct request *rq = HWGROUP(drive)->rq;
245 int nsectors = rq->hard_cur_sectors;
246
Jens Axboe4aff5e22006-08-10 08:44:47 +0200247 if (blk_sense_request(rq) && uptodate) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 /*
Jens Axboe4aff5e22006-08-10 08:44:47 +0200249 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
250 * failed request
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 */
252 struct request *failed = (struct request *) rq->buffer;
253 struct cdrom_info *info = drive->driver_data;
254 void *sense = &info->sense_data;
255 unsigned long flags;
256
257 if (failed) {
258 if (failed->sense) {
259 sense = failed->sense;
260 failed->sense_len = rq->sense_len;
261 }
Alan Coxdbe217a2006-06-25 05:47:44 -0700262 cdrom_analyze_sense_data(drive, failed, sense);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 /*
264 * now end failed request
265 */
Alan Coxdbe217a2006-06-25 05:47:44 -0700266 if (blk_fs_request(failed)) {
267 if (ide_end_dequeued_request(drive, failed, 0,
268 failed->hard_nr_sectors))
269 BUG();
270 } else {
271 spin_lock_irqsave(&ide_lock, flags);
Kiyoshi Ueda5e36bb62008-01-28 10:34:20 +0100272 if (__blk_end_request(failed, -EIO,
273 failed->data_len))
274 BUG();
Alan Coxdbe217a2006-06-25 05:47:44 -0700275 spin_unlock_irqrestore(&ide_lock, flags);
276 }
277 } else
278 cdrom_analyze_sense_data(drive, NULL, sense);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 }
280
281 if (!rq->current_nr_sectors && blk_fs_request(rq))
282 uptodate = 1;
283 /* make sure it's fully ended */
284 if (blk_pc_request(rq))
285 nsectors = (rq->data_len + 511) >> 9;
286 if (!nsectors)
287 nsectors = 1;
288
289 ide_end_request(drive, uptodate, nsectors);
290}
291
Alan Coxdbe217a2006-06-25 05:47:44 -0700292static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 stat)
293{
294 if (stat & 0x80)
295 return;
296 ide_dump_status(drive, msg, stat);
297}
298
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299/* Returns 0 if the request should be continued.
300 Returns 1 if the request was ended. */
301static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
302{
303 struct request *rq = HWGROUP(drive)->rq;
304 int stat, err, sense_key;
305
306 /* Check for errors. */
307 stat = HWIF(drive)->INB(IDE_STATUS_REG);
308 if (stat_ret)
309 *stat_ret = stat;
310
311 if (OK_STAT(stat, good_stat, BAD_R_STAT))
312 return 0;
313
314 /* Get the IDE error register. */
315 err = HWIF(drive)->INB(IDE_ERROR_REG);
316 sense_key = err >> 4;
317
318 if (rq == NULL) {
319 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
320 return 1;
321 }
322
Jens Axboe4aff5e22006-08-10 08:44:47 +0200323 if (blk_sense_request(rq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 /* We got an error trying to get sense info
325 from the drive (probably while trying
326 to recover from a former error). Just give up. */
327
Jens Axboe4aff5e22006-08-10 08:44:47 +0200328 rq->cmd_flags |= REQ_FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 cdrom_end_request(drive, 0);
330 ide_error(drive, "request sense failure", stat);
331 return 1;
332
Jens Axboe8770c012006-10-12 17:24:52 +0200333 } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 /* All other functions, except for READ. */
335 unsigned long flags;
336
337 /*
338 * if we have an error, pass back CHECK_CONDITION as the
339 * scsi status byte
340 */
Jens Axboeb7156732006-11-13 18:05:02 +0100341 if (blk_pc_request(rq) && !rq->errors)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 rq->errors = SAM_STAT_CHECK_CONDITION;
343
344 /* Check for tray open. */
345 if (sense_key == NOT_READY) {
346 cdrom_saw_media_change (drive);
347 } else if (sense_key == UNIT_ATTENTION) {
348 /* Check for media change. */
349 cdrom_saw_media_change (drive);
350 /*printk("%s: media changed\n",drive->name);*/
351 return 0;
Stuart Hayes76ca1af2007-04-10 22:38:43 +0200352 } else if ((sense_key == ILLEGAL_REQUEST) &&
353 (rq->cmd[0] == GPCMD_START_STOP_UNIT)) {
354 /*
355 * Don't print error message for this condition--
356 * SFF8090i indicates that 5/24/00 is the correct
357 * response to a request to close the tray if the
358 * drive doesn't have that capability.
359 * cdrom_log_sense() knows this!
360 */
Jens Axboe4aff5e22006-08-10 08:44:47 +0200361 } else if (!(rq->cmd_flags & REQ_QUIET)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 /* Otherwise, print an error. */
363 ide_dump_status(drive, "packet command error", stat);
364 }
365
Jens Axboe4aff5e22006-08-10 08:44:47 +0200366 rq->cmd_flags |= REQ_FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
368 /*
369 * instead of playing games with moving completions around,
370 * remove failed request completely and end it when the
371 * request sense has completed
372 */
373 if (stat & ERR_STAT) {
374 spin_lock_irqsave(&ide_lock, flags);
375 blkdev_dequeue_request(rq);
376 HWGROUP(drive)->rq = NULL;
377 spin_unlock_irqrestore(&ide_lock, flags);
378
379 cdrom_queue_request_sense(drive, rq->sense, rq);
380 } else
381 cdrom_end_request(drive, 0);
382
383 } else if (blk_fs_request(rq)) {
384 int do_end_request = 0;
385
386 /* Handle errors from READ and WRITE requests. */
387
388 if (blk_noretry_request(rq))
389 do_end_request = 1;
390
391 if (sense_key == NOT_READY) {
392 /* Tray open. */
393 if (rq_data_dir(rq) == READ) {
394 cdrom_saw_media_change (drive);
395
396 /* Fail the request. */
397 printk ("%s: tray open\n", drive->name);
398 do_end_request = 1;
399 } else {
400 struct cdrom_info *info = drive->driver_data;
401
402 /* allow the drive 5 seconds to recover, some
403 * devices will return this error while flushing
404 * data from cache */
405 if (!rq->errors)
406 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
407 rq->errors = 1;
408 if (time_after(jiffies, info->write_timeout))
409 do_end_request = 1;
410 else {
411 unsigned long flags;
412
413 /*
414 * take a breather relying on the
415 * unplug timer to kick us again
416 */
417 spin_lock_irqsave(&ide_lock, flags);
418 blk_plug_device(drive->queue);
419 spin_unlock_irqrestore(&ide_lock,flags);
420 return 1;
421 }
422 }
423 } else if (sense_key == UNIT_ATTENTION) {
424 /* Media change. */
425 cdrom_saw_media_change (drive);
426
427 /* Arrange to retry the request.
428 But be sure to give up if we've retried
429 too many times. */
430 if (++rq->errors > ERROR_MAX)
431 do_end_request = 1;
432 } else if (sense_key == ILLEGAL_REQUEST ||
433 sense_key == DATA_PROTECT) {
434 /* No point in retrying after an illegal
435 request or data protect error.*/
Alan Coxdbe217a2006-06-25 05:47:44 -0700436 ide_dump_status_no_sense (drive, "command error", stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 do_end_request = 1;
438 } else if (sense_key == MEDIUM_ERROR) {
439 /* No point in re-trying a zillion times on a bad
440 * sector... If we got here the error is not correctable */
Alan Coxdbe217a2006-06-25 05:47:44 -0700441 ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 do_end_request = 1;
443 } else if (sense_key == BLANK_CHECK) {
444 /* Disk appears blank ?? */
Alan Coxdbe217a2006-06-25 05:47:44 -0700445 ide_dump_status_no_sense (drive, "media error (blank)", stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 do_end_request = 1;
447 } else if ((err & ~ABRT_ERR) != 0) {
448 /* Go to the default handler
449 for other errors. */
450 ide_error(drive, "cdrom_decode_status", stat);
451 return 1;
452 } else if ((++rq->errors > ERROR_MAX)) {
453 /* We've racked up too many retries. Abort. */
454 do_end_request = 1;
455 }
456
Alan Coxdbe217a2006-06-25 05:47:44 -0700457 /* End a request through request sense analysis when we have
458 sense data. We need this in order to perform end of media
459 processing */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460
Alan Coxdbe217a2006-06-25 05:47:44 -0700461 if (do_end_request) {
462 if (stat & ERR_STAT) {
463 unsigned long flags;
464 spin_lock_irqsave(&ide_lock, flags);
465 blkdev_dequeue_request(rq);
466 HWGROUP(drive)->rq = NULL;
467 spin_unlock_irqrestore(&ide_lock, flags);
468
469 cdrom_queue_request_sense(drive, rq->sense, rq);
470 } else
471 cdrom_end_request(drive, 0);
472 } else {
473 /* If we got a CHECK_CONDITION status,
474 queue a request sense command. */
475 if (stat & ERR_STAT)
476 cdrom_queue_request_sense(drive, NULL, NULL);
477 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 } else {
479 blk_dump_rq_flags(rq, "ide-cd: bad rq");
480 cdrom_end_request(drive, 0);
481 }
482
483 /* Retry, or handle the next request. */
484 return 1;
485}
486
487static int cdrom_timer_expiry(ide_drive_t *drive)
488{
489 struct request *rq = HWGROUP(drive)->rq;
490 unsigned long wait = 0;
491
492 /*
493 * Some commands are *slow* and normally take a long time to
494 * complete. Usually we can use the ATAPI "disconnect" to bypass
495 * this, but not all commands/drives support that. Let
496 * ide_timer_expiry keep polling us for these.
497 */
498 switch (rq->cmd[0]) {
499 case GPCMD_BLANK:
500 case GPCMD_FORMAT_UNIT:
501 case GPCMD_RESERVE_RZONE_TRACK:
502 case GPCMD_CLOSE_TRACK:
503 case GPCMD_FLUSH_CACHE:
504 wait = ATAPI_WAIT_PC;
505 break;
506 default:
Jens Axboe4aff5e22006-08-10 08:44:47 +0200507 if (!(rq->cmd_flags & REQ_QUIET))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
509 wait = 0;
510 break;
511 }
512 return wait;
513}
514
515/* Set up the device registers for transferring a packet command on DEV,
516 expecting to later transfer XFERLEN bytes. HANDLER is the routine
517 which actually transfers the command to the drive. If this is a
518 drq_interrupt device, this routine will arrange for HANDLER to be
519 called when the interrupt from the drive arrives. Otherwise, HANDLER
520 will be called immediately after the drive is prepared for the transfer. */
521
522static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
523 int xferlen,
524 ide_handler_t *handler)
525{
526 ide_startstop_t startstop;
527 struct cdrom_info *info = drive->driver_data;
528 ide_hwif_t *hwif = drive->hwif;
529
530 /* Wait for the controller to be idle. */
531 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
532 return startstop;
533
Bartlomiej Zolnierkiewicz3a6a3542008-01-25 22:17:13 +0100534 /* FIXME: for Virtual DMA we must check harder */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 if (info->dma)
536 info->dma = !hwif->dma_setup(drive);
537
538 /* Set up the controller registers. */
Bartlomiej Zolnierkiewicz2fc57382008-01-25 22:17:13 +0100539 ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL |
540 IDE_TFLAG_NO_SELECT_MASK, xferlen, info->dma);
Bartlomiej Zolnierkiewicz4fe67172008-02-01 23:09:21 +0100541
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +0100542 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
Albert Leef0dd8712007-02-17 02:40:21 +0100543 /* waiting for CDB interrupt, not DMA yet. */
544 if (info->dma)
545 drive->waiting_for_dma = 0;
546
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 /* packet command */
548 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
549 return ide_started;
550 } else {
551 unsigned long flags;
552
553 /* packet command */
554 spin_lock_irqsave(&ide_lock, flags);
555 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
556 ndelay(400);
557 spin_unlock_irqrestore(&ide_lock, flags);
558
559 return (*handler) (drive);
560 }
561}
562
563/* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
564 The device registers must have already been prepared
565 by cdrom_start_packet_command.
566 HANDLER is the interrupt handler to call when the command completes
567 or there's data ready. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568#define ATAPI_MIN_CDB_BYTES 12
569static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
570 struct request *rq,
571 ide_handler_t *handler)
572{
573 ide_hwif_t *hwif = drive->hwif;
574 int cmd_len;
575 struct cdrom_info *info = drive->driver_data;
576 ide_startstop_t startstop;
577
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +0100578 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 /* Here we should have been called after receiving an interrupt
580 from the device. DRQ should how be set. */
581
582 /* Check for errors. */
583 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
584 return ide_stopped;
Albert Leef0dd8712007-02-17 02:40:21 +0100585
586 /* Ok, next interrupt will be DMA interrupt. */
587 if (info->dma)
588 drive->waiting_for_dma = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 } else {
590 /* Otherwise, we must wait for DRQ to get set. */
591 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
592 BUSY_STAT, WAIT_READY))
593 return startstop;
594 }
595
596 /* Arm the interrupt handler. */
597 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
598
599 /* ATAPI commands get padded out to 12 bytes minimum */
600 cmd_len = COMMAND_SIZE(rq->cmd[0]);
601 if (cmd_len < ATAPI_MIN_CDB_BYTES)
602 cmd_len = ATAPI_MIN_CDB_BYTES;
603
604 /* Send the command to the device. */
605 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
606
607 /* Start the DMA if need be */
608 if (info->dma)
609 hwif->dma_start(drive);
610
611 return ide_started;
612}
613
614/****************************************************************************
615 * Block read functions.
616 */
617
Bartlomiej Zolnierkiewicz68661c52008-02-01 23:09:17 +0100618typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
619
Bartlomiej Zolnierkiewicz5a5222d2008-02-01 23:09:17 +0100620static void ide_cd_pad_transfer(ide_drive_t *drive, xfer_func_t *xf, int len)
621{
622 while (len > 0) {
623 int dum = 0;
624 xf(drive, &dum, sizeof(dum));
625 len -= sizeof(dum);
626 }
627}
628
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629/*
630 * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
631 * buffer. Once the first sector is added, any subsequent sectors are
632 * assumed to be continuous (until the buffer is cleared). For the first
633 * sector added, SECTOR is its sector number. (SECTOR is then ignored until
634 * the buffer is cleared.)
635 */
636static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
637 int sectors_to_transfer)
638{
639 struct cdrom_info *info = drive->driver_data;
640
641 /* Number of sectors to read into the buffer. */
642 int sectors_to_buffer = min_t(int, sectors_to_transfer,
643 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
644 info->nsectors_buffered);
645
646 char *dest;
647
648 /* If we couldn't get a buffer, don't try to buffer anything... */
649 if (info->buffer == NULL)
650 sectors_to_buffer = 0;
651
652 /* If this is the first sector in the buffer, remember its number. */
653 if (info->nsectors_buffered == 0)
654 info->sector_buffered = sector;
655
656 /* Read the data into the buffer. */
657 dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
658 while (sectors_to_buffer > 0) {
659 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
660 --sectors_to_buffer;
661 --sectors_to_transfer;
662 ++info->nsectors_buffered;
663 dest += SECTOR_SIZE;
664 }
665
666 /* Throw away any remaining data. */
667 while (sectors_to_transfer > 0) {
668 static char dum[SECTOR_SIZE];
669 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
670 --sectors_to_transfer;
671 }
672}
673
674/*
675 * Check the contents of the interrupt reason register from the cdrom
676 * and attempt to recover if there are problems. Returns 0 if everything's
677 * ok; nonzero if the request has been terminated.
678 */
Arjan van de Ven858119e2006-01-14 13:20:43 -0800679static
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
681{
682 if (ireason == 2)
683 return 0;
684 else if (ireason == 0) {
Bartlomiej Zolnierkiewicz5a5222d2008-02-01 23:09:17 +0100685 ide_hwif_t *hwif = drive->hwif;
686
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 /* Whoops... The drive is expecting to receive data from us! */
Bartlomiej Zolnierkiewicz35379c02007-12-24 15:23:43 +0100688 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
689 drive->name, __FUNCTION__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
691 /* Throw some data at the drive so it doesn't hang
692 and quit this request. */
Bartlomiej Zolnierkiewicz5a5222d2008-02-01 23:09:17 +0100693 ide_cd_pad_transfer(drive, hwif->atapi_output_bytes, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 } else if (ireason == 1) {
695 /* Some drives (ASUS) seem to tell us that status
696 * info is available. just get it and ignore.
697 */
698 (void) HWIF(drive)->INB(IDE_STATUS_REG);
699 return 0;
700 } else {
701 /* Drive wants a command packet, or invalid ireason... */
Bartlomiej Zolnierkiewicz35379c02007-12-24 15:23:43 +0100702 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
703 drive->name, __FUNCTION__, ireason);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 }
705
706 cdrom_end_request(drive, 0);
707 return -1;
708}
709
710/*
711 * Interrupt routine. Called when a read request has completed.
712 */
713static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
714{
715 int stat;
716 int ireason, len, sectors_to_transfer, nskip;
717 struct cdrom_info *info = drive->driver_data;
718 u8 lowcyl = 0, highcyl = 0;
719 int dma = info->dma, dma_error = 0;
720
721 struct request *rq = HWGROUP(drive)->rq;
722
723 /*
724 * handle dma case
725 */
726 if (dma) {
727 info->dma = 0;
Bartlomiej Zolnierkiewicz52ef2ed2007-12-24 15:23:43 +0100728 dma_error = HWIF(drive)->ide_dma_end(drive);
729 if (dma_error) {
730 printk(KERN_ERR "%s: DMA read error\n", drive->name);
Bartlomiej Zolnierkiewicz7469aaf2007-02-17 02:40:26 +0100731 ide_dma_off(drive);
Bartlomiej Zolnierkiewicz52ef2ed2007-12-24 15:23:43 +0100732 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 }
734
735 if (cdrom_decode_status(drive, 0, &stat))
736 return ide_stopped;
737
738 if (dma) {
739 if (!dma_error) {
740 ide_end_request(drive, 1, rq->nr_sectors);
741 return ide_stopped;
742 } else
743 return ide_error(drive, "dma error", stat);
744 }
745
746 /* Read the interrupt reason and the transfer length. */
747 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
748 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
749 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
750
751 len = lowcyl + (256 * highcyl);
752
753 /* If DRQ is clear, the command has completed. */
754 if ((stat & DRQ_STAT) == 0) {
755 /* If we're not done filling the current buffer, complain.
756 Otherwise, complete the command normally. */
757 if (rq->current_nr_sectors > 0) {
758 printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
759 drive->name, rq->current_nr_sectors);
Jens Axboe4aff5e22006-08-10 08:44:47 +0200760 rq->cmd_flags |= REQ_FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 cdrom_end_request(drive, 0);
762 } else
763 cdrom_end_request(drive, 1);
764 return ide_stopped;
765 }
766
767 /* Check that the drive is expecting to do the same thing we are. */
768 if (cdrom_read_check_ireason (drive, len, ireason))
769 return ide_stopped;
770
771 /* Assume that the drive will always provide data in multiples
772 of at least SECTOR_SIZE, as it gets hairy to keep track
773 of the transfers otherwise. */
774 if ((len % SECTOR_SIZE) != 0) {
775 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
776 drive->name, len);
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +0100777 if (info->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 printk (KERN_ERR " This drive is not supported by this version of the driver\n");
779 else {
780 printk (KERN_ERR " Trying to limit transfer sizes\n");
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +0100781 info->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 }
783 cdrom_end_request(drive, 0);
784 return ide_stopped;
785 }
786
787 /* The number of sectors we need to read from the drive. */
788 sectors_to_transfer = len / SECTOR_SIZE;
789
790 /* First, figure out if we need to bit-bucket
791 any of the leading sectors. */
792 nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
793
794 while (nskip > 0) {
795 /* We need to throw away a sector. */
796 static char dum[SECTOR_SIZE];
797 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
798
799 --rq->current_nr_sectors;
800 --nskip;
801 --sectors_to_transfer;
802 }
803
804 /* Now loop while we still have data to read from the drive. */
805 while (sectors_to_transfer > 0) {
806 int this_transfer;
807
808 /* If we've filled the present buffer but there's another
809 chained buffer after it, move on. */
810 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
811 cdrom_end_request(drive, 1);
812
813 /* If the buffers are full, cache the rest of the data in our
814 internal buffer. */
815 if (rq->current_nr_sectors == 0) {
816 cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
817 sectors_to_transfer = 0;
818 } else {
819 /* Transfer data to the buffers.
820 Figure out how many sectors we can transfer
821 to the current buffer. */
822 this_transfer = min_t(int, sectors_to_transfer,
823 rq->current_nr_sectors);
824
825 /* Read this_transfer sectors
826 into the current buffer. */
827 while (this_transfer > 0) {
828 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
829 rq->buffer += SECTOR_SIZE;
830 --rq->nr_sectors;
831 --rq->current_nr_sectors;
832 ++rq->sector;
833 --this_transfer;
834 --sectors_to_transfer;
835 }
836 }
837 }
838
839 /* Done moving data! Wait for another interrupt. */
840 ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
841 return ide_started;
842}
843
844/*
845 * Try to satisfy some of the current read request from our cached data.
846 * Returns nonzero if the request has been completed, zero otherwise.
847 */
848static int cdrom_read_from_buffer (ide_drive_t *drive)
849{
850 struct cdrom_info *info = drive->driver_data;
851 struct request *rq = HWGROUP(drive)->rq;
852 unsigned short sectors_per_frame;
853
854 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
855
856 /* Can't do anything if there's no buffer. */
857 if (info->buffer == NULL) return 0;
858
859 /* Loop while this request needs data and the next block is present
860 in our cache. */
861 while (rq->nr_sectors > 0 &&
862 rq->sector >= info->sector_buffered &&
863 rq->sector < info->sector_buffered + info->nsectors_buffered) {
864 if (rq->current_nr_sectors == 0)
865 cdrom_end_request(drive, 1);
866
867 memcpy (rq->buffer,
868 info->buffer +
869 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
870 SECTOR_SIZE);
871 rq->buffer += SECTOR_SIZE;
872 --rq->current_nr_sectors;
873 --rq->nr_sectors;
874 ++rq->sector;
875 }
876
877 /* If we've satisfied the current request,
878 terminate it successfully. */
879 if (rq->nr_sectors == 0) {
880 cdrom_end_request(drive, 1);
881 return -1;
882 }
883
884 /* Move on to the next buffer if needed. */
885 if (rq->current_nr_sectors == 0)
886 cdrom_end_request(drive, 1);
887
888 /* If this condition does not hold, then the kluge i use to
889 represent the number of sectors to skip at the start of a transfer
890 will fail. I think that this will never happen, but let's be
891 paranoid and check. */
892 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
893 (rq->sector & (sectors_per_frame - 1))) {
894 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
895 drive->name, (long)rq->sector);
896 cdrom_end_request(drive, 0);
897 return -1;
898 }
899
900 return 0;
901}
902
903/*
904 * Routine to send a read packet command to the drive.
905 * This is usually called directly from cdrom_start_read.
906 * However, for drq_interrupt devices, it is called from an interrupt
907 * when the drive is ready to accept the command.
908 */
909static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
910{
911 struct request *rq = HWGROUP(drive)->rq;
912 unsigned short sectors_per_frame;
913 int nskip;
914
915 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
916
917 /* If the requested sector doesn't start on a cdrom block boundary,
918 we must adjust the start of the transfer so that it does,
919 and remember to skip the first few sectors.
920 If the CURRENT_NR_SECTORS field is larger than the size
921 of the buffer, it will mean that we're to skip a number
922 of sectors equal to the amount by which CURRENT_NR_SECTORS
923 is larger than the buffer size. */
924 nskip = rq->sector & (sectors_per_frame - 1);
925 if (nskip > 0) {
926 /* Sanity check... */
927 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
928 (rq->sector & (sectors_per_frame - 1))) {
929 printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
930 drive->name, rq->current_nr_sectors);
931 cdrom_end_request(drive, 0);
932 return ide_stopped;
933 }
934 rq->current_nr_sectors += nskip;
935 }
936
937 /* Set up the command */
938 rq->timeout = ATAPI_WAIT_PC;
939
940 /* Send the command to the drive and return. */
941 return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
942}
943
944
945#define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
946#define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
947#define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
948
949static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
950{
951 struct cdrom_info *info = drive->driver_data;
952 int stat;
953 static int retry = 10;
954
955 if (cdrom_decode_status(drive, 0, &stat))
956 return ide_stopped;
Bartlomiej Zolnierkiewicz4fe67172008-02-01 23:09:21 +0100957
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +0100958 info->cd_flags |= IDE_CD_FLAG_SEEKING;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959
960 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
961 if (--retry == 0) {
962 /*
963 * this condition is far too common, to bother
964 * users about it
965 */
966 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
967 drive->dsc_overlap = 0;
968 }
969 }
970 return ide_stopped;
971}
972
973static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
974{
975 struct request *rq = HWGROUP(drive)->rq;
976 sector_t frame = rq->sector;
977
978 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
979
980 memset(rq->cmd, 0, sizeof(rq->cmd));
981 rq->cmd[0] = GPCMD_SEEK;
982 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
983
984 rq->timeout = ATAPI_WAIT_PC;
985 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
986}
987
988static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
989{
990 struct cdrom_info *info = drive->driver_data;
991
992 info->dma = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 info->start_seek = jiffies;
994 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
995}
996
997/* Fix up a possibly partially-processed request so that we can
998 start it over entirely, or even put it back on the request queue. */
999static void restore_request (struct request *rq)
1000{
1001 if (rq->buffer != bio_data(rq->bio)) {
1002 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1003
1004 rq->buffer = bio_data(rq->bio);
1005 rq->nr_sectors += n;
1006 rq->sector -= n;
1007 }
1008 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1009 rq->hard_nr_sectors = rq->nr_sectors;
1010 rq->hard_sector = rq->sector;
1011 rq->q->prep_rq_fn(rq->q, rq);
1012}
1013
1014/*
1015 * Start a read request from the CD-ROM.
1016 */
1017static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1018{
1019 struct cdrom_info *info = drive->driver_data;
1020 struct request *rq = HWGROUP(drive)->rq;
1021 unsigned short sectors_per_frame;
1022
1023 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1024
1025 /* We may be retrying this request after an error. Fix up
1026 any weirdness which might be present in the request packet. */
1027 restore_request(rq);
1028
1029 /* Satisfy whatever we can of this request from our cached sector. */
1030 if (cdrom_read_from_buffer(drive))
1031 return ide_stopped;
1032
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 /* Clear the local sector buffer. */
1034 info->nsectors_buffered = 0;
1035
1036 /* use dma, if possible. */
1037 info->dma = drive->using_dma;
1038 if ((rq->sector & (sectors_per_frame - 1)) ||
1039 (rq->nr_sectors & (sectors_per_frame - 1)))
1040 info->dma = 0;
1041
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 /* Start sending the read request to the drive. */
1043 return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1044}
1045
1046/****************************************************************************
1047 * Execute all other packet commands.
1048 */
1049
1050/* Interrupt routine for packet command completion. */
1051static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1052{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 struct request *rq = HWGROUP(drive)->rq;
Bartlomiej Zolnierkiewicz68661c52008-02-01 23:09:17 +01001054 xfer_func_t *xferfunc = NULL;
1055 int stat, ireason, len, thislen, write;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 u8 lowcyl = 0, highcyl = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
1058 /* Check for errors. */
1059 if (cdrom_decode_status(drive, 0, &stat))
1060 return ide_stopped;
1061
1062 /* Read the interrupt reason and the transfer length. */
Bartlomiej Zolnierkiewicz8606ab02007-12-24 15:23:44 +01001063 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1065 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1066
1067 len = lowcyl + (256 * highcyl);
1068
1069 /* If DRQ is clear, the command has completed.
1070 Complain if we still have data left to transfer. */
1071 if ((stat & DRQ_STAT) == 0) {
1072 /* Some of the trailing request sense fields are optional, and
1073 some drives don't send them. Sigh. */
1074 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1075 rq->data_len > 0 &&
1076 rq->data_len <= 5) {
1077 while (rq->data_len > 0) {
1078 *(unsigned char *)rq->data++ = 0;
1079 --rq->data_len;
1080 }
1081 }
1082
1083 if (rq->data_len == 0)
1084 cdrom_end_request(drive, 1);
1085 else {
Jens Axboe4aff5e22006-08-10 08:44:47 +02001086 rq->cmd_flags |= REQ_FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 cdrom_end_request(drive, 0);
1088 }
1089 return ide_stopped;
1090 }
1091
1092 /* Figure out how much data to transfer. */
1093 thislen = rq->data_len;
Bartlomiej Zolnierkiewicz68661c52008-02-01 23:09:17 +01001094 if (thislen > len)
1095 thislen = len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096
Bartlomiej Zolnierkiewicz8606ab02007-12-24 15:23:44 +01001097 if (ireason == 0) {
Bartlomiej Zolnierkiewicz68661c52008-02-01 23:09:17 +01001098 write = 1;
1099 xferfunc = HWIF(drive)->atapi_output_bytes;
1100 } else if (ireason == 2) {
1101 write = 0;
1102 xferfunc = HWIF(drive)->atapi_input_bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 }
1104
Bartlomiej Zolnierkiewicz68661c52008-02-01 23:09:17 +01001105 if (xferfunc) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 if (!rq->data) {
Bartlomiej Zolnierkiewiczf1071e62008-02-01 23:09:17 +01001107 printk(KERN_ERR "%s: confused, missing data\n",
1108 drive->name);
Bartlomiej Zolnierkiewicz68661c52008-02-01 23:09:17 +01001109 blk_dump_rq_flags(rq, write ? "cdrom_pc_intr, write"
1110 : "cdrom_pc_intr, read");
Bartlomiej Zolnierkiewiczf1071e62008-02-01 23:09:17 +01001111 goto pad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 }
1113 /* Transfer the data. */
Bartlomiej Zolnierkiewicz68661c52008-02-01 23:09:17 +01001114 xferfunc(drive, rq->data, thislen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 /* Keep count of how much data we've moved. */
Bartlomiej Zolnierkiewicz5a5222d2008-02-01 23:09:17 +01001117 len -= thislen;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 rq->data += thislen;
1119 rq->data_len -= thislen;
1120
Bartlomiej Zolnierkiewicz68661c52008-02-01 23:09:17 +01001121 if (write && blk_sense_request(rq))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 rq->sense_len += thislen;
1123 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
Rachita Kothiyal1ad55442006-06-23 02:02:56 -07001125 "appears confused (ireason = 0x%02x). "
1126 "Trying to recover by ending request.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 drive->name, ireason);
Jens Axboe4aff5e22006-08-10 08:44:47 +02001128 rq->cmd_flags |= REQ_FAILED;
Rachita Kothiyal1ad55442006-06-23 02:02:56 -07001129 cdrom_end_request(drive, 0);
1130 return ide_stopped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 }
Bartlomiej Zolnierkiewiczf1071e62008-02-01 23:09:17 +01001132pad:
Bartlomiej Zolnierkiewicz5a5222d2008-02-01 23:09:17 +01001133 /*
1134 * If we haven't moved enough data to satisfy the drive,
1135 * add some padding.
1136 */
1137 if (len > 0)
1138 ide_cd_pad_transfer(drive, xferfunc, len);
1139
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140 /* Now we wait for another interrupt. */
1141 ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1142 return ide_started;
1143}
1144
1145static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1146{
1147 struct request *rq = HWGROUP(drive)->rq;
1148
1149 if (!rq->timeout)
1150 rq->timeout = ATAPI_WAIT_PC;
1151
1152 /* Send the command to the drive and return. */
1153 return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1154}
1155
1156
1157static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1158{
1159 int len;
1160 struct request *rq = HWGROUP(drive)->rq;
1161 struct cdrom_info *info = drive->driver_data;
1162
1163 info->dma = 0;
Jens Axboe4aff5e22006-08-10 08:44:47 +02001164 rq->cmd_flags &= ~REQ_FAILED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 len = rq->data_len;
1166
1167 /* Start sending the command to the drive. */
1168 return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1169}
1170
1171
Alan Coxdbe217a2006-06-25 05:47:44 -07001172static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173{
1174 struct request_sense sense;
1175 int retries = 10;
Jens Axboe4aff5e22006-08-10 08:44:47 +02001176 unsigned int flags = rq->cmd_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177
1178 if (rq->sense == NULL)
1179 rq->sense = &sense;
1180
1181 /* Start of retry loop. */
1182 do {
1183 int error;
1184 unsigned long time = jiffies;
Jens Axboe4aff5e22006-08-10 08:44:47 +02001185 rq->cmd_flags = flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
1187 error = ide_do_drive_cmd(drive, rq, ide_wait);
1188 time = jiffies - time;
1189
1190 /* FIXME: we should probably abort/retry or something
1191 * in case of failure */
Jens Axboe4aff5e22006-08-10 08:44:47 +02001192 if (rq->cmd_flags & REQ_FAILED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 /* The request failed. Retry if it was due to a unit
1194 attention status
1195 (usually means media was changed). */
1196 struct request_sense *reqbuf = rq->sense;
1197
1198 if (reqbuf->sense_key == UNIT_ATTENTION)
1199 cdrom_saw_media_change(drive);
1200 else if (reqbuf->sense_key == NOT_READY &&
1201 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1202 /* The drive is in the process of loading
1203 a disk. Retry, but wait a little to give
1204 the drive time to complete the load. */
1205 ssleep(2);
1206 } else {
1207 /* Otherwise, don't retry. */
1208 retries = 0;
1209 }
1210 --retries;
1211 }
1212
1213 /* End of retry loop. */
Jens Axboe4aff5e22006-08-10 08:44:47 +02001214 } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215
1216 /* Return an error if the command failed. */
Jens Axboe4aff5e22006-08-10 08:44:47 +02001217 return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218}
1219
1220/*
1221 * Write handling
1222 */
Arjan van de Ven858119e2006-01-14 13:20:43 -08001223static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224{
1225 /* Two notes about IDE interrupt reason here - 0 means that
1226 * the drive wants to receive data from us, 2 means that
1227 * the drive is expecting to transfer data to us.
1228 */
1229 if (ireason == 0)
1230 return 0;
1231 else if (ireason == 2) {
Bartlomiej Zolnierkiewicz5a5222d2008-02-01 23:09:17 +01001232 ide_hwif_t *hwif = drive->hwif;
1233
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 /* Whoops... The drive wants to send data. */
Bartlomiej Zolnierkiewicz35379c02007-12-24 15:23:43 +01001235 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1236 drive->name, __FUNCTION__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237
Bartlomiej Zolnierkiewicz5a5222d2008-02-01 23:09:17 +01001238 ide_cd_pad_transfer(drive, hwif->atapi_input_bytes, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 } else {
1240 /* Drive wants a command packet, or invalid ireason... */
Bartlomiej Zolnierkiewicz35379c02007-12-24 15:23:43 +01001241 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1242 drive->name, __FUNCTION__, ireason);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 }
1244
1245 cdrom_end_request(drive, 0);
1246 return 1;
1247}
1248
Kiyoshi Uedaaaa04c22007-12-11 17:51:23 -05001249/*
1250 * Called from blk_end_request_callback() after the data of the request
1251 * is completed and before the request is completed.
1252 * By returning value '1', blk_end_request_callback() returns immediately
1253 * without completing the request.
1254 */
1255static int cdrom_newpc_intr_dummy_cb(struct request *rq)
1256{
1257 return 1;
1258}
1259
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260/*
1261 * best way to deal with dma that is not sector aligned right now... note
1262 * that in this path we are not using ->data or ->buffer at all. this irs
1263 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1264 * future.
1265 */
1266static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1267{
1268 struct cdrom_info *info = drive->driver_data;
1269 struct request *rq = HWGROUP(drive)->rq;
1270 int dma_error, dma, stat, ireason, len, thislen;
1271 u8 lowcyl, highcyl;
1272 xfer_func_t *xferfunc;
1273 unsigned long flags;
1274
1275 /* Check for errors. */
1276 dma_error = 0;
1277 dma = info->dma;
1278 if (dma) {
1279 info->dma = 0;
1280 dma_error = HWIF(drive)->ide_dma_end(drive);
Bartlomiej Zolnierkiewiczeba15fb2008-02-01 23:09:17 +01001281 if (dma_error) {
1282 printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1283 rq_data_dir(rq) ? "write" : "read");
1284 ide_dma_off(drive);
1285 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 }
1287
1288 if (cdrom_decode_status(drive, 0, &stat))
1289 return ide_stopped;
1290
1291 /*
1292 * using dma, transfer is complete now
1293 */
1294 if (dma) {
Bartlomiej Zolnierkiewiczeba15fb2008-02-01 23:09:17 +01001295 if (dma_error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 return ide_error(drive, "dma error", stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297
Kiyoshi Uedaaaa04c22007-12-11 17:51:23 -05001298 spin_lock_irqsave(&ide_lock, flags);
1299 if (__blk_end_request(rq, 0, rq->data_len))
1300 BUG();
1301 HWGROUP(drive)->rq = NULL;
1302 spin_unlock_irqrestore(&ide_lock, flags);
1303
1304 return ide_stopped;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 }
1306
1307 /*
1308 * ok we fall to pio :/
1309 */
1310 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1311 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1312 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1313
1314 len = lowcyl + (256 * highcyl);
1315 thislen = rq->data_len;
1316 if (thislen > len)
1317 thislen = len;
1318
1319 /*
1320 * If DRQ is clear, the command has completed.
1321 */
Kiyoshi Uedaaaa04c22007-12-11 17:51:23 -05001322 if ((stat & DRQ_STAT) == 0) {
1323 spin_lock_irqsave(&ide_lock, flags);
Jens Axboe4f4f6c252008-01-31 13:57:51 +01001324 if (__blk_end_request(rq, 0, rq->data_len))
Kiyoshi Uedaaaa04c22007-12-11 17:51:23 -05001325 BUG();
1326 HWGROUP(drive)->rq = NULL;
1327 spin_unlock_irqrestore(&ide_lock, flags);
1328
1329 return ide_stopped;
1330 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331
1332 /*
1333 * check which way to transfer data
1334 */
1335 if (rq_data_dir(rq) == WRITE) {
1336 /*
1337 * write to drive
1338 */
1339 if (cdrom_write_check_ireason(drive, len, ireason))
1340 return ide_stopped;
1341
1342 xferfunc = HWIF(drive)->atapi_output_bytes;
1343 } else {
1344 /*
1345 * read from drive
1346 */
1347 if (cdrom_read_check_ireason(drive, len, ireason))
1348 return ide_stopped;
1349
1350 xferfunc = HWIF(drive)->atapi_input_bytes;
1351 }
1352
1353 /*
1354 * transfer data
1355 */
1356 while (thislen > 0) {
1357 int blen = blen = rq->data_len;
1358 char *ptr = rq->data;
1359
1360 /*
1361 * bio backed?
1362 */
1363 if (rq->bio) {
1364 ptr = bio_data(rq->bio);
1365 blen = bio_iovec(rq->bio)->bv_len;
1366 }
1367
1368 if (!ptr) {
1369 printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1370 break;
1371 }
1372
1373 if (blen > thislen)
1374 blen = thislen;
1375
1376 xferfunc(drive, ptr, blen);
1377
1378 thislen -= blen;
1379 len -= blen;
1380 rq->data_len -= blen;
1381
1382 if (rq->bio)
Kiyoshi Uedaaaa04c22007-12-11 17:51:23 -05001383 /*
1384 * The request can't be completed until DRQ is cleared.
1385 * So complete the data, but don't complete the request
1386 * using the dummy function for the callback feature
1387 * of blk_end_request_callback().
1388 */
1389 blk_end_request_callback(rq, 0, blen,
1390 cdrom_newpc_intr_dummy_cb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 else
1392 rq->data += blen;
1393 }
1394
1395 /*
1396 * pad, if necessary
1397 */
Bartlomiej Zolnierkiewicz5a5222d2008-02-01 23:09:17 +01001398 if (len > 0)
1399 ide_cd_pad_transfer(drive, xferfunc, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400
Eric Sesterhenn125e1872006-06-23 02:06:06 -07001401 BUG_ON(HWGROUP(drive)->handler != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402
1403 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1404 return ide_started;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405}
1406
1407static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1408{
1409 int stat, ireason, len, sectors_to_transfer, uptodate;
1410 struct cdrom_info *info = drive->driver_data;
1411 int dma_error = 0, dma = info->dma;
1412 u8 lowcyl = 0, highcyl = 0;
1413
1414 struct request *rq = HWGROUP(drive)->rq;
1415
1416 /* Check for errors. */
1417 if (dma) {
1418 info->dma = 0;
Bartlomiej Zolnierkiewiczb481b232007-12-24 15:23:43 +01001419 dma_error = HWIF(drive)->ide_dma_end(drive);
1420 if (dma_error) {
1421 printk(KERN_ERR "%s: DMA write error\n", drive->name);
Bartlomiej Zolnierkiewicz7469aaf2007-02-17 02:40:26 +01001422 ide_dma_off(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 }
1424 }
1425
1426 if (cdrom_decode_status(drive, 0, &stat))
1427 return ide_stopped;
1428
1429 /*
1430 * using dma, transfer is complete now
1431 */
1432 if (dma) {
1433 if (dma_error)
1434 return ide_error(drive, "dma error", stat);
1435
1436 ide_end_request(drive, 1, rq->nr_sectors);
1437 return ide_stopped;
1438 }
1439
1440 /* Read the interrupt reason and the transfer length. */
Bartlomiej Zolnierkiewicz31a71192007-12-24 15:23:43 +01001441 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1443 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1444
1445 len = lowcyl + (256 * highcyl);
1446
1447 /* If DRQ is clear, the command has completed. */
1448 if ((stat & DRQ_STAT) == 0) {
1449 /* If we're not done writing, complain.
1450 * Otherwise, complete the command normally.
1451 */
1452 uptodate = 1;
1453 if (rq->current_nr_sectors > 0) {
Bartlomiej Zolnierkiewiczb481b232007-12-24 15:23:43 +01001454 printk(KERN_ERR "%s: %s: data underrun (%d blocks)\n",
1455 drive->name, __FUNCTION__,
1456 rq->current_nr_sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 uptodate = 0;
1458 }
1459 cdrom_end_request(drive, uptodate);
1460 return ide_stopped;
1461 }
1462
1463 /* Check that the drive is expecting to do the same thing we are. */
1464 if (cdrom_write_check_ireason(drive, len, ireason))
1465 return ide_stopped;
1466
1467 sectors_to_transfer = len / SECTOR_SIZE;
1468
1469 /*
1470 * now loop and write out the data
1471 */
1472 while (sectors_to_transfer > 0) {
1473 int this_transfer;
1474
1475 if (!rq->current_nr_sectors) {
Bartlomiej Zolnierkiewiczb481b232007-12-24 15:23:43 +01001476 printk(KERN_ERR "%s: %s: confused, missing data\n",
1477 drive->name, __FUNCTION__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 break;
1479 }
1480
1481 /*
1482 * Figure out how many sectors we can transfer
1483 */
1484 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1485
1486 while (this_transfer > 0) {
1487 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1488 rq->buffer += SECTOR_SIZE;
1489 --rq->nr_sectors;
1490 --rq->current_nr_sectors;
1491 ++rq->sector;
1492 --this_transfer;
1493 --sectors_to_transfer;
1494 }
1495
1496 /*
1497 * current buffer complete, move on
1498 */
1499 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1500 cdrom_end_request(drive, 1);
1501 }
1502
1503 /* re-arm handler */
1504 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1505 return ide_started;
1506}
1507
1508static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1509{
1510 struct request *rq = HWGROUP(drive)->rq;
1511
1512#if 0 /* the immediate bit */
1513 rq->cmd[1] = 1 << 3;
1514#endif
1515 rq->timeout = ATAPI_WAIT_PC;
1516
1517 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1518}
1519
1520static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1521{
1522 struct cdrom_info *info = drive->driver_data;
1523 struct gendisk *g = info->disk;
1524 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1525
1526 /*
1527 * writes *must* be hardware frame aligned
1528 */
1529 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1530 (rq->sector & (sectors_per_frame - 1))) {
1531 cdrom_end_request(drive, 0);
1532 return ide_stopped;
1533 }
1534
1535 /*
1536 * disk has become write protected
1537 */
1538 if (g->policy) {
1539 cdrom_end_request(drive, 0);
1540 return ide_stopped;
1541 }
1542
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543 info->nsectors_buffered = 0;
1544
1545 /* use dma, if possible. we don't need to check more, since we
1546 * know that the transfer is always (at least!) frame aligned */
1547 info->dma = drive->using_dma ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548
1549 info->devinfo.media_written = 1;
1550
1551 /* Start sending the write request to the drive. */
1552 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1553}
1554
1555static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1556{
1557 struct request *rq = HWGROUP(drive)->rq;
1558
1559 if (!rq->timeout)
1560 rq->timeout = ATAPI_WAIT_PC;
1561
1562 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1563}
1564
1565static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1566{
1567 struct cdrom_info *info = drive->driver_data;
1568
Jens Axboe4aff5e22006-08-10 08:44:47 +02001569 rq->cmd_flags |= REQ_QUIET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570
1571 info->dma = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572
1573 /*
1574 * sg request
1575 */
1576 if (rq->bio) {
1577 int mask = drive->queue->dma_alignment;
1578 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1579
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 info->dma = drive->using_dma;
1581
1582 /*
1583 * check if dma is safe
Linus Torvalds5d9e4ea2005-05-27 07:36:17 -07001584 *
1585 * NOTE! The "len" and "addr" checks should possibly have
1586 * separate masks.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 */
Jens Axboe4e7c6812005-05-31 17:47:36 +02001588 if ((rq->data_len & 15) || (addr & mask))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 info->dma = 0;
1590 }
1591
1592 /* Start sending the command to the drive. */
1593 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1594}
1595
1596/****************************************************************************
1597 * cdrom driver request routine.
1598 */
1599static ide_startstop_t
1600ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1601{
1602 ide_startstop_t action;
1603 struct cdrom_info *info = drive->driver_data;
1604
1605 if (blk_fs_request(rq)) {
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001606 if (info->cd_flags & IDE_CD_FLAG_SEEKING) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 unsigned long elapsed = jiffies - info->start_seek;
1608 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1609
1610 if ((stat & SEEK_STAT) != SEEK_STAT) {
1611 if (elapsed < IDECD_SEEK_TIMEOUT) {
1612 ide_stall_queue(drive, IDECD_SEEK_TIMER);
1613 return ide_stopped;
1614 }
1615 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1616 }
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001617 info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 }
1619 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1620 action = cdrom_start_seek(drive, block);
1621 } else {
1622 if (rq_data_dir(rq) == READ)
1623 action = cdrom_start_read(drive, block);
1624 else
1625 action = cdrom_start_write(drive, rq);
1626 }
1627 info->last_block = block;
1628 return action;
Jens Axboecea28852006-10-12 15:08:45 +02001629 } else if (rq->cmd_type == REQ_TYPE_SENSE ||
1630 rq->cmd_type == REQ_TYPE_ATA_PC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 return cdrom_do_packet_command(drive);
Jens Axboe4aff5e22006-08-10 08:44:47 +02001632 } else if (blk_pc_request(rq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 return cdrom_do_block_pc(drive, rq);
Jens Axboe4aff5e22006-08-10 08:44:47 +02001634 } else if (blk_special_request(rq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 /*
1636 * right now this can only be a reset...
1637 */
1638 cdrom_end_request(drive, 1);
1639 return ide_stopped;
1640 }
1641
1642 blk_dump_rq_flags(rq, "ide-cd bad flags");
1643 cdrom_end_request(drive, 0);
1644 return ide_stopped;
1645}
1646
1647
1648
1649/****************************************************************************
1650 * Ioctl handling.
1651 *
1652 * Routines which queue packet commands take as a final argument a pointer
1653 * to a request_sense struct. If execution of the command results
1654 * in an error with a CHECK CONDITION status, this structure will be filled
1655 * with the results of the subsequent request sense command. The pointer
1656 * can also be NULL, in which case no sense information is returned.
1657 */
1658
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659static
1660void msf_from_bcd (struct atapi_msf *msf)
1661{
Bartlomiej Zolnierkiewicz9a6dc662008-02-01 23:09:22 +01001662 msf->minute = BCD2BIN(msf->minute);
1663 msf->second = BCD2BIN(msf->second);
1664 msf->frame = BCD2BIN(msf->frame);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665}
1666
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667static inline
1668void lba_to_msf (int lba, byte *m, byte *s, byte *f)
1669{
1670 lba += CD_MSF_OFFSET;
1671 lba &= 0xffffff; /* negative lbas use only 24 bits */
1672 *m = lba / (CD_SECS * CD_FRAMES);
1673 lba %= (CD_SECS * CD_FRAMES);
1674 *s = lba / CD_FRAMES;
1675 *f = lba % CD_FRAMES;
1676}
1677
1678
1679static inline
1680int msf_to_lba (byte m, byte s, byte f)
1681{
1682 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
1683}
1684
1685static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
1686{
1687 struct request req;
1688 struct cdrom_info *info = drive->driver_data;
1689 struct cdrom_device_info *cdi = &info->devinfo;
1690
1691 cdrom_prepare_request(drive, &req);
1692
1693 req.sense = sense;
1694 req.cmd[0] = GPCMD_TEST_UNIT_READY;
Jens Axboe4aff5e22006-08-10 08:44:47 +02001695 req.cmd_flags |= REQ_QUIET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696
Bartlomiej Zolnierkiewiczcdf60002008-02-01 23:09:22 +01001697 /*
1698 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1699 * switch CDs instead of supporting the LOAD_UNLOAD opcode.
1700 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 req.cmd[7] = cdi->sanyo_slot % 3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702
1703 return cdrom_queue_packet_command(drive, &req);
1704}
1705
1706
1707/* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
1708static int
1709cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
1710{
Bartlomiej Zolnierkiewicz4fe67172008-02-01 23:09:21 +01001711 struct cdrom_info *cd = drive->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 struct request_sense my_sense;
1713 struct request req;
1714 int stat;
1715
1716 if (sense == NULL)
1717 sense = &my_sense;
1718
1719 /* If the drive cannot lock the door, just pretend. */
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001720 if (cd->cd_flags & IDE_CD_FLAG_NO_DOORLOCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 stat = 0;
1722 } else {
1723 cdrom_prepare_request(drive, &req);
1724 req.sense = sense;
1725 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
1726 req.cmd[4] = lockflag ? 1 : 0;
1727 stat = cdrom_queue_packet_command(drive, &req);
1728 }
1729
1730 /* If we got an illegal field error, the drive
1731 probably cannot lock the door. */
1732 if (stat != 0 &&
1733 sense->sense_key == ILLEGAL_REQUEST &&
1734 (sense->asc == 0x24 || sense->asc == 0x20)) {
1735 printk (KERN_ERR "%s: door locking not supported\n",
1736 drive->name);
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001737 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 stat = 0;
1739 }
1740
1741 /* no medium, that's alright. */
1742 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
1743 stat = 0;
1744
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001745 if (stat == 0) {
1746 if (lockflag)
1747 cd->cd_flags |= IDE_CD_FLAG_DOOR_LOCKED;
1748 else
1749 cd->cd_flags &= ~IDE_CD_FLAG_DOOR_LOCKED;
1750 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751
1752 return stat;
1753}
1754
1755
1756/* Eject the disk if EJECTFLAG is 0.
1757 If EJECTFLAG is 1, try to reload the disk. */
1758static int cdrom_eject(ide_drive_t *drive, int ejectflag,
1759 struct request_sense *sense)
1760{
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01001761 struct cdrom_info *cd = drive->driver_data;
1762 struct cdrom_device_info *cdi = &cd->devinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763 struct request req;
1764 char loej = 0x02;
1765
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001766 if ((cd->cd_flags & IDE_CD_FLAG_NO_EJECT) && !ejectflag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 return -EDRIVE_CANT_DO_THIS;
Bartlomiej Zolnierkiewicz4fe67172008-02-01 23:09:21 +01001768
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 /* reload fails on some drives, if the tray is locked */
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001770 if ((cd->cd_flags & IDE_CD_FLAG_DOOR_LOCKED) && ejectflag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 return 0;
1772
1773 cdrom_prepare_request(drive, &req);
1774
1775 /* only tell drive to close tray if open, if it can do that */
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01001776 if (ejectflag && (cdi->mask & CDC_CLOSE_TRAY))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 loej = 0;
1778
1779 req.sense = sense;
1780 req.cmd[0] = GPCMD_START_STOP_UNIT;
1781 req.cmd[4] = loej | (ejectflag != 0);
1782 return cdrom_queue_packet_command(drive, &req);
1783}
1784
1785static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
1786 unsigned long *sectors_per_frame,
1787 struct request_sense *sense)
1788{
1789 struct {
1790 __u32 lba;
1791 __u32 blocklen;
1792 } capbuf;
1793
1794 int stat;
1795 struct request req;
1796
1797 cdrom_prepare_request(drive, &req);
1798
1799 req.sense = sense;
1800 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
1801 req.data = (char *)&capbuf;
1802 req.data_len = sizeof(capbuf);
Jens Axboe4aff5e22006-08-10 08:44:47 +02001803 req.cmd_flags |= REQ_QUIET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804
1805 stat = cdrom_queue_packet_command(drive, &req);
1806 if (stat == 0) {
1807 *capacity = 1 + be32_to_cpu(capbuf.lba);
1808 *sectors_per_frame =
1809 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
1810 }
1811
1812 return stat;
1813}
1814
1815static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
1816 int format, char *buf, int buflen,
1817 struct request_sense *sense)
1818{
1819 struct request req;
1820
1821 cdrom_prepare_request(drive, &req);
1822
1823 req.sense = sense;
1824 req.data = buf;
1825 req.data_len = buflen;
Jens Axboe4aff5e22006-08-10 08:44:47 +02001826 req.cmd_flags |= REQ_QUIET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
1828 req.cmd[6] = trackno;
1829 req.cmd[7] = (buflen >> 8);
1830 req.cmd[8] = (buflen & 0xff);
1831 req.cmd[9] = (format << 6);
1832
1833 if (msf_flag)
1834 req.cmd[1] = 2;
1835
1836 return cdrom_queue_packet_command(drive, &req);
1837}
1838
1839
1840/* Try to read the entire TOC for the disk into our internal buffer. */
1841static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
1842{
1843 int stat, ntracks, i;
1844 struct cdrom_info *info = drive->driver_data;
1845 struct cdrom_device_info *cdi = &info->devinfo;
1846 struct atapi_toc *toc = info->toc;
1847 struct {
1848 struct atapi_toc_header hdr;
1849 struct atapi_toc_entry ent;
1850 } ms_tmp;
1851 long last_written;
1852 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
1853
1854 if (toc == NULL) {
1855 /* Try to allocate space. */
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08001856 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 if (toc == NULL) {
1858 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
1859 return -ENOMEM;
1860 }
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08001861 info->toc = toc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 }
1863
1864 /* Check to see if the existing data is still valid.
1865 If it is, just return. */
1866 (void) cdrom_check_status(drive, sense);
1867
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001868 if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 return 0;
1870
1871 /* Try to get the total cdrom capacity and sector size. */
1872 stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
1873 sense);
1874 if (stat)
1875 toc->capacity = 0x1fffff;
1876
1877 set_capacity(info->disk, toc->capacity * sectors_per_frame);
Alan Coxdbe217a2006-06-25 05:47:44 -07001878 /* Save a private copy of te TOC capacity for error handling */
1879 drive->probed_capacity = toc->capacity * sectors_per_frame;
1880
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881 blk_queue_hardsect_size(drive->queue,
1882 sectors_per_frame << SECTOR_BITS);
1883
1884 /* First read just the header, so we know how long the TOC is. */
1885 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
1886 sizeof(struct atapi_toc_header), sense);
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08001887 if (stat)
1888 return stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001890 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
Bartlomiej Zolnierkiewicz9a6dc662008-02-01 23:09:22 +01001891 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1892 toc->hdr.last_track = BCD2BIN(toc->hdr.last_track);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894
1895 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1896 if (ntracks <= 0)
1897 return -EIO;
1898 if (ntracks > MAX_TRACKS)
1899 ntracks = MAX_TRACKS;
1900
1901 /* Now read the whole schmeer. */
1902 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
1903 (char *)&toc->hdr,
1904 sizeof(struct atapi_toc_header) +
1905 (ntracks + 1) *
1906 sizeof(struct atapi_toc_entry), sense);
1907
1908 if (stat && toc->hdr.first_track > 1) {
1909 /* Cds with CDI tracks only don't have any TOC entries,
1910 despite of this the returned values are
1911 first_track == last_track = number of CDI tracks + 1,
1912 so that this case is indistinguishable from the same
1913 layout plus an additional audio track.
1914 If we get an error for the regular case, we assume
1915 a CDI without additional audio tracks. In this case
1916 the readable TOC is empty (CDI tracks are not included)
Jan Engelhardt96de0e22007-10-19 23:21:04 +02001917 and only holds the Leadout entry. Heiko Eißfeldt */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 ntracks = 0;
1919 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
1920 (char *)&toc->hdr,
1921 sizeof(struct atapi_toc_header) +
1922 (ntracks + 1) *
1923 sizeof(struct atapi_toc_entry),
1924 sense);
Bartlomiej Zolnierkiewiczcdf60002008-02-01 23:09:22 +01001925 if (stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 return stat;
Bartlomiej Zolnierkiewiczcdf60002008-02-01 23:09:22 +01001927
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001928 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
Bartlomiej Zolnierkiewicz9a6dc662008-02-01 23:09:22 +01001929 toc->hdr.first_track = (u8)BIN2BCD(CDROM_LEADOUT);
1930 toc->hdr.last_track = (u8)BIN2BCD(CDROM_LEADOUT);
Bartlomiej Zolnierkiewiczcdf60002008-02-01 23:09:22 +01001931 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 toc->hdr.first_track = CDROM_LEADOUT;
1933 toc->hdr.last_track = CDROM_LEADOUT;
1934 }
1935 }
1936
1937 if (stat)
1938 return stat;
1939
1940 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
1941
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001942 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
Bartlomiej Zolnierkiewicz9a6dc662008-02-01 23:09:22 +01001943 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1944 toc->hdr.last_track = BCD2BIN(toc->hdr.last_track);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946
Bartlomiej Zolnierkiewiczcdf60002008-02-01 23:09:22 +01001947 for (i = 0; i <= ntracks; i++) {
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001948 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1949 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD)
Bartlomiej Zolnierkiewicz9a6dc662008-02-01 23:09:22 +01001950 toc->ent[i].track = BCD2BIN(toc->ent[i].track);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 msf_from_bcd(&toc->ent[i].addr.msf);
1952 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
1954 toc->ent[i].addr.msf.second,
1955 toc->ent[i].addr.msf.frame);
1956 }
1957
1958 /* Read the multisession information. */
1959 if (toc->hdr.first_track != CDROM_LEADOUT) {
1960 /* Read the multisession information. */
1961 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
1962 sizeof(ms_tmp), sense);
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08001963 if (stat)
1964 return stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965
1966 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
1967 } else {
1968 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
1969 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
1970 }
1971
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001972 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 /* Re-read multisession information using MSF format */
1974 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
1975 sizeof(ms_tmp), sense);
1976 if (stat)
1977 return stat;
1978
1979 msf_from_bcd (&ms_tmp.ent.addr.msf);
1980 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1981 ms_tmp.ent.addr.msf.second,
1982 ms_tmp.ent.addr.msf.frame);
1983 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984
1985 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
1986
1987 /* Now try to get the total cdrom capacity. */
1988 stat = cdrom_get_last_written(cdi, &last_written);
1989 if (!stat && (last_written > toc->capacity)) {
1990 toc->capacity = last_written;
1991 set_capacity(info->disk, toc->capacity * sectors_per_frame);
Alan Coxdbe217a2006-06-25 05:47:44 -07001992 drive->probed_capacity = toc->capacity * sectors_per_frame;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 }
1994
1995 /* Remember that we've read this stuff. */
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01001996 info->cd_flags |= IDE_CD_FLAG_TOC_VALID;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997
1998 return 0;
1999}
2000
Bartlomiej Zolnierkiewiczba3fab22008-02-01 23:09:23 +01002001static int ide_cd_read_tochdr(ide_drive_t *drive, void *arg)
2002{
2003 struct cdrom_info *cd = drive->driver_data;
2004 struct cdrom_tochdr *tochdr = arg;
2005 struct atapi_toc *toc;
2006 int stat;
2007
2008 /* Make sure our saved TOC is valid. */
2009 stat = cdrom_read_toc(drive, NULL);
2010 if (stat)
2011 return stat;
2012
2013 toc = cd->toc;
2014 tochdr->cdth_trk0 = toc->hdr.first_track;
2015 tochdr->cdth_trk1 = toc->hdr.last_track;
2016
2017 return 0;
2018}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020/* ATAPI cdrom drives are free to select the speed you request or any slower
2021 rate :-( Requesting too fast a speed will _not_ produce an error. */
2022static int cdrom_select_speed(ide_drive_t *drive, int speed,
2023 struct request_sense *sense)
2024{
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002025 struct cdrom_info *cd = drive->driver_data;
2026 struct cdrom_device_info *cdi = &cd->devinfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 struct request req;
2028 cdrom_prepare_request(drive, &req);
2029
2030 req.sense = sense;
2031 if (speed == 0)
2032 speed = 0xffff; /* set to max */
2033 else
2034 speed *= 177; /* Nx to kbytes/s */
2035
2036 req.cmd[0] = GPCMD_SET_SPEED;
2037 /* Read Drive speed in kbytes/second MSB */
2038 req.cmd[2] = (speed >> 8) & 0xff;
2039 /* Read Drive speed in kbytes/second LSB */
2040 req.cmd[3] = speed & 0xff;
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002041 if ((cdi->mask & (CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) !=
2042 (CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 /* Write Drive speed in kbytes/second MSB */
2044 req.cmd[4] = (speed >> 8) & 0xff;
2045 /* Write Drive speed in kbytes/second LSB */
2046 req.cmd[5] = speed & 0xff;
2047 }
2048
2049 return cdrom_queue_packet_command(drive, &req);
2050}
2051
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2053 struct atapi_toc_entry **ent)
2054{
2055 struct cdrom_info *info = drive->driver_data;
2056 struct atapi_toc *toc = info->toc;
2057 int ntracks;
2058
2059 /*
2060 * don't serve cached data, if the toc isn't valid
2061 */
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002062 if ((info->cd_flags & IDE_CD_FLAG_TOC_VALID) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 return -EINVAL;
2064
2065 /* Check validity of requested track number. */
2066 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2067 if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2068 if (track == CDROM_LEADOUT)
2069 *ent = &toc->ent[ntracks];
2070 else if (track < toc->hdr.first_track ||
2071 track > toc->hdr.last_track)
2072 return -EINVAL;
2073 else
2074 *ent = &toc->ent[track - toc->hdr.first_track];
2075
2076 return 0;
2077}
2078
Bartlomiej Zolnierkiewiczba3fab22008-02-01 23:09:23 +01002079static int ide_cd_read_tocentry(ide_drive_t *drive, void *arg)
2080{
2081 struct cdrom_tocentry *tocentry = arg;
2082 struct atapi_toc_entry *toce;
2083 int stat;
2084
2085 stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2086 if (stat)
2087 return stat;
2088
2089 tocentry->cdte_ctrl = toce->control;
2090 tocentry->cdte_adr = toce->adr;
2091 if (tocentry->cdte_format == CDROM_MSF) {
2092 lba_to_msf(toce->addr.lba,
2093 &tocentry->cdte_addr.msf.minute,
2094 &tocentry->cdte_addr.msf.second,
2095 &tocentry->cdte_addr.msf.frame);
2096 } else
2097 tocentry->cdte_addr.lba = toce->addr.lba;
2098
2099 return 0;
2100}
2101
2102static int ide_cd_fake_play_trkind(ide_drive_t *drive, void *arg)
2103{
2104 struct cdrom_ti *ti = arg;
2105 struct atapi_toc_entry *first_toc, *last_toc;
2106 unsigned long lba_start, lba_end;
2107 int stat;
Bartlomiej Zolnierkiewicza891b142008-02-01 23:09:23 +01002108 struct request rq;
2109 struct request_sense sense;
Bartlomiej Zolnierkiewiczba3fab22008-02-01 23:09:23 +01002110
2111 stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2112 if (stat)
2113 return stat;
2114
2115 stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2116 if (stat)
2117 return stat;
2118
2119 if (ti->cdti_trk1 != CDROM_LEADOUT)
2120 ++last_toc;
2121 lba_start = first_toc->addr.lba;
2122 lba_end = last_toc->addr.lba;
2123
2124 if (lba_end <= lba_start)
2125 return -EINVAL;
2126
Bartlomiej Zolnierkiewicza891b142008-02-01 23:09:23 +01002127 cdrom_prepare_request(drive, &rq);
2128
2129 rq.sense = &sense;
2130 rq.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2131 lba_to_msf(lba_start, &rq.cmd[3], &rq.cmd[4], &rq.cmd[5]);
2132 lba_to_msf(lba_end - 1, &rq.cmd[6], &rq.cmd[7], &rq.cmd[8]);
2133
2134 return cdrom_queue_packet_command(drive, &rq);
Bartlomiej Zolnierkiewiczba3fab22008-02-01 23:09:23 +01002135}
2136
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137/* the generic packet interface to cdrom.c */
2138static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2139 struct packet_command *cgc)
2140{
2141 struct request req;
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002142 ide_drive_t *drive = cdi->handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143
2144 if (cgc->timeout <= 0)
2145 cgc->timeout = ATAPI_WAIT_PC;
2146
2147 /* here we queue the commands from the uniform CD-ROM
2148 layer. the packet must be complete, as we do not
2149 touch it at all. */
2150 cdrom_prepare_request(drive, &req);
2151 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2152 if (cgc->sense)
2153 memset(cgc->sense, 0, sizeof(struct request_sense));
2154 req.data = cgc->buffer;
2155 req.data_len = cgc->buflen;
2156 req.timeout = cgc->timeout;
2157
2158 if (cgc->quiet)
Jens Axboe4aff5e22006-08-10 08:44:47 +02002159 req.cmd_flags |= REQ_QUIET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160
2161 req.sense = cgc->sense;
2162 cgc->stat = cdrom_queue_packet_command(drive, &req);
2163 if (!cgc->stat)
2164 cgc->buflen -= req.data_len;
2165 return cgc->stat;
2166}
2167
Bartlomiej Zolnierkiewiczba3fab22008-02-01 23:09:23 +01002168static int ide_cdrom_audio_ioctl(struct cdrom_device_info *cdi,
2169 unsigned int cmd, void *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170{
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002171 ide_drive_t *drive = cdi->handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172
2173 switch (cmd) {
2174 /*
2175 * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2176 * atapi doesn't support it
2177 */
Bartlomiej Zolnierkiewiczba3fab22008-02-01 23:09:23 +01002178 case CDROMPLAYTRKIND:
2179 return ide_cd_fake_play_trkind(drive, arg);
2180 case CDROMREADTOCHDR:
2181 return ide_cd_read_tochdr(drive, arg);
2182 case CDROMREADTOCENTRY:
2183 return ide_cd_read_tocentry(drive, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184 default:
2185 return -EINVAL;
2186 }
2187}
2188
2189static
2190int ide_cdrom_reset (struct cdrom_device_info *cdi)
2191{
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002192 ide_drive_t *drive = cdi->handle;
Bartlomiej Zolnierkiewicz0ba11212008-02-01 23:09:21 +01002193 struct cdrom_info *cd = drive->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194 struct request_sense sense;
2195 struct request req;
2196 int ret;
2197
2198 cdrom_prepare_request(drive, &req);
Jens Axboe4aff5e22006-08-10 08:44:47 +02002199 req.cmd_type = REQ_TYPE_SPECIAL;
2200 req.cmd_flags = REQ_QUIET;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201 ret = ide_do_drive_cmd(drive, &req, ide_wait);
2202
2203 /*
2204 * A reset will unlock the door. If it was previously locked,
2205 * lock it again.
2206 */
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002207 if (cd->cd_flags & IDE_CD_FLAG_DOOR_LOCKED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 (void) cdrom_lockdoor(drive, 1, &sense);
2209
2210 return ret;
2211}
2212
2213
2214static
2215int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2216{
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002217 ide_drive_t *drive = cdi->handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218 struct request_sense sense;
2219
2220 if (position) {
2221 int stat = cdrom_lockdoor(drive, 0, &sense);
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002222 if (stat)
2223 return stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002224 }
2225
2226 return cdrom_eject(drive, !position, &sense);
2227}
2228
2229static
2230int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2231{
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002232 ide_drive_t *drive = cdi->handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 return cdrom_lockdoor(drive, lock, NULL);
2234}
2235
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002236static int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
Eric Piel9235e682005-06-23 00:10:29 -07002237{
2238 struct cdrom_info *info = drive->driver_data;
2239 struct cdrom_device_info *cdi = &info->devinfo;
2240 struct packet_command cgc;
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002241 int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
Eric Piel9235e682005-06-23 00:10:29 -07002242
Bartlomiej Zolnierkiewicze59724c2008-02-01 23:09:22 +01002243 if ((info->cd_flags & IDE_CD_FLAG_FULL_CAPS_PAGE) == 0)
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002244 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
Eric Piel9235e682005-06-23 00:10:29 -07002245
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002246 init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
Eric Piel9235e682005-06-23 00:10:29 -07002247 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2248 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2249 if (!stat)
2250 break;
2251 } while (--attempts);
2252 return stat;
2253}
2254
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002255static void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
Eric Piel9235e682005-06-23 00:10:29 -07002256{
Bartlomiej Zolnierkiewicz4fe67172008-02-01 23:09:21 +01002257 struct cdrom_info *cd = drive->driver_data;
Bartlomiej Zolnierkiewicz481c8c62008-02-01 23:09:20 +01002258 u16 curspeed, maxspeed;
2259
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002260 curspeed = *(u16 *)&buf[8 + 14];
2261 maxspeed = *(u16 *)&buf[8 + 8];
2262
Bartlomiej Zolnierkiewicze59724c2008-02-01 23:09:22 +01002263 if (cd->cd_flags & IDE_CD_FLAG_LE_SPEED_FIELDS) {
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002264 curspeed = le16_to_cpu(curspeed);
2265 maxspeed = le16_to_cpu(maxspeed);
Eric Piel9235e682005-06-23 00:10:29 -07002266 } else {
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002267 curspeed = be16_to_cpu(curspeed);
2268 maxspeed = be16_to_cpu(maxspeed);
Eric Piel9235e682005-06-23 00:10:29 -07002269 }
Bartlomiej Zolnierkiewicz481c8c62008-02-01 23:09:20 +01002270
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002271 cd->current_speed = (curspeed + (176/2)) / 176;
2272 cd->max_speed = (maxspeed + (176/2)) / 176;
Eric Piel9235e682005-06-23 00:10:29 -07002273}
2274
2275static
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276int ide_cdrom_select_speed (struct cdrom_device_info *cdi, int speed)
2277{
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002278 ide_drive_t *drive = cdi->handle;
Bartlomiej Zolnierkiewicz0ba11212008-02-01 23:09:21 +01002279 struct cdrom_info *cd = drive->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280 struct request_sense sense;
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002281 u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 int stat;
2283
2284 if ((stat = cdrom_select_speed(drive, speed, &sense)) < 0)
2285 return stat;
2286
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002287 if (!ide_cdrom_get_capabilities(drive, buf)) {
2288 ide_cdrom_update_speed(drive, buf);
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002289 cdi->speed = cd->current_speed;
Eric Piel9235e682005-06-23 00:10:29 -07002290 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 return 0;
2292}
2293
2294/*
2295 * add logic to try GET_EVENT command first to check for media and tray
2296 * status. this should be supported by newer cd-r/w and all DVD etc
2297 * drives
2298 */
2299static
2300int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2301{
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002302 ide_drive_t *drive = cdi->handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303 struct media_event_desc med;
2304 struct request_sense sense;
2305 int stat;
2306
2307 if (slot_nr != CDSL_CURRENT)
2308 return -EINVAL;
2309
2310 stat = cdrom_check_status(drive, &sense);
2311 if (!stat || sense.sense_key == UNIT_ATTENTION)
2312 return CDS_DISC_OK;
2313
2314 if (!cdrom_get_media_event(cdi, &med)) {
2315 if (med.media_present)
2316 return CDS_DISC_OK;
2317 else if (med.door_open)
2318 return CDS_TRAY_OPEN;
2319 else
2320 return CDS_NO_DISC;
2321 }
2322
2323 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2324 return CDS_DISC_OK;
2325
2326 /*
2327 * If not using Mt Fuji extended media tray reports,
2328 * just return TRAY_OPEN since ATAPI doesn't provide
2329 * any other way to detect this...
2330 */
2331 if (sense.sense_key == NOT_READY) {
Alan Coxdbe217a2006-06-25 05:47:44 -07002332 if (sense.asc == 0x3a && sense.ascq == 1)
2333 return CDS_NO_DISC;
2334 else
2335 return CDS_TRAY_OPEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337 return CDS_DRIVE_NOT_READY;
2338}
2339
2340static
2341int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2342 struct cdrom_multisession *ms_info)
2343{
2344 struct atapi_toc *toc;
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002345 ide_drive_t *drive = cdi->handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346 struct cdrom_info *info = drive->driver_data;
2347 struct request_sense sense;
2348 int ret;
2349
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002350 if ((info->cd_flags & IDE_CD_FLAG_TOC_VALID) == 0 || info->toc == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351 if ((ret = cdrom_read_toc(drive, &sense)))
2352 return ret;
2353
2354 toc = info->toc;
2355 ms_info->addr.lba = toc->last_session_lba;
2356 ms_info->xa_flag = toc->xa_flag;
2357
2358 return 0;
2359}
2360
Bartlomiej Zolnierkiewicz53126b92008-02-01 23:09:24 +01002361static int ide_cdrom_get_mcn(struct cdrom_device_info *cdi,
2362 struct cdrom_mcn *mcn_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363{
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002364 ide_drive_t *drive = cdi->handle;
Bartlomiej Zolnierkiewicz53126b92008-02-01 23:09:24 +01002365 int stat, mcnlen;
2366 struct request rq;
2367 char buf[24];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368
Bartlomiej Zolnierkiewicz53126b92008-02-01 23:09:24 +01002369 cdrom_prepare_request(drive, &rq);
2370
2371 rq.data = buf;
2372 rq.data_len = sizeof(buf);
2373
2374 rq.cmd[0] = GPCMD_READ_SUBCHANNEL;
2375 rq.cmd[1] = 2; /* MSF addressing */
2376 rq.cmd[2] = 0x40; /* request subQ data */
2377 rq.cmd[3] = 2; /* format */
2378 rq.cmd[8] = sizeof(buf);
2379
2380 stat = cdrom_queue_packet_command(drive, &rq);
2381 if (stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002382 return stat;
2383
Bartlomiej Zolnierkiewicz53126b92008-02-01 23:09:24 +01002384 mcnlen = sizeof(mcn_info->medium_catalog_number) - 1;
2385 memcpy(mcn_info->medium_catalog_number, buf + 9, mcnlen);
2386 mcn_info->medium_catalog_number[mcnlen] = '\0';
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387
2388 return 0;
2389}
2390
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391/****************************************************************************
2392 * Other driver requests (open, close, check media change).
2393 */
2394
2395static
2396int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2397 int slot_nr)
2398{
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002399 ide_drive_t *drive = cdi->handle;
Bartlomiej Zolnierkiewicz0ba11212008-02-01 23:09:21 +01002400 struct cdrom_info *cd = drive->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 int retval;
Bartlomiej Zolnierkiewicz0ba11212008-02-01 23:09:21 +01002402
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403 if (slot_nr == CDSL_CURRENT) {
2404 (void) cdrom_check_status(drive, NULL);
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002405 retval = (cd->cd_flags & IDE_CD_FLAG_MEDIA_CHANGED) ? 1 : 0;
2406 cd->cd_flags &= ~IDE_CD_FLAG_MEDIA_CHANGED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407 return retval;
2408 } else {
2409 return -EINVAL;
2410 }
2411}
2412
2413
2414static
2415int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2416{
2417 return 0;
2418}
2419
2420/*
2421 * Close down the device. Invalidate all cached blocks.
2422 */
2423
2424static
2425void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2426{
2427 ide_drive_t *drive = cdi->handle;
Bartlomiej Zolnierkiewicz0ba11212008-02-01 23:09:21 +01002428 struct cdrom_info *cd = drive->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429
2430 if (!cdi->use_count)
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002431 cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432}
2433
Bartlomiej Zolnierkiewicz20e7f7e2008-02-01 23:09:20 +01002434#define IDE_CD_CAPABILITIES \
2435 (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
2436 CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
2437 CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
2438 CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
2439 CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440
Linus Torvalds1da177e2005-04-16 15:20:36 -07002441static struct cdrom_device_ops ide_cdrom_dops = {
2442 .open = ide_cdrom_open_real,
2443 .release = ide_cdrom_release_real,
2444 .drive_status = ide_cdrom_drive_status,
2445 .media_changed = ide_cdrom_check_media_change_real,
2446 .tray_move = ide_cdrom_tray_move,
2447 .lock_door = ide_cdrom_lock_door,
2448 .select_speed = ide_cdrom_select_speed,
2449 .get_last_session = ide_cdrom_get_last_session,
2450 .get_mcn = ide_cdrom_get_mcn,
2451 .reset = ide_cdrom_reset,
2452 .audio_ioctl = ide_cdrom_audio_ioctl,
Bartlomiej Zolnierkiewicz20e7f7e2008-02-01 23:09:20 +01002453 .capability = IDE_CD_CAPABILITIES,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454 .generic_packet = ide_cdrom_packet,
2455};
2456
2457static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2458{
2459 struct cdrom_info *info = drive->driver_data;
2460 struct cdrom_device_info *devinfo = &info->devinfo;
2461
2462 devinfo->ops = &ide_cdrom_dops;
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002463 devinfo->speed = info->current_speed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464 devinfo->capacity = nslots;
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002465 devinfo->handle = drive;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002466 strcpy(devinfo->name, drive->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002468 if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT)
Bartlomiej Zolnierkiewicz3cbd8142007-12-24 15:23:43 +01002469 devinfo->mask |= CDC_SELECT_SPEED;
2470
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 devinfo->disk = info->disk;
2472 return register_cdrom(devinfo);
2473}
2474
2475static
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2477{
Bartlomiej Zolnierkiewicz4fe67172008-02-01 23:09:21 +01002478 struct cdrom_info *cd = drive->driver_data;
2479 struct cdrom_device_info *cdi = &cd->devinfo;
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002480 u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
2481 mechtype_t mechtype;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002482 int nslots = 1;
2483
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002484 cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
2485 CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO |
2486 CDC_MO_DRIVE | CDC_RAM);
2487
Linus Torvalds1da177e2005-04-16 15:20:36 -07002488 if (drive->media == ide_optical) {
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002489 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2491 return nslots;
2492 }
2493
Bartlomiej Zolnierkiewicze59724c2008-02-01 23:09:22 +01002494 if (cd->cd_flags & IDE_CD_FLAG_PRE_ATAPI12) {
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002495 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002496 cdi->mask &= ~CDC_PLAY_AUDIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497 return nslots;
2498 }
2499
2500 /*
2501 * we have to cheat a little here. the packet will eventually
2502 * be queued with ide_cdrom_packet(), which extracts the
2503 * drive from cdi->handle. Since this device hasn't been
2504 * registered with the Uniform layer yet, it can't do this.
2505 * Same goes for cdi->ops.
2506 */
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002507 cdi->handle = drive;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002508 cdi->ops = &ide_cdrom_dops;
2509
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002510 if (ide_cdrom_get_capabilities(drive, buf))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511 return 0;
2512
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002513 if ((buf[8 + 6] & 0x01) == 0)
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002514 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002515 if (buf[8 + 6] & 0x08)
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002516 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002517 if (buf[8 + 3] & 0x01)
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002518 cdi->mask &= ~CDC_CD_R;
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002519 if (buf[8 + 3] & 0x02)
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002520 cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002521 if (buf[8 + 2] & 0x38)
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002522 cdi->mask &= ~CDC_DVD;
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002523 if (buf[8 + 3] & 0x20)
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002524 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002525 if (buf[8 + 3] & 0x10)
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002526 cdi->mask &= ~CDC_DVD_R;
Bartlomiej Zolnierkiewicze59724c2008-02-01 23:09:22 +01002527 if ((buf[8 + 4] & 0x01) || (cd->cd_flags & IDE_CD_FLAG_PLAY_AUDIO_OK))
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002528 cdi->mask &= ~CDC_PLAY_AUDIO;
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002529
2530 mechtype = buf[8 + 6] >> 5;
2531 if (mechtype == mechtype_caddy || mechtype == mechtype_popup)
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002532 cdi->mask |= CDC_CLOSE_TRAY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002533
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534 if (cdi->sanyo_slot > 0) {
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002535 cdi->mask &= ~CDC_SELECT_DISC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536 nslots = 3;
Bartlomiej Zolnierkiewiczcdf60002008-02-01 23:09:22 +01002537 } else if (mechtype == mechtype_individual_changer ||
2538 mechtype == mechtype_cartridge_changer) {
Bartlomiej Zolnierkiewicz2609d062008-02-01 23:09:19 +01002539 nslots = cdrom_number_of_slots(cdi);
2540 if (nslots > 1)
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002541 cdi->mask &= ~CDC_SELECT_DISC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542 }
2543
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002544 ide_cdrom_update_speed(drive, buf);
Bartlomiej Zolnierkiewicz4fe67172008-02-01 23:09:21 +01002545
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546 printk(KERN_INFO "%s: ATAPI", drive->name);
Bartlomiej Zolnierkiewicz4fe67172008-02-01 23:09:21 +01002547
2548 /* don't print speed if the drive reported 0 */
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002549 if (cd->max_speed)
2550 printk(KERN_CONT " %dX", cd->max_speed);
Bartlomiej Zolnierkiewicz4fe67172008-02-01 23:09:21 +01002551
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002552 printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002554 if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
2555 printk(KERN_CONT " DVD%s%s",
2556 (cdi->mask & CDC_DVD_R) ? "" : "-R",
2557 (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002559 if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
2560 printk(KERN_CONT " CD%s%s",
2561 (cdi->mask & CDC_CD_R) ? "" : "-R",
2562 (cdi->mask & CDC_CD_RW) ? "" : "/RW");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563
Bartlomiej Zolnierkiewicz3f1b86d2008-02-01 23:09:20 +01002564 if ((cdi->mask & CDC_SELECT_DISC) == 0)
2565 printk(KERN_CONT " changer w/%d slots", nslots);
2566 else
2567 printk(KERN_CONT " drive");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568
Bartlomiej Zolnierkiewicz455d80a2008-02-01 23:09:21 +01002569 printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12]));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570
2571 return nslots;
2572}
2573
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02002574#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575static void ide_cdrom_add_settings(ide_drive_t *drive)
2576{
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +02002577 ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002578}
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02002579#else
2580static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
2581#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582
2583/*
2584 * standard prep_rq_fn that builds 10 byte cmds
2585 */
Jens Axboe165125e2007-07-24 09:28:11 +02002586static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002587{
2588 int hard_sect = queue_hardsect_size(q);
2589 long block = (long)rq->hard_sector / (hard_sect >> 9);
2590 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
2591
2592 memset(rq->cmd, 0, sizeof(rq->cmd));
2593
2594 if (rq_data_dir(rq) == READ)
2595 rq->cmd[0] = GPCMD_READ_10;
2596 else
2597 rq->cmd[0] = GPCMD_WRITE_10;
2598
2599 /*
2600 * fill in lba
2601 */
2602 rq->cmd[2] = (block >> 24) & 0xff;
2603 rq->cmd[3] = (block >> 16) & 0xff;
2604 rq->cmd[4] = (block >> 8) & 0xff;
2605 rq->cmd[5] = block & 0xff;
2606
2607 /*
2608 * and transfer length
2609 */
2610 rq->cmd[7] = (blocks >> 8) & 0xff;
2611 rq->cmd[8] = blocks & 0xff;
2612 rq->cmd_len = 10;
2613 return BLKPREP_OK;
2614}
2615
2616/*
2617 * Most of the SCSI commands are supported directly by ATAPI devices.
2618 * This transform handles the few exceptions.
2619 */
2620static int ide_cdrom_prep_pc(struct request *rq)
2621{
2622 u8 *c = rq->cmd;
2623
2624 /*
2625 * Transform 6-byte read/write commands to the 10-byte version
2626 */
2627 if (c[0] == READ_6 || c[0] == WRITE_6) {
2628 c[8] = c[4];
2629 c[5] = c[3];
2630 c[4] = c[2];
2631 c[3] = c[1] & 0x1f;
2632 c[2] = 0;
2633 c[1] &= 0xe0;
2634 c[0] += (READ_10 - READ_6);
2635 rq->cmd_len = 10;
2636 return BLKPREP_OK;
2637 }
2638
2639 /*
2640 * it's silly to pretend we understand 6-byte sense commands, just
2641 * reject with ILLEGAL_REQUEST and the caller should take the
2642 * appropriate action
2643 */
2644 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
2645 rq->errors = ILLEGAL_REQUEST;
2646 return BLKPREP_KILL;
2647 }
2648
2649 return BLKPREP_OK;
2650}
2651
Jens Axboe165125e2007-07-24 09:28:11 +02002652static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653{
Jens Axboe4aff5e22006-08-10 08:44:47 +02002654 if (blk_fs_request(rq))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002655 return ide_cdrom_prep_fs(q, rq);
Jens Axboe4aff5e22006-08-10 08:44:47 +02002656 else if (blk_pc_request(rq))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657 return ide_cdrom_prep_pc(rq);
2658
2659 return 0;
2660}
2661
Bartlomiej Zolnierkiewicze59724c2008-02-01 23:09:22 +01002662struct cd_list_entry {
2663 const char *id_model;
2664 const char *id_firmware;
2665 unsigned int cd_flags;
2666};
2667
2668static const struct cd_list_entry ide_cd_quirks_list[] = {
2669 /* Limit transfer size per interrupt. */
2670 { "SAMSUNG CD-ROM SCR-2430", NULL, IDE_CD_FLAG_LIMIT_NFRAMES },
2671 { "SAMSUNG CD-ROM SCR-2432", NULL, IDE_CD_FLAG_LIMIT_NFRAMES },
2672 /* SCR-3231 doesn't support the SET_CD_SPEED command. */
2673 { "SAMSUNG CD-ROM SCR-3231", NULL, IDE_CD_FLAG_NO_SPEED_SELECT },
2674 /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
2675 { "NEC CD-ROM DRIVE:260", "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD |
2676 IDE_CD_FLAG_PRE_ATAPI12, },
2677 /* Vertos 300, some versions of this drive like to talk BCD. */
2678 { "V003S0DS", NULL, IDE_CD_FLAG_VERTOS_300_SSD, },
2679 /* Vertos 600 ESD. */
2680 { "V006E0DS", NULL, IDE_CD_FLAG_VERTOS_600_ESD, },
2681 /*
2682 * Sanyo 3 CD changer uses a non-standard command for CD changing
2683 * (by default standard ATAPI support for CD changers is used).
2684 */
2685 { "CD-ROM CDR-C3 G", NULL, IDE_CD_FLAG_SANYO_3CD },
2686 { "CD-ROM CDR-C3G", NULL, IDE_CD_FLAG_SANYO_3CD },
2687 { "CD-ROM CDR_C36", NULL, IDE_CD_FLAG_SANYO_3CD },
2688 /* Stingray 8X CD-ROM. */
2689 { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_CD_FLAG_PRE_ATAPI12},
2690 /*
2691 * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
2692 * mode sense page capabilities size, but older drives break.
2693 */
2694 { "ATAPI CD ROM DRIVE 50X MAX", NULL, IDE_CD_FLAG_FULL_CAPS_PAGE },
2695 { "WPI CDS-32X", NULL, IDE_CD_FLAG_FULL_CAPS_PAGE },
2696 /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
2697 { "", "241N", IDE_CD_FLAG_LE_SPEED_FIELDS },
2698 /*
2699 * Some drives used by Apple don't advertise audio play
2700 * but they do support reading TOC & audio datas.
2701 */
2702 { "MATSHITADVD-ROM SR-8187", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
2703 { "MATSHITADVD-ROM SR-8186", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
2704 { "MATSHITADVD-ROM SR-8176", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
2705 { "MATSHITADVD-ROM SR-8174", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
2706 { NULL, NULL, 0 }
2707};
2708
2709static unsigned int ide_cd_flags(struct hd_driveid *id)
2710{
2711 const struct cd_list_entry *cle = ide_cd_quirks_list;
2712
2713 while (cle->id_model) {
2714 if (strcmp(cle->id_model, id->model) == 0 &&
2715 (cle->id_firmware == NULL ||
2716 strstr(id->fw_rev, cle->id_firmware)))
2717 return cle->cd_flags;
2718 cle++;
2719 }
2720
2721 return 0;
2722}
2723
Linus Torvalds1da177e2005-04-16 15:20:36 -07002724static
2725int ide_cdrom_setup (ide_drive_t *drive)
2726{
Bartlomiej Zolnierkiewicz4fe67172008-02-01 23:09:21 +01002727 struct cdrom_info *cd = drive->driver_data;
2728 struct cdrom_device_info *cdi = &cd->devinfo;
Bartlomiej Zolnierkiewicze59724c2008-02-01 23:09:22 +01002729 struct hd_driveid *id = drive->id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002730 int nslots;
2731
2732 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
2733 blk_queue_dma_alignment(drive->queue, 31);
2734 drive->queue->unplug_delay = (1 * HZ) / 1000;
2735 if (!drive->queue->unplug_delay)
2736 drive->queue->unplug_delay = 1;
2737
2738 drive->special.all = 0;
2739
Bartlomiej Zolnierkiewicze59724c2008-02-01 23:09:22 +01002740 cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT |
2741 ide_cd_flags(id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742
Bartlomiej Zolnierkiewicze59724c2008-02-01 23:09:22 +01002743 if ((id->config & 0x0060) == 0x20)
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002744 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
Bartlomiej Zolnierkiewiczb8d25de2008-02-01 23:09:19 +01002745
Bartlomiej Zolnierkiewicze59724c2008-02-01 23:09:22 +01002746 if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) &&
2747 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002748 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
2749 IDE_CD_FLAG_TOCADDR_AS_BCD);
Bartlomiej Zolnierkiewicze59724c2008-02-01 23:09:22 +01002750 else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) &&
2751 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
Bartlomiej Zolnierkiewicz2bc4cf22008-02-01 23:09:22 +01002752 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
Bartlomiej Zolnierkiewicze59724c2008-02-01 23:09:22 +01002753 else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
2754 cdi->sanyo_slot = 3; /* 3 => use CD in slot 0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756 nslots = ide_cdrom_probe_capabilities (drive);
2757
2758 /*
2759 * set correct block size
2760 */
2761 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
2762
2763 if (drive->autotune == IDE_TUNE_DEFAULT ||
2764 drive->autotune == IDE_TUNE_AUTO)
2765 drive->dsc_overlap = (drive->next != drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766
2767 if (ide_cdrom_register(drive, nslots)) {
2768 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
Bartlomiej Zolnierkiewicz4fe67172008-02-01 23:09:21 +01002769 cd->devinfo.handle = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770 return 1;
2771 }
2772 ide_cdrom_add_settings(drive);
2773 return 0;
2774}
2775
Bartlomiej Zolnierkiewiczecfd80e2007-05-10 00:01:09 +02002776#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07002777static
2778sector_t ide_cdrom_capacity (ide_drive_t *drive)
2779{
2780 unsigned long capacity, sectors_per_frame;
2781
2782 if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
2783 return 0;
2784
2785 return capacity * sectors_per_frame;
2786}
Amos Waterlandd97b32142005-10-30 15:02:10 -08002787#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002788
Russell King4031bbe2006-01-06 11:41:00 +00002789static void ide_cd_remove(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790{
2791 struct cdrom_info *info = drive->driver_data;
2792
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02002793 ide_proc_unregister_driver(drive, info->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794
2795 del_gendisk(info->disk);
2796
2797 ide_cd_put(info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798}
2799
2800static void ide_cd_release(struct kref *kref)
2801{
2802 struct cdrom_info *info = to_ide_cd(kref);
2803 struct cdrom_device_info *devinfo = &info->devinfo;
2804 ide_drive_t *drive = info->drive;
2805 struct gendisk *g = info->disk;
2806
Jesper Juhl6044ec82005-11-07 01:01:32 -08002807 kfree(info->buffer);
2808 kfree(info->toc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002809 if (devinfo->handle == drive && unregister_cdrom(devinfo))
2810 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
2811 "driver.\n", __FUNCTION__, drive->name);
2812 drive->dsc_overlap = 0;
2813 drive->driver_data = NULL;
2814 blk_queue_prep_rq(drive->queue, NULL);
2815 g->private_data = NULL;
2816 put_disk(g);
2817 kfree(info);
2818}
2819
Russell King4031bbe2006-01-06 11:41:00 +00002820static int ide_cd_probe(ide_drive_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821
Bartlomiej Zolnierkiewiczecfd80e2007-05-10 00:01:09 +02002822#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823static int proc_idecd_read_capacity
2824 (char *page, char **start, off_t off, int count, int *eof, void *data)
2825{
Jesper Juhl2a91f3e2005-10-30 15:02:45 -08002826 ide_drive_t *drive = data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827 int len;
2828
2829 len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
2830 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
2831}
2832
2833static ide_proc_entry_t idecd_proc[] = {
2834 { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
2835 { NULL, 0, NULL, NULL }
2836};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837#endif
2838
2839static ide_driver_t ide_cdrom_driver = {
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02002840 .gen_driver = {
Laurent Riffard4ef3b8f2005-11-18 22:15:40 +01002841 .owner = THIS_MODULE,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02002842 .name = "ide-cdrom",
2843 .bus = &ide_bus_type,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02002844 },
Russell King4031bbe2006-01-06 11:41:00 +00002845 .probe = ide_cd_probe,
2846 .remove = ide_cd_remove,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847 .version = IDECD_VERSION,
2848 .media = ide_cdrom,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849 .supports_dsc_overlap = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 .do_request = ide_do_rw_cdrom,
2851 .end_request = ide_end_request,
2852 .error = __ide_error,
2853 .abort = __ide_abort,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02002854#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 .proc = idecd_proc,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02002856#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002857};
2858
2859static int idecd_open(struct inode * inode, struct file * file)
2860{
2861 struct gendisk *disk = inode->i_bdev->bd_disk;
2862 struct cdrom_info *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002863 int rc = -ENOMEM;
2864
2865 if (!(info = ide_cd_get(disk)))
2866 return -ENXIO;
2867
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868 if (!info->buffer)
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +01002869 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
2870
2871 if (info->buffer)
2872 rc = cdrom_open(&info->devinfo, inode, file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873
2874 if (rc < 0)
2875 ide_cd_put(info);
2876
2877 return rc;
2878}
2879
2880static int idecd_release(struct inode * inode, struct file * file)
2881{
2882 struct gendisk *disk = inode->i_bdev->bd_disk;
2883 struct cdrom_info *info = ide_cd_g(disk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002884
2885 cdrom_release (&info->devinfo, file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886
2887 ide_cd_put(info);
2888
2889 return 0;
2890}
2891
Christoph Hellwig6a2900b2006-03-23 03:00:15 -08002892static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2893{
2894 struct packet_command cgc;
2895 char buffer[16];
2896 int stat;
2897 char spindown;
2898
2899 if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
2900 return -EFAULT;
2901
2902 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2903
2904 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2905 if (stat)
2906 return stat;
2907
2908 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2909 return cdrom_mode_select(cdi, &cgc);
2910}
2911
2912static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2913{
2914 struct packet_command cgc;
2915 char buffer[16];
2916 int stat;
2917 char spindown;
2918
2919 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2920
2921 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2922 if (stat)
2923 return stat;
2924
2925 spindown = buffer[11] & 0x0f;
2926 if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
2927 return -EFAULT;
2928 return 0;
2929}
2930
Linus Torvalds1da177e2005-04-16 15:20:36 -07002931static int idecd_ioctl (struct inode *inode, struct file *file,
2932 unsigned int cmd, unsigned long arg)
2933{
2934 struct block_device *bdev = inode->i_bdev;
2935 struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
2936 int err;
2937
Christoph Hellwig6a2900b2006-03-23 03:00:15 -08002938 switch (cmd) {
2939 case CDROMSETSPINDOWN:
2940 return idecd_set_spindown(&info->devinfo, arg);
2941 case CDROMGETSPINDOWN:
2942 return idecd_get_spindown(&info->devinfo, arg);
2943 default:
2944 break;
2945 }
2946
2947 err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002948 if (err == -EINVAL)
2949 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
2950
2951 return err;
2952}
2953
2954static int idecd_media_changed(struct gendisk *disk)
2955{
2956 struct cdrom_info *info = ide_cd_g(disk);
2957 return cdrom_media_changed(&info->devinfo);
2958}
2959
2960static int idecd_revalidate_disk(struct gendisk *disk)
2961{
2962 struct cdrom_info *info = ide_cd_g(disk);
2963 struct request_sense sense;
2964 cdrom_read_toc(info->drive, &sense);
2965 return 0;
2966}
2967
2968static struct block_device_operations idecd_ops = {
2969 .owner = THIS_MODULE,
2970 .open = idecd_open,
2971 .release = idecd_release,
2972 .ioctl = idecd_ioctl,
2973 .media_changed = idecd_media_changed,
2974 .revalidate_disk= idecd_revalidate_disk
2975};
2976
2977/* options */
2978static char *ignore = NULL;
2979
2980module_param(ignore, charp, 0400);
2981MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2982
Russell King4031bbe2006-01-06 11:41:00 +00002983static int ide_cd_probe(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984{
2985 struct cdrom_info *info;
2986 struct gendisk *g;
2987 struct request_sense sense;
2988
2989 if (!strstr("ide-cdrom", drive->driver_req))
2990 goto failed;
2991 if (!drive->present)
2992 goto failed;
2993 if (drive->media != ide_cdrom && drive->media != ide_optical)
2994 goto failed;
2995 /* skip drives that we were told to ignore */
2996 if (ignore != NULL) {
2997 if (strstr(ignore, drive->name)) {
2998 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
2999 goto failed;
3000 }
3001 }
3002 if (drive->scsi) {
3003 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
3004 goto failed;
3005 }
Deepak Saxenaf5e3c2f2005-11-07 01:01:25 -08003006 info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003007 if (info == NULL) {
3008 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3009 goto failed;
3010 }
3011
3012 g = alloc_disk(1 << PARTN_BITS);
3013 if (!g)
3014 goto out_free_cd;
3015
3016 ide_init_disk(g, drive);
3017
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02003018 ide_proc_register_driver(drive, &ide_cdrom_driver);
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003019
Linus Torvalds1da177e2005-04-16 15:20:36 -07003020 kref_init(&info->kref);
3021
3022 info->drive = drive;
3023 info->driver = &ide_cdrom_driver;
3024 info->disk = g;
3025
3026 g->private_data = &info->driver;
3027
3028 drive->driver_data = info;
3029
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030 g->minors = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003031 g->driverfs_dev = &drive->gendev;
3032 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3033 if (ide_cdrom_setup(drive)) {
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02003034 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
Bartlomiej Zolnierkiewicz05017db2007-12-24 15:23:43 +01003035 ide_cd_release(&info->kref);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036 goto failed;
3037 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003038
3039 cdrom_read_toc(drive, &sense);
3040 g->fops = &idecd_ops;
3041 g->flags |= GENHD_FL_REMOVABLE;
3042 add_disk(g);
3043 return 0;
3044
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045out_free_cd:
3046 kfree(info);
3047failed:
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003048 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003049}
3050
3051static void __exit ide_cdrom_exit(void)
3052{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003053 driver_unregister(&ide_cdrom_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003054}
Bartlomiej Zolnierkiewicz17514e82005-11-19 22:24:35 +01003055
3056static int __init ide_cdrom_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003057{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02003058 return driver_register(&ide_cdrom_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003059}
3060
Kay Sievers263756e2005-12-12 18:03:44 +01003061MODULE_ALIAS("ide:*m-cdrom*");
Bartlomiej Zolnierkiewicz972560f2008-02-01 23:09:23 +01003062MODULE_ALIAS("ide-cd");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003063module_init(ide_cdrom_init);
3064module_exit(ide_cdrom_exit);
3065MODULE_LICENSE("GPL");