This source file includes following definitions.
- sbpcd_dprintf
- sbpcd_dbg_ioctl
- sbp_sleep
- lba2msf
- bin2bcdx
- blk2msf
- make16
- make32
- swap_nibbles
- byt2bcd
- bcd2bin
- msf2blk
- msf2lba
- sta2err
- clr_cmdbuf
- mark_timeout
- flush_status
- CDi_stat_loop
- tst_DataReady
- tst_ResultReady
- tst_Attention
- ResponseInfo
- EvaluateStatus
- ResponseStatus
- xx_ReadStatus
- xx_ReadError
- cmd_out
- xx_Seek
- xx_SpinUp
- yy_SpinDown
- yy_SetSpeed
- xx_SetVolume
- GetStatus
- xy_DriveReset
- SetSpeed
- DriveReset
- xx_Pause_Resume
- yy_LockDoor
- yy_CloseTray
- xx_ReadSubQ
- xx_ModeSense
- xx_ModeSelect
- xx_TellVolume
- xx_ReadCapacity
- xx_ReadTocDescr
- xx_ReadTocEntry
- xx_ReadPacket
- convert_UPC
- xx_ReadUPC
- yy_CheckMultiSession
- yy_SubChanInfo
- check_datarate
- teac_reset
- look_for_TEAC_drive
- find_teac_drives
- xx_ReadVersion
- yy_ReadError
- ask_mail
- check_version
- switch_drive
- check_drives
- timewait
- obey_audio_state
- check_allowed1
- check_allowed2
- check_allowed3
- seek_pos_audio_end
- ReadToC
- DiskInfo
- prepare
- xx_PlayAudio
- sbp_status
- sbpcd_ioctl
- sbp_transfer
- DO_SBPCD_REQUEST
- sbp_read_cmd
- sbp_data
- sbpcd_open
- sbpcd_release
- sbpcd_setup
- config_spea
- SBPCD_INIT
- sbpcd_chk_disk_change
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220 #ifndef SBPCD_ISSUE
221 #define SBPCD_ISSUE 1
222 #endif SBPCD_ISSUE
223
224 #include <linux/config.h>
225 #include <linux/errno.h>
226
227 #include <linux/sched.h>
228 #include <linux/mm.h>
229
230 #include <linux/timer.h>
231 #include <linux/fs.h>
232 #include <linux/kernel.h>
233 #include <linux/cdrom.h>
234 #include <linux/ioport.h>
235 #include <linux/major.h>
236 #include <linux/sbpcd.h>
237 #include <linux/string.h>
238 #include <asm/system.h>
239 #include <asm/io.h>
240 #include <asm/segment.h>
241 #include <stdarg.h>
242
243 #if !(SBPCD_ISSUE-1)
244 #define MAJOR_NR MATSUSHITA_CDROM_MAJOR
245 #endif
246 #if !(SBPCD_ISSUE-2)
247 #define MAJOR_NR MATSUSHITA_CDROM2_MAJOR
248 #endif
249 #if !(SBPCD_ISSUE-3)
250 #define MAJOR_NR MATSUSHITA_CDROM3_MAJOR
251 #endif
252 #if !(SBPCD_ISSUE-4)
253 #define MAJOR_NR MATSUSHITA_CDROM4_MAJOR
254 #endif
255
256 #include "blk.h"
257
258 #define VERSION "3.3 Eberhard Moenkeberg <emoenke@gwdg.de>"
259
260
261
262
263 #define TEAC 0
264
265 #define MULTISESSION_BY_DRIVER 0
266
267
268 #define READ_AUDIO 4
269
270 #define JUKEBOX 1
271 #define EJECT 1
272 #define LONG_TIMING 0
273 #define MANY_SESSION 0
274 #undef FUTURE
275 #define WORKMAN 1
276 #define CDMKE
277
278 #undef XA_TEST1
279 #define XA_TEST2
280
281 #define TEST_UPC 0
282 #define SPEA_TEST 0
283 #define PRINTK_BUG 0
284 #define TEST_STI 0
285
286 #define DISTRIBUTION 1
287
288 #if 0
289 #define INLINE
290 #else
291 #define INLINE inline
292 #endif
293
294
295
296
297
298
299 #if !(SBPCD_ISSUE-1)
300 #define DO_SBPCD_REQUEST(a) do_sbpcd_request(a)
301 #define SBPCD_INIT(a,b) sbpcd_init(a,b)
302 #endif
303 #if !(SBPCD_ISSUE-2)
304 #define DO_SBPCD_REQUEST(a) do_sbpcd2_request(a)
305 #define SBPCD_INIT(a,b) sbpcd2_init(a,b)
306 #endif
307 #if !(SBPCD_ISSUE-3)
308 #define DO_SBPCD_REQUEST(a) do_sbpcd3_request(a)
309 #define SBPCD_INIT(a,b) sbpcd3_init(a,b)
310 #endif
311 #if !(SBPCD_ISSUE-4)
312 #define DO_SBPCD_REQUEST(a) do_sbpcd4_request(a)
313 #define SBPCD_INIT(a,b) sbpcd4_init(a,b)
314 #endif
315
316 #if MANY_SESSION
317 #undef LONG_TIMING
318 #define LONG_TIMING 1
319 #endif
320
321 #if SBPCD_DIS_IRQ
322 #define SBPCD_CLI cli()
323 #define SBPCD_STI sti()
324 #else
325 #define SBPCD_CLI
326 #define SBPCD_STI
327 #endif SBPCD_DIS_IRQ
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345 #if !(SBPCD_ISSUE-1)
346 static int sbpcd_probe[] =
347 {
348 CDROM_PORT, SBPRO,
349 #if DISTRIBUTION
350 0x230, 1,
351 0x300, 0,
352
353 0x250, 1,
354 0x260, 1,
355 0x320, 0,
356
357 0x338, 0,
358 0x340, 0,
359 0x360, 0,
360 0x270, 1,
361 0x670, 0,
362 0x690, 0,
363 0x330, 2,
364 0x320, 2,
365 0x340, 2,
366 0x634, 0,
367 0x638, 0,
368
369 0x630, 0,
370 0x650, 0,
371
372
373
374
375 #if 0
376 0x330, 0,
377 0x350, 0,
378 0x350, 2,
379 0x370, 0,
380 0x290, 1,
381 0x310, 0,
382 #endif
383 #endif DISTRIBUTION
384 };
385 #else
386 static int sbpcd_probe[] = {CDROM_PORT, SBPRO};
387 #endif
388
389 #define NUM_PROBE (sizeof(sbpcd_probe) / sizeof(int))
390
391
392
393
394
395
396 #if !(SBPCD_ISSUE-1)
397 #ifdef CONFIG_SBPCD2
398 extern unsigned long sbpcd2_init(unsigned long, unsigned long);
399 #endif
400 #ifdef CONFIG_SBPCD3
401 extern unsigned long sbpcd3_init(unsigned long, unsigned long);
402 #endif
403 #ifdef CONFIG_SBPCD4
404 extern unsigned long sbpcd4_init(unsigned long, unsigned long);
405 #endif
406 #endif
407
408
409
410
411
412
413 static void sbp_read_cmd(void);
414 static int sbp_data(void);
415 static int cmd_out(int);
416 static int DiskInfo(void);
417 static int sbpcd_chk_disk_change(dev_t);
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455 #if DISTRIBUTION
456 static int sbpcd_debug = (1<<DBG_INF) |
457 (1<<DBG_WRN) |
458 (1<<DBG_MUL);
459 #else
460 static int sbpcd_debug = (1<<DBG_INF) |
461 (1<<DBG_TOC) |
462 (1<<DBG_MUL) |
463 (1<<DBG_UPC);
464 #endif DISTRIBUTION
465
466 static int sbpcd_ioaddr = CDROM_PORT;
467 static int sbpro_type = SBPRO;
468 static unsigned char setup_done = 0;
469 static int CDo_command, CDo_reset;
470 static int CDo_sel_i_d, CDo_enable;
471 static int CDi_info, CDi_status, CDi_data;
472 static int MIXER_addr, MIXER_data;
473 static struct cdrom_msf msf;
474 static struct cdrom_ti ti;
475 static struct cdrom_tochdr tochdr;
476 static struct cdrom_tocentry tocentry;
477 static struct cdrom_subchnl SC;
478 static struct cdrom_volctrl volctrl;
479 static struct cdrom_read_audio read_audio;
480 static struct cdrom_multisession ms_info;
481
482 static char *str_sb = "SoundBlaster";
483 static char *str_lm = "LaserMate";
484 static char *str_sp = "SPEA";
485 char *type;
486 #if !(SBPCD_ISSUE-1)
487 static char *major_name="sbpcd";
488 #endif
489 #if !(SBPCD_ISSUE-2)
490 static char *major_name="sbpcd2";
491 #endif
492 #if !(SBPCD_ISSUE-3)
493 static char *major_name="sbpcd3";
494 #endif
495 #if !(SBPCD_ISSUE-4)
496 static char *major_name="sbpcd4";
497 #endif
498
499
500
501 #if FUTURE
502 static struct wait_queue *sbp_waitq = NULL;
503 #endif FUTURE
504
505
506 #define SBP_BUFFER_FRAMES 4
507 #define SBP_BUFFER_AUDIO_FRAMES READ_AUDIO
508
509
510
511 static u_char family0[]="MATSHITA";
512 static u_char family1[]="CR-56";
513 static u_char family2[]="CD200";
514 static u_char familyL[]="LCS-7260";
515 static u_char familyT[]="CD-55A";
516
517 static u_int response_count=0;
518 static u_int flags_cmd_out;
519 static u_char cmd_type=0;
520 static u_char drvcmd[10];
521 static u_char infobuf[20];
522 static u_char xa_head_buf[CD_XA_HEAD];
523 static u_char xa_tail_buf[CD_XA_TAIL];
524
525 static u_char busy_data=0, busy_audio=0;
526 static u_char timed_out=0;
527 static u_int datarate= 1000000;
528 static u_int maxtim16=16000000;
529 static u_int maxtim04= 4000000;
530 static u_int maxtim02= 2000000;
531 static u_int maxtim_8= 30000;
532 #if LONG_TIMING
533 static u_int maxtim_data= 9000;
534 #else
535 static u_int maxtim_data= 3000;
536 #endif LONG_TIMING
537 #if DISTRIBUTION
538 static int n_retries=3;
539 #else
540 static int n_retries=1;
541 #endif
542
543
544 static int ndrives=0;
545 static u_char drv_pattern[4]={speed_auto,speed_auto,speed_auto,speed_auto};
546 static int sbpcd_blocksizes[NR_SBPCD] = {0, };
547
548
549
550
551
552 static int d=0;
553
554 static struct {
555 char drv_id;
556 char drv_sel;
557
558 char drive_model[9];
559 u_char firmware_version[4];
560 char f_eject;
561 u_char *sbp_buf;
562
563 int sbp_first_frame;
564 int sbp_last_frame;
565 int sbp_read_frames;
566 int sbp_current;
567
568 u_char mode;
569 u_char *aud_buf;
570
571 u_char drv_type;
572 u_char drv_options;
573 u_char status_byte;
574 u_char diskstate_flags;
575 u_char sense_byte;
576
577 u_char CD_changed;
578 u_char open_count;
579 u_char error_byte;
580
581 u_char f_multisession;
582 u_int lba_multi;
583 #if MULTISESSION_BY_DRIVER
584 u_int last_redirect;
585 #endif MULTISESSION_BY_DRIVER
586 int first_session;
587 int last_session;
588
589 u_char audio_state;
590 u_int pos_audio_start;
591 u_int pos_audio_end;
592 char vol_chan0;
593 u_char vol_ctrl0;
594 char vol_chan1;
595 u_char vol_ctrl1;
596 #if 000
597 char vol_chan2;
598 u_char vol_ctrl2;
599 char vol_chan3;
600 u_char vol_ctrl3;
601 #endif 000
602
603 u_char SubQ_ctl_adr;
604 u_char SubQ_trk;
605 u_char SubQ_pnt_idx;
606 u_int SubQ_run_tot;
607 u_int SubQ_run_trk;
608 u_char SubQ_whatisthis;
609
610 u_char UPC_ctl_adr;
611 u_char UPC_buf[7];
612
613 int CDsize_blk;
614 int frame_size;
615 int CDsize_frm;
616
617 u_char xa_byte;
618 u_char n_first_track;
619 u_char n_last_track;
620 u_int size_msf;
621 u_int size_blk;
622
623 u_char TocEnt_nixbyte;
624 u_char TocEnt_ctl_adr;
625 u_char TocEnt_number;
626 u_char TocEnt_format;
627 u_int TocEnt_address;
628 u_char ored_ctl_adr;
629
630 struct {
631 u_char nixbyte;
632 u_char ctl_adr;
633 u_char number;
634 u_char format;
635 u_int address;
636 } TocBuffer[MAX_TRACKS+1];
637
638 int in_SpinUp;
639
640 } DriveStruct[NR_SBPCD];
641
642
643
644
645
646
647
648
649
650 static void sbpcd_dprintf(int level, char *fmt, ...)
651 {
652 char buff[256];
653 va_list args;
654 extern int vsprintf(char *buf, const char *fmt, va_list args);
655
656 if (! (sbpcd_debug & (1 << level))) return;
657
658 va_start(args, fmt);
659 vsprintf(buff, fmt, args);
660 va_end(args);
661 printk(buff);
662 #if PRINTK_BUG
663 sti();
664 #endif
665 }
666
667
668
669
670 static int sbpcd_dbg_ioctl(unsigned long arg, int level)
671 {
672 int val;
673
674 val = get_fs_long((int *) arg);
675 switch(val)
676 {
677 case 0:
678 sbpcd_debug = 0;
679 break;
680
681 default:
682 if (val >= 128) sbpcd_debug &= ~(1 << (val - 128));
683 else sbpcd_debug |= (1 << val);
684 }
685 return(0);
686 }
687
688
689
690
691
692
693
694 static INLINE void sbp_sleep(u_int jifs)
695 {
696 sti();
697 current->state = TASK_INTERRUPTIBLE;
698 current->timeout = jiffies + jifs;
699 schedule();
700 sti();
701 }
702
703
704
705
706
707
708 static INLINE void lba2msf(int lba, u_char *msf)
709 {
710 lba += CD_BLOCK_OFFSET;
711 msf[0] = lba / (CD_SECS*CD_FRAMES);
712 lba %= CD_SECS*CD_FRAMES;
713 msf[1] = lba / CD_FRAMES;
714 msf[2] = lba % CD_FRAMES;
715 }
716
717
718
719
720
721 static INLINE void bin2bcdx(u_char *p)
722 {
723 *p=((*p/10)<<4)|(*p%10);
724 }
725
726 static INLINE u_int blk2msf(u_int blk)
727 {
728 MSF msf;
729 u_int mm;
730
731 msf.c[3] = 0;
732 msf.c[2] = (blk + CD_BLOCK_OFFSET) / (CD_SECS * CD_FRAMES);
733 mm = (blk + CD_BLOCK_OFFSET) % (CD_SECS * CD_FRAMES);
734 msf.c[1] = mm / CD_FRAMES;
735 msf.c[0] = mm % CD_FRAMES;
736 return (msf.n);
737 }
738
739 static INLINE u_int make16(u_char rh, u_char rl)
740 {
741 return ((rh<<8)|rl);
742 }
743
744 static INLINE u_int make32(u_int rh, u_int rl)
745 {
746 return ((rh<<16)|rl);
747 }
748
749 static INLINE u_char swap_nibbles(u_char i)
750 {
751 return ((i<<4)|(i>>4));
752 }
753
754 static INLINE u_char byt2bcd(u_char i)
755 {
756 return (((i/10)<<4)+i%10);
757 }
758
759 static INLINE u_char bcd2bin(u_char bcd)
760 {
761 return ((bcd>>4)*10+(bcd&0x0F));
762 }
763
764 static INLINE int msf2blk(int msfx)
765 {
766 MSF msf;
767 int i;
768
769 msf.n=msfx;
770 i=(msf.c[2] * CD_SECS + msf.c[1]) * CD_FRAMES + msf.c[0] - CD_BLOCK_OFFSET;
771 if (i<0) return (0);
772 return (i);
773 }
774
775
776
777
778 static INLINE int msf2lba(u_char *msf)
779 {
780 int i;
781
782 i=(msf[0] * CD_SECS + msf[1]) * CD_FRAMES + msf[2] - CD_BLOCK_OFFSET;
783 if (i<0) return (0);
784 return (i);
785 }
786
787
788 static int sta2err(int sta)
789 {
790 if (sta<=2) return (sta);
791 if (sta==0x05) return (-4);
792 if (sta==0x06) return (-6);
793 if (sta==0x0d) return (-6);
794 if (sta==0x0e) return (-3);
795 if (sta==0x14) return (-3);
796 if (sta==0x0c) return (-11);
797 if (sta==0x0f) return (-11);
798 if (sta==0x10) return (-11);
799 if (sta>=0x16) return (-12);
800 DriveStruct[d].CD_changed=0xFF;
801 if (sta==0x11) return (-15);
802 if (famL_drive)
803 if (sta==0x12) return (-15);
804 return (-2);
805 }
806
807 static INLINE void clr_cmdbuf(void)
808 {
809 int i;
810
811 for (i=0;i<10;i++) drvcmd[i]=0;
812 cmd_type=0;
813 }
814
815 static void mark_timeout(unsigned long i)
816 {
817 timed_out=1;
818 DPRINTF((DBG_TIM,"SBPCD: timer expired.\n"));
819 }
820
821 static struct timer_list delay_timer = { NULL, NULL, 0, 0, mark_timeout};
822 #if 0
823 static struct timer_list data_timer = { NULL, NULL, 0, 0, mark_timeout};
824 static struct timer_list audio_timer = { NULL, NULL, 0, 0, mark_timeout};
825 #endif
826
827 static void flush_status(void)
828 {
829 #ifdef CDMKE
830 int i;
831
832 if (current == task[0])
833 for (i=maxtim02;i!=0;i--) inb(CDi_status);
834 else
835 {
836 sbp_sleep(150);
837 for (i=maxtim_data;i!=0;i--) inb(CDi_status);
838 }
839 #else
840 timed_out=0;
841 #if 0
842 del_timer(&delay_timer);
843 #endif
844 delay_timer.expires = 150;
845 add_timer(&delay_timer);
846 do { }
847 while (!timed_out);
848 #if 0
849 del_timer(&delay_timer);
850 #endif 0
851 inb(CDi_status);
852 #endif CDMKE
853 }
854
855 static int CDi_stat_loop(void)
856 {
857 int i,j;
858 u_long timeout;
859
860 if (current == task[0])
861 for(i=maxtim16;i!=0;i--)
862 {
863 j=inb(CDi_status);
864 if (!(j&s_not_data_ready)) return (j);
865 if (!(j&s_not_result_ready)) return (j);
866 if (fam0L_drive) if (j&s_attention) return (j);
867 }
868 else
869 for(timeout = jiffies + 1000, i=maxtim_data; timeout > jiffies; )
870 {
871 for ( ;i!=0;i--)
872 {
873 j=inb(CDi_status);
874 if (!(j&s_not_data_ready)) return (j);
875 if (!(j&s_not_result_ready)) return (j);
876 if (fam0L_drive) if (j&s_attention) return (j);
877 }
878 sbp_sleep(1);
879 i = 1;
880 }
881 DPRINTF((DBG_LCS,"SBPCD: CDi_stat_loop failed\n"));
882 return (-1);
883 }
884
885 #if TEAC-X
886
887 static int tst_DataReady(void)
888 {
889 int i;
890
891 i=inb(CDi_status);
892 if (i&s_not_data_ready) return (0);
893 return (1);
894 }
895
896 static int tst_ResultReady(void)
897 {
898 int i;
899
900 i=inb(CDi_status);
901 if (i&s_not_result_ready) return (0);
902 return (1);
903 }
904
905 static int tst_Attention(void)
906 {
907 int i;
908
909 i=inb(CDi_status);
910 if (i&s_attention) return (1);
911 return (0);
912 }
913
914 #endif TEAC-X
915
916 static int ResponseInfo(void)
917 {
918 int i,j, st=0;
919 u_long timeout;
920
921 DPRINTF((DBG_000,"SBPCD: ResponseInfo entered.\n"));
922 if (current == task[0])
923 for (i=0;i<response_count;i++)
924 {
925 for (j=maxtim_8;j!=0;j--)
926 {
927 st=inb(CDi_status);
928 if (!(st&s_not_result_ready)) break;
929 }
930 if (j==0)
931 {
932 DPRINTF((DBG_SEQ,"SBPCD: ResponseInfo: not_result_ready (got %d of %d bytes).\n", i, response_count));
933 return (-1);
934 }
935 infobuf[i]=inb(CDi_info);
936 }
937 else
938 {
939 for (i=0, timeout = jiffies + 100; i < response_count; i++)
940 {
941 for (j=maxtim_data; ; )
942 {
943 for ( ;j!=0;j-- )
944 {
945 st=inb(CDi_status);
946 if (!(st&s_not_result_ready)) break;
947 }
948 if (j != 0 || timeout <= jiffies) break;
949 sbp_sleep(0);
950 j = 1;
951 }
952 if (timeout <= jiffies) return (-1);
953 infobuf[i]=inb(CDi_info);
954 }
955 }
956 DPRINTF((DBG_000,"SBPCD: ResponseInfo: done.\n"));
957 return (0);
958 }
959
960 static int EvaluateStatus(int st)
961 {
962 if (fam0_drive)
963 {
964 DriveStruct[d].status_byte=0;
965 if (st&p_caddin_old) DriveStruct[d].status_byte |= p_door_closed|p_caddy_in;
966 if (st&p_spinning) DriveStruct[d].status_byte |= p_spinning;
967 if (st&p_check) DriveStruct[d].status_byte |= p_check;
968 if (st&p_busy_old) DriveStruct[d].status_byte |= p_busy_new;
969 if (st&p_disk_ok) DriveStruct[d].status_byte |= p_disk_ok;
970 }
971 else if (famL_drive)
972 {
973 DriveStruct[d].status_byte=0;
974 if (st&p_caddin_old) DriveStruct[d].status_byte |= p_disk_ok|p_caddy_in;
975 if (st&p_spinning) DriveStruct[d].status_byte |= p_spinning;
976 if (st&p_check) DriveStruct[d].status_byte |= p_check;
977 if (st&p_busy_old) DriveStruct[d].status_byte |= p_busy_new;
978 if (st&p_lcs_door_closed) DriveStruct[d].status_byte |= p_door_closed;
979 if (st&p_lcs_door_locked) DriveStruct[d].status_byte |= p_door_locked;
980 }
981 else if (fam1_drive)
982 {
983 DriveStruct[d].status_byte=st;
984 st=p_success_old;
985 }
986 else
987 {
988 }
989 return (st);
990 }
991
992 static int ResponseStatus(void)
993 {
994 int i,j;
995 u_long timeout;
996
997 DPRINTF((DBG_STA,"SBPCD: doing ResponseStatus...\n"));
998
999 if (current == task[0])
1000 {
1001 if (flags_cmd_out & f_respo3) j = maxtim_8;
1002 else if (flags_cmd_out&f_respo2) j=maxtim16;
1003 else j=maxtim04;
1004 for (;j!=0;j--)
1005 {
1006 i=inb(CDi_status);
1007 if (!(i&s_not_result_ready)) break;
1008 }
1009 }
1010 else
1011 {
1012 if (flags_cmd_out & f_respo3) timeout = jiffies;
1013 else if (flags_cmd_out & f_respo2) timeout = jiffies + 1600;
1014 else timeout = jiffies + 400;
1015 j=maxtim_8;
1016 do
1017 {
1018 for ( ;j!=0;j--)
1019 {
1020 i=inb(CDi_status);
1021 if (!(i&s_not_result_ready)) break;
1022 }
1023 if (j != 0 || timeout <= jiffies) break;
1024 sbp_sleep(0);
1025 j = 1;
1026 }
1027 while (1);
1028 }
1029 if (j==0)
1030 { if ((flags_cmd_out & f_respo3) == 0)
1031 DPRINTF((DBG_STA,"SBPCD: ResponseStatus: timeout.\n"));
1032 EvaluateStatus(0);
1033 return (-1);
1034 }
1035 i=inb(CDi_info);
1036 DPRINTF((DBG_STA,"SBPCD: ResponseStatus: response %2X.\n", i));
1037 i=EvaluateStatus(i);
1038 return (i);
1039 }
1040
1041 static void xx_ReadStatus(void)
1042 {
1043 int i;
1044
1045 DPRINTF((DBG_STA,"SBPCD: giving xx_ReadStatus command\n"));
1046 SBPCD_CLI;
1047 if (fam0L_drive) OUT(CDo_command,CMD0_STATUS);
1048 else if (fam1_drive) OUT(CDo_command,CMD1_STATUS);
1049 else
1050 {
1051 }
1052 if (!fam0L_drive) for (i=0;i<6;i++) OUT(CDo_command,0);
1053 SBPCD_STI;
1054 }
1055
1056 static int xx_ReadError(void)
1057 {
1058 int i;
1059
1060 clr_cmdbuf();
1061 DPRINTF((DBG_ERR,"SBPCD: giving xx_ReadError command.\n"));
1062 if (fam1_drive)
1063 {
1064 drvcmd[0]=CMD1_READ_ERR;
1065 response_count=8;
1066 flags_cmd_out=f_putcmd|f_ResponseStatus;
1067 }
1068 else if (fam0L_drive)
1069 {
1070 drvcmd[0]=CMD0_READ_ERR;
1071 response_count=6;
1072 if (famL_drive)
1073 flags_cmd_out=f_putcmd;
1074 else
1075 flags_cmd_out=f_putcmd|f_getsta|f_ResponseStatus;
1076 }
1077 else if (fam2_drive)
1078 {
1079 drvcmd[0]=CMD2_READ_ERR;
1080 response_count=6;
1081 flags_cmd_out=f_putcmd;
1082 }
1083 else
1084 {
1085 return (-1);
1086 drvcmd[0]=CMDT_READ_ERR;
1087 response_count=5;
1088 flags_cmd_out=f_putcmd;
1089 }
1090 i=cmd_out(7);
1091 DriveStruct[d].error_byte=0;
1092 DPRINTF((DBG_ERR,"SBPCD: xx_ReadError: cmd_out(82) returns %d (%02X)\n",i,i));
1093 if (i<0) return (i);
1094 if (fam0_drive) i=1;
1095 else i=2;
1096 DriveStruct[d].error_byte=infobuf[i];
1097 DPRINTF((DBG_ERR,"SBPCD: xx_ReadError: infobuf[%d] is %d (%02X)\n",i,DriveStruct[d].error_byte,DriveStruct[d].error_byte));
1098 i=sta2err(infobuf[i]);
1099 return (i);
1100 }
1101
1102 static int cmd_out(int len)
1103 {
1104 int i=0;
1105
1106 if (flags_cmd_out&f_putcmd)
1107 {
1108 DPRINTF((DBG_CMD,"SBPCD: cmd_out: put"));
1109 for (i=0;i<len;i++) DPRINTF((DBG_CMD," %02X",drvcmd[i]));
1110 DPRINTF((DBG_CMD,"\n"));
1111
1112 cli();
1113 for (i=0;i<len;i++) OUT(CDo_command,drvcmd[i]);
1114 sti();
1115 }
1116 if (response_count!=0)
1117 {
1118 if (cmd_type!=0)
1119 {
1120 if (sbpro_type==1) OUT(CDo_sel_i_d,1);
1121 DPRINTF((DBG_INF,"SBPCD: misleaded to try ResponseData.\n"));
1122 if (sbpro_type==1) OUT(CDo_sel_i_d,0);
1123 return (-22);
1124 }
1125 else i=ResponseInfo();
1126 if (i<0) return (-9);
1127 }
1128 if (DriveStruct[d].in_SpinUp != 0) DPRINTF((DBG_SPI,"SBPCD: to CDi_stat_loop.\n"));
1129 if (flags_cmd_out&f_lopsta)
1130 {
1131 i=CDi_stat_loop();
1132 if ((i<0)||!(i&s_attention)) return (-9);
1133 }
1134 if (!(flags_cmd_out&f_getsta)) goto LOC_229;
1135
1136 LOC_228:
1137 if (DriveStruct[d].in_SpinUp != 0) DPRINTF((DBG_SPI,"SBPCD: to xx_ReadStatus.\n"));
1138 xx_ReadStatus();
1139
1140 LOC_229:
1141 if (flags_cmd_out&f_ResponseStatus)
1142 {
1143 if (DriveStruct[d].in_SpinUp != 0) DPRINTF((DBG_SPI,"SBPCD: to ResponseStatus.\n"));
1144 i=ResponseStatus();
1145
1146 if (i<0) return (-9);
1147 if (flags_cmd_out&(f_bit1|f_wait_if_busy))
1148 {
1149 if (!st_check)
1150 {
1151 if (flags_cmd_out&f_bit1) if (i&p_success_old) goto LOC_232;
1152 if (!(flags_cmd_out&f_wait_if_busy)) goto LOC_228;
1153 if (!st_busy) goto LOC_228;
1154 }
1155 }
1156 }
1157 LOC_232:
1158 if (!(flags_cmd_out&f_obey_p_check)) return (0);
1159 if (!st_check) return (0);
1160 if (DriveStruct[d].in_SpinUp != 0) DPRINTF((DBG_SPI,"SBPCD: to xx_ReadError.\n"));
1161 i=xx_ReadError();
1162 if (DriveStruct[d].in_SpinUp != 0) DPRINTF((DBG_SPI,"SBPCD: to cmd_out OK.\n"));
1163 return (i);
1164 }
1165
1166 static int xx_Seek(u_int pos, char f_blk_msf)
1167 {
1168 int i;
1169
1170 clr_cmdbuf();
1171 if (f_blk_msf>1) return (-3);
1172 if (fam0_drive)
1173 {
1174 drvcmd[0]=CMD0_SEEK;
1175 if (f_blk_msf==1) pos=msf2blk(pos);
1176 drvcmd[2]=(pos>>16)&0x00FF;
1177 drvcmd[3]=(pos>>8)&0x00FF;
1178 drvcmd[4]=pos&0x00FF;
1179 flags_cmd_out = f_putcmd | f_respo2 | f_lopsta | f_getsta |
1180 f_ResponseStatus | f_obey_p_check | f_bit1;
1181 }
1182 else if (fam1L_drive)
1183 {
1184 drvcmd[0]=CMD1_SEEK;
1185 if (f_blk_msf==0) pos=blk2msf(pos);
1186 drvcmd[1]=(pos>>16)&0x00FF;
1187 drvcmd[2]=(pos>>8)&0x00FF;
1188 drvcmd[3]=pos&0x00FF;
1189 if (famL_drive)
1190 flags_cmd_out=f_putcmd|f_respo2|f_lopsta|f_getsta|f_ResponseStatus|f_obey_p_check|f_bit1;
1191 else
1192 flags_cmd_out=f_putcmd|f_respo2|f_ResponseStatus|f_obey_p_check;
1193 }
1194 else if (fam2_drive)
1195 {
1196 drvcmd[0]=CMD2_SEEK;
1197 if (f_blk_msf==0) pos=blk2msf(pos);
1198 drvcmd[2]=(pos>>16)&0x00FF;
1199 drvcmd[3]=(pos>>16)&0x00FF;
1200 drvcmd[4]=(pos>>8)&0x00FF;
1201 drvcmd[5]=pos&0x00FF;
1202 flags_cmd_out=f_putcmd|f_ResponseStatus;
1203 }
1204 else
1205 {
1206 return (-1);
1207 }
1208 response_count=0;
1209 i=cmd_out(7);
1210 return (i);
1211 }
1212
1213 static int xx_SpinUp(void)
1214 {
1215 int i;
1216
1217 DPRINTF((DBG_SPI,"SBPCD: SpinUp.\n"));
1218 DriveStruct[d].in_SpinUp = 1;
1219 clr_cmdbuf();
1220 if (fam0L_drive)
1221 {
1222 drvcmd[0]=CMD0_SPINUP;
1223 flags_cmd_out=f_putcmd|f_respo2|f_lopsta|f_getsta|
1224 f_ResponseStatus|f_obey_p_check|f_bit1;
1225 }
1226 else if (fam1_drive)
1227 {
1228 drvcmd[0]=CMD1_SPINUP;
1229 flags_cmd_out=f_putcmd|f_respo2|f_ResponseStatus|f_obey_p_check;
1230 }
1231 else if (fam2_drive)
1232 {
1233 drvcmd[0]=CMD2_TRAY_CTL;
1234 drvcmd[4]=0x01;
1235 flags_cmd_out=f_putcmd|f_respo2|f_ResponseStatus|f_obey_p_check;
1236 }
1237 else
1238 {
1239 return (-1);
1240 }
1241 response_count=0;
1242 i=cmd_out(7);
1243 DriveStruct[d].in_SpinUp = 0;
1244 return (i);
1245 }
1246
1247 static int yy_SpinDown(void)
1248 {
1249 int i;
1250
1251 if (fam0_drive) return (-3);
1252 clr_cmdbuf();
1253 response_count=0;
1254 if (fam1_drive)
1255 {
1256 drvcmd[0]=CMD1_SPINDOWN;
1257 flags_cmd_out=f_putcmd|f_respo2|f_ResponseStatus|f_obey_p_check;
1258 }
1259 else if (fam2_drive)
1260 {
1261 drvcmd[0]=CMD2_TRAY_CTL;
1262 drvcmd[4]=0x02;
1263 flags_cmd_out=f_putcmd|f_ResponseStatus;
1264 }
1265 else if (famL_drive)
1266 {
1267 drvcmd[0]=CMDL_SPINDOWN;
1268 drvcmd[1]=1;
1269 flags_cmd_out=f_putcmd|f_respo2|f_lopsta|f_getsta|f_ResponseStatus|f_obey_p_check|f_bit1;
1270 }
1271 else
1272 {
1273 return (-1);
1274 }
1275 i=cmd_out(7);
1276 return (i);
1277 }
1278
1279 static int yy_SetSpeed(u_char speed, u_char x1, u_char x2)
1280 {
1281 int i;
1282
1283 if (fam0L_drive) return (-3);
1284 clr_cmdbuf();
1285 response_count=0;
1286 if (fam1_drive)
1287 {
1288 drvcmd[0]=CMD1_SETMODE;
1289 drvcmd[1]=0x03;
1290 drvcmd[2]=speed;
1291 drvcmd[3]=x1;
1292 drvcmd[4]=x2;
1293 flags_cmd_out=f_putcmd|f_ResponseStatus|f_obey_p_check;
1294 }
1295 else if (fam2_drive)
1296 {
1297 drvcmd[0]=CMD2_SETSPEED;
1298 if (speed&speed_auto)
1299 {
1300 drvcmd[2]=0xFF;
1301 drvcmd[3]=0xFF;
1302 }
1303 else
1304 {
1305 drvcmd[2]=0;
1306 drvcmd[3]=150;
1307 }
1308 flags_cmd_out=f_putcmd|f_ResponseStatus;
1309 }
1310 else
1311 {
1312 return (-1);
1313 }
1314 i=cmd_out(7);
1315 return (i);
1316 }
1317
1318 static int xx_SetVolume(void)
1319 {
1320 int i;
1321 u_char channel0,channel1,volume0,volume1;
1322 u_char control0,value0,control1,value1;
1323
1324 DriveStruct[d].diskstate_flags &= ~volume_bit;
1325 clr_cmdbuf();
1326 channel0=DriveStruct[d].vol_chan0;
1327 volume0=DriveStruct[d].vol_ctrl0;
1328 channel1=control1=DriveStruct[d].vol_chan1;
1329 volume1=value1=DriveStruct[d].vol_ctrl1;
1330 control0=value0=0;
1331
1332 if (((DriveStruct[d].drv_options&audio_mono)!=0)&&(DriveStruct[d].drv_type>=drv_211))
1333 {
1334 if ((volume0!=0)&&(volume1==0))
1335 {
1336 volume1=volume0;
1337 channel1=channel0;
1338 }
1339 else if ((volume0==0)&&(volume1!=0))
1340 {
1341 volume0=volume1;
1342 channel0=channel1;
1343 }
1344 }
1345 if (channel0>1)
1346 {
1347 channel0=0;
1348 volume0=0;
1349 }
1350 if (channel1>1)
1351 {
1352 channel1=1;
1353 volume1=0;
1354 }
1355
1356 if (fam1_drive)
1357 {
1358 control0=channel0+1;
1359 control1=channel1+1;
1360 value0=(volume0>volume1)?volume0:volume1;
1361 value1=value0;
1362 if (volume0==0) control0=0;
1363 if (volume1==0) control1=0;
1364 drvcmd[0]=CMD1_SETMODE;
1365 drvcmd[1]=0x05;
1366 drvcmd[3]=control0;
1367 drvcmd[4]=value0;
1368 drvcmd[5]=control1;
1369 drvcmd[6]=value1;
1370 flags_cmd_out=f_putcmd|f_ResponseStatus|f_obey_p_check;
1371 }
1372 else if (fam2_drive)
1373 {
1374 control0=channel0+1;
1375 control1=channel1+1;
1376 value0=(volume0>volume1)?volume0:volume1;
1377 value1=value0;
1378 if (volume0==0) control0=0;
1379 if (volume1==0) control1=0;
1380 drvcmd[0]=CMD2_SETMODE;
1381 drvcmd[1]=0x0E;
1382 drvcmd[3]=control0;
1383 drvcmd[4]=value0;
1384 drvcmd[5]=control1;
1385 drvcmd[6]=value1;
1386 flags_cmd_out=f_putcmd|f_ResponseStatus;
1387 }
1388 else if (famL_drive)
1389 {
1390 if ((volume0==0)||(channel0!=0)) control0 |= 0x80;
1391 if ((volume1==0)||(channel1!=1)) control0 |= 0x40;
1392 if (volume0|volume1) value0=0x80;
1393 drvcmd[0]=CMDL_SETMODE;
1394 drvcmd[1]=0x03;
1395 drvcmd[4]=control0;
1396 drvcmd[5]=value0;
1397 flags_cmd_out=f_putcmd|f_lopsta|f_getsta|f_ResponseStatus|f_obey_p_check|f_bit1;
1398 }
1399 else if (fam0_drive)
1400 {
1401 if (DriveStruct[d].drv_type>=drv_300)
1402 {
1403 control0=volume0&0xFC;
1404 value0=volume1&0xFC;
1405 if ((volume0!=0)&&(volume0<4)) control0 |= 0x04;
1406 if ((volume1!=0)&&(volume1<4)) value0 |= 0x04;
1407 if (channel0!=0) control0 |= 0x01;
1408 if (channel1==1) value0 |= 0x01;
1409 }
1410 else
1411 {
1412 value0=(volume0>volume1)?volume0:volume1;
1413 if (DriveStruct[d].drv_type<drv_211)
1414 {
1415 if (channel0!=0)
1416 {
1417 i=channel1;
1418 channel1=channel0;
1419 channel0=i;
1420 i=volume1;
1421 volume1=volume0;
1422 volume0=i;
1423 }
1424 if (channel0==channel1)
1425 {
1426 if (channel0==0)
1427 {
1428 channel1=1;
1429 volume1=0;
1430 volume0=value0;
1431 }
1432 else
1433 {
1434 channel0=0;
1435 volume0=0;
1436 volume1=value0;
1437 }
1438 }
1439 }
1440
1441 if ((volume0!=0)&&(volume1!=0))
1442 {
1443 if (volume0==0xFF) volume1=0xFF;
1444 else if (volume1==0xFF) volume0=0xFF;
1445 }
1446 else if (DriveStruct[d].drv_type<drv_201) volume0=volume1=value0;
1447
1448 if (DriveStruct[d].drv_type>=drv_201)
1449 {
1450 if (volume0==0) control0 |= 0x80;
1451 if (volume1==0) control0 |= 0x40;
1452 }
1453 if (DriveStruct[d].drv_type>=drv_211)
1454 {
1455 if (channel0!=0) control0 |= 0x20;
1456 if (channel1!=1) control0 |= 0x10;
1457 }
1458 }
1459 drvcmd[0]=CMD0_SETMODE;
1460 drvcmd[1]=0x83;
1461 drvcmd[4]=control0;
1462 drvcmd[5]=value0;
1463 flags_cmd_out=f_putcmd|f_getsta|f_ResponseStatus|f_obey_p_check;
1464 }
1465 else
1466 {
1467 return (-1);
1468 }
1469 response_count=0;
1470 i=cmd_out(7);
1471 if (i>0) return (i);
1472 DriveStruct[d].diskstate_flags |= volume_bit;
1473 return (0);
1474 }
1475
1476 static int GetStatus(void)
1477 {
1478 int i;
1479
1480 flags_cmd_out=f_getsta|f_ResponseStatus|f_obey_p_check;
1481 response_count=0;
1482 cmd_type=0;
1483 i=cmd_out(7);
1484 return (i);
1485 }
1486
1487 static int xy_DriveReset(void)
1488 {
1489 int i;
1490
1491 DPRINTF((DBG_RES,"SBPCD: xy_DriveReset called.\n"));
1492 clr_cmdbuf();
1493 response_count=0;
1494 if (fam0L_drive) OUT(CDo_reset,0x00);
1495 else if (fam1_drive)
1496 {
1497 drvcmd[0]=CMD1_RESET;
1498 flags_cmd_out=f_putcmd;
1499 i=cmd_out(7);
1500 }
1501 else if (fam2_drive)
1502 {
1503 drvcmd[0]=CMD2_RESET;
1504 flags_cmd_out=f_putcmd;
1505 i=cmd_out(7);
1506 OUT(CDo_reset,0x00);
1507 }
1508 else
1509 {
1510 return (-1);
1511 }
1512 if (famL_drive) sbp_sleep(500);
1513 else sbp_sleep(100);
1514 flush_status();
1515 i=GetStatus();
1516 if (i>=0) return -1;
1517 if (DriveStruct[d].error_byte!=aud_12) return -1;
1518 return (0);
1519 }
1520
1521 static int SetSpeed(void)
1522 {
1523 int i, speed;
1524
1525 if (!(DriveStruct[d].drv_options&(speed_auto|speed_300|speed_150))) return (0);
1526 speed=speed_auto;
1527 if (!(DriveStruct[d].drv_options&speed_auto))
1528 {
1529 speed |= speed_300;
1530 if (!(DriveStruct[d].drv_options&speed_300)) speed=0;
1531 }
1532 i=yy_SetSpeed(speed,0,0);
1533 return (i);
1534 }
1535
1536 static int DriveReset(void)
1537 {
1538 int i;
1539
1540 i=xy_DriveReset();
1541 if (i<0) return (-2);
1542 do
1543 {
1544 i=GetStatus();
1545 if ((i<0)&&(i!=-15)) return (-2);
1546 if (!st_caddy_in) break;
1547 }
1548 while (!st_diskok);
1549 #if 000
1550 DriveStruct[d].CD_changed=1;
1551 #endif
1552 if ((st_door_closed) && (st_caddy_in))
1553 {
1554 i=DiskInfo();
1555 if (i<0) return (-2);
1556 }
1557 return (0);
1558 }
1559
1560 static int xx_Pause_Resume(int pau_res)
1561 {
1562 int i;
1563
1564 clr_cmdbuf();
1565 response_count=0;
1566 if (fam1_drive)
1567 {
1568 drvcmd[0]=CMD1_PAU_RES;
1569 if (pau_res!=1) drvcmd[1]=0x80;
1570 flags_cmd_out=f_putcmd|f_respo2|f_ResponseStatus|f_obey_p_check;
1571 }
1572 else if (fam2_drive)
1573 {
1574 drvcmd[0]=CMD2_PAU_RES;
1575 if (pau_res!=1) drvcmd[2]=0x01;
1576 flags_cmd_out=f_putcmd|f_ResponseStatus;
1577 }
1578 else if (fam0L_drive)
1579 {
1580 drvcmd[0]=CMD0_PAU_RES;
1581 if (pau_res!=1) drvcmd[1]=0x80;
1582 if (famL_drive)
1583 flags_cmd_out=f_putcmd|f_respo2|f_lopsta|f_getsta|f_ResponseStatus|
1584 f_obey_p_check|f_bit1;
1585 else
1586 flags_cmd_out=f_putcmd|f_respo2|f_lopsta|f_getsta|f_ResponseStatus|
1587 f_obey_p_check;
1588 }
1589 else
1590 {
1591 return (-1);
1592 }
1593 i=cmd_out(7);
1594 return (i);
1595 }
1596
1597 static int yy_LockDoor(char lock)
1598 {
1599 int i;
1600
1601 if (fam0_drive) return (0);
1602 DPRINTF((DBG_LCK,"SBPCD: yy_LockDoor: %d (drive %d)\n", lock, d));
1603 DPRINTF((DBG_LCS,"SBPCD: p_door_locked bit %d before\n", st_door_locked));
1604 clr_cmdbuf();
1605 response_count=0;
1606 if (fam1_drive)
1607 {
1608 drvcmd[0]=CMD1_LOCK_CTL;
1609 if (lock==1) drvcmd[1]=0x01;
1610 flags_cmd_out=f_putcmd|f_ResponseStatus|f_obey_p_check;
1611 }
1612 else if (fam2_drive)
1613 {
1614 drvcmd[0]=CMD2_LOCK_CTL;
1615 if (lock==1) drvcmd[4]=0x01;
1616 flags_cmd_out=f_putcmd|f_ResponseStatus;
1617 }
1618 else if (famL_drive)
1619 {
1620 drvcmd[0]=CMDL_LOCK_CTL;
1621 if (lock==1) drvcmd[1]=0x01;
1622 flags_cmd_out=f_putcmd|f_respo2|f_lopsta|f_getsta|f_ResponseStatus|f_obey_p_check|f_bit1;
1623 }
1624 else
1625 {
1626 return (-1);
1627 }
1628 i=cmd_out(7);
1629 DPRINTF((DBG_LCS,"SBPCD: p_door_locked bit %d after\n", st_door_locked));
1630 return (i);
1631 }
1632
1633 static int yy_CloseTray(void)
1634 {
1635 int i;
1636
1637 if (fam0_drive) return (0);
1638 DPRINTF((DBG_LCK,"SBPCD: yy_CloseTray (drive %d)\n", d));
1639 DPRINTF((DBG_LCS,"SBPCD: p_door_closed bit %d before\n", st_door_closed));
1640
1641 clr_cmdbuf();
1642 response_count=0;
1643 if (fam1_drive)
1644 {
1645 drvcmd[0]=CMD1_TRAY_CTL;
1646 flags_cmd_out=f_putcmd|f_respo2|f_ResponseStatus|f_obey_p_check;
1647 }
1648 else if (fam2_drive)
1649 {
1650 drvcmd[0]=CMD2_TRAY_CTL;
1651 drvcmd[1]=0x01;
1652 drvcmd[4]=0x03;
1653 flags_cmd_out=f_putcmd|f_ResponseStatus;
1654 }
1655 else if (famL_drive)
1656 {
1657 drvcmd[0]=CMDL_TRAY_CTL;
1658 flags_cmd_out=f_putcmd|f_respo2|f_lopsta|f_getsta|
1659 f_ResponseStatus|f_obey_p_check|f_bit1;
1660 }
1661 else
1662 {
1663 return (-1);
1664 }
1665 i=cmd_out(7);
1666 DPRINTF((DBG_LCS,"SBPCD: p_door_closed bit %d after\n", st_door_closed));
1667 return (i);
1668 }
1669
1670 static int xx_ReadSubQ(void)
1671 {
1672 int i,j;
1673
1674 DriveStruct[d].diskstate_flags &= ~subq_bit;
1675 for (j=255;j>0;j--)
1676 {
1677 clr_cmdbuf();
1678 if (fam1_drive)
1679 {
1680 drvcmd[0]=CMD1_READSUBQ;
1681 flags_cmd_out=f_putcmd|f_ResponseStatus|f_obey_p_check;
1682 response_count=11;
1683 }
1684 else if (fam2_drive)
1685 {
1686 drvcmd[0]=CMD2_READSUBQ;
1687 drvcmd[1]=0x02;
1688 drvcmd[3]=0x01;
1689 flags_cmd_out=f_putcmd;
1690 response_count=10;
1691 }
1692 else if (fam0L_drive)
1693 {
1694 drvcmd[0]=CMD0_READSUBQ;
1695 drvcmd[1]=0x02;
1696 if (famL_drive)
1697 flags_cmd_out=f_putcmd;
1698 else
1699 flags_cmd_out=f_putcmd|f_getsta|f_ResponseStatus|f_obey_p_check;
1700 response_count=13;
1701 }
1702 else
1703 {
1704 return (-1);
1705 }
1706 i=cmd_out(7);
1707 if (i<0) return (i);
1708 DPRINTF((DBG_SQ,"SBPCD: xx_ReadSubQ:"));
1709 for (i=0;i<response_count;i++)
1710 {
1711 DPRINTF((DBG_SQ," %02X", infobuf[i]));
1712 }
1713 DPRINTF((DBG_SQ,"\n"));
1714 if (infobuf[0]!=0) break;
1715 if ((!st_spinning) || (j==1))
1716 {
1717 DriveStruct[d].SubQ_ctl_adr=DriveStruct[d].SubQ_trk=DriveStruct[d].SubQ_pnt_idx=DriveStruct[d].SubQ_whatisthis=0;
1718 DriveStruct[d].SubQ_run_tot=DriveStruct[d].SubQ_run_trk=0;
1719 return (0);
1720 }
1721 }
1722 DriveStruct[d].SubQ_ctl_adr=swap_nibbles(infobuf[1]);
1723 DriveStruct[d].SubQ_trk=byt2bcd(infobuf[2]);
1724 DriveStruct[d].SubQ_pnt_idx=byt2bcd(infobuf[3]);
1725 i=4;
1726 if (fam0L_drive) i=5;
1727 DriveStruct[d].SubQ_run_tot=make32(make16(0,infobuf[i]),make16(infobuf[i+1],infobuf[i+2]));
1728 i=7;
1729 if (fam0L_drive) i=9;
1730 DriveStruct[d].SubQ_run_trk=make32(make16(0,infobuf[i]),make16(infobuf[i+1],infobuf[i+2]));
1731 DriveStruct[d].SubQ_whatisthis=infobuf[i+3];
1732 DriveStruct[d].diskstate_flags |= subq_bit;
1733 return (0);
1734 }
1735
1736 static int xx_ModeSense(void)
1737 {
1738 int i;
1739
1740 if (fam2_drive) return (0);
1741 DriveStruct[d].diskstate_flags &= ~frame_size_bit;
1742 clr_cmdbuf();
1743 if (fam1_drive)
1744 {
1745 drvcmd[0]=CMD1_GETMODE;
1746 flags_cmd_out=f_putcmd|f_ResponseStatus|f_obey_p_check;
1747 response_count=5;
1748 }
1749 else if (fam0L_drive)
1750 {
1751 drvcmd[0]=CMD0_GETMODE;
1752 if (famL_drive)
1753 flags_cmd_out=f_putcmd;
1754 else
1755 flags_cmd_out=f_putcmd|f_getsta|f_ResponseStatus|f_obey_p_check;
1756 response_count=2;
1757 }
1758 else
1759 {
1760 return (-1);
1761 }
1762 i=cmd_out(7);
1763 if (i<0) return (i);
1764 i=0;
1765 if (fam1_drive) DriveStruct[d].sense_byte=infobuf[i++];
1766 else if (fam0L_drive) DriveStruct[d].sense_byte=0;
1767 else
1768 {
1769 }
1770 DriveStruct[d].frame_size=make16(infobuf[i],infobuf[i+1]);
1771
1772 DPRINTF((DBG_XA,"SBPCD: xx_ModeSense: "));
1773 for (i=0;i<(fam1_drive?5:2);i++)
1774 {
1775 DPRINTF((DBG_XA,"%02X ", infobuf[i]));
1776 }
1777 DPRINTF((DBG_XA,"\n"));
1778
1779 DriveStruct[d].diskstate_flags |= frame_size_bit;
1780 return (0);
1781 }
1782
1783
1784 static int xx_ModeSelect(int framesize)
1785 {
1786 int i;
1787
1788 if (fam2_drive) return (0);
1789 DriveStruct[d].diskstate_flags &= ~frame_size_bit;
1790 clr_cmdbuf();
1791 DriveStruct[d].frame_size=framesize;
1792 if (framesize==CD_FRAMESIZE_RAW) DriveStruct[d].sense_byte=0x82;
1793 else DriveStruct[d].sense_byte=0x00;
1794
1795 DPRINTF((DBG_XA,"SBPCD: xx_ModeSelect: %02X %04X\n",
1796 DriveStruct[d].sense_byte, DriveStruct[d].frame_size));
1797
1798 if (fam1_drive)
1799 {
1800 drvcmd[0]=CMD1_SETMODE;
1801 drvcmd[1]=0x00;
1802 drvcmd[2]=DriveStruct[d].sense_byte;
1803 drvcmd[3]=(DriveStruct[d].frame_size>>8)&0xFF;
1804 drvcmd[4]=DriveStruct[d].frame_size&0xFF;
1805 flags_cmd_out=f_putcmd|f_ResponseStatus|f_obey_p_check;
1806 }
1807 else if (fam0L_drive)
1808 {
1809 drvcmd[0]=CMD0_SETMODE;
1810 drvcmd[1]=0x00;
1811 drvcmd[2]=(DriveStruct[d].frame_size>>8)&0xFF;
1812 drvcmd[3]=DriveStruct[d].frame_size&0xFF;
1813 drvcmd[4]=0x00;
1814 if(famL_drive)
1815 flags_cmd_out=f_putcmd|f_lopsta|f_getsta|f_ResponseStatus|f_obey_p_check;
1816 else
1817 flags_cmd_out=f_putcmd|f_getsta|f_ResponseStatus|f_obey_p_check;
1818 }
1819 else
1820 {
1821 return (-1);
1822 }
1823 response_count=0;
1824 i=cmd_out(7);
1825 if (i<0) return (i);
1826 DriveStruct[d].diskstate_flags |= frame_size_bit;
1827 return (0);
1828 }
1829
1830 #if 0000
1831 static int xx_TellVolume(void)
1832 {
1833 int i;
1834 u_char switches;
1835 u_char chan0,vol0,chan1,vol1;
1836
1837 DriveStruct[d].diskstate_flags &= ~volume_bit;
1838 clr_cmdbuf();
1839 if (fam1_drive)
1840 {
1841 drvcmd[0]=CMD1_GETMODE;
1842 drvcmd[1]=0x05;
1843 response_count=5;
1844 flags_cmd_out=f_putcmd|f_ResponseStatus|f_obey_p_check;
1845 }
1846 else if (fam2_drive)
1847 {
1848 drvcmd[0]=CMD2_GETMODE;
1849 drvcmd[1]=0x0E;
1850 response_count=5;
1851 flags_cmd_out=f_putcmd;
1852 }
1853 else if (fam0L_drive)
1854 {
1855 drvcmd[0]=CMD0_GETMODE;
1856 drvcmd[1]=0x03;
1857 response_count=2;
1858 if(famL_drive)
1859 flags_cmd_out=f_putcmd;
1860 else
1861 flags_cmd_out=f_putcmd|f_getsta|f_ResponseStatus|f_obey_p_check;
1862 }
1863 else
1864 {
1865 return (-1);
1866 }
1867 i=cmd_out(7);
1868 if (i<0) return (i);
1869 if (fam1_drive)
1870 {
1871 chan0=infobuf[1]&0x0F;
1872 vol0=infobuf[2];
1873 chan1=infobuf[3]&0x0F;
1874 vol1=infobuf[4];
1875 if (chan0==0)
1876 {
1877 chan0=1;
1878 vol0=0;
1879 }
1880 if (chan1==0)
1881 {
1882 chan1=2;
1883 vol1=0;
1884 }
1885 chan0 >>= 1;
1886 chan1 >>= 1;
1887 }
1888 else if (fam2_drive)
1889 {
1890 chan0=infobuf[1];
1891 vol0=infobuf[2];
1892 chan1=infobuf[3];
1893 vol1=infobuf[4];
1894 }
1895 else if (famL_drive)
1896 {
1897 chan0=0;
1898 chan1=1;
1899 vol0=vol1=infobuf[1];
1900 switches=infobuf[0];
1901 if ((switches&0x80)!=0) chan0=1;
1902 if ((switches&0x40)!=0) chan1=0;
1903 }
1904 else if (fam0_drive)
1905 {
1906 chan0=0;
1907 chan1=1;
1908 vol0=vol1=infobuf[1];
1909 if (DriveStruct[d].drv_type>=drv_201)
1910 {
1911 if (DriveStruct[d].drv_type<drv_300)
1912 {
1913 switches=infobuf[0];
1914 if ((switches&0x80)!=0) vol0=0;
1915 if ((switches&0x40)!=0) vol1=0;
1916 if (DriveStruct[d].drv_type>=drv_211)
1917 {
1918 if ((switches&0x20)!=0) chan0=1;
1919 if ((switches&0x10)!=0) chan1=0;
1920 }
1921 }
1922 else
1923 {
1924 vol0=infobuf[0];
1925 if ((vol0&0x01)!=0) chan0=1;
1926 if ((vol1&0x01)==0) chan1=0;
1927 vol0 &= 0xFC;
1928 vol1 &= 0xFC;
1929 if (vol0!=0) vol0 += 3;
1930 if (vol1!=0) vol1 += 3;
1931 }
1932 }
1933 }
1934 else
1935 {
1936 return (-1);
1937 }
1938 DriveStruct[d].vol_chan0=chan0;
1939 DriveStruct[d].vol_ctrl0=vol0;
1940 DriveStruct[d].vol_chan1=chan1;
1941 DriveStruct[d].vol_ctrl1=vol1;
1942 DriveStruct[d].vol_chan2=2;
1943 DriveStruct[d].vol_ctrl2=0xFF;
1944 DriveStruct[d].vol_chan3=3;
1945 DriveStruct[d].vol_ctrl3=0xFF;
1946 DriveStruct[d].diskstate_flags |= volume_bit;
1947 return (0);
1948 }
1949 #endif
1950
1951 static int xx_ReadCapacity(void)
1952 {
1953 int i;
1954
1955 if (famL_drive) return (0);
1956 DriveStruct[d].diskstate_flags &= ~cd_size_bit;
1957 clr_cmdbuf();
1958 if (fam1_drive)
1959 {
1960 drvcmd[0]=CMD1_CAPACITY;
1961 response_count=5;
1962 flags_cmd_out=f_putcmd|f_ResponseStatus|f_obey_p_check;
1963 }
1964 else if (fam2_drive)
1965 {
1966 drvcmd[0]=CMD2_CAPACITY;
1967 response_count=8;
1968 flags_cmd_out=f_putcmd;
1969 }
1970 else if (fam0_drive)
1971 {
1972 drvcmd[0]=CMD0_CAPACITY;
1973 response_count=5;
1974 if(famL_drive)
1975 flags_cmd_out=f_putcmd;
1976 else
1977 flags_cmd_out=f_putcmd|f_getsta|f_ResponseStatus|f_obey_p_check;
1978 }
1979 else
1980 {
1981 return (-1);
1982 }
1983 i=cmd_out(7);
1984 if (i<0) return (i);
1985 if (fam1_drive) DriveStruct[d].CDsize_frm=msf2blk(make32(make16(0,infobuf[0]),make16(infobuf[1],infobuf[2])))+CD_BLOCK_OFFSET;
1986 else if (fam0_drive) DriveStruct[d].CDsize_frm=make32(make16(0,infobuf[0]),make16(infobuf[1],infobuf[2]));
1987 else if (fam2_drive) DriveStruct[d].CDsize_frm=make32(make16(infobuf[0],infobuf[1]),make16(infobuf[2],infobuf[3]));
1988 DriveStruct[d].diskstate_flags |= cd_size_bit;
1989 return (0);
1990 }
1991
1992 static int xx_ReadTocDescr(void)
1993 {
1994 int i;
1995
1996 DriveStruct[d].diskstate_flags &= ~toc_bit;
1997 clr_cmdbuf();
1998 if (fam1_drive)
1999 {
2000 drvcmd[0]=CMD1_DISKINFO;
2001 response_count=6;
2002 flags_cmd_out=f_putcmd|f_ResponseStatus|f_obey_p_check;
2003 }
2004 else if (fam0L_drive)
2005 {
2006 drvcmd[0]=CMD0_DISKINFO;
2007 response_count=6;
2008 if(famL_drive)
2009 flags_cmd_out=f_putcmd;
2010 else
2011 flags_cmd_out=f_putcmd|f_getsta|f_ResponseStatus|f_obey_p_check;
2012 }
2013 else if (fam2_drive)
2014 {
2015
2016 DriveStruct[d].f_multisession=0;
2017 drvcmd[0]=CMD2_DISKINFO;
2018 drvcmd[1]=0x02;
2019 drvcmd[2]=0xAB;
2020 drvcmd[3]=0xFF;
2021 response_count=8;
2022 flags_cmd_out=f_putcmd;
2023 }
2024 else
2025 {
2026 return (-1);
2027 }
2028 i=cmd_out(7);
2029 if (i<0) return (i);
2030 DriveStruct[d].xa_byte=infobuf[0];
2031 if (fam2_drive)
2032 {
2033 DriveStruct[d].first_session=infobuf[1];
2034 DriveStruct[d].last_session=infobuf[2];
2035 DriveStruct[d].n_first_track=infobuf[3];
2036 DriveStruct[d].n_last_track=infobuf[4];
2037 if (DriveStruct[d].first_session!=DriveStruct[d].last_session)
2038 {
2039 DriveStruct[d].f_multisession=1;
2040 DriveStruct[d].lba_multi=msf2blk(make32(make16(0,infobuf[5]),make16(infobuf[6],infobuf[7])));
2041 }
2042 #if 0
2043 if (DriveStruct[d].first_session!=DriveStruct[d].last_session)
2044 {
2045 if (DriveStruct[d].last_session<=20)
2046 zwanzig=DriveStruct[d].last_session+1;
2047 else zwanzig=20;
2048 for (count=DriveStruct[d].first_session;count<zwanzig;count++)
2049 {
2050 drvcmd[0]=CMD2_DISKINFO;
2051 drvcmd[1]=0x02;
2052 drvcmd[2]=0xAB;
2053 drvcmd[3]=count;
2054 response_count=8;
2055 flags_cmd_out=f_putcmd;
2056 i=cmd_out(7);
2057 if (i<0) return (i);
2058 DriveStruct[d].msf_multi_n[count]=make32(make16(0,infobuf[5]),make16(infobuf[6],infobuf[7]));
2059 }
2060 DriveStruct[d].diskstate_flags |= multisession_bit;
2061 }
2062 #endif
2063 drvcmd[0]=CMD2_DISKINFO;
2064 drvcmd[1]=0x02;
2065 drvcmd[2]=0xAA;
2066 drvcmd[3]=0xFF;
2067 response_count=5;
2068 flags_cmd_out=f_putcmd;
2069 i=cmd_out(7);
2070 if (i<0) return (i);
2071 DriveStruct[d].size_msf=make32(make16(0,infobuf[2]),make16(infobuf[3],infobuf[4]));
2072 DriveStruct[d].size_blk=msf2blk(DriveStruct[d].size_msf);
2073 }
2074 else
2075 {
2076 DriveStruct[d].n_first_track=infobuf[1];
2077 DriveStruct[d].n_last_track=infobuf[2];
2078 DriveStruct[d].size_msf=make32(make16(0,infobuf[3]),make16(infobuf[4],infobuf[5]));
2079 DriveStruct[d].size_blk=msf2blk(DriveStruct[d].size_msf);
2080 if (famL_drive) DriveStruct[d].CDsize_frm=DriveStruct[d].size_blk+1;
2081 }
2082 DriveStruct[d].diskstate_flags |= toc_bit;
2083 DPRINTF((DBG_TOC,"SBPCD: TocDesc: %02X %02X %02X %08X\n",
2084 DriveStruct[d].xa_byte,
2085 DriveStruct[d].n_first_track,
2086 DriveStruct[d].n_last_track,
2087 DriveStruct[d].size_msf));
2088 return (0);
2089 }
2090
2091 static int xx_ReadTocEntry(int num)
2092 {
2093 int i;
2094
2095 clr_cmdbuf();
2096 if (fam1_drive)
2097 {
2098 drvcmd[0]=CMD1_READTOC;
2099 response_count=8;
2100 flags_cmd_out=f_putcmd|f_ResponseStatus|f_obey_p_check;
2101 }
2102 else if (fam2_drive)
2103 {
2104
2105 drvcmd[0]=CMD2_DISKINFO;
2106 drvcmd[1]=0x02;
2107 response_count=5;
2108 flags_cmd_out=f_putcmd;
2109 }
2110 else if (fam0L_drive)
2111 {
2112 drvcmd[0]=CMD0_READTOC;
2113 drvcmd[1]=0x02;
2114 response_count=8;
2115 if(famL_drive)
2116 flags_cmd_out=f_putcmd;
2117 else
2118 flags_cmd_out=f_putcmd|f_getsta|f_ResponseStatus|f_obey_p_check;
2119 }
2120 else
2121 {
2122 return (-1);
2123 }
2124 drvcmd[2]=num;
2125 i=cmd_out(7);
2126 if (i<0) return (i);
2127 if (fam2_drive) i=0;
2128 else
2129 {
2130 DriveStruct[d].TocEnt_nixbyte=infobuf[0];
2131 i=1;
2132 }
2133 DriveStruct[d].TocEnt_ctl_adr=swap_nibbles(infobuf[i++]);
2134 if (!(fam2_drive))
2135 {
2136 DriveStruct[d].TocEnt_number=infobuf[i++];
2137 DriveStruct[d].TocEnt_format=infobuf[i];
2138 }
2139 if (fam1_drive) i=4;
2140 else if (fam0L_drive) i=5;
2141 else if (fam2_drive) i=2;
2142 DriveStruct[d].TocEnt_address=make32(make16(0,infobuf[i]),
2143 make16(infobuf[i+1],infobuf[i+2]));
2144 DPRINTF((DBG_TOC,"SBPCD: TocEntry: %02X %02X %02X %02X %08X\n",
2145 DriveStruct[d].TocEnt_nixbyte, DriveStruct[d].TocEnt_ctl_adr,
2146 DriveStruct[d].TocEnt_number, DriveStruct[d].TocEnt_format,
2147 DriveStruct[d].TocEnt_address));
2148 return (0);
2149 }
2150
2151 static int xx_ReadPacket(void)
2152 {
2153 int i;
2154
2155 clr_cmdbuf();
2156 drvcmd[0]=CMD0_PACKET;
2157 drvcmd[1]=response_count;
2158 if(famL_drive)
2159 flags_cmd_out=f_putcmd;
2160 else if (fam01_drive)
2161 flags_cmd_out=f_putcmd|f_getsta|f_ResponseStatus|f_obey_p_check;
2162 else
2163 {
2164 return (-1);
2165 }
2166 i=cmd_out(7);
2167 return (i);
2168 }
2169
2170 static int convert_UPC(u_char *p)
2171 {
2172 int i;
2173
2174 p++;
2175 if (fam0L_drive) p[13]=0;
2176 for (i=0;i<7;i++)
2177 {
2178 if (fam1_drive) DriveStruct[d].UPC_buf[i]=swap_nibbles(*p++);
2179 else if (fam0L_drive)
2180 {
2181 DriveStruct[d].UPC_buf[i]=((*p++)<<4)&0xFF;
2182 DriveStruct[d].UPC_buf[i] |= *p++;
2183 }
2184 else
2185 {
2186 return (-1);
2187 }
2188 }
2189 DriveStruct[d].UPC_buf[6] &= 0xF0;
2190 return (0);
2191 }
2192
2193 static int xx_ReadUPC(void)
2194 {
2195 int i;
2196 #if TEST_UPC
2197 int block, checksum;
2198 #endif TEST_UPC
2199
2200 DriveStruct[d].diskstate_flags &= ~upc_bit;
2201 #if TEST_UPC
2202 for (block=CD_BLOCK_OFFSET+1;block<CD_BLOCK_OFFSET+200;block++)
2203 {
2204 #endif TEST_UPC
2205 clr_cmdbuf();
2206 if (fam1_drive)
2207 {
2208 drvcmd[0]=CMD1_READ_UPC;
2209 #if TEST_UPC
2210 drvcmd[1]=(block>>16)&0xFF;
2211 drvcmd[2]=(block>>8)&0xFF;
2212 drvcmd[3]=block&0xFF;
2213 #endif TEST_UPC
2214 response_count=8;
2215 flags_cmd_out=f_putcmd|f_ResponseStatus|f_obey_p_check;
2216 }
2217 else if (fam0L_drive)
2218 {
2219 drvcmd[0]=CMD0_READ_UPC;
2220 #if TEST_UPC
2221 drvcmd[2]=(block>>16)&0xFF;
2222 drvcmd[3]=(block>>8)&0xFF;
2223 drvcmd[4]=block&0xFF;
2224 #endif TEST_UPC
2225 response_count=0;
2226 flags_cmd_out=f_putcmd|f_lopsta|f_getsta|f_ResponseStatus|f_obey_p_check|f_bit1;
2227 }
2228 else
2229 {
2230 return (-1);
2231 }
2232 i=cmd_out(7);
2233 if (i<0) return (i);
2234 if (fam0L_drive)
2235 {
2236 response_count=16;
2237 if (famL_drive) flags_cmd_out=f_putcmd;
2238 i=xx_ReadPacket();
2239 if (i<0) return (i);
2240 }
2241 #if TEST_UPC
2242 checksum=0;
2243 #endif TEST_UPC
2244 DPRINTF((DBG_UPC,"SBPCD: UPC info: "));
2245 for (i=0;i<(fam1_drive?8:16);i++)
2246 {
2247 #if TEST_UPC
2248 checksum |= infobuf[i];
2249 #endif TEST_UPC
2250 DPRINTF((DBG_UPC,"%02X ", infobuf[i]));
2251 }
2252 DPRINTF((DBG_UPC,"\n"));
2253 #if TEST_UPC
2254 if ((checksum&0x7F)!=0) break;
2255 }
2256 #endif TEST_UPC
2257 DriveStruct[d].UPC_ctl_adr=0;
2258 if (fam1_drive) i=0;
2259 else i=2;
2260 if ((infobuf[i]&0x80)!=0)
2261 {
2262 convert_UPC(&infobuf[i]);
2263 DriveStruct[d].UPC_ctl_adr = (DriveStruct[d].TocEnt_ctl_adr & 0xF0) | 0x02;
2264 }
2265
2266 DPRINTF((DBG_UPC,"SBPCD: UPC code: "));
2267 DPRINTF((DBG_UPC,"(%02X) ", DriveStruct[d].UPC_ctl_adr));
2268 for (i=0;i<7;i++)
2269 {
2270 DPRINTF((DBG_UPC,"%02X ", DriveStruct[d].UPC_buf[i]));
2271 }
2272 DPRINTF((DBG_UPC,"\n"));
2273
2274 DriveStruct[d].diskstate_flags |= upc_bit;
2275 return (0);
2276 }
2277
2278 static int yy_CheckMultiSession(void)
2279 {
2280 int i;
2281
2282 if (fam2_drive) return (0);
2283 DriveStruct[d].f_multisession=0;
2284 DriveStruct[d].lba_multi=0;
2285 if (fam0_drive) return (0);
2286 clr_cmdbuf();
2287 if (fam1_drive)
2288 {
2289 drvcmd[0]=CMD1_MULTISESS;
2290 response_count=6;
2291 flags_cmd_out=f_putcmd|f_ResponseStatus|f_obey_p_check;
2292 i=cmd_out(7);
2293 if (i<0) return (i);
2294 if ((infobuf[0]&0x80)!=0)
2295 {
2296 DriveStruct[d].f_multisession=1;
2297 DriveStruct[d].lba_multi=msf2blk(make32(make16(0,infobuf[1]),
2298 make16(infobuf[2],infobuf[3])));
2299 #if MULTISESSION_BY_DRIVER
2300 DriveStruct[d].last_redirect=19;
2301 #endif MULTISESSION_BY_DRIVER
2302 DPRINTF((DBG_MUL,"SBPCD: MultiSession CD detected: %02X %02X %02X %02X %02X %02X (%d)\n",
2303 infobuf[0], infobuf[1], infobuf[2],
2304 infobuf[3], infobuf[4], infobuf[5],
2305 DriveStruct[d].lba_multi));
2306 }
2307 }
2308 else if (famL_drive)
2309 {
2310 drvcmd[0]=CMDL_MULTISESS;
2311 drvcmd[1]=3;
2312 drvcmd[2]=1;
2313 response_count=8;
2314 flags_cmd_out=f_putcmd;
2315 i=cmd_out(7);
2316 if (i<0) return (i);
2317 DriveStruct[d].lba_multi=msf2blk(make32(make16(0,infobuf[5]),
2318 make16(infobuf[6],infobuf[7])));
2319 DPRINTF((DBG_MUL,"SBPCD: MultiSession Info: %02X %02X %02X %02X %02X %02X %02X %02X (%d)\n",
2320 infobuf[0], infobuf[1], infobuf[2], infobuf[3],
2321 infobuf[4], infobuf[5], infobuf[6], infobuf[7],
2322 DriveStruct[d].lba_multi));
2323 if (DriveStruct[d].lba_multi>200)
2324 {
2325 DPRINTF((DBG_MUL,"SBPCD: MultiSession base: %06X\n", DriveStruct[d].lba_multi));
2326 DriveStruct[d].f_multisession=1;
2327 #if MULTISESSION_BY_DRIVER
2328 DriveStruct[d].last_redirect=19;
2329 #endif MULTISESSION_BY_DRIVER
2330 }
2331 }
2332 else
2333 {
2334 return (-1);
2335 }
2336 return (0);
2337 }
2338
2339 #if FUTURE
2340 static int yy_SubChanInfo(int frame, int count, u_char *buffer)
2341
2342 {
2343 int i;
2344
2345 if (fam0L_drive) return (-ENOSYS);
2346 #if 0
2347 if (DriveStruct[d].audio_state!=audio_playing) return (-ENODATA);
2348 #endif
2349 clr_cmdbuf();
2350 drvcmd[0]=CMD1_SUBCHANINF;
2351 drvcmd[1]=(frame>>16)&0xFF;
2352 drvcmd[2]=(frame>>8)&0xFF;
2353 drvcmd[3]=frame&0xFF;
2354 drvcmd[5]=(count>>8)&0xFF;
2355 drvcmd[6]=count&0xFF;
2356 flags_cmd_out=f_putcmd|f_respo2|f_ResponseStatus|f_obey_p_check;
2357 cmd_type=READ_SC;
2358 DriveStruct[d].frame_size=CD_FRAMESIZE_SUB;
2359 i=cmd_out(7);
2360 return (i);
2361 }
2362 #endif FUTURE
2363
2364 static void check_datarate(void)
2365 {
2366 #ifdef CDMKE
2367 int i=0;
2368
2369 DPRINTF((DBG_IOX,"SBPCD: check_datarate entered.\n"));
2370 datarate=0;
2371 #if TEST_STI
2372 for (i=0;i<=1000;i++) printk(".");
2373 #endif
2374
2375 #if 0
2376 del_timer(&delay_timer);
2377 #endif
2378 delay_timer.expires = 110;
2379 timed_out=0;
2380 add_timer(&delay_timer);
2381 DPRINTF((DBG_TIM,"SBPCD: timer started (110).\n"));
2382 do
2383 {
2384 i=inb(CDi_status);
2385 datarate++;
2386 #if 00000
2387 if (datarate>0x0FFFFFFF) break;
2388 #endif 00000
2389 }
2390 while (!timed_out);
2391 #if 0
2392 del_timer(&delay_timer);
2393 #endif 0
2394 DPRINTF((DBG_TIM,"SBPCD: datarate: %d\n", datarate));
2395 if (datarate<65536) datarate=65536;
2396
2397 maxtim16=datarate*16;
2398 maxtim04=datarate*4;
2399 maxtim02=datarate*2;
2400 maxtim_8=datarate/32;
2401 #if LONG_TIMING
2402 maxtim_data=datarate/100;
2403 #else
2404 maxtim_data=datarate/300;
2405 #endif LONG_TIMING
2406 DPRINTF((DBG_TIM,"SBPCD: maxtim_8 %d, maxtim_data %d.\n",
2407 maxtim_8, maxtim_data));
2408 #endif CDMKE
2409 }
2410
2411 #if TEAC-X
2412
2413 static void teac_reset(int drv_id)
2414 {
2415 int i;
2416
2417 OUT(CDo_sel_i_d,0);
2418 OUT(CDo_enable,drv_id);
2419 OUT(CDo_command,CMDT_RESET);
2420 for (i=0;i<9;i++) OUT(CDo_command,0);
2421 DPRINTF((DBG_TEA,"SBPCD: TEAC soft reset.\n"));
2422 sbp_sleep(100);
2423 }
2424
2425 static int look_for_TEAC_drive(int drv_id)
2426 {
2427 int i;
2428 if (sbpro_type!=1) teac_reset(drv_id);
2429
2430 OUT(CDo_enable,drv_id);
2431 OUT(CDo_sel_i_d,0);
2432 i=inb(CDi_status);
2433 if (i&s_not_result_ready) return (-1);
2434 i=inb(CDi_info);
2435 DPRINTF((DBG_TEA,"SBPCD: TEAC look_for_drive: %02X.\n",i));
2436 if (i!=0x55) return (-2);
2437 return (1);
2438 }
2439
2440 static int find_teac_drives(void)
2441 {
2442 int i, j, found;
2443
2444 found=0;
2445 for (i=0;i<4;i++)
2446 {
2447 j=look_for_TEAC_drive(i);
2448 if (j<1) continue;
2449 found++;
2450 DPRINTF((DBG_TEA,"SBPCD: TEAC drive (id=%d) found.\n",i));
2451 }
2452 return (found);
2453 }
2454
2455 #endif TEAC-X
2456
2457
2458 #ifdef CD200
2459
2460 #if 0
2461
2462 static int xx_ReadVersion(int fam)
2463 {
2464 int i;
2465
2466 clr_cmdbuf();
2467 clear_response_buffer(13);
2468 if (fam==1)
2469 {
2470 drvcmd[0]=CMD0_READ_VER;
2471 response_count=13;
2472 i=do_cmd(f_putcmd|f_lopsta|f_getsta|f_ResponseStatus);
2473 }
2474 else if (fam==2)
2475 {
2476 drvcmd[0]=CMD2_READ_VER;
2477 response_count=12;
2478 i=do_cmd(f_putcmd);
2479 }
2480 else return (-1);
2481 return (i);
2482 }
2483
2484 static int yy_ReadError(int fam)
2485 {
2486 int i;
2487
2488 clr_cmdbuf();
2489 response_count=9;
2490 clr_respo_buf(9);
2491 if (fam==1)
2492 {
2493 drvcmd[0]=CMD0_READ_ERR;
2494 i=do_cmd(f_putcmd|f_lopsta|f_getsta|f_ResponseStatus);
2495 }
2496 else if (fam==2)
2497 {
2498 drvcmd[0]=CMD2_READ_ERR;
2499 i=do_cmd(f_putcmd);
2500 }
2501 else return (-1);
2502 return (i);
2503 }
2504 #endif
2505
2506 #endif CD200
2507
2508 static void ask_mail(void)
2509 {
2510 int i;
2511
2512 printk("SBPCD: please mail the following lines to emoenke@gwdg.de:\n");
2513 printk("SBPCD: infobuf = \"");
2514 for (i=0;i<12;i++) printk("%02X ",infobuf[i]);
2515 printk("\"\nSBPCD: infobuf = \"");
2516 for (i=0;i<12;i++) printk("%c",infobuf[i]);
2517 printk("\"\n");
2518 }
2519
2520 static int check_version(void)
2521 {
2522 int i, j;
2523 u_char lcs_firm[][4]={"A4F4","A E1"};
2524
2525 DPRINTF((DBG_INI,"SBPCD: check_version entered.\n"));
2526 DriveStruct[d].drv_type=0;
2527
2528 #if TEAC
2529
2530 clr_cmdbuf();
2531 drvcmd[0]=CMDT_READ_ERR;
2532 response_count=5;
2533 flags_cmd_out=f_putcmd;
2534 i=cmd_out(7);
2535 if (i<0) DPRINTF((DBG_INI,"SBPCD: CMDT_READERR returns %d (ok anyway).\n",i));
2536
2537 clr_cmdbuf();
2538 for (i=0;i<12;i++) infobuf[i]=0;
2539 if (sbpro_type==1) OUT(CDo_sel_i_d,0);
2540 response_count=12;
2541 drvcmd[0]=CMDT_READ_VER;
2542 drvcmd[4]=response_count;
2543 flags_cmd_out=f_putcmd;
2544 i=cmd_out(10);
2545 if (i<0) DPRINTF((DBG_INI,"SBPCD: CMDT_READ_VER returns %d\n",i));
2546 #else
2547
2548 clr_cmdbuf();
2549 drvcmd[0]=CMD2_READ_ERR;
2550 response_count=9;
2551 flags_cmd_out=f_putcmd;
2552 i=cmd_out(7);
2553 if (i<0) DPRINTF((DBG_INI,"SBPCD: CMD2_READERR returns %d (ok anyway).\n",i));
2554
2555 clr_cmdbuf();
2556 for (i=0;i<12;i++) infobuf[i]=0;
2557 if (sbpro_type==1) OUT(CDo_sel_i_d,0);
2558 #if 0
2559 OUT(CDo_reset,0);
2560 sbp_sleep(600);
2561 OUT(CDo_enable,DriveStruct[d].drv_sel);
2562 #endif
2563 drvcmd[0]=CMD2_READ_VER;
2564 response_count=12;
2565 flags_cmd_out=f_putcmd;
2566 i=cmd_out(7);
2567 if (i<0) DPRINTF((DBG_INI,"SBPCD: CMD2_READ_VER returns %d\n",i));
2568 #endif TEAC
2569 if (i>=0)
2570 {
2571 for (i=0, j=0;i<12;i++) j+=infobuf[i];
2572 if (j)
2573 {
2574 DPRINTF((DBG_ID,"SBPCD: infobuf = \""));
2575 for (i=0;i<12;i++) DPRINTF((DBG_ID,"%02X ",infobuf[i]));
2576 for (i=0;i<12;i++) DPRINTF((DBG_ID,"%c",infobuf[i]));
2577 DPRINTF((DBG_ID,"\"\n"));
2578 }
2579 for (i=0;i<5;i++) if (infobuf[i]!=family2[i]) break;
2580 if (i==5)
2581 {
2582 DriveStruct[d].drive_model[0]='C';
2583 DriveStruct[d].drive_model[1]='D';
2584 DriveStruct[d].drive_model[2]='2';
2585 DriveStruct[d].drive_model[3]='0';
2586 DriveStruct[d].drive_model[4]='0';
2587 DriveStruct[d].drive_model[5]=infobuf[i++];
2588 DriveStruct[d].drive_model[6]=infobuf[i++];
2589 DriveStruct[d].drive_model[7]=0;
2590 DriveStruct[d].drv_type=drv_fam2;
2591 }
2592 else
2593 {
2594 for (i=0;i<5;i++) if (infobuf[i]!=familyT[i]) break;
2595 if (i==5)
2596 {
2597 DriveStruct[d].drive_model[0]='C';
2598 DriveStruct[d].drive_model[1]='D';
2599 DriveStruct[d].drive_model[2]='-';
2600 DriveStruct[d].drive_model[3]='5';
2601 DriveStruct[d].drive_model[4]='5';
2602 DriveStruct[d].drive_model[5]='A';
2603 DriveStruct[d].drive_model[6]=infobuf[i++];
2604 DriveStruct[d].drive_model[7]=infobuf[i++];
2605 DriveStruct[d].drive_model[8]=0;
2606 }
2607 DriveStruct[d].drv_type=drv_famT;
2608 }
2609 }
2610
2611 if (!DriveStruct[d].drv_type)
2612 {
2613
2614
2615 clr_cmdbuf();
2616 drvcmd[0]=CMD0_READ_ERR;
2617 response_count=9;
2618 flags_cmd_out=f_putcmd;
2619 i=cmd_out(7);
2620 if (i<0) DPRINTF((DBG_INI,"SBPCD: CMD0_READERR returns %d (ok anyway).\n",i));
2621
2622 clr_cmdbuf();
2623 for (i=0;i<12;i++) infobuf[i]=0;
2624 drvcmd[0]=CMD0_READ_VER;
2625 response_count=12;
2626 flags_cmd_out=f_putcmd;
2627 i=cmd_out(7);
2628 if (i<0) DPRINTF((DBG_INI,"SBPCD: CMD0_READ_VER returns %d\n",i));
2629
2630 for (i=0, j=0;i<12;i++) j+=infobuf[i];
2631 if (j)
2632 {
2633 DPRINTF((DBG_ID,"SBPCD: infobuf = \""));
2634 for (i=0;i<12;i++) DPRINTF((DBG_ID,"%02X ",infobuf[i]));
2635 for (i=0;i<12;i++) DPRINTF((DBG_ID,"%c",infobuf[i]));
2636 DPRINTF((DBG_ID,"\"\n"));
2637 }
2638
2639 for (i=0;i<4;i++) if (infobuf[i]!=family1[i]) break;
2640 if (i==4)
2641 {
2642 DriveStruct[d].drive_model[0]='C';
2643 DriveStruct[d].drive_model[1]='R';
2644 DriveStruct[d].drive_model[2]='-';
2645 DriveStruct[d].drive_model[3]='5';
2646 DriveStruct[d].drive_model[4]=infobuf[i++];
2647 DriveStruct[d].drive_model[5]=infobuf[i++];
2648 DriveStruct[d].drive_model[6]=0;
2649 DriveStruct[d].drv_type=drv_fam1;
2650 }
2651 if (!DriveStruct[d].drv_type)
2652 {
2653 for (i=0;i<8;i++) if (infobuf[i]!=family0[i]) break;
2654 if (i==8)
2655 {
2656 DriveStruct[d].drive_model[0]='C';
2657 DriveStruct[d].drive_model[1]='R';
2658 DriveStruct[d].drive_model[2]='-';
2659 DriveStruct[d].drive_model[3]='5';
2660 DriveStruct[d].drive_model[4]='2';
2661 DriveStruct[d].drive_model[5]='x';
2662 DriveStruct[d].drive_model[6]=0;
2663 DriveStruct[d].drv_type=drv_fam0;
2664 }
2665 }
2666 if (!DriveStruct[d].drv_type)
2667 {
2668 for (i=0;i<8;i++) if (infobuf[i]!=familyL[i]) break;
2669 if (i==8)
2670 {
2671 for (j=0;j<8;j++)
2672 DriveStruct[d].drive_model[j]=infobuf[j];
2673 DriveStruct[d].drive_model[8]=0;
2674 DriveStruct[d].drv_type=drv_famL;
2675 }
2676 }
2677 }
2678 if (!DriveStruct[d].drv_type)
2679 {
2680 DPRINTF((DBG_INI,"SBPCD: check_version: error.\n"));
2681 return (-1);
2682 }
2683 for (j=0;j<4;j++) DriveStruct[d].firmware_version[j]=infobuf[i+j];
2684 if (famL_drive)
2685 {
2686 for (i=0;i<2;i++)
2687 {
2688 for (j=0;j<4;j++)
2689 if (DriveStruct[d].firmware_version[j]!=lcs_firm[i][j]) break;
2690 if (j==4) break;
2691 }
2692 if (j!=4) ask_mail();
2693 DriveStruct[d].drv_type=drv_260;
2694 }
2695 else if (famT_drive)
2696 {
2697 printk("\n\nSBPCD: possibly TEAC CD-55A present.\n");
2698 printk("SBPCD: support is not fulfilled yet - drive gets ignored.\n");
2699 ask_mail();
2700 DriveStruct[d].drv_type=0;
2701 return (-1);
2702 }
2703 else
2704 {
2705 j = (DriveStruct[d].firmware_version[0] & 0x0F) * 100 +
2706 (DriveStruct[d].firmware_version[2] & 0x0F) *10 +
2707 (DriveStruct[d].firmware_version[3] & 0x0F);
2708 if (fam0_drive)
2709 {
2710 if (j<200) DriveStruct[d].drv_type=drv_199;
2711 else if (j<201) DriveStruct[d].drv_type=drv_200;
2712 else if (j<210) DriveStruct[d].drv_type=drv_201;
2713 else if (j<211) DriveStruct[d].drv_type=drv_210;
2714 else if (j<300) DriveStruct[d].drv_type=drv_211;
2715 else if (j>=300) DriveStruct[d].drv_type=drv_300;
2716 }
2717 else if (fam1_drive)
2718 {
2719 if (j<100) DriveStruct[d].drv_type=drv_099;
2720 else DriveStruct[d].drv_type=drv_100;
2721 }
2722 else if (fam2_drive)
2723 {
2724 printk("\n\nSBPCD: new drive CD200 (%s)detected.\n",
2725 DriveStruct[d].firmware_version);
2726 printk("SBPCD: support is not fulfilled yet.\n");
2727 if (j!=101)
2728 ask_mail();
2729 }
2730 }
2731 DPRINTF((DBG_LCS,"SBPCD: drive type %02X\n",DriveStruct[d].drv_type));
2732 DPRINTF((DBG_INI,"SBPCD: check_version done.\n"));
2733 return (0);
2734 }
2735
2736 static int switch_drive(int i)
2737 {
2738 d=i;
2739 if (DriveStruct[d].drv_id!=-1)
2740 {
2741 OUT(CDo_enable,DriveStruct[d].drv_sel);
2742 DPRINTF((DBG_DID,"SBPCD: drive %d (ID=%d) activated.\n", i, DriveStruct[d].drv_id));
2743 return (0);
2744 }
2745 else return (-1);
2746 }
2747
2748
2749
2750
2751 static int check_drives(void)
2752 {
2753 int i, j;
2754 char *printk_header="";
2755
2756 DPRINTF((DBG_INI,"SBPCD: check_drives entered.\n"));
2757
2758 ndrives=0;
2759 for (j=0;j<NR_SBPCD;j++)
2760 {
2761 DriveStruct[ndrives].drv_id=j;
2762 if (sbpro_type==1) DriveStruct[ndrives].drv_sel=(j&0x01)<<1|(j&0x02)>>1;
2763 else DriveStruct[ndrives].drv_sel=j;
2764 switch_drive(ndrives);
2765 DPRINTF((DBG_INI,"SBPCD: check_drives: drive %d (ID=%d) activated.\n",ndrives,j));
2766 i=check_version();
2767 if (i<0) DPRINTF((DBG_INI,"SBPCD: check_version returns %d.\n",i));
2768 else
2769 {
2770 DriveStruct[d].drv_options=drv_pattern[j];
2771 if (fam0L_drive) DriveStruct[d].drv_options&=~(speed_auto|speed_300|speed_150);
2772 printk("%sDrive %d (ID=%d): %.9s (%.4s)\n", printk_header, d,
2773 DriveStruct[d].drv_id,
2774 DriveStruct[d].drive_model,
2775 DriveStruct[d].firmware_version);
2776 printk_header=" - ";
2777 ndrives++;
2778 }
2779
2780 }
2781 for (j=ndrives;j<NR_SBPCD;j++) DriveStruct[j].drv_id=-1;
2782 if (ndrives==0) return (-1);
2783 return (0);
2784 }
2785
2786 #if 000
2787 static void timewait(void)
2788 {
2789 int i;
2790 for (i=0; i<65500; i++);
2791 }
2792 #endif 000
2793
2794 #if FUTURE
2795
2796
2797
2798 static int obey_audio_state(u_char audio_state, u_char func,u_char subfunc)
2799 {
2800 switch (audio_state)
2801 {
2802 case aud_11:
2803 case audx11:
2804 switch (func)
2805 {
2806 case cmd_07:
2807 case cmd_0d:
2808 case cmd_0e:
2809 case cmd_0c:
2810 return (1);
2811 case cmd_03:
2812 switch (subfunc)
2813
2814 {
2815 case cxi_00:
2816 case cxi_06:
2817 case cxi_09:
2818 return (1);
2819 default:
2820 return (ERROR15);
2821 }
2822 return (1);
2823 default:
2824 return (ERROR15);
2825 }
2826 return (1);
2827 case aud_12:
2828 case audx12:
2829 return (1);
2830 default:
2831 return (2);
2832 }
2833 }
2834 #endif FUTURE
2835
2836
2837
2838
2839
2840
2841 static int check_allowed1(u_char func1, u_char func2)
2842 {
2843 #if 000
2844 if (func1==ioctl_o) return (0);
2845 if (func1==read_long) return (-1);
2846 if (func1==read_long_prefetch) return (-1);
2847 if (func1==seek) return (-1);
2848 if (func1==audio_play) return (-1);
2849 if (func1==audio_pause) return (-1);
2850 if (func1==audio_resume) return (-1);
2851 if (func1!=ioctl_i) return (0);
2852 if (func2==tell_SubQ_run_tot) return (-1);
2853 if (func2==tell_cdsize) return (-1);
2854 if (func2==tell_TocDescrip) return (-1);
2855 if (func2==tell_TocEntry) return (-1);
2856 if (func2==tell_subQ_info) return (-1);
2857 if (fam1_drive) if (func2==tell_SubChanInfo) return (-1);
2858 if (func2==tell_UPC) return (-1);
2859 #else
2860 return (0);
2861 #endif 000
2862 }
2863
2864 static int check_allowed2(u_char func1, u_char func2)
2865 {
2866 #if 000
2867 if (func1==read_long) return (-1);
2868 if (func1==read_long_prefetch) return (-1);
2869 if (func1==seek) return (-1);
2870 if (func1==audio_play) return (-1);
2871 if (func1!=ioctl_o) return (0);
2872 if (fam1_drive)
2873 {
2874 if (func2==EjectDisk) return (-1);
2875 if (func2==CloseTray) return (-1);
2876 }
2877 #else
2878 return (0);
2879 #endif 000
2880 }
2881
2882 static int check_allowed3(u_char func1, u_char func2)
2883 {
2884 #if 000
2885 if (func1==ioctl_i)
2886 {
2887 if (func2==tell_address) return (0);
2888 if (func2==tell_capabiliti) return (0);
2889 if (func2==tell_CD_changed) return (0);
2890 if (fam0L_drive) if (func2==tell_SubChanInfo) return (0);
2891 return (-1);
2892 }
2893 if (func1==ioctl_o)
2894 {
2895 if (func2==DriveReset) return (0);
2896 if (fam0L_drive)
2897 {
2898 if (func2==EjectDisk) return (0);
2899 if (func2==LockDoor) return (0);
2900 if (func2==CloseTray) return (0);
2901 }
2902 return (-1);
2903 }
2904 if (func1==flush_input) return (-1);
2905 if (func1==read_long) return (-1);
2906 if (func1==read_long_prefetch) return (-1);
2907 if (func1==seek) return (-1);
2908 if (func1==audio_play) return (-1);
2909 if (func1==audio_pause) return (-1);
2910 if (func1==audio_resume) return (-1);
2911 #else
2912 return (0);
2913 #endif 000
2914 }
2915
2916 static int seek_pos_audio_end(void)
2917 {
2918 int i;
2919
2920 i=msf2blk(DriveStruct[d].pos_audio_end)-1;
2921 if (i<0) return (-1);
2922 i=xx_Seek(i,0);
2923 return (i);
2924 }
2925
2926 static int ReadToC(void)
2927 {
2928 int i, j;
2929 DriveStruct[d].diskstate_flags &= ~toc_bit;
2930 DriveStruct[d].ored_ctl_adr=0;
2931 for (j=DriveStruct[d].n_first_track;j<=DriveStruct[d].n_last_track;j++)
2932 {
2933 i=xx_ReadTocEntry(j);
2934 if (i<0) return (i);
2935 DriveStruct[d].TocBuffer[j].nixbyte=DriveStruct[d].TocEnt_nixbyte;
2936 DriveStruct[d].TocBuffer[j].ctl_adr=DriveStruct[d].TocEnt_ctl_adr;
2937 DriveStruct[d].TocBuffer[j].number=DriveStruct[d].TocEnt_number;
2938 DriveStruct[d].TocBuffer[j].format=DriveStruct[d].TocEnt_format;
2939 DriveStruct[d].TocBuffer[j].address=DriveStruct[d].TocEnt_address;
2940 DriveStruct[d].ored_ctl_adr |= DriveStruct[d].TocEnt_ctl_adr;
2941 }
2942
2943 DriveStruct[d].TocBuffer[j].nixbyte=0;
2944 DriveStruct[d].TocBuffer[j].ctl_adr=0;
2945 DriveStruct[d].TocBuffer[j].number=CDROM_LEADOUT;
2946 DriveStruct[d].TocBuffer[j].format=0;
2947 DriveStruct[d].TocBuffer[j].address=DriveStruct[d].size_msf;
2948
2949 DriveStruct[d].diskstate_flags |= toc_bit;
2950 return (0);
2951 }
2952
2953 static int DiskInfo(void)
2954 {
2955 int i, j;
2956
2957 DriveStruct[d].mode=READ_M1;
2958
2959 #undef LOOP_COUNT
2960 #define LOOP_COUNT 20
2961
2962 for (j=1;j<LOOP_COUNT;j++)
2963 {
2964 i=SetSpeed();
2965 if (i<0)
2966 {
2967 DPRINTF((DBG_INF,"SBPCD: DiskInfo: SetSpeed returns %d\n", i));
2968 continue;
2969 }
2970 i=xx_ModeSense();
2971 if (i<0)
2972 {
2973 DPRINTF((DBG_INF,"SBPCD: DiskInfo: xx_ModeSense returns %d\n", i));
2974 continue;
2975 }
2976 i=xx_ReadCapacity();
2977 if (i>=0) break;
2978 DPRINTF((DBG_INF,"SBPCD: DiskInfo: ReadCapacity #%d returns %d\n", j, i));
2979 i=DriveReset();
2980 }
2981 if (j==LOOP_COUNT) return (-2);
2982
2983 i=xx_ReadTocDescr();
2984 if (i<0)
2985 {
2986 DPRINTF((DBG_INF,"SBPCD: DiskInfo: ReadTocDescr returns %d\n", i));
2987 return (i);
2988 }
2989 i=ReadToC();
2990 if (i<0)
2991 {
2992 DPRINTF((DBG_INF,"SBPCD: DiskInfo: ReadToC returns %d\n", i));
2993 return (i);
2994 }
2995 i=yy_CheckMultiSession();
2996 if (i<0)
2997 {
2998 DPRINTF((DBG_INF,"SBPCD: DiskInfo: yy_CheckMultiSession returns %d\n", i));
2999 return (i);
3000 }
3001 i=xx_ReadTocEntry(DriveStruct[d].n_first_track);
3002 if (i<0)
3003 {
3004 DPRINTF((DBG_INF,"SBPCD: DiskInfo: xx_ReadTocEntry(1) returns %d\n", i));
3005 return (i);
3006 }
3007 i=xx_ReadUPC();
3008 if (i<0)
3009 {
3010 DPRINTF((DBG_INF,"SBPCD: DiskInfo: xx_ReadUPC returns %d\n", i));
3011 return (i);
3012 }
3013 #ifdef XA_TEST2
3014 if ((fam0L_drive) && (DriveStruct[d].xa_byte==0x20))
3015 {
3016 xx_ModeSelect(CD_FRAMESIZE_XA);
3017 xx_ModeSense();
3018 }
3019 #endif XA_TEST2
3020
3021 return (0);
3022 }
3023
3024
3025
3026
3027
3028 static int prepare(u_char func, u_char subfunc)
3029 {
3030 int i;
3031
3032 if (fam0L_drive)
3033 {
3034 i=inb(CDi_status);
3035 if (i&s_attention) GetStatus();
3036 }
3037 else if (fam1_drive) GetStatus();
3038 else
3039 {
3040 }
3041 if (DriveStruct[d].CD_changed==0xFF)
3042 {
3043 #if MANY_SESSION
3044 #else
3045 DriveStruct[d].diskstate_flags=0;
3046 #endif MANY_SESSION
3047 DriveStruct[d].audio_state=0;
3048 if (!st_diskok)
3049 {
3050 i=check_allowed1(func,subfunc);
3051 if (i<0) return (-2);
3052 }
3053 else
3054 {
3055 i=check_allowed3(func,subfunc);
3056 if (i<0)
3057 {
3058 DriveStruct[d].CD_changed=1;
3059 return (-15);
3060 }
3061 }
3062 }
3063 else
3064 {
3065 if (!st_diskok)
3066 {
3067 #if MANY_SESSION
3068 #else
3069 DriveStruct[d].diskstate_flags=0;
3070 #endif MANY_SESSION
3071 DriveStruct[d].audio_state=0;
3072 i=check_allowed1(func,subfunc);
3073 if (i<0) return (-2);
3074 }
3075 else
3076 {
3077 if (st_busy)
3078 {
3079 if (DriveStruct[d].audio_state!=audio_pausing)
3080 {
3081 i=check_allowed2(func,subfunc);
3082 if (i<0) return (-2);
3083 }
3084 }
3085 else
3086 {
3087 if (DriveStruct[d].audio_state==audio_playing) seek_pos_audio_end();
3088 DriveStruct[d].audio_state=0;
3089 }
3090 if (!frame_size_valid)
3091 {
3092 i=DiskInfo();
3093 if (i<0)
3094 {
3095 #if MANY_SESSION
3096 #else
3097 DriveStruct[d].diskstate_flags=0;
3098 #endif MANY_SESSION
3099 DriveStruct[d].audio_state=0;
3100 i=check_allowed1(func,subfunc);
3101 if (i<0) return (-2);
3102 }
3103 }
3104 }
3105 }
3106 return (0);
3107 }
3108
3109 static int xx_PlayAudio(int pos_audio_start,int pos_audio_end)
3110 {
3111 int i, n;
3112
3113 if (DriveStruct[d].audio_state==audio_playing) return (-EINVAL);
3114 clr_cmdbuf();
3115 if (famL_drive)
3116 {
3117 drvcmd[0]=CMDL_PLAY;
3118 i=msf2blk(pos_audio_start);
3119 n=msf2blk(pos_audio_end)+1-i;
3120 drvcmd[1]=(i>>16)&0x00FF;
3121 drvcmd[2]=(i>>8)&0x00FF;
3122 drvcmd[3]=i&0x00FF;
3123 drvcmd[4]=(n>>16)&0x00FF;
3124 drvcmd[5]=(n>>8)&0x00FF;
3125 drvcmd[6]=n&0x00FF;
3126 flags_cmd_out = f_putcmd | f_respo2 | f_lopsta | f_getsta |
3127 f_ResponseStatus | f_obey_p_check | f_wait_if_busy;
3128 }
3129 else
3130 {
3131 if (fam1_drive)
3132 {
3133 drvcmd[0]=CMD1_PLAY_MSF;
3134 flags_cmd_out = f_putcmd | f_respo2 | f_ResponseStatus |
3135 f_obey_p_check | f_wait_if_busy;
3136 }
3137 else if (fam0_drive)
3138 {
3139 drvcmd[0]=CMD0_PLAY_MSF;
3140 flags_cmd_out = f_putcmd | f_respo2 | f_lopsta | f_getsta |
3141 f_ResponseStatus | f_obey_p_check | f_wait_if_busy;
3142 }
3143 else
3144 {
3145 }
3146 drvcmd[1]=(pos_audio_start>>16)&0x00FF;
3147 drvcmd[2]=(pos_audio_start>>8)&0x00FF;
3148 drvcmd[3]=pos_audio_start&0x00FF;
3149 drvcmd[4]=(pos_audio_end>>16)&0x00FF;
3150 drvcmd[5]=(pos_audio_end>>8)&0x00FF;
3151 drvcmd[6]=pos_audio_end&0x00FF;
3152 }
3153 response_count=0;
3154 i=cmd_out(7);
3155 return (i);
3156 }
3157
3158
3159
3160
3161
3162
3163 static int sbp_status(void)
3164 {
3165 int st;
3166
3167 st=ResponseStatus();
3168 if (st<0)
3169 {
3170 DPRINTF((DBG_INF,"SBPCD: sbp_status: timeout.\n"));
3171 return (0);
3172 }
3173
3174 if (!st_spinning) DPRINTF((DBG_SPI,"SBPCD: motor got off - ignoring.\n"));
3175
3176 if (st_check)
3177 {
3178 DPRINTF((DBG_INF,"SBPCD: st_check detected - retrying.\n"));
3179 return (0);
3180 }
3181 if (!st_door_closed)
3182 {
3183 DPRINTF((DBG_INF,"SBPCD: door is open - retrying.\n"));
3184 return (0);
3185 }
3186 if (!st_caddy_in)
3187 {
3188 DPRINTF((DBG_INF,"SBPCD: disk removed - retrying.\n"));
3189 return (0);
3190 }
3191 if (!st_diskok)
3192 {
3193 DPRINTF((DBG_INF,"SBPCD: !st_diskok detected - retrying.\n"));
3194 return (0);
3195 }
3196 if (st_busy)
3197 {
3198 DPRINTF((DBG_INF,"SBPCD: st_busy detected - retrying.\n"));
3199 return (0);
3200 }
3201 return (1);
3202 }
3203
3204
3205
3206
3207
3208
3209
3210 static int sbpcd_ioctl(struct inode *inode, struct file *file, u_int cmd,
3211 u_long arg)
3212 {
3213 int i, st;
3214
3215 DPRINTF((DBG_IO2,"SBPCD: ioctl(%d, 0x%08lX, 0x%08lX)\n",
3216 MINOR(inode->i_rdev), cmd, arg));
3217 if (!inode) return (-EINVAL);
3218 i=MINOR(inode->i_rdev);
3219 if ((i<0) || (i>=NR_SBPCD) || (DriveStruct[i].drv_id==-1))
3220 {
3221 printk("SBPCD: ioctl: bad device: %04X\n", inode->i_rdev);
3222 return (-ENXIO);
3223 }
3224 switch_drive(i);
3225
3226 st=GetStatus();
3227 if (st<0) return (-EIO);
3228
3229 if (!toc_valid)
3230 {
3231 i=DiskInfo();
3232 if (i<0) return (-EIO);
3233 }
3234
3235 DPRINTF((DBG_IO2,"SBPCD: ioctl: device %d, request %04X\n",i,cmd));
3236 switch (cmd)
3237 {
3238 case DDIOCSDBG:
3239 if (! suser()) return (-EPERM);
3240 i = verify_area(VERIFY_READ, (int *) arg, sizeof(int));
3241 if (i>=0) i=sbpcd_dbg_ioctl(arg,1);
3242 return (i);
3243
3244 case CDROMPAUSE:
3245 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMPAUSE entered.\n"));
3246
3247
3248
3249
3250 switch (DriveStruct[d].audio_state)
3251 {
3252 case audio_playing:
3253 if (famL_drive) i=xx_ReadSubQ();
3254 else i=xx_Pause_Resume(1);
3255 if (i<0) return (-EIO);
3256 if (famL_drive) i=xx_Pause_Resume(1);
3257 else i=xx_ReadSubQ();
3258 if (i<0) return (-EIO);
3259 DriveStruct[d].pos_audio_start=DriveStruct[d].SubQ_run_tot;
3260 DriveStruct[d].audio_state=audio_pausing;
3261 return (0);
3262 case audio_pausing:
3263 i=xx_Seek(DriveStruct[d].pos_audio_start,1);
3264 if (i<0) return (-EIO);
3265 return (0);
3266 default:
3267 return (-EINVAL);
3268 }
3269
3270 case CDROMRESUME:
3271 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMRESUME entered.\n"));
3272
3273
3274
3275 if (DriveStruct[d].audio_state!=audio_pausing) return -EINVAL;
3276 if (famL_drive)
3277 i=xx_PlayAudio(DriveStruct[d].pos_audio_start,
3278 DriveStruct[d].pos_audio_end);
3279 else i=xx_Pause_Resume(3);
3280 if (i<0) return (-EIO);
3281 DriveStruct[d].audio_state=audio_playing;
3282 return (0);
3283
3284 case CDROMPLAYMSF:
3285 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMPLAYMSF entered.\n"));
3286 if (DriveStruct[d].audio_state==audio_playing)
3287 {
3288 i=xx_Pause_Resume(1);
3289 if (i<0) return (-EIO);
3290 i=xx_ReadSubQ();
3291 if (i<0) return (-EIO);
3292 DriveStruct[d].pos_audio_start=DriveStruct[d].SubQ_run_tot;
3293 i=xx_Seek(DriveStruct[d].pos_audio_start,1);
3294 }
3295 st=verify_area(VERIFY_READ, (void *) arg, sizeof(struct cdrom_msf));
3296 if (st) return (st);
3297 memcpy_fromfs(&msf, (void *) arg, sizeof(struct cdrom_msf));
3298
3299 DriveStruct[d].pos_audio_start = (msf.cdmsf_min0<<16) |
3300 (msf.cdmsf_sec0<<8) |
3301 msf.cdmsf_frame0;
3302 DriveStruct[d].pos_audio_end = (msf.cdmsf_min1<<16) |
3303 (msf.cdmsf_sec1<<8) |
3304 msf.cdmsf_frame1;
3305 DPRINTF((DBG_IOX,"SBPCD: ioctl: CDROMPLAYMSF %08X %08X\n",
3306 DriveStruct[d].pos_audio_start,DriveStruct[d].pos_audio_end));
3307 i=xx_PlayAudio(DriveStruct[d].pos_audio_start,DriveStruct[d].pos_audio_end);
3308 DPRINTF((DBG_IOC,"SBPCD: ioctl: xx_PlayAudio returns %d\n",i));
3309 #if 0
3310 if (i<0) return (-EIO);
3311 #endif 0
3312 DriveStruct[d].audio_state=audio_playing;
3313 return (0);
3314
3315 case CDROMPLAYTRKIND:
3316 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMPLAYTRKIND entered.\n"));
3317 if (DriveStruct[d].audio_state==audio_playing)
3318 {
3319 DPRINTF((DBG_IOX,"SBPCD: CDROMPLAYTRKIND: already audio_playing.\n"));
3320 return (0);
3321 return (-EINVAL);
3322 }
3323 st=verify_area(VERIFY_READ,(void *) arg,sizeof(struct cdrom_ti));
3324 if (st<0)
3325 {
3326 DPRINTF((DBG_IOX,"SBPCD: CDROMPLAYTRKIND: verify_area error.\n"));
3327 return (st);
3328 }
3329 memcpy_fromfs(&ti,(void *) arg,sizeof(struct cdrom_ti));
3330 DPRINTF((DBG_IOX,"SBPCD: ioctl: trk0: %d, ind0: %d, trk1:%d, ind1:%d\n",
3331 ti.cdti_trk0,ti.cdti_ind0,ti.cdti_trk1,ti.cdti_ind1));
3332 if (ti.cdti_trk0<DriveStruct[d].n_first_track) return (-EINVAL);
3333 if (ti.cdti_trk0>DriveStruct[d].n_last_track) return (-EINVAL);
3334 if (ti.cdti_trk1<ti.cdti_trk0) ti.cdti_trk1=ti.cdti_trk0;
3335 if (ti.cdti_trk1>DriveStruct[d].n_last_track) ti.cdti_trk1=DriveStruct[d].n_last_track;
3336 DriveStruct[d].pos_audio_start=DriveStruct[d].TocBuffer[ti.cdti_trk0].address;
3337 DriveStruct[d].pos_audio_end=DriveStruct[d].TocBuffer[ti.cdti_trk1+1].address;
3338 i=xx_PlayAudio(DriveStruct[d].pos_audio_start,DriveStruct[d].pos_audio_end);
3339 #if 0
3340 if (i<0) return (-EIO);
3341 #endif 0
3342 DriveStruct[d].audio_state=audio_playing;
3343 return (0);
3344
3345 case CDROMREADTOCHDR:
3346 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMREADTOCHDR entered.\n"));
3347 tochdr.cdth_trk0=DriveStruct[d].n_first_track;
3348 tochdr.cdth_trk1=DriveStruct[d].n_last_track;
3349 st=verify_area(VERIFY_WRITE, (void *) arg, sizeof(struct cdrom_tochdr));
3350 if (st) return (st);
3351 memcpy_tofs((void *) arg, &tochdr, sizeof(struct cdrom_tochdr));
3352 return (0);
3353
3354 case CDROMREADTOCENTRY:
3355 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMREADTOCENTRY entered.\n"));
3356 st=verify_area(VERIFY_READ, (void *) arg, sizeof(struct cdrom_tocentry));
3357 if (st) return (st);
3358 memcpy_fromfs(&tocentry, (void *) arg, sizeof(struct cdrom_tocentry));
3359 i=tocentry.cdte_track;
3360 if (i==CDROM_LEADOUT) i=DriveStruct[d].n_last_track+1;
3361 else if (i<DriveStruct[d].n_first_track||i>DriveStruct[d].n_last_track) return (-EINVAL);
3362 tocentry.cdte_adr=DriveStruct[d].TocBuffer[i].ctl_adr&0x0F;
3363 tocentry.cdte_ctrl=(DriveStruct[d].TocBuffer[i].ctl_adr>>4)&0x0F;
3364 tocentry.cdte_datamode=DriveStruct[d].TocBuffer[i].format;
3365 if (tocentry.cdte_format==CDROM_MSF)
3366 { tocentry.cdte_addr.msf.minute=(DriveStruct[d].TocBuffer[i].address>>16)&0x00FF;
3367 tocentry.cdte_addr.msf.second=(DriveStruct[d].TocBuffer[i].address>>8)&0x00FF;
3368 tocentry.cdte_addr.msf.frame=DriveStruct[d].TocBuffer[i].address&0x00FF;
3369 }
3370 else if (tocentry.cdte_format==CDROM_LBA)
3371 tocentry.cdte_addr.lba=msf2blk(DriveStruct[d].TocBuffer[i].address);
3372 else return (-EINVAL);
3373 st=verify_area(VERIFY_WRITE,(void *) arg, sizeof(struct cdrom_tocentry));
3374 if (st) return (st);
3375 memcpy_tofs((void *) arg, &tocentry, sizeof(struct cdrom_tocentry));
3376 return (0);
3377
3378 case CDROMSTOP:
3379 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMSTOP entered.\n"));
3380 i=xx_Pause_Resume(1);
3381 DriveStruct[d].audio_state=0;
3382 return (0);
3383
3384 case CDROMSTART:
3385 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMSTART entered.\n"));
3386 xx_SpinUp();
3387 DriveStruct[d].audio_state=0;
3388 return (0);
3389
3390 case CDROMEJECT:
3391 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMEJECT entered.\n"));
3392 if (fam0_drive) return (0);
3393 do i=yy_LockDoor(0);
3394 while (i!=0);
3395 DriveStruct[d].open_count=0;
3396 i=yy_SpinDown();
3397 DPRINTF((DBG_IOX,"SBPCD: ioctl: yy_SpinDown returned %d.\n", i));
3398 if (i<0) return (-EIO);
3399 DriveStruct[d].CD_changed=0xFF;
3400 DriveStruct[d].diskstate_flags=0;
3401 DriveStruct[d].audio_state=0;
3402 return (0);
3403
3404 case CDROMEJECT_SW:
3405 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMEJECT_SW entered.\n"));
3406 if (fam0_drive) return (0);
3407 DriveStruct[d].f_eject=arg;
3408 return (0);
3409
3410 case CDROMVOLCTRL:
3411 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMVOLCTRL entered.\n"));
3412 st=verify_area(VERIFY_READ,(void *) arg,sizeof(volctrl));
3413 if (st) return (st);
3414 memcpy_fromfs(&volctrl,(char *) arg,sizeof(volctrl));
3415 DriveStruct[d].vol_chan0=0;
3416 DriveStruct[d].vol_ctrl0=volctrl.channel0;
3417 DriveStruct[d].vol_chan1=1;
3418 DriveStruct[d].vol_ctrl1=volctrl.channel1;
3419 i=xx_SetVolume();
3420 return (0);
3421
3422 case CDROMSUBCHNL:
3423 DPRINTF((DBG_IOS,"SBPCD: ioctl: CDROMSUBCHNL entered.\n"));
3424 if ((st_spinning)||(!subq_valid)) { i=xx_ReadSubQ();
3425 if (i<0) return (-EIO);
3426 }
3427 st=verify_area(VERIFY_WRITE, (void *) arg, sizeof(struct cdrom_subchnl));
3428 if (st) return (st);
3429 memcpy_fromfs(&SC, (void *) arg, sizeof(struct cdrom_subchnl));
3430 switch (DriveStruct[d].audio_state)
3431 {
3432 case audio_playing:
3433 SC.cdsc_audiostatus=CDROM_AUDIO_PLAY;
3434 break;
3435 case audio_pausing:
3436 SC.cdsc_audiostatus=CDROM_AUDIO_PAUSED;
3437 break;
3438 default:
3439 SC.cdsc_audiostatus=CDROM_AUDIO_NO_STATUS;
3440 break;
3441 }
3442 SC.cdsc_adr=DriveStruct[d].SubQ_ctl_adr;
3443 SC.cdsc_ctrl=DriveStruct[d].SubQ_ctl_adr>>4;
3444 SC.cdsc_trk=bcd2bin(DriveStruct[d].SubQ_trk);
3445 SC.cdsc_ind=bcd2bin(DriveStruct[d].SubQ_pnt_idx);
3446 if (SC.cdsc_format==CDROM_LBA)
3447 {
3448 SC.cdsc_absaddr.lba=msf2blk(DriveStruct[d].SubQ_run_tot);
3449 SC.cdsc_reladdr.lba=msf2blk(DriveStruct[d].SubQ_run_trk);
3450 }
3451 else
3452 {
3453 SC.cdsc_absaddr.msf.minute=(DriveStruct[d].SubQ_run_tot>>16)&0x00FF;
3454 SC.cdsc_absaddr.msf.second=(DriveStruct[d].SubQ_run_tot>>8)&0x00FF;
3455 SC.cdsc_absaddr.msf.frame=DriveStruct[d].SubQ_run_tot&0x00FF;
3456 SC.cdsc_reladdr.msf.minute=(DriveStruct[d].SubQ_run_trk>>16)&0x00FF;
3457 SC.cdsc_reladdr.msf.second=(DriveStruct[d].SubQ_run_trk>>8)&0x00FF;
3458 SC.cdsc_reladdr.msf.frame=DriveStruct[d].SubQ_run_trk&0x00FF;
3459 }
3460 memcpy_tofs((void *) arg, &SC, sizeof(struct cdrom_subchnl));
3461 DPRINTF((DBG_IOS,"SBPCD: CDROMSUBCHNL: %1X %02X %08X %08X %02X %02X %06X %06X\n",
3462 SC.cdsc_format,SC.cdsc_audiostatus,
3463 SC.cdsc_adr,SC.cdsc_ctrl,
3464 SC.cdsc_trk,SC.cdsc_ind,
3465 SC.cdsc_absaddr,SC.cdsc_reladdr));
3466 return (0);
3467
3468 case CDROMREADMODE1:
3469 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMREADMODE1 requested.\n"));
3470 xx_ModeSelect(CD_FRAMESIZE);
3471 xx_ModeSense();
3472 DriveStruct[d].mode=READ_M1;
3473 return (0);
3474
3475 case CDROMREADMODE2:
3476 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMREADMODE2 requested.\n"));
3477 xx_ModeSelect(CD_FRAMESIZE_XA);
3478 xx_ModeSense();
3479 DriveStruct[d].mode=READ_M2;
3480 return (0);
3481
3482 case CDROMREADAUDIO:
3483 {
3484 int i=0, j=0, frame, block;
3485 u_int try=0;
3486 u_long timeout;
3487 u_char *p;
3488 u_int data_tries = 0;
3489 u_int data_waits = 0;
3490 u_int data_retrying = 0;
3491 int status_tries;
3492 int error_flag;
3493
3494 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMREADAUDIO requested.\n"));
3495 if (fam0_drive) return (-EINVAL);
3496 if (famL_drive) return (-EINVAL);
3497 if (fam2_drive) return (-EINVAL);
3498 if (famT_drive) return (-EINVAL);
3499 if (DriveStruct[d].aud_buf==NULL) return (-EINVAL);
3500 i=verify_area(VERIFY_READ, (void *) arg, sizeof(struct cdrom_read_audio));
3501 if (i) return (i);
3502 memcpy_fromfs(&read_audio, (void *) arg, sizeof(struct cdrom_read_audio));
3503 if (read_audio.nframes>SBP_BUFFER_AUDIO_FRAMES) return (-EINVAL);
3504 i=verify_area(VERIFY_WRITE, read_audio.buf,
3505 read_audio.nframes*CD_FRAMESIZE_RAW);
3506 if (i) return (i);
3507
3508 if (read_audio.addr_format==CDROM_MSF)
3509 block=msf2lba(&read_audio.addr.msf.minute);
3510 else if (read_audio.addr_format==CDROM_LBA)
3511 block=read_audio.addr.lba;
3512 else return (-EINVAL);
3513 i=yy_SetSpeed(speed_150,0,0);
3514 if (i) DPRINTF((DBG_AUD,"SBPCD: read_audio: SetSpeed error %d\n", i));
3515 DPRINTF((DBG_AUD,"SBPCD: read_audio: lba: %d, msf: %06X\n",
3516 block, blk2msf(block)));
3517 DPRINTF((DBG_AUD,"SBPCD: read_audio: before xx_ReadStatus.\n"));
3518 while (busy_data) sbp_sleep(10);
3519 busy_audio=1;
3520 error_flag=0;
3521 for (data_tries=5; data_tries>0; data_tries--)
3522 {
3523 DPRINTF((DBG_AUD,"SBPCD: data_tries=%d ...\n", data_tries));
3524 DriveStruct[d].mode=READ_AU;
3525 xx_ModeSelect(CD_FRAMESIZE_RAW);
3526 xx_ModeSense();
3527 for (status_tries=3; status_tries > 0; status_tries--)
3528 {
3529 flags_cmd_out |= f_respo3;
3530 xx_ReadStatus();
3531 if (sbp_status() != 0) break;
3532 sbp_sleep(1);
3533 }
3534 if (status_tries == 0)
3535 {
3536 DPRINTF((DBG_AUD,"SBPCD: read_audio: sbp_status: failed after 3 tries.\n"));
3537 continue;
3538 }
3539 DPRINTF((DBG_AUD,"SBPCD: read_audio: sbp_status: ok.\n"));
3540
3541 flags_cmd_out = f_putcmd | f_respo2 | f_ResponseStatus | f_obey_p_check;
3542 if (fam0L_drive)
3543 {
3544 flags_cmd_out |= f_lopsta | f_getsta | f_bit1;
3545 cmd_type=READ_M2;
3546 drvcmd[0]=CMD0_READ_XA;
3547 drvcmd[1]=(block>>16)&0x000000ff;
3548 drvcmd[2]=(block>>8)&0x000000ff;
3549 drvcmd[3]=block&0x000000ff;
3550 drvcmd[4]=0;
3551 drvcmd[5]=read_audio.nframes;
3552 drvcmd[6]=0;
3553 }
3554 else if (fam1_drive)
3555 {
3556 drvcmd[0]=CMD1_READ;
3557 lba2msf(block,&drvcmd[1]);
3558 drvcmd[4]=0;
3559 drvcmd[5]=0;
3560 drvcmd[6]=read_audio.nframes;
3561 }
3562 else
3563 {
3564 }
3565 DPRINTF((DBG_AUD,"SBPCD: read_audio: before giving \"read\" command.\n"));
3566 for (i=0;i<7;i++) OUT(CDo_command,drvcmd[i]);
3567 sbp_sleep(0);
3568 DPRINTF((DBG_AUD,"SBPCD: read_audio: after giving \"read\" command.\n"));
3569 for (frame=1;frame<2 && !error_flag; frame++)
3570 {
3571 try=maxtim_data;
3572 for (timeout=jiffies+900; ; )
3573 {
3574 for ( ; try!=0;try--)
3575 {
3576 j=inb(CDi_status);
3577 if (!(j&s_not_data_ready)) break;
3578 if (!(j&s_not_result_ready)) break;
3579 if (fam0L_drive) if (j&s_attention) break;
3580 }
3581 if (try != 0 || timeout <= jiffies) break;
3582 if (data_retrying == 0) data_waits++;
3583 data_retrying = 1;
3584 sbp_sleep(1);
3585 try = 1;
3586 }
3587 if (try==0)
3588 {
3589 DPRINTF((DBG_INF,"SBPCD: read_audio: sbp_data: CDi_status timeout.\n"));
3590 error_flag++;
3591 break;
3592 }
3593 DPRINTF((DBG_AUD,"SBPCD: read_audio: sbp_data: CDi_status ok.\n"));
3594 if (j&s_not_data_ready)
3595 {
3596 printk("SBPCD: read_audio: sbp_data: DATA_READY timeout.\n");
3597 error_flag++;
3598 break;
3599 }
3600 DPRINTF((DBG_AUD,"SBPCD: read_audio: before reading data.\n"));
3601 error_flag=0;
3602 p = DriveStruct[d].aud_buf;
3603 if (sbpro_type==1) OUT(CDo_sel_i_d,1);
3604 #if 0
3605 cli();
3606 #endif
3607 READ_DATA(CDi_data, p, read_audio.nframes*CD_FRAMESIZE_RAW);
3608 #if 0
3609 sti();
3610 #endif
3611 if (sbpro_type==1) OUT(CDo_sel_i_d,0);
3612 data_retrying = 0;
3613 }
3614 DPRINTF((DBG_AUD,"SBPCD: read_audio: after reading data.\n"));
3615 if (error_flag)
3616 {
3617 DPRINTF((DBG_AUD,"SBPCD: read_audio: read aborted by drive\n"));
3618 #if 0000
3619 i=DriveReset();
3620 #else
3621 i=xx_ReadError();
3622 #endif 0000
3623 continue;
3624 }
3625 if (fam0L_drive)
3626 {
3627 i=maxtim_data;
3628 for (timeout=jiffies+900; timeout > jiffies; timeout--)
3629 {
3630 for ( ;i!=0;i--)
3631 {
3632 j=inb(CDi_status);
3633 if (!(j&s_not_data_ready)) break;
3634 if (!(j&s_not_result_ready)) break;
3635 if (j&s_attention) break;
3636 }
3637 if (i != 0 || timeout <= jiffies) break;
3638 sbp_sleep(0);
3639 i = 1;
3640 }
3641 if (i==0) { DPRINTF((DBG_AUD,"SBPCD: read_audio: STATUS TIMEOUT AFTER READ")); }
3642 if (!(j&s_attention))
3643 {
3644 DPRINTF((DBG_AUD,"SBPCD: read_audio: sbp_data: timeout waiting DRV_ATTN - retrying\n"));
3645 i=DriveReset();
3646 continue;
3647 }
3648 }
3649 do
3650 {
3651 if (fam0L_drive) xx_ReadStatus();
3652 i=ResponseStatus();
3653 if (i<0) { DPRINTF((DBG_AUD,
3654 "SBPCD: read_audio: xx_ReadStatus error after read: %02X\n",
3655 DriveStruct[d].status_byte));
3656 continue;
3657 }
3658 }
3659 while ((fam0L_drive)&&(!st_check)&&(!(i&p_success_old)));
3660 if (st_check)
3661 {
3662 i=xx_ReadError();
3663 DPRINTF((DBG_AUD,"SBPCD: read_audio: xx_ReadError was necessary after read: %02X\n",i));
3664 continue;
3665 }
3666 memcpy_tofs((u_char *) read_audio.buf,
3667 (u_char *) DriveStruct[d].aud_buf,
3668 read_audio.nframes*CD_FRAMESIZE_RAW);
3669 DPRINTF((DBG_AUD,"SBPCD: read_audio: memcpy_tofs done.\n"));
3670 break;
3671 }
3672 xx_ModeSelect(CD_FRAMESIZE);
3673 xx_ModeSense();
3674 DriveStruct[d].mode=READ_M1;
3675 busy_audio=0;
3676 if (data_tries == 0)
3677 {
3678 DPRINTF((DBG_AUD,"SBPCD: read_audio: failed after 5 tries.\n"));
3679 return (-8);
3680 }
3681 DPRINTF((DBG_AUD,"SBPCD: read_audio: successful return.\n"));
3682 return (0);
3683 }
3684
3685 case CDROMMULTISESSION:
3686 DPRINTF((DBG_IOC,"SBPCD: ioctl: CDROMMULTISESSION entered.\n"));
3687 st=verify_area(VERIFY_READ, (void *) arg, sizeof(struct cdrom_multisession));
3688 if (st) return (st);
3689 memcpy_fromfs(&ms_info, (void *) arg, sizeof(struct cdrom_multisession));
3690 if (ms_info.addr_format==CDROM_MSF)
3691 lba2msf(DriveStruct[d].lba_multi,&ms_info.addr.msf.minute);
3692 else if (ms_info.addr_format==CDROM_LBA)
3693 ms_info.addr.lba=DriveStruct[d].lba_multi;
3694 else return (-EINVAL);
3695 if (DriveStruct[d].f_multisession) ms_info.xa_flag=1;
3696 else ms_info.xa_flag=0;
3697 st=verify_area(VERIFY_WRITE,(void *) arg, sizeof(struct cdrom_multisession));
3698 if (st) return (st);
3699 memcpy_tofs((void *) arg, &ms_info, sizeof(struct cdrom_multisession));
3700 DPRINTF((DBG_MUL,"SBPCD: ioctl: CDROMMULTISESSION done (%d, %08X).\n",
3701 ms_info.xa_flag, ms_info.addr.lba));
3702 return (0);
3703
3704 case BLKRASET:
3705 if(!suser()) return -EACCES;
3706 if(!inode->i_rdev) return -EINVAL;
3707 if(arg > 0xff) return -EINVAL;
3708 read_ahead[MAJOR(inode->i_rdev)] = arg;
3709 return (0);
3710
3711 default:
3712 DPRINTF((DBG_IOC,"SBPCD: ioctl: unknown function request %04X\n", cmd));
3713 return (-EINVAL);
3714 }
3715 }
3716
3717
3718
3719
3720 static void sbp_transfer(void)
3721 {
3722 long offs;
3723
3724 while ( (CURRENT->nr_sectors > 0) &&
3725 (CURRENT->sector/4 >= DriveStruct[d].sbp_first_frame) &&
3726 (CURRENT->sector/4 <= DriveStruct[d].sbp_last_frame) )
3727 {
3728 offs = (CURRENT->sector - DriveStruct[d].sbp_first_frame * 4) * 512;
3729 memcpy(CURRENT->buffer, DriveStruct[d].sbp_buf + offs, 512);
3730 CURRENT->nr_sectors--;
3731 CURRENT->sector++;
3732 CURRENT->buffer += 512;
3733 }
3734 }
3735
3736
3737
3738
3739 static void DO_SBPCD_REQUEST(void)
3740 {
3741 u_int block;
3742 u_int nsect;
3743 int i, status_tries, data_tries;
3744
3745 request_loop:
3746
3747 sti();
3748
3749 if ((CURRENT==NULL)||(CURRENT->dev<0)) goto done;
3750 if (CURRENT -> sector == -1) goto done;
3751
3752 i = MINOR(CURRENT->dev);
3753 if ( (i<0) || (i>=NR_SBPCD) || (DriveStruct[i].drv_id==-1))
3754 {
3755 printk("SBPCD: do_request: bad device: %04X\n", CURRENT->dev);
3756 goto done;
3757 }
3758 switch_drive(i);
3759
3760 INIT_REQUEST;
3761 block = CURRENT->sector;
3762 nsect = CURRENT->nr_sectors;
3763 if (CURRENT->cmd != READ)
3764 {
3765 printk("SBPCD: bad cmd %d\n", CURRENT->cmd);
3766 end_request(0);
3767 goto request_loop;
3768 }
3769
3770 DPRINTF((DBG_BSZ,"SBPCD: read sector %d (%d sectors)\n", block, nsect));
3771 #if 0
3772 DPRINTF((DBG_MUL,"SBPCD: read LBA %d\n", block/4));
3773 #endif
3774
3775 sbp_transfer();
3776
3777 if (CURRENT->nr_sectors == 0)
3778 {
3779 end_request(1);
3780 goto request_loop;
3781 }
3782
3783 i=prepare(0,0);
3784 if (i!=0)
3785 DPRINTF((DBG_INF,"SBPCD: \"prepare\" tells error %d -- ignored\n", i));
3786
3787 while (busy_audio) sbp_sleep(100);
3788 busy_data=1;
3789
3790 if (!st_spinning) xx_SpinUp();
3791
3792 #ifdef XA_TEST1
3793 if ((fam0L_drive) && (DriveStruct[d].xa_byte==0x20))
3794 {
3795 xx_ModeSelect(CD_FRAMESIZE_XA);
3796 xx_ModeSense();
3797 }
3798 #endif XA_TEST1
3799
3800 for (data_tries=n_retries; data_tries > 0; data_tries--)
3801 {
3802 for (status_tries=3; status_tries > 0; status_tries--)
3803 {
3804 flags_cmd_out |= f_respo3;
3805 xx_ReadStatus();
3806 if (sbp_status() != 0) break;
3807 if (st_check) xx_ReadError();
3808 sbp_sleep(1);
3809 }
3810 if (status_tries == 0)
3811 {
3812 DPRINTF((DBG_INF,"SBPCD: sbp_status: failed after 3 tries\n"));
3813 break;
3814 }
3815
3816 sbp_read_cmd();
3817 sbp_sleep(0);
3818 if (sbp_data() != 0)
3819 {
3820 end_request(1);
3821 goto request_loop;
3822 }
3823 }
3824
3825 end_request(0);
3826 sbp_sleep(10);
3827 goto request_loop;
3828
3829 done:
3830 busy_data=0;
3831 return;
3832 }
3833
3834
3835
3836
3837
3838 static void sbp_read_cmd(void)
3839 {
3840 int i;
3841 int block;
3842
3843 DriveStruct[d].sbp_first_frame=DriveStruct[d].sbp_last_frame=-1;
3844 block=CURRENT->sector/4;
3845
3846 #if MULTISESSION_BY_DRIVER
3847 if (!fam0_drive)
3848 {
3849 #if MANY_SESSION
3850 DPRINTF((DBG_MUL,"SBPCD: read MSF %08X\n", blk2msf(block)));
3851 if (DriveStruct[d].f_multisession)
3852 {
3853 DPRINTF((DBG_MUL,"SBPCD: ManySession: use %08X for %08X (msf)\n",
3854 blk2msf(DriveStruct[d].lba_multi+block),
3855 blk2msf(block)));
3856 block=DriveStruct[d].lba_multi+block;
3857 }
3858 #else
3859 if ((block<=DriveStruct[d].last_redirect)
3860 && (DriveStruct[d].f_multisession))
3861 {
3862 DPRINTF((DBG_MUL,"SBPCD: MultiSession: use %08X for %08X (msf)\n",
3863 blk2msf(DriveStruct[d].lba_multi+block),
3864 blk2msf(block)));
3865 block=DriveStruct[d].lba_multi+block;
3866 }
3867 #endif MANY_SESSION
3868 }
3869 #endif MULTISESSION_BY_DRIVER
3870
3871 if (block+SBP_BUFFER_FRAMES <= DriveStruct[d].CDsize_frm)
3872 DriveStruct[d].sbp_read_frames = SBP_BUFFER_FRAMES;
3873 else
3874 {
3875 DriveStruct[d].sbp_read_frames=DriveStruct[d].CDsize_frm-block;
3876
3877 if (DriveStruct[d].sbp_read_frames < 1)
3878 {
3879 DPRINTF((DBG_INF,"SBPCD: requested frame %d, CD size %d ???\n",
3880 block, DriveStruct[d].CDsize_frm));
3881 DriveStruct[d].sbp_read_frames=1;
3882 }
3883 }
3884 DriveStruct[d].sbp_current = 0;
3885
3886 flags_cmd_out = f_putcmd |
3887 f_respo2 |
3888 f_ResponseStatus |
3889 f_obey_p_check;
3890
3891 if (fam0L_drive)
3892 {
3893 flags_cmd_out |= f_lopsta | f_getsta | f_bit1;
3894 if (DriveStruct[d].xa_byte==0x20)
3895 {
3896 cmd_type=READ_M2;
3897 drvcmd[0]=CMD0_READ_XA;
3898 drvcmd[1]=(block>>16)&0x000000ff;
3899 drvcmd[2]=(block>>8)&0x000000ff;
3900 drvcmd[3]=block&0x000000ff;
3901 drvcmd[4]=0;
3902 drvcmd[5]=DriveStruct[d].sbp_read_frames;
3903 drvcmd[6]=0;
3904 }
3905 else
3906 {
3907 drvcmd[0]=CMD0_READ;
3908
3909 if (DriveStruct[d].drv_type>=drv_201)
3910 {
3911 lba2msf(block,&drvcmd[1]);
3912 bin2bcdx(&drvcmd[1]);
3913 bin2bcdx(&drvcmd[2]);
3914 bin2bcdx(&drvcmd[3]);
3915 }
3916 else
3917 {
3918 drvcmd[1]=(block>>16)&0x000000ff;
3919 drvcmd[2]=(block>>8)&0x000000ff;
3920 drvcmd[3]=block&0x000000ff;
3921 }
3922 drvcmd[4]=0;
3923 drvcmd[5]=DriveStruct[d].sbp_read_frames;
3924 drvcmd[6]=(DriveStruct[d].drv_type<drv_201)?0:2;
3925 }
3926 }
3927 else if (fam1_drive)
3928 {
3929 drvcmd[0]=CMD1_READ;
3930 lba2msf(block,&drvcmd[1]);
3931 drvcmd[4]=0;
3932 drvcmd[5]=0;
3933 drvcmd[6]=DriveStruct[d].sbp_read_frames;
3934 }
3935 else if (fam2_drive)
3936 {
3937 drvcmd[0]=CMD2_READ;
3938 lba2msf(block,&drvcmd[1]);
3939 drvcmd[4]=0;
3940 drvcmd[5]=DriveStruct[d].sbp_read_frames;
3941 drvcmd[6]=0x02;
3942 }
3943 else
3944 {
3945 }
3946 SBPCD_CLI;
3947 for (i=0;i<7;i++) OUT(CDo_command,drvcmd[i]);
3948 SBPCD_STI;
3949
3950 return;
3951 }
3952
3953
3954
3955
3956
3957 static int sbp_data(void)
3958 {
3959 int i=0, j=0, frame;
3960 u_int try=0;
3961 u_long timeout;
3962 u_char *p;
3963 u_int data_tries = 0;
3964 u_int data_waits = 0;
3965 u_int data_retrying = 0;
3966 int error_flag;
3967 int xa_count;
3968 error_flag=0;
3969
3970 for (frame=DriveStruct[d].sbp_current;frame<DriveStruct[d].sbp_read_frames&&!error_flag; frame++)
3971 {
3972 SBPCD_CLI;
3973 try=maxtim_data;
3974 #if LONG_TIMING
3975 for (timeout=jiffies+900; ; )
3976 #else
3977 for (timeout=jiffies+ ( (famL_drive)? 300:100 ); ; )
3978 #endif
3979 {
3980 for ( ; try!=0;try--)
3981 {
3982 j=inb(CDi_status);
3983 if (!(j&s_not_data_ready)) break;
3984 if (!(j&s_not_result_ready)) break;
3985 if (fam0L_drive) if (j&s_attention) break;
3986 }
3987 if (try != 0 || timeout <= jiffies) break;
3988 if (data_retrying == 0) data_waits++;
3989 data_retrying = 1;
3990 sbp_sleep(1);
3991 try = 1;
3992 }
3993 if (try==0)
3994 {
3995 DPRINTF((DBG_INF,"SBPCD: sbp_data: CDi_status timeout.\n"));
3996 error_flag++;
3997 break;
3998 }
3999
4000 if (j&s_not_data_ready)
4001 {
4002 if ((DriveStruct[d].ored_ctl_adr&0x40)==0)
4003 printk("SBPCD: CD contains no data tracks.\n");
4004 else printk("SBPCD: sbp_data: DATA_READY timeout.\n");
4005 error_flag++;
4006 break;
4007 }
4008
4009 SBPCD_STI;
4010 error_flag=0;
4011 p = DriveStruct[d].sbp_buf + frame * CD_FRAMESIZE;
4012
4013 if (sbpro_type==1) OUT(CDo_sel_i_d,1);
4014 if (cmd_type==READ_M2) READ_DATA(CDi_data, xa_head_buf, CD_XA_HEAD);
4015 READ_DATA(CDi_data, p, CD_FRAMESIZE);
4016 if (cmd_type==READ_M2) READ_DATA(CDi_data, xa_tail_buf, CD_XA_TAIL);
4017 if (sbpro_type==1) OUT(CDo_sel_i_d,0);
4018 DriveStruct[d].sbp_current++;
4019 if (cmd_type==READ_M2)
4020 {
4021 DPRINTF((DBG_XA,"SBPCD: xa_head:"));
4022 for (xa_count=0;xa_count<CD_XA_HEAD;xa_count++)
4023 DPRINTF((DBG_XA," %02X", xa_head_buf[xa_count]));
4024 DPRINTF((DBG_XA,"\n"));
4025 }
4026 data_tries++;
4027 data_retrying = 0;
4028 if (data_tries >= 1000)
4029 {
4030 DPRINTF((DBG_INF,"SBPCD: info: %d waits in %d frames.\n",
4031 data_waits, data_tries));
4032 data_waits = data_tries = 0;
4033 }
4034 }
4035 SBPCD_STI;
4036
4037 if (error_flag)
4038 {
4039 DPRINTF((DBG_INF,"SBPCD: read aborted by drive\n"));
4040 #if 0
4041 i=DriveReset();
4042 #else
4043 i=xx_ReadError();
4044 #endif
4045 return (0);
4046 }
4047
4048 if (fam0L_drive)
4049 {
4050 SBPCD_CLI;
4051 i=maxtim_data;
4052 for (timeout=jiffies+100; timeout > jiffies; timeout--)
4053 {
4054 for ( ;i!=0;i--)
4055 {
4056 j=inb(CDi_status);
4057 if (!(j&s_not_data_ready)) break;
4058 if (!(j&s_not_result_ready)) break;
4059 if (j&s_attention) break;
4060 }
4061 if (i != 0 || timeout <= jiffies) break;
4062 sbp_sleep(0);
4063 i = 1;
4064 }
4065 if (i==0) { DPRINTF((DBG_INF,"SBPCD: STATUS TIMEOUT AFTER READ")); }
4066 if (!(j&s_attention))
4067 {
4068 DPRINTF((DBG_INF,"SBPCD: sbp_data: timeout waiting DRV_ATTN - retrying\n"));
4069 i=DriveReset();
4070 SBPCD_STI;
4071 return (0);
4072 }
4073 SBPCD_STI;
4074 }
4075
4076 do
4077 {
4078 if (fam0L_drive) xx_ReadStatus();
4079 i=ResponseStatus();
4080 if (i<0) { DPRINTF((DBG_INF,"SBPCD: xx_ReadStatus error after read: %02X\n",
4081 DriveStruct[d].status_byte));
4082 return (0);
4083 }
4084 }
4085 while ((fam0L_drive)&&(!st_check)&&(!(i&p_success_old)));
4086 if (st_check)
4087 {
4088 i=xx_ReadError();
4089 DPRINTF((DBG_INF,"SBPCD: xx_ReadError was necessary after read: %02X\n",i));
4090 return (0);
4091 }
4092
4093 DriveStruct[d].sbp_first_frame = CURRENT -> sector / 4;
4094 DriveStruct[d].sbp_last_frame = DriveStruct[d].sbp_first_frame + DriveStruct[d].sbp_read_frames - 1;
4095 sbp_transfer();
4096 return (1);
4097 }
4098
4099
4100
4101
4102
4103 static int sbpcd_open(struct inode *ip, struct file *fp)
4104 {
4105 int i;
4106
4107 i = MINOR(ip->i_rdev);
4108 if ((i<0) || (i>=NR_SBPCD) || (DriveStruct[i].drv_id==-1))
4109 {
4110 printk("SBPCD: open: bad device: %04X\n", ip->i_rdev);
4111 return (-ENXIO);
4112 }
4113 if (fp->f_mode & 2)
4114 return -EROFS;
4115
4116 switch_drive(i);
4117
4118 flags_cmd_out |= f_respo2;
4119 xx_ReadStatus();
4120 i=ResponseStatus();
4121 if (!st_door_closed)
4122 {
4123 yy_CloseTray();
4124 flags_cmd_out |= f_respo2;
4125 xx_ReadStatus();
4126 i=ResponseStatus();
4127 }
4128 if (!st_spinning)
4129 {
4130 xx_SpinUp();
4131 flags_cmd_out |= f_respo2;
4132 xx_ReadStatus();
4133 i=ResponseStatus();
4134 }
4135 if (i<0)
4136 {
4137 DPRINTF((DBG_INF,"SBPCD: sbpcd_open: xx_ReadStatus timed out\n"));
4138 return (-EIO);
4139 }
4140 DPRINTF((DBG_STA,"SBPCD: sbpcd_open: status %02X\n", DriveStruct[d].status_byte));
4141 if (!st_door_closed||!st_caddy_in)
4142 {
4143 printk("SBPCD: sbpcd_open: no disk in drive\n");
4144 #if JUKEBOX
4145 do
4146 i=yy_LockDoor(0);
4147 while (i!=0);
4148 if (!fam0_drive) yy_SpinDown();
4149 #endif
4150 return (-ENXIO);
4151 }
4152
4153
4154
4155 DPRINTF((DBG_LCK,"SBPCD: open_count: %d -> %d\n",
4156 DriveStruct[d].open_count,DriveStruct[d].open_count+1));
4157 if (++DriveStruct[d].open_count==1)
4158 {
4159 do
4160 i=yy_LockDoor(1);
4161 while (i!=0);
4162 }
4163 if (!st_spinning) xx_SpinUp();
4164
4165 i=DiskInfo();
4166 if ((DriveStruct[d].ored_ctl_adr&0x40)==0)
4167 DPRINTF((DBG_INF,"SBPCD: CD contains no data tracks.\n"));
4168 return (0);
4169 }
4170
4171
4172
4173
4174 static void sbpcd_release(struct inode * ip, struct file * file)
4175 {
4176 int i;
4177
4178 i = MINOR(ip->i_rdev);
4179 if ((i<0) || (i>=NR_SBPCD) || (DriveStruct[i].drv_id==-1))
4180 {
4181 printk("SBPCD: release: bad device: %04X\n", ip->i_rdev);
4182 return;
4183 }
4184 switch_drive(i);
4185
4186 DriveStruct[d].sbp_first_frame=DriveStruct[d].sbp_last_frame=-1;
4187 sync_dev(ip->i_rdev);
4188 invalidate_buffers(ip->i_rdev);
4189
4190
4191
4192
4193 DPRINTF((DBG_LCK,"SBPCD: open_count: %d -> %d\n",
4194 DriveStruct[d].open_count,DriveStruct[d].open_count-1));
4195 if (DriveStruct[d].open_count!=0)
4196 {
4197 if (--DriveStruct[d].open_count==0)
4198 {
4199 do
4200 i=yy_LockDoor(0);
4201 while (i!=0);
4202 if (DriveStruct[d].f_eject) yy_SpinDown();
4203 DriveStruct[d].diskstate_flags &= ~cd_size_bit;
4204 }
4205 }
4206 }
4207
4208
4209
4210
4211 static struct file_operations sbpcd_fops =
4212 {
4213 NULL,
4214 block_read,
4215 block_write,
4216 NULL,
4217 NULL,
4218 sbpcd_ioctl,
4219 NULL,
4220 sbpcd_open,
4221 sbpcd_release,
4222 NULL,
4223 NULL,
4224 sbpcd_chk_disk_change,
4225 NULL
4226 };
4227
4228
4229
4230
4231
4232
4233
4234
4235
4236
4237
4238
4239
4240
4241
4242
4243
4244
4245
4246
4247
4248 #if (SBPCD_ISSUE-1)
4249 static
4250 #endif
4251 void sbpcd_setup(char *s, int *p)
4252 {
4253 setup_done++;
4254 DPRINTF((DBG_INI,"SBPCD: sbpcd_setup called with %04X,%s\n",p[1], s));
4255 sbpro_type=0;
4256 if (!strcmp(s,str_sb)) sbpro_type=1;
4257 else if (!strcmp(s,str_sp)) sbpro_type=2;
4258 if (p[0]>0) sbpcd_ioaddr=p[1];
4259
4260 CDo_command=sbpcd_ioaddr;
4261 CDi_info=sbpcd_ioaddr;
4262 CDi_status=sbpcd_ioaddr+1;
4263 CDo_sel_i_d=sbpcd_ioaddr+1;
4264 CDo_reset=sbpcd_ioaddr+2;
4265 CDo_enable=sbpcd_ioaddr+3;
4266 if (sbpro_type==1)
4267 {
4268 MIXER_addr=sbpcd_ioaddr-0x10+0x04;
4269 MIXER_data=sbpcd_ioaddr-0x10+0x05;
4270 CDi_data=sbpcd_ioaddr;
4271 }
4272 else CDi_data=sbpcd_ioaddr+2;
4273 }
4274
4275
4276
4277
4278
4279
4280
4281
4282 static int config_spea(void)
4283 {
4284 int n_ports=0x10;
4285
4286 int irq_number=0;
4287 int dma_channel=0;
4288 int dack_polarity=0;
4289 int drq_polarity=0x40;
4290
4291 int i;
4292
4293 #define SPEA_REG_1 sbpcd_ioaddr+4
4294 #define SPEA_REG_2 sbpcd_ioaddr+5
4295
4296 OUT(SPEA_REG_1,0xFF);
4297 i=inb(SPEA_REG_1);
4298 if (i!=0x0F)
4299 {
4300 DPRINTF((DBG_SEQ,"SBPCD: no SPEA interface at %04X present.\n",
4301 sbpcd_ioaddr));
4302 return (-1);
4303 }
4304 OUT(SPEA_REG_1,0x04);
4305 OUT(SPEA_REG_2,0xC0);
4306
4307 OUT(SPEA_REG_1,0x05);
4308 OUT(SPEA_REG_2,0x10|drq_polarity|dack_polarity);
4309
4310 #if 1
4311 #define SPEA_PATTERN 0x80
4312 #else
4313 #define SPEA_PATTERN 0x00
4314 #endif
4315 OUT(SPEA_REG_1,0x06);
4316 OUT(SPEA_REG_2,dma_channel|irq_number|SPEA_PATTERN);
4317 OUT(SPEA_REG_2,dma_channel|irq_number|SPEA_PATTERN);
4318
4319 OUT(SPEA_REG_1,0x09);
4320 i=(inb(SPEA_REG_2)&0xCF)|n_ports;
4321 OUT(SPEA_REG_2,i);
4322
4323 sbpro_type = 0;
4324 DPRINTF((DBG_SEQ,"SBPCD: found SPEA interface at %04X.\n",
4325 sbpcd_ioaddr));
4326 return (0);
4327 }
4328
4329
4330
4331
4332 unsigned long SBPCD_INIT(u_long mem_start, u_long mem_end)
4333 {
4334 int i=0, j=0;
4335 int addr[2]={1, CDROM_PORT};
4336 int port_index;
4337
4338 sti();
4339
4340 DPRINTF((DBG_INF,"SBPCD version %s\n", VERSION));
4341
4342 if (!setup_done)
4343 {
4344 DPRINTF((DBG_INF,"SBPCD: Looking for Matsushita, Panasonic, CreativeLabs, IBM, Longshine, TEAC CD-ROM drives\n"));
4345 DPRINTF((DBG_WRN,"SBPCD: \n"));
4346 DPRINTF((DBG_WRN,"SBPCD: = = = = = = = = = = W A R N I N G = = = = = = = = = =\n"));
4347 DPRINTF((DBG_WRN,"SBPCD: Auto-Probing can cause a hang (f.e. touching an ethernet card).\n"));
4348 DPRINTF((DBG_WRN,"SBPCD: If that happens, you have to reboot and use the\n"));
4349 DPRINTF((DBG_WRN,"SBPCD: LILO (kernel) command line feature like:\n"));
4350 DPRINTF((DBG_WRN,"SBPCD: \n"));
4351 DPRINTF((DBG_WRN,"SBPCD: LILO boot: linux sbpcd=0x230,SoundBlaster\n"));
4352 DPRINTF((DBG_WRN,"SBPCD: or like:\n"));
4353 DPRINTF((DBG_WRN,"SBPCD: LILO boot: linux sbpcd=0x300,LaserMate\n"));
4354 DPRINTF((DBG_WRN,"SBPCD: or like:\n"));
4355 DPRINTF((DBG_WRN,"SBPCD: LILO boot: linux sbpcd=0x330,SPEA\n"));
4356 DPRINTF((DBG_WRN,"SBPCD: \n"));
4357 DPRINTF((DBG_WRN,"SBPCD: with your REAL address.\n"));
4358 DPRINTF((DBG_WRN,"SBPCD: = = = = = = = = = = END of WARNING = = = = = = = = = =\n"));
4359 DPRINTF((DBG_WRN,"SBPCD: \n"));
4360 }
4361 sbpcd_probe[0]=sbpcd_ioaddr;
4362 sbpcd_probe[1]=sbpro_type;
4363
4364 for (port_index=0;port_index<NUM_PROBE;port_index+=2)
4365 {
4366 addr[1]=sbpcd_probe[port_index];
4367 if (check_region(addr[1],4))
4368 {
4369 DPRINTF((DBG_INI,"SBPCD: check_region: %03X is not free.\n",addr[1]));
4370 continue;
4371 }
4372 if (sbpcd_probe[port_index+1]==0) type=str_lm;
4373 else if (sbpcd_probe[port_index+1]==1) type=str_sb;
4374 else type=str_sp;
4375 sbpcd_setup(type, addr);
4376 DPRINTF((DBG_INF,"SBPCD: Trying to detect a %s CD-ROM drive at 0x%X.\n", type, CDo_command));
4377 DPRINTF((DBG_INF,"SBPCD: - "));
4378 if (sbpcd_probe[port_index+1]==2)
4379 {
4380 i=config_spea();
4381 if (i<0)
4382 {
4383 DPRINTF((DBG_INF,"\n"));
4384 continue;
4385 }
4386 }
4387 #if TEAC
4388 i=find_teac_drives();
4389 if (i>0)
4390 {
4391 DPRINTF((DBG_INF,"SBPCD: found %d TEAC drives. A wonder.\n",i));
4392 DPRINTF((DBG_INF,"SBPCD: - "));
4393 }
4394 #endif TEAC
4395 i=check_drives();
4396 DPRINTF((DBG_INI,"SBPCD: check_drives done.\n"));
4397 if (i>=0) break;
4398 DPRINTF((DBG_INF,"\n"));
4399 }
4400
4401 if (ndrives==0)
4402 {
4403 printk("SBPCD: No drive found.\n");
4404 #if PRINTK_BUG
4405 sti();
4406 #endif
4407 goto init_done;
4408 }
4409
4410 if (port_index>0)
4411 {
4412 printk("SBPCD: You should configure sbpcd.h for your hardware.\n");
4413 #if PRINTK_BUG
4414 sti();
4415 #endif
4416 }
4417
4418 printk("SBPCD: %d %s CD-ROM drive(s) at 0x%04X.\n",
4419 ndrives, type, CDo_command);
4420 #if PRINTK_BUG
4421 sti();
4422 #endif
4423 check_datarate();
4424 DPRINTF((DBG_INI,"SBPCD: check_datarate done.\n"));
4425
4426 if (!famL_drive)
4427 {
4428 OUT(CDo_reset,0);
4429 sbp_sleep(100);
4430 }
4431
4432 for (j=0;j<NR_SBPCD;j++)
4433 {
4434 if (DriveStruct[j].drv_id==-1) continue;
4435 switch_drive(j);
4436 if (!famL_drive) xy_DriveReset();
4437 if (!st_spinning) xx_SpinUp();
4438 DriveStruct[d].sbp_first_frame = -1;
4439 DriveStruct[d].sbp_last_frame = -1;
4440 DriveStruct[d].sbp_read_frames = 0;
4441 DriveStruct[d].sbp_current = 0;
4442 DriveStruct[d].CD_changed=1;
4443 DriveStruct[d].frame_size=CD_FRAMESIZE;
4444 #if EJECT
4445 if (!fam0_drive) DriveStruct[d].f_eject=1;
4446 else DriveStruct[d].f_eject=0;
4447 #else
4448 DriveStruct[d].f_eject=0;
4449 #endif
4450
4451 xx_ReadStatus();
4452 i=ResponseStatus();
4453 if (i<0)
4454 DPRINTF((DBG_INF,"SBPCD: init: ResponseStatus returns %02X\n",i));
4455 else
4456 {
4457 if (st_check)
4458 {
4459 i=xx_ReadError();
4460 DPRINTF((DBG_INI,"SBPCD: init: xx_ReadError returns %d\n",i));
4461 }
4462 }
4463 DPRINTF((DBG_INI,"SBPCD: init: first GetStatus: %d\n",i));
4464 DPRINTF((DBG_LCS,"SBPCD: init: first GetStatus: error_byte=%d\n",
4465 DriveStruct[d].error_byte));
4466 if (DriveStruct[d].error_byte==aud_12)
4467 {
4468 do { i=GetStatus();
4469 DPRINTF((DBG_INI,"SBPCD: init: second GetStatus: %02X\n",i));
4470 DPRINTF((DBG_LCS,
4471 "SBPCD: init: second GetStatus: error_byte=%d\n",
4472 DriveStruct[d].error_byte));
4473 if (i<0) break;
4474 if (!st_caddy_in) break;
4475 }
4476 while (!st_diskok);
4477 }
4478 i=SetSpeed();
4479 if (i>=0) DriveStruct[d].CD_changed=1;
4480 }
4481
4482
4483
4484
4485
4486
4487 if ((sbpro_type==1) || (SOUND_BASE))
4488 {
4489 if (sbpro_type!=1)
4490 {
4491 MIXER_addr=SOUND_BASE+0x04;
4492 MIXER_data=SOUND_BASE+0x05;
4493 }
4494 OUT(MIXER_addr,MIXER_CD_Volume);
4495 OUT(MIXER_data,0xCC);
4496 }
4497
4498 if (register_blkdev(MAJOR_NR, major_name, &sbpcd_fops) != 0)
4499 {
4500 printk("SBPCD: Can't get MAJOR %d for Matsushita CDROM\n", MAJOR_NR);
4501 #if PRINTK_BUG
4502 sti();
4503 #endif
4504 goto init_done;
4505 }
4506 blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
4507 read_ahead[MAJOR_NR] = SBP_BUFFER_FRAMES * (CD_FRAMESIZE / 512);
4508
4509 request_region(CDo_command,4,major_name);
4510
4511 for (j=0;j<NR_SBPCD;j++)
4512 {
4513 if (DriveStruct[j].drv_id==-1) continue;
4514 switch_drive(j);
4515
4516
4517
4518 DriveStruct[j].sbp_buf=(u_char *)mem_start;
4519 mem_start += SBP_BUFFER_FRAMES*CD_FRAMESIZE;
4520 if ((fam1_drive) && (SBP_BUFFER_AUDIO_FRAMES>0))
4521 {
4522 DriveStruct[j].aud_buf=(u_char *)mem_start;
4523 mem_start += SBP_BUFFER_AUDIO_FRAMES*CD_FRAMESIZE_RAW;
4524 }
4525 else DriveStruct[j].aud_buf=NULL;
4526
4527
4528
4529 sbpcd_blocksizes[j]=CD_FRAMESIZE;
4530 }
4531 blksize_size[MAJOR_NR]=sbpcd_blocksizes;
4532
4533 init_done:
4534 #if !(SBPCD_ISSUE-1)
4535 #ifdef CONFIG_SBPCD2
4536 mem_start=sbpcd2_init(mem_start, mem_end);
4537 #endif
4538 #ifdef CONFIG_SBPCD3
4539 mem_start=sbpcd3_init(mem_start, mem_end);
4540 #endif
4541 #ifdef CONFIG_SBPCD4
4542 mem_start=sbpcd4_init(mem_start, mem_end);
4543 #endif
4544 #endif
4545 #if !(SBPCD_ISSUE-1)
4546 DPRINTF((DBG_INF,"SBPCD: init done.\n"));
4547 #endif
4548 return (mem_start);
4549 }
4550
4551
4552
4553
4554
4555
4556 static int sbpcd_chk_disk_change(dev_t full_dev)
4557 {
4558 int i, st;
4559
4560 DPRINTF((DBG_CHK,"SBPCD: media_check (%d) called\n", MINOR(full_dev)));
4561 return (0);
4562
4563 i=MINOR(full_dev);
4564 if ( (i<0) || (i>=NR_SBPCD) || (DriveStruct[i].drv_id==-1) )
4565 {
4566 printk("SBPCD: media_check: invalid device %04X.\n", full_dev);
4567 return (-1);
4568 }
4569
4570 switch_drive(i);
4571
4572 xx_ReadStatus();
4573 st=ResponseStatus();
4574 DPRINTF((DBG_CHK,"SBPCD: media_check: %02X\n",DriveStruct[d].status_byte));
4575 if (st<0)
4576 {
4577 DPRINTF((DBG_INF,"SBPCD: media_check: ResponseStatus error.\n"));
4578 return (1);
4579 }
4580 if (DriveStruct[d].CD_changed==0xFF) DPRINTF((DBG_CHK,"SBPCD: media_check: \"changed\" assumed.\n"));
4581 if (!st_spinning) DPRINTF((DBG_CHK,"SBPCD: media_check: motor off.\n"));
4582 if (!st_door_closed)
4583 {
4584 DPRINTF((DBG_CHK,"SBPCD: media_check: door open.\n"));
4585 DriveStruct[d].CD_changed=0xFF;
4586 }
4587 if (!st_caddy_in)
4588 {
4589 DPRINTF((DBG_CHK,"SBPCD: media_check: no disk in drive.\n"));
4590 DriveStruct[d].CD_changed=0xFF;
4591 }
4592 if (!st_diskok) DPRINTF((DBG_CHK,"SBPCD: media_check: !st_diskok.\n"));
4593
4594 #if 0000
4595 if (DriveStruct[d].CD_changed==0xFF)
4596 {
4597 DriveStruct[d].CD_changed=1;
4598 return (1);
4599 }
4600 #endif 0000
4601
4602 if (!st_diskok) return (1);
4603 if (!st_caddy_in) return (1);
4604 if (!st_door_closed) return (1);
4605 return (0);
4606 }
4607