xnu-201.tar.gz

[apple/xnu.git] / iokit / Drivers / platform / drvAppleCuda / AppleCuda.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 1996 1995 by Open Software Foundation, Inc. 1997 1996 1995 1994 1993 1992 1991  
 *              All Rights Reserved 
 *  
 * Permission to use, copy, modify, and distribute this software and 
 * its documentation for any purpose and without fee is hereby granted, 
 * provided that the above copyright notice appears in all copies and 
 * that both the copyright notice and this permission notice appear in 
 * supporting documentation. 
 *  
 * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE 
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
 * FOR A PARTICULAR PURPOSE. 
 *  
 * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR 
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT, 
 * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 
 * 
 */
/*
 * Copyright 1996 1995 by Apple Computer, Inc. 1997 1996 1995 1994 1993 1992 1991  
 *              All Rights Reserved 
 *  
 * Permission to use, copy, modify, and distribute this software and 
 * its documentation for any purpose and without fee is hereby granted, 
 * provided that the above copyright notice appears in all copies and 
 * that both the copyright notice and this permission notice appear in 
 * supporting documentation. 
 *  
 * APPLE COMPUTER DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE 
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
 * FOR A PARTICULAR PURPOSE. 
 *  
 * IN NO EVENT SHALL APPLE COMPUTER BE LIABLE FOR ANY SPECIAL, INDIRECT, OR 
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT, 
 * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION 
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 
 */
/*
 * MKLINUX-1.0DR2
 */

/* 1 April 1997 Simon Douglas:
 * Stolen wholesale from MkLinux.
 * Added nonblocking adb poll from interrupt level for the debugger.
 * Acknowledge before response so polled mode can work from inside the adb handler.
 *
 * 18 June 1998 sdouglas
 * Start IOKit version. Fix errors from kCudaSRQAssertMask. Use ool cmd & reply buffers,
 * not fixed len in packet. Does queueing here.
 *
 * 20 Nov 1998 suurballe
 * Port to C++
 */


#include "AppleCuda.h"
#include "AppleCudaUserClient.h"
#include "IOCudaADBController.h"
#include <IOKit/IOLib.h>
#include <IOKit/IOSyncer.h>
#include <IOKit/IOWorkLoop.h>
#include <IOKit/IOInterruptEventSource.h>
#include <IOKit/IODeviceMemory.h>
#include <IOKit/IOPlatformExpert.h>
#include <IOKit/pwr_mgt/IOPM.h> 

#include <IOKit/assert.h>

#define super IOService
OSDefineMetaClassAndStructors(AppleCuda,IOService)

static  void 	cuda_interrupt ( AppleCuda * self );

static  void    cuda_process_response(AppleCuda * self);
static  void    cuda_transmit_data(AppleCuda * self);
static  void    cuda_expected_attention(AppleCuda * self);
static  void    cuda_unexpected_attention(AppleCuda * self);
static  void    cuda_receive_data(AppleCuda * self);
static  void    cuda_receive_last_byte(AppleCuda * self);
static  void    cuda_collision(AppleCuda * self);
static  void    cuda_idle(AppleCuda * self);

static  void    cuda_poll(AppleCuda * self);
static  void    cuda_error(AppleCuda * self);
static  void    cuda_send_request(AppleCuda * self);
static IOReturn cuda_do_sync_request( AppleCuda * self,
		cuda_request_t * request, bool polled);
static	void	cuda_do_state_transition_delay(AppleCuda * self);

static int Cuda_PE_poll_input(unsigned int options, char * c);
static int Cuda_PE_read_write_time_of_day(unsigned int options, long * secs);
static int Cuda_PE_halt_restart(unsigned int type);
static int Cuda_PE_write_IIC(unsigned char addr, unsigned char reg,
				unsigned char data);

static void
autopollArrived ( OSObject *inCuda, IOInterruptEventSource *, int );

static int set_cuda_power_message ( int command );
static int set_cuda_file_server_mode ( int command );
static int set_cuda_poweruptime(long secs);
static void cuda_async_set_power_message_enable( thread_call_param_t param, thread_call_param_t );
static void cuda_async_set_file_server_mode( thread_call_param_t param, thread_call_param_t ) ;

bool CudahasRoot( OSObject * us, void *, IOService * yourDevice );


//
// inline functions
//

static __inline__ unsigned char cuda_read_data(AppleCuda * self)
{
    volatile unsigned char val;

    val = *self->cuda_via_regs.shift; eieio();
    return val;
}

static __inline__ int cuda_get_result(cuda_request_t *request)
{
    int status = ADB_RET_OK;
    int theStatus = request->a_reply.a_header[1];
    
    if ( theStatus & kCudaTimeOutMask ) {
        status = ADB_RET_TIMEOUT;
#if 0
    // these are expected before autopoll mask is set
    } else if ( theStatus & kCudaSRQAssertMask ) {
        status = ADB_RET_UNEXPECTED_RESULT;
#endif
    } else if ( theStatus & kCudaSRQErrorMask ) {
        status = ADB_RET_REQUEST_ERROR;
    } else if ( theStatus & kCudaBusErrorMask ) {
        status = ADB_RET_BUS_ERROR;
    }

    return status;
}

static __inline__ void cuda_lock(AppleCuda * self)
{
    if( !self->cuda_polled_mode)
        IOSimpleLockLock(self->cuda_request_lock);
}

static __inline__ void cuda_unlock(AppleCuda * self)
{
    if( !self->cuda_polled_mode)
        IOSimpleLockUnlock(self->cuda_request_lock);
}

