sys/dev/mcd/mcd.c

   1 /*-
   2  * Copyright 1993 by Holger Veit (data part)
   3  * Copyright 1993 by Brian Moore (audio part)
   4  * Changes Copyright 1993 by Gary Clark II
   5  * Changes Copyright (C) 1994-1995 by Andrey A. Chernov, Moscow, Russia
   6  *
   7  * Rewrote probe routine to work on newer Mitsumi drives.
   8  * Additional changes (C) 1994 by Jordan K. Hubbard
   9  *
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. All advertising materials mentioning features or use of this software
  21  *    must display the following acknowledgement:
  22  *      This software was developed by Holger Veit and Brian Moore
  23  *      for use with "386BSD" and similar operating systems.
  24  *    "Similar operating systems" includes mainly non-profit oriented
  25  *    systems for research and education, including but not restricted to
  26  *    "NetBSD", "FreeBSD", "Mach" (by CMU).
  27  * 4. Neither the name of the developer(s) nor the name "386BSD"
  28  *    may be used to endorse or promote products derived from this
  29  *    software without specific prior written permission.
  30  *
  31  * THIS SOFTWARE IS PROVIDED BY THE DEVELOPER(S) ``AS IS'' AND ANY
  32  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  33  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  34  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE DEVELOPER(S) BE
  35  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
  36  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
  37  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  38  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  39  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  40  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  41  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  42  *
  43  */
  44
  45 #include <sys/cdefs.h>
  46 __FBSDID("$FreeBSD$");
  47 static const char COPYRIGHT[] = "mcd-driver (C)1993 by H.Veit & B.Moore";
  48
  49 #include <sys/param.h>
  50 #include <sys/systm.h>
  51 #include <sys/kernel.h>
  52 #include <sys/conf.h>
  53 #include <sys/fcntl.h>
  54 #include <sys/bio.h>
  55 #include <sys/cdio.h>
  56 #include <sys/disk.h>
  57 #include <sys/bus.h>
  58
  59 #include <machine/bus.h>
  60 #include <machine/resource.h>
  61 #include <sys/rman.h>
  62
  63 #include <isa/isavar.h>
  64
  65 #include <dev/mcd/mcdreg.h>
  66 #include <dev/mcd/mcdvar.h>
  67
  68 #define MCD_TRACE(format, args...)                                      \
  69 {                                                                       \
  70         if (sc->debug) {                                                \
  71                 device_printf(sc->dev, "status=0x%02x: ",               \
  72                         sc->data.status);                               \
  73                 printf(format, ## args);                                \
  74         }                                                               \
  75 }
  76
  77 #define RAW_PART        2
  78
  79 /* flags */
  80 #define MCDVALID        0x0001  /* parameters loaded */
  81 #define MCDINIT         0x0002  /* device is init'd */
  82 #define MCDNEWMODEL     0x0004  /* device is new model */
  83 #define MCDLABEL        0x0008  /* label is read */
  84 #define MCDPROBING      0x0010  /* probing */
  85 #define MCDREADRAW      0x0020  /* read raw mode (2352 bytes) */
  86 #define MCDVOLINFO      0x0040  /* already read volinfo */
  87 #define MCDTOC          0x0080  /* already read toc */
  88 #define MCDMBXBSY       0x0100  /* local mbx is busy */
  89
  90 /* status */
  91 #define MCDAUDIOBSY     MCD_ST_AUDIOBSY         /* playing audio */
  92 #define MCDDSKCHNG      MCD_ST_DSKCHNG          /* sensed change of disk */
  93 #define MCDDSKIN        MCD_ST_DSKIN            /* sensed disk in drive */
  94 #define MCDDOOROPEN     MCD_ST_DOOROPEN         /* sensed door open */
  95
  96 /* These are apparently the different states a mitsumi can get up to */
  97 #define MCDCDABSENT     0x0030
  98 #define MCDCDPRESENT    0x0020
  99 #define MCDSCLOSED      0x0080
 100 #define MCDSOPEN        0x00a0
 101
 102 #define MCD_MD_UNKNOWN  (-1)
 103
 104 #define MCD_TYPE_UNKNOWN        0
 105 #define MCD_TYPE_LU002S         1
 106 #define MCD_TYPE_LU005S         2
 107 #define MCD_TYPE_LU006S         3
 108 #define MCD_TYPE_FX001          4
 109 #define MCD_TYPE_FX001D         5
 110
 111 /* reader state machine */
 112 #define MCD_S_BEGIN     0
 113 #define MCD_S_BEGIN1    1
 114 #define MCD_S_WAITSTAT  2
 115 #define MCD_S_WAITMODE  3
 116 #define MCD_S_WAITREAD  4
 117
 118 /* prototypes */
 119 static void     mcd_start(struct mcd_softc *);
 120 #ifdef NOTYET
 121 static void     mcd_configure(struct mcd_softc *sc);
 122 #endif
 123 static int      mcd_get(struct mcd_softc *, char *buf, int nmax);
 124 static int      mcd_setflags(struct mcd_softc *);
 125 static int      mcd_getstat(struct mcd_softc *,int sflg);
 126 static int      mcd_send(struct mcd_softc *, int cmd,int nretrys);
 127 static void     hsg2msf(int hsg, bcd_t *msf);
 128 static int      msf2hsg(bcd_t *msf, int relative);
 129 static int      mcd_volinfo(struct mcd_softc *);
 130 static int      mcd_waitrdy(struct mcd_softc *,int dly);
 131 static timeout_t mcd_timeout;
 132 static void     mcd_doread(struct mcd_softc *, int state, struct mcd_mbx *mbxin);
 133 static void     mcd_soft_reset(struct mcd_softc *);
 134 static int      mcd_hard_reset(struct mcd_softc *);
 135 static int      mcd_setmode(struct mcd_softc *, int mode);
 136 static int      mcd_getqchan(struct mcd_softc *, struct mcd_qchninfo *q);
 137 static int      mcd_subchan(struct mcd_softc *, struct ioc_read_subchannel *sc,
 138                     int nocopyout);
 139 static int      mcd_toc_header(struct mcd_softc *, struct ioc_toc_header *th);
 140 static int      mcd_read_toc(struct mcd_softc *);
 141 static int      mcd_toc_entrys(struct mcd_softc *, struct ioc_read_toc_entry *te);
 142 #if 0
 143 static int      mcd_toc_entry(struct mcd_softc *, struct ioc_read_toc_single_entry *te);
 144 #endif
 145 static int      mcd_stop(struct mcd_softc *);
 146 static int      mcd_eject(struct mcd_softc *);
 147 static int      mcd_inject(struct mcd_softc *);
 148 static int      mcd_playtracks(struct mcd_softc *, struct ioc_play_track *pt);
 149 static int      mcd_play(struct mcd_softc *, struct mcd_read2 *pb);
 150 static int      mcd_playmsf(struct mcd_softc *, struct ioc_play_msf *pt);
 151 static int      mcd_playblocks(struct mcd_softc *, struct ioc_play_blocks *);
 152 static int      mcd_pause(struct mcd_softc *);
 153 static int      mcd_resume(struct mcd_softc *);
 154 static int      mcd_lock_door(struct mcd_softc *, int lock);
 155 static int      mcd_close_tray(struct mcd_softc *);
 156 static int      mcd_size(struct cdev *dev);
 157
 158 static d_open_t         mcdopen;
 159 static d_close_t        mcdclose;
 160 static d_ioctl_t        mcdioctl;
 161 static d_strategy_t     mcdstrategy;
 162
 163 static struct cdevsw mcd_cdevsw = {
 164         .d_version =    D_VERSION,
 165         .d_open =       mcdopen,
 166         .d_close =      mcdclose,
 167         .d_read =       physread,
 168         .d_ioctl =      mcdioctl,
 169         .d_strategy =   mcdstrategy,
 170         .d_name =       "mcd",
 171         .d_flags =      D_DISK | D_NEEDGIANT,
 172 };
 173
 174 #define MCD_RETRYS      5
 175 #define MCD_RDRETRYS    8
 176
 177 #define CLOSE_TRAY_SECS 8
 178 #define DISK_SENSE_SECS 3
 179 #define WAIT_FRAC 4
 180
 181 /* several delays */
 182 #define RDELAY_WAITSTAT 300
 183 #define RDELAY_WAITMODE 300
 184 #define RDELAY_WAITREAD 800
 185
 186 #define MIN_DELAY       15
 187 #define DELAY_GETREPLY  5000000
 188
 189 int
 190 mcd_attach(struct mcd_softc *sc)
 191 {
 192         int unit;
 193
 194         unit = device_get_unit(sc->dev);
 195
 196         sc->data.flags |= MCDINIT;
 197         mcd_soft_reset(sc);
 198         bioq_init(&sc->data.head);
 199
 200 #ifdef NOTYET
 201         /* wire controller for interrupts and dma */
 202         mcd_configure(sc);
 203 #endif
 204         /* name filled in probe */
 205         sc->mcd_dev_t = make_dev(&mcd_cdevsw, 8 * unit,
 206                                  UID_ROOT, GID_OPERATOR, 0640, "mcd%d", unit);
 207
 208         sc->mcd_dev_t->si_drv1 = (void *)sc;
 209
 210         return (0);
 211 }
 212
 213 static int
 214 mcdopen(struct cdev *dev, int flags, int fmt, struct thread *td)
 215 {
 216         struct mcd_softc *sc;
 217         int r,retry;
 218
 219         sc = (struct mcd_softc *)dev->si_drv1;
 220
 221         /* not initialized*/
 222         if (!(sc->data.flags & MCDINIT))
 223                 return (ENXIO);
 224
 225         /* invalidated in the meantime? mark all open part's invalid */
 226         if (!(sc->data.flags & MCDVALID) && sc->data.openflags)
 227                 return (ENXIO);
 228
 229         if (mcd_getstat(sc, 1) == -1)
 230                 return (EIO);
 231
 232         if (    (sc->data.status & (MCDDSKCHNG|MCDDOOROPEN))
 233             || !(sc->data.status & MCDDSKIN))
 234                 for (retry = 0; retry < DISK_SENSE_SECS * WAIT_FRAC; retry++) {
 235                         (void) tsleep((caddr_t)sc, PSOCK | PCATCH, "mcdsn1", hz/WAIT_FRAC);
 236                         if ((r = mcd_getstat(sc, 1)) == -1)
 237                                 return (EIO);
 238                         if (r != -2)
 239                                 break;
 240                 }
 241
 242         if (sc->data.status & MCDDOOROPEN) {
 243                 device_printf(sc->dev, "door is open\n");
 244                 return (ENXIO);
 245         }
 246         if (!(sc->data.status & MCDDSKIN)) {
 247                 device_printf(sc->dev, "no CD inside\n");
 248                 return (ENXIO);
 249         }
 250         if (sc->data.status & MCDDSKCHNG) {
 251                 device_printf(sc->dev, "CD not sensed\n");
 252                 return (ENXIO);
 253         }
 254
 255         if (mcd_size(dev) < 0) {
 256                 device_printf(sc->dev, "failed to get disk size\n");
 257                 return (ENXIO);
 258         }
 259
 260         sc->data.openflags = 1;
 261         sc->data.partflags |= MCDREADRAW;
 262         sc->data.flags |= MCDVALID;
 263
 264         (void) mcd_lock_door(sc, MCD_LK_LOCK);
 265         if (!(sc->data.flags & MCDVALID))
 266                 return (ENXIO);
 267
 268         return mcd_read_toc(sc);
 269 }
 270
 271 static int
 272 mcdclose(struct cdev *dev, int flags, int fmt, struct thread *td)
 273 {
 274         struct mcd_softc *sc;
 275
 276         sc = (struct mcd_softc *)dev->si_drv1;
 277
 278         if (!(sc->data.flags & MCDINIT) || !sc->data.openflags)
 279                 return (ENXIO);
 280
 281         (void) mcd_lock_door(sc, MCD_LK_UNLOCK);
 282         sc->data.openflags = 0;
 283         sc->data.partflags &= ~MCDREADRAW;
 284
 285         return (0);
 286 }
 287
 288 static void
 289 mcdstrategy(struct bio *bp)
 290 {
 291         struct mcd_softc *sc;
 292         int s;
 293
 294         sc = (struct mcd_softc *)bp->bio_dev->si_drv1;
 295
 296         /* if device invalidated (e.g. media change, door open), error */
 297         if (!(sc->data.flags & MCDVALID)) {
 298                 device_printf(sc->dev, "media changed\n");
 299                 bp->bio_error = EIO;
 300                 goto bad;
 301         }
 302
 303         /* read only */
 304         if (!(bp->bio_cmd == BIO_READ)) {
 305                 bp->bio_error = EROFS;
 306                 goto bad;
 307         }
 308
 309         /* no data to read */
 310         if (bp->bio_bcount == 0)
 311                 goto done;
 312
 313         if (!(sc->data.flags & MCDTOC)) {
 314                 bp->bio_error = EIO;
 315                 goto bad;
 316         }
 317
 318         bp->bio_resid = 0;
 319
 320         /* queue it */
 321         s = splbio();
 322         bioq_disksort(&sc->data.head, bp);
 323         splx(s);
 324
 325         /* now check whether we can perform processing */
 326         mcd_start(sc);
 327         return;
 328
 329 bad:
 330         bp->bio_flags |= BIO_ERROR;
 331 done:
 332         bp->bio_resid = bp->bio_bcount;
 333         biodone(bp);
 334         return;
 335 }
 336
 337 static void
 338 mcd_start(struct mcd_softc *sc)
 339 {
 340         struct bio *bp;
 341         int s = splbio();
 342
 343         if (sc->data.flags & MCDMBXBSY) {
 344                 splx(s);
 345                 return;
 346         }
 347
 348         bp = bioq_takefirst(&sc->data.head);
 349         if (bp != 0) {
 350                 /* block found to process, dequeue */
 351                 /*MCD_TRACE("mcd_start: found block bp=0x%x\n",bp,0,0,0);*/
 352                 sc->data.flags |= MCDMBXBSY;
 353                 splx(s);
 354         } else {
 355                 /* nothing to do */
 356                 splx(s);
 357                 return;
 358         }
 359
 360         sc->data.mbx.retry = MCD_RETRYS;
 361         sc->data.mbx.bp = bp;
 362
 363         mcd_doread(sc, MCD_S_BEGIN,&(sc->data.mbx));
 364         return;
 365 }
 366
 367 static int
 368 mcdioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flags, struct thread *td)
 369 {
 370         struct mcd_softc *sc;
 371         int retry,r;
 372
 373         sc = (struct mcd_softc *)dev->si_drv1;
 374
 375         if (mcd_getstat(sc, 1) == -1) /* detect disk change too */
 376                 return (EIO);
 377 MCD_TRACE("ioctl called 0x%lx\n", cmd);
 378
 379         switch (cmd) {
 380         case CDIOCSETPATCH:
 381         case CDIOCGETVOL:
 382         case CDIOCSETVOL:
 383         case CDIOCSETMONO:
 384         case CDIOCSETSTERIO:
 385         case CDIOCSETMUTE:
 386         case CDIOCSETLEFT:
 387         case CDIOCSETRIGHT:
 388                 return (EINVAL);
 389         case CDIOCEJECT:
 390                 return mcd_eject(sc);
 391         case CDIOCSETDEBUG:
 392                 sc->data.debug = 1;
 393                 return (0);
 394         case CDIOCCLRDEBUG:
 395                 sc->data.debug = 0;
 396                 return (0);
 397         case CDIOCRESET:
 398                 return mcd_hard_reset(sc);
 399         case CDIOCALLOW:
 400                 return mcd_lock_door(sc, MCD_LK_UNLOCK);
 401         case CDIOCPREVENT:
 402                 return mcd_lock_door(sc, MCD_LK_LOCK);
 403         case CDIOCCLOSE:
 404                 return mcd_inject(sc);
 405         }
 406
 407         if (!(sc->data.flags & MCDVALID)) {
 408                 if (    (sc->data.status & (MCDDSKCHNG|MCDDOOROPEN))
 409                     || !(sc->data.status & MCDDSKIN))
 410                         for (retry = 0; retry < DISK_SENSE_SECS * WAIT_FRAC; retry++) {
 411                                 (void) tsleep((caddr_t)sc, PSOCK | PCATCH, "mcdsn2", hz/WAIT_FRAC);
 412                                 if ((r = mcd_getstat(sc, 1)) == -1)
 413                                         return (EIO);
 414                                 if (r != -2)
 415                                         break;
 416                         }
 417                 if (   (sc->data.status & (MCDDOOROPEN|MCDDSKCHNG))
 418                     || !(sc->data.status & MCDDSKIN)
 419                     || mcd_size(dev) < 0
 420                    )
 421                         return (ENXIO);
 422                 sc->data.flags |= MCDVALID;
 423                 sc->data.partflags |= MCDREADRAW;
 424                 (void) mcd_lock_door(sc, MCD_LK_LOCK);
 425                 if (!(sc->data.flags & MCDVALID))
 426                         return (ENXIO);
 427         }
 428
 429         switch (cmd) {
 430         case DIOCGMEDIASIZE:
 431                 *(off_t *)addr = (off_t)sc->data.disksize * sc->data.blksize;
 432                 return (0);
 433         case DIOCGSECTORSIZE:
 434                 *(u_int *)addr = sc->data.blksize;
 435                 return (0);
 436
 437         case CDIOCPLAYTRACKS:
 438                 return mcd_playtracks(sc, (struct ioc_play_track *) addr);
 439         case CDIOCPLAYBLOCKS:
 440                 return mcd_playblocks(sc, (struct ioc_play_blocks *) addr);
 441         case CDIOCPLAYMSF:
 442                 return mcd_playmsf(sc, (struct ioc_play_msf *) addr);
 443         case CDIOCREADSUBCHANNEL_SYSSPACE:
 444                 return mcd_subchan(sc, (struct ioc_read_subchannel *) addr, 1);
 445         case CDIOCREADSUBCHANNEL:
 446                 return mcd_subchan(sc, (struct ioc_read_subchannel *) addr, 0);
 447         case CDIOREADTOCHEADER:
 448                 return mcd_toc_header(sc, (struct ioc_toc_header *) addr);
 449         case CDIOREADTOCENTRYS:
 450                 return mcd_toc_entrys(sc, (struct ioc_read_toc_entry *) addr);
 451         case CDIOCRESUME:
 452                 return mcd_resume(sc);
 453         case CDIOCPAUSE:
 454                 return mcd_pause(sc);
 455         case CDIOCSTART:
 456                 if (mcd_setmode(sc, MCD_MD_COOKED) != 0)
 457                         return (EIO);
 458                 return (0);
 459         case CDIOCSTOP:
 460                 return mcd_stop(sc);
 461         default:
 462                 return (ENOTTY);
 463         }
 464         /*NOTREACHED*/
 465 }
 466
 467 static int
 468 mcd_size(struct cdev *dev)
 469 {
 470         struct mcd_softc *sc;
 471         int size;
 472
 473         sc = (struct mcd_softc *)dev->si_drv1;
 474
 475         if (mcd_volinfo(sc) == 0) {
 476                 sc->data.blksize = MCDBLK;
 477                 size = msf2hsg(sc->data.volinfo.vol_msf, 0);
 478                 sc->data.disksize = size * (MCDBLK/DEV_BSIZE);
 479                 return (0);
 480         }
 481         return (-1);
 482 }
 483
 484 /***************************************************************
 485  * lower level of driver starts here
 486  **************************************************************/
 487
 488 #ifdef NOTDEF
 489 static char
 490 irqs[] = {
 491         0x00,0x00,0x10,0x20,0x00,0x30,0x00,0x00,
 492         0x00,0x10,0x40,0x50,0x00,0x00,0x00,0x00
 493 };
 494
 495 static char
 496 drqs[] = {
 497         0x00,0x01,0x00,0x03,0x00,0x05,0x06,0x07,
 498 };
 499 #endif
 500
 501 #ifdef NOT_YET
 502 static void
 503 mcd_configure(struct mcd_softc *sc)
 504 {
 505         MCD_WRITE(sc, MCD_REG_CONFIG, sc->data.config);
 506 }
 507 #endif
 508
 509 /* Wait for non-busy - return 0 on timeout */
 510 static int
 511 twiddle_thumbs(struct mcd_softc *sc, int count, char *whine)
 512 {
 513         int i;
 514
 515         for (i = 0; i < count; i++) {
 516                 if (!(MCD_READ(sc, MCD_FLAGS) & MFL_STATUS_NOT_AVAIL))
 517                         return (1);
 518                 }
 519         if (bootverbose)
 520                 device_printf(sc->dev, "timeout %s\n", whine);
 521         return (0);
 522 }
 523
 524 /* check to see if a Mitsumi CD-ROM is attached to the ISA bus */
 525
 526 int
 527 mcd_probe(struct mcd_softc *sc)
 528 {
 529         int i, j;
 530         unsigned char stbytes[3];
 531
 532         sc->data.flags = MCDPROBING;
 533
 534 #ifdef NOTDEF
 535         /* get irq/drq configuration word */
 536         sc->data.config = irqs[dev->id_irq]; /* | drqs[dev->id_drq];*/
 537 #else
 538         sc->data.config = 0;
 539 #endif
 540
 541         /* send a reset */
 542         MCD_WRITE(sc, MCD_FLAGS, M_RESET);
 543
 544         /*
 545          * delay awhile by getting any pending garbage (old data) and
 546          * throwing it away.
 547          */
 548         for (i = 1000000; i != 0; i--)
 549                 (void)MCD_READ(sc, MCD_FLAGS);
 550
 551         /* Get status */
 552         MCD_WRITE(sc, MCD_DATA, MCD_CMDGETSTAT);
 553         if (!twiddle_thumbs(sc, 1000000, "getting status"))
 554                 return (ENXIO); /* Timeout */
 555         /* Get version information */
 556         MCD_WRITE(sc, MCD_DATA, MCD_CMDCONTINFO);
 557         for (j = 0; j < 3; j++) {
 558                 if (!twiddle_thumbs(sc, 3000, "getting version info"))
 559                         return (ENXIO);
 560                 stbytes[j] = (MCD_READ(sc, MCD_DATA) & 0xFF);
 561         }
 562         if (stbytes[1] == stbytes[2])
 563                 return (ENXIO);
 564         if (stbytes[2] >= 4 || stbytes[1] != 'M') {
 565                 MCD_WRITE(sc, MCD_CTRL, M_PICKLE);
 566                 sc->data.flags |= MCDNEWMODEL;
 567         }
 568         sc->data.read_command = MCD_CMDSINGLESPEEDREAD;
 569         switch (stbytes[1]) {
 570         case 'M':
 571                 if (stbytes[2] <= 2) {
 572                         sc->data.type = MCD_TYPE_LU002S;
 573                         sc->data.name = "Mitsumi LU002S";
 574                 } else if (stbytes[2] <= 5) {
 575                         sc->data.type = MCD_TYPE_LU005S;
 576                         sc->data.name = "Mitsumi LU005S";
 577                 } else {
 578                         sc->data.type = MCD_TYPE_LU006S;
 579                         sc->data.name = "Mitsumi LU006S";
 580                 }
 581                 break;
 582         case 'F':
 583                 sc->data.type = MCD_TYPE_FX001;
 584                 sc->data.name = "Mitsumi FX001";
 585                 break;
 586         case 'D':
 587                 sc->data.type = MCD_TYPE_FX001D;
 588                 sc->data.name = "Mitsumi FX001D";
 589                 sc->data.read_command = MCD_CMDDOUBLESPEEDREAD;
 590                 break;
 591         default:
 592                 sc->data.type = MCD_TYPE_UNKNOWN;
 593                 sc->data.name = "Mitsumi ???";
 594                 break;
 595         }
 596
 597         if (bootverbose)
 598                 device_printf(sc->dev, "type %s, version info: %c %x\n",
 599                         sc->data.name, stbytes[1], stbytes[2]);
 600
 601         return (0);
 602 }
 603
 604
 605 static int
 606 mcd_waitrdy(struct mcd_softc *sc, int dly)
 607 {
 608         int i;
 609
 610         /* wait until flag port senses status ready */
 611         for (i=0; i<dly; i+=MIN_DELAY) {
 612                 if (!(MCD_READ(sc, MCD_FLAGS) & MFL_STATUS_NOT_AVAIL))
 613                         return (0);
 614                 DELAY(MIN_DELAY);
 615         }
 616         return (-1);
 617 }
 618
 619 static int
 620 mcd_getreply(struct mcd_softc *sc, int dly)
 621 {
 622
 623         /* wait data to become ready */
 624         if (mcd_waitrdy(sc, dly)<0) {
 625                 device_printf(sc->dev, "timeout getreply\n");
 626                 return (-1);
 627         }
 628
 629         /* get the data */
 630         return (MCD_READ(sc, MCD_REG_STATUS) & 0xFF);
 631 }
 632
 633 static int
 634 mcd_getstat(struct mcd_softc *sc, int sflg)
 635 {
 636         int     i;
 637
 638         /* get the status */
 639         if (sflg)
 640                 MCD_WRITE(sc, MCD_REG_COMMAND, MCD_CMDGETSTAT);
 641         i = mcd_getreply(sc, DELAY_GETREPLY);
 642         if (i<0 || (i & MCD_ST_CMDCHECK)) {
 643                 sc->data.curr_mode = MCD_MD_UNKNOWN;
 644                 return (-1);
 645         }
 646
 647         sc->data.status = i;
 648
 649         if (mcd_setflags(sc) < 0)
 650                 return (-2);
 651         return (sc->data.status);
 652 }
 653
 654 static int
 655 mcd_setflags(struct mcd_softc *sc)
 656 {
 657
 658         /* check flags */
 659         if (    (sc->data.status & (MCDDSKCHNG|MCDDOOROPEN))
 660             || !(sc->data.status & MCDDSKIN)) {
 661                 MCD_TRACE("setflags: sensed DSKCHNG or DOOROPEN or !DSKIN\n");
 662                 mcd_soft_reset(sc);
 663                 return (-1);
 664         }
 665
 666         if (sc->data.status & MCDAUDIOBSY)
 667                 sc->data.audio_status = CD_AS_PLAY_IN_PROGRESS;
 668         else if (sc->data.audio_status == CD_AS_PLAY_IN_PROGRESS)
 669                 sc->data.audio_status = CD_AS_PLAY_COMPLETED;
 670         return (0);
 671 }
 672
 673 static int
 674 mcd_get(struct mcd_softc *sc, char *buf, int nmax)
 675 {
 676         int i,k;
 677
 678         for (i=0; i<nmax; i++) {
 679                 /* wait for data */
 680                 if ((k = mcd_getreply(sc, DELAY_GETREPLY)) < 0) {
 681                         device_printf(sc->dev, "timeout mcd_get\n");
 682                         return (-1);
 683                 }
 684                 buf[i] = k;
 685         }
 686         return (i);
 687 }
 688
 689 static int
 690 mcd_send(struct mcd_softc *sc, int cmd,int nretrys)
 691 {
 692         int i,k=0;
 693
 694 /*MCD_TRACE("mcd_send: command = 0x%02x\n",cmd,0,0,0);*/
 695         for (i=0; i<nretrys; i++) {
 696                 MCD_WRITE(sc, MCD_REG_COMMAND, cmd);
 697                 if ((k=mcd_getstat(sc, 0)) != -1)
 698                         break;
 699         }
 700         if (k == -2) {
 701                 device_printf(sc->dev, "media changed\n");
 702                 return (-1);
 703         }
 704         if (i == nretrys) {
 705                 device_printf(sc->dev, "mcd_send retry cnt exceeded\n");
 706                 return (-1);
 707         }
 708 /*MCD_TRACE("mcd_send: done\n",0,0,0,0);*/
 709         return (0);
 710 }
 711
 712 static void
 713 hsg2msf(int hsg, bcd_t *msf)
 714 {
 715         hsg += 150;
 716         F_msf(msf) = bin2bcd(hsg % 75);
 717         hsg /= 75;
 718         S_msf(msf) = bin2bcd(hsg % 60);
 719         hsg /= 60;
 720         M_msf(msf) = bin2bcd(hsg);
 721 }
 722
 723 static int
 724 msf2hsg(bcd_t *msf, int relative)
 725 {
 726         return (bcd2bin(M_msf(msf)) * 60 + bcd2bin(S_msf(msf))) * 75 +
 727                 bcd2bin(F_msf(msf)) - (!relative) * 150;
 728 }
 729
 730 static int
 731 mcd_volinfo(struct mcd_softc *sc)
 732 {
 733
 734         /* Just return if we already have it */
 735         if (sc->data.flags & MCDVOLINFO) return (0);
 736
 737 /*MCD_TRACE("mcd_volinfo: enter\n",0,0,0,0);*/
 738
 739         /* send volume info command */
 740         if (mcd_send(sc, MCD_CMDGETVOLINFO,MCD_RETRYS) < 0)
 741                 return (EIO);
 742
 743         /* get data */
 744         if (mcd_get(sc, (char*) &sc->data.volinfo,sizeof(struct mcd_volinfo)) < 0) {
 745                 device_printf(sc->dev, "mcd_volinfo: error read data\n");
 746                 return (EIO);
 747         }
 748
 749         if (sc->data.volinfo.trk_low > 0 &&
 750             sc->data.volinfo.trk_high >= sc->data.volinfo.trk_low
 751            ) {
 752                 sc->data.flags |= MCDVOLINFO;   /* volinfo is OK */
 753                 return (0);
 754         }
 755
 756         return (EINVAL);
 757 }
 758
 759 /* state machine to process read requests
 760  * initialize with MCD_S_BEGIN: calculate sizes, and read status
 761  * MCD_S_WAITSTAT: wait for status reply, set mode
 762  * MCD_S_WAITMODE: waits for status reply from set mode, set read command
 763  * MCD_S_WAITREAD: wait for read ready, read data
 764  */
 765 static void
 766 mcd_timeout(void *arg)
 767 {
 768         struct mcd_softc *sc;
 769
 770         sc = (struct mcd_softc *)arg;
 771
 772         mcd_doread(sc, sc->ch_state, sc->ch_mbxsave);
 773 }
 774
 775 static void
 776 mcd_doread(struct mcd_softc *sc, int state, struct mcd_mbx *mbxin)
 777 {
 778         struct mcd_mbx *mbx;
 779         struct bio *bp;
 780         int rm, i, k;
 781         struct mcd_read2 rbuf;
 782         int blknum;
 783         caddr_t addr;
 784
 785         mbx = (state!=MCD_S_BEGIN) ? sc->ch_mbxsave : mbxin;
 786         bp = mbx->bp;
 787
 788 loop:
 789         switch (state) {
 790         case MCD_S_BEGIN:
 791                 mbx = sc->ch_mbxsave = mbxin;
 792
 793         case MCD_S_BEGIN1:
 794 retry_status:
 795                 /* get status */
 796                 MCD_WRITE(sc, MCD_REG_COMMAND, MCD_CMDGETSTAT);
 797                 mbx->count = RDELAY_WAITSTAT;
 798                 sc->ch_state = MCD_S_WAITSTAT;
 799                 sc->ch = timeout(mcd_timeout, (caddr_t)sc, hz/100); /* XXX */
 800                 return;
 801         case MCD_S_WAITSTAT:
 802                 sc->ch_state = MCD_S_WAITSTAT;
 803                 untimeout(mcd_timeout,(caddr_t)sc, sc->ch);
 804                 if (mbx->count-- >= 0) {
 805                         if (MCD_READ(sc, MCD_FLAGS) & MFL_STATUS_NOT_AVAIL) {
 806                                 sc->ch_state = MCD_S_WAITSTAT;
 807                                 timeout(mcd_timeout, (caddr_t)sc, hz/100); /* XXX */
 808                                 return;
 809                         }
 810                         sc->data.status = MCD_READ(sc, MCD_REG_STATUS) & 0xFF;
 811                         if (sc->data.status & MCD_ST_CMDCHECK)
 812                                 goto retry_status;
 813                         if (mcd_setflags(sc) < 0)
 814                                 goto changed;
 815                         MCD_TRACE("got WAITSTAT delay=%d\n",
 816                                 RDELAY_WAITSTAT-mbx->count);
 817                         /* reject, if audio active */
 818                         if (sc->data.status & MCDAUDIOBSY) {
 819                                 device_printf(sc->dev, "audio is active\n");
 820                                 goto readerr;
 821                         }
 822
 823 retry_mode:
 824                         /* to check for raw/cooked mode */
 825                         if (sc->data.flags & MCDREADRAW) {
 826                                 rm = MCD_MD_RAW;
 827                                 mbx->sz = MCDRBLK;
 828                         } else {
 829                                 rm = MCD_MD_COOKED;
 830                                 mbx->sz = sc->data.blksize;
 831                         }
 832
 833                         if (rm == sc->data.curr_mode)
 834                                 goto modedone;
 835
 836                         mbx->count = RDELAY_WAITMODE;
 837
 838                         sc->data.curr_mode = MCD_MD_UNKNOWN;
 839                         mbx->mode = rm;
 840                         MCD_WRITE(sc, MCD_REG_COMMAND, MCD_CMDSETMODE);
 841                         MCD_WRITE(sc, MCD_REG_COMMAND, rm);
 842
 843                         sc->ch_state = MCD_S_WAITMODE;
 844                         sc->ch = timeout(mcd_timeout, (caddr_t)sc, hz/100); /* XXX */
 845                         return;
 846                 } else {
 847                         device_printf(sc->dev, "timeout getstatus\n");
 848                         goto readerr;
 849                 }
 850
 851         case MCD_S_WAITMODE:
 852                 sc->ch_state = MCD_S_WAITMODE;
 853                 untimeout(mcd_timeout, (caddr_t)sc, sc->ch);
 854                 if (mbx->count-- < 0) {
 855                         device_printf(sc->dev, "timeout set mode\n");
 856                         goto readerr;
 857                 }
 858                 if (MCD_READ(sc, MCD_FLAGS) & MFL_STATUS_NOT_AVAIL) {
 859                         sc->ch_state = MCD_S_WAITMODE;
 860                         sc->ch = timeout(mcd_timeout, (caddr_t)sc, hz/100);
 861                         return;
 862                 }
 863                 sc->data.status = MCD_READ(sc, MCD_REG_STATUS) & 0xFF;
 864                 if (sc->data.status & MCD_ST_CMDCHECK) {
 865                         sc->data.curr_mode = MCD_MD_UNKNOWN;
 866                         goto retry_mode;
 867                 }
 868                 if (mcd_setflags(sc) < 0)
 869                         goto changed;
 870                 sc->data.curr_mode = mbx->mode;
 871                 MCD_TRACE("got WAITMODE delay=%d\n",
 872                         RDELAY_WAITMODE-mbx->count);
 873 modedone:
 874                 /* for first block */
 875                 mbx->nblk = (bp->bio_bcount + (mbx->sz-1)) / mbx->sz;
 876                 mbx->skip = 0;
 877
 878 nextblock:
 879                 blknum  = bp->bio_offset / mbx->sz + mbx->skip/mbx->sz;
 880
 881                 MCD_TRACE("mcd_doread: read blknum=%d for bp=%p\n",
 882                         blknum, bp);
 883
 884                 /* build parameter block */
 885                 hsg2msf(blknum,rbuf.start_msf);
 886 retry_read:
 887                 /* send the read command */
 888                 critical_enter();
 889                 MCD_WRITE(sc, MCD_REG_COMMAND, sc->data.read_command);
 890                 MCD_WRITE(sc, MCD_REG_COMMAND, rbuf.start_msf[0]);
 891                 MCD_WRITE(sc, MCD_REG_COMMAND, rbuf.start_msf[1]);
 892                 MCD_WRITE(sc, MCD_REG_COMMAND, rbuf.start_msf[2]);
 893                 MCD_WRITE(sc, MCD_REG_COMMAND, 0);
 894                 MCD_WRITE(sc, MCD_REG_COMMAND, 0);
 895                 MCD_WRITE(sc, MCD_REG_COMMAND, 1);
 896                 critical_exit();
 897
 898                 /* Spin briefly (<= 2ms) to avoid missing next block */
 899                 for (i = 0; i < 20; i++) {
 900                         k = MCD_READ(sc, MCD_FLAGS);
 901                         if (!(k & MFL_DATA_NOT_AVAIL))
 902                                 goto got_it;
 903                         DELAY(100);
 904                 }
 905
 906                 mbx->count = RDELAY_WAITREAD;
 907                 sc->ch_state = MCD_S_WAITREAD;
 908                 sc->ch = timeout(mcd_timeout, (caddr_t)sc, hz/100); /* XXX */
 909                 return;
 910         case MCD_S_WAITREAD:
 911                 sc->ch_state = MCD_S_WAITREAD;
 912                 untimeout(mcd_timeout, (caddr_t)sc, sc->ch);
 913                 if (mbx->count-- > 0) {
 914                         k = MCD_READ(sc, MCD_FLAGS);
 915                         if (!(k & MFL_DATA_NOT_AVAIL)) { /* XXX */
 916                                 MCD_TRACE("got data delay=%d\n",
 917                                         RDELAY_WAITREAD-mbx->count);
 918                         got_it:
 919                                 /* data is ready */
 920                                 addr    = bp->bio_data + mbx->skip;
 921
 922                                 MCD_WRITE(sc, MCD_REG_CTL2,0x04);       /* XXX */
 923                                 for (i=0; i<mbx->sz; i++)
 924                                         *addr++ = MCD_READ(sc, MCD_REG_RDATA);
 925                                 MCD_WRITE(sc, MCD_REG_CTL2,0x0c);       /* XXX */
 926
 927                                 k = MCD_READ(sc, MCD_FLAGS);
 928                                 /* If we still have some junk, read it too */
 929                                 if (!(k & MFL_DATA_NOT_AVAIL)) {
 930                                         MCD_WRITE(sc, MCD_REG_CTL2, 0x04);       /* XXX */
 931                                         (void)MCD_READ(sc, MCD_REG_RDATA);
 932                                         (void)MCD_READ(sc, MCD_REG_RDATA);
 933                                         MCD_WRITE(sc, MCD_REG_CTL2, 0x0c);       /* XXX */
 934                                 }
 935
 936                                 if (--mbx->nblk > 0) {
 937                                         mbx->skip += mbx->sz;
 938                                         goto nextblock;
 939                                 }
 940
 941                                 /* return buffer */
 942                                 bp->bio_resid = 0;
 943                                 biodone(bp);
 944
 945                                 sc->data.flags &= ~(MCDMBXBSY|MCDREADRAW);
 946                                 mcd_start(sc);
 947                                 return;
 948                         }
 949                         if (!(k & MFL_STATUS_NOT_AVAIL)) {
 950                                 sc->data.status = MCD_READ(sc, MCD_REG_STATUS) & 0xFF;
 951                                 if (sc->data.status & MCD_ST_CMDCHECK)
 952                                         goto retry_read;
 953                                 if (mcd_setflags(sc) < 0)
 954                                         goto changed;
 955                         }
 956                         sc->ch_state = MCD_S_WAITREAD;
 957                         sc->ch = timeout(mcd_timeout, (caddr_t)sc, hz/100); /* XXX */
 958                         return;
 959                 } else {
 960                         device_printf(sc->dev, "timeout read data\n");
 961                         goto readerr;
 962                 }
 963         }
 964
 965 readerr:
 966         if (mbx->retry-- > 0) {
 967                 device_printf(sc->dev, "retrying\n");
 968                 state = MCD_S_BEGIN1;
 969                 goto loop;
 970         }
 971 harderr:
 972         /* invalidate the buffer */
 973         bp->bio_flags |= BIO_ERROR;
 974         bp->bio_resid = bp->bio_bcount;
 975         biodone(bp);
 976
 977         sc->data.flags &= ~(MCDMBXBSY|MCDREADRAW);
 978         mcd_start(sc);
 979         return;
 980
 981 changed:
 982         device_printf(sc->dev, "media changed\n");
 983         goto harderr;
 984
 985 #ifdef NOTDEF
 986         device_printf(sc->dev, "unit timeout, resetting\n");
 987         MCD_WRITE(sc, MCD_REG_RESET, MCD_CMDRESET);
 988         DELAY(300000);
 989         (void)mcd_getstat(sc, 1);
 990         (void)mcd_getstat(sc, 1);
 991         /*sc->data.status &= ~MCDDSKCHNG; */
 992         sc->data.debug = 1; /* preventive set debug mode */
 993
 994 #endif
 995
 996 }
 997
 998 static int
 999 mcd_lock_door(struct mcd_softc *sc, int lock)
