[apple/xnu.git] / iokit / Families / IOATAHDDrive / IOATAHDCommand.cpp

/*
 * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * Copyright (c) 1999 Apple Computer, Inc.  All rights reserved. 
 *
 * IOATAHDCommand.cpp - Performs ATA command processing.
 *
 * HISTORY
 * Aug 27, 1999	jliu - Ported from AppleATADrive.
 */

#include <IOKit/assert.h>
#include <IOKit/IOSyncer.h>
#include <IOKit/storage/ata/IOATAHDDrive.h>

// Enable this define to generate debugging messages.
// #define DEBUG_LOG 1

//---------------------------------------------------------------------------
// Select the device timing protocol.

bool
IOATAHDDrive::selectTimingProtocol()
{
	bool              ret;
	UInt8             ataReadCmd;
	UInt8             ataWriteCmd;
    ATATimingProtocol timing;
    char *            protocolName;

    ret = _ataDevice->getTimingsSupported(&timing);
    if (ret == false)
    {
        IOLog("%s: getTimingsSupported() error\n", getName());
        timing = kATATimingPIO;
    }

	// IOLog("%s: device supported timings: %08x\n", getName(), timing);
	
	if (timing & (kATATimingUltraDMA66 | kATATimingUltraDMA33 | kATATimingDMA)) 
	{
		if (timing & kATATimingUltraDMA66)
		{
            protocolName = "U-DMA/66";
			timing = kATATimingUltraDMA66;
		}
		else if (timing & kATATimingUltraDMA33)
		{
            protocolName = "U-DMA/33";
			timing = kATATimingUltraDMA33;
		}
		else
		{
            protocolName = "DMA";
			timing = kATATimingDMA;
		}

        selectCommandProtocol(true);

        switch ( _ataProtocol )
        {
            case kATAProtocolDMAQueued:
  		        ataReadCmd  = kIOATACommandReadDMAQueued;
		        ataWriteCmd = kIOATACommandWriteDMAQueued;
                break;

            case kATAProtocolDMA:
            default:
  		        ataReadCmd  = kIOATACommandReadDMA;
		        ataWriteCmd = kIOATACommandWriteDMA;
        }
	}
	else
	{
        protocolName = "PIO";
		timing       = kATATimingPIO;
		ataReadCmd   = kIOATACommandReadPIO;
		ataWriteCmd  = kIOATACommandWritePIO;
        selectCommandProtocol(false);
	}

    _timingProtocol = timing;
    _ataReadCmd     = ataReadCmd;
    _ataWriteCmd    = ataWriteCmd;
    ret             = true;

    // Select device timing.
    //
    ret = _ataDevice->selectTiming( _timingProtocol, false );

	if (ret == false)
	{
		IOLog("%s: %s selectTiming() failed\n", getName(), protocolName);

		if (_timingProtocol != kATATimingPIO)
		{
			// Non PIO mode selection failed, defaulting to PIO mode and
			// try one more time.

			protocolName    = "PIO";
			_timingProtocol = kATATimingPIO;
			_ataReadCmd     = kIOATACommandReadPIO;
			_ataWriteCmd    = kIOATACommandWritePIO;
			selectCommandProtocol(false);

			ret = _ataDevice->selectTiming( _timingProtocol, false );
			if (ret == false)
				IOLog("%s: %s selectTiming() retry failed\n",
				      getName(), protocolName);
		}
	}

	if (ret && _logSelectedTimingProtocol)
		IOLog("%s: Using %s transfers\n", getName(), protocolName);

	return ret;
}

//---------------------------------------------------------------------------
// Select the command protocol to use (e.g. ataProtocolPIO, ataProtocolDMA).

bool
IOATAHDDrive::selectCommandProtocol(bool isDMA)
{
    ATAProtocol	protocolsSupported;

    if ( _ataDevice->getProtocolsSupported( &protocolsSupported ) == false )
    {
        IOLog("%s: getProtocolsSupported() failed\n", getName());
        return false;
    }

    if ( (protocolsSupported & kATAProtocolDMAQueued) != 0 )
    {
#if 0
        _ataProtocol = kATAProtocolDMAQueued;
#else
        _ataProtocol = kATAProtocolDMA;
#endif
    }
    else if ( (protocolsSupported & kATAProtocolDMA) != 0 )
    {    
        _ataProtocol = kATAProtocolDMA;
    }
    else
    {
        _ataProtocol = kATAProtocolPIO;
    }

    return true;
}

//---------------------------------------------------------------------------
// Configure the ATA/ATAPI device when the driver is initialized, and
// after every device reset.

bool
IOATAHDDrive::configureDevice(IOATADevice * device)
{
    bool ret;

    // Select device timing.
    //
    ret = device->selectTiming( _timingProtocol, true );
	if (ret == false) {
		IOLog("%s: selectTiming() failed\n", getName());
        return false;
    }

    return true;
}

