![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IdeCntCmds.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 IdeCntCmds.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: * IdeCntCmds.m - Implementation of Commands category for IDE Controller
29: * device.
30: *
31: * It contains implementation of the ATA command set.
32: *
33: *
34: * HISTORY
35: *
36: * 23-Feb-1998 Joe Liu at Apple
37: * startUpAttachedDevices method is called immediately after acquiring
38: * the lock.
39: *
40: * 1-Feb-1998 Joe Liu at Apple
41: * ideSetDriveFeature method changed to support all EIDE transfer modes.
42: * Added support for Bus Master DMA.
43: * ideExecuteCmd now sets _driveNum within the retry loop.
44: *
45: * 1-Aug-1995 Rakesh Dubey at NeXT
46: * Reduced the timeout in IDE_IDENTIFY_DRIVE method.
47: *
48: * 17-July-1994 Rakesh Dubey at NeXT
49: * Created.
50: */
51:
52: //#define DEBUG
53:
54: #import "IdeCnt.h"
55: #import "IdeCntInit.h"
56: #import "IdePIIX.h"
57: #import <kern/assert.h>
58: #import <driverkit/kernelDriver.h>
59: #import <driverkit/interruptMsg.h>
60: #import <mach/mach_interface.h>
61: #import <driverkit/IODevice.h>
62: #import <driverkit/align.h>
63: #import <machkit/NXLock.h>
64: #import <machdep/i386/io_inline.h>
65: #import "IdeDDM.h"
66:
67: /*
68: * All methods in this file implement one or more of the IDE commands. These
69: * commands get invoked by IdeDisk objects.
70: */
71:
72: @implementation IdeController(Commands)
73:
74: /*
75: * Returns a struct containing IDE registers values for a given sector
76: * address and size. Depending upon whether the drive supports LBA or CHS we
77: * fill in different values. The calling routine must make sure that these
78: * values are not overwritten. The only thing that they need to fill in is
79: * the drive number.
80: */
81: - (ideRegsVal_t)logToPhys:(unsigned)block numOfBlocks:(unsigned)nblk
82: {
83: ideRegsVal_t rv;
84: unsigned int cyl, nheads;
85: unsigned int track, spt;
86:
87: if (_drives[_driveNum].addressMode == ADDRESS_MODE_CHS) {
88: nheads = _drives[_driveNum].ideInfo.heads;
89: spt = _drives[_driveNum].ideInfo.sectors_per_trk;
90:
91: track = (block / spt);
92: cyl = track / nheads;
93: rv.sectNum = block % spt + 1;
94:
95: rv.drHead = track % nheads;
96: rv.cylLow = (cyl & 0xff);
97: rv.cylHigh = ((cyl & 0xff00) >> 8);
98: } else {
99: rv.sectNum = block & 0x0ff;
100: rv.cylLow = (block >> 8) & 0xff;
101: rv.cylHigh = (block >> 16) & 0xff;
102: rv.drHead = (block >> 24) & 0x0f;
103: }
104:
105: rv.sectCnt = (nblk == MAX_BLOCKS_PER_XFER) ? 0 : nblk;
106:
107: rv.drHead |= _drives[_driveNum].addressMode;
108: rv.drHead |= (_driveNum ? SEL_DRIVE1 : SEL_DRIVE0);
109:
110: return rv;
111: }
112:
113: /*
114: * Commands to the IDE controller.
115: */
116:
117:
118: - (ide_return_t)ideDiagnose:(unsigned *)diagError
119: {
120: ide_return_t rtn;
121: unsigned char status;
122:
123: rtn = [self waitForDeviceReady];
124: if (rtn != IDER_SUCCESS)
125: return IDER_CMD_ERROR;
126:
127: [self enableInterrupts];
128: outb(_ideRegsAddrs.command, IDE_DIAGNOSE);
129:
130: rtn = [self ideWaitForInterrupt:IDE_DIAGNOSE ideStatus:&status];
131: if (rtn != IDER_SUCCESS) {
132: [self getIdeRegisters:NULL Print:"Diagnose"];
133: return IDER_CMD_ERROR;
134: }
135:
136: rtn = [self waitForDeviceReady];
137: if (rtn != IDER_SUCCESS)
138: return IDER_CMD_ERROR;
139:
140: *diagError = inb(_ideRegsAddrs.error);
141:
142: if (*diagError == 0x01) {
143: /* FIXME: do we need to soft reset ATAPI devices? */
144: return IDER_SUCCESS;
145: }
146:
147: /*
148: * At least one of the drives is bad.
149: */
150: if (*diagError & 0x080) {
151: IOLog("%s: Drive 1 has failed diagnostics.\n", [self name]);
152: _drives[1].ideInfo.type = 0;
153:
154: if ((*diagError & 0x07f) != 1) {
155: IOLog("%s: Drive 0 has failed diagnostics, error %d\n",
156: [self name], (*diagError & 0x07f));
157: return IDER_CMD_ERROR;
158: }
159: } else {
160: _drives[0].ideInfo.type = 0;
161: IOLog("%s: Drive 0 has failed diagnostics, error %d\n",
162: [self name], (*diagError & 0x07f));
163: }
164:
165: return IDER_CMD_ERROR;
166: }
167:
168: - (ide_return_t)ideSetParams:(unsigned)sectCnt numHeads:(unsigned)nHeads
169: ForDrive:(unsigned)drive
170: {
171: unsigned char dh = _drives[drive].addressMode;
172: ide_return_t rtn;
173:
174: rtn = [self waitForDeviceReady];
175: if (rtn != IDER_SUCCESS)
176: return rtn;
177:
178: dh |= ((drive ? SEL_DRIVE1 : SEL_DRIVE0) | ((nHeads - 1) & 0x0f));
179: outb(_ideRegsAddrs.drHead, dh);
180: outb(_ideRegsAddrs.sectCnt, (sectCnt & 0xff));
181:
182: [self enableInterrupts];
183: outb(_ideRegsAddrs.command, IDE_SET_PARAMS);
184:
185: rtn = [self ideWaitForInterrupt:IDE_SET_PARAMS ideStatus:NULL];
186: if (rtn != IDER_SUCCESS) {
187: [self getIdeRegisters:NULL Print:"SetParams"];
188: return rtn;
189: }
190:
191: return rtn;
192: }
193:
194: - (ide_return_t)ideSetDriveFeature:(unsigned char)feature
195: value:(unsigned char)val
196: transferType:(ideTransferType_t)type
197: {
198: unsigned char dh = _drives[_driveNum].addressMode;
199: unsigned char status;
200: ide_return_t rtn;
201: // unsigned char tmp;
202:
203: #ifdef DEBUG
204: IOLog("Setting drive feature %x to %x\n", feature, val);
205: #endif DEBUG
206:
207: /*
208: * We are not going to do anything if EIDE support is disabled.
209: *
210: * Currently, this is useful only for setting the transfer mode.
211: */
212: if ((_EIDESupport == NO) || (feature != FEATURE_SET_TRANSFER_MODE) ||
213: (val == ATA_MODE_NONE))
214: return IDER_SUCCESS;
215:
216: val = ata_mode_to_num(val);
217: // IOLog("Mode num: %d\n", val);
218:
219: rtn = [self waitForDeviceReady];
220: if (rtn != IDER_SUCCESS)
221: return rtn;
222:
223: dh |= (_driveNum ? SEL_DRIVE1 : SEL_DRIVE0);
224: outb(_ideRegsAddrs.drHead, dh);
225:
226: val &= 0x07;
227: switch (type) {
228: case IDE_TRANSFER_PIO:
229: val |= (1 << 3);
230: break;
231: case IDE_TRANSFER_SW_DMA:
232: val |= (1 << 4);
233: break;
234: case IDE_TRANSFER_MW_DMA:
235: val |= (1 << 5);
236: break;
237: case IDE_TRANSFER_ULTRA_DMA:
238: val |= (1 << 6);
239: break;
240: default:
241: val = 0;
242: }
243: outb(_ideRegsAddrs.sectCnt, val);
244: outb(_ideRegsAddrs.features, feature);
245:
246: [self enableInterrupts];
247: outb(_ideRegsAddrs.command, IDE_SET_FEATURES);
248:
249: rtn = [self ideWaitForInterrupt:IDE_SET_FEATURES ideStatus:&status];
250: if (rtn != IDER_SUCCESS) {
251: [self getIdeRegisters:NULL Print:"SetFeatures"];
252: return rtn;
253: }
254:
255: if (status & ERROR)
256: return IDER_ERROR;
257:
258: return rtn;
259: }
260:
261: - (ide_return_t)ideRestore:(ideRegsVal_t *)ideRegs
262: {
263: ide_return_t rtn;
264: unsigned char status;
265: unsigned char dh = _drives[_driveNum].addressMode;
266:
267: rtn = [self waitForDeviceReady];
268: if (rtn != IDER_SUCCESS) {
269: return rtn;
270: }
271:
272: dh |= (_driveNum ? SEL_DRIVE1 : SEL_DRIVE0);
273: outb(_ideRegsAddrs.drHead, dh);
274:
275: [self enableInterrupts];
276: outb(_ideRegsAddrs.command, IDE_RESTORE);
277:
278: rtn = [self ideWaitForInterrupt:IDE_RESTORE ideStatus: &status];
279: if (rtn != IDER_SUCCESS) {
280: [self getIdeRegisters:NULL Print:"Restore"];
281: return rtn;
282: }
283:
284: rtn = [self waitForDeviceReady];
285: if (rtn == IDER_SUCCESS) {
286: if (status & ERROR) {
287: [self getIdeRegisters:ideRegs Print:"Restore"];
288: rtn = IDER_CMD_ERROR;
289: }
290: }
291:
292: return (rtn);
293: }
294:
295: - (ide_return_t)ideReadGetInfoCommon:(ideRegsVal_t *)ideRegs
296: client:(struct vm_map *)client
297: addr:(caddr_t)xferAddr
298: command:(unsigned int)cmd
299: {
300: ide_return_t rtn;
301: unsigned int sec_cnt = ideRegs->sectCnt;
302: int i;
303: unsigned char *taddr;
304: unsigned char status;
305: unsigned char dh = _drives[_driveNum].addressMode;
306:
307: if (sec_cnt == 0)
308: sec_cnt = MAX_BLOCKS_PER_XFER;
309:
310: taddr = xferAddr;
311:
312: /*
313: * We have to define this for the IDE_IDENTIFY_DRIVE command.
314: */
315: if (cmd == IDE_IDENTIFY_DRIVE) {
316: ideRegs->sectCnt = 1;
317: sec_cnt = 1;
318: }
319:
320: /*
321: * Select the drive first. This routine is invoked by the initialization
322: * code as well (-resetAndInit) so it is necessary to do this here.
323: */
324: dh |= (_driveNum ? SEL_DRIVE1 : SEL_DRIVE0);
325: outb(_ideRegsAddrs.drHead, dh);
326:
327:
328: rtn = [self waitForDeviceReady];
329: if (rtn != IDER_SUCCESS) {
330: if (_ide_debug) {
331: IOLog("ideReadGetInfoCommon: waitForDeviceReady\n");
332: [self getIdeRegisters:ideRegs Print:NULL];
333: }
334: return (rtn);
335: }
336:
337: if (cmd == IDE_READ) {
338: outb(_ideRegsAddrs.drHead, ideRegs->drHead);
339: outb(_ideRegsAddrs.sectNum, ideRegs->sectNum);
340: outb(_ideRegsAddrs.sectCnt, ideRegs->sectCnt);
341: outb(_ideRegsAddrs.cylLow, ideRegs->cylLow);
342: outb(_ideRegsAddrs.cylHigh, ideRegs->cylHigh);
343: } else {
344: /* probably unnecessary */
345: outb(_ideRegsAddrs.drHead, dh);
346: outb(_ideRegsAddrs.sectCnt, ideRegs->sectCnt);
347: }
348:
349: [self enableInterrupts];
350: outb(_ideRegsAddrs.command, cmd);
351:
352: for (i = 0; i < sec_cnt; i++) {
353:
354: rtn = [self ideWaitForInterrupt:cmd ideStatus:&status];
355: if (rtn != IDER_SUCCESS) {
356: if (_ide_debug) {
357: IOLog("ideReadGetInfoCommon: ideWaitForInterrupt\n");
358: [self getIdeRegisters:ideRegs Print:NULL];
359: }
360: return rtn;
361: } else {
362: /*
363: if (status & ERROR_CORRECTED) {
364: IOLog("%s: Corrected error during read.\n", [self name]);
365: }
366: */
367: }
368:
369: /*
370: * Same as waitForDataReady but with a quick timeout.
371: */
372: rtn = [self ataIdeReadGetInfoCommonWaitForDataReady];
373: if (rtn != IDER_SUCCESS) {
374: if (_ide_debug) {
375: IOLog("ideReadGetInfoCommon: "
376: "ataIdeReadGetInfoCommonWaitForDataReady\n");
377: [self getIdeRegisters:ideRegs Print:NULL];
378: }
379: return (rtn);
380: }
381:
382: [self xferData:taddr read:YES client:client length:IDE_SECTOR_SIZE];
383: taddr += IDE_SECTOR_SIZE;
384: }
385:
386: return rtn;
387: }
388:
389: - (ide_return_t)ideWrite:(ideRegsVal_t *)ideRegs
390: client:(struct vm_map *)client
391: addr:(caddr_t)xferAddr
392: {
393: ide_return_t rtn;
394: unsigned int sec_cnt = ideRegs->sectCnt;
395: int i;
396: unsigned char *taddr;
397: unsigned char status;
398:
399: if (sec_cnt == 0)
400: sec_cnt = MAX_BLOCKS_PER_XFER;
401:
402: taddr = xferAddr;
403:
404: rtn = [self waitForDeviceReady];
405: if (rtn != IDER_SUCCESS) {
406: return (rtn);
407: }
408:
409: outb(_ideRegsAddrs.drHead, ideRegs->drHead);
410: outb(_ideRegsAddrs.sectNum, ideRegs->sectNum);
411: outb(_ideRegsAddrs.sectCnt, ideRegs->sectCnt);
412: outb(_ideRegsAddrs.cylLow, ideRegs->cylLow);
413: outb(_ideRegsAddrs.cylHigh, ideRegs->cylHigh);
414:
415: [self enableInterrupts];
416: outb(_ideRegsAddrs.command, IDE_WRITE);
417:
418: for (i = 0; i < sec_cnt; i++) {
419:
420: rtn = [self waitForDataReady];
421: if (rtn != IDER_SUCCESS) {
422: return (rtn);
423: }
424:
425: [self xferData:taddr read:NO client:client length:IDE_SECTOR_SIZE];
426: taddr += IDE_SECTOR_SIZE;
427:
428: rtn = [self ideWaitForInterrupt:IDE_WRITE ideStatus:&status];
429:
430: if (rtn != IDER_SUCCESS) {
431: [self getIdeRegisters:ideRegs Print:"Write"];
432: return (rtn);
433: } else {
434: /*
435: if (status & ERROR_CORRECTED) {
436: IOLog("%s: Corrected error during write.\n", [self name]);
437: }
438: */
439: }
440: }
441:
442: return (rtn);
443: }
444:
445: - (ide_return_t)ideReadVerifySeekCommon:(ideRegsVal_t *)ideRegs
446: command:(unsigned int)cmd
447: {
448: ide_return_t rtn;
449: unsigned char status;
450:
451: rtn = [self waitForDeviceReady];
452: if (rtn != IDER_SUCCESS) {
453: return (rtn);
454: }
455:
456: outb(_ideRegsAddrs.drHead, ideRegs->drHead);
457: outb(_ideRegsAddrs.sectNum, ideRegs->sectNum);
458: if (cmd == IDE_READ_VERIFY)
459: outb(_ideRegsAddrs.sectCnt, ideRegs->sectCnt);
460: outb(_ideRegsAddrs.cylLow, ideRegs->cylLow);
461: outb(_ideRegsAddrs.cylHigh, ideRegs->cylHigh);
462:
463: [self enableInterrupts];
464: outb(_ideRegsAddrs.command, cmd);
465:
466: rtn = [self ideWaitForInterrupt:cmd ideStatus: &status];
467: if (rtn != IDER_SUCCESS) {
468: [self getIdeRegisters:NULL Print:"ReadVerify/Seek"];
469: return (rtn);
470: }
471:
472: if (status & (ERROR | WRITE_FAULT)) {
473: rtn = IDER_CMD_ERROR;
474: } else {
475: if ((cmd == IDE_SEEK) && (!(status & SEEK_COMPLETE)))
476: rtn = IDER_CMD_ERROR;
477: }
478:
479: return (rtn);
480: }
481:
482: - (ide_return_t)ideSetMultiSectorMode:(ideRegsVal_t *)ideRegs
483: numSectors:(unsigned char)nSectors
484: {
485: ide_return_t rtn;
486: unsigned char status;
487: unsigned char dh = _drives[_driveNum].addressMode;
488:
489: rtn = [self waitForDeviceReady];
490: if (rtn != IDER_SUCCESS) {
491: return (rtn);
492: }
493:
494: dh |= (_driveNum ? SEL_DRIVE1 : SEL_DRIVE0);
495: outb(_ideRegsAddrs.drHead, dh);
496: outb(_ideRegsAddrs.sectCnt, nSectors);
497:
498: [self enableInterrupts];
499: outb(_ideRegsAddrs.command, IDE_SET_MULTIPLE);
500:
501: rtn = [self ideWaitForInterrupt:IDE_SET_MULTIPLE ideStatus:&status];
502: if (rtn != IDER_SUCCESS) {
503: return (rtn);
504: }
505:
506: rtn = [self waitForDeviceReady];
507: if (rtn == IDER_SUCCESS) {
508: if (status & ERROR) {
509: rtn = IDER_CMD_ERROR;
510: [self getIdeRegisters:ideRegs Print:NULL];
511: } else
512: rtn = IDER_SUCCESS;
513: }
514:
515: return (rtn);
516: }
517:
518: /*
519: * Note: Never read the status register at the end of data transfer, you may
520: * clobber the next interrupt from the drive. If it is necessary to get
521: * status use the alternate status register.
522: */
523: - (ide_return_t)ideReadMultiple:(ideRegsVal_t *)ideRegs
524: client:(struct vm_map *)client
525: addr:(caddr_t)xferAddr
526: {
527: ide_return_t rtn;
528: unsigned char status;
529: unsigned sec_cnt = ideRegs->sectCnt;
530: unsigned int nSectors;
531: unsigned char *taddr;
532: unsigned int length;
533:
534: if (sec_cnt == 0)
535: sec_cnt = MAX_BLOCKS_PER_XFER;
536:
537: taddr = xferAddr;
538:
539: rtn = [self waitForDeviceReady];
540: if (rtn != IDER_SUCCESS) {
541: return (rtn);
542: }
543:
544: outb(_ideRegsAddrs.drHead, ideRegs->drHead);
545: outb(_ideRegsAddrs.sectNum, ideRegs->sectNum);
546: outb(_ideRegsAddrs.sectCnt, ideRegs->sectCnt);
547: outb(_ideRegsAddrs.cylLow, ideRegs->cylLow);
548: outb(_ideRegsAddrs.cylHigh, ideRegs->cylHigh);
549:
550: [self enableInterrupts];
551: outb(_ideRegsAddrs.command, IDE_READ_MULTIPLE);
552:
553: ddm_ide_cmd("ideReadMultiple: sec_cnt %d sectors\n", sec_cnt, 2,3,4,5);
554:
555: while (sec_cnt > 0) {
556:
557: ddm_ide_cmd("ideReadMultiple: waiting for interrupt\n",1,2,3,4,5);
558: rtn = [self ideWaitForInterrupt:IDE_READ_MULTIPLE
559: ideStatus: &status];
560: ddm_ide_cmd("ideReadMultiple: received interrupt\n",1,2,3,4,5);
561:
562: if (rtn != IDER_SUCCESS) {
563: [self getIdeRegisters:ideRegs Print:"Read Multiple"];
564: return (rtn);
565: }
566:
567: #if 1
568: rtn = [self waitForDataReady];
569: if (rtn != IDER_SUCCESS) {
570: return (rtn);
571: }
572: #endif 1
573:
574: if (status & (ERROR | WRITE_FAULT)) {
575: [self getIdeRegisters:ideRegs Print:"Read Multiple"];
576: return IDER_CMD_ERROR;
577: }
578:
579: /*
580: * Any drive formatted with 63 sector/track (which most over 400 MB
581: * are) reporting this status (ERROR_CORRECTED) will cause an
582: * fallacious error (possibly uncorrectable) due to a long-standing
583: * bug in DOS. This status bit should be made vendor specific, like
584: * IDX. It has outlived its usefulness.
585: * -- [email protected]
586: */
587:
588: /*
589: if (status & ERROR_CORRECTED) {
590: IOLog("%s: Corrected error during read.\n", [self name]);
591: }
592: */
593:
594: /*
595: * All is well. Read in the data.
596: */
597: if (sec_cnt > _drives[_driveNum].multiSector)
598: nSectors = _drives[_driveNum].multiSector;
599: else
600: nSectors = sec_cnt;
601:
602: sec_cnt -= nSectors;
603:
604: ddm_ide_cmd("ideReadMultiple: starting data transfer\n",1,2,3,4,5);
605:
606: while (nSectors) {
607: if (nSectors > PAGE_SIZE / IDE_SECTOR_SIZE) {
608: length = PAGE_SIZE;
609: nSectors -= (PAGE_SIZE / IDE_SECTOR_SIZE);
610: } else {
611: length = nSectors * IDE_SECTOR_SIZE;
612: nSectors = 0;
613: }
614:
615: [self xferData:taddr read:YES client:client length:length];
616: taddr += length;
617: }
618:
619: ddm_ide_cmd("ideReadMultiple: data transfer done\n",1,2,3,4,5);
620: }
621:
622: ddm_ide_cmd("ideReadMultiple: completed\n",1,2,3,4,5);
623:
624: return (rtn);
625: }
626:
627: - (ide_return_t)ideWriteMultiple:(ideRegsVal_t *)ideRegs
628: client:(struct vm_map *)client
629: addr:(caddr_t)xferAddr
630: {
631: ide_return_t rtn;
632: unsigned char status;
633: unsigned sec_cnt = ideRegs->sectCnt;
634: unsigned int nSectors;
635: unsigned char *taddr;
636: unsigned int length;
637:
638: if (sec_cnt == 0)
639: sec_cnt = MAX_BLOCKS_PER_XFER;
640:
641: taddr = xferAddr;
642:
643: rtn = [self waitForDeviceReady];
644: if (rtn != IDER_SUCCESS) {
645: return (rtn);
646: }
647:
648: outb(_ideRegsAddrs.drHead, ideRegs->drHead);
649: outb(_ideRegsAddrs.sectNum, ideRegs->sectNum);
650: outb(_ideRegsAddrs.sectCnt, ideRegs->sectCnt);
651: outb(_ideRegsAddrs.cylLow, ideRegs->cylLow);
652: outb(_ideRegsAddrs.cylHigh, ideRegs->cylHigh);
653:
654: [self enableInterrupts];
655: outb(_ideRegsAddrs.command, IDE_WRITE_MULTIPLE);
656:
657: ddm_ide_cmd("ideWriteMultiple: sec_cnt %d sectors\n", sec_cnt, 2,3,4,5);
658:
659: while (sec_cnt > 0) {
660:
661: rtn = [self waitForDataReady];
662: if (rtn != IDER_SUCCESS) {
663: return (rtn);
664: }
665:
666: if (sec_cnt > _drives[_driveNum].multiSector)
667: nSectors = _drives[_driveNum].multiSector;
668: else
669: nSectors = sec_cnt;
670:
671: sec_cnt -= nSectors;
672:
673: ddm_ide_cmd("ideWriteMultiple: starting data transfer\n",1,2,3,4,5);
674:
675: while (nSectors) {
676: if (nSectors > PAGE_SIZE / IDE_SECTOR_SIZE) {
677: length = PAGE_SIZE;
678: nSectors -= (PAGE_SIZE / IDE_SECTOR_SIZE);
679: } else {
680: length = nSectors * IDE_SECTOR_SIZE;
681: nSectors = 0;
682: }
683:
684: [self xferData:taddr read:NO client:client length:length];
685: taddr += length;
686: }
687: ddm_ide_cmd("ideWriteMultiple: data transfer done\n",1,2,3,4,5);
688:
689: ddm_ide_cmd("ideWriteMultiple: waiting for interrupt\n",1,2,3,4,5);
690: rtn = [self ideWaitForInterrupt:IDE_WRITE_MULTIPLE
691: ideStatus:&status];
692: ddm_ide_cmd("ideWriteMultiple: received interrupt\n",1,2,3,4,5);
693:
694: if (rtn != IDER_SUCCESS) {
695: [self getIdeRegisters:ideRegs Print:"Write Multiple"];
696: return (rtn);
697: }
698:
699: if (status & (ERROR | WRITE_FAULT)) {
700: [self getIdeRegisters:ideRegs Print:"Write Multiple"];
701: return IDER_CMD_ERROR;
702: }
703:
704: /*
705: if (status & ERROR_CORRECTED) {
706: IOLog("%s: Corrected error during write.\n", [self name]);
707: }
708: */
709:
710: }
711:
712: ddm_ide_cmd("ideWriteMultiple: completed\n",1,2,3,4,5);
713:
714: return (rtn);
715: }
716:
717: /*
718: * Method: performDMATestOnDrive:(unsigned char)drive
719: *
720: * Purpose:
721: * Read a few sectors and make sure DMA really "seems" to works.
722: *
723: * NOTE: _driveNum must be set prior to calling this method.
724: */
725: - (ide_return_t)performDMATest
726: {
727: ideIoReq_t ideIoReq;
728: ide_return_t status;
729: vm_offset_t tempDmaBuf;
730: vm_offset_t alignBuf;
731: unsigned int currentTimeout;
732: unsigned char dh;
733:
734: /*
735: * The hardware claims to supports DMA. Verify by reading a
736: * few sectors. Allocate memory for dummy buffer.
737: */
738: tempDmaBuf = (vm_offset_t)IOMalloc(PAGE_SIZE);
739: if (tempDmaBuf == NULL) {
740: IOLog("%s: memory allocation failed\n", [self name]);
741: return IDER_REJECT;
742: }
743:
744: /*
745: * Advance the pointer and make the buffer 4 byte aligned.
746: */
747: alignBuf = (tempDmaBuf + 3) & ~3;
748:
749: bzero((unsigned char *)&ideIoReq, sizeof(ideIoReq_t));
750: ideIoReq.cmd = IDE_READ_DMA;
751: ideIoReq.block = 0;
752: ideIoReq.blkcnt = (PAGE_SIZE - 4)/IDE_SECTOR_SIZE;
753: ideIoReq.addr = (caddr_t)alignBuf;
754: ideIoReq.timeout = 5000;
755: ideIoReq.map = (struct vm_map *)IOVmTaskSelf();
756:
757: /*
758: * Select the drive first.
759: */
760: if ([self waitForDeviceIdle] != IDER_SUCCESS) {
761: IOLog("%s: Drive %d DMA test FAILED\n", [self name], _driveNum);
762: return IDER_TIMEOUT;
763: }
764: dh = _drives[_driveNum].addressMode;
765: dh |= (_driveNum ? SEL_DRIVE1 : SEL_DRIVE0);
766: outb(_ideRegsAddrs.drHead, dh);
767:
768: /*
769: * Wait 400ns before reading the status register and make sure the
770: * currently selected drive is ready to accept a command.
771: */
772: IODelay(1);
773: if ([self waitForDeviceIdle] != IDER_SUCCESS) {
774: IOLog("%s: Drive %d DMA test FAILED\n", [self name], _driveNum);
775: return IDER_TIMEOUT;
776: }
777:
778: /*
779: * Clear any unwanted interrupts which may have accumulated.
780: */
781: [self enableInterrupts];
782: IOSleep(100);
783:
784: /*
785: * Set a smaller (3 sec) timeout for this test.
786: */
787: currentTimeout = [self interruptTimeOut];
788: [self setInterruptTimeOut:3000];
789: [self clearInterrupts];
790:
791: /*
792: * Perform test.
793: */
794: if (([self performDMA:(ideIoReq_t *)&ideIoReq]) == IDER_SUCCESS) {
795: status = IDER_SUCCESS;
796: // IOLog("%s: Drive %d: DMA test PASSED\n", [self name], _driveNum);
797: }
798: else {
799: status = IDER_REJECT;
800: IOLog("%s: Drive %d: DMA test FAILED\n", [self name], _driveNum);
801: }
802:
803: /*
804: * Revert the original timeout value and free allocated memory.
805: */
806: [self setInterruptTimeOut:currentTimeout];
807: IOFree((void *)tempDmaBuf, PAGE_SIZE);
808: return status;
809: }
810:
811: /*
812: * All I/O to to controller object is done through this method. We first
813: * acquire a lock before executing any IDE commands since the IDE controller
814: * can do only one thing at a time (both drivers can not be active
815: * simultaneously except for reset and disgnostics).
816: *
817: * If it necessary to call any of the IDE command methods (which are invoked by
818: * the switch() below, like ideReadGetInfoCommon:client:addr:command) it is
819: * necessary to acquire the lock. The IDE command methods should not be
820: * invoked directly by the Disk object.
821: *
822: * This method will in turn call one of several methods which deal with
823: * hardware.
824: */
825:
826: static unsigned char unaligned_warnings;
827: #define UNALIGNED_WARNINGS_MAX 20
828:
829: #define MAX_COMMAND_RETRY 3
830:
831: - (IOReturn) ideExecuteCmd:(ideIoReq_t *)ideIoReq ToDrive:(unsigned char)drive
832: {
833: int retry;
834: ideRegsVal_t irv;
835: unsigned block, cnt;
836: unsigned error;
837: unsigned int maxSectors;
838: unsigned char dh;
839:
840: ddm_ide_cmd("ideExecuteCmd: executing %x\n", ideIoReq->cmd,2,3,4,5);
841:
842: /*
843: * If the controller wishes to put the drive to sleep, it sets this flag
844: * to YES and tries to acquire the lock. This method should not try to
845: * get the lock (and execute any more commands) if the flag is set. This
846: * is needed in order to enter sleep mode as soon as the current command
847: * is finished. If we do not do this there is contention for lock between
848: * the controller (which wants to put the drive to sleep) and this method
849: * (which wants to service more requests). Note that this does not do
850: * away with the need for a lock, it only gives the controller a little
851: * head-start.
852: */
853:
854: while (_driveSleepRequest) {
855: IOSleep(100);
856: }
857:
858: ddm_ide_lock("ideExecuteCmd: acquiring lock\n",1,2,3,4,5);
859: [self ideCntrlrLock];
860: ddm_ide_lock("ideExecuteCmd: acquired lock\n",1,2,3,4,5);
861:
862: /*
863: * Check if we need to do a media access to get the drive respinning
864: * after a suspend operation.
865: */
866: if ([self drivePowerState] != IDE_PM_ACTIVE) {
867: [self startUpAttachedDevices];
868: }
869:
870: _driveNum = drive; /* used by IDE command methods. */
871:
872: for (retry = 0; retry < MAX_COMMAND_RETRY; retry++) {
873:
874: /*
875: * Select the drive first. We don't know the head number at this time so
876: * this register will be rewritten by the specific routine later.
877: *
878: * The Device Selection protocol is defined as follows:
879: * HOST: Read Status or AltStatus register
880: * HOST: Continue reading until BSY = 0, and DRQ = 0
881: * HOST: Write Device/Head register with appropriate DEV bit value
882: * HOST: Wait 400ns
883: * HOST: Read Status or AltStatus register
884: * HOST: Continue reading until BSY = 0, and DRQ = 0
885: *
886: */
887: // [self waitForDeviceIdle]; // Devices should be already in an idle state
888: dh = _drives[_driveNum].addressMode;
889: dh |= (_driveNum ? SEL_DRIVE1 : SEL_DRIVE0);
890: outb(_ideRegsAddrs.drHead, dh);
891: IODelay(1);
892: // [self waitForDeviceIdle]; // Each method below will do their own wait
893:
894: ideIoReq->status = IDER_CMD_ERROR;
895: ideIoReq->blocks_xfered = 0;
896:
897: [self clearInterrupts];
898:
899: switch (ideIoReq->cmd) {
900:
901: case IDE_READ_DMA:
902: if (((vm_offset_t)ideIoReq->addr & 0x03) == 0) {
903: block = ideIoReq->block;
904: cnt = ideIoReq->blkcnt;
905: ddm_ide_log("IDE_READ_DMA: %d\n", cnt, 2, 3, 4, 5);
906: if (cnt > MAX_BLOCKS_PER_XFER) {
907: ideIoReq->status = IDER_REJECT;
908: break;
909: }
910:
911: ideIoReq->status = [self performDMA:ideIoReq];
912: if (ideIoReq->status == IDER_SUCCESS)
913: ideIoReq->blocks_xfered = ideIoReq->blkcnt;
914: break;
915: }
916:
917: /*
918: * If we reached here, it means that the buffer is not 4-byte
919: * aligned. This should not happen.
920: */
921: if (unaligned_warnings < UNALIGNED_WARNINGS_MAX) {
922: IOLog("%s: READ DMA: buffer not 4-byte aligned\n", [self name]);
923: unaligned_warnings++;
924: }
925:
926: case IDE_READ:
927: case IDE_READ_MULTIPLE:
928:
929: block = ideIoReq->block;
930: cnt = ideIoReq->blkcnt;
931: ddm_ide_log("IDE_READ: %d\n", cnt, 2, 3, 4, 5);
932: if (cnt > MAX_BLOCKS_PER_XFER) {
933: ideIoReq->status = IDER_REJECT;
934: break;
935: }
936: ideIoReq->regValues = [self logToPhys:block numOfBlocks:cnt];
937: if (ideIoReq->cmd == IDE_READ)
938: ideIoReq->status =
939: [self ideReadGetInfoCommon:&(ideIoReq->regValues)
940: client:(ideIoReq->map)
941: addr:(ideIoReq->addr) command:IDE_READ];
942: else
943: ideIoReq->status =
944: [self ideReadMultiple:&(ideIoReq->regValues)
945: client:(ideIoReq->map) addr:(ideIoReq->addr)];
946:
947: if (ideIoReq->status == IDER_SUCCESS)
948: ideIoReq->blocks_xfered = ideIoReq->blkcnt;
949: break;
950:
951: case IDE_WRITE_DMA:
952: if (((vm_offset_t)ideIoReq->addr & 0x03) == 0) {
953: block = ideIoReq->block;
954: cnt = ideIoReq->blkcnt;
955: ddm_ide_log("IDE_WRITE_DMA: %d\n", cnt, 2, 3, 4, 5);
956: if (cnt > MAX_BLOCKS_PER_XFER) {
957: ideIoReq->status = IDER_REJECT;
958: break;
959: }
960:
961: ideIoReq->status = [self performDMA:ideIoReq];
962: if (ideIoReq->status == IDER_SUCCESS)
963: ideIoReq->blocks_xfered = ideIoReq->blkcnt;
964: break;
965: }
966:
967: /*
968: * If we reached here, it means that the buffer is not 4-byte
969: * aligned. This should not happen.
970: */
971: if (unaligned_warnings < UNALIGNED_WARNINGS_MAX) {
972: IOLog("%s: WRITE DMA: buffer not 4-byte aligned\n", [self name]);
973: unaligned_warnings++;
974: }
975:
976: case IDE_WRITE:
977: case IDE_WRITE_MULTIPLE:
978:
979: block = ideIoReq->block;
980: cnt = ideIoReq->blkcnt;
981: ddm_ide_log("IDE_WRITE: %d\n", cnt, 2, 3, 4, 5);
982: if (cnt > MAX_BLOCKS_PER_XFER) {
983: ideIoReq->status = IDER_REJECT;
984: break;
985: }
986: ideIoReq->regValues = [self logToPhys:block numOfBlocks:cnt];
987: if (ideIoReq->cmd == IDE_WRITE)
988: ideIoReq->status = [self ideWrite:&(ideIoReq->regValues)
989: client:(ideIoReq->map)
990: addr:(ideIoReq->addr)];
991: else
992: ideIoReq->status =
993: [self ideWriteMultiple:&(ideIoReq->regValues)
994: client:(ideIoReq->map) addr:(ideIoReq->addr)];
995:
996: if (ideIoReq->status == IDER_SUCCESS)
997: ideIoReq->blocks_xfered = ideIoReq->blkcnt;
998: break;
999:
1000: case IDE_SEEK:
1001: block = ideIoReq->block;
1002: cnt = 1;
1003: ideIoReq->regValues = [self logToPhys:block numOfBlocks:cnt];
1004: ideIoReq->status =
1005: [self ideReadVerifySeekCommon:&(ideIoReq->regValues)
1006: command:IDE_SEEK];
1007: break;
1008:
1009: case IDE_RESTORE:
1010: ideIoReq->status = [self ideRestore:&(ideIoReq->regValues)];
1011: break;
1012:
1013: case IDE_READ_VERIFY:
1014: block = ideIoReq->block;
1015: cnt = ideIoReq->blkcnt;
1016: ddm_ide_log("IDE_READ_VERIFY: %d\n", cnt, 2, 3, 4, 5);
1017: if (cnt > MAX_BLOCKS_PER_XFER) {
1018: ideIoReq->status = IDER_REJECT;
1019: break;
1020: }
1021: ideIoReq->regValues = [self logToPhys:block numOfBlocks:cnt];
1022: ideIoReq->status =
1023: [self ideReadVerifySeekCommon:&(ideIoReq->regValues)
1024: command:IDE_READ_VERIFY];
1025: break;
1026:
1027: case IDE_DIAGNOSE:
1028: [self ideDiagnose:&error];
1029: ideIoReq->diagResult = error;
1030: ideIoReq->status = IDER_SUCCESS;
1031: break;
1032:
1033: case IDE_SET_PARAMS:
1034: ideIoReq->status =
1035: [self ideSetParams:_drives[_driveNum].ideInfo.sectors_per_trk
1036: numHeads:_drives[_driveNum].ideInfo.heads ForDrive:_driveNum];
1037: break;
1038:
1039: case IDE_IDENTIFY_DRIVE:
1040: ideIoReq->status =
1041: [self ideReadGetInfoCommon:&(ideIoReq->regValues)
1042: client :(ideIoReq->map) addr :(ideIoReq->addr)
1043: command:IDE_IDENTIFY_DRIVE];
1044:
1045: if (ideIoReq->status == IDER_SUCCESS)
1046: ideIoReq->blocks_xfered = 1;
1047: break;
1048:
1049: case IDE_SET_MULTIPLE:
1050: maxSectors = (_drives[_driveNum].ideIdentifyInfo->multipleSectors)
1051: & IDE_MULTI_SECTOR_MASK;
1052: if (ideIoReq->maxSectorsPerIntr > maxSectors) {
1053: ideIoReq->status = IDER_REJECT;
1054: } else {
1055: ideIoReq->status = [self ideSetMultiSectorMode:
1056: &(ideIoReq->regValues)
1057: numSectors:ideIoReq->maxSectorsPerIntr];
1058: if (ideIoReq->status == IDER_SUCCESS)
1059: _drives[_driveNum].multiSector = ideIoReq->maxSectorsPerIntr;
1060: else
1061: _drives[_driveNum].multiSector = 0;
1062: }
1063: break;
1064:
1065: default:
1066: ideIoReq->status = IDER_REJECT;
1067: ddm_ide_lock("ideExecuteCmd: releasing lock, bad cmd\n",1,2,3,4,5);
1068: [self ideCntrlrUnLock];
1069: return (IDER_REJECT);
1070: }
1071:
1072: /*
1073: * Return if command has been executed successfully or summarily
1074: * rejected.
1075: */
1076: if (ideIoReq->status == IDER_SUCCESS) {
1077: [self ideCntrlrUnLock];
1078: ddm_ide_lock("ideExecuteCmd: releasing lock, success\n",1,2,3,4,5);
1079: return IDER_SUCCESS;
1080: }
1081:
1082: if (ideIoReq->status == IDER_REJECT) {
1083: [self ideCntrlrUnLock];
1084: ddm_ide_lock("ideExecuteCmd: releasing lock, reject\n",1,2,3,4,5);
1085: return IDER_REJECT;
1086: }
1087:
1088: /*
1089: * The command failed to exceute properly but was accepted by the
1090: * drive. Reset the drives and try again.
1091: */
1092: IOLog("%s: ATA command %x failed. Retrying...\n", [self name],
1093: ideIoReq->cmd);
1094: [self getIdeRegisters:NULL Print:"ATA Command"];
1095: [self resetAndInit];
1096:
1097: /*
1098: * resetAndInit will change the value of _driveNum.
1099: * Revert _driveNum to the original value before retrying the
1100: * command.
1101: */
1102: _driveNum = drive;
1103: (void) [self ideRestore:&irv];
1104: }
1105:
1106: /*
1107: * If we get here then this is a catastrophic failure.
1108: */
1109: ddm_ide_lock("ideExecuteCmd: releasing lock, failed\n",1,2,3,4,5);
1110: [self ideCntrlrUnLock];
1111: return ideIoReq->status;
1112: }
1113:
1114: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.