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         struct mutex *lock = &rx8025->rtc->ops_lock;
 146         int status;
 147
 148         mutex_lock(lock);
 149         status = rx8025_read_reg(client, RX8025_REG_CTRL2);
 150         if (status < 0)
 151                 goto out;
 152
 153         if (!(status & RX8025_BIT_CTRL2_XST))
 154                 dev_warn(&client->dev, "Oscillation stop was detected,"
 155                          "you may have to readjust the clock\n");
 156
 157         if (status & RX8025_BIT_CTRL2_CTFG) {
 158                 /* periodic */
 159                 status &= ~RX8025_BIT_CTRL2_CTFG;
 160                 rtc_update_irq(rx8025->rtc, 1, RTC_PF | RTC_IRQF);
 161         }
 162
 163         if (status & RX8025_BIT_CTRL2_DAFG) {
 164                 /* alarm */
 165                 status &= RX8025_BIT_CTRL2_DAFG;
 166                 if (rx8025_write_reg(client, RX8025_REG_CTRL1,
 167                                      rx8025->ctrl1 & ~RX8025_BIT_CTRL1_DALE))
 168                         goto out;
 169                 rtc_update_irq(rx8025->rtc, 1, RTC_AF | RTC_IRQF);
 170         }
 171
 172 out:
 173         mutex_unlock(lock);
 174
 175         return IRQ_HANDLED;
 176 }
 177
 178 static int rx8025_get_time(struct device *dev, struct rtc_time *dt)
 179 {
 180         struct i2c_client *client = to_i2c_client(dev);
 181         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 182         u8 date[7];
 183         int err;
 184
 185         err = rx8025_check_validity(dev);
 186         if (err)
 187                 return err;
 188
 189         err = rx8025_read_regs(client, RX8025_REG_SEC, 7, date);
 190         if (err)
 191                 return err;
 192
 193         dev_dbg(dev, "%s: read %7ph\n", __func__, date);
 194
 195         dt->tm_sec = bcd2bin(date[RX8025_REG_SEC] & 0x7f);
 196         dt->tm_min = bcd2bin(date[RX8025_REG_MIN] & 0x7f);
 197         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
 198                 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x3f);
 199         else
 200                 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x1f) % 12
 201                         + (date[RX8025_REG_HOUR] & 0x20 ? 12 : 0);
 202
 203         dt->tm_mday = bcd2bin(date[RX8025_REG_MDAY] & 0x3f);
 204         dt->tm_mon = bcd2bin(date[RX8025_REG_MONTH] & 0x1f) - 1;
 205         dt->tm_year = bcd2bin(date[RX8025_REG_YEAR]) + 100;
 206
 207         dev_dbg(dev, "%s: date %ptRr\n", __func__, dt);
 208
 209         return 0;
 210 }
 211
 212 static int rx8025_set_time(struct device *dev, struct rtc_time *dt)
 213 {
 214         struct i2c_client *client = to_i2c_client(dev);
 215         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 216         u8 date[7];
 217         int ret;
 218
 219         if ((dt->tm_year < 100) || (dt->tm_year > 199))
 220                 return -EINVAL;
 221
 222         /*
 223          * Here the read-only bits are written as "0".  I'm not sure if that
 224          * is sound.
 225          */
 226         date[RX8025_REG_SEC] = bin2bcd(dt->tm_sec);
 227         date[RX8025_REG_MIN] = bin2bcd(dt->tm_min);
 228         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
 229                 date[RX8025_REG_HOUR] = bin2bcd(dt->tm_hour);
 230         else
 231                 date[RX8025_REG_HOUR] = (dt->tm_hour >= 12 ? 0x20 : 0)
 232                         | bin2bcd((dt->tm_hour + 11) % 12 + 1);
 233
 234         date[RX8025_REG_WDAY] = bin2bcd(dt->tm_wday);
 235         date[RX8025_REG_MDAY] = bin2bcd(dt->tm_mday);
 236         date[RX8025_REG_MONTH] = bin2bcd(dt->tm_mon + 1);
 237         date[RX8025_REG_YEAR] = bin2bcd(dt->tm_year - 100);
 238
 239         dev_dbg(dev, "%s: write %7ph\n", __func__, date);
 240
 241         ret = rx8025_write_regs(client, RX8025_REG_SEC, 7, date);
 242         if (ret < 0)
 243                 return ret;
 244
 245         return rx8025_reset_validity(client);
 246 }
 247
 248 static int rx8025_init_client(struct i2c_client *client)
 249 {
 250         struct rx8025_data *rx8025 = i2c_get_clientdata(client);
 251         u8 ctrl[2], ctrl2;
 252         int need_clear = 0;
 253         int err;
 254
 255         err = rx8025_read_regs(client, RX8025_REG_CTRL1, 2, ctrl);
 256         if (err)
 257                 goto out;
 258
 259         /* Keep test bit zero ! */
 260         rx8025->ctrl1 = ctrl[0] & ~RX8025_BIT_CTRL1_TEST;
 261
 262         if (ctrl[1] & (RX8025_BIT_CTRL2_DAFG | RX8025_BIT_CTRL2_WAFG)) {
 263                 dev_warn(&client->dev, "Alarm was detected\n");
 264                 need_clear = 1;
 265         }
 266
 267         if (ctrl[1] & RX8025_BIT_CTRL2_CTFG)
 268                 need_clear = 1;
 269
 270         if (need_clear) {
 271                 ctrl2 = ctrl[1];
 272                 ctrl2 &= ~(RX8025_BIT_CTRL2_CTFG | RX8025_BIT_CTRL2_WAFG |
 273                            RX8025_BIT_CTRL2_DAFG);
 274
 275                 err = rx8025_write_reg(client, RX8025_REG_CTRL2, ctrl2);
 276         }
 277 out:
 278         return err;
 279 }
 280
 281 /* Alarm support */
 282 static int rx8025_read_alarm(struct device *dev, struct rtc_wkalrm *t)
 283 {
 284         struct i2c_client *client = to_i2c_client(dev);
 285         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 286         u8 ald[2];
 287         int ctrl2, err;
 288
 289         if (client->irq <= 0)
 290                 return -EINVAL;
 291
 292         err = rx8025_read_regs(client, RX8025_REG_ALDMIN, 2, ald);
 293         if (err)
 294                 return err;
 295
 296         ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2);
 297         if (ctrl2 < 0)
 298                 return ctrl2;
 299
 300         dev_dbg(dev, "%s: read alarm 0x%02x 0x%02x ctrl2 %02x\n",
 301                 __func__, ald[0], ald[1], ctrl2);
 302
 303         /* Hardware alarms precision is 1 minute! */
 304         t->time.tm_sec = 0;
 305         t->time.tm_min = bcd2bin(ald[0] & 0x7f);
 306         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
 307                 t->time.tm_hour = bcd2bin(ald[1] & 0x3f);
 308         else
 309                 t->time.tm_hour = bcd2bin(ald[1] & 0x1f) % 12
 310                         + (ald[1] & 0x20 ? 12 : 0);
 311
 312         dev_dbg(dev, "%s: date: %ptRr\n", __func__, &t->time);
 313         t->enabled = !!(rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE);
 314         t->pending = (ctrl2 & RX8025_BIT_CTRL2_DAFG) && t->enabled;
 315
 316         return err;
 317 }
 318
 319 static int rx8025_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 320 {
 321         struct i2c_client *client = to_i2c_client(dev);
 322         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 323         u8 ald[2];
 324         int err;
 325
 326         if (client->irq <= 0)
 327                 return -EINVAL;
 328
 329         /*
 330          * Hardware alarm precision is 1 minute!
 331          * round up to nearest minute
 332          */
 333         if (t->time.tm_sec) {
 334                 time64_t alarm_time = rtc_tm_to_time64(&t->time);
 335
 336                 alarm_time += 60 - t->time.tm_sec;
 337                 rtc_time64_to_tm(alarm_time, &t->time);
 338         }
 339
 340         ald[0] = bin2bcd(t->time.tm_min);
 341         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
 342                 ald[1] = bin2bcd(t->time.tm_hour);
 343         else
 344                 ald[1] = (t->time.tm_hour >= 12 ? 0x20 : 0)
 345                         | bin2bcd((t->time.tm_hour + 11) % 12 + 1);
 346
 347         dev_dbg(dev, "%s: write 0x%02x 0x%02x\n", __func__, ald[0], ald[1]);
 348
 349         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE) {
 350                 rx8025->ctrl1 &= ~RX8025_BIT_CTRL1_DALE;
 351                 err = rx8025_write_reg(client, RX8025_REG_CTRL1,
 352                                        rx8025->ctrl1);
 353                 if (err)
 354                         return err;
 355         }
 356         err = rx8025_write_regs(client, RX8025_REG_ALDMIN, 2, ald);
 357         if (err)
 358                 return err;
 359
 360         if (t->enabled) {
 361                 rx8025->ctrl1 |= RX8025_BIT_CTRL1_DALE;
 362                 err = rx8025_write_reg(client, RX8025_REG_CTRL1,
 363                                        rx8025->ctrl1);
 364                 if (err)
 365                         return err;
 366         }
 367
 368         return 0;
 369 }
 370
 371 static int rx8025_alarm_irq_enable(struct device *dev, unsigned int enabled)
 372 {
 373         struct i2c_client *client = to_i2c_client(dev);
 374         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 375         u8 ctrl1;
 376         int err;
 377
 378         ctrl1 = rx8025->ctrl1;
 379         if (enabled)
 380                 ctrl1 |= RX8025_BIT_CTRL1_DALE;
 381         else
 382                 ctrl1 &= ~RX8025_BIT_CTRL1_DALE;
 383
 384         if (ctrl1 != rx8025->ctrl1) {
 385                 rx8025->ctrl1 = ctrl1;
 386                 err = rx8025_write_reg(client, RX8025_REG_CTRL1,
 387                                        rx8025->ctrl1);
 388                 if (err)
 389                         return err;
 390         }
 391         return 0;
 392 }
 393
 394 static const struct rtc_class_ops rx8025_rtc_ops = {
 395         .read_time = rx8025_get_time,
 396         .set_time = rx8025_set_time,
 397         .read_alarm = rx8025_read_alarm,
 398         .set_alarm = rx8025_set_alarm,
 399         .alarm_irq_enable = rx8025_alarm_irq_enable,
 400 };
 401
 402 /*
 403  * Clock precision adjustment support
 404  *
 405  * According to the RX8025 SA/NB application manual the frequency and
 406  * temperature characteristics can be approximated using the following
 407  * equation:
 408  *
 409  *   df = a * (ut - t)**2
 410  *
 411  *   df: Frequency deviation in any temperature
 412  *   a : Coefficient = (-35 +-5) * 10**-9
 413  *   ut: Ultimate temperature in degree = +25 +-5 degree
 414  *   t : Any temperature in degree
 415  *
 416  * Note that the clock adjustment in ppb must be entered (which is
 417  * the negative value of the deviation).
 418  */
 419 static int rx8025_get_clock_adjust(struct device *dev, int *adj)
 420 {
 421         struct i2c_client *client = to_i2c_client(dev);
 422         int digoff;
 423
 424         digoff = rx8025_read_reg(client, RX8025_REG_DIGOFF);
 425         if (digoff < 0)
 426                 return digoff;
 427
 428         *adj = digoff >= 64 ? digoff - 128 : digoff;
 429         if (*adj > 0)
 430                 (*adj)--;
 431         *adj *= -RX8025_ADJ_RESOLUTION;
 432
 433         return 0;
 434 }
 435
 436 static int rx8025_set_clock_adjust(struct device *dev, int adj)
 437 {
 438         struct i2c_client *client = to_i2c_client(dev);
 439         u8 digoff;
 440         int err;
 441
 442         adj /= -RX8025_ADJ_RESOLUTION;
 443         if (adj > RX8025_ADJ_DATA_MAX)
 444                 adj = RX8025_ADJ_DATA_MAX;
 445         else if (adj < RX8025_ADJ_DATA_MIN)
 446                 adj = RX8025_ADJ_DATA_MIN;
 447         else if (adj > 0)
 448                 adj++;
 449         else if (adj < 0)
 450                 adj += 128;
 451         digoff = adj;
 452
 453         err = rx8025_write_reg(client, RX8025_REG_DIGOFF, digoff);
 454         if (err)
 455                 return err;
 456
 457         dev_dbg(dev, "%s: write 0x%02x\n", __func__, digoff);
 458
 459         return 0;
 460 }
 461
 462 static ssize_t rx8025_sysfs_show_clock_adjust(struct device *dev,
 463                                               struct device_attribute *attr,
 464                                               char *buf)
 465 {
 466         int err, adj;
 467
 468         err = rx8025_get_clock_adjust(dev, &adj);
 469         if (err)
 470                 return err;
 471
 472         return sprintf(buf, "%d\n", adj);
 473 }
 474
 475 static ssize_t rx8025_sysfs_store_clock_adjust(struct device *dev,
 476                                                struct device_attribute *attr,
 477                                                const char *buf, size_t count)
 478 {
 479         int adj, err;
 480
 481         if (sscanf(buf, "%i", &adj) != 1)
 482                 return -EINVAL;
 483
 484         err = rx8025_set_clock_adjust(dev, adj);
 485
 486         return err ? err : count;
 487 }
 488
 489 static DEVICE_ATTR(clock_adjust_ppb, S_IRUGO | S_IWUSR,
 490                    rx8025_sysfs_show_clock_adjust,
 491                    rx8025_sysfs_store_clock_adjust);
 492
 493 static int rx8025_sysfs_register(struct device *dev)
 494 {
 495         return device_create_file(dev, &dev_attr_clock_adjust_ppb);
 496 }
 497
 498 static void rx8025_sysfs_unregister(struct device *dev)
 499 {
 500         device_remove_file(dev, &dev_attr_clock_adjust_ppb);
 501 }
 502
 503 static int rx8025_probe(struct i2c_client *client,
 504                         const struct i2c_device_id *id)
 505 {
 506         struct i2c_adapter *adapter = client->adapter;
 507         struct rx8025_data *rx8025;
 508         int err = 0;
 509
 510         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
 511                                      | I2C_FUNC_SMBUS_I2C_BLOCK)) {
 512                 dev_err(&adapter->dev,
 513                         "doesn't support required functionality\n");
 514                 return -EIO;
 515         }
 516
 517         rx8025 = devm_kzalloc(&client->dev, sizeof(*rx8025), GFP_KERNEL);
 518         if (!rx8025)
 519                 return -ENOMEM;
 520
 521         i2c_set_clientdata(client, rx8025);
 522
 523         err = rx8025_init_client(client);
 524         if (err)
 525                 return err;
 526
 527         rx8025->rtc = devm_rtc_device_register(&client->dev, client->name,
 528                                           &rx8025_rtc_ops, THIS_MODULE);
 529         if (IS_ERR(rx8025->rtc)) {
 530                 dev_err(&client->dev, "unable to register the class device\n");
 531                 return PTR_ERR(rx8025->rtc);
 532         }
 533
 534         if (client->irq > 0) {
 535                 dev_info(&client->dev, "IRQ %d supplied\n", client->irq);
 536                 err = devm_request_threaded_irq(&client->dev, client->irq, NULL,
 537                                                 rx8025_handle_irq,
 538                                                 IRQF_ONESHOT,
 539                                                 "rx8025", client);
 540                 if (err) {
 541                         dev_err(&client->dev, "unable to request IRQ, alarms disabled\n");
 542                         client->irq = 0;
 543                 }
 544         }
 545
 546         rx8025->rtc->max_user_freq = 1;
 547
 548         /* the rx8025 alarm only supports a minute accuracy */
 549         rx8025->rtc->uie_unsupported = 1;
 550
 551         err = rx8025_sysfs_register(&client->dev);
 552         return err;
 553 }
 554
 555 static int rx8025_remove(struct i2c_client *client)
 556 {
 557         rx8025_sysfs_unregister(&client->dev);
 558         return 0;
 559 }
 560
 561 static struct i2c_driver rx8025_driver = {
 562         .driver = {
 563                 .name = "rtc-rx8025",
 564         },
 565         .probe          = rx8025_probe,
 566         .remove         = rx8025_remove,
 567         .id_table       = rx8025_id,
 568 };
 569
 570 module_i2c_driver(rx8025_driver);
 571
 572 MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
 573 MODULE_DESCRIPTION("RX-8025 SA/NB RTC driver");
 574 MODULE_LICENSE("GPL");