xref: /openbmc/linux/drivers/rtc/rtc-isl1208.c (revision 625fd913)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Intersil ISL1208 rtc class driver
4  *
5  * Copyright 2005,2006 Hebert Valerio Riedel <hvr@gnu.org>
6  */
7 
8 #include <linux/bcd.h>
9 #include <linux/clk.h>
10 #include <linux/i2c.h>
11 #include <linux/module.h>
12 #include <linux/of.h>
13 #include <linux/of_irq.h>
14 #include <linux/rtc.h>
15 
16 /* Register map */
17 /* rtc section */
18 #define ISL1208_REG_SC  0x00
19 #define ISL1208_REG_MN  0x01
20 #define ISL1208_REG_HR  0x02
21 #define ISL1208_REG_HR_MIL     (1<<7)	/* 24h/12h mode */
22 #define ISL1208_REG_HR_PM      (1<<5)	/* PM/AM bit in 12h mode */
23 #define ISL1208_REG_DT  0x03
24 #define ISL1208_REG_MO  0x04
25 #define ISL1208_REG_YR  0x05
26 #define ISL1208_REG_DW  0x06
27 #define ISL1208_RTC_SECTION_LEN 7
28 
29 /* control/status section */
30 #define ISL1208_REG_SR  0x07
31 #define ISL1208_REG_SR_ARST    (1<<7)	/* auto reset */
32 #define ISL1208_REG_SR_XTOSCB  (1<<6)	/* crystal oscillator */
33 #define ISL1208_REG_SR_WRTC    (1<<4)	/* write rtc */
34 #define ISL1208_REG_SR_EVT     (1<<3)	/* event */
35 #define ISL1208_REG_SR_ALM     (1<<2)	/* alarm */
36 #define ISL1208_REG_SR_BAT     (1<<1)	/* battery */
37 #define ISL1208_REG_SR_RTCF    (1<<0)	/* rtc fail */
38 #define ISL1208_REG_INT 0x08
39 #define ISL1208_REG_INT_ALME   (1<<6)   /* alarm enable */
40 #define ISL1208_REG_INT_IM     (1<<7)   /* interrupt/alarm mode */
41 #define ISL1219_REG_EV  0x09
42 #define ISL1219_REG_EV_EVEN    (1<<4)   /* event detection enable */
43 #define ISL1219_REG_EV_EVIENB  (1<<7)   /* event in pull-up disable */
44 #define ISL1208_REG_ATR 0x0a
45 #define ISL1208_REG_DTR 0x0b
46 
47 /* alarm section */
48 #define ISL1208_REG_SCA 0x0c
49 #define ISL1208_REG_MNA 0x0d
50 #define ISL1208_REG_HRA 0x0e
51 #define ISL1208_REG_DTA 0x0f
52 #define ISL1208_REG_MOA 0x10
53 #define ISL1208_REG_DWA 0x11
54 #define ISL1208_ALARM_SECTION_LEN 6
55 
56 /* user section */
57 #define ISL1208_REG_USR1 0x12
58 #define ISL1208_REG_USR2 0x13
59 #define ISL1208_USR_SECTION_LEN 2
60 
61 /* event section */
62 #define ISL1219_REG_SCT 0x14
63 #define ISL1219_REG_MNT 0x15
64 #define ISL1219_REG_HRT 0x16
65 #define ISL1219_REG_DTT 0x17
66 #define ISL1219_REG_MOT 0x18
67 #define ISL1219_REG_YRT 0x19
68 #define ISL1219_EVT_SECTION_LEN 6
69 
70 static struct i2c_driver isl1208_driver;
71 
72 /* Chip capabilities table */
73 struct isl1208_config {
74 	unsigned int	nvmem_length;
75 	unsigned	has_tamper:1;
76 	unsigned	has_timestamp:1;
77 	unsigned	has_inverted_osc_bit:1;
78 };
79 
80 static const struct isl1208_config config_isl1208 = {
81 	.nvmem_length = 2,
82 	.has_tamper = false,
83 	.has_timestamp = false
84 };
85 
86 static const struct isl1208_config config_isl1209 = {
87 	.nvmem_length = 2,
88 	.has_tamper = true,
89 	.has_timestamp = false
90 };
91 
92 static const struct isl1208_config config_isl1218 = {
93 	.nvmem_length = 8,
94 	.has_tamper = false,
95 	.has_timestamp = false
96 };
97 
98 static const struct isl1208_config config_isl1219 = {
99 	.nvmem_length = 2,
100 	.has_tamper = true,
101 	.has_timestamp = true
102 };
103 
104 static const struct isl1208_config config_raa215300_a0 = {
105 	.nvmem_length = 2,
106 	.has_tamper = false,
107 	.has_timestamp = false,
108 	.has_inverted_osc_bit = true
109 };
110 
111 static const struct i2c_device_id isl1208_id[] = {
112 	{ "isl1208", .driver_data = (kernel_ulong_t)&config_isl1208 },
113 	{ "isl1209", .driver_data = (kernel_ulong_t)&config_isl1209 },
114 	{ "isl1218", .driver_data = (kernel_ulong_t)&config_isl1218 },
115 	{ "isl1219", .driver_data = (kernel_ulong_t)&config_isl1219 },
116 	{ "raa215300_a0", .driver_data = (kernel_ulong_t)&config_raa215300_a0 },
117 	{ }
118 };
119 MODULE_DEVICE_TABLE(i2c, isl1208_id);
120 
121 static const __maybe_unused struct of_device_id isl1208_of_match[] = {
122 	{ .compatible = "isil,isl1208", .data = &config_isl1208 },
123 	{ .compatible = "isil,isl1209", .data = &config_isl1209 },
124 	{ .compatible = "isil,isl1218", .data = &config_isl1218 },
125 	{ .compatible = "isil,isl1219", .data = &config_isl1219 },
126 	{ }
127 };
128 MODULE_DEVICE_TABLE(of, isl1208_of_match);
129 
130 /* Device state */
131 struct isl1208_state {
132 	struct nvmem_config nvmem_config;
133 	struct rtc_device *rtc;
134 	const struct isl1208_config *config;
135 };
136 
137 /* block read */
138 static int
isl1208_i2c_read_regs(struct i2c_client * client,u8 reg,u8 buf[],unsigned len)139 isl1208_i2c_read_regs(struct i2c_client *client, u8 reg, u8 buf[],
140 		      unsigned len)
141 {
142 	int ret;
143 
144 	WARN_ON(reg > ISL1219_REG_YRT);
145 	WARN_ON(reg + len > ISL1219_REG_YRT + 1);
146 
147 	ret = i2c_smbus_read_i2c_block_data(client, reg, len, buf);
148 	return (ret < 0) ? ret : 0;
149 }
150 
151 /* block write */
152 static int
isl1208_i2c_set_regs(struct i2c_client * client,u8 reg,u8 const buf[],unsigned len)153 isl1208_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[],
154 		     unsigned len)
155 {
156 	int ret;
157 
158 	WARN_ON(reg > ISL1219_REG_YRT);
159 	WARN_ON(reg + len > ISL1219_REG_YRT + 1);
160 
161 	ret = i2c_smbus_write_i2c_block_data(client, reg, len, buf);
162 	return (ret < 0) ? ret : 0;
163 }
164 
165 /* simple check to see whether we have a isl1208 */
166 static int
isl1208_i2c_validate_client(struct i2c_client * client)167 isl1208_i2c_validate_client(struct i2c_client *client)
168 {
169 	u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
170 	u8 zero_mask[ISL1208_RTC_SECTION_LEN] = {
171 		0x80, 0x80, 0x40, 0xc0, 0xe0, 0x00, 0xf8
172 	};
173 	int i;
174 	int ret;
175 
176 	ret = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
177 	if (ret < 0)
178 		return ret;
179 
180 	for (i = 0; i < ISL1208_RTC_SECTION_LEN; ++i) {
181 		if (regs[i] & zero_mask[i])	/* check if bits are cleared */
182 			return -ENODEV;
183 	}
184 
185 	return 0;
186 }
187 
isl1208_set_xtoscb(struct i2c_client * client,int sr,int xtosb_val)188 static int isl1208_set_xtoscb(struct i2c_client *client, int sr, int xtosb_val)
189 {
190 	/* Do nothing if bit is already set to desired value */
191 	if (!!(sr & ISL1208_REG_SR_XTOSCB) == xtosb_val)
192 		return 0;
193 
194 	if (xtosb_val)
195 		sr |= ISL1208_REG_SR_XTOSCB;
196 	else
197 		sr &= ~ISL1208_REG_SR_XTOSCB;
198 
199 	return i2c_smbus_write_byte_data(client, ISL1208_REG_SR, sr);
200 }
201 
202 static int
isl1208_i2c_get_sr(struct i2c_client * client)203 isl1208_i2c_get_sr(struct i2c_client *client)
204 {
205 	return i2c_smbus_read_byte_data(client, ISL1208_REG_SR);
206 }
207 
208 static int
isl1208_i2c_get_atr(struct i2c_client * client)209 isl1208_i2c_get_atr(struct i2c_client *client)
210 {
211 	int atr = i2c_smbus_read_byte_data(client, ISL1208_REG_ATR);
212 	if (atr < 0)
213 		return atr;
214 
215 	/* The 6bit value in the ATR register controls the load
216 	 * capacitance C_load * in steps of 0.25pF
217 	 *
218 	 * bit (1<<5) of the ATR register is inverted
219 	 *
220 	 * C_load(ATR=0x20) =  4.50pF
221 	 * C_load(ATR=0x00) = 12.50pF
222 	 * C_load(ATR=0x1f) = 20.25pF
223 	 *
224 	 */
225 
226 	atr &= 0x3f;		/* mask out lsb */
227 	atr ^= 1 << 5;		/* invert 6th bit */
228 	atr += 2 * 9;		/* add offset of 4.5pF; unit[atr] = 0.25pF */
229 
230 	return atr;
231 }
232 
233 /* returns adjustment value + 100 */
234 static int
isl1208_i2c_get_dtr(struct i2c_client * client)235 isl1208_i2c_get_dtr(struct i2c_client *client)
236 {
237 	int dtr = i2c_smbus_read_byte_data(client, ISL1208_REG_DTR);
238 	if (dtr < 0)
239 		return -EIO;
240 
241 	/* dtr encodes adjustments of {-60,-40,-20,0,20,40,60} ppm */
242 	dtr = ((dtr & 0x3) * 20) * (dtr & (1 << 2) ? -1 : 1);
243 
244 	return dtr + 100;
245 }
246 
247 static int
isl1208_i2c_get_usr(struct i2c_client * client)248 isl1208_i2c_get_usr(struct i2c_client *client)
249 {
250 	u8 buf[ISL1208_USR_SECTION_LEN] = { 0, };
251 	int ret;
252 
253 	ret = isl1208_i2c_read_regs(client, ISL1208_REG_USR1, buf,
254 				    ISL1208_USR_SECTION_LEN);
255 	if (ret < 0)
256 		return ret;
257 
258 	return (buf[1] << 8) | buf[0];
259 }
260 
261 static int
isl1208_i2c_set_usr(struct i2c_client * client,u16 usr)262 isl1208_i2c_set_usr(struct i2c_client *client, u16 usr)
263 {
264 	u8 buf[ISL1208_USR_SECTION_LEN];
265 
266 	buf[0] = usr & 0xff;
267 	buf[1] = (usr >> 8) & 0xff;
268 
269 	return isl1208_i2c_set_regs(client, ISL1208_REG_USR1, buf,
270 				    ISL1208_USR_SECTION_LEN);
271 }
272 
273 static int
isl1208_rtc_toggle_alarm(struct i2c_client * client,int enable)274 isl1208_rtc_toggle_alarm(struct i2c_client *client, int enable)
275 {
276 	int icr = i2c_smbus_read_byte_data(client, ISL1208_REG_INT);
277 
278 	if (icr < 0) {
279 		dev_err(&client->dev, "%s: reading INT failed\n", __func__);
280 		return icr;
281 	}
282 
283 	if (enable)
284 		icr |= ISL1208_REG_INT_ALME | ISL1208_REG_INT_IM;
285 	else
286 		icr &= ~(ISL1208_REG_INT_ALME | ISL1208_REG_INT_IM);
287 
288 	icr = i2c_smbus_write_byte_data(client, ISL1208_REG_INT, icr);
289 	if (icr < 0) {
290 		dev_err(&client->dev, "%s: writing INT failed\n", __func__);
291 		return icr;
292 	}
293 
294 	return 0;
295 }
296 
297 static int
isl1208_rtc_proc(struct device * dev,struct seq_file * seq)298 isl1208_rtc_proc(struct device *dev, struct seq_file *seq)
299 {
300 	struct i2c_client *const client = to_i2c_client(dev);
301 	int sr, dtr, atr, usr;
302 
303 	sr = isl1208_i2c_get_sr(client);
304 	if (sr < 0) {
305 		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
306 		return sr;
307 	}
308 
309 	seq_printf(seq, "status_reg\t:%s%s%s%s%s%s (0x%.2x)\n",
310 		   (sr & ISL1208_REG_SR_RTCF) ? " RTCF" : "",
311 		   (sr & ISL1208_REG_SR_BAT) ? " BAT" : "",
312 		   (sr & ISL1208_REG_SR_ALM) ? " ALM" : "",
313 		   (sr & ISL1208_REG_SR_WRTC) ? " WRTC" : "",
314 		   (sr & ISL1208_REG_SR_XTOSCB) ? " XTOSCB" : "",
315 		   (sr & ISL1208_REG_SR_ARST) ? " ARST" : "", sr);
316 
317 	seq_printf(seq, "batt_status\t: %s\n",
318 		   (sr & ISL1208_REG_SR_RTCF) ? "bad" : "okay");
319 
320 	dtr = isl1208_i2c_get_dtr(client);
321 	if (dtr >= 0)
322 		seq_printf(seq, "digital_trim\t: %d ppm\n", dtr - 100);
323 
324 	atr = isl1208_i2c_get_atr(client);
325 	if (atr >= 0)
326 		seq_printf(seq, "analog_trim\t: %d.%.2d pF\n",
327 			   atr >> 2, (atr & 0x3) * 25);
328 
329 	usr = isl1208_i2c_get_usr(client);
330 	if (usr >= 0)
331 		seq_printf(seq, "user_data\t: 0x%.4x\n", usr);
332 
333 	return 0;
334 }
335 
336 static int
isl1208_i2c_read_time(struct i2c_client * client,struct rtc_time * tm)337 isl1208_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
338 {
339 	int sr;
340 	u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
341 
342 	sr = isl1208_i2c_get_sr(client);
343 	if (sr < 0) {
344 		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
345 		return -EIO;
346 	}
347 
348 	sr = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
349 	if (sr < 0) {
350 		dev_err(&client->dev, "%s: reading RTC section failed\n",
351 			__func__);
352 		return sr;
353 	}
354 
355 	tm->tm_sec = bcd2bin(regs[ISL1208_REG_SC]);
356 	tm->tm_min = bcd2bin(regs[ISL1208_REG_MN]);
357 
358 	/* HR field has a more complex interpretation */
359 	{
360 		const u8 _hr = regs[ISL1208_REG_HR];
361 		if (_hr & ISL1208_REG_HR_MIL)	/* 24h format */
362 			tm->tm_hour = bcd2bin(_hr & 0x3f);
363 		else {
364 			/* 12h format */
365 			tm->tm_hour = bcd2bin(_hr & 0x1f);
366 			if (_hr & ISL1208_REG_HR_PM)	/* PM flag set */
367 				tm->tm_hour += 12;
368 		}
369 	}
370 
371 	tm->tm_mday = bcd2bin(regs[ISL1208_REG_DT]);
372 	tm->tm_mon = bcd2bin(regs[ISL1208_REG_MO]) - 1;	/* rtc starts at 1 */
373 	tm->tm_year = bcd2bin(regs[ISL1208_REG_YR]) + 100;
374 	tm->tm_wday = bcd2bin(regs[ISL1208_REG_DW]);
375 
376 	return 0;
377 }
378 
379 static int
isl1208_i2c_read_alarm(struct i2c_client * client,struct rtc_wkalrm * alarm)380 isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
381 {
382 	struct rtc_time *const tm = &alarm->time;
383 	u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, };
384 	int icr, yr, sr = isl1208_i2c_get_sr(client);
385 
386 	if (sr < 0) {
387 		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
388 		return sr;
389 	}
390 
391 	sr = isl1208_i2c_read_regs(client, ISL1208_REG_SCA, regs,
392 				   ISL1208_ALARM_SECTION_LEN);
393 	if (sr < 0) {
394 		dev_err(&client->dev, "%s: reading alarm section failed\n",
395 			__func__);
396 		return sr;
397 	}
398 
399 	/* MSB of each alarm register is an enable bit */
400 	tm->tm_sec = bcd2bin(regs[ISL1208_REG_SCA - ISL1208_REG_SCA] & 0x7f);
401 	tm->tm_min = bcd2bin(regs[ISL1208_REG_MNA - ISL1208_REG_SCA] & 0x7f);
402 	tm->tm_hour = bcd2bin(regs[ISL1208_REG_HRA - ISL1208_REG_SCA] & 0x3f);
403 	tm->tm_mday = bcd2bin(regs[ISL1208_REG_DTA - ISL1208_REG_SCA] & 0x3f);
404 	tm->tm_mon =
405 		bcd2bin(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1;
406 	tm->tm_wday = bcd2bin(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03);
407 
408 	/* The alarm doesn't store the year so get it from the rtc section */
409 	yr = i2c_smbus_read_byte_data(client, ISL1208_REG_YR);
410 	if (yr < 0) {
411 		dev_err(&client->dev, "%s: reading RTC YR failed\n", __func__);
412 		return yr;
413 	}
414 	tm->tm_year = bcd2bin(yr) + 100;
415 
416 	icr = i2c_smbus_read_byte_data(client, ISL1208_REG_INT);
417 	if (icr < 0) {
418 		dev_err(&client->dev, "%s: reading INT failed\n", __func__);
419 		return icr;
420 	}
421 	alarm->enabled = !!(icr & ISL1208_REG_INT_ALME);
422 
423 	return 0;
424 }
425 
426 static int
isl1208_i2c_set_alarm(struct i2c_client * client,struct rtc_wkalrm * alarm)427 isl1208_i2c_set_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
428 {
429 	struct rtc_time *alarm_tm = &alarm->time;
430 	u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, };
431 	const int offs = ISL1208_REG_SCA;
432 	struct rtc_time rtc_tm;
433 	int err, enable;
434 
435 	err = isl1208_i2c_read_time(client, &rtc_tm);
436 	if (err)
437 		return err;
438 
439 	/* If the alarm time is before the current time disable the alarm */
440 	if (!alarm->enabled || rtc_tm_sub(alarm_tm, &rtc_tm) <= 0)
441 		enable = 0x00;
442 	else
443 		enable = 0x80;
444 
445 	/* Program the alarm and enable it for each setting */
446 	regs[ISL1208_REG_SCA - offs] = bin2bcd(alarm_tm->tm_sec) | enable;
447 	regs[ISL1208_REG_MNA - offs] = bin2bcd(alarm_tm->tm_min) | enable;
448 	regs[ISL1208_REG_HRA - offs] = bin2bcd(alarm_tm->tm_hour) |
449 		ISL1208_REG_HR_MIL | enable;
450 
451 	regs[ISL1208_REG_DTA - offs] = bin2bcd(alarm_tm->tm_mday) | enable;
452 	regs[ISL1208_REG_MOA - offs] = bin2bcd(alarm_tm->tm_mon + 1) | enable;
453 	regs[ISL1208_REG_DWA - offs] = bin2bcd(alarm_tm->tm_wday & 7) | enable;
454 
455 	/* write ALARM registers */
456 	err = isl1208_i2c_set_regs(client, offs, regs,
457 				  ISL1208_ALARM_SECTION_LEN);
458 	if (err < 0) {
459 		dev_err(&client->dev, "%s: writing ALARM section failed\n",
460 			__func__);
461 		return err;
462 	}
463 
464 	err = isl1208_rtc_toggle_alarm(client, enable);
465 	if (err)
466 		return err;
467 
468 	return 0;
469 }
470 
471 static int
isl1208_rtc_read_time(struct device * dev,struct rtc_time * tm)472 isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm)
473 {
474 	return isl1208_i2c_read_time(to_i2c_client(dev), tm);
475 }
476 
477 static int
isl1208_i2c_set_time(struct i2c_client * client,struct rtc_time const * tm)478 isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
479 {
480 	int sr;
481 	u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
482 
483 	/* The clock has an 8 bit wide bcd-coded register (they never learn)
484 	 * for the year. tm_year is an offset from 1900 and we are interested
485 	 * in the 2000-2099 range, so any value less than 100 is invalid.
486 	 */
487 	if (tm->tm_year < 100)
488 		return -EINVAL;
489 
490 	regs[ISL1208_REG_SC] = bin2bcd(tm->tm_sec);
491 	regs[ISL1208_REG_MN] = bin2bcd(tm->tm_min);
492 	regs[ISL1208_REG_HR] = bin2bcd(tm->tm_hour) | ISL1208_REG_HR_MIL;
493 
494 	regs[ISL1208_REG_DT] = bin2bcd(tm->tm_mday);
495 	regs[ISL1208_REG_MO] = bin2bcd(tm->tm_mon + 1);
496 	regs[ISL1208_REG_YR] = bin2bcd(tm->tm_year - 100);
497 
498 	regs[ISL1208_REG_DW] = bin2bcd(tm->tm_wday & 7);
499 
500 	sr = isl1208_i2c_get_sr(client);
501 	if (sr < 0) {
502 		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
503 		return sr;
504 	}
505 
506 	/* set WRTC */
507 	sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
508 				       sr | ISL1208_REG_SR_WRTC);
509 	if (sr < 0) {
510 		dev_err(&client->dev, "%s: writing SR failed\n", __func__);
511 		return sr;
512 	}
513 
514 	/* write RTC registers */
515 	sr = isl1208_i2c_set_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
516 	if (sr < 0) {
517 		dev_err(&client->dev, "%s: writing RTC section failed\n",
518 			__func__);
519 		return sr;
520 	}
521 
522 	/* clear WRTC again */
523 	sr = isl1208_i2c_get_sr(client);
524 	if (sr < 0) {
525 		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
526 		return sr;
527 	}
528 	sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
529 				       sr & ~ISL1208_REG_SR_WRTC);
530 	if (sr < 0) {
531 		dev_err(&client->dev, "%s: writing SR failed\n", __func__);
532 		return sr;
533 	}
534 
535 	return 0;
536 }
537 
538 static int
isl1208_rtc_set_time(struct device * dev,struct rtc_time * tm)539 isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm)
540 {
541 	return isl1208_i2c_set_time(to_i2c_client(dev), tm);
542 }
543 
544 static int
isl1208_rtc_read_alarm(struct device * dev,struct rtc_wkalrm * alarm)545 isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
546 {
547 	return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm);
548 }
549 
550 static int
isl1208_rtc_set_alarm(struct device * dev,struct rtc_wkalrm * alarm)551 isl1208_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
552 {
553 	return isl1208_i2c_set_alarm(to_i2c_client(dev), alarm);
554 }
555 
timestamp0_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)556 static ssize_t timestamp0_store(struct device *dev,
557 				struct device_attribute *attr,
558 				const char *buf, size_t count)
559 {
560 	struct i2c_client *client = to_i2c_client(dev->parent);
561 	int sr;
562 
563 	sr = isl1208_i2c_get_sr(client);
564 	if (sr < 0) {
565 		dev_err(dev, "%s: reading SR failed\n", __func__);
566 		return sr;
567 	}
568 
569 	sr &= ~ISL1208_REG_SR_EVT;
570 
571 	sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, sr);
572 	if (sr < 0)
573 		dev_err(dev, "%s: writing SR failed\n",
574 			__func__);
575 
576 	return count;
577 };
578 
timestamp0_show(struct device * dev,struct device_attribute * attr,char * buf)579 static ssize_t timestamp0_show(struct device *dev,
580 			       struct device_attribute *attr, char *buf)
581 {
582 	struct i2c_client *client = to_i2c_client(dev->parent);
583 	u8 regs[ISL1219_EVT_SECTION_LEN] = { 0, };
584 	struct rtc_time tm;
585 	int sr;
586 
587 	sr = isl1208_i2c_get_sr(client);
588 	if (sr < 0) {
589 		dev_err(dev, "%s: reading SR failed\n", __func__);
590 		return sr;
591 	}
592 
593 	if (!(sr & ISL1208_REG_SR_EVT))
594 		return 0;
595 
596 	sr = isl1208_i2c_read_regs(client, ISL1219_REG_SCT, regs,
597 				   ISL1219_EVT_SECTION_LEN);
598 	if (sr < 0) {
599 		dev_err(dev, "%s: reading event section failed\n",
600 			__func__);
601 		return 0;
602 	}
603 
604 	/* MSB of each alarm register is an enable bit */
605 	tm.tm_sec = bcd2bin(regs[ISL1219_REG_SCT - ISL1219_REG_SCT] & 0x7f);
606 	tm.tm_min = bcd2bin(regs[ISL1219_REG_MNT - ISL1219_REG_SCT] & 0x7f);
607 	tm.tm_hour = bcd2bin(regs[ISL1219_REG_HRT - ISL1219_REG_SCT] & 0x3f);
608 	tm.tm_mday = bcd2bin(regs[ISL1219_REG_DTT - ISL1219_REG_SCT] & 0x3f);
609 	tm.tm_mon =
610 		bcd2bin(regs[ISL1219_REG_MOT - ISL1219_REG_SCT] & 0x1f) - 1;
611 	tm.tm_year = bcd2bin(regs[ISL1219_REG_YRT - ISL1219_REG_SCT]) + 100;
612 
613 	sr = rtc_valid_tm(&tm);
614 	if (sr)
615 		return sr;
616 
617 	return sprintf(buf, "%llu\n",
618 				(unsigned long long)rtc_tm_to_time64(&tm));
619 };
620 
621 static DEVICE_ATTR_RW(timestamp0);
622 
623 static irqreturn_t
isl1208_rtc_interrupt(int irq,void * data)624 isl1208_rtc_interrupt(int irq, void *data)
625 {
626 	unsigned long timeout = jiffies + msecs_to_jiffies(1000);
627 	struct i2c_client *client = data;
628 	struct isl1208_state *isl1208 = i2c_get_clientdata(client);
629 	int handled = 0, sr, err;
630 
631 	/*
632 	 * I2C reads get NAK'ed if we read straight away after an interrupt?
633 	 * Using a mdelay/msleep didn't seem to help either, so we work around
634 	 * this by continually trying to read the register for a short time.
635 	 */
636 	while (1) {
637 		sr = isl1208_i2c_get_sr(client);
638 		if (sr >= 0)
639 			break;
640 
641 		if (time_after(jiffies, timeout)) {
642 			dev_err(&client->dev, "%s: reading SR failed\n",
643 				__func__);
644 			return sr;
645 		}
646 	}
647 
648 	if (sr & ISL1208_REG_SR_ALM) {
649 		dev_dbg(&client->dev, "alarm!\n");
650 
651 		rtc_update_irq(isl1208->rtc, 1, RTC_IRQF | RTC_AF);
652 
653 		/* Clear the alarm */
654 		sr &= ~ISL1208_REG_SR_ALM;
655 		sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, sr);
656 		if (sr < 0)
657 			dev_err(&client->dev, "%s: writing SR failed\n",
658 				__func__);
659 		else
660 			handled = 1;
661 
662 		/* Disable the alarm */
663 		err = isl1208_rtc_toggle_alarm(client, 0);
664 		if (err)
665 			return err;
666 	}
667 
668 	if (isl1208->config->has_tamper && (sr & ISL1208_REG_SR_EVT)) {
669 		dev_warn(&client->dev, "event detected");
670 		handled = 1;
671 		if (isl1208->config->has_timestamp)
672 			sysfs_notify(&isl1208->rtc->dev.kobj, NULL,
673 				     dev_attr_timestamp0.attr.name);
674 	}
675 
676 	return handled ? IRQ_HANDLED : IRQ_NONE;
677 }
678 
679 static const struct rtc_class_ops isl1208_rtc_ops = {
680 	.proc = isl1208_rtc_proc,
681 	.read_time = isl1208_rtc_read_time,
682 	.set_time = isl1208_rtc_set_time,
683 	.read_alarm = isl1208_rtc_read_alarm,
684 	.set_alarm = isl1208_rtc_set_alarm,
685 };
686 
687 /* sysfs interface */
688 
689 static ssize_t
isl1208_sysfs_show_atrim(struct device * dev,struct device_attribute * attr,char * buf)690 isl1208_sysfs_show_atrim(struct device *dev,
691 			 struct device_attribute *attr, char *buf)
692 {
693 	int atr = isl1208_i2c_get_atr(to_i2c_client(dev->parent));
694 	if (atr < 0)
695 		return atr;
696 
697 	return sprintf(buf, "%d.%.2d pF\n", atr >> 2, (atr & 0x3) * 25);
698 }
699 
700 static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL);
701 
702 static ssize_t
isl1208_sysfs_show_dtrim(struct device * dev,struct device_attribute * attr,char * buf)703 isl1208_sysfs_show_dtrim(struct device *dev,
704 			 struct device_attribute *attr, char *buf)
705 {
706 	int dtr = isl1208_i2c_get_dtr(to_i2c_client(dev->parent));
707 	if (dtr < 0)
708 		return dtr;
709 
710 	return sprintf(buf, "%d ppm\n", dtr - 100);
711 }
712 
713 static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL);
714 
715 static ssize_t
isl1208_sysfs_show_usr(struct device * dev,struct device_attribute * attr,char * buf)716 isl1208_sysfs_show_usr(struct device *dev,
717 		       struct device_attribute *attr, char *buf)
718 {
719 	int usr = isl1208_i2c_get_usr(to_i2c_client(dev->parent));
720 	if (usr < 0)
721 		return usr;
722 
723 	return sprintf(buf, "0x%.4x\n", usr);
724 }
725 
726 static ssize_t
isl1208_sysfs_store_usr(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)727 isl1208_sysfs_store_usr(struct device *dev,
728 			struct device_attribute *attr,
729 			const char *buf, size_t count)
730 {
731 	int usr = -1;
732 
733 	if (buf[0] == '0' && (buf[1] == 'x' || buf[1] == 'X')) {
734 		if (sscanf(buf, "%x", &usr) != 1)
735 			return -EINVAL;
736 	} else {
737 		if (sscanf(buf, "%d", &usr) != 1)
738 			return -EINVAL;
739 	}
740 
741 	if (usr < 0 || usr > 0xffff)
742 		return -EINVAL;
743 
744 	if (isl1208_i2c_set_usr(to_i2c_client(dev->parent), usr))
745 		return -EIO;
746 
747 	return count;
748 }
749 
750 static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr,
751 		   isl1208_sysfs_store_usr);
752 
753 static struct attribute *isl1208_rtc_attrs[] = {
754 	&dev_attr_atrim.attr,
755 	&dev_attr_dtrim.attr,
756 	&dev_attr_usr.attr,
757 	NULL
758 };
759 
760 static const struct attribute_group isl1208_rtc_sysfs_files = {
761 	.attrs	= isl1208_rtc_attrs,
762 };
763 
764 static struct attribute *isl1219_rtc_attrs[] = {
765 	&dev_attr_timestamp0.attr,
766 	NULL
767 };
768 
769 static const struct attribute_group isl1219_rtc_sysfs_files = {
770 	.attrs	= isl1219_rtc_attrs,
771 };
772 
isl1208_nvmem_read(void * priv,unsigned int off,void * buf,size_t count)773 static int isl1208_nvmem_read(void *priv, unsigned int off, void *buf,
774 			      size_t count)
775 {
776 	struct isl1208_state *isl1208 = priv;
777 	struct i2c_client *client = to_i2c_client(isl1208->rtc->dev.parent);
778 
779 	/* nvmem sanitizes offset/count for us, but count==0 is possible */
780 	if (!count)
781 		return count;
782 
783 	return isl1208_i2c_read_regs(client, ISL1208_REG_USR1 + off, buf,
784 				    count);
785 }
786 
isl1208_nvmem_write(void * priv,unsigned int off,void * buf,size_t count)787 static int isl1208_nvmem_write(void *priv, unsigned int off, void *buf,
788 			       size_t count)
789 {
790 	struct isl1208_state *isl1208 = priv;
791 	struct i2c_client *client = to_i2c_client(isl1208->rtc->dev.parent);
792 
793 	/* nvmem sanitizes off/count for us, but count==0 is possible */
794 	if (!count)
795 		return count;
796 
797 	return isl1208_i2c_set_regs(client, ISL1208_REG_USR1 + off, buf,
798 				   count);
799 }
800 
801 static const struct nvmem_config isl1208_nvmem_config = {
802 	.name = "isl1208_nvram",
803 	.word_size = 1,
804 	.stride = 1,
805 	/* .size from chip specific config */
806 	.reg_read = isl1208_nvmem_read,
807 	.reg_write = isl1208_nvmem_write,
808 };
809 
isl1208_setup_irq(struct i2c_client * client,int irq)810 static int isl1208_setup_irq(struct i2c_client *client, int irq)
811 {
812 	int rc = devm_request_threaded_irq(&client->dev, irq, NULL,
813 					isl1208_rtc_interrupt,
814 					IRQF_SHARED | IRQF_ONESHOT,
815 					isl1208_driver.driver.name,
816 					client);
817 	if (!rc) {
818 		device_init_wakeup(&client->dev, 1);
819 		enable_irq_wake(irq);
820 	} else {
821 		dev_err(&client->dev,
822 			"Unable to request irq %d, no alarm support\n",
823 			irq);
824 	}
825 	return rc;
826 }
827 
828 static int
isl1208_clk_present(struct i2c_client * client,const char * name)829 isl1208_clk_present(struct i2c_client *client, const char *name)
830 {
831 	struct clk *clk;
832 
833 	clk = devm_clk_get_optional(&client->dev, name);
834 	if (IS_ERR(clk))
835 		return PTR_ERR(clk);
836 
837 	return !!clk;
838 }
839 
840 static int
isl1208_probe(struct i2c_client * client)841 isl1208_probe(struct i2c_client *client)
842 {
843 	struct isl1208_state *isl1208;
844 	int evdet_irq = -1;
845 	int xtosb_val = 0;
846 	int rc = 0;
847 	int sr;
848 
849 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
850 		return -ENODEV;
851 
852 	if (isl1208_i2c_validate_client(client) < 0)
853 		return -ENODEV;
854 
855 	/* Allocate driver state, point i2c client data to it */
856 	isl1208 = devm_kzalloc(&client->dev, sizeof(*isl1208), GFP_KERNEL);
857 	if (!isl1208)
858 		return -ENOMEM;
859 	i2c_set_clientdata(client, isl1208);
860 
861 	/* Determine which chip we have */
862 	isl1208->config = i2c_get_match_data(client);
863 	if (!isl1208->config)
864 		return -ENODEV;
865 
866 	rc = isl1208_clk_present(client, "xin");
867 	if (rc < 0)
868 		return rc;
869 
870 	if (!rc) {
871 		rc = isl1208_clk_present(client, "clkin");
872 		if (rc < 0)
873 			return rc;
874 
875 		if (rc)
876 			xtosb_val = 1;
877 	}
878 
879 	isl1208->rtc = devm_rtc_allocate_device(&client->dev);
880 	if (IS_ERR(isl1208->rtc))
881 		return PTR_ERR(isl1208->rtc);
882 
883 	isl1208->rtc->ops = &isl1208_rtc_ops;
884 
885 	/* Setup nvmem configuration in driver state struct */
886 	isl1208->nvmem_config = isl1208_nvmem_config;
887 	isl1208->nvmem_config.size = isl1208->config->nvmem_length;
888 	isl1208->nvmem_config.priv = isl1208;
889 
890 	sr = isl1208_i2c_get_sr(client);
891 	if (sr < 0) {
892 		dev_err(&client->dev, "reading status failed\n");
893 		return sr;
894 	}
895 
896 	if (isl1208->config->has_inverted_osc_bit)
897 		xtosb_val = !xtosb_val;
898 
899 	rc = isl1208_set_xtoscb(client, sr, xtosb_val);
900 	if (rc)
901 		return rc;
902 
903 	if (sr & ISL1208_REG_SR_RTCF)
904 		dev_warn(&client->dev, "rtc power failure detected, "
905 			 "please set clock.\n");
906 
907 	if (isl1208->config->has_tamper) {
908 		struct device_node *np = client->dev.of_node;
909 		u32 evienb;
910 
911 		rc = i2c_smbus_read_byte_data(client, ISL1219_REG_EV);
912 		if (rc < 0) {
913 			dev_err(&client->dev, "failed to read EV reg\n");
914 			return rc;
915 		}
916 		rc |= ISL1219_REG_EV_EVEN;
917 		if (!of_property_read_u32(np, "isil,ev-evienb", &evienb)) {
918 			if (evienb)
919 				rc |= ISL1219_REG_EV_EVIENB;
920 			else
921 				rc &= ~ISL1219_REG_EV_EVIENB;
922 		}
923 		rc = i2c_smbus_write_byte_data(client, ISL1219_REG_EV, rc);
924 		if (rc < 0) {
925 			dev_err(&client->dev, "could not enable tamper detection\n");
926 			return rc;
927 		}
928 		evdet_irq = of_irq_get_byname(np, "evdet");
929 	}
930 	if (isl1208->config->has_timestamp) {
931 		rc = rtc_add_group(isl1208->rtc, &isl1219_rtc_sysfs_files);
932 		if (rc)
933 			return rc;
934 	}
935 
936 	rc = rtc_add_group(isl1208->rtc, &isl1208_rtc_sysfs_files);
937 	if (rc)
938 		return rc;
939 
940 	if (client->irq > 0) {
941 		rc = isl1208_setup_irq(client, client->irq);
942 		if (rc)
943 			return rc;
944 	} else {
945 		clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, isl1208->rtc->features);
946 	}
947 
948 	if (evdet_irq > 0 && evdet_irq != client->irq)
949 		rc = isl1208_setup_irq(client, evdet_irq);
950 	if (rc)
951 		return rc;
952 
953 	rc = devm_rtc_nvmem_register(isl1208->rtc, &isl1208->nvmem_config);
954 	if (rc)
955 		return rc;
956 
957 	return devm_rtc_register_device(isl1208->rtc);
958 }
959 
960 static struct i2c_driver isl1208_driver = {
961 	.driver = {
962 		.name = "rtc-isl1208",
963 		.of_match_table = of_match_ptr(isl1208_of_match),
964 	},
965 	.probe = isl1208_probe,
966 	.id_table = isl1208_id,
967 };
968 
969 module_i2c_driver(isl1208_driver);
970 
971 MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>");
972 MODULE_DESCRIPTION("Intersil ISL1208 RTC driver");
973 MODULE_LICENSE("GPL");
974