]> git.ipfire.org Git - thirdparty/linux.git/blob - drivers/cdrom/aztcd.c
projects / thirdparty / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Linux-2.6.12-rc2
[thirdparty/linux.git] / drivers / cdrom / aztcd.c
1 #define AZT_VERSION "2.60"
2
3 /* $Id: aztcd.c,v 2.60 1997/11/29 09:51:19 root Exp root $
4 linux/drivers/block/aztcd.c - Aztech CD268 CDROM driver
5
6 Copyright (C) 1994-98 Werner Zimmermann(Werner.Zimmermann@fht-esslingen.de)
7
8 based on Mitsumi CDROM driver by Martin Hariss and preworks by
9 Eberhard Moenkeberg; contains contributions by Joe Nardone and Robby
10 Schirmer.
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2, or (at your option)
15 any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25
26 HISTORY
27 V0.0 Adaption to Aztech CD268-01A Version 1.3
28 Version is PRE_ALPHA, unresolved points:
29 1. I use busy wait instead of timer wait in STEN_LOW,DTEN_LOW
30 thus driver causes CPU overhead and is very slow
31 2. could not find a way to stop the drive, when it is
32 in data read mode, therefore I had to set
33 msf.end.min/sec/frame to 0:0:1 (in azt_poll); so only one
34 frame can be read in sequence, this is also the reason for
35 3. getting 'timeout in state 4' messages, but nevertheless
36 it works
37 W.Zimmermann, Oct. 31, 1994
38 V0.1 Version is ALPHA, problems #2 and #3 resolved.
39 W.Zimmermann, Nov. 3, 1994
40 V0.2 Modification to some comments, debugging aids for partial test
41 with Borland C under DOS eliminated. Timer interrupt wait
42 STEN_LOW_WAIT additionally to busy wait for STEN_LOW implemented;
43 use it only for the 'slow' commands (ACMD_GET_Q_CHANNEL, ACMD_
44 SEEK_TO_LEAD_IN), all other commands are so 'fast', that busy
45 waiting seems better to me than interrupt rescheduling.
46 Besides that, when used in the wrong place, STEN_LOW_WAIT causes
47 kernel panic.
48 In function aztPlay command ACMD_PLAY_AUDIO added, should make
49 audio functions work. The Aztech drive needs different commands
50 to read data tracks and play audio tracks.
51 W.Zimmermann, Nov. 8, 1994
52 V0.3 Recognition of missing drive during boot up improved (speeded up).
53 W.Zimmermann, Nov. 13, 1994
54 V0.35 Rewrote the control mechanism in azt_poll (formerly mcd_poll)
55 including removal of all 'goto' commands. :-);
56 J. Nardone, Nov. 14, 1994
57 V0.4 Renamed variables and constants to 'azt' instead of 'mcd'; had
58 to make some "compatibility" defines in azt.h; please note,
59 that the source file was renamed to azt.c, the include file to
60 azt.h
61 Speeded up drive recognition during init (will be a little bit
62 slower than before if no drive is installed!); suggested by
63 Robby Schirmer.
64 read_count declared volatile and set to AZT_BUF_SIZ to make
65 drive faster (now 300kB/sec, was 60kB/sec before, measured
66 by 'time dd if=/dev/cdrom of=/dev/null bs=2048 count=4096';
67 different AZT_BUF_SIZes were test, above 16 no further im-
68 provement seems to be possible; suggested by E.Moenkeberg.
69 W.Zimmermann, Nov. 18, 1994
70 V0.42 Included getAztStatus command in GetQChannelInfo() to allow
71 reading Q-channel info on audio disks, if drive is stopped,
72 and some other bug fixes in the audio stuff, suggested by
73 Robby Schirmer.
74 Added more ioctls (reading data in mode 1 and mode 2).
75 Completely removed the old azt_poll() routine.
76 Detection of ORCHID CDS-3110 in aztcd_init implemented.
77 Additional debugging aids (see the readme file).
78 W.Zimmermann, Dec. 9, 1994
79 V0.50 Autodetection of drives implemented.
80 W.Zimmermann, Dec. 12, 1994
81 V0.52 Prepared for including in the standard kernel, renamed most
82 variables to contain 'azt', included autoconf.h
83 W.Zimmermann, Dec. 16, 1994
84 V0.6 Version for being included in the standard Linux kernel.
85 Renamed source and header file to aztcd.c and aztcd.h
86 W.Zimmermann, Dec. 24, 1994
87 V0.7 Changed VERIFY_READ to VERIFY_WRITE in aztcd_ioctl, case
88 CDROMREADMODE1 and CDROMREADMODE2; bug fix in the ioctl,
89 which causes kernel crashes when playing audio, changed
90 include-files (config.h instead of autoconf.h, removed
91 delay.h)
92 W.Zimmermann, Jan. 8, 1995
93 V0.72 Some more modifications for adaption to the standard kernel.
94 W.Zimmermann, Jan. 16, 1995
95 V0.80 aztcd is now part of the standard kernel since version 1.1.83.
96 Modified the SET_TIMER and CLEAR_TIMER macros to comply with
97 the new timer scheme.
98 W.Zimmermann, Jan. 21, 1995
99 V0.90 Included CDROMVOLCTRL, but with my Aztech drive I can only turn
100 the channels on and off. If it works better with your drive,
101 please mail me. Also implemented ACMD_CLOSE for CDROMSTART.
102 W.Zimmermann, Jan. 24, 1995
103 V1.00 Implemented close and lock tray commands. Patches supplied by
104 Frank Racis
105 Added support for loadable MODULEs, so aztcd can now also be
106 loaded by insmod and removed by rmmod during run time
107 Werner Zimmermann, Mar. 24, 95
108 V1.10 Implemented soundcard configuration for Orchid CDS-3110 drives
109 connected to Soundwave32 cards. Release for LST 2.1.
110 (still experimental)
111 Werner Zimmermann, May 8, 95
112 V1.20 Implemented limited support for DOSEMU0.60's cdrom.c. Now it works, but
113 sometimes DOSEMU may hang for 30 seconds or so. A fully functional ver-
114 sion needs an update of Dosemu0.60's cdrom.c, which will come with the
115 next revision of Dosemu.
116 Also Soundwave32 support now works.
117 Werner Zimmermann, May 22, 95
118 V1.30 Auto-eject feature. Inspired by Franc Racis (racis@psu.edu)
119 Werner Zimmermann, July 4, 95
120 V1.40 Started multisession support. Implementation copied from mcdx.c
121 by Heiko Schlittermann. Not tested yet.
122 Werner Zimmermann, July 15, 95
123 V1.50 Implementation of ioctl CDROMRESET, continued multisession, began
124 XA, but still untested. Heavy modifications to drive status de-
125 tection.
126 Werner Zimmermann, July 25, 95
127 V1.60 XA support now should work. Speeded up drive recognition in cases,
128 where no drive is installed.
129 Werner Zimmermann, August 8, 1995
130 V1.70 Multisession support now is completed, but there is still not
131 enough testing done. If you can test it, please contact me. For
132 details please read Documentation/cdrom/aztcd
133 Werner Zimmermann, August 19, 1995
134 V1.80 Modification to suit the new kernel boot procedure introduced
135 with kernel 1.3.33. Will definitely not work with older kernels.
136 Programming done by Linus himself.
137 Werner Zimmermann, October 11, 1995
138 V1.90 Support for Conrad TXC drives, thank's to Jochen Kunz and Olaf Kaluza.
139 Werner Zimmermann, October 21, 1995
140 V2.00 Changed #include "blk.h" to <linux/blk.h> as the directory
141 structure was changed. README.aztcd is now /usr/src/docu-
142 mentation/cdrom/aztcd
143 Werner Zimmermann, November 10, 95
144 V2.10 Started to modify azt_poll to prevent reading beyond end of
145 tracks.
146 Werner Zimmermann, December 3, 95
147 V2.20 Changed some comments
148 Werner Zimmermann, April 1, 96
149 V2.30 Implemented support for CyCDROM CR520, CR940, Code for CR520
150 delivered by H.Berger with preworks by E.Moenkeberg.
151 Werner Zimmermann, April 29, 96
152 V2.40 Reorganized the placement of functions in the source code file
153 to reflect the layered approach; did not actually change code
154 Werner Zimmermann, May 1, 96
155 V2.50 Heiko Eissfeldt suggested to remove some VERIFY_READs in
156 aztcd_ioctl; check_aztcd_media_change modified
157 Werner Zimmermann, May 16, 96
158 V2.60 Implemented Auto-Probing; made changes for kernel's 2.1.xx blocksize
159 Adaption to linux kernel > 2.1.0
160 Werner Zimmermann, Nov 29, 97
161
162 November 1999 -- Make kernel-parameter implementation work with 2.3.x
163 Removed init_module & cleanup_module in favor of
164 module_init & module_exit.
165 Torben Mathiasen <tmm@image.dk>
166 */
167
168 #include <linux/blkdev.h>
169 #include "aztcd.h"
170
171 #include <linux/module.h>
172 #include <linux/errno.h>
173 #include <linux/sched.h>
174 #include <linux/mm.h>
175 #include <linux/timer.h>
176 #include <linux/fs.h>
177 #include <linux/kernel.h>
178 #include <linux/cdrom.h>
179 #include <linux/ioport.h>
180 #include <linux/string.h>
181 #include <linux/major.h>
182
183 #include <linux/init.h>
184
185 #include <asm/system.h>
186 #include <asm/io.h>
187
188 #include <asm/uaccess.h>
189
190 /*###########################################################################
191 Defines
192 ###########################################################################
193 */
194
195 #define MAJOR_NR AZTECH_CDROM_MAJOR
196 #define QUEUE (azt_queue)
197 #define CURRENT elv_next_request(azt_queue)
198 #define SET_TIMER(func, jifs) delay_timer.expires = jiffies + (jifs); \
199 delay_timer.function = (void *) (func); \
200 add_timer(&delay_timer);
201
202 #define CLEAR_TIMER del_timer(&delay_timer);
203
204 #define RETURNM(message,value) {printk("aztcd: Warning: %s failed\n",message);\
205 return value;}
206 #define RETURN(message) {printk("aztcd: Warning: %s failed\n",message);\
207 return;}
208
209 /* Macros to switch the IDE-interface to the slave device and back to the master*/
210 #define SWITCH_IDE_SLAVE outb_p(0xa0,azt_port+6); \
211 outb_p(0x10,azt_port+6); \
212 outb_p(0x00,azt_port+7); \
213 outb_p(0x10,azt_port+6);
214 #define SWITCH_IDE_MASTER outb_p(0xa0,azt_port+6);
215
216
217 #if 0
218 #define AZT_TEST
219 #define AZT_TEST1 /* <int-..> */
220 #define AZT_TEST2 /* do_aztcd_request */
221 #define AZT_TEST3 /* AZT_S_state */
222 #define AZT_TEST4 /* QUICK_LOOP-counter */
223 #define AZT_TEST5 /* port(1) state */
224 #define AZT_DEBUG
225 #define AZT_DEBUG_MULTISESSION
226 #endif
227
228 static struct request_queue *azt_queue;
229
230 static int current_valid(void)
231 {
232 return CURRENT &&
233 CURRENT->cmd == READ &&
234 CURRENT->sector != -1;
235 }
236
237 #define AFL_STATUSorDATA (AFL_STATUS | AFL_DATA)
238 #define AZT_BUF_SIZ 16
239
240 #define READ_TIMEOUT 3000
241
242 #define azt_port aztcd /*needed for the modutils */
243
244 /*##########################################################################
245 Type Definitions
246 ##########################################################################
247 */
248 enum azt_state_e { AZT_S_IDLE, /* 0 */
249 AZT_S_START, /* 1 */
250 AZT_S_MODE, /* 2 */
251 AZT_S_READ, /* 3 */
252 AZT_S_DATA, /* 4 */
253 AZT_S_STOP, /* 5 */
254 AZT_S_STOPPING /* 6 */
255 };
256 enum azt_read_modes { AZT_MODE_0, /*read mode for audio disks, not supported by Aztech firmware */
257 AZT_MODE_1, /*read mode for normal CD-ROMs */
258 AZT_MODE_2 /*read mode for XA CD-ROMs */
259 };
260
261 /*##########################################################################
262 Global Variables
263 ##########################################################################
264 */
265 static int aztPresent = 0;
266
267 static volatile int azt_transfer_is_active = 0;
268
269 static char azt_buf[CD_FRAMESIZE_RAW * AZT_BUF_SIZ]; /*buffer for block size conversion */
270 #if AZT_PRIVATE_IOCTLS
271 static char buf[CD_FRAMESIZE_RAW]; /*separate buffer for the ioctls */
272 #endif
273
274 static volatile int azt_buf_bn[AZT_BUF_SIZ], azt_next_bn;
275 static volatile int azt_buf_in, azt_buf_out = -1;
276 static volatile int azt_error = 0;
277 static int azt_open_count = 0;
278 static volatile enum azt_state_e azt_state = AZT_S_IDLE;
279 #ifdef AZT_TEST3
280 static volatile enum azt_state_e azt_state_old = AZT_S_STOP;
281 static volatile int azt_st_old = 0;
282 #endif
283 static volatile enum azt_read_modes azt_read_mode = AZT_MODE_1;
284
285 static int azt_mode = -1;
286 static volatile int azt_read_count = 1;
287
288 static int azt_port = AZT_BASE_ADDR;
289
290 module_param(azt_port, int, 0);
291
292 static int azt_port_auto[16] = AZT_BASE_AUTO;
293
294 static char azt_cont = 0;
295 static char azt_init_end = 0;
296 static char azt_auto_eject = AZT_AUTO_EJECT;
297
298 static int AztTimeout, AztTries;
299 static DECLARE_WAIT_QUEUE_HEAD(azt_waitq);
300 static struct timer_list delay_timer = TIMER_INITIALIZER(NULL, 0, 0);
301
302 static struct azt_DiskInfo DiskInfo;
303 static struct azt_Toc Toc[MAX_TRACKS];
304 static struct azt_Play_msf azt_Play;
305
306 static int aztAudioStatus = CDROM_AUDIO_NO_STATUS;
307 static char aztDiskChanged = 1;
308 static char aztTocUpToDate = 0;
309
310 static unsigned char aztIndatum;
311 static unsigned long aztTimeOutCount;
312 static int aztCmd = 0;
313
314 static DEFINE_SPINLOCK(aztSpin);
315
316 /*###########################################################################
317 Function Prototypes
318 ###########################################################################
319 */
320 /* CDROM Drive Low Level I/O Functions */
321 static void aztStatTimer(void);
322
323 /* CDROM Drive Command Functions */
324 static int aztGetDiskInfo(void);
325 #if AZT_MULTISESSION
326 static int aztGetMultiDiskInfo(void);
327 #endif
328 static int aztGetToc(int multi);
329
330 /* Kernel Interface Functions */
331 static int check_aztcd_media_change(struct gendisk *disk);
332 static int aztcd_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
333 unsigned long arg);
334 static int aztcd_open(struct inode *ip, struct file *fp);
335 static int aztcd_release(struct inode *inode, struct file *file);
336
337 static struct block_device_operations azt_fops = {
338 .owner = THIS_MODULE,
339 .open = aztcd_open,
340 .release = aztcd_release,
341 .ioctl = aztcd_ioctl,
342 .media_changed = check_aztcd_media_change,
343 };
344
345 /* Aztcd State Machine: Controls Drive Operating State */
346 static void azt_poll(void);
347
348 /* Miscellaneous support functions */
349 static void azt_hsg2msf(long hsg, struct msf *msf);
350 static long azt_msf2hsg(struct msf *mp);
351 static void azt_bin2bcd(unsigned char *p);
352 static int azt_bcd2bin(unsigned char bcd);
353
354 /*##########################################################################
355 CDROM Drive Low Level I/O Functions
356 ##########################################################################
357 */
358 /* Macros for the drive hardware interface handshake, these macros use
359 busy waiting */
360 /* Wait for OP_OK = drive answers with AFL_OP_OK after receiving a command*/
361 # define OP_OK op_ok()
362 static void op_ok(void)
363 {
364 aztTimeOutCount = 0;
365 do {
366 aztIndatum = inb(DATA_PORT);
367 aztTimeOutCount++;
368 if (aztTimeOutCount >= AZT_TIMEOUT) {
369 printk("aztcd: Error Wait OP_OK\n");
370 break;
371 }
372 } while (aztIndatum != AFL_OP_OK);
373 }
374
375 /* Wait for PA_OK = drive answers with AFL_PA_OK after receiving parameters*/
376 #if 0
377 # define PA_OK pa_ok()
378 static void pa_ok(void)
379 {
380 aztTimeOutCount = 0;
381 do {
382 aztIndatum = inb(DATA_PORT);
383 aztTimeOutCount++;
384 if (aztTimeOutCount >= AZT_TIMEOUT) {
385 printk("aztcd: Error Wait PA_OK\n");
386 break;
387 }
388 } while (aztIndatum != AFL_PA_OK);
389 }
390 #endif
391
392 /* Wait for STEN=Low = handshake signal 'AFL_.._OK available or command executed*/
393 # define STEN_LOW sten_low()
394 static void sten_low(void)
395 {
396 aztTimeOutCount = 0;
397 do {
398 aztIndatum = inb(STATUS_PORT);
399 aztTimeOutCount++;
400 if (aztTimeOutCount >= AZT_TIMEOUT) {
401 if (azt_init_end)
402 printk
403 ("aztcd: Error Wait STEN_LOW commands:%x\n",
404 aztCmd);
405 break;
406 }
407 } while (aztIndatum & AFL_STATUS);
408 }
409
410 /* Wait for DTEN=Low = handshake signal 'Data available'*/
411 # define DTEN_LOW dten_low()
412 static void dten_low(void)
413 {
414 aztTimeOutCount = 0;
415 do {
416 aztIndatum = inb(STATUS_PORT);
417 aztTimeOutCount++;
418 if (aztTimeOutCount >= AZT_TIMEOUT) {
419 printk("aztcd: Error Wait DTEN_OK\n");
420 break;
421 }
422 } while (aztIndatum & AFL_DATA);
423 }
424
425 /*
426 * Macro for timer wait on STEN=Low, should only be used for 'slow' commands;
427 * may cause kernel panic when used in the wrong place
428 */
429 #define STEN_LOW_WAIT statusAzt()
430 static void statusAzt(void)
431 {
432 AztTimeout = AZT_STATUS_DELAY;
433 SET_TIMER(aztStatTimer, HZ / 100);
434 sleep_on(&azt_waitq);
435 if (AztTimeout <= 0)
436 printk("aztcd: Error Wait STEN_LOW_WAIT command:%x\n",
437 aztCmd);
438 return;
439 }
440
441 static void aztStatTimer(void)
442 {
443 if (!(inb(STATUS_PORT) & AFL_STATUS)) {
444 wake_up(&azt_waitq);
445 return;
446 }
447 AztTimeout--;
448 if (AztTimeout <= 0) {
449 wake_up(&azt_waitq);
450 printk("aztcd: Error aztStatTimer: Timeout\n");
451 return;
452 }
453 SET_TIMER(aztStatTimer, HZ / 100);
454 }
455
456 /*##########################################################################
457 CDROM Drive Command Functions
458 ##########################################################################
459 */
460 /*
461 * Send a single command, return -1 on error, else 0
462 */
463 static int aztSendCmd(int cmd)
464 {
465 unsigned char data;
466 int retry;
467
468 #ifdef AZT_DEBUG
469 printk("aztcd: Executing command %x\n", cmd);
470 #endif
471
472 if ((azt_port == 0x1f0) || (azt_port == 0x170))
473 SWITCH_IDE_SLAVE; /*switch IDE interface to slave configuration */
474
475 aztCmd = cmd;
476 outb(POLLED, MODE_PORT);
477 do {
478 if (inb(STATUS_PORT) & AFL_STATUS)
479 break;
480 inb(DATA_PORT); /* if status left from last command, read and */
481 } while (1); /* discard it */
482 do {
483 if (inb(STATUS_PORT) & AFL_DATA)
484 break;
485 inb(DATA_PORT); /* if data left from last command, read and */
486 } while (1); /* discard it */
487 for (retry = 0; retry < AZT_RETRY_ATTEMPTS; retry++) {
488 outb((unsigned char) cmd, CMD_PORT);
489 STEN_LOW;
490 data = inb(DATA_PORT);
491 if (data == AFL_OP_OK) {
492 return 0;
493 } /*OP_OK? */
494 if (data == AFL_OP_ERR) {
495 STEN_LOW;
496 data = inb(DATA_PORT);
497 printk
498 ("### Error 1 aztcd: aztSendCmd %x Error Code %x\n",
499 cmd, data);
500 }
501 }
502 if (retry >= AZT_RETRY_ATTEMPTS) {
503 printk("### Error 2 aztcd: aztSendCmd %x \n", cmd);
504 azt_error = 0xA5;
505 }
506 RETURNM("aztSendCmd", -1);
507 }
508
509 /*
510 * Send a play or read command to the drive, return -1 on error, else 0
511 */
512 static int sendAztCmd(int cmd, struct azt_Play_msf *params)
513 {
514 unsigned char data;
515 int retry;
516
517 #ifdef AZT_DEBUG
518 printk("aztcd: play start=%02x:%02x:%02x end=%02x:%02x:%02x\n",
519 params->start.min, params->start.sec, params->start.frame,
520 params->end.min, params->end.sec, params->end.frame);
521 #endif
522 for (retry = 0; retry < AZT_RETRY_ATTEMPTS; retry++) {
523 aztSendCmd(cmd);
524 outb(params->start.min, CMD_PORT);
525 outb(params->start.sec, CMD_PORT);
526 outb(params->start.frame, CMD_PORT);
527 outb(params->end.min, CMD_PORT);
528 outb(params->end.sec, CMD_PORT);
529 outb(params->end.frame, CMD_PORT);
530 STEN_LOW;
531 data = inb(DATA_PORT);
532 if (data == AFL_PA_OK) {
533 return 0;
534 } /*PA_OK ? */
535 if (data == AFL_PA_ERR) {
536 STEN_LOW;
537 data = inb(DATA_PORT);
538 printk
539 ("### Error 1 aztcd: sendAztCmd %x Error Code %x\n",
540 cmd, data);
541 }
542 }
543 if (retry >= AZT_RETRY_ATTEMPTS) {
544 printk("### Error 2 aztcd: sendAztCmd %x\n ", cmd);
545 azt_error = 0xA5;
546 }
547 RETURNM("sendAztCmd", -1);
548 }
549
550 /*
551 * Send a seek command to the drive, return -1 on error, else 0
552 */
553 static int aztSeek(struct azt_Play_msf *params)
554 {
555 unsigned char data;
556 int retry;
557
558 #ifdef AZT_DEBUG
559 printk("aztcd: aztSeek %02x:%02x:%02x\n",
560 params->start.min, params->start.sec, params->start.frame);
561 #endif
562 for (retry = 0; retry < AZT_RETRY_ATTEMPTS; retry++) {
563 aztSendCmd(ACMD_SEEK);
564 outb(params->start.min, CMD_PORT);
565 outb(params->start.sec, CMD_PORT);
566 outb(params->start.frame, CMD_PORT);
567 STEN_LOW;
568 data = inb(DATA_PORT);
569 if (data == AFL_PA_OK) {
570 return 0;
571 } /*PA_OK ? */
572 if (data == AFL_PA_ERR) {
573 STEN_LOW;
574 data = inb(DATA_PORT);
575 printk("### Error 1 aztcd: aztSeek\n");
576 }
577 }
578 if (retry >= AZT_RETRY_ATTEMPTS) {
579 printk("### Error 2 aztcd: aztSeek\n ");
580 azt_error = 0xA5;
581 }
582 RETURNM("aztSeek", -1);
583 }
584
585 /* Send a Set Disk Type command
586 does not seem to work with Aztech drives, behavior is completely indepen-
587 dent on which mode is set ???
588 */
589 static int aztSetDiskType(int type)
590 {
591 unsigned char data;
592 int retry;
593
594 #ifdef AZT_DEBUG
595 printk("aztcd: set disk type command: type= %i\n", type);
596 #endif
597 for (retry = 0; retry < AZT_RETRY_ATTEMPTS; retry++) {
598 aztSendCmd(ACMD_SET_DISK_TYPE);
599 outb(type, CMD_PORT);
600 STEN_LOW;
601 data = inb(DATA_PORT);
602 if (data == AFL_PA_OK) { /*PA_OK ? */
603 azt_read_mode = type;
604 return 0;
605 }
606 if (data == AFL_PA_ERR) {
607 STEN_LOW;
608 data = inb(DATA_PORT);
609 printk
610 ("### Error 1 aztcd: aztSetDiskType %x Error Code %x\n",
611 type, data);
612 }
613 }
614 if (retry >= AZT_RETRY_ATTEMPTS) {
615 printk("### Error 2 aztcd: aztSetDiskType %x\n ", type);
616 azt_error = 0xA5;
617 }
618 RETURNM("aztSetDiskType", -1);
619 }
620
621
622 /* used in azt_poll to poll the status, expects another program to issue a
623 * ACMD_GET_STATUS directly before
624 */
625 static int aztStatus(void)
626 {
627 int st;
628 /* int i;
629
630 i = inb(STATUS_PORT) & AFL_STATUS; is STEN=0? ???
631 if (!i)
632 */ STEN_LOW;
633 if (aztTimeOutCount < AZT_TIMEOUT) {
634 st = inb(DATA_PORT) & 0xFF;
635 return st;
636 } else
637 RETURNM("aztStatus", -1);
638 }
639
640 /*
641 * Get the drive status
642 */
643 static int getAztStatus(void)
644 {
645 int st;
646
647 if (aztSendCmd(ACMD_GET_STATUS))
648 RETURNM("getAztStatus 1", -1);
649 STEN_LOW;
650 st = inb(DATA_PORT) & 0xFF;
651 #ifdef AZT_DEBUG
652 printk("aztcd: Status = %x\n", st);
653 #endif
654 if ((st == 0xFF) || (st & AST_CMD_CHECK)) {
655 printk
656 ("aztcd: AST_CMD_CHECK error or no status available\n");
657 return -1;
658 }
659
660 if (((st & AST_MODE_BITS) != AST_BUSY)
661 && (aztAudioStatus == CDROM_AUDIO_PLAY))
662 /* XXX might be an error? look at q-channel? */
663 aztAudioStatus = CDROM_AUDIO_COMPLETED;
664
665 if ((st & AST_DSK_CHG) || (st & AST_NOT_READY)) {
666 aztDiskChanged = 1;
667 aztTocUpToDate = 0;
668 aztAudioStatus = CDROM_AUDIO_NO_STATUS;
669 }
670 return st;
671 }
672
673
674 /*
675 * Send a 'Play' command and get the status. Use only from the top half.
676 */
677 static int aztPlay(struct azt_Play_msf *arg)
678 {
679 if (sendAztCmd(ACMD_PLAY_AUDIO, arg) < 0)
680 RETURNM("aztPlay", -1);
681 return 0;
682 }
683
684 /*
685 * Subroutines to automatically close the door (tray) and
686 * lock it closed when the cd is mounted. Leave the tray
687 * locking as an option
688 */
689 static void aztCloseDoor(void)
690 {
691 aztSendCmd(ACMD_CLOSE);
692 STEN_LOW;
693 return;
694 }
695
696 static void aztLockDoor(void)
697 {
698 #if AZT_ALLOW_TRAY_LOCK
699 aztSendCmd(ACMD_LOCK);
700 STEN_LOW;
701 #endif
702 return;
703 }
704
705 static void aztUnlockDoor(void)
706 {
707 #if AZT_ALLOW_TRAY_LOCK
708 aztSendCmd(ACMD_UNLOCK);
709 STEN_LOW;
710 #endif
711 return;
712 }
713
714 /*
715 * Read a value from the drive. Should return quickly, so a busy wait
716 * is used to avoid excessive rescheduling. The read command itself must
717 * be issued with aztSendCmd() directly before
718 */
719 static int aztGetValue(unsigned char *result)
720 {
721 int s;
722
723 STEN_LOW;
724 if (aztTimeOutCount >= AZT_TIMEOUT) {
725 printk("aztcd: aztGetValue timeout\n");
726 return -1;
727 }
728 s = inb(DATA_PORT) & 0xFF;
729 *result = (unsigned char) s;
730 return 0;
731 }
732
733 /*
734 * Read the current Q-channel info. Also used for reading the
735 * table of contents.
736 */
737 static int aztGetQChannelInfo(struct azt_Toc *qp)
738 {
739 unsigned char notUsed;
740 int st;
741
742 #ifdef AZT_DEBUG
743 printk("aztcd: starting aztGetQChannelInfo Time:%li\n", jiffies);
744 #endif
745 if ((st = getAztStatus()) == -1)
746 RETURNM("aztGetQChannelInfo 1", -1);
747 if (aztSendCmd(ACMD_GET_Q_CHANNEL))
748 RETURNM("aztGetQChannelInfo 2", -1);
749 /*STEN_LOW_WAIT; ??? Dosemu0.60's cdrom.c does not like STEN_LOW_WAIT here */
750 if (aztGetValue(&notUsed))
751 RETURNM("aztGetQChannelInfo 3", -1); /*??? Nullbyte einlesen */
752 if ((st & AST_MODE_BITS) == AST_INITIAL) {
753 qp->ctrl_addr = 0; /* when audio stop ACMD_GET_Q_CHANNEL returns */
754 qp->track = 0; /* only one byte with Aztech drives */
755 qp->pointIndex = 0;
756 qp->trackTime.min = 0;
757 qp->trackTime.sec = 0;
758 qp->trackTime.frame = 0;
759 qp->diskTime.min = 0;
760 qp->diskTime.sec = 0;
761 qp->diskTime.frame = 0;
762 return 0;
763 } else {
764 if (aztGetValue(&qp->ctrl_addr) < 0)
765 RETURNM("aztGetQChannelInfo 4", -1);
766 if (aztGetValue(&qp->track) < 0)
767 RETURNM("aztGetQChannelInfo 4", -1);
768 if (aztGetValue(&qp->pointIndex) < 0)
769 RETURNM("aztGetQChannelInfo 4", -1);
770 if (aztGetValue(&qp->trackTime.min) < 0)
771 RETURNM("aztGetQChannelInfo 4", -1);
772 if (aztGetValue(&qp->trackTime.sec) < 0)
773 RETURNM("aztGetQChannelInfo 4", -1);
774 if (aztGetValue(&qp->trackTime.frame) < 0)
775 RETURNM("aztGetQChannelInfo 4", -1);
776 if (aztGetValue(&notUsed) < 0)
777 RETURNM("aztGetQChannelInfo 4", -1);
778 if (aztGetValue(&qp->diskTime.min) < 0)
779 RETURNM("aztGetQChannelInfo 4", -1);
780 if (aztGetValue(&qp->diskTime.sec) < 0)
781 RETURNM("aztGetQChannelInfo 4", -1);
782 if (aztGetValue(&qp->diskTime.frame) < 0)
783 RETURNM("aztGetQChannelInfo 4", -1);
784 }
785 #ifdef AZT_DEBUG
786 printk("aztcd: exiting aztGetQChannelInfo Time:%li\n", jiffies);
787 #endif
788 return 0;
789 }
790
791 /*
792 * Read the table of contents (TOC) and TOC header if necessary
793 */
794 static int aztUpdateToc(void)
795 {
796 int st;
797
798 #ifdef AZT_DEBUG
799 printk("aztcd: starting aztUpdateToc Time:%li\n", jiffies);
800 #endif
801 if (aztTocUpToDate)
802 return 0;
803
804 if (aztGetDiskInfo() < 0)
805 return -EIO;
806
807 if (aztGetToc(0) < 0)
808 return -EIO;
809
810 /*audio disk detection
811 with my Aztech drive there is no audio status bit, so I use the copy
812 protection bit of the first track. If this track is copy protected
813 (copy bit = 0), I assume, it's an audio disk. Strange, but works ??? */
814 if (!(Toc[DiskInfo.first].ctrl_addr & 0x40))
815 DiskInfo.audio = 1;
816 else
817 DiskInfo.audio = 0;
818
819 /* XA detection */
820 if (!DiskInfo.audio) {
821 azt_Play.start.min = 0; /*XA detection only seems to work */
822 azt_Play.start.sec = 2; /*when we play a track */
823 azt_Play.start.frame = 0;
824 azt_Play.end.min = 0;
825 azt_Play.end.sec = 0;
826 azt_Play.end.frame = 1;
827 if (sendAztCmd(ACMD_PLAY_READ, &azt_Play))
828 return -1;
829 DTEN_LOW;
830 for (st = 0; st < CD_FRAMESIZE; st++)
831 inb(DATA_PORT);
832 }
833 DiskInfo.xa = getAztStatus() & AST_MODE;
834 if (DiskInfo.xa) {
835 printk
836 ("aztcd: XA support experimental - mail results to Werner.Zimmermann@fht-esslingen.de\n");
837 }
838
839 /*multisession detection
840 support for multisession CDs is done automatically with Aztech drives,
841 we don't have to take care about TOC redirection; if we want the isofs
842 to take care about redirection, we have to set AZT_MULTISESSION to 1 */
843 DiskInfo.multi = 0;
844 #if AZT_MULTISESSION
845 if (DiskInfo.xa) {
846 aztGetMultiDiskInfo(); /*here Disk.Info.multi is set */
847 }
848 #endif
849 if (DiskInfo.multi) {
850 DiskInfo.lastSession.min = Toc[DiskInfo.next].diskTime.min;
851 DiskInfo.lastSession.sec = Toc[DiskInfo.next].diskTime.sec;
852 DiskInfo.lastSession.frame =
853 Toc[DiskInfo.next].diskTime.frame;
854 printk("aztcd: Multisession support experimental\n");
855 } else {
856 DiskInfo.lastSession.min =
857 Toc[DiskInfo.first].diskTime.min;
858 DiskInfo.lastSession.sec =
859 Toc[DiskInfo.first].diskTime.sec;
860 DiskInfo.lastSession.frame =
861 Toc[DiskInfo.first].diskTime.frame;
862 }
863
864 aztTocUpToDate = 1;
865 #ifdef AZT_DEBUG
866 printk("aztcd: exiting aztUpdateToc Time:%li\n", jiffies);
867 #endif
868 return 0;
869 }
870
871
872 /* Read the table of contents header, i.e. no. of tracks and start of first
873 * track
874 */
875 static int aztGetDiskInfo(void)
876 {
877 int limit;
878 unsigned char test;
879 struct azt_Toc qInfo;
880
881 #ifdef AZT_DEBUG
882 printk("aztcd: starting aztGetDiskInfo Time:%li\n", jiffies);
883 #endif
884 if (aztSendCmd(ACMD_SEEK_TO_LEADIN))
885 RETURNM("aztGetDiskInfo 1", -1);
886 STEN_LOW_WAIT;
887 test = 0;
888 for (limit = 300; limit > 0; limit--) {
889 if (aztGetQChannelInfo(&qInfo) < 0)
890 RETURNM("aztGetDiskInfo 2", -1);
891 if (qInfo.pointIndex == 0xA0) { /*Number of FirstTrack */
892 DiskInfo.first = qInfo.diskTime.min;
893 DiskInfo.first = azt_bcd2bin(DiskInfo.first);
894 test = test | 0x01;
895 }
896 if (qInfo.pointIndex == 0xA1) { /*Number of LastTrack */
897 DiskInfo.last = qInfo.diskTime.min;
898 DiskInfo.last = azt_bcd2bin(DiskInfo.last);
899 test = test | 0x02;
900 }
901 if (qInfo.pointIndex == 0xA2) { /*DiskLength */
902 DiskInfo.diskLength.min = qInfo.diskTime.min;
903 DiskInfo.diskLength.sec = qInfo.diskTime.sec;
904 DiskInfo.diskLength.frame = qInfo.diskTime.frame;
905 test = test | 0x04;
906 }
907 if ((qInfo.pointIndex == DiskInfo.first) && (test & 0x01)) { /*StartTime of First Track */
908 DiskInfo.firstTrack.min = qInfo.diskTime.min;
909 DiskInfo.firstTrack.sec = qInfo.diskTime.sec;
910 DiskInfo.firstTrack.frame = qInfo.diskTime.frame;
911 test = test | 0x08;
912 }
913 if (test == 0x0F)
914 break;
915 }
916 #ifdef AZT_DEBUG
917 printk("aztcd: exiting aztGetDiskInfo Time:%li\n", jiffies);
918 printk
919 ("Disk Info: first %d last %d length %02X:%02X.%02X dez first %02X:%02X.%02X dez\n",
920 DiskInfo.first, DiskInfo.last, DiskInfo.diskLength.min,
921 DiskInfo.diskLength.sec, DiskInfo.diskLength.frame,
922 DiskInfo.firstTrack.min, DiskInfo.firstTrack.sec,
923 DiskInfo.firstTrack.frame);
924 #endif
925 if (test != 0x0F)
926 return -1;
927 return 0;
928 }
929
930 #if AZT_MULTISESSION
931 /*
932 * Get Multisession Disk Info
933 */
934 static int aztGetMultiDiskInfo(void)
935 {
936 int limit, k = 5;
937 unsigned char test;
938 struct azt_Toc qInfo;
939
940 #ifdef AZT_DEBUG
941 printk("aztcd: starting aztGetMultiDiskInfo\n");
942 #endif
943
944 do {
945 azt_Play.start.min = Toc[DiskInfo.last + 1].diskTime.min;
946 azt_Play.start.sec = Toc[DiskInfo.last + 1].diskTime.sec;
947 azt_Play.start.frame =
948 Toc[DiskInfo.last + 1].diskTime.frame;
949 test = 0;
950
951 for (limit = 30; limit > 0; limit--) { /*Seek for LeadIn of next session */
952 if (aztSeek(&azt_Play))
953 RETURNM("aztGetMultiDiskInfo 1", -1);
954 if (aztGetQChannelInfo(&qInfo) < 0)
955 RETURNM("aztGetMultiDiskInfo 2", -1);
956 if ((qInfo.track == 0) && (qInfo.pointIndex))
957 break; /*LeadIn found */
958 if ((azt_Play.start.sec += 10) > 59) {
959 azt_Play.start.sec = 0;
960 azt_Play.start.min++;
961 }
962 }
963 if (!limit)
964 break; /*Check, if a leadin track was found, if not we're
965 at the end of the disk */
966 #ifdef AZT_DEBUG_MULTISESSION
967 printk("leadin found track %d pointIndex %x limit %d\n",
968 qInfo.track, qInfo.pointIndex, limit);
969 #endif
970 for (limit = 300; limit > 0; limit--) {
971 if (++azt_Play.start.frame > 74) {
972 azt_Play.start.frame = 0;
973 if (azt_Play.start.sec > 59) {
974 azt_Play.start.sec = 0;
975 azt_Play.start.min++;
976 }
977 }
978 if (aztSeek(&azt_Play))
979 RETURNM("aztGetMultiDiskInfo 3", -1);
980 if (aztGetQChannelInfo(&qInfo) < 0)
981 RETURNM("aztGetMultiDiskInfo 4", -1);
982 if (qInfo.pointIndex == 0xA0) { /*Number of NextTrack */
983 DiskInfo.next = qInfo.diskTime.min;
984 DiskInfo.next = azt_bcd2bin(DiskInfo.next);
985 test = test | 0x01;
986 }
987 if (qInfo.pointIndex == 0xA1) { /*Number of LastTrack */
988 DiskInfo.last = qInfo.diskTime.min;
989 DiskInfo.last = azt_bcd2bin(DiskInfo.last);
990 test = test | 0x02;
991 }
992 if (qInfo.pointIndex == 0xA2) { /*DiskLength */
993 DiskInfo.diskLength.min =
994 qInfo.diskTime.min;
995 DiskInfo.diskLength.sec =
996 qInfo.diskTime.sec;
997 DiskInfo.diskLength.frame =
998 qInfo.diskTime.frame;
999 test = test | 0x04;
1000 }
1001 if ((qInfo.pointIndex == DiskInfo.next) && (test & 0x01)) { /*StartTime of Next Track */
1002 DiskInfo.nextSession.min =
1003 qInfo.diskTime.min;
1004 DiskInfo.nextSession.sec =
1005 qInfo.diskTime.sec;
1006 DiskInfo.nextSession.frame =
1007 qInfo.diskTime.frame;
1008 test = test | 0x08;
1009 }
1010 if (test == 0x0F)
1011 break;
1012 }
1013 #ifdef AZT_DEBUG_MULTISESSION
1014 printk
1015 ("MultiDisk Info: first %d next %d last %d length %02x:%02x.%02x dez first %02x:%02x.%02x dez next %02x:%02x.%02x dez\n",
1016 DiskInfo.first, DiskInfo.next, DiskInfo.last,
1017 DiskInfo.diskLength.min, DiskInfo.diskLength.sec,
1018 DiskInfo.diskLength.frame, DiskInfo.firstTrack.min,
1019 DiskInfo.firstTrack.sec, DiskInfo.firstTrack.frame,
1020 DiskInfo.nextSession.min, DiskInfo.nextSession.sec,
1021 DiskInfo.nextSession.frame);
1022 #endif
1023 if (test != 0x0F)
1024 break;
1025 else
1026 DiskInfo.multi = 1; /*found TOC of more than one session */
1027 aztGetToc(1);
1028 } while (--k);
1029
1030 #ifdef AZT_DEBUG
1031 printk("aztcd: exiting aztGetMultiDiskInfo Time:%li\n", jiffies);
1032 #endif
1033 return 0;
1034 }
1035 #endif
1036
1037 /*
1038 * Read the table of contents (TOC)
1039 */
1040 static int aztGetToc(int multi)
1041 {
1042 int i, px;
1043 int limit;
1044 struct azt_Toc qInfo;
1045
1046 #ifdef AZT_DEBUG
1047 printk("aztcd: starting aztGetToc Time:%li\n", jiffies);
1048 #endif
1049 if (!multi) {
1050 for (i = 0; i < MAX_TRACKS; i++)
1051 Toc[i].pointIndex = 0;
1052 i = DiskInfo.last + 3;
1053 } else {
1054 for (i = DiskInfo.next; i < MAX_TRACKS; i++)
1055 Toc[i].pointIndex = 0;
1056 i = DiskInfo.last + 4 - DiskInfo.next;
1057 }
1058
1059 /*Is there a good reason to stop motor before TOC read?
1060 if (aztSendCmd(ACMD_STOP)) RETURNM("aztGetToc 1",-1);
1061 STEN_LOW_WAIT;
1062 */
1063
1064 if (!multi) {
1065 azt_mode = 0x05;
1066 if (aztSendCmd(ACMD_SEEK_TO_LEADIN))
1067 RETURNM("aztGetToc 2", -1);
1068 STEN_LOW_WAIT;
1069 }
1070 for (limit = 300; limit > 0; limit--) {
1071 if (multi) {
1072 if (++azt_Play.start.sec > 59) {
1073 azt_Play.start.sec = 0;
1074 azt_Play.start.min++;
1075 }
1076 if (aztSeek(&azt_Play))
1077 RETURNM("aztGetToc 3", -1);
1078 }
1079 if (aztGetQChannelInfo(&qInfo) < 0)
1080 break;
1081
1082 px = azt_bcd2bin(qInfo.pointIndex);
1083
1084 if (px > 0 && px < MAX_TRACKS && qInfo.track == 0)
1085 if (Toc[px].pointIndex == 0) {
1086 Toc[px] = qInfo;
1087 i--;
1088 }
1089
1090 if (i <= 0)
1091 break;
1092 }
1093
1094 Toc[DiskInfo.last + 1].diskTime = DiskInfo.diskLength;
1095 Toc[DiskInfo.last].trackTime = DiskInfo.diskLength;
1096
1097 #ifdef AZT_DEBUG_MULTISESSION
1098 printk("aztcd: exiting aztGetToc\n");
1099 for (i = 1; i <= DiskInfo.last + 1; i++)
1100 printk
1101 ("i = %2d ctl-adr = %02X track %2d px %02X %02X:%02X.%02X dez %02X:%02X.%02X dez\n",
1102 i, Toc[i].ctrl_addr, Toc[i].track, Toc[i].pointIndex,
1103 Toc[i].trackTime.min, Toc[i].trackTime.sec,
1104 Toc[i].trackTime.frame, Toc[i].diskTime.min,
1105 Toc[i].diskTime.sec, Toc[i].diskTime.frame);
1106 for (i = 100; i < 103; i++)
1107 printk
1108 ("i = %2d ctl-adr = %02X track %2d px %02X %02X:%02X.%02X dez %02X:%02X.%02X dez\n",
1109 i, Toc[i].ctrl_addr, Toc[i].track, Toc[i].pointIndex,
1110 Toc[i].trackTime.min, Toc[i].trackTime.sec,
1111 Toc[i].trackTime.frame, Toc[i].diskTime.min,
1112 Toc[i].diskTime.sec, Toc[i].diskTime.frame);
1113 #endif
1114
1115 return limit > 0 ? 0 : -1;
1116 }
1117
1118
1119 /*##########################################################################
1120 Kernel Interface Functions
1121 ##########################################################################
1122 */
1123
1124 #ifndef MODULE
1125 static int __init aztcd_setup(char *str)
1126 {
1127 int ints[4];
1128
1129 (void) get_options(str, ARRAY_SIZE(ints), ints);
1130
1131 if (ints[0] > 0)
1132 azt_port = ints[1];
1133 if (ints[1] > 1)
1134 azt_cont = ints[2];
1135 return 1;
1136 }
1137
1138 __setup("aztcd=", aztcd_setup);
1139
1140 #endif /* !MODULE */
1141
1142 /*
1143 * Checking if the media has been changed
1144 */
1145 static int check_aztcd_media_change(struct gendisk *disk)
1146 {
1147 if (aztDiskChanged) { /* disk changed */
1148 aztDiskChanged = 0;
1149 return 1;
1150 } else
1151 return 0; /* no change */
1152 }
1153
1154 /*
1155 * Kernel IO-controls
1156 */
1157 static int aztcd_ioctl(struct inode *ip, struct file *fp, unsigned int cmd,
1158 unsigned long arg)
1159 {
1160 int i;
1161 struct azt_Toc qInfo;
1162 struct cdrom_ti ti;
1163 struct cdrom_tochdr tocHdr;
1164 struct cdrom_msf msf;
1165 struct cdrom_tocentry entry;
1166 struct azt_Toc *tocPtr;
1167 struct cdrom_subchnl subchnl;
1168 struct cdrom_volctrl volctrl;
1169 void __user *argp = (void __user *)arg;
1170
1171 #ifdef AZT_DEBUG
1172 printk("aztcd: starting aztcd_ioctl - Command:%x Time: %li\n",
1173 cmd, jiffies);
1174 printk("aztcd Status %x\n", getAztStatus());
1175 #endif
1176 if (!ip)
1177 RETURNM("aztcd_ioctl 1", -EINVAL);
1178 if (getAztStatus() < 0)
1179 RETURNM("aztcd_ioctl 2", -EIO);
1180 if ((!aztTocUpToDate) || (aztDiskChanged)) {
1181 if ((i = aztUpdateToc()) < 0)
1182 RETURNM("aztcd_ioctl 3", i); /* error reading TOC */
1183 }
1184
1185 switch (cmd) {
1186 case CDROMSTART: /* Spin up the drive. Don't know, what to do,
1187 at least close the tray */
1188 #if AZT_PRIVATE_IOCTLS
1189 if (aztSendCmd(ACMD_CLOSE))
1190 RETURNM("aztcd_ioctl 4", -1);
1191 STEN_LOW_WAIT;
1192 #endif
1193 break;
1194 case CDROMSTOP: /* Spin down the drive */
1195 if (aztSendCmd(ACMD_STOP))
1196 RETURNM("aztcd_ioctl 5", -1);
1197 STEN_LOW_WAIT;
1198 /* should we do anything if it fails? */
1199 aztAudioStatus = CDROM_AUDIO_NO_STATUS;
1200 break;
1201 case CDROMPAUSE: /* Pause the drive */
1202 if (aztAudioStatus != CDROM_AUDIO_PLAY)
1203 return -EINVAL;
1204
1205 if (aztGetQChannelInfo(&qInfo) < 0) { /* didn't get q channel info */
1206 aztAudioStatus = CDROM_AUDIO_NO_STATUS;
1207 RETURNM("aztcd_ioctl 7", 0);
1208 }
1209 azt_Play.start = qInfo.diskTime; /* remember restart point */
1210
1211 if (aztSendCmd(ACMD_PAUSE))
1212 RETURNM("aztcd_ioctl 8", -1);
1213 STEN_LOW_WAIT;
1214 aztAudioStatus = CDROM_AUDIO_PAUSED;
1215 break;
1216 case CDROMRESUME: /* Play it again, Sam */
1217 if (aztAudioStatus != CDROM_AUDIO_PAUSED)
1218 return -EINVAL;
1219 /* restart the drive at the saved position. */
1220 i = aztPlay(&azt_Play);
1221 if (i < 0) {
1222 aztAudioStatus = CDROM_AUDIO_ERROR;
1223 return -EIO;
1224 }
1225 aztAudioStatus = CDROM_AUDIO_PLAY;
1226 break;
1227 case CDROMMULTISESSION: /*multisession support -- experimental */
1228 {
1229 struct cdrom_multisession ms;
1230 #ifdef AZT_DEBUG
1231 printk("aztcd ioctl MULTISESSION\n");
1232 #endif
1233 if (copy_from_user(&ms, argp,
1234 sizeof(struct cdrom_multisession)))
1235 return -EFAULT;
1236 if (ms.addr_format == CDROM_MSF) {
1237 ms.addr.msf.minute =
1238 azt_bcd2bin(DiskInfo.lastSession.min);
1239 ms.addr.msf.second =
1240 azt_bcd2bin(DiskInfo.lastSession.sec);
1241 ms.addr.msf.frame =
1242 azt_bcd2bin(DiskInfo.lastSession.
1243 frame);
1244 } else if (ms.addr_format == CDROM_LBA)
1245 ms.addr.lba =
1246 azt_msf2hsg(&DiskInfo.lastSession);
1247 else
1248 return -EINVAL;
1249 ms.xa_flag = DiskInfo.xa;
1250 if (copy_to_user(argp, &ms,
1251 sizeof(struct cdrom_multisession)))
1252 return -EFAULT;
1253 #ifdef AZT_DEBUG
1254 if (ms.addr_format == CDROM_MSF)
1255 printk
1256 ("aztcd multisession xa:%d, msf:%02x:%02x.%02x [%02x:%02x.%02x])\n",
1257 ms.xa_flag, ms.addr.msf.minute,
1258 ms.addr.msf.second, ms.addr.msf.frame,
1259 DiskInfo.lastSession.min,
1260 DiskInfo.lastSession.sec,
1261 DiskInfo.lastSession.frame);
1262 else
1263 printk
1264 ("aztcd multisession %d, lba:0x%08x [%02x:%02x.%02x])\n",
1265 ms.xa_flag, ms.addr.lba,
1266 DiskInfo.lastSession.min,
1267 DiskInfo.lastSession.sec,
1268 DiskInfo.lastSession.frame);
1269 #endif
1270 return 0;
1271 }
1272 case CDROMPLAYTRKIND: /* Play a track. This currently ignores index. */
1273 if (copy_from_user(&ti, argp, sizeof ti))
1274 return -EFAULT;
1275 if (ti.cdti_trk0 < DiskInfo.first
1276 || ti.cdti_trk0 > DiskInfo.last
1277 || ti.cdti_trk1 < ti.cdti_trk0) {
1278 return -EINVAL;
1279 }
1280 if (ti.cdti_trk1 > DiskInfo.last)
1281 ti.cdti_trk1 = DiskInfo.last;
1282 azt_Play.start = Toc[ti.cdti_trk0].diskTime;
1283 azt_Play.end = Toc[ti.cdti_trk1 + 1].diskTime;
1284 #ifdef AZT_DEBUG
1285 printk("aztcd play: %02x:%02x.%02x to %02x:%02x.%02x\n",
1286 azt_Play.start.min, azt_Play.start.sec,
1287 azt_Play.start.frame, azt_Play.end.min,
1288 azt_Play.end.sec, azt_Play.end.frame);
1289 #endif
1290 i = aztPlay(&azt_Play);
1291 if (i < 0) {
1292 aztAudioStatus = CDROM_AUDIO_ERROR;
1293 return -EIO;
1294 }
1295 aztAudioStatus = CDROM_AUDIO_PLAY;
1296 break;
1297 case CDROMPLAYMSF: /* Play starting at the given MSF address. */
1298 /* if (aztAudioStatus == CDROM_AUDIO_PLAY)
1299 { if (aztSendCmd(ACMD_STOP)) RETURNM("aztcd_ioctl 9",-1);
1300 STEN_LOW;
1301 aztAudioStatus = CDROM_AUDIO_NO_STATUS;
1302 }
1303 */
1304 if (copy_from_user(&msf, argp, sizeof msf))
1305 return -EFAULT;
1306 /* convert to bcd */
1307 azt_bin2bcd(&msf.cdmsf_min0);
1308 azt_bin2bcd(&msf.cdmsf_sec0);
1309 azt_bin2bcd(&msf.cdmsf_frame0);
1310 azt_bin2bcd(&msf.cdmsf_min1);
1311 azt_bin2bcd(&msf.cdmsf_sec1);
1312 azt_bin2bcd(&msf.cdmsf_frame1);
1313 azt_Play.start.min = msf.cdmsf_min0;
1314 azt_Play.start.sec = msf.cdmsf_sec0;
1315 azt_Play.start.frame = msf.cdmsf_frame0;
1316 azt_Play.end.min = msf.cdmsf_min1;
1317 azt_Play.end.sec = msf.cdmsf_sec1;
1318 azt_Play.end.frame = msf.cdmsf_frame1;
1319 #ifdef AZT_DEBUG
1320 printk("aztcd play: %02x:%02x.%02x to %02x:%02x.%02x\n",
1321 azt_Play.start.min, azt_Play.start.sec,
1322 azt_Play.start.frame, azt_Play.end.min,
1323 azt_Play.end.sec, azt_Play.end.frame);
1324 #endif
1325 i = aztPlay(&azt_Play);
1326 if (i < 0) {
1327 aztAudioStatus = CDROM_AUDIO_ERROR;
1328 return -EIO;
1329 }
1330 aztAudioStatus = CDROM_AUDIO_PLAY;
1331 break;
1332
1333 case CDROMREADTOCHDR: /* Read the table of contents header */
1334 tocHdr.cdth_trk0 = DiskInfo.first;
1335 tocHdr.cdth_trk1 = DiskInfo.last;
1336 if (copy_to_user(argp, &tocHdr, sizeof tocHdr))
1337 return -EFAULT;
1338 break;
1339 case CDROMREADTOCENTRY: /* Read an entry in the table of contents */
1340 if (copy_from_user(&entry, argp, sizeof entry))
1341 return -EFAULT;
1342 if ((!aztTocUpToDate) || aztDiskChanged)
1343 aztUpdateToc();
1344 if (entry.cdte_track == CDROM_LEADOUT)
1345 tocPtr = &Toc[DiskInfo.last + 1];
1346 else if (entry.cdte_track > DiskInfo.last
1347 || entry.cdte_track < DiskInfo.first) {
1348 return -EINVAL;
1349 } else
1350 tocPtr = &Toc[entry.cdte_track];
1351 entry.cdte_adr = tocPtr->ctrl_addr;
1352 entry.cdte_ctrl = tocPtr->ctrl_addr >> 4;
1353 if (entry.cdte_format == CDROM_LBA)
1354 entry.cdte_addr.lba =
1355 azt_msf2hsg(&tocPtr->diskTime);
1356 else if (entry.cdte_format == CDROM_MSF) {
1357 entry.cdte_addr.msf.minute =
1358 azt_bcd2bin(tocPtr->diskTime.min);
1359 entry.cdte_addr.msf.second =
1360 azt_bcd2bin(tocPtr->diskTime.sec);
1361 entry.cdte_addr.msf.frame =
1362 azt_bcd2bin(tocPtr->diskTime.frame);
1363 } else {
1364 return -EINVAL;
1365 }
1366 if (copy_to_user(argp, &entry, sizeof entry))
1367 return -EFAULT;
1368 break;
1369 case CDROMSUBCHNL: /* Get subchannel info */
1370 if (copy_from_user
1371 (&subchnl, argp, sizeof(struct cdrom_subchnl)))
1372 return -EFAULT;
1373 if (aztGetQChannelInfo(&qInfo) < 0) {
1374 #ifdef AZT_DEBUG
1375 printk
1376 ("aztcd: exiting aztcd_ioctl - Error 3 - Command:%x\n",
1377 cmd);
1378 #endif
1379 return -EIO;
1380 }
1381 subchnl.cdsc_audiostatus = aztAudioStatus;
1382 subchnl.cdsc_adr = qInfo.ctrl_addr;
1383 subchnl.cdsc_ctrl = qInfo.ctrl_addr >> 4;
1384 subchnl.cdsc_trk = azt_bcd2bin(qInfo.track);
1385 subchnl.cdsc_ind = azt_bcd2bin(qInfo.pointIndex);
1386 if (subchnl.cdsc_format == CDROM_LBA) {
1387 subchnl.cdsc_absaddr.lba =
1388 azt_msf2hsg(&qInfo.diskTime);
1389 subchnl.cdsc_reladdr.lba =
1390 azt_msf2hsg(&qInfo.trackTime);
1391 } else { /*default */
1392 subchnl.cdsc_format = CDROM_MSF;
1393 subchnl.cdsc_absaddr.msf.minute =
1394 azt_bcd2bin(qInfo.diskTime.min);
1395 subchnl.cdsc_absaddr.msf.second =
1396 azt_bcd2bin(qInfo.diskTime.sec);
1397 subchnl.cdsc_absaddr.msf.frame =
1398 azt_bcd2bin(qInfo.diskTime.frame);
1399 subchnl.cdsc_reladdr.msf.minute =
1400 azt_bcd2bin(qInfo.trackTime.min);
1401 subchnl.cdsc_reladdr.msf.second =
1402 azt_bcd2bin(qInfo.trackTime.sec);
1403 subchnl.cdsc_reladdr.msf.frame =
1404 azt_bcd2bin(qInfo.trackTime.frame);
1405 }
1406 if (copy_to_user(argp, &subchnl, sizeof(struct cdrom_subchnl)))
1407 return -EFAULT;
1408 break;
1409 case CDROMVOLCTRL: /* Volume control
1410 * With my Aztech CD268-01A volume control does not work, I can only
1411 turn the channels on (any value !=0) or off (value==0). Maybe it
1412 works better with your drive */
1413 if (copy_from_user(&volctrl, argp, sizeof(volctrl)))
1414 return -EFAULT;
1415 azt_Play.start.min = 0x21;
1416 azt_Play.start.sec = 0x84;
1417 azt_Play.start.frame = volctrl.channel0;
1418 azt_Play.end.min = volctrl.channel1;
1419 azt_Play.end.sec = volctrl.channel2;
1420 azt_Play.end.frame = volctrl.channel3;
1421 sendAztCmd(ACMD_SET_VOLUME, &azt_Play);
1422 STEN_LOW_WAIT;
1423 break;
1424 case CDROMEJECT:
1425 aztUnlockDoor(); /* Assume user knows what they're doing */
1426 /* all drives can at least stop! */
1427 if (aztAudioStatus == CDROM_AUDIO_PLAY) {
1428 if (aztSendCmd(ACMD_STOP))
1429 RETURNM("azt_ioctl 10", -1);
1430 STEN_LOW_WAIT;
1431 }
1432 if (aztSendCmd(ACMD_EJECT))
1433 RETURNM("azt_ioctl 11", -1);
1434 STEN_LOW_WAIT;
1435 aztAudioStatus = CDROM_AUDIO_NO_STATUS;
1436 break;
1437 case CDROMEJECT_SW:
1438 azt_auto_eject = (char) arg;
1439 break;
1440 case CDROMRESET:
1441 outb(ACMD_SOFT_RESET, CMD_PORT); /*send reset */
1442 STEN_LOW;
1443 if (inb(DATA_PORT) != AFL_OP_OK) { /*OP_OK? */
1444 printk
1445 ("aztcd: AZTECH CD-ROM drive does not respond\n");
1446 }
1447 break;
1448 /*Take care, the following code is not compatible with other CD-ROM drivers,
1449 use it at your own risk with cdplay.c. Set AZT_PRIVATE_IOCTLS to 0 in aztcd.h,
1450 if you do not want to use it!
1451 */
1452 #if AZT_PRIVATE_IOCTLS
1453 case CDROMREADCOOKED: /*read data in mode 1 (2048 Bytes) */
1454 case CDROMREADRAW: /*read data in mode 2 (2336 Bytes) */
1455 {
1456 if (copy_from_user(&msf, argp, sizeof msf))
1457 return -EFAULT;
1458 /* convert to bcd */
1459 azt_bin2bcd(&msf.cdmsf_min0);
1460 azt_bin2bcd(&msf.cdmsf_sec0);
1461 azt_bin2bcd(&msf.cdmsf_frame0);
1462 msf.cdmsf_min1 = 0;
1463 msf.cdmsf_sec1 = 0;
1464 msf.cdmsf_frame1 = 1; /*read only one frame */
1465 azt_Play.start.min = msf.cdmsf_min0;
1466 azt_Play.start.sec = msf.cdmsf_sec0;
1467 azt_Play.start.frame = msf.cdmsf_frame0;
1468 azt_Play.end.min = msf.cdmsf_min1;
1469 azt_Play.end.sec = msf.cdmsf_sec1;
1470 azt_Play.end.frame = msf.cdmsf_frame1;
1471 if (cmd == CDROMREADRAW) {
1472 if (DiskInfo.xa) {
1473 return -1; /*XA Disks can't be read raw */
1474 } else {
1475 if (sendAztCmd(ACMD_PLAY_READ_RAW, &azt_Play))
1476 return -1;
1477 DTEN_LOW;
1478 insb(DATA_PORT, buf, CD_FRAMESIZE_RAW);
1479 if (copy_to_user(argp, &buf, CD_FRAMESIZE_RAW))
1480 return -EFAULT;
1481 }
1482 } else
1483 /*CDROMREADCOOKED*/ {
1484 if (sendAztCmd(ACMD_PLAY_READ, &azt_Play))
1485 return -1;
1486 DTEN_LOW;
1487 insb(DATA_PORT, buf, CD_FRAMESIZE);
1488 if (copy_to_user(argp, &buf, CD_FRAMESIZE))
1489 return -EFAULT;
1490 }
1491 }
1492 break;
1493 case CDROMSEEK: /*seek msf address */
1494 if (copy_from_user(&msf, argp, sizeof msf))
1495 return -EFAULT;
1496 /* convert to bcd */
1497 azt_bin2bcd(&msf.cdmsf_min0);
1498 azt_bin2bcd(&msf.cdmsf_sec0);
1499 azt_bin2bcd(&msf.cdmsf_frame0);
1500 azt_Play.start.min = msf.cdmsf_min0;
1501 azt_Play.start.sec = msf.cdmsf_sec0;
1502 azt_Play.start.frame = msf.cdmsf_frame0;
1503 if (aztSeek(&azt_Play))
1504 return -1;
1505 break;
1506 #endif /*end of incompatible code */
1507 case CDROMREADMODE1: /*set read data in mode 1 */
1508 return aztSetDiskType(AZT_MODE_1);
1509 case CDROMREADMODE2: /*set read data in mode 2 */
1510 return aztSetDiskType(AZT_MODE_2);
1511 default:
1512 return -EINVAL;
1513 }
1514 #ifdef AZT_DEBUG
1515 printk("aztcd: exiting aztcd_ioctl Command:%x Time:%li\n", cmd,
1516 jiffies);
1517 #endif
1518 return 0;
1519 }
1520
1521 /*
1522 * Take care of the different block sizes between cdrom and Linux.
1523 * When Linux gets variable block sizes this will probably go away.
1524 */
1525 static void azt_transfer(void)
1526 {
1527 #ifdef AZT_TEST
1528 printk("aztcd: executing azt_transfer Time:%li\n", jiffies);
1529 #endif
1530 if (!current_valid())
1531 return;
1532
1533 while (CURRENT->nr_sectors) {
1534 int bn = CURRENT->sector / 4;
1535 int i;
1536 for (i = 0; i < AZT_BUF_SIZ && azt_buf_bn[i] != bn; ++i);
1537 if (i < AZT_BUF_SIZ) {
1538 int offs = (i * 4 + (CURRENT->sector & 3)) * 512;
1539 int nr_sectors = 4 - (CURRENT->sector & 3);
1540 if (azt_buf_out != i) {
1541 azt_buf_out = i;
1542 if (azt_buf_bn[i] != bn) {
1543 azt_buf_out = -1;
1544 continue;
1545 }
1546 }
1547 if (nr_sectors > CURRENT->nr_sectors)
1548 nr_sectors = CURRENT->nr_sectors;
1549 memcpy(CURRENT->buffer, azt_buf + offs,
1550 nr_sectors * 512);
1551 CURRENT->nr_sectors -= nr_sectors;
1552 CURRENT->sector += nr_sectors;
1553 CURRENT->buffer += nr_sectors * 512;
1554 } else {
1555 azt_buf_out = -1;
1556 break;
1557 }
1558 }
1559 }
1560
1561 static void do_aztcd_request(request_queue_t * q)
1562 {
1563 #ifdef AZT_TEST
1564 printk(" do_aztcd_request(%ld+%ld) Time:%li\n", CURRENT->sector,
1565 CURRENT->nr_sectors, jiffies);
1566 #endif
1567 if (DiskInfo.audio) {
1568 printk("aztcd: Error, tried to mount an Audio CD\n");
1569 end_request(CURRENT, 0);
1570 return;
1571 }
1572 azt_transfer_is_active = 1;
1573 while (current_valid()) {
1574 azt_transfer();
1575 if (CURRENT->nr_sectors == 0) {
1576 end_request(CURRENT, 1);
1577 } else {
1578 azt_buf_out = -1; /* Want to read a block not in buffer */
1579 if (azt_state == AZT_S_IDLE) {
1580 if ((!aztTocUpToDate) || aztDiskChanged) {
1581 if (aztUpdateToc() < 0) {
1582 while (current_valid())
1583 end_request(CURRENT, 0);
1584 break;
1585 }
1586 }
1587 azt_state = AZT_S_START;
1588 AztTries = 5;
1589 SET_TIMER(azt_poll, HZ / 100);
1590 }
1591 break;
1592 }
1593 }
1594 azt_transfer_is_active = 0;
1595 #ifdef AZT_TEST2
1596 printk
1597 ("azt_next_bn:%x azt_buf_in:%x azt_buf_out:%x azt_buf_bn:%x\n",
1598 azt_next_bn, azt_buf_in, azt_buf_out, azt_buf_bn[azt_buf_in]);
1599 printk(" do_aztcd_request ends Time:%li\n", jiffies);
1600 #endif
1601 }
1602
1603
1604 static void azt_invalidate_buffers(void)
1605 {
1606 int i;
1607
1608 #ifdef AZT_DEBUG
1609 printk("aztcd: executing azt_invalidate_buffers\n");
1610 #endif
1611 for (i = 0; i < AZT_BUF_SIZ; ++i)
1612 azt_buf_bn[i] = -1;
1613 azt_buf_out = -1;
1614 }
1615
1616 /*
1617 * Open the device special file. Check that a disk is in.
1618 */
1619 static int aztcd_open(struct inode *ip, struct file *fp)
1620 {
1621 int st;
1622
1623 #ifdef AZT_DEBUG
1624 printk("aztcd: starting aztcd_open\n");
1625 #endif
1626
1627 if (aztPresent == 0)
1628 return -ENXIO; /* no hardware */
1629
1630 if (!azt_open_count && azt_state == AZT_S_IDLE) {
1631 azt_invalidate_buffers();
1632
1633 st = getAztStatus(); /* check drive status */
1634 if (st == -1)
1635 goto err_out; /* drive doesn't respond */
1636
1637 if (st & AST_DOOR_OPEN) { /* close door, then get the status again. */
1638 printk("aztcd: Door Open?\n");
1639 aztCloseDoor();
1640 st = getAztStatus();
1641 }
1642
1643 if ((st & AST_NOT_READY) || (st & AST_DSK_CHG)) { /*no disk in drive or changed */
1644 printk
1645 ("aztcd: Disk Changed or No Disk in Drive?\n");
1646 aztTocUpToDate = 0;
1647 }
1648 if (aztUpdateToc())
1649 goto err_out;
1650
1651 }
1652 ++azt_open_count;
1653 aztLockDoor();
1654
1655 #ifdef AZT_DEBUG
1656 printk("aztcd: exiting aztcd_open\n");
1657 #endif
1658 return 0;
1659
1660 err_out:
1661 return -EIO;
1662 }
1663
1664
1665 /*
1666 * On close, we flush all azt blocks from the buffer cache.
1667 */
1668 static int aztcd_release(struct inode *inode, struct file *file)
1669 {
1670 #ifdef AZT_DEBUG
1671 printk("aztcd: executing aztcd_release\n");
1672 printk("inode: %p, device: %s file: %p\n", inode,
1673 inode->i_bdev->bd_disk->disk_name, file);
1674 #endif
1675 if (!--azt_open_count) {
1676 azt_invalidate_buffers();
1677 aztUnlockDoor();
1678 if (azt_auto_eject)
1679 aztSendCmd(ACMD_EJECT);
1680 CLEAR_TIMER;
1681 }
1682 return 0;
1683 }
1684
1685 static struct gendisk *azt_disk;
1686
1687 /*
1688 * Test for presence of drive and initialize it. Called at boot time.
1689 */
1690
1691 static int __init aztcd_init(void)
1692 {
1693 long int count, max_count;
1694 unsigned char result[50];
1695 int st;
1696 void* status = NULL;
1697 int i = 0;
1698 int ret = 0;
1699
1700 if (azt_port == 0) {
1701 printk(KERN_INFO "aztcd: no Aztech CD-ROM Initialization");
1702 return -EIO;
1703 }
1704
1705 printk(KERN_INFO "aztcd: AZTECH, ORCHID, OKANO, WEARNES, TXC, CyDROM "
1706 "CD-ROM Driver\n");
1707 printk(KERN_INFO "aztcd: (C) 1994-98 W.Zimmermann\n");
1708 if (azt_port == -1) {
1709 printk
1710 ("aztcd: DriverVersion=%s For IDE/ATAPI-drives use ide-cd.c\n",
1711 AZT_VERSION);
1712 } else
1713 printk
1714 ("aztcd: DriverVersion=%s BaseAddress=0x%x For IDE/ATAPI-drives use ide-cd.c\n",
1715 AZT_VERSION, azt_port);
1716 printk(KERN_INFO "aztcd: If you have problems, read /usr/src/linux/"
1717 "Documentation/cdrom/aztcd\n");
1718
1719
1720 #ifdef AZT_SW32 /*CDROM connected to Soundwave32 card */
1721 if ((0xFF00 & inw(AZT_SW32_ID_REG)) != 0x4500) {
1722 printk
1723 ("aztcd: no Soundwave32 card detected at base:%x init:%x config:%x id:%x\n",
1724 AZT_SW32_BASE_ADDR, AZT_SW32_INIT,
1725 AZT_SW32_CONFIG_REG, AZT_SW32_ID_REG);
1726 return -EIO;
1727 } else {
1728 printk(KERN_INFO
1729 "aztcd: Soundwave32 card detected at %x Version %x\n",
1730 AZT_SW32_BASE_ADDR, inw(AZT_SW32_ID_REG));
1731 outw(AZT_SW32_INIT, AZT_SW32_CONFIG_REG);
1732 for (count = 0; count < 10000; count++); /*delay a bit */
1733 }
1734 #endif
1735
1736 /* check for presence of drive */
1737
1738 if (azt_port == -1) { /* autoprobing for proprietary interface */
1739 for (i = 0; (azt_port_auto[i] != 0) && (i < 16); i++) {
1740 azt_port = azt_port_auto[i];
1741 printk(KERN_INFO "aztcd: Autoprobing BaseAddress=0x%x"
1742 "\n", azt_port);
1743 /*proprietary interfaces need 4 bytes */
1744 if (!request_region(azt_port, 4, "aztcd")) {
1745 continue;
1746 }
1747 outb(POLLED, MODE_PORT);
1748 inb(CMD_PORT);
1749 inb(CMD_PORT);
1750 outb(ACMD_GET_VERSION, CMD_PORT); /*Try to get version info */
1751
1752 aztTimeOutCount = 0;
1753 do {
1754 aztIndatum = inb(STATUS_PORT);
1755 aztTimeOutCount++;
1756 if (aztTimeOutCount >= AZT_FAST_TIMEOUT)
1757 break;
1758 } while (aztIndatum & AFL_STATUS);
1759 if (inb(DATA_PORT) == AFL_OP_OK) { /* OK drive found */
1760 break;
1761 }
1762 else { /* Drive not found on this port - try next one */
1763 release_region(azt_port, 4);
1764 }
1765 }
1766 if ((azt_port_auto[i] == 0) || (i == 16)) {
1767 printk(KERN_INFO "aztcd: no AZTECH CD-ROM drive found\n");
1768 return -EIO;
1769 }
1770 } else { /* no autoprobing */
1771 if ((azt_port == 0x1f0) || (azt_port == 0x170))
1772 status = request_region(azt_port, 8, "aztcd"); /*IDE-interfaces need 8 bytes */
1773 else
1774 status = request_region(azt_port, 4, "aztcd"); /*proprietary interfaces need 4 bytes */
1775 if (!status) {
1776 printk(KERN_WARNING "aztcd: conflict, I/O port (%X) "
1777 "already used\n", azt_port);
1778 return -EIO;
1779 }
1780
1781 if ((azt_port == 0x1f0) || (azt_port == 0x170))
1782 SWITCH_IDE_SLAVE; /*switch IDE interface to slave configuration */
1783
1784 outb(POLLED, MODE_PORT);
1785 inb(CMD_PORT);
1786 inb(CMD_PORT);
1787 outb(ACMD_GET_VERSION, CMD_PORT); /*Try to get version info */
1788
1789 aztTimeOutCount = 0;
1790 do {
1791 aztIndatum = inb(STATUS_PORT);
1792 aztTimeOutCount++;
1793 if (aztTimeOutCount >= AZT_FAST_TIMEOUT)
1794 break;
1795 } while (aztIndatum & AFL_STATUS);
1796
1797 if (inb(DATA_PORT) != AFL_OP_OK) { /*OP_OK? If not, reset and try again */
1798 #ifndef MODULE
1799 if (azt_cont != 0x79) {
1800 printk(KERN_WARNING "aztcd: no AZTECH CD-ROM "
1801 "drive found-Try boot parameter aztcd="
1802 "<BaseAddress>,0x79\n");
1803 ret = -EIO;
1804 goto err_out;
1805 }
1806 #else
1807 if (0) {
1808 }
1809 #endif
1810 else {
1811 printk(KERN_INFO "aztcd: drive reset - "
1812 "please wait\n");
1813 for (count = 0; count < 50; count++) {
1814 inb(STATUS_PORT); /*removing all data from earlier tries */
1815 inb(DATA_PORT);
1816 }
1817 outb(POLLED, MODE_PORT);
1818 inb(CMD_PORT);
1819 inb(CMD_PORT);
1820 getAztStatus(); /*trap errors */
1821 outb(ACMD_SOFT_RESET, CMD_PORT); /*send reset */
1822 STEN_LOW;
1823 if (inb(DATA_PORT) != AFL_OP_OK) { /*OP_OK? */
1824 printk(KERN_WARNING "aztcd: no AZTECH "
1825 "CD-ROM drive found\n");
1826 ret = -EIO;
1827 goto err_out;
1828 }
1829
1830 for (count = 0; count < AZT_TIMEOUT;
1831 count++)
1832 barrier(); /* Stop gcc 2.96 being smart */
1833 /* use udelay(), damnit -- AV */
1834
1835 if ((st = getAztStatus()) == -1) {
1836 printk(KERN_WARNING "aztcd: Drive Status"
1837 " Error Status=%x\n", st);
1838 ret = -EIO;
1839 goto err_out;
1840 }
1841 #ifdef AZT_DEBUG
1842 printk(KERN_DEBUG "aztcd: Status = %x\n", st);
1843 #endif
1844 outb(POLLED, MODE_PORT);
1845 inb(CMD_PORT);
1846 inb(CMD_PORT);
1847 outb(ACMD_GET_VERSION, CMD_PORT); /*GetVersion */
1848 STEN_LOW;
1849 OP_OK;
1850 }
1851 }
1852 }
1853
1854 azt_init_end = 1;
1855 STEN_LOW;
1856 result[0] = inb(DATA_PORT); /*reading in a null byte??? */
1857 for (count = 1; count < 50; count++) { /*Reading version string */
1858 aztTimeOutCount = 0; /*here we must implement STEN_LOW differently */
1859 do {
1860 aztIndatum = inb(STATUS_PORT); /*because we want to exit by timeout */
1861 aztTimeOutCount++;
1862 if (aztTimeOutCount >= AZT_FAST_TIMEOUT)
1863 break;
1864 } while (aztIndatum & AFL_STATUS);
1865 if (aztTimeOutCount >= AZT_FAST_TIMEOUT)
1866 break; /*all chars read? */
1867 result[count] = inb(DATA_PORT);
1868 }
1869 if (count > 30)
1870 max_count = 30; /*print max.30 chars of the version string */
1871 else
1872 max_count = count;
1873 printk(KERN_INFO "aztcd: FirmwareVersion=");
1874 for (count = 1; count < max_count; count++)
1875 printk("%c", result[count]);
1876 printk("<<>> ");
1877
1878 if ((result[1] == 'A') && (result[2] == 'Z') && (result[3] == 'T')) {
1879 printk("AZTECH drive detected\n");
1880 /*AZTECH*/}
1881 else if ((result[2] == 'C') && (result[3] == 'D')
1882 && (result[4] == 'D')) {
1883 printk("ORCHID or WEARNES drive detected\n"); /*ORCHID or WEARNES */
1884 } else if ((result[1] == 0x03) && (result[2] == '5')) {
1885 printk("TXC or CyCDROM drive detected\n"); /*Conrad TXC, CyCDROM */
1886 } else { /*OTHERS or none */
1887 printk("\nunknown drive or firmware version detected\n");
1888 printk
1889 ("aztcd may not run stable, if you want to try anyhow,\n");
1890 printk("boot with: aztcd=<BaseAddress>,0x79\n");
1891 if ((azt_cont != 0x79)) {
1892 printk("aztcd: FirmwareVersion=");
1893 for (count = 1; count < 5; count++)
1894 printk("%c", result[count]);
1895 printk("<<>> ");
1896 printk("Aborted\n");
1897 ret = -EIO;
1898 goto err_out;
1899 }
1900 }
1901 azt_disk = alloc_disk(1);
1902 if (!azt_disk)
1903 goto err_out;
1904
1905 if (register_blkdev(MAJOR_NR, "aztcd")) {
1906 ret = -EIO;
1907 goto err_out2;
1908 }
1909
1910 azt_queue = blk_init_queue(do_aztcd_request, &aztSpin);
1911 if (!azt_queue) {
1912 ret = -ENOMEM;
1913 goto err_out3;
1914 }
1915
1916 blk_queue_hardsect_size(azt_queue, 2048);
1917 azt_disk->major = MAJOR_NR;
1918 azt_disk->first_minor = 0;
1919 azt_disk->fops = &azt_fops;
1920 sprintf(azt_disk->disk_name, "aztcd");
1921 sprintf(azt_disk->devfs_name, "aztcd");
1922 azt_disk->queue = azt_queue;
1923 add_disk(azt_disk);
1924 azt_invalidate_buffers();
1925 aztPresent = 1;
1926 aztCloseDoor();
1927 return 0;
1928 err_out3:
1929 unregister_blkdev(MAJOR_NR, "aztcd");
1930 err_out2:
1931 put_disk(azt_disk);
1932 err_out:
1933 if ((azt_port == 0x1f0) || (azt_port == 0x170)) {
1934 SWITCH_IDE_MASTER;
1935 release_region(azt_port, 8); /*IDE-interface */
1936 } else
1937 release_region(azt_port, 4); /*proprietary interface */
1938 return ret;
1939
1940 }
1941
1942 static void __exit aztcd_exit(void)
1943 {
1944 del_gendisk(azt_disk);
1945 put_disk(azt_disk);
1946 if ((unregister_blkdev(MAJOR_NR, "aztcd") == -EINVAL)) {
1947 printk("What's that: can't unregister aztcd\n");
1948 return;
1949 }
1950 blk_cleanup_queue(azt_queue);
1951 if ((azt_port == 0x1f0) || (azt_port == 0x170)) {
1952 SWITCH_IDE_MASTER;
1953 release_region(azt_port, 8); /*IDE-interface */
1954 } else
1955 release_region(azt_port, 4); /*proprietary interface */
1956 printk(KERN_INFO "aztcd module released.\n");
1957 }
1958
1959 module_init(aztcd_init);
1960 module_exit(aztcd_exit);
1961
1962 /*##########################################################################
1963 Aztcd State Machine: Controls Drive Operating State
1964 ##########################################################################
1965 */
1966 static void azt_poll(void)
1967 {
1968 int st = 0;
1969 int loop_ctl = 1;
1970 int skip = 0;
1971
1972 if (azt_error) {
1973 if (aztSendCmd(ACMD_GET_ERROR))
1974 RETURN("azt_poll 1");
1975 STEN_LOW;
1976 azt_error = inb(DATA_PORT) & 0xFF;
1977 printk("aztcd: I/O error 0x%02x\n", azt_error);
1978 azt_invalidate_buffers();
1979 #ifdef WARN_IF_READ_FAILURE
1980 if (AztTries == 5)
1981 printk
1982 ("aztcd: Read of Block %d Failed - Maybe Audio Disk?\n",
1983 azt_next_bn);
1984 #endif
1985 if (!AztTries--) {
1986 printk
1987 ("aztcd: Read of Block %d Failed, Maybe Audio Disk? Giving up\n",
1988 azt_next_bn);
1989 if (azt_transfer_is_active) {
1990 AztTries = 0;
1991 loop_ctl = 0;
1992 }
1993 if (current_valid())
1994 end_request(CURRENT, 0);
1995 AztTries = 5;
1996 }
1997 azt_error = 0;
1998 azt_state = AZT_S_STOP;
1999 }
2000
2001 while (loop_ctl) {
2002 loop_ctl = 0; /* each case must flip this back to 1 if we want
2003 to come back up here */
2004 switch (azt_state) {
2005
2006 case AZT_S_IDLE:
2007 #ifdef AZT_TEST3
2008 if (azt_state != azt_state_old) {
2009 azt_state_old = azt_state;
2010 printk("AZT_S_IDLE\n");
2011 }
2012 #endif
2013 return;
2014
2015 case AZT_S_START:
2016 #ifdef AZT_TEST3
2017 if (azt_state != azt_state_old) {
2018 azt_state_old = azt_state;
2019 printk("AZT_S_START\n");
2020 }
2021 #endif
2022 if (aztSendCmd(ACMD_GET_STATUS))
2023 RETURN("azt_poll 2"); /*result will be checked by aztStatus() */
2024 azt_state =
2025 azt_mode == 1 ? AZT_S_READ : AZT_S_MODE;
2026 AztTimeout = 3000;
2027 break;
2028
2029 case AZT_S_MODE:
2030 #ifdef AZT_TEST3
2031 if (azt_state != azt_state_old) {
2032 azt_state_old = azt_state;
2033 printk("AZT_S_MODE\n");
2034 }
2035 #endif
2036 if (!skip) {
2037 if ((st = aztStatus()) != -1) {
2038 if ((st & AST_DSK_CHG)
2039 || (st & AST_NOT_READY)) {
2040 aztDiskChanged = 1;
2041 aztTocUpToDate = 0;
2042 azt_invalidate_buffers();
2043 end_request(CURRENT, 0);
2044 printk
2045 ("aztcd: Disk Changed or Not Ready 1 - Unmount Disk!\n");
2046 }
2047 } else
2048 break;
2049 }
2050 skip = 0;
2051
2052 if ((st & AST_DOOR_OPEN) || (st & AST_NOT_READY)) {
2053 aztDiskChanged = 1;
2054 aztTocUpToDate = 0;
2055 printk
2056 ("aztcd: Disk Changed or Not Ready 2 - Unmount Disk!\n");
2057 end_request(CURRENT, 0);
2058 printk((st & AST_DOOR_OPEN) ?
2059 "aztcd: door open\n" :
2060 "aztcd: disk removed\n");
2061 if (azt_transfer_is_active) {
2062 azt_state = AZT_S_START;
2063 loop_ctl = 1; /* goto immediately */
2064 break;
2065 }
2066 azt_state = AZT_S_IDLE;
2067 while (current_valid())
2068 end_request(CURRENT, 0);
2069 return;
2070 }
2071
2072 /* if (aztSendCmd(ACMD_SET_MODE)) RETURN("azt_poll 3");
2073 outb(0x01, DATA_PORT);
2074 PA_OK;
2075 STEN_LOW;
2076 */
2077 if (aztSendCmd(ACMD_GET_STATUS))
2078 RETURN("azt_poll 4");
2079 STEN_LOW;
2080 azt_mode = 1;
2081 azt_state = AZT_S_READ;
2082 AztTimeout = 3000;
2083
2084 break;
2085
2086
2087 case AZT_S_READ:
2088 #ifdef AZT_TEST3
2089 if (azt_state != azt_state_old) {
2090 azt_state_old = azt_state;
2091 printk("AZT_S_READ\n");
2092 }
2093 #endif
2094 if (!skip) {
2095 if ((st = aztStatus()) != -1) {
2096 if ((st & AST_DSK_CHG)
2097 || (st & AST_NOT_READY)) {
2098 aztDiskChanged = 1;
2099 aztTocUpToDate = 0;
2100 azt_invalidate_buffers();
2101 printk
2102 ("aztcd: Disk Changed or Not Ready 3 - Unmount Disk!\n");
2103 end_request(CURRENT, 0);
2104 }
2105 } else
2106 break;
2107 }
2108
2109 skip = 0;
2110 if ((st & AST_DOOR_OPEN) || (st & AST_NOT_READY)) {
2111 aztDiskChanged = 1;
2112 aztTocUpToDate = 0;
2113 printk((st & AST_DOOR_OPEN) ?
2114 "aztcd: door open\n" :
2115 "aztcd: disk removed\n");
2116 if (azt_transfer_is_active) {
2117 azt_state = AZT_S_START;
2118 loop_ctl = 1;
2119 break;
2120 }
2121 azt_state = AZT_S_IDLE;
2122 while (current_valid())
2123 end_request(CURRENT, 0);
2124 return;
2125 }
2126
2127 if (current_valid()) {
2128 struct azt_Play_msf msf;
2129 int i;
2130 azt_next_bn = CURRENT->sector / 4;
2131 azt_hsg2msf(azt_next_bn, &msf.start);
2132 i = 0;
2133 /* find out in which track we are */
2134 while (azt_msf2hsg(&msf.start) >
2135 azt_msf2hsg(&Toc[++i].trackTime)) {
2136 };
2137 if (azt_msf2hsg(&msf.start) <
2138 azt_msf2hsg(&Toc[i].trackTime) -
2139 AZT_BUF_SIZ) {
2140 azt_read_count = AZT_BUF_SIZ; /*fast, because we read ahead */
2141 /*azt_read_count=CURRENT->nr_sectors; slow, no read ahead */
2142 } else /* don't read beyond end of track */
2143 #if AZT_MULTISESSION
2144 {
2145 azt_read_count =
2146 (azt_msf2hsg(&Toc[i].trackTime)
2147 / 4) * 4 -
2148 azt_msf2hsg(&msf.start);
2149 if (azt_read_count < 0)
2150 azt_read_count = 0;
2151 if (azt_read_count > AZT_BUF_SIZ)
2152 azt_read_count =
2153 AZT_BUF_SIZ;
2154 printk
2155 ("aztcd: warning - trying to read beyond end of track\n");
2156 /* printk("%i %i %li %li\n",i,azt_read_count,azt_msf2hsg(&msf.start),azt_msf2hsg(&Toc[i].trackTime));
2157 */ }
2158 #else
2159 {
2160 azt_read_count = AZT_BUF_SIZ;
2161 }
2162 #endif
2163 msf.end.min = 0;
2164 msf.end.sec = 0;
2165 msf.end.frame = azt_read_count; /*Mitsumi here reads 0xffffff sectors */
2166 #ifdef AZT_TEST3
2167 printk
2168 ("---reading msf-address %x:%x:%x %x:%x:%x\n",
2169 msf.start.min, msf.start.sec,
2170 msf.start.frame, msf.end.min,
2171 msf.end.sec, msf.end.frame);
2172 printk
2173 ("azt_next_bn:%x azt_buf_in:%x azt_buf_out:%x azt_buf_bn:%x\n",
2174 azt_next_bn, azt_buf_in, azt_buf_out,
2175 azt_buf_bn[azt_buf_in]);
2176 #endif
2177 if (azt_read_mode == AZT_MODE_2) {
2178 sendAztCmd(ACMD_PLAY_READ_RAW, &msf); /*XA disks in raw mode */
2179 } else {
2180 sendAztCmd(ACMD_PLAY_READ, &msf); /*others in cooked mode */
2181 }
2182 azt_state = AZT_S_DATA;
2183 AztTimeout = READ_TIMEOUT;
2184 } else {
2185 azt_state = AZT_S_STOP;
2186 loop_ctl = 1;
2187 break;
2188 }
2189
2190 break;
2191
2192
2193 case AZT_S_DATA:
2194 #ifdef AZT_TEST3
2195 if (azt_state != azt_state_old) {
2196 azt_state_old = azt_state;
2197 printk("AZT_S_DATA\n");
2198 }
2199 #endif
2200
2201 st = inb(STATUS_PORT) & AFL_STATUSorDATA;
2202
2203 switch (st) {
2204
2205 case AFL_DATA:
2206 #ifdef AZT_TEST3
2207 if (st != azt_st_old) {
2208 azt_st_old = st;
2209 printk("---AFL_DATA st:%x\n", st);
2210 }
2211 #endif
2212 if (!AztTries--) {
2213 printk
2214 ("aztcd: Read of Block %d Failed, Maybe Audio Disk ? Giving up\n",
2215 azt_next_bn);
2216 if (azt_transfer_is_active) {
2217 AztTries = 0;
2218 break;
2219 }
2220 if (current_valid())
2221 end_request(CURRENT, 0);
2222 AztTries = 5;
2223 }
2224 azt_state = AZT_S_START;
2225 AztTimeout = READ_TIMEOUT;
2226 loop_ctl = 1;
2227 break;
2228
2229 case AFL_STATUSorDATA:
2230 #ifdef AZT_TEST3
2231 if (st != azt_st_old) {
2232 azt_st_old = st;
2233 printk
2234 ("---AFL_STATUSorDATA st:%x\n",
2235 st);
2236 }
2237 #endif
2238 break;
2239
2240 default:
2241 #ifdef AZT_TEST3
2242 if (st != azt_st_old) {
2243 azt_st_old = st;
2244 printk("---default: st:%x\n", st);
2245 }
2246 #endif
2247 AztTries = 5;
2248 if (!current_valid() && azt_buf_in == azt_buf_out) {
2249 azt_state = AZT_S_STOP;
2250 loop_ctl = 1;
2251 break;
2252 }
2253 if (azt_read_count <= 0)
2254 printk
2255 ("aztcd: warning - try to read 0 frames\n");
2256 while (azt_read_count) { /*??? fast read ahead loop */
2257 azt_buf_bn[azt_buf_in] = -1;
2258 DTEN_LOW; /*??? unsolved problem, very
2259 seldom we get timeouts
2260 here, don't now the real
2261 reason. With my drive this
2262 sometimes also happens with
2263 Aztech's original driver under
2264 DOS. Is it a hardware bug?
2265 I tried to recover from such
2266 situations here. Zimmermann */
2267 if (aztTimeOutCount >= AZT_TIMEOUT) {
2268 printk
2269 ("read_count:%d CURRENT->nr_sectors:%ld azt_buf_in:%d\n",
2270 azt_read_count,
2271 CURRENT->nr_sectors,
2272 azt_buf_in);
2273 printk
2274 ("azt_transfer_is_active:%x\n",
2275 azt_transfer_is_active);
2276 azt_read_count = 0;
2277 azt_state = AZT_S_STOP;
2278 loop_ctl = 1;
2279 end_request(CURRENT, 1); /*should we have here (1) or (0)? */
2280 } else {
2281 if (azt_read_mode ==
2282 AZT_MODE_2) {
2283 insb(DATA_PORT,
2284 azt_buf +
2285 CD_FRAMESIZE_RAW
2286 * azt_buf_in,
2287 CD_FRAMESIZE_RAW);
2288 } else {
2289 insb(DATA_PORT,
2290 azt_buf +
2291 CD_FRAMESIZE *
2292 azt_buf_in,
2293 CD_FRAMESIZE);
2294 }
2295 azt_read_count--;
2296 #ifdef AZT_TEST3
2297 printk
2298 ("AZT_S_DATA; ---I've read data- read_count: %d\n",
2299 azt_read_count);
2300 printk
2301 ("azt_next_bn:%d azt_buf_in:%d azt_buf_out:%d azt_buf_bn:%d\n",
2302 azt_next_bn,
2303 azt_buf_in,
2304 azt_buf_out,
2305 azt_buf_bn
2306 [azt_buf_in]);
2307 #endif
2308 azt_buf_bn[azt_buf_in] =
2309 azt_next_bn++;
2310 if (azt_buf_out == -1)
2311 azt_buf_out =
2312 azt_buf_in;
2313 azt_buf_in =
2314 azt_buf_in + 1 ==
2315 AZT_BUF_SIZ ? 0 :
2316 azt_buf_in + 1;
2317 }
2318 }
2319 if (!azt_transfer_is_active) {
2320 while (current_valid()) {
2321 azt_transfer();
2322 if (CURRENT->nr_sectors ==
2323 0)
2324 end_request(CURRENT, 1);
2325 else
2326 break;
2327 }
2328 }
2329
2330 if (current_valid()
2331 && (CURRENT->sector / 4 < azt_next_bn
2332 || CURRENT->sector / 4 >
2333 azt_next_bn + AZT_BUF_SIZ)) {
2334 azt_state = AZT_S_STOP;
2335 loop_ctl = 1;
2336 break;
2337 }
2338 AztTimeout = READ_TIMEOUT;
2339 if (azt_read_count == 0) {
2340 azt_state = AZT_S_STOP;
2341 loop_ctl = 1;
2342 break;
2343 }
2344 break;
2345 }
2346 break;
2347
2348
2349 case AZT_S_STOP:
2350 #ifdef AZT_TEST3
2351 if (azt_state != azt_state_old) {
2352 azt_state_old = azt_state;
2353 printk("AZT_S_STOP\n");
2354 }
2355 #endif
2356 if (azt_read_count != 0)
2357 printk("aztcd: discard data=%x frames\n",
2358 azt_read_count);
2359 while (azt_read_count != 0) {
2360 int i;
2361 if (!(inb(STATUS_PORT) & AFL_DATA)) {
2362 if (azt_read_mode == AZT_MODE_2)
2363 for (i = 0;
2364 i < CD_FRAMESIZE_RAW;
2365 i++)
2366 inb(DATA_PORT);
2367 else
2368 for (i = 0;
2369 i < CD_FRAMESIZE; i++)
2370 inb(DATA_PORT);
2371 }
2372 azt_read_count--;
2373 }
2374 if (aztSendCmd(ACMD_GET_STATUS))
2375 RETURN("azt_poll 5");
2376 azt_state = AZT_S_STOPPING;
2377 AztTimeout = 1000;
2378 break;
2379
2380 case AZT_S_STOPPING:
2381 #ifdef AZT_TEST3
2382 if (azt_state != azt_state_old) {
2383 azt_state_old = azt_state;
2384 printk("AZT_S_STOPPING\n");
2385 }
2386 #endif
2387
2388 if ((st = aztStatus()) == -1 && AztTimeout)
2389 break;
2390
2391 if ((st != -1)
2392 && ((st & AST_DSK_CHG)
2393 || (st & AST_NOT_READY))) {
2394 aztDiskChanged = 1;
2395 aztTocUpToDate = 0;
2396 azt_invalidate_buffers();
2397 printk
2398 ("aztcd: Disk Changed or Not Ready 4 - Unmount Disk!\n");
2399 end_request(CURRENT, 0);
2400 }
2401
2402 #ifdef AZT_TEST3
2403 printk("CURRENT_VALID %d azt_mode %d\n",
2404 current_valid(), azt_mode);
2405 #endif
2406
2407 if (current_valid()) {
2408 if (st != -1) {
2409 if (azt_mode == 1) {
2410 azt_state = AZT_S_READ;
2411 loop_ctl = 1;
2412 skip = 1;
2413 break;
2414 } else {
2415 azt_state = AZT_S_MODE;
2416 loop_ctl = 1;
2417 skip = 1;
2418 break;
2419 }
2420 } else {
2421 azt_state = AZT_S_START;
2422 AztTimeout = 1;
2423 }
2424 } else {
2425 azt_state = AZT_S_IDLE;
2426 return;
2427 }
2428 break;
2429
2430 default:
2431 printk("aztcd: invalid state %d\n", azt_state);
2432 return;
2433 } /* case */
2434 } /* while */
2435
2436
2437 if (!AztTimeout--) {
2438 printk("aztcd: timeout in state %d\n", azt_state);
2439 azt_state = AZT_S_STOP;
2440 if (aztSendCmd(ACMD_STOP))
2441 RETURN("azt_poll 6");
2442 STEN_LOW_WAIT;
2443 };
2444
2445 SET_TIMER(azt_poll, HZ / 100);
2446 }
2447
2448
2449 /*###########################################################################
2450 * Miscellaneous support functions
2451 ###########################################################################
2452 */
2453 static void azt_hsg2msf(long hsg, struct msf *msf)
2454 {
2455 hsg += 150;
2456 msf->min = hsg / 4500;
2457 hsg %= 4500;
2458 msf->sec = hsg / 75;
2459 msf->frame = hsg % 75;
2460 #ifdef AZT_DEBUG
2461 if (msf->min >= 70)
2462 printk("aztcd: Error hsg2msf address Minutes\n");
2463 if (msf->sec >= 60)
2464 printk("aztcd: Error hsg2msf address Seconds\n");
2465 if (msf->frame >= 75)
2466 printk("aztcd: Error hsg2msf address Frames\n");
2467 #endif
2468 azt_bin2bcd(&msf->min); /* convert to BCD */
2469 azt_bin2bcd(&msf->sec);
2470 azt_bin2bcd(&msf->frame);
2471 }
2472
2473 static long azt_msf2hsg(struct msf *mp)
2474 {
2475 return azt_bcd2bin(mp->frame) + azt_bcd2bin(mp->sec) * 75
2476 + azt_bcd2bin(mp->min) * 4500 - CD_MSF_OFFSET;
2477 }
2478
2479 static void azt_bin2bcd(unsigned char *p)
2480 {
2481 int u, t;
2482
2483 u = *p % 10;
2484 t = *p / 10;
2485 *p = u | (t << 4);
2486 }
2487
2488 static int azt_bcd2bin(unsigned char bcd)
2489 {
2490 return (bcd >> 4) * 10 + (bcd & 0xF);
2491 }
2492
2493 MODULE_LICENSE("GPL");
2494 MODULE_ALIAS_BLOCKDEV_MAJOR(AZTECH_CDROM_MAJOR);
A mirror of Linus' kernel repository