/* 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(kdev_t dev, 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(kdev_t dev)
{
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(kdev_t dev, 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(kdev_t dev, 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(kdev_t dev)
{
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(kdev_t dev)
{
if (cd) return cd->openfiles;
return -1;
}
/* controls tray movement */
int cm206_tray_move(kdev_t dev, 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(kdev_t dev)
{
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(kdev_t dev)
{
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(kdev_t dev, 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(kdev_t dev, 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(kdev_t dev, 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(kdev_t dev)
{
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_open_files, /* number of open_files */
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 */
0, /* mask flags */
2, /* maximum speed */
1, /* number of minor devices */
1, /* number of discs */
0, /* options, ignored */
0 /* mc_flags, ignored */
};
/* 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(MAJOR_NR, "cm206")) {
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(MAJOR_NR, "cm206", &cm206_dops) != 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:
*/
