![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ATADiskInternal.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvATADisk|
Return to ATADiskInternal.m CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvATADisk |
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.1 (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: /* ! 26: * Copyright 1997-1998 by Apple Computer, Inc., All rights reserved. ! 27: * Copyright 1994-1997 NeXT Software, Inc., All rights reserved. ! 28: * ! 29: * ATADiskInternal.m - internal IDE/ATA disk methods. ! 30: * ! 31: * HISTORY ! 32: * ! 33: * 04-Mar-1996 Rakesh Dubey at NeXT ! 34: * Modified so that no memory is allocated at run-time. ! 35: * ! 36: * 07-Jul-1994 Rakesh Dubey at NeXT ! 37: * Created from original driver written by David Somayajulu. ! 38: */ ! 39: ! 40: #import <driverkit/return.h> ! 41: #import <driverkit/driverTypes.h> ! 42: #import "ATADiskInternal.h" ! 43: #import "ATADiskKernel.h" ! 44: #import <driverkit/kernelDiskMethods.h> ! 45: #import <driverkit/generalFuncs.h> ! 46: #import <machkit/NXLock.h> ! 47: #import <driverkit/align.h> ! 48: #import <sys/systm.h> ! 49: ! 50: IOReturn iderToIo(ide_return_t); ! 51: ! 52: //#define DEBUG ! 53: ! 54: @implementation ATADisk(Internal) ! 55: ! 56: /* ! 57: * Print information about the disk and fill up the ideDriveName field. ! 58: */ ! 59: -(void)printInfo:(ideIdentifyInfo_t *)ideIdentifyInfo unit:(unsigned int)unit ! 60: { ! 61: int i; ! 62: char name[50]; ! 63: char firmware[9]; ! 64: ! 65: /* ! 66: * Print drive name with firmware revision number after doing byte swaps. ! 67: */ ! 68: for (i = 0; i < 20; i++) { ! 69: name[2*i] = ideIdentifyInfo->modelNumber[2*i+1]; ! 70: name[2*i+1] = ideIdentifyInfo->modelNumber[2*i]; ! 71: } ! 72: name[40] = '\0'; ! 73: ! 74: for (i = 0; i < 4; i++) { ! 75: firmware[2*i] = ideIdentifyInfo->firmwareRevision[2*i+1]; ! 76: firmware[2*i+1] = ideIdentifyInfo->firmwareRevision[2*i]; ! 77: } ! 78: firmware[8] = '\0'; ! 79: ! 80: for (i = 38; i >= 0; i--) { ! 81: if (name[i] != ' ') ! 82: break; ! 83: } ! 84: strcpy(name+i+2, firmware); ! 85: ! 86: ! 87: IOLog("%s: %s\n", [self name], name); ! 88: ! 89: /* ! 90: * The drive name is limited to 32 characters and we don't want firmware ! 91: * version in there. ! 92: */ ! 93: name[i+1] = '\0'; name[31] = '\0'; ! 94: strcpy(_ideDriveName, name); ! 95: ! 96: /* ! 97: * Other diagnostic information. All of this can also be obtained via ! 98: * /usr/etc/idemodes ! 99: */ ! 100: #if 0 ! 101: IOLog("%s: PIO timing cycle: %d ns (mode %d).\n", [self name], ! 102: ideIdentifyInfo->pioDataTransferCyleTimingMode & ! 103: IDE_PIO_TIMING_MODE_MASK, ! 104: [_cntrlr getTransferModeFromCycleTime:ideIdentifyInfo ! 105: transferType:IDE_TRANSFER_PIO]); ! 106: ! 107: if (ideIdentifyInfo->capabilities & IDE_CAP_DMA_SUPPORTED) { ! 108: IOLog("%s: DMA timing cycle: %d ns (mode %d).\n", [self name], ! 109: ideIdentifyInfo->dmaDataTransferCyleTimingMode & ! 110: IDE_DMA_TIMING_MODE_MASK, ! 111: [_cntrlr getTransferModeFromCycleTime:ideIdentifyInfo ! 112: transferType:IDE_TRANSFER_SW_DMA]); ! 113: } ! 114: if (ideIdentifyInfo->capabilities & IDE_CAP_LBA_SUPPORTED) { ! 115: IOLog("%s: LBA supported.\n", [self name]); ! 116: } ! 117: if (ideIdentifyInfo->capabilities & IDE_CAP_IORDY_SUPPORTED) { ! 118: IOLog("%s: IORDY supported.\n", [self name]); ! 119: } ! 120: ! 121: if (ideIdentifyInfo->bufferType != 0) { ! 122: IOLog("%s: buffer type %d of %d sectors.\n", [self name], ! 123: ideIdentifyInfo->bufferType, ideIdentifyInfo->bufferSize); ! 124: } ! 125: #endif ! 126: } ! 127: ! 128: /* ! 129: * Device-specific initialization. We just do enough here to do some I/O and ! 130: * to find out if the requested drive is present. This function is "reusable" ! 131: * for a given instance of ATADisk; initResources must have been called ! 132: * exactly once prior to any use of this method. Returns YES if drive is ! 133: * present, else NO. ! 134: */ ! 135: - (BOOL)ideDiskInit:(unsigned int)diskUnit target:(unsigned int)unit ! 136: { ! 137: char dev_name[10]; ! 138: unsigned total_sectors; ! 139: ideIdentifyInfo_t *ideIdentifyInfo; ! 140: #ifdef NO_ATA_RUNTIME_MEMORY_ALLOCATION ! 141: int i; ! 142: ideBuf_t *ideBuf; ! 143: #endif NO_ATA_RUNTIME_MEMORY_ALLOCATION ! 144: ! 145: ! 146: queue_init(&_ioQueueDisk); ! 147: queue_init(&_ioQueueNodisk); ! 148: ! 149: ! 150: #ifdef NO_ATA_RUNTIME_MEMORY_ALLOCATION ! 151: ! 152: /* Set up a queue of ideBufs */ ! 153: queue_init(&_ideBufQueue); ! 154: _ideBufLock = [NXLock new]; ! 155: [_ideBufLock lock]; ! 156: ! 157: ! 158: for (i = 0; i < MAX_NUM_ATABUF; i++) { ! 159: ideBuf = &_ideBufPool[i]; ! 160: ideBuf->waitLock = [NXConditionLock alloc]; ! 161: [ideBuf->waitLock initWith:NO]; ! 162: queue_enter(&_ideBufQueue, ideBuf, ideBuf_t *, bufLink); ! 163: } ! 164: [_ideBufLock unlock]; ! 165: ! 166: #if 0 // XXX ! 167: if (_ide_debug) { ! 168: IOLog("NO_ATA_RUNTIME_MEMORY_ALLOCATION\n"); ! 169: } ! 170: #endif ! 171: ! 172: #endif NO_ATA_RUNTIME_MEMORY_ALLOCATION ! 173: ! 174: _driveNum = unit; ! 175: ! 176: /* Skip ATAPI devices. */ ! 177: if ([_cntrlr isAtapiDevice:unit] == YES) { ! 178: return NO; ! 179: } ! 180: ! 181: _ideInfo = *[_cntrlr getIdeDriveInfo:unit]; ! 182: if (_ideInfo.type == 0) { ! 183: //IOLog("ATADisk: Bogus info for disk %d target %d.\n", diskUnit, unit); ! 184: return NO; ! 185: } ! 186: ! 187: sprintf(dev_name, "hd%d", diskUnit); ! 188: [self setUnit:diskUnit]; ! 189: [self setName:dev_name]; ! 190: ! 191: ideIdentifyInfo = [_cntrlr getIdeIdentifyInfo:unit]; ! 192: [self printInfo:ideIdentifyInfo unit:unit]; ! 193: ! 194: /* ! 195: * Cache optimal data transfer command. ! 196: */ ! 197: ! 198: if ([_cntrlr getMultiSectorValue:unit] > 0) ! 199: { ! 200: _ideReadCommandPIO = IDE_READ_MULTIPLE; ! 201: _ideWriteCommandPIO = IDE_WRITE_MULTIPLE; ! 202: } ! 203: else ! 204: { ! 205: _ideReadCommandPIO = IDE_READ; ! 206: _ideWriteCommandPIO = IDE_WRITE; ! 207: } ! 208: ! 209: if ( [_cntrlr isDmaSupported:unit] ) ! 210: { ! 211: IOLog("%s: using DMA transfers.\n", [self name]); ! 212: _ideReadCommand = IDE_READ_DMA; ! 213: _ideWriteCommand = IDE_WRITE_DMA; ! 214: } ! 215: else ! 216: { ! 217: IOLog("%s: using PIO transfers.\n", [self name]); ! 218: _ideReadCommand = _ideReadCommandPIO; ! 219: _ideWriteCommand = _ideWriteCommandPIO; ! 220: } ! 221: ! 222: _ideControllerType = [_cntrlr getControllerType]; ! 223: ! 224: if ([self initIdeDrive] != IO_R_SUCCESS) { ! 225: return NO; ! 226: } ! 227: ! 228: total_sectors = _ideInfo.total_sectors; ! 229: ! 230: [self setRemovable:NO]; ! 231: [self setBlockSize:_ideInfo.bytes_per_sector]; ! 232: [self setDiskSize:total_sectors]; ! 233: [self setFormattedInternal:YES]; ! 234: [self setLastReadyState: IO_Ready]; ! 235: ! 236: if (_ideDriveName[0] == '\0') { ! 237: sprintf(_ideDriveName, "IDE Drive Type %d", _ideInfo.type); ! 238: } ! 239: [self setDriveName:_ideDriveName]; ! 240: ! 241: [super init]; ! 242: ! 243: return YES; ! 244: } ! 245: ! 246: /* ! 247: * One-time only initialization. We have only one thread per disk since ATA ! 248: * disks do not support command queueing. ! 249: */ ! 250: #ifdef DEBUG ! 251: void *ideThreadPtr; ! 252: #endif DEBUG ! 253: ! 254: - initResources : controller ! 255: { ! 256: _cntrlr = controller; ! 257: _ioQLock = [NXConditionLock alloc]; ! 258: [_ioQLock initWith:NO_WORK_AVAILABLE]; ! 259: #ifdef DEBUG ! 260: ideThreadPtr = IOForkThread((IOThreadFunc)ideThread, self); ! 261: #else DEBUG ! 262: IOForkThread((IOThreadFunc)ideThread, self); ! 263: #endif DEBUG ! 264: return self; ! 265: } ! 266: ! 267: /* ! 268: * Free up local resources. ! 269: */ ! 270: - free ! 271: { ! 272: /* ! 273: * First kill the I/O thread, then free alloc'd instance variables. ! 274: */ ! 275: ideBuf_t *ideBuf; ! 276: int i; ! 277: ! 278: ideBuf = [self allocIdeBuf:NULL]; ! 279: ideBuf->command = IDEC_THREAD_ABORT; ! 280: ideBuf->buf = NULL; ! 281: ideBuf->needsDisk = 0; ! 282: ideBuf->oneWay = 0; ! 283: [self enqueueIdeBuf:ideBuf]; ! 284: ! 285: [self freeIdeBuf:ideBuf]; ! 286: [_ioQLock free]; ! 287: ! 288: #ifdef NO_ATA_RUNTIME_MEMORY_ALLOCATION ! 289: if (_ideBufLock) ! 290: [_ideBufLock free]; ! 291: ! 292: for (i = 0; i < MAX_NUM_ATABUF; i++) { ! 293: if (_ideBufPool[i].waitLock) ! 294: [_ideBufPool[i].waitLock free]; ! 295: } ! 296: #endif NO_ATA_RUNTIME_MEMORY_ALLOCATION ! 297: ! 298: return ([super free]); ! 299: } ! 300: ! 301: /* ! 302: * Allocate and free IdeBuf_t's. ! 303: */ ! 304: ! 305: #ifdef NO_ATA_RUNTIME_MEMORY_ALLOCATION ! 306: - (ideBuf_t *) allocIdeBuf:(void *)pending ! 307: { ! 308: ideBuf_t *ideBuf; ! 309: id waitLock; ! 310: ! 311: while (1) { ! 312: [_ideBufLock lock]; ! 313: if (!queue_empty(&_ideBufQueue)) ! 314: break; ! 315: [_ideBufLock unlock]; ! 316: IOSleep(10); // the system is overloaded ! 317: } ! 318: ! 319: ASSERT(queue_empty(&_ideBufQueue) != 0); ! 320: ideBuf = (ideBuf_t *) queue_first(&_ideBufQueue); ! 321: ASSERT(ideBuf != 0); ! 322: queue_remove(&_ideBufQueue, ideBuf, ideBuf_t *, bufLink); ! 323: ! 324: waitLock = ideBuf->waitLock; ! 325: bzero(ideBuf, sizeof(ideBuf_t)); ! 326: ideBuf->waitLock = waitLock; ! 327: [ideBuf->waitLock initWith:NO]; ! 328: ! 329: if (pending != NULL) ! 330: ideBuf->pending = pending; ! 331: ! 332: [_ideBufLock unlock]; ! 333: return (ideBuf); ! 334: } ! 335: ! 336: - (void)freeIdeBuf:(ideBuf_t *) ideBuf ! 337: { ! 338: [_ideBufLock lock]; ! 339: queue_enter(&_ideBufQueue, ideBuf, ideBuf_t *, bufLink); ! 340: ASSERT(queue_empty(&_ideBufQueue) != 0); ! 341: [_ideBufLock unlock]; ! 342: } ! 343: ! 344: #else NO_ATA_RUNTIME_MEMORY_ALLOCATION ! 345: ! 346: - (ideBuf_t *) allocIdeBuf:(void *)pending ! 347: { ! 348: ideBuf_t *ideBuf = IOMalloc(sizeof(ideBuf_t)); ! 349: ! 350: bzero(ideBuf, sizeof(ideBuf_t)); ! 351: if (pending == NULL) { ! 352: ideBuf->waitLock = [NXConditionLock alloc]; ! 353: [ideBuf->waitLock initWith:NO]; ! 354: } else ! 355: ideBuf->pending = pending; ! 356: return (ideBuf); ! 357: } ! 358: ! 359: - (void)freeIdeBuf:(ideBuf_t *) ideBuf ! 360: { ! 361: if (ideBuf->waitLock) { ! 362: [ideBuf->waitLock free]; ! 363: } ! 364: IOFree(ideBuf, sizeof(ideBuf_t)); ! 365: } ! 366: #endif NO_ATA_RUNTIME_MEMORY_ALLOCATION ! 367: ! 368: - (IOReturn) ideXfrIoReq:(ideIoReq_t *)ideIoReq ! 369: { ! 370: ideBuf_t *ideBuf; ! 371: IOReturn rtn; ! 372: ! 373: ideBuf = [self allocIdeBuf:NULL]; ! 374: ideBuf->command = IDEC_IOREQ; ! 375: ideBuf->ideIoReq = ideIoReq; ! 376: ideBuf->block = 0; ! 377: ideBuf->blockCnt = 0; ! 378: ideBuf->buf = 0; ! 379: ideBuf->client = 0; /* it picked up from ideIoReq */ ! 380: ideBuf->needsDisk = 1; ! 381: ideBuf->bytesXfr = 0; ! 382: ideBuf->oneWay = 0; ! 383: rtn = [self enqueueIdeBuf:ideBuf]; ! 384: [self freeIdeBuf:ideBuf]; ! 385: ! 386: return (rtn); ! 387: } ! 388: ! 389: - (IOReturn) initIdeDrive ! 390: { ! 391: IOReturn rtn; ! 392: ideBuf_t *ideBuf; ! 393: ! 394: ideBuf = [self allocIdeBuf:NULL]; ! 395: ideBuf->command = IDEC_INIT; ! 396: ideBuf->block = 0; ! 397: ideBuf->blockCnt = 0; ! 398: ideBuf->buf = 0; ! 399: ideBuf->client = 0; ! 400: ideBuf->needsDisk = 1; ! 401: ideBuf->bytesXfr = 0; ! 402: ideBuf->oneWay = 0; ! 403: rtn = [self enqueueIdeBuf:ideBuf]; ! 404: [self freeIdeBuf:ideBuf]; ! 405: ! 406: return(rtn); ! 407: } ! 408: ! 409: /* ! 410: * Common read/write routine. ! 411: */ ! 412: - (IOReturn) deviceRwCommon:(IdeCmd_t) command ! 413: block:(u_int) deviceBlock ! 414: length:(u_int) length ! 415: buffer:(void *)buffer ! 416: client:(vm_task_t) client ! 417: pending:(void *)pending ! 418: actualLength:(u_int *) actualLength ! 419: { ! 420: ideBuf_t *ideBuf; ! 421: IOReturn rtn; ! 422: u_int blocksReq; ! 423: u_int block_size; ! 424: u_int dev_size; ! 425: ! 426: rtn = [self isDiskReady:NO]; ! 427: ! 428: switch (rtn) { ! 429: case IO_R_SUCCESS: ! 430: break; ! 431: case IO_R_NO_DISK: ! 432: return (rtn); ! 433: default: ! 434: IOLog("%s deviceRwCommon: bogus return from isDiskReady (%s)\n", ! 435: [self name], [self stringFromReturn:rtn]); ! 436: return (rtn); ! 437: } ! 438: ! 439: block_size = [self blockSize]; ! 440: dev_size = [self diskSize]; ! 441: ! 442: if (length % block_size) { ! 443: return (IO_R_INVALID); ! 444: } ! 445: blocksReq = length / block_size; ! 446: if ((deviceBlock + blocksReq) > dev_size) { ! 447: if (deviceBlock >= dev_size) { ! 448: return (IO_R_INVALID_ARG); ! 449: } ! 450: blocksReq = dev_size - deviceBlock; ! 451: } ! 452: ideBuf = [self allocIdeBuf:pending]; ! 453: ideBuf->command = command; ! 454: ideBuf->block = deviceBlock; ! 455: ideBuf->blockCnt = blocksReq; ! 456: ideBuf->buf = buffer; ! 457: ideBuf->client = client; ! 458: ideBuf->needsDisk = 1; ! 459: ideBuf->bytesXfr = 0; ! 460: ideBuf->oneWay = 0; ! 461: ! 462: rtn = [self enqueueIdeBuf:ideBuf]; ! 463: ! 464: if (pending == NULL) { ! 465: /* ! 466: * Sync I/O. ! 467: */ ! 468: *actualLength = ideBuf->bytesXfr; ! 469: [self freeIdeBuf:ideBuf]; ! 470: } ! 471: return (rtn); ! 472: } ! 473: ! 474: /* ! 475: * -- Enqueue an IdeBuf_t on ioQueue<Disk,Nodisk> ! 476: * -- wake up the I/O thread ! 477: * -- wait for I/O complete (if ideBuf->pending == NULL) ! 478: * ! 479: * All I/O goes thru here; this is the last method called by exported methods ! 480: * before the I/O thread takes over. ! 481: */ ! 482: - (IOReturn) enqueueIdeBuf:(ideBuf_t *) ideBuf ! 483: { ! 484: queue_head_t *q; ! 485: ! 486: ideBuf->status = IO_R_INVALID; ! 487: [_ioQLock lock]; ! 488: if (ideBuf->needsDisk) ! 489: q = &_ioQueueDisk; ! 490: else ! 491: q = &_ioQueueNodisk; ! 492: queue_enter(q, ideBuf, ideBuf_t *, link); ! 493: [_ioQLock unlockWith:WORK_AVAILABLE]; ! 494: ! 495: if (ideBuf->pending != NULL) ! 496: return (IO_R_SUCCESS); ! 497: ! 498: /* ! 499: * Wait for I/O complete if not an async command. ! 500: */ ! 501: ! 502: if (ideBuf->oneWay) { ! 503: return IO_R_SUCCESS; ! 504: } ! 505: [ideBuf->waitLock lockWhen:YES]; ! 506: [ideBuf->waitLock unlock]; ! 507: ! 508: return (ideBuf->status); ! 509: } ! 510: ! 511: ! 512: /* ! 513: * Either wake up the thread which is waiting on the ideCmdBuf, or send an ! 514: * ioComplete back to client. ideCmdBuf->status must be valid. ! 515: */ ! 516: - (void)ideIoComplete:(ideBuf_t *) ideBuf ! 517: { ! 518: if (ideBuf->pending) { ! 519: [self completeTransfer:ideBuf->pending ! 520: withStatus:ideBuf->status ! 521: actualLength:ideBuf->bytesXfr]; ! 522: [self freeIdeBuf:ideBuf]; ! 523: } else { ! 524: /* ! 525: * Sync I/O. Just wake up the waiting thread. ! 526: */ ! 527: [ideBuf->waitLock lock]; ! 528: [ideBuf->waitLock unlockWith:YES]; ! 529: } ! 530: ! 531: } ! 532: ! 533: /* ! 534: * Main command dispatch method. ! 535: */ ! 536: - (void)ideCmdDispatch:(ideBuf_t *)ideBuf ! 537: { ! 538: IOReturn rtn = IO_R_SUCCESS; ! 539: ideBuf_t *abortBuf; ! 540: ! 541: switch (ideBuf->command) { ! 542: ! 543: case IDEC_IOREQ: ! 544: [_cntrlr ideExecuteCmd:ideBuf->ideIoReq ToDrive:_driveNum]; ! 545: ! 546: break; ! 547: ! 548: case IDEC_READ: ! 549: case IDEC_WRITE: ! 550: rtn = [self ideRwCommon:ideBuf]; ! 551: ! 552: break; ! 553: ! 554: case IDEC_ABORT: ! 555: ! 556: /* ! 557: * Each I/O pending in the needsDisk queue must be aborted. ! 558: */ ! 559: [_ioQLock lock]; ! 560: while (!queue_empty(&_ioQueueDisk)) { ! 561: abortBuf = (ideBuf_t *) queue_first(&_ioQueueDisk); ! 562: queue_remove(&_ioQueueDisk, ! 563: abortBuf, ! 564: ideBuf_t *, ! 565: link); ! 566: [_ioQLock unlock]; ! 567: abortBuf->status = IO_R_NO_DISK; ! 568: if (abortBuf->ideIoReq) ! 569: abortBuf->ideIoReq->status = IDER_VOLUNAVAIL; ! 570: [self ideIoComplete:abortBuf]; ! 571: [_ioQLock lock]; ! 572: } ! 573: [_ioQLock unlock]; ! 574: ! 575: break; ! 576: ! 577: case IDEC_THREAD_ABORT: ! 578: ! 579: /* ! 580: * First give I/O complete before we die. ! 581: */ ! 582: ideBuf->status = IO_R_SUCCESS; ! 583: [self ideIoComplete:ideBuf]; ! 584: IOExitThread(); ! 585: ! 586: case IDEC_INIT: ! 587: #if 0 ! 588: /* Called once during initialization. */ ! 589: if ([_cntrlr initIdeDriveLowLevel] == IDER_SUCCESS) ! 590: rtn = IO_R_SUCCESS; ! 591: else ! 592: rtn = IO_R_IO; ! 593: #endif 0 ! 594: rtn = IO_R_SUCCESS; ! 595: break; ! 596: ! 597: default: ! 598: IOLog("%s: Bogus ideBuf->command 0x%0x in ideCmdDispatch\n", ! 599: [self name], ideBuf->command); ! 600: IOPanic("ideThread"); ! 601: } ! 602: ! 603: /* ! 604: * I/O complete the command if appropriate. ! 605: */ ! 606: if (ideBuf->oneWay) { ! 607: ! 608: [self freeIdeBuf:ideBuf]; ! 609: ! 610: return; ! 611: } ! 612: ideBuf->status = rtn; ! 613: ! 614: [self ideIoComplete:ideBuf]; ! 615: return; ! 616: } ! 617: ! 618: /* ! 619: * Common r/w routine. The following ideBuf fields are required: ! 620: * block ! 621: * blockCnt ! 622: * buf ! 623: * client ! 624: * pending ! 625: * ! 626: * block and blockCnt are assumed to be already adjusted for overflow. ! 627: */ ! 628: ! 629: - (IOReturn) ideRwCommon:(ideBuf_t *)ideBuf ! 630: { ! 631: int currentBlock = ideBuf->block; /* start block, current ! 632: * segment */ ! 633: int currentBlockCnt; /* block count, current segment */ ! 634: int blocksToGo = ideBuf->blockCnt; ! 635: unsigned ioCommand; ! 636: char *currentBuf = ideBuf->buf; ! 637: ideIoReq_t ideIoReq; ! 638: IOReturn rtn; ! 639: unsigned int block_size = _ideInfo.bytes_per_sector; ! 640: BOOL readFlag = (ideBuf->command == IDEC_READ) ? YES : NO; ! 641: int blocksMoved; ! 642: ns_time_t start_time; ! 643: ! 644: ! 645: IOGetTimestamp(&start_time); ! 646: ! 647: if ( (_ideControllerType == kControllerTypeCmd646X) && ((u_int)currentBuf & 1) ) ! 648: { ! 649: ioCommand = readFlag ? _ideReadCommandPIO : _ideWriteCommandPIO; ! 650: } ! 651: else ! 652: { ! 653: ioCommand = readFlag ? _ideReadCommand : _ideWriteCommand; ! 654: } ! 655: ! 656: while (blocksToGo) { ! 657: ! 658: /* ! 659: * Set up controller command block for current segment. ! 660: */ ! 661: currentBlockCnt = ((blocksToGo > MAX_BLOCKS_PER_XFER) ? ! 662: MAX_BLOCKS_PER_XFER : blocksToGo); ! 663: ! 664: ideIoReq.cmd = ioCommand; ! 665: ideIoReq.addr = currentBuf; ! 666: ideIoReq.blkcnt = currentBlockCnt; ! 667: ideIoReq.block = currentBlock; ! 668: ! 669: /* ! 670: * Note we're compiling MACH_USER_API, hence the cast... ! 671: */ ! 672: ideIoReq.map = (struct vm_map *) ideBuf->client; ! 673: ! 674: rtn = [_cntrlr ideExecuteCmd:&ideIoReq ToDrive:_driveNum]; ! 675: ! 676: blocksMoved = ideIoReq.blocks_xfered; ! 677: blocksToGo -= blocksMoved; ! 678: currentBlock += blocksMoved; ! 679: currentBuf += ideIoReq.blocks_xfered * block_size; ! 680: ! 681: /* ! 682: * Handle errors. ! 683: */ ! 684: ! 685: if (rtn) { ! 686: /* ! 687: * This is a colossal error, which should never happen... ! 688: */ ! 689: ideIoReq.status = IDER_REJECT; ! 690: } ! 691: switch (ideIoReq.status) { ! 692: case IDER_SUCCESS: ! 693: break; ! 694: case IDER_TIMEOUT: ! 695: case IDER_MEMALLOC: ! 696: case IDER_MEMFAIL: ! 697: case IDER_REJECT: ! 698: case IDER_BADDRV: ! 699: case IDER_CMD_ERROR: ! 700: case IDER_VOLUNAVAIL: ! 701: case IDER_SPURIOUS: ! 702: goto done; ! 703: break; ! 704: default: ! 705: ! 706: /* ! 707: * Non-retriable errors. ! 708: */ ! 709: [self logRwErr:"FATAL" block:currentBlock status:ideIoReq.status ! 710: readFlag:readFlag]; ! 711: goto done; ! 712: break; ! 713: ! 714: } /* switch status */ ! 715: } /* while blocksToGo */ ! 716: done: ! 717: ! 718: /* ! 719: * Finished. Update client's status and log statistics. ! 720: */ ! 721: ideBuf->bytesXfr = (ideBuf->blockCnt - blocksToGo) * block_size; ! 722: rtn = ideBuf->status = iderToIo(ideIoReq.status); ! 723: if (ideIoReq.status != IO_R_SUCCESS) { ! 724: ! 725: if (readFlag) { ! 726: [self incrementReadErrors]; ! 727: } else { ! 728: [self incrementWriteErrors]; ! 729: } ! 730: ! 731: } else { ! 732: ns_time_t end_time; ! 733: ! 734: /* no "latency" measurement... */ ! 735: ns_time_t delta; ! 736: ! 737: IOGetTimestamp(&end_time); ! 738: delta = end_time - start_time; ! 739: if (readFlag) { ! 740: ! 741: [self addToBytesRead:ideBuf->bytesXfr ! 742: totalTime:delta ! 743: latentTime:0]; ! 744: } else { ! 745: [self addToBytesWritten:ideBuf->bytesXfr ! 746: totalTime:delta ! 747: latentTime:0]; ! 748: } ! 749: } ! 750: ! 751: return (rtn); ! 752: } ! 753: ! 754: - (void)logRwErr : (const char *)errType // e.g., "RECALIBRATING" ! 755: block : (int)block ! 756: status : (ide_return_t)status ! 757: readFlag : (BOOL)readFlag ! 758: { ! 759: ! 760: IOLog("%s: Sector %d cmd = %s; %s: %s\n", ! 761: [self name], block, readFlag ? "Read" : "Write", ! 762: IOFindNameForValue(status, iderValues), errType); ! 763: ! 764: } ! 765: ! 766: /* ! 767: * Unlock ioQLock, updating condition variable as appropriate. ! 768: */ ! 769: - (void)unlockIoQLock ! 770: { ! 771: int queue_state; ! 772: IODiskReadyState lastReady = [self lastReadyState]; ! 773: ! 774: /* ! 775: * There's still work to do when: ! 776: * -- ioQueueNodisk non-empty, or ! 777: * -- ioQueueDisk non-empty and we have a disk. ! 778: */ ! 779: ! 780: if ((!queue_empty(&_ioQueueNodisk)) || ! 781: ((!queue_empty(&_ioQueueDisk)) && (lastReady != IO_NoDisk))) { ! 782: queue_state = WORK_AVAILABLE; ! 783: } else ! 784: queue_state = NO_WORK_AVAILABLE; ! 785: [_ioQLock unlockWith:queue_state]; ! 786: } ! 787: ! 788: ! 789: /* ! 790: * I/O thread. Each one of these sits around waiting for work to do on ! 791: * ioQueue; when something appears, the thread grabs it and disptahes it. ! 792: */ ! 793: ! 794: volatile void ideThread(ATADisk *idisk) ! 795: { ! 796: ideBuf_t *ideBuf; ! 797: queue_head_t *q; ! 798: ! 799: while (1) { ! 800: ! 801: /* ! 802: * Wait for some work to do. ! 803: */ ! 804: [idisk->_ioQLock lockWhen:WORK_AVAILABLE]; ! 805: ! 806: /* ! 807: * Service all requests which do not require a disk. ! 808: */ ! 809: q = &idisk->_ioQueueNodisk; ! 810: while (!queue_empty(q)) { ! 811: ideBuf = (ideBuf_t *) queue_first(q); ! 812: queue_remove(q, ideBuf, ideBuf_t *, link); ! 813: [idisk->_ioQLock unlock]; ! 814: ASSERT(ideBuf->needsDisk == 0); ! 815: [idisk ideCmdDispatch:ideBuf]; ! 816: [idisk->_ioQLock lock]; ! 817: } ! 818: ! 819: /* ! 820: * Now service all requests which require a disk, as long as we have ! 821: * one. ! 822: */ ! 823: ! 824: q = &idisk->_ioQueueDisk; ! 825: ASSERT([idisk lastReadyState] == IO_Ready); ! 826: while ((!queue_empty(q)) && ! 827: ([idisk lastReadyState] == IO_Ready)) { ! 828: ideBuf = (ideBuf_t *) queue_first(q); ! 829: queue_remove(q, ideBuf, ideBuf_t *, link); ! 830: [idisk->_ioQLock unlock]; ! 831: ASSERT(ideBuf->needsDisk == 1); ! 832: [idisk ideCmdDispatch:ideBuf]; ! 833: [idisk->_ioQLock lock]; ! 834: } ! 835: ! 836: [idisk unlockIoQLock]; ! 837: } ! 838: ! 839: /* NOT REACHED */ ! 840: } ! 841: ! 842: IOReturn iderToIo(ide_return_t ider) ! 843: { ! 844: switch (ider) { ! 845: case IDER_SUCCESS: ! 846: return (IO_R_SUCCESS); ! 847: case IDER_TIMEOUT: ! 848: case IDER_CNTRL_REJECT: ! 849: case IDER_CMD_ERROR: ! 850: case IDER_SPURIOUS: ! 851: return (IO_R_IO); ! 852: case IDER_MEMALLOC: ! 853: return (IO_R_NO_MEMORY); ! 854: case IDER_MEMFAIL: ! 855: return (IO_R_VM_FAILURE); ! 856: case IDER_REJECT: ! 857: return (IO_R_UNSUPPORTED); ! 858: case IDER_BADDRV: ! 859: return (IO_R_NO_DEVICE); ! 860: case IDER_VOLUNAVAIL: ! 861: return (IO_R_NO_DISK); ! 862: default: ! 863: return (IO_R_INTERNAL); ! 864: } ! 865: } ! 866: ! 867: @end ! 868:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.