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 60static struct i2c_driver isl1208_driver; 61 62/* block read */ 63static int 64isl1208_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 */ 85static int 86isl1208_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 */ 108static int 109isl1208_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 130static int 131isl1208_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 140static int 141isl1208_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 165static int 166isl1208_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 178static int 179isl1208_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 192static int 193isl1208_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 204static int 205isl1208_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 243static int 244isl1208_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 286static int 287isl1208_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 319static int 320isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm) 321{ 322 return isl1208_i2c_read_time(to_i2c_client(dev), tm); 323} 324 325static int 326isl1208_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 382static int 383isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm) 384{ 385 return isl1208_i2c_set_time(to_i2c_client(dev), tm); 386} 387 388static int 389isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) 390{ 391 return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm); 392} 393 394static 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 404static ssize_t 405isl1208_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 415static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL); 416 417static ssize_t 418isl1208_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 428static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL); 429 430static ssize_t 431isl1208_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 441static ssize_t 442isl1208_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 462static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr, 463 isl1208_sysfs_store_usr); 464 465static struct attribute *isl1208_rtc_attrs[] = { 466 &dev_attr_atrim.attr, 467 &dev_attr_dtrim.attr, 468 &dev_attr_usr.attr, 469 NULL 470}; 471 472static const struct attribute_group isl1208_rtc_sysfs_files = { 473 .attrs = isl1208_rtc_attrs, 474}; 475 476static int 477isl1208_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 515exit_unregister: 516 rtc_device_unregister(rtc); 517 518 return rc; 519} 520 521static int 522isl1208_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 532static const struct i2c_device_id isl1208_id[] = { 533 { "isl1208", 0 }, 534 { } 535}; 536MODULE_DEVICE_TABLE(i2c, isl1208_id); 537 538static 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 547static int __init 548isl1208_init(void) 549{ 550 return i2c_add_driver(&isl1208_driver); 551} 552 553static void __exit 554isl1208_exit(void) 555{ 556 i2c_del_driver(&isl1208_driver); 557} 558 559MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>"); 560MODULE_DESCRIPTION("Intersil ISL1208 RTC driver"); 561MODULE_LICENSE("GPL"); 562MODULE_VERSION(DRV_VERSION); 563 564module_init(isl1208_init); 565module_exit(isl1208_exit); 566