hp.c revision 1.4
1 /* $NetBSD: hp.c,v 1.4 1996/02/11 13:19:33 ragge Exp $ */ 2 /* 3 * Copyright (c) 1996 Ludd, University of Lule}, Sweden. 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed at Ludd, University of 17 * Lule}, Sweden and its contributors. 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 /* 34 * Simple device driver routine for massbuss disks. 35 * TODO: 36 * Fix support for Standard DEC BAD144 bad block forwarding. 37 * Be able to to handle soft/hard transfer errors. 38 * Handle non-data transfer interrupts. 39 * Autoconfiguration of disk drives 'on the fly'. 40 * Handle disk media changes. 41 * Dual-port operations should be supported. 42 */ 43 #include <sys/param.h> 44 #include <sys/device.h> 45 #include <sys/disklabel.h> 46 #include <sys/disk.h> 47 #include <sys/dkio.h> 48 #include <sys/buf.h> 49 #include <sys/stat.h> 50 #include <sys/ioccom.h> 51 #include <sys/fcntl.h> 52 #include <sys/syslog.h> 53 54 #include <machine/trap.h> 55 #include <machine/pte.h> 56 #include <machine/mtpr.h> 57 58 #include <vax/mba/mbavar.h> 59 #include <vax/mba/mbareg.h> 60 #include <vax/mba/hpreg.h> 61 62 #define HPMASK 0xffff 63 64 struct hp_softc { 65 struct device sc_dev; 66 struct disk sc_disk; 67 struct mba_device sc_md; /* Common struct used by mbaqueue. */ 68 }; 69 70 int hpmatch __P((struct device *, void *, void *)); 71 void hpattach __P((struct device *, struct device *, void *)); 72 void hpstrategy __P((struct buf *)); 73 void hpstart __P((struct mba_device *)); 74 int hpattn __P((struct mba_device *)); 75 enum xfer_action hpfinish __P((struct mba_device *, int, int *)); 76 int hpopen __P((dev_t, int, int)); 77 int hpclose __P((dev_t, int, int)); 78 int hpioctl __P((dev_t, u_long, caddr_t, int, struct proc *)); 79 int hpdump __P((dev_t, caddr_t, caddr_t, size_t)); 80 int hpread __P((dev_t, struct uio *)); 81 int hpwrite __P((dev_t, struct uio *)); 82 int hpsize __P((dev_t)); 83 84 struct cfdriver hpcd = { 85 NULL, "hp", hpmatch, hpattach, DV_DISK, sizeof(struct hp_softc) 86 }; 87 88 /* 89 * Check if this is a disk drive; done by checking type from mbaattach. 90 */ 91 int 92 hpmatch(parent, match, aux) 93 struct device *parent; 94 void *match, *aux; 95 { 96 struct cfdata *cf = match; 97 struct mba_attach_args *ma = aux; 98 99 if (cf->cf_loc[0] != -1 && cf->cf_loc[0] != ma->unit) 100 return 0; 101 102 if (ma->devtyp != MB_RP) 103 return 0; 104 105 return 1; 106 } 107 108 /* 109 * Disk drive found; fake a disklabel and try to read the real one. 110 * If the on-disk label can't be read; we lose. 111 */ 112 void 113 hpattach(parent, self, aux) 114 struct device *parent, *self; 115 void *aux; 116 { 117 struct hp_softc *sc = (void *)self; 118 struct mba_softc *ms = (void *)parent; 119 struct disklabel *dl; 120 struct mba_attach_args *ma = aux; 121 char *msg; 122 123 /* 124 * Init the common struct for both the adapter and its slaves. 125 */ 126 sc->sc_md.md_softc = (void *)sc; /* Pointer to this softc */ 127 sc->sc_md.md_mba = (void *)parent; /* Pointer to parent softc */ 128 sc->sc_md.md_start = hpstart; /* Disk start routine */ 129 sc->sc_md.md_attn = hpattn; /* Disk attention routine */ 130 sc->sc_md.md_finish = hpfinish; /* Disk xfer finish routine */ 131 132 ms->sc_md[ma->unit] = &sc->sc_md; /* Per-unit backpointer */ 133 134 /* 135 * Init and attach the disk structure. 136 */ 137 sc->sc_disk.dk_name = sc->sc_dev.dv_xname; 138 disk_attach(&sc->sc_disk); 139 140 /* 141 * Fake a disklabel to be able to read in the real label. 142 */ 143 dl = sc->sc_disk.dk_label; 144 145 dl->d_secsize = DEV_BSIZE; 146 dl->d_ntracks = 1; 147 dl->d_nsectors = 32; 148 dl->d_secpercyl = 32; 149 150 /* 151 * Read in label. 152 */ 153 if ((msg = readdisklabel(makedev(0, self->dv_unit * 8), hpstrategy, 154 dl, NULL)) != NULL) 155 printf(": %s", msg); 156 printf(": %s, size = %d sectors\n", dl->d_typename, dl->d_secperunit); 157 } 158 159 160 void 161 hpstrategy(bp) 162 struct buf *bp; 163 { 164 struct hp_softc *sc; 165 struct buf *gp; 166 int unit, s; 167 168 unit = DISKUNIT(bp->b_dev); 169 sc = hpcd.cd_devs[unit]; 170 171 if (bounds_check_with_label(bp, sc->sc_disk.dk_label, 0) <= 0) 172 goto done; 173 174 if (bp->b_flags & B_WRITE) { 175 bp->b_error = EROFS; 176 bp->b_flags |= B_ERROR; 177 goto err; 178 } 179 s = splbio(); 180 181 gp = sc->sc_md.md_q.b_actf; 182 disksort(&sc->sc_md.md_q, bp); 183 if (gp == 0) 184 mbaqueue(&sc->sc_md); 185 186 splx(s); 187 return; 188 189 done: 190 bp->b_resid = bp->b_bcount; 191 err: 192 biodone(bp); 193 } 194 195 /* 196 * Start transfer on given disk. Called from mbastart(). 197 */ 198 void 199 hpstart(md) 200 struct mba_device *md; 201 { 202 struct hp_softc *sc = md->md_softc; 203 struct mba_regs *mr = md->md_mba->sc_mbareg; 204 volatile struct hp_regs *hr; 205 struct disklabel *lp = sc->sc_disk.dk_label; 206 struct buf *bp = md->md_q.b_actf; 207 unsigned bn, cn, sn, tn; 208 int part = DISKPART(bp->b_dev); 209 210 /* 211 * Collect statistics. 212 */ 213 disk_busy(&sc->sc_disk); 214 sc->sc_disk.dk_seek++; 215 216 hr = (void *)&mr->mba_md[DISKUNIT(bp->b_dev)]; 217 218 bn = bp->b_blkno + lp->d_partitions[part].p_offset; 219 if (bn) { 220 cn = bn / lp->d_secpercyl; 221 sn = bn % lp->d_secpercyl; 222 tn = sn / lp->d_nsectors; 223 sn = sn % lp->d_nsectors; 224 } else 225 cn = sn = tn = 0; 226 227 hr->hp_dc = cn; 228 hr->hp_da = (tn << 8) | sn; 229 if (bp->b_flags & B_READ) 230 hr->hp_cs1 = HPCS_READ; /* GO */ 231 else 232 hr->hp_cs1 = HPCS_WRITE; 233 } 234 235 int 236 hpopen(dev, flag, fmt) 237 dev_t dev; 238 int flag, fmt; 239 { 240 struct hp_softc *sc; 241 int unit, part; 242 243 unit = DISKUNIT(dev); 244 if (unit >= hpcd.cd_ndevs) 245 return ENXIO; 246 sc = hpcd.cd_devs[unit]; 247 if (sc == 0) 248 return ENXIO; 249 250 part = DISKPART(dev); 251 252 if ( (part >= sc->sc_disk.dk_label->d_npartitions || 253 sc->sc_disk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) 254 return ENXIO; 255 256 switch (fmt) { 257 case S_IFCHR: 258 sc->sc_disk.dk_copenmask |= (1 << part); 259 break; 260 261 case S_IFBLK: 262 sc->sc_disk.dk_bopenmask |= (1 << part); 263 break; 264 } 265 sc->sc_disk.dk_openmask = 266 sc->sc_disk.dk_copenmask | sc->sc_disk.dk_bopenmask; 267 268 return 0; 269 } 270 271 int 272 hpclose(dev, flag, fmt) 273 dev_t dev; 274 int flag, fmt; 275 { 276 struct hp_softc *sc; 277 int unit, part; 278 279 unit = DISKUNIT(dev); 280 sc = hpcd.cd_devs[unit]; 281 282 part = DISKPART(dev); 283 284 switch (fmt) { 285 case S_IFCHR: 286 sc->sc_disk.dk_copenmask &= ~(1 << part); 287 break; 288 289 case S_IFBLK: 290 sc->sc_disk.dk_bopenmask &= ~(1 << part); 291 break; 292 } 293 sc->sc_disk.dk_openmask = 294 sc->sc_disk.dk_copenmask | sc->sc_disk.dk_bopenmask; 295 296 return 0; 297 } 298 299 int 300 hpioctl(dev, cmd, addr, flag, p) 301 dev_t dev; 302 u_long cmd; 303 caddr_t addr; 304 int flag; 305 struct proc *p; 306 { 307 struct hp_softc *sc = hpcd.cd_devs[DISKUNIT(dev)]; 308 struct disklabel *lp = sc->sc_disk.dk_label; 309 310 switch (cmd) { 311 case DIOCGDINFO: 312 bcopy(lp, addr, sizeof (struct disklabel)); 313 return 0; 314 315 case DIOCGPART: 316 ((struct partinfo *)addr)->disklab = lp; 317 ((struct partinfo *)addr)->part = 318 &lp->d_partitions[DISKPART(dev)]; 319 break; 320 321 case DIOCSDINFO: 322 if ((flag & FWRITE) == 0) 323 return EBADF; 324 325 return setdisklabel(lp, (struct disklabel *)addr, 0, 0); 326 327 case DIOCWDINFO: 328 if ((flag & FWRITE) == 0) 329 return EBADF; 330 331 return writedisklabel(dev, hpstrategy, sc->sc_disk.dk_label, 0); 332 333 default: 334 printf("hpioctl: command %d\n", cmd); 335 return ENOTTY; 336 } 337 } 338 339 /* 340 * Called when a transfer is finished. Check if transfer went OK, 341 * Return info about what-to-do-now. 342 */ 343 enum xfer_action 344 hpfinish(md, mbasr, attn) 345 struct mba_device *md; 346 int mbasr, *attn; 347 { 348 struct hp_softc *sc = md->md_softc; 349 struct buf *bp = md->md_q.b_actf; 350 volatile struct mba_regs *mr = md->md_mba->sc_mbareg; 351 volatile struct hp_regs *hr = (void *)&mr->mba_md[DISKUNIT(bp->b_dev)]; 352 int er1, er2; 353 volatile int bc; /* to get GCC read whole longword */ 354 unsigned byte; 355 356 er1 = hr->hp_er1 & HPMASK; 357 er2 = hr->hp_er2 & HPMASK; 358 hr->hp_er1 = hr->hp_er2 = 0; 359 hper1: 360 switch (ffs(er1) - 1) { 361 case -1: 362 hr->hp_er1 = 0; 363 goto hper2; 364 365 case HPER1_DCK: /* Corrected? data read. Just notice. */ 366 bc = mr->mba_bc; 367 byte = ~(bc >> 16); 368 diskerr(buf, hpcd.cd_name, "soft ecc", LOG_PRINTF, 369 btodb(bp->b_bcount - byte), sc->sc_disk.dk_label); 370 er1 &= ~(1<<HPER1_DCK); 371 er1 &= HPMASK; 372 break; 373 374 default: 375 printf("drive error :%s er1 %x er2 %x\n", 376 sc->sc_dev.dv_xname, er1, er2); 377 hr->hp_er1 = hr->hp_er2 = 0; 378 goto hper2; 379 } 380 goto hper1; 381 382 hper2: 383 mbasr &= ~(MBASR_DTBUSY|MBASR_DTCMP|MBASR_ATTN); 384 if (mbasr) 385 printf("massbuss error :%s %x\n", 386 sc->sc_dev.dv_xname, mbasr); 387 388 md->md_q.b_actf->b_resid = 0; 389 disk_unbusy(&sc->sc_disk, md->md_q.b_actf->b_bcount); 390 return XFER_FINISH; 391 } 392 393 /* 394 * Non-data transfer interrupt; like volume change. 395 */ 396 int 397 hpattn(md) 398 struct mba_device *md; 399 { 400 struct hp_softc *sc = md->md_softc; 401 struct mba_softc *ms = (void *)sc->sc_dev.dv_parent; 402 struct mba_regs *mr = ms->sc_mbareg; 403 struct hp_regs *hr = (void *)&mr->mba_md[sc->sc_dev.dv_unit]; 404 int er1, er2; 405 406 er1 = hr->hp_er1 & HPMASK; 407 er2 = hr->hp_er2 & HPMASK; 408 409 printf("%s: Attention! er1 %x er2 %x\n", 410 sc->sc_dev.dv_xname, er1, er2); 411 return 0; 412 } 413 414 415 int 416 hpsize(dev) 417 dev_t dev; 418 { 419 int size, unit = DISKUNIT(dev); 420 struct hp_softc *sc; 421 422 if (unit >= hpcd.cd_ndevs || hpcd.cd_devs[unit] == 0) 423 return -1; 424 425 sc = hpcd.cd_devs[unit]; 426 size = sc->sc_disk.dk_label->d_partitions[DISKPART(dev)].p_size; 427 428 return size; 429 } 430 431 int 432 hpdump(dev, a1, a2, size) 433 dev_t dev; 434 caddr_t a1, a2; 435 size_t size; 436 { 437 printf("hpdump: Not implemented yet.\n"); 438 } 439 440 int 441 hpread(dev, uio) 442 dev_t dev; 443 struct uio *uio; 444 { 445 return (physio(hpstrategy, NULL, dev, B_READ, minphys, uio)); 446 } 447 448 int 449 hpwrite(dev, uio) 450 dev_t dev; 451 struct uio *uio; 452 { 453 return (physio(hpstrategy, NULL, dev, B_WRITE, minphys, uio)); 454 } 455 456
Indexes created Wed Sep 24 22:09:59 GMT 2025