This source file includes following definitions.
- scd_disk_change
- enable_interrupts
- disable_interrupts
- sony_sleep
- is_attention
- is_busy
- is_data_ready
- is_data_requested
- is_result_ready
- is_param_write_rdy
- is_result_reg_not_empty
- reset_drive
- clear_attention
- clear_result_ready
- clear_data_ready
- clear_param_reg
- read_status_register
- read_result_register
- read_data_register
- write_param
- write_cmd
- cdu31a_interrupt
- set_drive_params
- restart_on_error
- write_params
- get_result
- do_sony_cd_cmd
- handle_sony_cd_attention
- int_to_bcd
- bcd_to_int
- log_to_msf
- msf_to_log
- size_to_buf
- start_request
- abort_read
- handle_abort_timeout
- input_data
- read_data_block
- do_cdu31a_request
- mcovlp
- sony_get_toc
- find_track
- read_subcode
- sony_get_subchnl_info
- read_audio_data
- read_audio
- do_sony_cd_cmd_chk
- scd_ioctl
- scd_open
- scd_release
- get_drive_configuration
- cdu31a_setup
- cdu31a_init
- cleanup_module
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 #include <linux/major.h>
164 #include <linux/config.h>
165
166 #ifdef MODULE
167 # include <linux/module.h>
168 # include <linux/version.h>
169 # ifndef CONFIG_MODVERSIONS
170 char kernel_version[]= UTS_RELEASE;
171 # endif
172 #endif
173
174 #include <linux/errno.h>
175 #include <linux/signal.h>
176 #include <linux/sched.h>
177 #include <linux/timer.h>
178 #include <linux/fs.h>
179 #include <linux/kernel.h>
180 #include <linux/hdreg.h>
181 #include <linux/genhd.h>
182 #include <linux/ioport.h>
183 #include <linux/string.h>
184 #include <linux/malloc.h>
185
186 #include <asm/system.h>
187 #include <asm/io.h>
188 #include <asm/segment.h>
189 #include <asm/dma.h>
190
191 #include <linux/cdrom.h>
192 #include <linux/cdu31a.h>
193
194 #define MAJOR_NR CDU31A_CDROM_MAJOR
195 #include "blk.h"
196
197 #define DEBUG 0
198
199 #define CDU31A_READAHEAD 128
200 #define CDU31A_MAX_CONSECUTIVE_ATTENTIONS 10
201
202
203 #undef SONY_POLL_EACH_BYTE
204
205
206
207
208
209
210 static struct
211 {
212 unsigned short base;
213 short int_num;
214
215 } cdu31a_addresses[] =
216 {
217 #if 0
218
219 { 0x340, 0 },
220 { 0x1f88, 0 },
221 { 0x230, 0 },
222 { 0x360, 0 },
223 { 0x320, 0 },
224 { 0x330, 0 },
225 { 0x634, 0 },
226 { 0x654, 0 },
227 #endif
228 { 0 }
229 };
230
231 static int handle_sony_cd_attention(void);
232 static int read_subcode(void);
233 static void sony_get_toc(void);
234 static int scd_open(struct inode *inode, struct file *filp);
235 static void do_sony_cd_cmd(unsigned char cmd,
236 unsigned char *params,
237 unsigned int num_params,
238 unsigned char *result_buffer,
239 unsigned int *result_size);
240 static void size_to_buf(unsigned int size,
241 unsigned char *buf);
242
243
244 static unsigned int sony_next_block;
245 static unsigned int sony_blocks_left = 0;
246
247
248
249
250
251 static unsigned short cdu31a_port = 0;
252
253
254
255
256
257 static volatile unsigned short sony_cd_cmd_reg;
258 static volatile unsigned short sony_cd_param_reg;
259 static volatile unsigned short sony_cd_write_reg;
260 static volatile unsigned short sony_cd_control_reg;
261 static volatile unsigned short sony_cd_status_reg;
262 static volatile unsigned short sony_cd_result_reg;
263 static volatile unsigned short sony_cd_read_reg;
264 static volatile unsigned short sony_cd_fifost_reg;
265
266
267 static int sony_spun_up = 0;
268
269 static int sony_xa_mode = 0;
270
271
272 static int sony_raw_data_mode = 1;
273
274
275 static unsigned int sony_usage = 0;
276
277
278 static int sony_pas_init = 0;
279
280
281 static struct s_sony_session_toc sony_toc;
282
283
284
285 static int sony_toc_read = 0;
286
287
288 static struct s_sony_subcode last_sony_subcode;
289
290
291 static volatile int sony_inuse = 0;
292
293
294 static struct wait_queue * sony_wait = NULL;
295
296 static struct task_struct *has_cd_task = NULL;
297
298
299
300 static int is_double_speed = 0;
301
302
303
304
305
306 static volatile int sony_audio_status = CDROM_AUDIO_NO_STATUS;
307
308
309
310
311
312
313
314
315 static unsigned volatile char cur_pos_msf[3] = { 0, 0, 0 };
316 static unsigned volatile char final_pos_msf[3] = { 0, 0, 0 };
317
318
319 static int cdu31a_irq = 0;
320
321
322
323 static struct wait_queue *cdu31a_irq_wait = NULL;
324
325 static int curr_control_reg = 0;
326
327
328
329
330 static char disk_changed;
331
332
333
334
335 static char readahead_buffer[CD_FRAMESIZE_RAW];
336 static int readahead_dataleft = 0;
337 static int readahead_bad = 0;
338
339
340
341
342 static struct timer_list cdu31a_abort_timer;
343
344
345
346
347 static int abort_read_started = 0;
348
349
350
351
352
353
354 static int
355 scd_disk_change(dev_t full_dev)
356 {
357 int retval;
358
359 retval = disk_changed;
360 disk_changed = 0;
361
362 return retval;
363 }
364
365 static inline void
366 enable_interrupts(void)
367 {
368 curr_control_reg |= ( SONY_ATTN_INT_EN_BIT
369 | SONY_RES_RDY_INT_EN_BIT
370 | SONY_DATA_RDY_INT_EN_BIT);
371 outb(curr_control_reg, sony_cd_control_reg);
372 }
373
374 static inline void
375 disable_interrupts(void)
376 {
377 curr_control_reg &= ~( SONY_ATTN_INT_EN_BIT
378 | SONY_RES_RDY_INT_EN_BIT
379 | SONY_DATA_RDY_INT_EN_BIT);
380 outb(curr_control_reg, sony_cd_control_reg);
381 }
382
383
384
385
386
387 static inline void
388 sony_sleep(void)
389 {
390 unsigned long flags;
391
392 if (cdu31a_irq <= 0)
393 {
394 current->state = TASK_INTERRUPTIBLE;
395 current->timeout = jiffies;
396 schedule();
397 }
398 else
399 {
400 save_flags(flags);
401 cli();
402 enable_interrupts();
403 interruptible_sleep_on(&cdu31a_irq_wait);
404 restore_flags(flags);
405 }
406 }
407
408
409
410
411
412
413 static inline int
414 is_attention(void)
415 {
416 return((inb(sony_cd_status_reg) & SONY_ATTN_BIT) != 0);
417 }
418
419 static inline int
420 is_busy(void)
421 {
422 return((inb(sony_cd_status_reg) & SONY_BUSY_BIT) != 0);
423 }
424
425 static inline int
426 is_data_ready(void)
427 {
428 return((inb(sony_cd_status_reg) & SONY_DATA_RDY_BIT) != 0);
429 }
430
431 static inline int
432 is_data_requested(void)
433 {
434 return((inb(sony_cd_status_reg) & SONY_DATA_REQUEST_BIT) != 0);
435 }
436
437 static inline int
438 is_result_ready(void)
439 {
440 return((inb(sony_cd_status_reg) & SONY_RES_RDY_BIT) != 0);
441 }
442
443 static inline int
444 is_param_write_rdy(void)
445 {
446 return((inb(sony_cd_fifost_reg) & SONY_PARAM_WRITE_RDY_BIT) != 0);
447 }
448
449 static inline int
450 is_result_reg_not_empty(void)
451 {
452 return((inb(sony_cd_fifost_reg) & SONY_RES_REG_NOT_EMP_BIT) != 0);
453 }
454
455 static inline void
456 reset_drive(void)
457 {
458 curr_control_reg = 0;
459 outb(SONY_DRIVE_RESET_BIT, sony_cd_control_reg);
460 }
461
462 static inline void
463 clear_attention(void)
464 {
465 outb(curr_control_reg | SONY_ATTN_CLR_BIT, sony_cd_control_reg);
466 }
467
468 static inline void
469 clear_result_ready(void)
470 {
471 outb(curr_control_reg | SONY_RES_RDY_CLR_BIT, sony_cd_control_reg);
472 }
473
474 static inline void
475 clear_data_ready(void)
476 {
477 outb(curr_control_reg | SONY_DATA_RDY_CLR_BIT, sony_cd_control_reg);
478 }
479
480 static inline void
481 clear_param_reg(void)
482 {
483 outb(curr_control_reg | SONY_PARAM_CLR_BIT, sony_cd_control_reg);
484 }
485
486 static inline unsigned char
487 read_status_register(void)
488 {
489 return(inb(sony_cd_status_reg));
490 }
491
492 static inline unsigned char
493 read_result_register(void)
494 {
495 return(inb(sony_cd_result_reg));
496 }
497
498 static inline unsigned char
499 read_data_register(void)
500 {
501 return(inb(sony_cd_read_reg));
502 }
503
504 static inline void
505 write_param(unsigned char param)
506 {
507 outb(param, sony_cd_param_reg);
508 }
509
510 static inline void
511 write_cmd(unsigned char cmd)
512 {
513 outb(curr_control_reg | SONY_RES_RDY_INT_EN_BIT, sony_cd_control_reg);
514 outb(cmd, sony_cd_cmd_reg);
515 }
516
517 static void
518 cdu31a_interrupt(int irq, struct pt_regs *regs)
519 {
520 unsigned char val;
521
522 if (abort_read_started)
523 {
524
525
526
527
528 while (is_result_reg_not_empty())
529 {
530 val = read_result_register();
531 }
532 clear_data_ready();
533 clear_result_ready();
534
535
536 while (is_data_requested())
537 {
538 val = read_data_register();
539 }
540 abort_read_started = 0;
541
542
543 if (cdu31a_irq_wait != NULL)
544 {
545 disable_interrupts();
546 wake_up(&cdu31a_irq_wait);
547 }
548 }
549 else if (cdu31a_irq_wait != NULL)
550 {
551 disable_interrupts();
552 wake_up(&cdu31a_irq_wait);
553 }
554 else
555 {
556 disable_interrupts();
557 printk("CDU31A: Got an interrupt but nothing was waiting\n");
558 }
559 }
560
561
562
563
564
565 static void
566 set_drive_params(void)
567 {
568 unsigned char res_reg[12];
569 unsigned int res_size;
570 unsigned char params[3];
571
572
573 params[0] = SONY_SD_AUTO_SPIN_DOWN_TIME;
574 params[1] = 0x00;
575 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
576 params,
577 2,
578 res_reg,
579 &res_size);
580 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20))
581 {
582 printk(" Unable to set spin-down time: 0x%2.2x\n", res_reg[1]);
583 }
584
585 params[0] = SONY_SD_MECH_CONTROL;
586 params[1] = 0x03;
587 if (is_double_speed)
588 {
589 params[1] |= 0x04;
590 }
591 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
592 params,
593 2,
594 res_reg,
595 &res_size);
596 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20))
597 {
598 printk(" Unable to set mechanical parameters: 0x%2.2x\n", res_reg[1]);
599 }
600 }
601
602
603
604
605 static void
606 restart_on_error(void)
607 {
608 unsigned char res_reg[12];
609 unsigned int res_size;
610 unsigned int retry_count;
611
612
613 printk("cdu31a: Resetting drive on error\n");
614 reset_drive();
615 retry_count = jiffies + SONY_RESET_TIMEOUT;
616 while ((retry_count > jiffies) && (!is_attention()))
617 {
618 sony_sleep();
619 }
620 set_drive_params();
621 do_sony_cd_cmd(SONY_SPIN_UP_CMD, NULL, 0, res_reg, &res_size);
622 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20))
623 {
624 printk("cdu31a: Unable to spin up drive: 0x%2.2x\n", res_reg[1]);
625 }
626
627 current->state = TASK_INTERRUPTIBLE;
628 current->timeout = jiffies + 200;
629 schedule();
630
631 do_sony_cd_cmd(SONY_READ_TOC_CMD, NULL, 0, res_reg, &res_size);
632 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20))
633 {
634 printk("cdu31a: Unable to read TOC: 0x%2.2x\n", res_reg[1]);
635 }
636 }
637
638
639
640
641
642 static int
643 write_params(unsigned char *params,
644 int num_params)
645 {
646 unsigned int retry_count;
647
648
649 retry_count = SONY_READY_RETRIES;
650 while ((retry_count > 0) && (!is_param_write_rdy()))
651 {
652 retry_count--;
653 }
654 if (!is_param_write_rdy())
655 {
656 return -EIO;
657 }
658
659 while (num_params > 0)
660 {
661 write_param(*params);
662 params++;
663 num_params--;
664 }
665
666 return 0;
667 }
668
669
670
671
672
673
674
675
676 static void
677 get_result(unsigned char *result_buffer,
678 unsigned int *result_size)
679 {
680 unsigned char a, b;
681 int i;
682 unsigned int retry_count;
683
684
685 while (handle_sony_cd_attention())
686 ;
687
688 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
689 while ((retry_count > jiffies) && (is_busy() || (!(is_result_ready()))))
690 {
691 sony_sleep();
692
693 while (handle_sony_cd_attention())
694 ;
695 }
696 if (is_busy() || (!(is_result_ready())))
697 {
698 #if DEBUG
699 printk("CDU31A timeout out %d\n", __LINE__);
700 #endif
701 result_buffer[0] = 0x20;
702 result_buffer[1] = SONY_TIMEOUT_OP_ERR;
703 *result_size = 2;
704 return;
705 }
706
707
708
709
710
711 clear_result_ready();
712 a = read_result_register();
713 *result_buffer = a;
714 result_buffer++;
715
716
717 if ((a & 0xf0) == 0x50)
718 {
719 *result_size = 1;
720 return;
721 }
722
723 b = read_result_register();
724 *result_buffer = b;
725 result_buffer++;
726 *result_size = 2;
727
728
729
730
731
732
733
734
735
736 if ((a & 0xf0) != 0x20)
737 {
738 if (b > 8)
739 {
740 for (i=0; i<8; i++)
741 {
742 *result_buffer = read_result_register();
743 result_buffer++;
744 (*result_size)++;
745 }
746 b = b - 8;
747
748 while (b > 10)
749 {
750 retry_count = SONY_READY_RETRIES;
751 while ((retry_count > 0) && (!is_result_ready()))
752 {
753 retry_count--;
754 }
755 if (!is_result_ready())
756 {
757 #if DEBUG
758 printk("CDU31A timeout out %d\n", __LINE__);
759 #endif
760 result_buffer[0] = 0x20;
761 result_buffer[1] = SONY_TIMEOUT_OP_ERR;
762 *result_size = 2;
763 return;
764 }
765
766 clear_result_ready();
767
768 for (i=0; i<10; i++)
769 {
770 *result_buffer = read_result_register();
771 result_buffer++;
772 (*result_size)++;
773 }
774 b = b - 10;
775 }
776
777 if (b > 0)
778 {
779 retry_count = SONY_READY_RETRIES;
780 while ((retry_count > 0) && (!is_result_ready()))
781 {
782 retry_count--;
783 }
784 if (!is_result_ready())
785 {
786 #if DEBUG
787 printk("CDU31A timeout out %d\n", __LINE__);
788 #endif
789 result_buffer[0] = 0x20;
790 result_buffer[1] = SONY_TIMEOUT_OP_ERR;
791 *result_size = 2;
792 return;
793 }
794 }
795 }
796
797 while (b > 0)
798 {
799 *result_buffer = read_result_register();
800 result_buffer++;
801 (*result_size)++;
802 b--;
803 }
804 }
805 }
806
807
808
809
810
811
812 static void
813 do_sony_cd_cmd(unsigned char cmd,
814 unsigned char *params,
815 unsigned int num_params,
816 unsigned char *result_buffer,
817 unsigned int *result_size)
818 {
819 unsigned int retry_count;
820 int num_retries;
821 int recursive_call;
822 unsigned long flags;
823
824
825 save_flags(flags);
826 cli();
827 if (current != has_cd_task)
828 {
829 while (sony_inuse)
830 {
831 interruptible_sleep_on(&sony_wait);
832 if (current->signal & ~current->blocked)
833 {
834 result_buffer[0] = 0x20;
835 result_buffer[1] = SONY_SIGNAL_OP_ERR;
836 *result_size = 2;
837 return;
838 }
839 }
840 sony_inuse = 1;
841 has_cd_task = current;
842 recursive_call = 0;
843 }
844 else
845 {
846 recursive_call = 1;
847 }
848
849 num_retries = 0;
850 retry_cd_operation:
851
852 while (handle_sony_cd_attention())
853 ;
854
855 sti();
856
857 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
858 while ((retry_count > jiffies) && (is_busy()))
859 {
860 sony_sleep();
861
862 while (handle_sony_cd_attention())
863 ;
864 }
865 if (is_busy())
866 {
867 #if DEBUG
868 printk("CDU31A timeout out %d\n", __LINE__);
869 #endif
870 result_buffer[0] = 0x20;
871 result_buffer[1] = SONY_TIMEOUT_OP_ERR;
872 *result_size = 2;
873 }
874 else
875 {
876 clear_result_ready();
877 clear_param_reg();
878
879 write_params(params, num_params);
880 write_cmd(cmd);
881
882 get_result(result_buffer, result_size);
883 }
884
885 if ( ((result_buffer[0] & 0xf0) == 0x20)
886 && (num_retries < MAX_CDU31A_RETRIES))
887 {
888 num_retries++;
889 current->state = TASK_INTERRUPTIBLE;
890 current->timeout = jiffies + 10;
891 schedule();
892 goto retry_cd_operation;
893 }
894
895 if (!recursive_call)
896 {
897 has_cd_task = NULL;
898 sony_inuse = 0;
899 wake_up_interruptible(&sony_wait);
900 }
901
902 restore_flags(flags);
903 }
904
905
906
907
908
909
910
911
912
913
914
915 static int
916 handle_sony_cd_attention(void)
917 {
918 unsigned char atten_code;
919 static int num_consecutive_attentions = 0;
920 volatile int val;
921
922
923 if (abort_read_started)
924 {
925 while (is_result_reg_not_empty())
926 {
927 val = read_result_register();
928 }
929 clear_data_ready();
930 clear_result_ready();
931
932 while (is_data_requested())
933 {
934 val = read_data_register();
935 }
936 abort_read_started = 0;
937 return(1);
938 }
939 else if (is_attention())
940 {
941 if (num_consecutive_attentions > CDU31A_MAX_CONSECUTIVE_ATTENTIONS)
942 {
943 printk("cdu31a: Too many consecutive attentions: %d\n",
944 num_consecutive_attentions);
945 num_consecutive_attentions = 0;
946 return(0);
947 }
948
949 clear_attention();
950 atten_code = read_result_register();
951
952 switch (atten_code)
953 {
954
955 case SONY_MECH_LOADED_ATTN:
956 disk_changed = 1;
957 sony_toc_read = 0;
958 sony_audio_status = CDROM_AUDIO_NO_STATUS;
959 sony_blocks_left = 0;
960 break;
961
962 case SONY_SPIN_DOWN_COMPLETE_ATTN:
963
964 sony_spun_up = 0;
965 break;
966
967 case SONY_AUDIO_PLAY_DONE_ATTN:
968 sony_audio_status = CDROM_AUDIO_COMPLETED;
969 read_subcode();
970 break;
971
972 case SONY_EJECT_PUSHED_ATTN:
973 sony_audio_status = CDROM_AUDIO_INVALID;
974 break;
975
976 case SONY_LEAD_IN_ERR_ATTN:
977 case SONY_LEAD_OUT_ERR_ATTN:
978 case SONY_DATA_TRACK_ERR_ATTN:
979 case SONY_AUDIO_PLAYBACK_ERR_ATTN:
980 sony_audio_status = CDROM_AUDIO_ERROR;
981 break;
982 }
983
984 num_consecutive_attentions++;
985 return(1);
986 }
987
988 num_consecutive_attentions = 0;
989 return(0);
990 }
991
992
993
994 static inline unsigned int
995 int_to_bcd(unsigned int val)
996 {
997 int retval;
998
999
1000 retval = (val / 10) << 4;
1001 retval = retval | val % 10;
1002 return(retval);
1003 }
1004
1005
1006
1007 static unsigned int
1008 bcd_to_int(unsigned int bcd)
1009 {
1010 return((((bcd >> 4) & 0x0f) * 10) + (bcd & 0x0f));
1011 }
1012
1013
1014
1015
1016
1017
1018 static void
1019 log_to_msf(unsigned int log, unsigned char *msf)
1020 {
1021 log = log + LOG_START_OFFSET;
1022 msf[0] = int_to_bcd(log / 4500);
1023 log = log % 4500;
1024 msf[1] = int_to_bcd(log / 75);
1025 msf[2] = int_to_bcd(log % 75);
1026 }
1027
1028
1029
1030
1031
1032 static unsigned int
1033 msf_to_log(unsigned char *msf)
1034 {
1035 unsigned int log;
1036
1037
1038 log = bcd_to_int(msf[2]);
1039 log += bcd_to_int(msf[1]) * 75;
1040 log += bcd_to_int(msf[0]) * 4500;
1041 log = log - LOG_START_OFFSET;
1042
1043 return log;
1044 }
1045
1046
1047
1048
1049
1050
1051 static void
1052 size_to_buf(unsigned int size,
1053 unsigned char *buf)
1054 {
1055 buf[0] = size / 65536;
1056 size = size % 65536;
1057 buf[1] = size / 256;
1058 buf[2] = size % 256;
1059 }
1060
1061
1062
1063
1064
1065
1066
1067 static int
1068 start_request(unsigned int sector,
1069 unsigned int nsect,
1070 int read_nsect_only)
1071 {
1072 unsigned char params[6];
1073 unsigned int read_size;
1074 unsigned int retry_count;
1075
1076
1077 log_to_msf(sector, params);
1078
1079 if (read_nsect_only)
1080 {
1081 read_size = nsect;
1082 }
1083
1084
1085
1086
1087 else if ((sector + nsect) >= sony_toc.lead_out_start_lba)
1088 {
1089 read_size = sony_toc.lead_out_start_lba - sector;
1090 }
1091
1092 else
1093 {
1094 read_size = CDU31A_READAHEAD;
1095 }
1096 size_to_buf(read_size, ¶ms[3]);
1097
1098
1099
1100
1101
1102 while (handle_sony_cd_attention())
1103 ;
1104
1105 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
1106 while ((retry_count > jiffies) && (is_busy()))
1107 {
1108 sony_sleep();
1109
1110 while (handle_sony_cd_attention())
1111 ;
1112 }
1113
1114 if (is_busy())
1115 {
1116 printk("CDU31A: Timeout while waiting to issue command\n");
1117 return(1);
1118 }
1119 else
1120 {
1121
1122 clear_result_ready();
1123 clear_param_reg();
1124
1125 write_params(params, 6);
1126 write_cmd(SONY_READ_BLKERR_STAT_CMD);
1127
1128 sony_blocks_left = read_size * 4;
1129 sony_next_block = sector * 4;
1130 readahead_dataleft = 0;
1131 readahead_bad = 0;
1132 return(0);
1133 }
1134 }
1135
1136
1137
1138 static void
1139 abort_read(void)
1140 {
1141 unsigned char result_reg[2];
1142 int result_size;
1143 volatile int val;
1144
1145
1146 do_sony_cd_cmd(SONY_ABORT_CMD, NULL, 0, result_reg, &result_size);
1147 if ((result_reg[0] & 0xf0) == 0x20)
1148 {
1149 printk("CDU31A: Error aborting read, error = 0x%2.2x\n",
1150 result_reg[1]);
1151 }
1152
1153 while (is_result_reg_not_empty())
1154 {
1155 val = read_result_register();
1156 }
1157 clear_data_ready();
1158 clear_result_ready();
1159
1160 while (is_data_requested())
1161 {
1162 val = read_data_register();
1163 }
1164
1165 sony_blocks_left = 0;
1166 readahead_dataleft = 0;
1167 readahead_bad = 0;
1168 }
1169
1170
1171
1172 static void
1173 handle_abort_timeout(unsigned long data)
1174 {
1175
1176 if (!sony_inuse)
1177 {
1178
1179
1180
1181
1182 clear_result_ready();
1183 clear_param_reg();
1184 write_cmd(SONY_ABORT_CMD);
1185
1186 sony_blocks_left = 0;
1187 readahead_dataleft = 0;
1188 readahead_bad = 0;
1189 abort_read_started = 1;
1190 }
1191 }
1192
1193
1194 static void
1195 input_data(char *buffer,
1196 unsigned int bytesleft,
1197 unsigned int nblocks,
1198 unsigned int offset,
1199 unsigned int skip)
1200 {
1201 int i;
1202 volatile unsigned char val;
1203
1204
1205
1206
1207 if (sony_xa_mode)
1208 {
1209 for(i=0; i<CD_XA_HEAD; i++)
1210 {
1211 val = read_data_register();
1212 }
1213 }
1214
1215 clear_data_ready();
1216
1217 if (bytesleft == 2048)
1218 {
1219 insb(sony_cd_read_reg, buffer, 2048);
1220 readahead_dataleft = 0;
1221 }
1222 else
1223 {
1224
1225
1226 if (skip != 0)
1227 {
1228 insb(sony_cd_read_reg, readahead_buffer, skip);
1229 }
1230
1231
1232 insb(sony_cd_read_reg, &buffer[offset], bytesleft);
1233
1234
1235
1236 readahead_dataleft = (2048 - skip) - bytesleft;
1237 insb(sony_cd_read_reg,
1238 readahead_buffer + bytesleft,
1239 readahead_dataleft);
1240 }
1241 sony_blocks_left -= nblocks;
1242 sony_next_block += nblocks;
1243
1244
1245
1246 if (sony_xa_mode)
1247 {
1248 for(i=0; i<CD_XA_TAIL; i++)
1249 {
1250 val = read_data_register();
1251 }
1252 }
1253 }
1254
1255
1256 static void
1257 read_data_block(char *buffer,
1258 unsigned int block,
1259 unsigned int nblocks,
1260 unsigned char res_reg[],
1261 int *res_size)
1262 {
1263 unsigned int retry_count;
1264 unsigned int bytesleft;
1265 unsigned int offset;
1266 unsigned int skip;
1267
1268
1269 res_reg[0] = 0;
1270 res_reg[1] = 0;
1271 *res_size = 0;
1272 bytesleft = nblocks * 512;
1273 offset = 0;
1274
1275
1276
1277 if (((block % 4) * 512) != ((2048 - readahead_dataleft) % 2048))
1278 {
1279 sony_next_block += block % 4;
1280 sony_blocks_left -= block % 4;
1281 skip = (block % 4) * 512;
1282 }
1283 else
1284 {
1285 skip = 0;
1286 }
1287
1288
1289
1290 if (readahead_dataleft != 0)
1291 {
1292 if (bytesleft > readahead_dataleft)
1293 {
1294
1295
1296 memcpy(buffer,
1297 readahead_buffer + (2048 - readahead_dataleft),
1298 readahead_dataleft);
1299 readahead_dataleft = 0;
1300 bytesleft -= readahead_dataleft;
1301 offset += readahead_dataleft;
1302 }
1303 else
1304 {
1305
1306
1307 memcpy(buffer,
1308 readahead_buffer + (2048 - readahead_dataleft),
1309 bytesleft);
1310 readahead_dataleft -= bytesleft;
1311 bytesleft = 0;
1312 sony_blocks_left -= nblocks;
1313 sony_next_block += nblocks;
1314
1315
1316
1317 if (readahead_bad)
1318 {
1319 res_reg[0] = 0x20;
1320 res_reg[1] = SONY_BAD_DATA_ERR;
1321 *res_size = 2;
1322 }
1323
1324 if (readahead_dataleft == 0)
1325 {
1326 readahead_bad = 0;
1327 }
1328
1329
1330 if (sony_blocks_left == 0)
1331 {
1332 get_result(res_reg, res_size);
1333 }
1334 return;
1335 }
1336 }
1337
1338
1339 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
1340 while ((retry_count > jiffies) && !(is_data_ready()))
1341 {
1342 while (handle_sony_cd_attention())
1343 ;
1344
1345 sony_sleep();
1346 }
1347 if (!(is_data_ready()))
1348 {
1349 if (is_result_ready())
1350 {
1351 get_result(res_reg, res_size);
1352 if ((res_reg[0] & 0xf0) != 0x20)
1353 {
1354 printk("CDU31A: Got result that should have been error: %d\n",
1355 res_reg[0]);
1356 res_reg[0] = 0x20;
1357 res_reg[1] = SONY_BAD_DATA_ERR;
1358 *res_size = 2;
1359 }
1360 abort_read();
1361 }
1362 else
1363 {
1364 #if DEBUG
1365 printk("CDU31A timeout out %d\n", __LINE__);
1366 #endif
1367 res_reg[0] = 0x20;
1368 res_reg[1] = SONY_TIMEOUT_OP_ERR;
1369 *res_size = 2;
1370 abort_read();
1371 }
1372 }
1373 else
1374 {
1375 input_data(buffer, bytesleft, nblocks, offset, skip);
1376
1377
1378 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
1379 while ((retry_count > jiffies) && !(is_result_ready()))
1380 {
1381 while (handle_sony_cd_attention())
1382 ;
1383
1384 sony_sleep();
1385 }
1386
1387 if (!is_result_ready())
1388 {
1389 #if DEBUG
1390 printk("CDU31A timeout out %d\n", __LINE__);
1391 #endif
1392 res_reg[0] = 0x20;
1393 res_reg[1] = SONY_TIMEOUT_OP_ERR;
1394 *res_size = 2;
1395 abort_read();
1396 }
1397 else
1398 {
1399 get_result(res_reg, res_size);
1400
1401
1402 if ((res_reg[0] & 0xf0) == 0x50)
1403 {
1404
1405 if ( (res_reg[0] == SONY_NO_CIRC_ERR_BLK_STAT)
1406 || (res_reg[0] == SONY_NO_LECC_ERR_BLK_STAT)
1407 || (res_reg[0] == SONY_RECOV_LECC_ERR_BLK_STAT))
1408 {
1409
1410
1411
1412 if (readahead_bad)
1413 {
1414 readahead_bad = 0;
1415 res_reg[0] = 0x20;
1416 res_reg[1] = SONY_BAD_DATA_ERR;
1417 *res_size = 2;
1418 }
1419 }
1420 else
1421 {
1422 printk("CDU31A: Data block error: 0x%x\n", res_reg[0]);
1423 res_reg[0] = 0x20;
1424 res_reg[1] = SONY_BAD_DATA_ERR;
1425 *res_size = 2;
1426
1427
1428
1429 if (bytesleft != 2048)
1430 {
1431 readahead_bad = 1;
1432 }
1433 }
1434
1435
1436 if (sony_blocks_left == 0)
1437 {
1438 get_result(res_reg, res_size);
1439 }
1440 }
1441 else if ((res_reg[0] & 0xf0) != 0x20)
1442 {
1443
1444
1445 printk("CDU31A: Invalid block status: 0x%x\n", res_reg[0]);
1446 restart_on_error();
1447 res_reg[0] = 0x20;
1448 res_reg[1] = SONY_BAD_DATA_ERR;
1449 *res_size = 2;
1450 }
1451 }
1452 }
1453 }
1454
1455
1456
1457
1458
1459
1460
1461
1462 static void
1463 do_cdu31a_request(void)
1464 {
1465 int block;
1466 int nblock;
1467 unsigned char res_reg[12];
1468 unsigned int res_size;
1469 int num_retries;
1470 unsigned long flags;
1471
1472
1473
1474
1475
1476
1477 save_flags(flags);
1478 cli();
1479 while (sony_inuse)
1480 {
1481 interruptible_sleep_on(&sony_wait);
1482 if (current->signal & ~current->blocked)
1483 {
1484 restore_flags(flags);
1485 if (CURRENT && (CURRENT->dev > 0))
1486 {
1487 end_request(0);
1488 }
1489 restore_flags(flags);
1490 return;
1491 }
1492 }
1493 sony_inuse = 1;
1494 has_cd_task = current;
1495
1496
1497 while (handle_sony_cd_attention())
1498 ;
1499
1500 sti();
1501
1502
1503 if (cdu31a_abort_timer.next != NULL)
1504 {
1505 del_timer(&cdu31a_abort_timer);
1506 }
1507
1508 while (1)
1509 {
1510 cdu31a_request_startover:
1511
1512
1513
1514
1515 if (!(CURRENT) || CURRENT->dev < 0)
1516 {
1517 goto end_do_cdu31a_request;
1518 }
1519
1520 if (!sony_spun_up)
1521 {
1522 struct inode in;
1523
1524
1525
1526
1527 in.i_rdev = CURRENT->dev;
1528 scd_open(&in,NULL);
1529 }
1530
1531
1532
1533
1534 if (MAJOR(CURRENT->dev) != MAJOR_NR)
1535 {
1536 panic(DEVICE_NAME ": request list destroyed");
1537 }
1538 if (CURRENT->bh)
1539 {
1540 if (!CURRENT->bh->b_lock)
1541 {
1542 panic(DEVICE_NAME ": block not locked");
1543 }
1544 }
1545
1546 block = CURRENT->sector;
1547 nblock = CURRENT->nr_sectors;
1548
1549 if (!sony_toc_read)
1550 {
1551 printk("CDU31A: TOC not read\n");
1552 end_request(0);
1553 goto cdu31a_request_startover;
1554 }
1555
1556
1557
1558
1559
1560 if (block < 80)
1561 {
1562
1563 block += (sony_toc.start_track_lba * 4);
1564 }
1565
1566 switch(CURRENT->cmd)
1567 {
1568 case READ:
1569
1570
1571
1572
1573 #if 0
1574 if ((block / 4) < sony_toc.start_track_lba)
1575 {
1576 printk("CDU31A: Request before beginning of media\n");
1577 end_request(0);
1578 goto cdu31a_request_startover;
1579 }
1580 #endif
1581 if ((block / 4) >= sony_toc.lead_out_start_lba)
1582 {
1583 printk("CDU31A: Request past end of media\n");
1584 end_request(0);
1585 goto cdu31a_request_startover;
1586 }
1587 if (((block + nblock) / 4) >= sony_toc.lead_out_start_lba)
1588 {
1589 printk("CDU31A: Request past end of media\n");
1590 end_request(0);
1591 goto cdu31a_request_startover;
1592 }
1593
1594 num_retries = 0;
1595
1596 try_read_again:
1597 while (handle_sony_cd_attention())
1598 ;
1599
1600 if (!sony_toc_read)
1601 {
1602 printk("CDU31A: TOC not read\n");
1603 end_request(0);
1604 goto cdu31a_request_startover;
1605 }
1606
1607
1608
1609 if (sony_blocks_left == 0)
1610 {
1611 if (start_request(block / 4, CDU31A_READAHEAD / 4, 0))
1612 {
1613 end_request(0);
1614 goto cdu31a_request_startover;
1615 }
1616 }
1617
1618
1619
1620 else if (block != sony_next_block)
1621 {
1622 #if DEBUG
1623 printk("CDU31A Warning: Read for block %d, expected %d\n",
1624 block,
1625 sony_next_block);
1626 #endif
1627 abort_read();
1628 if (!sony_toc_read)
1629 {
1630 printk("CDU31A: TOC not read\n");
1631 end_request(0);
1632 goto cdu31a_request_startover;
1633 }
1634 if (start_request(block / 4, CDU31A_READAHEAD / 4, 0))
1635 {
1636 printk("CDU31a: start request failed\n");
1637 end_request(0);
1638 goto cdu31a_request_startover;
1639 }
1640 }
1641
1642 read_data_block(CURRENT->buffer, block, nblock, res_reg, &res_size);
1643 if (res_reg[0] == 0x20)
1644 {
1645 if (num_retries > MAX_CDU31A_RETRIES)
1646 {
1647 end_request(0);
1648 goto cdu31a_request_startover;
1649 }
1650
1651 num_retries++;
1652 if (res_reg[1] == SONY_NOT_SPIN_ERR)
1653 {
1654 do_sony_cd_cmd(SONY_SPIN_UP_CMD, NULL, 0, res_reg, &res_size);
1655 }
1656 else
1657 {
1658 printk("CDU31A: Read error: 0x%2.2x\n", res_reg[1]);
1659 }
1660 goto try_read_again;
1661 }
1662 else
1663 {
1664 end_request(1);
1665 }
1666 break;
1667
1668 case WRITE:
1669 end_request(0);
1670 break;
1671
1672 default:
1673 panic("CDU31A: Unknown cmd");
1674 }
1675 }
1676
1677 end_do_cdu31a_request:
1678 #if 0
1679
1680 abort_read();
1681 #else
1682
1683
1684 cdu31a_abort_timer.expires = jiffies + 2*HZ;
1685 add_timer(&cdu31a_abort_timer);
1686 #endif
1687
1688 has_cd_task = NULL;
1689 sony_inuse = 0;
1690 wake_up_interruptible(&sony_wait);
1691 restore_flags(flags);
1692 }
1693
1694
1695 static void
1696 mcovlp(char *dst,
1697 char *src,
1698 int size)
1699 {
1700 src += (size - 1);
1701 dst += (size - 1);
1702 while (size > 0)
1703 {
1704 *dst = *src;
1705 size--;
1706 dst--;
1707 src--;
1708 }
1709 }
1710
1711
1712
1713
1714
1715
1716 static void
1717 sony_get_toc(void)
1718 {
1719 unsigned char res_reg[2];
1720 unsigned int res_size;
1721 unsigned char parms[1];
1722 int session;
1723
1724
1725 #if DEBUG
1726 printk("Entering sony_get_toc\n");
1727 #endif
1728
1729 if (!sony_toc_read)
1730 {
1731
1732
1733
1734
1735
1736
1737 session = 2;
1738 while (1)
1739 {
1740 #if DEBUG
1741 printk("Trying session %d\n", session);
1742 #endif
1743 parms[0] = session;
1744 do_sony_cd_cmd(SONY_READ_TOC_SPEC_CMD,
1745 parms,
1746 1,
1747 res_reg,
1748 &res_size);
1749
1750 #if DEBUG
1751 printk("%2.2x %2.2x\n", res_reg[0], res_reg[1]);
1752 #endif
1753
1754 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20))
1755 {
1756
1757 break;
1758 }
1759
1760 session++;
1761
1762
1763 if (session > 20)
1764 {
1765 return;
1766 }
1767 }
1768
1769 session--;
1770
1771 #if DEBUG
1772 printk("Reading session %d\n", session);
1773 #endif
1774
1775 parms[0] = session;
1776 do_sony_cd_cmd(SONY_REQ_TOC_DATA_SPEC_CMD,
1777 parms,
1778 1,
1779 (unsigned char *) &sony_toc,
1780 &res_size);
1781 if ((res_size < 2) || ((sony_toc.exec_status[0] & 0xf0) == 0x20))
1782 {
1783
1784
1785 return;
1786 }
1787
1788 sony_toc_read = 1;
1789
1790
1791
1792 if (sony_toc.pointb0 != 0xb0)
1793 {
1794 mcovlp(((char *) &sony_toc) + 27,
1795 ((char *) &sony_toc) + 18,
1796 res_size - 18);
1797 res_size += 9;
1798 }
1799 if (sony_toc.pointb1 != 0xb1)
1800 {
1801 mcovlp(((char *) &sony_toc) + 36,
1802 ((char *) &sony_toc) + 27,
1803 res_size - 27);
1804 res_size += 9;
1805 }
1806 if (sony_toc.pointb2 != 0xb2)
1807 {
1808 mcovlp(((char *) &sony_toc) + 45,
1809 ((char *) &sony_toc) + 36,
1810 res_size - 36);
1811 res_size += 9;
1812 }
1813 if (sony_toc.pointb3 != 0xb3)
1814 {
1815 mcovlp(((char *) &sony_toc) + 54,
1816 ((char *) &sony_toc) + 45,
1817 res_size - 45);
1818 res_size += 9;
1819 }
1820 if (sony_toc.pointb4 != 0xb4)
1821 {
1822 mcovlp(((char *) &sony_toc) + 63,
1823 ((char *) &sony_toc) + 54,
1824 res_size - 54);
1825 res_size += 9;
1826 }
1827 if (sony_toc.pointc0 != 0xc0)
1828 {
1829 mcovlp(((char *) &sony_toc) + 72,
1830 ((char *) &sony_toc) + 63,
1831 res_size - 63);
1832 res_size += 9;
1833 }
1834
1835 sony_toc.start_track_lba = msf_to_log(sony_toc.tracks[0].track_start_msf);
1836 sony_toc.lead_out_start_lba = msf_to_log(sony_toc.lead_out_start_msf);
1837
1838 #if DEBUG
1839 printk("Disk session %d, start track: %d, stop track: %d\n",
1840 session,
1841 sony_toc.start_track_lba,
1842 sony_toc.lead_out_start_lba);
1843 #endif
1844 }
1845 #if DEBUG
1846 printk("Leaving sony_get_toc\n");
1847 #endif
1848 }
1849
1850
1851
1852
1853
1854 static int
1855 find_track(int track)
1856 {
1857 int i;
1858 int num_tracks;
1859
1860
1861 num_tracks = sony_toc.last_track_num - sony_toc.first_track_num + 1;
1862 for (i = 0; i < num_tracks; i++)
1863 {
1864 if (sony_toc.tracks[i].track == track)
1865 {
1866 return i;
1867 }
1868 }
1869
1870 return -1;
1871 }
1872
1873
1874
1875
1876
1877 static int
1878 read_subcode(void)
1879 {
1880 unsigned int res_size;
1881
1882
1883 do_sony_cd_cmd(SONY_REQ_SUBCODE_ADDRESS_CMD,
1884 NULL,
1885 0,
1886 (unsigned char *) &last_sony_subcode,
1887 &res_size);
1888 if ((res_size < 2) || ((last_sony_subcode.exec_status[0] & 0xf0) == 0x20))
1889 {
1890 printk("Sony CDROM error 0x%2.2x (read_subcode)\n",
1891 last_sony_subcode.exec_status[1]);
1892 return -EIO;
1893 }
1894
1895 return 0;
1896 }
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906 static int
1907 sony_get_subchnl_info(long arg)
1908 {
1909 struct cdrom_subchnl schi;
1910
1911
1912
1913 while (handle_sony_cd_attention())
1914 ;
1915
1916 sony_get_toc();
1917 if (!sony_toc_read)
1918 {
1919 return -EIO;
1920 }
1921
1922 verify_area(VERIFY_READ, (char *) arg, sizeof(schi));
1923 verify_area(VERIFY_WRITE, (char *) arg, sizeof(schi));
1924
1925 memcpy_fromfs(&schi, (char *) arg, sizeof(schi));
1926
1927 switch (sony_audio_status)
1928 {
1929 case CDROM_AUDIO_PLAY:
1930 if (read_subcode() < 0)
1931 {
1932 return -EIO;
1933 }
1934 break;
1935
1936 case CDROM_AUDIO_PAUSED:
1937 case CDROM_AUDIO_COMPLETED:
1938 break;
1939
1940 case CDROM_AUDIO_NO_STATUS:
1941 schi.cdsc_audiostatus = sony_audio_status;
1942 memcpy_tofs((char *) arg, &schi, sizeof(schi));
1943 return 0;
1944 break;
1945
1946 case CDROM_AUDIO_INVALID:
1947 case CDROM_AUDIO_ERROR:
1948 default:
1949 return -EIO;
1950 }
1951
1952 schi.cdsc_audiostatus = sony_audio_status;
1953 schi.cdsc_adr = last_sony_subcode.address;
1954 schi.cdsc_ctrl = last_sony_subcode.control;
1955 schi.cdsc_trk = bcd_to_int(last_sony_subcode.track_num);
1956 schi.cdsc_ind = bcd_to_int(last_sony_subcode.index_num);
1957 if (schi.cdsc_format == CDROM_MSF)
1958 {
1959 schi.cdsc_absaddr.msf.minute = bcd_to_int(last_sony_subcode.abs_msf[0]);
1960 schi.cdsc_absaddr.msf.second = bcd_to_int(last_sony_subcode.abs_msf[1]);
1961 schi.cdsc_absaddr.msf.frame = bcd_to_int(last_sony_subcode.abs_msf[2]);
1962
1963 schi.cdsc_reladdr.msf.minute = bcd_to_int(last_sony_subcode.rel_msf[0]);
1964 schi.cdsc_reladdr.msf.second = bcd_to_int(last_sony_subcode.rel_msf[1]);
1965 schi.cdsc_reladdr.msf.frame = bcd_to_int(last_sony_subcode.rel_msf[2]);
1966 }
1967 else if (schi.cdsc_format == CDROM_LBA)
1968 {
1969 schi.cdsc_absaddr.lba = msf_to_log(last_sony_subcode.abs_msf);
1970 schi.cdsc_reladdr.lba = msf_to_log(last_sony_subcode.rel_msf);
1971 }
1972
1973 memcpy_tofs((char *) arg, &schi, sizeof(schi));
1974 return 0;
1975 }
1976
1977
1978
1979
1980
1981 static void
1982 read_audio_data(char *buffer,
1983 unsigned char res_reg[],
1984 int *res_size)
1985 {
1986 unsigned int retry_count;
1987 int result_read;
1988
1989
1990 res_reg[0] = 0;
1991 res_reg[1] = 0;
1992 *res_size = 0;
1993 result_read = 0;
1994
1995
1996 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
1997 continue_read_audio_wait:
1998 while ( (retry_count > jiffies)
1999 && !(is_data_ready())
2000 && !(is_result_ready() || result_read))
2001 {
2002 while (handle_sony_cd_attention())
2003 ;
2004
2005 sony_sleep();
2006 }
2007 if (!(is_data_ready()))
2008 {
2009 if (is_result_ready() && !result_read)
2010 {
2011 get_result(res_reg, res_size);
2012
2013
2014 if ((res_reg[0] & 0xf0) == 0x50)
2015 {
2016 result_read = 1;
2017 goto continue_read_audio_wait;
2018 }
2019
2020 else if ((res_reg[0] & 0xf0) != 0x20)
2021 {
2022 printk("CDU31A: Got result that should have been error: %d\n",
2023 res_reg[0]);
2024 res_reg[0] = 0x20;
2025 res_reg[1] = SONY_BAD_DATA_ERR;
2026 *res_size = 2;
2027 }
2028 abort_read();
2029 }
2030 else
2031 {
2032 #if DEBUG
2033 printk("CDU31A timeout out %d\n", __LINE__);
2034 #endif
2035 res_reg[0] = 0x20;
2036 res_reg[1] = SONY_TIMEOUT_OP_ERR;
2037 *res_size = 2;
2038 abort_read();
2039 }
2040 }
2041 else
2042 {
2043 clear_data_ready();
2044
2045
2046 if (sony_raw_data_mode)
2047 {
2048 insb(sony_cd_read_reg, buffer + CD_XA_HEAD, CD_FRAMESIZE_XA);
2049 }
2050 else
2051 {
2052
2053 insb(sony_cd_read_reg, buffer, CD_FRAMESIZE_RAW);
2054 }
2055
2056
2057 if (!result_read)
2058 {
2059
2060 retry_count = jiffies + SONY_JIFFIES_TIMEOUT;
2061 while ((retry_count > jiffies) && !(is_result_ready()))
2062 {
2063 while (handle_sony_cd_attention())
2064 ;
2065
2066 sony_sleep();
2067 }
2068
2069 if (!is_result_ready())
2070 {
2071 #if DEBUG
2072 printk("CDU31A timeout out %d\n", __LINE__);
2073 #endif
2074 res_reg[0] = 0x20;
2075 res_reg[1] = SONY_TIMEOUT_OP_ERR;
2076 *res_size = 2;
2077 abort_read();
2078 return;
2079 }
2080 else
2081 {
2082 get_result(res_reg, res_size);
2083 }
2084 }
2085
2086 if ((res_reg[0] & 0xf0) == 0x50)
2087 {
2088 if ( (res_reg[0] == SONY_NO_CIRC_ERR_BLK_STAT)
2089 || (res_reg[0] == SONY_NO_LECC_ERR_BLK_STAT)
2090 || (res_reg[0] == SONY_RECOV_LECC_ERR_BLK_STAT)
2091 || (res_reg[0] == SONY_NO_ERR_DETECTION_STAT))
2092 {
2093
2094 }
2095 else
2096 {
2097 printk("CDU31A: Data block error: 0x%x\n", res_reg[0]);
2098 res_reg[0] = 0x20;
2099 res_reg[1] = SONY_BAD_DATA_ERR;
2100 *res_size = 2;
2101 }
2102 }
2103 else if ((res_reg[0] & 0xf0) != 0x20)
2104 {
2105
2106
2107 printk("CDU31A: Invalid block status: 0x%x\n", res_reg[0]);
2108 restart_on_error();
2109 res_reg[0] = 0x20;
2110 res_reg[1] = SONY_BAD_DATA_ERR;
2111 *res_size = 2;
2112 }
2113 }
2114 }
2115
2116
2117
2118 static int
2119 read_audio(struct cdrom_read_audio *ra,
2120 struct inode *inode)
2121 {
2122 int retval;
2123 unsigned char params[2];
2124 unsigned char res_reg[12];
2125 unsigned int res_size;
2126 unsigned int cframe;
2127 unsigned long flags;
2128
2129
2130
2131
2132
2133 save_flags(flags);
2134 cli();
2135 while (sony_inuse)
2136 {
2137 interruptible_sleep_on(&sony_wait);
2138 if (current->signal & ~current->blocked)
2139 {
2140 return -EAGAIN;
2141 }
2142 }
2143 sony_inuse = 1;
2144 has_cd_task = current;
2145 restore_flags(flags);
2146
2147 if (!sony_spun_up)
2148 {
2149 scd_open (inode, NULL);
2150 }
2151
2152
2153 params[0] = SONY_SD_DECODE_PARAM;
2154 params[1] = 0x06 | sony_raw_data_mode;
2155 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
2156 params,
2157 2,
2158 res_reg,
2159 &res_size);
2160 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20))
2161 {
2162 printk("CDU31A: Unable to set decode params: 0x%2.2x\n", res_reg[1]);
2163 return -EIO;
2164 }
2165
2166
2167
2168
2169
2170 retval = 0;
2171
2172 if (start_request(ra->addr.lba, ra->nframes, 1))
2173 {
2174 retval = -EIO;
2175 goto exit_read_audio;
2176 }
2177
2178
2179 cframe = 0;
2180 while (cframe < ra->nframes)
2181 {
2182 read_audio_data(readahead_buffer, res_reg, &res_size);
2183 if ((res_reg[0] & 0xf0) == 0x20)
2184 {
2185 if (res_reg[1] == SONY_BAD_DATA_ERR)
2186 {
2187 printk("CDU31A: Data error on audio sector %d\n",
2188 ra->addr.lba + cframe);
2189 }
2190 else if (res_reg[1] == SONY_ILL_TRACK_R_ERR)
2191 {
2192
2193 sony_raw_data_mode = (sony_raw_data_mode) ? 0 : 1;
2194
2195
2196 params[0] = SONY_SD_DECODE_PARAM;
2197 params[1] = 0x06 | sony_raw_data_mode;
2198 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
2199 params,
2200 2,
2201 res_reg,
2202 &res_size);
2203 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20))
2204 {
2205 printk("CDU31A: Unable to set decode params: 0x%2.2x\n", res_reg[1]);
2206 retval = -EIO;
2207 goto exit_read_audio;
2208 }
2209
2210
2211 if (start_request(ra->addr.lba + cframe, ra->nframes - cframe, 1))
2212 {
2213 retval = -EIO;
2214 goto exit_read_audio;
2215 }
2216
2217
2218
2219
2220 read_audio_data(readahead_buffer, res_reg, &res_size);
2221 if ((res_reg[0] & 0xf0) == 0x20)
2222 {
2223 if (res_reg[1] == SONY_BAD_DATA_ERR)
2224 {
2225 printk("CDU31A: Data error on audio sector %d\n",
2226 ra->addr.lba + cframe);
2227 }
2228 else
2229 {
2230 printk("CDU31A: Error reading audio data on sector %d: 0x%x\n",
2231 ra->addr.lba + cframe,
2232 res_reg[1]);
2233 retval = -EIO;
2234 goto exit_read_audio;
2235 }
2236 }
2237 else
2238 {
2239 memcpy_tofs((char *) (ra->buf + (CD_FRAMESIZE_RAW * cframe)),
2240 (char *) readahead_buffer,
2241 CD_FRAMESIZE_RAW);
2242 }
2243 }
2244 else
2245 {
2246 printk("CDU31A: Error reading audio data on sector %d: 0x%x\n",
2247 ra->addr.lba + cframe,
2248 res_reg[1]);
2249 retval = -EIO;
2250 goto exit_read_audio;
2251 }
2252 }
2253 else
2254 {
2255 memcpy_tofs((char *) (ra->buf + (CD_FRAMESIZE_RAW * cframe)),
2256 (char *) readahead_buffer,
2257 CD_FRAMESIZE_RAW);
2258 }
2259
2260 cframe++;
2261 }
2262
2263 get_result(res_reg, &res_size);
2264 if ((res_reg[0] & 0xf0) == 0x20)
2265 {
2266 printk("CDU31A: Error return from audio read: 0x%x\n",
2267 res_reg[1]);
2268 retval = -EIO;
2269 goto exit_read_audio;
2270 }
2271
2272 exit_read_audio:
2273
2274
2275 params[0] = SONY_SD_DECODE_PARAM;
2276 if (!sony_xa_mode)
2277 {
2278 params[1] = 0x0f;
2279 }
2280 else
2281 {
2282 params[1] = 0x07;
2283 }
2284 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
2285 params,
2286 2,
2287 res_reg,
2288 &res_size);
2289 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20))
2290 {
2291 printk("CDU31A: Unable to reset decode params: 0x%2.2x\n", res_reg[1]);
2292 return -EIO;
2293 }
2294
2295 has_cd_task = NULL;
2296 sony_inuse = 0;
2297 wake_up_interruptible(&sony_wait);
2298
2299 return(retval);
2300 }
2301
2302 static int
2303 do_sony_cd_cmd_chk(const char *name,
2304 unsigned char cmd,
2305 unsigned char *params,
2306 unsigned int num_params,
2307 unsigned char *result_buffer,
2308 unsigned int *result_size)
2309 {
2310 do_sony_cd_cmd(cmd, params, num_params, result_buffer, result_size);
2311 if ((*result_size < 2) || ((result_buffer[0] & 0xf0) == 0x20))
2312 {
2313 printk("Sony CDROM error 0x%2.2x (CDROM%s)\n", result_buffer[1], name);
2314 return -EIO;
2315 }
2316 return 0;
2317 }
2318
2319
2320
2321
2322 static int scd_ioctl(struct inode *inode,
2323 struct file *file,
2324 unsigned int cmd,
2325 unsigned long arg)
2326 {
2327 unsigned char res_reg[12];
2328 unsigned int res_size;
2329 unsigned char params[7];
2330 int i;
2331
2332
2333 if (!inode)
2334 {
2335 return -EINVAL;
2336 }
2337
2338 switch (cmd)
2339 {
2340 case CDROMSTART:
2341 return do_sony_cd_cmd_chk("START",SONY_SPIN_UP_CMD, NULL, 0, res_reg, &res_size);
2342 return 0;
2343 break;
2344
2345 case CDROMSTOP:
2346 do_sony_cd_cmd(SONY_AUDIO_STOP_CMD, NULL, 0, res_reg, &res_size);
2347
2348
2349
2350
2351
2352 sony_audio_status = CDROM_AUDIO_NO_STATUS;
2353 return do_sony_cd_cmd_chk("STOP",SONY_SPIN_DOWN_CMD, NULL, 0, res_reg, &res_size);
2354
2355 case CDROMPAUSE:
2356 if(do_sony_cd_cmd_chk("PAUSE", SONY_AUDIO_STOP_CMD, NULL, 0, res_reg, &res_size))
2357 return -EIO;
2358
2359 if (read_subcode() < 0)
2360 {
2361 return -EIO;
2362 }
2363 cur_pos_msf[0] = last_sony_subcode.abs_msf[0];
2364 cur_pos_msf[1] = last_sony_subcode.abs_msf[1];
2365 cur_pos_msf[2] = last_sony_subcode.abs_msf[2];
2366 sony_audio_status = CDROM_AUDIO_PAUSED;
2367 return 0;
2368 break;
2369
2370 case CDROMRESUME:
2371 if (sony_audio_status != CDROM_AUDIO_PAUSED)
2372 {
2373 return -EINVAL;
2374 }
2375
2376 do_sony_cd_cmd(SONY_SPIN_UP_CMD, NULL, 0, res_reg, &res_size);
2377
2378
2379 params[1] = cur_pos_msf[0];
2380 params[2] = cur_pos_msf[1];
2381 params[3] = cur_pos_msf[2];
2382 params[4] = final_pos_msf[0];
2383 params[5] = final_pos_msf[1];
2384 params[6] = final_pos_msf[2];
2385 params[0] = 0x03;
2386 if(do_sony_cd_cmd_chk("RESUME",SONY_AUDIO_PLAYBACK_CMD, params, 7, res_reg, &res_size)<0)
2387 return -EIO;
2388 sony_audio_status = CDROM_AUDIO_PLAY;
2389 return 0;
2390
2391 case CDROMPLAYMSF:
2392 i=verify_area(VERIFY_READ, (char *) arg, 6);
2393 if(i)
2394 return i;
2395 do_sony_cd_cmd(SONY_SPIN_UP_CMD, NULL, 0, res_reg, &res_size);
2396 memcpy_fromfs(&(params[1]), (void *) arg, 6);
2397
2398
2399 for (i=1; i<7; i++)
2400 {
2401 params[i] = int_to_bcd(params[i]);
2402 }
2403 params[0] = 0x03;
2404 if(do_sony_cd_cmd_chk("PLAYMSF",SONY_AUDIO_PLAYBACK_CMD, params, 7, res_reg, &res_size)<0)
2405 return -EIO;
2406
2407
2408 final_pos_msf[0] = params[4];
2409 final_pos_msf[1] = params[5];
2410 final_pos_msf[2] = params[6];
2411 sony_audio_status = CDROM_AUDIO_PLAY;
2412 return 0;
2413
2414 case CDROMREADTOCHDR:
2415 {
2416 struct cdrom_tochdr *hdr;
2417 struct cdrom_tochdr loc_hdr;
2418
2419 sony_get_toc();
2420 if (!sony_toc_read)
2421 {
2422 return -EIO;
2423 }
2424
2425 hdr = (struct cdrom_tochdr *) arg;
2426 i=verify_area(VERIFY_WRITE, hdr, sizeof(*hdr));
2427 if(i<0)
2428 return i;
2429 loc_hdr.cdth_trk0 = bcd_to_int(sony_toc.first_track_num);
2430 loc_hdr.cdth_trk1 = bcd_to_int(sony_toc.last_track_num);
2431 memcpy_tofs(hdr, &loc_hdr, sizeof(*hdr));
2432 }
2433 return 0;
2434
2435 case CDROMREADTOCENTRY:
2436 {
2437 struct cdrom_tocentry *entry;
2438 struct cdrom_tocentry loc_entry;
2439 int track_idx;
2440 unsigned char *msf_val = NULL;
2441
2442 sony_get_toc();
2443 if (!sony_toc_read)
2444 {
2445 return -EIO;
2446 }
2447
2448 entry = (struct cdrom_tocentry *) arg;
2449 i=verify_area(VERIFY_READ, entry, sizeof(*entry));
2450 if(i<0)
2451 return i;
2452 i=verify_area(VERIFY_WRITE, entry, sizeof(*entry));
2453 if(i<0)
2454 return i;
2455
2456 memcpy_fromfs(&loc_entry, entry, sizeof(loc_entry));
2457
2458
2459 if (loc_entry.cdte_track == CDROM_LEADOUT)
2460 {
2461 loc_entry.cdte_adr = sony_toc.address2;
2462 loc_entry.cdte_ctrl = sony_toc.control2;
2463 msf_val = sony_toc.lead_out_start_msf;
2464 }
2465 else
2466 {
2467 track_idx = find_track(int_to_bcd(loc_entry.cdte_track));
2468 if (track_idx < 0)
2469 {
2470 return -EINVAL;
2471 }
2472
2473 loc_entry.cdte_adr = sony_toc.tracks[track_idx].address;
2474 loc_entry.cdte_ctrl = sony_toc.tracks[track_idx].control;
2475 msf_val = sony_toc.tracks[track_idx].track_start_msf;
2476 }
2477
2478
2479 if (loc_entry.cdte_format == CDROM_LBA)
2480 {
2481 loc_entry.cdte_addr.lba = msf_to_log(msf_val);
2482 }
2483 else if (loc_entry.cdte_format == CDROM_MSF)
2484 {
2485 loc_entry.cdte_addr.msf.minute = bcd_to_int(*msf_val);
2486 loc_entry.cdte_addr.msf.second = bcd_to_int(*(msf_val+1));
2487 loc_entry.cdte_addr.msf.frame = bcd_to_int(*(msf_val+2));
2488 }
2489 memcpy_tofs(entry, &loc_entry, sizeof(*entry));
2490 }
2491 return 0;
2492 break;
2493
2494 case CDROMPLAYTRKIND:
2495 {
2496 struct cdrom_ti ti;
2497 int track_idx;
2498
2499 sony_get_toc();
2500 if (!sony_toc_read)
2501 {
2502 return -EIO;
2503 }
2504
2505 i=verify_area(VERIFY_READ, (char *) arg, sizeof(ti));
2506 if(i<0)
2507 return i;
2508
2509 memcpy_fromfs(&ti, (char *) arg, sizeof(ti));
2510 if ( (ti.cdti_trk0 < sony_toc.first_track_num)
2511 || (ti.cdti_trk0 > sony_toc.last_track_num)
2512 || (ti.cdti_trk1 < ti.cdti_trk0))
2513 {
2514 return -EINVAL;
2515 }
2516
2517 track_idx = find_track(int_to_bcd(ti.cdti_trk0));
2518 if (track_idx < 0)
2519 {
2520 return -EINVAL;
2521 }
2522 params[1] = sony_toc.tracks[track_idx].track_start_msf[0];
2523 params[2] = sony_toc.tracks[track_idx].track_start_msf[1];
2524 params[3] = sony_toc.tracks[track_idx].track_start_msf[2];
2525
2526
2527
2528
2529
2530 if (ti.cdti_trk1 >= bcd_to_int(sony_toc.last_track_num))
2531 {
2532 log_to_msf(msf_to_log(sony_toc.lead_out_start_msf)-1,
2533 &(params[4]));
2534 }
2535 else
2536 {
2537 track_idx = find_track(int_to_bcd(ti.cdti_trk1+1));
2538 if (track_idx < 0)
2539 {
2540 return -EINVAL;
2541 }
2542 log_to_msf(msf_to_log(sony_toc.tracks[track_idx].track_start_msf)-1,
2543 &(params[4]));
2544 }
2545 params[0] = 0x03;
2546
2547 do_sony_cd_cmd(SONY_SPIN_UP_CMD, NULL, 0, res_reg, &res_size);
2548
2549 do_sony_cd_cmd(SONY_AUDIO_PLAYBACK_CMD, params, 7, res_reg, &res_size);
2550
2551 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20))
2552 {
2553 printk("Params: %x %x %x %x %x %x %x\n", params[0], params[1],
2554 params[2], params[3], params[4], params[5], params[6]);
2555 printk("Sony CDROM error 0x%2.2x (CDROMPLAYTRKIND\n", res_reg[1]);
2556 return -EIO;
2557 }
2558
2559
2560 final_pos_msf[0] = params[4];
2561 final_pos_msf[1] = params[5];
2562 final_pos_msf[2] = params[6];
2563 sony_audio_status = CDROM_AUDIO_PLAY;
2564 return 0;
2565 }
2566
2567 case CDROMSUBCHNL:
2568 return sony_get_subchnl_info(arg);
2569
2570 case CDROMVOLCTRL:
2571 {
2572 struct cdrom_volctrl volctrl;
2573
2574 i=verify_area(VERIFY_READ, (char *) arg, sizeof(volctrl));
2575 if(i<0)
2576 return i;
2577
2578 memcpy_fromfs(&volctrl, (char *) arg, sizeof(volctrl));
2579 params[0] = SONY_SD_AUDIO_VOLUME;
2580 params[1] = volctrl.channel0;
2581 params[2] = volctrl.channel1;
2582 return do_sony_cd_cmd_chk("VOLCTRL",SONY_SET_DRIVE_PARAM_CMD, params, 3, res_reg, &res_size);
2583 }
2584 case CDROMEJECT:
2585 do_sony_cd_cmd(SONY_AUDIO_STOP_CMD, NULL, 0, res_reg, &res_size);
2586 do_sony_cd_cmd(SONY_SPIN_DOWN_CMD, NULL, 0, res_reg, &res_size);
2587
2588 sony_audio_status = CDROM_AUDIO_INVALID;
2589 return do_sony_cd_cmd_chk("EJECT",SONY_EJECT_CMD, NULL, 0, res_reg, &res_size);
2590
2591 case CDROMREADAUDIO:
2592
2593 {
2594 struct cdrom_read_audio ra;
2595
2596
2597 sony_get_toc();
2598 if (!sony_toc_read)
2599 {
2600 return -EIO;
2601 }
2602
2603 i=verify_area(VERIFY_READ, (char *) arg, sizeof(ra));
2604 if(i<0)
2605 return i;
2606 memcpy_fromfs(&ra, (char *) arg, sizeof(ra));
2607
2608 i=verify_area(VERIFY_WRITE, ra.buf, CD_FRAMESIZE_RAW * ra.nframes);
2609 if(i<0)
2610 return i;
2611
2612 if (ra.addr_format == CDROM_LBA)
2613 {
2614 if ( (ra.addr.lba >= sony_toc.lead_out_start_lba)
2615 || (ra.addr.lba + ra.nframes >= sony_toc.lead_out_start_lba))
2616 {
2617 return -EINVAL;
2618 }
2619 }
2620 else if (ra.addr_format == CDROM_MSF)
2621 {
2622 if ( (ra.addr.msf.minute >= 75)
2623 || (ra.addr.msf.second >= 60)
2624 || (ra.addr.msf.frame >= 75))
2625 {
2626 return -EINVAL;
2627 }
2628
2629 ra.addr.lba = ( (ra.addr.msf.minute * 4500)
2630 + (ra.addr.msf.second * 75)
2631 + ra.addr.msf.frame);
2632 if ( (ra.addr.lba >= sony_toc.lead_out_start_lba)
2633 || (ra.addr.lba + ra.nframes >= sony_toc.lead_out_start_lba))
2634 {
2635 return -EINVAL;
2636 }
2637
2638
2639
2640
2641 ra.addr.lba -= LOG_START_OFFSET;
2642 }
2643 else
2644 {
2645 return -EINVAL;
2646 }
2647
2648 return(read_audio(&ra, inode));
2649 }
2650 return 0;
2651 break;
2652
2653 default:
2654 return -EINVAL;
2655 }
2656 }
2657
2658
2659
2660
2661
2662
2663 static int
2664 scd_open(struct inode *inode,
2665 struct file *filp)
2666 {
2667 unsigned char res_reg[12];
2668 unsigned int res_size;
2669 int num_spin_ups;
2670 unsigned char params[2];
2671
2672
2673 if ((filp) && filp->f_mode & 2)
2674 return -EROFS;
2675
2676 if (!sony_spun_up)
2677 {
2678 num_spin_ups = 0;
2679
2680 respinup_on_open:
2681 do_sony_cd_cmd(SONY_SPIN_UP_CMD, NULL, 0, res_reg, &res_size);
2682
2683
2684
2685 if ((res_size < 2) || ((res_reg[0] != 0) && (res_reg[1] != 0)))
2686 {
2687 printk("Sony CDROM error 0x%2.2x (scd_open, spin up)\n", res_reg[1]);
2688 return -EIO;
2689 }
2690
2691 do_sony_cd_cmd(SONY_READ_TOC_CMD, NULL, 0, res_reg, &res_size);
2692
2693
2694
2695 if ((res_size < 2) || ((res_reg[0] != 0) && (res_reg[1] != 0)))
2696 {
2697
2698 if ((res_reg[1] == SONY_AUDIO_PLAYING_ERR) || (res_reg[1] == 0))
2699 {
2700 goto drive_spinning;
2701 }
2702
2703
2704
2705 if ( (res_reg[1] == SONY_NOT_SPIN_ERR)
2706 && (num_spin_ups < MAX_CDU31A_RETRIES))
2707 {
2708 num_spin_ups++;
2709 goto respinup_on_open;
2710 }
2711
2712 printk("Sony CDROM error 0x%2.2x (scd_open, read toc)\n", res_reg[1]);
2713 do_sony_cd_cmd(SONY_SPIN_DOWN_CMD, NULL, 0, res_reg, &res_size);
2714
2715 return -EIO;
2716 }
2717
2718 sony_get_toc();
2719 if (!sony_toc_read)
2720 {
2721 do_sony_cd_cmd(SONY_SPIN_DOWN_CMD, NULL, 0, res_reg, &res_size);
2722 return -EIO;
2723 }
2724
2725
2726
2727 if ( (sony_toc.disk_type == SONY_XA_DISK_TYPE)
2728 && (!is_double_speed))
2729 {
2730 params[0] = SONY_SD_DECODE_PARAM;
2731 params[1] = 0x07;
2732 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
2733 params,
2734 2,
2735 res_reg,
2736 &res_size);
2737 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20))
2738 {
2739 printk("CDU31A: Unable to set XA params: 0x%2.2x\n", res_reg[1]);
2740 }
2741 sony_xa_mode = 1;
2742 }
2743
2744 else if (sony_xa_mode)
2745 {
2746 params[0] = SONY_SD_DECODE_PARAM;
2747 params[1] = 0x0f;
2748 do_sony_cd_cmd(SONY_SET_DRIVE_PARAM_CMD,
2749 params,
2750 2,
2751 res_reg,
2752 &res_size);
2753 if ((res_size < 2) || ((res_reg[0] & 0xf0) == 0x20))
2754 {
2755 printk("CDU31A: Unable to reset XA params: 0x%2.2x\n", res_reg[1]);
2756 }
2757 sony_xa_mode = 0;
2758 }
2759
2760 sony_spun_up = 1;
2761 }
2762
2763 drive_spinning:
2764
2765
2766 if (filp)
2767 {
2768 check_disk_change(inode->i_rdev);
2769 }
2770
2771 sony_usage++;
2772
2773 return 0;
2774 }
2775
2776
2777
2778
2779
2780
2781 static void
2782 scd_release(struct inode *inode,
2783 struct file *filp)
2784 {
2785 unsigned char res_reg[12];
2786 unsigned int res_size;
2787
2788
2789 if (sony_usage > 0)
2790 {
2791 sony_usage--;
2792 }
2793 if (sony_usage == 0)
2794 {
2795 sync_dev(inode->i_rdev);
2796 do_sony_cd_cmd(SONY_SPIN_DOWN_CMD, NULL, 0, res_reg, &res_size);
2797
2798 sony_spun_up = 0;
2799 }
2800 }
2801
2802
2803 static struct file_operations scd_fops = {
2804 NULL,
2805 block_read,
2806 block_write,
2807 NULL,
2808 NULL,
2809 scd_ioctl,
2810 NULL,
2811 scd_open,
2812 scd_release,
2813 NULL,
2814 NULL,
2815 scd_disk_change,
2816 NULL
2817 };
2818
2819
2820
2821 static const char *load_mech[] = { "caddy", "tray", "pop-up", "unknown" };
2822
2823 static void
2824 get_drive_configuration(unsigned short base_io,
2825 unsigned char res_reg[],
2826 unsigned int *res_size)
2827 {
2828 int retry_count;
2829
2830
2831
2832 cdu31a_port = base_io;
2833
2834
2835 sony_cd_cmd_reg = cdu31a_port + SONY_CMD_REG_OFFSET;
2836 sony_cd_param_reg = cdu31a_port + SONY_PARAM_REG_OFFSET;
2837 sony_cd_write_reg = cdu31a_port + SONY_WRITE_REG_OFFSET;
2838 sony_cd_control_reg = cdu31a_port + SONY_CONTROL_REG_OFFSET;
2839 sony_cd_status_reg = cdu31a_port + SONY_STATUS_REG_OFFSET;
2840 sony_cd_result_reg = cdu31a_port + SONY_RESULT_REG_OFFSET;
2841 sony_cd_read_reg = cdu31a_port + SONY_READ_REG_OFFSET;
2842 sony_cd_fifost_reg = cdu31a_port + SONY_FIFOST_REG_OFFSET;
2843
2844
2845
2846
2847
2848
2849 if (read_status_register() != 0xff)
2850 {
2851
2852
2853
2854
2855 reset_drive();
2856 retry_count = jiffies + SONY_RESET_TIMEOUT;
2857 while ((retry_count > jiffies) && (!is_attention()))
2858 {
2859 sony_sleep();
2860 }
2861
2862 #if 0
2863
2864 if (!is_attention())
2865 {
2866 res_reg[0] = 0x20;
2867 return;
2868 }
2869 #endif
2870
2871
2872
2873
2874 do_sony_cd_cmd(SONY_REQ_DRIVE_CONFIG_CMD,
2875 NULL,
2876 0,
2877 (unsigned char *) res_reg,
2878 res_size);
2879 return;
2880 }
2881
2882
2883 res_reg[0] = 0x20;
2884 }
2885
2886
2887
2888
2889 void
2890 cdu31a_setup(char *strings,
2891 int *ints)
2892 {
2893 if (ints[0] > 0)
2894 {
2895 cdu31a_port = ints[1];
2896 }
2897 if (ints[0] > 1)
2898 {
2899 cdu31a_irq = ints[2];
2900 }
2901 if ((strings != NULL) && (*strings != '\0'))
2902 {
2903 if (strcmp(strings, "PAS") == 0)
2904 {
2905 sony_pas_init = 1;
2906 }
2907 else
2908 {
2909 printk("CDU31A: Unknown interface type: %s\n", strings);
2910 }
2911 }
2912 }
2913
2914 static int cdu31a_block_size;
2915
2916
2917
2918
2919 #ifndef MODULE
2920 unsigned long
2921 cdu31a_init(unsigned long mem_start, unsigned long mem_end)
2922 #else
2923 int
2924 init_module(void)
2925 #endif
2926 {
2927 struct s_sony_drive_config drive_config;
2928 unsigned int res_size;
2929 int i;
2930 int drive_found;
2931 int tmp_irq;
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941 if (sony_pas_init)
2942 {
2943 outb(0xbc, 0x9a01);
2944 outb(0xe2, 0x9a01);
2945 }
2946
2947 drive_found = 0;
2948
2949
2950 if (cdu31a_port == 0xffff)
2951 {
2952 }
2953 else if (cdu31a_port != 0)
2954 {
2955 tmp_irq = cdu31a_irq;
2956 cdu31a_irq = 0;
2957
2958 get_drive_configuration(cdu31a_port,
2959 drive_config.exec_status,
2960 &res_size);
2961 if ((res_size > 2) && ((drive_config.exec_status[0] & 0xf0) == 0x00))
2962 {
2963 drive_found = 1;
2964 }
2965
2966 cdu31a_irq = tmp_irq;
2967 }
2968 else
2969 {
2970 cdu31a_irq = 0;
2971 i = 0;
2972 while ( (cdu31a_addresses[i].base != 0)
2973 && (!drive_found))
2974 {
2975 if (check_region(cdu31a_addresses[i].base, 4)) {
2976 i++;
2977 continue;
2978 }
2979 get_drive_configuration(cdu31a_addresses[i].base,
2980 drive_config.exec_status,
2981 &res_size);
2982 if ((res_size > 2) && ((drive_config.exec_status[0] & 0xf0) == 0x00))
2983 {
2984 drive_found = 1;
2985 cdu31a_irq = cdu31a_addresses[i].int_num;
2986 }
2987 else
2988 {
2989 i++;
2990 }
2991 }
2992 }
2993
2994 if (drive_found)
2995 {
2996 request_region(cdu31a_port, 4,"cdu31a");
2997
2998 if (register_blkdev(MAJOR_NR,"cdu31a",&scd_fops))
2999 {
3000 printk("Unable to get major %d for CDU-31a\n", MAJOR_NR);
3001 #ifdef MODULE
3002 return -EIO;
3003 #else
3004 return mem_start;
3005 #endif
3006 }
3007
3008 if (SONY_HWC_DOUBLE_SPEED(drive_config))
3009 {
3010 is_double_speed = 1;
3011 }
3012
3013 tmp_irq = cdu31a_irq;
3014 cdu31a_irq = 0;
3015
3016 set_drive_params();
3017
3018 cdu31a_irq = tmp_irq;
3019
3020 if (cdu31a_irq > 0)
3021 {
3022 if (request_irq(cdu31a_irq, cdu31a_interrupt, SA_INTERRUPT, "cdu31a"))
3023 {
3024 printk("Unable to grab IRQ%d for the CDU31A driver\n", cdu31a_irq);
3025 cdu31a_irq = 0;
3026 }
3027 }
3028
3029 printk("Sony I/F CDROM : %8.8s %16.16s %8.8s\n",
3030 drive_config.vendor_id,
3031 drive_config.product_id,
3032 drive_config.product_rev_level);
3033 printk(" Capabilities: %s",
3034 load_mech[SONY_HWC_GET_LOAD_MECH(drive_config)]);
3035 if (SONY_HWC_AUDIO_PLAYBACK(drive_config))
3036 {
3037 printk(", audio");
3038 }
3039 if (SONY_HWC_EJECT(drive_config))
3040 {
3041 printk(", eject");
3042 }
3043 if (SONY_HWC_LED_SUPPORT(drive_config))
3044 {
3045 printk(", LED");
3046 }
3047 if (SONY_HWC_ELECTRIC_VOLUME(drive_config))
3048 {
3049 printk(", elec. Vol");
3050 }
3051 if (SONY_HWC_ELECTRIC_VOLUME_CTL(drive_config))
3052 {
3053 printk(", sep. Vol");
3054 }
3055 if (is_double_speed)
3056 {
3057 printk(", double speed");
3058 }
3059 if (cdu31a_irq > 0)
3060 {
3061 printk(", irq %d", cdu31a_irq);
3062 }
3063 printk("\n");
3064
3065 blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
3066 read_ahead[MAJOR_NR] = CDU31A_READAHEAD;
3067 cdu31a_block_size = 1024;
3068
3069 blksize_size[MAJOR_NR] = &cdu31a_block_size;
3070
3071 cdu31a_abort_timer.next = NULL;
3072 cdu31a_abort_timer.prev = NULL;
3073 cdu31a_abort_timer.function = handle_abort_timeout;
3074 }
3075
3076
3077 disk_changed = 1;
3078
3079 #ifdef MODULE
3080 if (drive_found)
3081 {
3082 return(0);
3083 }
3084 else
3085 {
3086 return -EIO;
3087 }
3088 #else
3089 return mem_start;
3090 #endif
3091 }
3092
3093 #ifdef MODULE
3094 void
3095 cleanup_module(void)
3096 {
3097 if (sony_usage != 0)
3098 {
3099 printk("cdu31a module in use - can't remove it.\n");
3100 return;
3101 }
3102
3103 if ((unregister_blkdev(MAJOR_NR, "cdu31a") == -EINVAL))
3104 {
3105 printk("Can't unregister cdu31a\n");
3106 return;
3107 }
3108 release_region(cdu31a_port,4);
3109 printk("cdu31a module released.\n");
3110 }
3111 #endif MODULE