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/of_gpio.h> 14 #include <linux/regmap.h> 15 #include <linux/rtc.h> 16 #include <linux/of.h> 17 #include <linux/of_device.h> 18 #include <linux/spi/spi.h> 19 20 /* RX-6110 Register definitions */ 21 #define RX6110_REG_SEC 0x10 22 #define RX6110_REG_MIN 0x11 23 #define RX6110_REG_HOUR 0x12 24 #define RX6110_REG_WDAY 0x13 25 #define RX6110_REG_MDAY 0x14 26 #define RX6110_REG_MONTH 0x15 27 #define RX6110_REG_YEAR 0x16 28 #define RX6110_REG_RES1 0x17 29 #define RX6110_REG_ALMIN 0x18 30 #define RX6110_REG_ALHOUR 0x19 31 #define RX6110_REG_ALWDAY 0x1A 32 #define RX6110_REG_TCOUNT0 0x1B 33 #define RX6110_REG_TCOUNT1 0x1C 34 #define RX6110_REG_EXT 0x1D 35 #define RX6110_REG_FLAG 0x1E 36 #define RX6110_REG_CTRL 0x1F 37 #define RX6110_REG_USER0 0x20 38 #define RX6110_REG_USER1 0x21 39 #define RX6110_REG_USER2 0x22 40 #define RX6110_REG_USER3 0x23 41 #define RX6110_REG_USER4 0x24 42 #define RX6110_REG_USER5 0x25 43 #define RX6110_REG_USER6 0x26 44 #define RX6110_REG_USER7 0x27 45 #define RX6110_REG_USER8 0x28 46 #define RX6110_REG_USER9 0x29 47 #define RX6110_REG_USERA 0x2A 48 #define RX6110_REG_USERB 0x2B 49 #define RX6110_REG_USERC 0x2C 50 #define RX6110_REG_USERD 0x2D 51 #define RX6110_REG_USERE 0x2E 52 #define RX6110_REG_USERF 0x2F 53 #define RX6110_REG_RES2 0x30 54 #define RX6110_REG_RES3 0x31 55 #define RX6110_REG_IRQ 0x32 56 57 #define RX6110_BIT_ALARM_EN BIT(7) 58 59 /* Extension Register (1Dh) bit positions */ 60 #define RX6110_BIT_EXT_TSEL0 BIT(0) 61 #define RX6110_BIT_EXT_TSEL1 BIT(1) 62 #define RX6110_BIT_EXT_TSEL2 BIT(2) 63 #define RX6110_BIT_EXT_WADA BIT(3) 64 #define RX6110_BIT_EXT_TE BIT(4) 65 #define RX6110_BIT_EXT_USEL BIT(5) 66 #define RX6110_BIT_EXT_FSEL0 BIT(6) 67 #define RX6110_BIT_EXT_FSEL1 BIT(7) 68 69 /* Flag Register (1Eh) bit positions */ 70 #define RX6110_BIT_FLAG_VLF BIT(1) 71 #define RX6110_BIT_FLAG_AF BIT(3) 72 #define RX6110_BIT_FLAG_TF BIT(4) 73 #define RX6110_BIT_FLAG_UF BIT(5) 74 75 /* Control Register (1Fh) bit positions */ 76 #define RX6110_BIT_CTRL_TBKE BIT(0) 77 #define RX6110_BIT_CTRL_TBKON BIT(1) 78 #define RX6110_BIT_CTRL_TSTP BIT(2) 79 #define RX6110_BIT_CTRL_AIE BIT(3) 80 #define RX6110_BIT_CTRL_TIE BIT(4) 81 #define RX6110_BIT_CTRL_UIE BIT(5) 82 #define RX6110_BIT_CTRL_STOP BIT(6) 83 #define RX6110_BIT_CTRL_TEST BIT(7) 84 85 enum { 86 RTC_SEC = 0, 87 RTC_MIN, 88 RTC_HOUR, 89 RTC_WDAY, 90 RTC_MDAY, 91 RTC_MONTH, 92 RTC_YEAR, 93 RTC_NR_TIME 94 }; 95 96 #define RX6110_DRIVER_NAME "rx6110" 97 98 struct rx6110_data { 99 struct rtc_device *rtc; 100 struct regmap *regmap; 101 }; 102 103 /** 104 * rx6110_rtc_tm_to_data - convert rtc_time to native time encoding 105 * 106 * @tm: holds date and time 107 * @data: holds the encoding in rx6110 native form 108 */ 109 static int rx6110_rtc_tm_to_data(struct rtc_time *tm, u8 *data) 110 { 111 pr_debug("%s: date %ptRr\n", __func__, tm); 112 113 /* 114 * The year in the RTC is a value between 0 and 99. 115 * Assume that this represents the current century 116 * and disregard all other values. 117 */ 118 if (tm->tm_year < 100 || tm->tm_year >= 200) 119 return -EINVAL; 120 121 data[RTC_SEC] = bin2bcd(tm->tm_sec); 122 data[RTC_MIN] = bin2bcd(tm->tm_min); 123 data[RTC_HOUR] = bin2bcd(tm->tm_hour); 124 data[RTC_WDAY] = BIT(bin2bcd(tm->tm_wday)); 125 data[RTC_MDAY] = bin2bcd(tm->tm_mday); 126 data[RTC_MONTH] = bin2bcd(tm->tm_mon + 1); 127 data[RTC_YEAR] = bin2bcd(tm->tm_year % 100); 128 129 return 0; 130 } 131 132 /** 133 * rx6110_data_to_rtc_tm - convert native time encoding to rtc_time 134 * 135 * @data: holds the encoding in rx6110 native form 136 * @tm: holds date and time 137 */ 138 static int rx6110_data_to_rtc_tm(u8 *data, struct rtc_time *tm) 139 { 140 tm->tm_sec = bcd2bin(data[RTC_SEC] & 0x7f); 141 tm->tm_min = bcd2bin(data[RTC_MIN] & 0x7f); 142 /* only 24-hour clock */ 143 tm->tm_hour = bcd2bin(data[RTC_HOUR] & 0x3f); 144 tm->tm_wday = ffs(data[RTC_WDAY] & 0x7f); 145 tm->tm_mday = bcd2bin(data[RTC_MDAY] & 0x3f); 146 tm->tm_mon = bcd2bin(data[RTC_MONTH] & 0x1f) - 1; 147 tm->tm_year = bcd2bin(data[RTC_YEAR]) + 100; 148 149 pr_debug("%s: date %ptRr\n", __func__, tm); 150 151 /* 152 * The year in the RTC is a value between 0 and 99. 153 * Assume that this represents the current century 154 * and disregard all other values. 155 */ 156 if (tm->tm_year < 100 || tm->tm_year >= 200) 157 return -EINVAL; 158 159 return 0; 160 } 161 162 /** 163 * rx6110_set_time - set the current time in the rx6110 registers 164 * 165 * @dev: the rtc device in use 166 * @tm: holds date and time 167 * 168 * BUG: The HW assumes every year that is a multiple of 4 to be a leap 169 * year. Next time this is wrong is 2100, which will not be a leap year 170 * 171 * Note: If STOP is not set/cleared, the clock will start when the seconds 172 * register is written 173 * 174 */ 175 static int rx6110_set_time(struct device *dev, struct rtc_time *tm) 176 { 177 struct rx6110_data *rx6110 = dev_get_drvdata(dev); 178 u8 data[RTC_NR_TIME]; 179 int ret; 180 181 ret = rx6110_rtc_tm_to_data(tm, data); 182 if (ret < 0) 183 return ret; 184 185 /* set STOP bit before changing clock/calendar */ 186 ret = regmap_update_bits(rx6110->regmap, RX6110_REG_CTRL, 187 RX6110_BIT_CTRL_STOP, RX6110_BIT_CTRL_STOP); 188 if (ret) 189 return ret; 190 191 ret = regmap_bulk_write(rx6110->regmap, RX6110_REG_SEC, data, 192 RTC_NR_TIME); 193 if (ret) 194 return ret; 195 196 /* The time in the RTC is valid. Be sure to have VLF cleared. */ 197 ret = regmap_update_bits(rx6110->regmap, RX6110_REG_FLAG, 198 RX6110_BIT_FLAG_VLF, 0); 199 if (ret) 200 return ret; 201 202 /* clear STOP bit after changing clock/calendar */ 203 ret = regmap_update_bits(rx6110->regmap, RX6110_REG_CTRL, 204 RX6110_BIT_CTRL_STOP, 0); 205 206 return ret; 207 } 208 209 /** 210 * rx6110_get_time - get the current time from the rx6110 registers 211 * @dev: the rtc device in use 212 * @tm: holds date and time 213 */ 214 static int rx6110_get_time(struct device *dev, struct rtc_time *tm) 215 { 216 struct rx6110_data *rx6110 = dev_get_drvdata(dev); 217 u8 data[RTC_NR_TIME]; 218 int flags; 219 int ret; 220 221 ret = regmap_read(rx6110->regmap, RX6110_REG_FLAG, &flags); 222 if (ret) 223 return -EINVAL; 224 225 /* check for VLF Flag (set at power-on) */ 226 if ((flags & RX6110_BIT_FLAG_VLF)) { 227 dev_warn(dev, "Voltage low, data is invalid.\n"); 228 return -EINVAL; 229 } 230 231 /* read registers to date */ 232 ret = regmap_bulk_read(rx6110->regmap, RX6110_REG_SEC, data, 233 RTC_NR_TIME); 234 if (ret) 235 return ret; 236 237 ret = rx6110_data_to_rtc_tm(data, tm); 238 if (ret) 239 return ret; 240 241 dev_dbg(dev, "%s: date %ptRr\n", __func__, tm); 242 243 return 0; 244 } 245 246 static const struct reg_sequence rx6110_default_regs[] = { 247 { RX6110_REG_RES1, 0xB8 }, 248 { RX6110_REG_RES2, 0x00 }, 249 { RX6110_REG_RES3, 0x10 }, 250 { RX6110_REG_IRQ, 0x00 }, 251 { RX6110_REG_ALMIN, 0x00 }, 252 { RX6110_REG_ALHOUR, 0x00 }, 253 { RX6110_REG_ALWDAY, 0x00 }, 254 }; 255 256 /** 257 * rx6110_init - initialize the rx6110 registers 258 * 259 * @rx6110: pointer to the rx6110 struct in use 260 * 261 */ 262 static int rx6110_init(struct rx6110_data *rx6110) 263 { 264 struct rtc_device *rtc = rx6110->rtc; 265 int flags; 266 int ret; 267 268 ret = regmap_update_bits(rx6110->regmap, RX6110_REG_EXT, 269 RX6110_BIT_EXT_TE, 0); 270 if (ret) 271 return ret; 272 273 ret = regmap_register_patch(rx6110->regmap, rx6110_default_regs, 274 ARRAY_SIZE(rx6110_default_regs)); 275 if (ret) 276 return ret; 277 278 ret = regmap_read(rx6110->regmap, RX6110_REG_FLAG, &flags); 279 if (ret) 280 return ret; 281 282 /* check for VLF Flag (set at power-on) */ 283 if ((flags & RX6110_BIT_FLAG_VLF)) 284 dev_warn(&rtc->dev, "Voltage low, data loss detected.\n"); 285 286 /* check for Alarm Flag */ 287 if (flags & RX6110_BIT_FLAG_AF) 288 dev_warn(&rtc->dev, "An alarm may have been missed.\n"); 289 290 /* check for Periodic Timer Flag */ 291 if (flags & RX6110_BIT_FLAG_TF) 292 dev_warn(&rtc->dev, "Periodic timer was detected\n"); 293 294 /* check for Update Timer Flag */ 295 if (flags & RX6110_BIT_FLAG_UF) 296 dev_warn(&rtc->dev, "Update timer was detected\n"); 297 298 /* clear all flags BUT VLF */ 299 ret = regmap_update_bits(rx6110->regmap, RX6110_REG_FLAG, 300 RX6110_BIT_FLAG_AF | 301 RX6110_BIT_FLAG_UF | 302 RX6110_BIT_FLAG_TF, 303 0); 304 305 return ret; 306 } 307 308 static const struct rtc_class_ops rx6110_rtc_ops = { 309 .read_time = rx6110_get_time, 310 .set_time = rx6110_set_time, 311 }; 312 313 static struct regmap_config regmap_spi_config = { 314 .reg_bits = 8, 315 .val_bits = 8, 316 .max_register = RX6110_REG_IRQ, 317 .read_flag_mask = 0x80, 318 }; 319 320 /** 321 * rx6110_probe - initialize rtc driver 322 * @spi: pointer to spi device 323 */ 324 static int rx6110_probe(struct spi_device *spi) 325 { 326 struct rx6110_data *rx6110; 327 int err; 328 329 if ((spi->bits_per_word && spi->bits_per_word != 8) || 330 (spi->max_speed_hz > 2000000) || 331 (spi->mode != (SPI_CS_HIGH | SPI_CPOL | SPI_CPHA))) { 332 dev_warn(&spi->dev, "SPI settings: bits_per_word: %d, max_speed_hz: %d, mode: %xh\n", 333 spi->bits_per_word, spi->max_speed_hz, spi->mode); 334 dev_warn(&spi->dev, "driving device in an unsupported mode"); 335 } 336 337 rx6110 = devm_kzalloc(&spi->dev, sizeof(*rx6110), GFP_KERNEL); 338 if (!rx6110) 339 return -ENOMEM; 340 341 rx6110->regmap = devm_regmap_init_spi(spi, ®map_spi_config); 342 if (IS_ERR(rx6110->regmap)) { 343 dev_err(&spi->dev, "regmap init failed for rtc rx6110\n"); 344 return PTR_ERR(rx6110->regmap); 345 } 346 347 spi_set_drvdata(spi, rx6110); 348 349 rx6110->rtc = devm_rtc_device_register(&spi->dev, 350 RX6110_DRIVER_NAME, 351 &rx6110_rtc_ops, THIS_MODULE); 352 353 if (IS_ERR(rx6110->rtc)) 354 return PTR_ERR(rx6110->rtc); 355 356 err = rx6110_init(rx6110); 357 if (err) 358 return err; 359 360 rx6110->rtc->max_user_freq = 1; 361 362 return 0; 363 } 364 365 static const struct spi_device_id rx6110_id[] = { 366 { "rx6110", 0 }, 367 { } 368 }; 369 MODULE_DEVICE_TABLE(spi, rx6110_id); 370 371 static const struct of_device_id rx6110_spi_of_match[] = { 372 { .compatible = "epson,rx6110" }, 373 { }, 374 }; 375 MODULE_DEVICE_TABLE(of, rx6110_spi_of_match); 376 377 static struct spi_driver rx6110_driver = { 378 .driver = { 379 .name = RX6110_DRIVER_NAME, 380 .of_match_table = of_match_ptr(rx6110_spi_of_match), 381 }, 382 .probe = rx6110_probe, 383 .id_table = rx6110_id, 384 }; 385 386 module_spi_driver(rx6110_driver); 387 388 MODULE_AUTHOR("Val Krutov <val.krutov@erd.epson.com>"); 389 MODULE_DESCRIPTION("RX-6110 SA RTC driver"); 390 MODULE_LICENSE("GPL"); 391