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