Root/
1 | /* |
2 | * An SPI driver for the Philips PCF2123 RTC |
3 | * Copyright 2009 Cyber Switching, Inc. |
4 | * |
5 | * Author: Chris Verges <chrisv@cyberswitching.com> |
6 | * Maintainers: http://www.cyberswitching.com |
7 | * |
8 | * based on the RS5C348 driver in this same directory. |
9 | * |
10 | * Thanks to Christian Pellegrin <chripell@fsfe.org> for |
11 | * the sysfs contributions to this driver. |
12 | * |
13 | * This program is free software; you can redistribute it and/or modify |
14 | * it under the terms of the GNU General Public License version 2 as |
15 | * published by the Free Software Foundation. |
16 | * |
17 | * Please note that the CS is active high, so platform data |
18 | * should look something like: |
19 | * |
20 | * static struct spi_board_info ek_spi_devices[] = { |
21 | * ... |
22 | * { |
23 | * .modalias = "rtc-pcf2123", |
24 | * .chip_select = 1, |
25 | * .controller_data = (void *)AT91_PIN_PA10, |
26 | * .max_speed_hz = 1000 * 1000, |
27 | * .mode = SPI_CS_HIGH, |
28 | * .bus_num = 0, |
29 | * }, |
30 | * ... |
31 | *}; |
32 | * |
33 | */ |
34 | |
35 | #include <linux/bcd.h> |
36 | #include <linux/delay.h> |
37 | #include <linux/device.h> |
38 | #include <linux/errno.h> |
39 | #include <linux/init.h> |
40 | #include <linux/kernel.h> |
41 | #include <linux/string.h> |
42 | #include <linux/slab.h> |
43 | #include <linux/rtc.h> |
44 | #include <linux/spi/spi.h> |
45 | |
46 | #define DRV_VERSION "0.6" |
47 | |
48 | #define PCF2123_REG_CTRL1 (0x00) /* Control Register 1 */ |
49 | #define PCF2123_REG_CTRL2 (0x01) /* Control Register 2 */ |
50 | #define PCF2123_REG_SC (0x02) /* datetime */ |
51 | #define PCF2123_REG_MN (0x03) |
52 | #define PCF2123_REG_HR (0x04) |
53 | #define PCF2123_REG_DM (0x05) |
54 | #define PCF2123_REG_DW (0x06) |
55 | #define PCF2123_REG_MO (0x07) |
56 | #define PCF2123_REG_YR (0x08) |
57 | |
58 | #define PCF2123_SUBADDR (1 << 4) |
59 | #define PCF2123_WRITE ((0 << 7) | PCF2123_SUBADDR) |
60 | #define PCF2123_READ ((1 << 7) | PCF2123_SUBADDR) |
61 | |
62 | static struct spi_driver pcf2123_driver; |
63 | |
64 | struct pcf2123_sysfs_reg { |
65 | struct device_attribute attr; |
66 | char name[2]; |
67 | }; |
68 | |
69 | struct pcf2123_plat_data { |
70 | struct rtc_device *rtc; |
71 | struct pcf2123_sysfs_reg regs[16]; |
72 | }; |
73 | |
74 | /* |
75 | * Causes a 30 nanosecond delay to ensure that the PCF2123 chip select |
76 | * is released properly after an SPI write. This function should be |
77 | * called after EVERY read/write call over SPI. |
78 | */ |
79 | static inline void pcf2123_delay_trec(void) |
80 | { |
81 | ndelay(30); |
82 | } |
83 | |
84 | static ssize_t pcf2123_show(struct device *dev, struct device_attribute *attr, |
85 | char *buffer) |
86 | { |
87 | struct spi_device *spi = to_spi_device(dev); |
88 | struct pcf2123_sysfs_reg *r; |
89 | u8 txbuf[1], rxbuf[1]; |
90 | unsigned long reg; |
91 | int ret; |
92 | |
93 | r = container_of(attr, struct pcf2123_sysfs_reg, attr); |
94 | |
95 | if (strict_strtoul(r->name, 16, ®)) |
96 | return -EINVAL; |
97 | |
98 | txbuf[0] = PCF2123_READ | reg; |
99 | ret = spi_write_then_read(spi, txbuf, 1, rxbuf, 1); |
100 | if (ret < 0) |
101 | return -EIO; |
102 | pcf2123_delay_trec(); |
103 | return sprintf(buffer, "0x%x\n", rxbuf[0]); |
104 | } |
105 | |
106 | static ssize_t pcf2123_store(struct device *dev, struct device_attribute *attr, |
107 | const char *buffer, size_t count) { |
108 | struct spi_device *spi = to_spi_device(dev); |
109 | struct pcf2123_sysfs_reg *r; |
110 | u8 txbuf[2]; |
111 | unsigned long reg; |
112 | unsigned long val; |
113 | |
114 | int ret; |
115 | |
116 | r = container_of(attr, struct pcf2123_sysfs_reg, attr); |
117 | |
118 | if (strict_strtoul(r->name, 16, ®) |
119 | || strict_strtoul(buffer, 10, &val)) |
120 | return -EINVAL; |
121 | |
122 | txbuf[0] = PCF2123_WRITE | reg; |
123 | txbuf[1] = val; |
124 | ret = spi_write(spi, txbuf, sizeof(txbuf)); |
125 | if (ret < 0) |
126 | return -EIO; |
127 | pcf2123_delay_trec(); |
128 | return count; |
129 | } |
130 | |
131 | static int pcf2123_rtc_read_time(struct device *dev, struct rtc_time *tm) |
132 | { |
133 | struct spi_device *spi = to_spi_device(dev); |
134 | u8 txbuf[1], rxbuf[7]; |
135 | int ret; |
136 | |
137 | txbuf[0] = PCF2123_READ | PCF2123_REG_SC; |
138 | ret = spi_write_then_read(spi, txbuf, sizeof(txbuf), |
139 | rxbuf, sizeof(rxbuf)); |
140 | if (ret < 0) |
141 | return ret; |
142 | pcf2123_delay_trec(); |
143 | |
144 | tm->tm_sec = bcd2bin(rxbuf[0] & 0x7F); |
145 | tm->tm_min = bcd2bin(rxbuf[1] & 0x7F); |
146 | tm->tm_hour = bcd2bin(rxbuf[2] & 0x3F); /* rtc hr 0-23 */ |
147 | tm->tm_mday = bcd2bin(rxbuf[3] & 0x3F); |
148 | tm->tm_wday = rxbuf[4] & 0x07; |
149 | tm->tm_mon = bcd2bin(rxbuf[5] & 0x1F) - 1; /* rtc mn 1-12 */ |
150 | tm->tm_year = bcd2bin(rxbuf[6]); |
151 | if (tm->tm_year < 70) |
152 | tm->tm_year += 100; /* assume we are in 1970...2069 */ |
153 | |
154 | dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, " |
155 | "mday=%d, mon=%d, year=%d, wday=%d\n", |
156 | __func__, |
157 | tm->tm_sec, tm->tm_min, tm->tm_hour, |
158 | tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday); |
159 | |
160 | /* the clock can give out invalid datetime, but we cannot return |
161 | * -EINVAL otherwise hwclock will refuse to set the time on bootup. |
162 | */ |
163 | if (rtc_valid_tm(tm) < 0) |
164 | dev_err(dev, "retrieved date/time is not valid.\n"); |
165 | |
166 | return 0; |
167 | } |
168 | |
169 | static int pcf2123_rtc_set_time(struct device *dev, struct rtc_time *tm) |
170 | { |
171 | struct spi_device *spi = to_spi_device(dev); |
172 | u8 txbuf[8]; |
173 | int ret; |
174 | |
175 | dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, " |
176 | "mday=%d, mon=%d, year=%d, wday=%d\n", |
177 | __func__, |
178 | tm->tm_sec, tm->tm_min, tm->tm_hour, |
179 | tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday); |
180 | |
181 | /* Stop the counter first */ |
182 | txbuf[0] = PCF2123_WRITE | PCF2123_REG_CTRL1; |
183 | txbuf[1] = 0x20; |
184 | ret = spi_write(spi, txbuf, 2); |
185 | if (ret < 0) |
186 | return ret; |
187 | pcf2123_delay_trec(); |
188 | |
189 | /* Set the new time */ |
190 | txbuf[0] = PCF2123_WRITE | PCF2123_REG_SC; |
191 | txbuf[1] = bin2bcd(tm->tm_sec & 0x7F); |
192 | txbuf[2] = bin2bcd(tm->tm_min & 0x7F); |
193 | txbuf[3] = bin2bcd(tm->tm_hour & 0x3F); |
194 | txbuf[4] = bin2bcd(tm->tm_mday & 0x3F); |
195 | txbuf[5] = tm->tm_wday & 0x07; |
196 | txbuf[6] = bin2bcd((tm->tm_mon + 1) & 0x1F); /* rtc mn 1-12 */ |
197 | txbuf[7] = bin2bcd(tm->tm_year < 100 ? tm->tm_year : tm->tm_year - 100); |
198 | |
199 | ret = spi_write(spi, txbuf, sizeof(txbuf)); |
200 | if (ret < 0) |
201 | return ret; |
202 | pcf2123_delay_trec(); |
203 | |
204 | /* Start the counter */ |
205 | txbuf[0] = PCF2123_WRITE | PCF2123_REG_CTRL1; |
206 | txbuf[1] = 0x00; |
207 | ret = spi_write(spi, txbuf, 2); |
208 | if (ret < 0) |
209 | return ret; |
210 | pcf2123_delay_trec(); |
211 | |
212 | return 0; |
213 | } |
214 | |
215 | static const struct rtc_class_ops pcf2123_rtc_ops = { |
216 | .read_time = pcf2123_rtc_read_time, |
217 | .set_time = pcf2123_rtc_set_time, |
218 | }; |
219 | |
220 | static int __devinit pcf2123_probe(struct spi_device *spi) |
221 | { |
222 | struct rtc_device *rtc; |
223 | struct pcf2123_plat_data *pdata; |
224 | u8 txbuf[2], rxbuf[2]; |
225 | int ret, i; |
226 | |
227 | pdata = kzalloc(sizeof(struct pcf2123_plat_data), GFP_KERNEL); |
228 | if (!pdata) |
229 | return -ENOMEM; |
230 | spi->dev.platform_data = pdata; |
231 | |
232 | /* Send a software reset command */ |
233 | txbuf[0] = PCF2123_WRITE | PCF2123_REG_CTRL1; |
234 | txbuf[1] = 0x58; |
235 | dev_dbg(&spi->dev, "resetting RTC (0x%02X 0x%02X)\n", |
236 | txbuf[0], txbuf[1]); |
237 | ret = spi_write(spi, txbuf, 2 * sizeof(u8)); |
238 | if (ret < 0) |
239 | goto kfree_exit; |
240 | pcf2123_delay_trec(); |
241 | |
242 | /* Stop the counter */ |
243 | txbuf[0] = PCF2123_WRITE | PCF2123_REG_CTRL1; |
244 | txbuf[1] = 0x20; |
245 | dev_dbg(&spi->dev, "stopping RTC (0x%02X 0x%02X)\n", |
246 | txbuf[0], txbuf[1]); |
247 | ret = spi_write(spi, txbuf, 2 * sizeof(u8)); |
248 | if (ret < 0) |
249 | goto kfree_exit; |
250 | pcf2123_delay_trec(); |
251 | |
252 | /* See if the counter was actually stopped */ |
253 | txbuf[0] = PCF2123_READ | PCF2123_REG_CTRL1; |
254 | dev_dbg(&spi->dev, "checking for presence of RTC (0x%02X)\n", |
255 | txbuf[0]); |
256 | ret = spi_write_then_read(spi, txbuf, 1 * sizeof(u8), |
257 | rxbuf, 2 * sizeof(u8)); |
258 | dev_dbg(&spi->dev, "received data from RTC (0x%02X 0x%02X)\n", |
259 | rxbuf[0], rxbuf[1]); |
260 | if (ret < 0) |
261 | goto kfree_exit; |
262 | pcf2123_delay_trec(); |
263 | |
264 | if (!(rxbuf[0] & 0x20)) { |
265 | dev_err(&spi->dev, "chip not found\n"); |
266 | goto kfree_exit; |
267 | } |
268 | |
269 | dev_info(&spi->dev, "chip found, driver version " DRV_VERSION "\n"); |
270 | dev_info(&spi->dev, "spiclk %u KHz.\n", |
271 | (spi->max_speed_hz + 500) / 1000); |
272 | |
273 | /* Start the counter */ |
274 | txbuf[0] = PCF2123_WRITE | PCF2123_REG_CTRL1; |
275 | txbuf[1] = 0x00; |
276 | ret = spi_write(spi, txbuf, sizeof(txbuf)); |
277 | if (ret < 0) |
278 | goto kfree_exit; |
279 | pcf2123_delay_trec(); |
280 | |
281 | /* Finalize the initialization */ |
282 | rtc = rtc_device_register(pcf2123_driver.driver.name, &spi->dev, |
283 | &pcf2123_rtc_ops, THIS_MODULE); |
284 | |
285 | if (IS_ERR(rtc)) { |
286 | dev_err(&spi->dev, "failed to register.\n"); |
287 | ret = PTR_ERR(rtc); |
288 | goto kfree_exit; |
289 | } |
290 | |
291 | pdata->rtc = rtc; |
292 | |
293 | for (i = 0; i < 16; i++) { |
294 | sprintf(pdata->regs[i].name, "%1x", i); |
295 | pdata->regs[i].attr.attr.mode = S_IRUGO | S_IWUSR; |
296 | pdata->regs[i].attr.attr.name = pdata->regs[i].name; |
297 | pdata->regs[i].attr.show = pcf2123_show; |
298 | pdata->regs[i].attr.store = pcf2123_store; |
299 | ret = device_create_file(&spi->dev, &pdata->regs[i].attr); |
300 | if (ret) { |
301 | dev_err(&spi->dev, "Unable to create sysfs %s\n", |
302 | pdata->regs[i].name); |
303 | goto sysfs_exit; |
304 | } |
305 | } |
306 | |
307 | return 0; |
308 | |
309 | sysfs_exit: |
310 | for (i--; i >= 0; i--) |
311 | device_remove_file(&spi->dev, &pdata->regs[i].attr); |
312 | |
313 | kfree_exit: |
314 | kfree(pdata); |
315 | spi->dev.platform_data = NULL; |
316 | return ret; |
317 | } |
318 | |
319 | static int __devexit pcf2123_remove(struct spi_device *spi) |
320 | { |
321 | struct pcf2123_plat_data *pdata = spi->dev.platform_data; |
322 | int i; |
323 | |
324 | if (pdata) { |
325 | struct rtc_device *rtc = pdata->rtc; |
326 | |
327 | if (rtc) |
328 | rtc_device_unregister(rtc); |
329 | for (i = 0; i < 16; i++) |
330 | if (pdata->regs[i].name[0]) |
331 | device_remove_file(&spi->dev, |
332 | &pdata->regs[i].attr); |
333 | kfree(pdata); |
334 | } |
335 | |
336 | return 0; |
337 | } |
338 | |
339 | static struct spi_driver pcf2123_driver = { |
340 | .driver = { |
341 | .name = "rtc-pcf2123", |
342 | .bus = &spi_bus_type, |
343 | .owner = THIS_MODULE, |
344 | }, |
345 | .probe = pcf2123_probe, |
346 | .remove = __devexit_p(pcf2123_remove), |
347 | }; |
348 | |
349 | static int __init pcf2123_init(void) |
350 | { |
351 | return spi_register_driver(&pcf2123_driver); |
352 | } |
353 | |
354 | static void __exit pcf2123_exit(void) |
355 | { |
356 | spi_unregister_driver(&pcf2123_driver); |
357 | } |
358 | |
359 | MODULE_AUTHOR("Chris Verges <chrisv@cyberswitching.com>"); |
360 | MODULE_DESCRIPTION("NXP PCF2123 RTC driver"); |
361 | MODULE_LICENSE("GPL"); |
362 | MODULE_VERSION(DRV_VERSION); |
363 | |
364 | module_init(pcf2123_init); |
365 | module_exit(pcf2123_exit); |
366 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9