projects/linux·blob master · refs

364 lines · 9.0 KiB

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