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