1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 I2C functions
4 Copyright (C) 2003-2004 Kevin Thayer <nufan_wfk at yahoo.com>
5 Copyright (C) 2005-2007 Hans Verkuil <hverkuil@xs4all.nl>
6
7 */
8
9 /*
10 This file includes an i2c implementation that was reverse engineered
11 from the Hauppauge windows driver. Older ivtv versions used i2c-algo-bit,
12 which whilst fine under most circumstances, had trouble with the Zilog
13 CPU on the PVR-150 which handles IR functions (occasional inability to
14 communicate with the chip until it was reset) and also with the i2c
15 bus being completely unreachable when multiple PVR cards were present.
16
17 The implementation is very similar to i2c-algo-bit, but there are enough
18 subtle differences that the two are hard to merge. The general strategy
19 employed by i2c-algo-bit is to use udelay() to implement the timing
20 when putting out bits on the scl/sda lines. The general strategy taken
21 here is to poll the lines for state changes (see ivtv_waitscl and
22 ivtv_waitsda). In addition there are small delays at various locations
23 which poll the SCL line 5 times (ivtv_scldelay). I would guess that
24 since this is memory mapped I/O that the length of those delays is tied
25 to the PCI bus clock. There is some extra code to do with recovery
26 and retries. Since it is not known what causes the actual i2c problems
27 in the first place, the only goal if one was to attempt to use
28 i2c-algo-bit would be to try to make it follow the same code path.
29 This would be a lot of work, and I'm also not convinced that it would
30 provide a generic benefit to i2c-algo-bit. Therefore consider this
31 an engineering solution -- not pretty, but it works.
32
33 Some more general comments about what we are doing:
34
35 The i2c bus is a 2 wire serial bus, with clock (SCL) and data (SDA)
36 lines. To communicate on the bus (as a master, we don't act as a slave),
37 we first initiate a start condition (ivtv_start). We then write the
38 address of the device that we want to communicate with, along with a flag
39 that indicates whether this is a read or a write. The slave then issues
40 an ACK signal (ivtv_ack), which tells us that it is ready for reading /
41 writing. We then proceed with reading or writing (ivtv_read/ivtv_write),
42 and finally issue a stop condition (ivtv_stop) to make the bus available
43 to other masters.
44
45 There is an additional form of transaction where a write may be
46 immediately followed by a read. In this case, there is no intervening
47 stop condition. (Only the msp3400 chip uses this method of data transfer).
48 */
49
50 #include "ivtv-driver.h"
51 #include "ivtv-cards.h"
52 #include "ivtv-gpio.h"
53 #include "ivtv-i2c.h"
54 #include <media/drv-intf/cx25840.h>
55
56 /* i2c implementation for cx23415/6 chip, ivtv project.
57 * Author: Kevin Thayer (nufan_wfk at yahoo.com)
58 */
59 /* i2c stuff */
60 #define IVTV_REG_I2C_SETSCL_OFFSET 0x7000
61 #define IVTV_REG_I2C_SETSDA_OFFSET 0x7004
62 #define IVTV_REG_I2C_GETSCL_OFFSET 0x7008
63 #define IVTV_REG_I2C_GETSDA_OFFSET 0x700c
64
65 #define IVTV_CS53L32A_I2C_ADDR 0x11
66 #define IVTV_M52790_I2C_ADDR 0x48
67 #define IVTV_CX25840_I2C_ADDR 0x44
68 #define IVTV_SAA7115_I2C_ADDR 0x21
69 #define IVTV_SAA7127_I2C_ADDR 0x44
70 #define IVTV_SAA717x_I2C_ADDR 0x21
71 #define IVTV_MSP3400_I2C_ADDR 0x40
72 #define IVTV_HAUPPAUGE_I2C_ADDR 0x50
73 #define IVTV_WM8739_I2C_ADDR 0x1a
74 #define IVTV_WM8775_I2C_ADDR 0x1b
75 #define IVTV_TEA5767_I2C_ADDR 0x60
76 #define IVTV_UPD64031A_I2C_ADDR 0x12
77 #define IVTV_UPD64083_I2C_ADDR 0x5c
78 #define IVTV_VP27SMPX_I2C_ADDR 0x5b
79 #define IVTV_M52790_I2C_ADDR 0x48
80 #define IVTV_AVERMEDIA_IR_RX_I2C_ADDR 0x40
81 #define IVTV_HAUP_EXT_IR_RX_I2C_ADDR 0x1a
82 #define IVTV_HAUP_INT_IR_RX_I2C_ADDR 0x18
83 #define IVTV_Z8F0811_IR_TX_I2C_ADDR 0x70
84 #define IVTV_Z8F0811_IR_RX_I2C_ADDR 0x71
85 #define IVTV_ADAPTEC_IR_ADDR 0x6b
86
87 /* This array should match the IVTV_HW_ defines */
88 static const u8 hw_addrs[] = {
89 IVTV_CX25840_I2C_ADDR,
90 IVTV_SAA7115_I2C_ADDR,
91 IVTV_SAA7127_I2C_ADDR,
92 IVTV_MSP3400_I2C_ADDR,
93 0,
94 IVTV_WM8775_I2C_ADDR,
95 IVTV_CS53L32A_I2C_ADDR,
96 0,
97 IVTV_SAA7115_I2C_ADDR,
98 IVTV_UPD64031A_I2C_ADDR,
99 IVTV_UPD64083_I2C_ADDR,
100 IVTV_SAA717x_I2C_ADDR,
101 IVTV_WM8739_I2C_ADDR,
102 IVTV_VP27SMPX_I2C_ADDR,
103 IVTV_M52790_I2C_ADDR,
104 0, /* IVTV_HW_GPIO dummy driver ID */
105 IVTV_AVERMEDIA_IR_RX_I2C_ADDR, /* IVTV_HW_I2C_IR_RX_AVER */
106 IVTV_HAUP_EXT_IR_RX_I2C_ADDR, /* IVTV_HW_I2C_IR_RX_HAUP_EXT */
107 IVTV_HAUP_INT_IR_RX_I2C_ADDR, /* IVTV_HW_I2C_IR_RX_HAUP_INT */
108 IVTV_Z8F0811_IR_RX_I2C_ADDR, /* IVTV_HW_Z8F0811_IR_HAUP */
109 IVTV_ADAPTEC_IR_ADDR, /* IVTV_HW_I2C_IR_RX_ADAPTEC */
110 };
111
112 /* This array should match the IVTV_HW_ defines */
113 static const char * const hw_devicenames[] = {
114 "cx25840",
115 "saa7115",
116 "saa7127_auto", /* saa7127 or saa7129 */
117 "msp3400",
118 "tuner",
119 "wm8775",
120 "cs53l32a",
121 "tveeprom",
122 "saa7114",
123 "upd64031a",
124 "upd64083",
125 "saa717x",
126 "wm8739",
127 "vp27smpx",
128 "m52790",
129 "gpio",
130 "ir_video", /* IVTV_HW_I2C_IR_RX_AVER */
131 "ir_video", /* IVTV_HW_I2C_IR_RX_HAUP_EXT */
132 "ir_video", /* IVTV_HW_I2C_IR_RX_HAUP_INT */
133 "ir_z8f0811_haup", /* IVTV_HW_Z8F0811_IR_HAUP */
134 "ir_video", /* IVTV_HW_I2C_IR_RX_ADAPTEC */
135 };
136
get_key_adaptec(struct IR_i2c * ir,enum rc_proto * protocol,u32 * scancode,u8 * toggle)137 static int get_key_adaptec(struct IR_i2c *ir, enum rc_proto *protocol,
138 u32 *scancode, u8 *toggle)
139 {
140 unsigned char keybuf[4];
141
142 keybuf[0] = 0x00;
143 i2c_master_send(ir->c, keybuf, 1);
144 /* poll IR chip */
145 if (i2c_master_recv(ir->c, keybuf, sizeof(keybuf)) != sizeof(keybuf)) {
146 return 0;
147 }
148
149 /* key pressed ? */
150 if (keybuf[2] == 0xff)
151 return 0;
152
153 /* remove repeat bit */
154 keybuf[2] &= 0x7f;
155 keybuf[3] |= 0x80;
156
157 *protocol = RC_PROTO_UNKNOWN;
158 *scancode = keybuf[3] | keybuf[2] << 8 | keybuf[1] << 16 |keybuf[0] << 24;
159 *toggle = 0;
160 return 1;
161 }
162
ivtv_i2c_new_ir(struct ivtv * itv,u32 hw,const char * type,u8 addr)163 static int ivtv_i2c_new_ir(struct ivtv *itv, u32 hw, const char *type, u8 addr)
164 {
165 struct i2c_board_info info;
166 struct i2c_adapter *adap = &itv->i2c_adap;
167 struct IR_i2c_init_data *init_data = &itv->ir_i2c_init_data;
168 unsigned short addr_list[2] = { addr, I2C_CLIENT_END };
169
170 /* Only allow one IR receiver to be registered per board */
171 if (itv->hw_flags & IVTV_HW_IR_ANY)
172 return -1;
173
174 /* Our default information for ir-kbd-i2c.c to use */
175 switch (hw) {
176 case IVTV_HW_I2C_IR_RX_AVER:
177 init_data->ir_codes = RC_MAP_AVERMEDIA_CARDBUS;
178 init_data->internal_get_key_func =
179 IR_KBD_GET_KEY_AVERMEDIA_CARDBUS;
180 init_data->type = RC_PROTO_BIT_OTHER;
181 init_data->name = "AVerMedia AVerTV card";
182 break;
183 case IVTV_HW_I2C_IR_RX_HAUP_EXT:
184 case IVTV_HW_I2C_IR_RX_HAUP_INT:
185 init_data->ir_codes = RC_MAP_HAUPPAUGE;
186 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP;
187 init_data->type = RC_PROTO_BIT_RC5;
188 init_data->name = itv->card_name;
189 break;
190 case IVTV_HW_Z8F0811_IR_HAUP:
191 /* Default to grey remote */
192 init_data->ir_codes = RC_MAP_HAUPPAUGE;
193 init_data->internal_get_key_func = IR_KBD_GET_KEY_HAUP_XVR;
194 init_data->type = RC_PROTO_BIT_RC5 | RC_PROTO_BIT_RC6_MCE |
195 RC_PROTO_BIT_RC6_6A_32;
196 init_data->name = itv->card_name;
197 break;
198 case IVTV_HW_I2C_IR_RX_ADAPTEC:
199 init_data->get_key = get_key_adaptec;
200 init_data->name = itv->card_name;
201 /* FIXME: The protocol and RC_MAP needs to be corrected */
202 init_data->ir_codes = RC_MAP_EMPTY;
203 init_data->type = RC_PROTO_BIT_UNKNOWN;
204 break;
205 }
206
207 memset(&info, 0, sizeof(struct i2c_board_info));
208 info.platform_data = init_data;
209 strscpy(info.type, type, I2C_NAME_SIZE);
210
211 return IS_ERR(i2c_new_scanned_device(adap, &info, addr_list, NULL)) ?
212 -1 : 0;
213 }
214
215 /* Instantiate the IR receiver device using probing -- undesirable */
ivtv_i2c_new_ir_legacy(struct ivtv * itv)216 void ivtv_i2c_new_ir_legacy(struct ivtv *itv)
217 {
218 struct i2c_board_info info;
219 /*
220 * The external IR receiver is at i2c address 0x34.
221 * The internal IR receiver is at i2c address 0x30.
222 *
223 * In theory, both can be fitted, and Hauppauge suggests an external
224 * overrides an internal. That's why we probe 0x1a (~0x34) first. CB
225 *
226 * Some of these addresses we probe may collide with other i2c address
227 * allocations, so this function must be called after all other i2c
228 * devices we care about are registered.
229 */
230 static const unsigned short addr_list[] = {
231 0x1a, /* Hauppauge IR external - collides with WM8739 */
232 0x18, /* Hauppauge IR internal */
233 I2C_CLIENT_END
234 };
235
236 memset(&info, 0, sizeof(struct i2c_board_info));
237 strscpy(info.type, "ir_video", I2C_NAME_SIZE);
238 i2c_new_scanned_device(&itv->i2c_adap, &info, addr_list, NULL);
239 }
240
ivtv_i2c_register(struct ivtv * itv,unsigned idx)241 int ivtv_i2c_register(struct ivtv *itv, unsigned idx)
242 {
243 struct v4l2_subdev *sd;
244 struct i2c_adapter *adap = &itv->i2c_adap;
245 const char *type = hw_devicenames[idx];
246 u32 hw = 1 << idx;
247
248 if (hw == IVTV_HW_TUNER) {
249 /* special tuner handling */
250 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev, adap, type, 0,
251 itv->card_i2c->radio);
252 if (sd)
253 sd->grp_id = 1 << idx;
254 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev, adap, type, 0,
255 itv->card_i2c->demod);
256 if (sd)
257 sd->grp_id = 1 << idx;
258 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev, adap, type, 0,
259 itv->card_i2c->tv);
260 if (sd)
261 sd->grp_id = 1 << idx;
262 return sd ? 0 : -1;
263 }
264
265 if (hw & IVTV_HW_IR_ANY)
266 return ivtv_i2c_new_ir(itv, hw, type, hw_addrs[idx]);
267
268 /* Is it not an I2C device or one we do not wish to register? */
269 if (!hw_addrs[idx])
270 return -1;
271
272 /* It's an I2C device other than an analog tuner or IR chip */
273 if (hw == IVTV_HW_UPD64031A || hw == IVTV_HW_UPD6408X) {
274 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
275 adap, type, 0, I2C_ADDRS(hw_addrs[idx]));
276 } else if (hw == IVTV_HW_CX25840) {
277 struct cx25840_platform_data pdata;
278 struct i2c_board_info cx25840_info = {
279 .type = "cx25840",
280 .addr = hw_addrs[idx],
281 .platform_data = &pdata,
282 };
283
284 memset(&pdata, 0, sizeof(pdata));
285 pdata.pvr150_workaround = itv->pvr150_workaround;
286 sd = v4l2_i2c_new_subdev_board(&itv->v4l2_dev, adap,
287 &cx25840_info, NULL);
288 } else {
289 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
290 adap, type, hw_addrs[idx], NULL);
291 }
292 if (sd)
293 sd->grp_id = 1 << idx;
294 return sd ? 0 : -1;
295 }
296
ivtv_find_hw(struct ivtv * itv,u32 hw)297 struct v4l2_subdev *ivtv_find_hw(struct ivtv *itv, u32 hw)
298 {
299 struct v4l2_subdev *result = NULL;
300 struct v4l2_subdev *sd;
301
302 spin_lock(&itv->v4l2_dev.lock);
303 v4l2_device_for_each_subdev(sd, &itv->v4l2_dev) {
304 if (sd->grp_id == hw) {
305 result = sd;
306 break;
307 }
308 }
309 spin_unlock(&itv->v4l2_dev.lock);
310 return result;
311 }
312
313 /* Set the serial clock line to the desired state */
ivtv_setscl(struct ivtv * itv,int state)314 static void ivtv_setscl(struct ivtv *itv, int state)
315 {
316 /* write them out */
317 /* write bits are inverted */
318 write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET);
319 }
320
321 /* Set the serial data line to the desired state */
ivtv_setsda(struct ivtv * itv,int state)322 static void ivtv_setsda(struct ivtv *itv, int state)
323 {
324 /* write them out */
325 /* write bits are inverted */
326 write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET);
327 }
328
329 /* Read the serial clock line */
ivtv_getscl(struct ivtv * itv)330 static int ivtv_getscl(struct ivtv *itv)
331 {
332 return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
333 }
334
335 /* Read the serial data line */
ivtv_getsda(struct ivtv * itv)336 static int ivtv_getsda(struct ivtv *itv)
337 {
338 return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
339 }
340
341 /* Implement a short delay by polling the serial clock line */
ivtv_scldelay(struct ivtv * itv)342 static void ivtv_scldelay(struct ivtv *itv)
343 {
344 int i;
345
346 for (i = 0; i < 5; ++i)
347 ivtv_getscl(itv);
348 }
349
350 /* Wait for the serial clock line to become set to a specific value */
ivtv_waitscl(struct ivtv * itv,int val)351 static int ivtv_waitscl(struct ivtv *itv, int val)
352 {
353 int i;
354
355 ivtv_scldelay(itv);
356 for (i = 0; i < 1000; ++i) {
357 if (ivtv_getscl(itv) == val)
358 return 1;
359 }
360 return 0;
361 }
362
363 /* Wait for the serial data line to become set to a specific value */
ivtv_waitsda(struct ivtv * itv,int val)364 static int ivtv_waitsda(struct ivtv *itv, int val)
365 {
366 int i;
367
368 ivtv_scldelay(itv);
369 for (i = 0; i < 1000; ++i) {
370 if (ivtv_getsda(itv) == val)
371 return 1;
372 }
373 return 0;
374 }
375
376 /* Wait for the slave to issue an ACK */
ivtv_ack(struct ivtv * itv)377 static int ivtv_ack(struct ivtv *itv)
378 {
379 int ret = 0;
380
381 if (ivtv_getscl(itv) == 1) {
382 IVTV_DEBUG_HI_I2C("SCL was high starting an ack\n");
383 ivtv_setscl(itv, 0);
384 if (!ivtv_waitscl(itv, 0)) {
385 IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n");
386 return -EREMOTEIO;
387 }
388 }
389 ivtv_setsda(itv, 1);
390 ivtv_scldelay(itv);
391 ivtv_setscl(itv, 1);
392 if (!ivtv_waitsda(itv, 0)) {
393 IVTV_DEBUG_I2C("Slave did not ack\n");
394 ret = -EREMOTEIO;
395 }
396 ivtv_setscl(itv, 0);
397 if (!ivtv_waitscl(itv, 0)) {
398 IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n");
399 ret = -EREMOTEIO;
400 }
401 return ret;
402 }
403
404 /* Write a single byte to the i2c bus and wait for the slave to ACK */
ivtv_sendbyte(struct ivtv * itv,unsigned char byte)405 static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte)
406 {
407 int i, bit;
408
409 IVTV_DEBUG_HI_I2C("write %x\n",byte);
410 for (i = 0; i < 8; ++i, byte<<=1) {
411 ivtv_setscl(itv, 0);
412 if (!ivtv_waitscl(itv, 0)) {
413 IVTV_DEBUG_I2C("Error setting SCL low\n");
414 return -EREMOTEIO;
415 }
416 bit = (byte>>7)&1;
417 ivtv_setsda(itv, bit);
418 if (!ivtv_waitsda(itv, bit)) {
419 IVTV_DEBUG_I2C("Error setting SDA\n");
420 return -EREMOTEIO;
421 }
422 ivtv_setscl(itv, 1);
423 if (!ivtv_waitscl(itv, 1)) {
424 IVTV_DEBUG_I2C("Slave not ready for bit\n");
425 return -EREMOTEIO;
426 }
427 }
428 ivtv_setscl(itv, 0);
429 if (!ivtv_waitscl(itv, 0)) {
430 IVTV_DEBUG_I2C("Error setting SCL low\n");
431 return -EREMOTEIO;
432 }
433 return ivtv_ack(itv);
434 }
435
436 /* Read a byte from the i2c bus and send a NACK if applicable (i.e. for the
437 final byte) */
ivtv_readbyte(struct ivtv * itv,unsigned char * byte,int nack)438 static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack)
439 {
440 int i;
441
442 *byte = 0;
443
444 ivtv_setsda(itv, 1);
445 ivtv_scldelay(itv);
446 for (i = 0; i < 8; ++i) {
447 ivtv_setscl(itv, 0);
448 ivtv_scldelay(itv);
449 ivtv_setscl(itv, 1);
450 if (!ivtv_waitscl(itv, 1)) {
451 IVTV_DEBUG_I2C("Error setting SCL high\n");
452 return -EREMOTEIO;
453 }
454 *byte = ((*byte)<<1)|ivtv_getsda(itv);
455 }
456 ivtv_setscl(itv, 0);
457 ivtv_scldelay(itv);
458 ivtv_setsda(itv, nack);
459 ivtv_scldelay(itv);
460 ivtv_setscl(itv, 1);
461 ivtv_scldelay(itv);
462 ivtv_setscl(itv, 0);
463 ivtv_scldelay(itv);
464 IVTV_DEBUG_HI_I2C("read %x\n",*byte);
465 return 0;
466 }
467
468 /* Issue a start condition on the i2c bus to alert slaves to prepare for
469 an address write */
ivtv_start(struct ivtv * itv)470 static int ivtv_start(struct ivtv *itv)
471 {
472 int sda;
473
474 sda = ivtv_getsda(itv);
475 if (sda != 1) {
476 IVTV_DEBUG_HI_I2C("SDA was low at start\n");
477 ivtv_setsda(itv, 1);
478 if (!ivtv_waitsda(itv, 1)) {
479 IVTV_DEBUG_I2C("SDA stuck low\n");
480 return -EREMOTEIO;
481 }
482 }
483 if (ivtv_getscl(itv) != 1) {
484 ivtv_setscl(itv, 1);
485 if (!ivtv_waitscl(itv, 1)) {
486 IVTV_DEBUG_I2C("SCL stuck low at start\n");
487 return -EREMOTEIO;
488 }
489 }
490 ivtv_setsda(itv, 0);
491 ivtv_scldelay(itv);
492 return 0;
493 }
494
495 /* Issue a stop condition on the i2c bus to release it */
ivtv_stop(struct ivtv * itv)496 static int ivtv_stop(struct ivtv *itv)
497 {
498 int i;
499
500 if (ivtv_getscl(itv) != 0) {
501 IVTV_DEBUG_HI_I2C("SCL not low when stopping\n");
502 ivtv_setscl(itv, 0);
503 if (!ivtv_waitscl(itv, 0)) {
504 IVTV_DEBUG_I2C("SCL could not be set low\n");
505 }
506 }
507 ivtv_setsda(itv, 0);
508 ivtv_scldelay(itv);
509 ivtv_setscl(itv, 1);
510 if (!ivtv_waitscl(itv, 1)) {
511 IVTV_DEBUG_I2C("SCL could not be set high\n");
512 return -EREMOTEIO;
513 }
514 ivtv_scldelay(itv);
515 ivtv_setsda(itv, 1);
516 if (!ivtv_waitsda(itv, 1)) {
517 IVTV_DEBUG_I2C("resetting I2C\n");
518 for (i = 0; i < 16; ++i) {
519 ivtv_setscl(itv, 0);
520 ivtv_scldelay(itv);
521 ivtv_setscl(itv, 1);
522 ivtv_scldelay(itv);
523 ivtv_setsda(itv, 1);
524 }
525 ivtv_waitsda(itv, 1);
526 return -EREMOTEIO;
527 }
528 return 0;
529 }
530
531 /* Write a message to the given i2c slave. do_stop may be 0 to prevent
532 issuing the i2c stop condition (when following with a read) */
ivtv_write(struct ivtv * itv,unsigned char addr,unsigned char * data,u32 len,int do_stop)533 static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop)
534 {
535 int retry, ret = -EREMOTEIO;
536 u32 i;
537
538 for (retry = 0; ret != 0 && retry < 8; ++retry) {
539 ret = ivtv_start(itv);
540
541 if (ret == 0) {
542 ret = ivtv_sendbyte(itv, addr<<1);
543 for (i = 0; ret == 0 && i < len; ++i)
544 ret = ivtv_sendbyte(itv, data[i]);
545 }
546 if (ret != 0 || do_stop) {
547 ivtv_stop(itv);
548 }
549 }
550 if (ret)
551 IVTV_DEBUG_I2C("i2c write to %x failed\n", addr);
552 return ret;
553 }
554
555 /* Read data from the given i2c slave. A stop condition is always issued. */
ivtv_read(struct ivtv * itv,unsigned char addr,unsigned char * data,u32 len)556 static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len)
557 {
558 int retry, ret = -EREMOTEIO;
559 u32 i;
560
561 for (retry = 0; ret != 0 && retry < 8; ++retry) {
562 ret = ivtv_start(itv);
563 if (ret == 0)
564 ret = ivtv_sendbyte(itv, (addr << 1) | 1);
565 for (i = 0; ret == 0 && i < len; ++i) {
566 ret = ivtv_readbyte(itv, &data[i], i == len - 1);
567 }
568 ivtv_stop(itv);
569 }
570 if (ret)
571 IVTV_DEBUG_I2C("i2c read from %x failed\n", addr);
572 return ret;
573 }
574
575 /* Kernel i2c transfer implementation. Takes a number of messages to be read
576 or written. If a read follows a write, this will occur without an
577 intervening stop condition */
ivtv_xfer(struct i2c_adapter * i2c_adap,struct i2c_msg * msgs,int num)578 static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
579 {
580 struct v4l2_device *v4l2_dev = i2c_get_adapdata(i2c_adap);
581 struct ivtv *itv = to_ivtv(v4l2_dev);
582 int retval;
583 int i;
584
585 mutex_lock(&itv->i2c_bus_lock);
586 for (i = retval = 0; retval == 0 && i < num; i++) {
587 if (msgs[i].flags & I2C_M_RD)
588 retval = ivtv_read(itv, msgs[i].addr, msgs[i].buf, msgs[i].len);
589 else {
590 /* if followed by a read, don't stop */
591 int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD);
592
593 retval = ivtv_write(itv, msgs[i].addr, msgs[i].buf, msgs[i].len, stop);
594 }
595 }
596 mutex_unlock(&itv->i2c_bus_lock);
597 return retval ? retval : num;
598 }
599
600 /* Kernel i2c capabilities */
ivtv_functionality(struct i2c_adapter * adap)601 static u32 ivtv_functionality(struct i2c_adapter *adap)
602 {
603 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
604 }
605
606 static const struct i2c_algorithm ivtv_algo = {
607 .master_xfer = ivtv_xfer,
608 .functionality = ivtv_functionality,
609 };
610
611 /* template for our-bit banger */
612 static const struct i2c_adapter ivtv_i2c_adap_hw_template = {
613 .name = "ivtv i2c driver",
614 .algo = &ivtv_algo,
615 .algo_data = NULL, /* filled from template */
616 .owner = THIS_MODULE,
617 };
618
ivtv_setscl_old(void * data,int state)619 static void ivtv_setscl_old(void *data, int state)
620 {
621 struct ivtv *itv = (struct ivtv *)data;
622
623 if (state)
624 itv->i2c_state |= 0x01;
625 else
626 itv->i2c_state &= ~0x01;
627
628 /* write them out */
629 /* write bits are inverted */
630 write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET);
631 }
632
ivtv_setsda_old(void * data,int state)633 static void ivtv_setsda_old(void *data, int state)
634 {
635 struct ivtv *itv = (struct ivtv *)data;
636
637 if (state)
638 itv->i2c_state |= 0x01;
639 else
640 itv->i2c_state &= ~0x01;
641
642 /* write them out */
643 /* write bits are inverted */
644 write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSDA_OFFSET);
645 }
646
ivtv_getscl_old(void * data)647 static int ivtv_getscl_old(void *data)
648 {
649 struct ivtv *itv = (struct ivtv *)data;
650
651 return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
652 }
653
ivtv_getsda_old(void * data)654 static int ivtv_getsda_old(void *data)
655 {
656 struct ivtv *itv = (struct ivtv *)data;
657
658 return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
659 }
660
661 /* template for i2c-bit-algo */
662 static const struct i2c_adapter ivtv_i2c_adap_template = {
663 .name = "ivtv i2c driver",
664 .algo = NULL, /* set by i2c-algo-bit */
665 .algo_data = NULL, /* filled from template */
666 .owner = THIS_MODULE,
667 };
668
669 #define IVTV_ALGO_BIT_TIMEOUT (2) /* seconds */
670
671 static const struct i2c_algo_bit_data ivtv_i2c_algo_template = {
672 .setsda = ivtv_setsda_old,
673 .setscl = ivtv_setscl_old,
674 .getsda = ivtv_getsda_old,
675 .getscl = ivtv_getscl_old,
676 .udelay = IVTV_DEFAULT_I2C_CLOCK_PERIOD / 2, /* microseconds */
677 .timeout = IVTV_ALGO_BIT_TIMEOUT * HZ, /* jiffies */
678 };
679
680 static const struct i2c_client ivtv_i2c_client_template = {
681 .name = "ivtv internal",
682 };
683
684 /* init + register i2c adapter */
init_ivtv_i2c(struct ivtv * itv)685 int init_ivtv_i2c(struct ivtv *itv)
686 {
687 int retval;
688
689 IVTV_DEBUG_I2C("i2c init\n");
690
691 /* Sanity checks for the I2C hardware arrays. They must be the
692 * same size.
693 */
694 if (ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_addrs)) {
695 IVTV_ERR("Mismatched I2C hardware arrays\n");
696 return -ENODEV;
697 }
698 if (itv->options.newi2c > 0) {
699 itv->i2c_adap = ivtv_i2c_adap_hw_template;
700 } else {
701 itv->i2c_adap = ivtv_i2c_adap_template;
702 itv->i2c_algo = ivtv_i2c_algo_template;
703 }
704 itv->i2c_algo.udelay = itv->options.i2c_clock_period / 2;
705 itv->i2c_algo.data = itv;
706 itv->i2c_adap.algo_data = &itv->i2c_algo;
707
708 sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d",
709 itv->instance);
710 i2c_set_adapdata(&itv->i2c_adap, &itv->v4l2_dev);
711
712 itv->i2c_client = ivtv_i2c_client_template;
713 itv->i2c_client.adapter = &itv->i2c_adap;
714 itv->i2c_adap.dev.parent = &itv->pdev->dev;
715
716 IVTV_DEBUG_I2C("setting scl and sda to 1\n");
717 ivtv_setscl(itv, 1);
718 ivtv_setsda(itv, 1);
719
720 if (itv->options.newi2c > 0)
721 retval = i2c_add_adapter(&itv->i2c_adap);
722 else
723 retval = i2c_bit_add_bus(&itv->i2c_adap);
724
725 return retval;
726 }
727
exit_ivtv_i2c(struct ivtv * itv)728 void exit_ivtv_i2c(struct ivtv *itv)
729 {
730 IVTV_DEBUG_I2C("i2c exit\n");
731
732 i2c_del_adapter(&itv->i2c_adap);
733 }
734
