Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373// SPDX-License-Identifier: GPL-2.0-or-later//// Copyright (C) 2018 ROHM Semiconductors//// RTC driver for ROHM BD71828 and BD71815 PMIC
#include <linux/bcd.h>#include <linux/mfd/rohm-bd71815.h>#include <linux/mfd/rohm-bd71828.h>#include <linux/mfd/rohm-bd72720.h>#include <linux/mfd/rohm-bd73800.h>#include <linux/module.h>#include <linux/of.h>#include <linux/platform_device.h>#include <linux/regmap.h>#include <linux/rtc.h>
/* * On BD71828 and BD71815 the ALM0 MASK is 14 bytes after the ALM0 * block start */#define BD718XX_ALM_EN_OFFSET 14
/* * We read regs RTC_SEC => RTC_YEAR * this struct is ordered according to chip registers. * Keep it u8 only (or packed) to avoid padding issues. */struct bd70528_rtc_day { u8 sec; u8 min; u8 hour;} __packed;
struct bd70528_rtc_data { struct bd70528_rtc_day time; u8 week; u8 day; u8 month; u8 year;} __packed;
struct bd71828_rtc_alm { struct bd70528_rtc_data alm0; struct bd70528_rtc_data alm1; u8 alm_mask; u8 alm1_mask;} __packed;
struct bd70528_rtc { struct rohm_regmap_dev *parent; struct regmap *regmap; struct device *dev; u8 reg_time_start; u8 bd718xx_alm_block_start;};
static inline void tmday2rtc(struct rtc_time *t, struct bd70528_rtc_day *d){ d->sec &= ~BD70528_MASK_RTC_SEC; d->min &= ~BD70528_MASK_RTC_MINUTE; d->hour &= ~BD70528_MASK_RTC_HOUR; d->sec |= bin2bcd(t->tm_sec); d->min |= bin2bcd(t->tm_min); d->hour |= bin2bcd(t->tm_hour);}
static inline void tm2rtc(struct rtc_time *t, struct bd70528_rtc_data *r){ r->day &= ~BD70528_MASK_RTC_DAY; r->week &= ~BD70528_MASK_RTC_WEEK; r->month &= ~BD70528_MASK_RTC_MONTH; /* * PM and 24H bits are not used by Wake - thus we clear them * here and not in tmday2rtc() which is also used by wake. */ r->time.hour &= ~(BD70528_MASK_RTC_HOUR_PM | BD70528_MASK_RTC_HOUR_24H);
tmday2rtc(t, &r->time); /* * We do always set time in 24H mode. */ r->time.hour |= BD70528_MASK_RTC_HOUR_24H; r->day |= bin2bcd(t->tm_mday); r->week |= bin2bcd(t->tm_wday); r->month |= bin2bcd(t->tm_mon + 1); r->year = bin2bcd(t->tm_year - 100);}
static inline void rtc2tm(struct bd70528_rtc_data *r, struct rtc_time *t){ t->tm_sec = bcd2bin(r->time.sec & BD70528_MASK_RTC_SEC); t->tm_min = bcd2bin(r->time.min & BD70528_MASK_RTC_MINUTE); t->tm_hour = bcd2bin(r->time.hour & BD70528_MASK_RTC_HOUR); /* * If RTC is in 12H mode, then bit BD70528_MASK_RTC_HOUR_PM * is not BCD value but tells whether it is AM or PM */ if (!(r->time.hour & BD70528_MASK_RTC_HOUR_24H)) { t->tm_hour %= 12; if (r->time.hour & BD70528_MASK_RTC_HOUR_PM) t->tm_hour += 12; } t->tm_mday = bcd2bin(r->day & BD70528_MASK_RTC_DAY); t->tm_mon = bcd2bin(r->month & BD70528_MASK_RTC_MONTH) - 1; t->tm_year = 100 + bcd2bin(r->year & BD70528_MASK_RTC_YEAR); t->tm_wday = bcd2bin(r->week & BD70528_MASK_RTC_WEEK);}
static int bd71828_set_alarm(struct device *dev, struct rtc_wkalrm *a){ int ret; struct bd71828_rtc_alm alm; struct bd70528_rtc *r = dev_get_drvdata(dev);
ret = regmap_bulk_read(r->regmap, r->bd718xx_alm_block_start, &alm, sizeof(alm)); if (ret) { dev_err(dev, "Failed to read alarm regs\n"); return ret; }
tm2rtc(&a->time, &alm.alm0);
if (!a->enabled) alm.alm_mask &= ~BD70528_MASK_ALM_EN; else alm.alm_mask |= BD70528_MASK_ALM_EN;
ret = regmap_bulk_write(r->regmap, r->bd718xx_alm_block_start, &alm, sizeof(alm)); if (ret) dev_err(dev, "Failed to set alarm time\n");
return ret;
}
static int bd71828_read_alarm(struct device *dev, struct rtc_wkalrm *a){ int ret; struct bd71828_rtc_alm alm; struct bd70528_rtc *r = dev_get_drvdata(dev);
ret = regmap_bulk_read(r->regmap, r->bd718xx_alm_block_start, &alm, sizeof(alm)); if (ret) { dev_err(dev, "Failed to read alarm regs\n"); return ret; }
rtc2tm(&alm.alm0, &a->time); a->time.tm_mday = -1; a->time.tm_mon = -1; a->time.tm_year = -1; a->enabled = !!(alm.alm_mask & BD70528_MASK_ALM_EN); a->pending = 0;
return 0;}
static int bd71828_set_time(struct device *dev, struct rtc_time *t){ int ret; struct bd70528_rtc_data rtc_data; struct bd70528_rtc *r = dev_get_drvdata(dev);
ret = regmap_bulk_read(r->regmap, r->reg_time_start, &rtc_data, sizeof(rtc_data)); if (ret) { dev_err(dev, "Failed to read RTC time registers\n"); return ret; } tm2rtc(t, &rtc_data);
ret = regmap_bulk_write(r->regmap, r->reg_time_start, &rtc_data, sizeof(rtc_data)); if (ret) dev_err(dev, "Failed to set RTC time\n");
return ret;}
static int bd70528_get_time(struct device *dev, struct rtc_time *t){ struct bd70528_rtc *r = dev_get_drvdata(dev); struct bd70528_rtc_data rtc_data; int ret;
/* read the RTC date and time registers all at once */ ret = regmap_bulk_read(r->regmap, r->reg_time_start, &rtc_data, sizeof(rtc_data)); if (ret) { dev_err(dev, "Failed to read RTC time (err %d)\n", ret); return ret; }
rtc2tm(&rtc_data, t);
return 0;}
static int bd71828_alm_enable(struct device *dev, unsigned int enabled){ int ret; struct bd70528_rtc *r = dev_get_drvdata(dev); unsigned int enableval = BD70528_MASK_ALM_EN;
if (!enabled) enableval = 0;
ret = regmap_update_bits(r->regmap, r->bd718xx_alm_block_start + BD718XX_ALM_EN_OFFSET, BD70528_MASK_ALM_EN, enableval); if (ret) dev_err(dev, "Failed to change alarm state\n");
return ret;}
static const struct rtc_class_ops bd71828_rtc_ops = { .read_time = bd70528_get_time, .set_time = bd71828_set_time, .read_alarm = bd71828_read_alarm, .set_alarm = bd71828_set_alarm, .alarm_irq_enable = bd71828_alm_enable,};
static irqreturn_t alm_hndlr(int irq, void *data){ struct rtc_device *rtc = data;
rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF | RTC_PF); return IRQ_HANDLED;}
static int bd70528_probe(struct platform_device *pdev){ struct bd70528_rtc *bd_rtc; const struct rtc_class_ops *rtc_ops; int ret; struct rtc_device *rtc; int irq; unsigned int hr; u8 hour_reg; enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
bd_rtc = devm_kzalloc(&pdev->dev, sizeof(*bd_rtc), GFP_KERNEL); if (!bd_rtc) return -ENOMEM;
bd_rtc->regmap = dev_get_regmap(pdev->dev.parent, NULL); if (!bd_rtc->regmap) { dev_err(&pdev->dev, "No regmap\n"); return -EINVAL; }
bd_rtc->dev = &pdev->dev; rtc_ops = &bd71828_rtc_ops;
switch (chip) { case ROHM_CHIP_TYPE_BD71815: bd_rtc->reg_time_start = BD71815_REG_RTC_START;
/* * See also BD718XX_ALM_EN_OFFSET: * This works for BD71828, BD71815, and BD72720 as they all * have same offset between the ALM0 start and the ALM0_MASK. * If new ICs are to be added this requires proper check as * the ALM0_MASK is not located at the end of ALM0 block - * but after all ALM blocks. If amount of ALMs differ, the * offset to enable/disable is likely to be incorrect and * enable/disable must be given as own reg address here. */ bd_rtc->bd718xx_alm_block_start = BD71815_REG_RTC_ALM_START; hour_reg = BD71815_REG_HOUR; break; case ROHM_CHIP_TYPE_BD71828: bd_rtc->reg_time_start = BD71828_REG_RTC_START; bd_rtc->bd718xx_alm_block_start = BD71828_REG_RTC_ALM_START; hour_reg = BD71828_REG_RTC_HOUR; break; case ROHM_CHIP_TYPE_BD72720: bd_rtc->reg_time_start = BD72720_REG_RTC_START; bd_rtc->bd718xx_alm_block_start = BD72720_REG_RTC_ALM_START; hour_reg = BD72720_REG_RTC_HOUR; break; case ROHM_CHIP_TYPE_BD73800: bd_rtc->reg_time_start = BD73800_REG_RTC_START; bd_rtc->bd718xx_alm_block_start = BD73800_REG_RTC_ALM_START; hour_reg = BD73800_REG_RTC_HOUR; break;
default: dev_err(&pdev->dev, "Unknown chip\n"); return -ENOENT; }
irq = platform_get_irq_byname(pdev, "bd70528-rtc-alm-0");
if (irq < 0) return irq;
platform_set_drvdata(pdev, bd_rtc);
ret = regmap_read(bd_rtc->regmap, hour_reg, &hr);
if (ret) { dev_err(&pdev->dev, "Failed to reag RTC clock\n"); return ret; }
if (!(hr & BD70528_MASK_RTC_HOUR_24H)) { struct rtc_time t;
ret = rtc_ops->read_time(&pdev->dev, &t);
if (!ret) ret = rtc_ops->set_time(&pdev->dev, &t);
if (ret) { dev_err(&pdev->dev, "Setting 24H clock for RTC failed\n"); return ret; } }
device_set_wakeup_capable(&pdev->dev, true); device_wakeup_enable(&pdev->dev);
rtc = devm_rtc_allocate_device(&pdev->dev); if (IS_ERR(rtc)) { dev_err(&pdev->dev, "RTC device creation failed\n"); return PTR_ERR(rtc); }
rtc->range_min = RTC_TIMESTAMP_BEGIN_2000; rtc->range_max = RTC_TIMESTAMP_END_2099; rtc->ops = rtc_ops;
/* Request alarm IRQ prior to registerig the RTC */ ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, &alm_hndlr, IRQF_ONESHOT, "bd70528-rtc", rtc); if (ret) return ret;
return devm_rtc_register_device(rtc);}
static const struct platform_device_id bd718x7_rtc_id[] = { { .name = "bd71828-rtc", .driver_data = ROHM_CHIP_TYPE_BD71828 }, { .name = "bd71815-rtc", .driver_data = ROHM_CHIP_TYPE_BD71815 }, { .name = "bd72720-rtc", .driver_data = ROHM_CHIP_TYPE_BD72720 }, { .name = "bd73800-rtc", .driver_data = ROHM_CHIP_TYPE_BD73800 }, { }};MODULE_DEVICE_TABLE(platform, bd718x7_rtc_id);
static struct platform_driver bd70528_rtc = { .driver = { .name = "bd70528-rtc" }, .probe = bd70528_probe, .id_table = bd718x7_rtc_id,};
module_platform_driver(bd70528_rtc);
MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");MODULE_DESCRIPTION("ROHM BD71828 and BD71815 PMIC RTC driver");MODULE_LICENSE("GPL");MODULE_ALIAS("platform:bd70528-rtc");