![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ide-cd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / block|
Return to ide-cd.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / block |
1.1 root 1: /*
2: * linux/drivers/block/ide-cd.c
3: *
4: * 1.00 Oct 31, 1994 -- Initial version.
5: * 1.01 Nov 2, 1994 -- Fixed problem with starting request in
6: * cdrom_check_status.
7: * 1.03 Nov 25, 1994 -- leaving unmask_intr[] as a user-setting (as for disks)
8: * (from mlord) -- minor changes to cdrom_setup()
9: * -- renamed ide_dev_s to ide_drive_t, enable irq on command
10: * 2.00 Nov 27, 1994 -- Generalize packet command interface;
11: * add audio ioctls.
12: * 2.01 Dec 3, 1994 -- Rework packet command interface to handle devices
13: * which send an interrupt when ready for a command.
14: * 2.02 Dec 11, 1994 -- Cache the TOC in the driver.
15: * Don't use SCMD_PLAYAUDIO_TI; it's not included
16: * in the current version of ATAPI.
17: * Try to use LBA instead of track or MSF addressing
18: * when possible.
19: * Don't wait for READY_STAT.
20: * 2.03 Jan 10, 1995 -- Rewrite block read routines to handle block sizes
21: * other than 2k and to move multiple sectors in a
22: * single transaction.
23: * 2.04 Apr 21, 1995 -- Add work-around for Creative Labs CD220E drives.
24: * Thanks to Nick Saw <[email protected]> for
25: * help in figuring this out. Ditto for Acer and
26: * Aztech drives, which seem to have the same problem.
27: * 2.04b May 30, 1995 -- Fix to match changes in ide.c version 3.16 -ml
28: * 2.05 Jun 8, 1995 -- Don't attempt to retry after an illegal request
29: * or data protect error.
30: * Use HWIF and DEV_HWIF macros as in ide.c.
31: * Always try to do a request_sense after
32: * a failed command.
33: * Include an option to give textual descriptions
34: * of ATAPI errors.
35: * Fix a bug in handling the sector cache which
36: * showed up if the drive returned data in 512 byte
37: * blocks (like Pioneer drives). Thanks to
38: * Richard Hirst <[email protected]> for diagnosing this.
39: * Properly supply the page number field in the
40: * MODE_SELECT command.
41: * PLAYAUDIO12 is broken on the Aztech; work around it.
42: * 2.05x Aug 11, 1995 -- lots of data structure renaming/restructuring in ide.c
43: * (my apologies to Scott, but now ide-cd.c is independent)
44: * 3.00 Aug 22, 1995 -- Implement CDROMMULTISESSION ioctl.
45: * Implement CDROMREADAUDIO ioctl (UNTESTED).
46: * Use input_ide_data() and output_ide_data().
47: * Add door locking.
48: * Fix usage count leak in cdrom_open, which happened
49: * when a read-write mount was attempted.
50: * Try to load the disk on open.
51: * Implement CDROMEJECT_SW ioctl (off by default).
52: * Read total cdrom capacity during open.
53: * Rearrange logic in cdrom_decode_status. Issue
54: * request sense commands for failed packet commands
55: * from here instead of from cdrom_queue_packet_command.
56: * Fix a race condition in retrieving error information.
57: * Suppress printing normal unit attention errors and
58: * some drive not ready errors.
59: * Implement CDROMVOLREAD ioctl.
60: * Implement CDROMREADMODE1/2 ioctls.
61: * Fix race condition in setting up interrupt handlers
62: * when the `serialize' option is used.
63: * 3.01 Sep 2, 1995 -- Fix ordering of reenabling interrupts in
64: * cdrom_queue_request.
65: * Another try at using ide_[input,output]_data.
66: * 3.02 Sep 16, 1995 -- Stick total disk capacity in partition table as well.
67: * Make VERBOSE_IDE_CD_ERRORS dump failed command again.
68: * Dump out more information for ILLEGAL REQUEST errs.
69: * Fix handling of errors occuring before the
70: * packet command is transferred.
71: * Fix transfers with odd bytelengths.
72: * 3.03 Oct 27, 1995 -- Some Creative drives have an id of just `CD'.
73: * `DCI-2S10' drives are broken too.
74: * 3.04 Nov 20, 1995 -- So are Vertos drives.
75: * 3.05 Dec 1, 1995 -- Changes to go with overhaul of ide.c and ide-tape.c
76: * 3.06 Dec 16, 1995 -- Add support needed for partitions.
77: * More workarounds for Vertos bugs (based on patches
78: * from Holger Dietze <[email protected]>).
79: * Try to eliminate byteorder assumptions.
80: * Use atapi_cdrom_subchnl struct definition.
81: * Add STANDARD_ATAPI compilation option.
82: * 3.07 Jan 29, 1996 -- More twiddling for broken drives: Sony 55D,
83: * Vertos 300.
84: * Add NO_DOOR_LOCKING configuration option.
85: * Handle drive_cmd requests w/NULL args (for hdparm -t).
86: * Work around sporadic Sony55e audio play problem.
87: * 3.07a Feb 11, 1996 -- check drive->id for NULL before dereferencing, to fix
88: * problem with "hde=cdrom" with no drive present. -ml
89: *
90: * NOTE: Direct audio reads will only work on some types of drive.
91: * So far, i've received reports of success for Sony and Toshiba drives.
92: *
93: * ATAPI cd-rom driver. To be used with ide.c.
94: *
95: * Copyright (C) 1994, 1995, 1996 scott snyder <[email protected]>
96: * May be copied or modified under the terms of the GNU General Public License
97: * (../../COPYING).
98: */
99:
100:
101: /***************************************************************************/
102:
103: #include <linux/types.h>
104: #include <linux/kernel.h>
105: #include <linux/delay.h>
106: #include <linux/timer.h>
107: #include <linux/malloc.h>
108: #include <linux/ioport.h>
109: #include <linux/interrupt.h>
110: #include <linux/blkdev.h>
111: #include <linux/errno.h>
112: #include <linux/hdreg.h>
113: #include <linux/cdrom.h>
114: #include <asm/irq.h>
115: #include <asm/io.h>
116: #include <asm/byteorder.h>
117: #include <asm/segment.h>
118: #ifdef __alpha__
119: # include <asm/unaligned.h>
120: #endif
121:
122: #include "ide.h"
123:
124:
125:
126: /* Turn this on to have the driver print out the meanings of the
127: ATAPI error codes. This will use up additional kernel-space
128: memory, though. */
129:
130: #ifndef VERBOSE_IDE_CD_ERRORS
131: #define VERBOSE_IDE_CD_ERRORS 0
132: #endif
133:
134:
135: /* Turning this on will remove code to work around various nonstandard
136: ATAPI implementations. If you know your drive follows the standard,
137: this will give you a slightly smaller kernel. */
138:
139: #ifndef STANDARD_ATAPI
140: #define STANDARD_ATAPI 0
141: #endif
142:
143:
144: /* Turning this on will disable the door-locking functionality.
145: This is apparently needed for supermount. */
146:
147: #ifndef NO_DOOR_LOCKING
148: #define NO_DOOR_LOCKING 0
149: #endif
150:
151:
152: /************************************************************************/
153:
154: #define SECTOR_SIZE 512
155: #define SECTOR_BITS 9
156: #define SECTORS_PER_FRAME (CD_FRAMESIZE / SECTOR_SIZE)
157:
158: #define MIN(a,b) ((a) < (b) ? (a) : (b))
159:
160: /* special command codes for strategy routine. */
161: #define PACKET_COMMAND 4315
162: #define REQUEST_SENSE_COMMAND 4316
163: #define RESET_DRIVE_COMMAND 4317
164:
165: /* Some ATAPI command opcodes (just like SCSI).
166: (Some other cdrom-specific codes are in cdrom.h.) */
167: #define TEST_UNIT_READY 0x00
168: #define REQUEST_SENSE 0x03
169: #define START_STOP 0x1b
170: #define ALLOW_MEDIUM_REMOVAL 0x1e
171: #define READ_CAPACITY 0x25
172: #define READ_10 0x28
173: #define MODE_SENSE_10 0x5a
174: #define MODE_SELECT_10 0x55
175: #define READ_CD 0xbe
176:
177:
178: /* ATAPI sense keys (mostly copied from scsi.h). */
179:
180: #define NO_SENSE 0x00
181: #define RECOVERED_ERROR 0x01
182: #define NOT_READY 0x02
183: #define MEDIUM_ERROR 0x03
184: #define HARDWARE_ERROR 0x04
185: #define ILLEGAL_REQUEST 0x05
186: #define UNIT_ATTENTION 0x06
187: #define DATA_PROTECT 0x07
188: #define ABORTED_COMMAND 0x0b
189: #define MISCOMPARE 0x0e
190:
191: /* We want some additional flags for cd-rom drives.
192: To save space in the ide_drive_t struct, use some fields which
193: doesn't make sense for cd-roms -- `bios_sect' and `bios_head'. */
194:
195: /* Configuration flags. These describe the capabilities of the drive.
196: They generally do not change after initialization, unless we learn
197: more about the drive from stuff failing. */
198: struct ide_cd_config_flags {
199: __u8 drq_interrupt : 1; /* Device sends an interrupt when ready
200: for a packet command. */
201: __u8 no_doorlock : 1; /* Drive cannot lock the door. */
202: #if ! STANDARD_ATAPI
203: __u8 no_playaudio12: 1; /* The PLAYAUDIO12 command is not supported. */
204:
205: __u8 no_lba_toc : 1; /* Drive cannot return TOC info in LBA format. */
206: __u8 playmsf_uses_bcd : 1; /* Drive uses BCD in PLAYAUDIO_MSF. */
207: __u8 old_readcd : 1; /* Drive uses old READ CD opcode. */
208: __u8 vertos_lossage: 1; /* Drive is a Vertos 300,
209: and likes to speak BCD. */
210: #endif /* not STANDARD_ATAPI */
211: __u8 reserved : 1;
212: };
213: #define CDROM_CONFIG_FLAGS(drive) ((struct ide_cd_config_flags *)&((drive)->bios_sect))
214:
215:
216: /* State flags. These give information about the current state of the
217: drive, and will change during normal operation. */
218: struct ide_cd_state_flags {
219: __u8 media_changed : 1; /* Driver has noticed a media change. */
220: __u8 toc_valid : 1; /* Saved TOC information is current. */
221: __u8 door_locked : 1; /* We think that the drive door is locked. */
222: __u8 eject_on_close: 1; /* Drive should eject when device is closed. */
223: __u8 reserved : 4;
224: };
225: #define CDROM_STATE_FLAGS(drive) ((struct ide_cd_state_flags *)&((drive)->bios_head))
226:
227:
228: #define SECTOR_BUFFER_SIZE CD_FRAMESIZE
229:
230:
231:
232: /****************************************************************************
233: * Routines to read and write data from/to the drive, using
234: * the routines input_ide_data() and output_ide_data() from ide.c.
235: *
236: * These routines will round up any request for an odd number of bytes,
237: * so if an odd bytecount is specified, be sure that there's at least one
238: * extra byte allocated for the buffer.
239: */
240:
241:
242: static inline
243: void cdrom_in_bytes (ide_drive_t *drive, void *buffer, uint bytecount)
244: {
245: ++bytecount;
246: ide_input_data (drive, buffer, bytecount / 4);
247: if ((bytecount & 0x03) >= 2)
248: {
249: insw (IDE_DATA_REG, ((byte *)buffer) + (bytecount & ~0x03), 1);
250: }
251: }
252:
253:
254: static inline
255: void cdrom_out_bytes (ide_drive_t *drive, void *buffer, uint bytecount)
256: {
257: ++bytecount;
258: ide_output_data (drive, buffer, bytecount / 4);
259: if ((bytecount & 0x03) >= 2)
260: {
261: outsw (IDE_DATA_REG, ((byte *)buffer) + (bytecount & ~0x03), 1);
262: }
263: }
264:
265:
266:
267: /****************************************************************************
268: * Descriptions of ATAPI error codes.
269: */
270:
271: #define ARY_LEN(a) ((sizeof(a) / sizeof(a[0])))
272:
273: #if VERBOSE_IDE_CD_ERRORS
274:
275: /* From Table 124 of the ATAPI 1.2 spec. */
276:
277: char *sense_key_texts[16] = {
278: "No sense data",
279: "Recovered error",
280: "Not ready",
281: "Medium error",
282: "Hardware error",
283: "Illegal request",
284: "Unit attention",
285: "Data protect",
286: "(reserved)",
287: "(reserved)",
288: "(reserved)",
289: "Aborted command",
290: "(reserved)",
291: "(reserved)",
292: "Miscompare",
293: "(reserved)",
294: };
295:
296:
297: /* From Table 125 of the ATAPI 1.2 spec. */
298:
299: struct {
300: short asc_ascq;
301: char *text;
302: } sense_data_texts[] = {
303: { 0x0000, "No additional sense information" },
304: { 0x0011, "Audio play operation in progress" },
305: { 0x0012, "Audio play operation paused" },
306: { 0x0013, "Audio play operation successfully completed" },
307: { 0x0014, "Audio play operation stopped due to error" },
308: { 0x0015, "No current audio status to return" },
309:
310: { 0x0200, "No seek complete" },
311:
312: { 0x0400, "Logical unit not ready - cause not reportable" },
313: { 0x0401, "Logical unit not ready - in progress (sic) of becoming ready" },
314: { 0x0402, "Logical unit not ready - initializing command required" },
315: { 0x0403, "Logical unit not ready - manual intervention required" },
316:
317: { 0x0600, "No reference position found" },
318:
319: { 0x0900, "Track following error" },
320: { 0x0901, "Tracking servo failure" },
321: { 0x0902, "Focus servo failure" },
322: { 0x0903, "Spindle servo failure" },
323:
324: { 0x1100, "Unrecovered read error" },
325: { 0x1106, "CIRC unrecovered error" },
326:
327: { 0x1500, "Random positioning error" },
328: { 0x1501, "Mechanical positioning error" },
329: { 0x1502, "Positioning error detected by read of medium" },
330:
331: { 0x1700, "Recovered data with no error correction applied" },
332: { 0x1701, "Recovered data with retries" },
333: { 0x1702, "Recovered data with positive head offset" },
334: { 0x1703, "Recovered data with negative head offset" },
335: { 0x1704, "Recovered data with retries and/or CIRC applied" },
336: { 0x1705, "Recovered data using previous sector ID" },
337:
338: { 0x1800, "Recovered data with error correction applied" },
339: { 0x1801, "Recovered data with error correction and retries applied" },
340: { 0x1802, "Recovered data - the data was auto-reallocated" },
341: { 0x1803, "Recovered data with CIRC" },
342: { 0x1804, "Recovered data with L-EC" },
343: { 0x1805, "Recovered data - recommend reassignment" },
344: { 0x1806, "Recovered data - recommend rewrite" },
345:
346: { 0x1a00, "Parameter list length error" },
347:
348: { 0x2000, "Invalid command operation code" },
349:
350: { 0x2100, "Logical block address out of range" },
351:
352: { 0x2400, "Invalid field in command packet" },
353:
354: { 0x2600, "Invalid field in parameter list" },
355: { 0x2601, "Parameter not supported" },
356: { 0x2602, "Parameter value invalid" },
357: { 0x2603, "Threshold parameters not supported" },
358:
359: { 0x2800, "Not ready to ready transition, medium may have changed" },
360:
361: { 0x2900, "Power on, reset or bus device reset occurred" },
362:
363: { 0x2a00, "Parameters changed" },
364: { 0x2a01, "Mode parameters changed" },
365:
366: { 0x3000, "Incompatible medium installed" },
367: { 0x3001, "Cannot read medium - unknown format" },
368: { 0x3002, "Cannot read medium - incompatible format" },
369:
370: { 0x3700, "Rounded parameter" },
371:
372: { 0x3900, "Saving parameters not supported" },
373:
374: { 0x3a00, "Medium not present" },
375:
376: { 0x3f00, "ATAPI CD-ROM drive operating conditions have changed" },
377: { 0x3f01, "Microcode has been changed" },
378: { 0x3f02, "Changed operating definition" },
379: { 0x3f03, "Inquiry data has changed" },
380:
381: { 0x4000, "Diagnostic failure on component (ASCQ)" },
382:
383: { 0x4400, "Internal ATAPI CD-ROM drive failure" },
384:
385: { 0x4e00, "Overlapped commands attempted" },
386:
387: { 0x5300, "Media load or eject failed" },
388: { 0x5302, "Medium removal prevented" },
389:
390: { 0x5700, "Unable to recover table of contents" },
391:
392: { 0x5a00, "Operator request or state change input (unspecified)" },
393: { 0x5a01, "Operator medium removal request" },
394:
395: { 0x5b00, "Threshold condition met" },
396:
397: { 0x5c00, "Status change" },
398:
399: { 0x6300, "End of user area encountered on this track" },
400:
401: { 0x6400, "Illegal mode for this track" },
402:
403: { 0xbf00, "Loss of streaming" },
404: };
405: #endif
406:
407:
408:
409: /****************************************************************************
410: * Generic packet command support and error handling routines.
411: */
412:
413:
414: static
415: void cdrom_analyze_sense_data (ide_drive_t *drive,
416: struct atapi_request_sense *reqbuf,
417: struct packet_command *failed_command)
418: {
419: /* Don't print not ready or unit attention errors for READ_SUBCHANNEL.
420: Workman (and probably other programs) uses this command to poll
421: the drive, and we don't want to fill the syslog with useless errors. */
422: if (failed_command &&
423: failed_command->c[0] == SCMD_READ_SUBCHANNEL &&
424: (reqbuf->sense_key == NOT_READY || reqbuf->sense_key == UNIT_ATTENTION))
425: return;
426:
427: #if VERBOSE_IDE_CD_ERRORS
428: {
429: int i;
430: char *s;
431: char buf[80];
432:
433: printk ("ATAPI device %s:\n", drive->name);
434:
435: printk (" Error code: 0x%02x\n", reqbuf->error_code);
436:
437: if (reqbuf->sense_key >= 0 &&
438: reqbuf->sense_key < ARY_LEN (sense_key_texts))
439: s = sense_key_texts[reqbuf->sense_key];
440: else
441: s = "(bad sense key)";
442:
443: printk (" Sense key: 0x%02x - %s\n", reqbuf->sense_key, s);
444:
445: if (reqbuf->asc == 0x40) {
446: sprintf (buf, "Diagnostic failure on component 0x%02x", reqbuf->ascq);
447: s = buf;
448: }
449:
450: else {
451: int lo, hi;
452: int key = (reqbuf->asc << 8);
453: if ( ! (reqbuf->ascq >= 0x80 && reqbuf->ascq <= 0xdd) )
454: key |= reqbuf->ascq;
455:
456: lo = 0;
457: hi = ARY_LEN (sense_data_texts);
458: s = NULL;
459:
460: while (hi > lo) {
461: int mid = (lo + hi) / 2;
462: if (sense_data_texts[mid].asc_ascq == key) {
463: s = sense_data_texts[mid].text;
464: break;
465: }
466: else if (sense_data_texts[mid].asc_ascq > key)
467: hi = mid;
468: else
469: lo = mid+1;
470: }
471: }
472:
473: if (s == NULL) {
474: if (reqbuf->asc > 0x80)
475: s = "(vendor-specific error)";
476: else
477: s = "(reserved error code)";
478: }
479:
480: printk (" Additional sense data: 0x%02x, 0x%02x - %s\n",
481: reqbuf->asc, reqbuf->ascq, s);
482:
483: if (failed_command != NULL) {
484: printk (" Failed packet command: ");
485: for (i=0; i<sizeof (failed_command->c); i++)
486: printk ("%02x ", failed_command->c[i]);
487: printk ("\n");
488: }
489:
490: if (reqbuf->sense_key == ILLEGAL_REQUEST &&
491: (reqbuf->sense_key_specific[0] & 0x80) != 0)
492: {
493: printk (" Error in %s byte %d",
494: (reqbuf->sense_key_specific[0] & 0x40) != 0
495: ? "command packet"
496: : "command data",
497: (reqbuf->sense_key_specific[1] << 8) +
498: reqbuf->sense_key_specific[2]);
499:
500: if ((reqbuf->sense_key_specific[0] & 0x40) != 0)
501: {
502: printk (" bit %d", reqbuf->sense_key_specific[0] & 0x07);
503: }
504:
505: printk ("\n");
506: }
507: }
508:
509: #else
510:
511: /* Suppress printing unit attention and `in progress of becoming ready'
512: errors when we're not being verbose. */
513:
514: if (reqbuf->sense_key == UNIT_ATTENTION ||
515: (reqbuf->sense_key == NOT_READY && (reqbuf->asc == 4 ||
516: reqbuf->asc == 0x3a)))
517: return;
518:
519: printk ("%s: code: 0x%02x key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
520: drive->name,
521: reqbuf->error_code, reqbuf->sense_key, reqbuf->asc, reqbuf->ascq);
522: #endif
523: }
524:
525:
526: /* Fix up a possibly partially-processed request so that we can
527: start it over entirely, or even put it back on the request queue. */
528: static void restore_request (struct request *rq)
529: {
530: if (rq->buffer != rq->bh->b_data)
531: {
532: int n = (rq->buffer - rq->bh->b_data) / SECTOR_SIZE;
533: rq->buffer = rq->bh->b_data;
534: rq->nr_sectors += n;
535: rq->sector -= n;
536: }
537: rq->current_nr_sectors = rq->bh->b_size >> SECTOR_BITS;
538: }
539:
540:
541: static void cdrom_queue_request_sense (ide_drive_t *drive,
542: struct semaphore *sem,
543: struct atapi_request_sense *reqbuf,
544: struct packet_command *failed_command)
545: {
546: struct request *rq;
547: struct packet_command *pc;
548: int len;
549:
550: /* If the request didn't explicitly specify where to put the sense data,
551: use the statically allocated structure. */
552: if (reqbuf == NULL)
553: reqbuf = &drive->cdrom_info.sense_data;
554:
555: /* Make up a new request to retrieve sense information. */
556:
557: pc = &HWIF(drive)->request_sense_pc;
558: memset (pc, 0, sizeof (*pc));
559:
560: /* The request_sense structure has an odd number of (16-bit) words,
561: which won't work well with 32-bit transfers. However, we don't care
562: about the last two bytes, so just truncate the structure down
563: to an even length. */
564: len = sizeof (*reqbuf) / 4;
565: len *= 4;
566:
567: pc->c[0] = REQUEST_SENSE;
568: pc->c[4] = len;
569: pc->buffer = (char *)reqbuf;
570: pc->buflen = len;
571: pc->sense_data = (struct atapi_request_sense *)failed_command;
572:
573: /* stuff the sense request in front of our current request */
574:
575: rq = &HWIF(drive)->request_sense_request;
576: ide_init_drive_cmd (rq);
577: rq->cmd = REQUEST_SENSE_COMMAND;
578: rq->buffer = (char *)pc;
579: rq->sem = sem;
580: (void) ide_do_drive_cmd (drive, rq, ide_preempt);
581: }
582:
583:
584: static void cdrom_end_request (int uptodate, ide_drive_t *drive)
585: {
586: struct request *rq = HWGROUP(drive)->rq;
587:
588: /* The code in blk.h can screw us up on error recovery if the block
589: size is larger than 1k. Fix that up here. */
590: if (!uptodate && rq->bh != 0)
591: {
592: int adj = rq->current_nr_sectors - 1;
593: rq->current_nr_sectors -= adj;
594: rq->sector += adj;
595: }
596:
597: if (rq->cmd == REQUEST_SENSE_COMMAND && uptodate)
598: {
599: struct packet_command *pc = (struct packet_command *)rq->buffer;
600: cdrom_analyze_sense_data (drive,
601: (struct atapi_request_sense *)(pc->buffer - pc->c[4]),
602: (struct packet_command *)pc->sense_data);
603: }
604:
605: ide_end_request (uptodate, HWGROUP(drive));
606: }
607:
608:
609: /* Mark that we've seen a media change, and invalidate our internal
610: buffers. */
611: static void cdrom_saw_media_change (ide_drive_t *drive)
612: {
613: CDROM_STATE_FLAGS (drive)->media_changed = 1;
614: CDROM_STATE_FLAGS (drive)->toc_valid = 0;
615: drive->cdrom_info.nsectors_buffered = 0;
616: }
617:
618:
619: /* Returns 0 if the request should be continued.
620: Returns 1 if the request was ended. */
621: static int cdrom_decode_status (ide_drive_t *drive, int good_stat, int *stat_ret)
622: {
623: struct request *rq = HWGROUP(drive)->rq;
624: int stat, err, sense_key, cmd;
625:
626: /* Check for errors. */
627: stat = GET_STAT();
628: *stat_ret = stat;
629:
630: if (OK_STAT (stat, good_stat, BAD_R_STAT))
631: return 0;
632:
633: /* Got an error. */
634: err = IN_BYTE (IDE_ERROR_REG);
635: sense_key = err >> 4;
636:
637: if (rq == NULL)
638: printk ("%s : missing request in cdrom_decode_status\n", drive->name);
639: else
640: {
641: cmd = rq->cmd;
642:
643: if (cmd == REQUEST_SENSE_COMMAND)
644: {
645: /* We got an error trying to get sense info from the drive
646: (probably while trying to recover from a former error).
647: Just give up. */
648:
649: struct packet_command *pc = (struct packet_command *)rq->buffer;
650: pc->stat = 1;
651: cdrom_end_request (1, drive);
652: ide_error (drive, "request sense failure", stat);
653: return 1;
654: }
655:
656: else if (cmd == PACKET_COMMAND)
657: {
658: /* All other functions, except for READ. */
659:
660: struct packet_command *pc = (struct packet_command *)rq->buffer;
661: struct semaphore *sem = NULL;
662:
663: /* Check for tray open. */
664: if (sense_key == NOT_READY)
665: {
666: cdrom_saw_media_change (drive);
667:
668: /* Print an error message to the syslog.
669: Exception: don't print anything if this is a read subchannel
670: command. This is because workman constantly polls the drive
671: with this command, and we don't want to uselessly fill up
672: the syslog. */
673: if (pc->c[0] != SCMD_READ_SUBCHANNEL)
674: printk ("%s : tray open or drive not ready\n", drive->name);
675: }
676:
677: /* Check for media change. */
678: else if (sense_key == UNIT_ATTENTION)
679: {
680: cdrom_saw_media_change (drive);
681: printk ("%s: media changed\n", drive->name);
682: }
683:
684: /* Otherwise, print an error. */
685: else
686: {
687: ide_dump_status (drive, "packet command error", stat);
688: }
689:
690: /* Set the error flag and complete the request.
691: Then, if we have a CHECK CONDITION status, queue a request
692: sense command. We must be careful, though: we don't want
693: the thread in cdrom_queue_packet_command to wake up until
694: the request sense has completed. We do this by transferring
695: the semaphore from the packet command request to the
696: request sense request. */
697:
698: if ((stat & ERR_STAT) != 0)
699: {
700: sem = rq->sem;
701: rq->sem = NULL;
702: }
703:
704: pc->stat = 1;
705: cdrom_end_request (1, drive);
706:
707: if ((stat & ERR_STAT) != 0)
708: cdrom_queue_request_sense (drive, sem, pc->sense_data, pc);
709: }
710:
711: else
712: {
713: /* Handle errors from READ requests. */
714:
715: /* Check for tray open. */
716: if (sense_key == NOT_READY)
717: {
718: cdrom_saw_media_change (drive);
719:
720: /* Fail the request. */
721: printk ("%s : tray open\n", drive->name);
722: cdrom_end_request (0, drive);
723: }
724:
725: /* Check for media change. */
726: else if (sense_key == UNIT_ATTENTION)
727: {
728: cdrom_saw_media_change (drive);
729:
730: /* Arrange to retry the request.
731: But be sure to give up if we've retried too many times. */
732: if (++rq->errors > ERROR_MAX)
733: {
734: cdrom_end_request (0, drive);
735: }
736: }
737: /* No point in retrying after an illegal request or
738: data protect error.*/
739: else if (sense_key == ILLEGAL_REQUEST || sense_key == DATA_PROTECT)
740: {
741: ide_dump_status (drive, "command error", stat);
742: cdrom_end_request (0, drive);
743: }
744:
745: /* If there were other errors, go to the default handler. */
746: else if ((err & ~ABRT_ERR) != 0)
747: {
748: ide_error (drive, "cdrom_decode_status", stat);
749: return 1;
750: }
751:
752: /* Else, abort if we've racked up too many retries. */
753: else if ((++rq->errors > ERROR_MAX))
754: {
755: cdrom_end_request (0, drive);
756: }
757:
758: /* If we got a CHECK_CONDITION status, queue a request sense
759: command. */
760: if ((stat & ERR_STAT) != 0)
761: cdrom_queue_request_sense (drive, NULL, NULL, NULL);
762: }
763: }
764:
765: /* Retry, or handle the next request. */
766: return 1;
767: }
768:
769:
770: /* Set up the device registers for transferring a packet command on DEV,
771: expecting to later transfer XFERLEN bytes. HANDLER is the routine
772: which actually transfers the command to the drive. If this is a
773: drq_interrupt device, this routine will arrange for HANDLER to be
774: called when the interrupt from the drive arrives. Otherwise, HANDLER
775: will be called immediately after the drive is prepared for the transfer. */
776:
777: static int cdrom_start_packet_command (ide_drive_t *drive, int xferlen,
778: ide_handler_t *handler)
779: {
780: /* Wait for the controller to be idle. */
781: if (ide_wait_stat (drive, 0, BUSY_STAT, WAIT_READY)) return 1;
782:
783: /* Set up the controller registers. */
784: OUT_BYTE (0, IDE_FEATURE_REG);
785: OUT_BYTE (0, IDE_NSECTOR_REG);
786: OUT_BYTE (0, IDE_SECTOR_REG);
787:
788: OUT_BYTE (xferlen & 0xff, IDE_LCYL_REG);
789: OUT_BYTE (xferlen >> 8 , IDE_HCYL_REG);
790: OUT_BYTE (drive->ctl, IDE_CONTROL_REG);
791:
792: if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt)
793: {
794: ide_set_handler (drive, handler, WAIT_CMD);
795: OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
796: }
797: else
798: {
799: OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG); /* packet command */
800: (*handler) (drive);
801: }
802:
803: return 0;
804: }
805:
806:
807: /* Send a packet command to DRIVE described by CMD_BUF and CMD_LEN.
808: The device registers must have already been prepared
809: by cdrom_start_packet_command.
810: HANDLER is the interrupt handler to call when the command completes
811: or there's data ready. */
812: static int cdrom_transfer_packet_command (ide_drive_t *drive,
813: char *cmd_buf, int cmd_len,
814: ide_handler_t *handler)
815: {
816: if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt)
817: {
818: /* Here we should have been called after receiving an interrupt
819: from the device. DRQ should how be set. */
820: int stat_dum;
821:
822: /* Check for errors. */
823: if (cdrom_decode_status (drive, DRQ_STAT, &stat_dum)) return 1;
824: }
825: else
826: {
827: /* Otherwise, we must wait for DRQ to get set. */
828: if (ide_wait_stat (drive, DRQ_STAT, BUSY_STAT, WAIT_READY)) return 1;
829: }
830:
831: /* Arm the interrupt handler. */
832: ide_set_handler (drive, handler, WAIT_CMD);
833:
834: /* Send the command to the device. */
835: cdrom_out_bytes (drive, cmd_buf, cmd_len);
836:
837: return 0;
838: }
839:
840:
841:
842: /****************************************************************************
843: * Block read functions.
844: */
845:
846: /*
847: * Buffer up to SECTORS_TO_TRANSFER sectors from the drive in our sector
848: * buffer. Once the first sector is added, any subsequent sectors are
849: * assumed to be continuous (until the buffer is cleared). For the first
850: * sector added, SECTOR is its sector number. (SECTOR is then ignored until
851: * the buffer is cleared.)
852: */
853: static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
854: int sectors_to_transfer)
855: {
856: struct cdrom_info *info = &drive->cdrom_info;
857:
858: /* Number of sectors to read into the buffer. */
859: int sectors_to_buffer = MIN (sectors_to_transfer,
860: (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
861: info->nsectors_buffered);
862:
863: char *dest;
864:
865: /* If we don't yet have a sector buffer, try to allocate one.
866: If we can't get one atomically, it's not fatal -- we'll just throw
867: the data away rather than caching it. */
868: if (info->sector_buffer == NULL)
869: {
870: info->sector_buffer = (char *) kmalloc (SECTOR_BUFFER_SIZE, GFP_ATOMIC);
871:
872: /* If we couldn't get a buffer, don't try to buffer anything... */
873: if (info->sector_buffer == NULL)
874: sectors_to_buffer = 0;
875: }
876:
877: /* If this is the first sector in the buffer, remember its number. */
878: if (info->nsectors_buffered == 0)
879: info->sector_buffered = sector;
880:
881: /* Read the data into the buffer. */
882: dest = info->sector_buffer + info->nsectors_buffered * SECTOR_SIZE;
883: while (sectors_to_buffer > 0)
884: {
885: cdrom_in_bytes (drive, dest, SECTOR_SIZE);
886: --sectors_to_buffer;
887: --sectors_to_transfer;
888: ++info->nsectors_buffered;
889: dest += SECTOR_SIZE;
890: }
891:
892: /* Throw away any remaining data. */
893: while (sectors_to_transfer > 0)
894: {
895: char dum[SECTOR_SIZE];
896: cdrom_in_bytes (drive, dum, sizeof (dum));
897: --sectors_to_transfer;
898: }
899: }
900:
901:
902: /*
903: * Check the contents of the interrupt reason register from the cdrom
904: * and attempt to recover if there are problems. Returns 0 if everything's
905: * ok; nonzero if the request has been terminated.
906: */
907: static inline
908: int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
909: {
910: ireason &= 3;
911: if (ireason == 2) return 0;
912:
913: if (ireason == 0)
914: {
915: /* Whoops... The drive is expecting to receive data from us! */
916: printk ("%s: cdrom_read_intr: "
917: "Drive wants to transfer data the wrong way!\n",
918: drive->name);
919:
920: /* Throw some data at the drive so it doesn't hang
921: and quit this request. */
922: while (len > 0)
923: {
924: int dum = 0;
925: cdrom_out_bytes (drive, &dum, sizeof (dum));
926: len -= sizeof (dum);
927: }
928: }
929:
930: else
931: {
932: /* Drive wants a command packet, or invalid ireason... */
933: printk ("%s: cdrom_read_intr: bad interrupt reason %d\n",
934: drive->name, ireason);
935: }
936:
937: cdrom_end_request (0, drive);
938: return -1;
939: }
940:
941:
942: /*
943: * Interrupt routine. Called when a read request has completed.
944: */
945: static void cdrom_read_intr (ide_drive_t *drive)
946: {
947: int stat;
948: int ireason, len, sectors_to_transfer, nskip;
949:
950: struct request *rq = HWGROUP(drive)->rq;
951:
952: /* Check for errors. */
953: if (cdrom_decode_status (drive, 0, &stat)) return;
954:
955: /* Read the interrupt reason and the transfer length. */
956: ireason = IN_BYTE (IDE_NSECTOR_REG);
957: len = IN_BYTE (IDE_LCYL_REG) + 256 * IN_BYTE (IDE_HCYL_REG);
958:
959: /* If DRQ is clear, the command has completed. */
960: if ((stat & DRQ_STAT) == 0)
961: {
962: /* If we're not done filling the current buffer, complain.
963: Otherwise, complete the command normally. */
964: if (rq->current_nr_sectors > 0)
965: {
966: printk ("%s: cdrom_read_intr: data underrun (%ld blocks)\n",
967: drive->name, rq->current_nr_sectors);
968: cdrom_end_request (0, drive);
969: }
970: else
971: cdrom_end_request (1, drive);
972:
973: return;
974: }
975:
976: /* Check that the drive is expecting to do the same thing that we are. */
977: if (cdrom_read_check_ireason (drive, len, ireason)) return;
978:
979: /* Assume that the drive will always provide data in multiples of at least
980: SECTOR_SIZE, as it gets hairy to keep track of the transfers otherwise. */
981: if ((len % SECTOR_SIZE) != 0)
982: {
983: printk ("%s: cdrom_read_intr: Bad transfer size %d\n",
984: drive->name, len);
985: printk (" This drive is not supported by this version of the driver\n");
986: cdrom_end_request (0, drive);
987: return;
988: }
989:
990: /* The number of sectors we need to read from the drive. */
991: sectors_to_transfer = len / SECTOR_SIZE;
992:
993: /* First, figure out if we need to bit-bucket any of the leading sectors. */
994: nskip = MIN ((int)(rq->current_nr_sectors - (rq->bh->b_size >> SECTOR_BITS)),
995: sectors_to_transfer);
996:
997: while (nskip > 0)
998: {
999: /* We need to throw away a sector. */
1000: char dum[SECTOR_SIZE];
1001: cdrom_in_bytes (drive, dum, sizeof (dum));
1002:
1003: --rq->current_nr_sectors;
1004: --nskip;
1005: --sectors_to_transfer;
1006: }
1007:
1008: /* Now loop while we still have data to read from the drive. */
1009: while (sectors_to_transfer > 0)
1010: {
1011: int this_transfer;
1012:
1013: /* If we've filled the present buffer but there's another chained
1014: buffer after it, move on. */
1015: if (rq->current_nr_sectors == 0 &&
1016: rq->nr_sectors > 0)
1017: cdrom_end_request (1, drive);
1018:
1019: /* If the buffers are full, cache the rest of the data in our
1020: internal buffer. */
1021: if (rq->current_nr_sectors == 0)
1022: {
1023: cdrom_buffer_sectors (drive, rq->sector, sectors_to_transfer);
1024: sectors_to_transfer = 0;
1025: }
1026: else
1027: {
1028: /* Transfer data to the buffers.
1029: Figure out how many sectors we can transfer
1030: to the current buffer. */
1031: this_transfer = MIN (sectors_to_transfer,
1032: rq->current_nr_sectors);
1033:
1034: /* Read this_transfer sectors into the current buffer. */
1035: while (this_transfer > 0)
1036: {
1037: cdrom_in_bytes (drive, rq->buffer, SECTOR_SIZE);
1038: rq->buffer += SECTOR_SIZE;
1039: --rq->nr_sectors;
1040: --rq->current_nr_sectors;
1041: ++rq->sector;
1042: --this_transfer;
1043: --sectors_to_transfer;
1044: }
1045: }
1046: }
1047:
1048: /* Done moving data!
1049: Wait for another interrupt. */
1050: ide_set_handler (drive, &cdrom_read_intr, WAIT_CMD);
1051: }
1052:
1053:
1054: /*
1055: * Try to satisfy some of the current read request from our cached data.
1056: * Returns nonzero if the request has been completed, zero otherwise.
1057: */
1058: static int cdrom_read_from_buffer (ide_drive_t *drive)
1059: {
1060: struct cdrom_info *info = &drive->cdrom_info;
1061: struct request *rq = HWGROUP(drive)->rq;
1062:
1063: /* Can't do anything if there's no buffer. */
1064: if (info->sector_buffer == NULL) return 0;
1065:
1066: /* Loop while this request needs data and the next block is present
1067: in our cache. */
1068: while (rq->nr_sectors > 0 &&
1069: rq->sector >= info->sector_buffered &&
1070: rq->sector < info->sector_buffered + info->nsectors_buffered)
1071: {
1072: if (rq->current_nr_sectors == 0)
1073: cdrom_end_request (1, drive);
1074:
1075: memcpy (rq->buffer,
1076: info->sector_buffer +
1077: (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1078: SECTOR_SIZE);
1079: rq->buffer += SECTOR_SIZE;
1080: --rq->current_nr_sectors;
1081: --rq->nr_sectors;
1082: ++rq->sector;
1083: }
1084:
1085: /* If we've satisfied the current request, terminate it successfully. */
1086: if (rq->nr_sectors == 0)
1087: {
1088: cdrom_end_request (1, drive);
1089: return -1;
1090: }
1091:
1092: /* Move on to the next buffer if needed. */
1093: if (rq->current_nr_sectors == 0)
1094: cdrom_end_request (1, drive);
1095:
1096: /* If this condition does not hold, then the kluge i use to
1097: represent the number of sectors to skip at the start of a transfer
1098: will fail. I think that this will never happen, but let's be
1099: paranoid and check. */
1100: if (rq->current_nr_sectors < (rq->bh->b_size >> SECTOR_BITS) &&
1101: (rq->sector % SECTORS_PER_FRAME) != 0)
1102: {
1103: printk ("%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1104: drive->name, rq->sector);
1105: cdrom_end_request (0, drive);
1106: return -1;
1107: }
1108:
1109: return 0;
1110: }
1111:
1112:
1113:
1114: /*
1115: * Routine to send a read packet command to the drive.
1116: * This is usually called directly from cdrom_start_read.
1117: * However, for drq_interrupt devices, it is called from an interrupt
1118: * when the drive is ready to accept the command.
1119: */
1120: static void cdrom_start_read_continuation (ide_drive_t *drive)
1121: {
1122: struct packet_command pc;
1123: struct request *rq = HWGROUP(drive)->rq;
1124:
1125: int nsect, sector, nframes, frame, nskip;
1126:
1127: /* Number of sectors to transfer. */
1128: nsect = rq->nr_sectors;
1129:
1130: /* Starting sector. */
1131: sector = rq->sector;
1132:
1133: /* If the requested sector doesn't start on a cdrom block boundary,
1134: we must adjust the start of the transfer so that it does,
1135: and remember to skip the first few sectors. If the CURRENT_NR_SECTORS
1136: field is larger than the size of the buffer, it will mean that
1137: we're to skip a number of sectors equal to the amount by which
1138: CURRENT_NR_SECTORS is larger than the buffer size. */
1139: nskip = (sector % SECTORS_PER_FRAME);
1140: if (nskip > 0)
1141: {
1142: /* Sanity check... */
1143: if (rq->current_nr_sectors != (rq->bh->b_size >> SECTOR_BITS))
1144: {
1145: printk ("%s: cdrom_start_read_continuation: buffer botch (%ld)\n",
1146: drive->name, rq->current_nr_sectors);
1147: cdrom_end_request (0, drive);
1148: return;
1149: }
1150:
1151: sector -= nskip;
1152: nsect += nskip;
1153: rq->current_nr_sectors += nskip;
1154: }
1155:
1156: /* Convert from sectors to cdrom blocks, rounding up the transfer
1157: length if needed. */
1158: nframes = (nsect + SECTORS_PER_FRAME-1) / SECTORS_PER_FRAME;
1159: frame = sector / SECTORS_PER_FRAME;
1160:
1161: /* Largest number of frames was can transfer at once is 64k-1. */
1162: nframes = MIN (nframes, 65535);
1163:
1164: /* Set up the command */
1165: memset (&pc.c, 0, sizeof (pc.c));
1166: pc.c[0] = READ_10;
1167: pc.c[7] = (nframes >> 8);
1168: pc.c[8] = (nframes & 0xff);
1169: #ifdef __alpha__
1170: stl_u (htonl (frame), (unsigned int *) &pc.c[2]);
1171: #else
1172: *(int *)(&pc.c[2]) = htonl (frame);
1173: #endif
1174:
1175: /* Send the command to the drive and return. */
1176: (void) cdrom_transfer_packet_command (drive, pc.c, sizeof (pc.c),
1177: &cdrom_read_intr);
1178: }
1179:
1180:
1181: /*
1182: * Start a read request from the CD-ROM.
1183: */
1184: static void cdrom_start_read (ide_drive_t *drive, unsigned int block)
1185: {
1186: struct request *rq = HWGROUP(drive)->rq;
1187: int minor = MINOR (rq->rq_dev);
1188:
1189: /* If the request is relative to a partition, fix it up to refer to the
1190: absolute address. */
1191: if ((minor & PARTN_MASK) != 0) {
1192: rq->sector = block;
1193: minor &= ~PARTN_MASK;
1194: rq->rq_dev = MKDEV (MAJOR(rq->rq_dev), minor);
1195: }
1196:
1197: /* We may be retrying this request after an error.
1198: Fix up any weirdness which might be present in the request packet. */
1199: restore_request (rq);
1200:
1201: /* Satisfy whatever we can of this request from our cached sector. */
1202: if (cdrom_read_from_buffer (drive))
1203: return;
1204:
1205: /* Clear the local sector buffer. */
1206: drive->cdrom_info.nsectors_buffered = 0;
1207:
1208: /* Start sending the read request to the drive. */
1209: cdrom_start_packet_command (drive, 32768, cdrom_start_read_continuation);
1210: }
1211:
1212:
1213:
1214:
1215: /****************************************************************************
1216: * Execute all other packet commands.
1217: */
1218:
1219: /* Forward declarations. */
1220: static int
1221: cdrom_lockdoor (ide_drive_t *drive, int lockflag,
1222: struct atapi_request_sense *reqbuf);
1223:
1224:
1225:
1226: /* Interrupt routine for packet command completion. */
1227: static void cdrom_pc_intr (ide_drive_t *drive)
1228: {
1229: int ireason, len, stat, thislen;
1230: struct request *rq = HWGROUP(drive)->rq;
1231: struct packet_command *pc = (struct packet_command *)rq->buffer;
1232:
1233: /* Check for errors. */
1234: if (cdrom_decode_status (drive, 0, &stat)) return;
1235:
1236: /* Read the interrupt reason and the transfer length. */
1237: ireason = IN_BYTE (IDE_NSECTOR_REG);
1238: len = IN_BYTE (IDE_LCYL_REG) + 256 * IN_BYTE (IDE_HCYL_REG);
1239:
1240: /* If DRQ is clear, the command has completed.
1241: Complain if we still have data left to transfer. */
1242: if ((stat & DRQ_STAT) == 0)
1243: {
1244: /* Some of the trailing request sense fields are optional, and
1245: some drives don't send them. Sigh. */
1246: if (pc->c[0] == REQUEST_SENSE && pc->buflen > 0 && pc->buflen <= 5) {
1247: while (pc->buflen > 0) {
1248: *pc->buffer++ = 0;
1249: --pc->buflen;
1250: }
1251: }
1252:
1253: if (pc->buflen == 0)
1254: cdrom_end_request (1, drive);
1255: else
1256: {
1257: printk ("%s: cdrom_pc_intr: data underrun %d\n",
1258: drive->name, pc->buflen);
1259: pc->stat = 1;
1260: cdrom_end_request (1, drive);
1261: }
1262: return;
1263: }
1264:
1265: /* Figure out how much data to transfer. */
1266: thislen = pc->buflen;
1267: if (thislen < 0) thislen = -thislen;
1268: if (thislen > len) thislen = len;
1269:
1270: /* The drive wants to be written to. */
1271: if ((ireason & 3) == 0)
1272: {
1273: /* Check that we want to write. */
1274: if (pc->buflen > 0)
1275: {
1276: printk ("%s: cdrom_pc_intr: Drive wants to transfer data the wrong way!\n",
1277: drive->name);
1278: pc->stat = 1;
1279: thislen = 0;
1280: }
1281:
1282: /* Transfer the data. */
1283: cdrom_out_bytes (drive, pc->buffer, thislen);
1284:
1285: /* If we haven't moved enough data to satisfy the drive,
1286: add some padding. */
1287: while (len > thislen)
1288: {
1289: int dum = 0;
1290: cdrom_out_bytes (drive, &dum, sizeof (dum));
1291: len -= sizeof (dum);
1292: }
1293:
1294: /* Keep count of how much data we've moved. */
1295: pc->buffer += thislen;
1296: pc->buflen += thislen;
1297: }
1298:
1299: /* Same drill for reading. */
1300: else if ((ireason & 3) == 2)
1301: {
1302: /* Check that we want to read. */
1303: if (pc->buflen < 0)
1304: {
1305: printk ("%s: cdrom_pc_intr: Drive wants to transfer data the wrong way!\n",
1306: drive->name);
1307: pc->stat = 1;
1308: thislen = 0;
1309: }
1310:
1311: /* Transfer the data. */
1312: cdrom_in_bytes (drive, pc->buffer, thislen);
1313:
1314: /* If we haven't moved enough data to satisfy the drive,
1315: add some padding. */
1316: while (len > thislen)
1317: {
1318: int dum = 0;
1319: cdrom_in_bytes (drive, &dum, sizeof (dum));
1320: len -= sizeof (dum);
1321: }
1322:
1323: /* Keep count of how much data we've moved. */
1324: pc->buffer += thislen;
1325: pc->buflen -= thislen;
1326: }
1327:
1328: else
1329: {
1330: printk ("%s: cdrom_pc_intr: The drive appears confused (ireason = 0x%2x)\n",
1331: drive->name, ireason);
1332: pc->stat = 1;
1333: }
1334:
1335: /* Now we wait for another interrupt. */
1336: ide_set_handler (drive, &cdrom_pc_intr, WAIT_CMD);
1337: }
1338:
1339:
1340: static void cdrom_do_pc_continuation (ide_drive_t *drive)
1341: {
1342: struct request *rq = HWGROUP(drive)->rq;
1343: struct packet_command *pc = (struct packet_command *)rq->buffer;
1344:
1345: /* Send the command to the drive and return. */
1346: cdrom_transfer_packet_command (drive, pc->c, sizeof (pc->c), &cdrom_pc_intr);
1347: }
1348:
1349:
1350: static void cdrom_do_packet_command (ide_drive_t *drive)
1351: {
1352: int len;
1353: struct request *rq = HWGROUP(drive)->rq;
1354: struct packet_command *pc = (struct packet_command *)rq->buffer;
1355:
1356: len = pc->buflen;
1357: if (len < 0) len = -len;
1358:
1359: pc->stat = 0;
1360:
1361: /* Start sending the command to the drive. */
1362: cdrom_start_packet_command (drive, len, cdrom_do_pc_continuation);
1363: }
1364:
1365: #ifndef MACH
1366: /* Sleep for TIME jiffies.
1367: Not to be called from an interrupt handler. */
1368: static
1369: void cdrom_sleep (int time)
1370: {
1371: current->state = TASK_INTERRUPTIBLE;
1372: current->timeout = jiffies + time;
1373: schedule ();
1374: }
1375: #endif
1376:
1377: static
1378: int cdrom_queue_packet_command (ide_drive_t *drive, struct packet_command *pc)
1379: {
1380: struct atapi_request_sense my_reqbuf;
1381: int retries = 10;
1382: struct request req;
1383:
1384: /* If our caller has not provided a place to stick any sense data,
1385: use our own area. */
1386: if (pc->sense_data == NULL)
1387: pc->sense_data = &my_reqbuf;
1388: pc->sense_data->sense_key = 0;
1389:
1390: /* Start of retry loop. */
1391: do {
1392: ide_init_drive_cmd (&req);
1393: req.cmd = PACKET_COMMAND;
1394: req.buffer = (char *)pc;
1395: (void) ide_do_drive_cmd (drive, &req, ide_wait);
1396:
1397: if (pc->stat != 0)
1398: {
1399: /* The request failed. Retry if it was due to a unit attention status
1400: (usually means media was changed). */
1401: struct atapi_request_sense *reqbuf = pc->sense_data;
1402:
1403: if (reqbuf->sense_key == UNIT_ATTENTION)
1404: ;
1405:
1406: /* Also retry if the drive is in the process of loading a disk.
1407: This time, however, wait a little between retries to give
1408: the drive time. */
1409: else if (reqbuf->sense_key == NOT_READY && reqbuf->asc == 4)
1410: {
1411: cdrom_sleep (HZ);
1412: }
1413:
1414: /* Otherwise, don't retry. */
1415: else
1416: retries = 0;
1417:
1418: --retries;
1419: }
1420:
1421: /* End of retry loop. */
1422: } while (pc->stat != 0 && retries >= 0);
1423:
1424:
1425: /* Return an error if the command failed. */
1426: if (pc->stat != 0)
1427: return -EIO;
1428:
1429: else
1430: {
1431: /* The command succeeded. If it was anything other than a request sense,
1432: eject, or door lock command, and we think that the door is presently
1433: unlocked, lock it again. (The door was probably unlocked via
1434: an explicit CDROMEJECT ioctl.) */
1435: if (CDROM_STATE_FLAGS (drive)->door_locked == 0 &&
1436: (pc->c[0] != REQUEST_SENSE &&
1437: pc->c[0] != ALLOW_MEDIUM_REMOVAL &&
1438: pc->c[0] != START_STOP))
1439: {
1440: (void) cdrom_lockdoor (drive, 1, NULL);
1441: }
1442: return 0;
1443: }
1444: }
1445:
1446:
1447:
1448: /****************************************************************************
1449: * drive_cmd handling.
1450: *
1451: * Most of the functions accessed via drive_cmd are not valid for ATAPI
1452: * devices. Only attempt to execute those which actually should be valid.
1453: */
1454:
1455: static
1456: void cdrom_do_drive_cmd (ide_drive_t *drive)
1457: {
1458: struct request *rq = HWGROUP(drive)->rq;
1459: byte *args = rq->buffer;
1460:
1461: if (args)
1462: {
1463: #if 0 /* This bit isn't done yet... */
1464: if (args[0] == WIN_SETFEATURES &&
1465: (args[2] == 0x66 || args[2] == 0xcc || args[2] == 0x02 ||
1466: args[2] == 0xdd || args[2] == 0x5d))
1467: {
1468: OUT_BYTE (args[2], io_base + IDE_FEATURE_OFFSET);
1469: <send cmd>
1470: }
1471: else
1472: #endif
1473: {
1474: printk ("%s: Unsupported drive command %02x %02x %02x\n",
1475: drive->name, args[0], args[1], args[2]);
1476: rq->errors = 1;
1477: }
1478: }
1479:
1480: cdrom_end_request (1, drive);
1481: }
1482:
1483:
1484:
1485: /****************************************************************************
1486: * cdrom driver request routine.
1487: */
1488:
1489: void ide_do_rw_cdrom (ide_drive_t *drive, unsigned long block)
1490: {
1491: struct request *rq = HWGROUP(drive)->rq;
1492:
1493: if (rq -> cmd == PACKET_COMMAND || rq -> cmd == REQUEST_SENSE_COMMAND)
1494: cdrom_do_packet_command (drive);
1495:
1496: else if (rq -> cmd == RESET_DRIVE_COMMAND)
1497: {
1498: cdrom_end_request (1, drive);
1499: ide_do_reset (drive);
1500: return;
1501: }
1502:
1503: else if (rq -> cmd == IDE_DRIVE_CMD)
1504: cdrom_do_drive_cmd (drive);
1505:
1506: else if (rq -> cmd != READ)
1507: {
1508: printk ("ide-cd: bad cmd %d\n", rq -> cmd);
1509: cdrom_end_request (0, drive);
1510: }
1511: else
1512: cdrom_start_read (drive, block);
1513: }
1514:
1515:
1516:
1517: /****************************************************************************
1518: * Ioctl handling.
1519: *
1520: * Routines which queue packet commands take as a final argument a pointer
1521: * to an atapi_request_sense struct. If execution of the command results
1522: * in an error with a CHECK CONDITION status, this structure will be filled
1523: * with the results of the subsequent request sense command. The pointer
1524: * can also be NULL, in which case no sense information is returned.
1525: */
1526:
1527: #if ! STANDARD_ATAPI
1528: static
1529: int bin2bcd (int x)
1530: {
1531: return (x%10) | ((x/10) << 4);
1532: }
1533:
1534:
1535: static
1536: int bcd2bin (int x)
1537: {
1538: return (x >> 4) * 10 + (x & 0x0f);
1539: }
1540: #endif /* not STANDARD_ATAPI */
1541:
1542:
1543: static inline
1544: void lba_to_msf (int lba, byte *m, byte *s, byte *f)
1545: {
1546: lba += CD_BLOCK_OFFSET;
1547: lba &= 0xffffff; /* negative lbas use only 24 bits */
1548: *m = lba / (CD_SECS * CD_FRAMES);
1549: lba %= (CD_SECS * CD_FRAMES);
1550: *s = lba / CD_FRAMES;
1551: *f = lba % CD_FRAMES;
1552: }
1553:
1554:
1555: static inline
1556: int msf_to_lba (byte m, byte s, byte f)
1557: {
1558: return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_BLOCK_OFFSET;
1559: }
1560:
1561:
1562: static int
1563: cdrom_check_status (ide_drive_t *drive,
1564: struct atapi_request_sense *reqbuf)
1565: {
1566: struct packet_command pc;
1567:
1568: memset (&pc, 0, sizeof (pc));
1569:
1570: pc.sense_data = reqbuf;
1571: pc.c[0] = TEST_UNIT_READY;
1572:
1573: return cdrom_queue_packet_command (drive, &pc);
1574: }
1575:
1576:
1577: /* Lock the door if LOCKFLAG is nonzero; unlock it otherwise. */
1578: static int
1579: cdrom_lockdoor (ide_drive_t *drive, int lockflag,
1580: struct atapi_request_sense *reqbuf)
1581: {
1582: struct atapi_request_sense my_reqbuf;
1583: int stat;
1584: struct packet_command pc;
1585:
1586: if (reqbuf == NULL)
1587: reqbuf = &my_reqbuf;
1588:
1589: /* If the drive cannot lock the door, just pretend. */
1590: if (CDROM_CONFIG_FLAGS (drive)->no_doorlock)
1591: stat = 0;
1592: else
1593: {
1594: memset (&pc, 0, sizeof (pc));
1595: pc.sense_data = reqbuf;
1596:
1597: pc.c[0] = ALLOW_MEDIUM_REMOVAL;
1598: pc.c[4] = (lockflag != 0);
1599: stat = cdrom_queue_packet_command (drive, &pc);
1600: }
1601:
1602: if (stat == 0)
1603: CDROM_STATE_FLAGS (drive)->door_locked = lockflag;
1604: else
1605: {
1606: /* If we got an illegal field error, the drive
1607: probably cannot lock the door. */
1608: if (reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x24)
1609: {
1610: printk ("%s: door locking not supported\n", drive->name);
1611: CDROM_CONFIG_FLAGS (drive)->no_doorlock = 1;
1612: stat = 0;
1613: CDROM_STATE_FLAGS (drive)->door_locked = lockflag;
1614: }
1615: }
1616: return stat;
1617: }
1618:
1619:
1620: /* Eject the disk if EJECTFLAG is 0.
1621: If EJECTFLAG is 1, try to reload the disk. */
1622: static int
1623: cdrom_eject (ide_drive_t *drive, int ejectflag,
1624: struct atapi_request_sense *reqbuf)
1625: {
1626: struct packet_command pc;
1627:
1628: memset (&pc, 0, sizeof (pc));
1629: pc.sense_data = reqbuf;
1630:
1631: pc.c[0] = START_STOP;
1632: pc.c[4] = 2 + (ejectflag != 0);
1633: return cdrom_queue_packet_command (drive, &pc);
1634: }
1635:
1636:
1637: static int
1638: cdrom_pause (ide_drive_t *drive, int pauseflag,
1639: struct atapi_request_sense *reqbuf)
1640: {
1641: struct packet_command pc;
1642:
1643: memset (&pc, 0, sizeof (pc));
1644: pc.sense_data = reqbuf;
1645:
1646: pc.c[0] = SCMD_PAUSE_RESUME;
1647: pc.c[8] = !pauseflag;
1648: return cdrom_queue_packet_command (drive, &pc);
1649: }
1650:
1651:
1652: static int
1653: cdrom_startstop (ide_drive_t *drive, int startflag,
1654: struct atapi_request_sense *reqbuf)
1655: {
1656: struct packet_command pc;
1657:
1658: memset (&pc, 0, sizeof (pc));
1659: pc.sense_data = reqbuf;
1660:
1661: pc.c[0] = START_STOP;
1662: pc.c[1] = 1;
1663: pc.c[4] = startflag;
1664: return cdrom_queue_packet_command (drive, &pc);
1665: }
1666:
1667:
1668: static int
1669: cdrom_read_capacity (ide_drive_t *drive, unsigned *capacity,
1670: struct atapi_request_sense *reqbuf)
1671: {
1672: struct {
1673: unsigned lba;
1674: unsigned blocklen;
1675: } capbuf;
1676:
1677: int stat;
1678: struct packet_command pc;
1679:
1680: memset (&pc, 0, sizeof (pc));
1681: pc.sense_data = reqbuf;
1682:
1683: pc.c[0] = READ_CAPACITY;
1684: pc.buffer = (char *)&capbuf;
1685: pc.buflen = sizeof (capbuf);
1686:
1687: stat = cdrom_queue_packet_command (drive, &pc);
1688: if (stat == 0)
1689: {
1690: *capacity = ntohl (capbuf.lba);
1691: }
1692:
1693: return stat;
1694: }
1695:
1696:
1697: static int
1698: cdrom_read_tocentry (ide_drive_t *drive, int trackno, int msf_flag,
1699: int format, char *buf, int buflen,
1700: struct atapi_request_sense *reqbuf)
1701: {
1702: struct packet_command pc;
1703:
1704: memset (&pc, 0, sizeof (pc));
1705: pc.sense_data = reqbuf;
1706:
1707: pc.buffer = buf;
1708: pc.buflen = buflen;
1709: pc.c[0] = SCMD_READ_TOC;
1710: pc.c[6] = trackno;
1711: pc.c[7] = (buflen >> 8);
1712: pc.c[8] = (buflen & 0xff);
1713: pc.c[9] = (format << 6);
1714: if (msf_flag) pc.c[1] = 2;
1715: return cdrom_queue_packet_command (drive, &pc);
1716: }
1717:
1718:
1719: /* Try to read the entire TOC for the disk into our internal buffer. */
1720: static int
1721: cdrom_read_toc (ide_drive_t *drive,
1722: struct atapi_request_sense *reqbuf)
1723: {
1724: int msf_flag;
1725: int stat, ntracks, i;
1726: struct atapi_toc *toc = drive->cdrom_info.toc;
1727: struct {
1728: struct atapi_toc_header hdr;
1729: struct atapi_toc_entry ent;
1730: } ms_tmp;
1731:
1732: if (toc == NULL)
1733: {
1734: /* Try to allocate space. */
1735: toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
1736: GFP_KERNEL);
1737: drive->cdrom_info.toc = toc;
1738: }
1739:
1740: if (toc == NULL)
1741: {
1742: printk ("%s: No cdrom TOC buffer!\n", drive->name);
1743: return -EIO;
1744: }
1745:
1746: /* Check to see if the existing data is still valid.
1747: If it is, just return. */
1748: if (CDROM_STATE_FLAGS (drive)->toc_valid)
1749: (void) cdrom_check_status (drive, NULL);
1750:
1751: if (CDROM_STATE_FLAGS (drive)->toc_valid) return 0;
1752:
1753: #if STANDARD_ATAPI
1754: msf_flag = 0;
1755: #else /* not STANDARD_ATAPI */
1756: /* Some drives can't return TOC data in LBA format. */
1757: msf_flag = (CDROM_CONFIG_FLAGS (drive)->no_lba_toc);
1758: #endif /* not STANDARD_ATAPI */
1759:
1760: /* First read just the header, so we know how long the TOC is. */
1761: stat = cdrom_read_tocentry (drive, 0, msf_flag, 0, (char *)&toc->hdr,
1762: sizeof (struct atapi_toc_header) +
1763: sizeof (struct atapi_toc_entry),
1764: reqbuf);
1765: if (stat) return stat;
1766:
1767: #if ! STANDARD_ATAPI
1768: if (CDROM_CONFIG_FLAGS (drive)->vertos_lossage)
1769: {
1770: toc->hdr.first_track = bcd2bin (toc->hdr.first_track);
1771: toc->hdr.last_track = bcd2bin (toc->hdr.last_track);
1772: /* hopefully the length is not BCD, too ;-| */
1773: }
1774: #endif /* not STANDARD_ATAPI */
1775:
1776: ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1777: if (ntracks <= 0) return -EIO;
1778: if (ntracks > MAX_TRACKS) ntracks = MAX_TRACKS;
1779:
1780: /* Now read the whole schmeer. */
1781: stat = cdrom_read_tocentry (drive, 0, msf_flag, 0, (char *)&toc->hdr,
1782: sizeof (struct atapi_toc_header) +
1783: (ntracks+1) * sizeof (struct atapi_toc_entry),
1784: reqbuf);
1785: if (stat) return stat;
1786: toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
1787:
1788: #if ! STANDARD_ATAPI
1789: if (CDROM_CONFIG_FLAGS (drive)->vertos_lossage)
1790: {
1791: toc->hdr.first_track = bcd2bin (toc->hdr.first_track);
1792: toc->hdr.last_track = bcd2bin (toc->hdr.last_track);
1793: /* hopefully the length is not BCD, too ;-| */
1794: }
1795: #endif /* not STANDARD_ATAPI */
1796:
1797: for (i=0; i<=ntracks; i++)
1798: {
1799: #if ! STANDARD_ATAPI
1800: if (msf_flag)
1801: {
1802: if (CDROM_CONFIG_FLAGS (drive)->vertos_lossage)
1803: {
1804: toc->ent[i].track = bcd2bin (toc->ent[i].track);
1805: toc->ent[i].addr.msf.m = bcd2bin (toc->ent[i].addr.msf.m);
1806: toc->ent[i].addr.msf.s = bcd2bin (toc->ent[i].addr.msf.s);
1807: toc->ent[i].addr.msf.f = bcd2bin (toc->ent[i].addr.msf.f);
1808: }
1809: toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.m,
1810: toc->ent[i].addr.msf.s,
1811: toc->ent[i].addr.msf.f);
1812: }
1813: else
1814: #endif /* not STANDARD_ATAPI */
1815: toc->ent[i].addr.lba = ntohl (toc->ent[i].addr.lba);
1816: }
1817:
1818: /* Read the multisession information. */
1819: stat = cdrom_read_tocentry (drive, 0, msf_flag, 1,
1820: (char *)&ms_tmp, sizeof (ms_tmp),
1821: reqbuf);
1822: if (stat) return stat;
1823: #if ! STANDARD_ATAPI
1824: if (msf_flag)
1825: toc->last_session_lba = msf_to_lba (ms_tmp.ent.addr.msf.m,
1826: ms_tmp.ent.addr.msf.s,
1827: ms_tmp.ent.addr.msf.f);
1828: else
1829: #endif /* not STANDARD_ATAPI */
1830: toc->last_session_lba = ntohl (ms_tmp.ent.addr.lba);
1831:
1832: toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
1833:
1834: /* Now try to get the total cdrom capacity. */
1835: stat = cdrom_read_capacity (drive, &toc->capacity, reqbuf);
1836: if (stat) toc->capacity = 0x1fffff;
1837:
1838: HWIF(drive)->gd->sizes[drive->select.b.unit << PARTN_BITS]
1839: = toc->capacity * SECTORS_PER_FRAME;
1840: drive->part[0].nr_sects = toc->capacity * SECTORS_PER_FRAME;
1841:
1842: /* Remember that we've read this stuff. */
1843: CDROM_STATE_FLAGS (drive)->toc_valid = 1;
1844:
1845: return 0;
1846: }
1847:
1848:
1849: static int
1850: cdrom_read_subchannel (ide_drive_t *drive,
1851: char *buf, int buflen,
1852: struct atapi_request_sense *reqbuf)
1853: {
1854: struct packet_command pc;
1855:
1856: memset (&pc, 0, sizeof (pc));
1857: pc.sense_data = reqbuf;
1858:
1859: pc.buffer = buf;
1860: pc.buflen = buflen;
1861: pc.c[0] = SCMD_READ_SUBCHANNEL;
1862: pc.c[2] = 0x40; /* request subQ data */
1863: pc.c[3] = 0x01; /* Format 1: current position */
1864: pc.c[7] = (buflen >> 8);
1865: pc.c[8] = (buflen & 0xff);
1866: return cdrom_queue_packet_command (drive, &pc);
1867: }
1868:
1869:
1870: /* modeflag: 0 = current, 1 = changeable mask, 2 = default, 3 = saved */
1871: static int
1872: cdrom_mode_sense (ide_drive_t *drive, int pageno, int modeflag,
1873: char *buf, int buflen,
1874: struct atapi_request_sense *reqbuf)
1875: {
1876: struct packet_command pc;
1877:
1878: memset (&pc, 0, sizeof (pc));
1879: pc.sense_data = reqbuf;
1880:
1881: pc.buffer = buf;
1882: pc.buflen = buflen;
1883: pc.c[0] = MODE_SENSE_10;
1884: pc.c[2] = pageno | (modeflag << 6);
1885: pc.c[7] = (buflen >> 8);
1886: pc.c[8] = (buflen & 0xff);
1887: return cdrom_queue_packet_command (drive, &pc);
1888: }
1889:
1890:
1891: static int
1892: cdrom_mode_select (ide_drive_t *drive, int pageno, char *buf, int buflen,
1893: struct atapi_request_sense *reqbuf)
1894: {
1895: struct packet_command pc;
1896:
1897: memset (&pc, 0, sizeof (pc));
1898: pc.sense_data = reqbuf;
1899:
1900: pc.buffer = buf;
1901: pc.buflen = - buflen;
1902: pc.c[0] = MODE_SELECT_10;
1903: pc.c[1] = 0x10;
1904: pc.c[2] = pageno;
1905: pc.c[7] = (buflen >> 8);
1906: pc.c[8] = (buflen & 0xff);
1907: return cdrom_queue_packet_command (drive, &pc);
1908: }
1909:
1910:
1911: static int
1912: cdrom_play_lba_range_play12 (ide_drive_t *drive, int lba_start, int lba_end,
1913: struct atapi_request_sense *reqbuf)
1914: {
1915: struct packet_command pc;
1916:
1917: memset (&pc, 0, sizeof (pc));
1918: pc.sense_data = reqbuf;
1919:
1920: pc.c[0] = SCMD_PLAYAUDIO12;
1921: #ifdef __alpha__
1922: stq_u(((long) htonl (lba_end - lba_start) << 32) | htonl(lba_start),
1923: (unsigned long *) &pc.c[2]);
1924: #else
1925: *(int *)(&pc.c[2]) = htonl (lba_start);
1926: *(int *)(&pc.c[6]) = htonl (lba_end - lba_start);
1927: #endif
1928:
1929: return cdrom_queue_packet_command (drive, &pc);
1930: }
1931:
1932:
1933: #if ! STANDARD_ATAPI
1934: static int
1935: cdrom_play_lba_range_msf (ide_drive_t *drive, int lba_start, int lba_end,
1936: struct atapi_request_sense *reqbuf)
1937: {
1938: struct packet_command pc;
1939:
1940: memset (&pc, 0, sizeof (pc));
1941: pc.sense_data = reqbuf;
1942:
1943: pc.c[0] = SCMD_PLAYAUDIO_MSF;
1944: lba_to_msf (lba_start, &pc.c[3], &pc.c[4], &pc.c[5]);
1945: lba_to_msf (lba_end-1, &pc.c[6], &pc.c[7], &pc.c[8]);
1946:
1947: if (CDROM_CONFIG_FLAGS (drive)->playmsf_uses_bcd)
1948: {
1949: pc.c[3] = bin2bcd (pc.c[3]);
1950: pc.c[4] = bin2bcd (pc.c[4]);
1951: pc.c[5] = bin2bcd (pc.c[5]);
1952: pc.c[6] = bin2bcd (pc.c[6]);
1953: pc.c[7] = bin2bcd (pc.c[7]);
1954: pc.c[8] = bin2bcd (pc.c[8]);
1955: }
1956:
1957: return cdrom_queue_packet_command (drive, &pc);
1958: }
1959: #endif /* not STANDARD_ATAPI */
1960:
1961:
1962: static int
1963: cdrom_play_lba_range_1 (ide_drive_t *drive, int lba_start, int lba_end,
1964: struct atapi_request_sense *reqbuf)
1965: {
1966: /* This is rather annoying.
1967: My NEC-260 won't recognize group 5 commands such as PLAYAUDIO12;
1968: the only way to get it to play more than 64k of blocks at once
1969: seems to be the PLAYAUDIO_MSF command. However, the parameters
1970: the NEC 260 wants for the PLAYMSF command are incompatible with
1971: the new version of the spec.
1972:
1973: So what i'll try is this. First try for PLAYAUDIO12. If it works,
1974: great. Otherwise, if the drive reports an illegal command code,
1975: try PLAYAUDIO_MSF using the NEC 260-style bcd parameters. */
1976:
1977: #if ! STANDARD_ATAPI
1978: if (CDROM_CONFIG_FLAGS (drive)->no_playaudio12)
1979: return cdrom_play_lba_range_msf (drive, lba_start, lba_end, reqbuf);
1980: else
1981: #endif /* not STANDARD_ATAPI */
1982: {
1983: int stat;
1984: struct atapi_request_sense my_reqbuf;
1985:
1986: if (reqbuf == NULL)
1987: reqbuf = &my_reqbuf;
1988:
1989: stat = cdrom_play_lba_range_play12 (drive, lba_start, lba_end, reqbuf);
1990: if (stat == 0) return 0;
1991:
1992: #if ! STANDARD_ATAPI
1993: /* It failed. Try to find out why. */
1994: if (reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x20)
1995: {
1996: /* The drive didn't recognize the command.
1997: Retry with the MSF variant. */
1998: printk ("%s: Drive does not support PLAYAUDIO12; "
1999: "trying PLAYAUDIO_MSF\n", drive->name);
2000: CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 1;
2001: CDROM_CONFIG_FLAGS (drive)->playmsf_uses_bcd = 1;
2002: return cdrom_play_lba_range_msf (drive, lba_start, lba_end, reqbuf);
2003: }
2004: #endif /* not STANDARD_ATAPI */
2005:
2006: /* Failed for some other reason. Give up. */
2007: return stat;
2008: }
2009: }
2010:
2011:
2012: /* Play audio starting at LBA LBA_START and finishing with the
2013: LBA before LBA_END. */
2014: static int
2015: cdrom_play_lba_range (ide_drive_t *drive, int lba_start, int lba_end,
2016: struct atapi_request_sense *reqbuf)
2017: {
2018: int i, stat;
2019: struct atapi_request_sense my_reqbuf;
2020:
2021: if (reqbuf == NULL)
2022: reqbuf = &my_reqbuf;
2023:
2024: /* Some drives, will, for certain audio cds,
2025: give an error if you ask them to play the entire cd using the
2026: values which are returned in the TOC. The play will succeed, however,
2027: if the ending address is adjusted downwards by a few frames. */
2028: for (i=0; i<75; i++)
2029: {
2030: stat = cdrom_play_lba_range_1 (drive, lba_start, lba_end, reqbuf);
2031:
2032: if (stat == 0 ||
2033: !(reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x24))
2034: return stat;
2035:
2036: --lba_end;
2037: if (lba_end <= lba_start) break;
2038: }
2039:
2040: return stat;
2041: }
2042:
2043:
2044: static
2045: int cdrom_get_toc_entry (ide_drive_t *drive, int track,
2046: struct atapi_toc_entry **ent,
2047: struct atapi_request_sense *reqbuf)
2048: {
2049: int stat, ntracks;
2050: struct atapi_toc *toc;
2051:
2052: /* Make sure our saved TOC is valid. */
2053: stat = cdrom_read_toc (drive, reqbuf);
2054: if (stat) return stat;
2055:
2056: toc = drive->cdrom_info.toc;
2057:
2058: /* Check validity of requested track number. */
2059: ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
2060: if (track == CDROM_LEADOUT)
2061: *ent = &toc->ent[ntracks];
2062: else if (track < toc->hdr.first_track ||
2063: track > toc->hdr.last_track)
2064: return -EINVAL;
2065: else
2066: *ent = &toc->ent[track - toc->hdr.first_track];
2067:
2068: return 0;
2069: }
2070:
2071:
2072: static int
2073: cdrom_read_block (ide_drive_t *drive, int format, int lba,
2074: char *buf, int buflen,
2075: struct atapi_request_sense *reqbuf)
2076: {
2077: struct packet_command pc;
2078: struct atapi_request_sense my_reqbuf;
2079: int stat;
2080:
2081: if (reqbuf == NULL)
2082: reqbuf = &my_reqbuf;
2083:
2084: memset (&pc, 0, sizeof (pc));
2085: pc.sense_data = reqbuf;
2086:
2087: pc.buffer = buf;
2088: pc.buflen = buflen;
2089:
2090: #if ! STANDARD_ATAPI
2091: if (CDROM_CONFIG_FLAGS (drive)->old_readcd)
2092: pc.c[0] = 0xd4;
2093: else
2094: #endif /* not STANDARD_ATAPI */
2095: pc.c[0] = READ_CD;
2096:
2097: pc.c[1] = (format << 2);
2098: #ifdef __alpha__
2099: stl_u(htonl (lba), (unsigned int *) &pc.c[2]);
2100: #else
2101: *(int *)(&pc.c[2]) = htonl (lba);
2102: #endif
2103: pc.c[8] = 1; /* one block */
2104: pc.c[9] = 0x10;
2105:
2106: stat = cdrom_queue_packet_command (drive, &pc);
2107:
2108: #if ! STANDARD_ATAPI
2109: /* If the drive doesn't recognize the READ CD opcode, retry the command
2110: with an older opcode for that command. */
2111: if (stat && reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x20 &&
2112: CDROM_CONFIG_FLAGS (drive)->old_readcd == 0)
2113: {
2114: printk ("%s: Drive does not recognize READ_CD; trying opcode 0xd4\n",
2115: drive->name);
2116: CDROM_CONFIG_FLAGS (drive)->old_readcd = 1;
2117: return cdrom_read_block (drive, format, lba, buf, buflen, reqbuf);
2118: }
2119: #endif /* not STANDARD_ATAPI */
2120:
2121: return stat;
2122: }
2123:
2124:
2125: int ide_cdrom_ioctl (ide_drive_t *drive, struct inode *inode,
2126: struct file *file, unsigned int cmd, unsigned long arg)
2127: {
2128: switch (cmd)
2129: {
2130: case CDROMEJECT:
2131: {
2132: int stat;
2133:
2134: if (drive->usage > 1)
2135: return -EBUSY;
2136:
2137: stat = cdrom_lockdoor (drive, 0, NULL);
2138: if (stat) return stat;
2139:
2140: return cdrom_eject (drive, 0, NULL);
2141: }
2142:
2143: case CDROMEJECT_SW:
2144: {
2145: CDROM_STATE_FLAGS (drive)->eject_on_close = arg;
2146: return 0;
2147: }
2148:
2149: case CDROMPAUSE:
2150: return cdrom_pause (drive, 1, NULL);
2151:
2152: case CDROMRESUME:
2153: return cdrom_pause (drive, 0, NULL);
2154:
2155: case CDROMSTART:
2156: return cdrom_startstop (drive, 1, NULL);
2157:
2158: case CDROMSTOP:
2159: {
2160: int stat;
2161:
2162: stat = cdrom_startstop (drive, 0, NULL);
2163: if (stat) return stat;
2164: /* pit says the Dolphin needs this. */
2165: return cdrom_eject (drive, 1, NULL);
2166: }
2167:
2168: case CDROMPLAYMSF:
2169: {
2170: struct cdrom_msf msf;
2171: int stat, lba_start, lba_end;
2172:
2173: stat = verify_area (VERIFY_READ, (void *)arg, sizeof (msf));
2174: if (stat) return stat;
2175:
2176: memcpy_fromfs (&msf, (void *) arg, sizeof(msf));
2177:
2178: lba_start = msf_to_lba (msf.cdmsf_min0, msf.cdmsf_sec0,
2179: msf.cdmsf_frame0);
2180: lba_end = msf_to_lba (msf.cdmsf_min1, msf.cdmsf_sec1,
2181: msf.cdmsf_frame1) + 1;
2182:
2183: if (lba_end <= lba_start) return -EINVAL;
2184:
2185: return cdrom_play_lba_range (drive, lba_start, lba_end, NULL);
2186: }
2187:
2188: /* Like just about every other Linux cdrom driver, we ignore the
2189: index part of the request here. */
2190: case CDROMPLAYTRKIND:
2191: {
2192: int stat, lba_start, lba_end;
2193: struct cdrom_ti ti;
2194: struct atapi_toc_entry *first_toc, *last_toc;
2195:
2196: stat = verify_area (VERIFY_READ, (void *)arg, sizeof (ti));
2197: if (stat) return stat;
2198:
2199: memcpy_fromfs (&ti, (void *) arg, sizeof(ti));
2200:
2201: stat = cdrom_get_toc_entry (drive, ti.cdti_trk0, &first_toc, NULL);
2202: if (stat) return stat;
2203: stat = cdrom_get_toc_entry (drive, ti.cdti_trk1, &last_toc, NULL);
2204: if (stat) return stat;
2205:
2206: if (ti.cdti_trk1 != CDROM_LEADOUT) ++last_toc;
2207: lba_start = first_toc->addr.lba;
2208: lba_end = last_toc->addr.lba;
2209:
2210: if (lba_end <= lba_start) return -EINVAL;
2211:
2212: return cdrom_play_lba_range (drive, lba_start, lba_end, NULL);
2213: }
2214:
2215: case CDROMREADTOCHDR:
2216: {
2217: int stat;
2218: struct cdrom_tochdr tochdr;
2219: struct atapi_toc *toc;
2220:
2221: stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (tochdr));
2222: if (stat) return stat;
2223:
2224: /* Make sure our saved TOC is valid. */
2225: stat = cdrom_read_toc (drive, NULL);
2226: if (stat) return stat;
2227:
2228: toc = drive->cdrom_info.toc;
2229: tochdr.cdth_trk0 = toc->hdr.first_track;
2230: tochdr.cdth_trk1 = toc->hdr.last_track;
2231:
2232: memcpy_tofs ((void *) arg, &tochdr, sizeof (tochdr));
2233:
2234: return stat;
2235: }
2236:
2237: case CDROMREADTOCENTRY:
2238: {
2239: int stat;
2240: struct cdrom_tocentry tocentry;
2241: struct atapi_toc_entry *toce;
2242:
2243: stat = verify_area (VERIFY_READ, (void *) arg, sizeof (tocentry));
2244: if (stat) return stat;
2245: stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (tocentry));
2246: if (stat) return stat;
2247:
2248: memcpy_fromfs (&tocentry, (void *) arg, sizeof (tocentry));
2249:
2250: stat = cdrom_get_toc_entry (drive, tocentry.cdte_track, &toce, NULL);
2251: if (stat) return stat;
2252:
2253: tocentry.cdte_ctrl = toce->control;
2254: tocentry.cdte_adr = toce->adr;
2255:
2256: if (tocentry.cdte_format == CDROM_MSF)
2257: {
2258: /* convert to MSF */
2259: lba_to_msf (toce->addr.lba,
2260: &tocentry.cdte_addr.msf.minute,
2261: &tocentry.cdte_addr.msf.second,
2262: &tocentry.cdte_addr.msf.frame);
2263: }
2264: else
2265: tocentry.cdte_addr.lba = toce->addr.lba;
2266:
2267: memcpy_tofs ((void *) arg, &tocentry, sizeof (tocentry));
2268:
2269: return stat;
2270: }
2271:
2272: case CDROMSUBCHNL:
2273: {
2274: struct atapi_cdrom_subchnl scbuf;
2275: int stat, abs_lba, rel_lba;
2276: struct cdrom_subchnl subchnl;
2277:
2278: stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (subchnl));
2279: if (stat) return stat;
2280: stat = verify_area (VERIFY_READ, (void *) arg, sizeof (subchnl));
2281: if (stat) return stat;
2282:
2283: memcpy_fromfs (&subchnl, (void *) arg, sizeof (subchnl));
2284:
2285: stat = cdrom_read_subchannel (drive, (char *)&scbuf, sizeof (scbuf),
2286: NULL);
2287: if (stat) return stat;
2288:
2289: #if ! STANDARD_ATAPI
2290: if (CDROM_CONFIG_FLAGS (drive)->vertos_lossage)
2291: {
2292: abs_lba = msf_to_lba (bcd2bin (scbuf.acdsc_absaddr.msf.minute),
2293: bcd2bin (scbuf.acdsc_absaddr.msf.second),
2294: bcd2bin (scbuf.acdsc_absaddr.msf.frame));
2295: rel_lba = msf_to_lba (bcd2bin (scbuf.acdsc_reladdr.msf.minute),
2296: bcd2bin (scbuf.acdsc_reladdr.msf.second),
2297: bcd2bin (scbuf.acdsc_reladdr.msf.frame));
2298: scbuf.acdsc_trk = bcd2bin (scbuf.acdsc_trk);
2299: }
2300: else
2301: #endif /* not STANDARD_ATAPI */
2302: {
2303: abs_lba = ntohl (scbuf.acdsc_absaddr.lba);
2304: rel_lba = ntohl (scbuf.acdsc_reladdr.lba);
2305: }
2306:
2307: if (subchnl.cdsc_format == CDROM_MSF)
2308: {
2309: lba_to_msf (abs_lba,
2310: &subchnl.cdsc_absaddr.msf.minute,
2311: &subchnl.cdsc_absaddr.msf.second,
2312: &subchnl.cdsc_absaddr.msf.frame);
2313: lba_to_msf (rel_lba,
2314: &subchnl.cdsc_reladdr.msf.minute,
2315: &subchnl.cdsc_reladdr.msf.second,
2316: &subchnl.cdsc_reladdr.msf.frame);
2317: }
2318: else
2319: {
2320: subchnl.cdsc_absaddr.lba = abs_lba;
2321: subchnl.cdsc_reladdr.lba = rel_lba;
2322: }
2323:
2324: subchnl.cdsc_audiostatus = scbuf.acdsc_audiostatus;
2325: subchnl.cdsc_ctrl = scbuf.acdsc_ctrl;
2326: subchnl.cdsc_trk = scbuf.acdsc_trk;
2327: subchnl.cdsc_ind = scbuf.acdsc_ind;
2328:
2329: memcpy_tofs ((void *) arg, &subchnl, sizeof (subchnl));
2330:
2331: return stat;
2332: }
2333:
2334: case CDROMVOLCTRL:
2335: {
2336: struct cdrom_volctrl volctrl;
2337: char buffer[24], mask[24];
2338: int stat;
2339:
2340: stat = verify_area (VERIFY_READ, (void *) arg, sizeof (volctrl));
2341: if (stat) return stat;
2342: memcpy_fromfs (&volctrl, (void *) arg, sizeof (volctrl));
2343:
2344: stat = cdrom_mode_sense (drive, 0x0e, 0, buffer, sizeof (buffer),NULL);
2345: if (stat) return stat;
2346: stat = cdrom_mode_sense (drive, 0x0e, 1, mask , sizeof (buffer),NULL);
2347: if (stat) return stat;
2348:
2349: buffer[1] = buffer[2] = 0;
2350:
2351: buffer[17] = volctrl.channel0 & mask[17];
2352: buffer[19] = volctrl.channel1 & mask[19];
2353: buffer[21] = volctrl.channel2 & mask[21];
2354: buffer[23] = volctrl.channel3 & mask[23];
2355:
2356: return cdrom_mode_select (drive, 0x0e, buffer, sizeof (buffer), NULL);
2357: }
2358:
2359: case CDROMVOLREAD:
2360: {
2361: struct cdrom_volctrl volctrl;
2362: char buffer[24];
2363: int stat;
2364:
2365: stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (volctrl));
2366: if (stat) return stat;
2367:
2368: stat = cdrom_mode_sense (drive, 0x0e, 0, buffer, sizeof (buffer), NULL);
2369: if (stat) return stat;
2370:
2371: volctrl.channel0 = buffer[17];
2372: volctrl.channel1 = buffer[19];
2373: volctrl.channel2 = buffer[21];
2374: volctrl.channel3 = buffer[23];
2375:
2376: memcpy_tofs ((void *) arg, &volctrl, sizeof (volctrl));
2377:
2378: return 0;
2379: }
2380:
2381: case CDROMMULTISESSION:
2382: {
2383: struct cdrom_multisession ms_info;
2384: struct atapi_toc *toc;
2385: int stat;
2386:
2387: stat = verify_area (VERIFY_READ, (void *)arg, sizeof (ms_info));
2388: if (stat) return stat;
2389: stat = verify_area (VERIFY_WRITE, (void *)arg, sizeof (ms_info));
2390: if (stat) return stat;
2391:
2392: memcpy_fromfs (&ms_info, (void *)arg, sizeof (ms_info));
2393:
2394: /* Make sure the TOC information is valid. */
2395: stat = cdrom_read_toc (drive, NULL);
2396: if (stat) return stat;
2397:
2398: toc = drive->cdrom_info.toc;
2399:
2400: if (ms_info.addr_format == CDROM_MSF)
2401: lba_to_msf (toc->last_session_lba,
2402: &ms_info.addr.msf.minute,
2403: &ms_info.addr.msf.second,
2404: &ms_info.addr.msf.frame);
2405:
2406: else if (ms_info.addr_format == CDROM_LBA)
2407: ms_info.addr.lba = toc->last_session_lba;
2408:
2409: else
2410: return -EINVAL;
2411:
2412: ms_info.xa_flag = toc->xa_flag;
2413:
2414: memcpy_tofs ((void *)arg, &ms_info, sizeof (ms_info));
2415:
2416: return 0;
2417: }
2418:
2419: /* Read 2352 byte blocks from audio tracks. */
2420: case CDROMREADAUDIO:
2421: {
2422: int stat, lba;
2423: struct atapi_toc *toc;
2424: struct cdrom_read_audio ra;
2425: char buf[CD_FRAMESIZE_RAW];
2426:
2427: /* Make sure the TOC is up to date. */
2428: stat = cdrom_read_toc (drive, NULL);
2429: if (stat) return stat;
2430:
2431: toc = drive->cdrom_info.toc;
2432:
2433: stat = verify_area (VERIFY_READ, (char *)arg, sizeof (ra));
2434: if (stat) return stat;
2435:
2436: memcpy_fromfs (&ra, (void *)arg, sizeof (ra));
2437:
2438: if (ra.nframes < 0 || ra.nframes > toc->capacity)
2439: return -EINVAL;
2440: else if (ra.nframes == 0)
2441: return 0;
2442:
2443: stat = verify_area (VERIFY_WRITE, (char *)ra.buf,
2444: ra.nframes * CD_FRAMESIZE_RAW);
2445: if (stat) return stat;
2446:
2447: if (ra.addr_format == CDROM_MSF)
2448: lba = msf_to_lba (ra.addr.msf.minute, ra.addr.msf.second,
2449: ra.addr.msf.frame);
2450:
2451: else if (ra.addr_format == CDROM_LBA)
2452: lba = ra.addr.lba;
2453:
2454: else
2455: return -EINVAL;
2456:
2457: if (lba < 0 || lba >= toc->capacity)
2458: return -EINVAL;
2459:
2460: while (ra.nframes > 0)
2461: {
2462: stat = cdrom_read_block (drive, 1, lba, buf,
2463: CD_FRAMESIZE_RAW, NULL);
2464: if (stat) return stat;
2465: memcpy_tofs (ra.buf, buf, CD_FRAMESIZE_RAW);
2466: ra.buf += CD_FRAMESIZE_RAW;
2467: --ra.nframes;
2468: ++lba;
2469: }
2470:
2471: return 0;
2472: }
2473:
2474: case CDROMREADMODE1:
2475: case CDROMREADMODE2:
2476: {
2477: struct cdrom_msf msf;
2478: int blocksize, format, stat, lba;
2479: struct atapi_toc *toc;
2480: char buf[CD_FRAMESIZE_RAW0];
2481:
2482: if (cmd == CDROMREADMODE1)
2483: {
2484: blocksize = CD_FRAMESIZE;
2485: format = 2;
2486: }
2487: else
2488: {
2489: blocksize = CD_FRAMESIZE_RAW0;
2490: format = 3;
2491: }
2492:
2493: stat = verify_area (VERIFY_READ, (char *)arg, sizeof (msf));
2494: if (stat) return stat;
2495: stat = verify_area (VERIFY_WRITE, (char *)arg, blocksize);
2496: if (stat) return stat;
2497:
2498: memcpy_fromfs (&msf, (void *)arg, sizeof (msf));
2499:
2500: lba = msf_to_lba (msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
2501:
2502: /* Make sure the TOC is up to date. */
2503: stat = cdrom_read_toc (drive, NULL);
2504: if (stat) return stat;
2505:
2506: toc = drive->cdrom_info.toc;
2507:
2508: if (lba < 0 || lba >= toc->capacity)
2509: return -EINVAL;
2510:
2511: stat = cdrom_read_block (drive, format, lba, buf, blocksize, NULL);
2512: if (stat) return stat;
2513:
2514: memcpy_tofs ((char *)arg, buf, blocksize);
2515: return 0;
2516: }
2517:
2518: #if 0 /* Doesn't work reliably yet. */
2519: case CDROMRESET:
2520: {
2521: struct request req;
2522: ide_init_drive_cmd (&req);
2523: req.cmd = RESET_DRIVE_COMMAND;
2524: return ide_do_drive_cmd (drive, &req, ide_wait);
2525: }
2526: #endif
2527:
2528:
2529: #ifdef TEST
2530: case 0x1234:
2531: {
2532: int stat;
2533: struct packet_command pc;
2534: int len, lena;
2535:
2536: memset (&pc, 0, sizeof (pc));
2537:
2538: stat = verify_area (VERIFY_READ, (void *) arg, sizeof (pc.c));
2539: if (stat) return stat;
2540: memcpy_fromfs (&pc.c, (void *) arg, sizeof (pc.c));
2541: arg += sizeof (pc.c);
2542:
2543: stat = verify_area (VERIFY_READ, (void *) arg, sizeof (len));
2544: if (stat) return stat;
2545: memcpy_fromfs (&len, (void *) arg , sizeof (len));
2546: arg += sizeof (len);
2547:
2548: if (len > 0) {
2549: stat = verify_area (VERIFY_WRITE, (void *) arg, len);
2550: if (stat) return stat;
2551: }
2552:
2553: lena = len;
2554: if (lena < 0) lena = 0;
2555:
2556: {
2557: char buf[lena];
2558: if (len > 0) {
2559: pc.buflen = len;
2560: pc.buffer = buf;
2561: }
2562:
2563: stat = cdrom_queue_packet_command (drive, &pc);
2564:
2565: if (len > 0)
2566: memcpy_tofs ((void *)arg, buf, len);
2567: }
2568:
2569: return stat;
2570: }
2571: #endif
2572:
2573: default:
2574: return -EPERM;
2575: }
2576:
2577: }
2578:
2579:
2580:
2581: /****************************************************************************
2582: * Other driver requests (open, close, check media change).
2583: */
2584:
2585: int ide_cdrom_check_media_change (ide_drive_t *drive)
2586: {
2587: int retval;
2588:
2589: (void) cdrom_check_status (drive, NULL);
2590:
2591: retval = CDROM_STATE_FLAGS (drive)->media_changed;
2592: CDROM_STATE_FLAGS (drive)->media_changed = 0;
2593:
2594: return retval;
2595: }
2596:
2597:
2598: int ide_cdrom_open (struct inode *ip, struct file *fp, ide_drive_t *drive)
2599: {
2600: /* no write access */
2601: if (fp->f_mode & 2)
2602: {
2603: --drive->usage;
2604: return -EROFS;
2605: }
2606:
2607: /* If this is the first open, check the drive status. */
2608: if (drive->usage == 1)
2609: {
2610: int stat;
2611: struct atapi_request_sense my_reqbuf;
2612: my_reqbuf.sense_key = 0;
2613:
2614: /* Get the drive status. */
2615: stat = cdrom_check_status (drive, &my_reqbuf);
2616:
2617: /* If the tray is open, try to close it. */
2618: if (stat && my_reqbuf.sense_key == NOT_READY)
2619: {
2620: cdrom_eject (drive, 1, &my_reqbuf);
2621: stat = cdrom_check_status (drive, &my_reqbuf);
2622: }
2623:
2624: /* Return an error if there are still problems. */
2625: if (stat && my_reqbuf.sense_key != UNIT_ATTENTION)
2626: {
2627: --drive->usage;
2628: return -ENXIO;
2629: }
2630:
2631: /* Now lock the door. */
2632: (void) cdrom_lockdoor (drive, 1, &my_reqbuf);
2633:
2634: /* And try to read the TOC information now. */
2635: (void) cdrom_read_toc (drive, &my_reqbuf);
2636: }
2637:
2638: return 0;
2639: }
2640:
2641:
2642: /*
2643: * Close down the device. Invalidate all cached blocks.
2644: */
2645:
2646: void ide_cdrom_release (struct inode *inode, struct file *file, ide_drive_t *drive)
2647: {
2648: if (drive->usage == 0)
2649: {
2650: invalidate_buffers (inode->i_rdev);
2651:
2652: /* Unlock the door. */
2653: (void) cdrom_lockdoor (drive, 0, NULL);
2654:
2655: /* Do an eject if we were requested to do so. */
2656: if (CDROM_STATE_FLAGS (drive)->eject_on_close)
2657: (void) cdrom_eject (drive, 0, NULL);
2658: }
2659: }
2660:
2661:
2662:
2663: /****************************************************************************
2664: * Device initialization.
2665: */
2666:
2667: void ide_cdrom_setup (ide_drive_t *drive)
2668: {
2669: blksize_size[HWIF(drive)->major][drive->select.b.unit << PARTN_BITS] = CD_FRAMESIZE;
2670:
2671: drive->special.all = 0;
2672: drive->ready_stat = 0;
2673:
2674: CDROM_STATE_FLAGS (drive)->media_changed = 0;
2675: CDROM_STATE_FLAGS (drive)->toc_valid = 0;
2676: CDROM_STATE_FLAGS (drive)->door_locked = 0;
2677:
2678: /* Turn this off by default, since many people don't like it. */
2679: CDROM_STATE_FLAGS (drive)->eject_on_close= 0;
2680:
2681: #if NO_DOOR_LOCKING
2682: CDROM_CONFIG_FLAGS (drive)->no_doorlock = 1;
2683: #else
2684: CDROM_CONFIG_FLAGS (drive)->no_doorlock = 0;
2685: #endif
2686:
2687: if (drive->id != NULL) {
2688: CDROM_CONFIG_FLAGS (drive)->drq_interrupt =
2689: ((drive->id->config & 0x0060) == 0x20);
2690: } else {
2691: CDROM_CONFIG_FLAGS (drive)->drq_interrupt = 0;
2692: }
2693:
2694: #if ! STANDARD_ATAPI
2695: CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 0;
2696: CDROM_CONFIG_FLAGS (drive)->old_readcd = 0;
2697: CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 0;
2698: CDROM_CONFIG_FLAGS (drive)->playmsf_uses_bcd = 0;
2699: CDROM_CONFIG_FLAGS (drive)->vertos_lossage = 0;
2700:
2701: if (drive->id != NULL) {
2702: /* Accommodate some broken drives... */
2703: if (strcmp (drive->id->model, "CD220E") == 0 ||
2704: strcmp (drive->id->model, "CD") == 0) /* Creative Labs */
2705: CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2706:
2707: else if (strcmp (drive->id->model, "TO-ICSLYAL") == 0 || /* Acer CD525E */
2708: strcmp (drive->id->model, "OTI-SCYLLA") == 0)
2709: CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2710:
2711: /* I don't know who makes this.
2712: Francesco Messineo <[email protected]> says this one's broken too. */
2713: else if (strcmp (drive->id->model, "DCI-2S10") == 0)
2714: CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2715:
2716: else if (strcmp (drive->id->model, "CDA26803I SE") == 0) /* Aztech */
2717: {
2718: CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2719:
2720: /* This drive _also_ does not implement PLAYAUDIO12 correctly. */
2721: CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 1;
2722: }
2723:
2724: /* Vertos 300.
2725: There seem to be at least two different, incompatible versions
2726: of this drive floating around. Luckily, they appear to return their
2727: id strings with different byte orderings. */
2728: else if (strcmp (drive->id->model, "V003S0DS") == 0)
2729: {
2730: CDROM_CONFIG_FLAGS (drive)->vertos_lossage = 1;
2731: CDROM_CONFIG_FLAGS (drive)->playmsf_uses_bcd = 1;
2732: CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2733: }
2734: else if (strcmp (drive->id->model, "0V300SSD") == 0 ||
2735: strcmp (drive->id->model, "V003M0DP") == 0)
2736: CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2737:
2738: /* Vertos 400. */
2739: else if (strcmp (drive->id->model, "V004E0DT") == 0 ||
2740: strcmp (drive->id->model, "0V400ETD") == 0)
2741: CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2742:
2743: else if ( strcmp (drive->id->model, "CD-ROM CDU55D") == 0) /*sony cdu55d */
2744: CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 1;
2745:
2746: else if (strcmp (drive->id->model, "CD-ROM CDU55E") == 0)
2747: CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 1;
2748: } /* drive-id != NULL */
2749: #endif /* not STANDARD_ATAPI */
2750:
2751: drive->cdrom_info.toc = NULL;
2752: drive->cdrom_info.sector_buffer = NULL;
2753: drive->cdrom_info.sector_buffered = 0;
2754: drive->cdrom_info.nsectors_buffered = 0;
2755: }
2756:
2757:
2758:
2759: /*
2760: * TODO:
2761: * CDROM_GET_UPC
2762: * CDROMRESET
2763: * Lock the door when a read request completes successfully and the
2764: * door is not already locked. Also try to reorganize to reduce
2765: * duplicated functionality between read and ioctl paths?
2766: * Establish interfaces for an IDE port driver, and break out the cdrom
2767: * code into a loadable module.
2768: * Support changers.
2769: * Write some real documentation.
2770: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.