Annotation of sys/dev/ata/ata_wdc.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: ata_wdc.c,v 1.30 2007/02/14 00:53:47 jsg Exp $ */
2: /* $NetBSD: ata_wdc.c,v 1.21 1999/08/09 09:43:11 bouyer Exp $ */
3:
4: /*
5: * Copyright (c) 1998, 2001 Manuel Bouyer.
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. Neither the name of the University nor the names of its contributors
19: * may be used to endorse or promote products derived from this software
20: * without specific prior written permission.
21: *
22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32: *
33: */
34:
35: /*-
36: * Copyright (c) 1998 The NetBSD Foundation, Inc.
37: * All rights reserved.
38: *
39: * This code is derived from software contributed to The NetBSD Foundation
40: * by Charles M. Hannum, by Onno van der Linden and by Manuel Bouyer.
41: *
42: * Redistribution and use in source and binary forms, with or without
43: * modification, are permitted provided that the following conditions
44: * are met:
45: * 1. Redistributions of source code must retain the above copyright
46: * notice, this list of conditions and the following disclaimer.
47: * 2. Redistributions in binary form must reproduce the above copyright
48: * notice, this list of conditions and the following disclaimer in the
49: * documentation and/or other materials provided with the distribution.
50: * 3. All advertising materials mentioning features or use of this software
51: * must display the following acknowledgement:
52: * This product includes software developed by the NetBSD
53: * Foundation, Inc. and its contributors.
54: * 4. Neither the name of The NetBSD Foundation nor the names of its
55: * contributors may be used to endorse or promote products derived
56: * from this software without specific prior written permission.
57: *
58: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
59: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
60: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
61: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
62: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
63: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
64: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
65: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
66: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
67: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
68: * POSSIBILITY OF SUCH DAMAGE.
69: */
70:
71: #include <sys/param.h>
72: #include <sys/systm.h>
73: #include <sys/kernel.h>
74: #include <sys/file.h>
75: #include <sys/stat.h>
76: #include <sys/buf.h>
77: #include <sys/malloc.h>
78: #include <sys/device.h>
79: #include <sys/disklabel.h>
80: #include <sys/syslog.h>
81: #include <sys/proc.h>
82:
83: #include <machine/intr.h>
84: #include <machine/bus.h>
85:
86: #include <dev/ata/atareg.h>
87: #include <dev/ata/atavar.h>
88: #include <dev/ic/wdcreg.h>
89: #include <dev/ic/wdcvar.h>
90: #include <dev/ata/wdvar.h>
91:
92: #define DEBUG_INTR 0x01
93: #define DEBUG_XFERS 0x02
94: #define DEBUG_STATUS 0x04
95: #define DEBUG_FUNCS 0x08
96: #define DEBUG_PROBE 0x10
97:
98: #ifdef WDCDEBUG
99: #ifndef WDCDEBUG_WD_MASK
100: #define WDCDEBUG_WD_MASK 0x00
101: #endif
102: int wdcdebug_wd_mask = WDCDEBUG_WD_MASK;
103: #define WDCDEBUG_PRINT(args, level) do { \
104: if ((wdcdebug_wd_mask & (level)) != 0) \
105: printf args; \
106: } while (0)
107: #else
108: #define WDCDEBUG_PRINT(args, level)
109: #endif
110:
111: #define ATA_DELAY 10000 /* 10s for a drive I/O */
112:
113: struct cfdriver wdc_cd = {
114: NULL, "wdc", DV_DULL
115: };
116:
117: void wdc_ata_bio_start(struct channel_softc *, struct wdc_xfer *);
118: void _wdc_ata_bio_start(struct channel_softc *, struct wdc_xfer *);
119: int wdc_ata_bio_intr(struct channel_softc *, struct wdc_xfer *, int);
120: void wdc_ata_bio_kill_xfer(struct channel_softc *, struct wdc_xfer *);
121: void wdc_ata_bio_done(struct channel_softc *, struct wdc_xfer *);
122: int wdc_ata_ctrl_intr(struct channel_softc *, struct wdc_xfer *, int);
123: int wdc_ata_err(struct ata_drive_datas *, struct ata_bio *);
124: #define WDC_ATA_NOERR 0x00 /* Drive doesn't report an error */
125: #define WDC_ATA_RECOV 0x01 /* There was a recovered error */
126: #define WDC_ATA_ERR 0x02 /* Drive reports an error */
127:
128: /*
129: * Handle block I/O operation. Return WDC_COMPLETE, WDC_QUEUED, or
130: * WDC_TRY_AGAIN. Must be called at splbio().
131: */
132: int
133: wdc_ata_bio(struct ata_drive_datas *drvp, struct ata_bio *ata_bio)
134: {
135: struct wdc_xfer *xfer;
136: struct channel_softc *chp = drvp->chnl_softc;
137:
138: xfer = wdc_get_xfer(WDC_NOSLEEP);
139: if (xfer == NULL)
140: return WDC_TRY_AGAIN;
141: if (ata_bio->flags & ATA_POLL)
142: xfer->c_flags |= C_POLL;
143: if (!(ata_bio->flags & ATA_POLL) &&
144: (drvp->drive_flags & (DRIVE_DMA | DRIVE_UDMA)) &&
145: (ata_bio->flags & ATA_SINGLE) == 0 &&
146: (ata_bio->bcount > 512 ||
147: (chp->wdc->quirks & WDC_QUIRK_NOSHORTDMA) == 0))
148: xfer->c_flags |= C_DMA;
149: xfer->drive = drvp->drive;
150: xfer->cmd = ata_bio;
151: xfer->databuf = ata_bio->databuf;
152: xfer->c_bcount = ata_bio->bcount;
153: xfer->c_start = wdc_ata_bio_start;
154: xfer->c_intr = wdc_ata_bio_intr;
155: xfer->c_kill_xfer = wdc_ata_bio_kill_xfer;
156: wdc_exec_xfer(chp, xfer);
157: return (ata_bio->flags & ATA_ITSDONE) ? WDC_COMPLETE : WDC_QUEUED;
158: }
159:
160: void
161: wdc_ata_bio_start(struct channel_softc *chp, struct wdc_xfer *xfer)
162: {
163: struct ata_bio *ata_bio = xfer->cmd;
164: WDCDEBUG_PRINT(("wdc_ata_bio_start %s:%d:%d\n",
165: chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive),
166: DEBUG_XFERS);
167:
168: /* start timeout machinery */
169: if ((ata_bio->flags & ATA_POLL) == 0)
170: timeout_add(&chp->ch_timo, ATA_DELAY / 1000 * hz);
171: _wdc_ata_bio_start(chp, xfer);
172: }
173:
174: void
175: _wdc_ata_bio_start(struct channel_softc *chp, struct wdc_xfer *xfer)
176: {
177: struct ata_bio *ata_bio = xfer->cmd;
178: struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
179: u_int16_t cyl;
180: u_int8_t head, sect, cmd = 0;
181: int nblks;
182: int ata_delay;
183: int dma_flags = 0;
184:
185: WDCDEBUG_PRINT(("_wdc_ata_bio_start %s:%d:%d\n",
186: chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive),
187: DEBUG_INTR | DEBUG_XFERS);
188: /* Do control operations specially. */
189: if (drvp->state < READY) {
190: /*
191: * Actually, we want to be careful not to mess with the control
192: * state if the device is currently busy, but we can assume
193: * that we never get to this point if that's the case.
194: */
195: /* at this point, we should only be in RECAL state */
196: if (drvp->state != RECAL) {
197: printf("%s:%d:%d: bad state %d in _wdc_ata_bio_start\n",
198: chp->wdc->sc_dev.dv_xname, chp->channel,
199: xfer->drive, drvp->state);
200: panic("_wdc_ata_bio_start: bad state");
201: }
202: xfer->c_intr = wdc_ata_ctrl_intr;
203: wdc_set_drive(chp, xfer->drive);
204: if (wdcwait(chp, WDCS_DRDY, WDCS_DRDY, ATA_DELAY) != 0)
205: goto timeout;
206: wdccommandshort(chp, xfer->drive, WDCC_RECAL);
207: drvp->state = RECAL_WAIT;
208: if ((ata_bio->flags & ATA_POLL) == 0) {
209: chp->ch_flags |= WDCF_IRQ_WAIT;
210: } else {
211: /* Wait for at last 400ns for status bit to be valid */
212: DELAY(1);
213: wdc_ata_ctrl_intr(chp, xfer, 0);
214: }
215: return;
216: }
217:
218: if (xfer->c_flags & C_DMA) {
219: if (drvp->n_xfers <= NXFER)
220: drvp->n_xfers++;
221: dma_flags = (ata_bio->flags & ATA_READ) ? WDC_DMA_READ : 0;
222: if (ata_bio->flags & ATA_LBA48)
223: dma_flags |= WDC_DMA_LBA48;
224: }
225: if (ata_bio->flags & ATA_SINGLE)
226: ata_delay = ATA_DELAY;
227: else
228: ata_delay = ATA_DELAY;
229: again:
230: /*
231: *
232: * When starting a multi-sector transfer, or doing single-sector
233: * transfers...
234: */
235: if (xfer->c_skip == 0 || (ata_bio->flags & ATA_SINGLE) != 0) {
236: if (ata_bio->flags & ATA_SINGLE)
237: nblks = 1;
238: else
239: nblks = xfer->c_bcount / ata_bio->lp->d_secsize;
240: if (ata_bio->flags & ATA_LBA) {
241: sect = (ata_bio->blkno >> 0) & 0xff;
242: cyl = (ata_bio->blkno >> 8) & 0xffff;
243: head = (ata_bio->blkno >> 24) & 0x0f;
244: head |= WDSD_LBA;
245: } else {
246: int blkno = ata_bio->blkno;
247: sect = blkno % ata_bio->lp->d_nsectors;
248: sect++; /* Sectors begin with 1, not 0. */
249: blkno /= ata_bio->lp->d_nsectors;
250: head = blkno % ata_bio->lp->d_ntracks;
251: blkno /= ata_bio->lp->d_ntracks;
252: cyl = blkno;
253: head |= WDSD_CHS;
254: }
255: if (xfer->c_flags & C_DMA) {
256: ata_bio->nblks = nblks;
257: ata_bio->nbytes = xfer->c_bcount;
258: if (ata_bio->flags & ATA_LBA48)
259: cmd = (ata_bio->flags & ATA_READ) ?
260: WDCC_READDMA_EXT : WDCC_WRITEDMA_EXT;
261: else
262: cmd = (ata_bio->flags & ATA_READ) ?
263: WDCC_READDMA : WDCC_WRITEDMA;
264: /* Init the DMA channel. */
265: if ((*chp->wdc->dma_init)(chp->wdc->dma_arg,
266: chp->channel, xfer->drive,
267: (char *)xfer->databuf + xfer->c_skip,
268: ata_bio->nbytes, dma_flags) != 0) {
269: ata_bio->error = ERR_DMA;
270: ata_bio->r_error = 0;
271: wdc_ata_bio_done(chp, xfer);
272: return;
273: }
274: /* Initiate command */
275: wdc_set_drive(chp, xfer->drive);
276: if (wait_for_ready(chp, ata_delay) < 0)
277: goto timeout;
278: if (ata_bio->flags & ATA_LBA48) {
279: wdccommandext(chp, xfer->drive, cmd,
280: (u_int64_t)ata_bio->blkno, nblks);
281: } else {
282: wdccommand(chp, xfer->drive, cmd, cyl,
283: head, sect, nblks, 0);
284: }
285: /* start the DMA channel */
286: (*chp->wdc->dma_start)(chp->wdc->dma_arg,
287: chp->channel, xfer->drive);
288: chp->ch_flags |= WDCF_DMA_WAIT;
289: /* wait for irq */
290: goto intr;
291: } /* else not DMA */
292: ata_bio->nblks = min(nblks, ata_bio->multi);
293: ata_bio->nbytes = ata_bio->nblks * ata_bio->lp->d_secsize;
294: if (ata_bio->nblks > 1 && (ata_bio->flags & ATA_SINGLE) == 0) {
295: if (ata_bio->flags & ATA_LBA48)
296: cmd = (ata_bio->flags & ATA_READ) ?
297: WDCC_READMULTI_EXT : WDCC_WRITEMULTI_EXT;
298: else
299: cmd = (ata_bio->flags & ATA_READ) ?
300: WDCC_READMULTI : WDCC_WRITEMULTI;
301: } else {
302: if (ata_bio->flags & ATA_LBA48)
303: cmd = (ata_bio->flags & ATA_READ) ?
304: WDCC_READ_EXT : WDCC_WRITE_EXT;
305: else
306: cmd = (ata_bio->flags & ATA_READ) ?
307: WDCC_READ : WDCC_WRITE;
308: }
309: /* Initiate command! */
310: wdc_set_drive(chp, xfer->drive);
311: if (wait_for_ready(chp, ata_delay) < 0)
312: goto timeout;
313: if (ata_bio->flags & ATA_LBA48) {
314: wdccommandext(chp, xfer->drive, cmd,
315: (u_int64_t)ata_bio->blkno, nblks);
316: } else {
317: wdccommand(chp, xfer->drive, cmd, cyl,
318: head, sect, nblks,
319: (ata_bio->lp->d_type == DTYPE_ST506) ?
320: ata_bio->lp->d_precompcyl / 4 : 0);
321: }
322: } else if (ata_bio->nblks > 1) {
323: /* The number of blocks in the last stretch may be smaller. */
324: nblks = xfer->c_bcount / ata_bio->lp->d_secsize;
325: if (ata_bio->nblks > nblks) {
326: ata_bio->nblks = nblks;
327: ata_bio->nbytes = xfer->c_bcount;
328: }
329: }
330: /* If this was a write and not using DMA, push the data. */
331: if ((ata_bio->flags & ATA_READ) == 0) {
332: if (wait_for_drq(chp, ata_delay) != 0) {
333: printf("%s:%d:%d: timeout waiting for DRQ, "
334: "st=0x%b, err=0x%02x\n",
335: chp->wdc->sc_dev.dv_xname, chp->channel,
336: xfer->drive, chp->ch_status, WDCS_BITS,
337: chp->ch_error);
338: if (wdc_ata_err(drvp, ata_bio) != WDC_ATA_ERR)
339: ata_bio->error = TIMEOUT;
340: wdc_ata_bio_done(chp, xfer);
341: return;
342: }
343: if (wdc_ata_err(drvp, ata_bio) == WDC_ATA_ERR) {
344: wdc_ata_bio_done(chp, xfer);
345: return;
346: }
347: wdc_output_bytes(drvp, (char *)xfer->databuf + xfer->c_skip,
348: ata_bio->nbytes);
349: }
350:
351: intr: /* Wait for IRQ (either real or polled) */
352: if ((ata_bio->flags & ATA_POLL) == 0) {
353: chp->ch_flags |= WDCF_IRQ_WAIT;
354: } else {
355: /* Wait for at last 400ns for status bit to be valid */
356: delay(1);
357: if (chp->ch_flags & WDCF_DMA_WAIT) {
358: wdc_dmawait(chp, xfer, ATA_DELAY);
359: chp->ch_flags &= ~WDCF_DMA_WAIT;
360: }
361: wdc_ata_bio_intr(chp, xfer, 0);
362: if ((ata_bio->flags & ATA_ITSDONE) == 0)
363: goto again;
364: }
365: return;
366: timeout:
367: printf("%s:%d:%d: not ready, st=0x%b, err=0x%02x\n",
368: chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive,
369: chp->ch_status, WDCS_BITS, chp->ch_error);
370: if (wdc_ata_err(drvp, ata_bio) != WDC_ATA_ERR)
371: ata_bio->error = TIMEOUT;
372: wdc_ata_bio_done(chp, xfer);
373: return;
374: }
375:
376: int
377: wdc_ata_bio_intr(struct channel_softc *chp, struct wdc_xfer *xfer, int irq)
378: {
379: struct ata_bio *ata_bio = xfer->cmd;
380: struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
381: int drv_err;
382:
383: WDCDEBUG_PRINT(("wdc_ata_bio_intr %s:%d:%d\n",
384: chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive),
385: DEBUG_INTR | DEBUG_XFERS);
386:
387:
388: /* Is it not a transfer, but a control operation? */
389: if (drvp->state < READY) {
390: printf("%s:%d:%d: bad state %d in wdc_ata_bio_intr\n",
391: chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive,
392: drvp->state);
393: panic("wdc_ata_bio_intr: bad state");
394: }
395:
396: /*
397: * reset on timeout. This will cause extra resets in the case
398: * of occasional lost interrupts
399: */
400: if (xfer->c_flags & C_TIMEOU)
401: goto timeout;
402:
403: /* Ack interrupt done by wait_for_unbusy */
404: if (wait_for_unbusy(chp,
405: (irq == 0) ? ATA_DELAY : 0) < 0) {
406: if (irq)
407: return 0; /* IRQ was not for us */
408: printf("%s:%d:%d: device timeout, c_bcount=%d, c_skip%d\n",
409: chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive,
410: xfer->c_bcount, xfer->c_skip);
411:
412: goto timeout;
413: }
414: if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
415: chp->wdc->irqack(chp);
416:
417: drv_err = wdc_ata_err(drvp, ata_bio);
418:
419: if (xfer->c_flags & C_DMA) {
420: if (chp->wdc->dma_status != 0) {
421: if (drv_err != WDC_ATA_ERR) {
422: ata_bio->error = ERR_DMA;
423: drv_err = WDC_ATA_ERR;
424: }
425: }
426: if (chp->ch_status & WDCS_DRQ) {
427: if (drv_err != WDC_ATA_ERR) {
428: printf("%s:%d:%d: intr with DRQ (st=0x%b)\n",
429: chp->wdc->sc_dev.dv_xname, chp->channel,
430: xfer->drive, chp->ch_status, WDCS_BITS);
431: ata_bio->error = TIMEOUT;
432: drv_err = WDC_ATA_ERR;
433: }
434: }
435: if (drv_err != WDC_ATA_ERR)
436: goto end;
437: ata_dmaerr(drvp);
438: }
439:
440: /* if we had an error, end */
441: if (drv_err == WDC_ATA_ERR) {
442: wdc_ata_bio_done(chp, xfer);
443: return 1;
444: }
445:
446: /* If this was a read and not using DMA, fetch the data. */
447: if ((ata_bio->flags & ATA_READ) != 0) {
448: if ((chp->ch_status & WDCS_DRQ) != WDCS_DRQ) {
449: printf("%s:%d:%d: read intr before drq\n",
450: chp->wdc->sc_dev.dv_xname, chp->channel,
451: xfer->drive);
452: ata_bio->error = TIMEOUT;
453: wdc_ata_bio_done(chp, xfer);
454: return 1;
455: }
456: wdc_input_bytes(drvp, (char *)xfer->databuf + xfer->c_skip,
457: ata_bio->nbytes);
458: }
459: end:
460: ata_bio->blkno += ata_bio->nblks;
461: ata_bio->blkdone += ata_bio->nblks;
462: xfer->c_skip += ata_bio->nbytes;
463: xfer->c_bcount -= ata_bio->nbytes;
464: /* See if this transfer is complete. */
465: if (xfer->c_bcount > 0) {
466: if ((ata_bio->flags & ATA_POLL) == 0) {
467: /* Start the next operation */
468: _wdc_ata_bio_start(chp, xfer);
469: } else {
470: /* Let _wdc_ata_bio_start do the loop */
471: return 1;
472: }
473: } else { /* Done with this transfer */
474: ata_bio->error = NOERROR;
475: wdc_ata_bio_done(chp, xfer);
476: }
477: return 1;
478:
479: timeout:
480: if (xfer->c_flags & C_DMA)
481: ata_dmaerr(drvp);
482:
483: ata_bio->error = TIMEOUT;
484: wdc_ata_bio_done(chp, xfer);
485: return 1;
486: }
487:
488: void
489: wdc_ata_bio_kill_xfer(struct channel_softc *chp, struct wdc_xfer *xfer)
490: {
491: struct ata_bio *ata_bio = xfer->cmd;
492:
493: timeout_del(&chp->ch_timo);
494: /* remove this command from xfer queue */
495: wdc_free_xfer(chp, xfer);
496:
497: ata_bio->flags |= ATA_ITSDONE;
498: ata_bio->error = ERR_NODEV;
499: ata_bio->r_error = WDCE_ABRT;
500: if ((ata_bio->flags & ATA_POLL) == 0) {
501: WDCDEBUG_PRINT(("wdc_ata_done: wddone\n"), DEBUG_XFERS);
502: wddone(ata_bio->wd);
503: }
504: }
505:
506: void
507: wdc_ata_bio_done(struct channel_softc *chp, struct wdc_xfer *xfer)
508: {
509: struct ata_bio *ata_bio = xfer->cmd;
510:
511: WDCDEBUG_PRINT(("wdc_ata_bio_done %s:%d:%d: flags 0x%x\n",
512: chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive,
513: (u_int)xfer->c_flags),
514: DEBUG_XFERS);
515:
516: timeout_del(&chp->ch_timo);
517:
518: /* feed back residual bcount to our caller */
519: ata_bio->bcount = xfer->c_bcount;
520:
521: /* remove this command from xfer queue */
522: wdc_free_xfer(chp, xfer);
523:
524: ata_bio->flags |= ATA_ITSDONE;
525: if ((ata_bio->flags & ATA_POLL) == 0) {
526: WDCDEBUG_PRINT(("wdc_ata_done: wddone\n"), DEBUG_XFERS);
527: wddone(ata_bio->wd);
528: }
529: WDCDEBUG_PRINT(("wdcstart from wdc_ata_done, flags 0x%x\n",
530: chp->ch_flags), DEBUG_XFERS);
531: wdcstart(chp);
532: }
533:
534: /*
535: * Implement operations needed before read/write.
536: */
537: int
538: wdc_ata_ctrl_intr(struct channel_softc *chp, struct wdc_xfer *xfer, int irq)
539: {
540: struct ata_bio *ata_bio = xfer->cmd;
541: struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
542: char *errstring = NULL;
543: int delay = (irq == 0) ? ATA_DELAY : 0;
544:
545: WDCDEBUG_PRINT(("wdc_ata_ctrl_intr: state %d\n", drvp->state),
546: DEBUG_FUNCS);
547:
548: again:
549: switch (drvp->state) {
550: case RECAL: /* Should not be in this state here */
551: panic("wdc_ata_ctrl_intr: state==RECAL");
552: break;
553:
554: case RECAL_WAIT:
555: errstring = "recal";
556: if (wdcwait(chp, WDCS_DRDY, WDCS_DRDY, delay))
557: goto timeout;
558: if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
559: chp->wdc->irqack(chp);
560: if (chp->ch_status & (WDCS_ERR | WDCS_DWF))
561: goto error;
562: /* FALLTHROUGH */
563:
564: case PIOMODE:
565: /* Don't try to set modes if controller can't be adjusted */
566: if ((chp->wdc->cap & WDC_CAPABILITY_MODE) == 0)
567: goto geometry;
568: /* Also don't try if the drive didn't report its mode */
569: if ((drvp->drive_flags & DRIVE_MODE) == 0)
570: goto geometry;
571: /* SET FEATURES 0x08 is only for PIO mode > 2 */
572: if (drvp->PIO_mode <= 2)
573: goto geometry;
574: wdccommand(chp, drvp->drive, SET_FEATURES, 0, 0, 0,
575: 0x08 | drvp->PIO_mode, WDSF_SET_MODE);
576: drvp->state = PIOMODE_WAIT;
577: break;
578:
579: case PIOMODE_WAIT:
580: errstring = "piomode";
581: if (wdcwait(chp, WDCS_DRDY, WDCS_DRDY, delay))
582: goto timeout;
583: if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
584: chp->wdc->irqack(chp);
585: if (chp->ch_status & (WDCS_ERR | WDCS_DWF))
586: goto error;
587: /* FALLTHROUGH */
588:
589: case DMAMODE:
590: if (drvp->drive_flags & DRIVE_UDMA) {
591: wdccommand(chp, drvp->drive, SET_FEATURES, 0, 0, 0,
592: 0x40 | drvp->UDMA_mode, WDSF_SET_MODE);
593: } else if (drvp->drive_flags & DRIVE_DMA) {
594: wdccommand(chp, drvp->drive, SET_FEATURES, 0, 0, 0,
595: 0x20 | drvp->DMA_mode, WDSF_SET_MODE);
596: } else {
597: goto geometry;
598: }
599: drvp->state = DMAMODE_WAIT;
600: break;
601: case DMAMODE_WAIT:
602: errstring = "dmamode";
603: if (wdcwait(chp, WDCS_DRDY, WDCS_DRDY, delay))
604: goto timeout;
605: if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
606: chp->wdc->irqack(chp);
607: if (chp->ch_status & (WDCS_ERR | WDCS_DWF))
608: goto error;
609: /* FALLTHROUGH */
610:
611: case GEOMETRY:
612: geometry:
613: if (ata_bio->flags & ATA_LBA)
614: goto multimode;
615: wdccommand(chp, xfer->drive, WDCC_IDP,
616: ata_bio->lp->d_ncylinders,
617: ata_bio->lp->d_ntracks - 1, 0, ata_bio->lp->d_nsectors,
618: (ata_bio->lp->d_type == DTYPE_ST506) ?
619: ata_bio->lp->d_precompcyl / 4 : 0);
620: drvp->state = GEOMETRY_WAIT;
621: break;
622:
623: case GEOMETRY_WAIT:
624: errstring = "geometry";
625: if (wdcwait(chp, WDCS_DRDY, WDCS_DRDY, delay))
626: goto timeout;
627: if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
628: chp->wdc->irqack(chp);
629: if (chp->ch_status & (WDCS_ERR | WDCS_DWF))
630: goto error;
631: /* FALLTHROUGH */
632:
633: case MULTIMODE:
634: multimode:
635: if (ata_bio->multi == 1)
636: goto ready;
637: wdccommand(chp, xfer->drive, WDCC_SETMULTI, 0, 0, 0,
638: ata_bio->multi, 0);
639: drvp->state = MULTIMODE_WAIT;
640: break;
641:
642: case MULTIMODE_WAIT:
643: errstring = "setmulti";
644: if (wdcwait(chp, WDCS_DRDY, WDCS_DRDY, delay))
645: goto timeout;
646: if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
647: chp->wdc->irqack(chp);
648: if (chp->ch_status & (WDCS_ERR | WDCS_DWF))
649: goto error;
650: /* FALLTHROUGH */
651:
652: case READY:
653: ready:
654: drvp->state = READY;
655: /*
656: * The drive is usable now
657: */
658: xfer->c_intr = wdc_ata_bio_intr;
659: _wdc_ata_bio_start(chp, xfer);
660: return 1;
661: }
662:
663: if ((ata_bio->flags & ATA_POLL) == 0) {
664: chp->ch_flags |= WDCF_IRQ_WAIT;
665: } else {
666: goto again;
667: }
668: return 1;
669:
670: timeout:
671: if (irq && (xfer->c_flags & C_TIMEOU) == 0) {
672: return 0; /* IRQ was not for us */
673: }
674: printf("%s:%d:%d: %s timed out\n",
675: chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive, errstring);
676: ata_bio->error = TIMEOUT;
677: drvp->state = 0;
678: wdc_ata_bio_done(chp, xfer);
679: return 0;
680: error:
681: printf("%s:%d:%d: %s ",
682: chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive,
683: errstring);
684: if (chp->ch_status & WDCS_DWF) {
685: printf("drive fault\n");
686: ata_bio->error = ERR_DF;
687: } else {
688: printf("error (%x)\n", chp->ch_error);
689: ata_bio->r_error = chp->ch_error;
690: ata_bio->error = ERROR;
691: }
692: drvp->state = 0;
693: wdc_ata_bio_done(chp, xfer);
694: return 1;
695: }
696:
697: int
698: wdc_ata_err(struct ata_drive_datas *drvp, struct ata_bio *ata_bio)
699: {
700: struct channel_softc *chp = drvp->chnl_softc;
701: ata_bio->error = 0;
702: if (chp->ch_status & WDCS_BSY) {
703: ata_bio->error = TIMEOUT;
704: return WDC_ATA_ERR;
705: }
706:
707: if (chp->ch_status & WDCS_DWF) {
708: ata_bio->error = ERR_DF;
709: return WDC_ATA_ERR;
710: }
711:
712: if (chp->ch_status & WDCS_ERR) {
713: ata_bio->error = ERROR;
714: ata_bio->r_error = chp->ch_error;
715: if (drvp->drive_flags & DRIVE_UDMA &&
716: (ata_bio->r_error & WDCE_CRC)) {
717: /*
718: * Record the CRC error, to avoid downgrading to
719: * multiword DMA
720: */
721: drvp->drive_flags |= DRIVE_DMAERR;
722: }
723: if (ata_bio->r_error & (WDCE_BBK | WDCE_UNC | WDCE_IDNF |
724: WDCE_ABRT | WDCE_TK0NF | WDCE_AMNF))
725: return WDC_ATA_ERR;
726: return WDC_ATA_NOERR;
727: }
728:
729: if (chp->ch_status & WDCS_CORR)
730: ata_bio->flags |= ATA_CORR;
731: return WDC_ATA_NOERR;
732: }
733:
734: #if 0
735: int
736: wdc_ata_addref(drvp)
737: struct ata_drive_datas *drvp;
738: {
739: struct channel_softc *chp = drvp->chnl_softc;
740:
741: return (wdc_addref(chp));
742: }
743:
744: void
745: wdc_ata_delref(drvp)
746: struct ata_drive_datas *drvp;
747: {
748: struct channel_softc *chp = drvp->chnl_softc;
749:
750: wdc_delref(chp);
751: }
752: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ata_wdc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ata