projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:


c9316859195e740be2a06e46f841953f7d51b7b4
[GitHub/mt8127/android_kernel_alcatel_ttab.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) 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 = HWIF(drive)->INB(IDE_STATUS_REG);
299 if (stat_ret)
300 *stat_ret = stat;
301
302 if (OK_STAT(stat, good_stat, BAD_R_STAT))
303 return 0;
304
305 /* Get the IDE error register. */
306 err = HWIF(drive)->INB(IDE_ERROR_REG);
307 sense_key = err >> 4;
308
309 if (rq == NULL) {
310 printk("%s: missing rq in cdrom_decode_status\n", drive->name);
311 return 1;
312 }
313
314 if (blk_sense_request(rq)) {
315 /* We got an error trying to get sense info
316 from the drive (probably while trying
317 to recover from a former error). Just give up. */
318
319 rq->cmd_flags |= REQ_FAILED;
320 cdrom_end_request(drive, 0);
321 ide_error(drive, "request sense failure", stat);
322 return 1;
323
324 } else if (blk_pc_request(rq) || rq->cmd_type == REQ_TYPE_ATA_PC) {
325 /* All other functions, except for READ. */
326
327 /*
328 * if we have an error, pass back CHECK_CONDITION as the
329 * scsi status byte
330 */
331 if (blk_pc_request(rq) && !rq->errors)
332 rq->errors = SAM_STAT_CHECK_CONDITION;
333
334 /* Check for tray open. */
335 if (sense_key == NOT_READY) {
336 cdrom_saw_media_change (drive);
337 } else if (sense_key == UNIT_ATTENTION) {
338 /* Check for media change. */
339 cdrom_saw_media_change (drive);
340 /*printk("%s: media changed\n",drive->name);*/
341 return 0;
342 } else if ((sense_key == ILLEGAL_REQUEST) &&
343 (rq->cmd[0] == GPCMD_START_STOP_UNIT)) {
344 /*
345 * Don't print error message for this condition--
346 * SFF8090i indicates that 5/24/00 is the correct
347 * response to a request to close the tray if the
348 * drive doesn't have that capability.
349 * cdrom_log_sense() knows this!
350 */
351 } else if (!(rq->cmd_flags & REQ_QUIET)) {
352 /* Otherwise, print an error. */
353 ide_dump_status(drive, "packet command error", stat);
354 }
355
356 rq->cmd_flags |= REQ_FAILED;
357
358 /*
359 * instead of playing games with moving completions around,
360 * remove failed request completely and end it when the
361 * request sense has completed
362 */
363 goto end_request;
364
365 } else if (blk_fs_request(rq)) {
366 int do_end_request = 0;
367
368 /* Handle errors from READ and WRITE requests. */
369
370 if (blk_noretry_request(rq))
371 do_end_request = 1;
372
373 if (sense_key == NOT_READY) {
374 /* Tray open. */
375 if (rq_data_dir(rq) == READ) {
376 cdrom_saw_media_change (drive);
377
378 /* Fail the request. */
379 printk ("%s: tray open\n", drive->name);
380 do_end_request = 1;
381 } else {
382 struct cdrom_info *info = drive->driver_data;
383
384 /* allow the drive 5 seconds to recover, some
385 * devices will return this error while flushing
386 * data from cache */
387 if (!rq->errors)
388 info->write_timeout = jiffies + ATAPI_WAIT_WRITE_BUSY;
389 rq->errors = 1;
390 if (time_after(jiffies, info->write_timeout))
391 do_end_request = 1;
392 else {
393 unsigned long flags;
394
395 /*
396 * take a breather relying on the
397 * unplug timer to kick us again
398 */
399 spin_lock_irqsave(&ide_lock, flags);
400 blk_plug_device(drive->queue);
401 spin_unlock_irqrestore(&ide_lock,flags);
402 return 1;
403 }
404 }
405 } else if (sense_key == UNIT_ATTENTION) {
406 /* Media change. */
407 cdrom_saw_media_change (drive);
408
409 /* Arrange to retry the request.
410 But be sure to give up if we've retried
411 too many times. */
412 if (++rq->errors > ERROR_MAX)
413 do_end_request = 1;
414 } else if (sense_key == ILLEGAL_REQUEST ||
415 sense_key == DATA_PROTECT) {
416 /* No point in retrying after an illegal
417 request or data protect error.*/
418 ide_dump_status_no_sense (drive, "command error", stat);
419 do_end_request = 1;
420 } else if (sense_key == MEDIUM_ERROR) {
421 /* No point in re-trying a zillion times on a bad
422 * sector... If we got here the error is not correctable */
423 ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
424 do_end_request = 1;
425 } else if (sense_key == BLANK_CHECK) {
426 /* Disk appears blank ?? */
427 ide_dump_status_no_sense (drive, "media error (blank)", stat);
428 do_end_request = 1;
429 } else if ((err & ~ABRT_ERR) != 0) {
430 /* Go to the default handler
431 for other errors. */
432 ide_error(drive, "cdrom_decode_status", stat);
433 return 1;
434 } else if ((++rq->errors > ERROR_MAX)) {
435 /* We've racked up too many retries. Abort. */
436 do_end_request = 1;
437 }
438
439 /* End a request through request sense analysis when we have
440 sense data. We need this in order to perform end of media
441 processing */
442
443 if (do_end_request)
444 goto end_request;
445
446 /*
447 * If we got a CHECK_CONDITION status,
448 * queue a request sense command.
449 */
450 if (stat & ERR_STAT)
451 cdrom_queue_request_sense(drive, NULL, NULL);
452 } else {
453 blk_dump_rq_flags(rq, "ide-cd: bad rq");
454 cdrom_end_request(drive, 0);
455 }
456
457 /* Retry, or handle the next request. */
458 return 1;
459
460 end_request:
461 if (stat & ERR_STAT) {
462 unsigned long flags;
463
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
473 return 1;
474 }
475
476 static int cdrom_timer_expiry(ide_drive_t *drive)
477 {
478 struct request *rq = HWGROUP(drive)->rq;
479 unsigned long wait = 0;
480
481 /*
482 * Some commands are *slow* and normally take a long time to
483 * complete. Usually we can use the ATAPI "disconnect" to bypass
484 * this, but not all commands/drives support that. Let
485 * ide_timer_expiry keep polling us for these.
486 */
487 switch (rq->cmd[0]) {
488 case GPCMD_BLANK:
489 case GPCMD_FORMAT_UNIT:
490 case GPCMD_RESERVE_RZONE_TRACK:
491 case GPCMD_CLOSE_TRACK:
492 case GPCMD_FLUSH_CACHE:
493 wait = ATAPI_WAIT_PC;
494 break;
495 default:
496 if (!(rq->cmd_flags & REQ_QUIET))
497 printk(KERN_INFO "ide-cd: cmd 0x%x timed out\n", rq->cmd[0]);
498 wait = 0;
499 break;
500 }
501 return wait;
502 }
503
504 /* Set up the device registers for transferring a packet command on DEV,
505 expecting to later transfer XFERLEN bytes. HANDLER is the routine
506 which actually transfers the command to the drive. If this is a
507 drq_interrupt device, this routine will arrange for HANDLER to be
508 called when the interrupt from the drive arrives. Otherwise, HANDLER
509 will be called immediately after the drive is prepared for the transfer. */
510
511 static ide_startstop_t cdrom_start_packet_command(ide_drive_t *drive,
512 int xferlen,
513 ide_handler_t *handler)
514 {
515 ide_startstop_t startstop;
516 struct cdrom_info *info = drive->driver_data;
517 ide_hwif_t *hwif = drive->hwif;
518
519 /* Wait for the controller to be idle. */
520 if (ide_wait_stat(&startstop, drive, 0, BUSY_STAT, WAIT_READY))
521 return startstop;
522
523 /* FIXME: for Virtual DMA we must check harder */
524 if (info->dma)
525 info->dma = !hwif->dma_setup(drive);
526
527 /* Set up the controller registers. */
528 ide_pktcmd_tf_load(drive, IDE_TFLAG_OUT_NSECT | IDE_TFLAG_OUT_LBAL |
529 IDE_TFLAG_NO_SELECT_MASK, xferlen, info->dma);
530
531 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
532 /* waiting for CDB interrupt, not DMA yet. */
533 if (info->dma)
534 drive->waiting_for_dma = 0;
535
536 /* packet command */
537 ide_execute_command(drive, WIN_PACKETCMD, handler, ATAPI_WAIT_PC, cdrom_timer_expiry);
538 return ide_started;
539 } else {
540 unsigned long flags;
541
542 /* packet command */
543 spin_lock_irqsave(&ide_lock, flags);
544 hwif->OUTBSYNC(drive, WIN_PACKETCMD, IDE_COMMAND_REG);
545 ndelay(400);
546 spin_unlock_irqrestore(&ide_lock, flags);
547
548 return (*handler) (drive);
549 }
550 }
551
552 /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
553 The device registers must have already been prepared
554 by cdrom_start_packet_command.
555 HANDLER is the interrupt handler to call when the command completes
556 or there's data ready. */
557 #define ATAPI_MIN_CDB_BYTES 12
558 static ide_startstop_t cdrom_transfer_packet_command (ide_drive_t *drive,
559 struct request *rq,
560 ide_handler_t *handler)
561 {
562 ide_hwif_t *hwif = drive->hwif;
563 int cmd_len;
564 struct cdrom_info *info = drive->driver_data;
565 ide_startstop_t startstop;
566
567 if (info->cd_flags & IDE_CD_FLAG_DRQ_INTERRUPT) {
568 /* Here we should have been called after receiving an interrupt
569 from the device. DRQ should how be set. */
570
571 /* Check for errors. */
572 if (cdrom_decode_status(drive, DRQ_STAT, NULL))
573 return ide_stopped;
574
575 /* Ok, next interrupt will be DMA interrupt. */
576 if (info->dma)
577 drive->waiting_for_dma = 1;
578 } else {
579 /* Otherwise, we must wait for DRQ to get set. */
580 if (ide_wait_stat(&startstop, drive, DRQ_STAT,
581 BUSY_STAT, WAIT_READY))
582 return startstop;
583 }
584
585 /* Arm the interrupt handler. */
586 ide_set_handler(drive, handler, rq->timeout, cdrom_timer_expiry);
587
588 /* ATAPI commands get padded out to 12 bytes minimum */
589 cmd_len = COMMAND_SIZE(rq->cmd[0]);
590 if (cmd_len < ATAPI_MIN_CDB_BYTES)
591 cmd_len = ATAPI_MIN_CDB_BYTES;
592
593 /* Send the command to the device. */
594 HWIF(drive)->atapi_output_bytes(drive, rq->cmd, cmd_len);
595
596 /* Start the DMA if need be */
597 if (info->dma)
598 hwif->dma_start(drive);
599
600 return ide_started;
601 }
602
603 /****************************************************************************
604 * Block read functions.
605 */
606
607 typedef void (xfer_func_t)(ide_drive_t *, void *, u32);
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
675 int ide_cd_check_ireason(ide_drive_t *drive, 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) HWIF(drive)->INB(IDE_STATUS_REG);
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 cdrom_end_request(drive, 0);
706 return -1;
707 }
708
709 /*
710 * Assume that the drive will always provide data in multiples of at least
711 * SECTOR_SIZE, as it gets hairy to keep track of the transfers otherwise.
712 */
713 static int ide_cd_check_transfer_size(ide_drive_t *drive, int len)
714 {
715 struct cdrom_info *cd = drive->driver_data;
716
717 if ((len % SECTOR_SIZE) == 0)
718 return 0;
719
720 printk(KERN_ERR "%s: %s: Bad transfer size %d\n",
721 drive->name, __FUNCTION__, len);
722
723 if (cd->cd_flags & IDE_CD_FLAG_LIMIT_NFRAMES)
724 printk(KERN_ERR " This drive is not supported by "
725 "this version of the driver\n");
726 else {
727 printk(KERN_ERR " Trying to limit transfer sizes\n");
728 cd->cd_flags |= IDE_CD_FLAG_LIMIT_NFRAMES;
729 }
730
731 return 1;
732 }
733
734 /*
735 * Try to satisfy some of the current read request from our cached data.
736 * Returns nonzero if the request has been completed, zero otherwise.
737 */
738 static int cdrom_read_from_buffer (ide_drive_t *drive)
739 {
740 struct cdrom_info *info = drive->driver_data;
741 struct request *rq = HWGROUP(drive)->rq;
742 unsigned short sectors_per_frame;
743
744 sectors_per_frame = queue_hardsect_size(drive->queue) >> SECTOR_BITS;
745
746 /* Can't do anything if there's no buffer. */
747 if (info->buffer == NULL) return 0;
748
749 /* Loop while this request needs data and the next block is present
750 in our cache. */
751 while (rq->nr_sectors > 0 &&
752 rq->sector >= info->sector_buffered &&
753 rq->sector < info->sector_buffered + info->nsectors_buffered) {
754 if (rq->current_nr_sectors == 0)
755 cdrom_end_request(drive, 1);
756
757 memcpy (rq->buffer,
758 info->buffer +
759 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
760 SECTOR_SIZE);
761 rq->buffer += SECTOR_SIZE;
762 --rq->current_nr_sectors;
763 --rq->nr_sectors;
764 ++rq->sector;
765 }
766
767 /* If we've satisfied the current request,
768 terminate it successfully. */
769 if (rq->nr_sectors == 0) {
770 cdrom_end_request(drive, 1);
771 return -1;
772 }
773
774 /* Move on to the next buffer if needed. */
775 if (rq->current_nr_sectors == 0)
776 cdrom_end_request(drive, 1);
777
778 /* If this condition does not hold, then the kluge i use to
779 represent the number of sectors to skip at the start of a transfer
780 will fail. I think that this will never happen, but let's be
781 paranoid and check. */
782 if (rq->current_nr_sectors < bio_cur_sectors(rq->bio) &&
783 (rq->sector & (sectors_per_frame - 1))) {
784 printk(KERN_ERR "%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
785 drive->name, (long)rq->sector);
786 cdrom_end_request(drive, 0);
787 return -1;
788 }
789
790 return 0;
791 }
792
793 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *);
794
795 /*
796 * Routine to send a read/write packet command to the drive.
797 * This is usually called directly from cdrom_start_{read,write}().
798 * However, for drq_interrupt devices, it is called from an interrupt
799 * when the drive is ready to accept the command.
800 */
801 static ide_startstop_t cdrom_start_rw_cont(ide_drive_t *drive)
802 {
803 struct request *rq = HWGROUP(drive)->rq;
804
805 if (rq_data_dir(rq) == READ) {
806 unsigned short sectors_per_frame =
807 queue_hardsect_size(drive->queue) >> SECTOR_BITS;
808 int nskip = rq->sector & (sectors_per_frame - 1);
809
810 /*
811 * If the requested sector doesn't start on a frame boundary,
812 * we must adjust the start of the transfer so that it does,
813 * and remember to skip the first few sectors.
814 *
815 * If the rq->current_nr_sectors field is larger than the size
816 * of the buffer, it will mean that we're to skip a number of
817 * sectors equal to the amount by which rq->current_nr_sectors
818 * is larger than the buffer size.
819 */
820 if (nskip > 0) {
821 /* Sanity check... */
822 if (rq->current_nr_sectors !=
823 bio_cur_sectors(rq->bio)) {
824 printk(KERN_ERR "%s: %s: buffer botch (%u)\n",
825 drive->name, __FUNCTION__,
826 rq->current_nr_sectors);
827 cdrom_end_request(drive, 0);
828 return ide_stopped;
829 }
830 rq->current_nr_sectors += nskip;
831 }
832 }
833 #if 0
834 else
835 /* the immediate bit */
836 rq->cmd[1] = 1 << 3;
837 #endif
838 /* Set up the command */
839 rq->timeout = ATAPI_WAIT_PC;
840
841 /* Send the command to the drive and return. */
842 return cdrom_transfer_packet_command(drive, rq, cdrom_newpc_intr);
843 }
844
845 #define IDECD_SEEK_THRESHOLD (1000) /* 1000 blocks */
846 #define IDECD_SEEK_TIMER (5 * WAIT_MIN_SLEEP) /* 100 ms */
847 #define IDECD_SEEK_TIMEOUT (2 * WAIT_CMD) /* 20 sec */
848
849 static ide_startstop_t cdrom_seek_intr (ide_drive_t *drive)
850 {
851 struct cdrom_info *info = drive->driver_data;
852 int stat;
853 static int retry = 10;
854
855 if (cdrom_decode_status(drive, 0, &stat))
856 return ide_stopped;
857
858 info->cd_flags |= IDE_CD_FLAG_SEEKING;
859
860 if (retry && time_after(jiffies, info->start_seek + IDECD_SEEK_TIMER)) {
861 if (--retry == 0) {
862 /*
863 * this condition is far too common, to bother
864 * users about it
865 */
866 /* printk("%s: disabled DSC seek overlap\n", drive->name);*/
867 drive->dsc_overlap = 0;
868 }
869 }
870 return ide_stopped;
871 }
872
873 static ide_startstop_t cdrom_start_seek_continuation (ide_drive_t *drive)
874 {
875 struct request *rq = HWGROUP(drive)->rq;
876 sector_t frame = rq->sector;
877
878 sector_div(frame, queue_hardsect_size(drive->queue) >> SECTOR_BITS);
879
880 memset(rq->cmd, 0, sizeof(rq->cmd));
881 rq->cmd[0] = GPCMD_SEEK;
882 put_unaligned(cpu_to_be32(frame), (unsigned int *) &rq->cmd[2]);
883
884 rq->timeout = ATAPI_WAIT_PC;
885 return cdrom_transfer_packet_command(drive, rq, &cdrom_seek_intr);
886 }
887
888 static ide_startstop_t cdrom_start_seek (ide_drive_t *drive, unsigned int block)
889 {
890 struct cdrom_info *info = drive->driver_data;
891
892 info->dma = 0;
893 info->start_seek = jiffies;
894 return cdrom_start_packet_command(drive, 0, cdrom_start_seek_continuation);
895 }
896
897 /* Fix up a possibly partially-processed request so that we can
898 start it over entirely, or even put it back on the request queue. */
899 static void restore_request (struct request *rq)
900 {
901 if (rq->buffer != bio_data(rq->bio)) {
902 sector_t n = (rq->buffer - (char *) bio_data(rq->bio)) / SECTOR_SIZE;
903
904 rq->buffer = bio_data(rq->bio);
905 rq->nr_sectors += n;
906 rq->sector -= n;
907 }
908 rq->hard_cur_sectors = rq->current_nr_sectors = bio_cur_sectors(rq->bio);
909 rq->hard_nr_sectors = rq->nr_sectors;
910 rq->hard_sector = rq->sector;
911 rq->q->prep_rq_fn(rq->q, rq);
912 }
913
914 /****************************************************************************
915 * Execute all other packet commands.
916 */
917
918 static void ide_cd_request_sense_fixup(struct request *rq)
919 {
920 /*
921 * Some of the trailing request sense fields are optional,
922 * and some drives don't send them. Sigh.
923 */
924 if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
925 rq->data_len > 0 && rq->data_len <= 5)
926 while (rq->data_len > 0) {
927 *(u8 *)rq->data++ = 0;
928 --rq->data_len;
929 }
930 }
931
932 int ide_cd_queue_pc(ide_drive_t *drive, struct request *rq)
933 {
934 struct request_sense sense;
935 int retries = 10;
936 unsigned int flags = rq->cmd_flags;
937
938 if (rq->sense == NULL)
939 rq->sense = &sense;
940
941 /* Start of retry loop. */
942 do {
943 int error;
944 unsigned long time = jiffies;
945 rq->cmd_flags = flags;
946
947 error = ide_do_drive_cmd(drive, rq, ide_wait);
948 time = jiffies - time;
949
950 /* FIXME: we should probably abort/retry or something
951 * in case of failure */
952 if (rq->cmd_flags & REQ_FAILED) {
953 /* The request failed. Retry if it was due to a unit
954 attention status
955 (usually means media was changed). */
956 struct request_sense *reqbuf = rq->sense;
957
958 if (reqbuf->sense_key == UNIT_ATTENTION)
959 cdrom_saw_media_change(drive);
960 else if (reqbuf->sense_key == NOT_READY &&
961 reqbuf->asc == 4 && reqbuf->ascq != 4) {
962 /* The drive is in the process of loading
963 a disk. Retry, but wait a little to give
964 the drive time to complete the load. */
965 ssleep(2);
966 } else {
967 /* Otherwise, don't retry. */
968 retries = 0;
969 }
970 --retries;
971 }
972
973 /* End of retry loop. */
974 } while ((rq->cmd_flags & REQ_FAILED) && retries >= 0);
975
976 /* Return an error if the command failed. */
977 return (rq->cmd_flags & REQ_FAILED) ? -EIO : 0;
978 }
979
980 /*
981 * Called from blk_end_request_callback() after the data of the request
982 * is completed and before the request is completed.
983 * By returning value '1', blk_end_request_callback() returns immediately
984 * without completing the request.
985 */
986 static int cdrom_newpc_intr_dummy_cb(struct request *rq)
987 {
988 return 1;
989 }
990
991 static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
992 {
993 struct cdrom_info *info = drive->driver_data;
994 struct request *rq = HWGROUP(drive)->rq;
995 xfer_func_t *xferfunc;
996 ide_expiry_t *expiry = NULL;
997 int dma_error = 0, dma, stat, ireason, len, thislen, uptodate = 0;
998 int write = (rq_data_dir(rq) == WRITE) ? 1 : 0;
999 unsigned int timeout;
1000 u8 lowcyl, highcyl;
1001
1002 /* Check for errors. */
1003 dma = info->dma;
1004 if (dma) {
1005 info->dma = 0;
1006 dma_error = HWIF(drive)->ide_dma_end(drive);
1007 if (dma_error) {
1008 printk(KERN_ERR "%s: DMA %s error\n", drive->name,
1009 write ? "write" : "read");
1010 ide_dma_off(drive);
1011 }
1012 }
1013
1014 if (cdrom_decode_status(drive, 0, &stat))
1015 return ide_stopped;
1016
1017 /*
1018 * using dma, transfer is complete now
1019 */
1020 if (dma) {
1021 if (dma_error)
1022 return ide_error(drive, "dma error", stat);
1023 if (blk_fs_request(rq)) {
1024 ide_end_request(drive, 1, rq->nr_sectors);
1025 return ide_stopped;
1026 }
1027 goto end_request;
1028 }
1029
1030 /*
1031 * ok we fall to pio :/
1032 */
1033 ireason = HWIF(drive)->INB(IDE_IREASON_REG) & 0x3;
1034 lowcyl = HWIF(drive)->INB(IDE_BCOUNTL_REG);
1035 highcyl = HWIF(drive)->INB(IDE_BCOUNTH_REG);
1036
1037 len = lowcyl + (256 * highcyl);
1038
1039 thislen = blk_fs_request(rq) ? len : rq->data_len;
1040 if (thislen > len)
1041 thislen = len;
1042
1043 /*
1044 * If DRQ is clear, the command has completed.
1045 */
1046 if ((stat & DRQ_STAT) == 0) {
1047 if (blk_fs_request(rq)) {
1048 /*
1049 * If we're not done reading/writing, complain.
1050 * Otherwise, complete the command normally.
1051 */
1052 uptodate = 1;
1053 if (rq->current_nr_sectors > 0) {
1054 printk(KERN_ERR "%s: %s: data underrun "
1055 "(%d blocks)\n",
1056 drive->name, __FUNCTION__,
1057 rq->current_nr_sectors);
1058 if (!write)
1059 rq->cmd_flags |= REQ_FAILED;
1060 uptodate = 0;
1061 }
1062 cdrom_end_request(drive, uptodate);
1063 return ide_stopped;
1064 } else if (!blk_pc_request(rq)) {
1065 ide_cd_request_sense_fixup(rq);
1066 /* Complain if we still have data left to transfer. */
1067 uptodate = rq->data_len ? 0 : 1;
1068 }
1069 goto end_request;
1070 }
1071
1072 /*
1073 * check which way to transfer data
1074 */
1075 if (blk_fs_request(rq) || blk_pc_request(rq)) {
1076 if (ide_cd_check_ireason(drive, len, ireason, write))
1077 return ide_stopped;
1078
1079 if (blk_fs_request(rq) && write == 0) {
1080 int nskip;
1081
1082 if (ide_cd_check_transfer_size(drive, len)) {
1083 cdrom_end_request(drive, 0);
1084 return ide_stopped;
1085 }
1086
1087 /*
1088 * First, figure out if we need to bit-bucket
1089 * any of the leading sectors.
1090 */
1091 nskip = min_t(int, rq->current_nr_sectors
1092 - bio_cur_sectors(rq->bio),
1093 thislen >> 9);
1094 if (nskip > 0) {
1095 ide_cd_drain_data(drive, nskip);
1096 rq->current_nr_sectors -= nskip;
1097 thislen -= (nskip << 9);
1098 }
1099 }
1100 }
1101
1102 if (ireason == 0) {
1103 write = 1;
1104 xferfunc = HWIF(drive)->atapi_output_bytes;
1105 } else if (ireason == 2 || (ireason == 1 &&
1106 (blk_fs_request(rq) || blk_pc_request(rq)))) {
1107 write = 0;
1108 xferfunc = HWIF(drive)->atapi_input_bytes;
1109 } else {
1110 printk(KERN_ERR "%s: %s: The drive "
1111 "appears confused (ireason = 0x%02x). "
1112 "Trying to recover by ending request.\n",
1113 drive->name, __FUNCTION__, ireason);
1114 goto end_request;
1115 }
1116
1117 /*
1118 * transfer data
1119 */
1120 while (thislen > 0) {
1121 u8 *ptr = blk_fs_request(rq) ? NULL : rq->data;
1122 int blen = rq->data_len;
1123
1124 /*
1125 * bio backed?
1126 */
1127 if (rq->bio) {
1128 if (blk_fs_request(rq)) {
1129 ptr = rq->buffer;
1130 blen = rq->current_nr_sectors << 9;
1131 } else {
1132 ptr = bio_data(rq->bio);
1133 blen = bio_iovec(rq->bio)->bv_len;
1134 }
1135 }
1136
1137 if (!ptr) {
1138 if (blk_fs_request(rq) && !write)
1139 /*
1140 * If the buffers are full, cache the rest
1141 * of the data in our internal buffer.
1142 */
1143 cdrom_buffer_sectors(drive, rq->sector,
1144 thislen >> 9);
1145 else {
1146 printk(KERN_ERR "%s: confused, missing data\n",
1147 drive->name);
1148 blk_dump_rq_flags(rq, rq_data_dir(rq)
1149 ? "cdrom_newpc_intr, write"
1150 : "cdrom_newpc_intr, read");
1151 }
1152 break;
1153 }
1154
1155 if (blen > thislen)
1156 blen = thislen;
1157
1158 xferfunc(drive, ptr, blen);
1159
1160 thislen -= blen;
1161 len -= blen;
1162
1163 if (blk_fs_request(rq)) {
1164 rq->buffer += blen;
1165 rq->nr_sectors -= (blen >> 9);
1166 rq->current_nr_sectors -= (blen >> 9);
1167 rq->sector += (blen >> 9);
1168
1169 if (rq->current_nr_sectors == 0 && rq->nr_sectors)
1170 cdrom_end_request(drive, 1);
1171 } else {
1172 rq->data_len -= blen;
1173
1174 /*
1175 * The request can't be completed until DRQ is cleared.
1176 * So complete the data, but don't complete the request
1177 * using the dummy function for the callback feature
1178 * of blk_end_request_callback().
1179 */
1180 if (rq->bio)
1181 blk_end_request_callback(rq, 0, blen,
1182 cdrom_newpc_intr_dummy_cb);
1183 else
1184 rq->data += blen;
1185 }
1186 }
1187
1188 if (write && blk_sense_request(rq))
1189 rq->sense_len += thislen;
1190
1191 /*
1192 * pad, if necessary
1193 */
1194 if (!blk_fs_request(rq) && len > 0)
1195 ide_cd_pad_transfer(drive, xferfunc, len);
1196
1197 if (blk_pc_request(rq)) {
1198 timeout = rq->timeout;
1199 } else {
1200 timeout = ATAPI_WAIT_PC;
1201 if (!blk_fs_request(rq))
1202 expiry = cdrom_timer_expiry;
1203 }
1204
1205 ide_set_handler(drive, cdrom_newpc_intr, timeout, expiry);
1206 return ide_started;
1207
1208 end_request:
1209 if (blk_pc_request(rq)) {
1210 unsigned long flags;
1211
1212 spin_lock_irqsave(&ide_lock, flags);
1213 if (__blk_end_request(rq, 0, rq->data_len))
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 = HWIF(drive)->INB(IDE_STATUS_REG);
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 = ntohs (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 { NULL, NULL, 0 }
1932 };
1933
1934 static unsigned int ide_cd_flags(struct hd_driveid *id)
1935 {
1936 const struct cd_list_entry *cle = ide_cd_quirks_list;
1937
1938 while (cle->id_model) {
1939 if (strcmp(cle->id_model, id->model) == 0 &&
1940 (cle->id_firmware == NULL ||
1941 strstr(id->fw_rev, cle->id_firmware)))
1942 return cle->cd_flags;
1943 cle++;
1944 }
1945
1946 return 0;
1947 }
1948
1949 static
1950 int ide_cdrom_setup (ide_drive_t *drive)
1951 {
1952 struct cdrom_info *cd = drive->driver_data;
1953 struct cdrom_device_info *cdi = &cd->devinfo;
1954 struct hd_driveid *id = drive->id;
1955 int nslots;
1956
1957 blk_queue_prep_rq(drive->queue, ide_cdrom_prep_fn);
1958 blk_queue_dma_alignment(drive->queue, 31);
1959 drive->queue->unplug_delay = (1 * HZ) / 1000;
1960 if (!drive->queue->unplug_delay)
1961 drive->queue->unplug_delay = 1;
1962
1963 drive->special.all = 0;
1964
1965 cd->cd_flags = IDE_CD_FLAG_MEDIA_CHANGED | IDE_CD_FLAG_NO_EJECT |
1966 ide_cd_flags(id);
1967
1968 if ((id->config & 0x0060) == 0x20)
1969 cd->cd_flags |= IDE_CD_FLAG_DRQ_INTERRUPT;
1970
1971 if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_300_SSD) &&
1972 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
1973 cd->cd_flags |= (IDE_CD_FLAG_TOCTRACKS_AS_BCD |
1974 IDE_CD_FLAG_TOCADDR_AS_BCD);
1975 else if ((cd->cd_flags & IDE_CD_FLAG_VERTOS_600_ESD) &&
1976 id->fw_rev[4] == '1' && id->fw_rev[6] <= '2')
1977 cd->cd_flags |= IDE_CD_FLAG_TOCTRACKS_AS_BCD;
1978 else if (cd->cd_flags & IDE_CD_FLAG_SANYO_3CD)
1979 cdi->sanyo_slot = 3; /* 3 => use CD in slot 0 */
1980
1981 nslots = ide_cdrom_probe_capabilities (drive);
1982
1983 /*
1984 * set correct block size
1985 */
1986 blk_queue_hardsect_size(drive->queue, CD_FRAMESIZE);
1987
1988 if (drive->autotune == IDE_TUNE_DEFAULT ||
1989 drive->autotune == IDE_TUNE_AUTO)
1990 drive->dsc_overlap = (drive->next != drive);
1991
1992 if (ide_cdrom_register(drive, nslots)) {
1993 printk (KERN_ERR "%s: ide_cdrom_setup failed to register device with the cdrom driver.\n", drive->name);
1994 cd->devinfo.handle = NULL;
1995 return 1;
1996 }
1997 ide_cdrom_add_settings(drive);
1998 return 0;
1999 }
2000
2001 #ifdef CONFIG_IDE_PROC_FS
2002 static
2003 sector_t ide_cdrom_capacity (ide_drive_t *drive)
2004 {
2005 unsigned long capacity, sectors_per_frame;
2006
2007 if (cdrom_read_capacity(drive, &capacity, &sectors_per_frame, NULL))
2008 return 0;
2009
2010 return capacity * sectors_per_frame;
2011 }
2012 #endif
2013
2014 static void ide_cd_remove(ide_drive_t *drive)
2015 {
2016 struct cdrom_info *info = drive->driver_data;
2017
2018 ide_proc_unregister_driver(drive, info->driver);
2019
2020 del_gendisk(info->disk);
2021
2022 ide_cd_put(info);
2023 }
2024
2025 static void ide_cd_release(struct kref *kref)
2026 {
2027 struct cdrom_info *info = to_ide_cd(kref);
2028 struct cdrom_device_info *devinfo = &info->devinfo;
2029 ide_drive_t *drive = info->drive;
2030 struct gendisk *g = info->disk;
2031
2032 kfree(info->buffer);
2033 kfree(info->toc);
2034 if (devinfo->handle == drive && unregister_cdrom(devinfo))
2035 printk(KERN_ERR "%s: %s failed to unregister device from the cdrom "
2036 "driver.\n", __FUNCTION__, drive->name);
2037 drive->dsc_overlap = 0;
2038 drive->driver_data = NULL;
2039 blk_queue_prep_rq(drive->queue, NULL);
2040 g->private_data = NULL;
2041 put_disk(g);
2042 kfree(info);
2043 }
2044
2045 static int ide_cd_probe(ide_drive_t *);
2046
2047 #ifdef CONFIG_IDE_PROC_FS
2048 static int proc_idecd_read_capacity
2049 (char *page, char **start, off_t off, int count, int *eof, void *data)
2050 {
2051 ide_drive_t *drive = data;
2052 int len;
2053
2054 len = sprintf(page,"%llu\n", (long long)ide_cdrom_capacity(drive));
2055 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
2056 }
2057
2058 static ide_proc_entry_t idecd_proc[] = {
2059 { "capacity", S_IFREG|S_IRUGO, proc_idecd_read_capacity, NULL },
2060 { NULL, 0, NULL, NULL }
2061 };
2062 #endif
2063
2064 static ide_driver_t ide_cdrom_driver = {
2065 .gen_driver = {
2066 .owner = THIS_MODULE,
2067 .name = "ide-cdrom",
2068 .bus = &ide_bus_type,
2069 },
2070 .probe = ide_cd_probe,
2071 .remove = ide_cd_remove,
2072 .version = IDECD_VERSION,
2073 .media = ide_cdrom,
2074 .supports_dsc_overlap = 1,
2075 .do_request = ide_do_rw_cdrom,
2076 .end_request = ide_end_request,
2077 .error = __ide_error,
2078 .abort = __ide_abort,
2079 #ifdef CONFIG_IDE_PROC_FS
2080 .proc = idecd_proc,
2081 #endif
2082 };
2083
2084 static int idecd_open(struct inode * inode, struct file * file)
2085 {
2086 struct gendisk *disk = inode->i_bdev->bd_disk;
2087 struct cdrom_info *info;
2088 int rc = -ENOMEM;
2089
2090 if (!(info = ide_cd_get(disk)))
2091 return -ENXIO;
2092
2093 if (!info->buffer)
2094 info->buffer = kmalloc(SECTOR_BUFFER_SIZE, GFP_KERNEL|__GFP_REPEAT);
2095
2096 if (info->buffer)
2097 rc = cdrom_open(&info->devinfo, inode, file);
2098
2099 if (rc < 0)
2100 ide_cd_put(info);
2101
2102 return rc;
2103 }
2104
2105 static int idecd_release(struct inode * inode, struct file * file)
2106 {
2107 struct gendisk *disk = inode->i_bdev->bd_disk;
2108 struct cdrom_info *info = ide_cd_g(disk);
2109
2110 cdrom_release (&info->devinfo, file);
2111
2112 ide_cd_put(info);
2113
2114 return 0;
2115 }
2116
2117 static int idecd_set_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2118 {
2119 struct packet_command cgc;
2120 char buffer[16];
2121 int stat;
2122 char spindown;
2123
2124 if (copy_from_user(&spindown, (void __user *)arg, sizeof(char)))
2125 return -EFAULT;
2126
2127 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2128
2129 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2130 if (stat)
2131 return stat;
2132
2133 buffer[11] = (buffer[11] & 0xf0) | (spindown & 0x0f);
2134 return cdrom_mode_select(cdi, &cgc);
2135 }
2136
2137 static int idecd_get_spindown(struct cdrom_device_info *cdi, unsigned long arg)
2138 {
2139 struct packet_command cgc;
2140 char buffer[16];
2141 int stat;
2142 char spindown;
2143
2144 init_cdrom_command(&cgc, buffer, sizeof(buffer), CGC_DATA_UNKNOWN);
2145
2146 stat = cdrom_mode_sense(cdi, &cgc, GPMODE_CDROM_PAGE, 0);
2147 if (stat)
2148 return stat;
2149
2150 spindown = buffer[11] & 0x0f;
2151 if (copy_to_user((void __user *)arg, &spindown, sizeof (char)))
2152 return -EFAULT;
2153 return 0;
2154 }
2155
2156 static int idecd_ioctl (struct inode *inode, struct file *file,
2157 unsigned int cmd, unsigned long arg)
2158 {
2159 struct block_device *bdev = inode->i_bdev;
2160 struct cdrom_info *info = ide_cd_g(bdev->bd_disk);
2161 int err;
2162
2163 switch (cmd) {
2164 case CDROMSETSPINDOWN:
2165 return idecd_set_spindown(&info->devinfo, arg);
2166 case CDROMGETSPINDOWN:
2167 return idecd_get_spindown(&info->devinfo, arg);
2168 default:
2169 break;
2170 }
2171
2172 err = generic_ide_ioctl(info->drive, file, bdev, cmd, arg);
2173 if (err == -EINVAL)
2174 err = cdrom_ioctl(file, &info->devinfo, inode, cmd, arg);
2175
2176 return err;
2177 }
2178
2179 static int idecd_media_changed(struct gendisk *disk)
2180 {
2181 struct cdrom_info *info = ide_cd_g(disk);
2182 return cdrom_media_changed(&info->devinfo);
2183 }
2184
2185 static int idecd_revalidate_disk(struct gendisk *disk)
2186 {
2187 struct cdrom_info *info = ide_cd_g(disk);
2188 struct request_sense sense;
2189
2190 ide_cd_read_toc(info->drive, &sense);
2191
2192 return 0;
2193 }
2194
2195 static struct block_device_operations idecd_ops = {
2196 .owner = THIS_MODULE,
2197 .open = idecd_open,
2198 .release = idecd_release,
2199 .ioctl = idecd_ioctl,
2200 .media_changed = idecd_media_changed,
2201 .revalidate_disk= idecd_revalidate_disk
2202 };
2203
2204 /* options */
2205 static char *ignore = NULL;
2206
2207 module_param(ignore, charp, 0400);
2208 MODULE_DESCRIPTION("ATAPI CD-ROM Driver");
2209
2210 static int ide_cd_probe(ide_drive_t *drive)
2211 {
2212 struct cdrom_info *info;
2213 struct gendisk *g;
2214 struct request_sense sense;
2215
2216 if (!strstr("ide-cdrom", drive->driver_req))
2217 goto failed;
2218 if (!drive->present)
2219 goto failed;
2220 if (drive->media != ide_cdrom && drive->media != ide_optical)
2221 goto failed;
2222 /* skip drives that we were told to ignore */
2223 if (ignore != NULL) {
2224 if (strstr(ignore, drive->name)) {
2225 printk(KERN_INFO "ide-cd: ignoring drive %s\n", drive->name);
2226 goto failed;
2227 }
2228 }
2229 if (drive->scsi) {
2230 printk(KERN_INFO "ide-cd: passing drive %s to ide-scsi emulation.\n", drive->name);
2231 goto failed;
2232 }
2233 info = kzalloc(sizeof(struct cdrom_info), GFP_KERNEL);
2234 if (info == NULL) {
2235 printk(KERN_ERR "%s: Can't allocate a cdrom structure\n", drive->name);
2236 goto failed;
2237 }
2238
2239 g = alloc_disk(1 << PARTN_BITS);
2240 if (!g)
2241 goto out_free_cd;
2242
2243 ide_init_disk(g, drive);
2244
2245 ide_proc_register_driver(drive, &ide_cdrom_driver);
2246
2247 kref_init(&info->kref);
2248
2249 info->drive = drive;
2250 info->driver = &ide_cdrom_driver;
2251 info->disk = g;
2252
2253 g->private_data = &info->driver;
2254
2255 drive->driver_data = info;
2256
2257 g->minors = 1;
2258 g->driverfs_dev = &drive->gendev;
2259 g->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE;
2260 if (ide_cdrom_setup(drive)) {
2261 ide_proc_unregister_driver(drive, &ide_cdrom_driver);
2262 ide_cd_release(&info->kref);
2263 goto failed;
2264 }
2265
2266 ide_cd_read_toc(drive, &sense);
2267 g->fops = &idecd_ops;
2268 g->flags |= GENHD_FL_REMOVABLE;
2269 add_disk(g);
2270 return 0;
2271
2272 out_free_cd:
2273 kfree(info);
2274 failed:
2275 return -ENODEV;
2276 }
2277
2278 static void __exit ide_cdrom_exit(void)
2279 {
2280 driver_unregister(&ide_cdrom_driver.gen_driver);
2281 }
2282
2283 static int __init ide_cdrom_init(void)
2284 {
2285 return driver_register(&ide_cdrom_driver.gen_driver);
2286 }
2287
2288 MODULE_ALIAS("ide:*m-cdrom*");
2289 MODULE_ALIAS("ide-cd");
2290 module_init(ide_cdrom_init);
2291 module_exit(ide_cdrom_exit);
2292 MODULE_LICENSE("GPL");
kernel source for telekom puls (alcatel/mediatek)