hdc9224.c revision 1.9.24.1
1 /* $NetBSD: hdc9224.c,v 1.9.24.1 2000/06/28 13:32:24 ragge 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 Bertram Barth. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. All advertising materials mentioning features or use of this software 17 * must display the following acknowledgement: 18 * This product includes software developed at Ludd, University of 19 * Lule}, Sweden and its contributors. 20 * 4. The name of the author may not be used to endorse or promote products 21 * derived from this software without specific prior written permission 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 26 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 28 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 32 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 /* 36 * with much help from (in alphabetical order): 37 * Jeremy 38 * Roger Ivie 39 * Rick Macklem 40 * Mike Young 41 * 42 * Rewritten by Ragge 25 Jun 2000. New features: 43 * - Uses interrupts instead of polling to signal ready. 44 * - Can cooperate with the SCSI routines WRT. the DMA area. 45 * 46 * TODO: 47 * - Floppy support missing. 48 * - Bad block forwarding missing. 49 * - Statistics collection. 50 */ 51 #undef RDDEBUG 52 53 #include <sys/param.h> 54 #include <sys/systm.h> 55 #include <sys/kernel.h> 56 #include <sys/conf.h> 57 #include <sys/file.h> 58 #include <sys/stat.h> 59 #include <sys/ioctl.h> 60 #include <sys/buf.h> 61 #include <sys/proc.h> 62 #include <sys/user.h> 63 #include <sys/map.h> 64 #include <sys/device.h> 65 #include <sys/dkstat.h> 66 #include <sys/disklabel.h> 67 #include <sys/disk.h> 68 #include <sys/syslog.h> 69 #include <sys/reboot.h> 70 71 #include <vm/vm.h> 72 #include <vm/vm_kern.h> 73 74 #include <ufs/ufs/dinode.h> /* For BBSIZE */ 75 #include <ufs/ffs/fs.h> 76 77 #include <machine/pte.h> 78 #include <machine/sid.h> 79 #include <machine/cpu.h> 80 #include <machine/uvax.h> 81 #include <machine/ka410.h> 82 #include <machine/vsbus.h> 83 #include <machine/rpb.h> 84 #include <machine/scb.h> 85 86 #include <dev/mscp/mscp.h> /* For DEC disk encoding */ 87 88 #include <vax/vsa/hdc9224.h> 89 90 #include "ioconf.h" 91 #include "locators.h" 92 93 94 /* 95 * on-disk geometry block 96 */ 97 #define _aP __attribute__ ((packed)) /* force byte-alignment */ 98 struct rdgeom { 99 char mbz[10]; /* 10 bytes of zero */ 100 long xbn_count _aP; /* number of XBNs */ 101 long dbn_count _aP; /* number of DBNs */ 102 long lbn_count _aP; /* number of LBNs (Logical-Block-Numbers) */ 103 long rbn_count _aP; /* number of RBNs (Replacement-Block-Numbers) */ 104 short nspt; /* number of sectors per track */ 105 short ntracks; /* number of tracks */ 106 short ncylinders; /* number of cylinders */ 107 short precomp; /* first cylinder for write precompensation */ 108 short reduced; /* first cylinder for reduced write current */ 109 short seek_rate; /* seek rate or zero for buffered seeks */ 110 short crc_eec; /* 0 if CRC, 1 if ECC is being used */ 111 short rct; /* "replacement control table" (RCT) */ 112 short rct_ncopies; /* number of copies of the RCT */ 113 long media_id _aP; /* media identifier */ 114 short interleave; /* sector-to-sector interleave */ 115 short headskew; /* head-to-head skew */ 116 short cylskew; /* cylinder-to-cylinder skew */ 117 short gap0_size; /* size of GAP 0 in the MFM format */ 118 short gap1_size; /* size of GAP 1 in the MFM format */ 119 short gap2_size; /* size of GAP 2 in the MFM format */ 120 short gap3_size; /* size of GAP 3 in the MFM format */ 121 short sync_value; /* sync value used when formatting */ 122 char reserved[32]; /* reserved for use by the RQDX formatter */ 123 short serial_number; /* serial number */ 124 #if 0 /* we don't need these 412 useless bytes ... */ 125 char fill[412-2]; /* Filler bytes to the end of the block */ 126 short checksum; /* checksum over the XBN */ 127 #endif 128 }; 129 130 /* 131 * Software status 132 */ 133 struct rdsoftc { 134 struct device sc_dev; /* must be here! (pseudo-OOP:) */ 135 struct disk sc_disk; /* disklabel etc. */ 136 struct rdgeom sc_xbn; /* on-disk geometry information */ 137 int sc_drive; /* physical unit number */ 138 }; 139 140 struct hdcsoftc { 141 struct device sc_dev; /* must be here (pseudo-OOP:) */ 142 struct evcnt sc_intrcnt; 143 struct vsbus_dma sc_vd; 144 vaddr_t sc_regs; /* register addresses */ 145 struct buf_queue sc_q; 146 struct buf *sc_active; 147 struct hdc9224_UDCreg sc_creg; /* (command) registers to be written */ 148 struct hdc9224_UDCreg sc_sreg; /* (status) registers being read */ 149 caddr_t sc_dmabase; /* */ 150 int sc_dmasize; 151 caddr_t sc_bufaddr; /* Current in-core address */ 152 int sc_diskblk; /* Current block on disk */ 153 int sc_bytecnt; /* How much left to transfer */ 154 int sc_xfer; /* Current transfer size */ 155 int sc_retries; 156 volatile u_char sc_status; /* last status from interrupt */ 157 char sc_intbit; 158 }; 159 160 struct hdc_attach_args { 161 int ha_drive; 162 }; 163 164 /* 165 * prototypes for (almost) all the internal routines 166 */ 167 static int hdcmatch(struct device *, struct cfdata *, void *); 168 static void hdcattach(struct device *, struct device *, void *); 169 static int hdcprint(void *, const char *); 170 static int rdmatch(struct device *, struct cfdata *, void *); 171 static void rdattach(struct device *, struct device *, void *); 172 static void hdcintr(void *); 173 static int hdc_command(struct hdcsoftc *, int); 174 static void rd_readgeom(struct hdcsoftc *, struct rdsoftc *); 175 #ifdef RDDEBUG 176 static void hdc_printgeom( struct rdgeom *); 177 #endif 178 static void hdc_writeregs(struct hdcsoftc *); 179 static void hdcstart(struct hdcsoftc *, struct buf *); 180 static int hdc_rdselect(struct hdcsoftc *, int); 181 static void rdmakelabel(struct disklabel *, struct rdgeom *); 182 static void hdc_writeregs(struct hdcsoftc *); 183 static void hdc_readregs(struct hdcsoftc *); 184 static void hdc_qstart(void *); 185 186 bdev_decl(rd); 187 cdev_decl(rd); 188 189 struct cfattach hdc_ca = { 190 sizeof(struct hdcsoftc), hdcmatch, hdcattach 191 }; 192 193 struct cfattach rd_ca = { 194 sizeof(struct rdsoftc), rdmatch, rdattach 195 }; 196 197 198 /* At least 0.7 uS between register accesses */ 199 static int rd_dmasize, inq = 0; 200 static int u; 201 #define WAIT asm("movl _u,_u;movl _u,_u;movl _u,_u; movl _u,_u") 202 203 #define HDC_WREG(x) *(volatile char *)(sc->sc_regs) = (x) 204 #define HDC_RREG *(volatile char *)(sc->sc_regs) 205 #define HDC_WCMD(x) *(volatile char *)(sc->sc_regs + 4) = (x) 206 #define HDC_RSTAT *(volatile char *)(sc->sc_regs + 4) 207 208 /* 209 * new-config's hdcmatch() is similiar to old-config's hdcprobe(), 210 * thus we probe for the existence of the controller and reset it. 211 * NB: we can't initialize the controller yet, since space for hdcsoftc 212 * is not yet allocated. Thus we do this in hdcattach()... 213 */ 214 int 215 hdcmatch(struct device *parent, struct cfdata *cf, void *aux) 216 { 217 struct vsbus_attach_args *va = aux; 218 volatile char *hdc_csr = (char *)va->va_addr; 219 int i; 220 221 u = 8; /* !!! - GCC */ 222 223 if (vax_boardtype == VAX_BTYP_49 || vax_boardtype == VAX_BTYP_46 224 || vax_boardtype == VAX_BTYP_48) 225 return 0; 226 227 hdc_csr[4] = DKC_CMD_RESET; /* reset chip */ 228 for (i = 0; i < 1000; i++) { 229 DELAY(1000); 230 if (hdc_csr[4] & DKC_ST_DONE) 231 break; 232 } 233 if (i == 100) 234 return 0; /* No response to reset */ 235 236 hdc_csr[4] = DKC_CMD_SETREGPTR|UDC_TERM; 237 WAIT; 238 hdc_csr[0] = UDC_TC_CRCPRE|UDC_TC_INTDONE; 239 WAIT; 240 hdc_csr[4] = DKC_CMD_DRDESELECT; /* Should be harmless */ 241 DELAY(1000); 242 return (1); 243 } 244 245 int 246 hdcprint(void *aux, const char *name) 247 { 248 struct hdc_attach_args *ha = aux; 249 250 if (name) 251 printf ("RD?? at %s drive %d", name, ha->ha_drive); 252 return UNCONF; 253 } 254 255 /* 256 * hdc_attach() probes for all possible devices 257 */ 258 void 259 hdcattach(struct device *parent, struct device *self, void *aux) 260 { 261 struct vsbus_attach_args *va = aux; 262 struct hdcsoftc *sc = (void *)self; 263 struct hdc_attach_args ha; 264 int status, i; 265 266 printf ("\n"); 267 /* 268 * Get interrupt vector, enable instrumentation. 269 */ 270 scb_vecalloc(va->va_cvec, hdcintr, sc, SCB_ISTACK, &sc->sc_intrcnt); 271 evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, NULL, 272 self->dv_xname, "intr"); 273 274 sc->sc_regs = vax_map_physmem(va->va_paddr, 1); 275 sc->sc_dmabase = (caddr_t)va->va_dmaaddr; 276 sc->sc_dmasize = va->va_dmasize; 277 sc->sc_intbit = va->va_maskno; 278 rd_dmasize = min(MAXPHYS, sc->sc_dmasize); /* Used in rd_minphys */ 279 280 sc->sc_vd.vd_go = hdc_qstart; 281 sc->sc_vd.vd_arg = sc; 282 /* 283 * Reset controller. 284 */ 285 HDC_WCMD(DKC_CMD_RESET); 286 DELAY(1000); 287 status = HDC_RSTAT; 288 if (status != (DKC_ST_DONE|DKC_TC_SUCCESS)) { 289 printf("%s: RESET failed, status 0x%x\n", 290 sc->sc_dev.dv_xname, status); 291 return; 292 } 293 BUFQ_INIT(&sc->sc_q); 294 295 /* 296 * now probe for all possible hard drives 297 */ 298 for (i = 0; i < 4; i++) { 299 if (i == 2) /* Floppy, needs special handling */ 300 continue; 301 HDC_WCMD(DKC_CMD_DRSELECT | i); 302 DELAY(1000); 303 status = HDC_RSTAT; 304 ha.ha_drive = i; 305 if ((status & DKC_ST_TERMCOD) == DKC_TC_SUCCESS) 306 config_found(self, (void *)&ha, hdcprint); 307 } 308 } 309 310 /* 311 * rdmatch() probes for the existence of a RD-type disk/floppy 312 */ 313 int 314 rdmatch(parent, cf, aux) 315 struct device *parent; 316 struct cfdata *cf; 317 void *aux; 318 { 319 struct hdc_attach_args *ha = aux; 320 321 if (cf->cf_loc[HDCCF_DRIVE] != HDCCF_DRIVE_DEFAULT && 322 cf->cf_loc[HDCCF_DRIVE] != ha->ha_drive) 323 return 0; 324 325 if (ha->ha_drive == 2) /* Always floppy, not supported */ 326 return 0; 327 328 return 1; 329 } 330 331 #define RDMAJOR 19 332 333 void 334 rdattach(struct device *parent, struct device *self, void *aux) 335 { 336 struct hdcsoftc *sc = (void*)parent; 337 struct rdsoftc *rd = (void*)self; 338 struct hdc_attach_args *ha = aux; 339 struct disklabel *dl; 340 char *msg; 341 342 rd->sc_drive = ha->ha_drive; 343 /* 344 * Initialize and attach the disk structure. 345 */ 346 rd->sc_disk.dk_name = rd->sc_dev.dv_xname; 347 disk_attach(&rd->sc_disk); 348 349 /* 350 * if it's not a floppy then evaluate the on-disk geometry. 351 * if neccessary correct the label... 352 */ 353 rd_readgeom(sc, rd); 354 disk_printtype(rd->sc_drive, rd->sc_xbn.media_id); 355 dl = rd->sc_disk.dk_label; 356 rdmakelabel(dl, &rd->sc_xbn); 357 printf("%s", rd->sc_dev.dv_xname); 358 msg = readdisklabel(MAKEDISKDEV(RDMAJOR, rd->sc_dev.dv_unit, RAW_PART), 359 rdstrategy, dl, NULL); 360 if (msg) 361 printf(": %s", msg); 362 printf(": size %d sectors\n", dl->d_secperunit); 363 #ifdef RDDEBUG 364 hdc_printgeom(&rd->sc_xbn); 365 #endif 366 } 367 368 void 369 hdcintr(void *arg) 370 { 371 struct hdcsoftc *sc = arg; 372 struct buf *bp; 373 374 sc->sc_status = HDC_RSTAT; 375 if (sc->sc_active == 0) 376 return; /* Complain? */ 377 378 if ((sc->sc_status & (DKC_ST_INTPEND|DKC_ST_DONE)) != 379 (DKC_ST_INTPEND|DKC_ST_DONE)) 380 return; /* Why spurious ints sometimes??? */ 381 382 bp = sc->sc_active; 383 sc->sc_active = 0; 384 if ((sc->sc_status & DKC_ST_TERMCOD) != DKC_TC_SUCCESS) { 385 int i; 386 u_char *g = (u_char *)&sc->sc_sreg; 387 388 if (sc->sc_retries++ < 3) { /* Allow 3 retries */ 389 hdcstart(sc, bp); 390 return; 391 } 392 printf("%s: failed, status 0x%x\n", 393 sc->sc_dev.dv_xname, sc->sc_status); 394 hdc_readregs(sc); 395 for (i = 0; i < 10; i++) 396 printf("%i: %x\n", i, g[i]); 397 bp->b_flags |= B_ERROR; 398 bp->b_error = ENXIO; 399 bp->b_resid = bp->b_bcount; 400 biodone(bp); 401 vsbus_dma_intr(); 402 return; 403 } 404 405 if (bp->b_flags & B_READ) { 406 vsbus_copytoproc(bp->b_proc, sc->sc_dmabase, sc->sc_bufaddr, 407 sc->sc_xfer); 408 } 409 sc->sc_diskblk += (sc->sc_xfer/DEV_BSIZE); 410 sc->sc_bytecnt -= sc->sc_xfer; 411 sc->sc_bufaddr += sc->sc_xfer; 412 413 if (sc->sc_bytecnt == 0) { /* Finished transfer */ 414 biodone(bp); 415 vsbus_dma_intr(); 416 } else 417 hdcstart(sc, bp); 418 } 419 420 /* 421 * 422 */ 423 void 424 rdstrategy(struct buf *bp) 425 { 426 struct rdsoftc *rd; 427 struct hdcsoftc *sc; 428 struct disklabel *lp; 429 int unit, s; 430 431 unit = DISKUNIT(bp->b_dev); 432 if (unit > rd_cd.cd_ndevs || (rd = rd_cd.cd_devs[unit]) == NULL) { 433 bp->b_error = ENXIO; 434 bp->b_flags |= B_ERROR; 435 goto done; 436 } 437 sc = (void *)rd->sc_dev.dv_parent; 438 439 lp = rd->sc_disk.dk_label; 440 if ((bounds_check_with_label(bp, lp, 1)) <= 0) 441 goto done; 442 443 if (bp->b_bcount == 0) 444 goto done; 445 446 bp->b_rawblkno = 447 bp->b_blkno + lp->d_partitions[DISKPART(bp->b_dev)].p_offset; 448 bp->b_cylinder = bp->b_rawblkno / lp->d_secpercyl; 449 450 s = splimp(); 451 disksort_cylinder(&sc->sc_q, bp); 452 if (inq == 0) { 453 inq = 1; 454 vsbus_dma_start(&sc->sc_vd); 455 } 456 splx(s); 457 return; 458 459 done: biodone(bp); 460 } 461 462 void 463 hdc_qstart(void *arg) 464 { 465 struct hdcsoftc *sc = arg; 466 467 inq = 0; 468 469 hdcstart(sc, 0); 470 if (BUFQ_FIRST(&sc->sc_q)) { 471 vsbus_dma_start(&sc->sc_vd); /* More to go */ 472 inq = 1; 473 } 474 } 475 476 void 477 hdcstart(struct hdcsoftc *sc, struct buf *ob) 478 { 479 struct hdc9224_UDCreg *p = &sc->sc_creg; 480 struct disklabel *lp; 481 struct rdsoftc *rd; 482 struct buf *bp; 483 int cn, sn, tn, bn, blks; 484 volatile char ch; 485 486 if (sc->sc_active) 487 return; /* Already doing something */ 488 489 490 if (ob == 0) { 491 bp = BUFQ_FIRST(&sc->sc_q); 492 if (bp == NULL) 493 return; /* Nothing to do */ 494 BUFQ_REMOVE(&sc->sc_q, bp); 495 sc->sc_bufaddr = bp->b_data; 496 sc->sc_diskblk = bp->b_rawblkno; 497 sc->sc_bytecnt = bp->b_bcount; 498 sc->sc_retries = 0; 499 bp->b_resid = 0; 500 } else 501 bp = ob; 502 503 rd = rd_cd.cd_devs[DISKUNIT(bp->b_dev)]; 504 hdc_rdselect(sc, rd->sc_drive); 505 sc->sc_active = bp; 506 507 bn = sc->sc_diskblk; 508 lp = rd->sc_disk.dk_label; 509 if (bn) { 510 cn = bn / lp->d_secpercyl; 511 sn = bn % lp->d_secpercyl; 512 tn = sn / lp->d_nsectors; 513 sn = sn % lp->d_nsectors; 514 } else 515 cn = sn = tn = 0; 516 517 cn++; /* first cylinder is reserved */ 518 519 bzero(p, sizeof(struct hdc9224_UDCreg)); 520 521 /* 522 * Tricky thing: the controller do itself only increase the sector 523 * number, not the track or cylinder number. Therefore the driver 524 * is not allowed to have transfers that crosses track boundaries. 525 */ 526 blks = sc->sc_bytecnt/DEV_BSIZE; 527 if ((sn + blks) > lp->d_nsectors) 528 blks = lp->d_nsectors - sn; 529 530 p->udc_dsect = sn; 531 p->udc_dcyl = cn & 0xff; 532 p->udc_dhead = ((cn >> 4) & 0x70) | tn; 533 p->udc_scnt = blks; 534 535 p->udc_rtcnt = UDC_RC_RTRYCNT; 536 p->udc_mode = UDC_MD_HDD; 537 p->udc_term = UDC_TC_CRCPRE|UDC_TC_INTDONE|UDC_TC_TDELDAT|UDC_TC_TWRFLT; 538 hdc_writeregs(sc); 539 540 /* Count up vars */ 541 sc->sc_xfer = blks * DEV_BSIZE; 542 543 ch = HDC_RSTAT; /* Avoid pending interrupts */ 544 WAIT; 545 vsbus_clrintr(sc->sc_intbit); /* Clear pending int's */ 546 547 if (bp->b_flags & B_READ) { 548 HDC_WCMD(DKC_CMD_READ_HDD); 549 } else { 550 vsbus_copyfromproc(bp->b_proc, sc->sc_bufaddr, sc->sc_dmabase, 551 sc->sc_xfer); 552 HDC_WCMD(DKC_CMD_WRITE_HDD); 553 } 554 } 555 556 void 557 rd_readgeom(struct hdcsoftc *sc, struct rdsoftc *rd) 558 { 559 struct hdc9224_UDCreg *p = &sc->sc_creg; 560 561 hdc_rdselect(sc, rd->sc_drive); /* select drive right now */ 562 563 bzero(p, sizeof(struct hdc9224_UDCreg)); 564 565 p->udc_scnt = 1; 566 p->udc_rtcnt = UDC_RC_RTRYCNT; 567 p->udc_mode = UDC_MD_HDD; 568 p->udc_term = UDC_TC_CRCPRE|UDC_TC_INTDONE|UDC_TC_TDELDAT|UDC_TC_TWPROT; 569 hdc_writeregs(sc); 570 sc->sc_status = 0; 571 HDC_WCMD(DKC_CMD_READ_HDD|2); 572 while ((sc->sc_status & DKC_ST_INTPEND) == 0) 573 ; 574 bcopy(sc->sc_dmabase, &rd->sc_xbn, sizeof(struct rdgeom)); 575 } 576 577 #ifdef RDDEBUG 578 /* 579 * display the contents of the on-disk geometry structure 580 */ 581 void 582 hdc_printgeom(p) 583 struct rdgeom *p; 584 { 585 printf ("**DiskData** XBNs: %ld, DBNs: %ld, LBNs: %ld, RBNs: %ld\n", 586 p->xbn_count, p->dbn_count, p->lbn_count, p->rbn_count); 587 printf ("sec/track: %d, tracks: %d, cyl: %d, precomp/reduced: %d/%d\n", 588 p->nspt, p->ntracks, p->ncylinders, p->precomp, p->reduced); 589 printf ("seek-rate: %d, crc/eec: %s, RCT: %d, RCT-copies: %d\n", 590 p->seek_rate, p->crc_eec?"EEC":"CRC", p->rct, p->rct_ncopies); 591 printf ("media-ID: %lx, interleave: %d, headskew: %d, cylskew: %d\n", 592 p->media_id, p->interleave, p->headskew, p->cylskew); 593 printf ("gap0: %d, gap1: %d, gap2: %d, gap3: %d, sync-value: %d\n", 594 p->gap0_size, p->gap1_size, p->gap2_size, p->gap3_size, 595 p->sync_value); 596 } 597 #endif 598 599 /* 600 * Return the size of a partition, if known, or -1 if not. 601 */ 602 int 603 rdsize(dev_t dev) 604 { 605 struct rdsoftc *rd; 606 int unit = DISKUNIT(dev); 607 int size; 608 609 if (unit >= rd_cd.cd_ndevs || rd_cd.cd_devs[unit] == 0) 610 return -1; 611 rd = rd_cd.cd_devs[unit]; 612 size = rd->sc_disk.dk_label->d_partitions[DISKPART(dev)].p_size * 613 (rd->sc_disk.dk_label->d_secsize / DEV_BSIZE); 614 615 return (size); 616 } 617 618 /* 619 * 620 */ 621 int 622 rdopen(dev_t dev, int flag, int fmt, struct proc *p) 623 { 624 struct rdsoftc *rd; 625 int unit, part; 626 627 unit = DISKUNIT(dev); 628 if (unit >= rd_cd.cd_ndevs) 629 return ENXIO; 630 rd = rd_cd.cd_devs[unit]; 631 if (rd == 0) 632 return ENXIO; 633 634 part = DISKPART(dev); 635 if (part >= rd->sc_disk.dk_label->d_npartitions) 636 return ENXIO; 637 638 switch (fmt) { 639 case S_IFCHR: 640 rd->sc_disk.dk_copenmask |= (1 << part); 641 break; 642 case S_IFBLK: 643 rd->sc_disk.dk_bopenmask |= (1 << part); 644 break; 645 } 646 rd->sc_disk.dk_openmask = 647 rd->sc_disk.dk_copenmask | rd->sc_disk.dk_bopenmask; 648 649 return 0; 650 } 651 652 /* 653 * 654 */ 655 int 656 rdclose(dev_t dev, int flag, int fmt, struct proc *p) 657 { 658 struct rdsoftc *rd; 659 int part; 660 661 rd = rd_cd.cd_devs[DISKUNIT(dev)]; 662 part = DISKPART(dev); 663 664 switch (fmt) { 665 case S_IFCHR: 666 rd->sc_disk.dk_copenmask &= ~(1 << part); 667 break; 668 case S_IFBLK: 669 rd->sc_disk.dk_bopenmask &= ~(1 << part); 670 break; 671 } 672 rd->sc_disk.dk_openmask = 673 rd->sc_disk.dk_copenmask | rd->sc_disk.dk_bopenmask; 674 675 return (0); 676 } 677 678 /* 679 * 680 */ 681 int 682 rdioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) 683 { 684 struct rdsoftc *rd = rd_cd.cd_devs[DISKUNIT(dev)]; 685 struct disklabel *lp = rd->sc_disk.dk_label; 686 int err = 0; 687 688 switch (cmd) { 689 case DIOCGDINFO: 690 bcopy(lp, addr, sizeof (struct disklabel)); 691 break; 692 693 case DIOCGPART: 694 ((struct partinfo *)addr)->disklab = lp; 695 ((struct partinfo *)addr)->part = 696 &lp->d_partitions[DISKPART(dev)]; 697 break; 698 699 case DIOCWDINFO: 700 case DIOCSDINFO: 701 if ((flag & FWRITE) == 0) 702 return EBADF; 703 else 704 err = (cmd == DIOCSDINFO ? 705 setdisklabel(lp, (struct disklabel *)addr, 0, 0) : 706 writedisklabel(dev, rdstrategy, lp, 0)); 707 break; 708 709 case DIOCGDEFLABEL: 710 bzero(lp, sizeof(struct disklabel)); 711 rdmakelabel(lp, &rd->sc_xbn); 712 break; 713 714 case DIOCWLABEL: 715 if ((flag & FWRITE) == 0) 716 err = EBADF; 717 break; 718 719 default: 720 err = ENOTTY; 721 } 722 return err; 723 } 724 725 /* 726 * 727 */ 728 int 729 rdread(dev_t dev, struct uio *uio, int flag) 730 { 731 return (physio (rdstrategy, NULL, dev, B_READ, minphys, uio)); 732 } 733 734 /* 735 * 736 */ 737 int 738 rdwrite(dev_t dev, struct uio *uio, int flag) 739 { 740 return (physio (rdstrategy, NULL, dev, B_WRITE, minphys, uio)); 741 } 742 743 /* 744 * 745 */ 746 int 747 rddump(dev_t dev, daddr_t daddr, caddr_t addr, size_t size) 748 { 749 return 0; 750 } 751 752 /* 753 * we have to wait 0.7 usec between two accesses to any of the 754 * dkc-registers, on a VS2000 with 1 MIPS, this is roughly one 755 * instruction. Thus the loop-overhead will be enough... 756 */ 757 static void 758 hdc_readregs(struct hdcsoftc *sc) 759 { 760 int i; 761 char *p; 762 763 HDC_WCMD(DKC_CMD_SETREGPTR); 764 WAIT; 765 p = (void*)&sc->sc_sreg; 766 for (i=0; i<10; i++) { 767 *p++ = HDC_RREG; /* dkc_reg auto-increments */ 768 WAIT; 769 } 770 } 771 772 static void 773 hdc_writeregs(struct hdcsoftc *sc) 774 { 775 int i; 776 char *p; 777 778 HDC_WCMD(DKC_CMD_SETREGPTR); 779 p = (void*)&sc->sc_creg; 780 for (i=0; i<10; i++) { 781 HDC_WREG(*p++); /* dkc_reg auto-increments */ 782 WAIT; 783 } 784 } 785 786 /* 787 * hdc_command() issues a command and polls the intreq-register 788 * to find when command has completed 789 */ 790 int 791 hdc_command(struct hdcsoftc *sc, int cmd) 792 { 793 hdc_writeregs(sc); /* write the prepared registers */ 794 HDC_WCMD(cmd); 795 WAIT; 796 return (0); 797 } 798 799 int 800 hdc_rdselect(struct hdcsoftc *sc, int unit) 801 { 802 struct hdc9224_UDCreg *p = &sc->sc_creg; 803 int error; 804 805 /* 806 * bring "creg" in some known-to-work state and 807 * select the drive with the DRIVE SELECT command. 808 */ 809 bzero(p, sizeof(struct hdc9224_UDCreg)); 810 811 p->udc_rtcnt = UDC_RC_HDD_READ; 812 p->udc_mode = UDC_MD_HDD; 813 p->udc_term = UDC_TC_HDD; 814 815 error = hdc_command(sc, DKC_CMD_DRSEL_HDD | unit); 816 817 return (error); 818 } 819 820 void 821 rdmakelabel(struct disklabel *dl, struct rdgeom *g) 822 { 823 int n, p = 0; 824 825 dl->d_bbsize = BBSIZE; 826 dl->d_sbsize = SBSIZE; 827 dl->d_typename[p++] = MSCP_MID_CHAR(2, g->media_id); 828 dl->d_typename[p++] = MSCP_MID_CHAR(1, g->media_id); 829 if (MSCP_MID_ECH(0, g->media_id)) 830 dl->d_typename[p++] = MSCP_MID_CHAR(0, g->media_id); 831 n = MSCP_MID_NUM(g->media_id); 832 if (n > 99) { 833 dl->d_typename[p++] = '1'; 834 n -= 100; 835 } 836 if (n > 9) { 837 dl->d_typename[p++] = (n / 10) + '0'; 838 n %= 10; 839 } 840 dl->d_typename[p++] = n + '0'; 841 dl->d_typename[p] = 0; 842 dl->d_type = DTYPE_MSCP; /* XXX - what to use here??? */ 843 dl->d_rpm = 3600; 844 dl->d_secsize = DEV_BSIZE; 845 846 dl->d_secperunit = g->lbn_count; 847 dl->d_nsectors = g->nspt; 848 dl->d_ntracks = g->ntracks; 849 dl->d_secpercyl = dl->d_nsectors * dl->d_ntracks; 850 dl->d_ncylinders = dl->d_secperunit / dl->d_secpercyl; 851 852 dl->d_npartitions = MAXPARTITIONS; 853 dl->d_partitions[0].p_size = dl->d_partitions[2].p_size = 854 dl->d_secperunit; 855 dl->d_partitions[0].p_offset = dl->d_partitions[2].p_offset = 0; 856 dl->d_interleave = dl->d_headswitch = 1; 857 dl->d_magic = dl->d_magic2 = DISKMAGIC; 858 dl->d_checksum = dkcksum(dl); 859 } 860
Indexes created Sun Oct 19 02:09:48 GMT 2025