//
// 
//


static AppleCuda * gCuda;
// **********************************************************************************
// init
//
// **********************************************************************************
bool AppleCuda::init ( OSDictionary * properties = 0 )
{
return super::init(properties);
}


// **********************************************************************************
// start
//
// **********************************************************************************
bool AppleCuda::start ( IOService * nub )
{
int i;
IOMemoryMap * viaMap;
unsigned char * cuda_base;

if( !super::start(nub))
    return false;

gCuda = this;
  // callPlatformFunction symbols
  cuda_check_any_interrupt = OSSymbol::withCString("cuda_check_any_interrupt");

workLoop = NULL;
eventSrc = NULL;
ourADBinterface = NULL;
_rootDomain = 0; 
_wakeup_from_sleep = false;

workLoop = IOWorkLoop::workLoop();
if ( !workLoop ) {
        kprintf("Start is bailing\n");
	return false;
}

eventSrc = IOInterruptEventSource::interruptEventSource(this, autopollArrived);
if (!eventSrc || 
	kIOReturnSuccess != workLoop->addEventSource(eventSrc) ) {
        kprintf("Start is bailing\n");
	return false;
}

if( 0 == (viaMap = nub->mapDeviceMemoryWithIndex( 0 )) ) {
	IOLog("%s: no via memory\n", getName());
        kprintf("Start is bailing\n");
	return false;
}
cuda_base = (unsigned char *)viaMap->getVirtualAddress();

kprintf("VIA base = %08x\n", (UInt32)cuda_base);
ourADBinterface = new IOCudaADBController;
if ( !ourADBinterface ) {
        kprintf("Start is bailing\n");
	return false;
}
if ( !ourADBinterface->init(0,this) ) {
        kprintf("Start is bailing\n");
        return false;
}

if ( !ourADBinterface->attach( this) ) {
        kprintf("Start is bailing\n");
        return false;
}

cuda_request_lock = IOSimpleLockAlloc();
IOSimpleLockInit(cuda_request_lock);

cuda_via_regs.dataB         	    = cuda_base;
cuda_via_regs.handshakeDataA        = cuda_base+0x0200;
cuda_via_regs.dataDirectionB        = cuda_base+0x0400;
cuda_via_regs.dataDirectionA        = cuda_base+0x0600;
cuda_via_regs.timer1CounterLow      = cuda_base+0x0800;
cuda_via_regs.timer1CounterHigh     = cuda_base+0x0A00;
cuda_via_regs.timer1LatchLow        = cuda_base+0x0C00;
cuda_via_regs.timer1LatchHigh       = cuda_base+0x0E00;
cuda_via_regs.timer2CounterLow      = cuda_base+0x1000;
cuda_via_regs.timer2CounterHigh     = cuda_base+0x1200;
cuda_via_regs.shift         	    = cuda_base+0x1400;
cuda_via_regs.auxillaryControl      = cuda_base+0x1600;
cuda_via_regs.peripheralControl     = cuda_base+0x1800;
cuda_via_regs.interruptFlag    	    = cuda_base+0x1A00;
cuda_via_regs.interruptEnable       = cuda_base+0x1C00;
cuda_via_regs.dataA         	    = cuda_base+0x1E00;

// we require delays of this duration between certain state transitions
clock_interval_to_absolutetime_interval(200, 1, &cuda_state_transition_delay);

// Set the direction of the cuda signals.  ByteACk and TIP are output and
// TREQ is an input

*cuda_via_regs.dataDirectionB |= (kCudaByteAcknowledgeMask | kCudaTransferInProgressMask);
*cuda_via_regs.dataDirectionB &= ~kCudaTransferRequestMask;

// Set the clock control.  Set to shift data in by external clock CB1.

*cuda_via_regs.auxillaryControl = (*cuda_via_regs.auxillaryControl | kCudaTransferMode) &
								kCudaSystemRecieve;

// Clear any posible cuda interupt.

if ( *cuda_via_regs.shift );

// Initialize the internal data.

cuda_interrupt_state    = CUDA_STATE_IDLE;
cuda_transaction_state  = CUDA_TS_NO_REQUEST;
cuda_is_header_transfer = false;
cuda_is_packet_type 	= false;
cuda_transfer_count 	= 0;
cuda_current_response   = NULL;
for( i = 0; i < NUM_AP_BUFFERS; i++ ) {
	cuda_unsolicited[ i ].a_buffer = cuda_autopoll_buffers[ i ];
}

// Terminate transaction and set idle state

cuda_neg_tip_and_byteack(this);

// we want to delay 4 mS for ADB reset to complete

IOSleep( 4 );

// Clear pending interrupt if any...

(void)cuda_read_data(this);

// Issue a Sync Transaction, ByteAck asserted while TIP is negated.

cuda_assert_byte_ack(this);

// Wait for the Sync acknowledgement, cuda to assert TREQ

cuda_wait_for_transfer_request_assert(this);

// Wait for the Sync acknowledgement interrupt.

cuda_wait_for_interrupt(this);

// Clear pending interrupt

(void)cuda_read_data(this);

// Terminate the sync cycle by Negating ByteAck

cuda_neg_byte_ack(this);

// Wait for the Sync termination acknowledgement, cuda negates TREQ.

cuda_wait_for_transfer_request_neg(this);

// Wait for the Sync termination acknowledgement interrupt.

cuda_wait_for_interrupt(this);

// Terminate transaction and set idle state, TIP negate and ByteAck negate.
cuda_neg_transfer_in_progress(this);

// Clear pending interrupt, if there is one...
(void)cuda_read_data(this);

#if 0
        cuda_polled_mode = true;
#else
#define	VIA_DEV_CUDA		2
nub->registerInterrupt(VIA_DEV_CUDA,
                       this, (IOInterruptAction) cuda_interrupt);
nub->enableInterrupt(VIA_DEV_CUDA);
#endif

PE_poll_input = Cuda_PE_poll_input;
PE_read_write_time_of_day = Cuda_PE_read_write_time_of_day;
PE_halt_restart = Cuda_PE_halt_restart;
PE_write_IIC = Cuda_PE_write_IIC;
publishResource( "IOiic0", this );
publishResource( "IORTC", this );


//set_cuda_power_message(kADB_powermsg_enable); //won't work on beige G3
thread_call_func(cuda_async_set_power_message_enable, (thread_call_param_t)this, true);
thread_call_func(cuda_async_set_file_server_mode, (thread_call_param_t)this, true);

    registerService();	//Gossamer needs to find this driver for waking up G3

    _cuda_power_state = 1;  //default is wake state
    //We want to know when sleep is about to occur
    addNotification( gIOPublishNotification,serviceMatching("IOPMrootDomain"),
                 (IOServiceNotificationHandler)CudahasRoot, this, 0 );

ourADBinterface->start( this );

return true;
}