//---------------------------------------------------------------------------
// Setup an ATATaskFile from the parameters given, and write the taskfile
// to the ATATaskfile structure pointer provided.
//
// taskfile - pointer to a taskfile structure.
// protocol - An ATA transfer protocol (ataProtocolPIO, ataProtocolDMA, etc)
// command  - ATA command byte.
// block    - Initial transfer block.
// nblks    - Number of blocks to transfer.

void
IOATAHDDrive::setupReadWriteTaskFile(ATATaskfile * taskfile,
                                     ATAProtocol   protocol,
                                     UInt8         command,
                                     UInt32        block,
                                     UInt32        nblks)
{
    bzero( taskfile, sizeof(ATATaskfile) );

	taskfile->protocol = protocol;

	// Mask of all taskfile registers that shall contain valid
	// data and should be written to the hardware registers.
	//
	taskfile->regmask  = ATARegtoMask(kATARegSectorNumber)	|
                         ATARegtoMask(kATARegCylinderLow)	|
                         ATARegtoMask(kATARegCylinderHigh)	|
						 ATARegtoMask(kATARegDriveHead)		|
						 ATARegtoMask(kATARegSectorCount)	|
						 ATARegtoMask(kATARegFeatures)		|
						 ATARegtoMask(kATARegCommand);

	taskfile->resultmask = 0;

	taskfile->ataRegs[kATARegSectorNumber] = block & 0x0ff;
	taskfile->ataRegs[kATARegCylinderLow]  = (block >> 8) & 0xff;
	taskfile->ataRegs[kATARegCylinderHigh] = (block >> 16) & 0xff;
	taskfile->ataRegs[kATARegDriveHead]    = ((block >> 24) & 0x0f) |
                                             kATAModeLBA | (_unit << 4); 

    if ( protocol == kATAProtocolDMAQueued )
    {
        taskfile->ataRegs[kATARegFeatures]    =
            (nblks == kIOATAMaxBlocksPerXfer) ? 0 : nblks;
        taskfile->ataRegs[kATARegSectorCount] = 0;
    }
    else
    {
        taskfile->ataRegs[kATARegFeatures]    = 0;
        taskfile->ataRegs[kATARegSectorCount] =
            (nblks == kIOATAMaxBlocksPerXfer) ? 0 : nblks;
    }

    taskfile->ataRegs[kATARegCommand] = command;
}

//---------------------------------------------------------------------------
// Allocate and return an IOATACommand that is initialized to perform
// a read/write operation.
//
// buffer   - IOMemoryDescriptor object describing this transfer.
// block    - Initial transfer block.
// nblks    - Number of blocks to transfer.

IOATACommand *
IOATAHDDrive::ataCommandReadWrite(IOMemoryDescriptor * buffer,
                                  UInt32               block,
                                  UInt32               nblks)
{
	ATATaskfile    taskfile;
	bool           isWrite;
	IOATACommand * cmd = allocateCommand();

	assert(buffer);

	if (!cmd) return 0;		// error, command allocation failed.

	isWrite = (buffer->getDirection() == kIODirectionOut) ?
	          true : false;

#ifdef DEBUG_LOG
	IOLog("%s::ataCommandReadWrite %08x (%d) %s %d %d\n",
		getName(),
		buffer,
		buffer->getLength(),
		isWrite ? "WR" : "RD",
		block,
		nblks);
#endif

#if 0	// used for testing - force PIO mode
	setupReadWriteTaskFile(&taskfile,
	                       kATAProtocolPIO,
	                       isWrite ? kIOATACommandWritePIO : 
						   kIOATACommandReadPIO,
	                       block,
	                       nblks);
#else

	// Setup the taskfile structure with the size and direction of the
	// transfer. This structure will be written to the actual taskfile
	// registers when this command is processed.
	//
	setupReadWriteTaskFile(&taskfile,
	                       _ataProtocol,
	                       isWrite ? _ataWriteCmd : _ataReadCmd,
	                       block,
	                       nblks);
#endif

	// Get a pointer to the client data buffer, and record parameters
	// which shall be later used by the completion routine.
	//
	ATA_CLIENT_DATA(cmd)->buffer = buffer;

	cmd->setTaskfile(&taskfile);

	cmd->setPointers(buffer,                /* (IOMemoryDescriptor *) */
                     buffer->getLength(),   /* transferCount (bytes) */
                     isWrite);              /* isWrite */

	return cmd;
}

//---------------------------------------------------------------------------
// Allocate and return a ATA SetFeatures command.

