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 |
9edae7bc | 42 | #define ISL1208_REG_09 0x09 /* reserved */ |
7e56a7dc HVR |
43 | #define ISL1208_REG_ATR 0x0a |
44 | #define ISL1208_REG_DTR 0x0b | |
45 | ||
46 | /* alarm section */ | |
47 | #define ISL1208_REG_SCA 0x0c | |
48 | #define ISL1208_REG_MNA 0x0d | |
49 | #define ISL1208_REG_HRA 0x0e | |
50 | #define ISL1208_REG_DTA 0x0f | |
51 | #define ISL1208_REG_MOA 0x10 | |
52 | #define ISL1208_REG_DWA 0x11 | |
53 | #define ISL1208_ALARM_SECTION_LEN 6 | |
54 | ||
55 | /* user section */ | |
56 | #define ISL1208_REG_USR1 0x12 | |
57 | #define ISL1208_REG_USR2 0x13 | |
58 | #define ISL1208_USR_SECTION_LEN 2 | |
59 | ||
9edae7bc | 60 | static struct i2c_driver isl1208_driver; |
7e56a7dc HVR |
61 | |
62 | /* block read */ | |
63 | static int | |
64 | isl1208_i2c_read_regs(struct i2c_client *client, u8 reg, u8 buf[], | |
9edae7bc | 65 | unsigned len) |
7e56a7dc HVR |
66 | { |
67 | u8 reg_addr[1] = { reg }; | |
68 | struct i2c_msg msgs[2] = { | |
9edae7bc AZ |
69 | {client->addr, 0, sizeof(reg_addr), reg_addr} |
70 | , | |
71 | {client->addr, I2C_M_RD, len, buf} | |
7e56a7dc HVR |
72 | }; |
73 | int ret; | |
74 | ||
7e56a7dc HVR |
75 | BUG_ON(reg > ISL1208_REG_USR2); |
76 | BUG_ON(reg + len > ISL1208_REG_USR2 + 1); | |
77 | ||
78 | ret = i2c_transfer(client->adapter, msgs, 2); | |
79 | if (ret > 0) | |
80 | ret = 0; | |
81 | return ret; | |
82 | } | |
83 | ||
84 | /* block write */ | |
85 | static int | |
86 | isl1208_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[], | |
9edae7bc | 87 | unsigned len) |
7e56a7dc HVR |
88 | { |
89 | u8 i2c_buf[ISL1208_REG_USR2 + 2]; | |
90 | struct i2c_msg msgs[1] = { | |
9edae7bc | 91 | {client->addr, 0, len + 1, i2c_buf} |
7e56a7dc HVR |
92 | }; |
93 | int ret; | |
94 | ||
7e56a7dc HVR |
95 | BUG_ON(reg > ISL1208_REG_USR2); |
96 | BUG_ON(reg + len > ISL1208_REG_USR2 + 1); | |
97 | ||
98 | i2c_buf[0] = reg; | |
99 | memcpy(&i2c_buf[1], &buf[0], len); | |
100 | ||
101 | ret = i2c_transfer(client->adapter, msgs, 1); | |
102 | if (ret > 0) | |
103 | ret = 0; | |
104 | return ret; | |
105 | } | |
106 | ||
107 | /* simple check to see wether we have a isl1208 */ | |
9edae7bc AZ |
108 | static int |
109 | isl1208_i2c_validate_client(struct i2c_client *client) | |
7e56a7dc HVR |
110 | { |
111 | u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, }; | |
112 | u8 zero_mask[ISL1208_RTC_SECTION_LEN] = { | |
113 | 0x80, 0x80, 0x40, 0xc0, 0xe0, 0x00, 0xf8 | |
114 | }; | |
115 | int i; | |
116 | int ret; | |
117 | ||
118 | ret = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN); | |
119 | if (ret < 0) | |
120 | return ret; | |
121 | ||
122 | for (i = 0; i < ISL1208_RTC_SECTION_LEN; ++i) { | |
9edae7bc | 123 | if (regs[i] & zero_mask[i]) /* check if bits are cleared */ |
7e56a7dc HVR |
124 | return -ENODEV; |
125 | } | |
126 | ||
127 | return 0; | |
128 | } | |
129 | ||
9edae7bc AZ |
130 | static int |
131 | isl1208_i2c_get_sr(struct i2c_client *client) | |
7e56a7dc | 132 | { |
9edae7bc AZ |
133 | int sr = i2c_smbus_read_byte_data(client, ISL1208_REG_SR); |
134 | if (sr < 0) | |
135 | return -EIO; | |
136 | ||
137 | return sr; | |
7e56a7dc HVR |
138 | } |
139 | ||
9edae7bc AZ |
140 | static int |
141 | isl1208_i2c_get_atr(struct i2c_client *client) | |
7e56a7dc HVR |
142 | { |
143 | int atr = i2c_smbus_read_byte_data(client, ISL1208_REG_ATR); | |
7e56a7dc | 144 | if (atr < 0) |
9edae7bc | 145 | return atr; |
7e56a7dc HVR |
146 | |
147 | /* The 6bit value in the ATR register controls the load | |
148 | * capacitance C_load * in steps of 0.25pF | |
149 | * | |
150 | * bit (1<<5) of the ATR register is inverted | |
151 | * | |
152 | * C_load(ATR=0x20) = 4.50pF | |
153 | * C_load(ATR=0x00) = 12.50pF | |
154 | * C_load(ATR=0x1f) = 20.25pF | |
155 | * | |
156 | */ | |
157 | ||
9edae7bc AZ |
158 | atr &= 0x3f; /* mask out lsb */ |
159 | atr ^= 1 << 5; /* invert 6th bit */ | |
160 | atr += 2 * 9; /* add offset of 4.5pF; unit[atr] = 0.25pF */ | |
7e56a7dc HVR |
161 | |
162 | return atr; | |
163 | } | |
164 | ||
9edae7bc AZ |
165 | static int |
166 | isl1208_i2c_get_dtr(struct i2c_client *client) | |
7e56a7dc HVR |
167 | { |
168 | int dtr = i2c_smbus_read_byte_data(client, ISL1208_REG_DTR); | |
7e56a7dc HVR |
169 | if (dtr < 0) |
170 | return -EIO; | |
171 | ||
172 | /* dtr encodes adjustments of {-60,-40,-20,0,20,40,60} ppm */ | |
9edae7bc | 173 | dtr = ((dtr & 0x3) * 20) * (dtr & (1 << 2) ? -1 : 1); |
7e56a7dc HVR |
174 | |
175 | return dtr; | |
176 | } | |
177 | ||
9edae7bc AZ |
178 | static int |
179 | isl1208_i2c_get_usr(struct i2c_client *client) | |
7e56a7dc HVR |
180 | { |
181 | u8 buf[ISL1208_USR_SECTION_LEN] = { 0, }; | |
182 | int ret; | |
183 | ||
9edae7bc AZ |
184 | ret = isl1208_i2c_read_regs(client, ISL1208_REG_USR1, buf, |
185 | ISL1208_USR_SECTION_LEN); | |
7e56a7dc HVR |
186 | if (ret < 0) |
187 | return ret; | |
188 | ||
189 | return (buf[1] << 8) | buf[0]; | |
190 | } | |
191 | ||
9edae7bc AZ |
192 | static int |
193 | isl1208_i2c_set_usr(struct i2c_client *client, u16 usr) | |
7e56a7dc HVR |
194 | { |
195 | u8 buf[ISL1208_USR_SECTION_LEN]; | |
196 | ||
197 | buf[0] = usr & 0xff; | |
198 | buf[1] = (usr >> 8) & 0xff; | |
199 | ||
9edae7bc AZ |
200 | return isl1208_i2c_set_regs(client, ISL1208_REG_USR1, buf, |
201 | ISL1208_USR_SECTION_LEN); | |
7e56a7dc HVR |
202 | } |
203 | ||
9edae7bc AZ |
204 | static int |
205 | isl1208_rtc_proc(struct device *dev, struct seq_file *seq) | |
7e56a7dc HVR |
206 | { |
207 | struct i2c_client *const client = to_i2c_client(dev); | |
208 | int sr, dtr, atr, usr; | |
209 | ||
210 | sr = isl1208_i2c_get_sr(client); | |
211 | if (sr < 0) { | |
212 | dev_err(&client->dev, "%s: reading SR failed\n", __func__); | |
213 | return sr; | |
214 | } | |
215 | ||
216 | seq_printf(seq, "status_reg\t:%s%s%s%s%s%s (0x%.2x)\n", | |
217 | (sr & ISL1208_REG_SR_RTCF) ? " RTCF" : "", | |
218 | (sr & ISL1208_REG_SR_BAT) ? " BAT" : "", | |
219 | (sr & ISL1208_REG_SR_ALM) ? " ALM" : "", | |
220 | (sr & ISL1208_REG_SR_WRTC) ? " WRTC" : "", | |
221 | (sr & ISL1208_REG_SR_XTOSCB) ? " XTOSCB" : "", | |
9edae7bc | 222 | (sr & ISL1208_REG_SR_ARST) ? " ARST" : "", sr); |
7e56a7dc HVR |
223 | |
224 | seq_printf(seq, "batt_status\t: %s\n", | |
225 | (sr & ISL1208_REG_SR_RTCF) ? "bad" : "okay"); | |
226 | ||
227 | dtr = isl1208_i2c_get_dtr(client); | |
9edae7bc | 228 | if (dtr >= 0 - 1) |
7e56a7dc HVR |
229 | seq_printf(seq, "digital_trim\t: %d ppm\n", dtr); |
230 | ||
231 | atr = isl1208_i2c_get_atr(client); | |
232 | if (atr >= 0) | |
233 | seq_printf(seq, "analog_trim\t: %d.%.2d pF\n", | |
9edae7bc | 234 | atr >> 2, (atr & 0x3) * 25); |
7e56a7dc HVR |
235 | |
236 | usr = isl1208_i2c_get_usr(client); | |
237 | if (usr >= 0) | |
238 | seq_printf(seq, "user_data\t: 0x%.4x\n", usr); | |
239 | ||
240 | return 0; | |
241 | } | |
242 | ||
9edae7bc AZ |
243 | static int |
244 | isl1208_i2c_read_time(struct i2c_client *client, struct rtc_time *tm) | |
7e56a7dc HVR |
245 | { |
246 | int sr; | |
247 | u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, }; | |
248 | ||
249 | sr = isl1208_i2c_get_sr(client); | |
250 | if (sr < 0) { | |
251 | dev_err(&client->dev, "%s: reading SR failed\n", __func__); | |
252 | return -EIO; | |
253 | } | |
254 | ||
255 | sr = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN); | |
256 | if (sr < 0) { | |
257 | dev_err(&client->dev, "%s: reading RTC section failed\n", | |
258 | __func__); | |
259 | return sr; | |
260 | } | |
261 | ||
fe20ba70 AB |
262 | tm->tm_sec = bcd2bin(regs[ISL1208_REG_SC]); |
263 | tm->tm_min = bcd2bin(regs[ISL1208_REG_MN]); | |
9edae7bc AZ |
264 | |
265 | /* HR field has a more complex interpretation */ | |
266 | { | |
7e56a7dc | 267 | const u8 _hr = regs[ISL1208_REG_HR]; |
9edae7bc | 268 | if (_hr & ISL1208_REG_HR_MIL) /* 24h format */ |
fe20ba70 | 269 | tm->tm_hour = bcd2bin(_hr & 0x3f); |
9edae7bc AZ |
270 | else { |
271 | /* 12h format */ | |
fe20ba70 | 272 | tm->tm_hour = bcd2bin(_hr & 0x1f); |
9edae7bc | 273 | if (_hr & ISL1208_REG_HR_PM) /* PM flag set */ |
7e56a7dc HVR |
274 | tm->tm_hour += 12; |
275 | } | |
276 | } | |
277 | ||
fe20ba70 AB |
278 | tm->tm_mday = bcd2bin(regs[ISL1208_REG_DT]); |
279 | tm->tm_mon = bcd2bin(regs[ISL1208_REG_MO]) - 1; /* rtc starts at 1 */ | |
280 | tm->tm_year = bcd2bin(regs[ISL1208_REG_YR]) + 100; | |
281 | tm->tm_wday = bcd2bin(regs[ISL1208_REG_DW]); | |
7e56a7dc HVR |
282 | |
283 | return 0; | |
284 | } | |
285 | ||
9edae7bc AZ |
286 | static int |
287 | isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm) | |
7e56a7dc HVR |
288 | { |
289 | struct rtc_time *const tm = &alarm->time; | |
290 | u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, }; | |
291 | int sr; | |
292 | ||
293 | sr = isl1208_i2c_get_sr(client); | |
294 | if (sr < 0) { | |
295 | dev_err(&client->dev, "%s: reading SR failed\n", __func__); | |
296 | return sr; | |
297 | } | |
298 | ||
299 | sr = isl1208_i2c_read_regs(client, ISL1208_REG_SCA, regs, | |
9edae7bc | 300 | ISL1208_ALARM_SECTION_LEN); |
7e56a7dc HVR |
301 | if (sr < 0) { |
302 | dev_err(&client->dev, "%s: reading alarm section failed\n", | |
303 | __func__); | |
304 | return sr; | |
305 | } | |
306 | ||
307 | /* MSB of each alarm register is an enable bit */ | |
fe20ba70 AB |
308 | tm->tm_sec = bcd2bin(regs[ISL1208_REG_SCA - ISL1208_REG_SCA] & 0x7f); |
309 | tm->tm_min = bcd2bin(regs[ISL1208_REG_MNA - ISL1208_REG_SCA] & 0x7f); | |
310 | tm->tm_hour = bcd2bin(regs[ISL1208_REG_HRA - ISL1208_REG_SCA] & 0x3f); | |
311 | tm->tm_mday = bcd2bin(regs[ISL1208_REG_DTA - ISL1208_REG_SCA] & 0x3f); | |
9edae7bc | 312 | tm->tm_mon = |
fe20ba70 AB |
313 | bcd2bin(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1; |
314 | tm->tm_wday = bcd2bin(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03); | |
7e56a7dc HVR |
315 | |
316 | return 0; | |
317 | } | |
318 | ||
9edae7bc AZ |
319 | static int |
320 | isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm) | |
7e56a7dc HVR |
321 | { |
322 | return isl1208_i2c_read_time(to_i2c_client(dev), tm); | |
323 | } | |
324 | ||
9edae7bc AZ |
325 | static int |
326 | isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm) | |
7e56a7dc HVR |
327 | { |
328 | int sr; | |
329 | u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, }; | |
330 | ||
cc6c2ca3 CE |
331 | /* The clock has an 8 bit wide bcd-coded register (they never learn) |
332 | * for the year. tm_year is an offset from 1900 and we are interested | |
333 | * in the 2000-2099 range, so any value less than 100 is invalid. | |
334 | */ | |
335 | if (tm->tm_year < 100) | |
336 | return -EINVAL; | |
337 | ||
fe20ba70 AB |
338 | regs[ISL1208_REG_SC] = bin2bcd(tm->tm_sec); |
339 | regs[ISL1208_REG_MN] = bin2bcd(tm->tm_min); | |
340 | regs[ISL1208_REG_HR] = bin2bcd(tm->tm_hour) | ISL1208_REG_HR_MIL; | |
7e56a7dc | 341 | |
fe20ba70 AB |
342 | regs[ISL1208_REG_DT] = bin2bcd(tm->tm_mday); |
343 | regs[ISL1208_REG_MO] = bin2bcd(tm->tm_mon + 1); | |
344 | regs[ISL1208_REG_YR] = bin2bcd(tm->tm_year - 100); | |
7e56a7dc | 345 | |
fe20ba70 | 346 | regs[ISL1208_REG_DW] = bin2bcd(tm->tm_wday & 7); |
7e56a7dc HVR |
347 | |
348 | sr = isl1208_i2c_get_sr(client); | |
349 | if (sr < 0) { | |
350 | dev_err(&client->dev, "%s: reading SR failed\n", __func__); | |
351 | return sr; | |
352 | } | |
353 | ||
354 | /* set WRTC */ | |
9edae7bc | 355 | sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, |
7e56a7dc HVR |
356 | sr | ISL1208_REG_SR_WRTC); |
357 | if (sr < 0) { | |
358 | dev_err(&client->dev, "%s: writing SR failed\n", __func__); | |
359 | return sr; | |
360 | } | |
361 | ||
362 | /* write RTC registers */ | |
363 | sr = isl1208_i2c_set_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN); | |
364 | if (sr < 0) { | |
365 | dev_err(&client->dev, "%s: writing RTC section failed\n", | |
366 | __func__); | |
367 | return sr; | |
368 | } | |
369 | ||
370 | /* clear WRTC again */ | |
9edae7bc | 371 | sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, |
7e56a7dc HVR |
372 | sr & ~ISL1208_REG_SR_WRTC); |
373 | if (sr < 0) { | |
374 | dev_err(&client->dev, "%s: writing SR failed\n", __func__); | |
375 | return sr; | |
376 | } | |
377 | ||
378 | return 0; | |
379 | } | |
380 | ||
381 | ||
9edae7bc AZ |
382 | static int |
383 | isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm) | |
7e56a7dc HVR |
384 | { |
385 | return isl1208_i2c_set_time(to_i2c_client(dev), tm); | |
386 | } | |
387 | ||
9edae7bc AZ |
388 | static int |
389 | isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) | |
7e56a7dc HVR |
390 | { |
391 | return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm); | |
392 | } | |
393 | ||
ff8371ac | 394 | static const struct rtc_class_ops isl1208_rtc_ops = { |
9edae7bc AZ |
395 | .proc = isl1208_rtc_proc, |
396 | .read_time = isl1208_rtc_read_time, | |
397 | .set_time = isl1208_rtc_set_time, | |
398 | .read_alarm = isl1208_rtc_read_alarm, | |
399 | /*.set_alarm = isl1208_rtc_set_alarm, */ | |
7e56a7dc HVR |
400 | }; |
401 | ||
402 | /* sysfs interface */ | |
403 | ||
9edae7bc AZ |
404 | static ssize_t |
405 | isl1208_sysfs_show_atrim(struct device *dev, | |
406 | struct device_attribute *attr, char *buf) | |
7e56a7dc | 407 | { |
9edae7bc | 408 | int atr = isl1208_i2c_get_atr(to_i2c_client(dev)); |
7e56a7dc HVR |
409 | if (atr < 0) |
410 | return atr; | |
411 | ||
9edae7bc | 412 | return sprintf(buf, "%d.%.2d pF\n", atr >> 2, (atr & 0x3) * 25); |
7e56a7dc | 413 | } |
9edae7bc | 414 | |
7e56a7dc HVR |
415 | static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL); |
416 | ||
9edae7bc AZ |
417 | static ssize_t |
418 | isl1208_sysfs_show_dtrim(struct device *dev, | |
419 | struct device_attribute *attr, char *buf) | |
7e56a7dc | 420 | { |
9edae7bc | 421 | int dtr = isl1208_i2c_get_dtr(to_i2c_client(dev)); |
7e56a7dc HVR |
422 | if (dtr < 0) |
423 | return dtr; | |
424 | ||
425 | return sprintf(buf, "%d ppm\n", dtr); | |
426 | } | |
9edae7bc | 427 | |
7e56a7dc HVR |
428 | static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL); |
429 | ||
9edae7bc AZ |
430 | static ssize_t |
431 | isl1208_sysfs_show_usr(struct device *dev, | |
432 | struct device_attribute *attr, char *buf) | |
7e56a7dc | 433 | { |
9edae7bc | 434 | int usr = isl1208_i2c_get_usr(to_i2c_client(dev)); |
7e56a7dc HVR |
435 | if (usr < 0) |
436 | return usr; | |
437 | ||
438 | return sprintf(buf, "0x%.4x\n", usr); | |
439 | } | |
440 | ||
9edae7bc AZ |
441 | static ssize_t |
442 | isl1208_sysfs_store_usr(struct device *dev, | |
443 | struct device_attribute *attr, | |
444 | const char *buf, size_t count) | |
7e56a7dc HVR |
445 | { |
446 | int usr = -1; | |
447 | ||
448 | if (buf[0] == '0' && (buf[1] == 'x' || buf[1] == 'X')) { | |
449 | if (sscanf(buf, "%x", &usr) != 1) | |
450 | return -EINVAL; | |
451 | } else { | |
452 | if (sscanf(buf, "%d", &usr) != 1) | |
453 | return -EINVAL; | |
454 | } | |
455 | ||
456 | if (usr < 0 || usr > 0xffff) | |
457 | return -EINVAL; | |
458 | ||
459 | return isl1208_i2c_set_usr(to_i2c_client(dev), usr) ? -EIO : count; | |
460 | } | |
9edae7bc | 461 | |
7e56a7dc HVR |
462 | static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr, |
463 | isl1208_sysfs_store_usr); | |
464 | ||
465 | static int | |
9edae7bc | 466 | isl1208_sysfs_register(struct device *dev) |
7e56a7dc | 467 | { |
9edae7bc AZ |
468 | int err; |
469 | ||
470 | err = device_create_file(dev, &dev_attr_atrim); | |
471 | if (err) | |
472 | return err; | |
7e56a7dc | 473 | |
9edae7bc AZ |
474 | err = device_create_file(dev, &dev_attr_dtrim); |
475 | if (err) { | |
476 | device_remove_file(dev, &dev_attr_atrim); | |
477 | return err; | |
7e56a7dc HVR |
478 | } |
479 | ||
9edae7bc AZ |
480 | err = device_create_file(dev, &dev_attr_usr); |
481 | if (err) { | |
482 | device_remove_file(dev, &dev_attr_atrim); | |
483 | device_remove_file(dev, &dev_attr_dtrim); | |
7e56a7dc HVR |
484 | } |
485 | ||
9edae7bc AZ |
486 | return 0; |
487 | } | |
7e56a7dc | 488 | |
9edae7bc AZ |
489 | static int |
490 | isl1208_sysfs_unregister(struct device *dev) | |
491 | { | |
001e979d | 492 | device_remove_file(dev, &dev_attr_dtrim); |
9edae7bc AZ |
493 | device_remove_file(dev, &dev_attr_atrim); |
494 | device_remove_file(dev, &dev_attr_usr); | |
495 | ||
496 | return 0; | |
497 | } | |
498 | ||
499 | static int | |
d2653e92 | 500 | isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id) |
9edae7bc AZ |
501 | { |
502 | int rc = 0; | |
503 | struct rtc_device *rtc; | |
7e56a7dc | 504 | |
9edae7bc AZ |
505 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) |
506 | return -ENODEV; | |
7e56a7dc | 507 | |
9edae7bc AZ |
508 | if (isl1208_i2c_validate_client(client) < 0) |
509 | return -ENODEV; | |
510 | ||
511 | dev_info(&client->dev, | |
7e56a7dc HVR |
512 | "chip found, driver version " DRV_VERSION "\n"); |
513 | ||
514 | rtc = rtc_device_register(isl1208_driver.driver.name, | |
9edae7bc AZ |
515 | &client->dev, &isl1208_rtc_ops, |
516 | THIS_MODULE); | |
517 | if (IS_ERR(rtc)) | |
518 | return PTR_ERR(rtc); | |
7e56a7dc | 519 | |
9edae7bc | 520 | i2c_set_clientdata(client, rtc); |
7e56a7dc | 521 | |
9edae7bc | 522 | rc = isl1208_i2c_get_sr(client); |
7e56a7dc | 523 | if (rc < 0) { |
9edae7bc AZ |
524 | dev_err(&client->dev, "reading status failed\n"); |
525 | goto exit_unregister; | |
7e56a7dc HVR |
526 | } |
527 | ||
528 | if (rc & ISL1208_REG_SR_RTCF) | |
9edae7bc | 529 | dev_warn(&client->dev, "rtc power failure detected, " |
7e56a7dc HVR |
530 | "please set clock.\n"); |
531 | ||
9edae7bc AZ |
532 | rc = isl1208_sysfs_register(&client->dev); |
533 | if (rc) | |
534 | goto exit_unregister; | |
7e56a7dc HVR |
535 | |
536 | return 0; | |
537 | ||
9edae7bc | 538 | exit_unregister: |
7e56a7dc | 539 | rtc_device_unregister(rtc); |
7e56a7dc | 540 | |
9edae7bc | 541 | return rc; |
7e56a7dc HVR |
542 | } |
543 | ||
544 | static int | |
9edae7bc | 545 | isl1208_remove(struct i2c_client *client) |
7e56a7dc | 546 | { |
9edae7bc | 547 | struct rtc_device *rtc = i2c_get_clientdata(client); |
7e56a7dc | 548 | |
9edae7bc AZ |
549 | isl1208_sysfs_unregister(&client->dev); |
550 | rtc_device_unregister(rtc); | |
7e56a7dc HVR |
551 | |
552 | return 0; | |
553 | } | |
554 | ||
3760f736 JD |
555 | static const struct i2c_device_id isl1208_id[] = { |
556 | { "isl1208", 0 }, | |
557 | { } | |
558 | }; | |
559 | MODULE_DEVICE_TABLE(i2c, isl1208_id); | |
560 | ||
9edae7bc AZ |
561 | static struct i2c_driver isl1208_driver = { |
562 | .driver = { | |
563 | .name = "rtc-isl1208", | |
564 | }, | |
565 | .probe = isl1208_probe, | |
566 | .remove = isl1208_remove, | |
3760f736 | 567 | .id_table = isl1208_id, |
9edae7bc | 568 | }; |
7e56a7dc | 569 | |
9edae7bc AZ |
570 | static int __init |
571 | isl1208_init(void) | |
7e56a7dc HVR |
572 | { |
573 | return i2c_add_driver(&isl1208_driver); | |
574 | } | |
575 | ||
9edae7bc AZ |
576 | static void __exit |
577 | isl1208_exit(void) | |
7e56a7dc HVR |
578 | { |
579 | i2c_del_driver(&isl1208_driver); | |
580 | } | |
581 | ||
582 | MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>"); | |
583 | MODULE_DESCRIPTION("Intersil ISL1208 RTC driver"); | |
584 | MODULE_LICENSE("GPL"); | |
585 | MODULE_VERSION(DRV_VERSION); | |
586 | ||
587 | module_init(isl1208_init); | |
588 | module_exit(isl1208_exit); |