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