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 rx6110->rtc->max_user_freq = 1; 328 329 return 0; 330 } 331 332 #if IS_ENABLED(CONFIG_SPI_MASTER) 333 static struct regmap_config regmap_spi_config = { 334 .reg_bits = 8, 335 .val_bits = 8, 336 .max_register = RX6110_REG_IRQ, 337 .read_flag_mask = 0x80, 338 }; 339 340 /** 341 * rx6110_spi_probe - initialize rtc driver 342 * @spi: pointer to spi device 343 */ 344 static int rx6110_spi_probe(struct spi_device *spi) 345 { 346 struct rx6110_data *rx6110; 347 348 if ((spi->bits_per_word && spi->bits_per_word != 8) || 349 (spi->max_speed_hz > 2000000) || 350 (spi->mode != (SPI_CS_HIGH | SPI_CPOL | SPI_CPHA))) { 351 dev_warn(&spi->dev, "SPI settings: bits_per_word: %d, max_speed_hz: %d, mode: %xh\n", 352 spi->bits_per_word, spi->max_speed_hz, spi->mode); 353 dev_warn(&spi->dev, "driving device in an unsupported mode"); 354 } 355 356 rx6110 = devm_kzalloc(&spi->dev, sizeof(*rx6110), GFP_KERNEL); 357 if (!rx6110) 358 return -ENOMEM; 359 360 rx6110->regmap = devm_regmap_init_spi(spi, ®map_spi_config); 361 if (IS_ERR(rx6110->regmap)) { 362 dev_err(&spi->dev, "regmap init failed for rtc rx6110\n"); 363 return PTR_ERR(rx6110->regmap); 364 } 365 366 spi_set_drvdata(spi, rx6110); 367 368 return rx6110_probe(rx6110, &spi->dev); 369 } 370 371 static const struct spi_device_id rx6110_spi_id[] = { 372 { "rx6110", 0 }, 373 { } 374 }; 375 MODULE_DEVICE_TABLE(spi, rx6110_spi_id); 376 377 static const __maybe_unused struct of_device_id rx6110_spi_of_match[] = { 378 { .compatible = "epson,rx6110" }, 379 { }, 380 }; 381 MODULE_DEVICE_TABLE(of, rx6110_spi_of_match); 382 383 static struct spi_driver rx6110_spi_driver = { 384 .driver = { 385 .name = RX6110_DRIVER_NAME, 386 .of_match_table = of_match_ptr(rx6110_spi_of_match), 387 }, 388 .probe = rx6110_spi_probe, 389 .id_table = rx6110_spi_id, 390 }; 391 392 static int rx6110_spi_register(void) 393 { 394 return spi_register_driver(&rx6110_spi_driver); 395 } 396 397 static void rx6110_spi_unregister(void) 398 { 399 spi_unregister_driver(&rx6110_spi_driver); 400 } 401 #else 402 static int rx6110_spi_register(void) 403 { 404 return 0; 405 } 406 407 static void rx6110_spi_unregister(void) 408 { 409 } 410 #endif /* CONFIG_SPI_MASTER */ 411 412 #if IS_ENABLED(CONFIG_I2C) 413 static struct regmap_config regmap_i2c_config = { 414 .reg_bits = 8, 415 .val_bits = 8, 416 .max_register = RX6110_REG_IRQ, 417 .read_flag_mask = 0x80, 418 }; 419 420 static int rx6110_i2c_probe(struct i2c_client *client) 421 { 422 struct i2c_adapter *adapter = client->adapter; 423 struct rx6110_data *rx6110; 424 425 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA 426 | I2C_FUNC_SMBUS_I2C_BLOCK)) { 427 dev_err(&adapter->dev, 428 "doesn't support required functionality\n"); 429 return -EIO; 430 } 431 432 rx6110 = devm_kzalloc(&client->dev, sizeof(*rx6110), GFP_KERNEL); 433 if (!rx6110) 434 return -ENOMEM; 435 436 rx6110->regmap = devm_regmap_init_i2c(client, ®map_i2c_config); 437 if (IS_ERR(rx6110->regmap)) { 438 dev_err(&client->dev, "regmap init failed for rtc rx6110\n"); 439 return PTR_ERR(rx6110->regmap); 440 } 441 442 i2c_set_clientdata(client, rx6110); 443 444 return rx6110_probe(rx6110, &client->dev); 445 } 446 447 static const struct acpi_device_id rx6110_i2c_acpi_match[] = { 448 { "SECC6110" }, 449 { } 450 }; 451 MODULE_DEVICE_TABLE(acpi, rx6110_i2c_acpi_match); 452 453 static const struct i2c_device_id rx6110_i2c_id[] = { 454 { "rx6110", 0 }, 455 { } 456 }; 457 MODULE_DEVICE_TABLE(i2c, rx6110_i2c_id); 458 459 static struct i2c_driver rx6110_i2c_driver = { 460 .driver = { 461 .name = RX6110_DRIVER_NAME, 462 .acpi_match_table = rx6110_i2c_acpi_match, 463 }, 464 .probe = rx6110_i2c_probe, 465 .id_table = rx6110_i2c_id, 466 }; 467 468 static int rx6110_i2c_register(void) 469 { 470 return i2c_add_driver(&rx6110_i2c_driver); 471 } 472 473 static void rx6110_i2c_unregister(void) 474 { 475 i2c_del_driver(&rx6110_i2c_driver); 476 } 477 #else 478 static int rx6110_i2c_register(void) 479 { 480 return 0; 481 } 482 483 static void rx6110_i2c_unregister(void) 484 { 485 } 486 #endif /* CONFIG_I2C */ 487 488 static int __init rx6110_module_init(void) 489 { 490 int ret; 491 492 ret = rx6110_spi_register(); 493 if (ret) 494 return ret; 495 496 ret = rx6110_i2c_register(); 497 if (ret) 498 rx6110_spi_unregister(); 499 500 return ret; 501 } 502 module_init(rx6110_module_init); 503 504 static void __exit rx6110_module_exit(void) 505 { 506 rx6110_spi_unregister(); 507 rx6110_i2c_unregister(); 508 } 509 module_exit(rx6110_module_exit); 510 511 MODULE_AUTHOR("Val Krutov <val.krutov@erd.epson.com>"); 512 MODULE_DESCRIPTION("RX-6110 SA RTC driver"); 513 MODULE_LICENSE("GPL"); 514