pmu.c

Embeded bootloader (rrload by ridgerun) for TI linux based platform v5.36

/***************************************************************************/
/* 																		   */
/*			         	pmu.c 											   */
/*     Description : Power by PMU(PCF50606 Phillips)                       */
/*     Author : rha34([e-mail])                            */
/*     Date : 2004. 3. 22                                                  */
/*     Version : 0.1												       */
/* 																		   */
/***************************************************************************/

#include "pmpConfig.h"
#include "i2c.h"
#include "util.h"
#include "pmu.h"
#include "dm270-registers.h"

//=========== Definitions ==================
#define PMU_DEV_ADDR 0x10
#define I2C_SCL_GIO	 31
#define I2C_SDA_GIO	 32

#define MAIN_POWER_KEY		0x100	
#define REMOCON_POWER_KEY	 0x100

#define MAIN_POWER_BIT	0x1
#define REMOCON_POWER_BIT	0x2;
#define EEPROM_ADDR	0xa8
#define EEPROM_DATA_SUBADDR	27

#define REG *(unsigned short *)
#define KEEPACT_GIO		(1 << 13)

// For debugging messages
//#define DEBUG

#define RETRY_NUM	3
//=========  Variables  ====================


//========  Functions  =====================
unsigned char power_on_check(void){
	unsigned char ret = 0;
	unsigned char flag;
	unsigned short temp;

	//main power key direction Input
	temp = REG GIO_DIR0;
	temp |= MAIN_POWER_KEY;
	REG GIO_DIR0 = temp;

	//remocon power key direction Input
	temp = REG GIO_DIR1;
	temp |= (REMOCON_POWER_KEY>>16);
	REG GIO_DIR1 = temp;

	//check whether one of these keys are pressed....
	temp = REG GIO_BITSET0;
	if(temp & MAIN_POWER_KEY){
//		util_printf("main key pressed..\n");
		ret |= MAIN_POWER_BIT; //Power on by main key
	}

	temp = REG GIO_BITSET1;
	if(temp & REMOCON_POWER_KEY){
//		util_printf("remocon key pressed..\n");
		ret |= REMOCON_POWER_BIT; //Power on by remocon key
	}

//	if(ret){
		I2C_init(I2C_SCL_GIO, I2C_SDA_GIO);
		I2C_writeReg(EEPROM_ADDR,EEPROM_DATA_SUBADDR,ret, &flag);
//	}
		
	return(ret);
}

unsigned char pmu_write_reg(unsigned char subaddr, unsigned char data){
	unsigned char flag;
	int writeRepeat;

	writeRepeat = 0;
	do{
		I2C_writeReg(PMU_DEV_ADDR,subaddr,data, &flag);
		writeRepeat++;
	}while(flag == I2C_ERROR && writeRepeat < RETRY_NUM);

	if(flag){
		util_printf("I2C write Error..\n");
		util_printf("addr : %x, data : %x\n",subaddr,data);
	}
	return(flag);
}

unsigned char pmu_read_reg(unsigned char subaddr, unsigned char *value){
	unsigned char flag;
	int rcvRepeat;

	rcvRepeat = 0;
	do{
		*value = I2C_readReg(PMU_DEV_ADDR, subaddr, &flag);
		rcvRepeat++;
	}while(flag == I2C_ERROR && rcvRepeat < RETRY_NUM);

	if(flag){
		util_printf("I2C read Error...\n");
		util_printf("addr : %x, data : %x\n",subaddr,value);
	}
	return(flag);
}

void quit_discharge(void){
	I2C_init(I2C_SCL_GIO, I2C_SDA_GIO);
	pmu_write_reg(GPOC5,0x7); //quick discharge current...
}

