drivers/rtc/rtc-rt5036.c

   1 /*
   2  *  drivers/rtc/rt5036-rtc.c
   3  *  Driver for Richtek RT5036 PMIC RTC driver
   4  *
   5  *  Copyright (C) 2014 Richtek Technology Corp.
   6  *  cy_huang <cy_huang@richtek.com>
   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; either version 2
  11  * of the License, or (at your option) any later version.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/init.h>
  17 #include <linux/err.h>
  18 #include <linux/rtc.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/i2c.h>
  21 #include <linux/of.h>
  22
  23 #include <linux/mfd/rt5036/rt5036.h>
  24 #include <linux/rtc/rtc-rt5036.h>
  25
  26 static unsigned char rtc_init_regval[] = {
  27         0x1,                    /*REG 0x97*/
  28         0x3,                    /*REG 0xA5*/
  29 };
  30
  31 static int rt5036_read_time(struct device *dev, struct rtc_time *tm)
  32 {
  33         struct rt5036_rtc_info *ri = dev_get_drvdata(dev);
  34         unsigned char val[6];
  35         int rc;
  36
  37         RTINFO("\n");
  38         rc = rt5036_reg_block_read(ri->i2c, RT5036_REG_RTCTSEC, ARRAY_SIZE(val),
  39                                    val);
  40         if (rc < 0) {
  41                 dev_err(dev, "reading rtc time io error\n");
  42         } else {
  43                 tm->tm_sec = val[0] & RT5036_RTC_SECMASK;
  44                 tm->tm_min = val[1] & RT5036_RTC_MINMASK;
  45                 tm->tm_hour = val[2] & RT5036_RTC_HOURMASK;
  46                 tm->tm_year = (val[3] & RT5036_RTC_YEARMASK) + 100;
  47                 tm->tm_mon = (val[4] & RT5036_RTC_MONMASK) - 1;
  48                 tm->tm_mday = val[5] & RT5036_RTC_DAYMASK;
  49                 RTINFO("%04d:%02d:%02d, %02d:%02d:%02d\n", tm->tm_year + 1900,
  50                        tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min,
  51                        tm->tm_sec);
  52                 rc = rtc_valid_tm(tm);
  53                 if (rc < 0) {
  54                         dev_err(dev, "not invalid time reading from RT5036\n");
  55                         return -EINVAL;
  56                 }
  57         }
  58         return rc;
  59 }
  60
  61 static int rt5036_set_time(struct device *dev, struct rtc_time *tm)
  62 {
  63         struct rt5036_rtc_info *ri = dev_get_drvdata(dev);
  64         unsigned char val[6];
  65         int rc;
  66
  67         RTINFO("\n");
  68         rc = rt5036_reg_block_read(ri->i2c, RT5036_REG_RTCTSEC, ARRAY_SIZE(val),
  69                                    val);
  70         if (rc < 0) {
  71                 dev_err(dev, "reading rtc time io error\n");
  72         } else {
  73                 val[0] &= ~RT5036_RTC_SECMASK;
  74                 val[0] |= (tm->tm_sec & RT5036_RTC_SECMASK);
  75                 val[1] &= ~RT5036_RTC_MINMASK;
  76                 val[1] |= (tm->tm_min & RT5036_RTC_MINMASK);
  77                 val[2] &= ~RT5036_RTC_HOURMASK;
  78                 val[2] |= (tm->tm_hour & RT5036_RTC_HOURMASK);
  79                 val[3] &= ~RT5036_RTC_YEARMASK;
  80                 val[3] |= ((tm->tm_year - 100) & RT5036_RTC_YEARMASK);
  81                 val[4] &= ~RT5036_RTC_MONMASK;
  82                 val[4] |= ((tm->tm_mon + 1) & RT5036_RTC_MONMASK);
  83                 val[5] &= ~RT5036_RTC_DAYMASK;
  84                 val[5] |= (tm->tm_mday & RT5036_RTC_DAYMASK);
  85                 val[5] &= ~RT5036_RTC_WEEKMASK;
  86                 val[5] |=
  87                     ((tm->
  88                       tm_wday & RT5036_RTC_WEEKMASK) << RT5036_RTC_WEEKSHIFT);
  89                 RTINFO("%04d:%02d:%02d, %02d:%02d:%02d\n", tm->tm_year + 1900,
  90                        tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min,
  91                        tm->tm_sec);
  92
  93                 if (tm->tm_year < 100)
  94                         return -EINVAL;
  95
  96                 rc = rt5036_reg_block_write(ri->i2c, RT5036_REG_RTCTSEC,
  97                                             ARRAY_SIZE(val), val);
  98                 if (rc < 0) {
  99                         dev_err(dev, "writing rtc time io error\n");
 100                         return rc;
 101                 }
 102         }
 103         return rc;
 104 }
 105
 106 static int rt5036_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 107 {
 108         struct rt5036_rtc_info *ri = dev_get_drvdata(dev);
 109         struct rtc_time *tm = &(alarm->time);
 110         unsigned char val[6];
 111         int rc;
 112
 113         RTINFO("\n");
 114         rc = rt5036_reg_block_read(ri->i2c, RT5036_REG_RTCASEC, ARRAY_SIZE(val),
 115                                    val);
 116         if (rc < 0) {
 117                 dev_err(dev, "reading alarm time io error\n");
 118         } else {
 119                 tm->tm_sec = val[0] & RT5036_RTC_SECMASK;
 120                 tm->tm_min = val[1] & RT5036_RTC_MINMASK;
 121                 tm->tm_hour = val[2] & RT5036_RTC_HOURMASK;
 122                 tm->tm_year = (val[3] & RT5036_RTC_YEARMASK) + 100;
 123                 tm->tm_mon = (val[4] & RT5036_RTC_MONMASK) - 1;
 124                 tm->tm_mday = val[5] & RT5036_RTC_DAYMASK;
 125                 RTINFO("%04d_%02d_%02d, %02d:%02d:%02d\n", tm->tm_year + 1900,
 126                        tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min,
 127                        tm->tm_sec);
 128                 rc = rtc_valid_tm(tm);
 129                 if (rc < 0) {
 130                         dev_err(dev, "not invalid alarm reading from RT5036\n");
 131                         return -EINVAL;
 132                 }
 133         }
 134         return rc;
 135 }
 136
 137 static int rt5036_alarm_irq_enable(struct device *dev, unsigned int enabled);
 138
 139 static int rt5036_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 140 {
 141         struct rt5036_rtc_info *ri = dev_get_drvdata(dev);
 142         struct rtc_time *tm = &alarm->time;
 143         unsigned char val[6];
 144         int rc;
 145
 146         RTINFO("\n");
 147         rt5036_alarm_irq_enable(ri->dev, 0);
 148         rc = rt5036_reg_block_read(ri->i2c, RT5036_REG_RTCASEC, ARRAY_SIZE(val),
 149                                    val);
 150         if (rc < 0) {
 151                 dev_err(dev, "reading rtc time io error\n");
 152         } else {
 153                 val[0] &= ~RT5036_RTC_SECMASK;
 154                 val[0] |= (tm->tm_sec & RT5036_RTC_SECMASK);
 155                 val[1] &= ~RT5036_RTC_MINMASK;
 156                 val[1] |= (tm->tm_min & RT5036_RTC_MINMASK);
 157                 val[2] &= ~RT5036_RTC_HOURMASK;
 158                 val[2] |= (tm->tm_hour & RT5036_RTC_HOURMASK);
 159                 val[3] &= ~RT5036_RTC_YEARMASK;
 160                 val[3] |= ((tm->tm_year - 100) & RT5036_RTC_YEARMASK);
 161                 val[4] &= ~RT5036_RTC_MONMASK;
 162                 val[4] |= ((tm->tm_mon + 1) & RT5036_RTC_MONMASK);
 163                 val[5] &= ~RT5036_RTC_DAYMASK;
 164                 val[5] |= (tm->tm_mday & RT5036_RTC_DAYMASK);
 165                 RTINFO("%04d:%02d:%02d, %02d:%02d:%02d\n", tm->tm_year + 1900,
 166                        tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min,
 167                        tm->tm_sec);
 168
 169                 if (tm->tm_year < 100)
 170                         return -EINVAL;
 171
 172                 rc = rt5036_reg_block_write(ri->i2c, RT5036_REG_RTCASEC,
 173                                             ARRAY_SIZE(val), val);
 174                 if (rc < 0) {
 175                         dev_err(dev, "writing alarm time io error\n");
 176                         return rc;
 177                 }
 178         }
 179         rt5036_alarm_irq_enable(ri->dev, alarm->enabled);
 180         return rc;
 181 }
 182
 183 static int rt5036_alarm_irq_enable(struct device *dev, unsigned int enabled)
 184 {
 185         struct rt5036_rtc_info *ri = dev_get_drvdata(dev);
 186
 187         RTINFO("enable=%d\n", enabled);
 188         if (enabled) {
 189                 rt5036_clr_bits(ri->i2c, RT5036_REG_STBWACKIRQMASK,
 190                                 RT5036_RTCAIRQ_MASK);
 191                 rt5036_set_bits(ri->i2c, RT5036_REG_STBMODE,
 192                                 RT5036_RTCAEN_MASK);
 193         } else {
 194                 rt5036_clr_bits(ri->i2c, RT5036_REG_STBMODE,
 195                                 RT5036_RTCAEN_MASK);
 196                 rt5036_set_bits(ri->i2c, RT5036_REG_STBWACKIRQMASK,
 197                                 RT5036_RTCAIRQ_MASK);
 198         }
 199         return 0;
 200 }
 201
 202 static const struct rtc_class_ops rt5036_rtc_ops = {
 203         .read_time = rt5036_read_time,
 204         .set_time = rt5036_set_time,
 205         .read_alarm = rt5036_read_alarm,
 206         .set_alarm = rt5036_set_alarm,
 207         .alarm_irq_enable = rt5036_alarm_irq_enable,
 208 };
 209
 210 static void rt5036_general_irq_handler(void *info, int eventno)
 211 {
 212         struct rt5036_rtc_info *ri = info;
 213
 214         dev_info(ri->dev, "eventno=%02d\n", eventno);
 215         switch (eventno) {
 216         case RTCEVENT_CAIRQ:
 217                 rt5036_alarm_irq_enable(ri->dev, 0);
 218                 break;
 219         default:
 220                 break;
 221         }
 222 }
 223
 224 static rt_irq_handler rt_rtcirq_handler[RTCEVENT_MAX] = {
 225         [RTCEVENT_CAIRQ] = rt5036_general_irq_handler,
 226         [RTCEVENT_CDIRQ] = rt5036_general_irq_handler,
 227 };
 228
 229 void rt5036_rtc_irq_handler(struct rt5036_rtc_info *ri, unsigned int irqevent)
 230 {
 231         int i;
 232
 233         for (i = 0; i < RTCEVENT_MAX; i++) {
 234                 if ((irqevent & (1 << i)) && rt_rtcirq_handler[i])
 235                         rt_rtcirq_handler[i] (ri, i);
 236         }
 237 }
 238 EXPORT_SYMBOL(rt5036_rtc_irq_handler);
 239
 240 static int rt5036_rtc_reginit(struct i2c_client *i2c)
 241 {
 242         rt5036_reg_write(i2c, RT5036_REG_STBMODE, rtc_init_regval[0]);
 243         rt5036_reg_write(i2c, RT5036_REG_STBWACKIRQMASK, rtc_init_regval[1]);
 244         /*always clear at the fist time*/
 245         rt5036_reg_read(i2c, RT5036_REG_STBWACKIRQ);
 246         return 0;
 247 }
 248
 249 static int rt_parse_dt(struct rt5036_rtc_info *ri, struct device *dev)
 250 {
 251         rt5036_rtc_reginit(ri->i2c);
 252         RTINFO("\n");
 253         return 0;
 254 }
 255
 256 static int rt_parse_pdata(struct rt5036_rtc_info *ri,
 257                                     struct device *dev)
 258 {
 259         rt5036_rtc_reginit(ri->i2c);
 260         RTINFO("\n");
 261         return 0;
 262 }
 263
 264 static int rt5036_rtc_probe(struct platform_device *pdev)
 265 {
 266         struct rt5036_chip *chip = dev_get_drvdata(pdev->dev.parent);
 267         struct rt5036_rtc_info *ri;
 268         bool use_dt = pdev->dev.of_node;
 269
 270         ri = devm_kzalloc(&pdev->dev, sizeof(*ri), GFP_KERNEL);
 271         if (!ri)
 272                 return -ENOMEM;
 273
 274         ri->i2c = chip->i2c;
 275         if (use_dt)
 276                 rt_parse_dt(ri, &pdev->dev);
 277         else
 278                 rt_parse_pdata(ri, &pdev->dev);
 279
 280         ri->dev = &pdev->dev;
 281         platform_set_drvdata(pdev, ri);
 282
 283         ri->rtc = rtc_device_register("rt5036-rtc", &pdev->dev,
 284                                       &rt5036_rtc_ops, THIS_MODULE);
 285         if (IS_ERR(ri->rtc)) {
 286                 dev_err(&pdev->dev, "rtc device register failed\n");
 287                 goto out_dev;
 288         }
 289         chip->rtc_info = ri;
 290         device_init_wakeup(&pdev->dev, 1);
 291         dev_info(&pdev->dev, "driver successfully loaded\n");
 292         return 0;
 293 out_dev:
 294         return -EINVAL;
 295 }
 296
 297 static int rt5036_rtc_remove(struct platform_device *pdev)
 298 {
 299         struct rt5036_rtc_info *ri = platform_get_drvdata(pdev);
 300
 301         rtc_device_unregister(ri->rtc);
 302         return 0;
 303 }
 304
 305 static const struct of_device_id rt_match_table[] = {
 306         {.compatible = "rt,rt5036-rtc",},
 307         {},
 308 };
 309
 310 static struct platform_driver rt5036_rtc_driver = {
 311         .driver = {
 312                    .name = RT5036_DEV_NAME "-rtc",
 313                    .owner = THIS_MODULE,
 314                    .of_match_table = rt_match_table,
 315                    },
 316         .probe = rt5036_rtc_probe,
 317         .remove = rt5036_rtc_remove,
 318 };
 319
 320 static int __init rt5036_rtc_init(void)
 321 {
 322         return platform_driver_register(&rt5036_rtc_driver);
 323 }
 324 subsys_initcall(rt5036_rtc_init);
 325
 326 static void __exit rt5036_rtc_exit(void)
 327 {
 328         platform_driver_unregister(&rt5036_rtc_driver);
 329 }
 330 module_exit(rt5036_rtc_exit);
 331
 332 MODULE_LICENSE("GPL");
 333 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com");
 334 MODULE_DESCRIPTION("RTC driver for RT5036");
 335 MODULE_ALIAS("platform:" RT5036_DEV_NAME "-rtc");
 336 MODULE_VERSION(RT5036_DRV_VER);