projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[kernel] update to 2.6.28.7 and 2.6.27.19
[openwrt.git] / target / linux / s3c24xx / patches-2.6.24 / 1029-hxd8-tsl256x.patch.patch
1 From d238d3347d19a6df97670624bd0712e61b83b666 Mon Sep 17 00:00:00 2001
2 From: mokopatches <mokopatches@openmoko.org>
3 Date: Fri, 4 Apr 2008 11:34:17 +0100
4 Subject: [PATCH] hxd8-tsl256x.patch
5
6 ---
7 drivers/i2c/chips/Kconfig | 10 ++
8 drivers/i2c/chips/Makefile | 1 +
9 drivers/i2c/chips/tsl256x.c | 310 +++++++++++++++++++++++++++++++++++++++++++
10 drivers/i2c/chips/tsl256x.h | 154 +++++++++++++++++++++
11 include/linux/i2c-id.h | 1 +
12 5 files changed, 476 insertions(+), 0 deletions(-)
13 create mode 100644 drivers/i2c/chips/tsl256x.c
14 create mode 100644 drivers/i2c/chips/tsl256x.h
15
16 diff --git a/drivers/i2c/chips/Kconfig b/drivers/i2c/chips/Kconfig
17 index c0011fc..bf0da3a 100644
18 --- a/drivers/i2c/chips/Kconfig
19 +++ b/drivers/i2c/chips/Kconfig
20 @@ -174,4 +174,14 @@ config MENELAUS
21 and other features that are often used in portable devices like
22 cell phones and PDAs.
23
24 +config SENSORS_TSL256X
25 + tristate "Texas TSL256X Ambient Light Sensor"
26 + depends on I2C
27 + help
28 + If you say yes here you get support for the Texas TSL256X
29 + ambient light sensor chip.
30 +
31 + This driver can also be built as a module. If so, the module
32 + will be called tsl256x.
33 +
34 endmenu
35 diff --git a/drivers/i2c/chips/Makefile b/drivers/i2c/chips/Makefile
36 index 864e6cf..a4772c7 100644
37 --- a/drivers/i2c/chips/Makefile
38 +++ b/drivers/i2c/chips/Makefile
39 @@ -16,6 +16,7 @@ obj-$(CONFIG_ISP1301_OMAP) += isp1301_omap.o
40 obj-$(CONFIG_TPS65010) += tps65010.o
41 obj-$(CONFIG_MENELAUS) += menelaus.o
42 obj-$(CONFIG_SENSORS_TSL2550) += tsl2550.o
43 +obj-$(CONFIG_SENSORS_TSL256X) += tsl256x.o
44
45 ifeq ($(CONFIG_I2C_DEBUG_CHIP),y)
46 EXTRA_CFLAGS += -DDEBUG
47 diff --git a/drivers/i2c/chips/tsl256x.c b/drivers/i2c/chips/tsl256x.c
48 new file mode 100644
49 index 0000000..455ec5e
50 --- /dev/null
51 +++ b/drivers/i2c/chips/tsl256x.c
52 @@ -0,0 +1,310 @@
53 +/*
54 + * tsl256x.c -- TSL256x Light Sensor driver
55 + *
56 + * Copyright 2007 by Fiwin.
57 + * Author: Alec Tsai <alec_tsai@fiwin.com.tw>
58 + *
59 + * This program is free software; you can redistribute it and/or modify
60 + * it under the terms of the GNU General Public License version 2 as
61 + * published by the Free Software Foundation.
62 + *
63 + * This I2C client driver refers to pcf50606.c.
64 + */
65 +
66 +#include <linux/module.h>
67 +#include <linux/init.h>
68 +#include <linux/i2c.h>
69 +#include <linux/types.h>
70 +#include <linux/input.h>
71 +
72 +#include "tsl256x.h"
73 +
74 +static unsigned short normal_i2c[] = { 0x39, I2C_CLIENT_END };
75 +/* Magic definition of all other variables and things */
76 +I2C_CLIENT_INSMOD;
77 +
78 +struct tsl256x_data {
79 + struct i2c_client client;
80 + struct mutex lock;
81 + struct input_dev *input_dev;
82 +};
83 +
84 +static struct i2c_driver tsl256x_driver;
85 +
86 +/******************************************************************************
87 + * Low-Level routines
88 + *****************************************************************************/
89 +static inline int __reg_write(struct tsl256x_data *tsl, u_int8_t reg,
90 + u_int8_t val)
91 +{
92 + return i2c_smbus_write_byte_data(&tsl->client, reg, val);
93 +}
94 +
95 +static int reg_write(struct tsl256x_data *tsl, u_int8_t reg, u_int8_t val)
96 +{
97 + int ret;
98 +
99 + mutex_lock(&tsl->lock);
100 + ret = __reg_write(tsl, reg, val);
101 + mutex_unlock(&tsl->lock);
102 +
103 + return ret;
104 +}
105 +
106 +static inline int32_t __reg_read(struct tsl256x_data *tsl, u_int8_t reg)
107 +{
108 + int32_t ret;
109 +
110 + ret = i2c_smbus_read_byte_data(&tsl->client, reg);
111 +
112 + return ret;
113 +}
114 +
115 +static u_int8_t reg_read(struct tsl256x_data *tsl, u_int8_t reg)
116 +{
117 + int32_t ret;
118 +
119 + mutex_lock(&tsl->lock);
120 + ret = __reg_read(tsl, reg);
121 + mutex_unlock(&tsl->lock);
122 +
123 + return ret & 0xff;
124 +}
125 +
126 +u_int32_t calculate_lux(u_int32_t iGain, u_int32_t iType, u_int32_t ch0,
127 + u_int32_t ch1)
128 +{
129 + u_int32_t channel0 = ch0 * 636 / 10;
130 + u_int32_t channel1 = ch1 * 636 / 10;
131 + u_int32_t lux_value = 0;
132 + u_int32_t ratio = (channel1 * (2^RATIO_SCALE)) / channel0;
133 + u_int32_t b = 0, m = 0;
134 +
135 + if (0 == ch0)
136 + return 0;
137 + else {
138 + if (ratio > (13 * (2^RATIO_SCALE) / 10))
139 + return 0;
140 + }
141 +
142 + switch (iType) {
143 + case 0: // T package
144 + if ((ratio >= 0) && (ratio <= K1T)) {
145 + b = B1T;
146 + m = M1T;
147 + } else if (ratio <= K2T) {
148 + b = B2T;
149 + m = M2T;
150 + } else if (ratio <= K3T) {
151 + b = B3T;
152 + m = M3T;
153 + } else if (ratio <= K4T) {
154 + b = B4T;
155 + m = M4T;
156 + } else if (ratio <= K5T) {
157 + b = B5T;
158 + m = M5T;
159 + } else if (ratio <= K6T) {
160 + b = B6T;
161 + m = M6T;
162 + } else if (ratio <= K7T) {
163 + b = B7T;
164 + m = M7T;
165 + } else if (ratio > K8T) {
166 + b = B8T;
167 + m = M8T;
168 + }
169 + break;
170 + case 1:// CS package
171 + if ((ratio >= 0) && (ratio <= K1C)) {
172 + b = B1C;
173 + m = M1C;
174 + } else if (ratio <= K2C) {
175 + b = B2C;
176 + m = M2C;
177 + } else if (ratio <= K3C) {
178 + b = B3C;
179 + m = M3C;
180 + } else if (ratio <= K4C) {
181 + b = B4C;
182 + m = M4C;
183 + } else if (ratio <= K5C) {
184 + b = B5C;
185 + m = M5C;
186 + } else if (ratio <= K6C) {
187 + b = B6C;
188 + m = M6C;
189 + } else if (ratio <= K7C) {
190 + b = B7C;
191 + m = M7C;
192 + } else if (ratio > K8C) {
193 + b = B8C;
194 + m = M8C;
195 + }
196 + break;
197 + default:
198 + return 0;
199 + break;
200 + }
201 +
202 + lux_value = ((channel0 * b) - (channel1 * m)) / 16384;
203 + return(lux_value);
204 +}
205 +
206 +static ssize_t tsl256x_show_light_lux(struct device *dev,
207 + struct device_attribute *attr, char *buf)
208 +{
209 + struct i2c_client *client = to_i2c_client(dev);
210 + struct tsl256x_data *tsl = i2c_get_clientdata(client);
211 + u_int8_t low_byte_of_ch0 = 0, high_byte_of_ch0 = 0;
212 + u_int8_t low_byte_of_ch1 = 0, high_byte_of_ch1 = 0;
213 + u_int32_t adc_value_ch0, adc_value_ch1, adc_value;
214 +
215 + low_byte_of_ch0 = reg_read(tsl, TSL256X_REG_DATA0LOW);
216 + high_byte_of_ch0 = reg_read(tsl, TSL256X_REG_DATA0HIGH);
217 + low_byte_of_ch1 = reg_read(tsl, TSL256X_REG_DATA1LOW);
218 + high_byte_of_ch1 = reg_read(tsl, TSL256X_REG_DATA1HIGH);
219 +
220 + adc_value_ch0 = (high_byte_of_ch0 * 256 + low_byte_of_ch0) * 16;
221 + adc_value_ch1 = (high_byte_of_ch1 * 256 + low_byte_of_ch1) * 16;
222 +
223 + adc_value = calculate_lux(0, 0, adc_value_ch0, adc_value_ch1);
224 + return sprintf(buf, "%d\n", adc_value);
225 +}
226 +
227 +static DEVICE_ATTR(light_lux, S_IRUGO, tsl256x_show_light_lux, NULL);
228 +
229 +static int tsl256x_detect(struct i2c_adapter *adapter, int address, int kind)
230 +{
231 + struct i2c_client *new_client = NULL;
232 + struct tsl256x_data *tsl256x = NULL;
233 + u_int8_t id = 0;
234 + int res = 0;
235 +
236 + if (!(tsl256x = kzalloc(sizeof(*tsl256x), GFP_KERNEL)))
237 + return -ENOMEM;
238 +
239 + mutex_init(&tsl256x->lock);
240 + new_client = &tsl256x->client;
241 + i2c_set_clientdata(new_client, tsl256x);
242 + new_client->addr = address;
243 + new_client->adapter = adapter;
244 + new_client->driver = &tsl256x_driver;
245 + new_client->flags = 0;
246 + strlcpy(new_client->name, "tsl256x", I2C_NAME_SIZE);
247 +
248 + /* now we try to detect the chip */
249 + /* register with i2c core */
250 + res = i2c_attach_client(new_client);
251 + if (res) {
252 + printk(KERN_DEBUG "[%s]Error: during i2c_attach_client()\n",
253 + new_client->name);
254 + goto exit_free;
255 + } else {
256 + printk(KERN_INFO "TSL256X is attached to I2C bus.\n");
257 + }
258 +
259 + /* Configure TSL256X. */
260 + {
261 + /* Power up TSL256X. */
262 + reg_write(tsl256x, TSL256X_REG_CONTROL, 0x03);
263 +
264 + /* Check TSL256X ID. */
265 + id = reg_read(tsl256x, TSL256X_REG_ID);
266 + if (TSL2561_ID == (id & 0xF0)) {
267 + /* Configuring the Timing Register.
268 + High Gain (16x), integration time of 101ms. */
269 + reg_write(tsl256x, TSL256X_REG_TIMING, 0x11);
270 + } else {
271 + goto exit_free;
272 + }
273 + }
274 +
275 + res = device_create_file(&new_client->dev, &dev_attr_light_lux);
276 + if (res)
277 + goto exit_detach;
278 +
279 + return 0;
280 +
281 +exit_free:
282 + kfree(tsl256x);
283 + return res;
284 +exit_detach:
285 + i2c_detach_client(new_client);
286 + return res;
287 +}
288 +
289 +static int tsl256x_attach_adapter(struct i2c_adapter *adapter)
290 +{
291 + return i2c_probe(adapter, &addr_data, &tsl256x_detect);
292 +}
293 +
294 +static int tsl256x_detach_client(struct i2c_client *client)
295 +{
296 + struct tsl256x_data *tsl256x = i2c_get_clientdata(client);
297 +
298 + printk(KERN_INFO "Detach TSL256X from I2C bus.\n");
299 +
300 + /* Power down TSL256X. */
301 + reg_write(tsl256x, TSL256X_REG_CONTROL, 0x00);
302 +
303 + device_remove_file(&client->dev, &dev_attr_light_lux);
304 + kfree(tsl256x);
305 +
306 + return 0;
307 +}
308 +
309 +#ifdef CONFIG_PM
310 +static int tsl256x_suspend(struct device *dev, pm_message_t state)
311 +{
312 + struct i2c_client *client = to_i2c_client(dev);
313 + struct tsl256x_data *tsl256x = i2c_get_clientdata(client);
314 +
315 + /* Power down TSL256X. */
316 + reg_write(tsl256x, TSL256X_REG_CONTROL, 0x00);
317 +
318 + return 0;
319 +}
320 +
321 +static int tsl256x_resume(struct device *dev)
322 +{
323 + struct i2c_client *client = to_i2c_client(dev);
324 + struct tsl256x_data *tsl256x = i2c_get_clientdata(client);
325 +
326 + /* Power up TSL256X. */
327 + reg_write(tsl256x, TSL256X_REG_CONTROL, 0x03);
328 +
329 + return 0;
330 +}
331 +#endif
332 +
333 +static struct i2c_driver tsl256x_driver = {
334 + .driver = {
335 + .name = "tsl256x",
336 + .owner = THIS_MODULE,
337 +#ifdef CONFIG_PM
338 + .suspend = tsl256x_suspend,
339 + .resume = tsl256x_resume,
340 +#endif
341 + },
342 + .id = I2C_DRIVERID_TSL256X,
343 + .attach_adapter = tsl256x_attach_adapter,
344 + .detach_client = tsl256x_detach_client,
345 +};
346 +
347 +static int __init tsl256x_init(void)
348 +{
349 + return i2c_add_driver(&tsl256x_driver);
350 +}
351 +
352 +static void __exit tsl256x_exit(void)
353 +{
354 + i2c_del_driver(&tsl256x_driver);
355 +}
356 +
357 +MODULE_AUTHOR("Alec Tsai <alec_tsai@fiwin.com.tw>");
358 +MODULE_LICENSE("GPL");
359 +
360 +module_init(tsl256x_init);
361 +module_exit(tsl256x_exit);
362 +
363 diff --git a/drivers/i2c/chips/tsl256x.h b/drivers/i2c/chips/tsl256x.h
364 new file mode 100644
365 index 0000000..88de0c6
366 --- /dev/null
367 +++ b/drivers/i2c/chips/tsl256x.h
368 @@ -0,0 +1,154 @@
369 +/*
370 + * tsl256x.h -- TSL256x Light Sensor driver
371 + *
372 + * Copyright 2007 by Fiwin.
373 + * Author: Alec Tsai <alec_tsai@fiwin.com.tw>
374 + *
375 + * This program is free software; you can redistribute it and/or modify
376 + * it under the terms of the GNU General Public License version 2 as
377 + * published by the Free Software Foundation.
378 + *
379 + * The contents of header file is copied from TSL256x Datasheet.
380 + */
381 +
382 +#ifndef _TSL256X_H
383 +#define _TSL256X_H
384 +
385 +#define TSL2560_ID 0x00
386 +#define TSL2561_ID 0x10
387 +
388 +#define LUX_SCALE 14 /* scale by 2^14 */
389 +#define RATIO_SCALE 9 /*scale ratio by 2^9 */
390 +
391 +/******************************************************************************
392 + * Integration time scaling factors
393 + *****************************************************************************/
394 +#define CH_SCALE 10 /* scale channel values by 2^10 */
395 +#define CHSCALE_TINT0 0x7517 /* 322/11 * 2^CH_SCALE */
396 +#define CHSCALE_TINT1 0x0fe7 /* 322/81 * 2^CH_SCALE */
397 +
398 +/******************************************************************************
399 + * T Package coefficients
400 + *****************************************************************************/
401 +/*
402 + * For Ch1/Ch0=0.00 to 0.50
403 + * Lux/Ch0=0.0304.0.062*((Ch1/Ch0)^1.4)
404 + * piecewise approximation
405 + * For Ch1/Ch0=0.00 to 0.125:
406 + * Lux/Ch0=0.0304.0.0272*(Ch1/Ch0)
407 + *
408 + * For Ch1/Ch0=0.125 to 0.250:
409 + * Lux/Ch0=0.0325.0.0440*(Ch1/Ch0)
410 + *
411 + * For Ch1/Ch0=0.250 to 0.375:
412 + * Lux/Ch0=0.0351.0.0544*(Ch1/Ch0)
413 + *
414 + * For Ch1/Ch0=0.375 to 0.50:
415 + * Lux/Ch0=0.0381.0.0624*(Ch1/Ch0)
416 + *
417 + * For Ch1/Ch0=0.50 to 0.61:
418 + * Lux/Ch0=0.0224.0.031*(Ch1/Ch0)
419 + *
420 + * For Ch1/Ch0=0.61 to 0.80:
421 + * Lux/Ch0=0.0128.0.0153*(Ch1/Ch0)
422 + *
423 + * For Ch1/Ch0=0.80 to 1.30:
424 + * Lux/Ch0=0.00146.0.00112*(Ch1/Ch0)
425 + *
426 + * For Ch1/Ch0>1.3:
427 + * Lux/Ch0=0
428 + */
429 +#define K1T 0x0040 /* 0.125 * 2^RATIO_SCALE */
430 +#define B1T 0x01f2 /* 0.0304 * 2^LUX_SCALE */
431 +#define M1T 0x01be /* 0.0272 * 2^LUX_SCALE */
432 +#define K2T 0x0080 /* 0.250 * 2^RATIO_SCALE */
433 +#define B2T 0x0214 /* 0.0325 * 2^LUX_SCALE */
434 +#define M2T 0x02d1 /* 0.0440 * 2^LUX_SCALE */
435 +#define K3T 0x00c0 /* 0.375 * 2^RATIO_SCALE */
436 +#define B3T 0x023f /* 0.0351 * 2^LUX_SCALE */
437 +#define M3T 0x037b /* 0.0544 * 2^LUX_SCALE */
438 +#define K4T 0x0100 /* 0.50 * 2^RATIO_SCALE */
439 +#define B4T 0x0270 /* 0.0381 * 2^LUX_SCALE */
440 +#define M4T 0x03fe /* 0.0624 * 2^LUX_SCALE */
441 +#define K5T 0x0138 /* 0.61 * 2^RATIO_SCALE */
442 +#define B5T 0x016f /* 0.0224 * 2^LUX_SCALE */
443 +#define M5T 0x01fc /* 0.0310 * 2^LUX_SCALE */
444 +#define K6T 0x019a /* 0.80 * 2^RATIO_SCALE */
445 +#define B6T 0x00d2 /* 0.0128 * 2^LUX_SCALE */
446 +#define M6T 0x00fb /* 0.0153 * 2^LUX_SCALE */
447 +#define K7T 0x029a /* 1.3 * 2^RATIO_SCALE */
448 +#define B7T 0x0018 /* 0.00146 * 2^LUX_SCALE */
449 +#define M7T 0x0012 /* 0.00112 * 2^LUX_SCALE */
450 +#define K8T 0x029a /* 1.3 * 2^RATIO_SCALE */
451 +#define B8T 0x0000 /* 0.000 * 2^LUX_SCALE */
452 +#define M8T 0x0000 /* 0.000 * 2^LUX_SCALE */
453 +
454 +/******************************************************************************
455 + * CS package coefficients
456 + *****************************************************************************/
457 +/*
458 + * For 0 <= Ch1/Ch0 <= 0.52
459 + * Lux/Ch0 = 0.0315.0.0593*((Ch1/Ch0)^1.4)
460 + * piecewise approximation
461 + * For 0 <= Ch1/Ch0 <= 0.13
462 + * Lux/Ch0 = 0.0315.0.0262*(Ch1/Ch0)
463 + * For 0.13 <= Ch1/Ch0 <= 0.26
464 + * Lux/Ch0 = 0.0337.0.0430*(Ch1/Ch0)
465 + * For 0.26 <= Ch1/Ch0 <= 0.39
466 + * Lux/Ch0 = 0.0363.0.0529*(Ch1/Ch0)
467 + * For 0.39 <= Ch1/Ch0 <= 0.52
468 + * Lux/Ch0 = 0.0392.0.0605*(Ch1/Ch0)
469 + * For 0.52 < Ch1/Ch0 <= 0.65
470 + * Lux/Ch0 = 0.0229.0.0291*(Ch1/Ch0)
471 + * For 0.65 < Ch1/Ch0 <= 0.80
472 + * Lux/Ch0 = 0.00157.0.00180*(Ch1/Ch0)
473 + * For 0.80 < Ch1/Ch0 <= 1.30
474 + * Lux/Ch0 = 0.00338.0.00260*(Ch1/Ch0)
475 + * For Ch1/Ch0 > 1.30
476 + * Lux = 0
477 + */
478 +#define K1C 0x0043 /* 0.130 * 2^RATIO_SCALE */
479 +#define B1C 0x0204 /* 0.0315 * 2^LUX_SCALE */
480 +#define M1C 0x01ad /* 0.0262 * 2^LUX_SCALE */
481 +#define K2C 0x0085 /* 0.260 * 2^RATIO_SCALE */
482 +#define B2C 0x0228 /* 0.0337 * 2^LUX_SCALE */
483 +#define M2C 0x02c1 /* 0.0430 * 2^LUX_SCALE */
484 +#define K3C 0x00c8 /* 0.390 * 2^RATIO_SCALE */
485 +#define B3C 0x0253 /* 0.0363 * 2^LUX_SCALE */
486 +#define M3C 0x0363 /* 0.0529 * 2^LUX_SCALE */
487 +#define K4C 0x010a /* 0.520 * 2^RATIO_SCALE */
488 +#define B4C 0x0282 /* 0.0392 * 2^LUX_SCALE */
489 +#define M4C 0x03df /* 0.0605 * 2^LUX_SCALE */
490 +#define K5C 0x014d /* 0.65 * 2^RATIO_SCALE */
491 +#define B5C 0x0177 /* 0.0229 * 2^LUX_SCALE */
492 +#define M5C 0x01dd /* 0.0291 * 2^LUX_SCALE */
493 +#define K6C 0x019a /* 0.80 * 2^RATIO_SCALE */
494 +#define B6C 0x0101 /* 0.0157 * 2^LUX_SCALE */
495 +#define M6C 0x0127 /* 0.0180 * 2^LUX_SCALE */
496 +#define K7C 0x029a /* 1.3 * 2^RATIO_SCALE */
497 +#define B7C 0x0037 /* 0.00338 * 2^LUX_SCALE */
498 +#define M7C 0x002b /* 0.00260 * 2^LUX_SCALE */
499 +#define K8C 0x029a /* 1.3 * 2^RATIO_SCALE */
500 +#define B8C 0x0000 /* 0.000 * 2^LUX_SCALE */
501 +#define M8C 0x0000 /* 0.000 * 2^LUX_SCALE */
502 +
503 +/* TSL256x registers definition . */
504 +enum tsl256x_regs {
505 + TSL256X_REG_CONTROL = 0x80, /* Control of basic functions */
506 + TSL256X_REG_TIMING = 0x81, /* Integration time/gain control */
507 + TSL256X_REG_THRESHLOWLOW = 0x82, /* Low byte of low interrupt threshold */
508 + TSL256X_REG_THRESHLOWHIGH = 0x83, /* High byte of low interrupt threshold */
509 + TSL256X_REG_THRESHHIGHLOW = 0x84, /* Low byte of high interrupt threshold */
510 + TSL256X_REG_THRESHHIGHHIGH = 0x85, /* High byte of high interrupt threshold */
511 + TSL256X_REG_INTERRUPT = 0x86, /* Interrupt control */
512 + TSL256X_REG_CRC = 0x88, /* Factory test - not a user register */
513 + TSL256X_REG_ID = 0x8A, /* Part number/ Rev ID */
514 + TSL256X_REG_DATA0LOW = 0x8C, /* Low byte of ADC channel 0 */
515 + TSL256X_REG_DATA0HIGH = 0x8D, /* High byte of ADC channel 0 */
516 + TSL256X_REG_DATA1LOW = 0x8E, /* Low byte of ADC channel 1 */
517 + TSL256X_REG_DATA1HIGH = 0x8F, /* High byte of ADC channel 1 */
518 + __NUM_TSL256X_REGS
519 +};
520 +
521 +#endif /* _TSL256X_H */
522 +
523 diff --git a/include/linux/i2c-id.h b/include/linux/i2c-id.h
524 index 9b8ae78..a089554 100644
525 --- a/include/linux/i2c-id.h
526 +++ b/include/linux/i2c-id.h
527 @@ -168,6 +168,7 @@
528 #define I2C_DRIVERID_W83L785TS 1047
529 #define I2C_DRIVERID_OV7670 1048 /* Omnivision 7670 camera */
530 #define I2C_DRIVERID_PCF50606 1049
531 +#define I2C_DRIVERID_TSL256X 1050
532
533 /*
534 * ---- Adapter types ----------------------------------------------------
535 --
536 1.5.6.5
537
Personal OpenWRT clone
This page took 0.061924 seconds and 5 git commands to generate.