1 /* 2 * Copyright (c) 1990 The Regents of the University of California. 3 * All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Don Ahn. 7 * 8 * Libretto PCMCIA floppy support by David Horwitt (dhorwitt@ucsd.edu) 9 * aided by the Linux floppy driver modifications from David Bateman 10 * (dbateman@eng.uts.edu.au). 11 * 12 * Copyright (c) 1993, 1994 by 13 * jc@irbs.UUCP (John Capo) 14 * vak@zebub.msk.su (Serge Vakulenko) 15 * ache@astral.msk.su (Andrew A. Chernov) 16 * 17 * Copyright (c) 1993, 1994, 1995 by 18 * joerg_wunsch@uriah.sax.de (Joerg Wunsch) 19 * dufault@hda.com (Peter Dufault) 20 * 21 * Redistribution and use in source and binary forms, with or without 22 * modification, are permitted provided that the following conditions 23 * are met: 24 * 1. Redistributions of source code must retain the above copyright 25 * notice, this list of conditions and the following disclaimer. 26 * 2. Redistributions in binary form must reproduce the above copyright 27 * notice, this list of conditions and the following disclaimer in the 28 * documentation and/or other materials provided with the distribution. 29 * 3. All advertising materials mentioning features or use of this software 30 * must display the following acknowledgement: 31 * This product includes software developed by the University of 32 * California, Berkeley and its contributors. 33 * 4. Neither the name of the University nor the names of its contributors 34 * may be used to endorse or promote products derived from this software 35 * without specific prior written permission. 36 * 37 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 38 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 39 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 40 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 41 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 42 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 43 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 44 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 45 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 46 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 47 * SUCH DAMAGE. 48 * 49 * from: @(#)fd.c 7.4 (Berkeley) 5/25/91 50 * $Id: fd.c,v 1.133 1999/02/10 00:03:32 ken Exp $ 51 * 52 */ 53 54 #include "fd.h" 55 #include "opt_devfs.h" 56 #include "opt_fdc.h" 57 58 #if NFDC > 0 59 60 #include <sys/param.h> 61 #include <sys/systm.h> 62 #include <sys/kernel.h> 63 #include <sys/conf.h> 64 #include <sys/fcntl.h> 65 #include <machine/clock.h> 66 #include <machine/ioctl_fd.h> 67 #include <sys/disklabel.h> 68 #include <sys/buf.h> 69 #include <sys/devicestat.h> 70 #include <sys/malloc.h> 71 #include <sys/proc.h> 72 #include <sys/syslog.h> 73 #include <i386/isa/isa.h> 74 #include <i386/isa/isa_device.h> 75 #include <i386/isa/fdreg.h> 76 #include <i386/isa/fdc.h> 77 #include <i386/isa/rtc.h> 78 #include <machine/stdarg.h> 79 #ifdef DEVFS 80 #include <sys/devfsext.h> 81 #endif /* DEVFS */ 82 83 /* misuse a flag to identify format operation */ 84 #define B_FORMAT B_XXX 85 86 /* configuration flags */ 87 #define FDC_PRETEND_D0 (1 << 0) /* pretend drive 0 to be there */ 88 #ifdef FDC_YE 89 #define FDC_IS_PCMCIA (1 << 1) /* if successful probe, then it's 90 a PCMCIA device */ 91 #endif 92 93 /* internally used only, not really from CMOS: */ 94 #define RTCFDT_144M_PRETENDED 0x1000 95 96 /* 97 * this biotab field doubles as a field for the physical unit number 98 * on the controller 99 */ 100 #define id_physid id_scsiid 101 102 /* error returns for fd_cmd() */ 103 #define FD_FAILED -1 104 #define FD_NOT_VALID -2 105 #define FDC_ERRMAX 100 /* do not log more */ 106 107 #define NUMTYPES 14 108 #define NUMDENS (NUMTYPES - 6) 109 110 /* These defines (-1) must match index for fd_types */ 111 #define F_TAPE_TYPE 0x020 /* bit for fd_types to indicate tape */ 112 #define NO_TYPE 0 /* must match NO_TYPE in ft.c */ 113 #define FD_1720 1 114 #define FD_1480 2 115 #define FD_1440 3 116 #define FD_1200 4 117 #define FD_820 5 118 #define FD_800 6 119 #define FD_720 7 120 #define FD_360 8 121 122 #define FD_1480in5_25 9 123 #define FD_1440in5_25 10 124 #define FD_820in5_25 11 125 #define FD_800in5_25 12 126 #define FD_720in5_25 13 127 #define FD_360in5_25 14 128 129 130 static struct fd_type fd_types[NUMTYPES] = 131 { 132 { 21,2,0xFF,0x04,82,3444,1,FDC_500KBPS,2,0x0C,2 }, /* 1.72M in HD 3.5in */ 133 { 18,2,0xFF,0x1B,82,2952,1,FDC_500KBPS,2,0x6C,1 }, /* 1.48M in HD 3.5in */ 134 { 18,2,0xFF,0x1B,80,2880,1,FDC_500KBPS,2,0x6C,1 }, /* 1.44M in HD 3.5in */ 135 { 15,2,0xFF,0x1B,80,2400,1,FDC_500KBPS,2,0x54,1 }, /* 1.2M in HD 5.25/3.5 */ 136 { 10,2,0xFF,0x10,82,1640,1,FDC_250KBPS,2,0x2E,1 }, /* 820K in HD 3.5in */ 137 { 10,2,0xFF,0x10,80,1600,1,FDC_250KBPS,2,0x2E,1 }, /* 800K in HD 3.5in */ 138 { 9,2,0xFF,0x20,80,1440,1,FDC_250KBPS,2,0x50,1 }, /* 720K in HD 3.5in */ 139 { 9,2,0xFF,0x2A,40, 720,1,FDC_250KBPS,2,0x50,1 }, /* 360K in DD 5.25in */ 140 141 { 18,2,0xFF,0x02,82,2952,1,FDC_500KBPS,2,0x02,2 }, /* 1.48M in HD 5.25in */ 142 { 18,2,0xFF,0x02,80,2880,1,FDC_500KBPS,2,0x02,2 }, /* 1.44M in HD 5.25in */ 143 { 10,2,0xFF,0x10,82,1640,1,FDC_300KBPS,2,0x2E,1 }, /* 820K in HD 5.25in */ 144 { 10,2,0xFF,0x10,80,1600,1,FDC_300KBPS,2,0x2E,1 }, /* 800K in HD 5.25in */ 145 { 9,2,0xFF,0x20,80,1440,1,FDC_300KBPS,2,0x50,1 }, /* 720K in HD 5.25in */ 146 { 9,2,0xFF,0x23,40, 720,2,FDC_300KBPS,2,0x50,1 }, /* 360K in HD 5.25in */ 147 }; 148 149 #define DRVS_PER_CTLR 2 /* 2 floppies */ 150 151 /***********************************************************************\ 152 * Per controller structure. * 153 \***********************************************************************/ 154 struct fdc_data fdc_data[NFDC]; 155 156 /***********************************************************************\ 157 * Per drive structure. * 158 * N per controller (DRVS_PER_CTLR) * 159 \***********************************************************************/ 160 static struct fd_data { 161 struct fdc_data *fdc; /* pointer to controller structure */ 162 int fdsu; /* this units number on this controller */ 163 int type; /* Drive type (FD_1440...) */ 164 struct fd_type *ft; /* pointer to the type descriptor */ 165 int flags; 166 #define FD_OPEN 0x01 /* it's open */ 167 #define FD_ACTIVE 0x02 /* it's active */ 168 #define FD_MOTOR 0x04 /* motor should be on */ 169 #define FD_MOTOR_WAIT 0x08 /* motor coming up */ 170 int skip; 171 int hddrv; 172 #define FD_NO_TRACK -2 173 int track; /* where we think the head is */ 174 int options; /* user configurable options, see ioctl_fd.h */ 175 struct callout_handle toffhandle; 176 struct callout_handle tohandle; 177 struct devstat device_stats; 178 #ifdef DEVFS 179 void *bdevs[1 + NUMDENS + MAXPARTITIONS]; 180 void *cdevs[1 + NUMDENS + MAXPARTITIONS]; 181 #endif 182 } fd_data[NFD]; 183 184 /***********************************************************************\ 185 * Throughout this file the following conventions will be used: * 186 * fd is a pointer to the fd_data struct for the drive in question * 187 * fdc is a pointer to the fdc_data struct for the controller * 188 * fdu is the floppy drive unit number * 189 * fdcu is the floppy controller unit number * 190 * fdsu is the floppy drive unit number on that controller. (sub-unit) * 191 \***********************************************************************/ 192 193 #ifdef FDC_YE 194 #include "card.h" 195 static int yeattach(struct isa_device *); 196 #endif 197 198 /* autoconfig functions */ 199 static int fdprobe(struct isa_device *); 200 static int fdattach(struct isa_device *); 201 202 /* needed for ft driver, thus exported */ 203 int in_fdc(fdcu_t); 204 int out_fdc(fdcu_t, int); 205 206 /* internal functions */ 207 static void set_motor(fdcu_t, int, int); 208 # define TURNON 1 209 # define TURNOFF 0 210 static timeout_t fd_turnoff; 211 static timeout_t fd_motor_on; 212 static void fd_turnon(fdu_t); 213 static void fdc_reset(fdc_p); 214 static int fd_in(fdcu_t, int *); 215 static void fdstart(fdcu_t); 216 static timeout_t fd_iotimeout; 217 static timeout_t fd_pseudointr; 218 static ointhand2_t fdintr; 219 static int fdstate(fdcu_t, fdc_p); 220 static int retrier(fdcu_t); 221 static int fdformat(dev_t, struct fd_formb *, struct proc *); 222 223 static int enable_fifo(fdc_p fdc); 224 225 static int fifo_threshold = 8; /* XXX: should be accessible via sysctl */ 226 227 228 #define DEVIDLE 0 229 #define FINDWORK 1 230 #define DOSEEK 2 231 #define SEEKCOMPLETE 3 232 #define IOCOMPLETE 4 233 #define RECALCOMPLETE 5 234 #define STARTRECAL 6 235 #define RESETCTLR 7 236 #define SEEKWAIT 8 237 #define RECALWAIT 9 238 #define MOTORWAIT 10 239 #define IOTIMEDOUT 11 240 #define RESETCOMPLETE 12 241 #ifdef FDC_YE 242 #define PIOREAD 13 243 #endif 244 245 #ifdef FDC_DEBUG 246 static char const * const fdstates[] = 247 { 248 "DEVIDLE", 249 "FINDWORK", 250 "DOSEEK", 251 "SEEKCOMPLETE", 252 "IOCOMPLETE", 253 "RECALCOMPLETE", 254 "STARTRECAL", 255 "RESETCTLR", 256 "SEEKWAIT", 257 "RECALWAIT", 258 "MOTORWAIT", 259 "IOTIMEDOUT", 260 "RESETCOMPLETE", 261 #ifdef FDC_YE 262 "PIOREAD", 263 #endif 264 }; 265 266 /* CAUTION: fd_debug causes huge amounts of logging output */ 267 static int volatile fd_debug = 0; 268 #define TRACE0(arg) if(fd_debug) printf(arg) 269 #define TRACE1(arg1, arg2) if(fd_debug) printf(arg1, arg2) 270 #else /* FDC_DEBUG */ 271 #define TRACE0(arg) 272 #define TRACE1(arg1, arg2) 273 #endif /* FDC_DEBUG */ 274 275 #ifdef FDC_YE 276 #if NCARD > 0 277 #include <sys/select.h> 278 #include <sys/module.h> 279 #include <pccard/cardinfo.h> 280 #include <pccard/driver.h> 281 #include <pccard/slot.h> 282 283 /* 284 * PC-Card (PCMCIA) specific code. 285 */ 286 static int yeinit(struct pccard_devinfo *); /* init device */ 287 static void yeunload(struct pccard_devinfo *); /* Disable driver */ 288 static int yeintr(struct pccard_devinfo *); /* Interrupt handler */ 289 290 PCCARD_MODULE(fdc, yeinit, yeunload, yeintr, 0, bio_imask); 291 292 /* 293 * this is the secret PIO data port (offset from base) 294 */ 295 #define FDC_YE_DATAPORT 6 296 297 /* 298 * Initialize the device - called from Slot manager. 299 */ 300 static int yeinit(struct pccard_devinfo *devi) 301 { 302 fdc_p fdc = &fdc_data[devi->isahd.id_unit]; 303 304 /* validate unit number. */ 305 if (devi->isahd.id_unit >= NFDC) 306 return(ENODEV); 307 fdc->baseport = devi->isahd.id_iobase; 308 /* 309 * reset controller 310 */ 311 outb(fdc->baseport+FDOUT, 0); 312 DELAY(100); 313 outb(fdc->baseport+FDOUT, FDO_FRST); 314 315 /* 316 * wire into system 317 */ 318 if (yeattach(&devi->isahd) == 0) 319 return(ENXIO); 320 321 return(0); 322 } 323 324 /* 325 * yeunload - unload the driver and clear the table. 326 * XXX TODO: 327 * This is usually called when the card is ejected, but 328 * can be caused by a modunload of a controller driver. 329 * The idea is to reset the driver's view of the device 330 * and ensure that any driver entry points such as 331 * read and write do not hang. 332 */ 333 static void yeunload(struct pccard_devinfo *devi) 334 { 335 if (fd_data[devi->isahd.id_unit].type == NO_TYPE) 336 return; 337 338 /* 339 * this prevents Fdopen() and fdstrategy() from attempting 340 * to access unloaded controller 341 */ 342 fd_data[devi->isahd.id_unit].type = NO_TYPE; 343 344 printf("fdc%d: unload\n", devi->isahd.id_unit); 345 } 346 347 /* 348 * yeintr - Shared interrupt called from 349 * front end of PC-Card handler. 350 */ 351 static int yeintr(struct pccard_devinfo *devi) 352 { 353 fdintr((fdcu_t)devi->isahd.id_unit); 354 return(1); 355 } 356 #endif /* NCARD > 0 */ 357 #endif /* FDC_YE */ 358 359 360 /* autoconfig structure */ 361 362 struct isa_driver fdcdriver = { 363 fdprobe, fdattach, "fdc", 364 }; 365 366 static d_open_t Fdopen; /* NOTE, not fdopen */ 367 static d_read_t fdread; 368 static d_write_t fdwrite; 369 static d_close_t fdclose; 370 static d_ioctl_t fdioctl; 371 static d_strategy_t fdstrategy; 372 373 /* even if SLICE defined, these are needed for the ft support. */ 374 #define CDEV_MAJOR 9 375 #define BDEV_MAJOR 2 376 377 378 static struct cdevsw fd_cdevsw = { 379 Fdopen, fdclose, fdread, fdwrite, 380 fdioctl, nostop, nullreset, nodevtotty, 381 seltrue, nommap, fdstrategy, "fd", 382 NULL, -1, nodump, nopsize, 383 D_DISK, 0, -1 }; 384 385 386 static struct isa_device *fdcdevs[NFDC]; 387 388 389 static int 390 fdc_err(fdcu_t fdcu, const char *s) 391 { 392 fdc_data[fdcu].fdc_errs++; 393 if(s) { 394 if(fdc_data[fdcu].fdc_errs < FDC_ERRMAX) 395 printf("fdc%d: %s", fdcu, s); 396 else if(fdc_data[fdcu].fdc_errs == FDC_ERRMAX) 397 printf("fdc%d: too many errors, not logging any more\n", 398 fdcu); 399 } 400 401 return FD_FAILED; 402 } 403 404 /* 405 * fd_cmd: Send a command to the chip. Takes a varargs with this structure: 406 * Unit number, 407 * # of output bytes, output bytes as ints ..., 408 * # of input bytes, input bytes as ints ... 409 */ 410 411 static int 412 fd_cmd(fdcu_t fdcu, int n_out, ...) 413 { 414 u_char cmd; 415 int n_in; 416 int n; 417 va_list ap; 418 419 va_start(ap, n_out); 420 cmd = (u_char)(va_arg(ap, int)); 421 va_end(ap); 422 va_start(ap, n_out); 423 for (n = 0; n < n_out; n++) 424 { 425 if (out_fdc(fdcu, va_arg(ap, int)) < 0) 426 { 427 char msg[50]; 428 snprintf(msg, sizeof(msg), 429 "cmd %x failed at out byte %d of %d\n", 430 cmd, n + 1, n_out); 431 return fdc_err(fdcu, msg); 432 } 433 } 434 n_in = va_arg(ap, int); 435 for (n = 0; n < n_in; n++) 436 { 437 int *ptr = va_arg(ap, int *); 438 if (fd_in(fdcu, ptr) < 0) 439 { 440 char msg[50]; 441 snprintf(msg, sizeof(msg), 442 "cmd %02x failed at in byte %d of %d\n", 443 cmd, n + 1, n_in); 444 return fdc_err(fdcu, msg); 445 } 446 } 447 448 return 0; 449 } 450 451 static int 452 enable_fifo(fdc_p fdc) 453 { 454 int i, j; 455 456 if ((fdc->flags & FDC_HAS_FIFO) == 0) { 457 458 /* 459 * XXX: 460 * Cannot use fd_cmd the normal way here, since 461 * this might be an invalid command. Thus we send the 462 * first byte, and check for an early turn of data directon. 463 */ 464 465 if (out_fdc(fdc->fdcu, I8207X_CONFIGURE) < 0) 466 return fdc_err(fdc->fdcu, "Enable FIFO failed\n"); 467 468 /* If command is invalid, return */ 469 j = 100000; 470 while ((i = inb(fdc->baseport + FDSTS) & (NE7_DIO | NE7_RQM)) 471 != NE7_RQM && j-- > 0) 472 if (i == (NE7_DIO | NE7_RQM)) { 473 fdc_reset(fdc); 474 return FD_FAILED; 475 } 476 if (j<0 || 477 fd_cmd(fdc->fdcu, 3, 478 0, (fifo_threshold - 1) & 0xf, 0, 0) < 0) { 479 fdc_reset(fdc); 480 return fdc_err(fdc->fdcu, "Enable FIFO failed\n"); 481 } 482 fdc->flags |= FDC_HAS_FIFO; 483 return 0; 484 } 485 if (fd_cmd(fdc->fdcu, 4, 486 I8207X_CONFIGURE, 0, (fifo_threshold - 1) & 0xf, 0, 0) < 0) 487 return fdc_err(fdc->fdcu, "Re-enable FIFO failed\n"); 488 return 0; 489 } 490 491 static int 492 fd_sense_drive_status(fdc_p fdc, int *st3p) 493 { 494 int st3; 495 496 if (fd_cmd(fdc->fdcu, 2, NE7CMD_SENSED, fdc->fdu, 1, &st3)) 497 { 498 return fdc_err(fdc->fdcu, "Sense Drive Status failed\n"); 499 } 500 if (st3p) 501 *st3p = st3; 502 503 return 0; 504 } 505 506 static int 507 fd_sense_int(fdc_p fdc, int *st0p, int *cylp) 508 { 509 int st0, cyl; 510 511 int ret = fd_cmd(fdc->fdcu, 1, NE7CMD_SENSEI, 1, &st0); 512 513 if (ret) 514 { 515 (void)fdc_err(fdc->fdcu, 516 "sense intr err reading stat reg 0\n"); 517 return ret; 518 } 519 520 if (st0p) 521 *st0p = st0; 522 523 if ((st0 & NE7_ST0_IC) == NE7_ST0_IC_IV) 524 { 525 /* 526 * There doesn't seem to have been an interrupt. 527 */ 528 return FD_NOT_VALID; 529 } 530 531 if (fd_in(fdc->fdcu, &cyl) < 0) 532 { 533 return fdc_err(fdc->fdcu, "can't get cyl num\n"); 534 } 535 536 if (cylp) 537 *cylp = cyl; 538 539 return 0; 540 } 541 542 543 static int 544 fd_read_status(fdc_p fdc, int fdsu) 545 { 546 int i, ret; 547 548 for (i = 0; i < 7; i++) 549 { 550 /* 551 * XXX types are poorly chosen. Only bytes can by read 552 * from the hardware, but fdc->status[] wants u_ints and 553 * fd_in() gives ints. 554 */ 555 int status; 556 557 ret = fd_in(fdc->fdcu, &status); 558 fdc->status[i] = status; 559 if (ret != 0) 560 break; 561 } 562 563 if (ret == 0) 564 fdc->flags |= FDC_STAT_VALID; 565 else 566 fdc->flags &= ~FDC_STAT_VALID; 567 568 return ret; 569 } 570 571 /****************************************************************************/ 572 /* autoconfiguration stuff */ 573 /****************************************************************************/ 574 575 /* 576 * probe for existance of controller 577 */ 578 static int 579 fdprobe(struct isa_device *dev) 580 { 581 fdcu_t fdcu = dev->id_unit; 582 if(fdc_data[fdcu].flags & FDC_ATTACHED) 583 { 584 printf("fdc%d: unit used multiple times\n", fdcu); 585 return 0; 586 } 587 588 fdcdevs[fdcu] = dev; 589 fdc_data[fdcu].baseport = dev->id_iobase; 590 591 /* First - lets reset the floppy controller */ 592 outb(dev->id_iobase+FDOUT, 0); 593 DELAY(100); 594 outb(dev->id_iobase+FDOUT, FDO_FRST); 595 596 /* see if it can handle a command */ 597 if (fd_cmd(fdcu, 598 3, NE7CMD_SPECIFY, NE7_SPEC_1(3, 240), NE7_SPEC_2(2, 0), 599 0)) 600 { 601 return(0); 602 } 603 #ifdef FDC_YE 604 /* 605 * don't succeed on probe; wait 606 * for PCCARD subsystem to do it 607 */ 608 if (dev->id_flags & FDC_IS_PCMCIA) 609 return(0); 610 #endif 611 return (IO_FDCSIZE); 612 } 613 614 /* 615 * wire controller into system, look for floppy units 616 */ 617 static int 618 fdattach(struct isa_device *dev) 619 { 620 unsigned fdt; 621 fdu_t fdu; 622 fdcu_t fdcu = dev->id_unit; 623 fdc_p fdc = fdc_data + fdcu; 624 fd_p fd; 625 int fdsu, st0, st3, i; 626 struct isa_device *fdup; 627 int ic_type = 0; 628 #ifdef DEVFS 629 int mynor; 630 int typemynor; 631 int typesize; 632 #endif 633 634 dev->id_ointr = fdintr; 635 fdc->fdcu = fdcu; 636 fdc->flags |= FDC_ATTACHED; 637 fdc->dmachan = dev->id_drq; 638 /* Acquire the DMA channel forever, The driver will do the rest */ 639 isa_dma_acquire(fdc->dmachan); 640 isa_dmainit(fdc->dmachan, 128 << 3 /* XXX max secsize */); 641 fdc->state = DEVIDLE; 642 /* reset controller, turn motor off, clear fdout mirror reg */ 643 outb(fdc->baseport + FDOUT, ((fdc->fdout = 0))); 644 bufq_init(&fdc->head); 645 646 /* check for each floppy drive */ 647 for (fdup = isa_biotab_fdc; fdup->id_driver != 0; fdup++) { 648 if (fdup->id_iobase != dev->id_iobase) 649 continue; 650 fdu = fdup->id_unit; 651 fd = &fd_data[fdu]; 652 if (fdu >= (NFD)) 653 continue; 654 fdsu = fdup->id_physid; 655 /* look up what bios thinks we have */ 656 switch (fdu) { 657 case 0: if (dev->id_flags & FDC_PRETEND_D0) 658 fdt = RTCFDT_144M | RTCFDT_144M_PRETENDED; 659 else 660 fdt = (rtcin(RTC_FDISKETTE) & 0xf0); 661 break; 662 case 1: fdt = ((rtcin(RTC_FDISKETTE) << 4) & 0xf0); 663 break; 664 default: fdt = RTCFDT_NONE; 665 break; 666 } 667 /* is there a unit? */ 668 if ((fdt == RTCFDT_NONE) 669 ) { 670 fd->type = NO_TYPE; 671 continue; 672 } 673 674 /* select it */ 675 set_motor(fdcu, fdsu, TURNON); 676 DELAY(1000000); /* 1 sec */ 677 678 if (ic_type == 0 && 679 fd_cmd(fdcu, 1, NE7CMD_VERSION, 1, &ic_type) == 0) 680 { 681 #ifdef FDC_PRINT_BOGUS_CHIPTYPE 682 printf("fdc%d: ", fdcu); 683 #endif 684 ic_type = (u_char)ic_type; 685 switch( ic_type ) { 686 case 0x80: 687 #ifdef FDC_PRINT_BOGUS_CHIPTYPE 688 printf("NEC 765\n"); 689 #endif 690 fdc->fdct = FDC_NE765; 691 break; 692 case 0x81: 693 #ifdef FDC_PRINT_BOGUS_CHIPTYPE 694 printf("Intel 82077\n"); 695 #endif 696 fdc->fdct = FDC_I82077; 697 break; 698 case 0x90: 699 #ifdef FDC_PRINT_BOGUS_CHIPTYPE 700 printf("NEC 72065B\n"); 701 #endif 702 fdc->fdct = FDC_NE72065; 703 break; 704 default: 705 #ifdef FDC_PRINT_BOGUS_CHIPTYPE 706 printf("unknown IC type %02x\n", ic_type); 707 #endif 708 fdc->fdct = FDC_UNKNOWN; 709 break; 710 } 711 if (fdc->fdct != FDC_NE765 && 712 fdc->fdct != FDC_UNKNOWN && 713 enable_fifo(fdc) == 0) { 714 printf("fdc%d: FIFO enabled", fdcu); 715 printf(", %d bytes threshold\n", 716 fifo_threshold); 717 } 718 } 719 if ((fd_cmd(fdcu, 2, NE7CMD_SENSED, fdsu, 1, &st3) == 0) && 720 (st3 & NE7_ST3_T0)) { 721 /* if at track 0, first seek inwards */ 722 /* seek some steps: */ 723 (void)fd_cmd(fdcu, 3, NE7CMD_SEEK, fdsu, 10, 0); 724 DELAY(300000); /* ...wait a moment... */ 725 (void)fd_sense_int(fdc, 0, 0); /* make ctrlr happy */ 726 } 727 728 /* If we're at track 0 first seek inwards. */ 729 if ((fd_sense_drive_status(fdc, &st3) == 0) && 730 (st3 & NE7_ST3_T0)) { 731 /* Seek some steps... */ 732 if (fd_cmd(fdcu, 3, NE7CMD_SEEK, fdsu, 10, 0) == 0) { 733 /* ...wait a moment... */ 734 DELAY(300000); 735 /* make ctrlr happy: */ 736 (void)fd_sense_int(fdc, 0, 0); 737 } 738 } 739 740 for(i = 0; i < 2; i++) { 741 /* 742 * we must recalibrate twice, just in case the 743 * heads have been beyond cylinder 76, since most 744 * FDCs still barf when attempting to recalibrate 745 * more than 77 steps 746 */ 747 /* go back to 0: */ 748 if (fd_cmd(fdcu, 2, NE7CMD_RECAL, fdsu, 0) == 0) { 749 /* a second being enough for full stroke seek*/ 750 DELAY(i == 0? 1000000: 300000); 751 752 /* anything responding? */ 753 if (fd_sense_int(fdc, &st0, 0) == 0 && 754 (st0 & NE7_ST0_EC) == 0) 755 break; /* already probed succesfully */ 756 } 757 } 758 759 set_motor(fdcu, fdsu, TURNOFF); 760 761 if (st0 & NE7_ST0_EC) /* no track 0 -> no drive present */ 762 continue; 763 764 fd->track = FD_NO_TRACK; 765 fd->fdc = fdc; 766 fd->fdsu = fdsu; 767 fd->options = 0; 768 callout_handle_init(&fd->toffhandle); 769 callout_handle_init(&fd->tohandle); 770 printf("fd%d: ", fdu); 771 772 switch (fdt) { 773 case RTCFDT_12M: 774 printf("1.2MB 5.25in\n"); 775 fd->type = FD_1200; 776 break; 777 case RTCFDT_144M | RTCFDT_144M_PRETENDED: 778 printf("config-pretended "); 779 fdt = RTCFDT_144M; 780 /* fallthrough */ 781 case RTCFDT_144M: 782 printf("1.44MB 3.5in\n"); 783 fd->type = FD_1440; 784 break; 785 case RTCFDT_288M: 786 case RTCFDT_288M_1: 787 printf("2.88MB 3.5in - 1.44MB mode\n"); 788 fd->type = FD_1440; 789 break; 790 case RTCFDT_360K: 791 printf("360KB 5.25in\n"); 792 fd->type = FD_360; 793 break; 794 case RTCFDT_720K: 795 printf("720KB 3.5in\n"); 796 fd->type = FD_720; 797 break; 798 default: 799 printf("unknown\n"); 800 fd->type = NO_TYPE; 801 continue; 802 } 803 #ifdef DEVFS 804 mynor = fdu << 6; 805 fd->bdevs[0] = devfs_add_devswf(&fd_cdevsw, mynor, DV_BLK, 806 UID_ROOT, GID_OPERATOR, 0640, 807 "fd%d", fdu); 808 fd->cdevs[0] = devfs_add_devswf(&fd_cdevsw, mynor, DV_CHR, 809 UID_ROOT, GID_OPERATOR, 0640, 810 "rfd%d", fdu); 811 for (i = 1; i < 1 + NUMDENS; i++) { 812 /* 813 * XXX this and the lookup in Fdopen() should be 814 * data driven. 815 */ 816 switch (fd->type) { 817 case FD_360: 818 if (i != FD_360) 819 continue; 820 break; 821 case FD_720: 822 if (i != FD_720 && i != FD_800 && i != FD_820) 823 continue; 824 break; 825 case FD_1200: 826 if (i != FD_360 && i != FD_720 && i != FD_800 827 && i != FD_820 && i != FD_1200 828 && i != FD_1440 && i != FD_1480) 829 continue; 830 break; 831 case FD_1440: 832 if (i != FD_720 && i != FD_800 && i != FD_820 833 && i != FD_1200 && i != FD_1440 834 && i != FD_1480 && i != FD_1720) 835 continue; 836 break; 837 } 838 typesize = fd_types[i - 1].size / 2; 839 /* 840 * XXX all these conversions give bloated code and 841 * confusing names. 842 */ 843 if (typesize == 1476) 844 typesize = 1480; 845 if (typesize == 1722) 846 typesize = 1720; 847 typemynor = mynor | i; 848 fd->bdevs[i] = 849 devfs_add_devswf(&fd_cdevsw, typemynor, DV_BLK, 850 UID_ROOT, GID_OPERATOR, 0640, 851 "fd%d.%d", fdu, typesize); 852 fd->cdevs[i] = 853 devfs_add_devswf(&fd_cdevsw, typemynor, DV_CHR, 854 UID_ROOT, GID_OPERATOR, 0640, 855 "rfd%d.%d", fdu, typesize); 856 } 857 858 for (i = 0; i < MAXPARTITIONS; i++) { 859 fd->bdevs[1 + NUMDENS + i] = devfs_makelink(fd->bdevs[0], 860 "fd%d%c", fdu, 'a' + i); 861 fd->cdevs[1 + NUMDENS + i] = 862 devfs_makelink(fd->cdevs[0], 863 "rfd%d%c", fdu, 'a' + i); 864 } 865 #endif /* DEVFS */ 866 /* 867 * Export the drive to the devstat interface. 868 */ 869 devstat_add_entry(&fd->device_stats, "fd", 870 fdu, 512, 871 DEVSTAT_NO_ORDERED_TAGS, 872 DEVSTAT_TYPE_FLOPPY | DEVSTAT_TYPE_IF_OTHER, 873 DEVSTAT_PRIORITY_FD); 874 875 } 876 877 return (1); 878 } 879 880 881 882 #ifdef FDC_YE 883 /* 884 * this is a subset of fdattach() optimized for the Y-E Data 885 * PCMCIA floppy drive. 886 */ 887 static int yeattach(struct isa_device *dev) 888 { 889 fdcu_t fdcu = dev->id_unit; 890 fdc_p fdc = fdc_data + fdcu; 891 fdsu_t fdsu = 0; /* assume 1 drive per YE controller */ 892 fdu_t fdu; 893 fd_p fd; 894 int st0, st3, i; 895 #ifdef DEVFS 896 int mynor; 897 int typemynor; 898 int typesize; 899 #endif 900 fdc->fdcu = fdcu; 901 /* 902 * the FDC_PCMCIA flag is used to to indicate special PIO is used 903 * instead of DMA 904 */ 905 fdc->flags = FDC_ATTACHED|FDC_PCMCIA; 906 fdc->state = DEVIDLE; 907 /* reset controller, turn motor off, clear fdout mirror reg */ 908 outb(fdc->baseport + FDOUT, ((fdc->fdout = 0))); 909 bufq_init(&fdc->head); 910 /* 911 * assume 2 drives/ "normal" controller 912 */ 913 fdu = fdcu * 2; 914 if (fdu >= NFD) { 915 printf("fdu %d >= NFD\n",fdu); 916 return(0); 917 }; 918 fd = &fd_data[fdu]; 919 920 set_motor(fdcu, fdsu, TURNON); 921 DELAY(1000000); /* 1 sec */ 922 fdc->fdct = FDC_NE765; 923 924 if ((fd_cmd(fdcu, 2, NE7CMD_SENSED, fdsu, 1, &st3) == 0) && 925 (st3 & NE7_ST3_T0)) { 926 /* if at track 0, first seek inwards */ 927 /* seek some steps: */ 928 (void)fd_cmd(fdcu, 3, NE7CMD_SEEK, fdsu, 10, 0); 929 DELAY(300000); /* ...wait a moment... */ 930 (void)fd_sense_int(fdc, 0, 0); /* make ctrlr happy */ 931 } 932 933 /* If we're at track 0 first seek inwards. */ 934 if ((fd_sense_drive_status(fdc, &st3) == 0) && (st3 & NE7_ST3_T0)) { 935 /* Seek some steps... */ 936 if (fd_cmd(fdcu, 3, NE7CMD_SEEK, fdsu, 10, 0) == 0) { 937 /* ...wait a moment... */ 938 DELAY(300000); 939 /* make ctrlr happy: */ 940 (void)fd_sense_int(fdc, 0, 0); 941 } 942 } 943 944 for(i = 0; i < 2; i++) { 945 /* 946 * we must recalibrate twice, just in case the 947 * heads have been beyond cylinder 76, since most 948 * FDCs still barf when attempting to recalibrate 949 * more than 77 steps 950 */ 951 /* go back to 0: */ 952 if (fd_cmd(fdcu, 2, NE7CMD_RECAL, fdsu, 0) == 0) { 953 /* a second being enough for full stroke seek*/ 954 DELAY(i == 0? 1000000: 300000); 955 956 /* anything responding? */ 957 if (fd_sense_int(fdc, &st0, 0) == 0 && 958 (st0 & NE7_ST0_EC) == 0) 959 break; /* already probed succesfully */ 960 } 961 } 962 963 set_motor(fdcu, fdsu, TURNOFF); 964 965 if (st0 & NE7_ST0_EC) /* no track 0 -> no drive present */ 966 return(0); 967 968 fd->track = FD_NO_TRACK; 969 fd->fdc = fdc; 970 fd->fdsu = fdsu; 971 fd->options = 0; 972 printf("fdc%d: 1.44MB 3.5in PCMCIA\n", fdcu); 973 fd->type = FD_1440; 974 975 #ifdef DEVFS 976 mynor = fdcu << 6; 977 fd->bdevs[0] = devfs_add_devswf(&fd_cdevsw, mynor, DV_BLK, 978 UID_ROOT, GID_OPERATOR, 0640, 979 "fd%d", fdu); 980 fd->cdevs[0] = devfs_add_devswf(&fd_cdevsw, mynor, DV_CHR, 981 UID_ROOT, GID_OPERATOR, 0640, 982 "rfd%d", fdu); 983 /* 984 * XXX this and the lookup in Fdopen() should be 985 * data driven. 986 */ 987 typemynor = mynor | FD_1440; 988 typesize = fd_types[FD_1440 - 1].size / 2; 989 /* 990 * XXX all these conversions give bloated code and 991 * confusing names. 992 */ 993 if (typesize == 1476) 994 typesize = 1480; 995 if (typesize == 1722) 996 typesize = 1720; 997 fd->bdevs[FD_1440] = devfs_add_devswf(&fd_cdevsw, typemynor, 998 DV_BLK, UID_ROOT, GID_OPERATOR, 999 0640, "fd%d.%d", fdu, typesize); 1000 fd->cdevs[FD_1440] = devfs_add_devswf(&fd_cdevsw, typemynor, 1001 DV_CHR, UID_ROOT, GID_OPERATOR, 1002 0640,"rfd%d.%d", fdu, typesize); 1003 for (i = 0; i < MAXPARTITIONS; i++) { 1004 fd->bdevs[1 + NUMDENS + i] = devfs_makelink(fd->bdevs[0], 1005 "fd%d%c", fdu, 'a' + i); 1006 fd->cdevs[1 + NUMDENS + i] = devfs_makelink(fd->cdevs[0], 1007 "rfd%d%c", fdu, 'a' + i); 1008 } 1009 #endif /* DEVFS */ 1010 return (1); 1011 } 1012 #endif 1013 1014 /****************************************************************************/ 1015 /* motor control stuff */ 1016 /* remember to not deselect the drive we're working on */ 1017 /****************************************************************************/ 1018 static void 1019 set_motor(fdcu_t fdcu, int fdsu, int turnon) 1020 { 1021 int fdout = fdc_data[fdcu].fdout; 1022 int needspecify = 0; 1023 1024 if(turnon) { 1025 fdout &= ~FDO_FDSEL; 1026 fdout |= (FDO_MOEN0 << fdsu) + fdsu; 1027 } else 1028 fdout &= ~(FDO_MOEN0 << fdsu); 1029 1030 if(!turnon 1031 && (fdout & (FDO_MOEN0+FDO_MOEN1+FDO_MOEN2+FDO_MOEN3)) == 0) 1032 /* gonna turn off the last drive, put FDC to bed */ 1033 fdout &= ~ (FDO_FRST|FDO_FDMAEN); 1034 else { 1035 /* make sure controller is selected and specified */ 1036 if((fdout & (FDO_FRST|FDO_FDMAEN)) == 0) 1037 needspecify = 1; 1038 fdout |= (FDO_FRST|FDO_FDMAEN); 1039 } 1040 1041 outb(fdc_data[fdcu].baseport+FDOUT, fdout); 1042 fdc_data[fdcu].fdout = fdout; 1043 TRACE1("[0x%x->FDOUT]", fdout); 1044 1045 if(needspecify) { 1046 /* 1047 * XXX 1048 * special case: since we have just woken up the FDC 1049 * from its sleep, we silently assume the command will 1050 * be accepted, and do not test for a timeout 1051 */ 1052 (void)fd_cmd(fdcu, 3, NE7CMD_SPECIFY, 1053 NE7_SPEC_1(3, 240), NE7_SPEC_2(2, 0), 1054 0); 1055 if (fdc_data[fdcu].flags & FDC_HAS_FIFO) 1056 (void) enable_fifo(&fdc_data[fdcu]); 1057 } 1058 } 1059 1060 static void 1061 fd_turnoff(void *arg1) 1062 { 1063 fdu_t fdu = (fdu_t)arg1; 1064 int s; 1065 fd_p fd = fd_data + fdu; 1066 1067 TRACE1("[fd%d: turnoff]", fdu); 1068 1069 /* 1070 * Don't turn off the motor yet if the drive is active. 1071 * XXX shouldn't even schedule turnoff until drive is inactive 1072 * and nothing is queued on it. 1073 */ 1074 if (fd->fdc->state != DEVIDLE && fd->fdc->fdu == fdu) { 1075 fd->toffhandle = timeout(fd_turnoff, arg1, 4 * hz); 1076 return; 1077 } 1078 1079 s = splbio(); 1080 fd->flags &= ~FD_MOTOR; 1081 set_motor(fd->fdc->fdcu, fd->fdsu, TURNOFF); 1082 splx(s); 1083 } 1084 1085 static void 1086 fd_motor_on(void *arg1) 1087 { 1088 fdu_t fdu = (fdu_t)arg1; 1089 int s; 1090 1091 fd_p fd = fd_data + fdu; 1092 s = splbio(); 1093 fd->flags &= ~FD_MOTOR_WAIT; 1094 if((fd->fdc->fd == fd) && (fd->fdc->state == MOTORWAIT)) 1095 { 1096 fdintr(fd->fdc->fdcu); 1097 } 1098 splx(s); 1099 } 1100 1101 static void 1102 fd_turnon(fdu_t fdu) 1103 { 1104 fd_p fd = fd_data + fdu; 1105 if(!(fd->flags & FD_MOTOR)) 1106 { 1107 fd->flags |= (FD_MOTOR + FD_MOTOR_WAIT); 1108 set_motor(fd->fdc->fdcu, fd->fdsu, TURNON); 1109 timeout(fd_motor_on, (caddr_t)fdu, hz); /* in 1 sec its ok */ 1110 } 1111 } 1112 1113 static void 1114 fdc_reset(fdc_p fdc) 1115 { 1116 fdcu_t fdcu = fdc->fdcu; 1117 1118 /* Try a reset, keep motor on */ 1119 outb(fdc->baseport + FDOUT, fdc->fdout & ~(FDO_FRST|FDO_FDMAEN)); 1120 TRACE1("[0x%x->FDOUT]", fdc->fdout & ~(FDO_FRST|FDO_FDMAEN)); 1121 DELAY(100); 1122 /* enable FDC, but defer interrupts a moment */ 1123 outb(fdc->baseport + FDOUT, fdc->fdout & ~FDO_FDMAEN); 1124 TRACE1("[0x%x->FDOUT]", fdc->fdout & ~FDO_FDMAEN); 1125 DELAY(100); 1126 outb(fdc->baseport + FDOUT, fdc->fdout); 1127 TRACE1("[0x%x->FDOUT]", fdc->fdout); 1128 1129 /* XXX after a reset, silently believe the FDC will accept commands */ 1130 (void)fd_cmd(fdcu, 3, NE7CMD_SPECIFY, 1131 NE7_SPEC_1(3, 240), NE7_SPEC_2(2, 0), 1132 0); 1133 if (fdc->flags & FDC_HAS_FIFO) 1134 (void) enable_fifo(fdc); 1135 } 1136 1137 /****************************************************************************/ 1138 /* fdc in/out */ 1139 /****************************************************************************/ 1140 int 1141 in_fdc(fdcu_t fdcu) 1142 { 1143 int baseport = fdc_data[fdcu].baseport; 1144 int i, j = 100000; 1145 while ((i = inb(baseport+FDSTS) & (NE7_DIO|NE7_RQM)) 1146 != (NE7_DIO|NE7_RQM) && j-- > 0) 1147 if (i == NE7_RQM) 1148 return fdc_err(fdcu, "ready for output in input\n"); 1149 if (j <= 0) 1150 return fdc_err(fdcu, bootverbose? "input ready timeout\n": 0); 1151 #ifdef FDC_DEBUG 1152 i = inb(baseport+FDDATA); 1153 TRACE1("[FDDATA->0x%x]", (unsigned char)i); 1154 return(i); 1155 #else /* !FDC_DEBUG */ 1156 return inb(baseport+FDDATA); 1157 #endif /* FDC_DEBUG */ 1158 } 1159 1160 /* 1161 * fd_in: Like in_fdc, but allows you to see if it worked. 1162 */ 1163 static int 1164 fd_in(fdcu_t fdcu, int *ptr) 1165 { 1166 int baseport = fdc_data[fdcu].baseport; 1167 int i, j = 100000; 1168 while ((i = inb(baseport+FDSTS) & (NE7_DIO|NE7_RQM)) 1169 != (NE7_DIO|NE7_RQM) && j-- > 0) 1170 if (i == NE7_RQM) 1171 return fdc_err(fdcu, "ready for output in input\n"); 1172 if (j <= 0) 1173 return fdc_err(fdcu, bootverbose? "input ready timeout\n": 0); 1174 #ifdef FDC_DEBUG 1175 i = inb(baseport+FDDATA); 1176 TRACE1("[FDDATA->0x%x]", (unsigned char)i); 1177 *ptr = i; 1178 return 0; 1179 #else /* !FDC_DEBUG */ 1180 i = inb(baseport+FDDATA); 1181 if (ptr) 1182 *ptr = i; 1183 return 0; 1184 #endif /* FDC_DEBUG */ 1185 } 1186 1187 int 1188 out_fdc(fdcu_t fdcu, int x) 1189 { 1190 int baseport = fdc_data[fdcu].baseport; 1191 int i; 1192 1193 /* Check that the direction bit is set */ 1194 i = 100000; 1195 while ((inb(baseport+FDSTS) & NE7_DIO) && i-- > 0); 1196 if (i <= 0) return fdc_err(fdcu, "direction bit not set\n"); 1197 1198 /* Check that the floppy controller is ready for a command */ 1199 i = 100000; 1200 while ((inb(baseport+FDSTS) & NE7_RQM) == 0 && i-- > 0); 1201 if (i <= 0) 1202 return fdc_err(fdcu, bootverbose? "output ready timeout\n": 0); 1203 1204 /* Send the command and return */ 1205 outb(baseport+FDDATA, x); 1206 TRACE1("[0x%x->FDDATA]", x); 1207 return (0); 1208 } 1209 1210 /****************************************************************************/ 1211 /* fdopen/fdclose */ 1212 /****************************************************************************/ 1213 int 1214 Fdopen(dev_t dev, int flags, int mode, struct proc *p) 1215 { 1216 fdu_t fdu = FDUNIT(minor(dev)); 1217 int type = FDTYPE(minor(dev)); 1218 fdc_p fdc; 1219 1220 /* check bounds */ 1221 if (fdu >= NFD) 1222 return(ENXIO); 1223 fdc = fd_data[fdu].fdc; 1224 if ((fdc == NULL) || (fd_data[fdu].type == NO_TYPE)) 1225 return(ENXIO); 1226 if (type > NUMDENS) 1227 return(ENXIO); 1228 if (type == 0) 1229 type = fd_data[fdu].type; 1230 else { 1231 /* 1232 * For each type of basic drive, make sure we are trying 1233 * to open a type it can do, 1234 */ 1235 if (type != fd_data[fdu].type) { 1236 switch (fd_data[fdu].type) { 1237 case FD_360: 1238 return(ENXIO); 1239 case FD_720: 1240 if ( type != FD_820 1241 && type != FD_800 1242 ) 1243 return(ENXIO); 1244 break; 1245 case FD_1200: 1246 switch (type) { 1247 case FD_1480: 1248 type = FD_1480in5_25; 1249 break; 1250 case FD_1440: 1251 type = FD_1440in5_25; 1252 break; 1253 case FD_820: 1254 type = FD_820in5_25; 1255 break; 1256 case FD_800: 1257 type = FD_800in5_25; 1258 break; 1259 case FD_720: 1260 type = FD_720in5_25; 1261 break; 1262 case FD_360: 1263 type = FD_360in5_25; 1264 break; 1265 default: 1266 return(ENXIO); 1267 } 1268 break; 1269 case FD_1440: 1270 if ( type != FD_1720 1271 && type != FD_1480 1272 && type != FD_1200 1273 && type != FD_820 1274 && type != FD_800 1275 && type != FD_720 1276 ) 1277 return(ENXIO); 1278 break; 1279 } 1280 } 1281 } 1282 fd_data[fdu].ft = fd_types + type - 1; 1283 fd_data[fdu].flags |= FD_OPEN; 1284 1285 return 0; 1286 } 1287 1288 int 1289 fdclose(dev_t dev, int flags, int mode, struct proc *p) 1290 { 1291 fdu_t fdu = FDUNIT(minor(dev)); 1292 1293 fd_data[fdu].flags &= ~FD_OPEN; 1294 fd_data[fdu].options &= ~FDOPT_NORETRY; 1295 1296 return(0); 1297 } 1298 1299 static int 1300 fdread(dev_t dev, struct uio *uio, int ioflag) 1301 { 1302 return (physio(fdstrategy, NULL, dev, 1, minphys, uio)); 1303 } 1304 1305 static int 1306 fdwrite(dev_t dev, struct uio *uio, int ioflag) 1307 { 1308 return (physio(fdstrategy, NULL, dev, 0, minphys, uio)); 1309 } 1310 1311 1312 /****************************************************************************/ 1313 /* fdstrategy */ 1314 /****************************************************************************/ 1315 void 1316 fdstrategy(struct buf *bp) 1317 { 1318 unsigned nblocks, blknum, cando; 1319 int s; 1320 fdcu_t fdcu; 1321 fdu_t fdu; 1322 fdc_p fdc; 1323 fd_p fd; 1324 size_t fdblk; 1325 1326 fdu = FDUNIT(minor(bp->b_dev)); 1327 fd = &fd_data[fdu]; 1328 fdc = fd->fdc; 1329 fdcu = fdc->fdcu; 1330 #ifdef FDC_YE 1331 if (fd->type == NO_TYPE) { 1332 bp->b_error = ENXIO; 1333 bp->b_flags |= B_ERROR; 1334 /* 1335 * I _refuse_ to use a goto 1336 */ 1337 biodone(bp); 1338 return; 1339 }; 1340 #endif 1341 1342 fdblk = 128 << (fd->ft->secsize); 1343 if (!(bp->b_flags & B_FORMAT)) { 1344 if ((fdu >= NFD) || (bp->b_blkno < 0)) { 1345 printf( 1346 "fd%d: fdstrat: bad request blkno = %lu, bcount = %ld\n", 1347 fdu, (u_long)bp->b_blkno, bp->b_bcount); 1348 bp->b_error = EINVAL; 1349 bp->b_flags |= B_ERROR; 1350 goto bad; 1351 } 1352 if ((bp->b_bcount % fdblk) != 0) { 1353 bp->b_error = EINVAL; 1354 bp->b_flags |= B_ERROR; 1355 goto bad; 1356 } 1357 } 1358 1359 /* 1360 * Set up block calculations. 1361 */ 1362 if (bp->b_blkno > 20000000) { 1363 /* 1364 * Reject unreasonably high block number, prevent the 1365 * multiplication below from overflowing. 1366 */ 1367 bp->b_error = EINVAL; 1368 bp->b_flags |= B_ERROR; 1369 goto bad; 1370 } 1371 blknum = (unsigned) bp->b_blkno * DEV_BSIZE/fdblk; 1372 nblocks = fd->ft->size; 1373 bp->b_resid = 0; 1374 if (blknum + (bp->b_bcount / fdblk) > nblocks) { 1375 if (blknum <= nblocks) { 1376 cando = (nblocks - blknum) * fdblk; 1377 bp->b_resid = bp->b_bcount - cando; 1378 if (cando == 0) 1379 goto bad; /* not actually bad but EOF */ 1380 } else { 1381 bp->b_error = EINVAL; 1382 bp->b_flags |= B_ERROR; 1383 goto bad; 1384 } 1385 } 1386 bp->b_pblkno = bp->b_blkno; 1387 s = splbio(); 1388 bufqdisksort(&fdc->head, bp); 1389 untimeout(fd_turnoff, (caddr_t)fdu, fd->toffhandle); /* a good idea */ 1390 1391 /* Tell devstat we are starting on the transaction */ 1392 devstat_start_transaction(&fd->device_stats); 1393 1394 fdstart(fdcu); 1395 splx(s); 1396 return; 1397 1398 bad: 1399 biodone(bp); 1400 } 1401 1402 /***************************************************************\ 1403 * fdstart * 1404 * We have just queued something.. if the controller is not busy * 1405 * then simulate the case where it has just finished a command * 1406 * So that it (the interrupt routine) looks on the queue for more* 1407 * work to do and picks up what we just added. * 1408 * If the controller is already busy, we need do nothing, as it * 1409 * will pick up our work when the present work completes * 1410 \***************************************************************/ 1411 static void 1412 fdstart(fdcu_t fdcu) 1413 { 1414 int s; 1415 1416 s = splbio(); 1417 if(fdc_data[fdcu].state == DEVIDLE) 1418 { 1419 fdintr(fdcu); 1420 } 1421 splx(s); 1422 } 1423 1424 static void 1425 fd_iotimeout(void *arg1) 1426 { 1427 fdc_p fdc; 1428 fdcu_t fdcu; 1429 int s; 1430 1431 fdcu = (fdcu_t)arg1; 1432 fdc = fdc_data + fdcu; 1433 TRACE1("fd%d[fd_iotimeout()]", fdc->fdu); 1434 1435 /* 1436 * Due to IBM's brain-dead design, the FDC has a faked ready 1437 * signal, hardwired to ready == true. Thus, any command 1438 * issued if there's no diskette in the drive will _never_ 1439 * complete, and must be aborted by resetting the FDC. 1440 * Many thanks, Big Blue! 1441 * The FDC must not be reset directly, since that would 1442 * interfere with the state machine. Instead, pretend that 1443 * the command completed but was invalid. The state machine 1444 * will reset the FDC and retry once. 1445 */ 1446 s = splbio(); 1447 fdc->status[0] = NE7_ST0_IC_IV; 1448 fdc->flags &= ~FDC_STAT_VALID; 1449 fdc->state = IOTIMEDOUT; 1450 fdintr(fdcu); 1451 splx(s); 1452 } 1453 1454 /* just ensure it has the right spl */ 1455 static void 1456 fd_pseudointr(void *arg1) 1457 { 1458 fdcu_t fdcu = (fdcu_t)arg1; 1459 int s; 1460 1461 s = splbio(); 1462 fdintr(fdcu); 1463 splx(s); 1464 } 1465 1466 /***********************************************************************\ 1467 * fdintr * 1468 * keep calling the state machine until it returns a 0 * 1469 * ALWAYS called at SPLBIO * 1470 \***********************************************************************/ 1471 static void 1472 fdintr(fdcu_t fdcu) 1473 { 1474 fdc_p fdc = fdc_data + fdcu; 1475 while(fdstate(fdcu, fdc)) 1476 ; 1477 } 1478 1479 #ifdef FDC_YE 1480 /* 1481 * magic pseudo-DMA initialization for YE FDC. Sets count and 1482 * direction 1483 */ 1484 #define SET_BCDR(wr,cnt,port) outb(port,(((cnt)-1) & 0xff)); \ 1485 outb(port+1,((wr ? 0x80 : 0) | ((((cnt)-1) >> 8) & 0x7f))) 1486 1487 /* 1488 * fdcpio(): perform programmed IO read/write for YE PCMCIA floppy 1489 */ 1490 static int fdcpio(fdcu_t fdcu, long flags, caddr_t addr, u_int count) 1491 { 1492 u_char *cptr = (u_char *)addr; 1493 fdc_p fdc = &fdc_data[fdcu]; 1494 int io = fdc->baseport; 1495 1496 if (flags & B_READ) { 1497 if (fdc->state != PIOREAD) { 1498 fdc->state = PIOREAD; 1499 return(0); 1500 }; 1501 SET_BCDR(0,count,io); 1502 insb(io+FDC_YE_DATAPORT,cptr,count); 1503 } else { 1504 outsb(io+FDC_YE_DATAPORT,cptr,count); 1505 SET_BCDR(0,count,io); 1506 }; 1507 return(1); 1508 } 1509 #endif /* FDC_YE */ 1510 1511 /***********************************************************************\ 1512 * The controller state machine. * 1513 * if it returns a non zero value, it should be called again immediatly * 1514 \***********************************************************************/ 1515 static int 1516 fdstate(fdcu_t fdcu, fdc_p fdc) 1517 { 1518 int read, format, head, i, sec = 0, sectrac, st0, cyl, st3; 1519 unsigned blknum = 0, b_cylinder = 0; 1520 fdu_t fdu = fdc->fdu; 1521 fd_p fd; 1522 register struct buf *bp; 1523 struct fd_formb *finfo = NULL; 1524 size_t fdblk; 1525 1526 bp = fdc->bp; 1527 if (bp == NULL) { 1528 bp = bufq_first(&fdc->head); 1529 if (bp != NULL) { 1530 bufq_remove(&fdc->head, bp); 1531 fdc->bp = bp; 1532 } 1533 } 1534 if (bp == NULL) { 1535 /***********************************************\ 1536 * nothing left for this controller to do * 1537 * Force into the IDLE state, * 1538 \***********************************************/ 1539 fdc->state = DEVIDLE; 1540 if(fdc->fd) 1541 { 1542 printf("fd%d: unexpected valid fd pointer\n", 1543 fdc->fdu); 1544 fdc->fd = (fd_p) 0; 1545 fdc->fdu = -1; 1546 } 1547 TRACE1("[fdc%d IDLE]", fdcu); 1548 return(0); 1549 } 1550 fdu = FDUNIT(minor(bp->b_dev)); 1551 fd = fd_data + fdu; 1552 fdblk = 128 << fd->ft->secsize; 1553 if (fdc->fd && (fd != fdc->fd)) 1554 { 1555 printf("fd%d: confused fd pointers\n", fdu); 1556 } 1557 read = bp->b_flags & B_READ; 1558 format = bp->b_flags & B_FORMAT; 1559 if(format) { 1560 finfo = (struct fd_formb *)bp->b_data; 1561 fd->skip = (char *)&(finfo->fd_formb_cylno(0)) 1562 - (char *)finfo; 1563 } 1564 if (fdc->state == DOSEEK || fdc->state == SEEKCOMPLETE) { 1565 blknum = (unsigned) bp->b_pblkno * DEV_BSIZE/fdblk + 1566 fd->skip/fdblk; 1567 b_cylinder = blknum / (fd->ft->sectrac * fd->ft->heads); 1568 } 1569 TRACE1("fd%d", fdu); 1570 TRACE1("[%s]", fdstates[fdc->state]); 1571 TRACE1("(0x%x)", fd->flags); 1572 untimeout(fd_turnoff, (caddr_t)fdu, fd->toffhandle); 1573 fd->toffhandle = timeout(fd_turnoff, (caddr_t)fdu, 4 * hz); 1574 switch (fdc->state) 1575 { 1576 case DEVIDLE: 1577 case FINDWORK: /* we have found new work */ 1578 fdc->retry = 0; 1579 fd->skip = 0; 1580 fdc->fd = fd; 1581 fdc->fdu = fdu; 1582 outb(fdc->baseport+FDCTL, fd->ft->trans); 1583 TRACE1("[0x%x->FDCTL]", fd->ft->trans); 1584 /*******************************************************\ 1585 * If the next drive has a motor startup pending, then * 1586 * it will start up in its own good time * 1587 \*******************************************************/ 1588 if(fd->flags & FD_MOTOR_WAIT) 1589 { 1590 fdc->state = MOTORWAIT; 1591 return(0); /* come back later */ 1592 } 1593 /*******************************************************\ 1594 * Maybe if it's not starting, it SHOULD be starting * 1595 \*******************************************************/ 1596 if (!(fd->flags & FD_MOTOR)) 1597 { 1598 fdc->state = MOTORWAIT; 1599 fd_turnon(fdu); 1600 return(0); 1601 } 1602 else /* at least make sure we are selected */ 1603 { 1604 set_motor(fdcu, fd->fdsu, TURNON); 1605 } 1606 if (fdc->flags & FDC_NEEDS_RESET) { 1607 fdc->state = RESETCTLR; 1608 fdc->flags &= ~FDC_NEEDS_RESET; 1609 } else 1610 fdc->state = DOSEEK; 1611 break; 1612 case DOSEEK: 1613 if (b_cylinder == (unsigned)fd->track) 1614 { 1615 fdc->state = SEEKCOMPLETE; 1616 break; 1617 } 1618 if (fd_cmd(fdcu, 3, NE7CMD_SEEK, 1619 fd->fdsu, b_cylinder * fd->ft->steptrac, 1620 0)) 1621 { 1622 /* 1623 * seek command not accepted, looks like 1624 * the FDC went off to the Saints... 1625 */ 1626 fdc->retry = 6; /* try a reset */ 1627 return(retrier(fdcu)); 1628 } 1629 fd->track = FD_NO_TRACK; 1630 fdc->state = SEEKWAIT; 1631 return(0); /* will return later */ 1632 case SEEKWAIT: 1633 /* allow heads to settle */ 1634 timeout(fd_pseudointr, (caddr_t)fdcu, hz / 16); 1635 fdc->state = SEEKCOMPLETE; 1636 return(0); /* will return later */ 1637 case SEEKCOMPLETE : /* SEEK DONE, START DMA */ 1638 /* Make sure seek really happened*/ 1639 if(fd->track == FD_NO_TRACK) 1640 { 1641 int descyl = b_cylinder * fd->ft->steptrac; 1642 do { 1643 /* 1644 * This might be a "ready changed" interrupt, 1645 * which cannot really happen since the 1646 * RDY pin is hardwired to + 5 volts. This 1647 * generally indicates a "bouncing" intr 1648 * line, so do one of the following: 1649 * 1650 * When running on an enhanced FDC that is 1651 * known to not go stuck after responding 1652 * with INVALID, fetch all interrupt states 1653 * until seeing either an INVALID or a 1654 * real interrupt condition. 1655 * 1656 * When running on a dumb old NE765, give 1657 * up immediately. The controller will 1658 * provide up to four dummy RC interrupt 1659 * conditions right after reset (for the 1660 * corresponding four drives), so this is 1661 * our only chance to get notice that it 1662 * was not the FDC that caused the interrupt. 1663 */ 1664 if (fd_sense_int(fdc, &st0, &cyl) 1665 == FD_NOT_VALID) 1666 return 0; 1667 if(fdc->fdct == FDC_NE765 1668 && (st0 & NE7_ST0_IC) == NE7_ST0_IC_RC) 1669 return 0; /* hope for a real intr */ 1670 } while ((st0 & NE7_ST0_IC) == NE7_ST0_IC_RC); 1671 1672 if (0 == descyl) 1673 { 1674 int failed = 0; 1675 /* 1676 * seek to cyl 0 requested; make sure we are 1677 * really there 1678 */ 1679 if (fd_sense_drive_status(fdc, &st3)) 1680 failed = 1; 1681 if ((st3 & NE7_ST3_T0) == 0) { 1682 printf( 1683 "fd%d: Seek to cyl 0, but not really there (ST3 = %b)\n", 1684 fdu, st3, NE7_ST3BITS); 1685 failed = 1; 1686 } 1687 1688 if (failed) 1689 { 1690 if(fdc->retry < 3) 1691 fdc->retry = 3; 1692 return(retrier(fdcu)); 1693 } 1694 } 1695 1696 if (cyl != descyl) 1697 { 1698 printf( 1699 "fd%d: Seek to cyl %d failed; am at cyl %d (ST0 = 0x%x)\n", 1700 fdu, descyl, cyl, st0); 1701 if (fdc->retry < 3) 1702 fdc->retry = 3; 1703 return(retrier(fdcu)); 1704 } 1705 } 1706 1707 fd->track = b_cylinder; 1708 #ifdef FDC_YE 1709 if (!(fdc->flags & FDC_PCMCIA)) 1710 #endif 1711 isa_dmastart(bp->b_flags, bp->b_data+fd->skip, 1712 format ? bp->b_bcount : fdblk, fdc->dmachan); 1713 sectrac = fd->ft->sectrac; 1714 sec = blknum % (sectrac * fd->ft->heads); 1715 head = sec / sectrac; 1716 sec = sec % sectrac + 1; 1717 fd->hddrv = ((head&1)<<2)+fdu; 1718 1719 if(format || !read) 1720 { 1721 /* make sure the drive is writable */ 1722 if(fd_sense_drive_status(fdc, &st3) != 0) 1723 { 1724 /* stuck controller? */ 1725 isa_dmadone(bp->b_flags, bp->b_data + fd->skip, 1726 format ? bp->b_bcount : fdblk, 1727 fdc->dmachan); 1728 fdc->retry = 6; /* reset the beast */ 1729 return(retrier(fdcu)); 1730 } 1731 if(st3 & NE7_ST3_WP) 1732 { 1733 /* 1734 * XXX YES! this is ugly. 1735 * in order to force the current operation 1736 * to fail, we will have to fake an FDC 1737 * error - all error handling is done 1738 * by the retrier() 1739 */ 1740 fdc->status[0] = NE7_ST0_IC_AT; 1741 fdc->status[1] = NE7_ST1_NW; 1742 fdc->status[2] = 0; 1743 fdc->status[3] = fd->track; 1744 fdc->status[4] = head; 1745 fdc->status[5] = sec; 1746 fdc->retry = 8; /* break out immediately */ 1747 fdc->state = IOTIMEDOUT; /* not really... */ 1748 return (1); 1749 } 1750 } 1751 1752 if(format) 1753 { 1754 #ifdef FDC_YE 1755 if (fdc->flags & FDC_PCMCIA) 1756 (void)fdcpio(fdcu,bp->b_flags, 1757 bp->b_data+fd->skip, 1758 bp->b_bcount); 1759 #endif 1760 /* formatting */ 1761 if(fd_cmd(fdcu, 6, 1762 NE7CMD_FORMAT, 1763 head << 2 | fdu, 1764 finfo->fd_formb_secshift, 1765 finfo->fd_formb_nsecs, 1766 finfo->fd_formb_gaplen, 1767 finfo->fd_formb_fillbyte, 1768 0)) 1769 { 1770 /* controller fell over */ 1771 isa_dmadone(bp->b_flags, bp->b_data + fd->skip, 1772 format ? bp->b_bcount : fdblk, 1773 fdc->dmachan); 1774 fdc->retry = 6; 1775 return(retrier(fdcu)); 1776 } 1777 } 1778 else 1779 { 1780 #ifdef FDC_YE 1781 if (fdc->flags & FDC_PCMCIA) { 1782 /* 1783 * this seems to be necessary even when 1784 * reading data 1785 */ 1786 SET_BCDR(1,fdblk,fdc->baseport); 1787 1788 /* 1789 * perform the write pseudo-DMA before 1790 * the WRITE command is sent 1791 */ 1792 if (!read) 1793 (void)fdcpio(fdcu,bp->b_flags, 1794 bp->b_data+fd->skip, 1795 fdblk); 1796 } 1797 #endif 1798 if (fd_cmd(fdcu, 9, 1799 (read ? NE7CMD_READ : NE7CMD_WRITE), 1800 head << 2 | fdu, /* head & unit */ 1801 fd->track, /* track */ 1802 head, 1803 sec, /* sector + 1 */ 1804 fd->ft->secsize, /* sector size */ 1805 sectrac, /* sectors/track */ 1806 fd->ft->gap, /* gap size */ 1807 fd->ft->datalen, /* data length */ 1808 0)) 1809 { 1810 /* the beast is sleeping again */ 1811 isa_dmadone(bp->b_flags, bp->b_data + fd->skip, 1812 format ? bp->b_bcount : fdblk, 1813 fdc->dmachan); 1814 fdc->retry = 6; 1815 return(retrier(fdcu)); 1816 } 1817 } 1818 #ifdef FDC_YE 1819 if (fdc->flags & FDC_PCMCIA) 1820 /* 1821 * if this is a read, then simply await interrupt 1822 * before performing PIO 1823 */ 1824 if (read && !fdcpio(fdcu,bp->b_flags, 1825 bp->b_data+fd->skip,fdblk)) { 1826 fd->tohandle = timeout(fd_iotimeout, 1827 (caddr_t)fdcu, hz); 1828 return(0); /* will return later */ 1829 }; 1830 1831 /* 1832 * write (or format) operation will fall through and 1833 * await completion interrupt 1834 */ 1835 #endif 1836 fdc->state = IOCOMPLETE; 1837 fd->tohandle = timeout(fd_iotimeout, (caddr_t)fdcu, hz); 1838 return(0); /* will return later */ 1839 #ifdef FDC_YE 1840 case PIOREAD: 1841 /* 1842 * actually perform the PIO read. The IOCOMPLETE case 1843 * removes the timeout for us. 1844 */ 1845 (void)fdcpio(fdcu,bp->b_flags,bp->b_data+fd->skip,fdblk); 1846 fdc->state = IOCOMPLETE; 1847 /* FALLTHROUGH */ 1848 #endif 1849 case IOCOMPLETE: /* IO DONE, post-analyze */ 1850 untimeout(fd_iotimeout, (caddr_t)fdcu, fd->tohandle); 1851 1852 if (fd_read_status(fdc, fd->fdsu)) 1853 { 1854 isa_dmadone(bp->b_flags, bp->b_data + fd->skip, 1855 format ? bp->b_bcount : fdblk, 1856 fdc->dmachan); 1857 if (fdc->retry < 6) 1858 fdc->retry = 6; /* force a reset */ 1859 return retrier(fdcu); 1860 } 1861 1862 fdc->state = IOTIMEDOUT; 1863 1864 /* FALLTHROUGH */ 1865 1866 case IOTIMEDOUT: 1867 #ifdef FDC_YE 1868 if (!(fdc->flags & FDC_PCMCIA)) 1869 #endif 1870 isa_dmadone(bp->b_flags, bp->b_data + fd->skip, 1871 format ? bp->b_bcount : fdblk, fdc->dmachan); 1872 if (fdc->status[0] & NE7_ST0_IC) 1873 { 1874 if ((fdc->status[0] & NE7_ST0_IC) == NE7_ST0_IC_AT 1875 && fdc->status[1] & NE7_ST1_OR) { 1876 /* 1877 * DMA overrun. Someone hogged the bus 1878 * and didn't release it in time for the 1879 * next FDC transfer. 1880 * Just restart it, don't increment retry 1881 * count. (vak) 1882 */ 1883 fdc->state = SEEKCOMPLETE; 1884 return (1); 1885 } 1886 else if((fdc->status[0] & NE7_ST0_IC) == NE7_ST0_IC_IV 1887 && fdc->retry < 6) 1888 fdc->retry = 6; /* force a reset */ 1889 else if((fdc->status[0] & NE7_ST0_IC) == NE7_ST0_IC_AT 1890 && fdc->status[2] & NE7_ST2_WC 1891 && fdc->retry < 3) 1892 fdc->retry = 3; /* force recalibrate */ 1893 return(retrier(fdcu)); 1894 } 1895 /* All OK */ 1896 fd->skip += fdblk; 1897 if (!format && fd->skip < bp->b_bcount - bp->b_resid) 1898 { 1899 /* set up next transfer */ 1900 fdc->state = DOSEEK; 1901 } 1902 else 1903 { 1904 /* ALL DONE */ 1905 fd->skip = 0; 1906 fdc->bp = NULL; 1907 /* Tell devstat we have finished with the transaction */ 1908 devstat_end_transaction(&fd->device_stats, 1909 bp->b_bcount - bp->b_resid, 1910 DEVSTAT_TAG_NONE, 1911 (bp->b_flags & B_READ) ? 1912 DEVSTAT_READ : DEVSTAT_WRITE); 1913 biodone(bp); 1914 fdc->fd = (fd_p) 0; 1915 fdc->fdu = -1; 1916 fdc->state = FINDWORK; 1917 } 1918 return(1); 1919 case RESETCTLR: 1920 fdc_reset(fdc); 1921 fdc->retry++; 1922 fdc->state = RESETCOMPLETE; 1923 return (0); 1924 case RESETCOMPLETE: 1925 /* 1926 * Discard all the results from the reset so that they 1927 * can't cause an unexpected interrupt later. 1928 */ 1929 for (i = 0; i < 4; i++) 1930 (void)fd_sense_int(fdc, &st0, &cyl); 1931 fdc->state = STARTRECAL; 1932 /* Fall through. */ 1933 case STARTRECAL: 1934 if(fd_cmd(fdcu, 1935 2, NE7CMD_RECAL, fdu, 1936 0)) /* Recalibrate Function */ 1937 { 1938 /* arrgl */ 1939 fdc->retry = 6; 1940 return(retrier(fdcu)); 1941 } 1942 fdc->state = RECALWAIT; 1943 return(0); /* will return later */ 1944 case RECALWAIT: 1945 /* allow heads to settle */ 1946 timeout(fd_pseudointr, (caddr_t)fdcu, hz / 8); 1947 fdc->state = RECALCOMPLETE; 1948 return(0); /* will return later */ 1949 case RECALCOMPLETE: 1950 do { 1951 /* 1952 * See SEEKCOMPLETE for a comment on this: 1953 */ 1954 if (fd_sense_int(fdc, &st0, &cyl) == FD_NOT_VALID) 1955 return 0; 1956 if(fdc->fdct == FDC_NE765 1957 && (st0 & NE7_ST0_IC) == NE7_ST0_IC_RC) 1958 return 0; /* hope for a real intr */ 1959 } while ((st0 & NE7_ST0_IC) == NE7_ST0_IC_RC); 1960 if ((st0 & NE7_ST0_IC) != NE7_ST0_IC_NT || cyl != 0) 1961 { 1962 if(fdc->retry > 3) 1963 /* 1964 * a recalibrate from beyond cylinder 77 1965 * will "fail" due to the FDC limitations; 1966 * since people used to complain much about 1967 * the failure message, try not logging 1968 * this one if it seems to be the first 1969 * time in a line 1970 */ 1971 printf("fd%d: recal failed ST0 %b cyl %d\n", 1972 fdu, st0, NE7_ST0BITS, cyl); 1973 if(fdc->retry < 3) fdc->retry = 3; 1974 return(retrier(fdcu)); 1975 } 1976 fd->track = 0; 1977 /* Seek (probably) necessary */ 1978 fdc->state = DOSEEK; 1979 return(1); /* will return immediatly */ 1980 case MOTORWAIT: 1981 if(fd->flags & FD_MOTOR_WAIT) 1982 { 1983 return(0); /* time's not up yet */ 1984 } 1985 if (fdc->flags & FDC_NEEDS_RESET) { 1986 fdc->state = RESETCTLR; 1987 fdc->flags &= ~FDC_NEEDS_RESET; 1988 } else { 1989 /* 1990 * If all motors were off, then the controller was 1991 * reset, so it has lost track of the current 1992 * cylinder. Recalibrate to handle this case. 1993 */ 1994 fdc->state = STARTRECAL; 1995 } 1996 return(1); /* will return immediatly */ 1997 default: 1998 printf("fdc%d: Unexpected FD int->", fdcu); 1999 if (fd_read_status(fdc, fd->fdsu) == 0) 2000 printf("FDC status :%x %x %x %x %x %x %x ", 2001 fdc->status[0], 2002 fdc->status[1], 2003 fdc->status[2], 2004 fdc->status[3], 2005 fdc->status[4], 2006 fdc->status[5], 2007 fdc->status[6] ); 2008 else 2009 printf("No status available "); 2010 if (fd_sense_int(fdc, &st0, &cyl) != 0) 2011 { 2012 printf("[controller is dead now]\n"); 2013 return(0); 2014 } 2015 printf("ST0 = %x, PCN = %x\n", st0, cyl); 2016 return(0); 2017 } 2018 /*XXX confusing: some branches return immediately, others end up here*/ 2019 return(1); /* Come back immediatly to new state */ 2020 } 2021 2022 static int 2023 retrier(fdcu) 2024 fdcu_t fdcu; 2025 { 2026 fdc_p fdc = fdc_data + fdcu; 2027 register struct buf *bp; 2028 2029 bp = fdc->bp; 2030 2031 if(fd_data[FDUNIT(minor(bp->b_dev))].options & FDOPT_NORETRY) 2032 goto fail; 2033 switch(fdc->retry) 2034 { 2035 case 0: case 1: case 2: 2036 fdc->state = SEEKCOMPLETE; 2037 break; 2038 case 3: case 4: case 5: 2039 fdc->state = STARTRECAL; 2040 break; 2041 case 6: 2042 fdc->state = RESETCTLR; 2043 break; 2044 case 7: 2045 break; 2046 default: 2047 fail: 2048 { 2049 dev_t sav_b_dev = bp->b_dev; 2050 /* Trick diskerr */ 2051 bp->b_dev = makedev(major(bp->b_dev), 2052 (FDUNIT(minor(bp->b_dev))<<3)|RAW_PART); 2053 diskerr(bp, "fd", "hard error", LOG_PRINTF, 2054 fdc->fd->skip / DEV_BSIZE, 2055 (struct disklabel *)NULL); 2056 bp->b_dev = sav_b_dev; 2057 if (fdc->flags & FDC_STAT_VALID) 2058 { 2059 printf( 2060 " (ST0 %b ST1 %b ST2 %b cyl %u hd %u sec %u)\n", 2061 fdc->status[0], NE7_ST0BITS, 2062 fdc->status[1], NE7_ST1BITS, 2063 fdc->status[2], NE7_ST2BITS, 2064 fdc->status[3], fdc->status[4], 2065 fdc->status[5]); 2066 } 2067 else 2068 printf(" (No status)\n"); 2069 } 2070 bp->b_flags |= B_ERROR; 2071 bp->b_error = EIO; 2072 bp->b_resid += bp->b_bcount - fdc->fd->skip; 2073 fdc->bp = NULL; 2074 2075 /* Tell devstat we have finished with the transaction */ 2076 devstat_end_transaction(&fdc->fd->device_stats, 2077 bp->b_bcount - bp->b_resid, 2078 DEVSTAT_TAG_NONE, 2079 (bp->b_flags & B_READ) ? DEVSTAT_READ : 2080 DEVSTAT_WRITE); 2081 fdc->fd->skip = 0; 2082 biodone(bp); 2083 fdc->state = FINDWORK; 2084 fdc->flags |= FDC_NEEDS_RESET; 2085 fdc->fd = (fd_p) 0; 2086 fdc->fdu = -1; 2087 return(1); 2088 } 2089 fdc->retry++; 2090 return(1); 2091 } 2092 2093 static int 2094 fdformat(dev, finfo, p) 2095 dev_t dev; 2096 struct fd_formb *finfo; 2097 struct proc *p; 2098 { 2099 fdu_t fdu; 2100 fd_p fd; 2101 2102 struct buf *bp; 2103 int rv = 0, s; 2104 size_t fdblk; 2105 2106 fdu = FDUNIT(minor(dev)); 2107 fd = &fd_data[fdu]; 2108 fdblk = 128 << fd->ft->secsize; 2109 2110 /* set up a buffer header for fdstrategy() */ 2111 bp = (struct buf *)malloc(sizeof(struct buf), M_TEMP, M_NOWAIT); 2112 if(bp == 0) 2113 return ENOBUFS; 2114 /* 2115 * keep the process from being swapped 2116 */ 2117 PHOLD(p); 2118 bzero((void *)bp, sizeof(struct buf)); 2119 bp->b_flags = B_BUSY | B_PHYS | B_FORMAT; 2120 bp->b_proc = p; 2121 2122 /* 2123 * calculate a fake blkno, so fdstrategy() would initiate a 2124 * seek to the requested cylinder 2125 */ 2126 bp->b_blkno = (finfo->cyl * (fd->ft->sectrac * fd->ft->heads) 2127 + finfo->head * fd->ft->sectrac) * fdblk / DEV_BSIZE; 2128 2129 bp->b_bcount = sizeof(struct fd_idfield_data) * finfo->fd_formb_nsecs; 2130 bp->b_data = (caddr_t)finfo; 2131 2132 /* now do the format */ 2133 bp->b_dev = dev; 2134 fdstrategy(bp); 2135 2136 /* ...and wait for it to complete */ 2137 s = splbio(); 2138 while(!(bp->b_flags & B_DONE)) 2139 { 2140 rv = tsleep((caddr_t)bp, PRIBIO, "fdform", 20 * hz); 2141 if(rv == EWOULDBLOCK) 2142 break; 2143 } 2144 splx(s); 2145 2146 if(rv == EWOULDBLOCK) { 2147 /* timed out */ 2148 rv = EIO; 2149 biodone(bp); 2150 } 2151 if(bp->b_flags & B_ERROR) 2152 rv = bp->b_error; 2153 /* 2154 * allow the process to be swapped 2155 */ 2156 PRELE(p); 2157 free(bp, M_TEMP); 2158 return rv; 2159 } 2160 2161 /* 2162 * TODO: don't allocate buffer on stack. 2163 */ 2164 2165 static int 2166 fdioctl(dev, cmd, addr, flag, p) 2167 dev_t dev; 2168 u_long cmd; 2169 caddr_t addr; 2170 int flag; 2171 struct proc *p; 2172 { 2173 fdu_t fdu = FDUNIT(minor(dev)); 2174 fd_p fd = &fd_data[fdu]; 2175 size_t fdblk; 2176 2177 struct fd_type *fdt; 2178 struct disklabel *dl; 2179 char buffer[DEV_BSIZE]; 2180 int error = 0; 2181 2182 fdblk = 128 << fd->ft->secsize; 2183 2184 switch (cmd) 2185 { 2186 case DIOCGDINFO: 2187 bzero(buffer, sizeof (buffer)); 2188 dl = (struct disklabel *)buffer; 2189 dl->d_secsize = fdblk; 2190 fdt = fd_data[FDUNIT(minor(dev))].ft; 2191 dl->d_secpercyl = fdt->size / fdt->tracks; 2192 dl->d_type = DTYPE_FLOPPY; 2193 2194 if (readdisklabel(dkmodpart(dev, RAW_PART), fdstrategy, dl) 2195 == NULL) 2196 error = 0; 2197 else 2198 error = EINVAL; 2199 2200 *(struct disklabel *)addr = *dl; 2201 break; 2202 2203 case DIOCSDINFO: 2204 if ((flag & FWRITE) == 0) 2205 error = EBADF; 2206 break; 2207 2208 case DIOCWLABEL: 2209 if ((flag & FWRITE) == 0) 2210 error = EBADF; 2211 break; 2212 2213 case DIOCWDINFO: 2214 if ((flag & FWRITE) == 0) 2215 { 2216 error = EBADF; 2217 break; 2218 } 2219 2220 dl = (struct disklabel *)addr; 2221 2222 if ((error = setdisklabel((struct disklabel *)buffer, dl, 2223 (u_long)0)) != 0) 2224 break; 2225 2226 error = writedisklabel(dev, fdstrategy, 2227 (struct disklabel *)buffer); 2228 break; 2229 case FD_FORM: 2230 if((flag & FWRITE) == 0) 2231 error = EBADF; /* must be opened for writing */ 2232 else if(((struct fd_formb *)addr)->format_version != 2233 FD_FORMAT_VERSION) 2234 error = EINVAL; /* wrong version of formatting prog */ 2235 else 2236 error = fdformat(dev, (struct fd_formb *)addr, p); 2237 break; 2238 2239 case FD_GTYPE: /* get drive type */ 2240 *(struct fd_type *)addr = *fd->ft; 2241 break; 2242 2243 case FD_STYPE: /* set drive type */ 2244 /* this is considered harmful; only allow for superuser */ 2245 if(suser(p->p_ucred, &p->p_acflag) != 0) 2246 return EPERM; 2247 *fd->ft = *(struct fd_type *)addr; 2248 break; 2249 2250 case FD_GOPTS: /* get drive options */ 2251 *(int *)addr = fd->options; 2252 break; 2253 2254 case FD_SOPTS: /* set drive options */ 2255 fd->options = *(int *)addr; 2256 break; 2257 2258 default: 2259 error = ENOTTY; 2260 break; 2261 } 2262 return (error); 2263 } 2264 2265 2266 static fd_devsw_installed = 0; 2267 2268 static void fd_drvinit(void *notused ) 2269 { 2270 2271 if( ! fd_devsw_installed ) { 2272 cdevsw_add_generic(BDEV_MAJOR,CDEV_MAJOR, &fd_cdevsw); 2273 fd_devsw_installed = 1; 2274 } 2275 } 2276 2277 SYSINIT(fddev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,fd_drvinit,NULL) 2278 2279 2280 #endif 2281 2282 /* 2283 * Hello emacs, these are the 2284 * Local Variables: 2285 * c-indent-level: 8 2286 * c-continued-statement-offset: 8 2287 * c-continued-brace-offset: 0 2288 * c-brace-offset: -8 2289 * c-brace-imaginary-offset: 0 2290 * c-argdecl-indent: 8 2291 * c-label-offset: -8 2292 * c++-hanging-braces: 1 2293 * c++-access-specifier-offset: -8 2294 * c++-empty-arglist-indent: 8 2295 * c++-friend-offset: 0 2296 * End: 2297 */ 2298