git.oblomov.eu Git - linux-2.6/blob - drivers/cdrom/mcdx.c

   1 /*
   2  * The Mitsumi CDROM interface
   3  * Copyright (C) 1995 1996 Heiko Schlittermann <heiko@lotte.sax.de>
   4  * VERSION: 2.14(hs)
   5  *
   6  * ... anyway, I'm back again, thanks to Marcin, he adopted
   7  * large portions of my code (at least the parts containing
   8  * my main thoughts ...)
   9  *
  10  ****************** H E L P *********************************
  11  * If you ever plan to update your CD ROM drive and perhaps
  12  * want to sell or simply give away your Mitsumi FX-001[DS]
  13  * -- Please --
  14  * mail me (heiko@lotte.sax.de).  When my last drive goes
  15  * ballistic no more driver support will be available from me!
  16  *************************************************************
  17  *
  18  * This program is free software; you can redistribute it and/or modify
  19  * it under the terms of the GNU General Public License as published by
  20  * the Free Software Foundation; either version 2, or (at your option)
  21  * any later version.
  22  *
  23  * This program is distributed in the hope that it will be useful,
  24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  * GNU General Public License for more details.
  27  *
  28  * You should have received a copy of the GNU General Public License
  29  * along with this program; see the file COPYING.  If not, write to
  30  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  31  *
  32  * Thanks to
  33  *  The Linux Community at all and ...
  34  *  Martin Harriss (he wrote the first Mitsumi Driver)
  35  *  Eberhard Moenkeberg (he gave me much support and the initial kick)
  36  *  Bernd Huebner, Ruediger Helsch (Unifix-Software GmbH, they
  37  *      improved the original driver)
  38  *  Jon Tombs, Bjorn Ekwall (module support)
  39  *  Daniel v. Mosnenck (he sent me the Technical and Programming Reference)
  40  *  Gerd Knorr (he lent me his PhotoCD)
  41  *  Nils Faerber and Roger E. Wolff (extensively tested the LU portion)
  42  *  Andreas Kies (testing the mysterious hang-ups)
  43  *  Heiko Eissfeldt (VERIFY_READ/WRITE)
  44  *  Marcin Dalecki (improved performance, shortened code)
  45  *  ... somebody forgotten?
  46  *
  47  *  9 November 1999 -- Make kernel-parameter implementation work with 2.3.x
  48  *                     Removed init_module & cleanup_module in favor of
  49  *                     module_init & module_exit.
  50  *                     Torben Mathiasen <tmm@image.dk>
  51  */
  52
  53
  54 #if RCS
  55 static const char *mcdx_c_version
  56     = "$Id: mcdx.c,v 1.21 1997/01/26 07:12:59 davem Exp $";
  57 #endif
  58
  59 #include <linux/module.h>
  60
  61 #include <linux/errno.h>
  62 #include <linux/interrupt.h>
  63 #include <linux/fs.h>
  64 #include <linux/kernel.h>
  65 #include <linux/cdrom.h>
  66 #include <linux/ioport.h>
  67 #include <linux/mm.h>
  68 #include <linux/slab.h>
  69 #include <linux/init.h>
  70 #include <asm/io.h>
  71 #include <asm/current.h>
  72 #include <asm/uaccess.h>
  73
  74 #include <linux/major.h>
  75 #define MAJOR_NR MITSUMI_X_CDROM_MAJOR
  76 #include <linux/blkdev.h>
  77 #include <linux/devfs_fs_kernel.h>
  78
  79 #include "mcdx.h"
  80
  81 #ifndef HZ
  82 #error HZ not defined
  83 #endif
  84
  85 #define xwarn(fmt, args...) printk(KERN_WARNING MCDX " " fmt, ## args)
  86
  87 #if !MCDX_QUIET
  88 #define xinfo(fmt, args...) printk(KERN_INFO MCDX " " fmt, ## args)
  89 #else
  90 #define xinfo(fmt, args...) { ; }
  91 #endif
  92
  93 #if MCDX_DEBUG
  94 #define xtrace(lvl, fmt, args...) \
  95                 { if (lvl > 0) \
  96                         { printk(KERN_DEBUG MCDX ":: " fmt, ## args); } }
  97 #define xdebug(fmt, args...) printk(KERN_DEBUG MCDX ":: " fmt, ## args)
  98 #else
  99 #define xtrace(lvl, fmt, args...) { ; }
 100 #define xdebug(fmt, args...) { ; }
 101 #endif
 102
 103 /* CONSTANTS *******************************************************/
 104
 105 /* Following are the number of sectors we _request_ from the drive
 106    every time an access outside the already requested range is done.
 107    The _direct_ size is the number of sectors we're allowed to skip
 108    directly (performing a read instead of requesting the new sector
 109    needed */
 110 static const int REQUEST_SIZE = 800;    /* should be less then 255 * 4 */
 111 static const int DIRECT_SIZE = 400;     /* should be less then REQUEST_SIZE */
 112
 113 enum drivemodes { TOC, DATA, RAW, COOKED };
 114 enum datamodes { MODE0, MODE1, MODE2 };
 115 enum resetmodes { SOFT, HARD };
 116
 117 static const int SINGLE = 0x01;         /* single speed drive (FX001S, LU) */
 118 static const int DOUBLE = 0x02;         /* double speed drive (FX001D, ..? */
 119 static const int DOOR = 0x04;           /* door locking capability */
 120 static const int MULTI = 0x08;          /* multi session capability */
 121
 122 static const unsigned char READ1X = 0xc0;
 123 static const unsigned char READ2X = 0xc1;
 124
 125
 126 /* DECLARATIONS ****************************************************/
 127 struct s_subqcode {
 128         unsigned char control;
 129         unsigned char tno;
 130         unsigned char index;
 131         struct cdrom_msf0 tt;
 132         struct cdrom_msf0 dt;
 133 };
 134
 135 struct s_diskinfo {
 136         unsigned int n_first;
 137         unsigned int n_last;
 138         struct cdrom_msf0 msf_leadout;
 139         struct cdrom_msf0 msf_first;
 140 };
 141
 142 struct s_multi {
 143         unsigned char multi;
 144         struct cdrom_msf0 msf_last;
 145 };
 146
 147 struct s_version {
 148         unsigned char code;
 149         unsigned char ver;
 150 };
 151
 152 /* Per drive/controller stuff **************************************/
 153
 154 struct s_drive_stuff {
 155         /* waitqueues */
 156         wait_queue_head_t busyq;
 157         wait_queue_head_t lockq;
 158         wait_queue_head_t sleepq;
 159
 160         /* flags */
 161         volatile int introk;    /* status of last irq operation */
 162         volatile int busy;      /* drive performs an operation */
 163         volatile int lock;      /* exclusive usage */
 164
 165         /* cd infos */
 166         struct s_diskinfo di;
 167         struct s_multi multi;
 168         struct s_subqcode *toc; /* first entry of the toc array */
 169         struct s_subqcode start;
 170         struct s_subqcode stop;
 171         int xa;                 /* 1 if xa disk */
 172         int audio;              /* 1 if audio disk */
 173         int audiostatus;
 174
 175         /* `buffer' control */
 176         volatile int valid;     /* pending, ..., values are valid */
 177         volatile int pending;   /* next sector to be read */
 178         volatile int low_border;        /* first sector not to be skipped direct */
 179         volatile int high_border;       /* first sector `out of area' */
 180 #ifdef AK2
 181         volatile int int_err;
 182 #endif                          /* AK2 */
 183
 184         /* adds and odds */
 185         unsigned wreg_data;     /* w data */
 186         unsigned wreg_reset;    /* w hardware reset */
 187         unsigned wreg_hcon;     /* w hardware conf */
 188         unsigned wreg_chn;      /* w channel */
 189         unsigned rreg_data;     /* r data */
 190         unsigned rreg_status;   /* r status */
 191
 192         int irq;                /* irq used by this drive */
 193         int present;            /* drive present and its capabilities */
 194         unsigned char readcmd;  /* read cmd depends on single/double speed */
 195         unsigned char playcmd;  /* play should always be single speed */
 196         unsigned int xxx;       /* set if changed, reset while open */
 197         unsigned int yyy;       /* set if changed, reset by media_changed */
 198         int users;              /* keeps track of open/close */
 199         int lastsector;         /* last block accessible */
 200         int status;             /* last operation's error / status */
 201         int readerrs;           /* # of blocks read w/o error */
 202         struct cdrom_device_info info;
 203         struct gendisk *disk;
 204 };
 205
 206
 207 /* Prototypes ******************************************************/
 208
 209 /*      The following prototypes are already declared elsewhere.  They are
 210         repeated here to show what's going on.  And to sense, if they're
 211         changed elsewhere. */
 212
 213 static int mcdx_init(void);
 214
 215 static int mcdx_block_open(struct inode *inode, struct file *file)
 216 {
 217         struct s_drive_stuff *p = inode->i_bdev->bd_disk->private_data;
 218         return cdrom_open(&p->info, inode, file);
 219 }
 220
 221 static int mcdx_block_release(struct inode *inode, struct file *file)
 222 {
 223         struct s_drive_stuff *p = inode->i_bdev->bd_disk->private_data;
 224         return cdrom_release(&p->info, file);
 225 }
 226
 227 static int mcdx_block_ioctl(struct inode *inode, struct file *file,
 228                                 unsigned cmd, unsigned long arg)
 229 {
 230         struct s_drive_stuff *p = inode->i_bdev->bd_disk->private_data;
 231         return cdrom_ioctl(file, &p->info, inode, cmd, arg);
 232 }
 233
 234 static int mcdx_block_media_changed(struct gendisk *disk)
 235 {
 236         struct s_drive_stuff *p = disk->private_data;
 237         return cdrom_media_changed(&p->info);
 238 }
 239
 240 static struct block_device_operations mcdx_bdops =
 241 {
 242         .owner          = THIS_MODULE,
 243         .open           = mcdx_block_open,
 244         .release        = mcdx_block_release,
 245         .ioctl          = mcdx_block_ioctl,
 246         .media_changed  = mcdx_block_media_changed,
 247 };
 248
 249
 250 /*      Indirect exported functions. These functions are exported by their
 251         addresses, such as mcdx_open and mcdx_close in the
 252         structure mcdx_dops. */
 253
 254 /* exported by file_ops */
 255 static int mcdx_open(struct cdrom_device_info *cdi, int purpose);
 256 static void mcdx_close(struct cdrom_device_info *cdi);
 257 static int mcdx_media_changed(struct cdrom_device_info *cdi, int disc_nr);
 258 static int mcdx_tray_move(struct cdrom_device_info *cdi, int position);
 259 static int mcdx_lockdoor(struct cdrom_device_info *cdi, int lock);
 260 static int mcdx_audio_ioctl(struct cdrom_device_info *cdi,
 261                             unsigned int cmd, void *arg);
 262
 263 /* misc internal support functions */
 264 static void log2msf(unsigned int, struct cdrom_msf0 *);
 265 static unsigned int msf2log(const struct cdrom_msf0 *);
 266 static unsigned int uint2bcd(unsigned int);
 267 static unsigned int bcd2uint(unsigned char);
 268 static unsigned port(int *);
 269 static int irq(int *);
 270 static void mcdx_delay(struct s_drive_stuff *, long jifs);
 271 static int mcdx_transfer(struct s_drive_stuff *, char *buf, int sector,
 272                          int nr_sectors);
 273 static int mcdx_xfer(struct s_drive_stuff *, char *buf, int sector,
 274                      int nr_sectors);
 275
 276 static int mcdx_config(struct s_drive_stuff *, int);
 277 static int mcdx_requestversion(struct s_drive_stuff *, struct s_version *,
 278                                int);
 279 static int mcdx_stop(struct s_drive_stuff *, int);
 280 static int mcdx_hold(struct s_drive_stuff *, int);
 281 static int mcdx_reset(struct s_drive_stuff *, enum resetmodes, int);
 282 static int mcdx_setdrivemode(struct s_drive_stuff *, enum drivemodes, int);
 283 static int mcdx_setdatamode(struct s_drive_stuff *, enum datamodes, int);
 284 static int mcdx_requestsubqcode(struct s_drive_stuff *,
 285                                 struct s_subqcode *, int);
 286 static int mcdx_requestmultidiskinfo(struct s_drive_stuff *,
 287                                      struct s_multi *, int);
 288 static int mcdx_requesttocdata(struct s_drive_stuff *, struct s_diskinfo *,
 289                                int);
 290 static int mcdx_getstatus(struct s_drive_stuff *, int);
 291 static int mcdx_getval(struct s_drive_stuff *, int to, int delay, char *);
 292 static int mcdx_talk(struct s_drive_stuff *,
 293                      const unsigned char *cmd, size_t,
 294                      void *buffer, size_t size, unsigned int timeout, int);
 295 static int mcdx_readtoc(struct s_drive_stuff *);
 296 static int mcdx_playtrk(struct s_drive_stuff *, const struct cdrom_ti *);
 297 static int mcdx_playmsf(struct s_drive_stuff *, const struct cdrom_msf *);
 298 static int mcdx_setattentuator(struct s_drive_stuff *,
 299                                struct cdrom_volctrl *, int);
 300
 301 /* static variables ************************************************/
 302
 303 static int mcdx_drive_map[][2] = MCDX_DRIVEMAP;
 304 static struct s_drive_stuff *mcdx_stuffp[MCDX_NDRIVES];
 305 static DEFINE_SPINLOCK(mcdx_lock);
 306 static struct request_queue *mcdx_queue;
 307
 308 /* You can only set the first two pairs, from old MODULE_PARM code.  */
 309 static int mcdx_set(const char *val, struct kernel_param *kp)
 310 {
 311         get_options((char *)val, 4, (int *)mcdx_drive_map);
 312         return 0;
 313 }
 314 module_param_call(mcdx, mcdx_set, NULL, NULL, 0);
 315
 316 static struct cdrom_device_ops mcdx_dops = {
 317         .open           = mcdx_open,
 318         .release        = mcdx_close,
 319         .media_changed  = mcdx_media_changed,
 320         .tray_move      = mcdx_tray_move,
 321         .lock_door      = mcdx_lockdoor,
 322         .audio_ioctl    = mcdx_audio_ioctl,
 323         .capability     = CDC_OPEN_TRAY | CDC_LOCK | CDC_MEDIA_CHANGED |
 324                           CDC_PLAY_AUDIO | CDC_DRIVE_STATUS,
 325 };
 326
 327 /* KERNEL INTERFACE FUNCTIONS **************************************/
 328
 329
 330 static int mcdx_audio_ioctl(struct cdrom_device_info *cdi,
 331                             unsigned int cmd, void *arg)
 332 {
 333         struct s_drive_stuff *stuffp = cdi->handle;
 334
 335         if (!stuffp->present)
 336                 return -ENXIO;
 337
 338         if (stuffp->xxx) {
 339                 if (-1 == mcdx_requesttocdata(stuffp, &stuffp->di, 1)) {
 340                         stuffp->lastsector = -1;
 341                 } else {
 342                         stuffp->lastsector = (CD_FRAMESIZE / 512)
 343                             * msf2log(&stuffp->di.msf_leadout) - 1;
 344                 }
 345
 346                 if (stuffp->toc) {
 347                         kfree(stuffp->toc);
 348                         stuffp->toc = NULL;
 349                         if (-1 == mcdx_readtoc(stuffp))
 350                                 return -1;
 351                 }
 352
 353                 stuffp->xxx = 0;
 354         }
 355
 356         switch (cmd) {
 357         case CDROMSTART:{
 358                         xtrace(IOCTL, "ioctl() START\n");
 359                         /* Spin up the drive.  Don't think we can do this.
 360                            * For now, ignore it.
 361                          */
 362                         return 0;
 363                 }
 364
 365         case CDROMSTOP:{
 366                         xtrace(IOCTL, "ioctl() STOP\n");
 367                         stuffp->audiostatus = CDROM_AUDIO_INVALID;
 368                         if (-1 == mcdx_stop(stuffp, 1))
 369                                 return -EIO;
 370                         return 0;
 371                 }
 372
 373         case CDROMPLAYTRKIND:{
 374                         struct cdrom_ti *ti = (struct cdrom_ti *) arg;
 375
 376                         xtrace(IOCTL, "ioctl() PLAYTRKIND\n");
 377                         if ((ti->cdti_trk0 < stuffp->di.n_first)
 378                             || (ti->cdti_trk0 > stuffp->di.n_last)
 379                             || (ti->cdti_trk1 < stuffp->di.n_first))
 380                                 return -EINVAL;
 381                         if (ti->cdti_trk1 > stuffp->di.n_last)
 382                                 ti->cdti_trk1 = stuffp->di.n_last;
 383                         xtrace(PLAYTRK, "ioctl() track %d to %d\n",
 384                                ti->cdti_trk0, ti->cdti_trk1);
 385                         return mcdx_playtrk(stuffp, ti);
 386                 }
 387
 388         case CDROMPLAYMSF:{
 389                         struct cdrom_msf *msf = (struct cdrom_msf *) arg;
 390
 391                         xtrace(IOCTL, "ioctl() PLAYMSF\n");
 392
 393                         if ((stuffp->audiostatus == CDROM_AUDIO_PLAY)
 394                             && (-1 == mcdx_hold(stuffp, 1)))
 395                                 return -EIO;
 396
 397                         msf->cdmsf_min0 = uint2bcd(msf->cdmsf_min0);
 398                         msf->cdmsf_sec0 = uint2bcd(msf->cdmsf_sec0);
 399                         msf->cdmsf_frame0 = uint2bcd(msf->cdmsf_frame0);
 400
 401                         msf->cdmsf_min1 = uint2bcd(msf->cdmsf_min1);
 402                         msf->cdmsf_sec1 = uint2bcd(msf->cdmsf_sec1);
 403                         msf->cdmsf_frame1 = uint2bcd(msf->cdmsf_frame1);
 404
 405                         stuffp->stop.dt.minute = msf->cdmsf_min1;
 406                         stuffp->stop.dt.second = msf->cdmsf_sec1;
 407                         stuffp->stop.dt.frame = msf->cdmsf_frame1;
 408
 409                         return mcdx_playmsf(stuffp, msf);
 410                 }
 411
 412         case CDROMRESUME:{
 413                         xtrace(IOCTL, "ioctl() RESUME\n");
 414                         return mcdx_playtrk(stuffp, NULL);
 415                 }
 416
 417         case CDROMREADTOCENTRY:{
 418                         struct cdrom_tocentry *entry =
 419                             (struct cdrom_tocentry *) arg;
 420                         struct s_subqcode *tp = NULL;
 421                         xtrace(IOCTL, "ioctl() READTOCENTRY\n");
 422
 423                         if (-1 == mcdx_readtoc(stuffp))
 424                                 return -1;
 425                         if (entry->cdte_track == CDROM_LEADOUT)
 426                                 tp = &stuffp->toc[stuffp->di.n_last -
 427                                                   stuffp->di.n_first + 1];
 428                         else if (entry->cdte_track > stuffp->di.n_last
 429                                  || entry->cdte_track < stuffp->di.n_first)
 430                                 return -EINVAL;
 431                         else
 432                                 tp = &stuffp->toc[entry->cdte_track -
 433                                                   stuffp->di.n_first];
 434
 435                         if (NULL == tp)
 436                                 return -EIO;
 437                         entry->cdte_adr = tp->control;
 438                         entry->cdte_ctrl = tp->control >> 4;
 439                         /* Always return stuff in MSF, and let the Uniform cdrom driver
 440                            worry about what the user actually wants */
 441                         entry->cdte_addr.msf.minute =
 442                             bcd2uint(tp->dt.minute);
 443                         entry->cdte_addr.msf.second =
 444                             bcd2uint(tp->dt.second);
 445                         entry->cdte_addr.msf.frame =
 446                             bcd2uint(tp->dt.frame);
 447                         return 0;
 448                 }
 449
 450         case CDROMSUBCHNL:{
 451                         struct cdrom_subchnl *sub =
 452                             (struct cdrom_subchnl *) arg;
 453                         struct s_subqcode q;
 454
 455                         xtrace(IOCTL, "ioctl() SUBCHNL\n");
 456
 457                         if (-1 == mcdx_requestsubqcode(stuffp, &q, 2))
 458                                 return -EIO;
 459
 460                         xtrace(SUBCHNL, "audiostatus: %x\n",
 461                                stuffp->audiostatus);
 462                         sub->cdsc_audiostatus = stuffp->audiostatus;
 463                         sub->cdsc_adr = q.control;
 464                         sub->cdsc_ctrl = q.control >> 4;
 465                         sub->cdsc_trk = bcd2uint(q.tno);
 466                         sub->cdsc_ind = bcd2uint(q.index);
 467
 468                         xtrace(SUBCHNL, "trk %d, ind %d\n",
 469                                sub->cdsc_trk, sub->cdsc_ind);
 470                         /* Always return stuff in MSF, and let the Uniform cdrom driver
 471                            worry about what the user actually wants */
 472                         sub->cdsc_absaddr.msf.minute =
 473                             bcd2uint(q.dt.minute);
 474                         sub->cdsc_absaddr.msf.second =
 475                             bcd2uint(q.dt.second);
 476                         sub->cdsc_absaddr.msf.frame = bcd2uint(q.dt.frame);
 477                         sub->cdsc_reladdr.msf.minute =
 478                             bcd2uint(q.tt.minute);
 479                         sub->cdsc_reladdr.msf.second =
 480                             bcd2uint(q.tt.second);
 481                         sub->cdsc_reladdr.msf.frame = bcd2uint(q.tt.frame);
 482                         xtrace(SUBCHNL,
 483                                "msf: abs %02d:%02d:%02d, rel %02d:%02d:%02d\n",
 484                                sub->cdsc_absaddr.msf.minute,
 485                                sub->cdsc_absaddr.msf.second,
 486                                sub->cdsc_absaddr.msf.frame,
 487                                sub->cdsc_reladdr.msf.minute,
 488                                sub->cdsc_reladdr.msf.second,
 489                                sub->cdsc_reladdr.msf.frame);
 490
 491                         return 0;
 492                 }
 493
 494         case CDROMREADTOCHDR:{
 495                         struct cdrom_tochdr *toc =
 496                             (struct cdrom_tochdr *) arg;
 497
 498                         xtrace(IOCTL, "ioctl() READTOCHDR\n");
 499                         toc->cdth_trk0 = stuffp->di.n_first;
 500                         toc->cdth_trk1 = stuffp->di.n_last;
 501                         xtrace(TOCHDR,
 502                                "ioctl() track0 = %d, track1 = %d\n",
 503                                stuffp->di.n_first, stuffp->di.n_last);
 504                         return 0;
 505                 }
 506
 507         case CDROMPAUSE:{
 508                         xtrace(IOCTL, "ioctl() PAUSE\n");
 509                         if (stuffp->audiostatus != CDROM_AUDIO_PLAY)
 510                                 return -EINVAL;
 511                         if (-1 == mcdx_stop(stuffp, 1))
 512                                 return -EIO;
 513                         stuffp->audiostatus = CDROM_AUDIO_PAUSED;
 514                         if (-1 ==
 515                             mcdx_requestsubqcode(stuffp, &stuffp->start,
 516                                                  1))
 517                                 return -EIO;
 518                         return 0;
 519                 }
 520
 521         case CDROMMULTISESSION:{
 522                         struct cdrom_multisession *ms =
 523                             (struct cdrom_multisession *) arg;
 524                         xtrace(IOCTL, "ioctl() MULTISESSION\n");
 525                         /* Always return stuff in LBA, and let the Uniform cdrom driver
 526                            worry about what the user actually wants */
 527                         ms->addr.lba = msf2log(&stuffp->multi.msf_last);
 528                         ms->xa_flag = !!stuffp->multi.multi;
 529                         xtrace(MS,
 530                                "ioctl() (%d, 0x%08x [%02x:%02x.%02x])\n",
 531                                ms->xa_flag, ms->addr.lba,
 532                                stuffp->multi.msf_last.minute,
 533                                stuffp->multi.msf_last.second,
 534                                stuffp->multi.msf_last.frame);
 535
 536                         return 0;
 537                 }
 538
 539         case CDROMEJECT:{
 540                         xtrace(IOCTL, "ioctl() EJECT\n");
 541                         if (stuffp->users > 1)
 542                                 return -EBUSY;
 543                         return (mcdx_tray_move(cdi, 1));
 544                 }
 545
 546         case CDROMCLOSETRAY:{
 547                         xtrace(IOCTL, "ioctl() CDROMCLOSETRAY\n");
 548                         return (mcdx_tray_move(cdi, 0));
 549                 }
 550
 551         case CDROMVOLCTRL:{
 552                         struct cdrom_volctrl *volctrl =
 553                             (struct cdrom_volctrl *) arg;
 554                         xtrace(IOCTL, "ioctl() VOLCTRL\n");
 555
 556 #if 0                           /* not tested! */
 557                         /* adjust for the weirdness of workman (md) */
 558                         /* can't test it (hs) */
 559                         volctrl.channel2 = volctrl.channel1;
 560                         volctrl.channel1 = volctrl.channel3 = 0x00;
 561 #endif
 562                         return mcdx_setattentuator(stuffp, volctrl, 2);
 563                 }
 564
 565         default:
 566                 return -EINVAL;
 567         }
 568 }
 569
 570 static void do_mcdx_request(request_queue_t * q)
 571 {
 572         struct s_drive_stuff *stuffp;
 573         struct request *req;
 574
 575       again:
 576
 577         req = elv_next_request(q);
 578         if (!req)
 579                 return;
 580
 581         stuffp = req->rq_disk->private_data;
 582
 583         if (!stuffp->present) {
 584                 xwarn("do_request(): bad device: %s\n",req->rq_disk->disk_name);
 585                 xtrace(REQUEST, "end_request(0): bad device\n");
 586                 end_request(req, 0);
 587                 return;
 588         }
 589
 590         if (stuffp->audio) {
 591                 xwarn("do_request() attempt to read from audio cd\n");
 592                 xtrace(REQUEST, "end_request(0): read from audio\n");
 593                 end_request(req, 0);
 594                 return;
 595         }
 596
 597         xtrace(REQUEST, "do_request() (%lu + %lu)\n",
 598                req->sector, req->nr_sectors);
 599
 600         if (req->cmd != READ) {
 601                 xwarn("do_request(): non-read command to cd!!\n");
 602                 xtrace(REQUEST, "end_request(0): write\n");
 603                 end_request(req, 0);
 604                 return;
 605         }
 606         else {
 607                 stuffp->status = 0;
 608                 while (req->nr_sectors) {
 609                         int i;
 610
 611                         i = mcdx_transfer(stuffp,
 612                                           req->buffer,
 613                                           req->sector,
 614                                           req->nr_sectors);
 615
 616                         if (i == -1) {
 617                                 end_request(req, 0);
 618                                 goto again;
 619                         }
 620                         req->sector += i;
 621                         req->nr_sectors -= i;
 622                         req->buffer += (i * 512);
 623                 }
 624                 end_request(req, 1);
 625                 goto again;
 626
 627                 xtrace(REQUEST, "end_request(1)\n");
 628                 end_request(req, 1);
 629         }
 630
 631         goto again;
 632 }
 633
 634 static int mcdx_open(struct cdrom_device_info *cdi, int purpose)
 635 {
 636         struct s_drive_stuff *stuffp;
 637         xtrace(OPENCLOSE, "open()\n");
 638         stuffp = cdi->handle;
 639         if (!stuffp->present)
 640                 return -ENXIO;
 641
 642         /* Make the modules looking used ... (thanx bjorn).
 643          * But we shouldn't forget to decrement the module counter
 644          * on error return */
 645
 646         /* this is only done to test if the drive talks with us */
 647         if (-1 == mcdx_getstatus(stuffp, 1))
 648                 return -EIO;
 649
 650         if (stuffp->xxx) {
 651
 652                 xtrace(OPENCLOSE, "open() media changed\n");
 653                 stuffp->audiostatus = CDROM_AUDIO_INVALID;
 654                 stuffp->readcmd = 0;
 655                 xtrace(OPENCLOSE, "open() Request multisession info\n");
 656                 if (-1 ==
 657                     mcdx_requestmultidiskinfo(stuffp, &stuffp->multi, 6))
 658                         xinfo("No multidiskinfo\n");
 659         } else {
 660                 /* multisession ? */
 661                 if (!stuffp->multi.multi)
 662                         stuffp->multi.msf_last.second = 2;
 663
 664                 xtrace(OPENCLOSE, "open() MS: %d, last @ %02x:%02x.%02x\n",
 665                        stuffp->multi.multi,
 666                        stuffp->multi.msf_last.minute,
 667                        stuffp->multi.msf_last.second,
 668                        stuffp->multi.msf_last.frame);
 669
 670                 {;
 671                 }               /* got multisession information */
 672                 /* request the disks table of contents (aka diskinfo) */
 673                 if (-1 == mcdx_requesttocdata(stuffp, &stuffp->di, 1)) {
 674
 675                         stuffp->lastsector = -1;
 676
 677                 } else {
 678
 679                         stuffp->lastsector = (CD_FRAMESIZE / 512)
 680                             * msf2log(&stuffp->di.msf_leadout) - 1;
 681
 682                         xtrace(OPENCLOSE,
 683                                "open() start %d (%02x:%02x.%02x) %d\n",
 684                                stuffp->di.n_first,
 685                                stuffp->di.msf_first.minute,
 686                                stuffp->di.msf_first.second,
 687                                stuffp->di.msf_first.frame,
 688                                msf2log(&stuffp->di.msf_first));
 689                         xtrace(OPENCLOSE,
 690                                "open() last %d (%02x:%02x.%02x) %d\n",
 691                                stuffp->di.n_last,
 692                                stuffp->di.msf_leadout.minute,
 693                                stuffp->di.msf_leadout.second,
 694                                stuffp->di.msf_leadout.frame,
 695                                msf2log(&stuffp->di.msf_leadout));
 696                 }
 697
 698                 if (stuffp->toc) {
 699                         xtrace(MALLOC, "open() free old toc @ %p\n",
 700                                stuffp->toc);
 701                         kfree(stuffp->toc);
 702
 703                         stuffp->toc = NULL;
 704                 }
 705
 706                 xtrace(OPENCLOSE, "open() init irq generation\n");
 707                 if (-1 == mcdx_config(stuffp, 1))
 708                         return -EIO;
 709 #if FALLBACK
 710                 /* Set the read speed */
 711                 xwarn("AAA %x AAA\n", stuffp->readcmd);
 712                 if (stuffp->readerrs)
 713                         stuffp->readcmd = READ1X;
 714                 else
 715                         stuffp->readcmd =
 716                             stuffp->present | SINGLE ? READ1X : READ2X;
 717                 xwarn("XXX %x XXX\n", stuffp->readcmd);
 718 #else
 719                 stuffp->readcmd =
 720                     stuffp->present | SINGLE ? READ1X : READ2X;
 721 #endif
 722
 723                 /* try to get the first sector, iff any ... */
 724                 if (stuffp->lastsector >= 0) {
 725                         char buf[512];
 726                         int ans;
 727                         int tries;
 728
 729                         stuffp->xa = 0;
 730                         stuffp->audio = 0;
 731
 732                         for (tries = 6; tries; tries--) {
 733
 734                                 stuffp->introk = 1;
 735
 736                                 xtrace(OPENCLOSE, "open() try as %s\n",
 737                                        stuffp->xa ? "XA" : "normal");
 738                                 /* set data mode */
 739                                 if (-1 == (ans = mcdx_setdatamode(stuffp,
 740                                                                   stuffp->
 741                                                                   xa ?
 742                                                                   MODE2 :
 743                                                                   MODE1,
 744                                                                   1))) {
 745                                         /* return -EIO; */
 746                                         stuffp->xa = 0;
 747                                         break;
 748                                 }
 749
 750                                 if ((stuffp->audio = e_audio(ans)))
 751                                         break;
 752
 753                                 while (0 ==
 754                                        (ans =
 755                                         mcdx_transfer(stuffp, buf, 0, 1)));
 756
 757                                 if (ans == 1)
 758                                         break;
 759                                 stuffp->xa = !stuffp->xa;
 760                         }
 761                 }
 762                 /* xa disks will be read in raw mode, others not */
 763                 if (-1 == mcdx_setdrivemode(stuffp,
 764                                             stuffp->xa ? RAW : COOKED,
 765                                             1))
 766                         return -EIO;
 767                 if (stuffp->audio) {
 768                         xinfo("open() audio disk found\n");
 769                 } else if (stuffp->lastsector >= 0) {
 770                         xinfo("open() %s%s disk found\n",
 771                               stuffp->xa ? "XA / " : "",
 772                               stuffp->multi.
 773                               multi ? "Multi Session" : "Single Session");
 774                 }
 775         }
 776         stuffp->xxx = 0;
 777         stuffp->users++;
 778         return 0;
 779 }
 780
 781 static void mcdx_close(struct cdrom_device_info *cdi)
 782 {
 783         struct s_drive_stuff *stuffp;
 784
 785         xtrace(OPENCLOSE, "close()\n");
 786
 787         stuffp = cdi->handle;
 788
 789         --stuffp->users;
 790 }
 791
 792 static int mcdx_media_changed(struct cdrom_device_info *cdi, int disc_nr)
 793 /*      Return: 1 if media changed since last call to this function
 794                         0 otherwise */
 795 {
 796         struct s_drive_stuff *stuffp;
 797
 798         xinfo("mcdx_media_changed called for device %s\n", cdi->name);
 799
 800         stuffp = cdi->handle;
 801         mcdx_getstatus(stuffp, 1);
 802
 803         if (stuffp->yyy == 0)
 804                 return 0;
 805
 806         stuffp->yyy = 0;
 807         return 1;
 808 }
 809
 810 #ifndef MODULE
 811 static int __init mcdx_setup(char *str)
 812 {
 813         int pi[4];
 814         (void) get_options(str, ARRAY_SIZE(pi), pi);
 815
 816         if (pi[0] > 0)
 817                 mcdx_drive_map[0][0] = pi[1];
 818         if (pi[0] > 1)
 819                 mcdx_drive_map[0][1] = pi[2];
 820         return 1;
 821 }
 822
 823 __setup("mcdx=", mcdx_setup);
 824
 825 #endif
 826
 827 /* DIRTY PART ******************************************************/
 828
 829 static void mcdx_delay(struct s_drive_stuff *stuff, long jifs)
 830 /* This routine is used for sleeping.
 831  * A jifs value <0 means NO sleeping,
 832  *              =0 means minimal sleeping (let the kernel
 833  *                 run for other processes)
 834  *              >0 means at least sleep for that amount.
 835  *      May be we could use a simple count loop w/ jumps to itself, but
 836  *      I wanna make this independent of cpu speed. [1 jiffy is 1/HZ] sec */
 837 {
 838         if (jifs < 0)
 839                 return;
 840
 841         xtrace(SLEEP, "*** delay: sleepq\n");
 842         interruptible_sleep_on_timeout(&stuff->sleepq, jifs);
 843         xtrace(SLEEP, "delay awoken\n");
 844         if (signal_pending(current)) {
 845                 xtrace(SLEEP, "got signal\n");
 846         }
 847 }
 848
 849 static irqreturn_t mcdx_intr(int irq, void *dev_id, struct pt_regs *regs)
 850 {
 851         struct s_drive_stuff *stuffp = dev_id;
 852         unsigned char b;
 853
 854         if (stuffp == NULL) {
 855                 xwarn("mcdx: no device for intr %d\n", irq);
 856                 return IRQ_NONE;
 857         }
 858 #ifdef AK2
 859         if (!stuffp->busy && stuffp->pending)
 860                 stuffp->int_err = 1;
 861
 862 #endif                          /* AK2 */
 863         /* get the interrupt status */
 864         b = inb(stuffp->rreg_status);
 865         stuffp->introk = ~b & MCDX_RBIT_DTEN;
 866
 867         /* NOTE: We only should get interrupts if the data we
 868          * requested are ready to transfer.
 869          * But the drive seems to generate ``asynchronous'' interrupts
 870          * on several error conditions too.  (Despite the err int enable
 871          * setting during initialisation) */
 872
 873         /* if not ok, read the next byte as the drives status */
 874         if (!stuffp->introk) {
 875                 xtrace(IRQ, "intr() irq %d hw status 0x%02x\n", irq, b);
 876                 if (~b & MCDX_RBIT_STEN) {
 877                         xinfo("intr() irq %d    status 0x%02x\n",
 878                               irq, inb(stuffp->rreg_data));
 879                 } else {
 880                         xinfo("intr() irq %d ambiguous hw status\n", irq);
 881                 }
 882         } else {
 883                 xtrace(IRQ, "irq() irq %d ok, status %02x\n", irq, b);
 884         }
 885
 886         stuffp->busy = 0;
 887         wake_up_interruptible(&stuffp->busyq);
 888         return IRQ_HANDLED;
 889 }
 890
 891
 892 static int mcdx_talk(struct s_drive_stuff *stuffp,
 893           const unsigned char *cmd, size_t cmdlen,
 894           void *buffer, size_t size, unsigned int timeout, int tries)
 895 /* Send a command to the drive, wait for the result.
 896  * returns -1 on timeout, drive status otherwise
 897  * If buffer is not zero, the result (length size) is stored there.
 898  * If buffer is zero the size should be the number of bytes to read
 899  * from the drive.  These bytes are discarded.
 900  */
 901 {
 902         int st;
 903         char c;
 904         int discard;
 905
 906         /* Somebody wants the data read? */
 907         if ((discard = (buffer == NULL)))
 908                 buffer = &c;
 909
 910         while (stuffp->lock) {
 911                 xtrace(SLEEP, "*** talk: lockq\n");
 912                 interruptible_sleep_on(&stuffp->lockq);
 913                 xtrace(SLEEP, "talk: awoken\n");
 914         }
 915
 916         stuffp->lock = 1;
 917
 918         /* An operation other then reading data destroys the
 919            * data already requested and remembered in stuffp->request, ... */
 920         stuffp->valid = 0;
 921
 922 #if MCDX_DEBUG & TALK
 923         {
 924                 unsigned char i;
 925                 xtrace(TALK,
 926                        "talk() %d / %d tries, res.size %d, command 0x%02x",
 927                        tries, timeout, size, (unsigned char) cmd[0]);
 928                 for (i = 1; i < cmdlen; i++)
 929                         xtrace(TALK, " 0x%02x", cmd[i]);
 930                 xtrace(TALK, "\n");
 931         }
 932 #endif
 933
 934         /*  give up if all tries are done (bad) or if the status
 935          *  st != -1 (good) */
 936         for (st = -1; st == -1 && tries; tries--) {
 937
 938                 char *bp = (char *) buffer;
 939                 size_t sz = size;
 940
 941                 outsb(stuffp->wreg_data, cmd, cmdlen);
 942                 xtrace(TALK, "talk() command sent\n");
 943
 944                 /* get the status byte */
 945                 if (-1 == mcdx_getval(stuffp, timeout, 0, bp)) {
 946                         xinfo("talk() %02x timed out (status), %d tr%s left\n",
 947                              cmd[0], tries - 1, tries == 2 ? "y" : "ies");
 948                         continue;
 949                 }
 950                 st = *bp;
 951                 sz--;
 952                 if (!discard)
 953                         bp++;
 954
 955                 xtrace(TALK, "talk() got status 0x%02x\n", st);
 956
 957                 /* command error? */
 958                 if (e_cmderr(st)) {
 959                         xwarn("command error cmd = %02x %s \n",
 960                               cmd[0], cmdlen > 1 ? "..." : "");
 961                         st = -1;
 962                         continue;
 963                 }
 964
 965                 /* audio status? */
 966                 if (stuffp->audiostatus == CDROM_AUDIO_INVALID)
 967                         stuffp->audiostatus =
 968                             e_audiobusy(st) ? CDROM_AUDIO_PLAY :
 969                             CDROM_AUDIO_NO_STATUS;
 970                 else if (stuffp->audiostatus == CDROM_AUDIO_PLAY
 971                          && e_audiobusy(st) == 0)
 972                         stuffp->audiostatus = CDROM_AUDIO_COMPLETED;
 973
 974                 /* media change? */
 975                 if (e_changed(st)) {
 976                         xinfo("talk() media changed\n");
 977                         stuffp->xxx = stuffp->yyy = 1;
 978                 }
 979
 980                 /* now actually get the data */
 981                 while (sz--) {
 982                         if (-1 == mcdx_getval(stuffp, timeout, 0, bp)) {
 983                                 xinfo("talk() %02x timed out (data), %d tr%s left\n",
 984                                      cmd[0], tries - 1,
 985                                      tries == 2 ? "y" : "ies");
 986                                 st = -1;
 987                                 break;
 988                         }
 989                         if (!discard)
 990                                 bp++;
 991                         xtrace(TALK, "talk() got 0x%02x\n", *(bp - 1));
 992                 }
 993         }
 994
 995 #if !MCDX_QUIET
 996         if (!tries && st == -1)
 997                 xinfo("talk() giving up\n");
 998 #endif
 999
1000         stuffp->lock = 0;
1001         wake_up_interruptible(&stuffp->lockq);
1002
1003         xtrace(TALK, "talk() done with 0x%02x\n", st);
1004         return st;
1005 }
1006
1007 /* MODULE STUFF ***********************************************************/
1008
1009 int __mcdx_init(void)
1010 {
1011         int i;
1012         int drives = 0;
1013
1014         mcdx_init();
1015         for (i = 0; i < MCDX_NDRIVES; i++) {
1016                 if (mcdx_stuffp[i]) {
1017                         xtrace(INIT, "init_module() drive %d stuff @ %p\n",
1018                                i, mcdx_stuffp[i]);
1019                         drives++;
1020                 }
1021         }
1022
1023         if (!drives)
1024                 return -EIO;
1025
1026         return 0;
1027 }
1028
1029 static void __exit mcdx_exit(void)
1030 {
1031         int i;
1032
1033         xinfo("cleanup_module called\n");
1034
1035         for (i = 0; i < MCDX_NDRIVES; i++) {
1036                 struct s_drive_stuff *stuffp = mcdx_stuffp[i];
1037                 if (!stuffp)
1038                         continue;
1039                 del_gendisk(stuffp->disk);
1040                 if (unregister_cdrom(&stuffp->info)) {
1041                         printk(KERN_WARNING "Can't unregister cdrom mcdx\n");
1042                         continue;
1043                 }
1044                 put_disk(stuffp->disk);
1045                 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1046                 free_irq(stuffp->irq, NULL);
1047                 if (stuffp->toc) {
1048                         xtrace(MALLOC, "cleanup_module() free toc @ %p\n",
1049                                stuffp->toc);
1050                         kfree(stuffp->toc);
1051                 }
1052                 xtrace(MALLOC, "cleanup_module() free stuffp @ %p\n",
1053                        stuffp);
1054                 mcdx_stuffp[i] = NULL;
1055                 kfree(stuffp);
1056         }
1057
1058         if (unregister_blkdev(MAJOR_NR, "mcdx") != 0) {
1059                 xwarn("cleanup() unregister_blkdev() failed\n");
1060         }
1061         blk_cleanup_queue(mcdx_queue);
1062 #if !MCDX_QUIET
1063         else
1064         xinfo("cleanup() succeeded\n");
1065 #endif
1066 }
1067
1068 #ifdef MODULE
1069 module_init(__mcdx_init);
1070 #endif
1071 module_exit(mcdx_exit);
1072
1073
1074 /* Support functions ************************************************/
1075
1076 static int __init mcdx_init_drive(int drive)
1077 {
1078         struct s_version version;
1079         struct gendisk *disk;
1080         struct s_drive_stuff *stuffp;
1081         int size = sizeof(*stuffp);
1082         char msg[80];
1083
1084         xtrace(INIT, "init() try drive %d\n", drive);
1085
1086         xtrace(INIT, "kmalloc space for stuffpt's\n");
1087         xtrace(MALLOC, "init() malloc %d bytes\n", size);
1088         if (!(stuffp = kmalloc(size, GFP_KERNEL))) {
1089                 xwarn("init() malloc failed\n");
1090                 return 1;
1091         }
1092
1093         disk = alloc_disk(1);
1094         if (!disk) {
1095                 xwarn("init() malloc failed\n");
1096                 kfree(stuffp);
1097                 return 1;
1098         }
1099
1100         xtrace(INIT, "init() got %d bytes for drive stuff @ %p\n",
1101                sizeof(*stuffp), stuffp);
1102
1103         /* set default values */
1104         memset(stuffp, 0, sizeof(*stuffp));
1105
1106         stuffp->present = 0;    /* this should be 0 already */
1107         stuffp->toc = NULL;     /* this should be NULL already */
1108
1109         /* setup our irq and i/o addresses */
1110         stuffp->irq = irq(mcdx_drive_map[drive]);
1111         stuffp->wreg_data = stuffp->rreg_data = port(mcdx_drive_map[drive]);
1112         stuffp->wreg_reset = stuffp->rreg_status = stuffp->wreg_data + 1;
1113         stuffp->wreg_hcon = stuffp->wreg_reset + 1;
1114         stuffp->wreg_chn = stuffp->wreg_hcon + 1;
1115
1116         init_waitqueue_head(&stuffp->busyq);
1117         init_waitqueue_head(&stuffp->lockq);
1118         init_waitqueue_head(&stuffp->sleepq);
1119
1120         /* check if i/o addresses are available */
1121         if (!request_region(stuffp->wreg_data, MCDX_IO_SIZE, "mcdx")) {
1122                 xwarn("0x%03x,%d: Init failed. "
1123                       "I/O ports (0x%03x..0x%03x) already in use.\n",
1124                       stuffp->wreg_data, stuffp->irq,
1125                       stuffp->wreg_data,
1126                       stuffp->wreg_data + MCDX_IO_SIZE - 1);
1127                 xtrace(MALLOC, "init() free stuffp @ %p\n", stuffp);
1128                 kfree(stuffp);
1129                 put_disk(disk);
1130                 xtrace(INIT, "init() continue at next drive\n");
1131                 return 0;       /* next drive */
1132         }
1133
1134         xtrace(INIT, "init() i/o port is available at 0x%03x\n"
1135                stuffp->wreg_data);
1136         xtrace(INIT, "init() hardware reset\n");
1137         mcdx_reset(stuffp, HARD, 1);
1138
1139         xtrace(INIT, "init() get version\n");
1140         if (-1 == mcdx_requestversion(stuffp, &version, 4)) {
1141                 /* failed, next drive */
1142                 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1143                 xwarn("%s=0x%03x,%d: Init failed. Can't get version.\n",
1144                       MCDX, stuffp->wreg_data, stuffp->irq);
1145                 xtrace(MALLOC, "init() free stuffp @ %p\n", stuffp);
1146                 kfree(stuffp);
1147                 put_disk(disk);
1148                 xtrace(INIT, "init() continue at next drive\n");
1149                 return 0;
1150         }
1151
1152         switch (version.code) {
1153         case 'D':
1154                 stuffp->readcmd = READ2X;
1155                 stuffp->present = DOUBLE | DOOR | MULTI;
1156                 break;
1157         case 'F':
1158                 stuffp->readcmd = READ1X;
1159                 stuffp->present = SINGLE | DOOR | MULTI;
1160                 break;
1161         case 'M':
1162                 stuffp->readcmd = READ1X;
1163                 stuffp->present = SINGLE;
1164                 break;
1165         default:
1166                 stuffp->present = 0;
1167                 break;
1168         }
1169
1170         stuffp->playcmd = READ1X;
1171
1172         if (!stuffp->present) {
1173                 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1174                 xwarn("%s=0x%03x,%d: Init failed. No Mitsumi CD-ROM?.\n",
1175                       MCDX, stuffp->wreg_data, stuffp->irq);
1176                 kfree(stuffp);
1177                 put_disk(disk);
1178                 return 0;       /* next drive */
1179         }
1180
1181         xtrace(INIT, "init() register blkdev\n");
1182         if (register_blkdev(MAJOR_NR, "mcdx")) {
1183                 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1184                 kfree(stuffp);
1185                 put_disk(disk);
1186                 return 1;
1187         }
1188
1189         mcdx_queue = blk_init_queue(do_mcdx_request, &mcdx_lock);
1190         if (!mcdx_queue) {
1191                 unregister_blkdev(MAJOR_NR, "mcdx");
1192                 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1193                 kfree(stuffp);
1194                 put_disk(disk);
1195                 return 1;
1196         }
1197
1198         xtrace(INIT, "init() subscribe irq and i/o\n");
1199         if (request_irq(stuffp->irq, mcdx_intr, SA_INTERRUPT, "mcdx", stuffp)) {
1200                 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1201                 xwarn("%s=0x%03x,%d: Init failed. Can't get irq (%d).\n",
1202                       MCDX, stuffp->wreg_data, stuffp->irq, stuffp->irq);
1203                 stuffp->irq = 0;
1204                 blk_cleanup_queue(mcdx_queue);
1205                 kfree(stuffp);
1206                 put_disk(disk);
1207                 return 0;
1208         }
1209
1210         xtrace(INIT, "init() get garbage\n");
1211         {
1212                 int i;
1213                 mcdx_delay(stuffp, HZ / 2);
1214                 for (i = 100; i; i--)
1215                         (void) inb(stuffp->rreg_status);
1216         }
1217
1218
1219 #if WE_KNOW_WHY
1220         /* irq 11 -> channel register */
1221         outb(0x50, stuffp->wreg_chn);
1222 #endif
1223
1224         xtrace(INIT, "init() set non dma but irq mode\n");
1225         mcdx_config(stuffp, 1);
1226
1227         stuffp->info.ops = &mcdx_dops;
1228         stuffp->info.speed = 2;
1229         stuffp->info.capacity = 1;
1230         stuffp->info.handle = stuffp;
1231         sprintf(stuffp->info.name, "mcdx%d", drive);
1232         disk->major = MAJOR_NR;
1233         disk->first_minor = drive;
1234         strcpy(disk->disk_name, stuffp->info.name);
1235         disk->fops = &mcdx_bdops;
1236         disk->flags = GENHD_FL_CD;
1237         stuffp->disk = disk;
1238
1239         sprintf(msg, " mcdx: Mitsumi CD-ROM installed at 0x%03x, irq %d."
1240                 " (Firmware version %c %x)\n",
1241                 stuffp->wreg_data, stuffp->irq, version.code, version.ver);
1242         mcdx_stuffp[drive] = stuffp;
1243         xtrace(INIT, "init() mcdx_stuffp[%d] = %p\n", drive, stuffp);
1244         if (register_cdrom(&stuffp->info) != 0) {
1245                 printk("Cannot register Mitsumi CD-ROM!\n");
1246                 free_irq(stuffp->irq, NULL);
1247                 release_region(stuffp->wreg_data, MCDX_IO_SIZE);
1248                 kfree(stuffp);
1249                 put_disk(disk);
1250                 if (unregister_blkdev(MAJOR_NR, "mcdx") != 0)
1251                         xwarn("cleanup() unregister_blkdev() failed\n");
1252                 blk_cleanup_queue(mcdx_queue);
1253                 return 2;
1254         }
1255         disk->private_data = stuffp;
1256         disk->queue = mcdx_queue;
1257         add_disk(disk);
1258         printk(msg);
1259         return 0;
1260 }
1261
1262 static int __init mcdx_init(void)
1263 {
1264         int drive;
1265         xwarn("Version 2.14(hs) \n");
1266
1267         xwarn("$Id: mcdx.c,v 1.21 1997/01/26 07:12:59 davem Exp $\n");
1268
1269         /* zero the pointer array */
1270         for (drive = 0; drive < MCDX_NDRIVES; drive++)
1271                 mcdx_stuffp[drive] = NULL;
1272
1273         /* do the initialisation */
1274         for (drive = 0; drive < MCDX_NDRIVES; drive++) {
1275                 switch (mcdx_init_drive(drive)) {
1276                 case 2:
1277                         return -EIO;
1278                 case 1:
1279                         break;
1280                 }
1281         }
1282         return 0;
1283 }
1284
1285 static int mcdx_transfer(struct s_drive_stuff *stuffp,
1286               char *p, int sector, int nr_sectors)
1287 /*      This seems to do the actually transfer.  But it does more.  It
1288         keeps track of errors occurred and will (if possible) fall back
1289         to single speed on error.
1290         Return: -1 on timeout or other error
1291                         else status byte (as in stuff->st) */
1292 {
1293         int ans;
1294
1295         ans = mcdx_xfer(stuffp, p, sector, nr_sectors);
1296         return ans;
1297 #if FALLBACK
1298         if (-1 == ans)
1299                 stuffp->readerrs++;
1300         else
1301                 return ans;
1302
1303         if (stuffp->readerrs && stuffp->readcmd == READ1X) {
1304                 xwarn("XXX Already reading 1x -- no chance\n");
1305                 return -1;
1306         }
1307
1308         xwarn("XXX Fallback to 1x\n");
1309
1310         stuffp->readcmd = READ1X;
1311         return mcdx_transfer(stuffp, p, sector, nr_sectors);
1312 #endif
1313
1314 }
1315
1316
1317 static int mcdx_xfer(struct s_drive_stuff *stuffp,
1318                      char *p, int sector, int nr_sectors)
1319 /*      This does actually the transfer from the drive.
1320         Return: -1 on timeout or other error
1321                         else status byte (as in stuff->st) */
1322 {
1323         int border;
1324         int done = 0;
1325         long timeout;
1326
1327         if (stuffp->audio) {
1328                 xwarn("Attempt to read from audio CD.\n");
1329                 return -1;
1330         }
1331
1332         if (!stuffp->readcmd) {
1333                 xinfo("Can't transfer from missing disk.\n");
1334                 return -1;
1335         }
1336
1337         while (stuffp->lock) {
1338                 interruptible_sleep_on(&stuffp->lockq);
1339         }
1340
1341         if (stuffp->valid && (sector >= stuffp->pending)
1342             && (sector < stuffp->low_border)) {
1343
1344                 /* All (or at least a part of the sectors requested) seems
1345                    * to be already requested, so we don't need to bother the
1346                    * drive with new requests ...
1347                    * Wait for the drive become idle, but first
1348                    * check for possible occurred errors --- the drive
1349                    * seems to report them asynchronously */
1350
1351
1352                 border = stuffp->high_border < (border =
1353                                                 sector + nr_sectors)
1354                     ? stuffp->high_border : border;
1355
1356                 stuffp->lock = current->pid;
1357
1358                 do {
1359
1360                         while (stuffp->busy) {
1361
1362                                 timeout =
1363                                     interruptible_sleep_on_timeout
1364                                     (&stuffp->busyq, 5 * HZ);
1365
1366                                 if (!stuffp->introk) {
1367                                         xtrace(XFER,
1368                                                "error via interrupt\n");
1369                                 } else if (!timeout) {
1370                                         xtrace(XFER, "timeout\n");
1371                                 } else if (signal_pending(current)) {
1372                                         xtrace(XFER, "signal\n");
1373                                 } else
1374                                         continue;
1375
1376                                 stuffp->lock = 0;
1377                                 stuffp->busy = 0;
1378                                 stuffp->valid = 0;
1379
1380                                 wake_up_interruptible(&stuffp->lockq);
1381                                 xtrace(XFER, "transfer() done (-1)\n");
1382                                 return -1;
1383                         }
1384
1385                         /* check if we need to set the busy flag (as we
1386                          * expect an interrupt */
1387                         stuffp->busy = (3 == (stuffp->pending & 3));
1388
1389                         /* Test if it's the first sector of a block,
1390                          * there we have to skip some bytes as we read raw data */
1391                         if (stuffp->xa && (0 == (stuffp->pending & 3))) {
1392                                 const int HEAD =
1393                                     CD_FRAMESIZE_RAW - CD_XA_TAIL -
1394                                     CD_FRAMESIZE;
1395                                 insb(stuffp->rreg_data, p, HEAD);
1396                         }
1397
1398                         /* now actually read the data */
1399                         insb(stuffp->rreg_data, p, 512);
1400
1401                         /* test if it's the last sector of a block,
1402                          * if so, we have to handle XA special */
1403                         if ((3 == (stuffp->pending & 3)) && stuffp->xa) {
1404                                 char dummy[CD_XA_TAIL];
1405                                 insb(stuffp->rreg_data, &dummy[0], CD_XA_TAIL);
1406                         }
1407
1408                         if (stuffp->pending == sector) {
1409                                 p += 512;
1410                                 done++;
1411                                 sector++;
1412                         }
1413                 } while (++(stuffp->pending) < border);
1414
1415                 stuffp->lock = 0;
1416                 wake_up_interruptible(&stuffp->lockq);
1417
1418         } else {
1419
1420                 /* The requested sector(s) is/are out of the
1421                  * already requested range, so we have to bother the drive
1422                  * with a new request. */
1423
1424                 static unsigned char cmd[] = {
1425                         0,
1426                         0, 0, 0,
1427                         0, 0, 0
1428                 };
1429
1430                 cmd[0] = stuffp->readcmd;
1431
1432                 /* The numbers held in ->pending, ..., should be valid */
1433                 stuffp->valid = 1;
1434                 stuffp->pending = sector & ~3;
1435
1436                 /* do some sanity checks */
1437                 if (stuffp->pending > stuffp->lastsector) {
1438                         xwarn
1439                             ("transfer() sector %d from nirvana requested.\n",
1440                              stuffp->pending);
1441                         stuffp->status = MCDX_ST_EOM;
1442                         stuffp->valid = 0;
1443                         xtrace(XFER, "transfer() done (-1)\n");
1444                         return -1;
1445                 }
1446
1447                 if ((stuffp->low_border = stuffp->pending + DIRECT_SIZE)
1448                     > stuffp->lastsector + 1) {
1449                         xtrace(XFER, "cut low_border\n");
1450                         stuffp->low_border = stuffp->lastsector + 1;
1451                 }
1452                 if ((stuffp->high_border = stuffp->pending + REQUEST_SIZE)
1453                     > stuffp->lastsector + 1) {
1454                         xtrace(XFER, "cut high_border\n");
1455                         stuffp->high_border = stuffp->lastsector + 1;
1456                 }
1457
1458                 {               /* Convert the sector to be requested to MSF format */
1459                         struct cdrom_msf0 pending;
1460                         log2msf(stuffp->pending / 4, &pending);
1461                         cmd[1] = pending.minute;
1462                         cmd[2] = pending.second;
1463                         cmd[3] = pending.frame;
1464                 }
1465
1466                 cmd[6] =
1467                     (unsigned
1468                      char) ((stuffp->high_border - stuffp->pending) / 4);
1469                 xtrace(XFER, "[%2d]\n", cmd[6]);
1470
1471                 stuffp->busy = 1;
1472                 /* Now really issue the request command */
1473                 outsb(stuffp->wreg_data, cmd, sizeof cmd);
1474
1475         }
1476 #ifdef AK2
1477         if (stuffp->int_err) {
1478                 stuffp->valid = 0;
1479                 stuffp->int_err = 0;
1480                 return -1;
1481         }
1482 #endif                          /* AK2 */
1483
1484         stuffp->low_border = (stuffp->low_border +=
1485                               done) <
1486             stuffp->high_border ? stuffp->low_border : stuffp->high_border;
1487
1488         return done;
1489 }
1490
1491
1492 /*      Access to elements of the mcdx_drive_map members */
1493
1494 static unsigned port(int *ip)
1495 {
1496         return ip[0];
1497 }
1498 static int irq(int *ip)
1499 {
1500         return ip[1];
1501 }
1502
1503 /*      Misc number converters */
1504
1505 static unsigned int bcd2uint(unsigned char c)
1506 {
1507         return (c >> 4) * 10 + (c & 0x0f);
1508 }
1509
1510 static unsigned int uint2bcd(unsigned int ival)
1511 {
1512         return ((ival / 10) << 4) | (ival % 10);
1513 }
1514
1515 static void log2msf(unsigned int l, struct cdrom_msf0 *pmsf)
1516 {
1517         l += CD_MSF_OFFSET;
1518         pmsf->minute = uint2bcd(l / 4500), l %= 4500;
1519         pmsf->second = uint2bcd(l / 75);
1520         pmsf->frame = uint2bcd(l % 75);
1521 }
1522
1523 static unsigned int msf2log(const struct cdrom_msf0 *pmsf)
1524 {
1525         return bcd2uint(pmsf->frame)
1526             + bcd2uint(pmsf->second) * 75
1527             + bcd2uint(pmsf->minute) * 4500 - CD_MSF_OFFSET;
1528 }
1529
1530 int mcdx_readtoc(struct s_drive_stuff *stuffp)
1531 /*  Read the toc entries from the CD,
1532  *  Return: -1 on failure, else 0 */
1533 {
1534
1535         if (stuffp->toc) {
1536                 xtrace(READTOC, "ioctl() toc already read\n");
1537                 return 0;
1538         }
1539
1540         xtrace(READTOC, "ioctl() readtoc for %d tracks\n",
1541                stuffp->di.n_last - stuffp->di.n_first + 1);
1542
1543         if (-1 == mcdx_hold(stuffp, 1))
1544                 return -1;
1545
1546         xtrace(READTOC, "ioctl() tocmode\n");
1547         if (-1 == mcdx_setdrivemode(stuffp, TOC, 1))
1548                 return -EIO;
1549
1550         /* all seems to be ok so far ... malloc */
1551         {
1552                 int size;
1553                 size =
1554                     sizeof(struct s_subqcode) * (stuffp->di.n_last -
1555                                                  stuffp->di.n_first + 2);
1556
1557                 xtrace(MALLOC, "ioctl() malloc %d bytes\n", size);
1558                 stuffp->toc = kmalloc(size, GFP_KERNEL);
1559                 if (!stuffp->toc) {
1560                         xwarn("Cannot malloc %d bytes for toc\n", size);
1561                         mcdx_setdrivemode(stuffp, DATA, 1);
1562                         return -EIO;
1563                 }
1564         }
1565
1566         /* now read actually the index */
1567         {
1568                 int trk;
1569                 int retries;
1570
1571                 for (trk = 0;
1572                      trk < (stuffp->di.n_last - stuffp->di.n_first + 1);
1573                      trk++)
1574                         stuffp->toc[trk].index = 0;
1575
1576                 for (retries = 300; retries; retries--) {       /* why 300? */
1577                         struct s_subqcode q;
1578                         unsigned int idx;
1579
1580                         if (-1 == mcdx_requestsubqcode(stuffp, &q, 1)) {
1581                                 mcdx_setdrivemode(stuffp, DATA, 1);
1582                                 return -EIO;
1583                         }
1584
1585                         idx = bcd2uint(q.index);
1586
1587                         if ((idx > 0)
1588                             && (idx <= stuffp->di.n_last)
1589                             && (q.tno == 0)
1590                             && (stuffp->toc[idx - stuffp->di.n_first].
1591                                 index == 0)) {
1592                                 stuffp->toc[idx - stuffp->di.n_first] = q;
1593                                 xtrace(READTOC,
1594                                        "ioctl() toc idx %d (trk %d)\n",
1595                                        idx, trk);
1596                                 trk--;
1597                         }
1598                         if (trk == 0)
1599                                 break;
1600                 }
1601                 memset(&stuffp->
1602                        toc[stuffp->di.n_last - stuffp->di.n_first + 1], 0,
1603                        sizeof(stuffp->toc[0]));
1604                 stuffp->toc[stuffp->di.n_last - stuffp->di.n_first +
1605                             1].dt = stuffp->di.msf_leadout;
1606         }
1607
1608         /* unset toc mode */
1609         xtrace(READTOC, "ioctl() undo toc mode\n");
1610         if (-1 == mcdx_setdrivemode(stuffp, DATA, 2))
1611                 return -EIO;
1612
1613 #if MCDX_DEBUG && READTOC
1614         {
1615                 int trk;
1616                 for (trk = 0;
1617                      trk < (stuffp->di.n_last - stuffp->di.n_first + 2);
1618                      trk++)
1619                         xtrace(READTOC, "ioctl() %d readtoc %02x %02x %02x"
1620                                "  %02x:%02x.%02x  %02x:%02x.%02x\n",
1621                                trk + stuffp->di.n_first,
1622                                stuffp->toc[trk].control,
1623                                stuffp->toc[trk].tno,
1624                                stuffp->toc[trk].index,
1625                                stuffp->toc[trk].tt.minute,
1626                                stuffp->toc[trk].tt.second,
1627                                stuffp->toc[trk].tt.frame,
1628                                stuffp->toc[trk].dt.minute,
1629                                stuffp->toc[trk].dt.second,
1630                                stuffp->toc[trk].dt.frame);
1631         }
1632 #endif
1633
1634         return 0;
1635 }
1636
1637 static int
1638 mcdx_playmsf(struct s_drive_stuff *stuffp, const struct cdrom_msf *msf)
1639 {
1640         unsigned char cmd[7] = {
1641                 0, 0, 0, 0, 0, 0, 0
1642         };
1643
1644         if (!stuffp->readcmd) {
1645                 xinfo("Can't play from missing disk.\n");
1646                 return -1;
1647         }
1648
1649         cmd[0] = stuffp->playcmd;
1650
1651         cmd[1] = msf->cdmsf_min0;
1652         cmd[2] = msf->cdmsf_sec0;
1653         cmd[3] = msf->cdmsf_frame0;
1654         cmd[4] = msf->cdmsf_min1;
1655         cmd[5] = msf->cdmsf_sec1;
1656         cmd[6] = msf->cdmsf_frame1;
1657
1658         xtrace(PLAYMSF, "ioctl(): play %x "
1659                "%02x:%02x:%02x -- %02x:%02x:%02x\n",
1660                cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6]);
1661
1662         outsb(stuffp->wreg_data, cmd, sizeof cmd);
1663
1664         if (-1 == mcdx_getval(stuffp, 3 * HZ, 0, NULL)) {
1665                 xwarn("playmsf() timeout\n");
1666                 return -1;
1667         }
1668
1669         stuffp->audiostatus = CDROM_AUDIO_PLAY;
1670         return 0;
1671 }
1672
1673 static int
1674 mcdx_playtrk(struct s_drive_stuff *stuffp, const struct cdrom_ti *ti)
1675 {
1676         struct s_subqcode *p;
1677         struct cdrom_msf msf;
1678
1679         if (-1 == mcdx_readtoc(stuffp))
1680                 return -1;
1681
1682         if (ti)
1683                 p = &stuffp->toc[ti->cdti_trk0 - stuffp->di.n_first];
1684         else
1685                 p = &stuffp->start;
1686
1687         msf.cdmsf_min0 = p->dt.minute;
1688         msf.cdmsf_sec0 = p->dt.second;
1689         msf.cdmsf_frame0 = p->dt.frame;
1690
1691         if (ti) {
1692                 p = &stuffp->toc[ti->cdti_trk1 - stuffp->di.n_first + 1];
1693                 stuffp->stop = *p;
1694         } else
1695                 p = &stuffp->stop;
1696
1697         msf.cdmsf_min1 = p->dt.minute;
1698         msf.cdmsf_sec1 = p->dt.second;
1699         msf.cdmsf_frame1 = p->dt.frame;
1700
1701         return mcdx_playmsf(stuffp, &msf);
1702 }
1703
1704
1705 /* Drive functions ************************************************/
1706
1707 static int mcdx_tray_move(struct cdrom_device_info *cdi, int position)
1708 {
1709         struct s_drive_stuff *stuffp = cdi->handle;
1710
1711         if (!stuffp->present)
1712                 return -ENXIO;
1713         if (!(stuffp->present & DOOR))
1714                 return -ENOSYS;
1715
1716         if (position)           /* 1: eject */
1717                 return mcdx_talk(stuffp, "\xf6", 1, NULL, 1, 5 * HZ, 3);
1718         else                    /* 0: close */
1719                 return mcdx_talk(stuffp, "\xf8", 1, NULL, 1, 5 * HZ, 3);
1720         return 1;
1721 }
1722
1723 static int mcdx_stop(struct s_drive_stuff *stuffp, int tries)
1724 {
1725         return mcdx_talk(stuffp, "\xf0", 1, NULL, 1, 2 * HZ, tries);
1726 }
1727
1728 static int mcdx_hold(struct s_drive_stuff *stuffp, int tries)
1729 {
1730         return mcdx_talk(stuffp, "\x70", 1, NULL, 1, 2 * HZ, tries);
1731 }
1732
1733 static int mcdx_requestsubqcode(struct s_drive_stuff *stuffp,
1734                      struct s_subqcode *sub, int tries)
1735 {
1736         char buf[11];
1737         int ans;
1738
1739         if (-1 == (ans = mcdx_talk(stuffp, "\x20", 1, buf, sizeof(buf),
1740                                    2 * HZ, tries)))
1741                 return -1;
1742         sub->control = buf[1];
1743         sub->tno = buf[2];
1744         sub->index = buf[3];
1745         sub->tt.minute = buf[4];
1746         sub->tt.second = buf[5];
1747         sub->tt.frame = buf[6];
1748         sub->dt.minute = buf[8];
1749         sub->dt.second = buf[9];
1750         sub->dt.frame = buf[10];
1751
1752         return ans;
1753 }
1754
1755 static int mcdx_requestmultidiskinfo(struct s_drive_stuff *stuffp,
1756                           struct s_multi *multi, int tries)
1757 {
1758         char buf[5];
1759         int ans;
1760
1761         if (stuffp->present & MULTI) {
1762                 ans =
1763                     mcdx_talk(stuffp, "\x11", 1, buf, sizeof(buf), 2 * HZ,
1764                               tries);
1765                 multi->multi = buf[1];
1766                 multi->msf_last.minute = buf[2];
1767                 multi->msf_last.second = buf[3];
1768                 multi->msf_last.frame = buf[4];
1769                 return ans;
1770         } else {
1771                 multi->multi = 0;
1772                 return 0;
1773         }
1774 }
1775
1776 static int mcdx_requesttocdata(struct s_drive_stuff *stuffp, struct s_diskinfo *info,
1777                     int tries)
1778 {
1779         char buf[9];
1780         int ans;
1781         ans =
1782             mcdx_talk(stuffp, "\x10", 1, buf, sizeof(buf), 2 * HZ, tries);
1783         if (ans == -1) {
1784                 info->n_first = 0;
1785                 info->n_last = 0;
1786         } else {
1787                 info->n_first = bcd2uint(buf[1]);
1788                 info->n_last = bcd2uint(buf[2]);
1789                 info->msf_leadout.minute = buf[3];
1790                 info->msf_leadout.second = buf[4];
1791                 info->msf_leadout.frame = buf[5];
1792                 info->msf_first.minute = buf[6];
1793                 info->msf_first.second = buf[7];
1794                 info->msf_first.frame = buf[8];
1795         }
1796         return ans;
1797 }
1798
1799 static int mcdx_setdrivemode(struct s_drive_stuff *stuffp, enum drivemodes mode,
1800                   int tries)
1801 {
1802         char cmd[2];
1803         int ans;
1804
1805         xtrace(HW, "setdrivemode() %d\n", mode);
1806
1807         if (-1 == (ans = mcdx_talk(stuffp, "\xc2", 1, cmd, sizeof(cmd), 5 * HZ, tries)))
1808                 return -1;
1809
1810         switch (mode) {
1811         case TOC:
1812                 cmd[1] |= 0x04;
1813                 break;
1814         case DATA:
1815                 cmd[1] &= ~0x04;
1816                 break;
1817         case RAW:
1818                 cmd[1] |= 0x40;
1819                 break;
1820         case COOKED:
1821                 cmd[1] &= ~0x40;
1822                 break;
1823         default:
1824                 break;
1825         }
1826         cmd[0] = 0x50;
1827         return mcdx_talk(stuffp, cmd, 2, NULL, 1, 5 * HZ, tries);
1828 }
1829
1830 static int mcdx_setdatamode(struct s_drive_stuff *stuffp, enum datamodes mode,
1831                  int tries)
1832 {
1833         unsigned char cmd[2] = { 0xa0 };
1834         xtrace(HW, "setdatamode() %d\n", mode);
1835         switch (mode) {
1836         case MODE0:
1837                 cmd[1] = 0x00;
1838                 break;
1839         case MODE1:
1840                 cmd[1] = 0x01;
1841                 break;
1842         case MODE2:
1843                 cmd[1] = 0x02;
1844                 break;
1845         default:
1846                 return -EINVAL;
1847         }
1848         return mcdx_talk(stuffp, cmd, 2, NULL, 1, 5 * HZ, tries);
1849 }
1850
1851 static int mcdx_config(struct s_drive_stuff *stuffp, int tries)
1852 {
1853         char cmd[4];
1854
1855         xtrace(HW, "config()\n");
1856
1857         cmd[0] = 0x90;
1858
1859         cmd[1] = 0x10;          /* irq enable */
1860         cmd[2] = 0x05;          /* pre, err irq enable */
1861
1862         if (-1 == mcdx_talk(stuffp, cmd, 3, NULL, 1, 1 * HZ, tries))
1863                 return -1;
1864
1865         cmd[1] = 0x02;          /* dma select */
1866         cmd[2] = 0x00;          /* no dma */
1867
1868         return mcdx_talk(stuffp, cmd, 3, NULL, 1, 1 * HZ, tries);
1869 }
1870
1871 static int mcdx_requestversion(struct s_drive_stuff *stuffp, struct s_version *ver,
1872                     int tries)
1873 {
1874         char buf[3];
1875         int ans;
1876
1877         if (-1 == (ans = mcdx_talk(stuffp, "\xdc",
1878                                    1, buf, sizeof(buf), 2 * HZ, tries)))
1879                 return ans;
1880
1881         ver->code = buf[1];
1882         ver->ver = buf[2];
1883
1884         return ans;
1885 }
1886
1887 static int mcdx_reset(struct s_drive_stuff *stuffp, enum resetmodes mode, int tries)
1888 {
1889         if (mode == HARD) {
1890                 outb(0, stuffp->wreg_chn);      /* no dma, no irq -> hardware */
1891                 outb(0, stuffp->wreg_reset);    /* hw reset */
1892                 return 0;
1893         } else
1894                 return mcdx_talk(stuffp, "\x60", 1, NULL, 1, 5 * HZ, tries);
1895 }
1896
1897 static int mcdx_lockdoor(struct cdrom_device_info *cdi, int lock)
1898 {
1899         struct s_drive_stuff *stuffp = cdi->handle;
1900         char cmd[2] = { 0xfe };
1901
1902         if (!(stuffp->present & DOOR))
1903                 return -ENOSYS;
1904         if (stuffp->present & DOOR) {
1905                 cmd[1] = lock ? 0x01 : 0x00;
1906                 return mcdx_talk(stuffp, cmd, sizeof(cmd), NULL, 1, 5 * HZ, 3);
1907         } else
1908                 return 0;
1909 }
1910
1911 static int mcdx_getstatus(struct s_drive_stuff *stuffp, int tries)
1912 {
1913         return mcdx_talk(stuffp, "\x40", 1, NULL, 1, 5 * HZ, tries);
1914 }
1915
1916 static int
1917 mcdx_getval(struct s_drive_stuff *stuffp, int to, int delay, char *buf)
1918 {
1919         unsigned long timeout = to + jiffies;
1920         char c;
1921
1922         if (!buf)
1923                 buf = &c;
1924
1925         while (inb(stuffp->rreg_status) & MCDX_RBIT_STEN) {
1926                 if (time_after(jiffies, timeout))
1927                         return -1;
1928                 mcdx_delay(stuffp, delay);
1929         }
1930
1931         *buf = (unsigned char) inb(stuffp->rreg_data) & 0xff;
1932
1933         return 0;
1934 }
1935
1936 static int mcdx_setattentuator(struct s_drive_stuff *stuffp,
1937                     struct cdrom_volctrl *vol, int tries)
1938 {
1939         char cmd[5];
1940         cmd[0] = 0xae;
1941         cmd[1] = vol->channel0;
1942         cmd[2] = 0;
1943         cmd[3] = vol->channel1;
1944         cmd[4] = 0;
1945
1946         return mcdx_talk(stuffp, cmd, sizeof(cmd), NULL, 5, 200, tries);
1947 }
1948
1949 MODULE_LICENSE("GPL");
1950 MODULE_ALIAS_BLOCKDEV_MAJOR(MITSUMI_X_CDROM_MAJOR);