Linux-2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
diff --git a/drivers/cdrom/optcd.c b/drivers/cdrom/optcd.c
new file mode 100644
index 0000000..7e69c54
--- /dev/null
+++ b/drivers/cdrom/optcd.c
@@ -0,0 +1,2106 @@
+/* linux/drivers/cdrom/optcd.c - Optics Storage 8000 AT CDROM driver
+ $Id: optcd.c,v 1.11 1997/01/26 07:13:00 davem Exp $
+
+ Copyright (C) 1995 Leo Spiekman (spiekman@dutette.et.tudelft.nl)
+
+
+ Based on Aztech CD268 CDROM driver by Werner Zimmermann and preworks
+ by Eberhard Moenkeberg (emoenke@gwdg.de).
+
+ 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, 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.
+*/
+
+/* Revision history
+
+
+ 14-5-95 v0.0 Plays sound tracks. No reading of data CDs yet.
+ Detection of disk change doesn't work.
+ 21-5-95 v0.1 First ALPHA version. CD can be mounted. The
+ device major nr is borrowed from the Aztech
+ driver. Speed is around 240 kb/s, as measured
+ with "time dd if=/dev/cdrom of=/dev/null \
+ bs=2048 count=4096".
+ 24-6-95 v0.2 Reworked the #defines for the command codes
+ and the like, as well as the structure of
+ the hardware communication protocol, to
+ reflect the "official" documentation, kindly
+ supplied by C.K. Tan, Optics Storage Pte. Ltd.
+ Also tidied up the state machine somewhat.
+ 28-6-95 v0.3 Removed the ISP-16 interface code, as this
+ should go into its own driver. The driver now
+ has its own major nr.
+ Disk change detection now seems to work, too.
+ This version became part of the standard
+ kernel as of version 1.3.7
+ 24-9-95 v0.4 Re-inserted ISP-16 interface code which I
+ copied from sjcd.c, with a few changes.
+ Updated README.optcd. Submitted for
+ inclusion in 1.3.21
+ 29-9-95 v0.4a Fixed bug that prevented compilation as module
+ 25-10-95 v0.5 Started multisession code. Implementation
+ copied from Werner Zimmermann, who copied it
+ from Heiko Schlittermann's mcdx.
+ 17-1-96 v0.6 Multisession works; some cleanup too.
+ 18-4-96 v0.7 Increased some timing constants;
+ thanks to Luke McFarlane. Also tidied up some
+ printk behaviour. ISP16 initialization
+ is now handled by a separate driver.
+
+ 09-11-99 Make kernel-parameter implementation work with 2.3.x
+ Removed init_module & cleanup_module in favor of
+ module_init & module_exit.
+ Torben Mathiasen <tmm@image.dk>
+*/
+
+/* Includes */
+
+
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/ioport.h>
+#include <linux/init.h>
+
+#include <asm/io.h>
+#include <linux/blkdev.h>
+
+#include <linux/cdrom.h>
+#include "optcd.h"
+
+#include <asm/uaccess.h>
+
+#define MAJOR_NR OPTICS_CDROM_MAJOR
+#define QUEUE (opt_queue)
+#define CURRENT elv_next_request(opt_queue)
+
+
+/* Debug support */
+
+
+/* Don't forget to add new debug flags here. */
+#if DEBUG_DRIVE_IF | DEBUG_VFS | DEBUG_CONV | DEBUG_TOC | \
+ DEBUG_BUFFERS | DEBUG_REQUEST | DEBUG_STATE | DEBUG_MULTIS
+#define DEBUG(x) debug x
+static void debug(int debug_this, const char* fmt, ...)
+{
+ char s[1024];
+ va_list args;
+
+ if (!debug_this)
+ return;
+
+ va_start(args, fmt);
+ vsprintf(s, fmt, args);
+ printk(KERN_DEBUG "optcd: %s\n", s);
+ va_end(args);
+}
+#else
+#define DEBUG(x)
+#endif
+
+
+/* Drive hardware/firmware characteristics
+ Identifiers in accordance with Optics Storage documentation */
+
+
+#define optcd_port optcd /* Needed for the modutils. */
+static short optcd_port = OPTCD_PORTBASE; /* I/O base of drive. */
+module_param(optcd_port, short, 0);
+/* Drive registers, read */
+#define DATA_PORT optcd_port /* Read data/status */
+#define STATUS_PORT optcd_port+1 /* Indicate data/status availability */
+
+/* Drive registers, write */
+#define COMIN_PORT optcd_port /* For passing command/parameter */
+#define RESET_PORT optcd_port+1 /* Write anything and wait 0.5 sec */
+#define HCON_PORT optcd_port+2 /* Host Xfer Configuration */
+
+
+/* Command completion/status read from DATA register */
+#define ST_DRVERR 0x80
+#define ST_DOOR_OPEN 0x40
+#define ST_MIXEDMODE_DISK 0x20
+#define ST_MODE_BITS 0x1c
+#define ST_M_STOP 0x00
+#define ST_M_READ 0x04
+#define ST_M_AUDIO 0x04
+#define ST_M_PAUSE 0x08
+#define ST_M_INITIAL 0x0c
+#define ST_M_ERROR 0x10
+#define ST_M_OTHERS 0x14
+#define ST_MODE2TRACK 0x02
+#define ST_DSK_CHG 0x01
+#define ST_L_LOCK 0x01
+#define ST_CMD_OK 0x00
+#define ST_OP_OK 0x01
+#define ST_PA_OK 0x02
+#define ST_OP_ERROR 0x05
+#define ST_PA_ERROR 0x06
+
+
+/* Error codes (appear as command completion code from DATA register) */
+/* Player related errors */
+#define ERR_ILLCMD 0x11 /* Illegal command to player module */
+#define ERR_ILLPARM 0x12 /* Illegal parameter to player module */
+#define ERR_SLEDGE 0x13
+#define ERR_FOCUS 0x14
+#define ERR_MOTOR 0x15
+#define ERR_RADIAL 0x16
+#define ERR_PLL 0x17 /* PLL lock error */
+#define ERR_SUB_TIM 0x18 /* Subcode timeout error */
+#define ERR_SUB_NF 0x19 /* Subcode not found error */
+#define ERR_TRAY 0x1a
+#define ERR_TOC 0x1b /* Table of Contents read error */
+#define ERR_JUMP 0x1c
+/* Data errors */
+#define ERR_MODE 0x21
+#define ERR_FORM 0x22
+#define ERR_HEADADDR 0x23 /* Header Address not found */
+#define ERR_CRC 0x24
+#define ERR_ECC 0x25 /* Uncorrectable ECC error */
+#define ERR_CRC_UNC 0x26 /* CRC error and uncorrectable error */
+#define ERR_ILLBSYNC 0x27 /* Illegal block sync error */
+#define ERR_VDST 0x28 /* VDST not found */
+/* Timeout errors */
+#define ERR_READ_TIM 0x31 /* Read timeout error */
+#define ERR_DEC_STP 0x32 /* Decoder stopped */
+#define ERR_DEC_TIM 0x33 /* Decoder interrupt timeout error */
+/* Function abort codes */
+#define ERR_KEY 0x41 /* Key -Detected abort */
+#define ERR_READ_FINISH 0x42 /* Read Finish */
+/* Second Byte diagnostic codes */
+#define ERR_NOBSYNC 0x01 /* No block sync */
+#define ERR_SHORTB 0x02 /* Short block */
+#define ERR_LONGB 0x03 /* Long block */
+#define ERR_SHORTDSP 0x04 /* Short DSP word */
+#define ERR_LONGDSP 0x05 /* Long DSP word */
+
+
+/* Status availability flags read from STATUS register */
+#define FL_EJECT 0x20
+#define FL_WAIT 0x10 /* active low */
+#define FL_EOP 0x08 /* active low */
+#define FL_STEN 0x04 /* Status available when low */
+#define FL_DTEN 0x02 /* Data available when low */
+#define FL_DRQ 0x01 /* active low */
+#define FL_RESET 0xde /* These bits are high after a reset */
+#define FL_STDT (FL_STEN|FL_DTEN)
+
+
+/* Transfer mode, written to HCON register */
+#define HCON_DTS 0x08
+#define HCON_SDRQB 0x04
+#define HCON_LOHI 0x02
+#define HCON_DMA16 0x01
+
+
+/* Drive command set, written to COMIN register */
+/* Quick response commands */
+#define COMDRVST 0x20 /* Drive Status Read */
+#define COMERRST 0x21 /* Error Status Read */
+#define COMIOCTLISTAT 0x22 /* Status Read; reset disk changed bit */
+#define COMINITSINGLE 0x28 /* Initialize Single Speed */
+#define COMINITDOUBLE 0x29 /* Initialize Double Speed */
+#define COMUNLOCK 0x30 /* Unlock */
+#define COMLOCK 0x31 /* Lock */
+#define COMLOCKST 0x32 /* Lock/Unlock Status */
+#define COMVERSION 0x40 /* Get Firmware Revision */
+#define COMVOIDREADMODE 0x50 /* Void Data Read Mode */
+/* Read commands */
+#define COMFETCH 0x60 /* Prefetch Data */
+#define COMREAD 0x61 /* Read */
+#define COMREADRAW 0x62 /* Read Raw Data */
+#define COMREADALL 0x63 /* Read All 2646 Bytes */
+/* Player control commands */
+#define COMLEADIN 0x70 /* Seek To Lead-in */
+#define COMSEEK 0x71 /* Seek */
+#define COMPAUSEON 0x80 /* Pause On */
+#define COMPAUSEOFF 0x81 /* Pause Off */
+#define COMSTOP 0x82 /* Stop */
+#define COMOPEN 0x90 /* Open Tray Door */
+#define COMCLOSE 0x91 /* Close Tray Door */
+#define COMPLAY 0xa0 /* Audio Play */
+#define COMPLAY_TNO 0xa2 /* Audio Play By Track Number */
+#define COMSUBQ 0xb0 /* Read Sub-q Code */
+#define COMLOCATION 0xb1 /* Read Head Position */
+/* Audio control commands */
+#define COMCHCTRL 0xc0 /* Audio Channel Control */
+/* Miscellaneous (test) commands */
+#define COMDRVTEST 0xd0 /* Write Test Bytes */
+#define COMTEST 0xd1 /* Diagnostic Test */
+
+/* Low level drive interface. Only here we do actual I/O
+ Waiting for status / data available */
+
+
+/* Busy wait until FLAG goes low. Return 0 on timeout. */
+inline static int flag_low(int flag, unsigned long timeout)
+{
+ int flag_high;
+ unsigned long count = 0;
+
+ while ((flag_high = (inb(STATUS_PORT) & flag)))
+ if (++count >= timeout)
+ break;
+
+ DEBUG((DEBUG_DRIVE_IF, "flag_low 0x%x count %ld%s",
+ flag, count, flag_high ? " timeout" : ""));
+ return !flag_high;
+}
+
+
+/* Timed waiting for status or data */
+static int sleep_timeout; /* max # of ticks to sleep */
+static DECLARE_WAIT_QUEUE_HEAD(waitq);
+static void sleep_timer(unsigned long data);
+static struct timer_list delay_timer = TIMER_INITIALIZER(sleep_timer, 0, 0);
+static DEFINE_SPINLOCK(optcd_lock);
+static struct request_queue *opt_queue;
+
+/* Timer routine: wake up when desired flag goes low,
+ or when timeout expires. */
+static void sleep_timer(unsigned long data)
+{
+ int flags = inb(STATUS_PORT) & FL_STDT;
+
+ if (flags == FL_STDT && --sleep_timeout > 0) {
+ mod_timer(&delay_timer, jiffies + HZ/100); /* multi-statement macro */
+ } else
+ wake_up(&waitq);
+}
+
+
+/* Sleep until FLAG goes low. Return 0 on timeout or wrong flag low. */
+static int sleep_flag_low(int flag, unsigned long timeout)
+{
+ int flag_high;
+
+ DEBUG((DEBUG_DRIVE_IF, "sleep_flag_low"));
+
+ sleep_timeout = timeout;
+ flag_high = inb(STATUS_PORT) & flag;
+ if (flag_high && sleep_timeout > 0) {
+ mod_timer(&delay_timer, jiffies + HZ/100);
+ sleep_on(&waitq);
+ flag_high = inb(STATUS_PORT) & flag;
+ }
+
+ DEBUG((DEBUG_DRIVE_IF, "flag 0x%x count %ld%s",
+ flag, timeout, flag_high ? " timeout" : ""));
+ return !flag_high;
+}
+
+/* Low level drive interface. Only here we do actual I/O
+ Sending commands and parameters */
+
+
+/* Errors in the command protocol */
+#define ERR_IF_CMD_TIMEOUT 0x100
+#define ERR_IF_ERR_TIMEOUT 0x101
+#define ERR_IF_RESP_TIMEOUT 0x102
+#define ERR_IF_DATA_TIMEOUT 0x103
+#define ERR_IF_NOSTAT 0x104
+
+
+/* Send command code. Return <0 indicates error */
+static int send_cmd(int cmd)
+{
+ unsigned char ack;
+
+ DEBUG((DEBUG_DRIVE_IF, "sending command 0x%02x\n", cmd));
+
+ outb(HCON_DTS, HCON_PORT); /* Enable Suspend Data Transfer */
+ outb(cmd, COMIN_PORT); /* Send command code */
+ if (!flag_low(FL_STEN, BUSY_TIMEOUT)) /* Wait for status */
+ return -ERR_IF_CMD_TIMEOUT;
+ ack = inb(DATA_PORT); /* read command acknowledge */
+ outb(HCON_SDRQB, HCON_PORT); /* Disable Suspend Data Transfer */
+ return ack==ST_OP_OK ? 0 : -ack;
+}
+
+
+/* Send command parameters. Return <0 indicates error */
+static int send_params(struct cdrom_msf *params)
+{
+ unsigned char ack;
+
+ DEBUG((DEBUG_DRIVE_IF, "sending parameters"
+ " %02x:%02x:%02x"
+ " %02x:%02x:%02x",
+ params->cdmsf_min0,
+ params->cdmsf_sec0,
+ params->cdmsf_frame0,
+ params->cdmsf_min1,
+ params->cdmsf_sec1,
+ params->cdmsf_frame1));
+
+ outb(params->cdmsf_min0, COMIN_PORT);
+ outb(params->cdmsf_sec0, COMIN_PORT);
+ outb(params->cdmsf_frame0, COMIN_PORT);
+ outb(params->cdmsf_min1, COMIN_PORT);
+ outb(params->cdmsf_sec1, COMIN_PORT);
+ outb(params->cdmsf_frame1, COMIN_PORT);
+ if (!flag_low(FL_STEN, BUSY_TIMEOUT)) /* Wait for status */
+ return -ERR_IF_CMD_TIMEOUT;
+ ack = inb(DATA_PORT); /* read command acknowledge */
+ return ack==ST_PA_OK ? 0 : -ack;
+}
+
+
+/* Send parameters for SEEK command. Return <0 indicates error */
+static int send_seek_params(struct cdrom_msf *params)
+{
+ unsigned char ack;
+
+ DEBUG((DEBUG_DRIVE_IF, "sending seek parameters"
+ " %02x:%02x:%02x",
+ params->cdmsf_min0,
+ params->cdmsf_sec0,
+ params->cdmsf_frame0));
+
+ outb(params->cdmsf_min0, COMIN_PORT);
+ outb(params->cdmsf_sec0, COMIN_PORT);
+ outb(params->cdmsf_frame0, COMIN_PORT);
+ if (!flag_low(FL_STEN, BUSY_TIMEOUT)) /* Wait for status */
+ return -ERR_IF_CMD_TIMEOUT;
+ ack = inb(DATA_PORT); /* read command acknowledge */
+ return ack==ST_PA_OK ? 0 : -ack;
+}
+
+
+/* Wait for command execution status. Choice between busy waiting
+ and sleeping. Return value <0 indicates timeout. */
+inline static int get_exec_status(int busy_waiting)
+{
+ unsigned char exec_status;
+
+ if (busy_waiting
+ ? !flag_low(FL_STEN, BUSY_TIMEOUT)
+ : !sleep_flag_low(FL_STEN, SLEEP_TIMEOUT))
+ return -ERR_IF_CMD_TIMEOUT;
+
+ exec_status = inb(DATA_PORT);
+ DEBUG((DEBUG_DRIVE_IF, "returned exec status 0x%02x", exec_status));
+ return exec_status;
+}
+
+
+/* Wait busy for extra byte of data that a command returns.
+ Return value <0 indicates timeout. */
+inline static int get_data(int short_timeout)
+{
+ unsigned char data;
+
+ if (!flag_low(FL_STEN, short_timeout ? FAST_TIMEOUT : BUSY_TIMEOUT))
+ return -ERR_IF_DATA_TIMEOUT;
+
+ data = inb(DATA_PORT);
+ DEBUG((DEBUG_DRIVE_IF, "returned data 0x%02x", data));
+ return data;
+}
+
+
+/* Returns 0 if failed */
+static int reset_drive(void)
+{
+ unsigned long count = 0;
+ int flags;
+
+ DEBUG((DEBUG_DRIVE_IF, "reset drive"));
+
+ outb(0, RESET_PORT);
+ while (++count < RESET_WAIT)
+ inb(DATA_PORT);
+
+ count = 0;
+ while ((flags = (inb(STATUS_PORT) & FL_RESET)) != FL_RESET)
+ if (++count >= BUSY_TIMEOUT)
+ break;
+
+ DEBUG((DEBUG_DRIVE_IF, "reset %s",
+ flags == FL_RESET ? "succeeded" : "failed"));
+
+ if (flags != FL_RESET)
+ return 0; /* Reset failed */
+ outb(HCON_SDRQB, HCON_PORT); /* Disable Suspend Data Transfer */
+ return 1; /* Reset succeeded */
+}
+
+
+/* Facilities for asynchronous operation */
+
+/* Read status/data availability flags FL_STEN and FL_DTEN */
+inline static int stdt_flags(void)
+{
+ return inb(STATUS_PORT) & FL_STDT;
+}
+
+
+/* Fetch status that has previously been waited for. <0 means not available */
+inline static int fetch_status(void)
+{
+ unsigned char status;
+
+ if (inb(STATUS_PORT) & FL_STEN)
+ return -ERR_IF_NOSTAT;
+
+ status = inb(DATA_PORT);
+ DEBUG((DEBUG_DRIVE_IF, "fetched exec status 0x%02x", status));
+ return status;
+}
+
+
+/* Fetch data that has previously been waited for. */
+inline static void fetch_data(char *buf, int n)
+{
+ insb(DATA_PORT, buf, n);
+ DEBUG((DEBUG_DRIVE_IF, "fetched 0x%x bytes", n));
+}
+
+
+/* Flush status and data fifos */
+inline static void flush_data(void)
+{
+ while ((inb(STATUS_PORT) & FL_STDT) != FL_STDT)
+ inb(DATA_PORT);
+ DEBUG((DEBUG_DRIVE_IF, "flushed fifos"));
+}
+
+/* Command protocol */
+
+
+/* Send a simple command and wait for response. Command codes < COMFETCH
+ are quick response commands */
+inline static int exec_cmd(int cmd)
+{
+ int ack = send_cmd(cmd);
+ if (ack < 0)
+ return ack;
+ return get_exec_status(cmd < COMFETCH);
+}
+
+
+/* Send a command with parameters. Don't wait for the response,
+ * which consists of data blocks read from the CD. */
+inline static int exec_read_cmd(int cmd, struct cdrom_msf *params)
+{
+ int ack = send_cmd(cmd);
+ if (ack < 0)
+ return ack;
+ return send_params(params);
+}
+
+
+/* Send a seek command with parameters and wait for response */
+inline static int exec_seek_cmd(int cmd, struct cdrom_msf *params)
+{
+ int ack = send_cmd(cmd);
+ if (ack < 0)
+ return ack;
+ ack = send_seek_params(params);
+ if (ack < 0)
+ return ack;
+ return 0;
+}
+
+
+/* Send a command with parameters and wait for response */
+inline static int exec_long_cmd(int cmd, struct cdrom_msf *params)
+{
+ int ack = exec_read_cmd(cmd, params);
+ if (ack < 0)
+ return ack;
+ return get_exec_status(0);
+}
+
+/* Address conversion routines */
+
+
+/* Binary to BCD (2 digits) */
+inline static void single_bin2bcd(u_char *p)
+{
+ DEBUG((DEBUG_CONV, "bin2bcd %02d", *p));
+ *p = (*p % 10) | ((*p / 10) << 4);
+}
+
+
+/* Convert entire msf struct */
+static void bin2bcd(struct cdrom_msf *msf)
+{
+ single_bin2bcd(&msf->cdmsf_min0);
+ single_bin2bcd(&msf->cdmsf_sec0);
+ single_bin2bcd(&msf->cdmsf_frame0);
+ single_bin2bcd(&msf->cdmsf_min1);
+ single_bin2bcd(&msf->cdmsf_sec1);
+ single_bin2bcd(&msf->cdmsf_frame1);
+}
+
+
+/* Linear block address to minute, second, frame form */
+#define CD_FPM (CD_SECS * CD_FRAMES) /* frames per minute */
+
+static void lba2msf(int lba, struct cdrom_msf *msf)
+{
+ DEBUG((DEBUG_CONV, "lba2msf %d", lba));
+ lba += CD_MSF_OFFSET;
+ msf->cdmsf_min0 = lba / CD_FPM; lba %= CD_FPM;
+ msf->cdmsf_sec0 = lba / CD_FRAMES;
+ msf->cdmsf_frame0 = lba % CD_FRAMES;
+ msf->cdmsf_min1 = 0;
+ msf->cdmsf_sec1 = 0;
+ msf->cdmsf_frame1 = 0;
+ bin2bcd(msf);
+}
+
+
+/* Two BCD digits to binary */
+inline static u_char bcd2bin(u_char bcd)
+{
+ DEBUG((DEBUG_CONV, "bcd2bin %x%02x", bcd));
+ return (bcd >> 4) * 10 + (bcd & 0x0f);
+}
+
+
+static void msf2lba(union cdrom_addr *addr)
+{
+ addr->lba = addr->msf.minute * CD_FPM
+ + addr->msf.second * CD_FRAMES
+ + addr->msf.frame - CD_MSF_OFFSET;
+}
+
+
+/* Minute, second, frame address BCD to binary or to linear address,
+ depending on MODE */
+static void msf_bcd2bin(union cdrom_addr *addr)
+{
+ addr->msf.minute = bcd2bin(addr->msf.minute);
+ addr->msf.second = bcd2bin(addr->msf.second);
+ addr->msf.frame = bcd2bin(addr->msf.frame);
+}
+
+/* High level drive commands */
+
+
+static int audio_status = CDROM_AUDIO_NO_STATUS;
+static char toc_uptodate = 0;
+static char disk_changed = 1;
+
+/* Get drive status, flagging completion of audio play and disk changes. */
+static int drive_status(void)
+{
+ int status;
+
+ status = exec_cmd(COMIOCTLISTAT);
+ DEBUG((DEBUG_DRIVE_IF, "IOCTLISTAT: %03x", status));
+ if (status < 0)
+ return status;
+ if (status == 0xff) /* No status available */
+ return -ERR_IF_NOSTAT;
+
+ if (((status & ST_MODE_BITS) != ST_M_AUDIO) &&
+ (audio_status == CDROM_AUDIO_PLAY)) {
+ audio_status = CDROM_AUDIO_COMPLETED;
+ }
+
+ if (status & ST_DSK_CHG) {
+ toc_uptodate = 0;
+ disk_changed = 1;
+ audio_status = CDROM_AUDIO_NO_STATUS;
+ }
+
+ return status;
+}
+
+
+/* Read the current Q-channel info. Also used for reading the
+ table of contents. qp->cdsc_format must be set on entry to
+ indicate the desired address format */
+static int get_q_channel(struct cdrom_subchnl *qp)
+{
+ int status, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10;
+
+ status = drive_status();
+ if (status < 0)
+ return status;
+ qp->cdsc_audiostatus = audio_status;
+
+ status = exec_cmd(COMSUBQ);
+ if (status < 0)
+ return status;
+
+ d1 = get_data(0);
+ if (d1 < 0)
+ return d1;
+ qp->cdsc_adr = d1;
+ qp->cdsc_ctrl = d1 >> 4;
+
+ d2 = get_data(0);
+ if (d2 < 0)
+ return d2;
+ qp->cdsc_trk = bcd2bin(d2);
+
+ d3 = get_data(0);
+ if (d3 < 0)
+ return d3;
+ qp->cdsc_ind = bcd2bin(d3);
+
+ d4 = get_data(0);
+ if (d4 < 0)
+ return d4;
+ qp->cdsc_reladdr.msf.minute = d4;
+
+ d5 = get_data(0);
+ if (d5 < 0)
+ return d5;
+ qp->cdsc_reladdr.msf.second = d5;
+
+ d6 = get_data(0);
+ if (d6 < 0)
+ return d6;
+ qp->cdsc_reladdr.msf.frame = d6;
+
+ d7 = get_data(0);
+ if (d7 < 0)
+ return d7;
+ /* byte not used */
+
+ d8 = get_data(0);
+ if (d8 < 0)
+ return d8;
+ qp->cdsc_absaddr.msf.minute = d8;
+
+ d9 = get_data(0);
+ if (d9 < 0)
+ return d9;
+ qp->cdsc_absaddr.msf.second = d9;
+
+ d10 = get_data(0);
+ if (d10 < 0)
+ return d10;
+ qp->cdsc_absaddr.msf.frame = d10;
+
+ DEBUG((DEBUG_TOC, "%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x",
+ d1, d2, d3, d4, d5, d6, d7, d8, d9, d10));
+
+ msf_bcd2bin(&qp->cdsc_absaddr);
+ msf_bcd2bin(&qp->cdsc_reladdr);
+ if (qp->cdsc_format == CDROM_LBA) {
+ msf2lba(&qp->cdsc_absaddr);
+ msf2lba(&qp->cdsc_reladdr);
+ }
+
+ return 0;
+}
+
+/* Table of contents handling */
+
+
+/* Errors in table of contents */
+#define ERR_TOC_MISSINGINFO 0x120
+#define ERR_TOC_MISSINGENTRY 0x121
+
+
+struct cdrom_disk_info {
+ unsigned char first;
+ unsigned char last;
+ struct cdrom_msf0 disk_length;
+ struct cdrom_msf0 first_track;
+ /* Multisession info: */
+ unsigned char next;
+ struct cdrom_msf0 next_session;
+ struct cdrom_msf0 last_session;
+ unsigned char multi;
+ unsigned char xa;
+ unsigned char audio;
+};
+static struct cdrom_disk_info disk_info;
+
+#define MAX_TRACKS 111
+static struct cdrom_subchnl toc[MAX_TRACKS];
+
+#define QINFO_FIRSTTRACK 100 /* bcd2bin(0xa0) */
+#define QINFO_LASTTRACK 101 /* bcd2bin(0xa1) */
+#define QINFO_DISKLENGTH 102 /* bcd2bin(0xa2) */
+#define QINFO_NEXTSESSION 110 /* bcd2bin(0xb0) */
+
+#define I_FIRSTTRACK 0x01
+#define I_LASTTRACK 0x02
+#define I_DISKLENGTH 0x04
+#define I_NEXTSESSION 0x08
+#define I_ALL (I_FIRSTTRACK | I_LASTTRACK | I_DISKLENGTH)
+
+
+#if DEBUG_TOC
+static void toc_debug_info(int i)
+{
+ printk(KERN_DEBUG "#%3d ctl %1x, adr %1x, track %2d index %3d"
+ " %2d:%02d.%02d %2d:%02d.%02d\n",
+ i, toc[i].cdsc_ctrl, toc[i].cdsc_adr,
+ toc[i].cdsc_trk, toc[i].cdsc_ind,
+ toc[i].cdsc_reladdr.msf.minute,
+ toc[i].cdsc_reladdr.msf.second,
+ toc[i].cdsc_reladdr.msf.frame,
+ toc[i].cdsc_absaddr.msf.minute,
+ toc[i].cdsc_absaddr.msf.second,
+ toc[i].cdsc_absaddr.msf.frame);
+}
+#endif
+
+
+static int read_toc(void)
+{
+ int status, limit, count;
+ unsigned char got_info = 0;
+ struct cdrom_subchnl q_info;
+#if DEBUG_TOC
+ int i;
+#endif
+
+ DEBUG((DEBUG_TOC, "starting read_toc"));
+
+ count = 0;
+ for (limit = 60; limit > 0; limit--) {
+ int index;
+
+ q_info.cdsc_format = CDROM_MSF;
+ status = get_q_channel(&q_info);
+ if (status < 0)
+ return status;
+
+ index = q_info.cdsc_ind;
+ if (index > 0 && index < MAX_TRACKS
+ && q_info.cdsc_trk == 0 && toc[index].cdsc_ind == 0) {
+ toc[index] = q_info;
+ DEBUG((DEBUG_TOC, "got %d", index));
+ if (index < 100)
+ count++;
+
+ switch (q_info.cdsc_ind) {
+ case QINFO_FIRSTTRACK:
+ got_info |= I_FIRSTTRACK;
+ break;
+ case QINFO_LASTTRACK:
+ got_info |= I_LASTTRACK;
+ break;
+ case QINFO_DISKLENGTH:
+ got_info |= I_DISKLENGTH;
+ break;
+ case QINFO_NEXTSESSION:
+ got_info |= I_NEXTSESSION;
+ break;
+ }
+ }
+
+ if ((got_info & I_ALL) == I_ALL
+ && toc[QINFO_FIRSTTRACK].cdsc_absaddr.msf.minute + count
+ >= toc[QINFO_LASTTRACK].cdsc_absaddr.msf.minute + 1)
+ break;
+ }
+
+ /* Construct disk_info from TOC */
+ if (disk_info.first == 0) {
+ disk_info.first = toc[QINFO_FIRSTTRACK].cdsc_absaddr.msf.minute;
+ disk_info.first_track.minute =
+ toc[disk_info.first].cdsc_absaddr.msf.minute;
+ disk_info.first_track.second =
+ toc[disk_info.first].cdsc_absaddr.msf.second;
+ disk_info.first_track.frame =
+ toc[disk_info.first].cdsc_absaddr.msf.frame;
+ }
+ disk_info.last = toc[QINFO_LASTTRACK].cdsc_absaddr.msf.minute;
+ disk_info.disk_length.minute =
+ toc[QINFO_DISKLENGTH].cdsc_absaddr.msf.minute;
+ disk_info.disk_length.second =
+ toc[QINFO_DISKLENGTH].cdsc_absaddr.msf.second-2;
+ disk_info.disk_length.frame =
+ toc[QINFO_DISKLENGTH].cdsc_absaddr.msf.frame;
+ disk_info.next_session.minute =
+ toc[QINFO_NEXTSESSION].cdsc_reladdr.msf.minute;
+ disk_info.next_session.second =
+ toc[QINFO_NEXTSESSION].cdsc_reladdr.msf.second;
+ disk_info.next_session.frame =
+ toc[QINFO_NEXTSESSION].cdsc_reladdr.msf.frame;
+ disk_info.next = toc[QINFO_FIRSTTRACK].cdsc_absaddr.msf.minute;
+ disk_info.last_session.minute =
+ toc[disk_info.next].cdsc_absaddr.msf.minute;
+ disk_info.last_session.second =
+ toc[disk_info.next].cdsc_absaddr.msf.second;
+ disk_info.last_session.frame =
+ toc[disk_info.next].cdsc_absaddr.msf.frame;
+ toc[disk_info.last + 1].cdsc_absaddr.msf.minute =
+ disk_info.disk_length.minute;
+ toc[disk_info.last + 1].cdsc_absaddr.msf.second =
+ disk_info.disk_length.second;
+ toc[disk_info.last + 1].cdsc_absaddr.msf.frame =
+ disk_info.disk_length.frame;
+#if DEBUG_TOC
+ for (i = 1; i <= disk_info.last + 1; i++)
+ toc_debug_info(i);
+ toc_debug_info(QINFO_FIRSTTRACK);
+ toc_debug_info(QINFO_LASTTRACK);
+ toc_debug_info(QINFO_DISKLENGTH);
+ toc_debug_info(QINFO_NEXTSESSION);
+#endif
+
+ DEBUG((DEBUG_TOC, "exiting read_toc, got_info %x, count %d",
+ got_info, count));
+ if ((got_info & I_ALL) != I_ALL
+ || toc[QINFO_FIRSTTRACK].cdsc_absaddr.msf.minute + count
+ < toc[QINFO_LASTTRACK].cdsc_absaddr.msf.minute + 1)
+ return -ERR_TOC_MISSINGINFO;
+ return 0;
+}
+
+
+#ifdef MULTISESSION
+static int get_multi_disk_info(void)
+{
+ int sessions, status;
+ struct cdrom_msf multi_index;
+
+
+ for (sessions = 2; sessions < 10 /* %%for now */; sessions++) {
+ int count;
+
+ for (count = 100; count < MAX_TRACKS; count++)
+ toc[count].cdsc_ind = 0;
+
+ multi_index.cdmsf_min0 = disk_info.next_session.minute;
+ multi_index.cdmsf_sec0 = disk_info.next_session.second;
+ multi_index.cdmsf_frame0 = disk_info.next_session.frame;
+ if (multi_index.cdmsf_sec0 >= 20)
+ multi_index.cdmsf_sec0 -= 20;
+ else {
+ multi_index.cdmsf_sec0 += 40;
+ multi_index.cdmsf_min0--;
+ }
+ DEBUG((DEBUG_MULTIS, "Try %d: %2d:%02d.%02d", sessions,
+ multi_index.cdmsf_min0,
+ multi_index.cdmsf_sec0,
+ multi_index.cdmsf_frame0));
+ bin2bcd(&multi_index);
+ multi_index.cdmsf_min1 = 0;
+ multi_index.cdmsf_sec1 = 0;
+ multi_index.cdmsf_frame1 = 1;
+
+ status = exec_read_cmd(COMREAD, &multi_index);
+ if (status < 0) {
+ DEBUG((DEBUG_TOC, "exec_read_cmd COMREAD: %02x",
+ -status));
+ break;
+ }
+ status = sleep_flag_low(FL_DTEN, MULTI_SEEK_TIMEOUT) ?
+ 0 : -ERR_TOC_MISSINGINFO;
+ flush_data();
+ if (status < 0) {
+ DEBUG((DEBUG_TOC, "sleep_flag_low: %02x", -status));
+ break;
+ }
+
+ status = read_toc();
+ if (status < 0) {
+ DEBUG((DEBUG_TOC, "read_toc: %02x", -status));
+ break;
+ }
+
+ disk_info.multi = 1;
+ }
+
+ exec_cmd(COMSTOP);
+
+ if (status < 0)
+ return -EIO;
+ return 0;
+}
+#endif /* MULTISESSION */
+
+
+static int update_toc(void)
+{
+ int status, count;
+
+ if (toc_uptodate)
+ return 0;
+
+ DEBUG((DEBUG_TOC, "starting update_toc"));
+
+ disk_info.first = 0;
+ for (count = 0; count < MAX_TRACKS; count++)
+ toc[count].cdsc_ind = 0;
+
+ status = exec_cmd(COMLEADIN);
+ if (status < 0)
+ return -EIO;
+
+ status = read_toc();
+ if (status < 0) {
+ DEBUG((DEBUG_TOC, "read_toc: %02x", -status));
+ return -EIO;
+ }
+
+ /* Audio disk detection. Look at first track. */
+ disk_info.audio =
+ (toc[disk_info.first].cdsc_ctrl & CDROM_DATA_TRACK) ? 0 : 1;
+
+ /* XA detection */
+ disk_info.xa = drive_status() & ST_MODE2TRACK;
+
+ /* Multisession detection: if we want this, define MULTISESSION */
+ disk_info.multi = 0;
+#ifdef MULTISESSION
+ if (disk_info.xa)
+ get_multi_disk_info(); /* Here disk_info.multi is set */
+#endif /* MULTISESSION */
+ if (disk_info.multi)
+ printk(KERN_WARNING "optcd: Multisession support experimental, "
+ "see Documentation/cdrom/optcd\n");
+
+ DEBUG((DEBUG_TOC, "exiting update_toc"));
+
+ toc_uptodate = 1;
+ return 0;
+}
+
+/* Request handling */
+
+static int current_valid(void)
+{
+ return CURRENT &&
+ CURRENT->cmd == READ &&
+ CURRENT->sector != -1;
+}
+
+/* Buffers for block size conversion. */
+#define NOBUF -1
+
+static char buf[CD_FRAMESIZE * N_BUFS];
+static volatile int buf_bn[N_BUFS], next_bn;
+static volatile int buf_in = 0, buf_out = NOBUF;
+
+inline static void opt_invalidate_buffers(void)
+{
+ int i;
+
+ DEBUG((DEBUG_BUFFERS, "executing opt_invalidate_buffers"));
+
+ for (i = 0; i < N_BUFS; i++)
+ buf_bn[i] = NOBUF;
+ buf_out = NOBUF;
+}
+
+
+/* Take care of the different block sizes between cdrom and Linux.
+ When Linux gets variable block sizes this will probably go away. */
+static void transfer(void)
+{
+#if DEBUG_BUFFERS | DEBUG_REQUEST
+ printk(KERN_DEBUG "optcd: executing transfer\n");
+#endif
+
+ if (!current_valid())
+ return;
+ while (CURRENT -> nr_sectors) {
+ int bn = CURRENT -> sector / 4;
+ int i, offs, nr_sectors;
+ for (i = 0; i < N_BUFS && buf_bn[i] != bn; ++i);
+
+ DEBUG((DEBUG_REQUEST, "found %d", i));
+
+ if (i >= N_BUFS) {
+ buf_out = NOBUF;
+ break;
+ }
+
+ offs = (i * 4 + (CURRENT -> sector & 3)) * 512;
+ nr_sectors = 4 - (CURRENT -> sector & 3);
+
+ if (buf_out != i) {
+ buf_out = i;
+ if (buf_bn[i] != bn) {
+ buf_out = NOBUF;
+ continue;
+ }
+ }
+
+ if (nr_sectors > CURRENT -> nr_sectors)
+ nr_sectors = CURRENT -> nr_sectors;
+ memcpy(CURRENT -> buffer, buf + offs, nr_sectors * 512);
+ CURRENT -> nr_sectors -= nr_sectors;
+ CURRENT -> sector += nr_sectors;
+ CURRENT -> buffer += nr_sectors * 512;
+ }
+}
+
+
+/* State machine for reading disk blocks */
+
+enum state_e {
+ S_IDLE, /* 0 */
+ S_START, /* 1 */
+ S_READ, /* 2 */
+ S_DATA, /* 3 */
+ S_STOP, /* 4 */
+ S_STOPPING /* 5 */
+};
+
+static volatile enum state_e state = S_IDLE;
+#if DEBUG_STATE
+static volatile enum state_e state_old = S_STOP;
+static volatile int flags_old = 0;
+static volatile long state_n = 0;
+#endif
+
+
+/* Used as mutex to keep do_optcd_request (and other processes calling
+ ioctl) out while some process is inside a VFS call.
+ Reverse is accomplished by checking if state = S_IDLE upon entry
+ of opt_ioctl and opt_media_change. */
+static int in_vfs = 0;
+
+
+static volatile int transfer_is_active = 0;
+static volatile int error = 0; /* %% do something with this?? */
+static int tries; /* ibid?? */
+static int timeout = 0;
+
+static void poll(unsigned long data);
+static struct timer_list req_timer = {.function = poll};
+
+
+static void poll(unsigned long data)
+{
+ static volatile int read_count = 1;
+ int flags;
+ int loop_again = 1;
+ int status = 0;
+ int skip = 0;
+
+ if (error) {
+ printk(KERN_ERR "optcd: I/O error 0x%02x\n", error);
+ opt_invalidate_buffers();
+ if (!tries--) {
+ printk(KERN_ERR "optcd: read block %d failed;"
+ " Giving up\n", next_bn);
+ if (transfer_is_active)
+ loop_again = 0;
+ if (current_valid())
+ end_request(CURRENT, 0);
+ tries = 5;
+ }
+ error = 0;
+ state = S_STOP;
+ }
+
+ while (loop_again)
+ {
+ loop_again = 0; /* each case must flip this back to 1 if we want
+ to come back up here */
+
+#if DEBUG_STATE
+ if (state == state_old)
+ state_n++;
+ else {
+ state_old = state;
+ if (++state_n > 1)
+ printk(KERN_DEBUG "optcd: %ld times "
+ "in previous state\n", state_n);
+ printk(KERN_DEBUG "optcd: state %d\n", state);
+ state_n = 0;
+ }
+#endif
+
+ switch (state) {
+ case S_IDLE:
+ return;
+ case S_START:
+ if (in_vfs)
+ break;
+ if (send_cmd(COMDRVST)) {
+ state = S_IDLE;
+ while (current_valid())
+ end_request(CURRENT, 0);
+ return;
+ }
+ state = S_READ;
+ timeout = READ_TIMEOUT;
+ break;
+ case S_READ: {
+ struct cdrom_msf msf;
+ if (!skip) {
+ status = fetch_status();
+ if (status < 0)
+ break;
+ if (status & ST_DSK_CHG) {
+ toc_uptodate = 0;
+ opt_invalidate_buffers();
+ }
+ }
+ skip = 0;
+ if ((status & ST_DOOR_OPEN) || (status & ST_DRVERR)) {
+ toc_uptodate = 0;
+ opt_invalidate_buffers();
+ printk(KERN_WARNING "optcd: %s\n",
+ (status & ST_DOOR_OPEN)
+ ? "door open"
+ : "disk removed");
+ state = S_IDLE;
+ while (current_valid())
+ end_request(CURRENT, 0);
+ return;
+ }
+ if (!current_valid()) {
+ state = S_STOP;
+ loop_again = 1;
+ break;
+ }
+ next_bn = CURRENT -> sector / 4;
+ lba2msf(next_bn, &msf);
+ read_count = N_BUFS;
+ msf.cdmsf_frame1 = read_count; /* Not BCD! */
+
+ DEBUG((DEBUG_REQUEST, "reading %x:%x.%x %x:%x.%x",
+ msf.cdmsf_min0,
+ msf.cdmsf_sec0,
+ msf.cdmsf_frame0,
+ msf.cdmsf_min1,
+ msf.cdmsf_sec1,
+ msf.cdmsf_frame1));
+ DEBUG((DEBUG_REQUEST, "next_bn:%d buf_in:%d"
+ " buf_out:%d buf_bn:%d",
+ next_bn,
+ buf_in,
+ buf_out,
+ buf_bn[buf_in]));
+
+ exec_read_cmd(COMREAD, &msf);
+ state = S_DATA;
+ timeout = READ_TIMEOUT;
+ break;
+ }
+ case S_DATA:
+ flags = stdt_flags() & (FL_STEN|FL_DTEN);
+
+#if DEBUG_STATE
+ if (flags != flags_old) {
+ flags_old = flags;
+ printk(KERN_DEBUG "optcd: flags:%x\n", flags);
+ }
+ if (flags == FL_STEN)
+ printk(KERN_DEBUG "timeout cnt: %d\n", timeout);
+#endif
+
+ switch (flags) {
+ case FL_DTEN: /* only STEN low */
+ if (!tries--) {
+ printk(KERN_ERR
+ "optcd: read block %d failed; "
+ "Giving up\n", next_bn);
+ if (transfer_is_active) {
+ tries = 0;
+ break;
+ }
+ if (current_valid())
+ end_request(CURRENT, 0);
+ tries = 5;
+ }
+ state = S_START;
+ timeout = READ_TIMEOUT;
+ loop_again = 1;
+ case (FL_STEN|FL_DTEN): /* both high */
+ break;
+ default: /* DTEN low */
+ tries = 5;
+ if (!current_valid() && buf_in == buf_out) {
+ state = S_STOP;
+ loop_again = 1;
+ break;
+ }
+ if (read_count<=0)
+ printk(KERN_WARNING
+ "optcd: warning - try to read"
+ " 0 frames\n");
+ while (read_count) {
+ buf_bn[buf_in] = NOBUF;
+ if (!flag_low(FL_DTEN, BUSY_TIMEOUT)) {
+ /* should be no waiting here!?? */
+ printk(KERN_ERR
+ "read_count:%d "
+ "CURRENT->nr_sectors:%ld "
+ "buf_in:%d\n",
+ read_count,
+ CURRENT->nr_sectors,
+ buf_in);
+ printk(KERN_ERR
+ "transfer active: %x\n",
+ transfer_is_active);
+ read_count = 0;
+ state = S_STOP;
+ loop_again = 1;
+ end_request(CURRENT, 0);
+ break;
+ }
+ fetch_data(buf+
+ CD_FRAMESIZE*buf_in,
+ CD_FRAMESIZE);
+ read_count--;
+
+ DEBUG((DEBUG_REQUEST,
+ "S_DATA; ---I've read data- "
+ "read_count: %d",
+ read_count));
+ DEBUG((DEBUG_REQUEST,
+ "next_bn:%d buf_in:%d "
+ "buf_out:%d buf_bn:%d",
+ next_bn,
+ buf_in,
+ buf_out,
+ buf_bn[buf_in]));
+
+ buf_bn[buf_in] = next_bn++;
+ if (buf_out == NOBUF)
+ buf_out = buf_in;
+ buf_in = buf_in + 1 ==
+ N_BUFS ? 0 : buf_in + 1;
+ }
+ if (!transfer_is_active) {
+ while (current_valid()) {
+ transfer();
+ if (CURRENT -> nr_sectors == 0)
+ end_request(CURRENT, 1);
+ else
+ break;
+ }
+ }
+
+ if (current_valid()
+ && (CURRENT -> sector / 4 < next_bn ||
+ CURRENT -> sector / 4 >
+ next_bn + N_BUFS)) {
+ state = S_STOP;
+ loop_again = 1;
+ break;
+ }
+ timeout = READ_TIMEOUT;
+ if (read_count == 0) {
+ state = S_STOP;
+ loop_again = 1;
+ break;
+ }
+ }
+ break;
+ case S_STOP:
+ if (read_count != 0)
+ printk(KERN_ERR
+ "optcd: discard data=%x frames\n",
+ read_count);
+ flush_data();
+ if (send_cmd(COMDRVST)) {
+ state = S_IDLE;
+ while (current_valid())
+ end_request(CURRENT, 0);
+ return;
+ }
+ state = S_STOPPING;
+ timeout = STOP_TIMEOUT;
+ break;
+ case S_STOPPING:
+ status = fetch_status();
+ if (status < 0 && timeout)
+ break;
+ if ((status >= 0) && (status & ST_DSK_CHG)) {
+ toc_uptodate = 0;
+ opt_invalidate_buffers();
+ }
+ if (current_valid()) {
+ if (status >= 0) {
+ state = S_READ;
+ loop_again = 1;
+ skip = 1;
+ break;
+ } else {
+ state = S_START;
+ timeout = 1;
+ }
+ } else {
+ state = S_IDLE;
+ return;
+ }
+ break;
+ default:
+ printk(KERN_ERR "optcd: invalid state %d\n", state);
+ return;
+ } /* case */
+ } /* while */
+
+ if (!timeout--) {
+ printk(KERN_ERR "optcd: timeout in state %d\n", state);
+ state = S_STOP;
+ if (exec_cmd(COMSTOP) < 0) {
+ state = S_IDLE;
+ while (current_valid())
+ end_request(CURRENT, 0);
+ return;
+ }
+ }
+
+ mod_timer(&req_timer, jiffies + HZ/100);
+}
+
+
+static void do_optcd_request(request_queue_t * q)
+{
+ DEBUG((DEBUG_REQUEST, "do_optcd_request(%ld+%ld)",
+ CURRENT -> sector, CURRENT -> nr_sectors));
+
+ if (disk_info.audio) {
+ printk(KERN_WARNING "optcd: tried to mount an Audio CD\n");
+ end_request(CURRENT, 0);
+ return;
+ }
+
+ transfer_is_active = 1;
+ while (current_valid()) {
+ transfer(); /* First try to transfer block from buffers */
+ if (CURRENT -> nr_sectors == 0) {
+ end_request(CURRENT, 1);
+ } else { /* Want to read a block not in buffer */
+ buf_out = NOBUF;
+ if (state == S_IDLE) {
+ /* %% Should this block the request queue?? */
+ if (update_toc() < 0) {
+ while (current_valid())
+ end_request(CURRENT, 0);
+ break;
+ }
+ /* Start state machine */
+ state = S_START;
+ timeout = READ_TIMEOUT;
+ tries = 5;
+ /* %% why not start right away?? */
+ mod_timer(&req_timer, jiffies + HZ/100);
+ }
+ break;
+ }
+ }
+ transfer_is_active = 0;
+
+ DEBUG((DEBUG_REQUEST, "next_bn:%d buf_in:%d buf_out:%d buf_bn:%d",
+ next_bn, buf_in, buf_out, buf_bn[buf_in]));
+ DEBUG((DEBUG_REQUEST, "do_optcd_request ends"));
+}
+
+/* IOCTLs */
+
+
+static char auto_eject = 0;
+
+static int cdrompause(void)
+{
+ int status;
+
+ if (audio_status != CDROM_AUDIO_PLAY)
+ return -EINVAL;
+
+ status = exec_cmd(COMPAUSEON);
+ if (status < 0) {
+ DEBUG((DEBUG_VFS, "exec_cmd COMPAUSEON: %02x", -status));
+ return -EIO;
+ }
+ audio_status = CDROM_AUDIO_PAUSED;
+ return 0;
+}
+
+
+static int cdromresume(void)
+{
+ int status;
+
+ if (audio_status != CDROM_AUDIO_PAUSED)
+ return -EINVAL;
+
+ status = exec_cmd(COMPAUSEOFF);
+ if (status < 0) {
+ DEBUG((DEBUG_VFS, "exec_cmd COMPAUSEOFF: %02x", -status));
+ audio_status = CDROM_AUDIO_ERROR;
+ return -EIO;
+ }
+ audio_status = CDROM_AUDIO_PLAY;
+ return 0;
+}
+
+
+static int cdromplaymsf(void __user *arg)
+{
+ int status;
+ struct cdrom_msf msf;
+
+ if (copy_from_user(&msf, arg, sizeof msf))
+ return -EFAULT;
+
+ bin2bcd(&msf);
+ status = exec_long_cmd(COMPLAY, &msf);
+ if (status < 0) {
+ DEBUG((DEBUG_VFS, "exec_long_cmd COMPLAY: %02x", -status));
+ audio_status = CDROM_AUDIO_ERROR;
+ return -EIO;
+ }
+
+ audio_status = CDROM_AUDIO_PLAY;
+ return 0;
+}
+
+
+static int cdromplaytrkind(void __user *arg)
+{
+ int status;
+ struct cdrom_ti ti;
+ struct cdrom_msf msf;
+
+ if (copy_from_user(&ti, arg, sizeof ti))
+ return -EFAULT;
+
+ if (ti.cdti_trk0 < disk_info.first
+ || ti.cdti_trk0 > disk_info.last
+ || ti.cdti_trk1 < ti.cdti_trk0)
+ return -EINVAL;
+ if (ti.cdti_trk1 > disk_info.last)
+ ti.cdti_trk1 = disk_info.last;
+
+ msf.cdmsf_min0 = toc[ti.cdti_trk0].cdsc_absaddr.msf.minute;
+ msf.cdmsf_sec0 = toc[ti.cdti_trk0].cdsc_absaddr.msf.second;
+ msf.cdmsf_frame0 = toc[ti.cdti_trk0].cdsc_absaddr.msf.frame;
+ msf.cdmsf_min1 = toc[ti.cdti_trk1 + 1].cdsc_absaddr.msf.minute;
+ msf.cdmsf_sec1 = toc[ti.cdti_trk1 + 1].cdsc_absaddr.msf.second;
+ msf.cdmsf_frame1 = toc[ti.cdti_trk1 + 1].cdsc_absaddr.msf.frame;
+
+ DEBUG((DEBUG_VFS, "play %02d:%02d.%02d to %02d:%02d.%02d",
+ msf.cdmsf_min0,
+ msf.cdmsf_sec0,
+ msf.cdmsf_frame0,
+ msf.cdmsf_min1,
+ msf.cdmsf_sec1,
+ msf.cdmsf_frame1));
+
+ bin2bcd(&msf);
+ status = exec_long_cmd(COMPLAY, &msf);
+ if (status < 0) {
+ DEBUG((DEBUG_VFS, "exec_long_cmd COMPLAY: %02x", -status));
+ audio_status = CDROM_AUDIO_ERROR;
+ return -EIO;
+ }
+
+ audio_status = CDROM_AUDIO_PLAY;
+ return 0;
+}
+
+
+static int cdromreadtochdr(void __user *arg)
+{
+ struct cdrom_tochdr tochdr;
+
+ tochdr.cdth_trk0 = disk_info.first;
+ tochdr.cdth_trk1 = disk_info.last;
+
+ return copy_to_user(arg, &tochdr, sizeof tochdr) ? -EFAULT : 0;
+}
+
+
+static int cdromreadtocentry(void __user *arg)
+{
+ struct cdrom_tocentry entry;
+ struct cdrom_subchnl *tocptr;
+
+ if (copy_from_user(&entry, arg, sizeof entry))
+ return -EFAULT;
+
+ if (entry.cdte_track == CDROM_LEADOUT)
+ tocptr = &toc[disk_info.last + 1];
+ else if (entry.cdte_track > disk_info.last
+ || entry.cdte_track < disk_info.first)
+ return -EINVAL;
+ else
+ tocptr = &toc[entry.cdte_track];
+
+ entry.cdte_adr = tocptr->cdsc_adr;
+ entry.cdte_ctrl = tocptr->cdsc_ctrl;
+ entry.cdte_addr.msf.minute = tocptr->cdsc_absaddr.msf.minute;
+ entry.cdte_addr.msf.second = tocptr->cdsc_absaddr.msf.second;
+ entry.cdte_addr.msf.frame = tocptr->cdsc_absaddr.msf.frame;
+ /* %% What should go into entry.cdte_datamode? */
+
+ if (entry.cdte_format == CDROM_LBA)
+ msf2lba(&entry.cdte_addr);
+ else if (entry.cdte_format != CDROM_MSF)
+ return -EINVAL;
+
+ return copy_to_user(arg, &entry, sizeof entry) ? -EFAULT : 0;
+}
+
+
+static int cdromvolctrl(void __user *arg)
+{
+ int status;
+ struct cdrom_volctrl volctrl;
+ struct cdrom_msf msf;
+
+ if (copy_from_user(&volctrl, arg, sizeof volctrl))
+ return -EFAULT;
+
+ msf.cdmsf_min0 = 0x10;
+ msf.cdmsf_sec0 = 0x32;
+ msf.cdmsf_frame0 = volctrl.channel0;
+ msf.cdmsf_min1 = volctrl.channel1;
+ msf.cdmsf_sec1 = volctrl.channel2;
+ msf.cdmsf_frame1 = volctrl.channel3;
+
+ status = exec_long_cmd(COMCHCTRL, &msf);
+ if (status < 0) {
+ DEBUG((DEBUG_VFS, "exec_long_cmd COMCHCTRL: %02x", -status));
+ return -EIO;
+ }
+ return 0;
+}
+
+
+static int cdromsubchnl(void __user *arg)
+{
+ int status;
+ struct cdrom_subchnl subchnl;
+
+ if (copy_from_user(&subchnl, arg, sizeof subchnl))
+ return -EFAULT;
+
+ if (subchnl.cdsc_format != CDROM_LBA
+ && subchnl.cdsc_format != CDROM_MSF)
+ return -EINVAL;
+
+ status = get_q_channel(&subchnl);
+ if (status < 0) {
+ DEBUG((DEBUG_VFS, "get_q_channel: %02x", -status));
+ return -EIO;
+ }
+
+ if (copy_to_user(arg, &subchnl, sizeof subchnl))
+ return -EFAULT;
+ return 0;
+}
+
+
+static struct gendisk *optcd_disk;
+
+
+static int cdromread(void __user *arg, int blocksize, int cmd)
+{
+ int status;
+ struct cdrom_msf msf;
+
+ if (copy_from_user(&msf, arg, sizeof msf))
+ return -EFAULT;
+
+ bin2bcd(&msf);
+ msf.cdmsf_min1 = 0;
+ msf.cdmsf_sec1 = 0;
+ msf.cdmsf_frame1 = 1; /* read only one frame */
+ status = exec_read_cmd(cmd, &msf);
+
+ DEBUG((DEBUG_VFS, "read cmd status 0x%x", status));
+
+ if (!sleep_flag_low(FL_DTEN, SLEEP_TIMEOUT))
+ return -EIO;
+
+ fetch_data(optcd_disk->private_data, blocksize);
+
+ if (copy_to_user(arg, optcd_disk->private_data, blocksize))
+ return -EFAULT;
+
+ return 0;
+}
+
+
+static int cdromseek(void __user *arg)
+{
+ int status;
+ struct cdrom_msf msf;
+
+ if (copy_from_user(&msf, arg, sizeof msf))
+ return -EFAULT;
+
+ bin2bcd(&msf);
+ status = exec_seek_cmd(COMSEEK, &msf);
+
+ DEBUG((DEBUG_VFS, "COMSEEK status 0x%x", status));
+
+ if (status < 0)
+ return -EIO;
+ return 0;
+}
+
+
+#ifdef MULTISESSION
+static int cdrommultisession(void __user *arg)
+{
+ struct cdrom_multisession ms;
+
+ if (copy_from_user(&ms, arg, sizeof ms))
+ return -EFAULT;
+
+ ms.addr.msf.minute = disk_info.last_session.minute;
+ ms.addr.msf.second = disk_info.last_session.second;
+ ms.addr.msf.frame = disk_info.last_session.frame;
+
+ if (ms.addr_format != CDROM_LBA
+ && ms.addr_format != CDROM_MSF)
+ return -EINVAL;
+ if (ms.addr_format == CDROM_LBA)
+ msf2lba(&ms.addr);
+
+ ms.xa_flag = disk_info.xa;
+
+ if (copy_to_user(arg, &ms, sizeof(struct cdrom_multisession)))
+ return -EFAULT;
+
+#if DEBUG_MULTIS
+ if (ms.addr_format == CDROM_MSF)
+ printk(KERN_DEBUG
+ "optcd: multisession xa:%d, msf:%02d:%02d.%02d\n",
+ ms.xa_flag,
+ ms.addr.msf.minute,
+ ms.addr.msf.second,
+ ms.addr.msf.frame);
+ else
+ printk(KERN_DEBUG
+ "optcd: multisession %d, lba:0x%08x [%02d:%02d.%02d])\n",
+ ms.xa_flag,
+ ms.addr.lba,
+ disk_info.last_session.minute,
+ disk_info.last_session.second,
+ disk_info.last_session.frame);
+#endif /* DEBUG_MULTIS */
+
+ return 0;
+}
+#endif /* MULTISESSION */
+
+
+static int cdromreset(void)
+{
+ if (state != S_IDLE) {
+ error = 1;
+ tries = 0;
+ }
+
+ toc_uptodate = 0;
+ disk_changed = 1;
+ opt_invalidate_buffers();
+ audio_status = CDROM_AUDIO_NO_STATUS;
+
+ if (!reset_drive())
+ return -EIO;
+ return 0;
+}
+
+/* VFS calls */
+
+
+static int opt_ioctl(struct inode *ip, struct file *fp,
+ unsigned int cmd, unsigned long arg)
+{
+ int status, err, retval = 0;
+ void __user *argp = (void __user *)arg;
+
+ DEBUG((DEBUG_VFS, "starting opt_ioctl"));
+
+ if (!ip)
+ return -EINVAL;
+
+ if (cmd == CDROMRESET)
+ return cdromreset();
+
+ /* is do_optcd_request or another ioctl busy? */
+ if (state != S_IDLE || in_vfs)
+ return -EBUSY;
+
+ in_vfs = 1;
+
+ status = drive_status();
+ if (status < 0) {
+ DEBUG((DEBUG_VFS, "drive_status: %02x", -status));
+ in_vfs = 0;
+ return -EIO;
+ }
+
+ if (status & ST_DOOR_OPEN)
+ switch (cmd) { /* Actions that can be taken with door open */
+ case CDROMCLOSETRAY:
+ /* We do this before trying to read the toc. */
+ err = exec_cmd(COMCLOSE);
+ if (err < 0) {
+ DEBUG((DEBUG_VFS,
+ "exec_cmd COMCLOSE: %02x", -err));
+ in_vfs = 0;
+ return -EIO;
+ }
+ break;
+ default: in_vfs = 0;
+ return -EBUSY;
+ }
+
+ err = update_toc();
+ if (err < 0) {
+ DEBUG((DEBUG_VFS, "update_toc: %02x", -err));
+ in_vfs = 0;
+ return -EIO;
+ }
+
+ DEBUG((DEBUG_VFS, "ioctl cmd 0x%x", cmd));
+
+ switch (cmd) {
+ case CDROMPAUSE: retval = cdrompause(); break;
+ case CDROMRESUME: retval = cdromresume(); break;
+ case CDROMPLAYMSF: retval = cdromplaymsf(argp); break;
+ case CDROMPLAYTRKIND: retval = cdromplaytrkind(argp); break;
+ case CDROMREADTOCHDR: retval = cdromreadtochdr(argp); break;
+ case CDROMREADTOCENTRY: retval = cdromreadtocentry(argp); break;
+
+ case CDROMSTOP: err = exec_cmd(COMSTOP);
+ if (err < 0) {
+ DEBUG((DEBUG_VFS,
+ "exec_cmd COMSTOP: %02x",
+ -err));
+ retval = -EIO;
+ } else
+ audio_status = CDROM_AUDIO_NO_STATUS;
+ break;
+ case CDROMSTART: break; /* This is a no-op */
+ case CDROMEJECT: err = exec_cmd(COMUNLOCK);
+ if (err < 0) {
+ DEBUG((DEBUG_VFS,
+ "exec_cmd COMUNLOCK: %02x",
+ -err));
+ retval = -EIO;
+ break;
+ }
+ err = exec_cmd(COMOPEN);
+ if (err < 0) {
+ DEBUG((DEBUG_VFS,
+ "exec_cmd COMOPEN: %02x",
+ -err));
+ retval = -EIO;
+ }
+ break;
+
+ case CDROMVOLCTRL: retval = cdromvolctrl(argp); break;
+ case CDROMSUBCHNL: retval = cdromsubchnl(argp); break;
+
+ /* The drive detects the mode and automatically delivers the
+ correct 2048 bytes, so we don't need these IOCTLs */
+ case CDROMREADMODE2: retval = -EINVAL; break;
+ case CDROMREADMODE1: retval = -EINVAL; break;
+
+ /* Drive doesn't support reading audio */
+ case CDROMREADAUDIO: retval = -EINVAL; break;
+
+ case CDROMEJECT_SW: auto_eject = (char) arg;
+ break;
+
+#ifdef MULTISESSION
+ case CDROMMULTISESSION: retval = cdrommultisession(argp); break;
+#endif
+
+ case CDROM_GET_MCN: retval = -EINVAL; break; /* not implemented */
+ case CDROMVOLREAD: retval = -EINVAL; break; /* not implemented */
+
+ case CDROMREADRAW:
+ /* this drive delivers 2340 bytes in raw mode */
+ retval = cdromread(argp, CD_FRAMESIZE_RAW1, COMREADRAW);
+ break;
+ case CDROMREADCOOKED:
+ retval = cdromread(argp, CD_FRAMESIZE, COMREAD);
+ break;
+ case CDROMREADALL:
+ retval = cdromread(argp, CD_FRAMESIZE_RAWER, COMREADALL);
+ break;
+
+ case CDROMSEEK: retval = cdromseek(argp); break;
+ case CDROMPLAYBLK: retval = -EINVAL; break; /* not implemented */
+ case CDROMCLOSETRAY: break; /* The action was taken earlier */
+ default: retval = -EINVAL;
+ }
+ in_vfs = 0;
+ return retval;
+}
+
+
+static int open_count = 0;
+
+/* Open device special file; check that a disk is in. */
+static int opt_open(struct inode *ip, struct file *fp)
+{
+ DEBUG((DEBUG_VFS, "starting opt_open"));
+
+ if (!open_count && state == S_IDLE) {
+ int status;
+ char *buf;
+
+ buf = kmalloc(CD_FRAMESIZE_RAWER, GFP_KERNEL);
+ if (!buf) {
+ printk(KERN_INFO "optcd: cannot allocate read buffer\n");
+ return -ENOMEM;
+ }
+ optcd_disk->private_data = buf; /* save read buffer */
+
+ toc_uptodate = 0;
+ opt_invalidate_buffers();
+
+ status = exec_cmd(COMCLOSE); /* close door */
+ if (status < 0) {
+ DEBUG((DEBUG_VFS, "exec_cmd COMCLOSE: %02x", -status));
+ }
+
+ status = drive_status();
+ if (status < 0) {
+ DEBUG((DEBUG_VFS, "drive_status: %02x", -status));
+ goto err_out;
+ }
+ DEBUG((DEBUG_VFS, "status: %02x", status));
+ if ((status & ST_DOOR_OPEN) || (status & ST_DRVERR)) {
+ printk(KERN_INFO "optcd: no disk or door open\n");
+ goto err_out;
+ }
+ status = exec_cmd(COMLOCK); /* Lock door */
+ if (status < 0) {
+ DEBUG((DEBUG_VFS, "exec_cmd COMLOCK: %02x", -status));
+ }
+ status = update_toc(); /* Read table of contents */
+ if (status < 0) {
+ DEBUG((DEBUG_VFS, "update_toc: %02x", -status));
+ status = exec_cmd(COMUNLOCK); /* Unlock door */
+ if (status < 0) {
+ DEBUG((DEBUG_VFS,
+ "exec_cmd COMUNLOCK: %02x", -status));
+ }
+ goto err_out;
+ }
+ open_count++;
+ }
+
+ DEBUG((DEBUG_VFS, "exiting opt_open"));
+
+ return 0;
+
+err_out:
+ return -EIO;
+}
+
+
+/* Release device special file; flush all blocks from the buffer cache */
+static int opt_release(struct inode *ip, struct file *fp)
+{
+ int status;
+
+ DEBUG((DEBUG_VFS, "executing opt_release"));
+ DEBUG((DEBUG_VFS, "inode: %p, device: %s, file: %p\n",
+ ip, ip->i_bdev->bd_disk->disk_name, fp));
+
+ if (!--open_count) {
+ toc_uptodate = 0;
+ opt_invalidate_buffers();
+ status = exec_cmd(COMUNLOCK); /* Unlock door */
+ if (status < 0) {
+ DEBUG((DEBUG_VFS, "exec_cmd COMUNLOCK: %02x", -status));
+ }
+ if (auto_eject) {
+ status = exec_cmd(COMOPEN);
+ DEBUG((DEBUG_VFS, "exec_cmd COMOPEN: %02x", -status));
+ }
+ kfree(optcd_disk->private_data);
+ del_timer(&delay_timer);
+ del_timer(&req_timer);
+ }
+ return 0;
+}
+
+
+/* Check if disk has been changed */
+static int opt_media_change(struct gendisk *disk)
+{
+ DEBUG((DEBUG_VFS, "executing opt_media_change"));
+ DEBUG((DEBUG_VFS, "dev: %s; disk_changed = %d\n",
+ disk->disk_name, disk_changed));
+
+ if (disk_changed) {
+ disk_changed = 0;
+ return 1;
+ }
+ return 0;
+}
+
+/* Driver initialisation */
+
+
+/* Returns 1 if a drive is detected with a version string
+ starting with "DOLPHIN". Otherwise 0. */
+static int __init version_ok(void)
+{
+ char devname[100];
+ int count, i, ch, status;
+
+ status = exec_cmd(COMVERSION);
+ if (status < 0) {
+ DEBUG((DEBUG_VFS, "exec_cmd COMVERSION: %02x", -status));
+ return 0;
+ }
+ if ((count = get_data(1)) < 0) {
+ DEBUG((DEBUG_VFS, "get_data(1): %02x", -count));
+ return 0;
+ }
+ for (i = 0, ch = -1; count > 0; count--) {
+ if ((ch = get_data(1)) < 0) {
+ DEBUG((DEBUG_VFS, "get_data(1): %02x", -ch));
+ break;
+ }
+ if (i < 99)
+ devname[i++] = ch;
+ }
+ devname[i] = '\0';
+ if (ch < 0)
+ return 0;
+
+ printk(KERN_INFO "optcd: Device %s detected\n", devname);
+ return ((devname[0] == 'D')
+ && (devname[1] == 'O')
+ && (devname[2] == 'L')
+ && (devname[3] == 'P')
+ && (devname[4] == 'H')
+ && (devname[5] == 'I')
+ && (devname[6] == 'N'));
+}
+
+
+static struct block_device_operations opt_fops = {
+ .owner = THIS_MODULE,
+ .open = opt_open,
+ .release = opt_release,
+ .ioctl = opt_ioctl,
+ .media_changed = opt_media_change,
+};
+
+#ifndef MODULE
+/* Get kernel parameter when used as a kernel driver */
+static int optcd_setup(char *str)
+{
+ int ints[4];
+ (void)get_options(str, ARRAY_SIZE(ints), ints);
+
+ if (ints[0] > 0)
+ optcd_port = ints[1];
+
+ return 1;
+}
+
+__setup("optcd=", optcd_setup);
+
+#endif /* MODULE */
+
+/* Test for presence of drive and initialize it. Called at boot time
+ or during module initialisation. */
+static int __init optcd_init(void)
+{
+ int status;
+
+ if (optcd_port <= 0) {
+ printk(KERN_INFO
+ "optcd: no Optics Storage CDROM Initialization\n");
+ return -EIO;
+ }
+ optcd_disk = alloc_disk(1);
+ if (!optcd_disk) {
+ printk(KERN_ERR "optcd: can't allocate disk\n");
+ return -ENOMEM;
+ }
+ optcd_disk->major = MAJOR_NR;
+ optcd_disk->first_minor = 0;
+ optcd_disk->fops = &opt_fops;
+ sprintf(optcd_disk->disk_name, "optcd");
+ sprintf(optcd_disk->devfs_name, "optcd");
+
+ if (!request_region(optcd_port, 4, "optcd")) {
+ printk(KERN_ERR "optcd: conflict, I/O port 0x%x already used\n",
+ optcd_port);
+ put_disk(optcd_disk);
+ return -EIO;
+ }
+
+ if (!reset_drive()) {
+ printk(KERN_ERR "optcd: drive at 0x%x not ready\n", optcd_port);
+ release_region(optcd_port, 4);
+ put_disk(optcd_disk);
+ return -EIO;
+ }
+ if (!version_ok()) {
+ printk(KERN_ERR "optcd: unknown drive detected; aborting\n");
+ release_region(optcd_port, 4);
+ put_disk(optcd_disk);
+ return -EIO;
+ }
+ status = exec_cmd(COMINITDOUBLE);
+ if (status < 0) {
+ printk(KERN_ERR "optcd: cannot init double speed mode\n");
+ release_region(optcd_port, 4);
+ DEBUG((DEBUG_VFS, "exec_cmd COMINITDOUBLE: %02x", -status));
+ put_disk(optcd_disk);
+ return -EIO;
+ }
+ if (register_blkdev(MAJOR_NR, "optcd")) {
+ release_region(optcd_port, 4);
+ put_disk(optcd_disk);
+ return -EIO;
+ }
+
+
+ opt_queue = blk_init_queue(do_optcd_request, &optcd_lock);
+ if (!opt_queue) {
+ unregister_blkdev(MAJOR_NR, "optcd");
+ release_region(optcd_port, 4);
+ put_disk(optcd_disk);
+ return -ENOMEM;
+ }
+
+ blk_queue_hardsect_size(opt_queue, 2048);
+ optcd_disk->queue = opt_queue;
+ add_disk(optcd_disk);
+
+ printk(KERN_INFO "optcd: DOLPHIN 8000 AT CDROM at 0x%x\n", optcd_port);
+ return 0;
+}
+
+
+static void __exit optcd_exit(void)
+{
+ del_gendisk(optcd_disk);
+ put_disk(optcd_disk);
+ if (unregister_blkdev(MAJOR_NR, "optcd") == -EINVAL) {
+ printk(KERN_ERR "optcd: what's that: can't unregister\n");
+ return;
+ }
+ blk_cleanup_queue(opt_queue);
+ release_region(optcd_port, 4);
+ printk(KERN_INFO "optcd: module released.\n");
+}
+
+module_init(optcd_init);
+module_exit(optcd_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_BLOCKDEV_MAJOR(OPTICS_CDROM_MAJOR);