drivers/rtc/rtc-isl1208.c

   1 /*
   2  * Intersil ISL1208 rtc class driver
   3  *
   4  * Copyright 2005,2006 Hebert Valerio Riedel <hvr@gnu.org>
   5  *
   6  *  This program is free software; you can redistribute  it and/or modify it
   7  *  under  the terms of  the GNU General  Public License as published by the
   8  *  Free Software Foundation;  either version 2 of the  License, or (at your
   9  *  option) any later version.
  10  *
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/i2c.h>
  15 #include <linux/bcd.h>
  16 #include <linux/rtc.h>
  17
  18 /* Register map */
  19 /* rtc section */
  20 #define ISL1208_REG_SC  0x00
  21 #define ISL1208_REG_MN  0x01
  22 #define ISL1208_REG_HR  0x02
  23 #define ISL1208_REG_HR_MIL     (1<<7)   /* 24h/12h mode */
  24 #define ISL1208_REG_HR_PM      (1<<5)   /* PM/AM bit in 12h mode */
  25 #define ISL1208_REG_DT  0x03
  26 #define ISL1208_REG_MO  0x04
  27 #define ISL1208_REG_YR  0x05
  28 #define ISL1208_REG_DW  0x06
  29 #define ISL1208_RTC_SECTION_LEN 7
  30
  31 /* control/status section */
  32 #define ISL1208_REG_SR  0x07
  33 #define ISL1208_REG_SR_ARST    (1<<7)   /* auto reset */
  34 #define ISL1208_REG_SR_XTOSCB  (1<<6)   /* crystal oscillator */
  35 #define ISL1208_REG_SR_WRTC    (1<<4)   /* write rtc */
  36 #define ISL1208_REG_SR_ALM     (1<<2)   /* alarm */
  37 #define ISL1208_REG_SR_BAT     (1<<1)   /* battery */
  38 #define ISL1208_REG_SR_RTCF    (1<<0)   /* rtc fail */
  39 #define ISL1208_REG_INT 0x08
  40 #define ISL1208_REG_INT_ALME   (1<<6)   /* alarm enable */
  41 #define ISL1208_REG_INT_IM     (1<<7)   /* interrupt/alarm mode */
  42 #define ISL1208_REG_09  0x09    /* reserved */
  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 static struct i2c_driver isl1208_driver;
  61
  62 /* block read */
  63 static int
  64 isl1208_i2c_read_regs(struct i2c_client *client, u8 reg, u8 buf[],
  65                       unsigned len)
  66 {
  67         u8 reg_addr[1] = { reg };
  68         struct i2c_msg msgs[2] = {
  69                 {
  70                         .addr = client->addr,
  71                         .len = sizeof(reg_addr),
  72                         .buf = reg_addr
  73                 },
  74                 {
  75                         .addr = client->addr,
  76                         .flags = I2C_M_RD,
  77                         .len = len,
  78                         .buf = buf
  79                 }
  80         };
  81         int ret;
  82
  83         BUG_ON(reg > ISL1208_REG_USR2);
  84         BUG_ON(reg + len > ISL1208_REG_USR2 + 1);
  85
  86         ret = i2c_transfer(client->adapter, msgs, 2);
  87         if (ret > 0)
  88                 ret = 0;
  89         return ret;
  90 }
  91
  92 /* block write */
  93 static int
  94 isl1208_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[],
  95                      unsigned len)
  96 {
  97         u8 i2c_buf[ISL1208_REG_USR2 + 2];
  98         struct i2c_msg msgs[1] = {
  99                 {
 100                         .addr = client->addr,
 101                         .len = len + 1,
 102                         .buf = i2c_buf
 103                 }
 104         };
 105         int ret;
 106
 107         BUG_ON(reg > ISL1208_REG_USR2);
 108         BUG_ON(reg + len > ISL1208_REG_USR2 + 1);
 109
 110         i2c_buf[0] = reg;
 111         memcpy(&i2c_buf[1], &buf[0], len);
 112
 113         ret = i2c_transfer(client->adapter, msgs, 1);
 114         if (ret > 0)
 115                 ret = 0;
 116         return ret;
 117 }
 118
 119 /* simple check to see whether we have a isl1208 */
 120 static int
 121 isl1208_i2c_validate_client(struct i2c_client *client)
 122 {
 123         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 124         u8 zero_mask[ISL1208_RTC_SECTION_LEN] = {
 125                 0x80, 0x80, 0x40, 0xc0, 0xe0, 0x00, 0xf8
 126         };
 127         int i;
 128         int ret;
 129
 130         ret = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
 131         if (ret < 0)
 132                 return ret;
 133
 134         for (i = 0; i < ISL1208_RTC_SECTION_LEN; ++i) {
 135                 if (regs[i] & zero_mask[i])     /* check if bits are cleared */
 136                         return -ENODEV;
 137         }
 138
 139         return 0;
 140 }
 141
 142 static int
 143 isl1208_i2c_get_sr(struct i2c_client *client)
 144 {
 145         return i2c_smbus_read_byte_data(client, ISL1208_REG_SR);
 146 }
 147
 148 static int
 149 isl1208_i2c_get_atr(struct i2c_client *client)
 150 {
 151         int atr = i2c_smbus_read_byte_data(client, ISL1208_REG_ATR);
 152         if (atr < 0)
 153                 return atr;
 154
 155         /* The 6bit value in the ATR register controls the load
 156          * capacitance C_load * in steps of 0.25pF
 157          *
 158          * bit (1<<5) of the ATR register is inverted
 159          *
 160          * C_load(ATR=0x20) =  4.50pF
 161          * C_load(ATR=0x00) = 12.50pF
 162          * C_load(ATR=0x1f) = 20.25pF
 163          *
 164          */
 165
 166         atr &= 0x3f;            /* mask out lsb */
 167         atr ^= 1 << 5;          /* invert 6th bit */
 168         atr += 2 * 9;           /* add offset of 4.5pF; unit[atr] = 0.25pF */
 169
 170         return atr;
 171 }
 172
 173 static int
 174 isl1208_i2c_get_dtr(struct i2c_client *client)
 175 {
 176         int dtr = i2c_smbus_read_byte_data(client, ISL1208_REG_DTR);
 177         if (dtr < 0)
 178                 return -EIO;
 179
 180         /* dtr encodes adjustments of {-60,-40,-20,0,20,40,60} ppm */
 181         dtr = ((dtr & 0x3) * 20) * (dtr & (1 << 2) ? -1 : 1);
 182
 183         return dtr;
 184 }
 185
 186 static int
 187 isl1208_i2c_get_usr(struct i2c_client *client)
 188 {
 189         u8 buf[ISL1208_USR_SECTION_LEN] = { 0, };
 190         int ret;
 191
 192         ret = isl1208_i2c_read_regs(client, ISL1208_REG_USR1, buf,
 193                                     ISL1208_USR_SECTION_LEN);
 194         if (ret < 0)
 195                 return ret;
 196
 197         return (buf[1] << 8) | buf[0];
 198 }
 199
 200 static int
 201 isl1208_i2c_set_usr(struct i2c_client *client, u16 usr)
 202 {
 203         u8 buf[ISL1208_USR_SECTION_LEN];
 204
 205         buf[0] = usr & 0xff;
 206         buf[1] = (usr >> 8) & 0xff;
 207
 208         return isl1208_i2c_set_regs(client, ISL1208_REG_USR1, buf,
 209                                     ISL1208_USR_SECTION_LEN);
 210 }
 211
 212 static int
 213 isl1208_rtc_toggle_alarm(struct i2c_client *client, int enable)
 214 {
 215         int icr = i2c_smbus_read_byte_data(client, ISL1208_REG_INT);
 216
 217         if (icr < 0) {
 218                 dev_err(&client->dev, "%s: reading INT failed\n", __func__);
 219                 return icr;
 220         }
 221
 222         if (enable)
 223                 icr |= ISL1208_REG_INT_ALME | ISL1208_REG_INT_IM;
 224         else
 225                 icr &= ~(ISL1208_REG_INT_ALME | ISL1208_REG_INT_IM);
 226
 227         icr = i2c_smbus_write_byte_data(client, ISL1208_REG_INT, icr);
 228         if (icr < 0) {
 229                 dev_err(&client->dev, "%s: writing INT failed\n", __func__);
 230                 return icr;
 231         }
 232
 233         return 0;
 234 }
 235
 236 static int
 237 isl1208_rtc_proc(struct device *dev, struct seq_file *seq)
 238 {
 239         struct i2c_client *const client = to_i2c_client(dev);
 240         int sr, dtr, atr, usr;
 241
 242         sr = isl1208_i2c_get_sr(client);
 243         if (sr < 0) {
 244                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 245                 return sr;
 246         }
 247
 248         seq_printf(seq, "status_reg\t:%s%s%s%s%s%s (0x%.2x)\n",
 249                    (sr & ISL1208_REG_SR_RTCF) ? " RTCF" : "",
 250                    (sr & ISL1208_REG_SR_BAT) ? " BAT" : "",
 251                    (sr & ISL1208_REG_SR_ALM) ? " ALM" : "",
 252                    (sr & ISL1208_REG_SR_WRTC) ? " WRTC" : "",
 253                    (sr & ISL1208_REG_SR_XTOSCB) ? " XTOSCB" : "",
 254                    (sr & ISL1208_REG_SR_ARST) ? " ARST" : "", sr);
 255
 256         seq_printf(seq, "batt_status\t: %s\n",
 257                    (sr & ISL1208_REG_SR_RTCF) ? "bad" : "okay");
 258
 259         dtr = isl1208_i2c_get_dtr(client);
 260         if (dtr >= 0 - 1)
 261                 seq_printf(seq, "digital_trim\t: %d ppm\n", dtr);
 262
 263         atr = isl1208_i2c_get_atr(client);
 264         if (atr >= 0)
 265                 seq_printf(seq, "analog_trim\t: %d.%.2d pF\n",
 266                            atr >> 2, (atr & 0x3) * 25);
 267
 268         usr = isl1208_i2c_get_usr(client);
 269         if (usr >= 0)
 270                 seq_printf(seq, "user_data\t: 0x%.4x\n", usr);
 271
 272         return 0;
 273 }
 274
 275 static int
 276 isl1208_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
 277 {
 278         int sr;
 279         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 280
 281         sr = isl1208_i2c_get_sr(client);
 282         if (sr < 0) {
 283                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 284                 return -EIO;
 285         }
 286
 287         sr = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
 288         if (sr < 0) {
 289                 dev_err(&client->dev, "%s: reading RTC section failed\n",
 290                         __func__);
 291                 return sr;
 292         }
 293
 294         tm->tm_sec = bcd2bin(regs[ISL1208_REG_SC]);
 295         tm->tm_min = bcd2bin(regs[ISL1208_REG_MN]);
 296
 297         /* HR field has a more complex interpretation */
 298         {
 299                 const u8 _hr = regs[ISL1208_REG_HR];
 300                 if (_hr & ISL1208_REG_HR_MIL)   /* 24h format */
 301                         tm->tm_hour = bcd2bin(_hr & 0x3f);
 302                 else {
 303                         /* 12h format */
 304                         tm->tm_hour = bcd2bin(_hr & 0x1f);
 305                         if (_hr & ISL1208_REG_HR_PM)    /* PM flag set */
 306                                 tm->tm_hour += 12;
 307                 }
 308         }
 309
 310         tm->tm_mday = bcd2bin(regs[ISL1208_REG_DT]);
 311         tm->tm_mon = bcd2bin(regs[ISL1208_REG_MO]) - 1; /* rtc starts at 1 */
 312         tm->tm_year = bcd2bin(regs[ISL1208_REG_YR]) + 100;
 313         tm->tm_wday = bcd2bin(regs[ISL1208_REG_DW]);
 314
 315         return 0;
 316 }
 317
 318 static int
 319 isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
 320 {
 321         struct rtc_time *const tm = &alarm->time;
 322         u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, };
 323         int icr, yr, sr = isl1208_i2c_get_sr(client);
 324
 325         if (sr < 0) {
 326                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 327                 return sr;
 328         }
 329
 330         sr = isl1208_i2c_read_regs(client, ISL1208_REG_SCA, regs,
 331                                    ISL1208_ALARM_SECTION_LEN);
 332         if (sr < 0) {
 333                 dev_err(&client->dev, "%s: reading alarm section failed\n",
 334                         __func__);
 335                 return sr;
 336         }
 337
 338         /* MSB of each alarm register is an enable bit */
 339         tm->tm_sec = bcd2bin(regs[ISL1208_REG_SCA - ISL1208_REG_SCA] & 0x7f);
 340         tm->tm_min = bcd2bin(regs[ISL1208_REG_MNA - ISL1208_REG_SCA] & 0x7f);
 341         tm->tm_hour = bcd2bin(regs[ISL1208_REG_HRA - ISL1208_REG_SCA] & 0x3f);
 342         tm->tm_mday = bcd2bin(regs[ISL1208_REG_DTA - ISL1208_REG_SCA] & 0x3f);
 343         tm->tm_mon =
 344                 bcd2bin(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1;
 345         tm->tm_wday = bcd2bin(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03);
 346
 347         /* The alarm doesn't store the year so get it from the rtc section */
 348         yr = i2c_smbus_read_byte_data(client, ISL1208_REG_YR);
 349         if (yr < 0) {
 350                 dev_err(&client->dev, "%s: reading RTC YR failed\n", __func__);
 351                 return yr;
 352         }
 353         tm->tm_year = bcd2bin(yr) + 100;
 354
 355         icr = i2c_smbus_read_byte_data(client, ISL1208_REG_INT);
 356         if (icr < 0) {
 357                 dev_err(&client->dev, "%s: reading INT failed\n", __func__);
 358                 return icr;
 359         }
 360         alarm->enabled = !!(icr & ISL1208_REG_INT_ALME);
 361
 362         return 0;
 363 }
 364
 365 static int
 366 isl1208_i2c_set_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
 367 {
 368         struct rtc_time *alarm_tm = &alarm->time;
 369         u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, };
 370         const int offs = ISL1208_REG_SCA;
 371         struct rtc_time rtc_tm;
 372         int err, enable;
 373
 374         err = isl1208_i2c_read_time(client, &rtc_tm);
 375         if (err)
 376                 return err;
 377
 378         /* If the alarm time is before the current time disable the alarm */
 379         if (!alarm->enabled || rtc_tm_sub(alarm_tm, &rtc_tm) <= 0)
 380                 enable = 0x00;
 381         else
 382                 enable = 0x80;
 383
 384         /* Program the alarm and enable it for each setting */
 385         regs[ISL1208_REG_SCA - offs] = bin2bcd(alarm_tm->tm_sec) | enable;
 386         regs[ISL1208_REG_MNA - offs] = bin2bcd(alarm_tm->tm_min) | enable;
 387         regs[ISL1208_REG_HRA - offs] = bin2bcd(alarm_tm->tm_hour) |
 388                 ISL1208_REG_HR_MIL | enable;
 389
 390         regs[ISL1208_REG_DTA - offs] = bin2bcd(alarm_tm->tm_mday) | enable;
 391         regs[ISL1208_REG_MOA - offs] = bin2bcd(alarm_tm->tm_mon + 1) | enable;
 392         regs[ISL1208_REG_DWA - offs] = bin2bcd(alarm_tm->tm_wday & 7) | enable;
 393
 394         /* write ALARM registers */
 395         err = isl1208_i2c_set_regs(client, offs, regs,
 396                                   ISL1208_ALARM_SECTION_LEN);
 397         if (err < 0) {
 398                 dev_err(&client->dev, "%s: writing ALARM section failed\n",
 399                         __func__);
 400                 return err;
 401         }
 402
 403         err = isl1208_rtc_toggle_alarm(client, enable);
 404         if (err)
 405                 return err;
 406
 407         return 0;
 408 }
 409
 410 static int
 411 isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm)
 412 {
 413         return isl1208_i2c_read_time(to_i2c_client(dev), tm);
 414 }
 415
 416 static int
 417 isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
 418 {
 419         int sr;
 420         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 421
 422         /* The clock has an 8 bit wide bcd-coded register (they never learn)
 423          * for the year. tm_year is an offset from 1900 and we are interested
 424          * in the 2000-2099 range, so any value less than 100 is invalid.
 425          */
 426         if (tm->tm_year < 100)
 427                 return -EINVAL;
 428
 429         regs[ISL1208_REG_SC] = bin2bcd(tm->tm_sec);
 430         regs[ISL1208_REG_MN] = bin2bcd(tm->tm_min);
 431         regs[ISL1208_REG_HR] = bin2bcd(tm->tm_hour) | ISL1208_REG_HR_MIL;
 432
 433         regs[ISL1208_REG_DT] = bin2bcd(tm->tm_mday);
 434         regs[ISL1208_REG_MO] = bin2bcd(tm->tm_mon + 1);
 435         regs[ISL1208_REG_YR] = bin2bcd(tm->tm_year - 100);
 436
 437         regs[ISL1208_REG_DW] = bin2bcd(tm->tm_wday & 7);
 438
 439         sr = isl1208_i2c_get_sr(client);
 440         if (sr < 0) {
 441                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 442                 return sr;
 443         }
 444
 445         /* set WRTC */
 446         sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
 447                                        sr | ISL1208_REG_SR_WRTC);
 448         if (sr < 0) {
 449                 dev_err(&client->dev, "%s: writing SR failed\n", __func__);
 450                 return sr;
 451         }
 452
 453         /* write RTC registers */
 454         sr = isl1208_i2c_set_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
 455         if (sr < 0) {
 456                 dev_err(&client->dev, "%s: writing RTC section failed\n",
 457                         __func__);
 458                 return sr;
 459         }
 460
 461         /* clear WRTC again */
 462         sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
 463                                        sr & ~ISL1208_REG_SR_WRTC);
 464         if (sr < 0) {
 465                 dev_err(&client->dev, "%s: writing SR failed\n", __func__);
 466                 return sr;
 467         }
 468
 469         return 0;
 470 }
 471
 472
 473 static int
 474 isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm)
 475 {
 476         return isl1208_i2c_set_time(to_i2c_client(dev), tm);
 477 }
 478
 479 static int
 480 isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 481 {
 482         return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm);
 483 }
 484
 485 static int
 486 isl1208_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 487 {
 488         return isl1208_i2c_set_alarm(to_i2c_client(dev), alarm);
 489 }
 490
 491 static irqreturn_t
 492 isl1208_rtc_interrupt(int irq, void *data)
 493 {
 494         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
 495         struct i2c_client *client = data;
 496         struct rtc_device *rtc = i2c_get_clientdata(client);
 497         int handled = 0, sr, err;
 498
 499         /*
 500          * I2C reads get NAK'ed if we read straight away after an interrupt?
 501          * Using a mdelay/msleep didn't seem to help either, so we work around
 502          * this by continually trying to read the register for a short time.
 503          */
 504         while (1) {
 505                 sr = isl1208_i2c_get_sr(client);
 506                 if (sr >= 0)
 507                         break;
 508
 509                 if (time_after(jiffies, timeout)) {
 510                         dev_err(&client->dev, "%s: reading SR failed\n",
 511                                 __func__);
 512                         return sr;
 513                 }
 514         }
 515
 516         if (sr & ISL1208_REG_SR_ALM) {
 517                 dev_dbg(&client->dev, "alarm!\n");
 518
 519                 rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF);
 520
 521                 /* Clear the alarm */
 522                 sr &= ~ISL1208_REG_SR_ALM;
 523                 sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, sr);
 524                 if (sr < 0)
 525                         dev_err(&client->dev, "%s: writing SR failed\n",
 526                                 __func__);
 527                 else
 528                         handled = 1;
 529
 530                 /* Disable the alarm */
 531                 err = isl1208_rtc_toggle_alarm(client, 0);
 532                 if (err)
 533                         return err;
 534         }
 535
 536         return handled ? IRQ_HANDLED : IRQ_NONE;
 537 }
 538
 539 static const struct rtc_class_ops isl1208_rtc_ops = {
 540         .proc = isl1208_rtc_proc,
 541         .read_time = isl1208_rtc_read_time,
 542         .set_time = isl1208_rtc_set_time,
 543         .read_alarm = isl1208_rtc_read_alarm,
 544         .set_alarm = isl1208_rtc_set_alarm,
 545 };
 546
 547 /* sysfs interface */
 548
 549 static ssize_t
 550 isl1208_sysfs_show_atrim(struct device *dev,
 551                          struct device_attribute *attr, char *buf)
 552 {
 553         int atr = isl1208_i2c_get_atr(to_i2c_client(dev));
 554         if (atr < 0)
 555                 return atr;
 556
 557         return sprintf(buf, "%d.%.2d pF\n", atr >> 2, (atr & 0x3) * 25);
 558 }
 559
 560 static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL);
 561
 562 static ssize_t
 563 isl1208_sysfs_show_dtrim(struct device *dev,
 564                          struct device_attribute *attr, char *buf)
 565 {
 566         int dtr = isl1208_i2c_get_dtr(to_i2c_client(dev));
 567         if (dtr < 0)
 568                 return dtr;
 569
 570         return sprintf(buf, "%d ppm\n", dtr);
 571 }
 572
 573 static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL);
 574
 575 static ssize_t
 576 isl1208_sysfs_show_usr(struct device *dev,
 577                        struct device_attribute *attr, char *buf)
 578 {
 579         int usr = isl1208_i2c_get_usr(to_i2c_client(dev));
 580         if (usr < 0)
 581                 return usr;
 582
 583         return sprintf(buf, "0x%.4x\n", usr);
 584 }
 585
 586 static ssize_t
 587 isl1208_sysfs_store_usr(struct device *dev,
 588                         struct device_attribute *attr,
 589                         const char *buf, size_t count)
 590 {
 591         int usr = -1;
 592
 593         if (buf[0] == '0' && (buf[1] == 'x' || buf[1] == 'X')) {
 594                 if (sscanf(buf, "%x", &usr) != 1)
 595                         return -EINVAL;
 596         } else {
 597                 if (sscanf(buf, "%d", &usr) != 1)
 598                         return -EINVAL;
 599         }
 600
 601         if (usr < 0 || usr > 0xffff)
 602                 return -EINVAL;
 603
 604         return isl1208_i2c_set_usr(to_i2c_client(dev), usr) ? -EIO : count;
 605 }
 606
 607 static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr,
 608                    isl1208_sysfs_store_usr);
 609
 610 static struct attribute *isl1208_rtc_attrs[] = {
 611         &dev_attr_atrim.attr,
 612         &dev_attr_dtrim.attr,
 613         &dev_attr_usr.attr,
 614         NULL
 615 };
 616
 617 static const struct attribute_group isl1208_rtc_sysfs_files = {
 618         .attrs  = isl1208_rtc_attrs,
 619 };
 620
 621 static int
 622 isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
 623 {
 624         int rc = 0;
 625         struct rtc_device *rtc;
 626
 627         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 628                 return -ENODEV;
 629
 630         if (isl1208_i2c_validate_client(client) < 0)
 631                 return -ENODEV;
 632
 633         if (client->irq > 0) {
 634                 rc = devm_request_threaded_irq(&client->dev, client->irq, NULL,
 635                                                isl1208_rtc_interrupt,
 636                                                IRQF_SHARED | IRQF_ONESHOT,
 637                                                isl1208_driver.driver.name,
 638                                                client);
 639                 if (!rc) {
 640                         device_init_wakeup(&client->dev, 1);
 641                         enable_irq_wake(client->irq);
 642                 } else {
 643                         dev_err(&client->dev,
 644                                 "Unable to request irq %d, no alarm support\n",
 645                                 client->irq);
 646                         client->irq = 0;
 647                 }
 648         }
 649
 650         rtc = devm_rtc_device_register(&client->dev, isl1208_driver.driver.name,
 651                                   &isl1208_rtc_ops,
 652                                   THIS_MODULE);
 653         if (IS_ERR(rtc))
 654                 return PTR_ERR(rtc);
 655
 656         i2c_set_clientdata(client, rtc);
 657
 658         rc = isl1208_i2c_get_sr(client);
 659         if (rc < 0) {
 660                 dev_err(&client->dev, "reading status failed\n");
 661                 return rc;
 662         }
 663
 664         if (rc & ISL1208_REG_SR_RTCF)
 665                 dev_warn(&client->dev, "rtc power failure detected, "
 666                          "please set clock.\n");
 667
 668         rc = sysfs_create_group(&client->dev.kobj, &isl1208_rtc_sysfs_files);
 669         if (rc)
 670                 return rc;
 671
 672         return 0;
 673 }
 674
 675 static int
 676 isl1208_remove(struct i2c_client *client)
 677 {
 678         sysfs_remove_group(&client->dev.kobj, &isl1208_rtc_sysfs_files);
 679
 680         return 0;
 681 }
 682
 683 static const struct i2c_device_id isl1208_id[] = {
 684         { "isl1208", 0 },
 685         { "isl1218", 0 },
 686         { }
 687 };
 688 MODULE_DEVICE_TABLE(i2c, isl1208_id);
 689
 690 static const struct of_device_id isl1208_of_match[] = {
 691         { .compatible = "isil,isl1208" },
 692         { .compatible = "isil,isl1218" },
 693         { }
 694 };
 695 MODULE_DEVICE_TABLE(of, isl1208_of_match);
 696
 697 static struct i2c_driver isl1208_driver = {
 698         .driver = {
 699                 .name = "rtc-isl1208",
 700                 .of_match_table = of_match_ptr(isl1208_of_match),
 701         },
 702         .probe = isl1208_probe,
 703         .remove = isl1208_remove,
 704         .id_table = isl1208_id,
 705 };
 706
 707 module_i2c_driver(isl1208_driver);
 708
 709 MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>");
 710 MODULE_DESCRIPTION("Intersil ISL1208 RTC driver");
 711 MODULE_LICENSE("GPL");