drivers/rtc/rtc-rx8010.c

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