rtc.c

T－Kernel Driver Sample

/*""FILE COMMENT""*************************************************************
*       System Name : RENESAS T-Engine/micro T-Engine
*       File Name   : rtc.c
*       Version     : 1.00.00
*       Contents    : CLOCK device driver sysdepend routines
*       Model       : SH7145 micro T-Engine 
*       CPU         : SH7145F(SH-2) 
*       Compiler    : GNU
*       OS          : T-Kernel
*       note        : The Software is being delivered to you "AS IS" 
*                   : and Renesas,whether explicitly or implicitly makes  
*                   : no warranty as to its Use or performance. 
*                   : RENESAS AND ITS SUPPLIER DO NOT AND CANNOT WARRANT 
*                   : THE PERFORMANCE OR RESULTS YOU MAY OBTAIN  BY USING 
*                   : THE SOFTWARE. AS TO ANY MATTER INCLUDING WITHOUT 
*                   : LIMITATION NONINFRINGEMENT OF THIRD PARTY RIGHTS,
*                   : MERCHANTABILITY, INTEGRATION, SATISFACTORY QUALITY, 
*                   : OR FITNESS FOR ANY PARTICULAR PURPOSE.
*                     
*                     If H-UDI(e.g. E10A or MyICE) is connected,
*                     RTC device do not worked.
*                     (SCI2 and H-UDI are multiplexed)  
*
*       Copyright (c) 2005 RENESAS TECHNOLOGY CORP. All Rights Reserved.
*       AND RENESAS SOLUTIONS CORP. All Rights Reserved.
*       history   : 2005.01.21 ver1.00.00
*""FILE COMMENT END""*********************************************************/

#include "clkdrv.h"

/* Definition of SH7145 registers */
#define REG_RTCCEDATA  	(volatile unsigned short *)0xFFFF8380 /* PADRH */
#define REG_RTCCEMODE	(volatile unsigned short *)0xFFFF8384 /* PAIORH */
#define REG_RTCSCIMODE  (volatile unsigned short *)0xFFFF83B8 /* PECRL1 */
#define REG_RTCSCIMODE2	(volatile unsigned short *)0xFFFF83B4 /* PEIORL */

#define REG_RTCSCIMST	(volatile unsigned short *)0xFFFF861C /* MSTCR1 */

#define REG_RTCSMR      (volatile unsigned char *)0xFFFF81C0  /* SMR    */
#define REG_RTCBRR      (volatile unsigned char *)0xFFFF81C1  /* BRR    */
#define REG_RTCSCR      (volatile unsigned char *)0xFFFF81C2  /* SCR    */
#define REG_RTCTXD      (volatile unsigned char *)0xFFFF81C3  /* TXD    */
#define REG_RTCSSR      (volatile unsigned char *)0xFFFF81C4  /* SSR    */
#define REG_RTCRXD      (volatile unsigned char *)0xFFFF81C5  /* RXD    */
#define REG_RTCSDCR     (volatile unsigned char *)0xFFFF81C6  /* SDCR   */

/* Definition of the RTC controller */
/* register address */
#define REG_SEC          0x00
#define REG_MIN          0x10
#define REG_HOUR         0x20
#define REG_WEEK         0x30
#define REG_DAY          0x40
#define REG_MONTH        0x50
#define REG_YEAR         0x60
#define REG_ADJ          0x70
#define REG_ALARM_W_MIN  0x80
#define REG_ALARM_W_HOUR 0x90
#define REG_ALARM_W_WEEK 0xA0
#define REG_ALARM_D_MIN  0xB0
#define REG_ALARM_D_HOUR 0xC0
#define REG_CTRL1        0xE0
#define REG_CTRL2        0xF0

/* transfer format */
#define WRITE_RTC_1BYTE  0x08
#define READ_RTC_1BYTE   0x0C
#define WRITE_RTC_BURST  0x00
#define READ_RTC_BURST   0x04

/* Bit field for RTC register */
#define RTC_XSTP         0x10
#define RTC_VDET         0x40
#define RTC_Y2KBIT       0x80

/* SCI2 bps */
#define	RTC_DEFBPS	6	/* RTC max clock 1MHz */

