int q40_hwclk(int op, struct hwclk_time *t) { if (op) { /* Write.... */ RTC_CTRL |= RTC_WRITE; RTC_SECS = bin2bcd(t->sec); RTC_MINS = bin2bcd(t->min); RTC_HOUR = bin2bcd(t->hour); RTC_DATE = bin2bcd(t->day); RTC_MNTH = bin2bcd(t->mon + 1); RTC_YEAR = bin2bcd(t->year%100); if (t->wday >= 0) RTC_DOW = bin2bcd(t->wday+1); RTC_CTRL &= ~(RTC_WRITE); } else { /* Read.... */ RTC_CTRL |= RTC_READ; t->year = bcd2bin (RTC_YEAR); t->mon = bcd2bin (RTC_MNTH)-1; t->day = bcd2bin (RTC_DATE); t->hour = bcd2bin (RTC_HOUR); t->min = bcd2bin (RTC_MINS); t->sec = bcd2bin (RTC_SECS); RTC_CTRL &= ~(RTC_READ); if (t->year < 70) t->year += 100; t->wday = bcd2bin(RTC_DOW)-1; } return 0; }
static int m48t59_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm) { struct platform_device *pdev = to_platform_device(dev); struct m48t59_plat_data *pdata = pdev->dev.platform_data; struct m48t59_private *m48t59 = platform_get_drvdata(pdev); struct rtc_time *tm = &alrm->time; unsigned long flags; u8 val; if (m48t59->irq == NO_IRQ) return -EIO; spin_lock_irqsave(&m48t59->lock, flags); M48T59_SET_BITS(M48T59_CNTL_READ, M48T59_CNTL); tm->tm_year = bcd2bin(M48T59_READ(M48T59_YEAR)); #ifdef CONFIG_SPARC tm->tm_year += 68; #endif tm->tm_mon = bcd2bin(M48T59_READ(M48T59_MONTH)) - 1; val = M48T59_READ(M48T59_WDAY); if ((val & M48T59_WDAY_CEB) && (val & M48T59_WDAY_CB)) tm->tm_year += 100; tm->tm_mday = bcd2bin(M48T59_READ(M48T59_ALARM_DATE)); tm->tm_hour = bcd2bin(M48T59_READ(M48T59_ALARM_HOUR)); tm->tm_min = bcd2bin(M48T59_READ(M48T59_ALARM_MIN)); tm->tm_sec = bcd2bin(M48T59_READ(M48T59_ALARM_SEC)); M48T59_CLEAR_BITS(M48T59_CNTL_READ, M48T59_CNTL); spin_unlock_irqrestore(&m48t59->lock, flags); dev_dbg(dev, "RTC read alarm time %04d-%02d-%02d %02d/%02d/%02d\n", tm->tm_year + 1900, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec); return rtc_valid_tm(tm); }
/* * Read alarm time and date in RTC */ static int m48t59_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm) { struct platform_device *pdev = to_platform_device(dev); struct m48t59_plat_data *pdata = pdev->dev.platform_data; struct m48t59_private *m48t59 = platform_get_drvdata(pdev); struct rtc_time *tm = &alrm->time; unsigned long flags; u8 val; /* If no irq, we don't support ALARM */ if (m48t59->irq == NO_IRQ) return -EIO; spin_lock_irqsave(&m48t59->lock, flags); /* Issue the READ command */ M48T59_SET_BITS(M48T59_CNTL_READ, M48T59_CNTL); tm->tm_year = bcd2bin(M48T59_READ(M48T59_YEAR)); #ifdef CONFIG_SPARC /* Sun SPARC machines count years since 1968 */ tm->tm_year += 68; #endif /* tm_mon is 0-11 */ tm->tm_mon = bcd2bin(M48T59_READ(M48T59_MONTH)) - 1; val = M48T59_READ(M48T59_WDAY); if ((val & M48T59_WDAY_CEB) && (val & M48T59_WDAY_CB)) tm->tm_year += 100; /* one century */ tm->tm_mday = bcd2bin(M48T59_READ(M48T59_ALARM_DATE)); tm->tm_hour = bcd2bin(M48T59_READ(M48T59_ALARM_HOUR)); tm->tm_min = bcd2bin(M48T59_READ(M48T59_ALARM_MIN)); tm->tm_sec = bcd2bin(M48T59_READ(M48T59_ALARM_SEC)); /* Clear the READ bit */ M48T59_CLEAR_BITS(M48T59_CNTL_READ, M48T59_CNTL); spin_unlock_irqrestore(&m48t59->lock, flags); dev_dbg(dev, "RTC read alarm time %04d-%02d-%02d %02d/%02d/%02d\n", tm->tm_year + 1900, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec); return 0; }
/* * Gets current rc5t583 RTC time and date parameters. * * The RTC's time/alarm representation is not what gmtime(3) requires * Linux to use: * * - Months are 1..12 vs Linux 0-11 * - Years are 0..99 vs Linux 1900..N (we assume 21st century) */ static int rc5t583_rtc_read_time(struct device *dev, struct rtc_time *tm) { struct rc5t583 *rc5t583 = dev_get_drvdata(dev->parent); u8 rtc_data[NUM_TIME_REGS]; int ret; ret = regmap_bulk_read(rc5t583->regmap, RC5T583_RTC_SEC, rtc_data, NUM_TIME_REGS); if (ret < 0) { dev_err(dev, "RTC read time failed with err:%d\n", ret); return ret; } tm->tm_sec = bcd2bin(rtc_data[0]); tm->tm_min = bcd2bin(rtc_data[1]); tm->tm_hour = bcd2bin(rtc_data[2]); tm->tm_wday = bcd2bin(rtc_data[3]); tm->tm_mday = bcd2bin(rtc_data[4]); tm->tm_mon = bcd2bin(rtc_data[5]) - 1; tm->tm_year = bcd2bin(rtc_data[6]) + 100; return ret; }
int rtc_get(struct rtc_time *tmp) { uchar const *const data = rtc_validate(); if (!data) return -1; tmp->tm_sec = bcd2bin(data[RTC_SEC] & 0x7F); tmp->tm_min = bcd2bin(data[RTC_MIN] & 0x7F); tmp->tm_hour = bcd2bin(data[RTC_HOUR] & 0x3F); tmp->tm_mday = bcd2bin(data[RTC_DATE] & 0x3F); tmp->tm_mon = bcd2bin(data[RTC_MONTH] & 0x1F); tmp->tm_year = cb2year(data[RTC_MONTH] >> 6) + bcd2bin(data[RTC_YEAR]); tmp->tm_wday = bcd2bin(data[RTC_DAY] & 0x07) - 1; tmp->tm_yday = 0; tmp->tm_isdst = 0; debug("Get DATE: %4d-%02d-%02d (wday=%d) TIME: %2d:%02d:%02d\n", tmp->tm_year, tmp->tm_mon, tmp->tm_mday, tmp->tm_wday, tmp->tm_hour, tmp->tm_min, tmp->tm_sec); return 0; }
static int ds3234_read_time(struct device *dev, struct rtc_time *dt) { int err; unsigned char buf[8]; struct spi_device *spi = to_spi_device(dev); buf[0] = 0x00; /* Start address */ err = spi_write_then_read(spi, buf, 1, buf, 8); if (err != 0) return err; /* Seconds, Minutes, Hours, Day, Date, Month, Year */ dt->tm_sec = bcd2bin(buf[0]); dt->tm_min = bcd2bin(buf[1]); dt->tm_hour = bcd2bin(buf[2] & 0x3f); dt->tm_wday = bcd2bin(buf[3]) - 1; /* 0 = Sun */ dt->tm_mday = bcd2bin(buf[4]); dt->tm_mon = bcd2bin(buf[5] & 0x1f) - 1; /* 0 = Jan */ dt->tm_year = bcd2bin(buf[6] & 0xff) + 100; /* Assume 20YY */ return rtc_valid_tm(dt); }
void PCF8563_read_datetime(date_time_t volatile *dt) { union{ struct{ uint8_t bcd_sec; uint8_t bcd_min; uint8_t bcd_hrs; uint8_t bcd_day; uint8_t wek; uint8_t bcd_mon; uint8_t bcd_yer; }Fields; uint8_t arrWeekDays[7]; }Time; uint8_t data = 0; // LowVoltage = VL_sec.7 // Century = C_Mon.7 // Disable interrupts so the i2c process is not disrupted. data = PCF8563_SECONDS_REG; HAL_I2C_Master_Transmit(&hi2c2, PCF8563_WRITE_ADDRESS, &data, 1, 200); // Read the date/time registers inside the PCF8563. HAL_I2C_Master_Receive(&hi2c2, PCF8563_READ_ADDRESS, Time.arrWeekDays, 7, 100); // Convert the date/time values from BCD to // unsigned 8-bit integers. Unpack the bits // in the PCF8563 registers where required. Time.Fields.bcd_sec &= 0x7F; Time.Fields.bcd_mon &= 0x7F; dt->seconds = bcd2bin(Time.Fields.bcd_sec); dt->minutes = bcd2bin(Time.Fields.bcd_min); dt->hours = bcd2bin(Time.Fields.bcd_hrs & 0x3F); dt->day = bcd2bin(Time.Fields.bcd_day & 0x3F); dt->month = bcd2bin(Time.Fields.bcd_mon & 0x1F); dt->weekday = Time.Fields.wek & 0x07; dt->year = bcd2bin(Time.Fields.bcd_yer); }
// 0x08 enum ab1815_status ab1815_get_alarm(struct ab1815_t *clock, struct tmElements_t *time, enum ab1815_alarm_repeat_mode *alarm_mode) { enum ab1815_status to_ret = ab1815_status_ERROR; size_t length = AB1815_REG_STATUS - AB1815_REG_ALARM_HUNDREDTHS ; uint8_t buffer[length]; memset(buffer, 0, length); struct ab1815_countdown_control_t cd_reg; if(ab1815_get_countdown_control(clock, &cd_reg) == ab1815_status_OK) { if(ab1815_read(clock, AB1815_REG_ALARM_HUNDREDTHS, buffer, length) == ab1815_status_OK) { to_ret = ab1815_status_OK; time->Hundredth = bcd2bin(buffer[0]); time->Second = bcd2bin(0x7F & buffer[1]); time->Minute = bcd2bin(0x7F & buffer[2]); time->Hour = bcd2bin(0x3F & buffer[3]); time->Day = bcd2bin(0x3F & buffer[4]); time->Month = bcd2bin(0x1F & buffer[5]); time->Wday = bcd2bin(0x07 & buffer[6]); } *alarm_mode = cd_reg.fields.RPT; if(cd_reg.fields.RPT == 7) { if((time->Hundredth & 0xF0) == 0xF0) { (*alarm_mode)++; if((time->Hundredth & 0xFF) == 0xFF) { (*alarm_mode)++; } } } } return to_ret; };
static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm) { unsigned int have_retried = 0; void __iomem *base = s3c_rtc_base; clk_enable(rtc_clk); retry_get_time: rtc_tm->tm_min = readb(base + S3C2410_RTCMIN); rtc_tm->tm_hour = readb(base + S3C2410_RTCHOUR); rtc_tm->tm_mday = readb(base + S3C2410_RTCDATE); rtc_tm->tm_mon = readb(base + S3C2410_RTCMON); rtc_tm->tm_year = readb(base + S3C2410_RTCYEAR); rtc_tm->tm_sec = readb(base + S3C2410_RTCSEC); /* the only way to work out whether the system was mid-update * when we read it is to check the second counter, and if it * is zero, then we re-try the entire read */ if (rtc_tm->tm_sec == 0 && !have_retried) { have_retried = 1; goto retry_get_time; } rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec); rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min); rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour); rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday); rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon); rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year); rtc_tm->tm_year += 100; dev_dbg(dev, "read time %04d.%02d.%02d %02d:%02d:%02d\n", 1900 + rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday, rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec); rtc_tm->tm_mon -= 1; clk_disable(rtc_clk); return rtc_valid_tm(rtc_tm); }
static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm) { unsigned int have_retried = 0; void __iomem *base = s3c_rtc_base; clk_enable(rtc_clk); retry_get_time: rtc_tm->tm_min = readb(base + S3C2410_RTCMIN); rtc_tm->tm_hour = readb(base + S3C2410_RTCHOUR); rtc_tm->tm_mday = readb(base + S3C2410_RTCDATE); rtc_tm->tm_mon = readb(base + S3C2410_RTCMON); rtc_tm->tm_year = readb(base + S3C2410_RTCYEAR); rtc_tm->tm_sec = readb(base + S3C2410_RTCSEC); /* */ if (rtc_tm->tm_sec == 0 && !have_retried) { have_retried = 1; goto retry_get_time; } rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec); rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min); rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour); rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday); rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon); rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year); rtc_tm->tm_year += 100; pr_debug("read time %04d.%02d.%02d %02d:%02d:%02d\n", 1900 + rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday, rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec); rtc_tm->tm_mon -= 1; clk_disable(rtc_clk); return rtc_valid_tm(rtc_tm); }
int rtc_get(struct rtc_time *time) { uint8_t value; int ret = 0; /* * Set RTC_READSEL to cause reads to access shadow registers and * transition GET_TIME from 0 to 1 to cause dynamic register content * to be copied into shadow registers. This ensures a coherent reading * of time values as we access each register using slow I2C transfers. */ rk808_clrsetbits(RTC_CTRL, RTC_CTRL_GET_TIME, 0); rk808_clrsetbits(RTC_CTRL, 0, RTC_CTRL_GET_TIME | RTC_CTRL_RTC_READSEL); /* * After we set the GET_TIME bit, the rtc time can't be read * immediately. So we should wait up to 31.25 us. */ udelay(32); ret |= rk808_read(RTC_SECOND, &value); time->sec = bcd2bin(value & 0x7f); ret |= rk808_read(RTC_MINUTE, &value); time->min = bcd2bin(value & 0x7f); ret |= rk808_read(RTC_HOUR, &value); time->hour = bcd2bin(value & 0x3f); ret |= rk808_read(RTC_DAY, &value); time->mday = bcd2bin(value & 0x3f); ret |= rk808_read(RTC_MONTH, &value); time->mon = bcd2bin(value & 0x1f); ret |= rk808_read(RTC_YEAR, &value); time->year = bcd2bin(value); time->wday = -1; /* unknown */ return ret; }
static int m48t86_rtc_read_time(struct device *dev, struct rtc_time *tm) { unsigned char reg; struct platform_device *pdev = to_platform_device(dev); struct m48t86_ops *ops = dev_get_platdata(&pdev->dev); reg = ops->readbyte(M48T86_REG_B); if (reg & M48T86_REG_B_DM) { /* data (binary) mode */ tm->tm_sec = ops->readbyte(M48T86_REG_SEC); tm->tm_min = ops->readbyte(M48T86_REG_MIN); tm->tm_hour = ops->readbyte(M48T86_REG_HOUR) & 0x3F; tm->tm_mday = ops->readbyte(M48T86_REG_DOM); /* tm_mon is 0-11 */ tm->tm_mon = ops->readbyte(M48T86_REG_MONTH) - 1; tm->tm_year = ops->readbyte(M48T86_REG_YEAR) + 100; tm->tm_wday = ops->readbyte(M48T86_REG_DOW); } else { /* bcd mode */ tm->tm_sec = bcd2bin(ops->readbyte(M48T86_REG_SEC)); tm->tm_min = bcd2bin(ops->readbyte(M48T86_REG_MIN)); tm->tm_hour = bcd2bin(ops->readbyte(M48T86_REG_HOUR) & 0x3F); tm->tm_mday = bcd2bin(ops->readbyte(M48T86_REG_DOM)); /* tm_mon is 0-11 */ tm->tm_mon = bcd2bin(ops->readbyte(M48T86_REG_MONTH)) - 1; tm->tm_year = bcd2bin(ops->readbyte(M48T86_REG_YEAR)) + 100; tm->tm_wday = bcd2bin(ops->readbyte(M48T86_REG_DOW)); } /* correct the hour if the clock is in 12h mode */ if (!(reg & M48T86_REG_B_H24)) if (ops->readbyte(M48T86_REG_HOUR) & 0x80) tm->tm_hour += 12; return rtc_valid_tm(tm); }
static int m48t35_read_time(struct device *dev, struct rtc_time *tm) { struct m48t35_priv *priv = dev_get_drvdata(dev); u8 control; /* * Only the values that we read from the RTC are set. We leave * tm_wday, tm_yday and tm_isdst untouched. Even though the * RTC has RTC_DAY_OF_WEEK, we ignore it, as it is only updated * by the RTC when initially set to a non-zero value. */ spin_lock_irq(&priv->lock); control = readb(&priv->reg->control); writeb(control | M48T35_RTC_READ, &priv->reg->control); tm->tm_sec = readb(&priv->reg->sec); tm->tm_min = readb(&priv->reg->min); tm->tm_hour = readb(&priv->reg->hour); tm->tm_mday = readb(&priv->reg->date); tm->tm_mon = readb(&priv->reg->month); tm->tm_year = readb(&priv->reg->year); writeb(control, &priv->reg->control); spin_unlock_irq(&priv->lock); tm->tm_sec = bcd2bin(tm->tm_sec); tm->tm_min = bcd2bin(tm->tm_min); tm->tm_hour = bcd2bin(tm->tm_hour); tm->tm_mday = bcd2bin(tm->tm_mday); tm->tm_mon = bcd2bin(tm->tm_mon); tm->tm_year = bcd2bin(tm->tm_year); /* * Account for differences between how the RTC uses the values * and how they are defined in a struct rtc_time; */ tm->tm_year += 70; if (tm->tm_year <= 69) tm->tm_year += 100; tm->tm_mon--; return rtc_valid_tm(tm); }
static int m48t86_rtc_read_time(struct device *dev, struct rtc_time *tm) { unsigned char reg; reg = m48t86_readb(dev, M48T86_B); if (reg & M48T86_B_DM) { /* data (binary) mode */ tm->tm_sec = m48t86_readb(dev, M48T86_SEC); tm->tm_min = m48t86_readb(dev, M48T86_MIN); tm->tm_hour = m48t86_readb(dev, M48T86_HOUR) & 0x3f; tm->tm_mday = m48t86_readb(dev, M48T86_DOM); /* tm_mon is 0-11 */ tm->tm_mon = m48t86_readb(dev, M48T86_MONTH) - 1; tm->tm_year = m48t86_readb(dev, M48T86_YEAR) + 100; tm->tm_wday = m48t86_readb(dev, M48T86_DOW); } else { /* bcd mode */ tm->tm_sec = bcd2bin(m48t86_readb(dev, M48T86_SEC)); tm->tm_min = bcd2bin(m48t86_readb(dev, M48T86_MIN)); tm->tm_hour = bcd2bin(m48t86_readb(dev, M48T86_HOUR) & 0x3f); tm->tm_mday = bcd2bin(m48t86_readb(dev, M48T86_DOM)); /* tm_mon is 0-11 */ tm->tm_mon = bcd2bin(m48t86_readb(dev, M48T86_MONTH)) - 1; tm->tm_year = bcd2bin(m48t86_readb(dev, M48T86_YEAR)) + 100; tm->tm_wday = bcd2bin(m48t86_readb(dev, M48T86_DOW)); } /* correct the hour if the clock is in 12h mode */ if (!(reg & M48T86_B_H24)) if (m48t86_readb(dev, M48T86_HOUR) & 0x80) tm->tm_hour += 12; return 0; }
static int q40_hwclk(int op, struct rtc_time *t) { if (op) { /* Write.... */ Q40_RTC_CTRL |= Q40_RTC_WRITE; Q40_RTC_SECS = bin2bcd(t->tm_sec); Q40_RTC_MINS = bin2bcd(t->tm_min); Q40_RTC_HOUR = bin2bcd(t->tm_hour); Q40_RTC_DATE = bin2bcd(t->tm_mday); Q40_RTC_MNTH = bin2bcd(t->tm_mon + 1); Q40_RTC_YEAR = bin2bcd(t->tm_year%100); if (t->tm_wday >= 0) Q40_RTC_DOW = bin2bcd(t->tm_wday+1); Q40_RTC_CTRL &= ~(Q40_RTC_WRITE); } else { /* Read.... */ Q40_RTC_CTRL |= Q40_RTC_READ; t->tm_year = bcd2bin (Q40_RTC_YEAR); t->tm_mon = bcd2bin (Q40_RTC_MNTH)-1; t->tm_mday = bcd2bin (Q40_RTC_DATE); t->tm_hour = bcd2bin (Q40_RTC_HOUR); t->tm_min = bcd2bin (Q40_RTC_MINS); t->tm_sec = bcd2bin (Q40_RTC_SECS); Q40_RTC_CTRL &= ~(Q40_RTC_READ); if (t->tm_year < 70) t->tm_year += 100; t->tm_wday = bcd2bin(Q40_RTC_DOW)-1; } return 0; }
static int hym8563_rtc_read_time(struct device *dev, struct rtc_time *tm) { struct i2c_client *client = to_i2c_client(dev); struct hym8563 *hym8563 = i2c_get_clientdata(client); u8 buf[7]; int ret; if (!hym8563->valid) { dev_warn(&client->dev, "no valid clock/calendar values available\n"); return -EPERM; } ret = i2c_smbus_read_i2c_block_data(client, HYM8563_SEC, 7, buf); tm->tm_sec = bcd2bin(buf[0] & HYM8563_SEC_MASK); tm->tm_min = bcd2bin(buf[1] & HYM8563_MIN_MASK); tm->tm_hour = bcd2bin(buf[2] & HYM8563_HOUR_MASK); tm->tm_mday = bcd2bin(buf[3] & HYM8563_DAY_MASK); tm->tm_wday = bcd2bin(buf[4] & HYM8563_WEEKDAY_MASK); /* 0 = Sun */ tm->tm_mon = bcd2bin(buf[5] & HYM8563_MONTH_MASK) - 1; /* 0 = Jan */ tm->tm_year = bcd2bin(buf[6]) + 100; return 0; }
static int rx8025_get_time(struct device *dev, struct rtc_time *dt) { struct rx8025_data *rx8025 = dev_get_drvdata(dev); u8 date[7]; int err; err = rx8025_read_regs(rx8025->client, RX8025_REG_SEC, 7, date); if (err) return err; dev_dbg(dev, "%s: read 0x%02x 0x%02x " "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n", __func__, date[0], date[1], date[2], date[3], date[4], date[5], date[6]); dt->tm_sec = bcd2bin(date[RX8025_REG_SEC] & 0x7f); dt->tm_min = bcd2bin(date[RX8025_REG_MIN] & 0x7f); if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224) dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x3f); else dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x1f) % 12 + (date[RX8025_REG_HOUR] & 0x20 ? 12 : 0); dt->tm_mday = bcd2bin(date[RX8025_REG_MDAY] & 0x3f); dt->tm_mon = bcd2bin(date[RX8025_REG_MONTH] & 0x1f) - 1; dt->tm_year = bcd2bin(date[RX8025_REG_YEAR]); if (dt->tm_year < 70) dt->tm_year += 100; dev_dbg(dev, "%s: date %ds %dm %dh %dmd %dm %dy\n", __func__, dt->tm_sec, dt->tm_min, dt->tm_hour, dt->tm_mday, dt->tm_mon, dt->tm_year); return rtc_valid_tm(dt); }
unsigned long read_persistent_clock(void) { unsigned int year, month, day, hour, min, sec; unsigned long flags; spin_lock_irqsave(&rtc_lock, flags); /* Stop the update to the time */ m48t37_base->control = 0x40; year = bcd2bin(m48t37_base->year); year += bcd2bin(m48t37_base->century) * 100; month = bcd2bin(m48t37_base->month); day = bcd2bin(m48t37_base->date); hour = bcd2bin(m48t37_base->hour); min = bcd2bin(m48t37_base->min); sec = bcd2bin(m48t37_base->sec); /* Start the update to the time again */ m48t37_base->control = 0x00; spin_unlock_irqrestore(&rtc_lock, flags); return mktime(year, month, day, hour, min, sec); }
void test1302() { ds1302_struct rtc; char buffer[80]; // the code uses 70 characters. getTime1302(rtc); sprintf( buffer, "Time = %02d:%02d:%02d, ", \ bcd2bin( rtc.h24.Hour10, rtc.h24.Hour), \ bcd2bin( rtc.Minutes10, rtc.Minutes), \ bcd2bin( rtc.Seconds10, rtc.Seconds)); Serial.print(buffer); sprintf(buffer, "Date(day of month) = %d, Month = %d, " \ "Day(day of week) = %d, Year = %d", \ bcd2bin( rtc.Date10, rtc.Date), \ bcd2bin( rtc.Month10, rtc.Month), \ rtc.Day, \ 2000 + bcd2bin( rtc.Year10, rtc.Year)); Serial.println( buffer); }
// 0x28 enum ab1815_status ab1815_get_id(struct ab1815_t *clock, struct ab1815_id_t *id) { size_t length = AB1815_REG_ID6 - AB1815_REG_ID0; uint8_t buffer[length]; memset(buffer, 0, length); enum ab1815_status result = ab1815_status_ERROR; result = ab1815_read(clock, AB1815_REG_ID0, buffer, length); if(result == ab1815_status_OK) { id->ID0 = bcd2bin(buffer[0]); id->ID1 = bcd2bin(buffer[1]); id->ID2.value = buffer[2]; id->ID3 = bcd2bin(buffer[3]); id->ID4 = bcd2bin(buffer[4]); id->ID5 = bcd2bin(buffer[5]); id->ID6 = bcd2bin(buffer[6]); } return result; };
static int s3c_rtc_gettime(struct device *dev, struct rtc_time *rtc_tm) { unsigned int have_retried = 0; void __iomem *base = s3c_rtc_base; retry_get_time: rtc_tm->tm_min = readb(base + S3C2410_RTCMIN); rtc_tm->tm_hour = readb(base + S3C2410_RTCHOUR); rtc_tm->tm_mday = readb(base + S3C2410_RTCDATE); rtc_tm->tm_mon = readb(base + S3C2410_RTCMON); rtc_tm->tm_year = readb(base + S3C2410_RTCYEAR); rtc_tm->tm_sec = readb(base + S3C2410_RTCSEC); /* the only way to work out wether the system was mid-update * when we read it is to check the second counter, and if it * is zero, then we re-try the entire read */ if (rtc_tm->tm_sec == 0 && !have_retried) { have_retried = 1; goto retry_get_time; } pr_debug("read time %02x.%02x.%02x %02x/%02x/%02x\n", rtc_tm->tm_year, rtc_tm->tm_mon, rtc_tm->tm_mday, rtc_tm->tm_hour, rtc_tm->tm_min, rtc_tm->tm_sec); rtc_tm->tm_sec = bcd2bin(rtc_tm->tm_sec); rtc_tm->tm_min = bcd2bin(rtc_tm->tm_min); rtc_tm->tm_hour = bcd2bin(rtc_tm->tm_hour); rtc_tm->tm_mday = bcd2bin(rtc_tm->tm_mday); rtc_tm->tm_mon = bcd2bin(rtc_tm->tm_mon); rtc_tm->tm_year = bcd2bin(rtc_tm->tm_year); rtc_tm->tm_year += 100; rtc_tm->tm_mon -= 1; return 0; }
static int tps80031_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm) { u8 buff[6]; int ret; ret = tps80031_reads(dev->parent, TPS80031_SLAVE_ID1, TPS80031_ALARM_SECONDS_REG, TPS80031_RTC_ALARM_NUM_REGS, buff); if (ret < 0) { dev_err(dev->parent, "reading RTC_ALARM failed, err = %d\n", ret); return ret; } alrm->time.tm_sec = bcd2bin(buff[0]); alrm->time.tm_min = bcd2bin(buff[1]); alrm->time.tm_hour = bcd2bin(buff[2]); alrm->time.tm_mday = bcd2bin(buff[3]); alrm->time.tm_mon = bcd2bin(buff[4]) - 1; alrm->time.tm_year = bcd2bin(buff[5]) + RTC_YEAR_OFFSET; return 0; }
void read_persistent_clock(struct timespec *ts) { unsigned int year, mon, day, hour, min, sec, real_year; unsigned long flags; spin_lock_irqsave(&rtc_lock, flags); do { sec = CMOS_READ(RTC_SECONDS); min = CMOS_READ(RTC_MINUTES); hour = CMOS_READ(RTC_HOURS); day = CMOS_READ(RTC_DAY_OF_MONTH); mon = CMOS_READ(RTC_MONTH); year = CMOS_READ(RTC_YEAR); /* * The PROM will reset the year to either '72 or '73. * Therefore we store the real year separately, in one * of unused BBU RAM locations. */ real_year = CMOS_READ(RTC_DEC_YEAR); } while (sec != CMOS_READ(RTC_SECONDS)); spin_unlock_irqrestore(&rtc_lock, flags); if (!(CMOS_READ(RTC_CONTROL) & RTC_DM_BINARY) || RTC_ALWAYS_BCD) { sec = bcd2bin(sec); min = bcd2bin(min); hour = bcd2bin(hour); day = bcd2bin(day); mon = bcd2bin(mon); year = bcd2bin(year); } year += real_year - 72 + 2000; ts->tv_sec = mktime(year, mon, day, hour, min, sec); ts->tv_nsec = 0; }
static int pcf2123_rtc_read_time(struct device *dev, struct rtc_time *tm) { struct spi_device *spi = to_spi_device(dev); u8 txbuf[1], rxbuf[7]; int ret; txbuf[0] = PCF2123_READ | PCF2123_REG_SC; ret = spi_write_then_read(spi, txbuf, sizeof(txbuf), rxbuf, sizeof(rxbuf)); if (ret < 0) return ret; pcf2123_delay_trec(); tm->tm_sec = bcd2bin(rxbuf[0] & 0x7F); tm->tm_min = bcd2bin(rxbuf[1] & 0x7F); tm->tm_hour = bcd2bin(rxbuf[2] & 0x3F); /* */ tm->tm_mday = bcd2bin(rxbuf[3] & 0x3F); tm->tm_wday = rxbuf[4] & 0x07; tm->tm_mon = bcd2bin(rxbuf[5] & 0x1F) - 1; /* */ tm->tm_year = bcd2bin(rxbuf[6]); if (tm->tm_year < 70) tm->tm_year += 100; /* */ dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, " "mday=%d, mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec, tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday); /* */ if (rtc_valid_tm(tm) < 0) dev_err(dev, "retrieved date/time is not valid.\n"); return 0; }
static int pcf2123_rtc_read_time(struct device *dev, struct rtc_time *tm) { struct spi_device *spi = to_spi_device(dev); u8 txbuf[1], rxbuf[7]; int ret; txbuf[0] = PCF2123_READ | PCF2123_REG_SC; ret = spi_write_then_read(spi, txbuf, sizeof(txbuf), rxbuf, sizeof(rxbuf)); if (ret < 0) return ret; pcf2123_delay_trec(); tm->tm_sec = bcd2bin(rxbuf[0] & 0x7F); tm->tm_min = bcd2bin(rxbuf[1] & 0x7F); tm->tm_hour = bcd2bin(rxbuf[2] & 0x3F); /* rtc hr 0-23 */ tm->tm_mday = bcd2bin(rxbuf[3] & 0x3F); tm->tm_wday = rxbuf[4] & 0x07; tm->tm_mon = bcd2bin(rxbuf[5] & 0x1F) - 1; /* rtc mn 1-12 */ tm->tm_year = bcd2bin(rxbuf[6]); if (tm->tm_year < 70) tm->tm_year += 100; /* assume we are in 1970...2069 */ dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, " "mday=%d, mon=%d, year=%d, wday=%d\n", __func__, tm->tm_sec, tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday); /* the clock can give out invalid datetime, but we cannot return * -EINVAL otherwise hwclock will refuse to set the time on bootup. */ if (rtc_valid_tm(tm) < 0) dev_err(dev, "retrieved date/time is not valid.\n"); return 0; }
void HEATMINDER::print_info(ds1302_struct time) { char buffer[80]; // the code uses 70 characters. sprintf( buffer, "Time = %02d:%02d:%02d, ", \ bcd2bin( time.h24.Hour10, time.h24.Hour), \ bcd2bin( time.Minutes10, time.Minutes), \ bcd2bin( time.Seconds10, time.Seconds)); Serial.print(buffer); sprintf(buffer, "Date(day of month) = %d, Month = %d, " \ "Day(day of week) = %d, Year = %d", \ bcd2bin( time.Date10, time.Date), \ bcd2bin( time.Month10, time.Month), \ time.Day, \ 2000 + bcd2bin( time.Year10, time.Year)); Serial.println( buffer); Serial.print("State = "); Serial.print(time_state); Serial.print("\n"); Serial.print("Inside Temp = "); Serial.print(tempC_inside); Serial.print("\n"); Serial.print("Outside Temp = "); Serial.print(tempC_outside); Serial.print("\n"); Serial.print("Flow Temp = "); Serial.print(tempC_flow); Serial.print("\n"); Serial.print("Return Temp = "); Serial.print(tempC_return); Serial.print("\n"); Serial.print("Test Temp = "); Serial.print(tempC_test); Serial.print("\n"); }
/* * Gets current TWL RTC time and date parameters. * * The RTC's time/alarm representation is not what gmtime(3) requires * Linux to use: * * - Months are 1..12 vs Linux 0-11 * - Years are 0..99 vs Linux 1900..N (we assume 21st century) */ static int twl_rtc_read_time(struct device *dev, struct rtc_time *tm) { unsigned char rtc_data[ALL_TIME_REGS + 1]; int ret; u8 save_control; ret = twl_rtc_read_u8(&save_control, REG_RTC_CTRL_REG); if (ret < 0) return ret; save_control |= BIT_RTC_CTRL_REG_GET_TIME_M; ret = twl_rtc_write_u8(save_control, REG_RTC_CTRL_REG); if (ret < 0) return ret; #ifndef CONFIG_ARCH_OMAP4 ret = twl_i2c_read(TWL_MODULE_RTC, rtc_data, (rtc_reg_map[REG_SECONDS_REG]), ALL_TIME_REGS); #else ret = twl_rtc_read(rtc_data, REG_SECONDS_REG, ALL_TIME_REGS); #endif if (ret < 0) { dev_err(dev, "rtc_read_time error %d\n", ret); return ret; } tm->tm_sec = bcd2bin(rtc_data[0]); tm->tm_min = bcd2bin(rtc_data[1]); tm->tm_hour = bcd2bin(rtc_data[2]); tm->tm_mday = bcd2bin(rtc_data[3]); tm->tm_mon = bcd2bin(rtc_data[4]) - 1; tm->tm_year = bcd2bin(rtc_data[5]) + 100; return ret; }
// Get current date/time from Chronodot // See data sheet for structure of regs, but essentially // the first 7 regs contain the time in BCD // and the last two contain the temp as integer in the MSB // and 1/4 degree in the left two bits of the LSB DateTime Chronodot::now() { uint8_t field, tB[7]; // tB = time/temp buffer string uint8_t ss, mm, hh, d, m; uint16_t y; const float tempLow2[4] = { 0.0, 0.25, 0.50, 0.75 }; // Get the time fields into the buffer for conversion I2c.read((int)CHRONODOT, (int)CD_SEC, (int)7, tB); ss = bcd2bin(tB[0] & 0x7F); mm = bcd2bin(tB[1]); hh = bcd2bin(tB[2]); d = bcd2bin(tB[4]); m = bcd2bin(tB[5]); y = bcd2bin(tB[6]); // Now get the temp and convert it I2c.read((int)CHRONODOT, (int)MSB_TEMP, (int)2, tB); float ttc = (float)(int)tB[0]; ttc += tempLow2[tB[1]>>6]; float ttf = (((ttc * 9.0) / 5.0) + 32.0); // Return the values as fields in the structure return DateTime (y, m, d, hh, mm, ss, ttf, ttc); }
unsigned long get_cmos_time(void) { unsigned int year, mon, day, hour, min, sec; sec = CMOS_READ(RTC_SECONDS); min = CMOS_READ(RTC_MINUTES); hour = CMOS_READ(RTC_HOURS); day = CMOS_READ(RTC_DAY_OF_MONTH); mon = CMOS_READ(RTC_MONTH); year = CMOS_READ(RTC_YEAR); sec = bcd2bin(sec); min = bcd2bin(min); hour = bcd2bin(hour); day = bcd2bin(day); mon = bcd2bin(mon); year = bcd2bin(year); if ((year += 1900) < 1970) year += 100; return mktime(year, mon, day, hour, min, sec); }
static int msf2hsg(bcd_t *msf, int relative) { return (bcd2bin(M_msf(msf)) * 60 + bcd2bin(S_msf(msf))) * 75 + bcd2bin(F_msf(msf)) - (!relative) * 150; }