?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf intel-pt: Factor out intel_pt_8b_tsc()
[linux/fpc-iii.git] / drivers / rtc / rtc-rs5c372.c
blob66a473a3c3fef1d2643ba0383ee285682e4bb1f1
1 /*
2 * An I2C driver for Ricoh RS5C372, R2025S/D and RV5C38[67] RTCs
3 *
4 * Copyright (C) 2005 Pavel Mironchik <pmironchik@optifacio.net>
5 * Copyright (C) 2006 Tower Technologies
6 * Copyright (C) 2008 Paul Mundt
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13 #include <linux/i2c.h>
14 #include <linux/rtc.h>
15 #include <linux/bcd.h>
16 #include <linux/slab.h>
17 #include <linux/module.h>
18 #include <linux/of_device.h>
19
20 /*
21 * Ricoh has a family of I2C based RTCs, which differ only slightly from
22 * each other. Differences center on pinout (e.g. how many interrupts,
23 * output clock, etc) and how the control registers are used. The '372
24 * is significant only because that's the one this driver first supported.
25 */
26 #define RS5C372_REG_SECS 0
27 #define RS5C372_REG_MINS 1
28 #define RS5C372_REG_HOURS 2
29 #define RS5C372_REG_WDAY 3
30 #define RS5C372_REG_DAY 4
31 #define RS5C372_REG_MONTH 5
32 #define RS5C372_REG_YEAR 6
33 #define RS5C372_REG_TRIM 7
34 # define RS5C372_TRIM_XSL 0x80
35 # define RS5C372_TRIM_MASK 0x7F
36
37 #define RS5C_REG_ALARM_A_MIN 8 /* or ALARM_W */
38 #define RS5C_REG_ALARM_A_HOURS 9
39 #define RS5C_REG_ALARM_A_WDAY 10
40
41 #define RS5C_REG_ALARM_B_MIN 11 /* or ALARM_D */
42 #define RS5C_REG_ALARM_B_HOURS 12
43 #define RS5C_REG_ALARM_B_WDAY 13 /* (ALARM_B only) */
44
45 #define RS5C_REG_CTRL1 14
46 # define RS5C_CTRL1_AALE (1 << 7) /* or WALE */
47 # define RS5C_CTRL1_BALE (1 << 6) /* or DALE */
48 # define RV5C387_CTRL1_24 (1 << 5)
49 # define RS5C372A_CTRL1_SL1 (1 << 5)
50 # define RS5C_CTRL1_CT_MASK (7 << 0)
51 # define RS5C_CTRL1_CT0 (0 << 0) /* no periodic irq */
52 # define RS5C_CTRL1_CT4 (4 << 0) /* 1 Hz level irq */
53 #define RS5C_REG_CTRL2 15
54 # define RS5C372_CTRL2_24 (1 << 5)
55 # define RS5C_CTRL2_XSTP (1 << 4) /* only if !R2x2x */
56 # define R2x2x_CTRL2_VDET (1 << 6) /* only if R2x2x */
57 # define R2x2x_CTRL2_XSTP (1 << 5) /* only if R2x2x */
58 # define R2x2x_CTRL2_PON (1 << 4) /* only if R2x2x */
59 # define RS5C_CTRL2_CTFG (1 << 2)
60 # define RS5C_CTRL2_AAFG (1 << 1) /* or WAFG */
61 # define RS5C_CTRL2_BAFG (1 << 0) /* or DAFG */
62
63
64 /* to read (style 1) or write registers starting at R */
65 #define RS5C_ADDR(R) (((R) << 4) | 0)
66
67
68 enum rtc_type {
69 rtc_undef = 0,
70 rtc_r2025sd,
71 rtc_r2221tl,
72 rtc_rs5c372a,
73 rtc_rs5c372b,
74 rtc_rv5c386,
75 rtc_rv5c387a,
76 };
77
78 static const struct i2c_device_id rs5c372_id[] = {
79 { "r2025sd", rtc_r2025sd },
80 { "r2221tl", rtc_r2221tl },
81 { "rs5c372a", rtc_rs5c372a },
82 { "rs5c372b", rtc_rs5c372b },
83 { "rv5c386", rtc_rv5c386 },
84 { "rv5c387a", rtc_rv5c387a },
85 { }
86 };
87 MODULE_DEVICE_TABLE(i2c, rs5c372_id);
88
89 static const struct of_device_id rs5c372_of_match[] = {
90 {
91 .compatible = "ricoh,r2025sd",
92 .data = (void *)rtc_r2025sd
93 },
94 {
95 .compatible = "ricoh,r2221tl",
96 .data = (void *)rtc_r2221tl
97 },
98 {
99 .compatible = "ricoh,rs5c372a",
100 .data = (void *)rtc_rs5c372a
101 },
102 {
103 .compatible = "ricoh,rs5c372b",
104 .data = (void *)rtc_rs5c372b
105 },
106 {
107 .compatible = "ricoh,rv5c386",
108 .data = (void *)rtc_rv5c386
109 },
110 {
111 .compatible = "ricoh,rv5c387a",
112 .data = (void *)rtc_rv5c387a
113 },
114 { }
115 };
116 MODULE_DEVICE_TABLE(of, rs5c372_of_match);
117
118 /* REVISIT: this assumes that:
119 * - we're in the 21st century, so it's safe to ignore the century
120 * bit for rv5c38[67] (REG_MONTH bit 7);
121 * - we should use ALARM_A not ALARM_B (may be wrong on some boards)
122 */
123 struct rs5c372 {
124 struct i2c_client *client;
125 struct rtc_device *rtc;
126 enum rtc_type type;
127 unsigned time24:1;
128 unsigned has_irq:1;
129 unsigned smbus:1;
130 char buf[17];
131 char *regs;
132 };
133
134 static int rs5c_get_regs(struct rs5c372 *rs5c)
135 {
136 struct i2c_client *client = rs5c->client;
137 struct i2c_msg msgs[] = {
138 {
139 .addr = client->addr,
140 .flags = I2C_M_RD,
141 .len = sizeof(rs5c->buf),
142 .buf = rs5c->buf
143 },
144 };
145
146 /* This implements the third reading method from the datasheet, using
147 * an internal address that's reset after each transaction (by STOP)
148 * to 0x0f ... so we read extra registers, and skip the first one.
149 *
150 * The first method doesn't work with the iop3xx adapter driver, on at
151 * least 80219 chips; this works around that bug.
152 *
153 * The third method on the other hand doesn't work for the SMBus-only
154 * configurations, so we use the the first method there, stripping off
155 * the extra register in the process.
156 */
157 if (rs5c->smbus) {
158 int addr = RS5C_ADDR(RS5C372_REG_SECS);
159 int size = sizeof(rs5c->buf) - 1;
160
161 if (i2c_smbus_read_i2c_block_data(client, addr, size,
162 rs5c->buf + 1) != size) {
163 dev_warn(&client->dev, "can't read registers\n");
164 return -EIO;
165 }
166 } else {
167 if ((i2c_transfer(client->adapter, msgs, 1)) != 1) {
168 dev_warn(&client->dev, "can't read registers\n");
169 return -EIO;
170 }
171 }
172
173 dev_dbg(&client->dev,
174 "%3ph (%02x) %3ph (%02x), %3ph, %3ph; %02x %02x\n",
175 rs5c->regs + 0, rs5c->regs[3],
176 rs5c->regs + 4, rs5c->regs[7],
177 rs5c->regs + 8, rs5c->regs + 11,
178 rs5c->regs[14], rs5c->regs[15]);
179
180 return 0;
181 }
182
183 static unsigned rs5c_reg2hr(struct rs5c372 *rs5c, unsigned reg)
184 {
185 unsigned hour;
186
187 if (rs5c->time24)
188 return bcd2bin(reg & 0x3f);
189
190 hour = bcd2bin(reg & 0x1f);
191 if (hour == 12)
192 hour = 0;
193 if (reg & 0x20)
194 hour += 12;
195 return hour;
196 }
197
198 static unsigned rs5c_hr2reg(struct rs5c372 *rs5c, unsigned hour)
199 {
200 if (rs5c->time24)
201 return bin2bcd(hour);
202
203 if (hour > 12)
204 return 0x20 | bin2bcd(hour - 12);
205 if (hour == 12)
206 return 0x20 | bin2bcd(12);
207 if (hour == 0)
208 return bin2bcd(12);
209 return bin2bcd(hour);
210 }
211
212 static int rs5c372_rtc_read_time(struct device *dev, struct rtc_time *tm)
213 {
214 struct i2c_client *client = to_i2c_client(dev);
215 struct rs5c372 *rs5c = i2c_get_clientdata(client);
216 int status = rs5c_get_regs(rs5c);
217 unsigned char ctrl2 = rs5c->regs[RS5C_REG_CTRL2];
218
219 if (status < 0)
220 return status;
221
222 switch (rs5c->type) {
223 case rtc_r2025sd:
224 case rtc_r2221tl:
225 if ((rs5c->type == rtc_r2025sd && !(ctrl2 & R2x2x_CTRL2_XSTP)) ||
226 (rs5c->type == rtc_r2221tl && (ctrl2 & R2x2x_CTRL2_XSTP))) {
227 dev_warn(&client->dev, "rtc oscillator interruption detected. Please reset the rtc clock.\n");
228 return -EINVAL;
229 }
230 break;
231 default:
232 if (ctrl2 & RS5C_CTRL2_XSTP) {
233 dev_warn(&client->dev, "rtc oscillator interruption detected. Please reset the rtc clock.\n");
234 return -EINVAL;
235 }
236 }
237
238 tm->tm_sec = bcd2bin(rs5c->regs[RS5C372_REG_SECS] & 0x7f);
239 tm->tm_min = bcd2bin(rs5c->regs[RS5C372_REG_MINS] & 0x7f);
240 tm->tm_hour = rs5c_reg2hr(rs5c, rs5c->regs[RS5C372_REG_HOURS]);
241
242 tm->tm_wday = bcd2bin(rs5c->regs[RS5C372_REG_WDAY] & 0x07);
243 tm->tm_mday = bcd2bin(rs5c->regs[RS5C372_REG_DAY] & 0x3f);
244
245 /* tm->tm_mon is zero-based */
246 tm->tm_mon = bcd2bin(rs5c->regs[RS5C372_REG_MONTH] & 0x1f) - 1;
247
248 /* year is 1900 + tm->tm_year */
249 tm->tm_year = bcd2bin(rs5c->regs[RS5C372_REG_YEAR]) + 100;
250
251 dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
252 "mday=%d, mon=%d, year=%d, wday=%d\n",
253 __func__,
254 tm->tm_sec, tm->tm_min, tm->tm_hour,
255 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
256
257 return 0;
258 }
259
260 static int rs5c372_rtc_set_time(struct device *dev, struct rtc_time *tm)
261 {
262 struct i2c_client *client = to_i2c_client(dev);
263 struct rs5c372 *rs5c = i2c_get_clientdata(client);
264 unsigned char buf[7];
265 unsigned char ctrl2;
266 int addr;
267
268 dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d "
269 "mday=%d, mon=%d, year=%d, wday=%d\n",
270 __func__,
271 tm->tm_sec, tm->tm_min, tm->tm_hour,
272 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
273
274 addr = RS5C_ADDR(RS5C372_REG_SECS);
275 buf[0] = bin2bcd(tm->tm_sec);
276 buf[1] = bin2bcd(tm->tm_min);
277 buf[2] = rs5c_hr2reg(rs5c, tm->tm_hour);
278 buf[3] = bin2bcd(tm->tm_wday);
279 buf[4] = bin2bcd(tm->tm_mday);
280 buf[5] = bin2bcd(tm->tm_mon + 1);
281 buf[6] = bin2bcd(tm->tm_year - 100);
282
283 if (i2c_smbus_write_i2c_block_data(client, addr, sizeof(buf), buf) < 0) {
284 dev_dbg(&client->dev, "%s: write error in line %i\n",
285 __func__, __LINE__);
286 return -EIO;
287 }
288
289 addr = RS5C_ADDR(RS5C_REG_CTRL2);
290 ctrl2 = i2c_smbus_read_byte_data(client, addr);
291
292 /* clear rtc warning bits */
293 switch (rs5c->type) {
294 case rtc_r2025sd:
295 case rtc_r2221tl:
296 ctrl2 &= ~(R2x2x_CTRL2_VDET | R2x2x_CTRL2_PON);
297 if (rs5c->type == rtc_r2025sd)
298 ctrl2 |= R2x2x_CTRL2_XSTP;
299 else
300 ctrl2 &= ~R2x2x_CTRL2_XSTP;
301 break;
302 default:
303 ctrl2 &= ~RS5C_CTRL2_XSTP;
304 break;
305 }
306
307 if (i2c_smbus_write_byte_data(client, addr, ctrl2) < 0) {
308 dev_dbg(&client->dev, "%s: write error in line %i\n",
309 __func__, __LINE__);
310 return -EIO;
311 }
312
313 return 0;
314 }
315
316 #if IS_ENABLED(CONFIG_RTC_INTF_PROC)
317 #define NEED_TRIM
318 #endif
319
320 #if IS_ENABLED(CONFIG_RTC_INTF_SYSFS)
321 #define NEED_TRIM
322 #endif
323
324 #ifdef NEED_TRIM
325 static int rs5c372_get_trim(struct i2c_client *client, int *osc, int *trim)
326 {
327 struct rs5c372 *rs5c372 = i2c_get_clientdata(client);
328 u8 tmp = rs5c372->regs[RS5C372_REG_TRIM];
329
330 if (osc)
331 *osc = (tmp & RS5C372_TRIM_XSL) ? 32000 : 32768;
332
333 if (trim) {
334 dev_dbg(&client->dev, "%s: raw trim=%x\n", __func__, tmp);
335 tmp &= RS5C372_TRIM_MASK;
336 if (tmp & 0x3e) {
337 int t = tmp & 0x3f;
338
339 if (tmp & 0x40)
340 t = (~t | (s8)0xc0) + 1;
341 else
342 t = t - 1;
343
344 tmp = t * 2;
345 } else
346 tmp = 0;
347 *trim = tmp;
348 }
349
350 return 0;
351 }
352 #endif
353
354 static int rs5c_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
355 {
356 struct i2c_client *client = to_i2c_client(dev);
357 struct rs5c372 *rs5c = i2c_get_clientdata(client);
358 unsigned char buf;
359 int status, addr;
360
361 buf = rs5c->regs[RS5C_REG_CTRL1];
362
363 if (!rs5c->has_irq)
364 return -EINVAL;
365
366 status = rs5c_get_regs(rs5c);
367 if (status < 0)
368 return status;
369
370 addr = RS5C_ADDR(RS5C_REG_CTRL1);
371 if (enabled)
372 buf |= RS5C_CTRL1_AALE;
373 else
374 buf &= ~RS5C_CTRL1_AALE;
375
376 if (i2c_smbus_write_byte_data(client, addr, buf) < 0) {
377 dev_warn(dev, "can't update alarm\n");
378 status = -EIO;
379 } else
380 rs5c->regs[RS5C_REG_CTRL1] = buf;
381
382 return status;
383 }
384
385
386 /* NOTE: Since RTC_WKALM_{RD,SET} were originally defined for EFI,
387 * which only exposes a polled programming interface; and since
388 * these calls map directly to those EFI requests; we don't demand
389 * we have an IRQ for this chip when we go through this API.
390 *
391 * The older x86_pc derived RTC_ALM_{READ,SET} calls require irqs
392 * though, managed through RTC_AIE_{ON,OFF} requests.
393 */
394
395 static int rs5c_read_alarm(struct device *dev, struct rtc_wkalrm *t)
396 {
397 struct i2c_client *client = to_i2c_client(dev);
398 struct rs5c372 *rs5c = i2c_get_clientdata(client);
399 int status;
400
401 status = rs5c_get_regs(rs5c);
402 if (status < 0)
403 return status;
404
405 /* report alarm time */
406 t->time.tm_sec = 0;
407 t->time.tm_min = bcd2bin(rs5c->regs[RS5C_REG_ALARM_A_MIN] & 0x7f);
408 t->time.tm_hour = rs5c_reg2hr(rs5c, rs5c->regs[RS5C_REG_ALARM_A_HOURS]);
409
410 /* ... and status */
411 t->enabled = !!(rs5c->regs[RS5C_REG_CTRL1] & RS5C_CTRL1_AALE);
412 t->pending = !!(rs5c->regs[RS5C_REG_CTRL2] & RS5C_CTRL2_AAFG);
413
414 return 0;
415 }
416
417 static int rs5c_set_alarm(struct device *dev, struct rtc_wkalrm *t)
418 {
419 struct i2c_client *client = to_i2c_client(dev);
420 struct rs5c372 *rs5c = i2c_get_clientdata(client);
421 int status, addr, i;
422 unsigned char buf[3];
423
424 /* only handle up to 24 hours in the future, like RTC_ALM_SET */
425 if (t->time.tm_mday != -1
426 || t->time.tm_mon != -1
427 || t->time.tm_year != -1)
428 return -EINVAL;
429
430 /* REVISIT: round up tm_sec */
431
432 /* if needed, disable irq (clears pending status) */
433 status = rs5c_get_regs(rs5c);
434 if (status < 0)
435 return status;
436 if (rs5c->regs[RS5C_REG_CTRL1] & RS5C_CTRL1_AALE) {
437 addr = RS5C_ADDR(RS5C_REG_CTRL1);
438 buf[0] = rs5c->regs[RS5C_REG_CTRL1] & ~RS5C_CTRL1_AALE;
439 if (i2c_smbus_write_byte_data(client, addr, buf[0]) < 0) {
440 dev_dbg(dev, "can't disable alarm\n");
441 return -EIO;
442 }
443 rs5c->regs[RS5C_REG_CTRL1] = buf[0];
444 }
445
446 /* set alarm */
447 buf[0] = bin2bcd(t->time.tm_min);
448 buf[1] = rs5c_hr2reg(rs5c, t->time.tm_hour);
449 buf[2] = 0x7f; /* any/all days */
450
451 for (i = 0; i < sizeof(buf); i++) {
452 addr = RS5C_ADDR(RS5C_REG_ALARM_A_MIN + i);
453 if (i2c_smbus_write_byte_data(client, addr, buf[i]) < 0) {
454 dev_dbg(dev, "can't set alarm time\n");
455 return -EIO;
456 }
457 }
458
459 /* ... and maybe enable its irq */
460 if (t->enabled) {
461 addr = RS5C_ADDR(RS5C_REG_CTRL1);
462 buf[0] = rs5c->regs[RS5C_REG_CTRL1] | RS5C_CTRL1_AALE;
463 if (i2c_smbus_write_byte_data(client, addr, buf[0]) < 0)
464 dev_warn(dev, "can't enable alarm\n");
465 rs5c->regs[RS5C_REG_CTRL1] = buf[0];
466 }
467
468 return 0;
469 }
470
471 #if IS_ENABLED(CONFIG_RTC_INTF_PROC)
472
473 static int rs5c372_rtc_proc(struct device *dev, struct seq_file *seq)
474 {
475 int err, osc, trim;
476
477 err = rs5c372_get_trim(to_i2c_client(dev), &osc, &trim);
478 if (err == 0) {
479 seq_printf(seq, "crystal\t\t: %d.%03d KHz\n",
480 osc / 1000, osc % 1000);
481 seq_printf(seq, "trim\t\t: %d\n", trim);
482 }
483
484 return 0;
485 }
486
487 #else
488 #define rs5c372_rtc_proc NULL
489 #endif
490
491 static const struct rtc_class_ops rs5c372_rtc_ops = {
492 .proc = rs5c372_rtc_proc,
493 .read_time = rs5c372_rtc_read_time,
494 .set_time = rs5c372_rtc_set_time,
495 .read_alarm = rs5c_read_alarm,
496 .set_alarm = rs5c_set_alarm,
497 .alarm_irq_enable = rs5c_rtc_alarm_irq_enable,
498 };
499
500 #if IS_ENABLED(CONFIG_RTC_INTF_SYSFS)
501
502 static ssize_t rs5c372_sysfs_show_trim(struct device *dev,
503 struct device_attribute *attr, char *buf)
504 {
505 int err, trim;
506
507 err = rs5c372_get_trim(to_i2c_client(dev), NULL, &trim);
508 if (err)
509 return err;
510
511 return sprintf(buf, "%d\n", trim);
512 }
513 static DEVICE_ATTR(trim, S_IRUGO, rs5c372_sysfs_show_trim, NULL);
514
515 static ssize_t rs5c372_sysfs_show_osc(struct device *dev,
516 struct device_attribute *attr, char *buf)
517 {
518 int err, osc;
519
520 err = rs5c372_get_trim(to_i2c_client(dev), &osc, NULL);
521 if (err)
522 return err;
523
524 return sprintf(buf, "%d.%03d KHz\n", osc / 1000, osc % 1000);
525 }
526 static DEVICE_ATTR(osc, S_IRUGO, rs5c372_sysfs_show_osc, NULL);
527
528 static int rs5c_sysfs_register(struct device *dev)
529 {
530 int err;
531
532 err = device_create_file(dev, &dev_attr_trim);
533 if (err)
534 return err;
535 err = device_create_file(dev, &dev_attr_osc);
536 if (err)
537 device_remove_file(dev, &dev_attr_trim);
538
539 return err;
540 }
541
542 static void rs5c_sysfs_unregister(struct device *dev)
543 {
544 device_remove_file(dev, &dev_attr_trim);
545 device_remove_file(dev, &dev_attr_osc);
546 }
547
548 #else
549 static int rs5c_sysfs_register(struct device *dev)
550 {
551 return 0;
552 }
553
554 static void rs5c_sysfs_unregister(struct device *dev)
555 {
556 /* nothing */
557 }
558 #endif /* SYSFS */
559
560 static struct i2c_driver rs5c372_driver;
561
562 static int rs5c_oscillator_setup(struct rs5c372 *rs5c372)
563 {
564 unsigned char buf[2];
565 int addr, i, ret = 0;
566
567 addr = RS5C_ADDR(RS5C_REG_CTRL1);
568 buf[0] = rs5c372->regs[RS5C_REG_CTRL1];
569 buf[1] = rs5c372->regs[RS5C_REG_CTRL2];
570
571 switch (rs5c372->type) {
572 case rtc_r2025sd:
573 if (buf[1] & R2x2x_CTRL2_XSTP)
574 return ret;
575 break;
576 case rtc_r2221tl:
577 if (!(buf[1] & R2x2x_CTRL2_XSTP))
578 return ret;
579 break;
580 default:
581 if (!(buf[1] & RS5C_CTRL2_XSTP))
582 return ret;
583 break;
584 }
585
586 /* use 24hr mode */
587 switch (rs5c372->type) {
588 case rtc_rs5c372a:
589 case rtc_rs5c372b:
590 buf[1] |= RS5C372_CTRL2_24;
591 rs5c372->time24 = 1;
592 break;
593 case rtc_r2025sd:
594 case rtc_r2221tl:
595 case rtc_rv5c386:
596 case rtc_rv5c387a:
597 buf[0] |= RV5C387_CTRL1_24;
598 rs5c372->time24 = 1;
599 break;
600 default:
601 /* impossible */
602 break;
603 }
604
605 for (i = 0; i < sizeof(buf); i++) {
606 addr = RS5C_ADDR(RS5C_REG_CTRL1 + i);
607 ret = i2c_smbus_write_byte_data(rs5c372->client, addr, buf[i]);
608 if (unlikely(ret < 0))
609 return ret;
610 }
611
612 rs5c372->regs[RS5C_REG_CTRL1] = buf[0];
613 rs5c372->regs[RS5C_REG_CTRL2] = buf[1];
614
615 return 0;
616 }
617
618 static int rs5c372_probe(struct i2c_client *client,
619 const struct i2c_device_id *id)
620 {
621 int err = 0;
622 int smbus_mode = 0;
623 struct rs5c372 *rs5c372;
624
625 dev_dbg(&client->dev, "%s\n", __func__);
626
627 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
628 I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) {
629 /*
630 * If we don't have any master mode adapter, try breaking
631 * it down in to the barest of capabilities.
632 */
633 if (i2c_check_functionality(client->adapter,
634 I2C_FUNC_SMBUS_BYTE_DATA |
635 I2C_FUNC_SMBUS_I2C_BLOCK))
636 smbus_mode = 1;
637 else {
638 /* Still no good, give up */
639 err = -ENODEV;
640 goto exit;
641 }
642 }
643
644 rs5c372 = devm_kzalloc(&client->dev, sizeof(struct rs5c372),
645 GFP_KERNEL);
646 if (!rs5c372) {
647 err = -ENOMEM;
648 goto exit;
649 }
650
651 rs5c372->client = client;
652 i2c_set_clientdata(client, rs5c372);
653 if (client->dev.of_node)
654 rs5c372->type = (enum rtc_type)
655 of_device_get_match_data(&client->dev);
656 else
657 rs5c372->type = id->driver_data;
658
659 /* we read registers 0x0f then 0x00-0x0f; skip the first one */
660 rs5c372->regs = &rs5c372->buf[1];
661 rs5c372->smbus = smbus_mode;
662
663 err = rs5c_get_regs(rs5c372);
664 if (err < 0)
665 goto exit;
666
667 /* clock may be set for am/pm or 24 hr time */
668 switch (rs5c372->type) {
669 case rtc_rs5c372a:
670 case rtc_rs5c372b:
671 /* alarm uses ALARM_A; and nINTRA on 372a, nINTR on 372b.
672 * so does periodic irq, except some 327a modes.
673 */
674 if (rs5c372->regs[RS5C_REG_CTRL2] & RS5C372_CTRL2_24)
675 rs5c372->time24 = 1;
676 break;
677 case rtc_r2025sd:
678 case rtc_r2221tl:
679 case rtc_rv5c386:
680 case rtc_rv5c387a:
681 if (rs5c372->regs[RS5C_REG_CTRL1] & RV5C387_CTRL1_24)
682 rs5c372->time24 = 1;
683 /* alarm uses ALARM_W; and nINTRB for alarm and periodic
684 * irq, on both 386 and 387
685 */
686 break;
687 default:
688 dev_err(&client->dev, "unknown RTC type\n");
689 goto exit;
690 }
691
692 /* if the oscillator lost power and no other software (like
693 * the bootloader) set it up, do it here.
694 *
695 * The R2025S/D does this a little differently than the other
696 * parts, so we special case that..
697 */
698 err = rs5c_oscillator_setup(rs5c372);
699 if (unlikely(err < 0)) {
700 dev_err(&client->dev, "setup error\n");
701 goto exit;
702 }
703
704 dev_info(&client->dev, "%s found, %s\n",
705 ({ char *s; switch (rs5c372->type) {
706 case rtc_r2025sd: s = "r2025sd"; break;
707 case rtc_r2221tl: s = "r2221tl"; break;
708 case rtc_rs5c372a: s = "rs5c372a"; break;
709 case rtc_rs5c372b: s = "rs5c372b"; break;
710 case rtc_rv5c386: s = "rv5c386"; break;
711 case rtc_rv5c387a: s = "rv5c387a"; break;
712 default: s = "chip"; break;
713 }; s;}),
714 rs5c372->time24 ? "24hr" : "am/pm"
715 );
716
717 /* REVISIT use client->irq to register alarm irq ... */
718 rs5c372->rtc = devm_rtc_device_register(&client->dev,
719 rs5c372_driver.driver.name,
720 &rs5c372_rtc_ops, THIS_MODULE);
721
722 if (IS_ERR(rs5c372->rtc)) {
723 err = PTR_ERR(rs5c372->rtc);
724 goto exit;
725 }
726
727 err = rs5c_sysfs_register(&client->dev);
728 if (err)
729 goto exit;
730
731 return 0;
732
733 exit:
734 return err;
735 }
736
737 static int rs5c372_remove(struct i2c_client *client)
738 {
739 rs5c_sysfs_unregister(&client->dev);
740 return 0;
741 }
742
743 static struct i2c_driver rs5c372_driver = {
744 .driver = {
745 .name = "rtc-rs5c372",
746 .of_match_table = of_match_ptr(rs5c372_of_match),
747 },
748 .probe = rs5c372_probe,
749 .remove = rs5c372_remove,
750 .id_table = rs5c372_id,
751 };
752
753 module_i2c_driver(rs5c372_driver);
754
755 MODULE_AUTHOR(
756 "Pavel Mironchik <pmironchik@optifacio.net>, "
757 "Alessandro Zummo <a.zummo@towertech.it>, "
758 "Paul Mundt <lethal@linux-sh.org>");
759 MODULE_DESCRIPTION("Ricoh RS5C372 RTC driver");
760 MODULE_LICENSE("GPL");
Linux with added FPC-III support