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 <[email protected]>
   6  *
   7  * Copyright (C) 2005 by Digi International Inc.
   8  * All rights reserved.
   9  *
  10  * Modified by fengjh at rising.com.cn
  11  * <[email protected]>
  12  * 2006.11
  13  *
  14  * Code cleanup by Sergei Poselenov, <[email protected]>
  15  * Converted to new style by Wolfgang Grandegger <[email protected]>
  16  * Alarm and periodic interrupt added by Dmitry Rakhchev <[email protected]>
  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 i2c_client *client;
  71         struct rtc_device *rtc;
  72         u8 ctrl1;
  73 };
  74
  75 static s32 rx8025_read_reg(const struct i2c_client *client, u8 number)
  76 {
  77         return i2c_smbus_read_byte_data(client, number << 4);
  78 }
  79
  80 static int rx8025_read_regs(const struct i2c_client *client,
  81                             u8 number, u8 length, u8 *values)
  82 {
  83         int ret = i2c_smbus_read_i2c_block_data(client, number << 4, length,
  84                                                 values);
  85         if (ret != length)
  86                 return ret < 0 ? ret : -EIO;
  87
  88         return 0;
  89 }
  90
  91 static s32 rx8025_write_reg(const struct i2c_client *client, u8 number,
  92                             u8 value)
  93 {
  94         return i2c_smbus_write_byte_data(client, number << 4, value);
  95 }
  96
  97 static s32 rx8025_write_regs(const struct i2c_client *client,
  98                              u8 number, u8 length, const u8 *values)
  99 {
 100         return i2c_smbus_write_i2c_block_data(client, number << 4,
 101                                               length, values);
 102 }
 103
 104 static int rx8025_check_validity(struct device *dev)
 105 {
 106         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 107         int ctrl2;
 108
 109         ctrl2 = rx8025_read_reg(rx8025->client, RX8025_REG_CTRL2);
 110         if (ctrl2 < 0)
 111                 return ctrl2;
 112
 113         if (ctrl2 & RX8025_BIT_CTRL2_VDET)
 114                 dev_warn(dev, "power voltage drop detected\n");
 115
 116         if (ctrl2 & RX8025_BIT_CTRL2_PON) {
 117                 dev_warn(dev, "power-on reset detected, date is invalid\n");
 118                 return -EINVAL;
 119         }
 120
 121         if (!(ctrl2 & RX8025_BIT_CTRL2_XST)) {
 122                 dev_warn(dev, "crystal stopped, date is invalid\n");
 123                 return -EINVAL;
 124         }
 125
 126         return 0;
 127 }
 128
 129 static int rx8025_reset_validity(struct i2c_client *client)
 130 {
 131         int ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2);
 132
 133         if (ctrl2 < 0)
 134                 return ctrl2;
 135
 136         ctrl2 &= ~(RX8025_BIT_CTRL2_PON | RX8025_BIT_CTRL2_VDET);
 137
 138         return rx8025_write_reg(client, RX8025_REG_CTRL2,
 139                                 ctrl2 | RX8025_BIT_CTRL2_XST);
 140 }
 141
 142 static irqreturn_t rx8025_handle_irq(int irq, void *dev_id)
 143 {
 144         struct i2c_client *client = dev_id;
 145         struct rx8025_data *rx8025 = i2c_get_clientdata(client);
 146         struct mutex *lock = &rx8025->rtc->ops_lock;
 147         int status;
 148
 149         mutex_lock(lock);
 150         status = rx8025_read_reg(client, RX8025_REG_CTRL2);
 151         if (status < 0)
 152                 goto out;
 153
 154         if (!(status & RX8025_BIT_CTRL2_XST))
 155                 dev_warn(&client->dev, "Oscillation stop was detected,"
 156                          "you may have to readjust the clock\n");
 157
 158         if (status & RX8025_BIT_CTRL2_CTFG) {
 159                 /* periodic */
 160                 status &= ~RX8025_BIT_CTRL2_CTFG;
 161                 rtc_update_irq(rx8025->rtc, 1, RTC_PF | RTC_IRQF);
 162         }
 163
 164         if (status & RX8025_BIT_CTRL2_DAFG) {
 165                 /* alarm */
 166                 status &= RX8025_BIT_CTRL2_DAFG;
 167                 if (rx8025_write_reg(client, RX8025_REG_CTRL1,
 168                                      rx8025->ctrl1 & ~RX8025_BIT_CTRL1_DALE))
 169                         goto out;
 170                 rtc_update_irq(rx8025->rtc, 1, RTC_AF | RTC_IRQF);
 171         }
 172
 173 out:
 174         mutex_unlock(lock);
 175
 176         return IRQ_HANDLED;
 177 }
 178
 179 static int rx8025_get_time(struct device *dev, struct rtc_time *dt)
 180 {
 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(rx8025->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 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(rx8025->client, RX8025_REG_SEC, 7, date);
 241         if (ret < 0)
 242                 return ret;
 243
 244         return rx8025_reset_validity(rx8025->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(rx8025->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 rx8025_data *rx8025 = dev_get_drvdata(dev);
 284         struct i2c_client *client = rx8025->client;
 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(rx8025->client, RX8025_REG_CTRL1,
 351                                        rx8025->ctrl1);
 352                 if (err)
 353                         return err;
 354         }
 355         err = rx8025_write_regs(rx8025->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(rx8025->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 rx8025_data *rx8025 = dev_get_drvdata(dev);
 373         u8 ctrl1;
 374         int err;
 375
 376         ctrl1 = rx8025->ctrl1;
 377         if (enabled)
 378                 ctrl1 |= RX8025_BIT_CTRL1_DALE;
 379         else
 380                 ctrl1 &= ~RX8025_BIT_CTRL1_DALE;
 381
 382         if (ctrl1 != rx8025->ctrl1) {
 383                 rx8025->ctrl1 = ctrl1;
 384                 err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1,
 385                                        rx8025->ctrl1);
 386                 if (err)
 387                         return err;
 388         }
 389         return 0;
 390 }
 391
 392 static const struct rtc_class_ops rx8025_rtc_ops = {
 393         .read_time = rx8025_get_time,
 394         .set_time = rx8025_set_time,
 395         .read_alarm = rx8025_read_alarm,
 396         .set_alarm = rx8025_set_alarm,
 397         .alarm_irq_enable = rx8025_alarm_irq_enable,
 398 };
 399
 400 /*
 401  * Clock precision adjustment support
 402  *
 403  * According to the RX8025 SA/NB application manual the frequency and
 404  * temperature characteristics can be approximated using the following
 405  * equation:
 406  *
 407  *   df = a * (ut - t)**2
 408  *
 409  *   df: Frequency deviation in any temperature
 410  *   a : Coefficient = (-35 +-5) * 10**-9
 411  *   ut: Ultimate temperature in degree = +25 +-5 degree
 412  *   t : Any temperature in degree
 413  *
 414  * Note that the clock adjustment in ppb must be entered (which is
 415  * the negative value of the deviation).
 416  */
 417 static int rx8025_get_clock_adjust(struct device *dev, int *adj)
 418 {
 419         struct i2c_client *client = to_i2c_client(dev);
 420         int digoff;
 421
 422         digoff = rx8025_read_reg(client, RX8025_REG_DIGOFF);
 423         if (digoff < 0)
 424                 return digoff;
 425
 426         *adj = digoff >= 64 ? digoff - 128 : digoff;
 427         if (*adj > 0)
 428                 (*adj)--;
 429         *adj *= -RX8025_ADJ_RESOLUTION;
 430
 431         return 0;
 432 }
 433
 434 static int rx8025_set_clock_adjust(struct device *dev, int adj)
 435 {
 436         struct i2c_client *client = to_i2c_client(dev);
 437         u8 digoff;
 438         int err;
 439
 440         adj /= -RX8025_ADJ_RESOLUTION;
 441         if (adj > RX8025_ADJ_DATA_MAX)
 442                 adj = RX8025_ADJ_DATA_MAX;
 443         else if (adj < RX8025_ADJ_DATA_MIN)
 444                 adj = RX8025_ADJ_DATA_MIN;
 445         else if (adj > 0)
 446                 adj++;
 447         else if (adj < 0)
 448                 adj += 128;
 449         digoff = adj;
 450
 451         err = rx8025_write_reg(client, RX8025_REG_DIGOFF, digoff);
 452         if (err)
 453                 return err;
 454
 455         dev_dbg(dev, "%s: write 0x%02x\n", __func__, digoff);
 456
 457         return 0;
 458 }
 459
 460 static ssize_t rx8025_sysfs_show_clock_adjust(struct device *dev,
 461                                               struct device_attribute *attr,
 462                                               char *buf)
 463 {
 464         int err, adj;
 465
 466         err = rx8025_get_clock_adjust(dev, &adj);
 467         if (err)
 468                 return err;
 469
 470         return sprintf(buf, "%d\n", adj);
 471 }
 472
 473 static ssize_t rx8025_sysfs_store_clock_adjust(struct device *dev,
 474                                                struct device_attribute *attr,
 475                                                const char *buf, size_t count)
 476 {
 477         int adj, err;
 478
 479         if (sscanf(buf, "%i", &adj) != 1)
 480                 return -EINVAL;
 481
 482         err = rx8025_set_clock_adjust(dev, adj);
 483
 484         return err ? err : count;
 485 }
 486
 487 static DEVICE_ATTR(clock_adjust_ppb, S_IRUGO | S_IWUSR,
 488                    rx8025_sysfs_show_clock_adjust,
 489                    rx8025_sysfs_store_clock_adjust);
 490
 491 static int rx8025_sysfs_register(struct device *dev)
 492 {
 493         return device_create_file(dev, &dev_attr_clock_adjust_ppb);
 494 }
 495
 496 static void rx8025_sysfs_unregister(struct device *dev)
 497 {
 498         device_remove_file(dev, &dev_attr_clock_adjust_ppb);
 499 }
 500
 501 static int rx8025_probe(struct i2c_client *client,
 502                         const struct i2c_device_id *id)
 503 {
 504         struct i2c_adapter *adapter = client->adapter;
 505         struct rx8025_data *rx8025;
 506         int err = 0;
 507
 508         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
 509                                      | I2C_FUNC_SMBUS_I2C_BLOCK)) {
 510                 dev_err(&adapter->dev,
 511                         "doesn't support required functionality\n");
 512                 return -EIO;
 513         }
 514
 515         rx8025 = devm_kzalloc(&client->dev, sizeof(*rx8025), GFP_KERNEL);
 516         if (!rx8025)
 517                 return -ENOMEM;
 518
 519         rx8025->client = client;
 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 <[email protected]>");
 572 MODULE_DESCRIPTION("RX-8025 SA/NB RTC driver");
 573 MODULE_LICENSE("GPL");