/* Here are some power management functions so we can tell when system is
    going to sleep. */
bool CudahasRoot( OSObject * us, void *, IOService * yourDevice )
{
    if (( yourDevice != NULL ) && ((AppleCuda *)us)->_rootDomain == 0)
    {
        ((AppleCuda *)us)->_rootDomain = (IOPMrootDomain *) yourDevice;
        ((IOPMrootDomain *)yourDevice)->registerInterestedDriver((IOService *) us);
    }
    return true;
}   
 
IOReturn AppleCuda::powerStateWillChangeTo ( IOPMPowerFlags theFlags, unsigned long unused1,
    IOService* unused2)
{
    if ( ! (theFlags & IOPMPowerOn) )
    {
        _cuda_power_state = 0;  //0 means sleeping
    }
    return IOPMAckImplied;
}

IOReturn AppleCuda::powerStateDidChangeTo ( IOPMPowerFlags theFlags, unsigned long unused1,
    IOService* unused2)
{
    if (theFlags & IOPMPowerOn)
    {
        _cuda_power_state = 1;  //1 means awake
	_wakeup_from_sleep = false; //normally it is false
    }
    return IOPMAckImplied;
}



// *****************************************************************************
// getWorkLoop
//
// Return the cuda's workloop.
//
// *****************************************************************************
IOWorkLoop *AppleCuda::getWorkLoop() const
{
    return workLoop;
}

// *****************************************************************************
// free
//
// Release everything we may have allocated.
//
// *****************************************************************************
void AppleCuda::free ( void )
{
if ( workLoop ) {
	workLoop->release();
}
if ( eventSrc ) {
	eventSrc->release();
}
if ( ourADBinterface ) {
	ourADBinterface->release();
}
    if (_rootDomain) 
    {
        _rootDomain->deRegisterInterestedDriver((IOService *) this); 
        _rootDomain = 0;
    }
super::free();
}


// **********************************************************************************
// registerForADBInterrupts
//
// Some driver is calling to say it is prepared to receive "unsolicited" adb
// interrupts (e.g. autopoll keyboard and trackpad data).  The parameters identify
// who to call when we get one.
// **********************************************************************************
void AppleCuda::registerForADBInterrupts ( ADB_callback_func handler, IOService * caller )
{
autopoll_handler = handler;
ADBid = caller;
}


// **********************************************************************************
// autopollArrived
//
// **********************************************************************************
static void autopollArrived ( OSObject * CudaDriver, IOInterruptEventSource *, int )
{
((AppleCuda *)CudaDriver)->serviceAutopolls();
}

#define RB_BOOT		1	/* Causes reboot, not halt.  Is in xnu/bsd/sys/reboot.h */
extern "C" {
	void boot(int paniced, int howto, char * command);
}


static void cuda_async_set_power_message_enable( thread_call_param_t param, thread_call_param_t )
{
    //AppleCuda * me = (AppleCuda *) param;

    set_cuda_power_message(kADB_powermsg_enable);
}

static void cuda_async_set_file_server_mode( thread_call_param_t param, thread_call_param_t )
{
    set_cuda_file_server_mode(1); 
}   
        
// **********************************************************************************
// serviceAutopolls
//      We get here just before calling autopollHandler() in IOADBController.cpp
// **********************************************************************************
void AppleCuda::serviceAutopolls ( void )
{
cuda_packet_t *	response;

  while( inIndex != outIndex ) {
        response = &cuda_unsolicited[ outIndex ];

        //Check for power messages, which are handled differently from regular
        //  autopoll data coming from mouse or keyboard.
        if (response->a_header[0] == ADB_PACKET_POWER)
        {
                unsigned char flag, cmd;

                flag = response->a_header[1];
                cmd  = response->a_header[2];

                if ((flag == kADB_powermsg_flag_chassis)
                &&  (cmd == kADB_powermsg_cmd_chassis_off))
                {
                        thread_call_func(cuda_async_set_power_message_enable,
                                (thread_call_param_t)this, true);

                        if (_rootDomain)
                        {
                            if (_cuda_power_state)
                            {
                                //Put system to sleep now
                                _rootDomain->receivePowerNotification (kIOPMSleepNow);
                            }
                            else //If asleep, wake up the system
                            {
                                //Tickle activity timer in root domain.  This will not
                                // wake up machine that is in demand-sleep, but it will
                                // wake up an inactive system that dozed
                                _rootDomain->activityTickle(0,0);
                            }
                        }
                }
		else if ((flag == kADB_powermsg_flag_keyboardpwr)
                &&  (cmd == kADB_powermsg_cmd_keyboardoff))
		{
			//set_cuda_power_message(kADB_powermsg_continue);
			//This needs to by async so Beige G3 ADB won't lock up
    			thread_call_func(cuda_async_set_power_message_enable, 
				(thread_call_param_t)this, true);
		}

        }
        if ( ADBid != NULL ) {
           (*autopoll_handler)(ADBid,response->a_header[2],response->a_bcount,response->a_buffer);
        }

        outIndex = (outIndex + 1) & (NUM_AP_BUFFERS - 1);

  } //end of while loop

}


