Annotation of sys/dev/ata/wd.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: wd.c,v 1.66 2007/06/20 18:15:46 deraadt Exp $ */
2: /* $NetBSD: wd.c,v 1.193 1999/02/28 17:15:27 explorer Exp $ */
3:
4: /*
5: * Copyright (c) 1998, 2001 Manuel Bouyer. All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. All advertising materials mentioning features or use of this software
16: * must display the following acknowledgement:
17: * This product includes software developed by Manuel Bouyer.
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: * Copyright (c) 1998 The NetBSD Foundation, Inc.
35: * All rights reserved.
36: *
37: * This code is derived from software contributed to The NetBSD Foundation
38: * by Charles M. Hannum and by Onno van der Linden.
39: *
40: * Redistribution and use in source and binary forms, with or without
41: * modification, are permitted provided that the following conditions
42: * are met:
43: * 1. Redistributions of source code must retain the above copyright
44: * notice, this list of conditions and the following disclaimer.
45: * 2. Redistributions in binary form must reproduce the above copyright
46: * notice, this list of conditions and the following disclaimer in the
47: * documentation and/or other materials provided with the distribution.
48: * 3. All advertising materials mentioning features or use of this software
49: * must display the following acknowledgement:
50: * This product includes software developed by the NetBSD
51: * Foundation, Inc. and its contributors.
52: * 4. Neither the name of The NetBSD Foundation nor the names of its
53: * contributors may be used to endorse or promote products derived
54: * from this software without specific prior written permission.
55: *
56: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
57: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
58: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
59: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
60: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
61: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
62: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
63: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
64: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
65: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
66: * POSSIBILITY OF SUCH DAMAGE.
67: */
68:
69: #if 0
70: #include "rnd.h"
71: #endif
72:
73: #include <sys/param.h>
74: #include <sys/systm.h>
75: #include <sys/kernel.h>
76: #include <sys/conf.h>
77: #include <sys/file.h>
78: #include <sys/stat.h>
79: #include <sys/ioctl.h>
80: #include <sys/buf.h>
81: #include <sys/uio.h>
82: #include <sys/malloc.h>
83: #include <sys/device.h>
84: #include <sys/disklabel.h>
85: #include <sys/disk.h>
86: #include <sys/syslog.h>
87: #include <sys/proc.h>
88: #include <sys/vnode.h>
89:
90: #include <uvm/uvm_extern.h>
91:
92: #include <machine/intr.h>
93: #include <machine/bus.h>
94:
95: #include <dev/ata/atareg.h>
96: #include <dev/ata/atavar.h>
97: #include <dev/ata/wdvar.h>
98: #include <dev/ic/wdcreg.h>
99: #include <dev/ic/wdcvar.h>
100: #if 0
101: #include "locators.h"
102: #endif
103:
104: #define LBA48_THRESHOLD (0xfffffff) /* 128GB / DEV_BSIZE */
105:
106: #define WDIORETRIES_SINGLE 4 /* number of retries before single-sector */
107: #define WDIORETRIES 5 /* number of retries before giving up */
108: #define RECOVERYTIME hz/2 /* time to wait before retrying a cmd */
109:
110: #define DEBUG_INTR 0x01
111: #define DEBUG_XFERS 0x02
112: #define DEBUG_STATUS 0x04
113: #define DEBUG_FUNCS 0x08
114: #define DEBUG_PROBE 0x10
115: #ifdef WDCDEBUG
116: extern int wdcdebug_wd_mask; /* init'ed in ata_wdc.c */
117: #define WDCDEBUG_PRINT(args, level) do { \
118: if ((wdcdebug_wd_mask & (level)) != 0) \
119: printf args; \
120: } while (0)
121: #else
122: #define WDCDEBUG_PRINT(args, level)
123: #endif
124:
125: struct wd_softc {
126: /* General disk infos */
127: struct device sc_dev;
128: struct disk sc_dk;
129: struct buf sc_q;
130: /* IDE disk soft states */
131: struct ata_bio sc_wdc_bio; /* current transfer */
132: struct buf *sc_bp; /* buf being transferred */
133: struct ata_drive_datas *drvp; /* Our controller's infos */
134: int openings;
135: struct ataparams sc_params;/* drive characteristics found */
136: int sc_flags;
137: #define WDF_LOCKED 0x01
138: #define WDF_WANTED 0x02
139: #define WDF_WLABEL 0x04 /* label is writable */
140: #define WDF_LABELLING 0x08 /* writing label */
141: /*
142: * XXX Nothing resets this yet, but disk change sensing will when ATA-4 is
143: * more fully implemented.
144: */
145: #define WDF_LOADED 0x10 /* parameters loaded */
146: #define WDF_WAIT 0x20 /* waiting for resources */
147: #define WDF_LBA 0x40 /* using LBA mode */
148: #define WDF_LBA48 0x80 /* using 48-bit LBA mode */
149:
150: u_int64_t sc_capacity;
151: int cyl; /* actual drive parameters */
152: int heads;
153: int sectors;
154: int retries; /* number of xfer retry */
155: struct timeout sc_restart_timeout;
156: void *sc_sdhook;
157: };
158:
159: #define sc_drive sc_wdc_bio.drive
160: #define sc_mode sc_wdc_bio.mode
161: #define sc_multi sc_wdc_bio.multi
162:
163: int wdprobe(struct device *, void *, void *);
164: void wdattach(struct device *, struct device *, void *);
165: int wddetach(struct device *, int);
166: int wdactivate(struct device *, enum devact);
167: int wdprint(void *, char *);
168:
169: struct cfattach wd_ca = {
170: sizeof(struct wd_softc), wdprobe, wdattach,
171: wddetach, wdactivate
172: };
173:
174: struct cfdriver wd_cd = {
175: NULL, "wd", DV_DISK
176: };
177:
178: void wdgetdefaultlabel(struct wd_softc *, struct disklabel *);
179: void wdgetdisklabel(dev_t dev, struct wd_softc *, struct disklabel *, int);
180: void wdstrategy(struct buf *);
181: void wdstart(void *);
182: void __wdstart(struct wd_softc*, struct buf *);
183: void wdrestart(void *);
184: int wd_get_params(struct wd_softc *, u_int8_t, struct ataparams *);
185: void wd_flushcache(struct wd_softc *, int);
186: void wd_shutdown(void *);
187:
188: struct dkdriver wddkdriver = { wdstrategy };
189:
190: /* XXX: these should go elsewhere */
191: cdev_decl(wd);
192: bdev_decl(wd);
193:
194: #define wdlock(wd) disk_lock(&(wd)->sc_dk)
195: #define wdunlock(wd) disk_unlock(&(wd)->sc_dk)
196: #define wdlookup(unit) (struct wd_softc *)device_lookup(&wd_cd, (unit))
197:
198:
199: int
200: wdprobe(struct device *parent, void *match_, void *aux)
201: {
202: struct ata_atapi_attach *aa_link = aux;
203: struct cfdata *match = match_;
204:
205: if (aa_link == NULL)
206: return 0;
207: if (aa_link->aa_type != T_ATA)
208: return 0;
209:
210: if (match->cf_loc[0] != -1 &&
211: match->cf_loc[0] != aa_link->aa_channel)
212: return 0;
213:
214: if (match->cf_loc[1] != -1 &&
215: match->cf_loc[1] != aa_link->aa_drv_data->drive)
216: return 0;
217:
218: return 1;
219: }
220:
221: void
222: wdattach(struct device *parent, struct device *self, void *aux)
223: {
224: struct wd_softc *wd = (void *)self;
225: struct ata_atapi_attach *aa_link= aux;
226: struct wdc_command wdc_c;
227: int i, blank;
228: char buf[41], c, *p, *q;
229: WDCDEBUG_PRINT(("wdattach\n"), DEBUG_FUNCS | DEBUG_PROBE);
230:
231: wd->openings = aa_link->aa_openings;
232: wd->drvp = aa_link->aa_drv_data;
233:
234: strlcpy(wd->drvp->drive_name, wd->sc_dev.dv_xname,
235: sizeof(wd->drvp->drive_name));
236: wd->drvp->cf_flags = wd->sc_dev.dv_cfdata->cf_flags;
237:
238: if ((NERRS_MAX - 2) > 0)
239: wd->drvp->n_dmaerrs = NERRS_MAX - 2;
240: else
241: wd->drvp->n_dmaerrs = 0;
242:
243: /* read our drive info */
244: if (wd_get_params(wd, at_poll, &wd->sc_params) != 0) {
245: printf("%s: IDENTIFY failed\n", wd->sc_dev.dv_xname);
246: return;
247: }
248:
249: for (blank = 0, p = wd->sc_params.atap_model, q = buf, i = 0;
250: i < sizeof(wd->sc_params.atap_model); i++) {
251: c = *p++;
252: if (c == '\0')
253: break;
254: if (c != ' ') {
255: if (blank) {
256: *q++ = ' ';
257: blank = 0;
258: }
259: *q++ = c;
260: } else
261: blank = 1;
262: }
263: *q++ = '\0';
264:
265: printf(": <%s>\n", buf);
266:
267: wdc_probe_caps(wd->drvp, &wd->sc_params);
268: wdc_print_caps(wd->drvp);
269:
270: if ((wd->sc_params.atap_multi & 0xff) > 1) {
271: wd->sc_multi = wd->sc_params.atap_multi & 0xff;
272: } else {
273: wd->sc_multi = 1;
274: }
275:
276: printf("%s: %d-sector PIO,", wd->sc_dev.dv_xname, wd->sc_multi);
277:
278: /* use 48-bit LBA if enabled */
279: /* XXX: shall we use it if drive capacity < 137Gb? */
280: if ((wd->sc_params.atap_cmd2_en & ATAPI_CMD2_48AD) != 0)
281: wd->sc_flags |= WDF_LBA48;
282:
283: /* Prior to ATA-4, LBA was optional. */
284: if ((wd->sc_params.atap_capabilities1 & WDC_CAP_LBA) != 0)
285: wd->sc_flags |= WDF_LBA;
286: #if 0
287: /* ATA-4 requires LBA. */
288: if (wd->sc_params.atap_ataversion != 0xffff &&
289: wd->sc_params.atap_ataversion >= WDC_VER_ATA4)
290: wd->sc_flags |= WDF_LBA;
291: #endif
292:
293: if ((wd->sc_flags & WDF_LBA48) != 0) {
294: wd->sc_capacity =
295: (((u_int64_t)wd->sc_params.atap_max_lba[3] << 48) |
296: ((u_int64_t)wd->sc_params.atap_max_lba[2] << 32) |
297: ((u_int64_t)wd->sc_params.atap_max_lba[1] << 16) |
298: (u_int64_t)wd->sc_params.atap_max_lba[0]);
299: printf(" LBA48, %lluMB, %llu sectors\n",
300: wd->sc_capacity / (1048576 / DEV_BSIZE),
301: wd->sc_capacity);
302: } else if ((wd->sc_flags & WDF_LBA) != 0) {
303: wd->sc_capacity =
304: (wd->sc_params.atap_capacity[1] << 16) |
305: wd->sc_params.atap_capacity[0];
306: printf(" LBA, %lluMB, %llu sectors\n",
307: wd->sc_capacity / (1048576 / DEV_BSIZE),
308: wd->sc_capacity);
309: } else {
310: wd->sc_capacity =
311: wd->sc_params.atap_cylinders *
312: wd->sc_params.atap_heads *
313: wd->sc_params.atap_sectors;
314: printf(" CHS, %lluMB, %d cyl, %d head, %d sec, %llu sectors\n",
315: wd->sc_capacity / (1048576 / DEV_BSIZE),
316: wd->sc_params.atap_cylinders,
317: wd->sc_params.atap_heads,
318: wd->sc_params.atap_sectors,
319: wd->sc_capacity);
320: }
321: WDCDEBUG_PRINT(("%s: atap_dmatiming_mimi=%d, atap_dmatiming_recom=%d\n",
322: self->dv_xname, wd->sc_params.atap_dmatiming_mimi,
323: wd->sc_params.atap_dmatiming_recom), DEBUG_PROBE);
324:
325: /*
326: * FREEZE LOCK the drive so malicous users can't lock it on us.
327: * As there is no harm in issuing this to drives that don't
328: * support the security feature set we just send it, and don't
329: * bother checking if the drive sends a command abort to tell us it
330: * doesn't support it.
331: */
332: bzero(&wdc_c, sizeof(struct wdc_command));
333:
334: wdc_c.r_command = WDCC_SEC_FREEZE_LOCK;
335: wdc_c.timeout = 1000;
336: wdc_c.flags = at_poll;
337: if (wdc_exec_command(wd->drvp, &wdc_c) != WDC_COMPLETE) {
338: printf("%s: freeze lock command didn't complete\n",
339: wd->sc_dev.dv_xname);
340: }
341:
342: /*
343: * Initialize and attach the disk structure.
344: */
345: wd->sc_dk.dk_driver = &wddkdriver;
346: wd->sc_dk.dk_name = wd->sc_dev.dv_xname;
347: disk_attach(&wd->sc_dk);
348: wd->sc_wdc_bio.lp = wd->sc_dk.dk_label;
349: wd->sc_sdhook = shutdownhook_establish(wd_shutdown, wd);
350: if (wd->sc_sdhook == NULL)
351: printf("%s: WARNING: unable to establish shutdown hook\n",
352: wd->sc_dev.dv_xname);
353: timeout_set(&wd->sc_restart_timeout, wdrestart, wd);
354: }
355:
356: int
357: wdactivate(struct device *self, enum devact act)
358: {
359: int rv = 0;
360:
361: switch (act) {
362: case DVACT_ACTIVATE:
363: break;
364:
365: case DVACT_DEACTIVATE:
366: /*
367: * Nothing to do; we key off the device's DVF_ACTIVATE.
368: */
369: break;
370: }
371: return (rv);
372: }
373:
374: int
375: wddetach(struct device *self, int flags)
376: {
377: struct wd_softc *sc = (struct wd_softc *)self;
378: struct buf *dp, *bp;
379: int s, bmaj, cmaj, mn;
380:
381: /* Remove unprocessed buffers from queue */
382: s = splbio();
383: for (dp = &sc->sc_q; (bp = dp->b_actf) != NULL; ) {
384: dp->b_actf = bp->b_actf;
385: bp->b_error = ENXIO;
386: bp->b_flags |= B_ERROR;
387: biodone(bp);
388: }
389: splx(s);
390:
391: /* Locate the lowest minor number to be detached. */
392: mn = DISKMINOR(self->dv_unit, 0);
393:
394: for (bmaj = 0; bmaj < nblkdev; bmaj++)
395: if (bdevsw[bmaj].d_open == wdopen)
396: vdevgone(bmaj, mn, mn + MAXPARTITIONS - 1, VBLK);
397: for (cmaj = 0; cmaj < nchrdev; cmaj++)
398: if (cdevsw[cmaj].d_open == wdopen)
399: vdevgone(cmaj, mn, mn + MAXPARTITIONS - 1, VCHR);
400:
401: /* Get rid of the shutdown hook. */
402: if (sc->sc_sdhook != NULL)
403: shutdownhook_disestablish(sc->sc_sdhook);
404:
405: /* Detach disk. */
406: disk_detach(&sc->sc_dk);
407:
408: return (0);
409: }
410:
411: /*
412: * Read/write routine for a buffer. Validates the arguments and schedules the
413: * transfer. Does not wait for the transfer to complete.
414: */
415: void
416: wdstrategy(struct buf *bp)
417: {
418: struct wd_softc *wd;
419: int s;
420:
421: wd = wdlookup(DISKUNIT(bp->b_dev));
422: if (wd == NULL) {
423: bp->b_error = ENXIO;
424: goto bad;
425: }
426:
427: WDCDEBUG_PRINT(("wdstrategy (%s)\n", wd->sc_dev.dv_xname),
428: DEBUG_XFERS);
429:
430: /* Valid request? */
431: if (bp->b_blkno < 0 ||
432: (bp->b_bcount % wd->sc_dk.dk_label->d_secsize) != 0 ||
433: (bp->b_bcount / wd->sc_dk.dk_label->d_secsize) >= (1 << NBBY)) {
434: bp->b_error = EINVAL;
435: goto bad;
436: }
437:
438: /* If device invalidated (e.g. media change, door open), error. */
439: if ((wd->sc_flags & WDF_LOADED) == 0) {
440: bp->b_error = EIO;
441: goto bad;
442: }
443:
444: /* If it's a null transfer, return immediately. */
445: if (bp->b_bcount == 0)
446: goto done;
447:
448: /*
449: * Do bounds checking, adjust transfer. if error, process.
450: * If end of partition, just return.
451: */
452: if (DISKPART(bp->b_dev) != RAW_PART &&
453: bounds_check_with_label(bp, wd->sc_dk.dk_label,
454: (wd->sc_flags & (WDF_WLABEL|WDF_LABELLING)) != 0) <= 0)
455: goto done;
456: /* Queue transfer on drive, activate drive and controller if idle. */
457: s = splbio();
458: disksort(&wd->sc_q, bp);
459: wdstart(wd);
460: splx(s);
461: device_unref(&wd->sc_dev);
462: return;
463: bad:
464: bp->b_flags |= B_ERROR;
465: done:
466: /* Toss transfer; we're done early. */
467: bp->b_resid = bp->b_bcount;
468: s = splbio();
469: biodone(bp);
470: splx(s);
471: if (wd != NULL)
472: device_unref(&wd->sc_dev);
473: }
474:
475: /*
476: * Queue a drive for I/O.
477: */
478: void
479: wdstart(void *arg)
480: {
481: struct wd_softc *wd = arg;
482: struct buf *dp, *bp = NULL;
483:
484: WDCDEBUG_PRINT(("wdstart %s\n", wd->sc_dev.dv_xname),
485: DEBUG_XFERS);
486: while (wd->openings > 0) {
487:
488: /* Is there a buf for us ? */
489: dp = &wd->sc_q;
490: if ((bp = dp->b_actf) == NULL) /* yes, an assign */
491: return;
492: dp->b_actf = bp->b_actf;
493:
494: /*
495: * Make the command. First lock the device
496: */
497: wd->openings--;
498:
499: wd->retries = 0;
500: __wdstart(wd, bp);
501: }
502: }
503:
504: void
505: __wdstart(struct wd_softc *wd, struct buf *bp)
506: {
507: daddr64_t nblks;
508:
509: wd->sc_wdc_bio.blkno = bp->b_blkno +
510: DL_GETPOFFSET(&wd->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)]);
511: wd->sc_wdc_bio.blkno /= (wd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
512: wd->sc_wdc_bio.blkdone =0;
513: wd->sc_bp = bp;
514: /*
515: * If we're retrying, retry in single-sector mode. This will give us
516: * the sector number of the problem, and will eventually allow the
517: * transfer to succeed.
518: */
519: if (wd->sc_multi == 1 || wd->retries >= WDIORETRIES_SINGLE)
520: wd->sc_wdc_bio.flags = ATA_SINGLE;
521: else
522: wd->sc_wdc_bio.flags = 0;
523: nblks = bp->b_bcount / wd->sc_dk.dk_label->d_secsize;
524: if ((wd->sc_flags & WDF_LBA48) &&
525: /* use LBA48 only if really need */
526: ((wd->sc_wdc_bio.blkno + nblks - 1 > LBA48_THRESHOLD) ||
527: (nblks > 0xff)))
528: wd->sc_wdc_bio.flags |= ATA_LBA48;
529: if (wd->sc_flags & WDF_LBA)
530: wd->sc_wdc_bio.flags |= ATA_LBA;
531: if (bp->b_flags & B_READ)
532: wd->sc_wdc_bio.flags |= ATA_READ;
533: wd->sc_wdc_bio.bcount = bp->b_bcount;
534: wd->sc_wdc_bio.databuf = bp->b_data;
535: wd->sc_wdc_bio.wd = wd;
536: /* Instrumentation. */
537: disk_busy(&wd->sc_dk);
538: switch (wdc_ata_bio(wd->drvp, &wd->sc_wdc_bio)) {
539: case WDC_TRY_AGAIN:
540: timeout_add(&wd->sc_restart_timeout, hz);
541: break;
542: case WDC_QUEUED:
543: break;
544: case WDC_COMPLETE:
545: /*
546: * This code is never executed because we never set
547: * the ATA_POLL flag above
548: */
549: #if 0
550: if (wd->sc_wdc_bio.flags & ATA_POLL)
551: wddone(wd);
552: #endif
553: break;
554: default:
555: panic("__wdstart: bad return code from wdc_ata_bio()");
556: }
557: }
558:
559: void
560: wddone(void *v)
561: {
562: struct wd_softc *wd = v;
563: struct buf *bp = wd->sc_bp;
564: char buf[256], *errbuf = buf;
565: WDCDEBUG_PRINT(("wddone %s\n", wd->sc_dev.dv_xname),
566: DEBUG_XFERS);
567:
568: bp->b_resid = wd->sc_wdc_bio.bcount;
569: errbuf[0] = '\0';
570: switch (wd->sc_wdc_bio.error) {
571: case ERR_NODEV:
572: bp->b_flags |= B_ERROR;
573: bp->b_error = ENXIO;
574: break;
575: case ERR_DMA:
576: errbuf = "DMA error";
577: goto retry;
578: case ERR_DF:
579: errbuf = "device fault";
580: goto retry;
581: case TIMEOUT:
582: errbuf = "device timeout";
583: goto retry;
584: case ERROR:
585: /* Don't care about media change bits */
586: if (wd->sc_wdc_bio.r_error != 0 &&
587: (wd->sc_wdc_bio.r_error & ~(WDCE_MC | WDCE_MCR)) == 0)
588: goto noerror;
589: ata_perror(wd->drvp, wd->sc_wdc_bio.r_error, errbuf,
590: sizeof buf);
591: retry:
592: /* Just reset and retry. Can we do more ? */
593: wdc_reset_channel(wd->drvp);
594: diskerr(bp, "wd", errbuf, LOG_PRINTF,
595: wd->sc_wdc_bio.blkdone, wd->sc_dk.dk_label);
596: if (wd->retries++ < WDIORETRIES) {
597: printf(", retrying\n");
598: timeout_add(&wd->sc_restart_timeout, RECOVERYTIME);
599: return;
600: }
601: printf("\n");
602: bp->b_flags |= B_ERROR;
603: bp->b_error = EIO;
604: break;
605: case NOERROR:
606: noerror: if ((wd->sc_wdc_bio.flags & ATA_CORR) || wd->retries > 0)
607: printf("%s: soft error (corrected)\n",
608: wd->sc_dev.dv_xname);
609: }
610: disk_unbusy(&wd->sc_dk, (bp->b_bcount - bp->b_resid),
611: (bp->b_flags & B_READ));
612: biodone(bp);
613: wd->openings++;
614: wdstart(wd);
615: }
616:
617: void
618: wdrestart(void *v)
619: {
620: struct wd_softc *wd = v;
621: struct buf *bp = wd->sc_bp;
622: int s;
623: WDCDEBUG_PRINT(("wdrestart %s\n", wd->sc_dev.dv_xname),
624: DEBUG_XFERS);
625:
626: s = splbio();
627: disk_unbusy(&wd->sc_dk, 0, (bp->b_flags & B_READ));
628: __wdstart(v, bp);
629: splx(s);
630: }
631:
632: int
633: wdread(dev_t dev, struct uio *uio, int flags)
634: {
635:
636: WDCDEBUG_PRINT(("wdread\n"), DEBUG_XFERS);
637: return (physio(wdstrategy, NULL, dev, B_READ, minphys, uio));
638: }
639:
640: int
641: wdwrite(dev_t dev, struct uio *uio, int flags)
642: {
643:
644: WDCDEBUG_PRINT(("wdwrite\n"), DEBUG_XFERS);
645: return (physio(wdstrategy, NULL, dev, B_WRITE, minphys, uio));
646: }
647:
648: int
649: wdopen(dev_t dev, int flag, int fmt, struct proc *p)
650: {
651: struct wd_softc *wd;
652: int unit, part;
653: int error;
654:
655: WDCDEBUG_PRINT(("wdopen\n"), DEBUG_FUNCS);
656:
657: unit = DISKUNIT(dev);
658: wd = wdlookup(unit);
659: if (wd == NULL)
660: return ENXIO;
661:
662: /*
663: * If this is the first open of this device, add a reference
664: * to the adapter.
665: */
666: if ((error = wdlock(wd)) != 0)
667: goto bad4;
668:
669: if (wd->sc_dk.dk_openmask != 0) {
670: /*
671: * If any partition is open, but the disk has been invalidated,
672: * disallow further opens.
673: */
674: if ((wd->sc_flags & WDF_LOADED) == 0) {
675: error = EIO;
676: goto bad3;
677: }
678: } else {
679: if ((wd->sc_flags & WDF_LOADED) == 0) {
680: wd->sc_flags |= WDF_LOADED;
681:
682: /* Load the physical device parameters. */
683: wd_get_params(wd, AT_WAIT, &wd->sc_params);
684:
685: /* Load the partition info if not already loaded. */
686: wdgetdisklabel(dev, wd, wd->sc_dk.dk_label, 0);
687: }
688: }
689:
690: part = DISKPART(dev);
691:
692: /* Check that the partition exists. */
693: if (part != RAW_PART &&
694: (part >= wd->sc_dk.dk_label->d_npartitions ||
695: wd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
696: error = ENXIO;
697: goto bad;
698: }
699:
700: /* Insure only one open at a time. */
701: switch (fmt) {
702: case S_IFCHR:
703: wd->sc_dk.dk_copenmask |= (1 << part);
704: break;
705: case S_IFBLK:
706: wd->sc_dk.dk_bopenmask |= (1 << part);
707: break;
708: }
709: wd->sc_dk.dk_openmask =
710: wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
711:
712: wdunlock(wd);
713: device_unref(&wd->sc_dev);
714: return 0;
715:
716: bad:
717: if (wd->sc_dk.dk_openmask == 0) {
718: }
719:
720: bad3:
721: wdunlock(wd);
722: bad4:
723: device_unref(&wd->sc_dev);
724: return error;
725: }
726:
727: int
728: wdclose(dev_t dev, int flag, int fmt, struct proc *p)
729: {
730: struct wd_softc *wd;
731: int part = DISKPART(dev);
732: int error = 0;
733:
734: wd = wdlookup(DISKUNIT(dev));
735: if (wd == NULL)
736: return ENXIO;
737:
738: WDCDEBUG_PRINT(("wdclose\n"), DEBUG_FUNCS);
739: if ((error = wdlock(wd)) != 0)
740: goto exit;
741:
742: switch (fmt) {
743: case S_IFCHR:
744: wd->sc_dk.dk_copenmask &= ~(1 << part);
745: break;
746: case S_IFBLK:
747: wd->sc_dk.dk_bopenmask &= ~(1 << part);
748: break;
749: }
750: wd->sc_dk.dk_openmask =
751: wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
752:
753: if (wd->sc_dk.dk_openmask == 0) {
754: wd_flushcache(wd, 0);
755: /* XXXX Must wait for I/O to complete! */
756: }
757:
758: wdunlock(wd);
759:
760: exit:
761: device_unref(&wd->sc_dev);
762: return (error);
763: }
764:
765: void
766: wdgetdefaultlabel(struct wd_softc *wd, struct disklabel *lp)
767: {
768: WDCDEBUG_PRINT(("wdgetdefaultlabel\n"), DEBUG_FUNCS);
769: bzero(lp, sizeof(struct disklabel));
770:
771: lp->d_secsize = DEV_BSIZE;
772: DL_SETDSIZE(lp, wd->sc_capacity);
773: lp->d_ntracks = wd->sc_params.atap_heads;
774: lp->d_nsectors = wd->sc_params.atap_sectors;
775: lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
776: lp->d_ncylinders = DL_GETDSIZE(lp) / lp->d_secpercyl;
777: if (wd->drvp->ata_vers == -1) {
778: lp->d_type = DTYPE_ST506;
779: strncpy(lp->d_typename, "ST506/MFM/RLL", sizeof lp->d_typename);
780: } else {
781: lp->d_type = DTYPE_ESDI;
782: strncpy(lp->d_typename, "ESDI/IDE disk", sizeof lp->d_typename);
783: }
784: /* XXX - user viscopy() like sd.c */
785: strncpy(lp->d_packname, wd->sc_params.atap_model, sizeof lp->d_packname);
786: lp->d_rpm = 3600;
787: lp->d_interleave = 1;
788: lp->d_flags = 0;
789: lp->d_version = 1;
790:
791: lp->d_magic = DISKMAGIC;
792: lp->d_magic2 = DISKMAGIC;
793: lp->d_checksum = dkcksum(lp);
794: }
795:
796: /*
797: * Fabricate a default disk label, and try to read the correct one.
798: */
799: void
800: wdgetdisklabel(dev_t dev, struct wd_softc *wd, struct disklabel *lp,
801: int spoofonly)
802: {
803: char *errstring;
804:
805: WDCDEBUG_PRINT(("wdgetdisklabel\n"), DEBUG_FUNCS);
806:
807: wdgetdefaultlabel(wd, lp);
808:
809: if (wd->drvp->state > RECAL)
810: wd->drvp->drive_flags |= DRIVE_RESET;
811: errstring = readdisklabel(DISKLABELDEV(dev), wdstrategy, lp,
812: spoofonly);
813: if (wd->drvp->state > RECAL)
814: wd->drvp->drive_flags |= DRIVE_RESET;
815: if (errstring) {
816: /*printf("%s: %s\n", wd->sc_dev.dv_xname, errstring);*/
817: }
818: }
819:
820: int
821: wdioctl(dev_t dev, u_long xfer, caddr_t addr, int flag, struct proc *p)
822: {
823: struct wd_softc *wd;
824: struct disklabel *lp;
825: int error = 0;
826:
827: WDCDEBUG_PRINT(("wdioctl\n"), DEBUG_FUNCS);
828:
829: wd = wdlookup(DISKUNIT(dev));
830: if (wd == NULL)
831: return ENXIO;
832:
833: if ((wd->sc_flags & WDF_LOADED) == 0) {
834: error = EIO;
835: goto exit;
836: }
837:
838: switch (xfer) {
839: case DIOCRLDINFO:
840: lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
841: wdgetdisklabel(dev, wd, lp, 0);
842: bcopy(lp, wd->sc_dk.dk_label, sizeof(*lp));
843: free(lp, M_TEMP);
844: goto exit;
845:
846: case DIOCGPDINFO:
847: wdgetdisklabel(dev, wd, (struct disklabel *)addr, 1);
848: goto exit;
849:
850: case DIOCGDINFO:
851: *(struct disklabel *)addr = *(wd->sc_dk.dk_label);
852: goto exit;
853:
854: case DIOCGPART:
855: ((struct partinfo *)addr)->disklab = wd->sc_dk.dk_label;
856: ((struct partinfo *)addr)->part =
857: &wd->sc_dk.dk_label->d_partitions[DISKPART(dev)];
858: goto exit;
859:
860: case DIOCWDINFO:
861: case DIOCSDINFO:
862: if ((flag & FWRITE) == 0) {
863: error = EBADF;
864: goto exit;
865: }
866:
867: if ((error = wdlock(wd)) != 0)
868: goto exit;
869: wd->sc_flags |= WDF_LABELLING;
870:
871: error = setdisklabel(wd->sc_dk.dk_label,
872: (struct disklabel *)addr, /*wd->sc_dk.dk_openmask : */0);
873: if (error == 0) {
874: if (wd->drvp->state > RECAL)
875: wd->drvp->drive_flags |= DRIVE_RESET;
876: if (xfer == DIOCWDINFO)
877: error = writedisklabel(DISKLABELDEV(dev),
878: wdstrategy, wd->sc_dk.dk_label);
879: }
880:
881: wd->sc_flags &= ~WDF_LABELLING;
882: wdunlock(wd);
883: goto exit;
884:
885: case DIOCWLABEL:
886: if ((flag & FWRITE) == 0) {
887: error = EBADF;
888: goto exit;
889: }
890:
891: if (*(int *)addr)
892: wd->sc_flags |= WDF_WLABEL;
893: else
894: wd->sc_flags &= ~WDF_WLABEL;
895: goto exit;
896:
897: #ifdef notyet
898: case DIOCWFORMAT:
899: if ((flag & FWRITE) == 0)
900: return EBADF;
901: {
902: struct format_op *fop;
903: struct iovec aiov;
904: struct uio auio;
905:
906: fop = (struct format_op *)addr;
907: aiov.iov_base = fop->df_buf;
908: aiov.iov_len = fop->df_count;
909: auio.uio_iov = &aiov;
910: auio.uio_iovcnt = 1;
911: auio.uio_resid = fop->df_count;
912: auio.uio_segflg = 0;
913: auio.uio_offset =
914: fop->df_startblk * wd->sc_dk.dk_label->d_secsize;
915: auio.uio_procp = p;
916: error = physio(wdformat, NULL, dev, B_WRITE, minphys,
917: &auio);
918: fop->df_count -= auio.uio_resid;
919: fop->df_reg[0] = wdc->sc_status;
920: fop->df_reg[1] = wdc->sc_error;
921: goto exit;
922: }
923: #endif
924:
925: default:
926: error = wdc_ioctl(wd->drvp, xfer, addr, flag, p);
927: goto exit;
928: }
929:
930: #ifdef DIAGNOSTIC
931: panic("wdioctl: impossible");
932: #endif
933:
934: exit:
935: device_unref(&wd->sc_dev);
936: return (error);
937: }
938:
939: #ifdef B_FORMAT
940: int
941: wdformat(struct buf *bp)
942: {
943:
944: bp->b_flags |= B_FORMAT;
945: return wdstrategy(bp);
946: }
947: #endif
948:
949: daddr64_t
950: wdsize(dev_t dev)
951: {
952: struct wd_softc *wd;
953: int part, omask;
954: int64_t size;
955:
956: WDCDEBUG_PRINT(("wdsize\n"), DEBUG_FUNCS);
957:
958: wd = wdlookup(DISKUNIT(dev));
959: if (wd == NULL)
960: return (-1);
961:
962: part = DISKPART(dev);
963: omask = wd->sc_dk.dk_openmask & (1 << part);
964:
965: if (omask == 0 && wdopen(dev, 0, S_IFBLK, NULL) != 0) {
966: size = -1;
967: goto exit;
968: }
969:
970: size = DL_GETPSIZE(&wd->sc_dk.dk_label->d_partitions[part]) *
971: (wd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
972: if (omask == 0 && wdclose(dev, 0, S_IFBLK, NULL) != 0)
973: size = -1;
974:
975: exit:
976: device_unref(&wd->sc_dev);
977: return (size);
978: }
979:
980: /* #define WD_DUMP_NOT_TRUSTED if you just want to watch */
981: static int wddoingadump = 0;
982: static int wddumprecalibrated = 0;
983: static int wddumpmulti = 1;
984:
985: /*
986: * Dump core after a system crash.
987: */
988: int
989: wddump(dev_t dev, daddr64_t blkno, caddr_t va, size_t size)
990: {
991: struct wd_softc *wd; /* disk unit to do the I/O */
992: struct disklabel *lp; /* disk's disklabel */
993: int unit, part;
994: int nblks; /* total number of sectors left to write */
995: int err;
996: char errbuf[256];
997:
998: /* Check if recursive dump; if so, punt. */
999: if (wddoingadump)
1000: return EFAULT;
1001: wddoingadump = 1;
1002:
1003: unit = DISKUNIT(dev);
1004: wd = wdlookup(unit);
1005: if (wd == NULL)
1006: return ENXIO;
1007:
1008: part = DISKPART(dev);
1009:
1010: /* Make sure it was initialized. */
1011: if (wd->drvp->state < READY)
1012: return ENXIO;
1013:
1014: /* Convert to disk sectors. Request must be a multiple of size. */
1015: lp = wd->sc_dk.dk_label;
1016: if ((size % lp->d_secsize) != 0)
1017: return EFAULT;
1018: nblks = size / lp->d_secsize;
1019: blkno = blkno / (lp->d_secsize / DEV_BSIZE);
1020:
1021: /* Check transfer bounds against partition size. */
1022: if ((blkno < 0) || ((blkno + nblks) > DL_GETPSIZE(&lp->d_partitions[part])))
1023: return EINVAL;
1024:
1025: /* Offset block number to start of partition. */
1026: blkno += DL_GETPOFFSET(&lp->d_partitions[part]);
1027:
1028: /* Recalibrate, if first dump transfer. */
1029: if (wddumprecalibrated == 0) {
1030: wddumpmulti = wd->sc_multi;
1031: wddumprecalibrated = 1;
1032: wd->drvp->state = RECAL;
1033: }
1034:
1035: while (nblks > 0) {
1036: again:
1037: wd->sc_wdc_bio.blkno = blkno;
1038: wd->sc_wdc_bio.flags = ATA_POLL;
1039: if (wddumpmulti == 1)
1040: wd->sc_wdc_bio.flags |= ATA_SINGLE;
1041: if (wd->sc_flags & WDF_LBA48)
1042: wd->sc_wdc_bio.flags |= ATA_LBA48;
1043: if (wd->sc_flags & WDF_LBA)
1044: wd->sc_wdc_bio.flags |= ATA_LBA;
1045: wd->sc_wdc_bio.bcount =
1046: min(nblks, wddumpmulti) * lp->d_secsize;
1047: wd->sc_wdc_bio.databuf = va;
1048: wd->sc_wdc_bio.wd = wd;
1049: #ifndef WD_DUMP_NOT_TRUSTED
1050: switch (wdc_ata_bio(wd->drvp, &wd->sc_wdc_bio)) {
1051: case WDC_TRY_AGAIN:
1052: panic("wddump: try again");
1053: break;
1054: case WDC_QUEUED:
1055: panic("wddump: polled command has been queued");
1056: break;
1057: case WDC_COMPLETE:
1058: break;
1059: }
1060: switch(wd->sc_wdc_bio.error) {
1061: case TIMEOUT:
1062: printf("wddump: device timed out");
1063: err = EIO;
1064: break;
1065: case ERR_DF:
1066: printf("wddump: drive fault");
1067: err = EIO;
1068: break;
1069: case ERR_DMA:
1070: printf("wddump: DMA error");
1071: err = EIO;
1072: break;
1073: case ERROR:
1074: errbuf[0] = '\0';
1075: ata_perror(wd->drvp, wd->sc_wdc_bio.r_error, errbuf,
1076: sizeof errbuf);
1077: printf("wddump: %s", errbuf);
1078: err = EIO;
1079: break;
1080: case NOERROR:
1081: err = 0;
1082: break;
1083: default:
1084: panic("wddump: unknown error type");
1085: }
1086: if (err != 0) {
1087: if (wddumpmulti != 1) {
1088: wddumpmulti = 1; /* retry in single-sector */
1089: printf(", retrying\n");
1090: goto again;
1091: }
1092: printf("\n");
1093: return err;
1094: }
1095: #else /* WD_DUMP_NOT_TRUSTED */
1096: /* Let's just talk about this first... */
1097: printf("wd%d: dump addr 0x%x, cylin %d, head %d, sector %d\n",
1098: unit, va, cylin, head, sector);
1099: delay(500 * 1000); /* half a second */
1100: #endif
1101:
1102: /* update block count */
1103: nblks -= min(nblks, wddumpmulti);
1104: blkno += min(nblks, wddumpmulti);
1105: va += min(nblks, wddumpmulti) * lp->d_secsize;
1106: }
1107:
1108: wddoingadump = 0;
1109: return 0;
1110: }
1111:
1112: int
1113: wd_get_params(struct wd_softc *wd, u_int8_t flags, struct ataparams *params)
1114: {
1115: switch (ata_get_params(wd->drvp, flags, params)) {
1116: case CMD_AGAIN:
1117: return 1;
1118: case CMD_ERR:
1119: /* If we already have drive parameters, reuse them. */
1120: if (wd->sc_params.atap_cylinders != 0) {
1121: if (params != &wd->sc_params)
1122: bcopy(&wd->sc_params, params,
1123: sizeof(struct ataparams));
1124: return 0;
1125: }
1126: /*
1127: * We `know' there's a drive here; just assume it's old.
1128: * This geometry is only used to read the MBR and print a
1129: * (false) attach message.
1130: */
1131: bzero(params, sizeof(struct ataparams));
1132: strncpy(params->atap_model, "ST506",
1133: sizeof params->atap_model);
1134: params->atap_config = ATA_CFG_FIXED;
1135: params->atap_cylinders = 1024;
1136: params->atap_heads = 8;
1137: params->atap_sectors = 17;
1138: params->atap_multi = 1;
1139: params->atap_capabilities1 = params->atap_capabilities2 = 0;
1140: wd->drvp->ata_vers = -1; /* Mark it as pre-ATA */
1141: return 0;
1142: case CMD_OK:
1143: return 0;
1144: default:
1145: panic("wd_get_params: bad return code from ata_get_params");
1146: /* NOTREACHED */
1147: }
1148: }
1149:
1150: void
1151: wd_flushcache(struct wd_softc *wd, int flags)
1152: {
1153: struct wdc_command wdc_c;
1154:
1155: if (wd->drvp->ata_vers < 4) /* WDCC_FLUSHCACHE is here since ATA-4 */
1156: return;
1157: bzero(&wdc_c, sizeof(struct wdc_command));
1158: wdc_c.r_command = (wd->sc_flags & WDF_LBA48 ? WDCC_FLUSHCACHE_EXT :
1159: WDCC_FLUSHCACHE);
1160: wdc_c.r_st_bmask = WDCS_DRDY;
1161: wdc_c.r_st_pmask = WDCS_DRDY;
1162: if (flags != 0) {
1163: wdc_c.flags = AT_POLL;
1164: } else {
1165: wdc_c.flags = AT_WAIT;
1166: }
1167: wdc_c.timeout = 30000; /* 30s timeout */
1168: if (wdc_exec_command(wd->drvp, &wdc_c) != WDC_COMPLETE) {
1169: printf("%s: flush cache command didn't complete\n",
1170: wd->sc_dev.dv_xname);
1171: }
1172: if (wdc_c.flags & AT_TIMEOU) {
1173: printf("%s: flush cache command timeout\n",
1174: wd->sc_dev.dv_xname);
1175: }
1176: if (wdc_c.flags & AT_DF) {
1177: printf("%s: flush cache command: drive fault\n",
1178: wd->sc_dev.dv_xname);
1179: }
1180: /*
1181: * Ignore error register, it shouldn't report anything else
1182: * than COMMAND ABORTED, which means the device doesn't support
1183: * flush cache
1184: */
1185: }
1186:
1187: void
1188: wd_shutdown(void *arg)
1189: {
1190: struct wd_softc *wd = arg;
1191: wd_flushcache(wd, AT_POLL);
1192: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to wd.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ata