Commit | Line | Data |
---|---|---|
1da177e4 LT |
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); | |
8d06afab | 300 | static DEFINE_TIMER(delay_timer, NULL, 0, 0); |
1da177e4 LT |
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(¬Used)) | |
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(¬Used) < 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 | } | |
d93c2efc | 1766 | if ((i == 16) || (azt_port_auto[i] == 0)) { |
1da177e4 LT |
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); |