drivers/media/usb/usbvision/usbvision-i2c.c

   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
  22
  23 #include <linux/kernel.h>
  24 #include <linux/module.h>
  25 #include <linux/delay.h>
  26 #include <linux/init.h>
  27 #include <linux/uaccess.h>
  28 #include <linux/ioport.h>
  29 #include <linux/errno.h>
  30 #include <linux/usb.h>
  31 #include <linux/i2c.h>
  32 #include "usbvision.h"
  33
  34 #define DBG_I2C         (1 << 0)
  35
  36 static int i2c_debug;
  37
  38 module_param(i2c_debug, int, 0644);                     /* debug_i2c_usb mode of the device driver */
  39 MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
  40
  41 #define PDEBUG(level, fmt, args...) { \
  42                 if (i2c_debug & (level)) \
  43                         printk(KERN_INFO KBUILD_MODNAME ":[%s:%d] " fmt, \
  44                                 __func__, __LINE__ , ## args); \
  45         }
  46
  47 static int usbvision_i2c_write(struct usb_usbvision *usbvision, unsigned char addr, char *buf,
  48                             short len);
  49 static int usbvision_i2c_read(struct usb_usbvision *usbvision, unsigned char addr, char *buf,
  50                            short len);
  51
  52 static inline int try_write_address(struct i2c_adapter *i2c_adap,
  53                                     unsigned char addr, int retries)
  54 {
  55         struct usb_usbvision *usbvision;
  56         int i, ret = -1;
  57         char buf[4];
  58
  59         usbvision = (struct usb_usbvision *)i2c_get_adapdata(i2c_adap);
  60         buf[0] = 0x00;
  61         for (i = 0; i <= retries; i++) {
  62                 ret = (usbvision_i2c_write(usbvision, addr, buf, 1));
  63                 if (ret == 1)
  64                         break;  /* success! */
  65                 udelay(5);
  66                 if (i == retries)       /* no success */
  67                         break;
  68                 udelay(10);
  69         }
  70         if (i) {
  71                 PDEBUG(DBG_I2C, "Needed %d retries for address %#2x", i, addr);
  72                 PDEBUG(DBG_I2C, "Maybe there's no device at this address");
  73         }
  74         return ret;
  75 }
  76
  77 static inline int try_read_address(struct i2c_adapter *i2c_adap,
  78                                    unsigned char addr, int retries)
  79 {
  80         struct usb_usbvision *usbvision;
  81         int i, ret = -1;
  82         char buf[4];
  83
  84         usbvision = (struct usb_usbvision *)i2c_get_adapdata(i2c_adap);
  85         for (i = 0; i <= retries; i++) {
  86                 ret = (usbvision_i2c_read(usbvision, addr, buf, 1));
  87                 if (ret == 1)
  88                         break;  /* success! */
  89                 udelay(5);
  90                 if (i == retries)       /* no success */
  91                         break;
  92                 udelay(10);
  93         }
  94         if (i) {
  95                 PDEBUG(DBG_I2C, "Needed %d retries for address %#2x", i, addr);
  96                 PDEBUG(DBG_I2C, "Maybe there's no device at this address");
  97         }
  98         return ret;
  99 }
 100
 101 static inline int usb_find_address(struct i2c_adapter *i2c_adap,
 102                                    struct i2c_msg *msg, int retries,
 103                                    unsigned char *add)
 104 {
 105         unsigned short flags = msg->flags;
 106
 107         unsigned char addr;
 108         int ret;
 109
 110         addr = (msg->addr << 1);
 111         if (flags & I2C_M_RD)
 112                 addr |= 1;
 113
 114         add[0] = addr;
 115         if (flags & I2C_M_RD)
 116                 ret = try_read_address(i2c_adap, addr, retries);
 117         else
 118                 ret = try_write_address(i2c_adap, addr, retries);
 119
 120         if (ret != 1)
 121                 return -EREMOTEIO;
 122
 123         return 0;
 124 }
 125
 126 static int
 127 usbvision_i2c_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num)
 128 {
 129         struct i2c_msg *pmsg;
 130         struct usb_usbvision *usbvision;
 131         int i, ret;
 132         unsigned char addr = 0;
 133
 134         usbvision = (struct usb_usbvision *)i2c_get_adapdata(i2c_adap);
 135
 136         for (i = 0; i < num; i++) {
 137                 pmsg = &msgs[i];
 138                 ret = usb_find_address(i2c_adap, pmsg, i2c_adap->retries, &addr);
 139                 if (ret != 0) {
 140                         PDEBUG(DBG_I2C, "got NAK from device, message #%d", i);
 141                         return (ret < 0) ? ret : -EREMOTEIO;
 142                 }
 143
 144                 if (pmsg->flags & I2C_M_RD) {
 145                         /* read bytes into buffer */
 146                         ret = (usbvision_i2c_read(usbvision, addr, pmsg->buf, pmsg->len));
 147                         if (ret < pmsg->len)
 148                                 return (ret < 0) ? ret : -EREMOTEIO;
 149                 } else {
 150                         /* write bytes from buffer */
 151                         ret = (usbvision_i2c_write(usbvision, addr, pmsg->buf, pmsg->len));
 152                         if (ret < pmsg->len)
 153                                 return (ret < 0) ? ret : -EREMOTEIO;
 154                 }
 155         }
 156         return num;
 157 }
 158
 159 static u32 functionality(struct i2c_adapter *adap)
 160 {
 161         return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 162 }
 163
 164 /* -----exported algorithm data: -------------------------------------  */
 165
 166 static const struct i2c_algorithm usbvision_algo = {
 167         .master_xfer   = usbvision_i2c_xfer,
 168         .smbus_xfer    = NULL,
 169         .functionality = functionality,
 170 };
 171
 172
 173 /* ----------------------------------------------------------------------- */
 174 /* usbvision specific I2C functions                                        */
 175 /* ----------------------------------------------------------------------- */
 176 static const struct i2c_adapter i2c_adap_template;
 177
 178 int usbvision_i2c_register(struct usb_usbvision *usbvision)
 179 {
 180         static unsigned short saa711x_addrs[] = {
 181                 0x4a >> 1, 0x48 >> 1,   /* SAA7111, SAA7111A and SAA7113 */
 182                 0x42 >> 1, 0x40 >> 1,   /* SAA7114, SAA7115 and SAA7118 */
 183                 I2C_CLIENT_END };
 184
 185         if (usbvision->registered_i2c)
 186                 return 0;
 187
 188         usbvision->i2c_adap = i2c_adap_template;
 189
 190         snprintf(usbvision->i2c_adap.name, sizeof(usbvision->i2c_adap.name),
 191                  "usbvision-%d-%s",
 192                  usbvision->dev->bus->busnum, usbvision->dev->devpath);
 193         PDEBUG(DBG_I2C, "Adaptername: %s", usbvision->i2c_adap.name);
 194         usbvision->i2c_adap.dev.parent = &usbvision->dev->dev;
 195
 196         i2c_set_adapdata(&usbvision->i2c_adap, &usbvision->v4l2_dev);
 197
 198         if (usbvision_write_reg(usbvision, USBVISION_SER_MODE, USBVISION_IIC_LRNACK) < 0) {
 199                 printk(KERN_ERR "usbvision_i2c_register: can't write reg\n");
 200                 return -EBUSY;
 201         }
 202
 203         PDEBUG(DBG_I2C, "I2C   debugging is enabled [i2c]");
 204         PDEBUG(DBG_I2C, "ALGO   debugging is enabled [i2c]");
 205
 206         /* register new adapter to i2c module... */
 207
 208         usbvision->i2c_adap.algo = &usbvision_algo;
 209
 210         usbvision->i2c_adap.timeout = 100;      /* default values, should       */
 211         usbvision->i2c_adap.retries = 3;        /* be replaced by defines       */
 212
 213         i2c_add_adapter(&usbvision->i2c_adap);
 214
 215         PDEBUG(DBG_I2C, "i2c bus for %s registered", usbvision->i2c_adap.name);
 216
 217         /* Request the load of the i2c modules we need */
 218         switch (usbvision_device_data[usbvision->dev_model].codec) {
 219         case CODEC_SAA7113:
 220         case CODEC_SAA7111:
 221                 /* Without this delay the detection of the saa711x is
 222                    hit-and-miss. */
 223                 mdelay(10);
 224                 v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
 225                                 &usbvision->i2c_adap,
 226                                 "saa7115_auto", 0, saa711x_addrs);
 227                 break;
 228         }
 229         if (usbvision_device_data[usbvision->dev_model].tuner == 1) {
 230                 struct v4l2_subdev *sd;
 231                 enum v4l2_i2c_tuner_type type;
 232                 struct tuner_setup tun_setup;
 233
 234                 sd = v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
 235                                 &usbvision->i2c_adap,
 236                                 "tuner", 0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
 237                 /* depending on whether we found a demod or not, select
 238                    the tuner type. */
 239                 type = sd ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
 240
 241                 sd = v4l2_i2c_new_subdev(&usbvision->v4l2_dev,
 242                                 &usbvision->i2c_adap,
 243                                 "tuner", 0, v4l2_i2c_tuner_addrs(type));
 244
 245                 if (sd == NULL)
 246                         return -ENODEV;
 247                 if (usbvision->tuner_type != -1) {
 248                         tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
 249                         tun_setup.type = usbvision->tuner_type;
 250                         tun_setup.addr = v4l2_i2c_subdev_addr(sd);
 251                         call_all(usbvision, tuner, s_type_addr, &tun_setup);
 252                 }
 253         }
 254         usbvision->registered_i2c = 1;
 255
 256         return 0;
 257 }
 258
 259 int usbvision_i2c_unregister(struct usb_usbvision *usbvision)
 260 {
 261         if (!usbvision->registered_i2c)
 262                 return 0;
 263
 264         i2c_del_adapter(&(usbvision->i2c_adap));
 265         usbvision->registered_i2c = 0;
 266
 267         PDEBUG(DBG_I2C, "i2c bus for %s unregistered", usbvision->i2c_adap.name);
 268
 269         return 0;
 270 }
 271
 272 static int
 273 usbvision_i2c_read_max4(struct usb_usbvision *usbvision, unsigned char addr,
 274                      char *buf, short len)
 275 {
 276         int rc, retries;
 277
 278         for (retries = 5;;) {
 279                 rc = usbvision_write_reg(usbvision, USBVISION_SER_ADRS, addr);
 280                 if (rc < 0)
 281                         return rc;
 282
 283                 /* Initiate byte read cycle                    */
 284                 /* USBVISION_SER_CONT <- d0-d2 n. of bytes to r/w */
 285                 /*                    d3 0=Wr 1=Rd             */
 286                 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT,
 287                                       (len & 0x07) | 0x18);
 288                 if (rc < 0)
 289                         return rc;
 290
 291                 /* Test for Busy and ACK */
 292                 do {
 293                         /* USBVISION_SER_CONT -> d4 == 0 busy */
 294                         rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT);
 295                 } while (rc > 0 && ((rc & 0x10) != 0)); /* Retry while busy */
 296                 if (rc < 0)
 297                         return rc;
 298
 299                 /* USBVISION_SER_CONT -> d5 == 1 Not ack */
 300                 if ((rc & 0x20) == 0)   /* Ack? */
 301                         break;
 302
 303                 /* I2C abort */
 304                 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00);
 305                 if (rc < 0)
 306                         return rc;
 307
 308                 if (--retries < 0)
 309                         return -1;
 310         }
 311
 312         switch (len) {
 313         case 4:
 314                 buf[3] = usbvision_read_reg(usbvision, USBVISION_SER_DAT4);
 315                 /* fall through */
 316         case 3:
 317                 buf[2] = usbvision_read_reg(usbvision, USBVISION_SER_DAT3);
 318                 /* fall through */
 319         case 2:
 320                 buf[1] = usbvision_read_reg(usbvision, USBVISION_SER_DAT2);
 321                 /* fall through */
 322         case 1:
 323                 buf[0] = usbvision_read_reg(usbvision, USBVISION_SER_DAT1);
 324                 break;
 325         default:
 326                 printk(KERN_ERR
 327                        "usbvision_i2c_read_max4: buffer length > 4\n");
 328         }
 329
 330         if (i2c_debug & DBG_I2C) {
 331                 int idx;
 332
 333                 for (idx = 0; idx < len; idx++)
 334                         PDEBUG(DBG_I2C, "read %x from address %x", (unsigned char)buf[idx], addr);
 335         }
 336         return len;
 337 }
 338
 339
 340 static int usbvision_i2c_write_max4(struct usb_usbvision *usbvision,
 341                                  unsigned char addr, const char *buf,
 342                                  short len)
 343 {
 344         int rc, retries;
 345         int i;
 346         unsigned char *value = usbvision->ctrl_urb_buffer;
 347         unsigned char ser_cont;
 348
 349         ser_cont = (len & 0x07) | 0x10;
 350
 351         value[0] = addr;
 352         value[1] = ser_cont;
 353         for (i = 0; i < len; i++)
 354                 value[i + 2] = buf[i];
 355
 356         for (retries = 5;;) {
 357                 rc = usb_control_msg(usbvision->dev,
 358                                      usb_sndctrlpipe(usbvision->dev, 1),
 359                                      USBVISION_OP_CODE,
 360                                      USB_DIR_OUT | USB_TYPE_VENDOR |
 361                                      USB_RECIP_ENDPOINT, 0,
 362                                      (__u16) USBVISION_SER_ADRS, value,
 363                                      len + 2, HZ);
 364
 365                 if (rc < 0)
 366                         return rc;
 367
 368                 rc = usbvision_write_reg(usbvision, USBVISION_SER_CONT,
 369                                       (len & 0x07) | 0x10);
 370                 if (rc < 0)
 371                         return rc;
 372
 373                 /* Test for Busy and ACK */
 374                 do {
 375                         rc = usbvision_read_reg(usbvision, USBVISION_SER_CONT);
 376                 } while (rc > 0 && ((rc & 0x10) != 0)); /* Retry while busy */
 377                 if (rc < 0)
 378                         return rc;
 379
 380                 if ((rc & 0x20) == 0)   /* Ack? */
 381                         break;
 382
 383                 /* I2C abort */
 384                 usbvision_write_reg(usbvision, USBVISION_SER_CONT, 0x00);
 385
 386                 if (--retries < 0)
 387                         return -1;
 388
 389         }
 390
 391         if (i2c_debug & DBG_I2C) {
 392                 int idx;
 393
 394                 for (idx = 0; idx < len; idx++)
 395                         PDEBUG(DBG_I2C, "wrote %x at address %x", (unsigned char)buf[idx], addr);
 396         }
 397         return len;
 398 }
 399
 400 static int usbvision_i2c_write(struct usb_usbvision *usbvision, unsigned char addr, char *buf,
 401                             short len)
 402 {
 403         char *buf_ptr = buf;
 404         int retval;
 405         int wrcount = 0;
 406         int count;
 407         int max_len = 4;
 408
 409         while (len > 0) {
 410                 count = (len > max_len) ? max_len : len;
 411                 retval = usbvision_i2c_write_max4(usbvision, addr, buf_ptr, count);
 412                 if (retval > 0) {
 413                         len -= count;
 414                         buf_ptr += count;
 415                         wrcount += count;
 416                 } else
 417                         return (retval < 0) ? retval : -EFAULT;
 418         }
 419         return wrcount;
 420 }
 421
 422 static int usbvision_i2c_read(struct usb_usbvision *usbvision, unsigned char addr, char *buf,
 423                            short len)
 424 {
 425         char temp[4];
 426         int retval, i;
 427         int rdcount = 0;
 428         int count;
 429
 430         while (len > 0) {
 431                 count = (len > 3) ? 4 : len;
 432                 retval = usbvision_i2c_read_max4(usbvision, addr, temp, count);
 433                 if (retval > 0) {
 434                         for (i = 0; i < len; i++)
 435                                 buf[rdcount + i] = temp[i];
 436                         len -= count;
 437                         rdcount += count;
 438                 } else
 439                         return (retval < 0) ? retval : -EFAULT;
 440         }
 441         return rdcount;
 442 }
 443
 444 static const struct i2c_adapter i2c_adap_template = {
 445         .owner = THIS_MODULE,
 446         .name              = "usbvision",
 447 };