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