1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Driver for Epson's RTC module RX-8025 SA/NB |
4 | * |
5 | * Copyright (C) 2009 Wolfgang Grandegger <wg@grandegger.com> |
6 | * |
7 | * Copyright (C) 2005 by Digi International Inc. |
8 | * All rights reserved. |
9 | * |
10 | * Modified by fengjh at rising.com.cn |
11 | * <lm-sensors@lm-sensors.org> |
12 | * 2006.11 |
13 | * |
14 | * Code cleanup by Sergei Poselenov, <sposelenov@emcraft.com> |
15 | * Converted to new style by Wolfgang Grandegger <wg@grandegger.com> |
16 | * Alarm and periodic interrupt added by Dmitry Rakhchev <rda@emcraft.com> |
17 | */ |
18 | #include <linux/bcd.h> |
19 | #include <linux/bitops.h> |
20 | #include <linux/i2c.h> |
21 | #include <linux/kernel.h> |
22 | #include <linux/kstrtox.h> |
23 | #include <linux/module.h> |
24 | #include <linux/rtc.h> |
25 | |
26 | /* Register definitions */ |
27 | #define RX8025_REG_SEC 0x00 |
28 | #define RX8025_REG_MIN 0x01 |
29 | #define RX8025_REG_HOUR 0x02 |
30 | #define RX8025_REG_WDAY 0x03 |
31 | #define RX8025_REG_MDAY 0x04 |
32 | #define RX8025_REG_MONTH 0x05 |
33 | #define RX8025_REG_YEAR 0x06 |
34 | #define RX8025_REG_DIGOFF 0x07 |
35 | #define RX8025_REG_ALWMIN 0x08 |
36 | #define RX8025_REG_ALWHOUR 0x09 |
37 | #define RX8025_REG_ALWWDAY 0x0a |
38 | #define RX8025_REG_ALDMIN 0x0b |
39 | #define RX8025_REG_ALDHOUR 0x0c |
40 | /* 0x0d is reserved */ |
41 | #define RX8025_REG_CTRL1 0x0e |
42 | #define RX8025_REG_CTRL2 0x0f |
43 | |
44 | #define RX8025_BIT_CTRL1_CT (7 << 0) |
45 | /* 1 Hz periodic level irq */ |
46 | #define RX8025_BIT_CTRL1_CT_1HZ 4 |
47 | #define RX8025_BIT_CTRL1_TEST BIT(3) |
48 | #define RX8025_BIT_CTRL1_1224 BIT(5) |
49 | #define RX8025_BIT_CTRL1_DALE BIT(6) |
50 | #define RX8025_BIT_CTRL1_WALE BIT(7) |
51 | |
52 | #define RX8025_BIT_CTRL2_DAFG BIT(0) |
53 | #define RX8025_BIT_CTRL2_WAFG BIT(1) |
54 | #define RX8025_BIT_CTRL2_CTFG BIT(2) |
55 | #define RX8025_BIT_CTRL2_PON BIT(4) |
56 | #define RX8025_BIT_CTRL2_XST BIT(5) |
57 | #define RX8025_BIT_CTRL2_VDET BIT(6) |
58 | |
59 | #define RX8035_BIT_HOUR_1224 BIT(7) |
60 | |
61 | /* Clock precision adjustment */ |
62 | #define RX8025_ADJ_RESOLUTION 3050 /* in ppb */ |
63 | #define RX8025_ADJ_DATA_MAX 62 |
64 | #define RX8025_ADJ_DATA_MIN -62 |
65 | |
66 | enum rx_model { |
67 | model_rx_unknown, |
68 | model_rx_8025, |
69 | model_rx_8035, |
70 | model_last |
71 | }; |
72 | |
73 | static const struct i2c_device_id rx8025_id[] = { |
74 | { "rx8025" , model_rx_8025 }, |
75 | { "rx8035" , model_rx_8035 }, |
76 | { } |
77 | }; |
78 | MODULE_DEVICE_TABLE(i2c, rx8025_id); |
79 | |
80 | struct rx8025_data { |
81 | struct rtc_device *rtc; |
82 | enum rx_model model; |
83 | u8 ctrl1; |
84 | int is_24; |
85 | }; |
86 | |
87 | static s32 rx8025_read_reg(const struct i2c_client *client, u8 number) |
88 | { |
89 | return i2c_smbus_read_byte_data(client, command: number << 4); |
90 | } |
91 | |
92 | static int rx8025_read_regs(const struct i2c_client *client, |
93 | u8 number, u8 length, u8 *values) |
94 | { |
95 | int ret = i2c_smbus_read_i2c_block_data(client, command: number << 4, length, |
96 | values); |
97 | if (ret != length) |
98 | return ret < 0 ? ret : -EIO; |
99 | |
100 | return 0; |
101 | } |
102 | |
103 | static s32 rx8025_write_reg(const struct i2c_client *client, u8 number, |
104 | u8 value) |
105 | { |
106 | return i2c_smbus_write_byte_data(client, command: number << 4, value); |
107 | } |
108 | |
109 | static s32 rx8025_write_regs(const struct i2c_client *client, |
110 | u8 number, u8 length, const u8 *values) |
111 | { |
112 | return i2c_smbus_write_i2c_block_data(client, command: number << 4, |
113 | length, values); |
114 | } |
115 | |
116 | static int rx8025_is_osc_stopped(enum rx_model model, int ctrl2) |
117 | { |
118 | int xstp = ctrl2 & RX8025_BIT_CTRL2_XST; |
119 | /* XSTP bit has different polarity on RX-8025 vs RX-8035. |
120 | * RX-8025: 0 == oscillator stopped |
121 | * RX-8035: 1 == oscillator stopped |
122 | */ |
123 | |
124 | if (model == model_rx_8025) |
125 | xstp = !xstp; |
126 | |
127 | return xstp; |
128 | } |
129 | |
130 | static int rx8025_check_validity(struct device *dev) |
131 | { |
132 | struct i2c_client *client = to_i2c_client(dev); |
133 | struct rx8025_data *drvdata = dev_get_drvdata(dev); |
134 | int ctrl2; |
135 | int xstp; |
136 | |
137 | ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2); |
138 | if (ctrl2 < 0) |
139 | return ctrl2; |
140 | |
141 | if (ctrl2 & RX8025_BIT_CTRL2_VDET) |
142 | dev_warn(dev, "power voltage drop detected\n" ); |
143 | |
144 | if (ctrl2 & RX8025_BIT_CTRL2_PON) { |
145 | dev_warn(dev, "power-on reset detected, date is invalid\n" ); |
146 | return -EINVAL; |
147 | } |
148 | |
149 | xstp = rx8025_is_osc_stopped(model: drvdata->model, ctrl2); |
150 | if (xstp) { |
151 | dev_warn(dev, "crystal stopped, date is invalid\n" ); |
152 | return -EINVAL; |
153 | } |
154 | |
155 | return 0; |
156 | } |
157 | |
158 | static int rx8025_reset_validity(struct i2c_client *client) |
159 | { |
160 | struct rx8025_data *drvdata = i2c_get_clientdata(client); |
161 | int ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2); |
162 | |
163 | if (ctrl2 < 0) |
164 | return ctrl2; |
165 | |
166 | ctrl2 &= ~(RX8025_BIT_CTRL2_PON | RX8025_BIT_CTRL2_VDET); |
167 | |
168 | if (drvdata->model == model_rx_8025) |
169 | ctrl2 |= RX8025_BIT_CTRL2_XST; |
170 | else |
171 | ctrl2 &= ~(RX8025_BIT_CTRL2_XST); |
172 | |
173 | return rx8025_write_reg(client, RX8025_REG_CTRL2, |
174 | value: ctrl2); |
175 | } |
176 | |
177 | static irqreturn_t rx8025_handle_irq(int irq, void *dev_id) |
178 | { |
179 | struct i2c_client *client = dev_id; |
180 | struct rx8025_data *rx8025 = i2c_get_clientdata(client); |
181 | int status, xstp; |
182 | |
183 | rtc_lock(rx8025->rtc); |
184 | status = rx8025_read_reg(client, RX8025_REG_CTRL2); |
185 | if (status < 0) |
186 | goto out; |
187 | |
188 | xstp = rx8025_is_osc_stopped(model: rx8025->model, ctrl2: status); |
189 | if (xstp) |
190 | dev_warn(&client->dev, "Oscillation stop was detected," |
191 | "you may have to readjust the clock\n" ); |
192 | |
193 | if (status & RX8025_BIT_CTRL2_CTFG) { |
194 | /* periodic */ |
195 | status &= ~RX8025_BIT_CTRL2_CTFG; |
196 | rtc_update_irq(rtc: rx8025->rtc, num: 1, RTC_PF | RTC_IRQF); |
197 | } |
198 | |
199 | if (status & RX8025_BIT_CTRL2_DAFG) { |
200 | /* alarm */ |
201 | status &= RX8025_BIT_CTRL2_DAFG; |
202 | if (rx8025_write_reg(client, RX8025_REG_CTRL1, |
203 | value: rx8025->ctrl1 & ~RX8025_BIT_CTRL1_DALE)) |
204 | goto out; |
205 | rtc_update_irq(rtc: rx8025->rtc, num: 1, RTC_AF | RTC_IRQF); |
206 | } |
207 | |
208 | out: |
209 | rtc_unlock(rx8025->rtc); |
210 | |
211 | return IRQ_HANDLED; |
212 | } |
213 | |
214 | static int rx8025_get_time(struct device *dev, struct rtc_time *dt) |
215 | { |
216 | struct i2c_client *client = to_i2c_client(dev); |
217 | struct rx8025_data *rx8025 = dev_get_drvdata(dev); |
218 | u8 date[7]; |
219 | int err; |
220 | |
221 | err = rx8025_check_validity(dev); |
222 | if (err) |
223 | return err; |
224 | |
225 | err = rx8025_read_regs(client, RX8025_REG_SEC, length: 7, values: date); |
226 | if (err) |
227 | return err; |
228 | |
229 | dev_dbg(dev, "%s: read %7ph\n" , __func__, date); |
230 | |
231 | dt->tm_sec = bcd2bin(date[RX8025_REG_SEC] & 0x7f); |
232 | dt->tm_min = bcd2bin(date[RX8025_REG_MIN] & 0x7f); |
233 | if (rx8025->is_24) |
234 | dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x3f); |
235 | else |
236 | dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x1f) % 12 |
237 | + (date[RX8025_REG_HOUR] & 0x20 ? 12 : 0); |
238 | |
239 | dt->tm_mday = bcd2bin(date[RX8025_REG_MDAY] & 0x3f); |
240 | dt->tm_mon = bcd2bin(date[RX8025_REG_MONTH] & 0x1f) - 1; |
241 | dt->tm_year = bcd2bin(date[RX8025_REG_YEAR]) + 100; |
242 | |
243 | dev_dbg(dev, "%s: date %ptRr\n" , __func__, dt); |
244 | |
245 | return 0; |
246 | } |
247 | |
248 | static int rx8025_set_time(struct device *dev, struct rtc_time *dt) |
249 | { |
250 | struct i2c_client *client = to_i2c_client(dev); |
251 | struct rx8025_data *rx8025 = dev_get_drvdata(dev); |
252 | u8 date[7]; |
253 | int ret; |
254 | |
255 | /* |
256 | * Here the read-only bits are written as "0". I'm not sure if that |
257 | * is sound. |
258 | */ |
259 | date[RX8025_REG_SEC] = bin2bcd(dt->tm_sec); |
260 | date[RX8025_REG_MIN] = bin2bcd(dt->tm_min); |
261 | if (rx8025->is_24) |
262 | date[RX8025_REG_HOUR] = bin2bcd(dt->tm_hour); |
263 | else |
264 | date[RX8025_REG_HOUR] = (dt->tm_hour >= 12 ? 0x20 : 0) |
265 | | bin2bcd((dt->tm_hour + 11) % 12 + 1); |
266 | |
267 | date[RX8025_REG_WDAY] = bin2bcd(dt->tm_wday); |
268 | date[RX8025_REG_MDAY] = bin2bcd(dt->tm_mday); |
269 | date[RX8025_REG_MONTH] = bin2bcd(dt->tm_mon + 1); |
270 | date[RX8025_REG_YEAR] = bin2bcd(dt->tm_year - 100); |
271 | |
272 | dev_dbg(dev, "%s: write %7ph\n" , __func__, date); |
273 | |
274 | ret = rx8025_write_regs(client, RX8025_REG_SEC, length: 7, values: date); |
275 | if (ret < 0) |
276 | return ret; |
277 | |
278 | return rx8025_reset_validity(client); |
279 | } |
280 | |
281 | static int rx8025_init_client(struct i2c_client *client) |
282 | { |
283 | struct rx8025_data *rx8025 = i2c_get_clientdata(client); |
284 | u8 ctrl[2], ctrl2; |
285 | int need_clear = 0; |
286 | int hour_reg; |
287 | int err; |
288 | |
289 | err = rx8025_read_regs(client, RX8025_REG_CTRL1, length: 2, values: ctrl); |
290 | if (err) |
291 | goto out; |
292 | |
293 | /* Keep test bit zero ! */ |
294 | rx8025->ctrl1 = ctrl[0] & ~RX8025_BIT_CTRL1_TEST; |
295 | |
296 | if (ctrl[1] & (RX8025_BIT_CTRL2_DAFG | RX8025_BIT_CTRL2_WAFG)) { |
297 | dev_warn(&client->dev, "Alarm was detected\n" ); |
298 | need_clear = 1; |
299 | } |
300 | |
301 | if (ctrl[1] & RX8025_BIT_CTRL2_CTFG) |
302 | need_clear = 1; |
303 | |
304 | if (need_clear) { |
305 | ctrl2 = ctrl[1]; |
306 | ctrl2 &= ~(RX8025_BIT_CTRL2_CTFG | RX8025_BIT_CTRL2_WAFG | |
307 | RX8025_BIT_CTRL2_DAFG); |
308 | |
309 | err = rx8025_write_reg(client, RX8025_REG_CTRL2, value: ctrl2); |
310 | } |
311 | |
312 | if (rx8025->model == model_rx_8035) { |
313 | /* In RX-8035, 12/24 flag is in the hour register */ |
314 | hour_reg = rx8025_read_reg(client, RX8025_REG_HOUR); |
315 | if (hour_reg < 0) |
316 | return hour_reg; |
317 | rx8025->is_24 = (hour_reg & RX8035_BIT_HOUR_1224); |
318 | } else { |
319 | rx8025->is_24 = (ctrl[1] & RX8025_BIT_CTRL1_1224); |
320 | } |
321 | out: |
322 | return err; |
323 | } |
324 | |
325 | /* Alarm support */ |
326 | static int rx8025_read_alarm(struct device *dev, struct rtc_wkalrm *t) |
327 | { |
328 | struct i2c_client *client = to_i2c_client(dev); |
329 | struct rx8025_data *rx8025 = dev_get_drvdata(dev); |
330 | u8 ald[2]; |
331 | int ctrl2, err; |
332 | |
333 | err = rx8025_read_regs(client, RX8025_REG_ALDMIN, length: 2, values: ald); |
334 | if (err) |
335 | return err; |
336 | |
337 | ctrl2 = rx8025_read_reg(client, RX8025_REG_CTRL2); |
338 | if (ctrl2 < 0) |
339 | return ctrl2; |
340 | |
341 | dev_dbg(dev, "%s: read alarm 0x%02x 0x%02x ctrl2 %02x\n" , |
342 | __func__, ald[0], ald[1], ctrl2); |
343 | |
344 | /* Hardware alarms precision is 1 minute! */ |
345 | t->time.tm_sec = 0; |
346 | t->time.tm_min = bcd2bin(ald[0] & 0x7f); |
347 | if (rx8025->is_24) |
348 | t->time.tm_hour = bcd2bin(ald[1] & 0x3f); |
349 | else |
350 | t->time.tm_hour = bcd2bin(ald[1] & 0x1f) % 12 |
351 | + (ald[1] & 0x20 ? 12 : 0); |
352 | |
353 | dev_dbg(dev, "%s: date: %ptRr\n" , __func__, &t->time); |
354 | t->enabled = !!(rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE); |
355 | t->pending = (ctrl2 & RX8025_BIT_CTRL2_DAFG) && t->enabled; |
356 | |
357 | return err; |
358 | } |
359 | |
360 | static int rx8025_set_alarm(struct device *dev, struct rtc_wkalrm *t) |
361 | { |
362 | struct i2c_client *client = to_i2c_client(dev); |
363 | struct rx8025_data *rx8025 = dev_get_drvdata(dev); |
364 | u8 ald[2]; |
365 | int err; |
366 | |
367 | ald[0] = bin2bcd(t->time.tm_min); |
368 | if (rx8025->is_24) |
369 | ald[1] = bin2bcd(t->time.tm_hour); |
370 | else |
371 | ald[1] = (t->time.tm_hour >= 12 ? 0x20 : 0) |
372 | | bin2bcd((t->time.tm_hour + 11) % 12 + 1); |
373 | |
374 | dev_dbg(dev, "%s: write 0x%02x 0x%02x\n" , __func__, ald[0], ald[1]); |
375 | |
376 | if (rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE) { |
377 | rx8025->ctrl1 &= ~RX8025_BIT_CTRL1_DALE; |
378 | err = rx8025_write_reg(client, RX8025_REG_CTRL1, |
379 | value: rx8025->ctrl1); |
380 | if (err) |
381 | return err; |
382 | } |
383 | err = rx8025_write_regs(client, RX8025_REG_ALDMIN, length: 2, values: ald); |
384 | if (err) |
385 | return err; |
386 | |
387 | if (t->enabled) { |
388 | rx8025->ctrl1 |= RX8025_BIT_CTRL1_DALE; |
389 | err = rx8025_write_reg(client, RX8025_REG_CTRL1, |
390 | value: rx8025->ctrl1); |
391 | if (err) |
392 | return err; |
393 | } |
394 | |
395 | return 0; |
396 | } |
397 | |
398 | static int rx8025_alarm_irq_enable(struct device *dev, unsigned int enabled) |
399 | { |
400 | struct i2c_client *client = to_i2c_client(dev); |
401 | struct rx8025_data *rx8025 = dev_get_drvdata(dev); |
402 | u8 ctrl1; |
403 | int err; |
404 | |
405 | ctrl1 = rx8025->ctrl1; |
406 | if (enabled) |
407 | ctrl1 |= RX8025_BIT_CTRL1_DALE; |
408 | else |
409 | ctrl1 &= ~RX8025_BIT_CTRL1_DALE; |
410 | |
411 | if (ctrl1 != rx8025->ctrl1) { |
412 | rx8025->ctrl1 = ctrl1; |
413 | err = rx8025_write_reg(client, RX8025_REG_CTRL1, |
414 | value: rx8025->ctrl1); |
415 | if (err) |
416 | return err; |
417 | } |
418 | return 0; |
419 | } |
420 | |
421 | /* |
422 | * According to the RX8025 SA/NB application manual the frequency and |
423 | * temperature characteristics can be approximated using the following |
424 | * equation: |
425 | * |
426 | * df = a * (ut - t)**2 |
427 | * |
428 | * df: Frequency deviation in any temperature |
429 | * a : Coefficient = (-35 +-5) * 10**-9 |
430 | * ut: Ultimate temperature in degree = +25 +-5 degree |
431 | * t : Any temperature in degree |
432 | */ |
433 | static int rx8025_read_offset(struct device *dev, long *offset) |
434 | { |
435 | struct i2c_client *client = to_i2c_client(dev); |
436 | int digoff; |
437 | |
438 | digoff = rx8025_read_reg(client, RX8025_REG_DIGOFF); |
439 | if (digoff < 0) |
440 | return digoff; |
441 | |
442 | *offset = digoff >= 64 ? digoff - 128 : digoff; |
443 | if (*offset > 0) |
444 | (*offset)--; |
445 | *offset *= RX8025_ADJ_RESOLUTION; |
446 | |
447 | return 0; |
448 | } |
449 | |
450 | static int rx8025_set_offset(struct device *dev, long offset) |
451 | { |
452 | struct i2c_client *client = to_i2c_client(dev); |
453 | u8 digoff; |
454 | |
455 | offset /= RX8025_ADJ_RESOLUTION; |
456 | if (offset > RX8025_ADJ_DATA_MAX) |
457 | offset = RX8025_ADJ_DATA_MAX; |
458 | else if (offset < RX8025_ADJ_DATA_MIN) |
459 | offset = RX8025_ADJ_DATA_MIN; |
460 | else if (offset > 0) |
461 | offset++; |
462 | else if (offset < 0) |
463 | offset += 128; |
464 | digoff = offset; |
465 | |
466 | return rx8025_write_reg(client, RX8025_REG_DIGOFF, value: digoff); |
467 | } |
468 | |
469 | static const struct rtc_class_ops rx8025_rtc_ops = { |
470 | .read_time = rx8025_get_time, |
471 | .set_time = rx8025_set_time, |
472 | .read_alarm = rx8025_read_alarm, |
473 | .set_alarm = rx8025_set_alarm, |
474 | .alarm_irq_enable = rx8025_alarm_irq_enable, |
475 | .read_offset = rx8025_read_offset, |
476 | .set_offset = rx8025_set_offset, |
477 | }; |
478 | |
479 | static ssize_t rx8025_sysfs_show_clock_adjust(struct device *dev, |
480 | struct device_attribute *attr, |
481 | char *buf) |
482 | { |
483 | long adj; |
484 | int err; |
485 | |
486 | dev_warn_once(dev, "clock_adjust_ppb is deprecated, use offset\n" ); |
487 | err = rx8025_read_offset(dev, offset: &adj); |
488 | if (err) |
489 | return err; |
490 | |
491 | return sprintf(buf, fmt: "%ld\n" , -adj); |
492 | } |
493 | |
494 | static ssize_t rx8025_sysfs_store_clock_adjust(struct device *dev, |
495 | struct device_attribute *attr, |
496 | const char *buf, size_t count) |
497 | { |
498 | long adj; |
499 | int err; |
500 | |
501 | dev_warn_once(dev, "clock_adjust_ppb is deprecated, use offset\n" ); |
502 | if (kstrtol(s: buf, base: 10, res: &adj) != 0) |
503 | return -EINVAL; |
504 | |
505 | err = rx8025_set_offset(dev, offset: -adj); |
506 | |
507 | return err ? err : count; |
508 | } |
509 | |
510 | static DEVICE_ATTR(clock_adjust_ppb, S_IRUGO | S_IWUSR, |
511 | rx8025_sysfs_show_clock_adjust, |
512 | rx8025_sysfs_store_clock_adjust); |
513 | |
514 | static struct attribute *rx8025_attrs[] = { |
515 | &dev_attr_clock_adjust_ppb.attr, |
516 | NULL |
517 | }; |
518 | |
519 | static const struct attribute_group rx8025_attr_group = { |
520 | .attrs = rx8025_attrs, |
521 | }; |
522 | |
523 | static int rx8025_probe(struct i2c_client *client) |
524 | { |
525 | const struct i2c_device_id *id = i2c_match_id(id: rx8025_id, client); |
526 | struct i2c_adapter *adapter = client->adapter; |
527 | struct rx8025_data *rx8025; |
528 | int err = 0; |
529 | |
530 | if (!i2c_check_functionality(adap: adapter, I2C_FUNC_SMBUS_BYTE_DATA |
531 | | I2C_FUNC_SMBUS_I2C_BLOCK)) { |
532 | dev_err(&adapter->dev, |
533 | "doesn't support required functionality\n" ); |
534 | return -EIO; |
535 | } |
536 | |
537 | rx8025 = devm_kzalloc(dev: &client->dev, size: sizeof(*rx8025), GFP_KERNEL); |
538 | if (!rx8025) |
539 | return -ENOMEM; |
540 | |
541 | i2c_set_clientdata(client, data: rx8025); |
542 | |
543 | if (id) |
544 | rx8025->model = id->driver_data; |
545 | |
546 | err = rx8025_init_client(client); |
547 | if (err) |
548 | return err; |
549 | |
550 | rx8025->rtc = devm_rtc_allocate_device(dev: &client->dev); |
551 | if (IS_ERR(ptr: rx8025->rtc)) |
552 | return PTR_ERR(ptr: rx8025->rtc); |
553 | |
554 | rx8025->rtc->ops = &rx8025_rtc_ops; |
555 | rx8025->rtc->range_min = RTC_TIMESTAMP_BEGIN_1900; |
556 | rx8025->rtc->range_max = RTC_TIMESTAMP_END_2099; |
557 | |
558 | if (client->irq > 0) { |
559 | dev_info(&client->dev, "IRQ %d supplied\n" , client->irq); |
560 | err = devm_request_threaded_irq(dev: &client->dev, irq: client->irq, NULL, |
561 | thread_fn: rx8025_handle_irq, |
562 | IRQF_ONESHOT, |
563 | devname: "rx8025" , dev_id: client); |
564 | if (err) |
565 | clear_bit(RTC_FEATURE_ALARM, addr: rx8025->rtc->features); |
566 | } |
567 | |
568 | rx8025->rtc->max_user_freq = 1; |
569 | |
570 | set_bit(RTC_FEATURE_ALARM_RES_MINUTE, addr: rx8025->rtc->features); |
571 | clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, addr: rx8025->rtc->features); |
572 | |
573 | err = rtc_add_group(rtc: rx8025->rtc, grp: &rx8025_attr_group); |
574 | if (err) |
575 | return err; |
576 | |
577 | return devm_rtc_register_device(rx8025->rtc); |
578 | } |
579 | |
580 | static struct i2c_driver rx8025_driver = { |
581 | .driver = { |
582 | .name = "rtc-rx8025" , |
583 | }, |
584 | .probe = rx8025_probe, |
585 | .id_table = rx8025_id, |
586 | }; |
587 | |
588 | module_i2c_driver(rx8025_driver); |
589 | |
590 | MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>" ); |
591 | MODULE_DESCRIPTION("RX-8025 SA/NB RTC driver" ); |
592 | MODULE_LICENSE("GPL" ); |
593 | |