ide-cd: call blk_dump_rq_flags() on "missing data" in cdrom_newpc_intr()
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / ide / ide-cd.c
CommitLineData
1da177e4
LT
1/*
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 *
03553353
BZ
31 * For historical changelog please see:
32 * Documentation/ide/ChangeLog.ide-cd.1994-2004
33 */
34
1da177e4
LT
35#define IDECD_VERSION "4.61"
36
1da177e4
LT
37#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>
cf8b8975 48#include <linux/mutex.h>
9a6dc668 49#include <linux/bcd.h>
1da177e4
LT
50
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
cf8b8975 61static DEFINE_MUTEX(idecd_ref_mutex);
1da177e4
LT
62
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
cf8b8975 72 mutex_lock(&idecd_ref_mutex);
1da177e4
LT
73 cd = ide_cd_g(disk);
74 if (cd)
75 kref_get(&cd->kref);
cf8b8975 76 mutex_unlock(&idecd_ref_mutex);
1da177e4
LT
77 return cd;
78}
79
80static void ide_cd_release(struct kref *);
81
82static void ide_cd_put(struct cdrom_info *cd)
83{
cf8b8975 84 mutex_lock(&idecd_ref_mutex);
1da177e4 85 kref_put(&cd->kref, ide_cd_release);
cf8b8975 86 mutex_unlock(&idecd_ref_mutex);
1da177e4
LT
87}
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{
0ba11211
BZ
97 struct cdrom_info *cd = drive->driver_data;
98
2bc4cf2d
BZ
99 cd->cd_flags |= IDE_CD_FLAG_MEDIA_CHANGED;
100 cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
0ba11211 101 cd->nsectors_buffered = 0;
1da177e4
LT
102}
103
104static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
105 struct request_sense *sense)
106{
107 int log = 0;
108
4aff5e23 109 if (!sense || !rq || (rq->cmd_flags & REQ_QUIET))
1da177e4
LT
110 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)
dbe217af
AC
131 break;
132 log = 1;
1da177e4
LT
133 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{
dbe217af
AC
154 unsigned long sector;
155 unsigned long bio_sectors;
156 unsigned long valid;
157 struct cdrom_info *info = drive->driver_data;
158
1da177e4
LT
159 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
dbe217af
AC
171 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 }
1da177e4 202
972560fb 203 ide_cd_log_error(drive->name, failed_command, sense);
1da177e4
LT
204}
205
206/*
207 * Initialize a ide-cd packet command request
208 */
17802998 209void ide_cd_init_rq(ide_drive_t *drive, struct request *rq)
1da177e4
LT
210{
211 struct cdrom_info *cd = drive->driver_data;
212
213 ide_init_drive_cmd(rq);
cea2885a 214 rq->cmd_type = REQ_TYPE_ATA_PC;
1da177e4
LT
215 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 */
139c829d 228 ide_cd_init_rq(drive, rq);
1da177e4
LT
229
230 rq->data = sense;
231 rq->cmd[0] = GPCMD_REQUEST_SENSE;
232 rq->cmd[4] = rq->data_len = 18;
233
4aff5e23 234 rq->cmd_type = REQ_TYPE_SENSE;
1da177e4
LT
235
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
4aff5e23 247 if (blk_sense_request(rq) && uptodate) {
1da177e4 248 /*
4aff5e23
JA
249 * For REQ_TYPE_SENSE, "rq->buffer" points to the original
250 * failed request
1da177e4
LT
251 */
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 }
dbe217af 262 cdrom_analyze_sense_data(drive, failed, sense);
1da177e4
LT
263 /*
264 * now end failed request
265 */
dbe217af
AC
266 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);
5e36bb6e
KU
272 if (__blk_end_request(failed, -EIO,
273 failed->data_len))
274 BUG();
dbe217af
AC
275 spin_unlock_irqrestore(&ide_lock, flags);
276 }
277 } else
278 cdrom_analyze_sense_data(drive, NULL, sense);
1da177e4
LT
279 }
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
dbe217af
AC
292static 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
1da177e4
LT
299/* 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
4aff5e23 323 if (blk_sense_request(rq)) {
1da177e4
LT
324 /* 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
4aff5e23 328 rq->cmd_flags |= REQ_FAILED;
1da177e4
LT
329 cdrom_end_request(drive, 0);
330 ide_error(drive, "request sense failure", stat);
331 return 1;
332
8770c018 333 } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
1da177e4
LT
334 /* 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 */
b7156731 341 if (blk_pc_request(rq) && !rq->errors)
1da177e4
LT
342 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;
76ca1af1
SH
352 } 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 */
4aff5e23 361 } else if (!(rq->cmd_flags & REQ_QUIET)) {
1da177e4
LT
362 /* Otherwise, print an error. */
363 ide_dump_status(drive, "packet command error", stat);
364 }
365
4aff5e23 366 rq->cmd_flags |= REQ_FAILED;
1da177e4
LT
367
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.*/
dbe217af 436 ide_dump_status_no_sense (drive, "command error", stat);
1da177e4
LT
437 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 */
dbe217af 441 ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
1da177e4
LT
442 do_end_request = 1;
443 } else if (sense_key == BLANK_CHECK) {
444 /* Disk appears blank ?? */
dbe217af 445 ide_dump_status_no_sense (drive, "media error (blank)", stat);
1da177e4
LT
446 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
dbe217af
AC
457 /* 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 */
460
461 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 }
1da177e4
LT
478 } 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:
4aff5e23 507 if (!(rq->cmd_flags & REQ_QUIET))
1da177e4
LT
508 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
3a6a3549 534 /* FIXME: for Virtual DMA we must check harder */
1da177e4
LT
535 if (info->dma)
536 info->dma = !hwif->dma_setup(drive);
537
538 /* Set up the controller registers. */
2fc57388
BZ
539 ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL |
540 IDE_TFLAG_NO_SELECT_MASK, xferlen, info->dma);
4fe67178 541
2bc4cf2d 542 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
f0dd8712
AL
543 /* waiting for CDB interrupt, not DMA yet. */
544 if (info->dma)
545 drive->waiting_for_dma = 0;
546
1da177e4
LT
547 /* 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. */
1da177e4
LT
568#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
2bc4cf2d 578 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
1da177e4
LT
579 /* 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;
f0dd8712
AL
585
586 /* Ok, next interrupt will be DMA interrupt. */
587 if (info->dma)
588 drive->waiting_for_dma = 1;
1da177e4
LT
589 } 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
68661c53
BZ
618typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
619
5a5222d9
BZ
620static 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
1da177e4
LT
629/*
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 */
858119e1 679static
1da177e4
LT
680int 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) {
5a5222d9
BZ
685 ide_hwif_t *hwif = drive->hwif;
686
1da177e4 687 /* Whoops... The drive is expecting to receive data from us! */
35379c07
BZ
688 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
689 drive->name, __FUNCTION__);
1da177e4
LT
690
691 /* Throw some data at the drive so it doesn't hang
692 and quit this request. */
5a5222d9 693 ide_cd_pad_transfer(drive, hwif->atapi_output_bytes, len);
1da177e4
LT
694 } 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... */
35379c07
BZ
702 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
703 drive->name, __FUNCTION__, ireason);
1da177e4
LT
704 }
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;
52ef2ed0
BZ
728 dma_error = HWIF(drive)->ide_dma_end(drive);
729 if (dma_error) {
730 printk(KERN_ERR "%s: DMA read error\n", drive->name);
7469aaf6 731 ide_dma_off(drive);
52ef2ed0 732 }
1da177e4
LT
733 }
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);
4aff5e23 760 rq->cmd_flags |= REQ_FAILED;
1da177e4
LT
761 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);
2bc4cf2d 777 if (info->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES)
1da177e4
LT
778 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");
2bc4cf2d 781 info->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES;
1da177e4
LT
782 }
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;
4fe67178 957
2bc4cf2d 958 info->cd_flags |= IDE_CD_FLAG_SEEKING;
1da177e4
LT
959
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;
1da177e4
LT
993 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
1da177e4
LT
1033 /* 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
1da177e4
LT
1042 /* 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{
1da177e4 1053 struct request *rq = HWGROUP(drive)->rq;
68661c53
BZ
1054 xfer_func_t *xferfunc = NULL;
1055 int stat, ireason, len, thislen, write;
1da177e4 1056 u8 lowcyl = 0, highcyl = 0;
1da177e4
LT
1057
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. */
8606ab09 1063 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1da177e4
LT
1064 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 {
4aff5e23 1086 rq->cmd_flags |= REQ_FAILED;
1da177e4
LT
1087 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;
68661c53
BZ
1094 if (thislen > len)
1095 thislen = len;
1da177e4 1096
8606ab09 1097 if (ireason == 0) {
68661c53
BZ
1098 write = 1;
1099 xferfunc = HWIF(drive)->atapi_output_bytes;
1100 } else if (ireason == 2) {
1101 write = 0;
1102 xferfunc = HWIF(drive)->atapi_input_bytes;
1da177e4
LT
1103 }
1104
68661c53 1105 if (xferfunc) {
1da177e4 1106 if (!rq->data) {
f1071e62
BZ
1107 printk(KERN_ERR "%s: confused, missing data\n",
1108 drive->name);
68661c53
BZ
1109 blk_dump_rq_flags(rq, write ? "cdrom_pc_intr, write"
1110 : "cdrom_pc_intr, read");
f1071e62 1111 goto pad;
1da177e4
LT
1112 }
1113 /* Transfer the data. */
68661c53 1114 xferfunc(drive, rq->data, thislen);
1da177e4 1115
1da177e4 1116 /* Keep count of how much data we've moved. */
5a5222d9 1117 len -= thislen;
1da177e4
LT
1118 rq->data += thislen;
1119 rq->data_len -= thislen;
1120
68661c53 1121 if (write && blk_sense_request(rq))
1da177e4
LT
1122 rq->sense_len += thislen;
1123 } else {
1da177e4 1124 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1ad55440
RK
1125 "appears confused (ireason = 0x%02x). "
1126 "Trying to recover by ending request.\n",
1da177e4 1127 drive->name, ireason);
4aff5e23 1128 rq->cmd_flags |= REQ_FAILED;
1ad55440
RK
1129 cdrom_end_request(drive, 0);
1130 return ide_stopped;
1da177e4 1131 }
f1071e62 1132pad:
5a5222d9
BZ
1133 /*
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
1da177e4
LT
1140 /* 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;
4aff5e23 1164 rq->cmd_flags &= ~REQ_FAILED;
1da177e4
LT
1165 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
17802998 1171int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq)
1da177e4
LT
1172{
1173 struct request_sense sense;
1174 int retries = 10;
4aff5e23 1175 unsigned int flags = rq->cmd_flags;
1da177e4
LT
1176
1177 if (rq->sense == NULL)
1178 rq->sense = &sense;
1179
1180 /* Start of retry loop. */
1181 do {
1182 int error;
1183 unsigned long time = jiffies;
4aff5e23 1184 rq->cmd_flags = flags;
1da177e4
LT
1185
1186 error = ide_do_drive_cmd(drive, rq, ide_wait);
1187 time = jiffies - time;
1188
1189 /* FIXME: we should probably abort/retry or something
1190 * in case of failure */
4aff5e23 1191 if (rq->cmd_flags & REQ_FAILED) {
1da177e4
LT
1192 /* The request failed. Retry if it was due to a unit
1193 attention status
1194 (usually means media was changed). */
1195 struct request_sense *reqbuf = rq->sense;
1196
1197 if (reqbuf->sense_key == UNIT_ATTENTION)
1198 cdrom_saw_media_change(drive);
1199 else if (reqbuf->sense_key == NOT_READY &&
1200 reqbuf->asc == 4 && reqbuf->ascq != 4) {
1201 /* The drive is in the process of loading
1202 a disk. Retry, but wait a little to give
1203 the drive time to complete the load. */
1204 ssleep(2);
1205 } else {
1206 /* Otherwise, don't retry. */
1207 retries = 0;
1208 }
1209 --retries;
1210 }
1211
1212 /* End of retry loop. */
4aff5e23 1213 } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
1da177e4
LT
1214
1215 /* Return an error if the command failed. */
4aff5e23 1216 return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
1da177e4
LT
1217}
1218
1219/*
1220 * Write handling
1221 */
858119e1 1222static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1da177e4
LT
1223{
1224 /* Two notes about IDE interrupt reason here - 0 means that
1225 * the drive wants to receive data from us, 2 means that
1226 * the drive is expecting to transfer data to us.
1227 */
1228 if (ireason == 0)
1229 return 0;
1230 else if (ireason == 2) {
5a5222d9
BZ
1231 ide_hwif_t *hwif = drive->hwif;
1232
1da177e4 1233 /* Whoops... The drive wants to send data. */
35379c07
BZ
1234 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1235 drive->name, __FUNCTION__);
1da177e4 1236
5a5222d9 1237 ide_cd_pad_transfer(drive, hwif->atapi_input_bytes, len);
1da177e4
LT
1238 } else {
1239 /* Drive wants a command packet, or invalid ireason... */
35379c07
BZ
1240 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1241 drive->name, __FUNCTION__, ireason);
1da177e4
LT
1242 }
1243
1244 cdrom_end_request(drive, 0);
1245 return 1;
1246}
1247
aaa04c28
KU
1248/*
1249 * Called from blk_end_request_callback() after the data of the request
1250 * is completed and before the request is completed.
1251 * By returning value '1', blk_end_request_callback() returns immediately
1252 * without completing the request.
1253 */
1254static int cdrom_newpc_intr_dummy_cb(struct request *rq)
1255{
1256 return 1;
1257}
1258
1da177e4
LT
1259/*
1260 * best way to deal with dma that is not sector aligned right now... note
1261 * that in this path we are not using ->data or ->buffer at all. this irs
1262 * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1263 * future.
1264 */
1265static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1266{
1267 struct cdrom_info *info = drive->driver_data;
1268 struct request *rq = HWGROUP(drive)->rq;
1269 int dma_error, dma, stat, ireason, len, thislen;
1270 u8 lowcyl, highcyl;
1271 xfer_func_t *xferfunc;
1272 unsigned long flags;
1273
1274 /* Check for errors. */
1275 dma_error = 0;
1276 dma = info->dma;
1277 if (dma) {
1278 info->dma = 0;
1279 dma_error = HWIF(drive)->ide_dma_end(drive);
eba15fba
BZ
1280 if (dma_error) {
1281 printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1282 rq_data_dir(rq) ? "write" : "read");
1283 ide_dma_off(drive);
1284 }
1da177e4
LT
1285 }
1286
1287 if (cdrom_decode_status(drive, 0, &stat))
1288 return ide_stopped;
1289
1290 /*
1291 * using dma, transfer is complete now
1292 */
1293 if (dma) {
eba15fba 1294 if (dma_error)
1da177e4 1295 return ide_error(drive, "dma error", stat);
1da177e4 1296
aaa04c28
KU
1297 spin_lock_irqsave(&ide_lock, flags);
1298 if (__blk_end_request(rq, 0, rq->data_len))
1299 BUG();
1300 HWGROUP(drive)->rq = NULL;
1301 spin_unlock_irqrestore(&ide_lock, flags);
1302
1303 return ide_stopped;
1da177e4
LT
1304 }
1305
1306 /*
1307 * ok we fall to pio :/
1308 */
1309 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1310 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1311 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1312
1313 len = lowcyl + (256 * highcyl);
1314 thislen = rq->data_len;
1315 if (thislen > len)
1316 thislen = len;
1317
1318 /*
1319 * If DRQ is clear, the command has completed.
1320 */
aaa04c28
KU
1321 if ((stat & DRQ_STAT) == 0) {
1322 spin_lock_irqsave(&ide_lock, flags);
4f4f6c25 1323 if (__blk_end_request(rq, 0, rq->data_len))
aaa04c28
KU
1324 BUG();
1325 HWGROUP(drive)->rq = NULL;
1326 spin_unlock_irqrestore(&ide_lock, flags);
1327
1328 return ide_stopped;
1329 }
1da177e4
LT
1330
1331 /*
1332 * check which way to transfer data
1333 */
1334 if (rq_data_dir(rq) == WRITE) {
1335 /*
1336 * write to drive
1337 */
1338 if (cdrom_write_check_ireason(drive, len, ireason))
1339 return ide_stopped;
1340
1341 xferfunc = HWIF(drive)->atapi_output_bytes;
1342 } else {
1343 /*
1344 * read from drive
1345 */
1346 if (cdrom_read_check_ireason(drive, len, ireason))
1347 return ide_stopped;
1348
1349 xferfunc = HWIF(drive)->atapi_input_bytes;
1350 }
1351
1352 /*
1353 * transfer data
1354 */
1355 while (thislen > 0) {
1356 int blen = blen = rq->data_len;
1357 char *ptr = rq->data;
1358
1359 /*
1360 * bio backed?
1361 */
1362 if (rq->bio) {
1363 ptr = bio_data(rq->bio);
1364 blen = bio_iovec(rq->bio)->bv_len;
1365 }
1366
1367 if (!ptr) {
03f537d5
BZ
1368 printk(KERN_ERR "%s: confused, missing data\n",
1369 drive->name);
1370 blk_dump_rq_flags(rq, rq_data_dir(rq)
1371 ? "cdrom_newpc_intr, write"
1372 : "cdrom_newpc_intr, read");
1da177e4
LT
1373 break;
1374 }
1375
1376 if (blen > thislen)
1377 blen = thislen;
1378
1379 xferfunc(drive, ptr, blen);
1380
1381 thislen -= blen;
1382 len -= blen;
1383 rq->data_len -= blen;
1384
1385 if (rq->bio)
aaa04c28
KU
1386 /*
1387 * The request can't be completed until DRQ is cleared.
1388 * So complete the data, but don't complete the request
1389 * using the dummy function for the callback feature
1390 * of blk_end_request_callback().
1391 */
1392 blk_end_request_callback(rq, 0, blen,
1393 cdrom_newpc_intr_dummy_cb);
1da177e4
LT
1394 else
1395 rq->data += blen;
1396 }
1397
1398 /*
1399 * pad, if necessary
1400 */
5a5222d9
BZ
1401 if (len > 0)
1402 ide_cd_pad_transfer(drive, xferfunc, len);
1da177e4 1403
1da177e4
LT
1404 ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1405 return ide_started;
1da177e4
LT
1406}
1407
1408static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1409{
1410 int stat, ireason, len, sectors_to_transfer, uptodate;
1411 struct cdrom_info *info = drive->driver_data;
1412 int dma_error = 0, dma = info->dma;
1413 u8 lowcyl = 0, highcyl = 0;
1414
1415 struct request *rq = HWGROUP(drive)->rq;
1416
1417 /* Check for errors. */
1418 if (dma) {
1419 info->dma = 0;
b481b238
BZ
1420 dma_error = HWIF(drive)->ide_dma_end(drive);
1421 if (dma_error) {
1422 printk(KERN_ERR "%s: DMA write error\n", drive->name);
7469aaf6 1423 ide_dma_off(drive);
1da177e4
LT
1424 }
1425 }
1426
1427 if (cdrom_decode_status(drive, 0, &stat))
1428 return ide_stopped;
1429
1430 /*
1431 * using dma, transfer is complete now
1432 */
1433 if (dma) {
1434 if (dma_error)
1435 return ide_error(drive, "dma error", stat);
1436
1437 ide_end_request(drive, 1, rq->nr_sectors);
1438 return ide_stopped;
1439 }
1440
1441 /* Read the interrupt reason and the transfer length. */
31a71191 1442 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1da177e4
LT
1443 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1444 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1445
1446 len = lowcyl + (256 * highcyl);
1447
1448 /* If DRQ is clear, the command has completed. */
1449 if ((stat & DRQ_STAT) == 0) {
1450 /* If we're not done writing, complain.
1451 * Otherwise, complete the command normally.
1452 */
1453 uptodate = 1;
1454 if (rq->current_nr_sectors > 0) {
b481b238
BZ
1455 printk(KERN_ERR "%s: %s: data underrun (%d blocks)\n",
1456 drive->name, __FUNCTION__,
1457 rq->current_nr_sectors);
1da177e4
LT
1458 uptodate = 0;
1459 }
1460 cdrom_end_request(drive, uptodate);
1461 return ide_stopped;
1462 }
1463
1464 /* Check that the drive is expecting to do the same thing we are. */
1465 if (cdrom_write_check_ireason(drive, len, ireason))
1466 return ide_stopped;
1467
1468 sectors_to_transfer = len / SECTOR_SIZE;
1469
1470 /*
1471 * now loop and write out the data
1472 */
1473 while (sectors_to_transfer > 0) {
1474 int this_transfer;
1475
1476 if (!rq->current_nr_sectors) {
b481b238
BZ
1477 printk(KERN_ERR "%s: %s: confused, missing data\n",
1478 drive->name, __FUNCTION__);
1da177e4
LT
1479 break;
1480 }
1481
1482 /*
1483 * Figure out how many sectors we can transfer
1484 */
1485 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1486
1487 while (this_transfer > 0) {
1488 HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1489 rq->buffer += SECTOR_SIZE;
1490 --rq->nr_sectors;
1491 --rq->current_nr_sectors;
1492 ++rq->sector;
1493 --this_transfer;
1494 --sectors_to_transfer;
1495 }
1496
1497 /*
1498 * current buffer complete, move on
1499 */
1500 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1501 cdrom_end_request(drive, 1);
1502 }
1503
1504 /* re-arm handler */
1505 ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1506 return ide_started;
1507}
1508
1509static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1510{
1511 struct request *rq = HWGROUP(drive)->rq;
1512
1513#if 0 /* the immediate bit */
1514 rq->cmd[1] = 1 << 3;
1515#endif
1516 rq->timeout = ATAPI_WAIT_PC;
1517
1518 return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1519}
1520
1521static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1522{
1523 struct cdrom_info *info = drive->driver_data;
1524 struct gendisk *g = info->disk;
1525 unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1526
1527 /*
1528 * writes *must* be hardware frame aligned
1529 */
1530 if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1531 (rq->sector & (sectors_per_frame - 1))) {
1532 cdrom_end_request(drive, 0);
1533 return ide_stopped;
1534 }
1535
1536 /*
1537 * disk has become write protected
1538 */
1539 if (g->policy) {
1540 cdrom_end_request(drive, 0);
1541 return ide_stopped;
1542 }
1543
1da177e4
LT
1544 info->nsectors_buffered = 0;
1545
1546 /* use dma, if possible. we don't need to check more, since we
1547 * know that the transfer is always (at least!) frame aligned */
1548 info->dma = drive->using_dma ? 1 : 0;
1da177e4
LT
1549
1550 info->devinfo.media_written = 1;
1551
1552 /* Start sending the write request to the drive. */
1553 return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1554}
1555
1556static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1557{
1558 struct request *rq = HWGROUP(drive)->rq;
1559
1560 if (!rq->timeout)
1561 rq->timeout = ATAPI_WAIT_PC;
1562
1563 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1564}
1565
1566static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1567{
1568 struct cdrom_info *info = drive->driver_data;
1569
4aff5e23 1570 rq->cmd_flags |= REQ_QUIET;
1da177e4
LT
1571
1572 info->dma = 0;
1da177e4
LT
1573
1574 /*
1575 * sg request
1576 */
1577 if (rq->bio) {
1578 int mask = drive->queue->dma_alignment;
1579 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1580
1da177e4
LT
1581 info->dma = drive->using_dma;
1582
1583 /*
1584 * check if dma is safe
5d9e4ea5
LT
1585 *
1586 * NOTE! The "len" and "addr" checks should possibly have
1587 * separate masks.
1da177e4 1588 */
4e7c6816 1589 if ((rq->data_len & 15) || (addr & mask))
1da177e4
LT
1590 info->dma = 0;
1591 }
1592
1593 /* Start sending the command to the drive. */
1594 return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1595}
1596
1597/****************************************************************************
1598 * cdrom driver request routine.
1599 */
1600static ide_startstop_t
1601ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1602{
1603 ide_startstop_t action;
1604 struct cdrom_info *info = drive->driver_data;
1605
1606 if (blk_fs_request(rq)) {
2bc4cf2d 1607 if (info->cd_flags & IDE_CD_FLAG_SEEKING) {
1da177e4
LT
1608 unsigned long elapsed = jiffies - info->start_seek;
1609 int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1610
1611 if ((stat & SEEK_STAT) != SEEK_STAT) {
1612 if (elapsed < IDECD_SEEK_TIMEOUT) {
1613 ide_stall_queue(drive, IDECD_SEEK_TIMER);
1614 return ide_stopped;
1615 }
1616 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1617 }
2bc4cf2d 1618 info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
1da177e4
LT
1619 }
1620 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1621 action = cdrom_start_seek(drive, block);
1622 } else {
1623 if (rq_data_dir(rq) == READ)
1624 action = cdrom_start_read(drive, block);
1625 else
1626 action = cdrom_start_write(drive, rq);
1627 }
1628 info->last_block = block;
1629 return action;
cea2885a
JA
1630 } else if (rq->cmd_type == REQ_TYPE_SENSE ||
1631 rq->cmd_type == REQ_TYPE_ATA_PC) {
1da177e4 1632 return cdrom_do_packet_command(drive);
4aff5e23 1633 } else if (blk_pc_request(rq)) {
1da177e4 1634 return cdrom_do_block_pc(drive, rq);
4aff5e23 1635 } else if (blk_special_request(rq)) {
1da177e4
LT
1636 /*
1637 * right now this can only be a reset...
1638 */
1639 cdrom_end_request(drive, 1);
1640 return ide_stopped;
1641 }
1642
1643 blk_dump_rq_flags(rq, "ide-cd bad flags");
1644 cdrom_end_request(drive, 0);
1645 return ide_stopped;
1646}
1647
1648
1649
1650/****************************************************************************
1651 * Ioctl handling.
1652 *
1653 * Routines which queue packet commands take as a final argument a pointer
1654 * to a request_sense struct. If execution of the command results
1655 * in an error with a CHECK CONDITION status, this structure will be filled
1656 * with the results of the subsequent request sense command. The pointer
1657 * can also be NULL, in which case no sense information is returned.
1658 */
1659
1da177e4
LT
1660static
1661void msf_from_bcd (struct atapi_msf *msf)
1662{
9a6dc668
BZ
1663 msf->minute = BCD2BIN(msf->minute);
1664 msf->second = BCD2BIN(msf->second);
1665 msf->frame = BCD2BIN(msf->frame);
1da177e4
LT
1666}
1667
1da177e4
LT
1668static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
1669{
1670 struct request req;
1671 struct cdrom_info *info = drive->driver_data;
1672 struct cdrom_device_info *cdi = &info->devinfo;
1673
139c829d 1674 ide_cd_init_rq(drive, &req);
1da177e4
LT
1675
1676 req.sense = sense;
1677 req.cmd[0] = GPCMD_TEST_UNIT_READY;
4aff5e23 1678 req.cmd_flags |= REQ_QUIET;
1da177e4 1679
cdf6000d
BZ
1680 /*
1681 * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1682 * switch CDs instead of supporting the LOAD_UNLOAD opcode.
1683 */
1da177e4 1684 req.cmd[7] = cdi->sanyo_slot % 3;
1da177e4 1685
139c829d 1686 return ide_cd_queue_pc(drive, &req);
1da177e4
LT
1687}
1688
1da177e4 1689/* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
17802998
BZ
1690int ide_cd_lockdoor(ide_drive_t *drive, int lockflag,
1691 struct request_sense *sense)
1da177e4 1692{
4fe67178 1693 struct cdrom_info *cd = drive->driver_data;
1da177e4
LT
1694 struct request_sense my_sense;
1695 struct request req;
1696 int stat;
1697
1698 if (sense == NULL)
1699 sense = &my_sense;
1700
1701 /* If the drive cannot lock the door, just pretend. */
2bc4cf2d 1702 if (cd->cd_flags & IDE_CD_FLAG_NO_DOORLOCK) {
1da177e4
LT
1703 stat = 0;
1704 } else {
139c829d 1705 ide_cd_init_rq(drive, &req);
1da177e4
LT
1706 req.sense = sense;
1707 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
1708 req.cmd[4] = lockflag ? 1 : 0;
139c829d 1709 stat = ide_cd_queue_pc(drive, &req);
1da177e4
LT
1710 }
1711
1712 /* If we got an illegal field error, the drive
1713 probably cannot lock the door. */
1714 if (stat != 0 &&
1715 sense->sense_key == ILLEGAL_REQUEST &&
1716 (sense->asc == 0x24 || sense->asc == 0x20)) {
1717 printk (KERN_ERR "%s: door locking not supported\n",
1718 drive->name);
2bc4cf2d 1719 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
1da177e4
LT
1720 stat = 0;
1721 }
1722
1723 /* no medium, that's alright. */
1724 if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
1725 stat = 0;
1726
2bc4cf2d
BZ
1727 if (stat == 0) {
1728 if (lockflag)
1729 cd->cd_flags |= IDE_CD_FLAG_DOOR_LOCKED;
1730 else
1731 cd->cd_flags &= ~IDE_CD_FLAG_DOOR_LOCKED;
1732 }
1da177e4
LT
1733
1734 return stat;
1735}
1736
1737
1738/* Eject the disk if EJECTFLAG is 0.
1739 If EJECTFLAG is 1, try to reload the disk. */
1740static int cdrom_eject(ide_drive_t *drive, int ejectflag,
1741 struct request_sense *sense)
1742{
3f1b86d8
BZ
1743 struct cdrom_info *cd = drive->driver_data;
1744 struct cdrom_device_info *cdi = &cd->devinfo;
1da177e4
LT
1745 struct request req;
1746 char loej = 0x02;
1747
2bc4cf2d 1748 if ((cd->cd_flags & IDE_CD_FLAG_NO_EJECT) && !ejectflag)
1da177e4 1749 return -EDRIVE_CANT_DO_THIS;
4fe67178 1750
1da177e4 1751 /* reload fails on some drives, if the tray is locked */
2bc4cf2d 1752 if ((cd->cd_flags & IDE_CD_FLAG_DOOR_LOCKED) && ejectflag)
1da177e4
LT
1753 return 0;
1754
139c829d 1755 ide_cd_init_rq(drive, &req);
1da177e4
LT
1756
1757 /* only tell drive to close tray if open, if it can do that */
3f1b86d8 1758 if (ejectflag && (cdi->mask & CDC_CLOSE_TRAY))
1da177e4
LT
1759 loej = 0;
1760
1761 req.sense = sense;
1762 req.cmd[0] = GPCMD_START_STOP_UNIT;
1763 req.cmd[4] = loej | (ejectflag != 0);
139c829d
BZ
1764
1765 return ide_cd_queue_pc(drive, &req);
1da177e4
LT
1766}
1767
1768static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
1769 unsigned long *sectors_per_frame,
1770 struct request_sense *sense)
1771{
1772 struct {
1773 __u32 lba;
1774 __u32 blocklen;
1775 } capbuf;
1776
1777 int stat;
1778 struct request req;
1779
139c829d 1780 ide_cd_init_rq(drive, &req);
1da177e4
LT
1781
1782 req.sense = sense;
1783 req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
1784 req.data = (char *)&capbuf;
1785 req.data_len = sizeof(capbuf);
4aff5e23 1786 req.cmd_flags |= REQ_QUIET;
1da177e4 1787
139c829d 1788 stat = ide_cd_queue_pc(drive, &req);
1da177e4
LT
1789 if (stat == 0) {
1790 *capacity = 1 + be32_to_cpu(capbuf.lba);
1791 *sectors_per_frame =
1792 be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
1793 }
1794
1795 return stat;
1796}
1797
1798static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
1799 int format, char *buf, int buflen,
1800 struct request_sense *sense)
1801{
1802 struct request req;
1803
139c829d 1804 ide_cd_init_rq(drive, &req);
1da177e4
LT
1805
1806 req.sense = sense;
1807 req.data = buf;
1808 req.data_len = buflen;
4aff5e23 1809 req.cmd_flags |= REQ_QUIET;
1da177e4
LT
1810 req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
1811 req.cmd[6] = trackno;
1812 req.cmd[7] = (buflen >> 8);
1813 req.cmd[8] = (buflen & 0xff);
1814 req.cmd[9] = (format << 6);
1815
1816 if (msf_flag)
1817 req.cmd[1] = 2;
1818
139c829d 1819 return ide_cd_queue_pc(drive, &req);
1da177e4
LT
1820}
1821
1da177e4 1822/* Try to read the entire TOC for the disk into our internal buffer. */
17802998 1823int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
1da177e4
LT
1824{
1825 int stat, ntracks, i;
1826 struct cdrom_info *info = drive->driver_data;
1827 struct cdrom_device_info *cdi = &info->devinfo;
1828 struct atapi_toc *toc = info->toc;
1829 struct {
1830 struct atapi_toc_header hdr;
1831 struct atapi_toc_entry ent;
1832 } ms_tmp;
1833 long last_written;
1834 unsigned long sectors_per_frame = SECTORS_PER_FRAME;
1835
1836 if (toc == NULL) {
1837 /* Try to allocate space. */
2a91f3e5 1838 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
1da177e4
LT
1839 if (toc == NULL) {
1840 printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
1841 return -ENOMEM;
1842 }
2a91f3e5 1843 info->toc = toc;
1da177e4
LT
1844 }
1845
1846 /* Check to see if the existing data is still valid.
1847 If it is, just return. */
1848 (void) cdrom_check_status(drive, sense);
1849
2bc4cf2d 1850 if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
1da177e4
LT
1851 return 0;
1852
1853 /* Try to get the total cdrom capacity and sector size. */
1854 stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
1855 sense);
1856 if (stat)
1857 toc->capacity = 0x1fffff;
1858
1859 set_capacity(info->disk, toc->capacity * sectors_per_frame);
dbe217af
AC
1860 /* Save a private copy of te TOC capacity for error handling */
1861 drive->probed_capacity = toc->capacity * sectors_per_frame;
1862
1da177e4
LT
1863 blk_queue_hardsect_size(drive->queue,
1864 sectors_per_frame << SECTOR_BITS);
1865
1866 /* First read just the header, so we know how long the TOC is. */
1867 stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
1868 sizeof(struct atapi_toc_header), sense);
2a91f3e5
JJ
1869 if (stat)
1870 return stat;
1da177e4 1871
2bc4cf2d 1872 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
9a6dc668
BZ
1873 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1874 toc->hdr.last_track = BCD2BIN(toc->hdr.last_track);
1da177e4 1875 }
1da177e4
LT
1876
1877 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1878 if (ntracks <= 0)
1879 return -EIO;
1880 if (ntracks > MAX_TRACKS)
1881 ntracks = MAX_TRACKS;
1882
1883 /* Now read the whole schmeer. */
1884 stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
1885 (char *)&toc->hdr,
1886 sizeof(struct atapi_toc_header) +
1887 (ntracks + 1) *
1888 sizeof(struct atapi_toc_entry), sense);
1889
1890 if (stat && toc->hdr.first_track > 1) {
1891 /* Cds with CDI tracks only don't have any TOC entries,
1892 despite of this the returned values are
1893 first_track == last_track = number of CDI tracks + 1,
1894 so that this case is indistinguishable from the same
1895 layout plus an additional audio track.
1896 If we get an error for the regular case, we assume
1897 a CDI without additional audio tracks. In this case
1898 the readable TOC is empty (CDI tracks are not included)
96de0e25 1899 and only holds the Leadout entry. Heiko Eißfeldt */
1da177e4
LT
1900 ntracks = 0;
1901 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
1902 (char *)&toc->hdr,
1903 sizeof(struct atapi_toc_header) +
1904 (ntracks + 1) *
1905 sizeof(struct atapi_toc_entry),
1906 sense);
cdf6000d 1907 if (stat)
1da177e4 1908 return stat;
cdf6000d 1909
2bc4cf2d 1910 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
9a6dc668
BZ
1911 toc->hdr.first_track = (u8)BIN2BCD(CDROM_LEADOUT);
1912 toc->hdr.last_track = (u8)BIN2BCD(CDROM_LEADOUT);
cdf6000d 1913 } else {
1da177e4
LT
1914 toc->hdr.first_track = CDROM_LEADOUT;
1915 toc->hdr.last_track = CDROM_LEADOUT;
1916 }
1917 }
1918
1919 if (stat)
1920 return stat;
1921
1922 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
1923
2bc4cf2d 1924 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
9a6dc668
BZ
1925 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1926 toc->hdr.last_track = BCD2BIN(toc->hdr.last_track);
1da177e4 1927 }
1da177e4 1928
cdf6000d 1929 for (i = 0; i <= ntracks; i++) {
2bc4cf2d
BZ
1930 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1931 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD)
9a6dc668 1932 toc->ent[i].track = BCD2BIN(toc->ent[i].track);
1da177e4
LT
1933 msf_from_bcd(&toc->ent[i].addr.msf);
1934 }
1da177e4
LT
1935 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
1936 toc->ent[i].addr.msf.second,
1937 toc->ent[i].addr.msf.frame);
1938 }
1939
1940 /* Read the multisession information. */
1941 if (toc->hdr.first_track != CDROM_LEADOUT) {
1942 /* Read the multisession information. */
1943 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
1944 sizeof(ms_tmp), sense);
2a91f3e5
JJ
1945 if (stat)
1946 return stat;
1da177e4
LT
1947
1948 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
1949 } else {
1950 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
1951 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
1952 }
1953
2bc4cf2d 1954 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1da177e4
LT
1955 /* Re-read multisession information using MSF format */
1956 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
1957 sizeof(ms_tmp), sense);
1958 if (stat)
1959 return stat;
1960
1961 msf_from_bcd (&ms_tmp.ent.addr.msf);
1962 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1963 ms_tmp.ent.addr.msf.second,
1964 ms_tmp.ent.addr.msf.frame);
1965 }
1da177e4
LT
1966
1967 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
1968
1969 /* Now try to get the total cdrom capacity. */
1970 stat = cdrom_get_last_written(cdi, &last_written);
1971 if (!stat && (last_written > toc->capacity)) {
1972 toc->capacity = last_written;
1973 set_capacity(info->disk, toc->capacity * sectors_per_frame);
dbe217af 1974 drive->probed_capacity = toc->capacity * sectors_per_frame;
1da177e4
LT
1975 }
1976
1977 /* Remember that we've read this stuff. */
2bc4cf2d 1978 info->cd_flags |= IDE_CD_FLAG_TOC_VALID;
1da177e4
LT
1979
1980 return 0;
1981}
1982
1da177e4
LT
1983/* the generic packet interface to cdrom.c */
1984static int ide_cdrom_packet(struct cdrom_device_info *cdi,
1985 struct packet_command *cgc)
1986{
1987 struct request req;
2a91f3e5 1988 ide_drive_t *drive = cdi->handle;
1da177e4
LT
1989
1990 if (cgc->timeout <= 0)
1991 cgc->timeout = ATAPI_WAIT_PC;
1992
1993 /* here we queue the commands from the uniform CD-ROM
1994 layer. the packet must be complete, as we do not
1995 touch it at all. */
139c829d 1996 ide_cd_init_rq(drive, &req);
1da177e4
LT
1997 memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
1998 if (cgc->sense)
1999 memset(cgc->sense, 0, sizeof(struct request_sense));
2000 req.data = cgc->buffer;
2001 req.data_len = cgc->buflen;
2002 req.timeout = cgc->timeout;
2003
2004 if (cgc->quiet)
4aff5e23 2005 req.cmd_flags |= REQ_QUIET;
1da177e4
LT
2006
2007 req.sense = cgc->sense;
139c829d 2008 cgc->stat = ide_cd_queue_pc(drive, &req);
1da177e4
LT
2009 if (!cgc->stat)
2010 cgc->buflen -= req.data_len;
2011 return cgc->stat;
2012}
2013
1da177e4
LT
2014static
2015int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2016{
2a91f3e5 2017 ide_drive_t *drive = cdi->handle;
1da177e4
LT
2018 struct request_sense sense;
2019
2020 if (position) {
139c829d
BZ
2021 int stat = ide_cd_lockdoor(drive, 0, &sense);
2022
2a91f3e5
JJ
2023 if (stat)
2024 return stat;
1da177e4
LT
2025 }
2026
2027 return cdrom_eject(drive, !position, &sense);
2028}
2029
17802998 2030int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
9235e68b
EP
2031{
2032 struct cdrom_info *info = drive->driver_data;
2033 struct cdrom_device_info *cdi = &info->devinfo;
2034 struct packet_command cgc;
455d80a9 2035 int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
9235e68b 2036
e59724c7 2037 if ((info->cd_flags & IDE_CD_FLAG_FULL_CAPS_PAGE) == 0)
455d80a9 2038 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
9235e68b 2039
455d80a9 2040 init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
9235e68b
EP
2041 do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2042 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2043 if (!stat)
2044 break;
2045 } while (--attempts);
2046 return stat;
2047}
2048
17802998 2049void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
9235e68b 2050{
4fe67178 2051 struct cdrom_info *cd = drive->driver_data;
481c8c64
BZ
2052 u16 curspeed, maxspeed;
2053
455d80a9
BZ
2054 curspeed = *(u16 *)&buf[8 + 14];
2055 maxspeed = *(u16 *)&buf[8 + 8];
2056
e59724c7 2057 if (cd->cd_flags & IDE_CD_FLAG_LE_SPEED_FIELDS) {
455d80a9
BZ
2058 curspeed = le16_to_cpu(curspeed);
2059 maxspeed = le16_to_cpu(maxspeed);
9235e68b 2060 } else {
455d80a9
BZ
2061 curspeed = be16_to_cpu(curspeed);
2062 maxspeed = be16_to_cpu(maxspeed);
9235e68b 2063 }
481c8c64 2064
2bc4cf2d
BZ
2065 cd->current_speed = (curspeed + (176/2)) / 176;
2066 cd->max_speed = (maxspeed + (176/2)) / 176;
9235e68b
EP
2067}
2068
1da177e4
LT
2069/*
2070 * add logic to try GET_EVENT command first to check for media and tray
2071 * status. this should be supported by newer cd-r/w and all DVD etc
2072 * drives
2073 */
2074static
2075int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2076{
2a91f3e5 2077 ide_drive_t *drive = cdi->handle;
1da177e4
LT
2078 struct media_event_desc med;
2079 struct request_sense sense;
2080 int stat;
2081
2082 if (slot_nr != CDSL_CURRENT)
2083 return -EINVAL;
2084
2085 stat = cdrom_check_status(drive, &sense);
2086 if (!stat || sense.sense_key == UNIT_ATTENTION)
2087 return CDS_DISC_OK;
2088
2089 if (!cdrom_get_media_event(cdi, &med)) {
2090 if (med.media_present)
2091 return CDS_DISC_OK;
2092 else if (med.door_open)
2093 return CDS_TRAY_OPEN;
2094 else
2095 return CDS_NO_DISC;
2096 }
2097
2098 if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2099 return CDS_DISC_OK;
2100
2101 /*
2102 * If not using Mt Fuji extended media tray reports,
2103 * just return TRAY_OPEN since ATAPI doesn't provide
2104 * any other way to detect this...
2105 */
2106 if (sense.sense_key == NOT_READY) {
dbe217af
AC
2107 if (sense.asc == 0x3a && sense.ascq == 1)
2108 return CDS_NO_DISC;
2109 else
2110 return CDS_TRAY_OPEN;
1da177e4 2111 }
1da177e4
LT
2112 return CDS_DRIVE_NOT_READY;
2113}
2114
1da177e4
LT
2115/****************************************************************************
2116 * Other driver requests (open, close, check media change).
2117 */
2118
2119static
2120int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2121 int slot_nr)
2122{
2a91f3e5 2123 ide_drive_t *drive = cdi->handle;
0ba11211 2124 struct cdrom_info *cd = drive->driver_data;
1da177e4 2125 int retval;
0ba11211 2126
1da177e4
LT
2127 if (slot_nr == CDSL_CURRENT) {
2128 (void) cdrom_check_status(drive, NULL);
2bc4cf2d
BZ
2129 retval = (cd->cd_flags & IDE_CD_FLAG_MEDIA_CHANGED) ? 1 : 0;
2130 cd->cd_flags &= ~IDE_CD_FLAG_MEDIA_CHANGED;
1da177e4
LT
2131 return retval;
2132 } else {
2133 return -EINVAL;
2134 }
2135}
2136
2137
2138static
2139int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2140{
2141 return 0;
2142}
2143
2144/*
2145 * Close down the device. Invalidate all cached blocks.
2146 */
2147
2148static
2149void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2150{
2151 ide_drive_t *drive = cdi->handle;
0ba11211 2152 struct cdrom_info *cd = drive->driver_data;
1da177e4
LT
2153
2154 if (!cdi->use_count)
2bc4cf2d 2155 cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
1da177e4
LT
2156}
2157
20e7f7ef
BZ
2158#define IDE_CD_CAPABILITIES \
2159 (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
2160 CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
2161 CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
2162 CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
2163 CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
1da177e4 2164
1da177e4
LT
2165static struct cdrom_device_ops ide_cdrom_dops = {
2166 .open = ide_cdrom_open_real,
2167 .release = ide_cdrom_release_real,
2168 .drive_status = ide_cdrom_drive_status,
2169 .media_changed = ide_cdrom_check_media_change_real,
2170 .tray_move = ide_cdrom_tray_move,
2171 .lock_door = ide_cdrom_lock_door,
2172 .select_speed = ide_cdrom_select_speed,
2173 .get_last_session = ide_cdrom_get_last_session,
2174 .get_mcn = ide_cdrom_get_mcn,
2175 .reset = ide_cdrom_reset,
2176 .audio_ioctl = ide_cdrom_audio_ioctl,
20e7f7ef 2177 .capability = IDE_CD_CAPABILITIES,
1da177e4
LT
2178 .generic_packet = ide_cdrom_packet,
2179};
2180
2181static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2182{
2183 struct cdrom_info *info = drive->driver_data;
2184 struct cdrom_device_info *devinfo = &info->devinfo;
2185
2186 devinfo->ops = &ide_cdrom_dops;
2bc4cf2d 2187 devinfo->speed = info->current_speed;
1da177e4 2188 devinfo->capacity = nslots;
2a91f3e5 2189 devinfo->handle = drive;
1da177e4 2190 strcpy(devinfo->name, drive->name);
1da177e4 2191
2bc4cf2d 2192 if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT)
3cbd814e
BZ
2193 devinfo->mask |= CDC_SELECT_SPEED;
2194
1da177e4
LT
2195 devinfo->disk = info->disk;
2196 return register_cdrom(devinfo);
2197}
2198
1da177e4
LT
2199static
2200int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2201{
4fe67178
BZ
2202 struct cdrom_info *cd = drive->driver_data;
2203 struct cdrom_device_info *cdi = &cd->devinfo;
455d80a9
BZ
2204 u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
2205 mechtype_t mechtype;
1da177e4
LT
2206 int nslots = 1;
2207
3f1b86d8
BZ
2208 cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
2209 CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO |
2210 CDC_MO_DRIVE | CDC_RAM);
2211
1da177e4 2212 if (drive->media == ide_optical) {
3f1b86d8 2213 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
1da177e4
LT
2214 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2215 return nslots;
2216 }
2217
e59724c7 2218 if (cd->cd_flags & IDE_CD_FLAG_PRE_ATAPI12) {
2bc4cf2d 2219 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
3f1b86d8 2220 cdi->mask &= ~CDC_PLAY_AUDIO;
1da177e4
LT
2221 return nslots;
2222 }
2223
2224 /*
2225 * we have to cheat a little here. the packet will eventually
2226 * be queued with ide_cdrom_packet(), which extracts the
2227 * drive from cdi->handle. Since this device hasn't been
2228 * registered with the Uniform layer yet, it can't do this.
2229 * Same goes for cdi->ops.
2230 */
2a91f3e5 2231 cdi->handle = drive;
1da177e4
LT
2232 cdi->ops = &ide_cdrom_dops;
2233
455d80a9 2234 if (ide_cdrom_get_capabilities(drive, buf))
1da177e4
LT
2235 return 0;
2236
455d80a9 2237 if ((buf[8 + 6] & 0x01) == 0)
2bc4cf2d 2238 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
455d80a9 2239 if (buf[8 + 6] & 0x08)
2bc4cf2d 2240 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
455d80a9 2241 if (buf[8 + 3] & 0x01)
3f1b86d8 2242 cdi->mask &= ~CDC_CD_R;
455d80a9 2243 if (buf[8 + 3] & 0x02)
3f1b86d8 2244 cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
455d80a9 2245 if (buf[8 + 2] & 0x38)
3f1b86d8 2246 cdi->mask &= ~CDC_DVD;
455d80a9 2247 if (buf[8 + 3] & 0x20)
3f1b86d8 2248 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
455d80a9 2249 if (buf[8 + 3] & 0x10)
3f1b86d8 2250 cdi->mask &= ~CDC_DVD_R;
e59724c7 2251 if ((buf[8 + 4] & 0x01) || (cd->cd_flags & IDE_CD_FLAG_PLAY_AUDIO_OK))
3f1b86d8 2252 cdi->mask &= ~CDC_PLAY_AUDIO;
455d80a9
BZ
2253
2254 mechtype = buf[8 + 6] >> 5;
2255 if (mechtype == mechtype_caddy || mechtype == mechtype_popup)
3f1b86d8 2256 cdi->mask |= CDC_CLOSE_TRAY;
1da177e4 2257
1da177e4 2258 if (cdi->sanyo_slot > 0) {
3f1b86d8 2259 cdi->mask &= ~CDC_SELECT_DISC;
1da177e4 2260 nslots = 3;
cdf6000d
BZ
2261 } else if (mechtype == mechtype_individual_changer ||
2262 mechtype == mechtype_cartridge_changer) {
2609d06d
BZ
2263 nslots = cdrom_number_of_slots(cdi);
2264 if (nslots > 1)
3f1b86d8 2265 cdi->mask &= ~CDC_SELECT_DISC;
1da177e4
LT
2266 }
2267
455d80a9 2268 ide_cdrom_update_speed(drive, buf);
4fe67178 2269
1da177e4 2270 printk(KERN_INFO "%s: ATAPI", drive->name);
4fe67178
BZ
2271
2272 /* don't print speed if the drive reported 0 */
2bc4cf2d
BZ
2273 if (cd->max_speed)
2274 printk(KERN_CONT " %dX", cd->max_speed);
4fe67178 2275
3f1b86d8 2276 printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM");
1da177e4 2277
3f1b86d8
BZ
2278 if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
2279 printk(KERN_CONT " DVD%s%s",
2280 (cdi->mask & CDC_DVD_R) ? "" : "-R",
2281 (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
1da177e4 2282
3f1b86d8
BZ
2283 if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
2284 printk(KERN_CONT " CD%s%s",
2285 (cdi->mask & CDC_CD_R) ? "" : "-R",
2286 (cdi->mask & CDC_CD_RW) ? "" : "/RW");
1da177e4 2287
3f1b86d8
BZ
2288 if ((cdi->mask & CDC_SELECT_DISC) == 0)
2289 printk(KERN_CONT " changer w/%d slots", nslots);
2290 else
2291 printk(KERN_CONT " drive");
1da177e4 2292
455d80a9 2293 printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12]));
1da177e4
LT
2294
2295 return nslots;
2296}
2297
7662d046 2298#ifdef CONFIG_IDE_PROC_FS
1da177e4
LT
2299static void ide_cdrom_add_settings(ide_drive_t *drive)
2300{
1497943e 2301 ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
1da177e4 2302}
7662d046
BZ
2303#else
2304static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
2305#endif
1da177e4
LT
2306
2307/*
2308 * standard prep_rq_fn that builds 10 byte cmds
2309 */
165125e1 2310static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
1da177e4
LT
2311{
2312 int hard_sect = queue_hardsect_size(q);
2313 long block = (long)rq->hard_sector / (hard_sect >> 9);
2314 unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
2315
2316 memset(rq->cmd, 0, sizeof(rq->cmd));
2317
2318 if (rq_data_dir(rq) == READ)
2319 rq->cmd[0] = GPCMD_READ_10;
2320 else
2321 rq->cmd[0] = GPCMD_WRITE_10;
2322
2323 /*
2324 * fill in lba
2325 */
2326 rq->cmd[2] = (block >> 24) & 0xff;
2327 rq->cmd[3] = (block >> 16) & 0xff;
2328 rq->cmd[4] = (block >> 8) & 0xff;
2329 rq->cmd[5] = block & 0xff;
2330
2331 /*
2332 * and transfer length
2333 */
2334 rq->cmd[7] = (blocks >> 8) & 0xff;
2335 rq->cmd[8] = blocks & 0xff;
2336 rq->cmd_len = 10;
2337 return BLKPREP_OK;
2338}
2339
2340/*
2341 * Most of the SCSI commands are supported directly by ATAPI devices.
2342 * This transform handles the few exceptions.
2343 */
2344static int ide_cdrom_prep_pc(struct request *rq)
2345{
2346 u8 *c = rq->cmd;
2347
2348 /*
2349 * Transform 6-byte read/write commands to the 10-byte version
2350 */
2351 if (c[0] == READ_6 || c[0] == WRITE_6) {
2352 c[8] = c[4];
2353 c[5] = c[3];
2354 c[4] = c[2];
2355 c[3] = c[1] & 0x1f;
2356 c[2] = 0;
2357 c[1] &= 0xe0;
2358 c[0] += (READ_10 - READ_6);
2359 rq->cmd_len = 10;
2360 return BLKPREP_OK;
2361 }
2362
2363 /*
2364 * it's silly to pretend we understand 6-byte sense commands, just
2365 * reject with ILLEGAL_REQUEST and the caller should take the
2366 * appropriate action
2367 */
2368 if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
2369 rq->errors = ILLEGAL_REQUEST;
2370 return BLKPREP_KILL;
2371 }
2372
2373 return BLKPREP_OK;
2374}
2375
165125e1 2376static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
1da177e4 2377{
4aff5e23 2378 if (blk_fs_request(rq))
1da177e4 2379 return ide_cdrom_prep_fs(q, rq);
4aff5e23 2380 else if (blk_pc_request(rq))
1da177e4
LT
2381 return ide_cdrom_prep_pc(rq);
2382
2383 return 0;
2384}
2385
e59724c7
BZ
2386struct cd_list_entry {
2387 const char *id_model;
2388 const char *id_firmware;
2389 unsigned int cd_flags;
2390};
2391
2392static const struct cd_list_entry ide_cd_quirks_list[] = {
2393 /* Limit transfer size per interrupt. */
2394 { "SAMSUNG CD-ROM SCR-2430", NULL, IDE_CD_FLAG_LIMIT_NFRAMES },
2395 { "SAMSUNG CD-ROM SCR-2432", NULL, IDE_CD_FLAG_LIMIT_NFRAMES },
2396 /* SCR-3231 doesn't support the SET_CD_SPEED command. */
2397 { "SAMSUNG CD-ROM SCR-3231", NULL, IDE_CD_FLAG_NO_SPEED_SELECT },
2398 /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
2399 { "NEC CD-ROM DRIVE:260", "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD |
2400 IDE_CD_FLAG_PRE_ATAPI12, },
2401 /* Vertos 300, some versions of this drive like to talk BCD. */
2402 { "V003S0DS", NULL, IDE_CD_FLAG_VERTOS_300_SSD, },
2403 /* Vertos 600 ESD. */
2404 { "V006E0DS", NULL, IDE_CD_FLAG_VERTOS_600_ESD, },
2405 /*
2406 * Sanyo 3 CD changer uses a non-standard command for CD changing
2407 * (by default standard ATAPI support for CD changers is used).
2408 */
2409 { "CD-ROM CDR-C3 G", NULL, IDE_CD_FLAG_SANYO_3CD },
2410 { "CD-ROM CDR-C3G", NULL, IDE_CD_FLAG_SANYO_3CD },
2411 { "CD-ROM CDR_C36", NULL, IDE_CD_FLAG_SANYO_3CD },
2412 /* Stingray 8X CD-ROM. */
2413 { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_CD_FLAG_PRE_ATAPI12},
2414 /*
2415 * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
2416 * mode sense page capabilities size, but older drives break.
2417 */
2418 { "ATAPI CD ROM DRIVE 50X MAX", NULL, IDE_CD_FLAG_FULL_CAPS_PAGE },
2419 { "WPI CDS-32X", NULL, IDE_CD_FLAG_FULL_CAPS_PAGE },
2420 /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
2421 { "", "241N", IDE_CD_FLAG_LE_SPEED_FIELDS },
2422 /*
2423 * Some drives used by Apple don't advertise audio play
2424 * but they do support reading TOC & audio datas.
2425 */
2426 { "MATSHITADVD-ROM SR-8187", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
2427 { "MATSHITADVD-ROM SR-8186", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
2428 { "MATSHITADVD-ROM SR-8176", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
2429 { "MATSHITADVD-ROM SR-8174", NULL, IDE_CD_FLAG_PLAY_AUDIO_OK },
2430 { NULL, NULL, 0 }
2431};
2432
2433static unsigned int ide_cd_flags(struct hd_driveid *id)
2434{
2435 const struct cd_list_entry *cle = ide_cd_quirks_list;
2436
2437 while (cle->id_model) {
2438 if (strcmp(cle->id_model, id->model) == 0 &&
2439 (cle->id_firmware == NULL ||
2440 strstr(id->fw_rev, cle->id_firmware)))
2441 return cle->cd_flags;
2442 cle++;
2443 }
2444
2445 return 0;
2446}
2447
1da177e4
LT
2448static
2449int ide_cdrom_setup (ide_drive_t *drive)
2450{
4fe67178
BZ
2451 struct cdrom_info *cd = drive->driver_data;
2452 struct cdrom_device_info *cdi = &cd->devinfo;
e59724c7 2453 struct hd_driveid *id = drive->id;
1da177e4
LT
2454 int nslots;
2455
2456 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
2457 blk_queue_dma_alignment(drive->queue, 31);
2458 drive->queue->unplug_delay = (1 * HZ) / 1000;
2459 if (!drive->queue->unplug_delay)
2460 drive->queue->unplug_delay = 1;
2461
2462 drive->special.all = 0;
2463
e59724c7
BZ
2464 cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT |
2465 ide_cd_flags(id);
1da177e4 2466
e59724c7 2467 if ((id->config & 0x0060) == 0x20)
2bc4cf2d 2468 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
e59724c7
BZ
2469
2470 if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) &&
2471 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
2bc4cf2d
BZ
2472 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
2473 IDE_CD_FLAG_TOCADDR_AS_BCD);
e59724c7
BZ
2474 else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) &&
2475 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
2bc4cf2d 2476 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
e59724c7
BZ
2477 else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
2478 cdi->sanyo_slot = 3; /* 3 => use CD in slot 0 */
1da177e4 2479
1da177e4
LT
2480 nslots = ide_cdrom_probe_capabilities (drive);
2481
2482 /*
2483 * set correct block size
2484 */
2485 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
2486
2487 if (drive->autotune == IDE_TUNE_DEFAULT ||
2488 drive->autotune == IDE_TUNE_AUTO)
2489 drive->dsc_overlap = (drive->next != drive);
1da177e4
LT
2490
2491 if (ide_cdrom_register(drive, nslots)) {
2492 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
4fe67178 2493 cd->devinfo.handle = NULL;
1da177e4
LT
2494 return 1;
2495 }
2496 ide_cdrom_add_settings(drive);
2497 return 0;
2498}
2499
ecfd80e4 2500#ifdef CONFIG_IDE_PROC_FS
1da177e4
LT
2501static
2502sector_t ide_cdrom_capacity (ide_drive_t *drive)
2503{
2504 unsigned long capacity, sectors_per_frame;
2505
2506 if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
2507 return 0;
2508
2509 return capacity * sectors_per_frame;
2510}
d97b3214 2511#endif
1da177e4 2512
4031bbe4 2513static void ide_cd_remove(ide_drive_t *drive)
1da177e4
LT
2514{
2515 struct cdrom_info *info = drive->driver_data;
2516
7662d046 2517 ide_proc_unregister_driver(drive, info->driver);
1da177e4
LT
2518
2519 del_gendisk(info->disk);
2520
2521 ide_cd_put(info);
1da177e4
LT
2522}
2523
2524static void ide_cd_release(struct kref *kref)
2525{
2526 struct cdrom_info *info = to_ide_cd(kref);
2527 struct cdrom_device_info *devinfo = &info->devinfo;
2528 ide_drive_t *drive = info->drive;
2529 struct gendisk *g = info->disk;
2530
6044ec88
JJ
2531 kfree(info->buffer);
2532 kfree(info->toc);
1da177e4
LT
2533 if (devinfo->handle == drive && unregister_cdrom(devinfo))
2534 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
2535 "driver.\n", __FUNCTION__, drive->name);
2536 drive->dsc_overlap = 0;
2537 drive->driver_data = NULL;
2538 blk_queue_prep_rq(drive->queue, NULL);
2539 g->private_data = NULL;
2540 put_disk(g);
2541 kfree(info);
2542}
2543
4031bbe4 2544static int ide_cd_probe(ide_drive_t *);
1da177e4 2545
ecfd80e4 2546#ifdef CONFIG_IDE_PROC_FS
1da177e4
LT
2547static int proc_idecd_read_capacity
2548 (char *page, char **start, off_t off, int count, int *eof, void *data)
2549{
2a91f3e5 2550 ide_drive_t *drive = data;
1da177e4
LT
2551 int len;
2552
2553 len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
2554 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
2555}
2556
2557static ide_proc_entry_t idecd_proc[] = {
2558 { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
2559 { NULL, 0, NULL, NULL }
2560};
1da177e4
LT
2561#endif
2562
2563static ide_driver_t ide_cdrom_driver = {
8604affd 2564 .gen_driver = {
4ef3b8f4 2565 .owner = THIS_MODULE,
8604affd
BZ
2566 .name = "ide-cdrom",
2567 .bus = &ide_bus_type,
8604affd 2568 },
4031bbe4
RK
2569 .probe = ide_cd_probe,
2570 .remove = ide_cd_remove,
1da177e4
LT
2571 .version = IDECD_VERSION,
2572 .media = ide_cdrom,
1da177e4 2573 .supports_dsc_overlap = 1,
1da177e4
LT
2574 .do_request = ide_do_rw_cdrom,
2575 .end_request = ide_end_request,
2576 .error = __ide_error,
2577 .abort = __ide_abort,
7662d046 2578#ifdef CONFIG_IDE_PROC_FS
1da177e4 2579 .proc = idecd_proc,
7662d046 2580#endif
1da177e4
LT
2581};
2582
2583static int idecd_open(struct inode * inode, struct file * file)
2584{
2585 struct gendisk *disk = inode->i_bdev->bd_disk;
2586 struct cdrom_info *info;
1da177e4
LT
2587 int rc = -ENOMEM;
2588
2589 if (!(info = ide_cd_get(disk)))
2590 return -ENXIO;
2591
1da177e4 2592 if (!info->buffer)
c94964a4
BZ
2593 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
2594
2595 if (info->buffer)
2596 rc = cdrom_open(&info->devinfo, inode, file);
1da177e4
LT
2597
2598 if (rc < 0)
2599 ide_cd_put(info);
2600
2601 return rc;
2602}
2603
2604static int idecd_release(struct inode * inode, struct file * file)
2605{
2606 struct gendisk *disk = inode->i_bdev->bd_disk;
2607 struct cdrom_info *info = ide_cd_g(disk);
1da177e4
LT
2608
2609 cdrom_release (&info->devinfo, file);
1da177e4
LT
2610
2611 ide_cd_put(info);
2612
2613 return 0;
2614}
2615
6a2900b6
CH
2616static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2617{
2618 struct packet_command cgc;
2619 char buffer[16];
2620 int stat;
2621 char spindown;
2622
2623 if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
2624 return -EFAULT;
2625
2626 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2627
2628 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2629 if (stat)
2630 return stat;
2631
2632 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2633 return cdrom_mode_select(cdi, &cgc);
2634}
2635
2636static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2637{
2638 struct packet_command cgc;
2639 char buffer[16];
2640 int stat;
2641 char spindown;
2642
2643 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2644
2645 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2646 if (stat)
2647 return stat;
2648
2649 spindown = buffer[11] & 0x0f;
2650 if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
2651 return -EFAULT;
2652 return 0;
2653}
2654
1da177e4
LT
2655static int idecd_ioctl (struct inode *inode, struct file *file,
2656 unsigned int cmd, unsigned long arg)
2657{
2658 struct block_device *bdev = inode->i_bdev;
2659 struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
2660 int err;
2661
6a2900b6
CH
2662 switch (cmd) {
2663 case CDROMSETSPINDOWN:
2664 return idecd_set_spindown(&info->devinfo, arg);
2665 case CDROMGETSPINDOWN:
2666 return idecd_get_spindown(&info->devinfo, arg);
2667 default:
2668 break;
2669 }
2670
2671 err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
1da177e4
LT
2672 if (err == -EINVAL)
2673 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
2674
2675 return err;
2676}
2677
2678static int idecd_media_changed(struct gendisk *disk)
2679{
2680 struct cdrom_info *info = ide_cd_g(disk);
2681 return cdrom_media_changed(&info->devinfo);
2682}
2683
2684static int idecd_revalidate_disk(struct gendisk *disk)
2685{
2686 struct cdrom_info *info = ide_cd_g(disk);
2687 struct request_sense sense;
139c829d
BZ
2688
2689 ide_cd_read_toc(info->drive, &sense);
2690
1da177e4
LT
2691 return 0;
2692}
2693
2694static struct block_device_operations idecd_ops = {
2695 .owner = THIS_MODULE,
2696 .open = idecd_open,
2697 .release = idecd_release,
2698 .ioctl = idecd_ioctl,
2699 .media_changed = idecd_media_changed,
2700 .revalidate_disk= idecd_revalidate_disk
2701};
2702
2703/* options */
2704static char *ignore = NULL;
2705
2706module_param(ignore, charp, 0400);
2707MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2708
4031bbe4 2709static int ide_cd_probe(ide_drive_t *drive)
1da177e4
LT
2710{
2711 struct cdrom_info *info;
2712 struct gendisk *g;
2713 struct request_sense sense;
2714
2715 if (!strstr("ide-cdrom", drive->driver_req))
2716 goto failed;
2717 if (!drive->present)
2718 goto failed;
2719 if (drive->media != ide_cdrom && drive->media != ide_optical)
2720 goto failed;
2721 /* skip drives that we were told to ignore */
2722 if (ignore != NULL) {
2723 if (strstr(ignore, drive->name)) {
2724 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
2725 goto failed;
2726 }
2727 }
2728 if (drive->scsi) {
2729 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
2730 goto failed;
2731 }
f5e3c2fa 2732 info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
1da177e4
LT
2733 if (info == NULL) {
2734 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
2735 goto failed;
2736 }
2737
2738 g = alloc_disk(1 << PARTN_BITS);
2739 if (!g)
2740 goto out_free_cd;
2741
2742 ide_init_disk(g, drive);
2743
7662d046 2744 ide_proc_register_driver(drive, &ide_cdrom_driver);
8604affd 2745
1da177e4
LT
2746 kref_init(&info->kref);
2747
2748 info->drive = drive;
2749 info->driver = &ide_cdrom_driver;
2750 info->disk = g;
2751
2752 g->private_data = &info->driver;
2753
2754 drive->driver_data = info;
2755
1da177e4 2756 g->minors = 1;
1da177e4
LT
2757 g->driverfs_dev = &drive->gendev;
2758 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
2759 if (ide_cdrom_setup(drive)) {
7662d046 2760 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
05017db3 2761 ide_cd_release(&info->kref);
1da177e4
LT
2762 goto failed;
2763 }
1da177e4 2764
139c829d 2765 ide_cd_read_toc(drive, &sense);
1da177e4
LT
2766 g->fops = &idecd_ops;
2767 g->flags |= GENHD_FL_REMOVABLE;
2768 add_disk(g);
2769 return 0;
2770
1da177e4
LT
2771out_free_cd:
2772 kfree(info);
2773failed:
8604affd 2774 return -ENODEV;
1da177e4
LT
2775}
2776
2777static void __exit ide_cdrom_exit(void)
2778{
8604affd 2779 driver_unregister(&ide_cdrom_driver.gen_driver);
1da177e4 2780}
17514e8a
BZ
2781
2782static int __init ide_cdrom_init(void)
1da177e4 2783{
8604affd 2784 return driver_register(&ide_cdrom_driver.gen_driver);
1da177e4
LT
2785}
2786
263756ec 2787MODULE_ALIAS("ide:*m-cdrom*");
972560fb 2788MODULE_ALIAS("ide-cd");
1da177e4
LT
2789module_init(ide_cdrom_init);
2790module_exit(ide_cdrom_exit);
2791MODULE_LICENSE("GPL");