d290e19845f89c3b515864d3354d464ae0d5d042
[linux-2.6.git] / drivers / ide / ide-cd.c
1 /*
2  * linux/drivers/ide/ide-cd.c
3  *
4  * Copyright (C) 1994, 1995, 1996  scott snyder  <snyder@fnald0.fnal.gov>
5  * Copyright (C) 1996-1998  Erik Andersen <andersee@debian.org>
6  * Copyright (C) 1998-2000  Jens Axboe <axboe@suse.de>
7  *
8  * May be copied or modified under the terms of the GNU General Public
9  * License.  See linux/COPYING for more information.
10  *
11  * ATAPI CD-ROM driver.  To be used with ide.c.
12  * See Documentation/cdrom/ide-cd for usage information.
13  *
14  * Suggestions are welcome. Patches that work are more welcome though. ;-)
15  * For those wishing to work on this driver, please be sure you download
16  * and comply with the latest Mt. Fuji (SFF8090 version 4) and ATAPI 
17  * (SFF-8020i rev 2.6) standards. These documents can be obtained by 
18  * anonymous ftp from:
19  * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps
20  * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf
21  *
22  * Drives that deviate from these standards will be accommodated as much
23  * as possible via compile time or command-line options.  Since I only have
24  * a few drives, you generally need to send me patches...
25  *
26  * ----------------------------------
27  * TO DO LIST:
28  * -Make it so that Pioneer CD DR-A24X and friends don't get screwed up on
29  *   boot
30  *
31  * For historical changelog please see:
32  *      Documentation/ide/ChangeLog.ide-cd.1994-2004
33  */
34
35 #define IDECD_VERSION "4.61"
36
37 #include <linux/module.h>
38 #include <linux/types.h>
39 #include <linux/kernel.h>
40 #include <linux/delay.h>
41 #include <linux/timer.h>
42 #include <linux/slab.h>
43 #include <linux/interrupt.h>
44 #include <linux/errno.h>
45 #include <linux/cdrom.h>
46 #include <linux/ide.h>
47 #include <linux/completion.h>
48 #include <linux/mutex.h>
49 #include <linux/bcd.h>
50
51 #include <scsi/scsi.h>  /* For SCSI -> ATAPI command conversion */
52
53 #include <asm/irq.h>
54 #include <asm/io.h>
55 #include <asm/byteorder.h>
56 #include <asm/uaccess.h>
57 #include <asm/unaligned.h>
58
59 #include "ide-cd.h"
60
61 static DEFINE_MUTEX(idecd_ref_mutex);
62
63 #define to_ide_cd(obj) container_of(obj, struct cdrom_info, kref) 
64
65 #define ide_cd_g(disk) \
66         container_of((disk)->private_data, struct cdrom_info, driver)
67
68 static struct cdrom_info *ide_cd_get(struct gendisk *disk)
69 {
70         struct cdrom_info *cd = NULL;
71
72         mutex_lock(&idecd_ref_mutex);
73         cd = ide_cd_g(disk);
74         if (cd)
75                 kref_get(&cd->kref);
76         mutex_unlock(&idecd_ref_mutex);
77         return cd;
78 }
79
80 static void ide_cd_release(struct kref *);
81
82 static void ide_cd_put(struct cdrom_info *cd)
83 {
84         mutex_lock(&idecd_ref_mutex);
85         kref_put(&cd->kref, ide_cd_release);
86         mutex_unlock(&idecd_ref_mutex);
87 }
88
89 /****************************************************************************
90  * Generic packet command support and error handling routines.
91  */
92
93 /* Mark that we've seen a media change, and invalidate our internal
94    buffers. */
95 static void cdrom_saw_media_change (ide_drive_t *drive)
96 {
97         struct cdrom_info *cd = drive->driver_data;
98
99         cd->cd_flags |= IDE_CD_FLAG_MEDIA_CHANGED;
100         cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
101         cd->nsectors_buffered = 0;
102 }
103
104 static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
105                            struct request_sense *sense)
106 {
107         int log = 0;
108
109         if (!sense || !rq || (rq->cmd_flags & REQ_QUIET))
110                 return 0;
111
112         switch (sense->sense_key) {
113                 case NO_SENSE: case RECOVERED_ERROR:
114                         break;
115                 case NOT_READY:
116                         /*
117                          * don't care about tray state messages for
118                          * e.g. capacity commands or in-progress or
119                          * becoming ready
120                          */
121                         if (sense->asc == 0x3a || sense->asc == 0x04)
122                                 break;
123                         log = 1;
124                         break;
125                 case ILLEGAL_REQUEST:
126                         /*
127                          * don't log START_STOP unit with LoEj set, since
128                          * we cannot reliably check if drive can auto-close
129                          */
130                         if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
131                                 break;
132                         log = 1;
133                         break;
134                 case UNIT_ATTENTION:
135                         /*
136                          * Make good and sure we've seen this potential media
137                          * change. Some drives (i.e. Creative) fail to present
138                          * the correct sense key in the error register.
139                          */
140                         cdrom_saw_media_change(drive);
141                         break;
142                 default:
143                         log = 1;
144                         break;
145         }
146         return log;
147 }
148
149 static
150 void cdrom_analyze_sense_data(ide_drive_t *drive,
151                               struct request *failed_command,
152                               struct request_sense *sense)
153 {
154         unsigned long sector;
155         unsigned long bio_sectors;
156         unsigned long valid;
157         struct cdrom_info *info = drive->driver_data;
158
159         if (!cdrom_log_sense(drive, failed_command, sense))
160                 return;
161
162         /*
163          * If a read toc is executed for a CD-R or CD-RW medium where
164          * the first toc has not been recorded yet, it will fail with
165          * 05/24/00 (which is a confusing error)
166          */
167         if (failed_command && failed_command->cmd[0] == GPCMD_READ_TOC_PMA_ATIP)
168                 if (sense->sense_key == 0x05 && sense->asc == 0x24)
169                         return;
170
171         if (sense->error_code == 0x70) {        /* Current Error */
172                 switch(sense->sense_key) {
173                 case MEDIUM_ERROR:
174                 case VOLUME_OVERFLOW:
175                 case ILLEGAL_REQUEST:
176                         if (!sense->valid)
177                                 break;
178                         if (failed_command == NULL ||
179                                         !blk_fs_request(failed_command))
180                                 break;
181                         sector = (sense->information[0] << 24) |
182                                  (sense->information[1] << 16) |
183                                  (sense->information[2] <<  8) |
184                                  (sense->information[3]);
185
186                         bio_sectors = bio_sectors(failed_command->bio);
187                         if (bio_sectors < 4)
188                                 bio_sectors = 4;
189                         if (drive->queue->hardsect_size == 2048)
190                                 sector <<= 2;   /* Device sector size is 2K */
191                         sector &= ~(bio_sectors -1);
192                         valid = (sector - failed_command->sector) << 9;
193
194                         if (valid < 0)
195                                 valid = 0;
196                         if (sector < get_capacity(info->disk) &&
197                                 drive->probed_capacity - sector < 4 * 75) {
198                                 set_capacity(info->disk, sector);
199                         }
200                 }
201         }
202
203         ide_cd_log_error(drive->name, failed_command, sense);
204 }
205
206 /*
207  * Initialize a ide-cd packet command request
208  */
209 static void cdrom_prepare_request(ide_drive_t *drive, struct request *rq)
210 {
211         struct cdrom_info *cd = drive->driver_data;
212
213         ide_init_drive_cmd(rq);
214         rq->cmd_type = REQ_TYPE_ATA_PC;
215         rq->rq_disk = cd->disk;
216 }
217
218 static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
219                                       struct request *failed_command)
220 {
221         struct cdrom_info *info         = drive->driver_data;
222         struct request *rq              = &info->request_sense_request;
223
224         if (sense == NULL)
225                 sense = &info->sense_data;
226
227         /* stuff the sense request in front of our current request */
228         cdrom_prepare_request(drive, rq);
229
230         rq->data = sense;
231         rq->cmd[0] = GPCMD_REQUEST_SENSE;
232         rq->cmd[4] = rq->data_len = 18;
233
234         rq->cmd_type = REQ_TYPE_SENSE;
235
236         /* NOTE! Save the failed command in "rq->buffer" */
237         rq->buffer = (void *) failed_command;
238
239         (void) ide_do_drive_cmd(drive, rq, ide_preempt);
240 }
241
242 static void cdrom_end_request (ide_drive_t *drive, int uptodate)
243 {
244         struct request *rq = HWGROUP(drive)->rq;
245         int nsectors = rq->hard_cur_sectors;
246
247         if (blk_sense_request(rq) && uptodate) {
248                 /*
249                  * For REQ_TYPE_SENSE, "rq->buffer" points to the original
250                  * failed request
251                  */
252                 struct request *failed = (struct request *) rq->buffer;
253                 struct cdrom_info *info = drive->driver_data;
254                 void *sense = &info->sense_data;
255                 unsigned long flags;
256
257                 if (failed) {
258                         if (failed->sense) {
259                                 sense = failed->sense;
260                                 failed->sense_len = rq->sense_len;
261                         }
262                         cdrom_analyze_sense_data(drive, failed, sense);
263                         /*
264                          * now end failed request
265                          */
266                         if (blk_fs_request(failed)) {
267                                 if (ide_end_dequeued_request(drive, failed, 0,
268                                                 failed->hard_nr_sectors))
269                                         BUG();
270                         } else {
271                                 spin_lock_irqsave(&ide_lock, flags);
272                                 if (__blk_end_request(failed, -EIO,
273                                                       failed->data_len))
274                                         BUG();
275                                 spin_unlock_irqrestore(&ide_lock, flags);
276                         }
277                 } else
278                         cdrom_analyze_sense_data(drive, NULL, sense);
279         }
280
281         if (!rq->current_nr_sectors && blk_fs_request(rq))
282                 uptodate = 1;
283         /* make sure it's fully ended */
284         if (blk_pc_request(rq))
285                 nsectors = (rq->data_len + 511) >> 9;
286         if (!nsectors)
287                 nsectors = 1;
288
289         ide_end_request(drive, uptodate, nsectors);
290 }
291
292 static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 stat)
293 {
294         if (stat & 0x80)
295                 return;
296         ide_dump_status(drive, msg, stat);
297 }
298
299 /* Returns 0 if the request should be continued.
300    Returns 1 if the request was ended. */
301 static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
302 {
303         struct request *rq = HWGROUP(drive)->rq;
304         int stat, err, sense_key;
305         
306         /* Check for errors. */
307         stat = HWIF(drive)->INB(IDE_STATUS_REG);
308         if (stat_ret)
309                 *stat_ret = stat;
310
311         if (OK_STAT(stat, good_stat, BAD_R_STAT))
312                 return 0;
313
314         /* Get the IDE error register. */
315         err = HWIF(drive)->INB(IDE_ERROR_REG);
316         sense_key = err >> 4;
317
318         if (rq == NULL) {
319                 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
320                 return 1;
321         }
322
323         if (blk_sense_request(rq)) {
324                 /* We got an error trying to get sense info
325                    from the drive (probably while trying
326                    to recover from a former error).  Just give up. */
327
328                 rq->cmd_flags |= REQ_FAILED;
329                 cdrom_end_request(drive, 0);
330                 ide_error(drive, "request sense failure", stat);
331                 return 1;
332
333         } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
334                 /* All other functions, except for READ. */
335                 unsigned long flags;
336
337                 /*
338                  * if we have an error, pass back CHECK_CONDITION as the
339                  * scsi status byte
340                  */
341                 if (blk_pc_request(rq) && !rq->errors)
342                         rq->errors = SAM_STAT_CHECK_CONDITION;
343
344                 /* Check for tray open. */
345                 if (sense_key == NOT_READY) {
346                         cdrom_saw_media_change (drive);
347                 } else if (sense_key == UNIT_ATTENTION) {
348                         /* Check for media change. */
349                         cdrom_saw_media_change (drive);
350                         /*printk("%s: media changed\n",drive->name);*/
351                         return 0;
352                 } else if ((sense_key == ILLEGAL_REQUEST) &&
353                            (rq->cmd[0] == GPCMD_START_STOP_UNIT)) {
354                         /*
355                          * Don't print error message for this condition--
356                          * SFF8090i indicates that 5/24/00 is the correct
357                          * response to a request to close the tray if the
358                          * drive doesn't have that capability.
359                          * cdrom_log_sense() knows this!
360                          */
361                 } else if (!(rq->cmd_flags & REQ_QUIET)) {
362                         /* Otherwise, print an error. */
363                         ide_dump_status(drive, "packet command error", stat);
364                 }
365                 
366                 rq->cmd_flags |= REQ_FAILED;
367
368                 /*
369                  * instead of playing games with moving completions around,
370                  * remove failed request completely and end it when the
371                  * request sense has completed
372                  */
373                 if (stat & ERR_STAT) {
374                         spin_lock_irqsave(&ide_lock, flags);
375                         blkdev_dequeue_request(rq);
376                         HWGROUP(drive)->rq = NULL;
377                         spin_unlock_irqrestore(&ide_lock, flags);
378
379                         cdrom_queue_request_sense(drive, rq->sense, rq);
380                 } else
381                         cdrom_end_request(drive, 0);
382
383         } else if (blk_fs_request(rq)) {
384                 int do_end_request = 0;
385
386                 /* Handle errors from READ and WRITE requests. */
387
388                 if (blk_noretry_request(rq))
389                         do_end_request = 1;
390
391                 if (sense_key == NOT_READY) {
392                         /* Tray open. */
393                         if (rq_data_dir(rq) == READ) {
394                                 cdrom_saw_media_change (drive);
395
396                                 /* Fail the request. */
397                                 printk ("%s: tray open\n", drive->name);
398                                 do_end_request = 1;
399                         } else {
400                                 struct cdrom_info *info = drive->driver_data;
401
402                                 /* allow the drive 5 seconds to recover, some
403                                  * devices will return this error while flushing
404                                  * data from cache */
405                                 if (!rq->errors)
406                                         info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
407                                 rq->errors = 1;
408                                 if (time_after(jiffies, info->write_timeout))
409                                         do_end_request = 1;
410                                 else {
411                                         unsigned long flags;
412
413                                         /*
414                                          * take a breather relying on the
415                                          * unplug timer to kick us again
416                                          */
417                                         spin_lock_irqsave(&ide_lock, flags);
418                                         blk_plug_device(drive->queue);
419                                         spin_unlock_irqrestore(&ide_lock,flags);
420                                         return 1;
421                                 }
422                         }
423                 } else if (sense_key == UNIT_ATTENTION) {
424                         /* Media change. */
425                         cdrom_saw_media_change (drive);
426
427                         /* Arrange to retry the request.
428                            But be sure to give up if we've retried
429                            too many times. */
430                         if (++rq->errors > ERROR_MAX)
431                                 do_end_request = 1;
432                 } else if (sense_key == ILLEGAL_REQUEST ||
433                            sense_key == DATA_PROTECT) {
434                         /* No point in retrying after an illegal
435                            request or data protect error.*/
436                         ide_dump_status_no_sense (drive, "command error", stat);
437                         do_end_request = 1;
438                 } else if (sense_key == MEDIUM_ERROR) {
439                         /* No point in re-trying a zillion times on a bad 
440                          * sector...  If we got here the error is not correctable */
441                         ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
442                         do_end_request = 1;
443                 } else if (sense_key == BLANK_CHECK) {
444                         /* Disk appears blank ?? */
445                         ide_dump_status_no_sense (drive, "media error (blank)", stat);
446                         do_end_request = 1;
447                 } else if ((err & ~ABRT_ERR) != 0) {
448                         /* Go to the default handler
449                            for other errors. */
450                         ide_error(drive, "cdrom_decode_status", stat);
451                         return 1;
452                 } else if ((++rq->errors > ERROR_MAX)) {
453                         /* We've racked up too many retries.  Abort. */
454                         do_end_request = 1;
455                 }
456
457                 /* End a request through request sense analysis when we have
458                    sense data. We need this in order to perform end of media
459                    processing */
460
461                 if (do_end_request) {
462                         if (stat & ERR_STAT) {
463                                 unsigned long flags;
464                                 spin_lock_irqsave(&ide_lock, flags);
465                                 blkdev_dequeue_request(rq);
466                                 HWGROUP(drive)->rq = NULL;
467                                 spin_unlock_irqrestore(&ide_lock, flags);
468
469                                 cdrom_queue_request_sense(drive, rq->sense, rq);
470                         } else
471                                 cdrom_end_request(drive, 0);
472                 } else {
473                         /* If we got a CHECK_CONDITION status,
474                            queue a request sense command. */
475                         if (stat & ERR_STAT)
476                                 cdrom_queue_request_sense(drive, NULL, NULL);
477                 }
478         } else {
479                 blk_dump_rq_flags(rq, "ide-cd: bad rq");
480                 cdrom_end_request(drive, 0);
481         }
482
483         /* Retry, or handle the next request. */
484         return 1;
485 }
486
487 static int cdrom_timer_expiry(ide_drive_t *drive)
488 {
489         struct request *rq = HWGROUP(drive)->rq;
490         unsigned long wait = 0;
491
492         /*
493          * Some commands are *slow* and normally take a long time to
494          * complete. Usually we can use the ATAPI "disconnect" to bypass
495          * this, but not all commands/drives support that. Let
496          * ide_timer_expiry keep polling us for these.
497          */
498         switch (rq->cmd[0]) {
499                 case GPCMD_BLANK:
500                 case GPCMD_FORMAT_UNIT:
501                 case GPCMD_RESERVE_RZONE_TRACK:
502                 case GPCMD_CLOSE_TRACK:
503                 case GPCMD_FLUSH_CACHE:
504                         wait = ATAPI_WAIT_PC;
505                         break;
506                 default:
507                         if (!(rq->cmd_flags & REQ_QUIET))
508                                 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
509                         wait = 0;
510                         break;
511         }
512         return wait;
513 }
514
515 /* Set up the device registers for transferring a packet command on DEV,
516    expecting to later transfer XFERLEN bytes.  HANDLER is the routine
517    which actually transfers the command to the drive.  If this is a
518    drq_interrupt device, this routine will arrange for HANDLER to be
519    called when the interrupt from the drive arrives.  Otherwise, HANDLER
520    will be called immediately after the drive is prepared for the transfer. */
521
522 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
523                                                   int xferlen,
524                                                   ide_handler_t *handler)
525 {
526         ide_startstop_t startstop;
527         struct cdrom_info *info = drive->driver_data;
528         ide_hwif_t *hwif = drive->hwif;
529
530         /* Wait for the controller to be idle. */
531         if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
532                 return startstop;
533
534         /* FIXME: for Virtual DMA we must check harder */
535         if (info->dma)
536                 info->dma = !hwif->dma_setup(drive);
537
538         /* Set up the controller registers. */
539         ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL |
540                            IDE_TFLAG_NO_SELECT_MASK, xferlen, info->dma);
541
542         if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
543                 /* waiting for CDB interrupt, not DMA yet. */
544                 if (info->dma)
545                         drive->waiting_for_dma = 0;
546
547                 /* packet command */
548                 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
549                 return ide_started;
550         } else {
551                 unsigned long flags;
552
553                 /* packet command */
554                 spin_lock_irqsave(&ide_lock, flags);
555                 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
556                 ndelay(400);
557                 spin_unlock_irqrestore(&ide_lock, flags);
558
559                 return (*handler) (drive);
560         }
561 }
562
563 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
564    The device registers must have already been prepared
565    by cdrom_start_packet_command.
566    HANDLER is the interrupt handler to call when the command completes
567    or there's data ready. */
568 #define ATAPI_MIN_CDB_BYTES 12
569 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
570                                           struct request *rq,
571                                           ide_handler_t *handler)
572 {
573         ide_hwif_t *hwif = drive->hwif;
574         int cmd_len;
575         struct cdrom_info *info = drive->driver_data;
576         ide_startstop_t startstop;
577
578         if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
579                 /* Here we should have been called after receiving an interrupt
580                    from the device.  DRQ should how be set. */
581
582                 /* Check for errors. */
583                 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
584                         return ide_stopped;
585
586                 /* Ok, next interrupt will be DMA interrupt. */
587                 if (info->dma)
588                         drive->waiting_for_dma = 1;
589         } else {
590                 /* Otherwise, we must wait for DRQ to get set. */
591                 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
592                                 BUSY_STAT, WAIT_READY))
593                         return startstop;
594         }
595
596         /* Arm the interrupt handler. */
597         ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
598
599         /* ATAPI commands get padded out to 12 bytes minimum */
600         cmd_len = COMMAND_SIZE(rq->cmd[0]);
601         if (cmd_len < ATAPI_MIN_CDB_BYTES)
602                 cmd_len = ATAPI_MIN_CDB_BYTES;
603
604         /* Send the command to the device. */
605         HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
606
607         /* Start the DMA if need be */
608         if (info->dma)
609                 hwif->dma_start(drive);
610
611         return ide_started;
612 }
613
614 /****************************************************************************
615  * Block read functions.
616  */
617
618 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
619
620 static void ide_cd_pad_transfer(ide_drive_t *drive, xfer_func_t *xf, int len)
621 {
622         while (len > 0) {
623                 int dum = 0;
624                 xf(drive, &dum, sizeof(dum));
625                 len -= sizeof(dum);
626         }
627 }
628
629 /*
630  * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
631  * buffer.  Once the first sector is added, any subsequent sectors are
632  * assumed to be continuous (until the buffer is cleared).  For the first
633  * sector added, SECTOR is its sector number.  (SECTOR is then ignored until
634  * the buffer is cleared.)
635  */
636 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
637                                   int sectors_to_transfer)
638 {
639         struct cdrom_info *info = drive->driver_data;
640
641         /* Number of sectors to read into the buffer. */
642         int sectors_to_buffer = min_t(int, sectors_to_transfer,
643                                      (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
644                                        info->nsectors_buffered);
645
646         char *dest;
647
648         /* If we couldn't get a buffer, don't try to buffer anything... */
649         if (info->buffer == NULL)
650                 sectors_to_buffer = 0;
651
652         /* If this is the first sector in the buffer, remember its number. */
653         if (info->nsectors_buffered == 0)
654                 info->sector_buffered = sector;
655
656         /* Read the data into the buffer. */
657         dest = info->buffer + info->nsectors_buffered * SECTOR_SIZE;
658         while (sectors_to_buffer > 0) {
659                 HWIF(drive)->atapi_input_bytes(drive, dest, SECTOR_SIZE);
660                 --sectors_to_buffer;
661                 --sectors_to_transfer;
662                 ++info->nsectors_buffered;
663                 dest += SECTOR_SIZE;
664         }
665
666         /* Throw away any remaining data. */
667         while (sectors_to_transfer > 0) {
668                 static char dum[SECTOR_SIZE];
669                 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
670                 --sectors_to_transfer;
671         }
672 }
673
674 /*
675  * Check the contents of the interrupt reason register from the cdrom
676  * and attempt to recover if there are problems.  Returns  0 if everything's
677  * ok; nonzero if the request has been terminated.
678  */
679 static
680 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
681 {
682         if (ireason == 2)
683                 return 0;
684         else if (ireason == 0) {
685                 ide_hwif_t *hwif = drive->hwif;
686
687                 /* Whoops... The drive is expecting to receive data from us! */
688                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
689                                 drive->name, __FUNCTION__);
690
691                 /* Throw some data at the drive so it doesn't hang
692                    and quit this request. */
693                 ide_cd_pad_transfer(drive, hwif->atapi_output_bytes, len);
694         } else  if (ireason == 1) {
695                 /* Some drives (ASUS) seem to tell us that status
696                  * info is available. just get it and ignore.
697                  */
698                 (void) HWIF(drive)->INB(IDE_STATUS_REG);
699                 return 0;
700         } else {
701                 /* Drive wants a command packet, or invalid ireason... */
702                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
703                                 drive->name, __FUNCTION__, ireason);
704         }
705
706         cdrom_end_request(drive, 0);
707         return -1;
708 }
709
710 /*
711  * Interrupt routine.  Called when a read request has completed.
712  */
713 static ide_startstop_t cdrom_read_intr (ide_drive_t *drive)
714 {
715         int stat;
716         int ireason, len, sectors_to_transfer, nskip;
717         struct cdrom_info *info = drive->driver_data;
718         u8 lowcyl = 0, highcyl = 0;
719         int dma = info->dma, dma_error = 0;
720
721         struct request *rq = HWGROUP(drive)->rq;
722
723         /*
724          * handle dma case
725          */
726         if (dma) {
727                 info->dma = 0;
728                 dma_error = HWIF(drive)->ide_dma_end(drive);
729                 if (dma_error) {
730                         printk(KERN_ERR "%s: DMA read error\n", drive->name);
731                         ide_dma_off(drive);
732                 }
733         }
734
735         if (cdrom_decode_status(drive, 0, &stat))
736                 return ide_stopped;
737
738         if (dma) {
739                 if (!dma_error) {
740                         ide_end_request(drive, 1, rq->nr_sectors);
741                         return ide_stopped;
742                 } else
743                         return ide_error(drive, "dma error", stat);
744         }
745
746         /* Read the interrupt reason and the transfer length. */
747         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
748         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
749         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
750
751         len = lowcyl + (256 * highcyl);
752
753         /* If DRQ is clear, the command has completed. */
754         if ((stat & DRQ_STAT) == 0) {
755                 /* If we're not done filling the current buffer, complain.
756                    Otherwise, complete the command normally. */
757                 if (rq->current_nr_sectors > 0) {
758                         printk (KERN_ERR "%s: cdrom_read_intr: data underrun (%d blocks)\n",
759                                 drive->name, rq->current_nr_sectors);
760                         rq->cmd_flags |= REQ_FAILED;
761                         cdrom_end_request(drive, 0);
762                 } else
763                         cdrom_end_request(drive, 1);
764                 return ide_stopped;
765         }
766
767         /* Check that the drive is expecting to do the same thing we are. */
768         if (cdrom_read_check_ireason (drive, len, ireason))
769                 return ide_stopped;
770
771         /* Assume that the drive will always provide data in multiples
772            of at least SECTOR_SIZE, as it gets hairy to keep track
773            of the transfers otherwise. */
774         if ((len % SECTOR_SIZE) != 0) {
775                 printk (KERN_ERR "%s: cdrom_read_intr: Bad transfer size %d\n",
776                         drive->name, len);
777                 if (info->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES)
778                         printk (KERN_ERR "  This drive is not supported by this version of the driver\n");
779                 else {
780                         printk (KERN_ERR "  Trying to limit transfer sizes\n");
781                         info->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES;
782                 }
783                 cdrom_end_request(drive, 0);
784                 return ide_stopped;
785         }
786
787         /* The number of sectors we need to read from the drive. */
788         sectors_to_transfer = len / SECTOR_SIZE;
789
790         /* First, figure out if we need to bit-bucket
791            any of the leading sectors. */
792         nskip = min_t(int, rq->current_nr_sectors - bio_cur_sectors(rq->bio), sectors_to_transfer);
793
794         while (nskip > 0) {
795                 /* We need to throw away a sector. */
796                 static char dum[SECTOR_SIZE];
797                 HWIF(drive)->atapi_input_bytes(drive, dum, sizeof (dum));
798
799                 --rq->current_nr_sectors;
800                 --nskip;
801                 --sectors_to_transfer;
802         }
803
804         /* Now loop while we still have data to read from the drive. */
805         while (sectors_to_transfer > 0) {
806                 int this_transfer;
807
808                 /* If we've filled the present buffer but there's another
809                    chained buffer after it, move on. */
810                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
811                         cdrom_end_request(drive, 1);
812
813                 /* If the buffers are full, cache the rest of the data in our
814                    internal buffer. */
815                 if (rq->current_nr_sectors == 0) {
816                         cdrom_buffer_sectors(drive, rq->sector, sectors_to_transfer);
817                         sectors_to_transfer = 0;
818                 } else {
819                         /* Transfer data to the buffers.
820                            Figure out how many sectors we can transfer
821                            to the current buffer. */
822                         this_transfer = min_t(int, sectors_to_transfer,
823                                              rq->current_nr_sectors);
824
825                         /* Read this_transfer sectors
826                            into the current buffer. */
827                         while (this_transfer > 0) {
828                                 HWIF(drive)->atapi_input_bytes(drive, rq->buffer, SECTOR_SIZE);
829                                 rq->buffer += SECTOR_SIZE;
830                                 --rq->nr_sectors;
831                                 --rq->current_nr_sectors;
832                                 ++rq->sector;
833                                 --this_transfer;
834                                 --sectors_to_transfer;
835                         }
836                 }
837         }
838
839         /* Done moving data!  Wait for another interrupt. */
840         ide_set_handler(drive, &cdrom_read_intr, ATAPI_WAIT_PC, NULL);
841         return ide_started;
842 }
843
844 /*
845  * Try to satisfy some of the current read request from our cached data.
846  * Returns nonzero if the request has been completed, zero otherwise.
847  */
848 static int cdrom_read_from_buffer (ide_drive_t *drive)
849 {
850         struct cdrom_info *info = drive->driver_data;
851         struct request *rq = HWGROUP(drive)->rq;
852         unsigned short sectors_per_frame;
853
854         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
855
856         /* Can't do anything if there's no buffer. */
857         if (info->buffer == NULL) return 0;
858
859         /* Loop while this request needs data and the next block is present
860            in our cache. */
861         while (rq->nr_sectors > 0 &&
862                rq->sector >= info->sector_buffered &&
863                rq->sector < info->sector_buffered + info->nsectors_buffered) {
864                 if (rq->current_nr_sectors == 0)
865                         cdrom_end_request(drive, 1);
866
867                 memcpy (rq->buffer,
868                         info->buffer +
869                         (rq->sector - info->sector_buffered) * SECTOR_SIZE,
870                         SECTOR_SIZE);
871                 rq->buffer += SECTOR_SIZE;
872                 --rq->current_nr_sectors;
873                 --rq->nr_sectors;
874                 ++rq->sector;
875         }
876
877         /* If we've satisfied the current request,
878            terminate it successfully. */
879         if (rq->nr_sectors == 0) {
880                 cdrom_end_request(drive, 1);
881                 return -1;
882         }
883
884         /* Move on to the next buffer if needed. */
885         if (rq->current_nr_sectors == 0)
886                 cdrom_end_request(drive, 1);
887
888         /* If this condition does not hold, then the kluge i use to
889            represent the number of sectors to skip at the start of a transfer
890            will fail.  I think that this will never happen, but let's be
891            paranoid and check. */
892         if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
893             (rq->sector & (sectors_per_frame - 1))) {
894                 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
895                         drive->name, (long)rq->sector);
896                 cdrom_end_request(drive, 0);
897                 return -1;
898         }
899
900         return 0;
901 }
902
903 /*
904  * Routine to send a read packet command to the drive.
905  * This is usually called directly from cdrom_start_read.
906  * However, for drq_interrupt devices, it is called from an interrupt
907  * when the drive is ready to accept the command.
908  */
909 static ide_startstop_t cdrom_start_read_continuation (ide_drive_t *drive)
910 {
911         struct request *rq = HWGROUP(drive)->rq;
912         unsigned short sectors_per_frame;
913         int nskip;
914
915         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
916
917         /* If the requested sector doesn't start on a cdrom block boundary,
918            we must adjust the start of the transfer so that it does,
919            and remember to skip the first few sectors.
920            If the CURRENT_NR_SECTORS field is larger than the size
921            of the buffer, it will mean that we're to skip a number
922            of sectors equal to the amount by which CURRENT_NR_SECTORS
923            is larger than the buffer size. */
924         nskip = rq->sector & (sectors_per_frame - 1);
925         if (nskip > 0) {
926                 /* Sanity check... */
927                 if (rq->current_nr_sectors != bio_cur_sectors(rq->bio) &&
928                         (rq->sector & (sectors_per_frame - 1))) {
929                         printk(KERN_ERR "%s: cdrom_start_read_continuation: buffer botch (%u)\n",
930                                 drive->name, rq->current_nr_sectors);
931                         cdrom_end_request(drive, 0);
932                         return ide_stopped;
933                 }
934                 rq->current_nr_sectors += nskip;
935         }
936
937         /* Set up the command */
938         rq->timeout = ATAPI_WAIT_PC;
939
940         /* Send the command to the drive and return. */
941         return cdrom_transfer_packet_command(drive, rq, &cdrom_read_intr);
942 }
943
944
945 #define IDECD_SEEK_THRESHOLD    (1000)                  /* 1000 blocks */
946 #define IDECD_SEEK_TIMER        (5 * WAIT_MIN_SLEEP)    /* 100 ms */
947 #define IDECD_SEEK_TIMEOUT      (2 * WAIT_CMD)          /* 20 sec */
948
949 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
950 {
951         struct cdrom_info *info = drive->driver_data;
952         int stat;
953         static int retry = 10;
954
955         if (cdrom_decode_status(drive, 0, &stat))
956                 return ide_stopped;
957
958         info->cd_flags |= IDE_CD_FLAG_SEEKING;
959
960         if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
961                 if (--retry == 0) {
962                         /*
963                          * this condition is far too common, to bother
964                          * users about it
965                          */
966                         /* printk("%s: disabled DSC seek overlap\n", drive->name);*/ 
967                         drive->dsc_overlap = 0;
968                 }
969         }
970         return ide_stopped;
971 }
972
973 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
974 {
975         struct request *rq = HWGROUP(drive)->rq;
976         sector_t frame = rq->sector;
977
978         sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
979
980         memset(rq->cmd, 0, sizeof(rq->cmd));
981         rq->cmd[0] = GPCMD_SEEK;
982         put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
983
984         rq->timeout = ATAPI_WAIT_PC;
985         return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
986 }
987
988 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
989 {
990         struct cdrom_info *info = drive->driver_data;
991
992         info->dma = 0;
993         info->start_seek = jiffies;
994         return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
995 }
996
997 /* Fix up a possibly partially-processed request so that we can
998    start it over entirely, or even put it back on the request queue. */
999 static void restore_request (struct request *rq)
1000 {
1001         if (rq->buffer != bio_data(rq->bio)) {
1002                 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
1003
1004                 rq->buffer = bio_data(rq->bio);
1005                 rq->nr_sectors += n;
1006                 rq->sector -= n;
1007         }
1008         rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
1009         rq->hard_nr_sectors = rq->nr_sectors;
1010         rq->hard_sector = rq->sector;
1011         rq->q->prep_rq_fn(rq->q, rq);
1012 }
1013
1014 /*
1015  * Start a read request from the CD-ROM.
1016  */
1017 static ide_startstop_t cdrom_start_read (ide_drive_t *drive, unsigned int block)
1018 {
1019         struct cdrom_info *info = drive->driver_data;
1020         struct request *rq = HWGROUP(drive)->rq;
1021         unsigned short sectors_per_frame;
1022
1023         sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1024
1025         /* We may be retrying this request after an error.  Fix up
1026            any weirdness which might be present in the request packet. */
1027         restore_request(rq);
1028
1029         /* Satisfy whatever we can of this request from our cached sector. */
1030         if (cdrom_read_from_buffer(drive))
1031                 return ide_stopped;
1032
1033         /* Clear the local sector buffer. */
1034         info->nsectors_buffered = 0;
1035
1036         /* use dma, if possible. */
1037         info->dma = drive->using_dma;
1038         if ((rq->sector & (sectors_per_frame - 1)) ||
1039             (rq->nr_sectors & (sectors_per_frame - 1)))
1040                 info->dma = 0;
1041
1042         /* Start sending the read request to the drive. */
1043         return cdrom_start_packet_command(drive, 32768, cdrom_start_read_continuation);
1044 }
1045
1046 /****************************************************************************
1047  * Execute all other packet commands.
1048  */
1049
1050 /* Interrupt routine for packet command completion. */
1051 static ide_startstop_t cdrom_pc_intr (ide_drive_t *drive)
1052 {
1053         struct request *rq = HWGROUP(drive)->rq;
1054         xfer_func_t *xferfunc = NULL;
1055         int stat, ireason, len, thislen, write;
1056         u8 lowcyl = 0, highcyl = 0;
1057
1058         /* Check for errors. */
1059         if (cdrom_decode_status(drive, 0, &stat))
1060                 return ide_stopped;
1061
1062         /* Read the interrupt reason and the transfer length. */
1063         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1064         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1065         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1066
1067         len = lowcyl + (256 * highcyl);
1068
1069         /* If DRQ is clear, the command has completed.
1070            Complain if we still have data left to transfer. */
1071         if ((stat & DRQ_STAT) == 0) {
1072                 /* Some of the trailing request sense fields are optional, and
1073                    some drives don't send them.  Sigh. */
1074                 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
1075                     rq->data_len > 0 &&
1076                     rq->data_len <= 5) {
1077                         while (rq->data_len > 0) {
1078                                 *(unsigned char *)rq->data++ = 0;
1079                                 --rq->data_len;
1080                         }
1081                 }
1082
1083                 if (rq->data_len == 0)
1084                         cdrom_end_request(drive, 1);
1085                 else {
1086                         rq->cmd_flags |= REQ_FAILED;
1087                         cdrom_end_request(drive, 0);
1088                 }
1089                 return ide_stopped;
1090         }
1091
1092         /* Figure out how much data to transfer. */
1093         thislen = rq->data_len;
1094         if (thislen > len)
1095                 thislen = len;
1096
1097         if (ireason == 0) {
1098                 write = 1;
1099                 xferfunc = HWIF(drive)->atapi_output_bytes;
1100         } else if (ireason == 2) {
1101                 write = 0;
1102                 xferfunc = HWIF(drive)->atapi_input_bytes;
1103         }
1104
1105         if (xferfunc) {
1106                 if (!rq->data) {
1107                         printk(KERN_ERR "%s: confused, missing data\n",
1108                                         drive->name);
1109                         blk_dump_rq_flags(rq, write ? "cdrom_pc_intr, write"
1110                                                     : "cdrom_pc_intr, read");
1111                         goto pad;
1112                 }
1113                 /* Transfer the data. */
1114                 xferfunc(drive, rq->data, thislen);
1115
1116                 /* Keep count of how much data we've moved. */
1117                 len -= thislen;
1118                 rq->data += thislen;
1119                 rq->data_len -= thislen;
1120
1121                 if (write && blk_sense_request(rq))
1122                         rq->sense_len += thislen;
1123         } else {
1124                 printk (KERN_ERR "%s: cdrom_pc_intr: The drive "
1125                         "appears confused (ireason = 0x%02x). "
1126                         "Trying to recover by ending request.\n",
1127                         drive->name, ireason);
1128                 rq->cmd_flags |= REQ_FAILED;
1129                 cdrom_end_request(drive, 0);
1130                 return ide_stopped;
1131         }
1132 pad:
1133         /*
1134          * If we haven't moved enough data to satisfy the drive,
1135          * add some padding.
1136          */
1137         if (len > 0)
1138                 ide_cd_pad_transfer(drive, xferfunc, len);
1139
1140         /* Now we wait for another interrupt. */
1141         ide_set_handler(drive, &cdrom_pc_intr, ATAPI_WAIT_PC, cdrom_timer_expiry);
1142         return ide_started;
1143 }
1144
1145 static ide_startstop_t cdrom_do_pc_continuation (ide_drive_t *drive)
1146 {
1147         struct request *rq = HWGROUP(drive)->rq;
1148
1149         if (!rq->timeout)
1150                 rq->timeout = ATAPI_WAIT_PC;
1151
1152         /* Send the command to the drive and return. */
1153         return cdrom_transfer_packet_command(drive, rq, &cdrom_pc_intr);
1154 }
1155
1156
1157 static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
1158 {
1159         int len;
1160         struct request *rq = HWGROUP(drive)->rq;
1161         struct cdrom_info *info = drive->driver_data;
1162
1163         info->dma = 0;
1164         rq->cmd_flags &= ~REQ_FAILED;
1165         len = rq->data_len;
1166
1167         /* Start sending the command to the drive. */
1168         return cdrom_start_packet_command(drive, len, cdrom_do_pc_continuation);
1169 }
1170
1171
1172 static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
1173 {
1174         struct request_sense sense;
1175         int retries = 10;
1176         unsigned int flags = rq->cmd_flags;
1177
1178         if (rq->sense == NULL)
1179                 rq->sense = &sense;
1180
1181         /* Start of retry loop. */
1182         do {
1183                 int error;
1184                 unsigned long time = jiffies;
1185                 rq->cmd_flags = flags;
1186
1187                 error = ide_do_drive_cmd(drive, rq, ide_wait);
1188                 time = jiffies - time;
1189
1190                 /* FIXME: we should probably abort/retry or something 
1191                  * in case of failure */
1192                 if (rq->cmd_flags & REQ_FAILED) {
1193                         /* The request failed.  Retry if it was due to a unit
1194                            attention status
1195                            (usually means media was changed). */
1196                         struct request_sense *reqbuf = rq->sense;
1197
1198                         if (reqbuf->sense_key == UNIT_ATTENTION)
1199                                 cdrom_saw_media_change(drive);
1200                         else if (reqbuf->sense_key == NOT_READY &&
1201                                  reqbuf->asc == 4 && reqbuf->ascq != 4) {
1202                                 /* The drive is in the process of loading
1203                                    a disk.  Retry, but wait a little to give
1204                                    the drive time to complete the load. */
1205                                 ssleep(2);
1206                         } else {
1207                                 /* Otherwise, don't retry. */
1208                                 retries = 0;
1209                         }
1210                         --retries;
1211                 }
1212
1213                 /* End of retry loop. */
1214         } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
1215
1216         /* Return an error if the command failed. */
1217         return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
1218 }
1219
1220 /*
1221  * Write handling
1222  */
1223 static int cdrom_write_check_ireason(ide_drive_t *drive, int len, int ireason)
1224 {
1225         /* Two notes about IDE interrupt reason here - 0 means that
1226          * the drive wants to receive data from us, 2 means that
1227          * the drive is expecting to transfer data to us.
1228          */
1229         if (ireason == 0)
1230                 return 0;
1231         else if (ireason == 2) {
1232                 ide_hwif_t *hwif = drive->hwif;
1233
1234                 /* Whoops... The drive wants to send data. */
1235                 printk(KERN_ERR "%s: %s: wrong transfer direction!\n",
1236                                 drive->name, __FUNCTION__);
1237
1238                 ide_cd_pad_transfer(drive, hwif->atapi_input_bytes, len);
1239         } else {
1240                 /* Drive wants a command packet, or invalid ireason... */
1241                 printk(KERN_ERR "%s: %s: bad interrupt reason 0x%02x\n",
1242                                 drive->name, __FUNCTION__, ireason);
1243         }
1244
1245         cdrom_end_request(drive, 0);
1246         return 1;
1247 }
1248
1249 /*
1250  * Called from blk_end_request_callback() after the data of the request
1251  * is completed and before the request is completed.
1252  * By returning value '1', blk_end_request_callback() returns immediately
1253  * without completing the request.
1254  */
1255 static int cdrom_newpc_intr_dummy_cb(struct request *rq)
1256 {
1257         return 1;
1258 }
1259
1260 /*
1261  * best way to deal with dma that is not sector aligned right now... note
1262  * that in this path we are not using ->data or ->buffer at all. this irs
1263  * can replace cdrom_pc_intr, cdrom_read_intr, and cdrom_write_intr in the
1264  * future.
1265  */
1266 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
1267 {
1268         struct cdrom_info *info = drive->driver_data;
1269         struct request *rq = HWGROUP(drive)->rq;
1270         int dma_error, dma, stat, ireason, len, thislen;
1271         u8 lowcyl, highcyl;
1272         xfer_func_t *xferfunc;
1273         unsigned long flags;
1274
1275         /* Check for errors. */
1276         dma_error = 0;
1277         dma = info->dma;
1278         if (dma) {
1279                 info->dma = 0;
1280                 dma_error = HWIF(drive)->ide_dma_end(drive);
1281                 if (dma_error) {
1282                         printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1283                                         rq_data_dir(rq) ? "write" : "read");
1284                         ide_dma_off(drive);
1285                 }
1286         }
1287
1288         if (cdrom_decode_status(drive, 0, &stat))
1289                 return ide_stopped;
1290
1291         /*
1292          * using dma, transfer is complete now
1293          */
1294         if (dma) {
1295                 if (dma_error)
1296                         return ide_error(drive, "dma error", stat);
1297
1298                 spin_lock_irqsave(&ide_lock, flags);
1299                 if (__blk_end_request(rq, 0, rq->data_len))
1300                         BUG();
1301                 HWGROUP(drive)->rq = NULL;
1302                 spin_unlock_irqrestore(&ide_lock, flags);
1303
1304                 return ide_stopped;
1305         }
1306
1307         /*
1308          * ok we fall to pio :/
1309          */
1310         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1311         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1312         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1313
1314         len = lowcyl + (256 * highcyl);
1315         thislen = rq->data_len;
1316         if (thislen > len)
1317                 thislen = len;
1318
1319         /*
1320          * If DRQ is clear, the command has completed.
1321          */
1322         if ((stat & DRQ_STAT) == 0) {
1323                 spin_lock_irqsave(&ide_lock, flags);
1324                 if (__blk_end_request(rq, 0, rq->data_len))
1325                         BUG();
1326                 HWGROUP(drive)->rq = NULL;
1327                 spin_unlock_irqrestore(&ide_lock, flags);
1328
1329                 return ide_stopped;
1330         }
1331
1332         /*
1333          * check which way to transfer data
1334          */
1335         if (rq_data_dir(rq) == WRITE) {
1336                 /*
1337                  * write to drive
1338                  */
1339                 if (cdrom_write_check_ireason(drive, len, ireason))
1340                         return ide_stopped;
1341
1342                 xferfunc = HWIF(drive)->atapi_output_bytes;
1343         } else  {
1344                 /*
1345                  * read from drive
1346                  */
1347                 if (cdrom_read_check_ireason(drive, len, ireason))
1348                         return ide_stopped;
1349
1350                 xferfunc = HWIF(drive)->atapi_input_bytes;
1351         }
1352
1353         /*
1354          * transfer data
1355          */
1356         while (thislen > 0) {
1357                 int blen = blen = rq->data_len;
1358                 char *ptr = rq->data;
1359
1360                 /*
1361                  * bio backed?
1362                  */
1363                 if (rq->bio) {
1364                         ptr = bio_data(rq->bio);
1365                         blen = bio_iovec(rq->bio)->bv_len;
1366                 }
1367
1368                 if (!ptr) {
1369                         printk(KERN_ERR "%s: confused, missing data\n", drive->name);
1370                         break;
1371                 }
1372
1373                 if (blen > thislen)
1374                         blen = thislen;
1375
1376                 xferfunc(drive, ptr, blen);
1377
1378                 thislen -= blen;
1379                 len -= blen;
1380                 rq->data_len -= blen;
1381
1382                 if (rq->bio)
1383                         /*
1384                          * The request can't be completed until DRQ is cleared.
1385                          * So complete the data, but don't complete the request
1386                          * using the dummy function for the callback feature
1387                          * of blk_end_request_callback().
1388                          */
1389                         blk_end_request_callback(rq, 0, blen,
1390                                                  cdrom_newpc_intr_dummy_cb);
1391                 else
1392                         rq->data += blen;
1393         }
1394
1395         /*
1396          * pad, if necessary
1397          */
1398         if (len > 0)
1399                 ide_cd_pad_transfer(drive, xferfunc, len);
1400
1401         BUG_ON(HWGROUP(drive)->handler != NULL);
1402
1403         ide_set_handler(drive, cdrom_newpc_intr, rq->timeout, NULL);
1404         return ide_started;
1405 }
1406
1407 static ide_startstop_t cdrom_write_intr(ide_drive_t *drive)
1408 {
1409         int stat, ireason, len, sectors_to_transfer, uptodate;
1410         struct cdrom_info *info = drive->driver_data;
1411         int dma_error = 0, dma = info->dma;
1412         u8 lowcyl = 0, highcyl = 0;
1413
1414         struct request *rq = HWGROUP(drive)->rq;
1415
1416         /* Check for errors. */
1417         if (dma) {
1418                 info->dma = 0;
1419                 dma_error = HWIF(drive)->ide_dma_end(drive);
1420                 if (dma_error) {
1421                         printk(KERN_ERR "%s: DMA write error\n", drive->name);
1422                         ide_dma_off(drive);
1423                 }
1424         }
1425
1426         if (cdrom_decode_status(drive, 0, &stat))
1427                 return ide_stopped;
1428
1429         /*
1430          * using dma, transfer is complete now
1431          */
1432         if (dma) {
1433                 if (dma_error)
1434                         return ide_error(drive, "dma error", stat);
1435
1436                 ide_end_request(drive, 1, rq->nr_sectors);
1437                 return ide_stopped;
1438         }
1439
1440         /* Read the interrupt reason and the transfer length. */
1441         ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1442         lowcyl  = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1443         highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1444
1445         len = lowcyl + (256 * highcyl);
1446
1447         /* If DRQ is clear, the command has completed. */
1448         if ((stat & DRQ_STAT) == 0) {
1449                 /* If we're not done writing, complain.
1450                  * Otherwise, complete the command normally.
1451                  */
1452                 uptodate = 1;
1453                 if (rq->current_nr_sectors > 0) {
1454                         printk(KERN_ERR "%s: %s: data underrun (%d blocks)\n",
1455                                         drive->name, __FUNCTION__,
1456                                         rq->current_nr_sectors);
1457                         uptodate = 0;
1458                 }
1459                 cdrom_end_request(drive, uptodate);
1460                 return ide_stopped;
1461         }
1462
1463         /* Check that the drive is expecting to do the same thing we are. */
1464         if (cdrom_write_check_ireason(drive, len, ireason))
1465                 return ide_stopped;
1466
1467         sectors_to_transfer = len / SECTOR_SIZE;
1468
1469         /*
1470          * now loop and write out the data
1471          */
1472         while (sectors_to_transfer > 0) {
1473                 int this_transfer;
1474
1475                 if (!rq->current_nr_sectors) {
1476                         printk(KERN_ERR "%s: %s: confused, missing data\n",
1477                                         drive->name, __FUNCTION__);
1478                         break;
1479                 }
1480
1481                 /*
1482                  * Figure out how many sectors we can transfer
1483                  */
1484                 this_transfer = min_t(int, sectors_to_transfer, rq->current_nr_sectors);
1485
1486                 while (this_transfer > 0) {
1487                         HWIF(drive)->atapi_output_bytes(drive, rq->buffer, SECTOR_SIZE);
1488                         rq->buffer += SECTOR_SIZE;
1489                         --rq->nr_sectors;
1490                         --rq->current_nr_sectors;
1491                         ++rq->sector;
1492                         --this_transfer;
1493                         --sectors_to_transfer;
1494                 }
1495
1496                 /*
1497                  * current buffer complete, move on
1498                  */
1499                 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1500                         cdrom_end_request(drive, 1);
1501         }
1502
1503         /* re-arm handler */
1504         ide_set_handler(drive, &cdrom_write_intr, ATAPI_WAIT_PC, NULL);
1505         return ide_started;
1506 }
1507
1508 static ide_startstop_t cdrom_start_write_cont(ide_drive_t *drive)
1509 {
1510         struct request *rq = HWGROUP(drive)->rq;
1511
1512 #if 0   /* the immediate bit */
1513         rq->cmd[1] = 1 << 3;
1514 #endif
1515         rq->timeout = ATAPI_WAIT_PC;
1516
1517         return cdrom_transfer_packet_command(drive, rq, cdrom_write_intr);
1518 }
1519
1520 static ide_startstop_t cdrom_start_write(ide_drive_t *drive, struct request *rq)
1521 {
1522         struct cdrom_info *info = drive->driver_data;
1523         struct gendisk *g = info->disk;
1524         unsigned short sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
1525
1526         /*
1527          * writes *must* be hardware frame aligned
1528          */
1529         if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
1530             (rq->sector & (sectors_per_frame - 1))) {
1531                 cdrom_end_request(drive, 0);
1532                 return ide_stopped;
1533         }
1534
1535         /*
1536          * disk has become write protected
1537          */
1538         if (g->policy) {
1539                 cdrom_end_request(drive, 0);
1540                 return ide_stopped;
1541         }
1542
1543         info->nsectors_buffered = 0;
1544
1545         /* use dma, if possible. we don't need to check more, since we
1546          * know that the transfer is always (at least!) frame aligned */
1547         info->dma = drive->using_dma ? 1 : 0;
1548
1549         info->devinfo.media_written = 1;
1550
1551         /* Start sending the write request to the drive. */
1552         return cdrom_start_packet_command(drive, 32768, cdrom_start_write_cont);
1553 }
1554
1555 static ide_startstop_t cdrom_do_newpc_cont(ide_drive_t *drive)
1556 {
1557         struct request *rq = HWGROUP(drive)->rq;
1558
1559         if (!rq->timeout)
1560                 rq->timeout = ATAPI_WAIT_PC;
1561
1562         return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
1563 }
1564
1565 static ide_startstop_t cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
1566 {
1567         struct cdrom_info *info = drive->driver_data;
1568
1569         rq->cmd_flags |= REQ_QUIET;
1570
1571         info->dma = 0;
1572
1573         /*
1574          * sg request
1575          */
1576         if (rq->bio) {
1577                 int mask = drive->queue->dma_alignment;
1578                 unsigned long addr = (unsigned long) page_address(bio_page(rq->bio));
1579
1580                 info->dma = drive->using_dma;
1581
1582                 /*
1583                  * check if dma is safe
1584                  *
1585                  * NOTE! The "len" and "addr" checks should possibly have
1586                  * separate masks.
1587                  */
1588                 if ((rq->data_len & 15) || (addr & mask))
1589                         info->dma = 0;
1590         }
1591
1592         /* Start sending the command to the drive. */
1593         return cdrom_start_packet_command(drive, rq->data_len, cdrom_do_newpc_cont);
1594 }
1595
1596 /****************************************************************************
1597  * cdrom driver request routine.
1598  */
1599 static ide_startstop_t
1600 ide_do_rw_cdrom (ide_drive_t *drive, struct request *rq, sector_t block)
1601 {
1602         ide_startstop_t action;
1603         struct cdrom_info *info = drive->driver_data;
1604
1605         if (blk_fs_request(rq)) {
1606                 if (info->cd_flags & IDE_CD_FLAG_SEEKING) {
1607                         unsigned long elapsed = jiffies - info->start_seek;
1608                         int stat = HWIF(drive)->INB(IDE_STATUS_REG);
1609
1610                         if ((stat & SEEK_STAT) != SEEK_STAT) {
1611                                 if (elapsed < IDECD_SEEK_TIMEOUT) {
1612                                         ide_stall_queue(drive, IDECD_SEEK_TIMER);
1613                                         return ide_stopped;
1614                                 }
1615                                 printk (KERN_ERR "%s: DSC timeout\n", drive->name);
1616                         }
1617                         info->cd_flags &= ~IDE_CD_FLAG_SEEKING;
1618                 }
1619                 if ((rq_data_dir(rq) == READ) && IDE_LARGE_SEEK(info->last_block, block, IDECD_SEEK_THRESHOLD) && drive->dsc_overlap) {
1620                         action = cdrom_start_seek(drive, block);
1621                 } else {
1622                         if (rq_data_dir(rq) == READ)
1623                                 action = cdrom_start_read(drive, block);
1624                         else
1625                                 action = cdrom_start_write(drive, rq);
1626                 }
1627                 info->last_block = block;
1628                 return action;
1629         } else if (rq->cmd_type == REQ_TYPE_SENSE ||
1630                    rq->cmd_type == REQ_TYPE_ATA_PC) {
1631                 return cdrom_do_packet_command(drive);
1632         } else if (blk_pc_request(rq)) {
1633                 return cdrom_do_block_pc(drive, rq);
1634         } else if (blk_special_request(rq)) {
1635                 /*
1636                  * right now this can only be a reset...
1637                  */
1638                 cdrom_end_request(drive, 1);
1639                 return ide_stopped;
1640         }
1641
1642         blk_dump_rq_flags(rq, "ide-cd bad flags");
1643         cdrom_end_request(drive, 0);
1644         return ide_stopped;
1645 }
1646
1647
1648
1649 /****************************************************************************
1650  * Ioctl handling.
1651  *
1652  * Routines which queue packet commands take as a final argument a pointer
1653  * to a request_sense struct.  If execution of the command results
1654  * in an error with a CHECK CONDITION status, this structure will be filled
1655  * with the results of the subsequent request sense command.  The pointer
1656  * can also be NULL, in which case no sense information is returned.
1657  */
1658
1659 static
1660 void msf_from_bcd (struct atapi_msf *msf)
1661 {
1662         msf->minute = BCD2BIN(msf->minute);
1663         msf->second = BCD2BIN(msf->second);
1664         msf->frame  = BCD2BIN(msf->frame);
1665 }
1666
1667 static inline
1668 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
1669 {
1670         lba += CD_MSF_OFFSET;
1671         lba &= 0xffffff;  /* negative lbas use only 24 bits */
1672         *m = lba / (CD_SECS * CD_FRAMES);
1673         lba %= (CD_SECS * CD_FRAMES);
1674         *s = lba / CD_FRAMES;
1675         *f = lba % CD_FRAMES;
1676 }
1677
1678
1679 static inline
1680 int msf_to_lba (byte m, byte s, byte f)
1681 {
1682         return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_MSF_OFFSET;
1683 }
1684
1685 static int cdrom_check_status(ide_drive_t *drive, struct request_sense *sense)
1686 {
1687         struct request req;
1688         struct cdrom_info *info = drive->driver_data;
1689         struct cdrom_device_info *cdi = &info->devinfo;
1690
1691         cdrom_prepare_request(drive, &req);
1692
1693         req.sense = sense;
1694         req.cmd[0] = GPCMD_TEST_UNIT_READY;
1695         req.cmd_flags |= REQ_QUIET;
1696
1697         /*
1698          * Sanyo 3 CD changer uses byte 7 of TEST_UNIT_READY to
1699          * switch CDs instead of supporting the LOAD_UNLOAD opcode.
1700          */
1701         req.cmd[7] = cdi->sanyo_slot % 3;
1702
1703         return cdrom_queue_packet_command(drive, &req);
1704 }
1705
1706
1707 /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
1708 static int
1709 cdrom_lockdoor(ide_drive_t *drive, int lockflag, struct request_sense *sense)
1710 {
1711         struct cdrom_info *cd = drive->driver_data;
1712         struct request_sense my_sense;
1713         struct request req;
1714         int stat;
1715
1716         if (sense == NULL)
1717                 sense = &my_sense;
1718
1719         /* If the drive cannot lock the door, just pretend. */
1720         if (cd->cd_flags & IDE_CD_FLAG_NO_DOORLOCK) {
1721                 stat = 0;
1722         } else {
1723                 cdrom_prepare_request(drive, &req);
1724                 req.sense = sense;
1725                 req.cmd[0] = GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL;
1726                 req.cmd[4] = lockflag ? 1 : 0;
1727                 stat = cdrom_queue_packet_command(drive, &req);
1728         }
1729
1730         /* If we got an illegal field error, the drive
1731            probably cannot lock the door. */
1732         if (stat != 0 &&
1733             sense->sense_key == ILLEGAL_REQUEST &&
1734             (sense->asc == 0x24 || sense->asc == 0x20)) {
1735                 printk (KERN_ERR "%s: door locking not supported\n",
1736                         drive->name);
1737                 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
1738                 stat = 0;
1739         }
1740         
1741         /* no medium, that's alright. */
1742         if (stat != 0 && sense->sense_key == NOT_READY && sense->asc == 0x3a)
1743                 stat = 0;
1744
1745         if (stat == 0) {
1746                 if (lockflag)
1747                         cd->cd_flags |= IDE_CD_FLAG_DOOR_LOCKED;
1748                 else
1749                         cd->cd_flags &= ~IDE_CD_FLAG_DOOR_LOCKED;
1750         }
1751
1752         return stat;
1753 }
1754
1755
1756 /* Eject the disk if EJECTFLAG is 0.
1757    If EJECTFLAG is 1, try to reload the disk. */
1758 static int cdrom_eject(ide_drive_t *drive, int ejectflag,
1759                        struct request_sense *sense)
1760 {
1761         struct cdrom_info *cd = drive->driver_data;
1762         struct cdrom_device_info *cdi = &cd->devinfo;
1763         struct request req;
1764         char loej = 0x02;
1765
1766         if ((cd->cd_flags & IDE_CD_FLAG_NO_EJECT) && !ejectflag)
1767                 return -EDRIVE_CANT_DO_THIS;
1768
1769         /* reload fails on some drives, if the tray is locked */
1770         if ((cd->cd_flags & IDE_CD_FLAG_DOOR_LOCKED) && ejectflag)
1771                 return 0;
1772
1773         cdrom_prepare_request(drive, &req);
1774
1775         /* only tell drive to close tray if open, if it can do that */
1776         if (ejectflag && (cdi->mask & CDC_CLOSE_TRAY))
1777                 loej = 0;
1778
1779         req.sense = sense;
1780         req.cmd[0] = GPCMD_START_STOP_UNIT;
1781         req.cmd[4] = loej | (ejectflag != 0);
1782         return cdrom_queue_packet_command(drive, &req);
1783 }
1784
1785 static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
1786                                unsigned long *sectors_per_frame,
1787                                struct request_sense *sense)
1788 {
1789         struct {
1790                 __u32 lba;
1791                 __u32 blocklen;
1792         } capbuf;
1793
1794         int stat;
1795         struct request req;
1796
1797         cdrom_prepare_request(drive, &req);
1798
1799         req.sense = sense;
1800         req.cmd[0] = GPCMD_READ_CDVD_CAPACITY;
1801         req.data = (char *)&capbuf;
1802         req.data_len = sizeof(capbuf);
1803         req.cmd_flags |= REQ_QUIET;
1804
1805         stat = cdrom_queue_packet_command(drive, &req);
1806         if (stat == 0) {
1807                 *capacity = 1 + be32_to_cpu(capbuf.lba);
1808                 *sectors_per_frame =
1809                         be32_to_cpu(capbuf.blocklen) >> SECTOR_BITS;
1810         }
1811
1812         return stat;
1813 }
1814
1815 static int cdrom_read_tocentry(ide_drive_t *drive, int trackno, int msf_flag,
1816                                 int format, char *buf, int buflen,
1817                                 struct request_sense *sense)
1818 {
1819         struct request req;
1820
1821         cdrom_prepare_request(drive, &req);
1822
1823         req.sense = sense;
1824         req.data =  buf;
1825         req.data_len = buflen;
1826         req.cmd_flags |= REQ_QUIET;
1827         req.cmd[0] = GPCMD_READ_TOC_PMA_ATIP;
1828         req.cmd[6] = trackno;
1829         req.cmd[7] = (buflen >> 8);
1830         req.cmd[8] = (buflen & 0xff);
1831         req.cmd[9] = (format << 6);
1832
1833         if (msf_flag)
1834                 req.cmd[1] = 2;
1835
1836         return cdrom_queue_packet_command(drive, &req);
1837 }
1838
1839
1840 /* Try to read the entire TOC for the disk into our internal buffer. */
1841 static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
1842 {
1843         int stat, ntracks, i;
1844         struct cdrom_info *info = drive->driver_data;
1845         struct cdrom_device_info *cdi = &info->devinfo;
1846         struct atapi_toc *toc = info->toc;
1847         struct {
1848                 struct atapi_toc_header hdr;
1849                 struct atapi_toc_entry  ent;
1850         } ms_tmp;
1851         long last_written;
1852         unsigned long sectors_per_frame = SECTORS_PER_FRAME;
1853
1854         if (toc == NULL) {
1855                 /* Try to allocate space. */
1856                 toc = kmalloc(sizeof(struct atapi_toc), GFP_KERNEL);
1857                 if (toc == NULL) {
1858                         printk (KERN_ERR "%s: No cdrom TOC buffer!\n", drive->name);
1859                         return -ENOMEM;
1860                 }
1861                 info->toc = toc;
1862         }
1863
1864         /* Check to see if the existing data is still valid.
1865            If it is, just return. */
1866         (void) cdrom_check_status(drive, sense);
1867
1868         if (info->cd_flags & IDE_CD_FLAG_TOC_VALID)
1869                 return 0;
1870
1871         /* Try to get the total cdrom capacity and sector size. */
1872         stat = cdrom_read_capacity(drive, &toc->capacity, &sectors_per_frame,
1873                                    sense);
1874         if (stat)
1875                 toc->capacity = 0x1fffff;
1876
1877         set_capacity(info->disk, toc->capacity * sectors_per_frame);
1878         /* Save a private copy of te TOC capacity for error handling */
1879         drive->probed_capacity = toc->capacity * sectors_per_frame;
1880
1881         blk_queue_hardsect_size(drive->queue,
1882                                 sectors_per_frame << SECTOR_BITS);
1883
1884         /* First read just the header, so we know how long the TOC is. */
1885         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
1886                                     sizeof(struct atapi_toc_header), sense);
1887         if (stat)
1888                 return stat;
1889
1890         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1891                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1892                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1893         }
1894
1895         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1896         if (ntracks <= 0)
1897                 return -EIO;
1898         if (ntracks > MAX_TRACKS)
1899                 ntracks = MAX_TRACKS;
1900
1901         /* Now read the whole schmeer. */
1902         stat = cdrom_read_tocentry(drive, toc->hdr.first_track, 1, 0,
1903                                   (char *)&toc->hdr,
1904                                    sizeof(struct atapi_toc_header) +
1905                                    (ntracks + 1) *
1906                                    sizeof(struct atapi_toc_entry), sense);
1907
1908         if (stat && toc->hdr.first_track > 1) {
1909                 /* Cds with CDI tracks only don't have any TOC entries,
1910                    despite of this the returned values are
1911                    first_track == last_track = number of CDI tracks + 1,
1912                    so that this case is indistinguishable from the same
1913                    layout plus an additional audio track.
1914                    If we get an error for the regular case, we assume
1915                    a CDI without additional audio tracks. In this case
1916                    the readable TOC is empty (CDI tracks are not included)
1917                    and only holds the Leadout entry. Heiko EiƟfeldt */
1918                 ntracks = 0;
1919                 stat = cdrom_read_tocentry(drive, CDROM_LEADOUT, 1, 0,
1920                                            (char *)&toc->hdr,
1921                                            sizeof(struct atapi_toc_header) +
1922                                            (ntracks + 1) *
1923                                            sizeof(struct atapi_toc_entry),
1924                                            sense);
1925                 if (stat)
1926                         return stat;
1927
1928                 if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1929                         toc->hdr.first_track = (u8)BIN2BCD(CDROM_LEADOUT);
1930                         toc->hdr.last_track = (u8)BIN2BCD(CDROM_LEADOUT);
1931                 } else {
1932                         toc->hdr.first_track = CDROM_LEADOUT;
1933                         toc->hdr.last_track = CDROM_LEADOUT;
1934                 }
1935         }
1936
1937         if (stat)
1938                 return stat;
1939
1940         toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
1941
1942         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD) {
1943                 toc->hdr.first_track = BCD2BIN(toc->hdr.first_track);
1944                 toc->hdr.last_track  = BCD2BIN(toc->hdr.last_track);
1945         }
1946
1947         for (i = 0; i <= ntracks; i++) {
1948                 if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1949                         if (info->cd_flags & IDE_CD_FLAG_TOCTRACKS_AS_BCD)
1950                                 toc->ent[i].track = BCD2BIN(toc->ent[i].track);
1951                         msf_from_bcd(&toc->ent[i].addr.msf);
1952                 }
1953                 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.minute,
1954                                                    toc->ent[i].addr.msf.second,
1955                                                    toc->ent[i].addr.msf.frame);
1956         }
1957
1958         /* Read the multisession information. */
1959         if (toc->hdr.first_track != CDROM_LEADOUT) {
1960                 /* Read the multisession information. */
1961                 stat = cdrom_read_tocentry(drive, 0, 0, 1, (char *)&ms_tmp,
1962                                            sizeof(ms_tmp), sense);
1963                 if (stat)
1964                         return stat;
1965
1966                 toc->last_session_lba = be32_to_cpu(ms_tmp.ent.addr.lba);
1967         } else {
1968                 ms_tmp.hdr.first_track = ms_tmp.hdr.last_track = CDROM_LEADOUT;
1969                 toc->last_session_lba = msf_to_lba(0, 2, 0); /* 0m 2s 0f */
1970         }
1971
1972         if (info->cd_flags & IDE_CD_FLAG_TOCADDR_AS_BCD) {
1973                 /* Re-read multisession information using MSF format */
1974                 stat = cdrom_read_tocentry(drive, 0, 1, 1, (char *)&ms_tmp,
1975                                            sizeof(ms_tmp), sense);
1976                 if (stat)
1977                         return stat;
1978
1979                 msf_from_bcd (&ms_tmp.ent.addr.msf);
1980                 toc->last_session_lba = msf_to_lba(ms_tmp.ent.addr.msf.minute,
1981                                                    ms_tmp.ent.addr.msf.second,
1982                                                    ms_tmp.ent.addr.msf.frame);
1983         }
1984
1985         toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
1986
1987         /* Now try to get the total cdrom capacity. */
1988         stat = cdrom_get_last_written(cdi, &last_written);
1989         if (!stat && (last_written > toc->capacity)) {
1990                 toc->capacity = last_written;
1991                 set_capacity(info->disk, toc->capacity * sectors_per_frame);
1992                 drive->probed_capacity = toc->capacity * sectors_per_frame;
1993         }
1994
1995         /* Remember that we've read this stuff. */
1996         info->cd_flags |= IDE_CD_FLAG_TOC_VALID;
1997
1998         return 0;
1999 }
2000
2001 static int ide_cd_read_tochdr(ide_drive_t *drive, void *arg)
2002 {
2003         struct cdrom_info *cd = drive->driver_data;
2004         struct cdrom_tochdr *tochdr = arg;
2005         struct atapi_toc *toc;
2006         int stat;
2007
2008         /* Make sure our saved TOC is valid. */
2009         stat = cdrom_read_toc(drive, NULL);
2010         if (stat)
2011                 return stat;
2012
2013         toc = cd->toc;
2014         tochdr->cdth_trk0 = toc->hdr.first_track;
2015         tochdr->cdth_trk1 = toc->hdr.last_track;
2016
2017         return 0;
2018 }
2019
2020 static int cdrom_get_toc_entry(ide_drive_t *drive, int track,
2021                                 struct atapi_toc_entry **ent)
2022 {
2023         struct cdrom_info *info = drive->driver_data;
2024         struct atapi_toc *toc = info->toc;
2025         int ntracks;
2026
2027         /*
2028          * don't serve cached data, if the toc isn't valid
2029          */
2030         if ((info->cd_flags & IDE_CD_FLAG_TOC_VALID) == 0)
2031                 return -EINVAL;
2032
2033         /* Check validity of requested track number. */
2034         ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2035         if (toc->hdr.first_track == CDROM_LEADOUT) ntracks = 0;
2036         if (track == CDROM_LEADOUT)
2037                 *ent = &toc->ent[ntracks];
2038         else if (track < toc->hdr.first_track ||
2039                  track > toc->hdr.last_track)
2040                 return -EINVAL;
2041         else
2042                 *ent = &toc->ent[track - toc->hdr.first_track];
2043
2044         return 0;
2045 }
2046
2047 static int ide_cd_read_tocentry(ide_drive_t *drive, void *arg)
2048 {
2049         struct cdrom_tocentry *tocentry = arg;
2050         struct atapi_toc_entry *toce;
2051         int stat;
2052
2053         stat = cdrom_get_toc_entry(drive, tocentry->cdte_track, &toce);
2054         if (stat)
2055                 return stat;
2056
2057         tocentry->cdte_ctrl = toce->control;
2058         tocentry->cdte_adr  = toce->adr;
2059         if (tocentry->cdte_format == CDROM_MSF) {
2060                 lba_to_msf(toce->addr.lba,
2061                            &tocentry->cdte_addr.msf.minute,
2062                            &tocentry->cdte_addr.msf.second,
2063                            &tocentry->cdte_addr.msf.frame);
2064         } else
2065                 tocentry->cdte_addr.lba = toce->addr.lba;
2066
2067         return 0;
2068 }
2069
2070 static int ide_cd_fake_play_trkind(ide_drive_t *drive, void *arg)
2071 {
2072         struct cdrom_ti *ti = arg;
2073         struct atapi_toc_entry *first_toc, *last_toc;
2074         unsigned long lba_start, lba_end;
2075         int stat;
2076         struct request rq;
2077         struct request_sense sense;
2078
2079         stat = cdrom_get_toc_entry(drive, ti->cdti_trk0, &first_toc);
2080         if (stat)
2081                 return stat;
2082
2083         stat = cdrom_get_toc_entry(drive, ti->cdti_trk1, &last_toc);
2084         if (stat)
2085                 return stat;
2086
2087         if (ti->cdti_trk1 != CDROM_LEADOUT)
2088                 ++last_toc;
2089         lba_start = first_toc->addr.lba;
2090         lba_end   = last_toc->addr.lba;
2091
2092         if (lba_end <= lba_start)
2093                 return -EINVAL;
2094
2095         cdrom_prepare_request(drive, &rq);
2096
2097         rq.sense = &sense;
2098         rq.cmd[0] = GPCMD_PLAY_AUDIO_MSF;
2099         lba_to_msf(lba_start,   &rq.cmd[3], &rq.cmd[4], &rq.cmd[5]);
2100         lba_to_msf(lba_end - 1, &rq.cmd[6], &rq.cmd[7], &rq.cmd[8]);
2101
2102         return cdrom_queue_packet_command(drive, &rq);
2103 }
2104
2105 /* the generic packet interface to cdrom.c */
2106 static int ide_cdrom_packet(struct cdrom_device_info *cdi,
2107                             struct packet_command *cgc)
2108 {
2109         struct request req;
2110         ide_drive_t *drive = cdi->handle;
2111
2112         if (cgc->timeout <= 0)
2113                 cgc->timeout = ATAPI_WAIT_PC;
2114
2115         /* here we queue the commands from the uniform CD-ROM
2116            layer. the packet must be complete, as we do not
2117            touch it at all. */
2118         cdrom_prepare_request(drive, &req);
2119         memcpy(req.cmd, cgc->cmd, CDROM_PACKET_SIZE);
2120         if (cgc->sense)
2121                 memset(cgc->sense, 0, sizeof(struct request_sense));
2122         req.data = cgc->buffer;
2123         req.data_len = cgc->buflen;
2124         req.timeout = cgc->timeout;
2125
2126         if (cgc->quiet)
2127                 req.cmd_flags |= REQ_QUIET;
2128
2129         req.sense = cgc->sense;
2130         cgc->stat = cdrom_queue_packet_command(drive, &req);
2131         if (!cgc->stat)
2132                 cgc->buflen -= req.data_len;
2133         return cgc->stat;
2134 }
2135
2136 static int ide_cdrom_audio_ioctl(struct cdrom_device_info *cdi,
2137                                  unsigned int cmd, void *arg)
2138 {
2139         ide_drive_t *drive = cdi->handle;
2140
2141         switch (cmd) {
2142         /*
2143          * emulate PLAY_AUDIO_TI command with PLAY_AUDIO_10, since
2144          * atapi doesn't support it
2145          */
2146         case CDROMPLAYTRKIND:
2147                 return ide_cd_fake_play_trkind(drive, arg);
2148         case CDROMREADTOCHDR:
2149                 return ide_cd_read_tochdr(drive, arg);
2150         case CDROMREADTOCENTRY:
2151                 return ide_cd_read_tocentry(drive, arg);
2152         default:
2153                 return -EINVAL;
2154         }
2155 }
2156
2157 static
2158 int ide_cdrom_reset (struct cdrom_device_info *cdi)
2159 {
2160         ide_drive_t *drive = cdi->handle;
2161         struct cdrom_info *cd = drive->driver_data;
2162         struct request_sense sense;
2163         struct request req;
2164         int ret;
2165
2166         cdrom_prepare_request(drive, &req);
2167         req.cmd_type = REQ_TYPE_SPECIAL;
2168         req.cmd_flags = REQ_QUIET;
2169         ret = ide_do_drive_cmd(drive, &req, ide_wait);
2170
2171         /*
2172          * A reset will unlock the door. If it was previously locked,
2173          * lock it again.
2174          */
2175         if (cd->cd_flags & IDE_CD_FLAG_DOOR_LOCKED)
2176                 (void) cdrom_lockdoor(drive, 1, &sense);
2177
2178         return ret;
2179 }
2180
2181
2182 static
2183 int ide_cdrom_tray_move (struct cdrom_device_info *cdi, int position)
2184 {
2185         ide_drive_t *drive = cdi->handle;
2186         struct request_sense sense;
2187
2188         if (position) {
2189                 int stat = cdrom_lockdoor(drive, 0, &sense);
2190                 if (stat)
2191                         return stat;
2192         }
2193
2194         return cdrom_eject(drive, !position, &sense);
2195 }
2196
2197 static
2198 int ide_cdrom_lock_door (struct cdrom_device_info *cdi, int lock)
2199 {
2200         ide_drive_t *drive = cdi->handle;
2201         return cdrom_lockdoor(drive, lock, NULL);
2202 }
2203
2204 static int ide_cdrom_get_capabilities(ide_drive_t *drive, u8 *buf)
2205 {
2206         struct cdrom_info *info = drive->driver_data;
2207         struct cdrom_device_info *cdi = &info->devinfo;
2208         struct packet_command cgc;
2209         int stat, attempts = 3, size = ATAPI_CAPABILITIES_PAGE_SIZE;
2210
2211         if ((info->cd_flags & IDE_CD_FLAG_FULL_CAPS_PAGE) == 0)
2212                 size -= ATAPI_CAPABILITIES_PAGE_PAD_SIZE;
2213
2214         init_cdrom_command(&cgc, buf, size, CGC_DATA_UNKNOWN);
2215         do { /* we seem to get stat=0x01,err=0x00 the first time (??) */
2216                 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CAPABILITIES_PAGE, 0);
2217                 if (!stat)
2218                         break;
2219         } while (--attempts);
2220         return stat;
2221 }
2222
2223 static void ide_cdrom_update_speed(ide_drive_t *drive, u8 *buf)
2224 {
2225         struct cdrom_info *cd = drive->driver_data;
2226         u16 curspeed, maxspeed;
2227
2228         curspeed = *(u16 *)&buf[8 + 14];
2229         maxspeed = *(u16 *)&buf[8 +  8];
2230
2231         if (cd->cd_flags & IDE_CD_FLAG_LE_SPEED_FIELDS) {
2232                 curspeed = le16_to_cpu(curspeed);
2233                 maxspeed = le16_to_cpu(maxspeed);
2234         } else {
2235                 curspeed = be16_to_cpu(curspeed);
2236                 maxspeed = be16_to_cpu(maxspeed);
2237         }
2238
2239         cd->current_speed = (curspeed + (176/2)) / 176;
2240         cd->max_speed = (maxspeed + (176/2)) / 176;
2241 }
2242
2243 /*
2244  * ATAPI devices are free to select the speed you request or any slower
2245  * rate. :-(  Requesting too fast a speed will _not_ produce an error.
2246  */
2247 static int ide_cdrom_select_speed(struct cdrom_device_info *cdi, int speed)
2248 {
2249         ide_drive_t *drive = cdi->handle;
2250         struct cdrom_info *cd = drive->driver_data;
2251         struct request rq;
2252         struct request_sense sense;
2253         u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
2254         int stat;
2255
2256         cdrom_prepare_request(drive, &rq);
2257
2258         rq.sense = &sense;
2259
2260         if (speed == 0)
2261                 speed = 0xffff; /* set to max */
2262         else
2263                 speed *= 177;   /* Nx to kbytes/s */
2264
2265         rq.cmd[0] = GPCMD_SET_SPEED;
2266         /* Read Drive speed in kbytes/second MSB/LSB */
2267         rq.cmd[2] = (speed >> 8) & 0xff;
2268         rq.cmd[3] = speed & 0xff;
2269         if ((cdi->mask & (CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) !=
2270             (CDC_CD_R | CDC_CD_RW | CDC_DVD_R)) {
2271                 /* Write Drive speed in kbytes/second MSB/LSB */
2272                 rq.cmd[4] = (speed >> 8) & 0xff;
2273                 rq.cmd[5] = speed & 0xff;
2274         }
2275
2276         stat = cdrom_queue_packet_command(drive, &rq);
2277
2278         if (!ide_cdrom_get_capabilities(drive, buf)) {
2279                 ide_cdrom_update_speed(drive, buf);
2280                 cdi->speed = cd->current_speed;
2281         }
2282
2283         return 0;
2284 }
2285
2286 /*
2287  * add logic to try GET_EVENT command first to check for media and tray
2288  * status. this should be supported by newer cd-r/w and all DVD etc
2289  * drives
2290  */
2291 static
2292 int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
2293 {
2294         ide_drive_t *drive = cdi->handle;
2295         struct media_event_desc med;
2296         struct request_sense sense;
2297         int stat;
2298
2299         if (slot_nr != CDSL_CURRENT)
2300                 return -EINVAL;
2301
2302         stat = cdrom_check_status(drive, &sense);
2303         if (!stat || sense.sense_key == UNIT_ATTENTION)
2304                 return CDS_DISC_OK;
2305
2306         if (!cdrom_get_media_event(cdi, &med)) {
2307                 if (med.media_present)
2308                         return CDS_DISC_OK;
2309                 else if (med.door_open)
2310                         return CDS_TRAY_OPEN;
2311                 else
2312                         return CDS_NO_DISC;
2313         }
2314
2315         if (sense.sense_key == NOT_READY && sense.asc == 0x04 && sense.ascq == 0x04)
2316                 return CDS_DISC_OK;
2317
2318         /*
2319          * If not using Mt Fuji extended media tray reports,
2320          * just return TRAY_OPEN since ATAPI doesn't provide
2321          * any other way to detect this...
2322          */
2323         if (sense.sense_key == NOT_READY) {
2324                 if (sense.asc == 0x3a && sense.ascq == 1)
2325                         return CDS_NO_DISC;
2326                 else
2327                         return CDS_TRAY_OPEN;
2328         }
2329         return CDS_DRIVE_NOT_READY;
2330 }
2331
2332 static
2333 int ide_cdrom_get_last_session (struct cdrom_device_info *cdi,
2334                                 struct cdrom_multisession *ms_info)
2335 {
2336         struct atapi_toc *toc;
2337         ide_drive_t *drive = cdi->handle;
2338         struct cdrom_info *info = drive->driver_data;
2339         struct request_sense sense;
2340         int ret;
2341
2342         if ((info->cd_flags & IDE_CD_FLAG_TOC_VALID) == 0 || info->toc == NULL)
2343                 if ((ret = cdrom_read_toc(drive, &sense)))
2344                         return ret;
2345
2346         toc = info->toc;
2347         ms_info->addr.lba = toc->last_session_lba;
2348         ms_info->xa_flag = toc->xa_flag;
2349
2350         return 0;
2351 }
2352
2353 static int ide_cdrom_get_mcn(struct cdrom_device_info *cdi,
2354                              struct cdrom_mcn *mcn_info)
2355 {
2356         ide_drive_t *drive = cdi->handle;
2357         int stat, mcnlen;
2358         struct request rq;
2359         char buf[24];
2360
2361         cdrom_prepare_request(drive, &rq);
2362
2363         rq.data = buf;
2364         rq.data_len = sizeof(buf);
2365
2366         rq.cmd[0] = GPCMD_READ_SUBCHANNEL;
2367         rq.cmd[1] = 2;          /* MSF addressing */
2368         rq.cmd[2] = 0x40;       /* request subQ data */
2369         rq.cmd[3] = 2;          /* format */
2370         rq.cmd[8] = sizeof(buf);
2371
2372         stat = cdrom_queue_packet_command(drive, &rq);
2373         if (stat)
2374                 return stat;
2375
2376         mcnlen = sizeof(mcn_info->medium_catalog_number) - 1;
2377         memcpy(mcn_info->medium_catalog_number, buf + 9, mcnlen);
2378         mcn_info->medium_catalog_number[mcnlen] = '\0';
2379
2380         return 0;
2381 }
2382
2383 /****************************************************************************
2384  * Other driver requests (open, close, check media change).
2385  */
2386
2387 static
2388 int ide_cdrom_check_media_change_real (struct cdrom_device_info *cdi,
2389                                        int slot_nr)
2390 {
2391         ide_drive_t *drive = cdi->handle;
2392         struct cdrom_info *cd = drive->driver_data;
2393         int retval;
2394
2395         if (slot_nr == CDSL_CURRENT) {
2396                 (void) cdrom_check_status(drive, NULL);
2397                 retval = (cd->cd_flags & IDE_CD_FLAG_MEDIA_CHANGED) ? 1 : 0;
2398                 cd->cd_flags &= ~IDE_CD_FLAG_MEDIA_CHANGED;
2399                 return retval;
2400         } else {
2401                 return -EINVAL;
2402         }
2403 }
2404
2405
2406 static
2407 int ide_cdrom_open_real (struct cdrom_device_info *cdi, int purpose)
2408 {
2409         return 0;
2410 }
2411
2412 /*
2413  * Close down the device.  Invalidate all cached blocks.
2414  */
2415
2416 static
2417 void ide_cdrom_release_real (struct cdrom_device_info *cdi)
2418 {
2419         ide_drive_t *drive = cdi->handle;
2420         struct cdrom_info *cd = drive->driver_data;
2421
2422         if (!cdi->use_count)
2423                 cd->cd_flags &= ~IDE_CD_FLAG_TOC_VALID;
2424 }
2425
2426 #define IDE_CD_CAPABILITIES \
2427         (CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_SELECT_SPEED | \
2428          CDC_SELECT_DISC | CDC_MULTI_SESSION | CDC_MCN | CDC_MEDIA_CHANGED | \
2429          CDC_PLAY_AUDIO | CDC_RESET | CDC_DRIVE_STATUS | CDC_CD_R | \
2430          CDC_CD_RW | CDC_DVD | CDC_DVD_R | CDC_DVD_RAM | CDC_GENERIC_PACKET | \
2431          CDC_MO_DRIVE | CDC_MRW | CDC_MRW_W | CDC_RAM)
2432
2433 static struct cdrom_device_ops ide_cdrom_dops = {
2434         .open                   = ide_cdrom_open_real,
2435         .release                = ide_cdrom_release_real,
2436         .drive_status           = ide_cdrom_drive_status,
2437         .media_changed          = ide_cdrom_check_media_change_real,
2438         .tray_move              = ide_cdrom_tray_move,
2439         .lock_door              = ide_cdrom_lock_door,
2440         .select_speed           = ide_cdrom_select_speed,
2441         .get_last_session       = ide_cdrom_get_last_session,
2442         .get_mcn                = ide_cdrom_get_mcn,
2443         .reset                  = ide_cdrom_reset,
2444         .audio_ioctl            = ide_cdrom_audio_ioctl,
2445         .capability             = IDE_CD_CAPABILITIES,
2446         .generic_packet         = ide_cdrom_packet,
2447 };
2448
2449 static int ide_cdrom_register (ide_drive_t *drive, int nslots)
2450 {
2451         struct cdrom_info *info = drive->driver_data;
2452         struct cdrom_device_info *devinfo = &info->devinfo;
2453
2454         devinfo->ops = &ide_cdrom_dops;
2455         devinfo->speed = info->current_speed;
2456         devinfo->capacity = nslots;
2457         devinfo->handle = drive;
2458         strcpy(devinfo->name, drive->name);
2459
2460         if (info->cd_flags & IDE_CD_FLAG_NO_SPEED_SELECT)
2461                 devinfo->mask |= CDC_SELECT_SPEED;
2462
2463         devinfo->disk = info->disk;
2464         return register_cdrom(devinfo);
2465 }
2466
2467 static
2468 int ide_cdrom_probe_capabilities (ide_drive_t *drive)
2469 {
2470         struct cdrom_info *cd = drive->driver_data;
2471         struct cdrom_device_info *cdi = &cd->devinfo;
2472         u8 buf[ATAPI_CAPABILITIES_PAGE_SIZE];
2473         mechtype_t mechtype;
2474         int nslots = 1;
2475
2476         cdi->mask = (CDC_CD_R | CDC_CD_RW | CDC_DVD | CDC_DVD_R |
2477                      CDC_DVD_RAM | CDC_SELECT_DISC | CDC_PLAY_AUDIO |
2478                      CDC_MO_DRIVE | CDC_RAM);
2479
2480         if (drive->media == ide_optical) {
2481                 cdi->mask &= ~(CDC_MO_DRIVE | CDC_RAM);
2482                 printk(KERN_ERR "%s: ATAPI magneto-optical drive\n", drive->name);
2483                 return nslots;
2484         }
2485
2486         if (cd->cd_flags & IDE_CD_FLAG_PRE_ATAPI12) {
2487                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2488                 cdi->mask &= ~CDC_PLAY_AUDIO;
2489                 return nslots;
2490         }
2491
2492         /*
2493          * we have to cheat a little here. the packet will eventually
2494          * be queued with ide_cdrom_packet(), which extracts the
2495          * drive from cdi->handle. Since this device hasn't been
2496          * registered with the Uniform layer yet, it can't do this.
2497          * Same goes for cdi->ops.
2498          */
2499         cdi->handle = drive;
2500         cdi->ops = &ide_cdrom_dops;
2501
2502         if (ide_cdrom_get_capabilities(drive, buf))
2503                 return 0;
2504
2505         if ((buf[8 + 6] & 0x01) == 0)
2506                 cd->cd_flags |= IDE_CD_FLAG_NO_DOORLOCK;
2507         if (buf[8 + 6] & 0x08)
2508                 cd->cd_flags &= ~IDE_CD_FLAG_NO_EJECT;
2509         if (buf[8 + 3] & 0x01)
2510                 cdi->mask &= ~CDC_CD_R;
2511         if (buf[8 + 3] & 0x02)
2512                 cdi->mask &= ~(CDC_CD_RW | CDC_RAM);
2513         if (buf[8 + 2] & 0x38)
2514                 cdi->mask &= ~CDC_DVD;
2515         if (buf[8 + 3] & 0x20)
2516                 cdi->mask &= ~(CDC_DVD_RAM | CDC_RAM);
2517         if (buf[8 + 3] & 0x10)
2518                 cdi->mask &= ~CDC_DVD_R;
2519         if ((buf[8 + 4] & 0x01) || (cd->cd_flags & IDE_CD_FLAG_PLAY_AUDIO_OK))
2520                 cdi->mask &= ~CDC_PLAY_AUDIO;
2521
2522         mechtype = buf[8 + 6] >> 5;
2523         if (mechtype == mechtype_caddy || mechtype == mechtype_popup)
2524                 cdi->mask |= CDC_CLOSE_TRAY;
2525
2526         if (cdi->sanyo_slot > 0) {
2527                 cdi->mask &= ~CDC_SELECT_DISC;
2528                 nslots = 3;
2529         } else if (mechtype == mechtype_individual_changer ||
2530                    mechtype == mechtype_cartridge_changer) {
2531                 nslots = cdrom_number_of_slots(cdi);
2532                 if (nslots > 1)
2533                         cdi->mask &= ~CDC_SELECT_DISC;
2534         }
2535
2536         ide_cdrom_update_speed(drive, buf);
2537
2538         printk(KERN_INFO "%s: ATAPI", drive->name);
2539
2540         /* don't print speed if the drive reported 0 */
2541         if (cd->max_speed)
2542                 printk(KERN_CONT " %dX", cd->max_speed);
2543
2544         printk(KERN_CONT " %s", (cdi->mask & CDC_DVD) ? "CD-ROM" : "DVD-ROM");
2545
2546         if ((cdi->mask & CDC_DVD_R) == 0 || (cdi->mask & CDC_DVD_RAM) == 0)
2547                 printk(KERN_CONT " DVD%s%s",
2548                                  (cdi->mask & CDC_DVD_R) ? "" : "-R",
2549                                  (cdi->mask & CDC_DVD_RAM) ? "" : "-RAM");
2550
2551         if ((cdi->mask & CDC_CD_R) == 0 || (cdi->mask & CDC_CD_RW) == 0)
2552                 printk(KERN_CONT " CD%s%s",
2553                                  (cdi->mask & CDC_CD_R) ? "" : "-R",
2554                                  (cdi->mask & CDC_CD_RW) ? "" : "/RW");
2555
2556         if ((cdi->mask & CDC_SELECT_DISC) == 0)
2557                 printk(KERN_CONT " changer w/%d slots", nslots);
2558         else
2559                 printk(KERN_CONT " drive");
2560
2561         printk(KERN_CONT ", %dkB Cache\n", be16_to_cpu(*(u16 *)&buf[8 + 12]));
2562
2563         return nslots;
2564 }
2565
2566 #ifdef CONFIG_IDE_PROC_FS
2567 static void ide_cdrom_add_settings(ide_drive_t *drive)
2568 {
2569         ide_add_setting(drive, "dsc_overlap", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->dsc_overlap, NULL);
2570 }
2571 #else
2572 static inline void ide_cdrom_add_settings(ide_drive_t *drive) { ; }
2573 #endif
2574
2575 /*
2576  * standard prep_rq_fn that builds 10 byte cmds
2577  */
2578 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
2579 {
2580         int hard_sect = queue_hardsect_size(q);
2581         long block = (long)rq->hard_sector / (hard_sect >> 9);
2582         unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
2583
2584         memset(rq->cmd, 0, sizeof(rq->cmd));
2585
2586         if (rq_data_dir(rq) == READ)
2587                 rq->cmd[0] = GPCMD_READ_10;
2588         else
2589                 rq->cmd[0] = GPCMD_WRITE_10;
2590
2591         /*
2592          * fill in lba
2593          */
2594         rq->cmd[2] = (block >> 24) & 0xff;
2595         rq->cmd[3] = (block >> 16) & 0xff;
2596         rq->cmd[4] = (block >>  8) & 0xff;
2597         rq->cmd[5] = block & 0xff;
2598
2599         /*
2600          * and transfer length
2601          */
2602         rq->cmd[7] = (blocks >> 8) & 0xff;
2603         rq->cmd[8] = blocks & 0xff;
2604         rq->cmd_len = 10;
2605         return BLKPREP_OK;
2606 }
2607
2608 /*
2609  * Most of the SCSI commands are supported directly by ATAPI devices.
2610  * This transform handles the few exceptions.
2611  */
2612 static int ide_cdrom_prep_pc(struct request *rq)
2613 {
2614         u8 *c = rq->cmd;
2615
2616         /*
2617          * Transform 6-byte read/write commands to the 10-byte version
2618          */
2619         if (c[0] == READ_6 || c[0] == WRITE_6) {
2620                 c[8] = c[4];
2621                 c[5] = c[3];
2622                 c[4] = c[2];
2623                 c[3] = c[1] & 0x1f;
2624                 c[2] = 0;
2625                 c[1] &= 0xe0;
2626                 c[0] += (READ_10 - READ_6);
2627                 rq->cmd_len = 10;
2628                 return BLKPREP_OK;
2629         }
2630
2631         /*
2632          * it's silly to pretend we understand 6-byte sense commands, just
2633          * reject with ILLEGAL_REQUEST and the caller should take the
2634          * appropriate action
2635          */
2636         if (c[0] == MODE_SENSE || c[0] == MODE_SELECT) {
2637                 rq->errors = ILLEGAL_REQUEST;
2638                 return BLKPREP_KILL;
2639         }
2640         
2641         return BLKPREP_OK;
2642 }
2643
2644 static int ide_cdrom_prep_fn(struct request_queue *q, struct request *rq)
2645 {
2646         if (blk_fs_request(rq))
2647                 return ide_cdrom_prep_fs(q, rq);
2648         else if (blk_pc_request(rq))
2649                 return ide_cdrom_prep_pc(rq);
2650
2651         return 0;
2652 }
2653
2654 struct cd_list_entry {
2655         const char      *id_model;
2656         const char      *id_firmware;
2657         unsigned int    cd_flags;
2658 };
2659
2660 static const struct cd_list_entry ide_cd_quirks_list[] = {
2661         /* Limit transfer size per interrupt. */
2662         { "SAMSUNG CD-ROM SCR-2430", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
2663         { "SAMSUNG CD-ROM SCR-2432", NULL,   IDE_CD_FLAG_LIMIT_NFRAMES      },
2664         /* SCR-3231 doesn't support the SET_CD_SPEED command. */
2665         { "SAMSUNG CD-ROM SCR-3231", NULL,   IDE_CD_FLAG_NO_SPEED_SELECT    },
2666         /* Old NEC260 (not R) was released before ATAPI 1.2 spec. */
2667         { "NEC CD-ROM DRIVE:260",    "1.01", IDE_CD_FLAG_TOCADDR_AS_BCD |
2668                                              IDE_CD_FLAG_PRE_ATAPI12,       },
2669         /* Vertos 300, some versions of this drive like to talk BCD. */
2670         { "V003S0DS",                NULL,   IDE_CD_FLAG_VERTOS_300_SSD,    },
2671         /* Vertos 600 ESD. */
2672         { "V006E0DS",                NULL,   IDE_CD_FLAG_VERTOS_600_ESD,    },
2673         /*
2674          * Sanyo 3 CD changer uses a non-standard command for CD changing
2675          * (by default standard ATAPI support for CD changers is used).
2676          */
2677         { "CD-ROM CDR-C3 G",         NULL,   IDE_CD_FLAG_SANYO_3CD          },
2678         { "CD-ROM CDR-C3G",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
2679         { "CD-ROM CDR_C36",          NULL,   IDE_CD_FLAG_SANYO_3CD          },
2680         /* Stingray 8X CD-ROM. */
2681         { "STINGRAY 8422 IDE 8X CD-ROM 7-27-95", NULL, IDE_CD_FLAG_PRE_ATAPI12},
2682         /*
2683          * ACER 50X CD-ROM and WPI 32X CD-ROM require the full spec length
2684          * mode sense page capabilities size, but older drives break.
2685          */
2686         { "ATAPI CD ROM DRIVE 50X MAX", NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
2687         { "WPI CDS-32X",                NULL,   IDE_CD_FLAG_FULL_CAPS_PAGE  },
2688         /* ACER/AOpen 24X CD-ROM has the speed fields byte-swapped. */
2689         { "",                        "241N", IDE_CD_FLAG_LE_SPEED_FIELDS    },
2690         /*
2691          * Some drives used by Apple don't advertise audio play
2692          * but they do support reading TOC & audio datas.
2693          */
2694         { "MATSHITADVD-ROM SR-8187", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2695         { "MATSHITADVD-ROM SR-8186", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2696         { "MATSHITADVD-ROM SR-8176", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2697         { "MATSHITADVD-ROM SR-8174", NULL,   IDE_CD_FLAG_PLAY_AUDIO_OK      },
2698         { NULL, NULL, 0 }
2699 };
2700
2701 static unsigned int ide_cd_flags(struct hd_driveid *id)
2702 {
2703         const struct cd_list_entry *cle = ide_cd_quirks_list;
2704
2705         while (cle->id_model) {
2706                 if (strcmp(cle->id_model, id->model) == 0 &&
2707                     (cle->id_firmware == NULL ||
2708                      strstr(id->fw_rev, cle->id_firmware)))
2709                         return cle->cd_flags;
2710                 cle++;
2711         }
2712
2713         return 0;
2714 }
2715
2716 static
2717 int ide_cdrom_setup (ide_drive_t *drive)
2718 {
2719         struct cdrom_info *cd = drive->driver_data;
2720         struct cdrom_device_info *cdi = &cd->devinfo;
2721         struct hd_driveid *id = drive->id;
2722         int nslots;
2723
2724         blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
2725         blk_queue_dma_alignment(drive->queue, 31);
2726         drive->queue->unplug_delay = (1 * HZ) / 1000;
2727         if (!drive->queue->unplug_delay)
2728                 drive->queue->unplug_delay = 1;
2729
2730         drive->special.all      = 0;
2731
2732         cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT |
2733                        ide_cd_flags(id);
2734
2735         if ((id->config & 0x0060) == 0x20)
2736                 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
2737
2738         if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) &&
2739             id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
2740                 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
2741                                  IDE_CD_FLAG_TOCADDR_AS_BCD);
2742         else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) &&
2743                  id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
2744                 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
2745         else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
2746                 cdi->sanyo_slot = 3;    /* 3 => use CD in slot 0 */
2747
2748         nslots = ide_cdrom_probe_capabilities (drive);
2749
2750         /*
2751          * set correct block size
2752          */
2753         blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
2754
2755         if (drive->autotune == IDE_TUNE_DEFAULT ||
2756             drive->autotune == IDE_TUNE_AUTO)
2757                 drive->dsc_overlap = (drive->next != drive);
2758
2759         if (ide_cdrom_register(drive, nslots)) {
2760                 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
2761                 cd->devinfo.handle = NULL;
2762                 return 1;
2763         }
2764         ide_cdrom_add_settings(drive);
2765         return 0;
2766 }
2767
2768 #ifdef CONFIG_IDE_PROC_FS
2769 static
2770 sector_t ide_cdrom_capacity (ide_drive_t *drive)
2771 {
2772         unsigned long capacity, sectors_per_frame;
2773
2774         if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
2775                 return 0;
2776
2777         return capacity * sectors_per_frame;
2778 }
2779 #endif
2780
2781 static void ide_cd_remove(ide_drive_t *drive)
2782 {
2783         struct cdrom_info *info = drive->driver_data;
2784
2785         ide_proc_unregister_driver(drive, info->driver);
2786
2787         del_gendisk(info->disk);
2788
2789         ide_cd_put(info);
2790 }
2791
2792 static void ide_cd_release(struct kref *kref)
2793 {
2794         struct cdrom_info *info = to_ide_cd(kref);
2795         struct cdrom_device_info *devinfo = &info->devinfo;
2796         ide_drive_t *drive = info->drive;
2797         struct gendisk *g = info->disk;
2798
2799         kfree(info->buffer);
2800         kfree(info->toc);
2801         if (devinfo->handle == drive && unregister_cdrom(devinfo))
2802                 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
2803                                 "driver.\n", __FUNCTION__, drive->name);
2804         drive->dsc_overlap = 0;
2805         drive->driver_data = NULL;
2806         blk_queue_prep_rq(drive->queue, NULL);
2807         g->private_data = NULL;
2808         put_disk(g);
2809         kfree(info);
2810 }
2811
2812 static int ide_cd_probe(ide_drive_t *);
2813
2814 #ifdef CONFIG_IDE_PROC_FS
2815 static int proc_idecd_read_capacity
2816         (char *page, char **start, off_t off, int count, int *eof, void *data)
2817 {
2818         ide_drive_t *drive = data;
2819         int len;
2820
2821         len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
2822         PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
2823 }
2824
2825 static ide_proc_entry_t idecd_proc[] = {
2826         { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
2827         { NULL, 0, NULL, NULL }
2828 };
2829 #endif
2830
2831 static ide_driver_t ide_cdrom_driver = {
2832         .gen_driver = {
2833                 .owner          = THIS_MODULE,
2834                 .name           = "ide-cdrom",
2835                 .bus            = &ide_bus_type,
2836         },
2837         .probe                  = ide_cd_probe,
2838         .remove                 = ide_cd_remove,
2839         .version                = IDECD_VERSION,
2840         .media                  = ide_cdrom,
2841         .supports_dsc_overlap   = 1,
2842         .do_request             = ide_do_rw_cdrom,
2843         .end_request            = ide_end_request,
2844         .error                  = __ide_error,
2845         .abort                  = __ide_abort,
2846 #ifdef CONFIG_IDE_PROC_FS
2847         .proc                   = idecd_proc,
2848 #endif
2849 };
2850
2851 static int idecd_open(struct inode * inode, struct file * file)
2852 {
2853         struct gendisk *disk = inode->i_bdev->bd_disk;
2854         struct cdrom_info *info;
2855         int rc = -ENOMEM;
2856
2857         if (!(info = ide_cd_get(disk)))
2858                 return -ENXIO;
2859
2860         if (!info->buffer)
2861                 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
2862
2863         if (info->buffer)
2864                 rc = cdrom_open(&info->devinfo, inode, file);
2865
2866         if (rc < 0)
2867                 ide_cd_put(info);
2868
2869         return rc;
2870 }
2871
2872 static int idecd_release(struct inode * inode, struct file * file)
2873 {
2874         struct gendisk *disk = inode->i_bdev->bd_disk;
2875         struct cdrom_info *info = ide_cd_g(disk);
2876
2877         cdrom_release (&info->devinfo, file);
2878
2879         ide_cd_put(info);
2880
2881         return 0;
2882 }
2883
2884 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2885 {
2886         struct packet_command cgc;
2887         char buffer[16];
2888         int stat;
2889         char spindown;
2890
2891         if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
2892                 return -EFAULT;
2893
2894         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2895
2896         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2897         if (stat)
2898                 return stat;
2899
2900         buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2901         return cdrom_mode_select(cdi, &cgc);
2902 }
2903
2904 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2905 {
2906         struct packet_command cgc;
2907         char buffer[16];
2908         int stat;
2909         char spindown;
2910
2911         init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2912
2913         stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2914         if (stat)
2915                 return stat;
2916
2917         spindown = buffer[11] & 0x0f;
2918         if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
2919                 return -EFAULT;
2920         return 0;
2921 }
2922
2923 static int idecd_ioctl (struct inode *inode, struct file *file,
2924                         unsigned int cmd, unsigned long arg)
2925 {
2926         struct block_device *bdev = inode->i_bdev;
2927         struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
2928         int err;
2929
2930         switch (cmd) {
2931         case CDROMSETSPINDOWN:
2932                 return idecd_set_spindown(&info->devinfo, arg);
2933         case CDROMGETSPINDOWN:
2934                 return idecd_get_spindown(&info->devinfo, arg);
2935         default:
2936                 break;
2937         }
2938
2939         err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
2940         if (err == -EINVAL)
2941                 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
2942
2943         return err;
2944 }
2945
2946 static int idecd_media_changed(struct gendisk *disk)
2947 {
2948         struct cdrom_info *info = ide_cd_g(disk);
2949         return cdrom_media_changed(&info->devinfo);
2950 }
2951
2952 static int idecd_revalidate_disk(struct gendisk *disk)
2953 {
2954         struct cdrom_info *info = ide_cd_g(disk);
2955         struct request_sense sense;
2956         cdrom_read_toc(info->drive, &sense);
2957         return  0;
2958 }
2959
2960 static struct block_device_operations idecd_ops = {
2961         .owner          = THIS_MODULE,
2962         .open           = idecd_open,
2963         .release        = idecd_release,
2964         .ioctl          = idecd_ioctl,
2965         .media_changed  = idecd_media_changed,
2966         .revalidate_disk= idecd_revalidate_disk
2967 };
2968
2969 /* options */
2970 static char *ignore = NULL;
2971
2972 module_param(ignore, charp, 0400);
2973 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2974
2975 static int ide_cd_probe(ide_drive_t *drive)
2976 {
2977         struct cdrom_info *info;
2978         struct gendisk *g;
2979         struct request_sense sense;
2980
2981         if (!strstr("ide-cdrom", drive->driver_req))
2982                 goto failed;
2983         if (!drive->present)
2984                 goto failed;
2985         if (drive->media != ide_cdrom && drive->media != ide_optical)
2986                 goto failed;
2987         /* skip drives that we were told to ignore */
2988         if (ignore != NULL) {
2989                 if (strstr(ignore, drive->name)) {
2990                         printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
2991                         goto failed;
2992                 }
2993         }
2994         if (drive->scsi) {
2995                 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
2996                 goto failed;
2997         }
2998         info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
2999         if (info == NULL) {
3000                 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
3001                 goto failed;
3002         }
3003
3004         g = alloc_disk(1 << PARTN_BITS);
3005         if (!g)
3006                 goto out_free_cd;
3007
3008         ide_init_disk(g, drive);
3009
3010         ide_proc_register_driver(drive, &ide_cdrom_driver);
3011
3012         kref_init(&info->kref);
3013
3014         info->drive = drive;
3015         info->driver = &ide_cdrom_driver;
3016         info->disk = g;
3017
3018         g->private_data = &info->driver;
3019
3020         drive->driver_data = info;
3021
3022         g->minors = 1;
3023         g->driverfs_dev = &drive->gendev;
3024         g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
3025         if (ide_cdrom_setup(drive)) {
3026                 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
3027                 ide_cd_release(&info->kref);
3028                 goto failed;
3029         }
3030
3031         cdrom_read_toc(drive, &sense);
3032         g->fops = &idecd_ops;
3033         g->flags |= GENHD_FL_REMOVABLE;
3034         add_disk(g);
3035         return 0;
3036
3037 out_free_cd:
3038         kfree(info);
3039 failed:
3040         return -ENODEV;
3041 }
3042
3043 static void __exit ide_cdrom_exit(void)
3044 {
3045         driver_unregister(&ide_cdrom_driver.gen_driver);
3046 }
3047
3048 static int __init ide_cdrom_init(void)
3049 {
3050         return driver_register(&ide_cdrom_driver.gen_driver);
3051 }
3052
3053 MODULE_ALIAS("ide:*m-cdrom*");
3054 MODULE_ALIAS("ide-cd");
3055 module_init(ide_cdrom_init);
3056 module_exit(ide_cdrom_exit);
3057 MODULE_LICENSE("GPL");