Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 //
0003 // RTC driver for Maxim MAX8997
0004 //
0005 // Copyright (C) 2013 Samsung Electronics Co.Ltd
0006 //
0007 //  based on rtc-max8998.c
0008 
0009 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0010 
0011 #include <linux/slab.h>
0012 #include <linux/rtc.h>
0013 #include <linux/delay.h>
0014 #include <linux/mutex.h>
0015 #include <linux/module.h>
0016 #include <linux/platform_device.h>
0017 #include <linux/mfd/max8997-private.h>
0018 #include <linux/irqdomain.h>
0019 
0020 /* Module parameter for WTSR function control */
0021 static int wtsr_en = 1;
0022 module_param(wtsr_en, int, 0444);
0023 MODULE_PARM_DESC(wtsr_en, "Watchdog Timeout & Software Reset (default=on)");
0024 /* Module parameter for SMPL function control */
0025 static int smpl_en = 1;
0026 module_param(smpl_en, int, 0444);
0027 MODULE_PARM_DESC(smpl_en, "Sudden Momentary Power Loss (default=on)");
0028 
0029 /* RTC Control Register */
0030 #define BCD_EN_SHIFT            0
0031 #define BCD_EN_MASK         (1 << BCD_EN_SHIFT)
0032 #define MODEL24_SHIFT           1
0033 #define MODEL24_MASK            (1 << MODEL24_SHIFT)
0034 /* RTC Update Register1 */
0035 #define RTC_UDR_SHIFT           0
0036 #define RTC_UDR_MASK            (1 << RTC_UDR_SHIFT)
0037 /* WTSR and SMPL Register */
0038 #define WTSRT_SHIFT         0
0039 #define SMPLT_SHIFT         2
0040 #define WTSR_EN_SHIFT           6
0041 #define SMPL_EN_SHIFT           7
0042 #define WTSRT_MASK          (3 << WTSRT_SHIFT)
0043 #define SMPLT_MASK          (3 << SMPLT_SHIFT)
0044 #define WTSR_EN_MASK            (1 << WTSR_EN_SHIFT)
0045 #define SMPL_EN_MASK            (1 << SMPL_EN_SHIFT)
0046 /* RTC Hour register */
0047 #define HOUR_PM_SHIFT           6
0048 #define HOUR_PM_MASK            (1 << HOUR_PM_SHIFT)
0049 /* RTC Alarm Enable */
0050 #define ALARM_ENABLE_SHIFT      7
0051 #define ALARM_ENABLE_MASK       (1 << ALARM_ENABLE_SHIFT)
0052 
0053 enum {
0054     RTC_SEC = 0,
0055     RTC_MIN,
0056     RTC_HOUR,
0057     RTC_WEEKDAY,
0058     RTC_MONTH,
0059     RTC_YEAR,
0060     RTC_DATE,
0061     RTC_NR_TIME
0062 };
0063 
0064 struct max8997_rtc_info {
0065     struct device       *dev;
0066     struct max8997_dev  *max8997;
0067     struct i2c_client   *rtc;
0068     struct rtc_device   *rtc_dev;
0069     struct mutex        lock;
0070     int virq;
0071     int rtc_24hr_mode;
0072 };
0073 
0074 static void max8997_rtc_data_to_tm(u8 *data, struct rtc_time *tm,
0075                    int rtc_24hr_mode)
0076 {
0077     tm->tm_sec = data[RTC_SEC] & 0x7f;
0078     tm->tm_min = data[RTC_MIN] & 0x7f;
0079     if (rtc_24hr_mode)
0080         tm->tm_hour = data[RTC_HOUR] & 0x1f;
0081     else {
0082         tm->tm_hour = data[RTC_HOUR] & 0x0f;
0083         if (data[RTC_HOUR] & HOUR_PM_MASK)
0084             tm->tm_hour += 12;
0085     }
0086 
0087     tm->tm_wday = fls(data[RTC_WEEKDAY] & 0x7f) - 1;
0088     tm->tm_mday = data[RTC_DATE] & 0x1f;
0089     tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;
0090     tm->tm_year = (data[RTC_YEAR] & 0x7f) + 100;
0091     tm->tm_yday = 0;
0092     tm->tm_isdst = 0;
0093 }
0094 
0095 static int max8997_rtc_tm_to_data(struct rtc_time *tm, u8 *data)
0096 {
0097     data[RTC_SEC] = tm->tm_sec;
0098     data[RTC_MIN] = tm->tm_min;
0099     data[RTC_HOUR] = tm->tm_hour;
0100     data[RTC_WEEKDAY] = 1 << tm->tm_wday;
0101     data[RTC_DATE] = tm->tm_mday;
0102     data[RTC_MONTH] = tm->tm_mon + 1;
0103     data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0;
0104 
0105     if (tm->tm_year < 100) {
0106         pr_warn("RTC cannot handle the year %d.  Assume it's 2000.\n",
0107             1900 + tm->tm_year);
0108         return -EINVAL;
0109     }
0110     return 0;
0111 }
0112 
0113 static inline int max8997_rtc_set_update_reg(struct max8997_rtc_info *info)
0114 {
0115     int ret;
0116 
0117     ret = max8997_write_reg(info->rtc, MAX8997_RTC_UPDATE1,
0118                         RTC_UDR_MASK);
0119     if (ret < 0)
0120         dev_err(info->dev, "%s: fail to write update reg(%d)\n",
0121                 __func__, ret);
0122     else {
0123         /* Minimum 16ms delay required before RTC update.
0124          * Otherwise, we may read and update based on out-of-date
0125          * value */
0126         msleep(20);
0127     }
0128 
0129     return ret;
0130 }
0131 
0132 static int max8997_rtc_read_time(struct device *dev, struct rtc_time *tm)
0133 {
0134     struct max8997_rtc_info *info = dev_get_drvdata(dev);
0135     u8 data[RTC_NR_TIME];
0136     int ret;
0137 
0138     mutex_lock(&info->lock);
0139     ret = max8997_bulk_read(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data);
0140     mutex_unlock(&info->lock);
0141 
0142     if (ret < 0) {
0143         dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__,
0144                 ret);
0145         return ret;
0146     }
0147 
0148     max8997_rtc_data_to_tm(data, tm, info->rtc_24hr_mode);
0149 
0150     return 0;
0151 }
0152 
0153 static int max8997_rtc_set_time(struct device *dev, struct rtc_time *tm)
0154 {
0155     struct max8997_rtc_info *info = dev_get_drvdata(dev);
0156     u8 data[RTC_NR_TIME];
0157     int ret;
0158 
0159     ret = max8997_rtc_tm_to_data(tm, data);
0160     if (ret < 0)
0161         return ret;
0162 
0163     mutex_lock(&info->lock);
0164 
0165     ret = max8997_bulk_write(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data);
0166     if (ret < 0) {
0167         dev_err(info->dev, "%s: fail to write time reg(%d)\n", __func__,
0168                 ret);
0169         goto out;
0170     }
0171 
0172     ret = max8997_rtc_set_update_reg(info);
0173 out:
0174     mutex_unlock(&info->lock);
0175     return ret;
0176 }
0177 
0178 static int max8997_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0179 {
0180     struct max8997_rtc_info *info = dev_get_drvdata(dev);
0181     u8 data[RTC_NR_TIME];
0182     u8 val;
0183     int i, ret;
0184 
0185     mutex_lock(&info->lock);
0186 
0187     ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
0188             data);
0189     if (ret < 0) {
0190         dev_err(info->dev, "%s:%d fail to read alarm reg(%d)\n",
0191                 __func__, __LINE__, ret);
0192         goto out;
0193     }
0194 
0195     max8997_rtc_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);
0196 
0197     alrm->enabled = 0;
0198     for (i = 0; i < RTC_NR_TIME; i++) {
0199         if (data[i] & ALARM_ENABLE_MASK) {
0200             alrm->enabled = 1;
0201             break;
0202         }
0203     }
0204 
0205     alrm->pending = 0;
0206     ret = max8997_read_reg(info->max8997->i2c, MAX8997_REG_STATUS1, &val);
0207     if (ret < 0) {
0208         dev_err(info->dev, "%s:%d fail to read status1 reg(%d)\n",
0209                 __func__, __LINE__, ret);
0210         goto out;
0211     }
0212 
0213     if (val & (1 << 4)) /* RTCA1 */
0214         alrm->pending = 1;
0215 
0216 out:
0217     mutex_unlock(&info->lock);
0218     return ret;
0219 }
0220 
0221 static int max8997_rtc_stop_alarm(struct max8997_rtc_info *info)
0222 {
0223     u8 data[RTC_NR_TIME];
0224     int ret, i;
0225 
0226     if (!mutex_is_locked(&info->lock))
0227         dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
0228 
0229     ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
0230                 data);
0231     if (ret < 0) {
0232         dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
0233                 __func__, ret);
0234         goto out;
0235     }
0236 
0237     for (i = 0; i < RTC_NR_TIME; i++)
0238         data[i] &= ~ALARM_ENABLE_MASK;
0239 
0240     ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
0241                  data);
0242     if (ret < 0) {
0243         dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
0244                 __func__, ret);
0245         goto out;
0246     }
0247 
0248     ret = max8997_rtc_set_update_reg(info);
0249 out:
0250     return ret;
0251 }
0252 
0253 static int max8997_rtc_start_alarm(struct max8997_rtc_info *info)
0254 {
0255     u8 data[RTC_NR_TIME];
0256     int ret;
0257 
0258     if (!mutex_is_locked(&info->lock))
0259         dev_warn(info->dev, "%s: should have mutex locked\n", __func__);
0260 
0261     ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
0262                 data);
0263     if (ret < 0) {
0264         dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",
0265                 __func__, ret);
0266         goto out;
0267     }
0268 
0269     data[RTC_SEC] |= (1 << ALARM_ENABLE_SHIFT);
0270     data[RTC_MIN] |= (1 << ALARM_ENABLE_SHIFT);
0271     data[RTC_HOUR] |= (1 << ALARM_ENABLE_SHIFT);
0272     data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;
0273     if (data[RTC_MONTH] & 0xf)
0274         data[RTC_MONTH] |= (1 << ALARM_ENABLE_SHIFT);
0275     if (data[RTC_YEAR] & 0x7f)
0276         data[RTC_YEAR] |= (1 << ALARM_ENABLE_SHIFT);
0277     if (data[RTC_DATE] & 0x1f)
0278         data[RTC_DATE] |= (1 << ALARM_ENABLE_SHIFT);
0279 
0280     ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
0281                  data);
0282     if (ret < 0) {
0283         dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
0284                 __func__, ret);
0285         goto out;
0286     }
0287 
0288     ret = max8997_rtc_set_update_reg(info);
0289 out:
0290     return ret;
0291 }
0292 static int max8997_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
0293 {
0294     struct max8997_rtc_info *info = dev_get_drvdata(dev);
0295     u8 data[RTC_NR_TIME];
0296     int ret;
0297 
0298     ret = max8997_rtc_tm_to_data(&alrm->time, data);
0299     if (ret < 0)
0300         return ret;
0301 
0302     dev_info(info->dev, "%s: %d-%02d-%02d %02d:%02d:%02d\n", __func__,
0303             data[RTC_YEAR] + 2000, data[RTC_MONTH], data[RTC_DATE],
0304             data[RTC_HOUR], data[RTC_MIN], data[RTC_SEC]);
0305 
0306     mutex_lock(&info->lock);
0307 
0308     ret = max8997_rtc_stop_alarm(info);
0309     if (ret < 0)
0310         goto out;
0311 
0312     ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,
0313                 data);
0314     if (ret < 0) {
0315         dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",
0316                 __func__, ret);
0317         goto out;
0318     }
0319 
0320     ret = max8997_rtc_set_update_reg(info);
0321     if (ret < 0)
0322         goto out;
0323 
0324     if (alrm->enabled)
0325         ret = max8997_rtc_start_alarm(info);
0326 out:
0327     mutex_unlock(&info->lock);
0328     return ret;
0329 }
0330 
0331 static int max8997_rtc_alarm_irq_enable(struct device *dev,
0332                     unsigned int enabled)
0333 {
0334     struct max8997_rtc_info *info = dev_get_drvdata(dev);
0335     int ret;
0336 
0337     mutex_lock(&info->lock);
0338     if (enabled)
0339         ret = max8997_rtc_start_alarm(info);
0340     else
0341         ret = max8997_rtc_stop_alarm(info);
0342     mutex_unlock(&info->lock);
0343 
0344     return ret;
0345 }
0346 
0347 static irqreturn_t max8997_rtc_alarm_irq(int irq, void *data)
0348 {
0349     struct max8997_rtc_info *info = data;
0350 
0351     dev_info(info->dev, "%s:irq(%d)\n", __func__, irq);
0352 
0353     rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);
0354 
0355     return IRQ_HANDLED;
0356 }
0357 
0358 static const struct rtc_class_ops max8997_rtc_ops = {
0359     .read_time = max8997_rtc_read_time,
0360     .set_time = max8997_rtc_set_time,
0361     .read_alarm = max8997_rtc_read_alarm,
0362     .set_alarm = max8997_rtc_set_alarm,
0363     .alarm_irq_enable = max8997_rtc_alarm_irq_enable,
0364 };
0365 
0366 static void max8997_rtc_enable_wtsr(struct max8997_rtc_info *info, bool enable)
0367 {
0368     int ret;
0369     u8 val, mask;
0370 
0371     if (!wtsr_en)
0372         return;
0373 
0374     if (enable)
0375         val = (1 << WTSR_EN_SHIFT) | (3 << WTSRT_SHIFT);
0376     else
0377         val = 0;
0378 
0379     mask = WTSR_EN_MASK | WTSRT_MASK;
0380 
0381     dev_info(info->dev, "%s: %s WTSR\n", __func__,
0382             enable ? "enable" : "disable");
0383 
0384     ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask);
0385     if (ret < 0) {
0386         dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n",
0387                 __func__, ret);
0388         return;
0389     }
0390 
0391     max8997_rtc_set_update_reg(info);
0392 }
0393 
0394 static void max8997_rtc_enable_smpl(struct max8997_rtc_info *info, bool enable)
0395 {
0396     int ret;
0397     u8 val, mask;
0398 
0399     if (!smpl_en)
0400         return;
0401 
0402     if (enable)
0403         val = (1 << SMPL_EN_SHIFT) | (0 << SMPLT_SHIFT);
0404     else
0405         val = 0;
0406 
0407     mask = SMPL_EN_MASK | SMPLT_MASK;
0408 
0409     dev_info(info->dev, "%s: %s SMPL\n", __func__,
0410             enable ? "enable" : "disable");
0411 
0412     ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask);
0413     if (ret < 0) {
0414         dev_err(info->dev, "%s: fail to update SMPL reg(%d)\n",
0415                 __func__, ret);
0416         return;
0417     }
0418 
0419     max8997_rtc_set_update_reg(info);
0420 
0421     val = 0;
0422     max8997_read_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, &val);
0423     pr_info("WTSR_SMPL(0x%02x)\n", val);
0424 }
0425 
0426 static int max8997_rtc_init_reg(struct max8997_rtc_info *info)
0427 {
0428     u8 data[2];
0429     int ret;
0430 
0431     /* Set RTC control register : Binary mode, 24hour mdoe */
0432     data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
0433     data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);
0434 
0435     info->rtc_24hr_mode = 1;
0436 
0437     ret = max8997_bulk_write(info->rtc, MAX8997_RTC_CTRLMASK, 2, data);
0438     if (ret < 0) {
0439         dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",
0440                 __func__, ret);
0441         return ret;
0442     }
0443 
0444     ret = max8997_rtc_set_update_reg(info);
0445     return ret;
0446 }
0447 
0448 static int max8997_rtc_probe(struct platform_device *pdev)
0449 {
0450     struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent);
0451     struct max8997_rtc_info *info;
0452     int ret, virq;
0453 
0454     info = devm_kzalloc(&pdev->dev, sizeof(struct max8997_rtc_info),
0455             GFP_KERNEL);
0456     if (!info)
0457         return -ENOMEM;
0458 
0459     mutex_init(&info->lock);
0460     info->dev = &pdev->dev;
0461     info->max8997 = max8997;
0462     info->rtc = max8997->rtc;
0463 
0464     platform_set_drvdata(pdev, info);
0465 
0466     ret = max8997_rtc_init_reg(info);
0467 
0468     if (ret < 0) {
0469         dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret);
0470         return ret;
0471     }
0472 
0473     max8997_rtc_enable_wtsr(info, true);
0474     max8997_rtc_enable_smpl(info, true);
0475 
0476     device_init_wakeup(&pdev->dev, 1);
0477 
0478     info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8997-rtc",
0479                     &max8997_rtc_ops, THIS_MODULE);
0480 
0481     if (IS_ERR(info->rtc_dev)) {
0482         ret = PTR_ERR(info->rtc_dev);
0483         dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);
0484         return ret;
0485     }
0486 
0487     virq = irq_create_mapping(max8997->irq_domain, MAX8997_PMICIRQ_RTCA1);
0488     if (!virq) {
0489         dev_err(&pdev->dev, "Failed to create mapping alarm IRQ\n");
0490         ret = -ENXIO;
0491         goto err_out;
0492     }
0493     info->virq = virq;
0494 
0495     ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,
0496                 max8997_rtc_alarm_irq, 0,
0497                 "rtc-alarm0", info);
0498     if (ret < 0)
0499         dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",
0500             info->virq, ret);
0501 
0502 err_out:
0503     return ret;
0504 }
0505 
0506 static void max8997_rtc_shutdown(struct platform_device *pdev)
0507 {
0508     struct max8997_rtc_info *info = platform_get_drvdata(pdev);
0509 
0510     max8997_rtc_enable_wtsr(info, false);
0511     max8997_rtc_enable_smpl(info, false);
0512 }
0513 
0514 static const struct platform_device_id rtc_id[] = {
0515     { "max8997-rtc", 0 },
0516     {},
0517 };
0518 MODULE_DEVICE_TABLE(platform, rtc_id);
0519 
0520 static struct platform_driver max8997_rtc_driver = {
0521     .driver     = {
0522         .name   = "max8997-rtc",
0523     },
0524     .probe      = max8997_rtc_probe,
0525     .shutdown   = max8997_rtc_shutdown,
0526     .id_table   = rtc_id,
0527 };
0528 
0529 module_platform_driver(max8997_rtc_driver);
0530 
0531 MODULE_DESCRIPTION("Maxim MAX8997 RTC driver");
0532 MODULE_AUTHOR("<ms925.kim@samsung.com>");
0533 MODULE_LICENSE("GPL");
[ 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!