pwrctrl.c

基于一款32位嵌入式微处理器的USB接口的测试代码

/**********************************************************************
 *  Copyright (C) Asic Center. 2001
 *  All Rights Reserved
 *
 *  Filename : pwrctrl.c
 *  Function : power control
 *  Revision :
 *          2002/06/17     Pessia     Create this file;
 ***********************************************************************/
#if 0
#include <hardware\drball\M68328.h>
#include <kernel\ros33\ros33.h>
#include <sys\pwrctrl.h>
#endif

//gfd
#include "M68328.h"
#include "ros33.h"
#include "pwrctrl.h"
#define TIME_FOR_DOZE	100	/* 3 seconds */
#define TIME_FOR_SLEEP	1000	/* 30 seconds */

#ifndef PCTLR
#define PCTLR *((unsigned char *)0xFFFFF207 )	/* Power Control Register */
#endif
#ifndef PLLCR
#define PLLCR *((unsigned short *)0xFFFFF200 )	/* PLL Control Register */
#endif

extern UH g_uhIntTime;     // interrupt time

ULONG power_saving_counter;
UINT power_saving_flag=POWER_SAVING_DISABLE;	/*disable at reset */
UINT cur_pcs=PCS_NORMAL;

STATIC void set_pcs_doze( void );
STATIC void set_pcs_sleep( void );
STATIC void set_pcs_normal( void );

void init_pwrctrl( void ){
	power_saving_counter = 0;
	power_saving_flag=POWER_SAVING_DISABLE;
	cur_pcs=PCS_NORMAL;
}

STATIC void set_pcs_doze( void ){
	register UINT old_imr;
	
	/*************************************************************\
	 *  DISPATCH FORBIDDEN
	\*************************************************************/
	dis_dsp();
	
	/* Mask all interrupts */
	old_imr = IMR;
	IMR = 0xFFFFFFFF;
	
	/* RTC takes place of GPT and calls sys_clk() to make kernel-timer run. */
	power_saving_flag = POWER_SAVING_ENABLE;
	/* change sys_clk()'s tick */
	g_uhIntTime = 32; /* 1000/RTC's frequence(32Hz) */
	
	cur_pcs = PCS_DOZE;/* set current power control status */

	/* Restore all interrupts except GPT which has been taken placed by RTC. */
	IMR &= ( old_imr |IMR_MTMR2 );

	/* If RTC interrupt happens here,  it will be back because dispatch has been
	  * disabled. So, system will still enter DOZE-MODE, even if some higher-priority
	  * tasks are ready. These tasks will be scheduled while RTC interrupt happens
	  * next time. */
	
	/* Enter Doze-Mode */
	PCTLR = 0x00; /* clear WIDTH */
	PCTLR |= 0x80; /* enable Power Control */

	/* CPU halt! */
	/* .............  */

	ena_dsp();
	/*************************************************************\
	 *  DISPATCH OK
	\*************************************************************/
}

STATIC void set_pcs_sleep( void ){
	register UINT old_imr;
	extern void TurnOffLCD( void );
	
	/*************************************************************\
	 *  DISPATCH FORBIDDEN
	\*************************************************************/
	dis_dsp();
	
	/* Mask all interrupts */
	old_imr = IMR;
	IMR = 0xFFFFFFFF;

	cur_pcs = PCS_SLEEP;/* set current power control status */
	
	/* Turn off LCD. */
	//TurnOffLCD();//gfdmodified
	/* Change RTC's frequence to 1Hz. */
	//set_rtc( RTCIENR_1HZ );//gfdmodified
	/* change sys_clk()'s tick */
	g_uhIntTime = 1000;  /* 1000/RTC's frequence(1Hz) */
	
	/* Restore all interrupts */
	IMR &= ( ( old_imr |IMR_MTMR1 ) & ( ~IMR_MRTC ) );

	/* Close PLL */
	PLLCR |= 0x0008;
	//gfdmodified
	//asm("	STOP #$2000");
	
	/* CPU halt! */
	/* .............  */
	
	ena_dsp();
	/*************************************************************\
	 *  DISPATCH OK
	\*************************************************************/
}

STATIC void set_pcs_normal( void ){
	power_saving_flag = POWER_SAVING_DISABLE;
	cur_pcs = PCS_NORMAL;

	switch( cur_pcs ){
		case PCS_DOZE:
			/* change sys_clk()'s tick */
			g_uhIntTime = 100;
			/* Enable GPT interrupt */			
			IMR &= ~IMR_MTMR2;
			break;
			
		case PCS_SLEEP:
			/* change sys_clk()'s tick */
			g_uhIntTime = 100;
			/* Change RTC's frequence to 32Hz. */
			//set_rtc( RTCISR_SAM3 );
			//run_rtc();
			/* Enable GPT interrupt */
			IMR &= ~IMR_MTMR2;
			break;
			
		case PCS_IDLE:	
		case PCS_NORMAL:
		default:
			break;
		}
}

void set_pcs( UINT  status ){
	switch( status ){
		case PCS_IDLE:
			/* clear counter for power-saving, and enable counting */
			power_saving_counter = 0;
			power_saving_flag = POWER_SAVING_ENABLE;
			cur_pcs = status;
			break;
			
		case PCS_DOZE:
			set_pcs_doze();
			break;
			
		case PCS_SLEEP:
			set_pcs_sleep();
			break;
			
		case PCS_NORMAL:
			set_pcs_normal();
			break;
			
		default:
			break;
		}
	return;
}

UINT get_pcs( void ){
	return cur_pcs;
}

void idle_process( void ){
	while(1){
		switch( cur_pcs ){
			case PCS_NORMAL:
				set_pcs( PCS_IDLE );
				break;
				
			case PCS_IDLE:
				if( power_saving_counter > TIME_FOR_DOZE )
					set_pcs( PCS_DOZE );
				break;
				
			case PCS_DOZE:
				if( power_saving_counter > TIME_FOR_SLEEP )
					set_pcs( PCS_SLEEP );
				else
					set_pcs( PCS_DOZE );
				break;
				
			case PCS_SLEEP:
				set_pcs( PCS_SLEEP );
				break;
				
			default:
				break;
			}
		}
}