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 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 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 */ 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 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 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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) */ 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 */ 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 */ 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) */ 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. */ 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 */ 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 */ 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 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 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 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 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 */ 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 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