linux/drivers/rtc/rtc-rx8010.c
<<
>>
Prefs
   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/regmap.h>
  15#include <linux/rtc.h>
  16
  17#define RX8010_SEC              0x10
  18#define RX8010_MIN              0x11
  19#define RX8010_HOUR             0x12
  20#define RX8010_WDAY             0x13
  21#define RX8010_MDAY             0x14
  22#define RX8010_MONTH            0x15
  23#define RX8010_YEAR             0x16
  24#define RX8010_RESV17           0x17
  25#define RX8010_ALMIN            0x18
  26#define RX8010_ALHOUR           0x19
  27#define RX8010_ALWDAY           0x1A
  28#define RX8010_TCOUNT0          0x1B
  29#define RX8010_TCOUNT1          0x1C
  30#define RX8010_EXT              0x1D
  31#define RX8010_FLAG             0x1E
  32#define RX8010_CTRL             0x1F
  33/* 0x20 to 0x2F are user registers */
  34#define RX8010_RESV30           0x30
  35#define RX8010_RESV31           0x31
  36#define RX8010_IRQ              0x32
  37
  38#define RX8010_EXT_WADA         BIT(3)
  39
  40#define RX8010_FLAG_VLF         BIT(1)
  41#define RX8010_FLAG_AF          BIT(3)
  42#define RX8010_FLAG_TF          BIT(4)
  43#define RX8010_FLAG_UF          BIT(5)
  44
  45#define RX8010_CTRL_AIE         BIT(3)
  46#define RX8010_CTRL_UIE         BIT(5)
  47#define RX8010_CTRL_STOP        BIT(6)
  48#define RX8010_CTRL_TEST        BIT(7)
  49
  50#define RX8010_ALARM_AE         BIT(7)
  51
  52static const struct i2c_device_id rx8010_id[] = {
  53        { "rx8010", 0 },
  54        { }
  55};
  56MODULE_DEVICE_TABLE(i2c, rx8010_id);
  57
  58static const struct of_device_id rx8010_of_match[] = {
  59        { .compatible = "epson,rx8010" },
  60        { }
  61};
  62MODULE_DEVICE_TABLE(of, rx8010_of_match);
  63
  64struct rx8010_data {
  65        struct regmap *regs;
  66        struct rtc_device *rtc;
  67        u8 ctrlreg;
  68};
  69
  70static irqreturn_t rx8010_irq_1_handler(int irq, void *dev_id)
  71{
  72        struct i2c_client *client = dev_id;
  73        struct rx8010_data *rx8010 = i2c_get_clientdata(client);
  74        int flagreg, err;
  75
  76        mutex_lock(&rx8010->rtc->ops_lock);
  77
  78        err = regmap_read(rx8010->regs, RX8010_FLAG, &flagreg);
  79        if (err) {
  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        err = regmap_write(rx8010->regs, RX8010_FLAG, flagreg);
 103        mutex_unlock(&rx8010->rtc->ops_lock);
 104        return err ? IRQ_NONE : IRQ_HANDLED;
 105}
 106
 107static int rx8010_get_time(struct device *dev, struct rtc_time *dt)
 108{
 109        struct rx8010_data *rx8010 = dev_get_drvdata(dev);
 110        u8 date[RX8010_YEAR - RX8010_SEC + 1];
 111        int flagreg, err;
 112
 113        err = regmap_read(rx8010->regs, RX8010_FLAG, &flagreg);
 114        if (err)
 115                return err;
 116
 117        if (flagreg & RX8010_FLAG_VLF) {
 118                dev_warn(dev, "Frequency stop detected\n");
 119                return -EINVAL;
 120        }
 121
 122        err = regmap_bulk_read(rx8010->regs, RX8010_SEC, date, sizeof(date));
 123        if (err)
 124                return err;
 125
 126        dt->tm_sec = bcd2bin(date[RX8010_SEC - RX8010_SEC] & 0x7f);
 127        dt->tm_min = bcd2bin(date[RX8010_MIN - RX8010_SEC] & 0x7f);
 128        dt->tm_hour = bcd2bin(date[RX8010_HOUR - RX8010_SEC] & 0x3f);
 129        dt->tm_mday = bcd2bin(date[RX8010_MDAY - RX8010_SEC] & 0x3f);
 130        dt->tm_mon = bcd2bin(date[RX8010_MONTH - RX8010_SEC] & 0x1f) - 1;
 131        dt->tm_year = bcd2bin(date[RX8010_YEAR - RX8010_SEC]) + 100;
 132        dt->tm_wday = ffs(date[RX8010_WDAY - RX8010_SEC] & 0x7f);
 133
 134        return 0;
 135}
 136
 137static int rx8010_set_time(struct device *dev, struct rtc_time *dt)
 138{
 139        struct rx8010_data *rx8010 = dev_get_drvdata(dev);
 140        u8 date[RX8010_YEAR - RX8010_SEC + 1];
 141        int err;
 142
 143        /* set STOP bit before changing clock/calendar */
 144        err = regmap_set_bits(rx8010->regs, RX8010_CTRL, RX8010_CTRL_STOP);
 145        if (err)
 146                return err;
 147
 148        date[RX8010_SEC - RX8010_SEC] = bin2bcd(dt->tm_sec);
 149        date[RX8010_MIN - RX8010_SEC] = bin2bcd(dt->tm_min);
 150        date[RX8010_HOUR - RX8010_SEC] = bin2bcd(dt->tm_hour);
 151        date[RX8010_MDAY - RX8010_SEC] = bin2bcd(dt->tm_mday);
 152        date[RX8010_MONTH - RX8010_SEC] = bin2bcd(dt->tm_mon + 1);
 153        date[RX8010_YEAR - RX8010_SEC] = bin2bcd(dt->tm_year - 100);
 154        date[RX8010_WDAY - RX8010_SEC] = bin2bcd(1 << dt->tm_wday);
 155
 156        err = regmap_bulk_write(rx8010->regs, RX8010_SEC, date, sizeof(date));
 157        if (err)
 158                return err;
 159
 160        /* clear STOP bit after changing clock/calendar */
 161        err = regmap_clear_bits(rx8010->regs, RX8010_CTRL, RX8010_CTRL_STOP);
 162        if (err)
 163                return err;
 164
 165        err = regmap_clear_bits(rx8010->regs, RX8010_FLAG, RX8010_FLAG_VLF);
 166        if (err)
 167                return err;
 168
 169        return 0;
 170}
 171
 172static int rx8010_init(struct device *dev)
 173{
 174        struct rx8010_data *rx8010 = dev_get_drvdata(dev);
 175        u8 ctrl[2];
 176        int need_clear = 0, err;
 177
 178        /* Initialize reserved registers as specified in datasheet */
 179        err = regmap_write(rx8010->regs, RX8010_RESV17, 0xD8);
 180        if (err)
 181                return err;
 182
 183        err = regmap_write(rx8010->regs, RX8010_RESV30, 0x00);
 184        if (err)
 185                return err;
 186
 187        err = regmap_write(rx8010->regs, RX8010_RESV31, 0x08);
 188        if (err)
 189                return err;
 190
 191        err = regmap_write(rx8010->regs, RX8010_IRQ, 0x00);
 192        if (err)
 193                return err;
 194
 195        err = regmap_bulk_read(rx8010->regs, RX8010_FLAG, ctrl, 2);
 196        if (err)
 197                return err;
 198
 199        if (ctrl[0] & RX8010_FLAG_VLF)
 200                dev_warn(dev, "Frequency stop was detected\n");
 201
 202        if (ctrl[0] & RX8010_FLAG_AF) {
 203                dev_warn(dev, "Alarm was detected\n");
 204                need_clear = 1;
 205        }
 206
 207        if (ctrl[0] & RX8010_FLAG_TF)
 208                need_clear = 1;
 209
 210        if (ctrl[0] & RX8010_FLAG_UF)
 211                need_clear = 1;
 212
 213        if (need_clear) {
 214                ctrl[0] &= ~(RX8010_FLAG_AF | RX8010_FLAG_TF | RX8010_FLAG_UF);
 215                err = regmap_write(rx8010->regs, RX8010_FLAG, ctrl[0]);
 216                if (err)
 217                        return err;
 218        }
 219
 220        rx8010->ctrlreg = (ctrl[1] & ~RX8010_CTRL_TEST);
 221
 222        return 0;
 223}
 224
 225static int rx8010_read_alarm(struct device *dev, struct rtc_wkalrm *t)
 226{
 227        struct rx8010_data *rx8010 = dev_get_drvdata(dev);
 228        u8 alarmvals[3];
 229        int flagreg, err;
 230
 231        err = regmap_bulk_read(rx8010->regs, RX8010_ALMIN, alarmvals, 3);
 232        if (err)
 233                return err;
 234
 235        err = regmap_read(rx8010->regs, RX8010_FLAG, &flagreg);
 236        if (err)
 237                return err;
 238
 239        t->time.tm_sec = 0;
 240        t->time.tm_min = bcd2bin(alarmvals[0] & 0x7f);
 241        t->time.tm_hour = bcd2bin(alarmvals[1] & 0x3f);
 242
 243        if (!(alarmvals[2] & RX8010_ALARM_AE))
 244                t->time.tm_mday = bcd2bin(alarmvals[2] & 0x7f);
 245
 246        t->enabled = !!(rx8010->ctrlreg & RX8010_CTRL_AIE);
 247        t->pending = (flagreg & RX8010_FLAG_AF) && t->enabled;
 248
 249        return 0;
 250}
 251
 252static int rx8010_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 253{
 254        struct rx8010_data *rx8010 = dev_get_drvdata(dev);
 255        u8 alarmvals[3];
 256        int err;
 257
 258        if (rx8010->ctrlreg & (RX8010_CTRL_AIE | RX8010_CTRL_UIE)) {
 259                rx8010->ctrlreg &= ~(RX8010_CTRL_AIE | RX8010_CTRL_UIE);
 260                err = regmap_write(rx8010->regs, RX8010_CTRL, rx8010->ctrlreg);
 261                if (err)
 262                        return err;
 263        }
 264
 265        err = regmap_clear_bits(rx8010->regs, RX8010_FLAG, RX8010_FLAG_AF);
 266        if (err)
 267                return err;
 268
 269        alarmvals[0] = bin2bcd(t->time.tm_min);
 270        alarmvals[1] = bin2bcd(t->time.tm_hour);
 271        alarmvals[2] = bin2bcd(t->time.tm_mday);
 272
 273        err = regmap_bulk_write(rx8010->regs, RX8010_ALMIN, alarmvals, 2);
 274        if (err)
 275                return err;
 276
 277        err = regmap_clear_bits(rx8010->regs, RX8010_EXT, RX8010_EXT_WADA);
 278        if (err)
 279                return err;
 280
 281        if (alarmvals[2] == 0)
 282                alarmvals[2] |= RX8010_ALARM_AE;
 283
 284        err = regmap_write(rx8010->regs, RX8010_ALWDAY, alarmvals[2]);
 285        if (err)
 286                return err;
 287
 288        if (t->enabled) {
 289                if (rx8010->rtc->uie_rtctimer.enabled)
 290                        rx8010->ctrlreg |= RX8010_CTRL_UIE;
 291                if (rx8010->rtc->aie_timer.enabled)
 292                        rx8010->ctrlreg |=
 293                                (RX8010_CTRL_AIE | RX8010_CTRL_UIE);
 294
 295                err = regmap_write(rx8010->regs, RX8010_CTRL, rx8010->ctrlreg);
 296                if (err)
 297                        return err;
 298        }
 299
 300        return 0;
 301}
 302
 303static int rx8010_alarm_irq_enable(struct device *dev,
 304                                   unsigned int enabled)
 305{
 306        struct rx8010_data *rx8010 = dev_get_drvdata(dev);
 307        int err;
 308        u8 ctrl;
 309
 310        ctrl = rx8010->ctrlreg;
 311
 312        if (enabled) {
 313                if (rx8010->rtc->uie_rtctimer.enabled)
 314                        ctrl |= RX8010_CTRL_UIE;
 315                if (rx8010->rtc->aie_timer.enabled)
 316                        ctrl |= (RX8010_CTRL_AIE | RX8010_CTRL_UIE);
 317        } else {
 318                if (!rx8010->rtc->uie_rtctimer.enabled)
 319                        ctrl &= ~RX8010_CTRL_UIE;
 320                if (!rx8010->rtc->aie_timer.enabled)
 321                        ctrl &= ~RX8010_CTRL_AIE;
 322        }
 323
 324        err = regmap_clear_bits(rx8010->regs, RX8010_FLAG, RX8010_FLAG_AF);
 325        if (err)
 326                return err;
 327
 328        if (ctrl != rx8010->ctrlreg) {
 329                rx8010->ctrlreg = ctrl;
 330                err = regmap_write(rx8010->regs, RX8010_CTRL, rx8010->ctrlreg);
 331                if (err)
 332                        return err;
 333        }
 334
 335        return 0;
 336}
 337
 338static int rx8010_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 339{
 340        struct rx8010_data *rx8010 = dev_get_drvdata(dev);
 341        int tmp, flagreg, err;
 342
 343        switch (cmd) {
 344        case RTC_VL_READ:
 345                err = regmap_read(rx8010->regs, RX8010_FLAG, &flagreg);
 346                if (err)
 347                        return err;
 348
 349                tmp = flagreg & RX8010_FLAG_VLF ? RTC_VL_DATA_INVALID : 0;
 350                return put_user(tmp, (unsigned int __user *)arg);
 351
 352        default:
 353                return -ENOIOCTLCMD;
 354        }
 355}
 356
 357static const struct rtc_class_ops rx8010_rtc_ops_default = {
 358        .read_time = rx8010_get_time,
 359        .set_time = rx8010_set_time,
 360        .ioctl = rx8010_ioctl,
 361};
 362
 363static const struct rtc_class_ops rx8010_rtc_ops_alarm = {
 364        .read_time = rx8010_get_time,
 365        .set_time = rx8010_set_time,
 366        .ioctl = rx8010_ioctl,
 367        .read_alarm = rx8010_read_alarm,
 368        .set_alarm = rx8010_set_alarm,
 369        .alarm_irq_enable = rx8010_alarm_irq_enable,
 370};
 371
 372static const struct regmap_config rx8010_regmap_config = {
 373        .name = "rx8010-rtc",
 374        .reg_bits = 8,
 375        .val_bits = 8,
 376};
 377
 378static int rx8010_probe(struct i2c_client *client)
 379{
 380        struct device *dev = &client->dev;
 381        struct rx8010_data *rx8010;
 382        int err = 0;
 383
 384        rx8010 = devm_kzalloc(dev, sizeof(*rx8010), GFP_KERNEL);
 385        if (!rx8010)
 386                return -ENOMEM;
 387
 388        i2c_set_clientdata(client, rx8010);
 389
 390        rx8010->regs = devm_regmap_init_i2c(client, &rx8010_regmap_config);
 391        if (IS_ERR(rx8010->regs))
 392                return PTR_ERR(rx8010->regs);
 393
 394        err = rx8010_init(dev);
 395        if (err)
 396                return err;
 397
 398        rx8010->rtc = devm_rtc_allocate_device(dev);
 399        if (IS_ERR(rx8010->rtc))
 400                return PTR_ERR(rx8010->rtc);
 401
 402        if (client->irq > 0) {
 403                dev_info(dev, "IRQ %d supplied\n", client->irq);
 404                err = devm_request_threaded_irq(dev, client->irq, NULL,
 405                                                rx8010_irq_1_handler,
 406                                                IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 407                                                "rx8010", client);
 408                if (err) {
 409                        dev_err(dev, "unable to request IRQ\n");
 410                        return err;
 411                }
 412
 413                rx8010->rtc->ops = &rx8010_rtc_ops_alarm;
 414        } else {
 415                rx8010->rtc->ops = &rx8010_rtc_ops_default;
 416        }
 417
 418        rx8010->rtc->max_user_freq = 1;
 419        rx8010->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
 420        rx8010->rtc->range_max = RTC_TIMESTAMP_END_2099;
 421
 422        return rtc_register_device(rx8010->rtc);
 423}
 424
 425static struct i2c_driver rx8010_driver = {
 426        .driver = {
 427                .name = "rtc-rx8010",
 428                .of_match_table = of_match_ptr(rx8010_of_match),
 429        },
 430        .probe_new      = rx8010_probe,
 431        .id_table       = rx8010_id,
 432};
 433
 434module_i2c_driver(rx8010_driver);
 435
 436MODULE_AUTHOR("Akshay Bhat <akshay.bhat@timesys.com>");
 437MODULE_DESCRIPTION("Epson RX8010SJ RTC driver");
 438MODULE_LICENSE("GPL v2");
 439