1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for the Epson RTC module RX-8010 SJ 4 * 5 * Copyright(C) Timesys Corporation 2015 6 * Copyright(C) General Electric Company 2015 7 */ 8 9 #include <linux/bcd.h> 10 #include <linux/bitops.h> 11 #include <linux/i2c.h> 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/rtc.h> 15 16 #define RX8010_SEC 0x10 17 #define RX8010_MIN 0x11 18 #define RX8010_HOUR 0x12 19 #define RX8010_WDAY 0x13 20 #define RX8010_MDAY 0x14 21 #define RX8010_MONTH 0x15 22 #define RX8010_YEAR 0x16 23 #define RX8010_RESV17 0x17 24 #define RX8010_ALMIN 0x18 25 #define RX8010_ALHOUR 0x19 26 #define RX8010_ALWDAY 0x1A 27 #define RX8010_TCOUNT0 0x1B 28 #define RX8010_TCOUNT1 0x1C 29 #define RX8010_EXT 0x1D 30 #define RX8010_FLAG 0x1E 31 #define RX8010_CTRL 0x1F 32 /* 0x20 to 0x2F are user registers */ 33 #define RX8010_RESV30 0x30 34 #define RX8010_RESV31 0x31 35 #define RX8010_IRQ 0x32 36 37 #define RX8010_EXT_WADA BIT(3) 38 39 #define RX8010_FLAG_VLF BIT(1) 40 #define RX8010_FLAG_AF BIT(3) 41 #define RX8010_FLAG_TF BIT(4) 42 #define RX8010_FLAG_UF BIT(5) 43 44 #define RX8010_CTRL_AIE BIT(3) 45 #define RX8010_CTRL_UIE BIT(5) 46 #define RX8010_CTRL_STOP BIT(6) 47 #define RX8010_CTRL_TEST BIT(7) 48 49 #define RX8010_ALARM_AE BIT(7) 50 51 static const struct i2c_device_id rx8010_id[] = { 52 { "rx8010", 0 }, 53 { } 54 }; 55 MODULE_DEVICE_TABLE(i2c, rx8010_id); 56 57 static const struct of_device_id rx8010_of_match[] = { 58 { .compatible = "epson,rx8010" }, 59 { } 60 }; 61 MODULE_DEVICE_TABLE(of, rx8010_of_match); 62 63 struct rx8010_data { 64 struct i2c_client *client; 65 struct rtc_device *rtc; 66 u8 ctrlreg; 67 }; 68 69 static irqreturn_t rx8010_irq_1_handler(int irq, void *dev_id) 70 { 71 struct i2c_client *client = dev_id; 72 struct rx8010_data *rx8010 = i2c_get_clientdata(client); 73 int flagreg; 74 75 mutex_lock(&rx8010->rtc->ops_lock); 76 77 flagreg = i2c_smbus_read_byte_data(client, RX8010_FLAG); 78 79 if (flagreg <= 0) { 80 mutex_unlock(&rx8010->rtc->ops_lock); 81 return IRQ_NONE; 82 } 83 84 if (flagreg & RX8010_FLAG_VLF) 85 dev_warn(&client->dev, "Frequency stop detected\n"); 86 87 if (flagreg & RX8010_FLAG_TF) { 88 flagreg &= ~RX8010_FLAG_TF; 89 rtc_update_irq(rx8010->rtc, 1, RTC_PF | RTC_IRQF); 90 } 91 92 if (flagreg & RX8010_FLAG_AF) { 93 flagreg &= ~RX8010_FLAG_AF; 94 rtc_update_irq(rx8010->rtc, 1, RTC_AF | RTC_IRQF); 95 } 96 97 if (flagreg & RX8010_FLAG_UF) { 98 flagreg &= ~RX8010_FLAG_UF; 99 rtc_update_irq(rx8010->rtc, 1, RTC_UF | RTC_IRQF); 100 } 101 102 i2c_smbus_write_byte_data(client, RX8010_FLAG, flagreg); 103 104 mutex_unlock(&rx8010->rtc->ops_lock); 105 return IRQ_HANDLED; 106 } 107 108 static int rx8010_get_time(struct device *dev, struct rtc_time *dt) 109 { 110 struct rx8010_data *rx8010 = dev_get_drvdata(dev); 111 u8 date[7]; 112 int flagreg; 113 int err; 114 115 flagreg = i2c_smbus_read_byte_data(rx8010->client, RX8010_FLAG); 116 if (flagreg < 0) 117 return flagreg; 118 119 if (flagreg & RX8010_FLAG_VLF) { 120 dev_warn(dev, "Frequency stop detected\n"); 121 return -EINVAL; 122 } 123 124 err = i2c_smbus_read_i2c_block_data(rx8010->client, RX8010_SEC, 125 7, date); 126 if (err != 7) 127 return err < 0 ? err : -EIO; 128 129 dt->tm_sec = bcd2bin(date[RX8010_SEC - RX8010_SEC] & 0x7f); 130 dt->tm_min = bcd2bin(date[RX8010_MIN - RX8010_SEC] & 0x7f); 131 dt->tm_hour = bcd2bin(date[RX8010_HOUR - RX8010_SEC] & 0x3f); 132 dt->tm_mday = bcd2bin(date[RX8010_MDAY - RX8010_SEC] & 0x3f); 133 dt->tm_mon = bcd2bin(date[RX8010_MONTH - RX8010_SEC] & 0x1f) - 1; 134 dt->tm_year = bcd2bin(date[RX8010_YEAR - RX8010_SEC]) + 100; 135 dt->tm_wday = ffs(date[RX8010_WDAY - RX8010_SEC] & 0x7f); 136 137 return 0; 138 } 139 140 static int rx8010_set_time(struct device *dev, struct rtc_time *dt) 141 { 142 struct rx8010_data *rx8010 = dev_get_drvdata(dev); 143 u8 date[7]; 144 int ctrl, flagreg; 145 int ret; 146 147 if ((dt->tm_year < 100) || (dt->tm_year > 199)) 148 return -EINVAL; 149 150 /* set STOP bit before changing clock/calendar */ 151 ctrl = i2c_smbus_read_byte_data(rx8010->client, RX8010_CTRL); 152 if (ctrl < 0) 153 return ctrl; 154 rx8010->ctrlreg = ctrl | RX8010_CTRL_STOP; 155 ret = i2c_smbus_write_byte_data(rx8010->client, RX8010_CTRL, 156 rx8010->ctrlreg); 157 if (ret < 0) 158 return ret; 159 160 date[RX8010_SEC - RX8010_SEC] = bin2bcd(dt->tm_sec); 161 date[RX8010_MIN - RX8010_SEC] = bin2bcd(dt->tm_min); 162 date[RX8010_HOUR - RX8010_SEC] = bin2bcd(dt->tm_hour); 163 date[RX8010_MDAY - RX8010_SEC] = bin2bcd(dt->tm_mday); 164 date[RX8010_MONTH - RX8010_SEC] = bin2bcd(dt->tm_mon + 1); 165 date[RX8010_YEAR - RX8010_SEC] = bin2bcd(dt->tm_year - 100); 166 date[RX8010_WDAY - RX8010_SEC] = bin2bcd(1 << dt->tm_wday); 167 168 ret = i2c_smbus_write_i2c_block_data(rx8010->client, 169 RX8010_SEC, 7, date); 170 if (ret < 0) 171 return ret; 172 173 /* clear STOP bit after changing clock/calendar */ 174 ctrl = i2c_smbus_read_byte_data(rx8010->client, RX8010_CTRL); 175 if (ctrl < 0) 176 return ctrl; 177 rx8010->ctrlreg = ctrl & ~RX8010_CTRL_STOP; 178 ret = i2c_smbus_write_byte_data(rx8010->client, RX8010_CTRL, 179 rx8010->ctrlreg); 180 if (ret < 0) 181 return ret; 182 183 flagreg = i2c_smbus_read_byte_data(rx8010->client, RX8010_FLAG); 184 if (flagreg < 0) { 185 return flagreg; 186 } 187 188 if (flagreg & RX8010_FLAG_VLF) 189 ret = i2c_smbus_write_byte_data(rx8010->client, RX8010_FLAG, 190 flagreg & ~RX8010_FLAG_VLF); 191 192 return 0; 193 } 194 195 static int rx8010_init_client(struct i2c_client *client) 196 { 197 struct rx8010_data *rx8010 = i2c_get_clientdata(client); 198 u8 ctrl[2]; 199 int need_clear = 0, err = 0; 200 201 /* Initialize reserved registers as specified in datasheet */ 202 err = i2c_smbus_write_byte_data(client, RX8010_RESV17, 0xD8); 203 if (err < 0) 204 return err; 205 206 err = i2c_smbus_write_byte_data(client, RX8010_RESV30, 0x00); 207 if (err < 0) 208 return err; 209 210 err = i2c_smbus_write_byte_data(client, RX8010_RESV31, 0x08); 211 if (err < 0) 212 return err; 213 214 err = i2c_smbus_write_byte_data(client, RX8010_IRQ, 0x00); 215 if (err < 0) 216 return err; 217 218 err = i2c_smbus_read_i2c_block_data(rx8010->client, RX8010_FLAG, 219 2, ctrl); 220 if (err != 2) 221 return err < 0 ? err : -EIO; 222 223 if (ctrl[0] & RX8010_FLAG_VLF) 224 dev_warn(&client->dev, "Frequency stop was detected\n"); 225 226 if (ctrl[0] & RX8010_FLAG_AF) { 227 dev_warn(&client->dev, "Alarm was detected\n"); 228 need_clear = 1; 229 } 230 231 if (ctrl[0] & RX8010_FLAG_TF) 232 need_clear = 1; 233 234 if (ctrl[0] & RX8010_FLAG_UF) 235 need_clear = 1; 236 237 if (need_clear) { 238 ctrl[0] &= ~(RX8010_FLAG_AF | RX8010_FLAG_TF | RX8010_FLAG_UF); 239 err = i2c_smbus_write_byte_data(client, RX8010_FLAG, ctrl[0]); 240 if (err < 0) 241 return err; 242 } 243 244 rx8010->ctrlreg = (ctrl[1] & ~RX8010_CTRL_TEST); 245 246 return 0; 247 } 248 249 static int rx8010_read_alarm(struct device *dev, struct rtc_wkalrm *t) 250 { 251 struct rx8010_data *rx8010 = dev_get_drvdata(dev); 252 struct i2c_client *client = rx8010->client; 253 u8 alarmvals[3]; 254 int flagreg; 255 int err; 256 257 err = i2c_smbus_read_i2c_block_data(client, RX8010_ALMIN, 3, alarmvals); 258 if (err != 3) 259 return err < 0 ? err : -EIO; 260 261 flagreg = i2c_smbus_read_byte_data(client, RX8010_FLAG); 262 if (flagreg < 0) 263 return flagreg; 264 265 t->time.tm_sec = 0; 266 t->time.tm_min = bcd2bin(alarmvals[0] & 0x7f); 267 t->time.tm_hour = bcd2bin(alarmvals[1] & 0x3f); 268 269 if (!(alarmvals[2] & RX8010_ALARM_AE)) 270 t->time.tm_mday = bcd2bin(alarmvals[2] & 0x7f); 271 272 t->enabled = !!(rx8010->ctrlreg & RX8010_CTRL_AIE); 273 t->pending = (flagreg & RX8010_FLAG_AF) && t->enabled; 274 275 return 0; 276 } 277 278 static int rx8010_set_alarm(struct device *dev, struct rtc_wkalrm *t) 279 { 280 struct i2c_client *client = to_i2c_client(dev); 281 struct rx8010_data *rx8010 = dev_get_drvdata(dev); 282 u8 alarmvals[3]; 283 int extreg, flagreg; 284 int err; 285 286 flagreg = i2c_smbus_read_byte_data(client, RX8010_FLAG); 287 if (flagreg < 0) { 288 return flagreg; 289 } 290 291 if (rx8010->ctrlreg & (RX8010_CTRL_AIE | RX8010_CTRL_UIE)) { 292 rx8010->ctrlreg &= ~(RX8010_CTRL_AIE | RX8010_CTRL_UIE); 293 err = i2c_smbus_write_byte_data(rx8010->client, RX8010_CTRL, 294 rx8010->ctrlreg); 295 if (err < 0) { 296 return err; 297 } 298 } 299 300 flagreg &= ~RX8010_FLAG_AF; 301 err = i2c_smbus_write_byte_data(rx8010->client, RX8010_FLAG, flagreg); 302 if (err < 0) 303 return err; 304 305 alarmvals[0] = bin2bcd(t->time.tm_min); 306 alarmvals[1] = bin2bcd(t->time.tm_hour); 307 alarmvals[2] = bin2bcd(t->time.tm_mday); 308 309 err = i2c_smbus_write_i2c_block_data(rx8010->client, RX8010_ALMIN, 310 2, alarmvals); 311 if (err < 0) 312 return err; 313 314 extreg = i2c_smbus_read_byte_data(client, RX8010_EXT); 315 if (extreg < 0) 316 return extreg; 317 318 extreg |= RX8010_EXT_WADA; 319 err = i2c_smbus_write_byte_data(rx8010->client, RX8010_EXT, extreg); 320 if (err < 0) 321 return err; 322 323 if (alarmvals[2] == 0) 324 alarmvals[2] |= RX8010_ALARM_AE; 325 326 err = i2c_smbus_write_byte_data(rx8010->client, RX8010_ALWDAY, 327 alarmvals[2]); 328 if (err < 0) 329 return err; 330 331 if (t->enabled) { 332 if (rx8010->rtc->uie_rtctimer.enabled) 333 rx8010->ctrlreg |= RX8010_CTRL_UIE; 334 if (rx8010->rtc->aie_timer.enabled) 335 rx8010->ctrlreg |= 336 (RX8010_CTRL_AIE | RX8010_CTRL_UIE); 337 338 err = i2c_smbus_write_byte_data(rx8010->client, RX8010_CTRL, 339 rx8010->ctrlreg); 340 if (err < 0) 341 return err; 342 } 343 344 return 0; 345 } 346 347 static int rx8010_alarm_irq_enable(struct device *dev, 348 unsigned int enabled) 349 { 350 struct i2c_client *client = to_i2c_client(dev); 351 struct rx8010_data *rx8010 = dev_get_drvdata(dev); 352 int flagreg; 353 u8 ctrl; 354 int err; 355 356 ctrl = rx8010->ctrlreg; 357 358 if (enabled) { 359 if (rx8010->rtc->uie_rtctimer.enabled) 360 ctrl |= RX8010_CTRL_UIE; 361 if (rx8010->rtc->aie_timer.enabled) 362 ctrl |= (RX8010_CTRL_AIE | RX8010_CTRL_UIE); 363 } else { 364 if (!rx8010->rtc->uie_rtctimer.enabled) 365 ctrl &= ~RX8010_CTRL_UIE; 366 if (!rx8010->rtc->aie_timer.enabled) 367 ctrl &= ~RX8010_CTRL_AIE; 368 } 369 370 flagreg = i2c_smbus_read_byte_data(client, RX8010_FLAG); 371 if (flagreg < 0) 372 return flagreg; 373 374 flagreg &= ~RX8010_FLAG_AF; 375 err = i2c_smbus_write_byte_data(rx8010->client, RX8010_FLAG, flagreg); 376 if (err < 0) 377 return err; 378 379 if (ctrl != rx8010->ctrlreg) { 380 rx8010->ctrlreg = ctrl; 381 err = i2c_smbus_write_byte_data(rx8010->client, RX8010_CTRL, 382 rx8010->ctrlreg); 383 if (err < 0) 384 return err; 385 } 386 387 return 0; 388 } 389 390 static int rx8010_ioctl(struct device *dev, unsigned int cmd, unsigned long arg) 391 { 392 struct i2c_client *client = to_i2c_client(dev); 393 struct rx8010_data *rx8010 = dev_get_drvdata(dev); 394 int ret, tmp; 395 int flagreg; 396 397 switch (cmd) { 398 case RTC_VL_READ: 399 flagreg = i2c_smbus_read_byte_data(rx8010->client, RX8010_FLAG); 400 if (flagreg < 0) 401 return flagreg; 402 403 tmp = !!(flagreg & RX8010_FLAG_VLF); 404 if (copy_to_user((void __user *)arg, &tmp, sizeof(int))) 405 return -EFAULT; 406 407 return 0; 408 409 case RTC_VL_CLR: 410 flagreg = i2c_smbus_read_byte_data(rx8010->client, RX8010_FLAG); 411 if (flagreg < 0) { 412 return flagreg; 413 } 414 415 flagreg &= ~RX8010_FLAG_VLF; 416 ret = i2c_smbus_write_byte_data(client, RX8010_FLAG, flagreg); 417 if (ret < 0) 418 return ret; 419 420 return 0; 421 422 default: 423 return -ENOIOCTLCMD; 424 } 425 } 426 427 static struct rtc_class_ops rx8010_rtc_ops = { 428 .read_time = rx8010_get_time, 429 .set_time = rx8010_set_time, 430 .ioctl = rx8010_ioctl, 431 }; 432 433 static int rx8010_probe(struct i2c_client *client, 434 const struct i2c_device_id *id) 435 { 436 struct i2c_adapter *adapter = client->adapter; 437 struct rx8010_data *rx8010; 438 int err = 0; 439 440 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA 441 | I2C_FUNC_SMBUS_I2C_BLOCK)) { 442 dev_err(&adapter->dev, "doesn't support required functionality\n"); 443 return -EIO; 444 } 445 446 rx8010 = devm_kzalloc(&client->dev, sizeof(struct rx8010_data), 447 GFP_KERNEL); 448 if (!rx8010) 449 return -ENOMEM; 450 451 rx8010->client = client; 452 i2c_set_clientdata(client, rx8010); 453 454 err = rx8010_init_client(client); 455 if (err) 456 return err; 457 458 if (client->irq > 0) { 459 dev_info(&client->dev, "IRQ %d supplied\n", client->irq); 460 err = devm_request_threaded_irq(&client->dev, client->irq, NULL, 461 rx8010_irq_1_handler, 462 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 463 "rx8010", client); 464 465 if (err) { 466 dev_err(&client->dev, "unable to request IRQ\n"); 467 client->irq = 0; 468 } else { 469 rx8010_rtc_ops.read_alarm = rx8010_read_alarm; 470 rx8010_rtc_ops.set_alarm = rx8010_set_alarm; 471 rx8010_rtc_ops.alarm_irq_enable = rx8010_alarm_irq_enable; 472 } 473 } 474 475 rx8010->rtc = devm_rtc_device_register(&client->dev, client->name, 476 &rx8010_rtc_ops, THIS_MODULE); 477 478 if (IS_ERR(rx8010->rtc)) { 479 dev_err(&client->dev, "unable to register the class device\n"); 480 return PTR_ERR(rx8010->rtc); 481 } 482 483 rx8010->rtc->max_user_freq = 1; 484 485 return err; 486 } 487 488 static struct i2c_driver rx8010_driver = { 489 .driver = { 490 .name = "rtc-rx8010", 491 .of_match_table = of_match_ptr(rx8010_of_match), 492 }, 493 .probe = rx8010_probe, 494 .id_table = rx8010_id, 495 }; 496 497 module_i2c_driver(rx8010_driver); 498 499 MODULE_AUTHOR("Akshay Bhat <akshay.bhat@timesys.com>"); 500 MODULE_DESCRIPTION("Epson RX8010SJ RTC driver"); 501 MODULE_LICENSE("GPL v2"); 502