1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for the Epson RTC module RX-6110 SA 4 * 5 * Copyright(C) 2015 Pengutronix, Steffen Trumtrar <kernel@pengutronix.de> 6 * Copyright(C) SEIKO EPSON CORPORATION 2013. All rights reserved. 7 */ 8 9 #include <linux/bcd.h> 10 #include <linux/init.h> 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <linux/regmap.h> 14 #include <linux/rtc.h> 15 #include <linux/of.h> 16 #include <linux/spi/spi.h> 17 #include <linux/i2c.h> 18 19 /* RX-6110 Register definitions */ 20 #define RX6110_REG_SEC 0x10 21 #define RX6110_REG_MIN 0x11 22 #define RX6110_REG_HOUR 0x12 23 #define RX6110_REG_WDAY 0x13 24 #define RX6110_REG_MDAY 0x14 25 #define RX6110_REG_MONTH 0x15 26 #define RX6110_REG_YEAR 0x16 27 #define RX6110_REG_RES1 0x17 28 #define RX6110_REG_ALMIN 0x18 29 #define RX6110_REG_ALHOUR 0x19 30 #define RX6110_REG_ALWDAY 0x1A 31 #define RX6110_REG_TCOUNT0 0x1B 32 #define RX6110_REG_TCOUNT1 0x1C 33 #define RX6110_REG_EXT 0x1D 34 #define RX6110_REG_FLAG 0x1E 35 #define RX6110_REG_CTRL 0x1F 36 #define RX6110_REG_USER0 0x20 37 #define RX6110_REG_USER1 0x21 38 #define RX6110_REG_USER2 0x22 39 #define RX6110_REG_USER3 0x23 40 #define RX6110_REG_USER4 0x24 41 #define RX6110_REG_USER5 0x25 42 #define RX6110_REG_USER6 0x26 43 #define RX6110_REG_USER7 0x27 44 #define RX6110_REG_USER8 0x28 45 #define RX6110_REG_USER9 0x29 46 #define RX6110_REG_USERA 0x2A 47 #define RX6110_REG_USERB 0x2B 48 #define RX6110_REG_USERC 0x2C 49 #define RX6110_REG_USERD 0x2D 50 #define RX6110_REG_USERE 0x2E 51 #define RX6110_REG_USERF 0x2F 52 #define RX6110_REG_RES2 0x30 53 #define RX6110_REG_RES3 0x31 54 #define RX6110_REG_IRQ 0x32 55 56 #define RX6110_BIT_ALARM_EN BIT(7) 57 58 /* Extension Register (1Dh) bit positions */ 59 #define RX6110_BIT_EXT_TSEL0 BIT(0) 60 #define RX6110_BIT_EXT_TSEL1 BIT(1) 61 #define RX6110_BIT_EXT_TSEL2 BIT(2) 62 #define RX6110_BIT_EXT_WADA BIT(3) 63 #define RX6110_BIT_EXT_TE BIT(4) 64 #define RX6110_BIT_EXT_USEL BIT(5) 65 #define RX6110_BIT_EXT_FSEL0 BIT(6) 66 #define RX6110_BIT_EXT_FSEL1 BIT(7) 67 68 /* Flag Register (1Eh) bit positions */ 69 #define RX6110_BIT_FLAG_VLF BIT(1) 70 #define RX6110_BIT_FLAG_AF BIT(3) 71 #define RX6110_BIT_FLAG_TF BIT(4) 72 #define RX6110_BIT_FLAG_UF BIT(5) 73 74 /* Control Register (1Fh) bit positions */ 75 #define RX6110_BIT_CTRL_TBKE BIT(0) 76 #define RX6110_BIT_CTRL_TBKON BIT(1) 77 #define RX6110_BIT_CTRL_TSTP BIT(2) 78 #define RX6110_BIT_CTRL_AIE BIT(3) 79 #define RX6110_BIT_CTRL_TIE BIT(4) 80 #define RX6110_BIT_CTRL_UIE BIT(5) 81 #define RX6110_BIT_CTRL_STOP BIT(6) 82 #define RX6110_BIT_CTRL_TEST BIT(7) 83 84 enum { 85 RTC_SEC = 0, 86 RTC_MIN, 87 RTC_HOUR, 88 RTC_WDAY, 89 RTC_MDAY, 90 RTC_MONTH, 91 RTC_YEAR, 92 RTC_NR_TIME 93 }; 94 95 #define RX6110_DRIVER_NAME "rx6110" 96 97 struct rx6110_data { 98 struct rtc_device *rtc; 99 struct regmap *regmap; 100 }; 101 102 /** 103 * rx6110_rtc_tm_to_data - convert rtc_time to native time encoding 104 * 105 * @tm: holds date and time 106 * @data: holds the encoding in rx6110 native form 107 */ 108 static int rx6110_rtc_tm_to_data(struct rtc_time *tm, u8 *data) 109 { 110 pr_debug("%s: date %ptRr\n", __func__, tm); 111 112 /* 113 * The year in the RTC is a value between 0 and 99. 114 * Assume that this represents the current century 115 * and disregard all other values. 116 */ 117 if (tm->tm_year < 100 || tm->tm_year >= 200) 118 return -EINVAL; 119 120 data[RTC_SEC] = bin2bcd(tm->tm_sec); 121 data[RTC_MIN] = bin2bcd(tm->tm_min); 122 data[RTC_HOUR] = bin2bcd(tm->tm_hour); 123 data[RTC_WDAY] = BIT(bin2bcd(tm->tm_wday)); 124 data[RTC_MDAY] = bin2bcd(tm->tm_mday); 125 data[RTC_MONTH] = bin2bcd(tm->tm_mon + 1); 126 data[RTC_YEAR] = bin2bcd(tm->tm_year % 100); 127 128 return 0; 129 } 130 131 /** 132 * rx6110_data_to_rtc_tm - convert native time encoding to rtc_time 133 * 134 * @data: holds the encoding in rx6110 native form 135 * @tm: holds date and time 136 */ 137 static int rx6110_data_to_rtc_tm(u8 *data, struct rtc_time *tm) 138 { 139 tm->tm_sec = bcd2bin(data[RTC_SEC] & 0x7f); 140 tm->tm_min = bcd2bin(data[RTC_MIN] & 0x7f); 141 /* only 24-hour clock */ 142 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x3f); 143 tm->tm_wday = ffs(data[RTC_WDAY] & 0x7f); 144 tm->tm_mday = bcd2bin(data[RTC_MDAY] & 0x3f); 145 tm->tm_mon = bcd2bin(data[RTC_MONTH] & 0x1f) - 1; 146 tm->tm_year = bcd2bin(data[RTC_YEAR]) + 100; 147 148 pr_debug("%s: date %ptRr\n", __func__, tm); 149 150 /* 151 * The year in the RTC is a value between 0 and 99. 152 * Assume that this represents the current century 153 * and disregard all other values. 154 */ 155 if (tm->tm_year < 100 || tm->tm_year >= 200) 156 return -EINVAL; 157 158 return 0; 159 } 160 161 /** 162 * rx6110_set_time - set the current time in the rx6110 registers 163 * 164 * @dev: the rtc device in use 165 * @tm: holds date and time 166 * 167 * BUG: The HW assumes every year that is a multiple of 4 to be a leap 168 * year. Next time this is wrong is 2100, which will not be a leap year 169 * 170 * Note: If STOP is not set/cleared, the clock will start when the seconds 171 * register is written 172 * 173 */ 174 static int rx6110_set_time(struct device *dev, struct rtc_time *tm) 175 { 176 struct rx6110_data *rx6110 = dev_get_drvdata(dev); 177 u8 data[RTC_NR_TIME]; 178 int ret; 179 180 ret = rx6110_rtc_tm_to_data(tm, data); 181 if (ret < 0) 182 return ret; 183 184 /* set STOP bit before changing clock/calendar */ 185 ret = regmap_update_bits(rx6110->regmap, RX6110_REG_CTRL, 186 RX6110_BIT_CTRL_STOP, RX6110_BIT_CTRL_STOP); 187 if (ret) 188 return ret; 189 190 ret = regmap_bulk_write(rx6110->regmap, RX6110_REG_SEC, data, 191 RTC_NR_TIME); 192 if (ret) 193 return ret; 194 195 /* The time in the RTC is valid. Be sure to have VLF cleared. */ 196 ret = regmap_update_bits(rx6110->regmap, RX6110_REG_FLAG, 197 RX6110_BIT_FLAG_VLF, 0); 198 if (ret) 199 return ret; 200 201 /* clear STOP bit after changing clock/calendar */ 202 ret = regmap_update_bits(rx6110->regmap, RX6110_REG_CTRL, 203 RX6110_BIT_CTRL_STOP, 0); 204 205 return ret; 206 } 207 208 /** 209 * rx6110_get_time - get the current time from the rx6110 registers 210 * @dev: the rtc device in use 211 * @tm: holds date and time 212 */ 213 static int rx6110_get_time(struct device *dev, struct rtc_time *tm) 214 { 215 struct rx6110_data *rx6110 = dev_get_drvdata(dev); 216 u8 data[RTC_NR_TIME]; 217 int flags; 218 int ret; 219 220 ret = regmap_read(rx6110->regmap, RX6110_REG_FLAG, &flags); 221 if (ret) 222 return -EINVAL; 223 224 /* check for VLF Flag (set at power-on) */ 225 if ((flags & RX6110_BIT_FLAG_VLF)) { 226 dev_warn(dev, "Voltage low, data is invalid.\n"); 227 return -EINVAL; 228 } 229 230 /* read registers to date */ 231 ret = regmap_bulk_read(rx6110->regmap, RX6110_REG_SEC, data, 232 RTC_NR_TIME); 233 if (ret) 234 return ret; 235 236 ret = rx6110_data_to_rtc_tm(data, tm); 237 if (ret) 238 return ret; 239 240 dev_dbg(dev, "%s: date %ptRr\n", __func__, tm); 241 242 return 0; 243 } 244 245 static const struct reg_sequence rx6110_default_regs[] = { 246 { RX6110_REG_RES1, 0xB8 }, 247 { RX6110_REG_RES2, 0x00 }, 248 { RX6110_REG_RES3, 0x10 }, 249 { RX6110_REG_IRQ, 0x00 }, 250 { RX6110_REG_ALMIN, 0x00 }, 251 { RX6110_REG_ALHOUR, 0x00 }, 252 { RX6110_REG_ALWDAY, 0x00 }, 253 }; 254 255 /** 256 * rx6110_init - initialize the rx6110 registers 257 * 258 * @rx6110: pointer to the rx6110 struct in use 259 * 260 */ 261 static int rx6110_init(struct rx6110_data *rx6110) 262 { 263 struct rtc_device *rtc = rx6110->rtc; 264 int flags; 265 int ret; 266 267 ret = regmap_update_bits(rx6110->regmap, RX6110_REG_EXT, 268 RX6110_BIT_EXT_TE, 0); 269 if (ret) 270 return ret; 271 272 ret = regmap_register_patch(rx6110->regmap, rx6110_default_regs, 273 ARRAY_SIZE(rx6110_default_regs)); 274 if (ret) 275 return ret; 276 277 ret = regmap_read(rx6110->regmap, RX6110_REG_FLAG, &flags); 278 if (ret) 279 return ret; 280 281 /* check for VLF Flag (set at power-on) */ 282 if ((flags & RX6110_BIT_FLAG_VLF)) 283 dev_warn(&rtc->dev, "Voltage low, data loss detected.\n"); 284 285 /* check for Alarm Flag */ 286 if (flags & RX6110_BIT_FLAG_AF) 287 dev_warn(&rtc->dev, "An alarm may have been missed.\n"); 288 289 /* check for Periodic Timer Flag */ 290 if (flags & RX6110_BIT_FLAG_TF) 291 dev_warn(&rtc->dev, "Periodic timer was detected\n"); 292 293 /* check for Update Timer Flag */ 294 if (flags & RX6110_BIT_FLAG_UF) 295 dev_warn(&rtc->dev, "Update timer was detected\n"); 296 297 /* clear all flags BUT VLF */ 298 ret = regmap_update_bits(rx6110->regmap, RX6110_REG_FLAG, 299 RX6110_BIT_FLAG_AF | 300 RX6110_BIT_FLAG_UF | 301 RX6110_BIT_FLAG_TF, 302 0); 303 304 return ret; 305 } 306 307 static const struct rtc_class_ops rx6110_rtc_ops = { 308 .read_time = rx6110_get_time, 309 .set_time = rx6110_set_time, 310 }; 311 312 static int rx6110_probe(struct rx6110_data *rx6110, struct device *dev) 313 { 314 int err; 315 316 rx6110->rtc = devm_rtc_device_register(dev, 317 RX6110_DRIVER_NAME, 318 &rx6110_rtc_ops, THIS_MODULE); 319 320 if (IS_ERR(rx6110->rtc)) 321 return PTR_ERR(rx6110->rtc); 322 323 err = rx6110_init(rx6110); 324 if (err) 325 return err; 326 327 return 0; 328 } 329 330 #if IS_ENABLED(CONFIG_SPI_MASTER) 331 static const struct regmap_config regmap_spi_config = { 332 .reg_bits = 8, 333 .val_bits = 8, 334 .max_register = RX6110_REG_IRQ, 335 .read_flag_mask = 0x80, 336 }; 337 338 /** 339 * rx6110_spi_probe - initialize rtc driver 340 * @spi: pointer to spi device 341 */ 342 static int rx6110_spi_probe(struct spi_device *spi) 343 { 344 struct rx6110_data *rx6110; 345 346 if ((spi->bits_per_word && spi->bits_per_word != 8) || 347 (spi->max_speed_hz > 2000000) || 348 (spi->mode != (SPI_CS_HIGH | SPI_CPOL | SPI_CPHA))) { 349 dev_warn(&spi->dev, "SPI settings: bits_per_word: %d, max_speed_hz: %d, mode: %xh\n", 350 spi->bits_per_word, spi->max_speed_hz, spi->mode); 351 dev_warn(&spi->dev, "driving device in an unsupported mode"); 352 } 353 354 rx6110 = devm_kzalloc(&spi->dev, sizeof(*rx6110), GFP_KERNEL); 355 if (!rx6110) 356 return -ENOMEM; 357 358 rx6110->regmap = devm_regmap_init_spi(spi, ®map_spi_config); 359 if (IS_ERR(rx6110->regmap)) { 360 dev_err(&spi->dev, "regmap init failed for rtc rx6110\n"); 361 return PTR_ERR(rx6110->regmap); 362 } 363 364 spi_set_drvdata(spi, rx6110); 365 366 return rx6110_probe(rx6110, &spi->dev); 367 } 368 369 static const struct spi_device_id rx6110_spi_id[] = { 370 { "rx6110", 0 }, 371 { } 372 }; 373 MODULE_DEVICE_TABLE(spi, rx6110_spi_id); 374 375 static const __maybe_unused struct of_device_id rx6110_spi_of_match[] = { 376 { .compatible = "epson,rx6110" }, 377 { }, 378 }; 379 MODULE_DEVICE_TABLE(of, rx6110_spi_of_match); 380 381 static struct spi_driver rx6110_spi_driver = { 382 .driver = { 383 .name = RX6110_DRIVER_NAME, 384 .of_match_table = of_match_ptr(rx6110_spi_of_match), 385 }, 386 .probe = rx6110_spi_probe, 387 .id_table = rx6110_spi_id, 388 }; 389 390 static int rx6110_spi_register(void) 391 { 392 return spi_register_driver(&rx6110_spi_driver); 393 } 394 395 static void rx6110_spi_unregister(void) 396 { 397 spi_unregister_driver(&rx6110_spi_driver); 398 } 399 #else 400 static int rx6110_spi_register(void) 401 { 402 return 0; 403 } 404 405 static void rx6110_spi_unregister(void) 406 { 407 } 408 #endif /* CONFIG_SPI_MASTER */ 409 410 #if IS_ENABLED(CONFIG_I2C) 411 static const struct regmap_config regmap_i2c_config = { 412 .reg_bits = 8, 413 .val_bits = 8, 414 .max_register = RX6110_REG_IRQ, 415 .read_flag_mask = 0x80, 416 }; 417 418 static int rx6110_i2c_probe(struct i2c_client *client) 419 { 420 struct i2c_adapter *adapter = client->adapter; 421 struct rx6110_data *rx6110; 422 423 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA 424 | I2C_FUNC_SMBUS_I2C_BLOCK)) { 425 dev_err(&adapter->dev, 426 "doesn't support required functionality\n"); 427 return -EIO; 428 } 429 430 rx6110 = devm_kzalloc(&client->dev, sizeof(*rx6110), GFP_KERNEL); 431 if (!rx6110) 432 return -ENOMEM; 433 434 rx6110->regmap = devm_regmap_init_i2c(client, ®map_i2c_config); 435 if (IS_ERR(rx6110->regmap)) { 436 dev_err(&client->dev, "regmap init failed for rtc rx6110\n"); 437 return PTR_ERR(rx6110->regmap); 438 } 439 440 i2c_set_clientdata(client, rx6110); 441 442 return rx6110_probe(rx6110, &client->dev); 443 } 444 445 static const struct acpi_device_id rx6110_i2c_acpi_match[] = { 446 { "SECC6110" }, 447 { } 448 }; 449 MODULE_DEVICE_TABLE(acpi, rx6110_i2c_acpi_match); 450 451 static const struct i2c_device_id rx6110_i2c_id[] = { 452 { "rx6110" }, 453 { } 454 }; 455 MODULE_DEVICE_TABLE(i2c, rx6110_i2c_id); 456 457 static struct i2c_driver rx6110_i2c_driver = { 458 .driver = { 459 .name = RX6110_DRIVER_NAME, 460 .acpi_match_table = rx6110_i2c_acpi_match, 461 }, 462 .probe = rx6110_i2c_probe, 463 .id_table = rx6110_i2c_id, 464 }; 465 466 static int rx6110_i2c_register(void) 467 { 468 return i2c_add_driver(&rx6110_i2c_driver); 469 } 470 471 static void rx6110_i2c_unregister(void) 472 { 473 i2c_del_driver(&rx6110_i2c_driver); 474 } 475 #else 476 static int rx6110_i2c_register(void) 477 { 478 return 0; 479 } 480 481 static void rx6110_i2c_unregister(void) 482 { 483 } 484 #endif /* CONFIG_I2C */ 485 486 static int __init rx6110_module_init(void) 487 { 488 int ret; 489 490 ret = rx6110_spi_register(); 491 if (ret) 492 return ret; 493 494 ret = rx6110_i2c_register(); 495 if (ret) 496 rx6110_spi_unregister(); 497 498 return ret; 499 } 500 module_init(rx6110_module_init); 501 502 static void __exit rx6110_module_exit(void) 503 { 504 rx6110_spi_unregister(); 505 rx6110_i2c_unregister(); 506 } 507 module_exit(rx6110_module_exit); 508 509 MODULE_AUTHOR("Val Krutov <val.krutov@erd.epson.com>"); 510 MODULE_DESCRIPTION("RX-6110 SA RTC driver"); 511 MODULE_LICENSE("GPL"); 512