/* convert BIN <-> BCD */
#define	BIN2BCD(v)	((((v) / 10) << 4) + ((v) % 10))
#define	BCD2BIN(v)	(((v) >> 4) * 10 + ((v) & 0x0f))

/* definition of local function */
LOCAL void rtcsciwait(int time);

/*""FUNC COMMENT""*******************************************************
 * ID          :
 * Outline     : write data to RV5C348B register
 *-----------------------------------------------------------------------
 * Include     : tk/tkernel.h 
 *-----------------------------------------------------------------------
 * Definition  : LOCAL void writeRTC(W idx, W data)
 *-----------------------------------------------------------------------
 * Function    : write data to RV5C348B register
 *-----------------------------------------------------------------------
 * Argument    : W idx; register index
 *             : W data; write data 
 *----------------------------------------------------------------------- 
 * Return      : None
 *-----------------------------------------------------------------------
 * Input       : None 
 * Output      : None 
 *-----------------------------------------------------------------------
 * Used Func   : None
 *-----------------------------------------------------------------------
 * Notice      : None
 *""FUNC COMMENT END""***************************************************/
LOCAL void writeRTC(W idx, W data) {
	unsigned char tendflg;

	*REG_RTCCEDATA = 1;                  /* set CE -> high  */
	rtcsciwait(1);                       /* setup [tCES]    */ 
	*REG_RTCSCR = 0x20;                  /* set TE bit      */
	while((*REG_RTCSSR & 0x80) == 0);    /* wait TDRE bit   */ 
	*REG_RTCTXD = idx | WRITE_RTC_1BYTE; /* send command    */
	*REG_RTCSSR = *REG_RTCSSR & ~0x80;   /* clear TDRE bit  */

	do {
		tendflg = *REG_RTCSSR;           /* wait TEND bit   */
	} while(!(tendflg & 0x04));

	while((*REG_RTCSSR & 0x80) == 0);    /* wait TDRE bit   */
	*REG_RTCTXD = data;                  /* send data       */
	*REG_RTCSSR = *REG_RTCSSR & ~0x80;   /* clear TDRE bit  */

	do {
		tendflg = *REG_RTCSSR;           /* wait TEND bit   */
	} while(!(tendflg & 0x04));

	*REG_RTCSCR = 0x00;                  /* clear TE bit    */ 
	*REG_RTCCEDATA = 0;                  /* set "CE" -> low */
}

/*""FUNC COMMENT""*******************************************************
 * ID          :
 * Outline     : read data from RTC(RV5C348)
 *-----------------------------------------------------------------------
 * Include     : tk/tkernel.h 
 *-----------------------------------------------------------------------
 * Definition  : LOCAL INT readRTC(W idx)
 *-----------------------------------------------------------------------
 * Function    : read data from RV5C348B
 *-----------------------------------------------------------------------
 * Argument    : W idx; register index
 *             : W data; write data 
 *----------------------------------------------------------------------- 
 * Return      : None
 *-----------------------------------------------------------------------
 * Input       : None 
 * Output      : None 
 *-----------------------------------------------------------------------
 * Used Func   : None
 *-----------------------------------------------------------------------
 * Notice      : None
 *""FUNC COMMENT END""***************************************************/
int errflg;
LOCAL INT readRTC(W idx)
{
	unsigned char data,sci_flg,tendflg;

	*REG_RTCCEDATA = 1;                  /* set "CE" -> high */

	*REG_RTCSCR = 0x20;                  /* set RE bit       */

	while((*REG_RTCSSR & 0x80) == 0);    /* wait TDRE bit    */
	*REG_RTCTXD = idx|READ_RTC_1BYTE;    /* send command     */
	*REG_RTCSSR = *REG_RTCSSR & ~0x80;   /* clear TDRE bit   */ 

	do {
		tendflg = *REG_RTCSSR;           /* wait TEND bit    */
	} while(!(tendflg & 0x04));

	*REG_RTCSCR = 0x10;                  /* set RE bit       */

	do {
		sci_flg = *REG_RTCSSR;           /* wait RDRF bit    */
	} while(!(sci_flg & 0x40));

	data = *REG_RTCRXD & 0xFF;           /* receive data     */
	*REG_RTCSSR = sci_flg & ~0x40;       /* clear RDRF bit   */
	*REG_RTCSCR = 0x00;                  /* clear TE,RE bit  */

	*REG_RTCCEDATA = 0;                  /* set "CE" -> low  */

	return(data);
}

