// SPDX-License-Identifier: GPL-2.0+ /* * Holtek HT1380/HT1381 Serial Timekeeper Chip * * Communication with the chip is vendor-specific. * It is done via 3 GPIO pins: reset, clock, and data. * Describe in .dts this way: * * rtc { * compatible = "holtek,ht1380"; * rst-gpios = <&gpio 19 GPIO_ACTIVE_LOW>; * clk-gpios = <&gpio 20 GPIO_ACTIVE_HIGH>; * dat-gpios = <&gpio 21 GPIO_ACTIVE_HIGH>; * }; * */ #include #include #include #include #include #include struct ht1380_priv { struct gpio_desc rst_desc; struct gpio_desc clk_desc; struct gpio_desc dat_desc; }; enum registers { SEC, MIN, HOUR, MDAY, MONTH, WDAY, YEAR, WP, N_REGS }; enum hour_mode { AMPM_MODE = 0x80, /* RTC is in AM/PM mode */ PM_NOW = 0x20, /* set if PM, clear if AM */ }; static const int BURST = 0xbe; static const int READ = 1; static void ht1380_half_period_delay(void) { /* * Delay for half a period. 1 us complies with the 500 KHz maximum * input serial clock limit given by the datasheet. */ udelay(1); } static int ht1380_send_byte(struct ht1380_priv *priv, int byte) { int ret; for (int bit = 0; bit < 8; bit++) { ret = dm_gpio_set_value(&priv->dat_desc, byte >> bit & 1); if (ret) break; ht1380_half_period_delay(); ret = dm_gpio_set_value(&priv->clk_desc, 1); if (ret) break; ht1380_half_period_delay(); ret = dm_gpio_set_value(&priv->clk_desc, 0); if (ret) break; } return ret; } /* * Leave reset state. The transfer operation can then be started. */ static int ht1380_reset_off(struct ht1380_priv *priv) { const unsigned int T_CC = 4; /* us, Reset to Clock Setup */ int ret; /* * Leave RESET state. * Make sure we make the minimal delay required by the datasheet. */ ret = dm_gpio_set_value(&priv->rst_desc, 0); udelay(T_CC); return ret; } /* * Enter reset state. Completes the transfer operation. */ static int ht1380_reset_on(struct ht1380_priv *priv) { const unsigned int T_CWH = 4; /* us, Reset Inactive Time */ int ret; /* * Enter RESET state. * Make sure we make the minimal delay required by the datasheet. */ ret = dm_gpio_set_value(&priv->rst_desc, 1); udelay(T_CWH); return ret; } static int ht1380_rtc_get(struct udevice *dev, struct rtc_time *tm) { struct ht1380_priv *priv = dev_get_priv(dev); int ret, i, bit, reg[N_REGS]; ret = dm_gpio_set_value(&priv->clk_desc, 0); if (ret) return ret; ret = dm_gpio_set_dir_flags(&priv->dat_desc, GPIOD_IS_OUT); if (ret) return ret; ret = ht1380_reset_off(priv); if (ret) goto exit; ret = ht1380_send_byte(priv, BURST + READ); if (ret) goto exit; ret = dm_gpio_set_dir_flags(&priv->dat_desc, GPIOD_IS_IN); if (ret) goto exit; for (i = 0; i < N_REGS; i++) { reg[i] = 0; for (bit = 0; bit < 8; bit++) { ht1380_half_period_delay(); ret = dm_gpio_set_value(&priv->clk_desc, 1); if (ret) goto exit; ht1380_half_period_delay(); reg[i] |= dm_gpio_get_value(&priv->dat_desc) << bit; ret = dm_gpio_set_value(&priv->clk_desc, 0); if (ret) goto exit; } } ret = -EINVAL; /* Correctness check: some bits are always zero */ if (reg[MIN] & 0x80 || reg[HOUR] & 0x40 || reg[MDAY] & 0xc0 || reg[MONTH] & 0xe0 || reg[WDAY] & 0xf8 || reg[WP] & 0x7f) goto exit; /* Correctness check: some registers are always non-zero */ if (!reg[MDAY] || !reg[MONTH] || !reg[WDAY]) goto exit; tm->tm_sec = bcd2bin(reg[SEC]); tm->tm_min = bcd2bin(reg[MIN]); if (reg[HOUR] & AMPM_MODE) { /* AM-PM Mode, range is 01-12 */ tm->tm_hour = bcd2bin(reg[HOUR] & 0x1f) % 12; if (reg[HOUR] & PM_NOW) { /* it is PM (otherwise AM) */ tm->tm_hour += 12; } } else { /* 24-hour Mode, range is 0-23 */ tm->tm_hour = bcd2bin(reg[HOUR]); } tm->tm_mday = bcd2bin(reg[MDAY]); tm->tm_mon = bcd2bin(reg[MONTH]); tm->tm_year = 2000 + bcd2bin(reg[YEAR]); tm->tm_wday = bcd2bin(reg[WDAY]) - 1; tm->tm_yday = 0; tm->tm_isdst = 0; ret = 0; exit: ht1380_reset_on(priv); return ret; } static int ht1380_write_protection_off(struct ht1380_priv *priv) { int ret; const int PROTECT = 0x8e; ret = ht1380_reset_off(priv); if (ret) return ret; ret = ht1380_send_byte(priv, PROTECT); if (ret) return ret; ret = ht1380_send_byte(priv, 0); /* WP bit is 0 */ if (ret) return ret; return ht1380_reset_on(priv); } static int ht1380_rtc_set(struct udevice *dev, const struct rtc_time *tm) { struct ht1380_priv *priv = dev_get_priv(dev); int ret, i, reg[N_REGS]; ret = dm_gpio_set_value(&priv->clk_desc, 0); if (ret) return ret; ret = dm_gpio_set_dir_flags(&priv->dat_desc, GPIOD_IS_OUT); if (ret) goto exit; ret = ht1380_write_protection_off(priv); if (ret) goto exit; reg[SEC] = bin2bcd(tm->tm_sec); reg[MIN] = bin2bcd(tm->tm_min); reg[HOUR] = bin2bcd(tm->tm_hour); reg[MDAY] = bin2bcd(tm->tm_mday); reg[MONTH] = bin2bcd(tm->tm_mon); reg[WDAY] = bin2bcd(tm->tm_wday) + 1; reg[YEAR] = bin2bcd(tm->tm_year - 2000); reg[WP] = 0x80; /* WP bit is 1 */ ret = ht1380_reset_off(priv); if (ret) goto exit; ret = ht1380_send_byte(priv, BURST); for (i = 0; i < N_REGS && ret; i++) ret = ht1380_send_byte(priv, reg[i]); exit: ht1380_reset_on(priv); return ret; } static int ht1380_probe(struct udevice *dev) { int ret; struct ht1380_priv *priv; priv = dev_get_priv(dev); if (!priv) return -EINVAL; ret = gpio_request_by_name(dev, "rst-gpios", 0, &priv->rst_desc, GPIOD_IS_OUT); if (ret) goto fail_rst; ret = gpio_request_by_name(dev, "clk-gpios", 0, &priv->clk_desc, GPIOD_IS_OUT); if (ret) goto fail_clk; ret = gpio_request_by_name(dev, "dat-gpios", 0, &priv->dat_desc, 0); if (ret) goto fail_dat; ret = ht1380_reset_on(priv); if (ret) goto fail; return 0; fail: dm_gpio_free(dev, &priv->dat_desc); fail_dat: dm_gpio_free(dev, &priv->clk_desc); fail_clk: dm_gpio_free(dev, &priv->rst_desc); fail_rst: return ret; } static int ht1380_remove(struct udevice *dev) { struct ht1380_priv *priv = dev_get_priv(dev); dm_gpio_free(dev, &priv->rst_desc); dm_gpio_free(dev, &priv->clk_desc); dm_gpio_free(dev, &priv->dat_desc); return 0; } static const struct rtc_ops ht1380_rtc_ops = { .get = ht1380_rtc_get, .set = ht1380_rtc_set, }; static const struct udevice_id ht1380_rtc_ids[] = { { .compatible = "holtek,ht1380" }, { } }; U_BOOT_DRIVER(rtc_ht1380) = { .name = "rtc-ht1380", .id = UCLASS_RTC, .probe = ht1380_probe, .remove = ht1380_remove, .of_match = ht1380_rtc_ids, .ops = &ht1380_rtc_ops, .priv_auto = sizeof(struct ht1380_priv), };