]> git.saurik.com Git - apple/xnu.git/blob - iokit/Families/IOATAStandard/IOATAStandardDevice.cpp
projects / apple / xnu.git / blob
? search:


2d3b5c0be4cfefe08daa6e8b21d7649d405249c9
[apple/xnu.git] / iokit / Families / IOATAStandard / IOATAStandardDevice.cpp
1 /*
2 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * The contents of this file constitute Original Code as defined in and
7 * are subject to the Apple Public Source License Version 1.1 (the
8 * "License"). You may not use this file except in compliance with the
9 * License. Please obtain a copy of the License at
10 * http://www.apple.com/publicsource and read it before using this file.
11 *
12 * This Original Code and all software distributed under the License are
13 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17 * License for the specific language governing rights and limitations
18 * under the License.
19 *
20 * @APPLE_LICENSE_HEADER_END@
21 */
22 /*
23 * IOATAStandardDevice.cpp
24 *
25 */
26
27 #include <IOKit/IOSyncer.h>
28 #include <IOKit/ata/IOATAStandardInterface.h>
29 #include <IOKit/ata/ata-standard/ATAStandardPrivate.h>
30
31 #undef super
32 #define super IOATADevice
33
34 #ifndef MIN
35 #define MIN(a,b) ((a <= b) ? a : b)
36 #endif
37
38 #define round(x,y) (((int)(x) + (y) - 1) & ~((y)-1))
39
40 extern EndianTable AppleIdentifyEndianTable[];
41
42 extern UInt32 AppleNumPIOModes;
43 extern ATAModeTable ApplePIOModes[];
44 extern UInt32 AppleNumDMAModes;
45 extern ATAModeTable AppleDMAModes[];
46 extern UInt32 AppleNumUltraModes;
47 extern ATAModeTable AppleUltraModes[];
48
49 OSDefineMetaClassAndAbstractStructors( IOATADevice, IOCDBDevice )
50 OSDefineMetaClassAndStructors( IOATAStandardDevice, IOATADevice )
51
52 /*
53 *
54 *
55 *
56 */
57 bool IOATAStandardDevice::init( IOATAStandardController *forController, ATAUnit forUnit )
58 {
59 ATATaskfile taskfile;
60 ATACDBInfo ataCDB;
61
62 controller = forController;
63 unit = forUnit;
64
65 target = &controller->targets[unit];
66
67 queue_init( &deviceList );
68 queue_init( &bypassList );
69 queue_init( &activeList );
70 queue_init( &abortList );
71 queue_init( &cancelList );
72
73 clientSem = IORWLockAlloc();
74 if ( clientSem == 0 )
75 {
76 return false;
77 }
78
79 if ( super::init() == false )
80 {
81 return false;
82 }
83
84 if ( controller->controllerInfo.devicePrivateDataSize != 0 )
85 {
86 devicePrivateData = IOMallocContiguous( controller->controllerInfo.devicePrivateDataSize, 16, 0 );
87 if ( devicePrivateData == 0 )
88 {
89 return false;
90 }
91 }
92
93 bzero( &ataCDB, sizeof(ataCDB) );
94
95 probeCmd = allocCommand(kIOATAStandardDevice, 0);
96 if ( probeCmd == 0 )
97 {
98 return false;
99 }
100
101 abortCmd = allocCommand(kIOATAStandardDevice, 0);
102 if ( abortCmd == 0 )
103 {
104 return false;
105 }
106 abortCmd->setTimeout( kATAAbortTimeoutmS );
107
108 cancelCmd = allocCommand(kIOATAStandardDevice, 0);
109 if ( cancelCmd == 0 )
110 {
111 return false;
112 }
113 cancelCmd->setTimeout( 0 );
114 cancelCmd->cmdType = kATACommandCancel;
115
116 reqSenseCmd = allocCommand(kIOATAStandardDevice, 0);
117 if ( reqSenseCmd == 0 )
118 {
119 return false;
120 }
121
122 bzero( &taskfile, sizeof(taskfile) );
123 taskfile.protocol = kATAProtocolATAPIPIO;
124 taskfile.tagType = kATATagTypeNone;
125
126 taskfile.resultmask = ATARegtoMask( kATARegStatus );
127
128 taskfile.regmask = ATARegtoMask( kATARegATAPIFeatures )
129 | ATARegtoMask( kATARegATAPIByteCountLow )
130 | ATARegtoMask( kATARegATAPIByteCountHigh )
131 | ATARegtoMask( kATARegATAPIDeviceSelect )
132 | ATARegtoMask( kATARegATAPICommand );
133
134 taskfile.ataRegs[kATARegATAPIFeatures] = 0;
135 taskfile.ataRegs[kATARegATAPIByteCountLow] = 0xfe;
136 taskfile.ataRegs[kATARegATAPIByteCountHigh] = 0xff;
137 taskfile.ataRegs[kATARegATAPIDeviceSelect] = kATAModeLBA | (getUnit() << 4);
138 taskfile.ataRegs[kATARegATAPICommand] = kATACommandATAPIPacket;
139
140 reqSenseCmd->setTaskfile( &taskfile );
141
142 ataCDB.cdbLength = 12;
143 ataCDB.cdb[0] = kATAPICmdRequestSense;
144
145 reqSenseCmd->setTimeout( kATAReqSenseTimeoutmS );
146 reqSenseCmd->cmdType = kATACommandReqSense;
147 reqSenseCmd->setCDB( &ataCDB );
148
149 deviceGate = IOCommandGate::commandGate( this, (IOCommandGate::Action) &IOATAStandardDevice::receiveCommand );
150 if ( deviceGate == 0 )
151 {
152 return false;
153 }
154
155 if ( controller->workLoop->addEventSource( deviceGate ) != kIOReturnSuccess )
156 {
157 return false;
158 }
159
160 commandLimitSave = commandLimit = 1;
161
162 idleNotifyActive = false;
163
164 normalQHeld = 0;
165 bypassQHeld = 0;
166
167 currentTiming = kATATimingPIO;
168
169 return true;
170 }
171
172 IOReturn IOATAStandardDevice::probeDevice()
173 {
174 OSDictionary *propTable = 0;
175
176 if ( doIdentify( (void **)&identifyData ) != kIOReturnSuccess )
177 {
178 goto probeDevice_error;
179 }
180
181 if ( deviceType == kATADeviceATA )
182 {
183 doSpinUp();
184 }
185
186 else if ( deviceType == kATADeviceATAPI )
187 {
188 atapiPktInt = ((identifyData->generalConfiguration & kATAPIPktProtocolIntDRQ) != 0);
189
190 if ( doInquiry( (void **)&inquiryData ) != kIOReturnSuccess )
191 {
192 goto probeDevice_error;
193 }
194 }
195
196 if ( getATATimings() != true )
197 {
198 goto probeDevice_error;
199 }
200
201 if ( maxTags != 0 )
202 {
203 tagArraySize = round( maxTags, 32 ) / 8;
204 tagArray = (UInt32 *)IOMalloc( tagArraySize );
205 if ( tagArray == 0 )
206 {
207 goto probeDevice_error;
208 }
209 bzero( tagArray, tagArraySize );
210 }
211
212 propTable = createProperties();
213 if ( !propTable )
214 {
215 goto probeDevice_error;
216 }
217
218 setPropertyTable( propTable );
219
220 propTable->release();
221
222 close( this, 0 );
223
224 return true;
225
226 probeDevice_error: ;
227 close( this, 0 );
228 return false;
229 }
230
231 /*
232 *
233 *
234 *
235 */
236 ATADeviceType IOATAStandardDevice::probeDeviceType()
237 {
238 ATATaskfile taskfile;
239 ATAResults results;
240
241 bzero( (void *)&taskfile, sizeof(taskfile) );
242
243 taskfile.protocol = kATAProtocolSetRegs;
244 taskfile.regmask = ATARegtoMask(kATARegDriveHead);
245
246 taskfile.resultmask = ATARegtoMask(kATARegSectorCount)
247 | ATARegtoMask(kATARegSectorNumber)
248 | ATARegtoMask(kATARegCylinderLow)
249 | ATARegtoMask(kATARegCylinderHigh)
250 | ATARegtoMask(kATARegStatus);
251
252 taskfile.flags = kATACmdFlagTimingChanged;
253
254 taskfile.ataRegs[kATARegDriveHead] = kATAModeLBA | (getUnit() << 4);
255
256 probeCmd->setQueueInfo();
257 probeCmd->setTaskfile( &taskfile );
258 probeCmd->execute();
259
260 if ( probeCmd->getResults( &results ) != kIOReturnSuccess )
261 {
262 return (deviceType = kATADeviceNone);
263 }
264
265 if ( results.ataRegs[kATARegSectorCount] == kATASignatureSectorCount
266 && results.ataRegs[kATARegSectorNumber] == kATASignatureSectorNumber
267 && results.ataRegs[kATARegCylinderLow] == kATASignatureCylinderLow
268 && results.ataRegs[kATARegCylinderHigh] == kATASignatureCylinderHigh )
269 {
270 if ( !(results.ataRegs[kATARegStatus] & kATAStatusBSY)
271 && (results.ataRegs[kATARegStatus] & kATAStatusDRDY) )
272 {
273 return (deviceType = kATADeviceATA);
274 }
275 }
276
277 if ( results.ataRegs[kATARegCylinderLow] == kATAPISignatureCylinderLow
278 && results.ataRegs[kATARegCylinderHigh] == kATAPISignatureCylinderHigh )
279 {
280 return (deviceType = kATADeviceATAPI);
281 }
282
283 return (deviceType = kATADeviceNone);
284 }
285
286
287 /*
288 *
289 *
290 *
291 */
292 IOReturn IOATAStandardDevice::doSpinUp()
293 {
294 void *buffer = NULL;
295 IOReturn rc;
296
297 rc = doSectorCommand( kATACommandReadSector, 0, 1, &buffer );
298
299 if ( rc != kIOReturnSuccess )
300 {
301 return rc;
302 }
303
304 IOFree( buffer, 512 );
305
306 return rc ;
307 }
308
309 /*
310 *
311 *
312 *
313 */
314 IOReturn IOATAStandardDevice::doIdentify( void **dataPtr )
315 {
316 ATACommand ataCmd;
317 IOReturn rc;
318
319 ataCmd = (deviceType == kATADeviceATA) ? kATACommandIdentify : kATACommandATAPIIdentify;
320
321 rc = doSectorCommand( ataCmd, 0, 1, dataPtr );
322
323 if ( rc != kIOReturnSuccess )
324 {
325 return rc;
326 }
327
328 endianConvertData( *dataPtr, AppleIdentifyEndianTable );
329
330 return rc;
331 }
332
333
334
335 /*
336 *
337 *
338 *
339 */
340 IOReturn IOATAStandardDevice::doSectorCommand( ATACommand ataCmd, UInt32 ataLBA, UInt32 ataCount, void **dataPtr )
341 {
342 ATATaskfile taskfile;
343 ATAResults result;
344 IOMemoryDescriptor *desc;
345 UInt32 size;
346 void *data;
347 UInt32 i;
348 IOReturn rc;
349
350 *dataPtr = NULL;
351
352 size = ataCount * 512;
353
354 if ( !(data = (void *)IOMalloc(size)) )
355 {
356 return kIOReturnNoMemory;
357 }
358
359 bzero( &taskfile, sizeof(taskfile) );
360
361 desc = IOMemoryDescriptor::withAddress( data, size, kIODirectionIn );
362 if ( desc == NULL )
363 {
364 rc = kIOReturnNoMemory;
365 goto doSectorCommand_error;
366 }
367
368
369 taskfile.protocol = kATAProtocolPIO;
370 taskfile.regmask = ATARegtoMask(kATARegDriveHead)
371 | ATARegtoMask(kATARegSectorCount)
372 | ATARegtoMask(kATARegSectorNumber)
373 | ATARegtoMask(kATARegCylinderLow)
374 | ATARegtoMask(kATARegCylinderHigh)
375 | ATARegtoMask(kATARegFeatures)
376 | ATARegtoMask(kATARegCommand);
377
378
379 taskfile.resultmask = ATARegtoMask(kATARegError)
380 | ATARegtoMask(kATARegStatus);
381
382 taskfile.ataRegs[kATARegSectorCount] = ataCount;
383 taskfile.ataRegs[kATARegSectorNumber] = ataLBA & 0xff;
384 taskfile.ataRegs[kATARegCylinderLow] = (ataLBA >> 8) & 0xff;
385 taskfile.ataRegs[kATARegCylinderHigh] = (ataLBA >> 16) & 0xff;
386 taskfile.ataRegs[kATARegDriveHead] = (ataLBA >> 24) & 0x0f;
387
388 taskfile.ataRegs[kATARegDriveHead] |= kATAModeLBA | (getUnit() << 4);
389 taskfile.ataRegs[kATARegCommand] = ataCmd;
390
391 probeCmd->setQueueInfo();
392
393 for ( i = 0; i < 2; i++ )
394 {
395 probeCmd->setTimeout( 25000 );
396 probeCmd->setTaskfile( &taskfile );
397 probeCmd->setPointers( desc, size, false );
398 probeCmd->execute();
399
400 rc = probeCmd->getResults( &result );
401 if ( rc == kIOReturnSuccess )
402 {
403 break;
404 }
405 }
406
407
408 doSectorCommand_error: ;
409
410 desc->release();
411
412 if ( rc != kIOReturnSuccess )
413 {
414 IOFree( data, size );
415 return result.returnCode;
416 }
417
418 *dataPtr = data;
419
420 return kIOReturnSuccess;
421 }
422
423
424 /*
425 *
426 *
427 */
428 IOReturn IOATAStandardDevice::doInquiry( void **dataPtr )
429 {
430 ATATaskfile taskfile;
431 ATACDBInfo atapiCmd;
432 ATAResults result;
433 void *data;
434 IOMemoryDescriptor *desc;
435 UInt32 size = sizeof(ATAPIInquiry);
436
437 *dataPtr = 0;
438
439 if ( !(data = (void *)IOMalloc(size)) )
440 {
441 return kIOReturnNoMemory;
442 }
443
444 bzero( data, size );
445 bzero( &taskfile, sizeof(taskfile) );
446 bzero( &atapiCmd, sizeof(atapiCmd) );
447
448 desc = IOMemoryDescriptor::withAddress( data, size, kIODirectionIn );
449
450 taskfile.protocol = kATAProtocolATAPIPIO;
451 taskfile.regmask = ATARegtoMask(kATARegATAPIDeviceSelect)
452 | ATARegtoMask(kATARegATAPICommand)
453 | ATARegtoMask(kATARegATAPIByteCountLow)
454 | ATARegtoMask(kATARegATAPIByteCountHigh)
455 | ATARegtoMask(kATARegATAPIFeatures);
456 taskfile.ataRegs[kATARegATAPIDeviceSelect] = kATAModeLBA | (getUnit() << 4);
457 taskfile.ataRegs[kATARegATAPICommand] = kATACommandATAPIPacket;
458 taskfile.ataRegs[kATARegATAPIFeatures] = 0;
459 taskfile.ataRegs[kATARegATAPIByteCountLow] = 0xfe;
460 taskfile.ataRegs[kATARegATAPIByteCountHigh] = 0xff;
461
462 atapiCmd.cdbLength = 12; // Fix 16 byte cmdpkts??
463 atapiCmd.cdb[0] = 0x12;
464 atapiCmd.cdb[4] = size;
465
466 probeCmd->setCDB( &atapiCmd );
467 probeCmd->setTaskfile( &taskfile );
468 probeCmd->setPointers( desc, size, false );
469 probeCmd->setTimeout( 5000 );
470 probeCmd->setQueueInfo();
471 probeCmd->execute();
472
473 if ( probeCmd->getResults(&result) == kIOReturnSuccess )
474 {
475 *dataPtr = data;
476 }
477 else if ( ( result.returnCode == kIOReturnUnderrun ) &&
478 ( result.bytesTransferred >= 36 ) )
479 {
480 // The standard INQUIRY contain 36 required bytes,
481 // the rest is optional and vendor specific.
482
483 result.returnCode = kIOReturnSuccess;
484 *dataPtr = data;
485 }
486 else
487 {
488 IOFree( data, size );
489 }
490
491 desc->release();
492
493 return result.returnCode;
494 }
495
496 /*
497 *
498 *
499 */
500 bool IOATAStandardDevice::getDeviceCapacity( UInt32 *blockMax, UInt32 *blockSize )
501 {
502 UInt32 i;
503 UInt32 data[2];
504
505 if ( deviceType == kATADeviceATA )
506 {
507 if ( identifyData != NULL )
508 {
509 *blockMax = *(UInt32 *)identifyData->userAddressableSectors - 1;
510 *blockSize = 512;
511 return true;
512 }
513 }
514
515 if ( deviceType == kATADeviceATAPI )
516 {
517 for ( i=0; i < 8; i++ )
518 {
519 if ( doTestUnitReady() == kIOReturnSuccess )
520 {
521 break;
522 }
523 }
524
525 if ( doReadCapacity( data ) == kIOReturnSuccess )
526 {
527 *blockMax = OSSwapBigToHostInt32( data[0] );
528 *blockSize = OSSwapBigToHostInt32( data[1] );
529 return true;
530 }
531 }
532
533 return false;
534 }
535
536
537 IOReturn IOATAStandardDevice::doTestUnitReady()
538 {
539 ATATaskfile taskfile;
540 ATACDBInfo atapiCmd;
541 ATAResults result;
542
543 bzero( &taskfile, sizeof(taskfile) );
544 bzero( &atapiCmd, sizeof(atapiCmd) );
545
546 taskfile.protocol = kATAProtocolATAPIPIO;
547
548 taskfile.regmask = ATARegtoMask(kATARegATAPIDeviceSelect)
549 | ATARegtoMask(kATARegATAPICommand)
550 | ATARegtoMask(kATARegATAPIByteCountLow)
551 | ATARegtoMask(kATARegATAPIByteCountHigh)
552 | ATARegtoMask(kATARegATAPIFeatures);
553
554 taskfile.ataRegs[kATARegATAPIDeviceSelect] = kATAModeLBA | (getUnit() << 4);
555 taskfile.ataRegs[kATARegATAPICommand] = kATACommandATAPIPacket;
556 taskfile.ataRegs[kATARegATAPIFeatures] = 0;
557 taskfile.ataRegs[kATARegATAPIByteCountLow] = 0xfe;
558 taskfile.ataRegs[kATARegATAPIByteCountHigh] = 0xff;
559
560 atapiCmd.cdbLength = 12; // Fix 16 byte cmdpkts??
561 atapiCmd.cdb[0] = 0x00;
562
563 probeCmd->setCDB( &atapiCmd );
564 probeCmd->setTaskfile( &taskfile );
565 probeCmd->setPointers( (IOMemoryDescriptor *)NULL, 0, false );
566 probeCmd->setTimeout( 5000 );
567 probeCmd->setQueueInfo();
568 probeCmd->execute();
569 probeCmd->getResults(&result);
570
571 return result.returnCode;
572 }
573
574
575 /*
576 *
577 *
578 */
579 IOReturn IOATAStandardDevice::doReadCapacity( void *data )
580 {
581 ATATaskfile taskfile;
582 ATACDBInfo atapiCmd;
583 ATAResults result;
584 IOMemoryDescriptor *dataDesc;
585 UInt32 size = 8;
586
587
588 bzero( &taskfile, sizeof(taskfile) );
589 bzero( &atapiCmd, sizeof(atapiCmd) );
590
591 dataDesc = IOMemoryDescriptor::withAddress( data, size, kIODirectionIn );
592 if ( dataDesc == NULL )
593 {
594 return kIOReturnNoMemory;
595 }
596
597 taskfile.protocol = kATAProtocolATAPIPIO;
598 taskfile.regmask = ATARegtoMask(kATARegATAPIDeviceSelect)
599 | ATARegtoMask(kATARegATAPICommand)
600 | ATARegtoMask(kATARegATAPIByteCountLow)
601 | ATARegtoMask(kATARegATAPIByteCountHigh)
602 | ATARegtoMask(kATARegATAPIFeatures);
603 taskfile.ataRegs[kATARegATAPIDeviceSelect] = kATAModeLBA | (getUnit() << 4);
604 taskfile.ataRegs[kATARegATAPICommand] = kATACommandATAPIPacket;
605 taskfile.ataRegs[kATARegATAPIFeatures] = 0;
606 taskfile.ataRegs[kATARegATAPIByteCountLow] = 0xfe;
607 taskfile.ataRegs[kATARegATAPIByteCountHigh] = 0xff;
608
609 atapiCmd.cdbLength = 12; // Fix 16 byte cmdpkts??
610 atapiCmd.cdb[0] = 0x25;
611
612 probeCmd->setCDB( &atapiCmd );
613 probeCmd->setTaskfile( &taskfile );
614 probeCmd->setPointers( dataDesc, size, false );
615 probeCmd->setTimeout( 5000 );
616 probeCmd->setQueueInfo();
617 probeCmd->execute();
618
619 probeCmd->getResults(&result);
620
621 dataDesc->release();
622
623 return result.returnCode;
624 }
625
626 /*
627 *
628 *
629 */
630 bool IOATAStandardDevice::getTimingsSupported( ATATimingProtocol *timingsSupported )
631 {
632 UInt32 i;
633
634 *(UInt32 *)timingsSupported = 0;
635
636 for ( i=0; i < numTimings; i++ )
637 {
638 *(UInt32 *) timingsSupported |= (UInt32)ataTimings[i].timingProtocol;
639 }
640
641 return true;
642 }
643
644 /*
645 *
646 *
647 */
648 bool IOATAStandardDevice::getTimingSelected( ATATimingProtocol *timingSelected )
649 {
650 *timingSelected = currentTiming;
651 return true;
652 }
653
654 /*
655 *
656 *
657 */
658 bool IOATAStandardDevice::getProtocolsSupported( ATAProtocol *forProtocolsSupported )
659 {
660 *(UInt32 *)forProtocolsSupported = protocolsSupported;
661 return true;
662 }
663
664 /*
665 *
666 *
667 */
668 bool IOATAStandardDevice::getTiming( ATATimingProtocol *timingProtocol, ATATiming *timing )
669 {
670 UInt32 i;
671
672 for ( i=0; i < numTimings; i++ )
673 {
674 if ( ataTimings[i].timingProtocol == *timingProtocol )
675 {
676 bcopy( &ataTimings[i], timing, sizeof(ATATiming) );
677 return true;
678 }
679 }
680
681 return false;
682 }
683
684
685 /*
686 *
687 *
688 */
689 bool IOATAStandardDevice::selectTiming( ATATimingProtocol timingProtocol, bool fNotifyMsg )
690 {
691 ATATaskfile taskfile;
692 bool rc = false;
693 UInt32 i;
694 IOATAStandardCommand * ataCmd;
695
696 for ( i=0; i < numTimings; i++ )
697 {
698 if ( ataTimings[i].timingProtocol == timingProtocol )
699 {
700 rc = true;
701 break;
702 }
703 }
704
705 if ( rc == false )
706 {
707 return false;
708 }
709
710 ataCmd = allocCommand(kIOATAStandardDevice, 0);
711 if ( ataCmd == 0 ) return false;
712
713 currentTiming = timingProtocol;
714
715 bzero( &taskfile, sizeof(taskfile) );
716
717 taskfile.protocol = kATAProtocolPIO;
718 taskfile.regmask = ATARegtoMask(kATARegFeatures)
719 | ATARegtoMask(kATARegSectorCount)
720 | ATARegtoMask(kATARegDriveHead)
721 | ATARegtoMask(kATARegCommand);
722
723 taskfile.ataRegs[kATARegSectorCount] = ataTimings[i].featureSetting;
724 taskfile.ataRegs[kATARegFeatures] = kATAFeatureTransferMode;
725 taskfile.ataRegs[kATARegDriveHead] = kATAModeLBA | (getUnit() << 4);
726 taskfile.ataRegs[kATARegCommand] = kATACommandSetFeatures;
727
728 taskfile.flags = kATACmdFlagTimingChanged;
729
730 ataCmd->setTaskfile( &taskfile );
731 ataCmd->setPointers( (IOMemoryDescriptor *)NULL, 0, false );
732 ataCmd->setTimeout( 5000 );
733 ataCmd->setQueueInfo( kATAQTypeBypassQ );
734
735 if ( fNotifyMsg == false )
736 {
737 ataCmd->setCallback();
738 ataCmd->execute();
739 if ( ataCmd->getResults( (ATAResults *) 0 ) != kIOReturnSuccess )
740 {
741 rc = false;
742 }
743 ataCmd->release();
744 }
745 else
746 {
747 ataCmd->setCallback( this, (CallbackFn)&IOATAStandardDevice::selectTimingDone, ataCmd );
748 ataCmd->execute();
749 }
750 return rc;
751 }
752
753 /*
754 *
755 *
756 */
757 void IOATAStandardDevice::selectTimingDone( IOATAStandardCommand *ataCmd )
758 {
759 bool rc;
760
761 rc = (ataCmd->getResults( (ATAResults *)0 ) == kIOReturnSuccess);
762
763 client->message( kATAClientMsgSelectTiming | kATAClientMsgDone, this, (void *)rc );
764
765 ataCmd->release();
766 }
767
768 /*
769 *
770 *
771 */
772 bool IOATAStandardDevice::getATATimings()
773 {
774 int i, n;
775 UInt32 mode = 0;
776 UInt32 cycleTime = 0;
777
778 ATATiming *pTimings;
779
780 if ( controller->getProtocolsSupported( (ATAProtocol *)&protocolsSupported ) == false )
781 {
782 return false;
783 }
784
785 pTimings = ataTimings;
786
787 /*
788 * PIO Cycle timing......
789 *
790 * 1. Try to match Word 51 (pioCycleTime) with cycle timings
791 * in our pioModes table to get mode/CycleTime. (Valid for Modes 0-2)
792 * 2. If Words 64-68 are supported and Mode 3 or 4 supported check,
793 * update CycleTime with Word 68 (CycleTimeWithIORDY).
794 */
795
796 cycleTime = identifyData->pioMode;
797
798 if ( cycleTime > 2 )
799 {
800 for ( i=AppleNumPIOModes-1; i != -1; i-- )
801 {
802 if ( cycleTime <= ApplePIOModes[i].minDataCycle )
803 {
804 mode = i;
805 break;
806 }
807 }
808
809 if ( i == -1 )
810 {
811 cycleTime = ApplePIOModes[mode].minDataCycle;
812 }
813 }
814 else
815 {
816 mode = cycleTime;
817 cycleTime = ApplePIOModes[mode].minDataCycle;
818 }
819
820
821 if ( identifyData->validFields & identifyWords_64to70_Valid )
822 {
823 if (identifyData->advancedPIOModes & advPIOModes_Mode4_Supported)
824 mode = 4;
825 else if (identifyData->advancedPIOModes & advPIOModes_Mode3_Supported)
826 mode = 3;
827
828 if ( (mode >= 3) && identifyData->minPIOCyclcTimeIORDY )
829 {
830 cycleTime = identifyData->minPIOCyclcTimeIORDY;
831 }
832 }
833
834 pTimings->timingProtocol = kATATimingPIO;
835 pTimings->mode = mode;
836 pTimings->featureSetting = mode | kATATransferModePIOwFC;
837 pTimings->minDataCycle = cycleTime;
838 pTimings->minDataAccess = ApplePIOModes[mode].minDataAccess;
839
840 if ( ((protocolsSupported & kATAProtocolPIO) == 0)
841 || (controller->calculateTiming( getUnit(), pTimings ) == false) )
842 {
843 IOLog("IOATAStandardDevice::%s() - Controller driver must support PIO protocol\n\r", __FUNCTION__);
844 return false;
845 }
846
847 pTimings++;
848 numTimings++;
849
850 /*
851 * Multiword DMA timing.....
852 *
853 * 1. Check Word 63(7:0) (Multiword DMA Modes Supported). Lookup
854 * CycleTime for highest mode we support.
855 * 2. If Words 64-68 supported, update CycleTime from Word 66
856 * (RecommendedMultiWordCycleTime) if specified.
857 */
858
859 n = identifyData->dmaModes & dmaModes_Supported;
860 if ( n )
861 {
862 for ( i=0; n; i++, n>>=1 )
863 ;
864
865 mode = i - 1;
866 if ( mode > AppleNumDMAModes-1 )
867 {
868 mode = AppleNumDMAModes-1;
869 }
870 cycleTime = AppleDMAModes[mode].minDataCycle;
871
872 if (identifyData->validFields & identifyWords_64to70_Valid)
873 {
874 if ( identifyData->recDMACycleTime )
875 {
876 cycleTime = identifyData->recDMACycleTime;
877 }
878 }
879 pTimings->timingProtocol = kATATimingDMA;
880 pTimings->mode = mode;
881 pTimings->featureSetting = mode | kATATransferModeDMA;
882 pTimings->minDataCycle = cycleTime;
883 pTimings->minDataAccess = AppleDMAModes[mode].minDataAccess;
884
885 if ( ((protocolsSupported & kATAProtocolDMA) != 0)
886 && (controller->calculateTiming( getUnit(), pTimings ) == true) )
887 {
888 pTimings++;
889 numTimings++;
890 }
891 }
892
893 /*
894 * Ultra DMA timing.....
895 *
896 */
897 if ( identifyData->validFields & identifyWords_88to88_Valid )
898 {
899 n = identifyData->ultraDMAModes & ultraDMAModes_Supported;
900 if ( n )
901 {
902 for ( i=0; n; i++, n>>=1 )
903 ;
904
905 mode = i - 1;
906 if ( mode > AppleNumUltraModes-1 )
907 {
908 mode = AppleNumUltraModes-1;
909 }
910
911 /*
912 * Build a separate timing entry for Ultra DMA/33 (mode <= 2) and Ultra DMA/66
913 */
914 while ( 1 )
915 {
916 cycleTime = AppleUltraModes[mode].minDataCycle;
917
918 pTimings->timingProtocol = (mode > 2) ? kATATimingUltraDMA66 : kATATimingUltraDMA33;
919 pTimings->mode = mode;
920 pTimings->featureSetting = mode | kATATransferModeUltraDMA33;
921 pTimings->minDataCycle = cycleTime;
922 pTimings->minDataAccess = AppleUltraModes[mode].minDataAccess;
923
924 if ( ((protocolsSupported & kATAProtocolDMA) != 0)
925 && (controller->calculateTiming( getUnit(), pTimings ) == true) )
926 {
927 pTimings++;
928 numTimings++;
929 }
930
931 if ( mode < 3 ) break;
932
933 mode = 2;
934 }
935 }
936 }
937
938 maxTags = 0;
939
940 if ( deviceType == kATADeviceATA )
941 {
942 if ( ((identifyData->commandSetsSupported2 & commandSetsSupported2_ValidMask) == commandSetsSupported2_Valid)
943 && ((identifyData->commandSetsSupported3 & commandSetsSupported3_ValidMask) == commandSetsSupported3_Valid) )
944 {
945 if ( ((identifyData->commandSetsSupported2 & commandSetsSupported2_DMAQueued) != 0)
946 && ((identifyData->commandSetsEnabled2 & commandSetsEnabled2_DMAQueued) != 0) )
947 {
948 maxTags = identifyData->queueDepth + 1;
949 }
950 }
951 }
952
953 if ( maxTags == 0 )
954 {
955 protocolsSupported &= ~(kATAProtocolDMAQueued | kATAProtocolDMAQueuedRelease);
956 }
957
958
959 return true;
960 }
961
962 /*
963 *
964 *
965 *
966 */
967 ATAUnit IOATAStandardDevice::getUnit()
968 {
969 return unit;
970 }
971
972 /*
973 *
974 *
975 */
976 ATADeviceType IOATAStandardDevice::getDeviceType()
977 {
978 return deviceType;
979 }
980
981 /*
982 *
983 *
984 */
985 bool IOATAStandardDevice::getATAPIPktInt()
986 {
987 return atapiPktInt;
988 }
989
990 /*
991 *
992 *
993 */
994 bool IOATAStandardDevice::getIdentifyData( ATAIdentify *identifyBuffer )
995 {
996 if ( identifyData == NULL )
997 {
998 bzero( identifyBuffer, sizeof(ATAIdentify) );
999 return false;
1000 }
1001
1002 bcopy( identifyData, identifyBuffer, sizeof(ATAIdentify) );
1003 return true;
1004 }
1005
1006 /*
1007 *
1008 *
1009 */
1010 bool IOATAStandardDevice::getInquiryData( UInt32 inquiryBufLength, ATAPIInquiry *inquiryBuffer )
1011 {
1012 bzero( inquiryBuffer, inquiryBufLength );
1013
1014 if ( inquiryData == NULL )
1015 {
1016 return false;
1017 }
1018
1019 bcopy( inquiryData, inquiryBuffer, inquiryBufLength );
1020
1021 return true;
1022 }
1023
1024
1025 /*
1026 *
1027 *
1028 *
1029 */
1030 void IOATAStandardDevice::setupTarget()
1031 {
1032 }
1033
1034 /*
1035 *
1036 *
1037 *
1038 */
1039 void IOATAStandardDevice::getInquiryData( void *clientBuf, UInt32 clientBufSize, UInt32 *clientDataSize )
1040 {
1041 UInt32 len;
1042
1043 bzero( clientBuf, clientBufSize );
1044
1045 len = MIN( clientBufSize, inquiryDataSize );
1046
1047 bcopy( inquiryData, clientBuf, len );
1048
1049 *clientDataSize = len;
1050 }
1051
1052 /*
1053 *
1054 *
1055 *
1056 */
1057 void IOATAStandardDevice::abort()
1058 {
1059 submitCommand( kATACommandAbortAll, 0 );
1060 }
1061
1062 /*
1063 *
1064 *
1065 *
1066 */
1067 void IOATAStandardDevice::reset()
1068 {
1069 submitCommand( kATACommandDeviceReset, 0 );
1070 }
1071
1072 /*
1073 *
1074 *
1075 *
1076 */
1077 void IOATAStandardDevice::holdQueue( UInt32 queueType )
1078 {
1079 if ( getWorkLoop()->inGate() == false )
1080 {
1081 IOPanic( "IOATAStandardDevice::holdQueue() - must be called from workloop!!\n\r");
1082 }
1083
1084 if ( queueType == kATAQTypeBypassQ )
1085 {
1086 bypassQHeld++;
1087 }
1088 else if ( queueType == kATAQTypeNormalQ )
1089 {
1090 normalQHeld++;
1091 }
1092 }
1093
1094 /*
1095 *
1096 *
1097 *
1098 */
1099 void IOATAStandardDevice::releaseQueue( UInt32 queueType )
1100 {
1101 bool doDispatchRequest = false;
1102
1103 if ( getWorkLoop()->inGate() == false )
1104 {
1105 IOPanic( "IOATAStandardDevice::releaseQueue() - must be called from workloop!!\n\r");
1106 }
1107
1108 if ( queueType == kATAQTypeBypassQ )
1109 {
1110 if ( bypassQHeld && (--bypassQHeld == 0) )
1111 doDispatchRequest = true;
1112 }
1113 else if ( queueType == kATAQTypeNormalQ )
1114 {
1115 if ( normalQHeld && (--normalQHeld == 0) )
1116 doDispatchRequest = true;
1117 }
1118
1119 if ( doDispatchRequest ) dispatchRequest();
1120 }
1121
1122 /*
1123 *
1124 *
1125 *
1126 */
1127 void IOATAStandardDevice::notifyIdle( void *target = 0, CallbackFn callback = 0, void *refcon = 0 )
1128 {
1129 if ( getWorkLoop()->inGate() == false )
1130 {
1131 IOPanic( "IOATAStandardDevice:::notifyIdle() - must be called from workloop!!\n\r");
1132 }
1133
1134 if ( callback == 0 )
1135 {
1136 idleNotifyActive = false;
1137 return;
1138 }
1139
1140 if ( idleNotifyActive == true )
1141 {
1142 IOPanic( "IOATAStandardDevice:::notifyIdle() - only one idle notify may be active\n\r");
1143 }
1144
1145 idleNotifyActive = true;
1146 idleNotifyTarget = target;
1147 idleNotifyCallback = callback;
1148 idleNotifyRefcon = refcon;
1149
1150 checkIdleNotify();
1151 }
1152
1153
1154 /*
1155 *
1156 *
1157 *
1158 */
1159 void IOATAStandardDevice::submitCommand( UInt32 cmdType, IOATAStandardCommand *ataCmd, UInt32 cmdSequenceNumber )
1160 {
1161 deviceGate->runCommand( (void *)cmdType, (void *)ataCmd, (void *) cmdSequenceNumber, (void *) 0 );
1162 }
1163
1164 /*
1165 *
1166 *
1167 *
1168 */
1169 void IOATAStandardDevice::receiveCommand( UInt32 cmdType, IOATAStandardCommand *ataCmd, UInt32 cmdSequenceNumber, void *p3 )
1170 {
1171 queue_head_t *queue;
1172
1173 switch ( cmdType )
1174 {
1175 case kATACommandExecute:
1176 ataCmd->cmdType = (ATACommandType) cmdType;
1177
1178 queue = (ataCmd->queueType == kATAQTypeBypassQ) ? &bypassList : &deviceList;
1179
1180 if ( ataCmd->queuePosition == kATAQPositionHead )
1181 {
1182 stackCommand( queue, ataCmd );
1183 }
1184 else
1185 {
1186 addCommand( queue, ataCmd );
1187 }
1188
1189 dispatchRequest();
1190 break;
1191
1192 case kATACommandAbortAll:
1193 abortAllCommands( kATACommandAbortAll );
1194 break;
1195
1196 case kATACommandAbort:
1197 abortCommand( ataCmd, cmdSequenceNumber );
1198 break;
1199
1200 case kATACommandDeviceReset:
1201 abortAllCommands( kATACommandDeviceReset );
1202 break;
1203
1204 default:
1205 /* ??? */
1206 break;
1207 }
1208 }
1209
1210 /*
1211 *
1212 *
1213 *
1214 */
1215 void IOATAStandardDevice::abortCommand( IOATAStandardCommand *ataCmd, UInt32 sequenceNumber )
1216 {
1217 if ( ataCmd->list == (queue_head_t *)deviceGate )
1218 {
1219 if ( ataCmd->sequenceNumber != sequenceNumber )
1220 {
1221 return;
1222 }
1223 ataCmd->results.returnCode = kIOReturnAborted;
1224 }
1225 else if ( ataCmd->list == &deviceList )
1226 {
1227 if ( ataCmd->sequenceNumber != sequenceNumber )
1228 {
1229 return;
1230 }
1231
1232 deleteCommand( &deviceList, ataCmd );
1233 ataCmd->results.returnCode = kIOReturnAborted;
1234 finishCommand( ataCmd );
1235 }
1236 else if ( ataCmd->list == &activeList )
1237 {
1238 if ( ataCmd->sequenceNumber != sequenceNumber )
1239 {
1240 return;
1241 }
1242
1243 moveCommand( &activeList, &abortList, ataCmd );
1244
1245 dispatchRequest();
1246 }
1247 }
1248
1249
1250 /*
1251 *
1252 *
1253 *
1254 */
1255 void IOATAStandardDevice::abortAllCommands( ATACommandType cmdType )
1256 {
1257
1258 abortCmdPending = cmdType;
1259
1260 if ( abortCmdPending == kATACommandAbortAll )
1261 {
1262 if ( client != 0 )
1263 {
1264 client->message( kATAClientMsgDeviceAbort, this );
1265 }
1266 }
1267 else if ( abortCmdPending == kATACommandDeviceReset )
1268 {
1269 if ( client != 0 )
1270 {
1271 client->message( kATAClientMsgDeviceReset, this );
1272 }
1273 }
1274
1275 dispatchRequest();
1276 }
1277
1278 /*
1279 *
1280 *
1281 *
1282 */
1283 void IOATAStandardDevice::resetOccurred( ATAClientMessage clientMsg )
1284 {
1285 moveAllCommands( &activeList, &cancelList, kIOReturnAborted );
1286 moveAllCommands( &abortList, &cancelList, kIOReturnAborted );
1287
1288 abortState = kStateIdle;
1289 reqSenseState = kStateIdle;
1290 commandLimit = 1;
1291
1292 isSuspended = false;
1293 AbsoluteTime_to_scalar( &suspendTime ) = 0;
1294
1295 if ( (client != 0) && (clientMsg != kATAClientMsgNone) )
1296 {
1297 client->message( clientMsg, this );
1298 }
1299
1300 dispatchRequest();
1301 }
1302
1303 void IOATAStandardDevice::resetComplete()
1304 {
1305 if ( client != 0 )
1306 {
1307 client->message( kATAClientMsgBusReset | kATAClientMsgDone, this );
1308 }
1309 }
1310
1311
1312 /*
1313 *
1314 *
1315 *
1316 */
1317 bool IOATAStandardDevice::checkAbortQueue()
1318 {
1319 IOATAStandardCommand *origCmd;
1320
1321 if ( abortState == kStateActive )
1322 {
1323 return true;
1324 }
1325
1326 if ( abortCmdPending != kATACommandNone )
1327 {
1328 abortCmd->origCommand = 0;
1329 abortCmd->taskfile.tagType = kATATagTypeNone;
1330 abortCmd->cmdType = abortCmdPending;
1331
1332 abortCmd->timer = ( abortCmd->timeout != 0 ) ?
1333 abortCmd->timeout / kATATimerIntervalmS + 1 : 0;
1334
1335 bzero( &abortCmd->results, sizeof(ATAResults) );
1336
1337 abortState = kStateActive;
1338
1339 addCommand( &activeList, abortCmd );
1340
1341 if ( (abortCmdPending == kATACommandDeviceReset) ||
1342 (abortCmdPending == kATACommandAbortAll) && (queue_empty( &abortList ) == false) )
1343 {
1344 controller->abortCommand( abortCmd );
1345 }
1346 else
1347 {
1348 abortCmd->complete();
1349 }
1350 }
1351 else if ( queue_empty( &abortList ) == false )
1352 {
1353 origCmd = (IOATAStandardCommand *)queue_first( &abortList );
1354 abortCmd->origCommand = origCmd;
1355
1356 abortCmd->cmdType = kATACommandAbort;
1357 abortCmd->taskfile.tagType = origCmd->taskfile.tagType;
1358 abortCmd->taskfile.tag = origCmd->taskfile.tag;
1359
1360 abortCmd->timer = ( abortCmd->timeout != 0 ) ?
1361 abortCmd->timeout / kATATimerIntervalmS + 1 : 0;
1362
1363 bzero( &abortCmd->results, sizeof(ATAResults) );
1364
1365 abortState = kStateActive;
1366
1367 addCommand( &activeList, abortCmd );
1368 controller->abortCommand( abortCmd );
1369 }
1370 else
1371 {
1372 return false;
1373 }
1374
1375 return true;
1376 }
1377
1378 /*
1379 *
1380 *
1381 *
1382 */
1383 void IOATAStandardDevice::checkCancelQueue()
1384 {
1385 if ( cancelState != kStateIdle )
1386 {
1387 return;
1388 }
1389
1390 if ( queue_empty( &cancelList ) == true )
1391 {
1392 return;
1393 }
1394
1395 if ( controller->controllerInfo.disableCancelCommands == true )
1396 {
1397 return;
1398 }
1399
1400 cancelCmd->origCommand = (IOATAStandardCommand *)queue_first( &cancelList );
1401 bzero( &cancelCmd->results, sizeof(ATAResults) );
1402
1403 cancelState = kStateActive;
1404 controller->cancelCommand( cancelCmd );
1405 }
1406
1407 /*
1408 *
1409 *
1410 *
1411 */
1412 bool IOATAStandardDevice::checkReqSense()
1413 {
1414 IOMemoryDescriptor *senseData;
1415 UInt32 senseLength;
1416
1417 if ( reqSenseState == kStateIssue )
1418 {
1419 reqSenseCmd->origCommand = reqSenseOrigCmd;
1420 bzero( &reqSenseCmd->results, sizeof(ATAResults) );
1421
1422 reqSenseOrigCmd->getPointers( &senseData, &senseLength, 0, true );
1423 reqSenseCmd->setPointers( senseData, senseLength, false );
1424
1425 reqSenseCmd->timer = ( reqSenseCmd->timeout != 0 ) ?
1426 reqSenseCmd->timeout / kATATimerIntervalmS + 1 : 0;
1427
1428 reqSenseCmd->ataCmd.cdb[3] = (senseLength >> 8) & 0xff;
1429 reqSenseCmd->ataCmd.cdb[4] = senseLength & 0xff;
1430
1431 reqSenseState = kStatePending;
1432 }
1433
1434 if ( reqSenseState == kStatePending )
1435 {
1436 reqSenseState = kStateActive;
1437
1438 addCommand( &activeList, reqSenseCmd );
1439
1440 commandCount++;
1441 controller->commandCount++;
1442
1443 controller->executeCommand( reqSenseCmd );
1444 }
1445
1446 return (reqSenseState != kStateIdle);
1447 }
1448
1449
1450 /*
1451 *
1452 *
1453 *
1454 */
1455 bool IOATAStandardDevice::checkDeviceQueue( UInt32 *dispatchAction )
1456 {
1457 IOATAStandardCommand *ataCmd = 0;
1458 queue_head_t *queue;
1459 UInt32 i;
1460 bool rc = true;
1461 UInt32 queueHeld;
1462
1463 do
1464 {
1465 if ( isSuspended == true )
1466 {
1467 *dispatchAction = kDispatchNextDevice;
1468 break;
1469 }
1470
1471 if ( controller->commandCount >= controller->commandLimit )
1472 {
1473 *dispatchAction = kDispatchStop;
1474 break;
1475 }
1476
1477 *dispatchAction = kDispatchNextDevice;
1478
1479 if ( commandCount >= commandLimit )
1480 {
1481 break;
1482 }
1483
1484 for ( i=0; i < 2; i++ )
1485 {
1486 queueHeld = (i == 0) ? bypassQHeld : normalQHeld;
1487 queue = (i == 0) ? &bypassList : &deviceList;
1488
1489 if ( queueHeld > 0 )
1490 {
1491 continue;
1492 }
1493
1494 ataCmd = checkCommand( queue );
1495 if ( ataCmd != 0 )
1496 {
1497 *dispatchAction = kDispatchNextCommand;
1498 break;
1499 }
1500 }
1501
1502 if ( i == 2 )
1503 {
1504 rc = false;
1505 break;
1506 }
1507
1508
1509 if ( checkTag( ataCmd ) == false )
1510 {
1511 *dispatchAction = kDispatchNextDevice;
1512 break;
1513 }
1514
1515 getCommand( queue );
1516
1517 ataCmd->timer = ( ataCmd->timeout != 0 ) ? ataCmd->timeout / kATATimerIntervalmS + 1 : 0;
1518
1519 commandCount++;
1520 controller->commandCount++;
1521
1522 addCommand( &activeList, ataCmd );
1523
1524 controller->executeCommand( ataCmd );
1525
1526 } while ( 0 );
1527
1528 return rc;
1529 }
1530
1531 /*
1532 *
1533 *
1534 *
1535 */
1536 void IOATAStandardDevice::suspend()
1537 {
1538 if ( AbsoluteTime_to_scalar( &suspendTime ) == 0 )
1539 {
1540 clock_get_uptime( &suspendTime );
1541 }
1542
1543 isSuspended = true;
1544 }
1545
1546 /*
1547 *
1548 *
1549 *
1550 */
1551 void IOATAStandardDevice::resume()
1552 {
1553 AbsoluteTime_to_scalar( &suspendTime ) = 0;
1554 isSuspended = false;
1555
1556 dispatchRequest();
1557 }
1558
1559
1560 /*
1561 *
1562 *
1563 *
1564 */
1565 void IOATAStandardDevice::rescheduleCommand( IOATAStandardCommand *ataCmd )
1566 {
1567 queue_head_t *queue;
1568
1569 if ( ataCmd->list != &activeList )
1570 {
1571 IOLog( "IOATAStandardController::rescheduleCommand() - Command not active. Cmd = %08x\n\r", (int)ataCmd );
1572 return;
1573 }
1574
1575 deleteCommand( &activeList, ataCmd );
1576
1577 switch ( ataCmd->cmdType )
1578 {
1579 case kATACommandExecute:
1580 if ( ataCmd->taskfile.tagType != kATATagTypeNone )
1581 {
1582 freeTag( ataCmd->taskfile.tag );
1583 ataCmd->taskfile.tag = kATATagTypeNone;
1584 }
1585
1586 queue = (ataCmd->queueType == kATAQTypeBypassQ) ? &bypassList : &deviceList;
1587
1588 stackCommand( queue, ataCmd );
1589
1590 controller->commandCount--;
1591 commandCount--;
1592 break;
1593
1594 case kATACommandReqSense:
1595 reqSenseState = kStatePending;
1596 commandCount--;
1597 controller->commandCount--;
1598 break;
1599
1600 case kATACommandAbortAll:
1601 case kATACommandDeviceReset:
1602 abortCmdPending = ataCmd->cmdType;
1603
1604 case kATACommandAbort:
1605 abortState = kStateIdle;
1606 break;
1607
1608 default:
1609 ;
1610 }
1611
1612 dispatchRequest();
1613
1614 }
1615
1616 /*
1617 *
1618 *
1619 *
1620 */
1621 bool IOATAStandardDevice::checkTag( IOATAStandardCommand *ataCmd )
1622 {
1623 ATACDBInfo ataCDB;
1624 bool rc = true;
1625 ATAProtocol protocol;
1626
1627 ataCmd->getCDB( &ataCDB );
1628
1629 ataCmd->taskfile.tagType = kATATagTypeNone;
1630
1631 protocol = ataCmd->getProtocol();
1632
1633 do
1634 {
1635 if ( protocol != kATAProtocolDMAQueued && protocol != kATAProtocolDMAQueuedRelease )
1636 {
1637 break;
1638 }
1639 if ( allocTag( &ataCmd->taskfile.tag ) == false )
1640 {
1641 rc = false;
1642 break;
1643 }
1644
1645 ataCmd->taskfile.tagType = kATATagTypeSimple;
1646 }
1647 while ( 0 );
1648
1649 ataCmd->setCDB( &ataCDB );
1650
1651 return rc;
1652 }
1653
1654 /*
1655 *
1656 *
1657 *
1658 */
1659 bool IOATAStandardDevice::allocTag( UInt32 *tagId )
1660 {
1661 UInt32 i;
1662 UInt32 tagIndex;
1663 UInt32 tagMask;
1664 UInt32 *tags = 0;
1665
1666 tags = tagArray;
1667
1668 if ( tags == 0 ) return false;
1669
1670 for ( i = 0; i < maxTags; i++ )
1671 {
1672 tagIndex = i / 32;
1673 tagMask = 1 << (i % 32);
1674 if ( !(tags[tagIndex] & tagMask) )
1675 {
1676 tags[tagIndex] |= tagMask;
1677 *tagId = i;
1678 return true;
1679 }
1680 }
1681 return false;
1682 }
1683
1684 /*
1685 *
1686 *
1687 *
1688 */
1689 void IOATAStandardDevice::freeTag( UInt32 tagId )
1690 {
1691 UInt32 *tags = 0;
1692
1693 tags = tagArray;
1694
1695 if ( tags == 0 ) return;
1696
1697 tags[tagId/32] &= ~(1 << (tagId % 32));
1698 }
1699
1700 /*
1701 *
1702 *
1703 *
1704 */
1705 IOATAStandardCommand *IOATAStandardDevice::findCommandWithNexus( UInt32 tagValue )
1706 {
1707 IOATAStandardCommand *ataCmd;
1708 UInt32 tag;
1709
1710 queue_iterate( &activeList, ataCmd, IOATAStandardCommand *, nextCommand )
1711 {
1712 switch ( ataCmd->cmdType )
1713 {
1714 case kATACommandExecute:
1715 case kATACommandReqSense:
1716 tag = (ataCmd->taskfile.tagType == kATATagTypeNone) ? (UInt32) -1 : ataCmd->taskfile.tag;
1717 if ( tag == tagValue )
1718 {
1719 return ataCmd;
1720 }
1721 break;
1722 default:
1723 ;
1724 }
1725 }
1726
1727 queue_iterate( &abortList, ataCmd, IOATAStandardCommand *, nextCommand )
1728 {
1729 switch ( ataCmd->cmdType )
1730 {
1731 case kATACommandExecute:
1732 case kATACommandReqSense:
1733 if ( ataCmd->taskfile.tag == tagValue )
1734 {
1735 return ataCmd;
1736 }
1737 break;
1738 default:
1739 ;
1740 }
1741 }
1742
1743 return 0;
1744 }
1745
1746 /*
1747 *
1748 *
1749 *
1750 */
1751 void IOATAStandardDevice::timer()
1752 {
1753 IOATAStandardCommand *ataCmd, *tmp = 0;
1754
1755 queue_iterate( &activeList, ataCmd, IOATAStandardCommand *, nextCommand )
1756 {
1757 tmp = (IOATAStandardCommand *)queue_prev( &ataCmd->nextCommand );
1758
1759 if ( ataCmd->timer )
1760 {
1761 if ( !--ataCmd->timer )
1762 {
1763 IOLog("Timeout: Unit = %d Cmd = %08x Cmd Type = %d\n\r",
1764 unit, (int)ataCmd, ataCmd->cmdType );
1765
1766 controller->busResetState = kStateIssue;
1767 dispatchRequest();
1768 }
1769 }
1770
1771 if ( queue_end( &activeList, (queue_head_t *)ataCmd ) == true )
1772 {
1773 break;
1774 }
1775 }
1776 }
1777
1778 /*
1779 *
1780 *
1781 *
1782 */
1783 void IOATAStandardDevice::dispatchRequest()
1784 {
1785 target->state = kStateActive;
1786 controller->dispatchRequest();
1787 }
1788
1789 /*
1790 *
1791 *
1792 *
1793 */
1794 bool IOATAStandardDevice::dispatch( UInt32 *dispatchAction )
1795 {
1796 bool rc;
1797
1798 checkCancelQueue();
1799
1800 if ( controller->checkBusReset() == true )
1801 {
1802 *dispatchAction = kDispatchStop;
1803 return true;
1804 }
1805
1806 if ( checkAbortQueue() == true )
1807 {
1808 *dispatchAction = kDispatchNextDevice;
1809 return true;
1810 }
1811
1812 do
1813 {
1814 if ( (rc = controller->commandDisable) == true )
1815 {
1816 *dispatchAction = kDispatchStop;
1817 break;
1818 }
1819
1820 if ( isSuspended == true )
1821 {
1822 *dispatchAction = kDispatchNextDevice;
1823 break;
1824 }
1825
1826 if ( (rc = checkReqSense()) == true )
1827 {
1828 *dispatchAction = kDispatchNextDevice;
1829 break;
1830 }
1831
1832 rc = checkDeviceQueue( dispatchAction );
1833
1834 } while ( *dispatchAction == kDispatchNextCommand );
1835
1836 return rc;
1837 }
1838
1839
1840 /*
1841 *
1842 *
1843 *
1844 */
1845 void IOATAStandardDevice::completeCommand( IOATAStandardCommand *ataCmd )
1846 {
1847 ATACommandType cmdType;
1848
1849 cmdType = ataCmd->cmdType;
1850 switch ( cmdType )
1851 {
1852 case kATACommandExecute:
1853 executeCommandDone( ataCmd );
1854 break;
1855
1856 case kATACommandReqSense:
1857 executeReqSenseDone( ataCmd );
1858 break;
1859
1860 case kATACommandAbort:
1861 case kATACommandAbortAll:
1862 case kATACommandDeviceReset:
1863 abortCommandDone( ataCmd );
1864 break;
1865
1866 case kATACommandCancel:
1867 cancelCommandDone( ataCmd );
1868 break;
1869
1870 default:
1871 ;
1872 }
1873
1874 checkIdleNotify();
1875
1876 dispatchRequest();
1877 }
1878
1879 /*
1880 *
1881 *
1882 *
1883 */
1884 void IOATAStandardDevice::checkIdleNotify()
1885 {
1886 if ( idleNotifyActive == false )
1887 {
1888 return;
1889 }
1890
1891 if ( (queue_empty( &activeList ) == true)
1892 && (queue_empty( &abortList ) == true)
1893 && (queue_empty( &cancelList ) == true) )
1894 {
1895 idleNotifyActive = false;
1896 (idleNotifyCallback)( idleNotifyTarget, idleNotifyRefcon );
1897 }
1898 }
1899
1900 /*
1901 *
1902 *
1903 *
1904 */
1905 void IOATAStandardDevice::flushQueue( UInt32 queueType, IOReturn rc )
1906 {
1907 queue_head_t *queue;
1908
1909 queue = (queueType == kATAQTypeBypassQ) ? &bypassList : &deviceList;
1910 purgeAllCommands( queue, rc );
1911 }
1912
1913 /*
1914 *
1915 *
1916 *
1917 */
1918 void IOATAStandardDevice::executeCommandDone( IOATAStandardCommand *ataCmd )
1919 {
1920 deleteCommand( ataCmd->list, ataCmd );
1921
1922 commandCount--;
1923 controller->commandCount--;
1924
1925 if ( ataCmd->taskfile.tagType != kATATagTypeNone )
1926 {
1927 freeTag( ataCmd->taskfile.tag );
1928 ataCmd->taskfile.tagType = kATATagTypeNone;
1929 }
1930
1931 if ( deviceType == kATADeviceATAPI
1932 && ataCmd->results.adapterStatus == kATAReturnStatusError
1933 && ataCmd->results.requestSenseDone == false
1934 && ataCmd->senseData != 0 )
1935 {
1936 reqSenseOrigCmd = ataCmd;
1937 reqSenseState = kStateIssue;
1938 return;
1939 }
1940
1941 finishCommand( ataCmd );
1942 }
1943
1944 /*
1945 *
1946 *
1947 *
1948 */
1949 void IOATAStandardDevice::executeReqSenseDone( IOATAStandardCommand *ataCmd )
1950 {
1951 IOATAStandardCommand *origCommand;
1952
1953 deleteCommand( ataCmd->list, ataCmd );
1954
1955 commandCount--;
1956 controller->commandCount--;
1957
1958 reqSenseState = kStateIdle;
1959
1960 reqSenseOrigCmd = 0;
1961
1962 origCommand = ataCmd->origCommand;
1963
1964 if ( (ataCmd->results.returnCode == kIOReturnSuccess) || (ataCmd->results.returnCode == kIOReturnUnderrun))
1965 {
1966 origCommand->results.requestSenseDone = true;
1967 origCommand->results.requestSenseLength = ataCmd->results.bytesTransferred;
1968 }
1969 else
1970 {
1971 origCommand->results.requestSenseDone = false;
1972 origCommand->results.requestSenseLength = 0;
1973 }
1974
1975 finishCommand( ataCmd->origCommand );
1976 }
1977
1978 /*
1979 *
1980 *
1981 *
1982 */
1983 void IOATAStandardDevice::abortCommandDone( IOATAStandardCommand *ataCmd )
1984 {
1985 IOATAStandardCommand *origATACmd;
1986
1987 deleteCommand( ataCmd->list, ataCmd );
1988
1989 if ( ataCmd->cmdType == kATACommandAbortAll )
1990 {
1991 resetOccurred( (ATAClientMessage) (kATAClientMsgDeviceAbort | kATAClientMsgDone) );
1992 abortCmdPending = kATACommandNone;
1993 }
1994 if ( ataCmd->cmdType == kATACommandDeviceReset )
1995 {
1996 resetOccurred( (ATAClientMessage) (kATAClientMsgDeviceReset | kATAClientMsgDone) );
1997 abortCmdPending = kATACommandNone;
1998 }
1999 else if ( ataCmd->cmdType == kATACommandAbort )
2000 {
2001 origATACmd = ataCmd->origCommand;
2002
2003 if ( findCommand( &abortList, origATACmd ) == true )
2004 {
2005 moveCommand( &abortList, &cancelList, origATACmd, kIOReturnAborted );
2006 }
2007 }
2008
2009 abortState = kStateIdle;
2010
2011 return;
2012 }
2013
2014 /*
2015 *
2016 *
2017 *
2018 */
2019 void IOATAStandardDevice::cancelCommandDone( IOATAStandardCommand *ataCmd )
2020 {
2021 IOATAStandardCommand *origATACmd;
2022
2023 cancelState = kStateIdle;
2024
2025 origATACmd = ataCmd->origCommand;
2026
2027 if ( findCommand( &cancelList, origATACmd ) == true )
2028 {
2029 IOLog( "IOATAStandardDevice::cancelCommandDone - Cancelled command not completed - ataCmd = %08x\n\r", (int)origATACmd );
2030 deleteCommand( &cancelList, origATACmd );
2031 }
2032 }
2033
2034 /*
2035 *
2036 *
2037 *
2038 */
2039 void IOATAStandardDevice::finishCommand( IOATAStandardCommand *ataCmd )
2040 {
2041 if ( ataCmd->completionInfo.async.callback )
2042 {
2043 (*ataCmd->completionInfo.async.callback)( ataCmd->completionInfo.async.target,
2044 ataCmd->completionInfo.async.refcon );
2045 }
2046 else
2047 {
2048 ataCmd->completionInfo.sync.lock->signal();
2049 }
2050 }
2051
2052
2053 /*
2054 *
2055 *
2056 */
2057 OSDictionary *IOATAStandardDevice::createProperties()
2058 {
2059 OSDictionary *propTable = 0;
2060 OSObject *regObj;
2061 char tmpbuf[81];
2062 const char *s;
2063 char *d;
2064
2065
2066 propTable = OSDictionary::withCapacity(kATAMaxProperties);
2067 if ( propTable == NULL )
2068 {
2069 return NULL;
2070 }
2071
2072 s = (deviceType == kATADeviceATA) ? kATAPropertyProtocolATA : kATAPropertyProtocolATAPI;
2073 regObj = (OSObject *)OSString::withCString( s );
2074 if ( addToRegistry( propTable, regObj, kATAPropertyProtocol ) != true )
2075 {
2076 goto createprop_error;
2077 }
2078
2079 regObj = (OSObject *)OSNumber::withNumber(unit,32);
2080 if ( addToRegistry( propTable, regObj, kATAPropertyDeviceNumber ) != true )
2081 {
2082 goto createprop_error;
2083 }
2084
2085 regObj = (OSObject *)OSNumber::withNumber(unit,32);
2086 if ( addToRegistry( propTable, regObj, kATAPropertyLocation ) != true )
2087 {
2088 goto createprop_error;
2089 }
2090
2091 d = tmpbuf;
2092 stripBlanks( d, (char *)identifyData->modelNumber, sizeof(identifyData->modelNumber));
2093 regObj = (OSObject *)OSString::withCString( d );
2094 if ( addToRegistry( propTable, regObj, kATAPropertyModelNumber ) != true )
2095 {
2096 goto createprop_error;
2097 }
2098
2099 d = tmpbuf;
2100 stripBlanks( d, (char *)identifyData->firmwareRevision, sizeof(identifyData->firmwareRevision));
2101 regObj = (OSObject *)OSString::withCString( d );
2102 if ( addToRegistry( propTable, regObj, kATAPropertyFirmwareRev ) != true )
2103 {
2104 goto createprop_error;
2105 }
2106
2107 if ( inquiryData )
2108 {
2109 stripBlanks( d, (char *)inquiryData->vendorName, sizeof(inquiryData->vendorName) );
2110 regObj = (OSObject *)OSString::withCString( d );
2111 if ( addToRegistry( propTable, regObj, kATAPropertyVendorName ) != true )
2112 {
2113 goto createprop_error;
2114 }
2115
2116 stripBlanks( d, (char *)inquiryData->productName, sizeof(inquiryData->productName) );
2117 regObj = (OSObject *)OSString::withCString( d );
2118 if ( addToRegistry( propTable, regObj, kATAPropertyProductName ) != true )
2119 {
2120 goto createprop_error;
2121 }
2122
2123 stripBlanks( d, (char *)inquiryData->productRevision, sizeof(inquiryData->productRevision) );
2124 regObj = (OSObject *)OSString::withCString( d );
2125 if ( addToRegistry( propTable, regObj, kATAPropertyProductRevision ) != true )
2126 {
2127 goto createprop_error;
2128 }
2129 }
2130 return propTable;
2131
2132 createprop_error: ;
2133 propTable->release();
2134 return NULL;
2135 }
2136
2137
2138 /*
2139 *
2140 *
2141 */
2142 bool IOATAStandardDevice::addToRegistry( OSDictionary *propTable, OSObject *regObj, char *key,
2143 bool doRelease = true )
2144 {
2145 bool rc;
2146
2147 if ( regObj == NULL )
2148 {
2149 return false;
2150 }
2151
2152 rc = propTable->setObject( key, regObj );
2153
2154 if ( doRelease )
2155 {
2156 // If 'doRelease' is true, then a reference count is consumed.
2157 regObj->release();
2158 }
2159
2160 return rc;
2161 }
2162
2163
2164 /*
2165 *
2166 *
2167 *
2168 */
2169 bool IOATAStandardDevice::matchPropertyTable(OSDictionary * table)
2170 {
2171 return( controller->matchNubWithPropertyTable( this, table ));
2172 }
2173
2174
2175 /*
2176 *
2177 *
2178 *
2179 */
2180 IOService *IOATAStandardDevice::matchLocation(IOService * client)
2181 {
2182 return this;
2183 }
2184
2185
2186 /*
2187 *
2188 *
2189 *
2190 */
2191 void IOATAStandardDevice::stripBlanks( char *d, char *s, UInt32 l )
2192 {
2193 char *p, c;
2194
2195 for ( p = d, c = *s; l && c ; l--)
2196 {
2197 c = (*d++ = *s++);
2198 if ( c != ' ' )
2199 {
2200 p = d;
2201 }
2202 }
2203 *p = 0;
2204 }
2205
2206 /*
2207 *
2208 *
2209 */
2210 void IOATAStandardDevice::endianConvertData( void *data, void *endianTable )
2211 {
2212 EndianTable *t;
2213
2214 union EndianPtr
2215 {
2216 void *voidPtr;
2217 UInt8 *bytePtr;
2218 UInt16 *shortPtr;
2219 UInt32 *longPtr;
2220 UInt64 *longlongPtr;
2221 } p;
2222
2223 UInt32 i,j;
2224
2225 p.voidPtr = data;
2226
2227 t = (EndianTable *)endianTable;
2228
2229 for ( ; t->type; t++ )
2230 {
2231 i = t->size/t->type;
2232
2233 switch ( t->type )
2234 {
2235
2236 /* Note:
2237 *
2238 * The ATA standard defines identify strings as arrays of short ints,
2239 * with the left-most character of the string as the most significant
2240 * byte of the short int. Strings are not normally affected by the host
2241 * endianess. However, the way ATA defines strings would cause strings
2242 * to appear byte reversed. We do a manditory short int byte-swap here,
2243 * although strictly speaking this is not an endian issue.
2244 *
2245 */
2246 case sizeof(UInt8):
2247 for ( j = 0; j < i/2; j++ )
2248 {
2249 *p.shortPtr++ = OSSwapInt16(*p.shortPtr);
2250 }
2251
2252 break;
2253
2254 case sizeof(UInt16):
2255 for ( j = 0; j < i; j++ )
2256 {
2257 *p.shortPtr++ = OSSwapLittleToHostInt16(*p.shortPtr);
2258 }
2259 break;
2260
2261 case sizeof(UInt32):
2262 for ( j = 0; j < i; j++ )
2263 {
2264 *p.longPtr++ = OSSwapLittleToHostInt32(*p.longPtr);
2265 }
2266 break;
2267
2268 case sizeof(UInt64):
2269 for ( j = 0; j < i; j++ )
2270 {
2271 *p.longlongPtr++ = OSSwapLittleToHostInt64(*p.longlongPtr);
2272 }
2273 break;
2274
2275 default:
2276 ;
2277 }
2278 }
2279 }
2280
2281 /*
2282 *
2283 *
2284 *
2285 */
2286 IOATACommand *IOATAStandardDevice::allocCommand( IOATADevice *, UInt32 clientDataSize )
2287 {
2288 return (IOATAStandardCommand *) allocCommand( kIOATAStandardDevice, clientDataSize );
2289 }
2290
2291 IOCDBCommand *IOATAStandardDevice::allocCommand( IOCDBDevice *, UInt32 clientDataSize )
2292 {
2293 return (IOCDBCommand *) allocCommand( kIOATAStandardDevice, clientDataSize );
2294 }
2295
2296 IOATAStandardCommand *IOATAStandardDevice::allocCommand( IOATAStandardDevice *, UInt32 clientDataSize )
2297 {
2298 IOATAStandardCommand *cmd;
2299
2300 if ( (cmd = controller->allocCommand( clientDataSize )) )
2301 {
2302 cmd->device = this;
2303 }
2304 return cmd;
2305 }
2306
2307
2308 /*
2309 *
2310 *
2311 */
2312 IOWorkLoop *IOATAStandardDevice::getWorkLoop() const
2313 {
2314 return controller->workLoop;
2315 }
2316
2317
2318 /*
2319 *
2320 *
2321 *
2322 */
2323 bool IOATAStandardDevice::open( IOService *forClient, IOOptionBits options, void *arg )
2324 {
2325 if ( client != 0 ) return false;
2326
2327 client = forClient;
2328
2329 return super::open( forClient, options, arg );
2330 }
2331
2332 /*
2333 *
2334 *
2335 *
2336 */
2337 void IOATAStandardDevice::close( IOService *forClient, IOOptionBits options )
2338 {
2339 client = 0;
2340
2341 return super::close( forClient, options );
2342 }
2343
2344 /*
2345 *
2346 *
2347 *
2348 */
2349 void IOATAStandardDevice::free()
2350 {
2351 if ( deviceGate != 0 )
2352 {
2353 controller->workLoop->removeEventSource( deviceGate );
2354 deviceGate->release();
2355 }
2356
2357 if ( reqSenseCmd != 0 ) reqSenseCmd->release();
2358 if ( abortCmd != 0 ) abortCmd->release();
2359 if ( cancelCmd != 0 ) cancelCmd->release();
2360 if ( probeCmd != 0 ) probeCmd->release();
2361
2362 if ( tagArray != 0 ) IOFree( tagArray, tagArraySize );
2363 if ( inquiryData != 0 ) IOFree( inquiryData, inquiryDataSize );
2364 if ( devicePrivateData != 0 ) IOFreeContiguous( devicePrivateData, controller->controllerInfo.devicePrivateDataSize );
2365 if ( clientSem != 0 ) IORWLockFree( clientSem );
2366
2367 super::free();
2368 }
2369
2370
mirror of XNU