3ware RAID driver

// Handle completion of a command
//
// Note that this may be called either inside or outside the gate.
void
line 350 self::complete(bool postSuccess)
{
    IOStorageCompletion localCompletion;
    IOByteCount	actualByteCount;
    bool	result;

    postResult = postSuccess;
    
    command->complete(kIODirectionOutIn);
    dequeueActive();
    
    // auto-complete if we have a parameter buffer
    if (paramBuffer != NULL)
	paramBuffer->complete(kIODirectionOutIn);

    // if we have a copy buffer, finalise it
    if (copyBuffer != NULL)
	finishCopyBuffer();

    // data buffers for SET_PARAM auto-release here
    if (commandPtr->generic.opcode == TWE_OP_SET_PARAM)
	releaseParamBuffer();

    // Wake up a sleeping owner.
    // Owner is responsible for returning the command.
    if (waitingOwner) {
	controller->wakeCommand(this);
    } else {
	// save because we are going to release command first
	localCompletion = completion;
	actualByteCount = byteCount;
	result = getResult();
	if (!result) {
	    debug(2, "I/O error 0x%02x/ox%02x", (uint)commandPtr->generic.status, (uint)commandPtr->generic.flags);
	    print();
	}
	// Command submitter is gone, completion may know nothing
	// about our command, so we have to tear it down it ourselves.
	releaseDataBuffer();
	returnCommand();

	// Invoke completion
	IOStorage::complete(localCompletion,
		     result ? kIOReturnSuccess : kIOReturnError,
line 394	     result ? byteCount : 0);
    }
}

////////////////////////////////////////////////////////////////////////////////
// Build an I/O command
void
self::makeReadWrite(int unit,
		    IOMemoryDescriptor *buf,
		    UInt32 block,
		    UInt32 nblks,
line 562	    IOStorageCompletion withCompletion)
{

    // select opcode
    if (buf->getDirection() == kIODirectionOut) {
	commandPtr->io.opcode = TWE_OP_WRITE;
    } else {
	commandPtr->io.opcode = TWE_OP_READ;
    }
    commandPtr->io.size = 3;
    commandPtr->io.host_unit = unit;
    commandPtr->io.status = 0;
    commandPtr->io.flags = 0;
    commandPtr->io.block_count = OSSwapHostToLittleInt16((UInt16)nblks);
    commandPtr->io.lba = OSSwapHostToLittleInt32(block);
line 577    completion = withCompletion;
    setDataBuffer(buf);
}

    // Command mutators
    //
    virtual void	makeInitConnection(UInt32 credits);
    virtual void	makeGetParam(int table, int param, size_t size);
    virtual void	makeSetParam(int table, int param, UInt8 value);
    virtual void	makeSetParam(int table, int param, UInt16 value);
    virtual void	makeSetParam(int table, int param, UInt32 value);
    virtual void	makeSetParam(int table, int param, void *vp, size_t vsize);
    virtual void	makeFlush(int unit);
    virtual void	makeReadWrite(int unit, IOMemoryDescriptor *buf, UInt32 block, UInt32 nblks,
line 79			       IOStorageCompletion withCompletion);
    virtual void	makePowerSave(int state);	// 0 = spin down

    // temporary buffer, used to align unaligned requests
    IOBufferMemoryDescriptor	*copyBuffer;
    IOMemoryDescriptor		*realBuffer;

    // completion, set by ::makeReadWrite
line 134    IOStorageCompletion		completion;

//
IOReturn
self::doAsyncReadWrite(int unit,
		       IOMemoryDescriptor *buffer,
		       UInt32 block,
		       UInt32 nblks,
line 993	       IOStorageCompletion completion)
{
    TemagoCommand	*ec;
    bool		result;

    // check that drives are spun up
    checkPowerState();

    // do I/O
    ec = getCommand();
    ec->makeReadWrite(unit, buffer, block, nblks, completion);
    result = runAsynchronousCommand(ec);
    if (!result)
	ec->returnCommand();

    return(result ? kIOReturnSuccess : kIOReturnIOError);
}

// Request termination of a given unit

IOReturn
self::doRemoveUnit(int unit, bool force)
{
    TemagoDrive	*pUnit;

    // find unit and validate
    pUnit = logicalUnit[unit];
    if (!pUnit)
	return(kIOReturnNoDevice);
line 1068    if (!force && pUnit->isOpen()) {
	error("attempt to remove busy unit %d", unit);
	return(kIOReturnBusy);
    }

    // valid, terminate unit
    debug(3, "unit %d unbusy, terminating", unit);
line 1075    pUnit->terminate();
    logicalUnit[unit] = NULL;
    return(kIOReturnSuccess);
}
    // instantiate the drive
    if ((logicalUnit[unit] = new TemagoDrive) == NULL) {
	error("could not instantiate TemagoDrive for unit %d", unit)
	return(kIOReturnNoMemory);
    }
    logicalUnit[unit]->init(NULL);
    if (!logicalUnit[unit]->attach(this)) {
	error("could not attach TemagoDrive for unit %d", unit);
line 1155	logicalUnit[unit]->release();
	logicalUnit[unit] = NULL;
	return(kIOReturnError);
    }
    logicalUnit[unit]->setUnit(unit);
    logicalUnit[unit]->setSize(size);
    logicalUnit[unit]->setConfiguration(unitType);

    // all done, register unit for discovery
line 1164    logicalUnit[unit]->registerService();

    // The IORegistry has retained the unit, so we don't here.
    // It might make sense for us to keep a reference on it
    // just in case...
    logicalUnit[unit]->release();
    
    return(kIOReturnSuccess);
}

    // TemagoDrive interface
    //
    virtual char		*getControllerName(void);
    virtual char		*getControllerVersion(void);
    virtual IOReturn		doAsyncReadWrite(int unit, IOMemoryDescriptor *buffer,
line 120				       UInt32 block, UInt32 nblks, IOStorageCompletion completion);
    virtual IOReturn		doSynchronizeCache(int unit);

class TemagoController;

class TemagoDrive : public IOBlockStorageDevice
line 40{
    OSDeclareDefaultStructors(TemagoDrive);

public:
    // superclass overrides

    // IOBlockStorageDevice protocol
line 54    virtual IOReturn	doAsyncReadWrite(IOMemoryDescriptor *buffer, UInt32 block, UInt32 nblks, IOStorageCompletion completion);
    virtual IOReturn	doEjectMedia(void);
    virtual IOReturn	doFormatMedia(UInt64 byteCapacity);
    virtual UInt32	doGetFormatCapacities(UInt64 *capacities,  UInt32 capacitiesMaxCount) const;