1 /* $NetBSD: mfm.c,v 1.4 2001/07/26 22:55:13 wiz Exp $ */ 2 /* 3 * Copyright (c) 1996 Ludd, University of Lule}, Sweden. 4 * All rights reserved. 5 * 6 * This code is derived from software contributed to Ludd by 7 * Bertram Barth. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed at Ludd, University of 20 * Lule}, Sweden and its contributors. 21 * 4. The name of the author may not be used to endorse or promote products 22 * derived from this software without specific prior written permission 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 25 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 26 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 27 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 28 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 29 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 30 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 31 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 33 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 */ 35 36 /* 37 * ToDo: 38 * 39 * - insert appropriate delays for diskette-drive where needed 40 * - allow more than one sector per diskette-read 41 * - check for and handle bad sectors 42 * - ??? 43 */ 44 45 #include "sys/param.h" 46 #include "sys/reboot.h" 47 #include "sys/disklabel.h" 48 49 #include "lib/libsa/stand.h" 50 #include "lib/libsa/ufs.h" 51 52 #include "lib/libkern/libkern.h" 53 54 #include "../include/pte.h" 55 #include "../include/sid.h" 56 #include "../include/mtpr.h" 57 #include "../include/reg.h" 58 #include "../include/rpb.h" 59 60 #include "ka410.h" 61 #include "../vsa/hdc9224.h" 62 63 #include "data.h" 64 #include "vaxstand.h" 65 66 #define MAX_WAIT (1000*1000) /* # of loop-instructions in seconds */ 67 68 struct mfm_softc { 69 int part; 70 int unit; 71 }; 72 73 static struct disklabel mfmlabel; 74 static struct mfm_softc mfm_softc; 75 static char io_buf[DEV_BSIZE]; 76 77 /* 78 * These should probably be somewhere else, but ka410 is the only 79 * one with mfm disks anyway... 80 */ 81 volatile unsigned char *ka410_intreq = (void*)0x2008000f; 82 volatile unsigned char *ka410_intclr = (void*)0x2008000f; 83 volatile unsigned char *ka410_intmsk = (void*)0x2008000c; 84 85 static volatile struct hdc9224_DKCreg *dkc = (void *) 0x200c0000; 86 static volatile struct hdc9224_UDCreg sreg; /* input */ 87 static volatile struct hdc9224_UDCreg creg; /* output */ 88 89 static void sreg_read(void); 90 static void creg_write(void); 91 static int mfm_rxprepare(void); 92 static int mfm_command(int cmd); 93 static int mfm_rxselect(int unit); 94 static int mfm_rdselect(int unit); 95 static int mfm_rxstrategy(void *f, int func, daddr_t dblk, size_t size, void *buf, size_t *rsize); 96 static int mfm_rdstrategy(void *f, int func, daddr_t dblk, size_t size, void *buf, size_t *rsize); 97 /* 98 * we have to wait 0.7 usec between two accesses to any of the 99 * dkc-registers, on a VS2000 with 1 MIPS, this is roughly one 100 * instruction. Thus the loop-overhead will be enough... 101 */ 102 static void 103 sreg_read() 104 { 105 int i; 106 char *p; 107 108 dkc->dkc_cmd = 0x40; /* set internal counter to zero */ 109 p = (void *) &sreg; 110 for (i = 0; i < 10; i++) 111 *p++ = dkc->dkc_reg; /* dkc_reg auto-increments */ 112 } 113 114 static void 115 creg_write() 116 { 117 int i; 118 char *p; 119 120 dkc->dkc_cmd = 0x40; /* set internal counter to zero */ 121 p = (void *) &creg; 122 for (i = 0; i < 10; i++) 123 dkc->dkc_reg = *p++; /* dkc_reg auto-increments */ 124 } 125 126 /* 127 * floppies are handled in a quite strange way by this controller... 128 * 129 * before reading/writing a sector from/to floppy, we use the SEEK/READ_ID 130 * command to place the head at the desired location. Then we wait some 131 * time before issuing the real command in order to let the drive become 132 * ready... 133 */ 134 int 135 mfm_rxprepare() 136 { 137 int error; 138 139 error = mfm_command(DKC_CMD_SEEKREADID | 0x04); /* step=1, verify=0 */ 140 if (error) { 141 printf("error while stepping to position %d/%d/%x. Retry...\n", 142 creg.udc_dsect, creg.udc_dhead, creg.udc_dcyl); 143 error = mfm_command(DKC_CMD_SEEKREADID | 0x04); 144 } 145 return error; 146 } 147 148 int 149 mfm_rxselect(int unit) 150 { 151 int error; 152 153 /* 154 * bring "creg" in some known-to-work state and 155 * select the drive with the DRIVE SELECT command. 156 */ 157 creg.udc_dma7 = 0; 158 creg.udc_dma15 = 0; 159 creg.udc_dma23 = 0; 160 creg.udc_dsect = 1; /* sectors are numbered 1..15 !!! */ 161 creg.udc_dhead = 0; 162 creg.udc_dcyl = 0; 163 creg.udc_scnt = 0; 164 165 creg.udc_rtcnt = UDC_RC_RX33READ; 166 creg.udc_mode = UDC_MD_RX33; 167 creg.udc_term = UDC_TC_FDD; 168 169 /* 170 * this is ... 171 */ 172 error = mfm_command(DKC_CMD_DRSEL_RX33 | unit); 173 174 if ((error != 0) || ((sreg.udc_dstat & UDC_DS_READY) == 0)) { 175 printf("\nfloppy-drive not ready (new floppy inserted?)\n\n"); 176 177 creg.udc_rtcnt &= ~UDC_RC_INVRDY; /* clear INVRDY-flag */ 178 error = mfm_command(DKC_CMD_DRSEL_RX33 | unit); 179 if ((error != 0) || ((sreg.udc_dstat & UDC_DS_READY) == 0)) { 180 printf("diskette not ready(1): %x/%x\n", 181 error, sreg.udc_dstat); 182 printf("floppy-drive offline?\n"); 183 return (-1); 184 } 185 if (sreg.udc_dstat & UDC_DS_TRK00) 186 error = mfm_command(DKC_CMD_STEPIN_FDD); 187 else 188 error = mfm_command(DKC_CMD_STEPOUT_FDD); 189 190 /* 191 * now ready should be 0, cause INVRDY is not set 192 * (retrying a command makes this fail...) 193 */ 194 if ((error != 0) || ((sreg.udc_dstat & UDC_DS_READY) == 1)) { 195 printf("diskette not ready(2): %x/%x\n", 196 error, sreg.udc_dstat); 197 } 198 creg.udc_rtcnt |= UDC_RC_INVRDY; 199 error = mfm_command(DKC_CMD_DRSEL_RX33 | unit); 200 201 if ((error != 0) || ((sreg.udc_dstat & UDC_DS_READY) == 0)) { 202 printf("diskette not ready(3): %x/%x\n", 203 error, sreg.udc_dstat); 204 printf("no floppy inserted or floppy-door open\n"); 205 return (-1); 206 } 207 printf("floppy-drive reselected.\n"); 208 } 209 return (error); 210 } 211 212 int 213 mfm_rdselect(int unit) 214 { 215 int error; 216 217 /* 218 * bring "creg" in some known-to-work state and 219 * select the drive with the DRIVE SELECT command. 220 */ 221 creg.udc_dma7 = 0; 222 creg.udc_dma15 = 0; 223 creg.udc_dma23 = 0; 224 creg.udc_dsect = 0; /* sectors are numbered 0..16 */ 225 creg.udc_dhead = 0; 226 creg.udc_dcyl = 0; 227 creg.udc_scnt = 0; 228 229 creg.udc_rtcnt = UDC_RC_HDD_READ; 230 creg.udc_mode = UDC_MD_HDD; 231 creg.udc_term = UDC_TC_HDD; 232 233 error = mfm_command(DKC_CMD_DRSEL_HDD | unit); 234 235 return (error); 236 } 237 238 static int mfm_retry = 0; 239 240 int 241 mfm_command(int cmd) 242 { 243 int termcode, ready, i; 244 245 creg_write(); /* write command-registers */ 246 *ka410_intclr = INTR_DC; 247 dkc->dkc_cmd = cmd; /* issue command */ 248 for (i = 0; i < MAX_WAIT; i++) { 249 if (*ka410_intreq & INTR_DC) /* wait for interrupt */ 250 break; 251 } 252 if ((*ka410_intreq & INTR_DC) == 0) 253 printf("timeout in mfm_command...\n"); 254 255 sreg_read(); /* read status-registers */ 256 257 if (dkc->dkc_stat == (DKC_ST_DONE | DKC_TC_SUCCESS)) 258 return (0); 259 260 if (sreg.udc_cstat & UDC_CS_ECCERR) { 261 printf( 262 "\nspurious(?) ECC/CRC error at s%d/t%d/c%d [s%d/t%d/c%d(%d)]\n", 263 sreg.udc_csect, sreg.udc_chead, sreg.udc_ccyl, 264 creg.udc_dsect, creg.udc_dhead, creg.udc_dcyl,creg.udc_scnt); 265 if (sreg.udc_csect != creg.udc_dsect + creg.udc_scnt - 1) { 266 printf("DMA: %x %x %x [%x]\n", 267 sreg.udc_dma23, sreg.udc_dma15, 268 sreg.udc_dma7, 512 * (sreg.udc_csect - 269 creg.udc_dsect)); 270 creg.udc_scnt = creg.udc_scnt - 271 (sreg.udc_csect - creg.udc_dsect) - 1; 272 creg.udc_dsect = sreg.udc_csect + 1; 273 creg.udc_dma23 = sreg.udc_dma23; 274 creg.udc_dma15 = sreg.udc_dma15 + 2; 275 creg.udc_dma7 = 0; 276 printf("Retry starting from s%d/t%d/c%d (%d). ", 277 creg.udc_dsect, creg.udc_dhead, creg.udc_dcyl, 278 creg.udc_scnt); 279 } 280 goto retry; 281 } 282 termcode = (dkc->dkc_stat & DKC_ST_TERMCOD) >> 3; 283 ready = sreg.udc_dstat & UDC_DS_READY; 284 285 printf("cmd:0x%x: termcode=0x%x, status=0x%x, cstat=0x%x, dstat=0x%x\n", 286 cmd, termcode, dkc->dkc_stat, sreg.udc_cstat, sreg.udc_dstat); 287 288 if (dkc->dkc_stat & DKC_ST_BADSECT) 289 printf("bad sector found: s%d/t%d/c%d\n", creg.udc_dsect, 290 creg.udc_dhead, creg.udc_dcyl); 291 retry: 292 if ((mfm_retry == 0) && (sreg.udc_cstat & UDC_CS_RETREQ)) { 293 mfm_retry = 1; 294 printf("Retrying... "); 295 mfm_command(cmd); 296 printf("Retry done.\n"); 297 mfm_retry = 0; 298 } 299 return ((dkc->dkc_stat & DKC_ST_TERMCOD) >> 3); 300 } 301 302 /* 303 * on-disk geometry block 304 */ 305 #define _aP __attribute__ ((packed)) /* force byte-alignment */ 306 307 volatile struct mfm_xbn { 308 char mbz[10];/* 10 bytes of zero */ 309 long xbn_count _aP; /* number of XBNs */ 310 long dbn_count _aP; /* number of DBNs */ 311 long lbn_count _aP; /* number of LBNs (Logical-Block-Numbers) */ 312 long rbn_count _aP; /* number of RBNs (Replacement-Block-Numbers) */ 313 short nspt; /* number of sectors per track */ 314 short ntracks;/* number of tracks */ 315 short ncylinders; /* number of cylinders */ 316 short precomp;/* first cylinder for write precompensation */ 317 short reduced;/* first cylinder for reduced write current */ 318 short seek_rate; /* seek rate or zero for buffered 319 * seeks */ 320 short crc_eec;/* 0 if CRC is being used or 1 if ECC is 321 * being used */ 322 short rct; /* "replacement control table" (RCT) */ 323 short rct_ncopies; /* number of copies of the RCT */ 324 long media_id _aP; /* media identifier */ 325 short interleave; /* sector-to-sector interleave */ 326 short headskew; /* head-to-head skew */ 327 short cylskew;/* cylinder-to-cylinder skew */ 328 short gap0_size; /* size of GAP 0 in the MFM format */ 329 short gap1_size; /* size of GAP 1 in the MFM format */ 330 short gap2_size; /* size of GAP 2 in the MFM format */ 331 short gap3_size; /* size of GAP 3 in the MFM format */ 332 short sync_value; /* sync value used to start a track 333 * when formatting */ 334 char reserved[32]; /* reserved for use by the RQDX1/2/3 335 * formatter */ 336 short serial_number; /* serial number */ 337 char fill[412]; /* Filler bytes to the end of the 338 * block */ 339 short checksum; /* checksum over the XBN */ 340 } mfm_xbn; 341 342 #ifdef verbose 343 display_xbn(p) 344 struct mfm_xbn *p; 345 { 346 printf("**DiskData** XBNs: %d, DBNs: %d, LBNs: %d, RBNs: %d\n", 347 p->xbn_count, p->dbn_count, p->lbn_count, p->rbn_count); 348 printf("sect/track: %d, tracks: %d, cyl: %d, precomp/reduced: %d/%d\n", 349 p->nspt, p->ntracks, p->ncylinders, p->precomp, p->reduced); 350 printf("seek-rate: %d, crc/eec: %s, RCT: %d, RCT-copies: %d\n", 351 p->seek_rate, p->crc_eec ? "EEC" : "CRC", p->rct, p->rct_ncopies); 352 printf("media-ID: 0x%x, interleave: %d, headskew: %d, cylskew: %d\n", 353 &p->media_id, p->interleave, p->headskew, p->cylskew); 354 printf("gap0: %d, gap1: %d, gap2: %d, gap3: %d, sync-value: %d\n", 355 p->gap0_size, p->gap1_size, p->gap2_size, p->gap3_size, 356 p->sync_value); 357 printf("serial: %d, checksum: %d, size: %d, reserved: %32c\n", 358 p->serial_number, p->checksum, sizeof(*p), p->reserved); 359 } 360 #endif 361 362 int 363 mfmopen(f, adapt, ctlr, unit, part) 364 struct open_file *f; 365 int ctlr, unit, part; 366 { 367 char *msg; 368 struct disklabel *lp = &mfmlabel; 369 struct mfm_softc *msc = &mfm_softc; 370 int err; 371 size_t i; 372 373 bzero(lp, sizeof(struct disklabel)); 374 msc->unit = unit; 375 msc->part = part; 376 377 err = mfmstrategy(msc, F_READ, LABELSECTOR, DEV_BSIZE, io_buf, &i); 378 if (err) { 379 printf("reading disklabel: %s\n", strerror(err)); 380 return 0; 381 } 382 msg = getdisklabel(io_buf + LABELOFFSET, lp); 383 if (msg) 384 printf("getdisklabel: %s\n", msg); 385 386 f->f_devdata = (void *) msc; 387 388 { 389 #ifdef verbose 390 int k; 391 unsigned char *ucp; 392 struct mfm_xbn *xp; 393 #endif 394 395 /* mfmstrategy(msc, F_READ, -16, 8192, io_buf, &i); */ 396 mfmstrategy(msc, F_READ, -16, 512, io_buf, &i); 397 #ifdef verbose 398 printf("dumping raw disk-block #0:\n"); 399 ucp = io_buf; 400 for (k = 0; k < 128; k++) { 401 if (ucp[k] < 0x10) 402 printf("0"); 403 printf("%x ", ucp[k]); 404 if (k % 8 == 7) 405 printf(" "); 406 if (k % 16 == 15) 407 printf("\n"); 408 } 409 printf("\n"); 410 411 xp = (void *) io_buf; 412 display_xbn(xp); 413 printf("\n"); 414 #endif 415 } 416 417 if (unit == 2) { /* floppy! */ 418 if (lp->d_ntracks != 2) { 419 #ifdef verbose 420 printf("changing number of tracks from %d to %d.\n", 421 lp->d_ntracks, 2); 422 #endif 423 lp->d_ntracks = 2; 424 } 425 } else { /* hard-disk */ 426 unsigned short *usp = (void *) io_buf; 427 #ifdef verbose 428 printf("label says: s/t/c = %d/%d/%d\n", 429 lp->d_nsectors, lp->d_ntracks, lp->d_ncylinders); 430 #endif 431 if (lp->d_nsectors != usp[13]) { 432 #ifdef verbose 433 printf("changing number of sectors from %d to %d.\n", 434 lp->d_nsectors, usp[13]); 435 #endif 436 lp->d_nsectors = usp[13]; 437 } 438 if (lp->d_ntracks != usp[14]) { 439 #ifdef verbose 440 printf("changing number of heads/tracks from %d to %d.\n", 441 lp->d_ntracks, usp[14]); 442 #endif 443 lp->d_ntracks = usp[14]; 444 } 445 if (lp->d_ncylinders != usp[15]) { 446 #ifdef verbose 447 printf("changing number of cylinders from %d to %d.\n", 448 lp->d_ncylinders, usp[15]); 449 #endif 450 lp->d_ncylinders = usp[15]; 451 } 452 lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks; 453 } 454 455 return (0); 456 } 457 458 int 459 mfm_rxstrategy(void *f, int func, daddr_t dblk, size_t size, void *buf, size_t *rsize) { 460 struct mfm_softc *msc = f; 461 struct disklabel *lp; 462 int block, sect, head, cyl, scount, res; 463 464 lp = &mfmlabel; 465 block = (dblk < 0 ? 0 : dblk + lp->d_partitions[msc->part].p_offset); 466 467 mfm_rxselect(msc->unit); 468 469 /* 470 * if label is empty, assume RX33 471 */ 472 if (lp->d_nsectors == 0) 473 lp->d_nsectors = 15; 474 if (lp->d_ntracks == 0) 475 lp->d_ntracks = 2; 476 if (lp->d_secpercyl == 0) 477 lp->d_secpercyl = 30; 478 479 bzero((void *) 0x200D0000, size); 480 scount = size / 512; 481 482 while (scount) { 483 /* 484 * prepare drive/operation parameter 485 */ 486 cyl = block / lp->d_secpercyl; 487 sect = block % lp->d_secpercyl; 488 head = sect / lp->d_nsectors; 489 sect = sect % lp->d_nsectors; 490 491 /* 492 * *rsize = 512; one sector after the other 493 * ... 494 */ 495 *rsize = 512 * min(scount, lp->d_nsectors - sect); 496 497 /* 498 * now initialize the register values ... 499 */ 500 creg.udc_dma7 = 0; 501 creg.udc_dma15 = 0; 502 creg.udc_dma23 = 0; 503 504 creg.udc_dsect = sect + 1; /* sectors are numbered 1..15 505 * !!! */ 506 head |= (cyl >> 4) & 0x70; 507 creg.udc_dhead = head; 508 creg.udc_dcyl = cyl; 509 510 creg.udc_scnt = *rsize / 512; 511 512 if (func == F_WRITE) { 513 creg.udc_rtcnt = UDC_RC_RX33WRT; 514 creg.udc_mode = UDC_MD_RX33; 515 creg.udc_term = UDC_TC_FDD; 516 517 mfm_rxprepare(); 518 /* copy from buf */ 519 bcopy(buf, (void *) 0x200D0000, *rsize); 520 res = mfm_command(DKC_CMD_WRITE_RX33); 521 } else { 522 creg.udc_rtcnt = UDC_RC_RX33READ; 523 creg.udc_mode = UDC_MD_RX33; 524 creg.udc_term = UDC_TC_FDD; 525 526 mfm_rxprepare(); 527 /* clear disk buffer */ 528 bzero((void *) 0x200D0000, *rsize); 529 res = mfm_command(DKC_CMD_READ_RX33); 530 /* copy to buf */ 531 bcopy((void *) 0x200D0000, buf, *rsize); 532 } 533 534 scount -= *rsize / 512; 535 block += *rsize / 512; 536 (char *)buf += *rsize; 537 } 538 539 *rsize = size; 540 return 0; 541 } 542 543 int 544 mfm_rdstrategy(void *f, int func, daddr_t dblk, size_t size, void *buf, size_t *rsize) { 545 struct mfm_softc *msc = f; 546 struct disklabel *lp; 547 int block, sect, head, cyl, scount, cmd, res; 548 549 lp = &mfmlabel; 550 block = (dblk < 0 ? 0 : dblk + lp->d_partitions[msc->part].p_offset); 551 552 /* 553 * if label is empty, assume RD32 (XXX this must go away!!!) 554 */ 555 if (lp->d_nsectors == 0) 556 lp->d_nsectors = 17; 557 if (lp->d_ntracks == 0) 558 lp->d_ntracks = 6; 559 if (lp->d_secpercyl == 0) 560 lp->d_secpercyl = 102; 561 562 mfm_rdselect(msc->unit); 563 564 bzero((void *) 0x200D0000, size); 565 scount = size / 512; 566 567 while (scount) { 568 /* 569 * prepare drive/operation parameter 570 */ 571 cyl = block / lp->d_secpercyl; 572 sect = block % lp->d_secpercyl; 573 head = sect / lp->d_nsectors; 574 sect = sect % lp->d_nsectors; 575 576 if (dblk < 0) { 577 #ifdef verbose 578 printf("using raw diskblock-data!\n"); 579 printf("block %d, dblk %d ==> cyl %d, head %d, sect %d\n", 580 block, dblk, cyl, sect, head); 581 #endif 582 } else 583 cyl += 1; /* first cylinder is reserved for 584 * controller! */ 585 586 *rsize = 512 * min(scount, lp->d_nsectors - sect); 587 /* 588 * now re-initialize the register values ... 589 */ 590 creg.udc_dma7 = 0; 591 creg.udc_dma15 = 0; 592 creg.udc_dma23 = 0; 593 594 creg.udc_dsect = sect; 595 head |= (cyl >> 4) & 0x70; 596 creg.udc_dhead = head; 597 creg.udc_dcyl = cyl; 598 599 creg.udc_scnt = *rsize / 512; 600 601 if (func == F_WRITE) { 602 creg.udc_rtcnt = UDC_RC_HDD_WRT; 603 creg.udc_mode = UDC_MD_HDD; 604 creg.udc_term = UDC_TC_HDD; 605 cmd = DKC_CMD_WRITE_HDD; 606 607 bcopy(buf, (void *) 0x200D0000, *rsize); 608 res = mfm_command(cmd); 609 } else { 610 creg.udc_rtcnt = UDC_RC_HDD_READ; 611 creg.udc_mode = UDC_MD_HDD; 612 creg.udc_term = UDC_TC_HDD; 613 cmd = DKC_CMD_READ_HDD; 614 615 bzero((void *) 0x200D0000, *rsize); 616 res = mfm_command(cmd); 617 bcopy((void *) 0x200D0000, buf, *rsize); 618 } 619 620 scount -= *rsize / 512; 621 block += *rsize / 512; 622 (char *)buf += *rsize; 623 } 624 625 /* 626 * unselect the drive ... 627 */ 628 mfm_command(DKC_CMD_DRDESELECT); 629 630 *rsize = size; 631 return 0; 632 } 633 634 int 635 mfmstrategy(f, func, dblk, size, buf, rsize) 636 void *f; 637 int func; 638 daddr_t dblk; 639 void *buf; 640 size_t size, *rsize; 641 { 642 struct mfm_softc *msc = f; 643 int res = -1; 644 645 switch (msc->unit) { 646 case 0: 647 case 1: 648 res = mfm_rdstrategy(f, func, dblk, size, buf, rsize); 649 break; 650 case 2: 651 res = mfm_rxstrategy(f, func, dblk, size, buf, rsize); 652 break; 653 default: 654 printf("invalid unit %d in mfmstrategy()\n", msc->unit); 655 } 656 return (res); 657 } 658