Root/
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 | |
18 | #define DRV_VERSION "0.3" |
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 |
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 */ |
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 |
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 */ |
41 | #define ISL1208_REG_INT 0x08 |
42 | #define ISL1208_REG_09 0x09 /* reserved */ |
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 | |
60 | static struct i2c_driver isl1208_driver; |
61 | |
62 | /* block read */ |
63 | static int |
64 | isl1208_i2c_read_regs(struct i2c_client *client, u8 reg, u8 buf[], |
65 | unsigned len) |
66 | { |
67 | u8 reg_addr[1] = { reg }; |
68 | struct i2c_msg msgs[2] = { |
69 | {client->addr, 0, sizeof(reg_addr), reg_addr} |
70 | , |
71 | {client->addr, I2C_M_RD, len, buf} |
72 | }; |
73 | int ret; |
74 | |
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[], |
87 | unsigned len) |
88 | { |
89 | u8 i2c_buf[ISL1208_REG_USR2 + 2]; |
90 | struct i2c_msg msgs[1] = { |
91 | {client->addr, 0, len + 1, i2c_buf} |
92 | }; |
93 | int ret; |
94 | |
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 */ |
108 | static int |
109 | isl1208_i2c_validate_client(struct i2c_client *client) |
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) { |
123 | if (regs[i] & zero_mask[i]) /* check if bits are cleared */ |
124 | return -ENODEV; |
125 | } |
126 | |
127 | return 0; |
128 | } |
129 | |
130 | static int |
131 | isl1208_i2c_get_sr(struct i2c_client *client) |
132 | { |
133 | int sr = i2c_smbus_read_byte_data(client, ISL1208_REG_SR); |
134 | if (sr < 0) |
135 | return -EIO; |
136 | |
137 | return sr; |
138 | } |
139 | |
140 | static int |
141 | isl1208_i2c_get_atr(struct i2c_client *client) |
142 | { |
143 | int atr = i2c_smbus_read_byte_data(client, ISL1208_REG_ATR); |
144 | if (atr < 0) |
145 | return atr; |
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 | |
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 */ |
161 | |
162 | return atr; |
163 | } |
164 | |
165 | static int |
166 | isl1208_i2c_get_dtr(struct i2c_client *client) |
167 | { |
168 | int dtr = i2c_smbus_read_byte_data(client, ISL1208_REG_DTR); |
169 | if (dtr < 0) |
170 | return -EIO; |
171 | |
172 | /* dtr encodes adjustments of {-60,-40,-20,0,20,40,60} ppm */ |
173 | dtr = ((dtr & 0x3) * 20) * (dtr & (1 << 2) ? -1 : 1); |
174 | |
175 | return dtr; |
176 | } |
177 | |
178 | static int |
179 | isl1208_i2c_get_usr(struct i2c_client *client) |
180 | { |
181 | u8 buf[ISL1208_USR_SECTION_LEN] = { 0, }; |
182 | int ret; |
183 | |
184 | ret = isl1208_i2c_read_regs(client, ISL1208_REG_USR1, buf, |
185 | ISL1208_USR_SECTION_LEN); |
186 | if (ret < 0) |
187 | return ret; |
188 | |
189 | return (buf[1] << 8) | buf[0]; |
190 | } |
191 | |
192 | static int |
193 | isl1208_i2c_set_usr(struct i2c_client *client, u16 usr) |
194 | { |
195 | u8 buf[ISL1208_USR_SECTION_LEN]; |
196 | |
197 | buf[0] = usr & 0xff; |
198 | buf[1] = (usr >> 8) & 0xff; |
199 | |
200 | return isl1208_i2c_set_regs(client, ISL1208_REG_USR1, buf, |
201 | ISL1208_USR_SECTION_LEN); |
202 | } |
203 | |
204 | static int |
205 | isl1208_rtc_proc(struct device *dev, struct seq_file *seq) |
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" : "", |
222 | (sr & ISL1208_REG_SR_ARST) ? " ARST" : "", sr); |
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); |
228 | if (dtr >= 0 - 1) |
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", |
234 | atr >> 2, (atr & 0x3) * 25); |
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 | |
243 | static int |
244 | isl1208_i2c_read_time(struct i2c_client *client, struct rtc_time *tm) |
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 | |
262 | tm->tm_sec = bcd2bin(regs[ISL1208_REG_SC]); |
263 | tm->tm_min = bcd2bin(regs[ISL1208_REG_MN]); |
264 | |
265 | /* HR field has a more complex interpretation */ |
266 | { |
267 | const u8 _hr = regs[ISL1208_REG_HR]; |
268 | if (_hr & ISL1208_REG_HR_MIL) /* 24h format */ |
269 | tm->tm_hour = bcd2bin(_hr & 0x3f); |
270 | else { |
271 | /* 12h format */ |
272 | tm->tm_hour = bcd2bin(_hr & 0x1f); |
273 | if (_hr & ISL1208_REG_HR_PM) /* PM flag set */ |
274 | tm->tm_hour += 12; |
275 | } |
276 | } |
277 | |
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]); |
282 | |
283 | return 0; |
284 | } |
285 | |
286 | static int |
287 | isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm) |
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, |
300 | ISL1208_ALARM_SECTION_LEN); |
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 */ |
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); |
312 | tm->tm_mon = |
313 | bcd2bin(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1; |
314 | tm->tm_wday = bcd2bin(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03); |
315 | |
316 | return 0; |
317 | } |
318 | |
319 | static int |
320 | isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm) |
321 | { |
322 | return isl1208_i2c_read_time(to_i2c_client(dev), tm); |
323 | } |
324 | |
325 | static int |
326 | isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm) |
327 | { |
328 | int sr; |
329 | u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, }; |
330 | |
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 | |
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; |
341 | |
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); |
345 | |
346 | regs[ISL1208_REG_DW] = bin2bcd(tm->tm_wday & 7); |
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 */ |
355 | sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, |
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 */ |
371 | sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, |
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 | |
382 | static int |
383 | isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm) |
384 | { |
385 | return isl1208_i2c_set_time(to_i2c_client(dev), tm); |
386 | } |
387 | |
388 | static int |
389 | isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm) |
390 | { |
391 | return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm); |
392 | } |
393 | |
394 | static const struct rtc_class_ops isl1208_rtc_ops = { |
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, */ |
400 | }; |
401 | |
402 | /* sysfs interface */ |
403 | |
404 | static ssize_t |
405 | isl1208_sysfs_show_atrim(struct device *dev, |
406 | struct device_attribute *attr, char *buf) |
407 | { |
408 | int atr = isl1208_i2c_get_atr(to_i2c_client(dev)); |
409 | if (atr < 0) |
410 | return atr; |
411 | |
412 | return sprintf(buf, "%d.%.2d pF\n", atr >> 2, (atr & 0x3) * 25); |
413 | } |
414 | |
415 | static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL); |
416 | |
417 | static ssize_t |
418 | isl1208_sysfs_show_dtrim(struct device *dev, |
419 | struct device_attribute *attr, char *buf) |
420 | { |
421 | int dtr = isl1208_i2c_get_dtr(to_i2c_client(dev)); |
422 | if (dtr < 0) |
423 | return dtr; |
424 | |
425 | return sprintf(buf, "%d ppm\n", dtr); |
426 | } |
427 | |
428 | static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL); |
429 | |
430 | static ssize_t |
431 | isl1208_sysfs_show_usr(struct device *dev, |
432 | struct device_attribute *attr, char *buf) |
433 | { |
434 | int usr = isl1208_i2c_get_usr(to_i2c_client(dev)); |
435 | if (usr < 0) |
436 | return usr; |
437 | |
438 | return sprintf(buf, "0x%.4x\n", usr); |
439 | } |
440 | |
441 | static ssize_t |
442 | isl1208_sysfs_store_usr(struct device *dev, |
443 | struct device_attribute *attr, |
444 | const char *buf, size_t count) |
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 | } |
461 | |
462 | static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr, |
463 | isl1208_sysfs_store_usr); |
464 | |
465 | static int |
466 | isl1208_sysfs_register(struct device *dev) |
467 | { |
468 | int err; |
469 | |
470 | err = device_create_file(dev, &dev_attr_atrim); |
471 | if (err) |
472 | return err; |
473 | |
474 | err = device_create_file(dev, &dev_attr_dtrim); |
475 | if (err) { |
476 | device_remove_file(dev, &dev_attr_atrim); |
477 | return err; |
478 | } |
479 | |
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); |
484 | } |
485 | |
486 | return 0; |
487 | } |
488 | |
489 | static int |
490 | isl1208_sysfs_unregister(struct device *dev) |
491 | { |
492 | device_remove_file(dev, &dev_attr_dtrim); |
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 |
500 | isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id) |
501 | { |
502 | int rc = 0; |
503 | struct rtc_device *rtc; |
504 | |
505 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) |
506 | return -ENODEV; |
507 | |
508 | if (isl1208_i2c_validate_client(client) < 0) |
509 | return -ENODEV; |
510 | |
511 | dev_info(&client->dev, |
512 | "chip found, driver version " DRV_VERSION "\n"); |
513 | |
514 | rtc = rtc_device_register(isl1208_driver.driver.name, |
515 | &client->dev, &isl1208_rtc_ops, |
516 | THIS_MODULE); |
517 | if (IS_ERR(rtc)) |
518 | return PTR_ERR(rtc); |
519 | |
520 | i2c_set_clientdata(client, rtc); |
521 | |
522 | rc = isl1208_i2c_get_sr(client); |
523 | if (rc < 0) { |
524 | dev_err(&client->dev, "reading status failed\n"); |
525 | goto exit_unregister; |
526 | } |
527 | |
528 | if (rc & ISL1208_REG_SR_RTCF) |
529 | dev_warn(&client->dev, "rtc power failure detected, " |
530 | "please set clock.\n"); |
531 | |
532 | rc = isl1208_sysfs_register(&client->dev); |
533 | if (rc) |
534 | goto exit_unregister; |
535 | |
536 | return 0; |
537 | |
538 | exit_unregister: |
539 | rtc_device_unregister(rtc); |
540 | |
541 | return rc; |
542 | } |
543 | |
544 | static int |
545 | isl1208_remove(struct i2c_client *client) |
546 | { |
547 | struct rtc_device *rtc = i2c_get_clientdata(client); |
548 | |
549 | isl1208_sysfs_unregister(&client->dev); |
550 | rtc_device_unregister(rtc); |
551 | |
552 | return 0; |
553 | } |
554 | |
555 | static const struct i2c_device_id isl1208_id[] = { |
556 | { "isl1208", 0 }, |
557 | { } |
558 | }; |
559 | MODULE_DEVICE_TABLE(i2c, isl1208_id); |
560 | |
561 | static struct i2c_driver isl1208_driver = { |
562 | .driver = { |
563 | .name = "rtc-isl1208", |
564 | }, |
565 | .probe = isl1208_probe, |
566 | .remove = isl1208_remove, |
567 | .id_table = isl1208_id, |
568 | }; |
569 | |
570 | static int __init |
571 | isl1208_init(void) |
572 | { |
573 | return i2c_add_driver(&isl1208_driver); |
574 | } |
575 | |
576 | static void __exit |
577 | isl1208_exit(void) |
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); |
589 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9