This source file includes following definitions.
- 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_queue_packet_command
- do_rw_cdrom
- byte_swap_word
- byte_swap_long
- bin2bcd
- lba_to_msf
- msf_to_lba
- cdrom_check_status
- cdrom_request_sense
- cdrom_lockdoor
- cdrom_eject
- cdrom_pause
- cdrom_startstop
- 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
- ide_cdrom_ioctl
- cdrom_check_media_change
- cdrom_open
- cdrom_release
- 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 #include <linux/cdrom.h>
37
38 #define SECTOR_SIZE 512
39 #define SECTOR_BITS 9
40 #define SECTORS_PER_FRAME (CD_FRAMESIZE / SECTOR_SIZE)
41
42 #define MIN(a,b) ((a) < (b) ? (a) : (b))
43
44 #if 1
45 #define OUT_WORDS(b,n) outsw (IDE_PORT (HD_DATA, dev->hwif), (b), (n))
46 #define IN_WORDS(b,n) insw (IDE_PORT (HD_DATA, dev->hwif), (b), (n))
47 #else
48 #define OUT_WORDS(b,n) output_ide_data(dev,b,(n)/2)
49 #define IN_WORDS(b,n) input_ide_data(dev,b,(n)/2)
50 #endif
51
52
53 #define PACKET_COMMAND 4315
54
55 #define WIN_PACKETCMD 0xa0
56
57
58
59 #define TEST_UNIT_READY 0x00
60 #define REQUEST_SENSE 0x03
61 #define START_STOP 0x1b
62 #define ALLOW_MEDIUM_REMOVAL 0x1e
63 #define READ_10 0x28
64 #define MODE_SENSE_10 0x5a
65 #define MODE_SELECT_10 0x55
66
67 struct packet_command {
68 char *buffer;
69 int buflen;
70 int stat;
71 unsigned char c[12];
72 };
73
74
75 struct atapi_request_sense {
76 unsigned char error_code : 7;
77 unsigned char valid : 1;
78 byte reserved1;
79 unsigned char sense_key : 4;
80 unsigned char reserved2 : 1;
81 unsigned char ili : 1;
82 unsigned char reserved3 : 2;
83 byte info[4];
84 byte sense_len;
85 byte command_info[4];
86 byte asc;
87 byte ascq;
88 byte fru;
89 byte sense_key_specific[3];
90 };
91
92
93
94
95
96 struct ide_cd_flags {
97 unsigned drq_interrupt : 1;
98
99 unsigned no_playaudio12: 1;
100
101 unsigned media_changed : 1;
102 unsigned toc_valid : 1;
103 unsigned no_lba_toc : 1;
104 unsigned reserved : 3;
105 };
106
107 #define CDROM_FLAGS(dev) ((struct ide_cd_flags *)&((dev)->bios_sect))
108
109
110
111
112 #define MAX_TRACKS 99
113 struct atapi_toc_header {
114 unsigned short toc_length;
115 byte first_track;
116 byte last_track;
117 };
118
119 struct atapi_toc_entry {
120 byte reserved1;
121 unsigned control : 4;
122 unsigned adr : 4;
123 byte track;
124 byte reserved2;
125 unsigned lba;
126 };
127
128 struct atapi_toc {
129 struct atapi_toc_header hdr;
130 struct atapi_toc_entry ent[MAX_TRACKS+1];
131 };
132
133
134 #define SECTOR_BUFFER_SIZE CD_FRAMESIZE
135
136
137 struct cdrom_info {
138
139
140
141
142 struct atapi_toc *toc;
143
144
145
146
147
148
149
150
151 unsigned long sector_buffered;
152 unsigned long nsectors_buffered;
153 char *sector_buffer;
154 };
155
156
157 static struct cdrom_info cdrom_info[2][MAX_DRIVES];
158
159
160
161
162
163
164
165
166 static void cdrom_end_request (int uptodate, ide_dev_t *dev)
167 {
168 struct request *rq = ide_cur_rq[dev->hwif];
169
170
171
172 if (!uptodate && rq->bh != 0)
173 {
174 int adj = rq->current_nr_sectors - 1;
175 rq->current_nr_sectors -= adj;
176 rq->sector += adj;
177 }
178
179 end_request (uptodate, dev->hwif);
180 }
181
182
183
184
185 static void cdrom_saw_media_change (ide_dev_t *dev)
186 {
187 CDROM_FLAGS (dev)->media_changed = 1;
188 CDROM_FLAGS (dev)->toc_valid = 0;
189 cdrom_info[dev->hwif][dev->select.b.drive].nsectors_buffered = 0;
190 }
191
192
193
194
195 static int cdrom_decode_status (ide_dev_t *dev, int good_stat, int *stat_ret)
196 {
197 struct request *rq = ide_cur_rq[dev->hwif];
198 int stat, err;
199
200
201 stat = GET_STAT (dev->hwif);
202 *stat_ret = stat;
203
204 if (OK_STAT (stat, good_stat, BAD_R_STAT))
205 return 0;
206
207
208 err = IN_BYTE (HD_ERROR, dev->hwif);
209
210
211 if ((err & 0xf0) == 0x20)
212 {
213 struct packet_command *pc;
214 cdrom_saw_media_change (dev);
215
216
217 if (rq->cmd == READ)
218 {
219 printk ("%s : tray open\n", dev->name);
220 cdrom_end_request (0, dev);
221 }
222
223 else
224 {
225
226
227
228
229
230
231 pc = (struct packet_command *)rq->buffer;
232 if (pc->c[0] != SCMD_READ_SUBCHANNEL)
233 printk ("%s : tray open\n", dev->name);
234
235
236 pc->stat = 1;
237 cdrom_end_request (1, dev);
238 }
239 }
240
241
242 else if ((err & 0xf0) == 0x60)
243 {
244 cdrom_saw_media_change (dev);
245 printk ("%s: media changed\n", dev->name);
246
247
248
249 if ((++rq->errors > ERROR_MAX))
250 {
251 cdrom_end_request (0, dev);
252 }
253 }
254
255
256 else if (rq->cmd == PACKET_COMMAND)
257 {
258 struct packet_command *pc = (struct packet_command *)rq->buffer;
259 dump_status (dev->hwif, "packet command error", stat);
260 pc->stat = 1;
261 cdrom_end_request (1, dev);
262 }
263
264
265 else if ((err & ~ABRT_ERR) != 0)
266 {
267 ide_error (dev, "cdrom_decode_status", stat);
268 }
269
270
271 else if ((++rq->errors > ERROR_MAX))
272 {
273 cdrom_end_request (0, dev);
274 }
275
276
277 DO_REQUEST;
278 return 1;
279 }
280
281
282
283
284
285
286 static int cdrom_start_packet_command (ide_dev_t *dev, int xferlen)
287 {
288
289 if (wait_stat (dev, 0, BUSY_STAT, WAIT_READY)) return 1;
290
291
292 OUT_BYTE (0, HD_FEATURE);
293 OUT_BYTE (0, HD_NSECTOR);
294 OUT_BYTE (0, HD_SECTOR);
295
296 OUT_BYTE (xferlen & 0xff, HD_LCYL);
297 OUT_BYTE (xferlen >> 8 , HD_HCYL);
298 OUT_BYTE (dev->ctl, HD_CMD);
299 OUT_BYTE (WIN_PACKETCMD, HD_COMMAND);
300
301 return 0;
302 }
303
304
305
306
307
308 static int cdrom_transfer_packet_command (ide_dev_t *dev,
309 char *cmd_buf, int cmd_len)
310 {
311 if (CDROM_FLAGS (dev)->drq_interrupt)
312 {
313
314
315 int stat_dum;
316
317
318 if (cdrom_decode_status (dev, DRQ_STAT, &stat_dum)) return 1;
319 }
320 else
321 {
322
323 if (wait_stat (dev, DRQ_STAT, BAD_STAT, WAIT_READY)) return 1;
324 }
325
326
327 OUT_WORDS (cmd_buf, cmd_len/2);
328
329 return 0;
330 }
331
332
333
334
335
336
337
338
339
340
341
342 static void cdrom_buffer_sectors (ide_dev_t *dev, unsigned long sector,
343 int sectors_to_transfer)
344 {
345 struct cdrom_info *info = &cdrom_info[dev->hwif][dev->select.b.drive];
346
347
348 int sectors_to_buffer = MIN (sectors_to_transfer,
349 (SECTOR_BUFFER_SIZE >> SECTOR_BITS));
350
351 char *dest;
352
353
354
355
356 if (info->sector_buffer == NULL)
357 {
358 info->sector_buffer = (char *) kmalloc (SECTOR_BUFFER_SIZE, GFP_ATOMIC);
359
360
361 if (info->sector_buffer == NULL)
362 sectors_to_buffer = 0;
363 }
364
365
366 info->sector_buffered = sector;
367 info->nsectors_buffered = sectors_to_buffer;
368
369
370 dest = info->sector_buffer;
371 while (sectors_to_buffer > 0)
372 {
373 IN_WORDS (dest, SECTOR_SIZE / 2);
374 --sectors_to_buffer;
375 --sectors_to_transfer;
376 dest += SECTOR_SIZE;
377 }
378
379
380 while (sectors_to_transfer > 0)
381 {
382 char dum[SECTOR_SIZE];
383 IN_WORDS (dest, sizeof (dum) / 2);
384 --sectors_to_transfer;
385 }
386 }
387
388
389
390
391
392
393
394 static inline
395 int cdrom_read_check_ireason (ide_dev_t *dev, int len, int ireason)
396 {
397 ireason &= 3;
398 if (ireason == 2) return 0;
399
400 if (ireason == 0)
401 {
402
403 printk ("%s: cdrom_read_intr: "
404 "Drive wants to transfer data the wrong way!\n",
405 dev->name);
406
407
408
409 while (len > 0)
410 {
411 short dum = 0;
412 OUT_WORDS (&dum, 1);
413 len -= 2;
414 }
415 }
416
417 else
418 {
419
420 printk ("%s: cdrom_read_intr: bad interrupt reason %d\n",
421 dev->name, ireason);
422 }
423
424 cdrom_end_request (0, dev);
425 DO_REQUEST;
426 return -1;
427 }
428
429
430
431
432
433 static void cdrom_read_intr (ide_dev_t *dev)
434 {
435 int stat;
436 int ireason, len, sectors_to_transfer, nskip;
437
438 struct request *rq = ide_cur_rq[dev->hwif];
439
440
441 if (cdrom_decode_status (dev, 0, &stat)) return;
442
443
444 ireason = IN_BYTE (HD_NSECTOR, dev->hwif);
445 len = IN_BYTE (HD_LCYL, dev->hwif) + 256 * IN_BYTE (HD_HCYL, dev->hwif);
446
447
448 if ((stat & DRQ_STAT) == 0)
449 {
450
451
452 if (rq->current_nr_sectors > 0)
453 {
454 printk ("%s: cdrom_read_intr: data underrun (%ld blocks)\n",
455 dev->name, rq->current_nr_sectors);
456 cdrom_end_request (0, dev);
457 }
458 else
459 cdrom_end_request (1, dev);
460
461 DO_REQUEST;
462 return;
463 }
464
465
466 if (cdrom_read_check_ireason (dev, len, ireason)) return;
467
468
469
470 if ((len % SECTOR_SIZE) != 0)
471 {
472 printk ("%s: cdrom_read_intr: Bad transfer size %d\n",
473 dev->name, len);
474 printk (" This drive is not supported by this version of the driver\n");
475 cdrom_end_request (0, dev);
476 DO_REQUEST;
477 return;
478 }
479
480
481 sectors_to_transfer = len / SECTOR_SIZE;
482
483
484 nskip = MIN ((int)(rq->current_nr_sectors - (rq->bh->b_size >> SECTOR_BITS)),
485 sectors_to_transfer);
486
487 while (nskip > 0)
488 {
489
490 char dum[SECTOR_SIZE];
491 IN_WORDS (dum, sizeof (dum) / 2);
492
493 --rq->current_nr_sectors;
494 --nskip;
495 --sectors_to_transfer;
496 }
497
498
499 while (sectors_to_transfer > 0)
500 {
501 int this_transfer;
502
503
504
505 if (rq->current_nr_sectors == 0 &&
506 rq->nr_sectors > 0)
507 cdrom_end_request (1, dev);
508
509
510
511 if (rq->current_nr_sectors == 0)
512 {
513 cdrom_buffer_sectors (dev, rq->sector, sectors_to_transfer);
514 sectors_to_transfer = 0;
515 }
516 else
517 {
518
519
520
521 this_transfer = MIN (sectors_to_transfer,
522 rq->current_nr_sectors);
523
524
525 while (this_transfer > 0)
526 {
527 IN_WORDS (rq->buffer, SECTOR_SIZE / 2);
528 rq->buffer += SECTOR_SIZE;
529 --rq->nr_sectors;
530 --rq->current_nr_sectors;
531 ++rq->sector;
532 --this_transfer;
533 --sectors_to_transfer;
534 }
535 }
536 }
537
538
539
540 ide_handler[dev->hwif] = cdrom_read_intr;
541 }
542
543
544
545
546
547
548 static int cdrom_read_from_buffer (ide_dev_t *dev)
549 {
550 struct cdrom_info *info = &cdrom_info[dev->hwif][dev->select.b.drive];
551 struct request *rq = ide_cur_rq[dev->hwif];
552
553
554 if (info->sector_buffer == NULL) return 0;
555
556
557
558 while (rq->nr_sectors > 0 &&
559 rq->sector >= info->sector_buffered &&
560 rq->sector < info->sector_buffered + info->nsectors_buffered)
561 {
562 if (rq->current_nr_sectors == 0)
563 cdrom_end_request (1, dev);
564
565 memcpy (rq->buffer,
566 info->sector_buffer +
567 (rq->sector - info->sector_buffered) * SECTOR_SIZE,
568 SECTOR_SIZE);
569 rq->buffer += SECTOR_SIZE;
570 --rq->current_nr_sectors;
571 --rq->nr_sectors;
572 ++rq->sector;
573 }
574
575
576 if (rq->nr_sectors == 0)
577 {
578 cdrom_end_request (1, dev);
579 return -1;
580 }
581
582
583 if (rq->current_nr_sectors == 0)
584 cdrom_end_request (1, dev);
585
586
587
588
589
590 if (rq->current_nr_sectors < (rq->bh->b_size >> SECTOR_BITS) &&
591 (rq->sector % SECTORS_PER_FRAME) != 0)
592 {
593 printk ("%s: cdrom_read_from_buffer: buffer botch (%ld)\n",
594 dev->name, rq->sector);
595 cdrom_end_request (0, dev);
596 return -1;
597 }
598
599 return 0;
600 }
601
602
603
604
605
606
607
608
609
610 static int cdrom_start_read_continuation (ide_dev_t *dev)
611 {
612 struct packet_command pc;
613 struct request *rq = ide_cur_rq[dev->hwif];
614
615 int nsect, sector, nframes, frame, nskip;
616
617
618 nsect = rq->nr_sectors;
619
620
621 sector = rq->sector;
622
623
624
625
626
627
628
629 nskip = (sector % SECTORS_PER_FRAME);
630 if (nskip > 0)
631 {
632
633 if (rq->current_nr_sectors != (rq->bh->b_size >> SECTOR_BITS))
634 {
635 printk ("%s: cdrom_start_read_continuation: buffer botch (%ld)\n",
636 dev->name, rq->current_nr_sectors);
637 cdrom_end_request (0, dev);
638 DO_REQUEST;
639 return 1;
640 }
641
642 sector -= nskip;
643 nsect += nskip;
644 rq->current_nr_sectors += nskip;
645 }
646
647
648
649 nframes = (nsect + SECTORS_PER_FRAME-1) / SECTORS_PER_FRAME;
650 frame = sector / SECTORS_PER_FRAME;
651
652
653 nframes = MIN (nframes, 65535);
654
655
656 memset (&pc.c, 0, sizeof (pc.c));
657 pc.c[0] = READ_10;
658 pc.c[7] = (nframes >> 8);
659 pc.c[8] = (nframes & 0xff);
660
661
662 {
663 union {
664 struct {unsigned char b0, b1, b2, b3;} b;
665 struct {unsigned long l0;} l;
666 } conv;
667 conv.l.l0 = frame;
668 pc.c[2] = conv.b.b3;
669 pc.c[3] = conv.b.b2;
670 pc.c[4] = conv.b.b1;
671 pc.c[5] = conv.b.b0;
672 }
673
674 if (cdrom_transfer_packet_command (dev, pc.c, sizeof (pc.c)))
675 return 1;
676
677
678 ide_handler[dev->hwif] = cdrom_read_intr;
679
680 return 0;
681 }
682
683
684
685
686
687
688
689
690 static int cdrom_start_read (ide_dev_t *dev, unsigned int block)
691 {
692 struct request *rq = ide_cur_rq[dev->hwif];
693
694
695
696 if (rq->buffer != rq->bh->b_data)
697 {
698 int n = (rq->buffer - rq->bh->b_data) / SECTOR_SIZE;
699 rq->buffer = rq->bh->b_data;
700 rq->nr_sectors += n;
701 rq->current_nr_sectors += n;
702 rq->sector -= n;
703 }
704
705 if (rq->current_nr_sectors > (rq->bh->b_size >> SECTOR_BITS))
706 rq->current_nr_sectors = rq->bh->b_size;
707
708
709 if (cdrom_read_from_buffer (dev))
710 return 1;
711
712 if (cdrom_start_packet_command (dev, 32768))
713 return 1;
714
715 if (CDROM_FLAGS (dev)->drq_interrupt)
716 ide_handler[dev->hwif] = (void (*)(ide_dev_t *))cdrom_start_read_continuation;
717 else
718 {
719 if (cdrom_start_read_continuation (dev))
720 return 1;
721 }
722
723 return 0;
724 }
725
726
727
728
729
730
731
732
733 static void cdrom_pc_intr (ide_dev_t *dev)
734 {
735 int ireason, len, stat, thislen;
736 struct request *rq = ide_cur_rq[dev->hwif];
737 struct packet_command *pc = (struct packet_command *)rq->buffer;
738
739
740 if (cdrom_decode_status (dev, 0, &stat)) return;
741
742
743 ireason = IN_BYTE (HD_NSECTOR, dev->hwif);
744 len = IN_BYTE (HD_LCYL, dev->hwif) + 256 * IN_BYTE (HD_HCYL, dev->hwif);
745
746
747
748 if ((stat & DRQ_STAT) == 0)
749 {
750 if (pc->buflen == 0)
751 cdrom_end_request (1, dev);
752 else
753 {
754 printk ("%s: cdrom_pc_intr: data underrun %d\n",
755 dev->name, pc->buflen);
756 pc->stat = 1;
757 cdrom_end_request (1, dev);
758 }
759 DO_REQUEST;
760 return;
761 }
762
763
764 thislen = pc->buflen;
765 if (thislen < 0) thislen = -thislen;
766 if (thislen > len) thislen = len;
767
768
769 if ((ireason & 3) == 0)
770 {
771
772 if (pc->buflen > 0)
773 {
774 printk ("%s: cdrom_pc_intr: Drive wants to transfer data the wrong way!\n",
775 dev->name);
776 pc->stat = 1;
777 thislen = 0;
778 }
779
780
781 OUT_WORDS (pc->buffer, thislen / 2);
782
783
784
785 while (len > thislen)
786 {
787 short dum = 0;
788 OUT_WORDS (&dum, 1);
789 len -= 2;
790 }
791
792
793 pc->buffer += thislen;
794 pc->buflen += thislen;
795 }
796
797
798 else if ((ireason & 3) == 2)
799 {
800
801 if (pc->buflen < 0)
802 {
803 printk ("%s: cdrom_pc_intr: Drive wants to transfer data the wrong way!\n",
804 dev->name);
805 pc->stat = 1;
806 thislen = 0;
807 }
808
809
810 IN_WORDS (pc->buffer, thislen / 2);
811
812
813
814 while (len > thislen)
815 {
816 short dum = 0;
817 IN_WORDS (&dum, 1);
818 len -= 2;
819 }
820
821
822 pc->buffer += thislen;
823 pc->buflen -= thislen;
824 }
825
826 else
827 {
828 printk ("%s: cdrom_pc_intr: The drive appears confused (ireason = 0x%2x)\n",
829 dev->name, ireason);
830 pc->stat = 1;
831 }
832
833
834 ide_handler[dev->hwif] = cdrom_pc_intr;
835 }
836
837
838 static int cdrom_do_pc_continuation (ide_dev_t *dev)
839 {
840 struct request *rq = ide_cur_rq[dev->hwif];
841 struct packet_command *pc = (struct packet_command *)rq->buffer;
842
843 if (cdrom_transfer_packet_command (dev, pc->c, sizeof (pc->c)))
844 return 1;
845
846
847 ide_handler[dev->hwif] = cdrom_pc_intr;
848
849 return 0;
850 }
851
852
853 static int cdrom_do_packet_command (ide_dev_t *dev)
854 {
855 int len;
856 struct request *rq = ide_cur_rq[dev->hwif];
857 struct packet_command *pc = (struct packet_command *)rq->buffer;
858
859 len = pc->buflen;
860 if (len < 0) len = -len;
861
862 pc->stat = 0;
863
864 if (cdrom_start_packet_command (dev, len))
865 return 1;
866
867 if (CDROM_FLAGS (dev)->drq_interrupt)
868 ide_handler[dev->hwif] = (void (*)(ide_dev_t *))cdrom_do_pc_continuation;
869 else
870 {
871 if (cdrom_do_pc_continuation (dev))
872 return 1;
873 }
874
875 return 0;
876 }
877
878
879 static
880 int cdrom_queue_packet_command (ide_dev_t *dev, struct packet_command *pc)
881 {
882 unsigned long flags;
883 struct request req, **p, **pfirst;
884 struct semaphore sem = MUTEX_LOCKED;
885 int major = ide_major[dev->hwif];
886
887 req.dev = MKDEV (major, (dev->select.b.drive) << PARTN_BITS);
888 req.cmd = PACKET_COMMAND;
889 req.errors = 0;
890 req.sector = 0;
891 req.nr_sectors = 0;
892 req.current_nr_sectors = 0;
893 req.buffer = (char *)pc;
894 req.sem = &sem;
895 req.bh = NULL;
896 req.bhtail = NULL;
897 req.next = NULL;
898
899 save_flags (flags);
900 cli ();
901
902 p = &blk_dev[major].current_request;
903 pfirst = p;
904 while ((*p) != NULL)
905 {
906 p = &((*p)->next);
907 }
908 *p = &req;
909 if (p == pfirst)
910 blk_dev[major].request_fn ();
911
912 restore_flags (flags);
913
914 down (&sem);
915
916 if (pc->stat != 0)
917 return -EIO;
918 else
919 return 0;
920 }
921
922
923
924
925
926
927
928 static int do_rw_cdrom (ide_dev_t *dev, unsigned long block)
929 {
930 struct request *rq = ide_cur_rq[dev->hwif];
931
932 if (rq -> cmd == PACKET_COMMAND)
933 return cdrom_do_packet_command (dev);
934
935 if (rq -> cmd != READ)
936 {
937 printk ("ide-cd: bad cmd %d\n", rq -> cmd);
938 cdrom_end_request (0, dev);
939 return 1;
940 }
941
942 return cdrom_start_read (dev, block);
943 }
944
945
946
947
948
949
950
951 static inline
952 void byte_swap_word (unsigned short *x)
953 {
954 char *c = (char *)x;
955 char d = c[0];
956 c[0] = c[1];
957 c[1] = d;
958 }
959
960
961 static inline
962 void byte_swap_long (unsigned *x)
963 {
964 char *c = (char *)x;
965 char d = c[0];
966 c[0] = c[3];
967 c[3] = d;
968 d = c[1];
969 c[1] = c[2];
970 c[2] = d;
971 }
972
973
974 static
975 int bin2bcd (int x)
976 {
977 return (x%10) | ((x/10) << 4);
978 }
979
980
981 static inline
982 void lba_to_msf (int lba, byte *m, byte *s, byte *f)
983 {
984 lba += CD_BLOCK_OFFSET;
985 lba &= 0xffffff;
986 *m = lba / (CD_SECS * CD_FRAMES);
987 lba %= (CD_SECS * CD_FRAMES);
988 *s = lba / CD_FRAMES;
989 *f = lba % CD_FRAMES;
990 }
991
992
993 static inline
994 int msf_to_lba (byte m, byte s, byte f)
995 {
996 return (((m * CD_SECS) + s) * CD_FRAMES + f) - CD_BLOCK_OFFSET;
997 }
998
999
1000 static void
1001 cdrom_check_status (ide_dev_t *dev)
1002 {
1003 struct packet_command pc;
1004
1005 memset (&pc, 0, sizeof (pc));
1006
1007 pc.c[0] = TEST_UNIT_READY;
1008
1009 (void) cdrom_queue_packet_command (dev, &pc);
1010 }
1011
1012
1013 static int
1014 cdrom_request_sense (ide_dev_t *dev, struct atapi_request_sense *reqbuf)
1015 {
1016 struct packet_command pc;
1017
1018 memset (&pc, 0, sizeof (pc));
1019
1020 pc.c[0] = REQUEST_SENSE;
1021 pc.c[4] = sizeof (*reqbuf);
1022 pc.buffer = (char *)reqbuf;
1023 pc.buflen = sizeof (*reqbuf);
1024
1025 return cdrom_queue_packet_command (dev, &pc);
1026 }
1027
1028
1029 #if 0
1030
1031 static int
1032 cdrom_lockdoor (ide_dev_t *dev, int lockflag)
1033 {
1034 struct packet_command pc;
1035
1036 memset (&pc, 0, sizeof (pc));
1037
1038 pc.c[0] = ALLOW_MEDIUM_REMOVAL;
1039 pc.c[4] = (lockflag != 0);
1040 return cdrom_queue_packet_command (dev, &pc);
1041 }
1042 #endif
1043
1044
1045
1046
1047 static int
1048 cdrom_eject (ide_dev_t *dev, int ejectflag)
1049 {
1050 struct packet_command pc;
1051
1052 memset (&pc, 0, sizeof (pc));
1053
1054 pc.c[0] = START_STOP;
1055 pc.c[4] = 2 + (ejectflag != 0);
1056 return cdrom_queue_packet_command (dev, &pc);
1057 }
1058
1059
1060 static int
1061 cdrom_pause (ide_dev_t *dev, int pauseflag)
1062 {
1063 struct packet_command pc;
1064
1065 memset (&pc, 0, sizeof (pc));
1066
1067 pc.c[0] = SCMD_PAUSE_RESUME;
1068 pc.c[8] = !pauseflag;
1069 return cdrom_queue_packet_command (dev, &pc);
1070 }
1071
1072
1073 static int
1074 cdrom_startstop (ide_dev_t *dev, int startflag)
1075 {
1076 struct packet_command pc;
1077
1078 memset (&pc, 0, sizeof (pc));
1079
1080 pc.c[0] = START_STOP;
1081 pc.c[1] = 1;
1082 pc.c[4] = startflag;
1083 return cdrom_queue_packet_command (dev, &pc);
1084 }
1085
1086
1087 static int
1088 cdrom_read_tocentry (ide_dev_t *dev, int trackno, int msf_flag,
1089 char *buf, int buflen)
1090 {
1091 struct packet_command pc;
1092
1093 memset (&pc, 0, sizeof (pc));
1094
1095 pc.buffer = buf;
1096 pc.buflen = buflen;
1097 pc.c[0] = SCMD_READ_TOC;
1098 pc.c[6] = trackno;
1099 pc.c[7] = (buflen >> 8);
1100 pc.c[8] = (buflen & 0xff);
1101 if (msf_flag) pc.c[1] = 2;
1102 return cdrom_queue_packet_command (dev, &pc);
1103 }
1104
1105
1106
1107 static int
1108 cdrom_read_toc (ide_dev_t *dev)
1109 {
1110 int msf_flag;
1111 int stat, ntracks, i;
1112 struct atapi_toc *toc = cdrom_info[dev->hwif][dev->select.b.drive].toc;
1113
1114 if (toc == NULL)
1115 {
1116
1117 toc = (struct atapi_toc *) kmalloc (sizeof (struct atapi_toc),
1118 GFP_KERNEL);
1119 cdrom_info[dev->hwif][dev->select.b.drive].toc = toc;
1120 }
1121
1122 if (toc == NULL)
1123 {
1124 printk ("%s: No cdrom TOC buffer!\n", dev->name);
1125 return -EIO;
1126 }
1127
1128
1129
1130 if (CDROM_FLAGS (dev)->toc_valid)
1131 cdrom_check_status (dev);
1132
1133 if (CDROM_FLAGS (dev)->toc_valid) return 0;
1134
1135
1136 msf_flag = (CDROM_FLAGS (dev)->no_lba_toc);
1137
1138
1139 stat = cdrom_read_tocentry (dev, 0, msf_flag, (char *)toc,
1140 sizeof (struct atapi_toc_header) +
1141 sizeof (struct atapi_toc_entry));
1142 if (stat) return stat;
1143
1144 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1145 if (ntracks <= 0) return -EIO;
1146 if (ntracks > MAX_TRACKS) ntracks = MAX_TRACKS;
1147
1148
1149 stat = cdrom_read_tocentry (dev, 0, msf_flag, (char *)toc,
1150 sizeof (struct atapi_toc_header) +
1151 (ntracks+1) * sizeof (struct atapi_toc_entry));
1152 if (stat) return stat;
1153 byte_swap_word (&toc->hdr.toc_length);
1154 for (i=0; i<=ntracks; i++)
1155 {
1156 if (msf_flag)
1157 {
1158 byte *adr = (byte *)&(toc->ent[i].lba);
1159 toc->ent[i].lba = msf_to_lba (adr[1], adr[2], adr[3]);
1160 }
1161 else
1162 byte_swap_long (&toc->ent[i].lba);
1163 }
1164
1165
1166 CDROM_FLAGS (dev)->toc_valid = 1;
1167
1168 return 0;
1169 }
1170
1171
1172 static int
1173 cdrom_read_subchannel (ide_dev_t *dev,
1174 char *buf, int buflen)
1175 {
1176 struct packet_command pc;
1177
1178 memset (&pc, 0, sizeof (pc));
1179
1180 pc.buffer = buf;
1181 pc.buflen = buflen;
1182 pc.c[0] = SCMD_READ_SUBCHANNEL;
1183 pc.c[2] = 0x40;
1184 pc.c[3] = 0x01;
1185 pc.c[7] = (buflen >> 8);
1186 pc.c[8] = (buflen & 0xff);
1187 return cdrom_queue_packet_command (dev, &pc);
1188 }
1189
1190
1191
1192 static int
1193 cdrom_mode_sense (ide_dev_t *dev, int pageno, int modeflag,
1194 char *buf, int buflen)
1195 {
1196 struct packet_command pc;
1197
1198 memset (&pc, 0, sizeof (pc));
1199
1200 pc.buffer = buf;
1201 pc.buflen = buflen;
1202 pc.c[0] = MODE_SENSE_10;
1203 pc.c[2] = pageno | (modeflag << 6);
1204 pc.c[7] = (buflen >> 8);
1205 pc.c[8] = (buflen & 0xff);
1206 return cdrom_queue_packet_command (dev, &pc);
1207 }
1208
1209
1210 static int
1211 cdrom_mode_select (ide_dev_t *dev, char *buf, int buflen)
1212 {
1213 struct packet_command pc;
1214
1215 memset (&pc, 0, sizeof (pc));
1216
1217 pc.buffer = buf;
1218 pc.buflen = - buflen;
1219 pc.c[0] = MODE_SELECT_10;
1220 pc.c[1] = 0x10;
1221 pc.c[7] = (buflen >> 8);
1222 pc.c[8] = (buflen & 0xff);
1223 return cdrom_queue_packet_command (dev, &pc);
1224 }
1225
1226
1227 static int
1228 cdrom_play_lba_range_play12 (ide_dev_t *dev, int lba_start, int lba_end)
1229 {
1230 struct packet_command pc;
1231
1232 memset (&pc, 0, sizeof (pc));
1233
1234 pc.c[0] = SCMD_PLAYAUDIO12;
1235 *(int *)(&pc.c[2]) = lba_start;
1236 *(int *)(&pc.c[6]) = lba_end - lba_start;
1237 byte_swap_long ((int *)(&pc.c[2]));
1238 byte_swap_long ((int *)(&pc.c[6]));
1239
1240 return cdrom_queue_packet_command (dev, &pc);
1241 }
1242
1243
1244 static int
1245 cdrom_play_lba_range_msf (ide_dev_t *dev, int lba_start, int lba_end)
1246 {
1247 struct packet_command pc;
1248
1249 memset (&pc, 0, sizeof (pc));
1250
1251 pc.c[0] = SCMD_PLAYAUDIO_MSF;
1252 lba_to_msf (lba_start, &pc.c[3], &pc.c[4], &pc.c[5]);
1253 lba_to_msf (lba_end-1, &pc.c[6], &pc.c[7], &pc.c[8]);
1254
1255 pc.c[3] = bin2bcd (pc.c[3]);
1256 pc.c[4] = bin2bcd (pc.c[4]);
1257 pc.c[5] = bin2bcd (pc.c[5]);
1258 pc.c[6] = bin2bcd (pc.c[6]);
1259 pc.c[7] = bin2bcd (pc.c[7]);
1260 pc.c[8] = bin2bcd (pc.c[8]);
1261
1262 return cdrom_queue_packet_command (dev, &pc);
1263 }
1264
1265
1266
1267
1268 static int
1269 cdrom_play_lba_range (ide_dev_t *dev, int lba_start, int lba_end)
1270 {
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282 if (CDROM_FLAGS (dev)->no_playaudio12)
1283 return cdrom_play_lba_range_msf (dev, lba_start, lba_end);
1284 else
1285 {
1286 int stat, stat2;
1287 struct atapi_request_sense reqbuf;
1288
1289 stat = cdrom_play_lba_range_play12 (dev, lba_start, lba_end);
1290 if (stat == 0) return 0;
1291
1292
1293 stat2 = cdrom_request_sense (dev, &reqbuf);
1294 if (stat2) return stat;
1295
1296 if (reqbuf.sense_key == 0x05 && reqbuf.asc == 0x20)
1297 {
1298
1299
1300 printk ("%s: Drive does not support PLAYAUDIO12; "
1301 "trying PLAYAUDIO_MSF\n", dev->name);
1302 CDROM_FLAGS (dev)->no_playaudio12 = 1;
1303 return cdrom_play_lba_range_msf (dev, lba_start, lba_end);
1304 }
1305
1306
1307 return stat;
1308 }
1309 }
1310
1311
1312 static
1313 int cdrom_get_toc_entry (ide_dev_t *dev, int track,
1314 struct atapi_toc_entry **ent)
1315 {
1316 int stat, ntracks;
1317 struct atapi_toc *toc;
1318
1319
1320 stat = cdrom_read_toc (dev);
1321 if (stat) return stat;
1322
1323 toc = cdrom_info[dev->hwif][dev->select.b.drive].toc;
1324
1325
1326 ntracks = toc->hdr.last_track - toc->hdr.first_track + 1;
1327 if (track == CDROM_LEADOUT)
1328 *ent = &toc->ent[ntracks];
1329 else if (track < toc->hdr.first_track ||
1330 track > toc->hdr.last_track)
1331 return -EINVAL;
1332 else
1333 *ent = &toc->ent[track - toc->hdr.first_track];
1334
1335 return 0;
1336 }
1337
1338
1339 static int ide_cdrom_ioctl (ide_dev_t *dev, struct inode *inode,
1340 struct file *file, unsigned int cmd, unsigned long arg)
1341 {
1342 switch (cmd)
1343 {
1344 case CDROMEJECT:
1345 return cdrom_eject (dev, 0);
1346
1347 case CDROMPAUSE:
1348 return cdrom_pause (dev, 1);
1349
1350 case CDROMRESUME:
1351 return cdrom_pause (dev, 0);
1352
1353 case CDROMSTART:
1354 return cdrom_startstop (dev, 1);
1355
1356 case CDROMSTOP:
1357 return cdrom_startstop (dev, 0);
1358
1359 case CDROMPLAYMSF:
1360 {
1361 struct cdrom_msf msf;
1362 int stat, lba_start, lba_end;
1363
1364 stat = verify_area (VERIFY_READ, (void *)arg, sizeof (msf));
1365 if (stat) return stat;
1366
1367 memcpy_fromfs (&msf, (void *) arg, sizeof(msf));
1368
1369 lba_start = msf_to_lba (msf.cdmsf_min0, msf.cdmsf_sec0,
1370 msf.cdmsf_frame0);
1371 lba_end = msf_to_lba (msf.cdmsf_min1, msf.cdmsf_sec1,
1372 msf.cdmsf_frame1) + 1;
1373
1374 if (lba_end <= lba_start) return -EINVAL;
1375
1376 return cdrom_play_lba_range (dev, lba_start, lba_end);
1377 }
1378
1379
1380
1381 case CDROMPLAYTRKIND:
1382 {
1383 int stat, lba_start, lba_end;
1384 struct cdrom_ti ti;
1385 struct atapi_toc_entry *first_toc, *last_toc;
1386
1387 stat = verify_area (VERIFY_READ, (void *)arg, sizeof (ti));
1388 if (stat) return stat;
1389
1390 memcpy_fromfs (&ti, (void *) arg, sizeof(ti));
1391
1392 stat = cdrom_get_toc_entry (dev, ti.cdti_trk0, &first_toc);
1393 if (stat) return stat;
1394 stat = cdrom_get_toc_entry (dev, ti.cdti_trk1, &last_toc);
1395 if (stat) return stat;
1396
1397 if (ti.cdti_trk1 != CDROM_LEADOUT) ++last_toc;
1398 lba_start = first_toc->lba;
1399 lba_end = last_toc->lba;
1400
1401 if (lba_end <= lba_start) return -EINVAL;
1402
1403 return cdrom_play_lba_range (dev, lba_start, lba_end);
1404 }
1405
1406 case CDROMREADTOCHDR:
1407 {
1408 int stat;
1409 struct cdrom_tochdr tochdr;
1410 struct atapi_toc *toc;
1411
1412 stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (tochdr));
1413 if (stat) return stat;
1414
1415
1416 stat = cdrom_read_toc (dev);
1417 if (stat) return stat;
1418
1419 toc = cdrom_info[dev->hwif][dev->select.b.drive].toc;
1420 tochdr.cdth_trk0 = toc->hdr.first_track;
1421 tochdr.cdth_trk1 = toc->hdr.last_track;
1422
1423 memcpy_tofs ((void *) arg, &tochdr, sizeof (tochdr));
1424
1425 return stat;
1426 }
1427
1428 case CDROMREADTOCENTRY:
1429 {
1430 int stat;
1431 struct cdrom_tocentry tocentry;
1432 struct atapi_toc_entry *toce;
1433
1434 stat = verify_area (VERIFY_READ, (void *) arg, sizeof (tocentry));
1435 if (stat) return stat;
1436 stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (tocentry));
1437 if (stat) return stat;
1438
1439 memcpy_fromfs (&tocentry, (void *) arg, sizeof (tocentry));
1440
1441 stat = cdrom_get_toc_entry (dev, tocentry.cdte_track, &toce);
1442 if (stat) return stat;
1443
1444 tocentry.cdte_ctrl = toce->control;
1445 tocentry.cdte_adr = toce->adr;
1446
1447 if (tocentry.cdte_format == CDROM_MSF)
1448 {
1449
1450 lba_to_msf (toce->lba,
1451 &tocentry.cdte_addr.msf.minute,
1452 &tocentry.cdte_addr.msf.second,
1453 &tocentry.cdte_addr.msf.frame);
1454 }
1455 else
1456 tocentry.cdte_addr.lba = toce->lba;
1457
1458 memcpy_tofs ((void *) arg, &tocentry, sizeof (tocentry));
1459
1460 return stat;
1461 }
1462
1463 case CDROMSUBCHNL:
1464 {
1465 char buffer[16];
1466 int stat, abs_lba, rel_lba;
1467 struct cdrom_subchnl subchnl;
1468
1469 stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (subchnl));
1470 if (stat) return stat;
1471 stat = verify_area (VERIFY_READ, (void *) arg, sizeof (subchnl));
1472 if (stat) return stat;
1473
1474 memcpy_fromfs (&subchnl, (void *) arg, sizeof (subchnl));
1475
1476 stat = cdrom_read_subchannel (dev, buffer, sizeof (buffer));
1477 if (stat) return stat;
1478
1479 abs_lba = *(int *)&buffer[8];
1480 rel_lba = *(int *)&buffer[12];
1481 byte_swap_long (&abs_lba);
1482 byte_swap_long (&rel_lba);
1483
1484 if (subchnl.cdsc_format == CDROM_MSF)
1485 {
1486 lba_to_msf (abs_lba,
1487 &subchnl.cdsc_absaddr.msf.minute,
1488 &subchnl.cdsc_absaddr.msf.second,
1489 &subchnl.cdsc_absaddr.msf.frame);
1490 lba_to_msf (rel_lba,
1491 &subchnl.cdsc_reladdr.msf.minute,
1492 &subchnl.cdsc_reladdr.msf.second,
1493 &subchnl.cdsc_reladdr.msf.frame);
1494 }
1495 else
1496 {
1497 subchnl.cdsc_absaddr.lba = abs_lba;
1498 subchnl.cdsc_reladdr.lba = rel_lba;
1499 }
1500
1501 subchnl.cdsc_audiostatus = buffer[1];
1502 subchnl.cdsc_ctrl = buffer[5] & 0xf;
1503 subchnl.cdsc_trk = buffer[6];
1504 subchnl.cdsc_ind = buffer[7];
1505
1506 memcpy_tofs ((void *) arg, &subchnl, sizeof (subchnl));
1507
1508 return stat;
1509 }
1510
1511 case CDROMVOLCTRL:
1512 {
1513 struct cdrom_volctrl volctrl;
1514 char buffer[24], mask[24];
1515 int stat;
1516
1517 stat = verify_area (VERIFY_READ, (void *) arg, sizeof (volctrl));
1518 if (stat) return stat;
1519 memcpy_fromfs (&volctrl, (void *) arg, sizeof (volctrl));
1520
1521 stat = cdrom_mode_sense (dev, 0x0e, 0, buffer, sizeof (buffer));
1522 if (stat) return stat;
1523 stat = cdrom_mode_sense (dev, 0x0e, 1, mask , sizeof (buffer));
1524 if (stat) return stat;
1525
1526 buffer[1] = buffer[2] = 0;
1527
1528 buffer[17] = volctrl.channel0 & mask[17];
1529 buffer[19] = volctrl.channel1 & mask[19];
1530 buffer[21] = volctrl.channel2 & mask[21];
1531 buffer[23] = volctrl.channel3 & mask[23];
1532
1533 return cdrom_mode_select (dev, buffer, sizeof (buffer));
1534 }
1535
1536 #ifdef TEST
1537 case 0x1234:
1538 {
1539 int stat;
1540 struct packet_command pc;
1541
1542 memset (&pc, 0, sizeof (pc));
1543
1544 stat = verify_area (VERIFY_READ, (void *) arg, sizeof (pc.c));
1545 if (stat) return stat;
1546 memcpy_fromfs (&pc.c, (void *) arg, sizeof (pc.c));
1547
1548 return cdrom_queue_packet_command (dev, &pc);
1549 }
1550
1551 case 0x1235:
1552 {
1553 int stat;
1554 struct atapi_request_sense reqbuf;
1555
1556 stat = verify_area (VERIFY_WRITE, (void *) arg, sizeof (reqbuf));
1557 if (stat) return stat;
1558
1559 stat = cdrom_request_sense (dev, &reqbuf);
1560
1561 memcpy_tofs ((void *) arg, &reqbuf, sizeof (reqbuf));
1562
1563 return stat;
1564 }
1565 #endif
1566
1567 default:
1568 return -EPERM;
1569 }
1570
1571 }
1572
1573
1574
1575
1576
1577
1578
1579 static int cdrom_check_media_change (ide_dev_t *dev)
1580 {
1581 int retval;
1582
1583 cdrom_check_status (dev);
1584
1585 retval = CDROM_FLAGS (dev)->media_changed;
1586 CDROM_FLAGS (dev)->media_changed = 0;
1587
1588 return retval;
1589 }
1590
1591
1592 static int
1593 cdrom_open (struct inode *ip, struct file *fp, ide_dev_t *dev)
1594 {
1595
1596 if (fp->f_mode & 2) return -EROFS;
1597
1598 #if 0
1599
1600 if (dev->usage == 1)
1601 (void) cdrom_lockdoor (dev, 1);
1602 #endif
1603
1604
1605 return 0;
1606 }
1607
1608
1609
1610
1611
1612
1613 static void
1614 cdrom_release (struct inode *inode, struct file *file, ide_dev_t *dev)
1615 {
1616 if (dev->usage == 0)
1617 {
1618 invalidate_buffers (inode->i_rdev);
1619
1620 #if 0
1621
1622 (void) cdrom_lockdoor (dev, 0);
1623 #endif
1624 }
1625 }
1626
1627
1628
1629
1630
1631
1632
1633 static void cdrom_setup (ide_dev_t *dev)
1634 {
1635
1636 ide_capacity[dev->hwif][dev->select.b.drive] = 0x1fffff;
1637
1638 ide_blksizes[dev->hwif][dev->select.b.drive << PARTN_BITS] = CD_FRAMESIZE;
1639
1640 dev->special.all = 0;
1641
1642 CDROM_FLAGS (dev)->media_changed = 0;
1643 CDROM_FLAGS (dev)->toc_valid = 0;
1644
1645 CDROM_FLAGS (dev)->no_playaudio12 = 0;
1646 CDROM_FLAGS (dev)->no_lba_toc = 0;
1647 CDROM_FLAGS (dev)->drq_interrupt = ((dev->id->config & 0x0060) == 0x20);
1648
1649
1650 if (strcmp (dev->id->model, "CD220E") == 0)
1651 CDROM_FLAGS (dev)->no_lba_toc = 1;
1652
1653 else if (strcmp (dev->id->model, "TO-ICSLYAL") == 0 ||
1654 strcmp (dev->id->model, "OTI-SCYLLA") == 0)
1655 CDROM_FLAGS (dev)->no_lba_toc = 1;
1656
1657 else if (strcmp (dev->id->model, "CDA26803I SE") == 0)
1658 CDROM_FLAGS (dev)->no_lba_toc = 1;
1659
1660 cdrom_info[dev->hwif][dev->select.b.drive].toc = NULL;
1661 cdrom_info[dev->hwif][dev->select.b.drive].sector_buffer = NULL;
1662 cdrom_info[dev->hwif][dev->select.b.drive].sector_buffered = 0;
1663 cdrom_info[dev->hwif][dev->select.b.drive].nsectors_buffered = 0;
1664 }
1665
1666
1667 #undef MIN
1668 #undef SECTOR_SIZE
1669 #undef SECTOR_BITS
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681