1 /* 2 * An I2C driver for Ricoh RS5C372, R2025S/D and RV5C38[67] RTCs 3 * 4 * Copyright (C) 2005 Pavel Mironchik <pmironchik@optifacio.net> 5 * Copyright (C) 2006 Tower Technologies 6 * Copyright (C) 2008 Paul Mundt 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 */ 12 13 #include <linux/i2c.h> 14 #include <linux/rtc.h> 15 #include <linux/bcd.h> 16 #include <linux/slab.h> 17 #include <linux/module.h> 18 #include <linux/of_device.h> 19 20 /* 21 * Ricoh has a family of I2C based RTCs, which differ only slightly from 22 * each other. Differences center on pinout (e.g. how many interrupts, 23 * output clock, etc) and how the control registers are used. The '372 24 * is significant only because that's the one this driver first supported. 25 */ 26 #define RS5C372_REG_SECS 0 27 #define RS5C372_REG_MINS 1 28 #define RS5C372_REG_HOURS 2 29 #define RS5C372_REG_WDAY 3 30 #define RS5C372_REG_DAY 4 31 #define RS5C372_REG_MONTH 5 32 #define RS5C372_REG_YEAR 6 33 #define RS5C372_REG_TRIM 7 34 # define RS5C372_TRIM_XSL 0x80 35 # define RS5C372_TRIM_MASK 0x7F 36 37 #define RS5C_REG_ALARM_A_MIN 8 /* or ALARM_W */ 38 #define RS5C_REG_ALARM_A_HOURS 9 39 #define RS5C_REG_ALARM_A_WDAY 10 40 41 #define RS5C_REG_ALARM_B_MIN 11 /* or ALARM_D */ 42 #define RS5C_REG_ALARM_B_HOURS 12 43 #define RS5C_REG_ALARM_B_WDAY 13 /* (ALARM_B only) */ 44 45 #define RS5C_REG_CTRL1 14 46 # define RS5C_CTRL1_AALE (1 << 7) /* or WALE */ 47 # define RS5C_CTRL1_BALE (1 << 6) /* or DALE */ 48 # define RV5C387_CTRL1_24 (1 << 5) 49 # define RS5C372A_CTRL1_SL1 (1 << 5) 50 # define RS5C_CTRL1_CT_MASK (7 << 0) 51 # define RS5C_CTRL1_CT0 (0 << 0) /* no periodic irq */ 52 # define RS5C_CTRL1_CT4 (4 << 0) /* 1 Hz level irq */ 53 #define RS5C_REG_CTRL2 15 54 # define RS5C372_CTRL2_24 (1 << 5) 55 # define RS5C_CTRL2_XSTP (1 << 4) /* only if !R2x2x */ 56 # define R2x2x_CTRL2_VDET (1 << 6) /* only if R2x2x */ 57 # define R2x2x_CTRL2_XSTP (1 << 5) /* only if R2x2x */ 58 # define R2x2x_CTRL2_PON (1 << 4) /* only if R2x2x */ 59 # define RS5C_CTRL2_CTFG (1 << 2) 60 # define RS5C_CTRL2_AAFG (1 << 1) /* or WAFG */ 61 # define RS5C_CTRL2_BAFG (1 << 0) /* or DAFG */ 62 63 64 /* to read (style 1) or write registers starting at R */ 65 #define RS5C_ADDR(R) (((R) << 4) | 0) 66 67 68 enum rtc_type { 69 rtc_undef = 0, 70 rtc_r2025sd, 71 rtc_r2221tl, 72 rtc_rs5c372a, 73 rtc_rs5c372b, 74 rtc_rv5c386, 75 rtc_rv5c387a, 76 }; 77 78 static const struct i2c_device_id rs5c372_id[] = { 79 { "r2025sd", rtc_r2025sd }, 80 { "r2221tl", rtc_r2221tl }, 81 { "rs5c372a", rtc_rs5c372a }, 82 { "rs5c372b", rtc_rs5c372b }, 83 { "rv5c386", rtc_rv5c386 }, 84 { "rv5c387a", rtc_rv5c387a }, 85 { } 86 }; 87 MODULE_DEVICE_TABLE(i2c, rs5c372_id); 88 89 static const struct of_device_id rs5c372_of_match[] = { 90 { 91 .compatible = "ricoh,r2025sd", 92 .data = (void *)rtc_r2025sd 93 }, 94 { 95 .compatible = "ricoh,r2221tl", 96 .data = (void *)rtc_r2221tl 97 }, 98 { 99 .compatible = "ricoh,rs5c372a", 100 .data = (void *)rtc_rs5c372a 101 }, 102 { 103 .compatible = "ricoh,rs5c372b", 104 .data = (void *)rtc_rs5c372b 105 }, 106 { 107 .compatible = "ricoh,rv5c386", 108 .data = (void *)rtc_rv5c386 109 }, 110 { 111 .compatible = "ricoh,rv5c387a", 112 .data = (void *)rtc_rv5c387a 113 }, 114 { } 115 }; 116 MODULE_DEVICE_TABLE(of, rs5c372_of_match); 117 118 /* REVISIT: this assumes that: 119 * - we're in the 21st century, so it's safe to ignore the century 120 * bit for rv5c38[67] (REG_MONTH bit 7); 121 * - we should use ALARM_A not ALARM_B (may be wrong on some boards) 122 */ 123 struct rs5c372 { 124 struct i2c_client *client; 125 struct rtc_device *rtc; 126 enum rtc_type type; 127 unsigned time24:1; 128 unsigned has_irq:1; 129 unsigned smbus:1; 130 char buf[17]; 131 char *regs; 132 }; 133 134 static int rs5c_get_regs(struct rs5c372 *rs5c) 135 { 136 struct i2c_client *client = rs5c->client; 137 struct i2c_msg msgs[] = { 138 { 139 .addr = client->addr, 140 .flags = I2C_M_RD, 141 .len = sizeof(rs5c->buf), 142 .buf = rs5c->buf 143 }, 144 }; 145 146 /* This implements the third reading method from the datasheet, using 147 * an internal address that's reset after each transaction (by STOP) 148 * to 0x0f ... so we read extra registers, and skip the first one. 149 * 150 * The first method doesn't work with the iop3xx adapter driver, on at 151 * least 80219 chips; this works around that bug. 152 * 153 * The third method on the other hand doesn't work for the SMBus-only 154 * configurations, so we use the the first method there, stripping off 155 * the extra register in the process. 156 */ 157 if (rs5c->smbus) { 158 int addr = RS5C_ADDR(RS5C372_REG_SECS); 159 int size = sizeof(rs5c->buf) - 1; 160 161 if (i2c_smbus_read_i2c_block_data(client, addr, size, 162 rs5c->buf + 1) != size) { 163 dev_warn(&client->dev, "can't read registers\n"); 164 return -EIO; 165 } 166 } else { 167 if ((i2c_transfer(client->adapter, msgs, 1)) != 1) { 168 dev_warn(&client->dev, "can't read registers\n"); 169 return -EIO; 170 } 171 } 172 173 dev_dbg(&client->dev, 174 "%3ph (%02x) %3ph (%02x), %3ph, %3ph; %02x %02x\n", 175 rs5c->regs + 0, rs5c->regs[3], 176 rs5c->regs + 4, rs5c->regs[7], 177 rs5c->regs + 8, rs5c->regs + 11, 178 rs5c->regs[14], rs5c->regs[15]); 179 180 return 0; 181 } 182 183 static unsigned rs5c_reg2hr(struct rs5c372 *rs5c, unsigned reg) 184 { 185 unsigned hour; 186 187 if (rs5c->time24) 188 return bcd2bin(reg & 0x3f); 189 190 hour = bcd2bin(reg & 0x1f); 191 if (hour == 12) 192 hour = 0; 193 if (reg & 0x20) 194 hour += 12; 195 return hour; 196 } 197 198 static unsigned rs5c_hr2reg(struct rs5c372 *rs5c, unsigned hour) 199 { 200 if (rs5c->time24) 201 return bin2bcd(hour); 202 203 if (hour > 12) 204 return 0x20 | bin2bcd(hour - 12); 205 if (hour == 12) 206 return 0x20 | bin2bcd(12); 207 if (hour == 0) 208 return bin2bcd(12); 209 return bin2bcd(hour); 210 } 211 212 static int rs5c372_rtc_read_time(struct device *dev, struct rtc_time *tm) 213 { 214 struct i2c_client *client = to_i2c_client(dev); 215 struct rs5c372 *rs5c = i2c_get_clientdata(client); 216 int status = rs5c_get_regs(rs5c); 217 unsigned char ctrl2 = rs5c->regs[RS5C_REG_CTRL2]; 218 219 if (status < 0) 220 return status; 221 222 switch (rs5c->type) { 223 case rtc_r2025sd: 224 case rtc_r2221tl: 225 if ((rs5c->type == rtc_r2025sd && !(ctrl2 & R2x2x_CTRL2_XSTP)) || 226 (rs5c->type == rtc_r2221tl && (ctrl2 & R2x2x_CTRL2_XSTP))) { 227 dev_warn(&client->dev, "rtc oscillator interruption detected. Please reset the rtc clock.\n"); 228 return -EINVAL; 229 } 230 break; 231 default: 232 if (ctrl2 & RS5C_CTRL2_XSTP) { 233 dev_warn(&client->dev, "rtc oscillator interruption detected. Please reset the rtc clock.\n"); 234 return -EINVAL; 235 } 236 } 237 238 tm->tm_sec = bcd2bin(rs5c->regs[RS5C372_REG_SECS] & 0x7f); 239 tm->tm_min = bcd2bin(rs5c->regs[RS5C372_REG_MINS] & 0x7f); 240 tm->tm_hour = rs5c_reg2hr(rs5c, rs5c->regs[RS5C372_REG_HOURS]); 241 242 tm->tm_wday = bcd2bin(rs5c->regs[RS5C372_REG_WDAY] & 0x07); 243 tm->tm_mday = bcd2bin(rs5c->regs[RS5C372_REG_DAY] & 0x3f); 244 245 /* tm->tm_mon is zero-based */ 246 tm->tm_mon = bcd2bin(rs5c->regs[RS5C372_REG_MONTH] & 0x1f) - 1; 247 248 /* year is 1900 + tm->tm_year */ 249 tm->tm_year = bcd2bin(rs5c->regs[RS5C372_REG_YEAR]) + 100; 250 251 dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, " 252 "mday=%d, mon=%d, year=%d, wday=%d\n", 253 __func__, 254 tm->tm_sec, tm->tm_min, tm->tm_hour, 255 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday); 256 257 return 0; 258 } 259 260 static int rs5c372_rtc_set_time(struct device *dev, struct rtc_time *tm) 261 { 262 struct i2c_client *client = to_i2c_client(dev); 263 struct rs5c372 *rs5c = i2c_get_clientdata(client); 264 unsigned char buf[7]; 265 unsigned char ctrl2; 266 int addr; 267 268 dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d " 269 "mday=%d, mon=%d, year=%d, wday=%d\n", 270 __func__, 271 tm->tm_sec, tm->tm_min, tm->tm_hour, 272 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday); 273 274 addr = RS5C_ADDR(RS5C372_REG_SECS); 275 buf[0] = bin2bcd(tm->tm_sec); 276 buf[1] = bin2bcd(tm->tm_min); 277 buf[2] = rs5c_hr2reg(rs5c, tm->tm_hour); 278 buf[3] = bin2bcd(tm->tm_wday); 279 buf[4] = bin2bcd(tm->tm_mday); 280 buf[5] = bin2bcd(tm->tm_mon + 1); 281 buf[6] = bin2bcd(tm->tm_year - 100); 282 283 if (i2c_smbus_write_i2c_block_data(client, addr, sizeof(buf), buf) < 0) { 284 dev_dbg(&client->dev, "%s: write error in line %i\n", 285 __func__, __LINE__); 286 return -EIO; 287 } 288 289 addr = RS5C_ADDR(RS5C_REG_CTRL2); 290 ctrl2 = i2c_smbus_read_byte_data(client, addr); 291 292 /* clear rtc warning bits */ 293 switch (rs5c->type) { 294 case rtc_r2025sd: 295 case rtc_r2221tl: 296 ctrl2 &= ~(R2x2x_CTRL2_VDET | R2x2x_CTRL2_PON); 297 if (rs5c->type == rtc_r2025sd) 298 ctrl2 |= R2x2x_CTRL2_XSTP; 299 else 300 ctrl2 &= ~R2x2x_CTRL2_XSTP; 301 break; 302 default: 303 ctrl2 &= ~RS5C_CTRL2_XSTP; 304 break; 305 } 306 307 if (i2c_smbus_write_byte_data(client, addr, ctrl2) < 0) { 308 dev_dbg(&client->dev, "%s: write error in line %i\n", 309 __func__, __LINE__); 310 return -EIO; 311 } 312 313 return 0; 314 } 315 316 #if IS_ENABLED(CONFIG_RTC_INTF_PROC) 317 #define NEED_TRIM 318 #endif 319 320 #if IS_ENABLED(CONFIG_RTC_INTF_SYSFS) 321 #define NEED_TRIM 322 #endif 323 324 #ifdef NEED_TRIM 325 static int rs5c372_get_trim(struct i2c_client *client, int *osc, int *trim) 326 { 327 struct rs5c372 *rs5c372 = i2c_get_clientdata(client); 328 u8 tmp = rs5c372->regs[RS5C372_REG_TRIM]; 329 330 if (osc) 331 *osc = (tmp & RS5C372_TRIM_XSL) ? 32000 : 32768; 332 333 if (trim) { 334 dev_dbg(&client->dev, "%s: raw trim=%x\n", __func__, tmp); 335 tmp &= RS5C372_TRIM_MASK; 336 if (tmp & 0x3e) { 337 int t = tmp & 0x3f; 338 339 if (tmp & 0x40) 340 t = (~t | (s8)0xc0) + 1; 341 else 342 t = t - 1; 343 344 tmp = t * 2; 345 } else 346 tmp = 0; 347 *trim = tmp; 348 } 349 350 return 0; 351 } 352 #endif 353 354 static int rs5c_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled) 355 { 356 struct i2c_client *client = to_i2c_client(dev); 357 struct rs5c372 *rs5c = i2c_get_clientdata(client); 358 unsigned char buf; 359 int status, addr; 360 361 buf = rs5c->regs[RS5C_REG_CTRL1]; 362 363 if (!rs5c->has_irq) 364 return -EINVAL; 365 366 status = rs5c_get_regs(rs5c); 367 if (status < 0) 368 return status; 369 370 addr = RS5C_ADDR(RS5C_REG_CTRL1); 371 if (enabled) 372 buf |= RS5C_CTRL1_AALE; 373 else 374 buf &= ~RS5C_CTRL1_AALE; 375 376 if (i2c_smbus_write_byte_data(client, addr, buf) < 0) { 377 dev_warn(dev, "can't update alarm\n"); 378 status = -EIO; 379 } else 380 rs5c->regs[RS5C_REG_CTRL1] = buf; 381 382 return status; 383 } 384 385 386 /* NOTE: Since RTC_WKALM_{RD,SET} were originally defined for EFI, 387 * which only exposes a polled programming interface; and since 388 * these calls map directly to those EFI requests; we don't demand 389 * we have an IRQ for this chip when we go through this API. 390 * 391 * The older x86_pc derived RTC_ALM_{READ,SET} calls require irqs 392 * though, managed through RTC_AIE_{ON,OFF} requests. 393 */ 394 395 static int rs5c_read_alarm(struct device *dev, struct rtc_wkalrm *t) 396 { 397 struct i2c_client *client = to_i2c_client(dev); 398 struct rs5c372 *rs5c = i2c_get_clientdata(client); 399 int status; 400 401 status = rs5c_get_regs(rs5c); 402 if (status < 0) 403 return status; 404 405 /* report alarm time */ 406 t->time.tm_sec = 0; 407 t->time.tm_min = bcd2bin(rs5c->regs[RS5C_REG_ALARM_A_MIN] & 0x7f); 408 t->time.tm_hour = rs5c_reg2hr(rs5c, rs5c->regs[RS5C_REG_ALARM_A_HOURS]); 409 410 /* ... and status */ 411 t->enabled = !!(rs5c->regs[RS5C_REG_CTRL1] & RS5C_CTRL1_AALE); 412 t->pending = !!(rs5c->regs[RS5C_REG_CTRL2] & RS5C_CTRL2_AAFG); 413 414 return 0; 415 } 416 417 static int rs5c_set_alarm(struct device *dev, struct rtc_wkalrm *t) 418 { 419 struct i2c_client *client = to_i2c_client(dev); 420 struct rs5c372 *rs5c = i2c_get_clientdata(client); 421 int status, addr, i; 422 unsigned char buf[3]; 423 424 /* only handle up to 24 hours in the future, like RTC_ALM_SET */ 425 if (t->time.tm_mday != -1 426 || t->time.tm_mon != -1 427 || t->time.tm_year != -1) 428 return -EINVAL; 429 430 /* REVISIT: round up tm_sec */ 431 432 /* if needed, disable irq (clears pending status) */ 433 status = rs5c_get_regs(rs5c); 434 if (status < 0) 435 return status; 436 if (rs5c->regs[RS5C_REG_CTRL1] & RS5C_CTRL1_AALE) { 437 addr = RS5C_ADDR(RS5C_REG_CTRL1); 438 buf[0] = rs5c->regs[RS5C_REG_CTRL1] & ~RS5C_CTRL1_AALE; 439 if (i2c_smbus_write_byte_data(client, addr, buf[0]) < 0) { 440 dev_dbg(dev, "can't disable alarm\n"); 441 return -EIO; 442 } 443 rs5c->regs[RS5C_REG_CTRL1] = buf[0]; 444 } 445 446 /* set alarm */ 447 buf[0] = bin2bcd(t->time.tm_min); 448 buf[1] = rs5c_hr2reg(rs5c, t->time.tm_hour); 449 buf[2] = 0x7f; /* any/all days */ 450 451 for (i = 0; i < sizeof(buf); i++) { 452 addr = RS5C_ADDR(RS5C_REG_ALARM_A_MIN + i); 453 if (i2c_smbus_write_byte_data(client, addr, buf[i]) < 0) { 454 dev_dbg(dev, "can't set alarm time\n"); 455 return -EIO; 456 } 457 } 458 459 /* ... and maybe enable its irq */ 460 if (t->enabled) { 461 addr = RS5C_ADDR(RS5C_REG_CTRL1); 462 buf[0] = rs5c->regs[RS5C_REG_CTRL1] | RS5C_CTRL1_AALE; 463 if (i2c_smbus_write_byte_data(client, addr, buf[0]) < 0) 464 dev_warn(dev, "can't enable alarm\n"); 465 rs5c->regs[RS5C_REG_CTRL1] = buf[0]; 466 } 467 468 return 0; 469 } 470 471 #if IS_ENABLED(CONFIG_RTC_INTF_PROC) 472 473 static int rs5c372_rtc_proc(struct device *dev, struct seq_file *seq) 474 { 475 int err, osc, trim; 476 477 err = rs5c372_get_trim(to_i2c_client(dev), &osc, &trim); 478 if (err == 0) { 479 seq_printf(seq, "crystal\t\t: %d.%03d KHz\n", 480 osc / 1000, osc % 1000); 481 seq_printf(seq, "trim\t\t: %d\n", trim); 482 } 483 484 return 0; 485 } 486 487 #else 488 #define rs5c372_rtc_proc NULL 489 #endif 490 491 static const struct rtc_class_ops rs5c372_rtc_ops = { 492 .proc = rs5c372_rtc_proc, 493 .read_time = rs5c372_rtc_read_time, 494 .set_time = rs5c372_rtc_set_time, 495 .read_alarm = rs5c_read_alarm, 496 .set_alarm = rs5c_set_alarm, 497 .alarm_irq_enable = rs5c_rtc_alarm_irq_enable, 498 }; 499 500 #if IS_ENABLED(CONFIG_RTC_INTF_SYSFS) 501 502 static ssize_t rs5c372_sysfs_show_trim(struct device *dev, 503 struct device_attribute *attr, char *buf) 504 { 505 int err, trim; 506 507 err = rs5c372_get_trim(to_i2c_client(dev), NULL, &trim); 508 if (err) 509 return err; 510 511 return sprintf(buf, "%d\n", trim); 512 } 513 static DEVICE_ATTR(trim, S_IRUGO, rs5c372_sysfs_show_trim, NULL); 514 515 static ssize_t rs5c372_sysfs_show_osc(struct device *dev, 516 struct device_attribute *attr, char *buf) 517 { 518 int err, osc; 519 520 err = rs5c372_get_trim(to_i2c_client(dev), &osc, NULL); 521 if (err) 522 return err; 523 524 return sprintf(buf, "%d.%03d KHz\n", osc / 1000, osc % 1000); 525 } 526 static DEVICE_ATTR(osc, S_IRUGO, rs5c372_sysfs_show_osc, NULL); 527 528 static int rs5c_sysfs_register(struct device *dev) 529 { 530 int err; 531 532 err = device_create_file(dev, &dev_attr_trim); 533 if (err) 534 return err; 535 err = device_create_file(dev, &dev_attr_osc); 536 if (err) 537 device_remove_file(dev, &dev_attr_trim); 538 539 return err; 540 } 541 542 static void rs5c_sysfs_unregister(struct device *dev) 543 { 544 device_remove_file(dev, &dev_attr_trim); 545 device_remove_file(dev, &dev_attr_osc); 546 } 547 548 #else 549 static int rs5c_sysfs_register(struct device *dev) 550 { 551 return 0; 552 } 553 554 static void rs5c_sysfs_unregister(struct device *dev) 555 { 556 /* nothing */ 557 } 558 #endif /* SYSFS */ 559 560 static struct i2c_driver rs5c372_driver; 561 562 static int rs5c_oscillator_setup(struct rs5c372 *rs5c372) 563 { 564 unsigned char buf[2]; 565 int addr, i, ret = 0; 566 567 addr = RS5C_ADDR(RS5C_REG_CTRL1); 568 buf[0] = rs5c372->regs[RS5C_REG_CTRL1]; 569 buf[1] = rs5c372->regs[RS5C_REG_CTRL2]; 570 571 switch (rs5c372->type) { 572 case rtc_r2025sd: 573 if (buf[1] & R2x2x_CTRL2_XSTP) 574 return ret; 575 break; 576 case rtc_r2221tl: 577 if (!(buf[1] & R2x2x_CTRL2_XSTP)) 578 return ret; 579 break; 580 default: 581 if (!(buf[1] & RS5C_CTRL2_XSTP)) 582 return ret; 583 break; 584 } 585 586 /* use 24hr mode */ 587 switch (rs5c372->type) { 588 case rtc_rs5c372a: 589 case rtc_rs5c372b: 590 buf[1] |= RS5C372_CTRL2_24; 591 rs5c372->time24 = 1; 592 break; 593 case rtc_r2025sd: 594 case rtc_r2221tl: 595 case rtc_rv5c386: 596 case rtc_rv5c387a: 597 buf[0] |= RV5C387_CTRL1_24; 598 rs5c372->time24 = 1; 599 break; 600 default: 601 /* impossible */ 602 break; 603 } 604 605 for (i = 0; i < sizeof(buf); i++) { 606 addr = RS5C_ADDR(RS5C_REG_CTRL1 + i); 607 ret = i2c_smbus_write_byte_data(rs5c372->client, addr, buf[i]); 608 if (unlikely(ret < 0)) 609 return ret; 610 } 611 612 rs5c372->regs[RS5C_REG_CTRL1] = buf[0]; 613 rs5c372->regs[RS5C_REG_CTRL2] = buf[1]; 614 615 return 0; 616 } 617 618 static int rs5c372_probe(struct i2c_client *client, 619 const struct i2c_device_id *id) 620 { 621 int err = 0; 622 int smbus_mode = 0; 623 struct rs5c372 *rs5c372; 624 625 dev_dbg(&client->dev, "%s\n", __func__); 626 627 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C | 628 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) { 629 /* 630 * If we don't have any master mode adapter, try breaking 631 * it down in to the barest of capabilities. 632 */ 633 if (i2c_check_functionality(client->adapter, 634 I2C_FUNC_SMBUS_BYTE_DATA | 635 I2C_FUNC_SMBUS_I2C_BLOCK)) 636 smbus_mode = 1; 637 else { 638 /* Still no good, give up */ 639 err = -ENODEV; 640 goto exit; 641 } 642 } 643 644 rs5c372 = devm_kzalloc(&client->dev, sizeof(struct rs5c372), 645 GFP_KERNEL); 646 if (!rs5c372) { 647 err = -ENOMEM; 648 goto exit; 649 } 650 651 rs5c372->client = client; 652 i2c_set_clientdata(client, rs5c372); 653 if (client->dev.of_node) 654 rs5c372->type = (enum rtc_type) 655 of_device_get_match_data(&client->dev); 656 else 657 rs5c372->type = id->driver_data; 658 659 /* we read registers 0x0f then 0x00-0x0f; skip the first one */ 660 rs5c372->regs = &rs5c372->buf[1]; 661 rs5c372->smbus = smbus_mode; 662 663 err = rs5c_get_regs(rs5c372); 664 if (err < 0) 665 goto exit; 666 667 /* clock may be set for am/pm or 24 hr time */ 668 switch (rs5c372->type) { 669 case rtc_rs5c372a: 670 case rtc_rs5c372b: 671 /* alarm uses ALARM_A; and nINTRA on 372a, nINTR on 372b. 672 * so does periodic irq, except some 327a modes. 673 */ 674 if (rs5c372->regs[RS5C_REG_CTRL2] & RS5C372_CTRL2_24) 675 rs5c372->time24 = 1; 676 break; 677 case rtc_r2025sd: 678 case rtc_r2221tl: 679 case rtc_rv5c386: 680 case rtc_rv5c387a: 681 if (rs5c372->regs[RS5C_REG_CTRL1] & RV5C387_CTRL1_24) 682 rs5c372->time24 = 1; 683 /* alarm uses ALARM_W; and nINTRB for alarm and periodic 684 * irq, on both 386 and 387 685 */ 686 break; 687 default: 688 dev_err(&client->dev, "unknown RTC type\n"); 689 goto exit; 690 } 691 692 /* if the oscillator lost power and no other software (like 693 * the bootloader) set it up, do it here. 694 * 695 * The R2025S/D does this a little differently than the other 696 * parts, so we special case that.. 697 */ 698 err = rs5c_oscillator_setup(rs5c372); 699 if (unlikely(err < 0)) { 700 dev_err(&client->dev, "setup error\n"); 701 goto exit; 702 } 703 704 dev_info(&client->dev, "%s found, %s\n", 705 ({ char *s; switch (rs5c372->type) { 706 case rtc_r2025sd: s = "r2025sd"; break; 707 case rtc_r2221tl: s = "r2221tl"; break; 708 case rtc_rs5c372a: s = "rs5c372a"; break; 709 case rtc_rs5c372b: s = "rs5c372b"; break; 710 case rtc_rv5c386: s = "rv5c386"; break; 711 case rtc_rv5c387a: s = "rv5c387a"; break; 712 default: s = "chip"; break; 713 }; s;}), 714 rs5c372->time24 ? "24hr" : "am/pm" 715 ); 716 717 /* REVISIT use client->irq to register alarm irq ... */ 718 rs5c372->rtc = devm_rtc_device_register(&client->dev, 719 rs5c372_driver.driver.name, 720 &rs5c372_rtc_ops, THIS_MODULE); 721 722 if (IS_ERR(rs5c372->rtc)) { 723 err = PTR_ERR(rs5c372->rtc); 724 goto exit; 725 } 726 727 err = rs5c_sysfs_register(&client->dev); 728 if (err) 729 goto exit; 730 731 return 0; 732 733 exit: 734 return err; 735 } 736 737 static int rs5c372_remove(struct i2c_client *client) 738 { 739 rs5c_sysfs_unregister(&client->dev); 740 return 0; 741 } 742 743 static struct i2c_driver rs5c372_driver = { 744 .driver = { 745 .name = "rtc-rs5c372", 746 .of_match_table = of_match_ptr(rs5c372_of_match), 747 }, 748 .probe = rs5c372_probe, 749 .remove = rs5c372_remove, 750 .id_table = rs5c372_id, 751 }; 752 753 module_i2c_driver(rs5c372_driver); 754 755 MODULE_AUTHOR( 756 "Pavel Mironchik <pmironchik@optifacio.net>, " 757 "Alessandro Zummo <a.zummo@towertech.it>, " 758 "Paul Mundt <lethal@linux-sh.org>"); 759 MODULE_DESCRIPTION("Ricoh RS5C372 RTC driver"); 760 MODULE_LICENSE("GPL"); 761