Commit | Line | Data |
---|---|---|
7e56a7dc HVR |
1 | /* |
2 | * Intersil ISL1208 rtc class driver | |
3 | * | |
4 | * Copyright 2005,2006 Hebert Valerio Riedel <hvr@gnu.org> | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify it | |
7 | * under the terms of the GNU General Public License as published by the | |
8 | * Free Software Foundation; either version 2 of the License, or (at your | |
9 | * option) any later version. | |
10 | * | |
11 | */ | |
12 | ||
13 | #include <linux/module.h> | |
14 | #include <linux/i2c.h> | |
15 | #include <linux/bcd.h> | |
16 | #include <linux/rtc.h> | |
17 | ||
7e56a7dc HVR |
18 | /* Register map */ |
19 | /* rtc section */ | |
20 | #define ISL1208_REG_SC 0x00 | |
21 | #define ISL1208_REG_MN 0x01 | |
22 | #define ISL1208_REG_HR 0x02 | |
9edae7bc AZ |
23 | #define ISL1208_REG_HR_MIL (1<<7) /* 24h/12h mode */ |
24 | #define ISL1208_REG_HR_PM (1<<5) /* PM/AM bit in 12h mode */ | |
7e56a7dc HVR |
25 | #define ISL1208_REG_DT 0x03 |
26 | #define ISL1208_REG_MO 0x04 | |
27 | #define ISL1208_REG_YR 0x05 | |
28 | #define ISL1208_REG_DW 0x06 | |
29 | #define ISL1208_RTC_SECTION_LEN 7 | |
30 | ||
31 | /* control/status section */ | |
32 | #define ISL1208_REG_SR 0x07 | |
9edae7bc AZ |
33 | #define ISL1208_REG_SR_ARST (1<<7) /* auto reset */ |
34 | #define ISL1208_REG_SR_XTOSCB (1<<6) /* crystal oscillator */ | |
35 | #define ISL1208_REG_SR_WRTC (1<<4) /* write rtc */ | |
36 | #define ISL1208_REG_SR_ALM (1<<2) /* alarm */ | |
37 | #define ISL1208_REG_SR_BAT (1<<1) /* battery */ | |
38 | #define ISL1208_REG_SR_RTCF (1<<0) /* rtc fail */ | |
7e56a7dc | 39 | #define ISL1208_REG_INT 0x08 |
cf044f0e RM |
40 | #define ISL1208_REG_INT_ALME (1<<6) /* alarm enable */ |
41 | #define ISL1208_REG_INT_IM (1<<7) /* interrupt/alarm mode */ | |
9edae7bc | 42 | #define ISL1208_REG_09 0x09 /* reserved */ |
7e56a7dc HVR |
43 | #define ISL1208_REG_ATR 0x0a |
44 | #define ISL1208_REG_DTR 0x0b | |
45 | ||
46 | /* alarm section */ | |
47 | #define ISL1208_REG_SCA 0x0c | |
48 | #define ISL1208_REG_MNA 0x0d | |
49 | #define ISL1208_REG_HRA 0x0e | |
50 | #define ISL1208_REG_DTA 0x0f | |
51 | #define ISL1208_REG_MOA 0x10 | |
52 | #define ISL1208_REG_DWA 0x11 | |
53 | #define ISL1208_ALARM_SECTION_LEN 6 | |
54 | ||
55 | /* user section */ | |
56 | #define ISL1208_REG_USR1 0x12 | |
57 | #define ISL1208_REG_USR2 0x13 | |
58 | #define ISL1208_USR_SECTION_LEN 2 | |
59 | ||
9edae7bc | 60 | static struct i2c_driver isl1208_driver; |
7e56a7dc HVR |
61 | |
62 | /* block read */ | |
63 | static int | |
64 | isl1208_i2c_read_regs(struct i2c_client *client, u8 reg, u8 buf[], | |
9edae7bc | 65 | unsigned len) |
7e56a7dc HVR |
66 | { |
67 | u8 reg_addr[1] = { reg }; | |
68 | struct i2c_msg msgs[2] = { | |
885ccbb3 S |
69 | { |
70 | .addr = client->addr, | |
71 | .len = sizeof(reg_addr), | |
72 | .buf = reg_addr | |
73 | }, | |
74 | { | |
75 | .addr = client->addr, | |
76 | .flags = I2C_M_RD, | |
77 | .len = len, | |
78 | .buf = buf | |
79 | } | |
7e56a7dc HVR |
80 | }; |
81 | int ret; | |
82 | ||
7e56a7dc HVR |
83 | BUG_ON(reg > ISL1208_REG_USR2); |
84 | BUG_ON(reg + len > ISL1208_REG_USR2 + 1); | |
85 | ||
86 | ret = i2c_transfer(client->adapter, msgs, 2); | |
87 | if (ret > 0) | |
88 | ret = 0; | |
89 | return ret; | |
90 | } | |
91 | ||
92 | /* block write */ | |
93 | static int | |
94 | isl1208_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[], | |
9edae7bc | 95 | unsigned len) |
7e56a7dc HVR |
96 | { |
97 | u8 i2c_buf[ISL1208_REG_USR2 + 2]; | |
98 | struct i2c_msg msgs[1] = { | |
885ccbb3 S |
99 | { |
100 | .addr = client->addr, | |
101 | .len = len + 1, | |
102 | .buf = i2c_buf | |
103 | } | |
7e56a7dc HVR |
104 | }; |
105 | int ret; | |
106 | ||
7e56a7dc HVR |
107 | BUG_ON(reg > ISL1208_REG_USR2); |
108 | BUG_ON(reg + len > ISL1208_REG_USR2 + 1); | |
109 | ||
110 | i2c_buf[0] = reg; | |
111 | memcpy(&i2c_buf[1], &buf[0], len); | |
112 | ||
113 | ret = i2c_transfer(client->adapter, msgs, 1); | |
114 | if (ret > 0) | |
115 | ret = 0; | |
116 | return ret; | |
117 | } | |
118 | ||
48fc7f7e | 119 | /* simple check to see whether we have a isl1208 */ |
9edae7bc AZ |
120 | static int |
121 | isl1208_i2c_validate_client(struct i2c_client *client) | |
7e56a7dc HVR |
122 | { |
123 | u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, }; | |
124 | u8 zero_mask[ISL1208_RTC_SECTION_LEN] = { | |
125 | 0x80, 0x80, 0x40, 0xc0, 0xe0, 0x00, 0xf8 | |
126 | }; | |
127 | int i; | |
128 | int ret; | |
129 | ||
130 | ret = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN); | |
131 | if (ret < 0) | |
132 | return ret; | |
133 | ||
134 | for (i = 0; i < ISL1208_RTC_SECTION_LEN; ++i) { | |
9edae7bc | 135 | if (regs[i] & zero_mask[i]) /* check if bits are cleared */ |
7e56a7dc HVR |
136 | return -ENODEV; |
137 | } | |
138 | ||
139 | return 0; | |
140 | } | |
141 | ||
9edae7bc AZ |
142 | static int |
143 | isl1208_i2c_get_sr(struct i2c_client *client) | |
7e56a7dc | 144 | { |
c91fd91d | 145 | return i2c_smbus_read_byte_data(client, ISL1208_REG_SR); |
7e56a7dc HVR |
146 | } |
147 | ||
9edae7bc AZ |
148 | static int |
149 | isl1208_i2c_get_atr(struct i2c_client *client) | |
7e56a7dc HVR |
150 | { |
151 | int atr = i2c_smbus_read_byte_data(client, ISL1208_REG_ATR); | |
7e56a7dc | 152 | if (atr < 0) |
9edae7bc | 153 | return atr; |
7e56a7dc HVR |
154 | |
155 | /* The 6bit value in the ATR register controls the load | |
156 | * capacitance C_load * in steps of 0.25pF | |
157 | * | |
158 | * bit (1<<5) of the ATR register is inverted | |
159 | * | |
160 | * C_load(ATR=0x20) = 4.50pF | |
161 | * C_load(ATR=0x00) = 12.50pF | |
162 | * C_load(ATR=0x1f) = 20.25pF | |
163 | * | |
164 | */ | |
165 | ||
9edae7bc AZ |
166 | atr &= 0x3f; /* mask out lsb */ |
167 | atr ^= 1 << 5; /* invert 6th bit */ | |
168 | atr += 2 * 9; /* add offset of 4.5pF; unit[atr] = 0.25pF */ | |
7e56a7dc HVR |
169 | |
170 | return atr; | |
171 | } | |
172 | ||
9edae7bc AZ |
173 | static int |
174 | isl1208_i2c_get_dtr(struct i2c_client *client) | |
7e56a7dc HVR |
175 | { |
176 | int dtr = i2c_smbus_read_byte_data(client, ISL1208_REG_DTR); | |
7e56a7dc HVR |
177 | if (dtr < 0) |
178 | return -EIO; | |
179 | ||
180 | /* dtr encodes adjustments of {-60,-40,-20,0,20,40,60} ppm */ | |
9edae7bc | 181 | dtr = ((dtr & 0x3) * 20) * (dtr & (1 << 2) ? -1 : 1); |
7e56a7dc HVR |
182 | |
183 | return dtr; | |
184 | } | |
185 | ||
9edae7bc AZ |
186 | static int |
187 | isl1208_i2c_get_usr(struct i2c_client *client) | |
7e56a7dc HVR |
188 | { |
189 | u8 buf[ISL1208_USR_SECTION_LEN] = { 0, }; | |
190 | int ret; | |
191 | ||
9edae7bc AZ |
192 | ret = isl1208_i2c_read_regs(client, ISL1208_REG_USR1, buf, |
193 | ISL1208_USR_SECTION_LEN); | |
7e56a7dc HVR |
194 | if (ret < 0) |
195 | return ret; | |
196 | ||
197 | return (buf[1] << 8) | buf[0]; | |
198 | } | |
199 | ||
9edae7bc AZ |
200 | static int |
201 | isl1208_i2c_set_usr(struct i2c_client *client, u16 usr) | |
7e56a7dc HVR |
202 | { |
203 | u8 buf[ISL1208_USR_SECTION_LEN]; | |
204 | ||
205 | buf[0] = usr & 0xff; | |
206 | buf[1] = (usr >> 8) & 0xff; | |
207 | ||
9edae7bc AZ |
208 | return isl1208_i2c_set_regs(client, ISL1208_REG_USR1, buf, |
209 | ISL1208_USR_SECTION_LEN); | |
7e56a7dc HVR |
210 | } |
211 | ||
cf044f0e RM |
212 | static int |
213 | isl1208_rtc_toggle_alarm(struct i2c_client *client, int enable) | |
214 | { | |
215 | int icr = i2c_smbus_read_byte_data(client, ISL1208_REG_INT); | |
216 | ||
217 | if (icr < 0) { | |
218 | dev_err(&client->dev, "%s: reading INT failed\n", __func__); | |
219 | return icr; | |
220 | } | |
221 | ||
222 | if (enable) | |
223 | icr |= ISL1208_REG_INT_ALME | ISL1208_REG_INT_IM; | |
224 | else | |
225 | icr &= ~(ISL1208_REG_INT_ALME | ISL1208_REG_INT_IM); | |
226 | ||
227 | icr = i2c_smbus_write_byte_data(client, ISL1208_REG_INT, icr); | |
228 | if (icr < 0) { | |
229 | dev_err(&client->dev, "%s: writing INT failed\n", __func__); | |
230 | return icr; | |
231 | } | |
232 | ||
233 | return 0; | |
234 | } | |
235 | ||
9edae7bc AZ |
236 | static int |
237 | isl1208_rtc_proc(struct device *dev, struct seq_file *seq) | |
7e56a7dc HVR |
238 | { |
239 | struct i2c_client *const client = to_i2c_client(dev); | |
240 | int sr, dtr, atr, usr; | |
241 | ||
242 | sr = isl1208_i2c_get_sr(client); | |
243 | if (sr < 0) { | |
244 | dev_err(&client->dev, "%s: reading SR failed\n", __func__); | |
245 | return sr; | |
246 | } | |
247 | ||
248 | seq_printf(seq, "status_reg\t:%s%s%s%s%s%s (0x%.2x)\n", | |
249 | (sr & ISL1208_REG_SR_RTCF) ? " RTCF" : "", | |
250 | (sr & ISL1208_REG_SR_BAT) ? " BAT" : "", | |
251 | (sr & ISL1208_REG_SR_ALM) ? " ALM" : "", | |
252 | (sr & ISL1208_REG_SR_WRTC) ? " WRTC" : "", | |
253 | (sr & ISL1208_REG_SR_XTOSCB) ? " XTOSCB" : "", | |
9edae7bc | 254 | (sr & ISL1208_REG_SR_ARST) ? " ARST" : "", sr); |
7e56a7dc HVR |
255 | |
256 | seq_printf(seq, "batt_status\t: %s\n", | |
257 | (sr & ISL1208_REG_SR_RTCF) ? "bad" : "okay"); | |
258 | ||
259 | dtr = isl1208_i2c_get_dtr(client); | |
9edae7bc | 260 | if (dtr >= 0 - 1) |
7e56a7dc HVR |
261 | seq_printf(seq, "digital_trim\t: %d ppm\n", dtr); |
262 | ||
263 | atr = isl1208_i2c_get_atr(client); | |
264 | if (atr >= 0) | |
265 | seq_printf(seq, "analog_trim\t: %d.%.2d pF\n", | |
9edae7bc | 266 | atr >> 2, (atr & 0x3) * 25); |
7e56a7dc HVR |
267 | |
268 | usr = isl1208_i2c_get_usr(client); | |
269 | if (usr >= 0) | |
270 | seq_printf(seq, "user_data\t: 0x%.4x\n", usr); | |
271 | ||
272 | return 0; | |
273 | } | |
274 | ||
9edae7bc AZ |
275 | static int |
276 | isl1208_i2c_read_time(struct i2c_client *client, struct rtc_time *tm) | |
7e56a7dc HVR |
277 | { |
278 | int sr; | |
279 | u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, }; | |
280 | ||
281 | sr = isl1208_i2c_get_sr(client); | |
282 | if (sr < 0) { | |
283 | dev_err(&client->dev, "%s: reading SR failed\n", __func__); | |
284 | return -EIO; | |
285 | } | |
286 | ||
287 | sr = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN); | |
288 | if (sr < 0) { | |
289 | dev_err(&client->dev, "%s: reading RTC section failed\n", | |
290 | __func__); | |
291 | return sr; | |
292 | } | |
293 | ||
fe20ba70 AB |
294 | tm->tm_sec = bcd2bin(regs[ISL1208_REG_SC]); |
295 | tm->tm_min = bcd2bin(regs[ISL1208_REG_MN]); | |
9edae7bc AZ |
296 | |
297 | /* HR field has a more complex interpretation */ | |
298 | { | |
7e56a7dc | 299 | const u8 _hr = regs[ISL1208_REG_HR]; |
9edae7bc | 300 | if (_hr & ISL1208_REG_HR_MIL) /* 24h format */ |
fe20ba70 | 301 | tm->tm_hour = bcd2bin(_hr & 0x3f); |
9edae7bc AZ |
302 | else { |
303 | /* 12h format */ | |
fe20ba70 | 304 | tm->tm_hour = bcd2bin(_hr & 0x1f); |
9edae7bc | 305 | if (_hr & ISL1208_REG_HR_PM) /* PM flag set */ |
7e56a7dc HVR |
306 | tm->tm_hour += 12; |
307 | } | |
308 | } | |
309 | ||
fe20ba70 AB |
310 | tm->tm_mday = bcd2bin(regs[ISL1208_REG_DT]); |
311 | tm->tm_mon = bcd2bin(regs[ISL1208_REG_MO]) - 1; /* rtc starts at 1 */ | |
312 | tm->tm_year = bcd2bin(regs[ISL1208_REG_YR]) + 100; | |
313 | tm->tm_wday = bcd2bin(regs[ISL1208_REG_DW]); | |
7e56a7dc HVR |
314 | |
315 | return 0; | |
316 | } | |
317 | ||
9edae7bc AZ |
318 | static int |
319 | isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm) | |
7e56a7dc HVR |
320 | { |
321 | struct rtc_time *const tm = &alarm->time; | |
322 | u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, }; | |
cf044f0e | 323 | int icr, yr, sr = isl1208_i2c_get_sr(client); |
7e56a7dc | 324 | |
7e56a7dc HVR |
325 | if (sr < 0) { |
326 | dev_err(&client->dev, "%s: reading SR failed\n", __func__); | |
327 | return sr; | |
328 | } | |
329 | ||
330 | sr = isl1208_i2c_read_regs(client, ISL1208_REG_SCA, regs, | |
9edae7bc | 331 | ISL1208_ALARM_SECTION_LEN); |
7e56a7dc HVR |
332 | if (sr < 0) { |
333 | dev_err(&client->dev, "%s: reading alarm section failed\n", | |
334 | __func__); | |
335 | return sr; | |
336 | } | |
337 | ||
338 | /* MSB of each alarm register is an enable bit */ | |
fe20ba70 AB |
339 | tm->tm_sec = bcd2bin(regs[ISL1208_REG_SCA - ISL1208_REG_SCA] & 0x7f); |
340 | tm->tm_min = bcd2bin(regs[ISL1208_REG_MNA - ISL1208_REG_SCA] & 0x7f); | |
341 | tm->tm_hour = bcd2bin(regs[ISL1208_REG_HRA - ISL1208_REG_SCA] & 0x3f); | |
342 | tm->tm_mday = bcd2bin(regs[ISL1208_REG_DTA - ISL1208_REG_SCA] & 0x3f); | |
9edae7bc | 343 | tm->tm_mon = |
fe20ba70 AB |
344 | bcd2bin(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1; |
345 | tm->tm_wday = bcd2bin(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03); | |
7e56a7dc | 346 | |
cf044f0e RM |
347 | /* The alarm doesn't store the year so get it from the rtc section */ |
348 | yr = i2c_smbus_read_byte_data(client, ISL1208_REG_YR); | |
349 | if (yr < 0) { | |
350 | dev_err(&client->dev, "%s: reading RTC YR failed\n", __func__); | |
351 | return yr; | |
352 | } | |
353 | tm->tm_year = bcd2bin(yr) + 100; | |
354 | ||
355 | icr = i2c_smbus_read_byte_data(client, ISL1208_REG_INT); | |
356 | if (icr < 0) { | |
357 | dev_err(&client->dev, "%s: reading INT failed\n", __func__); | |
358 | return icr; | |
359 | } | |
360 | alarm->enabled = !!(icr & ISL1208_REG_INT_ALME); | |
361 | ||
362 | return 0; | |
363 | } | |
364 | ||
365 | static int | |
366 | isl1208_i2c_set_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm) | |
367 | { | |
368 | struct rtc_time *alarm_tm = &alarm->time; | |
369 | u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, }; | |
370 | const int offs = ISL1208_REG_SCA; | |
cf044f0e RM |
371 | struct rtc_time rtc_tm; |
372 | int err, enable; | |
373 | ||
374 | err = isl1208_i2c_read_time(client, &rtc_tm); | |
cf044f0e RM |
375 | if (err) |
376 | return err; | |
377 | ||
378 | /* If the alarm time is before the current time disable the alarm */ | |
f118db1e | 379 | if (!alarm->enabled || rtc_tm_sub(alarm_tm, &rtc_tm) <= 0) |
cf044f0e RM |
380 | enable = 0x00; |
381 | else | |
382 | enable = 0x80; | |
383 | ||
384 | /* Program the alarm and enable it for each setting */ | |
385 | regs[ISL1208_REG_SCA - offs] = bin2bcd(alarm_tm->tm_sec) | enable; | |
386 | regs[ISL1208_REG_MNA - offs] = bin2bcd(alarm_tm->tm_min) | enable; | |
387 | regs[ISL1208_REG_HRA - offs] = bin2bcd(alarm_tm->tm_hour) | | |
388 | ISL1208_REG_HR_MIL | enable; | |
389 | ||
390 | regs[ISL1208_REG_DTA - offs] = bin2bcd(alarm_tm->tm_mday) | enable; | |
391 | regs[ISL1208_REG_MOA - offs] = bin2bcd(alarm_tm->tm_mon + 1) | enable; | |
392 | regs[ISL1208_REG_DWA - offs] = bin2bcd(alarm_tm->tm_wday & 7) | enable; | |
393 | ||
394 | /* write ALARM registers */ | |
395 | err = isl1208_i2c_set_regs(client, offs, regs, | |
396 | ISL1208_ALARM_SECTION_LEN); | |
397 | if (err < 0) { | |
398 | dev_err(&client->dev, "%s: writing ALARM section failed\n", | |
399 | __func__); | |
400 | return err; | |
401 | } | |
402 | ||
403 | err = isl1208_rtc_toggle_alarm(client, enable); | |
404 | if (err) | |
405 | return err; | |
406 | ||
7e56a7dc HVR |
407 | return 0; |
408 | } | |
409 | ||
9edae7bc AZ |
410 | static int |
411 | isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm) | |
7e56a7dc HVR |
412 | { |
413 | return isl1208_i2c_read_time(to_i2c_client(dev), tm); | |
414 | } | |
415 | ||
9edae7bc AZ |
416 | static int |
417 | isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm) | |
7e56a7dc HVR |
418 | { |
419 | int sr; | |
420 | u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, }; | |
421 | ||
cc6c2ca3 CE |
422 | /* The clock has an 8 bit wide bcd-coded register (they never learn) |
423 | * for the year. tm_year is an offset from 1900 and we are interested | |
424 | * in the 2000-2099 range, so any value less than 100 is invalid. | |
425 | */ | |
426 | if (tm->tm_year < 100) | |
427 | return -EINVAL; | |
428 | ||
fe20ba70 AB |
429 | regs[ISL1208_REG_SC] = bin2bcd(tm->tm_sec); |
430 | regs[ISL1208_REG_MN] = bin2bcd(tm->tm_min); | |
431 | regs[ISL1208_REG_HR] = bin2bcd(tm->tm_hour) | ISL1208_REG_HR_MIL; | |
7e56a7dc | 432 | |
fe20ba70 AB |
433 | regs[ISL1208_REG_DT] = bin2bcd(tm->tm_mday); |
434 | regs[ISL1208_REG_MO] = bin2bcd(tm->tm_mon + 1); | |
435 | regs[ISL1208_REG_YR] = bin2bcd(tm->tm_year - 100); | |
7e56a7dc | 436 | |
fe20ba70 | 437 | regs[ISL1208_REG_DW] = bin2bcd(tm->tm_wday & 7); |
7e56a7dc HVR |
438 | |
439 | sr = isl1208_i2c_get_sr(client); | |
440 | if (sr < 0) { | |
441 | dev_err(&client->dev, "%s: reading SR failed\n", __func__); | |
442 | return sr; | |
443 | } | |
444 | ||
445 | /* set WRTC */ | |
9edae7bc | 446 | sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, |
7e56a7dc HVR |
447 | sr | ISL1208_REG_SR_WRTC); |
448 | if (sr < 0) { | |
449 | dev_err(&client->dev, "%s: writing SR failed\n", __func__); | |
450 | return sr; | |
451 | } | |
452 | ||
453 | /* write RTC registers */ | |
454 | sr = isl1208_i2c_set_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN); | |
455 | if (sr < 0) { | |
456 | dev_err(&client->dev, "%s: writing RTC section failed\n", | |
457 | __func__); | |
458 | return sr; | |
459 | } | |
460 | ||
461 | /* clear WRTC again */ | |
9edae7bc | 462 | sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, |
7e56a7dc HVR |
463 | sr & ~ISL1208_REG_SR_WRTC); |
464 | if (sr < 0) { | |
465 | dev_err(&client->dev, "%s: writing SR failed\n", __func__); | |
466 | return sr; | |
467 | } | |
468 | ||
469 | return 0; | |
470 | } | |
471 | ||
472 | ||
9edae7bc AZ |
473 | static int |
474 | isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm) | |
7e56a7dc HVR |
475 | { |
476 | return isl1208_i2c_set_time(to_i2c_client(dev), tm); | |
477 | } | |
478 | ||
9edae7bc AZ |
479 | static int |
480 | isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) | |
7e56a7dc HVR |
481 | { |
482 | return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm); | |
483 | } | |
484 | ||
cf044f0e RM |
485 | static int |
486 | isl1208_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) | |
487 | { | |
488 | return isl1208_i2c_set_alarm(to_i2c_client(dev), alarm); | |
489 | } | |
490 | ||
491 | static irqreturn_t | |
492 | isl1208_rtc_interrupt(int irq, void *data) | |
493 | { | |
494 | unsigned long timeout = jiffies + msecs_to_jiffies(1000); | |
495 | struct i2c_client *client = data; | |
72fca4a4 | 496 | struct rtc_device *rtc = i2c_get_clientdata(client); |
cf044f0e RM |
497 | int handled = 0, sr, err; |
498 | ||
499 | /* | |
500 | * I2C reads get NAK'ed if we read straight away after an interrupt? | |
501 | * Using a mdelay/msleep didn't seem to help either, so we work around | |
502 | * this by continually trying to read the register for a short time. | |
503 | */ | |
504 | while (1) { | |
505 | sr = isl1208_i2c_get_sr(client); | |
506 | if (sr >= 0) | |
507 | break; | |
508 | ||
509 | if (time_after(jiffies, timeout)) { | |
510 | dev_err(&client->dev, "%s: reading SR failed\n", | |
511 | __func__); | |
512 | return sr; | |
513 | } | |
514 | } | |
515 | ||
516 | if (sr & ISL1208_REG_SR_ALM) { | |
517 | dev_dbg(&client->dev, "alarm!\n"); | |
518 | ||
72fca4a4 JL |
519 | rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF); |
520 | ||
cf044f0e RM |
521 | /* Clear the alarm */ |
522 | sr &= ~ISL1208_REG_SR_ALM; | |
523 | sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, sr); | |
524 | if (sr < 0) | |
525 | dev_err(&client->dev, "%s: writing SR failed\n", | |
526 | __func__); | |
527 | else | |
528 | handled = 1; | |
529 | ||
530 | /* Disable the alarm */ | |
531 | err = isl1208_rtc_toggle_alarm(client, 0); | |
532 | if (err) | |
533 | return err; | |
534 | } | |
535 | ||
536 | return handled ? IRQ_HANDLED : IRQ_NONE; | |
537 | } | |
538 | ||
ff8371ac | 539 | static const struct rtc_class_ops isl1208_rtc_ops = { |
9edae7bc AZ |
540 | .proc = isl1208_rtc_proc, |
541 | .read_time = isl1208_rtc_read_time, | |
542 | .set_time = isl1208_rtc_set_time, | |
543 | .read_alarm = isl1208_rtc_read_alarm, | |
cf044f0e | 544 | .set_alarm = isl1208_rtc_set_alarm, |
7e56a7dc HVR |
545 | }; |
546 | ||
547 | /* sysfs interface */ | |
548 | ||
9edae7bc AZ |
549 | static ssize_t |
550 | isl1208_sysfs_show_atrim(struct device *dev, | |
551 | struct device_attribute *attr, char *buf) | |
7e56a7dc | 552 | { |
9edae7bc | 553 | int atr = isl1208_i2c_get_atr(to_i2c_client(dev)); |
7e56a7dc HVR |
554 | if (atr < 0) |
555 | return atr; | |
556 | ||
9edae7bc | 557 | return sprintf(buf, "%d.%.2d pF\n", atr >> 2, (atr & 0x3) * 25); |
7e56a7dc | 558 | } |
9edae7bc | 559 | |
7e56a7dc HVR |
560 | static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL); |
561 | ||
9edae7bc AZ |
562 | static ssize_t |
563 | isl1208_sysfs_show_dtrim(struct device *dev, | |
564 | struct device_attribute *attr, char *buf) | |
7e56a7dc | 565 | { |
9edae7bc | 566 | int dtr = isl1208_i2c_get_dtr(to_i2c_client(dev)); |
7e56a7dc HVR |
567 | if (dtr < 0) |
568 | return dtr; | |
569 | ||
570 | return sprintf(buf, "%d ppm\n", dtr); | |
571 | } | |
9edae7bc | 572 | |
7e56a7dc HVR |
573 | static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL); |
574 | ||
9edae7bc AZ |
575 | static ssize_t |
576 | isl1208_sysfs_show_usr(struct device *dev, | |
577 | struct device_attribute *attr, char *buf) | |
7e56a7dc | 578 | { |
9edae7bc | 579 | int usr = isl1208_i2c_get_usr(to_i2c_client(dev)); |
7e56a7dc HVR |
580 | if (usr < 0) |
581 | return usr; | |
582 | ||
583 | return sprintf(buf, "0x%.4x\n", usr); | |
584 | } | |
585 | ||
9edae7bc AZ |
586 | static ssize_t |
587 | isl1208_sysfs_store_usr(struct device *dev, | |
588 | struct device_attribute *attr, | |
589 | const char *buf, size_t count) | |
7e56a7dc HVR |
590 | { |
591 | int usr = -1; | |
592 | ||
593 | if (buf[0] == '0' && (buf[1] == 'x' || buf[1] == 'X')) { | |
594 | if (sscanf(buf, "%x", &usr) != 1) | |
595 | return -EINVAL; | |
596 | } else { | |
597 | if (sscanf(buf, "%d", &usr) != 1) | |
598 | return -EINVAL; | |
599 | } | |
600 | ||
601 | if (usr < 0 || usr > 0xffff) | |
602 | return -EINVAL; | |
603 | ||
604 | return isl1208_i2c_set_usr(to_i2c_client(dev), usr) ? -EIO : count; | |
605 | } | |
9edae7bc | 606 | |
7e56a7dc HVR |
607 | static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr, |
608 | isl1208_sysfs_store_usr); | |
609 | ||
e17ab5cb HS |
610 | static struct attribute *isl1208_rtc_attrs[] = { |
611 | &dev_attr_atrim.attr, | |
612 | &dev_attr_dtrim.attr, | |
613 | &dev_attr_usr.attr, | |
614 | NULL | |
615 | }; | |
9edae7bc | 616 | |
e17ab5cb HS |
617 | static const struct attribute_group isl1208_rtc_sysfs_files = { |
618 | .attrs = isl1208_rtc_attrs, | |
619 | }; | |
9edae7bc AZ |
620 | |
621 | static int | |
d2653e92 | 622 | isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id) |
9edae7bc AZ |
623 | { |
624 | int rc = 0; | |
625 | struct rtc_device *rtc; | |
7e56a7dc | 626 | |
9edae7bc AZ |
627 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) |
628 | return -ENODEV; | |
7e56a7dc | 629 | |
9edae7bc AZ |
630 | if (isl1208_i2c_validate_client(client) < 0) |
631 | return -ENODEV; | |
632 | ||
cf044f0e | 633 | if (client->irq > 0) { |
adce8c14 SK |
634 | rc = devm_request_threaded_irq(&client->dev, client->irq, NULL, |
635 | isl1208_rtc_interrupt, | |
7a96f287 | 636 | IRQF_SHARED | IRQF_ONESHOT, |
adce8c14 SK |
637 | isl1208_driver.driver.name, |
638 | client); | |
cf044f0e RM |
639 | if (!rc) { |
640 | device_init_wakeup(&client->dev, 1); | |
641 | enable_irq_wake(client->irq); | |
642 | } else { | |
643 | dev_err(&client->dev, | |
644 | "Unable to request irq %d, no alarm support\n", | |
645 | client->irq); | |
646 | client->irq = 0; | |
647 | } | |
648 | } | |
649 | ||
adce8c14 SK |
650 | rtc = devm_rtc_device_register(&client->dev, isl1208_driver.driver.name, |
651 | &isl1208_rtc_ops, | |
9edae7bc | 652 | THIS_MODULE); |
adce8c14 SK |
653 | if (IS_ERR(rtc)) |
654 | return PTR_ERR(rtc); | |
7e56a7dc | 655 | |
9edae7bc | 656 | i2c_set_clientdata(client, rtc); |
7e56a7dc | 657 | |
9edae7bc | 658 | rc = isl1208_i2c_get_sr(client); |
7e56a7dc | 659 | if (rc < 0) { |
9edae7bc | 660 | dev_err(&client->dev, "reading status failed\n"); |
adce8c14 | 661 | return rc; |
7e56a7dc HVR |
662 | } |
663 | ||
664 | if (rc & ISL1208_REG_SR_RTCF) | |
9edae7bc | 665 | dev_warn(&client->dev, "rtc power failure detected, " |
7e56a7dc HVR |
666 | "please set clock.\n"); |
667 | ||
e17ab5cb | 668 | rc = sysfs_create_group(&client->dev.kobj, &isl1208_rtc_sysfs_files); |
9edae7bc | 669 | if (rc) |
adce8c14 | 670 | return rc; |
7e56a7dc HVR |
671 | |
672 | return 0; | |
7e56a7dc HVR |
673 | } |
674 | ||
675 | static int | |
9edae7bc | 676 | isl1208_remove(struct i2c_client *client) |
7e56a7dc | 677 | { |
e17ab5cb | 678 | sysfs_remove_group(&client->dev.kobj, &isl1208_rtc_sysfs_files); |
7e56a7dc HVR |
679 | |
680 | return 0; | |
681 | } | |
682 | ||
3760f736 JD |
683 | static const struct i2c_device_id isl1208_id[] = { |
684 | { "isl1208", 0 }, | |
5fa44f86 | 685 | { "isl1218", 0 }, |
3760f736 JD |
686 | { } |
687 | }; | |
688 | MODULE_DEVICE_TABLE(i2c, isl1208_id); | |
689 | ||
9edae7bc AZ |
690 | static struct i2c_driver isl1208_driver = { |
691 | .driver = { | |
692 | .name = "rtc-isl1208", | |
693 | }, | |
694 | .probe = isl1208_probe, | |
695 | .remove = isl1208_remove, | |
3760f736 | 696 | .id_table = isl1208_id, |
9edae7bc | 697 | }; |
7e56a7dc | 698 | |
0abc9201 | 699 | module_i2c_driver(isl1208_driver); |
7e56a7dc HVR |
700 | |
701 | MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>"); | |
702 | MODULE_DESCRIPTION("Intersil ISL1208 RTC driver"); | |
703 | MODULE_LICENSE("GPL"); |