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 int
 466 isl1208_sysfs_register(struct device *dev)
 467 {
 468         int err;
 469
 470         err = device_create_file(dev, &dev_attr_atrim);
 471         if (err)
 472                 return err;
 473
 474         err = device_create_file(dev, &dev_attr_dtrim);
 475         if (err) {
 476                 device_remove_file(dev, &dev_attr_atrim);
 477                 return err;
 478         }
 479
 480         err = device_create_file(dev, &dev_attr_usr);
 481         if (err) {
 482                 device_remove_file(dev, &dev_attr_atrim);
 483                 device_remove_file(dev, &dev_attr_dtrim);
 484         }
 485
 486         return 0;
 487 }
 488
 489 static int
 490 isl1208_sysfs_unregister(struct device *dev)
 491 {
 492         device_remove_file(dev, &dev_attr_dtrim);
 493         device_remove_file(dev, &dev_attr_atrim);
 494         device_remove_file(dev, &dev_attr_usr);
 495
 496         return 0;
 497 }
 498
 499 static int
 500 isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
 501 {
 502         int rc = 0;
 503         struct rtc_device *rtc;
 504
 505         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 506                 return -ENODEV;
 507
 508         if (isl1208_i2c_validate_client(client) < 0)
 509                 return -ENODEV;
 510
 511         dev_info(&client->dev,
 512                  "chip found, driver version " DRV_VERSION "\n");
 513
 514         rtc = rtc_device_register(isl1208_driver.driver.name,
 515                                   &client->dev, &isl1208_rtc_ops,
 516                                   THIS_MODULE);
 517         if (IS_ERR(rtc))
 518                 return PTR_ERR(rtc);
 519
 520         i2c_set_clientdata(client, rtc);
 521
 522         rc = isl1208_i2c_get_sr(client);
 523         if (rc < 0) {
 524                 dev_err(&client->dev, "reading status failed\n");
 525                 goto exit_unregister;
 526         }
 527
 528         if (rc & ISL1208_REG_SR_RTCF)
 529                 dev_warn(&client->dev, "rtc power failure detected, "
 530                          "please set clock.\n");
 531
 532         rc = isl1208_sysfs_register(&client->dev);
 533         if (rc)
 534                 goto exit_unregister;
 535
 536         return 0;
 537
 538 exit_unregister:
 539         rtc_device_unregister(rtc);
 540
 541         return rc;
 542 }
 543
 544 static int
 545 isl1208_remove(struct i2c_client *client)
 546 {
 547         struct rtc_device *rtc = i2c_get_clientdata(client);
 548
 549         isl1208_sysfs_unregister(&client->dev);
 550         rtc_device_unregister(rtc);
 551
 552         return 0;
 553 }
 554
 555 static const struct i2c_device_id isl1208_id[] = {
 556         { "isl1208", 0 },
 557         { }
 558 };
 559 MODULE_DEVICE_TABLE(i2c, isl1208_id);
 560
 561 static struct i2c_driver isl1208_driver = {
 562         .driver = {
 563                    .name = "rtc-isl1208",
 564                    },
 565         .probe = isl1208_probe,
 566         .remove = isl1208_remove,
 567         .id_table = isl1208_id,
 568 };
 569
 570 static int __init
 571 isl1208_init(void)
 572 {
 573         return i2c_add_driver(&isl1208_driver);
 574 }
 575
 576 static void __exit
 577 isl1208_exit(void)
 578 {
 579         i2c_del_driver(&isl1208_driver);
 580 }
 581
 582 MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>");
 583 MODULE_DESCRIPTION("Intersil ISL1208 RTC driver");
 584 MODULE_LICENSE("GPL");
 585 MODULE_VERSION(DRV_VERSION);
 586
 587 module_init(isl1208_init);
 588 module_exit(isl1208_exit);