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