usbvision-i2c.c revision 1ff16c2091a557f8080eb62c087465a87e4330e9
1/* 2 * usbvision_i2c.c 3 * i2c algorithm for USB-I2C Bridges 4 * 5 * Copyright (c) 1999-2007 Joerg Heckenbach <joerg@heckenbach-aw.de> 6 * Dwaine Garden <dwainegarden@rogers.com> 7 * 8 * This module is part of usbvision driver project. 9 * Updates to driver completed by Dwaine P. Garden 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License as published by 13 * the Free Software Foundation; either version 2 of the License, or 14 * (at your option) any later version. 15 * 16 * This program is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 24 */ 25 26 27#include <linux/kernel.h> 28#include <linux/module.h> 29#include <linux/delay.h> 30#include <linux/slab.h> 31#include <linux/version.h> 32#include <linux/utsname.h> 33#include <linux/init.h> 34#include <asm/uaccess.h> 35#include <linux/ioport.h> 36#include <linux/errno.h> 37#include <linux/usb.h> 38#include <linux/i2c.h> 39#include "usbvision.h" 40 41#define DBG_I2C 1<<0 42 43static int i2c_debug = 0; 44 45module_param (i2c_debug, int, 0644); // debug_i2c_usb mode of the device driver 46MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]"); 47 48#define PDEBUG(level, fmt, args...) \ 49 if (i2c_debug & (level)) info("[%s:%d] " fmt, __PRETTY_FUNCTION__, __LINE__ , ## args) 50 51static int usbvision_i2c_write(struct usb_usbvision *usbvision, unsigned char addr, char *buf, 52 short len); 53static int usbvision_i2c_read(struct usb_usbvision *usbvision, unsigned char addr, char *buf, 54 short len); 55 56static inline int try_write_address(struct i2c_adapter *i2c_adap, 57 unsigned char addr, int retries) 58{ 59 struct usb_usbvision *usbvision; 60 int i, ret = -1; 61 char buf[4]; 62 63 usbvision = i2c_get_adapdata(i2c_adap); 64 buf[0] = 0x00; 65 for (i = 0; i <= retries; i++) { 66 ret = (usbvision_i2c_write(usbvision, addr, buf, 1)); 67 if (ret == 1) 68 break; /* success! */ 69 udelay(5); 70 if (i == retries) /* no success */ 71 break; 72 udelay(10); 73 } 74 if (i) { 75 PDEBUG(DBG_I2C,"Needed %d retries for address %#2x", i, addr); 76 PDEBUG(DBG_I2C,"Maybe there's no device at this address"); 77 } 78 return ret; 79} 80 81static inline int try_read_address(struct i2c_adapter *i2c_adap, 82 unsigned char addr, int retries) 83{ 84 struct usb_usbvision *usbvision; 85 int i, ret = -1; 86 char buf[4]; 87 88 usbvision = i2c_get_adapdata(i2c_adap); 89 for (i = 0; i <= retries; i++) { 90 ret = (usbvision_i2c_read(usbvision, addr, buf, 1)); 91 if (ret == 1) 92 break; /* success! */ 93 udelay(5); 94 if (i == retries) /* no success */ 95 break; 96 udelay(10); 97 } 98 if (i) { 99 PDEBUG(DBG_I2C,"Needed %d retries for address %#2x", i, addr); 100 PDEBUG(DBG_I2C,"Maybe there's no device at this address"); 101 } 102 return ret; 103} 104 105static inline int usb_find_address(struct i2c_adapter *i2c_adap, 106 struct i2c_msg *msg, int retries, 107 unsigned char *add) 108{ 109 unsigned short flags = msg->flags; 110 111 unsigned char addr; 112 int ret; 113 if ((flags & I2C_M_TEN)) { 114 /* a ten bit address */ 115 addr = 0xf0 | ((msg->addr >> 7) & 0x03); 116 /* try extended address code... */ 117 ret = try_write_address(i2c_adap, addr, retries); 118 if (ret != 1) { 119 err("died at extended address code, while writing"); 120 return -EREMOTEIO; 121 } 122 add[0] = addr; 123 if (flags & I2C_M_RD) { 124 /* okay, now switch into reading mode */ 125 addr |= 0x01; 126 ret = try_read_address(i2c_adap, addr, retries); 127 if (ret != 1) { 128 err("died at extended address code, while reading"); 129 return -EREMOTEIO; 130 } 131 } 132 133 } else { /* normal 7bit address */ 134 addr = (msg->addr << 1); 135 if (flags & I2C_M_RD) 136 addr |= 1; 137 if (flags & I2C_M_REV_DIR_ADDR) 138 addr ^= 1; 139 140 add[0] = addr; 141 if (flags & I2C_M_RD) 142 ret = try_read_address(i2c_adap, addr, retries); 143 else 144 ret = try_write_address(i2c_adap, addr, retries); 145 146 if (ret != 1) { 147 return -EREMOTEIO; 148 } 149 } 150 return 0; 151} 152 153static int 154usbvision_i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num) 155{ 156 struct i2c_msg *pmsg; 157 struct usb_usbvision *usbvision; 158 int i, ret; 159 unsigned char addr; 160 161 usbvision = i2c_get_adapdata(i2c_adap); 162 for (i = 0; i < num; i++) { 163 pmsg = &msgs[i]; 164 ret = usb_find_address(i2c_adap, pmsg, i2c_adap->retries, &addr); 165 if (ret != 0) { 166 PDEBUG(DBG_I2C,"got NAK from device, message #%d", i); 167 return (ret < 0) ? ret : -EREMOTEIO; 168 } 169 170 if (pmsg->flags & I2C_M_RD) { 171 /* read bytes into buffer */ 172 ret = (usbvision_i2c_read(usbvision, addr, pmsg->buf, pmsg->len)); 173 if (ret < pmsg->len) { 174 return (ret < 0) ? ret : -EREMOTEIO; 175 } 176 } else { 177 /* write bytes from buffer */ 178 ret = (usbvision_i2c_write(usbvision, addr, pmsg->buf, pmsg->len)); 179 if (ret < pmsg->len) { 180 return (ret < 0) ? ret : -EREMOTEIO; 181 } 182 } 183 } 184 return num; 185} 186 187static int algo_control(struct i2c_adapter *adapter, unsigned int cmd, unsigned long arg) 188{ 189 return 0; 190} 191 192static u32 functionality(struct i2c_adapter *adap) 193{ 194 return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_10BIT_ADDR | I2C_FUNC_PROTOCOL_MANGLING; 195} 196 197 198/* -----exported algorithm data: ------------------------------------- */ 199 200static struct i2c_algorithm usbvision_algo = { 201 .master_xfer = usbvision_i2c_xfer, 202 .smbus_xfer = NULL, 203 .algo_control = algo_control, 204 .functionality = functionality, 205}; 206 207 208/* ----------------------------------------------------------------------- */ 209/* usbvision specific I2C functions */ 210/* ----------------------------------------------------------------------- */ 211static struct i2c_adapter i2c_adap_template; 212static struct i2c_client i2c_client_template; 213 214int usbvision_i2c_register(struct usb_usbvision *usbvision) 215{ 216 int ret; 217 218 usbvision->i2c_adap = i2c_adap_template; 219 usbvision->i2c_adap.dev.parent = &usbvision->dev->dev; 220 221 PDEBUG(DBG_I2C, "I2C debugging is enabled [i2c]"); 222 223 sprintf(usbvision->i2c_adap.name + strlen(usbvision->i2c_adap.name), 224 " #%d", usbvision->vdev->minor & 0x1f); 225 PDEBUG(DBG_I2C,"I2C Registering adaptername: %s", usbvision->i2c_adap.name); 226 i2c_set_adapdata(&usbvision->i2c_adap,usbvision); 227 if ((ret = i2c_add_adapter(&usbvision->i2c_adap)) < 0) { 228 PDEBUG(DBG_I2C,"could not add I2C adapter %s", usbvision->i2c_adap.name); 229 return ret; 230 } 231 232 /* TODO: use i2c_client for eeprom detection as an example... */ 233 usbvision->i2c_client = i2c_client_template; 234 usbvision->i2c_client.adapter = &usbvision->i2c_adap; 235 236 if (usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_IIC_LRNACK) < 0) { 237 printk(KERN_ERR "usbvision_i2c_register: can't write reg\n"); 238 return -EBUSY; 239 } 240 241#ifdef CONFIG_MODULES 242 /* Request the load of the i2c modules we need */ 243 switch (usbvision_device_data[usbvision->DevModel].Codec) { 244 case CODEC_SAA7113: 245 request_module("saa7115"); 246 break; 247 case CODEC_SAA7111: 248 request_module("saa7115"); 249 break; 250 } 251 if (usbvision_device_data[usbvision->DevModel].Tuner == 1) { 252 request_module("tuner"); 253 } 254#endif 255 256 return 0; 257} 258 259int usbvision_i2c_unregister(struct usb_usbvision *usbvision) 260{ 261 262 i2c_del_adapter(&(usbvision->i2c_adap)); 263 264 PDEBUG(DBG_I2C,"i2c bus for %s unregistered", usbvision->i2c_adap.name); 265 266 return 0; 267} 268 269void call_i2c_clients(struct usb_usbvision *usbvision, unsigned int cmd, 270 void *arg) 271{ 272 i2c_clients_command(&usbvision->i2c_adap, cmd, arg); 273} 274 275static int attach_inform(struct i2c_client *client) 276{ 277 struct usb_usbvision *usbvision; 278 279 usbvision = i2c_get_adapdata(client->adapter); 280 switch (client->addr << 1) { 281 case 0x43: 282 case 0x4b: 283 { 284 struct tuner_setup tun_setup; 285 286 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO; 287 tun_setup.type = TUNER_TDA9887; 288 tun_setup.addr = client->addr; 289 290 call_i2c_clients(usbvision, TUNER_SET_TYPE_ADDR, &tun_setup); 291 292 break; 293 } 294 case 0x42: 295 PDEBUG(DBG_I2C,"attach_inform: saa7114 detected."); 296 break; 297 case 0x4a: 298 PDEBUG(DBG_I2C,"attach_inform: saa7113 detected."); 299 break; 300 case 0x48: 301 PDEBUG(DBG_I2C,"attach_inform: saa7111 detected."); 302 break; 303 case 0xa0: 304 PDEBUG(DBG_I2C,"attach_inform: eeprom detected."); 305 break; 306 307 default: 308 { 309 struct tuner_setup tun_setup; 310 311 PDEBUG(DBG_I2C,"attach inform: detected I2C address %x", client->addr << 1); 312 usbvision->tuner_addr = client->addr; 313 314 if ((usbvision->have_tuner) && (usbvision->tuner_type != -1)) { 315 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO; 316 tun_setup.type = usbvision->tuner_type; 317 tun_setup.addr = usbvision->tuner_addr; 318 call_i2c_clients(usbvision, TUNER_SET_TYPE_ADDR, &tun_setup); 319 } 320 } 321 break; 322 } 323 return 0; 324} 325 326static int detach_inform(struct i2c_client *client) 327{ 328 struct usb_usbvision *usbvision; 329 330 usbvision = i2c_get_adapdata(client->adapter); 331 332 PDEBUG(DBG_I2C,"usbvision[%d] detaches %s", usbvision->nr, client->name); 333 return 0; 334} 335 336static int 337usbvision_i2c_read_max4(struct usb_usbvision *usbvision, unsigned char addr, 338 char *buf, short len) 339{ 340 int rc, retries; 341 342 for (retries = 5;;) { 343 rc = usbvision_write_reg(usbvision, USBVISION_SER_ADRS, addr); 344 if (rc < 0) 345 return rc; 346 347 /* Initiate byte read cycle */ 348 /* USBVISION_SER_CONT <- d0-d2 n. of bytes to r/w */ 349 /* d3 0=Wr 1=Rd */ 350 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT, 351 (len & 0x07) | 0x18); 352 if (rc < 0) 353 return rc; 354 355 /* Test for Busy and ACK */ 356 do { 357 /* USBVISION_SER_CONT -> d4 == 0 busy */ 358 rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT); 359 } while (rc > 0 && ((rc & 0x10) != 0)); /* Retry while busy */ 360 if (rc < 0) 361 return rc; 362 363 /* USBVISION_SER_CONT -> d5 == 1 Not ack */ 364 if ((rc & 0x20) == 0) /* Ack? */ 365 break; 366 367 /* I2C abort */ 368 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00); 369 if (rc < 0) 370 return rc; 371 372 if (--retries < 0) 373 return -1; 374 } 375 376 switch (len) { 377 case 4: 378 buf[3] = usbvision_read_reg(usbvision, USBVISION_SER_DAT4); 379 case 3: 380 buf[2] = usbvision_read_reg(usbvision, USBVISION_SER_DAT3); 381 case 2: 382 buf[1] = usbvision_read_reg(usbvision, USBVISION_SER_DAT2); 383 case 1: 384 buf[0] = usbvision_read_reg(usbvision, USBVISION_SER_DAT1); 385 break; 386 default: 387 printk(KERN_ERR 388 "usbvision_i2c_read_max4: buffer length > 4\n"); 389 } 390 391 if (i2c_debug & DBG_I2C) { 392 int idx; 393 for (idx = 0; idx < len; idx++) { 394 PDEBUG(DBG_I2C,"read %x from address %x", (unsigned char)buf[idx], addr); 395 } 396 } 397 return len; 398} 399 400 401static int usbvision_i2c_write_max4(struct usb_usbvision *usbvision, 402 unsigned char addr, const char *buf, 403 short len) 404{ 405 int rc, retries; 406 int i; 407 unsigned char value[6]; 408 unsigned char ser_cont; 409 410 ser_cont = (len & 0x07) | 0x10; 411 412 value[0] = addr; 413 value[1] = ser_cont; 414 for (i = 0; i < len; i++) 415 value[i + 2] = buf[i]; 416 417 for (retries = 5;;) { 418 rc = usb_control_msg(usbvision->dev, 419 usb_sndctrlpipe(usbvision->dev, 1), 420 USBVISION_OP_CODE, 421 USB_DIR_OUT | USB_TYPE_VENDOR | 422 USB_RECIP_ENDPOINT, 0, 423 (__u16) USBVISION_SER_ADRS, value, 424 len + 2, HZ); 425 426 if (rc < 0) 427 return rc; 428 429 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT, 430 (len & 0x07) | 0x10); 431 if (rc < 0) 432 return rc; 433 434 /* Test for Busy and ACK */ 435 do { 436 rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT); 437 } while (rc > 0 && ((rc & 0x10) != 0)); /* Retry while busy */ 438 if (rc < 0) 439 return rc; 440 441 if ((rc & 0x20) == 0) /* Ack? */ 442 break; 443 444 /* I2C abort */ 445 usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00); 446 447 if (--retries < 0) 448 return -1; 449 450 } 451 452 if (i2c_debug & DBG_I2C) { 453 int idx; 454 for (idx = 0; idx < len; idx++) { 455 PDEBUG(DBG_I2C,"wrote %x at address %x", (unsigned char)buf[idx], addr); 456 } 457 } 458 return len; 459} 460 461static int usbvision_i2c_write(struct usb_usbvision *usbvision, unsigned char addr, char *buf, 462 short len) 463{ 464 char *bufPtr = buf; 465 int retval; 466 int wrcount = 0; 467 int count; 468 int maxLen = 4; 469 470 while (len > 0) { 471 count = (len > maxLen) ? maxLen : len; 472 retval = usbvision_i2c_write_max4(usbvision, addr, bufPtr, count); 473 if (retval > 0) { 474 len -= count; 475 bufPtr += count; 476 wrcount += count; 477 } else 478 return (retval < 0) ? retval : -EFAULT; 479 } 480 return wrcount; 481} 482 483static int usbvision_i2c_read(struct usb_usbvision *usbvision, unsigned char addr, char *buf, 484 short len) 485{ 486 char temp[4]; 487 int retval, i; 488 int rdcount = 0; 489 int count; 490 491 while (len > 0) { 492 count = (len > 3) ? 4 : len; 493 retval = usbvision_i2c_read_max4(usbvision, addr, temp, count); 494 if (retval > 0) { 495 for (i = 0; i < len; i++) 496 buf[rdcount + i] = temp[i]; 497 len -= count; 498 rdcount += count; 499 } else 500 return (retval < 0) ? retval : -EFAULT; 501 } 502 return rdcount; 503} 504 505static struct i2c_adapter i2c_adap_template = { 506 .owner = THIS_MODULE, 507 .name = "usbvision", 508 .id = I2C_HW_B_BT848, /* FIXME */ 509 .algo = &usbvision_algo, 510 .algo_data = NULL, 511 .client_register = attach_inform, 512 .client_unregister = detach_inform, 513#ifdef I2C_ADAP_CLASS_TV_ANALOG 514 .class = I2C_ADAP_CLASS_TV_ANALOG, 515#else 516 .class = I2C_CLASS_TV_ANALOG, 517#endif 518}; 519 520static struct i2c_client i2c_client_template = { 521 .name = "usbvision internal", 522}; 523 524/* 525 * Overrides for Emacs so that we follow Linus's tabbing style. 526 * --------------------------------------------------------------------------- 527 * Local variables: 528 * c-basic-offset: 8 529 * End: 530 */ 531