drivers/rtc/rtc-rx8025.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for Epson's RTC module RX-8025 SA/NB
   4  *
   5  * Copyright (C) 2009 Wolfgang Grandegger <wg@grandegger.com>
   6  *
   7  * Copyright (C) 2005 by Digi International Inc.
   8  * All rights reserved.
   9  *
  10  * Modified by fengjh at rising.com.cn
  11  * <lm-sensors@lm-sensors.org>
  12  * 2006.11
  13  *
  14  * Code cleanup by Sergei Poselenov, <sposelenov@emcraft.com>
  15  * Converted to new style by Wolfgang Grandegger <wg@grandegger.com>
  16  * Alarm and periodic interrupt added by Dmitry Rakhchev <rda@emcraft.com>
  17  */
  18 #include <linux/bcd.h>
  19 #include <linux/bitops.h>
  20 #include <linux/i2c.h>
  21 #include <linux/kernel.h>
  22 #include <linux/module.h>
  23 #include <linux/rtc.h>
  24
  25 /* Register definitions */
  26 #define RX8025_REG_SEC          0x00
  27 #define RX8025_REG_MIN          0x01
  28 #define RX8025_REG_HOUR         0x02
  29 #define RX8025_REG_WDAY         0x03
  30 #define RX8025_REG_MDAY         0x04
  31 #define RX8025_REG_MONTH        0x05
  32 #define RX8025_REG_YEAR         0x06
  33 #define RX8025_REG_DIGOFF       0x07
  34 #define RX8025_REG_ALWMIN       0x08
  35 #define RX8025_REG_ALWHOUR      0x09
  36 #define RX8025_REG_ALWWDAY      0x0a
  37 #define RX8025_REG_ALDMIN       0x0b
  38 #define RX8025_REG_ALDHOUR      0x0c
  39 /* 0x0d is reserved */
  40 #define RX8025_REG_CTRL1        0x0e
  41 #define RX8025_REG_CTRL2        0x0f
  42
  43 #define RX8025_BIT_CTRL1_CT     (7 << 0)
  44 /* 1 Hz periodic level irq */
  45 #define RX8025_BIT_CTRL1_CT_1HZ 4
  46 #define RX8025_BIT_CTRL1_TEST   BIT(3)
  47 #define RX8025_BIT_CTRL1_1224   BIT(5)
  48 #define RX8025_BIT_CTRL1_DALE   BIT(6)
  49 #define RX8025_BIT_CTRL1_WALE   BIT(7)
  50
  51 #define RX8025_BIT_CTRL2_DAFG   BIT(0)
  52 #define RX8025_BIT_CTRL2_WAFG   BIT(1)
  53 #define RX8025_BIT_CTRL2_CTFG   BIT(2)
  54 #define RX8025_BIT_CTRL2_PON    BIT(4)
  55 #define RX8025_BIT_CTRL2_XST    BIT(5)
  56 #define RX8025_BIT_CTRL2_VDET   BIT(6)
  57
  58 /* Clock precision adjustment */
  59 #define RX8025_ADJ_RESOLUTION   3050 /* in ppb */
  60 #define RX8025_ADJ_DATA_MAX     62
  61 #define RX8025_ADJ_DATA_MIN     -62
  62
  63 static const struct i2c_device_id rx8025_id[] = {
  64         { "rx8025", 0 },
  65         { }
  66 };
  67 MODULE_DEVICE_TABLE(i2c, rx8025_id);
  68
  69 struct rx8025_data {
  70         struct rtc_device *rtc;
  71         u8 ctrl1;
  72 };
  73
  74 static s32 rx8025_read_reg(const struct i2c_client *client, u8 number)
  75 {
  76         return i2c_smbus_read_byte_data(client, number << 4);
  77 }
  78
  79 static int rx8025_read_regs(const struct i2c_client *client,
  80                             u8 number, u8 length, u8 *values)
  81 {
  82         int ret = i2c_smbus_read_i2c_block_data(client, number << 4, length,
  83                                                 values);
  84         if (ret != length)
  85                 return ret < 0 ? ret : -EIO;
  86
  87         return 0;
  88 }
  89
  90 static s32 rx8025_write_reg(const struct i2c_client *client, u8 number,
  91                             u8 value)
  92 {
  93         return i2c_smbus_write_byte_data(client, number << 4, value);
  94 }
  95
  96 static s32 rx8025_write_regs(const struct i2c_client *client,
  97                              u8 number, u8 length, const u8 *values)
  98 {
  99         return i2c_smbus_write_i2c_block_data(client, number << 4,
 100                                               length, values);
 101 }
 102
 103 static int rx8025_check_validity(struct device *dev)
 104 {
 105         struct i2c_client *client = to_i2c_client(dev);
 106         int ctrl2;
 107
 108         ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2);
 109         if (ctrl2 < 0)
 110                 return ctrl2;
 111
 112         if (ctrl2 & RX8025_BIT_CTRL2_VDET)
 113                 dev_warn(dev, "power voltage drop detected\n");
 114
 115         if (ctrl2 & RX8025_BIT_CTRL2_PON) {
 116                 dev_warn(dev, "power-on reset detected, date is invalid\n");
 117                 return -EINVAL;
 118         }
 119
 120         if (!(ctrl2 & RX8025_BIT_CTRL2_XST)) {
 121                 dev_warn(dev, "crystal stopped, date is invalid\n");
 122                 return -EINVAL;
 123         }
 124
 125         return 0;
 126 }
 127
 128 static int rx8025_reset_validity(struct i2c_client *client)
 129 {
 130         int ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2);
 131
 132         if (ctrl2 < 0)
 133                 return ctrl2;
 134
 135         ctrl2 &= ~(RX8025_BIT_CTRL2_PON | RX8025_BIT_CTRL2_VDET);
 136
 137         return rx8025_write_reg(client, RX8025_REG_CTRL2,
 138                                 ctrl2 | RX8025_BIT_CTRL2_XST);
 139 }
 140
 141 static irqreturn_t rx8025_handle_irq(int irq, void *dev_id)
 142 {
 143         struct i2c_client *client = dev_id;
 144         struct rx8025_data *rx8025 = i2c_get_clientdata(client);
 145         int status;
 146
 147         rtc_lock(rx8025->rtc);
 148         status = rx8025_read_reg(client, RX8025_REG_CTRL2);
 149         if (status < 0)
 150                 goto out;
 151
 152         if (!(status & RX8025_BIT_CTRL2_XST))
 153                 dev_warn(&client->dev, "Oscillation stop was detected,"
 154                          "you may have to readjust the clock\n");
 155
 156         if (status & RX8025_BIT_CTRL2_CTFG) {
 157                 /* periodic */
 158                 status &= ~RX8025_BIT_CTRL2_CTFG;
 159                 rtc_update_irq(rx8025->rtc, 1, RTC_PF | RTC_IRQF);
 160         }
 161
 162         if (status & RX8025_BIT_CTRL2_DAFG) {
 163                 /* alarm */
 164                 status &= RX8025_BIT_CTRL2_DAFG;
 165                 if (rx8025_write_reg(client, RX8025_REG_CTRL1,
 166                                      rx8025->ctrl1 & ~RX8025_BIT_CTRL1_DALE))
 167                         goto out;
 168                 rtc_update_irq(rx8025->rtc, 1, RTC_AF | RTC_IRQF);
 169         }
 170
 171 out:
 172         rtc_unlock(rx8025->rtc);
 173
 174         return IRQ_HANDLED;
 175 }
 176
 177 static int rx8025_get_time(struct device *dev, struct rtc_time *dt)
 178 {
 179         struct i2c_client *client = to_i2c_client(dev);
 180         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 181         u8 date[7];
 182         int err;
 183
 184         err = rx8025_check_validity(dev);
 185         if (err)
 186                 return err;
 187
 188         err = rx8025_read_regs(client, RX8025_REG_SEC, 7, date);
 189         if (err)
 190                 return err;
 191
 192         dev_dbg(dev, "%s: read %7ph\n", __func__, date);
 193
 194         dt->tm_sec = bcd2bin(date[RX8025_REG_SEC] & 0x7f);
 195         dt->tm_min = bcd2bin(date[RX8025_REG_MIN] & 0x7f);
 196         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
 197                 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x3f);
 198         else
 199                 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x1f) % 12
 200                         + (date[RX8025_REG_HOUR] & 0x20 ? 12 : 0);
 201
 202         dt->tm_mday = bcd2bin(date[RX8025_REG_MDAY] & 0x3f);
 203         dt->tm_mon = bcd2bin(date[RX8025_REG_MONTH] & 0x1f) - 1;
 204         dt->tm_year = bcd2bin(date[RX8025_REG_YEAR]) + 100;
 205
 206         dev_dbg(dev, "%s: date %ptRr\n", __func__, dt);
 207
 208         return 0;
 209 }
 210
 211 static int rx8025_set_time(struct device *dev, struct rtc_time *dt)
 212 {
 213         struct i2c_client *client = to_i2c_client(dev);
 214         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 215         u8 date[7];
 216         int ret;
 217
 218         if ((dt->tm_year < 100) || (dt->tm_year > 199))
 219                 return -EINVAL;
 220
 221         /*
 222          * Here the read-only bits are written as "0".  I'm not sure if that
 223          * is sound.
 224          */
 225         date[RX8025_REG_SEC] = bin2bcd(dt->tm_sec);
 226         date[RX8025_REG_MIN] = bin2bcd(dt->tm_min);
 227         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
 228                 date[RX8025_REG_HOUR] = bin2bcd(dt->tm_hour);
 229         else
 230                 date[RX8025_REG_HOUR] = (dt->tm_hour >= 12 ? 0x20 : 0)
 231                         | bin2bcd((dt->tm_hour + 11) % 12 + 1);
 232
 233         date[RX8025_REG_WDAY] = bin2bcd(dt->tm_wday);
 234         date[RX8025_REG_MDAY] = bin2bcd(dt->tm_mday);
 235         date[RX8025_REG_MONTH] = bin2bcd(dt->tm_mon + 1);
 236         date[RX8025_REG_YEAR] = bin2bcd(dt->tm_year - 100);
 237
 238         dev_dbg(dev, "%s: write %7ph\n", __func__, date);
 239
 240         ret = rx8025_write_regs(client, RX8025_REG_SEC, 7, date);
 241         if (ret < 0)
 242                 return ret;
 243
 244         return rx8025_reset_validity(client);
 245 }
 246
 247 static int rx8025_init_client(struct i2c_client *client)
 248 {
 249         struct rx8025_data *rx8025 = i2c_get_clientdata(client);
 250         u8 ctrl[2], ctrl2;
 251         int need_clear = 0;
 252         int err;
 253
 254         err = rx8025_read_regs(client, RX8025_REG_CTRL1, 2, ctrl);
 255         if (err)
 256                 goto out;
 257
 258         /* Keep test bit zero ! */
 259         rx8025->ctrl1 = ctrl[0] & ~RX8025_BIT_CTRL1_TEST;
 260
 261         if (ctrl[1] & (RX8025_BIT_CTRL2_DAFG | RX8025_BIT_CTRL2_WAFG)) {
 262                 dev_warn(&client->dev, "Alarm was detected\n");
 263                 need_clear = 1;
 264         }
 265
 266         if (ctrl[1] & RX8025_BIT_CTRL2_CTFG)
 267                 need_clear = 1;
 268
 269         if (need_clear) {
 270                 ctrl2 = ctrl[1];
 271                 ctrl2 &= ~(RX8025_BIT_CTRL2_CTFG | RX8025_BIT_CTRL2_WAFG |
 272                            RX8025_BIT_CTRL2_DAFG);
 273
 274                 err = rx8025_write_reg(client, RX8025_REG_CTRL2, ctrl2);
 275         }
 276 out:
 277         return err;
 278 }
 279
 280 /* Alarm support */
 281 static int rx8025_read_alarm(struct device *dev, struct rtc_wkalrm *t)
 282 {
 283         struct i2c_client *client = to_i2c_client(dev);
 284         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 285         u8 ald[2];
 286         int ctrl2, err;
 287
 288         if (client->irq <= 0)
 289                 return -EINVAL;
 290
 291         err = rx8025_read_regs(client, RX8025_REG_ALDMIN, 2, ald);
 292         if (err)
 293                 return err;
 294
 295         ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2);
 296         if (ctrl2 < 0)
 297                 return ctrl2;
 298
 299         dev_dbg(dev, "%s: read alarm 0x%02x 0x%02x ctrl2 %02x\n",
 300                 __func__, ald[0], ald[1], ctrl2);
 301
 302         /* Hardware alarms precision is 1 minute! */
 303         t->time.tm_sec = 0;
 304         t->time.tm_min = bcd2bin(ald[0] & 0x7f);
 305         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
 306                 t->time.tm_hour = bcd2bin(ald[1] & 0x3f);
 307         else
 308                 t->time.tm_hour = bcd2bin(ald[1] & 0x1f) % 12
 309                         + (ald[1] & 0x20 ? 12 : 0);
 310
 311         dev_dbg(dev, "%s: date: %ptRr\n", __func__, &t->time);
 312         t->enabled = !!(rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE);
 313         t->pending = (ctrl2 & RX8025_BIT_CTRL2_DAFG) && t->enabled;
 314
 315         return err;
 316 }
 317
 318 static int rx8025_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 319 {
 320         struct i2c_client *client = to_i2c_client(dev);
 321         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 322         u8 ald[2];
 323         int err;
 324
 325         if (client->irq <= 0)
 326                 return -EINVAL;
 327
 328         /*
 329          * Hardware alarm precision is 1 minute!
 330          * round up to nearest minute
 331          */
 332         if (t->time.tm_sec) {
 333                 time64_t alarm_time = rtc_tm_to_time64(&t->time);
 334
 335                 alarm_time += 60 - t->time.tm_sec;
 336                 rtc_time64_to_tm(alarm_time, &t->time);
 337         }
 338
 339         ald[0] = bin2bcd(t->time.tm_min);
 340         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
 341                 ald[1] = bin2bcd(t->time.tm_hour);
 342         else
 343                 ald[1] = (t->time.tm_hour >= 12 ? 0x20 : 0)
 344                         | bin2bcd((t->time.tm_hour + 11) % 12 + 1);
 345
 346         dev_dbg(dev, "%s: write 0x%02x 0x%02x\n", __func__, ald[0], ald[1]);
 347
 348         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE) {
 349                 rx8025->ctrl1 &= ~RX8025_BIT_CTRL1_DALE;
 350                 err = rx8025_write_reg(client, RX8025_REG_CTRL1,
 351                                        rx8025->ctrl1);
 352                 if (err)
 353                         return err;
 354         }
 355         err = rx8025_write_regs(client, RX8025_REG_ALDMIN, 2, ald);
 356         if (err)
 357                 return err;
 358
 359         if (t->enabled) {
 360                 rx8025->ctrl1 |= RX8025_BIT_CTRL1_DALE;
 361                 err = rx8025_write_reg(client, RX8025_REG_CTRL1,
 362                                        rx8025->ctrl1);
 363                 if (err)
 364                         return err;
 365         }
 366
 367         return 0;
 368 }
 369
 370 static int rx8025_alarm_irq_enable(struct device *dev, unsigned int enabled)
 371 {
 372         struct i2c_client *client = to_i2c_client(dev);
 373         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 374         u8 ctrl1;
 375         int err;
 376
 377         ctrl1 = rx8025->ctrl1;
 378         if (enabled)
 379                 ctrl1 |= RX8025_BIT_CTRL1_DALE;
 380         else
 381                 ctrl1 &= ~RX8025_BIT_CTRL1_DALE;
 382
 383         if (ctrl1 != rx8025->ctrl1) {
 384                 rx8025->ctrl1 = ctrl1;
 385                 err = rx8025_write_reg(client, RX8025_REG_CTRL1,
 386                                        rx8025->ctrl1);
 387                 if (err)
 388                         return err;
 389         }
 390         return 0;
 391 }
 392
 393 static const struct rtc_class_ops rx8025_rtc_ops = {
 394         .read_time = rx8025_get_time,
 395         .set_time = rx8025_set_time,
 396         .read_alarm = rx8025_read_alarm,
 397         .set_alarm = rx8025_set_alarm,
 398         .alarm_irq_enable = rx8025_alarm_irq_enable,
 399 };
 400
 401 /*
 402  * Clock precision adjustment support
 403  *
 404  * According to the RX8025 SA/NB application manual the frequency and
 405  * temperature characteristics can be approximated using the following
 406  * equation:
 407  *
 408  *   df = a * (ut - t)**2
 409  *
 410  *   df: Frequency deviation in any temperature
 411  *   a : Coefficient = (-35 +-5) * 10**-9
 412  *   ut: Ultimate temperature in degree = +25 +-5 degree
 413  *   t : Any temperature in degree
 414  *
 415  * Note that the clock adjustment in ppb must be entered (which is
 416  * the negative value of the deviation).
 417  */
 418 static int rx8025_get_clock_adjust(struct device *dev, int *adj)
 419 {
 420         struct i2c_client *client = to_i2c_client(dev);
 421         int digoff;
 422
 423         digoff = rx8025_read_reg(client, RX8025_REG_DIGOFF);
 424         if (digoff < 0)
 425                 return digoff;
 426
 427         *adj = digoff >= 64 ? digoff - 128 : digoff;
 428         if (*adj > 0)
 429                 (*adj)--;
 430         *adj *= -RX8025_ADJ_RESOLUTION;
 431
 432         return 0;
 433 }
 434
 435 static int rx8025_set_clock_adjust(struct device *dev, int adj)
 436 {
 437         struct i2c_client *client = to_i2c_client(dev);
 438         u8 digoff;
 439         int err;
 440
 441         adj /= -RX8025_ADJ_RESOLUTION;
 442         if (adj > RX8025_ADJ_DATA_MAX)
 443                 adj = RX8025_ADJ_DATA_MAX;
 444         else if (adj < RX8025_ADJ_DATA_MIN)
 445                 adj = RX8025_ADJ_DATA_MIN;
 446         else if (adj > 0)
 447                 adj++;
 448         else if (adj < 0)
 449                 adj += 128;
 450         digoff = adj;
 451
 452         err = rx8025_write_reg(client, RX8025_REG_DIGOFF, digoff);
 453         if (err)
 454                 return err;
 455
 456         dev_dbg(dev, "%s: write 0x%02x\n", __func__, digoff);
 457
 458         return 0;
 459 }
 460
 461 static ssize_t rx8025_sysfs_show_clock_adjust(struct device *dev,
 462                                               struct device_attribute *attr,
 463                                               char *buf)
 464 {
 465         int err, adj;
 466
 467         err = rx8025_get_clock_adjust(dev, &adj);
 468         if (err)
 469                 return err;
 470
 471         return sprintf(buf, "%d\n", adj);
 472 }
 473
 474 static ssize_t rx8025_sysfs_store_clock_adjust(struct device *dev,
 475                                                struct device_attribute *attr,
 476                                                const char *buf, size_t count)
 477 {
 478         int adj, err;
 479
 480         if (sscanf(buf, "%i", &adj) != 1)
 481                 return -EINVAL;
 482
 483         err = rx8025_set_clock_adjust(dev, adj);
 484
 485         return err ? err : count;
 486 }
 487
 488 static DEVICE_ATTR(clock_adjust_ppb, S_IRUGO | S_IWUSR,
 489                    rx8025_sysfs_show_clock_adjust,
 490                    rx8025_sysfs_store_clock_adjust);
 491
 492 static int rx8025_sysfs_register(struct device *dev)
 493 {
 494         return device_create_file(dev, &dev_attr_clock_adjust_ppb);
 495 }
 496
 497 static void rx8025_sysfs_unregister(struct device *dev)
 498 {
 499         device_remove_file(dev, &dev_attr_clock_adjust_ppb);
 500 }
 501
 502 static int rx8025_probe(struct i2c_client *client,
 503                         const struct i2c_device_id *id)
 504 {
 505         struct i2c_adapter *adapter = client->adapter;
 506         struct rx8025_data *rx8025;
 507         int err = 0;
 508
 509         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
 510                                      | I2C_FUNC_SMBUS_I2C_BLOCK)) {
 511                 dev_err(&adapter->dev,
 512                         "doesn't support required functionality\n");
 513                 return -EIO;
 514         }
 515
 516         rx8025 = devm_kzalloc(&client->dev, sizeof(*rx8025), GFP_KERNEL);
 517         if (!rx8025)
 518                 return -ENOMEM;
 519
 520         i2c_set_clientdata(client, rx8025);
 521
 522         err = rx8025_init_client(client);
 523         if (err)
 524                 return err;
 525
 526         rx8025->rtc = devm_rtc_device_register(&client->dev, client->name,
 527                                           &rx8025_rtc_ops, THIS_MODULE);
 528         if (IS_ERR(rx8025->rtc)) {
 529                 dev_err(&client->dev, "unable to register the class device\n");
 530                 return PTR_ERR(rx8025->rtc);
 531         }
 532
 533         if (client->irq > 0) {
 534                 dev_info(&client->dev, "IRQ %d supplied\n", client->irq);
 535                 err = devm_request_threaded_irq(&client->dev, client->irq, NULL,
 536                                                 rx8025_handle_irq,
 537                                                 IRQF_ONESHOT,
 538                                                 "rx8025", client);
 539                 if (err) {
 540                         dev_err(&client->dev, "unable to request IRQ, alarms disabled\n");
 541                         client->irq = 0;
 542                 }
 543         }
 544
 545         rx8025->rtc->max_user_freq = 1;
 546
 547         /* the rx8025 alarm only supports a minute accuracy */
 548         rx8025->rtc->uie_unsupported = 1;
 549
 550         err = rx8025_sysfs_register(&client->dev);
 551         return err;
 552 }
 553
 554 static int rx8025_remove(struct i2c_client *client)
 555 {
 556         rx8025_sysfs_unregister(&client->dev);
 557         return 0;
 558 }
 559
 560 static struct i2c_driver rx8025_driver = {
 561         .driver = {
 562                 .name = "rtc-rx8025",
 563         },
 564         .probe          = rx8025_probe,
 565         .remove         = rx8025_remove,
 566         .id_table       = rx8025_id,
 567 };
 568
 569 module_i2c_driver(rx8025_driver);
 570
 571 MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
 572 MODULE_DESCRIPTION("RX-8025 SA/NB RTC driver");
 573 MODULE_LICENSE("GPL");