usbvision-i2c.c revision 3153bd91bfe14b6b93aef5b6b7c9fc279eec60d9
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 0x42 << 1: 282 case 0x43 << 1: 283 case 0x4a << 1: 284 case 0x4b << 1: 285 { 286 struct tuner_setup tun_setup; 287 288 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO; 289 tun_setup.type = TUNER_TDA9887; 290 tun_setup.addr = client->addr; 291 292 call_i2c_clients(usbvision, TUNER_SET_TYPE_ADDR, &tun_setup); 293 294 break; 295 } 296 case 0x42: 297 PDEBUG(DBG_I2C,"attach_inform: saa7114 detected."); 298 break; 299 case 0x4a: 300 PDEBUG(DBG_I2C,"attach_inform: saa7113 detected."); 301 break; 302 case 0x48: 303 PDEBUG(DBG_I2C,"attach_inform: saa7111 detected."); 304 break; 305 case 0xa0: 306 PDEBUG(DBG_I2C,"attach_inform: eeprom detected."); 307 break; 308 309 default: 310 { 311 struct tuner_setup tun_setup; 312 313 PDEBUG(DBG_I2C,"attach inform: detected I2C address %x", client->addr << 1); 314 usbvision->tuner_addr = client->addr; 315 316 if ((usbvision->have_tuner) && (usbvision->tuner_type != -1)) { 317 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO; 318 tun_setup.type = usbvision->tuner_type; 319 tun_setup.addr = usbvision->tuner_addr; 320 call_i2c_clients(usbvision, TUNER_SET_TYPE_ADDR, &tun_setup); 321 } 322 } 323 break; 324 } 325 return 0; 326} 327 328static int detach_inform(struct i2c_client *client) 329{ 330 struct usb_usbvision *usbvision; 331 332 usbvision = i2c_get_adapdata(client->adapter); 333 334 PDEBUG(DBG_I2C,"usbvision[%d] detaches %s", usbvision->nr, client->name); 335 return 0; 336} 337 338static int 339usbvision_i2c_read_max4(struct usb_usbvision *usbvision, unsigned char addr, 340 char *buf, short len) 341{ 342 int rc, retries; 343 344 for (retries = 5;;) { 345 rc = usbvision_write_reg(usbvision, USBVISION_SER_ADRS, addr); 346 if (rc < 0) 347 return rc; 348 349 /* Initiate byte read cycle */ 350 /* USBVISION_SER_CONT <- d0-d2 n. of bytes to r/w */ 351 /* d3 0=Wr 1=Rd */ 352 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT, 353 (len & 0x07) | 0x18); 354 if (rc < 0) 355 return rc; 356 357 /* Test for Busy and ACK */ 358 do { 359 /* USBVISION_SER_CONT -> d4 == 0 busy */ 360 rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT); 361 } while (rc > 0 && ((rc & 0x10) != 0)); /* Retry while busy */ 362 if (rc < 0) 363 return rc; 364 365 /* USBVISION_SER_CONT -> d5 == 1 Not ack */ 366 if ((rc & 0x20) == 0) /* Ack? */ 367 break; 368 369 /* I2C abort */ 370 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00); 371 if (rc < 0) 372 return rc; 373 374 if (--retries < 0) 375 return -1; 376 } 377 378 switch (len) { 379 case 4: 380 buf[3] = usbvision_read_reg(usbvision, USBVISION_SER_DAT4); 381 case 3: 382 buf[2] = usbvision_read_reg(usbvision, USBVISION_SER_DAT3); 383 case 2: 384 buf[1] = usbvision_read_reg(usbvision, USBVISION_SER_DAT2); 385 case 1: 386 buf[0] = usbvision_read_reg(usbvision, USBVISION_SER_DAT1); 387 break; 388 default: 389 printk(KERN_ERR 390 "usbvision_i2c_read_max4: buffer length > 4\n"); 391 } 392 393 if (i2c_debug & DBG_I2C) { 394 int idx; 395 for (idx = 0; idx < len; idx++) { 396 PDEBUG(DBG_I2C,"read %x from address %x", (unsigned char)buf[idx], addr); 397 } 398 } 399 return len; 400} 401 402 403static int usbvision_i2c_write_max4(struct usb_usbvision *usbvision, 404 unsigned char addr, const char *buf, 405 short len) 406{ 407 int rc, retries; 408 int i; 409 unsigned char value[6]; 410 unsigned char ser_cont; 411 412 ser_cont = (len & 0x07) | 0x10; 413 414 value[0] = addr; 415 value[1] = ser_cont; 416 for (i = 0; i < len; i++) 417 value[i + 2] = buf[i]; 418 419 for (retries = 5;;) { 420 rc = usb_control_msg(usbvision->dev, 421 usb_sndctrlpipe(usbvision->dev, 1), 422 USBVISION_OP_CODE, 423 USB_DIR_OUT | USB_TYPE_VENDOR | 424 USB_RECIP_ENDPOINT, 0, 425 (__u16) USBVISION_SER_ADRS, value, 426 len + 2, HZ); 427 428 if (rc < 0) 429 return rc; 430 431 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT, 432 (len & 0x07) | 0x10); 433 if (rc < 0) 434 return rc; 435 436 /* Test for Busy and ACK */ 437 do { 438 rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT); 439 } while (rc > 0 && ((rc & 0x10) != 0)); /* Retry while busy */ 440 if (rc < 0) 441 return rc; 442 443 if ((rc & 0x20) == 0) /* Ack? */ 444 break; 445 446 /* I2C abort */ 447 usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00); 448 449 if (--retries < 0) 450 return -1; 451 452 } 453 454 if (i2c_debug & DBG_I2C) { 455 int idx; 456 for (idx = 0; idx < len; idx++) { 457 PDEBUG(DBG_I2C,"wrote %x at address %x", (unsigned char)buf[idx], addr); 458 } 459 } 460 return len; 461} 462 463static int usbvision_i2c_write(struct usb_usbvision *usbvision, unsigned char addr, char *buf, 464 short len) 465{ 466 char *bufPtr = buf; 467 int retval; 468 int wrcount = 0; 469 int count; 470 int maxLen = 4; 471 472 while (len > 0) { 473 count = (len > maxLen) ? maxLen : len; 474 retval = usbvision_i2c_write_max4(usbvision, addr, bufPtr, count); 475 if (retval > 0) { 476 len -= count; 477 bufPtr += count; 478 wrcount += count; 479 } else 480 return (retval < 0) ? retval : -EFAULT; 481 } 482 return wrcount; 483} 484 485static int usbvision_i2c_read(struct usb_usbvision *usbvision, unsigned char addr, char *buf, 486 short len) 487{ 488 char temp[4]; 489 int retval, i; 490 int rdcount = 0; 491 int count; 492 493 while (len > 0) { 494 count = (len > 3) ? 4 : len; 495 retval = usbvision_i2c_read_max4(usbvision, addr, temp, count); 496 if (retval > 0) { 497 for (i = 0; i < len; i++) 498 buf[rdcount + i] = temp[i]; 499 len -= count; 500 rdcount += count; 501 } else 502 return (retval < 0) ? retval : -EFAULT; 503 } 504 return rdcount; 505} 506 507static struct i2c_adapter i2c_adap_template = { 508 .owner = THIS_MODULE, 509 .name = "usbvision", 510 .id = I2C_HW_B_BT848, /* FIXME */ 511 .algo = &usbvision_algo, 512 .algo_data = NULL, 513 .client_register = attach_inform, 514 .client_unregister = detach_inform, 515#ifdef I2C_ADAP_CLASS_TV_ANALOG 516 .class = I2C_ADAP_CLASS_TV_ANALOG, 517#else 518 .class = I2C_CLASS_TV_ANALOG, 519#endif 520}; 521 522static struct i2c_client i2c_client_template = { 523 .name = "usbvision internal", 524}; 525 526/* 527 * Overrides for Emacs so that we follow Linus's tabbing style. 528 * --------------------------------------------------------------------------- 529 * Local variables: 530 * c-basic-offset: 8 531 * End: 532 */ 533