kernel/drivers/rtc/rtc-abx80x.c

   1 /*
   2  * A driver for the I2C members of the Abracon AB x8xx RTC family,
   3  * and compatible: AB 1805 and AB 0805
   4  *
   5  * Copyright 2014-2015 Macq S.A.
   6  *
   7  * Author: Philippe De Muyter <phdm@macqel.be>
   8  * Author: Alexandre Belloni <alexandre.belloni@free-electrons.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  *
  14  */
  15
  16 #include <linux/bcd.h>
  17 #include <linux/i2c.h>
  18 #include <linux/module.h>
  19 #include <linux/rtc.h>
  20
  21 #define ABX8XX_REG_HTH          0x00
  22 #define ABX8XX_REG_SC           0x01
  23 #define ABX8XX_REG_MN           0x02
  24 #define ABX8XX_REG_HR           0x03
  25 #define ABX8XX_REG_DA           0x04
  26 #define ABX8XX_REG_MO           0x05
  27 #define ABX8XX_REG_YR           0x06
  28 #define ABX8XX_REG_WD           0x07
  29
  30 #define ABX8XX_REG_CTRL1        0x10
  31 #define ABX8XX_CTRL_WRITE       BIT(1)
  32 #define ABX8XX_CTRL_12_24       BIT(6)
  33
  34 #define ABX8XX_REG_CFG_KEY      0x1f
  35 #define ABX8XX_CFG_KEY_MISC     0x9d
  36
  37 #define ABX8XX_REG_ID0          0x28
  38
  39 #define ABX8XX_REG_TRICKLE      0x20
  40 #define ABX8XX_TRICKLE_CHARGE_ENABLE    0xa0
  41 #define ABX8XX_TRICKLE_STANDARD_DIODE   0x8
  42 #define ABX8XX_TRICKLE_SCHOTTKY_DIODE   0x4
  43
  44 static u8 trickle_resistors[] = {0, 3, 6, 11};
  45
  46 enum abx80x_chip {AB0801, AB0803, AB0804, AB0805,
  47         AB1801, AB1803, AB1804, AB1805, ABX80X};
  48
  49 struct abx80x_cap {
  50         u16 pn;
  51         bool has_tc;
  52 };
  53
  54 static struct abx80x_cap abx80x_caps[] = {
  55         [AB0801] = {.pn = 0x0801},
  56         [AB0803] = {.pn = 0x0803},
  57         [AB0804] = {.pn = 0x0804, .has_tc = true},
  58         [AB0805] = {.pn = 0x0805, .has_tc = true},
  59         [AB1801] = {.pn = 0x1801},
  60         [AB1803] = {.pn = 0x1803},
  61         [AB1804] = {.pn = 0x1804, .has_tc = true},
  62         [AB1805] = {.pn = 0x1805, .has_tc = true},
  63         [ABX80X] = {.pn = 0}
  64 };
  65
  66 static struct i2c_driver abx80x_driver;
  67
  68 static int abx80x_enable_trickle_charger(struct i2c_client *client,
  69                                          u8 trickle_cfg)
  70 {
  71         int err;
  72
  73         /*
  74          * Write the configuration key register to enable access to the Trickle
  75          * register
  76          */
  77         err = i2c_smbus_write_byte_data(client, ABX8XX_REG_CFG_KEY,
  78                                         ABX8XX_CFG_KEY_MISC);
  79         if (err < 0) {
  80                 dev_err(&client->dev, "Unable to write configuration key\n");
  81                 return -EIO;
  82         }
  83
  84         err = i2c_smbus_write_byte_data(client, ABX8XX_REG_TRICKLE,
  85                                         ABX8XX_TRICKLE_CHARGE_ENABLE |
  86                                         trickle_cfg);
  87         if (err < 0) {
  88                 dev_err(&client->dev, "Unable to write trickle register\n");
  89                 return -EIO;
  90         }
  91
  92         return 0;
  93 }
  94
  95 static int abx80x_rtc_read_time(struct device *dev, struct rtc_time *tm)
  96 {
  97         struct i2c_client *client = to_i2c_client(dev);
  98         unsigned char buf[8];
  99         int err;
 100
 101         err = i2c_smbus_read_i2c_block_data(client, ABX8XX_REG_HTH,
 102                                             sizeof(buf), buf);
 103         if (err < 0) {
 104                 dev_err(&client->dev, "Unable to read date\n");
 105                 return -EIO;
 106         }
 107
 108         tm->tm_sec = bcd2bin(buf[ABX8XX_REG_SC] & 0x7F);
 109         tm->tm_min = bcd2bin(buf[ABX8XX_REG_MN] & 0x7F);
 110         tm->tm_hour = bcd2bin(buf[ABX8XX_REG_HR] & 0x3F);
 111         tm->tm_wday = buf[ABX8XX_REG_WD] & 0x7;
 112         tm->tm_mday = bcd2bin(buf[ABX8XX_REG_DA] & 0x3F);
 113         tm->tm_mon = bcd2bin(buf[ABX8XX_REG_MO] & 0x1F) - 1;
 114         tm->tm_year = bcd2bin(buf[ABX8XX_REG_YR]) + 100;
 115
 116         err = rtc_valid_tm(tm);
 117         if (err < 0)
 118                 dev_err(&client->dev, "retrieved date/time is not valid.\n");
 119
 120         return err;
 121 }
 122
 123 static int abx80x_rtc_set_time(struct device *dev, struct rtc_time *tm)
 124 {
 125         struct i2c_client *client = to_i2c_client(dev);
 126         unsigned char buf[8];
 127         int err;
 128
 129         if (tm->tm_year < 100)
 130                 return -EINVAL;
 131
 132         buf[ABX8XX_REG_HTH] = 0;
 133         buf[ABX8XX_REG_SC] = bin2bcd(tm->tm_sec);
 134         buf[ABX8XX_REG_MN] = bin2bcd(tm->tm_min);
 135         buf[ABX8XX_REG_HR] = bin2bcd(tm->tm_hour);
 136         buf[ABX8XX_REG_DA] = bin2bcd(tm->tm_mday);
 137         buf[ABX8XX_REG_MO] = bin2bcd(tm->tm_mon + 1);
 138         buf[ABX8XX_REG_YR] = bin2bcd(tm->tm_year - 100);
 139         buf[ABX8XX_REG_WD] = tm->tm_wday;
 140
 141         err = i2c_smbus_write_i2c_block_data(client, ABX8XX_REG_HTH,
 142                                              sizeof(buf), buf);
 143         if (err < 0) {
 144                 dev_err(&client->dev, "Unable to write to date registers\n");
 145                 return -EIO;
 146         }
 147
 148         return 0;
 149 }
 150
 151 static const struct rtc_class_ops abx80x_rtc_ops = {
 152         .read_time      = abx80x_rtc_read_time,
 153         .set_time       = abx80x_rtc_set_time,
 154 };
 155
 156 static int abx80x_dt_trickle_cfg(struct device_node *np)
 157 {
 158         const char *diode;
 159         int trickle_cfg = 0;
 160         int i, ret;
 161         u32 tmp;
 162
 163         ret = of_property_read_string(np, "abracon,tc-diode", &diode);
 164         if (ret)
 165                 return ret;
 166
 167         if (!strcmp(diode, "standard"))
 168                 trickle_cfg |= ABX8XX_TRICKLE_STANDARD_DIODE;
 169         else if (!strcmp(diode, "schottky"))
 170                 trickle_cfg |= ABX8XX_TRICKLE_SCHOTTKY_DIODE;
 171         else
 172                 return -EINVAL;
 173
 174         ret = of_property_read_u32(np, "abracon,tc-resistor", &tmp);
 175         if (ret)
 176                 return ret;
 177
 178         for (i = 0; i < sizeof(trickle_resistors); i++)
 179                 if (trickle_resistors[i] == tmp)
 180                         break;
 181
 182         if (i == sizeof(trickle_resistors))
 183                 return -EINVAL;
 184
 185         return (trickle_cfg | i);
 186 }
 187
 188 static int abx80x_probe(struct i2c_client *client,
 189                         const struct i2c_device_id *id)
 190 {
 191         struct device_node *np = client->dev.of_node;
 192         struct rtc_device *rtc;
 193         int i, data, err, trickle_cfg = -EINVAL;
 194         char buf[7];
 195         unsigned int part = id->driver_data;
 196         unsigned int partnumber;
 197         unsigned int majrev, minrev;
 198         unsigned int lot;
 199         unsigned int wafer;
 200         unsigned int uid;
 201
 202         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 203                 return -ENODEV;
 204
 205         err = i2c_smbus_read_i2c_block_data(client, ABX8XX_REG_ID0,
 206                                             sizeof(buf), buf);
 207         if (err < 0) {
 208                 dev_err(&client->dev, "Unable to read partnumber\n");
 209                 return -EIO;
 210         }
 211
 212         partnumber = (buf[0] << 8) | buf[1];
 213         majrev = buf[2] >> 3;
 214         minrev = buf[2] & 0x7;
 215         lot = ((buf[4] & 0x80) << 2) | ((buf[6] & 0x80) << 1) | buf[3];
 216         uid = ((buf[4] & 0x7f) << 8) | buf[5];
 217         wafer = (buf[6] & 0x7c) >> 2;
 218         dev_info(&client->dev, "model %04x, revision %u.%u, lot %x, wafer %x, uid %x\n",
 219                  partnumber, majrev, minrev, lot, wafer, uid);
 220
 221         data = i2c_smbus_read_byte_data(client, ABX8XX_REG_CTRL1);
 222         if (data < 0) {
 223                 dev_err(&client->dev, "Unable to read control register\n");
 224                 return -EIO;
 225         }
 226
 227         err = i2c_smbus_write_byte_data(client, ABX8XX_REG_CTRL1,
 228                                         ((data & ~ABX8XX_CTRL_12_24) |
 229                                          ABX8XX_CTRL_WRITE));
 230         if (err < 0) {
 231                 dev_err(&client->dev, "Unable to write control register\n");
 232                 return -EIO;
 233         }
 234
 235         /* part autodetection */
 236         if (part == ABX80X) {
 237                 for (i = 0; abx80x_caps[i].pn; i++)
 238                         if (partnumber == abx80x_caps[i].pn)
 239                                 break;
 240                 if (abx80x_caps[i].pn == 0) {
 241                         dev_err(&client->dev, "Unknown part: %04x\n",
 242                                 partnumber);
 243                         return -EINVAL;
 244                 }
 245                 part = i;
 246         }
 247
 248         if (partnumber != abx80x_caps[part].pn) {
 249                 dev_err(&client->dev, "partnumber mismatch %04x != %04x\n",
 250                         partnumber, abx80x_caps[part].pn);
 251                 return -EINVAL;
 252         }
 253
 254         if (np && abx80x_caps[part].has_tc)
 255                 trickle_cfg = abx80x_dt_trickle_cfg(np);
 256
 257         if (trickle_cfg > 0) {
 258                 dev_info(&client->dev, "Enabling trickle charger: %02x\n",
 259                          trickle_cfg);
 260                 abx80x_enable_trickle_charger(client, trickle_cfg);
 261         }
 262
 263         rtc = devm_rtc_device_register(&client->dev, abx80x_driver.driver.name,
 264                                        &abx80x_rtc_ops, THIS_MODULE);
 265
 266         if (IS_ERR(rtc))
 267                 return PTR_ERR(rtc);
 268
 269         i2c_set_clientdata(client, rtc);
 270
 271         return 0;
 272 }
 273
 274 static int abx80x_remove(struct i2c_client *client)
 275 {
 276         return 0;
 277 }
 278
 279 static const struct i2c_device_id abx80x_id[] = {
 280         { "abx80x", ABX80X },
 281         { "ab0801", AB0801 },
 282         { "ab0803", AB0803 },
 283         { "ab0804", AB0804 },
 284         { "ab0805", AB0805 },
 285         { "ab1801", AB1801 },
 286         { "ab1803", AB1803 },
 287         { "ab1804", AB1804 },
 288         { "ab1805", AB1805 },
 289         { }
 290 };
 291 MODULE_DEVICE_TABLE(i2c, abx80x_id);
 292
 293 static struct i2c_driver abx80x_driver = {
 294         .driver         = {
 295                 .name   = "rtc-abx80x",
 296         },
 297         .probe          = abx80x_probe,
 298         .remove         = abx80x_remove,
 299         .id_table       = abx80x_id,
 300 };
 301
 302 module_i2c_driver(abx80x_driver);
 303
 304 MODULE_AUTHOR("Philippe De Muyter <phdm@macqel.be>");
 305 MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@free-electrons.com>");
 306 MODULE_DESCRIPTION("Abracon ABX80X RTC driver");
 307 MODULE_LICENSE("GPL v2");