xref: /openbmc/linux/drivers/rtc/rtc-ab8500.c (revision 7effbd18)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) ST-Ericsson SA 2010
4  *
5  * Author: Virupax Sadashivpetimath <virupax.sadashivpetimath@stericsson.com>
6  *
7  * RTC clock driver for the RTC part of the AB8500 Power management chip.
8  * Based on RTC clock driver for the AB3100 Analog Baseband Chip by
9  * Linus Walleij <linus.walleij@stericsson.com>
10  */
11 
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/init.h>
15 #include <linux/platform_device.h>
16 #include <linux/rtc.h>
17 #include <linux/mfd/abx500.h>
18 #include <linux/mfd/abx500/ab8500.h>
19 #include <linux/delay.h>
20 #include <linux/of.h>
21 #include <linux/pm_wakeirq.h>
22 
23 #define AB8500_RTC_SOFF_STAT_REG	0x00
24 #define AB8500_RTC_CC_CONF_REG		0x01
25 #define AB8500_RTC_READ_REQ_REG		0x02
26 #define AB8500_RTC_WATCH_TSECMID_REG	0x03
27 #define AB8500_RTC_WATCH_TSECHI_REG	0x04
28 #define AB8500_RTC_WATCH_TMIN_LOW_REG	0x05
29 #define AB8500_RTC_WATCH_TMIN_MID_REG	0x06
30 #define AB8500_RTC_WATCH_TMIN_HI_REG	0x07
31 #define AB8500_RTC_ALRM_MIN_LOW_REG	0x08
32 #define AB8500_RTC_ALRM_MIN_MID_REG	0x09
33 #define AB8500_RTC_ALRM_MIN_HI_REG	0x0A
34 #define AB8500_RTC_STAT_REG		0x0B
35 #define AB8500_RTC_BKUP_CHG_REG		0x0C
36 #define AB8500_RTC_FORCE_BKUP_REG	0x0D
37 #define AB8500_RTC_CALIB_REG		0x0E
38 #define AB8500_RTC_SWITCH_STAT_REG	0x0F
39 
40 /* RtcReadRequest bits */
41 #define RTC_READ_REQUEST		0x01
42 #define RTC_WRITE_REQUEST		0x02
43 
44 /* RtcCtrl bits */
45 #define RTC_ALARM_ENA			0x04
46 #define RTC_STATUS_DATA			0x01
47 
48 #define COUNTS_PER_SEC			(0xF000 / 60)
49 
50 static const u8 ab8500_rtc_time_regs[] = {
51 	AB8500_RTC_WATCH_TMIN_HI_REG, AB8500_RTC_WATCH_TMIN_MID_REG,
52 	AB8500_RTC_WATCH_TMIN_LOW_REG, AB8500_RTC_WATCH_TSECHI_REG,
53 	AB8500_RTC_WATCH_TSECMID_REG
54 };
55 
56 static const u8 ab8500_rtc_alarm_regs[] = {
57 	AB8500_RTC_ALRM_MIN_HI_REG, AB8500_RTC_ALRM_MIN_MID_REG,
58 	AB8500_RTC_ALRM_MIN_LOW_REG
59 };
60 
61 static int ab8500_rtc_read_time(struct device *dev, struct rtc_time *tm)
62 {
63 	unsigned long timeout = jiffies + HZ;
64 	int retval, i;
65 	unsigned long mins, secs;
66 	unsigned char buf[ARRAY_SIZE(ab8500_rtc_time_regs)];
67 	u8 value;
68 
69 	/* Request a data read */
70 	retval = abx500_set_register_interruptible(dev,
71 		AB8500_RTC, AB8500_RTC_READ_REQ_REG, RTC_READ_REQUEST);
72 	if (retval < 0)
73 		return retval;
74 
75 	/* Wait for some cycles after enabling the rtc read in ab8500 */
76 	while (time_before(jiffies, timeout)) {
77 		retval = abx500_get_register_interruptible(dev,
78 			AB8500_RTC, AB8500_RTC_READ_REQ_REG, &value);
79 		if (retval < 0)
80 			return retval;
81 
82 		if (!(value & RTC_READ_REQUEST))
83 			break;
84 
85 		usleep_range(1000, 5000);
86 	}
87 
88 	/* Read the Watchtime registers */
89 	for (i = 0; i < ARRAY_SIZE(ab8500_rtc_time_regs); i++) {
90 		retval = abx500_get_register_interruptible(dev,
91 			AB8500_RTC, ab8500_rtc_time_regs[i], &value);
92 		if (retval < 0)
93 			return retval;
94 		buf[i] = value;
95 	}
96 
97 	mins = (buf[0] << 16) | (buf[1] << 8) | buf[2];
98 
99 	secs =	(buf[3] << 8) | buf[4];
100 	secs =	secs / COUNTS_PER_SEC;
101 	secs =	secs + (mins * 60);
102 
103 	rtc_time64_to_tm(secs, tm);
104 	return 0;
105 }
106 
107 static int ab8500_rtc_set_time(struct device *dev, struct rtc_time *tm)
108 {
109 	int retval, i;
110 	unsigned char buf[ARRAY_SIZE(ab8500_rtc_time_regs)];
111 	unsigned long no_secs, no_mins, secs = 0;
112 
113 	secs = rtc_tm_to_time64(tm);
114 
115 	no_mins = secs / 60;
116 
117 	no_secs = secs % 60;
118 	/* Make the seconds count as per the RTC resolution */
119 	no_secs = no_secs * COUNTS_PER_SEC;
120 
121 	buf[4] = no_secs & 0xFF;
122 	buf[3] = (no_secs >> 8) & 0xFF;
123 
124 	buf[2] = no_mins & 0xFF;
125 	buf[1] = (no_mins >> 8) & 0xFF;
126 	buf[0] = (no_mins >> 16) & 0xFF;
127 
128 	for (i = 0; i < ARRAY_SIZE(ab8500_rtc_time_regs); i++) {
129 		retval = abx500_set_register_interruptible(dev, AB8500_RTC,
130 			ab8500_rtc_time_regs[i], buf[i]);
131 		if (retval < 0)
132 			return retval;
133 	}
134 
135 	/* Request a data write */
136 	return abx500_set_register_interruptible(dev, AB8500_RTC,
137 		AB8500_RTC_READ_REQ_REG, RTC_WRITE_REQUEST);
138 }
139 
140 static int ab8500_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
141 {
142 	int retval, i;
143 	u8 rtc_ctrl, value;
144 	unsigned char buf[ARRAY_SIZE(ab8500_rtc_alarm_regs)];
145 	unsigned long secs, mins;
146 
147 	/* Check if the alarm is enabled or not */
148 	retval = abx500_get_register_interruptible(dev, AB8500_RTC,
149 		AB8500_RTC_STAT_REG, &rtc_ctrl);
150 	if (retval < 0)
151 		return retval;
152 
153 	if (rtc_ctrl & RTC_ALARM_ENA)
154 		alarm->enabled = 1;
155 	else
156 		alarm->enabled = 0;
157 
158 	alarm->pending = 0;
159 
160 	for (i = 0; i < ARRAY_SIZE(ab8500_rtc_alarm_regs); i++) {
161 		retval = abx500_get_register_interruptible(dev, AB8500_RTC,
162 			ab8500_rtc_alarm_regs[i], &value);
163 		if (retval < 0)
164 			return retval;
165 		buf[i] = value;
166 	}
167 
168 	mins = (buf[0] << 16) | (buf[1] << 8) | (buf[2]);
169 	secs = mins * 60;
170 
171 	rtc_time64_to_tm(secs, &alarm->time);
172 
173 	return 0;
174 }
175 
176 static int ab8500_rtc_irq_enable(struct device *dev, unsigned int enabled)
177 {
178 	return abx500_mask_and_set_register_interruptible(dev, AB8500_RTC,
179 		AB8500_RTC_STAT_REG, RTC_ALARM_ENA,
180 		enabled ? RTC_ALARM_ENA : 0);
181 }
182 
183 static int ab8500_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
184 {
185 	int retval, i;
186 	unsigned char buf[ARRAY_SIZE(ab8500_rtc_alarm_regs)];
187 	unsigned long mins;
188 
189 	mins = (unsigned long)rtc_tm_to_time64(&alarm->time) / 60;
190 
191 	buf[2] = mins & 0xFF;
192 	buf[1] = (mins >> 8) & 0xFF;
193 	buf[0] = (mins >> 16) & 0xFF;
194 
195 	/* Set the alarm time */
196 	for (i = 0; i < ARRAY_SIZE(ab8500_rtc_alarm_regs); i++) {
197 		retval = abx500_set_register_interruptible(dev, AB8500_RTC,
198 			ab8500_rtc_alarm_regs[i], buf[i]);
199 		if (retval < 0)
200 			return retval;
201 	}
202 
203 	return ab8500_rtc_irq_enable(dev, alarm->enabled);
204 }
205 
206 static int ab8500_rtc_set_calibration(struct device *dev, int calibration)
207 {
208 	int retval;
209 	u8  rtccal = 0;
210 
211 	/*
212 	 * Check that the calibration value (which is in units of 0.5
213 	 * parts-per-million) is in the AB8500's range for RtcCalibration
214 	 * register. -128 (0x80) is not permitted because the AB8500 uses
215 	 * a sign-bit rather than two's complement, so 0x80 is just another
216 	 * representation of zero.
217 	 */
218 	if ((calibration < -127) || (calibration > 127)) {
219 		dev_err(dev, "RtcCalibration value outside permitted range\n");
220 		return -EINVAL;
221 	}
222 
223 	/*
224 	 * The AB8500 uses sign (in bit7) and magnitude (in bits0-7)
225 	 * so need to convert to this sort of representation before writing
226 	 * into RtcCalibration register...
227 	 */
228 	if (calibration >= 0)
229 		rtccal = 0x7F & calibration;
230 	else
231 		rtccal = ~(calibration - 1) | 0x80;
232 
233 	retval = abx500_set_register_interruptible(dev, AB8500_RTC,
234 			AB8500_RTC_CALIB_REG, rtccal);
235 
236 	return retval;
237 }
238 
239 static int ab8500_rtc_get_calibration(struct device *dev, int *calibration)
240 {
241 	int retval;
242 	u8  rtccal = 0;
243 
244 	retval =  abx500_get_register_interruptible(dev, AB8500_RTC,
245 			AB8500_RTC_CALIB_REG, &rtccal);
246 	if (retval >= 0) {
247 		/*
248 		 * The AB8500 uses sign (in bit7) and magnitude (in bits0-7)
249 		 * so need to convert value from RtcCalibration register into
250 		 * a two's complement signed value...
251 		 */
252 		if (rtccal & 0x80)
253 			*calibration = 0 - (rtccal & 0x7F);
254 		else
255 			*calibration = 0x7F & rtccal;
256 	}
257 
258 	return retval;
259 }
260 
261 static ssize_t ab8500_sysfs_store_rtc_calibration(struct device *dev,
262 				struct device_attribute *attr,
263 				const char *buf, size_t count)
264 {
265 	int retval;
266 	int calibration = 0;
267 
268 	if (sscanf(buf, " %i ", &calibration) != 1) {
269 		dev_err(dev, "Failed to store RTC calibration attribute\n");
270 		return -EINVAL;
271 	}
272 
273 	retval = ab8500_rtc_set_calibration(dev, calibration);
274 
275 	return retval ? retval : count;
276 }
277 
278 static ssize_t ab8500_sysfs_show_rtc_calibration(struct device *dev,
279 				struct device_attribute *attr, char *buf)
280 {
281 	int  retval = 0;
282 	int  calibration = 0;
283 
284 	retval = ab8500_rtc_get_calibration(dev, &calibration);
285 	if (retval < 0) {
286 		dev_err(dev, "Failed to read RTC calibration attribute\n");
287 		sprintf(buf, "0\n");
288 		return retval;
289 	}
290 
291 	return sprintf(buf, "%d\n", calibration);
292 }
293 
294 static DEVICE_ATTR(rtc_calibration, S_IRUGO | S_IWUSR,
295 		   ab8500_sysfs_show_rtc_calibration,
296 		   ab8500_sysfs_store_rtc_calibration);
297 
298 static struct attribute *ab8500_rtc_attrs[] = {
299 	&dev_attr_rtc_calibration.attr,
300 	NULL
301 };
302 
303 static const struct attribute_group ab8500_rtc_sysfs_files = {
304 	.attrs	= ab8500_rtc_attrs,
305 };
306 
307 static irqreturn_t rtc_alarm_handler(int irq, void *data)
308 {
309 	struct rtc_device *rtc = data;
310 	unsigned long events = RTC_IRQF | RTC_AF;
311 
312 	dev_dbg(&rtc->dev, "%s\n", __func__);
313 	rtc_update_irq(rtc, 1, events);
314 
315 	return IRQ_HANDLED;
316 }
317 
318 static const struct rtc_class_ops ab8500_rtc_ops = {
319 	.read_time		= ab8500_rtc_read_time,
320 	.set_time		= ab8500_rtc_set_time,
321 	.read_alarm		= ab8500_rtc_read_alarm,
322 	.set_alarm		= ab8500_rtc_set_alarm,
323 	.alarm_irq_enable	= ab8500_rtc_irq_enable,
324 };
325 
326 static const struct platform_device_id ab85xx_rtc_ids[] = {
327 	{ "ab8500-rtc", (kernel_ulong_t)&ab8500_rtc_ops, },
328 	{ /* sentinel */ }
329 };
330 MODULE_DEVICE_TABLE(platform, ab85xx_rtc_ids);
331 
332 static int ab8500_rtc_probe(struct platform_device *pdev)
333 {
334 	const struct platform_device_id *platid = platform_get_device_id(pdev);
335 	int err;
336 	struct rtc_device *rtc;
337 	u8 rtc_ctrl;
338 	int irq;
339 
340 	irq = platform_get_irq_byname(pdev, "ALARM");
341 	if (irq < 0)
342 		return irq;
343 
344 	/* For RTC supply test */
345 	err = abx500_mask_and_set_register_interruptible(&pdev->dev, AB8500_RTC,
346 		AB8500_RTC_STAT_REG, RTC_STATUS_DATA, RTC_STATUS_DATA);
347 	if (err < 0)
348 		return err;
349 
350 	/* Wait for reset by the PorRtc */
351 	usleep_range(1000, 5000);
352 
353 	err = abx500_get_register_interruptible(&pdev->dev, AB8500_RTC,
354 		AB8500_RTC_STAT_REG, &rtc_ctrl);
355 	if (err < 0)
356 		return err;
357 
358 	/* Check if the RTC Supply fails */
359 	if (!(rtc_ctrl & RTC_STATUS_DATA)) {
360 		dev_err(&pdev->dev, "RTC supply failure\n");
361 		return -ENODEV;
362 	}
363 
364 	device_init_wakeup(&pdev->dev, true);
365 
366 	rtc = devm_rtc_allocate_device(&pdev->dev);
367 	if (IS_ERR(rtc))
368 		return PTR_ERR(rtc);
369 
370 	rtc->ops = (struct rtc_class_ops *)platid->driver_data;
371 
372 	err = devm_request_threaded_irq(&pdev->dev, irq, NULL,
373 			rtc_alarm_handler, IRQF_ONESHOT,
374 			"ab8500-rtc", rtc);
375 	if (err < 0)
376 		return err;
377 
378 	dev_pm_set_wake_irq(&pdev->dev, irq);
379 	platform_set_drvdata(pdev, rtc);
380 
381 	set_bit(RTC_FEATURE_ALARM_RES_MINUTE, rtc->features);
382 	clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, rtc->features);
383 
384 	rtc->range_max = (1ULL << 24) * 60 - 1; // 24-bit minutes + 59 secs
385 	rtc->start_secs = RTC_TIMESTAMP_BEGIN_2000;
386 	rtc->set_start_time = true;
387 
388 	err = rtc_add_group(rtc, &ab8500_rtc_sysfs_files);
389 	if (err)
390 		return err;
391 
392 	return devm_rtc_register_device(rtc);
393 }
394 
395 static int ab8500_rtc_remove(struct platform_device *pdev)
396 {
397 	dev_pm_clear_wake_irq(&pdev->dev);
398 	device_init_wakeup(&pdev->dev, false);
399 
400 	return 0;
401 }
402 
403 static struct platform_driver ab8500_rtc_driver = {
404 	.driver = {
405 		.name = "ab8500-rtc",
406 	},
407 	.probe	= ab8500_rtc_probe,
408 	.remove = ab8500_rtc_remove,
409 	.id_table = ab85xx_rtc_ids,
410 };
411 
412 module_platform_driver(ab8500_rtc_driver);
413 
414 MODULE_AUTHOR("Virupax Sadashivpetimath <virupax.sadashivpetimath@stericsson.com>");
415 MODULE_DESCRIPTION("AB8500 RTC Driver");
416 MODULE_LICENSE("GPL v2");
417