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 
63 static struct i2c_driver pcf8563_driver;
64 
65 struct 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 
pcf8563_read_block_data(struct i2c_client * client,unsigned char reg,unsigned char length,unsigned char * buf)90 static 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 
pcf8563_write_block_data(struct i2c_client * client,unsigned char reg,unsigned char length,unsigned char * buf)115 static 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 
pcf8563_set_alarm_mode(struct i2c_client * client,bool on)136 static 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 
pcf8563_get_alarm_mode(struct i2c_client * client,unsigned char * en,unsigned char * pen)161 static 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 
pcf8563_irq(int irq,void * dev_id)179 static 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  */
pcf8563_get_datetime(struct i2c_client * client,struct rtc_time * tm)202 static 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 
pcf8563_set_datetime(struct i2c_client * client,struct rtc_time * tm)250 static 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
pcf8563_rtc_ioctl(struct device * dev,unsigned int cmd,unsigned long arg)283 static 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 
pcf8563_rtc_read_time(struct device * dev,struct rtc_time * tm)320 static 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 
pcf8563_rtc_set_time(struct device * dev,struct rtc_time * tm)325 static 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 
pcf8563_rtc_read_alarm(struct device * dev,struct rtc_wkalrm * tm)330 static 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 
pcf8563_rtc_set_alarm(struct device * dev,struct rtc_wkalrm * tm)362 static 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, !!tm->enabled);
391 }
392 
pcf8563_irq_enable(struct device * dev,unsigned int enabled)393 static 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 
406 static int clkout_rates[] = {
407 	32768,
408 	1024,
409 	32,
410 	1,
411 };
412 
pcf8563_clkout_recalc_rate(struct clk_hw * hw,unsigned long parent_rate)413 static 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[buf];
426 }
427 
pcf8563_clkout_round_rate(struct clk_hw * hw,unsigned long rate,unsigned long * prate)428 static 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 
pcf8563_clkout_set_rate(struct clk_hw * hw,unsigned long rate,unsigned long parent_rate)440 static 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 
pcf8563_clkout_control(struct clk_hw * hw,bool enable)465 static 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 
pcf8563_clkout_prepare(struct clk_hw * hw)484 static int pcf8563_clkout_prepare(struct clk_hw *hw)
485 {
486 	return pcf8563_clkout_control(hw, 1);
487 }
488 
pcf8563_clkout_unprepare(struct clk_hw * hw)489 static void pcf8563_clkout_unprepare(struct clk_hw *hw)
490 {
491 	pcf8563_clkout_control(hw, 0);
492 }
493 
pcf8563_clkout_is_prepared(struct clk_hw * hw)494 static 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 
507 static 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 
pcf8563_clkout_register_clk(struct pcf8563 * pcf8563)516 static 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 
551 static 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 
pcf8563_probe(struct i2c_client * client,const struct i2c_device_id * id)560 static 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 
567 	dev_dbg(&client->dev, "%s\n", __func__);
568 
569 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
570 		return -ENODEV;
571 
572 	pcf8563 = devm_kzalloc(&client->dev, sizeof(struct pcf8563),
573 				GFP_KERNEL);
574 	if (!pcf8563)
575 		return -ENOMEM;
576 
577 	i2c_set_clientdata(client, pcf8563);
578 	pcf8563->client = client;
579 	device_set_wakeup_capable(&client->dev, 1);
580 
581 	/* Set timer to lowest frequency to save power (ref Haoyu datasheet) */
582 	buf = PCF8563_TMRC_1_60;
583 	err = pcf8563_write_block_data(client, PCF8563_REG_TMRC, 1, &buf);
584 	if (err < 0) {
585 		dev_err(&client->dev, "%s: write error\n", __func__);
586 		return err;
587 	}
588 
589 	/* Clear flags and disable interrupts */
590 	buf = 0;
591 	err = pcf8563_write_block_data(client, PCF8563_REG_ST2, 1, &buf);
592 	if (err < 0) {
593 		dev_err(&client->dev, "%s: write error\n", __func__);
594 		return err;
595 	}
596 
597 	pcf8563->rtc = devm_rtc_device_register(&client->dev,
598 				pcf8563_driver.driver.name,
599 				&pcf8563_rtc_ops, THIS_MODULE);
600 
601 	if (IS_ERR(pcf8563->rtc))
602 		return PTR_ERR(pcf8563->rtc);
603 
604 	if (client->irq > 0) {
605 		err = devm_request_threaded_irq(&client->dev, client->irq,
606 				NULL, pcf8563_irq,
607 				IRQF_SHARED | IRQF_ONESHOT | IRQF_TRIGGER_LOW,
608 				pcf8563_driver.driver.name, client);
609 		if (err) {
610 			dev_err(&client->dev, "unable to request IRQ %d\n",
611 								client->irq);
612 			return err;
613 		}
614 
615 	}
616 
617 #ifdef CONFIG_COMMON_CLK
618 	/* register clk in common clk framework */
619 	pcf8563_clkout_register_clk(pcf8563);
620 #endif
621 
622 	/* the pcf8563 alarm only supports a minute accuracy */
623 	pcf8563->rtc->uie_unsupported = 1;
624 
625 	return 0;
626 }
627 
628 static const struct i2c_device_id pcf8563_id[] = {
629 	{ "pcf8563", 0 },
630 	{ "rtc8564", 0 },
631 	{ }
632 };
633 MODULE_DEVICE_TABLE(i2c, pcf8563_id);
634 
635 #ifdef CONFIG_OF
636 static const struct of_device_id pcf8563_of_match[] = {
637 	{ .compatible = "nxp,pcf8563" },
638 	{}
639 };
640 MODULE_DEVICE_TABLE(of, pcf8563_of_match);
641 #endif
642 
643 static struct i2c_driver pcf8563_driver = {
644 	.driver		= {
645 		.name	= "rtc-pcf8563",
646 		.of_match_table = of_match_ptr(pcf8563_of_match),
647 	},
648 	.probe		= pcf8563_probe,
649 	.id_table	= pcf8563_id,
650 };
651 
652 module_i2c_driver(pcf8563_driver);
653 
654 MODULE_AUTHOR("Alessandro Zummo <a.zummo@towertech.it>");
655 MODULE_DESCRIPTION("Philips PCF8563/Epson RTC8564 RTC driver");
656 MODULE_LICENSE("GPL");
657