/*
 * Copyright (c) 2004-2006 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The 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, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
#include <ppc/machine_routines.h>
#include <ppc/machine_cpu.h>
#include <ppc/exception.h>
#include <ppc/misc_protos.h>
#include <ppc/Firmware.h>
#include <ppc/pmap.h>
#include <ppc/asm.h>
#include <ppc/proc_reg.h>
#include <kern/pms.h>
#include <ppc/savearea.h>
#include <ppc/Diagnostics.h>
#include <kern/processor.h>


static void pmsCPURemote(uint32_t nstep);


pmsDef pmsDefault[] = {
	{
		.pmsLimit = century,							/* We can normally stay here for 100 years */
		.pmsStepID = pmsIdle,							/* Unique identifier to this step */
		.pmsSetCmd = 0,									/* Dummy platform power level */
		.sf.pmsSetFuncInd = 0,							/* Dummy platform set function */
		.pmsDown = pmsIdle,								/* We stay here */
		.pmsNext = pmsNorm								/* Next step */
	},
	{
		.pmsLimit = century,							/* We can normally stay here for 100 years */
		.pmsStepID = pmsNorm,							/* Unique identifier to this step */
		.pmsSetCmd = 0,									/* Dummy platform power level */
		.sf.pmsSetFuncInd = 0,							/* Dummy platform set function */
		.pmsDown = pmsIdle,								/* Down to idle */
		.pmsNext = pmsNorm								/* Next step */
	},
	{
		.pmsLimit = century,							/* We can normally stay here for 100 years */
		.pmsStepID = pmsNormHigh,						/* Unique identifier to this step */
		.pmsSetCmd = 0,									/* Dummy platform power level */
		.sf.pmsSetFuncInd = 0,							/* Dummy platform set function */
		.pmsDown = pmsIdle,								/* Down to idle */
		.pmsNext = pmsNormHigh							/* Next step */
	},
	{
		.pmsLimit = century,							/* We can normally stay here for 100 years */
		.pmsStepID = pmsBoost,							/* Unique identifier to this step */
		.pmsSetCmd = 0,									/* Dummy platform power level */
		.sf.pmsSetFuncInd = 0,							/* Dummy platform set function */
		.pmsDown = pmsIdle,								/* Step down */
		.pmsNext = pmsBoost								/* Next step */
	},	
	{	
		.pmsLimit = century,							/* We can normally stay here for 100 years */
		.pmsStepID = pmsLow,							/* Unique identifier to this step */
		.pmsSetCmd = 0,									/* Dummy platform power level */
		.sf.pmsSetFuncInd = 0,							/* Dummy platform set function */
		.pmsDown = pmsLow,								/* We always stay here */
		.pmsNext = pmsLow								/* We always stay here */
	},	
	{	
		.pmsLimit = century,							/* We can normally stay here for 100 years */
		.pmsStepID = pmsHigh,							/* Unique identifier to this step */
		.pmsSetCmd = 0,									/* Dummy platform power level */
		.sf.pmsSetFuncInd = 0,							/* Dummy platform set function */
		.pmsDown = pmsHigh,								/* We always stay here */
		.pmsNext = pmsHigh								/* We always stay here */
	},	
	{	
		.pmsLimit = 0,									/* Time doesn't matter for a prepare for change */
		.pmsStepID = pmsPrepCng,						/* Unique identifier to this step */
		.pmsSetCmd = pmsParkIt,							/* Force us to be parked */
		.sf.pmsSetFuncInd = 0,							/* Dummy platform set function */
		.pmsDown = pmsPrepCng,							/* We always stay here */
		.pmsNext = pmsPrepCng							/* We always stay here */
	},	
	{	
		.pmsLimit = 0,									/* Time doesn't matter for a prepare for sleep */
		.pmsStepID = pmsPrepSleep,						/* Unique identifier to this step */
		.pmsSetCmd = pmsParkIt,							/* Force us to be parked */
		.sf.pmsSetFuncInd = 0,							/* Dummy platform set function */
		.pmsDown = pmsPrepSleep,						/* We always stay here */
		.pmsNext = pmsPrepSleep							/* We always stay here */
	},	
	{	
		.pmsLimit = 0,									/* Time doesn't matter for a prepare for sleep */
		.pmsStepID = pmsOverTemp,						/* Unique identifier to this step */
		.pmsSetCmd = 0,									/* Dummy platform power level */
		.sf.pmsSetFuncInd = 0,							/* Dummy platform set function */
		.pmsDown = pmsOverTemp,							/* We always stay here */
		.pmsNext = pmsOverTemp							/* We always stay here */
	}	
};



/*
 *	This is where the CPU part of the stepper code lives.   
 *
 *	It also contains the "hacked kext" experimental code.  This is/was used for
 *	experimentation and bringup.  It should neither live long nor prosper.
 *
 */

/*
 *	Set the processor frequency and stuff
 */

