396000208f81ddd19062259724de074863110a3c
[linux-2.6.git] / drivers / ide / ide-cd.c
1 /*
2  * ATAPI CD-ROM driver.
3  *
4  * Copyright (C) 1994-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  * Copyright (C) 2005, 2007  Bartlomiej Zolnierkiewicz
8  *
9  * May be copied or modified under the terms of the GNU General Public
10  * License.  See linux/COPYING for more information.
11  *
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  * For historical changelog please see:
23  *      Documentation/ide/ChangeLog.ide-cd.1994-2004
24  */
25
26 #define IDECD_VERSION "5.00"
27
28 #include <linux/module.h>
29 #include <linux/types.h>
30 #include <linux/kernel.h>
31 #include <linux/delay.h>
32 #include <linux/timer.h>
33 #include <linux/slab.h>
34 #include <linux/interrupt.h>
35 #include <linux/errno.h>
36 #include <linux/cdrom.h>
37 #include <linux/ide.h>
38 #include <linux/completion.h>
39 #include <linux/mutex.h>
40 #include <linux/bcd.h>
41
42 #include <scsi/scsi.h>  /* For SCSI -> ATAPI command conversion */
43
44 #include <asm/irq.h>
45 #include <asm/io.h>
46 #include <asm/byteorder.h>
47 #include <asm/uaccess.h>
48 #include <asm/unaligned.h>
49
50 #include "ide-cd.h"
51
52 static DEFINE_MUTEX(idecd_ref_mutex);
53
54 #define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref) 
55
56 #define ide_cd_g(disk) \
57         container_of((disk)->private_data, struct cdrom_info, driver)
58
59 static struct cdrom_info *ide_cd_get(struct gendisk *disk)
60 {
61         struct cdrom_info *cd = NULL;
62
63         mutex_lock(&idecd_ref_mutex);
64         cd = ide_cd_g(disk);
65         if (cd)
66                 kref_get(&cd->kref);
67         mutex_unlock(&idecd_ref_mutex);
68         return cd;
69 }
70
71 static void ide_cd_release(struct kref *);
72
73 static void ide_cd_put(struct cdrom_info *cd)
74 {
75         mutex_lock(&idecd_ref_mutex);
76         kref_put(&cd->kref, ide_cd_release);
77         mutex_unlock(&idecd_ref_mutex);
78 }
79
80 /****************************************************************************
81  * Generic packet command support and error handling routines.
82  */
83
84 /* Mark that we've seen a media change, and invalidate our internal
85    buffers. */
86 static void cdrom_saw_media_change (ide_drive_t *drive)
87 {
88         struct cdrom_info *cd = drive->driver_data;
89
90         cd->cd_flags |= IDE_CD_FLAG_MEDIA_CHANGED;
91         cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
92         cd->nsectors_buffered = 0;
93 }
94
95 static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
96                            struct request_sense *sense)
97 {
98         int log = 0;
99
100         if (!sense || !rq || (rq->cmd_flags & REQ_QUIET))
101                 return 0;
102
103         switch (sense->sense_key) {
104                 case NO_SENSE: case RECOVERED_ERROR:
105                         break;
106                 case NOT_READY:
107                         /*
108                          * don't care about tray state messages for
109                          * e.g. capacity commands or in-progress or
110                          * becoming ready
111                          */
112                         if (sense->asc == 0x3a || sense->asc == 0x04)
113                                 break;
114                         log = 1;
115                         break;
116                 case ILLEGAL_REQUEST:
117                         /*
118                          * don't log START_STOP unit with LoEj set, since
119                          * we cannot reliably check if drive can auto-close
120                          */
121                         if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
122                                 break;
123                         log = 1;
124                         break;
125                 case UNIT_ATTENTION:
126                         /*
127                          * Make good and sure we've seen this potential media
128                          * change. Some drives (i.e. Creative) fail to present
129                          * the correct sense key in the error register.
130                          */
131                         cdrom_saw_media_change(drive);
132                         break;
133                 default:
134                         log = 1;
135                         break;
136         }
137         return log;
138 }
139
140 static
141 void cdrom_analyze_sense_data(ide_drive_t *drive,
142                               struct request *failed_command,
143                               struct request_sense *sense)
144 {
145         unsigned long sector;
146         unsigned long bio_sectors;
147         unsigned long valid;
148         struct cdrom_info *info = drive->driver_data;
149
150         if (!cdrom_log_sense(drive, failed_command, sense))
151                 return;
152
153         /*
154          * If a read toc is executed for a CD-R or CD-RW medium where
155          * the first toc has not been recorded yet, it will fail with
156          * 05/24/00 (which is a confusing error)
157          */
158         if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
159                 if (sense->sense_key == 0x05 && sense->asc == 0x24)
160                         return;
161
162         if (sense->error_code == 0x70) {        /* Current Error */
163                 switch(sense->sense_key) {
164                 case MEDIUM_ERROR:
165                 case VOLUME_OVERFLOW:
166                 case ILLEGAL_REQUEST:
167                         if (!sense->valid)
168                                 break;
169                         if (failed_command == NULL ||
170                                         !blk_fs_request(failed_command))
171                                 break;
172                         sector = (sense->information[0] << 24) |
173                                  (sense->information[1] << 16) |
174                                  (sense->information[2] <<  8) |
175                                  (sense->information[3]);
176
177                         bio_sectors = bio_sectors(failed_command->bio);
178                         if (bio_sectors < 4)
179                                 bio_sectors = 4;
180                         if (drive->queue->hardsect_size == 2048)
181                                 sector <<= 2;   /* Device sector size is 2K */
182                         sector &= ~(bio_sectors -1);
183                         valid = (sector - failed_command->sector) << 9;
184
185                         if (valid < 0)
186                                 valid = 0;
187                         if (sector < get_capacity(info->disk) &&
188                                 drive->probed_capacity - sector < 4 * 75) {
189                                 set_capacity(info->disk, sector);
190                         }
191                 }
192         }
193
194         ide_cd_log_error(drive->name, failed_command, sense);
195 }
196
197 /*
198  * Initialize a ide-cd packet command request
199  */
200 void ide_cd_init_rq(ide_drive_t *drive, struct request *rq)
201 {
202         struct cdrom_info *cd = drive->driver_data;
203
204         ide_init_drive_cmd(rq);
205         rq->cmd_type = REQ_TYPE_ATA_PC;
206         rq->rq_disk = cd->disk;
207 }
208
209 static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
210                                       struct request *failed_command)
211 {
212         struct cdrom_info *info         = drive->driver_data;
213         struct request *rq              = &info->request_sense_request;
214
215         if (sense == NULL)
216                 sense = &info->sense_data;
217
218         /* stuff the sense request in front of our current request */
219         ide_cd_init_rq(drive, rq);
220
221         rq->data = sense;
222         rq->cmd[0] = GPCMD_REQUEST_SENSE;
223         rq->cmd[4] = rq->data_len = 18;
224
225         rq->cmd_type = REQ_TYPE_SENSE;
226
227         /* NOTE! Save the failed command in "rq->buffer" */
228         rq->buffer = (void *) failed_command;
229
230         (void) ide_do_drive_cmd(drive, rq, ide_preempt);
231 }
232
233 static void cdrom_end_request (ide_drive_t *drive, int uptodate)
234 {
235         struct request *rq = HWGROUP(drive)->rq;
236         int nsectors = rq->hard_cur_sectors;
237
238         if (blk_sense_request(rq) && uptodate) {
239                 /*
240                  * For REQ_TYPE_SENSE, "rq->buffer" points to the original
241                  * failed request
242                  */
243                 struct request *failed = (struct request *) rq->buffer;
244                 struct cdrom_info *info = drive->driver_data;
245                 void *sense = &info->sense_data;
246                 unsigned long flags;
247
248                 if (failed) {
249                         if (failed->sense) {
250                                 sense = failed->sense;
251                                 failed->sense_len = rq->sense_len;
252                         }
253                         cdrom_analyze_sense_data(drive, failed, sense);
254                         /*
255                          * now end failed request
256                          */
257                         if (blk_fs_request(failed)) {
258                                 if (ide_end_dequeued_request(drive, failed, 0,
259                                                 failed->hard_nr_sectors))
260                                         BUG();
261                         } else {
262                                 spin_lock_irqsave(&ide_lock, flags);
263                                 if (__blk_end_request(failed, -EIO,
264                                                       failed->data_len))
265                                         BUG();
266                                 spin_unlock_irqrestore(&ide_lock, flags);
267                         }
268                 } else
269                         cdrom_analyze_sense_data(drive, NULL, sense);
270         }
271
272         if (!rq->current_nr_sectors && blk_fs_request(rq))
273                 uptodate = 1;
274         /* make sure it's fully ended */
275         if (blk_pc_request(rq))
276                 nsectors = (rq->data_len + 511) >> 9;
277         if (!nsectors)
278                 nsectors = 1;
279
280         ide_end_request(drive, uptodate, nsectors);
281 }
282
283 static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 stat)
284 {
285         if (stat & 0x80)
286                 return;
287         ide_dump_status(drive, msg, stat);
288 }
289
290 /* Returns 0 if the request should be continued.
291    Returns 1 if the request was ended. */
292 static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
293 {
294         struct request *rq = HWGROUP(drive)->rq;
295         int stat, err, sense_key;
296         
297         /* Check for errors. */
298         stat = ide_read_status(drive);
299
300         if (stat_ret)
301                 *stat_ret = stat;
302
303         if (OK_STAT(stat, good_stat, BAD_R_STAT))
304                 return 0;
305
306         /* Get the IDE error register. */
307         err = ide_read_error(drive);
308         sense_key = err >> 4;
309
310         if (rq == NULL) {
311                 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
312                 return 1;
313         }
314
315         if (blk_sense_request(rq)) {
316                 /* We got an error trying to get sense info
317                    from the drive (probably while trying
318                    to recover from a former error).  Just give up. */
319
320                 rq->cmd_flags |= REQ_FAILED;
321                 cdrom_end_request(drive, 0);
322                 ide_error(drive, "request sense failure", stat);
323                 return 1;
324
325         } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
326                 /* All other functions, except for READ. */
327
328                 /*
329                  * if we have an error, pass back CHECK_CONDITION as the
330                  * scsi status byte
331                  */
332                 if (blk_pc_request(rq) && !rq->errors)
333                         rq->errors = SAM_STAT_CHECK_CONDITION;
334
335                 /* Check for tray open. */
336                 if (sense_key == NOT_READY) {
337                         cdrom_saw_media_change (drive);
338                 } else if (sense_key == UNIT_ATTENTION) {
339                         /* Check for media change. */
340                         cdrom_saw_media_change (drive);
341                         /*printk("%s: media changed\n",drive->name);*/
342                         return 0;
343                 } else if ((sense_key == ILLEGAL_REQUEST) &&
344                            (rq->cmd[0] == GPCMD_START_STOP_UNIT)) {
345                         /*
346                          * Don't print error message for this condition--
347                          * SFF8090i indicates that 5/24/00 is the correct
348                          * response to a request to close the tray if the
349                          * drive doesn't have that capability.
350                          * cdrom_log_sense() knows this!
351                          */
352                 } else if (!(rq->cmd_flags & REQ_QUIET)) {
353                         /* Otherwise, print an error. */
354                         ide_dump_status(drive, "packet command error", stat);
355                 }
356                 
357                 rq->cmd_flags |= REQ_FAILED;
358
359                 /*
360                  * instead of playing games with moving completions around,
361                  * remove failed request completely and end it when the
362                  * request sense has completed
363                  */
364                 goto end_request;
365
366         } else if (blk_fs_request(rq)) {
367                 int do_end_request = 0;
368
369                 /* Handle errors from READ and WRITE requests. */
370
371                 if (blk_noretry_request(rq))
372                         do_end_request = 1;
373
374                 if (sense_key == NOT_READY) {
375                         /* Tray open. */
376                         if (rq_data_dir(rq) == READ) {
377                                 cdrom_saw_media_change (drive);
378
379                                 /* Fail the request. */
380                                 printk ("%s: tray open\n", drive->name);
381                                 do_end_request = 1;
382                         } else {
383                                 struct cdrom_info *info = drive->driver_data;
384
385                                 /* allow the drive 5 seconds to recover, some
386                                  * devices will return this error while flushing
387                                  * data from cache */
388                                 if (!rq->errors)
389                                         info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
390                                 rq->errors = 1;
391                                 if (time_after(jiffies, info->write_timeout))
392                                         do_end_request = 1;
393                                 else {
394                                         unsigned long flags;
395
396                                         /*
397                                          * take a breather relying on the
398                                          * unplug timer to kick us again
399                                          */
400                                         spin_lock_irqsave(&ide_lock, flags);
401                                         blk_plug_device(drive->queue);
402                                         spin_unlock_irqrestore(&ide_lock,flags);
403                                         return 1;
404                                 }
405                         }
406                 } else if (sense_key == UNIT_ATTENTION) {
407                         /* Media change. */
408                         cdrom_saw_media_change (drive);
409
410                         /* Arrange to retry the request.
411                            But be sure to give up if we've retried
412                            too many times. */
413                         if (++rq->errors > ERROR_MAX)
414                                 do_end_request = 1;
415                 } else if (sense_key == ILLEGAL_REQUEST ||
416                            sense_key == DATA_PROTECT) {
417                         /* No point in retrying after an illegal
418                            request or data protect error.*/
419                         ide_dump_status_no_sense (drive, "command error", stat);
420                         do_end_request = 1;
421                 } else if (sense_key == MEDIUM_ERROR) {
422                         /* No point in re-trying a zillion times on a bad 
423                          * sector...  If we got here the error is not correctable */
424                         ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
425                         do_end_request = 1;
426                 } else if (sense_key == BLANK_CHECK) {
427                         /* Disk appears blank ?? */
428                         ide_dump_status_no_sense (drive, "media error (blank)", stat);
429                         do_end_request = 1;
430                 } else if ((err & ~ABRT_ERR) != 0) {
431                         /* Go to the default handler
432                            for other errors. */
433                         ide_error(drive, "cdrom_decode_status", stat);
434                         return 1;
435                 } else if ((++rq->errors > ERROR_MAX)) {
436                         /* We've racked up too many retries.  Abort. */
437                         do_end_request = 1;
438                 }
439
440                 /* End a request through request sense analysis when we have
441                    sense data. We need this in order to perform end of media
442                    processing */
443
444                 if (do_end_request)
445                         goto end_request;
446
447                 /*
448                  * If we got a CHECK_CONDITION status,
449                  * queue a request sense command.
450                  */
451                 if (stat & ERR_STAT)
452                         cdrom_queue_request_sense(drive, NULL, NULL);
453         } else {
454                 blk_dump_rq_flags(rq, "ide-cd: bad rq");
455                 cdrom_end_request(drive, 0);
456         }
457
458         /* Retry, or handle the next request. */
459         return 1;
460
461 end_request:
462         if (stat & ERR_STAT) {
463                 unsigned long flags;
464
465                 spin_lock_irqsave(&ide_lock, flags);
466                 blkdev_dequeue_request(rq);
467                 HWGROUP(drive)->rq = NULL;
468                 spin_unlock_irqrestore(&ide_lock, flags);
469
470                 cdrom_queue_request_sense(drive, rq->sense, rq);
471         } else
472                 cdrom_end_request(drive, 0);
473
474         return 1;
475 }
476
477 static int cdrom_timer_expiry(ide_drive_t *drive)
478 {
479         struct request *rq = HWGROUP(drive)->rq;
480         unsigned long wait = 0;
481
482         /*
483          * Some commands are *slow* and normally take a long time to
484          * complete. Usually we can use the ATAPI "disconnect" to bypass
485          * this, but not all commands/drives support that. Let
486          * ide_timer_expiry keep polling us for these.
487          */
488         switch (rq->cmd[0]) {
489                 case GPCMD_BLANK:
490                 case GPCMD_FORMAT_UNIT:
491                 case GPCMD_RESERVE_RZONE_TRACK:
492                 case GPCMD_CLOSE_TRACK:
493                 case GPCMD_FLUSH_CACHE:
494                         wait = ATAPI_WAIT_PC;
495                         break;
496                 default:
497                         if (!(rq->cmd_flags & REQ_QUIET))
498                                 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
499                         wait = 0;
500                         break;
501         }
502         return wait;
503 }
504
505 /* Set up the device registers for transferring a packet command on DEV,
506    expecting to later transfer XFERLEN bytes.  HANDLER is the routine
507    which actually transfers the command to the drive.  If this is a
508    drq_interrupt device, this routine will arrange for HANDLER to be
509    called when the interrupt from the drive arrives.  Otherwise, HANDLER
510    will be called immediately after the drive is prepared for the transfer. */
511
512 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
513                                                   int xferlen,
514                                                   ide_handler_t *handler)
515 {
516         ide_startstop_t startstop;
517         struct cdrom_info *info = drive->driver_data;
518         ide_hwif_t *hwif = drive->hwif;
519
520         /* Wait for the controller to be idle. */
521         if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
522                 return startstop;
523
524         /* FIXME: for Virtual DMA we must check harder */
525         if (info->dma)
526                 info->dma = !hwif->dma_setup(drive);
527
528         /* Set up the controller registers. */
529         ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL |
530                            IDE_TFLAG_NO_SELECT_MASK, xferlen, info->dma);
531
532         if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
533                 /* waiting for CDB interrupt, not DMA yet. */
534                 if (info->dma)
535                         drive->waiting_for_dma = 0;
536
537                 /* packet command */
538                 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
539                 return ide_started;
540         } else {
541                 unsigned long flags;
542
543                 /* packet command */
544                 spin_lock_irqsave(&ide_lock, flags);
545                 hwif->OUTBSYNC(drive, WIN_PACKETCMD,
546                                hwif->io_ports[IDE_COMMAND_OFFSET]);
547                 ndelay(400);
548                 spin_unlock_irqrestore(&ide_lock, flags);
549
550                 return (*handler) (drive);
551         }
552 }
553
554 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
555    The device registers must have already been prepared
556    by cdrom_start_packet_command.
557    HANDLER is the interrupt handler to call when the command completes
558    or there's data ready. */
559 #define ATAPI_MIN_CDB_BYTES 12
560 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
561                                           struct request *rq,
562                                           ide_handler_t *handler)
563 {
564         ide_hwif_t *hwif = drive->hwif;
565         int cmd_len;
566         struct cdrom_info *info = drive->driver_data;
567         ide_startstop_t startstop;
568
569         if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
570                 /* Here we should have been called after receiving an interrupt
571                    from the device.  DRQ should how be set. */
572
573                 /* Check for errors. */
574                 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
575                         return ide_stopped;
576
577                 /* Ok, next interrupt will be DMA interrupt. */
578                 if (info->dma)
579                         drive->waiting_for_dma = 1;
580         } else {
581                 /* Otherwise, we must wait for DRQ to get set. */
582                 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
583                                 BUSY_STAT, WAIT_READY))
584                         return startstop;
585         }
586
587         /* Arm the interrupt handler. */
588         ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
589
590         /* ATAPI commands get padded out to 12 bytes minimum */
591         cmd_len = COMMAND_SIZE(rq->cmd[0]);
592         if (cmd_len < ATAPI_MIN_CDB_BYTES)
593                 cmd_len = ATAPI_MIN_CDB_BYTES;
594
595         /* Send the command to the device. */
596         HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
597
598         /* Start the DMA if need be */
599         if (info->dma)
600                 hwif->dma_start(drive);
601
602         return ide_started;
603 }
604
605 /****************************************************************************
606  * Block read functions.
607  */
608
609 static void ide_cd_pad_transfer(ide_drive_t *drive, xfer_func_t *xf, int len)
610 {
611         while (len > 0) {
612                 int dum = 0;
613                 xf(drive, &dum, sizeof(dum));
614                 len -= sizeof(dum);
615         }
616 }
617
618 static void ide_cd_drain_data(ide_drive_t *drive, int nsects)
619 {
620         while (nsects > 0) {
621                 static char dum[SECTOR_SIZE];
622
623                 drive->hwif->atapi_input_bytes(drive, dum, sizeof(dum));
624                 nsects--;
625         }
626 }
627
628 /*
629  * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
630  * buffer.  Once the first sector is added, any subsequent sectors are
631  * assumed to be continuous (until the buffer is cleared).  For the first
632  * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
633  * the buffer is cleared.)
634  */
635 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
636                                   int sectors_to_transfer)
637 {
638         struct cdrom_info *info = drive->driver_data;
639
640         /* Number of sectors to read into the buffer. */
641         int sectors_to_buffer = min_t(int, sectors_to_transfer,
642                                      (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
643                                        info->nsectors_buffered);
644
645         char *dest;
646
647         /* If we couldn't get a buffer, don't try to buffer anything... */
648         if (info->buffer == NULL)
649                 sectors_to_buffer = 0;
650
651         /* If this is the first sector in the buffer, remember its number. */
652         if (info->nsectors_buffered == 0)
653                 info->sector_buffered = sector;
654
655         /* Read the data into the buffer. */
656         dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
657         while (sectors_to_buffer > 0) {
658                 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
659                 --sectors_to_buffer;
660                 --sectors_to_transfer;
661                 ++info->nsectors_buffered;
662                 dest += SECTOR_SIZE;
663         }
664
665         /* Throw away any remaining data. */
666         ide_cd_drain_data(drive, sectors_to_transfer);
667 }
668
669 /*
670  * Check the contents of the interrupt reason register from the cdrom
671  * and attempt to recover if there are problems.  Returns  0 if everything's
672  * ok; nonzero if the request has been terminated.
673  */
674 static int ide_cd_check_ireason(ide_drive_t *drive, struct request *rq,
675                                 int len, int ireason, int rw)
676 {
677         /*
678          * ireason == 0: the drive wants to receive data from us
679          * ireason == 2: the drive is expecting to transfer data to us
680          */
681         if (ireason == (!rw << 1))
682                 return 0;
683         else if (ireason == (rw << 1)) {
684                 ide_hwif_t *hwif = drive->hwif;
685                 xfer_func_t *xf;
686
687                 /* Whoops... */
688                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
689                                 drive->name, __FUNCTION__);
690
691                 xf = rw ? hwif->atapi_output_bytes : hwif->atapi_input_bytes;
692                 ide_cd_pad_transfer(drive, xf, len);
693         } else  if (rw == 0 && ireason == 1) {
694                 /* Some drives (ASUS) seem to tell us that status
695                  * info is available. just get it and ignore.
696                  */
697                 (void)ide_read_status(drive);
698                 return 0;
699         } else {
700                 /* Drive wants a command packet, or invalid ireason... */
701                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
702                                 drive->name, __FUNCTION__, ireason);
703         }
704
705         if (rq->cmd_type == REQ_TYPE_ATA_PC)
706                 rq->cmd_flags |= REQ_FAILED;
707
708         cdrom_end_request(drive, 0);
709         return -1;
710 }
711
712 /*
713  * Assume that the drive will always provide data in multiples of at least
714  * SECTOR_SIZE, as it gets hairy to keep track of the transfers otherwise.
715  */
716 static int ide_cd_check_transfer_size(ide_drive_t *drive, int len)
717 {
718         struct cdrom_info *cd = drive->driver_data;
719
720         if ((len % SECTOR_SIZE) == 0)
721                 return 0;
722
723         printk(KERN_ERR "%s: %s: Bad transfer size %d\n",
724                         drive->name, __FUNCTION__, len);
725
726         if (cd->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES)
727                 printk(KERN_ERR "  This drive is not supported by "
728                                 "this version of the driver\n");
729         else {
730                 printk(KERN_ERR "  Trying to limit transfer sizes\n");
731                 cd->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES;
732         }
733
734         return 1;
735 }
736
737 /*
738  * Try to satisfy some of the current read request from our cached data.
739  * Returns nonzero if the request has been completed, zero otherwise.
740  */
741 static int cdrom_read_from_buffer (ide_drive_t *drive)
742 {
743         struct cdrom_info *info = drive->driver_data;
744         struct request *rq = HWGROUP(drive)->rq;
745         unsigned short sectors_per_frame;
746
747         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
748
749         /* Can't do anything if there's no buffer. */
750         if (info->buffer == NULL) return 0;
751
752         /* Loop while this request needs data and the next block is present
753            in our cache. */
754         while (rq->nr_sectors > 0 &&
755                rq->sector >= info->sector_buffered &&
756                rq->sector < info->sector_buffered + info->nsectors_buffered) {
757                 if (rq->current_nr_sectors == 0)
758                         cdrom_end_request(drive, 1);
759
760                 memcpy (rq->buffer,
761                         info->buffer +
762                         (rq->sector - info->sector_buffered) * SECTOR_SIZE,
763                         SECTOR_SIZE);
764                 rq->buffer += SECTOR_SIZE;
765                 --rq->current_nr_sectors;
766                 --rq->nr_sectors;
767                 ++rq->sector;
768         }
769
770         /* If we've satisfied the current request,
771            terminate it successfully. */
772         if (rq->nr_sectors == 0) {
773                 cdrom_end_request(drive, 1);
774                 return -1;
775         }
776
777         /* Move on to the next buffer if needed. */
778         if (rq->current_nr_sectors == 0)
779                 cdrom_end_request(drive, 1);
780
781         /* If this condition does not hold, then the kluge i use to
782            represent the number of sectors to skip at the start of a transfer
783            will fail.  I think that this will never happen, but let's be
784            paranoid and check. */
785         if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
786             (rq->sector & (sectors_per_frame - 1))) {
787                 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
788                         drive->name, (long)rq->sector);
789                 cdrom_end_request(drive, 0);
790                 return -1;
791         }
792
793         return 0;
794 }
795
796 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *);
797
798 /*
799  * Routine to send a read/write packet command to the drive.
800  * This is usually called directly from cdrom_start_{read,write}().
801  * However, for drq_interrupt devices, it is called from an interrupt
802  * when the drive is ready to accept the command.
803  */
804 static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)
805 {
806         struct request *rq = HWGROUP(drive)->rq;
807
808         if (rq_data_dir(rq) == READ) {
809                 unsigned short sectors_per_frame =
810                         queue_hardsect_size(drive->queue) >> SECTOR_BITS;
811                 int nskip = rq->sector & (sectors_per_frame - 1);
812
813                 /*
814                  * If the requested sector doesn't start on a frame boundary,
815                  * we must adjust the start of the transfer so that it does,
816                  * and remember to skip the first few sectors.
817                  *
818                  * If the rq->current_nr_sectors field is larger than the size
819                  * of the buffer, it will mean that we're to skip a number of
820                  * sectors equal to the amount by which rq->current_nr_sectors
821                  * is larger than the buffer size.
822                  */
823                 if (nskip > 0) {
824                         /* Sanity check... */
825                         if (rq->current_nr_sectors !=
826                             bio_cur_sectors(rq->bio)) {
827                                 printk(KERN_ERR "%s: %s: buffer botch (%u)\n",
828                                                 drive->name, __FUNCTION__,
829                                                 rq->current_nr_sectors);
830                                 cdrom_end_request(drive, 0);
831                                 return ide_stopped;
832                         }
833                         rq->current_nr_sectors += nskip;
834                 }
835         }
836 #if 0
837         else
838                 /* the immediate bit */
839                 rq->cmd[1] = 1 << 3;
840 #endif
841         /* Set up the command */
842         rq->timeout = ATAPI_WAIT_PC;
843
844         /* Send the command to the drive and return. */
845         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
846 }
847
848 #define IDECD_SEEK_THRESHOLD    (1000)                  /* 1000 blocks */
849 #define IDECD_SEEK_TIMER        (5 * WAIT_MIN_SLEEP)    /* 100 ms */
850 #define IDECD_SEEK_TIMEOUT      (2 * WAIT_CMD)          /* 20 sec */
851
852 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
853 {
854         struct cdrom_info *info = drive->driver_data;
855         int stat;
856         static int retry = 10;
857
858         if (cdrom_decode_status(drive, 0, &stat))
859                 return ide_stopped;
860
861         info->cd_flags |= IDE_CD_FLAG_SEEKING;
862
863         if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
864                 if (--retry == 0) {
865                         /*
866                          * this condition is far too common, to bother
867                          * users about it
868                          */
869                         /* printk("%s: disabled DSC seek overlap\n", drive->name);*/ 
870                         drive->dsc_overlap = 0;
871                 }
872         }
873         return ide_stopped;
874 }
875
876 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
877 {
878         struct request *rq = HWGROUP(drive)->rq;
879         sector_t frame = rq->sector;
880
881         sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
882
883         memset(rq->cmd, 0, sizeof(rq->cmd));
884         rq->cmd[0] = GPCMD_SEEK;
885         put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
886
887         rq->timeout = ATAPI_WAIT_PC;
888         return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
889 }
890
891 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
892 {
893         struct cdrom_info *info = drive->driver_data;
894
895         info->dma = 0;
896         info->start_seek = jiffies;
897         return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
898 }
899
900 /* Fix up a possibly partially-processed request so that we can
901    start it over entirely, or even put it back on the request queue. */
902 static void restore_request (struct request *rq)
903 {
904         if (rq->buffer != bio_data(rq->bio)) {
905                 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
906
907                 rq->buffer = bio_data(rq->bio);
908                 rq->nr_sectors += n;
909                 rq->sector -= n;
910         }
911         rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
912         rq->hard_nr_sectors = rq->nr_sectors;
913         rq->hard_sector = rq->sector;
914         rq->q->prep_rq_fn(rq->q, rq);
915 }
916
917 /****************************************************************************
918  * Execute all other packet commands.
919  */
920
921 static void ide_cd_request_sense_fixup(struct request *rq)
922 {
923         /*
924          * Some of the trailing request sense fields are optional,
925          * and some drives don't send them.  Sigh.
926          */
927         if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
928             rq->data_len > 0 && rq->data_len <= 5)
929                 while (rq->data_len > 0) {
930                         *(u8 *)rq->data++ = 0;
931                         --rq->data_len;
932                 }
933 }
934
935 int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq)
936 {
937         struct request_sense sense;
938         int retries = 10;
939         unsigned int flags = rq->cmd_flags;
940
941         if (rq->sense == NULL)
942                 rq->sense = &sense;
943
944         /* Start of retry loop. */
945         do {
946                 int error;
947                 unsigned long time = jiffies;
948                 rq->cmd_flags = flags;
949
950                 error = ide_do_drive_cmd(drive, rq, ide_wait);
951                 time = jiffies - time;
952
953                 /* FIXME: we should probably abort/retry or something 
954                  * in case of failure */
955                 if (rq->cmd_flags & REQ_FAILED) {
956                         /* The request failed.  Retry if it was due to a unit
957                            attention status
958                            (usually means media was changed). */
959                         struct request_sense *reqbuf = rq->sense;
960
961                         if (reqbuf->sense_key == UNIT_ATTENTION)
962                                 cdrom_saw_media_change(drive);
963                         else if (reqbuf->sense_key == NOT_READY &&
964                                  reqbuf->asc == 4 && reqbuf->ascq != 4) {
965                                 /* The drive is in the process of loading
966                                    a disk.  Retry, but wait a little to give
967                                    the drive time to complete the load. */
968                                 ssleep(2);
969                         } else {
970                                 /* Otherwise, don't retry. */
971                                 retries = 0;
972                         }
973                         --retries;
974                 }
975
976                 /* End of retry loop. */
977         } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
978
979         /* Return an error if the command failed. */
980         return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
981 }
982
983 /*
984  * Called from blk_end_request_callback() after the data of the request
985  * is completed and before the request is completed.
986  * By returning value '1', blk_end_request_callback() returns immediately
987  * without completing the request.
988  */
989 static int cdrom_newpc_intr_dummy_cb(struct request *rq)
990 {
991         return 1;
992 }
993
994 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
995 {
996         ide_hwif_t *hwif = drive->hwif;
997         struct cdrom_info *info = drive->driver_data;
998         struct request *rq = HWGROUP(drive)->rq;
999         xfer_func_t *xferfunc;
1000         ide_expiry_t *expiry = NULL;
1001         int dma_error = 0, dma, stat, ireason, len, thislen, uptodate = 0;
1002         int write = (rq_data_dir(rq) == WRITE) ? 1 : 0;
1003         unsigned int timeout;
1004         u8 lowcyl, highcyl;
1005
1006         /* Check for errors. */
1007         dma = info->dma;
1008         if (dma) {
1009                 info->dma = 0;
1010                 dma_error = HWIF(drive)->ide_dma_end(drive);
1011                 if (dma_error) {
1012                         printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1013                                         write ? "write" : "read");
1014                         ide_dma_off(drive);
1015                 }
1016         }
1017
1018         if (cdrom_decode_status(drive, 0, &stat))
1019                 return ide_stopped;
1020
1021         /*
1022          * using dma, transfer is complete now
1023          */
1024         if (dma) {
1025                 if (dma_error)
1026                         return ide_error(drive, "dma error", stat);
1027                 if (blk_fs_request(rq)) {
1028                         ide_end_request(drive, 1, rq->nr_sectors);
1029                         return ide_stopped;
1030                 }
1031                 goto end_request;
1032         }
1033
1034         /*
1035          * ok we fall to pio :/
1036          */
1037         ireason = hwif->INB(hwif->io_ports[IDE_IREASON_OFFSET]) & 0x3;
1038         lowcyl  = hwif->INB(hwif->io_ports[IDE_BCOUNTL_OFFSET]);
1039         highcyl = hwif->INB(hwif->io_ports[IDE_BCOUNTH_OFFSET]);
1040
1041         len = lowcyl + (256 * highcyl);
1042
1043         thislen = blk_fs_request(rq) ? len : rq->data_len;
1044         if (thislen > len)
1045                 thislen = len;
1046
1047         /*
1048          * If DRQ is clear, the command has completed.
1049          */
1050         if ((stat & DRQ_STAT) == 0) {
1051                 if (blk_fs_request(rq)) {
1052                         /*
1053                          * If we're not done reading/writing, complain.
1054                          * Otherwise, complete the command normally.
1055                          */
1056                         uptodate = 1;
1057                         if (rq->current_nr_sectors > 0) {
1058                                 printk(KERN_ERR "%s: %s: data underrun "
1059                                                 "(%d blocks)\n",
1060                                                 drive->name, __FUNCTION__,
1061                                                 rq->current_nr_sectors);
1062                                 if (!write)
1063                                         rq->cmd_flags |= REQ_FAILED;
1064                                 uptodate = 0;
1065                         }
1066                         cdrom_end_request(drive, uptodate);
1067                         return ide_stopped;
1068                 } else if (!blk_pc_request(rq)) {
1069                         ide_cd_request_sense_fixup(rq);
1070                         /* Complain if we still have data left to transfer. */
1071                         uptodate = rq->data_len ? 0 : 1;
1072                 }
1073                 goto end_request;
1074         }
1075
1076         /*
1077          * check which way to transfer data
1078          */
1079         if (ide_cd_check_ireason(drive, rq, len, ireason, write))
1080                 return ide_stopped;
1081
1082         if (blk_fs_request(rq)) {
1083                 if (write == 0) {
1084                         int nskip;
1085
1086                         if (ide_cd_check_transfer_size(drive, len)) {
1087                                 cdrom_end_request(drive, 0);
1088                                 return ide_stopped;
1089                         }
1090
1091                         /*
1092                          * First, figure out if we need to bit-bucket
1093                          * any of the leading sectors.
1094                          */
1095                         nskip = min_t(int, rq->current_nr_sectors
1096                                            - bio_cur_sectors(rq->bio),
1097                                            thislen >> 9);
1098                         if (nskip > 0) {
1099                                 ide_cd_drain_data(drive, nskip);
1100                                 rq->current_nr_sectors -= nskip;
1101                                 thislen -= (nskip << 9);
1102                         }
1103                 }
1104         }
1105
1106         if (ireason == 0) {
1107                 write = 1;
1108                 xferfunc = HWIF(drive)->atapi_output_bytes;
1109         } else {
1110                 write = 0;
1111                 xferfunc = HWIF(drive)->atapi_input_bytes;
1112         }
1113
1114         /*
1115          * transfer data
1116          */
1117         while (thislen > 0) {
1118                 u8 *ptr = blk_fs_request(rq) ? NULL : rq->data;
1119                 int blen = rq->data_len;
1120
1121                 /*
1122                  * bio backed?
1123                  */
1124                 if (rq->bio) {
1125                         if (blk_fs_request(rq)) {
1126                                 ptr = rq->buffer;
1127                                 blen = rq->current_nr_sectors << 9;
1128                         } else {
1129                                 ptr = bio_data(rq->bio);
1130                                 blen = bio_iovec(rq->bio)->bv_len;
1131                         }
1132                 }
1133
1134                 if (!ptr) {
1135                         if (blk_fs_request(rq) && !write)
1136                                 /*
1137                                  * If the buffers are full, cache the rest
1138                                  * of the data in our internal buffer.
1139                                  */
1140                                 cdrom_buffer_sectors(drive, rq->sector,
1141                                                      thislen >> 9);
1142                         else {
1143                                 printk(KERN_ERR "%s: confused, missing data\n",
1144                                                 drive->name);
1145                                 blk_dump_rq_flags(rq, rq_data_dir(rq)
1146                                                   ? "cdrom_newpc_intr, write"
1147                                                   : "cdrom_newpc_intr, read");
1148                         }
1149                         break;
1150                 }
1151
1152                 if (blen > thislen)
1153                         blen = thislen;
1154
1155                 xferfunc(drive, ptr, blen);
1156
1157                 thislen -= blen;
1158                 len -= blen;
1159
1160                 if (blk_fs_request(rq)) {
1161                         rq->buffer += blen;
1162                         rq->nr_sectors -= (blen >> 9);
1163                         rq->current_nr_sectors -= (blen >> 9);
1164                         rq->sector += (blen >> 9);
1165
1166                         if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1167                                 cdrom_end_request(drive, 1);
1168                 } else {
1169                         rq->data_len -= blen;
1170
1171                         /*
1172                          * The request can't be completed until DRQ is cleared.
1173                          * So complete the data, but don't complete the request
1174                          * using the dummy function for the callback feature
1175                          * of blk_end_request_callback().
1176                          */
1177                         if (rq->bio)
1178                                 blk_end_request_callback(rq, 0, blen,
1179                                                  cdrom_newpc_intr_dummy_cb);
1180                         else
1181                                 rq->data += blen;
1182                 }
1183                 if (!write && blk_sense_request(rq))
1184                         rq->sense_len += blen;
1185         }
1186
1187         /*
1188          * pad, if necessary
1189          */
1190         if (!blk_fs_request(rq) && len > 0)
1191                 ide_cd_pad_transfer(drive, xferfunc, len);
1192
1193         if (blk_pc_request(rq)) {
1194                 timeout = rq->timeout;
1195         } else {
1196                 timeout = ATAPI_WAIT_PC;
1197                 if (!blk_fs_request(rq))
1198                         expiry = cdrom_timer_expiry;
1199         }
1200
1201         ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
1202         return ide_started;
1203
1204 end_request:
1205         if (blk_pc_request(rq)) {
1206                 unsigned long flags;
1207                 unsigned int dlen = rq->data_len;
1208
1209                 if (dma)
1210                         rq->data_len = 0;
1211
1212                 spin_lock_irqsave(&ide_lock, flags);
1213                 if (__blk_end_request(rq, 0, dlen))
1214                         BUG();
1215                 HWGROUP(drive)->rq = NULL;
1216                 spin_unlock_irqrestore(&ide_lock, flags);
1217         } else {
1218                 if (!uptodate)
1219                         rq->cmd_flags |= REQ_FAILED;
1220                 cdrom_end_request(drive, uptodate);
1221         }
1222         return ide_stopped;
1223 }
1224
1225 static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
1226 {
1227         struct cdrom_info *cd = drive->driver_data;
1228         int write = rq_data_dir(rq) == WRITE;
1229         unsigned short sectors_per_frame =
1230                 queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1231
1232         if (write) {
1233                 /*
1234                  * disk has become write protected
1235                  */
1236                 if (cd->disk->policy) {
1237                         cdrom_end_request(drive, 0);
1238                         return ide_stopped;
1239                 }
1240         } else {
1241                 /*
1242                  * We may be retrying this request after an error.  Fix up any
1243                  * weirdness which might be present in the request packet.
1244                  */
1245                 restore_request(rq);
1246
1247                 /* Satisfy whatever we can of this request from our cache. */
1248                 if (cdrom_read_from_buffer(drive))
1249                         return ide_stopped;
1250         }
1251
1252         /*
1253          * use DMA, if possible / writes *must* be hardware frame aligned
1254          */
1255         if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1256             (rq->sector & (sectors_per_frame - 1))) {
1257                 if (write) {
1258                         cdrom_end_request(drive, 0);
1259                         return ide_stopped;
1260                 }
1261                 cd->dma = 0;
1262         } else
1263                 cd->dma = drive->using_dma;
1264
1265         /* Clear the local sector buffer. */
1266         cd->nsectors_buffered = 0;
1267
1268         if (write)
1269                 cd->devinfo.media_written = 1;
1270
1271         /* Start sending the read/write request to the drive. */
1272         return cdrom_start_packet_command(drive, 32768, cdrom_start_rw_cont);
1273 }
1274
1275 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1276 {
1277         struct request *rq = HWGROUP(drive)->rq;
1278
1279         if (!rq->timeout)
1280                 rq->timeout = ATAPI_WAIT_PC;
1281
1282         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1283 }
1284
1285 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1286 {
1287         struct cdrom_info *info = drive->driver_data;
1288
1289         if (blk_pc_request(rq))
1290                 rq->cmd_flags |= REQ_QUIET;
1291         else
1292                 rq->cmd_flags &= ~REQ_FAILED;
1293
1294         info->dma = 0;
1295
1296         /*
1297          * sg request
1298          */
1299         if (rq->bio) {
1300                 int mask = drive->queue->dma_alignment;
1301                 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1302
1303                 info->dma = drive->using_dma;
1304
1305                 /*
1306                  * check if dma is safe
1307                  *
1308                  * NOTE! The "len" and "addr" checks should possibly have
1309                  * separate masks.
1310                  */
1311                 if ((rq->data_len & 15) || (addr & mask))
1312                         info->dma = 0;
1313         }
1314
1315         /* Start sending the command to the drive. */
1316         return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1317 }
1318
1319 /****************************************************************************
1320  * cdrom driver request routine.
1321  */
1322 static ide_startstop_t
1323 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1324 {
1325         ide_startstop_t action;
1326         struct cdrom_info *info = drive->driver_data;
1327
1328         if (blk_fs_request(rq)) {
1329                 if (info->cd_flags & IDE_CD_FLAG_SEEKING) {
1330                         unsigned long elapsed = jiffies - info->start_seek;
1331                         int stat = ide_read_status(drive);
1332
1333                         if ((stat & SEEK_STAT) != SEEK_STAT) {
1334                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
1335                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
1336                                         return ide_stopped;
1337                                 }
1338                                 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1339                         }
1340                         info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
1341                 }
1342                 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1343                         action = cdrom_start_seek(drive, block);
1344                 } else
1345                         action = cdrom_start_rw(drive, rq);
1346                 info->last_block = block;
1347                 return action;
1348         } else if (blk_sense_request(rq) || blk_pc_request(rq) ||
1349                    rq->cmd_type == REQ_TYPE_ATA_PC) {
1350                 return cdrom_do_block_pc(drive, rq);
1351         } else if (blk_special_request(rq)) {
1352                 /*
1353                  * right now this can only be a reset...
1354                  */
1355                 cdrom_end_request(drive, 1);
1356                 return ide_stopped;
1357         }
1358
1359         blk_dump_rq_flags(rq, "ide-cd bad flags");
1360         cdrom_end_request(drive, 0);
1361         return ide_stopped;
1362 }
1363
1364
1365
1366 /****************************************************************************
1367  * Ioctl handling.
1368  *
1369  * Routines which queue packet commands take as a final argument a pointer
1370  * to a request_sense struct.  If execution of the command results
1371  * in an error with a CHECK CONDITION status, this structure will be filled
1372  * with the results of the subsequent request sense command.  The pointer
1373  * can also be NULL, in which case no sense information is returned.
1374  */
1375
1376 static
1377 void msf_from_bcd (struct atapi_msf *msf)
1378 {
1379         msf->minute = BCD2BIN(msf->minute);
1380         msf->second = BCD2BIN(msf->second);
1381         msf->frame  = BCD2BIN(msf->frame);
1382 }
1383
1384 int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
1385 {
1386         struct request req;
1387         struct cdrom_info *info = drive->driver_data;
1388         struct cdrom_device_info *cdi = &info->devinfo;
1389
1390         ide_cd_init_rq(drive, &req);
1391
1392         req.sense = sense;
1393         req.cmd[0] = GPCMD_TEST_UNIT_READY;
1394         req.cmd_flags |= REQ_QUIET;
1395
1396         /*
1397          * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1398          * switch CDs instead of supporting the LOAD_UNLOAD opcode.
1399          */
1400         req.cmd[7] = cdi->sanyo_slot % 3;
1401
1402         return ide_cd_queue_pc(drive, &req);
1403 }
1404
1405 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
1406                                unsigned long *sectors_per_frame,
1407                                struct request_sense *sense)
1408 {
1409         struct {
1410                 __u32 lba;
1411                 __u32 blocklen;
1412         } capbuf;
1413
1414         int stat;
1415         struct request req;
1416
1417         ide_cd_init_rq(drive, &req);
1418
1419         req.sense = sense;
1420         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
1421         req.data = (char *)&capbuf;
1422         req.data_len = sizeof(capbuf);
1423         req.cmd_flags |= REQ_QUIET;
1424
1425         stat = ide_cd_queue_pc(drive, &req);
1426         if (stat == 0) {
1427                 *capacity = 1 + be32_to_cpu(capbuf.lba);
1428                 *sectors_per_frame =
1429                         be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
1430         }
1431
1432         return stat;
1433 }
1434
1435 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
1436                                 int format, char *buf, int buflen,
1437                                 struct request_sense *sense)
1438 {
1439         struct request req;
1440
1441         ide_cd_init_rq(drive, &req);
1442
1443         req.sense = sense;
1444         req.data =  buf;
1445         req.data_len = buflen;
1446         req.cmd_flags |= REQ_QUIET;
1447         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
1448         req.cmd[6] = trackno;
1449         req.cmd[7] = (buflen >> 8);
1450         req.cmd[8] = (buflen & 0xff);
1451         req.cmd[9] = (format << 6);
1452
1453         if (msf_flag)
1454                 req.cmd[1] = 2;
1455
1456         return ide_cd_queue_pc(drive, &req);
1457 }
1458
1459 /* Try to read the entire TOC for the disk into our internal buffer. */
1460 int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
1461 {
1462         int stat, ntracks, i;
1463         struct cdrom_info *info = drive->driver_data;
1464         struct cdrom_device_info *cdi = &info->devinfo;
1465         struct atapi_toc *toc = info->toc;
1466         struct {
1467                 struct atapi_toc_header hdr;
1468                 struct atapi_toc_entry  ent;
1469         } ms_tmp;
1470         long last_written;
1471         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
1472
1473         if (toc == NULL) {
1474                 /* Try to allocate space. */
1475                 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
1476                 if (toc == NULL) {
1477                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
1478                         return -ENOMEM;
1479                 }
1480                 info->toc = toc;
1481         }
1482
1483         /* Check to see if the existing data is still valid.
1484            If it is, just return. */
1485         (void) cdrom_check_status(drive, sense);
1486
1487         if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
1488                 return 0;
1489
1490         /* Try to get the total cdrom capacity and sector size. */
1491         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
1492                                    sense);
1493         if (stat)
1494                 toc->capacity = 0x1fffff;
1495
1496         set_capacity(info->disk, toc->capacity * sectors_per_frame);
1497         /* Save a private copy of te TOC capacity for error handling */
1498         drive->probed_capacity = toc->capacity * sectors_per_frame;
1499
1500         blk_queue_hardsect_size(drive->queue,
1501                                 sectors_per_frame << SECTOR_BITS);
1502
1503         /* First read just the header, so we know how long the TOC is. */
1504         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
1505                                     sizeof(struct atapi_toc_header), sense);
1506         if (stat)
1507                 return stat;
1508
1509         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1510                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1511                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1512         }
1513
1514         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1515         if (ntracks <= 0)
1516                 return -EIO;
1517         if (ntracks > MAX_TRACKS)
1518                 ntracks = MAX_TRACKS;
1519
1520         /* Now read the whole schmeer. */
1521         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
1522                                   (char *)&toc->hdr,
1523                                    sizeof(struct atapi_toc_header) +
1524                                    (ntracks + 1) *
1525                                    sizeof(struct atapi_toc_entry), sense);
1526
1527         if (stat && toc->hdr.first_track > 1) {
1528                 /* Cds with CDI tracks only don't have any TOC entries,
1529                    despite of this the returned values are
1530                    first_track == last_track = number of CDI tracks + 1,
1531                    so that this case is indistinguishable from the same
1532                    layout plus an additional audio track.
1533                    If we get an error for the regular case, we assume
1534                    a CDI without additional audio tracks. In this case
1535                    the readable TOC is empty (CDI tracks are not included)
1536                    and only holds the Leadout entry. Heiko EiƟfeldt */
1537                 ntracks = 0;
1538                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
1539                                            (char *)&toc->hdr,
1540                                            sizeof(struct atapi_toc_header) +
1541                                            (ntracks + 1) *
1542                                            sizeof(struct atapi_toc_entry),
1543                                            sense);
1544                 if (stat)
1545                         return stat;
1546
1547                 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1548                         toc->hdr.first_track = (u8)BIN2BCD(CDROM_LEADOUT);
1549                         toc->hdr.last_track = (u8)BIN2BCD(CDROM_LEADOUT);
1550                 } else {
1551                         toc->hdr.first_track = CDROM_LEADOUT;
1552                         toc->hdr.last_track = CDROM_LEADOUT;
1553                 }
1554         }
1555
1556         if (stat)
1557                 return stat;
1558
1559         toc->hdr.toc_length = be16_to_cpu(toc->hdr.toc_length);
1560
1561         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1562                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1563                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1564         }
1565
1566         for (i = 0; i <= ntracks; i++) {
1567                 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1568                         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD)
1569                                 toc->ent[i].track = BCD2BIN(toc->ent[i].track);
1570                         msf_from_bcd(&toc->ent[i].addr.msf);
1571                 }
1572                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
1573                                                    toc->ent[i].addr.msf.second,
1574                                                    toc->ent[i].addr.msf.frame);
1575         }
1576
1577         /* Read the multisession information. */
1578         if (toc->hdr.first_track != CDROM_LEADOUT) {
1579                 /* Read the multisession information. */
1580                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
1581                                            sizeof(ms_tmp), sense);
1582                 if (stat)
1583                         return stat;
1584
1585                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
1586         } else {
1587                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
1588                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
1589         }
1590
1591         if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1592                 /* Re-read multisession information using MSF format */
1593                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
1594                                            sizeof(ms_tmp), sense);
1595                 if (stat)
1596                         return stat;
1597
1598                 msf_from_bcd (&ms_tmp.ent.addr.msf);
1599                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1600                                                    ms_tmp.ent.addr.msf.second,
1601                                                    ms_tmp.ent.addr.msf.frame);
1602         }
1603
1604         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
1605
1606         /* Now try to get the total cdrom capacity. */
1607         stat = cdrom_get_last_written(cdi, &last_written);
1608         if (!stat && (last_written > toc->capacity)) {
1609                 toc->capacity = last_written;
1610                 set_capacity(info->disk, toc->capacity * sectors_per_frame);
1611                 drive->probed_capacity = toc->capacity * sectors_per_frame;
1612         }
1613
1614         /* Remember that we've read this stuff. */
1615         info->cd_flags |= IDE_CD_FLAG_TOC_VALID;
1616
1617         return 0;
1618 }
1619
1620 int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
1621 {
1622         struct cdrom_info *info = drive->driver_data;
1623         struct cdrom_device_info *cdi = &info->devinfo;
1624         struct packet_command cgc;
1625         int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
1626
1627         if ((info->cd_flags & IDE_CD_FLAG_FULL_CAPS_PAGE) == 0)
1628                 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
1629
1630         init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
1631         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
1632                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
1633                 if (!stat)
1634                         break;
1635         } while (--attempts);
1636         return stat;
1637 }
1638
1639 void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
1640 {
1641         struct cdrom_info *cd = drive->driver_data;
1642         u16 curspeed, maxspeed;
1643
1644         curspeed = *(u16 *)&buf[8 + 14];
1645         maxspeed = *(u16 *)&buf[8 +  8];
1646
1647         if (cd->cd_flags & IDE_CD_FLAG_LE_SPEED_FIELDS) {
1648                 curspeed = le16_to_cpu(curspeed);
1649                 maxspeed = le16_to_cpu(maxspeed);
1650         } else {
1651                 curspeed = be16_to_cpu(curspeed);
1652                 maxspeed = be16_to_cpu(maxspeed);
1653         }
1654
1655         cd->current_speed = (curspeed + (176/2)) / 176;
1656         cd->max_speed = (maxspeed + (176/2)) / 176;
1657 }
1658
1659 #define IDE_CD_CAPABILITIES \
1660         (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
1661          CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
1662          CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
1663          CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
1664          CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
1665
1666 static struct cdrom_device_ops ide_cdrom_dops = {
1667         .open                   = ide_cdrom_open_real,
1668         .release                = ide_cdrom_release_real,
1669         .drive_status           = ide_cdrom_drive_status,
1670         .media_changed          = ide_cdrom_check_media_change_real,
1671         .tray_move              = ide_cdrom_tray_move,
1672         .lock_door              = ide_cdrom_lock_door,
1673         .select_speed           = ide_cdrom_select_speed,
1674         .get_last_session       = ide_cdrom_get_last_session,
1675         .get_mcn                = ide_cdrom_get_mcn,
1676         .reset                  = ide_cdrom_reset,
1677         .audio_ioctl            = ide_cdrom_audio_ioctl,
1678         .capability             = IDE_CD_CAPABILITIES,
1679         .generic_packet         = ide_cdrom_packet,
1680 };
1681
1682 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
1683 {
1684         struct cdrom_info *info = drive->driver_data;
1685         struct cdrom_device_info *devinfo = &info->devinfo;
1686
1687         devinfo->ops = &ide_cdrom_dops;
1688         devinfo->speed = info->current_speed;
1689         devinfo->capacity = nslots;
1690         devinfo->handle = drive;
1691         strcpy(devinfo->name, drive->name);
1692
1693         if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT)
1694                 devinfo->mask |= CDC_SELECT_SPEED;
1695
1696         devinfo->disk = info->disk;
1697         return register_cdrom(devinfo);
1698 }
1699
1700 static
1701 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
1702 {
1703         struct cdrom_info *cd = drive->driver_data;
1704         struct cdrom_device_info *cdi = &cd->devinfo;
1705         u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
1706         mechtype_t mechtype;
1707         int nslots = 1;
1708
1709         cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
1710                      CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO |
1711                      CDC_MO_DRIVE | CDC_RAM);
1712
1713         if (drive->media == ide_optical) {
1714                 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
1715                 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
1716                 return nslots;
1717         }
1718
1719         if (cd->cd_flags & IDE_CD_FLAG_PRE_ATAPI12) {
1720                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
1721                 cdi->mask &= ~CDC_PLAY_AUDIO;
1722                 return nslots;
1723         }
1724
1725         /*
1726          * we have to cheat a little here. the packet will eventually
1727          * be queued with ide_cdrom_packet(), which extracts the
1728          * drive from cdi->handle. Since this device hasn't been
1729          * registered with the Uniform layer yet, it can't do this.
1730          * Same goes for cdi->ops.
1731          */
1732         cdi->handle = drive;
1733         cdi->ops = &ide_cdrom_dops;
1734
1735         if (ide_cdrom_get_capabilities(drive, buf))
1736                 return 0;
1737
1738         if ((buf[8 + 6] & 0x01) == 0)
1739                 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
1740         if (buf[8 + 6] & 0x08)
1741                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
1742         if (buf[8 + 3] & 0x01)
1743                 cdi->mask &= ~CDC_CD_R;
1744         if (buf[8 + 3] & 0x02)
1745                 cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
1746         if (buf[8 + 2] & 0x38)
1747                 cdi->mask &= ~CDC_DVD;
1748         if (buf[8 + 3] & 0x20)
1749                 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
1750         if (buf[8 + 3] & 0x10)
1751                 cdi->mask &= ~CDC_DVD_R;
1752         if ((buf[8 + 4] & 0x01) || (cd->cd_flags & IDE_CD_FLAG_PLAY_AUDIO_OK))
1753                 cdi->mask &= ~CDC_PLAY_AUDIO;
1754
1755         mechtype = buf[8 + 6] >> 5;
1756         if (mechtype == mechtype_caddy || mechtype == mechtype_popup)
1757                 cdi->mask |= CDC_CLOSE_TRAY;
1758
1759         if (cdi->sanyo_slot > 0) {
1760                 cdi->mask &= ~CDC_SELECT_DISC;
1761                 nslots = 3;
1762         } else if (mechtype == mechtype_individual_changer ||
1763                    mechtype == mechtype_cartridge_changer) {
1764                 nslots = cdrom_number_of_slots(cdi);
1765                 if (nslots > 1)
1766                         cdi->mask &= ~CDC_SELECT_DISC;
1767         }
1768
1769         ide_cdrom_update_speed(drive, buf);
1770
1771         printk(KERN_INFO "%s: ATAPI", drive->name);
1772
1773         /* don't print speed if the drive reported 0 */
1774         if (cd->max_speed)
1775                 printk(KERN_CONT " %dX", cd->max_speed);
1776
1777         printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM");
1778
1779         if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
1780                 printk(KERN_CONT " DVD%s%s",
1781                                  (cdi->mask & CDC_DVD_R) ? "" : "-R",
1782                                  (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
1783
1784         if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
1785                 printk(KERN_CONT " CD%s%s",
1786                                  (cdi->mask & CDC_CD_R) ? "" : "-R",
1787                                  (cdi->mask & CDC_CD_RW) ? "" : "/RW");
1788
1789         if ((cdi->mask & CDC_SELECT_DISC) == 0)
1790                 printk(KERN_CONT " changer w/%d slots", nslots);
1791         else
1792                 printk(KERN_CONT " drive");
1793
1794         printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12]));
1795
1796         return nslots;
1797 }
1798
1799 #ifdef CONFIG_IDE_PROC_FS
1800 static void ide_cdrom_add_settings(ide_drive_t *drive)
1801 {
1802         ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
1803 }
1804 #else
1805 static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
1806 #endif
1807
1808 /*
1809  * standard prep_rq_fn that builds 10 byte cmds
1810  */
1811 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
1812 {
1813         int hard_sect = queue_hardsect_size(q);
1814         long block = (long)rq->hard_sector / (hard_sect >> 9);
1815         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
1816
1817         memset(rq->cmd, 0, sizeof(rq->cmd));
1818
1819         if (rq_data_dir(rq) == READ)
1820                 rq->cmd[0] = GPCMD_READ_10;
1821         else
1822                 rq->cmd[0] = GPCMD_WRITE_10;
1823
1824         /*
1825          * fill in lba
1826          */
1827         rq->cmd[2] = (block >> 24) & 0xff;
1828         rq->cmd[3] = (block >> 16) & 0xff;
1829         rq->cmd[4] = (block >>  8) & 0xff;
1830         rq->cmd[5] = block & 0xff;
1831
1832         /*
1833          * and transfer length
1834          */
1835         rq->cmd[7] = (blocks >> 8) & 0xff;
1836         rq->cmd[8] = blocks & 0xff;
1837         rq->cmd_len = 10;
1838         return BLKPREP_OK;
1839 }
1840
1841 /*
1842  * Most of the SCSI commands are supported directly by ATAPI devices.
1843  * This transform handles the few exceptions.
1844  */
1845 static int ide_cdrom_prep_pc(struct request *rq)
1846 {
1847         u8 *c = rq->cmd;
1848
1849         /*
1850          * Transform 6-byte read/write commands to the 10-byte version
1851          */
1852         if (c[0] == READ_6 || c[0] == WRITE_6) {
1853                 c[8] = c[4];
1854                 c[5] = c[3];
1855                 c[4] = c[2];
1856                 c[3] = c[1] & 0x1f;
1857                 c[2] = 0;
1858                 c[1] &= 0xe0;
1859                 c[0] += (READ_10 - READ_6);
1860                 rq->cmd_len = 10;
1861                 return BLKPREP_OK;
1862         }
1863
1864         /*
1865          * it's silly to pretend we understand 6-byte sense commands, just
1866          * reject with ILLEGAL_REQUEST and the caller should take the
1867          * appropriate action
1868          */
1869         if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
1870                 rq->errors = ILLEGAL_REQUEST;
1871                 return BLKPREP_KILL;
1872         }
1873         
1874         return BLKPREP_OK;
1875 }
1876
1877 static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
1878 {
1879         if (blk_fs_request(rq))
1880                 return ide_cdrom_prep_fs(q, rq);
1881         else if (blk_pc_request(rq))
1882                 return ide_cdrom_prep_pc(rq);
1883
1884         return 0;
1885 }
1886
1887 struct cd_list_entry {
1888         const char      *id_model;
1889         const char      *id_firmware;
1890         unsigned int    cd_flags;
1891 };
1892
1893 static const struct cd_list_entry ide_cd_quirks_list[] = {
1894         /* Limit transfer size per interrupt. */
1895         { "SAMSUNG CD-ROM SCR-2430", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
1896         { "SAMSUNG CD-ROM SCR-2432", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
1897         /* SCR-3231 doesn't support the SET_CD_SPEED command. */
1898         { "SAMSUNG CD-ROM SCR-3231", NULL,   IDE_CD_FLAG_NO_SPEED_SELECT    },
1899         /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
1900         { "NEC CD-ROM DRIVE:260",    "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD |
1901                                              IDE_CD_FLAG_PRE_ATAPI12,       },
1902         /* Vertos 300, some versions of this drive like to talk BCD. */
1903         { "V003S0DS",                NULL,   IDE_CD_FLAG_VERTOS_300_SSD,    },
1904         /* Vertos 600 ESD. */
1905         { "V006E0DS",                NULL,   IDE_CD_FLAG_VERTOS_600_ESD,    },
1906         /*
1907          * Sanyo 3 CD changer uses a non-standard command for CD changing
1908          * (by default standard ATAPI support for CD changers is used).
1909          */
1910         { "CD-ROM CDR-C3 G",         NULL,   IDE_CD_FLAG_SANYO_3CD          },
1911         { "CD-ROM CDR-C3G",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
1912         { "CD-ROM CDR_C36",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
1913         /* Stingray 8X CD-ROM. */
1914         { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_CD_FLAG_PRE_ATAPI12},
1915         /*
1916          * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
1917          * mode sense page capabilities size, but older drives break.
1918          */
1919         { "ATAPI CD ROM DRIVE 50X MAX", NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
1920         { "WPI CDS-32X",                NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
1921         /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
1922         { "",                        "241N", IDE_CD_FLAG_LE_SPEED_FIELDS    },
1923         /*
1924          * Some drives used by Apple don't advertise audio play
1925          * but they do support reading TOC & audio datas.
1926          */
1927         { "MATSHITADVD-ROM SR-8187", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1928         { "MATSHITADVD-ROM SR-8186", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1929         { "MATSHITADVD-ROM SR-8176", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1930         { "MATSHITADVD-ROM SR-8174", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1931         { "Optiarc DVD RW AD-5200A", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1932         { NULL, NULL, 0 }
1933 };
1934
1935 static unsigned int ide_cd_flags(struct hd_driveid *id)
1936 {
1937         const struct cd_list_entry *cle = ide_cd_quirks_list;
1938
1939         while (cle->id_model) {
1940                 if (strcmp(cle->id_model, id->model) == 0 &&
1941                     (cle->id_firmware == NULL ||
1942                      strstr(id->fw_rev, cle->id_firmware)))
1943                         return cle->cd_flags;
1944                 cle++;
1945         }
1946
1947         return 0;
1948 }
1949
1950 static
1951 int ide_cdrom_setup (ide_drive_t *drive)
1952 {
1953         struct cdrom_info *cd = drive->driver_data;
1954         struct cdrom_device_info *cdi = &cd->devinfo;
1955         struct hd_driveid *id = drive->id;
1956         int nslots;
1957
1958         blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
1959         blk_queue_dma_alignment(drive->queue, 31);
1960         drive->queue->unplug_delay = (1 * HZ) / 1000;
1961         if (!drive->queue->unplug_delay)
1962                 drive->queue->unplug_delay = 1;
1963
1964         drive->special.all      = 0;
1965
1966         cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT |
1967                        ide_cd_flags(id);
1968
1969         if ((id->config & 0x0060) == 0x20)
1970                 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
1971
1972         if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) &&
1973             id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
1974                 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
1975                                  IDE_CD_FLAG_TOCADDR_AS_BCD);
1976         else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) &&
1977                  id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
1978                 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
1979         else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
1980                 cdi->sanyo_slot = 3;    /* 3 => use CD in slot 0 */
1981
1982         nslots = ide_cdrom_probe_capabilities (drive);
1983
1984         /*
1985          * set correct block size
1986          */
1987         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
1988
1989         if (drive->autotune == IDE_TUNE_DEFAULT ||
1990             drive->autotune == IDE_TUNE_AUTO)
1991                 drive->dsc_overlap = (drive->next != drive);
1992
1993         if (ide_cdrom_register(drive, nslots)) {
1994                 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
1995                 cd->devinfo.handle = NULL;
1996                 return 1;
1997         }
1998         ide_cdrom_add_settings(drive);
1999         return 0;
2000 }
2001
2002 #ifdef CONFIG_IDE_PROC_FS
2003 static
2004 sector_t ide_cdrom_capacity (ide_drive_t *drive)
2005 {
2006         unsigned long capacity, sectors_per_frame;
2007
2008         if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
2009                 return 0;
2010
2011         return capacity * sectors_per_frame;
2012 }
2013 #endif
2014
2015 static void ide_cd_remove(ide_drive_t *drive)
2016 {
2017         struct cdrom_info *info = drive->driver_data;
2018
2019         ide_proc_unregister_driver(drive, info->driver);
2020
2021         del_gendisk(info->disk);
2022
2023         ide_cd_put(info);
2024 }
2025
2026 static void ide_cd_release(struct kref *kref)
2027 {
2028         struct cdrom_info *info = to_ide_cd(kref);
2029         struct cdrom_device_info *devinfo = &info->devinfo;
2030         ide_drive_t *drive = info->drive;
2031         struct gendisk *g = info->disk;
2032
2033         kfree(info->buffer);
2034         kfree(info->toc);
2035         if (devinfo->handle == drive && unregister_cdrom(devinfo))
2036                 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
2037                                 "driver.\n", __FUNCTION__, drive->name);
2038         drive->dsc_overlap = 0;
2039         drive->driver_data = NULL;
2040         blk_queue_prep_rq(drive->queue, NULL);
2041         g->private_data = NULL;
2042         put_disk(g);
2043         kfree(info);
2044 }
2045
2046 static int ide_cd_probe(ide_drive_t *);
2047
2048 #ifdef CONFIG_IDE_PROC_FS
2049 static int proc_idecd_read_capacity
2050         (char *page, char **start, off_t off, int count, int *eof, void *data)
2051 {
2052         ide_drive_t *drive = data;
2053         int len;
2054
2055         len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
2056         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
2057 }
2058
2059 static ide_proc_entry_t idecd_proc[] = {
2060         { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
2061         { NULL, 0, NULL, NULL }
2062 };
2063 #endif
2064
2065 static ide_driver_t ide_cdrom_driver = {
2066         .gen_driver = {
2067                 .owner          = THIS_MODULE,
2068                 .name           = "ide-cdrom",
2069                 .bus            = &ide_bus_type,
2070         },
2071         .probe                  = ide_cd_probe,
2072         .remove                 = ide_cd_remove,
2073         .version                = IDECD_VERSION,
2074         .media                  = ide_cdrom,
2075         .supports_dsc_overlap   = 1,
2076         .do_request             = ide_do_rw_cdrom,
2077         .end_request            = ide_end_request,
2078         .error                  = __ide_error,
2079         .abort                  = __ide_abort,
2080 #ifdef CONFIG_IDE_PROC_FS
2081         .proc                   = idecd_proc,
2082 #endif
2083 };
2084
2085 static int idecd_open(struct inode * inode, struct file * file)
2086 {
2087         struct gendisk *disk = inode->i_bdev->bd_disk;
2088         struct cdrom_info *info;
2089         int rc = -ENOMEM;
2090
2091         if (!(info = ide_cd_get(disk)))
2092                 return -ENXIO;
2093
2094         if (!info->buffer)
2095                 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
2096
2097         if (info->buffer)
2098                 rc = cdrom_open(&info->devinfo, inode, file);
2099
2100         if (rc < 0)
2101                 ide_cd_put(info);
2102
2103         return rc;
2104 }
2105
2106 static int idecd_release(struct inode * inode, struct file * file)
2107 {
2108         struct gendisk *disk = inode->i_bdev->bd_disk;
2109         struct cdrom_info *info = ide_cd_g(disk);
2110
2111         cdrom_release (&info->devinfo, file);
2112
2113         ide_cd_put(info);
2114
2115         return 0;
2116 }
2117
2118 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2119 {
2120         struct packet_command cgc;
2121         char buffer[16];
2122         int stat;
2123         char spindown;
2124
2125         if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
2126                 return -EFAULT;
2127
2128         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2129
2130         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2131         if (stat)
2132                 return stat;
2133
2134         buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2135         return cdrom_mode_select(cdi, &cgc);
2136 }
2137
2138 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2139 {
2140         struct packet_command cgc;
2141         char buffer[16];
2142         int stat;
2143         char spindown;
2144
2145         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2146
2147         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2148         if (stat)
2149                 return stat;
2150
2151         spindown = buffer[11] & 0x0f;
2152         if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
2153                 return -EFAULT;
2154         return 0;
2155 }
2156
2157 static int idecd_ioctl (struct inode *inode, struct file *file,
2158                         unsigned int cmd, unsigned long arg)
2159 {
2160         struct block_device *bdev = inode->i_bdev;
2161         struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
2162         int err;
2163
2164         switch (cmd) {
2165         case CDROMSETSPINDOWN:
2166                 return idecd_set_spindown(&info->devinfo, arg);
2167         case CDROMGETSPINDOWN:
2168                 return idecd_get_spindown(&info->devinfo, arg);
2169         default:
2170                 break;
2171         }
2172
2173         err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
2174         if (err == -EINVAL)
2175                 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
2176
2177         return err;
2178 }
2179
2180 static int idecd_media_changed(struct gendisk *disk)
2181 {
2182         struct cdrom_info *info = ide_cd_g(disk);
2183         return cdrom_media_changed(&info->devinfo);
2184 }
2185
2186 static int idecd_revalidate_disk(struct gendisk *disk)
2187 {
2188         struct cdrom_info *info = ide_cd_g(disk);
2189         struct request_sense sense;
2190
2191         ide_cd_read_toc(info->drive, &sense);
2192
2193         return  0;
2194 }
2195
2196 static struct block_device_operations idecd_ops = {
2197         .owner          = THIS_MODULE,
2198         .open           = idecd_open,
2199         .release        = idecd_release,
2200         .ioctl          = idecd_ioctl,
2201         .media_changed  = idecd_media_changed,
2202         .revalidate_disk= idecd_revalidate_disk
2203 };
2204
2205 /* options */
2206 static char *ignore = NULL;
2207
2208 module_param(ignore, charp, 0400);
2209 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2210
2211 static int ide_cd_probe(ide_drive_t *drive)
2212 {
2213         struct cdrom_info *info;
2214         struct gendisk *g;
2215         struct request_sense sense;
2216
2217         if (!strstr("ide-cdrom", drive->driver_req))
2218                 goto failed;
2219         if (!drive->present)
2220                 goto failed;
2221         if (drive->media != ide_cdrom && drive->media != ide_optical)
2222                 goto failed;
2223         /* skip drives that we were told to ignore */
2224         if (ignore != NULL) {
2225                 if (strstr(ignore, drive->name)) {
2226                         printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
2227                         goto failed;
2228                 }
2229         }
2230         if (drive->scsi) {
2231                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
2232                 goto failed;
2233         }
2234         info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
2235         if (info == NULL) {
2236                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
2237                 goto failed;
2238         }
2239
2240         g = alloc_disk(1 << PARTN_BITS);
2241         if (!g)
2242                 goto out_free_cd;
2243
2244         ide_init_disk(g, drive);
2245
2246         ide_proc_register_driver(drive, &ide_cdrom_driver);
2247
2248         kref_init(&info->kref);
2249
2250         info->drive = drive;
2251         info->driver = &ide_cdrom_driver;
2252         info->disk = g;
2253
2254         g->private_data = &info->driver;
2255
2256         drive->driver_data = info;
2257
2258         g->minors = 1;
2259         g->driverfs_dev = &drive->gendev;
2260         g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
2261         if (ide_cdrom_setup(drive)) {
2262                 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
2263                 ide_cd_release(&info->kref);
2264                 goto failed;
2265         }
2266
2267         ide_cd_read_toc(drive, &sense);
2268         g->fops = &idecd_ops;
2269         g->flags |= GENHD_FL_REMOVABLE;
2270         add_disk(g);
2271         return 0;
2272
2273 out_free_cd:
2274         kfree(info);
2275 failed:
2276         return -ENODEV;
2277 }
2278
2279 static void __exit ide_cdrom_exit(void)
2280 {
2281         driver_unregister(&ide_cdrom_driver.gen_driver);
2282 }
2283
2284 static int __init ide_cdrom_init(void)
2285 {
2286         return driver_register(&ide_cdrom_driver.gen_driver);
2287 }
2288
2289 MODULE_ALIAS("ide:*m-cdrom*");
2290 MODULE_ALIAS("ide-cd");
2291 module_init(ide_cdrom_init);
2292 module_exit(ide_cdrom_exit);
2293 MODULE_LICENSE("GPL");