drivers/rtc/rtc-pcf8563.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * An I2C driver for the Philips PCF8563 RTC
   4  * Copyright 2005-06 Tower Technologies
   5  *
   6  * Author: Alessandro Zummo <a.zummo@towertech.it>
   7  * Maintainers: http://www.nslu2-linux.org/
   8  *
   9  * based on the other drivers in this same directory.
  10  *
  11  * https://www.nxp.com/docs/en/data-sheet/PCF8563.pdf
  12  */
  13
  14 #include <linux/bcd.h>
  15 #include <linux/clk-provider.h>
  16 #include <linux/err.h>
  17 #include <linux/i2c.h>
  18 #include <linux/module.h>
  19 #include <linux/of.h>
  20 #include <linux/regmap.h>
  21 #include <linux/rtc.h>
  22 #include <linux/slab.h>
  23
  24 #define PCF8563_REG_ST1         0x00 /* status */
  25 #define PCF8563_REG_ST2         0x01
  26 #define PCF8563_BIT_AIE         BIT(1)
  27 #define PCF8563_BIT_AF          BIT(3)
  28 #define PCF8563_BITS_ST2_N      (7 << 5)
  29
  30 #define PCF8563_REG_SC          0x02 /* datetime */
  31 #define PCF8563_REG_MN          0x03
  32 #define PCF8563_REG_HR          0x04
  33 #define PCF8563_REG_DM          0x05
  34 #define PCF8563_REG_DW          0x06
  35 #define PCF8563_REG_MO          0x07
  36 #define PCF8563_REG_YR          0x08
  37
  38 #define PCF8563_REG_AMN         0x09 /* alarm */
  39
  40 #define PCF8563_REG_CLKO                0x0D /* clock out */
  41 #define PCF8563_REG_CLKO_FE             0x80 /* clock out enabled */
  42 #define PCF8563_REG_CLKO_F_MASK         0x03 /* frequenc mask */
  43 #define PCF8563_REG_CLKO_F_32768HZ      0x00
  44 #define PCF8563_REG_CLKO_F_1024HZ       0x01
  45 #define PCF8563_REG_CLKO_F_32HZ         0x02
  46 #define PCF8563_REG_CLKO_F_1HZ          0x03
  47
  48 #define PCF8563_REG_TMRC        0x0E /* timer control */
  49 #define PCF8563_TMRC_ENABLE     BIT(7)
  50 #define PCF8563_TMRC_4096       0
  51 #define PCF8563_TMRC_64         1
  52 #define PCF8563_TMRC_1          2
  53 #define PCF8563_TMRC_1_60       3
  54 #define PCF8563_TMRC_MASK       3
  55
  56 #define PCF8563_REG_TMR         0x0F /* timer */
  57
  58 #define PCF8563_SC_LV           0x80 /* low voltage */
  59 #define PCF8563_MO_C            0x80 /* century */
  60
  61 static struct i2c_driver pcf8563_driver;
  62
  63 struct pcf8563 {
  64         struct rtc_device *rtc;
  65         /*
  66          * The meaning of MO_C bit varies by the chip type.
  67          * From PCF8563 datasheet: this bit is toggled when the years
  68          * register overflows from 99 to 00
  69          *   0 indicates the century is 20xx
  70          *   1 indicates the century is 19xx
  71          * From RTC8564 datasheet: this bit indicates change of
  72          * century. When the year digit data overflows from 99 to 00,
  73          * this bit is set. By presetting it to 0 while still in the
  74          * 20th century, it will be set in year 2000, ...
  75          * There seems no reliable way to know how the system use this
  76          * bit.  So let's do it heuristically, assuming we are live in
  77          * 1970...2069.
  78          */
  79         int c_polarity; /* 0: MO_C=1 means 19xx, otherwise MO_C=1 means 20xx */
  80
  81         struct regmap *regmap;
  82 #ifdef CONFIG_COMMON_CLK
  83         struct clk_hw           clkout_hw;
  84 #endif
  85 };
  86
  87 static int pcf8563_set_alarm_mode(struct pcf8563 *pcf8563, bool on)
  88 {
  89         u32 buf;
  90         int err;
  91
  92         err = regmap_read(pcf8563->regmap, PCF8563_REG_ST2, &buf);
  93         if (err < 0)
  94                 return err;
  95
  96         if (on)
  97                 buf |= PCF8563_BIT_AIE;
  98         else
  99                 buf &= ~PCF8563_BIT_AIE;
 100
 101         buf &= ~(PCF8563_BIT_AF | PCF8563_BITS_ST2_N);
 102
 103         return regmap_write(pcf8563->regmap, PCF8563_REG_ST2, buf);
 104 }
 105
 106 static int pcf8563_get_alarm_mode(struct pcf8563 *pcf8563, unsigned char *en,
 107                                   unsigned char *pen)
 108 {
 109         u32 buf;
 110         int err;
 111
 112         err = regmap_read(pcf8563->regmap, PCF8563_REG_ST2, &buf);
 113         if (err < 0)
 114                 return err;
 115
 116         if (en)
 117                 *en = !!(buf & PCF8563_BIT_AIE);
 118         if (pen)
 119                 *pen = !!(buf & PCF8563_BIT_AF);
 120
 121         return 0;
 122 }
 123
 124 static irqreturn_t pcf8563_irq(int irq, void *dev_id)
 125 {
 126         struct pcf8563 *pcf8563 = dev_id;
 127         char pending;
 128         int err;
 129
 130         err = pcf8563_get_alarm_mode(pcf8563, NULL, &pending);
 131         if (err)
 132                 return IRQ_NONE;
 133
 134         if (pending) {
 135                 rtc_update_irq(pcf8563->rtc, 1, RTC_IRQF | RTC_AF);
 136                 pcf8563_set_alarm_mode(pcf8563, 1);
 137                 return IRQ_HANDLED;
 138         }
 139
 140         return IRQ_NONE;
 141 }
 142
 143 /*
 144  * In the routines that deal directly with the pcf8563 hardware, we use
 145  * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
 146  */
 147 static int pcf8563_rtc_read_time(struct device *dev, struct rtc_time *tm)
 148 {
 149         struct pcf8563 *pcf8563 = dev_get_drvdata(dev);
 150         unsigned char buf[9];
 151         int err;
 152
 153         err = regmap_bulk_read(pcf8563->regmap, PCF8563_REG_ST1, buf,
 154                                sizeof(buf));
 155         if (err < 0)
 156                 return err;
 157
 158         if (buf[PCF8563_REG_SC] & PCF8563_SC_LV) {
 159                 dev_err(dev,
 160                         "low voltage detected, date/time is not reliable.\n");
 161                 return -EINVAL;
 162         }
 163
 164         dev_dbg(dev,
 165                 "%s: raw data is st1=%02x, st2=%02x, sec=%02x, min=%02x, hr=%02x, "
 166                 "mday=%02x, wday=%02x, mon=%02x, year=%02x\n",
 167                 __func__,
 168                 buf[0], buf[1], buf[2], buf[3],
 169                 buf[4], buf[5], buf[6], buf[7],
 170                 buf[8]);
 171
 172         tm->tm_sec = bcd2bin(buf[PCF8563_REG_SC] & 0x7F);
 173         tm->tm_min = bcd2bin(buf[PCF8563_REG_MN] & 0x7F);
 174         tm->tm_hour = bcd2bin(buf[PCF8563_REG_HR] & 0x3F); /* rtc hr 0-23 */
 175         tm->tm_mday = bcd2bin(buf[PCF8563_REG_DM] & 0x3F);
 176         tm->tm_wday = buf[PCF8563_REG_DW] & 0x07;
 177         tm->tm_mon = bcd2bin(buf[PCF8563_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */
 178         tm->tm_year = bcd2bin(buf[PCF8563_REG_YR]) + 100;
 179         /* detect the polarity heuristically. see note above. */
 180         pcf8563->c_polarity = (buf[PCF8563_REG_MO] & PCF8563_MO_C) ?
 181                 (tm->tm_year >= 100) : (tm->tm_year < 100);
 182
 183         dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
 184                 "mday=%d, mon=%d, year=%d, wday=%d\n",
 185                 __func__,
 186                 tm->tm_sec, tm->tm_min, tm->tm_hour,
 187                 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 188
 189         return 0;
 190 }
 191
 192 static int pcf8563_rtc_set_time(struct device *dev, struct rtc_time *tm)
 193 {
 194         struct pcf8563 *pcf8563 = dev_get_drvdata(dev);
 195         unsigned char buf[9];
 196
 197         dev_dbg(dev, "%s: secs=%d, mins=%d, hours=%d, "
 198                 "mday=%d, mon=%d, year=%d, wday=%d\n",
 199                 __func__,
 200                 tm->tm_sec, tm->tm_min, tm->tm_hour,
 201                 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 202
 203         /* hours, minutes and seconds */
 204         buf[PCF8563_REG_SC] = bin2bcd(tm->tm_sec);
 205         buf[PCF8563_REG_MN] = bin2bcd(tm->tm_min);
 206         buf[PCF8563_REG_HR] = bin2bcd(tm->tm_hour);
 207
 208         buf[PCF8563_REG_DM] = bin2bcd(tm->tm_mday);
 209
 210         /* month, 1 - 12 */
 211         buf[PCF8563_REG_MO] = bin2bcd(tm->tm_mon + 1);
 212
 213         /* year and century */
 214         buf[PCF8563_REG_YR] = bin2bcd(tm->tm_year - 100);
 215         if (pcf8563->c_polarity ? (tm->tm_year >= 100) : (tm->tm_year < 100))
 216                 buf[PCF8563_REG_MO] |= PCF8563_MO_C;
 217
 218         buf[PCF8563_REG_DW] = tm->tm_wday & 0x07;
 219
 220         return regmap_bulk_write(pcf8563->regmap, PCF8563_REG_SC,
 221                                 buf + PCF8563_REG_SC,
 222                                 sizeof(buf) - PCF8563_REG_SC);
 223 }
 224
 225 static int pcf8563_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 226 {
 227         struct pcf8563 *pcf8563 = dev_get_drvdata(dev);
 228         int ret;
 229
 230         switch (cmd) {
 231         case RTC_VL_READ:
 232                 ret = regmap_test_bits(pcf8563->regmap, PCF8563_REG_SC,
 233                                        PCF8563_SC_LV);
 234                 if (ret < 0)
 235                         return ret;
 236
 237                 return put_user(ret ? RTC_VL_DATA_INVALID : 0,
 238                                 (unsigned int __user *)arg);
 239         default:
 240                 return -ENOIOCTLCMD;
 241         }
 242 }
 243
 244 static int pcf8563_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *tm)
 245 {
 246         struct pcf8563 *pcf8563 = dev_get_drvdata(dev);
 247         unsigned char buf[4];
 248         int err;
 249
 250         err = regmap_bulk_read(pcf8563->regmap, PCF8563_REG_AMN, buf,
 251                                sizeof(buf));
 252         if (err < 0)
 253                 return err;
 254
 255         dev_dbg(dev,
 256                 "%s: raw data is min=%02x, hr=%02x, mday=%02x, wday=%02x\n",
 257                 __func__, buf[0], buf[1], buf[2], buf[3]);
 258
 259         tm->time.tm_sec = 0;
 260         tm->time.tm_min = bcd2bin(buf[0] & 0x7F);
 261         tm->time.tm_hour = bcd2bin(buf[1] & 0x3F);
 262         tm->time.tm_mday = bcd2bin(buf[2] & 0x3F);
 263         tm->time.tm_wday = bcd2bin(buf[3] & 0x7);
 264
 265         err = pcf8563_get_alarm_mode(pcf8563, &tm->enabled, &tm->pending);
 266         if (err < 0)
 267                 return err;
 268
 269         dev_dbg(dev, "%s: tm is mins=%d, hours=%d, mday=%d, wday=%d,"
 270                 " enabled=%d, pending=%d\n", __func__, tm->time.tm_min,
 271                 tm->time.tm_hour, tm->time.tm_mday, tm->time.tm_wday,
 272                 tm->enabled, tm->pending);
 273
 274         return 0;
 275 }
 276
 277 static int pcf8563_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *tm)
 278 {
 279         struct pcf8563 *pcf8563 = dev_get_drvdata(dev);
 280         unsigned char buf[4];
 281         int err;
 282
 283         buf[0] = bin2bcd(tm->time.tm_min);
 284         buf[1] = bin2bcd(tm->time.tm_hour);
 285         buf[2] = bin2bcd(tm->time.tm_mday);
 286         buf[3] = tm->time.tm_wday & 0x07;
 287
 288         err = regmap_bulk_write(pcf8563->regmap, PCF8563_REG_SC, buf,
 289                                 sizeof(buf));
 290         if (err)
 291                 return err;
 292
 293         return pcf8563_set_alarm_mode(pcf8563, !!tm->enabled);
 294 }
 295
 296 static int pcf8563_irq_enable(struct device *dev, unsigned int enabled)
 297 {
 298         struct pcf8563 *pcf8563 = dev_get_drvdata(dev);
 299
 300         dev_dbg(dev, "%s: en=%d\n", __func__, enabled);
 301         return pcf8563_set_alarm_mode(pcf8563, !!enabled);
 302 }
 303
 304 #ifdef CONFIG_COMMON_CLK
 305 /*
 306  * Handling of the clkout
 307  */
 308
 309 #define clkout_hw_to_pcf8563(_hw) container_of(_hw, struct pcf8563, clkout_hw)
 310
 311 static const int clkout_rates[] = {
 312         32768,
 313         1024,
 314         32,
 315         1,
 316 };
 317
 318 static unsigned long pcf8563_clkout_recalc_rate(struct clk_hw *hw,
 319                                                 unsigned long parent_rate)
 320 {
 321         struct pcf8563 *pcf8563 = clkout_hw_to_pcf8563(hw);
 322         u32 buf;
 323         int ret;
 324
 325         ret = regmap_read(pcf8563->regmap, PCF8563_REG_CLKO, &buf);
 326         if (ret < 0)
 327                 return 0;
 328
 329         buf &= PCF8563_REG_CLKO_F_MASK;
 330         return clkout_rates[buf];
 331 }
 332
 333 static long pcf8563_clkout_round_rate(struct clk_hw *hw, unsigned long rate,
 334                                       unsigned long *prate)
 335 {
 336         int i;
 337
 338         for (i = 0; i < ARRAY_SIZE(clkout_rates); i++)
 339                 if (clkout_rates[i] <= rate)
 340                         return clkout_rates[i];
 341
 342         return 0;
 343 }
 344
 345 static int pcf8563_clkout_set_rate(struct clk_hw *hw, unsigned long rate,
 346                                    unsigned long parent_rate)
 347 {
 348         struct pcf8563 *pcf8563 = clkout_hw_to_pcf8563(hw);
 349         int i, ret;
 350         u32 buf;
 351
 352         ret = regmap_read(pcf8563->regmap, PCF8563_REG_CLKO, &buf);
 353         if (ret < 0)
 354                 return ret;
 355
 356         for (i = 0; i < ARRAY_SIZE(clkout_rates); i++)
 357                 if (clkout_rates[i] == rate) {
 358                         buf &= ~PCF8563_REG_CLKO_F_MASK;
 359                         buf |= i;
 360                         return regmap_update_bits(pcf8563->regmap,
 361                                             PCF8563_REG_CLKO,
 362                                             PCF8563_REG_CLKO_F_MASK,
 363                                             buf);
 364                 }
 365
 366         return -EINVAL;
 367 }
 368
 369 static int pcf8563_clkout_control(struct clk_hw *hw, bool enable)
 370 {
 371         struct pcf8563 *pcf8563 = clkout_hw_to_pcf8563(hw);
 372         u32 buf;
 373         int ret;
 374
 375         ret = regmap_read(pcf8563->regmap, PCF8563_REG_CLKO, &buf);
 376         if (ret < 0)
 377                 return ret;
 378
 379         if (enable)
 380                 buf |= PCF8563_REG_CLKO_FE;
 381         else
 382                 buf &= ~PCF8563_REG_CLKO_FE;
 383
 384         return regmap_update_bits(pcf8563->regmap, PCF8563_REG_CLKO,
 385                                   PCF8563_REG_CLKO_FE, buf);
 386 }
 387
 388 static int pcf8563_clkout_prepare(struct clk_hw *hw)
 389 {
 390         return pcf8563_clkout_control(hw, 1);
 391 }
 392
 393 static void pcf8563_clkout_unprepare(struct clk_hw *hw)
 394 {
 395         pcf8563_clkout_control(hw, 0);
 396 }
 397
 398 static int pcf8563_clkout_is_prepared(struct clk_hw *hw)
 399 {
 400         struct pcf8563 *pcf8563 = clkout_hw_to_pcf8563(hw);
 401         u32 buf;
 402         int ret;
 403
 404         ret = regmap_read(pcf8563->regmap, PCF8563_REG_CLKO, &buf);
 405         if (ret < 0)
 406                 return ret;
 407
 408         return !!(buf & PCF8563_REG_CLKO_FE);
 409 }
 410
 411 static const struct clk_ops pcf8563_clkout_ops = {
 412         .prepare = pcf8563_clkout_prepare,
 413         .unprepare = pcf8563_clkout_unprepare,
 414         .is_prepared = pcf8563_clkout_is_prepared,
 415         .recalc_rate = pcf8563_clkout_recalc_rate,
 416         .round_rate = pcf8563_clkout_round_rate,
 417         .set_rate = pcf8563_clkout_set_rate,
 418 };
 419
 420 static struct clk *pcf8563_clkout_register_clk(struct pcf8563 *pcf8563)
 421 {
 422         struct device_node *node = pcf8563->rtc->dev.of_node;
 423         struct clk_init_data init;
 424         struct clk *clk;
 425         int ret;
 426
 427         /* disable the clkout output */
 428         ret = regmap_clear_bits(pcf8563->regmap, PCF8563_REG_CLKO,
 429                                 PCF8563_REG_CLKO_FE);
 430         if (ret < 0)
 431                 return ERR_PTR(ret);
 432
 433         init.name = "pcf8563-clkout";
 434         init.ops = &pcf8563_clkout_ops;
 435         init.flags = 0;
 436         init.parent_names = NULL;
 437         init.num_parents = 0;
 438         pcf8563->clkout_hw.init = &init;
 439
 440         /* optional override of the clockname */
 441         of_property_read_string(node, "clock-output-names", &init.name);
 442
 443         /* register the clock */
 444         clk = devm_clk_register(&pcf8563->rtc->dev, &pcf8563->clkout_hw);
 445
 446         if (!IS_ERR(clk))
 447                 of_clk_add_provider(node, of_clk_src_simple_get, clk);
 448
 449         return clk;
 450 }
 451 #endif
 452
 453 static const struct rtc_class_ops pcf8563_rtc_ops = {
 454         .ioctl          = pcf8563_rtc_ioctl,
 455         .read_time      = pcf8563_rtc_read_time,
 456         .set_time       = pcf8563_rtc_set_time,
 457         .read_alarm     = pcf8563_rtc_read_alarm,
 458         .set_alarm      = pcf8563_rtc_set_alarm,
 459         .alarm_irq_enable = pcf8563_irq_enable,
 460 };
 461
 462 static const struct regmap_config regmap_config = {
 463         .reg_bits = 8,
 464         .val_bits = 8,
 465         .max_register = 0xF,
 466 };
 467
 468 static int pcf8563_probe(struct i2c_client *client)
 469 {
 470         struct pcf8563 *pcf8563;
 471         int err;
 472
 473         dev_dbg(&client->dev, "%s\n", __func__);
 474
 475         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 476                 return -ENODEV;
 477
 478         pcf8563 = devm_kzalloc(&client->dev, sizeof(struct pcf8563),
 479                                 GFP_KERNEL);
 480         if (!pcf8563)
 481                 return -ENOMEM;
 482
 483         pcf8563->regmap = devm_regmap_init_i2c(client, &regmap_config);
 484         if (IS_ERR(pcf8563->regmap))
 485                 return PTR_ERR(pcf8563->regmap);
 486
 487         i2c_set_clientdata(client, pcf8563);
 488         device_set_wakeup_capable(&client->dev, 1);
 489
 490         /* Set timer to lowest frequency to save power (ref Haoyu datasheet) */
 491         err = regmap_set_bits(pcf8563->regmap, PCF8563_REG_TMRC,
 492                               PCF8563_TMRC_1_60);
 493         if (err < 0) {
 494                 dev_err(&client->dev, "%s: write error\n", __func__);
 495                 return err;
 496         }
 497
 498         /* Clear flags and disable interrupts */
 499         err = regmap_write(pcf8563->regmap, PCF8563_REG_ST2, 0);
 500         if (err < 0) {
 501                 dev_err(&client->dev, "%s: write error\n", __func__);
 502                 return err;
 503         }
 504
 505         pcf8563->rtc = devm_rtc_allocate_device(&client->dev);
 506         if (IS_ERR(pcf8563->rtc))
 507                 return PTR_ERR(pcf8563->rtc);
 508
 509         pcf8563->rtc->ops = &pcf8563_rtc_ops;
 510         /* the pcf8563 alarm only supports a minute accuracy */
 511         set_bit(RTC_FEATURE_ALARM_RES_MINUTE, pcf8563->rtc->features);
 512         clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, pcf8563->rtc->features);
 513         clear_bit(RTC_FEATURE_ALARM, pcf8563->rtc->features);
 514         pcf8563->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
 515         pcf8563->rtc->range_max = RTC_TIMESTAMP_END_2099;
 516         pcf8563->rtc->set_start_time = true;
 517
 518         if (client->irq > 0) {
 519                 unsigned long irqflags = IRQF_TRIGGER_LOW;
 520
 521                 if (dev_fwnode(&client->dev))
 522                         irqflags = 0;
 523
 524                 err = devm_request_threaded_irq(&client->dev, client->irq,
 525                                 NULL, pcf8563_irq,
 526                                 IRQF_SHARED | IRQF_ONESHOT | irqflags,
 527                                 pcf8563_driver.driver.name, client);
 528                 if (err) {
 529                         dev_err(&client->dev, "unable to request IRQ %d\n",
 530                                                                 client->irq);
 531                         return err;
 532                 }
 533         } else {
 534                 client->irq = 0;
 535         }
 536
 537         if (client->irq > 0 || device_property_read_bool(&client->dev, "wakeup-source")) {
 538                 device_init_wakeup(&client->dev, true);
 539                 set_bit(RTC_FEATURE_ALARM, pcf8563->rtc->features);
 540         }
 541
 542         err = devm_rtc_register_device(pcf8563->rtc);
 543         if (err)
 544                 return err;
 545
 546 #ifdef CONFIG_COMMON_CLK
 547         /* register clk in common clk framework */
 548         pcf8563_clkout_register_clk(pcf8563);
 549 #endif
 550
 551         return 0;
 552 }
 553
 554 static const struct i2c_device_id pcf8563_id[] = {
 555         { "pcf8563" },
 556         { "rtc8564" },
 557         { "pca8565" },
 558         { }
 559 };
 560 MODULE_DEVICE_TABLE(i2c, pcf8563_id);
 561
 562 #ifdef CONFIG_OF
 563 static const struct of_device_id pcf8563_of_match[] = {
 564         { .compatible = "nxp,pcf8563" },
 565         { .compatible = "epson,rtc8564" },
 566         { .compatible = "microcrystal,rv8564" },
 567         { .compatible = "nxp,pca8565" },
 568         {}
 569 };
 570 MODULE_DEVICE_TABLE(of, pcf8563_of_match);
 571 #endif
 572
 573 static struct i2c_driver pcf8563_driver = {
 574         .driver         = {
 575                 .name   = "rtc-pcf8563",
 576                 .of_match_table = of_match_ptr(pcf8563_of_match),
 577         },
 578         .probe          = pcf8563_probe,
 579         .id_table       = pcf8563_id,
 580 };
 581
 582 module_i2c_driver(pcf8563_driver);
 583
 584 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
 585 MODULE_DESCRIPTION("Philips PCF8563/Epson RTC8564 RTC driver");
 586 MODULE_LICENSE("GPL");