1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright (C) 2012 Avionic Design GmbH
  4 */
  5
  6#include <linux/bcd.h>
  7#include <linux/i2c.h>
  8#include <linux/module.h>
  9#include <linux/rtc.h>
 10#include <linux/of.h>
 11#include <linux/pm_wakeirq.h>
 12
 13#define PCF8523_REG_CONTROL1 0x00
 14#define PCF8523_CONTROL1_CAP_SEL BIT(7)
 15#define PCF8523_CONTROL1_STOP    BIT(5)
 16#define PCF8523_CONTROL1_AIE    BIT(1)
 17
 18#define PCF8523_REG_CONTROL2 0x01
 19#define PCF8523_CONTROL2_AF BIT(3)
 20
 21#define PCF8523_REG_CONTROL3 0x02
 22#define PCF8523_CONTROL3_PM_BLD BIT(7) /* battery low detection disabled */
 23#define PCF8523_CONTROL3_PM_VDD BIT(6) /* switch-over disabled */
 24#define PCF8523_CONTROL3_PM_DSM BIT(5) /* direct switching mode */
 25#define PCF8523_CONTROL3_PM_MASK 0xe0
 26#define PCF8523_CONTROL3_BLF BIT(2) /* battery low bit, read-only */
 27
 28#define PCF8523_REG_SECONDS  0x03
 29#define PCF8523_SECONDS_OS BIT(7)
 30
 31#define PCF8523_REG_MINUTES  0x04
 32#define PCF8523_REG_HOURS    0x05
 33#define PCF8523_REG_DAYS     0x06
 34#define PCF8523_REG_WEEKDAYS 0x07
 35#define PCF8523_REG_MONTHS   0x08
 36#define PCF8523_REG_YEARS    0x09
 37
 38#define PCF8523_REG_MINUTE_ALARM	0x0a
 39#define PCF8523_REG_HOUR_ALARM		0x0b
 40#define PCF8523_REG_DAY_ALARM		0x0c
 41#define PCF8523_REG_WEEKDAY_ALARM	0x0d
 42#define ALARM_DIS BIT(7)
 43
 44#define PCF8523_REG_OFFSET   0x0e
 45#define PCF8523_OFFSET_MODE BIT(7)
 46
 47#define PCF8523_TMR_CLKOUT_CTRL 0x0f
 48
 49struct pcf8523 {
 50	struct rtc_device *rtc;
 51	struct i2c_client *client;
 52};
 53
 54static int pcf8523_read(struct i2c_client *client, u8 reg, u8 *valuep)
 55{
 56	struct i2c_msg msgs[2];
 57	u8 value = 0;
 58	int err;
 59
 60	msgs[0].addr = client->addr;
 61	msgs[0].flags = 0;
 62	msgs[0].len = sizeof(reg);
 63	msgs[0].buf = &reg;
 64
 65	msgs[1].addr = client->addr;
 66	msgs[1].flags = I2C_M_RD;
 67	msgs[1].len = sizeof(value);
 68	msgs[1].buf = &value;
 69
 70	err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 71	if (err < 0)
 72		return err;
 73
 74	*valuep = value;
 75
 76	return 0;
 77}
 78
 79static int pcf8523_write(struct i2c_client *client, u8 reg, u8 value)
 80{
 81	u8 buffer[2] = { reg, value };
 82	struct i2c_msg msg;
 83	int err;
 84
 85	msg.addr = client->addr;
 86	msg.flags = 0;
 87	msg.len = sizeof(buffer);
 88	msg.buf = buffer;
 89
 90	err = i2c_transfer(client->adapter, &msg, 1);
 91	if (err < 0)
 92		return err;
 93
 94	return 0;
 95}
 96
 97static int pcf8523_voltage_low(struct i2c_client *client)
 98{
 99	u8 value;
100	int err;
101
102	err = pcf8523_read(client, PCF8523_REG_CONTROL3, &value);
103	if (err < 0)
104		return err;
105
106	return !!(value & PCF8523_CONTROL3_BLF);
107}
108
109static int pcf8523_load_capacitance(struct i2c_client *client)
110{
111	u32 load;
112	u8 value;
113	int err;
114
115	err = pcf8523_read(client, PCF8523_REG_CONTROL1, &value);
116	if (err < 0)
117		return err;
118
119	load = 12500;
120	of_property_read_u32(client->dev.of_node, "quartz-load-femtofarads",
121			     &load);
122
123	switch (load) {
124	default:
125		dev_warn(&client->dev, "Unknown quartz-load-femtofarads value: %d. Assuming 12500",
126			 load);
127		fallthrough;
128	case 12500:
129		value |= PCF8523_CONTROL1_CAP_SEL;
130		break;
131	case 7000:
132		value &= ~PCF8523_CONTROL1_CAP_SEL;
133		break;
134	}
135
136	err = pcf8523_write(client, PCF8523_REG_CONTROL1, value);
137
138	return err;
139}
140
141static int pcf8523_set_pm(struct i2c_client *client, u8 pm)
142{
143	u8 value;
144	int err;
145
146	err = pcf8523_read(client, PCF8523_REG_CONTROL3, &value);
147	if (err < 0)
148		return err;
149
150	value = (value & ~PCF8523_CONTROL3_PM_MASK) | pm;
151
152	err = pcf8523_write(client, PCF8523_REG_CONTROL3, value);
153	if (err < 0)
154		return err;
155
156	return 0;
157}
158
159static irqreturn_t pcf8523_irq(int irq, void *dev_id)
160{
161	struct pcf8523 *pcf8523 = i2c_get_clientdata(dev_id);
162	u8 value;
163	int err;
164
165	err = pcf8523_read(pcf8523->client, PCF8523_REG_CONTROL2, &value);
166	if (err < 0)
167		return IRQ_HANDLED;
168
169	if (value & PCF8523_CONTROL2_AF) {
170		value &= ~PCF8523_CONTROL2_AF;
171		pcf8523_write(pcf8523->client, PCF8523_REG_CONTROL2, value);
172		rtc_update_irq(pcf8523->rtc, 1, RTC_IRQF | RTC_AF);
173
174		return IRQ_HANDLED;
175	}
176
177	return IRQ_NONE;
178}
179
180static int pcf8523_stop_rtc(struct i2c_client *client)
181{
182	u8 value;
183	int err;
184
185	err = pcf8523_read(client, PCF8523_REG_CONTROL1, &value);
186	if (err < 0)
187		return err;
188
189	value |= PCF8523_CONTROL1_STOP;
190
191	err = pcf8523_write(client, PCF8523_REG_CONTROL1, value);
192	if (err < 0)
193		return err;
194
195	return 0;
196}
197
198static int pcf8523_start_rtc(struct i2c_client *client)
199{
200	u8 value;
201	int err;
202
203	err = pcf8523_read(client, PCF8523_REG_CONTROL1, &value);
204	if (err < 0)
205		return err;
206
207	value &= ~PCF8523_CONTROL1_STOP;
208
209	err = pcf8523_write(client, PCF8523_REG_CONTROL1, value);
210	if (err < 0)
211		return err;
212
213	return 0;
214}
215
216static int pcf8523_rtc_read_time(struct device *dev, struct rtc_time *tm)
217{
218	struct i2c_client *client = to_i2c_client(dev);
219	u8 start = PCF8523_REG_SECONDS, regs[7];
220	struct i2c_msg msgs[2];
221	int err;
222
223	err = pcf8523_voltage_low(client);
224	if (err < 0) {
225		return err;
226	} else if (err > 0) {
227		dev_err(dev, "low voltage detected, time is unreliable\n");
228		return -EINVAL;
229	}
230
231	msgs[0].addr = client->addr;
232	msgs[0].flags = 0;
233	msgs[0].len = 1;
234	msgs[0].buf = &start;
235
236	msgs[1].addr = client->addr;
237	msgs[1].flags = I2C_M_RD;
238	msgs[1].len = sizeof(regs);
239	msgs[1].buf = regs;
240
241	err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
242	if (err < 0)
243		return err;
244
245	if (regs[0] & PCF8523_SECONDS_OS)
246		return -EINVAL;
247
248	tm->tm_sec = bcd2bin(regs[0] & 0x7f);
249	tm->tm_min = bcd2bin(regs[1] & 0x7f);
250	tm->tm_hour = bcd2bin(regs[2] & 0x3f);
251	tm->tm_mday = bcd2bin(regs[3] & 0x3f);
252	tm->tm_wday = regs[4] & 0x7;
253	tm->tm_mon = bcd2bin(regs[5] & 0x1f) - 1;
254	tm->tm_year = bcd2bin(regs[6]) + 100;
255
256	return 0;
257}
258
259static int pcf8523_rtc_set_time(struct device *dev, struct rtc_time *tm)
260{
261	struct i2c_client *client = to_i2c_client(dev);
262	struct i2c_msg msg;
263	u8 regs[8];
264	int err;
265
266	err = pcf8523_stop_rtc(client);
267	if (err < 0)
268		return err;
269
270	regs[0] = PCF8523_REG_SECONDS;
271	/* This will purposely overwrite PCF8523_SECONDS_OS */
272	regs[1] = bin2bcd(tm->tm_sec);
273	regs[2] = bin2bcd(tm->tm_min);
274	regs[3] = bin2bcd(tm->tm_hour);
275	regs[4] = bin2bcd(tm->tm_mday);
276	regs[5] = tm->tm_wday;
277	regs[6] = bin2bcd(tm->tm_mon + 1);
278	regs[7] = bin2bcd(tm->tm_year - 100);
279
280	msg.addr = client->addr;
281	msg.flags = 0;
282	msg.len = sizeof(regs);
283	msg.buf = regs;
284
285	err = i2c_transfer(client->adapter, &msg, 1);
286	if (err < 0) {
287		/*
288		 * If the time cannot be set, restart the RTC anyway. Note
289		 * that errors are ignored if the RTC cannot be started so
290		 * that we have a chance to propagate the original error.
291		 */
292		pcf8523_start_rtc(client);
293		return err;
294	}
295
296	return pcf8523_start_rtc(client);
297}
298
299static int pcf8523_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *tm)
300{
301	struct i2c_client *client = to_i2c_client(dev);
302	u8 start = PCF8523_REG_MINUTE_ALARM, regs[4];
303	struct i2c_msg msgs[2];
304	u8 value;
305	int err;
306
307	msgs[0].addr = client->addr;
308	msgs[0].flags = 0;
309	msgs[0].len = 1;
310	msgs[0].buf = &start;
311
312	msgs[1].addr = client->addr;
313	msgs[1].flags = I2C_M_RD;
314	msgs[1].len = sizeof(regs);
315	msgs[1].buf = regs;
316
317	err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
318	if (err < 0)
319		return err;
320
321	tm->time.tm_sec = 0;
322	tm->time.tm_min = bcd2bin(regs[0] & 0x7F);
323	tm->time.tm_hour = bcd2bin(regs[1] & 0x3F);
324	tm->time.tm_mday = bcd2bin(regs[2] & 0x3F);
325	tm->time.tm_wday = bcd2bin(regs[3] & 0x7);
326
327	err = pcf8523_read(client, PCF8523_REG_CONTROL1, &value);
328	if (err < 0)
329		return err;
330	tm->enabled = !!(value & PCF8523_CONTROL1_AIE);
331
332	err = pcf8523_read(client, PCF8523_REG_CONTROL2, &value);
333	if (err < 0)
334		return err;
335	tm->pending = !!(value & PCF8523_CONTROL2_AF);
336
337	return 0;
338}
339
340static int pcf8523_irq_enable(struct device *dev, unsigned int enabled)
341{
342	struct i2c_client *client = to_i2c_client(dev);
343	u8 value;
344	int err;
345
346	err = pcf8523_read(client, PCF8523_REG_CONTROL1, &value);
347	if (err < 0)
348		return err;
349
350	value &= PCF8523_CONTROL1_AIE;
351
352	if (enabled)
353		value |= PCF8523_CONTROL1_AIE;
354
355	err = pcf8523_write(client, PCF8523_REG_CONTROL1, value);
356	if (err < 0)
357		return err;
358
359	return 0;
360}
361
362static int pcf8523_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *tm)
363{
364	struct i2c_client *client = to_i2c_client(dev);
365	struct i2c_msg msg;
366	u8 regs[5];
367	int err;
368
369	err = pcf8523_irq_enable(dev, 0);
370	if (err)
371		return err;
372
373	err = pcf8523_write(client, PCF8523_REG_CONTROL2, 0);
374	if (err < 0)
375		return err;
376
377	/* The alarm has no seconds, round up to nearest minute */
378	if (tm->time.tm_sec) {
379		time64_t alarm_time = rtc_tm_to_time64(&tm->time);
380
381		alarm_time += 60 - tm->time.tm_sec;
382		rtc_time64_to_tm(alarm_time, &tm->time);
383	}
384
385	regs[0] = PCF8523_REG_MINUTE_ALARM;
386	regs[1] = bin2bcd(tm->time.tm_min);
387	regs[2] = bin2bcd(tm->time.tm_hour);
388	regs[3] = bin2bcd(tm->time.tm_mday);
389	regs[4] = ALARM_DIS;
390	msg.addr = client->addr;
391	msg.flags = 0;
392	msg.len = sizeof(regs);
393	msg.buf = regs;
394	err = i2c_transfer(client->adapter, &msg, 1);
395	if (err < 0)
396		return err;
397
398	if (tm->enabled)
399		return pcf8523_irq_enable(dev, tm->enabled);
400
401	return 0;
402}
403
404#ifdef CONFIG_RTC_INTF_DEV
405static int pcf8523_rtc_ioctl(struct device *dev, unsigned int cmd,
406			     unsigned long arg)
407{
408	struct i2c_client *client = to_i2c_client(dev);
409	unsigned int flags = 0;
410	u8 value;
411	int ret;
412
413	switch (cmd) {
414	case RTC_VL_READ:
415		ret = pcf8523_voltage_low(client);
416		if (ret < 0)
417			return ret;
418		if (ret)
419			flags |= RTC_VL_BACKUP_LOW;
420
421		ret = pcf8523_read(client, PCF8523_REG_SECONDS, &value);
422		if (ret < 0)
423			return ret;
424
425		if (value & PCF8523_SECONDS_OS)
426			flags |= RTC_VL_DATA_INVALID;
427
428		return put_user(flags, (unsigned int __user *)arg);
429
430	default:
431		return -ENOIOCTLCMD;
432	}
433}
434#else
435#define pcf8523_rtc_ioctl NULL
436#endif
437
438static int pcf8523_rtc_read_offset(struct device *dev, long *offset)
439{
440	struct i2c_client *client = to_i2c_client(dev);
441	int err;
442	u8 value;
443	s8 val;
444
445	err = pcf8523_read(client, PCF8523_REG_OFFSET, &value);
446	if (err < 0)
447		return err;
448
449	/* sign extend the 7-bit offset value */
450	val = value << 1;
451	*offset = (value & PCF8523_OFFSET_MODE ? 4069 : 4340) * (val >> 1);
452
453	return 0;
454}
455
456static int pcf8523_rtc_set_offset(struct device *dev, long offset)
457{
458	struct i2c_client *client = to_i2c_client(dev);
459	long reg_m0, reg_m1;
460	u8 value;
461
462	reg_m0 = clamp(DIV_ROUND_CLOSEST(offset, 4340), -64L, 63L);
463	reg_m1 = clamp(DIV_ROUND_CLOSEST(offset, 4069), -64L, 63L);
464
465	if (abs(reg_m0 * 4340 - offset) < abs(reg_m1 * 4069 - offset))
466		value = reg_m0 & 0x7f;
467	else
468		value = (reg_m1 & 0x7f) | PCF8523_OFFSET_MODE;
469
470	return pcf8523_write(client, PCF8523_REG_OFFSET, value);
471}
472
473static const struct rtc_class_ops pcf8523_rtc_ops = {
474	.read_time = pcf8523_rtc_read_time,
475	.set_time = pcf8523_rtc_set_time,
476	.read_alarm = pcf8523_rtc_read_alarm,
477	.set_alarm = pcf8523_rtc_set_alarm,
478	.alarm_irq_enable = pcf8523_irq_enable,
479	.ioctl = pcf8523_rtc_ioctl,
480	.read_offset = pcf8523_rtc_read_offset,
481	.set_offset = pcf8523_rtc_set_offset,
482};
483
484static int pcf8523_probe(struct i2c_client *client,
485			 const struct i2c_device_id *id)
486{
487	struct pcf8523 *pcf8523;
488	struct rtc_device *rtc;
489	bool wakeup_source = false;
490	int err;
491
492	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
493		return -ENODEV;
494
495	pcf8523 = devm_kzalloc(&client->dev, sizeof(struct pcf8523), GFP_KERNEL);
496	if (!pcf8523)
497		return -ENOMEM;
498
499	i2c_set_clientdata(client, pcf8523);
500	pcf8523->client = client;
501
502	err = pcf8523_load_capacitance(client);
503	if (err < 0)
504		dev_warn(&client->dev, "failed to set xtal load capacitance: %d",
505			 err);
506
507	err = pcf8523_set_pm(client, 0);
508	if (err < 0)
509		return err;
510
511	rtc = devm_rtc_allocate_device(&client->dev);
512	if (IS_ERR(rtc))
513		return PTR_ERR(rtc);
514
515	pcf8523->rtc = rtc;
516	rtc->ops = &pcf8523_rtc_ops;
517	rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
518	rtc->range_max = RTC_TIMESTAMP_END_2099;
519	rtc->uie_unsupported = 1;
520
521	if (client->irq > 0) {
522		err = pcf8523_write(client, PCF8523_TMR_CLKOUT_CTRL, 0x38);
523		if (err < 0)
524			return err;
525
526		err = devm_request_threaded_irq(&client->dev, client->irq,
527						NULL, pcf8523_irq,
528						IRQF_SHARED | IRQF_ONESHOT | IRQF_TRIGGER_LOW,
529						dev_name(&rtc->dev), client);
530		if (err)
531			return err;
532
533		dev_pm_set_wake_irq(&client->dev, client->irq);
534	}
535
536#ifdef CONFIG_OF
537	wakeup_source = of_property_read_bool(client->dev.of_node, "wakeup-source");
538#endif
539	if (client->irq > 0 || wakeup_source)
540		device_init_wakeup(&client->dev, true);
541
542	return devm_rtc_register_device(rtc);
543}
544
545static const struct i2c_device_id pcf8523_id[] = {
546	{ "pcf8523", 0 },
547	{ }
548};
549MODULE_DEVICE_TABLE(i2c, pcf8523_id);
550
551#ifdef CONFIG_OF
552static const struct of_device_id pcf8523_of_match[] = {
553	{ .compatible = "nxp,pcf8523" },
554	{ .compatible = "microcrystal,rv8523" },
555	{ }
556};
557MODULE_DEVICE_TABLE(of, pcf8523_of_match);
558#endif
559
560static struct i2c_driver pcf8523_driver = {
561	.driver = {
562		.name = "rtc-pcf8523",
563		.of_match_table = of_match_ptr(pcf8523_of_match),
564	},
565	.probe = pcf8523_probe,
566	.id_table = pcf8523_id,
567};
568module_i2c_driver(pcf8523_driver);
569
570MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
571MODULE_DESCRIPTION("NXP PCF8523 RTC driver");
572MODULE_LICENSE("GPL v2");