IOATACommand *
IOATAHDDrive::ataCommandSetFeatures(UInt8 features,
                                    UInt8 SectorCount,
                                    UInt8 SectorNumber,
                                    UInt8 CylinderLow,
                                    UInt8 CyclinderHigh)
{
	ATATaskfile    taskfile;
	IOATACommand * cmd = allocateCommand();

    if (!cmd) return 0;		// error, command allocation failed.

	taskfile.protocol   = kATAProtocolPIO;

	taskfile.regmask    = ATARegtoMask(kATARegSectorNumber)  |
                          ATARegtoMask(kATARegCylinderLow)   |
                          ATARegtoMask(kATARegCylinderHigh)  |
                          ATARegtoMask(kATARegDriveHead)     |
                          ATARegtoMask(kATARegSectorCount)   |
                          ATARegtoMask(kATARegCommand);

	taskfile.resultmask = ATARegtoMask(kATARegError) |
                          ATARegtoMask(kATARegStatus);

	taskfile.ataRegs[kATARegFeatures]     = features;
	taskfile.ataRegs[kATARegSectorNumber] = SectorNumber;
	taskfile.ataRegs[kATARegCylinderLow]  = CylinderLow;
	taskfile.ataRegs[kATARegCylinderHigh] = CyclinderHigh;
    taskfile.ataRegs[kATARegDriveHead]    = kATAModeLBA | (_unit << 4);
	taskfile.ataRegs[kATARegSectorCount]  = SectorCount;
    taskfile.ataRegs[kATARegCommand]      = kIOATACommandSetFeatures;

	cmd->setTaskfile(&taskfile);

    // This is a way to issue a command which will wait
    // for an interrupt, but does no data transfer.

    cmd->setPointers(0, 0, false);
    
	return cmd;
}

//---------------------------------------------------------------------------
// Return a Flush Cache command.

IOATACommand *
IOATAHDDrive::ataCommandFlushCache()
{
    ATATaskfile    taskfile;
	IOATACommand * cmd = allocateCommand();

    if (!cmd) return 0;		// error, command allocation failed.

    // kATAProtocolSetRegs does not wait for an interrupt from the drive.

    taskfile.protocol   = kATAProtocolPIO;

    taskfile.regmask    = ATARegtoMask(kATARegDriveHead) |
                            ATARegtoMask(kATARegCommand);

    taskfile.resultmask = ATARegtoMask(kATARegError)        |
                            ATARegtoMask(kATARegSectorNumber) |
                            ATARegtoMask(kATARegCylinderLow)  |
                            ATARegtoMask(kATARegCylinderHigh) |
                            ATARegtoMask(kATARegDriveHead)    |
                            ATARegtoMask(kATARegStatus);

    taskfile.ataRegs[kATARegDriveHead] = kATAModeLBA | (_unit << 4);
    taskfile.ataRegs[kATARegCommand]   = kIOATACommandFlushCache;

    cmd->setTaskfile(&taskfile);

    // This is a way to issue a command which will wait
    // for an interrupt, but does no data transfer.

    cmd->setPointers(0, 0, false);

    return cmd;
}

//---------------------------------------------------------------------------
// Return a STANDBY IMMEDIATE command.

IOATACommand *
IOATAHDDrive::ataCommandStandby()
{
    ATATaskfile    taskfile;
	IOATACommand * cmd = allocateCommand();

	if (!cmd) return 0;		// error, command allocation failed.

    // kATAProtocolSetRegs does not wait for an interrupt from the drive.

    taskfile.protocol   = kATAProtocolPIO;

    taskfile.regmask    = ATARegtoMask(kATARegDriveHead) |
                          ATARegtoMask(kATARegCommand);

    taskfile.resultmask = ATARegtoMask(kATARegError)     |
                          ATARegtoMask(kATARegStatus);

    taskfile.ataRegs[kATARegDriveHead] = kATAModeLBA | (_unit << 4);
    taskfile.ataRegs[kATARegCommand]   = kIOATACommandStandbyImmediate;

    cmd->setTaskfile(&taskfile);

    // This is a way to issue a command which will wait
    // for an interrupt, but does no data transfer.

    cmd->setPointers(0, 0, false);

    return cmd;
}

//---------------------------------------------------------------------------
// This routine is called by our provider when a command processing has
// completed.

void
IOATAHDDrive::sHandleCommandCompletion(IOATAHDDrive * self,
                                       IOATACommand * cmd)
{
	ATAResults        results;
    IOATADevice *     device;
    IOATAClientData * clientData;

	assert(cmd);
    device = cmd->getDevice(kIOATADevice);
    assert(device);

	clientData = ATA_CLIENT_DATA(cmd);
	assert(clientData);

	if ((cmd->getResults(&results) != kIOReturnSuccess) &&
		(clientData->maxRetries-- > 0))
    {
        cmd->execute();
        return;
    }
    
#if 0
	// Force command retry to test retry logic.
	// Controller will reset the IOMemoryDescriptor's position, right?
	//
	cmd->getResults(&results);
	if (clientData->maxRetries-- > 2) {		
		cmd->execute();
        return;
	}
#endif

#ifdef DEBUG_LOG
	IOLog("%s: sHandleCommandCompletion %08x %08x %08x %08x %d\n",
		getName(), device, cmd, refcon, results.returnCode,
		results.bytesTransferred);
#endif

	// Return IOReturn for sync commands.
	//
	clientData->returnCode = results.returnCode;

	if (clientData->isSync) {
		// For sync commands, unblock the client thread.
		//
		assert(clientData->completion.syncLock);
		clientData->completion.syncLock->signal();	// unblock the client.
	}
	else {
		// Signal the completion routine that the request has been completed.
		//

        IOStorage::complete(clientData->completion.async,
                            results.returnCode,
                            (UInt64) results.bytesTransferred);
	}

	// Release the IOMemoryDescriptor.
	//
	if (clientData->buffer)
		clientData->buffer->release();

	// Command processing is complete, release the command object.
	//
	cmd->release();
}

