aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video/ivtv/ivtv-i2c.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/video/ivtv/ivtv-i2c.c')
-rw-r--r--drivers/media/video/ivtv/ivtv-i2c.c748
1 files changed, 748 insertions, 0 deletions
diff --git a/drivers/media/video/ivtv/ivtv-i2c.c b/drivers/media/video/ivtv/ivtv-i2c.c
new file mode 100644
index 000000000000..50624c6a62a5
--- /dev/null
+++ b/drivers/media/video/ivtv/ivtv-i2c.c
@@ -0,0 +1,748 @@
1/*
2 I2C functions
3 Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com>
4 Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21/*
22 This file includes an i2c implementation that was reverse engineered
23 from the Hauppauge windows driver. Older ivtv versions used i2c-algo-bit,
24 which whilst fine under most circumstances, had trouble with the Zilog
25 CPU on the PVR-150 which handles IR functions (occasional inability to
26 communicate with the chip until it was reset) and also with the i2c
27 bus being completely unreachable when multiple PVR cards were present.
28
29 The implementation is very similar to i2c-algo-bit, but there are enough
30 subtle differences that the two are hard to merge. The general strategy
31 employed by i2c-algo-bit is to use udelay() to implement the timing
32 when putting out bits on the scl/sda lines. The general strategy taken
33 here is to poll the lines for state changes (see ivtv_waitscl and
34 ivtv_waitsda). In addition there are small delays at various locations
35 which poll the SCL line 5 times (ivtv_scldelay). I would guess that
36 since this is memory mapped I/O that the length of those delays is tied
37 to the PCI bus clock. There is some extra code to do with recovery
38 and retries. Since it is not known what causes the actual i2c problems
39 in the first place, the only goal if one was to attempt to use
40 i2c-algo-bit would be to try to make it follow the same code path.
41 This would be a lot of work, and I'm also not convinced that it would
42 provide a generic benefit to i2c-algo-bit. Therefore consider this
43 an engineering solution -- not pretty, but it works.
44
45 Some more general comments about what we are doing:
46
47 The i2c bus is a 2 wire serial bus, with clock (SCL) and data (SDA)
48 lines. To communicate on the bus (as a master, we don't act as a slave),
49 we first initiate a start condition (ivtv_start). We then write the
50 address of the device that we want to communicate with, along with a flag
51 that indicates whether this is a read or a write. The slave then issues
52 an ACK signal (ivtv_ack), which tells us that it is ready for reading /
53 writing. We then proceed with reading or writing (ivtv_read/ivtv_write),
54 and finally issue a stop condition (ivtv_stop) to make the bus available
55 to other masters.
56
57 There is an additional form of transaction where a write may be
58 immediately followed by a read. In this case, there is no intervening
59 stop condition. (Only the msp3400 chip uses this method of data transfer).
60 */
61
62#include "ivtv-driver.h"
63#include "ivtv-cards.h"
64#include "ivtv-gpio.h"
65#include "ivtv-i2c.h"
66
67#include <media/ir-kbd-i2c.h>
68
69/* i2c implementation for cx23415/6 chip, ivtv project.
70 * Author: Kevin Thayer (nufan_wfk at yahoo.com)
71 */
72/* i2c stuff */
73#define IVTV_REG_I2C_SETSCL_OFFSET 0x7000
74#define IVTV_REG_I2C_SETSDA_OFFSET 0x7004
75#define IVTV_REG_I2C_GETSCL_OFFSET 0x7008
76#define IVTV_REG_I2C_GETSDA_OFFSET 0x700c
77
78#ifndef I2C_ADAP_CLASS_TV_ANALOG
79#define I2C_ADAP_CLASS_TV_ANALOG I2C_CLASS_TV_ANALOG
80#endif /* I2C_ADAP_CLASS_TV_ANALOG */
81
82#define IVTV_CS53L32A_I2C_ADDR 0x11
83#define IVTV_CX25840_I2C_ADDR 0x44
84#define IVTV_SAA7115_I2C_ADDR 0x21
85#define IVTV_SAA7127_I2C_ADDR 0x44
86#define IVTV_SAA717x_I2C_ADDR 0x21
87#define IVTV_MSP3400_I2C_ADDR 0x40
88#define IVTV_HAUPPAUGE_I2C_ADDR 0x50
89#define IVTV_WM8739_I2C_ADDR 0x1a
90#define IVTV_WM8775_I2C_ADDR 0x1b
91#define IVTV_TEA5767_I2C_ADDR 0x60
92#define IVTV_UPD64031A_I2C_ADDR 0x12
93#define IVTV_UPD64083_I2C_ADDR 0x5c
94#define IVTV_TDA985X_I2C_ADDR 0x5b
95
96/* This array should match the IVTV_HW_ defines */
97static const u8 hw_driverids[] = {
98 I2C_DRIVERID_CX25840,
99 I2C_DRIVERID_SAA711X,
100 I2C_DRIVERID_SAA7127,
101 I2C_DRIVERID_MSP3400,
102 I2C_DRIVERID_TUNER,
103 I2C_DRIVERID_WM8775,
104 I2C_DRIVERID_CS53L32A,
105 I2C_DRIVERID_TVEEPROM,
106 I2C_DRIVERID_SAA711X,
107 I2C_DRIVERID_TVAUDIO,
108 I2C_DRIVERID_UPD64031A,
109 I2C_DRIVERID_UPD64083,
110 I2C_DRIVERID_SAA717X,
111 I2C_DRIVERID_WM8739,
112 0 /* IVTV_HW_GPIO dummy driver ID */
113};
114
115/* This array should match the IVTV_HW_ defines */
116static const char * const hw_drivernames[] = {
117 "cx2584x",
118 "saa7115",
119 "saa7127",
120 "msp3400",
121 "tuner",
122 "wm8775",
123 "cs53l32a",
124 "tveeprom",
125 "saa7114",
126 "tvaudio",
127 "upd64031a",
128 "upd64083",
129 "saa717x",
130 "wm8739",
131 "gpio",
132};
133
134static int attach_inform(struct i2c_client *client)
135{
136 struct ivtv *itv = (struct ivtv *)i2c_get_adapdata(client->adapter);
137 int i;
138
139 IVTV_DEBUG_I2C("i2c client attach\n");
140 for (i = 0; i < I2C_CLIENTS_MAX; i++) {
141 if (itv->i2c_clients[i] == NULL) {
142 itv->i2c_clients[i] = client;
143 break;
144 }
145 }
146 if (i == I2C_CLIENTS_MAX) {
147 IVTV_ERR("insufficient room for new I2C client!\n");
148 }
149 return 0;
150}
151
152static int detach_inform(struct i2c_client *client)
153{
154 int i;
155 struct ivtv *itv = (struct ivtv *)i2c_get_adapdata(client->adapter);
156
157 IVTV_DEBUG_I2C("i2c client detach\n");
158 for (i = 0; i < I2C_CLIENTS_MAX; i++) {
159 if (itv->i2c_clients[i] == client) {
160 itv->i2c_clients[i] = NULL;
161 break;
162 }
163 }
164 IVTV_DEBUG_I2C("i2c detach [client=%s,%s]\n",
165 client->name, (i < I2C_CLIENTS_MAX) ? "ok" : "failed");
166
167 return 0;
168}
169
170/* Set the serial clock line to the desired state */
171static void ivtv_setscl(struct ivtv *itv, int state)
172{
173 /* write them out */
174 /* write bits are inverted */
175 write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET);
176}
177
178/* Set the serial data line to the desired state */
179static void ivtv_setsda(struct ivtv *itv, int state)
180{
181 /* write them out */
182 /* write bits are inverted */
183 write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET);
184}
185
186/* Read the serial clock line */
187static int ivtv_getscl(struct ivtv *itv)
188{
189 return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
190}
191
192/* Read the serial data line */
193static int ivtv_getsda(struct ivtv *itv)
194{
195 return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
196}
197
198/* Implement a short delay by polling the serial clock line */
199static void ivtv_scldelay(struct ivtv *itv)
200{
201 int i;
202
203 for (i = 0; i < 5; ++i)
204 ivtv_getscl(itv);
205}
206
207/* Wait for the serial clock line to become set to a specific value */
208static int ivtv_waitscl(struct ivtv *itv, int val)
209{
210 int i;
211
212 ivtv_scldelay(itv);
213 for (i = 0; i < 1000; ++i) {
214 if (ivtv_getscl(itv) == val)
215 return 1;
216 }
217 return 0;
218}
219
220/* Wait for the serial data line to become set to a specific value */
221static int ivtv_waitsda(struct ivtv *itv, int val)
222{
223 int i;
224
225 ivtv_scldelay(itv);
226 for (i = 0; i < 1000; ++i) {
227 if (ivtv_getsda(itv) == val)
228 return 1;
229 }
230 return 0;
231}
232
233/* Wait for the slave to issue an ACK */
234static int ivtv_ack(struct ivtv *itv)
235{
236 int ret = 0;
237
238 if (ivtv_getscl(itv) == 1) {
239 IVTV_DEBUG_I2C("SCL was high starting an ack\n");
240 ivtv_setscl(itv, 0);
241 if (!ivtv_waitscl(itv, 0)) {
242 IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n");
243 return -EREMOTEIO;
244 }
245 }
246 ivtv_setsda(itv, 1);
247 ivtv_scldelay(itv);
248 ivtv_setscl(itv, 1);
249 if (!ivtv_waitsda(itv, 0)) {
250 IVTV_DEBUG_I2C("Slave did not ack\n");
251 ret = -EREMOTEIO;
252 }
253 ivtv_setscl(itv, 0);
254 if (!ivtv_waitscl(itv, 0)) {
255 IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n");
256 ret = -EREMOTEIO;
257 }
258 return ret;
259}
260
261/* Write a single byte to the i2c bus and wait for the slave to ACK */
262static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte)
263{
264 int i, bit;
265
266 IVTV_DEBUG_I2C("write %x\n",byte);
267 for (i = 0; i < 8; ++i, byte<<=1) {
268 ivtv_setscl(itv, 0);
269 if (!ivtv_waitscl(itv, 0)) {
270 IVTV_DEBUG_I2C("Error setting SCL low\n");
271 return -EREMOTEIO;
272 }
273 bit = (byte>>7)&1;
274 ivtv_setsda(itv, bit);
275 if (!ivtv_waitsda(itv, bit)) {
276 IVTV_DEBUG_I2C("Error setting SDA\n");
277 return -EREMOTEIO;
278 }
279 ivtv_setscl(itv, 1);
280 if (!ivtv_waitscl(itv, 1)) {
281 IVTV_DEBUG_I2C("Slave not ready for bit\n");
282 return -EREMOTEIO;
283 }
284 }
285 ivtv_setscl(itv, 0);
286 if (!ivtv_waitscl(itv, 0)) {
287 IVTV_DEBUG_I2C("Error setting SCL low\n");
288 return -EREMOTEIO;
289 }
290 return ivtv_ack(itv);
291}
292
293/* Read a byte from the i2c bus and send a NACK if applicable (i.e. for the
294 final byte) */
295static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack)
296{
297 int i;
298
299 *byte = 0;
300
301 ivtv_setsda(itv, 1);
302 ivtv_scldelay(itv);
303 for (i = 0; i < 8; ++i) {
304 ivtv_setscl(itv, 0);
305 ivtv_scldelay(itv);
306 ivtv_setscl(itv, 1);
307 if (!ivtv_waitscl(itv, 1)) {
308 IVTV_DEBUG_I2C("Error setting SCL high\n");
309 return -EREMOTEIO;
310 }
311 *byte = ((*byte)<<1)|ivtv_getsda(itv);
312 }
313 ivtv_setscl(itv, 0);
314 ivtv_scldelay(itv);
315 ivtv_setsda(itv, nack);
316 ivtv_scldelay(itv);
317 ivtv_setscl(itv, 1);
318 ivtv_scldelay(itv);
319 ivtv_setscl(itv, 0);
320 ivtv_scldelay(itv);
321 IVTV_DEBUG_I2C("read %x\n",*byte);
322 return 0;
323}
324
325/* Issue a start condition on the i2c bus to alert slaves to prepare for
326 an address write */
327static int ivtv_start(struct ivtv *itv)
328{
329 int sda;
330
331 sda = ivtv_getsda(itv);
332 if (sda != 1) {
333 IVTV_DEBUG_I2C("SDA was low at start\n");
334 ivtv_setsda(itv, 1);
335 if (!ivtv_waitsda(itv, 1)) {
336 IVTV_DEBUG_I2C("SDA stuck low\n");
337 return -EREMOTEIO;
338 }
339 }
340 if (ivtv_getscl(itv) != 1) {
341 ivtv_setscl(itv, 1);
342 if (!ivtv_waitscl(itv, 1)) {
343 IVTV_DEBUG_I2C("SCL stuck low at start\n");
344 return -EREMOTEIO;
345 }
346 }
347 ivtv_setsda(itv, 0);
348 ivtv_scldelay(itv);
349 return 0;
350}
351
352/* Issue a stop condition on the i2c bus to release it */
353static int ivtv_stop(struct ivtv *itv)
354{
355 int i;
356
357 if (ivtv_getscl(itv) != 0) {
358 IVTV_DEBUG_I2C("SCL not low when stopping\n");
359 ivtv_setscl(itv, 0);
360 if (!ivtv_waitscl(itv, 0)) {
361 IVTV_DEBUG_I2C("SCL could not be set low\n");
362 }
363 }
364 ivtv_setsda(itv, 0);
365 ivtv_scldelay(itv);
366 ivtv_setscl(itv, 1);
367 if (!ivtv_waitscl(itv, 1)) {
368 IVTV_DEBUG_I2C("SCL could not be set high\n");
369 return -EREMOTEIO;
370 }
371 ivtv_scldelay(itv);
372 ivtv_setsda(itv, 1);
373 if (!ivtv_waitsda(itv, 1)) {
374 IVTV_DEBUG_I2C("resetting I2C\n");
375 for (i = 0; i < 16; ++i) {
376 ivtv_setscl(itv, 0);
377 ivtv_scldelay(itv);
378 ivtv_setscl(itv, 1);
379 ivtv_scldelay(itv);
380 ivtv_setsda(itv, 1);
381 }
382 ivtv_waitsda(itv, 1);
383 return -EREMOTEIO;
384 }
385 return 0;
386}
387
388/* Write a message to the given i2c slave. do_stop may be 0 to prevent
389 issuing the i2c stop condition (when following with a read) */
390static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop)
391{
392 int retry, ret = -EREMOTEIO;
393 u32 i;
394
395 for (retry = 0; ret != 0 && retry < 8; ++retry) {
396 ret = ivtv_start(itv);
397
398 if (ret == 0) {
399 ret = ivtv_sendbyte(itv, addr<<1);
400 for (i = 0; ret == 0 && i < len; ++i)
401 ret = ivtv_sendbyte(itv, data[i]);
402 }
403 if (ret != 0 || do_stop) {
404 ivtv_stop(itv);
405 }
406 }
407 if (ret)
408 IVTV_DEBUG_I2C("i2c write to %x failed\n", addr);
409 return ret;
410}
411
412/* Read data from the given i2c slave. A stop condition is always issued. */
413static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len)
414{
415 int retry, ret = -EREMOTEIO;
416 u32 i;
417
418 for (retry = 0; ret != 0 && retry < 8; ++retry) {
419 ret = ivtv_start(itv);
420 if (ret == 0)
421 ret = ivtv_sendbyte(itv, (addr << 1) | 1);
422 for (i = 0; ret == 0 && i < len; ++i) {
423 ret = ivtv_readbyte(itv, &data[i], i == len - 1);
424 }
425 ivtv_stop(itv);
426 }
427 if (ret)
428 IVTV_DEBUG_I2C("i2c read from %x failed\n", addr);
429 return ret;
430}
431
432/* Kernel i2c transfer implementation. Takes a number of messages to be read
433 or written. If a read follows a write, this will occur without an
434 intervening stop condition */
435static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
436{
437 struct ivtv *itv = i2c_get_adapdata(i2c_adap);
438 int retval;
439 int i;
440
441 mutex_lock(&itv->i2c_bus_lock);
442 for (i = retval = 0; retval == 0 && i < num; i++) {
443 if (msgs[i].flags & I2C_M_RD)
444 retval = ivtv_read(itv, msgs[i].addr, msgs[i].buf, msgs[i].len);
445 else {
446 /* if followed by a read, don't stop */
447 int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD);
448
449 retval = ivtv_write(itv, msgs[i].addr, msgs[i].buf, msgs[i].len, stop);
450 }
451 }
452 mutex_unlock(&itv->i2c_bus_lock);
453 return retval ? retval : num;
454}
455
456/* Kernel i2c capabilities */
457static u32 ivtv_functionality(struct i2c_adapter *adap)
458{
459 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
460}
461
462static struct i2c_algorithm ivtv_algo = {
463 .master_xfer = ivtv_xfer,
464 .functionality = ivtv_functionality,
465};
466
467/* template for our-bit banger */
468static struct i2c_adapter ivtv_i2c_adap_hw_template = {
469 .name = "ivtv i2c driver",
470 .id = I2C_HW_B_CX2341X,
471 .algo = &ivtv_algo,
472 .algo_data = NULL, /* filled from template */
473 .client_register = attach_inform,
474 .client_unregister = detach_inform,
475 .owner = THIS_MODULE,
476#ifdef I2C_ADAP_CLASS_TV_ANALOG
477 .class = I2C_ADAP_CLASS_TV_ANALOG,
478#endif
479};
480
481static void ivtv_setscl_old(void *data, int state)
482{
483 struct ivtv *itv = (struct ivtv *)data;
484
485 if (state)
486 itv->i2c_state |= 0x01;
487 else
488 itv->i2c_state &= ~0x01;
489
490 /* write them out */
491 /* write bits are inverted */
492 write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET);
493}
494
495static void ivtv_setsda_old(void *data, int state)
496{
497 struct ivtv *itv = (struct ivtv *)data;
498
499 if (state)
500 itv->i2c_state |= 0x01;
501 else
502 itv->i2c_state &= ~0x01;
503
504 /* write them out */
505 /* write bits are inverted */
506 write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSDA_OFFSET);
507}
508
509static int ivtv_getscl_old(void *data)
510{
511 struct ivtv *itv = (struct ivtv *)data;
512
513 return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
514}
515
516static int ivtv_getsda_old(void *data)
517{
518 struct ivtv *itv = (struct ivtv *)data;
519
520 return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
521}
522
523/* template for i2c-bit-algo */
524static struct i2c_adapter ivtv_i2c_adap_template = {
525 .name = "ivtv i2c driver",
526 .id = I2C_HW_B_CX2341X, /* algo-bit is OR'd with this */
527 .algo = NULL, /* set by i2c-algo-bit */
528 .algo_data = NULL, /* filled from template */
529 .client_register = attach_inform,
530 .client_unregister = detach_inform,
531 .owner = THIS_MODULE,
532#ifdef I2C_ADAP_CLASS_TV_ANALOG
533 .class = I2C_ADAP_CLASS_TV_ANALOG,
534#endif
535};
536
537static struct i2c_algo_bit_data ivtv_i2c_algo_template = {
538 NULL, /* ?? */
539 ivtv_setsda_old, /* setsda function */
540 ivtv_setscl_old, /* " */
541 ivtv_getsda_old, /* " */
542 ivtv_getscl_old, /* " */
543 10, /* udelay */
544 200 /* timeout */
545};
546
547static struct i2c_client ivtv_i2c_client_template = {
548 .name = "ivtv internal",
549};
550
551int ivtv_call_i2c_client(struct ivtv *itv, int addr, unsigned int cmd, void *arg)
552{
553 struct i2c_client *client;
554 int retval;
555 int i;
556
557 IVTV_DEBUG_I2C("call_i2c_client addr=%02x\n", addr);
558 for (i = 0; i < I2C_CLIENTS_MAX; i++) {
559 client = itv->i2c_clients[i];
560 if (client == NULL) {
561 continue;
562 }
563 if (client->driver->command == NULL) {
564 continue;
565 }
566 if (addr == client->addr) {
567 retval = client->driver->command(client, cmd, arg);
568 return retval;
569 }
570 }
571 if (cmd != VIDIOC_G_CHIP_IDENT)
572 IVTV_ERR("i2c addr 0x%02x not found for command 0x%x!\n", addr, cmd);
573 return -ENODEV;
574}
575
576/* Find the i2c device based on the driver ID and return
577 its i2c address or -ENODEV if no matching device was found. */
578static int ivtv_i2c_id_addr(struct ivtv *itv, u32 id)
579{
580 struct i2c_client *client;
581 int retval = -ENODEV;
582 int i;
583
584 for (i = 0; i < I2C_CLIENTS_MAX; i++) {
585 client = itv->i2c_clients[i];
586 if (client == NULL)
587 continue;
588 if (id == client->driver->id) {
589 retval = client->addr;
590 break;
591 }
592 }
593 return retval;
594}
595
596/* Find the i2c device name matching the DRIVERID */
597static const char *ivtv_i2c_id_name(u32 id)
598{
599 int i;
600
601 for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
602 if (hw_driverids[i] == id)
603 return hw_drivernames[i];
604 return "unknown device";
605}
606
607/* Find the i2c device name matching the IVTV_HW_ flag */
608static const char *ivtv_i2c_hw_name(u32 hw)
609{
610 int i;
611
612 for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
613 if (1 << i == hw)
614 return hw_drivernames[i];
615 return "unknown device";
616}
617
618/* Find the i2c device matching the IVTV_HW_ flag and return
619 its i2c address or -ENODEV if no matching device was found. */
620int ivtv_i2c_hw_addr(struct ivtv *itv, u32 hw)
621{
622 int i;
623
624 for (i = 0; i < ARRAY_SIZE(hw_driverids); i++)
625 if (1 << i == hw)
626 return ivtv_i2c_id_addr(itv, hw_driverids[i]);
627 return -ENODEV;
628}
629
630/* Calls i2c device based on IVTV_HW_ flag. If hw == 0, then do nothing.
631 If hw == IVTV_HW_GPIO then call the gpio handler. */
632int ivtv_i2c_hw(struct ivtv *itv, u32 hw, unsigned int cmd, void *arg)
633{
634 int addr;
635
636 if (hw == IVTV_HW_GPIO)
637 return ivtv_gpio(itv, cmd, arg);
638 if (hw == 0)
639 return 0;
640
641 addr = ivtv_i2c_hw_addr(itv, hw);
642 if (addr < 0) {
643 IVTV_ERR("i2c hardware 0x%08x (%s) not found for command 0x%x!\n",
644 hw, ivtv_i2c_hw_name(hw), cmd);
645 return addr;
646 }
647 return ivtv_call_i2c_client(itv, addr, cmd, arg);
648}
649
650/* Calls i2c device based on I2C driver ID. */
651int ivtv_i2c_id(struct ivtv *itv, u32 id, unsigned int cmd, void *arg)
652{
653 int addr;
654
655 addr = ivtv_i2c_id_addr(itv, id);
656 if (addr < 0) {
657 if (cmd != VIDIOC_G_CHIP_IDENT)
658 IVTV_ERR("i2c ID 0x%08x (%s) not found for command 0x%x!\n",
659 id, ivtv_i2c_id_name(id), cmd);
660 return addr;
661 }
662 return ivtv_call_i2c_client(itv, addr, cmd, arg);
663}
664
665int ivtv_cx25840(struct ivtv *itv, unsigned int cmd, void *arg)
666{
667 return ivtv_call_i2c_client(itv, IVTV_CX25840_I2C_ADDR, cmd, arg);
668}
669
670int ivtv_saa7115(struct ivtv *itv, unsigned int cmd, void *arg)
671{
672 return ivtv_call_i2c_client(itv, IVTV_SAA7115_I2C_ADDR, cmd, arg);
673}
674
675int ivtv_saa7127(struct ivtv *itv, unsigned int cmd, void *arg)
676{
677 return ivtv_call_i2c_client(itv, IVTV_SAA7127_I2C_ADDR, cmd, arg);
678}
679
680int ivtv_saa717x(struct ivtv *itv, unsigned int cmd, void *arg)
681{
682 return ivtv_call_i2c_client(itv, IVTV_SAA717x_I2C_ADDR, cmd, arg);
683}
684
685int ivtv_upd64031a(struct ivtv *itv, unsigned int cmd, void *arg)
686{
687 return ivtv_call_i2c_client(itv, IVTV_UPD64031A_I2C_ADDR, cmd, arg);
688}
689
690int ivtv_upd64083(struct ivtv *itv, unsigned int cmd, void *arg)
691{
692 return ivtv_call_i2c_client(itv, IVTV_UPD64083_I2C_ADDR, cmd, arg);
693}
694
695/* broadcast cmd for all I2C clients and for the gpio subsystem */
696void ivtv_call_i2c_clients(struct ivtv *itv, unsigned int cmd, void *arg)
697{
698 if (itv->i2c_adap.algo == NULL) {
699 IVTV_ERR("adapter is not set");
700 return;
701 }
702 i2c_clients_command(&itv->i2c_adap, cmd, arg);
703 if (itv->hw_flags & IVTV_HW_GPIO)
704 ivtv_gpio(itv, cmd, arg);
705}
706
707/* init + register i2c algo-bit adapter */
708int __devinit init_ivtv_i2c(struct ivtv *itv)
709{
710 IVTV_DEBUG_I2C("i2c init\n");
711
712 if (itv->options.newi2c > 0) {
713 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_hw_template,
714 sizeof(struct i2c_adapter));
715 } else {
716 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_template,
717 sizeof(struct i2c_adapter));
718 memcpy(&itv->i2c_algo, &ivtv_i2c_algo_template,
719 sizeof(struct i2c_algo_bit_data));
720 itv->i2c_algo.data = itv;
721 itv->i2c_adap.algo_data = &itv->i2c_algo;
722 }
723
724 sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d",
725 itv->num);
726 i2c_set_adapdata(&itv->i2c_adap, itv);
727
728 memcpy(&itv->i2c_client, &ivtv_i2c_client_template,
729 sizeof(struct i2c_client));
730 itv->i2c_client.adapter = &itv->i2c_adap;
731 itv->i2c_adap.dev.parent = &itv->dev->dev;
732
733 IVTV_DEBUG_I2C("setting scl and sda to 1\n");
734 ivtv_setscl(itv, 1);
735 ivtv_setsda(itv, 1);
736
737 if (itv->options.newi2c > 0)
738 return i2c_add_adapter(&itv->i2c_adap);
739 else
740 return i2c_bit_add_bus(&itv->i2c_adap);
741}
742
743void __devexit exit_ivtv_i2c(struct ivtv *itv)
744{
745 IVTV_DEBUG_I2C("i2c exit\n");
746
747 i2c_del_adapter(&itv->i2c_adap);
748}
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-03 02:36:03 -0500