// **********************************************************************************
// doSyncRequest
//
// **********************************************************************************
IOReturn AppleCuda::doSyncRequest ( cuda_request_t * request )
{
return(cuda_do_sync_request(this, request, false));
}


IOReturn AppleCuda::callPlatformFunction(const OSSymbol *functionName,
						    bool waitForFunction,
						    void *param1, void *param2,
						    void *param3, void *param4)
{  
    if (functionName == cuda_check_any_interrupt)
    {
	bool	*hasint;
	
	hasint = (bool *)param1;
	*hasint = false;

	if (inIndex != outIndex)
	{
	    *hasint = true;
	}
	
	if (_wakeup_from_sleep)
	{
	    *hasint = true;
	}
	return kIOReturnSuccess;
    }
    
    return kIOReturnBadArgument;
}


void
AppleCuda::setWakeTime(UInt32 waketime)
{
    //Call this function with waketime=0 in order to allow normal sleep again
    _wakeup_from_sleep = false;
    if (waketime != 0) {
        timerSrc = IOTimerEventSource::timerEventSource((OSObject*)this, WakeupTimeoutHandler);

	if (!timerSrc || (workLoop->addEventSource(timerSrc) != kIOReturnSuccess)) 
	{
	    IOLog("Cuda can not register timeout event\n");
	    return;
	}

	timerSrc->setTimeoutMS(waketime);
    }
}

static void
AppleCuda::WakeupTimeoutHandler(OSObject *object, IOTimerEventSource *timer)
{
    gCuda->_wakeup_from_sleep = true;
    if (gCuda->_rootDomain) 
    {
	gCuda->_rootDomain->activityTickle(0,0);
    }
}


void
AppleCuda::setPowerOnTime(UInt32 newTime)
{
    long long_secs;

    if (newTime != 0) {
	Cuda_PE_read_write_time_of_day(kPEReadTOD, &long_secs);
	set_cuda_poweruptime((long)newTime + long_secs);
    }
}

void
AppleCuda::setFileServerMode(bool fileServerModeON)
{
    set_cuda_file_server_mode((int) fileServerModeON);
}

void AppleCuda::demandSleepNow(void)
{
    if (_rootDomain)
    {
	_rootDomain->receivePowerNotification (kIOPMSleepNow);
    }
}

// --------------------------------------------------------------------------
//
// Method: newUserClient
//
// Purpose:
//        newUserClient is called by the IOKit manager to create the
//        kernel receiver of a user request. The "type" is a qualifier
//        shared between the kernel and user client class instances..

#define kAppleCudaUserClientMagicCookie 0x0C00DA

IOReturn
AppleCuda::newUserClient(task_t        owningTask,
                        void          *securityToken,
                        UInt32        magicCookie,
                        IOUserClient  **handler)
{
    IOReturn ioReturn = kIOReturnSuccess;
    AppleCudaUserClient *client = NULL;

    IOLog("AppleCuda::newUserClient\n");

    if (IOUserClient::clientHasPrivilege(securityToken, "root") != kIOReturnSuccess) {
        IOLog("AppleCuda::newUserClient: Can't create user client, not privileged\n");
        return kIOReturnNotPrivileged;
    }

    // Check that this is a user client type that we support.
    // type is known only to this driver's user and kernel
    // classes. It could be used, for example, to define
    // read or write privileges. In this case, we look for
    // a private value.
    if (magicCookie == kAppleCudaUserClientMagicCookie) {
        // Construct a new client instance for the requesting task.
        // This is, essentially  client = new AppleCudaUserClient;
        //				... create metaclasses ...
        //				client->setTask(owningTask)
        client = AppleCudaUserClient::withTask(owningTask);
        if (client == NULL) {
            ioReturn = kIOReturnNoResources;
            IOLog("AppleCuda::newUserClient: Can't create user client\n");
        }
    }
    else {
        ioReturn = kIOReturnInvalid;
        IOLog("AppleCuda::newUserClient: bad magic cookie.\n");
    }

    if (ioReturn == kIOReturnSuccess) {
        // Attach ourself to the client so that this client instance
        // can call us.
        if (client->attach(this) == false) {
            ioReturn = kIOReturnError;
            IOLog("AppleCuda::newUserClient: Can't attach user client\n");
        }
    }

    if (ioReturn == kIOReturnSuccess) {
        // Start the client so it can accept requests.
        if (client->start(this) == false) {
            ioReturn = kIOReturnError;
            IOLog("AppleCuda::newUserClientt: Can't start user client\n");
        }
    }

    if (ioReturn != kIOReturnSuccess && client != NULL) {
        client->detach(this);
        client->release();
    }

    *handler = client;
    return (ioReturn);
}

