354c91d06a6d26d6af5f5c0fd5bb38d178d82a2f
[sfrench/cifs-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, IDE_COMMAND_REG);
546                 ndelay(400);
547                 spin_unlock_irqrestore(&ide_lock, flags);
548
549                 return (*handler) (drive);
550         }
551 }
552
553 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
554    The device registers must have already been prepared
555    by cdrom_start_packet_command.
556    HANDLER is the interrupt handler to call when the command completes
557    or there's data ready. */
558 #define ATAPI_MIN_CDB_BYTES 12
559 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
560                                           struct request *rq,
561                                           ide_handler_t *handler)
562 {
563         ide_hwif_t *hwif = drive->hwif;
564         int cmd_len;
565         struct cdrom_info *info = drive->driver_data;
566         ide_startstop_t startstop;
567
568         if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
569                 /* Here we should have been called after receiving an interrupt
570                    from the device.  DRQ should how be set. */
571
572                 /* Check for errors. */
573                 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
574                         return ide_stopped;
575
576                 /* Ok, next interrupt will be DMA interrupt. */
577                 if (info->dma)
578                         drive->waiting_for_dma = 1;
579         } else {
580                 /* Otherwise, we must wait for DRQ to get set. */
581                 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
582                                 BUSY_STAT, WAIT_READY))
583                         return startstop;
584         }
585
586         /* Arm the interrupt handler. */
587         ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
588
589         /* ATAPI commands get padded out to 12 bytes minimum */
590         cmd_len = COMMAND_SIZE(rq->cmd[0]);
591         if (cmd_len < ATAPI_MIN_CDB_BYTES)
592                 cmd_len = ATAPI_MIN_CDB_BYTES;
593
594         /* Send the command to the device. */
595         HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
596
597         /* Start the DMA if need be */
598         if (info->dma)
599                 hwif->dma_start(drive);
600
601         return ide_started;
602 }
603
604 /****************************************************************************
605  * Block read functions.
606  */
607
608 static void ide_cd_pad_transfer(ide_drive_t *drive, xfer_func_t *xf, int len)
609 {
610         while (len > 0) {
611                 int dum = 0;
612                 xf(drive, &dum, sizeof(dum));
613                 len -= sizeof(dum);
614         }
615 }
616
617 static void ide_cd_drain_data(ide_drive_t *drive, int nsects)
618 {
619         while (nsects > 0) {
620                 static char dum[SECTOR_SIZE];
621
622                 drive->hwif->atapi_input_bytes(drive, dum, sizeof(dum));
623                 nsects--;
624         }
625 }
626
627 /*
628  * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
629  * buffer.  Once the first sector is added, any subsequent sectors are
630  * assumed to be continuous (until the buffer is cleared).  For the first
631  * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
632  * the buffer is cleared.)
633  */
634 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
635                                   int sectors_to_transfer)
636 {
637         struct cdrom_info *info = drive->driver_data;
638
639         /* Number of sectors to read into the buffer. */
640         int sectors_to_buffer = min_t(int, sectors_to_transfer,
641                                      (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
642                                        info->nsectors_buffered);
643
644         char *dest;
645
646         /* If we couldn't get a buffer, don't try to buffer anything... */
647         if (info->buffer == NULL)
648                 sectors_to_buffer = 0;
649
650         /* If this is the first sector in the buffer, remember its number. */
651         if (info->nsectors_buffered == 0)
652                 info->sector_buffered = sector;
653
654         /* Read the data into the buffer. */
655         dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
656         while (sectors_to_buffer > 0) {
657                 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
658                 --sectors_to_buffer;
659                 --sectors_to_transfer;
660                 ++info->nsectors_buffered;
661                 dest += SECTOR_SIZE;
662         }
663
664         /* Throw away any remaining data. */
665         ide_cd_drain_data(drive, sectors_to_transfer);
666 }
667
668 /*
669  * Check the contents of the interrupt reason register from the cdrom
670  * and attempt to recover if there are problems.  Returns  0 if everything's
671  * ok; nonzero if the request has been terminated.
672  */
673 static
674 int ide_cd_check_ireason(ide_drive_t *drive, int len, int ireason, int rw)
675 {
676         /*
677          * ireason == 0: the drive wants to receive data from us
678          * ireason == 2: the drive is expecting to transfer data to us
679          */
680         if (ireason == (!rw << 1))
681                 return 0;
682         else if (ireason == (rw << 1)) {
683                 ide_hwif_t *hwif = drive->hwif;
684                 xfer_func_t *xf;
685
686                 /* Whoops... */
687                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
688                                 drive->name, __FUNCTION__);
689
690                 xf = rw ? hwif->atapi_output_bytes : hwif->atapi_input_bytes;
691                 ide_cd_pad_transfer(drive, xf, len);
692         } else  if (rw == 0 && ireason == 1) {
693                 /* Some drives (ASUS) seem to tell us that status
694                  * info is available. just get it and ignore.
695                  */
696                 (void)ide_read_status(drive);
697                 return 0;
698         } else {
699                 /* Drive wants a command packet, or invalid ireason... */
700                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
701                                 drive->name, __FUNCTION__, ireason);
702         }
703
704         cdrom_end_request(drive, 0);
705         return -1;
706 }
707
708 /*
709  * Assume that the drive will always provide data in multiples of at least
710  * SECTOR_SIZE, as it gets hairy to keep track of the transfers otherwise.
711  */
712 static int ide_cd_check_transfer_size(ide_drive_t *drive, int len)
713 {
714         struct cdrom_info *cd = drive->driver_data;
715
716         if ((len % SECTOR_SIZE) == 0)
717                 return 0;
718
719         printk(KERN_ERR "%s: %s: Bad transfer size %d\n",
720                         drive->name, __FUNCTION__, len);
721
722         if (cd->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES)
723                 printk(KERN_ERR "  This drive is not supported by "
724                                 "this version of the driver\n");
725         else {
726                 printk(KERN_ERR "  Trying to limit transfer sizes\n");
727                 cd->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES;
728         }
729
730         return 1;
731 }
732
733 /*
734  * Try to satisfy some of the current read request from our cached data.
735  * Returns nonzero if the request has been completed, zero otherwise.
736  */
737 static int cdrom_read_from_buffer (ide_drive_t *drive)
738 {
739         struct cdrom_info *info = drive->driver_data;
740         struct request *rq = HWGROUP(drive)->rq;
741         unsigned short sectors_per_frame;
742
743         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
744
745         /* Can't do anything if there's no buffer. */
746         if (info->buffer == NULL) return 0;
747
748         /* Loop while this request needs data and the next block is present
749            in our cache. */
750         while (rq->nr_sectors > 0 &&
751                rq->sector >= info->sector_buffered &&
752                rq->sector < info->sector_buffered + info->nsectors_buffered) {
753                 if (rq->current_nr_sectors == 0)
754                         cdrom_end_request(drive, 1);
755
756                 memcpy (rq->buffer,
757                         info->buffer +
758                         (rq->sector - info->sector_buffered) * SECTOR_SIZE,
759                         SECTOR_SIZE);
760                 rq->buffer += SECTOR_SIZE;
761                 --rq->current_nr_sectors;
762                 --rq->nr_sectors;
763                 ++rq->sector;
764         }
765
766         /* If we've satisfied the current request,
767            terminate it successfully. */
768         if (rq->nr_sectors == 0) {
769                 cdrom_end_request(drive, 1);
770                 return -1;
771         }
772
773         /* Move on to the next buffer if needed. */
774         if (rq->current_nr_sectors == 0)
775                 cdrom_end_request(drive, 1);
776
777         /* If this condition does not hold, then the kluge i use to
778            represent the number of sectors to skip at the start of a transfer
779            will fail.  I think that this will never happen, but let's be
780            paranoid and check. */
781         if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
782             (rq->sector & (sectors_per_frame - 1))) {
783                 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
784                         drive->name, (long)rq->sector);
785                 cdrom_end_request(drive, 0);
786                 return -1;
787         }
788
789         return 0;
790 }
791
792 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *);
793
794 /*
795  * Routine to send a read/write packet command to the drive.
796  * This is usually called directly from cdrom_start_{read,write}().
797  * However, for drq_interrupt devices, it is called from an interrupt
798  * when the drive is ready to accept the command.
799  */
800 static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)
801 {
802         struct request *rq = HWGROUP(drive)->rq;
803
804         if (rq_data_dir(rq) == READ) {
805                 unsigned short sectors_per_frame =
806                         queue_hardsect_size(drive->queue) >> SECTOR_BITS;
807                 int nskip = rq->sector & (sectors_per_frame - 1);
808
809                 /*
810                  * If the requested sector doesn't start on a frame boundary,
811                  * we must adjust the start of the transfer so that it does,
812                  * and remember to skip the first few sectors.
813                  *
814                  * If the rq->current_nr_sectors field is larger than the size
815                  * of the buffer, it will mean that we're to skip a number of
816                  * sectors equal to the amount by which rq->current_nr_sectors
817                  * is larger than the buffer size.
818                  */
819                 if (nskip > 0) {
820                         /* Sanity check... */
821                         if (rq->current_nr_sectors !=
822                             bio_cur_sectors(rq->bio)) {
823                                 printk(KERN_ERR "%s: %s: buffer botch (%u)\n",
824                                                 drive->name, __FUNCTION__,
825                                                 rq->current_nr_sectors);
826                                 cdrom_end_request(drive, 0);
827                                 return ide_stopped;
828                         }
829                         rq->current_nr_sectors += nskip;
830                 }
831         }
832 #if 0
833         else
834                 /* the immediate bit */
835                 rq->cmd[1] = 1 << 3;
836 #endif
837         /* Set up the command */
838         rq->timeout = ATAPI_WAIT_PC;
839
840         /* Send the command to the drive and return. */
841         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
842 }
843
844 #define IDECD_SEEK_THRESHOLD    (1000)                  /* 1000 blocks */
845 #define IDECD_SEEK_TIMER        (5 * WAIT_MIN_SLEEP)    /* 100 ms */
846 #define IDECD_SEEK_TIMEOUT      (2 * WAIT_CMD)          /* 20 sec */
847
848 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
849 {
850         struct cdrom_info *info = drive->driver_data;
851         int stat;
852         static int retry = 10;
853
854         if (cdrom_decode_status(drive, 0, &stat))
855                 return ide_stopped;
856
857         info->cd_flags |= IDE_CD_FLAG_SEEKING;
858
859         if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
860                 if (--retry == 0) {
861                         /*
862                          * this condition is far too common, to bother
863                          * users about it
864                          */
865                         /* printk("%s: disabled DSC seek overlap\n", drive->name);*/ 
866                         drive->dsc_overlap = 0;
867                 }
868         }
869         return ide_stopped;
870 }
871
872 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
873 {
874         struct request *rq = HWGROUP(drive)->rq;
875         sector_t frame = rq->sector;
876
877         sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
878
879         memset(rq->cmd, 0, sizeof(rq->cmd));
880         rq->cmd[0] = GPCMD_SEEK;
881         put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
882
883         rq->timeout = ATAPI_WAIT_PC;
884         return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
885 }
886
887 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
888 {
889         struct cdrom_info *info = drive->driver_data;
890
891         info->dma = 0;
892         info->start_seek = jiffies;
893         return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
894 }
895
896 /* Fix up a possibly partially-processed request so that we can
897    start it over entirely, or even put it back on the request queue. */
898 static void restore_request (struct request *rq)
899 {
900         if (rq->buffer != bio_data(rq->bio)) {
901                 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
902
903                 rq->buffer = bio_data(rq->bio);
904                 rq->nr_sectors += n;
905                 rq->sector -= n;
906         }
907         rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
908         rq->hard_nr_sectors = rq->nr_sectors;
909         rq->hard_sector = rq->sector;
910         rq->q->prep_rq_fn(rq->q, rq);
911 }
912
913 /****************************************************************************
914  * Execute all other packet commands.
915  */
916
917 static void ide_cd_request_sense_fixup(struct request *rq)
918 {
919         /*
920          * Some of the trailing request sense fields are optional,
921          * and some drives don't send them.  Sigh.
922          */
923         if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
924             rq->data_len > 0 && rq->data_len <= 5)
925                 while (rq->data_len > 0) {
926                         *(u8 *)rq->data++ = 0;
927                         --rq->data_len;
928                 }
929 }
930
931 int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq)
932 {
933         struct request_sense sense;
934         int retries = 10;
935         unsigned int flags = rq->cmd_flags;
936
937         if (rq->sense == NULL)
938                 rq->sense = &sense;
939
940         /* Start of retry loop. */
941         do {
942                 int error;
943                 unsigned long time = jiffies;
944                 rq->cmd_flags = flags;
945
946                 error = ide_do_drive_cmd(drive, rq, ide_wait);
947                 time = jiffies - time;
948
949                 /* FIXME: we should probably abort/retry or something 
950                  * in case of failure */
951                 if (rq->cmd_flags & REQ_FAILED) {
952                         /* The request failed.  Retry if it was due to a unit
953                            attention status
954                            (usually means media was changed). */
955                         struct request_sense *reqbuf = rq->sense;
956
957                         if (reqbuf->sense_key == UNIT_ATTENTION)
958                                 cdrom_saw_media_change(drive);
959                         else if (reqbuf->sense_key == NOT_READY &&
960                                  reqbuf->asc == 4 && reqbuf->ascq != 4) {
961                                 /* The drive is in the process of loading
962                                    a disk.  Retry, but wait a little to give
963                                    the drive time to complete the load. */
964                                 ssleep(2);
965                         } else {
966                                 /* Otherwise, don't retry. */
967                                 retries = 0;
968                         }
969                         --retries;
970                 }
971
972                 /* End of retry loop. */
973         } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
974
975         /* Return an error if the command failed. */
976         return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
977 }
978
979 /*
980  * Called from blk_end_request_callback() after the data of the request
981  * is completed and before the request is completed.
982  * By returning value '1', blk_end_request_callback() returns immediately
983  * without completing the request.
984  */
985 static int cdrom_newpc_intr_dummy_cb(struct request *rq)
986 {
987         return 1;
988 }
989
990 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
991 {
992         struct cdrom_info *info = drive->driver_data;
993         struct request *rq = HWGROUP(drive)->rq;
994         xfer_func_t *xferfunc;
995         ide_expiry_t *expiry = NULL;
996         int dma_error = 0, dma, stat, ireason, len, thislen, uptodate = 0;
997         int write = (rq_data_dir(rq) == WRITE) ? 1 : 0;
998         unsigned int timeout;
999         u8 lowcyl, highcyl;
1000
1001         /* Check for errors. */
1002         dma = info->dma;
1003         if (dma) {
1004                 info->dma = 0;
1005                 dma_error = HWIF(drive)->ide_dma_end(drive);
1006                 if (dma_error) {
1007                         printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1008                                         write ? "write" : "read");
1009                         ide_dma_off(drive);
1010                 }
1011         }
1012
1013         if (cdrom_decode_status(drive, 0, &stat))
1014                 return ide_stopped;
1015
1016         /*
1017          * using dma, transfer is complete now
1018          */
1019         if (dma) {
1020                 if (dma_error)
1021                         return ide_error(drive, "dma error", stat);
1022                 if (blk_fs_request(rq)) {
1023                         ide_end_request(drive, 1, rq->nr_sectors);
1024                         return ide_stopped;
1025                 }
1026                 goto end_request;
1027         }
1028
1029         /*
1030          * ok we fall to pio :/
1031          */
1032         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1033         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1034         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1035
1036         len = lowcyl + (256 * highcyl);
1037
1038         thislen = blk_fs_request(rq) ? len : rq->data_len;
1039         if (thislen > len)
1040                 thislen = len;
1041
1042         /*
1043          * If DRQ is clear, the command has completed.
1044          */
1045         if ((stat & DRQ_STAT) == 0) {
1046                 if (blk_fs_request(rq)) {
1047                         /*
1048                          * If we're not done reading/writing, complain.
1049                          * Otherwise, complete the command normally.
1050                          */
1051                         uptodate = 1;
1052                         if (rq->current_nr_sectors > 0) {
1053                                 printk(KERN_ERR "%s: %s: data underrun "
1054                                                 "(%d blocks)\n",
1055                                                 drive->name, __FUNCTION__,
1056                                                 rq->current_nr_sectors);
1057                                 if (!write)
1058                                         rq->cmd_flags |= REQ_FAILED;
1059                                 uptodate = 0;
1060                         }
1061                         cdrom_end_request(drive, uptodate);
1062                         return ide_stopped;
1063                 } else if (!blk_pc_request(rq)) {
1064                         ide_cd_request_sense_fixup(rq);
1065                         /* Complain if we still have data left to transfer. */
1066                         uptodate = rq->data_len ? 0 : 1;
1067                 }
1068                 goto end_request;
1069         }
1070
1071         /*
1072          * check which way to transfer data
1073          */
1074         if (blk_fs_request(rq) || blk_pc_request(rq)) {
1075                 if (ide_cd_check_ireason(drive, len, ireason, write))
1076                         return ide_stopped;
1077
1078                 if (blk_fs_request(rq) && write == 0) {
1079                         int nskip;
1080
1081                         if (ide_cd_check_transfer_size(drive, len)) {
1082                                 cdrom_end_request(drive, 0);
1083                                 return ide_stopped;
1084                         }
1085
1086                         /*
1087                          * First, figure out if we need to bit-bucket
1088                          * any of the leading sectors.
1089                          */
1090                         nskip = min_t(int, rq->current_nr_sectors
1091                                            - bio_cur_sectors(rq->bio),
1092                                            thislen >> 9);
1093                         if (nskip > 0) {
1094                                 ide_cd_drain_data(drive, nskip);
1095                                 rq->current_nr_sectors -= nskip;
1096                                 thislen -= (nskip << 9);
1097                         }
1098                 }
1099         }
1100
1101         if (ireason == 0) {
1102                 write = 1;
1103                 xferfunc = HWIF(drive)->atapi_output_bytes;
1104         } else if (ireason == 2 || (ireason == 1 &&
1105                    (blk_fs_request(rq) || blk_pc_request(rq)))) {
1106                 write = 0;
1107                 xferfunc = HWIF(drive)->atapi_input_bytes;
1108         } else {
1109                 printk(KERN_ERR "%s: %s: The drive "
1110                                 "appears confused (ireason = 0x%02x). "
1111                                 "Trying to recover by ending request.\n",
1112                                 drive->name, __FUNCTION__, ireason);
1113                 goto end_request;
1114         }
1115
1116         /*
1117          * transfer data
1118          */
1119         while (thislen > 0) {
1120                 u8 *ptr = blk_fs_request(rq) ? NULL : rq->data;
1121                 int blen = rq->data_len;
1122
1123                 /*
1124                  * bio backed?
1125                  */
1126                 if (rq->bio) {
1127                         if (blk_fs_request(rq)) {
1128                                 ptr = rq->buffer;
1129                                 blen = rq->current_nr_sectors << 9;
1130                         } else {
1131                                 ptr = bio_data(rq->bio);
1132                                 blen = bio_iovec(rq->bio)->bv_len;
1133                         }
1134                 }
1135
1136                 if (!ptr) {
1137                         if (blk_fs_request(rq) && !write)
1138                                 /*
1139                                  * If the buffers are full, cache the rest
1140                                  * of the data in our internal buffer.
1141                                  */
1142                                 cdrom_buffer_sectors(drive, rq->sector,
1143                                                      thislen >> 9);
1144                         else {
1145                                 printk(KERN_ERR "%s: confused, missing data\n",
1146                                                 drive->name);
1147                                 blk_dump_rq_flags(rq, rq_data_dir(rq)
1148                                                   ? "cdrom_newpc_intr, write"
1149                                                   : "cdrom_newpc_intr, read");
1150                         }
1151                         break;
1152                 }
1153
1154                 if (blen > thislen)
1155                         blen = thislen;
1156
1157                 xferfunc(drive, ptr, blen);
1158
1159                 thislen -= blen;
1160                 len -= blen;
1161
1162                 if (blk_fs_request(rq)) {
1163                         rq->buffer += blen;
1164                         rq->nr_sectors -= (blen >> 9);
1165                         rq->current_nr_sectors -= (blen >> 9);
1166                         rq->sector += (blen >> 9);
1167
1168                         if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1169                                 cdrom_end_request(drive, 1);
1170                 } else {
1171                         rq->data_len -= blen;
1172
1173                         /*
1174                          * The request can't be completed until DRQ is cleared.
1175                          * So complete the data, but don't complete the request
1176                          * using the dummy function for the callback feature
1177                          * of blk_end_request_callback().
1178                          */
1179                         if (rq->bio)
1180                                 blk_end_request_callback(rq, 0, blen,
1181                                                  cdrom_newpc_intr_dummy_cb);
1182                         else
1183                                 rq->data += blen;
1184                 }
1185         }
1186
1187         if (write && blk_sense_request(rq))
1188                 rq->sense_len += thislen;
1189
1190         /*
1191          * pad, if necessary
1192          */
1193         if (!blk_fs_request(rq) && len > 0)
1194                 ide_cd_pad_transfer(drive, xferfunc, len);
1195
1196         if (blk_pc_request(rq)) {
1197                 timeout = rq->timeout;
1198         } else {
1199                 timeout = ATAPI_WAIT_PC;
1200                 if (!blk_fs_request(rq))
1201                         expiry = cdrom_timer_expiry;
1202         }
1203
1204         ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
1205         return ide_started;
1206
1207 end_request:
1208         if (blk_pc_request(rq)) {
1209                 unsigned long flags;
1210
1211                 spin_lock_irqsave(&ide_lock, flags);
1212                 if (__blk_end_request(rq, 0, rq->data_len))
1213                         BUG();
1214                 HWGROUP(drive)->rq = NULL;
1215                 spin_unlock_irqrestore(&ide_lock, flags);
1216         } else {
1217                 if (!uptodate)
1218                         rq->cmd_flags |= REQ_FAILED;
1219                 cdrom_end_request(drive, uptodate);
1220         }
1221         return ide_stopped;
1222 }
1223
1224 static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
1225 {
1226         struct cdrom_info *cd = drive->driver_data;
1227         int write = rq_data_dir(rq) == WRITE;
1228         unsigned short sectors_per_frame =
1229                 queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1230
1231         if (write) {
1232                 /*
1233                  * disk has become write protected
1234                  */
1235                 if (cd->disk->policy) {
1236                         cdrom_end_request(drive, 0);
1237                         return ide_stopped;
1238                 }
1239         } else {
1240                 /*
1241                  * We may be retrying this request after an error.  Fix up any
1242                  * weirdness which might be present in the request packet.
1243                  */
1244                 restore_request(rq);
1245
1246                 /* Satisfy whatever we can of this request from our cache. */
1247                 if (cdrom_read_from_buffer(drive))
1248                         return ide_stopped;
1249         }
1250
1251         /*
1252          * use DMA, if possible / writes *must* be hardware frame aligned
1253          */
1254         if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1255             (rq->sector & (sectors_per_frame - 1))) {
1256                 if (write) {
1257                         cdrom_end_request(drive, 0);
1258                         return ide_stopped;
1259                 }
1260                 cd->dma = 0;
1261         } else
1262                 cd->dma = drive->using_dma;
1263
1264         /* Clear the local sector buffer. */
1265         cd->nsectors_buffered = 0;
1266
1267         if (write)
1268                 cd->devinfo.media_written = 1;
1269
1270         /* Start sending the read/write request to the drive. */
1271         return cdrom_start_packet_command(drive, 32768, cdrom_start_rw_cont);
1272 }
1273
1274 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1275 {
1276         struct request *rq = HWGROUP(drive)->rq;
1277
1278         if (!rq->timeout)
1279                 rq->timeout = ATAPI_WAIT_PC;
1280
1281         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1282 }
1283
1284 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1285 {
1286         struct cdrom_info *info = drive->driver_data;
1287
1288         if (blk_pc_request(rq))
1289                 rq->cmd_flags |= REQ_QUIET;
1290         else
1291                 rq->cmd_flags &= ~REQ_FAILED;
1292
1293         info->dma = 0;
1294
1295         /*
1296          * sg request
1297          */
1298         if (rq->bio) {
1299                 int mask = drive->queue->dma_alignment;
1300                 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1301
1302                 info->dma = drive->using_dma;
1303
1304                 /*
1305                  * check if dma is safe
1306                  *
1307                  * NOTE! The "len" and "addr" checks should possibly have
1308                  * separate masks.
1309                  */
1310                 if ((rq->data_len & 15) || (addr & mask))
1311                         info->dma = 0;
1312         }
1313
1314         /* Start sending the command to the drive. */
1315         return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1316 }
1317
1318 /****************************************************************************
1319  * cdrom driver request routine.
1320  */
1321 static ide_startstop_t
1322 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1323 {
1324         ide_startstop_t action;
1325         struct cdrom_info *info = drive->driver_data;
1326
1327         if (blk_fs_request(rq)) {
1328                 if (info->cd_flags & IDE_CD_FLAG_SEEKING) {
1329                         unsigned long elapsed = jiffies - info->start_seek;
1330                         int stat = ide_read_status(drive);
1331
1332                         if ((stat & SEEK_STAT) != SEEK_STAT) {
1333                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
1334                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
1335                                         return ide_stopped;
1336                                 }
1337                                 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1338                         }
1339                         info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
1340                 }
1341                 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1342                         action = cdrom_start_seek(drive, block);
1343                 } else
1344                         action = cdrom_start_rw(drive, rq);
1345                 info->last_block = block;
1346                 return action;
1347         } else if (blk_sense_request(rq) || blk_pc_request(rq) ||
1348                    rq->cmd_type == REQ_TYPE_ATA_PC) {
1349                 return cdrom_do_block_pc(drive, rq);
1350         } else if (blk_special_request(rq)) {
1351                 /*
1352                  * right now this can only be a reset...
1353                  */
1354                 cdrom_end_request(drive, 1);
1355                 return ide_stopped;
1356         }
1357
1358         blk_dump_rq_flags(rq, "ide-cd bad flags");
1359         cdrom_end_request(drive, 0);
1360         return ide_stopped;
1361 }
1362
1363
1364
1365 /****************************************************************************
1366  * Ioctl handling.
1367  *
1368  * Routines which queue packet commands take as a final argument a pointer
1369  * to a request_sense struct.  If execution of the command results
1370  * in an error with a CHECK CONDITION status, this structure will be filled
1371  * with the results of the subsequent request sense command.  The pointer
1372  * can also be NULL, in which case no sense information is returned.
1373  */
1374
1375 static
1376 void msf_from_bcd (struct atapi_msf *msf)
1377 {
1378         msf->minute = BCD2BIN(msf->minute);
1379         msf->second = BCD2BIN(msf->second);
1380         msf->frame  = BCD2BIN(msf->frame);
1381 }
1382
1383 int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
1384 {
1385         struct request req;
1386         struct cdrom_info *info = drive->driver_data;
1387         struct cdrom_device_info *cdi = &info->devinfo;
1388
1389         ide_cd_init_rq(drive, &req);
1390
1391         req.sense = sense;
1392         req.cmd[0] = GPCMD_TEST_UNIT_READY;
1393         req.cmd_flags |= REQ_QUIET;
1394
1395         /*
1396          * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1397          * switch CDs instead of supporting the LOAD_UNLOAD opcode.
1398          */
1399         req.cmd[7] = cdi->sanyo_slot % 3;
1400
1401         return ide_cd_queue_pc(drive, &req);
1402 }
1403
1404 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
1405                                unsigned long *sectors_per_frame,
1406                                struct request_sense *sense)
1407 {
1408         struct {
1409                 __u32 lba;
1410                 __u32 blocklen;
1411         } capbuf;
1412
1413         int stat;
1414         struct request req;
1415
1416         ide_cd_init_rq(drive, &req);
1417
1418         req.sense = sense;
1419         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
1420         req.data = (char *)&capbuf;
1421         req.data_len = sizeof(capbuf);
1422         req.cmd_flags |= REQ_QUIET;
1423
1424         stat = ide_cd_queue_pc(drive, &req);
1425         if (stat == 0) {
1426                 *capacity = 1 + be32_to_cpu(capbuf.lba);
1427                 *sectors_per_frame =
1428                         be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
1429         }
1430
1431         return stat;
1432 }
1433
1434 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
1435                                 int format, char *buf, int buflen,
1436                                 struct request_sense *sense)
1437 {
1438         struct request req;
1439
1440         ide_cd_init_rq(drive, &req);
1441
1442         req.sense = sense;
1443         req.data =  buf;
1444         req.data_len = buflen;
1445         req.cmd_flags |= REQ_QUIET;
1446         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
1447         req.cmd[6] = trackno;
1448         req.cmd[7] = (buflen >> 8);
1449         req.cmd[8] = (buflen & 0xff);
1450         req.cmd[9] = (format << 6);
1451
1452         if (msf_flag)
1453                 req.cmd[1] = 2;
1454
1455         return ide_cd_queue_pc(drive, &req);
1456 }
1457
1458 /* Try to read the entire TOC for the disk into our internal buffer. */
1459 int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
1460 {
1461         int stat, ntracks, i;
1462         struct cdrom_info *info = drive->driver_data;
1463         struct cdrom_device_info *cdi = &info->devinfo;
1464         struct atapi_toc *toc = info->toc;
1465         struct {
1466                 struct atapi_toc_header hdr;
1467                 struct atapi_toc_entry  ent;
1468         } ms_tmp;
1469         long last_written;
1470         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
1471
1472         if (toc == NULL) {
1473                 /* Try to allocate space. */
1474                 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
1475                 if (toc == NULL) {
1476                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
1477                         return -ENOMEM;
1478                 }
1479                 info->toc = toc;
1480         }
1481
1482         /* Check to see if the existing data is still valid.
1483            If it is, just return. */
1484         (void) cdrom_check_status(drive, sense);
1485
1486         if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
1487                 return 0;
1488
1489         /* Try to get the total cdrom capacity and sector size. */
1490         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
1491                                    sense);
1492         if (stat)
1493                 toc->capacity = 0x1fffff;
1494
1495         set_capacity(info->disk, toc->capacity * sectors_per_frame);
1496         /* Save a private copy of te TOC capacity for error handling */
1497         drive->probed_capacity = toc->capacity * sectors_per_frame;
1498
1499         blk_queue_hardsect_size(drive->queue,
1500                                 sectors_per_frame << SECTOR_BITS);
1501
1502         /* First read just the header, so we know how long the TOC is. */
1503         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
1504                                     sizeof(struct atapi_toc_header), sense);
1505         if (stat)
1506                 return stat;
1507
1508         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1509                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1510                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1511         }
1512
1513         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1514         if (ntracks <= 0)
1515                 return -EIO;
1516         if (ntracks > MAX_TRACKS)
1517                 ntracks = MAX_TRACKS;
1518
1519         /* Now read the whole schmeer. */
1520         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
1521                                   (char *)&toc->hdr,
1522                                    sizeof(struct atapi_toc_header) +
1523                                    (ntracks + 1) *
1524                                    sizeof(struct atapi_toc_entry), sense);
1525
1526         if (stat && toc->hdr.first_track > 1) {
1527                 /* Cds with CDI tracks only don't have any TOC entries,
1528                    despite of this the returned values are
1529                    first_track == last_track = number of CDI tracks + 1,
1530                    so that this case is indistinguishable from the same
1531                    layout plus an additional audio track.
1532                    If we get an error for the regular case, we assume
1533                    a CDI without additional audio tracks. In this case
1534                    the readable TOC is empty (CDI tracks are not included)
1535                    and only holds the Leadout entry. Heiko EiƟfeldt */
1536                 ntracks = 0;
1537                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
1538                                            (char *)&toc->hdr,
1539                                            sizeof(struct atapi_toc_header) +
1540                                            (ntracks + 1) *
1541                                            sizeof(struct atapi_toc_entry),
1542                                            sense);
1543                 if (stat)
1544                         return stat;
1545
1546                 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1547                         toc->hdr.first_track = (u8)BIN2BCD(CDROM_LEADOUT);
1548                         toc->hdr.last_track = (u8)BIN2BCD(CDROM_LEADOUT);
1549                 } else {
1550                         toc->hdr.first_track = CDROM_LEADOUT;
1551                         toc->hdr.last_track = CDROM_LEADOUT;
1552                 }
1553         }
1554
1555         if (stat)
1556                 return stat;
1557
1558         toc->hdr.toc_length = be16_to_cpu(toc->hdr.toc_length);
1559
1560         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1561                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1562                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1563         }
1564
1565         for (i = 0; i <= ntracks; i++) {
1566                 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1567                         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD)
1568                                 toc->ent[i].track = BCD2BIN(toc->ent[i].track);
1569                         msf_from_bcd(&toc->ent[i].addr.msf);
1570                 }
1571                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
1572                                                    toc->ent[i].addr.msf.second,
1573                                                    toc->ent[i].addr.msf.frame);
1574         }
1575
1576         /* Read the multisession information. */
1577         if (toc->hdr.first_track != CDROM_LEADOUT) {
1578                 /* Read the multisession information. */
1579                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
1580                                            sizeof(ms_tmp), sense);
1581                 if (stat)
1582                         return stat;
1583
1584                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
1585         } else {
1586                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
1587                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
1588         }
1589
1590         if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1591                 /* Re-read multisession information using MSF format */
1592                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
1593                                            sizeof(ms_tmp), sense);
1594                 if (stat)
1595                         return stat;
1596
1597                 msf_from_bcd (&ms_tmp.ent.addr.msf);
1598                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1599                                                    ms_tmp.ent.addr.msf.second,
1600                                                    ms_tmp.ent.addr.msf.frame);
1601         }
1602
1603         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
1604
1605         /* Now try to get the total cdrom capacity. */
1606         stat = cdrom_get_last_written(cdi, &last_written);
1607         if (!stat && (last_written > toc->capacity)) {
1608                 toc->capacity = last_written;
1609                 set_capacity(info->disk, toc->capacity * sectors_per_frame);
1610                 drive->probed_capacity = toc->capacity * sectors_per_frame;
1611         }
1612
1613         /* Remember that we've read this stuff. */
1614         info->cd_flags |= IDE_CD_FLAG_TOC_VALID;
1615
1616         return 0;
1617 }
1618
1619 int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
1620 {
1621         struct cdrom_info *info = drive->driver_data;
1622         struct cdrom_device_info *cdi = &info->devinfo;
1623         struct packet_command cgc;
1624         int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
1625
1626         if ((info->cd_flags & IDE_CD_FLAG_FULL_CAPS_PAGE) == 0)
1627                 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
1628
1629         init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
1630         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
1631                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
1632                 if (!stat)
1633                         break;
1634         } while (--attempts);
1635         return stat;
1636 }
1637
1638 void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
1639 {
1640         struct cdrom_info *cd = drive->driver_data;
1641         u16 curspeed, maxspeed;
1642
1643         curspeed = *(u16 *)&buf[8 + 14];
1644         maxspeed = *(u16 *)&buf[8 +  8];
1645
1646         if (cd->cd_flags & IDE_CD_FLAG_LE_SPEED_FIELDS) {
1647                 curspeed = le16_to_cpu(curspeed);
1648                 maxspeed = le16_to_cpu(maxspeed);
1649         } else {
1650                 curspeed = be16_to_cpu(curspeed);
1651                 maxspeed = be16_to_cpu(maxspeed);
1652         }
1653
1654         cd->current_speed = (curspeed + (176/2)) / 176;
1655         cd->max_speed = (maxspeed + (176/2)) / 176;
1656 }
1657
1658 #define IDE_CD_CAPABILITIES \
1659         (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
1660          CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
1661          CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
1662          CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
1663          CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
1664
1665 static struct cdrom_device_ops ide_cdrom_dops = {
1666         .open                   = ide_cdrom_open_real,
1667         .release                = ide_cdrom_release_real,
1668         .drive_status           = ide_cdrom_drive_status,
1669         .media_changed          = ide_cdrom_check_media_change_real,
1670         .tray_move              = ide_cdrom_tray_move,
1671         .lock_door              = ide_cdrom_lock_door,
1672         .select_speed           = ide_cdrom_select_speed,
1673         .get_last_session       = ide_cdrom_get_last_session,
1674         .get_mcn                = ide_cdrom_get_mcn,
1675         .reset                  = ide_cdrom_reset,
1676         .audio_ioctl            = ide_cdrom_audio_ioctl,
1677         .capability             = IDE_CD_CAPABILITIES,
1678         .generic_packet         = ide_cdrom_packet,
1679 };
1680
1681 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
1682 {
1683         struct cdrom_info *info = drive->driver_data;
1684         struct cdrom_device_info *devinfo = &info->devinfo;
1685
1686         devinfo->ops = &ide_cdrom_dops;
1687         devinfo->speed = info->current_speed;
1688         devinfo->capacity = nslots;
1689         devinfo->handle = drive;
1690         strcpy(devinfo->name, drive->name);
1691
1692         if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT)
1693                 devinfo->mask |= CDC_SELECT_SPEED;
1694
1695         devinfo->disk = info->disk;
1696         return register_cdrom(devinfo);
1697 }
1698
1699 static
1700 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
1701 {
1702         struct cdrom_info *cd = drive->driver_data;
1703         struct cdrom_device_info *cdi = &cd->devinfo;
1704         u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
1705         mechtype_t mechtype;
1706         int nslots = 1;
1707
1708         cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
1709                      CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO |
1710                      CDC_MO_DRIVE | CDC_RAM);
1711
1712         if (drive->media == ide_optical) {
1713                 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
1714                 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
1715                 return nslots;
1716         }
1717
1718         if (cd->cd_flags & IDE_CD_FLAG_PRE_ATAPI12) {
1719                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
1720                 cdi->mask &= ~CDC_PLAY_AUDIO;
1721                 return nslots;
1722         }
1723
1724         /*
1725          * we have to cheat a little here. the packet will eventually
1726          * be queued with ide_cdrom_packet(), which extracts the
1727          * drive from cdi->handle. Since this device hasn't been
1728          * registered with the Uniform layer yet, it can't do this.
1729          * Same goes for cdi->ops.
1730          */
1731         cdi->handle = drive;
1732         cdi->ops = &ide_cdrom_dops;
1733
1734         if (ide_cdrom_get_capabilities(drive, buf))
1735                 return 0;
1736
1737         if ((buf[8 + 6] & 0x01) == 0)
1738                 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
1739         if (buf[8 + 6] & 0x08)
1740                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
1741         if (buf[8 + 3] & 0x01)
1742                 cdi->mask &= ~CDC_CD_R;
1743         if (buf[8 + 3] & 0x02)
1744                 cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
1745         if (buf[8 + 2] & 0x38)
1746                 cdi->mask &= ~CDC_DVD;
1747         if (buf[8 + 3] & 0x20)
1748                 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
1749         if (buf[8 + 3] & 0x10)
1750                 cdi->mask &= ~CDC_DVD_R;
1751         if ((buf[8 + 4] & 0x01) || (cd->cd_flags & IDE_CD_FLAG_PLAY_AUDIO_OK))
1752                 cdi->mask &= ~CDC_PLAY_AUDIO;
1753
1754         mechtype = buf[8 + 6] >> 5;
1755         if (mechtype == mechtype_caddy || mechtype == mechtype_popup)
1756                 cdi->mask |= CDC_CLOSE_TRAY;
1757
1758         if (cdi->sanyo_slot > 0) {
1759                 cdi->mask &= ~CDC_SELECT_DISC;
1760                 nslots = 3;
1761         } else if (mechtype == mechtype_individual_changer ||
1762                    mechtype == mechtype_cartridge_changer) {
1763                 nslots = cdrom_number_of_slots(cdi);
1764                 if (nslots > 1)
1765                         cdi->mask &= ~CDC_SELECT_DISC;
1766         }
1767
1768         ide_cdrom_update_speed(drive, buf);
1769
1770         printk(KERN_INFO "%s: ATAPI", drive->name);
1771
1772         /* don't print speed if the drive reported 0 */
1773         if (cd->max_speed)
1774                 printk(KERN_CONT " %dX", cd->max_speed);
1775
1776         printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM");
1777
1778         if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
1779                 printk(KERN_CONT " DVD%s%s",
1780                                  (cdi->mask & CDC_DVD_R) ? "" : "-R",
1781                                  (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
1782
1783         if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
1784                 printk(KERN_CONT " CD%s%s",
1785                                  (cdi->mask & CDC_CD_R) ? "" : "-R",
1786                                  (cdi->mask & CDC_CD_RW) ? "" : "/RW");
1787
1788         if ((cdi->mask & CDC_SELECT_DISC) == 0)
1789                 printk(KERN_CONT " changer w/%d slots", nslots);
1790         else
1791                 printk(KERN_CONT " drive");
1792
1793         printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12]));
1794
1795         return nslots;
1796 }
1797
1798 #ifdef CONFIG_IDE_PROC_FS
1799 static void ide_cdrom_add_settings(ide_drive_t *drive)
1800 {
1801         ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
1802 }
1803 #else
1804 static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
1805 #endif
1806
1807 /*
1808  * standard prep_rq_fn that builds 10 byte cmds
1809  */
1810 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
1811 {
1812         int hard_sect = queue_hardsect_size(q);
1813         long block = (long)rq->hard_sector / (hard_sect >> 9);
1814         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
1815
1816         memset(rq->cmd, 0, sizeof(rq->cmd));
1817
1818         if (rq_data_dir(rq) == READ)
1819                 rq->cmd[0] = GPCMD_READ_10;
1820         else
1821                 rq->cmd[0] = GPCMD_WRITE_10;
1822
1823         /*
1824          * fill in lba
1825          */
1826         rq->cmd[2] = (block >> 24) & 0xff;
1827         rq->cmd[3] = (block >> 16) & 0xff;
1828         rq->cmd[4] = (block >>  8) & 0xff;
1829         rq->cmd[5] = block & 0xff;
1830
1831         /*
1832          * and transfer length
1833          */
1834         rq->cmd[7] = (blocks >> 8) & 0xff;
1835         rq->cmd[8] = blocks & 0xff;
1836         rq->cmd_len = 10;
1837         return BLKPREP_OK;
1838 }
1839
1840 /*
1841  * Most of the SCSI commands are supported directly by ATAPI devices.
1842  * This transform handles the few exceptions.
1843  */
1844 static int ide_cdrom_prep_pc(struct request *rq)
1845 {
1846         u8 *c = rq->cmd;
1847
1848         /*
1849          * Transform 6-byte read/write commands to the 10-byte version
1850          */
1851         if (c[0] == READ_6 || c[0] == WRITE_6) {
1852                 c[8] = c[4];
1853                 c[5] = c[3];
1854                 c[4] = c[2];
1855                 c[3] = c[1] & 0x1f;
1856                 c[2] = 0;
1857                 c[1] &= 0xe0;
1858                 c[0] += (READ_10 - READ_6);
1859                 rq->cmd_len = 10;
1860                 return BLKPREP_OK;
1861         }
1862
1863         /*
1864          * it's silly to pretend we understand 6-byte sense commands, just
1865          * reject with ILLEGAL_REQUEST and the caller should take the
1866          * appropriate action
1867          */
1868         if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
1869                 rq->errors = ILLEGAL_REQUEST;
1870                 return BLKPREP_KILL;
1871         }
1872         
1873         return BLKPREP_OK;
1874 }
1875
1876 static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
1877 {
1878         if (blk_fs_request(rq))
1879                 return ide_cdrom_prep_fs(q, rq);
1880         else if (blk_pc_request(rq))
1881                 return ide_cdrom_prep_pc(rq);
1882
1883         return 0;
1884 }
1885
1886 struct cd_list_entry {
1887         const char      *id_model;
1888         const char      *id_firmware;
1889         unsigned int    cd_flags;
1890 };
1891
1892 static const struct cd_list_entry ide_cd_quirks_list[] = {
1893         /* Limit transfer size per interrupt. */
1894         { "SAMSUNG CD-ROM SCR-2430", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
1895         { "SAMSUNG CD-ROM SCR-2432", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
1896         /* SCR-3231 doesn't support the SET_CD_SPEED command. */
1897         { "SAMSUNG CD-ROM SCR-3231", NULL,   IDE_CD_FLAG_NO_SPEED_SELECT    },
1898         /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
1899         { "NEC CD-ROM DRIVE:260",    "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD |
1900                                              IDE_CD_FLAG_PRE_ATAPI12,       },
1901         /* Vertos 300, some versions of this drive like to talk BCD. */
1902         { "V003S0DS",                NULL,   IDE_CD_FLAG_VERTOS_300_SSD,    },
1903         /* Vertos 600 ESD. */
1904         { "V006E0DS",                NULL,   IDE_CD_FLAG_VERTOS_600_ESD,    },
1905         /*
1906          * Sanyo 3 CD changer uses a non-standard command for CD changing
1907          * (by default standard ATAPI support for CD changers is used).
1908          */
1909         { "CD-ROM CDR-C3 G",         NULL,   IDE_CD_FLAG_SANYO_3CD          },
1910         { "CD-ROM CDR-C3G",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
1911         { "CD-ROM CDR_C36",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
1912         /* Stingray 8X CD-ROM. */
1913         { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_CD_FLAG_PRE_ATAPI12},
1914         /*
1915          * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
1916          * mode sense page capabilities size, but older drives break.
1917          */
1918         { "ATAPI CD ROM DRIVE 50X MAX", NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
1919         { "WPI CDS-32X",                NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
1920         /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
1921         { "",                        "241N", IDE_CD_FLAG_LE_SPEED_FIELDS    },
1922         /*
1923          * Some drives used by Apple don't advertise audio play
1924          * but they do support reading TOC & audio datas.
1925          */
1926         { "MATSHITADVD-ROM SR-8187", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1927         { "MATSHITADVD-ROM SR-8186", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1928         { "MATSHITADVD-ROM SR-8176", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1929         { "MATSHITADVD-ROM SR-8174", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
1930         { NULL, NULL, 0 }
1931 };
1932
1933 static unsigned int ide_cd_flags(struct hd_driveid *id)
1934 {
1935         const struct cd_list_entry *cle = ide_cd_quirks_list;
1936
1937         while (cle->id_model) {
1938                 if (strcmp(cle->id_model, id->model) == 0 &&
1939                     (cle->id_firmware == NULL ||
1940                      strstr(id->fw_rev, cle->id_firmware)))
1941                         return cle->cd_flags;
1942                 cle++;
1943         }
1944
1945         return 0;
1946 }
1947
1948 static
1949 int ide_cdrom_setup (ide_drive_t *drive)
1950 {
1951         struct cdrom_info *cd = drive->driver_data;
1952         struct cdrom_device_info *cdi = &cd->devinfo;
1953         struct hd_driveid *id = drive->id;
1954         int nslots;
1955
1956         blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
1957         blk_queue_dma_alignment(drive->queue, 31);
1958         drive->queue->unplug_delay = (1 * HZ) / 1000;
1959         if (!drive->queue->unplug_delay)
1960                 drive->queue->unplug_delay = 1;
1961
1962         drive->special.all      = 0;
1963
1964         cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT |
1965                        ide_cd_flags(id);
1966
1967         if ((id->config & 0x0060) == 0x20)
1968                 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
1969
1970         if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) &&
1971             id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
1972                 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
1973                                  IDE_CD_FLAG_TOCADDR_AS_BCD);
1974         else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) &&
1975                  id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
1976                 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
1977         else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
1978                 cdi->sanyo_slot = 3;    /* 3 => use CD in slot 0 */
1979
1980         nslots = ide_cdrom_probe_capabilities (drive);
1981
1982         /*
1983          * set correct block size
1984          */
1985         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
1986
1987         if (drive->autotune == IDE_TUNE_DEFAULT ||
1988             drive->autotune == IDE_TUNE_AUTO)
1989                 drive->dsc_overlap = (drive->next != drive);
1990
1991         if (ide_cdrom_register(drive, nslots)) {
1992                 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
1993                 cd->devinfo.handle = NULL;
1994                 return 1;
1995         }
1996         ide_cdrom_add_settings(drive);
1997         return 0;
1998 }
1999
2000 #ifdef CONFIG_IDE_PROC_FS
2001 static
2002 sector_t ide_cdrom_capacity (ide_drive_t *drive)
2003 {
2004         unsigned long capacity, sectors_per_frame;
2005
2006         if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
2007                 return 0;
2008
2009         return capacity * sectors_per_frame;
2010 }
2011 #endif
2012
2013 static void ide_cd_remove(ide_drive_t *drive)
2014 {
2015         struct cdrom_info *info = drive->driver_data;
2016
2017         ide_proc_unregister_driver(drive, info->driver);
2018
2019         del_gendisk(info->disk);
2020
2021         ide_cd_put(info);
2022 }
2023
2024 static void ide_cd_release(struct kref *kref)
2025 {
2026         struct cdrom_info *info = to_ide_cd(kref);
2027         struct cdrom_device_info *devinfo = &info->devinfo;
2028         ide_drive_t *drive = info->drive;
2029         struct gendisk *g = info->disk;
2030
2031         kfree(info->buffer);
2032         kfree(info->toc);
2033         if (devinfo->handle == drive && unregister_cdrom(devinfo))
2034                 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
2035                                 "driver.\n", __FUNCTION__, drive->name);
2036         drive->dsc_overlap = 0;
2037         drive->driver_data = NULL;
2038         blk_queue_prep_rq(drive->queue, NULL);
2039         g->private_data = NULL;
2040         put_disk(g);
2041         kfree(info);
2042 }
2043
2044 static int ide_cd_probe(ide_drive_t *);
2045
2046 #ifdef CONFIG_IDE_PROC_FS
2047 static int proc_idecd_read_capacity
2048         (char *page, char **start, off_t off, int count, int *eof, void *data)
2049 {
2050         ide_drive_t *drive = data;
2051         int len;
2052
2053         len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
2054         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
2055 }
2056
2057 static ide_proc_entry_t idecd_proc[] = {
2058         { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
2059         { NULL, 0, NULL, NULL }
2060 };
2061 #endif
2062
2063 static ide_driver_t ide_cdrom_driver = {
2064         .gen_driver = {
2065                 .owner          = THIS_MODULE,
2066                 .name           = "ide-cdrom",
2067                 .bus            = &ide_bus_type,
2068         },
2069         .probe                  = ide_cd_probe,
2070         .remove                 = ide_cd_remove,
2071         .version                = IDECD_VERSION,
2072         .media                  = ide_cdrom,
2073         .supports_dsc_overlap   = 1,
2074         .do_request             = ide_do_rw_cdrom,
2075         .end_request            = ide_end_request,
2076         .error                  = __ide_error,
2077         .abort                  = __ide_abort,
2078 #ifdef CONFIG_IDE_PROC_FS
2079         .proc                   = idecd_proc,
2080 #endif
2081 };
2082
2083 static int idecd_open(struct inode * inode, struct file * file)
2084 {
2085         struct gendisk *disk = inode->i_bdev->bd_disk;
2086         struct cdrom_info *info;
2087         int rc = -ENOMEM;
2088
2089         if (!(info = ide_cd_get(disk)))
2090                 return -ENXIO;
2091
2092         if (!info->buffer)
2093                 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
2094
2095         if (info->buffer)
2096                 rc = cdrom_open(&info->devinfo, inode, file);
2097
2098         if (rc < 0)
2099                 ide_cd_put(info);
2100
2101         return rc;
2102 }
2103
2104 static int idecd_release(struct inode * inode, struct file * file)
2105 {
2106         struct gendisk *disk = inode->i_bdev->bd_disk;
2107         struct cdrom_info *info = ide_cd_g(disk);
2108
2109         cdrom_release (&info->devinfo, file);
2110
2111         ide_cd_put(info);
2112
2113         return 0;
2114 }
2115
2116 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2117 {
2118         struct packet_command cgc;
2119         char buffer[16];
2120         int stat;
2121         char spindown;
2122
2123         if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
2124                 return -EFAULT;
2125
2126         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2127
2128         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2129         if (stat)
2130                 return stat;
2131
2132         buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2133         return cdrom_mode_select(cdi, &cgc);
2134 }
2135
2136 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2137 {
2138         struct packet_command cgc;
2139         char buffer[16];
2140         int stat;
2141         char spindown;
2142
2143         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2144
2145         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2146         if (stat)
2147                 return stat;
2148
2149         spindown = buffer[11] & 0x0f;
2150         if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
2151                 return -EFAULT;
2152         return 0;
2153 }
2154
2155 static int idecd_ioctl (struct inode *inode, struct file *file,
2156                         unsigned int cmd, unsigned long arg)
2157 {
2158         struct block_device *bdev = inode->i_bdev;
2159         struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
2160         int err;
2161
2162         switch (cmd) {
2163         case CDROMSETSPINDOWN:
2164                 return idecd_set_spindown(&info->devinfo, arg);
2165         case CDROMGETSPINDOWN:
2166                 return idecd_get_spindown(&info->devinfo, arg);
2167         default:
2168                 break;
2169         }
2170
2171         err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
2172         if (err == -EINVAL)
2173                 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
2174
2175         return err;
2176 }
2177
2178 static int idecd_media_changed(struct gendisk *disk)
2179 {
2180         struct cdrom_info *info = ide_cd_g(disk);
2181         return cdrom_media_changed(&info->devinfo);
2182 }
2183
2184 static int idecd_revalidate_disk(struct gendisk *disk)
2185 {
2186         struct cdrom_info *info = ide_cd_g(disk);
2187         struct request_sense sense;
2188
2189         ide_cd_read_toc(info->drive, &sense);
2190
2191         return  0;
2192 }
2193
2194 static struct block_device_operations idecd_ops = {
2195         .owner          = THIS_MODULE,
2196         .open           = idecd_open,
2197         .release        = idecd_release,
2198         .ioctl          = idecd_ioctl,
2199         .media_changed  = idecd_media_changed,
2200         .revalidate_disk= idecd_revalidate_disk
2201 };
2202
2203 /* options */
2204 static char *ignore = NULL;
2205
2206 module_param(ignore, charp, 0400);
2207 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2208
2209 static int ide_cd_probe(ide_drive_t *drive)
2210 {
2211         struct cdrom_info *info;
2212         struct gendisk *g;
2213         struct request_sense sense;
2214
2215         if (!strstr("ide-cdrom", drive->driver_req))
2216                 goto failed;
2217         if (!drive->present)
2218                 goto failed;
2219         if (drive->media != ide_cdrom && drive->media != ide_optical)
2220                 goto failed;
2221         /* skip drives that we were told to ignore */
2222         if (ignore != NULL) {
2223                 if (strstr(ignore, drive->name)) {
2224                         printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
2225                         goto failed;
2226                 }
2227         }
2228         if (drive->scsi) {
2229                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
2230                 goto failed;
2231         }
2232         info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
2233         if (info == NULL) {
2234                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
2235                 goto failed;
2236         }
2237
2238         g = alloc_disk(1 << PARTN_BITS);
2239         if (!g)
2240                 goto out_free_cd;
2241
2242         ide_init_disk(g, drive);
2243
2244         ide_proc_register_driver(drive, &ide_cdrom_driver);
2245
2246         kref_init(&info->kref);
2247
2248         info->drive = drive;
2249         info->driver = &ide_cdrom_driver;
2250         info->disk = g;
2251
2252         g->private_data = &info->driver;
2253
2254         drive->driver_data = info;
2255
2256         g->minors = 1;
2257         g->driverfs_dev = &drive->gendev;
2258         g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
2259         if (ide_cdrom_setup(drive)) {
2260                 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
2261                 ide_cd_release(&info->kref);
2262                 goto failed;
2263         }
2264
2265         ide_cd_read_toc(drive, &sense);
2266         g->fops = &idecd_ops;
2267         g->flags |= GENHD_FL_REMOVABLE;
2268         add_disk(g);
2269         return 0;
2270
2271 out_free_cd:
2272         kfree(info);
2273 failed:
2274         return -ENODEV;
2275 }
2276
2277 static void __exit ide_cdrom_exit(void)
2278 {
2279         driver_unregister(&ide_cdrom_driver.gen_driver);
2280 }
2281
2282 static int __init ide_cdrom_init(void)
2283 {
2284         return driver_register(&ide_cdrom_driver.gen_driver);
2285 }
2286
2287 MODULE_ALIAS("ide:*m-cdrom*");
2288 MODULE_ALIAS("ide-cd");
2289 module_init(ide_cdrom_init);
2290 module_exit(ide_cdrom_exit);
2291 MODULE_LICENSE("GPL");