drivers/rtc/rtc-rx8010.c

   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 rx8010_data *rx8010 = dev_get_drvdata(dev);
 393         int tmp;
 394         int flagreg;
 395
 396         switch (cmd) {
 397         case RTC_VL_READ:
 398                 flagreg = i2c_smbus_read_byte_data(rx8010->client, RX8010_FLAG);
 399                 if (flagreg < 0)
 400                         return flagreg;
 401
 402                 tmp = flagreg & RX8010_FLAG_VLF ? RTC_VL_DATA_INVALID : 0;
 403                 return put_user(tmp, (unsigned int __user *)arg);
 404
 405         default:
 406                 return -ENOIOCTLCMD;
 407         }
 408 }
 409
 410 static struct rtc_class_ops rx8010_rtc_ops = {
 411         .read_time = rx8010_get_time,
 412         .set_time = rx8010_set_time,
 413         .ioctl = rx8010_ioctl,
 414 };
 415
 416 static int rx8010_probe(struct i2c_client *client,
 417                         const struct i2c_device_id *id)
 418 {
 419         struct i2c_adapter *adapter = client->adapter;
 420         struct rx8010_data *rx8010;
 421         int err = 0;
 422
 423         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
 424                 | I2C_FUNC_SMBUS_I2C_BLOCK)) {
 425                 dev_err(&adapter->dev, "doesn't support required functionality\n");
 426                 return -EIO;
 427         }
 428
 429         rx8010 = devm_kzalloc(&client->dev, sizeof(struct rx8010_data),
 430                               GFP_KERNEL);
 431         if (!rx8010)
 432                 return -ENOMEM;
 433
 434         rx8010->client = client;
 435         i2c_set_clientdata(client, rx8010);
 436
 437         err = rx8010_init_client(client);
 438         if (err)
 439                 return err;
 440
 441         if (client->irq > 0) {
 442                 dev_info(&client->dev, "IRQ %d supplied\n", client->irq);
 443                 err = devm_request_threaded_irq(&client->dev, client->irq, NULL,
 444                                                 rx8010_irq_1_handler,
 445                                                 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 446                                                 "rx8010", client);
 447
 448                 if (err) {
 449                         dev_err(&client->dev, "unable to request IRQ\n");
 450                         client->irq = 0;
 451                 } else {
 452                         rx8010_rtc_ops.read_alarm = rx8010_read_alarm;
 453                         rx8010_rtc_ops.set_alarm = rx8010_set_alarm;
 454                         rx8010_rtc_ops.alarm_irq_enable = rx8010_alarm_irq_enable;
 455                 }
 456         }
 457
 458         rx8010->rtc = devm_rtc_device_register(&client->dev, client->name,
 459                 &rx8010_rtc_ops, THIS_MODULE);
 460
 461         if (IS_ERR(rx8010->rtc)) {
 462                 dev_err(&client->dev, "unable to register the class device\n");
 463                 return PTR_ERR(rx8010->rtc);
 464         }
 465
 466         rx8010->rtc->max_user_freq = 1;
 467
 468         return 0;
 469 }
 470
 471 static struct i2c_driver rx8010_driver = {
 472         .driver = {
 473                 .name = "rtc-rx8010",
 474                 .of_match_table = of_match_ptr(rx8010_of_match),
 475         },
 476         .probe          = rx8010_probe,
 477         .id_table       = rx8010_id,
 478 };
 479
 480 module_i2c_driver(rx8010_driver);
 481
 482 MODULE_AUTHOR("Akshay Bhat <akshay.bhat@timesys.com>");
 483 MODULE_DESCRIPTION("Epson RX8010SJ RTC driver");
 484 MODULE_LICENSE("GPL v2");