void pmu_BootInit(void){
	unsigned char flag;
	unsigned char temp;

//	I2C_init(I2C_SCL_GIO, I2C_SDA_GIO);

//	pmu_write_reg(GPOC5,0x7); //quick discharge current...

	flag = pmu_write_reg(DCDC1,0xf8);  //DCDC1 1.5V set.
	flag = pmu_write_reg(GPOC3,0x7); //GPO3 constant low --> FET open

	flag = pmu_write_reg(D1REGC1, 0x6); //D1REGC1阑 power off
 
	flag = pmu_write_reg(DCUDC1, 0xe3); //DCUDDC1俊 1.8V set
 
	//Added 040731
	flag = pmu_write_reg(DCUDC2,0x00);

	flag = pmu_write_reg(GPOC4, 0x7); //GPOC4甫 low active --> FFT open

	
//=================  Added 04.07.02  ======================
#if defined (PMP100_PP0)
	flag = pmu_write_reg(GPOC1, 0x77); //USB_RST 'H', HOST_PW_EN 'H'
#elif defined (PMP100_MP0)
	flag = pmu_write_reg(GPOC1,0x00); //SP_SHDN 'L', USB_CHG_EN 'L'
#endif

	flag = pmu_write_reg(GPOC2,0x07); //LCD_PW_B 'Z'
	//=====  Added 04.03.26 for USB  ===============
	flag = pmu_write_reg(D2REGC1, 0xf8); //USB device power
 
	flag = pmu_write_reg(D3REGC1, 0xf0); //USB device power

	//==========  End of 04.03.26  ==================== 

	//==========  Added 04.05.12 for ES2  ===============

	flag = pmu_write_reg(BBCC, 0x1f); 	// back up battery chargin enable STDBY,ACTIVE.
										// 400uA, 3.0V

	flag = pmu_write_reg(MBCC1, 0x1c); 	// charge mode idle

	flag = pmu_write_reg(LPREGC2, 0x0);	//LPREG1 off.
	

	//==========  Added 04.03.27  ===============
//	pmu_write_reg(INT1M,0x48,&flag); //Mask the SECOND interrupt.
	//Modified By Lee 04.03.30 for mask ON KEYF interrupt
	flag = pmu_write_reg(INT1M,0x4a); //Mask the SECOND interrupt.

#if defined(NOT_WAKEUP_BY_CHARGER)
	//===========  Added 04.03.30  ==============
	flag = pmu_write_reg(INT2M,0xff); //Mask the all interrupts by charger.

	//Modified 04.05.12 for ES2
	flag = pmu_write_reg(INT3M,0x09); //040805 mask adc ready int.
//	flag = pmu_write_reg(INT3M,0x0e); //Mask the all about accessory & touch screen interrupt.

	//Modified 04.05.12 for ES2
	flag = pmu_write_reg(OOCC1,0x0); //Mask the all wake up by something.
//	flag = pmu_write_reg(OOCC1,0x44); //Mask the wake up by charger interrupt.
#endif 

	//Added 040802
	flag = pmu_write_reg(OOCC2, 0x05);
	flag = pmu_write_reg(PSSC, 0xEF);
	flag = pmu_write_reg(PWROKM,0x00);
	flag = pmu_write_reg(DCDC2, 0xf9);
	flag = pmu_write_reg(DCDC3, 0x00);
	flag = pmu_write_reg(DCDEC1,0x08);
	flag = pmu_write_reg(DCDEC2,0xf9);
//	flag = pmu_write_reg(IOREGC,0xf4);
	flag = pmu_write_reg(IOREGC,0xf8);  //040806  default : 3.3V
	flag = pmu_write_reg(MBCC2,0x14);
	flag = pmu_write_reg(MBCC3,0x10);
	flag = pmu_write_reg(BVMC,0x0c);
	flag = pmu_write_reg(PWMC1,0x80);
	flag = pmu_write_reg(LEDC1,0x4d);
	flag = pmu_write_reg(LEDC2,0x4d);
        pmu_write_reg(ACDC1, 0x8c); //Accessory threshold voltage : 2.2V
        pmu_write_reg(LPREGC1,0xef); //LPVDD 2.4V, Active mode
                                                                                                         

	//Added 040726
        //PLD 1.8V supply check
        flag = pmu_read_reg(DCUDC1, &temp);
        if(flag != -1){
                if(temp != 0xE3){
                        pmu_write_reg(DCUDC1, 0xE3);
                }
        }
                                                                                                     
        //CPU core 1.5V supply check
        flag = pmu_read_reg(DCDC1,&temp);
        if(flag != -1){
                if(temp != 0xF8){
                        pmu_write_reg(DCDC1, 0xF8);
                }
        }
                                                                                                     

	return;
}