// **********************************************************************************
// cuda_do_sync_request
//
// **********************************************************************************
IOReturn cuda_do_sync_request ( AppleCuda * self, cuda_request_t * request, bool polled )
{
    bool		wasPolled = false;
    IOInterruptState	ints;

    if( !polled ) {
        request->sync = IOSyncer::create();
	request->needWake = true;
    }

    ints = IOSimpleLockLockDisableInterrupt(self->cuda_request_lock);

    if( polled ) {
        wasPolled = self->cuda_polled_mode;
        self->cuda_polled_mode = polled;
    }

    if( self->cuda_last_request )
	self->cuda_last_request->a_next = request;
    else
	self->cuda_request = request;

    self->cuda_last_request = request;

    if( self->cuda_interrupt_state == CUDA_STATE_IDLE )
	cuda_send_request(self);

    if( polled ) {
        cuda_poll(self);
        self->cuda_polled_mode = wasPolled;
        assert( 0 == self->cuda_request );
        assert( 0 == self->cuda_last_request );
    }

    IOSimpleLockUnlockEnableInterrupt(self->cuda_request_lock, ints);

    if( !polled)
	request->sync->wait();

    return cuda_get_result(request);
}


// **********************************************************************************
// Cuda_PE_read_write_time_of_day
//
// **********************************************************************************
static int Cuda_PE_read_write_time_of_day ( unsigned int options, long * secs )
{
cuda_request_t cmd;

adb_init_request(&cmd);

cmd.a_cmd.a_hcount = 2;
cmd.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;

switch( options ) {

	case kPEReadTOD:
            cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_GET_REAL_TIME;
            cmd.a_reply.a_buffer = (UInt8 *)secs;
            cmd.a_reply.a_bcount = sizeof(*secs);
	    break;

	case kPEWriteTOD:
            cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_SET_REAL_TIME;
            cmd.a_cmd.a_buffer = (UInt8 *)secs;
            cmd.a_cmd.a_bcount = sizeof(*secs);
	    break;

	default:
	    return 1;
}

return cuda_do_sync_request(gCuda, &cmd, true);
}


// **********************************************************************************
// Cuda_PE_halt_restart
//
// **********************************************************************************
static int Cuda_PE_halt_restart ( unsigned int type )
{
cuda_request_t cmd;

adb_init_request(&cmd);

cmd.a_cmd.a_hcount = 2;
cmd.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;

switch( type ) {

	case kPERestartCPU:
            cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_RESTART_SYSTEM;
	    break;

	case kPEHaltCPU:
            cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_POWER_DOWN;
	    break;

	default:
	    return 1;
    }

return cuda_do_sync_request(gCuda, &cmd, true);
}

// **********************************************************************************
// Set the power-on time.  2001
// **********************************************************************************
static int set_cuda_poweruptime (long secs)
{
    cuda_request_t cmd;
    long localsecs = secs;

    adb_init_request(&cmd);

    cmd.a_cmd.a_hcount = 2;
    cmd.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;

    cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_SET_POWER_UPTIME;
    cmd.a_cmd.a_buffer = (UInt8 *)&localsecs;
    cmd.a_cmd.a_bcount = 4;

    return cuda_do_sync_request(gCuda, &cmd, true);
}


// **********************************************************************************
// In case this machine loses power, it will automatically reboot when power is
//   restored.  Only desktop machines have Cuda, so this feature will not affect
//   PowerBooks.
// **********************************************************************************
static int set_cuda_file_server_mode ( int command )
{ 
cuda_request_t cmd;
    
adb_init_request(&cmd); 

cmd.a_cmd.a_hcount = 3;
cmd.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_FILE_SERVER_FLAG;
cmd.a_cmd.a_header[2] = command;
        
return cuda_do_sync_request(gCuda, &cmd, true);
}       

// **********************************************************************************
// Fix front panel power key (mostly on Yosemites) so that one press won't power
//   down the entire machine
//
// **********************************************************************************
static int set_cuda_power_message ( int command )
{
cuda_request_t cmd;

if (command >= kADB_powermsg_invalid)
	return 0;  //invalid Cuda power request

adb_init_request(&cmd);

cmd.a_cmd.a_hcount = 3;
cmd.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_SET_POWER_MESSAGES;
cmd.a_cmd.a_header[2] = command;

return cuda_do_sync_request(gCuda, &cmd, true);
}


// **********************************************************************************
// Cuda_PE_write_IIC
//
// **********************************************************************************
static int Cuda_PE_write_IIC ( unsigned char addr, unsigned char reg, unsigned char data )
{
cuda_request_t cmd;

adb_init_request(&cmd);

cmd.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_GET_SET_IIC;
cmd.a_cmd.a_header[2] = addr;
cmd.a_cmd.a_header[3] = reg;
cmd.a_cmd.a_header[4] = data;
cmd.a_cmd.a_hcount = 5;

return cuda_do_sync_request(gCuda, &cmd, true);
}

IOReturn
AppleCudaWriteIIC( UInt8 address, const UInt8 * buffer, IOByteCount * count )
{
    IOReturn	   ret;
    cuda_request_t cmd;
    
    if( !gCuda)
        return( kIOReturnUnsupported );

    adb_init_request(&cmd);

    cmd.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
    cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_GET_SET_IIC;
    cmd.a_cmd.a_header[2] = address;
    cmd.a_cmd.a_hcount    = 3;
    cmd.a_cmd.a_buffer    = (UInt8 *) buffer;
    cmd.a_cmd.a_bcount    = *count;

    ret = cuda_do_sync_request(gCuda, &cmd, true);

    *count = cmd.a_cmd.a_bcount;

    return( ret );
}

