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