mcd.c revision 1.1.2.6
1 /* 2 * Copyright (c) 1993 Charles Hannum. 3 * Copyright 1993 by Holger Veit (data part) 4 * Copyright 1993 by Brian Moore (audio part) 5 * Changes Copyright 1993 by Gary Clark II 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This software was developed by Holger Veit and Brian Moore 19 * for use with "386BSD" and similar operating systems. 20 * "Similar operating systems" includes mainly non-profit oriented 21 * systems for research and education, including but not restricted to 22 * "NetBSD", "FreeBSD", "Mach" (by CMU). 23 * 4. Neither the name of the developer(s) nor the name "386BSD" 24 * may be used to endorse or promote products derived from this 25 * software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE DEVELOPER(S) ``AS IS'' AND ANY 28 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE DEVELOPER(S) BE 31 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 32 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 33 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 34 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 35 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 36 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 37 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 38 * 39 * $Id: mcd.c,v 1.1.2.6 1994/02/02 11:43:54 mycroft Exp $ 40 */ 41 42 /*static char COPYRIGHT[] = "mcd-driver (C)1993 by H.Veit & B.Moore";*/ 43 44 #include "mcd.h" 45 46 #include <sys/types.h> 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/kernel.h> 50 #include <sys/conf.h> 51 #include <sys/file.h> 52 #include <sys/buf.h> 53 #include <sys/stat.h> 54 #include <sys/uio.h> 55 #include <sys/ioctl.h> 56 #include <sys/cdio.h> 57 #include <sys/errno.h> 58 #include <sys/dkbad.h> 59 #include <sys/disklabel.h> 60 #include <sys/device.h> 61 #include <sys/disk.h> 62 63 #include <machine/cpu.h> 64 #include <machine/pio.h> 65 66 #include <i386/isa/isavar.h> 67 #include <i386/isa/icu.h> 68 #include <i386/isa/mcdreg.h> 69 70 #ifndef MCDDEBUG 71 #define MCD_TRACE(fmt,a,b,c,d) 72 #else 73 #define MCD_TRACE(fmt,a,b,c,d) {if (sc->debug) {printf("%s: st=%02x: ", sc->sc_dev.dv_xname, mcd->status); printf(fmt,a,b,c,d);}} 74 #endif 75 76 #define MCDPART(dev) (((minor(dev)) & 0x07) ) 77 #define MCDUNIT(dev) (((minor(dev)) & 0x78) >> 3) 78 #define MCDPHYS(dev) (((minor(dev)) & 0x80) >> 7) 79 #define RAW_PART 3 80 81 /* flags */ 82 #define MCDOPEN 0x0001 /* device opened */ 83 #define MCDVALID 0x0002 /* parameters loaded */ 84 #define MCDINIT 0x0004 /* device is init'd */ 85 #define MCDWAIT 0x0008 /* waiting for something */ 86 #define MCDLABEL 0x0010 /* label is read */ 87 #define MCDREADRAW 0x0020 /* read raw mode (2352 bytes) */ 88 #define MCDVOLINFO 0x0040 /* already read volinfo */ 89 #define MCDTOC 0x0080 /* already read toc */ 90 #define MCDMBXBSY 0x0100 /* local mbx is busy */ 91 92 /* status */ 93 #define MCDAUDIOBSY MCD_ST_AUDIOBSY /* playing audio */ 94 #define MCDDSKCHNG MCD_ST_DSKCHNG /* sensed change of disk */ 95 #define MCDDSKIN MCD_ST_DSKIN /* sensed disk in drive */ 96 #define MCDDOOROPEN MCD_ST_DOOROPEN /* sensed door open */ 97 98 /* toc */ 99 #define MCD_MAXTOCS 104 /* from the Linux driver */ 100 #define MCD_LASTPLUS1 170 /* special toc entry */ 101 102 struct mcd_mbx { 103 short unit; 104 u_short iobase; 105 short retry; 106 short nblk; 107 int sz; 108 u_long skip; 109 struct buf *bp; 110 int p_offset; 111 short count; 112 }; 113 114 struct mcd_softc { 115 struct device sc_dev; 116 struct isadev sc_id; 117 struct intrhand sc_ih; 118 struct dkdevice sc_dk; 119 120 short config; 121 short flags; 122 short status; 123 int blksize; 124 u_long disksize; 125 int iobase; 126 struct disklabel dlabel; 127 int partflags[MAXPARTITIONS]; 128 int openflags; 129 struct mcd_volinfo volinfo; 130 struct mcd_qchninfo toc[MCD_MAXTOCS]; 131 short audio_status; 132 struct mcd_read2 lastpb; 133 short debug; 134 struct buf head; /* head of buf queue */ 135 struct mcd_mbx mbx; 136 }; 137 138 int mcdprobe __P((struct device *, struct device *, void *)); 139 void mcdattach __P((struct device *, struct device *, void *)); 140 141 struct cfdriver mcdcd = 142 { NULL, "mcd", mcdprobe, mcdattach, DV_DISK, sizeof(struct mcd_softc) }; 143 144 void mcdstrategy __P((struct buf *)); 145 146 struct dkdriver mcddkdriver = { mcdstrategy }; 147 148 /* reader state machine */ 149 #define MCD_S_BEGIN 0 150 #define MCD_S_BEGIN1 1 151 #define MCD_S_WAITSTAT 2 152 #define MCD_S_WAITMODE 3 153 #define MCD_S_WAITREAD 4 154 155 int mcdopen __P((dev_t)); 156 int mcdclose __P((dev_t)); 157 static void mcd_start __P((struct mcd_softc *)); 158 int mcdioctl __P((dev_t, int, caddr_t, int)); 159 static int mcd_getdisklabel __P((struct mcd_softc *)); 160 int mcdsize __P((dev_t)); 161 static void mcd_configure __P((struct mcd_softc *)); 162 static int mcd_waitrdy __P((u_short, int)); 163 static int mcd_getreply __P((struct mcd_softc *, int)); 164 static int mcd_getstat __P((struct mcd_softc *, int)); 165 static void mcd_setflags __P((struct mcd_softc *)); 166 static int mcd_get __P((struct mcd_softc *, char *, int)); 167 static int mcd_send __P((struct mcd_softc *, int, int)); 168 static int bcd2bin __P((bcd_t)); 169 static bcd_t bin2bcd __P((int)); 170 static void hsg2msf __P((int, bcd_t *)); 171 static int msf2hsg __P((bcd_t *)); 172 static int mcd_volinfo __P((struct mcd_softc *)); 173 int mcdintr __P((caddr_t)); 174 static void mcd_doread __P((int, struct mcd_mbx *)); 175 static int mcd_setmode __P((struct mcd_softc *, int)); 176 static int mcd_toc_header __P((struct mcd_softc *, struct ioc_toc_header *)); 177 static int mcd_read_toc __P((struct mcd_softc *)); 178 static int mcd_toc_entry __P((struct mcd_softc *, struct ioc_read_toc_entry *)); 179 static int mcd_stop __P((struct mcd_softc *)); 180 static int mcd_getqchan __P((struct mcd_softc *, struct mcd_qchninfo *)); 181 static int mcd_subchan __P((struct mcd_softc *, struct ioc_read_subchannel *)); 182 static int mcd_playtracks __P((struct mcd_softc *, struct ioc_play_track *)); 183 static int mcd_play __P((struct mcd_softc *, struct mcd_read2 *)); 184 static int mcd_pause __P((struct mcd_softc *)); 185 static int mcd_resume __P((struct mcd_softc *)); 186 187 #define mcd_put(port,byte) outb(port,byte) 188 189 #define MCD_RETRIES 5 190 #define MCD_RDRETRIES 8 191 192 #define MCDBLK 2048 /* for cooked mode */ 193 #define MCDRBLK 2352 /* for raw mode */ 194 195 /* several delays */ 196 #define RDELAY_WAITSTAT 300 197 #define RDELAY_WAITMODE 300 198 #define RDELAY_WAITREAD 800 199 200 #define DELAY_STATUS 10000l /* 10000 * 1us */ 201 #define DELAY_GETREPLY 200000l /* 200000 * 2us */ 202 #define DELAY_SEEKREAD 20000l /* 20000 * 1us */ 203 204 void 205 mcdattach(parent, self, aux) 206 struct device *parent, *self; 207 void *aux; 208 { 209 struct isa_attach_args *ia = aux; 210 struct mcd_softc *sc = (void *)self; 211 212 sc->iobase = ia->ia_iobase; 213 sc->flags = MCDINIT; 214 215 #ifdef notyet 216 /* get irq/drq configuration word */ 217 sc->config = irqs[ia->ia_irq]; /* | drqs[ia->ia_drq];*/ 218 /* wire controller for interrupts and dma */ 219 mcd_configure(sc); 220 #endif 221 222 printf(": Mitsumi CD-ROM\n"); 223 224 isa_establish(&sc->sc_id, &sc->sc_dev); 225 sc->sc_ih.ih_fun = mcdintr; 226 sc->sc_ih.ih_arg = sc; 227 intr_establish(ia->ia_irq, &sc->sc_ih, DV_DISK); 228 sc->sc_dk.dk_driver = &mcddkdriver; 229 dk_establish(&sc->sc_dk, &sc->sc_dev); 230 } 231 232 int 233 mcdopen(dev) 234 dev_t dev; 235 { 236 int unit, part, phys; 237 struct mcd_softc *sc; 238 239 unit = MCDUNIT(dev); 240 part = MCDPART(dev); 241 phys = MCDPHYS(dev); 242 243 if (unit >= mcdcd.cd_ndevs) 244 return ENXIO; 245 sc = mcdcd.cd_devs[unit]; 246 if (!sc || !(sc->flags & MCDINIT)) 247 return ENXIO; 248 249 /* invalidated in the meantime? mark all open part's invalid */ 250 if (!(sc->flags & MCDVALID) && sc->openflags) 251 return EBUSY; 252 253 if (mcd_getstat(sc, 1) < 0) 254 return ENXIO; 255 256 /* XXX get a default disklabel */ 257 mcd_getdisklabel(sc); 258 259 if (mcdsize(dev) < 0) { 260 printf("%s: failed to get disk size\n", sc->sc_dev.dv_xname); 261 return ENXIO; 262 } else 263 sc->flags |= MCDVALID; 264 265 MCD_TRACE("open: partition=%d, disksize = %d, blksize=%d\n", 266 part,sc->disksize,sc->blksize,0); 267 268 if (part == RAW_PART || 269 (part < sc->dlabel.d_npartitions && 270 sc->dlabel.d_partitions[part].p_fstype != FS_UNUSED)) { 271 sc->partflags[part] |= MCDOPEN; 272 sc->openflags |= (1<<part); 273 if (part == RAW_PART && phys != 0) 274 sc->partflags[part] |= MCDREADRAW; 275 return 0; 276 } 277 278 return ENXIO; 279 } 280 281 int 282 mcdclose(dev) 283 dev_t dev; 284 { 285 int unit, part; 286 struct mcd_softc *sc; 287 288 unit = MCDUNIT(dev); 289 part = MCDPART(dev); 290 sc = mcdcd.cd_devs[unit]; 291 292 mcd_getstat(sc, 1); /* get status */ 293 294 /* close channel */ 295 sc->partflags[part] &= ~(MCDOPEN|MCDREADRAW); 296 sc->openflags &= ~(1<<part); 297 MCD_TRACE("close: partition=%d\n", part, 0, 0, 0); 298 299 return 0; 300 } 301 302 void 303 mcdstrategy(bp) 304 struct buf *bp; 305 { 306 struct mcd_softc *sc; 307 struct buf *qp; 308 int s; 309 310 sc = mcdcd.cd_devs[MCDUNIT(bp->b_dev)]; 311 312 /* test validity */ 313 /*MCD_TRACE("strategy: buf=0x%lx, unit=%ld, block#=%ld bcount=%ld\n", 314 bp, sc->sc_dev.dv_unit, bp->b_blkno, bp->b_bcount);*/ 315 if (bp->b_blkno < 0) { 316 printf("mcdstrategy: unit = %d, blkno = %d, bcount = %d\n", 317 sc->sc_dev.dv_unit, bp->b_blkno, bp->b_bcount); 318 bp->b_error = EINVAL; 319 bp->b_flags |= B_ERROR; 320 goto bad; 321 } 322 323 /* if device invalidated (e.g. media change, door open), error */ 324 if (!(sc->flags & MCDVALID)) { 325 MCD_TRACE("strategy: drive not valid\n",0,0,0,0); 326 bp->b_error = EIO; 327 goto bad; 328 } 329 330 /* read only */ 331 if (!(bp->b_flags & B_READ)) { 332 bp->b_error = EROFS; 333 goto bad; 334 } 335 336 /* no data to read */ 337 if (bp->b_bcount == 0) 338 goto done; 339 340 /* for non raw access, check partition limits */ 341 if (MCDPART(bp->b_dev) != RAW_PART) { 342 if (!(sc->flags & MCDLABEL)) { 343 bp->b_error = EIO; 344 goto bad; 345 } 346 /* adjust transfer if necessary */ 347 if (bounds_check_with_label(bp,&sc->dlabel,1) <= 0) { 348 goto done; 349 } 350 } 351 352 /* queue it */ 353 qp = &sc->head; 354 s = splbio(); 355 disksort(qp,bp); 356 splx(s); 357 358 /* now check whether we can perform processing */ 359 mcd_start(sc); 360 return; 361 362 bad: 363 bp->b_flags |= B_ERROR; 364 done: 365 bp->b_resid = bp->b_bcount; 366 biodone(bp); 367 return; 368 } 369 370 static void 371 mcd_start(sc) 372 struct mcd_softc *sc; 373 { 374 struct buf *bp, *qp = &sc->head; 375 struct partition *p; 376 int s = splbio(); 377 378 if (sc->flags & MCDMBXBSY) 379 return; 380 381 if ((bp = qp->b_actf) != 0) { 382 /* block found to process, dequeue */ 383 MCD_TRACE("mcd_start: found block bp=0x%x\n", bp, 0, 0, 0); 384 qp->b_actf = bp->av_forw; 385 splx(s); 386 } else { 387 /* nothing to do */ 388 splx(s); 389 return; 390 } 391 392 /* changed media? */ 393 if (!(sc->flags & MCDVALID)) { 394 MCD_TRACE("mcd_start: drive not valid\n", 0, 0, 0, 0); 395 return; 396 } 397 398 p = &sc->sc_dk.dk_label.d_partitions[MCDPART(bp->b_dev)]; 399 400 sc->flags |= MCDMBXBSY; 401 sc->mbx.unit = sc->sc_dev.dv_unit; 402 sc->mbx.iobase = sc->iobase; 403 sc->mbx.retry = MCD_RETRIES; 404 sc->mbx.bp = bp; 405 sc->mbx.p_offset = p->p_offset; 406 407 /* calling the read routine */ 408 mcd_doread(MCD_S_BEGIN, &sc->mbx); 409 } 410 411 int 412 mcdioctl(dev, cmd, addr, flags) 413 dev_t dev; 414 int cmd; 415 caddr_t addr; 416 int flags; 417 { 418 struct mcd_softc *sc; 419 int unit; 420 421 unit = MCDUNIT(dev); 422 sc = mcdcd.cd_devs[unit]; 423 424 if (!(sc->flags & MCDVALID)) 425 return EIO; 426 MCD_TRACE("ioctl called 0x%x\n", cmd, 0, 0, 0); 427 428 switch (cmd) { 429 case DIOCSBAD: 430 return EINVAL; 431 case DIOCGDINFO: 432 case DIOCGPART: 433 case DIOCWDINFO: 434 case DIOCSDINFO: 435 case DIOCWLABEL: 436 return ENOTTY; 437 case CDIOCPLAYTRACKS: 438 return mcd_playtracks(sc, (struct ioc_play_track *) addr); 439 case CDIOCPLAYBLOCKS: 440 return mcd_play(sc, (struct mcd_read2 *) addr); 441 case CDIOCREADSUBCHANNEL: 442 return mcd_subchan(sc, (struct ioc_read_subchannel *) addr); 443 case CDIOREADTOCHEADER: 444 return mcd_toc_header(sc, (struct ioc_toc_header *) addr); 445 case CDIOREADTOCENTRYS: 446 return mcd_toc_entry(sc, (struct ioc_read_toc_entry *) addr); 447 case CDIOCSETPATCH: 448 case CDIOCGETVOL: 449 case CDIOCSETVOL: 450 case CDIOCSETMONO: 451 case CDIOCSETSTERIO: 452 case CDIOCSETMUTE: 453 case CDIOCSETLEFT: 454 case CDIOCSETRIGHT: 455 return EINVAL; 456 case CDIOCRESUME: 457 return mcd_resume(sc); 458 case CDIOCPAUSE: 459 return mcd_pause(sc); 460 case CDIOCSTART: 461 return EINVAL; 462 case CDIOCSTOP: 463 return mcd_stop(sc); 464 case CDIOCEJECT: 465 return EINVAL; 466 case CDIOCSETDEBUG: 467 sc->debug = 1; 468 return 0; 469 case CDIOCCLRDEBUG: 470 sc->debug = 0; 471 return 0; 472 case CDIOCRESET: 473 return EINVAL; 474 default: 475 return ENOTTY; 476 } 477 #ifdef DIAGNOSTIC 478 panic("mcdioctl: impossible"); 479 #endif 480 } 481 482 /* this could have been taken from scsi/cd.c, but it is not clear 483 * whether the scsi cd driver is linked in 484 */ 485 static int 486 mcd_getdisklabel(sc) 487 struct mcd_softc *sc; 488 { 489 490 if (sc->flags & MCDLABEL) 491 return -1; 492 493 bzero(&sc->sc_dk.dk_label, sizeof(struct disklabel)); 494 bzero(&sc->sc_dk.dk_cpulabel, sizeof(struct cpu_disklabel)); 495 strncpy(sc->sc_dk.dk_label.d_typename, "Mitsumi CD ROM ", 16); 496 strncpy(sc->sc_dk.dk_label.d_packname, "unknown ", 16); 497 sc->sc_dk.dk_label.d_secsize = sc->blksize; 498 sc->sc_dk.dk_label.d_nsectors = 100; 499 sc->sc_dk.dk_label.d_ntracks = 1; 500 sc->sc_dk.dk_label.d_ncylinders = (sc->disksize/100)+1; 501 sc->sc_dk.dk_label.d_secpercyl = 100; 502 sc->sc_dk.dk_label.d_secperunit = sc->disksize; 503 sc->sc_dk.dk_label.d_rpm = 300; 504 sc->sc_dk.dk_label.d_interleave = 1; 505 sc->sc_dk.dk_label.d_flags = D_REMOVABLE; 506 sc->sc_dk.dk_label.d_npartitions= 1; 507 sc->sc_dk.dk_label.d_partitions[0].p_offset = 0; 508 sc->sc_dk.dk_label.d_partitions[0].p_size = sc->disksize; 509 sc->sc_dk.dk_label.d_partitions[0].p_fstype = 9; 510 sc->sc_dk.dk_label.d_magic = DISKMAGIC; 511 sc->sc_dk.dk_label.d_magic2 = DISKMAGIC; 512 sc->sc_dk.dk_label.d_checksum = dkcksum(&sc->sc_dk.dk_label); 513 514 sc->flags |= MCDLABEL; 515 return 0; 516 } 517 518 int 519 mcdsize(dev) 520 dev_t dev; 521 { 522 int size; 523 int unit = MCDUNIT(dev); 524 struct mcd_softc *sc = mcdcd.cd_devs[unit]; 525 526 if (mcd_volinfo(sc) >= 0) { 527 sc->blksize = MCDBLK; 528 size = msf2hsg(sc->volinfo.vol_msf); 529 sc->disksize = size * (MCDBLK/DEV_BSIZE); 530 return 0; 531 } 532 return -1; 533 } 534 535 /*************************************************************** 536 * lower level of driver starts here 537 **************************************************************/ 538 539 #ifdef notyet 540 static char irqs[] = { 541 0x00,0x00,0x10,0x20,0x00,0x30,0x00,0x00, 542 0x00,0x10,0x40,0x50,0x00,0x00,0x00,0x00 543 }; 544 545 static char drqs[] = { 546 0x00,0x01,0x00,0x03,0x00,0x05,0x06,0x07, 547 }; 548 #endif 549 550 static void 551 mcd_configure(sc) 552 struct mcd_softc *sc; 553 { 554 555 outb(sc->iobase + mcd_config, sc->config); 556 } 557 558 int 559 mcdprobe(parent, self, aux) 560 struct device *parent, *self; 561 void *aux; 562 { 563 struct isa_attach_args *ia = aux; 564 struct mcd_softc *sc = (void *)self; 565 u_short iobase = ia->ia_iobase; 566 int i, j; 567 u_char st, check, junk; 568 569 if (iobase == IOBASEUNK) 570 return 0; 571 572 /* send a reset */ 573 outb(iobase + MCD_FLAGS, 0); 574 delay(3000); 575 576 for (j = 3; j; j--) { /* XXX why the loop? */ 577 578 /* get any pending garbage (old data) and throw away...*/ 579 for (i = 10; i; i--) 580 inb(iobase + MCD_DATA); 581 582 delay(2000); 583 outb(iobase + MCD_DATA, MCD_CMDCONTINFO); 584 for (i = 30000; i; i--) { 585 if ((inb(iobase + MCD_FLAGS) & M_STATUS_AVAIL) == M_STATUS_AVAIL) { /* XXX looks bogus */ 586 delay(600); 587 st = inb(iobase + MCD_DATA); 588 delay(500); 589 check = inb(iobase + MCD_DATA); 590 delay(500); 591 junk = inb(iobase + MCD_DATA); /* XXX what is this? */ 592 593 if (check == 'M') 594 goto found; 595 else 596 return 0; 597 break; 598 } 599 } 600 } 601 return 0; 602 603 found: 604 /* XXXX check irq and drq */ 605 printf("mcd%d: config register says %x\n", sc->sc_dev.dv_unit, 606 inb(iobase + mcd_config)); 607 608 ia->ia_iosize = 4; 609 ia->ia_msize = 0; 610 return 1; 611 } 612 613 static int 614 mcd_waitrdy(iobase, dly) 615 u_short iobase; 616 int dly; 617 { 618 int i; 619 620 /* wait until xfer port senses data ready */ 621 for (i = dly; i; i--) { 622 if ((inb(iobase + mcd_xfer) & MCD_ST_BUSY) == 0) 623 return 0; 624 delay(1); 625 } 626 return -1; 627 } 628 629 static int 630 mcd_getreply(sc, dly) 631 struct mcd_softc *sc; 632 int dly; 633 { 634 u_short iobase = sc->iobase; 635 636 /* wait data to become ready */ 637 if (mcd_waitrdy(iobase, dly)<0) { 638 printf("%s: timeout getreply\n", sc->sc_dev.dv_xname); 639 return -1; 640 } 641 642 /* get the data */ 643 return inb(iobase + mcd_status) & 0xff; 644 } 645 646 static int 647 mcd_getstat(sc, sflg) 648 struct mcd_softc *sc; 649 int sflg; 650 { 651 int i; 652 u_short iobase = sc->iobase; 653 654 /* get the status */ 655 if (sflg) 656 outb(iobase + mcd_command, MCD_CMDGETSTAT); 657 i = mcd_getreply(sc, DELAY_GETREPLY); 658 if (i < 0) 659 return -1; 660 661 sc->status = i; 662 663 mcd_setflags(sc); 664 return sc->status; 665 } 666 667 static void 668 mcd_setflags(sc) 669 struct mcd_softc *sc; 670 { 671 672 /* check flags */ 673 if (sc->status & (MCDDSKCHNG|MCDDOOROPEN)) { 674 MCD_TRACE("getstat: sensed DSKCHNG or DOOROPEN\n", 0, 0, 0, 0); 675 sc->flags &= ~MCDVALID; 676 } 677 678 if (sc->status & MCDAUDIOBSY) 679 sc->audio_status = CD_AS_PLAY_IN_PROGRESS; 680 else if (sc->audio_status == CD_AS_PLAY_IN_PROGRESS) 681 sc->audio_status = CD_AS_PLAY_COMPLETED; 682 } 683 684 static int 685 mcd_get(sc, buf, nmax) 686 struct mcd_softc *sc; 687 char *buf; 688 int nmax; 689 { 690 int i, k; 691 692 for (i = 0; i < nmax; i++) { 693 /* wait for data */ 694 if ((k = mcd_getreply(sc, DELAY_GETREPLY)) < 0) { 695 printf("%s: timeout mcd_get\n", sc->sc_dev.dv_xname); 696 return -1; 697 } 698 buf[i] = k; 699 } 700 return i; 701 } 702 703 static int 704 mcd_send(sc, cmd, nretries) 705 struct mcd_softc *sc; 706 int cmd, nretries; 707 { 708 int i, k; 709 u_short iobase = sc->iobase; 710 711 /*MCD_TRACE("mcd_send: command = 0x%x\n",cmd,0,0,0);*/ 712 for (i = nretries; i; i--) { 713 outb(iobase + mcd_command, cmd); 714 if ((k = mcd_getstat(sc, 0)) != -1) 715 break; 716 } 717 if (!i) { 718 printf("%s: mcd_send retry cnt exceeded\n", 719 sc->sc_dev.dv_xname); 720 return -1; 721 } 722 723 /*MCD_TRACE("mcd_send: status = 0x%x\n",k,0,0,0);*/ 724 return 0; 725 } 726 727 static int 728 bcd2bin(b) 729 bcd_t b; 730 { 731 732 return (b >> 4) * 10 + (b & 15); 733 } 734 735 static bcd_t 736 bin2bcd(b) 737 int b; 738 { 739 740 return ((b / 10) << 4) | (b % 10); 741 } 742 743 static void 744 hsg2msf(hsg, msf) 745 int hsg; 746 bcd_t *msf; 747 { 748 749 hsg += 150; 750 M_msf(msf) = bin2bcd(hsg / 4500); 751 hsg %= 4500; 752 S_msf(msf) = bin2bcd(hsg / 75); 753 F_msf(msf) = bin2bcd(hsg % 75); 754 } 755 756 static int 757 msf2hsg(msf) 758 bcd_t *msf; 759 { 760 761 return (bcd2bin(M_msf(msf)) * 60 + 762 bcd2bin(S_msf(msf))) * 75 + 763 bcd2bin(F_msf(msf)) - 150; 764 } 765 766 static int 767 mcd_volinfo(sc) 768 struct mcd_softc *sc; 769 { 770 771 /*MCD_TRACE("mcd_volinfo: enter\n",0,0,0,0);*/ 772 773 /* Get the status, in case the disc has been changed */ 774 if (mcd_getstat(sc, 1) < 0) 775 return EIO; 776 777 /* Just return if we already have it */ 778 if (sc->flags & MCDVOLINFO) 779 return 0; 780 781 /* send volume info command */ 782 if (mcd_send(sc, MCD_CMDGETVOLINFO, MCD_RETRIES) < 0) 783 return -1; 784 785 /* get data */ 786 if (mcd_get(sc, (char*) &sc->volinfo, sizeof(struct mcd_volinfo)) < 0) { 787 printf("%s: mcd_volinfo: error read data\n", 788 sc->sc_dev.dv_xname); 789 return -1; 790 } 791 792 if (sc->volinfo.trk_low != 0 || sc->volinfo.trk_high != 0) { 793 sc->flags |= MCDVOLINFO; /* volinfo is OK */ 794 return 0; 795 } 796 797 return -1; 798 } 799 800 int 801 mcdintr(arg) 802 caddr_t arg; 803 { 804 struct mcd_softc *sc = (void *)arg; 805 u_short iobase = sc->iobase; 806 807 MCD_TRACE("stray interrupt xfer=0x%x\n", inb(iobase + mcd_xfer), 808 0, 0, 0); 809 810 /* just read out status and ignore the rest */ 811 if ((inb(iobase + mcd_xfer) & 0xff) != 0xff) 812 (void) inb(iobase + mcd_status); 813 } 814 815 /* state machine to process read requests 816 * initialize with MCD_S_BEGIN: calculate sizes, and read status 817 * MCD_S_WAITSTAT: wait for status reply, set mode 818 * MCD_S_WAITMODE: waits for status reply from set mode, set read command 819 * MCD_S_WAITREAD: wait for read ready, read data 820 */ 821 static struct mcd_mbx *mbxsave; 822 823 static void 824 mcd_doread(state, mbxin) 825 int state; 826 struct mcd_mbx *mbxin; 827 { 828 struct mcd_mbx *mbx = (state != MCD_S_BEGIN) ? mbxsave : mbxin; 829 struct mcd_softc *sc = mcdcd.cd_devs[mbx->unit]; 830 u_short iobase = mbx->iobase; 831 struct buf *bp = mbx->bp; 832 833 int rm, i, k; 834 struct mcd_read2 rbuf; 835 int blkno; 836 caddr_t addr; 837 838 loop: 839 switch (state) { 840 case MCD_S_BEGIN: 841 mbx = mbxsave = mbxin; 842 843 case MCD_S_BEGIN1: 844 /* get status */ 845 outb(iobase + mcd_command, MCD_CMDGETSTAT); 846 mbx->count = RDELAY_WAITSTAT; 847 timeout((timeout_t) mcd_doread, (caddr_t) MCD_S_WAITSTAT, 848 hz/100); 849 return; 850 851 case MCD_S_WAITSTAT: 852 untimeout((timeout_t) mcd_doread, (caddr_t) MCD_S_WAITSTAT); 853 if (mbx->count-- >= 0) { 854 if (inb(iobase + mcd_xfer) & MCD_ST_BUSY) { 855 timeout((timeout_t) mcd_doread, 856 (caddr_t) MCD_S_WAITSTAT, hz/100); 857 return; 858 } 859 mcd_setflags(sc); 860 MCD_TRACE("got WAITSTAT delay=%d\n", 861 RDELAY_WAITSTAT-mbx->count, 0, 0, 0); 862 /* reject, if audio active */ 863 if (sc->status & MCDAUDIOBSY) { 864 printf("%s: audio is active\n", 865 sc->sc_dev.dv_xname); 866 goto readerr; 867 } 868 869 /* to check for raw/cooked mode */ 870 if (sc->flags & MCDREADRAW) { 871 rm = MCD_MD_RAW; 872 mbx->sz = MCDRBLK; 873 } else { 874 rm = MCD_MD_COOKED; 875 mbx->sz = sc->blksize; 876 } 877 878 mbx->count = RDELAY_WAITMODE; 879 880 mcd_put(iobase + mcd_command, MCD_CMDSETMODE); 881 mcd_put(iobase + mcd_command, rm); 882 timeout((timeout_t) mcd_doread, 883 (caddr_t) MCD_S_WAITMODE, hz/100); 884 return; 885 } else { 886 printf("%s: timeout getstatus\n", sc->sc_dev.dv_xname); 887 goto readerr; 888 } 889 890 case MCD_S_WAITMODE: 891 untimeout((timeout_t) mcd_doread, (caddr_t) MCD_S_WAITMODE); 892 if (mbx->count-- < 0) { 893 printf("%s: timeout set mode\n", sc->sc_dev.dv_xname); 894 goto readerr; 895 } 896 if (inb(iobase + mcd_xfer) & MCD_ST_BUSY) { 897 timeout((timeout_t) mcd_doread, 898 (caddr_t) MCD_S_WAITMODE, hz/100); 899 return; 900 } 901 mcd_setflags(sc); 902 MCD_TRACE("got WAITMODE delay=%d\n", 903 RDELAY_WAITMODE-mbx->count, 0, 0, 0); 904 /* for first block */ 905 mbx->nblk = (bp->b_bcount + (mbx->sz-1)) / mbx->sz; 906 mbx->skip = 0; 907 908 nextblock: 909 blkno = (bp->b_blkno / (mbx->sz/DEV_BSIZE)) 910 + mbx->p_offset + mbx->skip/mbx->sz; 911 912 MCD_TRACE("mcd_doread: read blkno=%d for bp=0x%x\n", 913 blkno, bp, 0, 0); 914 915 /* build parameter block */ 916 hsg2msf(blkno, rbuf.start_msf); 917 918 /* send the read command */ 919 mcd_put(iobase + mcd_command,MCD_CMDREAD2); 920 mcd_put(iobase + mcd_command,rbuf.start_msf[0]); 921 mcd_put(iobase + mcd_command,rbuf.start_msf[1]); 922 mcd_put(iobase + mcd_command,rbuf.start_msf[2]); 923 mcd_put(iobase + mcd_command,0); 924 mcd_put(iobase + mcd_command,0); 925 mcd_put(iobase + mcd_command,1); 926 mbx->count = RDELAY_WAITREAD; 927 timeout((timeout_t) mcd_doread, (caddr_t) MCD_S_WAITREAD, 928 hz/100); 929 return; 930 931 case MCD_S_WAITREAD: 932 untimeout((timeout_t) mcd_doread, (caddr_t) MCD_S_WAITREAD); 933 if (mbx->count-- > 0) { 934 k = inb(iobase + mcd_xfer); 935 if ((k & 2)==0) { 936 MCD_TRACE("got data delay=%d\n", 937 RDELAY_WAITREAD-mbx->count, 0, 0, 0); 938 /* data is ready */ 939 addr = bp->b_un.b_addr + mbx->skip; 940 outb(iobase + mcd_ctl2,0x04); /* XXX */ 941 for (i=0; i<mbx->sz; i++) 942 *addr++ = inb(iobase + mcd_rdata); 943 outb(iobase + mcd_ctl2,0x0c); /* XXX */ 944 945 if (--mbx->nblk > 0) { 946 mbx->skip += mbx->sz; 947 goto nextblock; 948 } 949 950 /* return buffer */ 951 bp->b_resid = 0; 952 biodone(bp); 953 954 sc->flags &= ~MCDMBXBSY; 955 mcd_start(sc); 956 return; 957 } 958 if ((k & 4) == 0) 959 mcd_getstat(sc, 0); 960 timeout((timeout_t) mcd_doread, 961 (caddr_t) MCD_S_WAITREAD, hz/100); 962 return; 963 } else { 964 printf("%s: timeout read data\n", sc->sc_dev.dv_xname); 965 goto readerr; 966 } 967 } 968 969 readerr: 970 if (mbx->retry-- > 0) { 971 printf("%s: retrying\n", sc->sc_dev.dv_xname); 972 state = MCD_S_BEGIN1; 973 goto loop; 974 } 975 976 /* invalidate the buffer */ 977 bp->b_flags |= B_ERROR; 978 bp->b_resid = bp->b_bcount; 979 biodone(bp); 980 mcd_start(sc); 981 982 #ifdef notdef 983 printf("%s: unit timeout, resetting\n", sc->sc_dev.dv_xname); 984 outb(mbx->iobase + mcd_reset,MCD_CMDRESET); 985 delay(300000); 986 (void)mcd_getstat(sc, 1); 987 (void)mcd_getstat(sc, 1); 988 /*sc->status &= ~MCDDSKCHNG; */ 989 sc->debug = 1; /* preventive set debug mode */ 990 #endif 991 } 992 993 static int 994 mcd_setmode(sc, mode) 995 struct mcd_softc *sc; 996 int mode; 997 { 998 u_short iobase = sc->iobase; 999 int retry; 1000 1001 printf("%s: setting mode to %d\n", sc->sc_dev.dv_xname, mode); 1002 for(retry = MCD_RETRIES; retry; retry--) { 1003 outb(iobase + mcd_command, MCD_CMDSETMODE); 1004 outb(iobase + mcd_command, mode); 1005 if (mcd_getstat(sc, 0) != -1) 1006 return 0; 1007 } 1008 1009 return -1; 1010 } 1011 1012 static int 1013 mcd_toc_header(sc, th) 1014 struct mcd_softc *sc; 1015 struct ioc_toc_header *th; 1016 { 1017 1018 if (mcd_volinfo(sc) < 0) 1019 return ENXIO; 1020 1021 th->len = msf2hsg(sc->volinfo.vol_msf); 1022 th->starting_track = bcd2bin(sc->volinfo.trk_low); 1023 th->ending_track = bcd2bin(sc->volinfo.trk_high); 1024 1025 return 0; 1026 } 1027 1028 static int 1029 mcd_read_toc(sc) 1030 struct mcd_softc *sc; 1031 { 1032 struct ioc_toc_header th; 1033 struct mcd_qchninfo q; 1034 int rc, trk, idx, retry; 1035 1036 /* Only read TOC if needed */ 1037 if (sc->flags & MCDTOC) 1038 return 0; 1039 1040 printf("%s: reading toc header\n", sc->sc_dev.dv_xname); 1041 if (mcd_toc_header(sc, &th) != 0) 1042 return ENXIO; 1043 1044 printf("%s: stopping play\n", sc->sc_dev.dv_xname); 1045 if ((rc = mcd_stop(sc)) != 0) 1046 return rc; 1047 1048 /* try setting the mode twice */ 1049 if (mcd_setmode(sc, MCD_MD_TOC) != 0) 1050 return EIO; 1051 if (mcd_setmode(sc, MCD_MD_TOC) != 0) 1052 return EIO; 1053 1054 printf("%s: get_toc reading qchannel info\n", sc->sc_dev.dv_xname); 1055 for(trk = th.starting_track; trk <= th.ending_track; trk++) 1056 sc->toc[trk].idx_no = 0; 1057 trk = th.ending_track - th.starting_track + 1; 1058 for(retry = 300; retry && trk > 0; retry--) { 1059 if (mcd_getqchan(sc, &q) < 0) 1060 break; 1061 idx = bcd2bin(q.idx_no); 1062 if (idx > 0 && idx < MCD_MAXTOCS && q.trk_no==0) 1063 if (sc->toc[idx].idx_no == 0) { 1064 sc->toc[idx] = q; 1065 trk--; 1066 } 1067 } 1068 1069 if (mcd_setmode(sc, MCD_MD_COOKED) != 0) 1070 return EIO; 1071 1072 if (trk != 0) 1073 return ENXIO; 1074 1075 /* add a fake last+1 */ 1076 idx = th.ending_track + 1; 1077 sc->toc[idx].ctrl_adr = sc->toc[idx-1].ctrl_adr; 1078 sc->toc[idx].trk_no = 0; 1079 sc->toc[idx].idx_no = 0xAA; 1080 sc->toc[idx].hd_pos_msf[0] = sc->volinfo.vol_msf[0]; 1081 sc->toc[idx].hd_pos_msf[1] = sc->volinfo.vol_msf[1]; 1082 sc->toc[idx].hd_pos_msf[2] = sc->volinfo.vol_msf[2]; 1083 1084 sc->flags |= MCDTOC; 1085 1086 return 0; 1087 } 1088 1089 static int 1090 mcd_toc_entry(sc, te) 1091 struct mcd_softc *sc; 1092 struct ioc_read_toc_entry *te; 1093 { 1094 struct ret_toc { 1095 struct ioc_toc_header th; 1096 struct cd_toc_entry rt; 1097 } ret_toc; 1098 struct ioc_toc_header th; 1099 int rc, i; 1100 1101 /* Make sure we have a valid toc */ 1102 if ((rc = mcd_read_toc(sc)) != 0) 1103 return rc; 1104 1105 /* find the toc to copy*/ 1106 i = te->starting_track; 1107 if (i == MCD_LASTPLUS1) 1108 i = bcd2bin(sc->volinfo.trk_high) + 1; 1109 1110 /* verify starting track */ 1111 if (i < bcd2bin(sc->volinfo.trk_low) || 1112 i > bcd2bin(sc->volinfo.trk_high) + 1) 1113 return EINVAL; 1114 1115 /* do we have room */ 1116 if (te->data_len < sizeof(struct ioc_toc_header) + 1117 sizeof(struct cd_toc_entry)) 1118 return EINVAL; 1119 1120 /* Copy the toc header */ 1121 if (mcd_toc_header(sc, &th) < 0) 1122 return EIO; 1123 ret_toc.th = th; 1124 1125 /* copy the toc data */ 1126 ret_toc.rt.control = sc->toc[i].ctrl_adr; 1127 ret_toc.rt.addr_type = te->address_format; 1128 ret_toc.rt.track = i; 1129 if (te->address_format == CD_MSF_FORMAT) { 1130 ret_toc.rt.addr[1] = sc->toc[i].hd_pos_msf[0]; 1131 ret_toc.rt.addr[2] = sc->toc[i].hd_pos_msf[1]; 1132 ret_toc.rt.addr[3] = sc->toc[i].hd_pos_msf[2]; 1133 } 1134 1135 /* copy the data back */ 1136 copyout(&ret_toc, te->data, sizeof(struct cd_toc_entry) 1137 + sizeof(struct ioc_toc_header)); 1138 1139 return 0; 1140 } 1141 1142 static int 1143 mcd_stop(sc) 1144 struct mcd_softc *sc; 1145 { 1146 1147 if (mcd_send(sc, MCD_CMDSTOPAUDIO, MCD_RETRIES) < 0) 1148 return ENXIO; 1149 sc->audio_status = CD_AS_PLAY_COMPLETED; 1150 return 0; 1151 } 1152 1153 static int 1154 mcd_getqchan(sc, q) 1155 struct mcd_softc *sc; 1156 struct mcd_qchninfo *q; 1157 { 1158 1159 if (mcd_send(sc, MCD_CMDGETQCHN, MCD_RETRIES) < 0) 1160 return -1; 1161 if (mcd_get(sc, (char *) q, sizeof(struct mcd_qchninfo)) < 0) 1162 return -1; 1163 if (sc->debug) 1164 printf("%s: qchannel ctl=%d, t=%d, i=%d, ttm=%d:%d.%d dtm=%d:%d.%d\n", 1165 sc->sc_dev.dv_xname, q->ctrl_adr, q->trk_no, q->idx_no, 1166 q->trk_size_msf[0], q->trk_size_msf[1], q->trk_size_msf[2], 1167 q->trk_size_msf[0], q->trk_size_msf[1], q->trk_size_msf[2]); 1168 return 0; 1169 } 1170 1171 static int 1172 mcd_subchan(sc, ch) 1173 struct mcd_softc *sc; 1174 struct ioc_read_subchannel *ch; 1175 { 1176 struct mcd_qchninfo q; 1177 struct cd_sub_channel_info data; 1178 1179 printf("%s: subchan af=%d, df=%d\n", sc->sc_dev.dv_xname, 1180 ch->address_format, ch->data_format); 1181 if (ch->address_format != CD_MSF_FORMAT) 1182 return EIO; 1183 if (ch->data_format != CD_CURRENT_POSITION) 1184 return EIO; 1185 1186 if (mcd_getqchan(sc, &q) < 0) 1187 return EIO; 1188 1189 data.header.audio_status = sc->audio_status; 1190 data.what.position.data_format = CD_MSF_FORMAT; 1191 data.what.position.track_number = bcd2bin(q.trk_no); 1192 1193 if (copyout(&data, ch->data, sizeof(struct cd_sub_channel_info)) != 0) 1194 return EFAULT; 1195 return 0; 1196 } 1197 1198 static int 1199 mcd_playtracks(sc, pt) 1200 struct mcd_softc *sc; 1201 struct ioc_play_track *pt; 1202 { 1203 struct mcd_read2 pb; 1204 int a = pt->start_track; 1205 int z = pt->end_track; 1206 int rc; 1207 1208 if ((rc = mcd_read_toc(sc)) != 0) 1209 return rc; 1210 1211 printf("%s: playtracks from %d:%d to %d:%d\n", sc->sc_dev.dv_xname, 1212 a, pt->start_index, z, pt->end_index); 1213 1214 if (a < sc->volinfo.trk_low || a > sc->volinfo.trk_high || a > z || 1215 z < sc->volinfo.trk_low || z > sc->volinfo.trk_high) 1216 return EINVAL; 1217 1218 pb.start_msf[0] = sc->toc[a].hd_pos_msf[0]; 1219 pb.start_msf[1] = sc->toc[a].hd_pos_msf[1]; 1220 pb.start_msf[2] = sc->toc[a].hd_pos_msf[2]; 1221 pb.end_msf[0] = sc->toc[z+1].hd_pos_msf[0]; 1222 pb.end_msf[1] = sc->toc[z+1].hd_pos_msf[1]; 1223 pb.end_msf[2] = sc->toc[z+1].hd_pos_msf[2]; 1224 1225 return mcd_play(sc, &pb); 1226 } 1227 1228 static int 1229 mcd_play(sc, pb) 1230 struct mcd_softc *sc; 1231 struct mcd_read2 *pb; 1232 { 1233 u_short iobase = sc->iobase; 1234 int retry, st; 1235 1236 sc->lastpb = *pb; 1237 for (retry = MCD_RETRIES; retry; retry--) { 1238 outb(iobase + mcd_command, MCD_CMDREAD2); 1239 outb(iobase + mcd_command, pb->start_msf[0]); 1240 outb(iobase + mcd_command, pb->start_msf[1]); 1241 outb(iobase + mcd_command, pb->start_msf[2]); 1242 outb(iobase + mcd_command, pb->end_msf[0]); 1243 outb(iobase + mcd_command, pb->end_msf[1]); 1244 outb(iobase + mcd_command, pb->end_msf[2]); 1245 if ((st = mcd_getstat(sc, 0)) != -1) 1246 break; 1247 } 1248 if (!retry) 1249 return ENXIO; 1250 1251 sc->audio_status = CD_AS_PLAY_IN_PROGRESS; 1252 return 0; 1253 } 1254 1255 static int 1256 mcd_pause(sc) 1257 struct mcd_softc *sc; 1258 { 1259 struct mcd_qchninfo q; 1260 int rc; 1261 1262 /* Verify current status */ 1263 if (sc->audio_status != CD_AS_PLAY_IN_PROGRESS) { 1264 printf("%s: pause attempted when not playing\n", 1265 sc->sc_dev.dv_xname); 1266 return EINVAL; 1267 } 1268 1269 /* Get the current position */ 1270 if (mcd_getqchan(sc, &q) < 0) 1271 return EIO; 1272 1273 /* Copy it into lastpb */ 1274 sc->lastpb.start_msf[0] = q.hd_pos_msf[0]; 1275 sc->lastpb.start_msf[1] = q.hd_pos_msf[1]; 1276 sc->lastpb.start_msf[2] = q.hd_pos_msf[2]; 1277 1278 /* Stop playing */ 1279 if ((rc = mcd_stop(sc)) != 0) 1280 return rc; 1281 1282 /* Set the proper status and exit */ 1283 sc->audio_status = CD_AS_PLAY_PAUSED; 1284 return 0; 1285 } 1286 1287 static int 1288 mcd_resume(sc) 1289 struct mcd_softc *sc; 1290 { 1291 1292 if (sc->audio_status != CD_AS_PLAY_PAUSED) 1293 return EINVAL; 1294 return mcd_play(sc, &sc->lastpb); 1295 } 1296
Indexes created Mon Oct 20 16:09:52 GMT 2025