1 /*
2 * Copyright (C) 2012 Avionic Design GmbH
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 */
8
9 #include <linux/bcd.h>
10 #include <linux/i2c.h>
11 #include <linux/module.h>
12 #include <linux/rtc.h>
13 #include <linux/of.h>
14
15 #define DRIVER_NAME "rtc-pcf8523"
16
17 #define REG_CONTROL1 0x00
18 #define REG_CONTROL1_CAP_SEL (1 << 7)
19 #define REG_CONTROL1_STOP (1 << 5)
20
21 #define REG_CONTROL3 0x02
22 #define REG_CONTROL3_PM_BLD (1 << 7) /* battery low detection disabled */
23 #define REG_CONTROL3_PM_VDD (1 << 6) /* switch-over disabled */
24 #define REG_CONTROL3_PM_DSM (1 << 5) /* direct switching mode */
25 #define REG_CONTROL3_PM_MASK 0xe0
26 #define REG_CONTROL3_BLF (1 << 2) /* battery low bit, read-only */
27
28 #define REG_SECONDS 0x03
29 #define REG_SECONDS_OS (1 << 7)
30
31 #define REG_MINUTES 0x04
32 #define REG_HOURS 0x05
33 #define REG_DAYS 0x06
34 #define REG_WEEKDAYS 0x07
35 #define REG_MONTHS 0x08
36 #define REG_YEARS 0x09
37
38 struct pcf8523 {
39 struct rtc_device *rtc;
40 };
41
pcf8523_read(struct i2c_client * client,u8 reg,u8 * valuep)42 static int pcf8523_read(struct i2c_client *client, u8 reg, u8 *valuep)
43 {
44 struct i2c_msg msgs[2];
45 u8 value = 0;
46 int err;
47
48 msgs[0].addr = client->addr;
49 msgs[0].flags = 0;
50 msgs[0].len = sizeof(reg);
51 msgs[0].buf = ®
52
53 msgs[1].addr = client->addr;
54 msgs[1].flags = I2C_M_RD;
55 msgs[1].len = sizeof(value);
56 msgs[1].buf = &value;
57
58 err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
59 if (err < 0)
60 return err;
61
62 *valuep = value;
63
64 return 0;
65 }
66
pcf8523_write(struct i2c_client * client,u8 reg,u8 value)67 static int pcf8523_write(struct i2c_client *client, u8 reg, u8 value)
68 {
69 u8 buffer[2] = { reg, value };
70 struct i2c_msg msg;
71 int err;
72
73 msg.addr = client->addr;
74 msg.flags = 0;
75 msg.len = sizeof(buffer);
76 msg.buf = buffer;
77
78 err = i2c_transfer(client->adapter, &msg, 1);
79 if (err < 0)
80 return err;
81
82 return 0;
83 }
84
pcf8523_select_capacitance(struct i2c_client * client,bool high)85 static int pcf8523_select_capacitance(struct i2c_client *client, bool high)
86 {
87 u8 value;
88 int err;
89
90 err = pcf8523_read(client, REG_CONTROL1, &value);
91 if (err < 0)
92 return err;
93
94 if (!high)
95 value &= ~REG_CONTROL1_CAP_SEL;
96 else
97 value |= REG_CONTROL1_CAP_SEL;
98
99 err = pcf8523_write(client, REG_CONTROL1, value);
100 if (err < 0)
101 return err;
102
103 return err;
104 }
105
pcf8523_set_pm(struct i2c_client * client,u8 pm)106 static int pcf8523_set_pm(struct i2c_client *client, u8 pm)
107 {
108 u8 value;
109 int err;
110
111 err = pcf8523_read(client, REG_CONTROL3, &value);
112 if (err < 0)
113 return err;
114
115 value = (value & ~REG_CONTROL3_PM_MASK) | pm;
116
117 err = pcf8523_write(client, REG_CONTROL3, value);
118 if (err < 0)
119 return err;
120
121 return 0;
122 }
123
pcf8523_stop_rtc(struct i2c_client * client)124 static int pcf8523_stop_rtc(struct i2c_client *client)
125 {
126 u8 value;
127 int err;
128
129 err = pcf8523_read(client, REG_CONTROL1, &value);
130 if (err < 0)
131 return err;
132
133 value |= REG_CONTROL1_STOP;
134
135 err = pcf8523_write(client, REG_CONTROL1, value);
136 if (err < 0)
137 return err;
138
139 return 0;
140 }
141
pcf8523_start_rtc(struct i2c_client * client)142 static int pcf8523_start_rtc(struct i2c_client *client)
143 {
144 u8 value;
145 int err;
146
147 err = pcf8523_read(client, REG_CONTROL1, &value);
148 if (err < 0)
149 return err;
150
151 value &= ~REG_CONTROL1_STOP;
152
153 err = pcf8523_write(client, REG_CONTROL1, value);
154 if (err < 0)
155 return err;
156
157 return 0;
158 }
159
pcf8523_rtc_read_time(struct device * dev,struct rtc_time * tm)160 static int pcf8523_rtc_read_time(struct device *dev, struct rtc_time *tm)
161 {
162 struct i2c_client *client = to_i2c_client(dev);
163 u8 start = REG_SECONDS, regs[7];
164 struct i2c_msg msgs[2];
165 int err;
166
167 msgs[0].addr = client->addr;
168 msgs[0].flags = 0;
169 msgs[0].len = 1;
170 msgs[0].buf = &start;
171
172 msgs[1].addr = client->addr;
173 msgs[1].flags = I2C_M_RD;
174 msgs[1].len = sizeof(regs);
175 msgs[1].buf = regs;
176
177 err = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
178 if (err < 0)
179 return err;
180
181 if (regs[0] & REG_SECONDS_OS) {
182 /*
183 * If the oscillator was stopped, try to clear the flag. Upon
184 * power-up the flag is always set, but if we cannot clear it
185 * the oscillator isn't running properly for some reason. The
186 * sensible thing therefore is to return an error, signalling
187 * that the clock cannot be assumed to be correct.
188 */
189
190 regs[0] &= ~REG_SECONDS_OS;
191
192 err = pcf8523_write(client, REG_SECONDS, regs[0]);
193 if (err < 0)
194 return err;
195
196 err = pcf8523_read(client, REG_SECONDS, ®s[0]);
197 if (err < 0)
198 return err;
199
200 if (regs[0] & REG_SECONDS_OS)
201 return -EAGAIN;
202 }
203
204 tm->tm_sec = bcd2bin(regs[0] & 0x7f);
205 tm->tm_min = bcd2bin(regs[1] & 0x7f);
206 tm->tm_hour = bcd2bin(regs[2] & 0x3f);
207 tm->tm_mday = bcd2bin(regs[3] & 0x3f);
208 tm->tm_wday = regs[4] & 0x7;
209 tm->tm_mon = bcd2bin(regs[5] & 0x1f) - 1;
210 tm->tm_year = bcd2bin(regs[6]) + 100;
211
212 return rtc_valid_tm(tm);
213 }
214
pcf8523_rtc_set_time(struct device * dev,struct rtc_time * tm)215 static int pcf8523_rtc_set_time(struct device *dev, struct rtc_time *tm)
216 {
217 struct i2c_client *client = to_i2c_client(dev);
218 struct i2c_msg msg;
219 u8 regs[8];
220 int err;
221
222 err = pcf8523_stop_rtc(client);
223 if (err < 0)
224 return err;
225
226 regs[0] = REG_SECONDS;
227 regs[1] = bin2bcd(tm->tm_sec);
228 regs[2] = bin2bcd(tm->tm_min);
229 regs[3] = bin2bcd(tm->tm_hour);
230 regs[4] = bin2bcd(tm->tm_mday);
231 regs[5] = tm->tm_wday;
232 regs[6] = bin2bcd(tm->tm_mon + 1);
233 regs[7] = bin2bcd(tm->tm_year - 100);
234
235 msg.addr = client->addr;
236 msg.flags = 0;
237 msg.len = sizeof(regs);
238 msg.buf = regs;
239
240 err = i2c_transfer(client->adapter, &msg, 1);
241 if (err < 0) {
242 /*
243 * If the time cannot be set, restart the RTC anyway. Note
244 * that errors are ignored if the RTC cannot be started so
245 * that we have a chance to propagate the original error.
246 */
247 pcf8523_start_rtc(client);
248 return err;
249 }
250
251 return pcf8523_start_rtc(client);
252 }
253
254 #ifdef CONFIG_RTC_INTF_DEV
pcf8523_rtc_ioctl(struct device * dev,unsigned int cmd,unsigned long arg)255 static int pcf8523_rtc_ioctl(struct device *dev, unsigned int cmd,
256 unsigned long arg)
257 {
258 struct i2c_client *client = to_i2c_client(dev);
259 u8 value;
260 int ret = 0, err;
261
262 switch (cmd) {
263 case RTC_VL_READ:
264 err = pcf8523_read(client, REG_CONTROL3, &value);
265 if (err < 0)
266 return err;
267
268 if (value & REG_CONTROL3_BLF)
269 ret = 1;
270
271 if (copy_to_user((void __user *)arg, &ret, sizeof(int)))
272 return -EFAULT;
273
274 return 0;
275 default:
276 return -ENOIOCTLCMD;
277 }
278 }
279 #else
280 #define pcf8523_rtc_ioctl NULL
281 #endif
282
283 static const struct rtc_class_ops pcf8523_rtc_ops = {
284 .read_time = pcf8523_rtc_read_time,
285 .set_time = pcf8523_rtc_set_time,
286 .ioctl = pcf8523_rtc_ioctl,
287 };
288
pcf8523_probe(struct i2c_client * client,const struct i2c_device_id * id)289 static int pcf8523_probe(struct i2c_client *client,
290 const struct i2c_device_id *id)
291 {
292 struct pcf8523 *pcf;
293 int err;
294
295 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
296 return -ENODEV;
297
298 pcf = devm_kzalloc(&client->dev, sizeof(*pcf), GFP_KERNEL);
299 if (!pcf)
300 return -ENOMEM;
301
302 err = pcf8523_select_capacitance(client, true);
303 if (err < 0)
304 return err;
305
306 err = pcf8523_set_pm(client, 0);
307 if (err < 0)
308 return err;
309
310 pcf->rtc = devm_rtc_device_register(&client->dev, DRIVER_NAME,
311 &pcf8523_rtc_ops, THIS_MODULE);
312 if (IS_ERR(pcf->rtc))
313 return PTR_ERR(pcf->rtc);
314
315 i2c_set_clientdata(client, pcf);
316
317 return 0;
318 }
319
320 static const struct i2c_device_id pcf8523_id[] = {
321 { "pcf8523", 0 },
322 { }
323 };
324 MODULE_DEVICE_TABLE(i2c, pcf8523_id);
325
326 #ifdef CONFIG_OF
327 static const struct of_device_id pcf8523_of_match[] = {
328 { .compatible = "nxp,pcf8523" },
329 { }
330 };
331 MODULE_DEVICE_TABLE(of, pcf8523_of_match);
332 #endif
333
334 static struct i2c_driver pcf8523_driver = {
335 .driver = {
336 .name = DRIVER_NAME,
337 .owner = THIS_MODULE,
338 .of_match_table = of_match_ptr(pcf8523_of_match),
339 },
340 .probe = pcf8523_probe,
341 .id_table = pcf8523_id,
342 };
343 module_i2c_driver(pcf8523_driver);
344
345 MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
346 MODULE_DESCRIPTION("NXP PCF8523 RTC driver");
347 MODULE_LICENSE("GPL v2");
348