void pmsCPUSet(uint32_t sel) {
	int nfreq;
	struct per_proc_info *pp;

	pp = getPerProc();									/* Get our per_proc */

	if(!((sel ^ pp->pms.pmsCSetCmd) & pmsCPU)) return;	/* If there aren't any changes, bail now... */

	nfreq = (sel & pmsCPU) >> 16;						/* Isolate the new frequency */
	
	switch(pp->pf.pfPowerModes & pmType) {				/* Figure out what type to do */
	
		case pmDFS:										/* This is a DFS machine */
			ml_set_processor_speed_dfs(nfreq);			/* Yes, set it */
			break;
	
		case pmDualPLL:
			ml_set_processor_speed_dpll(nfreq);			/* THIS IS COMPLETELY UNTESTED!!! */
			break;

		case pmPowerTune:								/* This is a PowerTune machine */
			ml_set_processor_speed_powertune(nfreq);	/* Diddle the deal */
			break;
			
		default:										/* Not this time dolt!!! */
			panic("pmsCPUSet: unsupported power manager type: %08X\n", pp->pf.pfPowerModes);
			break;
	
	}
	
}

/*
 *	This code configures the initial step tables.  It should be called after the timebase frequency is initialized.
 */

void pmsCPUConf(void) {

	int i;
	kern_return_t ret;
	pmsSetFunc_t pmsDfltFunc[pmsSetFuncMax];			/* List of functions for the external power control to use */

	for(i = 0; i < pmsSetFuncMax; i++) pmsDfltFunc[i] = NULL;	/* Clear this */


	ret = pmsBuild((pmsDef *)&pmsDefault, sizeof(pmsDefault), pmsDfltFunc, 0, (pmsQueryFunc_t)0);	/* Configure the default stepper */

	if(ret != KERN_SUCCESS) {							/* Some screw up? */
		panic("pmsCPUConf: initial stepper table build failed, ret = %08X\n", ret);	/* Squeal */
	}
	
	pmsSetStep(pmsHigh, 1);								/* Slew to high speed */
	pmsPark();											/* Then park */
	return;
}

/*
 * Machine-dependent initialization
 */
void
pmsCPUMachineInit(void)
{
	return;
}

/*
 *	This function should be called once for each processor to force the
 *	processor to the correct voltage and frequency.
 */
 
void pmsCPUInit(void) {

	int cpu;

	cpu = cpu_number();									/* Who are we? */
	
	kprintf("************ Initializing stepper hardware, cpu %d ******************\n", cpu);	/* (BRINGUP) */
	
	pmsSetStep(pmsHigh, 1);								/* Slew to high speed */
	pmsPark();											/* Then park */

	kprintf("************ Stepper hardware initialized, cpu %d ******************\n", cpu);	/* (BRINGUP) */
}

extern uint32_t hid1get(void);

uint32_t
pmsCPUQuery(void)
{
	uint32_t result;
	struct per_proc_info *pp;
	uint64_t scdata;

	pp = getPerProc();									/* Get our per_proc */

	switch(pp->pf.pfPowerModes & pmType) {				/* Figure out what type to do */
	
		case pmDFS:										/* This is a DFS machine */
			result = hid1get();							/* Get HID1 */
			result = (result >> 6) & 0x00030000;		/* Isolate the DFS bits */
			break;
			
		case pmPowerTune:								/* This is a PowerTune machine */		
			(void)ml_scom_read(PowerTuneStatusReg, &scdata);	/* Get the current power level */
			result = (scdata >> (32 + 8)) & 0x00030000;	/* Shift the data to align with the set command */
			break;
			
		default:										/* Query not supported for this kind */
			result = 0;									/* Return highest if not supported */
			break;
	
	}

	return result;
}

/*
 *	These are not implemented for PPC.
 */
void pmsCPUYellowFlag(void) {
}

void pmsCPUGreenFlag(void) {
}

uint32_t pmsCPUPackageQuery(void)
{
    	/* multi-core CPUs are not supported. */
    	return(~(uint32_t)0);
}

/*
 *	Broadcast a change to all processors including ourselves.
 *	This must transition before broadcasting because we may block and end up on a different processor.
 *
 *	This will block until all processors have transitioned, so
 *	obviously, this can block.
 *
 *	Called with interruptions disabled.
 *
 */
 
void pmsCPURun(uint32_t nstep) {

	pmsRunLocal(nstep);								/* If we aren't parking (we are already parked), transition ourselves */
	(void)cpu_broadcast(&pmsBroadcastWait, pmsCPURemote, nstep);	/* Tell everyone else to do it too */

	return;
	
}

/*
 *	Receive a broadcast and react.
 *	This is called from the interprocessor signal handler.
 *	We wake up the initiator after we are finished.
 *
 */
	
static void pmsCPURemote(uint32_t nstep) {

	pmsRunLocal(nstep);								/* Go set the step */
	if(!hw_atomic_sub(&pmsBroadcastWait, 1)) {		/* Drop the wait count */
		thread_wakeup((event_t)&pmsBroadcastWait);	/* If we were the last, wake up the signaller */
	}
	return;
}	

/*
 *	Control the Power Management Stepper.
 *	Called from user state by the superuser via a ppc system call.
 *	Interruptions disabled.
 *
 */
int pmsCntrl(struct savearea *save) {
	save->save_r3 = pmsControl(save->save_r3, (user_addr_t)(uintptr_t)save->save_r4, save->save_r5);
	return 1;
}