drivers/rtc/rtc-nct3018y.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (c) 2022 Nuvoton Technology Corporation
   3
   4 #include <linux/bcd.h>
   5 #include <linux/clk-provider.h>
   6 #include <linux/err.h>
   7 #include <linux/i2c.h>
   8 #include <linux/module.h>
   9 #include <linux/of.h>
  10 #include <linux/rtc.h>
  11 #include <linux/slab.h>
  12
  13 #define NCT3018Y_REG_SC         0x00 /* seconds */
  14 #define NCT3018Y_REG_SCA        0x01 /* alarm */
  15 #define NCT3018Y_REG_MN         0x02
  16 #define NCT3018Y_REG_MNA        0x03 /* alarm */
  17 #define NCT3018Y_REG_HR         0x04
  18 #define NCT3018Y_REG_HRA        0x05 /* alarm */
  19 #define NCT3018Y_REG_DW         0x06
  20 #define NCT3018Y_REG_DM         0x07
  21 #define NCT3018Y_REG_MO         0x08
  22 #define NCT3018Y_REG_YR         0x09
  23 #define NCT3018Y_REG_CTRL       0x0A /* timer control */
  24 #define NCT3018Y_REG_ST         0x0B /* status */
  25 #define NCT3018Y_REG_CLKO       0x0C /* clock out */
  26 #define NCT3018Y_REG_PART       0x21 /* part info */
  27
  28 #define NCT3018Y_BIT_AF         BIT(7)
  29 #define NCT3018Y_BIT_ST         BIT(7)
  30 #define NCT3018Y_BIT_DM         BIT(6)
  31 #define NCT3018Y_BIT_HF         BIT(5)
  32 #define NCT3018Y_BIT_DSM        BIT(4)
  33 #define NCT3018Y_BIT_AIE        BIT(3)
  34 #define NCT3018Y_BIT_OFIE       BIT(2)
  35 #define NCT3018Y_BIT_CIE        BIT(1)
  36 #define NCT3018Y_BIT_TWO        BIT(0)
  37
  38 #define NCT3018Y_REG_BAT_MASK           0x07
  39 #define NCT3018Y_REG_CLKO_F_MASK        0x03 /* frequenc mask */
  40 #define NCT3018Y_REG_CLKO_CKE           0x80 /* clock out enabled */
  41 #define NCT3018Y_REG_PART_NCT3018Y      0x02
  42
  43 struct nct3018y {
  44         struct rtc_device *rtc;
  45         struct i2c_client *client;
  46         int part_num;
  47 #ifdef CONFIG_COMMON_CLK
  48         struct clk_hw clkout_hw;
  49 #endif
  50 };
  51
  52 static int nct3018y_set_alarm_mode(struct i2c_client *client, bool on)
  53 {
  54         int err, flags;
  55
  56         dev_dbg(&client->dev, "%s:on:%d\n", __func__, on);
  57
  58         flags =  i2c_smbus_read_byte_data(client, NCT3018Y_REG_CTRL);
  59         if (flags < 0) {
  60                 dev_dbg(&client->dev,
  61                         "Failed to read NCT3018Y_REG_CTRL\n");
  62                 return flags;
  63         }
  64
  65         if (on)
  66                 flags |= NCT3018Y_BIT_AIE;
  67         else
  68                 flags &= ~NCT3018Y_BIT_AIE;
  69
  70         flags |= NCT3018Y_BIT_CIE;
  71         err = i2c_smbus_write_byte_data(client, NCT3018Y_REG_CTRL, flags);
  72         if (err < 0) {
  73                 dev_dbg(&client->dev, "Unable to write NCT3018Y_REG_CTRL\n");
  74                 return err;
  75         }
  76
  77         flags =  i2c_smbus_read_byte_data(client, NCT3018Y_REG_ST);
  78         if (flags < 0) {
  79                 dev_dbg(&client->dev,
  80                         "Failed to read NCT3018Y_REG_ST\n");
  81                 return flags;
  82         }
  83
  84         flags &= ~(NCT3018Y_BIT_AF);
  85         err = i2c_smbus_write_byte_data(client, NCT3018Y_REG_ST, flags);
  86         if (err < 0) {
  87                 dev_dbg(&client->dev, "Unable to write NCT3018Y_REG_ST\n");
  88                 return err;
  89         }
  90
  91         return 0;
  92 }
  93
  94 static int nct3018y_get_alarm_mode(struct i2c_client *client, unsigned char *alarm_enable,
  95                                    unsigned char *alarm_flag)
  96 {
  97         int flags;
  98
  99         if (alarm_enable) {
 100                 dev_dbg(&client->dev, "%s:NCT3018Y_REG_CTRL\n", __func__);
 101                 flags =  i2c_smbus_read_byte_data(client, NCT3018Y_REG_CTRL);
 102                 if (flags < 0)
 103                         return flags;
 104                 *alarm_enable = flags & NCT3018Y_BIT_AIE;
 105                 dev_dbg(&client->dev, "%s:alarm_enable:%x\n", __func__, *alarm_enable);
 106
 107         }
 108
 109         if (alarm_flag) {
 110                 dev_dbg(&client->dev, "%s:NCT3018Y_REG_ST\n", __func__);
 111                 flags =  i2c_smbus_read_byte_data(client, NCT3018Y_REG_ST);
 112                 if (flags < 0)
 113                         return flags;
 114                 *alarm_flag = flags & NCT3018Y_BIT_AF;
 115                 dev_dbg(&client->dev, "%s:alarm_flag:%x\n", __func__, *alarm_flag);
 116         }
 117
 118         return 0;
 119 }
 120
 121 static irqreturn_t nct3018y_irq(int irq, void *dev_id)
 122 {
 123         struct nct3018y *nct3018y = i2c_get_clientdata(dev_id);
 124         struct i2c_client *client = nct3018y->client;
 125         int err;
 126         unsigned char alarm_flag;
 127         unsigned char alarm_enable;
 128
 129         dev_dbg(&client->dev, "%s:irq:%d\n", __func__, irq);
 130         err = nct3018y_get_alarm_mode(nct3018y->client, &alarm_enable, &alarm_flag);
 131         if (err)
 132                 return IRQ_NONE;
 133
 134         if (alarm_flag) {
 135                 dev_dbg(&client->dev, "%s:alarm flag:%x\n",
 136                         __func__, alarm_flag);
 137                 rtc_update_irq(nct3018y->rtc, 1, RTC_IRQF | RTC_AF);
 138                 nct3018y_set_alarm_mode(nct3018y->client, 0);
 139                 dev_dbg(&client->dev, "%s:IRQ_HANDLED\n", __func__);
 140                 return IRQ_HANDLED;
 141         }
 142
 143         return IRQ_NONE;
 144 }
 145
 146 /*
 147  * In the routines that deal directly with the nct3018y hardware, we use
 148  * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
 149  */
 150 static int nct3018y_rtc_read_time(struct device *dev, struct rtc_time *tm)
 151 {
 152         struct i2c_client *client = to_i2c_client(dev);
 153         unsigned char buf[10];
 154         int err;
 155
 156         err = i2c_smbus_read_i2c_block_data(client, NCT3018Y_REG_ST, 1, buf);
 157         if (err < 0)
 158                 return err;
 159
 160         if (!buf[0]) {
 161                 dev_dbg(&client->dev, " voltage <=1.7, date/time is not reliable.\n");
 162                 return -EINVAL;
 163         }
 164
 165         err = i2c_smbus_read_i2c_block_data(client, NCT3018Y_REG_SC, sizeof(buf), buf);
 166         if (err < 0)
 167                 return err;
 168
 169         tm->tm_sec = bcd2bin(buf[0] & 0x7F);
 170         tm->tm_min = bcd2bin(buf[2] & 0x7F);
 171         tm->tm_hour = bcd2bin(buf[4] & 0x3F);
 172         tm->tm_wday = buf[6] & 0x07;
 173         tm->tm_mday = bcd2bin(buf[7] & 0x3F);
 174         tm->tm_mon = bcd2bin(buf[8] & 0x1F) - 1;
 175         tm->tm_year = bcd2bin(buf[9]) + 100;
 176
 177         return 0;
 178 }
 179
 180 static int nct3018y_rtc_set_time(struct device *dev, struct rtc_time *tm)
 181 {
 182         struct i2c_client *client = to_i2c_client(dev);
 183         struct nct3018y *nct3018y = dev_get_drvdata(dev);
 184         unsigned char buf[4] = {0};
 185         int err, flags;
 186         int restore_flags = 0;
 187
 188         flags = i2c_smbus_read_byte_data(client, NCT3018Y_REG_CTRL);
 189         if (flags < 0) {
 190                 dev_dbg(&client->dev, "Failed to read NCT3018Y_REG_CTRL.\n");
 191                 return flags;
 192         }
 193
 194         /* Check and set TWO bit */
 195         if (nct3018y->part_num == NCT3018Y_REG_PART_NCT3018Y && !(flags & NCT3018Y_BIT_TWO)) {
 196                 restore_flags = 1;
 197                 flags |= NCT3018Y_BIT_TWO;
 198                 err = i2c_smbus_write_byte_data(client, NCT3018Y_REG_CTRL, flags);
 199                 if (err < 0) {
 200                         dev_dbg(&client->dev, "Unable to write NCT3018Y_REG_CTRL.\n");
 201                         return err;
 202                 }
 203         }
 204
 205         buf[0] = bin2bcd(tm->tm_sec);
 206         err = i2c_smbus_write_byte_data(client, NCT3018Y_REG_SC, buf[0]);
 207         if (err < 0) {
 208                 dev_dbg(&client->dev, "Unable to write NCT3018Y_REG_SC\n");
 209                 return err;
 210         }
 211
 212         buf[0] = bin2bcd(tm->tm_min);
 213         err = i2c_smbus_write_byte_data(client, NCT3018Y_REG_MN, buf[0]);
 214         if (err < 0) {
 215                 dev_dbg(&client->dev, "Unable to write NCT3018Y_REG_MN\n");
 216                 return err;
 217         }
 218
 219         buf[0] = bin2bcd(tm->tm_hour);
 220         err = i2c_smbus_write_byte_data(client, NCT3018Y_REG_HR, buf[0]);
 221         if (err < 0) {
 222                 dev_dbg(&client->dev, "Unable to write NCT3018Y_REG_HR\n");
 223                 return err;
 224         }
 225
 226         buf[0] = tm->tm_wday & 0x07;
 227         buf[1] = bin2bcd(tm->tm_mday);
 228         buf[2] = bin2bcd(tm->tm_mon + 1);
 229         buf[3] = bin2bcd(tm->tm_year - 100);
 230         err = i2c_smbus_write_i2c_block_data(client, NCT3018Y_REG_DW,
 231                                              sizeof(buf), buf);
 232         if (err < 0) {
 233                 dev_dbg(&client->dev, "Unable to write for day and mon and year\n");
 234                 return -EIO;
 235         }
 236
 237         /* Restore TWO bit */
 238         if (restore_flags) {
 239                 if (nct3018y->part_num == NCT3018Y_REG_PART_NCT3018Y)
 240                         flags &= ~NCT3018Y_BIT_TWO;
 241
 242                 err = i2c_smbus_write_byte_data(client, NCT3018Y_REG_CTRL, flags);
 243                 if (err < 0) {
 244                         dev_dbg(&client->dev, "Unable to write NCT3018Y_REG_CTRL.\n");
 245                         return err;
 246                 }
 247         }
 248
 249         return err;
 250 }
 251
 252 static int nct3018y_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *tm)
 253 {
 254         struct i2c_client *client = to_i2c_client(dev);
 255         unsigned char buf[5];
 256         int err;
 257
 258         err = i2c_smbus_read_i2c_block_data(client, NCT3018Y_REG_SCA,
 259                                             sizeof(buf), buf);
 260         if (err < 0) {
 261                 dev_dbg(&client->dev, "Unable to read date\n");
 262                 return -EIO;
 263         }
 264
 265         dev_dbg(&client->dev, "%s: raw data is sec=%02x, min=%02x hr=%02x\n",
 266                 __func__, buf[0], buf[2], buf[4]);
 267
 268         tm->time.tm_sec = bcd2bin(buf[0] & 0x7F);
 269         tm->time.tm_min = bcd2bin(buf[2] & 0x7F);
 270         tm->time.tm_hour = bcd2bin(buf[4] & 0x3F);
 271
 272         err = nct3018y_get_alarm_mode(client, &tm->enabled, &tm->pending);
 273         if (err < 0)
 274                 return err;
 275
 276         dev_dbg(&client->dev, "%s:s=%d m=%d, hr=%d, enabled=%d, pending=%d\n",
 277                 __func__, tm->time.tm_sec, tm->time.tm_min,
 278                 tm->time.tm_hour, tm->enabled, tm->pending);
 279
 280         return 0;
 281 }
 282
 283 static int nct3018y_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *tm)
 284 {
 285         struct i2c_client *client = to_i2c_client(dev);
 286         int err;
 287
 288         dev_dbg(dev, "%s, sec=%d, min=%d hour=%d tm->enabled:%d\n",
 289                 __func__, tm->time.tm_sec, tm->time.tm_min, tm->time.tm_hour,
 290                 tm->enabled);
 291
 292         err = i2c_smbus_write_byte_data(client, NCT3018Y_REG_SCA, bin2bcd(tm->time.tm_sec));
 293         if (err < 0) {
 294                 dev_dbg(&client->dev, "Unable to write NCT3018Y_REG_SCA\n");
 295                 return err;
 296         }
 297
 298         err = i2c_smbus_write_byte_data(client, NCT3018Y_REG_MNA, bin2bcd(tm->time.tm_min));
 299         if (err < 0) {
 300                 dev_dbg(&client->dev, "Unable to write NCT3018Y_REG_MNA\n");
 301                 return err;
 302         }
 303
 304         err = i2c_smbus_write_byte_data(client, NCT3018Y_REG_HRA, bin2bcd(tm->time.tm_hour));
 305         if (err < 0) {
 306                 dev_dbg(&client->dev, "Unable to write NCT3018Y_REG_HRA\n");
 307                 return err;
 308         }
 309
 310         return nct3018y_set_alarm_mode(client, tm->enabled);
 311 }
 312
 313 static int nct3018y_irq_enable(struct device *dev, unsigned int enabled)
 314 {
 315         dev_dbg(dev, "%s: alarm enable=%d\n", __func__, enabled);
 316
 317         return nct3018y_set_alarm_mode(to_i2c_client(dev), enabled);
 318 }
 319
 320 static int nct3018y_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
 321 {
 322         struct i2c_client *client = to_i2c_client(dev);
 323         int status, flags = 0;
 324
 325         switch (cmd) {
 326         case RTC_VL_READ:
 327                 status = i2c_smbus_read_byte_data(client, NCT3018Y_REG_ST);
 328                 if (status < 0)
 329                         return status;
 330
 331                 if (!(status & NCT3018Y_REG_BAT_MASK))
 332                         flags |= RTC_VL_DATA_INVALID;
 333
 334                 return put_user(flags, (unsigned int __user *)arg);
 335
 336         default:
 337                 return -ENOIOCTLCMD;
 338         }
 339 }
 340
 341 #ifdef CONFIG_COMMON_CLK
 342 /*
 343  * Handling of the clkout
 344  */
 345
 346 #define clkout_hw_to_nct3018y(_hw) container_of(_hw, struct nct3018y, clkout_hw)
 347
 348 static const int clkout_rates[] = {
 349         32768,
 350         1024,
 351         32,
 352         1,
 353 };
 354
 355 static unsigned long nct3018y_clkout_recalc_rate(struct clk_hw *hw,
 356                                                  unsigned long parent_rate)
 357 {
 358         struct nct3018y *nct3018y = clkout_hw_to_nct3018y(hw);
 359         struct i2c_client *client = nct3018y->client;
 360         int flags;
 361
 362         flags = i2c_smbus_read_byte_data(client, NCT3018Y_REG_CLKO);
 363         if (flags < 0)
 364                 return 0;
 365
 366         flags &= NCT3018Y_REG_CLKO_F_MASK;
 367         return clkout_rates[flags];
 368 }
 369
 370 static long nct3018y_clkout_round_rate(struct clk_hw *hw, unsigned long rate,
 371                                        unsigned long *prate)
 372 {
 373         int i;
 374
 375         for (i = 0; i < ARRAY_SIZE(clkout_rates); i++)
 376                 if (clkout_rates[i] <= rate)
 377                         return clkout_rates[i];
 378
 379         return 0;
 380 }
 381
 382 static int nct3018y_clkout_set_rate(struct clk_hw *hw, unsigned long rate,
 383                                     unsigned long parent_rate)
 384 {
 385         struct nct3018y *nct3018y = clkout_hw_to_nct3018y(hw);
 386         struct i2c_client *client = nct3018y->client;
 387         int i, flags;
 388
 389         flags = i2c_smbus_read_byte_data(client, NCT3018Y_REG_CLKO);
 390         if (flags < 0)
 391                 return flags;
 392
 393         for (i = 0; i < ARRAY_SIZE(clkout_rates); i++)
 394                 if (clkout_rates[i] == rate) {
 395                         flags &= ~NCT3018Y_REG_CLKO_F_MASK;
 396                         flags |= i;
 397                         return i2c_smbus_write_byte_data(client, NCT3018Y_REG_CLKO, flags);
 398                 }
 399
 400         return -EINVAL;
 401 }
 402
 403 static int nct3018y_clkout_control(struct clk_hw *hw, bool enable)
 404 {
 405         struct nct3018y *nct3018y = clkout_hw_to_nct3018y(hw);
 406         struct i2c_client *client = nct3018y->client;
 407         int flags;
 408
 409         flags = i2c_smbus_read_byte_data(client, NCT3018Y_REG_CLKO);
 410         if (flags < 0)
 411                 return flags;
 412
 413         if (enable)
 414                 flags |= NCT3018Y_REG_CLKO_CKE;
 415         else
 416                 flags &= ~NCT3018Y_REG_CLKO_CKE;
 417
 418         return i2c_smbus_write_byte_data(client, NCT3018Y_REG_CLKO, flags);
 419 }
 420
 421 static int nct3018y_clkout_prepare(struct clk_hw *hw)
 422 {
 423         return nct3018y_clkout_control(hw, 1);
 424 }
 425
 426 static void nct3018y_clkout_unprepare(struct clk_hw *hw)
 427 {
 428         nct3018y_clkout_control(hw, 0);
 429 }
 430
 431 static int nct3018y_clkout_is_prepared(struct clk_hw *hw)
 432 {
 433         struct nct3018y *nct3018y = clkout_hw_to_nct3018y(hw);
 434         struct i2c_client *client = nct3018y->client;
 435         int flags;
 436
 437         flags = i2c_smbus_read_byte_data(client, NCT3018Y_REG_CLKO);
 438         if (flags < 0)
 439                 return flags;
 440
 441         return flags & NCT3018Y_REG_CLKO_CKE;
 442 }
 443
 444 static const struct clk_ops nct3018y_clkout_ops = {
 445         .prepare = nct3018y_clkout_prepare,
 446         .unprepare = nct3018y_clkout_unprepare,
 447         .is_prepared = nct3018y_clkout_is_prepared,
 448         .recalc_rate = nct3018y_clkout_recalc_rate,
 449         .round_rate = nct3018y_clkout_round_rate,
 450         .set_rate = nct3018y_clkout_set_rate,
 451 };
 452
 453 static struct clk *nct3018y_clkout_register_clk(struct nct3018y *nct3018y)
 454 {
 455         struct i2c_client *client = nct3018y->client;
 456         struct device_node *node = client->dev.of_node;
 457         struct clk *clk;
 458         struct clk_init_data init;
 459
 460         init.name = "nct3018y-clkout";
 461         init.ops = &nct3018y_clkout_ops;
 462         init.flags = 0;
 463         init.parent_names = NULL;
 464         init.num_parents = 0;
 465         nct3018y->clkout_hw.init = &init;
 466
 467         /* optional override of the clockname */
 468         of_property_read_string(node, "clock-output-names", &init.name);
 469
 470         /* register the clock */
 471         clk = devm_clk_register(&client->dev, &nct3018y->clkout_hw);
 472
 473         if (!IS_ERR(clk))
 474                 of_clk_add_provider(node, of_clk_src_simple_get, clk);
 475
 476         return clk;
 477 }
 478 #endif
 479
 480 static const struct rtc_class_ops nct3018y_rtc_ops = {
 481         .read_time      = nct3018y_rtc_read_time,
 482         .set_time       = nct3018y_rtc_set_time,
 483         .read_alarm     = nct3018y_rtc_read_alarm,
 484         .set_alarm      = nct3018y_rtc_set_alarm,
 485         .alarm_irq_enable = nct3018y_irq_enable,
 486         .ioctl          = nct3018y_ioctl,
 487 };
 488
 489 static int nct3018y_probe(struct i2c_client *client)
 490 {
 491         struct nct3018y *nct3018y;
 492         int err, flags;
 493
 494         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
 495                                      I2C_FUNC_SMBUS_BYTE |
 496                                      I2C_FUNC_SMBUS_BLOCK_DATA))
 497                 return -ENODEV;
 498
 499         nct3018y = devm_kzalloc(&client->dev, sizeof(struct nct3018y),
 500                                 GFP_KERNEL);
 501         if (!nct3018y)
 502                 return -ENOMEM;
 503
 504         i2c_set_clientdata(client, nct3018y);
 505         nct3018y->client = client;
 506         device_set_wakeup_capable(&client->dev, 1);
 507
 508         flags = i2c_smbus_read_byte_data(client, NCT3018Y_REG_CTRL);
 509         if (flags < 0) {
 510                 dev_dbg(&client->dev, "%s: read error\n", __func__);
 511                 return flags;
 512         } else if (flags & NCT3018Y_BIT_TWO) {
 513                 dev_dbg(&client->dev, "%s: NCT3018Y_BIT_TWO is set\n", __func__);
 514         }
 515
 516         nct3018y->part_num = i2c_smbus_read_byte_data(client, NCT3018Y_REG_PART);
 517         if (nct3018y->part_num < 0) {
 518                 dev_dbg(&client->dev, "Failed to read NCT3018Y_REG_PART.\n");
 519                 return nct3018y->part_num;
 520         } else if (nct3018y->part_num == NCT3018Y_REG_PART_NCT3018Y) {
 521                 flags = NCT3018Y_BIT_HF;
 522                 err = i2c_smbus_write_byte_data(client, NCT3018Y_REG_CTRL, flags);
 523                 if (err < 0) {
 524                         dev_dbg(&client->dev, "Unable to write NCT3018Y_REG_CTRL.\n");
 525                         return err;
 526                 }
 527         }
 528
 529         flags = 0;
 530         err = i2c_smbus_write_byte_data(client, NCT3018Y_REG_ST, flags);
 531         if (err < 0) {
 532                 dev_dbg(&client->dev, "%s: write error\n", __func__);
 533                 return err;
 534         }
 535
 536         nct3018y->rtc = devm_rtc_allocate_device(&client->dev);
 537         if (IS_ERR(nct3018y->rtc))
 538                 return PTR_ERR(nct3018y->rtc);
 539
 540         nct3018y->rtc->ops = &nct3018y_rtc_ops;
 541         nct3018y->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
 542         nct3018y->rtc->range_max = RTC_TIMESTAMP_END_2099;
 543
 544         if (client->irq > 0) {
 545                 err = devm_request_threaded_irq(&client->dev, client->irq,
 546                                                 NULL, nct3018y_irq,
 547                                                 IRQF_ONESHOT | IRQF_TRIGGER_FALLING,
 548                                                 "nct3018y", client);
 549                 if (err) {
 550                         dev_dbg(&client->dev, "unable to request IRQ %d\n", client->irq);
 551                         return err;
 552                 }
 553         } else {
 554                 clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, nct3018y->rtc->features);
 555                 clear_bit(RTC_FEATURE_ALARM, nct3018y->rtc->features);
 556         }
 557
 558 #ifdef CONFIG_COMMON_CLK
 559         /* register clk in common clk framework */
 560         nct3018y_clkout_register_clk(nct3018y);
 561 #endif
 562
 563         return devm_rtc_register_device(nct3018y->rtc);
 564 }
 565
 566 static const struct i2c_device_id nct3018y_id[] = {
 567         { "nct3018y", 0 },
 568         { }
 569 };
 570 MODULE_DEVICE_TABLE(i2c, nct3018y_id);
 571
 572 static const struct of_device_id nct3018y_of_match[] = {
 573         { .compatible = "nuvoton,nct3018y" },
 574         {}
 575 };
 576 MODULE_DEVICE_TABLE(of, nct3018y_of_match);
 577
 578 static struct i2c_driver nct3018y_driver = {
 579         .driver         = {
 580                 .name   = "rtc-nct3018y",
 581                 .of_match_table = nct3018y_of_match,
 582         },
 583         .probe          = nct3018y_probe,
 584         .id_table       = nct3018y_id,
 585 };
 586
 587 module_i2c_driver(nct3018y_driver);
 588
 589 MODULE_AUTHOR("Medad CChien <ctcchien@nuvoton.com>");
 590 MODULE_AUTHOR("Mia Lin <mimi05633@gmail.com>");
 591 MODULE_DESCRIPTION("Nuvoton NCT3018Y RTC driver");
 592 MODULE_LICENSE("GPL");