]>
Commit | Line | Data |
---|---|---|
796b7abb SA |
1 | /* |
2 | * An I2C driver for the PCF85063 RTC | |
3 | * Copyright 2014 Rose Technology | |
4 | * | |
5 | * Author: Søren Andersen <san@rosetechnology.dk> | |
6 | * Maintainers: http://www.nslu2-linux.org/ | |
7 | * | |
8 | * based on the other drivers in this same directory. | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or modify | |
11 | * it under the terms of the GNU General Public License version 2 as | |
12 | * published by the Free Software Foundation. | |
13 | */ | |
14 | #include <linux/i2c.h> | |
15 | #include <linux/bcd.h> | |
16 | #include <linux/rtc.h> | |
17 | #include <linux/module.h> | |
18 | ||
0d981f81 CD |
19 | /* |
20 | * Information for this driver was pulled from the following datasheets. | |
21 | * | |
22 | * http://www.nxp.com/documents/data_sheet/PCF85063A.pdf | |
23 | * http://www.nxp.com/documents/data_sheet/PCF85063TP.pdf | |
24 | * | |
25 | * PCF85063A -- Rev. 6 — 18 November 2015 | |
26 | * PCF85063TP -- Rev. 4 — 6 May 2015 | |
27 | */ | |
28 | ||
796b7abb | 29 | #define PCF85063_REG_CTRL1 0x00 /* status */ |
31d4d33e | 30 | #define PCF85063_REG_CTRL1_STOP BIT(5) |
796b7abb SA |
31 | #define PCF85063_REG_CTRL2 0x01 |
32 | ||
33 | #define PCF85063_REG_SC 0x04 /* datetime */ | |
6cc4c8b1 | 34 | #define PCF85063_REG_SC_OS 0x80 |
796b7abb SA |
35 | #define PCF85063_REG_MN 0x05 |
36 | #define PCF85063_REG_HR 0x06 | |
37 | #define PCF85063_REG_DM 0x07 | |
38 | #define PCF85063_REG_DW 0x08 | |
39 | #define PCF85063_REG_MO 0x09 | |
40 | #define PCF85063_REG_YR 0x0A | |
41 | ||
796b7abb SA |
42 | static struct i2c_driver pcf85063_driver; |
43 | ||
31d4d33e JB |
44 | static int pcf85063_stop_clock(struct i2c_client *client, u8 *ctrl1) |
45 | { | |
46 | s32 ret; | |
47 | ||
48 | ret = i2c_smbus_read_byte_data(client, PCF85063_REG_CTRL1); | |
49 | if (ret < 0) { | |
50 | dev_err(&client->dev, "Failing to stop the clock\n"); | |
51 | return -EIO; | |
52 | } | |
53 | ||
54 | /* stop the clock */ | |
55 | ret |= PCF85063_REG_CTRL1_STOP; | |
56 | ||
57 | ret = i2c_smbus_write_byte_data(client, PCF85063_REG_CTRL1, ret); | |
58 | if (ret < 0) { | |
59 | dev_err(&client->dev, "Failing to stop the clock\n"); | |
60 | return -EIO; | |
61 | } | |
62 | ||
63 | *ctrl1 = ret; | |
64 | ||
65 | return 0; | |
66 | } | |
67 | ||
0d981f81 CD |
68 | static int pcf85063_start_clock(struct i2c_client *client, u8 ctrl1) |
69 | { | |
70 | s32 ret; | |
71 | ||
72 | /* start the clock */ | |
73 | ctrl1 &= PCF85063_REG_CTRL1_STOP; | |
74 | ||
75 | ret = i2c_smbus_write_byte_data(client, PCF85063_REG_CTRL1, ctrl1); | |
76 | if (ret < 0) { | |
77 | dev_err(&client->dev, "Failing to start the clock\n"); | |
78 | return -EIO; | |
79 | } | |
80 | ||
81 | return 0; | |
82 | } | |
83 | ||
796b7abb SA |
84 | static int pcf85063_get_datetime(struct i2c_client *client, struct rtc_time *tm) |
85 | { | |
7b576848 | 86 | int rc; |
7b576848 JB |
87 | u8 regs[7]; |
88 | ||
89 | /* | |
90 | * while reading, the time/date registers are blocked and not updated | |
91 | * anymore until the access is finished. To not lose a second | |
92 | * event, the access must be finished within one second. So, read all | |
93 | * time/date registers in one turn. | |
94 | */ | |
95 | rc = i2c_smbus_read_i2c_block_data(client, PCF85063_REG_SC, | |
96 | sizeof(regs), regs); | |
97 | if (rc != sizeof(regs)) { | |
98 | dev_err(&client->dev, "date/time register read error\n"); | |
796b7abb SA |
99 | return -EIO; |
100 | } | |
101 | ||
6cc4c8b1 JB |
102 | /* if the clock has lost its power it makes no sense to use its time */ |
103 | if (regs[0] & PCF85063_REG_SC_OS) { | |
104 | dev_warn(&client->dev, "Power loss detected, invalid time\n"); | |
105 | return -EINVAL; | |
106 | } | |
107 | ||
7b576848 JB |
108 | tm->tm_sec = bcd2bin(regs[0] & 0x7F); |
109 | tm->tm_min = bcd2bin(regs[1] & 0x7F); | |
110 | tm->tm_hour = bcd2bin(regs[2] & 0x3F); /* rtc hr 0-23 */ | |
111 | tm->tm_mday = bcd2bin(regs[3] & 0x3F); | |
112 | tm->tm_wday = regs[4] & 0x07; | |
113 | tm->tm_mon = bcd2bin(regs[5] & 0x1F) - 1; /* rtc mn 1-12 */ | |
114 | tm->tm_year = bcd2bin(regs[6]); | |
c421ce72 | 115 | tm->tm_year += 100; |
796b7abb | 116 | |
5413eaba | 117 | return rtc_valid_tm(tm); |
796b7abb SA |
118 | } |
119 | ||
120 | static int pcf85063_set_datetime(struct i2c_client *client, struct rtc_time *tm) | |
121 | { | |
31d4d33e | 122 | int rc; |
0d981f81 CD |
123 | u8 regs[7]; |
124 | u8 ctrl1; | |
796b7abb | 125 | |
c421ce72 AB |
126 | if ((tm->tm_year < 100) || (tm->tm_year > 199)) |
127 | return -EINVAL; | |
128 | ||
31d4d33e JB |
129 | /* |
130 | * to accurately set the time, reset the divider chain and keep it in | |
131 | * reset state until all time/date registers are written | |
132 | */ | |
0d981f81 | 133 | rc = pcf85063_stop_clock(client, &ctrl1); |
31d4d33e JB |
134 | if (rc != 0) |
135 | return rc; | |
796b7abb SA |
136 | |
137 | /* hours, minutes and seconds */ | |
31d4d33e | 138 | regs[0] = bin2bcd(tm->tm_sec) & 0x7F; /* clear OS flag */ |
796b7abb | 139 | |
31d4d33e JB |
140 | regs[1] = bin2bcd(tm->tm_min); |
141 | regs[2] = bin2bcd(tm->tm_hour); | |
796b7abb SA |
142 | |
143 | /* Day of month, 1 - 31 */ | |
31d4d33e | 144 | regs[3] = bin2bcd(tm->tm_mday); |
796b7abb SA |
145 | |
146 | /* Day, 0 - 6 */ | |
31d4d33e | 147 | regs[4] = tm->tm_wday & 0x07; |
796b7abb SA |
148 | |
149 | /* month, 1 - 12 */ | |
31d4d33e | 150 | regs[5] = bin2bcd(tm->tm_mon + 1); |
796b7abb SA |
151 | |
152 | /* year and century */ | |
c421ce72 | 153 | regs[6] = bin2bcd(tm->tm_year - 100); |
31d4d33e | 154 | |
31d4d33e JB |
155 | /* write all registers at once */ |
156 | rc = i2c_smbus_write_i2c_block_data(client, PCF85063_REG_SC, | |
157 | sizeof(regs), regs); | |
158 | if (rc < 0) { | |
159 | dev_err(&client->dev, "date/time register write error\n"); | |
160 | return rc; | |
796b7abb SA |
161 | } |
162 | ||
0d981f81 CD |
163 | /* |
164 | * Write the control register as a separate action since the size of | |
165 | * the register space is different between the PCF85063TP and | |
166 | * PCF85063A devices. The rollover point can not be used. | |
167 | */ | |
168 | rc = pcf85063_start_clock(client, ctrl1); | |
169 | if (rc != 0) | |
170 | return rc; | |
171 | ||
796b7abb SA |
172 | return 0; |
173 | } | |
174 | ||
175 | static int pcf85063_rtc_read_time(struct device *dev, struct rtc_time *tm) | |
176 | { | |
177 | return pcf85063_get_datetime(to_i2c_client(dev), tm); | |
178 | } | |
179 | ||
180 | static int pcf85063_rtc_set_time(struct device *dev, struct rtc_time *tm) | |
181 | { | |
182 | return pcf85063_set_datetime(to_i2c_client(dev), tm); | |
183 | } | |
184 | ||
185 | static const struct rtc_class_ops pcf85063_rtc_ops = { | |
186 | .read_time = pcf85063_rtc_read_time, | |
187 | .set_time = pcf85063_rtc_set_time | |
188 | }; | |
189 | ||
190 | static int pcf85063_probe(struct i2c_client *client, | |
191 | const struct i2c_device_id *id) | |
192 | { | |
2da424af | 193 | struct rtc_device *rtc; |
796b7abb SA |
194 | |
195 | dev_dbg(&client->dev, "%s\n", __func__); | |
196 | ||
197 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) | |
198 | return -ENODEV; | |
199 | ||
2da424af AB |
200 | rtc = devm_rtc_device_register(&client->dev, |
201 | pcf85063_driver.driver.name, | |
202 | &pcf85063_rtc_ops, THIS_MODULE); | |
796b7abb | 203 | |
2da424af | 204 | return PTR_ERR_OR_ZERO(rtc); |
796b7abb SA |
205 | } |
206 | ||
207 | static const struct i2c_device_id pcf85063_id[] = { | |
208 | { "pcf85063", 0 }, | |
209 | { } | |
210 | }; | |
211 | MODULE_DEVICE_TABLE(i2c, pcf85063_id); | |
212 | ||
213 | #ifdef CONFIG_OF | |
214 | static const struct of_device_id pcf85063_of_match[] = { | |
215 | { .compatible = "nxp,pcf85063" }, | |
216 | {} | |
217 | }; | |
218 | MODULE_DEVICE_TABLE(of, pcf85063_of_match); | |
219 | #endif | |
220 | ||
221 | static struct i2c_driver pcf85063_driver = { | |
222 | .driver = { | |
223 | .name = "rtc-pcf85063", | |
796b7abb SA |
224 | .of_match_table = of_match_ptr(pcf85063_of_match), |
225 | }, | |
226 | .probe = pcf85063_probe, | |
227 | .id_table = pcf85063_id, | |
228 | }; | |
229 | ||
230 | module_i2c_driver(pcf85063_driver); | |
231 | ||
232 | MODULE_AUTHOR("Søren Andersen <san@rosetechnology.dk>"); | |
233 | MODULE_DESCRIPTION("PCF85063 RTC driver"); | |
234 | MODULE_LICENSE("GPL"); |