/*""FUNC COMMENT""*******************************************************
 * ID          :
 * Outline     : set current time to RTC
 *-----------------------------------------------------------------------
 * Include     : tk/tkernel.h 
 *-----------------------------------------------------------------------
 * Definition  : ER	setRTCTIME(VP date_tim)
 *-----------------------------------------------------------------------
 * Function    : set current time to RTC
 *-----------------------------------------------------------------------
 * Argument    : VP date_time
 *----------------------------------------------------------------------- 
 * Return      : None
 *-----------------------------------------------------------------------
 * Input       : None 
 * Output      : None 
 *-----------------------------------------------------------------------
 * Used Func   : writeRTC()
 *-----------------------------------------------------------------------
 * Notice      : None
 *""FUNC COMMENT END""***************************************************/
EXPORT	ER	setRTCTIME(VP date_time) {
	int         year;
	UB          y2kflg;
	DATE_TIM	*dt;

	dt = (DATE_TIM *)date_time;

	if(dt->d_year>=100) {
		year = dt->d_year - 100;
		y2kflg = RTC_Y2KBIT;
	} else {
		year = dt->d_year;
		y2kflg = 0;
	}

	/* convert BIN to BCD code */
	year = BIN2BCD(year);	
	dt->d_month = BIN2BCD(dt->d_month);	
	dt->d_day = BIN2BCD(dt->d_day);	
	dt->d_hour = BIN2BCD(dt->d_hour);	
	dt->d_min = BIN2BCD(dt->d_min);	
	dt->d_sec = BIN2BCD(dt->d_sec);	
	
	/* set date and time to RTC */
	writeRTC(REG_YEAR,  year);
	writeRTC(REG_MONTH, dt->d_month|y2kflg);
	writeRTC(REG_WEEK,  dt->d_wday);
	writeRTC(REG_HOUR,  dt->d_hour);
	writeRTC(REG_MIN,   dt->d_min);
	writeRTC(REG_SEC,   dt->d_sec);
	writeRTC(REG_DAY,   dt->d_day);
	
	return E_OK;
}

/*""FUNC COMMENT""*******************************************************
 * ID          :
 * Outline     : get current time from RTC
 *-----------------------------------------------------------------------
 * Include     : tk/tkernel.h 
 *-----------------------------------------------------------------------
 * Definition  : ER	getRTCTIME(VP date_tim)
 *-----------------------------------------------------------------------
 * Function    : get current time to RTC
 *-----------------------------------------------------------------------
 * Argument    : VP date_time
 *----------------------------------------------------------------------- 
 * Return      : None
 *-----------------------------------------------------------------------
 * Input       : None 
 * Output      : None 
 *-----------------------------------------------------------------------
 * Used Func   : readRTC()
 *-----------------------------------------------------------------------
 * Notice      : None
 *""FUNC COMMENT END""***************************************************/
EXPORT	ER	getRTCTIME(VP date_time)
{
	DATE_TIM	*dt;
	INT	sec;

	dt = (DATE_TIM *)date_time;

	/* get time from RTC */
	do {
		sec        = readRTC(REG_SEC);
		dt->d_year  = readRTC(REG_YEAR);
		dt->d_month = readRTC(REG_MONTH);
		dt->d_day   = readRTC(REG_DAY);
		dt->d_hour  = readRTC(REG_HOUR);
		dt->d_min   = readRTC(REG_MIN);
		dt->d_wday  = readRTC(REG_WEEK);
		dt->d_sec   = readRTC(REG_SEC);
	} while (sec != dt->d_sec);

	/* convert BCD to BIN */
	dt->d_year = BCD2BIN(dt->d_year);	
	if(dt->d_month & RTC_Y2KBIT) {
		dt->d_year += 100;
		dt->d_month &= ~RTC_Y2KBIT;
	}	
	dt->d_month = BCD2BIN(dt->d_month);	
	dt->d_day = BCD2BIN(dt->d_day);	
	dt->d_hour = BCD2BIN(dt->d_hour);	
	dt->d_min = BCD2BIN(dt->d_min);	
	dt->d_sec = BCD2BIN(dt->d_sec);	

	return E_OK;
}

