Import of Linux/MIPS 2.1.14

1 files changed, 1309 insertions, 0 deletions

diff --git a/drivers/cdrom/cm206.c b/drivers/cdrom/cm206.c
new file mode 100644
index 000000000..4870b8dc0
--- /dev/null
+++ b/drivers/cdrom/cm206.c
@@ -0,0 +1,1309 @@
+/* cm206.c. A linux-driver for the cm206 cdrom player with cm260 adapter card.
+   Copyright (c) 1995, 1996 David van Leeuwen.
+   
+     This program is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published by
+     the Free Software Foundation; either version 2 of the License, or
+     (at your option) any later version.
+     
+     This program is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+     GNU General Public License for more details.
+     
+     You should have received a copy of the GNU General Public License
+     along with this program; if not, write to the Free Software
+     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+History:
+ Started 25 jan 1994. Waiting for documentation...
+ 22 feb 1995: 0.1a first reasonably safe polling driver.
+	      Two major bugs, one in read_sector and one in 
+	      do_cm206_request, happened to cancel!
+ 25 feb 1995: 0.2a first reasonable interrupt driven version of above.
+              uart writes are still done in polling mode. 
+ 25 feb 1995: 0.21a writes also in interrupt mode, still some
+	      small bugs to be found... Larger buffer. 
+  2 mrt 1995: 0.22 Bug found (cd-> nowhere, interrupt was called in
+              initialization), read_ahead of 16. Timeouts implemented.
+	      unclear if they do something...
+  7 mrt 1995: 0.23 Start of background read-ahead.
+ 18 mrt 1995: 0.24 Working background read-ahead. (still problems)
+ 26 mrt 1995: 0.25 Multi-session ioctl added (kernel v1.2).
+              Statistics implemented, though separate stats206.h.
+	      Accessible trough ioctl 0x1000 (just a number).
+	      Hard to choose between v1.2 development and 1.1.75.
+	      Bottom-half doesn't work with 1.2...
+	      0.25a: fixed... typo. Still problems...
+  1 apr 1995: 0.26 Module support added. Most bugs found. Use kernel 1.2.n.
+  5 apr 1995: 0.27 Auto-probe for the adapter card base address.
+              Auto-probe for the adaptor card irq line.
+  7 apr 1995: 0.28 Added lilo setup support for base address and irq.
+              Use major number 32 (not in this source), officially
+	      assigned to this driver.
+  9 apr 1995: 0.29 Added very limited audio support. Toc_header, stop, pause,
+              resume, eject. Play_track ignores track info, because we can't 
+	      read a table-of-contents entry. Toc_entry is implemented
+	      as a `placebo' function: always returns start of disc. 
+  3 may 1995: 0.30 Audio support completed. The get_toc_entry function
+              is implemented as a binary search. 
+ 15 may 1995: 0.31 More work on audio stuff. Workman is not easy to 
+              satisfy; changed binary search into linear search.
+	      Auto-probe for base address somewhat relaxed.
+  1 jun 1995: 0.32 Removed probe_irq_on/off for module version.
+ 10 jun 1995: 0.33 Workman still behaves funny, but you should be
+              able to eject and substitute another disc.
+
+ An adaptation of 0.33 is included in linux-1.3.7 by Eberhard Moenkeberg
+
+ 18 jul 1995: 0.34 Patch by Heiko Eissfeldt included, mainly considering 
+              verify_area's in the ioctls. Some bugs introduced by 
+	      EM considering the base port and irq fixed. 
+
+ 18 dec 1995: 0.35 Add some code for error checking... no luck...
+
+ We jump to reach our goal: version 1.0 in the next stable linux kernel.
+
+ 19 mar 1996: 0.95 Different implementation of CDROM_GET_UPC, on
+	      request of Thomas Quinot. 
+ 25 mar 1996: 0.96 Interpretation of opening with O_WRONLY or O_RDWR:
+	      open only for ioctl operation, e.g., for operation of
+	      tray etc.
+ 4 apr 1996:  0.97 First implementation of layer between VFS and cdrom
+              driver, a generic interface. Much of the functionality
+	      of cm206_open() and cm206_ioctl() is transferred to a
+	      new file cdrom.c and its header ucdrom.h. 
+
+	      Upgrade to Linux kernel 1.3.78. 
+
+ 11 apr 1996  0.98 Upgrade to Linux kernel 1.3.85
+              Made it more uniform.
+ * 
+ * Parts of the code are based upon lmscd.c written by Kai Petzke,
+ * sbpcd.c written by Eberhard Moenkeberg, and mcd.c by Martin
+ * Harriss, but any off-the-shelf dynamic programming algorithm won't
+ * be able to find them.
+ *
+ * The cm206 drive interface and the cm260 adapter card seem to be 
+ * sufficiently different from their cm205/cm250 counterparts
+ * in order to write a complete new driver.
+ * 
+ * I call all routines connected to the Linux kernel something
+ * with `cm206' in it, as this stuff is too series-dependent. 
+ * 
+ * Currently, my limited knowledge is based on:
+ * - The Linux Kernel Hacker's guide, v. 0.5, by Michael K. Johnson
+ * - Linux Kernel Programmierung, by Michael Beck and others
+ * - Philips/LMS cm206 and cm226 product specification
+ * - Philips/LMS cm260 product specification
+ *
+ *                       David van Leeuwen, david@tm.tno.nl.  */
+#define VERSION "$Id: cm206.c,v 0.99.1.1 1996/08/11 10:35:01 david Exp $"
+
+#include <linux/module.h>	
+
+#include <linux/errno.h>	/* These include what we really need */
+#include <linux/delay.h>
+#include <linux/string.h>
+#include <linux/sched.h>
+#include <linux/interrupt.h>
+#include <linux/timer.h>
+#include <linux/cdrom.h>
+#include <linux/ioport.h>
+#include <linux/mm.h>
+#include <linux/malloc.h>
+
+#include <linux/ucdrom.h>
+
+#include <asm/io.h>
+
+#define MAJOR_NR CM206_CDROM_MAJOR
+#include <linux/blk.h>
+
+#undef DEBUG
+#define STATISTICS		/* record times and frequencies of events */
+#undef AUTO_PROBE_MODULE
+#define USE_INSW
+
+#include <linux/cm206.h>
+
+/* This variable defines whether or not to probe for adapter base port 
+   address and interrupt request. It can be overridden by the boot 
+   parameter `auto'.
+*/
+static int auto_probe=1;	/* Yes, why not? */
+
+static int cm206_base = CM206_BASE;
+static int cm206_irq = CM206_IRQ; 
+
+#define POLLOOP 10000
+#define READ_AHEAD 1		/* defines private buffer, waste! */
+#define BACK_AHEAD 1		/* defines adapter-read ahead */
+#define DATA_TIMEOUT (3*HZ)	/* measured in jiffies (10 ms) */
+#define UART_TIMEOUT (5*HZ/100)
+#define DSB_TIMEOUT (7*HZ)	/* time for the slowest command to finish */
+
+#define LINUX_BLOCK_SIZE 512	/* WHERE is this defined? */
+#define RAW_SECTOR_SIZE 2352	/* ok, is also defined in cdrom.h */
+#define ISO_SECTOR_SIZE 2048
+#define BLOCKS_ISO (ISO_SECTOR_SIZE/LINUX_BLOCK_SIZE) /* 4 */
+#define CD_SYNC_HEAD 16		/* CD_SYNC + CD_HEAD */
+
+#ifdef STATISTICS		/* keep track of errors in counters */
+#define stats(i) { ++cd->stats[st_ ## i]; \
+		     cd->last_stat[st_ ## i] = cd->stat_counter++; \
+		 }
+#else
+#define stats(i) (void) 0
+#endif
+
+#ifdef DEBUG			/* from lmscd.c */
+#define debug(a) printk a
+#else
+#define debug(a) (void) 0
+#endif
+
+typedef unsigned char uch;	/* 8-bits */
+typedef unsigned short ush;	/* 16-bits */
+
+struct toc_struct{		/* private copy of Table of Contents */
+  uch track, fsm[3], q0;
+};
+
+struct cm206_struct {
+  ush intr_ds;	 /* data status read on last interrupt */
+  ush intr_ls;	 /* uart line status read on last interrupt*/
+  uch intr_ur;			/* uart receive buffer */
+  uch dsb, cc;	 /* drive status byte and condition (error) code */
+  uch fool;
+  int command;			/* command to be written to the uart */
+  int openfiles;
+  ush sector[READ_AHEAD*RAW_SECTOR_SIZE/2]; /* buffered cd-sector */
+  int sector_first, sector_last;	/* range of these sector */
+  struct wait_queue * uart;	/* wait for interrupt */
+  struct wait_queue * data;
+  struct timer_list timer;	/* time-out */
+  char timed_out;
+  signed char max_sectors;
+  char wait_back;		/* we're waiting for a background-read */
+  char background;		/* is a read going on in the background? */
+  int adapter_first;		/* if so, that's the starting sector */
+  int adapter_last;
+  char fifo_overflowed;
+  uch disc_status[7];		/* result of get_disc_status command */
+#ifdef STATISTICS
+  int stats[NR_STATS];
+  int last_stat[NR_STATS];	/* `time' at which stat was stat */
+  int stat_counter;
+#endif  
+  struct toc_struct toc[101];	/* The whole table of contents + lead-out */
+  uch q[10];			/* Last read q-channel info */
+  uch audio_status[5];		/* last read position on pause */
+  uch media_changed;		/* record if media changed */
+};
+
+#define DISC_STATUS cd->disc_status[0]
+#define FIRST_TRACK cd->disc_status[1]
+#define LAST_TRACK cd->disc_status[2]
+#define PAUSED cd->audio_status[0] /* misuse this memory byte! */
+#define PLAY_TO cd->toc[0]	/* toc[0] records end-time in play */
+
+static struct cm206_struct * cd; /* the main memory structure */
+
+/* First, we define some polling functions. These are actually
+   only being used in the initialization. */
+
+void send_command_polled(int command)
+{
+  int loop=POLLOOP;
+  while (!(inw(r_line_status) & ls_transmitter_buffer_empty) && loop>0) 
+    --loop;
+  outw(command, r_uart_transmit);
+}
+
+uch receive_echo_polled(void)
+{
+  int loop=POLLOOP;
+  while (!(inw(r_line_status) & ls_receive_buffer_full) && loop>0) --loop;
+  return ((uch) inw(r_uart_receive));
+}
+
+uch send_receive_polled(int command)
+{
+  send_command_polled(command);
+  return receive_echo_polled();
+}
+
+/* The interrupt handler. When the cm260 generates an interrupt, very
+   much care has to be taken in reading out the registers in the right
+   order; in case of a receive_buffer_full interrupt, first the
+   uart_receive must be read, and then the line status again to
+   de-assert the interrupt line. It took me a couple of hours to find
+   this out:-( 
+
+   The function reset_cm206 appears to cause an interrupt, because
+   pulling up the INIT line clears both the uart-write-buffer /and/
+   the uart-write-buffer-empty mask. We call this a `lost interrupt,'
+   as there seems so reason for this to happen.
+*/
+
+static void cm206_interrupt(int sig, void *dev_id, struct pt_regs * regs) 
+/* you rang? */
+{
+  volatile ush fool;
+  cd->intr_ds = inw(r_data_status); /* resets data_ready, data_error,
+				       crc_error, sync_error, toc_ready 
+				       interrupts */
+  cd->intr_ls = inw(r_line_status); /* resets overrun bit */
+  if (cd->intr_ls & ls_attention) stats(attention);
+  /* receive buffer full? */
+  if (cd->intr_ls & ls_receive_buffer_full) {	
+    cd->intr_ur = inb(r_uart_receive); /* get order right! */
+    cd->intr_ls = inw(r_line_status); /* resets rbf interrupt */
+    if (!cd->background && cd->uart) wake_up_interruptible(&cd->uart);
+  }
+  /* data ready in fifo? */
+  else if (cd->intr_ds & ds_data_ready) { 
+    if (cd->background) ++cd->adapter_last;
+    if ((cd->wait_back || !cd->background) && cd->data) 
+      wake_up_interruptible(&cd->data);
+    stats(data_ready);
+  }
+  /* ready to issue a write command? */
+  else if (cd->command && cd->intr_ls & ls_transmitter_buffer_empty) {
+    outw(dc_normal | (inw(r_data_status) & 0x7f), r_data_control);
+    outw(cd->command, r_uart_transmit);
+    cd->command=0;
+    if (!cd->background) wake_up_interruptible(&cd->uart);
+  }
+  /* now treat errors (at least, identify them for debugging) */
+  else if (cd->intr_ds & ds_fifo_overflow) {
+    debug(("Fifo overflow at sectors 0x%x\n", cd->sector_first));
+    fool = inw(r_fifo_output_buffer);	/* de-assert the interrupt */
+    cd->fifo_overflowed=1;	/* signal one word less should be read */
+    stats(fifo_overflow);
+  }
+  else if (cd->intr_ds & ds_data_error) {
+    debug(("Data error at sector 0x%x\n", cd->sector_first));
+    stats(data_error);
+  }
+  else if (cd->intr_ds & ds_crc_error) {
+    debug(("CRC error at sector 0x%x\n", cd->sector_first));
+    stats(crc_error);
+  }
+  else if (cd->intr_ds & ds_sync_error) {
+    debug(("Sync at sector 0x%x\n", cd->sector_first));
+    stats(sync_error);
+  }
+  else if (cd->intr_ds & ds_toc_ready) {
+    /* do something appropriate */
+  }
+  /* couldn't see why this interrupt, maybe due to init */
+  else {			
+    outw(dc_normal | READ_AHEAD, r_data_control);
+    stats(lost_intr);
+  }
+  if (cd->background && (cd->adapter_last-cd->adapter_first == cd->max_sectors
+			 || cd->fifo_overflowed))
+    mark_bh(CM206_BH);	/* issue a stop read command */
+  stats(interrupt);
+}
+
+/* we have put the address of the wait queue in who */
+void cm206_timeout(unsigned long who)
+{
+  cd->timed_out = 1;
+  wake_up_interruptible((struct wait_queue **) who);
+}
+
+/* This function returns 1 if a timeout occurred, 0 if an interrupt
+   happened */
+int sleep_or_timeout(struct wait_queue ** wait, int timeout)
+{
+  cd->timer.data=(unsigned long) wait;
+  cd->timer.expires = jiffies + timeout;
+  add_timer(&cd->timer);
+  interruptible_sleep_on(wait);
+  del_timer(&cd->timer);
+  if (cd->timed_out) {
+    cd->timed_out = 0;
+    return 1;
+  }
+  else return 0;
+}
+
+void cm206_delay(int jiffies) 
+{
+  struct wait_queue * wait = NULL;
+  sleep_or_timeout(&wait, jiffies);
+}
+
+void send_command(int command)
+{
+  if (!(inw(r_line_status) & ls_transmitter_buffer_empty)) {
+    cd->command = command;
+    cli();			/* don't interrupt before sleep */
+    outw(dc_mask_sync_error | dc_no_stop_on_error | 
+	 (inw(r_data_status) & 0x7f), r_data_control);
+    /* interrupt routine sends command */
+    if (sleep_or_timeout(&cd->uart, UART_TIMEOUT)) {
+      debug(("Time out on write-buffer\n"));
+      stats(write_timeout);
+      outw(command, r_uart_transmit);
+    }
+  }
+  else outw(command, r_uart_transmit);
+}
+
+uch receive_echo(void)
+{
+  if (!(inw(r_line_status) & ls_receive_buffer_full) &&
+      sleep_or_timeout(&cd->uart, UART_TIMEOUT)) {
+    debug(("Time out on receive-buffer\n"));
+    stats(receive_timeout);
+    return ((uch) inw(r_uart_receive));
+  }
+  return cd->intr_ur;
+}
+
+inline uch send_receive(int command)
+{
+  send_command(command);
+  return receive_echo();
+}
+
+uch wait_dsb(void)
+{
+  if (!(inw(r_line_status) & ls_receive_buffer_full) &&
+      sleep_or_timeout(&cd->uart, DSB_TIMEOUT)) {
+    debug(("Time out on Drive Status Byte\n"));
+    stats(dsb_timeout);
+    return ((uch) inw(r_uart_receive));
+  }
+  return cd->intr_ur;
+}
+
+int type_0_command(int command, int expect_dsb)
+{
+  int e;
+  if (command != (e=send_receive(command))) {
+    debug(("command 0x%x echoed as 0x%x\n", command, e));
+    stats(echo);
+    return -1;
+  }
+  if (expect_dsb) {
+    cd->dsb = wait_dsb();	/* wait for command to finish */
+  }
+  return 0;
+}
+
+int type_1_command(int command, int bytes, uch * status) /* returns info */
+{
+  int i;
+  if (type_0_command(command,0)) return -1;
+  for(i=0; i<bytes; i++) 
+    status[i] = send_receive(c_gimme);
+  return 0;
+}  
+
+/* This function resets the adapter card. We'd better not do this too */
+/* often, because it tends to generate `lost interrupts.' */
+void reset_cm260(void)
+{
+  outw(dc_normal | dc_initialize | READ_AHEAD, r_data_control);
+  udelay(10);			/* 3.3 mu sec minimum */
+  outw(dc_normal | READ_AHEAD, r_data_control);
+}
+
+/* fsm: frame-sec-min from linear address */
+void fsm(int lba, uch * fsm) 
+{
+  fsm[0] = lba % 75;
+  lba /= 75; lba += 2;
+  fsm[1] = lba % 60; fsm[2] = lba / 60;
+}
+
+inline int fsm2lba(uch * fsm) 
+{
+  return fsm[0] + 75*(fsm[1]-2 + 60*fsm[2]);
+}
+
+inline int f_s_m2lba(uch f, uch s, uch m)
+{
+  return f + 75*(s-2 + 60*m);
+}
+
+int start_read(int start) 
+{
+  uch read_sector[4] = {c_read_data, };
+  int i, e;
+
+  fsm(start, &read_sector[1]);
+  for (i=0; i<4; i++) 
+    if (read_sector[i] != (e=send_receive(read_sector[i]))) {
+      debug(("read_sector: %x echoes %x\n", read_sector[i], e));
+      stats(echo);
+      return -1;
+    }
+  return 0;
+}
+
+int stop_read(void)
+{
+  type_0_command(c_stop,0);
+  if(receive_echo() != 0xff) {
+    debug(("c_stop didn't send 0xff\n"));
+    stats(stop_0xff);
+    return -1;
+  }
+  return 0;
+}  
+
+/* This function starts to read sectors in adapter memory, the
+   interrupt routine should stop the read. In fact, the bottom_half
+   routine takes care of this. Set a flag `background' in the cd
+   struct to indicate the process. */
+
+int read_background(int start, int reading)
+{
+  if (cd->background) return -1; /* can't do twice */
+  outw(dc_normal | BACK_AHEAD, r_data_control);
+  if (!reading && start_read(start)) return -2;
+  cd->adapter_first = cd->adapter_last = start; 
+  cd->background = 1;		/* flag a read is going on */
+  return 0;
+}
+
+#ifdef USE_INSW
+#define transport_data insw
+#else
+/* this routine implements insw(,,). There was a time i had the
+   impression that there would be any difference in error-behaviour. */
+void transport_data(int port, ush * dest, int count) 
+{
+  int i;
+  ush * d;
+  for (i=0, d=dest; i<count; i++, d++) 
+    *d = inw(port);
+}
+#endif
+
+int read_sector(int start)
+{
+  if (cd->background) {
+    cd->background=0;
+    cd->adapter_last = -1;	/* invalidate adapter memory */
+    stop_read();
+  }
+  cd->fifo_overflowed=0;
+  reset_cm260();		/* empty fifo etc. */
+  if (start_read(start)) return -1;
+  if (sleep_or_timeout(&cd->data, DATA_TIMEOUT)) {
+    debug(("Read timed out sector 0x%x\n", start));
+    stats(read_timeout);
+    stop_read();
+    return -3;		
+  }
+  transport_data(r_fifo_output_buffer, cd->sector, 
+		 READ_AHEAD*RAW_SECTOR_SIZE/2);
+  if (read_background(start+READ_AHEAD,1)) stats(read_background);
+  cd->sector_first = start; cd->sector_last = start+READ_AHEAD;
+  stats(read_restarted);
+  return 0;
+}
+
+/* The function of bottom-half is to send a stop command to the drive
+   This isn't easy because the routine is not `owned' by any process;
+   we can't go to sleep! The variable cd->background gives the status:
+   0 no read pending
+   1 a read is pending
+   2 c_stop waits for write_buffer_empty
+   3 c_stop waits for receive_buffer_full: echo
+   4 c_stop waits for receive_buffer_full: 0xff
+*/
+
+void cm206_bh(void)
+{
+  debug(("bh: %d\n", cd->background));
+  switch (cd->background) {
+  case 1:
+    stats(bh);
+    if (!(cd->intr_ls & ls_transmitter_buffer_empty)) {
+      cd->command = c_stop;
+      outw(dc_mask_sync_error | dc_no_stop_on_error | 
+	   (inw(r_data_status) & 0x7f), r_data_control);
+      cd->background=2;
+      break;			/* we'd better not time-out here! */
+    }
+    else outw(c_stop, r_uart_transmit);
+    /* fall into case 2: */
+  case 2:			
+    /* the write has been satisfied by interrupt routine */
+    cd->background=3;
+    break;
+  case 3:
+    if (cd->intr_ur != c_stop) {
+      debug(("cm206_bh: c_stop echoed 0x%x\n", cd->intr_ur));
+      stats(echo);
+    }
+    cd->background++;
+    break;
+  case 4:
+    if (cd->intr_ur != 0xff) {
+      debug(("cm206_bh: c_stop reacted with 0x%x\n", cd->intr_ur));
+      stats(stop_0xff);
+    }
+    cd->background=0;
+  }
+}
+
+/* This command clears the dsb_possible_media_change flag, so we must 
+ * retain it.
+ */
+void get_drive_status(void)
+{
+  uch status[2];
+  type_1_command(c_drive_status, 2, status); /* this might be done faster */
+  cd->dsb=status[0];
+  cd->cc=status[1];
+  cd->media_changed |= 
+    !!(cd->dsb & (dsb_possible_media_change | 
+		  dsb_drive_not_ready | dsb_tray_not_closed));
+}
+
+void get_disc_status(void)
+{
+  if (type_1_command(c_disc_status, 7, cd->disc_status)) {
+    debug(("get_disc_status: error\n"));
+  }
+}
+
+/* The new open. The real opening strategy is defined in cdrom.c. */
+
+static int cm206_open(struct cdrom_device_info *i, int purpose) 
+{
+  if (!cd->openfiles) {		/* reset only first time */
+    cd->background=0;
+    reset_cm260();
+    cd->adapter_last = -1;	/* invalidate adapter memory */
+    cd->sector_last = -1;
+  }
+  ++cd->openfiles; MOD_INC_USE_COUNT;
+  stats(open);
+  return 0;
+}
+
+static void cm206_release(struct cdrom_device_info *i)
+{
+  if (cd->openfiles==1) {
+    if (cd->background) {
+      cd->background=0;
+      stop_read();
+    }
+    cd->sector_last = -1;	/* Make our internal buffer invalid */
+    FIRST_TRACK = 0;		/* No valid disc status */
+  }
+  --cd->openfiles; MOD_DEC_USE_COUNT;
+}
+
+/* Empty buffer empties $sectors$ sectors of the adapter card buffer,
+ * and then reads a sector in kernel memory.  */
+void empty_buffer(int sectors) 
+{
+  while (sectors>=0) {
+    transport_data(r_fifo_output_buffer, cd->sector + cd->fifo_overflowed, 
+	 RAW_SECTOR_SIZE/2 - cd->fifo_overflowed);
+    --sectors;
+    ++cd->adapter_first;	/* update the current adapter sector */
+    cd->fifo_overflowed=0;	/* reset overflow bit */
+    stats(sector_transferred);
+  } 
+  cd->sector_first=cd->adapter_first-1;
+  cd->sector_last=cd->adapter_first; /* update the buffer sector */
+}
+
+/* try_adapter. This function determines if the requested sector is
+   in adapter memory, or will appear there soon. Returns 0 upon
+   success */
+int try_adapter(int sector)
+{
+  if (cd->adapter_first <= sector && sector < cd->adapter_last) { 
+    /* sector is in adapter memory */
+    empty_buffer(sector - cd->adapter_first);
+    return 0;
+  }
+  else if (cd->background==1 && cd->adapter_first <= sector
+	   && sector < cd->adapter_first+cd->max_sectors) {
+    /* a read is going on, we can wait for it */
+    cd->wait_back=1;
+    while (sector >= cd->adapter_last) {
+      if (sleep_or_timeout(&cd->data, DATA_TIMEOUT)) {
+	debug(("Timed out during background wait: %d %d %d %d\n", sector, 
+	       cd->adapter_last, cd->adapter_first, cd->background));
+	stats(back_read_timeout);
+	cd->wait_back=0;
+	return -1;
+      }
+    }
+    cd->wait_back=0;
+    empty_buffer(sector - cd->adapter_first);
+    return 0;
+  }
+  else return -2;
+}
+
+/* This is not a very smart implementation. We could optimize for 
+   consecutive block numbers. I'm not convinced this would really
+   bring down the processor load. */
+static void do_cm206_request(void)
+{
+  long int i, cd_sec_no;
+  int quarter, error; 
+  uch * source, * dest;
+  
+  while(1) {	 /* repeat until all requests have been satisfied */
+    INIT_REQUEST;
+    if (CURRENT == NULL || CURRENT->rq_status == RQ_INACTIVE)
+      return;
+    if (CURRENT->cmd != READ) {
+      debug(("Non-read command %d on cdrom\n", CURRENT->cmd));
+      end_request(0);
+      continue;
+    }
+    error=0;
+    for (i=0; i<CURRENT->nr_sectors; i++) {
+      cd_sec_no = (CURRENT->sector+i)/BLOCKS_ISO; /* 4 times 512 bytes */
+      quarter = (CURRENT->sector+i) % BLOCKS_ISO; 
+      dest = CURRENT->buffer + i*LINUX_BLOCK_SIZE;
+      /* is already in buffer memory? */
+      if (cd->sector_first <= cd_sec_no && cd_sec_no < cd->sector_last) {
+	source = ((uch *) cd->sector) + 16 + quarter*LINUX_BLOCK_SIZE 
+	  + (cd_sec_no-cd->sector_first)*RAW_SECTOR_SIZE;
+ 	memcpy(dest, source, LINUX_BLOCK_SIZE); 
+      }
+      else if (!try_adapter(cd_sec_no) || !read_sector(cd_sec_no)) {
+	source =  ((uch *) cd->sector)+16+quarter*LINUX_BLOCK_SIZE;
+	memcpy(dest, source, LINUX_BLOCK_SIZE); 
+      }
+      else {
+	error=1;
+      }
+    }
+    end_request(!error);
+  }
+}
+
+/* Audio support. I've tried very hard, but the cm206 drive doesn't 
+   seem to have a get_toc (table-of-contents) function, while i'm
+   pretty sure it must read the toc upon disc insertion. Therefore
+   this function has been implemented through a binary search 
+   strategy. All track starts that happen to be found are stored in
+   cd->toc[], for future use. 
+
+   I've spent a whole day on a bug that only shows under Workman---
+   I don't get it. Tried everything, nothing works. If workman asks
+   for track# 0xaa, it'll get the wrong time back. Any other program
+   receives the correct value. I'm stymied.
+*/
+
+/* seek seeks to address lba. It does wait to arrive there. */
+void seek(int lba)
+{
+  int i;
+  uch seek_command[4]={c_seek, };
+  
+  fsm(lba, &seek_command[1]);
+  for (i=0; i<4; i++) type_0_command(seek_command[i], 0);
+  cd->dsb = wait_dsb();
+}
+
+uch bcdbin(unsigned char bcd)	/* stolen from mcd.c! */
+{
+  return (bcd >> 4)*10 + (bcd & 0xf);
+} 
+
+inline uch normalize_track(uch track) 
+{
+  if (track<1) return 1;
+  if (track>LAST_TRACK) return LAST_TRACK+1;
+  return track;
+}
+
+/* This function does a binary search for track start. It records all
+ * tracks seen in the process. Input $track$ must be between 1 and
+ * #-of-tracks+1 */
+int get_toc_lba(uch track)
+{
+  int max=74*60*75-150, min=0;
+  int i, lba, l, old_lba=0;
+  uch * q = cd->q;
+  uch ct;			/* current track */
+  int binary=0;
+  const skip = 3*60*75;
+
+  for (i=track; i>0; i--) if (cd->toc[i].track) {
+    min = fsm2lba(cd->toc[i].fsm);
+    break;
+  }
+  lba = min + skip;		/* 3 minutes */
+  do {
+    seek(lba); 
+    type_1_command(c_read_current_q, 10, q);
+    ct = normalize_track(q[1]);
+    if (!cd->toc[ct].track) {
+      l = q[9]-bcdbin(q[5]) + 75*(q[8]-bcdbin(q[4])-2 + 
+				  60*(q[7]-bcdbin(q[3])));
+      cd->toc[ct].track=q[1];	/* lead out still 0xaa */
+      fsm(l, cd->toc[ct].fsm);
+      cd->toc[ct].q0 = q[0];	/* contains adr and ctrl info */
+      if (ct==track) return l;
+    }
+    old_lba=lba;
+    if (binary) {
+      if (ct < track) min = lba; else max = lba;
+      lba = (min+max)/2; 
+    } else {
+      if(ct < track) lba += skip;
+      else {
+	binary=1;
+	max = lba; min = lba - skip;
+	lba = (min+max)/2;
+      }
+    }
+  } while (lba!=old_lba);
+  return lba;
+}
+
+void update_toc_entry(uch track) 
+{
+  track = normalize_track(track);
+  if (!cd->toc[track].track) get_toc_lba(track);
+}
+
+/* return 0 upon success */
+int read_toc_header(struct cdrom_tochdr * hp)
+{
+  if (!FIRST_TRACK) get_disc_status();
+  if (hp && DISC_STATUS & cds_all_audio) { /* all audio */
+    int i;
+    hp->cdth_trk0 = FIRST_TRACK;
+    hp->cdth_trk1 = LAST_TRACK;
+    cd->toc[1].track=1;		/* fill in first track position */
+    for (i=0; i<3; i++) cd->toc[1].fsm[i] = cd->disc_status[3+i];
+    update_toc_entry(LAST_TRACK+1);		/* find most entries */
+    return 0;
+  }
+  return -1;
+}  
+
+void play_from_to_msf(struct cdrom_msf* msfp)
+{
+  uch play_command[] = {c_play, 
+	   msfp->cdmsf_frame0, msfp->cdmsf_sec0, msfp->cdmsf_min0,
+	   msfp->cdmsf_frame1, msfp->cdmsf_sec1, msfp->cdmsf_min1, 2, 2};
+  int i;
+  for (i=0; i<9; i++) type_0_command(play_command[i], 0);
+  for (i=0; i<3; i++) 
+    PLAY_TO.fsm[i] = play_command[i+4];
+  PLAY_TO.track = 0;		/* say no track end */
+  cd->dsb = wait_dsb();
+}  
+
+void play_from_to_track(int from, int to)
+{
+  uch play_command[8] = {c_play, };
+  int i;
+
+  if (from==0) {		/* continue paused play */
+    for (i=0; i<3; i++) { 
+      play_command[i+1] = cd->audio_status[i+2];
+      play_command[i+4] = PLAY_TO.fsm[i];
+    }
+  } else {
+    update_toc_entry(from); update_toc_entry(to+1);
+    for (i=0; i<3; i++) {
+      play_command[i+1] = cd->toc[from].fsm[i];
+      PLAY_TO.fsm[i] = play_command[i+4] = cd->toc[to+1].fsm[i];
+    }
+    PLAY_TO.track = to; 
+  }
+  for (i=0; i<7; i++) type_0_command(play_command[i],0);
+  for (i=0; i<2; i++) type_0_command(0x2, 0); /* volume */
+  cd->dsb = wait_dsb();
+}
+
+int get_current_q(struct cdrom_subchnl * qp)
+{
+  int i;
+  uch * q = cd->q;
+  if (type_1_command(c_read_current_q, 10, q)) return 0;
+/*  q[0] = bcdbin(q[0]); Don't think so! */
+  for (i=2; i<6; i++) q[i]=bcdbin(q[i]); 
+  qp->cdsc_adr = q[0] & 0xf; qp->cdsc_ctrl = q[0] >> 4;	/* from mcd.c */
+  qp->cdsc_trk = q[1];  qp->cdsc_ind = q[2];
+  if (qp->cdsc_format == CDROM_MSF) {
+    qp->cdsc_reladdr.msf.minute = q[3];
+    qp->cdsc_reladdr.msf.second = q[4];
+    qp->cdsc_reladdr.msf.frame = q[5];
+    qp->cdsc_absaddr.msf.minute = q[7];
+    qp->cdsc_absaddr.msf.second = q[8];
+    qp->cdsc_absaddr.msf.frame = q[9];
+  } else {
+    qp->cdsc_reladdr.lba = f_s_m2lba(q[5], q[4], q[3]);
+    qp->cdsc_absaddr.lba = f_s_m2lba(q[9], q[8], q[7]);
+  }
+  get_drive_status();
+  if (cd->dsb & dsb_play_in_progress) 
+    qp->cdsc_audiostatus = CDROM_AUDIO_PLAY ;
+  else if (PAUSED) 
+    qp->cdsc_audiostatus = CDROM_AUDIO_PAUSED;
+  else qp->cdsc_audiostatus = CDROM_AUDIO_NO_STATUS;
+  return 0;
+}
+
+void invalidate_toc(void)
+{
+  memset(cd->toc, 0, sizeof(cd->toc));
+  memset(cd->disc_status, 0, sizeof(cd->disc_status));
+}
+
+/* cdrom.c guarantees that cdte_format == CDROM_MSF */
+void get_toc_entry(struct cdrom_tocentry * ep)
+{
+  uch track = normalize_track(ep->cdte_track);
+  update_toc_entry(track);
+  ep->cdte_addr.msf.frame = cd->toc[track].fsm[0];
+  ep->cdte_addr.msf.second = cd->toc[track].fsm[1];
+  ep->cdte_addr.msf.minute = cd->toc[track].fsm[2];
+  ep->cdte_adr = cd->toc[track].q0 & 0xf; 
+  ep->cdte_ctrl = cd->toc[track].q0 >> 4;
+  ep->cdte_datamode=0;
+}
+
+/* Audio ioctl.  Ioctl commands connected to audio are in such an
+ * idiosyncratic i/o format, that we leave these untouched. Return 0
+ * upon success. Memory checking has been done by cdrom_ioctl(), the
+ * calling function, as well as LBA/MSF sanitization.
+*/
+int cm206_audio_ioctl(struct cdrom_device_info *i, unsigned int cmd, void * arg)
+{
+  switch (cmd) {
+  case CDROMREADTOCHDR: 
+    return read_toc_header((struct cdrom_tochdr *) arg);
+  case CDROMREADTOCENTRY: 	
+    get_toc_entry((struct cdrom_tocentry *) arg);
+    return 0;
+  case CDROMPLAYMSF: 
+    play_from_to_msf((struct cdrom_msf *) arg);
+    return 0;
+  case CDROMPLAYTRKIND:		/* admittedly, not particularly beautiful */
+    play_from_to_track(((struct cdrom_ti *)arg)->cdti_trk0, 
+		       ((struct cdrom_ti *)arg)->cdti_trk1);
+    return 0;
+  case CDROMSTOP: 
+    PAUSED=0;
+    if (cd->dsb & dsb_play_in_progress) return type_0_command(c_stop, 1);
+    else return 0;
+  case CDROMPAUSE: 
+    get_drive_status();
+    if (cd->dsb & dsb_play_in_progress) {
+      type_0_command(c_stop, 1);
+      type_1_command(c_audio_status, 5, cd->audio_status);
+      PAUSED=1;	/* say we're paused */
+    }
+    return 0;
+  case CDROMRESUME:
+    if (PAUSED) play_from_to_track(0,0);
+    PAUSED=0;
+    return 0;
+  case CDROMSTART:
+  case CDROMVOLCTRL:
+    return 0;
+  case CDROMSUBCHNL: 
+    return get_current_q((struct cdrom_subchnl *)arg);
+  default:
+    return -EINVAL;
+  }
+}
+
+/* Ioctl. These ioctls are specific to the cm206 driver. I have made
+   some driver statistics accessible through ioctl calls.
+ */
+
+static int cm206_ioctl(struct cdrom_device_info *i, unsigned int cmd, unsigned long arg)
+{
+  switch (cmd) {
+#ifdef STATISTICS
+  case CM206CTL_GET_STAT:
+    if (arg >= NR_STATS) return -EINVAL;
+    else return cd->stats[arg];
+  case CM206CTL_GET_LAST_STAT:
+    if (arg >= NR_STATS) return -EINVAL;
+    else return cd->last_stat[arg];
+#endif    
+  default:
+    debug(("Unknown ioctl call 0x%x\n", cmd));
+    return -EINVAL;
+  }
+}     
+
+int cm206_media_changed(struct cdrom_device_info *i, int n) 
+{
+  if (cd != NULL) {
+    int r;
+    get_drive_status();		/* ensure cd->media_changed OK */
+    r = cd->media_changed;
+    cd->media_changed = 0;	/* clear bit */
+    return r;
+  }
+  else return -EIO;
+}
+
+/* The new generic cdrom support. Routines should be concise, most of
+   the logic should be in cdrom.c */
+
+/* returns number of times device is in use */
+int cm206_open_files(struct cdrom_device_info *i)	
+{
+  if (cd) return cd->openfiles;
+  return -1;
+}
+
+/* controls tray movement */
+int cm206_tray_move(struct cdrom_device_info *i, int position) 
+{
+  if (position) {		/* 1: eject */
+    type_0_command(c_open_tray,1);
+    invalidate_toc();
+  } 
+  else type_0_command(c_close_tray, 1);	/* 0: close */
+  return 0;
+}
+
+/* gives current state of the drive */
+int cm206_drive_status(struct cdrom_device_info *i, int n)
+{
+  get_drive_status();
+  if (cd->dsb & dsb_tray_not_closed) return CDS_TRAY_OPEN;
+  if (!(cd->dsb & dsb_disc_present)) return CDS_NO_DISC; 
+  if (cd->dsb & dsb_drive_not_ready) return CDS_DRIVE_NOT_READY;
+  return CDS_DISC_OK;
+}
+ 
+/* gives current state of disc in drive */
+int cm206_disc_status(struct cdrom_device_info *i)
+{
+  uch xa;
+  get_drive_status();
+  if ((cd->dsb & dsb_not_useful) | !(cd->dsb & dsb_disc_present))
+    return CDS_NO_DISC;
+  get_disc_status();
+  if (DISC_STATUS & cds_all_audio) return CDS_AUDIO;
+  xa = DISC_STATUS >> 4;
+  switch (xa) {
+  case 0: return CDS_DATA_1;	/* can we detect CDS_DATA_2? */
+  case 1: return CDS_XA_2_1;	/* untested */
+  case 2: return CDS_XA_2_2;
+  }
+  return 0;
+}
+
+/* locks or unlocks door lock==1: lock; return 0 upon success */
+int cm206_lock_door(struct cdrom_device_info *i, int lock)
+{
+  uch command = (lock) ? c_lock_tray : c_unlock_tray;
+  type_0_command(command, 1);	/* wait and get dsb */
+  /* the logic calculates the success, 0 means successful */
+  return lock ^ ((cd->dsb & dsb_tray_locked) != 0);
+}
+  
+/* Although a session start should be in LBA format, we return it in 
+   MSF format because it is slightly easier, and the new generic ioctl
+   will take care of the necessary conversion. */
+int cm206_get_last_session(struct cdrom_device_info *i, struct cdrom_multisession * mssp) 
+{
+  if (!FIRST_TRACK) get_disc_status();
+  if (mssp != NULL) {
+    if (DISC_STATUS & cds_multi_session) { /* multi-session */
+      mssp->addr.msf.frame = cd->disc_status[3];
+      mssp->addr.msf.second = cd->disc_status[4];
+      mssp->addr.msf.minute = cd->disc_status[5];
+      mssp->addr_format = CDROM_MSF;
+      mssp->xa_flag = 1;
+    } else {
+      mssp->xa_flag = 0;
+    }
+    return 1;
+  }
+  return 0;
+}
+
+int cm206_get_upc(struct cdrom_device_info *info, struct cdrom_mcn * mcn)
+{
+  uch upc[10];
+  char * ret = mcn->medium_catalog_number;
+  int i;
+  
+  if (type_1_command(c_read_upc, 10, upc)) return -EIO;
+  for (i=0; i<13; i++) {
+    int w=i/2+1, r=i%2;
+    if (r) ret[i] = 0x30 | (upc[w] & 0x0f);
+    else ret[i] = 0x30 | ((upc[w] >> 4) & 0x0f);
+  }
+  ret[13] = '\0';
+  return 0;
+} 
+
+int cm206_reset(struct cdrom_device_info *i)
+{
+  stop_read();
+  reset_cm260();
+  outw(dc_normal | dc_break | READ_AHEAD, r_data_control);
+  udelay(1000);			/* 750 musec minimum */
+  outw(dc_normal | READ_AHEAD, r_data_control);
+  cd->sector_last = -1;		/* flag no data buffered */
+  cd->adapter_last = -1;    
+  invalidate_toc();
+  return 0;
+}
+
+static struct cdrom_device_ops cm206_dops = {
+  cm206_open,			/* open */
+  cm206_release,		/* release */
+  cm206_drive_status,		/* drive status */
+  cm206_disc_status,		/* disc status */
+  cm206_media_changed,		/* media changed */
+  cm206_tray_move,		/* tray move */
+  cm206_lock_door,		/* lock door */
+  NULL,				/* select speed */
+  NULL,				/* select disc */
+  cm206_get_last_session,	/* get last session */
+  cm206_get_upc,		/* get universal product code */
+  cm206_reset,			/* hard reset */
+  cm206_audio_ioctl,		/* audio ioctl */
+  cm206_ioctl,			/* device-specific ioctl */
+  CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_MULTI_SESSION |
+    CDC_MEDIA_CHANGED | CDC_MCN | CDC_PLAY_AUDIO, /* capability */
+  1,				/* number of minor devices */
+};
+
+static struct cdrom_device_info cm206_info= {
+	&cm206_dops,
+	NULL,
+	NULL,
+	CM206_CDROM_MAJOR,
+	CDC_CLOSE_TRAY | CDC_OPEN_TRAY | CDC_LOCK | CDC_MULTI_SESSION |
+		CDC_MEDIA_CHANGED | CDC_MCN | CDC_PLAY_AUDIO, /* capability */
+	2,				/* maximum speed */
+	1,				/* number of discs */
+	0,				/* options, ignored */
+	0,				/* mc_flags, ignored */
+	0
+};
+	
+/* This routine gets called during init if thing go wrong, can be used
+ * in cleanup_module as well. */
+void cleanup(int level)
+{
+  switch (level) {
+  case 4: 
+    if (unregister_cdrom(&cm206_info)) {
+      printk("Can't unregister cdrom cm206\n");
+      return;
+    }
+    if (unregister_blkdev(MAJOR_NR, "cm206")) {
+      printk("Can't unregister major cm206\n");
+      return;
+    }
+  case 3: 
+    free_irq(cm206_irq, NULL);
+  case 2: 
+  case 1: 
+    kfree(cd);
+    release_region(cm206_base, 16);
+  default:
+  }
+}
+
+/* This function probes for the adapter card. It returns the base
+   address if it has found the adapter card. One can specify a base 
+   port to probe specifically, or 0 which means span all possible
+   bases. 
+
+   Linus says it is too dangerous to use writes for probing, so we
+   stick with pure reads for a while. Hope that 8 possible ranges,
+   check_region, 15 bits of one port and 6 of another make things
+   likely enough to accept the region on the first hit...
+ */
+int probe_base_port(int base)
+{
+  int b=0x300, e=0x370;		/* this is the range of start addresses */
+  volatile int fool, i;
+
+  if (base) b=e=base;
+  for (base=b; base<=e; base += 0x10) {
+    if (check_region(base, 0x10)) continue;
+    for (i=0; i<3; i++) 
+      fool = inw(base+2); /* empty possibly uart_receive_buffer */
+    if((inw(base+6) & 0xffef) != 0x0001 || /* line_status */
+       (inw(base) & 0xad00) != 0) /* data status */
+      continue;
+    return(base);
+  }
+  return 0;
+}
+
+#if !defined(MODULE) || defined(AUTO_PROBE_MODULE)
+/* Probe for irq# nr. If nr==0, probe for all possible irq's. */
+int probe_irq(int nr) {
+  int irqs, irq;
+  outw(dc_normal | READ_AHEAD, r_data_control);	/* disable irq-generation */
+  sti(); 
+  irqs = probe_irq_on();
+  reset_cm260();		/* causes interrupt */
+  udelay(100);			/* wait for it */
+  irq = probe_irq_off(irqs);
+  outw(dc_normal | READ_AHEAD, r_data_control);	/* services interrupt */
+  if (nr && irq!=nr && irq>0) return 0;	/* wrong interrupt happened */
+  else return irq;
+}
+#endif
+
+int cm206_init(void)
+{
+  uch e=0;
+  long int size=sizeof(struct cm206_struct);
+
+  printk(KERN_INFO VERSION);
+  cm206_base = probe_base_port(auto_probe ? 0 : cm206_base);
+  if (!cm206_base) {
+    printk(" can't find adapter!\n");
+    return -EIO;
+  }
+  printk(" adapter at 0x%x", cm206_base);
+  request_region(cm206_base, 16, "cm206");
+  cd = (struct cm206_struct *) kmalloc(size, GFP_KERNEL);
+  if (!cd) return -EIO;
+  /* Now we have found the adaptor card, try to reset it. As we have
+   * found out earlier, this process generates an interrupt as well,
+   * so we might just exploit that fact for irq probing! */
+#if !defined(MODULE) || defined(AUTO_PROBE_MODULE)
+  cm206_irq = probe_irq(auto_probe ? 0 : cm206_irq);	
+  if (cm206_irq<=0) {
+    printk("can't find IRQ!\n");
+    cleanup(1);
+    return -EIO;
+  }
+  else printk(" IRQ %d found\n", cm206_irq);
+#else
+  cli();
+  reset_cm260();
+  /* Now, the problem here is that reset_cm260 can generate an
+     interrupt. It seems that this can cause a kernel oops some time
+     later. So we wait a while and `service' this interrupt. */
+  udelay(10);
+  outw(dc_normal | READ_AHEAD, r_data_control);
+  sti();
+  printk(" using IRQ %d\n", cm206_irq);
+#endif
+  if (send_receive_polled(c_drive_configuration) != c_drive_configuration) 
+    {
+      printk(" drive not there\n");
+      cleanup(1);
+      return -EIO;
+    }
+  e = send_receive_polled(c_gimme);
+  printk(KERN_INFO "Firmware revision %d", e & dcf_revision_code);
+  if (e & dcf_transfer_rate) printk(" double");
+  else printk(" single");
+  printk(" speed drive");
+  if (e & dcf_motorized_tray) printk(", motorized tray");
+  if (request_irq(cm206_irq, cm206_interrupt, 0, "cm206", NULL)) {
+    printk("\nUnable to reserve IRQ---aborted\n");
+    cleanup(2);
+    return -EIO;
+  }
+  printk(".\n");
+  if (register_blkdev(MAJOR_NR, "cm206", &cdrom_fops) != 0) {
+    printk("Cannot register for major %d!\n", MAJOR_NR);
+    cleanup(3);
+    return -EIO;
+  }
+  if (register_cdrom(&cm206_info,"cm206") != 0) {
+    printk("Cannot register for cdrom %d!\n", MAJOR_NR);
+    cleanup(3);
+    return -EIO;
+  }    
+  blk_dev[MAJOR_NR].request_fn = DEVICE_REQUEST;
+  read_ahead[MAJOR_NR] = 16;	/* reads ahead what? */
+  init_bh(CM206_BH, cm206_bh);
+
+  memset(cd, 0, sizeof(*cd));	/* give'm some reasonable value */
+  cd->sector_last = -1;		/* flag no data buffered */
+  cd->adapter_last = -1;
+  cd->timer.function = cm206_timeout;
+  cd->max_sectors = (inw(r_data_status) & ds_ram_size) ? 24 : 97;
+  printk(KERN_INFO "%d kB adapter memory available, "  
+	 " %ld bytes kernel memory used.\n", cd->max_sectors*2, size);
+  return 0;
+}
+
+#ifdef MODULE
+
+static int cm206[2] = {0,0};	/* for compatible `insmod' parameter passing */
+
+void parse_options(void) 
+{
+  int i;
+  for (i=0; i<2; i++) {
+    if (0x300 <= cm206[i] && i<= 0x370 && cm206[i] % 0x10 == 0) {
+      cm206_base = cm206[i];
+      auto_probe=0;
+    }
+    else if (3 <= cm206[i] && cm206[i] <= 15) {
+      cm206_irq = cm206[i];
+      auto_probe=0;
+    }
+  }
+}
+
+int init_module(void)
+{
+	parse_options();
+#if !defined(AUTO_PROBE_MODULE)
+	auto_probe=0;
+#endif
+	return cm206_init();
+}
+
+void cleanup_module(void)
+{
+  cleanup(4);
+  printk(KERN_INFO "cm206 removed\n");
+}
+      
+#else /* !MODULE */
+
+/* This setup function accepts either `auto' or numbers in the range
+ * 3--11 (for irq) or 0x300--0x370 (for base port) or both. */
+void cm206_setup(char *s, int *p)
+{
+  int i;
+  if (!strcmp(s, "auto")) auto_probe=1;
+  for(i=1; i<=p[0]; i++) {
+    if (0x300 <= p[i] && i<= 0x370 && p[i] % 0x10 == 0) {
+      cm206_base = p[i];
+      auto_probe = 0;
+    }
+    else if (3 <= p[i] && p[i] <= 15) {
+      cm206_irq = p[i];
+      auto_probe = 0;
+    }
+  }
+}
+#endif /* MODULE */
+/*
+ * Local variables:
+ * compile-command: "gcc -DMODULE -D__KERNEL__ -I/usr/src/linux/include/linux -Wall -Wstrict-prototypes -O2 -m486 -c cm206.c -o cm206.o"
+ * End:
+ */