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 | |
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 = ®, |
94 | }, |
95 | { |
96 | .addr = client->addr, |
97 | .flags = I2C_M_RD, |
98 | .len = length, |
99 | .buf = buf |
100 | }, |
101 | }; |
102 | |
103 | if ((i2c_transfer(adap: client->adapter, msgs, num: 2)) != 2) { |
104 | dev_err(&client->dev, "%s: read error\n" , __func__); |
105 | return -EIO; |
106 | } |
107 | |
108 | return 0; |
109 | } |
110 | |
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, buf: data, count: 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 | |
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, length: 1, buf: &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, length: 1, buf: &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 | |
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, length: 1, buf: &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 | |
175 | static irqreturn_t pcf8563_irq(int irq, void *dev_id) |
176 | { |
177 | struct pcf8563 *pcf8563 = i2c_get_clientdata(client: dev_id); |
178 | int err; |
179 | char pending; |
180 | |
181 | err = pcf8563_get_alarm_mode(client: pcf8563->client, NULL, pen: &pending); |
182 | if (err) |
183 | return IRQ_NONE; |
184 | |
185 | if (pending) { |
186 | rtc_update_irq(rtc: pcf8563->rtc, num: 1, RTC_IRQF | RTC_AF); |
187 | pcf8563_set_alarm_mode(client: pcf8563->client, on: 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 | */ |
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, length: 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 | |
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 | length: 9 - PCF8563_REG_SC, buf: buf + PCF8563_REG_SC); |
275 | } |
276 | |
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 | |
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, length: 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, en: &tm->enabled, pen: &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 | |
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, length: 4, buf); |
339 | if (err) |
340 | return err; |
341 | |
342 | return pcf8563_set_alarm_mode(client, on: !!tm->enabled); |
343 | } |
344 | |
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), on: !!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 | |
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, length: 1, buf: &buf); |
372 | |
373 | if (ret < 0) |
374 | return 0; |
375 | |
376 | buf &= PCF8563_REG_CLKO_F_MASK; |
377 | return clkout_rates[buf]; |
378 | } |
379 | |
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 | |
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, length: 1, buf: &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, length: 1, |
410 | buf: &buf); |
411 | return ret; |
412 | } |
413 | |
414 | return -EINVAL; |
415 | } |
416 | |
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, length: 1, buf: &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, length: 1, buf: &buf); |
433 | return ret; |
434 | } |
435 | |
436 | static int pcf8563_clkout_prepare(struct clk_hw *hw) |
437 | { |
438 | return pcf8563_clkout_control(hw, enable: 1); |
439 | } |
440 | |
441 | static void pcf8563_clkout_unprepare(struct clk_hw *hw) |
442 | { |
443 | pcf8563_clkout_control(hw, enable: 0); |
444 | } |
445 | |
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, length: 1, buf: &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 | |
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, length: 1, buf: &buf); |
480 | if (ret < 0) |
481 | return ERR_PTR(error: 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(np: node, propname: "clock-output-names" , out_string: &init.name); |
492 | |
493 | /* register the clock */ |
494 | clk = devm_clk_register(dev: &client->dev, hw: &pcf8563->clkout_hw); |
495 | |
496 | if (!IS_ERR(ptr: clk)) |
497 | of_clk_add_provider(np: node, clk_src_get: of_clk_src_simple_get, data: 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 | |
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(adap: client->adapter, I2C_FUNC_I2C)) |
521 | return -ENODEV; |
522 | |
523 | pcf8563 = devm_kzalloc(dev: &client->dev, size: sizeof(struct pcf8563), |
524 | GFP_KERNEL); |
525 | if (!pcf8563) |
526 | return -ENOMEM; |
527 | |
528 | i2c_set_clientdata(client, data: pcf8563); |
529 | pcf8563->client = client; |
530 | device_set_wakeup_capable(dev: &client->dev, capable: 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, length: 1, buf: &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, length: 1, buf: &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(dev: &client->dev); |
549 | if (IS_ERR(ptr: pcf8563->rtc)) |
550 | return PTR_ERR(ptr: 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, addr: pcf8563->rtc->features); |
555 | clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, addr: 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(dev: &client->dev, irq: client->irq, |
567 | NULL, thread_fn: pcf8563_irq, |
568 | IRQF_SHARED | IRQF_ONESHOT | irqflags, |
569 | devname: pcf8563_driver.driver.name, dev_id: 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, addr: 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 | |