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 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 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 i2c_new_probed_device(adap, &info, addr_list, NULL) == NULL ? 212 -1 : 0; 213 } 214 215 /* Instantiate the IR receiver device using probing -- undesirable */ 216 struct i2c_client *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 return i2c_new_probed_device(&itv->i2c_adap, &info, addr_list, NULL); 239 } 240 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 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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) */ 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 */ 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 */ 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) */ 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. */ 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 */ 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 */ 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 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 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 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 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 */ 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 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