Annotation of sys/dev/atapiscsi/atapiscsi.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: atapiscsi.c,v 1.78 2007/08/06 08:28:09 tom Exp $ */
! 2:
! 3: /*
! 4: * This code is derived from code with the copyright below.
! 5: */
! 6:
! 7: /*
! 8: * Copyright (c) 1996, 1998 Manuel Bouyer.
! 9: *
! 10: * Redistribution and use in source and binary forms, with or without
! 11: * modification, are permitted provided that the following conditions
! 12: * are met:
! 13: * 1. Redistributions of source code must retain the above copyright
! 14: * notice, this list of conditions and the following disclaimer.
! 15: * 2. Redistributions in binary form must reproduce the above copyright
! 16: * notice, this list of conditions and the following disclaimer in the
! 17: * documentation and/or other materials provided with the distribution.
! 18: * 3. All advertising materials mentioning features or use of this software
! 19: * must display the following acknowledgement:
! 20: * This product includes software developed by Manuel Bouyer.
! 21: * 4. Neither the name of the University nor the names of its contributors
! 22: * may be used to endorse or promote products derived from this software
! 23: * without specific prior written permission.
! 24: *
! 25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 35: * SUCH DAMAGE.
! 36: *
! 37: */
! 38:
! 39:
! 40: #include <sys/param.h>
! 41: #include <sys/systm.h>
! 42: #include <sys/kernel.h>
! 43: #include <sys/device.h>
! 44: #include <sys/buf.h>
! 45: #include <sys/dkstat.h>
! 46: #include <sys/disklabel.h>
! 47: #include <sys/dkstat.h>
! 48: #include <sys/malloc.h>
! 49: #include <sys/proc.h>
! 50: #include <sys/reboot.h>
! 51: #include <sys/file.h>
! 52: #include <sys/ioctl.h>
! 53: #include <sys/timeout.h>
! 54: #include <scsi/scsi_all.h>
! 55: #include <scsi/scsi_disk.h>
! 56: #include <scsi/scsi_tape.h>
! 57: #include <scsi/scsiconf.h>
! 58:
! 59: #include <machine/bus.h>
! 60: #include <machine/cpu.h>
! 61: #include <machine/intr.h>
! 62:
! 63: #include <dev/ata/atareg.h>
! 64: #include <dev/ata/atavar.h>
! 65: #include <dev/ic/wdcreg.h>
! 66: #include <dev/ic/wdcvar.h>
! 67: #include <dev/ic/wdcevent.h>
! 68:
! 69: /* drive states stored in ata_drive_datas */
! 70: enum atapi_drive_states {
! 71: ATAPI_RESET_BASE_STATE = 0,
! 72: ATAPI_DEVICE_RESET_WAIT_STATE = 1,
! 73: ATAPI_IDENTIFY_STATE = 2,
! 74: ATAPI_IDENTIFY_WAIT_STATE = 3,
! 75: ATAPI_PIOMODE_STATE = 4,
! 76: ATAPI_PIOMODE_WAIT_STATE = 5,
! 77: ATAPI_DMAMODE_STATE = 6,
! 78: ATAPI_DMAMODE_WAIT_STATE = 7,
! 79: ATAPI_READY_STATE = 8
! 80: };
! 81:
! 82: #define DEBUG_INTR 0x01
! 83: #define DEBUG_XFERS 0x02
! 84: #define DEBUG_STATUS 0x04
! 85: #define DEBUG_FUNCS 0x08
! 86: #define DEBUG_PROBE 0x10
! 87: #define DEBUG_DSC 0x20
! 88: #define DEBUG_POLL 0x40
! 89: #define DEBUG_ERRORS 0x80 /* Debug error handling code */
! 90:
! 91: #if defined(WDCDEBUG)
! 92: #ifndef WDCDEBUG_ATAPI_MASK
! 93: #define WDCDEBUG_ATAPI_MASK 0x00
! 94: #endif
! 95: int wdcdebug_atapi_mask = WDCDEBUG_ATAPI_MASK;
! 96: #define WDCDEBUG_PRINT(args, level) do { \
! 97: if ((wdcdebug_atapi_mask & (level)) != 0) \
! 98: printf args; \
! 99: } while (0)
! 100: #else
! 101: #define WDCDEBUG_PRINT(args, level)
! 102: #endif
! 103:
! 104: /* 10 ms, this is used only before sending a cmd. */
! 105: #define ATAPI_DELAY 10
! 106: #define ATAPI_RESET_DELAY 1000
! 107: #define ATAPI_RESET_WAIT 2000
! 108: #define ATAPI_CTRL_WAIT 4000
! 109:
! 110: /* When polling, let the exponential backoff max out at 1 second's interval. */
! 111: #define ATAPI_POLL_MAXTIC (hz)
! 112:
! 113: void wdc_atapi_start(struct channel_softc *,struct wdc_xfer *);
! 114:
! 115: void wdc_atapi_timer_handler(void *);
! 116:
! 117: void wdc_atapi_real_start(struct channel_softc *, struct wdc_xfer *,
! 118: int, struct atapi_return_args *);
! 119: void wdc_atapi_real_start_2(struct channel_softc *, struct wdc_xfer *,
! 120: int, struct atapi_return_args *);
! 121: void wdc_atapi_intr_command(struct channel_softc *, struct wdc_xfer *,
! 122: int, struct atapi_return_args *);
! 123: void wdc_atapi_intr_data(struct channel_softc *, struct wdc_xfer *,
! 124: int, struct atapi_return_args *);
! 125: void wdc_atapi_intr_complete(struct channel_softc *, struct wdc_xfer *,
! 126: int, struct atapi_return_args *);
! 127: void wdc_atapi_pio_intr(struct channel_softc *, struct wdc_xfer *,
! 128: int, struct atapi_return_args *);
! 129: void wdc_atapi_send_packet(struct channel_softc *, struct wdc_xfer *,
! 130: int, struct atapi_return_args *);
! 131: void wdc_atapi_ctrl(struct channel_softc *, struct wdc_xfer *,
! 132: int, struct atapi_return_args *);
! 133:
! 134: char *wdc_atapi_in_data_phase(struct wdc_xfer *, int, int);
! 135:
! 136: int wdc_atapi_intr(struct channel_softc *, struct wdc_xfer *, int);
! 137: void wdc_atapi_done(struct channel_softc *, struct wdc_xfer *,
! 138: int, struct atapi_return_args *);
! 139: void wdc_atapi_reset(struct channel_softc *, struct wdc_xfer *,
! 140: int, struct atapi_return_args *);
! 141: void wdc_atapi_reset_2(struct channel_softc *, struct wdc_xfer *,
! 142: int, struct atapi_return_args *);
! 143:
! 144: void wdc_atapi_tape_done(struct channel_softc *, struct wdc_xfer *,
! 145: int, struct atapi_return_args *);
! 146: #define MAX_SIZE MAXPHYS
! 147:
! 148: struct atapiscsi_softc;
! 149: struct atapiscsi_xfer;
! 150:
! 151: int atapiscsi_match(struct device *, void *, void *);
! 152: void atapiscsi_attach(struct device *, struct device *, void *);
! 153: int atapiscsi_detach(struct device *, int);
! 154: int atapi_to_scsi_sense(struct scsi_xfer *, u_int8_t);
! 155:
! 156: enum atapi_state { as_none, as_data, as_completed };
! 157:
! 158: struct atapiscsi_softc {
! 159: struct device sc_dev;
! 160: struct scsi_link sc_adapterlink;
! 161: struct channel_softc *chp;
! 162: enum atapi_state protocol_phase;
! 163:
! 164: int drive;
! 165: };
! 166:
! 167: void wdc_atapi_minphys(struct buf *bp);
! 168: int wdc_atapi_ioctl(struct scsi_link *,
! 169: u_long, caddr_t, int, struct proc *);
! 170: int wdc_atapi_send_cmd(struct scsi_xfer *sc_xfer);
! 171:
! 172: static struct scsi_adapter atapiscsi_switch =
! 173: {
! 174: wdc_atapi_send_cmd,
! 175: wdc_atapi_minphys,
! 176: NULL,
! 177: NULL,
! 178: wdc_atapi_ioctl
! 179: };
! 180:
! 181: static struct scsi_device atapiscsi_dev =
! 182: {
! 183: NULL,
! 184: NULL,
! 185: NULL,
! 186: NULL,
! 187: };
! 188:
! 189: /* Inital version shares bus_link structure so it can easily
! 190: be "attached to current" wdc driver */
! 191:
! 192: struct cfattach atapiscsi_ca = {
! 193: sizeof(struct atapiscsi_softc), atapiscsi_match, atapiscsi_attach,
! 194: atapiscsi_detach
! 195: };
! 196:
! 197: struct cfdriver atapiscsi_cd = {
! 198: NULL, "atapiscsi", DV_DULL
! 199: };
! 200:
! 201:
! 202: int
! 203: atapiscsi_match(parent, match, aux)
! 204: struct device *parent;
! 205: void *match, *aux;
! 206:
! 207: {
! 208: struct ata_atapi_attach *aa_link = aux;
! 209: struct cfdata *cf = match;
! 210:
! 211: if (aa_link == NULL)
! 212: return (0);
! 213:
! 214: if (aa_link->aa_type != T_ATAPI)
! 215: return (0);
! 216:
! 217: if (cf->cf_loc[0] != aa_link->aa_channel &&
! 218: cf->cf_loc[0] != -1)
! 219: return (0);
! 220:
! 221: return (1);
! 222: }
! 223:
! 224: void
! 225: atapiscsi_attach(parent, self, aux)
! 226: struct device *parent, *self;
! 227: void *aux;
! 228: {
! 229: struct atapiscsi_softc *as = (struct atapiscsi_softc *)self;
! 230: struct ata_atapi_attach *aa_link = aux;
! 231: struct scsibus_attach_args saa;
! 232: struct ata_drive_datas *drvp = aa_link->aa_drv_data;
! 233: struct channel_softc *chp = drvp->chnl_softc;
! 234: struct ataparams *id = &drvp->id;
! 235: struct device *child;
! 236:
! 237: printf("\n");
! 238:
! 239: /* Initialize shared data. */
! 240: scsi_init();
! 241:
! 242: #ifdef WDCDEBUG
! 243: if (chp->wdc->sc_dev.dv_cfdata->cf_flags & WDC_OPTION_PROBE_VERBOSE)
! 244: wdcdebug_atapi_mask |= DEBUG_PROBE;
! 245: #endif
! 246:
! 247: as->chp = chp;
! 248: as->drive = drvp->drive;
! 249: as->sc_adapterlink.adapter_softc = as;
! 250: as->sc_adapterlink.adapter_target = 7;
! 251: as->sc_adapterlink.adapter_buswidth = 2;
! 252: as->sc_adapterlink.adapter = &atapiscsi_switch;
! 253: as->sc_adapterlink.device = &atapiscsi_dev;
! 254: as->sc_adapterlink.luns = 1;
! 255: as->sc_adapterlink.openings = 1;
! 256: as->sc_adapterlink.flags = SDEV_ATAPI;
! 257:
! 258: strlcpy(drvp->drive_name, as->sc_dev.dv_xname,
! 259: sizeof(drvp->drive_name));
! 260: drvp->cf_flags = as->sc_dev.dv_cfdata->cf_flags;
! 261:
! 262: wdc_probe_caps(drvp, id);
! 263:
! 264: WDCDEBUG_PRINT(
! 265: ("general config %04x capabilities %04x ",
! 266: id->atap_config, id->atap_capabilities1),
! 267: DEBUG_PROBE);
! 268:
! 269: if ((NERRS_MAX - 2) > 0)
! 270: drvp->n_dmaerrs = NERRS_MAX - 2;
! 271: else
! 272: drvp->n_dmaerrs = 0;
! 273: drvp->drive_flags |= DRIVE_DEVICE_RESET;
! 274:
! 275: /* Tape drives do funny DSC stuff */
! 276: if (ATAPI_CFG_TYPE(id->atap_config) ==
! 277: ATAPI_CFG_TYPE_SEQUENTIAL)
! 278: drvp->atapi_cap |= ACAP_DSC;
! 279:
! 280: if ((id->atap_config & ATAPI_CFG_CMD_MASK) ==
! 281: ATAPI_CFG_CMD_16)
! 282: drvp->atapi_cap |= ACAP_LEN;
! 283:
! 284: drvp->atapi_cap |=
! 285: (id->atap_config & ATAPI_CFG_DRQ_MASK);
! 286:
! 287: WDCDEBUG_PRINT(("driver caps %04x\n", drvp->atapi_cap),
! 288: DEBUG_PROBE);
! 289:
! 290: bzero(&saa, sizeof(saa));
! 291: saa.saa_sc_link = &as->sc_adapterlink;
! 292:
! 293: child = config_found((struct device *)as, &saa, scsiprint);
! 294:
! 295: if (child != NULL) {
! 296: struct scsibus_softc *scsi = (struct scsibus_softc *)child;
! 297: struct scsi_link *link = scsi->sc_link[0][0];
! 298:
! 299: if (link) {
! 300: strlcpy(drvp->drive_name,
! 301: ((struct device *)(link->device_softc))->dv_xname,
! 302: sizeof(drvp->drive_name));
! 303:
! 304: wdc_print_caps(drvp);
! 305: }
! 306: }
! 307:
! 308: #ifdef WDCDEBUG
! 309: if (chp->wdc->sc_dev.dv_cfdata->cf_flags & WDC_OPTION_PROBE_VERBOSE)
! 310: wdcdebug_atapi_mask &= ~DEBUG_PROBE;
! 311: #endif
! 312: }
! 313:
! 314: int
! 315: atapiscsi_detach(dev, flags)
! 316: struct device *dev;
! 317: int flags;
! 318: {
! 319: return (config_detach_children(dev, flags));
! 320: }
! 321:
! 322: int
! 323: wdc_atapi_send_cmd(sc_xfer)
! 324: struct scsi_xfer *sc_xfer;
! 325: {
! 326: struct atapiscsi_softc *as = sc_xfer->sc_link->adapter_softc;
! 327: struct channel_softc *chp = as->chp;
! 328: struct ata_drive_datas *drvp = &chp->ch_drive[as->drive];
! 329: struct wdc_xfer *xfer;
! 330: int s, ret;
! 331: int idx;
! 332:
! 333: WDCDEBUG_PRINT(("wdc_atapi_send_cmd %s:%d:%d start\n",
! 334: chp->wdc->sc_dev.dv_xname, chp->channel, as->drive), DEBUG_XFERS);
! 335:
! 336: if (sc_xfer->sc_link->target != 0) {
! 337: sc_xfer->error = XS_DRIVER_STUFFUP;
! 338: return (COMPLETE);
! 339: }
! 340:
! 341: xfer = wdc_get_xfer(sc_xfer->flags & SCSI_NOSLEEP
! 342: ? WDC_NOSLEEP : WDC_CANSLEEP);
! 343: if (xfer == NULL) {
! 344: return (TRY_AGAIN_LATER);
! 345: }
! 346: if (sc_xfer->flags & SCSI_POLL)
! 347: xfer->c_flags |= C_POLL;
! 348: xfer->drive = as->drive;
! 349: xfer->c_flags |= C_ATAPI;
! 350: xfer->cmd = sc_xfer;
! 351: xfer->databuf = sc_xfer->data;
! 352: xfer->c_bcount = sc_xfer->datalen;
! 353: xfer->c_start = wdc_atapi_start;
! 354: xfer->c_intr = wdc_atapi_intr;
! 355:
! 356: timeout_set(&xfer->atapi_poll_to, wdc_atapi_timer_handler, chp);
! 357:
! 358: WDCDEBUG_PRINT(("wdc_atapi_send_cmd %s:%d:%d ",
! 359: chp->wdc->sc_dev.dv_xname, chp->channel, as->drive),
! 360: DEBUG_XFERS | DEBUG_ERRORS);
! 361:
! 362: for (idx = 0; idx < sc_xfer->cmdlen; idx++) {
! 363: WDCDEBUG_PRINT((" %02x",
! 364: ((unsigned char *)sc_xfer->cmd)[idx]),
! 365: DEBUG_XFERS | DEBUG_ERRORS);
! 366: }
! 367: WDCDEBUG_PRINT(("\n"), DEBUG_XFERS | DEBUG_ERRORS);
! 368:
! 369: s = splbio();
! 370:
! 371: if (drvp->atapi_cap & ACAP_DSC) {
! 372: WDCDEBUG_PRINT(("about to send cmd 0x%x ",
! 373: sc_xfer->cmd->opcode), DEBUG_DSC);
! 374: switch (sc_xfer->cmd->opcode) {
! 375: case READ:
! 376: case WRITE:
! 377: xfer->c_flags |= C_MEDIA_ACCESS;
! 378:
! 379: /* If we are not in buffer availability mode,
! 380: we limit the first request to 0 bytes, which
! 381: gets us into buffer availability mode without
! 382: holding the bus. */
! 383: if (!(drvp->drive_flags & DRIVE_DSCBA)) {
! 384: xfer->c_bcount = 0;
! 385: xfer->transfer_len =
! 386: _3btol(((struct scsi_rw_tape *)
! 387: sc_xfer->cmd)->len);
! 388: _lto3b(0,
! 389: ((struct scsi_rw_tape *)
! 390: sc_xfer->cmd)->len);
! 391: xfer->c_done = wdc_atapi_tape_done;
! 392: WDCDEBUG_PRINT(
! 393: ("R/W in completion mode, do 0 blocks\n"),
! 394: DEBUG_DSC);
! 395: } else
! 396: WDCDEBUG_PRINT(("R/W %d blocks %d bytes\n",
! 397: _3btol(((struct scsi_rw_tape *)
! 398: sc_xfer->cmd)->len),
! 399: sc_xfer->datalen),
! 400: DEBUG_DSC);
! 401:
! 402: /* DSC will change to buffer availability mode.
! 403: We reflect this in wdc_atapi_intr. */
! 404: break;
! 405:
! 406: case ERASE: /* Media access commands */
! 407: case LOAD:
! 408: case REWIND:
! 409: case SPACE:
! 410: case WRITE_FILEMARKS:
! 411: #if 0
! 412: case LOCATE:
! 413: case READ_POSITION:
! 414: #endif
! 415:
! 416: xfer->c_flags |= C_MEDIA_ACCESS;
! 417: break;
! 418:
! 419: default:
! 420: WDCDEBUG_PRINT(("no media access\n"), DEBUG_DSC);
! 421: }
! 422: }
! 423:
! 424: wdc_exec_xfer(chp, xfer);
! 425: #ifdef DIAGNOSTIC
! 426: if ((xfer->c_flags & C_POLL) != 0 &&
! 427: (sc_xfer->flags & ITSDONE) == 0)
! 428: panic("wdc_atapi_send_cmd: polled command not done");
! 429: #endif
! 430: ret = (sc_xfer->flags & ITSDONE) ? COMPLETE : SUCCESSFULLY_QUEUED;
! 431: splx(s);
! 432: return (ret);
! 433: }
! 434:
! 435: void
! 436: wdc_atapi_minphys (struct buf *bp)
! 437: {
! 438: if(bp->b_bcount > MAX_SIZE)
! 439: bp->b_bcount = MAX_SIZE;
! 440: minphys(bp);
! 441: }
! 442:
! 443: int
! 444: wdc_atapi_ioctl (sc_link, cmd, addr, flag, p)
! 445: struct scsi_link *sc_link;
! 446: u_long cmd;
! 447: caddr_t addr;
! 448: int flag;
! 449: struct proc *p;
! 450: {
! 451: struct atapiscsi_softc *as = sc_link->adapter_softc;
! 452: struct channel_softc *chp = as->chp;
! 453: struct ata_drive_datas *drvp = &chp->ch_drive[as->drive];
! 454:
! 455: if (sc_link->target != 0)
! 456: return ENOTTY;
! 457:
! 458: return (wdc_ioctl(drvp, cmd, addr, flag, p));
! 459: }
! 460:
! 461:
! 462: /*
! 463: * Returns 1 if we experienced an ATA-level abort command
! 464: * (ABRT bit set but no additional sense)
! 465: * 0 if normal command processing
! 466: */
! 467: int
! 468: atapi_to_scsi_sense(xfer, flags)
! 469: struct scsi_xfer *xfer;
! 470: u_int8_t flags;
! 471: {
! 472: struct scsi_sense_data *sense = &xfer->sense;
! 473: int ret = 0;
! 474:
! 475: xfer->error = XS_SHORTSENSE;
! 476:
! 477: sense->error_code = SSD_ERRCODE_VALID | 0x70;
! 478: sense->flags = (flags >> 4);
! 479:
! 480: WDCDEBUG_PRINT(("Atapi error: %d ", (flags >> 4)), DEBUG_ERRORS);
! 481:
! 482: if ((flags & 4) && (sense->flags == 0)) {
! 483: sense->flags = SKEY_ABORTED_COMMAND;
! 484: WDCDEBUG_PRINT(("ABRT "), DEBUG_ERRORS);
! 485: ret = 1;
! 486: }
! 487:
! 488: if (flags & 0x1) {
! 489: sense->flags |= SSD_ILI;
! 490: WDCDEBUG_PRINT(("ILI "), DEBUG_ERRORS);
! 491: }
! 492:
! 493: if (flags & 0x2) {
! 494: sense->flags |= SSD_EOM;
! 495: WDCDEBUG_PRINT(("EOM "), DEBUG_ERRORS);
! 496: }
! 497:
! 498: /* Media change requested */
! 499: /* Let's ignore these in version 1 */
! 500: if (flags & 0x8) {
! 501: WDCDEBUG_PRINT(("MCR "), DEBUG_ERRORS);
! 502: if (sense->flags == 0)
! 503: xfer->error = XS_NOERROR;
! 504: }
! 505:
! 506: WDCDEBUG_PRINT(("\n"), DEBUG_ERRORS);
! 507: return (ret);
! 508: }
! 509:
! 510: int wdc_atapi_drive_selected(struct channel_softc *, int);
! 511:
! 512: int
! 513: wdc_atapi_drive_selected(chp, drive)
! 514: struct channel_softc *chp;
! 515: int drive;
! 516: {
! 517: u_int8_t reg = CHP_READ_REG(chp, wdr_sdh);
! 518:
! 519: WDC_LOG_REG(chp, wdr_sdh, reg);
! 520:
! 521: return ((reg & 0x10) == (drive << 4));
! 522: }
! 523:
! 524: enum atapi_context {
! 525: ctxt_process = 0,
! 526: ctxt_timer = 1,
! 527: ctxt_interrupt = 2
! 528: };
! 529:
! 530: void wdc_atapi_the_machine(struct channel_softc *, struct wdc_xfer *,
! 531: enum atapi_context);
! 532:
! 533: void wdc_atapi_the_poll_machine(struct channel_softc *, struct wdc_xfer *);
! 534:
! 535: void
! 536: wdc_atapi_start(chp, xfer)
! 537: struct channel_softc *chp;
! 538: struct wdc_xfer *xfer;
! 539: {
! 540: xfer->next = wdc_atapi_real_start;
! 541:
! 542: wdc_atapi_the_machine(chp, xfer, ctxt_process);
! 543: }
! 544:
! 545:
! 546: void
! 547: wdc_atapi_timer_handler(arg)
! 548: void *arg;
! 549: {
! 550: struct channel_softc *chp = arg;
! 551: struct wdc_xfer *xfer;
! 552: int s;
! 553:
! 554: s = splbio();
! 555: xfer = TAILQ_FIRST(&chp->ch_queue->sc_xfer);
! 556: if (xfer == NULL ||
! 557: !timeout_triggered(&xfer->atapi_poll_to)) {
! 558: splx(s);
! 559: return;
! 560: }
! 561: xfer->c_flags &= ~C_POLL_MACHINE;
! 562: timeout_del(&xfer->atapi_poll_to);
! 563: chp->ch_flags &= ~WDCF_IRQ_WAIT;
! 564: wdc_atapi_the_machine(chp, xfer, ctxt_timer);
! 565: splx(s);
! 566: }
! 567:
! 568:
! 569: int
! 570: wdc_atapi_intr(chp, xfer, irq)
! 571: struct channel_softc *chp;
! 572: struct wdc_xfer *xfer;
! 573: int irq;
! 574: {
! 575: timeout_del(&chp->ch_timo);
! 576:
! 577: /* XXX we should consider an alternate signaling regime here */
! 578: if (xfer->c_flags & C_TIMEOU) {
! 579: xfer->c_flags &= ~C_TIMEOU;
! 580: wdc_atapi_the_machine(chp, xfer, ctxt_timer);
! 581: return (0);
! 582: }
! 583:
! 584: wdc_atapi_the_machine(chp, xfer, ctxt_interrupt);
! 585:
! 586: return (-1);
! 587: }
! 588:
! 589: struct atapi_return_args {
! 590: int timeout;
! 591: int delay;
! 592: int expect_irq;
! 593: };
! 594:
! 595: #define ARGS_INIT {-1, 0, 0}
! 596:
! 597: void
! 598: wdc_atapi_the_poll_machine(chp, xfer)
! 599: struct channel_softc *chp;
! 600: struct wdc_xfer *xfer;
! 601: {
! 602: int idx = 0;
! 603: int current_timeout = 10;
! 604:
! 605:
! 606: while (1) {
! 607: struct atapi_return_args retargs = ARGS_INIT;
! 608: idx++;
! 609:
! 610: (xfer->next)(chp, xfer, (current_timeout * 1000 <= idx),
! 611: &retargs);
! 612:
! 613: if (xfer->next == NULL) {
! 614: wdc_free_xfer(chp, xfer);
! 615: wdcstart(chp);
! 616: return;
! 617: }
! 618:
! 619: if (retargs.timeout != -1) {
! 620: current_timeout = retargs.timeout;
! 621: idx = 0;
! 622: }
! 623:
! 624: if (retargs.delay != 0) {
! 625: delay (1000 * retargs.delay);
! 626: idx += 1000 * retargs.delay;
! 627: }
! 628:
! 629: DELAY(1);
! 630: }
! 631: }
! 632:
! 633:
! 634: void
! 635: wdc_atapi_the_machine(chp, xfer, ctxt)
! 636: struct channel_softc *chp;
! 637: struct wdc_xfer *xfer;
! 638: enum atapi_context ctxt;
! 639: {
! 640: int idx = 0;
! 641: extern int ticks;
! 642: int timeout_delay = hz / 10;
! 643:
! 644: if (xfer->c_flags & C_POLL) {
! 645: wdc_disable_intr(chp);
! 646:
! 647: if (ctxt != ctxt_process) {
! 648: if (ctxt == ctxt_interrupt)
! 649: xfer->endticks = 1;
! 650:
! 651: return;
! 652: }
! 653:
! 654: wdc_atapi_the_poll_machine(chp, xfer);
! 655: return;
! 656: }
! 657:
! 658: /* Don't go through more than 50 state machine steps
! 659: before yielding. This tries to limit the amount of time
! 660: spent at high SPL */
! 661: for (idx = 0; idx < 50; idx++) {
! 662: struct atapi_return_args retargs = ARGS_INIT;
! 663:
! 664: (xfer->next)(chp, xfer,
! 665: xfer->endticks && (ticks - xfer->endticks >= 0),
! 666: &retargs);
! 667:
! 668: if (retargs.timeout != -1)
! 669: /*
! 670: * Add 1 tick to compensate for the fact that we
! 671: * can be just microseconds before the tick changes.
! 672: */
! 673: xfer->endticks =
! 674: max((retargs.timeout * hz) / 1000, 1) + 1 + ticks;
! 675:
! 676: if (xfer->next == NULL) {
! 677: if (xfer->c_flags & C_POLL_MACHINE)
! 678: timeout_del(&xfer->atapi_poll_to);
! 679:
! 680: wdc_free_xfer(chp, xfer);
! 681: wdcstart(chp);
! 682:
! 683: return;
! 684: }
! 685:
! 686: if (retargs.expect_irq) {
! 687: chp->ch_flags |= WDCF_IRQ_WAIT;
! 688: timeout_add(&chp->ch_timo, xfer->endticks - ticks);
! 689: return;
! 690: }
! 691:
! 692: if (retargs.delay != 0) {
! 693: timeout_delay = max(retargs.delay * hz / 1000, 1);
! 694: break;
! 695: }
! 696:
! 697: DELAY(1);
! 698: }
! 699:
! 700: timeout_add(&xfer->atapi_poll_to, timeout_delay);
! 701: xfer->c_flags |= C_POLL_MACHINE;
! 702:
! 703: return;
! 704: }
! 705:
! 706:
! 707: void wdc_atapi_update_status(struct channel_softc *);
! 708:
! 709: void
! 710: wdc_atapi_update_status(chp)
! 711: struct channel_softc *chp;
! 712: {
! 713: chp->ch_status = CHP_READ_REG(chp, wdr_status);
! 714:
! 715: WDC_LOG_STATUS(chp, chp->ch_status);
! 716:
! 717: if (chp->ch_status == 0xff && (chp->ch_flags & WDCF_ONESLAVE)) {
! 718: wdc_set_drive(chp, 1);
! 719:
! 720: chp->ch_status = CHP_READ_REG(chp, wdr_status);
! 721: WDC_LOG_STATUS(chp, chp->ch_status);
! 722: }
! 723:
! 724: if ((chp->ch_status & (WDCS_BSY | WDCS_ERR)) == WDCS_ERR) {
! 725: chp->ch_error = CHP_READ_REG(chp, wdr_error);
! 726: WDC_LOG_ERROR(chp, chp->ch_error);
! 727: }
! 728: }
! 729:
! 730: void
! 731: wdc_atapi_real_start(chp, xfer, timeout, ret)
! 732: struct channel_softc *chp;
! 733: struct wdc_xfer *xfer;
! 734: int timeout;
! 735: struct atapi_return_args *ret;
! 736: {
! 737: #ifdef WDCDEBUG
! 738: struct scsi_xfer *sc_xfer = xfer->cmd;
! 739: #endif
! 740: struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
! 741:
! 742: /*
! 743: * Only set the DMA flag if the transfer is reasonably large.
! 744: * At least one older drive failed to complete a 4 byte DMA transfer.
! 745: */
! 746:
! 747: /* Turn off DMA flag on REQUEST SENSE */
! 748:
! 749: if (!(xfer->c_flags & (C_POLL | C_SENSE | C_MEDIA_ACCESS)) &&
! 750: (drvp->drive_flags & (DRIVE_DMA | DRIVE_UDMA)) &&
! 751: (xfer->c_bcount > 100))
! 752: xfer->c_flags |= C_DMA;
! 753: else
! 754: xfer->c_flags &= ~C_DMA;
! 755:
! 756:
! 757: wdc_set_drive(chp, xfer->drive);
! 758:
! 759: DELAY(1);
! 760:
! 761: xfer->next = wdc_atapi_real_start_2;
! 762: ret->timeout = ATAPI_DELAY;
! 763:
! 764: WDCDEBUG_PRINT(("wdc_atapi_start %s:%d:%d, scsi flags 0x%x, "
! 765: "ATA flags 0x%x\n",
! 766: chp->wdc->sc_dev.dv_xname, chp->channel, drvp->drive,
! 767: sc_xfer->flags, xfer->c_flags), DEBUG_XFERS);
! 768:
! 769:
! 770: return;
! 771: }
! 772:
! 773:
! 774: void
! 775: wdc_atapi_real_start_2(chp, xfer, timeout, ret)
! 776: struct channel_softc *chp;
! 777: struct wdc_xfer *xfer;
! 778: int timeout;
! 779: struct atapi_return_args *ret;
! 780: {
! 781: struct scsi_xfer *sc_xfer = xfer->cmd;
! 782: struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
! 783:
! 784: if (timeout) {
! 785: printf("wdc_atapi_start: not ready, st = %02x\n",
! 786: chp->ch_status);
! 787:
! 788: sc_xfer->error = XS_TIMEOUT;
! 789: xfer->next = wdc_atapi_reset;
! 790: return;
! 791: } else {
! 792: wdc_atapi_update_status(chp);
! 793:
! 794: if (chp->ch_status & (WDCS_BSY | WDCS_DRQ))
! 795: return;
! 796: }
! 797:
! 798: /* Do control operations specially. */
! 799: if (drvp->state < ATAPI_READY_STATE) {
! 800: xfer->next = wdc_atapi_ctrl;
! 801: return;
! 802: }
! 803:
! 804: xfer->next = wdc_atapi_send_packet;
! 805: return;
! 806: }
! 807:
! 808:
! 809: void
! 810: wdc_atapi_send_packet(chp, xfer, timeout, ret)
! 811: struct channel_softc *chp;
! 812: struct wdc_xfer *xfer;
! 813: int timeout;
! 814: struct atapi_return_args *ret;
! 815: {
! 816: struct scsi_xfer *sc_xfer = xfer->cmd;
! 817: struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
! 818:
! 819: /*
! 820: * Even with WDCS_ERR, the device should accept a command packet
! 821: * Limit length to what can be stuffed into the cylinder register
! 822: * (16 bits). Some CD-ROMs seem to interpret '0' as 65536,
! 823: * but not all devices do that and it's not obvious from the
! 824: * ATAPI spec that this behaviour should be expected. If more
! 825: * data is necessary, multiple data transfer phases will be done.
! 826: */
! 827:
! 828: wdccommand(chp, xfer->drive, ATAPI_PKT_CMD,
! 829: xfer->c_bcount <= 0xfffe ? xfer->c_bcount : 0xfffe,
! 830: 0, 0, 0,
! 831: (xfer->c_flags & C_DMA) ? ATAPI_PKT_CMD_FTRE_DMA : 0);
! 832:
! 833: if (xfer->c_flags & C_DMA)
! 834: drvp->n_xfers++;
! 835:
! 836: DELAY(1);
! 837:
! 838: xfer->next = wdc_atapi_intr_command;
! 839: ret->timeout = sc_xfer->timeout;
! 840:
! 841: if ((drvp->atapi_cap & ATAPI_CFG_DRQ_MASK) == ATAPI_CFG_IRQ_DRQ) {
! 842: /* We expect an IRQ to tell us of the next state */
! 843: ret->expect_irq = 1;
! 844: }
! 845:
! 846: WDCDEBUG_PRINT(("wdc_atapi_send_packet %s:%d:%d command sent\n",
! 847: chp->wdc->sc_dev.dv_xname, chp->channel, drvp->drive
! 848: ), DEBUG_XFERS);
! 849: return;
! 850: }
! 851:
! 852: void
! 853: wdc_atapi_intr_command(chp, xfer, timeout, ret)
! 854: struct channel_softc *chp;
! 855: struct wdc_xfer *xfer;
! 856: int timeout;
! 857: struct atapi_return_args *ret;
! 858: {
! 859: struct scsi_xfer *sc_xfer = xfer->cmd;
! 860: struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
! 861: struct atapiscsi_softc *as = sc_xfer->sc_link->adapter_softc;
! 862: int i;
! 863: u_int8_t cmd[16];
! 864: struct scsi_sense *cmd_reqsense;
! 865: int cmdlen = (drvp->atapi_cap & ACAP_LEN) ? 16 : 12;
! 866: int dma_flags = ((sc_xfer->flags & SCSI_DATA_IN) ||
! 867: (xfer->c_flags & C_SENSE)) ? WDC_DMA_READ : 0;
! 868:
! 869: wdc_atapi_update_status(chp);
! 870:
! 871: if ((chp->ch_status & WDCS_BSY) || !(chp->ch_status & WDCS_DRQ)) {
! 872: if (timeout)
! 873: goto timeout;
! 874:
! 875: return;
! 876: }
! 877:
! 878: if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
! 879: chp->wdc->irqack(chp);
! 880:
! 881: bzero(cmd, sizeof(cmd));
! 882:
! 883: if (xfer->c_flags & C_SENSE) {
! 884: cmd_reqsense = (struct scsi_sense *)&cmd[0];
! 885: cmd_reqsense->opcode = REQUEST_SENSE;
! 886: cmd_reqsense->length = xfer->c_bcount;
! 887: } else
! 888: bcopy(sc_xfer->cmd, cmd, sc_xfer->cmdlen);
! 889:
! 890: WDC_LOG_ATAPI_CMD(chp, xfer->drive, xfer->c_flags,
! 891: cmdlen, cmd);
! 892:
! 893: for (i = 0; i < 12; i++)
! 894: WDCDEBUG_PRINT(("%02x ", cmd[i]), DEBUG_INTR);
! 895: WDCDEBUG_PRINT((": PHASE_CMDOUT\n"), DEBUG_INTR);
! 896:
! 897: /* Init the DMA channel if necessary */
! 898: if (xfer->c_flags & C_DMA) {
! 899: if ((*chp->wdc->dma_init)(chp->wdc->dma_arg,
! 900: chp->channel, xfer->drive, xfer->databuf,
! 901: xfer->c_bcount, dma_flags) != 0) {
! 902: sc_xfer->error = XS_DRIVER_STUFFUP;
! 903:
! 904: xfer->next = wdc_atapi_reset;
! 905: return;
! 906: }
! 907: }
! 908:
! 909: wdc_output_bytes(drvp, cmd, cmdlen);
! 910:
! 911: /* Start the DMA channel if necessary */
! 912: if (xfer->c_flags & C_DMA) {
! 913: (*chp->wdc->dma_start)(chp->wdc->dma_arg,
! 914: chp->channel, xfer->drive);
! 915: xfer->next = wdc_atapi_intr_complete;
! 916: } else {
! 917: if (xfer->c_bcount == 0)
! 918: as->protocol_phase = as_completed;
! 919: else
! 920: as->protocol_phase = as_data;
! 921:
! 922: xfer->next = wdc_atapi_pio_intr;
! 923: }
! 924:
! 925: ret->expect_irq = 1;
! 926:
! 927: /* If we read/write to a tape we will get into buffer
! 928: availability mode. */
! 929: if (drvp->atapi_cap & ACAP_DSC) {
! 930: if ((sc_xfer->cmd->opcode == READ ||
! 931: sc_xfer->cmd->opcode == WRITE)) {
! 932: drvp->drive_flags |= DRIVE_DSCBA;
! 933: WDCDEBUG_PRINT(("set DSCBA\n"), DEBUG_DSC);
! 934: } else if ((xfer->c_flags & C_MEDIA_ACCESS) &&
! 935: (drvp->drive_flags & DRIVE_DSCBA)) {
! 936: /* Clause 3.2.4 of QIC-157 D.
! 937:
! 938: Any media access command other than read or
! 939: write will switch DSC back to completion
! 940: mode */
! 941: drvp->drive_flags &= ~DRIVE_DSCBA;
! 942: WDCDEBUG_PRINT(("clear DCSBA\n"), DEBUG_DSC);
! 943: }
! 944: }
! 945:
! 946: return;
! 947:
! 948: timeout:
! 949: printf ("%s:%d:%d: device timeout waiting to send SCSI packet\n",
! 950: chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive);
! 951:
! 952: sc_xfer->error = XS_TIMEOUT;
! 953: xfer->next = wdc_atapi_reset;
! 954: return;
! 955: }
! 956:
! 957:
! 958: char *
! 959: wdc_atapi_in_data_phase(xfer, len, ire)
! 960: struct wdc_xfer *xfer;
! 961: int len, ire;
! 962: {
! 963: struct scsi_xfer *sc_xfer = xfer->cmd;
! 964: struct atapiscsi_softc *as = sc_xfer->sc_link->adapter_softc;
! 965: char *message;
! 966:
! 967: if (as->protocol_phase != as_data) {
! 968: message = "unexpected data phase";
! 969: goto unexpected_state;
! 970: }
! 971:
! 972: if (ire & WDCI_CMD) {
! 973: message = "unexpectedly in command phase";
! 974: goto unexpected_state;
! 975: }
! 976:
! 977: if (!(xfer->c_flags & C_SENSE)) {
! 978: if (!(sc_xfer->flags & (SCSI_DATA_IN | SCSI_DATA_OUT))) {
! 979: message = "data phase where none expected";
! 980: goto unexpected_state;
! 981: }
! 982:
! 983: /* Make sure polarities match */
! 984: if (((ire & WDCI_IN) == WDCI_IN) ==
! 985: ((sc_xfer->flags & SCSI_DATA_OUT) == SCSI_DATA_OUT)) {
! 986: message = "data transfer direction disagreement";
! 987: goto unexpected_state;
! 988: }
! 989: } else {
! 990: if (!(ire & WDCI_IN)) {
! 991: message = "data transfer direction disagreement during sense";
! 992: goto unexpected_state;
! 993: }
! 994: }
! 995:
! 996: if (len == 0) {
! 997: message = "zero length transfer requested in data phase";
! 998: goto unexpected_state;
! 999: }
! 1000:
! 1001:
! 1002: return (0);
! 1003:
! 1004: unexpected_state:
! 1005:
! 1006: return (message);
! 1007: }
! 1008:
! 1009: void
! 1010: wdc_atapi_intr_data(chp, xfer, timeout, ret)
! 1011: struct channel_softc *chp;
! 1012: struct wdc_xfer *xfer;
! 1013: int timeout;
! 1014: struct atapi_return_args *ret;
! 1015: {
! 1016: struct scsi_xfer *sc_xfer = xfer->cmd;
! 1017: struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
! 1018: int len, ire;
! 1019: char *message;
! 1020: int tohost;
! 1021:
! 1022: len = (CHP_READ_REG(chp, wdr_cyl_hi) << 8) |
! 1023: CHP_READ_REG(chp, wdr_cyl_lo);
! 1024: WDC_LOG_REG(chp, wdr_cyl_lo, len);
! 1025:
! 1026: ire = CHP_READ_REG(chp, wdr_ireason);
! 1027: WDC_LOG_REG(chp, wdr_ireason, ire);
! 1028:
! 1029: if ((message = wdc_atapi_in_data_phase(xfer, len, ire))) {
! 1030: /* The drive has dropped BSY before setting up the
! 1031: registers correctly for DATA phase. This drive is
! 1032: not compliant with ATA/ATAPI-4.
! 1033:
! 1034: Give the drive 100ms to get its house in order
! 1035: before we try again. */
! 1036: WDCDEBUG_PRINT(("wdc_atapi_intr: %s\n", message),
! 1037: DEBUG_ERRORS);
! 1038:
! 1039: if (!timeout) {
! 1040: ret->delay = 100;
! 1041: return;
! 1042: }
! 1043: }
! 1044:
! 1045: tohost = ((sc_xfer->flags & SCSI_DATA_IN) != 0 ||
! 1046: (xfer->c_flags & C_SENSE) != 0);
! 1047:
! 1048: if (xfer->c_bcount >= len) {
! 1049: WDCDEBUG_PRINT(("wdc_atapi_intr: c_bcount %d len %d "
! 1050: "st 0x%b err 0x%x "
! 1051: "ire 0x%x\n", xfer->c_bcount,
! 1052: len, chp->ch_status, WDCS_BITS, chp->ch_error, ire),
! 1053: DEBUG_INTR);
! 1054:
! 1055: /* Common case */
! 1056: if (!tohost)
! 1057: wdc_output_bytes(drvp, (u_int8_t *)xfer->databuf +
! 1058: xfer->c_skip, len);
! 1059: else
! 1060: wdc_input_bytes(drvp, (u_int8_t *)xfer->databuf +
! 1061: xfer->c_skip, len);
! 1062:
! 1063: xfer->c_skip += len;
! 1064: xfer->c_bcount -= len;
! 1065: } else {
! 1066: /* Exceptional case - drive want to transfer more
! 1067: data than we have buffer for */
! 1068: if (!tohost) {
! 1069: /* Wouldn't it be better to just abort here rather
! 1070: than to write random stuff to drive? */
! 1071: printf("wdc_atapi_intr: warning: device requesting "
! 1072: "%d bytes, only %d left in buffer\n", len, xfer->c_bcount);
! 1073:
! 1074: wdc_output_bytes(drvp, (u_int8_t *)xfer->databuf +
! 1075: xfer->c_skip, xfer->c_bcount);
! 1076:
! 1077: CHP_WRITE_RAW_MULTI_2(chp, NULL,
! 1078: len - xfer->c_bcount);
! 1079: } else {
! 1080: printf("wdc_atapi_intr: warning: reading only "
! 1081: "%d of %d bytes\n", xfer->c_bcount, len);
! 1082:
! 1083: wdc_input_bytes(drvp,
! 1084: (char *)xfer->databuf + xfer->c_skip,
! 1085: xfer->c_bcount);
! 1086: wdcbit_bucket(chp, len - xfer->c_bcount);
! 1087: }
! 1088:
! 1089: xfer->c_skip += xfer->c_bcount;
! 1090: xfer->c_bcount = 0;
! 1091: }
! 1092:
! 1093: ret->expect_irq = 1;
! 1094: xfer->next = wdc_atapi_pio_intr;
! 1095:
! 1096: return;
! 1097: }
! 1098:
! 1099: void
! 1100: wdc_atapi_intr_complete(chp, xfer, timeout, ret)
! 1101: struct channel_softc *chp;
! 1102: struct wdc_xfer *xfer;
! 1103: int timeout;
! 1104: struct atapi_return_args *ret;
! 1105: {
! 1106: struct scsi_xfer *sc_xfer = xfer->cmd;
! 1107: struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
! 1108: struct atapiscsi_softc *as = sc_xfer->sc_link->adapter_softc;
! 1109:
! 1110: WDCDEBUG_PRINT(("PHASE_COMPLETED\n"), DEBUG_INTR);
! 1111:
! 1112: if (xfer->c_flags & C_DMA) {
! 1113: int retry;
! 1114:
! 1115: if (timeout) {
! 1116: sc_xfer->error = XS_TIMEOUT;
! 1117: ata_dmaerr(drvp);
! 1118:
! 1119: xfer->next = wdc_atapi_reset;
! 1120: return;
! 1121: }
! 1122:
! 1123: for (retry = 5; retry > 0; retry--) {
! 1124: wdc_atapi_update_status(chp);
! 1125: if ((chp->ch_status & (WDCS_BSY | WDCS_DRQ)) == 0)
! 1126: break;
! 1127: DELAY(5);
! 1128: }
! 1129: if (retry == 0) {
! 1130: ret->expect_irq = 1;
! 1131: return;
! 1132: }
! 1133:
! 1134: chp->wdc->dma_status =
! 1135: (*chp->wdc->dma_finish)
! 1136: (chp->wdc->dma_arg, chp->channel,
! 1137: xfer->drive, 1);
! 1138:
! 1139: if (chp->wdc->dma_status & WDC_DMAST_UNDER)
! 1140: xfer->c_bcount = 1;
! 1141: else
! 1142: xfer->c_bcount = 0;
! 1143: }
! 1144:
! 1145: as->protocol_phase = as_none;
! 1146:
! 1147: if (xfer->c_flags & C_SENSE) {
! 1148: if (chp->ch_status & WDCS_ERR) {
! 1149: if (chp->ch_error & WDCE_ABRT) {
! 1150: WDCDEBUG_PRINT(("wdc_atapi_intr: request_sense aborted, "
! 1151: "calling wdc_atapi_done()"
! 1152: ), DEBUG_INTR);
! 1153: xfer->next = wdc_atapi_done;
! 1154: return;
! 1155: }
! 1156:
! 1157: /*
! 1158: * request sense failed ! it's not supposed
! 1159: * to be possible
! 1160: */
! 1161: sc_xfer->error = XS_SHORTSENSE;
! 1162: } else if (xfer->c_bcount < sizeof(sc_xfer->sense)) {
! 1163: /* use the sense we just read */
! 1164: sc_xfer->error = XS_SENSE;
! 1165: } else {
! 1166: /*
! 1167: * command completed, but no data was read.
! 1168: * use the short sense we saved previously.
! 1169: */
! 1170: sc_xfer->error = XS_SHORTSENSE;
! 1171: }
! 1172: } else {
! 1173: sc_xfer->resid = xfer->c_bcount;
! 1174: if (chp->ch_status & WDCS_ERR) {
! 1175: if (!atapi_to_scsi_sense(sc_xfer, chp->ch_error) &&
! 1176: (sc_xfer->sc_link->quirks &
! 1177: ADEV_NOSENSE) == 0) {
! 1178: /*
! 1179: * let the driver issue a
! 1180: * 'request sense'
! 1181: */
! 1182: xfer->databuf = &sc_xfer->sense;
! 1183: xfer->c_bcount = sizeof(sc_xfer->sense);
! 1184: xfer->c_skip = 0;
! 1185: xfer->c_done = NULL;
! 1186: xfer->c_flags |= C_SENSE;
! 1187: xfer->next = wdc_atapi_real_start;
! 1188: return;
! 1189: }
! 1190: }
! 1191: }
! 1192:
! 1193: if ((xfer->c_flags & C_DMA) &&
! 1194: (chp->wdc->dma_status & ~WDC_DMAST_UNDER)) {
! 1195: ata_dmaerr(drvp);
! 1196: sc_xfer->error = XS_RESET;
! 1197:
! 1198: xfer->next = wdc_atapi_reset;
! 1199: return;
! 1200: }
! 1201:
! 1202:
! 1203: if (xfer->c_bcount != 0) {
! 1204: WDCDEBUG_PRINT(("wdc_atapi_intr: bcount value is "
! 1205: "%d after io\n", xfer->c_bcount), DEBUG_XFERS);
! 1206: }
! 1207: #ifdef DIAGNOSTIC
! 1208: if (xfer->c_bcount < 0) {
! 1209: printf("wdc_atapi_intr warning: bcount value "
! 1210: "is %d after io\n", xfer->c_bcount);
! 1211: }
! 1212: #endif
! 1213:
! 1214: WDCDEBUG_PRINT(("wdc_atapi_intr: wdc_atapi_done() (end), error 0x%x "
! 1215: "\n", sc_xfer->error),
! 1216: DEBUG_INTR);
! 1217:
! 1218:
! 1219: if (xfer->c_done)
! 1220: xfer->next = xfer->c_done;
! 1221: else
! 1222: xfer->next = wdc_atapi_done;
! 1223:
! 1224: return;
! 1225: }
! 1226:
! 1227: void
! 1228: wdc_atapi_pio_intr(chp, xfer, timeout, ret)
! 1229: struct channel_softc *chp;
! 1230: struct wdc_xfer *xfer;
! 1231: int timeout;
! 1232: struct atapi_return_args *ret;
! 1233: {
! 1234: struct scsi_xfer *sc_xfer = xfer->cmd;
! 1235: struct atapiscsi_softc *as = sc_xfer->sc_link->adapter_softc;
! 1236: u_int8_t ireason;
! 1237:
! 1238: wdc_atapi_update_status(chp);
! 1239:
! 1240: if (chp->ch_status & WDCS_BSY) {
! 1241: if (timeout)
! 1242: goto timeout;
! 1243:
! 1244: return;
! 1245: }
! 1246:
! 1247: if (!wdc_atapi_drive_selected(chp, xfer->drive)) {
! 1248: WDCDEBUG_PRINT(("wdc_atapi_intr_for_us: wrong drive selected\n"), DEBUG_INTR);
! 1249: wdc_set_drive(chp, xfer->drive);
! 1250: delay (1);
! 1251:
! 1252: if (!timeout)
! 1253: return;
! 1254: }
! 1255:
! 1256: if ((xfer->c_flags & C_MEDIA_ACCESS) &&
! 1257: !(chp->ch_status & (WDCS_DSC | WDCS_DRQ))) {
! 1258: if (timeout)
! 1259: goto timeout;
! 1260:
! 1261: ret->delay = 100;
! 1262: return;
! 1263: }
! 1264:
! 1265: if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
! 1266: chp->wdc->irqack(chp);
! 1267:
! 1268: ireason = CHP_READ_REG(chp, wdr_ireason);
! 1269: WDC_LOG_REG(chp, wdr_ireason, ireason);
! 1270:
! 1271: WDCDEBUG_PRINT(("Phase %d, (0x%b, 0x%x) ", as->protocol_phase,
! 1272: chp->ch_status, WDCS_BITS, ireason), DEBUG_INTR );
! 1273:
! 1274: switch (as->protocol_phase) {
! 1275: case as_data:
! 1276: if ((chp->ch_status & WDCS_DRQ) ||
! 1277: (ireason & 3) != 3) {
! 1278: if (timeout)
! 1279: goto timeout;
! 1280:
! 1281: wdc_atapi_intr_data(chp, xfer, timeout, ret);
! 1282: return;
! 1283: }
! 1284:
! 1285: case as_completed:
! 1286: if ((chp->ch_status & WDCS_DRQ) ||
! 1287: (ireason & 3) != 3) {
! 1288: if (timeout)
! 1289: goto timeout;
! 1290:
! 1291: ret->delay = 100;
! 1292: return;
! 1293: }
! 1294:
! 1295: wdc_atapi_intr_complete(chp, xfer, timeout, ret);
! 1296: return;
! 1297:
! 1298: default:
! 1299: printf ("atapiscsi: Shouldn't get here\n");
! 1300: sc_xfer->error = XS_DRIVER_STUFFUP;
! 1301: xfer->next = wdc_atapi_reset;
! 1302: return;
! 1303: }
! 1304:
! 1305: return;
! 1306: timeout:
! 1307: ireason = CHP_READ_REG(chp, wdr_ireason);
! 1308: WDC_LOG_REG(chp, wdr_ireason, ireason);
! 1309:
! 1310: printf("%s:%d:%d: device timeout, c_bcount=%d, c_skip=%d, "
! 1311: "status=0x%b, ireason=0x%x\n",
! 1312: chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive,
! 1313: xfer->c_bcount, xfer->c_skip, chp->ch_status, WDCS_BITS, ireason);
! 1314:
! 1315: sc_xfer->error = XS_TIMEOUT;
! 1316: xfer->next = wdc_atapi_reset;
! 1317: return;
! 1318: }
! 1319:
! 1320:
! 1321:
! 1322: void
! 1323: wdc_atapi_ctrl(chp, xfer, timeout, ret)
! 1324: struct channel_softc *chp;
! 1325: struct wdc_xfer *xfer;
! 1326: int timeout;
! 1327: struct atapi_return_args *ret;
! 1328: {
! 1329: struct scsi_xfer *sc_xfer = xfer->cmd;
! 1330: struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
! 1331: char *errstring = NULL;
! 1332:
! 1333: wdc_atapi_update_status(chp);
! 1334:
! 1335: if (!timeout) {
! 1336: switch (drvp->state) {
! 1337: case ATAPI_IDENTIFY_WAIT_STATE:
! 1338: if (chp->ch_status & WDCS_BSY)
! 1339: return;
! 1340: break;
! 1341: default:
! 1342: if (chp->ch_status & (WDCS_BSY | WDCS_DRQ))
! 1343: return;
! 1344: break;
! 1345: }
! 1346: }
! 1347:
! 1348: if (!wdc_atapi_drive_selected(chp, xfer->drive))
! 1349: {
! 1350: wdc_set_drive(chp, xfer->drive);
! 1351: delay (1);
! 1352: }
! 1353:
! 1354: if (timeout) {
! 1355: int trigger_timeout = 1;
! 1356:
! 1357: switch (drvp->state) {
! 1358: case ATAPI_DEVICE_RESET_WAIT_STATE:
! 1359: errstring = "Device Reset Wait";
! 1360: drvp->drive_flags &= ~DRIVE_DEVICE_RESET;
! 1361: break;
! 1362:
! 1363: case ATAPI_IDENTIFY_WAIT_STATE:
! 1364: errstring = "Identify";
! 1365: if (!(chp->ch_status & WDCS_BSY) &&
! 1366: (chp->ch_status & (WDCS_DRQ | WDCS_ERR)))
! 1367: trigger_timeout = 0;
! 1368:
! 1369: break;
! 1370:
! 1371: case ATAPI_PIOMODE_STATE:
! 1372: errstring = "Post-Identify";
! 1373: if (!(chp->ch_status & (WDCS_BSY | WDCS_DRQ)))
! 1374: trigger_timeout = 0;
! 1375: break;
! 1376:
! 1377: case ATAPI_PIOMODE_WAIT_STATE:
! 1378: errstring = "PIOMODE";
! 1379: if (chp->ch_status & (WDCS_BSY | WDCS_DRQ))
! 1380: drvp->drive_flags &= ~DRIVE_MODE;
! 1381: else
! 1382: trigger_timeout = 0;
! 1383: break;
! 1384: case ATAPI_DMAMODE_WAIT_STATE:
! 1385: errstring = "dmamode";
! 1386: if (chp->ch_status & (WDCS_BSY | WDCS_DRQ))
! 1387: drvp->drive_flags &= ~(DRIVE_DMA | DRIVE_UDMA);
! 1388: else
! 1389: trigger_timeout = 0;
! 1390: break;
! 1391:
! 1392: default:
! 1393: errstring = "unknown state";
! 1394: break;
! 1395: }
! 1396:
! 1397: if (trigger_timeout)
! 1398: goto timeout;
! 1399: }
! 1400:
! 1401: WDCDEBUG_PRINT(("wdc_atapi_ctrl %s:%d:%d state %d\n",
! 1402: chp->wdc->sc_dev.dv_xname, chp->channel, drvp->drive, drvp->state),
! 1403: DEBUG_INTR | DEBUG_FUNCS);
! 1404:
! 1405: switch (drvp->state) {
! 1406: /* My ATAPI slave device likes to assert DASP-/PDIAG- until
! 1407: it is DEVICE RESET. This causes the LED to stay on.
! 1408:
! 1409: There is a trade-off here. This drive will cause any
! 1410: play-back or seeks happening to be interrupted.
! 1411:
! 1412: Note that the bus reset that triggered this state
! 1413: (which may have been caused by the other drive on
! 1414: the chain) need not interrupt this playback. It happens
! 1415: to on my Smart & Friendly CD burner.
! 1416:
! 1417: - csapuntz@
! 1418: */
! 1419: case ATAPI_RESET_BASE_STATE:
! 1420: if ((drvp->drive_flags & DRIVE_DEVICE_RESET) == 0) {
! 1421: drvp->state = ATAPI_IDENTIFY_STATE;
! 1422: break;
! 1423: }
! 1424:
! 1425: wdccommandshort(chp, drvp->drive, ATAPI_DEVICE_RESET);
! 1426: drvp->state = ATAPI_DEVICE_RESET_WAIT_STATE;
! 1427: ret->delay = ATAPI_RESET_DELAY;
! 1428: ret->timeout = ATAPI_RESET_WAIT;
! 1429: break;
! 1430:
! 1431: case ATAPI_DEVICE_RESET_WAIT_STATE:
! 1432: /* FALLTHROUGH */
! 1433:
! 1434: case ATAPI_IDENTIFY_STATE:
! 1435: wdccommandshort(chp, drvp->drive, ATAPI_IDENTIFY_DEVICE);
! 1436: drvp->state = ATAPI_IDENTIFY_WAIT_STATE;
! 1437: ret->delay = 10;
! 1438: ret->timeout = ATAPI_RESET_WAIT;
! 1439: break;
! 1440:
! 1441: case ATAPI_IDENTIFY_WAIT_STATE: {
! 1442: int idx = 0;
! 1443:
! 1444: while ((chp->ch_status & WDCS_DRQ) &&
! 1445: idx++ < 20) {
! 1446: wdcbit_bucket(chp, 512);
! 1447:
! 1448: DELAY(1);
! 1449: wdc_atapi_update_status(chp);
! 1450: }
! 1451:
! 1452: drvp->state = ATAPI_PIOMODE_STATE;
! 1453: /*
! 1454: * Note, we can't go directly to set PIO mode
! 1455: * because the drive is free to assert BSY
! 1456: * after the transfer
! 1457: */
! 1458: break;
! 1459: }
! 1460:
! 1461: case ATAPI_PIOMODE_STATE:
! 1462: /* Don't try to set mode if controller can't be adjusted */
! 1463: if ((chp->wdc->cap & WDC_CAPABILITY_MODE) == 0)
! 1464: goto ready;
! 1465: /* Also don't try if the drive didn't report its mode */
! 1466: if ((drvp->drive_flags & DRIVE_MODE) == 0)
! 1467: goto ready;
! 1468: /* SET FEATURES 0x08 is only for PIO mode > 2 */
! 1469: if (drvp->PIO_mode <= 2)
! 1470: goto ready;
! 1471: wdccommand(chp, drvp->drive, SET_FEATURES, 0, 0, 0,
! 1472: 0x08 | drvp->PIO_mode, WDSF_SET_MODE);
! 1473: drvp->state = ATAPI_PIOMODE_WAIT_STATE;
! 1474: ret->timeout = ATAPI_CTRL_WAIT;
! 1475: ret->expect_irq = 1;
! 1476: break;
! 1477: case ATAPI_PIOMODE_WAIT_STATE:
! 1478: if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
! 1479: chp->wdc->irqack(chp);
! 1480: if (chp->ch_status & WDCS_ERR) {
! 1481: /* Downgrade straight to PIO mode 3 */
! 1482: drvp->PIO_mode = 3;
! 1483: chp->wdc->set_modes(chp);
! 1484: }
! 1485: /* FALLTHROUGH */
! 1486:
! 1487: case ATAPI_DMAMODE_STATE:
! 1488: if (drvp->drive_flags & DRIVE_UDMA) {
! 1489: wdccommand(chp, drvp->drive, SET_FEATURES, 0, 0, 0,
! 1490: 0x40 | drvp->UDMA_mode, WDSF_SET_MODE);
! 1491: } else if (drvp->drive_flags & DRIVE_DMA) {
! 1492: wdccommand(chp, drvp->drive, SET_FEATURES, 0, 0, 0,
! 1493: 0x20 | drvp->DMA_mode, WDSF_SET_MODE);
! 1494: } else {
! 1495: goto ready;
! 1496: }
! 1497: drvp->state = ATAPI_DMAMODE_WAIT_STATE;
! 1498:
! 1499: ret->timeout = ATAPI_CTRL_WAIT;
! 1500: ret->expect_irq = 1;
! 1501: break;
! 1502:
! 1503: case ATAPI_DMAMODE_WAIT_STATE:
! 1504: if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
! 1505: chp->wdc->irqack(chp);
! 1506: if (chp->ch_status & WDCS_ERR)
! 1507: drvp->drive_flags &= ~(DRIVE_DMA | DRIVE_UDMA);
! 1508: /* FALLTHROUGH */
! 1509:
! 1510: case ATAPI_READY_STATE:
! 1511: ready:
! 1512: drvp->state = ATAPI_READY_STATE;
! 1513: xfer->next = wdc_atapi_real_start;
! 1514: break;
! 1515: }
! 1516: return;
! 1517:
! 1518: timeout:
! 1519: printf("%s:%d:%d: %s timed out\n",
! 1520: chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive, errstring);
! 1521: sc_xfer->error = XS_TIMEOUT;
! 1522: xfer->next = wdc_atapi_reset;
! 1523: return;
! 1524:
! 1525: }
! 1526:
! 1527: void
! 1528: wdc_atapi_tape_done(chp, xfer, timeout, ret)
! 1529: struct channel_softc *chp;
! 1530: struct wdc_xfer *xfer;
! 1531: int timeout;
! 1532: struct atapi_return_args *ret;
! 1533: {
! 1534: struct scsi_xfer *sc_xfer = xfer->cmd;
! 1535:
! 1536: if (sc_xfer->error != XS_NOERROR) {
! 1537: xfer->next = wdc_atapi_done;
! 1538: return;
! 1539: }
! 1540:
! 1541: _lto3b(xfer->transfer_len,
! 1542: ((struct scsi_rw_tape *)
! 1543: sc_xfer->cmd)->len);
! 1544:
! 1545: xfer->c_bcount = sc_xfer->datalen;
! 1546: xfer->c_done = NULL;
! 1547: xfer->c_skip = 0;
! 1548:
! 1549: xfer->next = wdc_atapi_real_start;
! 1550: return;
! 1551: }
! 1552:
! 1553:
! 1554: void
! 1555: wdc_atapi_done(chp, xfer, timeout, ret)
! 1556: struct channel_softc *chp;
! 1557: struct wdc_xfer *xfer;
! 1558: int timeout;
! 1559: struct atapi_return_args *ret;
! 1560: {
! 1561: struct scsi_xfer *sc_xfer = xfer->cmd;
! 1562:
! 1563: WDCDEBUG_PRINT(("wdc_atapi_done %s:%d:%d: flags 0x%x error 0x%x\n",
! 1564: chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive,
! 1565: (u_int)xfer->c_flags, sc_xfer->error), DEBUG_XFERS);
! 1566: WDC_LOG_ATAPI_DONE(chp, xfer->drive, xfer->c_flags, sc_xfer->error);
! 1567:
! 1568: sc_xfer->flags |= ITSDONE;
! 1569:
! 1570: if (xfer->c_flags & C_POLL) {
! 1571: wdc_enable_intr(chp);
! 1572: } else {
! 1573: WDCDEBUG_PRINT(("wdc_atapi_done: scsi_done\n"), DEBUG_XFERS);
! 1574: scsi_done(sc_xfer);
! 1575: }
! 1576:
! 1577: xfer->next = NULL;
! 1578: return;
! 1579: }
! 1580:
! 1581:
! 1582: void
! 1583: wdc_atapi_reset(chp, xfer, timeout, ret)
! 1584: struct channel_softc *chp;
! 1585: struct wdc_xfer *xfer;
! 1586: int timeout;
! 1587: struct atapi_return_args *ret;
! 1588: {
! 1589: struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
! 1590:
! 1591: if (drvp->state == 0) {
! 1592: xfer->next = wdc_atapi_done;
! 1593: return;
! 1594: }
! 1595:
! 1596: WDCDEBUG_PRINT(("wdc_atapi_reset\n"), DEBUG_XFERS);
! 1597: wdccommandshort(chp, xfer->drive, ATAPI_SOFT_RESET);
! 1598: drvp->state = ATAPI_IDENTIFY_STATE;
! 1599:
! 1600: drvp->n_resets++;
! 1601: /* Some ATAPI devices need extra time to find their
! 1602: brains after a reset
! 1603: */
! 1604: xfer->next = wdc_atapi_reset_2;
! 1605: ret->delay = ATAPI_RESET_DELAY;
! 1606: ret->timeout = ATAPI_RESET_WAIT;
! 1607: return;
! 1608: }
! 1609:
! 1610: void
! 1611: wdc_atapi_reset_2(chp, xfer, timeout, ret)
! 1612: struct channel_softc *chp;
! 1613: struct wdc_xfer *xfer;
! 1614: int timeout;
! 1615: struct atapi_return_args *ret;
! 1616: {
! 1617: struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
! 1618: struct scsi_xfer *sc_xfer = xfer->cmd;
! 1619:
! 1620: if (timeout) {
! 1621: printf("%s:%d:%d: soft reset failed\n",
! 1622: chp->wdc->sc_dev.dv_xname, chp->channel,
! 1623: xfer->drive);
! 1624: sc_xfer->error = XS_SELTIMEOUT;
! 1625: wdc_reset_channel(drvp);
! 1626:
! 1627: xfer->next = wdc_atapi_done;
! 1628: return;
! 1629: }
! 1630:
! 1631: wdc_atapi_update_status(chp);
! 1632:
! 1633: if (chp->ch_status & (WDCS_BSY | WDCS_DRQ)) {
! 1634: return;
! 1635: }
! 1636:
! 1637: xfer->next = wdc_atapi_done;
! 1638: return;
! 1639: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to atapiscsi.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / atapiscsi