1 /* $NetBSD: fd.c,v 1.53 2005/12/24 23:23:59 perry Exp $ */ 2 3 /* 4 * Copyright (c) 1995 Leo Weppelman. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Leo Weppelman. 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * This file contains a driver for the Floppy Disk Controller (FDC) 35 * on the Atari TT. It uses the WD 1772 chip, modified for steprates. 36 * 37 * The ST floppy disk controller shares the access to the DMA circuitry 38 * with other devices. For this reason the floppy disk controller makes 39 * use of some special DMA accessing code. 40 * 41 * Interrupts from the FDC are in fact DMA interrupts which get their 42 * first level handling in 'dma.c' . If the floppy driver is currently 43 * using DMA the interrupt is signalled to 'fdcint'. 44 * 45 * TODO: 46 * - Test it with 2 drives (I don't have them) 47 * - Test it with an HD-drive (Don't have that either) 48 * - Finish ioctl's 49 */ 50 51 #include <sys/cdefs.h> 52 __KERNEL_RCSID(0, "$NetBSD: fd.c,v 1.53 2005/12/24 23:23:59 perry Exp $"); 53 54 #include <sys/param.h> 55 #include <sys/systm.h> 56 #include <sys/callout.h> 57 #include <sys/kernel.h> 58 #include <sys/malloc.h> 59 #include <sys/buf.h> 60 #include <sys/bufq.h> 61 #include <sys/proc.h> 62 #include <sys/device.h> 63 #include <sys/ioctl.h> 64 #include <sys/fcntl.h> 65 #include <sys/conf.h> 66 #include <sys/disklabel.h> 67 #include <sys/disk.h> 68 #include <sys/dkbad.h> 69 #include <atari/atari/device.h> 70 #include <atari/atari/stalloc.h> 71 #include <machine/disklabel.h> 72 #include <machine/iomap.h> 73 #include <machine/mfp.h> 74 #include <machine/dma.h> 75 #include <machine/video.h> 76 #include <machine/cpu.h> 77 #include <atari/dev/ym2149reg.h> 78 #include <atari/dev/fdreg.h> 79 80 /* 81 * Be verbose for debugging 82 */ 83 /*#define FLP_DEBUG 1 */ 84 85 #define FDC_MAX_DMA_AD 0x1000000 /* No DMA possible beyond */ 86 87 /* Parameters for the disk drive. */ 88 #define SECTOR_SIZE 512 /* physical sector size in bytes */ 89 #define NR_DRIVES 2 /* maximum number of drives */ 90 #define NR_TYPES 3 /* number of diskette/drive combinations*/ 91 #define MAX_ERRORS 10 /* how often to try rd/wt before quitting*/ 92 #define STEP_DELAY 6000 /* 6ms (6000us) delay after stepping */ 93 94 95 #define INV_TRK 32000 /* Should fit in unsigned short */ 96 #define INV_PART NR_TYPES 97 98 /* 99 * Driver states 100 */ 101 #define FLP_IDLE 0x00 /* floppy is idle */ 102 #define FLP_MON 0x01 /* idle with motor on */ 103 #define FLP_STAT 0x02 /* determine floppy status */ 104 #define FLP_XFER 0x04 /* read/write data from floppy */ 105 106 /* 107 * Timer delay's 108 */ 109 #define FLP_MONDELAY (3 * hz) /* motor-on delay */ 110 #define FLP_XFERDELAY (2 * hz) /* timeout on transfer */ 111 112 /* 113 * The density codes 114 */ 115 #define FLP_DD 0 /* Double density */ 116 #define FLP_HD 1 /* High density */ 117 118 119 #define b_block b_resid /* FIXME: this is not the place */ 120 121 /* 122 * Global data for all physical floppy devices 123 */ 124 static short selected = 0; /* drive/head currently selected*/ 125 static short motoron = 0; /* motor is spinning */ 126 static short nopens = 0; /* Number of opens executed */ 127 128 static short fd_state = FLP_IDLE; /* Current driver state */ 129 static int lock_stat= 0; /* DMA locking status */ 130 static short fd_cmd = 0; /* command being executed */ 131 static const char *fd_error= NULL; /* error from fd_xfer_ok() */ 132 133 /* 134 * Private per device data 135 */ 136 struct fd_softc { 137 struct device sc_dv; /* generic device info */ 138 struct disk dkdev; /* generic disk info */ 139 struct bufq_state *bufq; /* queue of buf's */ 140 struct callout sc_motor_ch; 141 int unit; /* unit for atari controlling hw*/ 142 int nheads; /* number of heads in use */ 143 int nsectors; /* number of sectors/track */ 144 int density; /* density code */ 145 int nblocks; /* number of blocks on disk */ 146 int curtrk; /* track head positioned on */ 147 short flags; /* misc flags */ 148 short part; /* Current open partition */ 149 int sector; /* logical sector for I/O */ 150 caddr_t io_data; /* KVA for data transfer */ 151 int io_bytes; /* bytes left for I/O */ 152 int io_dir; /* B_READ/B_WRITE */ 153 int errcnt; /* current error count */ 154 u_char *bounceb; /* Bounce buffer */ 155 156 }; 157 158 /* 159 * Flags in fd_softc: 160 */ 161 #define FLPF_NOTRESP 0x001 /* Unit not responding */ 162 #define FLPF_ISOPEN 0x002 /* Unit is open */ 163 #define FLPF_SPARE 0x004 /* Not used */ 164 #define FLPF_HAVELAB 0x008 /* We have a valid label */ 165 #define FLPF_BOUNCE 0x010 /* Now using the bounce buffer */ 166 #define FLPF_WRTPROT 0x020 /* Unit is write-protected */ 167 #define FLPF_EMPTY 0x040 /* Unit is empty */ 168 #define FLPF_INOPEN 0x080 /* Currently being opened */ 169 #define FLPF_GETSTAT 0x100 /* Getting unit status */ 170 171 struct fd_types { 172 int nheads; /* Heads in use */ 173 int nsectors; /* sectors per track */ 174 int nblocks; /* number of blocks */ 175 int density; /* density code */ 176 const char *descr; /* type description */ 177 } fdtypes[NR_TYPES] = { 178 { 1, 9, 720 , FLP_DD , "360KB" }, /* 360 Kb */ 179 { 2, 9, 1440 , FLP_DD , "720KB" }, /* 720 Kb */ 180 { 2, 18, 2880 , FLP_HD , "1.44MB" }, /* 1.44 Mb */ 181 }; 182 183 #define FLP_TYPE_360 0 /* XXX: Please keep these in */ 184 #define FLP_TYPE_720 1 /* sync with the numbering in */ 185 #define FLP_TYPE_144 2 /* 'fdtypes' right above! */ 186 187 /* 188 * This is set only once at attach time. The value is determined by reading 189 * the configuration switches and is one of the FLP_TYPE_*'s. 190 * This is simular to the way Atari handles the _FLP cookie. 191 */ 192 static short def_type = 0; /* Reflects config-switches */ 193 194 #define FLP_DEFTYPE 1 /* 720Kb, reasonable default */ 195 #define FLP_TYPE(dev) ( DISKPART(dev) == 0 ? def_type : DISKPART(dev) - 1 ) 196 197 typedef void (*FPV) __P((void *)); 198 199 dev_type_open(fdopen); 200 dev_type_close(fdclose); 201 dev_type_read(fdread); 202 dev_type_write(fdwrite); 203 dev_type_ioctl(fdioctl); 204 dev_type_strategy(fdstrategy); 205 206 /* 207 * Private drive functions.... 208 */ 209 static void fdstart __P((struct fd_softc *)); 210 static void fddone __P((struct fd_softc *)); 211 static void fdstatus __P((struct fd_softc *)); 212 static void fd_xfer __P((struct fd_softc *)); 213 static void fdcint __P((struct fd_softc *)); 214 static int fd_xfer_ok __P((struct fd_softc *)); 215 static void fdmotoroff __P((struct fd_softc *)); 216 static void fdminphys __P((struct buf *)); 217 static void fdtestdrv __P((struct fd_softc *)); 218 static void fdgetdefaultlabel __P((struct fd_softc *, struct disklabel *, 219 int)); 220 static int fdgetdisklabel __P((struct fd_softc *, dev_t)); 221 static int fdselect __P((int, int, int)); 222 static void fddeselect __P((void)); 223 static void fdmoff __P((struct fd_softc *)); 224 u_char read_fdreg __P((u_short)); 225 void write_fdreg __P((u_short, u_short)); 226 u_char read_dmastat __P((void)); 227 228 extern inline u_char read_fdreg(u_short regno) 229 { 230 DMA->dma_mode = regno; 231 return(DMA->dma_data); 232 } 233 234 extern inline void write_fdreg(u_short regno, u_short val) 235 { 236 DMA->dma_mode = regno; 237 DMA->dma_data = val; 238 } 239 240 extern inline u_char read_dmastat(void) 241 { 242 DMA->dma_mode = FDC_CS | DMA_SCREG; 243 return(DMA->dma_stat); 244 } 245 246 /* 247 * Config switch stuff. Used only for the floppy type for now. That's 248 * why it's here... 249 * XXX: If needed in more places, it should be moved to it's own include file. 250 * Note: This location _must_ be read as an u_short. Failure to do so 251 * will return garbage! 252 */ 253 static u_short rd_cfg_switch __P((void)); 254 static u_short rd_cfg_switch(void) 255 { 256 return(*((u_short*)AD_CFG_SWITCH)); 257 } 258 259 /* 260 * Switch definitions. 261 * Note: ON reads as a zero bit! 262 */ 263 #define CFG_SWITCH_NOHD 0x4000 264 265 /* 266 * Autoconfig stuff.... 267 */ 268 extern struct cfdriver fd_cd; 269 270 static int fdcmatch __P((struct device *, struct cfdata *, void *)); 271 static int fdcprint __P((void *, const char *)); 272 static void fdcattach __P((struct device *, struct device *, void *)); 273 274 CFATTACH_DECL(fdc, sizeof(struct device), 275 fdcmatch, fdcattach, NULL, NULL); 276 277 const struct bdevsw fd_bdevsw = { 278 fdopen, fdclose, fdstrategy, fdioctl, nodump, nosize, D_DISK 279 }; 280 281 const struct cdevsw fd_cdevsw = { 282 fdopen, fdclose, fdread, fdwrite, fdioctl, 283 nostop, notty, nopoll, nommap, nokqfilter, D_DISK 284 }; 285 286 static int 287 fdcmatch(pdp, cfp, auxp) 288 struct device *pdp; 289 struct cfdata *cfp; 290 void *auxp; 291 { 292 static int fdc_matched = 0; 293 294 /* Match only once */ 295 if(strcmp("fdc", auxp) || fdc_matched) 296 return(0); 297 fdc_matched = 1; 298 return(1); 299 } 300 301 static void 302 fdcattach(pdp, dp, auxp) 303 struct device *pdp, *dp; 304 void *auxp; 305 { 306 struct fd_softc fdsoftc; 307 int i, nfound, first_found; 308 309 nfound = first_found = 0; 310 printf("\n"); 311 fddeselect(); 312 for(i = 0; i < NR_DRIVES; i++) { 313 314 /* 315 * Test if unit is present 316 */ 317 fdsoftc.unit = i; 318 fdsoftc.flags = 0; 319 st_dmagrab((dma_farg)fdcint, (dma_farg)fdtestdrv, &fdsoftc, 320 &lock_stat, 0); 321 st_dmafree(&fdsoftc, &lock_stat); 322 323 if(!(fdsoftc.flags & FLPF_NOTRESP)) { 324 if(!nfound) 325 first_found = i; 326 nfound++; 327 config_found(dp, (void*)i, fdcprint); 328 } 329 } 330 331 if(nfound) { 332 struct fd_softc *fdsc = getsoftc(fd_cd, first_found); 333 334 /* 335 * Make sure motor will be turned of when a floppy is 336 * inserted in the first selected drive. 337 */ 338 fdselect(first_found, 0, FLP_DD); 339 fd_state = FLP_MON; 340 callout_reset(&fdsc->sc_motor_ch, 0, (FPV)fdmotoroff, fdsc); 341 342 /* 343 * enable disk related interrupts 344 */ 345 MFP->mf_ierb |= IB_DINT; 346 MFP->mf_iprb = (u_int8_t)~IB_DINT; 347 MFP->mf_imrb |= IB_DINT; 348 } 349 } 350 351 static int 352 fdcprint(auxp, pnp) 353 void *auxp; 354 const char *pnp; 355 { 356 if (pnp != NULL) 357 aprint_normal("fd%d at %s:", (int)auxp, pnp); 358 359 return(UNCONF); 360 } 361 362 static int fdmatch __P((struct device *, struct cfdata *, void *)); 363 static void fdattach __P((struct device *, struct device *, void *)); 364 365 struct dkdriver fddkdriver = { fdstrategy }; 366 367 CFATTACH_DECL(fd, sizeof(struct fd_softc), 368 fdmatch, fdattach, NULL, NULL); 369 370 extern struct cfdriver fd_cd; 371 372 static int 373 fdmatch(pdp, cfp, auxp) 374 struct device *pdp; 375 struct cfdata *cfp; 376 void *auxp; 377 { 378 return(1); 379 } 380 381 static void 382 fdattach(pdp, dp, auxp) 383 struct device *pdp, *dp; 384 void *auxp; 385 { 386 struct fd_softc *sc; 387 struct fd_types *type; 388 u_short swtch; 389 390 sc = (struct fd_softc *)dp; 391 392 callout_init(&sc->sc_motor_ch); 393 394 /* 395 * Find out if an Ajax chip might be installed. Set the default 396 * floppy type accordingly. 397 */ 398 swtch = rd_cfg_switch(); 399 def_type = (swtch & CFG_SWITCH_NOHD) ? FLP_TYPE_720 : FLP_TYPE_144; 400 type = &fdtypes[def_type]; 401 402 printf(": %s %d cyl, %d head, %d sec\n", type->descr, 403 type->nblocks / (type->nsectors * type->nheads), type->nheads, 404 type->nsectors); 405 406 /* 407 * Initialize and attach the disk structure. 408 */ 409 sc->dkdev.dk_name = sc->sc_dv.dv_xname; 410 sc->dkdev.dk_driver = &fddkdriver; 411 disk_attach(&sc->dkdev); 412 } 413 414 int 415 fdioctl(dev, cmd, addr, flag, l) 416 dev_t dev; 417 u_long cmd; 418 int flag; 419 caddr_t addr; 420 struct lwp *l; 421 { 422 struct fd_softc *sc; 423 424 sc = getsoftc(fd_cd, DISKUNIT(dev)); 425 426 if((sc->flags & FLPF_HAVELAB) == 0) 427 return(EBADF); 428 429 switch(cmd) { 430 case DIOCSBAD: 431 return(EINVAL); 432 case DIOCGDINFO: 433 *(struct disklabel *)addr = *(sc->dkdev.dk_label); 434 return(0); 435 case DIOCGPART: 436 ((struct partinfo *)addr)->disklab = 437 sc->dkdev.dk_label; 438 ((struct partinfo *)addr)->part = 439 &sc->dkdev.dk_label->d_partitions[RAW_PART]; 440 return(0); 441 #ifdef notyet /* XXX LWP */ 442 case DIOCSRETRIES: 443 case DIOCSSTEP: 444 case DIOCSDINFO: 445 case DIOCWDINFO: 446 case DIOCWLABEL: 447 break; 448 #endif /* notyet */ 449 case DIOCGDEFLABEL: 450 fdgetdefaultlabel(sc, (struct disklabel *)addr, 451 RAW_PART); 452 return(0); 453 } 454 return(ENOTTY); 455 } 456 457 /* 458 * Open the device. If this is the first open on both the floppy devices, 459 * intialize the controller. 460 * Note that partition info on the floppy device is used to distinguise 461 * between 780Kb and 360Kb floppy's. 462 * partition 0: 360Kb 463 * partition 1: 780Kb 464 */ 465 int 466 fdopen(dev, flags, devtype, l) 467 dev_t dev; 468 int flags, devtype; 469 struct lwp *l; 470 { 471 struct fd_softc *sc; 472 int sps; 473 474 #ifdef FLP_DEBUG 475 printf("fdopen dev=0x%x\n", dev); 476 #endif 477 478 if(FLP_TYPE(dev) >= NR_TYPES) 479 return(ENXIO); 480 481 if((sc = getsoftc(fd_cd, DISKUNIT(dev))) == NULL) 482 return(ENXIO); 483 484 /* 485 * If no floppy currently open, reset the controller and select 486 * floppy type. 487 */ 488 if(!nopens) { 489 490 #ifdef FLP_DEBUG 491 printf("fdopen device not yet open\n"); 492 #endif 493 nopens++; 494 write_fdreg(FDC_CS, IRUPT); 495 delay(40); 496 } 497 498 /* 499 * Sleep while other process is opening the device 500 */ 501 sps = splbio(); 502 while(sc->flags & FLPF_INOPEN) 503 tsleep((caddr_t)sc, PRIBIO, "fdopen", 0); 504 splx(sps); 505 506 if(!(sc->flags & FLPF_ISOPEN)) { 507 /* 508 * Initialise some driver values. 509 */ 510 int type; 511 void *addr; 512 513 type = FLP_TYPE(dev); 514 515 bufq_alloc(&sc->bufq, "disksort", BUFQ_SORT_RAWBLOCK); 516 sc->unit = DISKUNIT(dev); 517 sc->part = RAW_PART; 518 sc->nheads = fdtypes[type].nheads; 519 sc->nsectors = fdtypes[type].nsectors; 520 sc->nblocks = fdtypes[type].nblocks; 521 sc->density = fdtypes[type].density; 522 sc->curtrk = INV_TRK; 523 sc->sector = 0; 524 sc->errcnt = 0; 525 sc->bounceb = (u_char*)alloc_stmem(SECTOR_SIZE, &addr); 526 if(sc->bounceb == NULL) 527 return(ENOMEM); /* XXX */ 528 529 /* 530 * Go get write protect + loaded status 531 */ 532 sc->flags |= FLPF_INOPEN|FLPF_GETSTAT; 533 sps = splbio(); 534 st_dmagrab((dma_farg)fdcint, (dma_farg)fdstatus, sc, 535 &lock_stat, 0); 536 while(sc->flags & FLPF_GETSTAT) 537 tsleep((caddr_t)sc, PRIBIO, "fdopen", 0); 538 splx(sps); 539 wakeup((caddr_t)sc); 540 541 if((sc->flags & FLPF_WRTPROT) && (flags & FWRITE)) { 542 sc->flags = 0; 543 return(EPERM); 544 } 545 if(sc->flags & FLPF_EMPTY) { 546 sc->flags = 0; 547 return(ENXIO); 548 } 549 sc->flags &= ~(FLPF_INOPEN|FLPF_GETSTAT); 550 sc->flags |= FLPF_ISOPEN; 551 } 552 else { 553 /* 554 * Multiply opens are granted when accessing the same type of 555 * floppy (eq. the same partition). 556 */ 557 if(sc->density != fdtypes[DISKPART(dev)].density) 558 return(ENXIO); /* XXX temporarely out of business */ 559 } 560 fdgetdisklabel(sc, dev); 561 #ifdef FLP_DEBUG 562 printf("fdopen open succeeded on type %d\n", sc->part); 563 #endif 564 return (0); 565 } 566 567 int 568 fdclose(dev, flags, devtype, l) 569 dev_t dev; 570 int flags, devtype; 571 struct lwp *l; 572 { 573 struct fd_softc *sc; 574 575 sc = getsoftc(fd_cd, DISKUNIT(dev)); 576 free_stmem(sc->bounceb); 577 sc->flags = 0; 578 nopens--; 579 580 #ifdef FLP_DEBUG 581 printf("Closed floppy device -- nopens: %d\n", nopens); 582 #endif 583 return(0); 584 } 585 586 void 587 fdstrategy(bp) 588 struct buf *bp; 589 { 590 struct fd_softc *sc; 591 struct disklabel *lp; 592 int sps, sz; 593 594 sc = getsoftc(fd_cd, DISKUNIT(bp->b_dev)); 595 596 #ifdef FLP_DEBUG 597 printf("fdstrategy: %p, b_bcount: %ld\n", bp, bp->b_bcount); 598 #endif 599 600 /* 601 * check for valid partition and bounds 602 */ 603 lp = sc->dkdev.dk_label; 604 if ((sc->flags & FLPF_HAVELAB) == 0) { 605 bp->b_error = EIO; 606 goto bad; 607 } 608 if (bp->b_blkno < 0 || (bp->b_bcount % SECTOR_SIZE)) { 609 bp->b_error = EINVAL; 610 goto bad; 611 } 612 if (bp->b_bcount == 0) 613 goto done; 614 615 sz = howmany(bp->b_bcount, SECTOR_SIZE); 616 617 if (bp->b_blkno + sz > sc->nblocks) { 618 sz = sc->nblocks - bp->b_blkno; 619 if (sz == 0) /* Exactly at EndOfDisk */ 620 goto done; 621 if (sz < 0) { /* Past EndOfDisk */ 622 bp->b_error = EINVAL; 623 goto bad; 624 } 625 /* Trucate it */ 626 if (bp->b_flags & B_RAW) 627 bp->b_bcount = sz << DEV_BSHIFT; 628 else bp->b_bcount = sz * lp->d_secsize; 629 } 630 631 /* No partition translation. */ 632 bp->b_rawblkno = bp->b_blkno; 633 634 /* 635 * queue the buf and kick the low level code 636 */ 637 sps = splbio(); 638 BUFQ_PUT(sc->bufq, bp); /* XXX disksort_cylinder */ 639 if (!lock_stat) { 640 if (fd_state & FLP_MON) 641 callout_stop(&sc->sc_motor_ch); 642 fd_state = FLP_IDLE; 643 st_dmagrab((dma_farg)fdcint, (dma_farg)fdstart, sc, 644 &lock_stat, 0); 645 } 646 splx(sps); 647 648 return; 649 bad: 650 bp->b_flags |= B_ERROR; 651 done: 652 bp->b_resid = bp->b_bcount; 653 biodone(bp); 654 } 655 656 int 657 fdread(dev, uio, flags) 658 dev_t dev; 659 struct uio *uio; 660 int flags; 661 { 662 return(physio(fdstrategy, NULL, dev, B_READ, fdminphys, uio)); 663 } 664 665 int 666 fdwrite(dev, uio, flags) 667 dev_t dev; 668 struct uio *uio; 669 int flags; 670 { 671 return(physio(fdstrategy, NULL, dev, B_WRITE, fdminphys, uio)); 672 } 673 674 /* 675 * Called through DMA-dispatcher, get status. 676 */ 677 static void 678 fdstatus(sc) 679 struct fd_softc *sc; 680 { 681 #ifdef FLP_DEBUG 682 printf("fdstatus\n"); 683 #endif 684 sc->errcnt = 0; 685 fd_state = FLP_STAT; 686 fd_xfer(sc); 687 } 688 689 /* 690 * Called through the DMA-dispatcher. So we know we are the only ones 691 * messing with the floppy-controller. 692 * Initialize some fields in the fdsoftc for the state-machine and get 693 * it going. 694 */ 695 static void 696 fdstart(sc) 697 struct fd_softc *sc; 698 { 699 struct buf *bp; 700 701 bp = BUFQ_PEEK(sc->bufq); 702 sc->sector = bp->b_blkno; /* Start sector for I/O */ 703 sc->io_data = bp->b_data; /* KVA base for I/O */ 704 sc->io_bytes = bp->b_bcount; /* Transfer size in bytes */ 705 sc->io_dir = bp->b_flags & B_READ;/* Direction of transfer */ 706 sc->errcnt = 0; /* No errors yet */ 707 fd_state = FLP_XFER; /* Yes, we're going to transfer */ 708 709 /* Instrumentation. */ 710 disk_busy(&sc->dkdev); 711 712 fd_xfer(sc); 713 } 714 715 /* 716 * The current transaction is finished (for good or bad). Let go of 717 * the DMA-resources. Call biodone() to finish the transaction. 718 * Find a new transaction to work on. 719 */ 720 static void 721 fddone(sc) 722 register struct fd_softc *sc; 723 { 724 struct buf *bp; 725 struct fd_softc *sc1; 726 int i, sps; 727 728 /* 729 * Give others a chance to use the DMA. 730 */ 731 st_dmafree(sc, &lock_stat); 732 733 734 if(fd_state != FLP_STAT) { 735 /* 736 * Finish current transaction. 737 */ 738 sps = splbio(); 739 bp = BUFQ_GET(sc->bufq); 740 if (bp == NULL) 741 panic("fddone"); 742 splx(sps); 743 744 #ifdef FLP_DEBUG 745 printf("fddone: unit: %d, buf: %p, resid: %d\n",sc->unit,bp, 746 sc->io_bytes); 747 #endif 748 bp->b_resid = sc->io_bytes; 749 750 disk_unbusy(&sc->dkdev, (bp->b_bcount - bp->b_resid), 751 (bp->b_flags & B_READ)); 752 753 biodone(bp); 754 } 755 fd_state = FLP_MON; 756 757 if(lock_stat) 758 return; /* XXX Is this possible? */ 759 760 /* 761 * Find a new transaction on round-robin basis. 762 */ 763 for(i = sc->unit + 1; ;i++) { 764 if(i >= fd_cd.cd_ndevs) 765 i = 0; 766 if((sc1 = fd_cd.cd_devs[i]) == NULL) 767 continue; 768 if (BUFQ_PEEK(sc1->bufq) != NULL) 769 break; 770 if(i == sc->unit) { 771 callout_reset(&sc->sc_motor_ch, FLP_MONDELAY, 772 (FPV)fdmotoroff, sc); 773 #ifdef FLP_DEBUG 774 printf("fddone: Nothing to do\n"); 775 #endif 776 return; /* No work */ 777 } 778 } 779 fd_state = FLP_IDLE; 780 #ifdef FLP_DEBUG 781 printf("fddone: Staring job on unit %d\n", sc1->unit); 782 #endif 783 st_dmagrab((dma_farg)fdcint, (dma_farg)fdstart, sc1, &lock_stat, 0); 784 } 785 786 static int 787 fdselect(drive, head, dense) 788 int drive, head, dense; 789 { 790 int i, spinning; 791 #ifdef FLP_DEBUG 792 printf("fdselect: drive=%d, head=%d, dense=%d\n", drive, head, dense); 793 #endif 794 i = ((drive == 1) ? PA_FLOP1 : PA_FLOP0) | head; 795 spinning = motoron; 796 motoron = 1; 797 798 switch(dense) { 799 case FLP_DD: 800 DMA->dma_drvmode = 0; 801 break; 802 case FLP_HD: 803 DMA->dma_drvmode = (FDC_HDSET|FDC_HDSIG); 804 break; 805 default: 806 panic("fdselect: unknown density code"); 807 } 808 if(i != selected) { 809 selected = i; 810 ym2149_fd_select((i ^ PA_FDSEL)); 811 } 812 return(spinning); 813 } 814 815 static void 816 fddeselect() 817 { 818 ym2149_fd_select(PA_FDSEL); 819 motoron = selected = 0; 820 DMA->dma_drvmode = 0; 821 } 822 823 /**************************************************************************** 824 * The following functions assume to be running as a result of a * 825 * disk-interrupt (e.q. spl = splbio). * 826 * They form the finit-state machine, the actual driver. * 827 * * 828 * fdstart()/ --> fd_xfer() -> activate hardware * 829 * fdopen() ^ * 830 * | * 831 * +-- not ready -<------------+ * 832 * | * 833 * fdmotoroff()/ --> fdcint() -> fd_xfer_ok() ---+ * 834 * h/w interrupt | * 835 * \|/ * 836 * finished ---> fdone() * 837 * * 838 ****************************************************************************/ 839 static void 840 fd_xfer(sc) 841 struct fd_softc *sc; 842 { 843 register int head; 844 register int track, sector, hbit; 845 u_long phys_addr; 846 847 head = track = 0; 848 switch(fd_state) { 849 case FLP_XFER: 850 /* 851 * Calculate head/track values 852 */ 853 track = sc->sector / sc->nsectors; 854 head = track % sc->nheads; 855 track = track / sc->nheads; 856 #ifdef FLP_DEBUG 857 printf("fd_xfer: sector:%d,head:%d,track:%d\n", sc->sector,head, 858 track); 859 #endif 860 break; 861 862 case FLP_STAT: 863 /* 864 * FLP_STAT only wants to recalibrate 865 */ 866 sc->curtrk = INV_TRK; 867 break; 868 default: 869 panic("fd_xfer: wrong state (0x%x)", fd_state); 870 } 871 872 /* 873 * Select the drive. 874 */ 875 hbit = fdselect(sc->unit, head, sc->density) ? HBIT : 0; 876 877 if(sc->curtrk == INV_TRK) { 878 /* 879 * Recalibrate, since we lost track of head positioning. 880 * The floppy disk controller has no way of determining its 881 * absolute arm position (track). Instead, it steps the 882 * arm a track at a time and keeps track of where it 883 * thinks it is (in software). However, after a SEEK, the 884 * hardware reads information from the diskette telling 885 * where the arm actually is. If the arm is in the wrong place, 886 * a recalibration is done, which forces the arm to track 0. 887 * This way the controller can get back into sync with reality. 888 */ 889 fd_cmd = RESTORE; 890 write_fdreg(FDC_CS, RESTORE|VBIT|hbit); 891 callout_reset(&sc->sc_motor_ch, FLP_XFERDELAY, 892 (FPV)fdmotoroff, sc); 893 894 #ifdef FLP_DEBUG 895 printf("fd_xfer:Recalibrating drive %d\n", sc->unit); 896 #endif 897 return; 898 } 899 900 write_fdreg(FDC_TR, sc->curtrk); 901 902 /* 903 * Issue a SEEK command on the indicated drive unless the arm is 904 * already positioned on the correct track. 905 */ 906 if(track != sc->curtrk) { 907 sc->curtrk = track; /* be optimistic */ 908 write_fdreg(FDC_DR, track); 909 write_fdreg(FDC_CS, SEEK|RATE6|VBIT|hbit); 910 callout_reset(&sc->sc_motor_ch, FLP_XFERDELAY, 911 (FPV)fdmotoroff, sc); 912 fd_cmd = SEEK; 913 #ifdef FLP_DEBUG 914 printf("fd_xfer:Seek to track %d on drive %d\n",track,sc->unit); 915 #endif 916 return; 917 } 918 919 /* 920 * The drive is now on the proper track. Read or write 1 block. 921 */ 922 sector = sc->sector % sc->nsectors; 923 sector++; /* start numbering at 1 */ 924 925 write_fdreg(FDC_SR, sector); 926 927 phys_addr = (u_long)kvtop(sc->io_data); 928 if(phys_addr >= FDC_MAX_DMA_AD) { 929 /* 930 * We _must_ bounce this address 931 */ 932 phys_addr = (u_long)kvtop(sc->bounceb); 933 if(sc->io_dir == B_WRITE) 934 bcopy(sc->io_data, sc->bounceb, SECTOR_SIZE); 935 sc->flags |= FLPF_BOUNCE; 936 } 937 st_dmaaddr_set((caddr_t)phys_addr); /* DMA address setup */ 938 939 #ifdef FLP_DEBUG 940 printf("fd_xfer:Start io (io_addr:%lx)\n", (u_long)kvtop(sc->io_data)); 941 #endif 942 943 if(sc->io_dir == B_READ) { 944 /* Issue the command */ 945 st_dmacomm(DMA_FDC | DMA_SCREG, 1); 946 write_fdreg(FDC_CS, F_READ|hbit); 947 fd_cmd = F_READ; 948 } 949 else { 950 /* Issue the command */ 951 st_dmacomm(DMA_WRBIT | DMA_FDC | DMA_SCREG, 1); 952 write_fdreg(DMA_WRBIT | FDC_CS, F_WRITE|hbit|EBIT|PBIT); 953 fd_cmd = F_WRITE; 954 } 955 callout_reset(&sc->sc_motor_ch, FLP_XFERDELAY, (FPV)fdmotoroff, sc); 956 } 957 958 /* return values of fd_xfer_ok(): */ 959 #define X_OK 0 960 #define X_AGAIN 1 961 #define X_ERROR 2 962 #define X_FAIL 3 963 964 /* 965 * Hardware interrupt function. 966 */ 967 static void 968 fdcint(sc) 969 struct fd_softc *sc; 970 { 971 struct buf *bp; 972 973 #ifdef FLP_DEBUG 974 printf("fdcint: unit = %d\n", sc->unit); 975 #endif 976 977 /* 978 * Cancel timeout (we made it, didn't we) 979 */ 980 callout_stop(&sc->sc_motor_ch); 981 982 switch(fd_xfer_ok(sc)) { 983 case X_ERROR : 984 if(++(sc->errcnt) < MAX_ERRORS) { 985 /* 986 * Command failed but still retries left. 987 */ 988 break; 989 } 990 /* FALL THROUGH */ 991 case X_FAIL : 992 /* 993 * Non recoverable error. Fall back to motor-on 994 * idle-state. 995 */ 996 if(fd_error != NULL) { 997 printf("Floppy error: %s\n", fd_error); 998 fd_error = NULL; 999 } 1000 1001 if(fd_state == FLP_STAT) { 1002 sc->flags |= FLPF_EMPTY; 1003 sc->flags &= ~FLPF_GETSTAT; 1004 wakeup((caddr_t)sc); 1005 fddone(sc); 1006 return; 1007 } 1008 1009 bp = BUFQ_PEEK(sc->bufq); 1010 1011 bp->b_error = EIO; 1012 bp->b_flags |= B_ERROR; 1013 fd_state = FLP_MON; 1014 1015 break; 1016 case X_AGAIN: 1017 /* 1018 * Start next part of state machine. 1019 */ 1020 break; 1021 case X_OK: 1022 /* 1023 * Command ok and finished. Reset error-counter. 1024 * If there are no more bytes to transfer fall back 1025 * to motor-on idle state. 1026 */ 1027 sc->errcnt = 0; 1028 1029 if(fd_state == FLP_STAT) { 1030 sc->flags &= ~FLPF_GETSTAT; 1031 wakeup((caddr_t)sc); 1032 fddone(sc); 1033 return; 1034 } 1035 1036 if((sc->flags & FLPF_BOUNCE) && (sc->io_dir == B_READ)) 1037 bcopy(sc->bounceb, sc->io_data, SECTOR_SIZE); 1038 sc->flags &= ~FLPF_BOUNCE; 1039 1040 sc->sector++; 1041 sc->io_data += SECTOR_SIZE; 1042 sc->io_bytes -= SECTOR_SIZE; 1043 if(sc->io_bytes <= 0) 1044 fd_state = FLP_MON; 1045 } 1046 if(fd_state == FLP_MON) 1047 fddone(sc); 1048 else fd_xfer(sc); 1049 } 1050 1051 /* 1052 * Determine status of last command. Should only be called through 1053 * 'fdcint()'. 1054 * Returns: 1055 * X_ERROR : Error on command; might succeed next time. 1056 * X_FAIL : Error on command; will never succeed. 1057 * X_AGAIN : Part of a command succeeded, call 'fd_xfer()' to complete. 1058 * X_OK : Command succeeded and is complete. 1059 * 1060 * This function only affects sc->curtrk. 1061 */ 1062 static int 1063 fd_xfer_ok(sc) 1064 register struct fd_softc *sc; 1065 { 1066 register int status; 1067 1068 #ifdef FLP_DEBUG 1069 printf("fd_xfer_ok: cmd: 0x%x, state: 0x%x\n", fd_cmd, fd_state); 1070 #endif 1071 switch(fd_cmd) { 1072 case IRUPT: 1073 /* 1074 * Timeout. Force a recalibrate before we try again. 1075 */ 1076 status = read_fdreg(FDC_CS); 1077 1078 fd_error = "Timeout"; 1079 sc->curtrk = INV_TRK; 1080 return(X_ERROR); 1081 case F_READ: 1082 /* 1083 * Test for DMA error 1084 */ 1085 status = read_dmastat(); 1086 if(!(status & DMAOK)) { 1087 fd_error = "DMA error"; 1088 return(X_ERROR); 1089 } 1090 /* 1091 * Get controller status and check for errors. 1092 */ 1093 status = read_fdreg(FDC_CS); 1094 if(status & (RNF | CRCERR | LD_T00)) { 1095 fd_error = "Read error"; 1096 if(status & RNF) 1097 sc->curtrk = INV_TRK; 1098 return(X_ERROR); 1099 } 1100 break; 1101 case F_WRITE: 1102 /* 1103 * Test for DMA error 1104 */ 1105 status = read_dmastat(); 1106 if(!(status & DMAOK)) { 1107 fd_error = "DMA error"; 1108 return(X_ERROR); 1109 } 1110 /* 1111 * Get controller status and check for errors. 1112 */ 1113 status = read_fdreg(FDC_CS); 1114 if(status & WRI_PRO) { 1115 fd_error = "Write protected"; 1116 return(X_FAIL); 1117 } 1118 if(status & (RNF | CRCERR | LD_T00)) { 1119 fd_error = "Write error"; 1120 sc->curtrk = INV_TRK; 1121 return(X_ERROR); 1122 } 1123 break; 1124 case SEEK: 1125 status = read_fdreg(FDC_CS); 1126 if(status & (RNF | CRCERR)) { 1127 fd_error = "Seek error"; 1128 sc->curtrk = INV_TRK; 1129 return(X_ERROR); 1130 } 1131 return(X_AGAIN); 1132 case RESTORE: 1133 /* 1134 * Determine if the recalibration succeeded. 1135 */ 1136 status = read_fdreg(FDC_CS); 1137 if(status & RNF) { 1138 fd_error = "Recalibrate error"; 1139 /* reset controller */ 1140 write_fdreg(FDC_CS, IRUPT); 1141 sc->curtrk = INV_TRK; 1142 return(X_ERROR); 1143 } 1144 sc->curtrk = 0; 1145 if(fd_state == FLP_STAT) { 1146 if(status & WRI_PRO) 1147 sc->flags |= FLPF_WRTPROT; 1148 break; 1149 } 1150 return(X_AGAIN); 1151 default: 1152 fd_error = "Driver error: fd_xfer_ok : Unknown state"; 1153 return(X_FAIL); 1154 } 1155 return(X_OK); 1156 } 1157 1158 /* 1159 * All timeouts will call this function. 1160 */ 1161 static void 1162 fdmotoroff(sc) 1163 struct fd_softc *sc; 1164 { 1165 int sps; 1166 1167 /* 1168 * Get at harware interrupt level 1169 */ 1170 sps = splbio(); 1171 1172 #if FLP_DEBUG 1173 printf("fdmotoroff, state = 0x%x\n", fd_state); 1174 #endif 1175 1176 switch(fd_state) { 1177 case FLP_STAT : 1178 case FLP_XFER : 1179 /* 1180 * Timeout during a transfer; cancel transaction 1181 * set command to 'IRUPT'. 1182 * A drive-interrupt is simulated to trigger the state 1183 * machine. 1184 */ 1185 /* 1186 * Cancel current transaction 1187 */ 1188 fd_cmd = IRUPT; 1189 write_fdreg(FDC_CS, IRUPT); 1190 delay(20); 1191 (void)read_fdreg(FDC_CS); 1192 write_fdreg(FDC_CS, RESTORE); 1193 break; 1194 1195 case FLP_MON : 1196 /* 1197 * Turn motor off. 1198 */ 1199 if(selected) { 1200 int tmp; 1201 1202 st_dmagrab((dma_farg)fdcint, (dma_farg)fdmoff, 1203 sc, &tmp, 0); 1204 } 1205 else fd_state = FLP_IDLE; 1206 break; 1207 } 1208 splx(sps); 1209 } 1210 1211 /* 1212 * min byte count to whats left of the track in question 1213 */ 1214 static void 1215 fdminphys(bp) 1216 struct buf *bp; 1217 { 1218 struct fd_softc *sc; 1219 int sec, toff, tsz; 1220 1221 if((sc = getsoftc(fd_cd, DISKUNIT(bp->b_dev))) == NULL) 1222 panic("fdminphys: couldn't get softc"); 1223 1224 sec = bp->b_blkno % (sc->nsectors * sc->nheads); 1225 toff = sec * SECTOR_SIZE; 1226 tsz = sc->nsectors * sc->nheads * SECTOR_SIZE; 1227 1228 #ifdef FLP_DEBUG 1229 printf("fdminphys: before %ld", bp->b_bcount); 1230 #endif 1231 1232 bp->b_bcount = min(bp->b_bcount, tsz - toff); 1233 1234 #ifdef FLP_DEBUG 1235 printf(" after %ld\n", bp->b_bcount); 1236 #endif 1237 1238 minphys(bp); 1239 } 1240 1241 /* 1242 * Called from fdmotoroff to turn the motor actually off.... 1243 * This can't be done in fdmotoroff itself, because exclusive access to the 1244 * DMA controller is needed to read the FDC-status register. The function 1245 * 'fdmoff()' always runs as the result of a 'dmagrab()'. 1246 * We need to test the status-register because we want to be sure that the 1247 * drive motor is really off before deselecting the drive. The FDC only 1248 * turns off the drive motor after having seen 10 index-pulses. You only 1249 * get index-pulses when a drive is selected....This means that if the 1250 * drive is deselected when the motor is still spinning, it will continue 1251 * to spin _even_ when you insert a floppy later on... 1252 */ 1253 static void 1254 fdmoff(fdsoftc) 1255 struct fd_softc *fdsoftc; 1256 { 1257 int tmp; 1258 1259 if ((fd_state == FLP_MON) && selected) { 1260 tmp = read_fdreg(FDC_CS); 1261 if (!(tmp & MOTORON)) { 1262 fddeselect(); 1263 fd_state = FLP_IDLE; 1264 } 1265 else 1266 callout_reset(&fdsoftc->sc_motor_ch, 10*FLP_MONDELAY, 1267 (FPV)fdmotoroff, fdsoftc); 1268 } 1269 st_dmafree(fdsoftc, &tmp); 1270 } 1271 1272 /* 1273 * Used to find out wich drives are actually connected. We do this by issuing 1274 * is 'RESTORE' command and check if the 'track-0' bit is set. This also works 1275 * if the drive is present but no floppy is inserted. 1276 */ 1277 static void 1278 fdtestdrv(fdsoftc) 1279 struct fd_softc *fdsoftc; 1280 { 1281 int status; 1282 1283 /* 1284 * Select the right unit and head. 1285 */ 1286 fdselect(fdsoftc->unit, 0, FLP_DD); 1287 1288 write_fdreg(FDC_CS, RESTORE|HBIT); 1289 1290 /* 1291 * Wait for about 2 seconds. 1292 */ 1293 delay(2000000); 1294 1295 status = read_fdreg(FDC_CS); 1296 if(status & (RNF|BUSY)) { 1297 write_fdreg(FDC_CS, IRUPT); /* reset controller */ 1298 delay(40); 1299 } 1300 1301 if(!(status & LD_T00)) 1302 fdsoftc->flags |= FLPF_NOTRESP; 1303 1304 fddeselect(); 1305 } 1306 1307 static void 1308 fdgetdefaultlabel(sc, lp, part) 1309 struct fd_softc *sc; 1310 struct disklabel *lp; 1311 int part; 1312 { 1313 1314 bzero(lp, sizeof(struct disklabel)); 1315 1316 lp->d_secsize = SECTOR_SIZE; 1317 lp->d_ntracks = sc->nheads; 1318 lp->d_nsectors = sc->nsectors; 1319 lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors; 1320 lp->d_ncylinders = sc->nblocks / lp->d_secpercyl; 1321 lp->d_secperunit = sc->nblocks; 1322 1323 lp->d_type = DTYPE_FLOPPY; 1324 lp->d_rpm = 300; /* good guess I suppose. */ 1325 lp->d_interleave = 1; /* FIXME: is this OK? */ 1326 lp->d_bbsize = 0; 1327 lp->d_sbsize = 0; 1328 lp->d_npartitions = part + 1; 1329 lp->d_trkseek = STEP_DELAY; 1330 lp->d_magic = DISKMAGIC; 1331 lp->d_magic2 = DISKMAGIC; 1332 lp->d_checksum = dkcksum(lp); 1333 lp->d_partitions[part].p_size = lp->d_secperunit; 1334 lp->d_partitions[part].p_fstype = FS_UNUSED; 1335 lp->d_partitions[part].p_fsize = 1024; 1336 lp->d_partitions[part].p_frag = 8; 1337 } 1338 1339 /* 1340 * Build disk label. For now we only create a label from what we know 1341 * from 'sc'. 1342 */ 1343 static int 1344 fdgetdisklabel(sc, dev) 1345 struct fd_softc *sc; 1346 dev_t dev; 1347 { 1348 struct disklabel *lp; 1349 int part; 1350 1351 /* 1352 * If we already got one, get out. 1353 */ 1354 if(sc->flags & FLPF_HAVELAB) 1355 return(0); 1356 1357 #ifdef FLP_DEBUG 1358 printf("fdgetdisklabel()\n"); 1359 #endif 1360 1361 part = RAW_PART; 1362 lp = sc->dkdev.dk_label; 1363 fdgetdefaultlabel(sc, lp, part); 1364 sc->flags |= FLPF_HAVELAB; 1365 1366 return(0); 1367 } 1368