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 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 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 */ 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 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 pdata.pvr150_workaround = itv->pvr150_workaround; 297 sd = v4l2_i2c_new_subdev_board(&itv->v4l2_dev, adap, 298 &cx25840_info, NULL); 299 } else { 300 sd = v4l2_i2c_new_subdev(&itv->v4l2_dev, 301 adap, type, hw_addrs[idx], NULL); 302 } 303 if (sd) 304 sd->grp_id = 1 << idx; 305 return sd ? 0 : -1; 306 } 307 308 struct v4l2_subdev *ivtv_find_hw(struct ivtv *itv, u32 hw) 309 { 310 struct v4l2_subdev *result = NULL; 311 struct v4l2_subdev *sd; 312 313 spin_lock(&itv->v4l2_dev.lock); 314 v4l2_device_for_each_subdev(sd, &itv->v4l2_dev) { 315 if (sd->grp_id == hw) { 316 result = sd; 317 break; 318 } 319 } 320 spin_unlock(&itv->v4l2_dev.lock); 321 return result; 322 } 323 324 /* Set the serial clock line to the desired state */ 325 static void ivtv_setscl(struct ivtv *itv, int state) 326 { 327 /* write them out */ 328 /* write bits are inverted */ 329 write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET); 330 } 331 332 /* Set the serial data line to the desired state */ 333 static void ivtv_setsda(struct ivtv *itv, int state) 334 { 335 /* write them out */ 336 /* write bits are inverted */ 337 write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET); 338 } 339 340 /* Read the serial clock line */ 341 static int ivtv_getscl(struct ivtv *itv) 342 { 343 return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1; 344 } 345 346 /* Read the serial data line */ 347 static int ivtv_getsda(struct ivtv *itv) 348 { 349 return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1; 350 } 351 352 /* Implement a short delay by polling the serial clock line */ 353 static void ivtv_scldelay(struct ivtv *itv) 354 { 355 int i; 356 357 for (i = 0; i < 5; ++i) 358 ivtv_getscl(itv); 359 } 360 361 /* Wait for the serial clock line to become set to a specific value */ 362 static int ivtv_waitscl(struct ivtv *itv, int val) 363 { 364 int i; 365 366 ivtv_scldelay(itv); 367 for (i = 0; i < 1000; ++i) { 368 if (ivtv_getscl(itv) == val) 369 return 1; 370 } 371 return 0; 372 } 373 374 /* Wait for the serial data line to become set to a specific value */ 375 static int ivtv_waitsda(struct ivtv *itv, int val) 376 { 377 int i; 378 379 ivtv_scldelay(itv); 380 for (i = 0; i < 1000; ++i) { 381 if (ivtv_getsda(itv) == val) 382 return 1; 383 } 384 return 0; 385 } 386 387 /* Wait for the slave to issue an ACK */ 388 static int ivtv_ack(struct ivtv *itv) 389 { 390 int ret = 0; 391 392 if (ivtv_getscl(itv) == 1) { 393 IVTV_DEBUG_HI_I2C("SCL was high starting an ack\n"); 394 ivtv_setscl(itv, 0); 395 if (!ivtv_waitscl(itv, 0)) { 396 IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n"); 397 return -EREMOTEIO; 398 } 399 } 400 ivtv_setsda(itv, 1); 401 ivtv_scldelay(itv); 402 ivtv_setscl(itv, 1); 403 if (!ivtv_waitsda(itv, 0)) { 404 IVTV_DEBUG_I2C("Slave did not ack\n"); 405 ret = -EREMOTEIO; 406 } 407 ivtv_setscl(itv, 0); 408 if (!ivtv_waitscl(itv, 0)) { 409 IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n"); 410 ret = -EREMOTEIO; 411 } 412 return ret; 413 } 414 415 /* Write a single byte to the i2c bus and wait for the slave to ACK */ 416 static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte) 417 { 418 int i, bit; 419 420 IVTV_DEBUG_HI_I2C("write %x\n",byte); 421 for (i = 0; i < 8; ++i, byte<<=1) { 422 ivtv_setscl(itv, 0); 423 if (!ivtv_waitscl(itv, 0)) { 424 IVTV_DEBUG_I2C("Error setting SCL low\n"); 425 return -EREMOTEIO; 426 } 427 bit = (byte>>7)&1; 428 ivtv_setsda(itv, bit); 429 if (!ivtv_waitsda(itv, bit)) { 430 IVTV_DEBUG_I2C("Error setting SDA\n"); 431 return -EREMOTEIO; 432 } 433 ivtv_setscl(itv, 1); 434 if (!ivtv_waitscl(itv, 1)) { 435 IVTV_DEBUG_I2C("Slave not ready for bit\n"); 436 return -EREMOTEIO; 437 } 438 } 439 ivtv_setscl(itv, 0); 440 if (!ivtv_waitscl(itv, 0)) { 441 IVTV_DEBUG_I2C("Error setting SCL low\n"); 442 return -EREMOTEIO; 443 } 444 return ivtv_ack(itv); 445 } 446 447 /* Read a byte from the i2c bus and send a NACK if applicable (i.e. for the 448 final byte) */ 449 static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack) 450 { 451 int i; 452 453 *byte = 0; 454 455 ivtv_setsda(itv, 1); 456 ivtv_scldelay(itv); 457 for (i = 0; i < 8; ++i) { 458 ivtv_setscl(itv, 0); 459 ivtv_scldelay(itv); 460 ivtv_setscl(itv, 1); 461 if (!ivtv_waitscl(itv, 1)) { 462 IVTV_DEBUG_I2C("Error setting SCL high\n"); 463 return -EREMOTEIO; 464 } 465 *byte = ((*byte)<<1)|ivtv_getsda(itv); 466 } 467 ivtv_setscl(itv, 0); 468 ivtv_scldelay(itv); 469 ivtv_setsda(itv, nack); 470 ivtv_scldelay(itv); 471 ivtv_setscl(itv, 1); 472 ivtv_scldelay(itv); 473 ivtv_setscl(itv, 0); 474 ivtv_scldelay(itv); 475 IVTV_DEBUG_HI_I2C("read %x\n",*byte); 476 return 0; 477 } 478 479 /* Issue a start condition on the i2c bus to alert slaves to prepare for 480 an address write */ 481 static int ivtv_start(struct ivtv *itv) 482 { 483 int sda; 484 485 sda = ivtv_getsda(itv); 486 if (sda != 1) { 487 IVTV_DEBUG_HI_I2C("SDA was low at start\n"); 488 ivtv_setsda(itv, 1); 489 if (!ivtv_waitsda(itv, 1)) { 490 IVTV_DEBUG_I2C("SDA stuck low\n"); 491 return -EREMOTEIO; 492 } 493 } 494 if (ivtv_getscl(itv) != 1) { 495 ivtv_setscl(itv, 1); 496 if (!ivtv_waitscl(itv, 1)) { 497 IVTV_DEBUG_I2C("SCL stuck low at start\n"); 498 return -EREMOTEIO; 499 } 500 } 501 ivtv_setsda(itv, 0); 502 ivtv_scldelay(itv); 503 return 0; 504 } 505 506 /* Issue a stop condition on the i2c bus to release it */ 507 static int ivtv_stop(struct ivtv *itv) 508 { 509 int i; 510 511 if (ivtv_getscl(itv) != 0) { 512 IVTV_DEBUG_HI_I2C("SCL not low when stopping\n"); 513 ivtv_setscl(itv, 0); 514 if (!ivtv_waitscl(itv, 0)) { 515 IVTV_DEBUG_I2C("SCL could not be set low\n"); 516 } 517 } 518 ivtv_setsda(itv, 0); 519 ivtv_scldelay(itv); 520 ivtv_setscl(itv, 1); 521 if (!ivtv_waitscl(itv, 1)) { 522 IVTV_DEBUG_I2C("SCL could not be set high\n"); 523 return -EREMOTEIO; 524 } 525 ivtv_scldelay(itv); 526 ivtv_setsda(itv, 1); 527 if (!ivtv_waitsda(itv, 1)) { 528 IVTV_DEBUG_I2C("resetting I2C\n"); 529 for (i = 0; i < 16; ++i) { 530 ivtv_setscl(itv, 0); 531 ivtv_scldelay(itv); 532 ivtv_setscl(itv, 1); 533 ivtv_scldelay(itv); 534 ivtv_setsda(itv, 1); 535 } 536 ivtv_waitsda(itv, 1); 537 return -EREMOTEIO; 538 } 539 return 0; 540 } 541 542 /* Write a message to the given i2c slave. do_stop may be 0 to prevent 543 issuing the i2c stop condition (when following with a read) */ 544 static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop) 545 { 546 int retry, ret = -EREMOTEIO; 547 u32 i; 548 549 for (retry = 0; ret != 0 && retry < 8; ++retry) { 550 ret = ivtv_start(itv); 551 552 if (ret == 0) { 553 ret = ivtv_sendbyte(itv, addr<<1); 554 for (i = 0; ret == 0 && i < len; ++i) 555 ret = ivtv_sendbyte(itv, data[i]); 556 } 557 if (ret != 0 || do_stop) { 558 ivtv_stop(itv); 559 } 560 } 561 if (ret) 562 IVTV_DEBUG_I2C("i2c write to %x failed\n", addr); 563 return ret; 564 } 565 566 /* Read data from the given i2c slave. A stop condition is always issued. */ 567 static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len) 568 { 569 int retry, ret = -EREMOTEIO; 570 u32 i; 571 572 for (retry = 0; ret != 0 && retry < 8; ++retry) { 573 ret = ivtv_start(itv); 574 if (ret == 0) 575 ret = ivtv_sendbyte(itv, (addr << 1) | 1); 576 for (i = 0; ret == 0 && i < len; ++i) { 577 ret = ivtv_readbyte(itv, &data[i], i == len - 1); 578 } 579 ivtv_stop(itv); 580 } 581 if (ret) 582 IVTV_DEBUG_I2C("i2c read from %x failed\n", addr); 583 return ret; 584 } 585 586 /* Kernel i2c transfer implementation. Takes a number of messages to be read 587 or written. If a read follows a write, this will occur without an 588 intervening stop condition */ 589 static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num) 590 { 591 struct v4l2_device *v4l2_dev = i2c_get_adapdata(i2c_adap); 592 struct ivtv *itv = to_ivtv(v4l2_dev); 593 int retval; 594 int i; 595 596 mutex_lock(&itv->i2c_bus_lock); 597 for (i = retval = 0; retval == 0 && i < num; i++) { 598 if (msgs[i].flags & I2C_M_RD) 599 retval = ivtv_read(itv, msgs[i].addr, msgs[i].buf, msgs[i].len); 600 else { 601 /* if followed by a read, don't stop */ 602 int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD); 603 604 retval = ivtv_write(itv, msgs[i].addr, msgs[i].buf, msgs[i].len, stop); 605 } 606 } 607 mutex_unlock(&itv->i2c_bus_lock); 608 return retval ? retval : num; 609 } 610 611 /* Kernel i2c capabilities */ 612 static u32 ivtv_functionality(struct i2c_adapter *adap) 613 { 614 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; 615 } 616 617 static const struct i2c_algorithm ivtv_algo = { 618 .master_xfer = ivtv_xfer, 619 .functionality = ivtv_functionality, 620 }; 621 622 /* template for our-bit banger */ 623 static const struct i2c_adapter ivtv_i2c_adap_hw_template = { 624 .name = "ivtv i2c driver", 625 .algo = &ivtv_algo, 626 .algo_data = NULL, /* filled from template */ 627 .owner = THIS_MODULE, 628 }; 629 630 static void ivtv_setscl_old(void *data, int state) 631 { 632 struct ivtv *itv = (struct ivtv *)data; 633 634 if (state) 635 itv->i2c_state |= 0x01; 636 else 637 itv->i2c_state &= ~0x01; 638 639 /* write them out */ 640 /* write bits are inverted */ 641 write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET); 642 } 643 644 static void ivtv_setsda_old(void *data, int state) 645 { 646 struct ivtv *itv = (struct ivtv *)data; 647 648 if (state) 649 itv->i2c_state |= 0x01; 650 else 651 itv->i2c_state &= ~0x01; 652 653 /* write them out */ 654 /* write bits are inverted */ 655 write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSDA_OFFSET); 656 } 657 658 static int ivtv_getscl_old(void *data) 659 { 660 struct ivtv *itv = (struct ivtv *)data; 661 662 return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1; 663 } 664 665 static int ivtv_getsda_old(void *data) 666 { 667 struct ivtv *itv = (struct ivtv *)data; 668 669 return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1; 670 } 671 672 /* template for i2c-bit-algo */ 673 static const struct i2c_adapter ivtv_i2c_adap_template = { 674 .name = "ivtv i2c driver", 675 .algo = NULL, /* set by i2c-algo-bit */ 676 .algo_data = NULL, /* filled from template */ 677 .owner = THIS_MODULE, 678 }; 679 680 #define IVTV_ALGO_BIT_TIMEOUT (2) /* seconds */ 681 682 static const struct i2c_algo_bit_data ivtv_i2c_algo_template = { 683 .setsda = ivtv_setsda_old, 684 .setscl = ivtv_setscl_old, 685 .getsda = ivtv_getsda_old, 686 .getscl = ivtv_getscl_old, 687 .udelay = IVTV_DEFAULT_I2C_CLOCK_PERIOD / 2, /* microseconds */ 688 .timeout = IVTV_ALGO_BIT_TIMEOUT * HZ, /* jiffies */ 689 }; 690 691 static const struct i2c_client ivtv_i2c_client_template = { 692 .name = "ivtv internal", 693 }; 694 695 /* init + register i2c adapter */ 696 int init_ivtv_i2c(struct ivtv *itv) 697 { 698 int retval; 699 700 IVTV_DEBUG_I2C("i2c init\n"); 701 702 /* Sanity checks for the I2C hardware arrays. They must be the 703 * same size. 704 */ 705 if (ARRAY_SIZE(hw_devicenames) != ARRAY_SIZE(hw_addrs)) { 706 IVTV_ERR("Mismatched I2C hardware arrays\n"); 707 return -ENODEV; 708 } 709 if (itv->options.newi2c > 0) { 710 itv->i2c_adap = ivtv_i2c_adap_hw_template; 711 } else { 712 itv->i2c_adap = ivtv_i2c_adap_template; 713 itv->i2c_algo = ivtv_i2c_algo_template; 714 } 715 itv->i2c_algo.udelay = itv->options.i2c_clock_period / 2; 716 itv->i2c_algo.data = itv; 717 itv->i2c_adap.algo_data = &itv->i2c_algo; 718 719 sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d", 720 itv->instance); 721 i2c_set_adapdata(&itv->i2c_adap, &itv->v4l2_dev); 722 723 itv->i2c_client = ivtv_i2c_client_template; 724 itv->i2c_client.adapter = &itv->i2c_adap; 725 itv->i2c_adap.dev.parent = &itv->pdev->dev; 726 727 IVTV_DEBUG_I2C("setting scl and sda to 1\n"); 728 ivtv_setscl(itv, 1); 729 ivtv_setsda(itv, 1); 730 731 if (itv->options.newi2c > 0) 732 retval = i2c_add_adapter(&itv->i2c_adap); 733 else 734 retval = i2c_bit_add_bus(&itv->i2c_adap); 735 736 return retval; 737 } 738 739 void exit_ivtv_i2c(struct ivtv *itv) 740 { 741 IVTV_DEBUG_I2C("i2c exit\n"); 742 743 i2c_del_adapter(&itv->i2c_adap); 744 } 745