Loading...
1/*
2 * An I2C and SPI driver for the NXP PCF2127/29 RTC
3 * Copyright 2013 Til-Technologies
4 *
5 * Author: Renaud Cerrato <r.cerrato@til-technologies.fr>
6 *
7 * based on the other drivers in this same directory.
8 *
9 * Datasheet: http://cache.nxp.com/documents/data_sheet/PCF2127.pdf
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 */
15
16#include <linux/i2c.h>
17#include <linux/spi/spi.h>
18#include <linux/bcd.h>
19#include <linux/rtc.h>
20#include <linux/slab.h>
21#include <linux/module.h>
22#include <linux/of.h>
23#include <linux/regmap.h>
24
25#define PCF2127_REG_CTRL1 (0x00) /* Control Register 1 */
26#define PCF2127_REG_CTRL2 (0x01) /* Control Register 2 */
27
28#define PCF2127_REG_CTRL3 (0x02) /* Control Register 3 */
29#define PCF2127_REG_CTRL3_BLF BIT(2)
30
31#define PCF2127_REG_SC (0x03) /* datetime */
32#define PCF2127_REG_MN (0x04)
33#define PCF2127_REG_HR (0x05)
34#define PCF2127_REG_DM (0x06)
35#define PCF2127_REG_DW (0x07)
36#define PCF2127_REG_MO (0x08)
37#define PCF2127_REG_YR (0x09)
38
39#define PCF2127_OSF BIT(7) /* Oscillator Fail flag */
40
41struct pcf2127 {
42 struct rtc_device *rtc;
43 struct regmap *regmap;
44};
45
46/*
47 * In the routines that deal directly with the pcf2127 hardware, we use
48 * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
49 */
50static int pcf2127_rtc_read_time(struct device *dev, struct rtc_time *tm)
51{
52 struct pcf2127 *pcf2127 = dev_get_drvdata(dev);
53 unsigned char buf[10];
54 int ret;
55 int i;
56
57 for (i = 0; i <= PCF2127_REG_CTRL3; i++) {
58 ret = regmap_read(pcf2127->regmap, PCF2127_REG_CTRL1 + i,
59 (unsigned int *)(buf + i));
60 if (ret) {
61 dev_err(dev, "%s: read error\n", __func__);
62 return ret;
63 }
64 }
65
66 ret = regmap_bulk_read(pcf2127->regmap, PCF2127_REG_SC,
67 (buf + PCF2127_REG_SC),
68 ARRAY_SIZE(buf) - PCF2127_REG_SC);
69 if (ret) {
70 dev_err(dev, "%s: read error\n", __func__);
71 return ret;
72 }
73
74 if (buf[PCF2127_REG_CTRL3] & PCF2127_REG_CTRL3_BLF)
75 dev_info(dev,
76 "low voltage detected, check/replace RTC battery.\n");
77
78 if (buf[PCF2127_REG_SC] & PCF2127_OSF) {
79 /*
80 * no need clear the flag here,
81 * it will be cleared once the new date is saved
82 */
83 dev_warn(dev,
84 "oscillator stop detected, date/time is not reliable\n");
85 return -EINVAL;
86 }
87
88 dev_dbg(dev,
89 "%s: raw data is cr1=%02x, cr2=%02x, cr3=%02x, "
90 "sec=%02x, min=%02x, hr=%02x, "
91 "mday=%02x, wday=%02x, mon=%02x, year=%02x\n",
92 __func__,
93 buf[0], buf[1], buf[2],
94 buf[3], buf[4], buf[5],
95 buf[6], buf[7], buf[8], buf[9]);
96
97
98 tm->tm_sec = bcd2bin(buf[PCF2127_REG_SC] & 0x7F);
99 tm->tm_min = bcd2bin(buf[PCF2127_REG_MN] & 0x7F);
100 tm->tm_hour = bcd2bin(buf[PCF2127_REG_HR] & 0x3F); /* rtc hr 0-23 */
101 tm->tm_mday = bcd2bin(buf[PCF2127_REG_DM] & 0x3F);
102 tm->tm_wday = buf[PCF2127_REG_DW] & 0x07;
103 tm->tm_mon = bcd2bin(buf[PCF2127_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */
104 tm->tm_year = bcd2bin(buf[PCF2127_REG_YR]);
105 if (tm->tm_year < 70)
106 tm->tm_year += 100; /* assume we are in 1970...2069 */
107
108 dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
109 "mday=%d, mon=%d, year=%d, wday=%d\n",
110 __func__,
111 tm->tm_sec, tm->tm_min, tm->tm_hour,
112 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
113
114 return 0;
115}
116
117static int pcf2127_rtc_set_time(struct device *dev, struct rtc_time *tm)
118{
119 struct pcf2127 *pcf2127 = dev_get_drvdata(dev);
120 unsigned char buf[7];
121 int i = 0, err;
122
123 dev_dbg(dev, "%s: secs=%d, mins=%d, hours=%d, "
124 "mday=%d, mon=%d, year=%d, wday=%d\n",
125 __func__,
126 tm->tm_sec, tm->tm_min, tm->tm_hour,
127 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
128
129 /* hours, minutes and seconds */
130 buf[i++] = bin2bcd(tm->tm_sec); /* this will also clear OSF flag */
131 buf[i++] = bin2bcd(tm->tm_min);
132 buf[i++] = bin2bcd(tm->tm_hour);
133 buf[i++] = bin2bcd(tm->tm_mday);
134 buf[i++] = tm->tm_wday & 0x07;
135
136 /* month, 1 - 12 */
137 buf[i++] = bin2bcd(tm->tm_mon + 1);
138
139 /* year */
140 buf[i++] = bin2bcd(tm->tm_year % 100);
141
142 /* write register's data */
143 err = regmap_bulk_write(pcf2127->regmap, PCF2127_REG_SC, buf, i);
144 if (err) {
145 dev_err(dev,
146 "%s: err=%d", __func__, err);
147 return err;
148 }
149
150 return 0;
151}
152
153#ifdef CONFIG_RTC_INTF_DEV
154static int pcf2127_rtc_ioctl(struct device *dev,
155 unsigned int cmd, unsigned long arg)
156{
157 struct pcf2127 *pcf2127 = dev_get_drvdata(dev);
158 int touser;
159 int ret;
160
161 switch (cmd) {
162 case RTC_VL_READ:
163 ret = regmap_read(pcf2127->regmap, PCF2127_REG_CTRL3, &touser);
164 if (ret)
165 return ret;
166
167 touser = touser & PCF2127_REG_CTRL3_BLF ? 1 : 0;
168
169 if (copy_to_user((void __user *)arg, &touser, sizeof(int)))
170 return -EFAULT;
171 return 0;
172 default:
173 return -ENOIOCTLCMD;
174 }
175}
176#else
177#define pcf2127_rtc_ioctl NULL
178#endif
179
180static const struct rtc_class_ops pcf2127_rtc_ops = {
181 .ioctl = pcf2127_rtc_ioctl,
182 .read_time = pcf2127_rtc_read_time,
183 .set_time = pcf2127_rtc_set_time,
184};
185
186static int pcf2127_probe(struct device *dev, struct regmap *regmap,
187 const char *name)
188{
189 struct pcf2127 *pcf2127;
190
191 dev_dbg(dev, "%s\n", __func__);
192
193 pcf2127 = devm_kzalloc(dev, sizeof(*pcf2127), GFP_KERNEL);
194 if (!pcf2127)
195 return -ENOMEM;
196
197 pcf2127->regmap = regmap;
198
199 dev_set_drvdata(dev, pcf2127);
200
201 pcf2127->rtc = devm_rtc_device_register(dev, name, &pcf2127_rtc_ops,
202 THIS_MODULE);
203
204 return PTR_ERR_OR_ZERO(pcf2127->rtc);
205}
206
207#ifdef CONFIG_OF
208static const struct of_device_id pcf2127_of_match[] = {
209 { .compatible = "nxp,pcf2127" },
210 { .compatible = "nxp,pcf2129" },
211 {}
212};
213MODULE_DEVICE_TABLE(of, pcf2127_of_match);
214#endif
215
216#if IS_ENABLED(CONFIG_I2C)
217
218static int pcf2127_i2c_write(void *context, const void *data, size_t count)
219{
220 struct device *dev = context;
221 struct i2c_client *client = to_i2c_client(dev);
222 int ret;
223
224 ret = i2c_master_send(client, data, count);
225 if (ret != count)
226 return ret < 0 ? ret : -EIO;
227
228 return 0;
229}
230
231static int pcf2127_i2c_gather_write(void *context,
232 const void *reg, size_t reg_size,
233 const void *val, size_t val_size)
234{
235 struct device *dev = context;
236 struct i2c_client *client = to_i2c_client(dev);
237 int ret;
238 void *buf;
239
240 if (WARN_ON(reg_size != 1))
241 return -EINVAL;
242
243 buf = kmalloc(val_size + 1, GFP_KERNEL);
244 if (!buf)
245 return -ENOMEM;
246
247 memcpy(buf, reg, 1);
248 memcpy(buf + 1, val, val_size);
249
250 ret = i2c_master_send(client, buf, val_size + 1);
251 if (ret != val_size + 1)
252 return ret < 0 ? ret : -EIO;
253
254 return 0;
255}
256
257static int pcf2127_i2c_read(void *context, const void *reg, size_t reg_size,
258 void *val, size_t val_size)
259{
260 struct device *dev = context;
261 struct i2c_client *client = to_i2c_client(dev);
262 int ret;
263
264 if (WARN_ON(reg_size != 1))
265 return -EINVAL;
266
267 ret = i2c_master_send(client, reg, 1);
268 if (ret != 1)
269 return ret < 0 ? ret : -EIO;
270
271 ret = i2c_master_recv(client, val, val_size);
272 if (ret != val_size)
273 return ret < 0 ? ret : -EIO;
274
275 return 0;
276}
277
278/*
279 * The reason we need this custom regmap_bus instead of using regmap_init_i2c()
280 * is that the STOP condition is required between set register address and
281 * read register data when reading from registers.
282 */
283static const struct regmap_bus pcf2127_i2c_regmap = {
284 .write = pcf2127_i2c_write,
285 .gather_write = pcf2127_i2c_gather_write,
286 .read = pcf2127_i2c_read,
287};
288
289static struct i2c_driver pcf2127_i2c_driver;
290
291static int pcf2127_i2c_probe(struct i2c_client *client,
292 const struct i2c_device_id *id)
293{
294 struct regmap *regmap;
295 static const struct regmap_config config = {
296 .reg_bits = 8,
297 .val_bits = 8,
298 };
299
300 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
301 return -ENODEV;
302
303 regmap = devm_regmap_init(&client->dev, &pcf2127_i2c_regmap,
304 &client->dev, &config);
305 if (IS_ERR(regmap)) {
306 dev_err(&client->dev, "%s: regmap allocation failed: %ld\n",
307 __func__, PTR_ERR(regmap));
308 return PTR_ERR(regmap);
309 }
310
311 return pcf2127_probe(&client->dev, regmap,
312 pcf2127_i2c_driver.driver.name);
313}
314
315static const struct i2c_device_id pcf2127_i2c_id[] = {
316 { "pcf2127", 0 },
317 { "pcf2129", 0 },
318 { }
319};
320MODULE_DEVICE_TABLE(i2c, pcf2127_i2c_id);
321
322static struct i2c_driver pcf2127_i2c_driver = {
323 .driver = {
324 .name = "rtc-pcf2127-i2c",
325 .of_match_table = of_match_ptr(pcf2127_of_match),
326 },
327 .probe = pcf2127_i2c_probe,
328 .id_table = pcf2127_i2c_id,
329};
330
331static int pcf2127_i2c_register_driver(void)
332{
333 return i2c_add_driver(&pcf2127_i2c_driver);
334}
335
336static void pcf2127_i2c_unregister_driver(void)
337{
338 i2c_del_driver(&pcf2127_i2c_driver);
339}
340
341#else
342
343static int pcf2127_i2c_register_driver(void)
344{
345 return 0;
346}
347
348static void pcf2127_i2c_unregister_driver(void)
349{
350}
351
352#endif
353
354#if IS_ENABLED(CONFIG_SPI_MASTER)
355
356static struct spi_driver pcf2127_spi_driver;
357
358static int pcf2127_spi_probe(struct spi_device *spi)
359{
360 static const struct regmap_config config = {
361 .reg_bits = 8,
362 .val_bits = 8,
363 .read_flag_mask = 0xa0,
364 .write_flag_mask = 0x20,
365 };
366 struct regmap *regmap;
367
368 regmap = devm_regmap_init_spi(spi, &config);
369 if (IS_ERR(regmap)) {
370 dev_err(&spi->dev, "%s: regmap allocation failed: %ld\n",
371 __func__, PTR_ERR(regmap));
372 return PTR_ERR(regmap);
373 }
374
375 return pcf2127_probe(&spi->dev, regmap, pcf2127_spi_driver.driver.name);
376}
377
378static const struct spi_device_id pcf2127_spi_id[] = {
379 { "pcf2127", 0 },
380 { "pcf2129", 0 },
381 { }
382};
383MODULE_DEVICE_TABLE(spi, pcf2127_spi_id);
384
385static struct spi_driver pcf2127_spi_driver = {
386 .driver = {
387 .name = "rtc-pcf2127-spi",
388 .of_match_table = of_match_ptr(pcf2127_of_match),
389 },
390 .probe = pcf2127_spi_probe,
391 .id_table = pcf2127_spi_id,
392};
393
394static int pcf2127_spi_register_driver(void)
395{
396 return spi_register_driver(&pcf2127_spi_driver);
397}
398
399static void pcf2127_spi_unregister_driver(void)
400{
401 spi_unregister_driver(&pcf2127_spi_driver);
402}
403
404#else
405
406static int pcf2127_spi_register_driver(void)
407{
408 return 0;
409}
410
411static void pcf2127_spi_unregister_driver(void)
412{
413}
414
415#endif
416
417static int __init pcf2127_init(void)
418{
419 int ret;
420
421 ret = pcf2127_i2c_register_driver();
422 if (ret) {
423 pr_err("Failed to register pcf2127 i2c driver: %d\n", ret);
424 return ret;
425 }
426
427 ret = pcf2127_spi_register_driver();
428 if (ret) {
429 pr_err("Failed to register pcf2127 spi driver: %d\n", ret);
430 pcf2127_i2c_unregister_driver();
431 }
432
433 return ret;
434}
435module_init(pcf2127_init)
436
437static void __exit pcf2127_exit(void)
438{
439 pcf2127_spi_unregister_driver();
440 pcf2127_i2c_unregister_driver();
441}
442module_exit(pcf2127_exit)
443
444MODULE_AUTHOR("Renaud Cerrato <r.cerrato@til-technologies.fr>");
445MODULE_DESCRIPTION("NXP PCF2127/29 RTC driver");
446MODULE_LICENSE("GPL v2");
1/*
2 * An I2C driver for the NXP PCF2127 RTC
3 * Copyright 2013 Til-Technologies
4 *
5 * Author: Renaud Cerrato <r.cerrato@til-technologies.fr>
6 *
7 * based on the other drivers in this same directory.
8 *
9 * http://www.nxp.com/documents/data_sheet/PCF2127AT.pdf
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 */
15
16#include <linux/i2c.h>
17#include <linux/bcd.h>
18#include <linux/rtc.h>
19#include <linux/slab.h>
20#include <linux/module.h>
21#include <linux/of.h>
22
23#define DRV_VERSION "0.0.1"
24
25#define PCF2127_REG_CTRL1 (0x00) /* Control Register 1 */
26#define PCF2127_REG_CTRL2 (0x01) /* Control Register 2 */
27#define PCF2127_REG_CTRL3 (0x02) /* Control Register 3 */
28#define PCF2127_REG_SC (0x03) /* datetime */
29#define PCF2127_REG_MN (0x04)
30#define PCF2127_REG_HR (0x05)
31#define PCF2127_REG_DM (0x06)
32#define PCF2127_REG_DW (0x07)
33#define PCF2127_REG_MO (0x08)
34#define PCF2127_REG_YR (0x09)
35
36static struct i2c_driver pcf2127_driver;
37
38struct pcf2127 {
39 struct rtc_device *rtc;
40 int voltage_low; /* indicates if a low_voltage was detected */
41};
42
43/*
44 * In the routines that deal directly with the pcf2127 hardware, we use
45 * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch.
46 */
47static int pcf2127_get_datetime(struct i2c_client *client, struct rtc_time *tm)
48{
49 struct pcf2127 *pcf2127 = i2c_get_clientdata(client);
50 unsigned char buf[10] = { PCF2127_REG_CTRL1 };
51
52 /* read registers */
53 if (i2c_master_send(client, buf, 1) != 1 ||
54 i2c_master_recv(client, buf, sizeof(buf)) != sizeof(buf)) {
55 dev_err(&client->dev, "%s: read error\n", __func__);
56 return -EIO;
57 }
58
59 if (buf[PCF2127_REG_CTRL3] & 0x04) {
60 pcf2127->voltage_low = 1;
61 dev_info(&client->dev,
62 "low voltage detected, date/time is not reliable.\n");
63 }
64
65 dev_dbg(&client->dev,
66 "%s: raw data is cr1=%02x, cr2=%02x, cr3=%02x, "
67 "sec=%02x, min=%02x, hr=%02x, "
68 "mday=%02x, wday=%02x, mon=%02x, year=%02x\n",
69 __func__,
70 buf[0], buf[1], buf[2],
71 buf[3], buf[4], buf[5],
72 buf[6], buf[7], buf[8], buf[9]);
73
74
75 tm->tm_sec = bcd2bin(buf[PCF2127_REG_SC] & 0x7F);
76 tm->tm_min = bcd2bin(buf[PCF2127_REG_MN] & 0x7F);
77 tm->tm_hour = bcd2bin(buf[PCF2127_REG_HR] & 0x3F); /* rtc hr 0-23 */
78 tm->tm_mday = bcd2bin(buf[PCF2127_REG_DM] & 0x3F);
79 tm->tm_wday = buf[PCF2127_REG_DW] & 0x07;
80 tm->tm_mon = bcd2bin(buf[PCF2127_REG_MO] & 0x1F) - 1; /* rtc mn 1-12 */
81 tm->tm_year = bcd2bin(buf[PCF2127_REG_YR]);
82 if (tm->tm_year < 70)
83 tm->tm_year += 100; /* assume we are in 1970...2069 */
84
85 dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
86 "mday=%d, mon=%d, year=%d, wday=%d\n",
87 __func__,
88 tm->tm_sec, tm->tm_min, tm->tm_hour,
89 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
90
91 /* the clock can give out invalid datetime, but we cannot return
92 * -EINVAL otherwise hwclock will refuse to set the time on bootup.
93 */
94 if (rtc_valid_tm(tm) < 0)
95 dev_err(&client->dev, "retrieved date/time is not valid.\n");
96
97 return 0;
98}
99
100static int pcf2127_set_datetime(struct i2c_client *client, struct rtc_time *tm)
101{
102 unsigned char buf[8];
103 int i = 0, err;
104
105 dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, "
106 "mday=%d, mon=%d, year=%d, wday=%d\n",
107 __func__,
108 tm->tm_sec, tm->tm_min, tm->tm_hour,
109 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
110
111 /* start register address */
112 buf[i++] = PCF2127_REG_SC;
113
114 /* hours, minutes and seconds */
115 buf[i++] = bin2bcd(tm->tm_sec);
116 buf[i++] = bin2bcd(tm->tm_min);
117 buf[i++] = bin2bcd(tm->tm_hour);
118 buf[i++] = bin2bcd(tm->tm_mday);
119 buf[i++] = tm->tm_wday & 0x07;
120
121 /* month, 1 - 12 */
122 buf[i++] = bin2bcd(tm->tm_mon + 1);
123
124 /* year */
125 buf[i++] = bin2bcd(tm->tm_year % 100);
126
127 /* write register's data */
128 err = i2c_master_send(client, buf, i);
129 if (err != i) {
130 dev_err(&client->dev,
131 "%s: err=%d", __func__, err);
132 return -EIO;
133 }
134
135 return 0;
136}
137
138#ifdef CONFIG_RTC_INTF_DEV
139static int pcf2127_rtc_ioctl(struct device *dev,
140 unsigned int cmd, unsigned long arg)
141{
142 struct pcf2127 *pcf2127 = i2c_get_clientdata(to_i2c_client(dev));
143
144 switch (cmd) {
145 case RTC_VL_READ:
146 if (pcf2127->voltage_low)
147 dev_info(dev, "low voltage detected, date/time is not reliable.\n");
148
149 if (copy_to_user((void __user *)arg, &pcf2127->voltage_low,
150 sizeof(int)))
151 return -EFAULT;
152 return 0;
153 default:
154 return -ENOIOCTLCMD;
155 }
156}
157#else
158#define pcf2127_rtc_ioctl NULL
159#endif
160
161static int pcf2127_rtc_read_time(struct device *dev, struct rtc_time *tm)
162{
163 return pcf2127_get_datetime(to_i2c_client(dev), tm);
164}
165
166static int pcf2127_rtc_set_time(struct device *dev, struct rtc_time *tm)
167{
168 return pcf2127_set_datetime(to_i2c_client(dev), tm);
169}
170
171static const struct rtc_class_ops pcf2127_rtc_ops = {
172 .ioctl = pcf2127_rtc_ioctl,
173 .read_time = pcf2127_rtc_read_time,
174 .set_time = pcf2127_rtc_set_time,
175};
176
177static int pcf2127_probe(struct i2c_client *client,
178 const struct i2c_device_id *id)
179{
180 struct pcf2127 *pcf2127;
181
182 dev_dbg(&client->dev, "%s\n", __func__);
183
184 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
185 return -ENODEV;
186
187 pcf2127 = devm_kzalloc(&client->dev, sizeof(struct pcf2127),
188 GFP_KERNEL);
189 if (!pcf2127)
190 return -ENOMEM;
191
192 dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
193
194 i2c_set_clientdata(client, pcf2127);
195
196 pcf2127->rtc = devm_rtc_device_register(&client->dev,
197 pcf2127_driver.driver.name,
198 &pcf2127_rtc_ops, THIS_MODULE);
199
200 return PTR_ERR_OR_ZERO(pcf2127->rtc);
201}
202
203static const struct i2c_device_id pcf2127_id[] = {
204 { "pcf2127", 0 },
205 { }
206};
207MODULE_DEVICE_TABLE(i2c, pcf2127_id);
208
209#ifdef CONFIG_OF
210static const struct of_device_id pcf2127_of_match[] = {
211 { .compatible = "nxp,pcf2127" },
212 {}
213};
214MODULE_DEVICE_TABLE(of, pcf2127_of_match);
215#endif
216
217static struct i2c_driver pcf2127_driver = {
218 .driver = {
219 .name = "rtc-pcf2127",
220 .owner = THIS_MODULE,
221 .of_match_table = of_match_ptr(pcf2127_of_match),
222 },
223 .probe = pcf2127_probe,
224 .id_table = pcf2127_id,
225};
226
227module_i2c_driver(pcf2127_driver);
228
229MODULE_AUTHOR("Renaud Cerrato <r.cerrato@til-technologies.fr>");
230MODULE_DESCRIPTION("NXP PCF2127 RTC driver");
231MODULE_LICENSE("GPL");
232MODULE_VERSION(DRV_VERSION);