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); 582