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_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                 {client->addr, 0, sizeof(reg_addr), reg_addr}
  70                 ,
  71                 {client->addr, I2C_M_RD, len, buf}
  72         };
  73         int ret;
  74
  75         BUG_ON(reg > ISL1208_REG_USR2);
  76         BUG_ON(reg + len > ISL1208_REG_USR2 + 1);
  77
  78         ret = i2c_transfer(client->adapter, msgs, 2);
  79         if (ret > 0)
  80                 ret = 0;
  81         return ret;
  82 }
  83
  84 /* block write */
  85 static int
  86 isl1208_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[],
  87                      unsigned len)
  88 {
  89         u8 i2c_buf[ISL1208_REG_USR2 + 2];
  90         struct i2c_msg msgs[1] = {
  91                 {client->addr, 0, len + 1, i2c_buf}
  92         };
  93         int ret;
  94
  95         BUG_ON(reg > ISL1208_REG_USR2);
  96         BUG_ON(reg + len > ISL1208_REG_USR2 + 1);
  97
  98         i2c_buf[0] = reg;
  99         memcpy(&i2c_buf[1], &buf[0], len);
 100
 101         ret = i2c_transfer(client->adapter, msgs, 1);
 102         if (ret > 0)
 103                 ret = 0;
 104         return ret;
 105 }
 106
 107 /* simple check to see wether we have a isl1208 */
 108 static int
 109 isl1208_i2c_validate_client(struct i2c_client *client)
 110 {
 111         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 112         u8 zero_mask[ISL1208_RTC_SECTION_LEN] = {
 113                 0x80, 0x80, 0x40, 0xc0, 0xe0, 0x00, 0xf8
 114         };
 115         int i;
 116         int ret;
 117
 118         ret = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
 119         if (ret < 0)
 120                 return ret;
 121
 122         for (i = 0; i < ISL1208_RTC_SECTION_LEN; ++i) {
 123                 if (regs[i] & zero_mask[i])     /* check if bits are cleared */
 124                         return -ENODEV;
 125         }
 126
 127         return 0;
 128 }
 129
 130 static int
 131 isl1208_i2c_get_sr(struct i2c_client *client)
 132 {
 133         int sr = i2c_smbus_read_byte_data(client, ISL1208_REG_SR);
 134         if (sr < 0)
 135                 return -EIO;
 136
 137         return sr;
 138 }
 139
 140 static int
 141 isl1208_i2c_get_atr(struct i2c_client *client)
 142 {
 143         int atr = i2c_smbus_read_byte_data(client, ISL1208_REG_ATR);
 144         if (atr < 0)
 145                 return atr;
 146
 147         /* The 6bit value in the ATR register controls the load
 148          * capacitance C_load * in steps of 0.25pF
 149          *
 150          * bit (1<<5) of the ATR register is inverted
 151          *
 152          * C_load(ATR=0x20) =  4.50pF
 153          * C_load(ATR=0x00) = 12.50pF
 154          * C_load(ATR=0x1f) = 20.25pF
 155          *
 156          */
 157
 158         atr &= 0x3f;            /* mask out lsb */
 159         atr ^= 1 << 5;          /* invert 6th bit */
 160         atr += 2 * 9;           /* add offset of 4.5pF; unit[atr] = 0.25pF */
 161
 162         return atr;
 163 }
 164
 165 static int
 166 isl1208_i2c_get_dtr(struct i2c_client *client)
 167 {
 168         int dtr = i2c_smbus_read_byte_data(client, ISL1208_REG_DTR);
 169         if (dtr < 0)
 170                 return -EIO;
 171
 172         /* dtr encodes adjustments of {-60,-40,-20,0,20,40,60} ppm */
 173         dtr = ((dtr & 0x3) * 20) * (dtr & (1 << 2) ? -1 : 1);
 174
 175         return dtr;
 176 }
 177
 178 static int
 179 isl1208_i2c_get_usr(struct i2c_client *client)
 180 {
 181         u8 buf[ISL1208_USR_SECTION_LEN] = { 0, };
 182         int ret;
 183
 184         ret = isl1208_i2c_read_regs(client, ISL1208_REG_USR1, buf,
 185                                     ISL1208_USR_SECTION_LEN);
 186         if (ret < 0)
 187                 return ret;
 188
 189         return (buf[1] << 8) | buf[0];
 190 }
 191
 192 static int
 193 isl1208_i2c_set_usr(struct i2c_client *client, u16 usr)
 194 {
 195         u8 buf[ISL1208_USR_SECTION_LEN];
 196
 197         buf[0] = usr & 0xff;
 198         buf[1] = (usr >> 8) & 0xff;
 199
 200         return isl1208_i2c_set_regs(client, ISL1208_REG_USR1, buf,
 201                                     ISL1208_USR_SECTION_LEN);
 202 }
 203
 204 static int
 205 isl1208_rtc_proc(struct device *dev, struct seq_file *seq)
 206 {
 207         struct i2c_client *const client = to_i2c_client(dev);
 208         int sr, dtr, atr, usr;
 209
 210         sr = isl1208_i2c_get_sr(client);
 211         if (sr < 0) {
 212                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 213                 return sr;
 214         }
 215
 216         seq_printf(seq, "status_reg\t:%s%s%s%s%s%s (0x%.2x)\n",
 217                    (sr & ISL1208_REG_SR_RTCF) ? " RTCF" : "",
 218                    (sr & ISL1208_REG_SR_BAT) ? " BAT" : "",
 219                    (sr & ISL1208_REG_SR_ALM) ? " ALM" : "",
 220                    (sr & ISL1208_REG_SR_WRTC) ? " WRTC" : "",
 221                    (sr & ISL1208_REG_SR_XTOSCB) ? " XTOSCB" : "",
 222                    (sr & ISL1208_REG_SR_ARST) ? " ARST" : "", sr);
 223
 224         seq_printf(seq, "batt_status\t: %s\n",
 225                    (sr & ISL1208_REG_SR_RTCF) ? "bad" : "okay");
 226
 227         dtr = isl1208_i2c_get_dtr(client);
 228         if (dtr >= 0 - 1)
 229                 seq_printf(seq, "digital_trim\t: %d ppm\n", dtr);
 230
 231         atr = isl1208_i2c_get_atr(client);
 232         if (atr >= 0)
 233                 seq_printf(seq, "analog_trim\t: %d.%.2d pF\n",
 234                            atr >> 2, (atr & 0x3) * 25);
 235
 236         usr = isl1208_i2c_get_usr(client);
 237         if (usr >= 0)
 238                 seq_printf(seq, "user_data\t: 0x%.4x\n", usr);
 239
 240         return 0;
 241 }
 242
 243 static int
 244 isl1208_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
 245 {
 246         int sr;
 247         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 248
 249         sr = isl1208_i2c_get_sr(client);
 250         if (sr < 0) {
 251                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 252                 return -EIO;
 253         }
 254
 255         sr = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
 256         if (sr < 0) {
 257                 dev_err(&client->dev, "%s: reading RTC section failed\n",
 258                         __func__);
 259                 return sr;
 260         }
 261
 262         tm->tm_sec = BCD2BIN(regs[ISL1208_REG_SC]);
 263         tm->tm_min = BCD2BIN(regs[ISL1208_REG_MN]);
 264
 265         /* HR field has a more complex interpretation */
 266         {
 267                 const u8 _hr = regs[ISL1208_REG_HR];
 268                 if (_hr & ISL1208_REG_HR_MIL)   /* 24h format */
 269                         tm->tm_hour = BCD2BIN(_hr & 0x3f);
 270                 else {
 271                         /* 12h format */
 272                         tm->tm_hour = BCD2BIN(_hr & 0x1f);
 273                         if (_hr & ISL1208_REG_HR_PM)    /* PM flag set */
 274                                 tm->tm_hour += 12;
 275                 }
 276         }
 277
 278         tm->tm_mday = BCD2BIN(regs[ISL1208_REG_DT]);
 279         tm->tm_mon = BCD2BIN(regs[ISL1208_REG_MO]) - 1; /* rtc starts at 1 */
 280         tm->tm_year = BCD2BIN(regs[ISL1208_REG_YR]) + 100;
 281         tm->tm_wday = BCD2BIN(regs[ISL1208_REG_DW]);
 282
 283         return 0;
 284 }
 285
 286 static int
 287 isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
 288 {
 289         struct rtc_time *const tm = &alarm->time;
 290         u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, };
 291         int sr;
 292
 293         sr = isl1208_i2c_get_sr(client);
 294         if (sr < 0) {
 295                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 296                 return sr;
 297         }
 298
 299         sr = isl1208_i2c_read_regs(client, ISL1208_REG_SCA, regs,
 300                                    ISL1208_ALARM_SECTION_LEN);
 301         if (sr < 0) {
 302                 dev_err(&client->dev, "%s: reading alarm section failed\n",
 303                         __func__);
 304                 return sr;
 305         }
 306
 307         /* MSB of each alarm register is an enable bit */
 308         tm->tm_sec = BCD2BIN(regs[ISL1208_REG_SCA - ISL1208_REG_SCA] & 0x7f);
 309         tm->tm_min = BCD2BIN(regs[ISL1208_REG_MNA - ISL1208_REG_SCA] & 0x7f);
 310         tm->tm_hour = BCD2BIN(regs[ISL1208_REG_HRA - ISL1208_REG_SCA] & 0x3f);
 311         tm->tm_mday = BCD2BIN(regs[ISL1208_REG_DTA - ISL1208_REG_SCA] & 0x3f);
 312         tm->tm_mon =
 313                 BCD2BIN(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1;
 314         tm->tm_wday = BCD2BIN(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03);
 315
 316         return 0;
 317 }
 318
 319 static int
 320 isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm)
 321 {
 322         return isl1208_i2c_read_time(to_i2c_client(dev), tm);
 323 }
 324
 325 static int
 326 isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
 327 {
 328         int sr;
 329         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 330
 331         regs[ISL1208_REG_SC] = BIN2BCD(tm->tm_sec);
 332         regs[ISL1208_REG_MN] = BIN2BCD(tm->tm_min);
 333         regs[ISL1208_REG_HR] = BIN2BCD(tm->tm_hour) | ISL1208_REG_HR_MIL;
 334
 335         regs[ISL1208_REG_DT] = BIN2BCD(tm->tm_mday);
 336         regs[ISL1208_REG_MO] = BIN2BCD(tm->tm_mon + 1);
 337         regs[ISL1208_REG_YR] = BIN2BCD(tm->tm_year - 100);
 338
 339         regs[ISL1208_REG_DW] = BIN2BCD(tm->tm_wday & 7);
 340
 341         sr = isl1208_i2c_get_sr(client);
 342         if (sr < 0) {
 343                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 344                 return sr;
 345         }
 346
 347         /* set WRTC */
 348         sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
 349                                        sr | ISL1208_REG_SR_WRTC);
 350         if (sr < 0) {
 351                 dev_err(&client->dev, "%s: writing SR failed\n", __func__);
 352                 return sr;
 353         }
 354
 355         /* write RTC registers */
 356         sr = isl1208_i2c_set_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
 357         if (sr < 0) {
 358                 dev_err(&client->dev, "%s: writing RTC section failed\n",
 359                         __func__);
 360                 return sr;
 361         }
 362
 363         /* clear WRTC again */
 364         sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
 365                                        sr & ~ISL1208_REG_SR_WRTC);
 366         if (sr < 0) {
 367                 dev_err(&client->dev, "%s: writing SR failed\n", __func__);
 368                 return sr;
 369         }
 370
 371         return 0;
 372 }
 373
 374
 375 static int
 376 isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm)
 377 {
 378         return isl1208_i2c_set_time(to_i2c_client(dev), tm);
 379 }
 380
 381 static int
 382 isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 383 {
 384         return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm);
 385 }
 386
 387 static const struct rtc_class_ops isl1208_rtc_ops = {
 388         .proc = isl1208_rtc_proc,
 389         .read_time = isl1208_rtc_read_time,
 390         .set_time = isl1208_rtc_set_time,
 391         .read_alarm = isl1208_rtc_read_alarm,
 392         /*.set_alarm    = isl1208_rtc_set_alarm, */
 393 };
 394
 395 /* sysfs interface */
 396
 397 static ssize_t
 398 isl1208_sysfs_show_atrim(struct device *dev,
 399                          struct device_attribute *attr, char *buf)
 400 {
 401         int atr = isl1208_i2c_get_atr(to_i2c_client(dev));
 402         if (atr < 0)
 403                 return atr;
 404
 405         return sprintf(buf, "%d.%.2d pF\n", atr >> 2, (atr & 0x3) * 25);
 406 }
 407
 408 static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL);
 409
 410 static ssize_t
 411 isl1208_sysfs_show_dtrim(struct device *dev,
 412                          struct device_attribute *attr, char *buf)
 413 {
 414         int dtr = isl1208_i2c_get_dtr(to_i2c_client(dev));
 415         if (dtr < 0)
 416                 return dtr;
 417
 418         return sprintf(buf, "%d ppm\n", dtr);
 419 }
 420
 421 static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL);
 422
 423 static ssize_t
 424 isl1208_sysfs_show_usr(struct device *dev,
 425                        struct device_attribute *attr, char *buf)
 426 {
 427         int usr = isl1208_i2c_get_usr(to_i2c_client(dev));
 428         if (usr < 0)
 429                 return usr;
 430
 431         return sprintf(buf, "0x%.4x\n", usr);
 432 }
 433
 434 static ssize_t
 435 isl1208_sysfs_store_usr(struct device *dev,
 436                         struct device_attribute *attr,
 437                         const char *buf, size_t count)
 438 {
 439         int usr = -1;
 440
 441         if (buf[0] == '0' && (buf[1] == 'x' || buf[1] == 'X')) {
 442                 if (sscanf(buf, "%x", &usr) != 1)
 443                         return -EINVAL;
 444         } else {
 445                 if (sscanf(buf, "%d", &usr) != 1)
 446                         return -EINVAL;
 447         }
 448
 449         if (usr < 0 || usr > 0xffff)
 450                 return -EINVAL;
 451
 452         return isl1208_i2c_set_usr(to_i2c_client(dev), usr) ? -EIO : count;
 453 }
 454
 455 static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr,
 456                    isl1208_sysfs_store_usr);
 457
 458 static int
 459 isl1208_sysfs_register(struct device *dev)
 460 {
 461         int err;
 462
 463         err = device_create_file(dev, &dev_attr_atrim);
 464         if (err)
 465                 return err;
 466
 467         err = device_create_file(dev, &dev_attr_dtrim);
 468         if (err) {
 469                 device_remove_file(dev, &dev_attr_atrim);
 470                 return err;
 471         }
 472
 473         err = device_create_file(dev, &dev_attr_usr);
 474         if (err) {
 475                 device_remove_file(dev, &dev_attr_atrim);
 476                 device_remove_file(dev, &dev_attr_dtrim);
 477         }
 478
 479         return 0;
 480 }
 481
 482 static int
 483 isl1208_sysfs_unregister(struct device *dev)
 484 {
 485         device_remove_file(dev, &dev_attr_atrim);
 486         device_remove_file(dev, &dev_attr_atrim);
 487         device_remove_file(dev, &dev_attr_usr);
 488
 489         return 0;
 490 }
 491
 492 static int
 493 isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
 494 {
 495         int rc = 0;
 496         struct rtc_device *rtc;
 497
 498         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 499                 return -ENODEV;
 500
 501         if (isl1208_i2c_validate_client(client) < 0)
 502                 return -ENODEV;
 503
 504         dev_info(&client->dev,
 505                  "chip found, driver version " DRV_VERSION "\n");
 506
 507         rtc = rtc_device_register(isl1208_driver.driver.name,
 508                                   &client->dev, &isl1208_rtc_ops,
 509                                   THIS_MODULE);
 510         if (IS_ERR(rtc))
 511                 return PTR_ERR(rtc);
 512
 513         i2c_set_clientdata(client, rtc);
 514
 515         rc = isl1208_i2c_get_sr(client);
 516         if (rc < 0) {
 517                 dev_err(&client->dev, "reading status failed\n");
 518                 goto exit_unregister;
 519         }
 520
 521         if (rc & ISL1208_REG_SR_RTCF)
 522                 dev_warn(&client->dev, "rtc power failure detected, "
 523                          "please set clock.\n");
 524
 525         rc = isl1208_sysfs_register(&client->dev);
 526         if (rc)
 527                 goto exit_unregister;
 528
 529         return 0;
 530
 531 exit_unregister:
 532         rtc_device_unregister(rtc);
 533
 534         return rc;
 535 }
 536
 537 static int
 538 isl1208_remove(struct i2c_client *client)
 539 {
 540         struct rtc_device *rtc = i2c_get_clientdata(client);
 541
 542         isl1208_sysfs_unregister(&client->dev);
 543         rtc_device_unregister(rtc);
 544
 545         return 0;
 546 }
 547
 548 static const struct i2c_device_id isl1208_id[] = {
 549         { "isl1208", 0 },
 550         { }
 551 };
 552 MODULE_DEVICE_TABLE(i2c, isl1208_id);
 553
 554 static struct i2c_driver isl1208_driver = {
 555         .driver = {
 556                    .name = "rtc-isl1208",
 557                    },
 558         .probe = isl1208_probe,
 559         .remove = isl1208_remove,
 560         .id_table = isl1208_id,
 561 };
 562
 563 static int __init
 564 isl1208_init(void)
 565 {
 566         return i2c_add_driver(&isl1208_driver);
 567 }
 568
 569 static void __exit
 570 isl1208_exit(void)
 571 {
 572         i2c_del_driver(&isl1208_driver);
 573 }
 574
 575 MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>");
 576 MODULE_DESCRIPTION("Intersil ISL1208 RTC driver");
 577 MODULE_LICENSE("GPL");
 578 MODULE_VERSION(DRV_VERSION);
 579
 580 module_init(isl1208_init);
 581 module_exit(isl1208_exit);