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