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         struct rtc_time rtc_tm;
 374         int err, enable;
 375
 376         err = isl1208_i2c_read_time(client, &rtc_tm);
 377         if (err)
 378                 return err;
 379
 380         /* If the alarm time is before the current time disable the alarm */
 381         if (!alarm->enabled || rtc_tm_sub(alarm_tm, &rtc_tm) <= 0)
 382                 enable = 0x00;
 383         else
 384                 enable = 0x80;
 385
 386         /* Program the alarm and enable it for each setting */
 387         regs[ISL1208_REG_SCA - offs] = bin2bcd(alarm_tm->tm_sec) | enable;
 388         regs[ISL1208_REG_MNA - offs] = bin2bcd(alarm_tm->tm_min) | enable;
 389         regs[ISL1208_REG_HRA - offs] = bin2bcd(alarm_tm->tm_hour) |
 390                 ISL1208_REG_HR_MIL | enable;
 391
 392         regs[ISL1208_REG_DTA - offs] = bin2bcd(alarm_tm->tm_mday) | enable;
 393         regs[ISL1208_REG_MOA - offs] = bin2bcd(alarm_tm->tm_mon + 1) | enable;
 394         regs[ISL1208_REG_DWA - offs] = bin2bcd(alarm_tm->tm_wday & 7) | enable;
 395
 396         /* write ALARM registers */
 397         err = isl1208_i2c_set_regs(client, offs, regs,
 398                                   ISL1208_ALARM_SECTION_LEN);
 399         if (err < 0) {
 400                 dev_err(&client->dev, "%s: writing ALARM section failed\n",
 401                         __func__);
 402                 return err;
 403         }
 404
 405         err = isl1208_rtc_toggle_alarm(client, enable);
 406         if (err)
 407                 return err;
 408
 409         return 0;
 410 }
 411
 412 static int
 413 isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm)
 414 {
 415         return isl1208_i2c_read_time(to_i2c_client(dev), tm);
 416 }
 417
 418 static int
 419 isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
 420 {
 421         int sr;
 422         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 423
 424         /* The clock has an 8 bit wide bcd-coded register (they never learn)
 425          * for the year. tm_year is an offset from 1900 and we are interested
 426          * in the 2000-2099 range, so any value less than 100 is invalid.
 427          */
 428         if (tm->tm_year < 100)
 429                 return -EINVAL;
 430
 431         regs[ISL1208_REG_SC] = bin2bcd(tm->tm_sec);
 432         regs[ISL1208_REG_MN] = bin2bcd(tm->tm_min);
 433         regs[ISL1208_REG_HR] = bin2bcd(tm->tm_hour) | ISL1208_REG_HR_MIL;
 434
 435         regs[ISL1208_REG_DT] = bin2bcd(tm->tm_mday);
 436         regs[ISL1208_REG_MO] = bin2bcd(tm->tm_mon + 1);
 437         regs[ISL1208_REG_YR] = bin2bcd(tm->tm_year - 100);
 438
 439         regs[ISL1208_REG_DW] = bin2bcd(tm->tm_wday & 7);
 440
 441         sr = isl1208_i2c_get_sr(client);
 442         if (sr < 0) {
 443                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 444                 return sr;
 445         }
 446
 447         /* set WRTC */
 448         sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
 449                                        sr | ISL1208_REG_SR_WRTC);
 450         if (sr < 0) {
 451                 dev_err(&client->dev, "%s: writing SR failed\n", __func__);
 452                 return sr;
 453         }
 454
 455         /* write RTC registers */
 456         sr = isl1208_i2c_set_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
 457         if (sr < 0) {
 458                 dev_err(&client->dev, "%s: writing RTC section failed\n",
 459                         __func__);
 460                 return sr;
 461         }
 462
 463         /* clear WRTC again */
 464         sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
 465                                        sr & ~ISL1208_REG_SR_WRTC);
 466         if (sr < 0) {
 467                 dev_err(&client->dev, "%s: writing SR failed\n", __func__);
 468                 return sr;
 469         }
 470
 471         return 0;
 472 }
 473
 474
 475 static int
 476 isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm)
 477 {
 478         return isl1208_i2c_set_time(to_i2c_client(dev), tm);
 479 }
 480
 481 static int
 482 isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 483 {
 484         return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm);
 485 }
 486
 487 static int
 488 isl1208_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 489 {
 490         return isl1208_i2c_set_alarm(to_i2c_client(dev), alarm);
 491 }
 492
 493 static irqreturn_t
 494 isl1208_rtc_interrupt(int irq, void *data)
 495 {
 496         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
 497         struct i2c_client *client = data;
 498         struct rtc_device *rtc = i2c_get_clientdata(client);
 499         int handled = 0, sr, err;
 500
 501         /*
 502          * I2C reads get NAK'ed if we read straight away after an interrupt?
 503          * Using a mdelay/msleep didn't seem to help either, so we work around
 504          * this by continually trying to read the register for a short time.
 505          */
 506         while (1) {
 507                 sr = isl1208_i2c_get_sr(client);
 508                 if (sr >= 0)
 509                         break;
 510
 511                 if (time_after(jiffies, timeout)) {
 512                         dev_err(&client->dev, "%s: reading SR failed\n",
 513                                 __func__);
 514                         return sr;
 515                 }
 516         }
 517
 518         if (sr & ISL1208_REG_SR_ALM) {
 519                 dev_dbg(&client->dev, "alarm!\n");
 520
 521                 rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF);
 522
 523                 /* Clear the alarm */
 524                 sr &= ~ISL1208_REG_SR_ALM;
 525                 sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, sr);
 526                 if (sr < 0)
 527                         dev_err(&client->dev, "%s: writing SR failed\n",
 528                                 __func__);
 529                 else
 530                         handled = 1;
 531
 532                 /* Disable the alarm */
 533                 err = isl1208_rtc_toggle_alarm(client, 0);
 534                 if (err)
 535                         return err;
 536         }
 537
 538         return handled ? IRQ_HANDLED : IRQ_NONE;
 539 }
 540
 541 static const struct rtc_class_ops isl1208_rtc_ops = {
 542         .proc = isl1208_rtc_proc,
 543         .read_time = isl1208_rtc_read_time,
 544         .set_time = isl1208_rtc_set_time,
 545         .read_alarm = isl1208_rtc_read_alarm,
 546         .set_alarm = isl1208_rtc_set_alarm,
 547 };
 548
 549 /* sysfs interface */
 550
 551 static ssize_t
 552 isl1208_sysfs_show_atrim(struct device *dev,
 553                          struct device_attribute *attr, char *buf)
 554 {
 555         int atr = isl1208_i2c_get_atr(to_i2c_client(dev));
 556         if (atr < 0)
 557                 return atr;
 558
 559         return sprintf(buf, "%d.%.2d pF\n", atr >> 2, (atr & 0x3) * 25);
 560 }
 561
 562 static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL);
 563
 564 static ssize_t
 565 isl1208_sysfs_show_dtrim(struct device *dev,
 566                          struct device_attribute *attr, char *buf)
 567 {
 568         int dtr = isl1208_i2c_get_dtr(to_i2c_client(dev));
 569         if (dtr < 0)
 570                 return dtr;
 571
 572         return sprintf(buf, "%d ppm\n", dtr);
 573 }
 574
 575 static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL);
 576
 577 static ssize_t
 578 isl1208_sysfs_show_usr(struct device *dev,
 579                        struct device_attribute *attr, char *buf)
 580 {
 581         int usr = isl1208_i2c_get_usr(to_i2c_client(dev));
 582         if (usr < 0)
 583                 return usr;
 584
 585         return sprintf(buf, "0x%.4x\n", usr);
 586 }
 587
 588 static ssize_t
 589 isl1208_sysfs_store_usr(struct device *dev,
 590                         struct device_attribute *attr,
 591                         const char *buf, size_t count)
 592 {
 593         int usr = -1;
 594
 595         if (buf[0] == '0' && (buf[1] == 'x' || buf[1] == 'X')) {
 596                 if (sscanf(buf, "%x", &usr) != 1)
 597                         return -EINVAL;
 598         } else {
 599                 if (sscanf(buf, "%d", &usr) != 1)
 600                         return -EINVAL;
 601         }
 602
 603         if (usr < 0 || usr > 0xffff)
 604                 return -EINVAL;
 605
 606         return isl1208_i2c_set_usr(to_i2c_client(dev), usr) ? -EIO : count;
 607 }
 608
 609 static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr,
 610                    isl1208_sysfs_store_usr);
 611
 612 static struct attribute *isl1208_rtc_attrs[] = {
 613         &dev_attr_atrim.attr,
 614         &dev_attr_dtrim.attr,
 615         &dev_attr_usr.attr,
 616         NULL
 617 };
 618
 619 static const struct attribute_group isl1208_rtc_sysfs_files = {
 620         .attrs  = isl1208_rtc_attrs,
 621 };
 622
 623 static int
 624 isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
 625 {
 626         int rc = 0;
 627         struct rtc_device *rtc;
 628
 629         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 630                 return -ENODEV;
 631
 632         if (isl1208_i2c_validate_client(client) < 0)
 633                 return -ENODEV;
 634
 635         dev_info(&client->dev,
 636                  "chip found, driver version " DRV_VERSION "\n");
 637
 638         if (client->irq > 0) {
 639                 rc = devm_request_threaded_irq(&client->dev, client->irq, NULL,
 640                                                isl1208_rtc_interrupt,
 641                                                IRQF_SHARED,
 642                                                isl1208_driver.driver.name,
 643                                                client);
 644                 if (!rc) {
 645                         device_init_wakeup(&client->dev, 1);
 646                         enable_irq_wake(client->irq);
 647                 } else {
 648                         dev_err(&client->dev,
 649                                 "Unable to request irq %d, no alarm support\n",
 650                                 client->irq);
 651                         client->irq = 0;
 652                 }
 653         }
 654
 655         rtc = devm_rtc_device_register(&client->dev, isl1208_driver.driver.name,
 656                                   &isl1208_rtc_ops,
 657                                   THIS_MODULE);
 658         if (IS_ERR(rtc))
 659                 return PTR_ERR(rtc);
 660
 661         i2c_set_clientdata(client, rtc);
 662
 663         rc = isl1208_i2c_get_sr(client);
 664         if (rc < 0) {
 665                 dev_err(&client->dev, "reading status failed\n");
 666                 return rc;
 667         }
 668
 669         if (rc & ISL1208_REG_SR_RTCF)
 670                 dev_warn(&client->dev, "rtc power failure detected, "
 671                          "please set clock.\n");
 672
 673         rc = sysfs_create_group(&client->dev.kobj, &isl1208_rtc_sysfs_files);
 674         if (rc)
 675                 return rc;
 676
 677         return 0;
 678 }
 679
 680 static int
 681 isl1208_remove(struct i2c_client *client)
 682 {
 683         sysfs_remove_group(&client->dev.kobj, &isl1208_rtc_sysfs_files);
 684
 685         return 0;
 686 }
 687
 688 static const struct i2c_device_id isl1208_id[] = {
 689         { "isl1208", 0 },
 690         { "isl1218", 0 },
 691         { }
 692 };
 693 MODULE_DEVICE_TABLE(i2c, isl1208_id);
 694
 695 static struct i2c_driver isl1208_driver = {
 696         .driver = {
 697                    .name = "rtc-isl1208",
 698                    },
 699         .probe = isl1208_probe,
 700         .remove = isl1208_remove,
 701         .id_table = isl1208_id,
 702 };
 703
 704 module_i2c_driver(isl1208_driver);
 705
 706 MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>");
 707 MODULE_DESCRIPTION("Intersil ISL1208 RTC driver");
 708 MODULE_LICENSE("GPL");
 709 MODULE_VERSION(DRV_VERSION);