1182ae2bbSAlexandre Belloni // SPDX-License-Identifier: GPL-2.0 21e3929efSAlexandre Belloni /* 31e3929efSAlexandre Belloni * RTC driver for the Micro Crystal RV8803 41e3929efSAlexandre Belloni * 51e3929efSAlexandre Belloni * Copyright (C) 2015 Micro Crystal SA 67d1e5bfeSAlexandre Belloni * Alexandre Belloni <alexandre.belloni@bootlin.com> 71e3929efSAlexandre Belloni * 81e3929efSAlexandre Belloni */ 91e3929efSAlexandre Belloni 101e3929efSAlexandre Belloni #include <linux/bcd.h> 111e3929efSAlexandre Belloni #include <linux/bitops.h> 12c27fee16SAhmad Fatoum #include <linux/bitfield.h> 13a1e98e09SBenoît Thébaudeau #include <linux/log2.h> 141e3929efSAlexandre Belloni #include <linux/i2c.h> 151e3929efSAlexandre Belloni #include <linux/interrupt.h> 161e3929efSAlexandre Belloni #include <linux/kernel.h> 171e3929efSAlexandre Belloni #include <linux/module.h> 1848144c28SRob Herring #include <linux/of.h> 191e3929efSAlexandre Belloni #include <linux/rtc.h> 20*2f80de65SStefan Eichenberger #include <linux/pm_wakeirq.h> 211e3929efSAlexandre Belloni 22d522649eSBenoît Thébaudeau #define RV8803_I2C_TRY_COUNT 4 23d522649eSBenoît Thébaudeau 241e3929efSAlexandre Belloni #define RV8803_SEC 0x00 251e3929efSAlexandre Belloni #define RV8803_MIN 0x01 261e3929efSAlexandre Belloni #define RV8803_HOUR 0x02 271e3929efSAlexandre Belloni #define RV8803_WEEK 0x03 281e3929efSAlexandre Belloni #define RV8803_DAY 0x04 291e3929efSAlexandre Belloni #define RV8803_MONTH 0x05 301e3929efSAlexandre Belloni #define RV8803_YEAR 0x06 311e3929efSAlexandre Belloni #define RV8803_RAM 0x07 321e3929efSAlexandre Belloni #define RV8803_ALARM_MIN 0x08 331e3929efSAlexandre Belloni #define RV8803_ALARM_HOUR 0x09 341e3929efSAlexandre Belloni #define RV8803_ALARM_WEEK_OR_DAY 0x0A 351e3929efSAlexandre Belloni #define RV8803_EXT 0x0D 361e3929efSAlexandre Belloni #define RV8803_FLAG 0x0E 371e3929efSAlexandre Belloni #define RV8803_CTRL 0x0F 38c27fee16SAhmad Fatoum #define RV8803_OSC_OFFSET 0x2C 391e3929efSAlexandre Belloni 401e3929efSAlexandre Belloni #define RV8803_EXT_WADA BIT(6) 411e3929efSAlexandre Belloni 421e3929efSAlexandre Belloni #define RV8803_FLAG_V1F BIT(0) 431e3929efSAlexandre Belloni #define RV8803_FLAG_V2F BIT(1) 441e3929efSAlexandre Belloni #define RV8803_FLAG_AF BIT(3) 451e3929efSAlexandre Belloni #define RV8803_FLAG_TF BIT(4) 461e3929efSAlexandre Belloni #define RV8803_FLAG_UF BIT(5) 471e3929efSAlexandre Belloni 481e3929efSAlexandre Belloni #define RV8803_CTRL_RESET BIT(0) 491e3929efSAlexandre Belloni 501e3929efSAlexandre Belloni #define RV8803_CTRL_EIE BIT(2) 511e3929efSAlexandre Belloni #define RV8803_CTRL_AIE BIT(3) 521e3929efSAlexandre Belloni #define RV8803_CTRL_TIE BIT(4) 531e3929efSAlexandre Belloni #define RV8803_CTRL_UIE BIT(5) 541e3929efSAlexandre Belloni 55c27fee16SAhmad Fatoum #define RX8803_CTRL_CSEL GENMASK(7, 6) 56c27fee16SAhmad Fatoum 571cd71376SOleksij Rempel #define RX8900_BACKUP_CTRL 0x18 581cd71376SOleksij Rempel #define RX8900_FLAG_SWOFF BIT(2) 591cd71376SOleksij Rempel #define RX8900_FLAG_VDETOFF BIT(3) 601cd71376SOleksij Rempel 611cd71376SOleksij Rempel enum rv8803_type { 621cd71376SOleksij Rempel rv_8803, 63c27fee16SAhmad Fatoum rx_8803, 645c0189a8SFabio Estevam rx_8804, 651cd71376SOleksij Rempel rx_8900 661cd71376SOleksij Rempel }; 671cd71376SOleksij Rempel 681e3929efSAlexandre Belloni struct rv8803_data { 691e3929efSAlexandre Belloni struct i2c_client *client; 701e3929efSAlexandre Belloni struct rtc_device *rtc; 719d1fa4c3SOleksij Rempel struct mutex flags_lock; 721e3929efSAlexandre Belloni u8 ctrl; 738c798e1eSAhmad Fatoum u8 backup; 74e5c59423SSascha Hauer u8 alarm_invalid:1; 751cd71376SOleksij Rempel enum rv8803_type type; 761e3929efSAlexandre Belloni }; 771e3929efSAlexandre Belloni 78d522649eSBenoît Thébaudeau static int rv8803_read_reg(const struct i2c_client *client, u8 reg) 79d522649eSBenoît Thébaudeau { 80d522649eSBenoît Thébaudeau int try = RV8803_I2C_TRY_COUNT; 81d522649eSBenoît Thébaudeau s32 ret; 82d522649eSBenoît Thébaudeau 83d522649eSBenoît Thébaudeau /* 84d522649eSBenoît Thébaudeau * There is a 61µs window during which the RTC does not acknowledge I2C 85d522649eSBenoît Thébaudeau * transfers. In that case, ensure that there are multiple attempts. 86d522649eSBenoît Thébaudeau */ 87d522649eSBenoît Thébaudeau do 88d522649eSBenoît Thébaudeau ret = i2c_smbus_read_byte_data(client, reg); 89d522649eSBenoît Thébaudeau while ((ret == -ENXIO || ret == -EIO) && --try); 90d522649eSBenoît Thébaudeau if (ret < 0) 91d522649eSBenoît Thébaudeau dev_err(&client->dev, "Unable to read register 0x%02x\n", reg); 92d522649eSBenoît Thébaudeau 93d522649eSBenoît Thébaudeau return ret; 94d522649eSBenoît Thébaudeau } 95d522649eSBenoît Thébaudeau 96d522649eSBenoît Thébaudeau static int rv8803_read_regs(const struct i2c_client *client, 97d522649eSBenoît Thébaudeau u8 reg, u8 count, u8 *values) 98d522649eSBenoît Thébaudeau { 99d522649eSBenoît Thébaudeau int try = RV8803_I2C_TRY_COUNT; 100d522649eSBenoît Thébaudeau s32 ret; 101d522649eSBenoît Thébaudeau 102d522649eSBenoît Thébaudeau do 103d522649eSBenoît Thébaudeau ret = i2c_smbus_read_i2c_block_data(client, reg, count, values); 104d522649eSBenoît Thébaudeau while ((ret == -ENXIO || ret == -EIO) && --try); 105d522649eSBenoît Thébaudeau if (ret != count) { 106d522649eSBenoît Thébaudeau dev_err(&client->dev, 107d522649eSBenoît Thébaudeau "Unable to read registers 0x%02x..0x%02x\n", 108d522649eSBenoît Thébaudeau reg, reg + count - 1); 109d522649eSBenoît Thébaudeau return ret < 0 ? ret : -EIO; 110d522649eSBenoît Thébaudeau } 111d522649eSBenoît Thébaudeau 112d522649eSBenoît Thébaudeau return 0; 113d522649eSBenoît Thébaudeau } 114d522649eSBenoît Thébaudeau 115d522649eSBenoît Thébaudeau static int rv8803_write_reg(const struct i2c_client *client, u8 reg, u8 value) 116d522649eSBenoît Thébaudeau { 117d522649eSBenoît Thébaudeau int try = RV8803_I2C_TRY_COUNT; 118d522649eSBenoît Thébaudeau s32 ret; 119d522649eSBenoît Thébaudeau 120d522649eSBenoît Thébaudeau do 121d522649eSBenoît Thébaudeau ret = i2c_smbus_write_byte_data(client, reg, value); 122d522649eSBenoît Thébaudeau while ((ret == -ENXIO || ret == -EIO) && --try); 123d522649eSBenoît Thébaudeau if (ret) 124d522649eSBenoît Thébaudeau dev_err(&client->dev, "Unable to write register 0x%02x\n", reg); 125d522649eSBenoît Thébaudeau 126d522649eSBenoît Thébaudeau return ret; 127d522649eSBenoît Thébaudeau } 128d522649eSBenoît Thébaudeau 129d522649eSBenoît Thébaudeau static int rv8803_write_regs(const struct i2c_client *client, 130d522649eSBenoît Thébaudeau u8 reg, u8 count, const u8 *values) 131d522649eSBenoît Thébaudeau { 132d522649eSBenoît Thébaudeau int try = RV8803_I2C_TRY_COUNT; 133d522649eSBenoît Thébaudeau s32 ret; 134d522649eSBenoît Thébaudeau 135d522649eSBenoît Thébaudeau do 136d522649eSBenoît Thébaudeau ret = i2c_smbus_write_i2c_block_data(client, reg, count, 137d522649eSBenoît Thébaudeau values); 138d522649eSBenoît Thébaudeau while ((ret == -ENXIO || ret == -EIO) && --try); 139d522649eSBenoît Thébaudeau if (ret) 140d522649eSBenoît Thébaudeau dev_err(&client->dev, 141d522649eSBenoît Thébaudeau "Unable to write registers 0x%02x..0x%02x\n", 142d522649eSBenoît Thébaudeau reg, reg + count - 1); 143d522649eSBenoît Thébaudeau 144d522649eSBenoît Thébaudeau return ret; 145d522649eSBenoît Thébaudeau } 146d522649eSBenoît Thébaudeau 147c27fee16SAhmad Fatoum static int rv8803_regs_init(struct rv8803_data *rv8803) 148c27fee16SAhmad Fatoum { 149c27fee16SAhmad Fatoum int ret; 150c27fee16SAhmad Fatoum 151c27fee16SAhmad Fatoum ret = rv8803_write_reg(rv8803->client, RV8803_OSC_OFFSET, 0x00); 152c27fee16SAhmad Fatoum if (ret) 153c27fee16SAhmad Fatoum return ret; 154c27fee16SAhmad Fatoum 155c27fee16SAhmad Fatoum ret = rv8803_write_reg(rv8803->client, RV8803_CTRL, 156c27fee16SAhmad Fatoum FIELD_PREP(RX8803_CTRL_CSEL, 1)); /* 2s */ 157c27fee16SAhmad Fatoum if (ret) 158c27fee16SAhmad Fatoum return ret; 159c27fee16SAhmad Fatoum 160c27fee16SAhmad Fatoum ret = rv8803_write_regs(rv8803->client, RV8803_ALARM_MIN, 3, 161c27fee16SAhmad Fatoum (u8[]){ 0, 0, 0 }); 162c27fee16SAhmad Fatoum if (ret) 163c27fee16SAhmad Fatoum return ret; 164c27fee16SAhmad Fatoum 165c27fee16SAhmad Fatoum return rv8803_write_reg(rv8803->client, RV8803_RAM, 0x00); 166c27fee16SAhmad Fatoum } 167c27fee16SAhmad Fatoum 168f8176e0bSAhmad Fatoum static int rv8803_regs_configure(struct rv8803_data *rv8803); 169f8176e0bSAhmad Fatoum 170e5c59423SSascha Hauer static int rv8803_regs_reset(struct rv8803_data *rv8803, bool full) 171f8176e0bSAhmad Fatoum { 172c27fee16SAhmad Fatoum /* 173c27fee16SAhmad Fatoum * The RV-8803 resets all registers to POR defaults after voltage-loss, 174c27fee16SAhmad Fatoum * the Epson RTCs don't, so we manually reset the remainder here. 175c27fee16SAhmad Fatoum */ 176e5c59423SSascha Hauer if (full || rv8803->type == rx_8803 || rv8803->type == rx_8900) { 177c27fee16SAhmad Fatoum int ret = rv8803_regs_init(rv8803); 178c27fee16SAhmad Fatoum if (ret) 179c27fee16SAhmad Fatoum return ret; 180c27fee16SAhmad Fatoum } 181c27fee16SAhmad Fatoum 182f8176e0bSAhmad Fatoum return rv8803_regs_configure(rv8803); 183f8176e0bSAhmad Fatoum } 184f8176e0bSAhmad Fatoum 1851e3929efSAlexandre Belloni static irqreturn_t rv8803_handle_irq(int irq, void *dev_id) 1861e3929efSAlexandre Belloni { 1871e3929efSAlexandre Belloni struct i2c_client *client = dev_id; 1881e3929efSAlexandre Belloni struct rv8803_data *rv8803 = i2c_get_clientdata(client); 1891e3929efSAlexandre Belloni unsigned long events = 0; 190d522649eSBenoît Thébaudeau int flags; 1911e3929efSAlexandre Belloni 1929d1fa4c3SOleksij Rempel mutex_lock(&rv8803->flags_lock); 1931e3929efSAlexandre Belloni 194d522649eSBenoît Thébaudeau flags = rv8803_read_reg(client, RV8803_FLAG); 1951e3929efSAlexandre Belloni if (flags <= 0) { 1969d1fa4c3SOleksij Rempel mutex_unlock(&rv8803->flags_lock); 1971e3929efSAlexandre Belloni return IRQ_NONE; 1981e3929efSAlexandre Belloni } 1991e3929efSAlexandre Belloni 2001e3929efSAlexandre Belloni if (flags & RV8803_FLAG_V1F) 2011e3929efSAlexandre Belloni dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n"); 2021e3929efSAlexandre Belloni 2031e3929efSAlexandre Belloni if (flags & RV8803_FLAG_V2F) 2041e3929efSAlexandre Belloni dev_warn(&client->dev, "Voltage low, data loss detected.\n"); 2051e3929efSAlexandre Belloni 2061e3929efSAlexandre Belloni if (flags & RV8803_FLAG_TF) { 2071e3929efSAlexandre Belloni flags &= ~RV8803_FLAG_TF; 2081e3929efSAlexandre Belloni rv8803->ctrl &= ~RV8803_CTRL_TIE; 2091e3929efSAlexandre Belloni events |= RTC_PF; 2101e3929efSAlexandre Belloni } 2111e3929efSAlexandre Belloni 2121e3929efSAlexandre Belloni if (flags & RV8803_FLAG_AF) { 2131e3929efSAlexandre Belloni flags &= ~RV8803_FLAG_AF; 2141e3929efSAlexandre Belloni rv8803->ctrl &= ~RV8803_CTRL_AIE; 2151e3929efSAlexandre Belloni events |= RTC_AF; 2161e3929efSAlexandre Belloni } 2171e3929efSAlexandre Belloni 2181e3929efSAlexandre Belloni if (flags & RV8803_FLAG_UF) { 2191e3929efSAlexandre Belloni flags &= ~RV8803_FLAG_UF; 2201e3929efSAlexandre Belloni rv8803->ctrl &= ~RV8803_CTRL_UIE; 2211e3929efSAlexandre Belloni events |= RTC_UF; 2221e3929efSAlexandre Belloni } 2231e3929efSAlexandre Belloni 2241e3929efSAlexandre Belloni if (events) { 2251e3929efSAlexandre Belloni rtc_update_irq(rv8803->rtc, 1, events); 226d522649eSBenoît Thébaudeau rv8803_write_reg(client, RV8803_FLAG, flags); 227d522649eSBenoît Thébaudeau rv8803_write_reg(rv8803->client, RV8803_CTRL, rv8803->ctrl); 2281e3929efSAlexandre Belloni } 2291e3929efSAlexandre Belloni 2309d1fa4c3SOleksij Rempel mutex_unlock(&rv8803->flags_lock); 2311e3929efSAlexandre Belloni 2321e3929efSAlexandre Belloni return IRQ_HANDLED; 2331e3929efSAlexandre Belloni } 2341e3929efSAlexandre Belloni 2351e3929efSAlexandre Belloni static int rv8803_get_time(struct device *dev, struct rtc_time *tm) 2361e3929efSAlexandre Belloni { 2371e3929efSAlexandre Belloni struct rv8803_data *rv8803 = dev_get_drvdata(dev); 2381e3929efSAlexandre Belloni u8 date1[7]; 2391e3929efSAlexandre Belloni u8 date2[7]; 2401e3929efSAlexandre Belloni u8 *date = date1; 2411e3929efSAlexandre Belloni int ret, flags; 2421e3929efSAlexandre Belloni 243e5c59423SSascha Hauer if (rv8803->alarm_invalid) { 244e5c59423SSascha Hauer dev_warn(dev, "Corruption detected, data may be invalid.\n"); 245e5c59423SSascha Hauer return -EINVAL; 246e5c59423SSascha Hauer } 247e5c59423SSascha Hauer 248d522649eSBenoît Thébaudeau flags = rv8803_read_reg(rv8803->client, RV8803_FLAG); 2491e3929efSAlexandre Belloni if (flags < 0) 2501e3929efSAlexandre Belloni return flags; 2511e3929efSAlexandre Belloni 2521e3929efSAlexandre Belloni if (flags & RV8803_FLAG_V2F) { 2531e3929efSAlexandre Belloni dev_warn(dev, "Voltage low, data is invalid.\n"); 2541e3929efSAlexandre Belloni return -EINVAL; 2551e3929efSAlexandre Belloni } 2561e3929efSAlexandre Belloni 257d522649eSBenoît Thébaudeau ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date); 258d522649eSBenoît Thébaudeau if (ret) 259d522649eSBenoît Thébaudeau return ret; 2601e3929efSAlexandre Belloni 2611e3929efSAlexandre Belloni if ((date1[RV8803_SEC] & 0x7f) == bin2bcd(59)) { 262d522649eSBenoît Thébaudeau ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date2); 263d522649eSBenoît Thébaudeau if (ret) 264d522649eSBenoît Thébaudeau return ret; 2651e3929efSAlexandre Belloni 2661e3929efSAlexandre Belloni if ((date2[RV8803_SEC] & 0x7f) != bin2bcd(59)) 2671e3929efSAlexandre Belloni date = date2; 2681e3929efSAlexandre Belloni } 2691e3929efSAlexandre Belloni 2701e3929efSAlexandre Belloni tm->tm_sec = bcd2bin(date[RV8803_SEC] & 0x7f); 2711e3929efSAlexandre Belloni tm->tm_min = bcd2bin(date[RV8803_MIN] & 0x7f); 2721e3929efSAlexandre Belloni tm->tm_hour = bcd2bin(date[RV8803_HOUR] & 0x3f); 273a1e98e09SBenoît Thébaudeau tm->tm_wday = ilog2(date[RV8803_WEEK] & 0x7f); 2741e3929efSAlexandre Belloni tm->tm_mday = bcd2bin(date[RV8803_DAY] & 0x3f); 2751e3929efSAlexandre Belloni tm->tm_mon = bcd2bin(date[RV8803_MONTH] & 0x1f) - 1; 2761e3929efSAlexandre Belloni tm->tm_year = bcd2bin(date[RV8803_YEAR]) + 100; 2771e3929efSAlexandre Belloni 27896acb25cSBenoît Thébaudeau return 0; 2791e3929efSAlexandre Belloni } 2801e3929efSAlexandre Belloni 2811e3929efSAlexandre Belloni static int rv8803_set_time(struct device *dev, struct rtc_time *tm) 2821e3929efSAlexandre Belloni { 2831e3929efSAlexandre Belloni struct rv8803_data *rv8803 = dev_get_drvdata(dev); 2841e3929efSAlexandre Belloni u8 date[7]; 285d3700b6bSBenoît Thébaudeau int ctrl, flags, ret; 2861e3929efSAlexandre Belloni 287d3700b6bSBenoît Thébaudeau ctrl = rv8803_read_reg(rv8803->client, RV8803_CTRL); 288d3700b6bSBenoît Thébaudeau if (ctrl < 0) 289d3700b6bSBenoît Thébaudeau return ctrl; 290d3700b6bSBenoît Thébaudeau 291d3700b6bSBenoît Thébaudeau /* Stop the clock */ 292d3700b6bSBenoît Thébaudeau ret = rv8803_write_reg(rv8803->client, RV8803_CTRL, 293d3700b6bSBenoît Thébaudeau ctrl | RV8803_CTRL_RESET); 294d3700b6bSBenoît Thébaudeau if (ret) 295d3700b6bSBenoît Thébaudeau return ret; 296d3700b6bSBenoît Thébaudeau 2971e3929efSAlexandre Belloni date[RV8803_SEC] = bin2bcd(tm->tm_sec); 2981e3929efSAlexandre Belloni date[RV8803_MIN] = bin2bcd(tm->tm_min); 2991e3929efSAlexandre Belloni date[RV8803_HOUR] = bin2bcd(tm->tm_hour); 3001e3929efSAlexandre Belloni date[RV8803_WEEK] = 1 << (tm->tm_wday); 3011e3929efSAlexandre Belloni date[RV8803_DAY] = bin2bcd(tm->tm_mday); 3021e3929efSAlexandre Belloni date[RV8803_MONTH] = bin2bcd(tm->tm_mon + 1); 3031e3929efSAlexandre Belloni date[RV8803_YEAR] = bin2bcd(tm->tm_year - 100); 3041e3929efSAlexandre Belloni 305d522649eSBenoît Thébaudeau ret = rv8803_write_regs(rv8803->client, RV8803_SEC, 7, date); 306d522649eSBenoît Thébaudeau if (ret) 3071e3929efSAlexandre Belloni return ret; 3081e3929efSAlexandre Belloni 309d3700b6bSBenoît Thébaudeau /* Restart the clock */ 310d3700b6bSBenoît Thébaudeau ret = rv8803_write_reg(rv8803->client, RV8803_CTRL, 311d3700b6bSBenoît Thébaudeau ctrl & ~RV8803_CTRL_RESET); 312d3700b6bSBenoît Thébaudeau if (ret) 313d3700b6bSBenoît Thébaudeau return ret; 314d3700b6bSBenoît Thébaudeau 3159d1fa4c3SOleksij Rempel mutex_lock(&rv8803->flags_lock); 3161e3929efSAlexandre Belloni 317d522649eSBenoît Thébaudeau flags = rv8803_read_reg(rv8803->client, RV8803_FLAG); 3181e3929efSAlexandre Belloni if (flags < 0) { 3199d1fa4c3SOleksij Rempel mutex_unlock(&rv8803->flags_lock); 3201e3929efSAlexandre Belloni return flags; 3211e3929efSAlexandre Belloni } 3221e3929efSAlexandre Belloni 323e5c59423SSascha Hauer if ((flags & RV8803_FLAG_V2F) || rv8803->alarm_invalid) { 324e5c59423SSascha Hauer /* 325e5c59423SSascha Hauer * If we sense corruption in the alarm registers, but see no 326e5c59423SSascha Hauer * voltage loss flag, we can't rely on other registers having 327e5c59423SSascha Hauer * sensible values. Reset them fully. 328e5c59423SSascha Hauer */ 329e5c59423SSascha Hauer ret = rv8803_regs_reset(rv8803, rv8803->alarm_invalid); 330bb42b7e9SYang Yingliang if (ret) { 331bb42b7e9SYang Yingliang mutex_unlock(&rv8803->flags_lock); 332f8176e0bSAhmad Fatoum return ret; 333f8176e0bSAhmad Fatoum } 334e5c59423SSascha Hauer 335e5c59423SSascha Hauer rv8803->alarm_invalid = false; 336bb42b7e9SYang Yingliang } 337f8176e0bSAhmad Fatoum 338d522649eSBenoît Thébaudeau ret = rv8803_write_reg(rv8803->client, RV8803_FLAG, 3396f367788SBenoît Thébaudeau flags & ~(RV8803_FLAG_V1F | RV8803_FLAG_V2F)); 3401e3929efSAlexandre Belloni 3419d1fa4c3SOleksij Rempel mutex_unlock(&rv8803->flags_lock); 3421e3929efSAlexandre Belloni 3431e3929efSAlexandre Belloni return ret; 3441e3929efSAlexandre Belloni } 3451e3929efSAlexandre Belloni 3461e3929efSAlexandre Belloni static int rv8803_get_alarm(struct device *dev, struct rtc_wkalrm *alrm) 3471e3929efSAlexandre Belloni { 3481e3929efSAlexandre Belloni struct rv8803_data *rv8803 = dev_get_drvdata(dev); 3491e3929efSAlexandre Belloni struct i2c_client *client = rv8803->client; 3501e3929efSAlexandre Belloni u8 alarmvals[3]; 3511e3929efSAlexandre Belloni int flags, ret; 3521e3929efSAlexandre Belloni 353d522649eSBenoît Thébaudeau ret = rv8803_read_regs(client, RV8803_ALARM_MIN, 3, alarmvals); 354d522649eSBenoît Thébaudeau if (ret) 355d522649eSBenoît Thébaudeau return ret; 3561e3929efSAlexandre Belloni 357d522649eSBenoît Thébaudeau flags = rv8803_read_reg(client, RV8803_FLAG); 3581e3929efSAlexandre Belloni if (flags < 0) 3591e3929efSAlexandre Belloni return flags; 3601e3929efSAlexandre Belloni 361e5c59423SSascha Hauer alarmvals[0] &= 0x7f; 362e5c59423SSascha Hauer alarmvals[1] &= 0x3f; 363e5c59423SSascha Hauer alarmvals[2] &= 0x3f; 364e5c59423SSascha Hauer 365e5c59423SSascha Hauer if (!bcd_is_valid(alarmvals[0]) || 366e5c59423SSascha Hauer !bcd_is_valid(alarmvals[1]) || 367e5c59423SSascha Hauer !bcd_is_valid(alarmvals[2])) 368e5c59423SSascha Hauer goto err_invalid; 369e5c59423SSascha Hauer 3701e3929efSAlexandre Belloni alrm->time.tm_sec = 0; 371e5c59423SSascha Hauer alrm->time.tm_min = bcd2bin(alarmvals[0]); 372e5c59423SSascha Hauer alrm->time.tm_hour = bcd2bin(alarmvals[1]); 373e5c59423SSascha Hauer alrm->time.tm_mday = bcd2bin(alarmvals[2]); 3741e3929efSAlexandre Belloni 3751e3929efSAlexandre Belloni alrm->enabled = !!(rv8803->ctrl & RV8803_CTRL_AIE); 3761e3929efSAlexandre Belloni alrm->pending = (flags & RV8803_FLAG_AF) && alrm->enabled; 3771e3929efSAlexandre Belloni 378e5c59423SSascha Hauer if ((unsigned int)alrm->time.tm_mday > 31 || 379e5c59423SSascha Hauer (unsigned int)alrm->time.tm_hour >= 24 || 380e5c59423SSascha Hauer (unsigned int)alrm->time.tm_min >= 60) 381e5c59423SSascha Hauer goto err_invalid; 382e5c59423SSascha Hauer 3831e3929efSAlexandre Belloni return 0; 384e5c59423SSascha Hauer 385e5c59423SSascha Hauer err_invalid: 386e5c59423SSascha Hauer rv8803->alarm_invalid = true; 387e5c59423SSascha Hauer return -EINVAL; 3881e3929efSAlexandre Belloni } 3891e3929efSAlexandre Belloni 3901e3929efSAlexandre Belloni static int rv8803_set_alarm(struct device *dev, struct rtc_wkalrm *alrm) 3911e3929efSAlexandre Belloni { 3921e3929efSAlexandre Belloni struct i2c_client *client = to_i2c_client(dev); 3931e3929efSAlexandre Belloni struct rv8803_data *rv8803 = dev_get_drvdata(dev); 3941e3929efSAlexandre Belloni u8 alarmvals[3]; 3951e3929efSAlexandre Belloni u8 ctrl[2]; 3961e3929efSAlexandre Belloni int ret, err; 3971e3929efSAlexandre Belloni 3981e3929efSAlexandre Belloni /* The alarm has no seconds, round up to nearest minute */ 3991e3929efSAlexandre Belloni if (alrm->time.tm_sec) { 4001e3929efSAlexandre Belloni time64_t alarm_time = rtc_tm_to_time64(&alrm->time); 4011e3929efSAlexandre Belloni 4021e3929efSAlexandre Belloni alarm_time += 60 - alrm->time.tm_sec; 4031e3929efSAlexandre Belloni rtc_time64_to_tm(alarm_time, &alrm->time); 4041e3929efSAlexandre Belloni } 4051e3929efSAlexandre Belloni 4069d1fa4c3SOleksij Rempel mutex_lock(&rv8803->flags_lock); 4071e3929efSAlexandre Belloni 408d522649eSBenoît Thébaudeau ret = rv8803_read_regs(client, RV8803_FLAG, 2, ctrl); 409d522649eSBenoît Thébaudeau if (ret) { 4109d1fa4c3SOleksij Rempel mutex_unlock(&rv8803->flags_lock); 411d522649eSBenoît Thébaudeau return ret; 4121e3929efSAlexandre Belloni } 4131e3929efSAlexandre Belloni 4141e3929efSAlexandre Belloni alarmvals[0] = bin2bcd(alrm->time.tm_min); 4151e3929efSAlexandre Belloni alarmvals[1] = bin2bcd(alrm->time.tm_hour); 4161e3929efSAlexandre Belloni alarmvals[2] = bin2bcd(alrm->time.tm_mday); 4171e3929efSAlexandre Belloni 4181e3929efSAlexandre Belloni if (rv8803->ctrl & (RV8803_CTRL_AIE | RV8803_CTRL_UIE)) { 4191e3929efSAlexandre Belloni rv8803->ctrl &= ~(RV8803_CTRL_AIE | RV8803_CTRL_UIE); 420d522649eSBenoît Thébaudeau err = rv8803_write_reg(rv8803->client, RV8803_CTRL, 4211e3929efSAlexandre Belloni rv8803->ctrl); 4221e3929efSAlexandre Belloni if (err) { 4239d1fa4c3SOleksij Rempel mutex_unlock(&rv8803->flags_lock); 4241e3929efSAlexandre Belloni return err; 4251e3929efSAlexandre Belloni } 4261e3929efSAlexandre Belloni } 4271e3929efSAlexandre Belloni 42803a86cdaSDominique Martinet ctrl[0] &= ~RV8803_FLAG_AF; 42903a86cdaSDominique Martinet err = rv8803_write_reg(rv8803->client, RV8803_FLAG, ctrl[0]); 4309d1fa4c3SOleksij Rempel mutex_unlock(&rv8803->flags_lock); 4311e3929efSAlexandre Belloni if (err) 4321e3929efSAlexandre Belloni return err; 4331e3929efSAlexandre Belloni 434d522649eSBenoît Thébaudeau err = rv8803_write_regs(rv8803->client, RV8803_ALARM_MIN, 3, alarmvals); 4351e3929efSAlexandre Belloni if (err) 4361e3929efSAlexandre Belloni return err; 4371e3929efSAlexandre Belloni 4381e3929efSAlexandre Belloni if (alrm->enabled) { 4391e3929efSAlexandre Belloni if (rv8803->rtc->uie_rtctimer.enabled) 4401e3929efSAlexandre Belloni rv8803->ctrl |= RV8803_CTRL_UIE; 4411e3929efSAlexandre Belloni if (rv8803->rtc->aie_timer.enabled) 4421e3929efSAlexandre Belloni rv8803->ctrl |= RV8803_CTRL_AIE; 4431e3929efSAlexandre Belloni 444d522649eSBenoît Thébaudeau err = rv8803_write_reg(rv8803->client, RV8803_CTRL, 4451e3929efSAlexandre Belloni rv8803->ctrl); 4461e3929efSAlexandre Belloni if (err) 4471e3929efSAlexandre Belloni return err; 4481e3929efSAlexandre Belloni } 4491e3929efSAlexandre Belloni 4501e3929efSAlexandre Belloni return 0; 4511e3929efSAlexandre Belloni } 4521e3929efSAlexandre Belloni 4531e3929efSAlexandre Belloni static int rv8803_alarm_irq_enable(struct device *dev, unsigned int enabled) 4541e3929efSAlexandre Belloni { 4551e3929efSAlexandre Belloni struct i2c_client *client = to_i2c_client(dev); 4561e3929efSAlexandre Belloni struct rv8803_data *rv8803 = dev_get_drvdata(dev); 4571e3929efSAlexandre Belloni int ctrl, flags, err; 4581e3929efSAlexandre Belloni 4591e3929efSAlexandre Belloni ctrl = rv8803->ctrl; 4601e3929efSAlexandre Belloni 4611e3929efSAlexandre Belloni if (enabled) { 4621e3929efSAlexandre Belloni if (rv8803->rtc->uie_rtctimer.enabled) 4631e3929efSAlexandre Belloni ctrl |= RV8803_CTRL_UIE; 4641e3929efSAlexandre Belloni if (rv8803->rtc->aie_timer.enabled) 4651e3929efSAlexandre Belloni ctrl |= RV8803_CTRL_AIE; 4661e3929efSAlexandre Belloni } else { 4671e3929efSAlexandre Belloni if (!rv8803->rtc->uie_rtctimer.enabled) 4681e3929efSAlexandre Belloni ctrl &= ~RV8803_CTRL_UIE; 4691e3929efSAlexandre Belloni if (!rv8803->rtc->aie_timer.enabled) 4701e3929efSAlexandre Belloni ctrl &= ~RV8803_CTRL_AIE; 4711e3929efSAlexandre Belloni } 4721e3929efSAlexandre Belloni 4739d1fa4c3SOleksij Rempel mutex_lock(&rv8803->flags_lock); 474d522649eSBenoît Thébaudeau flags = rv8803_read_reg(client, RV8803_FLAG); 4751e3929efSAlexandre Belloni if (flags < 0) { 4769d1fa4c3SOleksij Rempel mutex_unlock(&rv8803->flags_lock); 4771e3929efSAlexandre Belloni return flags; 4781e3929efSAlexandre Belloni } 4791e3929efSAlexandre Belloni flags &= ~(RV8803_FLAG_AF | RV8803_FLAG_UF); 480d522649eSBenoît Thébaudeau err = rv8803_write_reg(client, RV8803_FLAG, flags); 4819d1fa4c3SOleksij Rempel mutex_unlock(&rv8803->flags_lock); 4821e3929efSAlexandre Belloni if (err) 4831e3929efSAlexandre Belloni return err; 4841e3929efSAlexandre Belloni 4851e3929efSAlexandre Belloni if (ctrl != rv8803->ctrl) { 4861e3929efSAlexandre Belloni rv8803->ctrl = ctrl; 487d522649eSBenoît Thébaudeau err = rv8803_write_reg(client, RV8803_CTRL, rv8803->ctrl); 4881e3929efSAlexandre Belloni if (err) 4891e3929efSAlexandre Belloni return err; 4901e3929efSAlexandre Belloni } 4911e3929efSAlexandre Belloni 4921e3929efSAlexandre Belloni return 0; 4931e3929efSAlexandre Belloni } 4941e3929efSAlexandre Belloni 4951e3929efSAlexandre Belloni static int rv8803_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 4961e3929efSAlexandre Belloni { 4971e3929efSAlexandre Belloni struct i2c_client *client = to_i2c_client(dev); 4981e3929efSAlexandre Belloni struct rv8803_data *rv8803 = dev_get_drvdata(dev); 499bcd17c50SAlexandre Belloni unsigned int vl = 0; 5001e3929efSAlexandre Belloni int flags, ret = 0; 5011e3929efSAlexandre Belloni 5021e3929efSAlexandre Belloni switch (cmd) { 5031e3929efSAlexandre Belloni case RTC_VL_READ: 504d522649eSBenoît Thébaudeau flags = rv8803_read_reg(client, RV8803_FLAG); 5051e3929efSAlexandre Belloni if (flags < 0) 5061e3929efSAlexandre Belloni return flags; 5071e3929efSAlexandre Belloni 508bcd17c50SAlexandre Belloni if (flags & RV8803_FLAG_V1F) { 5091e3929efSAlexandre Belloni dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n"); 510bcd17c50SAlexandre Belloni vl = RTC_VL_ACCURACY_LOW; 511bcd17c50SAlexandre Belloni } 5121e3929efSAlexandre Belloni 5131e3929efSAlexandre Belloni if (flags & RV8803_FLAG_V2F) 514bcd17c50SAlexandre Belloni vl |= RTC_VL_DATA_INVALID; 5151e3929efSAlexandre Belloni 516bcd17c50SAlexandre Belloni return put_user(vl, (unsigned int __user *)arg); 5171e3929efSAlexandre Belloni 5181e3929efSAlexandre Belloni case RTC_VL_CLR: 5199d1fa4c3SOleksij Rempel mutex_lock(&rv8803->flags_lock); 520d522649eSBenoît Thébaudeau flags = rv8803_read_reg(client, RV8803_FLAG); 5211e3929efSAlexandre Belloni if (flags < 0) { 5229d1fa4c3SOleksij Rempel mutex_unlock(&rv8803->flags_lock); 5231e3929efSAlexandre Belloni return flags; 5241e3929efSAlexandre Belloni } 5251e3929efSAlexandre Belloni 5267e890a0fSAlexandre Belloni flags &= ~RV8803_FLAG_V1F; 527d522649eSBenoît Thébaudeau ret = rv8803_write_reg(client, RV8803_FLAG, flags); 5289d1fa4c3SOleksij Rempel mutex_unlock(&rv8803->flags_lock); 529d522649eSBenoît Thébaudeau if (ret) 5301e3929efSAlexandre Belloni return ret; 5311e3929efSAlexandre Belloni 5321e3929efSAlexandre Belloni return 0; 5331e3929efSAlexandre Belloni 5341e3929efSAlexandre Belloni default: 5351e3929efSAlexandre Belloni return -ENOIOCTLCMD; 5361e3929efSAlexandre Belloni } 5371e3929efSAlexandre Belloni } 5381e3929efSAlexandre Belloni 53916d70a78SAlexandre Belloni static int rv8803_nvram_write(void *priv, unsigned int offset, void *val, 54016d70a78SAlexandre Belloni size_t bytes) 5411e3929efSAlexandre Belloni { 542179b4bccSLiu Shixin return rv8803_write_reg(priv, RV8803_RAM, *(u8 *)val); 5431e3929efSAlexandre Belloni } 5441e3929efSAlexandre Belloni 54516d70a78SAlexandre Belloni static int rv8803_nvram_read(void *priv, unsigned int offset, 54616d70a78SAlexandre Belloni void *val, size_t bytes) 5471e3929efSAlexandre Belloni { 5481e3929efSAlexandre Belloni int ret; 5491e3929efSAlexandre Belloni 55016d70a78SAlexandre Belloni ret = rv8803_read_reg(priv, RV8803_RAM); 5511e3929efSAlexandre Belloni if (ret < 0) 5521e3929efSAlexandre Belloni return ret; 5531e3929efSAlexandre Belloni 55416d70a78SAlexandre Belloni *(u8 *)val = ret; 5551e3929efSAlexandre Belloni 55616d70a78SAlexandre Belloni return 0; 5571e3929efSAlexandre Belloni } 5581e3929efSAlexandre Belloni 55945909e5cSAlexandre Belloni static const struct rtc_class_ops rv8803_rtc_ops = { 5601e3929efSAlexandre Belloni .read_time = rv8803_get_time, 5611e3929efSAlexandre Belloni .set_time = rv8803_set_time, 5621e3929efSAlexandre Belloni .ioctl = rv8803_ioctl, 56345909e5cSAlexandre Belloni .read_alarm = rv8803_get_alarm, 56445909e5cSAlexandre Belloni .set_alarm = rv8803_set_alarm, 56545909e5cSAlexandre Belloni .alarm_irq_enable = rv8803_alarm_irq_enable, 5661e3929efSAlexandre Belloni }; 5671e3929efSAlexandre Belloni 5681cd71376SOleksij Rempel static int rx8900_trickle_charger_init(struct rv8803_data *rv8803) 5691cd71376SOleksij Rempel { 5701cd71376SOleksij Rempel struct i2c_client *client = rv8803->client; 5711cd71376SOleksij Rempel struct device_node *node = client->dev.of_node; 5721cd71376SOleksij Rempel int err; 5731cd71376SOleksij Rempel u8 flags; 5741cd71376SOleksij Rempel 5751cd71376SOleksij Rempel if (!node) 5761cd71376SOleksij Rempel return 0; 5771cd71376SOleksij Rempel 5781cd71376SOleksij Rempel if (rv8803->type != rx_8900) 5791cd71376SOleksij Rempel return 0; 5801cd71376SOleksij Rempel 5811cd71376SOleksij Rempel err = i2c_smbus_read_byte_data(rv8803->client, RX8900_BACKUP_CTRL); 5821cd71376SOleksij Rempel if (err < 0) 5831cd71376SOleksij Rempel return err; 5841cd71376SOleksij Rempel 5858c798e1eSAhmad Fatoum flags = (u8)err; 5868c798e1eSAhmad Fatoum flags &= ~(RX8900_FLAG_VDETOFF | RX8900_FLAG_SWOFF); 5878c798e1eSAhmad Fatoum flags |= rv8803->backup; 5881cd71376SOleksij Rempel 5891cd71376SOleksij Rempel return i2c_smbus_write_byte_data(rv8803->client, RX8900_BACKUP_CTRL, 5901cd71376SOleksij Rempel flags); 5911cd71376SOleksij Rempel } 5921cd71376SOleksij Rempel 5938c798e1eSAhmad Fatoum /* configure registers with values different than the Power-On reset defaults */ 5948c798e1eSAhmad Fatoum static int rv8803_regs_configure(struct rv8803_data *rv8803) 5958c798e1eSAhmad Fatoum { 5968c798e1eSAhmad Fatoum int err; 5978c798e1eSAhmad Fatoum 5988c798e1eSAhmad Fatoum err = rv8803_write_reg(rv8803->client, RV8803_EXT, RV8803_EXT_WADA); 5998c798e1eSAhmad Fatoum if (err) 6008c798e1eSAhmad Fatoum return err; 6018c798e1eSAhmad Fatoum 6028c798e1eSAhmad Fatoum err = rx8900_trickle_charger_init(rv8803); 6038c798e1eSAhmad Fatoum if (err) { 6048c798e1eSAhmad Fatoum dev_err(&rv8803->client->dev, "failed to init charger\n"); 6058c798e1eSAhmad Fatoum return err; 6068c798e1eSAhmad Fatoum } 6078c798e1eSAhmad Fatoum 6088c798e1eSAhmad Fatoum return 0; 6098c798e1eSAhmad Fatoum } 6108c798e1eSAhmad Fatoum 611*2f80de65SStefan Eichenberger static int rv8803_resume(struct device *dev) 612*2f80de65SStefan Eichenberger { 613*2f80de65SStefan Eichenberger struct rv8803_data *rv8803 = dev_get_drvdata(dev); 614*2f80de65SStefan Eichenberger 615*2f80de65SStefan Eichenberger if (rv8803->client->irq > 0 && device_may_wakeup(dev)) 616*2f80de65SStefan Eichenberger disable_irq_wake(rv8803->client->irq); 617*2f80de65SStefan Eichenberger 618*2f80de65SStefan Eichenberger return 0; 619*2f80de65SStefan Eichenberger } 620*2f80de65SStefan Eichenberger 621*2f80de65SStefan Eichenberger static int rv8803_suspend(struct device *dev) 622*2f80de65SStefan Eichenberger { 623*2f80de65SStefan Eichenberger struct rv8803_data *rv8803 = dev_get_drvdata(dev); 624*2f80de65SStefan Eichenberger 625*2f80de65SStefan Eichenberger if (rv8803->client->irq > 0 && device_may_wakeup(dev)) 626*2f80de65SStefan Eichenberger enable_irq_wake(rv8803->client->irq); 627*2f80de65SStefan Eichenberger 628*2f80de65SStefan Eichenberger return 0; 629*2f80de65SStefan Eichenberger } 630*2f80de65SStefan Eichenberger 631*2f80de65SStefan Eichenberger static DEFINE_SIMPLE_DEV_PM_OPS(rv8803_pm_ops, rv8803_suspend, rv8803_resume); 632*2f80de65SStefan Eichenberger 63384c2fb38SUwe Kleine-König static const struct i2c_device_id rv8803_id[] = { 63484c2fb38SUwe Kleine-König { "rv8803", rv_8803 }, 63584c2fb38SUwe Kleine-König { "rv8804", rx_8804 }, 63684c2fb38SUwe Kleine-König { "rx8803", rx_8803 }, 63784c2fb38SUwe Kleine-König { "rx8900", rx_8900 }, 63884c2fb38SUwe Kleine-König { } 63984c2fb38SUwe Kleine-König }; 64084c2fb38SUwe Kleine-König MODULE_DEVICE_TABLE(i2c, rv8803_id); 64184c2fb38SUwe Kleine-König 64284c2fb38SUwe Kleine-König static int rv8803_probe(struct i2c_client *client) 6431e3929efSAlexandre Belloni { 6445cb17269SWolfram Sang struct i2c_adapter *adapter = client->adapter; 6451e3929efSAlexandre Belloni struct rv8803_data *rv8803; 646d522649eSBenoît Thébaudeau int err, flags; 647c07fd9deSAlexandre Belloni struct nvmem_config nvmem_cfg = { 648c07fd9deSAlexandre Belloni .name = "rv8803_nvram", 649c07fd9deSAlexandre Belloni .word_size = 1, 650c07fd9deSAlexandre Belloni .stride = 1, 651c07fd9deSAlexandre Belloni .size = 1, 652c07fd9deSAlexandre Belloni .reg_read = rv8803_nvram_read, 653c07fd9deSAlexandre Belloni .reg_write = rv8803_nvram_write, 654c07fd9deSAlexandre Belloni .priv = client, 655c07fd9deSAlexandre Belloni }; 6561e3929efSAlexandre Belloni 6571e3929efSAlexandre Belloni if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | 6581e3929efSAlexandre Belloni I2C_FUNC_SMBUS_I2C_BLOCK)) { 6591e3929efSAlexandre Belloni dev_err(&adapter->dev, "doesn't support I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK\n"); 6601e3929efSAlexandre Belloni return -EIO; 6611e3929efSAlexandre Belloni } 6621e3929efSAlexandre Belloni 6631e3929efSAlexandre Belloni rv8803 = devm_kzalloc(&client->dev, sizeof(struct rv8803_data), 6641e3929efSAlexandre Belloni GFP_KERNEL); 6651e3929efSAlexandre Belloni if (!rv8803) 6661e3929efSAlexandre Belloni return -ENOMEM; 6671e3929efSAlexandre Belloni 6689d1fa4c3SOleksij Rempel mutex_init(&rv8803->flags_lock); 6691e3929efSAlexandre Belloni rv8803->client = client; 67084c2fb38SUwe Kleine-König if (client->dev.of_node) { 671fbbeae0aSKrzysztof Kozlowski rv8803->type = (uintptr_t)of_device_get_match_data(&client->dev); 67284c2fb38SUwe Kleine-König } else { 67384c2fb38SUwe Kleine-König const struct i2c_device_id *id = i2c_match_id(rv8803_id, client); 67484c2fb38SUwe Kleine-König 6751cd71376SOleksij Rempel rv8803->type = id->driver_data; 67684c2fb38SUwe Kleine-König } 6771e3929efSAlexandre Belloni i2c_set_clientdata(client, rv8803); 6781e3929efSAlexandre Belloni 679d522649eSBenoît Thébaudeau flags = rv8803_read_reg(client, RV8803_FLAG); 6801e3929efSAlexandre Belloni if (flags < 0) 6811e3929efSAlexandre Belloni return flags; 6821e3929efSAlexandre Belloni 6831e3929efSAlexandre Belloni if (flags & RV8803_FLAG_V1F) 6841e3929efSAlexandre Belloni dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n"); 6851e3929efSAlexandre Belloni 6861e3929efSAlexandre Belloni if (flags & RV8803_FLAG_V2F) 6871e3929efSAlexandre Belloni dev_warn(&client->dev, "Voltage low, data loss detected.\n"); 6881e3929efSAlexandre Belloni 6891e3929efSAlexandre Belloni if (flags & RV8803_FLAG_AF) 6901e3929efSAlexandre Belloni dev_warn(&client->dev, "An alarm maybe have been missed.\n"); 6911e3929efSAlexandre Belloni 6927133eca1SAlexandre Belloni rv8803->rtc = devm_rtc_allocate_device(&client->dev); 69344c638ceSAlexandre Belloni if (IS_ERR(rv8803->rtc)) 6947133eca1SAlexandre Belloni return PTR_ERR(rv8803->rtc); 6957133eca1SAlexandre Belloni 6961e3929efSAlexandre Belloni if (client->irq > 0) { 69711bfd6fcSAlexandre Belloni unsigned long irqflags = IRQF_TRIGGER_LOW; 69811bfd6fcSAlexandre Belloni 69911bfd6fcSAlexandre Belloni if (dev_fwnode(&client->dev)) 70011bfd6fcSAlexandre Belloni irqflags = 0; 70111bfd6fcSAlexandre Belloni 7021e3929efSAlexandre Belloni err = devm_request_threaded_irq(&client->dev, client->irq, 7031e3929efSAlexandre Belloni NULL, rv8803_handle_irq, 70411bfd6fcSAlexandre Belloni irqflags | IRQF_ONESHOT, 7051e3929efSAlexandre Belloni "rv8803", client); 7061e3929efSAlexandre Belloni if (err) { 7071e3929efSAlexandre Belloni dev_warn(&client->dev, "unable to request IRQ, alarms disabled\n"); 7081e3929efSAlexandre Belloni client->irq = 0; 709*2f80de65SStefan Eichenberger } else { 710*2f80de65SStefan Eichenberger device_init_wakeup(&client->dev, true); 711*2f80de65SStefan Eichenberger err = dev_pm_set_wake_irq(&client->dev, client->irq); 712*2f80de65SStefan Eichenberger if (err) 713*2f80de65SStefan Eichenberger dev_err(&client->dev, "failed to set wake IRQ\n"); 7141e3929efSAlexandre Belloni } 7151e3929efSAlexandre Belloni } 71645909e5cSAlexandre Belloni if (!client->irq) 71745909e5cSAlexandre Belloni clear_bit(RTC_FEATURE_ALARM, rv8803->rtc->features); 7181e3929efSAlexandre Belloni 7198c798e1eSAhmad Fatoum if (of_property_read_bool(client->dev.of_node, "epson,vdet-disable")) 7208c798e1eSAhmad Fatoum rv8803->backup |= RX8900_FLAG_VDETOFF; 7218c798e1eSAhmad Fatoum 7228c798e1eSAhmad Fatoum if (of_property_read_bool(client->dev.of_node, "trickle-diode-disable")) 7238c798e1eSAhmad Fatoum rv8803->backup |= RX8900_FLAG_SWOFF; 7248c798e1eSAhmad Fatoum 7258c798e1eSAhmad Fatoum err = rv8803_regs_configure(rv8803); 7261e3929efSAlexandre Belloni if (err) 7271e3929efSAlexandre Belloni return err; 7281e3929efSAlexandre Belloni 729ce1ae8ebSAlexandre Belloni rv8803->rtc->ops = &rv8803_rtc_ops; 7302e17f8b9SAlexandre Belloni rv8803->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000; 7312e17f8b9SAlexandre Belloni rv8803->rtc->range_max = RTC_TIMESTAMP_END_2099; 732fdcfd854SBartosz Golaszewski err = devm_rtc_register_device(rv8803->rtc); 733ce1ae8ebSAlexandre Belloni if (err) 734ce1ae8ebSAlexandre Belloni return err; 735ce1ae8ebSAlexandre Belloni 7363a905c2dSBartosz Golaszewski devm_rtc_nvmem_register(rv8803->rtc, &nvmem_cfg); 737ce1ae8ebSAlexandre Belloni 7381e3929efSAlexandre Belloni rv8803->rtc->max_user_freq = 1; 7391e3929efSAlexandre Belloni 7401e3929efSAlexandre Belloni return 0; 7411e3929efSAlexandre Belloni } 7421e3929efSAlexandre Belloni 743da826321SAlexandre Belloni static const __maybe_unused struct of_device_id rv8803_of_match[] = { 744740ad8f4SJavier Martinez Canillas { 745740ad8f4SJavier Martinez Canillas .compatible = "microcrystal,rv8803", 746c856618dSAlexandre Belloni .data = (void *)rv_8803 747740ad8f4SJavier Martinez Canillas }, 748740ad8f4SJavier Martinez Canillas { 749ac771ed7SAlexandre Belloni .compatible = "epson,rx8803", 750c27fee16SAhmad Fatoum .data = (void *)rx_8803 751ac771ed7SAlexandre Belloni }, 752ac771ed7SAlexandre Belloni { 7535c0189a8SFabio Estevam .compatible = "epson,rx8804", 7545c0189a8SFabio Estevam .data = (void *)rx_8804 7555c0189a8SFabio Estevam }, 7565c0189a8SFabio Estevam { 757740ad8f4SJavier Martinez Canillas .compatible = "epson,rx8900", 758740ad8f4SJavier Martinez Canillas .data = (void *)rx_8900 759740ad8f4SJavier Martinez Canillas }, 760740ad8f4SJavier Martinez Canillas { } 761740ad8f4SJavier Martinez Canillas }; 762740ad8f4SJavier Martinez Canillas MODULE_DEVICE_TABLE(of, rv8803_of_match); 763740ad8f4SJavier Martinez Canillas 7641e3929efSAlexandre Belloni static struct i2c_driver rv8803_driver = { 7651e3929efSAlexandre Belloni .driver = { 7661e3929efSAlexandre Belloni .name = "rtc-rv8803", 767740ad8f4SJavier Martinez Canillas .of_match_table = of_match_ptr(rv8803_of_match), 768*2f80de65SStefan Eichenberger .pm = &rv8803_pm_ops, 7691e3929efSAlexandre Belloni }, 77031b0cecbSUwe Kleine-König .probe = rv8803_probe, 7711e3929efSAlexandre Belloni .id_table = rv8803_id, 7721e3929efSAlexandre Belloni }; 7731e3929efSAlexandre Belloni module_i2c_driver(rv8803_driver); 7741e3929efSAlexandre Belloni 7757d1e5bfeSAlexandre Belloni MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@bootlin.com>"); 7761e3929efSAlexandre Belloni MODULE_DESCRIPTION("Micro Crystal RV8803 RTC driver"); 7771e3929efSAlexandre Belloni MODULE_LICENSE("GPL v2"); 778