unsigned char read_irqPort(void){
	volatile unsigned char key_val;
	volatile unsigned short port;

	#if defined(PMP100_EVM)
		REG DIR0 |= (1 << 6);
	#else
		REG DIR0 |= (1 << 5);
	#endif

		port = REG BITSET0;	
	#if defined(PMP100_EVM)
		key_val = port & (1 << 6);
	#else
		key_val = port & (1 << 5);
	#endif

	return(key_val);
}

unsigned char pmu_OnkeyCheck(void){
	unsigned char flag,key_val;
	unsigned char temp;

		flag = pmu_read_reg(INT1,&key_val); //button ON KEY check.
	#if defined(DEBUG)
		util_printf("%x\n",key_val);
	#endif
		flag = pmu_read_reg(INT2,&temp);
	#if defined(DEBUG)
		util_printf("%x\n",temp);
	#endif
		flag = pmu_read_reg(INT3,&temp);
	#if defined(DEBUG)
		util_printf("%x\n",temp);
	#endif
	//Modified at 04.04.23..
//		if(key_val & 0x3)
		if((key_val & 0x3)||(key_val == 0x40))
			return(0);
		else
			return(1);
}

unsigned char detect_interrupt(void){
	unsigned char flag;
	unsigned char key_val;

	if(!read_irqPort()){
		flag = pmu_read_reg(INT1,&key_val); //Read INT1 Register.
		if((key_val & 0x3)){
		#if defined(DEBUG)
			util_printf("ONKEY DETECTED\n");
		#endif
			return ONKEY_DETECT;
		}
		if(key_val & 0x4){
		#if defined(DEBUG)
			util_printf("ONKEY1S DETECTED\n");
		#endif
			return ONKEY1S_DETECT;
		}
		if(key_val & 0x10){
		#if defined(DEBUG)
			util_printf("EXTONF DETECTED\n");
		#endif
			return EXTONF_DETECT;
		} 
		if(key_val & 0x80){
		#if defined(DEBUG)
			util_printf("ALARM DETECTED\n");
		#endif
			return ALARM_DETECT;
		}
	}

	if(!read_irqPort()){
		flag = pmu_read_reg(INT2,&key_val);
		if(key_val & 0x1){
		#if defined(DEBUG)
			util_printf("CHGINS DETECTED\n");
		#endif
			return(CHGINS_DETECT);
		}
		if(key_val & 0x2){
		#if defined(DEBUG)
			util_printf("CHGRM DETECTED\n");
		#endif
			return(CHGRM_DETECT);
		}
	}

	if(!read_irqPort()){
		flag = pmu_read_reg(INT3, &key_val);
		if(key_val & 0x1){
		#if defined(DEBUG)
			util_printf("ADCREADY DETECTED\n");
		#endif
			return(ADCREADY_DETECT);
		}
	}

	return(0);
		
}

void waitOnKey(void){
	unsigned char key_val;
  unsigned char ch = 0;

	while(1){
		if(!read_irqPort()){
			key_val = detect_interrupt();
			util_printf("check  %x\n",key_val);
			if(key_val == ONKEY_DETECT){
				pmu_OnkeyCheck();
				break;
			}
		}	

      	ch = io_getc(100); // look for a key for x msec.
      	if (ch > 0) break;
	}
}

void pmu_goStandBy(void){
	unsigned char key_val,flag;

	flag = pmu_read_reg(OOCC1,&key_val);
	key_val |= 0x01;
	pmu_write_reg(OOCC1,key_val); //go standBy 
}

void pmu_goFinalize(void){
	pmu_write_reg(GPOC4, 0x00);
	pmu_write_reg(D1REGC1, 0xE6);
	pmu_write_reg(GPOC3, 0x00);
	return;
}