Pull ibm into release branch
[linux-2.6] / drivers / cdrom / cm206.c
1 /* cm206.c. A linux-driver for the cm206 cdrom player with cm260 adapter card.
2    Copyright (c) 1995--1997 David A. van Leeuwen.
3    $Id: cm206.c,v 1.5 1997/12/26 11:02:51 david Exp $
4    
5      This program is free software; you can redistribute it and/or modify
6      it under the terms of the GNU General Public License as published by
7      the Free Software Foundation; either version 2 of the License, or
8      (at your option) any later version.
9      
10      This program is distributed in the hope that it will be useful,
11      but WITHOUT ANY WARRANTY; without even the implied warranty of
12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13      GNU General Public License for more details.
14      
15      You should have received a copy of the GNU General Public License
16      along with this program; if not, write to the Free Software
17      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18
19 History:
20  Started 25 jan 1994. Waiting for documentation...
21  22 feb 1995: 0.1a first reasonably safe polling driver.
22               Two major bugs, one in read_sector and one in 
23               do_cm206_request, happened to cancel!
24  25 feb 1995: 0.2a first reasonable interrupt driven version of above.
25               uart writes are still done in polling mode. 
26  25 feb 1995: 0.21a writes also in interrupt mode, still some
27               small bugs to be found... Larger buffer. 
28   2 mrt 1995: 0.22 Bug found (cd-> nowhere, interrupt was called in
29               initialization), read_ahead of 16. Timeouts implemented.
30               unclear if they do something...
31   7 mrt 1995: 0.23 Start of background read-ahead.
32  18 mrt 1995: 0.24 Working background read-ahead. (still problems)
33  26 mrt 1995: 0.25 Multi-session ioctl added (kernel v1.2).
34               Statistics implemented, though separate stats206.h.
35               Accessible through ioctl 0x1000 (just a number).
36               Hard to choose between v1.2 development and 1.1.75.
37               Bottom-half doesn't work with 1.2...
38               0.25a: fixed... typo. Still problems...
39   1 apr 1995: 0.26 Module support added. Most bugs found. Use kernel 1.2.n.
40   5 apr 1995: 0.27 Auto-probe for the adapter card base address.
41               Auto-probe for the adaptor card irq line.
42   7 apr 1995: 0.28 Added lilo setup support for base address and irq.
43               Use major number 32 (not in this source), officially
44               assigned to this driver.
45   9 apr 1995: 0.29 Added very limited audio support. Toc_header, stop, pause,
46               resume, eject. Play_track ignores track info, because we can't 
47               read a table-of-contents entry. Toc_entry is implemented
48               as a `placebo' function: always returns start of disc. 
49   3 may 1995: 0.30 Audio support completed. The get_toc_entry function
50               is implemented as a binary search. 
51  15 may 1995: 0.31 More work on audio stuff. Workman is not easy to 
52               satisfy; changed binary search into linear search.
53               Auto-probe for base address somewhat relaxed.
54   1 jun 1995: 0.32 Removed probe_irq_on/off for module version.
55  10 jun 1995: 0.33 Workman still behaves funny, but you should be
56               able to eject and substitute another disc.
57
58  An adaptation of 0.33 is included in linux-1.3.7 by Eberhard Moenkeberg
59
60  18 jul 1995: 0.34 Patch by Heiko Eissfeldt included, mainly considering 
61               verify_area's in the ioctls. Some bugs introduced by 
62               EM considering the base port and irq fixed. 
63
64  18 dec 1995: 0.35 Add some code for error checking... no luck...
65
66  We jump to reach our goal: version 1.0 in the next stable linux kernel.
67
68  19 mar 1996: 0.95 Different implementation of CDROM_GET_UPC, on
69               request of Thomas Quinot. 
70  25 mar 1996: 0.96 Interpretation of opening with O_WRONLY or O_RDWR:
71               open only for ioctl operation, e.g., for operation of
72               tray etc.
73  4 apr 1996:  0.97 First implementation of layer between VFS and cdrom
74               driver, a generic interface. Much of the functionality
75               of cm206_open() and cm206_ioctl() is transferred to a
76               new file cdrom.c and its header ucdrom.h. 
77
78               Upgrade to Linux kernel 1.3.78. 
79
80  11 apr 1996  0.98 Upgrade to Linux kernel 1.3.85
81               More code moved to cdrom.c
82  
83               0.99 Some more small changes to decrease number
84               of oopses at module load; 
85  
86  27 jul 1996  0.100 Many hours of debugging, kernel change from 1.2.13
87               to 2.0.7 seems to have introduced some weird behavior
88               in (interruptible_)sleep_on(&cd->data): the process
89               seems to be woken without any explicit wake_up in my own
90               code. Patch to try 100x in case such untriggered wake_up's 
91               occur. 
92
93  28 jul 1996  0.101 Rewriting of the code that receives the command echo,
94               using a fifo to store echoed bytes. 
95
96               Branch from 0.99:
97  
98               0.99.1.0 Update to kernel release 2.0.10 dev_t -> kdev_t
99               (emoenke) various typos found by others.  extra
100               module-load oops protection.
101  
102               0.99.1.1 Initialization constant cdrom_dops.speed
103               changed from float (2.0) to int (2); Cli()-sti() pair
104               around cm260_reset() in module initialization code.
105  
106               0.99.1.2 Changes literally as proposed by Scott Snyder
107               <snyder@d0sgif.fnal.gov> for the 2.1 kernel line, which
108               have to do mainly with the poor minor support i had. The
109               major new concept is to change a cdrom driver's
110               operations struct from the capabilities struct. This
111               reflects the fact that there is one major for a driver,
112               whilst there can be many minors whith completely
113               different capabilities.
114
115               0.99.1.3 More changes for operations/info separation.
116
117               0.99.1.4 Added speed selection (someone had to do this
118               first).
119
120   23 jan 1997 0.99.1.5 MODULE_PARMS call added.
121
122   23 jan 1997 0.100.1.2--0.100.1.5 following similar lines as 
123               0.99.1.1--0.99.1.5. I get too many complaints about the
124               drive making read errors. What't wrong with the 2.0+
125               kernel line? Why get i (and othe cm206 owners) weird
126               results? Why were things good in the good old 1.1--1.2 
127               era? Why don't i throw away the drive?
128
129  2 feb 1997   0.102 Added `volatile' to values in cm206_struct. Seems to 
130               reduce many of the problems. Rewrote polling routines
131               to use fixed delays between polls. 
132               0.103 Changed printk behavior. 
133               0.104 Added a 0.100 -> 0.100.1.1 change
134
135 11 feb 1997   0.105 Allow auto_probe during module load, disable
136               with module option "auto_probe=0". Moved some debugging
137               statements to lower priority. Implemented select_speed()
138               function. 
139
140 13 feb 1997   1.0 Final version for 2.0 kernel line. 
141
142               All following changes will be for the 2.1 kernel line. 
143
144 15 feb 1997   1.1 Keep up with kernel 2.1.26, merge in changes from 
145               cdrom.c 0.100.1.1--1.0. Add some more MODULE_PARMS. 
146
147 14 sep 1997   1.2 Upgrade to Linux 2.1.55.  Added blksize_size[], patch
148               sent by James Bottomley <James.Bottomley@columbiasc.ncr.com>.
149
150 21 dec 1997   1.4 Upgrade to Linux 2.1.72.  
151
152 24 jan 1998   Removed the cm206_disc_status() function, as it was now dead
153               code.  The Uniform CDROM driver now provides this functionality.
154               
155 9 Nov. 1999   Make kernel-parameter implementation work with 2.3.x 
156               Removed init_module & cleanup_module in favor of 
157               module_init & module_exit.
158               Torben Mathiasen <tmm@image.dk>
159  * 
160  * Parts of the code are based upon lmscd.c written by Kai Petzke,
161  * sbpcd.c written by Eberhard Moenkeberg, and mcd.c by Martin
162  * Harriss, but any off-the-shelf dynamic programming algorithm won't
163  * be able to find them.
164  *
165  * The cm206 drive interface and the cm260 adapter card seem to be 
166  * sufficiently different from their cm205/cm250 counterparts
167  * in order to write a complete new driver.
168  * 
169  * I call all routines connected to the Linux kernel something
170  * with `cm206' in it, as this stuff is too series-dependent. 
171  * 
172  * Currently, my limited knowledge is based on:
173  * - The Linux Kernel Hacker's guide, v. 0.5, by Michael K. Johnson
174  * - Linux Kernel Programmierung, by Michael Beck and others
175  * - Philips/LMS cm206 and cm226 product specification
176  * - Philips/LMS cm260 product specification
177  *
178  * David van Leeuwen, david@tm.tno.nl.  */
179 #define REVISION "$Revision: 1.5 $"
180
181 #include <linux/module.h>
182
183 #include <linux/errno.h>        /* These include what we really need */
184 #include <linux/delay.h>
185 #include <linux/string.h>
186 #include <linux/interrupt.h>
187 #include <linux/timer.h>
188 #include <linux/cdrom.h>
189 #include <linux/ioport.h>
190 #include <linux/mm.h>
191 #include <linux/slab.h>
192 #include <linux/init.h>
193
194 /* #include <linux/ucdrom.h> */
195
196 #include <asm/io.h>
197
198 #define MAJOR_NR CM206_CDROM_MAJOR
199
200 #include <linux/blkdev.h>
201
202 #undef DEBUG
203 #define STATISTICS              /* record times and frequencies of events */
204 #define AUTO_PROBE_MODULE
205 #define USE_INSW
206
207 #include "cm206.h"
208
209 /* This variable defines whether or not to probe for adapter base port 
210    address and interrupt request. It can be overridden by the boot 
211    parameter `auto'.
212 */
213 static int auto_probe = 1;      /* Yes, why not? */
214
215 static int cm206_base = CM206_BASE;
216 static int cm206_irq = CM206_IRQ;
217 #ifdef MODULE
218 static int cm206[2] = { 0, 0 }; /* for compatible `insmod' parameter passing */
219 module_param_array(cm206, int, NULL, 0);        /* base,irq or irq,base */
220 #endif
221
222 module_param(cm206_base, int, 0);       /* base */
223 module_param(cm206_irq, int, 0);        /* irq */
224 module_param(auto_probe, bool, 0);      /* auto probe base and irq */
225 MODULE_LICENSE("GPL");
226
227 #define POLLOOP 100             /* milliseconds */
228 #define READ_AHEAD 1            /* defines private buffer, waste! */
229 #define BACK_AHEAD 1            /* defines adapter-read ahead */
230 #define DATA_TIMEOUT (3*HZ)     /* measured in jiffies (10 ms) */
231 #define UART_TIMEOUT (5*HZ/100)
232 #define DSB_TIMEOUT (7*HZ)      /* time for the slowest command to finish */
233 #define UR_SIZE 4               /* uart receive buffer fifo size */
234
235 #define LINUX_BLOCK_SIZE 512    /* WHERE is this defined? */
236 #define RAW_SECTOR_SIZE 2352    /* ok, is also defined in cdrom.h */
237 #define ISO_SECTOR_SIZE 2048
238 #define BLOCKS_ISO (ISO_SECTOR_SIZE/LINUX_BLOCK_SIZE)   /* 4 */
239 #define CD_SYNC_HEAD 16         /* CD_SYNC + CD_HEAD */
240
241 #ifdef STATISTICS               /* keep track of errors in counters */
242 #define stats(i) { ++cd->stats[st_ ## i]; \
243                      cd->last_stat[st_ ## i] = cd->stat_counter++; \
244                  }
245 #else
246 #define stats(i) (void) 0;
247 #endif
248
249 #define Debug(a) {printk (KERN_DEBUG); printk a;}
250 #ifdef DEBUG
251 #define debug(a) Debug(a)
252 #else
253 #define debug(a) (void) 0;
254 #endif
255
256 typedef unsigned char uch;      /* 8-bits */
257 typedef unsigned short ush;     /* 16-bits */
258
259 struct toc_struct {             /* private copy of Table of Contents */
260         uch track, fsm[3], q0;
261 };
262
263 struct cm206_struct {
264         volatile ush intr_ds;   /* data status read on last interrupt */
265         volatile ush intr_ls;   /* uart line status read on last interrupt */
266         volatile uch ur[UR_SIZE];       /* uart receive buffer fifo */
267         volatile uch ur_w, ur_r;        /* write/read buffer index */
268         volatile uch dsb, cc;   /* drive status byte and condition (error) code */
269         int command;            /* command to be written to the uart */
270         int openfiles;
271         ush sector[READ_AHEAD * RAW_SECTOR_SIZE / 2];   /* buffered cd-sector */
272         int sector_first, sector_last;  /* range of these sectors */
273         wait_queue_head_t uart; /* wait queues for interrupt */
274         wait_queue_head_t data;
275         struct timer_list timer;        /* time-out */
276         char timed_out;
277         signed char max_sectors;        /* number of sectors that fit in adapter mem */
278         char wait_back;         /* we're waiting for a background-read */
279         char background;        /* is a read going on in the background? */
280         int adapter_first;      /* if so, that's the starting sector */
281         int adapter_last;
282         char fifo_overflowed;
283         uch disc_status[7];     /* result of get_disc_status command */
284 #ifdef STATISTICS
285         int stats[NR_STATS];
286         int last_stat[NR_STATS];        /* `time' at which stat was stat */
287         int stat_counter;
288 #endif
289         struct toc_struct toc[101];     /* The whole table of contents + lead-out */
290         uch q[10];              /* Last read q-channel info */
291         uch audio_status[5];    /* last read position on pause */
292         uch media_changed;      /* record if media changed */
293 };
294
295 #define DISC_STATUS cd->disc_status[0]
296 #define FIRST_TRACK cd->disc_status[1]
297 #define LAST_TRACK cd->disc_status[2]
298 #define PAUSED cd->audio_status[0]      /* misuse this memory byte! */
299 #define PLAY_TO cd->toc[0]      /* toc[0] records end-time in play */
300
301 static struct cm206_struct *cd; /* the main memory structure */
302 static struct request_queue *cm206_queue;
303 static DEFINE_SPINLOCK(cm206_lock);
304
305 /* First, we define some polling functions. These are actually
306    only being used in the initialization. */
307
308 static void send_command_polled(int command)
309 {
310         int loop = POLLOOP;
311         while (!(inw(r_line_status) & ls_transmitter_buffer_empty)
312                && loop > 0) {
313                 mdelay(1);      /* one millisec delay */
314                 --loop;
315         }
316         outw(command, r_uart_transmit);
317 }
318
319 static uch receive_echo_polled(void)
320 {
321         int loop = POLLOOP;
322         while (!(inw(r_line_status) & ls_receive_buffer_full) && loop > 0) {
323                 mdelay(1);
324                 --loop;
325         }
326         return ((uch) inw(r_uart_receive));
327 }
328
329 static uch send_receive_polled(int command)
330 {
331         send_command_polled(command);
332         return receive_echo_polled();
333 }
334
335 static inline void clear_ur(void)
336 {
337         if (cd->ur_r != cd->ur_w) {
338                 debug(("Deleting bytes from fifo:"));
339                 for (; cd->ur_r != cd->ur_w;
340                      cd->ur_r++, cd->ur_r %= UR_SIZE)
341                         debug((" 0x%x", cd->ur[cd->ur_r]));
342                 debug(("\n"));
343         }
344 }
345
346 static struct tasklet_struct cm206_tasklet;
347
348 /* The interrupt handler. When the cm260 generates an interrupt, very
349    much care has to be taken in reading out the registers in the right
350    order; in case of a receive_buffer_full interrupt, first the
351    uart_receive must be read, and then the line status again to
352    de-assert the interrupt line. It took me a couple of hours to find
353    this out:-( 
354
355    The function reset_cm206 appears to cause an interrupt, because
356    pulling up the INIT line clears both the uart-write-buffer /and/
357    the uart-write-buffer-empty mask. We call this a `lost interrupt,'
358    as there seems so reason for this to happen.
359 */
360
361 static irqreturn_t cm206_interrupt(int sig, void *dev_id)
362 {
363         volatile ush fool;
364         cd->intr_ds = inw(r_data_status);       /* resets data_ready, data_error,
365                                                    crc_error, sync_error, toc_ready 
366                                                    interrupts */
367         cd->intr_ls = inw(r_line_status);       /* resets overrun bit */
368         debug(("Intr, 0x%x 0x%x, %d\n", cd->intr_ds, cd->intr_ls,
369                cd->background));
370         if (cd->intr_ls & ls_attention)
371                 stats(attention);
372         /* receive buffer full? */
373         if (cd->intr_ls & ls_receive_buffer_full) {
374                 cd->ur[cd->ur_w] = inb(r_uart_receive); /* get order right! */
375                 cd->intr_ls = inw(r_line_status);       /* resets rbf interrupt */
376                 debug(("receiving #%d: 0x%x\n", cd->ur_w,
377                        cd->ur[cd->ur_w]));
378                 cd->ur_w++;
379                 cd->ur_w %= UR_SIZE;
380                 if (cd->ur_w == cd->ur_r)
381                         debug(("cd->ur overflow!\n"));
382                 if (waitqueue_active(&cd->uart) && cd->background < 2) {
383                         del_timer(&cd->timer);
384                         wake_up_interruptible(&cd->uart);
385                 }
386         }
387         /* data ready in fifo? */
388         else if (cd->intr_ds & ds_data_ready) {
389                 if (cd->background)
390                         ++cd->adapter_last;
391                 if (waitqueue_active(&cd->data)
392                     && (cd->wait_back || !cd->background)) {
393                         del_timer(&cd->timer);
394                         wake_up_interruptible(&cd->data);
395                 }
396                 stats(data_ready);
397         }
398         /* ready to issue a write command? */
399         else if (cd->command && cd->intr_ls & ls_transmitter_buffer_empty) {
400                 outw(dc_normal | (inw(r_data_status) & 0x7f),
401                      r_data_control);
402                 outw(cd->command, r_uart_transmit);
403                 cd->command = 0;
404                 if (!cd->background)
405                         wake_up_interruptible(&cd->uart);
406         }
407         /* now treat errors (at least, identify them for debugging) */
408         else if (cd->intr_ds & ds_fifo_overflow) {
409                 debug(("Fifo overflow at sectors 0x%x\n",
410                        cd->sector_first));
411                 fool = inw(r_fifo_output_buffer);       /* de-assert the interrupt */
412                 cd->fifo_overflowed = 1;        /* signal one word less should be read */
413                 stats(fifo_overflow);
414         } else if (cd->intr_ds & ds_data_error) {
415                 debug(("Data error at sector 0x%x\n", cd->sector_first));
416                 stats(data_error);
417         } else if (cd->intr_ds & ds_crc_error) {
418                 debug(("CRC error at sector 0x%x\n", cd->sector_first));
419                 stats(crc_error);
420         } else if (cd->intr_ds & ds_sync_error) {
421                 debug(("Sync at sector 0x%x\n", cd->sector_first));
422                 stats(sync_error);
423         } else if (cd->intr_ds & ds_toc_ready) {
424                 /* do something appropriate */
425         }
426         /* couldn't see why this interrupt, maybe due to init */
427         else {
428                 outw(dc_normal | READ_AHEAD, r_data_control);
429                 stats(lost_intr);
430         }
431         if (cd->background
432             && (cd->adapter_last - cd->adapter_first == cd->max_sectors
433                 || cd->fifo_overflowed))
434                 tasklet_schedule(&cm206_tasklet);       /* issue a stop read command */
435         stats(interrupt);
436         return IRQ_HANDLED;
437 }
438
439 /* we have put the address of the wait queue in who */
440 static void cm206_timeout(unsigned long who)
441 {
442         cd->timed_out = 1;
443         debug(("Timing out\n"));
444         wake_up_interruptible((wait_queue_head_t *) who);
445 }
446
447 /* This function returns 1 if a timeout occurred, 0 if an interrupt
448    happened */
449 static int sleep_or_timeout(wait_queue_head_t * wait, int timeout)
450 {
451         cd->timed_out = 0;
452         init_timer(&cd->timer);
453         cd->timer.data = (unsigned long) wait;
454         cd->timer.expires = jiffies + timeout;
455         add_timer(&cd->timer);
456         debug(("going to sleep\n"));
457         interruptible_sleep_on(wait);
458         del_timer(&cd->timer);
459         if (cd->timed_out) {
460                 cd->timed_out = 0;
461                 return 1;
462         } else
463                 return 0;
464 }
465
466 static void send_command(int command)
467 {
468         debug(("Sending 0x%x\n", command));
469         if (!(inw(r_line_status) & ls_transmitter_buffer_empty)) {
470                 cd->command = command;
471                 cli();          /* don't interrupt before sleep */
472                 outw(dc_mask_sync_error | dc_no_stop_on_error |
473                      (inw(r_data_status) & 0x7f), r_data_control);
474                 /* interrupt routine sends command */
475                 if (sleep_or_timeout(&cd->uart, UART_TIMEOUT)) {
476                         debug(("Time out on write-buffer\n"));
477                         stats(write_timeout);
478                         outw(command, r_uart_transmit);
479                 }
480                 debug(("Write commmand delayed\n"));
481         } else
482                 outw(command, r_uart_transmit);
483 }
484
485 static uch receive_byte(int timeout)
486 {
487         uch ret;
488         cli();
489         debug(("cli\n"));
490         ret = cd->ur[cd->ur_r];
491         if (cd->ur_r != cd->ur_w) {
492                 sti();
493                 debug(("returning #%d: 0x%x\n", cd->ur_r,
494                        cd->ur[cd->ur_r]));
495                 cd->ur_r++;
496                 cd->ur_r %= UR_SIZE;
497                 return ret;
498         } else if (sleep_or_timeout(&cd->uart, timeout)) {      /* does sti() */
499                 debug(("Time out on receive-buffer\n"));
500 #ifdef STATISTICS
501                 if (timeout == UART_TIMEOUT)
502                         stats(receive_timeout)  /* no `;'! */
503                             else
504                         stats(dsb_timeout);
505 #endif
506                 return 0xda;
507         }
508         ret = cd->ur[cd->ur_r];
509         debug(("slept; returning #%d: 0x%x\n", cd->ur_r,
510                cd->ur[cd->ur_r]));
511         cd->ur_r++;
512         cd->ur_r %= UR_SIZE;
513         return ret;
514 }
515
516 static inline uch receive_echo(void)
517 {
518         return receive_byte(UART_TIMEOUT);
519 }
520
521 static inline uch send_receive(int command)
522 {
523         send_command(command);
524         return receive_echo();
525 }
526
527 static inline uch wait_dsb(void)
528 {
529         return receive_byte(DSB_TIMEOUT);
530 }
531
532 static int type_0_command(int command, int expect_dsb)
533 {
534         int e;
535         clear_ur();
536         if (command != (e = send_receive(command))) {
537                 debug(("command 0x%x echoed as 0x%x\n", command, e));
538                 stats(echo);
539                 return -1;
540         }
541         if (expect_dsb) {
542                 cd->dsb = wait_dsb();   /* wait for command to finish */
543         }
544         return 0;
545 }
546
547 static int type_1_command(int command, int bytes, uch * status)
548 {                               /* returns info */
549         int i;
550         if (type_0_command(command, 0))
551                 return -1;
552         for (i = 0; i < bytes; i++)
553                 status[i] = send_receive(c_gimme);
554         return 0;
555 }
556
557 /* This function resets the adapter card. We'd better not do this too
558  * often, because it tends to generate `lost interrupts.' */
559 static void reset_cm260(void)
560 {
561         outw(dc_normal | dc_initialize | READ_AHEAD, r_data_control);
562         udelay(10);             /* 3.3 mu sec minimum */
563         outw(dc_normal | READ_AHEAD, r_data_control);
564 }
565
566 /* fsm: frame-sec-min from linear address; one of many */
567 static void fsm(int lba, uch * fsm)
568 {
569         fsm[0] = lba % 75;
570         lba /= 75;
571         lba += 2;
572         fsm[1] = lba % 60;
573         fsm[2] = lba / 60;
574 }
575
576 static inline int fsm2lba(uch * fsm)
577 {
578         return fsm[0] + 75 * (fsm[1] - 2 + 60 * fsm[2]);
579 }
580
581 static inline int f_s_m2lba(uch f, uch s, uch m)
582 {
583         return f + 75 * (s - 2 + 60 * m);
584 }
585
586 static int start_read(int start)
587 {
588         uch read_sector[4] = { c_read_data, };
589         int i, e;
590
591         fsm(start, &read_sector[1]);
592         clear_ur();
593         for (i = 0; i < 4; i++)
594                 if (read_sector[i] != (e = send_receive(read_sector[i]))) {
595                         debug(("read_sector: %x echoes %x\n",
596                                read_sector[i], e));
597                         stats(echo);
598                         if (e == 0xff) {        /* this seems to happen often */
599                                 e = receive_echo();
600                                 debug(("Second try %x\n", e));
601                                 if (e != read_sector[i])
602                                         return -1;
603                         }
604                 }
605         return 0;
606 }
607
608 static int stop_read(void)
609 {
610         int e;
611         type_0_command(c_stop, 0);
612         if ((e = receive_echo()) != 0xff) {
613                 debug(("c_stop didn't send 0xff, but 0x%x\n", e));
614                 stats(stop_0xff);
615                 return -1;
616         }
617         return 0;
618 }
619
620 /* This function starts to read sectors in adapter memory, the
621    interrupt routine should stop the read. In fact, the bottom_half
622    routine takes care of this. Set a flag `background' in the cd
623    struct to indicate the process. */
624
625 static int read_background(int start, int reading)
626 {
627         if (cd->background)
628                 return -1;      /* can't do twice */
629         outw(dc_normal | BACK_AHEAD, r_data_control);
630         if (!reading && start_read(start))
631                 return -2;
632         cd->adapter_first = cd->adapter_last = start;
633         cd->background = 1;     /* flag a read is going on */
634         return 0;
635 }
636
637 #ifdef USE_INSW
638 #define transport_data insw
639 #else
640 /* this routine implements insw(,,). There was a time i had the
641    impression that there would be any difference in error-behaviour. */
642 void transport_data(int port, ush * dest, int count)
643 {
644         int i;
645         ush *d;
646         for (i = 0, d = dest; i < count; i++, d++)
647                 *d = inw(port);
648 }
649 #endif
650
651
652 #define MAX_TRIES 100
653 static int read_sector(int start)
654 {
655         int tries = 0;
656         if (cd->background) {
657                 cd->background = 0;
658                 cd->adapter_last = -1;  /* invalidate adapter memory */
659                 stop_read();
660         }
661         cd->fifo_overflowed = 0;
662         reset_cm260();          /* empty fifo etc. */
663         if (start_read(start))
664                 return -1;
665         do {
666                 if (sleep_or_timeout(&cd->data, DATA_TIMEOUT)) {
667                         debug(("Read timed out sector 0x%x\n", start));
668                         stats(read_timeout);
669                         stop_read();
670                         return -3;
671                 }
672                 tries++;
673         } while (cd->intr_ds & ds_fifo_empty && tries < MAX_TRIES);
674         if (tries > 1)
675                 debug(("Took me some tries\n"))
676                     else
677         if (tries == MAX_TRIES)
678                 debug(("MAX_TRIES tries for read sector\n"));
679         transport_data(r_fifo_output_buffer, cd->sector,
680                        READ_AHEAD * RAW_SECTOR_SIZE / 2);
681         if (read_background(start + READ_AHEAD, 1))
682                 stats(read_background);
683         cd->sector_first = start;
684         cd->sector_last = start + READ_AHEAD;
685         stats(read_restarted);
686         return 0;
687 }
688
689 /* The function of bottom-half is to send a stop command to the drive
690    This isn't easy because the routine is not `owned' by any process;
691    we can't go to sleep! The variable cd->background gives the status:
692    0 no read pending
693    1 a read is pending
694    2 c_stop waits for write_buffer_empty
695    3 c_stop waits for receive_buffer_full: echo
696    4 c_stop waits for receive_buffer_full: 0xff
697 */
698
699 static void cm206_tasklet_func(unsigned long ignore)
700 {
701         debug(("bh: %d\n", cd->background));
702         switch (cd->background) {
703         case 1:
704                 stats(bh);
705                 if (!(cd->intr_ls & ls_transmitter_buffer_empty)) {
706                         cd->command = c_stop;
707                         outw(dc_mask_sync_error | dc_no_stop_on_error |
708                              (inw(r_data_status) & 0x7f), r_data_control);
709                         cd->background = 2;
710                         break;  /* we'd better not time-out here! */
711                 } else
712                         outw(c_stop, r_uart_transmit);
713                 /* fall into case 2: */
714         case 2:
715                 /* the write has been satisfied by interrupt routine */
716                 cd->background = 3;
717                 break;
718         case 3:
719                 if (cd->ur_r != cd->ur_w) {
720                         if (cd->ur[cd->ur_r] != c_stop) {
721                                 debug(("cm206_bh: c_stop echoed 0x%x\n",
722                                        cd->ur[cd->ur_r]));
723                                 stats(echo);
724                         }
725                         cd->ur_r++;
726                         cd->ur_r %= UR_SIZE;
727                 }
728                 cd->background++;
729                 break;
730         case 4:
731                 if (cd->ur_r != cd->ur_w) {
732                         if (cd->ur[cd->ur_r] != 0xff) {
733                                 debug(("cm206_bh: c_stop reacted with 0x%x\n", cd->ur[cd->ur_r]));
734                                 stats(stop_0xff);
735                         }
736                         cd->ur_r++;
737                         cd->ur_r %= UR_SIZE;
738                 }
739                 cd->background = 0;
740         }
741 }
742
743 static DECLARE_TASKLET(cm206_tasklet, cm206_tasklet_func, 0);
744
745 /* This command clears the dsb_possible_media_change flag, so we must 
746  * retain it.
747  */
748 static void get_drive_status(void)
749 {
750         uch status[2];
751         type_1_command(c_drive_status, 2, status);      /* this might be done faster */
752         cd->dsb = status[0];
753         cd->cc = status[1];
754         cd->media_changed |=
755             !!(cd->dsb & (dsb_possible_media_change |
756                           dsb_drive_not_ready | dsb_tray_not_closed));
757 }
758
759 static void get_disc_status(void)
760 {
761         if (type_1_command(c_disc_status, 7, cd->disc_status)) {
762                 debug(("get_disc_status: error\n"));
763         }
764 }
765
766 /* The new open. The real opening strategy is defined in cdrom.c. */
767
768 static int cm206_open(struct cdrom_device_info *cdi, int purpose)
769 {
770         if (!cd->openfiles) {   /* reset only first time */
771                 cd->background = 0;
772                 reset_cm260();
773                 cd->adapter_last = -1;  /* invalidate adapter memory */
774                 cd->sector_last = -1;
775         }
776         ++cd->openfiles;
777         stats(open);
778         return 0;
779 }
780
781 static void cm206_release(struct cdrom_device_info *cdi)
782 {
783         if (cd->openfiles == 1) {
784                 if (cd->background) {
785                         cd->background = 0;
786                         stop_read();
787                 }
788                 cd->sector_last = -1;   /* Make our internal buffer invalid */
789                 FIRST_TRACK = 0;        /* No valid disc status */
790         }
791         --cd->openfiles;
792 }
793
794 /* Empty buffer empties $sectors$ sectors of the adapter card buffer,
795  * and then reads a sector in kernel memory.  */
796 static void empty_buffer(int sectors)
797 {
798         while (sectors >= 0) {
799                 transport_data(r_fifo_output_buffer,
800                                cd->sector + cd->fifo_overflowed,
801                                RAW_SECTOR_SIZE / 2 - cd->fifo_overflowed);
802                 --sectors;
803                 ++cd->adapter_first;    /* update the current adapter sector */
804                 cd->fifo_overflowed = 0;        /* reset overflow bit */
805                 stats(sector_transferred);
806         }
807         cd->sector_first = cd->adapter_first - 1;
808         cd->sector_last = cd->adapter_first;    /* update the buffer sector */
809 }
810
811 /* try_adapter. This function determines if the requested sector is
812    in adapter memory, or will appear there soon. Returns 0 upon
813    success */
814 static int try_adapter(int sector)
815 {
816         if (cd->adapter_first <= sector && sector < cd->adapter_last) {
817                 /* sector is in adapter memory */
818                 empty_buffer(sector - cd->adapter_first);
819                 return 0;
820         } else if (cd->background == 1 && cd->adapter_first <= sector
821                    && sector < cd->adapter_first + cd->max_sectors) {
822                 /* a read is going on, we can wait for it */
823                 cd->wait_back = 1;
824                 while (sector >= cd->adapter_last) {
825                         if (sleep_or_timeout(&cd->data, DATA_TIMEOUT)) {
826                                 debug(("Timed out during background wait: %d %d %d %d\n", sector, cd->adapter_last, cd->adapter_first, cd->background));
827                                 stats(back_read_timeout);
828                                 cd->wait_back = 0;
829                                 return -1;
830                         }
831                 }
832                 cd->wait_back = 0;
833                 empty_buffer(sector - cd->adapter_first);
834                 return 0;
835         } else
836                 return -2;
837 }
838
839 /* This is not a very smart implementation. We could optimize for 
840    consecutive block numbers. I'm not convinced this would really
841    bring down the processor load. */
842 static void do_cm206_request(request_queue_t * q)
843 {
844         long int i, cd_sec_no;
845         int quarter, error;
846         uch *source, *dest;
847         struct request *req;
848
849         while (1) {     /* repeat until all requests have been satisfied */
850                 req = elv_next_request(q);
851                 if (!req)
852                         return;
853
854                 if (req->cmd != READ) {
855                         debug(("Non-read command %d on cdrom\n", req->cmd));
856                         end_request(req, 0);
857                         continue;
858                 }
859                 spin_unlock_irq(q->queue_lock);
860                 error = 0;
861                 for (i = 0; i < req->nr_sectors; i++) {
862                         int e1, e2;
863                         cd_sec_no = (req->sector + i) / BLOCKS_ISO;     /* 4 times 512 bytes */
864                         quarter = (req->sector + i) % BLOCKS_ISO;
865                         dest = req->buffer + i * LINUX_BLOCK_SIZE;
866                         /* is already in buffer memory? */
867                         if (cd->sector_first <= cd_sec_no
868                             && cd_sec_no < cd->sector_last) {
869                                 source =
870                                     ((uch *) cd->sector) + 16 +
871                                     quarter * LINUX_BLOCK_SIZE +
872                                     (cd_sec_no -
873                                      cd->sector_first) * RAW_SECTOR_SIZE;
874                                 memcpy(dest, source, LINUX_BLOCK_SIZE);
875                         } else if (!(e1 = try_adapter(cd_sec_no)) ||
876                                    !(e2 = read_sector(cd_sec_no))) {
877                                 source =
878                                     ((uch *) cd->sector) + 16 +
879                                     quarter * LINUX_BLOCK_SIZE;
880                                 memcpy(dest, source, LINUX_BLOCK_SIZE);
881                         } else {
882                                 error = 1;
883                                 debug(("cm206_request: %d %d\n", e1, e2));
884                         }
885                 }
886                 spin_lock_irq(q->queue_lock);
887                 end_request(req, !error);
888         }
889 }
890
891 /* Audio support. I've tried very hard, but the cm206 drive doesn't 
892    seem to have a get_toc (table-of-contents) function, while i'm
893    pretty sure it must read the toc upon disc insertion. Therefore
894    this function has been implemented through a binary search 
895    strategy. All track starts that happen to be found are stored in
896    cd->toc[], for future use. 
897
898    I've spent a whole day on a bug that only shows under Workman---
899    I don't get it. Tried everything, nothing works. If workman asks
900    for track# 0xaa, it'll get the wrong time back. Any other program
901    receives the correct value. I'm stymied.
902 */
903
904 /* seek seeks to address lba. It does wait to arrive there. */
905 static void seek(int lba)
906 {
907         int i;
908         uch seek_command[4] = { c_seek, };
909
910         fsm(lba, &seek_command[1]);
911         for (i = 0; i < 4; i++)
912                 type_0_command(seek_command[i], 0);
913         cd->dsb = wait_dsb();
914 }
915
916 static uch bcdbin(unsigned char bcd)
917 {                               /* stolen from mcd.c! */
918         return (bcd >> 4) * 10 + (bcd & 0xf);
919 }
920
921 static inline uch normalize_track(uch track)
922 {
923         if (track < 1)
924                 return 1;
925         if (track > LAST_TRACK)
926                 return LAST_TRACK + 1;
927         return track;
928 }
929
930 /* This function does a binary search for track start. It records all
931  * tracks seen in the process. Input $track$ must be between 1 and
932  * #-of-tracks+1.  Note that the start of the disc must be in toc[1].fsm. 
933  */
934 static int get_toc_lba(uch track)
935 {
936         int max = 74 * 60 * 75 - 150, min = fsm2lba(cd->toc[1].fsm);
937         int i, lba, l, old_lba = 0;
938         uch *q = cd->q;
939         uch ct;                 /* current track */
940         int binary = 0;
941         const int skip = 3 * 60 * 75;   /* 3 minutes */
942
943         for (i = track; i > 0; i--)
944                 if (cd->toc[i].track) {
945                         min = fsm2lba(cd->toc[i].fsm);
946                         break;
947                 }
948         lba = min + skip;
949         do {
950                 seek(lba);
951                 type_1_command(c_read_current_q, 10, q);
952                 ct = normalize_track(q[1]);
953                 if (!cd->toc[ct].track) {
954                         l = q[9] - bcdbin(q[5]) + 75 * (q[8] -
955                                                         bcdbin(q[4]) - 2 +
956                                                         60 * (q[7] -
957                                                               bcdbin(q
958                                                                      [3])));
959                         cd->toc[ct].track = q[1];       /* lead out still 0xaa */
960                         fsm(l, cd->toc[ct].fsm);
961                         cd->toc[ct].q0 = q[0];  /* contains adr and ctrl info */
962                         if (ct == track)
963                                 return l;
964                 }
965                 old_lba = lba;
966                 if (binary) {
967                         if (ct < track)
968                                 min = lba;
969                         else
970                                 max = lba;
971                         lba = (min + max) / 2;
972                 } else {
973                         if (ct < track)
974                                 lba += skip;
975                         else {
976                                 binary = 1;
977                                 max = lba;
978                                 min = lba - skip;
979                                 lba = (min + max) / 2;
980                         }
981                 }
982         } while (lba != old_lba);
983         return lba;
984 }
985
986 static void update_toc_entry(uch track)
987 {
988         track = normalize_track(track);
989         if (!cd->toc[track].track)
990                 get_toc_lba(track);
991 }
992
993 /* return 0 upon success */
994 static int read_toc_header(struct cdrom_tochdr *hp)
995 {
996         if (!FIRST_TRACK)
997                 get_disc_status();
998         if (hp) {
999                 int i;
1000                 hp->cdth_trk0 = FIRST_TRACK;
1001                 hp->cdth_trk1 = LAST_TRACK;
1002                 /* fill in first track position */
1003                 for (i = 0; i < 3; i++)
1004                         cd->toc[1].fsm[i] = cd->disc_status[3 + i];
1005                 update_toc_entry(LAST_TRACK + 1);       /* find most entries */
1006                 return 0;
1007         }
1008         return -1;
1009 }
1010
1011 static void play_from_to_msf(struct cdrom_msf *msfp)
1012 {
1013         uch play_command[] = { c_play,
1014                 msfp->cdmsf_frame0, msfp->cdmsf_sec0, msfp->cdmsf_min0,
1015                 msfp->cdmsf_frame1, msfp->cdmsf_sec1, msfp->cdmsf_min1, 2,
1016                     2
1017         };
1018         int i;
1019         for (i = 0; i < 9; i++)
1020                 type_0_command(play_command[i], 0);
1021         for (i = 0; i < 3; i++)
1022                 PLAY_TO.fsm[i] = play_command[i + 4];
1023         PLAY_TO.track = 0;      /* say no track end */
1024         cd->dsb = wait_dsb();
1025 }
1026
1027 static void play_from_to_track(int from, int to)
1028 {
1029         uch play_command[8] = { c_play, };
1030         int i;
1031
1032         if (from == 0) {        /* continue paused play */
1033                 for (i = 0; i < 3; i++) {
1034                         play_command[i + 1] = cd->audio_status[i + 2];
1035                         play_command[i + 4] = PLAY_TO.fsm[i];
1036                 }
1037         } else {
1038                 update_toc_entry(from);
1039                 update_toc_entry(to + 1);
1040                 for (i = 0; i < 3; i++) {
1041                         play_command[i + 1] = cd->toc[from].fsm[i];
1042                         PLAY_TO.fsm[i] = play_command[i + 4] =
1043                             cd->toc[to + 1].fsm[i];
1044                 }
1045                 PLAY_TO.track = to;
1046         }
1047         for (i = 0; i < 7; i++)
1048                 type_0_command(play_command[i], 0);
1049         for (i = 0; i < 2; i++)
1050                 type_0_command(0x2, 0); /* volume */
1051         cd->dsb = wait_dsb();
1052 }
1053
1054 static int get_current_q(struct cdrom_subchnl *qp)
1055 {
1056         int i;
1057         uch *q = cd->q;
1058         if (type_1_command(c_read_current_q, 10, q))
1059                 return 0;
1060 /*  q[0] = bcdbin(q[0]); Don't think so! */
1061         for (i = 2; i < 6; i++)
1062                 q[i] = bcdbin(q[i]);
1063         qp->cdsc_adr = q[0] & 0xf;
1064         qp->cdsc_ctrl = q[0] >> 4;      /* from mcd.c */
1065         qp->cdsc_trk = q[1];
1066         qp->cdsc_ind = q[2];
1067         if (qp->cdsc_format == CDROM_MSF) {
1068                 qp->cdsc_reladdr.msf.minute = q[3];
1069                 qp->cdsc_reladdr.msf.second = q[4];
1070                 qp->cdsc_reladdr.msf.frame = q[5];
1071                 qp->cdsc_absaddr.msf.minute = q[7];
1072                 qp->cdsc_absaddr.msf.second = q[8];
1073                 qp->cdsc_absaddr.msf.frame = q[9];
1074         } else {
1075                 qp->cdsc_reladdr.lba = f_s_m2lba(q[5], q[4], q[3]);
1076                 qp->cdsc_absaddr.lba = f_s_m2lba(q[9], q[8], q[7]);
1077         }
1078         get_drive_status();
1079         if (cd->dsb & dsb_play_in_progress)
1080                 qp->cdsc_audiostatus = CDROM_AUDIO_PLAY;
1081         else if (PAUSED)
1082                 qp->cdsc_audiostatus = CDROM_AUDIO_PAUSED;
1083         else
1084                 qp->cdsc_audiostatus = CDROM_AUDIO_NO_STATUS;
1085         return 0;
1086 }
1087
1088 static void invalidate_toc(void)
1089 {
1090         memset(cd->toc, 0, sizeof(cd->toc));
1091         memset(cd->disc_status, 0, sizeof(cd->disc_status));
1092 }
1093
1094 /* cdrom.c guarantees that cdte_format == CDROM_MSF */
1095 static void get_toc_entry(struct cdrom_tocentry *ep)
1096 {
1097         uch track = normalize_track(ep->cdte_track);
1098         update_toc_entry(track);
1099         ep->cdte_addr.msf.frame = cd->toc[track].fsm[0];
1100         ep->cdte_addr.msf.second = cd->toc[track].fsm[1];
1101         ep->cdte_addr.msf.minute = cd->toc[track].fsm[2];
1102         ep->cdte_adr = cd->toc[track].q0 & 0xf;
1103         ep->cdte_ctrl = cd->toc[track].q0 >> 4;
1104         ep->cdte_datamode = 0;
1105 }
1106
1107 /* Audio ioctl.  Ioctl commands connected to audio are in such an
1108  * idiosyncratic i/o format, that we leave these untouched. Return 0
1109  * upon success. Memory checking has been done by cdrom_ioctl(), the
1110  * calling function, as well as LBA/MSF sanitization.
1111 */
1112 static int cm206_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,
1113                              void *arg)
1114 {
1115         switch (cmd) {
1116         case CDROMREADTOCHDR:
1117                 return read_toc_header((struct cdrom_tochdr *) arg);
1118         case CDROMREADTOCENTRY:
1119                 get_toc_entry((struct cdrom_tocentry *) arg);
1120                 return 0;
1121         case CDROMPLAYMSF:
1122                 play_from_to_msf((struct cdrom_msf *) arg);
1123                 return 0;
1124         case CDROMPLAYTRKIND:   /* admittedly, not particularly beautiful */
1125                 play_from_to_track(((struct cdrom_ti *) arg)->cdti_trk0,
1126                                    ((struct cdrom_ti *) arg)->cdti_trk1);
1127                 return 0;
1128         case CDROMSTOP:
1129                 PAUSED = 0;
1130                 if (cd->dsb & dsb_play_in_progress)
1131                         return type_0_command(c_stop, 1);
1132                 else
1133                         return 0;
1134         case CDROMPAUSE:
1135                 get_drive_status();
1136                 if (cd->dsb & dsb_play_in_progress) {
1137                         type_0_command(c_stop, 1);
1138                         type_1_command(c_audio_status, 5,
1139                                        cd->audio_status);
1140                         PAUSED = 1;     /* say we're paused */
1141                 }
1142                 return 0;
1143         case CDROMRESUME:
1144                 if (PAUSED)
1145                         play_from_to_track(0, 0);
1146                 PAUSED = 0;
1147                 return 0;
1148         case CDROMSTART:
1149         case CDROMVOLCTRL:
1150                 return 0;
1151         case CDROMSUBCHNL:
1152                 return get_current_q((struct cdrom_subchnl *) arg);
1153         default:
1154                 return -EINVAL;
1155         }
1156 }
1157
1158 static int cm206_media_changed(struct cdrom_device_info *cdi, int disc_nr)
1159 {
1160         if (cd != NULL) {
1161                 int r;
1162                 get_drive_status();     /* ensure cd->media_changed OK */
1163                 r = cd->media_changed;
1164                 cd->media_changed = 0;  /* clear bit */
1165                 return r;
1166         } else
1167                 return -EIO;
1168 }
1169
1170 /* The new generic cdrom support. Routines should be concise, most of
1171    the logic should be in cdrom.c */
1172
1173
1174 /* controls tray movement */
1175 static int cm206_tray_move(struct cdrom_device_info *cdi, int position)
1176 {
1177         if (position) {         /* 1: eject */
1178                 type_0_command(c_open_tray, 1);
1179                 invalidate_toc();
1180         } else
1181                 type_0_command(c_close_tray, 1);        /* 0: close */
1182         return 0;
1183 }
1184
1185 /* gives current state of the drive */
1186 static int cm206_drive_status(struct cdrom_device_info *cdi, int slot_nr)
1187 {
1188         get_drive_status();
1189         if (cd->dsb & dsb_tray_not_closed)
1190                 return CDS_TRAY_OPEN;
1191         if (!(cd->dsb & dsb_disc_present))
1192                 return CDS_NO_DISC;
1193         if (cd->dsb & dsb_drive_not_ready)
1194                 return CDS_DRIVE_NOT_READY;
1195         return CDS_DISC_OK;
1196 }
1197
1198 /* locks or unlocks door lock==1: lock; return 0 upon success */
1199 static int cm206_lock_door(struct cdrom_device_info *cdi, int lock)
1200 {
1201         uch command = (lock) ? c_lock_tray : c_unlock_tray;
1202         type_0_command(command, 1);     /* wait and get dsb */
1203         /* the logic calculates the success, 0 means successful */
1204         return lock ^ ((cd->dsb & dsb_tray_locked) != 0);
1205 }
1206
1207 /* Although a session start should be in LBA format, we return it in 
1208    MSF format because it is slightly easier, and the new generic ioctl
1209    will take care of the necessary conversion. */
1210 static int cm206_get_last_session(struct cdrom_device_info *cdi,
1211                                   struct cdrom_multisession *mssp)
1212 {
1213         if (!FIRST_TRACK)
1214                 get_disc_status();
1215         if (mssp != NULL) {
1216                 if (DISC_STATUS & cds_multi_session) {  /* multi-session */
1217                         mssp->addr.msf.frame = cd->disc_status[3];
1218                         mssp->addr.msf.second = cd->disc_status[4];
1219                         mssp->addr.msf.minute = cd->disc_status[5];
1220                         mssp->addr_format = CDROM_MSF;
1221                         mssp->xa_flag = 1;
1222                 } else {
1223                         mssp->xa_flag = 0;
1224                 }
1225                 return 1;
1226         }
1227         return 0;
1228 }
1229
1230 static int cm206_get_upc(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)
1231 {
1232         uch upc[10];
1233         char *ret = mcn->medium_catalog_number;
1234         int i;
1235
1236         if (type_1_command(c_read_upc, 10, upc))
1237                 return -EIO;
1238         for (i = 0; i < 13; i++) {
1239                 int w = i / 2 + 1, r = i % 2;
1240                 if (r)
1241                         ret[i] = 0x30 | (upc[w] & 0x0f);
1242                 else
1243                         ret[i] = 0x30 | ((upc[w] >> 4) & 0x0f);
1244         }
1245         ret[13] = '\0';
1246         return 0;
1247 }
1248
1249 static int cm206_reset(struct cdrom_device_info *cdi)
1250 {
1251         stop_read();
1252         reset_cm260();
1253         outw(dc_normal | dc_break | READ_AHEAD, r_data_control);
1254         mdelay(1);              /* 750 musec minimum */
1255         outw(dc_normal | READ_AHEAD, r_data_control);
1256         cd->sector_last = -1;   /* flag no data buffered */
1257         cd->adapter_last = -1;
1258         invalidate_toc();
1259         return 0;
1260 }
1261
1262 static int cm206_select_speed(struct cdrom_device_info *cdi, int speed)
1263 {
1264         int r;
1265         switch (speed) {
1266         case 0:
1267                 r = type_0_command(c_auto_mode, 1);
1268                 break;
1269         case 1:
1270                 r = type_0_command(c_force_1x, 1);
1271                 break;
1272         case 2:
1273                 r = type_0_command(c_force_2x, 1);
1274                 break;
1275         default:
1276                 return -1;
1277         }
1278         if (r < 0)
1279                 return r;
1280         else
1281                 return 1;
1282 }
1283
1284 static struct cdrom_device_ops cm206_dops = {
1285         .open                   = cm206_open,
1286         .release                = cm206_release,
1287         .drive_status           = cm206_drive_status,
1288         .media_changed          = cm206_media_changed,
1289         .tray_move              = cm206_tray_move,
1290         .lock_door              = cm206_lock_door,
1291         .select_speed           = cm206_select_speed,
1292         .get_last_session       = cm206_get_last_session,
1293         .get_mcn                = cm206_get_upc,
1294         .reset                  = cm206_reset,
1295         .audio_ioctl            = cm206_audio_ioctl,
1296         .capability             = CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK |
1297                                   CDC_MULTI_SESSION | CDC_MEDIA_CHANGED |
1298                                   CDC_MCN | CDC_PLAY_AUDIO | CDC_SELECT_SPEED |
1299                                   CDC_DRIVE_STATUS,
1300         .n_minors               = 1,
1301 };
1302
1303
1304 static struct cdrom_device_info cm206_info = {
1305         .ops            = &cm206_dops,
1306         .speed          = 2,
1307         .capacity       = 1,
1308         .name           = "cm206",
1309 };
1310
1311 static int cm206_block_open(struct inode *inode, struct file *file)
1312 {
1313         return cdrom_open(&cm206_info, inode, file);
1314 }
1315
1316 static int cm206_block_release(struct inode *inode, struct file *file)
1317 {
1318         return cdrom_release(&cm206_info, file);
1319 }
1320
1321 static int cm206_block_ioctl(struct inode *inode, struct file *file,
1322                                 unsigned cmd, unsigned long arg)
1323 {
1324         switch (cmd) {
1325 #ifdef STATISTICS
1326         case CM206CTL_GET_STAT:
1327                 if (arg >= NR_STATS)
1328                         return -EINVAL;
1329                 return cd->stats[arg];
1330         case CM206CTL_GET_LAST_STAT:
1331                 if (arg >= NR_STATS)
1332                         return -EINVAL;
1333                 return cd->last_stat[arg];
1334 #endif
1335         default:
1336                 break;
1337         }
1338
1339         return cdrom_ioctl(file, &cm206_info, inode, cmd, arg);
1340 }
1341
1342 static int cm206_block_media_changed(struct gendisk *disk)
1343 {
1344         return cdrom_media_changed(&cm206_info);
1345 }
1346
1347 static struct block_device_operations cm206_bdops =
1348 {
1349         .owner          = THIS_MODULE,
1350         .open           = cm206_block_open,
1351         .release        = cm206_block_release,
1352         .ioctl          = cm206_block_ioctl,
1353         .media_changed  = cm206_block_media_changed,
1354 };
1355
1356 static struct gendisk *cm206_gendisk;
1357
1358 /* This function probes for the adapter card. It returns the base
1359    address if it has found the adapter card. One can specify a base 
1360    port to probe specifically, or 0 which means span all possible
1361    bases. 
1362
1363    Linus says it is too dangerous to use writes for probing, so we
1364    stick with pure reads for a while. Hope that 8 possible ranges,
1365    request_region, 15 bits of one port and 6 of another make things
1366    likely enough to accept the region on the first hit...
1367  */
1368 static int __init probe_base_port(int base)
1369 {
1370         int b = 0x300, e = 0x370;       /* this is the range of start addresses */
1371         volatile int fool, i;
1372
1373         if (base)
1374                 b = e = base;
1375         for (base = b; base <= e; base += 0x10) {
1376                 if (!request_region(base, 0x10,"cm206"))
1377                         continue;
1378                 for (i = 0; i < 3; i++)
1379                         fool = inw(base + 2);   /* empty possibly uart_receive_buffer */
1380                 if ((inw(base + 6) & 0xffef) != 0x0001 ||       /* line_status */
1381                     (inw(base) & 0xad00) != 0)  { /* data status */
1382                         release_region(base,0x10);
1383                         continue;
1384                 }
1385                 return (base);
1386         }
1387         return 0;
1388 }
1389
1390 #if !defined(MODULE) || defined(AUTO_PROBE_MODULE)
1391 /* Probe for irq# nr. If nr==0, probe for all possible irq's. */
1392 static int __init probe_irq(int nr)
1393 {
1394         int irqs, irq;
1395         outw(dc_normal | READ_AHEAD, r_data_control);   /* disable irq-generation */
1396         sti();
1397         irqs = probe_irq_on();
1398         reset_cm260();          /* causes interrupt */
1399         udelay(100);            /* wait for it */
1400         irq = probe_irq_off(irqs);
1401         outw(dc_normal | READ_AHEAD, r_data_control);   /* services interrupt */
1402         if (nr && irq != nr && irq > 0)
1403                 return 0;       /* wrong interrupt happened */
1404         else
1405                 return irq;
1406 }
1407 #endif
1408
1409 int __init cm206_init(void)
1410 {
1411         uch e = 0;
1412         long int size = sizeof(struct cm206_struct);
1413         struct gendisk *disk;
1414
1415         printk(KERN_INFO "cm206 cdrom driver " REVISION);
1416         cm206_base = probe_base_port(auto_probe ? 0 : cm206_base);
1417         if (!cm206_base) {
1418                 printk(" can't find adapter!\n");
1419                 return -EIO;
1420         }
1421         printk(" adapter at 0x%x", cm206_base);
1422         cd = kmalloc(size, GFP_KERNEL);
1423         if (!cd)
1424                goto out_base;
1425         /* Now we have found the adaptor card, try to reset it. As we have
1426          * found out earlier, this process generates an interrupt as well,
1427          * so we might just exploit that fact for irq probing! */
1428 #if !defined(MODULE) || defined(AUTO_PROBE_MODULE)
1429         cm206_irq = probe_irq(auto_probe ? 0 : cm206_irq);
1430         if (cm206_irq <= 0) {
1431                 printk("can't find IRQ!\n");
1432                 goto out_probe;
1433         } else
1434                 printk(" IRQ %d found\n", cm206_irq);
1435 #else
1436         cli();
1437         reset_cm260();
1438         /* Now, the problem here is that reset_cm260 can generate an
1439            interrupt. It seems that this can cause a kernel oops some time
1440            later. So we wait a while and `service' this interrupt. */
1441         mdelay(1);
1442         outw(dc_normal | READ_AHEAD, r_data_control);
1443         sti();
1444         printk(" using IRQ %d\n", cm206_irq);
1445 #endif
1446         if (send_receive_polled(c_drive_configuration) !=
1447             c_drive_configuration) {
1448                 printk(KERN_INFO " drive not there\n");
1449                 goto out_probe;
1450         }
1451         e = send_receive_polled(c_gimme);
1452         printk(KERN_INFO "Firmware revision %d", e & dcf_revision_code);
1453         if (e & dcf_transfer_rate)
1454                 printk(" double");
1455         else
1456                 printk(" single");
1457         printk(" speed drive");
1458         if (e & dcf_motorized_tray)
1459                 printk(", motorized tray");
1460         if (request_irq(cm206_irq, cm206_interrupt, 0, "cm206", NULL)) {
1461                 printk("\nUnable to reserve IRQ---aborted\n");
1462                 goto out_probe;
1463         }
1464         printk(".\n");
1465
1466         if (register_blkdev(MAJOR_NR, "cm206"))
1467                 goto out_blkdev;
1468
1469         disk = alloc_disk(1);
1470         if (!disk)
1471                 goto out_disk;
1472         disk->major = MAJOR_NR;
1473         disk->first_minor = 0;
1474         sprintf(disk->disk_name, "cm206cd");
1475         disk->fops = &cm206_bdops;
1476         disk->flags = GENHD_FL_CD;
1477         cm206_gendisk = disk;
1478         if (register_cdrom(&cm206_info) != 0) {
1479                 printk(KERN_INFO "Cannot register for cdrom %d!\n", MAJOR_NR);
1480                 goto out_cdrom;
1481         }
1482         cm206_queue = blk_init_queue(do_cm206_request, &cm206_lock);
1483         if (!cm206_queue)
1484                 goto out_queue;
1485                 
1486         blk_queue_hardsect_size(cm206_queue, 2048);
1487         disk->queue = cm206_queue;
1488         add_disk(disk);
1489
1490         memset(cd, 0, sizeof(*cd));     /* give'm some reasonable value */
1491         cd->sector_last = -1;   /* flag no data buffered */
1492         cd->adapter_last = -1;
1493         init_timer(&cd->timer);
1494         cd->timer.function = cm206_timeout;
1495         cd->max_sectors = (inw(r_data_status) & ds_ram_size) ? 24 : 97;
1496         printk(KERN_INFO "%d kB adapter memory available, "
1497                " %ld bytes kernel memory used.\n", cd->max_sectors * 2,
1498                size);
1499         return 0;
1500
1501 out_queue:
1502         unregister_cdrom(&cm206_info);
1503 out_cdrom:
1504         put_disk(disk);
1505 out_disk:
1506         unregister_blkdev(MAJOR_NR, "cm206");
1507 out_blkdev:
1508         free_irq(cm206_irq, NULL);
1509 out_probe:
1510         kfree(cd);
1511 out_base:
1512         release_region(cm206_base, 16);
1513         return -EIO;
1514 }
1515
1516 #ifdef MODULE
1517
1518
1519 static void __init parse_options(void)
1520 {
1521         int i;
1522         for (i = 0; i < 2; i++) {
1523                 if (0x300 <= cm206[i] && i <= 0x370
1524                     && cm206[i] % 0x10 == 0) {
1525                         cm206_base = cm206[i];
1526                         auto_probe = 0;
1527                 } else if (3 <= cm206[i] && cm206[i] <= 15) {
1528                         cm206_irq = cm206[i];
1529                         auto_probe = 0;
1530                 }
1531         }
1532 }
1533
1534 static int __init __cm206_init(void)
1535 {
1536         parse_options();
1537 #if !defined(AUTO_PROBE_MODULE)
1538         auto_probe = 0;
1539 #endif
1540         return cm206_init();
1541 }
1542
1543 static void __exit cm206_exit(void)
1544 {
1545         del_gendisk(cm206_gendisk);
1546         put_disk(cm206_gendisk);
1547         if (unregister_cdrom(&cm206_info)) {
1548                 printk("Can't unregister cdrom cm206\n");
1549                 return;
1550         }
1551         if (unregister_blkdev(MAJOR_NR, "cm206")) {
1552                 printk("Can't unregister major cm206\n");
1553                 return;
1554         }
1555         blk_cleanup_queue(cm206_queue);
1556         free_irq(cm206_irq, NULL);
1557         kfree(cd);
1558         release_region(cm206_base, 16);
1559         printk(KERN_INFO "cm206 removed\n");
1560 }
1561
1562 module_init(__cm206_init);
1563 module_exit(cm206_exit);
1564
1565 #else                           /* !MODULE */
1566
1567 /* This setup function accepts either `auto' or numbers in the range
1568  * 3--11 (for irq) or 0x300--0x370 (for base port) or both. */
1569
1570 static int __init cm206_setup(char *s)
1571 {
1572         int i, p[4];
1573
1574         (void) get_options(s, ARRAY_SIZE(p), p);
1575
1576         if (!strcmp(s, "auto"))
1577                 auto_probe = 1;
1578         for (i = 1; i <= p[0]; i++) {
1579                 if (0x300 <= p[i] && i <= 0x370 && p[i] % 0x10 == 0) {
1580                         cm206_base = p[i];
1581                         auto_probe = 0;
1582                 } else if (3 <= p[i] && p[i] <= 15) {
1583                         cm206_irq = p[i];
1584                         auto_probe = 0;
1585                 }
1586         }
1587         return 1;
1588 }
1589
1590 __setup("cm206=", cm206_setup);
1591
1592 #endif                          /* !MODULE */
1593 MODULE_ALIAS_BLOCKDEV_MAJOR(CM206_CDROM_MAJOR);
1594