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 $
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.
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.
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.
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 trough 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.
58 An adaptation of 0.33 is included in linux-1.3.7 by Eberhard Moenkeberg
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.
64 18 dec 1995: 0.35 Add some code for error checking... no luck...
66 We jump to reach our goal: version 1.0 in the next stable linux kernel.
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
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.
78 Upgrade to Linux kernel 1.3.78.
80 11 apr 1996 0.98 Upgrade to Linux kernel 1.3.85
81 More code moved to cdrom.c
83 0.99 Some more small changes to decrease number
84 of oopses at module load;
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
93 28 jul 1996 0.101 Rewriting of the code that receives the command echo,
94 using a fifo to store echoed bytes.
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.
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.
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.
115 0.99.1.3 More changes for operations/info separation.
117 0.99.1.4 Added speed selection (someone had to do this
120 23 jan 1997 0.99.1.5 MODULE_PARMS call added.
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?
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
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()
140 13 feb 1997 1.0 Final version for 2.0 kernel line.
142 All following changes will be for the 2.1 kernel line.
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.
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>.
150 21 dec 1997 1.4 Upgrade to Linux 2.1.72.
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.
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>
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.
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.
169 * I call all routines connected to the Linux kernel something
170 * with `cm206' in it, as this stuff is too series-dependent.
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
178 * David van Leeuwen, david@tm.tno.nl. */
179 #define REVISION "$Revision: 1.5 $"
181 #include <linux/module.h>
183 #include <linux/errno.h> /* These include what we really need */
184 #include <linux/delay.h>
185 #include <linux/string.h>
186 #include <linux/sched.h>
187 #include <linux/interrupt.h>
188 #include <linux/timer.h>
189 #include <linux/cdrom.h>
190 #include <linux/devfs_fs_kernel.h>
191 #include <linux/ioport.h>
192 #include <linux/mm.h>
193 #include <linux/malloc.h>
194 #include <linux/init.h>
196 /* #include <linux/ucdrom.h> */
200 #define MAJOR_NR CM206_CDROM_MAJOR
201 #include <linux/blk.h>
204 #define STATISTICS /* record times and frequencies of events */
205 #define AUTO_PROBE_MODULE
210 /* This variable defines whether or not to probe for adapter base port
211 address and interrupt request. It can be overridden by the boot
214 static int auto_probe
=1; /* Yes, why not? */
216 static int cm206_base
= CM206_BASE
;
217 static int cm206_irq
= CM206_IRQ
;
218 static int cm206
[2] = {0,0}; /* for compatible `insmod' parameter passing */
220 MODULE_PARM(cm206_base
, "i"); /* base */
221 MODULE_PARM(cm206_irq
, "i"); /* irq */
222 MODULE_PARM(cm206
, "1-2i"); /* base,irq or irq,base */
223 MODULE_PARM(auto_probe
, "i"); /* auto probe base and irq */
225 #define POLLOOP 100 /* milliseconds */
226 #define READ_AHEAD 1 /* defines private buffer, waste! */
227 #define BACK_AHEAD 1 /* defines adapter-read ahead */
228 #define DATA_TIMEOUT (3*HZ) /* measured in jiffies (10 ms) */
229 #define UART_TIMEOUT (5*HZ/100)
230 #define DSB_TIMEOUT (7*HZ) /* time for the slowest command to finish */
231 #define UR_SIZE 4 /* uart receive buffer fifo size */
233 #define LINUX_BLOCK_SIZE 512 /* WHERE is this defined? */
234 #define RAW_SECTOR_SIZE 2352 /* ok, is also defined in cdrom.h */
235 #define ISO_SECTOR_SIZE 2048
236 #define BLOCKS_ISO (ISO_SECTOR_SIZE/LINUX_BLOCK_SIZE) /* 4 */
237 #define CD_SYNC_HEAD 16 /* CD_SYNC + CD_HEAD */
239 #ifdef STATISTICS /* keep track of errors in counters */
240 #define stats(i) { ++cd->stats[st_ ## i]; \
241 cd->last_stat[st_ ## i] = cd->stat_counter++; \
244 #define stats(i) (void) 0;
247 #define Debug(a) {printk (KERN_DEBUG); printk a;}
249 #define debug(a) Debug(a)
251 #define debug(a) (void) 0;
254 typedef unsigned char uch
; /* 8-bits */
255 typedef unsigned short ush
; /* 16-bits */
257 struct toc_struct
{ /* private copy of Table of Contents */
258 uch track
, fsm
[3], q0
;
261 static int cm206_blocksizes
[1] = { 2048 };
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 */
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 */
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 */
282 char fifo_overflowed
;
283 uch disc_status
[7]; /* result of get_disc_status command */
286 int last_stat
[NR_STATS
]; /* `time' at which stat was stat */
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 */
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 */
301 static struct cm206_struct
* cd
; /* the main memory structure */
303 /* First, we define some polling functions. These are actually
304 only being used in the initialization. */
306 void send_command_polled(int command
)
309 while (!(inw(r_line_status
) & ls_transmitter_buffer_empty
) && loop
>0) {
310 mdelay(1); /* one millisec delay */
313 outw(command
, r_uart_transmit
);
316 uch
receive_echo_polled(void)
319 while (!(inw(r_line_status
) & ls_receive_buffer_full
) && loop
>0) {
323 return ((uch
) inw(r_uart_receive
));
326 uch
send_receive_polled(int command
)
328 send_command_polled(command
);
329 return receive_echo_polled();
332 inline void clear_ur(void) {
333 if (cd
->ur_r
!= cd
->ur_w
) {
334 debug(("Deleting bytes from fifo:"));
335 for(;cd
->ur_r
!= cd
->ur_w
; cd
->ur_r
++, cd
->ur_r
%= UR_SIZE
)
336 debug((" 0x%x", cd
->ur
[cd
->ur_r
]));
341 /* The interrupt handler. When the cm260 generates an interrupt, very
342 much care has to be taken in reading out the registers in the right
343 order; in case of a receive_buffer_full interrupt, first the
344 uart_receive must be read, and then the line status again to
345 de-assert the interrupt line. It took me a couple of hours to find
348 The function reset_cm206 appears to cause an interrupt, because
349 pulling up the INIT line clears both the uart-write-buffer /and/
350 the uart-write-buffer-empty mask. We call this a `lost interrupt,'
351 as there seems so reason for this to happen.
354 static void cm206_interrupt(int sig
, void *dev_id
, struct pt_regs
* regs
)
358 cd
->intr_ds
= inw(r_data_status
); /* resets data_ready, data_error,
359 crc_error, sync_error, toc_ready
361 cd
->intr_ls
= inw(r_line_status
); /* resets overrun bit */
362 debug(("Intr, 0x%x 0x%x, %d\n", cd
->intr_ds
, cd
->intr_ls
, cd
->background
));
363 if (cd
->intr_ls
& ls_attention
) stats(attention
);
364 /* receive buffer full? */
365 if (cd
->intr_ls
& ls_receive_buffer_full
) {
366 cd
->ur
[cd
->ur_w
] = inb(r_uart_receive
); /* get order right! */
367 cd
->intr_ls
= inw(r_line_status
); /* resets rbf interrupt */
368 debug(("receiving #%d: 0x%x\n", cd
->ur_w
, cd
->ur
[cd
->ur_w
]));
369 cd
->ur_w
++; cd
->ur_w
%= UR_SIZE
;
370 if (cd
->ur_w
== cd
->ur_r
) debug(("cd->ur overflow!\n"));
371 if (waitqueue_active(&cd
->uart
) && cd
->background
< 2) {
372 del_timer(&cd
->timer
);
373 wake_up_interruptible(&cd
->uart
);
376 /* data ready in fifo? */
377 else if (cd
->intr_ds
& ds_data_ready
) {
378 if (cd
->background
) ++cd
->adapter_last
;
379 if (waitqueue_active(&cd
->data
) && (cd
->wait_back
|| !cd
->background
)) {
380 del_timer(&cd
->timer
);
381 wake_up_interruptible(&cd
->data
);
385 /* ready to issue a write command? */
386 else if (cd
->command
&& cd
->intr_ls
& ls_transmitter_buffer_empty
) {
387 outw(dc_normal
| (inw(r_data_status
) & 0x7f), r_data_control
);
388 outw(cd
->command
, r_uart_transmit
);
390 if (!cd
->background
) wake_up_interruptible(&cd
->uart
);
392 /* now treat errors (at least, identify them for debugging) */
393 else if (cd
->intr_ds
& ds_fifo_overflow
) {
394 debug(("Fifo overflow at sectors 0x%x\n", cd
->sector_first
));
395 fool
= inw(r_fifo_output_buffer
); /* de-assert the interrupt */
396 cd
->fifo_overflowed
=1; /* signal one word less should be read */
397 stats(fifo_overflow
);
399 else if (cd
->intr_ds
& ds_data_error
) {
400 debug(("Data error at sector 0x%x\n", cd
->sector_first
));
403 else if (cd
->intr_ds
& ds_crc_error
) {
404 debug(("CRC error at sector 0x%x\n", cd
->sector_first
));
407 else if (cd
->intr_ds
& ds_sync_error
) {
408 debug(("Sync at sector 0x%x\n", cd
->sector_first
));
411 else if (cd
->intr_ds
& ds_toc_ready
) {
412 /* do something appropriate */
414 /* couldn't see why this interrupt, maybe due to init */
416 outw(dc_normal
| READ_AHEAD
, r_data_control
);
419 if (cd
->background
&& (cd
->adapter_last
-cd
->adapter_first
== cd
->max_sectors
420 || cd
->fifo_overflowed
))
421 mark_bh(CM206_BH
); /* issue a stop read command */
425 /* we have put the address of the wait queue in who */
426 void cm206_timeout(unsigned long who
)
429 debug(("Timing out\n"));
430 wake_up_interruptible((wait_queue_head_t
*)who
);
433 /* This function returns 1 if a timeout occurred, 0 if an interrupt
435 int sleep_or_timeout(wait_queue_head_t
*wait
, int timeout
)
438 cd
->timer
.data
=(unsigned long) wait
;
439 cd
->timer
.expires
= jiffies
+ timeout
;
440 add_timer(&cd
->timer
);
441 debug(("going to sleep\n"));
442 interruptible_sleep_on(wait
);
443 del_timer(&cd
->timer
);
451 void cm206_delay(int nr_jiffies
)
453 DECLARE_WAIT_QUEUE_HEAD(wait
);
454 sleep_or_timeout(&wait
, nr_jiffies
);
457 void send_command(int command
)
459 debug(("Sending 0x%x\n", command
));
460 if (!(inw(r_line_status
) & ls_transmitter_buffer_empty
)) {
461 cd
->command
= command
;
462 cli(); /* don't interrupt before sleep */
463 outw(dc_mask_sync_error
| dc_no_stop_on_error
|
464 (inw(r_data_status
) & 0x7f), r_data_control
);
465 /* interrupt routine sends command */
466 if (sleep_or_timeout(&cd
->uart
, UART_TIMEOUT
)) {
467 debug(("Time out on write-buffer\n"));
468 stats(write_timeout
);
469 outw(command
, r_uart_transmit
);
471 debug(("Write commmand delayed\n"));
473 else outw(command
, r_uart_transmit
);
476 uch
receive_byte(int timeout
)
481 ret
= cd
->ur
[cd
->ur_r
];
482 if (cd
->ur_r
!= cd
->ur_w
) {
484 debug(("returning #%d: 0x%x\n", cd
->ur_r
, cd
->ur
[cd
->ur_r
]));
485 cd
->ur_r
++; cd
->ur_r
%= UR_SIZE
;
488 else if (sleep_or_timeout(&cd
->uart
, timeout
)) { /* does sti() */
489 debug(("Time out on receive-buffer\n"));
491 if (timeout
==UART_TIMEOUT
) stats(receive_timeout
) /* no `;'! */
492 else stats(dsb_timeout
);
496 ret
= cd
->ur
[cd
->ur_r
];
497 debug(("slept; returning #%d: 0x%x\n", cd
->ur_r
, cd
->ur
[cd
->ur_r
]));
498 cd
->ur_r
++; cd
->ur_r
%= UR_SIZE
;
502 inline uch
receive_echo(void)
504 return receive_byte(UART_TIMEOUT
);
507 inline uch
send_receive(int command
)
509 send_command(command
);
510 return receive_echo();
513 inline uch
wait_dsb(void)
515 return receive_byte(DSB_TIMEOUT
);
518 int type_0_command(int command
, int expect_dsb
)
522 if (command
!= (e
=send_receive(command
))) {
523 debug(("command 0x%x echoed as 0x%x\n", command
, e
));
528 cd
->dsb
= wait_dsb(); /* wait for command to finish */
533 int type_1_command(int command
, int bytes
, uch
* status
) /* returns info */
536 if (type_0_command(command
,0)) return -1;
537 for(i
=0; i
<bytes
; i
++)
538 status
[i
] = send_receive(c_gimme
);
542 /* This function resets the adapter card. We'd better not do this too
543 * often, because it tends to generate `lost interrupts.' */
544 void reset_cm260(void)
546 outw(dc_normal
| dc_initialize
| READ_AHEAD
, r_data_control
);
547 udelay(10); /* 3.3 mu sec minimum */
548 outw(dc_normal
| READ_AHEAD
, r_data_control
);
551 /* fsm: frame-sec-min from linear address; one of many */
552 void fsm(int lba
, uch
* fsm
)
556 fsm
[1] = lba
% 60; fsm
[2] = lba
/ 60;
559 inline int fsm2lba(uch
* fsm
)
561 return fsm
[0] + 75*(fsm
[1]-2 + 60*fsm
[2]);
564 inline int f_s_m2lba(uch f
, uch s
, uch m
)
566 return f
+ 75*(s
-2 + 60*m
);
569 int start_read(int start
)
571 uch read_sector
[4] = {c_read_data
, };
574 fsm(start
, &read_sector
[1]);
577 if (read_sector
[i
] != (e
=send_receive(read_sector
[i
]))) {
578 debug(("read_sector: %x echoes %x\n", read_sector
[i
], e
));
580 if (e
==0xff) { /* this seems to happen often */
582 debug(("Second try %x\n", e
));
583 if (e
!=read_sector
[i
]) return -1;
592 type_0_command(c_stop
,0);
593 if((e
=receive_echo()) != 0xff) {
594 debug(("c_stop didn't send 0xff, but 0x%x\n", e
));
601 /* This function starts to read sectors in adapter memory, the
602 interrupt routine should stop the read. In fact, the bottom_half
603 routine takes care of this. Set a flag `background' in the cd
604 struct to indicate the process. */
606 int read_background(int start
, int reading
)
608 if (cd
->background
) return -1; /* can't do twice */
609 outw(dc_normal
| BACK_AHEAD
, r_data_control
);
610 if (!reading
&& start_read(start
)) return -2;
611 cd
->adapter_first
= cd
->adapter_last
= start
;
612 cd
->background
= 1; /* flag a read is going on */
617 #define transport_data insw
619 /* this routine implements insw(,,). There was a time i had the
620 impression that there would be any difference in error-behaviour. */
621 void transport_data(int port
, ush
* dest
, int count
)
625 for (i
=0, d
=dest
; i
<count
; i
++, d
++)
631 #define MAX_TRIES 100
632 int read_sector(int start
)
635 if (cd
->background
) {
637 cd
->adapter_last
= -1; /* invalidate adapter memory */
640 cd
->fifo_overflowed
=0;
641 reset_cm260(); /* empty fifo etc. */
642 if (start_read(start
)) return -1;
644 if (sleep_or_timeout(&cd
->data
, DATA_TIMEOUT
)) {
645 debug(("Read timed out sector 0x%x\n", start
));
651 } while (cd
->intr_ds
& ds_fifo_empty
&& tries
< MAX_TRIES
);
652 if (tries
>1) debug(("Took me some tries\n"))
653 else if (tries
== MAX_TRIES
)
654 debug(("MAX_TRIES tries for read sector\n"));
655 transport_data(r_fifo_output_buffer
, cd
->sector
,
656 READ_AHEAD
*RAW_SECTOR_SIZE
/2);
657 if (read_background(start
+READ_AHEAD
,1)) stats(read_background
);
658 cd
->sector_first
= start
; cd
->sector_last
= start
+READ_AHEAD
;
659 stats(read_restarted
);
663 /* The function of bottom-half is to send a stop command to the drive
664 This isn't easy because the routine is not `owned' by any process;
665 we can't go to sleep! The variable cd->background gives the status:
668 2 c_stop waits for write_buffer_empty
669 3 c_stop waits for receive_buffer_full: echo
670 4 c_stop waits for receive_buffer_full: 0xff
675 debug(("bh: %d\n", cd
->background
));
676 switch (cd
->background
) {
679 if (!(cd
->intr_ls
& ls_transmitter_buffer_empty
)) {
680 cd
->command
= c_stop
;
681 outw(dc_mask_sync_error
| dc_no_stop_on_error
|
682 (inw(r_data_status
) & 0x7f), r_data_control
);
684 break; /* we'd better not time-out here! */
686 else outw(c_stop
, r_uart_transmit
);
687 /* fall into case 2: */
689 /* the write has been satisfied by interrupt routine */
693 if (cd
->ur_r
!= cd
->ur_w
) {
694 if (cd
->ur
[cd
->ur_r
] != c_stop
) {
695 debug(("cm206_bh: c_stop echoed 0x%x\n", cd
->ur
[cd
->ur_r
]));
698 cd
->ur_r
++; cd
->ur_r
%= UR_SIZE
;
703 if (cd
->ur_r
!= cd
->ur_w
) {
704 if (cd
->ur
[cd
->ur_r
] != 0xff) {
705 debug(("cm206_bh: c_stop reacted with 0x%x\n", cd
->ur
[cd
->ur_r
]));
708 cd
->ur_r
++; cd
->ur_r
%= UR_SIZE
;
714 /* This command clears the dsb_possible_media_change flag, so we must
717 void get_drive_status(void)
720 type_1_command(c_drive_status
, 2, status
); /* this might be done faster */
724 !!(cd
->dsb
& (dsb_possible_media_change
|
725 dsb_drive_not_ready
| dsb_tray_not_closed
));
728 void get_disc_status(void)
730 if (type_1_command(c_disc_status
, 7, cd
->disc_status
)) {
731 debug(("get_disc_status: error\n"));
735 /* The new open. The real opening strategy is defined in cdrom.c. */
737 static int cm206_open(struct cdrom_device_info
* cdi
, int purpose
)
740 if (!cd
->openfiles
) { /* reset only first time */
743 cd
->adapter_last
= -1; /* invalidate adapter memory */
744 cd
->sector_last
= -1;
751 static void cm206_release(struct cdrom_device_info
* cdi
)
753 if (cd
->openfiles
==1) {
754 if (cd
->background
) {
758 cd
->sector_last
= -1; /* Make our internal buffer invalid */
759 FIRST_TRACK
= 0; /* No valid disc status */
765 /* Empty buffer empties $sectors$ sectors of the adapter card buffer,
766 * and then reads a sector in kernel memory. */
767 void empty_buffer(int sectors
)
770 transport_data(r_fifo_output_buffer
, cd
->sector
+ cd
->fifo_overflowed
,
771 RAW_SECTOR_SIZE
/2 - cd
->fifo_overflowed
);
773 ++cd
->adapter_first
; /* update the current adapter sector */
774 cd
->fifo_overflowed
=0; /* reset overflow bit */
775 stats(sector_transferred
);
777 cd
->sector_first
=cd
->adapter_first
-1;
778 cd
->sector_last
=cd
->adapter_first
; /* update the buffer sector */
781 /* try_adapter. This function determines if the requested sector is
782 in adapter memory, or will appear there soon. Returns 0 upon
784 int try_adapter(int sector
)
786 if (cd
->adapter_first
<= sector
&& sector
< cd
->adapter_last
) {
787 /* sector is in adapter memory */
788 empty_buffer(sector
- cd
->adapter_first
);
791 else if (cd
->background
==1 && cd
->adapter_first
<= sector
792 && sector
< cd
->adapter_first
+cd
->max_sectors
) {
793 /* a read is going on, we can wait for it */
795 while (sector
>= cd
->adapter_last
) {
796 if (sleep_or_timeout(&cd
->data
, DATA_TIMEOUT
)) {
797 debug(("Timed out during background wait: %d %d %d %d\n", sector
,
798 cd
->adapter_last
, cd
->adapter_first
, cd
->background
));
799 stats(back_read_timeout
);
805 empty_buffer(sector
- cd
->adapter_first
);
811 /* This is not a very smart implementation. We could optimize for
812 consecutive block numbers. I'm not convinced this would really
813 bring down the processor load. */
814 static void do_cm206_request(request_queue_t
* q
)
816 long int i
, cd_sec_no
;
818 uch
* source
, * dest
;
820 while(1) { /* repeat until all requests have been satisfied */
822 if (QUEUE_EMPTY
|| CURRENT
->rq_status
== RQ_INACTIVE
)
824 if (CURRENT
->cmd
!= READ
) {
825 debug(("Non-read command %d on cdrom\n", CURRENT
->cmd
));
829 spin_unlock_irq(&io_request_lock
);
831 for (i
=0; i
<CURRENT
->nr_sectors
; i
++) {
833 cd_sec_no
= (CURRENT
->sector
+i
)/BLOCKS_ISO
; /* 4 times 512 bytes */
834 quarter
= (CURRENT
->sector
+i
) % BLOCKS_ISO
;
835 dest
= CURRENT
->buffer
+ i
*LINUX_BLOCK_SIZE
;
836 /* is already in buffer memory? */
837 if (cd
->sector_first
<= cd_sec_no
&& cd_sec_no
< cd
->sector_last
) {
838 source
= ((uch
*) cd
->sector
) + 16 + quarter
*LINUX_BLOCK_SIZE
839 + (cd_sec_no
-cd
->sector_first
)*RAW_SECTOR_SIZE
;
840 memcpy(dest
, source
, LINUX_BLOCK_SIZE
);
842 else if (!(e1
=try_adapter(cd_sec_no
)) ||
843 !(e2
=read_sector(cd_sec_no
))) {
844 source
= ((uch
*) cd
->sector
)+16+quarter
*LINUX_BLOCK_SIZE
;
845 memcpy(dest
, source
, LINUX_BLOCK_SIZE
);
849 debug(("cm206_request: %d %d\n", e1
, e2
));
852 spin_lock_irq(&io_request_lock
);
857 /* Audio support. I've tried very hard, but the cm206 drive doesn't
858 seem to have a get_toc (table-of-contents) function, while i'm
859 pretty sure it must read the toc upon disc insertion. Therefore
860 this function has been implemented through a binary search
861 strategy. All track starts that happen to be found are stored in
862 cd->toc[], for future use.
864 I've spent a whole day on a bug that only shows under Workman---
865 I don't get it. Tried everything, nothing works. If workman asks
866 for track# 0xaa, it'll get the wrong time back. Any other program
867 receives the correct value. I'm stymied.
870 /* seek seeks to address lba. It does wait to arrive there. */
874 uch seek_command
[4]={c_seek
, };
876 fsm(lba
, &seek_command
[1]);
877 for (i
=0; i
<4; i
++) type_0_command(seek_command
[i
], 0);
878 cd
->dsb
= wait_dsb();
881 uch
bcdbin(unsigned char bcd
) /* stolen from mcd.c! */
883 return (bcd
>> 4)*10 + (bcd
& 0xf);
886 inline uch
normalize_track(uch track
)
888 if (track
<1) return 1;
889 if (track
>LAST_TRACK
) return LAST_TRACK
+1;
893 /* This function does a binary search for track start. It records all
894 * tracks seen in the process. Input $track$ must be between 1 and
895 * #-of-tracks+1. Note that the start of the disc must be in toc[1].fsm.
897 int get_toc_lba(uch track
)
899 int max
=74*60*75-150, min
=fsm2lba(cd
->toc
[1].fsm
);
900 int i
, lba
, l
, old_lba
=0;
902 uch ct
; /* current track */
904 const int skip
= 3*60*75; /* 3 minutes */
906 for (i
=track
; i
>0; i
--) if (cd
->toc
[i
].track
) {
907 min
= fsm2lba(cd
->toc
[i
].fsm
);
913 type_1_command(c_read_current_q
, 10, q
);
914 ct
= normalize_track(q
[1]);
915 if (!cd
->toc
[ct
].track
) {
916 l
= q
[9]-bcdbin(q
[5]) + 75*(q
[8]-bcdbin(q
[4])-2 +
917 60*(q
[7]-bcdbin(q
[3])));
918 cd
->toc
[ct
].track
=q
[1]; /* lead out still 0xaa */
919 fsm(l
, cd
->toc
[ct
].fsm
);
920 cd
->toc
[ct
].q0
= q
[0]; /* contains adr and ctrl info */
921 if (ct
==track
) return l
;
925 if (ct
< track
) min
= lba
; else max
= lba
;
928 if(ct
< track
) lba
+= skip
;
931 max
= lba
; min
= lba
- skip
;
935 } while (lba
!=old_lba
);
939 void update_toc_entry(uch track
)
941 track
= normalize_track(track
);
942 if (!cd
->toc
[track
].track
) get_toc_lba(track
);
945 /* return 0 upon success */
946 int read_toc_header(struct cdrom_tochdr
* hp
)
948 if (!FIRST_TRACK
) get_disc_status();
951 hp
->cdth_trk0
= FIRST_TRACK
;
952 hp
->cdth_trk1
= LAST_TRACK
;
953 /* fill in first track position */
954 for (i
=0; i
<3; i
++) cd
->toc
[1].fsm
[i
] = cd
->disc_status
[3+i
];
955 update_toc_entry(LAST_TRACK
+1); /* find most entries */
961 void play_from_to_msf(struct cdrom_msf
* msfp
)
963 uch play_command
[] = {c_play
,
964 msfp
->cdmsf_frame0
, msfp
->cdmsf_sec0
, msfp
->cdmsf_min0
,
965 msfp
->cdmsf_frame1
, msfp
->cdmsf_sec1
, msfp
->cdmsf_min1
, 2, 2};
967 for (i
=0; i
<9; i
++) type_0_command(play_command
[i
], 0);
969 PLAY_TO
.fsm
[i
] = play_command
[i
+4];
970 PLAY_TO
.track
= 0; /* say no track end */
971 cd
->dsb
= wait_dsb();
974 void play_from_to_track(int from
, int to
)
976 uch play_command
[8] = {c_play
, };
979 if (from
==0) { /* continue paused play */
980 for (i
=0; i
<3; i
++) {
981 play_command
[i
+1] = cd
->audio_status
[i
+2];
982 play_command
[i
+4] = PLAY_TO
.fsm
[i
];
985 update_toc_entry(from
); update_toc_entry(to
+1);
986 for (i
=0; i
<3; i
++) {
987 play_command
[i
+1] = cd
->toc
[from
].fsm
[i
];
988 PLAY_TO
.fsm
[i
] = play_command
[i
+4] = cd
->toc
[to
+1].fsm
[i
];
992 for (i
=0; i
<7; i
++) type_0_command(play_command
[i
],0);
993 for (i
=0; i
<2; i
++) type_0_command(0x2, 0); /* volume */
994 cd
->dsb
= wait_dsb();
997 int get_current_q(struct cdrom_subchnl
* qp
)
1001 if (type_1_command(c_read_current_q
, 10, q
)) return 0;
1002 /* q[0] = bcdbin(q[0]); Don't think so! */
1003 for (i
=2; i
<6; i
++) q
[i
]=bcdbin(q
[i
]);
1004 qp
->cdsc_adr
= q
[0] & 0xf; qp
->cdsc_ctrl
= q
[0] >> 4; /* from mcd.c */
1005 qp
->cdsc_trk
= q
[1]; qp
->cdsc_ind
= q
[2];
1006 if (qp
->cdsc_format
== CDROM_MSF
) {
1007 qp
->cdsc_reladdr
.msf
.minute
= q
[3];
1008 qp
->cdsc_reladdr
.msf
.second
= q
[4];
1009 qp
->cdsc_reladdr
.msf
.frame
= q
[5];
1010 qp
->cdsc_absaddr
.msf
.minute
= q
[7];
1011 qp
->cdsc_absaddr
.msf
.second
= q
[8];
1012 qp
->cdsc_absaddr
.msf
.frame
= q
[9];
1014 qp
->cdsc_reladdr
.lba
= f_s_m2lba(q
[5], q
[4], q
[3]);
1015 qp
->cdsc_absaddr
.lba
= f_s_m2lba(q
[9], q
[8], q
[7]);
1018 if (cd
->dsb
& dsb_play_in_progress
)
1019 qp
->cdsc_audiostatus
= CDROM_AUDIO_PLAY
;
1021 qp
->cdsc_audiostatus
= CDROM_AUDIO_PAUSED
;
1022 else qp
->cdsc_audiostatus
= CDROM_AUDIO_NO_STATUS
;
1026 void invalidate_toc(void)
1028 memset(cd
->toc
, 0, sizeof(cd
->toc
));
1029 memset(cd
->disc_status
, 0, sizeof(cd
->disc_status
));
1032 /* cdrom.c guarantees that cdte_format == CDROM_MSF */
1033 void get_toc_entry(struct cdrom_tocentry
* ep
)
1035 uch track
= normalize_track(ep
->cdte_track
);
1036 update_toc_entry(track
);
1037 ep
->cdte_addr
.msf
.frame
= cd
->toc
[track
].fsm
[0];
1038 ep
->cdte_addr
.msf
.second
= cd
->toc
[track
].fsm
[1];
1039 ep
->cdte_addr
.msf
.minute
= cd
->toc
[track
].fsm
[2];
1040 ep
->cdte_adr
= cd
->toc
[track
].q0
& 0xf;
1041 ep
->cdte_ctrl
= cd
->toc
[track
].q0
>> 4;
1042 ep
->cdte_datamode
=0;
1045 /* Audio ioctl. Ioctl commands connected to audio are in such an
1046 * idiosyncratic i/o format, that we leave these untouched. Return 0
1047 * upon success. Memory checking has been done by cdrom_ioctl(), the
1048 * calling function, as well as LBA/MSF sanitization.
1050 int cm206_audio_ioctl(struct cdrom_device_info
* cdi
, unsigned int cmd
,
1054 case CDROMREADTOCHDR
:
1055 return read_toc_header((struct cdrom_tochdr
*) arg
);
1056 case CDROMREADTOCENTRY
:
1057 get_toc_entry((struct cdrom_tocentry
*) arg
);
1060 play_from_to_msf((struct cdrom_msf
*) arg
);
1062 case CDROMPLAYTRKIND
: /* admittedly, not particularly beautiful */
1063 play_from_to_track(((struct cdrom_ti
*)arg
)->cdti_trk0
,
1064 ((struct cdrom_ti
*)arg
)->cdti_trk1
);
1068 if (cd
->dsb
& dsb_play_in_progress
) return type_0_command(c_stop
, 1);
1072 if (cd
->dsb
& dsb_play_in_progress
) {
1073 type_0_command(c_stop
, 1);
1074 type_1_command(c_audio_status
, 5, cd
->audio_status
);
1075 PAUSED
=1; /* say we're paused */
1079 if (PAUSED
) play_from_to_track(0,0);
1086 return get_current_q((struct cdrom_subchnl
*)arg
);
1092 /* Ioctl. These ioctls are specific to the cm206 driver. I have made
1093 some driver statistics accessible through ioctl calls.
1096 static int cm206_ioctl(struct cdrom_device_info
* cdi
, unsigned int cmd
,
1101 case CM206CTL_GET_STAT
:
1102 if (arg
>= NR_STATS
) return -EINVAL
;
1103 else return cd
->stats
[arg
];
1104 case CM206CTL_GET_LAST_STAT
:
1105 if (arg
>= NR_STATS
) return -EINVAL
;
1106 else return cd
->last_stat
[arg
];
1109 debug(("Unknown ioctl call 0x%x\n", cmd
));
1114 int cm206_media_changed(struct cdrom_device_info
* cdi
, int disc_nr
)
1118 get_drive_status(); /* ensure cd->media_changed OK */
1119 r
= cd
->media_changed
;
1120 cd
->media_changed
= 0; /* clear bit */
1126 /* The new generic cdrom support. Routines should be concise, most of
1127 the logic should be in cdrom.c */
1129 /* returns number of times device is in use */
1130 int cm206_open_files(struct cdrom_device_info
* cdi
)
1132 if (cd
) return cd
->openfiles
;
1136 /* controls tray movement */
1137 int cm206_tray_move(struct cdrom_device_info
* cdi
, int position
)
1139 if (position
) { /* 1: eject */
1140 type_0_command(c_open_tray
,1);
1143 else type_0_command(c_close_tray
, 1); /* 0: close */
1147 /* gives current state of the drive */
1148 int cm206_drive_status(struct cdrom_device_info
* cdi
, int slot_nr
)
1151 if (cd
->dsb
& dsb_tray_not_closed
) return CDS_TRAY_OPEN
;
1152 if (!(cd
->dsb
& dsb_disc_present
)) return CDS_NO_DISC
;
1153 if (cd
->dsb
& dsb_drive_not_ready
) return CDS_DRIVE_NOT_READY
;
1157 /* locks or unlocks door lock==1: lock; return 0 upon success */
1158 int cm206_lock_door(struct cdrom_device_info
* cdi
, int lock
)
1160 uch command
= (lock
) ? c_lock_tray
: c_unlock_tray
;
1161 type_0_command(command
, 1); /* wait and get dsb */
1162 /* the logic calculates the success, 0 means successful */
1163 return lock
^ ((cd
->dsb
& dsb_tray_locked
) != 0);
1166 /* Although a session start should be in LBA format, we return it in
1167 MSF format because it is slightly easier, and the new generic ioctl
1168 will take care of the necessary conversion. */
1169 int cm206_get_last_session(struct cdrom_device_info
* cdi
,
1170 struct cdrom_multisession
* mssp
)
1172 if (!FIRST_TRACK
) get_disc_status();
1174 if (DISC_STATUS
& cds_multi_session
) { /* multi-session */
1175 mssp
->addr
.msf
.frame
= cd
->disc_status
[3];
1176 mssp
->addr
.msf
.second
= cd
->disc_status
[4];
1177 mssp
->addr
.msf
.minute
= cd
->disc_status
[5];
1178 mssp
->addr_format
= CDROM_MSF
;
1188 int cm206_get_upc(struct cdrom_device_info
* cdi
, struct cdrom_mcn
* mcn
)
1191 char * ret
= mcn
->medium_catalog_number
;
1194 if (type_1_command(c_read_upc
, 10, upc
)) return -EIO
;
1195 for (i
=0; i
<13; i
++) {
1197 if (r
) ret
[i
] = 0x30 | (upc
[w
] & 0x0f);
1198 else ret
[i
] = 0x30 | ((upc
[w
] >> 4) & 0x0f);
1204 int cm206_reset(struct cdrom_device_info
* cdi
)
1208 outw(dc_normal
| dc_break
| READ_AHEAD
, r_data_control
);
1209 mdelay(1); /* 750 musec minimum */
1210 outw(dc_normal
| READ_AHEAD
, r_data_control
);
1211 cd
->sector_last
= -1; /* flag no data buffered */
1212 cd
->adapter_last
= -1;
1217 int cm206_select_speed(struct cdrom_device_info
* cdi
, int speed
)
1222 r
= type_0_command(c_auto_mode
, 1);
1225 r
= type_0_command(c_force_1x
, 1);
1228 r
= type_0_command(c_force_2x
, 1);
1237 static struct cdrom_device_ops cm206_dops
= {
1239 release
: cm206_release
,
1240 drive_status
: cm206_drive_status
,
1241 media_changed
: cm206_media_changed
,
1242 tray_move
: cm206_tray_move
,
1243 lock_door
: cm206_lock_door
,
1244 select_speed
: cm206_select_speed
,
1245 get_last_session
: cm206_get_last_session
,
1246 get_mcn
: cm206_get_upc
,
1248 audio_ioctl
: cm206_audio_ioctl
,
1249 dev_ioctl
: cm206_ioctl
,
1250 capability
: CDC_CLOSE_TRAY
| CDC_OPEN_TRAY
| CDC_LOCK
|
1251 CDC_MULTI_SESSION
| CDC_MEDIA_CHANGED
|
1252 CDC_MCN
| CDC_PLAY_AUDIO
| CDC_SELECT_SPEED
|
1253 CDC_IOCTLS
| CDC_DRIVE_STATUS
,
1258 static struct cdrom_device_info cm206_info
= {
1265 /* This routine gets called during initialization if things go wrong,
1266 * can be used in cleanup_module as well. */
1267 static void cleanup(int level
)
1271 if (unregister_cdrom(&cm206_info
)) {
1272 printk("Can't unregister cdrom cm206\n");
1275 if (devfs_unregister_blkdev(MAJOR_NR
, "cm206")) {
1276 printk("Can't unregister major cm206\n");
1279 blk_cleanup_queue(BLK_DEFAULT_QUEUE(MAJOR_NR
));
1281 free_irq(cm206_irq
, NULL
);
1285 release_region(cm206_base
, 16);
1290 /* This function probes for the adapter card. It returns the base
1291 address if it has found the adapter card. One can specify a base
1292 port to probe specifically, or 0 which means span all possible
1295 Linus says it is too dangerous to use writes for probing, so we
1296 stick with pure reads for a while. Hope that 8 possible ranges,
1297 check_region, 15 bits of one port and 6 of another make things
1298 likely enough to accept the region on the first hit...
1300 int __init
probe_base_port(int base
)
1302 int b
=0x300, e
=0x370; /* this is the range of start addresses */
1303 volatile int fool
, i
;
1306 for (base
=b
; base
<=e
; base
+= 0x10) {
1307 if (check_region(base
, 0x10)) continue;
1309 fool
= inw(base
+2); /* empty possibly uart_receive_buffer */
1310 if((inw(base
+6) & 0xffef) != 0x0001 || /* line_status */
1311 (inw(base
) & 0xad00) != 0) /* data status */
1318 #if !defined(MODULE) || defined(AUTO_PROBE_MODULE)
1319 /* Probe for irq# nr. If nr==0, probe for all possible irq's. */
1320 int __init
probe_irq(int nr
){
1322 outw(dc_normal
| READ_AHEAD
, r_data_control
); /* disable irq-generation */
1324 irqs
= probe_irq_on();
1325 reset_cm260(); /* causes interrupt */
1326 udelay(100); /* wait for it */
1327 irq
= probe_irq_off(irqs
);
1328 outw(dc_normal
| READ_AHEAD
, r_data_control
); /* services interrupt */
1329 if (nr
&& irq
!=nr
&& irq
>0) return 0; /* wrong interrupt happened */
1334 int __init
cm206_init(void)
1337 long int size
=sizeof(struct cm206_struct
);
1339 printk(KERN_INFO
"cm206 cdrom driver " REVISION
);
1340 cm206_base
= probe_base_port(auto_probe
? 0 : cm206_base
);
1342 printk(" can't find adapter!\n");
1345 printk(" adapter at 0x%x", cm206_base
);
1346 request_region(cm206_base
, 16, "cm206");
1347 cd
= (struct cm206_struct
*) kmalloc(size
, GFP_KERNEL
);
1348 if (!cd
) return -EIO
;
1349 /* Now we have found the adaptor card, try to reset it. As we have
1350 * found out earlier, this process generates an interrupt as well,
1351 * so we might just exploit that fact for irq probing! */
1352 #if !defined(MODULE) || defined(AUTO_PROBE_MODULE)
1353 cm206_irq
= probe_irq(auto_probe
? 0 : cm206_irq
);
1355 printk("can't find IRQ!\n");
1359 else printk(" IRQ %d found\n", cm206_irq
);
1363 /* Now, the problem here is that reset_cm260 can generate an
1364 interrupt. It seems that this can cause a kernel oops some time
1365 later. So we wait a while and `service' this interrupt. */
1367 outw(dc_normal
| READ_AHEAD
, r_data_control
);
1369 printk(" using IRQ %d\n", cm206_irq
);
1371 if (send_receive_polled(c_drive_configuration
) != c_drive_configuration
)
1373 printk(KERN_INFO
" drive not there\n");
1377 e
= send_receive_polled(c_gimme
);
1378 printk(KERN_INFO
"Firmware revision %d", e
& dcf_revision_code
);
1379 if (e
& dcf_transfer_rate
) printk(" double");
1380 else printk(" single");
1381 printk(" speed drive");
1382 if (e
& dcf_motorized_tray
) printk(", motorized tray");
1383 if (request_irq(cm206_irq
, cm206_interrupt
, 0, "cm206", NULL
)) {
1384 printk("\nUnable to reserve IRQ---aborted\n");
1389 if (devfs_register_blkdev(MAJOR_NR
, "cm206", &cdrom_fops
) != 0) {
1390 printk(KERN_INFO
"Cannot register for major %d!\n", MAJOR_NR
);
1394 cm206_info
.dev
= MKDEV(MAJOR_NR
,0);
1395 if (register_cdrom(&cm206_info
) != 0) {
1396 printk(KERN_INFO
"Cannot register for cdrom %d!\n", MAJOR_NR
);
1400 blk_init_queue(BLK_DEFAULT_QUEUE(MAJOR_NR
), DEVICE_REQUEST
);
1401 blksize_size
[MAJOR_NR
] = cm206_blocksizes
;
1402 read_ahead
[MAJOR_NR
] = 16; /* reads ahead what? */
1403 init_bh(CM206_BH
, cm206_bh
);
1405 memset(cd
, 0, sizeof(*cd
)); /* give'm some reasonable value */
1406 cd
->sector_last
= -1; /* flag no data buffered */
1407 cd
->adapter_last
= -1;
1408 cd
->timer
.function
= cm206_timeout
;
1409 cd
->max_sectors
= (inw(r_data_status
) & ds_ram_size
) ? 24 : 97;
1410 printk(KERN_INFO
"%d kB adapter memory available, "
1411 " %ld bytes kernel memory used.\n", cd
->max_sectors
*2, size
);
1418 static void __init
parse_options(void)
1421 for (i
=0; i
<2; i
++) {
1422 if (0x300 <= cm206
[i
] && i
<= 0x370 && cm206
[i
] % 0x10 == 0) {
1423 cm206_base
= cm206
[i
];
1426 else if (3 <= cm206
[i
] && cm206
[i
] <= 15) {
1427 cm206_irq
= cm206
[i
];
1433 int __cm206_init(void)
1436 #if !defined(AUTO_PROBE_MODULE)
1439 return cm206_init();
1442 void __exit
cm206_exit(void)
1445 printk(KERN_INFO
"cm206 removed\n");
1448 module_init(__cm206_init
);
1449 module_exit(cm206_exit
);
1453 /* This setup function accepts either `auto' or numbers in the range
1454 * 3--11 (for irq) or 0x300--0x370 (for base port) or both. */
1456 static int __init
cm206_setup(char *s
)
1460 (void)get_options(s
, ARRAY_SIZE(p
), p
);
1462 if (!strcmp(s
, "auto")) auto_probe
=1;
1463 for(i
=1; i
<=p
[0]; i
++) {
1464 if (0x300 <= p
[i
] && i
<= 0x370 && p
[i
] % 0x10 == 0) {
1468 else if (3 <= p
[i
] && p
[i
] <= 15) {
1476 __setup("cm206=", cm206_setup
);
1478 #endif /* !MODULE */
1481 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/include -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -pipe -fno-strength-reduce -m486 -DMODULE -DMODVERSIONS -include /usr/src/linux/include/linux/modversions.h -c -o cm206.o cm206.c"