![[BACK]](/icons/back.gif){kind=icon}
Return to hd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hp300 / dev|
Return to hd.c CVS log | Up to [local] / sys / arch / hp300 / dev |
1.1 nbrk 1: /* $OpenBSD: hd.c,v 1.53 2007/06/21 20:23:07 miod Exp $ */
2: /* $NetBSD: rd.c,v 1.33 1997/07/10 18:14:08 kleink Exp $ */
3:
4: /*
5: * Copyright (c) 1996, 1997 Jason R. Thorpe. All rights reserved.
6: * Copyright (c) 1988 University of Utah.
7: * Copyright (c) 1982, 1990, 1993
8: * The Regents of the University of California. All rights reserved.
9: *
10: * This code is derived from software contributed to Berkeley by
11: * the Systems Programming Group of the University of Utah Computer
12: * Science Department.
13: *
14: * Redistribution and use in source and binary forms, with or without
15: * modification, are permitted provided that the following conditions
16: * are met:
17: * 1. Redistributions of source code must retain the above copyright
18: * notice, this list of conditions and the following disclaimer.
19: * 2. Redistributions in binary form must reproduce the above copyright
20: * notice, this list of conditions and the following disclaimer in the
21: * documentation and/or other materials provided with the distribution.
22: * 3. Neither the name of the University nor the names of its contributors
23: * may be used to endorse or promote products derived from this software
24: * without specific prior written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36: * SUCH DAMAGE.
37: *
38: * from: Utah $Hdr: rd.c 1.44 92/12/26$
39: *
40: * @(#)rd.c 8.2 (Berkeley) 5/19/94
41: */
42:
43: /*
44: * CS80/SS80 disk driver
45: */
46:
47: #include <sys/param.h>
48: #include <sys/systm.h>
49: #include <sys/buf.h>
50: #include <sys/conf.h>
51: #include <sys/device.h>
52: #include <sys/disk.h>
53: #include <sys/disklabel.h>
54: #include <sys/fcntl.h>
55: #include <sys/ioctl.h>
56: #include <sys/kernel.h>
57: #include <sys/proc.h>
58: #include <sys/stat.h>
59: #include <sys/syslog.h>
60:
61: #include <ufs/ffs/fs.h> /* for BBSIZE and SBSIZE */
62:
63: #include <hp300/dev/hpibvar.h>
64:
65: #include <hp300/dev/hdreg.h>
66: #include <hp300/dev/hdvar.h>
67:
68: #ifdef USELEDS
69: #include <hp300/hp300/leds.h>
70: #endif
71:
72: #ifndef HDRETRY
73: #define HDRETRY 5
74: #endif
75:
76: #ifndef HDWAITC
77: #define HDWAITC 1 /* min time for timeout in seconds */
78: #endif
79:
80: int hderrthresh = HDRETRY - 1; /* when to start reporting errors */
81:
82: #ifdef DEBUG
83: /* error message tables */
84: const char *err_reject[16] = {
85: NULL,
86: NULL,
87: "channel parity error", /* 0x2000 */
88: NULL,
89: NULL,
90: "illegal opcode", /* 0x0400 */
91: "module addressing", /* 0x0200 */
92: "address bounds", /* 0x0100 */
93: "parameter bounds", /* 0x0080 */
94: "illegal parameter", /* 0x0040 */
95: "message sequence", /* 0x0020 */
96: NULL,
97: "message length", /* 0x0008 */
98: NULL,
99: NULL,
100: NULL
101: };
102:
103: const char *err_fault[16] = {
104: NULL,
105: "cross unit", /* 0x4000 */
106: NULL,
107: "controller fault", /* 0x1000 */
108: NULL,
109: NULL,
110: "unit fault", /* 0x0200 */
111: NULL,
112: "diagnostic result", /* 0x0080 */
113: NULL,
114: "operator release request", /* 0x0020 */
115: "diagnostic release request", /* 0x0010 */
116: "internal maintenance release request", /* 0x0008 */
117: NULL,
118: "power fail", /* 0x0002 */
119: "retransmit" /* 0x0001 */
120: };
121:
122: const char *err_access[16] = {
123: "illegal parallel operation", /* 0x8000 */
124: "uninitialized media", /* 0x4000 */
125: "no spares available", /* 0x2000 */
126: "not ready", /* 0x1000 */
127: "write protect", /* 0x0800 */
128: "no data found", /* 0x0400 */
129: NULL,
130: NULL,
131: "unrecoverable data overflow", /* 0x0080 */
132: "unrecoverable data", /* 0x0040 */
133: NULL,
134: "end of file", /* 0x0010 */
135: "end of volume", /* 0x0008 */
136: NULL,
137: NULL,
138: NULL
139: };
140:
141: const char *err_info[16] = {
142: "operator release request", /* 0x8000 */
143: "diagnostic release request", /* 0x4000 */
144: "internal maintenance release request", /* 0x2000 */
145: "media wear", /* 0x1000 */
146: "latency induced", /* 0x0800 */
147: NULL,
148: NULL,
149: "auto sparing invoked", /* 0x0100 */
150: NULL,
151: "recoverable data overflow", /* 0x0040 */
152: "marginal data", /* 0x0020 */
153: "recoverable data", /* 0x0010 */
154: NULL,
155: "maintenance track overflow", /* 0x0004 */
156: NULL,
157: NULL
158: };
159:
160: #define HDB_FOLLOW 0x01
161: #define HDB_STATUS 0x02
162: #define HDB_IDENT 0x04
163: #define HDB_IO 0x08
164: #define HDB_ASYNC 0x10
165: #define HDB_ERROR 0x80
166: int hddebug = HDB_ERROR | HDB_IDENT;
167: #endif
168:
169: /*
170: * Misc. HW description, indexed by sc_type.
171: * Nothing really critical here, could do without it.
172: */
173: const struct hdidentinfo hdidentinfo[] = {
174: { HD7946AID, 0, "7945A", NHD7945ABPT,
175: NHD7945ATRK, 968, 108416 },
176:
177: { HD9134DID, 1, "9134D", NHD9134DBPT,
178: NHD9134DTRK, 303, 29088 },
179:
180: { HD9134LID, 1, "9122S", NHD9122SBPT,
181: NHD9122STRK, 77, 1232 },
182:
183: { HD7912PID, 0, "7912P", NHD7912PBPT,
184: NHD7912PTRK, 572, 128128 },
185:
186: { HD7914PID, 0, "7914P", NHD7914PBPT,
187: NHD7914PTRK, 1152, 258048 },
188:
189: { HD7958AID, 0, "7958A", NHD7958ABPT,
190: NHD7958ATRK, 1013, 255276 },
191:
192: { HD7957AID, 0, "7957A", NHD7957ABPT,
193: NHD7957ATRK, 1036, 159544 },
194:
195: { HD7933HID, 0, "7933H", NHD7933HBPT,
196: NHD7933HTRK, 1321, 789958 },
197:
198: { HD9134LID, 1, "9134L", NHD9134LBPT,
199: NHD9134LTRK, 973, 77840 },
200:
201: { HD7936HID, 0, "7936H", NHD7936HBPT,
202: NHD7936HTRK, 698, 600978 },
203:
204: { HD7937HID, 0, "7937H", NHD7937HBPT,
205: NHD7937HTRK, 698, 1116102 },
206:
207: { HD7914CTID, 0, "7914CT", NHD7914PBPT,
208: NHD7914PTRK, 1152, 258048 },
209:
210: { HD7946AID, 0, "7946A", NHD7945ABPT,
211: NHD7945ATRK, 968, 108416 },
212:
213: { HD9134LID, 1, "9122D", NHD9122SBPT,
214: NHD9122STRK, 77, 1232 },
215:
216: { HD7957BID, 0, "7957B", NHD7957BBPT,
217: NHD7957BTRK, 1269, 159894 },
218:
219: { HD7958BID, 0, "7958B", NHD7958BBPT,
220: NHD7958BTRK, 786, 297108 },
221:
222: { HD7959BID, 0, "7959B", NHD7959BBPT,
223: NHD7959BTRK, 1572, 594216 },
224:
225: { HD2200AID, 0, "2200A", NHD2200ABPT,
226: NHD2200ATRK, 1449, 654948 },
227:
228: { HD2203AID, 0, "2203A", NHD2203ABPT,
229: NHD2203ATRK, 1449, 1309896 }
230: };
231: const int numhdidentinfo = sizeof(hdidentinfo) / sizeof(hdidentinfo[0]);
232:
233: bdev_decl(hd);
234: cdev_decl(hd);
235:
236: int hdident(struct device *, struct hd_softc *,
237: struct hpibbus_attach_args *);
238: void hdreset(int, int, int);
239: void hdustart(struct hd_softc *);
240: void hdgetdisklabel(dev_t, struct hd_softc *, struct disklabel *, int);
241: void hdrestart(void *);
242: struct buf *hdfinish(struct hd_softc *, struct buf *);
243:
244: void hdstart(void *);
245: void hdinterrupt(void *);
246: void hdgo(void *);
247: int hdstatus(struct hd_softc *);
248: int hderror(int);
249: #ifdef DEBUG
250: void hdprinterr(const char *, short, const char **);
251: #endif
252:
253: int hdmatch(struct device *, void *, void *);
254: void hdattach(struct device *, struct device *, void *);
255:
256: struct cfattach hd_ca = {
257: sizeof(struct hd_softc), hdmatch, hdattach
258: };
259:
260: struct cfdriver hd_cd = {
261: NULL, "hd", DV_DISK
262: };
263:
264: #define hdlock(rs) disk_lock(&(rs)->sc_dkdev)
265: #define hdunlock(rs) disk_unlock(&(rs)->sc_dkdev)
266: #define hdlookup(unit) (struct hd_softc *)device_lookup(&hd_cd, (unit))
267:
268: int
269: hdmatch(parent, match, aux)
270: struct device *parent;
271: void *match, *aux;
272: {
273: struct hpibbus_attach_args *ha = aux;
274:
275: return (hdident(parent, NULL, ha));
276: }
277:
278: void
279: hdattach(parent, self, aux)
280: struct device *parent, *self;
281: void *aux;
282: {
283: struct hd_softc *sc = (struct hd_softc *)self;
284: struct hpibbus_attach_args *ha = aux;
285:
286: if (hdident(parent, sc, ha) == 0) {
287: printf("\n%s: didn't respond to describe command!\n",
288: sc->sc_dev.dv_xname);
289: return;
290: }
291:
292: /*
293: * Initialize and attach the disk structure.
294: */
295: bzero(&sc->sc_dkdev, sizeof(sc->sc_dkdev));
296: sc->sc_dkdev.dk_name = sc->sc_dev.dv_xname;
297: disk_attach(&sc->sc_dkdev);
298:
299: sc->sc_slave = ha->ha_slave;
300: sc->sc_punit = ha->ha_punit;
301:
302: /* Initialize the hpib job queue entry */
303: sc->sc_hq.hq_softc = sc;
304: sc->sc_hq.hq_slave = sc->sc_slave;
305: sc->sc_hq.hq_start = hdstart;
306: sc->sc_hq.hq_go = hdgo;
307: sc->sc_hq.hq_intr = hdinterrupt;
308:
309: #ifdef DEBUG
310: /* always report errors */
311: if (hddebug & HDB_ERROR)
312: hderrthresh = 0;
313: #endif
314:
315: /* Initialize timeout structure */
316: timeout_set(&sc->sc_timeout, hdrestart, sc);
317: }
318:
319: int
320: hdident(parent, sc, ha)
321: struct device *parent;
322: struct hd_softc *sc;
323: struct hpibbus_attach_args *ha;
324: {
325: struct cs80_describe desc;
326: u_char stat, cmd[3];
327: char name[7];
328: int i, id, n, ctlr, slave;
329:
330: ctlr = parent->dv_unit;
331: slave = ha->ha_slave;
332:
333: /* Verify that we have a CS80 device. */
334: if ((ha->ha_id & 0x200) == 0)
335: return (0);
336:
337: /* Is it one of the disks we support? */
338: for (id = 0; id < numhdidentinfo; id++)
339: if (ha->ha_id == hdidentinfo[id].ri_hwid &&
340: ha->ha_punit <= hdidentinfo[id].ri_maxunum)
341: break;
342: if (id == numhdidentinfo)
343: return (0);
344:
345: /*
346: * Reset device and collect description
347: */
348: bzero(&desc, sizeof(desc));
349: stat = 0;
350: hdreset(ctlr, slave, ha->ha_punit);
351: cmd[0] = C_SUNIT(ha->ha_punit);
352: cmd[1] = C_SVOL(0);
353: cmd[2] = C_DESC;
354: hpibsend(ctlr, slave, C_CMD, cmd, sizeof(cmd));
355: hpibrecv(ctlr, slave, C_EXEC, &desc, sizeof(desc));
356: hpibrecv(ctlr, slave, C_QSTAT, &stat, sizeof(stat));
357:
358: if (desc.d_name == 0 && stat != 0)
359: return (0);
360:
361: /*
362: * If we're just probing for the device, that's all the
363: * work we need to do.
364: */
365: if (sc == NULL)
366: return (1);
367:
368: bzero(name, sizeof(name));
369: n = desc.d_name;
370: for (i = 5; i >= 0; i--) {
371: name[i] = (n & 0xf) + '0';
372: n >>= 4;
373: }
374:
375: #ifdef DEBUG
376: if (hddebug & HDB_IDENT) {
377: printf(": stat %d name: %x ('%s')\n", stat, desc.d_name, name);
378: printf(" iuw %x, maxxfr %d, ctype %d\n",
379: desc.d_iuw, desc.d_cmaxxfr, desc.d_ctype);
380: printf(" utype %d, bps %d, blkbuf %d, burst %d, blktime %d\n",
381: desc.d_utype, desc.d_sectsize,
382: desc.d_blkbuf, desc.d_burstsize, desc.d_blocktime);
383: printf(" avxfr %d, ort %d, atp %d, maxint %d, fv %x, rv %x\n",
384: desc.d_uavexfr, desc.d_retry, desc.d_access,
385: desc.d_maxint, desc.d_fvbyte, desc.d_rvbyte);
386: printf(" maxcyl/head/sect %d/%d/%d, maxvsect %d, inter %d\n",
387: desc.d_maxcyl, desc.d_maxhead, desc.d_maxsect,
388: desc.d_maxvsectl, desc.d_interleave);
389: printf("%s:", sc->sc_dev.dv_xname);
390: }
391: #endif
392:
393: /*
394: * Take care of a couple of anomalies:
395: * 1. 7945A and 7946A both return same HW id
396: * 2. 9122S and 9134D both return same HW id
397: * 3. 9122D and 9134L both return same HW id
398: */
399: switch (ha->ha_id) {
400: case HD7946AID:
401: if (bcmp(name, "079450", 6) == 0)
402: id = HD7945A;
403: else
404: id = HD7946A;
405: break;
406:
407: case HD9134LID:
408: if (bcmp(name, "091340", 6) == 0)
409: id = HD9134L;
410: else
411: id = HD9122D;
412: break;
413:
414: case HD9134DID:
415: if (bcmp(name, "091220", 6) == 0)
416: id = HD9122S;
417: else
418: id = HD9134D;
419: break;
420: }
421:
422: sc->sc_type = id;
423:
424: /*
425: * XXX We use DEV_BSIZE instead of the sector size value pulled
426: * XXX off the driver because all of this code assumes 512 byte
427: * XXX blocks. ICK!
428: */
429: printf(": %s\n", hdidentinfo[id].ri_desc);
430: printf("%s: %luMB, %lu cyl, %lu head, %lu sec, %lu bytes/sec, %lu sec total\n",
431: sc->sc_dev.dv_xname,
432: hdidentinfo[id].ri_nblocks / (1048576 / DEV_BSIZE),
433: hdidentinfo[id].ri_ncyl, hdidentinfo[id].ri_ntpc,
434: hdidentinfo[id].ri_nbpt, DEV_BSIZE, hdidentinfo[id].ri_nblocks);
435:
436: return (1);
437: }
438:
439: void
440: hdreset(ctlr, slave, punit)
441: int ctlr, slave, punit;
442: {
443: struct hd_ssmcmd ssmc;
444: struct hd_srcmd src;
445: struct hd_clearcmd clear;
446: u_char stat;
447:
448: bzero(&clear, sizeof(clear));
449: clear.c_unit = C_SUNIT(punit);
450: clear.c_cmd = C_CLEAR;
451: hpibsend(ctlr, slave, C_TCMD, &clear, sizeof(clear));
452: hpibswait(ctlr, slave);
453: hpibrecv(ctlr, slave, C_QSTAT, &stat, sizeof(stat));
454:
455: bzero(&src, sizeof(src));
456: src.c_unit = C_SUNIT(HDCTLR);
457: src.c_nop = C_NOP;
458: src.c_cmd = C_SREL;
459: src.c_param = C_REL;
460: hpibsend(ctlr, slave, C_CMD, &src, sizeof(src));
461: hpibswait(ctlr, slave);
462: hpibrecv(ctlr, slave, C_QSTAT, &stat, sizeof(stat));
463:
464: bzero(&ssmc, sizeof(ssmc));
465: ssmc.c_unit = C_SUNIT(punit);
466: ssmc.c_cmd = C_SSM;
467: ssmc.c_refm = REF_MASK;
468: ssmc.c_fefm = FEF_MASK;
469: ssmc.c_aefm = AEF_MASK;
470: ssmc.c_iefm = IEF_MASK;
471: hpibsend(ctlr, slave, C_CMD, &ssmc, sizeof(ssmc));
472: hpibswait(ctlr, slave);
473: hpibrecv(ctlr, slave, C_QSTAT, &stat, sizeof(stat));
474: }
475:
476: /*
477: * Read or construct a disklabel
478: */
479: void
480: hdgetdisklabel(dev, rs, lp, spoofonly)
481: dev_t dev;
482: struct hd_softc *rs;
483: struct disklabel *lp;
484: int spoofonly;
485: {
486: char *errstring;
487:
488: bzero(lp, sizeof(struct disklabel));
489:
490: /*
491: * Create a default disk label based on geometry.
492: * This will get overridden if there is a real label on the disk.
493: */
494: lp->d_secsize = DEV_BSIZE;
495: lp->d_ntracks = hdidentinfo[rs->sc_type].ri_ntpc;
496: lp->d_nsectors = hdidentinfo[rs->sc_type].ri_nbpt;
497: lp->d_ncylinders = hdidentinfo[rs->sc_type].ri_ncyl;
498: lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
499: if (lp->d_secpercyl == 0) {
500: lp->d_secpercyl = 100;
501: /* as long as it's not 0 - readdisklabel divides by it */
502: }
503:
504: lp->d_type = DTYPE_HPIB;
505: strncpy(lp->d_typename, hdidentinfo[rs->sc_type].ri_desc,
506: sizeof(lp->d_typename));
507: strncpy(lp->d_packname, "fictitious", sizeof lp->d_packname);
508:
509: DL_SETDSIZE(lp, hdidentinfo[rs->sc_type].ri_nblocks);
510: lp->d_rpm = 3600;
511: lp->d_interleave = 1;
512: lp->d_flags = 0;
513: lp->d_version = 1;
514:
515: /* XXX - these values for BBSIZE and SBSIZE assume ffs */
516: lp->d_bbsize = BBSIZE;
517: lp->d_sbsize = SBSIZE;
518:
519: lp->d_magic = DISKMAGIC;
520: lp->d_magic2 = DISKMAGIC;
521: lp->d_checksum = dkcksum(lp);
522:
523: /*
524: * Now try to read the disklabel
525: */
526: errstring = readdisklabel(DISKLABELDEV(dev), hdstrategy, lp,
527: spoofonly);
528: if (errstring) {
529: /* printf("%s: %s\n", rs->sc_dev.dv_xname, errstring); */
530: return;
531: }
532: }
533:
534: int
535: hdopen(dev, flags, mode, p)
536: dev_t dev;
537: int flags, mode;
538: struct proc *p;
539: {
540: int unit = DISKUNIT(dev);
541: struct hd_softc *rs;
542: int mask, part;
543: int error;
544:
545: rs = hdlookup(unit);
546: if (rs == NULL)
547: return (ENXIO);
548:
549: if ((error = hdlock(rs)) != 0) {
550: device_unref(&rs->sc_dev);
551: return (error);
552: }
553:
554: /*
555: * On first open, get label and partition info.
556: * We may block reading the label, so be careful
557: * to stop any other opens.
558: */
559: if (rs->sc_dkdev.dk_openmask == 0) {
560: rs->sc_flags |= HDF_OPENING;
561: hdgetdisklabel(dev, rs, rs->sc_dkdev.dk_label, 0);
562: rs->sc_flags &= ~HDF_OPENING;
563: }
564:
565: part = DISKPART(dev);
566: mask = 1 << part;
567:
568: /* Check that the partition exists. */
569: if (part != RAW_PART &&
570: (part > rs->sc_dkdev.dk_label->d_npartitions ||
571: rs->sc_dkdev.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
572: error = ENXIO;
573: goto out;
574: }
575:
576: /* Ensure only one open at a time. */
577: switch (mode) {
578: case S_IFCHR:
579: rs->sc_dkdev.dk_copenmask |= mask;
580: break;
581: case S_IFBLK:
582: rs->sc_dkdev.dk_bopenmask |= mask;
583: break;
584: }
585: rs->sc_dkdev.dk_openmask =
586: rs->sc_dkdev.dk_copenmask | rs->sc_dkdev.dk_bopenmask;
587:
588: error = 0;
589: out:
590: hdunlock(rs);
591: device_unref(&rs->sc_dev);
592: return (error);
593: }
594:
595: int
596: hdclose(dev, flag, mode, p)
597: dev_t dev;
598: int flag, mode;
599: struct proc *p;
600: {
601: int unit = DISKUNIT(dev);
602: struct hd_softc *rs;
603: struct disk *dk;
604: int mask, s;
605: int error;
606:
607: rs = hdlookup(unit);
608: if (rs == NULL)
609: return (ENXIO);
610:
611: if ((error = hdlock(rs)) != 0) {
612: device_unref(&rs->sc_dev);
613: return (error);
614: }
615:
616: mask = 1 << DISKPART(dev);
617: dk = &rs->sc_dkdev;
618: switch (mode) {
619: case S_IFCHR:
620: dk->dk_copenmask &= ~mask;
621: break;
622: case S_IFBLK:
623: dk->dk_bopenmask &= ~mask;
624: break;
625: }
626: dk->dk_openmask = dk->dk_copenmask | dk->dk_bopenmask;
627:
628: /*
629: * On last close, we wait for all activity to cease since
630: * the label/parition info will become invalid.
631: * Note we don't have to about other closes since we know
632: * we are the last one.
633: */
634: if (dk->dk_openmask == 0) {
635: rs->sc_flags |= HDF_CLOSING;
636: s = splbio();
637: while (rs->sc_tab.b_active) {
638: rs->sc_flags |= HDF_WANTED;
639: tsleep((caddr_t)&rs->sc_tab, PRIBIO, "hdclose", 0);
640: }
641: splx(s);
642: rs->sc_flags &= ~(HDF_CLOSING);
643: }
644:
645: hdunlock(rs);
646: device_unref(&rs->sc_dev);
647: return (0);
648: }
649:
650: void
651: hdstrategy(bp)
652: struct buf *bp;
653: {
654: int unit = DISKUNIT(bp->b_dev);
655: struct hd_softc *rs;
656: struct buf *dp;
657: struct disklabel *lp;
658: int s;
659:
660: rs = hdlookup(unit);
661: if (rs == NULL) {
662: bp->b_error = ENXIO;
663: goto bad;
664: }
665:
666: #ifdef DEBUG
667: if (hddebug & HDB_FOLLOW)
668: printf("hdstrategy(%x): dev %x, bn %x, bcount %lx, %c\n",
669: bp, bp->b_dev, bp->b_blkno, bp->b_bcount,
670: (bp->b_flags & B_READ) ? 'R' : 'W');
671: #endif
672:
673: lp = rs->sc_dkdev.dk_label;
674:
675: /*
676: * If it's a null transfer, return immediately
677: */
678: if (bp->b_bcount == 0)
679: goto done;
680:
681: /*
682: * The transfer must be a whole number of blocks.
683: */
684: if ((bp->b_bcount % lp->d_secsize) != 0) {
685: bp->b_error = EINVAL;
686: goto bad;
687: }
688:
689: /*
690: * Do bounds checking, adjust transfer. if error, process;
691: * If end of partition, just return.
692: */
693: if (bounds_check_with_label(bp, lp,
694: (rs->sc_flags & HDF_WLABEL) != 0) <= 0)
695: goto done;
696:
697: s = splbio();
698: dp = &rs->sc_tab;
699: disksort(dp, bp);
700: if (dp->b_active == 0) {
701: dp->b_active = 1;
702: hdustart(rs);
703: }
704: splx(s);
705:
706: device_unref(&rs->sc_dev);
707: return;
708: bad:
709: bp->b_flags |= B_ERROR;
710: done:
711: /*
712: * Correctly set the buf to indicate a completed xfer
713: */
714: bp->b_resid = bp->b_bcount;
715: s = splbio();
716: biodone(bp);
717: splx(s);
718: if (rs != NULL)
719: device_unref(&rs->sc_dev);
720: }
721:
722: /*
723: * Called via timeout(9) when handling maintenance releases
724: */
725: void
726: hdrestart(arg)
727: void *arg;
728: {
729: int s = splbio();
730: hdustart((struct hd_softc *)arg);
731: splx(s);
732: }
733:
734: void
735: hdustart(rs)
736: struct hd_softc *rs;
737: {
738: struct buf *bp;
739:
740: bp = rs->sc_tab.b_actf;
741: rs->sc_addr = bp->b_data;
742: rs->sc_resid = bp->b_bcount;
743: if (hpibreq(rs->sc_dev.dv_parent, &rs->sc_hq))
744: hdstart(rs);
745: }
746:
747: struct buf *
748: hdfinish(rs, bp)
749: struct hd_softc *rs;
750: struct buf *bp;
751: {
752: struct buf *dp = &rs->sc_tab;
753: int s;
754:
755: rs->sc_errcnt = 0;
756: dp->b_actf = bp->b_actf;
757: bp->b_resid = 0;
758: s = splbio();
759: biodone(bp);
760: splx(s);
761: hpibfree(rs->sc_dev.dv_parent, &rs->sc_hq);
762: if (dp->b_actf)
763: return (dp->b_actf);
764: dp->b_active = 0;
765: if (rs->sc_flags & HDF_WANTED) {
766: rs->sc_flags &= ~HDF_WANTED;
767: wakeup((caddr_t)dp);
768: }
769: return (NULL);
770: }
771:
772: void
773: hdstart(arg)
774: void *arg;
775: {
776: struct hd_softc *rs = arg;
777: struct disklabel *lp;
778: struct buf *bp = rs->sc_tab.b_actf;
779: int ctlr, slave;
780: daddr64_t bn;
781:
782: ctlr = rs->sc_dev.dv_parent->dv_unit;
783: slave = rs->sc_slave;
784:
785: again:
786: #ifdef DEBUG
787: if (hddebug & HDB_FOLLOW)
788: printf("hdstart(%s): bp %p, %c\n", rs->sc_dev.dv_xname, bp,
789: (bp->b_flags & B_READ) ? 'R' : 'W');
790: #endif
791: lp = rs->sc_dkdev.dk_label;
792: bn = bp->b_blkno +
793: DL_GETPOFFSET(&lp->d_partitions[DISKPART(bp->b_dev)]);
794:
795: rs->sc_flags |= HDF_SEEK;
796: rs->sc_ioc.c_unit = C_SUNIT(rs->sc_punit);
797: rs->sc_ioc.c_volume = C_SVOL(0);
798: rs->sc_ioc.c_saddr = C_SADDR;
799: rs->sc_ioc.c_hiaddr = 0;
800: rs->sc_ioc.c_addr = HDBTOS(bn);
801: rs->sc_ioc.c_nop2 = C_NOP;
802: rs->sc_ioc.c_slen = C_SLEN;
803: rs->sc_ioc.c_len = rs->sc_resid;
804: rs->sc_ioc.c_cmd = bp->b_flags & B_READ ? C_READ : C_WRITE;
805: #ifdef DEBUG
806: if (hddebug & HDB_IO)
807: printf("hdstart: hpibsend(%x, %x, %x, %p, %x)\n",
808: ctlr, slave, C_CMD,
809: &rs->sc_ioc.c_unit, sizeof(rs->sc_ioc)-2);
810: #endif
811: if (hpibsend(ctlr, slave, C_CMD, &rs->sc_ioc.c_unit,
812: sizeof(rs->sc_ioc)-2) == sizeof(rs->sc_ioc)-2) {
813:
814: /* Instrumentation. */
815: disk_busy(&rs->sc_dkdev);
816: rs->sc_dkdev.dk_seek++;
817:
818: #ifdef DEBUG
819: if (hddebug & HDB_IO)
820: printf("hdstart: hpibawait(%x)\n", ctlr);
821: #endif
822: hpibawait(ctlr);
823: return;
824: }
825: /*
826: * Experience has shown that the hpibwait in this hpibsend will
827: * occasionally timeout. It appears to occur mostly on old 7914
828: * drives with full maintenance tracks. We should probably
829: * integrate this with the backoff code in hderror.
830: */
831: #ifdef DEBUG
832: if (hddebug & HDB_ERROR)
833: printf("%s: hdstart: cmd %x adr %lx blk %d len %d ecnt %ld\n",
834: rs->sc_dev.dv_xname, rs->sc_ioc.c_cmd, rs->sc_ioc.c_addr,
835: bp->b_blkno, rs->sc_resid, rs->sc_errcnt);
836: rs->sc_stats.hdretries++;
837: #endif
838: rs->sc_flags &= ~HDF_SEEK;
839: hdreset(rs->sc_dev.dv_parent->dv_unit, rs->sc_slave, rs->sc_punit);
840: if (rs->sc_errcnt++ < HDRETRY)
841: goto again;
842: printf("%s: hdstart err: err: cmd 0x%x sect %ld blk %d len %d\n",
843: rs->sc_dev.dv_xname, rs->sc_ioc.c_cmd, rs->sc_ioc.c_addr,
844: bp->b_blkno, rs->sc_resid);
845: bp->b_flags |= B_ERROR;
846: bp->b_error = EIO;
847: bp = hdfinish(rs, bp);
848: if (bp) {
849: rs->sc_addr = bp->b_data;
850: rs->sc_resid = bp->b_bcount;
851: if (hpibreq(rs->sc_dev.dv_parent, &rs->sc_hq))
852: goto again;
853: }
854: }
855:
856: void
857: hdgo(arg)
858: void *arg;
859: {
860: struct hd_softc *rs = arg;
861: struct buf *bp = rs->sc_tab.b_actf;
862: int rw, ctlr, slave;
863:
864: ctlr = rs->sc_dev.dv_parent->dv_unit;
865: slave = rs->sc_slave;
866:
867: rw = bp->b_flags & B_READ;
868:
869: /* Instrumentation. */
870: disk_busy(&rs->sc_dkdev);
871:
872: #ifdef USELEDS
873: ledcontrol(0, 0, LED_DISK);
874: #endif
875: hpibgo(ctlr, slave, C_EXEC, rs->sc_addr, rs->sc_resid, rw, rw != 0);
876: }
877:
878: /* ARGSUSED */
879: void
880: hdinterrupt(arg)
881: void *arg;
882: {
883: struct hd_softc *rs = arg;
884: int unit = rs->sc_dev.dv_unit;
885: struct buf *bp = rs->sc_tab.b_actf;
886: u_char stat = 13; /* in case hpibrecv fails */
887: int rv, restart, ctlr, slave;
888:
889: ctlr = rs->sc_dev.dv_parent->dv_unit;
890: slave = rs->sc_slave;
891:
892: #ifdef DEBUG
893: if (hddebug & HDB_FOLLOW)
894: printf("hdinterrupt(%d): bp %p, %c, flags %x\n", unit, bp,
895: (bp->b_flags & B_READ) ? 'R' : 'W', rs->sc_flags);
896: if (bp == NULL) {
897: printf("%s: bp == NULL\n", rs->sc_dev.dv_xname);
898: return;
899: }
900: #endif
901: disk_unbusy(&rs->sc_dkdev, (bp->b_bcount - bp->b_resid),
902: (bp->b_flags & B_READ));
903:
904: if (rs->sc_flags & HDF_SEEK) {
905: rs->sc_flags &= ~HDF_SEEK;
906: if (hpibustart(ctlr))
907: hdgo(rs);
908: return;
909: }
910: if ((rs->sc_flags & HDF_SWAIT) == 0) {
911: #ifdef DEBUG
912: rs->sc_stats.hdpolltries++;
913: #endif
914: if (hpibpptest(ctlr, slave) == 0) {
915: #ifdef DEBUG
916: rs->sc_stats.hdpollwaits++;
917: #endif
918:
919: /* Instrumentation. */
920: disk_busy(&rs->sc_dkdev);
921: rs->sc_flags |= HDF_SWAIT;
922: hpibawait(ctlr);
923: return;
924: }
925: } else
926: rs->sc_flags &= ~HDF_SWAIT;
927: rv = hpibrecv(ctlr, slave, C_QSTAT, &stat, 1);
928: if (rv != 1 || stat) {
929: #ifdef DEBUG
930: if (hddebug & HDB_ERROR)
931: printf("hdinterrupt: recv failed or bad stat %d\n", stat);
932: #endif
933: restart = hderror(unit);
934: #ifdef DEBUG
935: rs->sc_stats.hdretries++;
936: #endif
937: if (rs->sc_errcnt++ < HDRETRY) {
938: if (restart)
939: hdstart(rs);
940: return;
941: }
942: bp->b_flags |= B_ERROR;
943: bp->b_error = EIO;
944: }
945: if (hdfinish(rs, bp))
946: hdustart(rs);
947: }
948:
949: int
950: hdstatus(rs)
951: struct hd_softc *rs;
952: {
953: int c, s;
954: u_char stat;
955: int rv;
956:
957: c = rs->sc_dev.dv_parent->dv_unit;
958: s = rs->sc_slave;
959: rs->sc_rsc.c_unit = C_SUNIT(rs->sc_punit);
960: rs->sc_rsc.c_sram = C_SRAM;
961: rs->sc_rsc.c_ram = C_RAM;
962: rs->sc_rsc.c_cmd = C_STATUS;
963: bzero((caddr_t)&rs->sc_stat, sizeof(rs->sc_stat));
964: rv = hpibsend(c, s, C_CMD, &rs->sc_rsc, sizeof(rs->sc_rsc));
965: if (rv != sizeof(rs->sc_rsc)) {
966: #ifdef DEBUG
967: if (hddebug & HDB_STATUS)
968: printf("hdstatus: send C_CMD failed %d != %d\n",
969: rv, sizeof(rs->sc_rsc));
970: #endif
971: return(1);
972: }
973: rv = hpibrecv(c, s, C_EXEC, &rs->sc_stat, sizeof(rs->sc_stat));
974: if (rv != sizeof(rs->sc_stat)) {
975: #ifdef DEBUG
976: if (hddebug & HDB_STATUS)
977: printf("hdstatus: send C_EXEC failed %d != %d\n",
978: rv, sizeof(rs->sc_stat));
979: #endif
980: return(1);
981: }
982: rv = hpibrecv(c, s, C_QSTAT, &stat, 1);
983: if (rv != 1 || stat) {
984: #ifdef DEBUG
985: if (hddebug & HDB_STATUS)
986: printf("hdstatus: recv failed %d or bad stat %d\n",
987: rv, stat);
988: #endif
989: return(1);
990: }
991: return(0);
992: }
993:
994: /*
995: * Deal with errors.
996: * Returns 1 if request should be restarted,
997: * 0 if we should just quietly give up.
998: */
999: int
1000: hderror(unit)
1001: int unit;
1002: {
1003: struct hd_softc *rs = hd_cd.cd_devs[unit];
1004: struct hd_stat *sp;
1005: struct buf *bp;
1006: daddr64_t hwbn, pbn;
1007:
1008: if (hdstatus(rs)) {
1009: #ifdef DEBUG
1010: printf("%s: couldn't get status\n", rs->sc_dev.dv_xname);
1011: #endif
1012: hdreset(rs->sc_dev.dv_parent->dv_unit,
1013: rs->sc_slave, rs->sc_punit);
1014: return(1);
1015: }
1016: sp = &rs->sc_stat;
1017: if (sp->c_fef & FEF_REXMT)
1018: return(1);
1019: if (sp->c_fef & FEF_PF) {
1020: hdreset(rs->sc_dev.dv_parent->dv_unit,
1021: rs->sc_slave, rs->sc_punit);
1022: return(1);
1023: }
1024: /*
1025: * Unit requests release for internal maintenance.
1026: * We just delay a while and try again later. Use exponentially
1027: * increasing backoff a la ethernet drivers since we don't really
1028: * know how long the maintenance will take. With HDWAITC and
1029: * HDRETRY as defined, the range is 1 to 32 seconds.
1030: */
1031: if (sp->c_fef & FEF_IMR) {
1032: int hdtimo = HDWAITC << rs->sc_errcnt;
1033: #ifdef DEBUG
1034: printf("%s: internal maintenance, %d second timeout\n",
1035: rs->sc_dev.dv_xname, hdtimo);
1036: rs->sc_stats.hdtimeouts++;
1037: #endif
1038: hpibfree(rs->sc_dev.dv_parent, &rs->sc_hq);
1039: timeout_add(&rs->sc_timeout, hdtimo * hz);
1040: return(0);
1041: }
1042: /*
1043: * Only report error if we have reached the error reporting
1044: * threshold. By default, this will only report after the
1045: * retry limit has been exceeded.
1046: */
1047: if (rs->sc_errcnt < hderrthresh)
1048: return(1);
1049:
1050: /*
1051: * First conjure up the block number at which the error occurred.
1052: * Note that not all errors report a block number, in that case
1053: * we just use b_blkno.
1054: */
1055: bp = rs->sc_tab.b_actf;
1056: pbn = DL_GETPOFFSET(&rs->sc_dkdev.dk_label->d_partitions[DISKPART(bp->b_dev)]);
1057: if ((sp->c_fef & FEF_CU) || (sp->c_fef & FEF_DR) ||
1058: (sp->c_ief & IEF_RRMASK)) {
1059: hwbn = HDBTOS(pbn + bp->b_blkno);
1060: pbn = bp->b_blkno;
1061: } else {
1062: hwbn = sp->c_blk;
1063: pbn = HDSTOB(hwbn) - pbn;
1064: }
1065:
1066: diskerr(bp, hd_cd.cd_name, "hard error", LOG_PRINTF,
1067: pbn - bp->b_blkno, rs->sc_dkdev.dk_label);
1068: printf("\n%s%c: ", rs->sc_dev.dv_xname, 'a' + DISKPART(bp->b_dev));
1069:
1070: #ifdef DEBUG
1071: if (hddebug & HDB_ERROR) {
1072: /* status info */
1073: printf("volume: %d, unit: %d\n",
1074: (sp->c_vu>>4)&0xF, sp->c_vu&0xF);
1075: hdprinterr("reject", sp->c_ref, err_reject);
1076: hdprinterr("fault", sp->c_fef, err_fault);
1077: hdprinterr("access", sp->c_aef, err_access);
1078: hdprinterr("info", sp->c_ief, err_info);
1079: printf(" block: %d, P1-P10: ", hwbn);
1080: printf("0x%04x", *(u_int *)&sp->c_raw[0]);
1081: printf("%04x", *(u_int *)&sp->c_raw[4]);
1082: printf("%02x\n", *(u_short *)&sp->c_raw[8]);
1083: /* command */
1084: printf(" ioc: ");
1085: printf("0x%x", *(u_int *)&rs->sc_ioc.c_pad);
1086: printf("0x%x", *(u_short *)&rs->sc_ioc.c_hiaddr);
1087: printf("0x%x", *(u_int *)&rs->sc_ioc.c_addr);
1088: printf("0x%x", *(u_short *)&rs->sc_ioc.c_nop2);
1089: printf("0x%x", *(u_int *)&rs->sc_ioc.c_len);
1090: printf("0x%x\n", *(u_short *)&rs->sc_ioc.c_cmd);
1091: } else
1092: #endif
1093: {
1094: printf("v%d u%d, R0x%x F0x%x A0x%x I0x%x",
1095: (sp->c_vu>>4)&0xF, sp->c_vu&0xF,
1096: sp->c_ref, sp->c_fef, sp->c_aef, sp->c_ief);
1097: printf(" P1-P10: 0x%04x%04x%02x\n",
1098: *(u_int *)&sp->c_raw[0], *(u_int *)&sp->c_raw[4],
1099: *(u_short *)&sp->c_raw[8]);
1100: }
1101: return (1);
1102: }
1103:
1104: int
1105: hdread(dev, uio, flags)
1106: dev_t dev;
1107: struct uio *uio;
1108: int flags;
1109: {
1110:
1111: return (physio(hdstrategy, NULL, dev, B_READ, minphys, uio));
1112: }
1113:
1114: int
1115: hdwrite(dev, uio, flags)
1116: dev_t dev;
1117: struct uio *uio;
1118: int flags;
1119: {
1120:
1121: return (physio(hdstrategy, NULL, dev, B_WRITE, minphys, uio));
1122: }
1123:
1124: int
1125: hdioctl(dev, cmd, data, flag, p)
1126: dev_t dev;
1127: u_long cmd;
1128: caddr_t data;
1129: int flag;
1130: struct proc *p;
1131: {
1132: int unit = DISKUNIT(dev);
1133: struct hd_softc *sc;
1134: int error = 0;
1135:
1136: sc = hdlookup(unit);
1137: if (sc == NULL)
1138: return (ENXIO);
1139:
1140: switch (cmd) {
1141: case DIOCGPDINFO:
1142: hdgetdisklabel(dev, sc, (struct disklabel *)data, 1);
1143: goto exit;
1144:
1145: case DIOCGDINFO:
1146: *(struct disklabel *)data = *sc->sc_dkdev.dk_label;
1147: goto exit;
1148:
1149: case DIOCGPART:
1150: ((struct partinfo *)data)->disklab = sc->sc_dkdev.dk_label;
1151: ((struct partinfo *)data)->part =
1152: &sc->sc_dkdev.dk_label->d_partitions[DISKPART(dev)];
1153: goto exit;
1154:
1155: case DIOCWLABEL:
1156: if ((flag & FWRITE) == 0) {
1157: error = EBADF;
1158: goto exit;
1159: }
1160: if (*(int *)data)
1161: sc->sc_flags |= HDF_WLABEL;
1162: else
1163: sc->sc_flags &= ~HDF_WLABEL;
1164: goto exit;
1165:
1166: case DIOCWDINFO:
1167: case DIOCSDINFO:
1168: if ((flag & FWRITE) == 0) {
1169: error = EBADF;
1170: goto exit;
1171: }
1172:
1173: if ((error = hdlock(sc)) != 0)
1174: goto exit;
1175: sc->sc_flags |= HDF_WLABEL;
1176:
1177: error = setdisklabel(sc->sc_dkdev.dk_label,
1178: (struct disklabel *)data, /* sc->sc_dkdev.dk_openmask */ 0);
1179: if (error == 0) {
1180: if (cmd == DIOCWDINFO)
1181: error = writedisklabel(DISKLABELDEV(dev),
1182: hdstrategy, sc->sc_dkdev.dk_label);
1183: }
1184:
1185: sc->sc_flags &= ~HDF_WLABEL;
1186: hdunlock(sc);
1187: goto exit;
1188:
1189: default:
1190: error = EINVAL;
1191: break;
1192: }
1193:
1194: exit:
1195: device_unref(&sc->sc_dev);
1196: return (error);
1197: }
1198:
1199: daddr64_t
1200: hdsize(dev)
1201: dev_t dev;
1202: {
1203: struct hd_softc *rs;
1204: int unit = DISKUNIT(dev);
1205: int part, omask;
1206: int size;
1207:
1208: rs = hdlookup(unit);
1209: if (rs == NULL)
1210: return (-1);
1211:
1212: part = DISKPART(dev);
1213: omask = rs->sc_dkdev.dk_openmask & (1 << part);
1214:
1215: /*
1216: * We get called very early on (via swapconf)
1217: * without the device being open so we may need
1218: * to handle it here.
1219: */
1220: if (omask == 0 && hdopen(dev, FREAD | FWRITE, S_IFBLK, NULL) != 0) {
1221: size = -1;
1222: goto out;
1223: }
1224:
1225: if (rs->sc_dkdev.dk_label->d_partitions[part].p_fstype != FS_SWAP)
1226: size = -1;
1227: else
1228: size = DL_GETPSIZE(&rs->sc_dkdev.dk_label->d_partitions[part]) *
1229: (rs->sc_dkdev.dk_label->d_secsize / DEV_BSIZE);
1230:
1231: if (hdclose(dev, FREAD | FWRITE, S_IFBLK, NULL) != 0)
1232: size = -1;
1233:
1234: out:
1235: device_unref(&rs->sc_dev);
1236: return (size);
1237: }
1238:
1239: #ifdef DEBUG
1240: void
1241: hdprinterr(str, err, tab)
1242: const char *str;
1243: short err;
1244: const char **tab;
1245: {
1246: int i;
1247: int printed;
1248:
1249: if (err == 0)
1250: return;
1251: printf(" %s error %d field:", str, err);
1252: printed = 0;
1253: for (i = 0; i < 16; i++)
1254: if (err & (0x8000 >> i))
1255: printf("%s%s", printed++ ? " + " : " ", tab[i]);
1256: printf("\n");
1257: }
1258: #endif
1259:
1260: static int hddoingadump; /* simple mutex */
1261:
1262: /*
1263: * Non-interrupt driven, non-dma dump routine.
1264: */
1265: int
1266: hddump(dev, blkno, va, size)
1267: dev_t dev;
1268: daddr64_t blkno;
1269: caddr_t va;
1270: size_t size;
1271: {
1272: int sectorsize; /* size of a disk sector */
1273: daddr64_t nsects; /* number of sectors in partition */
1274: daddr64_t sectoff; /* sector offset of partition */
1275: int totwrt; /* total number of sectors left to write */
1276: int nwrt; /* current number of sectors to write */
1277: int unit, part;
1278: int ctlr, slave;
1279: struct hd_softc *rs;
1280: struct disklabel *lp;
1281: char stat;
1282:
1283: /* Check for recursive dump; if so, punt. */
1284: if (hddoingadump)
1285: return (EFAULT);
1286: hddoingadump = 1;
1287:
1288: /* Decompose unit and partition. */
1289: unit = DISKUNIT(dev);
1290: part = DISKPART(dev);
1291:
1292: /* Make sure dump device is ok. */
1293: rs = hdlookup(unit);
1294: if (rs == NULL)
1295: return (ENXIO);
1296: device_unref(&rs->sc_dev);
1297:
1298: ctlr = rs->sc_dev.dv_parent->dv_unit;
1299: slave = rs->sc_slave;
1300:
1301: /*
1302: * Convert to disk sectors. Request must be a multiple of size.
1303: */
1304: lp = rs->sc_dkdev.dk_label;
1305: sectorsize = lp->d_secsize;
1306: if ((size % sectorsize) != 0)
1307: return (EFAULT);
1308: totwrt = size / sectorsize;
1309: blkno = dbtob(blkno) / sectorsize; /* blkno in DEV_BSIZE units */
1310:
1311: nsects = DL_GETPSIZE(&lp->d_partitions[part]);
1312: sectoff = DL_GETPOFFSET(&lp->d_partitions[part]);
1313:
1314: /* Check transfer bounds against partition size. */
1315: if ((blkno < 0) || (blkno + totwrt) > nsects)
1316: return (EINVAL);
1317:
1318: /* Offset block number to start of partition. */
1319: blkno += sectoff;
1320:
1321: while (totwrt > 0) {
1322: nwrt = totwrt; /* XXX */
1323: #ifndef HD_DUMP_NOT_TRUSTED
1324: /*
1325: * Fill out and send HPIB command.
1326: */
1327: rs->sc_ioc.c_unit = C_SUNIT(rs->sc_punit);
1328: rs->sc_ioc.c_volume = C_SVOL(0);
1329: rs->sc_ioc.c_saddr = C_SADDR;
1330: rs->sc_ioc.c_hiaddr = 0;
1331: rs->sc_ioc.c_addr = HDBTOS(blkno);
1332: rs->sc_ioc.c_nop2 = C_NOP;
1333: rs->sc_ioc.c_slen = C_SLEN;
1334: rs->sc_ioc.c_len = nwrt * sectorsize;
1335: rs->sc_ioc.c_cmd = C_WRITE;
1336: hpibsend(ctlr, slave, C_CMD, &rs->sc_ioc.c_unit,
1337: sizeof(rs->sc_ioc)-2);
1338: if (hpibswait(ctlr, slave))
1339: return (EIO);
1340:
1341: /*
1342: * Send the data.
1343: */
1344: hpibsend(ctlr, slave, C_EXEC, va, nwrt * sectorsize);
1345: (void) hpibswait(ctlr, slave);
1346: hpibrecv(ctlr, slave, C_QSTAT, &stat, 1);
1347: if (stat)
1348: return (EIO);
1349: #else /* HD_DUMP_NOT_TRUSTED */
1350: /* Let's just talk about this first... */
1351: printf("%s: dump addr %p, blk %d\n", sc->sc_dev.dv_xname,
1352: va, blkno);
1353: delay(500 * 1000); /* half a second */
1354: #endif /* HD_DUMP_NOT_TRUSTED */
1355:
1356: /* update block count */
1357: totwrt -= nwrt;
1358: blkno += nwrt;
1359: va += sectorsize * nwrt;
1360: }
1361: hddoingadump = 0;
1362: return (0);
1363: }