IOATAStandardDevice.h [plain text]
#ifndef _IOATASTANDARDDEVICE_H
#define _IOATASTANDARDDEVICE_H
class IOATAStandardController;
class IOATAStandardDevice : public IOATADevice
{
OSDeclareDefaultStructors(IOATAStandardDevice)
friend class IOATAStandardCommand;
friend class IOATAStandardController;
public:
IOCDBCommand *allocCommand( IOCDBDevice *deviceType, UInt32 clientDataSize = 0 );
void abort();
void reset();
void getInquiryData( void *inquiryBuffer,
UInt32 inquiryBufSize,
UInt32 *inquiryDataSize );
public:
IOATAStandardCommand *allocCommand( IOATAStandardDevice *deviceType, UInt32 clientDataSize = 0 );
ATAUnit getUnit();
ATADeviceType getDeviceType();
bool getIdentifyData( ATAIdentify *identifyBuffer );
bool getInquiryData( UInt32 inquiryBufSize, ATAPIInquiry *inquiryBuffer );
bool getDeviceCapacity( UInt32 *blockMax, UInt32 *blockSize );
bool getProtocolsSupported( ATAProtocol *protocolsSupported );
bool getTimingsSupported( ATATimingProtocol *timingsSupported );
bool getTimingSelected( ATATimingProtocol *timingProtocol );
bool getTiming( ATATimingProtocol *timingProtocol, ATATiming *timing );
bool getATAPIPktInt();
bool selectTiming( ATATimingProtocol timingProtocol, bool fNotifyMsg = false );
void holdQueue( UInt32 queueType );
void releaseQueue( UInt32 queueType );
void flushQueue( UInt32 queueType, IOReturn rc );
void notifyIdle( void *target = 0, CallbackFn callback = 0, void *refcon = 0 );
IOWorkLoop *getWorkLoop() const;
public:
bool open( IOService *forClient, IOOptionBits options, void *arg );
void close( IOService *forClient, IOOptionBits options );
bool init( IOATAStandardController *forController, ATAUnit forUnit );
void free();
bool matchPropertyTable( OSDictionary * table );
IOService *matchLocation( IOService * client );
IOATACommand *allocCommand( IOATADevice *deviceType, UInt32 clientDataSize = 0 );
private:
void submitCommand( UInt32 cmdType, IOATAStandardCommand *ataCmd, UInt32 cmdSequenceNumber = 0 );
void receiveCommand( UInt32 cmdType, IOATAStandardCommand *ataCmd, UInt32 cmdSequenceNumber, void *p3 );
IOReturn probeDevice();
ATADeviceType probeDeviceType();
IOReturn doSpinUp();
IOReturn doIdentify( void **dataPtr );
IOReturn doSectorCommand( ATACommand ataCmd, UInt32 ataLBA, UInt32 ataCount, void **dataPtr );
IOReturn doInquiry( void **dataPtr );
IOReturn doTestUnitReady();
IOReturn doReadCapacity( void *data );
bool getATATimings();
void selectTimingDone( IOATAStandardCommand *ataCmd );
void setupTarget();
void dispatchRequest();
bool dispatch( UInt32 *dispatchAction );
void abortAllCommands( ATACommandType abortCmdType );
IOATAStandardCommand *findCommandWithNexus( UInt32 tagValue );
void abortCommand( IOATAStandardCommand *ataCmd, UInt32 cmdSequenceNumber );
void completeCommand( IOATAStandardCommand *cmd );
void checkIdleNotify();
void executeCommandDone( IOATAStandardCommand *ataCmd );
void executeReqSenseDone( IOATAStandardCommand *ataCmd );
void abortCommandDone( IOATAStandardCommand *ataCmd );
void cancelCommandDone( IOATAStandardCommand *ataCmd );
void finishCommand( IOATAStandardCommand *ataCmd );
OSDictionary *createProperties();
bool addToRegistry( OSDictionary *propTable, OSObject *regObj, char *key, bool doRelease = true );
void stripBlanks( char *d, char *s, UInt32 l );
void endianConvertData( void *data, void *endianTable );
bool checkDeviceQueue( UInt32 *dispatchAction );
void checkNegotiate( IOATAStandardCommand *ataCmd );
bool checkTag( IOATAStandardCommand *ataCmd );
bool checkReqSense();
bool checkAbortQueue();
void checkCancelQueue();
bool allocTag( UInt32 *tagId );
void freeTag( UInt32 tagId );
void timer();
void resetOccurred( ATAClientMessage clientMsg = kATAClientMsgNone );
void resetComplete();
void rescheduleCommand( IOATAStandardCommand *ataCmd );
void suspend();
void resume();
void addCommand( queue_head_t *list, IOATAStandardCommand *ataCmd );
void stackCommand( queue_head_t *list, IOATAStandardCommand *ataCmd );
void deleteCommand( queue_head_t *list, IOATAStandardCommand *ataCmd, IOReturn rc = kIOReturnSuccess );
IOATAStandardCommand *checkCommand( queue_head_t *list );
IOATAStandardCommand *getCommand( queue_head_t *list );
void moveCommand( queue_head_t *fromList,
queue_head_t *toList,
IOATAStandardCommand *ataCmd,
IOReturn rc = kIOReturnSuccess );
void moveAllCommands( queue_head_t *fromList, queue_head_t *toList, IOReturn rc = kIOReturnSuccess );
bool findCommand( queue_head_t *list, IOATAStandardCommand *findATACmd );
void purgeAllCommands( queue_head_t *list, IOReturn rc );
private:
ATAUnit unit;
ATATarget *target;
IOATAStandardController *controller;
IOCommandGate *deviceGate;
IOService *client;
IORWLock * clientSem;
queue_head_t deviceList;
queue_head_t bypassList;
queue_head_t activeList;
queue_head_t abortList;
queue_head_t cancelList;
ATACommandType abortCmdPending;
UInt32 reqSenseState;
UInt32 abortState;
UInt32 cancelState;
UInt32 negotiateState;
IOATAStandardCommand *reqSenseOrigCmd;
IOATAStandardCommand *reqSenseCmd;
IOATAStandardCommand *abortCmd;
IOATAStandardCommand *cancelCmd;
IOATAStandardCommand *probeCmd;
UInt32 normalQHeld;
UInt32 bypassQHeld;
bool idleNotifyActive;
CallbackFn idleNotifyCallback;
void *idleNotifyTarget;
void *idleNotifyRefcon;
bool isSuspended;
AbsoluteTime suspendTime;
UInt32 commandCount;
UInt32 commandLimit;
UInt32 commandLimitSave;
UInt32 maxTags;
UInt32 tagArraySize;
UInt32 *tagArray;
ATADeviceType deviceType;
UInt32 protocolsSupported;
UInt32 atapiPktInt;
ATAIdentify *identifyData;
ATAInquiry *inquiryData;
UInt32 inquiryDataSize;
ATATimingProtocol currentTiming;
UInt32 numTimings;
ATATiming ataTimings[kATAMaxTimings];
void *devicePrivateData;
};
#define kIOATAStandardDevice ((IOATAStandardDevice *)0)
#endif