This source file includes following definitions.
- cdrom_in_bytes
- cdrom_out_bytes
- cdrom_analyze_sense_data
- restore_request
- cdrom_queue_request_sense
- cdrom_end_request
- cdrom_saw_media_change
- cdrom_decode_status
- cdrom_start_packet_command
- cdrom_transfer_packet_command
- cdrom_buffer_sectors
- cdrom_read_check_ireason
- cdrom_read_intr
- cdrom_read_from_buffer
- cdrom_start_read_continuation
- cdrom_start_read
- cdrom_pc_intr
- cdrom_do_pc_continuation
- cdrom_do_packet_command
- cdrom_sleep
- cdrom_queue_packet_command
- ide_do_rw_cdrom
- bin2bcd
- bcd2bin
- lba_to_msf
- msf_to_lba
- cdrom_check_status
- cdrom_lockdoor
- cdrom_eject
- cdrom_pause
- cdrom_startstop
- cdrom_read_capacity
- cdrom_read_tocentry
- cdrom_read_toc
- cdrom_read_subchannel
- cdrom_mode_sense
- cdrom_mode_select
- cdrom_play_lba_range_play12
- cdrom_play_lba_range_msf
- cdrom_play_lba_range
- cdrom_get_toc_entry
- cdrom_read_block
- ide_cdrom_ioctl
- ide_cdrom_check_media_change
- ide_cdrom_open
- ide_cdrom_release
- ide_cdrom_setup
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96 #include <linux/types.h>
97 #include <linux/kernel.h>
98 #include <linux/delay.h>
99 #include <linux/timer.h>
100 #include <linux/malloc.h>
101 #include <linux/ioport.h>
102 #include <linux/interrupt.h>
103 #include <linux/blkdev.h>
104 #include <linux/errno.h>
105 #include <linux/hdreg.h>
106 #include <linux/cdrom.h>
107 #include <asm/irq.h>
108 #include <asm/io.h>
109 #include <asm/byteorder.h>
110
111 #include "ide.h"
112
113
114
115
116
117
118
119 #ifndef VERBOSE_IDE_CD_ERRORS
120 #define VERBOSE_IDE_CD_ERRORS 0
121 #endif
122
123
124
125
126
127
128 #ifndef STANDARD_ATAPI
129 #define STANDARD_ATAPI 0
130 #endif
131
132
133
134
135 #define SECTOR_SIZE 512
136 #define SECTOR_BITS 9
137 #define SECTORS_PER_FRAME (CD_FRAMESIZE / SECTOR_SIZE)
138
139 #define MIN(a,b) ((a) < (b) ? (a) : (b))
140
141
142 #define PACKET_COMMAND 4315
143 #define REQUEST_SENSE_COMMAND 4316
144 #define RESET_DRIVE_COMMAND 4317
145
146
147
148 #define TEST_UNIT_READY 0x00
149 #define REQUEST_SENSE 0x03
150 #define START_STOP 0x1b
151 #define ALLOW_MEDIUM_REMOVAL 0x1e
152 #define READ_CAPACITY 0x25
153 #define READ_10 0x28
154 #define MODE_SENSE_10 0x5a
155 #define MODE_SELECT_10 0x55
156 #define READ_CD 0xbe
157
158
159
160
161 #define NO_SENSE 0x00
162 #define RECOVERED_ERROR 0x01
163 #define NOT_READY 0x02
164 #define MEDIUM_ERROR 0x03
165 #define HARDWARE_ERROR 0x04
166 #define ILLEGAL_REQUEST 0x05
167 #define UNIT_ATTENTION 0x06
168 #define DATA_PROTECT 0x07
169 #define ABORTED_COMMAND 0x0b
170 #define MISCOMPARE 0x0e
171
172
173
174
175
176
177
178
179 struct ide_cd_config_flags {
180 unsigned drq_interrupt : 1;
181
182 unsigned no_doorlock : 1;
183 #if ! STANDARD_ATAPI
184 unsigned no_playaudio12: 1;
185
186 unsigned no_lba_toc : 1;
187 unsigned playmsf_uses_bcd : 1;
188 unsigned old_readcd : 1;
189 unsigned vertos_lossage: 1;
190
191 #endif
192 unsigned reserved : 1;
193 };
194 #define CDROM_CONFIG_FLAGS(drive) ((struct ide_cd_config_flags *)&((drive)->bios_sect))
195
196
197
198
199 struct ide_cd_state_flags {
200 unsigned media_changed : 1;
201 unsigned toc_valid : 1;
202 unsigned door_locked : 1;
203 unsigned eject_on_close: 1;
204 unsigned reserved : 4;
205 };
206 #define CDROM_STATE_FLAGS(drive) ((struct ide_cd_state_flags *)&((drive)->bios_head))
207
208
209 #define SECTOR_BUFFER_SIZE CD_FRAMESIZE
210
211
212
213
214
215
216
217
218
219
220
221
222
223 static inline
224 void cdrom_in_bytes (ide_drive_t *drive, void *buffer, uint bytecount)
225 {
226 ++bytecount;
227 ide_input_data (drive, buffer, bytecount / 4);
228 if ((bytecount & 0x03) >= 2)
229 {
230 insw (IDE_DATA_REG, ((byte *)buffer) + (bytecount & ~0x03), 1);
231 }
232 }
233
234
235 static inline
236 void cdrom_out_bytes (ide_drive_t *drive, void *buffer, uint bytecount)
237 {
238 ++bytecount;
239 ide_output_data (drive, buffer, bytecount / 4);
240 if ((bytecount & 0x03) >= 2)
241 {
242 outsw (IDE_DATA_REG, ((byte *)buffer) + (bytecount & ~0x03), 1);
243 }
244 }
245
246
247
248
249
250
251
252 #define ARY_LEN(a) ((sizeof(a) / sizeof(a[0])))
253
254 #if VERBOSE_IDE_CD_ERRORS
255
256
257
258 char *sense_key_texts[16] = {
259 "No sense data",
260 "Recovered error",
261 "Not ready",
262 "Medium error",
263 "Hardware error",
264 "Illegal request",
265 "Unit attention",
266 "Data protect",
267 "(reserved)",
268 "(reserved)",
269 "(reserved)",
270 "Aborted command",
271 "(reserved)",
272 "(reserved)",
273 "Miscompare",
274 "(reserved)",
275 };
276
277
278
279
280 struct {
281 short asc_ascq;
282 char *text;
283 } sense_data_texts[] = {
284 { 0x0000, "No additional sense information" },
285 { 0x0011, "Audio play operation in progress" },
286 { 0x0012, "Audio play operation paused" },
287 { 0x0013, "Audio play operation successfully completed" },
288 { 0x0014, "Audio play operation stopped due to error" },
289 { 0x0015, "No current audio status to return" },
290
291 { 0x0200, "No seek complete" },
292
293 { 0x0400, "Logical unit not ready - cause not reportable" },
294 { 0x0401, "Logical unit not ready - in progress (sic) of becoming ready" },
295 { 0x0402, "Logical unit not ready - initializing command required" },
296 { 0x0403, "Logical unit not ready - manual intervention required" },
297
298 { 0x0600, "No reference position found" },
299
300 { 0x0900, "Track following error" },
301 { 0x0901, "Tracking servo failure" },
302 { 0x0902, "Focus servo failure" },
303 { 0x0903, "Spindle servo failure" },
304
305 { 0x1100, "Unrecovered read error" },
306 { 0x1106, "CIRC unrecovered error" },
307
308 { 0x1500, "Random positioning error" },
309 { 0x1501, "Mechanical positioning error" },
310 { 0x1502, "Positioning error detected by read of medium" },
311
312 { 0x1700, "Recovered data with no error correction applied" },
313 { 0x1701, "Recovered data with retries" },
314 { 0x1702, "Recovered data with positive head offset" },
315 { 0x1703, "Recovered data with negative head offset" },
316 { 0x1704, "Recovered data with retries and/or CIRC applied" },
317 { 0x1705, "Recovered data using previous sector ID" },
318
319 { 0x1800, "Recovered data with error correction applied" },
320 { 0x1801, "Recovered data with error correction and retries applied" },
321 { 0x1802, "Recovered data - the data was auto-reallocated" },
322 { 0x1803, "Recovered data with CIRC" },
323 { 0x1804, "Recovered data with L-EC" },
324 { 0x1805, "Recovered data - recommend reassignment" },
325 { 0x1806, "Recovered data - recommend rewrite" },
326
327 { 0x1a00, "Parameter list length error" },
328
329 { 0x2000, "Invalid command operation code" },
330
331 { 0x2100, "Logical block address out of range" },
332
333 { 0x2400, "Invalid field in command packet" },
334
335 { 0x2600, "Invalid field in parameter list" },
336 { 0x2601, "Parameter not supported" },
337 { 0x2602, "Parameter value invalid" },
338 { 0x2603, "Threshold parameters not supported" },
339
340 { 0x2800, "Not ready to ready transition, medium may have changed" },
341
342 { 0x2900, "Power on, reset or bus device reset occurred" },
343
344 { 0x2a00, "Parameters changed" },
345 { 0x2a01, "Mode parameters changed" },
346
347 { 0x3000, "Incompatible medium installed" },
348 { 0x3001, "Cannot read medium - unknown format" },
349 { 0x3002, "Cannot read medium - incompatible format" },
350
351 { 0x3700, "Rounded parameter" },
352
353 { 0x3900, "Saving parameters not supported" },
354
355 { 0x3a00, "Medium not present" },
356
357 { 0x3f00, "ATAPI CD-ROM drive operating conditions have changed" },
358 { 0x3f01, "Microcode has been changed" },
359 { 0x3f02, "Changed operating definition" },
360 { 0x3f03, "Inquiry data has changed" },
361
362 { 0x4000, "Diagnostic failure on component (ASCQ)" },
363
364 { 0x4400, "Internal ATAPI CD-ROM drive failure" },
365
366 { 0x4e00, "Overlapped commands attempted" },
367
368 { 0x5300, "Media load or eject failed" },
369 { 0x5302, "Medium removal prevented" },
370
371 { 0x5700, "Unable to recover table of contents" },
372
373 { 0x5a00, "Operator request or state change input (unspecified)" },
374 { 0x5a01, "Operator medium removal request" },
375
376 { 0x5b00, "Threshold condition met" },
377
378 { 0x5c00, "Status change" },
379
380 { 0x6300, "End of user area encountered on this track" },
381
382 { 0x6400, "Illegal mode for this track" },
383
384 { 0xbf00, "Loss of streaming" },
385 };
386 #endif
387
388
389
390
391
392
393
394
395 static
396 void cdrom_analyze_sense_data (ide_drive_t *drive,
397 struct atapi_request_sense *reqbuf,
398 struct packet_command *failed_command)
399 {
400
401
402
403 if (failed_command &&
404 failed_command->c[0] == SCMD_READ_SUBCHANNEL &&
405 (reqbuf->sense_key == NOT_READY || reqbuf->sense_key == UNIT_ATTENTION))
406 return;
407
408 #if VERBOSE_IDE_CD_ERRORS
409 {
410 int i;
411 char *s;
412 char buf[80];
413
414 printk ("ATAPI device %s:\n", drive->name);
415
416 printk (" Error code: 0x%02x\n", reqbuf->error_code);
417
418 if (reqbuf->sense_key >= 0 &&
419 reqbuf->sense_key < ARY_LEN (sense_key_texts))
420 s = sense_key_texts[reqbuf->sense_key];
421 else
422 s = "(bad sense key)";
423
424 printk (" Sense key: 0x%02x - %s\n", reqbuf->sense_key, s);
425
426 if (reqbuf->asc == 0x40) {
427 sprintf (buf, "Diagnostic failure on component 0x%02x", reqbuf->ascq);
428 s = buf;
429 }
430
431 else {
432 int lo, hi;
433 int key = (reqbuf->asc << 8);
434 if ( ! (reqbuf->ascq >= 0x80 && reqbuf->ascq <= 0xdd) )
435 key |= reqbuf->ascq;
436
437 lo = 0;
438 hi = ARY_LEN (sense_data_texts);
439 s = NULL;
440
441 while (hi > lo) {
442 int mid = (lo + hi) / 2;
443 if (sense_data_texts[mid].asc_ascq == key) {
444 s = sense_data_texts[mid].text;
445 break;
446 }
447 else if (sense_data_texts[mid].asc_ascq > key)
448 hi = mid;
449 else
450 lo = mid+1;
451 }
452 }
453
454 if (s == NULL) {
455 if (reqbuf->asc > 0x80)
456 s = "(vendor-specific error)";
457 else
458 s = "(reserved error code)";
459 }
460
461 printk (" Additional sense data: 0x%02x, 0x%02x - %s\n",
462 reqbuf->asc, reqbuf->ascq, s);
463
464 if (failed_command != NULL) {
465 printk (" Failed packet command: ");
466 for (i=0; i<sizeof (failed_command->c); i++)
467 printk ("%02x ", failed_command->c[i]);
468 printk ("\n");
469 }
470
471 if (reqbuf->sense_key == ILLEGAL_REQUEST &&
472 (reqbuf->sense_key_specific[0] & 0x80) != 0)
473 {
474 printk (" Error in %s byte %d",
475 (reqbuf->sense_key_specific[0] & 0x40) != 0
476 ? "command packet"
477 : "command data",
478 (reqbuf->sense_key_specific[1] << 8) +
479 reqbuf->sense_key_specific[2]);
480
481 if ((reqbuf->sense_key_specific[0] & 0x40) != 0)
482 {
483 printk (" bit %d", reqbuf->sense_key_specific[0] & 0x07);
484 }
485
486 printk ("\n");
487 }
488 }
489
490 #else
491
492
493
494
495 if (reqbuf->sense_key == UNIT_ATTENTION ||
496 (reqbuf->sense_key == NOT_READY && (reqbuf->asc == 4 ||
497 reqbuf->asc == 0x3a)))
498 return;
499
500 printk ("%s: code: 0x%02x key: 0x%02x asc: 0x%02x ascq: 0x%02x\n",
501 drive->name,
502 reqbuf->error_code, reqbuf->sense_key, reqbuf->asc, reqbuf->ascq);
503 #endif
504 }
505
506
507
508
509 static void restore_request (struct request *rq)
510 {
511 if (rq->buffer != rq->bh->b_data)
512 {
513 int n = (rq->buffer - rq->bh->b_data) / SECTOR_SIZE;
514 rq->buffer = rq->bh->b_data;
515 rq->nr_sectors += n;
516 rq->sector -= n;
517 }
518 rq->current_nr_sectors = rq->bh->b_size >> SECTOR_BITS;
519 }
520
521
522 static void cdrom_queue_request_sense (ide_drive_t *drive,
523 struct semaphore *sem,
524 struct atapi_request_sense *reqbuf,
525 struct packet_command *failed_command)
526 {
527 struct request *rq;
528 struct packet_command *pc;
529 int len;
530
531
532
533 if (reqbuf == NULL)
534 reqbuf = &drive->cdrom_info.sense_data;
535
536
537
538 pc = &HWIF(drive)->request_sense_pc;
539 memset (pc, 0, sizeof (*pc));
540
541
542
543
544
545 len = sizeof (*reqbuf) / 4;
546 len *= 4;
547
548 pc->c[0] = REQUEST_SENSE;
549 pc->c[4] = len;
550 pc->buffer = (char *)reqbuf;
551 pc->buflen = len;
552 pc->sense_data = (struct atapi_request_sense *)failed_command;
553
554
555
556 rq = &HWIF(drive)->request_sense_request;
557 ide_init_drive_cmd (rq);
558 rq->cmd = REQUEST_SENSE_COMMAND;
559 rq->buffer = (char *)pc;
560 rq->sem = sem;
561 (void) ide_do_drive_cmd (drive, rq, ide_preempt);
562 }
563
564
565 static void cdrom_end_request (int uptodate, ide_drive_t *drive)
566 {
567 struct request *rq = HWGROUP(drive)->rq;
568
569
570
571 if (!uptodate && rq->bh != 0)
572 {
573 int adj = rq->current_nr_sectors - 1;
574 rq->current_nr_sectors -= adj;
575 rq->sector += adj;
576 }
577
578 if (rq->cmd == REQUEST_SENSE_COMMAND && uptodate)
579 {
580 struct packet_command *pc = (struct packet_command *)rq->buffer;
581 cdrom_analyze_sense_data (drive,
582 (struct atapi_request_sense *)(pc->buffer - pc->c[4]),
583 (struct packet_command *)pc->sense_data);
584 }
585
586 ide_end_request (uptodate, HWGROUP(drive));
587 }
588
589
590
591
592 static void cdrom_saw_media_change (ide_drive_t *drive)
593 {
594 CDROM_STATE_FLAGS (drive)->media_changed = 1;
595 CDROM_STATE_FLAGS (drive)->toc_valid = 0;
596 drive->cdrom_info.nsectors_buffered = 0;
597 }
598
599
600
601
602 static int cdrom_decode_status (ide_drive_t *drive, int good_stat, int *stat_ret)
603 {
604 struct request *rq = HWGROUP(drive)->rq;
605 int stat, err, sense_key, cmd;
606
607
608 stat = GET_STAT();
609 *stat_ret = stat;
610
611 if (OK_STAT (stat, good_stat, BAD_R_STAT))
612 return 0;
613
614
615 err = IN_BYTE (IDE_ERROR_REG);
616 sense_key = err >> 4;
617
618 if (rq == NULL)
619 printk ("%s : missing request in cdrom_decode_status\n", drive->name);
620 else
621 {
622 cmd = rq->cmd;
623
624 if (cmd == REQUEST_SENSE_COMMAND)
625 {
626
627
628
629
630 struct packet_command *pc = (struct packet_command *)rq->buffer;
631 pc->stat = 1;
632 cdrom_end_request (1, drive);
633 ide_error (drive, "request sense failure", stat);
634 return 1;
635 }
636
637 else if (cmd == PACKET_COMMAND)
638 {
639
640
641 struct packet_command *pc = (struct packet_command *)rq->buffer;
642 struct semaphore *sem = NULL;
643
644
645 if (sense_key == NOT_READY)
646 {
647 cdrom_saw_media_change (drive);
648
649
650
651
652
653
654 if (pc->c[0] != SCMD_READ_SUBCHANNEL)
655 printk ("%s : tray open or drive not ready\n", drive->name);
656 }
657
658
659 else if (sense_key == UNIT_ATTENTION)
660 {
661 cdrom_saw_media_change (drive);
662 printk ("%s: media changed\n", drive->name);
663 }
664
665
666 else
667 {
668 ide_dump_status (drive, "packet command error", stat);
669 }
670
671
672
673
674
675
676
677
678
679 if ((stat & ERR_STAT) != 0)
680 {
681 sem = rq->sem;
682 rq->sem = NULL;
683 }
684
685 pc->stat = 1;
686 cdrom_end_request (1, drive);
687
688 if ((stat & ERR_STAT) != 0)
689 cdrom_queue_request_sense (drive, sem, pc->sense_data, pc);
690 }
691
692 else
693 {
694
695
696
697 if (sense_key == NOT_READY)
698 {
699 cdrom_saw_media_change (drive);
700
701
702 printk ("%s : tray open\n", drive->name);
703 cdrom_end_request (0, drive);
704 }
705
706
707 else if (sense_key == UNIT_ATTENTION)
708 {
709 cdrom_saw_media_change (drive);
710
711
712
713 if (++rq->errors > ERROR_MAX)
714 {
715 cdrom_end_request (0, drive);
716 }
717 }
718
719
720 else if (sense_key == ILLEGAL_REQUEST || sense_key == DATA_PROTECT)
721 {
722 ide_dump_status (drive, "command error", stat);
723 cdrom_end_request (0, drive);
724 }
725
726
727 else if ((err & ~ABRT_ERR) != 0)
728 {
729 ide_error (drive, "cdrom_decode_status", stat);
730 return 1;
731 }
732
733
734 else if ((++rq->errors > ERROR_MAX))
735 {
736 cdrom_end_request (0, drive);
737 }
738
739
740
741 if ((stat & ERR_STAT) != 0)
742 cdrom_queue_request_sense (drive, NULL, NULL, NULL);
743 }
744 }
745
746
747 return 1;
748 }
749
750
751
752
753
754
755
756
757
758 static int cdrom_start_packet_command (ide_drive_t *drive, int xferlen,
759 ide_handler_t *handler)
760 {
761
762 if (ide_wait_stat (drive, 0, BUSY_STAT, WAIT_READY)) return 1;
763
764
765 OUT_BYTE (0, IDE_FEATURE_REG);
766 OUT_BYTE (0, IDE_NSECTOR_REG);
767 OUT_BYTE (0, IDE_SECTOR_REG);
768
769 OUT_BYTE (xferlen & 0xff, IDE_LCYL_REG);
770 OUT_BYTE (xferlen >> 8 , IDE_HCYL_REG);
771 OUT_BYTE (drive->ctl, IDE_CONTROL_REG);
772
773 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt)
774 {
775 ide_set_handler (drive, handler, WAIT_CMD);
776 OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG);
777 }
778 else
779 {
780 OUT_BYTE (WIN_PACKETCMD, IDE_COMMAND_REG);
781 (*handler) (drive);
782 }
783
784 return 0;
785 }
786
787
788
789
790
791
792
793 static int cdrom_transfer_packet_command (ide_drive_t *drive,
794 char *cmd_buf, int cmd_len,
795 ide_handler_t *handler)
796 {
797 if (CDROM_CONFIG_FLAGS (drive)->drq_interrupt)
798 {
799
800
801 int stat_dum;
802
803
804 if (cdrom_decode_status (drive, DRQ_STAT, &stat_dum)) return 1;
805 }
806 else
807 {
808
809 if (ide_wait_stat (drive, DRQ_STAT, BUSY_STAT, WAIT_READY)) return 1;
810 }
811
812
813 ide_set_handler (drive, handler, WAIT_CMD);
814
815
816 cdrom_out_bytes (drive, cmd_buf, cmd_len);
817
818 return 0;
819 }
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834 static void cdrom_buffer_sectors (ide_drive_t *drive, unsigned long sector,
835 int sectors_to_transfer)
836 {
837 struct cdrom_info *info = &drive->cdrom_info;
838
839
840 int sectors_to_buffer = MIN (sectors_to_transfer,
841 (SECTOR_BUFFER_SIZE >> SECTOR_BITS) -
842 info->nsectors_buffered);
843
844 char *dest;
845
846
847
848
849 if (info->sector_buffer == NULL)
850 {
851 info->sector_buffer = (char *) kmalloc (SECTOR_BUFFER_SIZE, GFP_ATOMIC);
852
853
854 if (info->sector_buffer == NULL)
855 sectors_to_buffer = 0;
856 }
857
858
859 if (info->nsectors_buffered == 0)
860 info->sector_buffered = sector;
861
862
863 dest = info->sector_buffer + info->nsectors_buffered * SECTOR_SIZE;
864 while (sectors_to_buffer > 0)
865 {
866 cdrom_in_bytes (drive, dest, SECTOR_SIZE);
867 --sectors_to_buffer;
868 --sectors_to_transfer;
869 ++info->nsectors_buffered;
870 dest += SECTOR_SIZE;
871 }
872
873
874 while (sectors_to_transfer > 0)
875 {
876 char dum[SECTOR_SIZE];
877 cdrom_in_bytes (drive, dum, sizeof (dum));
878 --sectors_to_transfer;
879 }
880 }
881
882
883
884
885
886
887
888 static inline
889 int cdrom_read_check_ireason (ide_drive_t *drive, int len, int ireason)
890 {
891 ireason &= 3;
892 if (ireason == 2) return 0;
893
894 if (ireason == 0)
895 {
896
897 printk ("%s: cdrom_read_intr: "
898 "Drive wants to transfer data the wrong way!\n",
899 drive->name);
900
901
902
903 while (len > 0)
904 {
905 int dum = 0;
906 cdrom_out_bytes (drive, &dum, sizeof (dum));
907 len -= sizeof (dum);
908 }
909 }
910
911 else
912 {
913
914 printk ("%s: cdrom_read_intr: bad interrupt reason %d\n",
915 drive->name, ireason);
916 }
917
918 cdrom_end_request (0, drive);
919 return -1;
920 }
921
922
923
924
925
926 static void cdrom_read_intr (ide_drive_t *drive)
927 {
928 int stat;
929 int ireason, len, sectors_to_transfer, nskip;
930
931 struct request *rq = HWGROUP(drive)->rq;
932
933
934 if (cdrom_decode_status (drive, 0, &stat)) return;
935
936
937 ireason = IN_BYTE (IDE_NSECTOR_REG);
938 len = IN_BYTE (IDE_LCYL_REG) + 256 * IN_BYTE (IDE_HCYL_REG);
939
940
941 if ((stat & DRQ_STAT) == 0)
942 {
943
944
945 if (rq->current_nr_sectors > 0)
946 {
947 printk ("%s: cdrom_read_intr: data underrun (%ld blocks)\n",
948 drive->name, rq->current_nr_sectors);
949 cdrom_end_request (0, drive);
950 }
951 else
952 cdrom_end_request (1, drive);
953
954 return;
955 }
956
957
958 if (cdrom_read_check_ireason (drive, len, ireason)) return;
959
960
961
962 if ((len % SECTOR_SIZE) != 0)
963 {
964 printk ("%s: cdrom_read_intr: Bad transfer size %d\n",
965 drive->name, len);
966 printk (" This drive is not supported by this version of the driver\n");
967 cdrom_end_request (0, drive);
968 return;
969 }
970
971
972 sectors_to_transfer = len / SECTOR_SIZE;
973
974
975 nskip = MIN ((int)(rq->current_nr_sectors - (rq->bh->b_size >> SECTOR_BITS)),
976 sectors_to_transfer);
977
978 while (nskip > 0)
979 {
980
981 char dum[SECTOR_SIZE];
982 cdrom_in_bytes (drive, dum, sizeof (dum));
983
984 --rq->current_nr_sectors;
985 --nskip;
986 --sectors_to_transfer;
987 }
988
989
990 while (sectors_to_transfer > 0)
991 {
992 int this_transfer;
993
994
995
996 if (rq->current_nr_sectors == 0 &&
997 rq->nr_sectors > 0)
998 cdrom_end_request (1, drive);
999
1000
1001
1002 if (rq->current_nr_sectors == 0)
1003 {
1004 cdrom_buffer_sectors (drive, rq->sector, sectors_to_transfer);
1005 sectors_to_transfer = 0;
1006 }
1007 else
1008 {
1009
1010
1011
1012 this_transfer = MIN (sectors_to_transfer,
1013 rq->current_nr_sectors);
1014
1015
1016 while (this_transfer > 0)
1017 {
1018 cdrom_in_bytes (drive, rq->buffer, SECTOR_SIZE);
1019 rq->buffer += SECTOR_SIZE;
1020 --rq->nr_sectors;
1021 --rq->current_nr_sectors;
1022 ++rq->sector;
1023 --this_transfer;
1024 --sectors_to_transfer;
1025 }
1026 }
1027 }
1028
1029
1030
1031 ide_set_handler (drive, &cdrom_read_intr, WAIT_CMD);
1032 }
1033
1034
1035
1036
1037
1038
1039 static int cdrom_read_from_buffer (ide_drive_t *drive)
1040 {
1041 struct cdrom_info *info = &drive->cdrom_info;
1042 struct request *rq = HWGROUP(drive)->rq;
1043
1044
1045 if (info->sector_buffer == NULL) return 0;
1046
1047
1048
1049 while (rq->nr_sectors > 0 &&
1050 rq->sector >= info->sector_buffered &&
1051 rq->sector < info->sector_buffered + info->nsectors_buffered)
1052 {
1053 if (rq->current_nr_sectors == 0)
1054 cdrom_end_request (1, drive);
1055
1056 memcpy (rq->buffer,
1057 info->sector_buffer +
1058 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
1059 SECTOR_SIZE);
1060 rq->buffer += SECTOR_SIZE;
1061 --rq->current_nr_sectors;
1062 --rq->nr_sectors;
1063 ++rq->sector;
1064 }
1065
1066
1067 if (rq->nr_sectors == 0)
1068 {
1069 cdrom_end_request (1, drive);
1070 return -1;
1071 }
1072
1073
1074 if (rq->current_nr_sectors == 0)
1075 cdrom_end_request (1, drive);
1076
1077
1078
1079
1080
1081 if (rq->current_nr_sectors < (rq->bh->b_size >> SECTOR_BITS) &&
1082 (rq->sector % SECTORS_PER_FRAME) != 0)
1083 {
1084 printk ("%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
1085 drive->name, rq->sector);
1086 cdrom_end_request (0, drive);
1087 return -1;
1088 }
1089
1090 return 0;
1091 }
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101 static void cdrom_start_read_continuation (ide_drive_t *drive)
1102 {
1103 struct packet_command pc;
1104 struct request *rq = HWGROUP(drive)->rq;
1105
1106 int nsect, sector, nframes, frame, nskip;
1107
1108
1109 nsect = rq->nr_sectors;
1110
1111
1112 sector = rq->sector;
1113
1114
1115
1116
1117
1118
1119
1120 nskip = (sector % SECTORS_PER_FRAME);
1121 if (nskip > 0)
1122 {
1123
1124 if (rq->current_nr_sectors != (rq->bh->b_size >> SECTOR_BITS))
1125 {
1126 printk ("%s: cdrom_start_read_continuation: buffer botch (%ld)\n",
1127 drive->name, rq->current_nr_sectors);
1128 cdrom_end_request (0, drive);
1129 return;
1130 }
1131
1132 sector -= nskip;
1133 nsect += nskip;
1134 rq->current_nr_sectors += nskip;
1135 }
1136
1137
1138
1139 nframes = (nsect + SECTORS_PER_FRAME-1) / SECTORS_PER_FRAME;
1140 frame = sector / SECTORS_PER_FRAME;
1141
1142
1143 nframes = MIN (nframes, 65535);
1144
1145
1146 memset (&pc.c, 0, sizeof (pc.c));
1147 pc.c[0] = READ_10;
1148 pc.c[7] = (nframes >> 8);
1149 pc.c[8] = (nframes & 0xff);
1150 *(int *)(&pc.c[2]) = htonl (frame);
1151
1152
1153 (void) cdrom_transfer_packet_command (drive, pc.c, sizeof (pc.c),
1154 &cdrom_read_intr);
1155 }
1156
1157
1158
1159
1160
1161 static void cdrom_start_read (ide_drive_t *drive, unsigned int block)
1162 {
1163 struct request *rq = HWGROUP(drive)->rq;
1164 int minor = MINOR (rq->rq_dev);
1165
1166
1167
1168 if ((minor & PARTN_MASK) != 0) {
1169 rq->sector = block;
1170 minor &= ~PARTN_MASK;
1171 rq->rq_dev = MKDEV (MAJOR(rq->rq_dev), minor);
1172 }
1173
1174
1175
1176 restore_request (rq);
1177
1178
1179 if (cdrom_read_from_buffer (drive))
1180 return;
1181
1182
1183 drive->cdrom_info.nsectors_buffered = 0;
1184
1185
1186 cdrom_start_packet_command (drive, 32768, cdrom_start_read_continuation);
1187 }
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197 static int
1198 cdrom_lockdoor (ide_drive_t *drive, int lockflag,
1199 struct atapi_request_sense *reqbuf);
1200
1201
1202
1203
1204 static void cdrom_pc_intr (ide_drive_t *drive)
1205 {
1206 int ireason, len, stat, thislen;
1207 struct request *rq = HWGROUP(drive)->rq;
1208 struct packet_command *pc = (struct packet_command *)rq->buffer;
1209
1210
1211 if (cdrom_decode_status (drive, 0, &stat)) return;
1212
1213
1214 ireason = IN_BYTE (IDE_NSECTOR_REG);
1215 len = IN_BYTE (IDE_LCYL_REG) + 256 * IN_BYTE (IDE_HCYL_REG);
1216
1217
1218
1219 if ((stat & DRQ_STAT) == 0)
1220 {
1221
1222
1223 if (pc->c[0] == REQUEST_SENSE && pc->buflen > 0 && pc->buflen <= 5) {
1224 while (pc->buflen > 0) {
1225 *pc->buffer++ = 0;
1226 --pc->buflen;
1227 }
1228 }
1229
1230 if (pc->buflen == 0)
1231 cdrom_end_request (1, drive);
1232 else
1233 {
1234 printk ("%s: cdrom_pc_intr: data underrun %d\n",
1235 drive->name, pc->buflen);
1236 pc->stat = 1;
1237 cdrom_end_request (1, drive);
1238 }
1239 return;
1240 }
1241
1242
1243 thislen = pc->buflen;
1244 if (thislen < 0) thislen = -thislen;
1245 if (thislen > len) thislen = len;
1246
1247
1248 if ((ireason & 3) == 0)
1249 {
1250
1251 if (pc->buflen > 0)
1252 {
1253 printk ("%s: cdrom_pc_intr: Drive wants to transfer data the wrong way!\n",
1254 drive->name);
1255 pc->stat = 1;
1256 thislen = 0;
1257 }
1258
1259
1260 cdrom_out_bytes (drive, pc->buffer, thislen);
1261
1262
1263
1264 while (len > thislen)
1265 {
1266 int dum = 0;
1267 cdrom_out_bytes (drive, &dum, sizeof (dum));
1268 len -= sizeof (dum);
1269 }
1270
1271
1272 pc->buffer += thislen;
1273 pc->buflen += thislen;
1274 }
1275
1276
1277 else if ((ireason & 3) == 2)
1278 {
1279
1280 if (pc->buflen < 0)
1281 {
1282 printk ("%s: cdrom_pc_intr: Drive wants to transfer data the wrong way!\n",
1283 drive->name);
1284 pc->stat = 1;
1285 thislen = 0;
1286 }
1287
1288
1289 cdrom_in_bytes (drive, pc->buffer, thislen);
1290
1291
1292
1293 while (len > thislen)
1294 {
1295 int dum = 0;
1296 cdrom_in_bytes (drive, &dum, sizeof (dum));
1297 len -= sizeof (dum);
1298 }
1299
1300
1301 pc->buffer += thislen;
1302 pc->buflen -= thislen;
1303 }
1304
1305 else
1306 {
1307 printk ("%s: cdrom_pc_intr: The drive appears confused (ireason = 0x%2x)\n",
1308 drive->name, ireason);
1309 pc->stat = 1;
1310 }
1311
1312
1313 ide_set_handler (drive, &cdrom_pc_intr, WAIT_CMD);
1314 }
1315
1316
1317 static void cdrom_do_pc_continuation (ide_drive_t *drive)
1318 {
1319 struct request *rq = HWGROUP(drive)->rq;
1320 struct packet_command *pc = (struct packet_command *)rq->buffer;
1321
1322
1323 cdrom_transfer_packet_command (drive, pc->c, sizeof (pc->c), &cdrom_pc_intr);
1324 }
1325
1326
1327 static void cdrom_do_packet_command (ide_drive_t *drive)
1328 {
1329 int len;
1330 struct request *rq = HWGROUP(drive)->rq;
1331 struct packet_command *pc = (struct packet_command *)rq->buffer;
1332
1333 len = pc->buflen;
1334 if (len < 0) len = -len;
1335
1336 pc->stat = 0;
1337
1338
1339 cdrom_start_packet_command (drive, len, cdrom_do_pc_continuation);
1340 }
1341
1342
1343
1344
1345 static
1346 void cdrom_sleep (int time)
1347 {
1348 current->state = TASK_INTERRUPTIBLE;
1349 current->timeout = jiffies + time;
1350 schedule ();
1351 }
1352
1353 static
1354 int cdrom_queue_packet_command (ide_drive_t *drive, struct packet_command *pc)
1355 {
1356 struct atapi_request_sense my_reqbuf;
1357 int retries = 10;
1358 struct request req;
1359
1360
1361
1362 if (pc->sense_data == NULL)
1363 pc->sense_data = &my_reqbuf;
1364 pc->sense_data->sense_key = 0;
1365
1366
1367 do {
1368 ide_init_drive_cmd (&req);
1369 req.cmd = PACKET_COMMAND;
1370 req.buffer = (char *)pc;
1371 (void) ide_do_drive_cmd (drive, &req, ide_wait);
1372
1373 if (pc->stat != 0)
1374 {
1375
1376
1377 struct atapi_request_sense *reqbuf = pc->sense_data;
1378
1379 if (reqbuf->sense_key == UNIT_ATTENTION)
1380 ;
1381
1382
1383
1384
1385 else if (reqbuf->sense_key == NOT_READY && reqbuf->asc == 4)
1386 {
1387 cdrom_sleep (HZ);
1388 }
1389
1390
1391 else
1392 retries = 0;
1393
1394 --retries;
1395 }
1396
1397
1398 } while (pc->stat != 0 && retries >= 0);
1399
1400
1401
1402 if (pc->stat != 0)
1403 return -EIO;
1404
1405 else
1406 {
1407
1408
1409
1410
1411 if (CDROM_STATE_FLAGS (drive)->door_locked == 0 &&
1412 (pc->c[0] != REQUEST_SENSE &&
1413 pc->c[0] != ALLOW_MEDIUM_REMOVAL &&
1414 pc->c[0] != START_STOP))
1415 {
1416 (void) cdrom_lockdoor (drive, 1, NULL);
1417 }
1418 return 0;
1419 }
1420 }
1421
1422
1423
1424
1425
1426
1427
1428 void ide_do_rw_cdrom (ide_drive_t *drive, unsigned long block)
1429 {
1430 struct request *rq = HWGROUP(drive)->rq;
1431
1432 if (rq -> cmd == PACKET_COMMAND || rq -> cmd == REQUEST_SENSE_COMMAND)
1433 cdrom_do_packet_command (drive);
1434
1435 else if (rq -> cmd == RESET_DRIVE_COMMAND)
1436 {
1437 cdrom_end_request (1, drive);
1438 ide_do_reset (drive);
1439 return;
1440 }
1441
1442 else if (rq -> cmd != READ)
1443 {
1444 printk ("ide-cd: bad cmd %d\n", rq -> cmd);
1445 cdrom_end_request (0, drive);
1446 }
1447 else
1448 cdrom_start_read (drive, block);
1449 }
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463 #if ! STANDARD_ATAPI
1464 static
1465 int bin2bcd (int x)
1466 {
1467 return (x%10) | ((x/10) << 4);
1468 }
1469
1470
1471 static
1472 int bcd2bin (int x)
1473 {
1474 return (x >> 4) * 10 + (x & 0x0f);
1475 }
1476 #endif
1477
1478
1479 static inline
1480 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
1481 {
1482 lba += CD_BLOCK_OFFSET;
1483 lba &= 0xffffff;
1484 *m = lba / (CD_SECS * CD_FRAMES);
1485 lba %= (CD_SECS * CD_FRAMES);
1486 *s = lba / CD_FRAMES;
1487 *f = lba % CD_FRAMES;
1488 }
1489
1490
1491 static inline
1492 int msf_to_lba (byte m, byte s, byte f)
1493 {
1494 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_BLOCK_OFFSET;
1495 }
1496
1497
1498 static int
1499 cdrom_check_status (ide_drive_t *drive,
1500 struct atapi_request_sense *reqbuf)
1501 {
1502 struct packet_command pc;
1503
1504 memset (&pc, 0, sizeof (pc));
1505
1506 pc.sense_data = reqbuf;
1507 pc.c[0] = TEST_UNIT_READY;
1508
1509 return cdrom_queue_packet_command (drive, &pc);
1510 }
1511
1512
1513
1514 static int
1515 cdrom_lockdoor (ide_drive_t *drive, int lockflag,
1516 struct atapi_request_sense *reqbuf)
1517 {
1518 struct atapi_request_sense my_reqbuf;
1519 int stat;
1520 struct packet_command pc;
1521
1522 if (reqbuf == NULL)
1523 reqbuf = &my_reqbuf;
1524
1525
1526 if (CDROM_CONFIG_FLAGS (drive)->no_doorlock)
1527 stat = 0;
1528 else
1529 {
1530 memset (&pc, 0, sizeof (pc));
1531 pc.sense_data = reqbuf;
1532
1533 pc.c[0] = ALLOW_MEDIUM_REMOVAL;
1534 pc.c[4] = (lockflag != 0);
1535 stat = cdrom_queue_packet_command (drive, &pc);
1536 }
1537
1538 if (stat == 0)
1539 CDROM_STATE_FLAGS (drive)->door_locked = lockflag;
1540 else
1541 {
1542
1543
1544 if (reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x24)
1545 {
1546 printk ("%s: door locking not supported\n", drive->name);
1547 CDROM_CONFIG_FLAGS (drive)->no_doorlock = 1;
1548 stat = 0;
1549 CDROM_STATE_FLAGS (drive)->door_locked = lockflag;
1550 }
1551 }
1552 return stat;
1553 }
1554
1555
1556
1557
1558 static int
1559 cdrom_eject (ide_drive_t *drive, int ejectflag,
1560 struct atapi_request_sense *reqbuf)
1561 {
1562 struct packet_command pc;
1563
1564 memset (&pc, 0, sizeof (pc));
1565 pc.sense_data = reqbuf;
1566
1567 pc.c[0] = START_STOP;
1568 pc.c[4] = 2 + (ejectflag != 0);
1569 return cdrom_queue_packet_command (drive, &pc);
1570 }
1571
1572
1573 static int
1574 cdrom_pause (ide_drive_t *drive, int pauseflag,
1575 struct atapi_request_sense *reqbuf)
1576 {
1577 struct packet_command pc;
1578
1579 memset (&pc, 0, sizeof (pc));
1580 pc.sense_data = reqbuf;
1581
1582 pc.c[0] = SCMD_PAUSE_RESUME;
1583 pc.c[8] = !pauseflag;
1584 return cdrom_queue_packet_command (drive, &pc);
1585 }
1586
1587
1588 static int
1589 cdrom_startstop (ide_drive_t *drive, int startflag,
1590 struct atapi_request_sense *reqbuf)
1591 {
1592 struct packet_command pc;
1593
1594 memset (&pc, 0, sizeof (pc));
1595 pc.sense_data = reqbuf;
1596
1597 pc.c[0] = START_STOP;
1598 pc.c[1] = 1;
1599 pc.c[4] = startflag;
1600 return cdrom_queue_packet_command (drive, &pc);
1601 }
1602
1603
1604 static int
1605 cdrom_read_capacity (ide_drive_t *drive, unsigned *capacity,
1606 struct atapi_request_sense *reqbuf)
1607 {
1608 struct {
1609 unsigned lba;
1610 unsigned blocklen;
1611 } capbuf;
1612
1613 int stat;
1614 struct packet_command pc;
1615
1616 memset (&pc, 0, sizeof (pc));
1617 pc.sense_data = reqbuf;
1618
1619 pc.c[0] = READ_CAPACITY;
1620 pc.buffer = (char *)&capbuf;
1621 pc.buflen = sizeof (capbuf);
1622
1623 stat = cdrom_queue_packet_command (drive, &pc);
1624 if (stat == 0)
1625 {
1626 *capacity = ntohl (capbuf.lba);
1627 }
1628
1629 return stat;
1630 }
1631
1632
1633 static int
1634 cdrom_read_tocentry (ide_drive_t *drive, int trackno, int msf_flag,
1635 int format, char *buf, int buflen,
1636 struct atapi_request_sense *reqbuf)
1637 {
1638 struct packet_command pc;
1639
1640 memset (&pc, 0, sizeof (pc));
1641 pc.sense_data = reqbuf;
1642
1643 pc.buffer = buf;
1644 pc.buflen = buflen;
1645 pc.c[0] = SCMD_READ_TOC;
1646 pc.c[6] = trackno;
1647 pc.c[7] = (buflen >> 8);
1648 pc.c[8] = (buflen & 0xff);
1649 pc.c[9] = (format << 6);
1650 if (msf_flag) pc.c[1] = 2;
1651 return cdrom_queue_packet_command (drive, &pc);
1652 }
1653
1654
1655
1656 static int
1657 cdrom_read_toc (ide_drive_t *drive,
1658 struct atapi_request_sense *reqbuf)
1659 {
1660 int msf_flag;
1661 int stat, ntracks, i;
1662 struct atapi_toc *toc = drive->cdrom_info.toc;
1663 struct {
1664 struct atapi_toc_header hdr;
1665 struct atapi_toc_entry ent;
1666 } ms_tmp;
1667
1668 if (toc == NULL)
1669 {
1670
1671 toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
1672 GFP_KERNEL);
1673 drive->cdrom_info.toc = toc;
1674 }
1675
1676 if (toc == NULL)
1677 {
1678 printk ("%s: No cdrom TOC buffer!\n", drive->name);
1679 return -EIO;
1680 }
1681
1682
1683
1684 if (CDROM_STATE_FLAGS (drive)->toc_valid)
1685 (void) cdrom_check_status (drive, NULL);
1686
1687 if (CDROM_STATE_FLAGS (drive)->toc_valid) return 0;
1688
1689 #if STANDARD_ATAPI
1690 msf_flag = 0;
1691 #else
1692
1693 msf_flag = (CDROM_CONFIG_FLAGS (drive)->no_lba_toc);
1694 #endif
1695
1696
1697 stat = cdrom_read_tocentry (drive, 0, msf_flag, 0, (char *)&toc->hdr,
1698 sizeof (struct atapi_toc_header) +
1699 sizeof (struct atapi_toc_entry),
1700 reqbuf);
1701 if (stat) return stat;
1702
1703 #if ! STANDARD_ATAPI
1704 if (CDROM_CONFIG_FLAGS (drive)->vertos_lossage)
1705 {
1706 toc->hdr.first_track = bcd2bin (toc->hdr.first_track);
1707 toc->hdr.last_track = bcd2bin (toc->hdr.last_track);
1708
1709 }
1710 #endif
1711
1712 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1713 if (ntracks <= 0) return -EIO;
1714 if (ntracks > MAX_TRACKS) ntracks = MAX_TRACKS;
1715
1716
1717 stat = cdrom_read_tocentry (drive, 0, msf_flag, 0, (char *)&toc->hdr,
1718 sizeof (struct atapi_toc_header) +
1719 (ntracks+1) * sizeof (struct atapi_toc_entry),
1720 reqbuf);
1721 if (stat) return stat;
1722 toc->hdr.toc_length = ntohs (toc->hdr.toc_length);
1723
1724 #if ! STANDARD_ATAPI
1725 if (CDROM_CONFIG_FLAGS (drive)->vertos_lossage)
1726 {
1727 toc->hdr.first_track = bcd2bin (toc->hdr.first_track);
1728 toc->hdr.last_track = bcd2bin (toc->hdr.last_track);
1729
1730 }
1731 #endif
1732
1733 for (i=0; i<=ntracks; i++)
1734 {
1735 #if ! STANDARD_ATAPI
1736 if (msf_flag)
1737 {
1738 if (CDROM_CONFIG_FLAGS (drive)->vertos_lossage)
1739 {
1740 toc->ent[i].track = bcd2bin (toc->ent[i].track);
1741 toc->ent[i].addr.msf.m = bcd2bin (toc->ent[i].addr.msf.m);
1742 toc->ent[i].addr.msf.s = bcd2bin (toc->ent[i].addr.msf.s);
1743 toc->ent[i].addr.msf.f = bcd2bin (toc->ent[i].addr.msf.f);
1744 }
1745 toc->ent[i].addr.lba = msf_to_lba (toc->ent[i].addr.msf.m,
1746 toc->ent[i].addr.msf.s,
1747 toc->ent[i].addr.msf.f);
1748 }
1749 else
1750 #endif
1751 toc->ent[i].addr.lba = ntohl (toc->ent[i].addr.lba);
1752 }
1753
1754
1755 stat = cdrom_read_tocentry (drive, 0, msf_flag, 1,
1756 (char *)&ms_tmp, sizeof (ms_tmp),
1757 reqbuf);
1758 if (stat) return stat;
1759 #if ! STANDARD_ATAPI
1760 if (msf_flag)
1761 toc->last_session_lba = msf_to_lba (ms_tmp.ent.addr.msf.m,
1762 ms_tmp.ent.addr.msf.s,
1763 ms_tmp.ent.addr.msf.f);
1764 else
1765 #endif
1766 toc->last_session_lba = ntohl (ms_tmp.ent.addr.lba);
1767
1768 toc->xa_flag = (ms_tmp.hdr.first_track != ms_tmp.hdr.last_track);
1769
1770
1771 stat = cdrom_read_capacity (drive, &toc->capacity, reqbuf);
1772 if (stat) toc->capacity = 0x1fffff;
1773
1774 HWIF(drive)->gd->sizes[drive->select.b.unit << PARTN_BITS]
1775 = toc->capacity * SECTORS_PER_FRAME;
1776 drive->part[0].nr_sects = toc->capacity * SECTORS_PER_FRAME;
1777
1778
1779 CDROM_STATE_FLAGS (drive)->toc_valid = 1;
1780
1781 return 0;
1782 }
1783
1784
1785 static int
1786 cdrom_read_subchannel (ide_drive_t *drive,
1787 char *buf, int buflen,
1788 struct atapi_request_sense *reqbuf)
1789 {
1790 struct packet_command pc;
1791
1792 memset (&pc, 0, sizeof (pc));
1793 pc.sense_data = reqbuf;
1794
1795 pc.buffer = buf;
1796 pc.buflen = buflen;
1797 pc.c[0] = SCMD_READ_SUBCHANNEL;
1798 pc.c[2] = 0x40;
1799 pc.c[3] = 0x01;
1800 pc.c[7] = (buflen >> 8);
1801 pc.c[8] = (buflen & 0xff);
1802 return cdrom_queue_packet_command (drive, &pc);
1803 }
1804
1805
1806
1807 static int
1808 cdrom_mode_sense (ide_drive_t *drive, int pageno, int modeflag,
1809 char *buf, int buflen,
1810 struct atapi_request_sense *reqbuf)
1811 {
1812 struct packet_command pc;
1813
1814 memset (&pc, 0, sizeof (pc));
1815 pc.sense_data = reqbuf;
1816
1817 pc.buffer = buf;
1818 pc.buflen = buflen;
1819 pc.c[0] = MODE_SENSE_10;
1820 pc.c[2] = pageno | (modeflag << 6);
1821 pc.c[7] = (buflen >> 8);
1822 pc.c[8] = (buflen & 0xff);
1823 return cdrom_queue_packet_command (drive, &pc);
1824 }
1825
1826
1827 static int
1828 cdrom_mode_select (ide_drive_t *drive, int pageno, char *buf, int buflen,
1829 struct atapi_request_sense *reqbuf)
1830 {
1831 struct packet_command pc;
1832
1833 memset (&pc, 0, sizeof (pc));
1834 pc.sense_data = reqbuf;
1835
1836 pc.buffer = buf;
1837 pc.buflen = - buflen;
1838 pc.c[0] = MODE_SELECT_10;
1839 pc.c[1] = 0x10;
1840 pc.c[2] = pageno;
1841 pc.c[7] = (buflen >> 8);
1842 pc.c[8] = (buflen & 0xff);
1843 return cdrom_queue_packet_command (drive, &pc);
1844 }
1845
1846
1847 static int
1848 cdrom_play_lba_range_play12 (ide_drive_t *drive, int lba_start, int lba_end,
1849 struct atapi_request_sense *reqbuf)
1850 {
1851 struct packet_command pc;
1852
1853 memset (&pc, 0, sizeof (pc));
1854 pc.sense_data = reqbuf;
1855
1856 pc.c[0] = SCMD_PLAYAUDIO12;
1857 *(int *)(&pc.c[2]) = htonl (lba_start);
1858 *(int *)(&pc.c[6]) = htonl (lba_end - lba_start);
1859
1860 return cdrom_queue_packet_command (drive, &pc);
1861 }
1862
1863
1864 #if ! STANDARD_ATAPI
1865 static int
1866 cdrom_play_lba_range_msf (ide_drive_t *drive, int lba_start, int lba_end,
1867 struct atapi_request_sense *reqbuf)
1868 {
1869 struct packet_command pc;
1870
1871 memset (&pc, 0, sizeof (pc));
1872 pc.sense_data = reqbuf;
1873
1874 pc.c[0] = SCMD_PLAYAUDIO_MSF;
1875 lba_to_msf (lba_start, &pc.c[3], &pc.c[4], &pc.c[5]);
1876 lba_to_msf (lba_end-1, &pc.c[6], &pc.c[7], &pc.c[8]);
1877
1878 if (CDROM_CONFIG_FLAGS (drive)->playmsf_uses_bcd)
1879 {
1880 pc.c[3] = bin2bcd (pc.c[3]);
1881 pc.c[4] = bin2bcd (pc.c[4]);
1882 pc.c[5] = bin2bcd (pc.c[5]);
1883 pc.c[6] = bin2bcd (pc.c[6]);
1884 pc.c[7] = bin2bcd (pc.c[7]);
1885 pc.c[8] = bin2bcd (pc.c[8]);
1886 }
1887
1888 return cdrom_queue_packet_command (drive, &pc);
1889 }
1890 #endif
1891
1892
1893
1894
1895 static int
1896 cdrom_play_lba_range (ide_drive_t *drive, int lba_start, int lba_end,
1897 struct atapi_request_sense *reqbuf)
1898 {
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910 #if ! STANDARD_ATAPI
1911 if (CDROM_CONFIG_FLAGS (drive)->no_playaudio12)
1912 return cdrom_play_lba_range_msf (drive, lba_start, lba_end, reqbuf);
1913 else
1914 #endif
1915 {
1916 int stat;
1917 struct atapi_request_sense my_reqbuf;
1918
1919 if (reqbuf == NULL)
1920 reqbuf = &my_reqbuf;
1921
1922 stat = cdrom_play_lba_range_play12 (drive, lba_start, lba_end, reqbuf);
1923 if (stat == 0) return 0;
1924
1925 #if ! STANDARD_ATAPI
1926
1927 if (reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x20)
1928 {
1929
1930
1931 printk ("%s: Drive does not support PLAYAUDIO12; "
1932 "trying PLAYAUDIO_MSF\n", drive->name);
1933 CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 1;
1934 CDROM_CONFIG_FLAGS (drive)->playmsf_uses_bcd = 1;
1935 return cdrom_play_lba_range_msf (drive, lba_start, lba_end, reqbuf);
1936 }
1937 #endif
1938
1939
1940 return stat;
1941 }
1942 }
1943
1944
1945 static
1946 int cdrom_get_toc_entry (ide_drive_t *drive, int track,
1947 struct atapi_toc_entry **ent,
1948 struct atapi_request_sense *reqbuf)
1949 {
1950 int stat, ntracks;
1951 struct atapi_toc *toc;
1952
1953
1954 stat = cdrom_read_toc (drive, reqbuf);
1955 if (stat) return stat;
1956
1957 toc = drive->cdrom_info.toc;
1958
1959
1960 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1961 if (track == CDROM_LEADOUT)
1962 *ent = &toc->ent[ntracks];
1963 else if (track < toc->hdr.first_track ||
1964 track > toc->hdr.last_track)
1965 return -EINVAL;
1966 else
1967 *ent = &toc->ent[track - toc->hdr.first_track];
1968
1969 return 0;
1970 }
1971
1972
1973 static int
1974 cdrom_read_block (ide_drive_t *drive, int format, int lba,
1975 char *buf, int buflen,
1976 struct atapi_request_sense *reqbuf)
1977 {
1978 struct packet_command pc;
1979 struct atapi_request_sense my_reqbuf;
1980 int stat;
1981
1982 if (reqbuf == NULL)
1983 reqbuf = &my_reqbuf;
1984
1985 memset (&pc, 0, sizeof (pc));
1986 pc.sense_data = reqbuf;
1987
1988 pc.buffer = buf;
1989 pc.buflen = buflen;
1990
1991 #if ! STANDARD_ATAPI
1992 if (CDROM_CONFIG_FLAGS (drive)->old_readcd)
1993 pc.c[0] = 0xd4;
1994 else
1995 #endif
1996 pc.c[0] = READ_CD;
1997
1998 pc.c[1] = (format << 2);
1999 *(int *)(&pc.c[2]) = htonl (lba);
2000 pc.c[8] = 1;
2001 pc.c[9] = 0x10;
2002
2003 stat = cdrom_queue_packet_command (drive, &pc);
2004
2005 #if ! STANDARD_ATAPI
2006
2007
2008 if (stat && reqbuf->sense_key == ILLEGAL_REQUEST && reqbuf->asc == 0x20 &&
2009 CDROM_CONFIG_FLAGS (drive)->old_readcd == 0)
2010 {
2011 printk ("%s: Drive does not recognize READ_CD; trying opcode 0xd4\n",
2012 drive->name);
2013 CDROM_CONFIG_FLAGS (drive)->old_readcd = 1;
2014 return cdrom_read_block (drive, format, lba, buf, buflen, reqbuf);
2015 }
2016 #endif
2017
2018 return stat;
2019 }
2020
2021
2022 int ide_cdrom_ioctl (ide_drive_t *drive, struct inode *inode,
2023 struct file *file, unsigned int cmd, unsigned long arg)
2024 {
2025 switch (cmd)
2026 {
2027 case CDROMEJECT:
2028 {
2029 int stat;
2030
2031 if (drive->usage > 1)
2032 return -EBUSY;
2033
2034 stat = cdrom_lockdoor (drive, 0, NULL);
2035 if (stat) return stat;
2036
2037 return cdrom_eject (drive, 0, NULL);
2038 }
2039
2040 case CDROMEJECT_SW:
2041 {
2042 CDROM_STATE_FLAGS (drive)->eject_on_close = arg;
2043 return 0;
2044 }
2045
2046 case CDROMPAUSE:
2047 return cdrom_pause (drive, 1, NULL);
2048
2049 case CDROMRESUME:
2050 return cdrom_pause (drive, 0, NULL);
2051
2052 case CDROMSTART:
2053 return cdrom_startstop (drive, 1, NULL);
2054
2055 case CDROMSTOP:
2056 {
2057 int stat;
2058
2059 stat = cdrom_startstop (drive, 0, NULL);
2060 if (stat) return stat;
2061
2062 return cdrom_eject (drive, 1, NULL);
2063 }
2064
2065 case CDROMPLAYMSF:
2066 {
2067 struct cdrom_msf msf;
2068 int stat, lba_start, lba_end;
2069
2070 stat = verify_area (VERIFY_READ, (void *)arg, sizeof (msf));
2071 if (stat) return stat;
2072
2073 memcpy_fromfs (&msf, (void *) arg, sizeof(msf));
2074
2075 lba_start = msf_to_lba (msf.cdmsf_min0, msf.cdmsf_sec0,
2076 msf.cdmsf_frame0);
2077 lba_end = msf_to_lba (msf.cdmsf_min1, msf.cdmsf_sec1,
2078 msf.cdmsf_frame1) + 1;
2079
2080 if (lba_end <= lba_start) return -EINVAL;
2081
2082 return cdrom_play_lba_range (drive, lba_start, lba_end, NULL);
2083 }
2084
2085
2086
2087 case CDROMPLAYTRKIND:
2088 {
2089 int stat, lba_start, lba_end;
2090 struct cdrom_ti ti;
2091 struct atapi_toc_entry *first_toc, *last_toc;
2092
2093 stat = verify_area (VERIFY_READ, (void *)arg, sizeof (ti));
2094 if (stat) return stat;
2095
2096 memcpy_fromfs (&ti, (void *) arg, sizeof(ti));
2097
2098 stat = cdrom_get_toc_entry (drive, ti.cdti_trk0, &first_toc, NULL);
2099 if (stat) return stat;
2100 stat = cdrom_get_toc_entry (drive, ti.cdti_trk1, &last_toc, NULL);
2101 if (stat) return stat;
2102
2103 if (ti.cdti_trk1 != CDROM_LEADOUT) ++last_toc;
2104 lba_start = first_toc->addr.lba;
2105 lba_end = last_toc->addr.lba;
2106
2107 if (lba_end <= lba_start) return -EINVAL;
2108
2109 return cdrom_play_lba_range (drive, lba_start, lba_end, NULL);
2110 }
2111
2112 case CDROMREADTOCHDR:
2113 {
2114 int stat;
2115 struct cdrom_tochdr tochdr;
2116 struct atapi_toc *toc;
2117
2118 stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (tochdr));
2119 if (stat) return stat;
2120
2121
2122 stat = cdrom_read_toc (drive, NULL);
2123 if (stat) return stat;
2124
2125 toc = drive->cdrom_info.toc;
2126 tochdr.cdth_trk0 = toc->hdr.first_track;
2127 tochdr.cdth_trk1 = toc->hdr.last_track;
2128
2129 memcpy_tofs ((void *) arg, &tochdr, sizeof (tochdr));
2130
2131 return stat;
2132 }
2133
2134 case CDROMREADTOCENTRY:
2135 {
2136 int stat;
2137 struct cdrom_tocentry tocentry;
2138 struct atapi_toc_entry *toce;
2139
2140 stat = verify_area (VERIFY_READ, (void *) arg, sizeof (tocentry));
2141 if (stat) return stat;
2142 stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (tocentry));
2143 if (stat) return stat;
2144
2145 memcpy_fromfs (&tocentry, (void *) arg, sizeof (tocentry));
2146
2147 stat = cdrom_get_toc_entry (drive, tocentry.cdte_track, &toce, NULL);
2148 if (stat) return stat;
2149
2150 tocentry.cdte_ctrl = toce->control;
2151 tocentry.cdte_adr = toce->adr;
2152
2153 if (tocentry.cdte_format == CDROM_MSF)
2154 {
2155
2156 lba_to_msf (toce->addr.lba,
2157 &tocentry.cdte_addr.msf.minute,
2158 &tocentry.cdte_addr.msf.second,
2159 &tocentry.cdte_addr.msf.frame);
2160 }
2161 else
2162 tocentry.cdte_addr.lba = toce->addr.lba;
2163
2164 memcpy_tofs ((void *) arg, &tocentry, sizeof (tocentry));
2165
2166 return stat;
2167 }
2168
2169 case CDROMSUBCHNL:
2170 {
2171 struct atapi_cdrom_subchnl scbuf;
2172 int stat, abs_lba, rel_lba;
2173 struct cdrom_subchnl subchnl;
2174
2175 stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (subchnl));
2176 if (stat) return stat;
2177 stat = verify_area (VERIFY_READ, (void *) arg, sizeof (subchnl));
2178 if (stat) return stat;
2179
2180 memcpy_fromfs (&subchnl, (void *) arg, sizeof (subchnl));
2181
2182 stat = cdrom_read_subchannel (drive, (char *)&scbuf, sizeof (scbuf),
2183 NULL);
2184 if (stat) return stat;
2185
2186 #if ! STANDARD_ATAPI
2187 if (CDROM_CONFIG_FLAGS (drive)->vertos_lossage)
2188 {
2189 abs_lba = msf_to_lba (bcd2bin (scbuf.acdsc_absaddr.msf.minute),
2190 bcd2bin (scbuf.acdsc_absaddr.msf.second),
2191 bcd2bin (scbuf.acdsc_absaddr.msf.frame));
2192 rel_lba = msf_to_lba (bcd2bin (scbuf.acdsc_reladdr.msf.minute),
2193 bcd2bin (scbuf.acdsc_reladdr.msf.second),
2194 bcd2bin (scbuf.acdsc_reladdr.msf.frame));
2195 scbuf.acdsc_trk = bcd2bin (scbuf.acdsc_trk);
2196 }
2197 else
2198 #endif
2199 {
2200 abs_lba = ntohl (scbuf.acdsc_absaddr.lba);
2201 rel_lba = ntohl (scbuf.acdsc_reladdr.lba);
2202 }
2203
2204 if (subchnl.cdsc_format == CDROM_MSF)
2205 {
2206 lba_to_msf (abs_lba,
2207 &subchnl.cdsc_absaddr.msf.minute,
2208 &subchnl.cdsc_absaddr.msf.second,
2209 &subchnl.cdsc_absaddr.msf.frame);
2210 lba_to_msf (rel_lba,
2211 &subchnl.cdsc_reladdr.msf.minute,
2212 &subchnl.cdsc_reladdr.msf.second,
2213 &subchnl.cdsc_reladdr.msf.frame);
2214 }
2215 else
2216 {
2217 subchnl.cdsc_absaddr.lba = abs_lba;
2218 subchnl.cdsc_reladdr.lba = rel_lba;
2219 }
2220
2221 subchnl.cdsc_audiostatus = scbuf.acdsc_audiostatus;
2222 subchnl.cdsc_ctrl = scbuf.acdsc_ctrl;
2223 subchnl.cdsc_trk = scbuf.acdsc_trk;
2224 subchnl.cdsc_ind = scbuf.acdsc_ind;
2225
2226 memcpy_tofs ((void *) arg, &subchnl, sizeof (subchnl));
2227
2228 return stat;
2229 }
2230
2231 case CDROMVOLCTRL:
2232 {
2233 struct cdrom_volctrl volctrl;
2234 char buffer[24], mask[24];
2235 int stat;
2236
2237 stat = verify_area (VERIFY_READ, (void *) arg, sizeof (volctrl));
2238 if (stat) return stat;
2239 memcpy_fromfs (&volctrl, (void *) arg, sizeof (volctrl));
2240
2241 stat = cdrom_mode_sense (drive, 0x0e, 0, buffer, sizeof (buffer),NULL);
2242 if (stat) return stat;
2243 stat = cdrom_mode_sense (drive, 0x0e, 1, mask , sizeof (buffer),NULL);
2244 if (stat) return stat;
2245
2246 buffer[1] = buffer[2] = 0;
2247
2248 buffer[17] = volctrl.channel0 & mask[17];
2249 buffer[19] = volctrl.channel1 & mask[19];
2250 buffer[21] = volctrl.channel2 & mask[21];
2251 buffer[23] = volctrl.channel3 & mask[23];
2252
2253 return cdrom_mode_select (drive, 0x0e, buffer, sizeof (buffer), NULL);
2254 }
2255
2256 case CDROMVOLREAD:
2257 {
2258 struct cdrom_volctrl volctrl;
2259 char buffer[24];
2260 int stat;
2261
2262 stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (volctrl));
2263 if (stat) return stat;
2264
2265 stat = cdrom_mode_sense (drive, 0x0e, 0, buffer, sizeof (buffer), NULL);
2266 if (stat) return stat;
2267
2268 volctrl.channel0 = buffer[17];
2269 volctrl.channel1 = buffer[19];
2270 volctrl.channel2 = buffer[21];
2271 volctrl.channel3 = buffer[23];
2272
2273 memcpy_tofs ((void *) arg, &volctrl, sizeof (volctrl));
2274
2275 return 0;
2276 }
2277
2278 case CDROMMULTISESSION:
2279 {
2280 struct cdrom_multisession ms_info;
2281 struct atapi_toc *toc;
2282 int stat;
2283
2284 stat = verify_area (VERIFY_READ, (void *)arg, sizeof (ms_info));
2285 if (stat) return stat;
2286 stat = verify_area (VERIFY_WRITE, (void *)arg, sizeof (ms_info));
2287 if (stat) return stat;
2288
2289 memcpy_fromfs (&ms_info, (void *)arg, sizeof (ms_info));
2290
2291
2292 stat = cdrom_read_toc (drive, NULL);
2293 if (stat) return stat;
2294
2295 toc = drive->cdrom_info.toc;
2296
2297 if (ms_info.addr_format == CDROM_MSF)
2298 lba_to_msf (toc->last_session_lba,
2299 &ms_info.addr.msf.minute,
2300 &ms_info.addr.msf.second,
2301 &ms_info.addr.msf.frame);
2302
2303 else if (ms_info.addr_format == CDROM_LBA)
2304 ms_info.addr.lba = toc->last_session_lba;
2305
2306 else
2307 return -EINVAL;
2308
2309 ms_info.xa_flag = toc->xa_flag;
2310
2311 memcpy_tofs ((void *)arg, &ms_info, sizeof (ms_info));
2312
2313 return 0;
2314 }
2315
2316
2317 case CDROMREADAUDIO:
2318 {
2319 int stat, lba;
2320 struct atapi_toc *toc;
2321 struct cdrom_read_audio ra;
2322 char buf[CD_FRAMESIZE_RAW];
2323
2324
2325 stat = cdrom_read_toc (drive, NULL);
2326 if (stat) return stat;
2327
2328 toc = drive->cdrom_info.toc;
2329
2330 stat = verify_area (VERIFY_READ, (char *)arg, sizeof (ra));
2331 if (stat) return stat;
2332
2333 memcpy_fromfs (&ra, (void *)arg, sizeof (ra));
2334
2335 if (ra.nframes < 0 || ra.nframes > toc->capacity)
2336 return -EINVAL;
2337 else if (ra.nframes == 0)
2338 return 0;
2339
2340 stat = verify_area (VERIFY_WRITE, (char *)ra.buf,
2341 ra.nframes * CD_FRAMESIZE_RAW);
2342 if (stat) return stat;
2343
2344 if (ra.addr_format == CDROM_MSF)
2345 lba = msf_to_lba (ra.addr.msf.minute, ra.addr.msf.second,
2346 ra.addr.msf.frame);
2347
2348 else if (ra.addr_format == CDROM_LBA)
2349 lba = ra.addr.lba;
2350
2351 else
2352 return -EINVAL;
2353
2354 if (lba < 0 || lba >= toc->capacity)
2355 return -EINVAL;
2356
2357 while (ra.nframes > 0)
2358 {
2359 stat = cdrom_read_block (drive, 1, lba, buf,
2360 CD_FRAMESIZE_RAW, NULL);
2361 if (stat) return stat;
2362 memcpy_tofs (ra.buf, buf, CD_FRAMESIZE_RAW);
2363 ra.buf += CD_FRAMESIZE_RAW;
2364 --ra.nframes;
2365 ++lba;
2366 }
2367
2368 return 0;
2369 }
2370
2371 case CDROMREADMODE1:
2372 case CDROMREADMODE2:
2373 {
2374 struct cdrom_msf msf;
2375 int blocksize, format, stat, lba;
2376 struct atapi_toc *toc;
2377 char buf[CD_FRAMESIZE_RAW0];
2378
2379 if (cmd == CDROMREADMODE1)
2380 {
2381 blocksize = CD_FRAMESIZE;
2382 format = 2;
2383 }
2384 else
2385 {
2386 blocksize = CD_FRAMESIZE_RAW0;
2387 format = 3;
2388 }
2389
2390 stat = verify_area (VERIFY_READ, (char *)arg, sizeof (msf));
2391 if (stat) return stat;
2392 stat = verify_area (VERIFY_WRITE, (char *)arg, blocksize);
2393 if (stat) return stat;
2394
2395 memcpy_fromfs (&msf, (void *)arg, sizeof (msf));
2396
2397 lba = msf_to_lba (msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0);
2398
2399
2400 stat = cdrom_read_toc (drive, NULL);
2401 if (stat) return stat;
2402
2403 toc = drive->cdrom_info.toc;
2404
2405 if (lba < 0 || lba >= toc->capacity)
2406 return -EINVAL;
2407
2408 stat = cdrom_read_block (drive, format, lba, buf, blocksize, NULL);
2409 if (stat) return stat;
2410
2411 memcpy_tofs ((char *)arg, buf, blocksize);
2412 return 0;
2413 }
2414
2415 #if 0
2416 case CDROMRESET:
2417 {
2418 struct request req;
2419 ide_init_drive_cmd (&req);
2420 req.cmd = RESET_DRIVE_COMMAND;
2421 return ide_do_drive_cmd (drive, &req, ide_wait);
2422 }
2423 #endif
2424
2425
2426 #ifdef TEST
2427 case 0x1234:
2428 {
2429 int stat;
2430 struct packet_command pc;
2431 int len, lena;
2432
2433 memset (&pc, 0, sizeof (pc));
2434
2435 stat = verify_area (VERIFY_READ, (void *) arg, sizeof (pc.c));
2436 if (stat) return stat;
2437 memcpy_fromfs (&pc.c, (void *) arg, sizeof (pc.c));
2438 arg += sizeof (pc.c);
2439
2440 stat = verify_area (VERIFY_READ, (void *) arg, sizeof (len));
2441 if (stat) return stat;
2442 memcpy_fromfs (&len, (void *) arg , sizeof (len));
2443 arg += sizeof (len);
2444
2445 if (len > 0) {
2446 stat = verify_area (VERIFY_WRITE, (void *) arg, len);
2447 if (stat) return stat;
2448 }
2449
2450 lena = len;
2451 if (lena < 0) lena = 0;
2452
2453 {
2454 char buf[lena];
2455 if (len > 0) {
2456 pc.buflen = len;
2457 pc.buffer = buf;
2458 }
2459
2460 stat = cdrom_queue_packet_command (drive, &pc);
2461
2462 if (len > 0)
2463 memcpy_tofs ((void *)arg, buf, len);
2464 }
2465
2466 return stat;
2467 }
2468 #endif
2469
2470 default:
2471 return -EPERM;
2472 }
2473
2474 }
2475
2476
2477
2478
2479
2480
2481
2482 int ide_cdrom_check_media_change (ide_drive_t *drive)
2483 {
2484 int retval;
2485
2486 (void) cdrom_check_status (drive, NULL);
2487
2488 retval = CDROM_STATE_FLAGS (drive)->media_changed;
2489 CDROM_STATE_FLAGS (drive)->media_changed = 0;
2490
2491 return retval;
2492 }
2493
2494
2495 int ide_cdrom_open (struct inode *ip, struct file *fp, ide_drive_t *drive)
2496 {
2497
2498 if (fp->f_mode & 2)
2499 {
2500 --drive->usage;
2501 return -EROFS;
2502 }
2503
2504
2505 if (drive->usage == 1)
2506 {
2507 int stat;
2508 struct atapi_request_sense my_reqbuf;
2509 my_reqbuf.sense_key = 0;
2510
2511
2512 stat = cdrom_check_status (drive, &my_reqbuf);
2513
2514
2515 if (stat && my_reqbuf.sense_key == NOT_READY)
2516 {
2517 cdrom_eject (drive, 1, &my_reqbuf);
2518 stat = cdrom_check_status (drive, &my_reqbuf);
2519 }
2520
2521
2522 if (stat && my_reqbuf.sense_key != UNIT_ATTENTION)
2523 {
2524 --drive->usage;
2525 return -ENXIO;
2526 }
2527
2528
2529 (void) cdrom_lockdoor (drive, 1, &my_reqbuf);
2530
2531
2532 (void) cdrom_read_toc (drive, &my_reqbuf);
2533 }
2534
2535 return 0;
2536 }
2537
2538
2539
2540
2541
2542
2543 void ide_cdrom_release (struct inode *inode, struct file *file, ide_drive_t *drive)
2544 {
2545 if (drive->usage == 0)
2546 {
2547 invalidate_buffers (inode->i_rdev);
2548
2549
2550 (void) cdrom_lockdoor (drive, 0, NULL);
2551
2552
2553 if (CDROM_STATE_FLAGS (drive)->eject_on_close)
2554 (void) cdrom_eject (drive, 0, NULL);
2555 }
2556 }
2557
2558
2559
2560
2561
2562
2563
2564 void ide_cdrom_setup (ide_drive_t *drive)
2565 {
2566 blksize_size[HWIF(drive)->major][drive->select.b.unit << PARTN_BITS] = CD_FRAMESIZE;
2567
2568 drive->special.all = 0;
2569 drive->ready_stat = 0;
2570
2571 CDROM_STATE_FLAGS (drive)->media_changed = 0;
2572 CDROM_STATE_FLAGS (drive)->toc_valid = 0;
2573 CDROM_STATE_FLAGS (drive)->door_locked = 0;
2574
2575
2576 CDROM_STATE_FLAGS (drive)->eject_on_close= 0;
2577
2578 CDROM_CONFIG_FLAGS (drive)->no_doorlock = 0;
2579 CDROM_CONFIG_FLAGS (drive)->drq_interrupt =
2580 ((drive->id->config & 0x0060) == 0x20);
2581
2582 #if ! STANDARD_ATAPI
2583 CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 0;
2584 CDROM_CONFIG_FLAGS (drive)->old_readcd = 0;
2585 CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 0;
2586 CDROM_CONFIG_FLAGS (drive)->playmsf_uses_bcd = 0;
2587 CDROM_CONFIG_FLAGS (drive)->vertos_lossage = 0;
2588
2589
2590 if (strcmp (drive->id->model, "CD220E") == 0 ||
2591 strcmp (drive->id->model, "CD") == 0)
2592 CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2593
2594 else if (strcmp (drive->id->model, "TO-ICSLYAL") == 0 ||
2595 strcmp (drive->id->model, "OTI-SCYLLA") == 0)
2596 CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2597
2598
2599
2600 else if (strcmp (drive->id->model, "DCI-2S10") == 0)
2601 CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2602
2603 else if (strcmp (drive->id->model, "CDA26803I SE") == 0)
2604 {
2605 CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2606
2607
2608 CDROM_CONFIG_FLAGS (drive)->no_playaudio12 = 1;
2609 }
2610
2611 else if (strcmp (drive->id->model, "V003S0DS") == 0 ||
2612 strcmp (drive->id->model, "0V300SSD") == 0)
2613 {
2614 CDROM_CONFIG_FLAGS (drive)->vertos_lossage = 1;
2615 CDROM_CONFIG_FLAGS (drive)->playmsf_uses_bcd = 1;
2616 CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2617 }
2618
2619 else if (strcmp (drive->id->model, "V004E0DT") == 0 ||
2620 strcmp (drive->id->model, "0V400ETD") == 0)
2621 CDROM_CONFIG_FLAGS (drive)->no_lba_toc = 1;
2622 #endif
2623
2624 drive->cdrom_info.toc = NULL;
2625 drive->cdrom_info.sector_buffer = NULL;
2626 drive->cdrom_info.sector_buffered = 0;
2627 drive->cdrom_info.nsectors_buffered = 0;
2628 }
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643