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         /* The clock has an 8 bit wide bcd-coded register (they never learn)
 332          * for the year. tm_year is an offset from 1900 and we are interested
 333          * in the 2000-2099 range, so any value less than 100 is invalid.
 334          */
 335         if (tm->tm_year < 100)
 336                 return -EINVAL;
 337
 338         regs[ISL1208_REG_SC] = bin2bcd(tm->tm_sec);
 339         regs[ISL1208_REG_MN] = bin2bcd(tm->tm_min);
 340         regs[ISL1208_REG_HR] = bin2bcd(tm->tm_hour) | ISL1208_REG_HR_MIL;
 341
 342         regs[ISL1208_REG_DT] = bin2bcd(tm->tm_mday);
 343         regs[ISL1208_REG_MO] = bin2bcd(tm->tm_mon + 1);
 344         regs[ISL1208_REG_YR] = bin2bcd(tm->tm_year - 100);
 345
 346         regs[ISL1208_REG_DW] = bin2bcd(tm->tm_wday & 7);
 347
 348         sr = isl1208_i2c_get_sr(client);
 349         if (sr < 0) {
 350                 dev_err(&client->dev, "%s: reading SR failed\n", __func__);
 351                 return sr;
 352         }
 353
 354         /* set WRTC */
 355         sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
 356                                        sr | ISL1208_REG_SR_WRTC);
 357         if (sr < 0) {
 358                 dev_err(&client->dev, "%s: writing SR failed\n", __func__);
 359                 return sr;
 360         }
 361
 362         /* write RTC registers */
 363         sr = isl1208_i2c_set_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
 364         if (sr < 0) {
 365                 dev_err(&client->dev, "%s: writing RTC section failed\n",
 366                         __func__);
 367                 return sr;
 368         }
 369
 370         /* clear WRTC again */
 371         sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
 372                                        sr & ~ISL1208_REG_SR_WRTC);
 373         if (sr < 0) {
 374                 dev_err(&client->dev, "%s: writing SR failed\n", __func__);
 375                 return sr;
 376         }
 377
 378         return 0;
 379 }
 380
 381
 382 static int
 383 isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm)
 384 {
 385         return isl1208_i2c_set_time(to_i2c_client(dev), tm);
 386 }
 387
 388 static int
 389 isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 390 {
 391         return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm);
 392 }
 393
 394 static const struct rtc_class_ops isl1208_rtc_ops = {
 395         .proc = isl1208_rtc_proc,
 396         .read_time = isl1208_rtc_read_time,
 397         .set_time = isl1208_rtc_set_time,
 398         .read_alarm = isl1208_rtc_read_alarm,
 399         /*.set_alarm    = isl1208_rtc_set_alarm, */
 400 };
 401
 402 /* sysfs interface */
 403
 404 static ssize_t
 405 isl1208_sysfs_show_atrim(struct device *dev,
 406                          struct device_attribute *attr, char *buf)
 407 {
 408         int atr = isl1208_i2c_get_atr(to_i2c_client(dev));
 409         if (atr < 0)
 410                 return atr;
 411
 412         return sprintf(buf, "%d.%.2d pF\n", atr >> 2, (atr & 0x3) * 25);
 413 }
 414
 415 static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL);
 416
 417 static ssize_t
 418 isl1208_sysfs_show_dtrim(struct device *dev,
 419                          struct device_attribute *attr, char *buf)
 420 {
 421         int dtr = isl1208_i2c_get_dtr(to_i2c_client(dev));
 422         if (dtr < 0)
 423                 return dtr;
 424
 425         return sprintf(buf, "%d ppm\n", dtr);
 426 }
 427
 428 static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL);
 429
 430 static ssize_t
 431 isl1208_sysfs_show_usr(struct device *dev,
 432                        struct device_attribute *attr, char *buf)
 433 {
 434         int usr = isl1208_i2c_get_usr(to_i2c_client(dev));
 435         if (usr < 0)
 436                 return usr;
 437
 438         return sprintf(buf, "0x%.4x\n", usr);
 439 }
 440
 441 static ssize_t
 442 isl1208_sysfs_store_usr(struct device *dev,
 443                         struct device_attribute *attr,
 444                         const char *buf, size_t count)
 445 {
 446         int usr = -1;
 447
 448         if (buf[0] == '0' && (buf[1] == 'x' || buf[1] == 'X')) {
 449                 if (sscanf(buf, "%x", &usr) != 1)
 450                         return -EINVAL;
 451         } else {
 452                 if (sscanf(buf, "%d", &usr) != 1)
 453                         return -EINVAL;
 454         }
 455
 456         if (usr < 0 || usr > 0xffff)
 457                 return -EINVAL;
 458
 459         return isl1208_i2c_set_usr(to_i2c_client(dev), usr) ? -EIO : count;
 460 }
 461
 462 static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr,
 463                    isl1208_sysfs_store_usr);
 464
 465 static struct attribute *isl1208_rtc_attrs[] = {
 466         &dev_attr_atrim.attr,
 467         &dev_attr_dtrim.attr,
 468         &dev_attr_usr.attr,
 469         NULL
 470 };
 471
 472 static const struct attribute_group isl1208_rtc_sysfs_files = {
 473         .attrs  = isl1208_rtc_attrs,
 474 };
 475
 476 static int
 477 isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
 478 {
 479         int rc = 0;
 480         struct rtc_device *rtc;
 481
 482         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 483                 return -ENODEV;
 484
 485         if (isl1208_i2c_validate_client(client) < 0)
 486                 return -ENODEV;
 487
 488         dev_info(&client->dev,
 489                  "chip found, driver version " DRV_VERSION "\n");
 490
 491         rtc = rtc_device_register(isl1208_driver.driver.name,
 492                                   &client->dev, &isl1208_rtc_ops,
 493                                   THIS_MODULE);
 494         if (IS_ERR(rtc))
 495                 return PTR_ERR(rtc);
 496
 497         i2c_set_clientdata(client, rtc);
 498
 499         rc = isl1208_i2c_get_sr(client);
 500         if (rc < 0) {
 501                 dev_err(&client->dev, "reading status failed\n");
 502                 goto exit_unregister;
 503         }
 504
 505         if (rc & ISL1208_REG_SR_RTCF)
 506                 dev_warn(&client->dev, "rtc power failure detected, "
 507                          "please set clock.\n");
 508
 509         rc = sysfs_create_group(&client->dev.kobj, &isl1208_rtc_sysfs_files);
 510         if (rc)
 511                 goto exit_unregister;
 512
 513         return 0;
 514
 515 exit_unregister:
 516         rtc_device_unregister(rtc);
 517
 518         return rc;
 519 }
 520
 521 static int
 522 isl1208_remove(struct i2c_client *client)
 523 {
 524         struct rtc_device *rtc = i2c_get_clientdata(client);
 525
 526         sysfs_remove_group(&client->dev.kobj, &isl1208_rtc_sysfs_files);
 527         rtc_device_unregister(rtc);
 528
 529         return 0;
 530 }
 531
 532 static const struct i2c_device_id isl1208_id[] = {
 533         { "isl1208", 0 },
 534         { }
 535 };
 536 MODULE_DEVICE_TABLE(i2c, isl1208_id);
 537
 538 static struct i2c_driver isl1208_driver = {
 539         .driver = {
 540                    .name = "rtc-isl1208",
 541                    },
 542         .probe = isl1208_probe,
 543         .remove = isl1208_remove,
 544         .id_table = isl1208_id,
 545 };
 546
 547 static int __init
 548 isl1208_init(void)
 549 {
 550         return i2c_add_driver(&isl1208_driver);
 551 }
 552
 553 static void __exit
 554 isl1208_exit(void)
 555 {
 556         i2c_del_driver(&isl1208_driver);
 557 }
 558
 559 MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>");
 560 MODULE_DESCRIPTION("Intersil ISL1208 RTC driver");
 561 MODULE_LICENSE("GPL");
 562 MODULE_VERSION(DRV_VERSION);
 563
 564 module_init(isl1208_init);
 565 module_exit(isl1208_exit);