![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / hp300 / dev|
Return to sd.c CVS log | Up to [Net/2] / Net2 / arch / hp300 / dev |
1.1 root 1: /*
2: * Copyright (c) 1990 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * This code is derived from software contributed to Berkeley by
6: * Van Jacobson of Lawrence Berkeley Laboratory.
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 by the University of
19: * California, Berkeley and its contributors.
20: * 4. Neither the name of the University nor the names of its contributors
21: * may be used to endorse or promote products derived from this software
22: * without specific prior written permission.
23: *
24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34: * SUCH DAMAGE.
35: *
36: * @(#)sd.c 7.8 (Berkeley) 6/9/91
37: */
38:
39: /*
40: * SCSI CCS (Command Command Set) disk driver.
41: */
42: #include "sd.h"
43: #if NSD > 0
44:
45: #ifndef lint
46: static char rcsid[] = "$Header: sd.c,v 1.15 91/04/24 11:54:30 mike Exp $";
47: #endif
48:
49: #include "sys/param.h"
50: #include "sys/systm.h"
51: #include "sys/buf.h"
52: #include "sys/dkstat.h"
53: #include "sys/disklabel.h"
54: #include "sys/malloc.h"
55: #include "sys/proc.h"
56:
57: #include "device.h"
58: #include "scsireg.h"
59: #include "vm/vm_param.h"
60: #include "vm/lock.h"
61: #include "vm/vm_statistics.h"
62: #include "vm/pmap.h"
63: #include "vm/vm_prot.h"
64:
65: extern int scsi_test_unit_rdy();
66: extern int scsi_request_sense();
67: extern int scsi_inquiry();
68: extern int scsi_read_capacity();
69: extern int scsi_tt_write();
70: extern int scsireq();
71: extern int scsiustart();
72: extern int scsigo();
73: extern void scsifree();
74: extern void scsireset();
75: extern void scsi_delay();
76:
77: extern void disksort();
78: extern void biodone();
79: extern int physio();
80: extern void TBIS();
81:
82: int sdinit();
83: void sdstrategy(), sdstart(), sdustart(), sdgo(), sdintr();
84:
85: struct driver sddriver = {
86: sdinit, "sd", (int (*)())sdstart, (int (*)())sdgo, (int (*)())sdintr,
87: };
88:
89: struct size {
90: u_long strtblk;
91: u_long endblk;
92: int nblocks;
93: };
94:
95: struct sdinfo {
96: struct size part[8];
97: };
98:
99: /*
100: * since the SCSI standard tends to hide the disk structure, we define
101: * partitions in terms of DEV_BSIZE blocks. The default partition table
102: * (for an unlabeled disk) reserves 512K for a boot area, has an 8 meg
103: * root and 32 meg of swap. The rest of the space on the drive goes in
104: * the G partition. As usual, the C partition covers the entire disk
105: * (including the boot area).
106: */
107: struct sdinfo sddefaultpart = {
108: 1024, 17408, 16384 , /* A */
109: 17408, 82944, 65536 , /* B */
110: 0, 0, 0 , /* C */
111: 17408, 115712, 98304 , /* D */
112: 115712, 218112, 102400 , /* E */
113: 218112, 0, 0 , /* F */
114: 82944, 0, 0 , /* G */
115: 115712, 0, 0 , /* H */
116: };
117:
118: struct sd_softc {
119: struct hp_device *sc_hd;
120: struct devqueue sc_dq;
121: int sc_format_pid; /* process using "format" mode */
122: short sc_flags;
123: short sc_type; /* drive type */
124: short sc_punit; /* physical unit (scsi lun) */
125: u_short sc_bshift; /* convert device blocks to DEV_BSIZE blks */
126: u_int sc_blks; /* number of blocks on device */
127: int sc_blksize; /* device block size in bytes */
128: u_int sc_wpms; /* average xfer rate in 16 bit wds/sec. */
129: struct sdinfo sc_info; /* drive partition table & label info */
130: } sd_softc[NSD];
131:
132: /* sc_flags values */
133: #define SDF_ALIVE 0x1
134:
135: #ifdef DEBUG
136: int sddebug = 1;
137: #define SDB_ERROR 0x01
138: #define SDB_PARTIAL 0x02
139: #endif
140:
141: struct sdstats {
142: long sdresets;
143: long sdtransfers;
144: long sdpartials;
145: } sdstats[NSD];
146:
147: struct buf sdtab[NSD];
148: struct scsi_fmt_cdb sdcmd[NSD];
149: struct scsi_fmt_sense sdsense[NSD];
150:
151: static struct scsi_fmt_cdb sd_read_cmd = { 10, CMD_READ_EXT };
152: static struct scsi_fmt_cdb sd_write_cmd = { 10, CMD_WRITE_EXT };
153:
154: #define sdunit(x) (minor(x) >> 3)
155: #define sdpart(x) (minor(x) & 0x7)
156: #define sdpunit(x) ((x) & 7)
157: #define b_cylin b_resid
158:
159: #define SDRETRY 2
160:
161: /*
162: * Table of scsi commands users are allowed to access via "format"
163: * mode. 0 means not legal. 1 means "immediate" (doesn't need dma).
164: * -1 means needs dma and/or wait for intr.
165: */
166: static char legal_cmds[256] = {
167: /***** 0 1 2 3 4 5 6 7 8 9 A B C D E F */
168: /*00*/ 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
169: /*10*/ 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
170: /*20*/ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
171: /*30*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
172: /*40*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
173: /*50*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
174: /*60*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
175: /*70*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
176: /*80*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
177: /*90*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
178: /*a0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
179: /*b0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
180: /*c0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
181: /*d0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
182: /*e0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
183: /*f0*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
184: };
185:
186: static struct scsi_inquiry inqbuf;
187: static struct scsi_fmt_cdb inq = {
188: 6,
189: CMD_INQUIRY, 0, 0, 0, sizeof(inqbuf), 0
190: };
191:
192: static u_char capbuf[8];
193: struct scsi_fmt_cdb cap = {
194: 10,
195: CMD_READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0
196: };
197:
198: static int
199: sdident(sc, hd)
200: struct sd_softc *sc;
201: struct hp_device *hd;
202: {
203: int unit;
204: register int ctlr, slave;
205: register int i;
206: register int tries = 10;
207: char idstr[32];
208: int ismo = 0;
209:
210: ctlr = hd->hp_ctlr;
211: slave = hd->hp_slave;
212: unit = sc->sc_punit;
213: scsi_delay(-1);
214:
215: /*
216: * See if unit exists and is a disk then read block size & nblocks.
217: */
218: while ((i = scsi_test_unit_rdy(ctlr, slave, unit)) != 0) {
219: if (i == -1 || --tries < 0) {
220: if (ismo)
221: break;
222: /* doesn't exist or not a CCS device */
223: goto failed;
224: }
225: if (i == STS_CHECKCOND) {
226: u_char sensebuf[128];
227: struct scsi_xsense *sp = (struct scsi_xsense *)sensebuf;
228:
229: scsi_request_sense(ctlr, slave, unit, sensebuf,
230: sizeof(sensebuf));
231: if (sp->class == 7)
232: switch (sp->key) {
233: /* not ready -- might be MO with no media */
234: case 2:
235: if (sp->len == 12 &&
236: sensebuf[12] == 10) /* XXX */
237: ismo = 1;
238: break;
239: /* drive doing an RTZ -- give it a while */
240: case 6:
241: DELAY(1000000);
242: break;
243: default:
244: break;
245: }
246: }
247: DELAY(1000);
248: }
249: /*
250: * Find out about device
251: */
252: if (scsi_immed_command(ctlr, slave, unit, &inq,
253: (u_char *)&inqbuf, sizeof(inqbuf), B_READ))
254: goto failed;
255: switch (inqbuf.type) {
256: case 0: /* disk */
257: case 4: /* WORM */
258: case 5: /* CD-ROM */
259: case 7: /* Magneto-optical */
260: break;
261: default: /* not a disk */
262: goto failed;
263: }
264: /*
265: * Get a usable id string
266: */
267: if (inqbuf.version != 1) {
268: bcopy("UNKNOWN", &idstr[0], 8);
269: bcopy("DRIVE TYPE", &idstr[8], 11);
270: } else {
271: bcopy((caddr_t)&inqbuf.vendor_id, (caddr_t)idstr, 28);
272: for (i = 27; i > 23; --i)
273: if (idstr[i] != ' ')
274: break;
275: idstr[i+1] = 0;
276: for (i = 23; i > 7; --i)
277: if (idstr[i] != ' ')
278: break;
279: idstr[i+1] = 0;
280: for (i = 7; i >= 0; --i)
281: if (idstr[i] != ' ')
282: break;
283: idstr[i+1] = 0;
284: }
285: i = scsi_immed_command(ctlr, slave, unit, &cap,
286: (u_char *)&capbuf, sizeof(capbuf), B_READ);
287: if (i) {
288: if (i != STS_CHECKCOND ||
289: bcmp(&idstr[0], "HP", 3) ||
290: bcmp(&idstr[8], "S6300.650A", 11))
291: goto failed;
292: /* XXX unformatted or non-existant MO media; fake it */
293: sc->sc_blks = 318664;
294: sc->sc_blksize = 1024;
295: } else {
296: sc->sc_blks = *(u_int *)&capbuf[0];
297: sc->sc_blksize = *(int *)&capbuf[4];
298: }
299: /* return value of read capacity is last valid block number */
300: sc->sc_blks++;
301:
302: if (inqbuf.version != 1)
303: printf("sd%d: type 0x%x, qual 0x%x, ver %d", hd->hp_unit,
304: inqbuf.type, inqbuf.qual, inqbuf.version);
305: else
306: printf("sd%d: %s %s rev %s", hd->hp_unit, idstr, &idstr[8],
307: &idstr[24]);
308: printf(", %d %d byte blocks\n", sc->sc_blks, sc->sc_blksize);
309: if (sc->sc_blksize != DEV_BSIZE) {
310: if (sc->sc_blksize < DEV_BSIZE) {
311: printf("sd%d: need %d byte blocks - drive ignored\n",
312: unit, DEV_BSIZE);
313: goto failed;
314: }
315: for (i = sc->sc_blksize; i > DEV_BSIZE; i >>= 1)
316: ++sc->sc_bshift;
317: sc->sc_blks <<= sc->sc_bshift;
318: }
319: sc->sc_wpms = 32 * (60 * DEV_BSIZE / 2); /* XXX */
320: scsi_delay(0);
321: return(inqbuf.type);
322: failed:
323: scsi_delay(0);
324: return(-1);
325: }
326:
327: int
328: sdinit(hd)
329: register struct hp_device *hd;
330: {
331: register struct sd_softc *sc = &sd_softc[hd->hp_unit];
332:
333: sc->sc_hd = hd;
334: sc->sc_punit = sdpunit(hd->hp_flags);
335: sc->sc_type = sdident(sc, hd);
336: if (sc->sc_type < 0)
337: return(0);
338: sc->sc_dq.dq_ctlr = hd->hp_ctlr;
339: sc->sc_dq.dq_unit = hd->hp_unit;
340: sc->sc_dq.dq_slave = hd->hp_slave;
341: sc->sc_dq.dq_driver = &sddriver;
342:
343: /*
344: * If we don't have a disk label, build a default partition
345: * table with 'standard' size root & swap and everything else
346: * in the G partition.
347: */
348: sc->sc_info = sddefaultpart;
349: /* C gets everything */
350: sc->sc_info.part[2].nblocks = sc->sc_blks;
351: sc->sc_info.part[2].endblk = sc->sc_blks;
352: /* G gets from end of B to end of disk */
353: sc->sc_info.part[6].nblocks = sc->sc_blks - sc->sc_info.part[1].endblk;
354: sc->sc_info.part[6].endblk = sc->sc_blks;
355: /*
356: * We also define the D, E and F paritions as an alternative to
357: * B and G. D is 48Mb, starts after A and is intended for swapping.
358: * E is 50Mb, starts after D and is intended for /usr. F starts
359: * after E and is what ever is left.
360: */
361: if (sc->sc_blks >= sc->sc_info.part[4].endblk) {
362: sc->sc_info.part[5].nblocks =
363: sc->sc_blks - sc->sc_info.part[4].endblk;
364: sc->sc_info.part[5].endblk = sc->sc_blks;
365: } else {
366: sc->sc_info.part[5].strtblk = 0;
367: sc->sc_info.part[3] = sc->sc_info.part[5];
368: sc->sc_info.part[4] = sc->sc_info.part[5];
369: }
370: /*
371: * H is a single partition alternative to E and F.
372: */
373: if (sc->sc_blks >= sc->sc_info.part[3].endblk) {
374: sc->sc_info.part[7].nblocks =
375: sc->sc_blks - sc->sc_info.part[3].endblk;
376: sc->sc_info.part[7].endblk = sc->sc_blks;
377: } else {
378: sc->sc_info.part[7].strtblk = 0;
379: }
380:
381: sc->sc_flags = SDF_ALIVE;
382: return(1);
383: }
384:
385: void
386: sdreset(sc, hd)
387: register struct sd_softc *sc;
388: register struct hp_device *hd;
389: {
390: sdstats[hd->hp_unit].sdresets++;
391: }
392:
393: int
394: sdopen(dev, flags, mode, p)
395: dev_t dev;
396: int flags, mode;
397: struct proc *p;
398: {
399: register int unit = sdunit(dev);
400: register struct sd_softc *sc = &sd_softc[unit];
401:
402: if (unit >= NSD)
403: return(ENXIO);
404: if ((sc->sc_flags & SDF_ALIVE) == 0 && suser(p->p_ucred, &p->p_acflag))
405: return(ENXIO);
406:
407: if (sc->sc_hd->hp_dk >= 0)
408: dk_wpms[sc->sc_hd->hp_dk] = sc->sc_wpms;
409: return(0);
410: }
411:
412: /*
413: * This routine is called for partial block transfers and non-aligned
414: * transfers (the latter only being possible on devices with a block size
415: * larger than DEV_BSIZE). The operation is performed in three steps
416: * using a locally allocated buffer:
417: * 1. transfer any initial partial block
418: * 2. transfer full blocks
419: * 3. transfer any final partial block
420: */
421: static void
422: sdlblkstrat(bp, bsize)
423: register struct buf *bp;
424: register int bsize;
425: {
426: register struct buf *cbp = (struct buf *)malloc(sizeof(struct buf),
427: M_DEVBUF, M_WAITOK);
428: caddr_t cbuf = (caddr_t)malloc(bsize, M_DEVBUF, M_WAITOK);
429: register int bn, resid;
430: register caddr_t addr;
431:
432: bzero((caddr_t)cbp, sizeof(*cbp));
433: cbp->b_proc = curproc; /* XXX */
434: cbp->b_dev = bp->b_dev;
435: bn = bp->b_blkno;
436: resid = bp->b_bcount;
437: addr = bp->b_un.b_addr;
438: #ifdef DEBUG
439: if (sddebug & SDB_PARTIAL)
440: printf("sdlblkstrat: bp %x flags %x bn %x resid %x addr %x\n",
441: bp, bp->b_flags, bn, resid, addr);
442: #endif
443:
444: while (resid > 0) {
445: register int boff = dbtob(bn) & (bsize - 1);
446: register int count;
447:
448: if (boff || resid < bsize) {
449: sdstats[sdunit(bp->b_dev)].sdpartials++;
450: count = MIN(resid, bsize - boff);
451: cbp->b_flags = B_BUSY | B_PHYS | B_READ;
452: cbp->b_blkno = bn - btodb(boff);
453: cbp->b_un.b_addr = cbuf;
454: cbp->b_bcount = bsize;
455: #ifdef DEBUG
456: if (sddebug & SDB_PARTIAL)
457: printf(" readahead: bn %x cnt %x off %x addr %x\n",
458: cbp->b_blkno, count, boff, addr);
459: #endif
460: sdstrategy(cbp);
461: biowait(cbp);
462: if (cbp->b_flags & B_ERROR) {
463: bp->b_flags |= B_ERROR;
464: bp->b_error = cbp->b_error;
465: break;
466: }
467: if (bp->b_flags & B_READ) {
468: bcopy(&cbuf[boff], addr, count);
469: goto done;
470: }
471: bcopy(addr, &cbuf[boff], count);
472: #ifdef DEBUG
473: if (sddebug & SDB_PARTIAL)
474: printf(" writeback: bn %x cnt %x off %x addr %x\n",
475: cbp->b_blkno, count, boff, addr);
476: #endif
477: } else {
478: count = resid & ~(bsize - 1);
479: cbp->b_blkno = bn;
480: cbp->b_un.b_addr = addr;
481: cbp->b_bcount = count;
482: #ifdef DEBUG
483: if (sddebug & SDB_PARTIAL)
484: printf(" fulltrans: bn %x cnt %x addr %x\n",
485: cbp->b_blkno, count, addr);
486: #endif
487: }
488: cbp->b_flags = B_BUSY | B_PHYS | (bp->b_flags & B_READ);
489: sdstrategy(cbp);
490: biowait(cbp);
491: if (cbp->b_flags & B_ERROR) {
492: bp->b_flags |= B_ERROR;
493: bp->b_error = cbp->b_error;
494: break;
495: }
496: done:
497: bn += btodb(count);
498: resid -= count;
499: addr += count;
500: #ifdef DEBUG
501: if (sddebug & SDB_PARTIAL)
502: printf(" done: bn %x resid %x addr %x\n",
503: bn, resid, addr);
504: #endif
505: }
506: free(cbuf, M_DEVBUF);
507: free(cbp, M_DEVBUF);
508: }
509:
510: void
511: sdstrategy(bp)
512: register struct buf *bp;
513: {
514: register int unit = sdunit(bp->b_dev);
515: register struct sd_softc *sc = &sd_softc[unit];
516: register struct size *pinfo = &sc->sc_info.part[sdpart(bp->b_dev)];
517: register struct buf *dp = &sdtab[unit];
518: register daddr_t bn;
519: register int sz, s;
520:
521: if (sc->sc_format_pid) {
522: if (sc->sc_format_pid != curproc->p_pid) { /* XXX */
523: bp->b_error = EPERM;
524: bp->b_flags |= B_ERROR;
525: goto done;
526: }
527: bp->b_cylin = 0;
528: } else {
529: bn = bp->b_blkno;
530: sz = howmany(bp->b_bcount, DEV_BSIZE);
531: if (bn < 0 || bn + sz > pinfo->nblocks) {
532: sz = pinfo->nblocks - bn;
533: if (sz == 0) {
534: bp->b_resid = bp->b_bcount;
535: goto done;
536: }
537: if (sz < 0) {
538: bp->b_error = EINVAL;
539: bp->b_flags |= B_ERROR;
540: goto done;
541: }
542: bp->b_bcount = dbtob(sz);
543: }
544: /*
545: * Non-aligned or partial-block transfers handled specially.
546: */
547: s = sc->sc_blksize - 1;
548: if ((dbtob(bn) & s) || (bp->b_bcount & s)) {
549: sdlblkstrat(bp, sc->sc_blksize);
550: goto done;
551: }
552: bp->b_cylin = (bn + pinfo->strtblk) >> sc->sc_bshift;
553: }
554: s = splbio();
555: disksort(dp, bp);
556: if (dp->b_active == 0) {
557: dp->b_active = 1;
558: sdustart(unit);
559: }
560: splx(s);
561: return;
562: done:
563: biodone(bp);
564: }
565:
566: void
567: sdustart(unit)
568: register int unit;
569: {
570: if (scsireq(&sd_softc[unit].sc_dq))
571: sdstart(unit);
572: }
573:
574: /*
575: * Return:
576: * 0 if not really an error
577: * <0 if we should do a retry
578: * >0 if a fatal error
579: */
580: static int
581: sderror(unit, sc, hp, stat)
582: int unit, stat;
583: register struct sd_softc *sc;
584: register struct hp_device *hp;
585: {
586: int cond = 1;
587:
588: sdsense[unit].status = stat;
589: if (stat & STS_CHECKCOND) {
590: struct scsi_xsense *sp;
591:
592: scsi_request_sense(hp->hp_ctlr, hp->hp_slave,
593: sc->sc_punit, sdsense[unit].sense,
594: sizeof(sdsense[unit].sense));
595: sp = (struct scsi_xsense *)sdsense[unit].sense;
596: printf("sd%d: scsi sense class %d, code %d", unit,
597: sp->class, sp->code);
598: if (sp->class == 7) {
599: printf(", key %d", sp->key);
600: if (sp->valid)
601: printf(", blk %d", *(int *)&sp->info1);
602: switch (sp->key) {
603: /* no sense, try again */
604: case 0:
605: cond = -1;
606: break;
607: /* recovered error, not a problem */
608: case 1:
609: cond = 0;
610: break;
611: }
612: }
613: printf("\n");
614: }
615: return(cond);
616: }
617:
618: static void
619: sdfinish(unit, sc, bp)
620: int unit;
621: register struct sd_softc *sc;
622: register struct buf *bp;
623: {
624: sdtab[unit].b_errcnt = 0;
625: sdtab[unit].b_actf = bp->b_actf;
626: bp->b_resid = 0;
627: biodone(bp);
628: scsifree(&sc->sc_dq);
629: if (sdtab[unit].b_actf)
630: sdustart(unit);
631: else
632: sdtab[unit].b_active = 0;
633: }
634:
635: void
636: sdstart(unit)
637: register int unit;
638: {
639: register struct sd_softc *sc = &sd_softc[unit];
640: register struct hp_device *hp = sc->sc_hd;
641:
642: /*
643: * we have the SCSI bus -- in format mode, we may or may not need dma
644: * so check now.
645: */
646: if (sc->sc_format_pid && legal_cmds[sdcmd[unit].cdb[0]] > 0) {
647: register struct buf *bp = sdtab[unit].b_actf;
648: register int sts;
649:
650: sts = scsi_immed_command(hp->hp_ctlr, hp->hp_slave,
651: sc->sc_punit, &sdcmd[unit],
652: bp->b_un.b_addr, bp->b_bcount,
653: bp->b_flags & B_READ);
654: sdsense[unit].status = sts;
655: if (sts & 0xfe) {
656: (void) sderror(unit, sc, hp, sts);
657: bp->b_flags |= B_ERROR;
658: bp->b_error = EIO;
659: }
660: sdfinish(unit, sc, bp);
661:
662: } else if (scsiustart(hp->hp_ctlr))
663: sdgo(unit);
664: }
665:
666: void
667: sdgo(unit)
668: register int unit;
669: {
670: register struct sd_softc *sc = &sd_softc[unit];
671: register struct hp_device *hp = sc->sc_hd;
672: register struct buf *bp = sdtab[unit].b_actf;
673: register int pad;
674: register struct scsi_fmt_cdb *cmd;
675:
676: if (sc->sc_format_pid) {
677: cmd = &sdcmd[unit];
678: pad = 0;
679: } else {
680: cmd = bp->b_flags & B_READ? &sd_read_cmd : &sd_write_cmd;
681: *(int *)(&cmd->cdb[2]) = bp->b_cylin;
682: pad = howmany(bp->b_bcount, sc->sc_blksize);
683: *(u_short *)(&cmd->cdb[7]) = pad;
684: pad = (bp->b_bcount & (sc->sc_blksize - 1)) != 0;
685: #ifdef DEBUG
686: if (pad)
687: printf("sd%d: partial block xfer -- %x bytes\n",
688: unit, bp->b_bcount);
689: #endif
690: sdstats[unit].sdtransfers++;
691: }
692: if (scsigo(hp->hp_ctlr, hp->hp_slave, sc->sc_punit, bp, cmd, pad) == 0) {
693: if (hp->hp_dk >= 0) {
694: dk_busy |= 1 << hp->hp_dk;
695: ++dk_seek[hp->hp_dk];
696: ++dk_xfer[hp->hp_dk];
697: dk_wds[hp->hp_dk] += bp->b_bcount >> 6;
698: }
699: return;
700: }
701: #ifdef DEBUG
702: if (sddebug & SDB_ERROR)
703: printf("sd%d: sdstart: %s adr %d blk %d len %d ecnt %d\n",
704: unit, bp->b_flags & B_READ? "read" : "write",
705: bp->b_un.b_addr, bp->b_cylin, bp->b_bcount,
706: sdtab[unit].b_errcnt);
707: #endif
708: bp->b_flags |= B_ERROR;
709: bp->b_error = EIO;
710: sdfinish(unit, sc, bp);
711: }
712:
713: void
714: sdintr(unit, stat)
715: register int unit;
716: int stat;
717: {
718: register struct sd_softc *sc = &sd_softc[unit];
719: register struct buf *bp = sdtab[unit].b_actf;
720: register struct hp_device *hp = sc->sc_hd;
721: int cond;
722:
723: if (bp == NULL) {
724: printf("sd%d: bp == NULL\n", unit);
725: return;
726: }
727: if (hp->hp_dk >= 0)
728: dk_busy &=~ (1 << hp->hp_dk);
729: if (stat) {
730: #ifdef DEBUG
731: if (sddebug & SDB_ERROR)
732: printf("sd%d: sdintr: bad scsi status 0x%x\n",
733: unit, stat);
734: #endif
735: cond = sderror(unit, sc, hp, stat);
736: if (cond) {
737: if (cond < 0 && sdtab[unit].b_errcnt++ < SDRETRY) {
738: #ifdef DEBUG
739: if (sddebug & SDB_ERROR)
740: printf("sd%d: retry #%d\n",
741: unit, sdtab[unit].b_errcnt);
742: #endif
743: sdstart(unit);
744: return;
745: }
746: bp->b_flags |= B_ERROR;
747: bp->b_error = EIO;
748: }
749: }
750: sdfinish(unit, sc, bp);
751: }
752:
753: int
754: sdread(dev, uio, flags)
755: dev_t dev;
756: struct uio *uio;
757: int flags;
758: {
759: register int unit = sdunit(dev);
760: register int pid;
761:
762: if ((pid = sd_softc[unit].sc_format_pid) &&
763: pid != uio->uio_procp->p_pid)
764: return (EPERM);
765:
766: return (physio(sdstrategy, NULL, dev, B_READ, minphys, uio));
767: }
768:
769: int
770: sdwrite(dev, uio, flags)
771: dev_t dev;
772: struct uio *uio;
773: int flags;
774: {
775: register int unit = sdunit(dev);
776: register int pid;
777:
778: if ((pid = sd_softc[unit].sc_format_pid) &&
779: pid != uio->uio_procp->p_pid)
780: return (EPERM);
781:
782: return (physio(sdstrategy, NULL, dev, B_WRITE, minphys, uio));
783: }
784:
785: int
786: sdioctl(dev, cmd, data, flag, p)
787: dev_t dev;
788: int cmd;
789: caddr_t data;
790: int flag;
791: struct proc *p;
792: {
793: register int unit = sdunit(dev);
794: register struct sd_softc *sc = &sd_softc[unit];
795:
796: switch (cmd) {
797: default:
798: return (EINVAL);
799:
800: case SDIOCSFORMAT:
801: /* take this device into or out of "format" mode */
802: if (suser(p->p_ucred, &p->p_acflag))
803: return(EPERM);
804:
805: if (*(int *)data) {
806: if (sc->sc_format_pid)
807: return (EPERM);
808: sc->sc_format_pid = p->p_pid;
809: } else
810: sc->sc_format_pid = 0;
811: return (0);
812:
813: case SDIOCGFORMAT:
814: /* find out who has the device in format mode */
815: *(int *)data = sc->sc_format_pid;
816: return (0);
817:
818: case SDIOCSCSICOMMAND:
819: /*
820: * Save what user gave us as SCSI cdb to use with next
821: * read or write to the char device.
822: */
823: if (sc->sc_format_pid != p->p_pid)
824: return (EPERM);
825: if (legal_cmds[((struct scsi_fmt_cdb *)data)->cdb[0]] == 0)
826: return (EINVAL);
827: bcopy(data, (caddr_t)&sdcmd[unit], sizeof(sdcmd[0]));
828: return (0);
829:
830: case SDIOCSENSE:
831: /*
832: * return the SCSI sense data saved after the last
833: * operation that completed with "check condition" status.
834: */
835: bcopy((caddr_t)&sdsense[unit], data, sizeof(sdsense[0]));
836: return (0);
837:
838: }
839: /*NOTREACHED*/
840: }
841:
842: int
843: sdsize(dev)
844: dev_t dev;
845: {
846: register int unit = sdunit(dev);
847: register struct sd_softc *sc = &sd_softc[unit];
848:
849: if (unit >= NSD || (sc->sc_flags & SDF_ALIVE) == 0)
850: return(-1);
851:
852: return(sc->sc_info.part[sdpart(dev)].nblocks);
853: }
854:
855: /*
856: * Non-interrupt driven, non-dma dump routine.
857: */
858: int
859: sddump(dev)
860: dev_t dev;
861: {
862: int part = sdpart(dev);
863: int unit = sdunit(dev);
864: register struct sd_softc *sc = &sd_softc[unit];
865: register struct hp_device *hp = sc->sc_hd;
866: register daddr_t baddr;
867: register int maddr;
868: register int pages, i;
869: int stat;
870: extern int lowram;
871:
872: /*
873: * Hmm... all vax drivers dump maxfree pages which is physmem minus
874: * the message buffer. Is there a reason for not dumping the
875: * message buffer? Savecore expects to read 'dumpsize' pages of
876: * dump, where dumpsys() sets dumpsize to physmem!
877: */
878: pages = physmem;
879:
880: /* is drive ok? */
881: if (unit >= NSD || (sc->sc_flags & SDF_ALIVE) == 0)
882: return (ENXIO);
883: /* dump parameters in range? */
884: if (dumplo < 0 || dumplo >= sc->sc_info.part[part].nblocks)
885: return (EINVAL);
886: if (dumplo + ctod(pages) > sc->sc_info.part[part].nblocks)
887: pages = dtoc(sc->sc_info.part[part].nblocks - dumplo);
888: maddr = lowram;
889: baddr = dumplo + sc->sc_info.part[part].strtblk;
890: /* scsi bus idle? */
891: if (!scsireq(&sc->sc_dq)) {
892: scsireset(hp->hp_ctlr);
893: sdreset(sc, sc->sc_hd);
894: printf("[ drive %d reset ] ", unit);
895: }
896: for (i = 0; i < pages; i++) {
897: #define NPGMB (1024*1024/NBPG)
898: /* print out how many Mbs we have dumped */
899: if (i && (i % NPGMB) == 0)
900: printf("%d ", i / NPGMB);
901: #undef NPBMG
902: pmap_enter(pmap_kernel(), vmmap, maddr, VM_PROT_READ, TRUE);
903: stat = scsi_tt_write(hp->hp_ctlr, hp->hp_slave, sc->sc_punit,
904: vmmap, NBPG, baddr, sc->sc_bshift);
905: if (stat) {
906: printf("sddump: scsi write error 0x%x\n", stat);
907: return (EIO);
908: }
909: maddr += NBPG;
910: baddr += ctod(1);
911: }
912: return (0);
913: }
914: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.