Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-12-04 18:13:04 +00:00
Code Issues Packages Projects Releases Wiki Activity
6788182602
linux/drivers/cdrom/mcdx.c
Jeff Garzik c7bec5aba5 Various drivers' irq handlers: kill dead code, needless casts 
- Eliminate casts to/from void*

- Eliminate checks for conditions that never occur.  These typically
  fall into two classes:

	1) Checking for 'dev_id == NULL', then it is never called with
	NULL as an argument.

	2) Checking for invalid irq number, when the only caller (the
	system) guarantees the irq handler is called with the proper
	'irq' number argument.

Signed-off-by: Jeff Garzik <jeff@garzik.org>
2006-10-06 15:00:58 -04:00

1944 lines
49 KiB
C
Raw Blame History

/*
* The Mitsumi CDROM interface
* Copyright (C) 1995 1996 Heiko Schlittermann <heiko@lotte.sax.de>
* VERSION: 2.14(hs)
*
* ... anyway, I'm back again, thanks to Marcin, he adopted
* large portions of my code (at least the parts containing
* my main thoughts ...)
*
****************** H E L P *********************************
* If you ever plan to update your CD ROM drive and perhaps
* want to sell or simply give away your Mitsumi FX-001[DS]
* -- Please --
* mail me (heiko@lotte.sax.de). When my last drive goes
* ballistic no more driver support will be available from me!
*************************************************************
*
* 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; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Thanks to
* The Linux Community at all and ...
* Martin Harriss (he wrote the first Mitsumi Driver)
* Eberhard Moenkeberg (he gave me much support and the initial kick)
* Bernd Huebner, Ruediger Helsch (Unifix-Software GmbH, they
* improved the original driver)
* Jon Tombs, Bjorn Ekwall (module support)
* Daniel v. Mosnenck (he sent me the Technical and Programming Reference)
* Gerd Knorr (he lent me his PhotoCD)
* Nils Faerber and Roger E. Wolff (extensively tested the LU portion)
* Andreas Kies (testing the mysterious hang-ups)
* Heiko Eissfeldt (VERIFY_READ/WRITE)
* Marcin Dalecki (improved performance, shortened code)
* ... somebody forgotten?
*
* 9 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>
*/
#ifdef RCS
static const char *mcdx_c_version
= "$Id: mcdx.c,v 1.21 1997/01/26 07:12:59 davem Exp $";
#endif
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/cdrom.h>
#include <linux/ioport.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <asm/io.h>
#include <asm/current.h>
#include <asm/uaccess.h>
#include <linux/major.h>
#define MAJOR_NR MITSUMI_X_CDROM_MAJOR
#include <linux/blkdev.h>
#include "mcdx.h"
#ifndef HZ
#error HZ not defined
#endif
#define xwarn(fmt, args...) printk(KERN_WARNING MCDX " " fmt, ## args)
#if !MCDX_QUIET
#define xinfo(fmt, args...) printk(KERN_INFO MCDX " " fmt, ## args)
#else
#define xinfo(fmt, args...) { ; }
#endif
#if MCDX_DEBUG
#define xtrace(lvl, fmt, args...) \
{ if (lvl > 0) \
{ printk(KERN_DEBUG MCDX ":: " fmt, ## args); } }
#define xdebug(fmt, args...) printk(KERN_DEBUG MCDX ":: " fmt, ## args)
#else
#define xtrace(lvl, fmt, args...) { ; }
#define xdebug(fmt, args...) { ; }
#endif
/* CONSTANTS *******************************************************/
/* Following are the number of sectors we _request_ from the drive
every time an access outside the already requested range is done.
The _direct_ size is the number of sectors we're allowed to skip
directly (performing a read instead of requesting the new sector
needed */
static const int REQUEST_SIZE = 800; /* should be less then 255 * 4 */
static const int DIRECT_SIZE = 400; /* should be less then REQUEST_SIZE */
enum drivemodes { TOC, DATA, RAW, COOKED };
enum datamodes { MODE0, MODE1, MODE2 };
enum resetmodes { SOFT, HARD };
static const int SINGLE = 0x01; /* single speed drive (FX001S, LU) */
static const int DOUBLE = 0x02; /* double speed drive (FX001D, ..? */
static const int DOOR = 0x04; /* door locking capability */
static const int MULTI = 0x08; /* multi session capability */
static const unsigned char READ1X = 0xc0;
static const unsigned char READ2X = 0xc1;
/* DECLARATIONS ****************************************************/
struct s_subqcode {
unsigned char control;
unsigned char tno;
unsigned char index;
struct cdrom_msf0 tt;
struct cdrom_msf0 dt;
};
struct s_diskinfo {
unsigned int n_first;
unsigned int n_last;
struct cdrom_msf0 msf_leadout;
struct cdrom_msf0 msf_first;
};
struct s_multi {
unsigned char multi;
struct cdrom_msf0 msf_last;
};
struct s_version {
unsigned char code;
unsigned char ver;
};
/* Per drive/controller stuff **************************************/
struct s_drive_stuff {
/* waitqueues */
wait_queue_head_t busyq;
wait_queue_head_t lockq;
wait_queue_head_t sleepq;
/* flags */
volatile int introk; /* status of last irq operation */
volatile int busy; /* drive performs an operation */
volatile int lock; /* exclusive usage */
/* cd infos */
struct s_diskinfo di;
struct s_multi multi;
struct s_subqcode *toc; /* first entry of the toc array */
struct s_subqcode start;
struct s_subqcode stop;
int xa; /* 1 if xa disk */
int audio; /* 1 if audio disk */
int audiostatus;
/* `buffer' control */
volatile int valid; /* pending, ..., values are valid */
volatile int pending; /* next sector to be read */
volatile int low_border; /* first sector not to be skipped direct */
volatile int high_border; /* first sector `out of area' */
#ifdef AK2
volatile int int_err;
#endif /* AK2 */
/* adds and odds */
unsigned wreg_data; /* w data */
unsigned wreg_reset; /* w hardware reset */
unsigned wreg_hcon; /* w hardware conf */
unsigned wreg_chn; /* w channel */
unsigned rreg_data; /* r data */
unsigned rreg_status; /* r status */
int irq; /* irq used by this drive */
int present; /* drive present and its capabilities */
unsigned char readcmd; /* read cmd depends on single/double speed */
unsigned char playcmd; /* play should always be single speed */
unsigned int xxx; /* set if changed, reset while open */
unsigned int yyy; /* set if changed, reset by media_changed */
int users; /* keeps track of open/close */
int lastsector; /* last block accessible */
int status; /* last operation's error / status */
int readerrs; /* # of blocks read w/o error */
struct cdrom_device_info info;
struct gendisk *disk;
};
/* Prototypes ******************************************************/
/* The following prototypes are already declared elsewhere. They are
repeated here to show what's going on. And to sense, if they're
changed elsewhere. */
static int mcdx_init(void);
static int mcdx_block_open(struct inode *inode, struct file *file)
{
struct s_drive_stuff *p = inode->i_bdev->bd_disk->private_data;
return cdrom_open(&p->info, inode, file);
}
static int mcdx_block_release(struct inode *inode, struct file *file)
{
struct s_drive_stuff *p = inode->i_bdev->bd_disk->private_data;
return cdrom_release(&p->info, file);
}
static int mcdx_block_ioctl(struct inode *inode, struct file *file,
unsigned cmd, unsigned long arg)
{
struct s_drive_stuff *p = inode->i_bdev->bd_disk->private_data;
return cdrom_ioctl(file, &p->info, inode, cmd, arg);
}
static int mcdx_block_media_changed(struct gendisk *disk)
{
struct s_drive_stuff *p = disk->private_data;
return cdrom_media_changed(&p->info);
}
static struct block_device_operations mcdx_bdops =
{
.owner = THIS_MODULE,
.open = mcdx_block_open,
.release = mcdx_block_release,
.ioctl = mcdx_block_ioctl,
.media_changed = mcdx_block_media_changed,
};
/* Indirect exported functions. These functions are exported by their
addresses, such as mcdx_open and mcdx_close in the
structure mcdx_dops. */
/* exported by file_ops */
static int mcdx_open(struct cdrom_device_info *cdi, int purpose);
static void mcdx_close(struct cdrom_device_info *cdi);
static int mcdx_media_changed(struct cdrom_device_info *cdi, int disc_nr);
static int mcdx_tray_move(struct cdrom_device_info *cdi, int position);
static int mcdx_lockdoor(struct cdrom_device_info *cdi, int lock);
static int mcdx_audio_ioctl(struct cdrom_device_info *cdi,
unsigned int cmd, void *arg);
/* misc internal support functions */
static void log2msf(unsigned int, struct cdrom_msf0 *);
static unsigned int msf2log(const struct cdrom_msf0 *);
static unsigned int uint2bcd(unsigned int);
static unsigned int bcd2uint(unsigned char);
static unsigned port(int *);
static int irq(int *);
static void mcdx_delay(struct s_drive_stuff *, long jifs);
static int mcdx_transfer(struct s_drive_stuff *, char *buf, int sector,
int nr_sectors);
static int mcdx_xfer(struct s_drive_stuff *, char *buf, int sector,
int nr_sectors);
static int mcdx_config(struct s_drive_stuff *, int);
static int mcdx_requestversion(struct s_drive_stuff *, struct s_version *,
int);
static int mcdx_stop(struct s_drive_stuff *, int);
static int mcdx_hold(struct s_drive_stuff *, int);
static int mcdx_reset(struct s_drive_stuff *, enum resetmodes, int);
static int mcdx_setdrivemode(struct s_drive_stuff *, enum drivemodes, int);
static int mcdx_setdatamode(struct s_drive_stuff *, enum datamodes, int);
static int mcdx_requestsubqcode(struct s_drive_stuff *,
struct s_subqcode *, int);
static int mcdx_requestmultidiskinfo(struct s_drive_stuff *,
struct s_multi *, int);
static int mcdx_requesttocdata(struct s_drive_stuff *, struct s_diskinfo *,
int);
static int mcdx_getstatus(struct s_drive_stuff *, int);
static int mcdx_getval(struct s_drive_stuff *, int to, int delay, char *);
static int mcdx_talk(struct s_drive_stuff *,
const unsigned char *cmd, size_t,
void *buffer, size_t size, unsigned int timeout, int);
static int mcdx_readtoc(struct s_drive_stuff *);
static int mcdx_playtrk(struct s_drive_stuff *, const struct cdrom_ti *);
static int mcdx_playmsf(struct s_drive_stuff *, const struct cdrom_msf *);
static int mcdx_setattentuator(struct s_drive_stuff *,
struct cdrom_volctrl *, int);
/* static variables ************************************************/
static int mcdx_drive_map[][2] = MCDX_DRIVEMAP;
static struct s_drive_stuff *mcdx_stuffp[MCDX_NDRIVES];
static DEFINE_SPINLOCK(mcdx_lock);
static struct request_queue *mcdx_queue;
/* You can only set the first two pairs, from old MODULE_PARM code. */
static int mcdx_set(const char *val, struct kernel_param *kp)
{
get_options((char *)val, 4, (int *)mcdx_drive_map);
return 0;
}
module_param_call(mcdx, mcdx_set, NULL, NULL, 0);
static struct cdrom_device_ops mcdx_dops = {
.open = mcdx_open,
.release = mcdx_close,
.media_changed = mcdx_media_changed,
.tray_move = mcdx_tray_move,
.lock_door = mcdx_lockdoor,
.audio_ioctl = mcdx_audio_ioctl,
.capability = CDC_OPEN_TRAY | CDC_LOCK | CDC_MEDIA_CHANGED |
CDC_PLAY_AUDIO | CDC_DRIVE_STATUS,
};
/* KERNEL INTERFACE FUNCTIONS **************************************/
static int mcdx_audio_ioctl(struct cdrom_device_info *cdi,
unsigned int cmd, void *arg)
{
struct s_drive_stuff *stuffp = cdi->handle;
if (!stuffp->present)
return -ENXIO;
if (stuffp->xxx) {
if (-1 == mcdx_requesttocdata(stuffp, &stuffp->di, 1)) {
stuffp->lastsector = -1;
} else {
stuffp->lastsector = (CD_FRAMESIZE / 512)
* msf2log(&stuffp->di.msf_leadout) - 1;
}
if (stuffp->toc) {
kfree(stuffp->toc);
stuffp->toc = NULL;
if (-1 == mcdx_readtoc(stuffp))
return -1;
}
stuffp->xxx = 0;
}
switch (cmd) {
case CDROMSTART:{
xtrace(IOCTL, "ioctl() START\n");
/* Spin up the drive. Don't think we can do this.
* For now, ignore it.
*/
return 0;
}
case CDROMSTOP:{
xtrace(IOCTL, "ioctl() STOP\n");
stuffp->audiostatus = CDROM_AUDIO_INVALID;
if (-1 == mcdx_stop(stuffp, 1))
return -EIO;
return 0;
}
case CDROMPLAYTRKIND:{
struct cdrom_ti *ti = (struct cdrom_ti *) arg;
xtrace(IOCTL, "ioctl() PLAYTRKIND\n");
if ((ti->cdti_trk0 < stuffp->di.n_first)
|| (ti->cdti_trk0 > stuffp->di.n_last)
|| (ti->cdti_trk1 < stuffp->di.n_first))
return -EINVAL;
if (ti->cdti_trk1 > stuffp->di.n_last)
ti->cdti_trk1 = stuffp->di.n_last;
xtrace(PLAYTRK, "ioctl() track %d to %d\n",
ti->cdti_trk0, ti->cdti_trk1);
return mcdx_playtrk(stuffp, ti);
}
case CDROMPLAYMSF:{
struct cdrom_msf *msf = (struct cdrom_msf *) arg;
xtrace(IOCTL, "ioctl() PLAYMSF\n");
if ((stuffp->audiostatus == CDROM_AUDIO_PLAY)
&& (-1 == mcdx_hold(stuffp, 1)))
return -EIO;
msf->cdmsf_min0 = uint2bcd(msf->cdmsf_min0);
msf->cdmsf_sec0 = uint2bcd(msf->cdmsf_sec0);
msf->cdmsf_frame0 = uint2bcd(msf->cdmsf_frame0);
msf->cdmsf_min1 = uint2bcd(msf->cdmsf_min1);
msf->cdmsf_sec1 = uint2bcd(msf->cdmsf_sec1);
msf->cdmsf_frame1 = uint2bcd(msf->cdmsf_frame1);
stuffp->stop.dt.minute = msf->cdmsf_min1;
stuffp->stop.dt.second = msf->cdmsf_sec1;
stuffp->stop.dt.frame = msf->cdmsf_frame1;
return mcdx_playmsf(stuffp, msf);
}
case CDROMRESUME:{
xtrace(IOCTL, "ioctl() RESUME\n");
return mcdx_playtrk(stuffp, NULL);
}
case CDROMREADTOCENTRY:{
struct cdrom_tocentry *entry =
(struct cdrom_tocentry *) arg;
struct s_subqcode *tp = NULL;
xtrace(IOCTL, "ioctl() READTOCENTRY\n");
if (-1 == mcdx_readtoc(stuffp))
return -1;
if (entry->cdte_track == CDROM_LEADOUT)
tp = &stuffp->toc[stuffp->di.n_last -
stuffp->di.n_first + 1];
else if (entry->cdte_track > stuffp->di.n_last
|| entry->cdte_track < stuffp->di.n_first)
return -EINVAL;
else
tp = &stuffp->toc[entry->cdte_track -
stuffp->di.n_first];
if (NULL == tp)
return -EIO;
entry->cdte_adr = tp->control;
entry->cdte_ctrl = tp->control >> 4;
/* Always return stuff in MSF, and let the Uniform cdrom driver
worry about what the user actually wants */
entry->cdte_addr.msf.minute =
bcd2uint(tp->dt.minute);
entry->cdte_addr.msf.second =
bcd2uint(tp->dt.second);
entry->cdte_addr.msf.frame =
bcd2uint(tp->dt.frame);
return 0;
}
case CDROMSUBCHNL:{
struct cdrom_subchnl *sub =
(struct cdrom_subchnl *) arg;
struct s_subqcode q;
xtrace(IOCTL, "ioctl() SUBCHNL\n");
if (-1 == mcdx_requestsubqcode(stuffp, &q, 2))
return -EIO;
xtrace(SUBCHNL, "audiostatus: %x\n",
stuffp->audiostatus);
sub->cdsc_audiostatus = stuffp->audiostatus;
sub->cdsc_adr = q.control;
sub->cdsc_ctrl = q.control >> 4;
sub->cdsc_trk = bcd2uint(q.tno);
sub->cdsc_ind = bcd2uint(q.index);
xtrace(SUBCHNL, "trk %d, ind %d\n",
sub->cdsc_trk, sub->cdsc_ind);
/* Always return stuff in MSF, and let the Uniform cdrom driver
worry about what the user actually wants */
sub->cdsc_absaddr.msf.minute =
bcd2uint(q.dt.minute);
sub->cdsc_absaddr.msf.second =
bcd2uint(q.dt.second);
sub->cdsc_absaddr.msf.frame = bcd2uint(q.dt.frame);
sub->cdsc_reladdr.msf.minute =
bcd2uint(q.tt.minute);
sub->cdsc_reladdr.msf.second =
bcd2uint(q.tt.second);
sub->cdsc_reladdr.msf.frame = bcd2uint(q.tt.frame);
xtrace(SUBCHNL,
"msf: abs %02d:%02d:%02d, rel %02d:%02d:%02d\n",
sub->cdsc_absaddr.msf.minute,
sub->cdsc_absaddr.msf.second,
sub->cdsc_absaddr.msf.frame,
sub->cdsc_reladdr.msf.minute,
sub->cdsc_reladdr.msf.second,
sub->cdsc_reladdr.msf.frame);
return 0;
}
case CDROMREADTOCHDR:{
struct cdrom_tochdr *toc =
(struct cdrom_tochdr *) arg;
xtrace(IOCTL, "ioctl() READTOCHDR\n");
toc->cdth_trk0 = stuffp->di.n_first;
toc->cdth_trk1 = stuffp->di.n_last;
xtrace(TOCHDR,
"ioctl() track0 = %d, track1 = %d\n",
stuffp->di.n_first, stuffp->di.n_last);
return 0;
}
case CDROMPAUSE:{
xtrace(IOCTL, "ioctl() PAUSE\n");
if (stuffp->audiostatus != CDROM_AUDIO_PLAY)
return -EINVAL;
if (-1 == mcdx_stop(stuffp, 1))
return -EIO;
stuffp->audiostatus = CDROM_AUDIO_PAUSED;
if (-1 ==
mcdx_requestsubqcode(stuffp, &stuffp->start,
1))
return -EIO;
return 0;
}
case CDROMMULTISESSION:{
struct cdrom_multisession *ms =
(struct cdrom_multisession *) arg;
xtrace(IOCTL, "ioctl() MULTISESSION\n");
/* Always return stuff in LBA, and let the Uniform cdrom driver
worry about what the user actually wants */
ms->addr.lba = msf2log(&stuffp->multi.msf_last);
ms->xa_flag = !!stuffp->multi.multi;
xtrace(MS,
"ioctl() (%d, 0x%08x [%02x:%02x.%02x])\n",
ms->xa_flag, ms->addr.lba,
stuffp->multi.msf_last.minute,
stuffp->multi.msf_last.second,
stuffp->multi.msf_last.frame);
return 0;
}
case CDROMEJECT:{
xtrace(IOCTL, "ioctl() EJECT\n");
if (stuffp->users > 1)
return -EBUSY;
return (mcdx_tray_move(cdi, 1));
}
case CDROMCLOSETRAY:{
xtrace(IOCTL, "ioctl() CDROMCLOSETRAY\n");
return (mcdx_tray_move(cdi, 0));
}
case CDROMVOLCTRL:{
struct cdrom_volctrl *volctrl =
(struct cdrom_volctrl *) arg;
xtrace(IOCTL, "ioctl() VOLCTRL\n");
#if 0 /* not tested! */
/* adjust for the weirdness of workman (md) */
/* can't test it (hs) */
volctrl.channel2 = volctrl.channel1;
volctrl.channel1 = volctrl.channel3 = 0x00;
#endif
return mcdx_setattentuator(stuffp, volctrl, 2);
}
default:
return -EINVAL;
}
}
static void do_mcdx_request(request_queue_t * q)
{
struct s_drive_stuff *stuffp;
struct request *req;
again:
req = elv_next_request(q);
if (!req)
return;
stuffp = req->rq_disk->private_data;
if (!stuffp->present) {
xwarn("do_request(): bad device: %s\n",req->rq_disk->disk_name);
xtrace(REQUEST, "end_request(0): bad device\n");
end_request(req, 0);
return;
}
if (stuffp->audio) {
xwarn("do_request() attempt to read from audio cd\n");
xtrace(REQUEST, "end_request(0): read from audio\n");
end_request(req, 0);
return;
}
xtrace(REQUEST, "do_request() (%lu + %lu)\n",
req->sector, req->nr_sectors);
if (req->cmd != READ) {
xwarn("do_request(): non-read command to cd!!\n");
xtrace(REQUEST, "end_request(0): write\n");
end_request(req, 0);
return;
}
else {
stuffp->status = 0;
while (req->nr_sectors) {
int i;
i = mcdx_transfer(stuffp,
req->buffer,
req->sector,
req->nr_sectors);
if (i == -1) {
end_request(req, 0);
goto again;
}
req->sector += i;
req->nr_sectors -= i;
req->buffer += (i * 512);
}
end_request(req, 1);
goto again;
xtrace(REQUEST, "end_request(1)\n");
end_request(req, 1);
}
goto again;
}
static int mcdx_open(struct cdrom_device_info *cdi, int purpose)
{
struct s_drive_stuff *stuffp;
xtrace(OPENCLOSE, "open()\n");
stuffp = cdi->handle;
if (!stuffp->present)
return -ENXIO;
/* Make the modules looking used ... (thanx bjorn).
* But we shouldn't forget to decrement the module counter
* on error return */
/* this is only done to test if the drive talks with us */
if (-1 == mcdx_getstatus(stuffp, 1))
return -EIO;
if (stuffp->xxx) {
xtrace(OPENCLOSE, "open() media changed\n");
stuffp->audiostatus = CDROM_AUDIO_INVALID;
stuffp->readcmd = 0;
xtrace(OPENCLOSE, "open() Request multisession info\n");
if (-1 ==
mcdx_requestmultidiskinfo(stuffp, &stuffp->multi, 6))
xinfo("No multidiskinfo\n");
} else {
/* multisession ? */
if (!stuffp->multi.multi)
stuffp->multi.msf_last.second = 2;
xtrace(OPENCLOSE, "open() MS: %d, last @ %02x:%02x.%02x\n",
stuffp->multi.multi,
stuffp->multi.msf_last.minute,
stuffp->multi.msf_last.second,
stuffp->multi.msf_last.frame);
{;
} /* got multisession information */
/* request the disks table of contents (aka diskinfo) */
if (-1 == mcdx_requesttocdata(stuffp, &stuffp->di, 1)) {
stuffp->lastsector = -1;
} else {
stuffp->lastsector = (CD_FRAMESIZE / 512)
* msf2log(&stuffp->di.msf_leadout) - 1;
xtrace(OPENCLOSE,
"open() start %d (%02x:%02x.%02x) %d\n",
stuffp->di.n_first,
stuffp->di.msf_first.minute,
stuffp->di.msf_first.second,
stuffp->di.msf_first.frame,
msf2log(&stuffp->di.msf_first));
xtrace(OPENCLOSE,
"open() last %d (%02x:%02x.%02x) %d\n",
stuffp->di.n_last,
stuffp->di.msf_leadout.minute,
stuffp->di.msf_leadout.second,
stuffp->di.msf_leadout.frame,
msf2log(&stuffp->di.msf_leadout));
}
if (stuffp->toc) {
xtrace(MALLOC, "open() free old toc @ %p\n",
stuffp->toc);
kfree(stuffp->toc);
stuffp->toc = NULL;
}
xtrace(OPENCLOSE, "open() init irq generation\n");
if (-1 == mcdx_config(stuffp, 1))
return -EIO;
#ifdef FALLBACK
/* Set the read speed */
xwarn("AAA %x AAA\n", stuffp->readcmd);
if (stuffp->readerrs)
stuffp->readcmd = READ1X;
else
stuffp->readcmd =
stuffp->present | SINGLE ? READ1X : READ2X;
xwarn("XXX %x XXX\n", stuffp->readcmd);
#else
stuffp->readcmd =
stuffp->present | SINGLE ? READ1X : READ2X;
#endif
/* try to get the first sector, iff any ... */
if (stuffp->lastsector >= 0) {
char buf[512];
int ans;
int tries;
stuffp->xa = 0;
stuffp->audio = 0;
for (tries = 6; tries; tries--) {
stuffp->introk = 1;
xtrace(OPENCLOSE, "open() try as %s\n",
stuffp->xa ? "XA" : "normal");
/* set data mode */
if (-1 == (ans = mcdx_setdatamode(stuffp,
stuffp->
xa ?
MODE2 :
MODE1,
1))) {
/* return -EIO; */
stuffp->xa = 0;
break;
}
if ((stuffp->audio = e_audio(ans)))
break;
while (0 ==
(ans =
mcdx_transfer(stuffp, buf, 0, 1)));
if (ans == 1)
break;
stuffp->xa = !stuffp->xa;
}
}
/* xa disks will be read in raw mode, others not */
if (-1 == mcdx_setdrivemode(stuffp,
stuffp->xa ? RAW : COOKED,
1))
return -EIO;
if (stuffp->audio) {
xinfo("open() audio disk found\n");
} else if (stuffp->lastsector >= 0) {
xinfo("open() %s%s disk found\n",
stuffp->xa ? "XA / " : "",
stuffp->multi.
multi ? "Multi Session" : "Single Session");
}
}
stuffp->xxx = 0;
stuffp->users++;
return 0;
}
static void mcdx_close(struct cdrom_device_info *cdi)
{
struct s_drive_stuff *stuffp;
xtrace(OPENCLOSE, "close()\n");
stuffp = cdi->handle;
--stuffp->users;
}
static int mcdx_media_changed(struct cdrom_device_info *cdi, int disc_nr)
/* Return: 1 if media changed since last call to this function
0 otherwise */
{
struct s_drive_stuff *stuffp;
xinfo("mcdx_media_changed called for device %s\n", cdi->name);
stuffp = cdi->handle;
mcdx_getstatus(stuffp, 1);
if (stuffp->yyy == 0)
return 0;
stuffp->yyy = 0;
return 1;
}
#ifndef MODULE
static int __init mcdx_setup(char *str)
{
int pi[4];
(void) get_options(str, ARRAY_SIZE(pi), pi);
if (pi[0] > 0)
mcdx_drive_map[0][0] = pi[1];
if (pi[0] > 1)
mcdx_drive_map[0][1] = pi[2];
return 1;
}
__setup("mcdx=", mcdx_setup);
#endif
/* DIRTY PART ******************************************************/
static void mcdx_delay(struct s_drive_stuff *stuff, long jifs)
/* This routine is used for sleeping.
* A jifs value <0 means NO sleeping,
* =0 means minimal sleeping (let the kernel
* run for other processes)
* >0 means at least sleep for that amount.
* May be we could use a simple count loop w/ jumps to itself, but
* I wanna make this independent of cpu speed. [1 jiffy is 1/HZ] sec */
{
if (jifs < 0)
return;
xtrace(SLEEP, "*** delay: sleepq\n");
interruptible_sleep_on_timeout(&stuff->sleepq, jifs);
xtrace(SLEEP, "delay awoken\n");
if (signal_pending(current)) {
xtrace(SLEEP, "got signal\n");
}
}
static irqreturn_t mcdx_intr(int irq, void *dev_id)
{
struct s_drive_stuff *stuffp = dev_id;
unsigned char b;
#ifdef AK2
if (!stuffp->busy && stuffp->pending)
stuffp->int_err = 1;
#endif /* AK2 */
/* get the interrupt status */
b = inb(stuffp->rreg_status);
stuffp->introk = ~b & MCDX_RBIT_DTEN;
/* NOTE: We only should get interrupts if the data we
* requested are ready to transfer.
* But the drive seems to generate ``asynchronous'' interrupts
* on several error conditions too. (Despite the err int enable
* setting during initialisation) */
/* if not ok, read the next byte as the drives status */
if (!stuffp->introk) {
xtrace(IRQ, "intr() irq %d hw status 0x%02x\n", irq, b);
if (~b & MCDX_RBIT_STEN) {
xinfo("intr() irq %d status 0x%02x\n",
irq, inb(stuffp->rreg_data));
} else {
xinfo("intr() irq %d ambiguous hw status\n", irq);
}
} else {
xtrace(IRQ, "irq() irq %d ok, status %02x\n", irq, b);
}
stuffp->busy = 0;
wake_up_interruptible(&stuffp->busyq);
return IRQ_HANDLED;
}
static int mcdx_talk(struct s_drive_stuff *stuffp,
const unsigned char *cmd, size_t cmdlen,
void *buffer, size_t size, unsigned int timeout, int tries)
/* Send a command to the drive, wait for the result.
* returns -1 on timeout, drive status otherwise
* If buffer is not zero, the result (length size) is stored there.
* If buffer is zero the size should be the number of bytes to read
* from the drive. These bytes are discarded.
*/
{
int st;
char c;
int discard;
/* Somebody wants the data read? */
if ((discard = (buffer == NULL)))
buffer = &c;
while (stuffp->lock) {
xtrace(SLEEP, "*** talk: lockq\n");
interruptible_sleep_on(&stuffp->lockq);
xtrace(SLEEP, "talk: awoken\n");
}
stuffp->lock = 1;
/* An operation other then reading data destroys the
* data already requested and remembered in stuffp->request, ... */
stuffp->valid = 0;
#if MCDX_DEBUG & TALK
{
unsigned char i;
xtrace(TALK,
"talk() %d / %d tries, res.size %d, command 0x%02x",
tries, timeout, size, (unsigned char) cmd[0]);
for (i = 1; i < cmdlen; i++)
xtrace(TALK, " 0x%02x", cmd[i]);
xtrace(TALK, "\n");
}
#endif
/* give up if all tries are done (bad) or if the status
* st != -1 (good) */
for (st = -1; st == -1 && tries; tries--) {
char *bp = (char *) buffer;
size_t sz = size;
outsb(stuffp->wreg_data, cmd, cmdlen);
xtrace(TALK, "talk() command sent\n");
/* get the status byte */
if (-1 == mcdx_getval(stuffp, timeout, 0, bp)) {
xinfo("talk() %02x timed out (status), %d tr%s left\n",
cmd[0], tries - 1, tries == 2 ? "y" : "ies");
continue;
}
st = *bp;
sz--;
if (!discard)
bp++;
xtrace(TALK, "talk() got status 0x%02x\n", st);
/* command error? */
if (e_cmderr(st)) {
xwarn("command error cmd = %02x %s \n",
cmd[0], cmdlen > 1 ? "..." : "");
st = -1;
continue;
}
/* audio status? */
if (stuffp->audiostatus == CDROM_AUDIO_INVALID)
stuffp->audiostatus =
e_audiobusy(st) ? CDROM_AUDIO_PLAY :
CDROM_AUDIO_NO_STATUS;
else if (stuffp->audiostatus == CDROM_AUDIO_PLAY
&& e_audiobusy(st) == 0)
stuffp->audiostatus = CDROM_AUDIO_COMPLETED;
/* media change? */
if (e_changed(st)) {
xinfo("talk() media changed\n");
stuffp->xxx = stuffp->yyy = 1;
}
/* now actually get the data */
while (sz--) {
if (-1 == mcdx_getval(stuffp, timeout, 0, bp)) {
xinfo("talk() %02x timed out (data), %d tr%s left\n",
cmd[0], tries - 1,
tries == 2 ? "y" : "ies");
st = -1;
break;
}
if (!discard)
bp++;
xtrace(TALK, "talk() got 0x%02x\n", *(bp - 1));
}
}
#if !MCDX_QUIET
if (!tries && st == -1)
xinfo("talk() giving up\n");
#endif
stuffp->lock = 0;
wake_up_interruptible(&stuffp->lockq);
xtrace(TALK, "talk() done with 0x%02x\n", st);
return st;
}
/* MODULE STUFF ***********************************************************/
static int __init __mcdx_init(void)
{
int i;
int drives = 0;
mcdx_init();
for (i = 0; i < MCDX_NDRIVES; i++) {
if (mcdx_stuffp[i]) {
xtrace(INIT, "init_module() drive %d stuff @ %p\n",
i, mcdx_stuffp[i]);
drives++;
}
}
if (!drives)
return -EIO;
return 0;
}
static void __exit mcdx_exit(void)
{
int i;
xinfo("cleanup_module called\n");
for (i = 0; i < MCDX_NDRIVES; i++) {
struct s_drive_stuff *stuffp = mcdx_stuffp[i];
if (!stuffp)
continue;
del_gendisk(stuffp->disk);
if (unregister_cdrom(&stuffp->info)) {
printk(KERN_WARNING "Can't unregister cdrom mcdx\n");
continue;
}
put_disk(stuffp->disk);
release_region(stuffp->wreg_data, MCDX_IO_SIZE);
free_irq(stuffp->irq, NULL);
if (stuffp->toc) {
xtrace(MALLOC, "cleanup_module() free toc @ %p\n",
stuffp->toc);
kfree(stuffp->toc);
}
xtrace(MALLOC, "cleanup_module() free stuffp @ %p\n",
stuffp);
mcdx_stuffp[i] = NULL;
kfree(stuffp);
}
if (unregister_blkdev(MAJOR_NR, "mcdx") != 0) {
xwarn("cleanup() unregister_blkdev() failed\n");
}
blk_cleanup_queue(mcdx_queue);
#if !MCDX_QUIET
else
xinfo("cleanup() succeeded\n");
#endif
}
#ifdef MODULE
module_init(__mcdx_init);
#endif
module_exit(mcdx_exit);
/* Support functions ************************************************/
static int __init mcdx_init_drive(int drive)
{
struct s_version version;
struct gendisk *disk;
struct s_drive_stuff *stuffp;
int size = sizeof(*stuffp);
char msg[80];
xtrace(INIT, "init() try drive %d\n", drive);
xtrace(INIT, "kmalloc space for stuffpt's\n");
xtrace(MALLOC, "init() malloc %d bytes\n", size);
if (!(stuffp = kzalloc(size, GFP_KERNEL))) {
xwarn("init() malloc failed\n");
return 1;
}
disk = alloc_disk(1);
if (!disk) {
xwarn("init() malloc failed\n");
kfree(stuffp);
return 1;
}
xtrace(INIT, "init() got %d bytes for drive stuff @ %p\n",
sizeof(*stuffp), stuffp);
/* set default values */
stuffp->present = 0; /* this should be 0 already */
stuffp->toc = NULL; /* this should be NULL already */
/* setup our irq and i/o addresses */
stuffp->irq = irq(mcdx_drive_map[drive]);
stuffp->wreg_data = stuffp->rreg_data = port(mcdx_drive_map[drive]);
stuffp->wreg_reset = stuffp->rreg_status = stuffp->wreg_data + 1;
stuffp->wreg_hcon = stuffp->wreg_reset + 1;
stuffp->wreg_chn = stuffp->wreg_hcon + 1;
init_waitqueue_head(&stuffp->busyq);
init_waitqueue_head(&stuffp->lockq);
init_waitqueue_head(&stuffp->sleepq);
/* check if i/o addresses are available */
if (!request_region(stuffp->wreg_data, MCDX_IO_SIZE, "mcdx")) {
xwarn("0x%03x,%d: Init failed. "
"I/O ports (0x%03x..0x%03x) already in use.\n",
stuffp->wreg_data, stuffp->irq,
stuffp->wreg_data,
stuffp->wreg_data + MCDX_IO_SIZE - 1);
xtrace(MALLOC, "init() free stuffp @ %p\n", stuffp);
kfree(stuffp);
put_disk(disk);
xtrace(INIT, "init() continue at next drive\n");
return 0; /* next drive */
}
xtrace(INIT, "init() i/o port is available at 0x%03x\n"
stuffp->wreg_data);
xtrace(INIT, "init() hardware reset\n");
mcdx_reset(stuffp, HARD, 1);
xtrace(INIT, "init() get version\n");
if (-1 == mcdx_requestversion(stuffp, &version, 4)) {
/* failed, next drive */
release_region(stuffp->wreg_data, MCDX_IO_SIZE);
xwarn("%s=0x%03x,%d: Init failed. Can't get version.\n",
MCDX, stuffp->wreg_data, stuffp->irq);
xtrace(MALLOC, "init() free stuffp @ %p\n", stuffp);
kfree(stuffp);
put_disk(disk);
xtrace(INIT, "init() continue at next drive\n");
return 0;
}
switch (version.code) {
case 'D':
stuffp->readcmd = READ2X;
stuffp->present = DOUBLE | DOOR | MULTI;
break;
case 'F':
stuffp->readcmd = READ1X;
stuffp->present = SINGLE | DOOR | MULTI;
break;
case 'M':
stuffp->readcmd = READ1X;
stuffp->present = SINGLE;
break;
default:
stuffp->present = 0;
break;
}
stuffp->playcmd = READ1X;
if (!stuffp->present) {
release_region(stuffp->wreg_data, MCDX_IO_SIZE);
xwarn("%s=0x%03x,%d: Init failed. No Mitsumi CD-ROM?.\n",
MCDX, stuffp->wreg_data, stuffp->irq);
kfree(stuffp);
put_disk(disk);
return 0; /* next drive */
}
xtrace(INIT, "init() register blkdev\n");
if (register_blkdev(MAJOR_NR, "mcdx")) {
release_region(stuffp->wreg_data, MCDX_IO_SIZE);
kfree(stuffp);
put_disk(disk);
return 1;
}
mcdx_queue = blk_init_queue(do_mcdx_request, &mcdx_lock);
if (!mcdx_queue) {
unregister_blkdev(MAJOR_NR, "mcdx");
release_region(stuffp->wreg_data, MCDX_IO_SIZE);
kfree(stuffp);
put_disk(disk);
return 1;
}
xtrace(INIT, "init() subscribe irq and i/o\n");
if (request_irq(stuffp->irq, mcdx_intr, IRQF_DISABLED, "mcdx", stuffp)) {
release_region(stuffp->wreg_data, MCDX_IO_SIZE);
xwarn("%s=0x%03x,%d: Init failed. Can't get irq (%d).\n",
MCDX, stuffp->wreg_data, stuffp->irq, stuffp->irq);
stuffp->irq = 0;
blk_cleanup_queue(mcdx_queue);
kfree(stuffp);
put_disk(disk);
return 0;
}
xtrace(INIT, "init() get garbage\n");
{
int i;
mcdx_delay(stuffp, HZ / 2);
for (i = 100; i; i--)
(void) inb(stuffp->rreg_status);
}
#ifdef WE_KNOW_WHY
/* irq 11 -> channel register */
outb(0x50, stuffp->wreg_chn);
#endif
xtrace(INIT, "init() set non dma but irq mode\n");
mcdx_config(stuffp, 1);
stuffp->info.ops = &mcdx_dops;
stuffp->info.speed = 2;
stuffp->info.capacity = 1;
stuffp->info.handle = stuffp;
sprintf(stuffp->info.name, "mcdx%d", drive);
disk->major = MAJOR_NR;
disk->first_minor = drive;
strcpy(disk->disk_name, stuffp->info.name);
disk->fops = &mcdx_bdops;
disk->flags = GENHD_FL_CD;
stuffp->disk = disk;
sprintf(msg, " mcdx: Mitsumi CD-ROM installed at 0x%03x, irq %d."
" (Firmware version %c %x)\n",
stuffp->wreg_data, stuffp->irq, version.code, version.ver);
mcdx_stuffp[drive] = stuffp;
xtrace(INIT, "init() mcdx_stuffp[%d] = %p\n", drive, stuffp);
if (register_cdrom(&stuffp->info) != 0) {
printk("Cannot register Mitsumi CD-ROM!\n");
free_irq(stuffp->irq, NULL);
release_region(stuffp->wreg_data, MCDX_IO_SIZE);
kfree(stuffp);
put_disk(disk);
if (unregister_blkdev(MAJOR_NR, "mcdx") != 0)
xwarn("cleanup() unregister_blkdev() failed\n");
blk_cleanup_queue(mcdx_queue);
return 2;
}
disk->private_data = stuffp;
disk->queue = mcdx_queue;
add_disk(disk);
printk(msg);
return 0;
}
static int __init mcdx_init(void)
{
int drive;
xwarn("Version 2.14(hs) \n");
xwarn("$Id: mcdx.c,v 1.21 1997/01/26 07:12:59 davem Exp $\n");
/* zero the pointer array */
for (drive = 0; drive < MCDX_NDRIVES; drive++)
mcdx_stuffp[drive] = NULL;
/* do the initialisation */
for (drive = 0; drive < MCDX_NDRIVES; drive++) {
switch (mcdx_init_drive(drive)) {
case 2:
return -EIO;
case 1:
break;
}
}
return 0;
}
static int mcdx_transfer(struct s_drive_stuff *stuffp,
char *p, int sector, int nr_sectors)
/* This seems to do the actually transfer. But it does more. It
keeps track of errors occurred and will (if possible) fall back
to single speed on error.
Return: -1 on timeout or other error
else status byte (as in stuff->st) */
{
int ans;
ans = mcdx_xfer(stuffp, p, sector, nr_sectors);
return ans;
#ifdef FALLBACK
if (-1 == ans)
stuffp->readerrs++;
else
return ans;
if (stuffp->readerrs && stuffp->readcmd == READ1X) {
xwarn("XXX Already reading 1x -- no chance\n");
return -1;
}
xwarn("XXX Fallback to 1x\n");
stuffp->readcmd = READ1X;
return mcdx_transfer(stuffp, p, sector, nr_sectors);
#endif
}
static int mcdx_xfer(struct s_drive_stuff *stuffp,
char *p, int sector, int nr_sectors)
/* This does actually the transfer from the drive.
Return: -1 on timeout or other error
else status byte (as in stuff->st) */
{
int border;
int done = 0;
long timeout;
if (stuffp->audio) {
xwarn("Attempt to read from audio CD.\n");
return -1;
}
if (!stuffp->readcmd) {
xinfo("Can't transfer from missing disk.\n");
return -1;
}
while (stuffp->lock) {
interruptible_sleep_on(&stuffp->lockq);
}
if (stuffp->valid && (sector >= stuffp->pending)
&& (sector < stuffp->low_border)) {
/* All (or at least a part of the sectors requested) seems
* to be already requested, so we don't need to bother the
* drive with new requests ...
* Wait for the drive become idle, but first
* check for possible occurred errors --- the drive
* seems to report them asynchronously */
border = stuffp->high_border < (border =
sector + nr_sectors)
? stuffp->high_border : border;
stuffp->lock = current->pid;
do {
while (stuffp->busy) {
timeout =
interruptible_sleep_on_timeout
(&stuffp->busyq, 5 * HZ);
if (!stuffp->introk) {
xtrace(XFER,
"error via interrupt\n");
} else if (!timeout) {
xtrace(XFER, "timeout\n");
} else if (signal_pending(current)) {
xtrace(XFER, "signal\n");
} else
continue;
stuffp->lock = 0;
stuffp->busy = 0;
stuffp->valid = 0;
wake_up_interruptible(&stuffp->lockq);
xtrace(XFER, "transfer() done (-1)\n");
return -1;
}
/* check if we need to set the busy flag (as we
* expect an interrupt */
stuffp->busy = (3 == (stuffp->pending & 3));
/* Test if it's the first sector of a block,
* there we have to skip some bytes as we read raw data */
if (stuffp->xa && (0 == (stuffp->pending & 3))) {
const int HEAD =
CD_FRAMESIZE_RAW - CD_XA_TAIL -
CD_FRAMESIZE;
insb(stuffp->rreg_data, p, HEAD);
}
/* now actually read the data */
insb(stuffp->rreg_data, p, 512);
/* test if it's the last sector of a block,
* if so, we have to handle XA special */
if ((3 == (stuffp->pending & 3)) && stuffp->xa) {
char dummy[CD_XA_TAIL];
insb(stuffp->rreg_data, &dummy[0], CD_XA_TAIL);
}
if (stuffp->pending == sector) {
p += 512;
done++;
sector++;
}
} while (++(stuffp->pending) < border);
stuffp->lock = 0;
wake_up_interruptible(&stuffp->lockq);
} else {
/* The requested sector(s) is/are out of the
* already requested range, so we have to bother the drive
* with a new request. */
static unsigned char cmd[] = {
0,
0, 0, 0,
0, 0, 0
};
cmd[0] = stuffp->readcmd;
/* The numbers held in ->pending, ..., should be valid */
stuffp->valid = 1;
stuffp->pending = sector & ~3;
/* do some sanity checks */
if (stuffp->pending > stuffp->lastsector) {
xwarn
("transfer() sector %d from nirvana requested.\n",
stuffp->pending);
stuffp->status = MCDX_ST_EOM;
stuffp->valid = 0;
xtrace(XFER, "transfer() done (-1)\n");
return -1;
}
if ((stuffp->low_border = stuffp->pending + DIRECT_SIZE)
> stuffp->lastsector + 1) {
xtrace(XFER, "cut low_border\n");
stuffp->low_border = stuffp->lastsector + 1;
}
if ((stuffp->high_border = stuffp->pending + REQUEST_SIZE)
> stuffp->lastsector + 1) {
xtrace(XFER, "cut high_border\n");
stuffp->high_border = stuffp->lastsector + 1;
}
{ /* Convert the sector to be requested to MSF format */
struct cdrom_msf0 pending;
log2msf(stuffp->pending / 4, &pending);
cmd[1] = pending.minute;
cmd[2] = pending.second;
cmd[3] = pending.frame;
}
cmd[6] =
(unsigned
char) ((stuffp->high_border - stuffp->pending) / 4);
xtrace(XFER, "[%2d]\n", cmd[6]);
stuffp->busy = 1;
/* Now really issue the request command */
outsb(stuffp->wreg_data, cmd, sizeof cmd);
}
#ifdef AK2
if (stuffp->int_err) {
stuffp->valid = 0;
stuffp->int_err = 0;
return -1;
}
#endif /* AK2 */
stuffp->low_border = (stuffp->low_border +=
done) <
stuffp->high_border ? stuffp->low_border : stuffp->high_border;
return done;
}
/* Access to elements of the mcdx_drive_map members */
static unsigned port(int *ip)
{
return ip[0];
}
static int irq(int *ip)
{
return ip[1];
}
/* Misc number converters */
static unsigned int bcd2uint(unsigned char c)
{
return (c >> 4) * 10 + (c & 0x0f);
}
static unsigned int uint2bcd(unsigned int ival)
{
return ((ival / 10) << 4) | (ival % 10);
}
static void log2msf(unsigned int l, struct cdrom_msf0 *pmsf)
{
l += CD_MSF_OFFSET;
pmsf->minute = uint2bcd(l / 4500), l %= 4500;
pmsf->second = uint2bcd(l / 75);
pmsf->frame = uint2bcd(l % 75);
}
static unsigned int msf2log(const struct cdrom_msf0 *pmsf)
{
return bcd2uint(pmsf->frame)
+ bcd2uint(pmsf->second) * 75
+ bcd2uint(pmsf->minute) * 4500 - CD_MSF_OFFSET;
}
int mcdx_readtoc(struct s_drive_stuff *stuffp)
/* Read the toc entries from the CD,
* Return: -1 on failure, else 0 */
{
if (stuffp->toc) {
xtrace(READTOC, "ioctl() toc already read\n");
return 0;
}
xtrace(READTOC, "ioctl() readtoc for %d tracks\n",
stuffp->di.n_last - stuffp->di.n_first + 1);
if (-1 == mcdx_hold(stuffp, 1))
return -1;
xtrace(READTOC, "ioctl() tocmode\n");
if (-1 == mcdx_setdrivemode(stuffp, TOC, 1))
return -EIO;
/* all seems to be ok so far ... malloc */
{
int size;
size =
sizeof(struct s_subqcode) * (stuffp->di.n_last -
stuffp->di.n_first + 2);
xtrace(MALLOC, "ioctl() malloc %d bytes\n", size);
stuffp->toc = kmalloc(size, GFP_KERNEL);
if (!stuffp->toc) {
xwarn("Cannot malloc %d bytes for toc\n", size);
mcdx_setdrivemode(stuffp, DATA, 1);
return -EIO;
}
}
/* now read actually the index */
{
int trk;
int retries;
for (trk = 0;
trk < (stuffp->di.n_last - stuffp->di.n_first + 1);
trk++)
stuffp->toc[trk].index = 0;
for (retries = 300; retries; retries--) { /* why 300? */
struct s_subqcode q;
unsigned int idx;
if (-1 == mcdx_requestsubqcode(stuffp, &q, 1)) {
mcdx_setdrivemode(stuffp, DATA, 1);
return -EIO;
}
idx = bcd2uint(q.index);
if ((idx > 0)
&& (idx <= stuffp->di.n_last)
&& (q.tno == 0)
&& (stuffp->toc[idx - stuffp->di.n_first].
index == 0)) {
stuffp->toc[idx - stuffp->di.n_first] = q;
xtrace(READTOC,
"ioctl() toc idx %d (trk %d)\n",
idx, trk);
trk--;
}
if (trk == 0)
break;
}
memset(&stuffp->
toc[stuffp->di.n_last - stuffp->di.n_first + 1], 0,
sizeof(stuffp->toc[0]));
stuffp->toc[stuffp->di.n_last - stuffp->di.n_first +
1].dt = stuffp->di.msf_leadout;
}
/* unset toc mode */
xtrace(READTOC, "ioctl() undo toc mode\n");
if (-1 == mcdx_setdrivemode(stuffp, DATA, 2))
return -EIO;
#if MCDX_DEBUG && READTOC
{
int trk;
for (trk = 0;
trk < (stuffp->di.n_last - stuffp->di.n_first + 2);
trk++)
xtrace(READTOC, "ioctl() %d readtoc %02x %02x %02x"
" %02x:%02x.%02x %02x:%02x.%02x\n",
trk + stuffp->di.n_first,
stuffp->toc[trk].control,
stuffp->toc[trk].tno,
stuffp->toc[trk].index,
stuffp->toc[trk].tt.minute,
stuffp->toc[trk].tt.second,
stuffp->toc[trk].tt.frame,
stuffp->toc[trk].dt.minute,
stuffp->toc[trk].dt.second,
stuffp->toc[trk].dt.frame);
}
#endif
return 0;
}
static int
mcdx_playmsf(struct s_drive_stuff *stuffp, const struct cdrom_msf *msf)
{
unsigned char cmd[7] = {
0, 0, 0, 0, 0, 0, 0
};
if (!stuffp->readcmd) {
xinfo("Can't play from missing disk.\n");
return -1;
}
cmd[0] = stuffp->playcmd;
cmd[1] = msf->cdmsf_min0;
cmd[2] = msf->cdmsf_sec0;
cmd[3] = msf->cdmsf_frame0;
cmd[4] = msf->cdmsf_min1;
cmd[5] = msf->cdmsf_sec1;
cmd[6] = msf->cdmsf_frame1;
xtrace(PLAYMSF, "ioctl(): play %x "
"%02x:%02x:%02x -- %02x:%02x:%02x\n",
cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6]);
outsb(stuffp->wreg_data, cmd, sizeof cmd);
if (-1 == mcdx_getval(stuffp, 3 * HZ, 0, NULL)) {
xwarn("playmsf() timeout\n");
return -1;
}
stuffp->audiostatus = CDROM_AUDIO_PLAY;
return 0;
}
static int
mcdx_playtrk(struct s_drive_stuff *stuffp, const struct cdrom_ti *ti)
{
struct s_subqcode *p;
struct cdrom_msf msf;
if (-1 == mcdx_readtoc(stuffp))
return -1;
if (ti)
p = &stuffp->toc[ti->cdti_trk0 - stuffp->di.n_first];
else
p = &stuffp->start;
msf.cdmsf_min0 = p->dt.minute;
msf.cdmsf_sec0 = p->dt.second;
msf.cdmsf_frame0 = p->dt.frame;
if (ti) {
p = &stuffp->toc[ti->cdti_trk1 - stuffp->di.n_first + 1];
stuffp->stop = *p;
} else
p = &stuffp->stop;
msf.cdmsf_min1 = p->dt.minute;
msf.cdmsf_sec1 = p->dt.second;
msf.cdmsf_frame1 = p->dt.frame;
return mcdx_playmsf(stuffp, &msf);
}
/* Drive functions ************************************************/
static int mcdx_tray_move(struct cdrom_device_info *cdi, int position)
{
struct s_drive_stuff *stuffp = cdi->handle;
if (!stuffp->present)
return -ENXIO;
if (!(stuffp->present & DOOR))
return -ENOSYS;
if (position) /* 1: eject */
return mcdx_talk(stuffp, "\xf6", 1, NULL, 1, 5 * HZ, 3);
else /* 0: close */
return mcdx_talk(stuffp, "\xf8", 1, NULL, 1, 5 * HZ, 3);
return 1;
}
static int mcdx_stop(struct s_drive_stuff *stuffp, int tries)
{
return mcdx_talk(stuffp, "\xf0", 1, NULL, 1, 2 * HZ, tries);
}
static int mcdx_hold(struct s_drive_stuff *stuffp, int tries)
{
return mcdx_talk(stuffp, "\x70", 1, NULL, 1, 2 * HZ, tries);
}
static int mcdx_requestsubqcode(struct s_drive_stuff *stuffp,
struct s_subqcode *sub, int tries)
{
char buf[11];
int ans;
if (-1 == (ans = mcdx_talk(stuffp, "\x20", 1, buf, sizeof(buf),
2 * HZ, tries)))
return -1;
sub->control = buf[1];
sub->tno = buf[2];
sub->index = buf[3];
sub->tt.minute = buf[4];
sub->tt.second = buf[5];
sub->tt.frame = buf[6];
sub->dt.minute = buf[8];
sub->dt.second = buf[9];
sub->dt.frame = buf[10];
return ans;
}
static int mcdx_requestmultidiskinfo(struct s_drive_stuff *stuffp,
struct s_multi *multi, int tries)
{
char buf[5];
int ans;
if (stuffp->present & MULTI) {
ans =
mcdx_talk(stuffp, "\x11", 1, buf, sizeof(buf), 2 * HZ,
tries);
multi->multi = buf[1];
multi->msf_last.minute = buf[2];
multi->msf_last.second = buf[3];
multi->msf_last.frame = buf[4];
return ans;
} else {
multi->multi = 0;
return 0;
}
}
static int mcdx_requesttocdata(struct s_drive_stuff *stuffp, struct s_diskinfo *info,
int tries)
{
char buf[9];
int ans;
ans =
mcdx_talk(stuffp, "\x10", 1, buf, sizeof(buf), 2 * HZ, tries);
if (ans == -1) {
info->n_first = 0;
info->n_last = 0;
} else {
info->n_first = bcd2uint(buf[1]);
info->n_last = bcd2uint(buf[2]);
info->msf_leadout.minute = buf[3];
info->msf_leadout.second = buf[4];
info->msf_leadout.frame = buf[5];
info->msf_first.minute = buf[6];
info->msf_first.second = buf[7];
info->msf_first.frame = buf[8];
}
return ans;
}
static int mcdx_setdrivemode(struct s_drive_stuff *stuffp, enum drivemodes mode,
int tries)
{
char cmd[2];
int ans;
xtrace(HW, "setdrivemode() %d\n", mode);
if (-1 == (ans = mcdx_talk(stuffp, "\xc2", 1, cmd, sizeof(cmd), 5 * HZ, tries)))
return -1;
switch (mode) {
case TOC:
cmd[1] |= 0x04;
break;
case DATA:
cmd[1] &= ~0x04;
break;
case RAW:
cmd[1] |= 0x40;
break;
case COOKED:
cmd[1] &= ~0x40;
break;
default:
break;
}
cmd[0] = 0x50;
return mcdx_talk(stuffp, cmd, 2, NULL, 1, 5 * HZ, tries);
}
static int mcdx_setdatamode(struct s_drive_stuff *stuffp, enum datamodes mode,
int tries)
{
unsigned char cmd[2] = { 0xa0 };
xtrace(HW, "setdatamode() %d\n", mode);
switch (mode) {
case MODE0:
cmd[1] = 0x00;
break;
case MODE1:
cmd[1] = 0x01;
break;
case MODE2:
cmd[1] = 0x02;
break;
default:
return -EINVAL;
}
return mcdx_talk(stuffp, cmd, 2, NULL, 1, 5 * HZ, tries);
}
static int mcdx_config(struct s_drive_stuff *stuffp, int tries)
{
char cmd[4];
xtrace(HW, "config()\n");
cmd[0] = 0x90;
cmd[1] = 0x10; /* irq enable */
cmd[2] = 0x05; /* pre, err irq enable */
if (-1 == mcdx_talk(stuffp, cmd, 3, NULL, 1, 1 * HZ, tries))
return -1;
cmd[1] = 0x02; /* dma select */
cmd[2] = 0x00; /* no dma */
return mcdx_talk(stuffp, cmd, 3, NULL, 1, 1 * HZ, tries);
}
static int mcdx_requestversion(struct s_drive_stuff *stuffp, struct s_version *ver,
int tries)
{
char buf[3];
int ans;
if (-1 == (ans = mcdx_talk(stuffp, "\xdc",
1, buf, sizeof(buf), 2 * HZ, tries)))
return ans;
ver->code = buf[1];
ver->ver = buf[2];
return ans;
}
static int mcdx_reset(struct s_drive_stuff *stuffp, enum resetmodes mode, int tries)
{
if (mode == HARD) {
outb(0, stuffp->wreg_chn); /* no dma, no irq -> hardware */
outb(0, stuffp->wreg_reset); /* hw reset */
return 0;
} else
return mcdx_talk(stuffp, "\x60", 1, NULL, 1, 5 * HZ, tries);
}
static int mcdx_lockdoor(struct cdrom_device_info *cdi, int lock)
{
struct s_drive_stuff *stuffp = cdi->handle;
char cmd[2] = { 0xfe };
if (!(stuffp->present & DOOR))
return -ENOSYS;
if (stuffp->present & DOOR) {
cmd[1] = lock ? 0x01 : 0x00;
return mcdx_talk(stuffp, cmd, sizeof(cmd), NULL, 1, 5 * HZ, 3);
} else
return 0;
}
static int mcdx_getstatus(struct s_drive_stuff *stuffp, int tries)
{
return mcdx_talk(stuffp, "\x40", 1, NULL, 1, 5 * HZ, tries);
}
static int
mcdx_getval(struct s_drive_stuff *stuffp, int to, int delay, char *buf)
{
unsigned long timeout = to + jiffies;
char c;
if (!buf)
buf = &c;
while (inb(stuffp->rreg_status) & MCDX_RBIT_STEN) {
if (time_after(jiffies, timeout))
return -1;
mcdx_delay(stuffp, delay);
}
*buf = (unsigned char) inb(stuffp->rreg_data) & 0xff;
return 0;
}
static int mcdx_setattentuator(struct s_drive_stuff *stuffp,
struct cdrom_volctrl *vol, int tries)
{
char cmd[5];
cmd[0] = 0xae;
cmd[1] = vol->channel0;
cmd[2] = 0;
cmd[3] = vol->channel1;
cmd[4] = 0;
return mcdx_talk(stuffp, cmd, sizeof(cmd), NULL, 5, 200, tries);
}
MODULE_LICENSE("GPL");
MODULE_ALIAS_BLOCKDEV_MAJOR(MITSUMI_X_CDROM_MAJOR);
Reference in New Issue View Git Blame Copy Permalink