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/module.h>
34 #include <linux/mfd/ricoh619.h>
35 #include <linux/rtc/rtc-ricoh619.h>
36 #include <linux/platform_device.h>
37 #include <linux/rtc.h>
38 #include <linux/slab.h>
39 #include <linux/irqdomain.h>
44 struct rtc_device *rtc;
48 static int ricoh619_read_regs(struct device *dev, int reg, int len,
53 ret = ricoh619_bulk_reads(dev->parent, reg, len, val);
55 dev_err(dev->parent, "\n %s failed reading from 0x%02x\n",
62 static int ricoh619_write_regs(struct device *dev, int reg, int len,
66 ret = ricoh619_bulk_writes(dev->parent, reg, len, val);
68 dev_err(dev->parent, "\n %s failed writing\n", __func__);
75 // 0=OK, -EINVAL= FAIL
76 static int ricoh619_rtc_valid_tm(struct device *dev, struct rtc_time *tm)
78 if (tm->tm_year > 199 || tm->tm_year < 70
79 || tm->tm_mon > 11 || tm->tm_mon < 0
81 || tm->tm_mday > rtc_month_days(tm->tm_mon, tm->tm_year + os_ref_year)
82 || tm->tm_hour >= 24 || tm->tm_hour < 0
83 || tm->tm_min < 0 || tm->tm_min >= 60
84 || tm->tm_sec < 0 || tm->tm_sec >= 60
87 dev_err(dev->parent, "PMU: %s *** Returning error due to time, %d/%d/%d %d:%d:%d *****\n",
88 __func__, tm->tm_mon, tm->tm_mday, tm->tm_year, tm->tm_hour, tm->tm_min, tm->tm_sec);
96 static u8 dec2bcd(u8 dec)
98 return ((dec/10)<<4)+(dec%10);
101 static u8 bcd2dec(u8 bcd)
103 return (bcd >> 4)*10+(bcd & 0xf);
106 static void convert_bcd_to_decimal(u8 *buf, u8 len)
109 for (i = 0; i < len; i++)
110 buf[i] = bcd2dec(buf[i]);
113 static void convert_decimal_to_bcd(u8 *buf, u8 len)
116 for (i = 0; i < len; i++)
117 buf[i] = dec2bcd(buf[i]);
120 static void print_time(struct device *dev, struct rtc_time *tm)
122 dev_info(dev, "PMU: %s *** rtc-time : %d/%d/%d %d:%d:%d *****\n",
123 __func__, (tm->tm_mon), tm->tm_mday, (tm->tm_year + os_ref_year), tm->tm_hour, tm->tm_min,tm->tm_sec);
126 static int ricoh619_rtc_periodic_disable(struct device *dev)
132 err = ricoh619_read_regs(dev, rtc_ctrl1, 1, ®_data);
135 dev_err(dev->parent, "read rtc_ctrl1 error=0x%x\n", err);
139 err = ricoh619_write_regs(dev, rtc_ctrl1, 1, ®_data);
142 dev_err(dev->parent, "read rtc_ctrl1 error=0x%x\n", err);
146 // clear alarm flag and CTFG
147 err = ricoh619_read_regs(dev, rtc_ctrl2, 1, ®_data);
150 dev_err(dev->parent, "read rtc_ctrl2 error=0x%x\n", err);
153 reg_data &= ~0x85;// 1000-0101
154 err = ricoh619_write_regs(dev, rtc_ctrl2, 1, ®_data);
157 dev_err(dev->parent, "read rtc_ctrl2 error=0x%x\n", err);
164 static int ricoh619_rtc_clk_adjust(struct device *dev, uint8_t clk)
166 return ricoh619_write_regs(dev, rtc_adjust, 1, &clk);
169 static int ricoh619_rtc_Pon_get_clr(struct device *dev, uint8_t *Pon_f)
174 err = ricoh619_read_regs(dev, rtc_ctrl2,1,®_data);
177 dev_err(dev->parent, "rtc_ctrl1 read err=0x%x\n", err);
180 // printk("%s,PON=1 -- CTRL2=0x%x\n", __func__, reg_data);
186 reg_data &= ~0x5b;// 0101-1011
187 reg_data |= 0x20; // 0010-0000
188 err = ricoh619_write_regs(dev, rtc_ctrl2, 1,®_data);
191 dev_err(dev->parent, "rtc_ctrl1 write err=0x%x\n", err);
203 // 0-12hour, 1-24hour
205 static int ricoh619_rtc_hour_mode_get(struct device *dev, uint8_t *mode)
209 err = ricoh619_read_regs(dev, rtc_ctrl1, 1, mode);
211 dev_err(dev->parent, "read rtc ctrl1 error\n");
221 // 0-12hour, 1-24hour
222 static int ricoh619_rtc_hour_mode_set(struct device *dev, int mode)
227 err = ricoh619_read_regs(dev, rtc_ctrl1, 1, ®_data);
230 dev_err(dev->parent, "read rtc_ctrl1 error\n");
237 err = ricoh619_write_regs(dev, rtc_ctrl1, 1, ®_data);
240 dev_err(dev->parent, "write rtc_ctrl1 error\n");
247 static int ricoh619_rtc_read_time(struct device *dev, struct rtc_time *tm)
253 err = ricoh619_read_regs(dev, rtc_seconds_reg, sizeof(buff), buff);
256 dev_err(dev->parent, "PMU: %s *** failed to read time *****\n", __func__);
265 buff[5] = buff[5]&0x1f; //bit5 19_20
266 convert_bcd_to_decimal(buff, sizeof(buff));
268 tm->tm_sec = buff[0];
269 tm->tm_min = buff[1];
270 tm->tm_hour = buff[2]; //bit5 PA_H20
271 tm->tm_wday = buff[3];
272 tm->tm_mday = buff[4];
273 tm->tm_mon = buff[5]; //for print
274 tm->tm_year = buff[6] + 100 * cent_flag;
275 print_time(dev, tm); //for print
276 tm->tm_mon = buff[5] - 1; //back to system 0-11
278 // printk(KERN_INFO "PMU: %s year=%d mon=%d day=% hour=%d min =%d sec=%d\n", __func__,
279 // tm->tm_year,tm->tm_mon ,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec );
284 static int ricoh619_rtc_set_time(struct device *dev, struct rtc_time *tm)
290 // printk(KERN_INFO "PMU: %s year=%d mon=%d day=% hour=%d min =%d sec=%d\n", __func__,
291 // tm->tm_year,tm->tm_mon ,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec );
293 if(ricoh619_rtc_valid_tm(dev, tm) != 0)
298 if (tm->tm_year >= 100)
303 tm->tm_mon = tm->tm_mon + 1;
304 buff[0] = tm->tm_sec;
305 buff[1] = tm->tm_min;
306 buff[2] = tm->tm_hour;
307 buff[3] = tm->tm_wday;
308 buff[4] = tm->tm_mday;
309 buff[5] = tm->tm_mon; //system set 0-11
310 buff[6] = tm->tm_year - 100 * cent_flag;
311 print_time(dev, tm); // RTC_TEST
313 convert_decimal_to_bcd(buff, sizeof(buff));
318 err = ricoh619_write_regs(dev, rtc_seconds_reg, sizeof(buff), buff);
320 dev_err(dev->parent, "\n failed to program new time\n");
327 static int ricoh619_rtc_alarm_is_enabled(struct device *dev, uint8_t *enabled)
333 err = ricoh619_read_regs(dev, rtc_ctrl1,1,®_data);
336 dev_err(dev->parent, "read rtc_ctrl1 error 0x%x\n", err);
349 // 0-disable, 1-enable
350 static int ricoh619_rtc_alarm_enable(struct device *dev, unsigned int enabled)
352 struct ricoh619_rtc *rtc = dev_get_drvdata(dev);
356 // printk(KERN_INFO "PMU: %s :%d\n", __func__,enabled);
362 err = ricoh619_read_regs(dev, rtc_ctrl1, 1,®_data);
365 dev_err(dev->parent, "read rtc_ctrl1 error =%d\n", err);
368 reg_data |= 0x40;// set DALE
369 err = ricoh619_write_regs(dev, rtc_ctrl1, 1,®_data);
371 dev_err(dev->parent, "write rtc_ctrl1 error =%d\n", err);
376 err = ricoh619_read_regs(dev, rtc_ctrl1, 1,®_data);
379 dev_err(dev->parent, "read rtc_ctrl1 error =%d\n", err);
382 reg_data &= 0xbf;// clear DALE
383 err = ricoh619_write_regs(dev, rtc_ctrl1, 1,®_data);
385 dev_err(dev->parent, "write rtc_ctrl1 error =%d\n", err);
392 static int ricoh619_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
398 unsigned char enabled_flag;
400 // printk(KERN_INFO "PMU: %s\n", __func__);
404 alrm->time.tm_sec = 0;
405 alrm->time.tm_min = 0;
406 alrm->time.tm_hour = 0;
407 alrm->time.tm_mday = 0;
408 alrm->time.tm_mon = 0;
409 alrm->time.tm_year = 0;
412 err = ricoh619_read_regs(dev, rtc_month_reg, 1, &buff_cent);
414 dev_err(dev->parent, "PMU: %s *** failed to read time *****\n", __func__);
417 if (buff_cent & 0x80)
422 err = ricoh619_read_regs(dev, rtc_alarm_y_sec, sizeof(buff), buff);
425 dev_err(dev->parent, "RTC: %s *** read rtc_alarm timer error =%d\n", __func__, err);
429 err = ricoh619_read_regs(dev, rtc_ctrl1, 1,&enabled_flag);
432 dev_err(dev->parent, "RTC: %s *** read rtc_enable flag error =%d\n", __func__, err);
435 if(enabled_flag & 0x40)
440 buff[3] &= ~0x80; /* clear DAL_EXT */
442 buff[3] = buff[3]&0x3f;
443 convert_bcd_to_decimal(buff, sizeof(buff));
445 alrm->time.tm_sec = buff[0];
446 alrm->time.tm_min = buff[1];
447 alrm->time.tm_hour = buff[2];
448 alrm->time.tm_mday = buff[3];
449 alrm->time.tm_mon = buff[4];// for print
450 alrm->time.tm_year = buff[5] + 100 * cent_flag;
451 dev_info(dev, "PMU: read alarm: %d/%d/%d %d:%d:%d *****\n",
452 (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);
453 alrm->time.tm_mon = buff[4] - 1;
454 alrm->enabled = enabled_flag;
459 static int ricoh619_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
461 struct ricoh619_rtc *rtc = dev_get_drvdata(dev);
466 // printk(KERN_INFO "PMU: %s\n", __func__);
468 ricoh619_rtc_alarm_enable(dev, 0);
475 if(alrm->enabled== 0)
478 if (alrm->time.tm_year >= 100)
483 alrm->time.tm_mon += 1;
484 print_time(dev->parent, &alrm->time);
485 buff[0] = alrm->time.tm_sec;
486 buff[1] = alrm->time.tm_min;
487 buff[2] = alrm->time.tm_hour;
488 buff[3] = alrm->time.tm_mday;
489 buff[4] = alrm->time.tm_mon;
490 // buff[5] = alrm->time.tm_year - rtc_year_offset;
491 buff[5] = alrm->time.tm_year - 100 * cent_flag;
492 convert_decimal_to_bcd(buff, sizeof(buff));
493 buff[3] |= 0x80; /* set DAL_EXT */
494 err = ricoh619_write_regs(dev, rtc_alarm_y_sec, sizeof(buff), buff);
496 dev_err(dev->parent, "\n unable to set alarm\n");
501 ricoh619_rtc_alarm_enable(dev, alrm->enabled);
507 static const struct rtc_class_ops ricoh619_rtc_ops = {
508 .read_time = ricoh619_rtc_read_time,
509 .set_time = ricoh619_rtc_set_time,
510 .set_alarm = ricoh619_rtc_set_alarm,
511 .read_alarm = ricoh619_rtc_read_alarm,
512 .alarm_irq_enable = ricoh619_rtc_alarm_enable,
515 static int ricoh619_rtc_alarm_flag_clr(struct device *dev)
520 /* clear alarm-D status bits.*/
521 err = ricoh619_read_regs(dev, rtc_ctrl2, 1, ®_data);
523 dev_err(dev->parent, "unable to read rtc_ctrl2 reg\n");
525 /* to clear alarm-D flag, and set adjustment parameter */
527 err = ricoh619_write_regs(dev, rtc_ctrl2, 1, ®_data);
529 dev_err(dev->parent, "unable to program rtc_status reg\n");
532 static irqreturn_t ricoh619_rtc_irq(int irq, void *data)
534 struct device *dev = data;
535 struct ricoh619_rtc *rtc = dev_get_drvdata(dev);
537 // printk(KERN_INFO "PMU: %s\n", __func__);
539 ricoh619_rtc_alarm_flag_clr(dev);
541 rtc_update_irq(rtc->rtc, 1, RTC_IRQF | RTC_AF);
546 static struct ricoh619_rtc_platform_data *ricoh619_rtc_dt_init(struct platform_device *pdev)
548 struct device_node *nproot = pdev->dev.parent->of_node;
549 struct device_node *np;
550 struct ricoh619_rtc_platform_data *pdata;
553 return pdev->dev.platform_data;
555 np = of_find_node_by_name(nproot, "rtc");
557 dev_err(&pdev->dev, "failed to find rtc node\n");
561 pdata = devm_kzalloc(&pdev->dev,
562 sizeof(struct ricoh619_rtc_platform_data),
565 of_property_read_u32(np, "ricoh,rtc-tm-year", &pdata->time.tm_year);
566 of_property_read_u32(np, "ricoh,rtc-tm-month", &pdata->time.tm_mon);
567 of_property_read_u32(np, "ricoh,rtc-tm-mday", &pdata->time.tm_mday);
568 of_property_read_u32(np, "ricoh,rtc-tm-hour", &pdata->time.tm_hour);
569 of_property_read_u32(np, "ricoh,rtc-tm-min", &pdata->time.tm_min);
570 of_property_read_u32(np, "ricoh,rtc-tm-sec", &pdata->time.tm_sec);
576 static struct ricoh619_rtc_platform_data *
577 ricoh619_rtc_dt_init(struct platform_device *pdev)
579 return pdev->dev.platform_data;
583 static int ricoh619_rtc_probe(struct platform_device *pdev)
585 struct ricoh619_rtc_platform_data *pdata;
586 struct ricoh619 *ricoh619 = dev_get_drvdata(pdev->dev.parent);
587 struct ricoh619_rtc *rtc;
589 uint8_t Pon_flag,Alarm_flag;
593 // printk(KERN_INFO "******PMU RTC: Version 2014-01-01 REDS!******\n");
595 pdata = ricoh619_rtc_dt_init(pdev);
597 dev_err(&pdev->dev, "platform data isn't assigned to "
601 printk("%s,line=%d\n", __func__,__LINE__);
603 rtc = devm_kzalloc(ricoh619->dev,sizeof(*rtc), GFP_KERNEL);
607 dev_err(&pdev->dev, "no enough memory for ricoh619_rtc using\n");
611 dev_set_drvdata(&pdev->dev, rtc);
614 err = PTR_ERR(rtc->rtc);
618 rtc->irq = irq_create_mapping(ricoh619->irq_domain, RICOH619_IRQ_DALE);
621 dev_err(&pdev->dev, "\n no irq specified, wakeup is disabled\n");
628 err = ricoh619_rtc_alarm_is_enabled(&pdev->dev, &Alarm_flag);
631 dev_err(&pdev->dev, "5T619 RTC: Disable alarm interrupt error\n");
637 err = ricoh619_rtc_Pon_get_clr(&pdev->dev, &Pon_flag);
640 dev_err(&pdev->dev, "5T619 RTC: get PON flag error\n");
644 // disable rtc periodic function
645 err = ricoh619_rtc_periodic_disable(&pdev->dev);
648 dev_err(&pdev->dev, "5T619 RTC: disable rtc periodic int error\n");
652 // clearing RTC Adjust register
653 err = ricoh619_rtc_clk_adjust(&pdev->dev, 0);
656 dev_err(&pdev->dev, "unable to program rtc_adjust reg\n");
662 err = ricoh619_rtc_alarm_enable(&pdev->dev, 0);
665 dev_err(&pdev->dev, "5T619 RTC: Disable alarm interrupt error\n");
674 err = ricoh619_rtc_alarm_flag_clr(&pdev->dev);
677 dev_err(&pdev->dev, "5T619 RTC: Pon=1 clear alarm flag error\n");
682 err = ricoh619_rtc_hour_mode_set(&pdev->dev,1);
685 dev_err(&pdev->dev, "5T619 RTC: Pon=1 set 24h-mode error\n");
689 // setting the default year
690 // printk(KERN_INFO "PMU: %s Set default time\n", __func__);
692 pdata->time.tm_sec=0;
693 pdata->time.tm_min=0;
694 pdata->time.tm_hour=0;
695 pdata->time.tm_wday=6;
696 pdata->time.tm_mday=1;
697 pdata->time.tm_mon=1;
698 pdata->time.tm_year=2012;
699 pdata->time.tm_year -= os_ref_year;
700 if(ricoh619_rtc_valid_tm(&pdev->dev, &(pdata->time)) == 0)
702 tm.tm_sec = pdata->time.tm_sec;
703 tm.tm_min = pdata->time.tm_min;
704 tm.tm_hour = pdata->time.tm_hour;
705 tm.tm_wday= pdata->time.tm_wday;
706 tm.tm_mday= pdata->time.tm_mday;
707 tm.tm_mon = pdata->time.tm_mon-1;
708 tm.tm_year = pdata->time.tm_year;
712 // using the ricoh default time instead of board default time
713 dev_err(&pdev->dev, "board rtc default is erro\n");
723 // set default alarm time
724 if (tm.tm_year >= 100)
725 buff[5] = tm.tm_year-100-1;
727 buff[5] = tm.tm_year-1;
730 buff[2] = tm.tm_hour;
731 buff[3] = tm.tm_mday;
732 buff[4] = tm.tm_mon +1;
734 err = ricoh619_rtc_set_time(&pdev->dev, &tm);
737 dev_err(&pdev->dev, "5t619 RTC:\n failed to set time\n");
741 convert_decimal_to_bcd(buff, sizeof(buff));
742 buff[3] |= 0x80; /* set DAL_EXT */
744 err = ricoh619_write_regs(&pdev->dev, rtc_alarm_y_sec, sizeof(buff), buff);
746 printk( "\n unable to set alarm\n");
750 device_init_wakeup(&pdev->dev, 1);
752 // printk(KERN_INFO "PMU: %s register rtc device \n", __func__);
753 rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name,
754 &ricoh619_rtc_ops, THIS_MODULE);
756 // set interrupt and enable it
758 err = devm_request_threaded_irq(&pdev->dev,rtc->irq, NULL, ricoh619_rtc_irq,
759 IRQF_ONESHOT, "rtc_ricoh619", &pdev->dev);
762 dev_err(&pdev->dev, "request IRQ:%d fail\n", rtc->irq);
764 err = ricoh619_rtc_alarm_enable(&pdev->dev, 0);
767 dev_err(&pdev->dev, "5T619 RTC: enable rtc alarm error\n");
773 enable_irq_wake(rtc->irq);
775 err = ricoh619_rtc_alarm_enable(&pdev->dev, Alarm_flag);
778 dev_err(&pdev->dev, "failed rtc setup\n");
786 // system don't want to using alarm interrupt, so close it
787 err = ricoh619_rtc_alarm_enable(&pdev->dev, 0);
790 dev_err(&pdev->dev, "5T619 RTC: Disable rtc alarm error\n");
793 dev_err(&pdev->dev, "ricoh619 interrupt is disabled\n");
795 printk(KERN_INFO "RICOH619 RTC Register Success\n");
797 ricoh619_read_regs(&pdev->dev, rtc_ctrl1, 1,&buff[0]);
798 ricoh619_read_regs(&pdev->dev, rtc_ctrl2, 1,&buff[1]);
799 // printk(KERN_INFO "0xAE:%x 0xAF:%x\n",buff[0],buff[1]);
806 static int ricoh619_rtc_remove(struct platform_device *pdev)
812 static const struct of_device_id ricoh619_rtc_dt_match[] = {
813 { .compatible = "ricoh,ricoh619-rtc", },
816 MODULE_DEVICE_TABLE(of, ricoh619_rtc_dt_match);
819 static struct platform_driver ricoh619_rtc_driver = {
821 .name = "ricoh619-rtc",
822 .owner = THIS_MODULE,
823 .of_match_table = of_match_ptr(ricoh619_rtc_dt_match),
825 .probe = ricoh619_rtc_probe,
826 .remove = ricoh619_rtc_remove,
829 static int __init ricoh619_rtc_init(void)
831 return platform_driver_register(&ricoh619_rtc_driver);
833 subsys_initcall_sync(ricoh619_rtc_init);
835 static void __exit ricoh619_rtc_exit(void)
837 platform_driver_unregister(&ricoh619_rtc_driver);
839 module_exit(ricoh619_rtc_exit);
841 MODULE_DESCRIPTION("RICOH RICOH619 RTC driver");
842 MODULE_ALIAS("platform:rtc_ricoh619");
843 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
844 MODULE_LICENSE("GPL");