IOReturn
AppleCudaReadIIC( UInt8 address, UInt8 * buffer, IOByteCount * count )
{
    IOReturn	   ret;
    cuda_request_t cmd;
    
    if( !gCuda)
        return( kIOReturnUnsupported );

    adb_init_request(&cmd);

    cmd.a_cmd.a_header[0] = ADB_PACKET_PSEUDO;
    cmd.a_cmd.a_header[1] = ADB_PSEUDOCMD_GET_SET_IIC;
    cmd.a_cmd.a_header[2] = address;
    cmd.a_cmd.a_hcount    = 3;
    cmd.a_reply.a_buffer  = buffer;
    cmd.a_reply.a_bcount  = *count;

    ret = cuda_do_sync_request(gCuda, &cmd, true);
    *count = cmd.a_reply.a_bcount;

    return( ret );
}


// **********************************************************************************
// Cuda_PE_poll_input
//
// **********************************************************************************
static int Cuda_PE_poll_input ( unsigned int, char * c )
{
AppleCuda * 	self = gCuda;
int 		interruptflag;
UInt8		code;
cuda_packet_t *	response;	  //0123456789abcdef
static char	keycodes2ascii[] = "asdfhgzxcv_bqwer"	//00
				"yt123465=97-80]o"	//10
				"u[ip\nlj'k;_,/nm."	//20
				"\t_";			//30

*c = 0xff;

if( !self ) {
	return 1;
}

self->cuda_polled_mode = true;
interruptflag = *self->cuda_via_regs.interruptFlag & kCudaInterruptMask;
eieio();
if( interruptflag ) {
	cuda_interrupt(self);
}

if( self->inIndex != self->outIndex ) {
	response = &self->cuda_unsolicited[ self->outIndex ];
	if( ((response->a_header[2] >> 4) == 2)
		&&  (response->a_bcount > 1) ) {
		code = response->a_buffer[0];
		if( code < sizeof(keycodes2ascii) ) {
			*c = keycodes2ascii[ code ];
		}
	}
        self->outIndex = self->inIndex;
}

self->cuda_polled_mode = false;
return 0;
}


//
// internal
//


// **********************************************************************************
// cuda_send_request
//
// **********************************************************************************
static void cuda_send_request ( AppleCuda * self )
{

    // The data register must written with the data byte 25uS
    // after examining TREQ or we run the risk of getting out of sync
    // with Cuda. So call with disabled interrupts and spinlock held.

    // Check if we can commence with the packet transmission.  First, check if
    // Cuda can service our request now.  Second, check if Cuda wants to send
    // a response packet now.

if( !cuda_is_transfer_in_progress(self) ) {
    // Set the shift register direction to output to Cuda by setting
    // the direction bit.

        cuda_set_data_direction_to_output(self);

        // Write the first byte to the shift register
        cuda_write_data(self, self->cuda_request->a_cmd.a_header[0]);

        // Set up the transfer state info here.

        self->cuda_is_header_transfer = true;
        self->cuda_transfer_count = 1;

        // Make sure we're in idle state before transaction, and then
        // assert TIP to tell Cuda we're starting command
        cuda_neg_byte_ack(self);
        cuda_assert_transfer_in_progress(self);

        // The next state is going to be a transmit state, if there is
        // no collision.  This is a requested response but call it sync.

        self->cuda_interrupt_state = CUDA_STATE_TRANSMIT_EXPECTED;
        self->cuda_transaction_state = CUDA_TS_SYNC_RESPONSE;
} 

#if 0
else {
	IOLog("Req = %x, state = %x, TIP = %x\n", self->cuda_request,
        self->cuda_interrupt_state, cuda_is_transfer_in_progress(self));
}
#endif
}


// **********************************************************************************
// cuda_poll
//
// **********************************************************************************
static void cuda_poll( AppleCuda * self )
{
    do {
        cuda_wait_for_interrupt(self);
	cuda_interrupt(self);
    } while( self->cuda_interrupt_state != CUDA_STATE_IDLE );
}

//
//  cuda_process_response
//  Execute at secondary interrupt.
//


// **********************************************************************************
// cuda_process_response
//
// **********************************************************************************
static void cuda_process_response ( AppleCuda * self )
{
volatile cuda_request_t *	request;
unsigned int			newIndex;

    // Almost ready for the next state, which should be a Idle state.
    // Just need to notifiy the client.

if ( self->cuda_transaction_state == CUDA_TS_SYNC_RESPONSE ) {

        // dequeue reqeuest
        cuda_lock(self);
        request = self->cuda_request;
        if( NULL == (self->cuda_request = request->a_next) ) {
            self->cuda_last_request = NULL;
	}
        cuda_unlock(self);

        // wake the sync request thread
        if ( ((cuda_request_t *)request)->needWake ) {
            ((cuda_request_t *)request)->sync->signal();
	}

}
else {
	if ( self->cuda_transaction_state == CUDA_TS_ASYNC_RESPONSE ) {
        	newIndex = (self->inIndex + 1) & (NUM_AP_BUFFERS - 1);
        	if( newIndex != self->outIndex ) {
       			self->inIndex = newIndex;
        	}
		else {
            		// drop this packet, and reuse the buffer
        	}
        	if ( !self->cuda_polled_mode ) {
            		// wake thread to service autopolls
            		self->eventSrc->interruptOccurred(0, 0, 0);
		}
        }
}
return;
}


