IOAccelerator.cpp   [plain text]

/*
 * 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@
 */

#include <IOKit/IOLib.h>
#include <IOKit/IOLocks.h>
#include <IOKit/assert.h>
#include <IOKit/IOKitKeys.h>

#include <IOKit/graphics/IOAccelerator.h>
#include <IOKit/graphics/IOGraphicsTypesPrivate.h>
#include <IOKit/IOUserClient.h>


OSDefineMetaClassAndStructors(IOAccelerator, IOService)

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

static IOLock * 	gLock;
static queue_head_t	gGlobalList;
static UInt32		gTotalCount;
static SInt32		gTweak;

struct IOAccelIDRecord
{
    IOAccelID		id;
    SInt32		retain;
    queue_chain_t	task_link;
    queue_chain_t	glob_link;
};

enum { kTweakBits = 0x1f };	// sizeof(IOAccelIDRecord) == 24

class IOAccelerationUserClient : public IOUserClient
{
    /*
     * Declare the metaclass information that is used for runtime
     * typechecking of IOKit objects.
     */

    OSDeclareDefaultStructors( IOAccelerationUserClient );

private:
    task_t		fTask;
    queue_head_t	fTaskList;

    static void initialize();

public:
    /* IOService overrides */
    virtual bool start( IOService * provider );
    virtual void stop( IOService * provider );

    /* IOUserClient overrides */
    virtual bool initWithTask( task_t owningTask, void * securityID,
                                                UInt32 type,  OSDictionary * properties );
    virtual IOReturn clientClose( void );

    virtual IOExternalMethod * getTargetAndMethodForIndex(
                                            IOService ** targetP, UInt32 index );


    IOReturn extCreate(IOOptionBits options,
			IOAccelID requestedID, IOAccelID * idOut);
    IOReturn extDestroy(IOOptionBits options, IOAccelID id);

};

#define super IOUserClient
OSDefineMetaClassAndStructorsWithInit(IOAccelerationUserClient, IOUserClient, 
					IOAccelerationUserClient::initialize());

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

void IOAccelerationUserClient::initialize()
{
    if (!gLock)
    {
	gLock = IOLockAlloc();
	queue_init(&gGlobalList);
    }
}

bool IOAccelerationUserClient::initWithTask( task_t owningTask, void * securityID,
                                             UInt32 type,  OSDictionary * properties )
{
   
    if ( properties != NULL )
	    properties->setObject ( kIOUserClientCrossEndianCompatibleKey, kOSBooleanTrue );
   
    fTask = owningTask;
    queue_init(&fTaskList);

    return( super::initWithTask( owningTask, securityID, type, properties ));
}

bool IOAccelerationUserClient::start( IOService * provider )
{
    if( !super::start( provider ))
        return( false );

    return (true);
}

IOReturn IOAccelerationUserClient::clientClose( void )
{
    if( !isInactive())
        terminate();

    return( kIOReturnSuccess );
}

void IOAccelerationUserClient::stop( IOService * provider )
{
    IOAccelIDRecord * record;

    IOLockLock(gLock);

    while (!queue_empty( &fTaskList ))
    {
        queue_remove_first( &fTaskList,
                            record,
                            IOAccelIDRecord *,
                            task_link );

	if (--record->retain)
	    record->task_link.next = 0;
	else
	{
	    queue_remove(&gGlobalList,
			    record,
			    IOAccelIDRecord *,
			    glob_link);
	    gTotalCount--;
	    IODelete(record, IOAccelIDRecord, 1);
	}
    }
    IOLockUnlock(gLock);

    super::stop( provider );
}

