![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to AtapiCntCmds.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / drvEIDE / EIDE.drvproj / EIDE.lksproj|
Return to AtapiCntCmds.m CVS log | Up to [Apple Darwin 0.x] / drvEIDE / EIDE.drvproj / EIDE.lksproj |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.0 (the 'License'). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License." ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: /* ! 25: * Copyright 1997-1998 by Apple Computer, Inc., All rights reserved. ! 26: * Copyright 1994-1997 NeXT Software, Inc., All rights reserved. ! 27: * ! 28: * AtapiCntCmds.m - ATAPI command implementation for ATA interface. ! 29: * ! 30: * HISTORY ! 31: * ! 32: * 4-Jan-1998 Joe Liu at Apple ! 33: * Merged the various wait routines into a single routine. ! 34: * Wait routine now sleeps longer to generate a more accurate wait ! 35: * interval. ! 36: * Check the BSY bit before sending the packet command. ! 37: * Detect shadow/phantom drives and timeout more quickly. ! 38: * Sprinkled some IODelays before checking the BSY bit. Since according ! 39: * to the spec, a drive may take up to 400ns to set the BSY bit, and ! 40: * we don't want to read it before it has enough time to assert itself. ! 41: * ! 42: * 3-Sep-1996 Becky Divinski at NeXT ! 43: * Moved LBA, IORDY, and buffer capabilities out ! 44: * from under DEBUG statements, so they will ! 45: * always print out during startup. ! 46: * ! 47: * 13-Feb-1996 Rakesh Dubey at NeXT ! 48: * More resistant to broken firmwares. ! 49: * ! 50: * 13-Jul-1995 Rakesh Dubey at NeXT ! 51: * Improved device detection and log messages. ! 52: * ! 53: * 1-Sep-1994 Rakesh Dubey at NeXT ! 54: * Created. ! 55: */ ! 56: ! 57: #import "AtapiCntCmds.h" ! 58: #import "IdePIIX.h" ! 59: ! 60: //#define DEBUG ! 61: ! 62: /* ! 63: * Max timeout while waiting for BSY == 0. ! 64: */ ! 65: #define ATAPI_MAX_WAIT_FOR_NOTBUSY (5 * 1000) // 5 secs ! 66: ! 67: @implementation IdeController(ATAPI) ! 68: ! 69: /* ! 70: * Method: atapiWaitStatusBitsFor:on:off:alt: ! 71: * ! 72: * General purpose wait routine. Wait for BSY bit in the Status/AltStatus ! 73: * register to clear, then make sure that the "on" bits are set, and the ! 74: * "off" bits are cleared in the status register. ! 75: * ! 76: * The routine busy waits for an initial count, then it uses IOSleeps to ! 77: * do non-blocking delays. IOSleep() has a minimum delay of around 15ms. ! 78: * Anything smaller will yield a longer than expected delay. ! 79: * ! 80: * Arguments: ! 81: * timeout - How long to wait for BSY bit to clear in milliseconds. ! 82: * on - Set bit mask. ! 83: * off - Cleared bit mask (BSY bit is implicitly checked). ! 84: * alt - YES to poll using AltStatus instead of Status register. ! 85: * ! 86: * Returns: ! 87: * IDER_SUCCESS - successful completion. ! 88: * IDER_TIMEOUT - timeout or bits check failed. ! 89: * ! 90: */ ! 91: ! 92: #define ATAPI_WAIT_DELAYS 5 // how many initial 1ms busy waits ! 93: #define ATAPI_SLEEP_DURATION 20 // how long to sleep using IOSleep ! 94: ! 95: - (atapi_return_t) atapiWaitStatusBitsFor:(unsigned int)timeout ! 96: on:(unsigned char)on ! 97: off:(unsigned char)off ! 98: alt:(BOOL)alt ! 99: { ! 100: unsigned char status; ! 101: int delays = ATAPI_WAIT_DELAYS; ! 102: ! 103: if (timeout == 0) ! 104: return IDER_TIMEOUT; ! 105: ! 106: IODelay(1); /* give the drive 400ns to assert BSY bit */ ! 107: do { ! 108: status = alt ? inb(_ideRegsAddrs.altStatus) : ! 109: inb(_ideRegsAddrs.status); ! 110: if (!(status & BUSY)) ! 111: break; ! 112: if (delays-- > 0) { // use IODelay for initial wait ! 113: IODelay(1000); // busy-wait for 1ms ! 114: timeout--; ! 115: } ! 116: else { // too long, use IOSleep instead ! 117: int sleep_interval = ATAPI_SLEEP_DURATION; ! 118: if (timeout < sleep_interval) ! 119: sleep_interval = timeout; ! 120: IOSleep(sleep_interval); ! 121: timeout -= sleep_interval; ! 122: } ! 123: } while (timeout > 0); ! 124: if (timeout == 0) ! 125: return IDER_TIMEOUT; ! 126: ! 127: IODelay(1); /* give the drive another 400ns to update Status Register */ ! 128: if (((status & on) == on) && ((~status & off) == off)) ! 129: return IDER_SUCCESS; ! 130: ! 131: return IDER_TIMEOUT; ! 132: } ! 133: ! 134: - (void) printAtapiInfo:(ideIdentifyInfo_t *)ideIdentifyInfo ! 135: Device:(unsigned char)unit ! 136: { ! 137: int i; ! 138: char name[50]; ! 139: char firmware[9]; ! 140: atapiGenConfig_t *atapiGenConfig; ! 141: char *protocolTypeStr, *deviceTypeStr, *cmdDrqTypeStr; ! 142: char *removableStr, *cmdPacketSizeStr; ! 143: ! 144: // IOLog("Capability: %04x\n", ideIdentifyInfo->capabilities); ! 145: ! 146: /* ! 147: * Print drive name with firmware revision number after doing byte swaps. ! 148: */ ! 149: for (i = 0; i < 20; i++) { ! 150: name[2*i] = ideIdentifyInfo->modelNumber[2*i+1]; ! 151: name[2*i+1] = ideIdentifyInfo->modelNumber[2*i]; ! 152: } ! 153: name[40] = '\0'; ! 154: ! 155: for (i = 0; i < 4; i++) { ! 156: firmware[2*i] = ideIdentifyInfo->firmwareRevision[2*i+1]; ! 157: firmware[2*i+1] = ideIdentifyInfo->firmwareRevision[2*i]; ! 158: } ! 159: firmware[8] = '\0'; ! 160: ! 161: for (i = 38; i >= 0; i--) { ! 162: if (name[i] != ' ') ! 163: break; ! 164: } ! 165: strcpy(name+i+2, firmware); ! 166: ! 167: #ifdef DEBUG ! 168: IOLog("%s: %s\n", [self name], name); ! 169: #endif DEBUG ! 170: ! 171: /* ! 172: * This information should be printed since it is not duplicated ! 173: * elsewhere. ! 174: */ ! 175: atapiGenConfig = (atapiGenConfig_t *) &ideIdentifyInfo->genConfig; ! 176: ! 177: #ifdef undef ! 178: IOLog("%s: gen config: %x\n", [self name], ideIdentifyInfo->genConfig); ! 179: #endif undef ! 180: ! 181: if (atapiGenConfig->protocolType == 0 || atapiGenConfig->protocolType == 1) ! 182: protocolTypeStr = "ATA"; ! 183: else if (atapiGenConfig->protocolType == 2) ! 184: protocolTypeStr = "ATAPI"; ! 185: else ! 186: protocolTypeStr = "UNKNOWN PROTOCOL"; ! 187: ! 188: if (atapiGenConfig->deviceType == 0) ! 189: deviceTypeStr = "DIRECT ACCESS"; ! 190: else if (atapiGenConfig->deviceType == 5) ! 191: deviceTypeStr = "CD-ROM"; ! 192: else if (atapiGenConfig->deviceType == 7) ! 193: deviceTypeStr = "OPTICAL"; ! 194: else if (atapiGenConfig->deviceType == 1) ! 195: deviceTypeStr = "TAPE"; ! 196: else ! 197: deviceTypeStr = "UNKNOWN DEVICE TYPE"; ! 198: ! 199: if (atapiGenConfig->cmdDrqType == 0) ! 200: cmdDrqTypeStr = "SLOW DRQ"; ! 201: else if (atapiGenConfig->cmdDrqType == 1) ! 202: cmdDrqTypeStr = "INTR DRQ"; ! 203: else if (atapiGenConfig->cmdDrqType == 2) ! 204: cmdDrqTypeStr = "FAST DRQ"; ! 205: else ! 206: cmdDrqTypeStr = "UNKNOWN DRQ TYPE"; ! 207: ! 208: if (atapiGenConfig->removable == 0) ! 209: removableStr = "NOT REMOVABLE"; ! 210: else if (atapiGenConfig->removable == 1) ! 211: removableStr = "REMOVABLE"; ! 212: ! 213: if (atapiGenConfig->cmdPacketSize == 0) ! 214: cmdPacketSizeStr = "CMD PKT LEN=12"; ! 215: else if (atapiGenConfig->cmdPacketSize == 1) ! 216: cmdPacketSizeStr = "CMD PKT LEN=16"; ! 217: else ! 218: cmdPacketSizeStr = "CMD PKT LEN=UNKNOWN"; ! 219: ! 220: ! 221: IOLog("%s: Drive %d: %s %s (%s, %s, %s)\n", [self name], unit, ! 222: protocolTypeStr, ! 223: deviceTypeStr, cmdDrqTypeStr, ! 224: removableStr, cmdPacketSizeStr); ! 225: ! 226: #ifdef DEBUG ! 227: if (ideIdentifyInfo->capabilities & IDE_CAP_LBA_SUPPORTED) { ! 228: IOLog("%s: LBA supported.\n", [self name]); ! 229: } ! 230: if (ideIdentifyInfo->capabilities & IDE_CAP_IORDY_SUPPORTED) { ! 231: IOLog("%s: IORDY supported.\n", [self name]); ! 232: } ! 233: ! 234: if (ideIdentifyInfo->bufferType != 0) { ! 235: IOLog("%s: buffer type %d, %d sectors.\n", [self name], ! 236: ideIdentifyInfo->bufferType, ideIdentifyInfo->bufferSize); ! 237: } ! 238: ! 239: IOLog("%s: PIO timing cycle: %d ns.\n", [self name], ! 240: ideIdentifyInfo->pioDataTransferCyleTimingMode & ! 241: IDE_PIO_TIMING_MODE_MASK); ! 242: ! 243: if (ideIdentifyInfo->capabilities & IDE_CAP_DMA_SUPPORTED) { ! 244: IOLog("%s: DMA timing cycle: %d ns.\n", [self name], ! 245: ideIdentifyInfo->dmaDataTransferCyleTimingMode & ! 246: IDE_DMA_TIMING_MODE_MASK); ! 247: } ! 248: ! 249: #endif DEBUG ! 250: } ! 251: ! 252: /* ! 253: * There are lots of ATAPI CD-ROMs that shadow the task file register and ! 254: * hence show up as two devices. They also might issue a valid interrupt when ! 255: * ATAPI Identify Device command is sent so we need to really make sure ! 256: * whether the device has data for us. ! 257: */ ! 258: - (atapi_return_t) _atapiIdentifyDevice:(struct vm_map *)client ! 259: addr:(caddr_t)xferAddr ! 260: { ! 261: unsigned int cmd = ATAPI_IDENTIFY_DRIVE; ! 262: unsigned char dh = ADDRESS_MODE_LBA; /* ALWAYS */ ! 263: unsigned char status; ! 264: atapi_return_t rtn; ! 265: ! 266: unsigned int oldTimeout; ! 267: ! 268: #ifdef DEBUG ! 269: IOLog("ATAPI Identify Device\n"); ! 270: #endif DEBUG ! 271: ! 272: rtn = [self atapiWaitStatusBitsFor:ATAPI_MAX_WAIT_FOR_NOTBUSY ! 273: on:0 off:0 alt:NO]; ! 274: if (rtn != IDER_SUCCESS) ! 275: return (rtn); ! 276: ! 277: dh |= _driveNum ? SEL_DRIVE1 : SEL_DRIVE0; ! 278: outb(_ideRegsAddrs.driveSelect, dh); ! 279: ! 280: bzero(xferAddr, IDE_SECTOR_SIZE); ! 281: ! 282: [self enableInterrupts]; ! 283: [self clearInterrupts]; ! 284: ! 285: outb(_ideRegsAddrs.command, ATAPI_IDENTIFY_DRIVE); ! 286: ! 287: /* Wait for BSY bit to clear before reading from AltStatus. ! 288: * We do this to avoid a long interrupt timeout when probing ! 289: * "phantom" CD-ROM drives shadowed by another device on the same ! 290: * IDE connector. ! 291: /* Read from AltStatus instead of Status register to avoid ! 292: * ack'ing any pending interrupts. ! 293: */ ! 294: rtn = [self atapiWaitStatusBitsFor:ATAPI_MAX_WAIT_FOR_NOTBUSY ! 295: on:0 off:0 alt:YES]; ! 296: if (rtn != IDER_SUCCESS) { ! 297: IOLog("%s: Polling BSY bit timed-out\n", [self name]); ! 298: return (rtn); ! 299: } ! 300: ! 301: /* Shadow (false) devices should set the ABORT bit in the ATA ! 302: * Error register. We check for ABORT bit and return an error ! 303: * if that bit is set. ! 304: */ ! 305: if ((inb(_ideRegsAddrs.altStatus) & ERROR) && ! 306: (inb(_ideRegsAddrs.error) & CMD_ABORTED)) { ! 307: // Don't bother waiting for an interrupt, abort immediately. ! 308: #ifdef DEBUG ! 309: IOLog("%s: Phantom ATAPI drive detected. Status:0x%02x\n", ! 310: [self name], inb(_ideRegsAddrs.altStatus)); ! 311: #endif DEBUG ! 312: return IDER_ERROR; ! 313: } ! 314: ! 315: oldTimeout = [self interruptTimeOut]; ! 316: [self setInterruptTimeOut:4000]; // four seconds ! 317: rtn = [self ideWaitForInterrupt:cmd ideStatus:&status]; ! 318: [self setInterruptTimeOut:oldTimeout]; ! 319: ! 320: if (rtn != IDER_SUCCESS) { ! 321: [self getIdeRegisters:NULL Print:"Atapi Identify"]; ! 322: return (rtn); ! 323: } ! 324: ! 325: // Make sure DRQ is set ! 326: rtn = [self atapiWaitStatusBitsFor:ATAPI_MAX_WAIT_FOR_NOTBUSY ! 327: on:DREQUEST off:0 alt:NO]; ! 328: if (rtn != IDER_SUCCESS) ! 329: return (rtn); ! 330: ! 331: /* ! 332: * FIXME: We need to do some sanity check on this data to be really sure ! 333: * that there is an ATAPI device out here. ! 334: */ ! 335: [self xferData:xferAddr read:YES client:client length:IDE_SECTOR_SIZE]; ! 336: return IDER_SUCCESS; ! 337: } ! 338: ! 339: /* ! 340: * Some CD-ROMS (like SONY CDU-55D) fail the first request so we reset the ! 341: * device and retry. ! 342: */ ! 343: #define ATAPI_IDENTIFY_DEVICE_RETRIES 3 ! 344: ! 345: - (atapi_return_t) atapiIdentifyDevice:(struct vm_map *)client ! 346: addr:(caddr_t)xferAddr ! 347: unit:(unsigned char)unit ! 348: { ! 349: int i; ! 350: atapi_return_t ret; ! 351: ! 352: for (i = 0; i < ATAPI_IDENTIFY_DEVICE_RETRIES; i++) { ! 353: ! 354: ret = [self _atapiIdentifyDevice:client addr:xferAddr]; ! 355: if (ret == IDER_SUCCESS) ! 356: break; ! 357: ! 358: /* Reset hardware and try again */ ! 359: [self atapiSoftReset:unit]; ! 360: IOSleep(500); ! 361: if (_ide_debug) { ! 362: IOLog("%s: Drive %d: ATAPI Identify Device failed " ! 363: "(error %d). Retrying..\n", [self name], unit, ret); ! 364: } ! 365: } ! 366: #ifdef DEBUG ! 367: if (i == ATAPI_IDENTIFY_DEVICE_RETRIES) { ! 368: IOLog("%s: FATAL: Drive %d: ATAPI Identify Device.\n", ! 369: [self name], unit); ! 370: } ! 371: #endif DEBUG ! 372: return ret; ! 373: } ! 374: ! 375: - (void) atapiInitParameters:(ideIdentifyInfo_t *)infoPtr ! 376: Device:(unsigned char)unit ! 377: { ! 378: atapiGenConfig_t *atapiGenConfig = ! 379: (atapiGenConfig_t *) &infoPtr->genConfig; ! 380: ! 381: if (atapiGenConfig->cmdPacketSize == 0x01) ! 382: _drives[unit].atapiCmdLen = 16; ! 383: else ! 384: _drives[unit].atapiCmdLen = 12; ! 385: ! 386: /* ! 387: * The command len is 12. However some devices think it is 16 which is ! 388: * actually reserved for SAM compatibility. See page 58, SFF 8020, rev ! 389: * 1.2. This is a workaround. ! 390: */ ! 391: if (_drives[unit].atapiCmdLen != 12) { ! 392: IOLog("%s: ATAPI: command len changed to 12 from %d.\n", ! 393: [self name], _drives[unit].atapiCmdLen); ! 394: _drives[unit].atapiCmdLen = 12; ! 395: } ! 396: ! 397: _drives[unit].atapiCmdDrqType = atapiGenConfig->cmdDrqType; ! 398: } ! 399: ! 400: /* ! 401: * Identify ATAPI device must have been executed first before callling this ! 402: * method. ! 403: */ ! 404: - (unsigned char) atapiCommandPacketSize:(unsigned char)unit ! 405: { ! 406: if (unit < MAX_IDE_DRIVES) ! 407: return _drives[unit].atapiCmdLen; ! 408: else ! 409: return 0; ! 410: } ! 411: ! 412: ! 413: /* ! 414: * The amount of time in milliseconds it takes for an ATAPI device to post ! 415: * its signature after a reset. Some CD-ROMs take a long time to respond. Do ! 416: * not decrease it without testing with various makes of ATAPI devices. ! 417: */ ! 418: #define ATAPI_RESET_DELAY 2500 ! 419: ! 420: - (atapi_return_t) atapiSoftReset:(unsigned char)unit ! 421: { ! 422: unsigned char dh = ADDRESS_MODE_LBA; /* ALWAYS */ ! 423: ! 424: #ifdef DEBUG ! 425: IOLog("%s: atapiSoftReset:device %d\n", [self name], unit); ! 426: #endif DEBUG ! 427: ! 428: dh |= unit ? SEL_DRIVE1 : SEL_DRIVE0; ! 429: ! 430: outb(_ideRegsAddrs.driveSelect, dh); ! 431: outb(_ideRegsAddrs.command, ATAPI_SOFT_RESET); ! 432: ! 433: IOSleep(50); /* Enough time to assert busy */ ! 434: ! 435: if ([self atapiWaitStatusBitsFor:ATAPI_RESET_DELAY on:0 off:0 alt:NO] == ! 436: IDER_SUCCESS) ! 437: return IDER_SUCCESS; ! 438: ! 439: #ifdef DEBUG ! 440: IOLog("%s: atapiSoftReset: FAILED. Status = %x\n", [self name], status); ! 441: #endif DEBUG ! 442: ! 443: return IDER_ERROR; ! 444: } ! 445: ! 446: /* ! 447: * Method: issuePacketCommand ! 448: * ! 449: * This method will issue the Packet Command code (0xA0) to the command ! 450: * register. Then wait for an interrupt (INT DRQ devices only) and poll ! 451: * the Ireason/Status for: ! 452: * ! 453: * BSY = 0 ! 454: * CoD = 1 ! 455: * IO = 0 ! 456: * ! 457: * We assume that the task file has been initialized prior to calling ! 458: * this method. ! 459: * ! 460: * Returns: ! 461: * IDER_SUCCESS - DRQ is set and ready to send the 12-byte command. ! 462: * IDER_ERROR - Abort and send a ATAPI soft reset. ! 463: */ ! 464: #define MAX_DRQ_WAIT (100 * 1000 * 5) // 5 second wait ! 465: ! 466: - (atapi_return_t) issuePacketCommand ! 467: { ! 468: int i; ! 469: unsigned char interruptReason; ! 470: unsigned char status; ! 471: ! 472: #ifdef DEBUG ! 473: IOLog("%s: issuePacketCommand\n", [self name]); ! 474: #endif DEBUG ! 475: ! 476: /* ! 477: * Send the packet command. ! 478: */ ! 479: outb(_ideRegsAddrs.command, ATAPI_PACKET); ! 480: ! 481: /* ! 482: * Some devices might have interrupted so we should take care of that ! 483: * first. ! 484: */ ! 485: if (_drives[_driveNum].atapiCmdDrqType == ATAPI_CMD_DRQ_INT) { ! 486: atapi_return_t rtn; ! 487: rtn = [self ideWaitForInterrupt:ATAPI_PACKET ideStatus:&status]; ! 488: if (rtn != IDER_SUCCESS) ! 489: return rtn; ! 490: } ! 491: ! 492: /* ! 493: * Wait till we get okay from the device. ! 494: */ ! 495: IODelay(1); ! 496: for (i = 0; i < MAX_DRQ_WAIT; i++) { ! 497: interruptReason = inb(_ideRegsAddrs.interruptReason); ! 498: status = inb(_ideRegsAddrs.status); ! 499: ! 500: if (!(status & BUSY) && ! 501: (interruptReason & CMD_OR_DATA) && ! 502: !(interruptReason & IO_DIRECTION)) ! 503: break; ! 504: IODelay(10); ! 505: } ! 506: ! 507: if (i == MAX_DRQ_WAIT) { ! 508: IOLog("%s: ATAPI Drive %d: Invalid Interrupt Reason: %x.\n", ! 509: [self name], _driveNum, interruptReason); ! 510: return IDER_ERROR; ! 511: } ! 512: ! 513: /* ! 514: * Now DRQ should be set. ! 515: */ ! 516: status = inb(_ideRegsAddrs.status); ! 517: if (status & DREQUEST) { ! 518: return IDER_SUCCESS; ! 519: } ! 520: ! 521: IOLog("%s: ATAPI Drive %d: DRQ not set: %x\n", ! 522: [self name], _driveNum, status); ! 523: return IDER_ERROR; ! 524: } ! 525: ! 526: /* ! 527: * Method: sendAtapiCommand:cmdLen: ! 528: * ! 529: * Send the ATAPI command packet bytes. ! 530: * Note that the command is sent out as words in little endian format. ! 531: */ ! 532: - (void) sendAtapiCommand:(unsigned char *)atapiCmd ! 533: cmdLen:(unsigned char)len ! 534: { ! 535: int i; ! 536: ! 537: for (i = 0; i < len/2; i++) { ! 538: outw(_ideRegsAddrs.data, atapiCmd[2*i+1] << 8 | atapiCmd[2*i]); ! 539: } ! 540: } ! 541: ! 542: #define MAX_SENDPACKET_RETRIES 3 ! 543: #define MAX_BUSY_WAIT (1000*100) ! 544: ! 545: /* ! 546: * Transfer data between host and the ATAPI device through PIO. ! 547: * ! 548: * Before calling this method, the packet command and command data bytes ! 549: * have been issued to the drive. This method will transfer data until ! 550: * DRQ = 0, or if the maximum transfer count is reached, whichever ! 551: * occurs first. This method will require an interrupt for every iteration ! 552: * of the loop. ! 553: */ ! 554: - (sc_status_t) atapiPIODataTransfer:(atapiIoReq_t *)atapiIoReq ! 555: buffer:(void *)buffer ! 556: client:(struct vm_map *)client ! 557: { ! 558: int i; ! 559: atapi_return_t rtn; ! 560: unsigned char status; ! 561: unsigned int offset; ! 562: unsigned char cmd = atapiIoReq->atapiCmd[0]; ! 563: unsigned int bytes; ! 564: ! 565: /* ! 566: * Zero the counters. ! 567: */ ! 568: atapiIoReq->bytesTransferred = 0; ! 569: offset = 0; ! 570: ! 571: for (;;) { ! 572: ! 573: /* At this point, the drive is executing the packet command. ! 574: * For commands such as FORMAT_UNIT (0x04), the may take a very ! 575: * long time. Probably much longer than IDE_INTR_TIMEOUT. ! 576: * ! 577: * To guard against those cases, we take the maximum of ! 578: * IDE_INTR_TIMEOUT vs. scsiReq.timeout. ! 579: */ ! 580: if (atapiIoReq->timeout > IDE_INTR_TIMEOUT) { ! 581: u_int current_timeout = [self interruptTimeOut]; ! 582: ! 583: //IOLog("using SCSI timeout:%d\n", atapiIoReq->timeout); ! 584: [self setInterruptTimeOut:atapiIoReq->timeout]; ! 585: rtn = [self ideWaitForInterrupt:cmd ideStatus:&status]; ! 586: [self setInterruptTimeOut:current_timeout]; ! 587: } ! 588: else { ! 589: rtn = [self ideWaitForInterrupt:cmd ideStatus:&status]; ! 590: } ! 591: ! 592: if (rtn != IDER_SUCCESS) { ! 593: IOLog("%s: FATAL: ATAPI Drive: %d Command %x failed.\n", ! 594: [self name], _driveNum, atapiIoReq->atapiCmd[0]); ! 595: [self getIdeRegisters:NULL Print:"ATAPI Command"]; ! 596: [self atapiSoftReset:_driveNum]; ! 597: atapiIoReq->scsiStatus = STAT_CHECK; ! 598: return SR_IOST_CHKSNV; ! 599: } ! 600: ! 601: /* ! 602: * This is stupid but the Chinon drive fires off an interrupt first ! 603: * and then updates the status register. It appears that any drive ! 604: * based on Western Digital chipset will do this. At any rate, this ! 605: * code is harmless and should be left here. ! 606: */ ! 607: for (i = 0; i < MAX_BUSY_WAIT; i++) { ! 608: if (status & BUSY) ! 609: IODelay(10); ! 610: else ! 611: break; ! 612: status = inb(_ideRegsAddrs.status); ! 613: } ! 614: ! 615: /* ! 616: * If DRQ == 0 then host has terminated the command. ! 617: */ ! 618: if (!(status & DREQUEST)) { ! 619: /* ! 620: * Check for command completion status. ! 621: */ ! 622: if (status & ERROR) { ! 623: #ifdef DEBUG ! 624: // Don't complain for TEST UNIT READY command ! 625: if (cmd != 0x00) { ! 626: [self dumpStatus: atapiIoReq]; ! 627: } ! 628: IOLog("%s: ATAPI command %x failed. " ! 629: "Error: %x Status: %x\n", [self name], ! 630: atapiIoReq->atapiCmd[0], ! 631: inb(_ideRegsAddrs.error), status); ! 632: #endif DEBUG ! 633: ! 634: atapiIoReq->scsiStatus = STAT_CHECK; ! 635: return SR_IOST_CHKSNV; ! 636: } ! 637: else { ! 638: #ifdef DEBUG ! 639: IOLog("%s: Comamnd %x completed. status %x\n", ! 640: [self name], atapiIoReq->atapiCmd[0], status); ! 641: #endif DEBUG ! 642: atapiIoReq->scsiStatus = STAT_GOOD; ! 643: return SR_IOST_GOOD; ! 644: } ! 645: } ! 646: ! 647: /* ! 648: * Command is not completed. We need to transfer data as requested by ! 649: * the device. ! 650: */ ! 651: bytes = inb(_ideRegsAddrs.byteCountHigh) << 8 | ! 652: inb(_ideRegsAddrs.byteCountLow); ! 653: ! 654: #ifdef DEBUG ! 655: IOLog("%s: ATAPI Drive %d: completed: %x, request: %x max: %x\n", ! 656: [self name], _driveNum, atapiIoReq->bytesTransferred, ! 657: bytes, atapiIoReq->maxTransfer); ! 658: #endif DEBUG ! 659: ! 660: /* ! 661: * If the device requests more data to be transferred than required ! 662: * by the command protocol, then we should transfer null data. ! 663: */ ! 664: ! 665: if (atapiIoReq->bytesTransferred + bytes > atapiIoReq->maxTransfer) { ! 666: ! 667: IOLog("%s: ATAPI Drive %d: " ! 668: "ERROR: Transfer limit (%x bytes) exceeded\n", ! 669: [self name], _driveNum, atapiIoReq->maxTransfer); ! 670: ! 671: IOLog("%s: Bytes already transfered: %x, next request: %x\n", ! 672: [self name], atapiIoReq->bytesTransferred, bytes); ! 673: ! 674: [self dumpStatus: atapiIoReq]; ! 675: ! 676: /* ! 677: * This thing is probably hosed but let's do the best we can. ! 678: */ ! 679: { ! 680: int diff = atapiIoReq->maxTransfer-atapiIoReq->bytesTransferred; ! 681: IOLog("%s: Transferring %x bytes instead of %x\n", ! 682: [self name], diff, bytes); ! 683: [self xferData:buffer+offset read:atapiIoReq->read ! 684: client:client length:diff]; ! 685: atapiIoReq->bytesTransferred += diff; ! 686: offset += diff; ! 687: [self atapiSoftReset:_driveNum]; // reset hardware as well ! 688: } ! 689: ! 690: atapiIoReq->scsiStatus = STAT_GOOD; ! 691: return SR_IOST_GOOD; ! 692: #if 0 ! 693: /* this was old behavior */ ! 694: atapiIoReq->scsiStatus = STAT_CHECK; ! 695: return SR_IOST_CMDREJ; ! 696: #endif 0 ! 697: } ! 698: ! 699: /* ! 700: * Now transfer data between device and memory. ! 701: */ ! 702: [self xferData:buffer+offset read:atapiIoReq->read client:client ! 703: length:bytes]; ! 704: ! 705: atapiIoReq->bytesTransferred += bytes; ! 706: offset += bytes; ! 707: } ! 708: ! 709: /* ! 710: * Will never get here. ! 711: */ ! 712: atapiIoReq->scsiStatus = STAT_GOOD; ! 713: return SR_IOST_GOOD; ! 714: } ! 715: ! 716: /* ! 717: * Prints command and result in case of error. ! 718: */ ! 719: - (void) dumpStatus:(atapiIoReq_t *)atapiIoReq ! 720: { ! 721: int i; ! 722: ! 723: IOLog("%s: Failed command: drive: %d lun: %d len: %d read: %d\n", ! 724: [self name], ! 725: atapiIoReq->drive, atapiIoReq->lun, atapiIoReq->cmdLen, ! 726: atapiIoReq->read); ! 727: IOLog("%s: Failed command: ", [self name]); ! 728: for (i = 0; i < atapiIoReq->cmdLen; i++) ! 729: IOLog("%x ", atapiIoReq->atapiCmd[i]); ! 730: IOLog("\n"); ! 731: ! 732: [self getIdeRegisters:NULL Print:"dumpStatus"]; ! 733: } ! 734: ! 735: /* ! 736: * Execute the ATAPI command specified in 'atapiIoReq'. ! 737: */ ! 738: - (sc_status_t) atapiExecuteCmd:(atapiIoReq_t *)atapiIoReq ! 739: buffer : (void *)buffer ! 740: client : (struct vm_map *)client ! 741: { ! 742: int i; ! 743: atapi_return_t rtn; ! 744: unsigned char dh = ADDRESS_MODE_LBA; /* ALWAYS */ ! 745: sc_status_t sc_ret; ! 746: unsigned char cmd = atapiIoReq->atapiCmd[0]; ! 747: BOOL useDMA = NO; ! 748: ! 749: /* ! 750: * Reject command if there are no ATAPI devices detected. ! 751: */ ! 752: if ((atapiIoReq->drive >= MAX_IDE_DRIVES) || ! 753: (atapiIoReq->lun != 0) || ! 754: ([self isAtapiDevice:atapiIoReq->drive] == NO)) { ! 755: return SR_IOST_SELTO; ! 756: } ! 757: ! 758: /* Now execute the SCSI command. */ ! 759: ! 760: #ifdef DEBUG ! 761: /* Print out the command received. */ ! 762: IOLog("%s: atapiExecuteCmd: drive: %d lun: %d len: %d read %d\n", ! 763: [self name], atapiIoReq->drive, atapiIoReq->lun, atapiIoReq->cmdLen, ! 764: atapiIoReq->read); ! 765: IOLog("%s: Command: ", [self name]); ! 766: if (atapiIoReq->atapiCmd[4] == 0x41) ! 767: atapiIoReq->atapiCmd[4] = 0x24; ! 768: for (i = 0; i < atapiIoReq->cmdLen; i++) ! 769: IOLog("%x ", atapiIoReq->atapiCmd[i]); ! 770: IOLog("\n"); ! 771: //IOBreakToDebugger(); ! 772: #endif DEBUG ! 773: ! 774: _driveNum = atapiIoReq->drive; ! 775: ! 776: /* ! 777: * We are very particular on the type of commands that we allow ! 778: * DMA to be used. ! 779: * ! 780: * 1. It must be a Read/Write data command. ! 781: * 2. Buffer must be 4-byte aligned. ! 782: # 3. The drive must be DMA capable. ! 783: */ ! 784: useDMA = ((_drives[_driveNum].transferType != IDE_TRANSFER_PIO) && ! 785: (((vm_offset_t)buffer & (PIIX_BUF_ALIGN - 1)) == 0) && ! 786: ((cmd == 0x28) || (cmd == 0xa8) || // read 10 and read 12 ! 787: (cmd == 0x2a) || (cmd == 0xaa) || // write 10 and write 12 ! 788: (cmd == 0x2f) || (cmd == 0x2e))); // write and verify ! 789: ! 790: for (i = 0; i < MAX_SENDPACKET_RETRIES; i++) { ! 791: ! 792: /* ! 793: * Select the drive. Make sure the BSY bit is off before ! 794: * changing the drv bit. ! 795: */ ! 796: [self atapiWaitStatusBitsFor:ATAPI_MAX_WAIT_FOR_NOTBUSY ! 797: on:0 off:0 alt:NO]; ! 798: dh |= _driveNum ? SEL_DRIVE1 : SEL_DRIVE0; ! 799: outb(_ideRegsAddrs.driveSelect, dh); ! 800: ! 801: /* ! 802: * Wait for BSY = 0, DRQ = 0. ! 803: */ ! 804: rtn = [self atapiWaitStatusBitsFor:ATAPI_MAX_WAIT_FOR_NOTBUSY ! 805: on:0 off:DREQUEST alt:NO]; ! 806: if (rtn != IDER_SUCCESS) { ! 807: IOLog("%s: ATAPI Drive %d: Not Ready For Packet command.\n", ! 808: [self name], _driveNum); ! 809: [self atapiSoftReset:_driveNum]; ! 810: continue; ! 811: } ! 812: ! 813: /* ! 814: * Send our preferred data transfer size (2048 bytes). ! 815: */ ! 816: outb(_ideRegsAddrs.byteCountLow, 0x00); ! 817: outb(_ideRegsAddrs.byteCountHigh, 0x08); ! 818: ! 819: /* ! 820: * We will use PIO for data transfers. ! 821: */ ! 822: if (useDMA == YES) ! 823: outb(_ideRegsAddrs.features, 1); ! 824: else ! 825: outb(_ideRegsAddrs.features, 0); ! 826: ! 827: [self enableInterrupts]; ! 828: [self clearInterrupts]; ! 829: ! 830: /* ! 831: * First tell the ATAPI device that we are going to send it a packet ! 832: * command. If this command fails the ATAPI device needs to be reset. ! 833: */ ! 834: if ([self issuePacketCommand] == IDER_SUCCESS) { ! 835: break; ! 836: } ! 837: ! 838: IOLog("%s: ATAPI Drive %d: Packet command failed. Retrying...\n", ! 839: [self name], _driveNum); ! 840: [self atapiSoftReset:_driveNum]; ! 841: } ! 842: ! 843: /* ! 844: * Are we hosed? ! 845: */ ! 846: if (i == MAX_SENDPACKET_RETRIES) { ! 847: atapiIoReq->scsiStatus = STAT_CHECK; ! 848: IOLog("%s: ATAPI Drive %d: FATAL: Packet command.\n", ! 849: [self name], _driveNum); ! 850: return SR_IOST_CMDREJ; ! 851: } ! 852: ! 853: // [self clearInterrupts]; ! 854: ! 855: /* ! 856: * Send the ATAPI command packet bytes (usually 12-bytes) to the device. ! 857: */ ! 858: [self sendAtapiCommand:atapiIoReq->atapiCmd cmdLen:atapiIoReq->cmdLen]; ! 859: ! 860: /* ! 861: * Peform data transfer (if any) and return the result code. ! 862: */ ! 863: if (useDMA == YES) ! 864: sc_ret = [self performATAPIDMA:atapiIoReq buffer:buffer client:client]; ! 865: else ! 866: sc_ret = [self atapiPIODataTransfer:atapiIoReq buffer:buffer ! 867: client:client]; ! 868: ! 869: return sc_ret; ! 870: } ! 871: ! 872: #if 0 ! 873: #define ATAPI_SET_CDROM_SPEED 0xbb ! 874: ! 875: /* ! 876: * Doesn't seem to make any difference. ! 877: */ ! 878: - (void)setMaxSpeedForATAPICDROM:(unsigned char)unit ! 879: { ! 880: atapiIoReq_t atapiIoReq; ! 881: ! 882: bzero(&atapiIoReq, sizeof(atapiIoReq_t)); ! 883: ! 884: atapiIoReq.cmdLen = [self atapiCommandPacketSize:unit]; ! 885: atapiIoReq.drive = unit; ! 886: ! 887: atapiIoReq.atapiCmd[0] = ATAPI_SET_CDROM_SPEED; ! 888: atapiIoReq.atapiCmd[2] = 0xff; ! 889: atapiIoReq.atapiCmd[3] = 0xff; ! 890: ! 891: (void) [self atapiExecuteCmd:&atapiIoReq ! 892: buffer:NULL client:(struct vm_map *)IOVmTaskSelf()]; ! 893: } ! 894: #endif 0 ! 895: ! 896: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.