//---------------------------------------------------------------------------
// Issue a synchronous ATA command.

IOReturn
IOATAHDDrive::syncExecute(IOATACommand *       cmd,       /* command object */
                          UInt32               timeout,   /* timeout in ms */
                          UInt                 retries,   /* max retries */
                          IOMemoryDescriptor * senseData)
{
	IOATAClientData * clientData = ATA_CLIENT_DATA(cmd);

    if ( _pmReady )
    {
        activityTickle( kIOPMSuperclassPolicy1, 1 );
    }

	// Bump the retain count on the command. The completion handler
	// will decrement the retain count.
	//
	cmd->retain();

	// Set timeout and register the completion handler.
	//
    cmd->setPointers(senseData, 
                     senseData ? senseData->getLength() : 0,
                     false,  /* isWrite */
                     true ); /* isSense */
    cmd->setTimeout(timeout);
    cmd->setCallback(this,
                     (CallbackFn) &IOATAHDDrive::sHandleCommandCompletion,
                     (void *) cmd);

	// Increment the retain count on the IOMemoryDescriptor.
	// Release when the completion routine gets called.
	//
	if (clientData->buffer)
		clientData->buffer->retain();

	// Set the max retry count. If retry count is 0, then the command shall
	// not be retried if an error occurs.
	//
	clientData->maxRetries = retries;
	clientData->completion.syncLock = IOSyncer::create();
	clientData->isSync = true;

	cmd->execute();

	// Block client thread on lock until the completion handler
	// receives an indication that the processing is complete.
	//
    clientData->completion.syncLock->wait();

	return clientData->returnCode;
}

//---------------------------------------------------------------------------
// Issue an asynchronous ATA command.

IOReturn
IOATAHDDrive::asyncExecute(IOATACommand *      cmd,      /* command object */
                           IOStorageCompletion completion,
                           UInt32              timeout,  /* timeout in ms */
                           UInt                retries)  /* max retries */
{
	IOATAClientData * clientData = ATA_CLIENT_DATA(cmd);

    if ( _pmReady )
    {
        activityTickle( kIOPMSuperclassPolicy1, 1 );
    }

	// Bump the retain count on the command. The completion handler
	// will decrement the retain count.
	//
	cmd->retain();

	// Set timeout and register the completion handler.
	//
	cmd->setTimeout(timeout);
    cmd->setCallback(this,
                     (CallbackFn) &IOATAHDDrive::sHandleCommandCompletion,
                     (void *) cmd);

	// Increment the retain count on the IOMemoryDescriptor.
	// Release when the completion routine gets called.
	//
	if (clientData->buffer)
		clientData->buffer->retain();

	// Set the max retry count. If retry count is 0, then the command shall
	// not be retried if an error occurs.
	//
	clientData->maxRetries = retries;
	clientData->isSync     = false;
	
	clientData->completion.async = completion;

	return (cmd->execute() ? kIOReturnSuccess : kIOReturnNoResources);
}

//---------------------------------------------------------------------------
// Allocate an IOATACommand object with a fixed client data area.

