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 67#include <media/ir-kbd-i2c.h> 68 69/* i2c implementation for cx23415/6 chip, ivtv project. 70 * Author: Kevin Thayer (nufan_wfk at yahoo.com) 71 */ 72/* i2c stuff */ 73#define IVTV_REG_I2C_SETSCL_OFFSET 0x7000 74#define IVTV_REG_I2C_SETSDA_OFFSET 0x7004 75#define IVTV_REG_I2C_GETSCL_OFFSET 0x7008 76#define IVTV_REG_I2C_GETSDA_OFFSET 0x700c 77 78#ifndef I2C_ADAP_CLASS_TV_ANALOG 79#define I2C_ADAP_CLASS_TV_ANALOG I2C_CLASS_TV_ANALOG 80#endif /* I2C_ADAP_CLASS_TV_ANALOG */ 81 82#define IVTV_CS53L32A_I2C_ADDR 0x11 83#define IVTV_CX25840_I2C_ADDR 0x44 84#define IVTV_SAA7115_I2C_ADDR 0x21 85#define IVTV_SAA7127_I2C_ADDR 0x44 86#define IVTV_SAA717x_I2C_ADDR 0x21 87#define IVTV_MSP3400_I2C_ADDR 0x40 88#define IVTV_HAUPPAUGE_I2C_ADDR 0x50 89#define IVTV_WM8739_I2C_ADDR 0x1a 90#define IVTV_WM8775_I2C_ADDR 0x1b 91#define IVTV_TEA5767_I2C_ADDR 0x60 92#define IVTV_UPD64031A_I2C_ADDR 0x12 93#define IVTV_UPD64083_I2C_ADDR 0x5c 94#define IVTV_TDA985X_I2C_ADDR 0x5b 95 96/* This array should match the IVTV_HW_ defines */ 97static const u8 hw_driverids[] = { 98 I2C_DRIVERID_CX25840, 99 I2C_DRIVERID_SAA711X, 100 I2C_DRIVERID_SAA7127, 101 I2C_DRIVERID_MSP3400, 102 I2C_DRIVERID_TUNER, 103 I2C_DRIVERID_WM8775, 104 I2C_DRIVERID_CS53L32A, 105 I2C_DRIVERID_TVEEPROM, 106 I2C_DRIVERID_SAA711X, 107 I2C_DRIVERID_TVAUDIO, 108 I2C_DRIVERID_UPD64031A, 109 I2C_DRIVERID_UPD64083, 110 I2C_DRIVERID_SAA717X, 111 I2C_DRIVERID_WM8739, 112 0 /* IVTV_HW_GPIO dummy driver ID */ 113}; 114 115/* This array should match the IVTV_HW_ defines */ 116static const char * const hw_drivernames[] = { 117 "cx2584x", 118 "saa7115", 119 "saa7127", 120 "msp3400", 121 "tuner", 122 "wm8775", 123 "cs53l32a", 124 "tveeprom", 125 "saa7114", 126 "tvaudio", 127 "upd64031a", 128 "upd64083", 129 "saa717x", 130 "wm8739", 131 "gpio", 132}; 133 134static int attach_inform(struct i2c_client *client) 135{ 136 struct ivtv *itv = (struct ivtv *)i2c_get_adapdata(client->adapter); 137 int i; 138 139 IVTV_DEBUG_I2C("i2c client attach\n"); 140 for (i = 0; i < I2C_CLIENTS_MAX; i++) { 141 if (itv->i2c_clients[i] == NULL) { 142 itv->i2c_clients[i] = client; 143 break; 144 } 145 } 146 if (i == I2C_CLIENTS_MAX) { 147 IVTV_ERR("insufficient room for new I2C client!\n"); 148 } 149 return 0; 150} 151 152static int detach_inform(struct i2c_client *client) 153{ 154 int i; 155 struct ivtv *itv = (struct ivtv *)i2c_get_adapdata(client->adapter); 156 157 IVTV_DEBUG_I2C("i2c client detach\n"); 158 for (i = 0; i < I2C_CLIENTS_MAX; i++) { 159 if (itv->i2c_clients[i] == client) { 160 itv->i2c_clients[i] = NULL; 161 break; 162 } 163 } 164 IVTV_DEBUG_I2C("i2c detach [client=%s,%s]\n", 165 client->name, (i < I2C_CLIENTS_MAX) ? "ok" : "failed"); 166 167 return 0; 168} 169 170/* Set the serial clock line to the desired state */ 171static void ivtv_setscl(struct ivtv *itv, int state) 172{ 173 /* write them out */ 174 /* write bits are inverted */ 175 write_reg(~state, IVTV_REG_I2C_SETSCL_OFFSET); 176} 177 178/* Set the serial data line to the desired state */ 179static void ivtv_setsda(struct ivtv *itv, int state) 180{ 181 /* write them out */ 182 /* write bits are inverted */ 183 write_reg(~state & 1, IVTV_REG_I2C_SETSDA_OFFSET); 184} 185 186/* Read the serial clock line */ 187static int ivtv_getscl(struct ivtv *itv) 188{ 189 return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1; 190} 191 192/* Read the serial data line */ 193static int ivtv_getsda(struct ivtv *itv) 194{ 195 return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1; 196} 197 198/* Implement a short delay by polling the serial clock line */ 199static void ivtv_scldelay(struct ivtv *itv) 200{ 201 int i; 202 203 for (i = 0; i < 5; ++i) 204 ivtv_getscl(itv); 205} 206 207/* Wait for the serial clock line to become set to a specific value */ 208static int ivtv_waitscl(struct ivtv *itv, int val) 209{ 210 int i; 211 212 ivtv_scldelay(itv); 213 for (i = 0; i < 1000; ++i) { 214 if (ivtv_getscl(itv) == val) 215 return 1; 216 } 217 return 0; 218} 219 220/* Wait for the serial data line to become set to a specific value */ 221static int ivtv_waitsda(struct ivtv *itv, int val) 222{ 223 int i; 224 225 ivtv_scldelay(itv); 226 for (i = 0; i < 1000; ++i) { 227 if (ivtv_getsda(itv) == val) 228 return 1; 229 } 230 return 0; 231} 232 233/* Wait for the slave to issue an ACK */ 234static int ivtv_ack(struct ivtv *itv) 235{ 236 int ret = 0; 237 238 if (ivtv_getscl(itv) == 1) { 239 IVTV_DEBUG_I2C("SCL was high starting an ack\n"); 240 ivtv_setscl(itv, 0); 241 if (!ivtv_waitscl(itv, 0)) { 242 IVTV_DEBUG_I2C("Could not set SCL low starting an ack\n"); 243 return -EREMOTEIO; 244 } 245 } 246 ivtv_setsda(itv, 1); 247 ivtv_scldelay(itv); 248 ivtv_setscl(itv, 1); 249 if (!ivtv_waitsda(itv, 0)) { 250 IVTV_DEBUG_I2C("Slave did not ack\n"); 251 ret = -EREMOTEIO; 252 } 253 ivtv_setscl(itv, 0); 254 if (!ivtv_waitscl(itv, 0)) { 255 IVTV_DEBUG_I2C("Failed to set SCL low after ACK\n"); 256 ret = -EREMOTEIO; 257 } 258 return ret; 259} 260 261/* Write a single byte to the i2c bus and wait for the slave to ACK */ 262static int ivtv_sendbyte(struct ivtv *itv, unsigned char byte) 263{ 264 int i, bit; 265 266 IVTV_DEBUG_I2C("write %x\n",byte); 267 for (i = 0; i < 8; ++i, byte<<=1) { 268 ivtv_setscl(itv, 0); 269 if (!ivtv_waitscl(itv, 0)) { 270 IVTV_DEBUG_I2C("Error setting SCL low\n"); 271 return -EREMOTEIO; 272 } 273 bit = (byte>>7)&1; 274 ivtv_setsda(itv, bit); 275 if (!ivtv_waitsda(itv, bit)) { 276 IVTV_DEBUG_I2C("Error setting SDA\n"); 277 return -EREMOTEIO; 278 } 279 ivtv_setscl(itv, 1); 280 if (!ivtv_waitscl(itv, 1)) { 281 IVTV_DEBUG_I2C("Slave not ready for bit\n"); 282 return -EREMOTEIO; 283 } 284 } 285 ivtv_setscl(itv, 0); 286 if (!ivtv_waitscl(itv, 0)) { 287 IVTV_DEBUG_I2C("Error setting SCL low\n"); 288 return -EREMOTEIO; 289 } 290 return ivtv_ack(itv); 291} 292 293/* Read a byte from the i2c bus and send a NACK if applicable (i.e. for the 294 final byte) */ 295static int ivtv_readbyte(struct ivtv *itv, unsigned char *byte, int nack) 296{ 297 int i; 298 299 *byte = 0; 300 301 ivtv_setsda(itv, 1); 302 ivtv_scldelay(itv); 303 for (i = 0; i < 8; ++i) { 304 ivtv_setscl(itv, 0); 305 ivtv_scldelay(itv); 306 ivtv_setscl(itv, 1); 307 if (!ivtv_waitscl(itv, 1)) { 308 IVTV_DEBUG_I2C("Error setting SCL high\n"); 309 return -EREMOTEIO; 310 } 311 *byte = ((*byte)<<1)|ivtv_getsda(itv); 312 } 313 ivtv_setscl(itv, 0); 314 ivtv_scldelay(itv); 315 ivtv_setsda(itv, nack); 316 ivtv_scldelay(itv); 317 ivtv_setscl(itv, 1); 318 ivtv_scldelay(itv); 319 ivtv_setscl(itv, 0); 320 ivtv_scldelay(itv); 321 IVTV_DEBUG_I2C("read %x\n",*byte); 322 return 0; 323} 324 325/* Issue a start condition on the i2c bus to alert slaves to prepare for 326 an address write */ 327static int ivtv_start(struct ivtv *itv) 328{ 329 int sda; 330 331 sda = ivtv_getsda(itv); 332 if (sda != 1) { 333 IVTV_DEBUG_I2C("SDA was low at start\n"); 334 ivtv_setsda(itv, 1); 335 if (!ivtv_waitsda(itv, 1)) { 336 IVTV_DEBUG_I2C("SDA stuck low\n"); 337 return -EREMOTEIO; 338 } 339 } 340 if (ivtv_getscl(itv) != 1) { 341 ivtv_setscl(itv, 1); 342 if (!ivtv_waitscl(itv, 1)) { 343 IVTV_DEBUG_I2C("SCL stuck low at start\n"); 344 return -EREMOTEIO; 345 } 346 } 347 ivtv_setsda(itv, 0); 348 ivtv_scldelay(itv); 349 return 0; 350} 351 352/* Issue a stop condition on the i2c bus to release it */ 353static int ivtv_stop(struct ivtv *itv) 354{ 355 int i; 356 357 if (ivtv_getscl(itv) != 0) { 358 IVTV_DEBUG_I2C("SCL not low when stopping\n"); 359 ivtv_setscl(itv, 0); 360 if (!ivtv_waitscl(itv, 0)) { 361 IVTV_DEBUG_I2C("SCL could not be set low\n"); 362 } 363 } 364 ivtv_setsda(itv, 0); 365 ivtv_scldelay(itv); 366 ivtv_setscl(itv, 1); 367 if (!ivtv_waitscl(itv, 1)) { 368 IVTV_DEBUG_I2C("SCL could not be set high\n"); 369 return -EREMOTEIO; 370 } 371 ivtv_scldelay(itv); 372 ivtv_setsda(itv, 1); 373 if (!ivtv_waitsda(itv, 1)) { 374 IVTV_DEBUG_I2C("resetting I2C\n"); 375 for (i = 0; i < 16; ++i) { 376 ivtv_setscl(itv, 0); 377 ivtv_scldelay(itv); 378 ivtv_setscl(itv, 1); 379 ivtv_scldelay(itv); 380 ivtv_setsda(itv, 1); 381 } 382 ivtv_waitsda(itv, 1); 383 return -EREMOTEIO; 384 } 385 return 0; 386} 387 388/* Write a message to the given i2c slave. do_stop may be 0 to prevent 389 issuing the i2c stop condition (when following with a read) */ 390static int ivtv_write(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len, int do_stop) 391{ 392 int retry, ret = -EREMOTEIO; 393 u32 i; 394 395 for (retry = 0; ret != 0 && retry < 8; ++retry) { 396 ret = ivtv_start(itv); 397 398 if (ret == 0) { 399 ret = ivtv_sendbyte(itv, addr<<1); 400 for (i = 0; ret == 0 && i < len; ++i) 401 ret = ivtv_sendbyte(itv, data[i]); 402 } 403 if (ret != 0 || do_stop) { 404 ivtv_stop(itv); 405 } 406 } 407 if (ret) 408 IVTV_DEBUG_I2C("i2c write to %x failed\n", addr); 409 return ret; 410} 411 412/* Read data from the given i2c slave. A stop condition is always issued. */ 413static int ivtv_read(struct ivtv *itv, unsigned char addr, unsigned char *data, u32 len) 414{ 415 int retry, ret = -EREMOTEIO; 416 u32 i; 417 418 for (retry = 0; ret != 0 && retry < 8; ++retry) { 419 ret = ivtv_start(itv); 420 if (ret == 0) 421 ret = ivtv_sendbyte(itv, (addr << 1) | 1); 422 for (i = 0; ret == 0 && i < len; ++i) { 423 ret = ivtv_readbyte(itv, &data[i], i == len - 1); 424 } 425 ivtv_stop(itv); 426 } 427 if (ret) 428 IVTV_DEBUG_I2C("i2c read from %x failed\n", addr); 429 return ret; 430} 431 432/* Kernel i2c transfer implementation. Takes a number of messages to be read 433 or written. If a read follows a write, this will occur without an 434 intervening stop condition */ 435static int ivtv_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num) 436{ 437 struct ivtv *itv = i2c_get_adapdata(i2c_adap); 438 int retval; 439 int i; 440 441 mutex_lock(&itv->i2c_bus_lock); 442 for (i = retval = 0; retval == 0 && i < num; i++) { 443 if (msgs[i].flags & I2C_M_RD) 444 retval = ivtv_read(itv, msgs[i].addr, msgs[i].buf, msgs[i].len); 445 else { 446 /* if followed by a read, don't stop */ 447 int stop = !(i + 1 < num && msgs[i + 1].flags == I2C_M_RD); 448 449 retval = ivtv_write(itv, msgs[i].addr, msgs[i].buf, msgs[i].len, stop); 450 } 451 } 452 mutex_unlock(&itv->i2c_bus_lock); 453 return retval ? retval : num; 454} 455 456/* Kernel i2c capabilities */ 457static u32 ivtv_functionality(struct i2c_adapter *adap) 458{ 459 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; 460} 461 462static struct i2c_algorithm ivtv_algo = { 463 .master_xfer = ivtv_xfer, 464 .functionality = ivtv_functionality, 465}; 466 467/* template for our-bit banger */ 468static struct i2c_adapter ivtv_i2c_adap_hw_template = { 469 .name = "ivtv i2c driver", 470 .id = I2C_HW_B_CX2341X, 471 .algo = &ivtv_algo, 472 .algo_data = NULL, /* filled from template */ 473 .client_register = attach_inform, 474 .client_unregister = detach_inform, 475 .owner = THIS_MODULE, 476#ifdef I2C_ADAP_CLASS_TV_ANALOG 477 .class = I2C_ADAP_CLASS_TV_ANALOG, 478#endif 479}; 480 481static void ivtv_setscl_old(void *data, int state) 482{ 483 struct ivtv *itv = (struct ivtv *)data; 484 485 if (state) 486 itv->i2c_state |= 0x01; 487 else 488 itv->i2c_state &= ~0x01; 489 490 /* write them out */ 491 /* write bits are inverted */ 492 write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSCL_OFFSET); 493} 494 495static void ivtv_setsda_old(void *data, int state) 496{ 497 struct ivtv *itv = (struct ivtv *)data; 498 499 if (state) 500 itv->i2c_state |= 0x01; 501 else 502 itv->i2c_state &= ~0x01; 503 504 /* write them out */ 505 /* write bits are inverted */ 506 write_reg(~itv->i2c_state, IVTV_REG_I2C_SETSDA_OFFSET); 507} 508 509static int ivtv_getscl_old(void *data) 510{ 511 struct ivtv *itv = (struct ivtv *)data; 512 513 return read_reg(IVTV_REG_I2C_GETSCL_OFFSET) & 1; 514} 515 516static int ivtv_getsda_old(void *data) 517{ 518 struct ivtv *itv = (struct ivtv *)data; 519 520 return read_reg(IVTV_REG_I2C_GETSDA_OFFSET) & 1; 521} 522 523/* template for i2c-bit-algo */ 524static struct i2c_adapter ivtv_i2c_adap_template = { 525 .name = "ivtv i2c driver", 526 .id = I2C_HW_B_CX2341X, /* algo-bit is OR'd with this */ 527 .algo = NULL, /* set by i2c-algo-bit */ 528 .algo_data = NULL, /* filled from template */ 529 .client_register = attach_inform, 530 .client_unregister = detach_inform, 531 .owner = THIS_MODULE, 532#ifdef I2C_ADAP_CLASS_TV_ANALOG 533 .class = I2C_ADAP_CLASS_TV_ANALOG, 534#endif 535}; 536 537static struct i2c_algo_bit_data ivtv_i2c_algo_template = { 538 NULL, /* ?? */ 539 ivtv_setsda_old, /* setsda function */ 540 ivtv_setscl_old, /* " */ 541 ivtv_getsda_old, /* " */ 542 ivtv_getscl_old, /* " */ 543 10, /* udelay */ 544 200 /* timeout */ 545}; 546 547static struct i2c_client ivtv_i2c_client_template = { 548 .name = "ivtv internal", 549}; 550 551int ivtv_call_i2c_client(struct ivtv *itv, int addr, unsigned int cmd, void *arg) 552{ 553 struct i2c_client *client; 554 int retval; 555 int i; 556 557 IVTV_DEBUG_I2C("call_i2c_client addr=%02x\n", addr); 558 for (i = 0; i < I2C_CLIENTS_MAX; i++) { 559 client = itv->i2c_clients[i]; 560 if (client == NULL) { 561 continue; 562 } 563 if (client->driver->command == NULL) { 564 continue; 565 } 566 if (addr == client->addr) { 567 retval = client->driver->command(client, cmd, arg); 568 return retval; 569 } 570 } 571 if (cmd != VIDIOC_G_CHIP_IDENT) 572 IVTV_ERR("i2c addr 0x%02x not found for command 0x%x!\n", addr, cmd); 573 return -ENODEV; 574} 575 576/* Find the i2c device based on the driver ID and return 577 its i2c address or -ENODEV if no matching device was found. */ 578static int ivtv_i2c_id_addr(struct ivtv *itv, u32 id) 579{ 580 struct i2c_client *client; 581 int retval = -ENODEV; 582 int i; 583 584 for (i = 0; i < I2C_CLIENTS_MAX; i++) { 585 client = itv->i2c_clients[i]; 586 if (client == NULL) 587 continue; 588 if (id == client->driver->id) { 589 retval = client->addr; 590 break; 591 } 592 } 593 return retval; 594} 595 596/* Find the i2c device name matching the DRIVERID */ 597static const char *ivtv_i2c_id_name(u32 id) 598{ 599 int i; 600 601 for (i = 0; i < ARRAY_SIZE(hw_driverids); i++) 602 if (hw_driverids[i] == id) 603 return hw_drivernames[i]; 604 return "unknown device"; 605} 606 607/* Find the i2c device name matching the IVTV_HW_ flag */ 608static const char *ivtv_i2c_hw_name(u32 hw) 609{ 610 int i; 611 612 for (i = 0; i < ARRAY_SIZE(hw_driverids); i++) 613 if (1 << i == hw) 614 return hw_drivernames[i]; 615 return "unknown device"; 616} 617 618/* Find the i2c device matching the IVTV_HW_ flag and return 619 its i2c address or -ENODEV if no matching device was found. */ 620int ivtv_i2c_hw_addr(struct ivtv *itv, u32 hw) 621{ 622 int i; 623 624 for (i = 0; i < ARRAY_SIZE(hw_driverids); i++) 625 if (1 << i == hw) 626 return ivtv_i2c_id_addr(itv, hw_driverids[i]); 627 return -ENODEV; 628} 629 630/* Calls i2c device based on IVTV_HW_ flag. If hw == 0, then do nothing. 631 If hw == IVTV_HW_GPIO then call the gpio handler. */ 632int ivtv_i2c_hw(struct ivtv *itv, u32 hw, unsigned int cmd, void *arg) 633{ 634 int addr; 635 636 if (hw == IVTV_HW_GPIO) 637 return ivtv_gpio(itv, cmd, arg); 638 if (hw == 0) 639 return 0; 640 641 addr = ivtv_i2c_hw_addr(itv, hw); 642 if (addr < 0) { 643 IVTV_ERR("i2c hardware 0x%08x (%s) not found for command 0x%x!\n", 644 hw, ivtv_i2c_hw_name(hw), cmd); 645 return addr; 646 } 647 return ivtv_call_i2c_client(itv, addr, cmd, arg); 648} 649 650/* Calls i2c device based on I2C driver ID. */ 651int ivtv_i2c_id(struct ivtv *itv, u32 id, unsigned int cmd, void *arg) 652{ 653 int addr; 654 655 addr = ivtv_i2c_id_addr(itv, id); 656 if (addr < 0) { 657 if (cmd != VIDIOC_G_CHIP_IDENT) 658 IVTV_ERR("i2c ID 0x%08x (%s) not found for command 0x%x!\n", 659 id, ivtv_i2c_id_name(id), cmd); 660 return addr; 661 } 662 return ivtv_call_i2c_client(itv, addr, cmd, arg); 663} 664 665int ivtv_cx25840(struct ivtv *itv, unsigned int cmd, void *arg) 666{ 667 return ivtv_call_i2c_client(itv, IVTV_CX25840_I2C_ADDR, cmd, arg); 668} 669 670int ivtv_saa7115(struct ivtv *itv, unsigned int cmd, void *arg) 671{ 672 return ivtv_call_i2c_client(itv, IVTV_SAA7115_I2C_ADDR, cmd, arg); 673} 674 675int ivtv_saa7127(struct ivtv *itv, unsigned int cmd, void *arg) 676{ 677 return ivtv_call_i2c_client(itv, IVTV_SAA7127_I2C_ADDR, cmd, arg); 678} 679 680int ivtv_saa717x(struct ivtv *itv, unsigned int cmd, void *arg) 681{ 682 return ivtv_call_i2c_client(itv, IVTV_SAA717x_I2C_ADDR, cmd, arg); 683} 684 685int ivtv_upd64031a(struct ivtv *itv, unsigned int cmd, void *arg) 686{ 687 return ivtv_call_i2c_client(itv, IVTV_UPD64031A_I2C_ADDR, cmd, arg); 688} 689 690int ivtv_upd64083(struct ivtv *itv, unsigned int cmd, void *arg) 691{ 692 return ivtv_call_i2c_client(itv, IVTV_UPD64083_I2C_ADDR, cmd, arg); 693} 694 695/* broadcast cmd for all I2C clients and for the gpio subsystem */ 696void ivtv_call_i2c_clients(struct ivtv *itv, unsigned int cmd, void *arg) 697{ 698 if (itv->i2c_adap.algo == NULL) { 699 IVTV_ERR("adapter is not set"); 700 return; 701 } 702 i2c_clients_command(&itv->i2c_adap, cmd, arg); 703 if (itv->hw_flags & IVTV_HW_GPIO) 704 ivtv_gpio(itv, cmd, arg); 705} 706 707/* init + register i2c algo-bit adapter */ 708int __devinit init_ivtv_i2c(struct ivtv *itv) 709{ 710 IVTV_DEBUG_I2C("i2c init\n"); 711 712 if (itv->options.newi2c > 0) { 713 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_hw_template, 714 sizeof(struct i2c_adapter)); 715 } else { 716 memcpy(&itv->i2c_adap, &ivtv_i2c_adap_template, 717 sizeof(struct i2c_adapter)); 718 memcpy(&itv->i2c_algo, &ivtv_i2c_algo_template, 719 sizeof(struct i2c_algo_bit_data)); 720 itv->i2c_algo.data = itv; 721 itv->i2c_adap.algo_data = &itv->i2c_algo; 722 } 723 724 sprintf(itv->i2c_adap.name + strlen(itv->i2c_adap.name), " #%d", 725 itv->num); 726 i2c_set_adapdata(&itv->i2c_adap, itv); 727 728 memcpy(&itv->i2c_client, &ivtv_i2c_client_template, 729 sizeof(struct i2c_client)); 730 itv->i2c_client.adapter = &itv->i2c_adap; 731 itv->i2c_adap.dev.parent = &itv->dev->dev; 732 733 IVTV_DEBUG_I2C("setting scl and sda to 1\n"); 734 ivtv_setscl(itv, 1); 735 ivtv_setsda(itv, 1); 736 737 if (itv->options.newi2c > 0) 738 return i2c_add_adapter(&itv->i2c_adap); 739 else 740 return i2c_bit_add_bus(&itv->i2c_adap); 741} 742 743void __devexit exit_ivtv_i2c(struct ivtv *itv) 744{ 745 IVTV_DEBUG_I2C("i2c exit\n"); 746 747 i2c_del_adapter(&itv->i2c_adap); 748} 749