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