release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/media/video/bt8xx/bttv-i2c.c

   1 /*
   2
   3     bttv-i2c.c  --  all the i2c code is here
   4
   5     bttv - Bt848 frame grabber driver
   6
   7     Copyright (C) 1996,97,98 Ralph  Metzler (rjkm@thp.uni-koeln.de)
   8                            & Marcus Metzler (mocm@thp.uni-koeln.de)
   9     (c) 1999-2003 Gerd Knorr <kraxel@bytesex.org>
  10
  11     (c) 2005 Mauro Carvalho Chehab <mchehab@infradead.org>
  12         - Multituner support and i2c address binding
  13
  14     This program is free software; you can redistribute it and/or modify
  15     it under the terms of the GNU General Public License as published by
  16     the Free Software Foundation; either version 2 of the License, or
  17     (at your option) any later version.
  18
  19     This program is distributed in the hope that it will be useful,
  20     but WITHOUT ANY WARRANTY; without even the implied warranty of
  21     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22     GNU General Public License for more details.
  23
  24     You should have received a copy of the GNU General Public License
  25     along with this program; if not, write to the Free Software
  26     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  27
  28 */
  29
  30 #include <linux/module.h>
  31 #include <linux/init.h>
  32 #include <linux/delay.h>
  33
  34 #include "bttvp.h"
  35 #include <media/v4l2-common.h>
  36 #include <linux/jiffies.h>
  37 #include <asm/io.h>
  38
  39 static int i2c_debug;
  40 static int i2c_hw;
  41 static int i2c_scan;
  42 module_param(i2c_debug, int, 0644);
  43 MODULE_PARM_DESC(i2c_debug, "configure i2c debug level");
  44 module_param(i2c_hw,    int, 0444);
  45 MODULE_PARM_DESC(i2c_hw,"force use of hardware i2c support, "
  46                         "instead of software bitbang");
  47 module_param(i2c_scan,  int, 0444);
  48 MODULE_PARM_DESC(i2c_scan,"scan i2c bus at insmod time");
  49
  50 static unsigned int i2c_udelay = 5;
  51 module_param(i2c_udelay, int, 0444);
  52 MODULE_PARM_DESC(i2c_udelay,"soft i2c delay at insmod time, in usecs "
  53                 "(should be 5 or higher). Lower value means higher bus speed.");
  54
  55 /* ----------------------------------------------------------------------- */
  56 /* I2C functions - bitbanging adapter (software i2c)                       */
  57
  58 static void bttv_bit_setscl(void *data, int state)
  59 {
  60         struct bttv *btv = (struct bttv*)data;
  61
  62         if (state)
  63                 btv->i2c_state |= 0x02;
  64         else
  65                 btv->i2c_state &= ~0x02;
  66         btwrite(btv->i2c_state, BT848_I2C);
  67         btread(BT848_I2C);
  68 }
  69
  70 static void bttv_bit_setsda(void *data, int state)
  71 {
  72         struct bttv *btv = (struct bttv*)data;
  73
  74         if (state)
  75                 btv->i2c_state |= 0x01;
  76         else
  77                 btv->i2c_state &= ~0x01;
  78         btwrite(btv->i2c_state, BT848_I2C);
  79         btread(BT848_I2C);
  80 }
  81
  82 static int bttv_bit_getscl(void *data)
  83 {
  84         struct bttv *btv = (struct bttv*)data;
  85         int state;
  86
  87         state = btread(BT848_I2C) & 0x02 ? 1 : 0;
  88         return state;
  89 }
  90
  91 static int bttv_bit_getsda(void *data)
  92 {
  93         struct bttv *btv = (struct bttv*)data;
  94         int state;
  95
  96         state = btread(BT848_I2C) & 0x01;
  97         return state;
  98 }
  99
 100 static struct i2c_algo_bit_data __devinitdata bttv_i2c_algo_bit_template = {
 101         .setsda  = bttv_bit_setsda,
 102         .setscl  = bttv_bit_setscl,
 103         .getsda  = bttv_bit_getsda,
 104         .getscl  = bttv_bit_getscl,
 105         .udelay  = 16,
 106         .timeout = 200,
 107 };
 108
 109 /* ----------------------------------------------------------------------- */
 110 /* I2C functions - hardware i2c                                            */
 111
 112 static u32 functionality(struct i2c_adapter *adap)
 113 {
 114         return I2C_FUNC_SMBUS_EMUL;
 115 }
 116
 117 static int
 118 bttv_i2c_wait_done(struct bttv *btv)
 119 {
 120         int rc = 0;
 121
 122         /* timeout */
 123         if (wait_event_interruptible_timeout(btv->i2c_queue,
 124                 btv->i2c_done, msecs_to_jiffies(85)) == -ERESTARTSYS)
 125
 126         rc = -EIO;
 127
 128         if (btv->i2c_done & BT848_INT_RACK)
 129                 rc = 1;
 130         btv->i2c_done = 0;
 131         return rc;
 132 }
 133
 134 #define I2C_HW (BT878_I2C_MODE  | BT848_I2C_SYNC |\
 135                 BT848_I2C_SCL | BT848_I2C_SDA)
 136
 137 static int
 138 bttv_i2c_sendbytes(struct bttv *btv, const struct i2c_msg *msg, int last)
 139 {
 140         u32 xmit;
 141         int retval,cnt;
 142
 143         /* sanity checks */
 144         if (0 == msg->len)
 145                 return -EINVAL;
 146
 147         /* start, address + first byte */
 148         xmit = (msg->addr << 25) | (msg->buf[0] << 16) | I2C_HW;
 149         if (msg->len > 1 || !last)
 150                 xmit |= BT878_I2C_NOSTOP;
 151         btwrite(xmit, BT848_I2C);
 152         retval = bttv_i2c_wait_done(btv);
 153         if (retval < 0)
 154                 goto err;
 155         if (retval == 0)
 156                 goto eio;
 157         if (i2c_debug) {
 158                 printk(" <W %02x %02x", msg->addr << 1, msg->buf[0]);
 159                 if (!(xmit & BT878_I2C_NOSTOP))
 160                         printk(" >\n");
 161         }
 162
 163         for (cnt = 1; cnt < msg->len; cnt++ ) {
 164                 /* following bytes */
 165                 xmit = (msg->buf[cnt] << 24) | I2C_HW | BT878_I2C_NOSTART;
 166                 if (cnt < msg->len-1 || !last)
 167                         xmit |= BT878_I2C_NOSTOP;
 168                 btwrite(xmit, BT848_I2C);
 169                 retval = bttv_i2c_wait_done(btv);
 170                 if (retval < 0)
 171                         goto err;
 172                 if (retval == 0)
 173                         goto eio;
 174                 if (i2c_debug) {
 175                         printk(" %02x", msg->buf[cnt]);
 176                         if (!(xmit & BT878_I2C_NOSTOP))
 177                                 printk(" >\n");
 178                 }
 179         }
 180         return msg->len;
 181
 182  eio:
 183         retval = -EIO;
 184  err:
 185         if (i2c_debug)
 186                 printk(" ERR: %d\n",retval);
 187         return retval;
 188 }
 189
 190 static int
 191 bttv_i2c_readbytes(struct bttv *btv, const struct i2c_msg *msg, int last)
 192 {
 193         u32 xmit;
 194         u32 cnt;
 195         int retval;
 196
 197         for(cnt = 0; cnt < msg->len; cnt++) {
 198                 xmit = (msg->addr << 25) | (1 << 24) | I2C_HW;
 199                 if (cnt < msg->len-1)
 200                         xmit |= BT848_I2C_W3B;
 201                 if (cnt < msg->len-1 || !last)
 202                         xmit |= BT878_I2C_NOSTOP;
 203                 if (cnt)
 204                         xmit |= BT878_I2C_NOSTART;
 205                 btwrite(xmit, BT848_I2C);
 206                 retval = bttv_i2c_wait_done(btv);
 207                 if (retval < 0)
 208                         goto err;
 209                 if (retval == 0)
 210                         goto eio;
 211                 msg->buf[cnt] = ((u32)btread(BT848_I2C) >> 8) & 0xff;
 212                 if (i2c_debug) {
 213                         if (!(xmit & BT878_I2C_NOSTART))
 214                                 printk(" <R %02x", (msg->addr << 1) +1);
 215                         printk(" =%02x", msg->buf[cnt]);
 216                         if (!(xmit & BT878_I2C_NOSTOP))
 217                                 printk(" >\n");
 218                 }
 219         }
 220         return msg->len;
 221
 222  eio:
 223         retval = -EIO;
 224  err:
 225         if (i2c_debug)
 226                 printk(" ERR: %d\n",retval);
 227         return retval;
 228 }
 229
 230 static int bttv_i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg *msgs, int num)
 231 {
 232         struct v4l2_device *v4l2_dev = i2c_get_adapdata(i2c_adap);
 233         struct bttv *btv = to_bttv(v4l2_dev);
 234         int retval = 0;
 235         int i;
 236
 237         if (i2c_debug)
 238                 printk("bt-i2c:");
 239         btwrite(BT848_INT_I2CDONE|BT848_INT_RACK, BT848_INT_STAT);
 240         for (i = 0 ; i < num; i++) {
 241                 if (msgs[i].flags & I2C_M_RD) {
 242                         /* read */
 243                         retval = bttv_i2c_readbytes(btv, &msgs[i], i+1 == num);
 244                         if (retval < 0)
 245                                 goto err;
 246                 } else {
 247                         /* write */
 248                         retval = bttv_i2c_sendbytes(btv, &msgs[i], i+1 == num);
 249                         if (retval < 0)
 250                                 goto err;
 251                 }
 252         }
 253         return num;
 254
 255  err:
 256         return retval;
 257 }
 258
 259 static const struct i2c_algorithm bttv_algo = {
 260         .master_xfer   = bttv_i2c_xfer,
 261         .functionality = functionality,
 262 };
 263
 264 /* ----------------------------------------------------------------------- */
 265 /* I2C functions - common stuff                                            */
 266
 267 /* read I2C */
 268 int bttv_I2CRead(struct bttv *btv, unsigned char addr, char *probe_for)
 269 {
 270         unsigned char buffer = 0;
 271
 272         if (0 != btv->i2c_rc)
 273                 return -1;
 274         if (bttv_verbose && NULL != probe_for)
 275                 printk(KERN_INFO "bttv%d: i2c: checking for %s @ 0x%02x... ",
 276                        btv->c.nr,probe_for,addr);
 277         btv->i2c_client.addr = addr >> 1;
 278         if (1 != i2c_master_recv(&btv->i2c_client, &buffer, 1)) {
 279                 if (NULL != probe_for) {
 280                         if (bttv_verbose)
 281                                 printk("not found\n");
 282                 } else
 283                         printk(KERN_WARNING "bttv%d: i2c read 0x%x: error\n",
 284                                btv->c.nr,addr);
 285                 return -1;
 286         }
 287         if (bttv_verbose && NULL != probe_for)
 288                 printk("found\n");
 289         return buffer;
 290 }
 291
 292 /* write I2C */
 293 int bttv_I2CWrite(struct bttv *btv, unsigned char addr, unsigned char b1,
 294                     unsigned char b2, int both)
 295 {
 296         unsigned char buffer[2];
 297         int bytes = both ? 2 : 1;
 298
 299         if (0 != btv->i2c_rc)
 300                 return -1;
 301         btv->i2c_client.addr = addr >> 1;
 302         buffer[0] = b1;
 303         buffer[1] = b2;
 304         if (bytes != i2c_master_send(&btv->i2c_client, buffer, bytes))
 305                 return -1;
 306         return 0;
 307 }
 308
 309 /* read EEPROM content */
 310 void __devinit bttv_readee(struct bttv *btv, unsigned char *eedata, int addr)
 311 {
 312         memset(eedata, 0, 256);
 313         if (0 != btv->i2c_rc)
 314                 return;
 315         btv->i2c_client.addr = addr >> 1;
 316         tveeprom_read(&btv->i2c_client, eedata, 256);
 317 }
 318
 319 static char *i2c_devs[128] = {
 320         [ 0x1c >> 1 ] = "lgdt330x",
 321         [ 0x30 >> 1 ] = "IR (hauppauge)",
 322         [ 0x80 >> 1 ] = "msp34xx",
 323         [ 0x86 >> 1 ] = "tda9887",
 324         [ 0xa0 >> 1 ] = "eeprom",
 325         [ 0xc0 >> 1 ] = "tuner (analog)",
 326         [ 0xc2 >> 1 ] = "tuner (analog)",
 327 };
 328
 329 static void do_i2c_scan(char *name, struct i2c_client *c)
 330 {
 331         unsigned char buf;
 332         int i,rc;
 333
 334         for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
 335                 c->addr = i;
 336                 rc = i2c_master_recv(c,&buf,0);
 337                 if (rc < 0)
 338                         continue;
 339                 printk("%s: i2c scan: found device @ 0x%x  [%s]\n",
 340                        name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
 341         }
 342 }
 343
 344 /* init + register i2c algo-bit adapter */
 345 int __devinit init_bttv_i2c(struct bttv *btv)
 346 {
 347         strlcpy(btv->i2c_client.name, "bttv internal", I2C_NAME_SIZE);
 348
 349         if (i2c_hw)
 350                 btv->use_i2c_hw = 1;
 351         if (btv->use_i2c_hw) {
 352                 /* bt878 */
 353                 strlcpy(btv->c.i2c_adap.name, "bt878",
 354                         sizeof(btv->c.i2c_adap.name));
 355                 btv->c.i2c_adap.algo = &bttv_algo;
 356         } else {
 357                 /* bt848 */
 358         /* Prevents usage of invalid delay values */
 359                 if (i2c_udelay<5)
 360                         i2c_udelay=5;
 361
 362                 strlcpy(btv->c.i2c_adap.name, "bttv",
 363                         sizeof(btv->c.i2c_adap.name));
 364                 memcpy(&btv->i2c_algo, &bttv_i2c_algo_bit_template,
 365                        sizeof(bttv_i2c_algo_bit_template));
 366                 btv->i2c_algo.udelay = i2c_udelay;
 367                 btv->i2c_algo.data = btv;
 368                 btv->c.i2c_adap.algo_data = &btv->i2c_algo;
 369         }
 370         btv->c.i2c_adap.owner = THIS_MODULE;
 371
 372         btv->c.i2c_adap.dev.parent = &btv->c.pci->dev;
 373         snprintf(btv->c.i2c_adap.name, sizeof(btv->c.i2c_adap.name),
 374                  "bt%d #%d [%s]", btv->id, btv->c.nr,
 375                  btv->use_i2c_hw ? "hw" : "sw");
 376
 377         i2c_set_adapdata(&btv->c.i2c_adap, &btv->c.v4l2_dev);
 378         btv->i2c_client.adapter = &btv->c.i2c_adap;
 379
 380
 381         if (btv->use_i2c_hw) {
 382                 btv->i2c_rc = i2c_add_adapter(&btv->c.i2c_adap);
 383         } else {
 384                 bttv_bit_setscl(btv,1);
 385                 bttv_bit_setsda(btv,1);
 386                 btv->i2c_rc = i2c_bit_add_bus(&btv->c.i2c_adap);
 387         }
 388         if (0 == btv->i2c_rc && i2c_scan)
 389                 do_i2c_scan(btv->c.v4l2_dev.name, &btv->i2c_client);
 390
 391         return btv->i2c_rc;
 392 }
 393
 394 /* Instantiate the I2C IR receiver device, if present */
 395 void __devinit init_bttv_i2c_ir(struct bttv *btv)
 396 {
 397         if (0 == btv->i2c_rc) {
 398                 struct i2c_board_info info;
 399                 /* The external IR receiver is at i2c address 0x34 (0x35 for
 400                    reads).  Future Hauppauge cards will have an internal
 401                    receiver at 0x30 (0x31 for reads).  In theory, both can be
 402                    fitted, and Hauppauge suggest an external overrides an
 403                    internal.
 404
 405                    That's why we probe 0x1a (~0x34) first. CB
 406                 */
 407                 const unsigned short addr_list[] = {
 408                         0x1a, 0x18, 0x4b, 0x64, 0x30, 0x71,
 409                         I2C_CLIENT_END
 410                 };
 411
 412                 memset(&info, 0, sizeof(struct i2c_board_info));
 413                 strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
 414                 i2c_new_probed_device(&btv->c.i2c_adap, &info, addr_list, NULL);
 415         }
 416 }
 417
 418 int __devexit fini_bttv_i2c(struct bttv *btv)
 419 {
 420         if (0 != btv->i2c_rc)
 421                 return 0;
 422
 423         return i2c_del_adapter(&btv->c.i2c_adap);
 424 }
 425
 426 /*
 427  * Local variables:
 428  * c-basic-offset: 8
 429  * End:
 430  */