File: /usr/src/linux/drivers/cdrom/sjcd.c
1 /* -- sjcd.c
2 *
3 * Sanyo CD-ROM device driver implementation, Version 1.6
4 * Copyright (C) 1995 Vadim V. Model
5 *
6 * model@cecmow.enet.dec.com
7 * vadim@rbrf.ru
8 * vadim@ipsun.ras.ru
9 *
10 *
11 * This driver is based on pre-works by Eberhard Moenkeberg (emoenke@gwdg.de);
12 * it was developed under use of mcd.c from Martin Harriss, with help of
13 * Eric van der Maarel (H.T.M.v.d.Maarel@marin.nl).
14 *
15 * It is planned to include these routines into sbpcd.c later - to make
16 * a "mixed use" on one cable possible for all kinds of drives which use
17 * the SoundBlaster/Panasonic style CDROM interface. But today, the
18 * ability to install directly from CDROM is more important than flexibility.
19 *
20 * This program is free software; you can redistribute it and/or modify
21 * it under the terms of the GNU General Public License as published by
22 * the Free Software Foundation; either version 2 of the License, or
23 * (at your option) any later version.
24 *
25 * This program is distributed in the hope that it will be useful,
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 * GNU General Public License for more details.
29 *
30 * You should have received a copy of the GNU General Public License
31 * along with this program; if not, write to the Free Software
32 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33 *
34 * History:
35 * 1.1 First public release with kernel version 1.3.7.
36 * Written by Vadim Model.
37 * 1.2 Added detection and configuration of cdrom interface
38 * on ISP16 soundcard.
39 * Allow for command line options: sjcd=<io_base>,<irq>,<dma>
40 * 1.3 Some minor changes to README.sjcd.
41 * 1.4 MSS Sound support!! Listen to a CD through the speakers.
42 * 1.5 Module support and bugfixes.
43 * Tray locking.
44 * 1.6 Removed ISP16 code from this driver.
45 * Allow only to set io base address on command line: sjcd=<io_base>
46 * Changes to Documentation/cdrom/sjcd
47 * Added cleanup after any error in the initialisation.
48 * 1.7 Added code to set the sector size tables to prevent the bug present in
49 * the previous version of this driver. Coded added by Anthony Barbachan
50 * from bugfix tip originally suggested by Alan Cox.
51 *
52 * November 1999 -- Make kernel-parameter implementation work with 2.3.x
53 * Removed init_module & cleanup_module in favor of
54 * module_init & module_exit.
55 * Torben Mathiasen <tmm@image.dk>
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
83 static int sjcd_present = 0;
84
85 #define SJCD_BUF_SIZ 32 /* cdr-h94a has internal 64K buffer */
86
87 /*
88 * buffer for block size conversion
89 */
90 static char sjcd_buf[2048 * SJCD_BUF_SIZ];
91 static volatile int sjcd_buf_bn[SJCD_BUF_SIZ], sjcd_next_bn;
92 static volatile int sjcd_buf_in, sjcd_buf_out = -1;
93
94 /*
95 * Status.
96 */
97 static unsigned short sjcd_status_valid = 0;
98 static unsigned short sjcd_door_closed;
99 static unsigned short sjcd_door_was_open;
100 static unsigned short sjcd_media_is_available;
101 static unsigned short sjcd_media_is_changed;
102 static unsigned short sjcd_toc_uptodate = 0;
103 static unsigned short sjcd_command_failed;
104 static volatile unsigned char sjcd_completion_status = 0;
105 static volatile unsigned char sjcd_completion_error = 0;
106 static unsigned short sjcd_command_is_in_progress = 0;
107 static unsigned short sjcd_error_reported = 0;
108
109 static int sjcd_open_count;
110
111 static int sjcd_audio_status;
112 static struct sjcd_play_msf sjcd_playing;
113
114 static int sjcd_base = SJCD_BASE_ADDR;
115
116 MODULE_PARM(sjcd_base, "i");
117
118 static DECLARE_WAIT_QUEUE_HEAD(sjcd_waitq);
119
120 /*
121 * Data transfer.
122 */
123 static volatile unsigned short sjcd_transfer_is_active = 0;
124
125 enum 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 };
134 static enum sjcd_transfer_state sjcd_transfer_state = SJCD_S_IDLE;
135 static long sjcd_transfer_timeout = 0;
136 static int sjcd_read_count = 0;
137 static unsigned char sjcd_mode = 0;
138
139 #define SJCD_READ_TIMEOUT 5000
140
141 #if defined( SJCD_GATHER_STAT )
142 /*
143 * Statistic.
144 */
145 static struct sjcd_stat statistic;
146 #endif
147
148 /*
149 * Timer.
150 */
151 static 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
160 static int sjcd_cleanup(void);
161
162 /*
163 * Set up device, i.e., use command line data to set
164 * base address.
165 */
166 #ifndef MODULE
167 static 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 * Special converters.
183 */
184 static 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
193 static int bcd2bin(unsigned char bcd)
194 {
195 return ((bcd >> 4) * 10 + (bcd & 0x0F));
196 }
197
198 static long msf2hsg(struct msf *mp)
199 {
200 return (bcd2bin(mp->frame) + bcd2bin(mp->sec) * 75
201 + bcd2bin(mp->min) * 4500 - 150);
202 }
203
204 static 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); /* convert to BCD */
212 msf->sec = bin2bcd(msf->sec);
213 msf->frame = bin2bcd(msf->frame);
214 }
215
216 /*
217 * Send a command to cdrom. Invalidate status.
218 */
219 static 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 * Send a command with one arg to cdrom. Invalidate status.
232 */
233 static 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 * Send a command with four args to cdrom. Invalidate status.
247 */
248 static 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 * Send a play or read command to cdrom. Invalidate Status.
267 */
268 static 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 * Get a value from the data port. Should not block, so we use a little
287 * wait for a while. Returns 0 if OK.
288 */
289 static 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 * Load and parse command completion status (drive info byte and maybe error).
307 * Sorry, no error classification yet.
308 */
309 static 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 * OK, we seem to catch an error ...
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 * Ok, status loaded successfully.
337 */
338 sjcd_status_valid = 1, sjcd_error_reported = 0;
339 sjcd_command_is_in_progress = 0;
340
341 /*
342 * If the disk is changed, the TOC is not valid.
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 * Read status from cdrom. Check to see if the status is available.
354 */
355 static int sjcd_check_status(void)
356 {
357 /*
358 * Try to load the response from cdrom into buffer.
359 */
360 if (SJCD_STATUS_AVAILABLE(inb(SJCDPORT(1)))) {
361 sjcd_load_status();
362 return (1);
363 } else {
364 /*
365 * No status is available.
366 */
367 return (0);
368 }
369 }
370
371 /*
372 * This is just timeout counter, and nothing more. Surprised ? :-)
373 */
374 static volatile long sjcd_status_timeout;
375
376 /*
377 * We need about 10 seconds to wait. The longest command takes about 5 seconds
378 * to probe the disk (usually after tray closed or drive reset). Other values
379 * should be thought of for other commands.
380 */
381 #define SJCD_WAIT_FOR_STATUS_TIMEOUT 1000
382
383 static void sjcd_status_timer(void)
384 {
385 if (sjcd_check_status()) {
386 /*
387 * The command completed and status is loaded, stop waiting.
388 */
389 wake_up(&sjcd_waitq);
390 } else if (--sjcd_status_timeout <= 0) {
391 /*
392 * We are timed out.
393 */
394 wake_up(&sjcd_waitq);
395 } else {
396 /*
397 * We have still some time to wait. Try again.
398 */
399 SJCD_SET_TIMER(sjcd_status_timer, 1);
400 }
401 }
402
403 /*
404 * Wait for status for 10 sec approx. Returns non-positive when timed out.
405 * Should not be used while reading data CDs.
406 */
407 static 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
419 static int sjcd_receive_status(void)
420 {
421 int i;
422 #if defined( SJCD_TRACE )
423 printk("SJCD: receive_status\n");
424 #endif
425 /*
426 * Wait a bit for status available.
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 * Load the status. Issue get status command and wait for status available.
443 */
444 static 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 * Check the drive if the disk is changed. Should be revised.
455 */
456 static 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 * Read the table of contents (TOC) and TOC header if necessary.
472 * We assume that the drive contains no more than 99 toc entries.
473 */
474 static struct sjcd_hw_disk_info sjcd_table_of_contents[SJCD_MAX_TRACKS];
475 static unsigned char sjcd_first_track_no, sjcd_last_track_no;
476 #define sjcd_disk_length sjcd_table_of_contents[0].un.track_msf
477
478 static 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 * check to see if we need to do anything
487 */
488 if (sjcd_toc_uptodate)
489 return (0);
490
491 /*
492 * Get the TOC start information.
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 * Get the TOC finish information.
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 * Get the first track information.
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 * Get the disk length info.
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 * Load subchannel information.
622 */
623 static 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 * Start playing from the specified position.
649 */
650 static int sjcd_play(struct sjcd_play_msf *mp)
651 {
652 struct sjcd_play_msf msf;
653
654 /*
655 * Turn the device to play mode.
656 */
657 sjcd_send_1_cmd(SCMD_SET_MODE, SCMD_MODE_PLAY);
658 if (sjcd_receive_status() < 0)
659 return (-1);
660
661 /*
662 * Seek to the starting point.
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 * Start playing.
672 */
673 sjcd_send_6_cmd(SCMD_PLAY, mp);
674 return (sjcd_receive_status());
675 }
676
677 /*
678 * Tray control functions.
679 */
680 static 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
689 static 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
698 static 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
707 static 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 * Do some user commands.
718 */
719 static 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 * continue play starting at saved location
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 * Invalidate internal buffers of the driver.
1063 */
1064 static 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 * Take care of the different block sizes between cdrom and Linux.
1073 * When Linux gets variable block sizes this will probably go away.
1074 */
1075
1076 #define CURRENT_IS_VALID \
1077 ( !QUEUE_EMPTY && MAJOR( CURRENT->rq_dev ) == MAJOR_NR && \
1078 CURRENT->cmd == READ && CURRENT->sector != -1 )
1079
1080 static 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
1123 static void sjcd_poll(void)
1124 {
1125 #if defined( SJCD_GATHER_STAT )
1126 /*
1127 * Update total number of ticks.
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 * Previous command is completed.
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; /* unknown mode; should not be valid when failed */
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 * Previous command is completed.
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 * We seem to come from set mode. So discard one byte of result.
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 * No data is waiting for us in the drive buffer. Status of operation
1298 * completion is available. Read and parse it.
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 * One frame is read into device buffer. We must copy it to our memory.
1331 * Otherwise cdrom hangs up. Check to see if we have something to copy
1332 * to.
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 * Everything seems to be OK. Just read the frame and recalculate
1348 * indices.
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 * Only one frame is ready at time. So we should turn over to wait for
1368 * another frame. If we need that, of course.
1369 */
1370 if (--sjcd_read_count == 0) {
1371 /*
1372 * OK, request seems to be precessed. Continue transferring...
1373 */
1374 if (!sjcd_transfer_is_active) {
1375 while (CURRENT_IS_VALID) {
1376 /*
1377 * Continue transferring.
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 * Now we should turn around rather than wait for while.
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 * Discard all the data from the pipe. Foolish method.
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 * Get back in some time. 1 should be replaced with count variable to
1487 * avoid unnecessary testings.
1488 */
1489 SJCD_SET_TIMER(sjcd_poll, 1);
1490 }
1491
1492 static 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 * Who of us are paranoiac?
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; /* Want to read a block not in buffer */
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 * Open the device special file. Check disk is in.
1539 */
1540 int sjcd_open(struct inode *ip, struct file *fp)
1541 {
1542 /*
1543 * Check the presence of device.
1544 */
1545 if (!sjcd_present)
1546 return (-ENXIO);
1547
1548 /*
1549 * Only read operations are allowed. Really? (:-)
1550 */
1551 if (fp->f_mode & 2)
1552 return (-EROFS);
1553
1554 MOD_INC_USE_COUNT;
1555
1556 if (sjcd_open_count == 0) {
1557 int s, sjcd_open_tries;
1558 /* We don't know that, do we? */
1559 /*
1560 sjcd_audio_status = CDROM_AUDIO_NO_STATUS;
1561 */
1562 sjcd_mode = 0;
1563 sjcd_door_was_open = 0;
1564 sjcd_transfer_state = SJCD_S_IDLE;
1565 sjcd_invalidate_buffers();
1566 sjcd_status_valid = 0;
1567
1568 /*
1569 * Strict status checking.
1570 */
1571 for (sjcd_open_tries = 4; --sjcd_open_tries;) {
1572 if (!sjcd_status_valid)
1573 sjcd_get_status();
1574 if (!sjcd_status_valid) {
1575 #if defined( SJCD_DIAGNOSTIC )
1576 printk
1577 ("SJCD: open: timed out when check status.\n");
1578 #endif
1579 goto err_out;
1580 } else if (!sjcd_media_is_available) {
1581 #if defined( SJCD_DIAGNOSTIC )
1582 printk("SJCD: open: no disk in drive\n");
1583 #endif
1584 if (!sjcd_door_closed) {
1585 sjcd_door_was_open = 1;
1586 #if defined( SJCD_TRACE )
1587 printk
1588 ("SJCD: open: close the tray\n");
1589 #endif
1590 s = sjcd_tray_close();
1591 if (s < 0 || !sjcd_status_valid
1592 || sjcd_command_failed) {
1593 #if defined( SJCD_DIAGNOSTIC )
1594 printk
1595 ("SJCD: open: tray close attempt failed\n");
1596 #endif
1597 goto err_out;
1598 }
1599 continue;
1600 } else
1601 goto err_out;
1602 }
1603 break;
1604 }
1605 s = sjcd_tray_lock();
1606 if (s < 0 || !sjcd_status_valid || sjcd_command_failed) {
1607 #if defined( SJCD_DIAGNOSTIC )
1608 printk("SJCD: open: tray lock attempt failed\n");
1609 #endif
1610 goto err_out;
1611 }
1612 #if defined( SJCD_TRACE )
1613 printk("SJCD: open: done\n");
1614 #endif
1615 }
1616
1617 ++sjcd_open_count;
1618 return (0);
1619
1620 err_out:
1621 MOD_DEC_USE_COUNT;
1622 return (-EIO);
1623 }
1624
1625 /*
1626 * On close, we flush all sjcd blocks from the buffer cache.
1627 */
1628 static int sjcd_release(struct inode *inode, struct file *file)
1629 {
1630 int s;
1631
1632 #if defined( SJCD_TRACE )
1633 printk("SJCD: release\n");
1634 #endif
1635 #ifdef MODULE
1636 MOD_DEC_USE_COUNT;
1637 #endif
1638 if (--sjcd_open_count == 0) {
1639 sjcd_invalidate_buffers();
1640 s = sjcd_tray_unlock();
1641 if (s < 0 || !sjcd_status_valid || sjcd_command_failed) {
1642 #if defined( SJCD_DIAGNOSTIC )
1643 printk
1644 ("SJCD: release: tray unlock attempt failed.\n");
1645 #endif
1646 }
1647 if (sjcd_door_was_open) {
1648 s = sjcd_tray_open();
1649 if (s < 0 || !sjcd_status_valid
1650 || sjcd_command_failed) {
1651 #if defined( SJCD_DIAGNOSTIC )
1652 printk
1653 ("SJCD: release: tray unload attempt failed.\n");
1654 #endif
1655 }
1656 }
1657 }
1658 return 0;
1659 }
1660
1661 /*
1662 * A list of file operations allowed for this cdrom.
1663 */
1664 static struct block_device_operations sjcd_fops = {
1665 open:sjcd_open,
1666 release:sjcd_release,
1667 ioctl:sjcd_ioctl,
1668 check_media_change:sjcd_disk_change,
1669 };
1670
1671 static int blksize = 2048;
1672 static int secsize = 2048;
1673
1674 /*
1675 * Following stuff is intended for initialization of the cdrom. It
1676 * first looks for presence of device. If the device is present, it
1677 * will be reset. Then read the version of the drive and load status.
1678 * The version is two BCD-coded bytes.
1679 */
1680 static struct {
1681 unsigned char major, minor;
1682 } sjcd_version;
1683
1684 /*
1685 * Test for presence of drive and initialize it. Called at boot time.
1686 * Probe cdrom, find out version and status.
1687 */
1688 int __init sjcd_init(void)
1689 {
1690 int i;
1691
1692 printk(KERN_INFO
1693 "SJCD: Sanyo CDR-H94A cdrom driver version %d.%d.\n",
1694 SJCD_VERSION_MAJOR, SJCD_VERSION_MINOR);
1695
1696 #if defined( SJCD_TRACE )
1697 printk("SJCD: sjcd=0x%x: ", sjcd_base);
1698 #endif
1699
1700 hardsect_size[MAJOR_NR] = &secsize;
1701 blksize_size[MAJOR_NR] = &blksize;
1702
1703 if (devfs_register_blkdev(MAJOR_NR, "sjcd", &sjcd_fops) != 0) {
1704 printk("SJCD: Unable to get major %d for Sanyo CD-ROM\n",
1705 MAJOR_NR);
1706 return (-EIO);
1707 }
1708
1709 blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR), DEVICE_REQUEST);
1710 read_ahead[MAJOR_NR] = 4;
1711 register_disk(NULL, MKDEV(MAJOR_NR, 0), 1, &sjcd_fops, 0);
1712
1713 if (check_region(sjcd_base, 4)) {
1714 printk
1715 ("SJCD: Init failed, I/O port (%X) is already in use\n",
1716 sjcd_base);
1717 sjcd_cleanup();
1718 return (-EIO);
1719 }
1720
1721 /*
1722 * Check for card. Since we are booting now, we can't use standard
1723 * wait algorithm.
1724 */
1725 printk(KERN_INFO "SJCD: Resetting: ");
1726 sjcd_send_cmd(SCMD_RESET);
1727 for (i = 1000; i > 0 && !sjcd_status_valid; --i) {
1728 unsigned long timer;
1729
1730 /*
1731 * Wait 10ms approx.
1732 */
1733 for (timer = jiffies; time_before_eq(jiffies, timer););
1734 if ((i % 100) == 0)
1735 printk(".");
1736 (void) sjcd_check_status();
1737 }
1738 if (i == 0 || sjcd_command_failed) {
1739 printk(" reset failed, no drive found.\n");
1740 sjcd_cleanup();
1741 return (-EIO);
1742 } else
1743 printk("\n");
1744
1745 /*
1746 * Get and print out cdrom version.
1747 */
1748 printk(KERN_INFO "SJCD: Getting version: ");
1749 sjcd_send_cmd(SCMD_GET_VERSION);
1750 for (i = 1000; i > 0 && !sjcd_status_valid; --i) {
1751 unsigned long timer;
1752
1753 /*
1754 * Wait 10ms approx.
1755 */
1756 for (timer = jiffies; time_before_eq(jiffies, timer););
1757 if ((i % 100) == 0)
1758 printk(".");
1759 (void) sjcd_check_status();
1760 }
1761 if (i == 0 || sjcd_command_failed) {
1762 printk(" get version failed, no drive found.\n");
1763 sjcd_cleanup();
1764 return (-EIO);
1765 }
1766
1767 if (sjcd_load_response(&sjcd_version, sizeof(sjcd_version)) == 0) {
1768 printk(" %1x.%02x\n", (int) sjcd_version.major,
1769 (int) sjcd_version.minor);
1770 } else {
1771 printk(" read version failed, no drive found.\n");
1772 sjcd_cleanup();
1773 return (-EIO);
1774 }
1775
1776 /*
1777 * Check and print out the tray state. (if it is needed?).
1778 */
1779 if (!sjcd_status_valid) {
1780 printk(KERN_INFO "SJCD: Getting status: ");
1781 sjcd_send_cmd(SCMD_GET_STATUS);
1782 for (i = 1000; i > 0 && !sjcd_status_valid; --i) {
1783 unsigned long timer;
1784
1785 /*
1786 * Wait 10ms approx.
1787 */
1788 for (timer = jiffies;
1789 time_before_eq(jiffies, timer););
1790 if ((i % 100) == 0)
1791 printk(".");
1792 (void) sjcd_check_status();
1793 }
1794 if (i == 0 || sjcd_command_failed) {
1795 printk(" get status failed, no drive found.\n");
1796 sjcd_cleanup();
1797 return (-EIO);
1798 } else
1799 printk("\n");
1800 }
1801
1802 printk(KERN_INFO "SJCD: Status: port=0x%x.\n", sjcd_base);
1803 devfs_register(NULL, "sjcd", DEVFS_FL_DEFAULT, MAJOR_NR, 0,
1804 S_IFBLK | S_IRUGO | S_IWUGO, &sjcd_fops, NULL);
1805
1806 sjcd_present++;
1807 return (0);
1808 }
1809
1810 static int sjcd_cleanup(void)
1811 {
1812 if ((devfs_unregister_blkdev(MAJOR_NR, "sjcd") == -EINVAL))
1813 printk("SJCD: cannot unregister device.\n");
1814 else {
1815 release_region(sjcd_base, 4);
1816 blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR));
1817 }
1818
1819 return (0);
1820 }
1821
1822
1823 void __exit sjcd_exit(void)
1824 {
1825 devfs_unregister(devfs_find_handle
1826 (NULL, "sjcd", 0, 0, DEVFS_SPECIAL_BLK, 0));
1827 if (sjcd_cleanup())
1828 printk("SJCD: module: cannot be removed.\n");
1829 else
1830 printk(KERN_INFO "SJCD: module: removed.\n");
1831 }
1832
1833 #ifdef MODULE
1834 module_init(sjcd_init);
1835 #endif
1836 module_exit(sjcd_exit);
1837
1838
1839 MODULE_LICENSE("GPL");
1840