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