534 lines · c
1// SPDX-License-Identifier: GPL-2.0+2//3// RTC driver for Maxim MAX89974//5// Copyright (C) 2013 Samsung Electronics Co.Ltd6//7// based on rtc-max8998.c8 9#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt10 11#include <linux/slab.h>12#include <linux/rtc.h>13#include <linux/delay.h>14#include <linux/mutex.h>15#include <linux/module.h>16#include <linux/platform_device.h>17#include <linux/mfd/max8997-private.h>18#include <linux/irqdomain.h>19 20/* Module parameter for WTSR function control */21static int wtsr_en = 1;22module_param(wtsr_en, int, 0444);23MODULE_PARM_DESC(wtsr_en, "Watchdog Timeout & Software Reset (default=on)");24/* Module parameter for SMPL function control */25static int smpl_en = 1;26module_param(smpl_en, int, 0444);27MODULE_PARM_DESC(smpl_en, "Sudden Momentary Power Loss (default=on)");28 29/* RTC Control Register */30#define BCD_EN_SHIFT 031#define BCD_EN_MASK (1 << BCD_EN_SHIFT)32#define MODEL24_SHIFT 133#define MODEL24_MASK (1 << MODEL24_SHIFT)34/* RTC Update Register1 */35#define RTC_UDR_SHIFT 036#define RTC_UDR_MASK (1 << RTC_UDR_SHIFT)37/* WTSR and SMPL Register */38#define WTSRT_SHIFT 039#define SMPLT_SHIFT 240#define WTSR_EN_SHIFT 641#define SMPL_EN_SHIFT 742#define WTSRT_MASK (3 << WTSRT_SHIFT)43#define SMPLT_MASK (3 << SMPLT_SHIFT)44#define WTSR_EN_MASK (1 << WTSR_EN_SHIFT)45#define SMPL_EN_MASK (1 << SMPL_EN_SHIFT)46/* RTC Hour register */47#define HOUR_PM_SHIFT 648#define HOUR_PM_MASK (1 << HOUR_PM_SHIFT)49/* RTC Alarm Enable */50#define ALARM_ENABLE_SHIFT 751#define ALARM_ENABLE_MASK (1 << ALARM_ENABLE_SHIFT)52 53enum {54 RTC_SEC = 0,55 RTC_MIN,56 RTC_HOUR,57 RTC_WEEKDAY,58 RTC_MONTH,59 RTC_YEAR,60 RTC_DATE,61 RTC_NR_TIME62};63 64struct max8997_rtc_info {65 struct device *dev;66 struct max8997_dev *max8997;67 struct i2c_client *rtc;68 struct rtc_device *rtc_dev;69 struct mutex lock;70 int virq;71 int rtc_24hr_mode;72};73 74static void max8997_rtc_data_to_tm(u8 *data, struct rtc_time *tm,75 int rtc_24hr_mode)76{77 tm->tm_sec = data[RTC_SEC] & 0x7f;78 tm->tm_min = data[RTC_MIN] & 0x7f;79 if (rtc_24hr_mode)80 tm->tm_hour = data[RTC_HOUR] & 0x1f;81 else {82 tm->tm_hour = data[RTC_HOUR] & 0x0f;83 if (data[RTC_HOUR] & HOUR_PM_MASK)84 tm->tm_hour += 12;85 }86 87 tm->tm_wday = fls(data[RTC_WEEKDAY] & 0x7f) - 1;88 tm->tm_mday = data[RTC_DATE] & 0x1f;89 tm->tm_mon = (data[RTC_MONTH] & 0x0f) - 1;90 tm->tm_year = (data[RTC_YEAR] & 0x7f) + 100;91 tm->tm_yday = 0;92 tm->tm_isdst = 0;93}94 95static int max8997_rtc_tm_to_data(struct rtc_time *tm, u8 *data)96{97 data[RTC_SEC] = tm->tm_sec;98 data[RTC_MIN] = tm->tm_min;99 data[RTC_HOUR] = tm->tm_hour;100 data[RTC_WEEKDAY] = 1 << tm->tm_wday;101 data[RTC_DATE] = tm->tm_mday;102 data[RTC_MONTH] = tm->tm_mon + 1;103 data[RTC_YEAR] = tm->tm_year > 100 ? (tm->tm_year - 100) : 0;104 105 if (tm->tm_year < 100) {106 pr_warn("RTC cannot handle the year %d. Assume it's 2000.\n",107 1900 + tm->tm_year);108 return -EINVAL;109 }110 return 0;111}112 113static inline int max8997_rtc_set_update_reg(struct max8997_rtc_info *info)114{115 int ret;116 117 ret = max8997_write_reg(info->rtc, MAX8997_RTC_UPDATE1,118 RTC_UDR_MASK);119 if (ret < 0)120 dev_err(info->dev, "%s: fail to write update reg(%d)\n",121 __func__, ret);122 else {123 /* Minimum 16ms delay required before RTC update.124 * Otherwise, we may read and update based on out-of-date125 * value */126 msleep(20);127 }128 129 return ret;130}131 132static int max8997_rtc_read_time(struct device *dev, struct rtc_time *tm)133{134 struct max8997_rtc_info *info = dev_get_drvdata(dev);135 u8 data[RTC_NR_TIME];136 int ret;137 138 mutex_lock(&info->lock);139 ret = max8997_bulk_read(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data);140 mutex_unlock(&info->lock);141 142 if (ret < 0) {143 dev_err(info->dev, "%s: fail to read time reg(%d)\n", __func__,144 ret);145 return ret;146 }147 148 max8997_rtc_data_to_tm(data, tm, info->rtc_24hr_mode);149 150 return 0;151}152 153static int max8997_rtc_set_time(struct device *dev, struct rtc_time *tm)154{155 struct max8997_rtc_info *info = dev_get_drvdata(dev);156 u8 data[RTC_NR_TIME];157 int ret;158 159 ret = max8997_rtc_tm_to_data(tm, data);160 if (ret < 0)161 return ret;162 163 mutex_lock(&info->lock);164 165 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_SEC, RTC_NR_TIME, data);166 if (ret < 0) {167 dev_err(info->dev, "%s: fail to write time reg(%d)\n", __func__,168 ret);169 goto out;170 }171 172 ret = max8997_rtc_set_update_reg(info);173out:174 mutex_unlock(&info->lock);175 return ret;176}177 178static int max8997_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)179{180 struct max8997_rtc_info *info = dev_get_drvdata(dev);181 u8 data[RTC_NR_TIME];182 u8 val;183 int i, ret;184 185 mutex_lock(&info->lock);186 187 ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,188 data);189 if (ret < 0) {190 dev_err(info->dev, "%s:%d fail to read alarm reg(%d)\n",191 __func__, __LINE__, ret);192 goto out;193 }194 195 max8997_rtc_data_to_tm(data, &alrm->time, info->rtc_24hr_mode);196 197 alrm->enabled = 0;198 for (i = 0; i < RTC_NR_TIME; i++) {199 if (data[i] & ALARM_ENABLE_MASK) {200 alrm->enabled = 1;201 break;202 }203 }204 205 alrm->pending = 0;206 ret = max8997_read_reg(info->max8997->i2c, MAX8997_REG_STATUS1, &val);207 if (ret < 0) {208 dev_err(info->dev, "%s:%d fail to read status1 reg(%d)\n",209 __func__, __LINE__, ret);210 goto out;211 }212 213 if (val & (1 << 4)) /* RTCA1 */214 alrm->pending = 1;215 216out:217 mutex_unlock(&info->lock);218 return ret;219}220 221static int max8997_rtc_stop_alarm(struct max8997_rtc_info *info)222{223 u8 data[RTC_NR_TIME];224 int ret, i;225 226 if (!mutex_is_locked(&info->lock))227 dev_warn(info->dev, "%s: should have mutex locked\n", __func__);228 229 ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,230 data);231 if (ret < 0) {232 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",233 __func__, ret);234 goto out;235 }236 237 for (i = 0; i < RTC_NR_TIME; i++)238 data[i] &= ~ALARM_ENABLE_MASK;239 240 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,241 data);242 if (ret < 0) {243 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",244 __func__, ret);245 goto out;246 }247 248 ret = max8997_rtc_set_update_reg(info);249out:250 return ret;251}252 253static int max8997_rtc_start_alarm(struct max8997_rtc_info *info)254{255 u8 data[RTC_NR_TIME];256 int ret;257 258 if (!mutex_is_locked(&info->lock))259 dev_warn(info->dev, "%s: should have mutex locked\n", __func__);260 261 ret = max8997_bulk_read(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,262 data);263 if (ret < 0) {264 dev_err(info->dev, "%s: fail to read alarm reg(%d)\n",265 __func__, ret);266 goto out;267 }268 269 data[RTC_SEC] |= (1 << ALARM_ENABLE_SHIFT);270 data[RTC_MIN] |= (1 << ALARM_ENABLE_SHIFT);271 data[RTC_HOUR] |= (1 << ALARM_ENABLE_SHIFT);272 data[RTC_WEEKDAY] &= ~ALARM_ENABLE_MASK;273 if (data[RTC_MONTH] & 0xf)274 data[RTC_MONTH] |= (1 << ALARM_ENABLE_SHIFT);275 if (data[RTC_YEAR] & 0x7f)276 data[RTC_YEAR] |= (1 << ALARM_ENABLE_SHIFT);277 if (data[RTC_DATE] & 0x1f)278 data[RTC_DATE] |= (1 << ALARM_ENABLE_SHIFT);279 280 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,281 data);282 if (ret < 0) {283 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",284 __func__, ret);285 goto out;286 }287 288 ret = max8997_rtc_set_update_reg(info);289out:290 return ret;291}292static int max8997_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)293{294 struct max8997_rtc_info *info = dev_get_drvdata(dev);295 u8 data[RTC_NR_TIME];296 int ret;297 298 ret = max8997_rtc_tm_to_data(&alrm->time, data);299 if (ret < 0)300 return ret;301 302 dev_info(info->dev, "%s: %d-%02d-%02d %02d:%02d:%02d\n", __func__,303 data[RTC_YEAR] + 2000, data[RTC_MONTH], data[RTC_DATE],304 data[RTC_HOUR], data[RTC_MIN], data[RTC_SEC]);305 306 mutex_lock(&info->lock);307 308 ret = max8997_rtc_stop_alarm(info);309 if (ret < 0)310 goto out;311 312 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_ALARM1_SEC, RTC_NR_TIME,313 data);314 if (ret < 0) {315 dev_err(info->dev, "%s: fail to write alarm reg(%d)\n",316 __func__, ret);317 goto out;318 }319 320 ret = max8997_rtc_set_update_reg(info);321 if (ret < 0)322 goto out;323 324 if (alrm->enabled)325 ret = max8997_rtc_start_alarm(info);326out:327 mutex_unlock(&info->lock);328 return ret;329}330 331static int max8997_rtc_alarm_irq_enable(struct device *dev,332 unsigned int enabled)333{334 struct max8997_rtc_info *info = dev_get_drvdata(dev);335 int ret;336 337 mutex_lock(&info->lock);338 if (enabled)339 ret = max8997_rtc_start_alarm(info);340 else341 ret = max8997_rtc_stop_alarm(info);342 mutex_unlock(&info->lock);343 344 return ret;345}346 347static irqreturn_t max8997_rtc_alarm_irq(int irq, void *data)348{349 struct max8997_rtc_info *info = data;350 351 dev_info(info->dev, "%s:irq(%d)\n", __func__, irq);352 353 rtc_update_irq(info->rtc_dev, 1, RTC_IRQF | RTC_AF);354 355 return IRQ_HANDLED;356}357 358static const struct rtc_class_ops max8997_rtc_ops = {359 .read_time = max8997_rtc_read_time,360 .set_time = max8997_rtc_set_time,361 .read_alarm = max8997_rtc_read_alarm,362 .set_alarm = max8997_rtc_set_alarm,363 .alarm_irq_enable = max8997_rtc_alarm_irq_enable,364};365 366static void max8997_rtc_enable_wtsr(struct max8997_rtc_info *info, bool enable)367{368 int ret;369 u8 val, mask;370 371 if (!wtsr_en)372 return;373 374 if (enable)375 val = (1 << WTSR_EN_SHIFT) | (3 << WTSRT_SHIFT);376 else377 val = 0;378 379 mask = WTSR_EN_MASK | WTSRT_MASK;380 381 dev_info(info->dev, "%s: %s WTSR\n", __func__,382 enable ? "enable" : "disable");383 384 ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask);385 if (ret < 0) {386 dev_err(info->dev, "%s: fail to update WTSR reg(%d)\n",387 __func__, ret);388 return;389 }390 391 max8997_rtc_set_update_reg(info);392}393 394static void max8997_rtc_enable_smpl(struct max8997_rtc_info *info, bool enable)395{396 int ret;397 u8 val, mask;398 399 if (!smpl_en)400 return;401 402 if (enable)403 val = (1 << SMPL_EN_SHIFT) | (0 << SMPLT_SHIFT);404 else405 val = 0;406 407 mask = SMPL_EN_MASK | SMPLT_MASK;408 409 dev_info(info->dev, "%s: %s SMPL\n", __func__,410 enable ? "enable" : "disable");411 412 ret = max8997_update_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, val, mask);413 if (ret < 0) {414 dev_err(info->dev, "%s: fail to update SMPL reg(%d)\n",415 __func__, ret);416 return;417 }418 419 max8997_rtc_set_update_reg(info);420 421 val = 0;422 max8997_read_reg(info->rtc, MAX8997_RTC_WTSR_SMPL, &val);423 pr_info("WTSR_SMPL(0x%02x)\n", val);424}425 426static int max8997_rtc_init_reg(struct max8997_rtc_info *info)427{428 u8 data[2];429 int ret;430 431 /* Set RTC control register : Binary mode, 24hour mdoe */432 data[0] = (1 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);433 data[1] = (0 << BCD_EN_SHIFT) | (1 << MODEL24_SHIFT);434 435 info->rtc_24hr_mode = 1;436 437 ret = max8997_bulk_write(info->rtc, MAX8997_RTC_CTRLMASK, 2, data);438 if (ret < 0) {439 dev_err(info->dev, "%s: fail to write controlm reg(%d)\n",440 __func__, ret);441 return ret;442 }443 444 ret = max8997_rtc_set_update_reg(info);445 return ret;446}447 448static int max8997_rtc_probe(struct platform_device *pdev)449{450 struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent);451 struct max8997_rtc_info *info;452 int ret, virq;453 454 info = devm_kzalloc(&pdev->dev, sizeof(struct max8997_rtc_info),455 GFP_KERNEL);456 if (!info)457 return -ENOMEM;458 459 mutex_init(&info->lock);460 info->dev = &pdev->dev;461 info->max8997 = max8997;462 info->rtc = max8997->rtc;463 464 platform_set_drvdata(pdev, info);465 466 ret = max8997_rtc_init_reg(info);467 468 if (ret < 0) {469 dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret);470 return ret;471 }472 473 max8997_rtc_enable_wtsr(info, true);474 max8997_rtc_enable_smpl(info, true);475 476 device_init_wakeup(&pdev->dev, 1);477 478 info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8997-rtc",479 &max8997_rtc_ops, THIS_MODULE);480 481 if (IS_ERR(info->rtc_dev)) {482 ret = PTR_ERR(info->rtc_dev);483 dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret);484 return ret;485 }486 487 virq = irq_create_mapping(max8997->irq_domain, MAX8997_PMICIRQ_RTCA1);488 if (!virq) {489 dev_err(&pdev->dev, "Failed to create mapping alarm IRQ\n");490 ret = -ENXIO;491 goto err_out;492 }493 info->virq = virq;494 495 ret = devm_request_threaded_irq(&pdev->dev, virq, NULL,496 max8997_rtc_alarm_irq, 0,497 "rtc-alarm0", info);498 if (ret < 0)499 dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n",500 info->virq, ret);501 502err_out:503 return ret;504}505 506static void max8997_rtc_shutdown(struct platform_device *pdev)507{508 struct max8997_rtc_info *info = platform_get_drvdata(pdev);509 510 max8997_rtc_enable_wtsr(info, false);511 max8997_rtc_enable_smpl(info, false);512}513 514static const struct platform_device_id rtc_id[] = {515 { "max8997-rtc", 0 },516 {},517};518MODULE_DEVICE_TABLE(platform, rtc_id);519 520static struct platform_driver max8997_rtc_driver = {521 .driver = {522 .name = "max8997-rtc",523 },524 .probe = max8997_rtc_probe,525 .shutdown = max8997_rtc_shutdown,526 .id_table = rtc_id,527};528 529module_platform_driver(max8997_rtc_driver);530 531MODULE_DESCRIPTION("Maxim MAX8997 RTC driver");532MODULE_AUTHOR("<ms925.kim@samsung.com>");533MODULE_LICENSE("GPL");534