static int sprd_rtc_read_alarm(struct device *dev,
struct rtc_wkalrm *alrm)
{
unsigned long secs = sprd_rtc_get_alarm_sec();
secs = secs + secs_start_year_to_1970;
rtc_time_to_tm(secs, &alrm->time);
alrm->enabled = !!(sci_adi_read(ANA_RTC_INT_EN) & RTC_ALARM_BIT);
alrm->pending = !!(sci_adi_read(ANA_RTC_INT_RSTS) & RTC_ALARM_BIT);
printk("rtc_alarm:alrm->enabled=%d,secs=%lu\n",alrm->enabled,secs);
return 0;
}
static void ktd259b_backlight_earlyresume(struct early_suspend *desc)
{
struct ktd259b_bl_data *ktd259b = container_of(desc, struct ktd259b_bl_data,
early_suspend_desc);
struct backlight_device *bl = platform_get_drvdata(ktd259b->pdev);
struct timespec ts;
struct rtc_time tm;
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
backlight_mode=BACKLIGHT_RESUME;
printk("[%02d:%02d:%02d.%03lu][BACKLIGHT] earlyresume\n", tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
backlight_update_status(bl);
}
static int coh901331_read_time(struct device *dev, struct rtc_time *tm)
{
struct coh901331_port *rtap = dev_get_drvdata(dev);
clk_enable(rtap->clk);
/* */
if (readl(rtap->virtbase + COH901331_VALID)) {
rtc_time_to_tm(readl(rtap->virtbase + COH901331_CUR_TIME), tm);
clk_disable(rtap->clk);
return rtc_valid_tm(tm);
}
clk_disable(rtap->clk);
return -EINVAL;
}
static int mv_rtc_read_time(struct rtc_time *tm)
{
MV_RTC_TIME time;
unsigned long temp_t;
mvRtcDS1339TimeGet(&time);
/* same as in the U-Boot we use the year for century 20 only */
temp_t = mktime ( time.year + 2000, time.month,
time.date, time.hours,
time.minutes, time.seconds);
rtc_time_to_tm(temp_t, tm);
return 0;
}
static void __init test_wakealarm(struct rtc_device *rtc, suspend_state_t state)
{
static char err_readtime[] __initdata =
KERN_ERR "PM: can't read %s time, err %d\n";
static char err_wakealarm [] __initdata =
KERN_ERR "PM: can't set %s wakealarm, err %d\n";
static char err_suspend[] __initdata =
KERN_ERR "PM: suspend test failed, error %d\n";
static char info_test[] __initdata =
KERN_INFO "PM: test RTC wakeup from '%s' suspend\n";
unsigned long now;
struct rtc_wkalrm alm;
int status;
status = rtc_read_time(rtc, &alm.time);
if (status < 0) {
printk(err_readtime, dev_name(&rtc->dev), status);
return;
}
rtc_tm_to_time(&alm.time, &now);
memset(&alm, 0, sizeof alm);
rtc_time_to_tm(now + TEST_SUSPEND_SECONDS, &alm.time);
alm.enabled = true;
status = rtc_set_alarm(rtc, &alm);
if (status < 0) {
printk(err_wakealarm, dev_name(&rtc->dev), status);
return;
}
if (state == PM_SUSPEND_MEM) {
printk(info_test, pm_states[state]);
status = pm_suspend(state);
if (status == -ENODEV)
state = PM_SUSPEND_STANDBY;
}
if (state == PM_SUSPEND_STANDBY) {
printk(info_test, pm_states[state]);
status = pm_suspend(state);
}
if (status < 0)
printk(err_suspend, status);
alm.enabled = false;
rtc_set_alarm(rtc, &alm);
}
static int pm8xxx_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
int rc;
u8 value[NUM_8_BIT_RTC_REGS], reg;
unsigned long secs;
struct pm8xxx_rtc *rtc_dd = dev_get_drvdata(dev);
rc = pm8xxx_read_wrapper(rtc_dd, value, rtc_dd->rtc_read_base,
NUM_8_BIT_RTC_REGS);
if (rc < 0) {
dev_err(dev, "RTC read data register failed\n");
return rc;
}
/*
* Read the LSB again and check if there has been a carry over.
* If there is, redo the read operation.
*/
rc = pm8xxx_read_wrapper(rtc_dd, ®, rtc_dd->rtc_read_base, 1);
if (rc < 0) {
dev_err(dev, "RTC read data register failed\n");
return rc;
}
if (unlikely(reg < value[0])) {
rc = pm8xxx_read_wrapper(rtc_dd, value,
rtc_dd->rtc_read_base, NUM_8_BIT_RTC_REGS);
if (rc < 0) {
dev_err(dev, "RTC read data register failed\n");
return rc;
}
}
secs = value[0] | (value[1] << 8) | (value[2] << 16) | (value[3] << 24);
rtc_time_to_tm(secs, tm);
rc = rtc_valid_tm(tm);
if (rc < 0) {
dev_err(dev, "Invalid time read from RTC\n");
return rc;
}
dev_dbg(dev, "secs = %lu, h:m:s == %d:%d:%d, d/m/y = %d/%d/%d\n",
secs, tm->tm_hour, tm->tm_min, tm->tm_sec,
tm->tm_mday, tm->tm_mon, tm->tm_year);
return 0;
}
/*
* omap_rtc_poweroff: RTC-controlled power off
*
* The RTC can be used to control an external PMIC via the pmic_power_en pin,
* which can be configured to transition to OFF on ALARM2 events.
*
* Notes:
* The two-second alarm offset is the shortest offset possible as the alarm
* registers must be set before the next timer update and the offset
* calculation is too heavy for everything to be done within a single access
* period (~15 us).
*
* Called with local interrupts disabled.
*/
static void omap_rtc_power_off(void)
{
struct omap_rtc *rtc = omap_rtc_power_off_rtc;
struct rtc_time tm;
unsigned long now;
u32 val;
rtc->type->unlock(rtc);
/* enable pmic_power_en control */
val = rtc_readl(rtc, OMAP_RTC_PMIC_REG);
rtc_writel(rtc, OMAP_RTC_PMIC_REG, val | OMAP_RTC_PMIC_POWER_EN_EN);
/* set alarm two seconds from now */
omap_rtc_read_time_raw(rtc, &tm);
bcd2tm(&tm);
rtc_tm_to_time(&tm, &now);
rtc_time_to_tm(now + 2, &tm);
if (tm2bcd(&tm) < 0) {
dev_err(&rtc->rtc->dev, "power off failed\n");
return;
}
rtc_wait_not_busy(rtc);
rtc_write(rtc, OMAP_RTC_ALARM2_SECONDS_REG, tm.tm_sec);
rtc_write(rtc, OMAP_RTC_ALARM2_MINUTES_REG, tm.tm_min);
rtc_write(rtc, OMAP_RTC_ALARM2_HOURS_REG, tm.tm_hour);
rtc_write(rtc, OMAP_RTC_ALARM2_DAYS_REG, tm.tm_mday);
rtc_write(rtc, OMAP_RTC_ALARM2_MONTHS_REG, tm.tm_mon);
rtc_write(rtc, OMAP_RTC_ALARM2_YEARS_REG, tm.tm_year);
/*
* enable ALARM2 interrupt
*
* NOTE: this fails on AM3352 if rtc_write (writeb) is used
*/
val = rtc_read(rtc, OMAP_RTC_INTERRUPTS_REG);
rtc_writel(rtc, OMAP_RTC_INTERRUPTS_REG,
val | OMAP_RTC_INTERRUPTS_IT_ALARM2);
rtc->type->lock(rtc);
/*
* Wait for alarm to trigger (within two seconds) and external PMIC to
* power off the system. Add a 500 ms margin for external latencies
* (e.g. debounce circuits).
*/
mdelay(2500);
}
static ssize_t eemcs_sysfs_show_statistics(struct device *dev, struct device_attribute *attr, char *buf)
{
int i = 0;
char line[121]={0};
char c_time_string[30]={0};
int pos = 0;
struct timeval tv;
struct rtc_time tm;
struct rtc_time tm_now;
do_gettimeofday(&tv);
rtc_time_to_tm(tv.tv_sec,&tm_now);
rtc_time_to_tm(eemcs_statistics[0]->time.tv_sec,&tm);
sprintf(c_time_string,"%04d-%02d-%02d_%02d:%02d:%02d ~ %02d:%02d - %d sec",
tm.tm_year+1900,tm.tm_mon+1, tm.tm_mday,tm.tm_hour,tm.tm_min,tm.tm_sec,
tm_now.tm_min,tm_now.tm_sec,
(unsigned int)(tv.tv_sec - eemcs_statistics[0]->time.tv_sec));
pos += sprintf(buf+pos, "Record Time: %s\n", c_time_string);
pos += sprintf(buf+pos, "%15s | %7s | %7s | %9s | %8s | %8s | %7s | %7s |\n",
"CCCI PORT", "TX CNT", "RX CNT", "RX Q(MAX)", "TX TOTAL", "RX TOTAL", "TX DROP", "RX DROP");
memset(line, '=', 91);
pos += sprintf(buf+pos, "%s\n", line);
for (i=0; i< CCCI_PORT_NUM_MAX; i++){
CCCI_PORT_STATISTICS *port = &eemcs_statistics[0]->port[i];
CCCI_PORT_STATISTICS *port_total = &eemcs_statistics[0]->port_total[i];
pos += sprintf(buf+pos, "%15s | %7d | %7d | %3d(%4d) | %8d | %8d | %7d | %7d |\n",
ccci_port_name[i], port->cnt[TX], port->cnt[RX],
port->queue[RX], port_total->queue[RX],
port_total->cnt[TX], port_total->cnt[RX],
port_total->drop[TX], port_total->drop[RX]
);
}
return pos;
}
/**
* balong_rtc_readalarm-read rtc alarm
*/
s32 balong_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alarm)
{
rtc_time_to_tm(readl(g_rtc_ctrl.rtc_base_addr + HI_RTC_CMR_OFFSET), &alarm->time);
alarm->pending = readl(g_rtc_ctrl.rtc_base_addr + HI_RTC_CCR_OFFSET) & RTC_BIT_AI;
if(readl(g_rtc_ctrl.rtc_base_addr + HI_RTC_CCR_OFFSET)&RTC_BIT_IM)
{
alarm->enabled = ALARM_DISABLED;
}
else
{
alarm->enabled = ALARM_ENABLE;
}
return BSP_OK;
}
int alarm_set_rtc_ring(struct timespec alarm_time)
{
struct rtc_wkalrm rtc_alarm;
unsigned long rtc_alarm_time;
if (pwr_rtc_dev != NULL) {
rtc_alarm_time = alarm_time.tv_sec;
pr_alarm(INT, "%s, alarm time: %lu\n",
__func__, rtc_alarm_time);
rtc_time_to_tm(rtc_alarm_time, &rtc_alarm.time);
rtc_alarm.enabled = 1;
rtc_set_alarm(pwr_rtc_dev, &rtc_alarm);
}
return 0;
}
static int puv3_rtc_getalarm(struct device *dev, struct rtc_wkalrm *alrm)
{
struct rtc_time *alm_tm = &alrm->time;
rtc_time_to_tm(readl(RTC_RTAR), alm_tm);
alrm->enabled = readl(RTC_RTSR) & RTC_RTSR_ALE;
pr_debug("read alarm %02x %02x.%02x.%02x %02x/%02x/%02x\n",
alrm->enabled,
alm_tm->tm_year, alm_tm->tm_mon, alm_tm->tm_mday,
alm_tm->tm_hour, alm_tm->tm_min, alm_tm->tm_sec);
return 0;
}
static int lpc32xx_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
{
unsigned long alarmsecs;
struct rtc_time *time = &wkalrm->time;
struct platform_device *pdev = to_platform_device(dev);
struct lpc32xx_rtc_priv *lpc32xx_rtc_dat = platform_get_drvdata(pdev);
/* Read alarm match register */
alarmsecs = __raw_readl(RTC_MATCH0(lpc32xx_rtc_dat->rtc_base));
wkalrm->enabled = lpc32xx_rtc_dat->alarm_enabled;
rtc_time_to_tm(alarmsecs, time);
return 0;
}
static int tegra_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
NvU32 now;
if (hPmu == NULL)
return -1;
if (!NvOdmPmuReadRtc(hPmu, &now)) {
printk("NvOdmPmuReadRtc failed\n");
return -1;
}
rtc_time_to_tm(now, tm);
return 0;
}
static void aat1401_backlight_earlysuspend(struct early_suspend *desc)
{
struct aat1401_bl_data *aat1401 = container_of(desc, struct aat1401_bl_data,
early_suspend_desc);
struct backlight_device *bl = platform_get_drvdata(aat1401->pdev);
struct timespec ts;
struct rtc_time tm;
backlight_mode=BACKLIGHT_SUSPEND;
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
printk("[%02d:%02d:%02d.%03lu][BACKLIGHT] earlysuspend\n", tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
}
static int ls1x_rtc_read_time(struct device *dev, struct rtc_time *rtm)
{
unsigned long v, t;
v = readl(SYS_TOYREAD0);
t = readl(SYS_TOYREAD1);
memset(rtm, 0, sizeof(struct rtc_time));
t = mktime((t & LS1X_YEAR_MASK), ls1x_get_month(v),
ls1x_get_day(v), ls1x_get_hour(v),
ls1x_get_min(v), ls1x_get_sec(v));
rtc_time_to_tm(t, rtm);
return 0;
}
static int
r2113s_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
struct spi_device *spi = to_spi_device(dev);
struct r2113s_plat_data *pdata = spi->dev.platform_data;
u8 txbuf[5], rxbuf[7];
int ret;
/* Transfer 5 byte befores reading SEC. This gives 31us for carry. */
txbuf[0] = R2113S_CMD_R(R2113S_REG_CTL2); /* cmd, ctl2 */
txbuf[1] = 0xff; /* dummy */
txbuf[2] = R2113S_CMD_R(R2113S_REG_CTL2); /* cmd, ctl2 */
txbuf[3] = 0xff; /* dummy */
txbuf[4] = R2113S_CMD_MR(R2113S_REG_SECS); /* cmd, sec, ... */
memset(rxbuf,0xff,sizeof(rxbuf));
/* read in one transfer to avoid data inconsistency */
ret = spi_write_then_read(spi, txbuf, sizeof(txbuf),
rxbuf, sizeof(rxbuf));
udelay(62); /* Tcsr 62us */
if (ret < 0)
return ret;
tm->tm_sec = BCD2BIN(rxbuf[R2113S_REG_SECS] & R2113S_SECS_MASK);
tm->tm_min = BCD2BIN(rxbuf[R2113S_REG_MINS] & R2113S_MINS_MASK);
if (pdata->rtc_24h) {
tm->tm_hour = BCD2BIN(rxbuf[R2113S_REG_HOURS] & R2113S_HOURS_MASK);
} else {
tm->tm_hour = BCD2BIN((rxbuf[R2113S_REG_HOURS] & R2113S_HOURS_MASK)&~R2113S_BIT_PM);
tm->tm_hour %= 12;
if (rxbuf[R2113S_REG_HOURS] & R2113S_BIT_PM)
tm->tm_hour += 12;
}
tm->tm_wday = BCD2BIN(rxbuf[R2113S_REG_WDAY] & R2113S_WDAY_MASK);
tm->tm_mday = BCD2BIN(rxbuf[R2113S_REG_DAY] & R2113S_DAY_MASK);
tm->tm_mon =
BCD2BIN(rxbuf[R2113S_REG_MONTH] & R2113S_MONTH_MASK) - 1;
/* year is 1900 + tm->tm_year */
tm->tm_year = BCD2BIN(rxbuf[R2113S_REG_YEAR]) +
((rxbuf[R2113S_REG_MONTH] & R2113S_BIT_Y2K) ? 100 : 0);
if (rtc_valid_tm(tm) < 0) {
dev_err(&spi->dev, "retrieved date/time is not valid.\n");
rtc_time_to_tm(0, tm);
}
return 0;
}
static int set_wakealarm(void)
{
int retval = 0;
unsigned long now, alarm;
struct rtc_wkalrm alm;
struct rtc_device *rtc;
rtc = rtc_class_open(CONFIG_WAKEALARM_RTC);
if (!rtc) {
return -1;
}
/* Only request alarms that trigger in the future. Disable them
* by writing another time, e.g. 0 meaning Jan 1 1970 UTC.
*/
retval = rtc_read_time(rtc, &alm.time);
if (retval < 0)
goto close_rtc;
rtc_tm_to_time(&alm.time, &now);
alarm = now + sleep_time;
if (alarm > now) {
/* Avoid accidentally clobbering active alarms; we can't
* entirely prevent that here, without even the minimal
* locking from the /dev/rtcN api.
*/
retval = rtc_read_alarm(rtc, &alm);
if (retval < 0)
goto close_rtc;
alm.enabled = 1;
} else {
alm.enabled = 0;
/* Provide a valid future alarm time. Linux isn't EFI,
* this time won't be ignored when disabling the alarm.
*/
alarm = now + 300;
}
rtc_time_to_tm(alarm, &alm.time);
retval = rtc_set_alarm(rtc, &alm);
close_rtc:
rtc_class_close(rtc);
return retval;
}
static int
rs5c348_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
struct spi_device *spi = to_spi_device(dev);
struct rs5c348_plat_data *pdata = dev_get_platdata(&spi->dev);
u8 txbuf[5], rxbuf[7];
int ret;
/* Transfer 5 byte befores reading SEC. This gives 31us for carry. */
txbuf[0] = RS5C348_CMD_R(RS5C348_REG_CTL2); /* cmd, ctl2 */
txbuf[1] = 0; /* dummy */
txbuf[2] = RS5C348_CMD_R(RS5C348_REG_CTL2); /* cmd, ctl2 */
txbuf[3] = 0; /* dummy */
txbuf[4] = RS5C348_CMD_MR(RS5C348_REG_SECS); /* cmd, sec, ... */
/* read in one transfer to avoid data inconsistency */
ret = spi_write_then_read(spi, txbuf, sizeof(txbuf),
rxbuf, sizeof(rxbuf));
udelay(62); /* Tcsr 62us */
if (ret < 0)
return ret;
tm->tm_sec = bcd2bin(rxbuf[RS5C348_REG_SECS] & RS5C348_SECS_MASK);
tm->tm_min = bcd2bin(rxbuf[RS5C348_REG_MINS] & RS5C348_MINS_MASK);
tm->tm_hour = bcd2bin(rxbuf[RS5C348_REG_HOURS] & RS5C348_HOURS_MASK);
if (!pdata->rtc_24h) {
if (rxbuf[RS5C348_REG_HOURS] & RS5C348_BIT_PM) {
tm->tm_hour -= 20;
tm->tm_hour %= 12;
tm->tm_hour += 12;
} else
tm->tm_hour %= 12;
}
tm->tm_wday = bcd2bin(rxbuf[RS5C348_REG_WDAY] & RS5C348_WDAY_MASK);
tm->tm_mday = bcd2bin(rxbuf[RS5C348_REG_DAY] & RS5C348_DAY_MASK);
tm->tm_mon =
bcd2bin(rxbuf[RS5C348_REG_MONTH] & RS5C348_MONTH_MASK) - 1;
/* year is 1900 + tm->tm_year */
tm->tm_year = bcd2bin(rxbuf[RS5C348_REG_YEAR]) +
((rxbuf[RS5C348_REG_MONTH] & RS5C348_BIT_Y2K) ? 100 : 0);
if (rtc_valid_tm(tm) < 0) {
dev_err(&spi->dev, "retrieved date/time is not valid.\n");
rtc_time_to_tm(0, tm);
}
return 0;
}
static int davinci_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
{
struct davinci_rtc *davinci_rtc = dev_get_drvdata(dev);
unsigned long flags;
u16 days;
if (alm->time.tm_mday <= 0 && alm->time.tm_mon < 0
&& alm->time.tm_year < 0) {
struct rtc_time tm;
unsigned long now, then;
davinci_rtc_read_time(dev, &tm);
rtc_tm_to_time(&tm, &now);
alm->time.tm_mday = tm.tm_mday;
alm->time.tm_mon = tm.tm_mon;
alm->time.tm_year = tm.tm_year;
rtc_tm_to_time(&alm->time, &then);
if (then < now) {
rtc_time_to_tm(now + 24 * 60 * 60, &tm);
alm->time.tm_mday = tm.tm_mday;
alm->time.tm_mon = tm.tm_mon;
alm->time.tm_year = tm.tm_year;
}
}
if (convert2days(&days, &alm->time) < 0)
return -EINVAL;
spin_lock_irqsave(&davinci_rtc_lock, flags);
davinci_rtcss_calendar_wait(davinci_rtc);
rtcss_write(davinci_rtc, bin2bcd(alm->time.tm_min), PRTCSS_RTC_AMIN);
davinci_rtcss_calendar_wait(davinci_rtc);
rtcss_write(davinci_rtc, bin2bcd(alm->time.tm_hour), PRTCSS_RTC_AHOUR);
davinci_rtcss_calendar_wait(davinci_rtc);
rtcss_write(davinci_rtc, days & 0xFF, PRTCSS_RTC_ADAY0);
davinci_rtcss_calendar_wait(davinci_rtc);
rtcss_write(davinci_rtc, (days & 0xFF00) >> 8, PRTCSS_RTC_ADAY1);
spin_unlock_irqrestore(&davinci_rtc_lock, flags);
return 0;
}
/*------------------------------------------------------------------------------
* RTC OPS
*/
static int nx_rtc_ops_read_time(struct device *dev, struct rtc_time *tm)
{
unsigned long rtc;
spin_lock_irq(&rtc_lock);
rtc = NX_RTC_GetRTCCounter();
rtc_time_to_tm(rtc + rtc_time_offs, tm);
DBGOUT("read time %04d.%02d.%02d %02d/%02d/%02d, rtc 0x%x\n",
tm->tm_year, tm->tm_mon, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec, (u_int)rtc);
spin_unlock_irq(&rtc_lock);
return 0;
}
static int datetime_proc_show(struct seq_file *m, void *v)
{
struct timeval time;
unsigned long local_time;
struct rtc_time tm;
do_gettimeofday(&time);
local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60));
rtc_time_to_tm(local_time, &tm);
seq_printf(m, "%04d.%02d.%02d %02d:%02d:%02d\n",
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec);
return 0;
}
static int pcap_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
struct pcap_rtc *pcap_rtc = dev_get_drvdata(dev);
unsigned long secs;
u32 tod, days;
ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_TOD, &tod);
secs = tod & PCAP_RTC_TOD_MASK;
ezx_pcap_read(pcap_rtc->pcap, PCAP_REG_RTC_DAY, &days);
secs += (days & PCAP_RTC_DAY_MASK) * SEC_PER_DAY;
rtc_time_to_tm(secs, tm);
return 0;
}
static void audio_allow_sleep(struct audio *audio)
{
struct timespec ts;
struct rtc_time tm;
wake_unlock(&audio->wakelock);
wake_unlock(&audio->idlelock);
MM_DBG("\n"); /* Macro prints the file name and function */
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
pr_aud_info1("[ATS][stop_music][successful] at %lld \
(%d-%02d-%02d %02d:%02d:%02d.%09lu UTC)\n",
ktime_to_ns(ktime_get()),
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
pr_aud_info("------------------------------\n");
}
static ssize_t lge_logstart_store(struct kobject *kobj,
struct kobj_attribute *attr, const char *buf, size_t n)
{
struct timespec ts;
struct rtc_time tm;
printk("lge_logstart_store() invoked\n");
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
printk(KERN_UTC_START "%d-%02d-%02d %02d:%02d:%02d.%06lu\n",
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec/1000);
return n;
}
static int ls1x_rtc_read_time(struct device *dev, struct rtc_time *rtm)
{
unsigned long v;
v = readl(SYS_RTCREAD0);
rtc_time_to_tm(v, rtm);
dev_dbg(dev, "%s secs=%d, mins=%d, "
"hours=%d, mday=%d, mon=%d, year=%d\n",
"read", rtm->tm_sec, rtm->tm_min,
rtm->tm_hour, rtm->tm_mday,
rtm->tm_mon, rtm->tm_year);
return rtc_valid_tm(rtm);
}
static void ktd259b_backlight_earlysuspend(struct early_suspend *desc)
{
struct timespec ts;
struct rtc_time tm;
backlight_mode=BACKLIGHT_SUSPEND;
getnstimeofday(&ts);
rtc_time_to_tm(ts.tv_sec, &tm);
gpio_set_value(backlight_pwm,0);
gpio_set_value(backlight_pin,0);
real_level = 0;
printk("[%02d:%02d:%02d.%03lu][BACKLIGHT] earlysuspend\n", tm.tm_hour, tm.tm_min, tm.tm_sec, ts.tv_nsec);
}
static int dm355evm_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
union evm_time time;
int status;
int tries = 0;
do {
/*
* Read LSB(0) to MSB(3) bytes. Defend against the counter
* rolling over by re-reading until the value is stable,
* and assuming the four reads take at most a few seconds.
*/
status = dm355evm_msp_read(DM355EVM_MSP_RTC_0);
if (status < 0)
return status;
if (tries && time.bytes[0] == status)
break;
time.bytes[0] = status;
status = dm355evm_msp_read(DM355EVM_MSP_RTC_1);
if (status < 0)
return status;
if (tries && time.bytes[1] == status)
break;
time.bytes[1] = status;
status = dm355evm_msp_read(DM355EVM_MSP_RTC_2);
if (status < 0)
return status;
if (tries && time.bytes[2] == status)
break;
time.bytes[2] = status;
status = dm355evm_msp_read(DM355EVM_MSP_RTC_3);
if (status < 0)
return status;
if (tries && time.bytes[3] == status)
break;
time.bytes[3] = status;
} while (++tries < 5);
dev_dbg(dev, "read timestamp %08x\n", time.value);
rtc_time_to_tm(le32_to_cpu(time.value), tm);
return 0;
}
/**
* Prototype : ps_tty_receive
* Description : called by tty uart when recive data from tty uart
* input : tty -> have opened tty
* data -> recive data ptr
* count-> recive data count
* output : not
* Calls :
* Called By :
*
* History :
* 1.Date : 2012/11/05
* Author : wx144390
* Modification : Created function
*
*/
STATIC void ps_tty_receive(struct tty_struct *tty, const uint8 *data,
int8 *tty_flags, int32 count)
{
struct timeval tv;
struct rtc_time tm;
uint64 tmp;
char filename[60] = {0};
struct ps_core_s *ps_core_d = NULL;
PS_PRINT_FUNCTION_NAME;
if (unlikely((NULL == tty)||(NULL == tty->disc_data)||(NULL == tty_recv)))
{
PS_PRINT_ERR("tty or tty->disc_data or tty_recv is NULL\n");
return;
}
ps_core_d = tty->disc_data;
spin_lock(&ps_core_d->rx_lock);
if(g_uart_rx_dump)
{
ps_core_d->curr_time = jiffies;
tmp = ps_core_d->curr_time - ps_core_d->pre_time;
if ((tmp > DBG_FILE_TIME * HZ)||(0 == ps_core_d->pre_time))
{
if (NULL != ps_core_d->rx_data_fp)
{
filp_close(ps_core_d->rx_data_fp, NULL);
}
do_gettimeofday(&tv);
rtc_time_to_tm(tv.tv_sec, &tm);
snprintf(filename, sizeof(filename) - 1, "/data/hwlogdir/uart_rx/uart_rx-%04d-%02d-%02d:%02d-%02d-%02d",
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
PS_PRINT_INFO("filename = %s",filename);
ps_core_d->rx_data_fp = filp_open(filename, O_RDWR | O_CREAT, 0777);
ps_core_d->pre_time = ps_core_d->curr_time;
}
}
PS_PRINT_DBG("RX:data[0] = %x, data[1] = %x, data[2] = %x, data[3] = %x, data[4] = %x, data[count-1] = %x\n",
data[0],data[1],data[2],data[3],data[4],data[count-1]);
ps_uart_tty_rx_add(count);
tty_recv(tty->disc_data, data, count);
spin_unlock(&ps_core_d->rx_lock);
}
static int msmrtc_tod_proc_result(struct msm_rpc_client *client, void *buff,
void *data)
{
struct rtc_tod_args *rtc_args = data;
if ((rtc_args->proc == TIMEREMOTE_PROCEEDURE_GET_JULIAN)
#ifdef CONFIG_RTC_SECURE_TIME_SUPPORT
|| (rtc_args->proc == TIMEREMOTE_PROCEEDURE_GET_SECURE_JULIAN)
#endif
) {
struct timeremote_get_julian_rep {
uint32_t opt_arg;
struct rpc_time_julian time;
};
struct timeremote_get_julian_rep *result = buff;
if (be32_to_cpu(result->opt_arg) != 0x1)
return -ENODATA;
rtc_args->tm->tm_year = be32_to_cpu(result->time.year);
rtc_args->tm->tm_mon = be32_to_cpu(result->time.month);
rtc_args->tm->tm_mday = be32_to_cpu(result->time.day);
rtc_args->tm->tm_hour = be32_to_cpu(result->time.hour);
rtc_args->tm->tm_min = be32_to_cpu(result->time.minute);
rtc_args->tm->tm_sec = be32_to_cpu(result->time.second);
rtc_args->tm->tm_wday = be32_to_cpu(result->time.day_of_week);
pr_debug("%s: %.2u/%.2u/%.4u %.2u:%.2u:%.2u (%.2u)\n",
__func__, rtc_args->tm->tm_mon, rtc_args->tm->tm_mday,
rtc_args->tm->tm_year, rtc_args->tm->tm_hour,
rtc_args->tm->tm_min, rtc_args->tm->tm_sec,
rtc_args->tm->tm_wday);
/* RTC layer expects years to start at 1900 */
rtc_args->tm->tm_year -= 1900;
/* RTC layer expects mons to be 0 based */
rtc_args->tm->tm_mon--;
if (rtc_valid_tm(rtc_args->tm) < 0) {
pr_err("%s: Retrieved data/time not valid\n", __func__);
rtc_time_to_tm(0, rtc_args->tm);
}
return 0;
} else
return 0;
}
static int jz4740_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
struct jz4740_rtc *rtc = dev_get_drvdata(dev);
uint32_t secs;
uint32_t ctrl;
secs = jz4740_rtc_reg_read(rtc, JZ_REG_RTC_SEC_ALARM);
ctrl = jz4740_rtc_reg_read(rtc, JZ_REG_RTC_CTRL);
alrm->enabled = !!(ctrl & JZ_RTC_CTRL_AE);
alrm->pending = !!(ctrl & JZ_RTC_CTRL_AF);
rtc_time_to_tm(secs, &alrm->time);
return rtc_valid_tm(&alrm->time);
}
