Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 //
0003 // Copyright (C) 2018 ROHM Semiconductors
0004 //
0005 // RTC driver for ROHM BD71828 and BD71815 PMIC
0006 
0007 #include <linux/bcd.h>
0008 #include <linux/mfd/rohm-bd71815.h>
0009 #include <linux/mfd/rohm-bd71828.h>
0010 #include <linux/module.h>
0011 #include <linux/of.h>
0012 #include <linux/platform_device.h>
0013 #include <linux/regmap.h>
0014 #include <linux/rtc.h>
0015 
0016 /*
0017  * On BD71828 and BD71815 the ALM0 MASK is 14 bytes after the ALM0
0018  * block start
0019  */
0020 #define BD718XX_ALM_EN_OFFSET 14
0021 
0022 /*
0023  * We read regs RTC_SEC => RTC_YEAR
0024  * this struct is ordered according to chip registers.
0025  * Keep it u8 only (or packed) to avoid padding issues.
0026  */
0027 struct bd70528_rtc_day {
0028     u8 sec;
0029     u8 min;
0030     u8 hour;
0031 } __packed;
0032 
0033 struct bd70528_rtc_data {
0034     struct bd70528_rtc_day time;
0035     u8 week;
0036     u8 day;
0037     u8 month;
0038     u8 year;
0039 } __packed;
0040 
0041 struct bd71828_rtc_alm {
0042     struct bd70528_rtc_data alm0;
0043     struct bd70528_rtc_data alm1;
0044     u8 alm_mask;
0045     u8 alm1_mask;
0046 } __packed;
0047 
0048 struct bd70528_rtc {
0049     struct rohm_regmap_dev *parent;
0050     struct regmap *regmap;
0051     struct device *dev;
0052     u8 reg_time_start;
0053     u8 bd718xx_alm_block_start;
0054 };
0055 
0056 static inline void tmday2rtc(struct rtc_time *t, struct bd70528_rtc_day *d)
0057 {
0058     d->sec &= ~BD70528_MASK_RTC_SEC;
0059     d->min &= ~BD70528_MASK_RTC_MINUTE;
0060     d->hour &= ~BD70528_MASK_RTC_HOUR;
0061     d->sec |= bin2bcd(t->tm_sec);
0062     d->min |= bin2bcd(t->tm_min);
0063     d->hour |= bin2bcd(t->tm_hour);
0064 }
0065 
0066 static inline void tm2rtc(struct rtc_time *t, struct bd70528_rtc_data *r)
0067 {
0068     r->day &= ~BD70528_MASK_RTC_DAY;
0069     r->week &= ~BD70528_MASK_RTC_WEEK;
0070     r->month &= ~BD70528_MASK_RTC_MONTH;
0071     /*
0072      * PM and 24H bits are not used by Wake - thus we clear them
0073      * here and not in tmday2rtc() which is also used by wake.
0074      */
0075     r->time.hour &= ~(BD70528_MASK_RTC_HOUR_PM | BD70528_MASK_RTC_HOUR_24H);
0076 
0077     tmday2rtc(t, &r->time);
0078     /*
0079      * We do always set time in 24H mode.
0080      */
0081     r->time.hour |= BD70528_MASK_RTC_HOUR_24H;
0082     r->day |= bin2bcd(t->tm_mday);
0083     r->week |= bin2bcd(t->tm_wday);
0084     r->month |= bin2bcd(t->tm_mon + 1);
0085     r->year = bin2bcd(t->tm_year - 100);
0086 }
0087 
0088 static inline void rtc2tm(struct bd70528_rtc_data *r, struct rtc_time *t)
0089 {
0090     t->tm_sec = bcd2bin(r->time.sec & BD70528_MASK_RTC_SEC);
0091     t->tm_min = bcd2bin(r->time.min & BD70528_MASK_RTC_MINUTE);
0092     t->tm_hour = bcd2bin(r->time.hour & BD70528_MASK_RTC_HOUR);
0093     /*
0094      * If RTC is in 12H mode, then bit BD70528_MASK_RTC_HOUR_PM
0095      * is not BCD value but tells whether it is AM or PM
0096      */
0097     if (!(r->time.hour & BD70528_MASK_RTC_HOUR_24H)) {
0098         t->tm_hour %= 12;
0099         if (r->time.hour & BD70528_MASK_RTC_HOUR_PM)
0100             t->tm_hour += 12;
0101     }
0102     t->tm_mday = bcd2bin(r->day & BD70528_MASK_RTC_DAY);
0103     t->tm_mon = bcd2bin(r->month & BD70528_MASK_RTC_MONTH) - 1;
0104     t->tm_year = 100 + bcd2bin(r->year & BD70528_MASK_RTC_YEAR);
0105     t->tm_wday = bcd2bin(r->week & BD70528_MASK_RTC_WEEK);
0106 }
0107 
0108 static int bd71828_set_alarm(struct device *dev, struct rtc_wkalrm *a)
0109 {
0110     int ret;
0111     struct bd71828_rtc_alm alm;
0112     struct bd70528_rtc *r = dev_get_drvdata(dev);
0113 
0114     ret = regmap_bulk_read(r->regmap, r->bd718xx_alm_block_start, &alm,
0115                    sizeof(alm));
0116     if (ret) {
0117         dev_err(dev, "Failed to read alarm regs\n");
0118         return ret;
0119     }
0120 
0121     tm2rtc(&a->time, &alm.alm0);
0122 
0123     if (!a->enabled)
0124         alm.alm_mask &= ~BD70528_MASK_ALM_EN;
0125     else
0126         alm.alm_mask |= BD70528_MASK_ALM_EN;
0127 
0128     ret = regmap_bulk_write(r->regmap, r->bd718xx_alm_block_start, &alm,
0129                 sizeof(alm));
0130     if (ret)
0131         dev_err(dev, "Failed to set alarm time\n");
0132 
0133     return ret;
0134 
0135 }
0136 
0137 static int bd71828_read_alarm(struct device *dev, struct rtc_wkalrm *a)
0138 {
0139     int ret;
0140     struct bd71828_rtc_alm alm;
0141     struct bd70528_rtc *r = dev_get_drvdata(dev);
0142 
0143     ret = regmap_bulk_read(r->regmap, r->bd718xx_alm_block_start, &alm,
0144                    sizeof(alm));
0145     if (ret) {
0146         dev_err(dev, "Failed to read alarm regs\n");
0147         return ret;
0148     }
0149 
0150     rtc2tm(&alm.alm0, &a->time);
0151     a->time.tm_mday = -1;
0152     a->time.tm_mon = -1;
0153     a->time.tm_year = -1;
0154     a->enabled = !!(alm.alm_mask & BD70528_MASK_ALM_EN);
0155     a->pending = 0;
0156 
0157     return 0;
0158 }
0159 
0160 static int bd71828_set_time(struct device *dev, struct rtc_time *t)
0161 {
0162     int ret;
0163     struct bd70528_rtc_data rtc_data;
0164     struct bd70528_rtc *r = dev_get_drvdata(dev);
0165 
0166     ret = regmap_bulk_read(r->regmap, r->reg_time_start, &rtc_data,
0167                    sizeof(rtc_data));
0168     if (ret) {
0169         dev_err(dev, "Failed to read RTC time registers\n");
0170         return ret;
0171     }
0172     tm2rtc(t, &rtc_data);
0173 
0174     ret = regmap_bulk_write(r->regmap, r->reg_time_start, &rtc_data,
0175                 sizeof(rtc_data));
0176     if (ret)
0177         dev_err(dev, "Failed to set RTC time\n");
0178 
0179     return ret;
0180 }
0181 
0182 static int bd70528_get_time(struct device *dev, struct rtc_time *t)
0183 {
0184     struct bd70528_rtc *r = dev_get_drvdata(dev);
0185     struct bd70528_rtc_data rtc_data;
0186     int ret;
0187 
0188     /* read the RTC date and time registers all at once */
0189     ret = regmap_bulk_read(r->regmap, r->reg_time_start, &rtc_data,
0190                    sizeof(rtc_data));
0191     if (ret) {
0192         dev_err(dev, "Failed to read RTC time (err %d)\n", ret);
0193         return ret;
0194     }
0195 
0196     rtc2tm(&rtc_data, t);
0197 
0198     return 0;
0199 }
0200 
0201 static int bd71828_alm_enable(struct device *dev, unsigned int enabled)
0202 {
0203     int ret;
0204     struct bd70528_rtc *r = dev_get_drvdata(dev);
0205     unsigned int enableval = BD70528_MASK_ALM_EN;
0206 
0207     if (!enabled)
0208         enableval = 0;
0209 
0210     ret = regmap_update_bits(r->regmap, r->bd718xx_alm_block_start +
0211                  BD718XX_ALM_EN_OFFSET, BD70528_MASK_ALM_EN,
0212                  enableval);
0213     if (ret)
0214         dev_err(dev, "Failed to change alarm state\n");
0215 
0216     return ret;
0217 }
0218 
0219 static const struct rtc_class_ops bd71828_rtc_ops = {
0220     .read_time      = bd70528_get_time,
0221     .set_time       = bd71828_set_time,
0222     .read_alarm     = bd71828_read_alarm,
0223     .set_alarm      = bd71828_set_alarm,
0224     .alarm_irq_enable   = bd71828_alm_enable,
0225 };
0226 
0227 static irqreturn_t alm_hndlr(int irq, void *data)
0228 {
0229     struct rtc_device *rtc = data;
0230 
0231     rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF | RTC_PF);
0232     return IRQ_HANDLED;
0233 }
0234 
0235 static int bd70528_probe(struct platform_device *pdev)
0236 {
0237     struct bd70528_rtc *bd_rtc;
0238     const struct rtc_class_ops *rtc_ops;
0239     const char *irq_name;
0240     int ret;
0241     struct rtc_device *rtc;
0242     int irq;
0243     unsigned int hr;
0244     u8 hour_reg;
0245     enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
0246 
0247     bd_rtc = devm_kzalloc(&pdev->dev, sizeof(*bd_rtc), GFP_KERNEL);
0248     if (!bd_rtc)
0249         return -ENOMEM;
0250 
0251     bd_rtc->regmap = dev_get_regmap(pdev->dev.parent, NULL);
0252     if (!bd_rtc->regmap) {
0253         dev_err(&pdev->dev, "No regmap\n");
0254         return -EINVAL;
0255     }
0256 
0257     bd_rtc->dev = &pdev->dev;
0258     rtc_ops = &bd71828_rtc_ops;
0259 
0260     switch (chip) {
0261     case ROHM_CHIP_TYPE_BD71815:
0262         irq_name = "bd71815-rtc-alm-0";
0263         bd_rtc->reg_time_start = BD71815_REG_RTC_START;
0264 
0265         /*
0266          * See also BD718XX_ALM_EN_OFFSET:
0267          * This works for BD71828 and BD71815 as they have same offset
0268          * between ALM0 start and ALM0_MASK. If new ICs are to be
0269          * added this requires proper check as ALM0_MASK is not located
0270          * at the end of ALM0 block - but after all ALM blocks so if
0271          * amount of ALMs differ the offset to enable/disable is likely
0272          * to be incorrect and enable/disable must be given as own
0273          * reg address here.
0274          */
0275         bd_rtc->bd718xx_alm_block_start = BD71815_REG_RTC_ALM_START;
0276         hour_reg = BD71815_REG_HOUR;
0277         break;
0278     case ROHM_CHIP_TYPE_BD71828:
0279         irq_name = "bd71828-rtc-alm-0";
0280         bd_rtc->reg_time_start = BD71828_REG_RTC_START;
0281         bd_rtc->bd718xx_alm_block_start = BD71828_REG_RTC_ALM_START;
0282         hour_reg = BD71828_REG_RTC_HOUR;
0283         break;
0284     default:
0285         dev_err(&pdev->dev, "Unknown chip\n");
0286         return -ENOENT;
0287     }
0288 
0289     irq = platform_get_irq_byname(pdev, irq_name);
0290 
0291     if (irq < 0)
0292         return irq;
0293 
0294     platform_set_drvdata(pdev, bd_rtc);
0295 
0296     ret = regmap_read(bd_rtc->regmap, hour_reg, &hr);
0297 
0298     if (ret) {
0299         dev_err(&pdev->dev, "Failed to reag RTC clock\n");
0300         return ret;
0301     }
0302 
0303     if (!(hr & BD70528_MASK_RTC_HOUR_24H)) {
0304         struct rtc_time t;
0305 
0306         ret = rtc_ops->read_time(&pdev->dev, &t);
0307 
0308         if (!ret)
0309             ret = rtc_ops->set_time(&pdev->dev, &t);
0310 
0311         if (ret) {
0312             dev_err(&pdev->dev,
0313                 "Setting 24H clock for RTC failed\n");
0314             return ret;
0315         }
0316     }
0317 
0318     device_set_wakeup_capable(&pdev->dev, true);
0319     device_wakeup_enable(&pdev->dev);
0320 
0321     rtc = devm_rtc_allocate_device(&pdev->dev);
0322     if (IS_ERR(rtc)) {
0323         dev_err(&pdev->dev, "RTC device creation failed\n");
0324         return PTR_ERR(rtc);
0325     }
0326 
0327     rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
0328     rtc->range_max = RTC_TIMESTAMP_END_2099;
0329     rtc->ops = rtc_ops;
0330 
0331     /* Request alarm IRQ prior to registerig the RTC */
0332     ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, &alm_hndlr,
0333                     IRQF_ONESHOT, "bd70528-rtc", rtc);
0334     if (ret)
0335         return ret;
0336 
0337     return devm_rtc_register_device(rtc);
0338 }
0339 
0340 static const struct platform_device_id bd718x7_rtc_id[] = {
0341     { "bd71828-rtc", ROHM_CHIP_TYPE_BD71828 },
0342     { "bd71815-rtc", ROHM_CHIP_TYPE_BD71815 },
0343     { },
0344 };
0345 MODULE_DEVICE_TABLE(platform, bd718x7_rtc_id);
0346 
0347 static struct platform_driver bd70528_rtc = {
0348     .driver = {
0349         .name = "bd70528-rtc"
0350     },
0351     .probe = bd70528_probe,
0352     .id_table = bd718x7_rtc_id,
0353 };
0354 
0355 module_platform_driver(bd70528_rtc);
0356 
0357 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
0358 MODULE_DESCRIPTION("ROHM BD71828 and BD71815 PMIC RTC driver");
0359 MODULE_LICENSE("GPL");
0360 MODULE_ALIAS("platform:bd70528-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!