2 * drivers/rtc/rtc-ricoh619.c
4 * Real time clock driver for RICOH RC5T619 power management chip.
6 * Copyright (C) 2012-2013 RICOH COMPANY,LTD
9 * Copyright (C) 2011 NVIDIA Corporation
11 * this program is free software; you can redistribute it and/or modify
12 * it under the terms of the gnu general public license as published by
13 * the free software foundation; either version 2 of the license, or
14 * (at your option) any later version.
16 * this program is distributed in the hope that it will be useful, but without
17 * any warranty; without even the implied warranty of merchantability or
18 * fitness for a particular purpose. see the gnu general public license for
21 * you should have received a copy of the gnu general public license
22 * along with this program. If not, see <http://www.gnu.org/licenses/>.
27 /* #define verbose_debug 1 */
29 #include <linux/device.h>
30 #include <linux/err.h>
31 #include <linux/init.h>
32 #include <linux/kernel.h>
33 #include <linux/mfd/ricoh619.h>
34 #include <linux/rtc/rtc-ricoh619.h>
35 #include <linux/platform_device.h>
36 #include <linux/rtc.h>
37 #include <linux/slab.h>
41 struct rtc_device *rtc;
45 static int ricoh619_read_regs(struct device *dev, int reg, int len,
50 ret = ricoh619_bulk_reads(dev->parent, reg, len, val);
52 dev_err(dev->parent, "\n %s failed reading from 0x%02x\n",
59 static int ricoh619_write_regs(struct device *dev, int reg, int len,
63 ret = ricoh619_bulk_writes(dev->parent, reg, len, val);
65 dev_err(dev->parent, "\n %s failed writing\n", __func__);
72 // 0=OK, -EINVAL= FAIL
73 static int ricoh619_rtc_valid_tm(struct device *dev, struct rtc_time *tm)
75 if (tm->tm_year > 199 || tm->tm_year < 70
76 || tm->tm_mon > 11 || tm->tm_mon < 0
78 || tm->tm_mday > rtc_month_days(tm->tm_mon, tm->tm_year + os_ref_year)
79 || tm->tm_hour >= 24 || tm->tm_hour <0
80 || tm->tm_min < 0 || tm->tm_min >= 60
81 || tm->tm_sec < 0 || tm->tm_sec >= 60
84 dev_err(dev->parent, "PMU: %s *** Returning error due to time, %d/%d/%d %d:%d:%d *****\n",
85 __func__, tm->tm_mon, tm->tm_mday, tm->tm_year, tm->tm_hour, tm->tm_min, tm->tm_sec);
93 static u8 dec2bcd(u8 dec)
95 return ((dec/10)<<4)+(dec%10);
98 static u8 bcd2dec(u8 bcd)
100 return (bcd >> 4)*10+(bcd & 0xf);
103 static void convert_bcd_to_decimal(u8 *buf, u8 len)
106 for (i = 0; i < len; i++)
107 buf[i] = bcd2dec(buf[i]);
110 static void convert_decimal_to_bcd(u8 *buf, u8 len)
113 for (i = 0; i < len; i++)
114 buf[i] = dec2bcd(buf[i]);
117 static void print_time(struct device *dev, struct rtc_time *tm)
119 dev_info(dev, "PMU: %s *** rtc-time : %d/%d/%d %d:%d:%d *****\n",
120 __func__, (tm->tm_mon), tm->tm_mday, (tm->tm_year + os_ref_year), tm->tm_hour, tm->tm_min,tm->tm_sec);
123 static int ricoh619_rtc_periodic_disable(struct device *dev)
129 err = ricoh619_read_regs(dev, rtc_ctrl1, 1, ®_data);
132 dev_err(dev->parent, "read rtc_ctrl1 error=0x%x\n", err);
136 err = ricoh619_write_regs(dev, rtc_ctrl1, 1, ®_data);
139 dev_err(dev->parent, "read rtc_ctrl1 error=0x%x\n", err);
143 // clear alarm flag and CTFG
144 err = ricoh619_read_regs(dev, rtc_ctrl2, 1, ®_data);
147 dev_err(dev->parent, "read rtc_ctrl1 error=0x%x\n", err);
150 reg_data &= ~0x85;// 1000-0101
151 err = ricoh619_write_regs(dev, rtc_ctrl2, 1, ®_data);
154 dev_err(dev->parent, "read rtc_ctrl1 error=0x%x\n", err);
161 static int ricoh619_rtc_clk_adjust(struct device *dev, uint8_t clk)
163 return ricoh619_write_regs(dev, rtc_adjust, 1, &clk);
166 static int ricoh619_rtc_Pon_get_clr(struct device *dev, uint8_t *Pon_f)
171 err = ricoh619_read_regs(dev, rtc_ctrl2, 1, ®_data);
174 dev_err(dev->parent, "rtc_ctrl1 read err=0x%x\n", err);
177 // printk("%s,PON=1 -- CTRL2=0x%x\n", __func__, reg_data);
183 reg_data &= ~0x5b;// 0101-1011
184 reg_data |= 0x20; // 0010-0000
185 err = ricoh619_write_regs(dev, rtc_ctrl2, 1, ®_data);
188 dev_err(dev->parent, "rtc_ctrl1 write err=0x%x\n", err);
200 // 0-12hour, 1-24hour
201 static int ricoh619_rtc_hour_mode_get(struct device *dev, int *mode)
205 err = ricoh619_read_regs(dev, rtc_ctrl1, 1, mode);
207 dev_err(dev->parent, "read rtc ctrl1 error\n");
217 // 0-12hour, 1-24hour
218 static int ricoh619_rtc_hour_mode_set(struct device *dev, int mode)
223 err = ricoh619_read_regs(dev, rtc_ctrl1, 1, ®_data);
226 dev_err(dev->parent, "read rtc_ctrl1 error\n");
233 err = ricoh619_write_regs(dev, rtc_ctrl1, 1, ®_data);
236 dev_err(dev->parent, "write rtc_ctrl1 error\n");
243 static int ricoh619_rtc_read_time(struct device *dev, struct rtc_time *tm)
250 // printk(KERN_INFO "PMU: %s\n", __func__);
251 err = ricoh619_read_regs(dev, rtc_seconds_reg, sizeof(buff), buff);
254 dev_err(dev->parent, "PMU: %s *** failed to read time *****\n", __func__);
263 buff[5] = buff[5]&0x1f; //bit5 19_20
264 convert_bcd_to_decimal(buff, sizeof(buff));
266 tm->tm_sec = buff[0];
267 tm->tm_min = buff[1];
268 tm->tm_hour = buff[2]; //bit5 PA_H20
269 tm->tm_wday = buff[3];
270 tm->tm_mday = buff[4];
271 tm->tm_mon = buff[5]; //for print
272 tm->tm_year = buff[6] + 100 * cent_flag;
273 print_time(dev, tm); //for print
274 tm->tm_mon = buff[5] - 1; //back to system 0-11
279 static int ricoh619_rtc_set_time(struct device *dev, struct rtc_time *tm)
285 // printk(KERN_INFO "PMU: %s\n", __func__);
287 if(ricoh619_rtc_valid_tm(dev, tm) != 0)
292 if (tm->tm_year >= 100)
297 tm->tm_mon = tm->tm_mon + 1;
298 buff[0] = tm->tm_sec;
299 buff[1] = tm->tm_min;
300 buff[2] = tm->tm_hour;
301 buff[3] = tm->tm_wday;
302 buff[4] = tm->tm_mday;
303 buff[5] = tm->tm_mon; //system set 0-11
304 buff[6] = tm->tm_year - 100 * cent_flag;
305 print_time(dev, tm); // RTC_TEST
307 convert_decimal_to_bcd(buff, sizeof(buff));
312 err = ricoh619_write_regs(dev, rtc_seconds_reg, sizeof(buff), buff);
314 dev_err(dev->parent, "\n failed to program new time\n");
321 static int ricoh619_rtc_alarm_is_enabled(struct device *dev, uint8_t *enabled)
323 struct ricoh619_rtc *rtc = dev_get_drvdata(dev);
328 err = ricoh619_read_regs(dev, rtc_ctrl1, 1,®_data);
331 dev_err(dev->parent, "read rtc_ctrl1 error 0x%lx\n", err);
344 // 0-disable, 1-enable
345 static int ricoh619_rtc_alarm_enable(struct device *dev, unsigned int enabled)
347 struct ricoh619_rtc *rtc = dev_get_drvdata(dev);
351 // printk(KERN_INFO "PMU: %s :%d\n", __func__,enabled);
357 err = ricoh619_read_regs(dev, rtc_ctrl1, 1,®_data);
360 dev_err(dev->parent, "read rtc_ctrl1 error 0x%lx\n", err);
363 reg_data |= 0x40;// set DALE
364 err = ricoh619_write_regs(dev, rtc_ctrl1, 1,®_data);
366 dev_err(dev->parent, "write rtc_ctrl1 error 0x%lx\n", err);
371 err = ricoh619_read_regs(dev, rtc_ctrl1, 1,®_data);
374 dev_err(dev->parent, "read rtc_ctrl1 error 0x%lx\n", err);
377 reg_data &= 0xbf;// clear DALE
378 err = ricoh619_write_regs(dev, rtc_ctrl1, 1,®_data);
380 dev_err(dev->parent, "write rtc_ctrl1 error 0x%lx\n", err);
387 static int ricoh619_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
393 unsigned char enabled_flag;
395 // printk(KERN_INFO "PMU: %s\n", __func__);
399 alrm->time.tm_sec = 0;
400 alrm->time.tm_min = 0;
401 alrm->time.tm_hour = 0;
402 alrm->time.tm_mday = 0;
403 alrm->time.tm_mon = 0;
404 alrm->time.tm_year = 0;
407 err = ricoh619_read_regs(dev, rtc_month_reg, 1, &buff_cent);
409 dev_err(dev->parent, "PMU: %s *** failed to read time *****\n", __func__);
412 if (buff_cent & 0x80)
417 err = ricoh619_read_regs(dev, rtc_alarm_y_sec, sizeof(buff), buff);
420 dev_err(dev->parent, "RTC: %s *** read rtc_alarm timer error 0x%lx\n", __func__, err);
424 err = ricoh619_read_regs(dev, rtc_ctrl1, 1,&enabled_flag);
427 dev_err(dev->parent, "RTC: %s *** read rtc_enable flag error 0x%lx\n", __func__, err);
430 if(enabled_flag & 0x40)
435 buff[3] &= ~0x80; /* clear DAL_EXT */
437 buff[3] = buff[3]&0x3f;
438 convert_bcd_to_decimal(buff, sizeof(buff));
440 alrm->time.tm_sec = buff[0];
441 alrm->time.tm_min = buff[1];
442 alrm->time.tm_hour = buff[2];
443 alrm->time.tm_mday = buff[3];
444 alrm->time.tm_mon = buff[4];// for print
445 alrm->time.tm_year = buff[5] + 100 * cent_flag;
446 dev_info(dev, "PMU: read alarm: %d/%d/%d %d:%d:%d *****\n",
447 (alrm->time.tm_mon), alrm->time.tm_mday, (alrm->time.tm_year + os_ref_year), alrm->time.tm_hour, alrm->time.tm_min,alrm->time.tm_sec);
448 alrm->time.tm_mon = buff[4] - 1;
449 alrm->enabled = enabled_flag;
454 static int ricoh619_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
456 struct ricoh619_rtc *rtc = dev_get_drvdata(dev);
461 // printk(KERN_INFO "PMU: %s\n", __func__);
463 ricoh619_rtc_alarm_enable(dev, 0);
470 if(alrm->enabled== 0)
473 if (alrm->time.tm_year >= 100)
478 alrm->time.tm_mon += 1;
479 print_time(dev->parent, &alrm->time);
480 buff[0] = alrm->time.tm_sec;
481 buff[1] = alrm->time.tm_min;
482 buff[2] = alrm->time.tm_hour;
483 buff[3] = alrm->time.tm_mday;
484 buff[4] = alrm->time.tm_mon;
485 // buff[5] = alrm->time.tm_year - rtc_year_offset;
486 buff[5] = alrm->time.tm_year - 100 * cent_flag;
487 convert_decimal_to_bcd(buff, sizeof(buff));
488 buff[3] |= 0x80; /* set DAL_EXT */
489 err = ricoh619_write_regs(dev, rtc_alarm_y_sec, sizeof(buff), buff);
491 dev_err(dev->parent, "\n unable to set alarm\n");
496 ricoh619_rtc_alarm_enable(dev, alrm->enabled);
502 static const struct rtc_class_ops ricoh619_rtc_ops = {
503 .read_time = ricoh619_rtc_read_time,
504 .set_time = ricoh619_rtc_set_time,
505 .set_alarm = ricoh619_rtc_set_alarm,
506 .read_alarm = ricoh619_rtc_read_alarm,
507 .alarm_irq_enable = ricoh619_rtc_alarm_enable,
510 static int ricoh619_rtc_alarm_flag_clr(struct device *dev)
515 /* clear alarm-D status bits.*/
516 err = ricoh619_read_regs(dev, rtc_ctrl2, 1, ®_data);
518 dev_err(dev->parent, "unable to read rtc_ctrl2 reg\n");
520 /* to clear alarm-D flag, and set adjustment parameter */
522 err = ricoh619_write_regs(dev, rtc_ctrl2, 1, ®_data);
524 dev_err(dev->parent, "unable to program rtc_status reg\n");
527 static irqreturn_t ricoh619_rtc_irq(int irq, void *data)
529 struct device *dev = data;
530 struct ricoh619_rtc *rtc = dev_get_drvdata(dev);
532 // printk(KERN_INFO "PMU: %s\n", __func__);
534 ricoh619_rtc_alarm_flag_clr(dev);
536 rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
540 static int __devinit ricoh619_rtc_probe(struct platform_device *pdev)
542 struct ricoh619_rtc_platform_data *pdata = pdev->dev.platform_data;
543 struct ricoh619_rtc *rtc;
545 uint8_t Pon_flag,Alarm_flag;
549 // printk(KERN_INFO "******PMU RTC: Version 2013-08-01 REDS!******\n");
550 // printk(KERN_INFO "PMU RTC: %s, ricoh619 driver run at 24H-mode\n", __func__);
551 // printk(KERN_INFO "PMU RTC: we never using periodic function and interrupt\n");
555 dev_err(&pdev->dev, "no platform_data specified\n");
559 rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
563 dev_err(&pdev->dev, "no enough memory for ricoh619_rtc using\n");
567 dev_set_drvdata(&pdev->dev, rtc);
570 err = PTR_ERR(rtc->rtc);
576 dev_err(&pdev->dev, "\n no irq specified, wakeup is disabled\n");
582 rtc->irq = pdata->irq;
587 err = ricoh619_rtc_alarm_is_enabled(&pdev->dev, &Alarm_flag);
590 dev_err(&pdev->dev, "5T619 RTC: Disable alarm interrupt error\n");
596 err = ricoh619_rtc_Pon_get_clr(&pdev->dev, &Pon_flag);
599 dev_err(&pdev->dev, "5T619 RTC: get PON flag error\n");
603 // disable rtc periodic function
604 err = ricoh619_rtc_periodic_disable(&pdev->dev);
607 dev_err(&pdev->dev, "5T619 RTC: disable rtc periodic int error\n");
611 // clearing RTC Adjust register
612 err = ricoh619_rtc_clk_adjust(&pdev->dev, 0);
615 dev_err(&pdev->dev, "unable to program rtc_adjust reg\n");
621 err = ricoh619_rtc_alarm_enable(&pdev->dev, 0);
624 dev_err(&pdev->dev, "5T619 RTC: Disable alarm interrupt error\n");
633 err = ricoh619_rtc_alarm_flag_clr(&pdev->dev);
636 dev_err(&pdev->dev, "5T619 RTC: Pon=1 clear alarm flag error\n");
641 err = ricoh619_rtc_hour_mode_set(&pdev->dev,1);
644 dev_err(&pdev->dev, "5T619 RTC: Pon=1 set 24h-mode error\n");
648 // setting the default year
649 // printk(KERN_INFO "PMU: %s Set default time\n", __func__);
651 pdata->time.tm_sec=0;
652 pdata->time.tm_min=0;
653 pdata->time.tm_hour=0;
654 pdata->time.tm_wday=6;
655 pdata->time.tm_mday=1;
656 pdata->time.tm_mon=1;
657 pdata->time.tm_year=2012;
658 pdata->time.tm_year -= os_ref_year;
659 if(ricoh619_rtc_valid_tm(&pdev->dev, &(pdata->time)) == 0)
661 tm.tm_sec = pdata->time.tm_sec;
662 tm.tm_min = pdata->time.tm_min;
663 tm.tm_hour = pdata->time.tm_hour;
664 tm.tm_wday= pdata->time.tm_wday;
665 tm.tm_mday= pdata->time.tm_mday;
666 tm.tm_mon = pdata->time.tm_mon-1;
667 tm.tm_year = pdata->time.tm_year;
671 // using the ricoh default time instead of board default time
672 dev_err(&pdev->dev, "board rtc default is erro\n");
682 // set default alarm time
683 if (tm.tm_year >= 100)
684 buff[5] = tm.tm_year-100-1;
686 buff[5] = tm.tm_year-1;
689 buff[2] = tm.tm_hour;
690 buff[3] = tm.tm_mday;
691 buff[4] = tm.tm_mon +1;
693 err = ricoh619_rtc_set_time(&pdev->dev, &tm);
696 dev_err(&pdev->dev, "5t619 RTC:\n failed to set time\n");
700 convert_decimal_to_bcd(buff, sizeof(buff));
701 buff[3] |= 0x80; /* set DAL_EXT */
703 err = ricoh619_write_regs(&pdev->dev, rtc_alarm_y_sec, sizeof(buff), buff);
705 printk( "\n unable to set alarm\n");
709 device_init_wakeup(&pdev->dev, 1);
711 // printk(KERN_INFO "PMU: %s register rtc device \n", __func__);
712 rtc->rtc = rtc_device_register(pdev->name, &pdev->dev,
713 &ricoh619_rtc_ops, THIS_MODULE);
715 // set interrupt and enable it
718 rtc->irq = rtc->irq + RICOH619_IRQ_DALE;
719 err = request_threaded_irq(rtc->irq, NULL, ricoh619_rtc_irq,
720 IRQF_ONESHOT, "rtc_ricoh619", &pdev->dev);
723 dev_err(&pdev->dev, "request IRQ:%d fail\n", rtc->irq);
725 err = ricoh619_rtc_alarm_enable(&pdev->dev, 0);
728 dev_err(&pdev->dev, "5T619 RTC: enable rtc alarm error\n");
735 enable_irq_wake(rtc->irq);
737 err = ricoh619_rtc_alarm_enable(&pdev->dev, Alarm_flag);
740 dev_err(&pdev->dev, "failed rtc setup\n");
748 // system don't want to using alarm interrupt, so close it
749 err = ricoh619_rtc_alarm_enable(&pdev->dev, 0);
752 dev_err(&pdev->dev, "5T619 RTC: Disable rtc alarm error\n");
755 dev_err(&pdev->dev, "ricoh619 interrupt is disabled\n");
758 printk(KERN_INFO "RICOH619 RTC Register Success\n");
760 ricoh619_read_regs(&pdev->dev, rtc_ctrl1, 1,&buff[0]);
761 ricoh619_read_regs(&pdev->dev, rtc_ctrl2, 1,&buff[1]);
762 // printk(KERN_INFO "0xAE:%x 0xAF:%x\n",buff[0],buff[1]);
766 if (!IS_ERR_OR_NULL(rtc->rtc))
767 rtc_device_unregister(rtc->rtc);
772 static int __devexit ricoh619_rtc_remove(struct platform_device *pdev)
774 struct ricoh619_rtc *rtc = dev_get_drvdata(&pdev->dev);
777 free_irq(rtc->irq, rtc);
778 rtc_device_unregister(rtc->rtc);
783 static struct platform_driver ricoh619_rtc_driver = {
785 .name = "rtc_ricoh619",
786 .owner = THIS_MODULE,
788 .probe = ricoh619_rtc_probe,
789 .remove = __devexit_p(ricoh619_rtc_remove),
792 static int __init ricoh619_rtc_init(void)
794 return platform_driver_register(&ricoh619_rtc_driver);
796 subsys_initcall_sync(ricoh619_rtc_init);
798 static void __exit ricoh619_rtc_exit(void)
800 platform_driver_unregister(&ricoh619_rtc_driver);
802 module_exit(ricoh619_rtc_exit);
804 MODULE_DESCRIPTION("RICOH RICOH619 RTC driver");
805 MODULE_ALIAS("platform:rtc_ricoh619");
806 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
807 MODULE_LICENSE("GPL");