// **********************************************************************************
// cuda_interrupt
//
// **********************************************************************************
static void cuda_interrupt ( AppleCuda * self )
{
unsigned char interruptState;

    // Get the relevant signal in determining the cause of the interrupt:
    // the shift direction, the transfer request line and the transfer
    // request line.

interruptState = cuda_get_interrupt_state(self);

//kprintf("%02x",interruptState);

switch ( interruptState ) {
    case kCudaReceiveByte:
        cuda_receive_data(self);
        break;

    case kCudaReceiveLastByte:
        cuda_receive_last_byte(self);
        break;

    case kCudaTransmitByte:
        cuda_transmit_data(self);
        break;

    case kCudaUnexpectedAttention:
        cuda_unexpected_attention(self);
        break;

    case kCudaExpectedAttention:
        cuda_expected_attention(self);
        break;

    case kCudaIdleState:
        cuda_idle(self);
        break;

    case kCudaCollision:
        cuda_collision(self);
        break;

    // Unknown interrupt, clear it and leave.
    default:
        cuda_error(self);
        break;
}
}

//
//  TransmitCudaData
//  Executes at hardware interrupt level.
//

// **********************************************************************************
// cuda_transmit_data
//
// **********************************************************************************
static void cuda_transmit_data ( AppleCuda * self )
{
    // Clear the pending interrupt by reading the shift register.

if ( self->cuda_is_header_transfer ) {
        // There are more header bytes, write one out.
        cuda_write_data(self, self->cuda_request->a_cmd.a_header[self->cuda_transfer_count++]);

        // Toggle the handshake line.
        if ( self->cuda_transfer_count >= self->cuda_request->a_cmd.a_hcount ) {
            self->cuda_is_header_transfer = FALSE;
            self->cuda_transfer_count = 0;
        }

        cuda_toggle_byte_ack( self);
}
else {
	if ( self->cuda_transfer_count < self->cuda_request->a_cmd.a_bcount ) {
    		// There are more command bytes, write one out and update the pointer
        	cuda_write_data( self,
			*(self->cuda_request->a_cmd.a_buffer + self->cuda_transfer_count++));
		// Toggle the handshake line.
        	cuda_toggle_byte_ack(self);
    	}
	else {
        	(void)cuda_read_data(self);
        	// There is no more command bytes, terminate the send transaction.
      		// Cuda should send a expected attention interrupt soon.

       		cuda_neg_tip_and_byteack(self);

        	// The next interrupt should be a expected attention interrupt.

        	self->cuda_interrupt_state = CUDA_STATE_ATTN_EXPECTED;
	}
}
}

//
//  cuda_expected_attention
//  Executes at hardware interrupt level.
//


// **********************************************************************************
// cuda_expected_attention
//
// **********************************************************************************
static void cuda_expected_attention ( AppleCuda * self )
{
    // Clear the pending interrupt by reading the shift register.

(void)cuda_read_data(self);

    // Allow the VIA to settle directions.. else the possibility of
    // data corruption.
cuda_do_state_transition_delay(self);

if ( self->cuda_transaction_state ==  CUDA_TS_SYNC_RESPONSE ) {
        self->cuda_current_response = (cuda_packet_t*)&self->cuda_request->a_reply;
}
else {
        self->cuda_current_response = &self->cuda_unsolicited[ self->inIndex ];
        self->cuda_current_response->a_hcount = 0;
        self->cuda_current_response->a_bcount = MAX_AP_RESPONSE;
}

self->cuda_is_header_transfer = true;
self->cuda_is_packet_type = true;
self->cuda_transfer_count = 0;

    // Set the shift register direction to input.
cuda_set_data_direction_to_input(self);

    // Start the response packet transaction.
cuda_assert_transfer_in_progress(self);

    // The next interrupt should be a receive data interrupt.
self->cuda_interrupt_state = CUDA_STATE_RECEIVE_EXPECTED;
}

//
//  cuda_unexpected_attention
//  Executes at hardware interrupt level.
//


// **********************************************************************************
// cuda_expected_attention
//
// **********************************************************************************
static void cuda_unexpected_attention ( AppleCuda * self )
{
    // Clear the pending interrupt by reading the shift register.
(void)cuda_read_data(self);

    // Get ready for a unsolicited response.
self->cuda_current_response = &self->cuda_unsolicited[ self->inIndex ];
self->cuda_current_response->a_hcount = 0;
self->cuda_current_response->a_bcount = MAX_AP_RESPONSE;

self->cuda_is_header_transfer = TRUE;
self->cuda_is_packet_type = TRUE;
self->cuda_transfer_count = 0;

    // Start the response packet transaction, Transaction In Progress
cuda_assert_transfer_in_progress(self);

    // The next interrupt should be a receive data interrupt and the next
    // response should be an async response.

self->cuda_interrupt_state = CUDA_STATE_RECEIVE_EXPECTED;

self->cuda_transaction_state = CUDA_TS_ASYNC_RESPONSE;
}

//
//  cuda_receive_data
//  Executes at hardware interrupt level.
//


