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