1 /* $NetBSD: mfm.c,v 1.13 2009/10/26 19:16:58 cegger 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(void) 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(void) 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(void) 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(struct mfm_xbn *p) 344 { 345 printf("**DiskData** XBNs: %d, DBNs: %d, LBNs: %d, RBNs: %d\n", 346 p->xbn_count, p->dbn_count, p->lbn_count, p->rbn_count); 347 printf("sect/track: %d, tracks: %d, cyl: %d, precomp/reduced: %d/%d\n", 348 p->nspt, p->ntracks, p->ncylinders, p->precomp, p->reduced); 349 printf("seek-rate: %d, crc/eec: %s, RCT: %d, RCT-copies: %d\n", 350 p->seek_rate, p->crc_eec ? "EEC" : "CRC", p->rct, p->rct_ncopies); 351 printf("media-ID: 0x%x, interleave: %d, headskew: %d, cylskew: %d\n", 352 &p->media_id, p->interleave, p->headskew, p->cylskew); 353 printf("gap0: %d, gap1: %d, gap2: %d, gap3: %d, sync-value: %d\n", 354 p->gap0_size, p->gap1_size, p->gap2_size, p->gap3_size, 355 p->sync_value); 356 printf("serial: %d, checksum: %d, size: %d, reserved: %32c\n", 357 p->serial_number, p->checksum, sizeof(*p), p->reserved); 358 } 359 #endif 360 361 int 362 mfmopen(struct open_file *f, int adapt, int ctlr, int unit, int part) 363 { 364 char *msg; 365 struct disklabel *lp = &mfmlabel; 366 struct mfm_softc *msc = &mfm_softc; 367 int err; 368 size_t i; 369 370 memset(lp, 0, sizeof(struct disklabel)); 371 msc->unit = unit; 372 msc->part = part; 373 374 err = mfmstrategy(msc, F_READ, LABELSECTOR, DEV_BSIZE, io_buf, &i); 375 if (err) { 376 printf("reading disklabel: %s\n", strerror(err)); 377 return 0; 378 } 379 msg = getdisklabel(io_buf + LABELOFFSET, lp); 380 if (msg) 381 printf("getdisklabel: %s\n", msg); 382 383 f->f_devdata = (void *) msc; 384 385 { 386 #ifdef verbose 387 int k; 388 unsigned char *ucp; 389 struct mfm_xbn *xp; 390 #endif 391 392 /* mfmstrategy(msc, F_READ, -16, 8192, io_buf, &i); */ 393 mfmstrategy(msc, F_READ, -16, 512, io_buf, &i); 394 #ifdef verbose 395 printf("dumping raw disk-block #0:\n"); 396 ucp = io_buf; 397 for (k = 0; k < 128; k++) { 398 if (ucp[k] < 0x10) 399 printf("0"); 400 printf("%x ", ucp[k]); 401 if (k % 8 == 7) 402 printf(" "); 403 if (k % 16 == 15) 404 printf("\n"); 405 } 406 printf("\n"); 407 408 xp = (void *) io_buf; 409 display_xbn(xp); 410 printf("\n"); 411 #endif 412 } 413 414 if (unit == 2) { /* floppy! */ 415 if (lp->d_ntracks != 2) { 416 #ifdef verbose 417 printf("changing number of tracks from %d to %d.\n", 418 lp->d_ntracks, 2); 419 #endif 420 lp->d_ntracks = 2; 421 } 422 } else { /* hard-disk */ 423 unsigned short *usp = (void *) io_buf; 424 #ifdef verbose 425 printf("label says: s/t/c = %d/%d/%d\n", 426 lp->d_nsectors, lp->d_ntracks, lp->d_ncylinders); 427 #endif 428 if (lp->d_nsectors != usp[13]) { 429 #ifdef verbose 430 printf("changing number of sectors from %d to %d.\n", 431 lp->d_nsectors, usp[13]); 432 #endif 433 lp->d_nsectors = usp[13]; 434 } 435 if (lp->d_ntracks != usp[14]) { 436 #ifdef verbose 437 printf("changing number of heads/tracks from %d to %d.\n", 438 lp->d_ntracks, usp[14]); 439 #endif 440 lp->d_ntracks = usp[14]; 441 } 442 if (lp->d_ncylinders != usp[15]) { 443 #ifdef verbose 444 printf("changing number of cylinders from %d to %d.\n", 445 lp->d_ncylinders, usp[15]); 446 #endif 447 lp->d_ncylinders = usp[15]; 448 } 449 lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks; 450 } 451 452 return (0); 453 } 454 455 int 456 mfm_rxstrategy(void *f, int func, daddr_t dblk, size_t size, void *buf, size_t *rsize) { 457 struct mfm_softc *msc = f; 458 struct disklabel *lp; 459 int block, sect, head, cyl, scount, res; 460 char *cbuf; 461 462 cbuf = (char*)buf; 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 memset((void *) 0x200D0000, 0, 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 memcpy((void *) 0x200D0000, cbuf, *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 memset((void *) 0x200D0000, 0, *rsize); 529 res = mfm_command(DKC_CMD_READ_RX33); 530 /* copy to buf */ 531 memcpy(cbuf, (void *) 0x200D0000, *rsize); 532 } 533 534 scount -= *rsize / 512; 535 block += *rsize / 512; 536 cbuf += *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 char *cbuf; 549 550 cbuf = (char *)buf; 551 552 lp = &mfmlabel; 553 block = (dblk < 0 ? 0 : dblk + lp->d_partitions[msc->part].p_offset); 554 555 /* 556 * if label is empty, assume RD32 (XXX this must go away!!!) 557 */ 558 if (lp->d_nsectors == 0) 559 lp->d_nsectors = 17; 560 if (lp->d_ntracks == 0) 561 lp->d_ntracks = 6; 562 if (lp->d_secpercyl == 0) 563 lp->d_secpercyl = 102; 564 565 mfm_rdselect(msc->unit); 566 567 memset((void *) 0x200D0000, 0, size); 568 scount = size / 512; 569 570 while (scount) { 571 /* 572 * prepare drive/operation parameter 573 */ 574 cyl = block / lp->d_secpercyl; 575 sect = block % lp->d_secpercyl; 576 head = sect / lp->d_nsectors; 577 sect = sect % lp->d_nsectors; 578 579 if (dblk < 0) { 580 #ifdef verbose 581 printf("using raw diskblock-data!\n"); 582 printf("block %d, dblk %d ==> cyl %d, head %d, sect %d\n", 583 block, dblk, cyl, sect, head); 584 #endif 585 } else 586 cyl += 1; /* first cylinder is reserved for 587 * controller! */ 588 589 *rsize = 512 * min(scount, lp->d_nsectors - sect); 590 /* 591 * now re-initialize the register values ... 592 */ 593 creg.udc_dma7 = 0; 594 creg.udc_dma15 = 0; 595 creg.udc_dma23 = 0; 596 597 creg.udc_dsect = sect; 598 head |= (cyl >> 4) & 0x70; 599 creg.udc_dhead = head; 600 creg.udc_dcyl = cyl; 601 602 creg.udc_scnt = *rsize / 512; 603 604 if (func == F_WRITE) { 605 creg.udc_rtcnt = UDC_RC_HDD_WRT; 606 creg.udc_mode = UDC_MD_HDD; 607 creg.udc_term = UDC_TC_HDD; 608 cmd = DKC_CMD_WRITE_HDD; 609 610 memcpy((void *) 0x200D0000, cbuf, *rsize); 611 res = mfm_command(cmd); 612 } else { 613 creg.udc_rtcnt = UDC_RC_HDD_READ; 614 creg.udc_mode = UDC_MD_HDD; 615 creg.udc_term = UDC_TC_HDD; 616 cmd = DKC_CMD_READ_HDD; 617 618 memset((void *) 0x200D0000, 0, *rsize); 619 res = mfm_command(cmd); 620 memcpy(cbuf, (void *) 0x200D0000, *rsize); 621 } 622 623 scount -= *rsize / 512; 624 block += *rsize / 512; 625 cbuf += *rsize; 626 } 627 628 /* 629 * unselect the drive ... 630 */ 631 mfm_command(DKC_CMD_DRDESELECT); 632 633 *rsize = size; 634 return 0; 635 } 636 637 int 638 mfmstrategy(void *f, int func, daddr_t dblk, size_t size, void *buf, size_t *rsize) 639 { 640 struct mfm_softc *msc = f; 641 int res = -1; 642 643 switch (msc->unit) { 644 case 0: 645 case 1: 646 res = mfm_rdstrategy(f, func, dblk, size, buf, rsize); 647 break; 648 case 2: 649 res = mfm_rxstrategy(f, func, dblk, size, buf, rsize); 650 break; 651 default: 652 printf("invalid unit %d in mfmstrategy()\n", msc->unit); 653 } 654 return (res); 655 } 656