i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* Fixed wrong indentation.

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@36430 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2010-04-23 10:56:39 +00:00
parent 6c7bc7cd22
commit 11a40e6d46
1 changed files with 191 additions and 194 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/bus_managers/ata/ATAPrivate.h
+191 -194
View File
@@ -61,280 +61,277 @@ void swap_words(void *data, size_t size);
class ATAChannel { class ATAChannel {
public: public:
ATAChannel(device_node *node); ATAChannel(device_node *node);
~ATAChannel(); ~ATAChannel();
status_t InitCheck(); status_t InitCheck();
uint32 ChannelID() const { return fChannelID; } uint32 ChannelID() const { return fChannelID; }
// SCSI stuff // SCSI stuff
void SetBus(scsi_bus bus); void SetBus(scsi_bus bus);
scsi_bus Bus() const { return fSCSIBus; } scsi_bus Bus() const { return fSCSIBus; }
status_t ScanBus(); status_t ScanBus();
void PathInquiry(scsi_path_inquiry *info); void PathInquiry(scsi_path_inquiry *info);
void GetRestrictions(uint8 targetID, void GetRestrictions(uint8 targetID, bool *isATAPI,
bool *isATAPI, bool *noAutoSense, bool *noAutoSense, uint32 *maxBlocks);
uint32 *maxBlocks); status_t ExecuteIO(scsi_ccb *ccb);
status_t ExecuteIO(scsi_ccb *ccb);
// ATA stuff // ATA stuff
status_t SelectDevice(uint8 index); status_t SelectDevice(uint8 index);
uint8 SelectedDevice(); uint8 SelectedDevice();
status_t Reset(); status_t Reset();
bool UseDMA() const { return fUseDMA; } bool UseDMA() const { return fUseDMA; }
status_t Wait(uint8 setBits, uint8 clearedBits, status_t Wait(uint8 setBits, uint8 clearedBits,
uint32 flags, bigtime_t timeout); uint32 flags, bigtime_t timeout);
status_t WaitDataRequest(bool high); status_t WaitDataRequest(bool high);
status_t WaitDeviceReady(); status_t WaitDeviceReady();
status_t WaitForIdle(); status_t WaitForIdle();
void PrepareWaitingForInterrupt(); void PrepareWaitingForInterrupt();
status_t WaitForInterrupt(bigtime_t timeout); status_t WaitForInterrupt(bigtime_t timeout);
status_t RecoverLostInterrupt(); status_t RecoverLostInterrupt();
// request handling // request handling
status_t SendRequest(ATARequest *request, status_t SendRequest(ATARequest *request, uint32 flags);
uint32 flags); status_t FinishRequest(ATARequest *request, uint32 flags,
status_t FinishRequest(ATARequest *request, uint8 errorMask);
uint32 flags, uint8 errorMask);
// data transfers // data transfers
status_t PrepareDMA(ATARequest *request); status_t PrepareDMA(ATARequest *request);
status_t StartDMA(); status_t StartDMA();
status_t FinishDMA(); status_t FinishDMA();
status_t ExecutePIOTransfer(ATARequest *request); status_t ExecutePIOTransfer(ATARequest *request);
status_t ReadRegs(ATADevice *device); status_t ReadRegs(ATADevice *device);
uint8 AltStatus(); uint8 AltStatus();
status_t ReadPIO(uint8 *buffer, size_t length); status_t ReadPIO(uint8 *buffer, size_t length);
status_t WritePIO(uint8 *buffer, size_t length); status_t WritePIO(uint8 *buffer, size_t length);
status_t Interrupt(uint8 status); status_t Interrupt(uint8 status);
private: private:
status_t _ReadRegs(ata_task_file *taskFile, status_t _ReadRegs(ata_task_file *taskFile,
ata_reg_mask mask); ata_reg_mask mask);
status_t _WriteRegs(ata_task_file *taskFile, status_t _WriteRegs(ata_task_file *taskFile,
ata_reg_mask mask); ata_reg_mask mask);
status_t _WriteControl(uint8 value); status_t _WriteControl(uint8 value);
uint8 _Status(); uint8 _Status();
void _FlushAndWait(bigtime_t waitTime); void _FlushAndWait(bigtime_t waitTime);
bool _DevicePresent(int device); bool _DevicePresent(int device);
status_t _ReadPIOBlock(ATARequest *request, status_t _ReadPIOBlock(ATARequest *request,
size_t length); size_t length);
status_t _WritePIOBlock(ATARequest *request, status_t _WritePIOBlock(ATARequest *request,
size_t length); size_t length);
status_t _TransferPIOBlock(ATARequest *request, status_t _TransferPIOBlock(ATARequest *request,
size_t length, size_t *transferred); size_t length, size_t *transferred);
status_t _TransferPIOPhysical(ATARequest *request, status_t _TransferPIOPhysical(ATARequest *request,
addr_t physicalAddress, size_t length, addr_t physicalAddress, size_t length,
size_t *transferred); size_t *transferred);
status_t _TransferPIOVirtual(ATARequest *request, status_t _TransferPIOVirtual(ATARequest *request,
uint8 *virtualAddress, size_t length, uint8 *virtualAddress, size_t length,
size_t *transferred); size_t *transferred);
const char * _DebugContext() { return fDebugContext; } const char * _DebugContext() { return fDebugContext; }
device_node * fNode; private:
uint32 fChannelID; device_node * fNode;
ata_controller_interface * fController; uint32 fChannelID;
void * fCookie; ata_controller_interface *fController;
void * fCookie;
spinlock fInterruptLock; spinlock fInterruptLock;
ConditionVariable fInterruptCondition; ConditionVariable fInterruptCondition;
ConditionVariableEntry fInterruptConditionEntry; ConditionVariableEntry fInterruptConditionEntry;
bool fExpectsInterrupt; bool fExpectsInterrupt;
status_t fStatus; status_t fStatus;
scsi_bus fSCSIBus; scsi_bus fSCSIBus;
uint8 fDeviceCount; uint8 fDeviceCount;
ATADevice ** fDevices; ATADevice ** fDevices;
bool fUseDMA; bool fUseDMA;
ATARequest * fRequest; ATARequest * fRequest;
char fDebugContext[16]; char fDebugContext[16];
}; };
class ATADevice { class ATADevice {
public: public:
ATADevice(ATAChannel *channel, ATADevice(ATAChannel *channel, uint8 index);
uint8 index); virtual ~ATADevice();
virtual ~ATADevice();
// SCSI stuff // SCSI stuff
status_t ModeSense(ATARequest *request); status_t ModeSense(ATARequest *request);
status_t TestUnitReady(ATARequest *request); status_t TestUnitReady(ATARequest *request);
status_t SynchronizeCache(ATARequest *request); status_t SynchronizeCache(ATARequest *request);
status_t Eject(ATARequest *request); status_t Eject(ATARequest *request);
status_t Inquiry(ATARequest *request); status_t Inquiry(ATARequest *request);
status_t ReadCapacity(ATARequest *request); status_t ReadCapacity(ATARequest *request);
virtual status_t ExecuteIO(ATARequest *request); virtual status_t ExecuteIO(ATARequest *request);
void GetRestrictions(bool *noAutoSense, void GetRestrictions(bool *noAutoSense,
uint32 *maxBlocks); uint32 *maxBlocks);
// ATA stuff // ATA stuff
virtual bool IsATAPI() const { return false; } virtual bool IsATAPI() const { return false; }
bool UseDMA() const { return fUseDMA; } bool UseDMA() const { return fUseDMA; }
bool Use48Bits() const { return fUse48Bits; } bool Use48Bits() const { return fUse48Bits; }
size_t BlockSize() const { return fBlockSize; } size_t BlockSize() const { return fBlockSize; }
status_t Select(); status_t Select();
ata_task_file * TaskFile() { return &fTaskFile; } ata_task_file * TaskFile() { return &fTaskFile; }
ata_reg_mask RegisterMask() const ata_reg_mask RegisterMask() const { return fRegisterMask; }
{ return fRegisterMask; }
status_t SetFeature(int feature); status_t SetFeature(int feature);
status_t DisableCommandQueueing(); status_t DisableCommandQueueing();
status_t ConfigureDMA(); status_t ConfigureDMA();
virtual status_t Configure(); virtual status_t Configure();
status_t Identify(); status_t Identify();
status_t ExecuteReadWrite(ATARequest *request, status_t ExecuteReadWrite(ATARequest *request,
uint64 address, uint32 sectorCount); uint64 address, uint32 sectorCount);
protected: protected:
const char * _DebugContext() { return fDebugContext; } const char * _DebugContext() { return fDebugContext; }
ATAChannel * fChannel; ATAChannel * fChannel;
ata_device_infoblock fInfoBlock; ata_device_infoblock fInfoBlock;
ata_task_file fTaskFile; ata_task_file fTaskFile;
ata_reg_mask fRegisterMask; ata_reg_mask fRegisterMask;
bool fUseDMA; bool fUseDMA;
uint8 fDMAMode; uint8 fDMAMode;
uint8 fDMAFailures; uint8 fDMAFailures;
private: private:
status_t _FillTaskFile(ATARequest *request, status_t _FillTaskFile(ATARequest *request,
uint64 address); uint64 address);
uint64 fTotalSectors; uint64 fTotalSectors;
size_t fBlockSize; size_t fBlockSize;
size_t fPhysicalBlockSize; size_t fPhysicalBlockSize;
size_t fBlockOffset; size_t fBlockOffset;
uint8 fIndex; uint8 fIndex;
bool fUse48Bits; bool fUse48Bits;
char fDebugContext[16]; char fDebugContext[16];
}; };
class ATAPIDevice : public ATADevice { class ATAPIDevice : public ATADevice {
public: public:
ATAPIDevice(ATAChannel *channel, ATAPIDevice(ATAChannel *channel, uint8 index);
uint8 index); virtual ~ATAPIDevice();
virtual ~ATAPIDevice();
status_t SendPacket(ATARequest *request); status_t SendPacket(ATARequest *request);
virtual status_t ExecuteIO(ATARequest *request); virtual status_t ExecuteIO(ATARequest *request);
virtual bool IsATAPI() const { return true; } virtual bool IsATAPI() const { return true; }
virtual status_t Configure(); virtual status_t Configure();
private:
status_t _FillTaskFilePacket(ATARequest *request);
status_t _FinishRequest(ATARequest *request,
uint32 flags);
private: private:
status_t _FillTaskFilePacket(ATARequest *request); uint8 fPacket[12];
status_t _FinishRequest(ATARequest *request,
uint32 flags);
uint8 fPacket[12];
}; };
class ATARequest { class ATARequest {
public: public:
ATARequest(bool hasLock); ATARequest(bool hasLock);
~ATARequest(); ~ATARequest();
void SetStatus(uint8 status); void SetStatus(uint8 status);
uint8 Status() const { return fStatus; } uint8 Status() const { return fStatus; }
void ClearSense(); void ClearSense();
void SetSense(uint8 key, uint16 codeQualifier); void SetSense(uint8 key, uint16 codeQualifier);
uint8 SenseKey() const { return fSenseKey; } uint8 SenseKey() const { return fSenseKey; }
uint8 SenseCode() const { return fSenseCode; } uint8 SenseCode() const { return fSenseCode; }
uint8 SenseQualifier() const uint8 SenseQualifier() const
{ return fSenseQualifier; } { return fSenseQualifier; }
void SetDevice(ATADevice *device); void SetDevice(ATADevice *device);
ATADevice * Device() const { return fDevice; } ATADevice * Device() const { return fDevice; }
void SetTimeout(bigtime_t timeout); void SetTimeout(bigtime_t timeout);
bigtime_t Timeout() const { return fTimeout; } bigtime_t Timeout() const { return fTimeout; }
void SetIsWrite(bool isWrite); void SetIsWrite(bool isWrite);
bool IsWrite() const { return fIsWrite; } bool IsWrite() const { return fIsWrite; }
void SetUseDMA(bool useDMA); void SetUseDMA(bool useDMA);
bool UseDMA() const { return fUseDMA; } bool UseDMA() const { return fUseDMA; }
void SetBytesLeft(uint32 bytesLeft); void SetBytesLeft(uint32 bytesLeft);
size_t * BytesLeft() { return &fBytesLeft; } size_t * BytesLeft() { return &fBytesLeft; }
bool HasData() const bool HasData() const
{ return fCCB->data_length > 0; } { return fCCB->data_length > 0; }
bool HasSense() const { return fSenseKey != 0; } bool HasSense() const { return fSenseKey != 0; }
status_t Finish(bool resubmit); status_t Finish(bool resubmit);
// SCSI stuff // SCSI stuff
status_t Start(scsi_ccb *ccb); status_t Start(scsi_ccb *ccb);
scsi_ccb * CCB() { return fCCB; } scsi_ccb * CCB() { return fCCB; }
void PrepareSGInfo(); void PrepareSGInfo();
void AdvanceSG(uint32 bytes); void AdvanceSG(uint32 bytes);
uint32 SGElementsLeft() const uint32 SGElementsLeft() const
{ return fSGElementsLeft; } { return fSGElementsLeft; }
const physical_entry * CurrentSGElement() const const physical_entry *CurrentSGElement() const
{ return fCurrentSGElement; } { return fCurrentSGElement; }
uint32 CurrentSGOffset() const uint32 CurrentSGOffset() const
{ return fCurrentSGOffset; } { return fCurrentSGOffset; }
void SetOddByte(uint8 byte); void SetOddByte(uint8 byte);
bool GetOddByte(uint8 *byte); bool GetOddByte(uint8 *byte);
void RequestSense(); void RequestSense();
private: private:
void _FillSense(scsi_sense *sense); void _FillSense(scsi_sense *sense);
const char * _DebugContext() { return " request"; }; const char * _DebugContext() { return " request"; };
mutex fLock; mutex fLock;
bool fHasLock; bool fHasLock;
uint8 fStatus; uint8 fStatus;
uint8 fSenseKey; uint8 fSenseKey;
uint8 fSenseCode; uint8 fSenseCode;
uint8 fSenseQualifier; uint8 fSenseQualifier;
ATADevice * fDevice; ATADevice * fDevice;
bigtime_t fTimeout; bigtime_t fTimeout;
size_t fBytesLeft; size_t fBytesLeft;
bool fIsWrite; bool fIsWrite;
bool fUseDMA; bool fUseDMA;
scsi_ccb * fCCB; scsi_ccb * fCCB;
uint32 fSGElementsLeft; uint32 fSGElementsLeft;
const physical_entry * fCurrentSGElement; const physical_entry *fCurrentSGElement;
uint32 fCurrentSGOffset; uint32 fCurrentSGOffset;
bool fHasOddByte; bool fHasOddByte;
uint8 fOddByte; uint8 fOddByte;
}; };
#endif // ATA_PRIVATE_H #endif // ATA_PRIVATE_H