drivers/rtc/rtc-bd70528.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 //
   3 // Copyright (C) 2018 ROHM Semiconductors
   4 //
   5 // RTC driver for ROHM BD71828 and BD71815 PMIC
   6
   7 #include <linux/bcd.h>
   8 #include <linux/mfd/rohm-bd71815.h>
   9 #include <linux/mfd/rohm-bd71828.h>
  10 #include <linux/module.h>
  11 #include <linux/of.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/regmap.h>
  14 #include <linux/rtc.h>
  15
  16 /*
  17  * On BD71828 and BD71815 the ALM0 MASK is 14 bytes after the ALM0
  18  * block start
  19  */
  20 #define BD718XX_ALM_EN_OFFSET 14
  21
  22 /*
  23  * We read regs RTC_SEC => RTC_YEAR
  24  * this struct is ordered according to chip registers.
  25  * Keep it u8 only (or packed) to avoid padding issues.
  26  */
  27 struct bd70528_rtc_day {
  28         u8 sec;
  29         u8 min;
  30         u8 hour;
  31 } __packed;
  32
  33 struct bd70528_rtc_data {
  34         struct bd70528_rtc_day time;
  35         u8 week;
  36         u8 day;
  37         u8 month;
  38         u8 year;
  39 } __packed;
  40
  41 struct bd71828_rtc_alm {
  42         struct bd70528_rtc_data alm0;
  43         struct bd70528_rtc_data alm1;
  44         u8 alm_mask;
  45         u8 alm1_mask;
  46 } __packed;
  47
  48 struct bd70528_rtc {
  49         struct rohm_regmap_dev *parent;
  50         struct regmap *regmap;
  51         struct device *dev;
  52         u8 reg_time_start;
  53         u8 bd718xx_alm_block_start;
  54 };
  55
  56 static inline void tmday2rtc(struct rtc_time *t, struct bd70528_rtc_day *d)
  57 {
  58         d->sec &= ~BD70528_MASK_RTC_SEC;
  59         d->min &= ~BD70528_MASK_RTC_MINUTE;
  60         d->hour &= ~BD70528_MASK_RTC_HOUR;
  61         d->sec |= bin2bcd(t->tm_sec);
  62         d->min |= bin2bcd(t->tm_min);
  63         d->hour |= bin2bcd(t->tm_hour);
  64 }
  65
  66 static inline void tm2rtc(struct rtc_time *t, struct bd70528_rtc_data *r)
  67 {
  68         r->day &= ~BD70528_MASK_RTC_DAY;
  69         r->week &= ~BD70528_MASK_RTC_WEEK;
  70         r->month &= ~BD70528_MASK_RTC_MONTH;
  71         /*
  72          * PM and 24H bits are not used by Wake - thus we clear them
  73          * here and not in tmday2rtc() which is also used by wake.
  74          */
  75         r->time.hour &= ~(BD70528_MASK_RTC_HOUR_PM | BD70528_MASK_RTC_HOUR_24H);
  76
  77         tmday2rtc(t, &r->time);
  78         /*
  79          * We do always set time in 24H mode.
  80          */
  81         r->time.hour |= BD70528_MASK_RTC_HOUR_24H;
  82         r->day |= bin2bcd(t->tm_mday);
  83         r->week |= bin2bcd(t->tm_wday);
  84         r->month |= bin2bcd(t->tm_mon + 1);
  85         r->year = bin2bcd(t->tm_year - 100);
  86 }
  87
  88 static inline void rtc2tm(struct bd70528_rtc_data *r, struct rtc_time *t)
  89 {
  90         t->tm_sec = bcd2bin(r->time.sec & BD70528_MASK_RTC_SEC);
  91         t->tm_min = bcd2bin(r->time.min & BD70528_MASK_RTC_MINUTE);
  92         t->tm_hour = bcd2bin(r->time.hour & BD70528_MASK_RTC_HOUR);
  93         /*
  94          * If RTC is in 12H mode, then bit BD70528_MASK_RTC_HOUR_PM
  95          * is not BCD value but tells whether it is AM or PM
  96          */
  97         if (!(r->time.hour & BD70528_MASK_RTC_HOUR_24H)) {
  98                 t->tm_hour %= 12;
  99                 if (r->time.hour & BD70528_MASK_RTC_HOUR_PM)
 100                         t->tm_hour += 12;
 101         }
 102         t->tm_mday = bcd2bin(r->day & BD70528_MASK_RTC_DAY);
 103         t->tm_mon = bcd2bin(r->month & BD70528_MASK_RTC_MONTH) - 1;
 104         t->tm_year = 100 + bcd2bin(r->year & BD70528_MASK_RTC_YEAR);
 105         t->tm_wday = bcd2bin(r->week & BD70528_MASK_RTC_WEEK);
 106 }
 107
 108 static int bd71828_set_alarm(struct device *dev, struct rtc_wkalrm *a)
 109 {
 110         int ret;
 111         struct bd71828_rtc_alm alm;
 112         struct bd70528_rtc *r = dev_get_drvdata(dev);
 113
 114         ret = regmap_bulk_read(r->regmap, r->bd718xx_alm_block_start, &alm,
 115                                sizeof(alm));
 116         if (ret) {
 117                 dev_err(dev, "Failed to read alarm regs\n");
 118                 return ret;
 119         }
 120
 121         tm2rtc(&a->time, &alm.alm0);
 122
 123         if (!a->enabled)
 124                 alm.alm_mask &= ~BD70528_MASK_ALM_EN;
 125         else
 126                 alm.alm_mask |= BD70528_MASK_ALM_EN;
 127
 128         ret = regmap_bulk_write(r->regmap, r->bd718xx_alm_block_start, &alm,
 129                                 sizeof(alm));
 130         if (ret)
 131                 dev_err(dev, "Failed to set alarm time\n");
 132
 133         return ret;
 134
 135 }
 136
 137 static int bd71828_read_alarm(struct device *dev, struct rtc_wkalrm *a)
 138 {
 139         int ret;
 140         struct bd71828_rtc_alm alm;
 141         struct bd70528_rtc *r = dev_get_drvdata(dev);
 142
 143         ret = regmap_bulk_read(r->regmap, r->bd718xx_alm_block_start, &alm,
 144                                sizeof(alm));
 145         if (ret) {
 146                 dev_err(dev, "Failed to read alarm regs\n");
 147                 return ret;
 148         }
 149
 150         rtc2tm(&alm.alm0, &a->time);
 151         a->time.tm_mday = -1;
 152         a->time.tm_mon = -1;
 153         a->time.tm_year = -1;
 154         a->enabled = !!(alm.alm_mask & BD70528_MASK_ALM_EN);
 155         a->pending = 0;
 156
 157         return 0;
 158 }
 159
 160 static int bd71828_set_time(struct device *dev, struct rtc_time *t)
 161 {
 162         int ret;
 163         struct bd70528_rtc_data rtc_data;
 164         struct bd70528_rtc *r = dev_get_drvdata(dev);
 165
 166         ret = regmap_bulk_read(r->regmap, r->reg_time_start, &rtc_data,
 167                                sizeof(rtc_data));
 168         if (ret) {
 169                 dev_err(dev, "Failed to read RTC time registers\n");
 170                 return ret;
 171         }
 172         tm2rtc(t, &rtc_data);
 173
 174         ret = regmap_bulk_write(r->regmap, r->reg_time_start, &rtc_data,
 175                                 sizeof(rtc_data));
 176         if (ret)
 177                 dev_err(dev, "Failed to set RTC time\n");
 178
 179         return ret;
 180 }
 181
 182 static int bd70528_get_time(struct device *dev, struct rtc_time *t)
 183 {
 184         struct bd70528_rtc *r = dev_get_drvdata(dev);
 185         struct bd70528_rtc_data rtc_data;
 186         int ret;
 187
 188         /* read the RTC date and time registers all at once */
 189         ret = regmap_bulk_read(r->regmap, r->reg_time_start, &rtc_data,
 190                                sizeof(rtc_data));
 191         if (ret) {
 192                 dev_err(dev, "Failed to read RTC time (err %d)\n", ret);
 193                 return ret;
 194         }
 195
 196         rtc2tm(&rtc_data, t);
 197
 198         return 0;
 199 }
 200
 201 static int bd71828_alm_enable(struct device *dev, unsigned int enabled)
 202 {
 203         int ret;
 204         struct bd70528_rtc *r = dev_get_drvdata(dev);
 205         unsigned int enableval = BD70528_MASK_ALM_EN;
 206
 207         if (!enabled)
 208                 enableval = 0;
 209
 210         ret = regmap_update_bits(r->regmap, r->bd718xx_alm_block_start +
 211                                  BD718XX_ALM_EN_OFFSET, BD70528_MASK_ALM_EN,
 212                                  enableval);
 213         if (ret)
 214                 dev_err(dev, "Failed to change alarm state\n");
 215
 216         return ret;
 217 }
 218
 219 static const struct rtc_class_ops bd71828_rtc_ops = {
 220         .read_time              = bd70528_get_time,
 221         .set_time               = bd71828_set_time,
 222         .read_alarm             = bd71828_read_alarm,
 223         .set_alarm              = bd71828_set_alarm,
 224         .alarm_irq_enable       = bd71828_alm_enable,
 225 };
 226
 227 static irqreturn_t alm_hndlr(int irq, void *data)
 228 {
 229         struct rtc_device *rtc = data;
 230
 231         rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF | RTC_PF);
 232         return IRQ_HANDLED;
 233 }
 234
 235 static int bd70528_probe(struct platform_device *pdev)
 236 {
 237         struct bd70528_rtc *bd_rtc;
 238         const struct rtc_class_ops *rtc_ops;
 239         int ret;
 240         struct rtc_device *rtc;
 241         int irq;
 242         unsigned int hr;
 243         u8 hour_reg;
 244         enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
 245
 246         bd_rtc = devm_kzalloc(&pdev->dev, sizeof(*bd_rtc), GFP_KERNEL);
 247         if (!bd_rtc)
 248                 return -ENOMEM;
 249
 250         bd_rtc->regmap = dev_get_regmap(pdev->dev.parent, NULL);
 251         if (!bd_rtc->regmap) {
 252                 dev_err(&pdev->dev, "No regmap\n");
 253                 return -EINVAL;
 254         }
 255
 256         bd_rtc->dev = &pdev->dev;
 257         rtc_ops = &bd71828_rtc_ops;
 258
 259         switch (chip) {
 260         case ROHM_CHIP_TYPE_BD71815:
 261                 bd_rtc->reg_time_start = BD71815_REG_RTC_START;
 262
 263                 /*
 264                  * See also BD718XX_ALM_EN_OFFSET:
 265                  * This works for BD71828 and BD71815 as they have same offset
 266                  * between ALM0 start and ALM0_MASK. If new ICs are to be
 267                  * added this requires proper check as ALM0_MASK is not located
 268                  * at the end of ALM0 block - but after all ALM blocks so if
 269                  * amount of ALMs differ the offset to enable/disable is likely
 270                  * to be incorrect and enable/disable must be given as own
 271                  * reg address here.
 272                  */
 273                 bd_rtc->bd718xx_alm_block_start = BD71815_REG_RTC_ALM_START;
 274                 hour_reg = BD71815_REG_HOUR;
 275                 break;
 276         case ROHM_CHIP_TYPE_BD71828:
 277                 bd_rtc->reg_time_start = BD71828_REG_RTC_START;
 278                 bd_rtc->bd718xx_alm_block_start = BD71828_REG_RTC_ALM_START;
 279                 hour_reg = BD71828_REG_RTC_HOUR;
 280                 break;
 281         default:
 282                 dev_err(&pdev->dev, "Unknown chip\n");
 283                 return -ENOENT;
 284         }
 285
 286         irq = platform_get_irq_byname(pdev, "bd70528-rtc-alm-0");
 287
 288         if (irq < 0)
 289                 return irq;
 290
 291         platform_set_drvdata(pdev, bd_rtc);
 292
 293         ret = regmap_read(bd_rtc->regmap, hour_reg, &hr);
 294
 295         if (ret) {
 296                 dev_err(&pdev->dev, "Failed to reag RTC clock\n");
 297                 return ret;
 298         }
 299
 300         if (!(hr & BD70528_MASK_RTC_HOUR_24H)) {
 301                 struct rtc_time t;
 302
 303                 ret = rtc_ops->read_time(&pdev->dev, &t);
 304
 305                 if (!ret)
 306                         ret = rtc_ops->set_time(&pdev->dev, &t);
 307
 308                 if (ret) {
 309                         dev_err(&pdev->dev,
 310                                 "Setting 24H clock for RTC failed\n");
 311                         return ret;
 312                 }
 313         }
 314
 315         device_set_wakeup_capable(&pdev->dev, true);
 316         device_wakeup_enable(&pdev->dev);
 317
 318         rtc = devm_rtc_allocate_device(&pdev->dev);
 319         if (IS_ERR(rtc)) {
 320                 dev_err(&pdev->dev, "RTC device creation failed\n");
 321                 return PTR_ERR(rtc);
 322         }
 323
 324         rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
 325         rtc->range_max = RTC_TIMESTAMP_END_2099;
 326         rtc->ops = rtc_ops;
 327
 328         /* Request alarm IRQ prior to registerig the RTC */
 329         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, &alm_hndlr,
 330                                         IRQF_ONESHOT, "bd70528-rtc", rtc);
 331         if (ret)
 332                 return ret;
 333
 334         return devm_rtc_register_device(rtc);
 335 }
 336
 337 static const struct platform_device_id bd718x7_rtc_id[] = {
 338         { "bd71828-rtc", ROHM_CHIP_TYPE_BD71828 },
 339         { "bd71815-rtc", ROHM_CHIP_TYPE_BD71815 },
 340         { },
 341 };
 342 MODULE_DEVICE_TABLE(platform, bd718x7_rtc_id);
 343
 344 static struct platform_driver bd70528_rtc = {
 345         .driver = {
 346                 .name = "bd70528-rtc"
 347         },
 348         .probe = bd70528_probe,
 349         .id_table = bd718x7_rtc_id,
 350 };
 351
 352 module_platform_driver(bd70528_rtc);
 353
 354 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
 355 MODULE_DESCRIPTION("ROHM BD71828 and BD71815 PMIC RTC driver");
 356 MODULE_LICENSE("GPL");
 357 MODULE_ALIAS("platform:bd70528-rtc");