1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 /* 26 * Copyright 2012 Garrett D'Amore <garrett@damore.org>. All rights reserved. 27 */ 28 29 30 /* 31 * Floppy Disk Controller Driver 32 * 33 * for the standard PC architecture using the Intel 8272A fdc. 34 * Note that motor control and drive select use a latch external 35 * to the fdc. 36 * 37 * This driver is EISA capable, and uses DMA buffer chaining if available. 38 * If this driver is attached to the ISA bus nexus (or if the EISA bus driver 39 * does not support DMA buffer chaining), then the bus driver must ensure 40 * that dma mapping (breakup) and dma engine requests are properly degraded. 41 */ 42 43 /* 44 * hack for bugid 1160621: 45 * workaround compiler optimization bug by turning on DEBUG 46 */ 47 #ifndef DEBUG 48 #define DEBUG 1 49 #endif 50 51 #include <sys/param.h> 52 #include <sys/buf.h> 53 #include <sys/ioctl.h> 54 #include <sys/uio.h> 55 #include <sys/open.h> 56 #include <sys/conf.h> 57 #include <sys/file.h> 58 #include <sys/cmn_err.h> 59 #include <sys/note.h> 60 #include <sys/debug.h> 61 #include <sys/kmem.h> 62 #include <sys/stat.h> 63 64 #include <sys/autoconf.h> 65 #include <sys/dkio.h> 66 #include <sys/vtoc.h> 67 #include <sys/kstat.h> 68 69 #include <sys/fdio.h> 70 #include <sys/fdc.h> 71 #include <sys/i8272A.h> 72 #include <sys/fd_debug.h> 73 #include <sys/promif.h> 74 #include <sys/ddi.h> 75 #include <sys/sunddi.h> 76 77 /* 78 * bss (uninitialized data) 79 */ 80 static void *fdc_state_head; /* opaque handle top of state structs */ 81 static ddi_dma_attr_t fdc_dma_attr; 82 static ddi_device_acc_attr_t fdc_accattr = {DDI_DEVICE_ATTR_V0, 83 DDI_STRUCTURE_LE_ACC, DDI_STRICTORDER_ACC}; 84 85 /* 86 * Local static data 87 */ 88 #define OURUN_TRIES 12 89 static uchar_t rwretry = 4; 90 static uchar_t skretry = 3; 91 static uchar_t configurecmd[4] = {FO_CNFG, 0, 0x0F, 0}; 92 static uchar_t recalcmd[2] = {FO_RECAL, 0}; 93 static uchar_t senseintcmd = FO_SINT; 94 95 /* 96 * error handling 97 * 98 * for debugging, set rwretry and skretry = 1 99 * set fcerrlevel to 1 100 * set fcerrmask to 224 or 644 101 * 102 * after debug, set rwretry to 4, skretry to 3, and fcerrlevel to 5 103 * set fcerrmask to FDEM_ALL 104 * or remove the define DEBUG 105 */ 106 static uint_t fcerrmask = FDEM_ALL; 107 static int fcerrlevel = 6; 108 109 #define KIOIP KSTAT_INTR_PTR(fcp->c_intrstat) 110 111 112 static xlate_tbl_t drate_mfm[] = { 113 { 250, 2}, 114 { 300, 1}, 115 { 417, 0}, 116 { 500, 0}, 117 { 1000, 3}, 118 { 0, 0} 119 }; 120 121 static xlate_tbl_t sector_size[] = { 122 { 256, 1}, 123 { 512, 2}, 124 { 1024, 3}, 125 { 0, 2} 126 }; 127 128 static xlate_tbl_t motor_onbits[] = { 129 { 0, 0x10}, 130 { 1, 0x20}, 131 { 2, 0x40}, 132 { 3, 0x80}, 133 { 0, 0x80} 134 }; 135 136 static xlate_tbl_t step_rate[] = { 137 { 10, 0xF0}, /* for 500K data rate */ 138 { 20, 0xE0}, 139 { 30, 0xD0}, 140 { 40, 0xC0}, 141 { 50, 0xB0}, 142 { 60, 0xA0}, 143 { 70, 0x90}, 144 { 80, 0x80}, 145 { 90, 0x70}, 146 { 100, 0x60}, 147 { 110, 0x50}, 148 { 120, 0x40}, 149 { 130, 0x30}, 150 { 140, 0x20}, 151 { 150, 0x10}, 152 { 160, 0x00}, 153 { 0, 0x00} 154 }; 155 156 #ifdef notdef 157 static xlate_tbl_t head_unld[] = { 158 { 16, 0x1}, /* for 500K data rate */ 159 { 32, 0x2}, 160 { 48, 0x3}, 161 { 64, 0x4}, 162 { 80, 0x5}, 163 { 96, 0x6}, 164 { 112, 0x7}, 165 { 128, 0x8}, 166 { 144, 0x9}, 167 { 160, 0xA}, 168 { 176, 0xB}, 169 { 192, 0xC}, 170 { 208, 0xD}, 171 { 224, 0xE}, 172 { 240, 0xF}, 173 { 256, 0x0}, 174 { 0, 0x0} 175 }; 176 #endif 177 178 static struct fdcmdinfo { 179 char *cmdname; /* command name */ 180 uchar_t ncmdbytes; /* number of bytes of command */ 181 uchar_t nrsltbytes; /* number of bytes in result */ 182 uchar_t cmdtype; /* characteristics */ 183 } fdcmds[] = { 184 "", 0, 0, 0, /* - */ 185 "", 0, 0, 0, /* - */ 186 "read_track", 9, 7, 1, /* 2 */ 187 "specify", 3, 0, 3, /* 3 */ 188 "sense_drv_status", 2, 1, 3, /* 4 */ 189 "write", 9, 7, 1, /* 5 */ 190 "read", 9, 7, 1, /* 6 */ 191 "recalibrate", 2, 0, 2, /* 7 */ 192 "sense_int_status", 1, 2, 3, /* 8 */ 193 "write_del", 9, 7, 1, /* 9 */ 194 "read_id", 2, 7, 2, /* A */ 195 "", 0, 0, 0, /* - */ 196 "read_del", 9, 7, 1, /* C */ 197 "format_track", 10, 7, 1, /* D */ 198 "dump_reg", 1, 10, 4, /* E */ 199 "seek", 3, 0, 2, /* F */ 200 "version", 1, 1, 3, /* 10 */ 201 "", 0, 0, 0, /* - */ 202 "perp_mode", 2, 0, 3, /* 12 */ 203 "configure", 4, 0, 4, /* 13 */ 204 /* relative seek */ 205 }; 206 207 208 static int 209 fdc_bus_ctl(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *, void *); 210 static int get_ioaddr(dev_info_t *dip, int *ioaddr); 211 static int get_unit(dev_info_t *dip, int *cntrl_num); 212 213 struct bus_ops fdc_bus_ops = { 214 BUSO_REV, 215 nullbusmap, 216 0, /* ddi_intrspec_t (*bus_get_intrspec)(); */ 217 0, /* int (*bus_add_intrspec)(); */ 218 0, /* void (*bus_remove_intrspec)(); */ 219 i_ddi_map_fault, 220 0, 221 ddi_dma_allochdl, 222 ddi_dma_freehdl, 223 ddi_dma_bindhdl, 224 ddi_dma_unbindhdl, 225 ddi_dma_flush, 226 ddi_dma_win, 227 ddi_dma_mctl, 228 fdc_bus_ctl, 229 ddi_bus_prop_op, 230 }; 231 232 static int fdc_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **); 233 static int fdc_probe(dev_info_t *); 234 static int fdc_attach(dev_info_t *, ddi_attach_cmd_t); 235 static int fdc_detach(dev_info_t *, ddi_detach_cmd_t); 236 static int fdc_quiesce(dev_info_t *); 237 static int fdc_enhance_probe(struct fdcntlr *fcp); 238 239 struct dev_ops fdc_ops = { 240 DEVO_REV, /* devo_rev, */ 241 0, /* refcnt */ 242 fdc_getinfo, /* getinfo */ 243 nulldev, /* identify */ 244 fdc_probe, /* probe */ 245 fdc_attach, /* attach */ 246 fdc_detach, /* detach */ 247 nodev, /* reset */ 248 (struct cb_ops *)0, /* driver operations */ 249 &fdc_bus_ops, /* bus operations */ 250 NULL, /* power */ 251 fdc_quiesce, /* quiesce */ 252 }; 253 254 /* 255 * This is the loadable module wrapper. 256 */ 257 #include <sys/modctl.h> 258 259 extern struct mod_ops mod_driverops; 260 261 static struct modldrv modldrv = { 262 &mod_driverops, /* Type of module. This one is a driver */ 263 "Floppy Controller", /* Name of the module. */ 264 &fdc_ops, /* Driver ops vector */ 265 }; 266 267 static struct modlinkage modlinkage = { 268 MODREV_1, (void *)&modldrv, NULL 269 }; 270 271 int 272 _init(void) 273 { 274 int retval; 275 276 if ((retval = ddi_soft_state_init(&fdc_state_head, 277 sizeof (struct fdcntlr) + NFDUN * sizeof (struct fcu_obj), 0)) != 0) 278 return (retval); 279 280 if ((retval = mod_install(&modlinkage)) != 0) 281 ddi_soft_state_fini(&fdc_state_head); 282 return (retval); 283 } 284 285 int 286 _fini(void) 287 { 288 int retval; 289 290 if ((retval = mod_remove(&modlinkage)) != 0) 291 return (retval); 292 ddi_soft_state_fini(&fdc_state_head); 293 return (retval); 294 } 295 296 int 297 _info(struct modinfo *modinfop) 298 { 299 return (mod_info(&modlinkage, modinfop)); 300 } 301 302 303 int fdc_abort(struct fcu_obj *); 304 int fdc_dkinfo(struct fcu_obj *, struct dk_cinfo *); 305 int fdc_select(struct fcu_obj *, int, int); 306 int fdgetchng(struct fcu_obj *, int); 307 int fdresetchng(struct fcu_obj *, int); 308 int fdrecalseek(struct fcu_obj *, int, int, int); 309 int fdrw(struct fcu_obj *, int, int, int, int, int, caddr_t, uint_t); 310 int fdtrkformat(struct fcu_obj *, int, int, int, int); 311 int fdrawioctl(struct fcu_obj *, int, caddr_t); 312 313 static struct fcobjops fdc_iops = { 314 fdc_abort, /* controller abort */ 315 fdc_dkinfo, /* get disk controller info */ 316 317 fdc_select, /* select / deselect unit */ 318 fdgetchng, /* get media change */ 319 fdresetchng, /* reset media change */ 320 fdrecalseek, /* recal / seek */ 321 NULL, /* read /write request (UNUSED) */ 322 fdrw, /* read /write sector */ 323 fdtrkformat, /* format track */ 324 fdrawioctl /* raw ioctl */ 325 }; 326 327 328 /* 329 * Function prototypes 330 */ 331 void encode(xlate_tbl_t *tablep, int val, uchar_t *rcode); 332 int decode(xlate_tbl_t *, int, int *); 333 static int fdc_propinit1(struct fdcntlr *, int); 334 static void fdc_propinit2(struct fdcntlr *); 335 void fdcquiesce(struct fdcntlr *); 336 int fdcsense_chng(struct fdcntlr *, int); 337 int fdcsense_drv(struct fdcntlr *, int); 338 int fdcsense_int(struct fdcntlr *, int *, int *); 339 int fdcspecify(struct fdcntlr *, int, int, int); 340 int fdcspdchange(struct fdcntlr *, struct fcu_obj *, int); 341 static int fdc_exec(struct fdcntlr *, int, int); 342 int fdcheckdisk(struct fdcntlr *, int); 343 static uint_t fdc_intr(caddr_t arg); 344 static void fdwatch(void *arg); 345 static void fdmotort(void *arg); 346 static int fdrecover(struct fdcntlr *); 347 static int fdc_motorsm(struct fcu_obj *, int, int); 348 static int fdc_statemach(struct fdcntlr *); 349 int fdc_docmd(struct fdcntlr *, uchar_t *, uchar_t); 350 int fdc_result(struct fdcntlr *, uchar_t *, uchar_t); 351 352 353 static int 354 fdc_bus_ctl(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t ctlop, 355 void *arg, void *result) 356 { 357 struct fdcntlr *fcp; 358 struct fcu_obj *fjp; 359 360 _NOTE(ARGUNUSED(result)); 361 362 FCERRPRINT(FDEP_L0, FDEM_ATTA, 363 (CE_CONT, "fdc_bus_ctl: cmd= %x\n", ctlop)); 364 365 if ((fcp = ddi_get_driver_private(dip)) == NULL) 366 return (DDI_FAILURE); 367 368 switch (ctlop) { 369 370 case DDI_CTLOPS_REPORTDEV: 371 cmn_err(CE_CONT, "?%s%d at %s%d\n", 372 ddi_get_name(rdip), ddi_get_instance(rdip), 373 ddi_get_name(dip), ddi_get_instance(dip)); 374 FCERRPRINT(FDEP_L3, FDEM_ATTA, 375 (CE_WARN, "fdc_bus_ctl: report %s%d at %s%d", 376 ddi_get_name(rdip), ddi_get_instance(rdip), 377 ddi_get_name(dip), ddi_get_instance(dip))); 378 return (DDI_SUCCESS); 379 380 case DDI_CTLOPS_INITCHILD: 381 { 382 dev_info_t *udip = (dev_info_t *)arg; 383 int cntlr; 384 int len; 385 int unit; 386 char name[MAXNAMELEN]; 387 388 FCERRPRINT(FDEP_L3, FDEM_ATTA, 389 (CE_WARN, "fdc_bus_ctl: init child 0x%p", (void*)udip)); 390 cntlr = fcp->c_number; 391 392 len = sizeof (unit); 393 if (ddi_prop_op(DDI_DEV_T_ANY, udip, PROP_LEN_AND_VAL_BUF, 394 DDI_PROP_DONTPASS, "unit", (caddr_t)&unit, &len) 395 != DDI_PROP_SUCCESS || 396 cntlr != FDCTLR(unit) || 397 (fcp->c_unit[FDUNIT(unit)])->fj_dip) 398 return (DDI_NOT_WELL_FORMED); 399 400 (void) sprintf(name, "%d,%d", cntlr, FDUNIT(unit)); 401 ddi_set_name_addr(udip, name); 402 403 fjp = fcp->c_unit[FDUNIT(unit)]; 404 fjp->fj_unit = unit; 405 fjp->fj_dip = udip; 406 fjp->fj_ops = &fdc_iops; 407 fjp->fj_fdc = fcp; 408 fjp->fj_iblock = &fcp->c_iblock; 409 410 ddi_set_driver_private(udip, fjp); 411 412 return (DDI_SUCCESS); 413 } 414 case DDI_CTLOPS_UNINITCHILD: 415 { 416 dev_info_t *udip = (dev_info_t *)arg; 417 418 FCERRPRINT(FDEP_L3, FDEM_ATTA, 419 (CE_WARN, "fdc_bus_ctl: uninit child 0x%p", (void *)udip)); 420 fjp = ddi_get_driver_private(udip); 421 ddi_set_driver_private(udip, NULL); 422 fjp->fj_dip = NULL; 423 ddi_set_name_addr(udip, NULL); 424 return (DDI_SUCCESS); 425 } 426 default: 427 return (DDI_FAILURE); 428 } 429 } 430 431 static int 432 fdc_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result) 433 { 434 struct fdcntlr *fcp; 435 int rval; 436 437 _NOTE(ARGUNUSED(dip)); 438 439 switch (cmd) { 440 case DDI_INFO_DEVT2DEVINFO: 441 if (fcp = ddi_get_soft_state(fdc_state_head, (dev_t)arg)) { 442 *result = fcp->c_dip; 443 rval = DDI_SUCCESS; 444 break; 445 } else { 446 rval = DDI_FAILURE; 447 break; 448 } 449 case DDI_INFO_DEVT2INSTANCE: 450 *result = (void *)(uintptr_t)getminor((dev_t)arg); 451 rval = DDI_SUCCESS; 452 break; 453 default: 454 rval = DDI_FAILURE; 455 } 456 return (rval); 457 } 458 459 static int 460 fdc_probe(dev_info_t *dip) 461 { 462 int debug[2]; 463 int ioaddr; 464 int len; 465 uchar_t stat; 466 467 len = sizeof (debug); 468 if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF, 469 DDI_PROP_DONTPASS, "debug", (caddr_t)debug, &len) == 470 DDI_PROP_SUCCESS) { 471 fcerrlevel = debug[0]; 472 fcerrmask = (uint_t)debug[1]; 473 } 474 475 FCERRPRINT(FDEP_L3, FDEM_ATTA, (CE_WARN, "fdc_probe: dip %p", 476 (void*)dip)); 477 478 if (get_ioaddr(dip, &ioaddr) != DDI_SUCCESS) 479 return (DDI_PROBE_FAILURE); 480 481 stat = inb(ioaddr + FCR_MSR); 482 if ((stat & (MS_RQM | MS_DIO | MS_CB)) != MS_RQM && 483 (stat & ~MS_DIO) != MS_CB) 484 return (DDI_PROBE_FAILURE); 485 486 return (DDI_PROBE_SUCCESS); 487 } 488 489 static int 490 fdc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 491 { 492 struct fdcntlr *fcp; 493 struct fcu_obj *fjp; 494 int cntlr_num, ctlr, unit; 495 int intr_set = 0; 496 int len; 497 char name[MAXNAMELEN]; 498 499 FCERRPRINT(FDEP_L3, FDEM_ATTA, (CE_WARN, "fdc_attach: dip %p", 500 (void*)dip)); 501 502 switch (cmd) { 503 case DDI_ATTACH: 504 if (ddi_getprop 505 (DDI_DEV_T_ANY, dip, 0, "ignore-hardware-nodes", 0)) { 506 len = sizeof (cntlr_num); 507 if (ddi_prop_op(DDI_DEV_T_ANY, dip, 508 PROP_LEN_AND_VAL_BUF, DDI_PROP_DONTPASS, "unit", 509 (caddr_t)&cntlr_num, &len) != DDI_PROP_SUCCESS) { 510 FCERRPRINT(FDEP_L3, FDEM_ATTA, (CE_WARN, 511 "fdc_attach failed: dip %p", (void*)dip)); 512 return (DDI_FAILURE); 513 } 514 } else { 515 if (get_unit(dip, &cntlr_num) != DDI_SUCCESS) 516 return (DDI_FAILURE); 517 } 518 519 ctlr = ddi_get_instance(dip); 520 if (ddi_soft_state_zalloc(fdc_state_head, ctlr) != 0) 521 return (DDI_FAILURE); 522 fcp = ddi_get_soft_state(fdc_state_head, ctlr); 523 524 for (unit = 0, fjp = (struct fcu_obj *)(fcp+1); 525 unit < NFDUN; unit++) { 526 fcp->c_unit[unit] = fjp++; 527 } 528 fcp->c_dip = dip; 529 530 if (fdc_propinit1(fcp, cntlr_num) != DDI_SUCCESS) 531 goto no_attach; 532 533 /* get iblock cookie to initialize mutex used in the ISR */ 534 if (ddi_get_iblock_cookie(dip, (uint_t)0, &fcp->c_iblock) != 535 DDI_SUCCESS) { 536 cmn_err(CE_WARN, 537 "fdc_attach: cannot get iblock cookie"); 538 goto no_attach; 539 } 540 mutex_init(&fcp->c_lock, NULL, MUTEX_DRIVER, fcp->c_iblock); 541 intr_set = 1; 542 543 /* setup interrupt handler */ 544 if (ddi_add_intr(dip, (uint_t)0, NULL, 545 (ddi_idevice_cookie_t *)0, fdc_intr, (caddr_t)fcp) != 546 DDI_SUCCESS) { 547 cmn_err(CE_WARN, "fdc: cannot add intr"); 548 goto no_attach; 549 } 550 intr_set++; 551 552 /* 553 * acquire the DMA channel 554 * this assumes that the chnl is not shared; else allocate 555 * and free the chnl with each fdc request 556 */ 557 if (ddi_dmae_alloc(dip, fcp->c_dmachan, DDI_DMA_DONTWAIT, NULL) 558 != DDI_SUCCESS) { 559 cmn_err(CE_WARN, "fdc: cannot acquire dma%d", 560 fcp->c_dmachan); 561 goto no_attach; 562 } 563 (void) ddi_dmae_getattr(dip, &fdc_dma_attr); 564 fdc_dma_attr.dma_attr_align = MMU_PAGESIZE; 565 566 mutex_init(&fcp->c_dorlock, NULL, MUTEX_DRIVER, fcp->c_iblock); 567 cv_init(&fcp->c_iocv, NULL, CV_DRIVER, fcp->c_iblock); 568 sema_init(&fcp->c_selsem, 1, NULL, SEMA_DRIVER, NULL); 569 570 (void) sprintf(name, "fdc%d", ctlr); 571 fcp->c_intrstat = kstat_create("fdc", ctlr, name, 572 "controller", KSTAT_TYPE_INTR, 1, KSTAT_FLAG_PERSISTENT); 573 if (fcp->c_intrstat) { 574 kstat_install(fcp->c_intrstat); 575 } 576 577 ddi_set_driver_private(dip, fcp); 578 579 /* 580 * reset the controller 581 */ 582 sema_p(&fcp->c_selsem); 583 mutex_enter(&fcp->c_lock); 584 fcp->c_csb.csb_xstate = FXS_RESET; 585 fcp->c_flags |= FCFLG_WAITING; 586 fdcquiesce(fcp); 587 588 /* first test for mode == Model 30 */ 589 fcp->c_mode = (inb(fcp->c_regbase + FCR_SRB) & 0x1c) ? 590 FDCMODE_AT : FDCMODE_30; 591 592 while (fcp->c_flags & FCFLG_WAITING) { 593 cv_wait(&fcp->c_iocv, &fcp->c_lock); 594 } 595 mutex_exit(&fcp->c_lock); 596 sema_v(&fcp->c_selsem); 597 598 fdc_propinit2(fcp); 599 600 ddi_report_dev(dip); 601 return (DDI_SUCCESS); 602 603 case DDI_RESUME: 604 605 fcp = ddi_get_driver_private(dip); 606 607 mutex_enter(&fcp->c_lock); 608 fcp->c_suspended = B_FALSE; 609 fcp->c_csb.csb_xstate = FXS_RESET; 610 fcp->c_flags |= FCFLG_WAITING; 611 fdcquiesce(fcp); 612 613 while (fcp->c_flags & FCFLG_WAITING) { 614 cv_wait(&fcp->c_iocv, &fcp->c_lock); 615 } 616 mutex_exit(&fcp->c_lock); 617 618 /* should be good to go now */ 619 sema_v(&fcp->c_selsem); 620 621 return (DDI_SUCCESS); 622 /* break; */ 623 624 default: 625 return (DDI_FAILURE); 626 } 627 628 no_attach: 629 if (intr_set) { 630 if (intr_set > 1) 631 ddi_remove_intr(dip, 0, fcp->c_iblock); 632 mutex_destroy(&fcp->c_lock); 633 } 634 ddi_soft_state_free(fdc_state_head, cntlr_num); 635 return (DDI_FAILURE); 636 } 637 638 static int 639 fdc_propinit1(struct fdcntlr *fcp, int cntlr) 640 { 641 dev_info_t *dip; 642 int len; 643 int value; 644 645 dip = fcp->c_dip; 646 len = sizeof (value); 647 648 if (get_ioaddr(dip, &value) != DDI_SUCCESS) 649 return (DDI_FAILURE); 650 651 fcp->c_regbase = (ushort_t)value; 652 653 if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF, 654 DDI_PROP_DONTPASS, "dma-channels", (caddr_t)&value, &len) 655 != DDI_PROP_SUCCESS) { 656 cmn_err(CE_WARN, 657 "fdc_attach: Error, could not find a dma channel"); 658 return (DDI_FAILURE); 659 } 660 fcp->c_dmachan = (ushort_t)value; 661 fcp->c_number = cntlr; 662 return (DDI_SUCCESS); 663 } 664 665 static void 666 fdc_propinit2(struct fdcntlr *fcp) 667 { 668 dev_info_t *dip; 669 int ccr; 670 int len; 671 int value; 672 673 dip = fcp->c_dip; 674 len = sizeof (value); 675 676 if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF, 677 DDI_PROP_DONTPASS, "chip", (caddr_t)&value, &len) 678 == DDI_PROP_SUCCESS) 679 fcp->c_chip = value; 680 else { 681 static uchar_t perpindcmd[2] = {FO_PERP, 0}; 682 static uchar_t versioncmd = FO_VRSN; 683 uchar_t result; 684 685 fcp->c_chip = i8272A; 686 (void) fdc_docmd(fcp, &versioncmd, 1); 687 /* 688 * Ignored return. If failed, warning was issued by fdc_docmd. 689 * fdc_results retrieves the controller/drive status 690 */ 691 if (!fdc_result(fcp, &result, 1) && result == 0x90) { 692 /* 693 * try a perpendicular_mode cmd to ensure 694 * that we really have an enhanced controller 695 */ 696 if (fdc_docmd(fcp, perpindcmd, 2) || 697 fdc_docmd(fcp, configurecmd, 4)) 698 /* 699 * perpindicular_mode will be rejected by 700 * older controllers; make sure we don't hang. 701 */ 702 (void) fdc_result(fcp, &result, 1); 703 /* 704 * Ignored return. If failed, warning was 705 * issued by fdc_result. 706 */ 707 else 708 /* enhanced type controller */ 709 710 if ((fcp->c_chip = fdc_enhance_probe(fcp)) == 0) 711 /* default enhanced cntlr */ 712 fcp->c_chip = i82077; 713 } 714 (void) ddi_prop_update_int(DDI_DEV_T_NONE, dip, 715 "chip", fcp->c_chip); 716 /* 717 * Ignoring return value because, for passed arguments, only 718 * DDI_SUCCESS is returned. 719 */ 720 } 721 if (fcp->c_chip >= i82077 && fcp->c_mode == FDCMODE_30 && 722 (inb(fcp->c_regbase + FCR_DIR) & 0x70) == 0) 723 for (ccr = 0; ccr <= (FCC_NOPREC | FCC_DRATE); ccr++) { 724 /* 725 * run through all the combinations of NOPREC and 726 * datarate selection, and see if they show up in the 727 * Model 30 DIR 728 */ 729 outb(fcp->c_regbase + FCR_CCR, ccr); 730 drv_usecwait(5); 731 if ((inb(fcp->c_regbase + FCR_DIR) & 732 (FCC_NOPREC | FCC_DRATE)) != ccr) { 733 fcp->c_mode = FDCMODE_AT; 734 break; 735 } 736 } 737 else 738 fcp->c_mode = FDCMODE_AT; 739 outb(fcp->c_regbase + FCR_CCR, 0); 740 } 741 742 static int 743 fdc_enhance_probe(struct fdcntlr *fcp) 744 { 745 static uchar_t nsccmd = FO_NSC; 746 uint_t ddic; 747 int retcode = 0; 748 uchar_t result; 749 uchar_t save; 750 751 /* 752 * Try to identify the enhanced floppy controller. 753 * This is required so that we can program the DENSEL output to 754 * control 3D mode (1.0 MB, 1.6 MB and 2.0 MB unformatted capacity, 755 * 720 KB, 1.2 MB, and 1.44 MB formatted capacity) 3.5" dual-speed 756 * floppy drives. Refer to bugid 1195155. 757 */ 758 759 (void) fdc_docmd(fcp, &nsccmd, 1); 760 /* 761 * Ignored return. If failed, warning was issued by fdc_docmd. 762 * fdc_results retrieves the controller/drive status 763 */ 764 if (!fdc_result(fcp, &result, 1) && result != S0_IVCMD) { 765 /* 766 * only enhanced National Semi PC8477 core 767 * should respond to this command 768 */ 769 if ((result & 0xf0) == 0x70) { 770 /* low 4 bits may change */ 771 fcp->c_flags |= FCFLG_3DMODE; 772 retcode = PC87322; 773 } else 774 cmn_err(CE_CONT, 775 "?fdc: unidentified, enhanced, National Semiconductor cntlr %x\n", result); 776 } else { 777 save = inb(fcp->c_regbase + FCR_SRA); 778 779 do { 780 /* probe for motherboard version of SMC cntlr */ 781 782 /* try to enable configuration mode */ 783 ddic = ddi_enter_critical(); 784 outb(fcp->c_regbase + FCR_SRA, FSA_ENA5); 785 outb(fcp->c_regbase + FCR_SRA, FSA_ENA5); 786 ddi_exit_critical(ddic); 787 788 outb(fcp->c_regbase + FCR_SRA, 0x0F); 789 if (inb(fcp->c_regbase + FCR_SRB) != 0x00) 790 /* always expect 0 from config reg F */ 791 break; 792 outb(fcp->c_regbase + FCR_SRA, 0x0D); 793 if (inb(fcp->c_regbase + FCR_SRB) != 0x65) 794 /* expect 0x65 from config reg D */ 795 break; 796 outb(fcp->c_regbase + FCR_SRA, 0x0E); 797 result = inb(fcp->c_regbase + FCR_SRB); 798 if (result != 0x02) { 799 /* expect revision level 2 from config reg E */ 800 cmn_err(CE_CONT, 801 "?fdc: unidentified, enhanced, SMC cntlr revision %x\n", result); 802 /* break; */ 803 } 804 fcp->c_flags |= FCFLG_3DMODE; 805 retcode = FDC37C665; 806 } while (retcode == 0); 807 outb(fcp->c_regbase + FCR_SRA, FSA_DISB); 808 809 while (retcode == 0) { 810 /* probe for adapter version of SMC cntlr */ 811 ddic = ddi_enter_critical(); 812 outb(fcp->c_regbase + FCR_SRA, FSA_ENA6); 813 outb(fcp->c_regbase + FCR_SRA, FSA_ENA6); 814 ddi_exit_critical(ddic); 815 816 outb(fcp->c_regbase + FCR_SRA, 0x0F); 817 if (inb(fcp->c_regbase + FCR_SRB) != 0x00) 818 /* always expect 0 from config reg F */ 819 break; 820 outb(fcp->c_regbase + FCR_SRA, 0x0D); 821 if (inb(fcp->c_regbase + FCR_SRB) != 0x66) 822 /* expect 0x66 from config reg D */ 823 break; 824 outb(fcp->c_regbase + FCR_SRA, 0x0E); 825 result = inb(fcp->c_regbase + FCR_SRB); 826 if (result != 0x02) { 827 /* expect revision level 2 from config reg E */ 828 cmn_err(CE_CONT, 829 "?fdc: unidentified, enhanced, SMC cntlr revision %x\n", result); 830 /* break; */ 831 } 832 fcp->c_flags |= FCFLG_3DMODE; 833 retcode = FDC37C666; 834 } 835 outb(fcp->c_regbase + FCR_SRA, FSA_DISB); 836 837 drv_usecwait(10); 838 outb(fcp->c_regbase + FCR_SRA, save); 839 } 840 return (retcode); 841 } 842 843 static int 844 fdc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 845 { 846 struct fdcntlr *fcp; 847 int unit; 848 int rval = 0; 849 850 FCERRPRINT(FDEP_L3, FDEM_ATTA, (CE_WARN, "fdc_detach: dip %p", 851 (void*)dip)); 852 853 fcp = ddi_get_driver_private(dip); 854 855 switch (cmd) { 856 case DDI_DETACH: 857 for (unit = 0; unit < NFDUN; unit++) 858 if ((fcp->c_unit[unit])->fj_dip) { 859 rval = EBUSY; 860 break; 861 } 862 kstat_delete(fcp->c_intrstat); 863 fcp->c_intrstat = NULL; 864 ddi_remove_intr(fcp->c_dip, 0, fcp->c_iblock); 865 if (ddi_dmae_release(fcp->c_dip, fcp->c_dmachan) != 866 DDI_SUCCESS) 867 cmn_err(CE_WARN, "fdc_detach: dma release failed, " 868 "dip %p, dmachan %x", 869 (void*)fcp->c_dip, fcp->c_dmachan); 870 ddi_prop_remove_all(fcp->c_dip); 871 ddi_set_driver_private(fcp->c_dip, NULL); 872 873 mutex_destroy(&fcp->c_lock); 874 mutex_destroy(&fcp->c_dorlock); 875 cv_destroy(&fcp->c_iocv); 876 sema_destroy(&fcp->c_selsem); 877 ddi_soft_state_free(fdc_state_head, ddi_get_instance(dip)); 878 break; 879 880 case DDI_SUSPEND: 881 /* 882 * For suspend, we just use the semaphore to 883 * keep any child devices from accessing any of our 884 * hardware routines, and then shutdown the hardware. 885 * 886 * On resume, we'll reinit the hardware and release the 887 * semaphore. 888 */ 889 sema_p(&fcp->c_selsem); 890 891 if (ddi_dmae_disable(fcp->c_dip, fcp->c_dmachan) != 892 DDI_SUCCESS) { 893 cmn_err(CE_WARN, "fdc_suspend: dma disable failed, " 894 "dip %p, dmachan %x", (void *)fcp->c_dip, 895 fcp->c_dmachan); 896 /* give it back on failure */ 897 sema_v(&fcp->c_selsem); 898 return (DDI_FAILURE); 899 } 900 901 mutex_enter(&fcp->c_lock); 902 fcp->c_suspended = B_TRUE; 903 mutex_exit(&fcp->c_lock); 904 905 rval = DDI_SUCCESS; 906 break; 907 908 default: 909 rval = EINVAL; 910 break; 911 } 912 return (rval); 913 } 914 915 916 int 917 fdc_abort(struct fcu_obj *fjp) 918 { 919 struct fdcntlr *fcp = fjp->fj_fdc; 920 int unit = fjp->fj_unit & 3; 921 922 FCERRPRINT(FDEP_L3, FDEM_RESE, (CE_WARN, "fdc_abort")); 923 if (fcp->c_curunit == unit) { 924 mutex_enter(&fcp->c_lock); 925 if (fcp->c_flags & FCFLG_WAITING) { 926 /* 927 * this can cause data corruption ! 928 */ 929 fdcquiesce(fcp); 930 fcp->c_csb.csb_xstate = FXS_RESET; 931 fcp->c_flags |= FCFLG_TIMEOUT; 932 if (ddi_dmae_stop(fcp->c_dip, fcp->c_dmachan) != 933 DDI_SUCCESS) 934 cmn_err(CE_WARN, 935 "fdc_detach: dma release failed, " 936 "dip %p, dmachan %x", 937 (void*)fcp->c_dip, fcp->c_dmachan); 938 } 939 mutex_exit(&fcp->c_lock); 940 drv_usecwait(500); 941 return (DDI_SUCCESS); 942 } 943 return (DDI_FAILURE); 944 } 945 946 int 947 fdc_dkinfo(struct fcu_obj *fjp, struct dk_cinfo *dcp) 948 { 949 struct fdcntlr *fcp = fjp->fj_fdc; 950 951 (void) strncpy((char *)&dcp->dki_cname, ddi_get_name(fcp->c_dip), 952 DK_DEVLEN); 953 dcp->dki_ctype = DKC_UNKNOWN; /* no code for generic PC/AT fdc */ 954 dcp->dki_flags = DKI_FMTTRK; 955 dcp->dki_addr = fcp->c_regbase; 956 dcp->dki_space = 0; 957 dcp->dki_prio = fcp->c_intprio; 958 dcp->dki_vec = fcp->c_intvec; 959 (void) strncpy((char *)&dcp->dki_dname, ddi_driver_name(fjp->fj_dip), 960 DK_DEVLEN); 961 dcp->dki_slave = fjp->fj_unit & 3; 962 dcp->dki_maxtransfer = maxphys / DEV_BSIZE; 963 return (DDI_SUCCESS); 964 } 965 966 /* 967 * on=> non-zero = select, 0 = de-select 968 */ 969 int 970 fdc_select(struct fcu_obj *fjp, int funit, int on) 971 { 972 struct fdcntlr *fcp = fjp->fj_fdc; 973 int unit = funit & 3; 974 975 if (on) { 976 /* possess controller */ 977 sema_p(&fcp->c_selsem); 978 FCERRPRINT(FDEP_L2, FDEM_DSEL, 979 (CE_NOTE, "fdc_select unit %d: on", funit)); 980 981 if (fcp->c_curunit != unit || !(fjp->fj_flags & FUNIT_CHAROK)) { 982 fcp->c_curunit = unit; 983 fjp->fj_flags |= FUNIT_CHAROK; 984 if (fdcspecify(fcp, 985 fjp->fj_chars->fdc_transfer_rate, 986 fjp->fj_drive->fdd_steprate, 40)) 987 cmn_err(CE_WARN, 988 "fdc_select: controller setup rejected " 989 "fdcntrl %p transfer rate %x step rate %x" 990 " head load time 40", (void*)fcp, 991 fjp->fj_chars->fdc_transfer_rate, 992 fjp->fj_drive->fdd_steprate); 993 } 994 995 mutex_enter(&fcp->c_dorlock); 996 997 /* make sure drive is not selected in case we change speed */ 998 fcp->c_digout = (fcp->c_digout & ~FD_DRSEL) | 999 (~unit & FD_DRSEL); 1000 outb(fcp->c_regbase + FCR_DOR, fcp->c_digout); 1001 1002 (void) fdc_motorsm(fjp, FMI_STARTCMD, 1003 fjp->fj_drive->fdd_motoron); 1004 /* 1005 * Return value ignored - fdcmotort deals with failure. 1006 */ 1007 if (fdcspdchange(fcp, fjp, fjp->fj_attr->fda_rotatespd)) { 1008 /* 3D drive requires 500 ms for speed change */ 1009 (void) fdc_motorsm(fjp, FMI_RSTARTCMD, 5); 1010 /* 1011 * Return value ignored - fdcmotort deals with failure. 1012 */ 1013 } 1014 1015 fcp->c_digout = (fcp->c_digout & ~FD_DRSEL) | (unit & FD_DRSEL); 1016 outb(fcp->c_regbase + FCR_DOR, fcp->c_digout); 1017 1018 mutex_exit(&fcp->c_dorlock); 1019 fcp->c_csb.csb_drive = (uchar_t)unit; 1020 } else { 1021 FCERRPRINT(FDEP_L2, FDEM_DSEL, 1022 (CE_NOTE, "fdc_select unit %d: off", funit)); 1023 1024 mutex_enter(&fcp->c_dorlock); 1025 1026 fcp->c_digout |= FD_DRSEL; 1027 outb(fcp->c_regbase + FCR_DOR, fcp->c_digout); 1028 (void) fdc_motorsm(fjp, FMI_IDLECMD, 1029 fjp->fj_drive->fdd_motoroff); 1030 /* 1031 * Return value ignored - fdcmotort deals with failure. 1032 */ 1033 1034 mutex_exit(&fcp->c_dorlock); 1035 1036 /* give up controller */ 1037 sema_v(&fcp->c_selsem); 1038 } 1039 return (0); 1040 } 1041 1042 1043 int 1044 fdgetchng(struct fcu_obj *fjp, int funit) 1045 { 1046 if (fdcsense_drv(fjp->fj_fdc, funit & 3)) 1047 cmn_err(CE_WARN, "fdgetchng: write protect check failed"); 1048 return (fdcsense_chng(fjp->fj_fdc, funit & 3)); 1049 } 1050 1051 1052 int 1053 fdresetchng(struct fcu_obj *fjp, int funit) 1054 { 1055 struct fdcntlr *fcp = fjp->fj_fdc; 1056 int unit = funit & 3; 1057 int newcyl; /* where to seek for reset of DSKCHG */ 1058 1059 FCERRPRINT(FDEP_L2, FDEM_CHEK, (CE_NOTE, "fdmediachng unit %d", funit)); 1060 1061 if (fcp->c_curpcyl[unit]) 1062 newcyl = fcp->c_curpcyl[unit] - 1; 1063 else 1064 newcyl = 1; 1065 return (fdrecalseek(fjp, funit, newcyl, 0)); 1066 } 1067 1068 1069 /* 1070 * fdrecalseek 1071 */ 1072 int 1073 fdrecalseek(struct fcu_obj *fjp, int funit, int arg, int execflg) 1074 { 1075 struct fdcntlr *fcp = fjp->fj_fdc; 1076 struct fdcsb *csb; 1077 int unit = funit & 3; 1078 int rval; 1079 1080 FCERRPRINT(FDEP_L2, FDEM_RECA, (CE_NOTE, "fdrecalseek unit %d to %d", 1081 funit, arg)); 1082 1083 csb = &fcp->c_csb; 1084 csb->csb_cmd[1] = (uchar_t)unit; 1085 if (arg < 0) { /* is recal... */ 1086 *csb->csb_cmd = FO_RECAL; 1087 csb->csb_ncmds = 2; 1088 csb->csb_timer = 28; 1089 } else { 1090 *csb->csb_cmd = FO_SEEK; 1091 csb->csb_cmd[2] = (uchar_t)arg; 1092 csb->csb_ncmds = 3; 1093 csb->csb_timer = 10; 1094 } 1095 csb->csb_nrslts = 2; /* 2 for SENSE INTERRUPTS */ 1096 csb->csb_opflags = CSB_OFINRPT; 1097 csb->csb_maxretry = skretry; 1098 csb->csb_dmahandle = NULL; 1099 csb->csb_handle_bound = 0; 1100 csb->csb_dmacookiecnt = 0; 1101 csb->csb_dmacurrcookie = 0; 1102 csb->csb_dmawincnt = 0; 1103 csb->csb_dmacurrwin = 0; 1104 1105 /* send cmd off to fdc_exec */ 1106 if (rval = fdc_exec(fcp, 1, execflg)) 1107 goto out; 1108 1109 if (!(*csb->csb_rslt & S0_SEKEND) || 1110 (*csb->csb_rslt & S0_ICMASK) || 1111 ((*csb->csb_rslt & S0_ECHK) && arg < 0) || 1112 csb->csb_cmdstat) 1113 rval = ENODEV; 1114 1115 if (fdcsense_drv(fcp, unit)) 1116 cmn_err(CE_WARN, "fdgetchng: write protect check failed"); 1117 out: 1118 return (rval); 1119 } 1120 1121 1122 /* 1123 * fdrw- used only for read/writing sectors into/from kernel buffers. 1124 */ 1125 int 1126 fdrw(struct fcu_obj *fjp, int funit, int rw, int cyl, int head, 1127 int sector, caddr_t bufp, uint_t len) 1128 { 1129 struct fdcntlr *fcp = fjp->fj_fdc; 1130 struct fdcsb *csb; 1131 uint_t dmar_flags = 0; 1132 int unit = funit & 3; 1133 int rval; 1134 ddi_acc_handle_t mem_handle = NULL; 1135 caddr_t aligned_buf; 1136 size_t real_size; 1137 1138 FCERRPRINT(FDEP_L1, FDEM_RW, (CE_CONT, "fdrw unit %d\n", funit)); 1139 1140 csb = &fcp->c_csb; 1141 if (rw) { 1142 dmar_flags = DDI_DMA_READ; 1143 csb->csb_opflags = CSB_OFDMARD | CSB_OFINRPT; 1144 *csb->csb_cmd = FO_MT | FO_MFM | FO_SK | FO_RDDAT; 1145 } else { /* write */ 1146 dmar_flags = DDI_DMA_WRITE; 1147 csb->csb_opflags = CSB_OFDMAWT | CSB_OFINRPT; 1148 *csb->csb_cmd = FO_MT | FO_MFM | FO_WRDAT; 1149 } 1150 csb->csb_cmd[1] = (uchar_t)(unit | ((head & 0x1) << 2)); 1151 csb->csb_cmd[2] = (uchar_t)cyl; 1152 csb->csb_cmd[3] = (uchar_t)head; 1153 csb->csb_cmd[4] = (uchar_t)sector; 1154 encode(sector_size, fjp->fj_chars->fdc_sec_size, 1155 &csb->csb_cmd[5]); 1156 csb->csb_cmd[6] = (uchar_t)max(fjp->fj_chars->fdc_secptrack, sector); 1157 csb->csb_cmd[7] = fjp->fj_attr->fda_gapl; 1158 csb->csb_cmd[8] = 0xFF; 1159 1160 csb->csb_ncmds = 9; 1161 csb->csb_nrslts = 7; 1162 csb->csb_timer = 36; 1163 if (rw == FDRDONE) 1164 csb->csb_maxretry = 1; 1165 else 1166 csb->csb_maxretry = rwretry; 1167 1168 csb->csb_dmahandle = NULL; 1169 csb->csb_handle_bound = 0; 1170 csb->csb_dmacookiecnt = 0; 1171 csb->csb_dmacurrcookie = 0; 1172 csb->csb_dmawincnt = 0; 1173 csb->csb_dmacurrwin = 0; 1174 dmar_flags |= (DDI_DMA_STREAMING | DDI_DMA_PARTIAL); 1175 1176 if (ddi_dma_alloc_handle(fcp->c_dip, &fdc_dma_attr, DDI_DMA_SLEEP, 1177 0, &csb->csb_dmahandle) != DDI_SUCCESS) { 1178 rval = EINVAL; 1179 goto out; 1180 } 1181 1182 /* 1183 * allocate a page aligned buffer to dma to/from. This way we can 1184 * ensure the cookie is a whole multiple of granularity and avoids 1185 * any alignment issues. 1186 */ 1187 rval = ddi_dma_mem_alloc(csb->csb_dmahandle, len, &fdc_accattr, 1188 DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, &aligned_buf, 1189 &real_size, &mem_handle); 1190 if (rval != DDI_SUCCESS) { 1191 rval = EINVAL; 1192 goto out; 1193 } 1194 1195 if (dmar_flags & DDI_DMA_WRITE) { 1196 bcopy(bufp, aligned_buf, len); 1197 } 1198 1199 rval = ddi_dma_addr_bind_handle(csb->csb_dmahandle, NULL, aligned_buf, 1200 len, dmar_flags, DDI_DMA_SLEEP, 0, &csb->csb_dmacookie, 1201 &csb->csb_dmacookiecnt); 1202 1203 if (rval == DDI_DMA_MAPPED) { 1204 csb->csb_dmawincnt = 1; 1205 csb->csb_handle_bound = 1; 1206 } else if (rval == DDI_DMA_PARTIAL_MAP) { 1207 csb->csb_handle_bound = 1; 1208 if (ddi_dma_numwin(csb->csb_dmahandle, &csb->csb_dmawincnt) != 1209 DDI_SUCCESS) { 1210 cmn_err(CE_WARN, "fdrw: dma numwin failed"); 1211 rval = EINVAL; 1212 goto out; 1213 } 1214 } else { 1215 cmn_err(CE_WARN, 1216 "fdrw: dma addr bind handle failed, rval = %d", rval); 1217 rval = EINVAL; 1218 goto out; 1219 } 1220 rval = fdc_exec(fcp, 1, 1); 1221 1222 if (dmar_flags & DDI_DMA_READ) { 1223 bcopy(aligned_buf, bufp, len); 1224 } 1225 1226 out: 1227 if (csb->csb_dmahandle) { 1228 if (csb->csb_handle_bound) { 1229 if (ddi_dma_unbind_handle(csb->csb_dmahandle) != 1230 DDI_SUCCESS) 1231 cmn_err(CE_WARN, "fdrw: " 1232 "dma unbind handle failed"); 1233 csb->csb_handle_bound = 0; 1234 } 1235 if (mem_handle != NULL) { 1236 ddi_dma_mem_free(&mem_handle); 1237 } 1238 ddi_dma_free_handle(&csb->csb_dmahandle); 1239 csb->csb_dmahandle = NULL; 1240 } 1241 return (rval); 1242 } 1243 1244 1245 int 1246 fdtrkformat(struct fcu_obj *fjp, int funit, int cyl, int head, int filldata) 1247 { 1248 struct fdcntlr *fcp = fjp->fj_fdc; 1249 struct fdcsb *csb; 1250 int unit = funit & 3; 1251 int fmdatlen, lsector, lstart; 1252 int interleave, numsctr, offset, psector; 1253 uchar_t *dp; 1254 int rval; 1255 ddi_acc_handle_t mem_handle = NULL; 1256 caddr_t aligned_buf; 1257 size_t real_size; 1258 1259 FCERRPRINT(FDEP_L2, FDEM_FORM, 1260 (CE_NOTE, "fdformattrk unit %d cyl=%d, hd=%d", funit, cyl, head)); 1261 1262 csb = &fcp->c_csb; 1263 1264 csb->csb_opflags = CSB_OFDMAWT | CSB_OFINRPT; 1265 1266 *csb->csb_cmd = FO_FRMT | FO_MFM; 1267 csb->csb_cmd[1] = (head << 2) | unit; 1268 encode(sector_size, fjp->fj_chars->fdc_sec_size, 1269 &csb->csb_cmd[2]); 1270 csb->csb_cmd[3] = numsctr = fjp->fj_chars->fdc_secptrack; 1271 csb->csb_cmd[4] = fjp->fj_attr->fda_gapf; 1272 csb->csb_cmd[5] = (uchar_t)filldata; 1273 1274 csb->csb_npcyl = (uchar_t)(cyl * fjp->fj_chars->fdc_steps); 1275 1276 csb->csb_dmahandle = NULL; 1277 csb->csb_handle_bound = 0; 1278 csb->csb_dmacookiecnt = 0; 1279 csb->csb_dmacurrcookie = 0; 1280 csb->csb_dmawincnt = 0; 1281 csb->csb_dmacurrwin = 0; 1282 csb->csb_ncmds = 6; 1283 csb->csb_nrslts = 7; 1284 csb->csb_timer = 32; 1285 csb->csb_maxretry = rwretry; 1286 1287 /* 1288 * alloc space for format track cmd 1289 */ 1290 /* 1291 * NOTE: have to add size of fifo also - for dummy format action 1292 */ 1293 fmdatlen = 4 * numsctr; 1294 1295 if (ddi_dma_alloc_handle(fcp->c_dip, &fdc_dma_attr, DDI_DMA_SLEEP, 1296 0, &csb->csb_dmahandle) != DDI_SUCCESS) { 1297 rval = EINVAL; 1298 goto out; 1299 } 1300 1301 /* 1302 * allocate a page aligned buffer to dma to/from. This way we can 1303 * ensure the cookie is a whole multiple of granularity and avoids 1304 * any alignment issues. 1305 */ 1306 rval = ddi_dma_mem_alloc(csb->csb_dmahandle, fmdatlen, &fdc_accattr, 1307 DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, &aligned_buf, 1308 &real_size, &mem_handle); 1309 if (rval != DDI_SUCCESS) { 1310 rval = EINVAL; 1311 goto out; 1312 } 1313 dp = (uchar_t *)aligned_buf; 1314 1315 interleave = fjp->fj_attr->fda_intrlv; 1316 offset = (numsctr + interleave - 1) / interleave; 1317 for (psector = lstart = 1; 1318 psector <= numsctr; psector += interleave, lstart++) { 1319 for (lsector = lstart; lsector <= numsctr; lsector += offset) { 1320 *dp++ = (uchar_t)cyl; 1321 *dp++ = (uchar_t)head; 1322 *dp++ = (uchar_t)lsector; 1323 *dp++ = csb->csb_cmd[2]; 1324 } 1325 } 1326 1327 rval = ddi_dma_addr_bind_handle(csb->csb_dmahandle, NULL, aligned_buf, 1328 fmdatlen, DDI_DMA_WRITE | DDI_DMA_STREAMING | DDI_DMA_PARTIAL, 1329 DDI_DMA_SLEEP, 0, &csb->csb_dmacookie, &csb->csb_dmacookiecnt); 1330 1331 if (rval == DDI_DMA_MAPPED) { 1332 csb->csb_dmawincnt = 1; 1333 csb->csb_handle_bound = 1; 1334 } else if (rval == DDI_DMA_PARTIAL_MAP) { 1335 csb->csb_handle_bound = 1; 1336 if (ddi_dma_numwin(csb->csb_dmahandle, &csb->csb_dmawincnt) != 1337 DDI_SUCCESS) { 1338 cmn_err(CE_WARN, "fdtrkformat: dma numwin failed"); 1339 rval = EINVAL; 1340 goto out; 1341 } 1342 } else { 1343 cmn_err(CE_WARN, 1344 "fdtrkformat: dma buf bind handle failed, rval = %d", 1345 rval); 1346 rval = EINVAL; 1347 goto out; 1348 } 1349 1350 rval = fdc_exec(fcp, 1, 1); 1351 out: 1352 if (csb->csb_dmahandle) { 1353 if (csb->csb_handle_bound) { 1354 if (ddi_dma_unbind_handle(csb->csb_dmahandle) != 1355 DDI_SUCCESS) 1356 cmn_err(CE_WARN, "fdtrkformat: " 1357 "dma unbind handle failed"); 1358 csb->csb_handle_bound = 0; 1359 } 1360 if (mem_handle != NULL) { 1361 ddi_dma_mem_free(&mem_handle); 1362 } 1363 ddi_dma_free_handle(&csb->csb_dmahandle); 1364 csb->csb_dmahandle = NULL; 1365 } 1366 return (rval); 1367 } 1368 1369 int 1370 fdrawioctl(struct fcu_obj *fjp, int funit, caddr_t arg) 1371 { 1372 struct fdcntlr *fcp = fjp->fj_fdc; 1373 struct fd_raw *fdrp = (struct fd_raw *)arg; 1374 struct fdcsb *csb; 1375 uint_t dmar_flags = 0; 1376 int i; 1377 int change = 1; 1378 int sleep = 1; 1379 int rval = 0; 1380 int rval_exec = 0; 1381 ddi_acc_handle_t mem_handle = NULL; 1382 caddr_t aligned_buf; 1383 size_t real_size; 1384 1385 _NOTE(ARGUNUSED(funit)); 1386 1387 FCERRPRINT(FDEP_L2, FDEM_RAWI, 1388 (CE_NOTE, "fdrawioctl: cmd[0]=0x%x", fdrp->fdr_cmd[0])); 1389 1390 csb = &fcp->c_csb; 1391 1392 /* copy cmd bytes into csb */ 1393 for (i = 0; i <= fdrp->fdr_cnum; i++) 1394 csb->csb_cmd[i] = fdrp->fdr_cmd[i]; 1395 csb->csb_ncmds = (uchar_t)fdrp->fdr_cnum; 1396 1397 csb->csb_maxretry = 0; /* let the application deal with errors */ 1398 csb->csb_opflags = CSB_OFRAWIOCTL; 1399 csb->csb_nrslts = 0; 1400 csb->csb_timer = 50; 1401 1402 switch (fdrp->fdr_cmd[0] & 0x0f) { 1403 1404 case FO_SEEK: 1405 change = 0; 1406 /* FALLTHROUGH */ 1407 case FO_RECAL: 1408 csb->csb_opflags |= CSB_OFINRPT; 1409 break; 1410 1411 case FO_FRMT: 1412 csb->csb_npcyl = *(uchar_t *)(fdrp->fdr_addr) * 1413 fjp->fj_chars->fdc_steps; 1414 /* FALLTHROUGH */ 1415 case FO_WRDAT: 1416 case FO_WRDEL: 1417 csb->csb_opflags |= CSB_OFDMAWT | CSB_OFRESLT | CSB_OFINRPT; 1418 csb->csb_nrslts = 7; 1419 if (fdrp->fdr_nbytes == 0) 1420 return (EINVAL); 1421 dmar_flags = DDI_DMA_WRITE; 1422 break; 1423 1424 case FO_RDDAT: 1425 case FO_RDDEL: 1426 case FO_RDTRK: 1427 csb->csb_opflags |= CSB_OFDMARD | CSB_OFRESLT | CSB_OFINRPT; 1428 csb->csb_nrslts = 7; 1429 dmar_flags = DDI_DMA_READ; 1430 break; 1431 1432 case FO_RDID: 1433 csb->csb_opflags |= CSB_OFRESLT | CSB_OFINRPT; 1434 csb->csb_nrslts = 7; 1435 break; 1436 1437 case FO_SDRV: 1438 sleep = 0; 1439 csb->csb_nrslts = 1; 1440 break; 1441 1442 case FO_SINT: 1443 sleep = 0; 1444 change = 0; 1445 csb->csb_nrslts = 2; 1446 break; 1447 1448 case FO_SPEC: 1449 sleep = 0; 1450 change = 0; 1451 break; 1452 1453 default: 1454 return (EINVAL); 1455 } 1456 1457 csb->csb_dmahandle = NULL; 1458 csb->csb_handle_bound = 0; 1459 csb->csb_dmacookiecnt = 0; 1460 csb->csb_dmacurrcookie = 0; 1461 csb->csb_dmawincnt = 0; 1462 csb->csb_dmacurrwin = 0; 1463 1464 if (csb->csb_opflags & (CSB_OFDMARD | CSB_OFDMAWT)) { 1465 if (ddi_dma_alloc_handle(fcp->c_dip, &fdc_dma_attr, 1466 DDI_DMA_SLEEP, 0, &csb->csb_dmahandle) != DDI_SUCCESS) { 1467 rval = EINVAL; 1468 goto out; 1469 } 1470 1471 /* 1472 * allocate a page aligned buffer to dma to/from. This way we 1473 * can ensure the cookie is a whole multiple of granularity and 1474 * avoids any alignment issues. 1475 */ 1476 rval = ddi_dma_mem_alloc(csb->csb_dmahandle, 1477 (uint_t)fdrp->fdr_nbytes, &fdc_accattr, DDI_DMA_CONSISTENT, 1478 DDI_DMA_SLEEP, NULL, &aligned_buf, &real_size, &mem_handle); 1479 if (rval != DDI_SUCCESS) { 1480 rval = EINVAL; 1481 goto out; 1482 } 1483 1484 if (dmar_flags & DDI_DMA_WRITE) { 1485 bcopy(fdrp->fdr_addr, aligned_buf, 1486 (uint_t)fdrp->fdr_nbytes); 1487 } 1488 1489 dmar_flags |= (DDI_DMA_STREAMING | DDI_DMA_PARTIAL); 1490 rval = ddi_dma_addr_bind_handle(csb->csb_dmahandle, NULL, 1491 aligned_buf, (uint_t)fdrp->fdr_nbytes, dmar_flags, 1492 DDI_DMA_SLEEP, 0, &csb->csb_dmacookie, 1493 &csb->csb_dmacookiecnt); 1494 1495 if (rval == DDI_DMA_MAPPED) { 1496 csb->csb_dmawincnt = 1; 1497 csb->csb_handle_bound = 1; 1498 } else if (rval == DDI_DMA_PARTIAL_MAP) { 1499 csb->csb_handle_bound = 1; 1500 if (ddi_dma_numwin(csb->csb_dmahandle, 1501 &csb->csb_dmawincnt) != DDI_SUCCESS) { 1502 cmn_err(CE_WARN, 1503 "fdrawioctl: dma numwin failed"); 1504 rval = EINVAL; 1505 goto out; 1506 } 1507 } else { 1508 cmn_err(CE_WARN, "fdrawioctl: " 1509 "dma buf bind handle failed, rval = %d", rval); 1510 rval = EINVAL; 1511 goto out; 1512 } 1513 } 1514 1515 FCERRPRINT(FDEP_L1, FDEM_RAWI, 1516 (CE_CONT, "cmd: %x %x %x %x %x %x %x %x %x %x\n", csb->csb_cmd[0], 1517 csb->csb_cmd[1], csb->csb_cmd[2], csb->csb_cmd[3], 1518 csb->csb_cmd[4], csb->csb_cmd[5], csb->csb_cmd[6], 1519 csb->csb_cmd[7], csb->csb_cmd[8], csb->csb_cmd[9])); 1520 FCERRPRINT(FDEP_L1, FDEM_RAWI, 1521 (CE_CONT, "nbytes: %x, opflags: %x, addr: %p, len: %x\n", 1522 csb->csb_ncmds, csb->csb_opflags, (void *)fdrp->fdr_addr, 1523 fdrp->fdr_nbytes)); 1524 1525 /* 1526 * Note that we ignore any error returns from fdexec. 1527 * This is the way the driver has been, and it may be 1528 * that the raw ioctl senders simply don't want to 1529 * see any errors returned in this fashion. 1530 */ 1531 1532 /* 1533 * VP/ix sense drive ioctl call checks for the error return. 1534 */ 1535 1536 rval_exec = fdc_exec(fcp, sleep, change); 1537 1538 if (dmar_flags & DDI_DMA_READ) { 1539 bcopy(aligned_buf, fdrp->fdr_addr, (uint_t)fdrp->fdr_nbytes); 1540 } 1541 1542 FCERRPRINT(FDEP_L1, FDEM_RAWI, 1543 (CE_CONT, "rslt: %x %x %x %x %x %x %x %x %x %x\n", csb->csb_rslt[0], 1544 csb->csb_rslt[1], csb->csb_rslt[2], csb->csb_rslt[3], 1545 csb->csb_rslt[4], csb->csb_rslt[5], csb->csb_rslt[6], 1546 csb->csb_rslt[7], csb->csb_rslt[8], csb->csb_rslt[9])); 1547 1548 /* copy results into fdr */ 1549 for (i = 0; i <= (int)csb->csb_nrslts; i++) 1550 fdrp->fdr_result[i] = csb->csb_rslt[i]; 1551 /* fdrp->fdr_nbytes = fdc->c_csb.csb_rlen; return resid */ 1552 1553 out: 1554 if (csb->csb_dmahandle) { 1555 if (csb->csb_handle_bound) { 1556 if (ddi_dma_unbind_handle(csb->csb_dmahandle) != 1557 DDI_SUCCESS) 1558 cmn_err(CE_WARN, "fdrawioctl: " 1559 "dma unbind handle failed"); 1560 csb->csb_handle_bound = 0; 1561 } 1562 if (mem_handle != NULL) { 1563 ddi_dma_mem_free(&mem_handle); 1564 } 1565 ddi_dma_free_handle(&csb->csb_dmahandle); 1566 csb->csb_dmahandle = NULL; 1567 } 1568 if ((fdrp->fdr_cmd[0] & 0x0f) == FO_SDRV) { 1569 return (rval_exec); 1570 } 1571 return (rval); 1572 } 1573 1574 void 1575 encode(xlate_tbl_t *tablep, int val, uchar_t *rcode) 1576 { 1577 do { 1578 if (tablep->value >= val) { 1579 *rcode = tablep->code; 1580 return; 1581 } 1582 } while ((++tablep)->value); 1583 *rcode = tablep->code; 1584 cmn_err(CE_WARN, "fdc encode failed, table %p val %x code %x", 1585 (void *)tablep, val, (uint_t)*rcode); 1586 } 1587 1588 int 1589 decode(xlate_tbl_t *tablep, int kode, int *rvalue) 1590 { 1591 do { 1592 if (tablep->code == kode) { 1593 *rvalue = tablep->value; 1594 return (0); 1595 } 1596 } while ((++tablep)->value); 1597 return (-1); 1598 } 1599 1600 /* 1601 * quiesce(9E) entry point. 1602 * 1603 * This function is called when the system is single-threaded at high 1604 * PIL with preemption disabled. Therefore, this function must not be 1605 * blocked. 1606 * 1607 * This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure. 1608 * DDI_FAILURE indicates an error condition and should almost never happen. 1609 */ 1610 int 1611 fdc_quiesce(dev_info_t *dip) 1612 { 1613 struct fdcntlr *fcp; 1614 int ctlr = ddi_get_instance(dip); 1615 int unit; 1616 1617 fcp = ddi_get_soft_state(fdc_state_head, ctlr); 1618 1619 if (fcp == NULL) 1620 return (DDI_FAILURE); 1621 1622 /* 1623 * If no FD units are attached, there is no need to quiesce. 1624 */ 1625 for (unit = 0; unit < NFDUN; unit++) { 1626 struct fcu_obj *fjp = fcp->c_unit[unit]; 1627 if (fjp->fj_flags & FUNIT_DRVATCH) { 1628 break; 1629 } 1630 } 1631 1632 if (unit == NFDUN) 1633 return (DDI_SUCCESS); 1634 1635 (void) ddi_dmae_disable(fcp->c_dip, fcp->c_dmachan); 1636 1637 fcp->c_digout = (fcp->c_digout & (FD_DMTREN | FD_DRSEL)) | FD_ENABLE; 1638 outb(fcp->c_regbase + FCR_DOR, fcp->c_digout); 1639 drv_usecwait(20); 1640 fcp->c_digout |= FD_RSETZ; 1641 outb(fcp->c_regbase + FCR_DOR, fcp->c_digout); 1642 1643 if (fcp->c_chip >= i82077) { 1644 int count = 4; 1645 uchar_t *oplistp = configurecmd; 1646 do { 1647 int ntries = FDC_RQM_RETRY; 1648 do { 1649 if ((inb(fcp->c_regbase + FCR_MSR) & 1650 (MS_RQM|MS_DIO)) == MS_RQM) 1651 break; 1652 else 1653 drv_usecwait(1); 1654 } while (--ntries); 1655 if (ntries == 0) { 1656 break; 1657 } 1658 outb(fcp->c_regbase + FCR_DATA, *oplistp++); 1659 drv_usecwait(16); /* See comment in fdc_result() */ 1660 } while (--count); 1661 } 1662 1663 return (DDI_SUCCESS); 1664 } 1665 1666 void 1667 fdcquiesce(struct fdcntlr *fcp) 1668 { 1669 int unit; 1670 1671 FCERRPRINT(FDEP_L2, FDEM_RESE, (CE_NOTE, "fdcquiesce fcp %p", 1672 (void*)fcp)); 1673 1674 ASSERT(MUTEX_HELD(&fcp->c_lock)); 1675 mutex_enter(&fcp->c_dorlock); 1676 1677 if (ddi_dmae_stop(fcp->c_dip, fcp->c_dmachan) != DDI_SUCCESS) 1678 cmn_err(CE_WARN, "fdcquiesce: dmae stop failed, " 1679 "dip %p, dmachan %x", 1680 (void*)fcp->c_dip, fcp->c_dmachan); 1681 1682 fcp->c_digout = (fcp->c_digout & (FD_DMTREN | FD_DRSEL)) | FD_ENABLE; 1683 outb(fcp->c_regbase + FCR_DOR, fcp->c_digout); 1684 drv_usecwait(20); 1685 fcp->c_digout |= FD_RSETZ; 1686 outb(fcp->c_regbase + FCR_DOR, fcp->c_digout); 1687 1688 mutex_exit(&fcp->c_dorlock); 1689 1690 /* count resets */ 1691 fcp->fdstats.reset++; 1692 fcp->c_curunit = -1; 1693 for (unit = 0; unit < NFDUN; unit++) 1694 fcp->c_curpcyl[unit] = -1; 1695 1696 if (fcp->c_chip >= i82077) { 1697 (void) fdc_docmd(fcp, configurecmd, 4); 1698 /* 1699 * Ignored return. If failed, warning was issued by fdc_docmd. 1700 */ 1701 } 1702 } 1703 1704 void 1705 fdcreadid(struct fdcntlr *fcp, struct fdcsb *csb) 1706 { 1707 static uchar_t readidcmd[2] = {FO_RDID | FO_MFM, 0}; 1708 1709 readidcmd[1] = csb->csb_cmd[1]; 1710 (void) fdc_docmd(fcp, readidcmd, 2); 1711 } 1712 1713 int 1714 fdcseek(struct fdcntlr *fcp, int unit, int cyl) 1715 { 1716 static uchar_t seekabscmd[3] = {FO_SEEK, 0, 0}; 1717 1718 FCERRPRINT(FDEP_L0, FDEM_RECA, (CE_CONT, "fdcseek unit %d to cyl %d\n", 1719 unit, cyl)); 1720 seekabscmd[1] = (uchar_t)unit; 1721 seekabscmd[2] = (uchar_t)cyl; 1722 return (fdc_docmd(fcp, seekabscmd, 3)); 1723 } 1724 1725 /* 1726 * Returns status of disk change line of selected drive. 1727 * = 0 means diskette is present 1728 * != 0 means diskette was removed and current state is unknown 1729 */ 1730 int 1731 fdcsense_chng(struct fdcntlr *fcp, int unit) 1732 { 1733 int digital_input; 1734 1735 FCERRPRINT(FDEP_L0, FDEM_SCHG, 1736 (CE_CONT, "fdcsense_chng unit %d\n", unit)); 1737 digital_input = inb(fcp->c_regbase + FCR_DIR); 1738 if (fcp->c_mode == FDCMODE_30) 1739 digital_input ^= FDI_DKCHG; 1740 return (digital_input & FDI_DKCHG); 1741 } 1742 1743 int 1744 fdcsense_drv(struct fdcntlr *fcp, int unit) 1745 { 1746 static uchar_t sensedrvcmd[2] = {FO_SDRV, 0}; 1747 uchar_t senser; 1748 int rval; 1749 1750 sensedrvcmd[1] = (uchar_t)unit; 1751 (void) fdc_docmd(fcp, sensedrvcmd, 2); 1752 /* 1753 * Ignored return. If failed, warning was issued by fdc_docmd. 1754 * fdc_results retrieves the controller/drive status 1755 */ 1756 if (rval = fdc_result(fcp, &senser, 1)) 1757 goto done; 1758 if (senser & S3_WPROT) 1759 fcp->c_unit[unit]->fj_flags |= FUNIT_WPROT; 1760 else 1761 fcp->c_unit[unit]->fj_flags &= ~FUNIT_WPROT; 1762 done: 1763 return (rval); 1764 } 1765 1766 int 1767 fdcsense_int(struct fdcntlr *fcp, int *unitp, int *cylp) 1768 { 1769 uchar_t senser[2]; 1770 int rval; 1771 1772 (void) fdc_docmd(fcp, &senseintcmd, 1); 1773 /* 1774 * Ignored return. If failed, warning was issued by fdc_docmd. 1775 * fdc_results retrieves the controller/drive status 1776 */ 1777 1778 if (!(rval = fdc_result(fcp, senser, 2))) { 1779 if ((*senser & (S0_IVCMD | S0_SEKEND | S0_ECHK)) != S0_SEKEND) 1780 rval = 1; 1781 if (unitp) 1782 *unitp = *senser & 3; 1783 if (cylp) 1784 *cylp = senser[1]; 1785 } 1786 return (rval); 1787 } 1788 1789 int 1790 fdcspecify(struct fdcntlr *fcp, int xferrate, int steprate, int hlt) 1791 { 1792 static uchar_t perpindcmd[2] = {FO_PERP, 0}; 1793 static uchar_t specifycmd[3] = {FO_SPEC, 0, 0}; 1794 1795 encode(drate_mfm, xferrate, &fcp->c_config); 1796 outb(fcp->c_regbase + FCR_CCR, fcp->c_config); 1797 1798 if (fcp->c_chip >= i82077) { 1799 /* 1800 * Use old style perpendicular mode command of 82077. 1801 */ 1802 if (xferrate == 1000) { 1803 /* Set GAP and WGATE */ 1804 perpindcmd[1] = 3; 1805 /* double step rate because xlate table is for 500Kb */ 1806 steprate <<= 1; 1807 hlt <<= 1; 1808 } else 1809 perpindcmd[1] = 0; 1810 (void) fdc_docmd(fcp, perpindcmd, 2); 1811 /* 1812 * Ignored return. If failed, warning was issued by fdc_docmd. 1813 */ 1814 } 1815 encode(step_rate, steprate, &fcp->c_hutsrt); 1816 specifycmd[1] = fcp->c_hutsrt |= 0x0F; /* use max head unload time */ 1817 hlt = (hlt >= 256) ? 0 : (hlt >> 1); /* encode head load time */ 1818 specifycmd[2] = fcp->c_hlt = hlt << 1; /* make room for DMA bit */ 1819 return (fdc_docmd(fcp, specifycmd, 3)); 1820 } 1821 1822 int 1823 fdcspdchange(struct fdcntlr *fcp, struct fcu_obj *fjp, int rpm) 1824 { 1825 int retcode = 0; 1826 uint_t ddic; 1827 uchar_t deselect = 0; 1828 uchar_t ds_code; 1829 uchar_t enable_code; 1830 uchar_t save; 1831 1832 if (((fcp->c_flags & FCFLG_DSOUT) == 0 && rpm <= fjp->fj_rotspd) || 1833 ((fcp->c_flags & FCFLG_DSOUT) && (fjp->fj_flags & FUNIT_3DMODE) && 1834 rpm > fjp->fj_rotspd)) { 1835 return (0); 1836 } 1837 1838 FCERRPRINT(FDEP_L1, FDEM_SCHG, 1839 (CE_CONT, "fdcspdchange: %d rpm\n", rpm)); 1840 ASSERT(MUTEX_HELD(&fcp->c_dorlock)); 1841 1842 switch (fcp->c_chip) { 1843 default: 1844 break; 1845 case i82077: 1846 break; 1847 1848 case PC87322: 1849 { 1850 uchar_t nscmodecmd[5] = {FO_MODE, 0x02, 0x00, 0xC8, 0x00}; 1851 1852 if (rpm > fjp->fj_rotspd) { 1853 nscmodecmd[3] ^= 0xC0; 1854 retcode = (fcp->c_flags ^ FCFLG_DSOUT) || 1855 (fjp->fj_flags ^ FUNIT_3DMODE); 1856 fcp->c_flags |= FCFLG_DSOUT; 1857 fjp->fj_flags |= FUNIT_3DMODE; 1858 } else { 1859 /* program DENSEL to default output */ 1860 fcp->c_flags &= ~FCFLG_DSOUT; 1861 retcode = fjp->fj_flags & FUNIT_3DMODE; 1862 fjp->fj_flags &= ~FUNIT_3DMODE; 1863 } 1864 if (retcode && (fcp->c_digout & FD_DRSEL) == fcp->c_curunit) { 1865 /* de-select drive while changing speed */ 1866 deselect = fcp->c_digout ^ FD_DRSEL; 1867 outb(fcp->c_regbase + FCR_DOR, deselect); 1868 } 1869 1870 (void) fdc_docmd(fcp, nscmodecmd, 5); 1871 /* 1872 * Ignored return. If failed, warning was issued by fdc_docmd. 1873 */ 1874 break; 1875 } 1876 1877 case FDC37C665: 1878 enable_code = FSA_ENA5; 1879 goto SMC_config; 1880 1881 case FDC37C666: 1882 enable_code = FSA_ENA6; 1883 SMC_config: 1884 if (rpm > fjp->fj_rotspd) { 1885 /* force DENSEL output to active LOW */ 1886 ds_code = FSB_DSHI; 1887 retcode = (fcp->c_flags ^ FCFLG_DSOUT) || 1888 (fjp->fj_flags ^ FUNIT_3DMODE); 1889 fcp->c_flags |= FCFLG_DSOUT; 1890 fjp->fj_flags |= FUNIT_3DMODE; 1891 } else { 1892 /* program DENSEL to default output */ 1893 ds_code = 0; 1894 fcp->c_flags &= ~FCFLG_DSOUT; 1895 retcode = fjp->fj_flags & FUNIT_3DMODE; 1896 fjp->fj_flags &= ~FUNIT_3DMODE; 1897 } 1898 if (retcode && (fcp->c_digout & FD_DRSEL) == fcp->c_curunit) { 1899 /* de-select drive while changing speed */ 1900 deselect = fcp->c_digout ^ FD_DRSEL; 1901 outb(fcp->c_regbase + FCR_DOR, deselect); 1902 } 1903 save = inb(fcp->c_regbase + FCR_SRA); 1904 1905 /* enter configuration mode */ 1906 ddic = ddi_enter_critical(); 1907 outb(fcp->c_regbase + FCR_SRA, enable_code); 1908 outb(fcp->c_regbase + FCR_SRA, enable_code); 1909 ddi_exit_critical(ddic); 1910 1911 outb(fcp->c_regbase + FCR_SRA, FSA_CR5); 1912 enable_code = inb(fcp->c_regbase + FCR_SRB) & FSB_DSDEF; 1913 /* update DENSEL mode bits */ 1914 outb(fcp->c_regbase + FCR_SRB, enable_code | ds_code); 1915 1916 /* exit configuration mode */ 1917 outb(fcp->c_regbase + FCR_SRA, FSA_DISB); 1918 drv_usecwait(10); 1919 outb(fcp->c_regbase + FCR_SRA, save); 1920 break; 1921 } 1922 if (deselect) 1923 /* reselect drive */ 1924 outb(fcp->c_regbase + FCR_DOR, fcp->c_digout); 1925 return (retcode); 1926 } 1927 1928 static int 1929 fdc_motorsm(struct fcu_obj *fjp, int input, int timeval) 1930 { 1931 struct fdcntlr *fcp = fjp->fj_fdc; 1932 int unit = fjp->fj_unit & 3; 1933 int old_mstate; 1934 int rval = 0; 1935 uchar_t motorbit; 1936 1937 ASSERT(MUTEX_HELD(&fcp->c_dorlock)); 1938 old_mstate = fcp->c_mtrstate[unit]; 1939 encode(motor_onbits, unit, &motorbit); 1940 1941 switch (input) { 1942 case FMI_TIMER: /* timer expired */ 1943 fcp->c_motort[unit] = 0; 1944 switch (old_mstate) { 1945 case FMS_START: 1946 case FMS_DELAY: 1947 fcp->c_mtrstate[unit] = FMS_ON; 1948 break; 1949 case FMS_KILLST: 1950 fcp->c_motort[unit] = timeout(fdmotort, (void *)fjp, 1951 drv_usectohz(1000000)); 1952 fcp->c_mtrstate[unit] = FMS_IDLE; 1953 break; 1954 case FMS_IDLE: 1955 fcp->c_digout &= ~motorbit; 1956 outb(fcp->c_regbase + FCR_DOR, fcp->c_digout); 1957 fcp->c_mtrstate[unit] = FMS_OFF; 1958 fjp->fj_flags &= ~FUNIT_3DMODE; 1959 break; 1960 case 86: 1961 rval = -1; 1962 break; 1963 case FMS_OFF: 1964 case FMS_ON: 1965 default: 1966 rval = -2; 1967 } 1968 break; 1969 1970 case FMI_STARTCMD: /* start command */ 1971 switch (old_mstate) { 1972 case FMS_IDLE: 1973 fcp->c_mtrstate[unit] = 86; 1974 mutex_exit(&fcp->c_dorlock); 1975 (void) untimeout(fcp->c_motort[unit]); 1976 mutex_enter(&fcp->c_dorlock); 1977 fcp->c_motort[unit] = 0; 1978 fcp->c_mtrstate[unit] = FMS_ON; 1979 break; 1980 case FMS_OFF: 1981 fcp->c_digout |= motorbit; 1982 outb(fcp->c_regbase + FCR_DOR, fcp->c_digout); 1983 1984 /* start motor_spinup_timer */ 1985 ASSERT(timeval > 0); 1986 fcp->c_motort[unit] = timeout(fdmotort, (void *)fjp, 1987 drv_usectohz(100000 * timeval)); 1988 /* FALLTHROUGH */ 1989 case FMS_KILLST: 1990 fcp->c_mtrstate[unit] = FMS_START; 1991 break; 1992 default: 1993 rval = -2; 1994 } 1995 break; 1996 1997 case FMI_RSTARTCMD: /* restart command */ 1998 if (fcp->c_motort[unit] != 0) { 1999 fcp->c_mtrstate[unit] = 86; 2000 mutex_exit(&fcp->c_dorlock); 2001 (void) untimeout(fcp->c_motort[unit]); 2002 mutex_enter(&fcp->c_dorlock); 2003 } 2004 ASSERT(timeval > 0); 2005 fcp->c_motort[unit] = timeout(fdmotort, (void *)fjp, 2006 drv_usectohz(100000 * timeval)); 2007 fcp->c_mtrstate[unit] = FMS_START; 2008 break; 2009 2010 case FMI_DELAYCMD: /* delay command */ 2011 if (fcp->c_motort[unit] == 0) 2012 fcp->c_motort[unit] = timeout(fdmotort, (void *)fjp, 2013 drv_usectohz(15000)); 2014 fcp->c_mtrstate[unit] = FMS_DELAY; 2015 break; 2016 2017 case FMI_IDLECMD: /* idle command */ 2018 switch (old_mstate) { 2019 case FMS_DELAY: 2020 fcp->c_mtrstate[unit] = 86; 2021 mutex_exit(&fcp->c_dorlock); 2022 (void) untimeout(fcp->c_motort[unit]); 2023 mutex_enter(&fcp->c_dorlock); 2024 /* FALLTHROUGH */ 2025 case FMS_ON: 2026 ASSERT(timeval > 0); 2027 fcp->c_motort[unit] = timeout(fdmotort, (void *)fjp, 2028 drv_usectohz(100000 * timeval)); 2029 fcp->c_mtrstate[unit] = FMS_IDLE; 2030 break; 2031 case FMS_START: 2032 fcp->c_mtrstate[unit] = FMS_KILLST; 2033 break; 2034 default: 2035 rval = -2; 2036 } 2037 break; 2038 2039 default: 2040 rval = -3; 2041 } 2042 if (rval) { 2043 FCERRPRINT(FDEP_L4, FDEM_EXEC, (CE_WARN, 2044 "fdc_motorsm: unit %d bad input %d or bad state %d", 2045 (int)fjp->fj_unit, input, old_mstate)); 2046 #if 0 2047 cmn_err(CE_WARN, 2048 "fdc_motorsm: unit %d bad input %d or bad state %d", 2049 (int)fjp->fj_unit, input, old_mstate); 2050 fcp->c_mtrstate[unit] = FMS_OFF; 2051 if (fcp->c_motort[unit] != 0) { 2052 mutex_exit(&fcp->c_dorlock); 2053 (void) untimeout(fcp->c_motort[unit]); 2054 mutex_enter(&fcp->c_dorlock); 2055 fcp->c_motort[unit] = 0; 2056 } 2057 #endif 2058 } else 2059 FCERRPRINT(FDEP_L0, FDEM_EXEC, 2060 (CE_CONT, "fdc_motorsm unit %d: input %d, %d -> %d\n", 2061 (int)fjp->fj_unit, input, old_mstate, 2062 fcp->c_mtrstate[unit])); 2063 return (rval); 2064 } 2065 2066 /* 2067 * fdmotort 2068 * is called from timeout() when a motor timer has expired. 2069 */ 2070 static void 2071 fdmotort(void *arg) 2072 { 2073 struct fcu_obj *fjp = (struct fcu_obj *)arg; 2074 struct fdcntlr *fcp = fjp->fj_fdc; 2075 struct fdcsb *csb = &fcp->c_csb; 2076 int unit = fjp->fj_unit & 3; 2077 int mval; 2078 int newxstate = 0; 2079 2080 mutex_enter(&fcp->c_dorlock); 2081 mval = fdc_motorsm(fjp, FMI_TIMER, 0); 2082 mutex_exit(&fcp->c_dorlock); 2083 if (mval < 0) 2084 return; 2085 2086 mutex_enter(&fcp->c_lock); 2087 2088 if ((fcp->c_flags & FCFLG_WAITING) && 2089 fcp->c_mtrstate[unit] == FMS_ON && 2090 (csb->csb_xstate == FXS_MTRON || csb->csb_xstate == FXS_HDST || 2091 csb->csb_xstate == FXS_DKCHGX)) 2092 newxstate = fdc_statemach(fcp); 2093 if (newxstate == -1) { 2094 FCERRPRINT(FDEP_L3, FDEM_EXEC, 2095 (CE_WARN, 2096 "fdc_motort unit %d: motor ready but bad xstate", 2097 (int)fjp->fj_unit)); 2098 fcp->c_csb.csb_cmdstat = EIO; 2099 } 2100 if (newxstate == -1 || newxstate == FXS_END) { 2101 fcp->c_flags ^= FCFLG_WAITING; 2102 cv_signal(&fcp->c_iocv); 2103 } 2104 mutex_exit(&fcp->c_lock); 2105 } 2106 2107 /* 2108 * DMA interrupt service routine 2109 * 2110 * Called by EISA dma interrupt service routine when buffer chaining 2111 * is required. 2112 */ 2113 2114 ddi_dma_cookie_t * 2115 fdc_dmae_isr(struct fdcntlr *fcp) 2116 { 2117 struct fdcsb *csb = &fcp->c_csb; 2118 off_t off; 2119 size_t len; 2120 2121 if (csb->csb_dmahandle && !csb->csb_cmdstat) { 2122 if (++csb->csb_dmacurrcookie < csb->csb_dmacookiecnt) { 2123 ddi_dma_nextcookie(csb->csb_dmahandle, 2124 &csb->csb_dmacookie); 2125 return (&csb->csb_dmacookie); 2126 } else if (++csb->csb_dmacurrwin < csb->csb_dmawincnt) { 2127 if (ddi_dma_getwin(csb->csb_dmahandle, 2128 csb->csb_dmacurrwin, &off, &len, 2129 &csb->csb_dmacookie, 2130 &csb->csb_dmacookiecnt) != DDI_SUCCESS) { 2131 return (NULL); 2132 } 2133 csb->csb_dmacurrcookie = 0; 2134 return (&csb->csb_dmacookie); 2135 } 2136 } else 2137 cmn_err(CE_WARN, "fdc: unsolicited DMA interrupt"); 2138 return (NULL); 2139 } 2140 2141 2142 /* 2143 * returns: 2144 * 0 if all ok, 2145 * ENXIO - diskette not in drive 2146 * ETIMEDOUT - for immediate operations that timed out 2147 * EBUSY - if stupid chip is locked busy??? 2148 * ENOEXEC - for timeout during sending cmds to chip 2149 * 2150 * to sleep: set sleep 2151 * to check for disk changed: set change 2152 */ 2153 static int 2154 fdc_exec(struct fdcntlr *fcp, int sleep, int change) 2155 { 2156 struct ddi_dmae_req dmaereq; 2157 struct fcu_obj *fjp; 2158 struct fdcsb *csb; 2159 off_t off; 2160 size_t len; 2161 int unit; 2162 2163 mutex_enter(&fcp->c_lock); 2164 FCERRPRINT(FDEP_L0, FDEM_EXEC, 2165 (CE_CONT, "fdc_exec: sleep %x change %x\n", sleep, change)); 2166 csb = &fcp->c_csb; 2167 unit = csb->csb_drive; 2168 fjp = fcp->c_unit[unit]; 2169 2170 if (csb->csb_opflags & CSB_OFINRPT) { 2171 if (*csb->csb_cmd == FO_RECAL) 2172 csb->csb_npcyl = 0; 2173 else if ((*csb->csb_cmd & ~FO_MFM) != FO_FRMT) 2174 csb->csb_npcyl = 2175 csb->csb_cmd[2] * fjp->fj_chars->fdc_steps; 2176 csb->csb_xstate = FXS_START; 2177 } else 2178 csb->csb_xstate = FXS_DOIT; 2179 csb->csb_retrys = 0; 2180 csb->csb_ourtrys = 0; 2181 2182 if (csb->csb_dmahandle) { 2183 /* ensure that entire format xfer is in one cookie */ 2184 /* 2185 * The change from ddi_dma_buf/addr_setup() to 2186 * ddi_dma_buf/addr_bind_handle() has already loaded 2187 * the first DMA window and cookie. 2188 */ 2189 if ((*csb->csb_cmd & ~FO_MFM) == FO_FRMT && 2190 (4 * csb->csb_cmd[3]) != csb->csb_dmacookie.dmac_size) { 2191 mutex_exit(&fcp->c_lock); 2192 return (EINVAL); 2193 } 2194 } 2195 2196 retry: 2197 if (fcp->c_curunit != unit || !(fjp->fj_flags & FUNIT_CHAROK)) { 2198 fcp->c_curunit = unit; 2199 fjp->fj_flags |= FUNIT_CHAROK; 2200 if (fjp->fj_chars->fdc_transfer_rate == 417) { 2201 /* XXX hack for fdformat */ 2202 /* fjp->fj_chars->fdc_transfer_rate == 500; */ 2203 fjp->fj_attr->fda_rotatespd = 360; 2204 } 2205 if (fdcspecify(fcp, fjp->fj_chars->fdc_transfer_rate, 2206 fjp->fj_drive->fdd_steprate, 40)) 2207 cmn_err(CE_WARN, 2208 "fdc_select: controller setup rejected " 2209 "fdcntrl %p transfer rate %x step rate %x " 2210 "head load time 40", (void*)fcp, 2211 fjp->fj_chars->fdc_transfer_rate, 2212 fjp->fj_drive->fdd_steprate); 2213 2214 mutex_enter(&fcp->c_dorlock); 2215 if (fdcspdchange(fcp, fjp, fjp->fj_attr->fda_rotatespd)) { 2216 /* 3D drive requires 500 ms for speed change */ 2217 (void) fdc_motorsm(fjp, FMI_RSTARTCMD, 5); 2218 /* 2219 * Return value ignored - fdcmotort deals with failure. 2220 */ 2221 } 2222 mutex_exit(&fcp->c_dorlock); 2223 } 2224 2225 /* 2226 * If checking for disk_change is enabled 2227 * (i.e. not seeking in fdresetchng), 2228 * we sample the DSKCHG line to see if the diskette has wandered away. 2229 */ 2230 if (change && fdcsense_chng(fcp, unit)) { 2231 FCERRPRINT(FDEP_L3, FDEM_EXEC, 2232 (CE_WARN, "diskette %d changed!!!", csb->csb_drive)); 2233 fcp->c_unit[unit]->fj_flags |= FUNIT_CHANGED; 2234 /* 2235 * If the diskette is still gone... so are we, adios! 2236 */ 2237 if (fdcheckdisk(fcp, unit)) { 2238 mutex_exit(&fcp->c_lock); 2239 2240 /* VP/ix expects an EBUSY return here */ 2241 if (*csb->csb_cmd == FO_SDRV) { 2242 return (EBUSY); 2243 } 2244 return (ENXIO); 2245 } 2246 /* 2247 * delay to ensure that new diskette is up to speed 2248 */ 2249 mutex_enter(&fcp->c_dorlock); 2250 (void) fdc_motorsm(fjp, FMI_RSTARTCMD, 2251 fjp->fj_drive->fdd_motoron); 2252 /* 2253 * Return value ignored - fdcmotort deals with failure. 2254 */ 2255 mutex_exit(&fcp->c_dorlock); 2256 } 2257 2258 /* 2259 * gather some statistics 2260 */ 2261 switch (csb->csb_cmd[0] & 0x1f) { 2262 case FO_RDDAT: 2263 fcp->fdstats.rd++; 2264 break; 2265 case FO_WRDAT: 2266 fcp->fdstats.wr++; 2267 break; 2268 case FO_RECAL: 2269 fcp->fdstats.recal++; 2270 break; 2271 case FO_FRMT: 2272 fcp->fdstats.form++; 2273 break; 2274 default: 2275 fcp->fdstats.other++; 2276 break; 2277 } 2278 2279 bzero(csb->csb_rslt, 10); 2280 csb->csb_cmdstat = 0; 2281 2282 if (csb->csb_dmahandle) { 2283 bzero(&dmaereq, sizeof (struct ddi_dmae_req)); 2284 dmaereq.der_command = (csb->csb_opflags & CSB_OFDMAWT) ? 2285 DMAE_CMD_WRITE : DMAE_CMD_READ; 2286 /* 2287 * setup for dma buffer chaining regardless of bus capability 2288 */ 2289 dmaereq.der_bufprocess = DMAE_BUF_CHAIN; 2290 dmaereq.proc = fdc_dmae_isr; 2291 dmaereq.procparms = (void *)fcp; 2292 if (ddi_dmae_prog(fcp->c_dip, &dmaereq, &csb->csb_dmacookie, 2293 fcp->c_dmachan) != DDI_SUCCESS) 2294 cmn_err(CE_WARN, "fdc_exec: dmae prog failed, " 2295 "dip %p, dmachan %x", 2296 (void*)fcp->c_dip, fcp->c_dmachan); 2297 } 2298 2299 if ((fdc_statemach(fcp) == FXS_DOWT) && !sleep) { 2300 /* 2301 * If the operation has no results - then just return 2302 */ 2303 if (!csb->csb_nrslts) { 2304 mutex_exit(&fcp->c_lock); 2305 return (0); 2306 } 2307 /* 2308 * this operation has no interrupt and an immediate result 2309 * so wait for the results and stuff them into the csb 2310 */ 2311 if (fdc_statemach(fcp) == -1) { 2312 mutex_exit(&fcp->c_lock); 2313 return (EIO); 2314 } 2315 } else { 2316 fcp->c_flags |= FCFLG_WAITING; 2317 /* 2318 * wait for completion interrupt 2319 */ 2320 while (fcp->c_flags & FCFLG_WAITING) { 2321 cv_wait(&fcp->c_iocv, &fcp->c_lock); 2322 } 2323 } 2324 2325 /* 2326 * See if there was an error detected, if so, fdrecover() 2327 * will check it out and say what to do. 2328 * 2329 * Don't do this, though, if this was the Sense Drive Status 2330 * or the Dump Registers command. 2331 */ 2332 if (csb->csb_cmdstat && *csb->csb_cmd != FO_SDRV) { 2333 /* if it can restarted OK, then do so, else return error */ 2334 if (fdrecover(fcp)) { 2335 mutex_exit(&fcp->c_lock); 2336 return (EIO); 2337 } 2338 /* ASSUMES that cmd is still intact in csb */ 2339 if (csb->csb_xstate == FXS_END) 2340 csb->csb_xstate = FXS_START; 2341 if (fdc_dma_attr.dma_attr_sgllen > 1 && csb->csb_dmahandle) { 2342 /* 2343 * restarted read/write operation requires 2344 * first DMA cookie of current window 2345 */ 2346 if (ddi_dma_getwin(csb->csb_dmahandle, 2347 csb->csb_dmacurrwin, &off, &len, 2348 &csb->csb_dmacookie, 2349 &csb->csb_dmacookiecnt) != DDI_SUCCESS) { 2350 2351 mutex_exit(&fcp->c_lock); 2352 return (EIO); 2353 } 2354 csb->csb_dmacurrcookie = 0; 2355 } 2356 goto retry; 2357 } 2358 /* things went ok */ 2359 mutex_exit(&fcp->c_lock); 2360 return (0); 2361 } 2362 2363 /* 2364 * fdcheckdisk 2365 * called by fdc_exec to check if the disk is still there - do a seek 2366 * then see if DSKCHG line went away; if so, diskette is in; else 2367 * it's (still) out. 2368 */ 2369 int 2370 fdcheckdisk(struct fdcntlr *fcp, int unit) 2371 { 2372 struct fdcsb *csb = &fcp->c_csb; 2373 int newcyl; /* where to seek for reset of DSKCHG */ 2374 int rval; 2375 enum fxstate save_xstate; 2376 uchar_t save_cmd, save_cd1, save_npcyl; 2377 2378 ASSERT(MUTEX_HELD(&fcp->c_lock)); 2379 FCERRPRINT(FDEP_L1, FDEM_CHEK, 2380 (CE_CONT, "fdcheckdisk unit %d\n", unit)); 2381 2382 if (fcp->c_curpcyl[unit]) 2383 newcyl = fcp->c_curpcyl[unit] - 1; 2384 else 2385 newcyl = 1; 2386 2387 save_cmd = *csb->csb_cmd; 2388 save_cd1 = csb->csb_cmd[1]; 2389 save_npcyl = csb->csb_npcyl; 2390 save_xstate = csb->csb_xstate; 2391 2392 *csb->csb_cmd = FO_SEEK; 2393 csb->csb_cmd[1] = (uchar_t)unit; 2394 csb->csb_npcyl = (uchar_t)newcyl; 2395 fcp->c_flags |= FCFLG_WAITING; 2396 2397 if (fcp->c_mtrstate[unit] != FMS_ON && fcp->c_motort[unit] != 0) 2398 /* 2399 * wait for motor to get up to speed, 2400 * and let motor_timer issue seek cmd 2401 */ 2402 csb->csb_xstate = FXS_DKCHGX; 2403 else { 2404 /* 2405 * motor is up to speed; issue seek cmd now 2406 */ 2407 csb->csb_xstate = FXS_SEEK; 2408 if (rval = fdcseek(fcp, unit, newcyl)) { 2409 /* 2410 * any recal/seek errors are too serious to attend to 2411 */ 2412 FCERRPRINT(FDEP_L3, FDEM_CHEK, 2413 (CE_WARN, "fdcheckdisk err %d", rval)); 2414 fcp->c_flags ^= FCFLG_WAITING; 2415 } 2416 } 2417 /* 2418 * wait for completion interrupt 2419 * XXX This should be backed up with a watchdog timer! 2420 */ 2421 while (fcp->c_flags & FCFLG_WAITING) { 2422 cv_wait(&fcp->c_iocv, &fcp->c_lock); 2423 } 2424 2425 /* 2426 * if disk change still asserted, no diskette in drive! 2427 */ 2428 if (rval = fdcsense_chng(fcp, unit)) { 2429 FCERRPRINT(FDEP_L3, FDEM_CHEK, 2430 (CE_WARN, "fdcheckdisk no disk %d", unit)); 2431 } 2432 2433 *csb->csb_cmd = save_cmd; 2434 csb->csb_cmd[1] = save_cd1; 2435 csb->csb_npcyl = save_npcyl; 2436 csb->csb_xstate = save_xstate; 2437 return (rval); 2438 } 2439 2440 static int 2441 fdrecover(struct fdcntlr *fcp) 2442 { 2443 struct fcu_obj *fjp; 2444 struct fdcsb *csb = &fcp->c_csb; 2445 int residual; 2446 int unit; 2447 char *failure; 2448 2449 FCERRPRINT(FDEP_L2, FDEM_RECO, 2450 (CE_NOTE, "fdrecover unit %d", csb->csb_drive)); 2451 2452 unit = csb->csb_drive; 2453 fjp = fcp->c_unit[unit]; 2454 if (fcp->c_flags & FCFLG_TIMEOUT) { 2455 fcp->c_flags ^= FCFLG_TIMEOUT; 2456 csb->csb_rslt[1] |= 0x08; 2457 FCERRPRINT(FDEP_L3, FDEM_RECO, 2458 (CE_WARN, "fd unit %d: %s timed out", csb->csb_drive, 2459 fdcmds[*csb->csb_cmd & 0x1f].cmdname)); 2460 } 2461 2462 if (csb->csb_status & S0_SEKEND) 2463 fcp->c_curpcyl[unit] = -1; 2464 2465 switch (csb->csb_oldxs) { 2466 case FXS_RCAL: /* recalibrate */ 2467 case FXS_SEEK: /* seek */ 2468 case FXS_RESET: /* cntlr reset */ 2469 FCERRPRINT(FDEP_L4, FDEM_RECO, (CE_WARN, 2470 "fd unit %d: %s error: st0=0x%x pcn=%d", csb->csb_drive, 2471 fdcmds[*csb->csb_cmd & 0x1f].cmdname, 2472 *csb->csb_rslt, csb->csb_rslt[1])); 2473 if (csb->csb_retrys++ < skretry && 2474 !(csb->csb_opflags & CSB_OFRAWIOCTL)) 2475 return (0); 2476 break; 2477 2478 case FXS_RDID: /* read ID */ 2479 if (!(csb->csb_status & S0_SEKEND)) 2480 csb->csb_xstate = FXS_HDST; 2481 /* FALLTHROUGH */ 2482 case FXS_DOIT: /* original operation */ 2483 case FXS_DOWT: /* waiting on operation */ 2484 if (csb->csb_opflags & (CSB_OFDMARD | CSB_OFDMAWT)) { 2485 if (ddi_dmae_getcnt(fcp->c_dip, fcp->c_dmachan, 2486 &residual) != DDI_SUCCESS) 2487 cmn_err(CE_WARN, 2488 "fdc_recover: dmae getcnt failed, " 2489 "dip %p dmachan %x residual %x", 2490 (void*)fcp->c_dip, fcp->c_dmachan, 2491 residual); 2492 FCERRPRINT(FDEP_L2, FDEM_RECO, 2493 (CE_NOTE, 2494 "fd unit %d: %s error: " 2495 "dma count=0x%lx residual=0x%x", 2496 csb->csb_drive, 2497 fdcmds[*csb->csb_cmd & 0x1f].cmdname, 2498 csb->csb_dmacookie.dmac_size, residual)); 2499 } 2500 if (csb->csb_rslt[1] == S1_OVRUN) 2501 /* 2502 * handle retries of over/underrun 2503 * with a secondary retry counter 2504 */ 2505 if (++csb->csb_ourtrys <= OURUN_TRIES) { 2506 FCERRPRINT(FDEP_L2, FDEM_RECO, 2507 (CE_NOTE, 2508 "fd unit %d: %s error: over/under-run", 2509 csb->csb_drive, 2510 fdcmds[*csb->csb_cmd & 0x1f].cmdname)); 2511 return (0); 2512 } else 2513 /* 2514 * count 1 set of over/underruns 2515 * as 1 primary retry effort 2516 */ 2517 csb->csb_ourtrys = 0; 2518 2519 if ((fjp->fj_flags & (FUNIT_UNLABELED | FUNIT_LABELOK)) && 2520 !(csb->csb_opflags & CSB_OFRAWIOCTL)) { 2521 /* 2522 * device is open so keep trying and 2523 * gather statistics on errors 2524 */ 2525 if (csb->csb_rslt[1] & S1_CRCER) 2526 fcp->fdstats.de++; 2527 if (csb->csb_rslt[1] & S1_OVRUN) 2528 fcp->fdstats.run++; 2529 if (csb->csb_rslt[1] & (S1_NODATA | S1_MADMK)) 2530 fcp->fdstats.bfmt++; 2531 if (csb->csb_rslt[1] & 0x08) 2532 fcp->fdstats.to++; 2533 2534 /* 2535 * if we have not run out of retries, return 0 2536 */ 2537 if (csb->csb_retrys++ < csb->csb_maxretry && 2538 (*csb->csb_cmd & ~FO_MFM) != FO_FRMT) { 2539 if (csb->csb_opflags & 2540 (CSB_OFDMARD | CSB_OFDMAWT)) { 2541 FCERRPRINT(FDEP_L4, FDEM_RECO, 2542 (CE_WARN, 2543 "fd unit %d: %s error: " 2544 "st0=0x%x st1=0x%x st2=0x%x", 2545 csb->csb_drive, 2546 fdcmds[*csb->csb_cmd & 2547 0x1f].cmdname, 2548 *csb->csb_rslt, csb->csb_rslt[1], 2549 csb->csb_rslt[2])); 2550 } 2551 if ((csb->csb_retrys & 1) && 2552 csb->csb_xstate == FXS_END) 2553 csb->csb_xstate = FXS_DOIT; 2554 else if (csb->csb_retrys == 3) 2555 csb->csb_xstate = FXS_RESTART; 2556 return (0); 2557 } 2558 if (csb->csb_rslt[1] & S1_CRCER) 2559 failure = "crc error"; 2560 else if (csb->csb_rslt[1] & S1_OVRUN) 2561 failure = "over/under-run"; 2562 else if (csb->csb_rslt[1] & (S1_NODATA | S1_MADMK)) 2563 failure = "bad format"; 2564 else if (csb->csb_rslt[1] & 0x08) 2565 failure = "timeout"; 2566 else 2567 failure = "failed"; 2568 cmn_err(CE_NOTE, "!fd unit %d: %s %s (%x %x %x)", 2569 csb->csb_drive, 2570 fdcmds[*csb->csb_cmd & 0x1f].cmdname, failure, 2571 *csb->csb_rslt, csb->csb_rslt[1], csb->csb_rslt[2]); 2572 } else { 2573 FCERRPRINT(FDEP_L2, FDEM_RECO, 2574 (CE_NOTE, "fd unit %d: %s failed (%x %x %x)", 2575 csb->csb_drive, 2576 fdcmds[*csb->csb_cmd & 0x1f].cmdname, 2577 *csb->csb_rslt, csb->csb_rslt[1], 2578 csb->csb_rslt[2])); 2579 } 2580 break; 2581 2582 default: 2583 FCERRPRINT(FDEP_L4, FDEM_RECO, (CE_WARN, 2584 "fd unit %d: %s failed: st0=0x%x st1=0x%x st2=0x%x", 2585 csb->csb_drive, fdcmds[*csb->csb_cmd & 0x1f].cmdname, 2586 *csb->csb_rslt, csb->csb_rslt[1], csb->csb_rslt[2])); 2587 break; 2588 } 2589 return (1); 2590 } 2591 2592 2593 /* Autovector Interrupt Entry Point */ 2594 static uint_t 2595 fdc_intr(caddr_t arg) 2596 { 2597 struct fdcntlr *fcp = (struct fdcntlr *)arg; 2598 struct fdcsb *csb; 2599 off_t off; 2600 size_t blklen; 2601 int drive; 2602 int newstate; 2603 int pendstate; 2604 int rval = DDI_DMA_DONE; 2605 int state; 2606 int maxspin = 10; 2607 2608 csb = &fcp->c_csb; 2609 2610 mutex_enter(&fcp->c_lock); 2611 if (fcp->c_suspended) { 2612 mutex_exit(&fcp->c_lock); 2613 return (DDI_INTR_UNCLAIMED); 2614 } 2615 2616 /* 2617 * Wait for the RQM bit to be set, or until we've tested it 2618 * a bunch of times (which may imply this isn't our interrupt). 2619 */ 2620 state = inb(fcp->c_regbase + FCR_MSR); 2621 pendstate = state & (MS_RQM | MS_DIO | MS_CB); 2622 while (((pendstate & MS_RQM) == 0) && (maxspin-- > 0)) { 2623 /* Small pause in between reading the status port */ 2624 drv_usecwait(10); 2625 /* Reread the status port */ 2626 state = inb(fcp->c_regbase + FCR_MSR); 2627 pendstate = state & (MS_RQM | MS_DIO | MS_CB); 2628 } 2629 FCERRPRINT(FDEP_L0, FDEM_INTR, 2630 (CE_CONT, "fdc_intr unit %d: xstate=%d MSR=0x%x\n", 2631 csb->csb_drive, csb->csb_xstate, state)); 2632 2633 /* 2634 * If there is an operation outstanding AND the controller is ready 2635 * to receive a command or send us the result of a command (OR if the 2636 * controller is ready to accept a new command), AND if 2637 * someone has been waiting for a command to finish AND (if no unit 2638 * is BUSY OR if the unit that we're waiting for is BUSY (i.e. it's in 2639 * the middle of a seek/recalibrate)) then this interrupt is for us. 2640 */ 2641 if ((pendstate == (MS_RQM | MS_DIO | MS_CB) || pendstate == MS_RQM) && 2642 (fcp->c_flags & FCFLG_WAITING) && 2643 (!(state & 0x0f) || ((1 << csb->csb_drive) & state))) { 2644 /* 2645 * Remove one of the conditions for entering this code. 2646 * The state_machine will release the c_lock if it 2647 * calls untimeout() 2648 */ 2649 fcp->c_flags ^= FCFLG_WAITING; 2650 2651 if ((newstate = fdc_statemach(fcp)) == -1) { 2652 /* restore waiting flag */ 2653 fcp->c_flags |= FCFLG_WAITING; 2654 mutex_exit(&fcp->c_lock); 2655 return (DDI_INTR_CLAIMED); 2656 } 2657 2658 if (fcp->c_intrstat) 2659 KIOIP->intrs[KSTAT_INTR_HARD]++; 2660 if (newstate == FXS_END) { 2661 2662 if (csb->csb_dmahandle && !csb->csb_cmdstat && 2663 /* 2664 * read/write operation may have multiple DMA 2665 * cookies: process next one 2666 */ 2667 ((csb->csb_dmacurrcookie < 2668 (csb->csb_dmacookiecnt - 1)) || 2669 (csb->csb_dmacurrwin) < (csb->csb_dmawincnt - 1))) { 2670 /* 2671 * read/write operation requires another 2672 * DMA cookie: process next one 2673 */ 2674 2675 if (++csb->csb_dmacurrcookie < 2676 csb->csb_dmacookiecnt) { 2677 ddi_dma_nextcookie(csb->csb_dmahandle, 2678 &csb->csb_dmacookie); 2679 } else if (++csb->csb_dmacurrwin < 2680 csb->csb_dmawincnt) { 2681 if (ddi_dma_getwin(csb->csb_dmahandle, 2682 csb->csb_dmacurrwin, &off, &blklen, 2683 &csb->csb_dmacookie, 2684 &csb->csb_dmacookiecnt) != 2685 DDI_SUCCESS) { 2686 cmn_err(CE_WARN, 2687 "fdc_intr: " 2688 "dma getwin failed"); 2689 } 2690 csb->csb_dmacurrcookie = 0; 2691 } 2692 2693 if (ddi_dmae_prog(fcp->c_dip, NULL, 2694 &csb->csb_dmacookie, fcp->c_dmachan) != 2695 DDI_SUCCESS) 2696 cmn_err(CE_WARN, 2697 "fdc_intr: dmae prog failed, " 2698 "dip %p dmachannel %x", 2699 (void*)fcp->c_dip, 2700 fcp->c_dmachan); 2701 2702 /* 2703 * status of last operation has disk 2704 * address for continuation 2705 */ 2706 csb->csb_cmd[2] = csb->csb_rslt[3]; 2707 csb->csb_cmd[3] = csb->csb_rslt[4]; 2708 csb->csb_cmd[4] = csb->csb_rslt[5]; 2709 csb->csb_cmd[1] = (csb->csb_cmd[1] & ~0x04) | 2710 (csb->csb_cmd[3] << 2); 2711 2712 csb->csb_xstate = FXS_START; 2713 (void) fdc_statemach(fcp); 2714 /* 2715 * Ignored return. If failed, warning already 2716 * posted. Returned state irrelevant. 2717 */ 2718 /* restore waiting flag */ 2719 fcp->c_flags |= FCFLG_WAITING; 2720 goto fi_exit; 2721 } 2722 if (rval != DDI_DMA_DONE) 2723 csb->csb_cmdstat = EIO; 2724 /* 2725 * somebody's waiting for completion of fdcntlr/csb, 2726 * wake them 2727 */ 2728 cv_signal(&fcp->c_iocv); 2729 } 2730 else 2731 /* restore waiting flag */ 2732 fcp->c_flags |= FCFLG_WAITING; 2733 fi_exit: 2734 mutex_exit(&fcp->c_lock); 2735 return (DDI_INTR_CLAIMED); 2736 } 2737 2738 if (state & MS_RQM) { 2739 (void) fdcsense_int(fcp, &drive, NULL); 2740 /* 2741 * Ignored return - senser state already saved 2742 */ 2743 FCERRPRINT(FDEP_L4, FDEM_INTR, 2744 (CE_WARN, "fdc_intr unit %d: nobody sleeping 0x%x", 2745 drive, state)); 2746 } else { 2747 FCERRPRINT(FDEP_L4, FDEM_INTR, 2748 (CE_WARN, "fdc_intr: nobody sleeping on %d 0x%x", 2749 csb->csb_drive, state)); 2750 } 2751 /* 2752 * This should probably be protected, but, what the 2753 * heck...the cost isn't worth the accuracy for this 2754 * statistic. 2755 */ 2756 if (fcp->c_intrstat) 2757 KIOIP->intrs[KSTAT_INTR_SPURIOUS]++; 2758 mutex_exit(&fcp->c_lock); 2759 return (DDI_INTR_UNCLAIMED); 2760 } 2761 2762 /* 2763 * fdwatch 2764 * is called from timeout() when a floppy operation timer has expired. 2765 */ 2766 static void 2767 fdwatch(void *arg) 2768 { 2769 struct fdcntlr *fcp = (struct fdcntlr *)arg; 2770 struct fdcsb *csb; 2771 2772 mutex_enter(&fcp->c_lock); 2773 2774 if (fcp->c_timeid == 0) { 2775 /* 2776 * fdc_intr got here first, ergo, no timeout condition.. 2777 */ 2778 mutex_exit(&fcp->c_lock); 2779 return; 2780 } 2781 2782 if (fcp->c_flags & FCFLG_WAITING) { 2783 if (ddi_dmae_stop(fcp->c_dip, fcp->c_dmachan) != DDI_SUCCESS) 2784 cmn_err(CE_WARN, "fdwatch: dmae stop failed, " 2785 "dip %p, dmachan %x", 2786 (void*)fcp->c_dip, fcp->c_dmachan); 2787 csb = &fcp->c_csb; 2788 FCERRPRINT(FDEP_L3, FDEM_WATC, 2789 (CE_WARN, "fdcwatch unit %d: xstate = %d", 2790 csb->csb_drive, csb->csb_xstate)); 2791 drv_usecwait(50); 2792 2793 if (inb(fcp->c_regbase + FCR_MSR) != MS_RQM) { 2794 /* 2795 * cntlr is still busy, so reset it 2796 */ 2797 csb->csb_xstate = FXS_KILL; 2798 (void) fdc_statemach(fcp); 2799 /* 2800 * Ignored return. If failed, warning already 2801 * posted. Returned state irrelevant. 2802 */ 2803 } else { 2804 csb->csb_xstate = FXS_END; 2805 fcp->c_timeid = 0; 2806 fcp->c_flags ^= FCFLG_WAITING; 2807 cv_signal(&fcp->c_iocv); 2808 } 2809 csb->csb_cmdstat = EIO; 2810 fcp->c_flags |= FCFLG_TIMEOUT; 2811 } else { 2812 FCERRPRINT(FDEP_L4, FDEM_INTR, 2813 (CE_WARN, "fdcwatch: not sleeping for unit %d", 2814 fcp->c_csb.csb_drive)); 2815 } 2816 if (fcp->c_intrstat) 2817 KIOIP->intrs[KSTAT_INTR_WATCHDOG]++; 2818 mutex_exit(&fcp->c_lock); 2819 } 2820 2821 2822 static int 2823 fdc_statemach(struct fdcntlr *fcp) 2824 { 2825 struct fcu_obj *fjp; 2826 struct fdcsb *csb = &fcp->c_csb; 2827 int backoff; 2828 clock_t time; 2829 int unit; 2830 2831 ASSERT(MUTEX_HELD(&fcp->c_lock)); 2832 2833 unit = csb->csb_drive; 2834 fjp = fcp->c_unit[unit]; 2835 2836 csb->csb_oldxs = csb->csb_xstate; 2837 switch (csb->csb_xstate) { 2838 2839 case FXS_START: /* start of operation */ 2840 ASSERT(fcp->c_timeid == 0); 2841 time = drv_usectohz(100000 * (unsigned int)csb->csb_timer); 2842 if (time == 0) 2843 time = drv_usectohz(2000000); 2844 fcp->c_timeid = timeout(fdwatch, (void *)fcp, time); 2845 2846 if (fcp->c_mtrstate[unit] == FMS_START) { 2847 /* 2848 * wait for motor to get up to speed 2849 */ 2850 csb->csb_xstate = FXS_MTRON; 2851 break; 2852 } 2853 /* FALLTHROUGH */ 2854 2855 case FXS_MTRON: /* motor is at speed */ 2856 if (fcp->c_mtrstate[unit] != FMS_ON) { 2857 /* how did we get here ?? */ 2858 cmn_err(CE_WARN, "fdc: selected but motor off"); 2859 return (-1); 2860 } 2861 if (fcp->c_curpcyl[unit] != -1 && *csb->csb_cmd != FO_RECAL) 2862 goto nxs_seek; 2863 recalcmd[1] = (uchar_t)unit; 2864 if (fdc_docmd(fcp, recalcmd, 2) == -1) { 2865 /* cntlr did not accept command bytes */ 2866 fdcquiesce(fcp); 2867 csb->csb_cmdstat = EIO; 2868 csb->csb_xstate = FXS_RESET; 2869 break; 2870 } 2871 fcp->c_sekdir[unit] = 0; 2872 csb->csb_xstate = FXS_RCAL; 2873 break; 2874 2875 case FXS_RCAL: /* forced recalibrate is complete */ 2876 #if 0 /* #ifdef _VPIX */ 2877 /* WARNING: this code breaks SPARC compatibility */ 2878 if (csb->csb_opflags & CSB_OFRAWIOCTL && 2879 *csb->csb_cmd == FO_RECAL) { 2880 fcp->c_curpcyl[unit] = 0; 2881 csb->csb_status = 0; 2882 goto nxs_cmpl; 2883 } 2884 #endif 2885 (void) fdc_docmd(fcp, &senseintcmd, 1); 2886 /* 2887 * Ignored return. If failed, warning was issued by fdc_docmd. 2888 * fdc_results retrieves the controller/drive status 2889 */ 2890 (void) fdc_result(fcp, csb->csb_rslt, 2); 2891 /* 2892 * Ignored return. If failed, warning was issued by fdc_result. 2893 * Actual results checked below 2894 */ 2895 if ((csb->csb_status = ((*csb->csb_rslt ^ S0_SEKEND) & 2896 (S0_ICMASK | S0_SEKEND | S0_ECHK | S0_NOTRDY))) != 0) { 2897 FCERRPRINT(FDEP_L3, FDEM_EXEC, 2898 (CE_WARN, "fdc_statemach unit %d: recal result %x", 2899 csb->csb_drive, *csb->csb_rslt)); 2900 fdcquiesce(fcp); 2901 csb->csb_cmdstat = EIO; 2902 csb->csb_xstate = FXS_RESET; 2903 break; 2904 } 2905 if (unit != (*csb->csb_rslt & 3) || csb->csb_rslt[1]) { 2906 csb->csb_status = S0_SEKEND; 2907 goto nxs_cmpl; 2908 } 2909 fcp->c_curpcyl[unit] = csb->csb_rslt[1]; 2910 if (*csb->csb_cmd == FO_RECAL) 2911 goto nxs_cmpl; 2912 nxs_seek: 2913 if (*csb->csb_cmd != FO_SEEK && 2914 csb->csb_npcyl == fcp->c_curpcyl[unit]) 2915 goto nxs_doit; 2916 fcp->c_sekdir[unit] = csb->csb_npcyl - fcp->c_curpcyl[unit]; 2917 /* FALLTHROUGH */ 2918 2919 case FXS_DKCHGX: /* reset Disk-Change latch */ 2920 (void) fdcseek(fcp, csb->csb_cmd[1], csb->csb_npcyl); 2921 /* 2922 * Ignored return. If command rejected, warnig already posted 2923 * by fdc_docmd(). 2924 */ 2925 csb->csb_xstate = FXS_SEEK; 2926 break; 2927 2928 case FXS_RESTART: /* special restart of read/write operation */ 2929 ASSERT(fcp->c_timeid == 0); 2930 time = drv_usectohz(100000 * csb->csb_timer); 2931 if (time == 0) 2932 time = drv_usectohz(2000000); 2933 fcp->c_timeid = timeout(fdwatch, (void *)fcp, time); 2934 2935 if (fcp->c_mtrstate[unit] != FMS_ON) { 2936 cmn_err(CE_WARN, "fdc: selected but motor off"); 2937 return (-1); 2938 } 2939 if ((csb->csb_npcyl == 0 || fcp->c_sekdir[unit] >= 0) && 2940 (int)csb->csb_cmd[2] < (fjp->fj_chars->fdc_ncyl - 1)) 2941 backoff = csb->csb_npcyl + 1; 2942 else 2943 backoff = csb->csb_npcyl - 1; 2944 (void) fdcseek(fcp, csb->csb_cmd[1], backoff); 2945 /* 2946 * Ignored return. If command rejected, warnig already posted 2947 * by fdc_docmd(). 2948 */ 2949 csb->csb_xstate = FXS_RESEEK; 2950 break; 2951 2952 case FXS_RESEEK: /* seek to backoff-cyl complete */ 2953 (void) fdc_docmd(fcp, &senseintcmd, 1); 2954 /* 2955 * Ignored return. If failed, warning was issued by fdc_docmd. 2956 * fdc_results retrieves the controller/drive status 2957 */ 2958 (void) fdc_result(fcp, csb->csb_rslt, 2); 2959 /* 2960 * Ignored return. If failed, warning was issued by fdc_result. 2961 * Actual results checked below 2962 */ 2963 if ((csb->csb_status = ((*csb->csb_rslt ^ S0_SEKEND) & 2964 (S0_ICMASK | S0_SEKEND | S0_ECHK | S0_NOTRDY))) != 0) 2965 goto nxs_cmpl; 2966 (void) fdcseek(fcp, csb->csb_cmd[1], csb->csb_npcyl); 2967 /* 2968 * Ignored return. If command rejected, warnig already posted 2969 * by fdc_docmd(). 2970 */ 2971 csb->csb_xstate = FXS_SEEK; 2972 break; 2973 2974 case FXS_SEEK: /* seek complete */ 2975 #if 0 /* #ifdef _VPIX */ 2976 /* WARNING: this code breaks SPARC compatibility and */ 2977 /* rawioctls in fdformat */ 2978 if (csb->csb_opflags & CSB_OFRAWIOCTL) { 2979 fcp->c_curpcyl[unit] = csb->csb_npcyl; 2980 csb->csb_status = 0; 2981 goto nxs_cmpl; 2982 } 2983 #endif 2984 (void) fdc_docmd(fcp, &senseintcmd, 1); 2985 /* 2986 * Ignored return. If failed, warning was issued by fdc_docmd. 2987 * fdc_results retrieves the controller/drive status 2988 */ 2989 (void) fdc_result(fcp, csb->csb_rslt, 2); 2990 /* 2991 * Ignored return. If failed, warning was issued by fdc_result. 2992 * Actual results checked below 2993 */ 2994 if ((csb->csb_status = ((*csb->csb_rslt ^ S0_SEKEND) & 2995 (S0_ICMASK | S0_SEKEND | S0_ECHK | S0_NOTRDY))) != 0) 2996 goto nxs_cmpl; 2997 if (unit != (*csb->csb_rslt & 3) || 2998 csb->csb_rslt[1] != csb->csb_npcyl) { 2999 csb->csb_status = S0_SEKEND; 3000 goto nxs_cmpl; 3001 }; 3002 fcp->c_curpcyl[unit] = csb->csb_rslt[1]; 3003 /* use motor_timer to delay for head settle */ 3004 mutex_enter(&fcp->c_dorlock); 3005 (void) fdc_motorsm(fjp, FMI_DELAYCMD, 3006 fjp->fj_drive->fdd_headsettle / 1000); 3007 /* 3008 * Return value ignored - fdcmotort deals with failure. 3009 */ 3010 mutex_exit(&fcp->c_dorlock); 3011 csb->csb_xstate = FXS_HDST; 3012 break; 3013 3014 case FXS_HDST: /* head settle */ 3015 if (*csb->csb_cmd == FO_SEEK) 3016 goto nxs_cmpl; 3017 if ((*csb->csb_cmd & ~FO_MFM) == FO_FRMT) 3018 goto nxs_doit; 3019 fdcreadid(fcp, csb); 3020 csb->csb_xstate = FXS_RDID; 3021 break; 3022 3023 case FXS_RDID: /* read ID complete */ 3024 (void) fdc_result(fcp, csb->csb_rslt, 7); 3025 /* 3026 * Ignored return. If failed, warning was issued by fdc_result. 3027 * Actual results checked below 3028 */ 3029 if ((csb->csb_status = (*csb->csb_rslt & 3030 (S0_ICMASK | S0_ECHK | S0_NOTRDY))) != 0) 3031 goto nxs_cmpl; 3032 if (csb->csb_cmd[2] != csb->csb_rslt[3]) { 3033 /* at wrong logical cylinder */ 3034 csb->csb_status = S0_SEKEND; 3035 goto nxs_cmpl; 3036 }; 3037 goto nxs_doit; 3038 3039 case FXS_DOIT: /* do original operation */ 3040 ASSERT(fcp->c_timeid == 0); 3041 time = drv_usectohz(100000 * csb->csb_timer); 3042 if (time == 0) 3043 time = drv_usectohz(2000000); 3044 fcp->c_timeid = timeout(fdwatch, (void *)fcp, time); 3045 nxs_doit: 3046 if (fdc_docmd(fcp, csb->csb_cmd, csb->csb_ncmds) == -1) { 3047 /* cntlr did not accept command bytes */ 3048 fdcquiesce(fcp); 3049 csb->csb_xstate = FXS_RESET; 3050 csb->csb_cmdstat = EIO; 3051 break; 3052 } 3053 csb->csb_xstate = FXS_DOWT; 3054 break; 3055 3056 case FXS_DOWT: /* operation complete */ 3057 (void) fdc_result(fcp, csb->csb_rslt, csb->csb_nrslts); 3058 /* 3059 * Ignored return. If failed, warning was issued by fdc_result. 3060 * Actual results checked below. 3061 */ 3062 if (*csb->csb_cmd == FO_SDRV) { 3063 csb->csb_status = 3064 (*csb->csb_rslt ^ (S3_DRRDY | S3_2SIDE)) & 3065 ~(S3_HEAD | S3_UNIT); 3066 } else { 3067 csb->csb_status = *csb->csb_rslt & 3068 (S0_ICMASK | S0_ECHK | S0_NOTRDY); 3069 } 3070 nxs_cmpl: 3071 if (csb->csb_status) 3072 csb->csb_cmdstat = EIO; 3073 csb->csb_xstate = FXS_END; 3074 3075 /* remove watchdog timer if armed and not already triggered */ 3076 if (fcp->c_timeid != 0) { 3077 timeout_id_t timeid; 3078 timeid = fcp->c_timeid; 3079 fcp->c_timeid = 0; 3080 mutex_exit(&fcp->c_lock); 3081 (void) untimeout(timeid); 3082 mutex_enter(&fcp->c_lock); 3083 } 3084 break; 3085 3086 case FXS_KILL: /* quiesce cntlr by reset */ 3087 fdcquiesce(fcp); 3088 fcp->c_timeid = timeout(fdwatch, (void *)fcp, 3089 drv_usectohz(2000000)); 3090 csb->csb_xstate = FXS_RESET; 3091 break; 3092 3093 case FXS_RESET: /* int from reset */ 3094 for (unit = 0; unit < NFDUN; unit++) { 3095 (void) fdcsense_int(fcp, NULL, NULL); 3096 fcp->c_curpcyl[unit] = -1; 3097 } 3098 if (fcp->c_timeid != 0) { 3099 timeout_id_t timeid; 3100 timeid = fcp->c_timeid; 3101 fcp->c_timeid = 0; 3102 mutex_exit(&fcp->c_lock); 3103 (void) untimeout(timeid); 3104 mutex_enter(&fcp->c_lock); 3105 } 3106 csb->csb_xstate = FXS_END; 3107 break; 3108 3109 default: 3110 cmn_err(CE_WARN, "fdc: statemach, unknown state"); 3111 return (-1); 3112 } 3113 FCERRPRINT(FDEP_L1, FDEM_EXEC, 3114 (CE_CONT, "fdc_statemach unit %d: %d -> %d\n", 3115 csb->csb_drive, csb->csb_oldxs, csb->csb_xstate)); 3116 return (csb->csb_xstate); 3117 } 3118 3119 3120 /* 3121 * routine to program a command into the floppy disk controller. 3122 */ 3123 int 3124 fdc_docmd(struct fdcntlr *fcp, uchar_t *oplistp, uchar_t count) 3125 { 3126 int ntries; 3127 3128 ASSERT(count >= 1); 3129 FCERRPRINT(FDEP_L0, FDEM_EXEC, 3130 (CE_CONT, "fdc_docmd: %x %x %x %x %x %x %x %x %x\n", 3131 oplistp[0], oplistp[1], oplistp[2], oplistp[3], oplistp[4], 3132 oplistp[5], oplistp[6], oplistp[7], oplistp[8])); 3133 3134 do { 3135 ntries = FDC_RQM_RETRY; 3136 do { 3137 if ((inb(fcp->c_regbase + FCR_MSR) & (MS_RQM|MS_DIO)) 3138 == MS_RQM) 3139 break; 3140 else 3141 drv_usecwait(1); 3142 } while (--ntries); 3143 if (ntries == 0) { 3144 FCERRPRINT(FDEP_L3, FDEM_EXEC, 3145 (CE_WARN, "fdc_docmd: ctlr not ready")); 3146 return (-1); 3147 } 3148 outb(fcp->c_regbase + FCR_DATA, *oplistp++); 3149 drv_usecwait(16); /* See comment in fdc_result() */ 3150 } while (--count); 3151 return (0); 3152 } 3153 3154 3155 /* 3156 * Routine to return controller/drive status information. 3157 * The diskette-controller data-register is read the 3158 * requested number of times and the results are placed in 3159 * consecutive memory locations starting at the passed 3160 * address. 3161 */ 3162 int 3163 fdc_result(struct fdcntlr *fcp, uchar_t *rsltp, uchar_t rcount) 3164 { 3165 int ntries; 3166 uchar_t *abresultp = rsltp; 3167 uchar_t stat; 3168 int laxative = 7; 3169 3170 ntries = 10 * FDC_RQM_RETRY; 3171 do { 3172 do { 3173 if ((inb(fcp->c_regbase + FCR_MSR) & 3174 (MS_RQM | MS_DIO)) == (MS_RQM | MS_DIO)) 3175 break; 3176 else 3177 drv_usecwait(10); 3178 } while (--ntries); 3179 if (!ntries) { 3180 FCERRPRINT(FDEP_L3, FDEM_EXEC, 3181 (CE_WARN, "fdc_result: ctlr not ready")); 3182 return (-2); 3183 } 3184 *rsltp++ = inb(fcp->c_regbase + FCR_DATA); 3185 3186 /* 3187 * The PRM suggests waiting for 14.5 us. 3188 * Adding a bit more to cover the case of bad calibration 3189 * of drv_usecwait(). 3190 */ 3191 drv_usecwait(16); 3192 ntries = FDC_RQM_RETRY; 3193 } while (--rcount); 3194 while ((inb(fcp->c_regbase + FCR_MSR) & MS_CB) && laxative--) { 3195 FCERRPRINT(FDEP_L3, FDEM_EXEC, 3196 (CE_WARN, "fdc_result: ctlr still busy")); 3197 /* 3198 * try to complete Result phase by purging 3199 * result bytes queued for reading 3200 */ 3201 *abresultp = S0_IVCMD; 3202 do { 3203 stat = inb(fcp->c_regbase + FCR_MSR) & 3204 (MS_RQM | MS_DIO); 3205 if (stat == MS_RQM) { 3206 /* 3207 * Result phase is complete 3208 * but did we get the results corresponding to 3209 * the command we think we executed? 3210 */ 3211 return (-1); 3212 } 3213 if (stat == (MS_RQM | MS_DIO)) 3214 break; 3215 else 3216 drv_usecwait(10); 3217 } while (--ntries); 3218 if (!ntries || !laxative) { 3219 FCERRPRINT(FDEP_L3, FDEM_EXEC, 3220 (CE_WARN, 3221 "fdc_result: ctlr still busy and not ready")); 3222 return (-3); 3223 } 3224 (void) inb(fcp->c_regbase + FCR_DATA); 3225 3226 drv_usecwait(16); /* See comment above */ 3227 ntries = FDC_RQM_RETRY; 3228 } 3229 return (0); 3230 } 3231 3232 /* 3233 * Function: get_unit() 3234 * 3235 * Assumptions: ioaddr is either 0x3f0 or 0x370 3236 */ 3237 static int 3238 get_unit(dev_info_t *dip, int *cntrl_num) 3239 { 3240 int ioaddr; 3241 3242 if (get_ioaddr(dip, &ioaddr) != DDI_SUCCESS) 3243 return (DDI_FAILURE); 3244 3245 switch (ioaddr) { 3246 case 0x3f0: 3247 *cntrl_num = 0; 3248 break; 3249 3250 case 0x370: 3251 *cntrl_num = 1; 3252 break; 3253 3254 default: 3255 return (DDI_FAILURE); 3256 } 3257 return (DDI_SUCCESS); 3258 } 3259 3260 static int 3261 get_ioaddr(dev_info_t *dip, int *ioaddr) 3262 { 3263 int reglen, nregs, i; 3264 int status = DDI_FAILURE; 3265 struct { 3266 int bustype; 3267 int base; 3268 int size; 3269 } *reglist; 3270 3271 if (ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 3272 "reg", (caddr_t)®list, ®len) != DDI_PROP_SUCCESS) { 3273 cmn_err(CE_WARN, "fdc: reg property not found"); 3274 return (DDI_FAILURE); 3275 } 3276 3277 nregs = reglen / sizeof (*reglist); 3278 for (i = 0; i < nregs; i++) { 3279 if (reglist[i].bustype == 1) { 3280 *ioaddr = reglist[i].base; 3281 status = DDI_SUCCESS; 3282 break; 3283 } 3284 } 3285 kmem_free(reglist, reglen); 3286 3287 if (status == DDI_SUCCESS) { 3288 if (*ioaddr == 0x3f2 || *ioaddr == 0x372) { 3289 /* 3290 * Some BIOS's (ASUS is one) don't include first 3291 * two IO ports in the floppy controller resources. 3292 */ 3293 3294 *ioaddr -= 2; /* step back to 0x3f0 or 0x370 */ 3295 3296 /* 3297 * It would be nice to update the regs property as well 3298 * so device pathname contains 3f0 instead of 3f2, but 3299 * updating the regs now won't have this effect as that 3300 * component of the device pathname has already been 3301 * constructed by the ISA nexus driver. 3302 * 3303 * reglist[i].base -= 2; 3304 * reglist[i].size += 2; 3305 * dev = makedevice(ddi_driver_major(dip), 0); 3306 * ddi_prop_update_int_array(dev, dip, "reg", 3307 * (int *)reglist, reglen / sizeof (int)); 3308 */ 3309 } 3310 } 3311 3312 return (status); 3313 } 3314