/*""FUNC COMMENT""*******************************************************
 * ID          :
 * Outline     : initial setting for RTC
 *-----------------------------------------------------------------------
 * Include     : tk/tkernel.h 
 *-----------------------------------------------------------------------
 * Definition  : ER	initRTC()
 *-----------------------------------------------------------------------
 * Function    : initial setting for RTC 
 *-----------------------------------------------------------------------
 * Argument    : None
 *----------------------------------------------------------------------- 
 * Return      : None
 *-----------------------------------------------------------------------
 * Input       : None 
 * Output      : None 
 *-----------------------------------------------------------------------
 * Used Func   : rtcsciwait() 
 *             : readRTC()
 *             : writeRTC()
 *-----------------------------------------------------------------------
 * Notice      : IF USE RTC,Can not use H-UDI(e.g. E10A/MyICE) debugger
 *""FUNC COMMENT END""***************************************************/
EXPORT	ER	initRTC(void)
{
	int data;

	/* stand-by registers */
	*REG_RTCSCIMST	= *REG_RTCSCIMST & 0xFFFB; /* clear MSTP18(SCI2) */ 

	/* initialize SCI2 for RTC */
	*REG_RTCSCR = 0x01;              /* CKE1:0 = 1 => SCLK out */
	*REG_RTCSMR = 0x80;              /* clocked serial mode */
	*REG_RTCBRR = RTC_DEFBPS;        /* n=0,N=6 -> 0.9MHz */
	*REG_RTCSDCR = 0xFA;             /* MSB first */
	rtcsciwait(1);

	/* initialize ports */
	*REG_RTCCEMODE  = 0x0001;        /* PA16(CE) output */
	*REG_RTCCEDATA  = 0x0000;        /* low  output */
	*REG_RTCSCIMODE = 0x0022;        /* TXD2,SCK2 */
	*REG_RTCSCIMODE2 = 0x0100;       /* SCK2(PE8) output */

	/* get RTC initial status(backup or not?) */
	data = readRTC(REG_CTRL2);
	if(data&(RTC_XSTP|RTC_VDET)) {
		/* If RTC is not backuped,set initial control value */
		writeRTC(REG_CTRL1,0x30);    /* Alarm Off,24hour mode */
		writeRTC(REG_CTRL2,0x00);
	}

	return E_OK;
}

/*""FUNC COMMENT""*******************************************************
 * ID          :
 * Outline     : RTC wait 
 *-----------------------------------------------------------------------
 * Include     : tk/tkernel.h 
 *-----------------------------------------------------------------------
 * Definition  : ER	rtcsciwait()
 *-----------------------------------------------------------------------
 * Function    : RTC wait
 *-----------------------------------------------------------------------
 * Argument    : int time 
 *----------------------------------------------------------------------- 
 * Return      : None
 *-----------------------------------------------------------------------
 * Input       : None 
 * Output      : None 
 *-----------------------------------------------------------------------
 * Used Func   : None 
 *-----------------------------------------------------------------------
 * Notice      : None
 *""FUNC COMMENT END""***************************************************/
LOCAL void rtcsciwait(int time){
	volatile int i;

	for(i=0;i<time;i++);
}

/* Set/get Auto Power ON time(not supported) */
EXPORT	ER	setRTCAutoPWRON(VP date_tim) { return E_NOSPT;}
EXPORT	ER	getRTCAutoPWRON(VP date_tim) { return E_NOSPT;}

/* Set/get non volatile register */
EXPORT	INT	setRTCREGS(VP buf, INT size) { return E_NOSPT;}
EXPORT	INT	getRTCREGS(VP buf, INT size) { return E_NOSPT;}