root/drivers/media/usb/cx231xx/cx231xx-i2c.c

DEFINITIONS

1. get_real_i2c_port
2. is_tuner
3. cx231xx_i2c_send_bytes
4. cx231xx_i2c_recv_bytes
5. cx231xx_i2c_recv_bytes_with_saddr
6. cx231xx_i2c_check_for_device
7. cx231xx_i2c_xfer
8. functionality
9. cx231xx_do_i2c_scan
10. cx231xx_i2c_register
11. cx231xx_i2c_unregister
12. cx231xx_i2c_mux_select
13. cx231xx_i2c_mux_create
14. cx231xx_i2c_mux_register
15. cx231xx_i2c_mux_unregister
16. cx231xx_get_i2c_adap

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3    cx231xx-i2c.c - driver for Conexant Cx23100/101/102 USB video capture devices
   4 
   5    Copyright (C) 2008 <srinivasa.deevi at conexant dot com>
   6                 Based on em28xx driver
   7                 Based on Cx23885 driver
   8 
   9  */
  10 
  11 #include "cx231xx.h"
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/i2c.h>
  15 #include <linux/i2c-mux.h>
  16 #include <media/v4l2-common.h>
  17 #include <media/tuner.h>
  18 
  19 
  20 /* ----------------------------------------------------------- */
  21 
  22 static unsigned int i2c_scan;
  23 module_param(i2c_scan, int, 0444);
  24 MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
  25 
  26 static unsigned int i2c_debug;
  27 module_param(i2c_debug, int, 0644);
  28 MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
  29 
  30 #define dprintk1(lvl, fmt, args...)                     \
  31 do {                                                    \
  32         if (i2c_debug >= lvl) {                         \
  33                 printk(fmt, ##args);                    \
  34                 }                                       \
  35 } while (0)
  36 
  37 #define dprintk2(lvl, fmt, args...)                     \
  38 do {                                                    \
  39         if (i2c_debug >= lvl) {                         \
  40                 printk(KERN_DEBUG "%s at %s: " fmt,     \
  41                        dev->name, __func__ , ##args);   \
  42       }                                                 \
  43 } while (0)
  44 
  45 static inline int get_real_i2c_port(struct cx231xx *dev, int bus_nr)
  46 {
  47         if (bus_nr == 1)
  48                 return dev->port_3_switch_enabled ? I2C_1_MUX_3 : I2C_1_MUX_1;
  49         return bus_nr;
  50 }
  51 
  52 static inline bool is_tuner(struct cx231xx *dev, struct cx231xx_i2c *bus,
  53                         const struct i2c_msg *msg, int tuner_type)
  54 {
  55         int i2c_port = get_real_i2c_port(dev, bus->nr);
  56 
  57         if (i2c_port != dev->board.tuner_i2c_master)
  58                 return false;
  59 
  60         if (msg->addr != dev->board.tuner_addr)
  61                 return false;
  62 
  63         if (dev->tuner_type != tuner_type)
  64                 return false;
  65 
  66         return true;
  67 }
  68 
  69 /*
  70  * cx231xx_i2c_send_bytes()
  71  */
  72 static int cx231xx_i2c_send_bytes(struct i2c_adapter *i2c_adap,
  73                                   const struct i2c_msg *msg)
  74 {
  75         struct cx231xx_i2c *bus = i2c_adap->algo_data;
  76         struct cx231xx *dev = bus->dev;
  77         struct cx231xx_i2c_xfer_data req_data;
  78         int status = 0;
  79         u16 size = 0;
  80         u8 loop = 0;
  81         u8 saddr_len = 1;
  82         u8 *buf_ptr = NULL;
  83         u16 saddr = 0;
  84         u8 need_gpio = 0;
  85 
  86         if (is_tuner(dev, bus, msg, TUNER_XC5000)) {
  87                 size = msg->len;
  88 
  89                 if (size == 2) {        /* register write sub addr */
  90                         /* Just writing sub address will cause problem
  91                         * to XC5000. So ignore the request */
  92                         return 0;
  93                 } else if (size == 4) { /* register write with sub addr */
  94                         if (msg->len >= 2)
  95                                 saddr = msg->buf[0] << 8 | msg->buf[1];
  96                         else if (msg->len == 1)
  97                                 saddr = msg->buf[0];
  98 
  99                         switch (saddr) {
 100                         case 0x0000:    /* start tuner calibration mode */
 101                                 need_gpio = 1;
 102                                 /* FW Loading is done */
 103                                 dev->xc_fw_load_done = 1;
 104                                 break;
 105                         case 0x000D:    /* Set signal source */
 106                         case 0x0001:    /* Set TV standard - Video */
 107                         case 0x0002:    /* Set TV standard - Audio */
 108                         case 0x0003:    /* Set RF Frequency */
 109                                 need_gpio = 1;
 110                                 break;
 111                         default:
 112                                 if (dev->xc_fw_load_done)
 113                                         need_gpio = 1;
 114                                 break;
 115                         }
 116 
 117                         if (need_gpio) {
 118                                 dprintk1(1,
 119                                 "GPIO WRITE: addr 0x%x, len %d, saddr 0x%x\n",
 120                                 msg->addr, msg->len, saddr);
 121 
 122                                 return dev->cx231xx_gpio_i2c_write(dev,
 123                                                                    msg->addr,
 124                                                                    msg->buf,
 125                                                                    msg->len);
 126                         }
 127                 }
 128 
 129                 /* special case for Xc5000 tuner case */
 130                 saddr_len = 1;
 131 
 132                 /* adjust the length to correct length */
 133                 size -= saddr_len;
 134                 buf_ptr = (u8 *) (msg->buf + 1);
 135 
 136                 do {
 137                         /* prepare xfer_data struct */
 138                         req_data.dev_addr = msg->addr;
 139                         req_data.direction = msg->flags;
 140                         req_data.saddr_len = saddr_len;
 141                         req_data.saddr_dat = msg->buf[0];
 142                         req_data.buf_size = size > 16 ? 16 : size;
 143                         req_data.p_buffer = (u8 *) (buf_ptr + loop * 16);
 144 
 145                         bus->i2c_nostop = (size > 16) ? 1 : 0;
 146                         bus->i2c_reserve = (loop == 0) ? 0 : 1;
 147 
 148                         /* usb send command */
 149                         status = dev->cx231xx_send_usb_command(bus, &req_data);
 150                         loop++;
 151 
 152                         if (size >= 16)
 153                                 size -= 16;
 154                         else
 155                                 size = 0;
 156 
 157                 } while (size > 0);
 158 
 159                 bus->i2c_nostop = 0;
 160                 bus->i2c_reserve = 0;
 161 
 162         } else {                /* regular case */
 163 
 164                 /* prepare xfer_data struct */
 165                 req_data.dev_addr = msg->addr;
 166                 req_data.direction = msg->flags;
 167                 req_data.saddr_len = 0;
 168                 req_data.saddr_dat = 0;
 169                 req_data.buf_size = msg->len;
 170                 req_data.p_buffer = msg->buf;
 171 
 172                 /* usb send command */
 173                 status = dev->cx231xx_send_usb_command(bus, &req_data);
 174         }
 175 
 176         return status < 0 ? status : 0;
 177 }
 178 
 179 /*
 180  * cx231xx_i2c_recv_bytes()
 181  * read a byte from the i2c device
 182  */
 183 static int cx231xx_i2c_recv_bytes(struct i2c_adapter *i2c_adap,
 184                                   const struct i2c_msg *msg)
 185 {
 186         struct cx231xx_i2c *bus = i2c_adap->algo_data;
 187         struct cx231xx *dev = bus->dev;
 188         struct cx231xx_i2c_xfer_data req_data;
 189         int status = 0;
 190         u16 saddr = 0;
 191         u8 need_gpio = 0;
 192 
 193         if (is_tuner(dev, bus, msg, TUNER_XC5000)) {
 194                 if (msg->len == 2)
 195                         saddr = msg->buf[0] << 8 | msg->buf[1];
 196                 else if (msg->len == 1)
 197                         saddr = msg->buf[0];
 198 
 199                 if (dev->xc_fw_load_done) {
 200 
 201                         switch (saddr) {
 202                         case 0x0009:    /* BUSY check */
 203                                 dprintk1(1,
 204                                 "GPIO R E A D: Special case BUSY check \n");
 205                                 /*Try read BUSY register, just set it to zero*/
 206                                 msg->buf[0] = 0;
 207                                 if (msg->len == 2)
 208                                         msg->buf[1] = 0;
 209                                 return 0;
 210                         case 0x0004:    /* read Lock status */
 211                                 need_gpio = 1;
 212                                 break;
 213 
 214                         }
 215 
 216                         if (need_gpio) {
 217                                 /* this is a special case to handle Xceive tuner
 218                                 clock stretch issue with gpio based I2C */
 219 
 220                                 dprintk1(1,
 221                                 "GPIO R E A D: addr 0x%x, len %d, saddr 0x%x\n",
 222                                 msg->addr, msg->len,
 223                                 msg->buf[0] << 8 | msg->buf[1]);
 224 
 225                                 status =
 226                                     dev->cx231xx_gpio_i2c_write(dev, msg->addr,
 227                                                                 msg->buf,
 228                                                                 msg->len);
 229                                 status =
 230                                     dev->cx231xx_gpio_i2c_read(dev, msg->addr,
 231                                                                msg->buf,
 232                                                                msg->len);
 233                                 return status;
 234                         }
 235                 }
 236 
 237                 /* prepare xfer_data struct */
 238                 req_data.dev_addr = msg->addr;
 239                 req_data.direction = msg->flags;
 240                 req_data.saddr_len = msg->len;
 241                 req_data.saddr_dat = msg->buf[0] << 8 | msg->buf[1];
 242                 req_data.buf_size = msg->len;
 243                 req_data.p_buffer = msg->buf;
 244 
 245                 /* usb send command */
 246                 status = dev->cx231xx_send_usb_command(bus, &req_data);
 247 
 248         } else {
 249 
 250                 /* prepare xfer_data struct */
 251                 req_data.dev_addr = msg->addr;
 252                 req_data.direction = msg->flags;
 253                 req_data.saddr_len = 0;
 254                 req_data.saddr_dat = 0;
 255                 req_data.buf_size = msg->len;
 256                 req_data.p_buffer = msg->buf;
 257 
 258                 /* usb send command */
 259                 status = dev->cx231xx_send_usb_command(bus, &req_data);
 260         }
 261 
 262         return status < 0 ? status : 0;
 263 }
 264 
 265 /*
 266  * cx231xx_i2c_recv_bytes_with_saddr()
 267  * read a byte from the i2c device
 268  */
 269 static int cx231xx_i2c_recv_bytes_with_saddr(struct i2c_adapter *i2c_adap,
 270                                              const struct i2c_msg *msg1,
 271                                              const struct i2c_msg *msg2)
 272 {
 273         struct cx231xx_i2c *bus = i2c_adap->algo_data;
 274         struct cx231xx *dev = bus->dev;
 275         struct cx231xx_i2c_xfer_data req_data;
 276         int status = 0;
 277         u16 saddr = 0;
 278         u8 need_gpio = 0;
 279 
 280         if (msg1->len == 2)
 281                 saddr = msg1->buf[0] << 8 | msg1->buf[1];
 282         else if (msg1->len == 1)
 283                 saddr = msg1->buf[0];
 284 
 285         if (is_tuner(dev, bus, msg2, TUNER_XC5000)) {
 286                 if ((msg2->len < 16)) {
 287 
 288                         dprintk1(1,
 289                         "i2c_read: addr 0x%x, len %d, saddr 0x%x, len %d\n",
 290                         msg2->addr, msg2->len, saddr, msg1->len);
 291 
 292                         switch (saddr) {
 293                         case 0x0008:    /* read FW load status */
 294                                 need_gpio = 1;
 295                                 break;
 296                         case 0x0004:    /* read Lock status */
 297                                 need_gpio = 1;
 298                                 break;
 299                         }
 300 
 301                         if (need_gpio) {
 302                                 status =
 303                                     dev->cx231xx_gpio_i2c_write(dev, msg1->addr,
 304                                                                 msg1->buf,
 305                                                                 msg1->len);
 306                                 status =
 307                                     dev->cx231xx_gpio_i2c_read(dev, msg2->addr,
 308                                                                msg2->buf,
 309                                                                msg2->len);
 310                                 return status;
 311                         }
 312                 }
 313         }
 314 
 315         /* prepare xfer_data struct */
 316         req_data.dev_addr = msg2->addr;
 317         req_data.direction = msg2->flags;
 318         req_data.saddr_len = msg1->len;
 319         req_data.saddr_dat = saddr;
 320         req_data.buf_size = msg2->len;
 321         req_data.p_buffer = msg2->buf;
 322 
 323         /* usb send command */
 324         status = dev->cx231xx_send_usb_command(bus, &req_data);
 325 
 326         return status < 0 ? status : 0;
 327 }
 328 
 329 /*
 330  * cx231xx_i2c_check_for_device()
 331  * check if there is a i2c_device at the supplied address
 332  */
 333 static int cx231xx_i2c_check_for_device(struct i2c_adapter *i2c_adap,
 334                                         const struct i2c_msg *msg)
 335 {
 336         struct cx231xx_i2c *bus = i2c_adap->algo_data;
 337         struct cx231xx *dev = bus->dev;
 338         struct cx231xx_i2c_xfer_data req_data;
 339         int status = 0;
 340         u8 buf[1];
 341 
 342         /* prepare xfer_data struct */
 343         req_data.dev_addr = msg->addr;
 344         req_data.direction = I2C_M_RD;
 345         req_data.saddr_len = 0;
 346         req_data.saddr_dat = 0;
 347         req_data.buf_size = 1;
 348         req_data.p_buffer = buf;
 349 
 350         /* usb send command */
 351         status = dev->cx231xx_send_usb_command(bus, &req_data);
 352 
 353         return status < 0 ? status : 0;
 354 }
 355 
 356 /*
 357  * cx231xx_i2c_xfer()
 358  * the main i2c transfer function
 359  */
 360 static int cx231xx_i2c_xfer(struct i2c_adapter *i2c_adap,
 361                             struct i2c_msg msgs[], int num)
 362 {
 363         struct cx231xx_i2c *bus = i2c_adap->algo_data;
 364         struct cx231xx *dev = bus->dev;
 365         int addr, rc, i, byte;
 366 
 367         mutex_lock(&dev->i2c_lock);
 368         for (i = 0; i < num; i++) {
 369 
 370                 addr = msgs[i].addr;
 371 
 372                 dprintk2(2, "%s %s addr=0x%x len=%d:",
 373                          (msgs[i].flags & I2C_M_RD) ? "read" : "write",
 374                          i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
 375                 if (!msgs[i].len) {
 376                         /* no len: check only for device presence */
 377                         rc = cx231xx_i2c_check_for_device(i2c_adap, &msgs[i]);
 378                         if (rc < 0) {
 379                                 dprintk2(2, " no device\n");
 380                                 mutex_unlock(&dev->i2c_lock);
 381                                 return rc;
 382                         }
 383 
 384                 } else if (msgs[i].flags & I2C_M_RD) {
 385                         /* read bytes */
 386                         rc = cx231xx_i2c_recv_bytes(i2c_adap, &msgs[i]);
 387                         if (i2c_debug >= 2) {
 388                                 for (byte = 0; byte < msgs[i].len; byte++)
 389                                         printk(KERN_CONT " %02x", msgs[i].buf[byte]);
 390                         }
 391                 } else if (i + 1 < num && (msgs[i + 1].flags & I2C_M_RD) &&
 392                            msgs[i].addr == msgs[i + 1].addr
 393                            && (msgs[i].len <= 2) && (bus->nr < 3)) {
 394                         /* write bytes */
 395                         if (i2c_debug >= 2) {
 396                                 for (byte = 0; byte < msgs[i].len; byte++)
 397                                         printk(KERN_CONT " %02x", msgs[i].buf[byte]);
 398                                 printk(KERN_CONT "\n");
 399                         }
 400                         /* read bytes */
 401                         dprintk2(2, "plus %s %s addr=0x%x len=%d:",
 402                                 (msgs[i+1].flags & I2C_M_RD) ? "read" : "write",
 403                                 i+1 == num - 1 ? "stop" : "nonstop", addr, msgs[i+1].len);
 404                         rc = cx231xx_i2c_recv_bytes_with_saddr(i2c_adap,
 405                                                                &msgs[i],
 406                                                                &msgs[i + 1]);
 407                         if (i2c_debug >= 2) {
 408                                 for (byte = 0; byte < msgs[i+1].len; byte++)
 409                                         printk(KERN_CONT " %02x", msgs[i+1].buf[byte]);
 410                         }
 411                         i++;
 412                 } else {
 413                         /* write bytes */
 414                         if (i2c_debug >= 2) {
 415                                 for (byte = 0; byte < msgs[i].len; byte++)
 416                                         printk(KERN_CONT " %02x", msgs[i].buf[byte]);
 417                         }
 418                         rc = cx231xx_i2c_send_bytes(i2c_adap, &msgs[i]);
 419                 }
 420                 if (rc < 0)
 421                         goto err;
 422                 if (i2c_debug >= 2)
 423                         printk(KERN_CONT "\n");
 424         }
 425         mutex_unlock(&dev->i2c_lock);
 426         return num;
 427 err:
 428         dprintk2(2, " ERROR: %i\n", rc);
 429         mutex_unlock(&dev->i2c_lock);
 430         return rc;
 431 }
 432 
 433 /* ----------------------------------------------------------- */
 434 
 435 /*
 436  * functionality()
 437  */
 438 static u32 functionality(struct i2c_adapter *adap)
 439 {
 440         return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C;
 441 }
 442 
 443 static const struct i2c_algorithm cx231xx_algo = {
 444         .master_xfer = cx231xx_i2c_xfer,
 445         .functionality = functionality,
 446 };
 447 
 448 static const struct i2c_adapter cx231xx_adap_template = {
 449         .owner = THIS_MODULE,
 450         .name = "cx231xx",
 451         .algo = &cx231xx_algo,
 452 };
 453 
 454 /* ----------------------------------------------------------- */
 455 
 456 /*
 457  * i2c_devs
 458  * incomplete list of known devices
 459  */
 460 static const char *i2c_devs[128] = {
 461         [0x20 >> 1] = "demod",
 462         [0x60 >> 1] = "colibri",
 463         [0x88 >> 1] = "hammerhead",
 464         [0x8e >> 1] = "CIR",
 465         [0x32 >> 1] = "GeminiIII",
 466         [0x02 >> 1] = "Aquarius",
 467         [0xa0 >> 1] = "eeprom",
 468         [0xc0 >> 1] = "tuner",
 469         [0xc2 >> 1] = "tuner",
 470 };
 471 
 472 /*
 473  * cx231xx_do_i2c_scan()
 474  * check i2c address range for devices
 475  */
 476 void cx231xx_do_i2c_scan(struct cx231xx *dev, int i2c_port)
 477 {
 478         unsigned char buf;
 479         int i, rc;
 480         struct i2c_adapter *adap;
 481         struct i2c_msg msg = {
 482                 .flags = I2C_M_RD,
 483                 .len = 1,
 484                 .buf = &buf,
 485         };
 486 
 487         if (!i2c_scan)
 488                 return;
 489 
 490         /* Don't generate I2C errors during scan */
 491         dev->i2c_scan_running = true;
 492         adap = cx231xx_get_i2c_adap(dev, i2c_port);
 493 
 494         for (i = 0; i < 128; i++) {
 495                 msg.addr = i;
 496                 rc = i2c_transfer(adap, &msg, 1);
 497 
 498                 if (rc < 0)
 499                         continue;
 500                 dev_info(dev->dev,
 501                          "i2c scan: found device @ port %d addr 0x%x  [%s]\n",
 502                          i2c_port,
 503                          i << 1,
 504                          i2c_devs[i] ? i2c_devs[i] : "???");
 505         }
 506 
 507         dev->i2c_scan_running = false;
 508 }
 509 
 510 /*
 511  * cx231xx_i2c_register()
 512  * register i2c bus
 513  */
 514 int cx231xx_i2c_register(struct cx231xx_i2c *bus)
 515 {
 516         struct cx231xx *dev = bus->dev;
 517 
 518         BUG_ON(!dev->cx231xx_send_usb_command);
 519 
 520         bus->i2c_adap = cx231xx_adap_template;
 521         bus->i2c_adap.dev.parent = dev->dev;
 522 
 523         snprintf(bus->i2c_adap.name, sizeof(bus->i2c_adap.name), "%s-%d", bus->dev->name, bus->nr);
 524 
 525         bus->i2c_adap.algo_data = bus;
 526         i2c_set_adapdata(&bus->i2c_adap, &dev->v4l2_dev);
 527         bus->i2c_rc = i2c_add_adapter(&bus->i2c_adap);
 528 
 529         if (0 != bus->i2c_rc)
 530                 dev_warn(dev->dev,
 531                          "i2c bus %d register FAILED\n", bus->nr);
 532 
 533         return bus->i2c_rc;
 534 }
 535 
 536 /*
 537  * cx231xx_i2c_unregister()
 538  * unregister i2c_bus
 539  */
 540 void cx231xx_i2c_unregister(struct cx231xx_i2c *bus)
 541 {
 542         if (!bus->i2c_rc)
 543                 i2c_del_adapter(&bus->i2c_adap);
 544 }
 545 
 546 /*
 547  * cx231xx_i2c_mux_select()
 548  * switch i2c master number 1 between port1 and port3
 549  */
 550 static int cx231xx_i2c_mux_select(struct i2c_mux_core *muxc, u32 chan_id)
 551 {
 552         struct cx231xx *dev = i2c_mux_priv(muxc);
 553 
 554         return cx231xx_enable_i2c_port_3(dev, chan_id);
 555 }
 556 
 557 int cx231xx_i2c_mux_create(struct cx231xx *dev)
 558 {
 559         dev->muxc = i2c_mux_alloc(&dev->i2c_bus[1].i2c_adap, dev->dev, 2, 0, 0,
 560                                   cx231xx_i2c_mux_select, NULL);
 561         if (!dev->muxc)
 562                 return -ENOMEM;
 563         dev->muxc->priv = dev;
 564         return 0;
 565 }
 566 
 567 int cx231xx_i2c_mux_register(struct cx231xx *dev, int mux_no)
 568 {
 569         return i2c_mux_add_adapter(dev->muxc,
 570                                    0,
 571                                    mux_no /* chan_id */,
 572                                    0 /* class */);
 573 }
 574 
 575 void cx231xx_i2c_mux_unregister(struct cx231xx *dev)
 576 {
 577         i2c_mux_del_adapters(dev->muxc);
 578 }
 579 
 580 struct i2c_adapter *cx231xx_get_i2c_adap(struct cx231xx *dev, int i2c_port)
 581 {
 582         switch (i2c_port) {
 583         case I2C_0:
 584                 return &dev->i2c_bus[0].i2c_adap;
 585         case I2C_1:
 586                 return &dev->i2c_bus[1].i2c_adap;
 587         case I2C_2:
 588                 return &dev->i2c_bus[2].i2c_adap;
 589         case I2C_1_MUX_1:
 590                 return dev->muxc->adapter[0];
 591         case I2C_1_MUX_3:
 592                 return dev->muxc->adapter[1];
 593         default:
 594                 BUG();
 595         }
 596 }
 597 EXPORT_SYMBOL_GPL(cx231xx_get_i2c_adap);