IOExternalMethod * IOAccelerationUserClient::getTargetAndMethodForIndex(
    IOService ** targetP, UInt32 index )
{
    static const IOExternalMethod methodTemplate[] =
    {
	/* 0 */  { NULL, (IOMethod) &IOAccelerationUserClient::extCreate,
		    kIOUCScalarIScalarO, 2, 1 },
	/* 1 */  { NULL, (IOMethod) &IOAccelerationUserClient::extDestroy,
		    kIOUCScalarIScalarO, 2, 0 },
    };

    if (index > (sizeof(methodTemplate) / sizeof(methodTemplate[0])))
        return (NULL);

    *targetP = this;

    return ((IOExternalMethod *)(methodTemplate + index));
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

static 
IOReturn _CreateID(queue_head_t * taskList, IOOptionBits options,
		    IOAccelID requestedID, IOAccelID * idOut)
{
    IOReturn	      err;
    Boolean	      found;
    IOAccelIDRecord * record;
    IOAccelIDRecord * dup;

    record = IONew(IOAccelIDRecord, 1);
    record->retain = 1;

    IOLockLock(gLock);

    gTotalCount++;

    do
    {
	if (kIOAccelSpecificID & options)
	{
	    if ((requestedID > 4095) || (requestedID < -4096))
	    {
		err = kIOReturnExclusiveAccess;
		break;
	    }
    
	    found = false;
	    queue_iterate(&gGlobalList,
			    dup,
			    IOAccelIDRecord *,
			    glob_link)
	    {
		found = (dup->id == requestedID);
		if (found)
		    break;
	    }
    
	    if (found)
	    {
		err = kIOReturnExclusiveAccess;
		break;
	    }
    
	    record->id = requestedID;
	}
	else
	{
    	    record->id = ((IOAccelID) (intptr_t) record) ^ (kTweakBits & gTweak++);
	}

	if (taskList)
	{
	    queue_enter(taskList, record,
			    IOAccelIDRecord *, task_link);
	}
	else
	    record->task_link.next = 0;

	queue_enter(&gGlobalList, record,
			IOAccelIDRecord *, glob_link);

	*idOut = record->id;
	err = kIOReturnSuccess;
    }
    while (false);

    if (kIOReturnSuccess != err)
	gTotalCount--;

    IOLockUnlock(gLock);

    if (kIOReturnSuccess != err)
    {
	IODelete(record, IOAccelIDRecord, 1);
    }
    return (err);
}

IOReturn IOAccelerationUserClient::extCreate(IOOptionBits options,
						IOAccelID requestedID, IOAccelID * idOut)
{
    return (_CreateID(&fTaskList, options, requestedID, idOut));
}

IOReturn IOAccelerationUserClient::extDestroy(IOOptionBits options, IOAccelID id)
{
    IOAccelIDRecord * record;
    bool found = false;
    IOLockLock(gLock);

    queue_iterate(&fTaskList,
                    record,
                    IOAccelIDRecord *,
                    task_link)
    {
        found = (record->id == id);
	if (found)
	{
	    queue_remove(&fTaskList,
			    record,
			    IOAccelIDRecord *,
			    task_link);
	    if (--record->retain)
		record->task_link.next = 0;
	    else
	    {
		queue_remove(&gGlobalList,
				record,
				IOAccelIDRecord *,
				glob_link);
		gTotalCount--;
		IODelete(record, IOAccelIDRecord, 1);
	    }
	    break;
	}
    }

    IOLockUnlock(gLock);

    return (found ? kIOReturnSuccess : kIOReturnBadMessageID);
}

IOReturn
IOAccelerator::createAccelID(IOOptionBits options, IOAccelID * identifier)
{
    return (_CreateID(0, options, *identifier, identifier));
}

IOReturn
IOAccelerator::retainAccelID(IOOptionBits options, IOAccelID id)
{
    IOAccelIDRecord * record;
    bool found = false;
    IOLockLock(gLock);

    queue_iterate(&gGlobalList,
                    record,
                    IOAccelIDRecord *,
                    glob_link)
    {
        found = (record->id == id);
	if (found)
	{
	    record->retain++;
	    break;
	}
    }

    IOLockUnlock(gLock);

    return (found ? kIOReturnSuccess : kIOReturnBadMessageID);
}

IOReturn
IOAccelerator::releaseAccelID(IOOptionBits options, IOAccelID id)
{
    IOAccelIDRecord * record;
    bool found = false;
    IOLockLock(gLock);

    queue_iterate(&gGlobalList,
                    record,
                    IOAccelIDRecord *,
                    glob_link)
    {
        found = (record->id == id);
	if (found)
	{
	    if (!--record->retain)
	    {
		if (record->task_link.next)
		    panic("IOAccelerator::releaseID task_link");

		queue_remove(&gGlobalList,
				record,
				IOAccelIDRecord *,
				glob_link);
		gTotalCount--;
		IODelete(record, IOAccelIDRecord, 1);
	    }
	    break;
	}
    }

    IOLockUnlock(gLock);

    return (found ? kIOReturnSuccess : kIOReturnBadMessageID);
}