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; | |
373 | unsigned long rtc_secs, alarm_secs; | |
374 | struct rtc_time rtc_tm; | |
375 | int err, enable; | |
376 | ||
377 | err = isl1208_i2c_read_time(client, &rtc_tm); | |
378 | if (err) | |
379 | return err; | |
380 | err = rtc_tm_to_time(&rtc_tm, &rtc_secs); | |
381 | if (err) | |
382 | return err; | |
383 | err = rtc_tm_to_time(alarm_tm, &alarm_secs); | |
384 | if (err) | |
385 | return err; | |
386 | ||
387 | /* If the alarm time is before the current time disable the alarm */ | |
388 | if (!alarm->enabled || alarm_secs <= rtc_secs) | |
389 | enable = 0x00; | |
390 | else | |
391 | enable = 0x80; | |
392 | ||
393 | /* Program the alarm and enable it for each setting */ | |
394 | regs[ISL1208_REG_SCA - offs] = bin2bcd(alarm_tm->tm_sec) | enable; | |
395 | regs[ISL1208_REG_MNA - offs] = bin2bcd(alarm_tm->tm_min) | enable; | |
396 | regs[ISL1208_REG_HRA - offs] = bin2bcd(alarm_tm->tm_hour) | | |
397 | ISL1208_REG_HR_MIL | enable; | |
398 | ||
399 | regs[ISL1208_REG_DTA - offs] = bin2bcd(alarm_tm->tm_mday) | enable; | |
400 | regs[ISL1208_REG_MOA - offs] = bin2bcd(alarm_tm->tm_mon + 1) | enable; | |
401 | regs[ISL1208_REG_DWA - offs] = bin2bcd(alarm_tm->tm_wday & 7) | enable; | |
402 | ||
403 | /* write ALARM registers */ | |
404 | err = isl1208_i2c_set_regs(client, offs, regs, | |
405 | ISL1208_ALARM_SECTION_LEN); | |
406 | if (err < 0) { | |
407 | dev_err(&client->dev, "%s: writing ALARM section failed\n", | |
408 | __func__); | |
409 | return err; | |
410 | } | |
411 | ||
412 | err = isl1208_rtc_toggle_alarm(client, enable); | |
413 | if (err) | |
414 | return err; | |
415 | ||
7e56a7dc HVR |
416 | return 0; |
417 | } | |
418 | ||
9edae7bc AZ |
419 | static int |
420 | isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm) | |
7e56a7dc HVR |
421 | { |
422 | return isl1208_i2c_read_time(to_i2c_client(dev), tm); | |
423 | } | |
424 | ||
9edae7bc AZ |
425 | static int |
426 | isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm) | |
7e56a7dc HVR |
427 | { |
428 | int sr; | |
429 | u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, }; | |
430 | ||
cc6c2ca3 CE |
431 | /* The clock has an 8 bit wide bcd-coded register (they never learn) |
432 | * for the year. tm_year is an offset from 1900 and we are interested | |
433 | * in the 2000-2099 range, so any value less than 100 is invalid. | |
434 | */ | |
435 | if (tm->tm_year < 100) | |
436 | return -EINVAL; | |
437 | ||
fe20ba70 AB |
438 | regs[ISL1208_REG_SC] = bin2bcd(tm->tm_sec); |
439 | regs[ISL1208_REG_MN] = bin2bcd(tm->tm_min); | |
440 | regs[ISL1208_REG_HR] = bin2bcd(tm->tm_hour) | ISL1208_REG_HR_MIL; | |
7e56a7dc | 441 | |
fe20ba70 AB |
442 | regs[ISL1208_REG_DT] = bin2bcd(tm->tm_mday); |
443 | regs[ISL1208_REG_MO] = bin2bcd(tm->tm_mon + 1); | |
444 | regs[ISL1208_REG_YR] = bin2bcd(tm->tm_year - 100); | |
7e56a7dc | 445 | |
fe20ba70 | 446 | regs[ISL1208_REG_DW] = bin2bcd(tm->tm_wday & 7); |
7e56a7dc HVR |
447 | |
448 | sr = isl1208_i2c_get_sr(client); | |
449 | if (sr < 0) { | |
450 | dev_err(&client->dev, "%s: reading SR failed\n", __func__); | |
451 | return sr; | |
452 | } | |
453 | ||
454 | /* set WRTC */ | |
9edae7bc | 455 | sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, |
7e56a7dc HVR |
456 | sr | ISL1208_REG_SR_WRTC); |
457 | if (sr < 0) { | |
458 | dev_err(&client->dev, "%s: writing SR failed\n", __func__); | |
459 | return sr; | |
460 | } | |
461 | ||
462 | /* write RTC registers */ | |
463 | sr = isl1208_i2c_set_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN); | |
464 | if (sr < 0) { | |
465 | dev_err(&client->dev, "%s: writing RTC section failed\n", | |
466 | __func__); | |
467 | return sr; | |
468 | } | |
469 | ||
470 | /* clear WRTC again */ | |
9edae7bc | 471 | sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, |
7e56a7dc HVR |
472 | sr & ~ISL1208_REG_SR_WRTC); |
473 | if (sr < 0) { | |
474 | dev_err(&client->dev, "%s: writing SR failed\n", __func__); | |
475 | return sr; | |
476 | } | |
477 | ||
478 | return 0; | |
479 | } | |
480 | ||
481 | ||
9edae7bc AZ |
482 | static int |
483 | isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm) | |
7e56a7dc HVR |
484 | { |
485 | return isl1208_i2c_set_time(to_i2c_client(dev), tm); | |
486 | } | |
487 | ||
9edae7bc AZ |
488 | static int |
489 | isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) | |
7e56a7dc HVR |
490 | { |
491 | return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm); | |
492 | } | |
493 | ||
cf044f0e RM |
494 | static int |
495 | isl1208_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) | |
496 | { | |
497 | return isl1208_i2c_set_alarm(to_i2c_client(dev), alarm); | |
498 | } | |
499 | ||
500 | static irqreturn_t | |
501 | isl1208_rtc_interrupt(int irq, void *data) | |
502 | { | |
503 | unsigned long timeout = jiffies + msecs_to_jiffies(1000); | |
504 | struct i2c_client *client = data; | |
72fca4a4 | 505 | struct rtc_device *rtc = i2c_get_clientdata(client); |
cf044f0e RM |
506 | int handled = 0, sr, err; |
507 | ||
508 | /* | |
509 | * I2C reads get NAK'ed if we read straight away after an interrupt? | |
510 | * Using a mdelay/msleep didn't seem to help either, so we work around | |
511 | * this by continually trying to read the register for a short time. | |
512 | */ | |
513 | while (1) { | |
514 | sr = isl1208_i2c_get_sr(client); | |
515 | if (sr >= 0) | |
516 | break; | |
517 | ||
518 | if (time_after(jiffies, timeout)) { | |
519 | dev_err(&client->dev, "%s: reading SR failed\n", | |
520 | __func__); | |
521 | return sr; | |
522 | } | |
523 | } | |
524 | ||
525 | if (sr & ISL1208_REG_SR_ALM) { | |
526 | dev_dbg(&client->dev, "alarm!\n"); | |
527 | ||
72fca4a4 JL |
528 | rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF); |
529 | ||
cf044f0e RM |
530 | /* Clear the alarm */ |
531 | sr &= ~ISL1208_REG_SR_ALM; | |
532 | sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, sr); | |
533 | if (sr < 0) | |
534 | dev_err(&client->dev, "%s: writing SR failed\n", | |
535 | __func__); | |
536 | else | |
537 | handled = 1; | |
538 | ||
539 | /* Disable the alarm */ | |
540 | err = isl1208_rtc_toggle_alarm(client, 0); | |
541 | if (err) | |
542 | return err; | |
543 | } | |
544 | ||
545 | return handled ? IRQ_HANDLED : IRQ_NONE; | |
546 | } | |
547 | ||
ff8371ac | 548 | static const struct rtc_class_ops isl1208_rtc_ops = { |
9edae7bc AZ |
549 | .proc = isl1208_rtc_proc, |
550 | .read_time = isl1208_rtc_read_time, | |
551 | .set_time = isl1208_rtc_set_time, | |
552 | .read_alarm = isl1208_rtc_read_alarm, | |
cf044f0e | 553 | .set_alarm = isl1208_rtc_set_alarm, |
7e56a7dc HVR |
554 | }; |
555 | ||
556 | /* sysfs interface */ | |
557 | ||
9edae7bc AZ |
558 | static ssize_t |
559 | isl1208_sysfs_show_atrim(struct device *dev, | |
560 | struct device_attribute *attr, char *buf) | |
7e56a7dc | 561 | { |
9edae7bc | 562 | int atr = isl1208_i2c_get_atr(to_i2c_client(dev)); |
7e56a7dc HVR |
563 | if (atr < 0) |
564 | return atr; | |
565 | ||
9edae7bc | 566 | return sprintf(buf, "%d.%.2d pF\n", atr >> 2, (atr & 0x3) * 25); |
7e56a7dc | 567 | } |
9edae7bc | 568 | |
7e56a7dc HVR |
569 | static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL); |
570 | ||
9edae7bc AZ |
571 | static ssize_t |
572 | isl1208_sysfs_show_dtrim(struct device *dev, | |
573 | struct device_attribute *attr, char *buf) | |
7e56a7dc | 574 | { |
9edae7bc | 575 | int dtr = isl1208_i2c_get_dtr(to_i2c_client(dev)); |
7e56a7dc HVR |
576 | if (dtr < 0) |
577 | return dtr; | |
578 | ||
579 | return sprintf(buf, "%d ppm\n", dtr); | |
580 | } | |
9edae7bc | 581 | |
7e56a7dc HVR |
582 | static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL); |
583 | ||
9edae7bc AZ |
584 | static ssize_t |
585 | isl1208_sysfs_show_usr(struct device *dev, | |
586 | struct device_attribute *attr, char *buf) | |
7e56a7dc | 587 | { |
9edae7bc | 588 | int usr = isl1208_i2c_get_usr(to_i2c_client(dev)); |
7e56a7dc HVR |
589 | if (usr < 0) |
590 | return usr; | |
591 | ||
592 | return sprintf(buf, "0x%.4x\n", usr); | |
593 | } | |
594 | ||
9edae7bc AZ |
595 | static ssize_t |
596 | isl1208_sysfs_store_usr(struct device *dev, | |
597 | struct device_attribute *attr, | |
598 | const char *buf, size_t count) | |
7e56a7dc HVR |
599 | { |
600 | int usr = -1; | |
601 | ||
602 | if (buf[0] == '0' && (buf[1] == 'x' || buf[1] == 'X')) { | |
603 | if (sscanf(buf, "%x", &usr) != 1) | |
604 | return -EINVAL; | |
605 | } else { | |
606 | if (sscanf(buf, "%d", &usr) != 1) | |
607 | return -EINVAL; | |
608 | } | |
609 | ||
610 | if (usr < 0 || usr > 0xffff) | |
611 | return -EINVAL; | |
612 | ||
613 | return isl1208_i2c_set_usr(to_i2c_client(dev), usr) ? -EIO : count; | |
614 | } | |
9edae7bc | 615 | |
7e56a7dc HVR |
616 | static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr, |
617 | isl1208_sysfs_store_usr); | |
618 | ||
e17ab5cb HS |
619 | static struct attribute *isl1208_rtc_attrs[] = { |
620 | &dev_attr_atrim.attr, | |
621 | &dev_attr_dtrim.attr, | |
622 | &dev_attr_usr.attr, | |
623 | NULL | |
624 | }; | |
9edae7bc | 625 | |
e17ab5cb HS |
626 | static const struct attribute_group isl1208_rtc_sysfs_files = { |
627 | .attrs = isl1208_rtc_attrs, | |
628 | }; | |
9edae7bc AZ |
629 | |
630 | static int | |
d2653e92 | 631 | isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id) |
9edae7bc AZ |
632 | { |
633 | int rc = 0; | |
634 | struct rtc_device *rtc; | |
7e56a7dc | 635 | |
9edae7bc AZ |
636 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) |
637 | return -ENODEV; | |
7e56a7dc | 638 | |
9edae7bc AZ |
639 | if (isl1208_i2c_validate_client(client) < 0) |
640 | return -ENODEV; | |
641 | ||
642 | dev_info(&client->dev, | |
7e56a7dc HVR |
643 | "chip found, driver version " DRV_VERSION "\n"); |
644 | ||
cf044f0e | 645 | if (client->irq > 0) { |
adce8c14 SK |
646 | rc = devm_request_threaded_irq(&client->dev, client->irq, NULL, |
647 | isl1208_rtc_interrupt, | |
648 | IRQF_SHARED, | |
649 | isl1208_driver.driver.name, | |
650 | client); | |
cf044f0e RM |
651 | if (!rc) { |
652 | device_init_wakeup(&client->dev, 1); | |
653 | enable_irq_wake(client->irq); | |
654 | } else { | |
655 | dev_err(&client->dev, | |
656 | "Unable to request irq %d, no alarm support\n", | |
657 | client->irq); | |
658 | client->irq = 0; | |
659 | } | |
660 | } | |
661 | ||
adce8c14 SK |
662 | rtc = devm_rtc_device_register(&client->dev, isl1208_driver.driver.name, |
663 | &isl1208_rtc_ops, | |
9edae7bc | 664 | THIS_MODULE); |
adce8c14 SK |
665 | if (IS_ERR(rtc)) |
666 | return PTR_ERR(rtc); | |
7e56a7dc | 667 | |
9edae7bc | 668 | i2c_set_clientdata(client, rtc); |
7e56a7dc | 669 | |
9edae7bc | 670 | rc = isl1208_i2c_get_sr(client); |
7e56a7dc | 671 | if (rc < 0) { |
9edae7bc | 672 | dev_err(&client->dev, "reading status failed\n"); |
adce8c14 | 673 | return rc; |
7e56a7dc HVR |
674 | } |
675 | ||
676 | if (rc & ISL1208_REG_SR_RTCF) | |
9edae7bc | 677 | dev_warn(&client->dev, "rtc power failure detected, " |
7e56a7dc HVR |
678 | "please set clock.\n"); |
679 | ||
e17ab5cb | 680 | rc = sysfs_create_group(&client->dev.kobj, &isl1208_rtc_sysfs_files); |
9edae7bc | 681 | if (rc) |
adce8c14 | 682 | return rc; |
7e56a7dc HVR |
683 | |
684 | return 0; | |
7e56a7dc HVR |
685 | } |
686 | ||
687 | static int | |
9edae7bc | 688 | isl1208_remove(struct i2c_client *client) |
7e56a7dc | 689 | { |
e17ab5cb | 690 | sysfs_remove_group(&client->dev.kobj, &isl1208_rtc_sysfs_files); |
7e56a7dc HVR |
691 | |
692 | return 0; | |
693 | } | |
694 | ||
3760f736 JD |
695 | static const struct i2c_device_id isl1208_id[] = { |
696 | { "isl1208", 0 }, | |
5fa44f86 | 697 | { "isl1218", 0 }, |
3760f736 JD |
698 | { } |
699 | }; | |
700 | MODULE_DEVICE_TABLE(i2c, isl1208_id); | |
701 | ||
9edae7bc AZ |
702 | static struct i2c_driver isl1208_driver = { |
703 | .driver = { | |
704 | .name = "rtc-isl1208", | |
705 | }, | |
706 | .probe = isl1208_probe, | |
707 | .remove = isl1208_remove, | |
3760f736 | 708 | .id_table = isl1208_id, |
9edae7bc | 709 | }; |
7e56a7dc | 710 | |
0abc9201 | 711 | module_i2c_driver(isl1208_driver); |
7e56a7dc HVR |
712 | |
713 | MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>"); | |
714 | MODULE_DESCRIPTION("Intersil ISL1208 RTC driver"); | |
715 | MODULE_LICENSE("GPL"); | |
716 | MODULE_VERSION(DRV_VERSION); |