drivers/rtc/rtc-isl1208.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
isl1208_i2c_read_regs
isl1208_i2c_set_regs
isl1208_i2c_validate_client
isl1208_i2c_get_sr
isl1208_i2c_get_atr
isl1208_i2c_get_dtr
isl1208_i2c_get_usr
isl1208_i2c_set_usr
isl1208_rtc_toggle_alarm
isl1208_rtc_proc
isl1208_i2c_read_time
isl1208_i2c_read_alarm
isl1208_i2c_set_alarm
isl1208_rtc_read_time
isl1208_i2c_set_time
isl1208_rtc_set_time
isl1208_rtc_read_alarm
isl1208_rtc_set_alarm
timestamp0_store
timestamp0_show
isl1208_rtc_interrupt
isl1208_sysfs_show_atrim
isl1208_sysfs_show_dtrim
isl1208_sysfs_show_usr
isl1208_sysfs_store_usr
isl1208_nvmem_read
isl1208_nvmem_write
isl1208_setup_irq
isl1208_probe
   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Intersil ISL1208 rtc class driver
   4  *
   5  * Copyright 2005,2006 Hebert Valerio Riedel <hvr@gnu.org>
   6  */
   7 
   8 #include <linux/bcd.h>
   9 #include <linux/i2c.h>
  10 #include <linux/module.h>
  11 #include <linux/of_device.h>
  12 #include <linux/of_irq.h>
  13 #include <linux/rtc.h>
  14 
  15 /* Register map */
  16 /* rtc section */
  17 #define ISL1208_REG_SC  0x00
  18 #define ISL1208_REG_MN  0x01
  19 #define ISL1208_REG_HR  0x02
  20 #define ISL1208_REG_HR_MIL     (1<<7)   /* 24h/12h mode */
  21 #define ISL1208_REG_HR_PM      (1<<5)   /* PM/AM bit in 12h mode */
  22 #define ISL1208_REG_DT  0x03
  23 #define ISL1208_REG_MO  0x04
  24 #define ISL1208_REG_YR  0x05
  25 #define ISL1208_REG_DW  0x06
  26 #define ISL1208_RTC_SECTION_LEN 7
  27 
  28 /* control/status section */
  29 #define ISL1208_REG_SR  0x07
  30 #define ISL1208_REG_SR_ARST    (1<<7)   /* auto reset */
  31 #define ISL1208_REG_SR_XTOSCB  (1<<6)   /* crystal oscillator */
  32 #define ISL1208_REG_SR_WRTC    (1<<4)   /* write rtc */
  33 #define ISL1208_REG_SR_EVT     (1<<3)   /* event */
  34 #define ISL1208_REG_SR_ALM     (1<<2)   /* alarm */
  35 #define ISL1208_REG_SR_BAT     (1<<1)   /* battery */
  36 #define ISL1208_REG_SR_RTCF    (1<<0)   /* rtc fail */
  37 #define ISL1208_REG_INT 0x08
  38 #define ISL1208_REG_INT_ALME   (1<<6)   /* alarm enable */
  39 #define ISL1208_REG_INT_IM     (1<<7)   /* interrupt/alarm mode */
  40 #define ISL1219_REG_EV  0x09
  41 #define ISL1219_REG_EV_EVEN    (1<<4)   /* event detection enable */
  42 #define ISL1219_REG_EV_EVIENB  (1<<7)   /* event in pull-up disable */
  43 #define ISL1208_REG_ATR 0x0a
  44 #define ISL1208_REG_DTR 0x0b
  45 
  46 /* alarm section */
  47 #define ISL1208_REG_SCA 0x0c
  48 #define ISL1208_REG_MNA 0x0d
  49 #define ISL1208_REG_HRA 0x0e
  50 #define ISL1208_REG_DTA 0x0f
  51 #define ISL1208_REG_MOA 0x10
  52 #define ISL1208_REG_DWA 0x11
  53 #define ISL1208_ALARM_SECTION_LEN 6
  54 
  55 /* user section */
  56 #define ISL1208_REG_USR1 0x12
  57 #define ISL1208_REG_USR2 0x13
  58 #define ISL1208_USR_SECTION_LEN 2
  59 
  60 /* event section */
  61 #define ISL1219_REG_SCT 0x14
  62 #define ISL1219_REG_MNT 0x15
  63 #define ISL1219_REG_HRT 0x16
  64 #define ISL1219_REG_DTT 0x17
  65 #define ISL1219_REG_MOT 0x18
  66 #define ISL1219_REG_YRT 0x19
  67 #define ISL1219_EVT_SECTION_LEN 6
  68 
  69 static struct i2c_driver isl1208_driver;
  70 
  71 /* ISL1208 various variants */
  72 enum isl1208_id {
  73         TYPE_ISL1208 = 0,
  74         TYPE_ISL1209,
  75         TYPE_ISL1218,
  76         TYPE_ISL1219,
  77         ISL_LAST_ID
  78 };
  79 
  80 /* Chip capabilities table */
  81 static const struct isl1208_config {
  82         const char      name[8];
  83         unsigned int    nvmem_length;
  84         unsigned        has_tamper:1;
  85         unsigned        has_timestamp:1;
  86 } isl1208_configs[] = {
  87         [TYPE_ISL1208] = { "isl1208", 2, false, false },
  88         [TYPE_ISL1209] = { "isl1209", 2, true,  false },
  89         [TYPE_ISL1218] = { "isl1218", 8, false, false },
  90         [TYPE_ISL1219] = { "isl1219", 2, true,  true },
  91 };
  92 
  93 static const struct i2c_device_id isl1208_id[] = {
  94         { "isl1208", TYPE_ISL1208 },
  95         { "isl1209", TYPE_ISL1209 },
  96         { "isl1218", TYPE_ISL1218 },
  97         { "isl1219", TYPE_ISL1219 },
  98         { }
  99 };
 100 MODULE_DEVICE_TABLE(i2c, isl1208_id);
 101 
 102 static const struct of_device_id isl1208_of_match[] = {
 103         { .compatible = "isil,isl1208", .data = &isl1208_configs[TYPE_ISL1208] },
 104         { .compatible = "isil,isl1209", .data = &isl1208_configs[TYPE_ISL1209] },
 105         { .compatible = "isil,isl1218", .data = &isl1208_configs[TYPE_ISL1218] },
 106         { .compatible = "isil,isl1219", .data = &isl1208_configs[TYPE_ISL1219] },
 107         { }
 108 };
 109 MODULE_DEVICE_TABLE(of, isl1208_of_match);
 110 
 111 /* Device state */
 112 struct isl1208_state {
 113         struct nvmem_config nvmem_config;
 114         struct rtc_device *rtc;
 115         const struct isl1208_config *config;
 116 };
 117 
 118 /* block read */
 119 static int
 120 isl1208_i2c_read_regs(struct i2c_client *client, u8 reg, u8 buf[],
 121                       unsigned len)
 122 {
 123         int ret;
 124 
 125         WARN_ON(reg > ISL1219_REG_YRT);
 126         WARN_ON(reg + len > ISL1219_REG_YRT + 1);
 127 
 128         ret = i2c_smbus_read_i2c_block_data(client, reg, len, buf);
 129         return (ret < 0) ? ret : 0;
 130 }
 131 
 132 /* block write */
 133 static int
 134 isl1208_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[],
 135                      unsigned len)
 136 {
 137         int ret;
 138 
 139         WARN_ON(reg > ISL1219_REG_YRT);
 140         WARN_ON(reg + len > ISL1219_REG_YRT + 1);
 141 
 142         ret = i2c_smbus_write_i2c_block_data(client, reg, len, buf);
 143         return (ret < 0) ? ret : 0;
 144 }
 145 
 146 /* simple check to see whether we have a isl1208 */
 147 static int
 148 isl1208_i2c_validate_client(struct i2c_client *client)
 149 {
 150         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 151         u8 zero_mask[ISL1208_RTC_SECTION_LEN] = {
 152                 0x80, 0x80, 0x40, 0xc0, 0xe0, 0x00, 0xf8
 153         };
 154         int i;
 155         int ret;
 156 
 157         ret = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
 158         if (ret < 0)
 159                 return ret;
 160 
 161         for (i = 0; i < ISL1208_RTC_SECTION_LEN; ++i) {
 162                 if (regs[i] & zero_mask[i])     /* check if bits are cleared */
 163                         return -ENODEV;
 164         }
 165 
 166         return 0;
 167 }
 168 
 169 static int
 170 isl1208_i2c_get_sr(struct i2c_client *client)
 171 {
 172         return i2c_smbus_read_byte_data(client, ISL1208_REG_SR);
 173 }
 174 
 175 static int
 176 isl1208_i2c_get_atr(struct i2c_client *client)
 177 {
 178         int atr = i2c_smbus_read_byte_data(client, ISL1208_REG_ATR);
 179         if (atr < 0)
 180                 return atr;
 181 
 182         /* The 6bit value in the ATR register controls the load
 183          * capacitance C_load * in steps of 0.25pF
 184          *
 185          * bit (1<<5) of the ATR register is inverted
 186          *
 187          * C_load(ATR=0x20) =  4.50pF
 188          * C_load(ATR=0x00) = 12.50pF
 189          * C_load(ATR=0x1f) = 20.25pF
 190          *
 191          */
 192 
 193         atr &= 0x3f;            /* mask out lsb */
 194         atr ^= 1 << 5;          /* invert 6th bit */
 195         atr += 2 * 9;           /* add offset of 4.5pF; unit[atr] = 0.25pF */
 196 
 197         return atr;
 198 }
 199 
 200 /* returns adjustment value + 100 */
 201 static int
 202 isl1208_i2c_get_dtr(struct i2c_client *client)
 203 {
 204         int dtr = i2c_smbus_read_byte_data(client, ISL1208_REG_DTR);
 205         if (dtr < 0)
 206                 return -EIO;
 207 
 208         /* dtr encodes adjustments of {-60,-40,-20,0,20,40,60} ppm */
 209         dtr = ((dtr & 0x3) * 20) * (dtr & (1 << 2) ? -1 : 1);
 210 
 211         return dtr + 100;
 212 }
 213 
 214 static int
 215 isl1208_i2c_get_usr(struct i2c_client *client)
 216 {
 217         u8 buf[ISL1208_USR_SECTION_LEN] = { 0, };
 218         int ret;
 219 
 220         ret = isl1208_i2c_read_regs(client, ISL1208_REG_USR1, buf,
 221                                     ISL1208_USR_SECTION_LEN);
 222         if (ret < 0)
 223                 return ret;
 224 
 225         return (buf[1] << 8) | buf[0];
 226 }
 227 
 228 static int
 229 isl1208_i2c_set_usr(struct i2c_client *client, u16 usr)
 230 {
 231         u8 buf[ISL1208_USR_SECTION_LEN];
 232 
 233         buf[0] = usr & 0xff;
 234         buf[1] = (usr >> 8) & 0xff;
 235 
 236         return isl1208_i2c_set_regs(client, ISL1208_REG_USR1, buf,
 237                                     ISL1208_USR_SECTION_LEN);
 238 }
 239 
 240 static int
 241 isl1208_rtc_toggle_alarm(struct i2c_client *client, int enable)
 242 {
 243         int icr = i2c_smbus_read_byte_data(client, ISL1208_REG_INT);
 244 
 245         if (icr < 0) {
 246                 dev_err(&client->dev, "%s: reading INT failed\n", __func__);
 247                 return icr;
 248         }
 249 
 250         if (enable)
 251                 icr |= ISL1208_REG_INT_ALME | ISL1208_REG_INT_IM;
 252         else
 253                 icr &= ~(ISL1208_REG_INT_ALME | ISL1208_REG_INT_IM);
 254 
 255         icr = i2c_smbus_write_byte_data(client, ISL1208_REG_INT, icr);
 256         if (icr < 0) {
 257                 dev_err(&client->dev, "%s: writing INT failed\n", __func__);
 258                 return icr;
 259         }
 260 
 261         return 0;
 262 }
 263 
 264 static int
 265 isl1208_rtc_proc(struct device *dev, struct seq_file *seq)
 266 {
 267         struct i2c_client *const client = to_i2c_client(dev);
 268         int sr, dtr, atr, usr;
 269 
 270         sr = isl1208_i2c_get_sr(client);
 271         if (sr < 0) {
 272                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 273                 return sr;
 274         }
 275 
 276         seq_printf(seq, "status_reg\t:%s%s%s%s%s%s (0x%.2x)\n",
 277                    (sr & ISL1208_REG_SR_RTCF) ? " RTCF" : "",
 278                    (sr & ISL1208_REG_SR_BAT) ? " BAT" : "",
 279                    (sr & ISL1208_REG_SR_ALM) ? " ALM" : "",
 280                    (sr & ISL1208_REG_SR_WRTC) ? " WRTC" : "",
 281                    (sr & ISL1208_REG_SR_XTOSCB) ? " XTOSCB" : "",
 282                    (sr & ISL1208_REG_SR_ARST) ? " ARST" : "", sr);
 283 
 284         seq_printf(seq, "batt_status\t: %s\n",
 285                    (sr & ISL1208_REG_SR_RTCF) ? "bad" : "okay");
 286 
 287         dtr = isl1208_i2c_get_dtr(client);
 288         if (dtr >= 0)
 289                 seq_printf(seq, "digital_trim\t: %d ppm\n", dtr - 100);
 290 
 291         atr = isl1208_i2c_get_atr(client);
 292         if (atr >= 0)
 293                 seq_printf(seq, "analog_trim\t: %d.%.2d pF\n",
 294                            atr >> 2, (atr & 0x3) * 25);
 295 
 296         usr = isl1208_i2c_get_usr(client);
 297         if (usr >= 0)
 298                 seq_printf(seq, "user_data\t: 0x%.4x\n", usr);
 299 
 300         return 0;
 301 }
 302 
 303 static int
 304 isl1208_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
 305 {
 306         int sr;
 307         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 308 
 309         sr = isl1208_i2c_get_sr(client);
 310         if (sr < 0) {
 311                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 312                 return -EIO;
 313         }
 314 
 315         sr = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
 316         if (sr < 0) {
 317                 dev_err(&client->dev, "%s: reading RTC section failed\n",
 318                         __func__);
 319                 return sr;
 320         }
 321 
 322         tm->tm_sec = bcd2bin(regs[ISL1208_REG_SC]);
 323         tm->tm_min = bcd2bin(regs[ISL1208_REG_MN]);
 324 
 325         /* HR field has a more complex interpretation */
 326         {
 327                 const u8 _hr = regs[ISL1208_REG_HR];
 328                 if (_hr & ISL1208_REG_HR_MIL)   /* 24h format */
 329                         tm->tm_hour = bcd2bin(_hr & 0x3f);
 330                 else {
 331                         /* 12h format */
 332                         tm->tm_hour = bcd2bin(_hr & 0x1f);
 333                         if (_hr & ISL1208_REG_HR_PM)    /* PM flag set */
 334                                 tm->tm_hour += 12;
 335                 }
 336         }
 337 
 338         tm->tm_mday = bcd2bin(regs[ISL1208_REG_DT]);
 339         tm->tm_mon = bcd2bin(regs[ISL1208_REG_MO]) - 1; /* rtc starts at 1 */
 340         tm->tm_year = bcd2bin(regs[ISL1208_REG_YR]) + 100;
 341         tm->tm_wday = bcd2bin(regs[ISL1208_REG_DW]);
 342 
 343         return 0;
 344 }
 345 
 346 static int
 347 isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
 348 {
 349         struct rtc_time *const tm = &alarm->time;
 350         u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, };
 351         int icr, yr, sr = isl1208_i2c_get_sr(client);
 352 
 353         if (sr < 0) {
 354                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 355                 return sr;
 356         }
 357 
 358         sr = isl1208_i2c_read_regs(client, ISL1208_REG_SCA, regs,
 359                                    ISL1208_ALARM_SECTION_LEN);
 360         if (sr < 0) {
 361                 dev_err(&client->dev, "%s: reading alarm section failed\n",
 362                         __func__);
 363                 return sr;
 364         }
 365 
 366         /* MSB of each alarm register is an enable bit */
 367         tm->tm_sec = bcd2bin(regs[ISL1208_REG_SCA - ISL1208_REG_SCA] & 0x7f);
 368         tm->tm_min = bcd2bin(regs[ISL1208_REG_MNA - ISL1208_REG_SCA] & 0x7f);
 369         tm->tm_hour = bcd2bin(regs[ISL1208_REG_HRA - ISL1208_REG_SCA] & 0x3f);
 370         tm->tm_mday = bcd2bin(regs[ISL1208_REG_DTA - ISL1208_REG_SCA] & 0x3f);
 371         tm->tm_mon =
 372                 bcd2bin(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1;
 373         tm->tm_wday = bcd2bin(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03);
 374 
 375         /* The alarm doesn't store the year so get it from the rtc section */
 376         yr = i2c_smbus_read_byte_data(client, ISL1208_REG_YR);
 377         if (yr < 0) {
 378                 dev_err(&client->dev, "%s: reading RTC YR failed\n", __func__);
 379                 return yr;
 380         }
 381         tm->tm_year = bcd2bin(yr) + 100;
 382 
 383         icr = i2c_smbus_read_byte_data(client, ISL1208_REG_INT);
 384         if (icr < 0) {
 385                 dev_err(&client->dev, "%s: reading INT failed\n", __func__);
 386                 return icr;
 387         }
 388         alarm->enabled = !!(icr & ISL1208_REG_INT_ALME);
 389 
 390         return 0;
 391 }
 392 
 393 static int
 394 isl1208_i2c_set_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
 395 {
 396         struct rtc_time *alarm_tm = &alarm->time;
 397         u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, };
 398         const int offs = ISL1208_REG_SCA;
 399         struct rtc_time rtc_tm;
 400         int err, enable;
 401 
 402         err = isl1208_i2c_read_time(client, &rtc_tm);
 403         if (err)
 404                 return err;
 405 
 406         /* If the alarm time is before the current time disable the alarm */
 407         if (!alarm->enabled || rtc_tm_sub(alarm_tm, &rtc_tm) <= 0)
 408                 enable = 0x00;
 409         else
 410                 enable = 0x80;
 411 
 412         /* Program the alarm and enable it for each setting */
 413         regs[ISL1208_REG_SCA - offs] = bin2bcd(alarm_tm->tm_sec) | enable;
 414         regs[ISL1208_REG_MNA - offs] = bin2bcd(alarm_tm->tm_min) | enable;
 415         regs[ISL1208_REG_HRA - offs] = bin2bcd(alarm_tm->tm_hour) |
 416                 ISL1208_REG_HR_MIL | enable;
 417 
 418         regs[ISL1208_REG_DTA - offs] = bin2bcd(alarm_tm->tm_mday) | enable;
 419         regs[ISL1208_REG_MOA - offs] = bin2bcd(alarm_tm->tm_mon + 1) | enable;
 420         regs[ISL1208_REG_DWA - offs] = bin2bcd(alarm_tm->tm_wday & 7) | enable;
 421 
 422         /* write ALARM registers */
 423         err = isl1208_i2c_set_regs(client, offs, regs,
 424                                   ISL1208_ALARM_SECTION_LEN);
 425         if (err < 0) {
 426                 dev_err(&client->dev, "%s: writing ALARM section failed\n",
 427                         __func__);
 428                 return err;
 429         }
 430 
 431         err = isl1208_rtc_toggle_alarm(client, enable);
 432         if (err)
 433                 return err;
 434 
 435         return 0;
 436 }
 437 
 438 static int
 439 isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm)
 440 {
 441         return isl1208_i2c_read_time(to_i2c_client(dev), tm);
 442 }
 443 
 444 static int
 445 isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
 446 {
 447         int sr;
 448         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 449 
 450         /* The clock has an 8 bit wide bcd-coded register (they never learn)
 451          * for the year. tm_year is an offset from 1900 and we are interested
 452          * in the 2000-2099 range, so any value less than 100 is invalid.
 453          */
 454         if (tm->tm_year < 100)
 455                 return -EINVAL;
 456 
 457         regs[ISL1208_REG_SC] = bin2bcd(tm->tm_sec);
 458         regs[ISL1208_REG_MN] = bin2bcd(tm->tm_min);
 459         regs[ISL1208_REG_HR] = bin2bcd(tm->tm_hour) | ISL1208_REG_HR_MIL;
 460 
 461         regs[ISL1208_REG_DT] = bin2bcd(tm->tm_mday);
 462         regs[ISL1208_REG_MO] = bin2bcd(tm->tm_mon + 1);
 463         regs[ISL1208_REG_YR] = bin2bcd(tm->tm_year - 100);
 464 
 465         regs[ISL1208_REG_DW] = bin2bcd(tm->tm_wday & 7);
 466 
 467         sr = isl1208_i2c_get_sr(client);
 468         if (sr < 0) {
 469                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 470                 return sr;
 471         }
 472 
 473         /* set WRTC */
 474         sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
 475                                        sr | ISL1208_REG_SR_WRTC);
 476         if (sr < 0) {
 477                 dev_err(&client->dev, "%s: writing SR failed\n", __func__);
 478                 return sr;
 479         }
 480 
 481         /* write RTC registers */
 482         sr = isl1208_i2c_set_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
 483         if (sr < 0) {
 484                 dev_err(&client->dev, "%s: writing RTC section failed\n",
 485                         __func__);
 486                 return sr;
 487         }
 488 
 489         /* clear WRTC again */
 490         sr = isl1208_i2c_get_sr(client);
 491         if (sr < 0) {
 492                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 493                 return sr;
 494         }
 495         sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
 496                                        sr & ~ISL1208_REG_SR_WRTC);
 497         if (sr < 0) {
 498                 dev_err(&client->dev, "%s: writing SR failed\n", __func__);
 499                 return sr;
 500         }
 501 
 502         return 0;
 503 }
 504 
 505 
 506 static int
 507 isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm)
 508 {
 509         return isl1208_i2c_set_time(to_i2c_client(dev), tm);
 510 }
 511 
 512 static int
 513 isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 514 {
 515         return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm);
 516 }
 517 
 518 static int
 519 isl1208_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 520 {
 521         return isl1208_i2c_set_alarm(to_i2c_client(dev), alarm);
 522 }
 523 
 524 static ssize_t timestamp0_store(struct device *dev,
 525                                 struct device_attribute *attr,
 526                                 const char *buf, size_t count)
 527 {
 528         struct i2c_client *client = to_i2c_client(dev->parent);
 529         int sr;
 530 
 531         sr = isl1208_i2c_get_sr(client);
 532         if (sr < 0) {
 533                 dev_err(dev, "%s: reading SR failed\n", __func__);
 534                 return sr;
 535         }
 536 
 537         sr &= ~ISL1208_REG_SR_EVT;
 538 
 539         sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, sr);
 540         if (sr < 0)
 541                 dev_err(dev, "%s: writing SR failed\n",
 542                         __func__);
 543 
 544         return count;
 545 };
 546 
 547 static ssize_t timestamp0_show(struct device *dev,
 548                                struct device_attribute *attr, char *buf)
 549 {
 550         struct i2c_client *client = to_i2c_client(dev->parent);
 551         u8 regs[ISL1219_EVT_SECTION_LEN] = { 0, };
 552         struct rtc_time tm;
 553         int sr;
 554 
 555         sr = isl1208_i2c_get_sr(client);
 556         if (sr < 0) {
 557                 dev_err(dev, "%s: reading SR failed\n", __func__);
 558                 return sr;
 559         }
 560 
 561         if (!(sr & ISL1208_REG_SR_EVT))
 562                 return 0;
 563 
 564         sr = isl1208_i2c_read_regs(client, ISL1219_REG_SCT, regs,
 565                                    ISL1219_EVT_SECTION_LEN);
 566         if (sr < 0) {
 567                 dev_err(dev, "%s: reading event section failed\n",
 568                         __func__);
 569                 return 0;
 570         }
 571 
 572         /* MSB of each alarm register is an enable bit */
 573         tm.tm_sec = bcd2bin(regs[ISL1219_REG_SCT - ISL1219_REG_SCT] & 0x7f);
 574         tm.tm_min = bcd2bin(regs[ISL1219_REG_MNT - ISL1219_REG_SCT] & 0x7f);
 575         tm.tm_hour = bcd2bin(regs[ISL1219_REG_HRT - ISL1219_REG_SCT] & 0x3f);
 576         tm.tm_mday = bcd2bin(regs[ISL1219_REG_DTT - ISL1219_REG_SCT] & 0x3f);
 577         tm.tm_mon =
 578                 bcd2bin(regs[ISL1219_REG_MOT - ISL1219_REG_SCT] & 0x1f) - 1;
 579         tm.tm_year = bcd2bin(regs[ISL1219_REG_YRT - ISL1219_REG_SCT]) + 100;
 580 
 581         sr = rtc_valid_tm(&tm);
 582         if (sr)
 583                 return sr;
 584 
 585         return sprintf(buf, "%llu\n",
 586                                 (unsigned long long)rtc_tm_to_time64(&tm));
 587 };
 588 
 589 static DEVICE_ATTR_RW(timestamp0);
 590 
 591 static irqreturn_t
 592 isl1208_rtc_interrupt(int irq, void *data)
 593 {
 594         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
 595         struct i2c_client *client = data;
 596         struct isl1208_state *isl1208 = i2c_get_clientdata(client);
 597         int handled = 0, sr, err;
 598 
 599         /*
 600          * I2C reads get NAK'ed if we read straight away after an interrupt?
 601          * Using a mdelay/msleep didn't seem to help either, so we work around
 602          * this by continually trying to read the register for a short time.
 603          */
 604         while (1) {
 605                 sr = isl1208_i2c_get_sr(client);
 606                 if (sr >= 0)
 607                         break;
 608 
 609                 if (time_after(jiffies, timeout)) {
 610                         dev_err(&client->dev, "%s: reading SR failed\n",
 611                                 __func__);
 612                         return sr;
 613                 }
 614         }
 615 
 616         if (sr & ISL1208_REG_SR_ALM) {
 617                 dev_dbg(&client->dev, "alarm!\n");
 618 
 619                 rtc_update_irq(isl1208->rtc, 1, RTC_IRQF | RTC_AF);
 620 
 621                 /* Clear the alarm */
 622                 sr &= ~ISL1208_REG_SR_ALM;
 623                 sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, sr);
 624                 if (sr < 0)
 625                         dev_err(&client->dev, "%s: writing SR failed\n",
 626                                 __func__);
 627                 else
 628                         handled = 1;
 629 
 630                 /* Disable the alarm */
 631                 err = isl1208_rtc_toggle_alarm(client, 0);
 632                 if (err)
 633                         return err;
 634         }
 635 
 636         if (isl1208->config->has_tamper && (sr & ISL1208_REG_SR_EVT)) {
 637                 dev_warn(&client->dev, "event detected");
 638                 handled = 1;
 639                 if (isl1208->config->has_timestamp)
 640                         sysfs_notify(&isl1208->rtc->dev.kobj, NULL,
 641                                      dev_attr_timestamp0.attr.name);
 642         }
 643 
 644         return handled ? IRQ_HANDLED : IRQ_NONE;
 645 }
 646 
 647 static const struct rtc_class_ops isl1208_rtc_ops = {
 648         .proc = isl1208_rtc_proc,
 649         .read_time = isl1208_rtc_read_time,
 650         .set_time = isl1208_rtc_set_time,
 651         .read_alarm = isl1208_rtc_read_alarm,
 652         .set_alarm = isl1208_rtc_set_alarm,
 653 };
 654 
 655 /* sysfs interface */
 656 
 657 static ssize_t
 658 isl1208_sysfs_show_atrim(struct device *dev,
 659                          struct device_attribute *attr, char *buf)
 660 {
 661         int atr = isl1208_i2c_get_atr(to_i2c_client(dev->parent));
 662         if (atr < 0)
 663                 return atr;
 664 
 665         return sprintf(buf, "%d.%.2d pF\n", atr >> 2, (atr & 0x3) * 25);
 666 }
 667 
 668 static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL);
 669 
 670 static ssize_t
 671 isl1208_sysfs_show_dtrim(struct device *dev,
 672                          struct device_attribute *attr, char *buf)
 673 {
 674         int dtr = isl1208_i2c_get_dtr(to_i2c_client(dev->parent));
 675         if (dtr < 0)
 676                 return dtr;
 677 
 678         return sprintf(buf, "%d ppm\n", dtr - 100);
 679 }
 680 
 681 static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL);
 682 
 683 static ssize_t
 684 isl1208_sysfs_show_usr(struct device *dev,
 685                        struct device_attribute *attr, char *buf)
 686 {
 687         int usr = isl1208_i2c_get_usr(to_i2c_client(dev->parent));
 688         if (usr < 0)
 689                 return usr;
 690 
 691         return sprintf(buf, "0x%.4x\n", usr);
 692 }
 693 
 694 static ssize_t
 695 isl1208_sysfs_store_usr(struct device *dev,
 696                         struct device_attribute *attr,
 697                         const char *buf, size_t count)
 698 {
 699         int usr = -1;
 700 
 701         if (buf[0] == '0' && (buf[1] == 'x' || buf[1] == 'X')) {
 702                 if (sscanf(buf, "%x", &usr) != 1)
 703                         return -EINVAL;
 704         } else {
 705                 if (sscanf(buf, "%d", &usr) != 1)
 706                         return -EINVAL;
 707         }
 708 
 709         if (usr < 0 || usr > 0xffff)
 710                 return -EINVAL;
 711 
 712         if (isl1208_i2c_set_usr(to_i2c_client(dev->parent), usr))
 713                 return -EIO;
 714 
 715         return count;
 716 }
 717 
 718 static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr,
 719                    isl1208_sysfs_store_usr);
 720 
 721 static struct attribute *isl1208_rtc_attrs[] = {
 722         &dev_attr_atrim.attr,
 723         &dev_attr_dtrim.attr,
 724         &dev_attr_usr.attr,
 725         NULL
 726 };
 727 
 728 static const struct attribute_group isl1208_rtc_sysfs_files = {
 729         .attrs  = isl1208_rtc_attrs,
 730 };
 731 
 732 static struct attribute *isl1219_rtc_attrs[] = {
 733         &dev_attr_timestamp0.attr,
 734         NULL
 735 };
 736 
 737 static const struct attribute_group isl1219_rtc_sysfs_files = {
 738         .attrs  = isl1219_rtc_attrs,
 739 };
 740 
 741 static int isl1208_nvmem_read(void *priv, unsigned int off, void *buf,
 742                               size_t count)
 743 {
 744         struct isl1208_state *isl1208 = priv;
 745         struct i2c_client *client = to_i2c_client(isl1208->rtc->dev.parent);
 746         int ret;
 747 
 748         /* nvmem sanitizes offset/count for us, but count==0 is possible */
 749         if (!count)
 750                 return count;
 751         ret = isl1208_i2c_read_regs(client, ISL1208_REG_USR1 + off, buf,
 752                                     count);
 753         return ret == 0 ? count : ret;
 754 }
 755 
 756 static int isl1208_nvmem_write(void *priv, unsigned int off, void *buf,
 757                                size_t count)
 758 {
 759         struct isl1208_state *isl1208 = priv;
 760         struct i2c_client *client = to_i2c_client(isl1208->rtc->dev.parent);
 761         int ret;
 762 
 763         /* nvmem sanitizes off/count for us, but count==0 is possible */
 764         if (!count)
 765                 return count;
 766         ret = isl1208_i2c_set_regs(client, ISL1208_REG_USR1 + off, buf,
 767                                    count);
 768 
 769         return ret == 0 ? count : ret;
 770 }
 771 
 772 static const struct nvmem_config isl1208_nvmem_config = {
 773         .name = "isl1208_nvram",
 774         .word_size = 1,
 775         .stride = 1,
 776         /* .size from chip specific config */
 777         .reg_read = isl1208_nvmem_read,
 778         .reg_write = isl1208_nvmem_write,
 779 };
 780 
 781 static int isl1208_setup_irq(struct i2c_client *client, int irq)
 782 {
 783         int rc = devm_request_threaded_irq(&client->dev, irq, NULL,
 784                                         isl1208_rtc_interrupt,
 785                                         IRQF_SHARED | IRQF_ONESHOT,
 786                                         isl1208_driver.driver.name,
 787                                         client);
 788         if (!rc) {
 789                 device_init_wakeup(&client->dev, 1);
 790                 enable_irq_wake(irq);
 791         } else {
 792                 dev_err(&client->dev,
 793                         "Unable to request irq %d, no alarm support\n",
 794                         irq);
 795         }
 796         return rc;
 797 }
 798 
 799 static int
 800 isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
 801 {
 802         int rc = 0;
 803         struct isl1208_state *isl1208;
 804         int evdet_irq = -1;
 805 
 806         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 807                 return -ENODEV;
 808 
 809         if (isl1208_i2c_validate_client(client) < 0)
 810                 return -ENODEV;
 811 
 812         /* Allocate driver state, point i2c client data to it */
 813         isl1208 = devm_kzalloc(&client->dev, sizeof(*isl1208), GFP_KERNEL);
 814         if (!isl1208)
 815                 return -ENOMEM;
 816         i2c_set_clientdata(client, isl1208);
 817 
 818         /* Determine which chip we have */
 819         if (client->dev.of_node) {
 820                 isl1208->config = of_device_get_match_data(&client->dev);
 821                 if (!isl1208->config)
 822                         return -ENODEV;
 823         } else {
 824                 if (id->driver_data >= ISL_LAST_ID)
 825                         return -ENODEV;
 826                 isl1208->config = &isl1208_configs[id->driver_data];
 827         }
 828 
 829         isl1208->rtc = devm_rtc_allocate_device(&client->dev);
 830         if (IS_ERR(isl1208->rtc))
 831                 return PTR_ERR(isl1208->rtc);
 832 
 833         isl1208->rtc->ops = &isl1208_rtc_ops;
 834 
 835         /* Setup nvmem configuration in driver state struct */
 836         isl1208->nvmem_config = isl1208_nvmem_config;
 837         isl1208->nvmem_config.size = isl1208->config->nvmem_length;
 838         isl1208->nvmem_config.priv = isl1208;
 839 
 840         rc = isl1208_i2c_get_sr(client);
 841         if (rc < 0) {
 842                 dev_err(&client->dev, "reading status failed\n");
 843                 return rc;
 844         }
 845 
 846         if (rc & ISL1208_REG_SR_RTCF)
 847                 dev_warn(&client->dev, "rtc power failure detected, "
 848                          "please set clock.\n");
 849 
 850         if (isl1208->config->has_tamper) {
 851                 struct device_node *np = client->dev.of_node;
 852                 u32 evienb;
 853 
 854                 rc = i2c_smbus_read_byte_data(client, ISL1219_REG_EV);
 855                 if (rc < 0) {
 856                         dev_err(&client->dev, "failed to read EV reg\n");
 857                         return rc;
 858                 }
 859                 rc |= ISL1219_REG_EV_EVEN;
 860                 if (!of_property_read_u32(np, "isil,ev-evienb", &evienb)) {
 861                         if (evienb)
 862                                 rc |= ISL1219_REG_EV_EVIENB;
 863                         else
 864                                 rc &= ~ISL1219_REG_EV_EVIENB;
 865                 }
 866                 rc = i2c_smbus_write_byte_data(client, ISL1219_REG_EV, rc);
 867                 if (rc < 0) {
 868                         dev_err(&client->dev, "could not enable tamper detection\n");
 869                         return rc;
 870                 }
 871                 evdet_irq = of_irq_get_byname(np, "evdet");
 872         }
 873         if (isl1208->config->has_timestamp) {
 874                 rc = rtc_add_group(isl1208->rtc, &isl1219_rtc_sysfs_files);
 875                 if (rc)
 876                         return rc;
 877         }
 878 
 879         rc = rtc_add_group(isl1208->rtc, &isl1208_rtc_sysfs_files);
 880         if (rc)
 881                 return rc;
 882 
 883         if (client->irq > 0)
 884                 rc = isl1208_setup_irq(client, client->irq);
 885         if (rc)
 886                 return rc;
 887 
 888         if (evdet_irq > 0 && evdet_irq != client->irq)
 889                 rc = isl1208_setup_irq(client, evdet_irq);
 890         if (rc)
 891                 return rc;
 892 
 893         rc = rtc_nvmem_register(isl1208->rtc, &isl1208->nvmem_config);
 894         if (rc)
 895                 return rc;
 896 
 897         return rtc_register_device(isl1208->rtc);
 898 }
 899 
 900 static struct i2c_driver isl1208_driver = {
 901         .driver = {
 902                 .name = "rtc-isl1208",
 903                 .of_match_table = of_match_ptr(isl1208_of_match),
 904         },
 905         .probe = isl1208_probe,
 906         .id_table = isl1208_id,
 907 };
 908 
 909 module_i2c_driver(isl1208_driver);
 910 
 911 MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>");
 912 MODULE_DESCRIPTION("Intersil ISL1208 RTC driver");
 913 MODULE_LICENSE("GPL");
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/rtc/rtc-isl1208.c

DEFINITIONS
