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