1000 {
1001
1002         MCD_WRITE(sc, MCD_REG_COMMAND, MCD_CMDLOCKDRV);
1003         MCD_WRITE(sc, MCD_REG_COMMAND, lock);
1004         if (mcd_getstat(sc, 0) == -1)
1005                 return (EIO);
1006         return (0);
1007 }
1008
1009 static int
1010 mcd_close_tray(struct mcd_softc *sc)
1011 {
1012         int retry, r;
1013
1014         if (mcd_getstat(sc, 1) == -1)
1015                 return (EIO);
1016         if (sc->data.status & MCDDOOROPEN) {
1017                 MCD_WRITE(sc, MCD_REG_COMMAND, MCD_CMDCLOSETRAY);
1018                 for (retry = 0; retry < CLOSE_TRAY_SECS * WAIT_FRAC; retry++) {
1019                         if (MCD_READ(sc, MCD_FLAGS) & MFL_STATUS_NOT_AVAIL)
1020                                 (void) tsleep((caddr_t)sc, PSOCK | PCATCH, "mcdcls", hz/WAIT_FRAC);
1021                         else {
1022                                 if ((r = mcd_getstat(sc, 0)) == -1)
1023                                         return (EIO);
1024                                 return (0);
1025                         }
1026                 }
1027                 return (ENXIO);
1028         }
1029         return (0);
1030 }
1031
1032 static int
1033 mcd_eject(struct mcd_softc *sc)
1034 {
1035         int r;
1036
1037         if (mcd_getstat(sc, 1) == -1)    /* detect disk change too */
1038                 return (EIO);
1039         if (sc->data.status & MCDDOOROPEN)
1040                 return (0);
1041         if ((r = mcd_stop(sc)) == EIO)
1042                 return (r);
1043         MCD_WRITE(sc, MCD_REG_COMMAND, MCD_CMDEJECTDISK);
1044         if (mcd_getstat(sc, 0) == -1)
1045                 return (EIO);
1046         return (0);
1047 }
1048
1049 static int
1050 mcd_inject(struct mcd_softc *sc)
1051 {
1052
1053         if (mcd_getstat(sc, 1) == -1)    /* detect disk change too */
1054                 return (EIO);
1055         if (sc->data.status & MCDDOOROPEN)
1056                 return mcd_close_tray(sc);
1057         return (0);
1058 }
1059
1060 static int
1061 mcd_hard_reset(struct mcd_softc *sc)
1062 {
1063
1064         MCD_WRITE(sc, MCD_REG_RESET, MCD_CMDRESET);
1065         sc->data.curr_mode = MCD_MD_UNKNOWN;
1066         sc->data.audio_status = CD_AS_AUDIO_INVALID;
1067         return (0);
1068 }
1069
1070 static void
1071 mcd_soft_reset(struct mcd_softc *sc)
1072 {
1073
1074         sc->data.flags &= (MCDINIT|MCDPROBING|MCDNEWMODEL);
1075         sc->data.curr_mode = MCD_MD_UNKNOWN;
1076         sc->data.partflags = 0;
1077         sc->data.audio_status = CD_AS_AUDIO_INVALID;
1078 }
1079
1080 static int
1081 mcd_setmode(struct mcd_softc *sc, int mode)
1082 {
1083         int retry, st;
1084
1085         if (sc->data.curr_mode == mode)
1086                 return (0);
1087         if (sc->data.debug)
1088                 device_printf(sc->dev, "setting mode to %d\n", mode);
1089         for(retry=0; retry<MCD_RETRYS; retry++)
1090         {
1091                 sc->data.curr_mode = MCD_MD_UNKNOWN;
1092                 MCD_WRITE(sc, MCD_REG_COMMAND, MCD_CMDSETMODE);
1093                 MCD_WRITE(sc, MCD_REG_COMMAND, mode);
1094                 if ((st = mcd_getstat(sc, 0)) >= 0) {
1095                         sc->data.curr_mode = mode;
1096                         return (0);
1097                 }
1098                 if (st == -2) {
1099                         device_printf(sc->dev, "media changed\n");
1100                         break;
1101                 }
1102         }
1103
1104         return (-1);
1105 }
1106
1107 static int
1108 mcd_toc_header(struct mcd_softc *sc, struct ioc_toc_header *th)
1109 {
1110         int r;
1111
1112         if ((r = mcd_volinfo(sc)) != 0)
1113                 return (r);
1114
1115         th->starting_track = bcd2bin(sc->data.volinfo.trk_low);
1116         th->ending_track = bcd2bin(sc->data.volinfo.trk_high);
1117         th->len = 2 * sizeof(u_char) /* start & end tracks */ +
1118                   (th->ending_track + 1 - th->starting_track + 1) *
1119                   sizeof(struct cd_toc_entry);
1120
1121         return (0);
1122 }
1123
1124 static int
1125 mcd_read_toc(struct mcd_softc *sc)
1126 {
1127         struct ioc_toc_header th;
1128         struct mcd_qchninfo q;
1129         int rc, trk, idx, retry;
1130
1131         /* Only read TOC if needed */
1132         if (sc->data.flags & MCDTOC)
1133                 return (0);
1134
1135         if (sc->data.debug)
1136                 device_printf(sc->dev, "reading toc header\n");
1137
1138         if ((rc = mcd_toc_header(sc, &th)) != 0)
1139                 return (rc);
1140
1141         if (mcd_send(sc, MCD_CMDSTOPAUDIO, MCD_RETRYS) < 0)
1142                 return (EIO);
1143
1144         if (mcd_setmode(sc, MCD_MD_TOC) != 0)
1145                 return (EIO);
1146
1147         if (sc->data.debug)
1148                 device_printf(sc->dev, "get_toc reading qchannel info\n");
1149
1150         for(trk=th.starting_track; trk<=th.ending_track; trk++)
1151                 sc->data.toc[trk].idx_no = 0;
1152         trk = th.ending_track - th.starting_track + 1;
1153         for(retry=0; retry<600 && trk>0; retry++)
1154         {
1155                 if (mcd_getqchan(sc, &q) < 0) break;
1156                 idx = bcd2bin(q.idx_no);
1157                 if (idx>=th.starting_track && idx<=th.ending_track && q.trk_no==0) {
1158                         if (sc->data.toc[idx].idx_no == 0) {
1159                                 sc->data.toc[idx] = q;
1160                                 trk--;
1161                         }
1162                 }
1163         }
1164
1165         if (mcd_setmode(sc, MCD_MD_COOKED) != 0)
1166                 return (EIO);
1167
1168         if (trk != 0)
1169                 return (ENXIO);
1170
1171         /* add a fake last+1 */
1172         idx = th.ending_track + 1;
1173         sc->data.toc[idx].control = sc->data.toc[idx-1].control;
1174         sc->data.toc[idx].addr_type = sc->data.toc[idx-1].addr_type;
1175         sc->data.toc[idx].trk_no = 0;
1176         sc->data.toc[idx].idx_no = MCD_LASTPLUS1;
1177         sc->data.toc[idx].hd_pos_msf[0] = sc->data.volinfo.vol_msf[0];
1178         sc->data.toc[idx].hd_pos_msf[1] = sc->data.volinfo.vol_msf[1];
1179         sc->data.toc[idx].hd_pos_msf[2] = sc->data.volinfo.vol_msf[2];
1180
1181         if (sc->data.debug)
1182         { int i;
1183         for (i = th.starting_track; i <= idx; i++)
1184                 device_printf(sc->dev, "trk %d idx %d pos %d %d %d\n",
1185                         i,
1186                         sc->data.toc[i].idx_no > 0x99 ? sc->data.toc[i].idx_no :
1187                         bcd2bin(sc->data.toc[i].idx_no),
1188                         bcd2bin(sc->data.toc[i].hd_pos_msf[0]),
1189                         bcd2bin(sc->data.toc[i].hd_pos_msf[1]),
1190                         bcd2bin(sc->data.toc[i].hd_pos_msf[2]));
1191         }
1192
1193         sc->data.flags |= MCDTOC;
1194
1195         return (0);
1196 }
1197
1198 #if 0
1199 static int
1200 mcd_toc_entry(struct mcd_softc *sc, struct ioc_read_toc_single_entry *te)
1201 {
1202         struct ioc_toc_header th;
1203         int rc, trk;
1204
1205         if (te->address_format != CD_MSF_FORMAT
1206             && te->address_format != CD_LBA_FORMAT)
1207                 return (EINVAL);
1208
1209         /* Copy the toc header */
1210         if ((rc = mcd_toc_header(sc, &th)) != 0)
1211                 return (rc);
1212
1213         /* verify starting track */
1214         trk = te->track;
1215         if (trk == 0)
1216                 trk = th.starting_track;
1217         else if (trk == MCD_LASTPLUS1)
1218                 trk = th.ending_track + 1;
1219         else if (trk < th.starting_track || trk > th.ending_track + 1)
1220                 return (EINVAL);
1221
1222         /* Make sure we have a valid toc */
1223         if ((rc=mcd_read_toc(sc)) != 0)
1224                 return (rc);
1225
1226         /* Copy the TOC data. */
1227         if (sc->data.toc[trk].idx_no == 0)
1228                 return (EIO);
1229
1230         te->entry.control = sc->data.toc[trk].control;
1231         te->entry.addr_type = sc->data.toc[trk].addr_type;
1232         te->entry.track =
1233                 sc->data.toc[trk].idx_no > 0x99 ? sc->data.toc[trk].idx_no :
1234                 bcd2bin(sc->data.toc[trk].idx_no);
1235         switch (te->address_format) {
1236         case CD_MSF_FORMAT:
1237                 te->entry.addr.msf.unused = 0;
1238                 te->entry.addr.msf.minute = bcd2bin(sc->data.toc[trk].hd_pos_msf[0]);
1239                 te->entry.addr.msf.second = bcd2bin(sc->data.toc[trk].hd_pos_msf[1]);
1240                 te->entry.addr.msf.frame = bcd2bin(sc->data.toc[trk].hd_pos_msf[2]);
1241                 break;
1242         case CD_LBA_FORMAT:
1243                 te->entry.addr.lba = htonl(msf2hsg(sc->data.toc[trk].hd_pos_msf, 0));
1244                 break;
1245         }
1246         return (0);
1247 }
1248 #endif
1249
1250 static int
1251 mcd_toc_entrys(struct mcd_softc *sc, struct ioc_read_toc_entry *te)
1252 {
1253         struct cd_toc_entry entries[MCD_MAXTOCS];
1254         struct ioc_toc_header th;
1255         int rc, n, trk, len;
1256
1257         if (   te->data_len < sizeof(entries[0])
1258             || (te->data_len % sizeof(entries[0])) != 0
1259             || (te->address_format != CD_MSF_FORMAT
1260                 && te->address_format != CD_LBA_FORMAT)
1261            )
1262                 return (EINVAL);
1263
1264         /* Copy the toc header */
1265         if ((rc = mcd_toc_header(sc, &th)) != 0)
1266                 return (rc);
1267
1268         /* verify starting track */
1269         trk = te->starting_track;
1270         if (trk == 0)
1271                 trk = th.starting_track;
1272         else if (trk == MCD_LASTPLUS1)
1273                 trk = th.ending_track + 1;
1274         else if (trk < th.starting_track || trk > th.ending_track + 1)
1275                 return (EINVAL);
1276
1277         len = ((th.ending_track + 1 - trk) + 1) *
1278                 sizeof(entries[0]);
1279         if (te->data_len < len)
1280                 len = te->data_len;
1281         if (len > sizeof(entries))
1282                 return (EINVAL);
1283
1284         /* Make sure we have a valid toc */
1285         if ((rc=mcd_read_toc(sc)) != 0)
1286                 return (rc);
1287
1288         /* Copy the TOC data. */
1289         for (n = 0; len > 0 && trk <= th.ending_track + 1; trk++) {
1290                 if (sc->data.toc[trk].idx_no == 0)
1291                         continue;
1292                 entries[n].control = sc->data.toc[trk].control;
1293                 entries[n].addr_type = sc->data.toc[trk].addr_type;
1294                 entries[n].track =
1295                         sc->data.toc[trk].idx_no > 0x99 ? sc->data.toc[trk].idx_no :
1296                         bcd2bin(sc->data.toc[trk].idx_no);
1297                 switch (te->address_format) {
1298                 case CD_MSF_FORMAT:
1299                         entries[n].addr.msf.unused = 0;
1300                         entries[n].addr.msf.minute = bcd2bin(sc->data.toc[trk].hd_pos_msf[0]);
1301                         entries[n].addr.msf.second = bcd2bin(sc->data.toc[trk].hd_pos_msf[1]);
1302                         entries[n].addr.msf.frame = bcd2bin(sc->data.toc[trk].hd_pos_msf[2]);
1303                         break;
1304                 case CD_LBA_FORMAT:
1305                         entries[n].addr.lba = htonl(msf2hsg(sc->data.toc[trk].hd_pos_msf, 0));
1306                         break;
1307                 }
1308                 len -= sizeof(struct cd_toc_entry);
1309                 n++;
1310         }
1311
1312         /* copy the data back */
1313         return copyout(entries, te->data, n * sizeof(struct cd_toc_entry));
1314 }
1315
1316 static int
1317 mcd_stop(struct mcd_softc *sc)
1318 {
1319
1320         /* Verify current status */
1321         if (sc->data.audio_status != CD_AS_PLAY_IN_PROGRESS &&
1322             sc->data.audio_status != CD_AS_PLAY_PAUSED &&
1323             sc->data.audio_status != CD_AS_PLAY_COMPLETED) {
1324                 if (sc->data.debug)
1325                         device_printf(sc->dev,
1326                                 "stop attempted when not playing, audio status %d\n",
1327                                 sc->data.audio_status);
1328                 return (EINVAL);
1329         }
1330         if (sc->data.audio_status == CD_AS_PLAY_IN_PROGRESS)
1331                 if (mcd_send(sc, MCD_CMDSTOPAUDIO, MCD_RETRYS) < 0)
1332                         return (EIO);
1333         sc->data.audio_status = CD_AS_PLAY_COMPLETED;
1334         return (0);
1335 }
1336
1337 static int
1338 mcd_getqchan(struct mcd_softc *sc, struct mcd_qchninfo *q)
1339 {
1340
1341         if (mcd_send(sc, MCD_CMDGETQCHN, MCD_RETRYS) < 0)
1342                 return (-1);
1343         if (mcd_get(sc, (char *) q, sizeof(struct mcd_qchninfo)) < 0)
1344                 return (-1);
1345         if (sc->data.debug) {
1346                 device_printf(sc->dev,
1347                         "getqchan control=0x%x addr_type=0x%x trk=%d ind=%d ttm=%d:%d.%d dtm=%d:%d.%d\n",
1348                         q->control, q->addr_type,
1349                         bcd2bin(q->trk_no),
1350                         bcd2bin(q->idx_no),
1351                         bcd2bin(q->trk_size_msf[0]),
1352                         bcd2bin(q->trk_size_msf[1]),
1353                         bcd2bin(q->trk_size_msf[2]),
1354                         bcd2bin(q->hd_pos_msf[0]),
1355                         bcd2bin(q->hd_pos_msf[1]),
1356                         bcd2bin(q->hd_pos_msf[2]));
1357         }
1358         return (0);
1359 }
1360
1361 static int
1362 mcd_subchan(struct mcd_softc *sc, struct ioc_read_subchannel *sch, int nocopyout)
1363 {
1364         struct mcd_qchninfo q;
1365         struct cd_sub_channel_info data;
1366         int lba;
1367
1368         if (sc->data.debug)
1369                 device_printf(sc->dev, "subchan af=%d, df=%d\n",
1370                         sch->address_format,
1371                         sch->data_format);
1372
1373         if (sch->address_format != CD_MSF_FORMAT &&
1374             sch->address_format != CD_LBA_FORMAT)
1375                 return (EINVAL);
1376
1377         if (sch->data_format != CD_CURRENT_POSITION &&
1378             sch->data_format != CD_MEDIA_CATALOG)
1379                 return (EINVAL);
1380
1381         if (mcd_setmode(sc, MCD_MD_COOKED) != 0)
1382                 return (EIO);
1383
1384         if (mcd_getqchan(sc, &q) < 0)
1385                 return (EIO);
1386
1387         data.header.audio_status = sc->data.audio_status;
1388         data.what.position.data_format = sch->data_format;
1389
1390         switch (sch->data_format) {
1391         case CD_MEDIA_CATALOG:
1392                 data.what.media_catalog.mc_valid = 1;
1393                 data.what.media_catalog.mc_number[0] = '\0';
1394                 break;
1395
1396         case CD_CURRENT_POSITION:
1397                 data.what.position.control = q.control;
1398                 data.what.position.addr_type = q.addr_type;
1399                 data.what.position.track_number = bcd2bin(q.trk_no);
1400                 data.what.position.index_number = bcd2bin(q.idx_no);
1401                 switch (sch->address_format) {
1402                 case CD_MSF_FORMAT:
1403                         data.what.position.reladdr.msf.unused = 0;
1404                         data.what.position.reladdr.msf.minute = bcd2bin(q.trk_size_msf[0]);
1405                         data.what.position.reladdr.msf.second = bcd2bin(q.trk_size_msf[1]);
1406                         data.what.position.reladdr.msf.frame = bcd2bin(q.trk_size_msf[2]);
1407                         data.what.position.absaddr.msf.unused = 0;
1408                         data.what.position.absaddr.msf.minute = bcd2bin(q.hd_pos_msf[0]);
1409                         data.what.position.absaddr.msf.second = bcd2bin(q.hd_pos_msf[1]);
1410                         data.what.position.absaddr.msf.frame = bcd2bin(q.hd_pos_msf[2]);
1411                         break;
1412                 case CD_LBA_FORMAT:
1413                         lba = msf2hsg(q.trk_size_msf, 1);
1414                         /*
1415                          * Pre-gap has index number of 0, and decreasing MSF
1416                          * address.  Must be converted to negative LBA, per
1417                          * SCSI spec.
1418                          */
1419                         if (data.what.position.index_number == 0)
1420                                 lba = -lba;
1421                         data.what.position.reladdr.lba = htonl(lba);
1422                         data.what.position.absaddr.lba = htonl(msf2hsg(q.hd_pos_msf, 0));
1423                         break;
1424                 }
1425                 break;
1426         }
1427
1428         if (nocopyout == 0)
1429                 return copyout(&data, sch->data, min(sizeof(struct cd_sub_channel_info), sch->data_len));
1430         bcopy(&data, sch->data, min(sizeof(struct cd_sub_channel_info), sch->data_len));
1431         return (0);
1432 }
1433
1434 static int
1435 mcd_playmsf(struct mcd_softc *sc, struct ioc_play_msf *p)
1436 {
1437         struct mcd_read2 pb;
1438
1439         if (sc->data.debug)
1440                 device_printf(sc->dev, "playmsf: from %d:%d.%d to %d:%d.%d\n",
1441                     p->start_m, p->start_s, p->start_f,
1442                     p->end_m, p->end_s, p->end_f);
1443
1444         if ((p->start_m * 60 * 75 + p->start_s * 75 + p->start_f) >=
1445             (p->end_m * 60 * 75 + p->end_s * 75 + p->end_f) ||
1446             (p->end_m * 60 * 75 + p->end_s * 75 + p->end_f) >
1447             M_msf(sc->data.volinfo.vol_msf) * 60 * 75 +
1448             S_msf(sc->data.volinfo.vol_msf) * 75 +
1449             F_msf(sc->data.volinfo.vol_msf))
1450                 return (EINVAL);
1451
1452         pb.start_msf[0] = bin2bcd(p->start_m);
1453         pb.start_msf[1] = bin2bcd(p->start_s);
1454         pb.start_msf[2] = bin2bcd(p->start_f);
1455         pb.end_msf[0] = bin2bcd(p->end_m);
1456         pb.end_msf[1] = bin2bcd(p->end_s);
1457         pb.end_msf[2] = bin2bcd(p->end_f);
1458
1459         if (mcd_setmode(sc, MCD_MD_COOKED) != 0)
1460                 return (EIO);
1461
1462         return mcd_play(sc, &pb);
1463 }
1464
1465 static int
1466 mcd_playtracks(struct mcd_softc *sc, struct ioc_play_track *pt)
1467 {
1468         struct mcd_read2 pb;
1469         int a = pt->start_track;
1470         int z = pt->end_track;
1471         int rc, i;
1472
1473         if ((rc = mcd_read_toc(sc)) != 0)
1474                 return (rc);
1475
1476         if (sc->data.debug)
1477                 device_printf(sc->dev, "playtracks from %d:%d to %d:%d\n",
1478                         a, pt->start_index, z, pt->end_index);
1479
1480         if (   a < bcd2bin(sc->data.volinfo.trk_low)
1481             || a > bcd2bin(sc->data.volinfo.trk_high)
1482             || a > z
1483             || z < bcd2bin(sc->data.volinfo.trk_low)
1484             || z > bcd2bin(sc->data.volinfo.trk_high))
1485                 return (EINVAL);
1486
1487         for (i = 0; i < 3; i++) {
1488                 pb.start_msf[i] = sc->data.toc[a].hd_pos_msf[i];
1489                 pb.end_msf[i] = sc->data.toc[z+1].hd_pos_msf[i];
1490         }
1491
1492         if (mcd_setmode(sc, MCD_MD_COOKED) != 0)
1493                 return (EIO);
1494
1495         return mcd_play(sc, &pb);
1496 }
1497
1498 static int
1499 mcd_playblocks(struct mcd_softc *sc, struct ioc_play_blocks *p)
1500 {
1501         struct mcd_read2 pb;
1502
1503         if (sc->data.debug)
1504                 device_printf(sc->dev, "playblocks: blkno %d length %d\n",
1505                     p->blk, p->len);
1506
1507         if (p->blk > sc->data.disksize || p->len > sc->data.disksize ||
1508             p->blk < 0 || p->len < 0 ||
1509             (p->blk + p->len) > sc->data.disksize)
1510                 return (EINVAL);
1511
1512         hsg2msf(p->blk, pb.start_msf);
1513         hsg2msf(p->blk + p->len, pb.end_msf);
1514
1515         if (mcd_setmode(sc, MCD_MD_COOKED) != 0)
1516                 return (EIO);
1517
1518         return mcd_play(sc, &pb);
1519 }
1520
1521 static int
1522 mcd_play(struct mcd_softc *sc, struct mcd_read2 *pb)
1523 {
1524         int retry, st = -1, status;
1525
1526         sc->data.lastpb = *pb;
1527         for(retry=0; retry<MCD_RETRYS; retry++) {
1528
1529                 critical_enter();
1530                 MCD_WRITE(sc, MCD_REG_COMMAND, MCD_CMDSINGLESPEEDREAD);
1531                 MCD_WRITE(sc, MCD_REG_COMMAND, pb->start_msf[0]);
1532                 MCD_WRITE(sc, MCD_REG_COMMAND, pb->start_msf[1]);
1533                 MCD_WRITE(sc, MCD_REG_COMMAND, pb->start_msf[2]);
1534                 MCD_WRITE(sc, MCD_REG_COMMAND, pb->end_msf[0]);
1535                 MCD_WRITE(sc, MCD_REG_COMMAND, pb->end_msf[1]);
1536                 MCD_WRITE(sc, MCD_REG_COMMAND, pb->end_msf[2]);
1537                 critical_exit();
1538
1539                 status=mcd_getstat(sc, 0);
1540                 if (status == -1)
1541                         continue;
1542                 else if (status != -2)
1543                         st = 0;
1544                 break;
1545         }
1546
1547         if (status == -2) {
1548                 device_printf(sc->dev, "media changed\n");
1549                 return (ENXIO);
1550         }
1551         if (sc->data.debug)
1552                 device_printf(sc->dev,
1553                         "mcd_play retry=%d, status=0x%02x\n", retry, status);
1554         if (st < 0)
1555                 return (ENXIO);
1556         sc->data.audio_status = CD_AS_PLAY_IN_PROGRESS;
1557         return (0);
1558 }
1559
1560 static int
1561 mcd_pause(struct mcd_softc *sc)
1562 {
1563         struct mcd_qchninfo q;
1564         int rc;
1565
1566         /* Verify current status */
1567         if (sc->data.audio_status != CD_AS_PLAY_IN_PROGRESS &&
1568             sc->data.audio_status != CD_AS_PLAY_PAUSED) {
1569                 if (sc->data.debug)
1570                         device_printf(sc->dev,
1571                                 "pause attempted when not playing, audio status %d\n",
1572                                 sc->data.audio_status);
1573                 return (EINVAL);
1574         }
1575
1576         /* Get the current position */
1577         if (mcd_getqchan(sc, &q) < 0)
1578                 return (EIO);
1579
1580         /* Copy it into lastpb */
1581         sc->data.lastpb.start_msf[0] = q.hd_pos_msf[0];
1582         sc->data.lastpb.start_msf[1] = q.hd_pos_msf[1];
1583         sc->data.lastpb.start_msf[2] = q.hd_pos_msf[2];
1584
1585         /* Stop playing */
1586         if ((rc=mcd_stop(sc)) != 0)
1587                 return (rc);
1588
1589         /* Set the proper status and exit */
1590         sc->data.audio_status = CD_AS_PLAY_PAUSED;
1591         return (0);
1592 }
1593
1594 static int
1595 mcd_resume(struct mcd_softc *sc)
1596 {
1597
1598         if (sc->data.audio_status != CD_AS_PLAY_PAUSED)
1599                 return (EINVAL);
1600         return mcd_play(sc, &sc->data.lastpb);
1601 }