1 /* rtc-ds1343.c
2  *
3  * Driver for Dallas Semiconductor DS1343 Low Current, SPI Compatible
4  * Real Time Clock
5  *
6  * Author : Raghavendra Chandra Ganiga <ravi23ganiga@gmail.com>
7  *	    Ankur Srivastava <sankurece@gmail.com> : DS1343 Nvram Support
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  *
13  */
14 
15 #include <linux/init.h>
16 #include <linux/module.h>
17 #include <linux/interrupt.h>
18 #include <linux/device.h>
19 #include <linux/spi/spi.h>
20 #include <linux/regmap.h>
21 #include <linux/rtc.h>
22 #include <linux/bcd.h>
23 #include <linux/pm.h>
24 #include <linux/pm_wakeirq.h>
25 #include <linux/slab.h>
26 
27 #define DALLAS_MAXIM_DS1343	0
28 #define DALLAS_MAXIM_DS1344	1
29 
30 /* RTC DS1343 Registers */
31 #define DS1343_SECONDS_REG	0x00
32 #define DS1343_MINUTES_REG	0x01
33 #define DS1343_HOURS_REG	0x02
34 #define DS1343_DAY_REG		0x03
35 #define DS1343_DATE_REG		0x04
36 #define DS1343_MONTH_REG	0x05
37 #define DS1343_YEAR_REG		0x06
38 #define DS1343_ALM0_SEC_REG	0x07
39 #define DS1343_ALM0_MIN_REG	0x08
40 #define DS1343_ALM0_HOUR_REG	0x09
41 #define DS1343_ALM0_DAY_REG	0x0A
42 #define DS1343_ALM1_SEC_REG	0x0B
43 #define DS1343_ALM1_MIN_REG	0x0C
44 #define DS1343_ALM1_HOUR_REG	0x0D
45 #define DS1343_ALM1_DAY_REG	0x0E
46 #define DS1343_CONTROL_REG	0x0F
47 #define DS1343_STATUS_REG	0x10
48 #define DS1343_TRICKLE_REG	0x11
49 #define DS1343_NVRAM		0x20
50 
51 #define DS1343_NVRAM_LEN	96
52 
53 /* DS1343 Control Registers bits */
54 #define DS1343_EOSC		0x80
55 #define DS1343_DOSF		0x20
56 #define DS1343_EGFIL		0x10
57 #define DS1343_SQW		0x08
58 #define DS1343_INTCN		0x04
59 #define DS1343_A1IE		0x02
60 #define DS1343_A0IE		0x01
61 
62 /* DS1343 Status Registers bits */
63 #define DS1343_OSF		0x80
64 #define DS1343_IRQF1		0x02
65 #define DS1343_IRQF0		0x01
66 
67 /* DS1343 Trickle Charger Registers bits */
68 #define DS1343_TRICKLE_MAGIC	0xa0
69 #define DS1343_TRICKLE_DS1	0x08
70 #define DS1343_TRICKLE_1K	0x01
71 #define DS1343_TRICKLE_2K	0x02
72 #define DS1343_TRICKLE_4K	0x03
73 
74 static const struct spi_device_id ds1343_id[] = {
75 	{ "ds1343", DALLAS_MAXIM_DS1343 },
76 	{ "ds1344", DALLAS_MAXIM_DS1344 },
77 	{ }
78 };
79 MODULE_DEVICE_TABLE(spi, ds1343_id);
80 
81 struct ds1343_priv {
82 	struct spi_device *spi;
83 	struct rtc_device *rtc;
84 	struct regmap *map;
85 	struct mutex mutex;
86 	unsigned int irqen;
87 	int irq;
88 	int alarm_sec;
89 	int alarm_min;
90 	int alarm_hour;
91 	int alarm_mday;
92 };
93 
ds1343_ioctl(struct device * dev,unsigned int cmd,unsigned long arg)94 static int ds1343_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
95 {
96 	switch (cmd) {
97 #ifdef RTC_SET_CHARGE
98 	case RTC_SET_CHARGE:
99 	{
100 		int val;
101 
102 		if (copy_from_user(&val, (int __user *)arg, sizeof(int)))
103 			return -EFAULT;
104 
105 		return regmap_write(priv->map, DS1343_TRICKLE_REG, val);
106 	}
107 	break;
108 #endif
109 	}
110 
111 	return -ENOIOCTLCMD;
112 }
113 
ds1343_show_glitchfilter(struct device * dev,struct device_attribute * attr,char * buf)114 static ssize_t ds1343_show_glitchfilter(struct device *dev,
115 				struct device_attribute *attr, char *buf)
116 {
117 	struct ds1343_priv *priv = dev_get_drvdata(dev);
118 	int glitch_filt_status, data;
119 
120 	regmap_read(priv->map, DS1343_CONTROL_REG, &data);
121 
122 	glitch_filt_status = !!(data & DS1343_EGFIL);
123 
124 	if (glitch_filt_status)
125 		return sprintf(buf, "enabled\n");
126 	else
127 		return sprintf(buf, "disabled\n");
128 }
129 
ds1343_store_glitchfilter(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)130 static ssize_t ds1343_store_glitchfilter(struct device *dev,
131 					struct device_attribute *attr,
132 					const char *buf, size_t count)
133 {
134 	struct ds1343_priv *priv = dev_get_drvdata(dev);
135 	int data;
136 
137 	regmap_read(priv->map, DS1343_CONTROL_REG, &data);
138 
139 	if (strncmp(buf, "enabled", 7) == 0)
140 		data |= DS1343_EGFIL;
141 
142 	else if (strncmp(buf, "disabled", 8) == 0)
143 		data &= ~(DS1343_EGFIL);
144 
145 	else
146 		return -EINVAL;
147 
148 	regmap_write(priv->map, DS1343_CONTROL_REG, data);
149 
150 	return count;
151 }
152 
153 static DEVICE_ATTR(glitch_filter, S_IRUGO | S_IWUSR, ds1343_show_glitchfilter,
154 			ds1343_store_glitchfilter);
155 
ds1343_nvram_write(void * priv,unsigned int off,void * val,size_t bytes)156 static int ds1343_nvram_write(void *priv, unsigned int off, void *val,
157 			      size_t bytes)
158 {
159 	struct ds1343_priv *ds1343 = priv;
160 
161 	return regmap_bulk_write(ds1343->map, DS1343_NVRAM + off, val, bytes);
162 }
163 
ds1343_nvram_read(void * priv,unsigned int off,void * val,size_t bytes)164 static int ds1343_nvram_read(void *priv, unsigned int off, void *val,
165 			     size_t bytes)
166 {
167 	struct ds1343_priv *ds1343 = priv;
168 
169 	return regmap_bulk_read(ds1343->map, DS1343_NVRAM + off, val, bytes);
170 }
171 
ds1343_show_tricklecharger(struct device * dev,struct device_attribute * attr,char * buf)172 static ssize_t ds1343_show_tricklecharger(struct device *dev,
173 				struct device_attribute *attr, char *buf)
174 {
175 	struct ds1343_priv *priv = dev_get_drvdata(dev);
176 	int data;
177 	char *diodes = "disabled", *resistors = " ";
178 
179 	regmap_read(priv->map, DS1343_TRICKLE_REG, &data);
180 
181 	if ((data & 0xf0) == DS1343_TRICKLE_MAGIC) {
182 		switch (data & 0x0c) {
183 		case DS1343_TRICKLE_DS1:
184 			diodes = "one diode,";
185 			break;
186 
187 		default:
188 			diodes = "no diode,";
189 			break;
190 		}
191 
192 		switch (data & 0x03) {
193 		case DS1343_TRICKLE_1K:
194 			resistors = "1k Ohm";
195 			break;
196 
197 		case DS1343_TRICKLE_2K:
198 			resistors = "2k Ohm";
199 			break;
200 
201 		case DS1343_TRICKLE_4K:
202 			resistors = "4k Ohm";
203 			break;
204 
205 		default:
206 			diodes = "disabled";
207 			break;
208 		}
209 	}
210 
211 	return sprintf(buf, "%s %s\n", diodes, resistors);
212 }
213 
214 static DEVICE_ATTR(trickle_charger, S_IRUGO, ds1343_show_tricklecharger, NULL);
215 
ds1343_sysfs_register(struct device * dev)216 static int ds1343_sysfs_register(struct device *dev)
217 {
218 	int err;
219 
220 	err = device_create_file(dev, &dev_attr_glitch_filter);
221 	if (err)
222 		return err;
223 
224 	err = device_create_file(dev, &dev_attr_trickle_charger);
225 	if (!err)
226 		return 0;
227 
228 	device_remove_file(dev, &dev_attr_glitch_filter);
229 
230 	return err;
231 }
232 
ds1343_sysfs_unregister(struct device * dev)233 static void ds1343_sysfs_unregister(struct device *dev)
234 {
235 	device_remove_file(dev, &dev_attr_glitch_filter);
236 	device_remove_file(dev, &dev_attr_trickle_charger);
237 }
238 
ds1343_read_time(struct device * dev,struct rtc_time * dt)239 static int ds1343_read_time(struct device *dev, struct rtc_time *dt)
240 {
241 	struct ds1343_priv *priv = dev_get_drvdata(dev);
242 	unsigned char buf[7];
243 	int res;
244 
245 	res = regmap_bulk_read(priv->map, DS1343_SECONDS_REG, buf, 7);
246 	if (res)
247 		return res;
248 
249 	dt->tm_sec	= bcd2bin(buf[0]);
250 	dt->tm_min	= bcd2bin(buf[1]);
251 	dt->tm_hour	= bcd2bin(buf[2] & 0x3F);
252 	dt->tm_wday	= bcd2bin(buf[3]) - 1;
253 	dt->tm_mday	= bcd2bin(buf[4]);
254 	dt->tm_mon	= bcd2bin(buf[5] & 0x1F) - 1;
255 	dt->tm_year	= bcd2bin(buf[6]) + 100; /* year offset from 1900 */
256 
257 	return 0;
258 }
259 
ds1343_set_time(struct device * dev,struct rtc_time * dt)260 static int ds1343_set_time(struct device *dev, struct rtc_time *dt)
261 {
262 	struct ds1343_priv *priv = dev_get_drvdata(dev);
263 	int res;
264 
265 	res = regmap_write(priv->map, DS1343_SECONDS_REG,
266 				bin2bcd(dt->tm_sec));
267 	if (res)
268 		return res;
269 
270 	res = regmap_write(priv->map, DS1343_MINUTES_REG,
271 				bin2bcd(dt->tm_min));
272 	if (res)
273 		return res;
274 
275 	res = regmap_write(priv->map, DS1343_HOURS_REG,
276 				bin2bcd(dt->tm_hour) & 0x3F);
277 	if (res)
278 		return res;
279 
280 	res = regmap_write(priv->map, DS1343_DAY_REG,
281 				bin2bcd(dt->tm_wday + 1));
282 	if (res)
283 		return res;
284 
285 	res = regmap_write(priv->map, DS1343_DATE_REG,
286 				bin2bcd(dt->tm_mday));
287 	if (res)
288 		return res;
289 
290 	res = regmap_write(priv->map, DS1343_MONTH_REG,
291 				bin2bcd(dt->tm_mon + 1));
292 	if (res)
293 		return res;
294 
295 	dt->tm_year %= 100;
296 
297 	res = regmap_write(priv->map, DS1343_YEAR_REG,
298 				bin2bcd(dt->tm_year));
299 	if (res)
300 		return res;
301 
302 	return 0;
303 }
304 
ds1343_update_alarm(struct device * dev)305 static int ds1343_update_alarm(struct device *dev)
306 {
307 	struct ds1343_priv *priv = dev_get_drvdata(dev);
308 	unsigned int control, stat;
309 	unsigned char buf[4];
310 	int res = 0;
311 
312 	res = regmap_read(priv->map, DS1343_CONTROL_REG, &control);
313 	if (res)
314 		return res;
315 
316 	res = regmap_read(priv->map, DS1343_STATUS_REG, &stat);
317 	if (res)
318 		return res;
319 
320 	control &= ~(DS1343_A0IE);
321 	stat &= ~(DS1343_IRQF0);
322 
323 	res = regmap_write(priv->map, DS1343_CONTROL_REG, control);
324 	if (res)
325 		return res;
326 
327 	res = regmap_write(priv->map, DS1343_STATUS_REG, stat);
328 	if (res)
329 		return res;
330 
331 	buf[0] = priv->alarm_sec < 0 || (priv->irqen & RTC_UF) ?
332 		0x80 : bin2bcd(priv->alarm_sec) & 0x7F;
333 	buf[1] = priv->alarm_min < 0 || (priv->irqen & RTC_UF) ?
334 		0x80 : bin2bcd(priv->alarm_min) & 0x7F;
335 	buf[2] = priv->alarm_hour < 0 || (priv->irqen & RTC_UF) ?
336 		0x80 : bin2bcd(priv->alarm_hour) & 0x3F;
337 	buf[3] = priv->alarm_mday < 0 || (priv->irqen & RTC_UF) ?
338 		0x80 : bin2bcd(priv->alarm_mday) & 0x7F;
339 
340 	res = regmap_bulk_write(priv->map, DS1343_ALM0_SEC_REG, buf, 4);
341 	if (res)
342 		return res;
343 
344 	if (priv->irqen) {
345 		control |= DS1343_A0IE;
346 		res = regmap_write(priv->map, DS1343_CONTROL_REG, control);
347 	}
348 
349 	return res;
350 }
351 
ds1343_read_alarm(struct device * dev,struct rtc_wkalrm * alarm)352 static int ds1343_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
353 {
354 	struct ds1343_priv *priv = dev_get_drvdata(dev);
355 	int res = 0;
356 	unsigned int stat;
357 
358 	if (priv->irq <= 0)
359 		return -EINVAL;
360 
361 	mutex_lock(&priv->mutex);
362 
363 	res = regmap_read(priv->map, DS1343_STATUS_REG, &stat);
364 	if (res)
365 		goto out;
366 
367 	alarm->enabled = !!(priv->irqen & RTC_AF);
368 	alarm->pending = !!(stat & DS1343_IRQF0);
369 
370 	alarm->time.tm_sec = priv->alarm_sec < 0 ? 0 : priv->alarm_sec;
371 	alarm->time.tm_min = priv->alarm_min < 0 ? 0 : priv->alarm_min;
372 	alarm->time.tm_hour = priv->alarm_hour < 0 ? 0 : priv->alarm_hour;
373 	alarm->time.tm_mday = priv->alarm_mday < 0 ? 0 : priv->alarm_mday;
374 
375 out:
376 	mutex_unlock(&priv->mutex);
377 	return res;
378 }
379 
ds1343_set_alarm(struct device * dev,struct rtc_wkalrm * alarm)380 static int ds1343_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
381 {
382 	struct ds1343_priv *priv = dev_get_drvdata(dev);
383 	int res = 0;
384 
385 	if (priv->irq <= 0)
386 		return -EINVAL;
387 
388 	mutex_lock(&priv->mutex);
389 
390 	priv->alarm_sec = alarm->time.tm_sec;
391 	priv->alarm_min = alarm->time.tm_min;
392 	priv->alarm_hour = alarm->time.tm_hour;
393 	priv->alarm_mday = alarm->time.tm_mday;
394 
395 	if (alarm->enabled)
396 		priv->irqen |= RTC_AF;
397 
398 	res = ds1343_update_alarm(dev);
399 
400 	mutex_unlock(&priv->mutex);
401 
402 	return res;
403 }
404 
ds1343_alarm_irq_enable(struct device * dev,unsigned int enabled)405 static int ds1343_alarm_irq_enable(struct device *dev, unsigned int enabled)
406 {
407 	struct ds1343_priv *priv = dev_get_drvdata(dev);
408 	int res = 0;
409 
410 	if (priv->irq <= 0)
411 		return -EINVAL;
412 
413 	mutex_lock(&priv->mutex);
414 
415 	if (enabled)
416 		priv->irqen |= RTC_AF;
417 	else
418 		priv->irqen &= ~RTC_AF;
419 
420 	res = ds1343_update_alarm(dev);
421 
422 	mutex_unlock(&priv->mutex);
423 
424 	return res;
425 }
426 
ds1343_thread(int irq,void * dev_id)427 static irqreturn_t ds1343_thread(int irq, void *dev_id)
428 {
429 	struct ds1343_priv *priv = dev_id;
430 	unsigned int stat, control;
431 	int res = 0;
432 
433 	mutex_lock(&priv->mutex);
434 
435 	res = regmap_read(priv->map, DS1343_STATUS_REG, &stat);
436 	if (res)
437 		goto out;
438 
439 	if (stat & DS1343_IRQF0) {
440 		stat &= ~DS1343_IRQF0;
441 		regmap_write(priv->map, DS1343_STATUS_REG, stat);
442 
443 		res = regmap_read(priv->map, DS1343_CONTROL_REG, &control);
444 		if (res)
445 			goto out;
446 
447 		control &= ~DS1343_A0IE;
448 		regmap_write(priv->map, DS1343_CONTROL_REG, control);
449 
450 		rtc_update_irq(priv->rtc, 1, RTC_AF | RTC_IRQF);
451 	}
452 
453 out:
454 	mutex_unlock(&priv->mutex);
455 	return IRQ_HANDLED;
456 }
457 
458 static const struct rtc_class_ops ds1343_rtc_ops = {
459 	.ioctl		= ds1343_ioctl,
460 	.read_time	= ds1343_read_time,
461 	.set_time	= ds1343_set_time,
462 	.read_alarm	= ds1343_read_alarm,
463 	.set_alarm	= ds1343_set_alarm,
464 	.alarm_irq_enable = ds1343_alarm_irq_enable,
465 };
466 
ds1343_probe(struct spi_device * spi)467 static int ds1343_probe(struct spi_device *spi)
468 {
469 	struct ds1343_priv *priv;
470 	struct regmap_config config = { .reg_bits = 8, .val_bits = 8,
471 					.write_flag_mask = 0x80, };
472 	unsigned int data;
473 	int res;
474 	struct nvmem_config nvmem_cfg = {
475 		.name = "ds1343-",
476 		.word_size = 1,
477 		.stride = 1,
478 		.size = DS1343_NVRAM_LEN,
479 		.reg_read = ds1343_nvram_read,
480 		.reg_write = ds1343_nvram_write,
481 	};
482 
483 	priv = devm_kzalloc(&spi->dev, sizeof(struct ds1343_priv), GFP_KERNEL);
484 	if (!priv)
485 		return -ENOMEM;
486 
487 	priv->spi = spi;
488 	mutex_init(&priv->mutex);
489 
490 	/* RTC DS1347 works in spi mode 3 and
491 	 * its chip select is active high
492 	 */
493 	spi->mode = SPI_MODE_3 | SPI_CS_HIGH;
494 	spi->bits_per_word = 8;
495 	res = spi_setup(spi);
496 	if (res)
497 		return res;
498 
499 	spi_set_drvdata(spi, priv);
500 
501 	priv->map = devm_regmap_init_spi(spi, &config);
502 
503 	if (IS_ERR(priv->map)) {
504 		dev_err(&spi->dev, "spi regmap init failed for rtc ds1343\n");
505 		return PTR_ERR(priv->map);
506 	}
507 
508 	res = regmap_read(priv->map, DS1343_SECONDS_REG, &data);
509 	if (res)
510 		return res;
511 
512 	regmap_read(priv->map, DS1343_CONTROL_REG, &data);
513 	data |= DS1343_INTCN;
514 	data &= ~(DS1343_EOSC | DS1343_A1IE | DS1343_A0IE);
515 	regmap_write(priv->map, DS1343_CONTROL_REG, data);
516 
517 	regmap_read(priv->map, DS1343_STATUS_REG, &data);
518 	data &= ~(DS1343_OSF | DS1343_IRQF1 | DS1343_IRQF0);
519 	regmap_write(priv->map, DS1343_STATUS_REG, data);
520 
521 	priv->rtc = devm_rtc_allocate_device(&spi->dev);
522 	if (IS_ERR(priv->rtc))
523 		return PTR_ERR(priv->rtc);
524 
525 	priv->rtc->nvram_old_abi = true;
526 	priv->rtc->ops = &ds1343_rtc_ops;
527 
528 	res = rtc_register_device(priv->rtc);
529 	if (res)
530 		return res;
531 
532 	nvmem_cfg.priv = priv;
533 	rtc_nvmem_register(priv->rtc, &nvmem_cfg);
534 
535 	priv->irq = spi->irq;
536 
537 	if (priv->irq >= 0) {
538 		res = devm_request_threaded_irq(&spi->dev, spi->irq, NULL,
539 						ds1343_thread, IRQF_ONESHOT,
540 						"ds1343", priv);
541 		if (res) {
542 			priv->irq = -1;
543 			dev_err(&spi->dev,
544 				"unable to request irq for rtc ds1343\n");
545 		} else {
546 			device_init_wakeup(&spi->dev, true);
547 			dev_pm_set_wake_irq(&spi->dev, spi->irq);
548 		}
549 	}
550 
551 	res = ds1343_sysfs_register(&spi->dev);
552 	if (res)
553 		dev_err(&spi->dev,
554 			"unable to create sysfs entries for rtc ds1343\n");
555 
556 	return 0;
557 }
558 
ds1343_remove(struct spi_device * spi)559 static int ds1343_remove(struct spi_device *spi)
560 {
561 	struct ds1343_priv *priv = spi_get_drvdata(spi);
562 
563 	if (spi->irq) {
564 		mutex_lock(&priv->mutex);
565 		priv->irqen &= ~RTC_AF;
566 		mutex_unlock(&priv->mutex);
567 
568 		dev_pm_clear_wake_irq(&spi->dev);
569 		device_init_wakeup(&spi->dev, false);
570 		devm_free_irq(&spi->dev, spi->irq, priv);
571 	}
572 
573 	spi_set_drvdata(spi, NULL);
574 
575 	ds1343_sysfs_unregister(&spi->dev);
576 
577 	return 0;
578 }
579 
580 #ifdef CONFIG_PM_SLEEP
581 
ds1343_suspend(struct device * dev)582 static int ds1343_suspend(struct device *dev)
583 {
584 	struct spi_device *spi = to_spi_device(dev);
585 
586 	if (spi->irq >= 0 && device_may_wakeup(dev))
587 		enable_irq_wake(spi->irq);
588 
589 	return 0;
590 }
591 
ds1343_resume(struct device * dev)592 static int ds1343_resume(struct device *dev)
593 {
594 	struct spi_device *spi = to_spi_device(dev);
595 
596 	if (spi->irq >= 0 && device_may_wakeup(dev))
597 		disable_irq_wake(spi->irq);
598 
599 	return 0;
600 }
601 
602 #endif
603 
604 static SIMPLE_DEV_PM_OPS(ds1343_pm, ds1343_suspend, ds1343_resume);
605 
606 static struct spi_driver ds1343_driver = {
607 	.driver = {
608 		.name = "ds1343",
609 		.pm = &ds1343_pm,
610 	},
611 	.probe = ds1343_probe,
612 	.remove = ds1343_remove,
613 	.id_table = ds1343_id,
614 };
615 
616 module_spi_driver(ds1343_driver);
617 
618 MODULE_DESCRIPTION("DS1343 RTC SPI Driver");
619 MODULE_AUTHOR("Raghavendra Chandra Ganiga <ravi23ganiga@gmail.com>,"
620 		"Ankur Srivastava <sankurece@gmail.com>");
621 MODULE_LICENSE("GPL v2");
622