IOATACommand *
IOATAHDDrive::allocateCommand()
{
	return _ataDevice->allocCommand(kIOATADevice, sizeof(IOATAClientData));
}
Commit	Line	Data
1c79356b A	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	* Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
	24	*
	25	* IOATAHDCommand.cpp - Performs ATA command processing.
	26	*
	27	* HISTORY
	28	* Aug 27, 1999 jliu - Ported from AppleATADrive.
	29	*/
	30
	31	#include <IOKit/assert.h>
	32	#include <IOKit/IOSyncer.h>
	33	#include <IOKit/storage/ata/IOATAHDDrive.h>
	34
	35	// Enable this define to generate debugging messages.
	36	// #define DEBUG_LOG 1
	37
	38	//---------------------------------------------------------------------------
	39	// Select the device timing protocol.
	40
	41	bool
	42	IOATAHDDrive::selectTimingProtocol()
	43	{
	44	bool ret;
	45	UInt8 ataReadCmd;
	46	UInt8 ataWriteCmd;
	47	ATATimingProtocol timing;
	48	char * protocolName;
	49
	50	ret = _ataDevice->getTimingsSupported(&timing);
	51	if (ret == false)
	52	{
	53	IOLog("%s: getTimingsSupported() error\n", getName());
	54	timing = kATATimingPIO;
	55	}
	56
	57	// IOLog("%s: device supported timings: %08x\n", getName(), timing);
	58
	59	if (timing & (kATATimingUltraDMA66 \| kATATimingUltraDMA33 \| kATATimingDMA))
	60	{
	61	if (timing & kATATimingUltraDMA66)
	62	{
	63	protocolName = "U-DMA/66";
	64	timing = kATATimingUltraDMA66;
65	}
66	else if (timing & kATATimingUltraDMA33)
67	{
68	protocolName = "U-DMA/33";
69	timing = kATATimingUltraDMA33;
70	}
71	else
72	{
73	protocolName = "DMA";
74	timing = kATATimingDMA;
75	}
76
77	selectCommandProtocol(true);
78
79	switch ( _ataProtocol )
80	{
81	case kATAProtocolDMAQueued:
82	ataReadCmd = kIOATACommandReadDMAQueued;
83	ataWriteCmd = kIOATACommandWriteDMAQueued;
84	break;
85
86	case kATAProtocolDMA:
87	default:
88	ataReadCmd = kIOATACommandReadDMA;
89	ataWriteCmd = kIOATACommandWriteDMA;
90	}
91	}
92	else
93	{
94	protocolName = "PIO";
95	timing = kATATimingPIO;
96	ataReadCmd = kIOATACommandReadPIO;
97	ataWriteCmd = kIOATACommandWritePIO;
98	selectCommandProtocol(false);
99	}
100
101	_timingProtocol = timing;
102	_ataReadCmd = ataReadCmd;
103	_ataWriteCmd = ataWriteCmd;
104	ret = true;
105
106	// Select device timing.
107	//
108	ret = _ataDevice->selectTiming( _timingProtocol, false );
109
110	if (ret == false)
111	{
112	IOLog("%s: %s selectTiming() failed\n", getName(), protocolName);
113
114	if (_timingProtocol != kATATimingPIO)
115	{
116	// Non PIO mode selection failed, defaulting to PIO mode and
117	// try one more time.
118
119	protocolName = "PIO";
120	_timingProtocol = kATATimingPIO;
121	_ataReadCmd = kIOATACommandReadPIO;
122	_ataWriteCmd = kIOATACommandWritePIO;
123	selectCommandProtocol(false);
124
125	ret = _ataDevice->selectTiming( _timingProtocol, false );
126	if (ret == false)
127	IOLog("%s: %s selectTiming() retry failed\n",
128	getName(), protocolName);
129	}
130	}
131
132	if (ret && _logSelectedTimingProtocol)
133	IOLog("%s: Using %s transfers\n", getName(), protocolName);
134
135	return ret;
136	}
137
138	//---------------------------------------------------------------------------
139	// Select the command protocol to use (e.g. ataProtocolPIO, ataProtocolDMA).
140
141	bool
142	IOATAHDDrive::selectCommandProtocol(bool isDMA)
143	{
144	ATAProtocol protocolsSupported;
145
146	if ( _ataDevice->getProtocolsSupported( &protocolsSupported ) == false )
147	{
148	IOLog("%s: getProtocolsSupported() failed\n", getName());
149	return false;
150	}
151
152	if ( (protocolsSupported & kATAProtocolDMAQueued) != 0 )
153	{
154	#if 0
155	_ataProtocol = kATAProtocolDMAQueued;
156	#else
157	_ataProtocol = kATAProtocolDMA;
158	#endif
159	}
160	else if ( (protocolsSupported & kATAProtocolDMA) != 0 )
161	{
162	_ataProtocol = kATAProtocolDMA;
163	}
164	else
165	{
166	_ataProtocol = kATAProtocolPIO;
167	}
168
169	return true;
170	}
171
172	//---------------------------------------------------------------------------
173	// Configure the ATA/ATAPI device when the driver is initialized, and
174	// after every device reset.
175
176	bool
177	IOATAHDDrive::configureDevice(IOATADevice * device)
178	{
179	bool ret;
180
181	// Select device timing.
182	//
183	ret = device->selectTiming( _timingProtocol, true );
184	if (ret == false) {
185	IOLog("%s: selectTiming() failed\n", getName());
186	return false;
187	}
188
189	return true;
190	}
191
192	//---------------------------------------------------------------------------
193	// Setup an ATATaskFile from the parameters given, and write the taskfile
194	// to the ATATaskfile structure pointer provided.
195	//
196	// taskfile - pointer to a taskfile structure.
197	// protocol - An ATA transfer protocol (ataProtocolPIO, ataProtocolDMA, etc)
198	// command - ATA command byte.
199	// block - Initial transfer block.
200	// nblks - Number of blocks to transfer.
201
202	void
203	IOATAHDDrive::setupReadWriteTaskFile(ATATaskfile * taskfile,
204	ATAProtocol protocol,
205	UInt8 command,
206	UInt32 block,
207	UInt32 nblks)
208	{
209	bzero( taskfile, sizeof(ATATaskfile) );
210
211	taskfile->protocol = protocol;
212
213	// Mask of all taskfile registers that shall contain valid
214	// data and should be written to the hardware registers.
215	//
216	taskfile->regmask = ATARegtoMask(kATARegSectorNumber) \|
217	ATARegtoMask(kATARegCylinderLow) \|
218	ATARegtoMask(kATARegCylinderHigh) \|
219	ATARegtoMask(kATARegDriveHead) \|
220	ATARegtoMask(kATARegSectorCount) \|
221	ATARegtoMask(kATARegFeatures) \|
222	ATARegtoMask(kATARegCommand);
223
224	taskfile->resultmask = 0;
225
226	taskfile->ataRegs[kATARegSectorNumber] = block & 0x0ff;
227	taskfile->ataRegs[kATARegCylinderLow] = (block >> 8) & 0xff;
228	taskfile->ataRegs[kATARegCylinderHigh] = (block >> 16) & 0xff;
229	taskfile->ataRegs[kATARegDriveHead] = ((block >> 24) & 0x0f) \|
230	kATAModeLBA \| (_unit << 4);
231
232	if ( protocol == kATAProtocolDMAQueued )
233	{
234	taskfile->ataRegs[kATARegFeatures] =
235	(nblks == kIOATAMaxBlocksPerXfer) ? 0 : nblks;
236	taskfile->ataRegs[kATARegSectorCount] = 0;
237	}
238	else
239	{
240	taskfile->ataRegs[kATARegFeatures] = 0;
241	taskfile->ataRegs[kATARegSectorCount] =
242	(nblks == kIOATAMaxBlocksPerXfer) ? 0 : nblks;
243	}
244
245	taskfile->ataRegs[kATARegCommand] = command;
246	}
247
248	//---------------------------------------------------------------------------
249	// Allocate and return an IOATACommand that is initialized to perform
250	// a read/write operation.
251	//
252	// buffer - IOMemoryDescriptor object describing this transfer.
253	// block - Initial transfer block.
254	// nblks - Number of blocks to transfer.
255
256	IOATACommand *
257	IOATAHDDrive::ataCommandReadWrite(IOMemoryDescriptor * buffer,
258	UInt32 block,
259	UInt32 nblks)
260	{
261	ATATaskfile taskfile;
262	bool isWrite;
263	IOATACommand * cmd = allocateCommand();
264
265	assert(buffer);
266
267	if (!cmd) return 0; // error, command allocation failed.
268
269	isWrite = (buffer->getDirection() == kIODirectionOut) ?
270	true : false;
271
272	#ifdef DEBUG_LOG
273	IOLog("%s::ataCommandReadWrite %08x (%d) %s %d %d\n",
274	getName(),
275	buffer,
276	buffer->getLength(),
277	isWrite ? "WR" : "RD",
278	block,
279	nblks);
280	#endif
281
282	#if 0 // used for testing - force PIO mode
283	setupReadWriteTaskFile(&taskfile,
284	kATAProtocolPIO,
285	isWrite ? kIOATACommandWritePIO :
286	kIOATACommandReadPIO,
287	block,
288	nblks);
289	#else
290
291	// Setup the taskfile structure with the size and direction of the
292	// transfer. This structure will be written to the actual taskfile
293	// registers when this command is processed.
294	//
295	setupReadWriteTaskFile(&taskfile,
296	_ataProtocol,
297	isWrite ? _ataWriteCmd : _ataReadCmd,
298	block,
299	nblks);
300	#endif
301
302	// Get a pointer to the client data buffer, and record parameters
303	// which shall be later used by the completion routine.
304	//
305	ATA_CLIENT_DATA(cmd)->buffer = buffer;
306
307	cmd->setTaskfile(&taskfile);
308
309	cmd->setPointers(buffer, /* (IOMemoryDescriptor ) /
310	buffer->getLength(), /* transferCount (bytes) */
311	isWrite); /* isWrite */
312
313	return cmd;
314	}
315
316	//---------------------------------------------------------------------------
317	// Allocate and return a ATA SetFeatures command.
318
319	IOATACommand *
320	IOATAHDDrive::ataCommandSetFeatures(UInt8 features,
321	UInt8 SectorCount,
322	UInt8 SectorNumber,
323	UInt8 CylinderLow,
324	UInt8 CyclinderHigh)
325	{
326	ATATaskfile taskfile;
327	IOATACommand * cmd = allocateCommand();
328
329	if (!cmd) return 0; // error, command allocation failed.
330
331	taskfile.protocol = kATAProtocolPIO;
332
333	taskfile.regmask = ATARegtoMask(kATARegSectorNumber) \|
334	ATARegtoMask(kATARegCylinderLow) \|
335	ATARegtoMask(kATARegCylinderHigh) \|
336	ATARegtoMask(kATARegDriveHead) \|
337	ATARegtoMask(kATARegSectorCount) \|
338	ATARegtoMask(kATARegCommand);
339
340	taskfile.resultmask = ATARegtoMask(kATARegError) \|
341	ATARegtoMask(kATARegStatus);
342
343	taskfile.ataRegs[kATARegFeatures] = features;
344	taskfile.ataRegs[kATARegSectorNumber] = SectorNumber;
345	taskfile.ataRegs[kATARegCylinderLow] = CylinderLow;
346	taskfile.ataRegs[kATARegCylinderHigh] = CyclinderHigh;
347	taskfile.ataRegs[kATARegDriveHead] = kATAModeLBA \| (_unit << 4);
348	taskfile.ataRegs[kATARegSectorCount] = SectorCount;
349	taskfile.ataRegs[kATARegCommand] = kIOATACommandSetFeatures;
350
351	cmd->setTaskfile(&taskfile);
352
353	// This is a way to issue a command which will wait
354	// for an interrupt, but does no data transfer.
355
356	cmd->setPointers(0, 0, false);
357
358	return cmd;
359	}
360
361	//---------------------------------------------------------------------------
362	// Return a Flush Cache command.
363
364	IOATACommand *
365	IOATAHDDrive::ataCommandFlushCache()
366	{
367	ATATaskfile taskfile;
368	IOATACommand * cmd = allocateCommand();
369
370	if (!cmd) return 0; // error, command allocation failed.
371
372	// kATAProtocolSetRegs does not wait for an interrupt from the drive.
373
374	taskfile.protocol = kATAProtocolPIO;
375
376	taskfile.regmask = ATARegtoMask(kATARegDriveHead) \|
377	ATARegtoMask(kATARegCommand);
378
379	taskfile.resultmask = ATARegtoMask(kATARegError) \|
380	ATARegtoMask(kATARegSectorNumber) \|
381	ATARegtoMask(kATARegCylinderLow) \|
382	ATARegtoMask(kATARegCylinderHigh) \|
383	ATARegtoMask(kATARegDriveHead) \|
384	ATARegtoMask(kATARegStatus);
385
386	taskfile.ataRegs[kATARegDriveHead] = kATAModeLBA \| (_unit << 4);
387	taskfile.ataRegs[kATARegCommand] = kIOATACommandFlushCache;
388
389	cmd->setTaskfile(&taskfile);
390
391	// This is a way to issue a command which will wait
392	// for an interrupt, but does no data transfer.
393
394	cmd->setPointers(0, 0, false);
395
396	return cmd;
397	}
398
399	//---------------------------------------------------------------------------
400	// Return a STANDBY IMMEDIATE command.
401
402	IOATACommand *
403	IOATAHDDrive::ataCommandStandby()
404	{
405	ATATaskfile taskfile;
406	IOATACommand * cmd = allocateCommand();
407
408	if (!cmd) return 0; // error, command allocation failed.
409
410	// kATAProtocolSetRegs does not wait for an interrupt from the drive.
411
412	taskfile.protocol = kATAProtocolPIO;
413
414	taskfile.regmask = ATARegtoMask(kATARegDriveHead) \|
415	ATARegtoMask(kATARegCommand);
416
417	taskfile.resultmask = ATARegtoMask(kATARegError) \|
418	ATARegtoMask(kATARegStatus);
419
420	taskfile.ataRegs[kATARegDriveHead] = kATAModeLBA \| (_unit << 4);
421	taskfile.ataRegs[kATARegCommand] = kIOATACommandStandbyImmediate;
422
423	cmd->setTaskfile(&taskfile);
424
425	// This is a way to issue a command which will wait
426	// for an interrupt, but does no data transfer.
427
428	cmd->setPointers(0, 0, false);
429
430	return cmd;
431	}
432
433	//---------------------------------------------------------------------------
434	// This routine is called by our provider when a command processing has
435	// completed.
436
437	void
438	IOATAHDDrive::sHandleCommandCompletion(IOATAHDDrive * self,
439	IOATACommand * cmd)
440	{
441	ATAResults results;
442	IOATADevice * device;
443	IOATAClientData * clientData;
444
445	assert(cmd);
446	device = cmd->getDevice(kIOATADevice);
447	assert(device);
448
449	clientData = ATA_CLIENT_DATA(cmd);
450	assert(clientData);
451
452	if ((cmd->getResults(&results) != kIOReturnSuccess) &&
453	(clientData->maxRetries-- > 0))
454	{
455	cmd->execute();
456	return;
457	}
458
459	#if 0
460	// Force command retry to test retry logic.
461	// Controller will reset the IOMemoryDescriptor's position, right?
462	//
463	cmd->getResults(&results);
464	if (clientData->maxRetries-- > 2) {
465	cmd->execute();
466	return;
467	}
468	#endif
469
470	#ifdef DEBUG_LOG
471	IOLog("%s: sHandleCommandCompletion %08x %08x %08x %08x %d\n",
472	getName(), device, cmd, refcon, results.returnCode,
473	results.bytesTransferred);
474	#endif
475
476	// Return IOReturn for sync commands.
477	//
478	clientData->returnCode = results.returnCode;
479
480	if (clientData->isSync) {
481	// For sync commands, unblock the client thread.
482	//
483	assert(clientData->completion.syncLock);
484	clientData->completion.syncLock->signal(); // unblock the client.
485	}
486	else {
487	// Signal the completion routine that the request has been completed.
488	//
489
490	IOStorage::complete(clientData->completion.async,
491	results.returnCode,
492	(UInt64) results.bytesTransferred);
493	}
494
495	// Release the IOMemoryDescriptor.
496	//
497	if (clientData->buffer)
498	clientData->buffer->release();
499
500	// Command processing is complete, release the command object.
501	//
502	cmd->release();
503	}
504
505	//---------------------------------------------------------------------------
506	// Issue a synchronous ATA command.
507
508	IOReturn
509	IOATAHDDrive::syncExecute(IOATACommand * cmd, /* command object */
510	UInt32 timeout, /* timeout in ms */
511	UInt retries, /* max retries */
512	IOMemoryDescriptor * senseData)
513	{
514	IOATAClientData * clientData = ATA_CLIENT_DATA(cmd);
515
516	if ( _pmReady )
517	{
518	activityTickle( kIOPMSuperclassPolicy1, 1 );
519	}
520
521	// Bump the retain count on the command. The completion handler
522	// will decrement the retain count.
523	//
524	cmd->retain();
525
526	// Set timeout and register the completion handler.
527	//
528	cmd->setPointers(senseData,
529	senseData ? senseData->getLength() : 0,
530	false, /* isWrite */
531	true ); /* isSense */
532	cmd->setTimeout(timeout);
533	cmd->setCallback(this,
534	(CallbackFn) &IOATAHDDrive::sHandleCommandCompletion,
535	(void *) cmd);
536
537	// Increment the retain count on the IOMemoryDescriptor.
538	// Release when the completion routine gets called.
539	//
540	if (clientData->buffer)
541	clientData->buffer->retain();
542
543	// Set the max retry count. If retry count is 0, then the command shall
544	// not be retried if an error occurs.
545	//
546	clientData->maxRetries = retries;
547	clientData->completion.syncLock = IOSyncer::create();
548	clientData->isSync = true;
549
550	cmd->execute();
551
552	// Block client thread on lock until the completion handler
553	// receives an indication that the processing is complete.
554	//
555	clientData->completion.syncLock->wait();
556
557	return clientData->returnCode;
558	}
559
560	//---------------------------------------------------------------------------
561	// Issue an asynchronous ATA command.
562
563	IOReturn
564	IOATAHDDrive::asyncExecute(IOATACommand * cmd, /* command object */
565	IOStorageCompletion completion,
566	UInt32 timeout, /* timeout in ms */
567	UInt retries) /* max retries */
568	{
569	IOATAClientData * clientData = ATA_CLIENT_DATA(cmd);
570
571	if ( _pmReady )
572	{
573	activityTickle( kIOPMSuperclassPolicy1, 1 );
574	}
575
576	// Bump the retain count on the command. The completion handler
577	// will decrement the retain count.
578	//
579	cmd->retain();
580
581	// Set timeout and register the completion handler.
582	//
583	cmd->setTimeout(timeout);
584	cmd->setCallback(this,
585	(CallbackFn) &IOATAHDDrive::sHandleCommandCompletion,
586	(void *) cmd);
587
588	// Increment the retain count on the IOMemoryDescriptor.
589	// Release when the completion routine gets called.
590	//
591	if (clientData->buffer)
592	clientData->buffer->retain();
593
594	// Set the max retry count. If retry count is 0, then the command shall
595	// not be retried if an error occurs.
596	//
597	clientData->maxRetries = retries;
598	clientData->isSync = false;
599
600	clientData->completion.async = completion;
601
602	return (cmd->execute() ? kIOReturnSuccess : kIOReturnNoResources);
603	}
604
605	//---------------------------------------------------------------------------
606	// Allocate an IOATACommand object with a fixed client data area.
607
608	IOATACommand *
609	IOATAHDDrive::allocateCommand()
610	{
611	return _ataDevice->allocCommand(kIOATADevice, sizeof(IOATAClientData));
612	}