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[IVTV_HW_MAX_BITS] = {
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[IVTV_HW_MAX_BITS] = {
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 i2c_adapter *adap = &itv->i2c_adap;
244 	struct v4l2_subdev *sd;
245 	const char *type;
246 	u32 hw;
247 
248 	if (idx >= IVTV_HW_MAX_BITS)
249 		return -ENODEV;
250 
251 	type = hw_devicenames[idx];
252 	hw = 1 << idx;
253 
254 	if (hw == IVTV_HW_TUNER) {
255 		/* special tuner handling */
256 		sd = v4l2_i2c_new_subdev(&itv->v4l2_dev, adap, type, 0,
257 				itv->card_i2c->radio);
258 		if (sd)
259 			sd->grp_id = 1 << idx;
260 		sd = v4l2_i2c_new_subdev(&itv->v4l2_dev, adap, type, 0,
261 				itv->card_i2c->demod);
262 		if (sd)
263 			sd->grp_id = 1 << idx;
264 		sd = v4l2_i2c_new_subdev(&itv->v4l2_dev, adap, type, 0,
265 				itv->card_i2c->tv);
266 		if (sd)
267 			sd->grp_id = 1 << idx;
268 		return sd ? 0 : -1;
269 	}
270 
271 	if (hw & IVTV_HW_IR_ANY)
272 		return ivtv_i2c_new_ir(itv, hw, type, hw_addrs[idx]);
273 
274 	/* Is it not an I2C device or one we do not wish to register? */
275 	if (!hw_addrs[idx])
276 		return -1;
277 
278 	/* It's an I2C device other than an analog tuner or IR chip */
279 	if (hw == IVTV_HW_UPD64031A || hw == IVTV_HW_UPD6408X) {
280 		sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
281 				adap, type, 0, I2C_ADDRS(hw_addrs[idx]));
282 	} else if (hw == IVTV_HW_CX25840) {
283 		struct cx25840_platform_data pdata;
284 		struct i2c_board_info cx25840_info = {
285 			.type = "cx25840",
286 			.addr = hw_addrs[idx],
287 			.platform_data = &pdata,
288 		};
289 
290 		memset(&pdata, 0, sizeof(pdata));
291 		pdata.pvr150_workaround = itv->pvr150_workaround;
292 		sd = v4l2_i2c_new_subdev_board(&itv->v4l2_dev, adap,
293 				&cx25840_info, NULL);
294 	} else {
295 		sd = v4l2_i2c_new_subdev(&itv->v4l2_dev,
296 				adap, type, hw_addrs[idx], NULL);
297 	}
298 	if (sd)
299 		sd->grp_id = 1 << idx;
300 	return sd ? 0 : -1;
301 }
302 
ivtv_find_hw(struct ivtv * itv,u32 hw)303 struct v4l2_subdev *ivtv_find_hw(struct ivtv *itv, u32 hw)
304 {
305 	struct v4l2_subdev *result = NULL;
306 	struct v4l2_subdev *sd;
307 
308 	spin_lock(&itv->v4l2_dev.lock);
309 	v4l2_device_for_each_subdev(sd, &itv->v4l2_dev) {
310 		if (sd->grp_id == hw) {
311 			result = sd;
312 			break;
313 		}
314 	}
315 	spin_unlock(&itv->v4l2_dev.lock);
316 	return result;
317 }
318 
319 /* Set the serial clock line to the desired state */
ivtv_setscl(struct ivtv * itv,int state)320 static void ivtv_setscl(struct ivtv *itv, int state)
321 {
322 	/* write them out */
323 	/* write bits are inverted */
324 	write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET);
325 }
326 
327 /* Set the serial data line to the desired state */
ivtv_setsda(struct ivtv * itv,int state)328 static void ivtv_setsda(struct ivtv *itv, int state)
329 {
330 	/* write them out */
331 	/* write bits are inverted */
332 	write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET);
333 }
334 
335 /* Read the serial clock line */
ivtv_getscl(struct ivtv * itv)336 static int ivtv_getscl(struct ivtv *itv)
337 {
338 	return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
339 }
340 
341 /* Read the serial data line */
ivtv_getsda(struct ivtv * itv)342 static int ivtv_getsda(struct ivtv *itv)
343 {
344 	return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
345 }
346 
347 /* Implement a short delay by polling the serial clock line */
ivtv_scldelay(struct ivtv * itv)348 static void ivtv_scldelay(struct ivtv *itv)
349 {
350 	int i;
351 
352 	for (i = 0; i < 5; ++i)
353 		ivtv_getscl(itv);
354 }
355 
356 /* Wait for the serial clock line to become set to a specific value */
ivtv_waitscl(struct ivtv * itv,int val)357 static int ivtv_waitscl(struct ivtv *itv, int val)
358 {
359 	int i;
360 
361 	ivtv_scldelay(itv);
362 	for (i = 0; i < 1000; ++i) {
363 		if (ivtv_getscl(itv) == val)
364 			return 1;
365 	}
366 	return 0;
367 }
368 
369 /* Wait for the serial data line to become set to a specific value */
ivtv_waitsda(struct ivtv * itv,int val)370 static int ivtv_waitsda(struct ivtv *itv, int val)
371 {
372 	int i;
373 
374 	ivtv_scldelay(itv);
375 	for (i = 0; i < 1000; ++i) {
376 		if (ivtv_getsda(itv) == val)
377 			return 1;
378 	}
379 	return 0;
380 }
381 
382 /* Wait for the slave to issue an ACK */
ivtv_ack(struct ivtv * itv)383 static int ivtv_ack(struct ivtv *itv)
384 {
385 	int ret = 0;
386 
387 	if (ivtv_getscl(itv) == 1) {
388 		IVTV_DEBUG_HI_I2C("SCL was high starting an ack\n");
389 		ivtv_setscl(itv, 0);
390 		if (!ivtv_waitscl(itv, 0)) {
391 			IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n");
392 			return -EREMOTEIO;
393 		}
394 	}
395 	ivtv_setsda(itv, 1);
396 	ivtv_scldelay(itv);
397 	ivtv_setscl(itv, 1);
398 	if (!ivtv_waitsda(itv, 0)) {
399 		IVTV_DEBUG_I2C("Slave did not ack\n");
400 		ret = -EREMOTEIO;
401 	}
402 	ivtv_setscl(itv, 0);
403 	if (!ivtv_waitscl(itv, 0)) {
404 		IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n");
405 		ret = -EREMOTEIO;
406 	}
407 	return ret;
408 }
409 
410 /* Write a single byte to the i2c bus and wait for the slave to ACK */
ivtv_sendbyte(struct ivtv * itv,unsigned char byte)411 static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte)
412 {
413 	int i, bit;
414 
415 	IVTV_DEBUG_HI_I2C("write %x\n",byte);
416 	for (i = 0; i < 8; ++i, byte<<=1) {
417 		ivtv_setscl(itv, 0);
418 		if (!ivtv_waitscl(itv, 0)) {
419 			IVTV_DEBUG_I2C("Error setting SCL low\n");
420 			return -EREMOTEIO;
421 		}
422 		bit = (byte>>7)&1;
423 		ivtv_setsda(itv, bit);
424 		if (!ivtv_waitsda(itv, bit)) {
425 			IVTV_DEBUG_I2C("Error setting SDA\n");
426 			return -EREMOTEIO;
427 		}
428 		ivtv_setscl(itv, 1);
429 		if (!ivtv_waitscl(itv, 1)) {
430 			IVTV_DEBUG_I2C("Slave not ready for bit\n");
431 			return -EREMOTEIO;
432 		}
433 	}
434 	ivtv_setscl(itv, 0);
435 	if (!ivtv_waitscl(itv, 0)) {
436 		IVTV_DEBUG_I2C("Error setting SCL low\n");
437 		return -EREMOTEIO;
438 	}
439 	return ivtv_ack(itv);
440 }
441 
442 /* Read a byte from the i2c bus and send a NACK if applicable (i.e. for the
443    final byte) */
ivtv_readbyte(struct ivtv * itv,unsigned char * byte,int nack)444 static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack)
445 {
446 	int i;
447 
448 	*byte = 0;
449 
450 	ivtv_setsda(itv, 1);
451 	ivtv_scldelay(itv);
452 	for (i = 0; i < 8; ++i) {
453 		ivtv_setscl(itv, 0);
454 		ivtv_scldelay(itv);
455 		ivtv_setscl(itv, 1);
456 		if (!ivtv_waitscl(itv, 1)) {
457 			IVTV_DEBUG_I2C("Error setting SCL high\n");
458 			return -EREMOTEIO;
459 		}
460 		*byte = ((*byte)<<1)|ivtv_getsda(itv);
461 	}
462 	ivtv_setscl(itv, 0);
463 	ivtv_scldelay(itv);
464 	ivtv_setsda(itv, nack);
465 	ivtv_scldelay(itv);
466 	ivtv_setscl(itv, 1);
467 	ivtv_scldelay(itv);
468 	ivtv_setscl(itv, 0);
469 	ivtv_scldelay(itv);
470 	IVTV_DEBUG_HI_I2C("read %x\n",*byte);
471 	return 0;
472 }
473 
474 /* Issue a start condition on the i2c bus to alert slaves to prepare for
475    an address write */
ivtv_start(struct ivtv * itv)476 static int ivtv_start(struct ivtv *itv)
477 {
478 	int sda;
479 
480 	sda = ivtv_getsda(itv);
481 	if (sda != 1) {
482 		IVTV_DEBUG_HI_I2C("SDA was low at start\n");
483 		ivtv_setsda(itv, 1);
484 		if (!ivtv_waitsda(itv, 1)) {
485 			IVTV_DEBUG_I2C("SDA stuck low\n");
486 			return -EREMOTEIO;
487 		}
488 	}
489 	if (ivtv_getscl(itv) != 1) {
490 		ivtv_setscl(itv, 1);
491 		if (!ivtv_waitscl(itv, 1)) {
492 			IVTV_DEBUG_I2C("SCL stuck low at start\n");
493 			return -EREMOTEIO;
494 		}
495 	}
496 	ivtv_setsda(itv, 0);
497 	ivtv_scldelay(itv);
498 	return 0;
499 }
500 
501 /* Issue a stop condition on the i2c bus to release it */
ivtv_stop(struct ivtv * itv)502 static int ivtv_stop(struct ivtv *itv)
503 {
504 	int i;
505 
506 	if (ivtv_getscl(itv) != 0) {
507 		IVTV_DEBUG_HI_I2C("SCL not low when stopping\n");
508 		ivtv_setscl(itv, 0);
509 		if (!ivtv_waitscl(itv, 0)) {
510 			IVTV_DEBUG_I2C("SCL could not be set low\n");
511 		}
512 	}
513 	ivtv_setsda(itv, 0);
514 	ivtv_scldelay(itv);
515 	ivtv_setscl(itv, 1);
516 	if (!ivtv_waitscl(itv, 1)) {
517 		IVTV_DEBUG_I2C("SCL could not be set high\n");
518 		return -EREMOTEIO;
519 	}
520 	ivtv_scldelay(itv);
521 	ivtv_setsda(itv, 1);
522 	if (!ivtv_waitsda(itv, 1)) {
523 		IVTV_DEBUG_I2C("resetting I2C\n");
524 		for (i = 0; i < 16; ++i) {
525 			ivtv_setscl(itv, 0);
526 			ivtv_scldelay(itv);
527 			ivtv_setscl(itv, 1);
528 			ivtv_scldelay(itv);
529 			ivtv_setsda(itv, 1);
530 		}
531 		ivtv_waitsda(itv, 1);
532 		return -EREMOTEIO;
533 	}
534 	return 0;
535 }
536 
537 /* Write a message to the given i2c slave.  do_stop may be 0 to prevent
538    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)539 static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop)
540 {
541 	int retry, ret = -EREMOTEIO;
542 	u32 i;
543 
544 	for (retry = 0; ret != 0 && retry < 8; ++retry) {
545 		ret = ivtv_start(itv);
546 
547 		if (ret == 0) {
548 			ret = ivtv_sendbyte(itv, addr<<1);
549 			for (i = 0; ret == 0 && i < len; ++i)
550 				ret = ivtv_sendbyte(itv, data[i]);
551 		}
552 		if (ret != 0 || do_stop) {
553 			ivtv_stop(itv);
554 		}
555 	}
556 	if (ret)
557 		IVTV_DEBUG_I2C("i2c write to %x failed\n", addr);
558 	return ret;
559 }
560 
561 /* 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)562 static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len)
563 {
564 	int retry, ret = -EREMOTEIO;
565 	u32 i;
566 
567 	for (retry = 0; ret != 0 && retry < 8; ++retry) {
568 		ret = ivtv_start(itv);
569 		if (ret == 0)
570 			ret = ivtv_sendbyte(itv, (addr << 1) | 1);
571 		for (i = 0; ret == 0 && i < len; ++i) {
572 			ret = ivtv_readbyte(itv, &data[i], i == len - 1);
573 		}
574 		ivtv_stop(itv);
575 	}
576 	if (ret)
577 		IVTV_DEBUG_I2C("i2c read from %x failed\n", addr);
578 	return ret;
579 }
580 
581 /* Kernel i2c transfer implementation.  Takes a number of messages to be read
582    or written.  If a read follows a write, this will occur without an
583    intervening stop condition */
ivtv_xfer(struct i2c_adapter * i2c_adap,struct i2c_msg * msgs,int num)584 static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
585 {
586 	struct v4l2_device *v4l2_dev = i2c_get_adapdata(i2c_adap);
587 	struct ivtv *itv = to_ivtv(v4l2_dev);
588 	int retval;
589 	int i;
590 
591 	mutex_lock(&itv->i2c_bus_lock);
592 	for (i = retval = 0; retval == 0 && i < num; i++) {
593 		if (msgs[i].flags & I2C_M_RD)
594 			retval = ivtv_read(itv, msgs[i].addr, msgs[i].buf, msgs[i].len);
595 		else {
596 			/* if followed by a read, don't stop */
597 			int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD);
598 
599 			retval = ivtv_write(itv, msgs[i].addr, msgs[i].buf, msgs[i].len, stop);
600 		}
601 	}
602 	mutex_unlock(&itv->i2c_bus_lock);
603 	return retval ? retval : num;
604 }
605 
606 /* Kernel i2c capabilities */
ivtv_functionality(struct i2c_adapter * adap)607 static u32 ivtv_functionality(struct i2c_adapter *adap)
608 {
609 	return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
610 }
611 
612 static const struct i2c_algorithm ivtv_algo = {
613 	.master_xfer   = ivtv_xfer,
614 	.functionality = ivtv_functionality,
615 };
616 
617 /* template for our-bit banger */
618 static const struct i2c_adapter ivtv_i2c_adap_hw_template = {
619 	.name = "ivtv i2c driver",
620 	.algo = &ivtv_algo,
621 	.algo_data = NULL,			/* filled from template */
622 	.owner = THIS_MODULE,
623 };
624 
ivtv_setscl_old(void * data,int state)625 static void ivtv_setscl_old(void *data, int state)
626 {
627 	struct ivtv *itv = (struct ivtv *)data;
628 
629 	if (state)
630 		itv->i2c_state |= 0x01;
631 	else
632 		itv->i2c_state &= ~0x01;
633 
634 	/* write them out */
635 	/* write bits are inverted */
636 	write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET);
637 }
638 
ivtv_setsda_old(void * data,int state)639 static void ivtv_setsda_old(void *data, int state)
640 {
641 	struct ivtv *itv = (struct ivtv *)data;
642 
643 	if (state)
644 		itv->i2c_state |= 0x01;
645 	else
646 		itv->i2c_state &= ~0x01;
647 
648 	/* write them out */
649 	/* write bits are inverted */
650 	write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSDA_OFFSET);
651 }
652 
ivtv_getscl_old(void * data)653 static int ivtv_getscl_old(void *data)
654 {
655 	struct ivtv *itv = (struct ivtv *)data;
656 
657 	return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1;
658 }
659 
ivtv_getsda_old(void * data)660 static int ivtv_getsda_old(void *data)
661 {
662 	struct ivtv *itv = (struct ivtv *)data;
663 
664 	return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1;
665 }
666 
667 /* template for i2c-bit-algo */
668 static const struct i2c_adapter ivtv_i2c_adap_template = {
669 	.name = "ivtv i2c driver",
670 	.algo = NULL,                   /* set by i2c-algo-bit */
671 	.algo_data = NULL,              /* filled from template */
672 	.owner = THIS_MODULE,
673 };
674 
675 #define IVTV_ALGO_BIT_TIMEOUT	(2)	/* seconds */
676 
677 static const struct i2c_algo_bit_data ivtv_i2c_algo_template = {
678 	.setsda		= ivtv_setsda_old,
679 	.setscl		= ivtv_setscl_old,
680 	.getsda		= ivtv_getsda_old,
681 	.getscl		= ivtv_getscl_old,
682 	.udelay		= IVTV_DEFAULT_I2C_CLOCK_PERIOD / 2,  /* microseconds */
683 	.timeout	= IVTV_ALGO_BIT_TIMEOUT * HZ,         /* jiffies */
684 };
685 
686 static const struct i2c_client ivtv_i2c_client_template = {
687 	.name = "ivtv internal",
688 };
689 
690 /* init + register i2c adapter */
init_ivtv_i2c(struct ivtv * itv)691 int init_ivtv_i2c(struct ivtv *itv)
692 {
693 	int retval;
694 
695 	IVTV_DEBUG_I2C("i2c init\n");
696 
697 	/* Sanity checks for the I2C hardware arrays. They must be the
698 	 * same size.
699 	 */
700 	if (ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_addrs)) {
701 		IVTV_ERR("Mismatched I2C hardware arrays\n");
702 		return -ENODEV;
703 	}
704 	if (itv->options.newi2c > 0) {
705 		itv->i2c_adap = ivtv_i2c_adap_hw_template;
706 	} else {
707 		itv->i2c_adap = ivtv_i2c_adap_template;
708 		itv->i2c_algo = ivtv_i2c_algo_template;
709 	}
710 	itv->i2c_algo.udelay = itv->options.i2c_clock_period / 2;
711 	itv->i2c_algo.data = itv;
712 	itv->i2c_adap.algo_data = &itv->i2c_algo;
713 
714 	sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d",
715 		itv->instance);
716 	i2c_set_adapdata(&itv->i2c_adap, &itv->v4l2_dev);
717 
718 	itv->i2c_client = ivtv_i2c_client_template;
719 	itv->i2c_client.adapter = &itv->i2c_adap;
720 	itv->i2c_adap.dev.parent = &itv->pdev->dev;
721 
722 	IVTV_DEBUG_I2C("setting scl and sda to 1\n");
723 	ivtv_setscl(itv, 1);
724 	ivtv_setsda(itv, 1);
725 
726 	if (itv->options.newi2c > 0)
727 		retval = i2c_add_adapter(&itv->i2c_adap);
728 	else
729 		retval = i2c_bit_add_bus(&itv->i2c_adap);
730 
731 	return retval;
732 }
733 
exit_ivtv_i2c(struct ivtv * itv)734 void exit_ivtv_i2c(struct ivtv *itv)
735 {
736 	IVTV_DEBUG_I2C("i2c exit\n");
737 
738 	i2c_del_adapter(&itv->i2c_adap);
739 }
740