1690 lines
48 KiB
C
1690 lines
48 KiB
C
/*
|
|
* Sony CDU-535 interface device driver
|
|
*
|
|
* This is a modified version of the CDU-31A device driver (see below).
|
|
* Changes were made using documentation for the CDU-531 (which Sony
|
|
* assures me is very similar to the 535) and partial disassembly of the
|
|
* DOS driver. I used Minyard's driver and replaced the CDU-31A
|
|
* commands with the CDU-531 commands. This was complicated by a different
|
|
* interface protocol with the drive. The driver is still polled.
|
|
*
|
|
* Data transfer rate is about 110 Kb/sec, theoretical maximum is 150 Kb/sec.
|
|
* I tried polling without the sony_sleep during the data transfers but
|
|
* it did not speed things up any.
|
|
*
|
|
* 1993-05-23 (rgj) changed the major number to 21 to get rid of conflict
|
|
* with CDU-31A driver. This is the also the number from the Linux
|
|
* Device Driver Registry for the Sony Drive. Hope nobody else is using it.
|
|
*
|
|
* 1993-08-29 (rgj) remove the configuring of the interface board address
|
|
* from the top level configuration, you have to modify it in this file.
|
|
*
|
|
* 1995-01-26 Made module-capable (Joel Katz <Stimpson@Panix.COM>)
|
|
*
|
|
* 1995-05-20
|
|
* Modified to support CDU-510/515 series
|
|
* (Claudio Porfiri<C.Porfiri@nisms.tei.ericsson.se>)
|
|
* Fixed to report verify_area() failures
|
|
* (Heiko Eissfeldt <heiko@colossus.escape.de>)
|
|
*
|
|
* 1995-06-01
|
|
* More changes to support CDU-510/515 series
|
|
* (Claudio Porfiri<C.Porfiri@nisms.tei.ericsson.se>)
|
|
*
|
|
* November 1999 -- 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>
|
|
*
|
|
* September 2003 - Fix SMP support by removing cli/sti calls.
|
|
* Using spinlocks with a wait_queue instead.
|
|
* Felipe Damasio <felipewd@terra.com.br>
|
|
*
|
|
* Things to do:
|
|
* - handle errors and status better, put everything into a single word
|
|
* - use interrupts (code mostly there, but a big hole still missing)
|
|
* - handle multi-session CDs?
|
|
* - use DMA?
|
|
*
|
|
* Known Bugs:
|
|
* -
|
|
*
|
|
* Ken Pizzini (ken@halcyon.com)
|
|
*
|
|
* Original by:
|
|
* Ron Jeppesen (ronj.an@site007.saic.com)
|
|
*
|
|
*
|
|
*------------------------------------------------------------------------
|
|
* Sony CDROM interface device driver.
|
|
*
|
|
* Corey Minyard (minyard@wf-rch.cirr.com) (CDU-535 complaints to Ken above)
|
|
*
|
|
* Colossians 3:17
|
|
*
|
|
* The Sony interface device driver handles Sony interface CDROM
|
|
* drives and provides a complete block-level interface as well as an
|
|
* ioctl() interface compatible with the Sun (as specified in
|
|
* include/linux/cdrom.h). With this interface, CDROMs can be
|
|
* accessed and standard audio CDs can be played back normally.
|
|
*
|
|
* This interface is (unfortunately) a polled interface. This is
|
|
* because most Sony interfaces are set up with DMA and interrupts
|
|
* disables. Some (like mine) do not even have the capability to
|
|
* handle interrupts or DMA. For this reason you will see a bit of
|
|
* the following:
|
|
*
|
|
* snap = jiffies;
|
|
* while (jiffies-snap < SONY_JIFFIES_TIMEOUT)
|
|
* {
|
|
* if (some_condition())
|
|
* break;
|
|
* sony_sleep();
|
|
* }
|
|
* if (some_condition not met)
|
|
* {
|
|
* return an_error;
|
|
* }
|
|
*
|
|
* This ugly hack waits for something to happen, sleeping a little
|
|
* between every try. (The conditional is written so that jiffies
|
|
* wrap-around is handled properly.)
|
|
*
|
|
* One thing about these drives: They talk in MSF (Minute Second Frame) format.
|
|
* There are 75 frames a second, 60 seconds a minute, and up to 75 minutes on a
|
|
* disk. The funny thing is that these are sent to the drive in BCD, but the
|
|
* interface wants to see them in decimal. A lot of conversion goes on.
|
|
*
|
|
* Copyright (C) 1993 Corey Minyard
|
|
*
|
|
* 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.
|
|
*
|
|
*/
|
|
|
|
|
|
# include <linux/module.h>
|
|
|
|
#include <linux/errno.h>
|
|
#include <linux/signal.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/hdreg.h>
|
|
#include <linux/genhd.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/init.h>
|
|
|
|
#define REALLY_SLOW_IO
|
|
#include <asm/system.h>
|
|
#include <asm/io.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <linux/cdrom.h>
|
|
|
|
#define MAJOR_NR CDU535_CDROM_MAJOR
|
|
#include <linux/blkdev.h>
|
|
|
|
#define sony535_cd_base_io sonycd535 /* for compatible parameter passing with "insmod" */
|
|
#include "sonycd535.h"
|
|
|
|
/*
|
|
* this is the base address of the interface card for the Sony CDU-535
|
|
* CDROM drive. If your jumpers are set for an address other than
|
|
* this one (the default), change the following line to the
|
|
* proper address.
|
|
*/
|
|
#ifndef CDU535_ADDRESS
|
|
# define CDU535_ADDRESS 0x340
|
|
#endif
|
|
#ifndef CDU535_INTERRUPT
|
|
# define CDU535_INTERRUPT 0
|
|
#endif
|
|
#ifndef CDU535_HANDLE
|
|
# define CDU535_HANDLE "cdu535"
|
|
#endif
|
|
#ifndef CDU535_MESSAGE_NAME
|
|
# define CDU535_MESSAGE_NAME "Sony CDU-535"
|
|
#endif
|
|
|
|
#define CDU535_BLOCK_SIZE 2048
|
|
|
|
#ifndef MAX_SPINUP_RETRY
|
|
# define MAX_SPINUP_RETRY 3 /* 1 is sufficient for most drives... */
|
|
#endif
|
|
#ifndef RETRY_FOR_BAD_STATUS
|
|
# define RETRY_FOR_BAD_STATUS 100 /* in 10th of second */
|
|
#endif
|
|
|
|
#ifndef DEBUG
|
|
# define DEBUG 1
|
|
#endif
|
|
|
|
/*
|
|
* SONY535_BUFFER_SIZE determines the size of internal buffer used
|
|
* by the drive. It must be at least 2K and the larger the buffer
|
|
* the better the transfer rate. It does however take system memory.
|
|
* On my system I get the following transfer rates using dd to read
|
|
* 10 Mb off /dev/cdrom.
|
|
*
|
|
* 8K buffer 43 Kb/sec
|
|
* 16K buffer 66 Kb/sec
|
|
* 32K buffer 91 Kb/sec
|
|
* 64K buffer 111 Kb/sec
|
|
* 128K buffer 123 Kb/sec
|
|
* 512K buffer 123 Kb/sec
|
|
*/
|
|
#define SONY535_BUFFER_SIZE (64*1024)
|
|
|
|
/*
|
|
* if LOCK_DOORS is defined then the eject button is disabled while
|
|
* the device is open.
|
|
*/
|
|
#ifndef NO_LOCK_DOORS
|
|
# define LOCK_DOORS
|
|
#endif
|
|
|
|
static int read_subcode(void);
|
|
static void sony_get_toc(void);
|
|
static int cdu_open(struct inode *inode, struct file *filp);
|
|
static inline unsigned int int_to_bcd(unsigned int val);
|
|
static unsigned int bcd_to_int(unsigned int bcd);
|
|
static int do_sony_cmd(Byte * cmd, int nCmd, Byte status[2],
|
|
Byte * response, int n_response, int ignoreStatusBit7);
|
|
|
|
/* The base I/O address of the Sony Interface. This is a variable (not a
|
|
#define) so it can be easily changed via some future ioctl() */
|
|
static unsigned int sony535_cd_base_io = CDU535_ADDRESS;
|
|
module_param(sony535_cd_base_io, int, 0);
|
|
|
|
/*
|
|
* The following are I/O addresses of the various registers for the drive. The
|
|
* comment for the base address also applies here.
|
|
*/
|
|
static unsigned short select_unit_reg;
|
|
static unsigned short result_reg;
|
|
static unsigned short command_reg;
|
|
static unsigned short read_status_reg;
|
|
static unsigned short data_reg;
|
|
|
|
static DEFINE_SPINLOCK(sonycd535_lock); /* queue lock */
|
|
static struct request_queue *sonycd535_queue;
|
|
|
|
static int initialized; /* Has the drive been initialized? */
|
|
static int sony_disc_changed = 1; /* Has the disk been changed
|
|
since the last check? */
|
|
static int sony_toc_read; /* Has the table of contents been
|
|
read? */
|
|
static unsigned int sony_buffer_size; /* Size in bytes of the read-ahead
|
|
buffer. */
|
|
static unsigned int sony_buffer_sectors; /* Size (in 2048 byte records) of
|
|
the read-ahead buffer. */
|
|
static unsigned int sony_usage; /* How many processes have the
|
|
drive open. */
|
|
|
|
static int sony_first_block = -1; /* First OS block (512 byte) in
|
|
the read-ahead buffer */
|
|
static int sony_last_block = -1; /* Last OS block (512 byte) in
|
|
the read-ahead buffer */
|
|
|
|
static struct s535_sony_toc *sony_toc; /* Points to the table of
|
|
contents. */
|
|
|
|
static struct s535_sony_subcode *last_sony_subcode; /* Points to the last
|
|
subcode address read */
|
|
static Byte **sony_buffer; /* Points to the pointers
|
|
to the sector buffers */
|
|
|
|
static int sony_inuse; /* is the drive in use? Only one
|
|
open at a time allowed */
|
|
|
|
/*
|
|
* The audio status uses the values from read subchannel data as specified
|
|
* in include/linux/cdrom.h.
|
|
*/
|
|
static int sony_audio_status = CDROM_AUDIO_NO_STATUS;
|
|
|
|
/*
|
|
* The following are a hack for pausing and resuming audio play. The drive
|
|
* does not work as I would expect it, if you stop it then start it again,
|
|
* the drive seeks back to the beginning and starts over. This holds the
|
|
* position during a pause so a resume can restart it. It uses the
|
|
* audio status variable above to tell if it is paused.
|
|
* I just kept the CDU-31A driver behavior rather than using the PAUSE
|
|
* command on the CDU-535.
|
|
*/
|
|
static Byte cur_pos_msf[3];
|
|
static Byte final_pos_msf[3];
|
|
|
|
/* What IRQ is the drive using? 0 if none. */
|
|
static int sony535_irq_used = CDU535_INTERRUPT;
|
|
|
|
/* The interrupt handler will wake this queue up when it gets an interrupt. */
|
|
static DECLARE_WAIT_QUEUE_HEAD(cdu535_irq_wait);
|
|
|
|
|
|
/*
|
|
* This routine returns 1 if the disk has been changed since the last
|
|
* check or 0 if it hasn't. Setting flag to 0 resets the changed flag.
|
|
*/
|
|
static int
|
|
cdu535_check_media_change(struct gendisk *disk)
|
|
{
|
|
/* if driver is not initialized, always return 0 */
|
|
int retval = initialized ? sony_disc_changed : 0;
|
|
sony_disc_changed = 0;
|
|
return retval;
|
|
}
|
|
|
|
static inline void
|
|
enable_interrupts(void)
|
|
{
|
|
#ifdef USE_IRQ
|
|
/*
|
|
* This code was taken from cdu31a.c; it will not
|
|
* directly work for the cdu535 as written...
|
|
*/
|
|
curr_control_reg |= ( SONY_ATTN_INT_EN_BIT
|
|
| SONY_RES_RDY_INT_EN_BIT
|
|
| SONY_DATA_RDY_INT_EN_BIT);
|
|
outb(curr_control_reg, sony_cd_control_reg);
|
|
#endif
|
|
}
|
|
|
|
static inline void
|
|
disable_interrupts(void)
|
|
{
|
|
#ifdef USE_IRQ
|
|
/*
|
|
* This code was taken from cdu31a.c; it will not
|
|
* directly work for the cdu535 as written...
|
|
*/
|
|
curr_control_reg &= ~(SONY_ATTN_INT_EN_BIT
|
|
| SONY_RES_RDY_INT_EN_BIT
|
|
| SONY_DATA_RDY_INT_EN_BIT);
|
|
outb(curr_control_reg, sony_cd_control_reg);
|
|
#endif
|
|
}
|
|
|
|
static irqreturn_t
|
|
cdu535_interrupt(int irq, void *dev_id)
|
|
{
|
|
disable_interrupts();
|
|
if (waitqueue_active(&cdu535_irq_wait)) {
|
|
wake_up(&cdu535_irq_wait);
|
|
return IRQ_HANDLED;
|
|
}
|
|
printk(CDU535_MESSAGE_NAME
|
|
": Got an interrupt but nothing was waiting\n");
|
|
return IRQ_NONE;
|
|
}
|
|
|
|
|
|
/*
|
|
* Wait a little while.
|
|
*/
|
|
static inline void
|
|
sony_sleep(void)
|
|
{
|
|
if (sony535_irq_used <= 0) { /* poll */
|
|
yield();
|
|
} else { /* Interrupt driven */
|
|
DEFINE_WAIT(wait);
|
|
|
|
spin_lock_irq(&sonycd535_lock);
|
|
enable_interrupts();
|
|
prepare_to_wait(&cdu535_irq_wait, &wait, TASK_INTERRUPTIBLE);
|
|
spin_unlock_irq(&sonycd535_lock);
|
|
schedule();
|
|
finish_wait(&cdu535_irq_wait, &wait);
|
|
}
|
|
}
|
|
|
|
/*------------------start of SONY CDU535 very specific ---------------------*/
|
|
|
|
/****************************************************************************
|
|
* void select_unit( int unit_no )
|
|
*
|
|
* Select the specified unit (0-3) so that subsequent commands reference it
|
|
****************************************************************************/
|
|
static void
|
|
select_unit(int unit_no)
|
|
{
|
|
unsigned int select_mask = ~(1 << unit_no);
|
|
outb(select_mask, select_unit_reg);
|
|
}
|
|
|
|
/***************************************************************************
|
|
* int read_result_reg( Byte *data_ptr )
|
|
*
|
|
* Read a result byte from the Sony CDU controller, store in location pointed
|
|
* to by data_ptr. Return zero on success, TIME_OUT if we did not receive
|
|
* data.
|
|
***************************************************************************/
|
|
static int
|
|
read_result_reg(Byte *data_ptr)
|
|
{
|
|
unsigned long snap;
|
|
int read_status;
|
|
|
|
snap = jiffies;
|
|
while (jiffies-snap < SONY_JIFFIES_TIMEOUT) {
|
|
read_status = inb(read_status_reg);
|
|
if ((read_status & SONY535_RESULT_NOT_READY_BIT) == 0) {
|
|
#if DEBUG > 1
|
|
printk(CDU535_MESSAGE_NAME
|
|
": read_result_reg(): readStatReg = 0x%x\n", read_status);
|
|
#endif
|
|
*data_ptr = inb(result_reg);
|
|
return 0;
|
|
} else {
|
|
sony_sleep();
|
|
}
|
|
}
|
|
printk(CDU535_MESSAGE_NAME " read_result_reg: TIME OUT!\n");
|
|
return TIME_OUT;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* int read_exec_status( Byte status[2] )
|
|
*
|
|
* Read the execution status of the last command and put into status.
|
|
* Handles reading second status word if available. Returns 0 on success,
|
|
* TIME_OUT on failure.
|
|
****************************************************************************/
|
|
static int
|
|
read_exec_status(Byte status[2])
|
|
{
|
|
status[1] = 0;
|
|
if (read_result_reg(&(status[0])) != 0)
|
|
return TIME_OUT;
|
|
if ((status[0] & 0x80) != 0) { /* byte two follows */
|
|
if (read_result_reg(&(status[1])) != 0)
|
|
return TIME_OUT;
|
|
}
|
|
#if DEBUG > 1
|
|
printk(CDU535_MESSAGE_NAME ": read_exec_status: read 0x%x 0x%x\n",
|
|
status[0], status[1]);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* int check_drive_status( void )
|
|
*
|
|
* Check the current drive status. Using this before executing a command
|
|
* takes care of the problem of unsolicited drive status-2 messages.
|
|
* Add a check of the audio status if we think the disk is playing.
|
|
****************************************************************************/
|
|
static int
|
|
check_drive_status(void)
|
|
{
|
|
Byte status, e_status[2];
|
|
int CDD, ATN;
|
|
Byte cmd;
|
|
|
|
select_unit(0);
|
|
if (sony_audio_status == CDROM_AUDIO_PLAY) { /* check status */
|
|
outb(SONY535_REQUEST_AUDIO_STATUS, command_reg);
|
|
if (read_result_reg(&status) == 0) {
|
|
switch (status) {
|
|
case 0x0:
|
|
break; /* play in progress */
|
|
case 0x1:
|
|
break; /* paused */
|
|
case 0x3: /* audio play completed */
|
|
case 0x5: /* play not requested */
|
|
sony_audio_status = CDROM_AUDIO_COMPLETED;
|
|
read_subcode();
|
|
break;
|
|
case 0x4: /* error during play */
|
|
sony_audio_status = CDROM_AUDIO_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
/* now check drive status */
|
|
outb(SONY535_REQUEST_DRIVE_STATUS_2, command_reg);
|
|
if (read_result_reg(&status) != 0)
|
|
return TIME_OUT;
|
|
|
|
#if DEBUG > 1
|
|
printk(CDU535_MESSAGE_NAME ": check_drive_status() got 0x%x\n", status);
|
|
#endif
|
|
|
|
if (status == 0)
|
|
return 0;
|
|
|
|
ATN = status & 0xf;
|
|
CDD = (status >> 4) & 0xf;
|
|
|
|
switch (ATN) {
|
|
case 0x0:
|
|
break; /* go on to CDD stuff */
|
|
case SONY535_ATN_BUSY:
|
|
if (initialized)
|
|
printk(CDU535_MESSAGE_NAME " error: drive busy\n");
|
|
return CD_BUSY;
|
|
case SONY535_ATN_EJECT_IN_PROGRESS:
|
|
printk(CDU535_MESSAGE_NAME " error: eject in progress\n");
|
|
sony_audio_status = CDROM_AUDIO_INVALID;
|
|
return CD_BUSY;
|
|
case SONY535_ATN_RESET_OCCURRED:
|
|
case SONY535_ATN_DISC_CHANGED:
|
|
case SONY535_ATN_RESET_AND_DISC_CHANGED:
|
|
#if DEBUG > 0
|
|
printk(CDU535_MESSAGE_NAME " notice: reset occurred or disc changed\n");
|
|
#endif
|
|
sony_disc_changed = 1;
|
|
sony_toc_read = 0;
|
|
sony_audio_status = CDROM_AUDIO_NO_STATUS;
|
|
sony_first_block = -1;
|
|
sony_last_block = -1;
|
|
if (initialized) {
|
|
cmd = SONY535_SPIN_UP;
|
|
do_sony_cmd(&cmd, 1, e_status, NULL, 0, 0);
|
|
sony_get_toc();
|
|
}
|
|
return 0;
|
|
default:
|
|
printk(CDU535_MESSAGE_NAME " error: drive busy (ATN=0x%x)\n", ATN);
|
|
return CD_BUSY;
|
|
}
|
|
switch (CDD) { /* the 531 docs are not helpful in decoding this */
|
|
case 0x0: /* just use the values from the DOS driver */
|
|
case 0x2:
|
|
case 0xa:
|
|
break; /* no error */
|
|
case 0xc:
|
|
printk(CDU535_MESSAGE_NAME
|
|
": check_drive_status(): CDD = 0xc! Not properly handled!\n");
|
|
return CD_BUSY; /* ? */
|
|
default:
|
|
return CD_BUSY;
|
|
}
|
|
return 0;
|
|
} /* check_drive_status() */
|
|
|
|
/*****************************************************************************
|
|
* int do_sony_cmd( Byte *cmd, int n_cmd, Byte status[2],
|
|
* Byte *response, int n_response, int ignore_status_bit7 )
|
|
*
|
|
* Generic routine for executing commands. The command and its parameters
|
|
* should be placed in the cmd[] array, number of bytes in the command is
|
|
* stored in nCmd. The response from the command will be stored in the
|
|
* response array. The number of bytes you expect back (excluding status)
|
|
* should be passed in n_response. Finally, some
|
|
* commands set bit 7 of the return status even when there is no second
|
|
* status byte, on these commands set ignoreStatusBit7 TRUE.
|
|
* If the command was sent and data received back, then we return 0,
|
|
* else we return TIME_OUT. You still have to check the status yourself.
|
|
* You should call check_drive_status() before calling this routine
|
|
* so that you do not lose notifications of disk changes, etc.
|
|
****************************************************************************/
|
|
static int
|
|
do_sony_cmd(Byte * cmd, int n_cmd, Byte status[2],
|
|
Byte * response, int n_response, int ignore_status_bit7)
|
|
{
|
|
int i;
|
|
|
|
/* write out the command */
|
|
for (i = 0; i < n_cmd; i++)
|
|
outb(cmd[i], command_reg);
|
|
|
|
/* read back the status */
|
|
if (read_result_reg(status) != 0)
|
|
return TIME_OUT;
|
|
if (!ignore_status_bit7 && ((status[0] & 0x80) != 0)) {
|
|
/* get second status byte */
|
|
if (read_result_reg(status + 1) != 0)
|
|
return TIME_OUT;
|
|
} else {
|
|
status[1] = 0;
|
|
}
|
|
#if DEBUG > 2
|
|
printk(CDU535_MESSAGE_NAME ": do_sony_cmd %x: %x %x\n",
|
|
*cmd, status[0], status[1]);
|
|
#endif
|
|
|
|
/* do not know about when I should read set of data and when not to */
|
|
if ((status[0] & ((ignore_status_bit7 ? 0x7f : 0xff) & 0x8f)) != 0)
|
|
return 0;
|
|
|
|
/* else, read in rest of data */
|
|
for (i = 0; 0 < n_response; n_response--, i++)
|
|
if (read_result_reg(response + i) != 0)
|
|
return TIME_OUT;
|
|
return 0;
|
|
} /* do_sony_cmd() */
|
|
|
|
/**************************************************************************
|
|
* int set_drive_mode( int mode, Byte status[2] )
|
|
*
|
|
* Set the drive mode to the specified value (mode=0 is audio, mode=e0
|
|
* is mode-1 CDROM
|
|
**************************************************************************/
|
|
static int
|
|
set_drive_mode(int mode, Byte status[2])
|
|
{
|
|
Byte cmd_buff[2];
|
|
Byte ret_buff[1];
|
|
|
|
cmd_buff[0] = SONY535_SET_DRIVE_MODE;
|
|
cmd_buff[1] = mode;
|
|
return do_sony_cmd(cmd_buff, 2, status, ret_buff, 1, 1);
|
|
}
|
|
|
|
/***************************************************************************
|
|
* int seek_and_read_N_blocks( Byte params[], int n_blocks, Byte status[2],
|
|
* Byte *data_buff, int buff_size )
|
|
*
|
|
* Read n_blocks of data from the CDROM starting at position params[0:2],
|
|
* number of blocks in stored in params[3:5] -- both these are already
|
|
* int bcd format.
|
|
* Transfer the data into the buffer pointed at by data_buff. buff_size
|
|
* gives the number of bytes available in the buffer.
|
|
* The routine returns number of bytes read in if successful, otherwise
|
|
* it returns one of the standard error returns.
|
|
***************************************************************************/
|
|
static int
|
|
seek_and_read_N_blocks(Byte params[], int n_blocks, Byte status[2],
|
|
Byte **buff, int buf_size)
|
|
{
|
|
Byte cmd_buff[7];
|
|
int i;
|
|
int read_status;
|
|
unsigned long snap;
|
|
Byte *data_buff;
|
|
int sector_count = 0;
|
|
|
|
if (buf_size < CDU535_BLOCK_SIZE * n_blocks)
|
|
return NO_ROOM;
|
|
|
|
set_drive_mode(SONY535_CDROM_DRIVE_MODE, status);
|
|
|
|
/* send command to read the data */
|
|
cmd_buff[0] = SONY535_SEEK_AND_READ_N_BLOCKS_1;
|
|
for (i = 0; i < 6; i++)
|
|
cmd_buff[i + 1] = params[i];
|
|
for (i = 0; i < 7; i++)
|
|
outb(cmd_buff[i], command_reg);
|
|
|
|
/* read back the data one block at a time */
|
|
while (0 < n_blocks--) {
|
|
/* wait for data to be ready */
|
|
int data_valid = 0;
|
|
snap = jiffies;
|
|
while (jiffies-snap < SONY_JIFFIES_TIMEOUT) {
|
|
read_status = inb(read_status_reg);
|
|
if ((read_status & SONY535_RESULT_NOT_READY_BIT) == 0) {
|
|
read_exec_status(status);
|
|
return BAD_STATUS;
|
|
}
|
|
if ((read_status & SONY535_DATA_NOT_READY_BIT) == 0) {
|
|
/* data is ready, read it */
|
|
data_buff = buff[sector_count++];
|
|
for (i = 0; i < CDU535_BLOCK_SIZE; i++)
|
|
*data_buff++ = inb(data_reg); /* unrolling this loop does not seem to help */
|
|
data_valid = 1;
|
|
break; /* exit the timeout loop */
|
|
}
|
|
sony_sleep(); /* data not ready, sleep a while */
|
|
}
|
|
if (!data_valid)
|
|
return TIME_OUT; /* if we reach this stage */
|
|
}
|
|
|
|
/* read all the data, now read the status */
|
|
if ((i = read_exec_status(status)) != 0)
|
|
return i;
|
|
return CDU535_BLOCK_SIZE * sector_count;
|
|
} /* seek_and_read_N_blocks() */
|
|
|
|
/****************************************************************************
|
|
* int request_toc_data( Byte status[2], struct s535_sony_toc *toc )
|
|
*
|
|
* Read in the table of contents data. Converts all the bcd data
|
|
* into integers in the toc structure.
|
|
****************************************************************************/
|
|
static int
|
|
request_toc_data(Byte status[2], struct s535_sony_toc *toc)
|
|
{
|
|
int to_status;
|
|
int i, j, n_tracks, track_no;
|
|
int first_track_num, last_track_num;
|
|
Byte cmd_no = 0xb2;
|
|
Byte track_address_buffer[5];
|
|
|
|
/* read the fixed portion of the table of contents */
|
|
if ((to_status = do_sony_cmd(&cmd_no, 1, status, (Byte *) toc, 15, 1)) != 0)
|
|
return to_status;
|
|
|
|
/* convert the data into integers so we can use them */
|
|
first_track_num = bcd_to_int(toc->first_track_num);
|
|
last_track_num = bcd_to_int(toc->last_track_num);
|
|
n_tracks = last_track_num - first_track_num + 1;
|
|
|
|
/* read each of the track address descriptors */
|
|
for (i = 0; i < n_tracks; i++) {
|
|
/* read the descriptor into a temporary buffer */
|
|
for (j = 0; j < 5; j++) {
|
|
if (read_result_reg(track_address_buffer + j) != 0)
|
|
return TIME_OUT;
|
|
if (j == 1) /* need to convert from bcd */
|
|
track_no = bcd_to_int(track_address_buffer[j]);
|
|
}
|
|
/* copy the descriptor to proper location - sonycd.c just fills */
|
|
memcpy(toc->tracks + i, track_address_buffer, 5);
|
|
}
|
|
return 0;
|
|
} /* request_toc_data() */
|
|
|
|
/***************************************************************************
|
|
* int spin_up_drive( Byte status[2] )
|
|
*
|
|
* Spin up the drive (unless it is already spinning).
|
|
***************************************************************************/
|
|
static int
|
|
spin_up_drive(Byte status[2])
|
|
{
|
|
Byte cmd;
|
|
|
|
/* first see if the drive is already spinning */
|
|
cmd = SONY535_REQUEST_DRIVE_STATUS_1;
|
|
if (do_sony_cmd(&cmd, 1, status, NULL, 0, 0) != 0)
|
|
return TIME_OUT;
|
|
if ((status[0] & SONY535_STATUS1_NOT_SPINNING) == 0)
|
|
return 0; /* it's already spinning */
|
|
|
|
/* otherwise, give the spin-up command */
|
|
cmd = SONY535_SPIN_UP;
|
|
return do_sony_cmd(&cmd, 1, status, NULL, 0, 0);
|
|
}
|
|
|
|
/*--------------------end of SONY CDU535 very specific ---------------------*/
|
|
|
|
/* Convert from an integer 0-99 to BCD */
|
|
static inline unsigned int
|
|
int_to_bcd(unsigned int val)
|
|
{
|
|
int retval;
|
|
|
|
retval = (val / 10) << 4;
|
|
retval = retval | val % 10;
|
|
return retval;
|
|
}
|
|
|
|
|
|
/* Convert from BCD to an integer from 0-99 */
|
|
static unsigned int
|
|
bcd_to_int(unsigned int bcd)
|
|
{
|
|
return (((bcd >> 4) & 0x0f) * 10) + (bcd & 0x0f);
|
|
}
|
|
|
|
|
|
/*
|
|
* Convert a logical sector value (like the OS would want to use for
|
|
* a block device) to an MSF format.
|
|
*/
|
|
static void
|
|
log_to_msf(unsigned int log, Byte *msf)
|
|
{
|
|
log = log + LOG_START_OFFSET;
|
|
msf[0] = int_to_bcd(log / 4500);
|
|
log = log % 4500;
|
|
msf[1] = int_to_bcd(log / 75);
|
|
msf[2] = int_to_bcd(log % 75);
|
|
}
|
|
|
|
|
|
/*
|
|
* Convert an MSF format to a logical sector.
|
|
*/
|
|
static unsigned int
|
|
msf_to_log(Byte *msf)
|
|
{
|
|
unsigned int log;
|
|
|
|
|
|
log = bcd_to_int(msf[2]);
|
|
log += bcd_to_int(msf[1]) * 75;
|
|
log += bcd_to_int(msf[0]) * 4500;
|
|
log = log - LOG_START_OFFSET;
|
|
|
|
return log;
|
|
}
|
|
|
|
|
|
/*
|
|
* Take in integer size value and put it into a buffer like
|
|
* the drive would want to see a number-of-sector value.
|
|
*/
|
|
static void
|
|
size_to_buf(unsigned int size, Byte *buf)
|
|
{
|
|
buf[0] = size / 65536;
|
|
size = size % 65536;
|
|
buf[1] = size / 256;
|
|
buf[2] = size % 256;
|
|
}
|
|
|
|
|
|
/*
|
|
* The OS calls this to perform a read or write operation to the drive.
|
|
* Write obviously fail. Reads to a read ahead of sony_buffer_size
|
|
* bytes to help speed operations. This especially helps since the OS
|
|
* may use 1024 byte blocks and the drive uses 2048 byte blocks. Since most
|
|
* data access on a CD is done sequentially, this saves a lot of operations.
|
|
*/
|
|
static void
|
|
do_cdu535_request(request_queue_t * q)
|
|
{
|
|
struct request *req;
|
|
unsigned int read_size;
|
|
int block;
|
|
int nsect;
|
|
int copyoff;
|
|
int spin_up_retry;
|
|
Byte params[10];
|
|
Byte status[2];
|
|
Byte cmd[2];
|
|
|
|
while (1) {
|
|
req = elv_next_request(q);
|
|
if (!req)
|
|
return;
|
|
|
|
block = req->sector;
|
|
nsect = req->nr_sectors;
|
|
if (!blk_fs_request(req)) {
|
|
end_request(req, 0);
|
|
continue;
|
|
}
|
|
if (rq_data_dir(req) == WRITE) {
|
|
end_request(req, 0);
|
|
continue;
|
|
}
|
|
/*
|
|
* If the block address is invalid or the request goes beyond
|
|
* the end of the media, return an error.
|
|
*/
|
|
if (sony_toc->lead_out_start_lba <= (block/4)) {
|
|
end_request(req, 0);
|
|
return;
|
|
}
|
|
if (sony_toc->lead_out_start_lba <= ((block + nsect) / 4)) {
|
|
end_request(req, 0);
|
|
return;
|
|
}
|
|
while (0 < nsect) {
|
|
/*
|
|
* If the requested sector is not currently in
|
|
* the read-ahead buffer, it must be read in.
|
|
*/
|
|
if ((block < sony_first_block) || (sony_last_block < block)) {
|
|
sony_first_block = (block / 4) * 4;
|
|
log_to_msf(block / 4, params);
|
|
|
|
/*
|
|
* If the full read-ahead would go beyond the end of the media, trim
|
|
* it back to read just till the end of the media.
|
|
*/
|
|
if (sony_toc->lead_out_start_lba <= ((block / 4) + sony_buffer_sectors)) {
|
|
sony_last_block = (sony_toc->lead_out_start_lba * 4) - 1;
|
|
read_size = sony_toc->lead_out_start_lba - (block / 4);
|
|
} else {
|
|
sony_last_block = sony_first_block + (sony_buffer_sectors * 4) - 1;
|
|
read_size = sony_buffer_sectors;
|
|
}
|
|
size_to_buf(read_size, ¶ms[3]);
|
|
|
|
/*
|
|
* Read the data. If the drive was not spinning,
|
|
* spin it up and try some more.
|
|
*/
|
|
for (spin_up_retry=0 ;; ++spin_up_retry) {
|
|
/* This loop has been modified to support the Sony
|
|
* CDU-510/515 series, thanks to Claudio Porfiri
|
|
* <C.Porfiri@nisms.tei.ericsson.se>.
|
|
*/
|
|
/*
|
|
* This part is to deal with very slow hardware. We
|
|
* try at most MAX_SPINUP_RETRY times to read the same
|
|
* block. A check for seek_and_read_N_blocks' result is
|
|
* performed; if the result is wrong, the CDROM's engine
|
|
* is restarted and the operation is tried again.
|
|
*/
|
|
/*
|
|
* 1995-06-01: The system got problems when downloading
|
|
* from Slackware CDROM, the problem seems to be:
|
|
* seek_and_read_N_blocks returns BAD_STATUS and we
|
|
* should wait for a while before retrying, so a new
|
|
* part was added to discriminate the return value from
|
|
* seek_and_read_N_blocks for the various cases.
|
|
*/
|
|
int readStatus = seek_and_read_N_blocks(params, read_size,
|
|
status, sony_buffer, (read_size * CDU535_BLOCK_SIZE));
|
|
if (0 <= readStatus) /* Good data; common case, placed first */
|
|
break;
|
|
if (readStatus == NO_ROOM || spin_up_retry == MAX_SPINUP_RETRY) {
|
|
/* give up */
|
|
if (readStatus == NO_ROOM)
|
|
printk(CDU535_MESSAGE_NAME " No room to read from CD\n");
|
|
else
|
|
printk(CDU535_MESSAGE_NAME " Read error: 0x%.2x\n",
|
|
status[0]);
|
|
sony_first_block = -1;
|
|
sony_last_block = -1;
|
|
end_request(req, 0);
|
|
return;
|
|
}
|
|
if (readStatus == BAD_STATUS) {
|
|
/* Sleep for a while, then retry */
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
spin_unlock_irq(&sonycd535_lock);
|
|
schedule_timeout(RETRY_FOR_BAD_STATUS*HZ/10);
|
|
spin_lock_irq(&sonycd535_lock);
|
|
}
|
|
#if DEBUG > 0
|
|
printk(CDU535_MESSAGE_NAME
|
|
" debug: calling spin up when reading data!\n");
|
|
#endif
|
|
cmd[0] = SONY535_SPIN_UP;
|
|
do_sony_cmd(cmd, 1, status, NULL, 0, 0);
|
|
}
|
|
}
|
|
/*
|
|
* The data is in memory now, copy it to the buffer and advance to the
|
|
* next block to read.
|
|
*/
|
|
copyoff = block - sony_first_block;
|
|
memcpy(req->buffer,
|
|
sony_buffer[copyoff / 4] + 512 * (copyoff % 4), 512);
|
|
|
|
block += 1;
|
|
nsect -= 1;
|
|
req->buffer += 512;
|
|
}
|
|
|
|
end_request(req, 1);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Read the table of contents from the drive and set sony_toc_read if
|
|
* successful.
|
|
*/
|
|
static void
|
|
sony_get_toc(void)
|
|
{
|
|
Byte status[2];
|
|
if (!sony_toc_read) {
|
|
/* do not call check_drive_status() from here since it can call this routine */
|
|
if (request_toc_data(status, sony_toc) < 0)
|
|
return;
|
|
sony_toc->lead_out_start_lba = msf_to_log(sony_toc->lead_out_start_msf);
|
|
sony_toc_read = 1;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Search for a specific track in the table of contents. track is
|
|
* passed in bcd format
|
|
*/
|
|
static int
|
|
find_track(int track)
|
|
{
|
|
int i;
|
|
int num_tracks;
|
|
|
|
|
|
num_tracks = bcd_to_int(sony_toc->last_track_num) -
|
|
bcd_to_int(sony_toc->first_track_num) + 1;
|
|
for (i = 0; i < num_tracks; i++) {
|
|
if (sony_toc->tracks[i].track == track) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Read the subcode and put it int last_sony_subcode for future use.
|
|
*/
|
|
static int
|
|
read_subcode(void)
|
|
{
|
|
Byte cmd = SONY535_REQUEST_SUB_Q_DATA;
|
|
Byte status[2];
|
|
int dsc_status;
|
|
|
|
if (check_drive_status() != 0)
|
|
return -EIO;
|
|
|
|
if ((dsc_status = do_sony_cmd(&cmd, 1, status, (Byte *) last_sony_subcode,
|
|
sizeof(struct s535_sony_subcode), 1)) != 0) {
|
|
printk(CDU535_MESSAGE_NAME " error 0x%.2x, %d (read_subcode)\n",
|
|
status[0], dsc_status);
|
|
return -EIO;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Get the subchannel info like the CDROMSUBCHNL command wants to see it. If
|
|
* the drive is playing, the subchannel needs to be read (since it would be
|
|
* changing). If the drive is paused or completed, the subcode information has
|
|
* already been stored, just use that. The ioctl call wants things in decimal
|
|
* (not BCD), so all the conversions are done.
|
|
*/
|
|
static int
|
|
sony_get_subchnl_info(void __user *arg)
|
|
{
|
|
struct cdrom_subchnl schi;
|
|
|
|
/* Get attention stuff */
|
|
if (check_drive_status() != 0)
|
|
return -EIO;
|
|
|
|
sony_get_toc();
|
|
if (!sony_toc_read) {
|
|
return -EIO;
|
|
}
|
|
if (copy_from_user(&schi, arg, sizeof schi))
|
|
return -EFAULT;
|
|
|
|
switch (sony_audio_status) {
|
|
case CDROM_AUDIO_PLAY:
|
|
if (read_subcode() < 0) {
|
|
return -EIO;
|
|
}
|
|
break;
|
|
|
|
case CDROM_AUDIO_PAUSED:
|
|
case CDROM_AUDIO_COMPLETED:
|
|
break;
|
|
|
|
case CDROM_AUDIO_NO_STATUS:
|
|
schi.cdsc_audiostatus = sony_audio_status;
|
|
if (copy_to_user(arg, &schi, sizeof schi))
|
|
return -EFAULT;
|
|
return 0;
|
|
break;
|
|
|
|
case CDROM_AUDIO_INVALID:
|
|
case CDROM_AUDIO_ERROR:
|
|
default:
|
|
return -EIO;
|
|
}
|
|
|
|
schi.cdsc_audiostatus = sony_audio_status;
|
|
schi.cdsc_adr = last_sony_subcode->address;
|
|
schi.cdsc_ctrl = last_sony_subcode->control;
|
|
schi.cdsc_trk = bcd_to_int(last_sony_subcode->track_num);
|
|
schi.cdsc_ind = bcd_to_int(last_sony_subcode->index_num);
|
|
if (schi.cdsc_format == CDROM_MSF) {
|
|
schi.cdsc_absaddr.msf.minute = bcd_to_int(last_sony_subcode->abs_msf[0]);
|
|
schi.cdsc_absaddr.msf.second = bcd_to_int(last_sony_subcode->abs_msf[1]);
|
|
schi.cdsc_absaddr.msf.frame = bcd_to_int(last_sony_subcode->abs_msf[2]);
|
|
|
|
schi.cdsc_reladdr.msf.minute = bcd_to_int(last_sony_subcode->rel_msf[0]);
|
|
schi.cdsc_reladdr.msf.second = bcd_to_int(last_sony_subcode->rel_msf[1]);
|
|
schi.cdsc_reladdr.msf.frame = bcd_to_int(last_sony_subcode->rel_msf[2]);
|
|
} else if (schi.cdsc_format == CDROM_LBA) {
|
|
schi.cdsc_absaddr.lba = msf_to_log(last_sony_subcode->abs_msf);
|
|
schi.cdsc_reladdr.lba = msf_to_log(last_sony_subcode->rel_msf);
|
|
}
|
|
return copy_to_user(arg, &schi, sizeof schi) ? -EFAULT : 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* The big ugly ioctl handler.
|
|
*/
|
|
static int
|
|
cdu_ioctl(struct inode *inode,
|
|
struct file *file,
|
|
unsigned int cmd,
|
|
unsigned long arg)
|
|
{
|
|
Byte status[2];
|
|
Byte cmd_buff[10], params[10];
|
|
int i;
|
|
int dsc_status;
|
|
void __user *argp = (void __user *)arg;
|
|
|
|
if (check_drive_status() != 0)
|
|
return -EIO;
|
|
|
|
switch (cmd) {
|
|
case CDROMSTART: /* Spin up the drive */
|
|
if (spin_up_drive(status) < 0) {
|
|
printk(CDU535_MESSAGE_NAME " error 0x%.2x (CDROMSTART)\n",
|
|
status[0]);
|
|
return -EIO;
|
|
}
|
|
return 0;
|
|
break;
|
|
|
|
case CDROMSTOP: /* Spin down the drive */
|
|
cmd_buff[0] = SONY535_HOLD;
|
|
do_sony_cmd(cmd_buff, 1, status, NULL, 0, 0);
|
|
|
|
/*
|
|
* Spin the drive down, ignoring the error if the disk was
|
|
* already not spinning.
|
|
*/
|
|
sony_audio_status = CDROM_AUDIO_NO_STATUS;
|
|
cmd_buff[0] = SONY535_SPIN_DOWN;
|
|
dsc_status = do_sony_cmd(cmd_buff, 1, status, NULL, 0, 0);
|
|
if (((dsc_status < 0) && (dsc_status != BAD_STATUS)) ||
|
|
((status[0] & ~(SONY535_STATUS1_NOT_SPINNING)) != 0)) {
|
|
printk(CDU535_MESSAGE_NAME " error 0x%.2x (CDROMSTOP)\n",
|
|
status[0]);
|
|
return -EIO;
|
|
}
|
|
return 0;
|
|
break;
|
|
|
|
case CDROMPAUSE: /* Pause the drive */
|
|
cmd_buff[0] = SONY535_HOLD; /* CDU-31 driver uses AUDIO_STOP, not pause */
|
|
if (do_sony_cmd(cmd_buff, 1, status, NULL, 0, 0) != 0) {
|
|
printk(CDU535_MESSAGE_NAME " error 0x%.2x (CDROMPAUSE)\n",
|
|
status[0]);
|
|
return -EIO;
|
|
}
|
|
/* Get the current position and save it for resuming */
|
|
if (read_subcode() < 0) {
|
|
return -EIO;
|
|
}
|
|
cur_pos_msf[0] = last_sony_subcode->abs_msf[0];
|
|
cur_pos_msf[1] = last_sony_subcode->abs_msf[1];
|
|
cur_pos_msf[2] = last_sony_subcode->abs_msf[2];
|
|
sony_audio_status = CDROM_AUDIO_PAUSED;
|
|
return 0;
|
|
break;
|
|
|
|
case CDROMRESUME: /* Start the drive after being paused */
|
|
set_drive_mode(SONY535_AUDIO_DRIVE_MODE, status);
|
|
|
|
if (sony_audio_status != CDROM_AUDIO_PAUSED) {
|
|
return -EINVAL;
|
|
}
|
|
spin_up_drive(status);
|
|
|
|
/* Start the drive at the saved position. */
|
|
cmd_buff[0] = SONY535_PLAY_AUDIO;
|
|
cmd_buff[1] = 0; /* play back starting at this address */
|
|
cmd_buff[2] = cur_pos_msf[0];
|
|
cmd_buff[3] = cur_pos_msf[1];
|
|
cmd_buff[4] = cur_pos_msf[2];
|
|
cmd_buff[5] = SONY535_PLAY_AUDIO;
|
|
cmd_buff[6] = 2; /* set ending address */
|
|
cmd_buff[7] = final_pos_msf[0];
|
|
cmd_buff[8] = final_pos_msf[1];
|
|
cmd_buff[9] = final_pos_msf[2];
|
|
if ((do_sony_cmd(cmd_buff, 5, status, NULL, 0, 0) != 0) ||
|
|
(do_sony_cmd(cmd_buff + 5, 5, status, NULL, 0, 0) != 0)) {
|
|
printk(CDU535_MESSAGE_NAME " error 0x%.2x (CDROMRESUME)\n",
|
|
status[0]);
|
|
return -EIO;
|
|
}
|
|
sony_audio_status = CDROM_AUDIO_PLAY;
|
|
return 0;
|
|
break;
|
|
|
|
case CDROMPLAYMSF: /* Play starting at the given MSF address. */
|
|
if (copy_from_user(params, argp, 6))
|
|
return -EFAULT;
|
|
spin_up_drive(status);
|
|
set_drive_mode(SONY535_AUDIO_DRIVE_MODE, status);
|
|
|
|
/* The parameters are given in int, must be converted */
|
|
for (i = 0; i < 3; i++) {
|
|
cmd_buff[2 + i] = int_to_bcd(params[i]);
|
|
cmd_buff[7 + i] = int_to_bcd(params[i + 3]);
|
|
}
|
|
cmd_buff[0] = SONY535_PLAY_AUDIO;
|
|
cmd_buff[1] = 0; /* play back starting at this address */
|
|
/* cmd_buff[2-4] are filled in for loop above */
|
|
cmd_buff[5] = SONY535_PLAY_AUDIO;
|
|
cmd_buff[6] = 2; /* set ending address */
|
|
/* cmd_buff[7-9] are filled in for loop above */
|
|
if ((do_sony_cmd(cmd_buff, 5, status, NULL, 0, 0) != 0) ||
|
|
(do_sony_cmd(cmd_buff + 5, 5, status, NULL, 0, 0) != 0)) {
|
|
printk(CDU535_MESSAGE_NAME " error 0x%.2x (CDROMPLAYMSF)\n",
|
|
status[0]);
|
|
return -EIO;
|
|
}
|
|
/* Save the final position for pauses and resumes */
|
|
final_pos_msf[0] = cmd_buff[7];
|
|
final_pos_msf[1] = cmd_buff[8];
|
|
final_pos_msf[2] = cmd_buff[9];
|
|
sony_audio_status = CDROM_AUDIO_PLAY;
|
|
return 0;
|
|
break;
|
|
|
|
case CDROMREADTOCHDR: /* Read the table of contents header */
|
|
{
|
|
struct cdrom_tochdr __user *hdr = argp;
|
|
struct cdrom_tochdr loc_hdr;
|
|
|
|
sony_get_toc();
|
|
if (!sony_toc_read)
|
|
return -EIO;
|
|
loc_hdr.cdth_trk0 = bcd_to_int(sony_toc->first_track_num);
|
|
loc_hdr.cdth_trk1 = bcd_to_int(sony_toc->last_track_num);
|
|
if (copy_to_user(hdr, &loc_hdr, sizeof *hdr))
|
|
return -EFAULT;
|
|
}
|
|
return 0;
|
|
break;
|
|
|
|
case CDROMREADTOCENTRY: /* Read a given table of contents entry */
|
|
{
|
|
struct cdrom_tocentry __user *entry = argp;
|
|
struct cdrom_tocentry loc_entry;
|
|
int track_idx;
|
|
Byte *msf_val = NULL;
|
|
|
|
sony_get_toc();
|
|
if (!sony_toc_read) {
|
|
return -EIO;
|
|
}
|
|
|
|
if (copy_from_user(&loc_entry, entry, sizeof loc_entry))
|
|
return -EFAULT;
|
|
|
|
/* Lead out is handled separately since it is special. */
|
|
if (loc_entry.cdte_track == CDROM_LEADOUT) {
|
|
loc_entry.cdte_adr = 0 /*sony_toc->address2 */ ;
|
|
loc_entry.cdte_ctrl = sony_toc->control2;
|
|
msf_val = sony_toc->lead_out_start_msf;
|
|
} else {
|
|
track_idx = find_track(int_to_bcd(loc_entry.cdte_track));
|
|
if (track_idx < 0)
|
|
return -EINVAL;
|
|
loc_entry.cdte_adr = 0 /*sony_toc->tracks[track_idx].address */ ;
|
|
loc_entry.cdte_ctrl = sony_toc->tracks[track_idx].control;
|
|
msf_val = sony_toc->tracks[track_idx].track_start_msf;
|
|
}
|
|
|
|
/* Logical buffer address or MSF format requested? */
|
|
if (loc_entry.cdte_format == CDROM_LBA) {
|
|
loc_entry.cdte_addr.lba = msf_to_log(msf_val);
|
|
} else if (loc_entry.cdte_format == CDROM_MSF) {
|
|
loc_entry.cdte_addr.msf.minute = bcd_to_int(*msf_val);
|
|
loc_entry.cdte_addr.msf.second = bcd_to_int(*(msf_val + 1));
|
|
loc_entry.cdte_addr.msf.frame = bcd_to_int(*(msf_val + 2));
|
|
}
|
|
if (copy_to_user(entry, &loc_entry, sizeof *entry))
|
|
return -EFAULT;
|
|
}
|
|
return 0;
|
|
break;
|
|
|
|
case CDROMPLAYTRKIND: /* Play a track. This currently ignores index. */
|
|
{
|
|
struct cdrom_ti ti;
|
|
int track_idx;
|
|
|
|
sony_get_toc();
|
|
if (!sony_toc_read)
|
|
return -EIO;
|
|
|
|
if (copy_from_user(&ti, argp, sizeof ti))
|
|
return -EFAULT;
|
|
if ((ti.cdti_trk0 < sony_toc->first_track_num)
|
|
|| (sony_toc->last_track_num < ti.cdti_trk0)
|
|
|| (ti.cdti_trk1 < ti.cdti_trk0)) {
|
|
return -EINVAL;
|
|
}
|
|
track_idx = find_track(int_to_bcd(ti.cdti_trk0));
|
|
if (track_idx < 0)
|
|
return -EINVAL;
|
|
params[1] = sony_toc->tracks[track_idx].track_start_msf[0];
|
|
params[2] = sony_toc->tracks[track_idx].track_start_msf[1];
|
|
params[3] = sony_toc->tracks[track_idx].track_start_msf[2];
|
|
/*
|
|
* If we want to stop after the last track, use the lead-out
|
|
* MSF to do that.
|
|
*/
|
|
if (bcd_to_int(sony_toc->last_track_num) <= ti.cdti_trk1) {
|
|
log_to_msf(msf_to_log(sony_toc->lead_out_start_msf) - 1,
|
|
&(params[4]));
|
|
} else {
|
|
track_idx = find_track(int_to_bcd(ti.cdti_trk1 + 1));
|
|
if (track_idx < 0)
|
|
return -EINVAL;
|
|
log_to_msf(msf_to_log(sony_toc->tracks[track_idx].track_start_msf) - 1,
|
|
&(params[4]));
|
|
}
|
|
params[0] = 0x03;
|
|
|
|
spin_up_drive(status);
|
|
|
|
set_drive_mode(SONY535_AUDIO_DRIVE_MODE, status);
|
|
|
|
/* Start the drive at the saved position. */
|
|
cmd_buff[0] = SONY535_PLAY_AUDIO;
|
|
cmd_buff[1] = 0; /* play back starting at this address */
|
|
cmd_buff[2] = params[1];
|
|
cmd_buff[3] = params[2];
|
|
cmd_buff[4] = params[3];
|
|
cmd_buff[5] = SONY535_PLAY_AUDIO;
|
|
cmd_buff[6] = 2; /* set ending address */
|
|
cmd_buff[7] = params[4];
|
|
cmd_buff[8] = params[5];
|
|
cmd_buff[9] = params[6];
|
|
if ((do_sony_cmd(cmd_buff, 5, status, NULL, 0, 0) != 0) ||
|
|
(do_sony_cmd(cmd_buff + 5, 5, status, NULL, 0, 0) != 0)) {
|
|
printk(CDU535_MESSAGE_NAME " error 0x%.2x (CDROMPLAYTRKIND)\n",
|
|
status[0]);
|
|
printk("... Params: %x %x %x %x %x %x %x\n",
|
|
params[0], params[1], params[2],
|
|
params[3], params[4], params[5], params[6]);
|
|
return -EIO;
|
|
}
|
|
/* Save the final position for pauses and resumes */
|
|
final_pos_msf[0] = params[4];
|
|
final_pos_msf[1] = params[5];
|
|
final_pos_msf[2] = params[6];
|
|
sony_audio_status = CDROM_AUDIO_PLAY;
|
|
return 0;
|
|
}
|
|
|
|
case CDROMSUBCHNL: /* Get subchannel info */
|
|
return sony_get_subchnl_info(argp);
|
|
|
|
case CDROMVOLCTRL: /* Volume control. What volume does this change, anyway? */
|
|
{
|
|
struct cdrom_volctrl volctrl;
|
|
|
|
if (copy_from_user(&volctrl, argp, sizeof volctrl))
|
|
return -EFAULT;
|
|
cmd_buff[0] = SONY535_SET_VOLUME;
|
|
cmd_buff[1] = volctrl.channel0;
|
|
cmd_buff[2] = volctrl.channel1;
|
|
if (do_sony_cmd(cmd_buff, 3, status, NULL, 0, 0) != 0) {
|
|
printk(CDU535_MESSAGE_NAME " error 0x%.2x (CDROMVOLCTRL)\n",
|
|
status[0]);
|
|
return -EIO;
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
case CDROMEJECT: /* Eject the drive */
|
|
cmd_buff[0] = SONY535_STOP;
|
|
do_sony_cmd(cmd_buff, 1, status, NULL, 0, 0);
|
|
cmd_buff[0] = SONY535_SPIN_DOWN;
|
|
do_sony_cmd(cmd_buff, 1, status, NULL, 0, 0);
|
|
|
|
sony_audio_status = CDROM_AUDIO_INVALID;
|
|
cmd_buff[0] = SONY535_EJECT_CADDY;
|
|
if (do_sony_cmd(cmd_buff, 1, status, NULL, 0, 0) != 0) {
|
|
printk(CDU535_MESSAGE_NAME " error 0x%.2x (CDROMEJECT)\n",
|
|
status[0]);
|
|
return -EIO;
|
|
}
|
|
return 0;
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Open the drive for operations. Spin the drive up and read the table of
|
|
* contents if these have not already been done.
|
|
*/
|
|
static int
|
|
cdu_open(struct inode *inode,
|
|
struct file *filp)
|
|
{
|
|
Byte status[2], cmd_buff[2];
|
|
|
|
if (sony_inuse)
|
|
return -EBUSY;
|
|
if (check_drive_status() != 0)
|
|
return -EIO;
|
|
sony_inuse = 1;
|
|
|
|
if (spin_up_drive(status) != 0) {
|
|
printk(CDU535_MESSAGE_NAME " error 0x%.2x (cdu_open, spin up)\n",
|
|
status[0]);
|
|
sony_inuse = 0;
|
|
return -EIO;
|
|
}
|
|
sony_get_toc();
|
|
if (!sony_toc_read) {
|
|
cmd_buff[0] = SONY535_SPIN_DOWN;
|
|
do_sony_cmd(cmd_buff, 1, status, NULL, 0, 0);
|
|
sony_inuse = 0;
|
|
return -EIO;
|
|
}
|
|
check_disk_change(inode->i_bdev);
|
|
sony_usage++;
|
|
|
|
#ifdef LOCK_DOORS
|
|
/* disable the eject button while mounted */
|
|
cmd_buff[0] = SONY535_DISABLE_EJECT_BUTTON;
|
|
do_sony_cmd(cmd_buff, 1, status, NULL, 0, 0);
|
|
#endif
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Close the drive. Spin it down if no task is using it. The spin
|
|
* down will fail if playing audio, so audio play is OK.
|
|
*/
|
|
static int
|
|
cdu_release(struct inode *inode,
|
|
struct file *filp)
|
|
{
|
|
Byte status[2], cmd_no;
|
|
|
|
sony_inuse = 0;
|
|
|
|
if (0 < sony_usage) {
|
|
sony_usage--;
|
|
}
|
|
if (sony_usage == 0) {
|
|
check_drive_status();
|
|
|
|
if (sony_audio_status != CDROM_AUDIO_PLAY) {
|
|
cmd_no = SONY535_SPIN_DOWN;
|
|
do_sony_cmd(&cmd_no, 1, status, NULL, 0, 0);
|
|
}
|
|
#ifdef LOCK_DOORS
|
|
/* enable the eject button after umount */
|
|
cmd_no = SONY535_ENABLE_EJECT_BUTTON;
|
|
do_sony_cmd(&cmd_no, 1, status, NULL, 0, 0);
|
|
#endif
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static struct block_device_operations cdu_fops =
|
|
{
|
|
.owner = THIS_MODULE,
|
|
.open = cdu_open,
|
|
.release = cdu_release,
|
|
.ioctl = cdu_ioctl,
|
|
.media_changed = cdu535_check_media_change,
|
|
};
|
|
|
|
static struct gendisk *cdu_disk;
|
|
|
|
/*
|
|
* Initialize the driver.
|
|
*/
|
|
static int __init sony535_init(void)
|
|
{
|
|
struct s535_sony_drive_config drive_config;
|
|
Byte cmd_buff[3];
|
|
Byte ret_buff[2];
|
|
Byte status[2];
|
|
unsigned long snap;
|
|
int got_result = 0;
|
|
int tmp_irq;
|
|
int i;
|
|
int err;
|
|
|
|
/* Setting the base I/O address to 0 will disable it. */
|
|
if ((sony535_cd_base_io == 0xffff)||(sony535_cd_base_io == 0))
|
|
return 0;
|
|
|
|
/* Set up all the register locations */
|
|
result_reg = sony535_cd_base_io;
|
|
command_reg = sony535_cd_base_io;
|
|
data_reg = sony535_cd_base_io + 1;
|
|
read_status_reg = sony535_cd_base_io + 2;
|
|
select_unit_reg = sony535_cd_base_io + 3;
|
|
|
|
#ifndef USE_IRQ
|
|
sony535_irq_used = 0; /* polling only until this is ready... */
|
|
#endif
|
|
/* we need to poll until things get initialized */
|
|
tmp_irq = sony535_irq_used;
|
|
sony535_irq_used = 0;
|
|
|
|
#if DEBUG > 0
|
|
printk(KERN_INFO CDU535_MESSAGE_NAME ": probing base address %03X\n",
|
|
sony535_cd_base_io);
|
|
#endif
|
|
/* look for the CD-ROM, follows the procedure in the DOS driver */
|
|
inb(select_unit_reg);
|
|
/* wait for 40 18 Hz ticks (reverse-engineered from DOS driver) */
|
|
schedule_timeout_interruptible((HZ+17)*40/18);
|
|
inb(result_reg);
|
|
|
|
outb(0, read_status_reg); /* does a reset? */
|
|
snap = jiffies;
|
|
while (jiffies-snap < SONY_JIFFIES_TIMEOUT) {
|
|
select_unit(0);
|
|
if (inb(result_reg) != 0xff) {
|
|
got_result = 1;
|
|
break;
|
|
}
|
|
sony_sleep();
|
|
}
|
|
|
|
if (!got_result || check_drive_status() == TIME_OUT)
|
|
goto Enodev;
|
|
|
|
/* CD-ROM drive responded -- get the drive configuration */
|
|
cmd_buff[0] = SONY535_INQUIRY;
|
|
if (do_sony_cmd(cmd_buff, 1, status, (Byte *)&drive_config, 28, 1) != 0)
|
|
goto Enodev;
|
|
|
|
/* was able to get the configuration,
|
|
* set drive mode as rest of init
|
|
*/
|
|
#if DEBUG > 0
|
|
/* 0x50 == CADDY_NOT_INSERTED | NOT_SPINNING */
|
|
if ( (status[0] & 0x7f) != 0 && (status[0] & 0x7f) != 0x50 )
|
|
printk(CDU535_MESSAGE_NAME
|
|
"Inquiry command returned status = 0x%x\n", status[0]);
|
|
#endif
|
|
/* now ready to use interrupts, if available */
|
|
sony535_irq_used = tmp_irq;
|
|
|
|
/* A negative sony535_irq_used will attempt an autoirq. */
|
|
if (sony535_irq_used < 0) {
|
|
unsigned long irq_mask, delay;
|
|
|
|
irq_mask = probe_irq_on();
|
|
enable_interrupts();
|
|
outb(0, read_status_reg); /* does a reset? */
|
|
delay = jiffies + HZ/10;
|
|
while (time_before(jiffies, delay)) ;
|
|
|
|
sony535_irq_used = probe_irq_off(irq_mask);
|
|
disable_interrupts();
|
|
}
|
|
if (sony535_irq_used > 0) {
|
|
if (request_irq(sony535_irq_used, cdu535_interrupt,
|
|
IRQF_DISABLED, CDU535_HANDLE, NULL)) {
|
|
printk("Unable to grab IRQ%d for the " CDU535_MESSAGE_NAME
|
|
" driver; polling instead.\n", sony535_irq_used);
|
|
sony535_irq_used = 0;
|
|
}
|
|
}
|
|
cmd_buff[0] = SONY535_SET_DRIVE_MODE;
|
|
cmd_buff[1] = 0x0; /* default audio */
|
|
if (do_sony_cmd(cmd_buff, 2, status, ret_buff, 1, 1) != 0)
|
|
goto Enodev_irq;
|
|
|
|
/* set the drive mode successful, we are set! */
|
|
sony_buffer_size = SONY535_BUFFER_SIZE;
|
|
sony_buffer_sectors = sony_buffer_size / CDU535_BLOCK_SIZE;
|
|
|
|
printk(KERN_INFO CDU535_MESSAGE_NAME " I/F CDROM : %8.8s %16.16s %4.4s",
|
|
drive_config.vendor_id,
|
|
drive_config.product_id,
|
|
drive_config.product_rev_level);
|
|
printk(" base address %03X, ", sony535_cd_base_io);
|
|
if (tmp_irq > 0)
|
|
printk("IRQ%d, ", tmp_irq);
|
|
printk("using %d byte buffer\n", sony_buffer_size);
|
|
|
|
if (register_blkdev(MAJOR_NR, CDU535_HANDLE)) {
|
|
err = -EIO;
|
|
goto out1;
|
|
}
|
|
sonycd535_queue = blk_init_queue(do_cdu535_request, &sonycd535_lock);
|
|
if (!sonycd535_queue) {
|
|
err = -ENOMEM;
|
|
goto out1a;
|
|
}
|
|
|
|
blk_queue_hardsect_size(sonycd535_queue, CDU535_BLOCK_SIZE);
|
|
sony_toc = kmalloc(sizeof(struct s535_sony_toc), GFP_KERNEL);
|
|
err = -ENOMEM;
|
|
if (!sony_toc)
|
|
goto out2;
|
|
last_sony_subcode = kmalloc(sizeof(struct s535_sony_subcode), GFP_KERNEL);
|
|
if (!last_sony_subcode)
|
|
goto out3;
|
|
sony_buffer = kmalloc(sizeof(Byte *) * sony_buffer_sectors, GFP_KERNEL);
|
|
if (!sony_buffer)
|
|
goto out4;
|
|
for (i = 0; i < sony_buffer_sectors; i++) {
|
|
sony_buffer[i] = kmalloc(CDU535_BLOCK_SIZE, GFP_KERNEL);
|
|
if (!sony_buffer[i]) {
|
|
while (--i>=0)
|
|
kfree(sony_buffer[i]);
|
|
goto out5;
|
|
}
|
|
}
|
|
initialized = 1;
|
|
|
|
cdu_disk = alloc_disk(1);
|
|
if (!cdu_disk)
|
|
goto out6;
|
|
cdu_disk->major = MAJOR_NR;
|
|
cdu_disk->first_minor = 0;
|
|
cdu_disk->fops = &cdu_fops;
|
|
sprintf(cdu_disk->disk_name, "cdu");
|
|
|
|
if (!request_region(sony535_cd_base_io, 4, CDU535_HANDLE)) {
|
|
printk(KERN_WARNING"sonycd535: Unable to request region 0x%x\n",
|
|
sony535_cd_base_io);
|
|
goto out7;
|
|
}
|
|
cdu_disk->queue = sonycd535_queue;
|
|
add_disk(cdu_disk);
|
|
return 0;
|
|
|
|
out7:
|
|
put_disk(cdu_disk);
|
|
out6:
|
|
for (i = 0; i < sony_buffer_sectors; i++)
|
|
kfree(sony_buffer[i]);
|
|
out5:
|
|
kfree(sony_buffer);
|
|
out4:
|
|
kfree(last_sony_subcode);
|
|
out3:
|
|
kfree(sony_toc);
|
|
out2:
|
|
blk_cleanup_queue(sonycd535_queue);
|
|
out1a:
|
|
unregister_blkdev(MAJOR_NR, CDU535_HANDLE);
|
|
out1:
|
|
if (sony535_irq_used)
|
|
free_irq(sony535_irq_used, NULL);
|
|
return err;
|
|
Enodev_irq:
|
|
if (sony535_irq_used)
|
|
free_irq(sony535_irq_used, NULL);
|
|
Enodev:
|
|
printk("Did not find a " CDU535_MESSAGE_NAME " drive\n");
|
|
return -EIO;
|
|
}
|
|
|
|
#ifndef MODULE
|
|
|
|
/*
|
|
* accept "kernel command line" parameters
|
|
* (added by emoenke@gwdg.de)
|
|
*
|
|
* use: tell LILO:
|
|
* sonycd535=0x320
|
|
*
|
|
* the address value has to be the existing CDROM port address.
|
|
*/
|
|
static int __init
|
|
sonycd535_setup(char *strings)
|
|
{
|
|
int ints[3];
|
|
(void)get_options(strings, ARRAY_SIZE(ints), ints);
|
|
/* if IRQ change and default io base desired,
|
|
* then call with io base of 0
|
|
*/
|
|
if (ints[0] > 0)
|
|
if (ints[1] != 0)
|
|
sony535_cd_base_io = ints[1];
|
|
if (ints[0] > 1)
|
|
sony535_irq_used = ints[2];
|
|
if ((strings != NULL) && (*strings != '\0'))
|
|
printk(CDU535_MESSAGE_NAME
|
|
": Warning: Unknown interface type: %s\n", strings);
|
|
|
|
return 1;
|
|
}
|
|
|
|
__setup("sonycd535=", sonycd535_setup);
|
|
|
|
#endif /* MODULE */
|
|
|
|
static void __exit
|
|
sony535_exit(void)
|
|
{
|
|
int i;
|
|
|
|
release_region(sony535_cd_base_io, 4);
|
|
for (i = 0; i < sony_buffer_sectors; i++)
|
|
kfree(sony_buffer[i]);
|
|
kfree(sony_buffer);
|
|
kfree(last_sony_subcode);
|
|
kfree(sony_toc);
|
|
del_gendisk(cdu_disk);
|
|
put_disk(cdu_disk);
|
|
blk_cleanup_queue(sonycd535_queue);
|
|
if (unregister_blkdev(MAJOR_NR, CDU535_HANDLE) == -EINVAL)
|
|
printk("Uh oh, couldn't unregister " CDU535_HANDLE "\n");
|
|
else
|
|
printk(KERN_INFO CDU535_HANDLE " module released\n");
|
|
}
|
|
|
|
module_init(sony535_init);
|
|
module_exit(sony535_exit);
|
|
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_ALIAS_BLOCKDEV_MAJOR(CDU535_CDROM_MAJOR);
|