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