Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * Real time clock device driver for DA9063
0004  * Copyright (C) 2013-2015  Dialog Semiconductor Ltd.
0005  */
0006 
0007 #include <linux/delay.h>
0008 #include <linux/init.h>
0009 #include <linux/interrupt.h>
0010 #include <linux/kernel.h>
0011 #include <linux/module.h>
0012 #include <linux/of.h>
0013 #include <linux/platform_device.h>
0014 #include <linux/regmap.h>
0015 #include <linux/rtc.h>
0016 #include <linux/slab.h>
0017 
0018 #include <linux/mfd/da9062/registers.h>
0019 #include <linux/mfd/da9063/registers.h>
0020 #include <linux/mfd/da9063/core.h>
0021 
0022 #define YEARS_TO_DA9063(year)       ((year) - 100)
0023 #define MONTHS_TO_DA9063(month)     ((month) + 1)
0024 #define YEARS_FROM_DA9063(year)     ((year) + 100)
0025 #define MONTHS_FROM_DA9063(month)   ((month) - 1)
0026 
0027 enum {
0028     RTC_SEC = 0,
0029     RTC_MIN = 1,
0030     RTC_HOUR = 2,
0031     RTC_DAY = 3,
0032     RTC_MONTH = 4,
0033     RTC_YEAR = 5,
0034     RTC_DATA_LEN
0035 };
0036 
0037 struct da9063_compatible_rtc_regmap {
0038     /* REGS */
0039     int rtc_enable_reg;
0040     int rtc_enable_32k_crystal_reg;
0041     int rtc_alarm_secs_reg;
0042     int rtc_alarm_year_reg;
0043     int rtc_count_secs_reg;
0044     int rtc_count_year_reg;
0045     int rtc_event_reg;
0046     /* MASKS */
0047     int rtc_enable_mask;
0048     int rtc_crystal_mask;
0049     int rtc_event_alarm_mask;
0050     int rtc_alarm_on_mask;
0051     int rtc_alarm_status_mask;
0052     int rtc_tick_on_mask;
0053     int rtc_ready_to_read_mask;
0054     int rtc_count_sec_mask;
0055     int rtc_count_min_mask;
0056     int rtc_count_hour_mask;
0057     int rtc_count_day_mask;
0058     int rtc_count_month_mask;
0059     int rtc_count_year_mask;
0060     /* ALARM CONFIG */
0061     int rtc_data_start;
0062     int rtc_alarm_len;
0063 };
0064 
0065 struct da9063_compatible_rtc {
0066     struct rtc_device *rtc_dev;
0067     struct rtc_time alarm_time;
0068     struct regmap *regmap;
0069     const struct da9063_compatible_rtc_regmap *config;
0070     bool rtc_sync;
0071 };
0072 
0073 static const struct da9063_compatible_rtc_regmap da9063_ad_regs = {
0074     /* REGS */
0075     .rtc_enable_reg             = DA9063_REG_CONTROL_E,
0076     .rtc_alarm_secs_reg         = DA9063_AD_REG_ALARM_MI,
0077     .rtc_alarm_year_reg         = DA9063_AD_REG_ALARM_Y,
0078     .rtc_count_secs_reg         = DA9063_REG_COUNT_S,
0079     .rtc_count_year_reg         = DA9063_REG_COUNT_Y,
0080     .rtc_event_reg              = DA9063_REG_EVENT_A,
0081     /* MASKS */
0082     .rtc_enable_mask            = DA9063_RTC_EN,
0083     .rtc_crystal_mask           = DA9063_CRYSTAL,
0084     .rtc_enable_32k_crystal_reg = DA9063_REG_EN_32K,
0085     .rtc_event_alarm_mask       = DA9063_E_ALARM,
0086     .rtc_alarm_on_mask          = DA9063_ALARM_ON,
0087     .rtc_alarm_status_mask      = DA9063_ALARM_STATUS_ALARM |
0088                       DA9063_ALARM_STATUS_TICK,
0089     .rtc_tick_on_mask           = DA9063_TICK_ON,
0090     .rtc_ready_to_read_mask     = DA9063_RTC_READ,
0091     .rtc_count_sec_mask         = DA9063_COUNT_SEC_MASK,
0092     .rtc_count_min_mask         = DA9063_COUNT_MIN_MASK,
0093     .rtc_count_hour_mask        = DA9063_COUNT_HOUR_MASK,
0094     .rtc_count_day_mask         = DA9063_COUNT_DAY_MASK,
0095     .rtc_count_month_mask       = DA9063_COUNT_MONTH_MASK,
0096     .rtc_count_year_mask        = DA9063_COUNT_YEAR_MASK,
0097     /* ALARM CONFIG */
0098     .rtc_data_start             = RTC_MIN,
0099     .rtc_alarm_len              = RTC_DATA_LEN - 1,
0100 };
0101 
0102 static const struct da9063_compatible_rtc_regmap da9063_bb_regs = {
0103     /* REGS */
0104     .rtc_enable_reg             = DA9063_REG_CONTROL_E,
0105     .rtc_alarm_secs_reg         = DA9063_BB_REG_ALARM_S,
0106     .rtc_alarm_year_reg         = DA9063_BB_REG_ALARM_Y,
0107     .rtc_count_secs_reg         = DA9063_REG_COUNT_S,
0108     .rtc_count_year_reg         = DA9063_REG_COUNT_Y,
0109     .rtc_event_reg              = DA9063_REG_EVENT_A,
0110     /* MASKS */
0111     .rtc_enable_mask            = DA9063_RTC_EN,
0112     .rtc_crystal_mask           = DA9063_CRYSTAL,
0113     .rtc_enable_32k_crystal_reg = DA9063_REG_EN_32K,
0114     .rtc_event_alarm_mask       = DA9063_E_ALARM,
0115     .rtc_alarm_on_mask          = DA9063_ALARM_ON,
0116     .rtc_alarm_status_mask      = DA9063_ALARM_STATUS_ALARM |
0117                       DA9063_ALARM_STATUS_TICK,
0118     .rtc_tick_on_mask           = DA9063_TICK_ON,
0119     .rtc_ready_to_read_mask     = DA9063_RTC_READ,
0120     .rtc_count_sec_mask         = DA9063_COUNT_SEC_MASK,
0121     .rtc_count_min_mask         = DA9063_COUNT_MIN_MASK,
0122     .rtc_count_hour_mask        = DA9063_COUNT_HOUR_MASK,
0123     .rtc_count_day_mask         = DA9063_COUNT_DAY_MASK,
0124     .rtc_count_month_mask       = DA9063_COUNT_MONTH_MASK,
0125     .rtc_count_year_mask        = DA9063_COUNT_YEAR_MASK,
0126     /* ALARM CONFIG */
0127     .rtc_data_start             = RTC_SEC,
0128     .rtc_alarm_len              = RTC_DATA_LEN,
0129 };
0130 
0131 static const struct da9063_compatible_rtc_regmap da9062_aa_regs = {
0132     /* REGS */
0133     .rtc_enable_reg             = DA9062AA_CONTROL_E,
0134     .rtc_alarm_secs_reg         = DA9062AA_ALARM_S,
0135     .rtc_alarm_year_reg         = DA9062AA_ALARM_Y,
0136     .rtc_count_secs_reg         = DA9062AA_COUNT_S,
0137     .rtc_count_year_reg         = DA9062AA_COUNT_Y,
0138     .rtc_event_reg              = DA9062AA_EVENT_A,
0139     /* MASKS */
0140     .rtc_enable_mask            = DA9062AA_RTC_EN_MASK,
0141     .rtc_crystal_mask           = DA9062AA_CRYSTAL_MASK,
0142     .rtc_enable_32k_crystal_reg = DA9062AA_EN_32K,
0143     .rtc_event_alarm_mask       = DA9062AA_M_ALARM_MASK,
0144     .rtc_alarm_on_mask          = DA9062AA_ALARM_ON_MASK,
0145     .rtc_alarm_status_mask      = (0x02 << 6),
0146     .rtc_tick_on_mask           = DA9062AA_TICK_ON_MASK,
0147     .rtc_ready_to_read_mask     = DA9062AA_RTC_READ_MASK,
0148     .rtc_count_sec_mask         = DA9062AA_COUNT_SEC_MASK,
0149     .rtc_count_min_mask         = DA9062AA_COUNT_MIN_MASK,
0150     .rtc_count_hour_mask        = DA9062AA_COUNT_HOUR_MASK,
0151     .rtc_count_day_mask         = DA9062AA_COUNT_DAY_MASK,
0152     .rtc_count_month_mask       = DA9062AA_COUNT_MONTH_MASK,
0153     .rtc_count_year_mask        = DA9062AA_COUNT_YEAR_MASK,
0154     /* ALARM CONFIG */
0155     .rtc_data_start             = RTC_SEC,
0156     .rtc_alarm_len              = RTC_DATA_LEN,
0157 };
0158 
0159 static const struct of_device_id da9063_compatible_reg_id_table[] = {
0160     { .compatible = "dlg,da9063-rtc", .data = &da9063_bb_regs },
0161     { .compatible = "dlg,da9062-rtc", .data = &da9062_aa_regs },
0162     { },
0163 };
0164 MODULE_DEVICE_TABLE(of, da9063_compatible_reg_id_table);
0165 
0166 static void da9063_data_to_tm(u8 *data, struct rtc_time *tm,
0167                   struct da9063_compatible_rtc *rtc)
0168 {
0169     const struct da9063_compatible_rtc_regmap *config = rtc->config;
0170 
0171     tm->tm_sec  = data[RTC_SEC]  & config->rtc_count_sec_mask;
0172     tm->tm_min  = data[RTC_MIN]  & config->rtc_count_min_mask;
0173     tm->tm_hour = data[RTC_HOUR] & config->rtc_count_hour_mask;
0174     tm->tm_mday = data[RTC_DAY]  & config->rtc_count_day_mask;
0175     tm->tm_mon  = MONTHS_FROM_DA9063(data[RTC_MONTH] &
0176                      config->rtc_count_month_mask);
0177     tm->tm_year = YEARS_FROM_DA9063(data[RTC_YEAR] &
0178                     config->rtc_count_year_mask);
0179 }
0180 
0181 static void da9063_tm_to_data(struct rtc_time *tm, u8 *data,
0182                   struct da9063_compatible_rtc *rtc)
0183 {
0184     const struct da9063_compatible_rtc_regmap *config = rtc->config;
0185 
0186     data[RTC_SEC]   = tm->tm_sec & config->rtc_count_sec_mask;
0187     data[RTC_MIN]   = tm->tm_min & config->rtc_count_min_mask;
0188     data[RTC_HOUR]  = tm->tm_hour & config->rtc_count_hour_mask;
0189     data[RTC_DAY]   = tm->tm_mday & config->rtc_count_day_mask;
0190     data[RTC_MONTH] = MONTHS_TO_DA9063(tm->tm_mon) &
0191                 config->rtc_count_month_mask;
0192     data[RTC_YEAR]  = YEARS_TO_DA9063(tm->tm_year) &
0193                 config->rtc_count_year_mask;
0194 }
0195 
0196 static int da9063_rtc_stop_alarm(struct device *dev)
0197 {
0198     struct da9063_compatible_rtc *rtc = dev_get_drvdata(dev);
0199     const struct da9063_compatible_rtc_regmap *config = rtc->config;
0200 
0201     return regmap_update_bits(rtc->regmap,
0202                   config->rtc_alarm_year_reg,
0203                   config->rtc_alarm_on_mask,
0204                   0);
0205 }
0206 
0207 static int da9063_rtc_start_alarm(struct device *dev)
0208 {
0209     struct da9063_compatible_rtc *rtc = dev_get_drvdata(dev);
0210     const struct da9063_compatible_rtc_regmap *config = rtc->config;
0211 
0212     return regmap_update_bits(rtc->regmap,
0213                   config->rtc_alarm_year_reg,
0214                   config->rtc_alarm_on_mask,
0215                   config->rtc_alarm_on_mask);
0216 }
0217 
0218 static int da9063_rtc_read_time(struct device *dev, struct rtc_time *tm)
0219 {
0220     struct da9063_compatible_rtc *rtc = dev_get_drvdata(dev);
0221     const struct da9063_compatible_rtc_regmap *config = rtc->config;
0222     unsigned long tm_secs;
0223     unsigned long al_secs;
0224     u8 data[RTC_DATA_LEN];
0225     int ret;
0226 
0227     ret = regmap_bulk_read(rtc->regmap,
0228                    config->rtc_count_secs_reg,
0229                    data, RTC_DATA_LEN);
0230     if (ret < 0) {
0231         dev_err(dev, "Failed to read RTC time data: %d\n", ret);
0232         return ret;
0233     }
0234 
0235     if (!(data[RTC_SEC] & config->rtc_ready_to_read_mask)) {
0236         dev_dbg(dev, "RTC not yet ready to be read by the host\n");
0237         return -EINVAL;
0238     }
0239 
0240     da9063_data_to_tm(data, tm, rtc);
0241 
0242     tm_secs = rtc_tm_to_time64(tm);
0243     al_secs = rtc_tm_to_time64(&rtc->alarm_time);
0244 
0245     /* handle the rtc synchronisation delay */
0246     if (rtc->rtc_sync && al_secs - tm_secs == 1)
0247         memcpy(tm, &rtc->alarm_time, sizeof(struct rtc_time));
0248     else
0249         rtc->rtc_sync = false;
0250 
0251     return 0;
0252 }
0253 
0254 static int da9063_rtc_set_time(struct device *dev, struct rtc_time *tm)
0255 {
0256     struct da9063_compatible_rtc *rtc = dev_get_drvdata(dev);
0257     const struct da9063_compatible_rtc_regmap *config = rtc->config;
0258     u8 data[RTC_DATA_LEN];
0259     int ret;
0260 
0261     da9063_tm_to_data(tm, data, rtc);
0262     ret = regmap_bulk_write(rtc->regmap,
0263                 config->rtc_count_secs_reg,
0264                 data, RTC_DATA_LEN);
0265     if (ret < 0)
0266         dev_err(dev, "Failed to set RTC time data: %d\n", ret);
0267 
0268     return ret;
0269 }
0270 
0271 static int da9063_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0272 {
0273     struct da9063_compatible_rtc *rtc = dev_get_drvdata(dev);
0274     const struct da9063_compatible_rtc_regmap *config = rtc->config;
0275     u8 data[RTC_DATA_LEN];
0276     int ret;
0277     unsigned int val;
0278 
0279     data[RTC_SEC] = 0;
0280     ret = regmap_bulk_read(rtc->regmap,
0281                    config->rtc_alarm_secs_reg,
0282                    &data[config->rtc_data_start],
0283                    config->rtc_alarm_len);
0284     if (ret < 0)
0285         return ret;
0286 
0287     da9063_data_to_tm(data, &alrm->time, rtc);
0288 
0289     alrm->enabled = !!(data[RTC_YEAR] & config->rtc_alarm_on_mask);
0290 
0291     ret = regmap_read(rtc->regmap,
0292               config->rtc_event_reg,
0293               &val);
0294     if (ret < 0)
0295         return ret;
0296 
0297     if (val & config->rtc_event_alarm_mask)
0298         alrm->pending = 1;
0299     else
0300         alrm->pending = 0;
0301 
0302     return 0;
0303 }
0304 
0305 static int da9063_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0306 {
0307     struct da9063_compatible_rtc *rtc = dev_get_drvdata(dev);
0308     const struct da9063_compatible_rtc_regmap *config = rtc->config;
0309     u8 data[RTC_DATA_LEN];
0310     int ret;
0311 
0312     da9063_tm_to_data(&alrm->time, data, rtc);
0313 
0314     ret = da9063_rtc_stop_alarm(dev);
0315     if (ret < 0) {
0316         dev_err(dev, "Failed to stop alarm: %d\n", ret);
0317         return ret;
0318     }
0319 
0320     ret = regmap_bulk_write(rtc->regmap,
0321                 config->rtc_alarm_secs_reg,
0322                 &data[config->rtc_data_start],
0323                 config->rtc_alarm_len);
0324     if (ret < 0) {
0325         dev_err(dev, "Failed to write alarm: %d\n", ret);
0326         return ret;
0327     }
0328 
0329     da9063_data_to_tm(data, &rtc->alarm_time, rtc);
0330 
0331     if (alrm->enabled) {
0332         ret = da9063_rtc_start_alarm(dev);
0333         if (ret < 0) {
0334             dev_err(dev, "Failed to start alarm: %d\n", ret);
0335             return ret;
0336         }
0337     }
0338 
0339     return ret;
0340 }
0341 
0342 static int da9063_rtc_alarm_irq_enable(struct device *dev,
0343                        unsigned int enabled)
0344 {
0345     if (enabled)
0346         return da9063_rtc_start_alarm(dev);
0347     else
0348         return da9063_rtc_stop_alarm(dev);
0349 }
0350 
0351 static irqreturn_t da9063_alarm_event(int irq, void *data)
0352 {
0353     struct da9063_compatible_rtc *rtc = data;
0354     const struct da9063_compatible_rtc_regmap *config = rtc->config;
0355 
0356     regmap_update_bits(rtc->regmap,
0357                config->rtc_alarm_year_reg,
0358                config->rtc_alarm_on_mask,
0359                0);
0360 
0361     rtc->rtc_sync = true;
0362     rtc_update_irq(rtc->rtc_dev, 1, RTC_IRQF | RTC_AF);
0363 
0364     return IRQ_HANDLED;
0365 }
0366 
0367 static const struct rtc_class_ops da9063_rtc_ops = {
0368     .read_time = da9063_rtc_read_time,
0369     .set_time = da9063_rtc_set_time,
0370     .read_alarm = da9063_rtc_read_alarm,
0371     .set_alarm = da9063_rtc_set_alarm,
0372     .alarm_irq_enable = da9063_rtc_alarm_irq_enable,
0373 };
0374 
0375 static int da9063_rtc_probe(struct platform_device *pdev)
0376 {
0377     struct da9063_compatible_rtc *rtc;
0378     const struct da9063_compatible_rtc_regmap *config;
0379     const struct of_device_id *match;
0380     int irq_alarm;
0381     u8 data[RTC_DATA_LEN];
0382     int ret;
0383 
0384     if (!pdev->dev.of_node)
0385         return -ENXIO;
0386 
0387     match = of_match_node(da9063_compatible_reg_id_table,
0388                   pdev->dev.of_node);
0389 
0390     rtc = devm_kzalloc(&pdev->dev, sizeof(*rtc), GFP_KERNEL);
0391     if (!rtc)
0392         return -ENOMEM;
0393 
0394     rtc->config = match->data;
0395     if (of_device_is_compatible(pdev->dev.of_node, "dlg,da9063-rtc")) {
0396         struct da9063 *chip = dev_get_drvdata(pdev->dev.parent);
0397 
0398         if (chip->variant_code == PMIC_DA9063_AD)
0399             rtc->config = &da9063_ad_regs;
0400     }
0401 
0402     rtc->regmap = dev_get_regmap(pdev->dev.parent, NULL);
0403     if (!rtc->regmap) {
0404         dev_warn(&pdev->dev, "Parent regmap unavailable.\n");
0405         return -ENXIO;
0406     }
0407 
0408     config = rtc->config;
0409     ret = regmap_update_bits(rtc->regmap,
0410                  config->rtc_enable_reg,
0411                  config->rtc_enable_mask,
0412                  config->rtc_enable_mask);
0413     if (ret < 0) {
0414         dev_err(&pdev->dev, "Failed to enable RTC\n");
0415         return ret;
0416     }
0417 
0418     ret = regmap_update_bits(rtc->regmap,
0419                  config->rtc_enable_32k_crystal_reg,
0420                  config->rtc_crystal_mask,
0421                  config->rtc_crystal_mask);
0422     if (ret < 0) {
0423         dev_err(&pdev->dev, "Failed to run 32kHz oscillator\n");
0424         return ret;
0425     }
0426 
0427     ret = regmap_update_bits(rtc->regmap,
0428                  config->rtc_alarm_secs_reg,
0429                  config->rtc_alarm_status_mask,
0430                  0);
0431     if (ret < 0) {
0432         dev_err(&pdev->dev, "Failed to access RTC alarm register\n");
0433         return ret;
0434     }
0435 
0436     ret = regmap_update_bits(rtc->regmap,
0437                  config->rtc_alarm_secs_reg,
0438                  DA9063_ALARM_STATUS_ALARM,
0439                  DA9063_ALARM_STATUS_ALARM);
0440     if (ret < 0) {
0441         dev_err(&pdev->dev, "Failed to access RTC alarm register\n");
0442         return ret;
0443     }
0444 
0445     ret = regmap_update_bits(rtc->regmap,
0446                  config->rtc_alarm_year_reg,
0447                  config->rtc_tick_on_mask,
0448                  0);
0449     if (ret < 0) {
0450         dev_err(&pdev->dev, "Failed to disable TICKs\n");
0451         return ret;
0452     }
0453 
0454     data[RTC_SEC] = 0;
0455     ret = regmap_bulk_read(rtc->regmap,
0456                    config->rtc_alarm_secs_reg,
0457                    &data[config->rtc_data_start],
0458                    config->rtc_alarm_len);
0459     if (ret < 0) {
0460         dev_err(&pdev->dev, "Failed to read initial alarm data: %d\n",
0461             ret);
0462         return ret;
0463     }
0464 
0465     platform_set_drvdata(pdev, rtc);
0466 
0467     rtc->rtc_dev = devm_rtc_allocate_device(&pdev->dev);
0468     if (IS_ERR(rtc->rtc_dev))
0469         return PTR_ERR(rtc->rtc_dev);
0470 
0471     rtc->rtc_dev->ops = &da9063_rtc_ops;
0472     rtc->rtc_dev->range_min = RTC_TIMESTAMP_BEGIN_2000;
0473     rtc->rtc_dev->range_max = RTC_TIMESTAMP_END_2063;
0474 
0475     da9063_data_to_tm(data, &rtc->alarm_time, rtc);
0476     rtc->rtc_sync = false;
0477 
0478     if (config->rtc_data_start != RTC_SEC) {
0479         set_bit(RTC_FEATURE_ALARM_RES_MINUTE, rtc->rtc_dev->features);
0480         /*
0481          * TODO: some models have alarms on a minute boundary but still
0482          * support real hardware interrupts.
0483          */
0484         clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, rtc->rtc_dev->features);
0485     }
0486 
0487     irq_alarm = platform_get_irq_byname(pdev, "ALARM");
0488     if (irq_alarm < 0)
0489         return irq_alarm;
0490 
0491     ret = devm_request_threaded_irq(&pdev->dev, irq_alarm, NULL,
0492                     da9063_alarm_event,
0493                     IRQF_TRIGGER_LOW | IRQF_ONESHOT,
0494                     "ALARM", rtc);
0495     if (ret)
0496         dev_err(&pdev->dev, "Failed to request ALARM IRQ %d: %d\n",
0497             irq_alarm, ret);
0498 
0499     device_init_wakeup(&pdev->dev, true);
0500 
0501     return devm_rtc_register_device(rtc->rtc_dev);
0502 }
0503 
0504 static struct platform_driver da9063_rtc_driver = {
0505     .probe      = da9063_rtc_probe,
0506     .driver     = {
0507         .name   = DA9063_DRVNAME_RTC,
0508         .of_match_table = da9063_compatible_reg_id_table,
0509     },
0510 };
0511 
0512 module_platform_driver(da9063_rtc_driver);
0513 
0514 MODULE_AUTHOR("S Twiss <stwiss.opensource@diasemi.com>");
0515 MODULE_DESCRIPTION("Real time clock device driver for Dialog DA9063");
0516 MODULE_LICENSE("GPL");
0517 MODULE_ALIAS("platform:" DA9063_DRVNAME_RTC);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!