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