1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/kernel.h>
22#include <linux/module.h>
23#include <linux/init.h>
24#include <linux/bcd.h>
25#include <linux/i2c.h>
26#include <linux/list.h>
27#include <linux/rtc.h>
28
29
30#define RX8025_REG_SEC 0x00
31#define RX8025_REG_MIN 0x01
32#define RX8025_REG_HOUR 0x02
33#define RX8025_REG_WDAY 0x03
34#define RX8025_REG_MDAY 0x04
35#define RX8025_REG_MONTH 0x05
36#define RX8025_REG_YEAR 0x06
37#define RX8025_REG_DIGOFF 0x07
38#define RX8025_REG_ALWMIN 0x08
39#define RX8025_REG_ALWHOUR 0x09
40#define RX8025_REG_ALWWDAY 0x0a
41#define RX8025_REG_ALDMIN 0x0b
42#define RX8025_REG_ALDHOUR 0x0c
43
44#define RX8025_REG_CTRL1 0x0e
45#define RX8025_REG_CTRL2 0x0f
46
47#define RX8025_BIT_CTRL1_CT (7 << 0)
48
49#define RX8025_BIT_CTRL1_CT_1HZ 4
50#define RX8025_BIT_CTRL1_TEST (1 << 3)
51#define RX8025_BIT_CTRL1_1224 (1 << 5)
52#define RX8025_BIT_CTRL1_DALE (1 << 6)
53#define RX8025_BIT_CTRL1_WALE (1 << 7)
54
55#define RX8025_BIT_CTRL2_DAFG (1 << 0)
56#define RX8025_BIT_CTRL2_WAFG (1 << 1)
57#define RX8025_BIT_CTRL2_CTFG (1 << 2)
58#define RX8025_BIT_CTRL2_PON (1 << 4)
59#define RX8025_BIT_CTRL2_XST (1 << 5)
60#define RX8025_BIT_CTRL2_VDET (1 << 6)
61
62
63#define RX8025_ADJ_RESOLUTION 3050
64#define RX8025_ADJ_DATA_MAX 62
65#define RX8025_ADJ_DATA_MIN -62
66
67static const struct i2c_device_id rx8025_id[] = {
68 { "rx8025", 0 },
69 { }
70};
71MODULE_DEVICE_TABLE(i2c, rx8025_id);
72
73struct rx8025_data {
74 struct i2c_client *client;
75 struct rtc_device *rtc;
76 struct work_struct work;
77 u8 ctrl1;
78 unsigned exiting:1;
79};
80
81static int rx8025_read_reg(struct i2c_client *client, int number, u8 *value)
82{
83 int ret = i2c_smbus_read_byte_data(client, (number << 4) | 0x08);
84
85 if (ret < 0) {
86 dev_err(&client->dev, "Unable to read register #%d\n", number);
87 return ret;
88 }
89
90 *value = ret;
91 return 0;
92}
93
94static int rx8025_read_regs(struct i2c_client *client,
95 int number, u8 length, u8 *values)
96{
97 int ret = i2c_smbus_read_i2c_block_data(client, (number << 4) | 0x08,
98 length, values);
99
100 if (ret != length) {
101 dev_err(&client->dev, "Unable to read registers #%d..#%d\n",
102 number, number + length - 1);
103 return ret < 0 ? ret : -EIO;
104 }
105
106 return 0;
107}
108
109static int rx8025_write_reg(struct i2c_client *client, int number, u8 value)
110{
111 int ret = i2c_smbus_write_byte_data(client, number << 4, value);
112
113 if (ret)
114 dev_err(&client->dev, "Unable to write register #%d\n",
115 number);
116
117 return ret;
118}
119
120static int rx8025_write_regs(struct i2c_client *client,
121 int number, u8 length, u8 *values)
122{
123 int ret = i2c_smbus_write_i2c_block_data(client, (number << 4) | 0x08,
124 length, values);
125
126 if (ret)
127 dev_err(&client->dev, "Unable to write registers #%d..#%d\n",
128 number, number + length - 1);
129
130 return ret;
131}
132
133static irqreturn_t rx8025_irq(int irq, void *dev_id)
134{
135 struct i2c_client *client = dev_id;
136 struct rx8025_data *rx8025 = i2c_get_clientdata(client);
137
138 disable_irq_nosync(irq);
139 schedule_work(&rx8025->work);
140 return IRQ_HANDLED;
141}
142
143static void rx8025_work(struct work_struct *work)
144{
145 struct rx8025_data *rx8025 = container_of(work, struct rx8025_data,
146 work);
147 struct i2c_client *client = rx8025->client;
148 struct mutex *lock = &rx8025->rtc->ops_lock;
149 u8 status;
150
151 mutex_lock(lock);
152
153 if (rx8025_read_reg(client, RX8025_REG_CTRL2, &status))
154 goto out;
155
156 if (!(status & RX8025_BIT_CTRL2_XST))
157 dev_warn(&client->dev, "Oscillation stop was detected,"
158 "you may have to readjust the clock\n");
159
160 if (status & RX8025_BIT_CTRL2_CTFG) {
161
162 status &= ~RX8025_BIT_CTRL2_CTFG;
163 local_irq_disable();
164 rtc_update_irq(rx8025->rtc, 1, RTC_PF | RTC_IRQF);
165 local_irq_enable();
166 }
167
168 if (status & RX8025_BIT_CTRL2_DAFG) {
169
170 status &= RX8025_BIT_CTRL2_DAFG;
171 if (rx8025_write_reg(client, RX8025_REG_CTRL1,
172 rx8025->ctrl1 & ~RX8025_BIT_CTRL1_DALE))
173 goto out;
174 local_irq_disable();
175 rtc_update_irq(rx8025->rtc, 1, RTC_AF | RTC_IRQF);
176 local_irq_enable();
177 }
178
179
180 rx8025_write_reg(client, RX8025_REG_CTRL2,
181 status | RX8025_BIT_CTRL2_XST);
182
183out:
184 if (!rx8025->exiting)
185 enable_irq(client->irq);
186
187 mutex_unlock(lock);
188}
189
190static int rx8025_get_time(struct device *dev, struct rtc_time *dt)
191{
192 struct rx8025_data *rx8025 = dev_get_drvdata(dev);
193 u8 date[7];
194 int err;
195
196 err = rx8025_read_regs(rx8025->client, RX8025_REG_SEC, 7, date);
197 if (err)
198 return err;
199
200 dev_dbg(dev, "%s: read 0x%02x 0x%02x "
201 "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n", __func__,
202 date[0], date[1], date[2], date[3], date[4],
203 date[5], date[6]);
204
205 dt->tm_sec = bcd2bin(date[RX8025_REG_SEC] & 0x7f);
206 dt->tm_min = bcd2bin(date[RX8025_REG_MIN] & 0x7f);
207 if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
208 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x3f);
209 else
210 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x1f) % 12
211 + (date[RX8025_REG_HOUR] & 0x20 ? 12 : 0);
212
213 dt->tm_mday = bcd2bin(date[RX8025_REG_MDAY] & 0x3f);
214 dt->tm_mon = bcd2bin(date[RX8025_REG_MONTH] & 0x1f) - 1;
215 dt->tm_year = bcd2bin(date[RX8025_REG_YEAR]);
216
217 if (dt->tm_year < 70)
218 dt->tm_year += 100;
219
220 dev_dbg(dev, "%s: date %ds %dm %dh %dmd %dm %dy\n", __func__,
221 dt->tm_sec, dt->tm_min, dt->tm_hour,
222 dt->tm_mday, dt->tm_mon, dt->tm_year);
223
224 return rtc_valid_tm(dt);
225}
226
227static int rx8025_set_time(struct device *dev, struct rtc_time *dt)
228{
229 struct rx8025_data *rx8025 = dev_get_drvdata(dev);
230 u8 date[7];
231
232
233
234
235
236
237
238
239
240
241
242 date[RX8025_REG_SEC] = bin2bcd(dt->tm_sec);
243 date[RX8025_REG_MIN] = bin2bcd(dt->tm_min);
244 if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
245 date[RX8025_REG_HOUR] = bin2bcd(dt->tm_hour);
246 else
247 date[RX8025_REG_HOUR] = (dt->tm_hour >= 12 ? 0x20 : 0)
248 | bin2bcd((dt->tm_hour + 11) % 12 + 1);
249
250 date[RX8025_REG_WDAY] = bin2bcd(dt->tm_wday);
251 date[RX8025_REG_MDAY] = bin2bcd(dt->tm_mday);
252 date[RX8025_REG_MONTH] = bin2bcd(dt->tm_mon + 1);
253 date[RX8025_REG_YEAR] = bin2bcd(dt->tm_year % 100);
254
255 dev_dbg(dev,
256 "%s: write 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
257 __func__,
258 date[0], date[1], date[2], date[3], date[4], date[5], date[6]);
259
260 return rx8025_write_regs(rx8025->client, RX8025_REG_SEC, 7, date);
261}
262
263static int rx8025_init_client(struct i2c_client *client, int *need_reset)
264{
265 struct rx8025_data *rx8025 = i2c_get_clientdata(client);
266 u8 ctrl[2], ctrl2;
267 int need_clear = 0;
268 int err;
269
270 err = rx8025_read_regs(rx8025->client, RX8025_REG_CTRL1, 2, ctrl);
271 if (err)
272 goto out;
273
274
275 rx8025->ctrl1 = ctrl[0] & ~RX8025_BIT_CTRL1_TEST;
276
277 if (ctrl[1] & RX8025_BIT_CTRL2_PON) {
278 dev_warn(&client->dev, "power-on reset was detected, "
279 "you may have to readjust the clock\n");
280 *need_reset = 1;
281 }
282
283 if (ctrl[1] & RX8025_BIT_CTRL2_VDET) {
284 dev_warn(&client->dev, "a power voltage drop was detected, "
285 "you may have to readjust the clock\n");
286 *need_reset = 1;
287 }
288
289 if (!(ctrl[1] & RX8025_BIT_CTRL2_XST)) {
290 dev_warn(&client->dev, "Oscillation stop was detected,"
291 "you may have to readjust the clock\n");
292 *need_reset = 1;
293 }
294
295 if (ctrl[1] & (RX8025_BIT_CTRL2_DAFG | RX8025_BIT_CTRL2_WAFG)) {
296 dev_warn(&client->dev, "Alarm was detected\n");
297 need_clear = 1;
298 }
299
300 if (!(ctrl[1] & RX8025_BIT_CTRL2_CTFG))
301 need_clear = 1;
302
303 if (*need_reset || need_clear) {
304 ctrl2 = ctrl[0];
305 ctrl2 &= ~(RX8025_BIT_CTRL2_PON | RX8025_BIT_CTRL2_VDET |
306 RX8025_BIT_CTRL2_CTFG | RX8025_BIT_CTRL2_WAFG |
307 RX8025_BIT_CTRL2_DAFG);
308 ctrl2 |= RX8025_BIT_CTRL2_XST;
309
310 err = rx8025_write_reg(client, RX8025_REG_CTRL2, ctrl2);
311 }
312out:
313 return err;
314}
315
316
317static int rx8025_read_alarm(struct device *dev, struct rtc_wkalrm *t)
318{
319 struct rx8025_data *rx8025 = dev_get_drvdata(dev);
320 struct i2c_client *client = rx8025->client;
321 u8 ctrl2, ald[2];
322 int err;
323
324 if (client->irq <= 0)
325 return -EINVAL;
326
327 err = rx8025_read_regs(client, RX8025_REG_ALDMIN, 2, ald);
328 if (err)
329 return err;
330
331 err = rx8025_read_reg(client, RX8025_REG_CTRL2, &ctrl2);
332 if (err)
333 return err;
334
335 dev_dbg(dev, "%s: read alarm 0x%02x 0x%02x ctrl2 %02x\n",
336 __func__, ald[0], ald[1], ctrl2);
337
338
339 t->time.tm_sec = 0;
340 t->time.tm_min = bcd2bin(ald[0] & 0x7f);
341 if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
342 t->time.tm_hour = bcd2bin(ald[1] & 0x3f);
343 else
344 t->time.tm_hour = bcd2bin(ald[1] & 0x1f) % 12
345 + (ald[1] & 0x20 ? 12 : 0);
346
347 t->time.tm_wday = -1;
348 t->time.tm_mday = -1;
349 t->time.tm_mon = -1;
350 t->time.tm_year = -1;
351
352 dev_dbg(dev, "%s: date: %ds %dm %dh %dmd %dm %dy\n",
353 __func__,
354 t->time.tm_sec, t->time.tm_min, t->time.tm_hour,
355 t->time.tm_mday, t->time.tm_mon, t->time.tm_year);
356 t->enabled = !!(rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE);
357 t->pending = (ctrl2 & RX8025_BIT_CTRL2_DAFG) && t->enabled;
358
359 return err;
360}
361
362static int rx8025_set_alarm(struct device *dev, struct rtc_wkalrm *t)
363{
364 struct i2c_client *client = to_i2c_client(dev);
365 struct rx8025_data *rx8025 = dev_get_drvdata(dev);
366 u8 ald[2];
367 int err;
368
369 if (client->irq <= 0)
370 return -EINVAL;
371
372
373 ald[0] = bin2bcd(t->time.tm_min);
374 if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
375 ald[1] = bin2bcd(t->time.tm_hour);
376 else
377 ald[1] = (t->time.tm_hour >= 12 ? 0x20 : 0)
378 | bin2bcd((t->time.tm_hour + 11) % 12 + 1);
379
380 dev_dbg(dev, "%s: write 0x%02x 0x%02x\n", __func__, ald[0], ald[1]);
381
382 if (rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE) {
383 rx8025->ctrl1 &= ~RX8025_BIT_CTRL1_DALE;
384 err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1,
385 rx8025->ctrl1);
386 if (err)
387 return err;
388 }
389 err = rx8025_write_regs(rx8025->client, RX8025_REG_ALDMIN, 2, ald);
390 if (err)
391 return err;
392
393 if (t->enabled) {
394 rx8025->ctrl1 |= RX8025_BIT_CTRL1_DALE;
395 err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1,
396 rx8025->ctrl1);
397 if (err)
398 return err;
399 }
400
401 return 0;
402}
403
404static int rx8025_alarm_irq_enable(struct device *dev, unsigned int enabled)
405{
406 struct rx8025_data *rx8025 = dev_get_drvdata(dev);
407 u8 ctrl1;
408 int err;
409
410 ctrl1 = rx8025->ctrl1;
411 if (enabled)
412 ctrl1 |= RX8025_BIT_CTRL1_DALE;
413 else
414 ctrl1 &= ~RX8025_BIT_CTRL1_DALE;
415
416 if (ctrl1 != rx8025->ctrl1) {
417 rx8025->ctrl1 = ctrl1;
418 err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1,
419 rx8025->ctrl1);
420 if (err)
421 return err;
422 }
423 return 0;
424}
425
426static int rx8025_irq_set_state(struct device *dev, int enabled)
427{
428 struct i2c_client *client = to_i2c_client(dev);
429 struct rx8025_data *rx8025 = i2c_get_clientdata(client);
430 int ctrl1;
431 int err;
432
433 if (client->irq <= 0)
434 return -ENXIO;
435
436 ctrl1 = rx8025->ctrl1 & ~RX8025_BIT_CTRL1_CT;
437 if (enabled)
438 ctrl1 |= RX8025_BIT_CTRL1_CT_1HZ;
439 if (ctrl1 != rx8025->ctrl1) {
440 rx8025->ctrl1 = ctrl1;
441 err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1,
442 rx8025->ctrl1);
443 if (err)
444 return err;
445 }
446
447 return 0;
448}
449
450static struct rtc_class_ops rx8025_rtc_ops = {
451 .read_time = rx8025_get_time,
452 .set_time = rx8025_set_time,
453 .read_alarm = rx8025_read_alarm,
454 .set_alarm = rx8025_set_alarm,
455 .alarm_irq_enable = rx8025_alarm_irq_enable,
456 .irq_set_state = rx8025_irq_set_state,
457};
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476static int rx8025_get_clock_adjust(struct device *dev, int *adj)
477{
478 struct i2c_client *client = to_i2c_client(dev);
479 u8 digoff;
480 int err;
481
482 err = rx8025_read_reg(client, RX8025_REG_DIGOFF, &digoff);
483 if (err)
484 return err;
485
486 *adj = digoff >= 64 ? digoff - 128 : digoff;
487 if (*adj > 0)
488 (*adj)--;
489 *adj *= -RX8025_ADJ_RESOLUTION;
490
491 return 0;
492}
493
494static int rx8025_set_clock_adjust(struct device *dev, int adj)
495{
496 struct i2c_client *client = to_i2c_client(dev);
497 u8 digoff;
498 int err;
499
500 adj /= -RX8025_ADJ_RESOLUTION;
501 if (adj > RX8025_ADJ_DATA_MAX)
502 adj = RX8025_ADJ_DATA_MAX;
503 else if (adj < RX8025_ADJ_DATA_MIN)
504 adj = RX8025_ADJ_DATA_MIN;
505 else if (adj > 0)
506 adj++;
507 else if (adj < 0)
508 adj += 128;
509 digoff = adj;
510
511 err = rx8025_write_reg(client, RX8025_REG_DIGOFF, digoff);
512 if (err)
513 return err;
514
515 dev_dbg(dev, "%s: write 0x%02x\n", __func__, digoff);
516
517 return 0;
518}
519
520static ssize_t rx8025_sysfs_show_clock_adjust(struct device *dev,
521 struct device_attribute *attr,
522 char *buf)
523{
524 int err, adj;
525
526 err = rx8025_get_clock_adjust(dev, &adj);
527 if (err)
528 return err;
529
530 return sprintf(buf, "%d\n", adj);
531}
532
533static ssize_t rx8025_sysfs_store_clock_adjust(struct device *dev,
534 struct device_attribute *attr,
535 const char *buf, size_t count)
536{
537 int adj, err;
538
539 if (sscanf(buf, "%i", &adj) != 1)
540 return -EINVAL;
541
542 err = rx8025_set_clock_adjust(dev, adj);
543
544 return err ? err : count;
545}
546
547static DEVICE_ATTR(clock_adjust_ppb, S_IRUGO | S_IWUSR,
548 rx8025_sysfs_show_clock_adjust,
549 rx8025_sysfs_store_clock_adjust);
550
551static int rx8025_sysfs_register(struct device *dev)
552{
553 return device_create_file(dev, &dev_attr_clock_adjust_ppb);
554}
555
556static void rx8025_sysfs_unregister(struct device *dev)
557{
558 device_remove_file(dev, &dev_attr_clock_adjust_ppb);
559}
560
561static int __devinit rx8025_probe(struct i2c_client *client,
562 const struct i2c_device_id *id)
563{
564 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
565 struct rx8025_data *rx8025;
566 int err, need_reset = 0;
567
568 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
569 | I2C_FUNC_SMBUS_I2C_BLOCK)) {
570 dev_err(&adapter->dev,
571 "doesn't support required functionality\n");
572 err = -EIO;
573 goto errout;
574 }
575
576 rx8025 = kzalloc(sizeof(*rx8025), GFP_KERNEL);
577 if (!rx8025) {
578 dev_err(&adapter->dev, "failed to alloc memory\n");
579 err = -ENOMEM;
580 goto errout;
581 }
582
583 rx8025->client = client;
584 i2c_set_clientdata(client, rx8025);
585 INIT_WORK(&rx8025->work, rx8025_work);
586
587 err = rx8025_init_client(client, &need_reset);
588 if (err)
589 goto errout_free;
590
591 if (need_reset) {
592 struct rtc_time tm;
593 dev_info(&client->dev,
594 "bad conditions detected, resetting date\n");
595 rtc_time_to_tm(0, &tm);
596 rx8025_set_time(&client->dev, &tm);
597 }
598
599 rx8025->rtc = rtc_device_register(client->name, &client->dev,
600 &rx8025_rtc_ops, THIS_MODULE);
601 if (IS_ERR(rx8025->rtc)) {
602 err = PTR_ERR(rx8025->rtc);
603 dev_err(&client->dev, "unable to register the class device\n");
604 goto errout_free;
605 }
606
607 if (client->irq > 0) {
608 dev_info(&client->dev, "IRQ %d supplied\n", client->irq);
609 err = request_irq(client->irq, rx8025_irq,
610 0, "rx8025", client);
611 if (err) {
612 dev_err(&client->dev, "unable to request IRQ\n");
613 goto errout_reg;
614 }
615 }
616
617 rx8025->rtc->irq_freq = 1;
618 rx8025->rtc->max_user_freq = 1;
619
620 err = rx8025_sysfs_register(&client->dev);
621 if (err)
622 goto errout_irq;
623
624 return 0;
625
626errout_irq:
627 if (client->irq > 0)
628 free_irq(client->irq, client);
629
630errout_reg:
631 rtc_device_unregister(rx8025->rtc);
632
633errout_free:
634 i2c_set_clientdata(client, NULL);
635 kfree(rx8025);
636
637errout:
638 dev_err(&adapter->dev, "probing for rx8025 failed\n");
639 return err;
640}
641
642static int __devexit rx8025_remove(struct i2c_client *client)
643{
644 struct rx8025_data *rx8025 = i2c_get_clientdata(client);
645 struct mutex *lock = &rx8025->rtc->ops_lock;
646
647 if (client->irq > 0) {
648 mutex_lock(lock);
649 rx8025->exiting = 1;
650 mutex_unlock(lock);
651
652 free_irq(client->irq, client);
653 flush_scheduled_work();
654 }
655
656 rx8025_sysfs_unregister(&client->dev);
657 rtc_device_unregister(rx8025->rtc);
658 i2c_set_clientdata(client, NULL);
659 kfree(rx8025);
660 return 0;
661}
662
663static struct i2c_driver rx8025_driver = {
664 .driver = {
665 .name = "rtc-rx8025",
666 .owner = THIS_MODULE,
667 },
668 .probe = rx8025_probe,
669 .remove = __devexit_p(rx8025_remove),
670 .id_table = rx8025_id,
671};
672
673static int __init rx8025_init(void)
674{
675 return i2c_add_driver(&rx8025_driver);
676}
677
678static void __exit rx8025_exit(void)
679{
680 i2c_del_driver(&rx8025_driver);
681}
682
683MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
684MODULE_DESCRIPTION("RX-8025 SA/NB RTC driver");
685MODULE_LICENSE("GPL");
686
687module_init(rx8025_init);
688module_exit(rx8025_exit);
689
