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