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#define SJCD_VERSION_MAJOR 1
59#define SJCD_VERSION_MINOR 7
60
61#include <linux/module.h>
62#include <linux/errno.h>
63#include <linux/sched.h>
64#include <linux/mm.h>
65#include <linux/timer.h>
66#include <linux/fs.h>
67#include <linux/kernel.h>
68#include <linux/cdrom.h>
69#include <linux/ioport.h>
70#include <linux/string.h>
71#include <linux/major.h>
72#include <linux/init.h>
73#include <linux/devfs_fs_kernel.h>
74
75#include <asm/system.h>
76#include <asm/io.h>
77#include <asm/uaccess.h>
78
79#define MAJOR_NR SANYO_CDROM_MAJOR
80#include <linux/blk.h>
81#include "sjcd.h"
82
83static int sjcd_present = 0;
84
85#define SJCD_BUF_SIZ 32
86
87
88
89
90static char sjcd_buf[2048 * SJCD_BUF_SIZ];
91static volatile int sjcd_buf_bn[SJCD_BUF_SIZ], sjcd_next_bn;
92static volatile int sjcd_buf_in, sjcd_buf_out = -1;
93
94
95
96
97static unsigned short sjcd_status_valid = 0;
98static unsigned short sjcd_door_closed;
99static unsigned short sjcd_door_was_open;
100static unsigned short sjcd_media_is_available;
101static unsigned short sjcd_media_is_changed;
102static unsigned short sjcd_toc_uptodate = 0;
103static unsigned short sjcd_command_failed;
104static volatile unsigned char sjcd_completion_status = 0;
105static volatile unsigned char sjcd_completion_error = 0;
106static unsigned short sjcd_command_is_in_progress = 0;
107static unsigned short sjcd_error_reported = 0;
108
109static int sjcd_open_count;
110
111static int sjcd_audio_status;
112static struct sjcd_play_msf sjcd_playing;
113
114static int sjcd_base = SJCD_BASE_ADDR;
115
116MODULE_PARM(sjcd_base, "i");
117
118static DECLARE_WAIT_QUEUE_HEAD(sjcd_waitq);
119
120
121
122
123static volatile unsigned short sjcd_transfer_is_active = 0;
124
125enum sjcd_transfer_state {
126 SJCD_S_IDLE = 0,
127 SJCD_S_START = 1,
128 SJCD_S_MODE = 2,
129 SJCD_S_READ = 3,
130 SJCD_S_DATA = 4,
131 SJCD_S_STOP = 5,
132 SJCD_S_STOPPING = 6
133};
134static enum sjcd_transfer_state sjcd_transfer_state = SJCD_S_IDLE;
135static long sjcd_transfer_timeout = 0;
136static int sjcd_read_count = 0;
137static unsigned char sjcd_mode = 0;
138
139#define SJCD_READ_TIMEOUT 5000
140
141#if defined( SJCD_GATHER_STAT )
142
143
144
145static struct sjcd_stat statistic;
146#endif
147
148
149
150
151static struct timer_list sjcd_delay_timer;
152
153#define SJCD_SET_TIMER( func, tmout ) \
154 ( sjcd_delay_timer.expires = jiffies+tmout, \
155 sjcd_delay_timer.function = ( void * )func, \
156 add_timer( &sjcd_delay_timer ) )
157
158#define CLEAR_TIMER del_timer( &sjcd_delay_timer )
159
160static int sjcd_cleanup(void);
161
162
163
164
165
166#ifndef MODULE
167static int __init sjcd_setup(char *str)
168{
169 int ints[2];
170 (void) get_options(str, ARRAY_SIZE(ints), ints);
171 if (ints[0] > 0)
172 sjcd_base = ints[1];
173
174 return 1;
175}
176
177__setup("sjcd=", sjcd_setup);
178
179#endif
180
181
182
183
184static unsigned char bin2bcd(int bin)
185{
186 int u, v;
187
188 u = bin % 10;
189 v = bin / 10;
190 return (u | (v << 4));
191}
192
193static int bcd2bin(unsigned char bcd)
194{
195 return ((bcd >> 4) * 10 + (bcd & 0x0F));
196}
197
198static long msf2hsg(struct msf *mp)
199{
200 return (bcd2bin(mp->frame) + bcd2bin(mp->sec) * 75
201 + bcd2bin(mp->min) * 4500 - 150);
202}
203
204static void hsg2msf(long hsg, struct msf *msf)
205{
206 hsg += 150;
207 msf->min = hsg / 4500;
208 hsg %= 4500;
209 msf->sec = hsg / 75;
210 msf->frame = hsg % 75;
211 msf->min = bin2bcd(msf->min);
212 msf->sec = bin2bcd(msf->sec);
213 msf->frame = bin2bcd(msf->frame);
214}
215
216
217
218
219static void sjcd_send_cmd(unsigned char cmd)
220{
221#if defined( SJCD_TRACE )
222 printk("SJCD: send_cmd( 0x%x )\n", cmd);
223#endif
224 outb(cmd, SJCDPORT(0));
225 sjcd_command_is_in_progress = 1;
226 sjcd_status_valid = 0;
227 sjcd_command_failed = 0;
228}
229
230
231
232
233static void sjcd_send_1_cmd(unsigned char cmd, unsigned char a)
234{
235#if defined( SJCD_TRACE )
236 printk("SJCD: send_1_cmd( 0x%x, 0x%x )\n", cmd, a);
237#endif
238 outb(cmd, SJCDPORT(0));
239 outb(a, SJCDPORT(0));
240 sjcd_command_is_in_progress = 1;
241 sjcd_status_valid = 0;
242 sjcd_command_failed = 0;
243}
244
245
246
247
248static void sjcd_send_4_cmd(unsigned char cmd, unsigned char a,
249 unsigned char b, unsigned char c,
250 unsigned char d)
251{
252#if defined( SJCD_TRACE )
253 printk("SJCD: send_4_cmd( 0x%x )\n", cmd);
254#endif
255 outb(cmd, SJCDPORT(0));
256 outb(a, SJCDPORT(0));
257 outb(b, SJCDPORT(0));
258 outb(c, SJCDPORT(0));
259 outb(d, SJCDPORT(0));
260 sjcd_command_is_in_progress = 1;
261 sjcd_status_valid = 0;
262 sjcd_command_failed = 0;
263}
264
265
266
267
268static void sjcd_send_6_cmd(unsigned char cmd, struct sjcd_play_msf *pms)
269{
270#if defined( SJCD_TRACE )
271 printk("SJCD: send_long_cmd( 0x%x )\n", cmd);
272#endif
273 outb(cmd, SJCDPORT(0));
274 outb(pms->start.min, SJCDPORT(0));
275 outb(pms->start.sec, SJCDPORT(0));
276 outb(pms->start.frame, SJCDPORT(0));
277 outb(pms->end.min, SJCDPORT(0));
278 outb(pms->end.sec, SJCDPORT(0));
279 outb(pms->end.frame, SJCDPORT(0));
280 sjcd_command_is_in_progress = 1;
281 sjcd_status_valid = 0;
282 sjcd_command_failed = 0;
283}
284
285
286
287
288
289static int sjcd_load_response(void *buf, int len)
290{
291 unsigned char *resp = (unsigned char *) buf;
292
293 for (; len; --len) {
294 int i;
295 for (i = 200;
296 i-- && !SJCD_STATUS_AVAILABLE(inb(SJCDPORT(1))););
297 if (i > 0)
298 *resp++ = (unsigned char) inb(SJCDPORT(0));
299 else
300 break;
301 }
302 return (len);
303}
304
305
306
307
308
309static void sjcd_load_status(void)
310{
311 sjcd_media_is_changed = 0;
312 sjcd_completion_error = 0;
313 sjcd_completion_status = inb(SJCDPORT(0));
314 if (sjcd_completion_status & SST_DOOR_OPENED) {
315 sjcd_door_closed = sjcd_media_is_available = 0;
316 } else {
317 sjcd_door_closed = 1;
318 if (sjcd_completion_status & SST_MEDIA_CHANGED)
319 sjcd_media_is_available = sjcd_media_is_changed =
320 1;
321 else if (sjcd_completion_status & 0x0F) {
322
323
324
325 while (!SJCD_STATUS_AVAILABLE(inb(SJCDPORT(1))));
326 sjcd_completion_error = inb(SJCDPORT(0));
327 if ((sjcd_completion_status & 0x08) &&
328 (sjcd_completion_error & 0x40))
329 sjcd_media_is_available = 0;
330 else
331 sjcd_command_failed = 1;
332 } else
333 sjcd_media_is_available = 1;
334 }
335
336
337
338 sjcd_status_valid = 1, sjcd_error_reported = 0;
339 sjcd_command_is_in_progress = 0;
340
341
342
343
344 if (sjcd_media_is_changed)
345 sjcd_toc_uptodate = 0;
346#if defined( SJCD_TRACE )
347 printk("SJCD: status %02x.%02x loaded.\n",
348 (int) sjcd_completion_status, (int) sjcd_completion_error);
349#endif
350}
351
352
353
354
355static int sjcd_check_status(void)
356{
357
358
359
360 if (SJCD_STATUS_AVAILABLE(inb(SJCDPORT(1)))) {
361 sjcd_load_status();
362 return (1);
363 } else {
364
365
366
367 return (0);
368 }
369}
370
371
372
373
374static volatile long sjcd_status_timeout;
375
376
377
378
379
380
381#define SJCD_WAIT_FOR_STATUS_TIMEOUT 1000
382
383static void sjcd_status_timer(void)
384{
385 if (sjcd_check_status()) {
386
387
388
389 wake_up(&sjcd_waitq);
390 } else if (--sjcd_status_timeout <= 0) {
391
392
393
394 wake_up(&sjcd_waitq);
395 } else {
396
397
398
399 SJCD_SET_TIMER(sjcd_status_timer, 1);
400 }
401}
402
403
404
405
406
407static int sjcd_wait_for_status(void)
408{
409 sjcd_status_timeout = SJCD_WAIT_FOR_STATUS_TIMEOUT;
410 SJCD_SET_TIMER(sjcd_status_timer, 1);
411 sleep_on(&sjcd_waitq);
412#if defined( SJCD_DIAGNOSTIC ) || defined ( SJCD_TRACE )
413 if (sjcd_status_timeout <= 0)
414 printk("SJCD: Error Wait For Status.\n");
415#endif
416 return (sjcd_status_timeout);
417}
418
419static int sjcd_receive_status(void)
420{
421 int i;
422#if defined( SJCD_TRACE )
423 printk("SJCD: receive_status\n");
424#endif
425
426
427
428 for (i = 200; i-- && (sjcd_check_status() == 0););
429 if (i < 0) {
430#if defined( SJCD_TRACE )
431 printk("SJCD: long wait for status\n");
432#endif
433 if (sjcd_wait_for_status() <= 0)
434 printk("SJCD: Timeout when read status.\n");
435 else
436 i = 0;
437 }
438 return (i);
439}
440
441
442
443
444static void sjcd_get_status(void)
445{
446#if defined( SJCD_TRACE )
447 printk("SJCD: get_status\n");
448#endif
449 sjcd_send_cmd(SCMD_GET_STATUS);
450 sjcd_receive_status();
451}
452
453
454
455
456static int sjcd_disk_change(kdev_t full_dev)
457{
458#if 0
459 printk("SJCD: sjcd_disk_change( 0x%x )\n", full_dev);
460#endif
461 if (MINOR(full_dev) > 0) {
462 printk("SJCD: request error: invalid device minor.\n");
463 return 0;
464 }
465 if (!sjcd_command_is_in_progress)
466 sjcd_get_status();
467 return (sjcd_status_valid ? sjcd_media_is_changed : 0);
468}
469
470
471
472
473
474static struct sjcd_hw_disk_info sjcd_table_of_contents[SJCD_MAX_TRACKS];
475static unsigned char sjcd_first_track_no, sjcd_last_track_no;
476#define sjcd_disk_length sjcd_table_of_contents[0].un.track_msf
477
478static int sjcd_update_toc(void)
479{
480 struct sjcd_hw_disk_info info;
481 int i;
482#if defined( SJCD_TRACE )
483 printk("SJCD: update toc:\n");
484#endif
485
486
487
488 if (sjcd_toc_uptodate)
489 return (0);
490
491
492
493
494 sjcd_send_1_cmd(SCMD_GET_DISK_INFO, SCMD_GET_1_TRACK);
495 sjcd_receive_status();
496
497 if (!sjcd_status_valid) {
498 printk("SJCD: cannot load status.\n");
499 return (-1);
500 }
501
502 if (!sjcd_media_is_available) {
503 printk("SJCD: no disk in drive\n");
504 return (-1);
505 }
506
507 if (!sjcd_command_failed) {
508 if (sjcd_load_response(&info, sizeof(info)) != 0) {
509 printk
510 ("SJCD: cannot load response about TOC start.\n");
511 return (-1);
512 }
513 sjcd_first_track_no = bcd2bin(info.un.track_no);
514 } else {
515 printk("SJCD: get first failed\n");
516 return (-1);
517 }
518#if defined( SJCD_TRACE )
519 printk("SJCD: TOC start 0x%02x ", sjcd_first_track_no);
520#endif
521
522
523
524 sjcd_send_1_cmd(SCMD_GET_DISK_INFO, SCMD_GET_L_TRACK);
525 sjcd_receive_status();
526
527 if (!sjcd_status_valid) {
528 printk("SJCD: cannot load status.\n");
529 return (-1);
530 }
531
532 if (!sjcd_media_is_available) {
533 printk("SJCD: no disk in drive\n");
534 return (-1);
535 }
536
537 if (!sjcd_command_failed) {
538 if (sjcd_load_response(&info, sizeof(info)) != 0) {
539 printk
540 ("SJCD: cannot load response about TOC finish.\n");
541 return (-1);
542 }
543 sjcd_last_track_no = bcd2bin(info.un.track_no);
544 } else {
545 printk("SJCD: get last failed\n");
546 return (-1);
547 }
548#if defined( SJCD_TRACE )
549 printk("SJCD: TOC finish 0x%02x ", sjcd_last_track_no);
550#endif
551 for (i = sjcd_first_track_no; i <= sjcd_last_track_no; i++) {
552
553
554
555 sjcd_send_1_cmd(SCMD_GET_DISK_INFO, bin2bcd(i));
556 sjcd_receive_status();
557
558 if (!sjcd_status_valid) {
559 printk("SJCD: cannot load status.\n");
560 return (-1);
561 }
562
563 if (!sjcd_media_is_available) {
564 printk("SJCD: no disk in drive\n");
565 return (-1);
566 }
567
568 if (!sjcd_command_failed) {
569 if (sjcd_load_response(&sjcd_table_of_contents[i],
570 sizeof(struct
571 sjcd_hw_disk_info))
572 != 0) {
573 printk
574 ("SJCD: cannot load info for %d track\n",
575 i);
576 return (-1);
577 }
578 } else {
579 printk("SJCD: get info %d failed\n", i);
580 return (-1);
581 }
582 }
583
584
585
586
587 sjcd_send_1_cmd(SCMD_GET_DISK_INFO, SCMD_GET_D_SIZE);
588 sjcd_receive_status();
589
590 if (!sjcd_status_valid) {
591 printk("SJCD: cannot load status.\n");
592 return (-1);
593 }
594
595 if (!sjcd_media_is_available) {
596 printk("SJCD: no disk in drive\n");
597 return (-1);
598 }
599
600 if (!sjcd_command_failed) {
601 if (sjcd_load_response(&info, sizeof(info)) != 0) {
602 printk
603 ("SJCD: cannot load response about disk size.\n");
604 return (-1);
605 }
606 sjcd_disk_length.min = info.un.track_msf.min;
607 sjcd_disk_length.sec = info.un.track_msf.sec;
608 sjcd_disk_length.frame = info.un.track_msf.frame;
609 } else {
610 printk("SJCD: get size failed\n");
611 return (1);
612 }
613#if defined( SJCD_TRACE )
614 printk("SJCD: (%02x:%02x.%02x)\n", sjcd_disk_length.min,
615 sjcd_disk_length.sec, sjcd_disk_length.frame);
616#endif
617 return (0);
618}
619
620
621
622
623static int sjcd_get_q_info(struct sjcd_hw_qinfo *qp)
624{
625 int s;
626#if defined( SJCD_TRACE )
627 printk("SJCD: load sub q\n");
628#endif
629 sjcd_send_cmd(SCMD_GET_QINFO);
630 s = sjcd_receive_status();
631 if (s < 0 || sjcd_command_failed || !sjcd_status_valid) {
632 sjcd_send_cmd(0xF2);
633 s = sjcd_receive_status();
634 if (s < 0 || sjcd_command_failed || !sjcd_status_valid)
635 return (-1);
636 sjcd_send_cmd(SCMD_GET_QINFO);
637 s = sjcd_receive_status();
638 if (s < 0 || sjcd_command_failed || !sjcd_status_valid)
639 return (-1);
640 }
641 if (sjcd_media_is_available)
642 if (sjcd_load_response(qp, sizeof(*qp)) == 0)
643 return (0);
644 return (-1);
645}
646
647
648
649
650static int sjcd_play(struct sjcd_play_msf *mp)
651{
652 struct sjcd_play_msf msf;
653
654
655
656
657 sjcd_send_1_cmd(SCMD_SET_MODE, SCMD_MODE_PLAY);
658 if (sjcd_receive_status() < 0)
659 return (-1);
660
661
662
663
664 msf.start = mp->start;
665 msf.end.min = msf.end.sec = msf.end.frame = 0x00;
666 sjcd_send_6_cmd(SCMD_SEEK, &msf);
667 if (sjcd_receive_status() < 0)
668 return (-1);
669
670
671
672
673 sjcd_send_6_cmd(SCMD_PLAY, mp);
674 return (sjcd_receive_status());
675}
676
677
678
679
680static int sjcd_tray_close(void)
681{
682#if defined( SJCD_TRACE )
683 printk("SJCD: tray_close\n");
684#endif
685 sjcd_send_cmd(SCMD_CLOSE_TRAY);
686 return (sjcd_receive_status());
687}
688
689static int sjcd_tray_lock(void)
690{
691#if defined( SJCD_TRACE )
692 printk("SJCD: tray_lock\n");
693#endif
694 sjcd_send_cmd(SCMD_LOCK_TRAY);
695 return (sjcd_receive_status());
696}
697
698static int sjcd_tray_unlock(void)
699{
700#if defined( SJCD_TRACE )
701 printk("SJCD: tray_unlock\n");
702#endif
703 sjcd_send_cmd(SCMD_UNLOCK_TRAY);
704 return (sjcd_receive_status());
705}
706
707static int sjcd_tray_open(void)
708{
709#if defined( SJCD_TRACE )
710 printk("SJCD: tray_open\n");
711#endif
712 sjcd_send_cmd(SCMD_EJECT_TRAY);
713 return (sjcd_receive_status());
714}
715
716
717
718
719static int sjcd_ioctl(struct inode *ip, struct file *fp,
720 unsigned int cmd, unsigned long arg)
721{
722#if defined( SJCD_TRACE )
723 printk("SJCD:ioctl\n");
724#endif
725
726 if (ip == NULL)
727 return (-EINVAL);
728
729 sjcd_get_status();
730 if (!sjcd_status_valid)
731 return (-EIO);
732 if (sjcd_update_toc() < 0)
733 return (-EIO);
734
735 switch (cmd) {
736 case CDROMSTART:{
737#if defined( SJCD_TRACE )
738 printk("SJCD: ioctl: start\n");
739#endif
740 return (0);
741 }
742
743 case CDROMSTOP:{
744#if defined( SJCD_TRACE )
745 printk("SJCD: ioctl: stop\n");
746#endif
747 sjcd_send_cmd(SCMD_PAUSE);
748 (void) sjcd_receive_status();
749 sjcd_audio_status = CDROM_AUDIO_NO_STATUS;
750 return (0);
751 }
752
753 case CDROMPAUSE:{
754 struct sjcd_hw_qinfo q_info;
755#if defined( SJCD_TRACE )
756 printk("SJCD: ioctl: pause\n");
757#endif
758 if (sjcd_audio_status == CDROM_AUDIO_PLAY) {
759 sjcd_send_cmd(SCMD_PAUSE);
760 (void) sjcd_receive_status();
761 if (sjcd_get_q_info(&q_info) < 0) {
762 sjcd_audio_status =
763 CDROM_AUDIO_NO_STATUS;
764 } else {
765 sjcd_audio_status =
766 CDROM_AUDIO_PAUSED;
767 sjcd_playing.start = q_info.abs;
768 }
769 return (0);
770 } else
771 return (-EINVAL);
772 }
773
774 case CDROMRESUME:{
775#if defined( SJCD_TRACE )
776 printk("SJCD: ioctl: resume\n");
777#endif
778 if (sjcd_audio_status == CDROM_AUDIO_PAUSED) {
779
780
781
782 if (sjcd_play(&sjcd_playing) < 0) {
783 sjcd_audio_status =
784 CDROM_AUDIO_ERROR;
785 return (-EIO);
786 } else {
787 sjcd_audio_status =
788 CDROM_AUDIO_PLAY;
789 return (0);
790 }
791 } else
792 return (-EINVAL);
793 }
794
795 case CDROMPLAYTRKIND:{
796 struct cdrom_ti ti;
797 int s;
798#if defined( SJCD_TRACE )
799 printk("SJCD: ioctl: playtrkind\n");
800#endif
801 if ((s =
802 verify_area(VERIFY_READ, (void *) arg,
803 sizeof(ti))) == 0) {
804 copy_from_user(&ti, (void *) arg,
805 sizeof(ti));
806
807 if (ti.cdti_trk0 < sjcd_first_track_no)
808 return (-EINVAL);
809 if (ti.cdti_trk1 > sjcd_last_track_no)
810 ti.cdti_trk1 = sjcd_last_track_no;
811 if (ti.cdti_trk0 > ti.cdti_trk1)
812 return (-EINVAL);
813
814 sjcd_playing.start =
815 sjcd_table_of_contents[ti.cdti_trk0].
816 un.track_msf;
817 sjcd_playing.end =
818 (ti.cdti_trk1 <
819 sjcd_last_track_no) ?
820 sjcd_table_of_contents[ti.cdti_trk1 +
821 1].un.
822 track_msf : sjcd_table_of_contents[0].
823 un.track_msf;
824
825 if (sjcd_play(&sjcd_playing) < 0) {
826 sjcd_audio_status =
827 CDROM_AUDIO_ERROR;
828 return (-EIO);
829 } else
830 sjcd_audio_status =
831 CDROM_AUDIO_PLAY;
832 }
833 return (s);
834 }
835
836 case CDROMPLAYMSF:{
837 struct cdrom_msf sjcd_msf;
838 int s;
839#if defined( SJCD_TRACE )
840 printk("SJCD: ioctl: playmsf\n");
841#endif
842 if ((s =
843 verify_area(VERIFY_READ, (void *) arg,
844 sizeof(sjcd_msf))) == 0) {
845 if (sjcd_audio_status == CDROM_AUDIO_PLAY) {
846 sjcd_send_cmd(SCMD_PAUSE);
847 (void) sjcd_receive_status();
848 sjcd_audio_status =
849 CDROM_AUDIO_NO_STATUS;
850 }
851
852 copy_from_user(&sjcd_msf, (void *) arg,
853 sizeof(sjcd_msf));
854
855 sjcd_playing.start.min =
856 bin2bcd(sjcd_msf.cdmsf_min0);
857 sjcd_playing.start.sec =
858 bin2bcd(sjcd_msf.cdmsf_sec0);
859 sjcd_playing.start.frame =
860 bin2bcd(sjcd_msf.cdmsf_frame0);
861 sjcd_playing.end.min =
862 bin2bcd(sjcd_msf.cdmsf_min1);
863 sjcd_playing.end.sec =
864 bin2bcd(sjcd_msf.cdmsf_sec1);
865 sjcd_playing.end.frame =
866 bin2bcd(sjcd_msf.cdmsf_frame1);
867
868 if (sjcd_play(&sjcd_playing) < 0) {
869 sjcd_audio_status =
870 CDROM_AUDIO_ERROR;
871 return (-EIO);
872 } else
873 sjcd_audio_status =
874 CDROM_AUDIO_PLAY;
875 }
876 return (s);
877 }
878
879 case CDROMREADTOCHDR:{
880 struct cdrom_tochdr toc_header;
881 int s;
882#if defined (SJCD_TRACE )
883 printk("SJCD: ioctl: readtocheader\n");
884#endif
885 if ((s =
886 verify_area(VERIFY_WRITE, (void *) arg,
887 sizeof(toc_header))) == 0) {
888 toc_header.cdth_trk0 = sjcd_first_track_no;
889 toc_header.cdth_trk1 = sjcd_last_track_no;
890 copy_to_user((void *) arg, &toc_header,
891 sizeof(toc_header));
892 }
893 return (s);
894 }
895
896 case CDROMREADTOCENTRY:{
897 struct cdrom_tocentry toc_entry;
898 int s;
899#if defined( SJCD_TRACE )
900 printk("SJCD: ioctl: readtocentry\n");
901#endif
902 if ((s =
903 verify_area(VERIFY_WRITE, (void *) arg,
904 sizeof(toc_entry))) == 0) {
905 struct sjcd_hw_disk_info *tp;
906
907 copy_from_user(&toc_entry, (void *) arg,
908 sizeof(toc_entry));
909
910 if (toc_entry.cdte_track == CDROM_LEADOUT)
911 tp = &sjcd_table_of_contents[0];
912 else if (toc_entry.cdte_track <
913 sjcd_first_track_no)
914 return (-EINVAL);
915 else if (toc_entry.cdte_track >
916 sjcd_last_track_no)
917 return (-EINVAL);
918 else
919 tp = &sjcd_table_of_contents
920 [toc_entry.cdte_track];
921
922 toc_entry.cdte_adr =
923 tp->track_control & 0x0F;
924 toc_entry.cdte_ctrl =
925 tp->track_control >> 4;
926
927 switch (toc_entry.cdte_format) {
928 case CDROM_LBA:
929 toc_entry.cdte_addr.lba =
930 msf2hsg(&(tp->un.track_msf));
931 break;
932 case CDROM_MSF:
933 toc_entry.cdte_addr.msf.minute =
934 bcd2bin(tp->un.track_msf.min);
935 toc_entry.cdte_addr.msf.second =
936 bcd2bin(tp->un.track_msf.sec);
937 toc_entry.cdte_addr.msf.frame =
938 bcd2bin(tp->un.track_msf.
939 frame);
940 break;
941 default:
942 return (-EINVAL);
943 }
944 copy_to_user((void *) arg, &toc_entry,
945 sizeof(toc_entry));
946 }
947 return (s);
948 }
949
950 case CDROMSUBCHNL:{
951 struct cdrom_subchnl subchnl;
952 int s;
953#if defined( SJCD_TRACE )
954 printk("SJCD: ioctl: subchnl\n");
955#endif
956 if ((s =
957 verify_area(VERIFY_WRITE, (void *) arg,
958 sizeof(subchnl))) == 0) {
959 struct sjcd_hw_qinfo q_info;
960
961 copy_from_user(&subchnl, (void *) arg,
962 sizeof(subchnl));
963 if (sjcd_get_q_info(&q_info) < 0)
964 return (-EIO);
965
966 subchnl.cdsc_audiostatus =
967 sjcd_audio_status;
968 subchnl.cdsc_adr =
969 q_info.track_control & 0x0F;
970 subchnl.cdsc_ctrl =
971 q_info.track_control >> 4;
972 subchnl.cdsc_trk =
973 bcd2bin(q_info.track_no);
974 subchnl.cdsc_ind = bcd2bin(q_info.x);
975
976 switch (subchnl.cdsc_format) {
977 case CDROM_LBA:
978 subchnl.cdsc_absaddr.lba =
979 msf2hsg(&(q_info.abs));
980 subchnl.cdsc_reladdr.lba =
981 msf2hsg(&(q_info.rel));
982 break;
983 case CDROM_MSF:
984 subchnl.cdsc_absaddr.msf.minute =
985 bcd2bin(q_info.abs.min);
986 subchnl.cdsc_absaddr.msf.second =
987 bcd2bin(q_info.abs.sec);
988 subchnl.cdsc_absaddr.msf.frame =
989 bcd2bin(q_info.abs.frame);
990 subchnl.cdsc_reladdr.msf.minute =
991 bcd2bin(q_info.rel.min);
992 subchnl.cdsc_reladdr.msf.second =
993 bcd2bin(q_info.rel.sec);
994 subchnl.cdsc_reladdr.msf.frame =
995 bcd2bin(q_info.rel.frame);
996 break;
997 default:
998 return (-EINVAL);
999 }
1000 copy_to_user((void *) arg, &subchnl,
1001 sizeof(subchnl));
1002 }
1003 return (s);
1004 }
1005
1006 case CDROMVOLCTRL:{
1007 struct cdrom_volctrl vol_ctrl;
1008 int s;
1009#if defined( SJCD_TRACE )
1010 printk("SJCD: ioctl: volctrl\n");
1011#endif
1012 if ((s =
1013 verify_area(VERIFY_READ, (void *) arg,
1014 sizeof(vol_ctrl))) == 0) {
1015 unsigned char dummy[4];
1016
1017 copy_from_user(&vol_ctrl, (void *) arg,
1018 sizeof(vol_ctrl));
1019 sjcd_send_4_cmd(SCMD_SET_VOLUME,
1020 vol_ctrl.channel0, 0xFF,
1021 vol_ctrl.channel1, 0xFF);
1022 if (sjcd_receive_status() < 0)
1023 return (-EIO);
1024 (void) sjcd_load_response(dummy, 4);
1025 }
1026 return (s);
1027 }
1028
1029 case CDROMEJECT:{
1030#if defined( SJCD_TRACE )
1031 printk("SJCD: ioctl: eject\n");
1032#endif
1033 if (!sjcd_command_is_in_progress) {
1034 sjcd_tray_unlock();
1035 sjcd_send_cmd(SCMD_EJECT_TRAY);
1036 (void) sjcd_receive_status();
1037 }
1038 return (0);
1039 }
1040
1041#if defined( SJCD_GATHER_STAT )
1042 case 0xABCD:{
1043 int s;
1044#if defined( SJCD_TRACE )
1045 printk("SJCD: ioctl: statistic\n");
1046#endif
1047 if ((s =
1048 verify_area(VERIFY_WRITE, (void *) arg,
1049 sizeof(statistic))) == 0)
1050 copy_to_user((void *) arg, &statistic,
1051 sizeof(statistic));
1052 return (s);
1053 }
1054#endif
1055
1056 default:
1057 return (-EINVAL);
1058 }
1059}
1060
1061
1062
1063
1064static void sjcd_invalidate_buffers(void)
1065{
1066 int i;
1067 for (i = 0; i < SJCD_BUF_SIZ; sjcd_buf_bn[i++] = -1);
1068 sjcd_buf_out = -1;
1069}
1070
1071
1072
1073
1074
1075
1076#define CURRENT_IS_VALID \
1077 ( !QUEUE_EMPTY && MAJOR( CURRENT->rq_dev ) == MAJOR_NR && \
1078 CURRENT->cmd == READ && CURRENT->sector != -1 )
1079
1080static void sjcd_transfer(void)
1081{
1082#if defined( SJCD_TRACE )
1083 printk("SJCD: transfer:\n");
1084#endif
1085 if (CURRENT_IS_VALID) {
1086 while (CURRENT->nr_sectors) {
1087 int i, bn = CURRENT->sector / 4;
1088 for (i = 0;
1089 i < SJCD_BUF_SIZ && sjcd_buf_bn[i] != bn;
1090 i++);
1091 if (i < SJCD_BUF_SIZ) {
1092 int offs =
1093 (i * 4 + (CURRENT->sector & 3)) * 512;
1094 int nr_sectors = 4 - (CURRENT->sector & 3);
1095 if (sjcd_buf_out != i) {
1096 sjcd_buf_out = i;
1097 if (sjcd_buf_bn[i] != bn) {
1098 sjcd_buf_out = -1;
1099 continue;
1100 }
1101 }
1102 if (nr_sectors > CURRENT->nr_sectors)
1103 nr_sectors = CURRENT->nr_sectors;
1104#if defined( SJCD_TRACE )
1105 printk("SJCD: copy out\n");
1106#endif
1107 memcpy(CURRENT->buffer, sjcd_buf + offs,
1108 nr_sectors * 512);
1109 CURRENT->nr_sectors -= nr_sectors;
1110 CURRENT->sector += nr_sectors;
1111 CURRENT->buffer += nr_sectors * 512;
1112 } else {
1113 sjcd_buf_out = -1;
1114 break;
1115 }
1116 }
1117 }
1118#if defined( SJCD_TRACE )
1119 printk("SJCD: transfer: done\n");
1120#endif
1121}
1122
1123static void sjcd_poll(void)
1124{
1125#if defined( SJCD_GATHER_STAT )
1126
1127
1128
1129 statistic.ticks++;
1130 statistic.tticks[sjcd_transfer_state]++;
1131#endif
1132
1133 ReSwitch:switch (sjcd_transfer_state) {
1134
1135 case SJCD_S_IDLE:{
1136#if defined( SJCD_GATHER_STAT )
1137 statistic.idle_ticks++;
1138#endif
1139#if defined( SJCD_TRACE )
1140 printk("SJCD_S_IDLE\n");
1141#endif
1142 return;
1143 }
1144
1145 case SJCD_S_START:{
1146#if defined( SJCD_GATHER_STAT )
1147 statistic.start_ticks++;
1148#endif
1149 sjcd_send_cmd(SCMD_GET_STATUS);
1150 sjcd_transfer_state =
1151 sjcd_mode ==
1152 SCMD_MODE_COOKED ? SJCD_S_READ : SJCD_S_MODE;
1153 sjcd_transfer_timeout = 500;
1154#if defined( SJCD_TRACE )
1155 printk("SJCD_S_START: goto SJCD_S_%s mode\n",
1156 sjcd_transfer_state ==
1157 SJCD_S_READ ? "READ" : "MODE");
1158#endif
1159 break;
1160 }
1161
1162 case SJCD_S_MODE:{
1163 if (sjcd_check_status()) {
1164
1165
1166
1167 if (!sjcd_status_valid
1168 || sjcd_command_failed) {
1169#if defined( SJCD_TRACE )
1170 printk
1171 ("SJCD_S_MODE: pre-cmd failed: goto to SJCD_S_STOP mode\n");
1172#endif
1173 sjcd_transfer_state = SJCD_S_STOP;
1174 goto ReSwitch;
1175 }
1176
1177 sjcd_mode = 0;
1178 sjcd_send_1_cmd(SCMD_SET_MODE,
1179 SCMD_MODE_COOKED);
1180 sjcd_transfer_state = SJCD_S_READ;
1181 sjcd_transfer_timeout = 1000;
1182#if defined( SJCD_TRACE )
1183 printk
1184 ("SJCD_S_MODE: goto SJCD_S_READ mode\n");
1185#endif
1186 }
1187#if defined( SJCD_GATHER_STAT )
1188 else
1189 statistic.mode_ticks++;
1190#endif
1191 break;
1192 }
1193
1194 case SJCD_S_READ:{
1195 if (sjcd_status_valid ? 1 : sjcd_check_status()) {
1196
1197
1198
1199 if (!sjcd_status_valid
1200 || sjcd_command_failed) {
1201#if defined( SJCD_TRACE )
1202 printk
1203 ("SJCD_S_READ: pre-cmd failed: goto to SJCD_S_STOP mode\n");
1204#endif
1205 sjcd_transfer_state = SJCD_S_STOP;
1206 goto ReSwitch;
1207 }
1208 if (!sjcd_media_is_available) {
1209#if defined( SJCD_TRACE )
1210 printk
1211 ("SJCD_S_READ: no disk: goto to SJCD_S_STOP mode\n");
1212#endif
1213 sjcd_transfer_state = SJCD_S_STOP;
1214 goto ReSwitch;
1215 }
1216 if (sjcd_mode != SCMD_MODE_COOKED) {
1217
1218
1219
1220 if (sjcd_load_response
1221 (&sjcd_mode, 1) != 0) {
1222#if defined( SJCD_TRACE )
1223 printk
1224 ("SJCD_S_READ: load failed: goto to SJCD_S_STOP mode\n");
1225#endif
1226 sjcd_transfer_state =
1227 SJCD_S_STOP;
1228 goto ReSwitch;
1229 }
1230 if (sjcd_mode != SCMD_MODE_COOKED) {
1231#if defined( SJCD_TRACE )
1232 printk
1233 ("SJCD_S_READ: mode failed: goto to SJCD_S_STOP mode\n");
1234#endif
1235 sjcd_transfer_state =
1236 SJCD_S_STOP;
1237 goto ReSwitch;
1238 }
1239 }
1240
1241 if (CURRENT_IS_VALID) {
1242 struct sjcd_play_msf msf;
1243
1244 sjcd_next_bn = CURRENT->sector / 4;
1245 hsg2msf(sjcd_next_bn, &msf.start);
1246 msf.end.min = 0;
1247 msf.end.sec = 0;
1248 msf.end.frame = sjcd_read_count =
1249 SJCD_BUF_SIZ;
1250#if defined( SJCD_TRACE )
1251 printk
1252 ("SJCD: ---reading msf-address %x:%x:%x %x:%x:%x\n",
1253 msf.start.min, msf.start.sec,
1254 msf.start.frame, msf.end.min,
1255 msf.end.sec, msf.end.frame);
1256 printk
1257 ("sjcd_next_bn:%x buf_in:%x buf_out:%x buf_bn:%x\n",
1258 sjcd_next_bn, sjcd_buf_in,
1259 sjcd_buf_out,
1260 sjcd_buf_bn[sjcd_buf_in]);
1261#endif
1262 sjcd_send_6_cmd(SCMD_DATA_READ,
1263 &msf);
1264 sjcd_transfer_state = SJCD_S_DATA;
1265 sjcd_transfer_timeout = 500;
1266#if defined( SJCD_TRACE )
1267 printk
1268 ("SJCD_S_READ: go to SJCD_S_DATA mode\n");
1269#endif
1270 } else {
1271#if defined( SJCD_TRACE )
1272 printk
1273 ("SJCD_S_READ: nothing to read: go to SJCD_S_STOP mode\n");
1274#endif
1275 sjcd_transfer_state = SJCD_S_STOP;
1276 goto ReSwitch;
1277 }
1278 }
1279#if defined( SJCD_GATHER_STAT )
1280 else
1281 statistic.read_ticks++;
1282#endif
1283 break;
1284 }
1285
1286 case SJCD_S_DATA:{
1287 unsigned char stat;
1288
1289 sjcd_s_data:stat =
1290 inb(SJCDPORT
1291 (1));
1292#if defined( SJCD_TRACE )
1293 printk("SJCD_S_DATA: status = 0x%02x\n", stat);
1294#endif
1295 if (SJCD_STATUS_AVAILABLE(stat)) {
1296
1297
1298
1299
1300 sjcd_load_status();
1301
1302 if (!sjcd_status_valid
1303 || sjcd_command_failed) {
1304#if defined( SJCD_TRACE )
1305 printk
1306 ("SJCD: read block %d failed, maybe audio disk? Giving up\n",
1307 sjcd_next_bn);
1308#endif
1309 if (CURRENT_IS_VALID)
1310 end_request(0);
1311#if defined( SJCD_TRACE )
1312 printk
1313 ("SJCD_S_DATA: pre-cmd failed: go to SJCD_S_STOP mode\n");
1314#endif
1315 sjcd_transfer_state = SJCD_S_STOP;
1316 goto ReSwitch;
1317 }
1318
1319 if (!sjcd_media_is_available) {
1320 printk
1321 ("SJCD_S_DATA: no disk: go to SJCD_S_STOP mode\n");
1322 sjcd_transfer_state = SJCD_S_STOP;
1323 goto ReSwitch;
1324 }
1325
1326 sjcd_transfer_state = SJCD_S_READ;
1327 goto ReSwitch;
1328 } else if (SJCD_DATA_AVAILABLE(stat)) {
1329
1330
1331
1332
1333
1334 if (!CURRENT_IS_VALID
1335 && sjcd_buf_in == sjcd_buf_out) {
1336#if defined( SJCD_TRACE )
1337 printk
1338 ("SJCD_S_DATA: nothing to read: go to SJCD_S_STOP mode\n");
1339 printk
1340 (" ... all the date would be discarded\n");
1341#endif
1342 sjcd_transfer_state = SJCD_S_STOP;
1343 goto ReSwitch;
1344 }
1345
1346
1347
1348
1349
1350 sjcd_buf_bn[sjcd_buf_in] = -1;
1351 insb(SJCDPORT(2),
1352 sjcd_buf + 2048 * sjcd_buf_in, 2048);
1353#if defined( SJCD_TRACE )
1354 printk
1355 ("SJCD_S_DATA: next_bn=%d, buf_in=%d, buf_out=%d, buf_bn=%d\n",
1356 sjcd_next_bn, sjcd_buf_in,
1357 sjcd_buf_out,
1358 sjcd_buf_bn[sjcd_buf_in]);
1359#endif
1360 sjcd_buf_bn[sjcd_buf_in] = sjcd_next_bn++;
1361 if (sjcd_buf_out == -1)
1362 sjcd_buf_out = sjcd_buf_in;
1363 if (++sjcd_buf_in == SJCD_BUF_SIZ)
1364 sjcd_buf_in = 0;
1365
1366
1367
1368
1369
1370 if (--sjcd_read_count == 0) {
1371
1372
1373
1374 if (!sjcd_transfer_is_active) {
1375 while (CURRENT_IS_VALID) {
1376
1377
1378
1379 sjcd_transfer();
1380 if (CURRENT->
1381 nr_sectors ==
1382 0)
1383 end_request
1384 (1);
1385 else
1386 break;
1387 }
1388 }
1389 if (CURRENT_IS_VALID &&
1390 (CURRENT->sector / 4 <
1391 sjcd_next_bn
1392 || CURRENT->sector / 4 >
1393 sjcd_next_bn +
1394 SJCD_BUF_SIZ)) {
1395#if defined( SJCD_TRACE )
1396 printk
1397 ("SJCD_S_DATA: can't read: go to SJCD_S_STOP mode\n");
1398#endif
1399 sjcd_transfer_state =
1400 SJCD_S_STOP;
1401 goto ReSwitch;
1402 }
1403 }
1404
1405
1406
1407 goto sjcd_s_data;
1408 }
1409#if defined( SJCD_GATHER_STAT )
1410 else
1411 statistic.data_ticks++;
1412#endif
1413 break;
1414 }
1415
1416 case SJCD_S_STOP:{
1417 sjcd_read_count = 0;
1418 sjcd_send_cmd(SCMD_STOP);
1419 sjcd_transfer_state = SJCD_S_STOPPING;
1420 sjcd_transfer_timeout = 500;
1421#if defined( SJCD_GATHER_STAT )
1422 statistic.stop_ticks++;
1423#endif
1424 break;
1425 }
1426
1427 case SJCD_S_STOPPING:{
1428 unsigned char stat;
1429
1430 stat = inb(SJCDPORT(1));
1431#if defined( SJCD_TRACE )
1432 printk("SJCD_S_STOP: status = 0x%02x\n", stat);
1433#endif
1434 if (SJCD_DATA_AVAILABLE(stat)) {
1435 int i;
1436#if defined( SJCD_TRACE )
1437 printk("SJCD_S_STOP: discard data\n");
1438#endif
1439
1440
1441
1442 for (i = 2048; i--;
1443 (void) inb(SJCDPORT(2)));
1444 sjcd_transfer_timeout = 500;
1445 } else if (SJCD_STATUS_AVAILABLE(stat)) {
1446 sjcd_load_status();
1447 if (sjcd_status_valid
1448 && sjcd_media_is_changed) {
1449 sjcd_toc_uptodate = 0;
1450 sjcd_invalidate_buffers();
1451 }
1452 if (CURRENT_IS_VALID) {
1453 if (sjcd_status_valid)
1454 sjcd_transfer_state =
1455 SJCD_S_READ;
1456 else
1457 sjcd_transfer_state =
1458 SJCD_S_START;
1459 } else
1460 sjcd_transfer_state = SJCD_S_IDLE;
1461 goto ReSwitch;
1462 }
1463#if defined( SJCD_GATHER_STAT )
1464 else
1465 statistic.stopping_ticks++;
1466#endif
1467 break;
1468 }
1469
1470 default:
1471 printk("SJCD: poll: invalid state %d\n",
1472 sjcd_transfer_state);
1473 return;
1474 }
1475
1476 if (--sjcd_transfer_timeout == 0) {
1477 printk("SJCD: timeout in state %d\n", sjcd_transfer_state);
1478 while (CURRENT_IS_VALID)
1479 end_request(0);
1480 sjcd_send_cmd(SCMD_STOP);
1481 sjcd_transfer_state = SJCD_S_IDLE;
1482 goto ReSwitch;
1483 }
1484
1485
1486
1487
1488
1489 SJCD_SET_TIMER(sjcd_poll, 1);
1490}
1491
1492static void do_sjcd_request(request_queue_t * q)
1493{
1494#if defined( SJCD_TRACE )
1495 printk("SJCD: do_sjcd_request(%ld+%ld)\n",
1496 CURRENT->sector, CURRENT->nr_sectors);
1497#endif
1498 sjcd_transfer_is_active = 1;
1499 while (CURRENT_IS_VALID) {
1500
1501
1502
1503 if (CURRENT->bh && !buffer_locked(CURRENT->bh))
1504 panic(DEVICE_NAME ": block not locked");
1505
1506 sjcd_transfer();
1507 if (CURRENT->nr_sectors == 0)
1508 end_request(1);
1509 else {
1510 sjcd_buf_out = -1;
1511 if (sjcd_transfer_state == SJCD_S_IDLE) {
1512 if (!sjcd_toc_uptodate) {
1513 if (sjcd_update_toc() < 0) {
1514 printk
1515 ("SJCD: transfer: discard\n");
1516 while (CURRENT_IS_VALID)
1517 end_request(0);
1518 break;
1519 }
1520 }
1521 sjcd_transfer_state = SJCD_S_START;
1522 SJCD_SET_TIMER(sjcd_poll, HZ / 100);
1523 }
1524 break;
1525 }
1526 }
1527 sjcd_transfer_is_active = 0;
1528#if defined( SJCD_TRACE )
1529 printk
1530 ("sjcd_next_bn:%x sjcd_buf_in:%x sjcd_buf_out:%x sjcd_buf_bn:%x\n",
1531 sjcd_next_bn, sjcd_buf_in, sjcd_buf_out,
1532 sjcd_buf_bn[sjcd_buf_in]);
1533 printk("do_sjcd_request ends\n");
1534#endif
1535}
1536
1537
1538
1539
1540int sjcd_open(struct inode *ip, struct file *fp)
1541{
1542
1543
1544
1545 if (!sjcd_present)
1546 return (-ENXIO);
1547
1548
1549
1550
1551 if (fp->f_mode & 2)
1552 return (-EROFS);
1553
1554 if (sjcd_open_count == 0) {
1555 int s, sjcd_open_tries;
1556
1557
1558
1559
1560 sjcd_mode = 0;
1561 sjcd_door_was_open = 0;
1562 sjcd_transfer_state = SJCD_S_IDLE;
1563 sjcd_invalidate_buffers();
1564 sjcd_status_valid = 0;
1565
1566
1567
1568
1569 for (sjcd_open_tries = 4; --sjcd_open_tries;) {
1570 if (!sjcd_status_valid)
1571 sjcd_get_status();
1572 if (!sjcd_status_valid) {
1573#if defined( SJCD_DIAGNOSTIC )
1574 printk
1575 ("SJCD: open: timed out when check status.\n");
1576#endif
1577 goto err_out;
1578 } else if (!sjcd_media_is_available) {
1579#if defined( SJCD_DIAGNOSTIC )
1580 printk("SJCD: open: no disk in drive\n");
1581#endif
1582 if (!sjcd_door_closed) {
1583 sjcd_door_was_open = 1;
1584#if defined( SJCD_TRACE )
1585 printk
1586 ("SJCD: open: close the tray\n");
1587#endif
1588 s = sjcd_tray_close();
1589 if (s < 0 || !sjcd_status_valid
1590 || sjcd_command_failed) {
1591#if defined( SJCD_DIAGNOSTIC )
1592 printk
1593 ("SJCD: open: tray close attempt failed\n");
1594#endif
1595 goto err_out;
1596 }
1597 continue;
1598 } else
1599 goto err_out;
1600 }
1601 break;
1602 }
1603 s = sjcd_tray_lock();
1604 if (s < 0 || !sjcd_status_valid || sjcd_command_failed) {
1605#if defined( SJCD_DIAGNOSTIC )
1606 printk("SJCD: open: tray lock attempt failed\n");
1607#endif
1608 goto err_out;
1609 }
1610#if defined( SJCD_TRACE )
1611 printk("SJCD: open: done\n");
1612#endif
1613 }
1614
1615 ++sjcd_open_count;
1616 return (0);
1617
1618 err_out:
1619 return (-EIO);
1620}
1621
1622
1623
1624
1625static int sjcd_release(struct inode *inode, struct file *file)
1626{
1627 int s;
1628
1629#if defined( SJCD_TRACE )
1630 printk("SJCD: release\n");
1631#endif
1632 if (--sjcd_open_count == 0) {
1633 sjcd_invalidate_buffers();
1634 s = sjcd_tray_unlock();
1635 if (s < 0 || !sjcd_status_valid || sjcd_command_failed) {
1636#if defined( SJCD_DIAGNOSTIC )
1637 printk
1638 ("SJCD: release: tray unlock attempt failed.\n");
1639#endif
1640 }
1641 if (sjcd_door_was_open) {
1642 s = sjcd_tray_open();
1643 if (s < 0 || !sjcd_status_valid
1644 || sjcd_command_failed) {
1645#if defined( SJCD_DIAGNOSTIC )
1646 printk
1647 ("SJCD: release: tray unload attempt failed.\n");
1648#endif
1649 }
1650 }
1651 }
1652 return 0;
1653}
1654
1655
1656
1657
1658static struct block_device_operations sjcd_fops = {
1659 owner:THIS_MODULE,
1660 open:sjcd_open,
1661 release:sjcd_release,
1662 ioctl:sjcd_ioctl,
1663 check_media_change:sjcd_disk_change,
1664};
1665
1666static int blksize = 2048;
1667static int secsize = 2048;
1668
1669
1670
1671
1672
1673
1674
1675static struct {
1676 unsigned char major, minor;
1677} sjcd_version;
1678
1679
1680
1681
1682
1683int __init sjcd_init(void)
1684{
1685 int i;
1686
1687 printk(KERN_INFO
1688 "SJCD: Sanyo CDR-H94A cdrom driver version %d.%d.\n",
1689 SJCD_VERSION_MAJOR, SJCD_VERSION_MINOR);
1690
1691#if defined( SJCD_TRACE )
1692 printk("SJCD: sjcd=0x%x: ", sjcd_base);
1693#endif
1694
1695 hardsect_size[MAJOR_NR] = &secsize;
1696 blksize_size[MAJOR_NR] = &blksize;
1697
1698 if (devfs_register_blkdev(MAJOR_NR, "sjcd", &sjcd_fops) != 0) {
1699 printk("SJCD: Unable to get major %d for Sanyo CD-ROM\n",
1700 MAJOR_NR);
1701 return (-EIO);
1702 }
1703
1704 blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), DEVICE_REQUEST);
1705 read_ahead[MAJOR_NR] = 4;
1706 register_disk(NULL, MKDEV(MAJOR_NR, 0), 1, &sjcd_fops, 0);
1707
1708 if (check_region(sjcd_base, 4)) {
1709 printk
1710 ("SJCD: Init failed, I/O port (%X) is already in use\n",
1711 sjcd_base);
1712 sjcd_cleanup();
1713 return (-EIO);
1714 }
1715
1716
1717
1718
1719
1720 printk(KERN_INFO "SJCD: Resetting: ");
1721 sjcd_send_cmd(SCMD_RESET);
1722 for (i = 1000; i > 0 && !sjcd_status_valid; --i) {
1723 unsigned long timer;
1724
1725
1726
1727
1728 for (timer = jiffies; time_before_eq(jiffies, timer););
1729 if ((i % 100) == 0)
1730 printk(".");
1731 (void) sjcd_check_status();
1732 }
1733 if (i == 0 || sjcd_command_failed) {
1734 printk(" reset failed, no drive found.\n");
1735 sjcd_cleanup();
1736 return (-EIO);
1737 } else
1738 printk("\n");
1739
1740
1741
1742
1743 printk(KERN_INFO "SJCD: Getting version: ");
1744 sjcd_send_cmd(SCMD_GET_VERSION);
1745 for (i = 1000; i > 0 && !sjcd_status_valid; --i) {
1746 unsigned long timer;
1747
1748
1749
1750
1751 for (timer = jiffies; time_before_eq(jiffies, timer););
1752 if ((i % 100) == 0)
1753 printk(".");
1754 (void) sjcd_check_status();
1755 }
1756 if (i == 0 || sjcd_command_failed) {
1757 printk(" get version failed, no drive found.\n");
1758 sjcd_cleanup();
1759 return (-EIO);
1760 }
1761
1762 if (sjcd_load_response(&sjcd_version, sizeof(sjcd_version)) == 0) {
1763 printk(" %1x.%02x\n", (int) sjcd_version.major,
1764 (int) sjcd_version.minor);
1765 } else {
1766 printk(" read version failed, no drive found.\n");
1767 sjcd_cleanup();
1768 return (-EIO);
1769 }
1770
1771
1772
1773
1774 if (!sjcd_status_valid) {
1775 printk(KERN_INFO "SJCD: Getting status: ");
1776 sjcd_send_cmd(SCMD_GET_STATUS);
1777 for (i = 1000; i > 0 && !sjcd_status_valid; --i) {
1778 unsigned long timer;
1779
1780
1781
1782
1783 for (timer = jiffies;
1784 time_before_eq(jiffies, timer););
1785 if ((i % 100) == 0)
1786 printk(".");
1787 (void) sjcd_check_status();
1788 }
1789 if (i == 0 || sjcd_command_failed) {
1790 printk(" get status failed, no drive found.\n");
1791 sjcd_cleanup();
1792 return (-EIO);
1793 } else
1794 printk("\n");
1795 }
1796
1797 printk(KERN_INFO "SJCD: Status: port=0x%x.\n", sjcd_base);
1798 devfs_register(NULL, "sjcd", DEVFS_FL_DEFAULT, MAJOR_NR, 0,
1799 S_IFBLK | S_IRUGO | S_IWUGO, &sjcd_fops, NULL);
1800
1801 sjcd_present++;
1802 return (0);
1803}
1804
1805static int sjcd_cleanup(void)
1806{
1807 if ((devfs_unregister_blkdev(MAJOR_NR, "sjcd") == -EINVAL))
1808 printk("SJCD: cannot unregister device.\n");
1809 else {
1810 release_region(sjcd_base, 4);
1811 blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
1812 }
1813
1814 return (0);
1815}
1816
1817
1818void __exit sjcd_exit(void)
1819{
1820 devfs_unregister(devfs_find_handle
1821 (NULL, "sjcd", 0, 0, DEVFS_SPECIAL_BLK, 0));
1822 if (sjcd_cleanup())
1823 printk("SJCD: module: cannot be removed.\n");
1824 else
1825 printk(KERN_INFO "SJCD: module: removed.\n");
1826}
1827
1828#ifdef MODULE
1829module_init(sjcd_init);
1830#endif
1831module_exit(sjcd_exit);
1832
1833
1834MODULE_LICENSE("GPL");
1835
