xref: /openbmc/linux/drivers/rtc/rtc-nct3018y.c (revision 1090a8c7)
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 
nct3018y_set_alarm_mode(struct i2c_client * client,bool on)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 
nct3018y_get_alarm_mode(struct i2c_client * client,unsigned char * alarm_enable,unsigned char * alarm_flag)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 
nct3018y_irq(int irq,void * dev_id)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  */
nct3018y_rtc_read_time(struct device * dev,struct rtc_time * tm)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 
nct3018y_rtc_set_time(struct device * dev,struct rtc_time * tm)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 
nct3018y_rtc_read_alarm(struct device * dev,struct rtc_wkalrm * tm)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 
nct3018y_rtc_set_alarm(struct device * dev,struct rtc_wkalrm * tm)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 
nct3018y_irq_enable(struct device * dev,unsigned int enabled)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 
nct3018y_ioctl(struct device * dev,unsigned int cmd,unsigned long arg)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 
nct3018y_clkout_recalc_rate(struct clk_hw * hw,unsigned long parent_rate)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 
nct3018y_clkout_round_rate(struct clk_hw * hw,unsigned long rate,unsigned long * prate)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 
nct3018y_clkout_set_rate(struct clk_hw * hw,unsigned long rate,unsigned long parent_rate)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 
nct3018y_clkout_control(struct clk_hw * hw,bool enable)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 
nct3018y_clkout_prepare(struct clk_hw * hw)421 static int nct3018y_clkout_prepare(struct clk_hw *hw)
422 {
423 	return nct3018y_clkout_control(hw, 1);
424 }
425 
nct3018y_clkout_unprepare(struct clk_hw * hw)426 static void nct3018y_clkout_unprepare(struct clk_hw *hw)
427 {
428 	nct3018y_clkout_control(hw, 0);
429 }
430 
nct3018y_clkout_is_prepared(struct clk_hw * hw)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 
nct3018y_clkout_register_clk(struct nct3018y * nct3018y)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 
nct3018y_probe(struct i2c_client * client)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");
593