1 /* hp.c 4.18 81/03/01 */ 2 3 #include "hp.h" 4 #if NHP > 0 5 /* 6 * HP disk driver for RP0x+RM0x 7 */ 8 9 #include "../h/param.h" 10 #include "../h/systm.h" 11 #include "../h/dk.h" 12 #include "../h/buf.h" 13 #include "../h/conf.h" 14 #include "../h/dir.h" 15 #include "../h/user.h" 16 #include "../h/map.h" 17 #include "../h/pte.h" 18 #include "../h/mba.h" 19 #include "../h/mtpr.h" 20 #include "../h/vm.h" 21 #include "../h/cmap.h" 22 23 #include "../h/hpreg.h" 24 25 /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */ 26 struct size { 27 daddr_t nblocks; 28 int cyloff; 29 } hp_sizes[8] = { 30 15884, 0, /* A=cyl 0 thru 37 */ 31 33440, 38, /* B=cyl 38 thru 117 */ 32 340670, 0, /* C=cyl 0 thru 814 */ 33 0, 0, 34 0, 0, 35 0, 0, 36 291346, 118, /* G=cyl 118 thru 814 */ 37 0, 0, 38 }, rm_sizes[8] = { 39 15884, 0, /* A=cyl 0 thru 99 */ 40 33440, 100, /* B=cyl 100 thru 309 */ 41 131680, 0, /* C=cyl 0 thru 822 */ 42 2720, 291, 43 0, 0, 44 0, 0, 45 82080, 310, /* G=cyl 310 thru 822 */ 46 0, 0, 47 }, rm5_sizes[8] = { 48 15884, 0, /* A=cyl 0 thru 26 */ 49 33440, 27, /* B=cyl 27 thru 81 */ 50 500992, 0, /* C=cyl 0 thru 823 */ 51 15884, 562, /* D=cyl 562 thru 588 */ 52 55936, 589, /* E=cyl 589 thru 680 */ 53 86944, 681, /* F=cyl 681 thru 823 */ 54 159296, 562, /* G=cyl 562 thru 823 */ 55 291346, 82, /* H=cyl 82 thru 561 */ 56 }, rm80_sizes[8] = { 57 15884, 0, /* A=cyl 0 thru 36 */ 58 33440, 37, /* B=cyl 37 thru 114 */ 59 242606, 0, /* C=cyl 0 thru 558 */ 60 0, 0, 61 0, 0, 62 0, 0, 63 82080, 115, /* G=cyl 115 thru 304 */ 64 110236, 305, /* H=cyl 305 thru 558 */ 65 }; 66 /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */ 67 68 #define _hpSDIST 2 69 #define _hpRDIST 3 70 71 int hpSDIST = _hpSDIST; 72 int hpRDIST = _hpRDIST; 73 74 short hptypes[] = 75 { MBDT_RM03, MBDT_RM05, MBDT_RP06, MBDT_RM80, 0 }; 76 struct mba_info *hpinfo[NHP]; 77 int hpdkinit(),hpustart(),hpstart(),hpdtint(); 78 struct mba_driver hpdriver = 79 { hpdkinit, hpustart, hpstart, hpdtint, 0, hptypes, hpinfo }; 80 81 struct hpst { 82 short nsect; 83 short ntrak; 84 short nspc; 85 short ncyl; 86 struct size *sizes; 87 } hpst[] = { 88 32, 5, 32*5, 823, rm_sizes, /* RM03 */ 89 32, 19, 32*19, 823, rm5_sizes, /* RM05 */ 90 22, 19, 22*19, 815, hp_sizes, /* RP06 */ 91 31, 14, 31*14, 559, rm80_sizes /* RM80 */ 92 }; 93 94 u_char hp_offset[16] = { 95 HP_P400, HP_M400, HP_P400, HP_M400, HP_P800, HP_M800, HP_P800, HP_M800, 96 HP_P1200, HP_M1200, HP_P1200, HP_M1200, 0, 0, 0, 0, 97 }; 98 99 struct buf rhpbuf[NHP]; 100 101 #define b_cylin b_resid 102 103 #ifdef INTRLVE 104 daddr_t dkblock(); 105 #endif 106 107 int hpseek; 108 109 hpdkinit(mi) 110 struct mba_info *mi; 111 { 112 register struct hpst *st = &hpst[mi->mi_type]; 113 114 if (mi->mi_dk >= 0) 115 dk_mspw[mi->mi_dk] = 1.0 / 60 / (st->nsect * 256); 116 } 117 118 hpstrategy(bp) 119 register struct buf *bp; 120 { 121 register struct mba_info *mi; 122 register struct hpst *st; 123 register int unit; 124 long sz, bn; 125 int xunit = minor(bp->b_dev) & 07; 126 127 sz = bp->b_bcount; 128 sz = (sz+511) >> 9; 129 unit = dkunit(bp); 130 if (unit >= NHP) 131 goto bad; 132 mi = hpinfo[unit]; 133 if (mi == 0 || mi->mi_alive == 0) 134 goto bad; 135 st = &hpst[mi->mi_type]; 136 if (bp->b_blkno < 0 || 137 (bn = dkblock(bp))+sz > st->sizes[xunit].nblocks) 138 goto bad; 139 bp->b_cylin = bn/st->nspc + st->sizes[xunit].cyloff; 140 (void) spl5(); 141 disksort(&mi->mi_tab, bp); 142 if (mi->mi_tab.b_active == 0) 143 mbustart(mi); 144 (void) spl0(); 145 return; 146 147 bad: 148 bp->b_flags |= B_ERROR; 149 iodone(bp); 150 return; 151 } 152 153 hpustart(mi) 154 register struct mba_info *mi; 155 { 156 register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; 157 register struct buf *bp = mi->mi_tab.b_actf; 158 register struct hpst *st; 159 daddr_t bn; 160 int sn, dist, flags; 161 162 if ((hpaddr->hpcs1&HP_DVA) == 0) 163 return (MBU_BUSY); 164 if ((hpaddr->hpds & HP_VV) == 0) { 165 hpaddr->hpcs1 = HP_DCLR|HP_GO; 166 hpaddr->hpcs1 = HP_PRESET|HP_GO; 167 hpaddr->hpof = HP_FMT22; 168 } 169 if (mi->mi_tab.b_active || mi->mi_hd->mh_ndrive == 1) 170 return (MBU_DODATA); 171 if ((hpaddr->hpds & (HP_DPR|HP_MOL)) != (HP_DPR|HP_MOL)) 172 return (MBU_DODATA); 173 st = &hpst[mi->mi_type]; 174 bn = dkblock(bp); 175 sn = bn%st->nspc; 176 sn = (sn+st->nsect-hpSDIST)%st->nsect; 177 if (bp->b_cylin == (hpaddr->hpdc & 0xffff)) { 178 if (hpseek) 179 return (MBU_DODATA); 180 dist = ((hpaddr->hpla & 0xffff)>>6) - st->nsect + 1; 181 if (dist < 0) 182 dist += st->nsect; 183 if (dist > st->nsect - hpRDIST) 184 return (MBU_DODATA); 185 } else 186 hpaddr->hpdc = bp->b_cylin; 187 if (hpseek) 188 hpaddr->hpcs1 = HP_SEEK|HP_GO; 189 else { 190 hpaddr->hpda = sn; 191 hpaddr->hpcs1 = HP_SEARCH|HP_GO; 192 } 193 return (MBU_STARTED); 194 } 195 196 hpstart(mi) 197 register struct mba_info *mi; 198 { 199 register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; 200 register struct buf *bp = mi->mi_tab.b_actf; 201 register struct hpst *st = &hpst[mi->mi_type]; 202 daddr_t bn; 203 int sn, tn; 204 205 bn = dkblock(bp); 206 sn = bn%st->nspc; 207 tn = sn/st->nsect; 208 sn %= st->nsect; 209 if (mi->mi_tab.b_errcnt >= 16 && (bp->b_flags&B_READ) != 0) { 210 hpaddr->hpof = hp_offset[mi->mi_tab.b_errcnt & 017] | HP_FMT22; 211 hpaddr->hpcs1 = HP_OFFSET|HP_GO; 212 while (hpaddr->hpds & HP_PIP) 213 ; 214 mbclrattn(mi); 215 } 216 hpaddr->hpdc = bp->b_cylin; 217 hpaddr->hpda = (tn << 8) + sn; 218 } 219 220 hpdtint(mi, mbasr) 221 register struct mba_info *mi; 222 int mbasr; 223 { 224 register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv; 225 register struct buf *bp = mi->mi_tab.b_actf; 226 int retry = 0; 227 228 if (hpaddr->hpds&HP_ERR || mbasr&MBAEBITS) { 229 int dready = 0; 230 231 while ((hpaddr->hpds & HP_DRY) == 0) { 232 if (++dready > 32) 233 break; 234 } 235 if ((hpaddr->hpds&HP_DREADY) != HP_DREADY) { 236 printf("hp%d not ready\n", dkunit(bp)); 237 bp->b_flags |= B_ERROR; 238 } else if (hpaddr->hper1&HP_WLE) { 239 printf("hp%d is write locked\n", dkunit(bp)); 240 bp->b_flags |= B_ERROR; 241 } else if (++mi->mi_tab.b_errcnt > 27 || 242 mbasr & MBASR_HARD || 243 hpaddr->hper1 & HPER1_HARD || 244 hpaddr->hper2 & HPER2_HARD) { 245 harderr(bp); 246 printf("hp%d mbasr=%b er1=%b er2=%b\n", 247 dkunit(bp), mbasr, mbasr_bits, 248 hpaddr->hper1, HPER1_BITS, 249 hpaddr->hper2, HPER2_BITS); 250 bp->b_flags |= B_ERROR; 251 } else if ((hpaddr->hper1&(HP_DCK|HP_ECH)) == HP_DCK) { 252 if (hpecc(mi)) 253 return (MBD_RESTARTED); 254 /* else done */ 255 } else 256 retry = 1; 257 hpaddr->hpcs1 = HP_DCLR|HP_GO; 258 if ((mi->mi_tab.b_errcnt&07) == 4) { 259 hpaddr->hpcs1 = HP_RECAL|HP_GO; 260 /* SHOULD SET AN INTERRUPT AND RETURN */ 261 /* AND HANDLE ALA rk.c OR up.c */ 262 while (hpaddr->hpds & HP_PIP) 263 ; 264 mbclrattn(mi); 265 } 266 if (retry) 267 return (MBD_RETRY); 268 } 269 bp->b_resid = -(mi->mi_mba->mba_bcr) & 0xffff; 270 if (mi->mi_tab.b_errcnt > 16) { 271 hpaddr->hpcs1 = HP_RTC|HP_GO; 272 while (hpaddr->hpds & HP_PIP) 273 ; 274 mbclrattn(mi); 275 } 276 hpaddr->hpcs1 = HP_RELEASE|HP_GO; 277 return (MBD_DONE); 278 } 279 280 hpread(dev) 281 dev_t dev; 282 { 283 register int unit = minor(dev) >> 3; 284 285 if (unit >= NHP) 286 u.u_error = ENXIO; 287 else 288 physio(hpstrategy, &rhpbuf[unit], dev, B_READ, minphys); 289 } 290 291 hpwrite(dev) 292 dev_t dev; 293 { 294 register int unit = minor(dev) >> 3; 295 296 if (unit >= NHP) 297 u.u_error = ENXIO; 298 else 299 physio(hpstrategy, &rhpbuf[unit], dev, B_WRITE, minphys); 300 } 301 302 hpecc(mi) 303 register struct mba_info *mi; 304 { 305 register struct mba_regs *mbp = mi->mi_mba; 306 register struct hpdevice *rp = (struct hpdevice *)mi->mi_drv; 307 register struct buf *bp = mi->mi_tab.b_actf; 308 register struct hpst *st; 309 register int i; 310 caddr_t addr; 311 int reg, bit, byte, npf, mask, o; 312 int bn, cn, tn, sn; 313 struct pte mpte; 314 int bcr; 315 316 bcr = mbp->mba_bcr & 0xffff; 317 if (bcr) 318 bcr |= 0xffff0000; /* sxt */ 319 npf = btop(bcr + bp->b_bcount) - 1; 320 reg = npf; 321 o = (int)bp->b_un.b_addr & PGOFSET; 322 printf("SOFT ECC hp%d%c bn%d\n", dkunit(bp), 323 'a'+(minor(bp->b_dev)&07), bp->b_blkno + npf); 324 mask = rp->hpec2&0xffff; 325 i = (rp->hpec1&0xffff) - 1; /* -1 makes 0 origin */ 326 bit = i&07; 327 i = (i&~07)>>3; 328 byte = i + o; 329 while (i < 512 && (int)ptob(npf)+i < bp->b_bcount && bit > -11) { 330 mpte = mbp->mba_map[reg+btop(byte)]; 331 addr = ptob(mpte.pg_pfnum) + (byte & PGOFSET); 332 putmemc(addr, getmemc(addr)^(mask<<bit)); 333 byte++; 334 i++; 335 bit -= 8; 336 } 337 if (bcr == 0) 338 return (0); 339 #ifdef notdef 340 rp->hper1 = 0; 341 rp->hpcs1 = HP_RCOM|HP_GO; 342 #else 343 rp->hpcs1 = HP_DCLR|HP_GO; 344 bn = dkblock(bp); 345 st = &hpst[mi->mi_type]; 346 cn = bp->b_cylin; 347 sn = bn%(st->nspc) + npf + 1; 348 tn = sn/st->nsect; 349 sn %= st->nsect; 350 cn += tn/st->ntrak; 351 tn %= st->ntrak; 352 rp->hpdc = cn; 353 rp->hpda = (tn<<8) + sn; 354 mbp->mba_sr = -1; 355 mbp->mba_var = (int)ptob(reg+1) + o; 356 rp->hpcs1 = HP_RCOM|HP_GO; 357 #endif 358 return (1); 359 } 360 361 #define DBSIZE 20 362 363 hpdump(dev) 364 dev_t dev; 365 { 366 register struct mba_info *mi; 367 register struct mba_regs *mba; 368 struct hpdevice *hpaddr; 369 char *start; 370 int num, unit; 371 register struct hpst *st; 372 373 num = maxfree; 374 start = 0; 375 unit = minor(dev) >> 3; 376 if (unit >= NHP) { 377 printf("bad unit\n"); 378 return (-1); 379 } 380 #define phys(a,b) ((b)((int)(a)&0x7fffffff)) 381 mi = phys(hpinfo[unit],struct mba_info *); 382 if (mi == 0 || mi->mi_alive == 0) { 383 printf("dna\n"); 384 return (-1); 385 } 386 mba = phys(mi->mi_hd, struct mba_hd *)->mh_physmba; 387 mba->mba_cr = MBAINIT; 388 hpaddr = (struct hpdevice *)&mba->mba_drv[mi->mi_drive]; 389 if ((hpaddr->hpds & HP_VV) == 0) { 390 hpaddr->hpcs1 = HP_DCLR|HP_GO; 391 hpaddr->hpcs1 = HP_PRESET|HP_GO; 392 hpaddr->hpof = HP_FMT22; 393 } 394 st = &hpst[mi->mi_type]; 395 if (dumplo < 0 || dumplo + num >= st->sizes[minor(dev)&07].nblocks) { 396 printf("oor\n"); 397 return (-1); 398 } 399 while (num > 0) { 400 register struct pte *hpte = mba->mba_map; 401 register int i; 402 int blk, cn, sn, tn; 403 daddr_t bn; 404 405 blk = num > DBSIZE ? DBSIZE : num; 406 bn = dumplo + btop(start); 407 cn = bn/st->nspc + st->sizes[minor(dev)&07].cyloff; 408 sn = bn%st->nspc; 409 tn = sn/st->nsect; 410 sn = sn%st->nsect; 411 hpaddr->hpdc = cn; 412 hpaddr->hpda = (tn << 8) + sn; 413 for (i = 0; i < blk; i++) 414 *(int *)hpte++ = (btop(start)+i) | PG_V; 415 mba->mba_sr = -1; 416 mba->mba_bcr = -(blk*NBPG); 417 mba->mba_var = 0; 418 hpaddr->hpcs1 = HP_WCOM | HP_GO; 419 while ((hpaddr->hpds & HP_DRY) == 0) 420 ; 421 if (hpaddr->hpds&HP_ERR) { 422 printf("dskerr: (%d,%d,%d) ds=%x er=%x\n", 423 cn, tn, sn, hpaddr->hpds, hpaddr->hper1); 424 return (-1); 425 } 426 start += blk*NBPG; 427 num -= blk; 428 } 429 return (0); 430 } 431 #endif 432