// **********************************************************************************
// cuda_receive_data
//
// **********************************************************************************
static void cuda_receive_data ( AppleCuda * self )
{
if ( self->cuda_is_packet_type ) {
        unsigned char packetType;

        packetType = cuda_read_data( self);
        self->cuda_current_response->a_header[self->cuda_transfer_count++] = packetType;

        if ( packetType == ADB_PACKET_ERROR) {
            self->cuda_current_response->a_hcount = 4;
        }
	else {
            self->cuda_current_response->a_hcount = 3;
        }

        self->cuda_is_packet_type = false;

        cuda_toggle_byte_ack(self);

}
else {


	if ( self->cuda_is_header_transfer ) {

        	self->cuda_current_response->a_header[self->cuda_transfer_count++] =
                	cuda_read_data(self);

        	if (self->cuda_transfer_count >= self->cuda_current_response->a_hcount) {
            		self->cuda_is_header_transfer = FALSE;
            		self->cuda_transfer_count = 0;
        	}

        	cuda_toggle_byte_ack(self);
    	}
	else {
		if ( self->cuda_transfer_count < self->cuda_current_response->a_bcount ) {
        		// Still room for more bytes. Get the byte and tell Cuda to continue.
        		// Toggle the handshake line, ByteAck, to acknowledge receive.

        		*(self->cuda_current_response->a_buffer + self->cuda_transfer_count++) =
                		cuda_read_data(self);
        		cuda_toggle_byte_ack(self);

    		}
		else {
        		// Cuda is still sending data but the buffer is full.
        		// Normally should not get here.  The only exceptions are open ended
        		// request such as  PRAM read...  In any event time to exit.

        		self->cuda_current_response->a_bcount = self->cuda_transfer_count;

        		cuda_read_data(self);

        		cuda_process_response(self);
        		cuda_neg_tip_and_byteack(self);
    		}
	}
}
}


//
//  cuda_receive_last_byte
//  Executes at hardware interrupt level.
//


// **********************************************************************************
// cuda_receive_last_byte
//
// **********************************************************************************
static void cuda_receive_last_byte ( AppleCuda * self )
{

if ( self->cuda_is_header_transfer ) {
        self->cuda_current_response->a_header[self->cuda_transfer_count++]  =
            cuda_read_data(self);

        self->cuda_transfer_count = 0;
    }
else {
	if ( self->cuda_transfer_count < self->cuda_current_response->a_bcount ) {
        	*(self->cuda_current_response->a_buffer + self->cuda_transfer_count++) =
            	cuda_read_data(self);
    	}
	else {
        	/* Overrun -- ignore data */
        	(void) cuda_read_data(self);
    	}
}
self->cuda_current_response->a_bcount = self->cuda_transfer_count;
    // acknowledge before response so polled mode can work
    //	from inside the handler
cuda_neg_tip_and_byteack(self);
cuda_process_response(self);
}


//
//  cuda_collision
//  Executes at hardware interrupt level.
//


// **********************************************************************************
// cuda_collision
//
// **********************************************************************************
static void cuda_collision ( AppleCuda * self )
{
// Clear the pending interrupt by reading the shift register.
(void)cuda_read_data(self);

// Negate TIP to abort the send.  Cuda should send a second attention
// interrupt to acknowledge the abort cycle.
cuda_neg_transfer_in_progress(self);

// The next interrupt should be an expected attention and the next
// response packet should be an async response.

self->cuda_interrupt_state = CUDA_STATE_ATTN_EXPECTED;
self->cuda_transaction_state = CUDA_TS_ASYNC_RESPONSE;

/* queue the request */
self->cuda_is_header_transfer = false;
self->cuda_transfer_count = 0;
}


//
//  
//  Executes at hardware interrupt level.
//


// **********************************************************************************
// cuda_idle
//
// **********************************************************************************
static void cuda_idle ( AppleCuda * self )
{

// Clear the pending interrupt by reading the shift register.
(void)cuda_read_data(self);

cuda_lock(self);
    // Set to the idle state.
self->cuda_interrupt_state = CUDA_STATE_IDLE;
    // See if there are any pending requests.
if( self->cuda_request ) {
        cuda_send_request(self);
}
cuda_unlock(self);
}


// **********************************************************************************
// cuda_error
//
// **********************************************************************************
static void cuda_error ( AppleCuda * self )
{
//printf("{Error %d}", self->cuda_transaction_state);

// Was looking at cuda_transaction_state - doesn't seem right

switch ( self->cuda_interrupt_state ) {
    case CUDA_STATE_IDLE:
        cuda_neg_tip_and_byteack(self);
        break;

    case CUDA_STATE_TRANSMIT_EXPECTED:
        if ( self->cuda_is_header_transfer && self->cuda_transfer_count <= 1 ) {
            cuda_do_state_transition_delay(self);
            cuda_neg_transfer_in_progress(self);
            cuda_set_data_direction_to_input(self);
            panic ("CUDA - TODO FORCE COMMAND BACK UP!\n");
        }
	else {
            self->cuda_interrupt_state = CUDA_STATE_ATTN_EXPECTED;
            cuda_neg_tip_and_byteack(self);
        }
        break;

    case CUDA_STATE_ATTN_EXPECTED:
        cuda_assert_transfer_in_progress(self);

        cuda_do_state_transition_delay(self);
        cuda_set_data_direction_to_input(self);
        cuda_neg_transfer_in_progress(self);
        panic("CUDA - TODO CHECK FOR TRANSACTION TYPE AND ERROR");
        break;

    case CUDA_STATE_RECEIVE_EXPECTED:
        cuda_neg_tip_and_byteack(self);
        panic("Cuda - todo check for transaction type and error");
        break;

    default:
        cuda_set_data_direction_to_input(self);
        cuda_neg_tip_and_byteack(self);
        break;
}
}

static void cuda_do_state_transition_delay( AppleCuda * self )
{
	AbsoluteTime	deadline;

	clock_absolutetime_interval_to_deadline(
							self->cuda_state_transition_delay, &deadline);
	clock_delay_until(deadline);
}