LXR linux/drivers/media/usb/em28xx/em28xx-camera.c

   1// SPDX-License-Identifier: GPL-2.0+
   2//
   3// em28xx-camera.c - driver for Empia EM25xx/27xx/28xx USB video capture devices
   4//
   5// Copyright (C) 2009 Mauro Carvalho Chehab <mchehab@kernel.org>
   6// Copyright (C) 2013 Frank Schäfer <fschaefer.oss@googlemail.com>
   7//
   8// This program is free software; you can redistribute it and/or modify
   9// it under the terms of the GNU General Public License as published by
  10// the Free Software Foundation; either version 2 of the License, or
  11// (at your option) any later version.
  12//
  13// This program is distributed in the hope that it will be useful,
  14// but WITHOUT ANY WARRANTY; without even the implied warranty of
  15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16// GNU General Public License for more details.
  17
  18#include "em28xx.h"
  19
  20#include <linux/i2c.h>
  21#include <linux/usb.h>
  22#include <media/i2c/mt9v011.h>
  23#include <media/v4l2-common.h>
  24
  25/* Possible i2c addresses of Micron sensors */
  26static unsigned short micron_sensor_addrs[] = {
  27        0xb8 >> 1,   /* MT9V111, MT9V403 */
  28        0xba >> 1,   /* MT9M001/011/111/112, MT9V011/012/112, MT9D011 */
  29        0x90 >> 1,   /* MT9V012/112, MT9D011 (alternative address) */
  30        I2C_CLIENT_END
  31};
  32
  33/* Possible i2c addresses of Omnivision sensors */
  34static unsigned short omnivision_sensor_addrs[] = {
  35        0x42 >> 1,   /* OV7725, OV7670/60/48 */
  36        0x60 >> 1,   /* OV2640, OV9650/53/55 */
  37        I2C_CLIENT_END
  38};
  39
  40/* FIXME: Should be replaced by a proper mt9m111 driver */
  41static int em28xx_initialize_mt9m111(struct em28xx *dev)
  42{
  43        int i;
  44        unsigned char regs[][3] = {
  45                { 0x0d, 0x00, 0x01, },  /* reset and use defaults */
  46                { 0x0d, 0x00, 0x00, },
  47                { 0x0a, 0x00, 0x21, },
  48                { 0x21, 0x04, 0x00, },  /* full readout spd, no row/col skip */
  49        };
  50
  51        for (i = 0; i < ARRAY_SIZE(regs); i++)
  52                i2c_master_send(&dev->i2c_client[dev->def_i2c_bus],
  53                                &regs[i][0], 3);
  54
  55        /* FIXME: This won't be creating a sensor at the media graph */
  56
  57        return 0;
  58}
  59
  60/* FIXME: Should be replaced by a proper mt9m001 driver */
  61static int em28xx_initialize_mt9m001(struct em28xx *dev)
  62{
  63        int i;
  64        unsigned char regs[][3] = {
  65                { 0x0d, 0x00, 0x01, },
  66                { 0x0d, 0x00, 0x00, },
  67                { 0x04, 0x05, 0x00, },  /* hres = 1280 */
  68                { 0x03, 0x04, 0x00, },  /* vres = 1024 */
  69                { 0x20, 0x11, 0x00, },
  70                { 0x06, 0x00, 0x10, },
  71                { 0x2b, 0x00, 0x24, },
  72                { 0x2e, 0x00, 0x24, },
  73                { 0x35, 0x00, 0x24, },
  74                { 0x2d, 0x00, 0x20, },
  75                { 0x2c, 0x00, 0x20, },
  76                { 0x09, 0x0a, 0xd4, },
  77                { 0x35, 0x00, 0x57, },
  78        };
  79
  80        for (i = 0; i < ARRAY_SIZE(regs); i++)
  81                i2c_master_send(&dev->i2c_client[dev->def_i2c_bus],
  82                                &regs[i][0], 3);
  83
  84        /* FIXME: This won't be creating a sensor at the media graph */
  85
  86        return 0;
  87}
  88
  89/*
  90 * Probes Micron sensors with 8 bit address and 16 bit register width
  91 */
  92static int em28xx_probe_sensor_micron(struct em28xx *dev)
  93{
  94        int ret, i;
  95        char *name;
  96        u16 id;
  97
  98        struct i2c_client *client = &dev->i2c_client[dev->def_i2c_bus];
  99
 100        dev->em28xx_sensor = EM28XX_NOSENSOR;
 101        for (i = 0; micron_sensor_addrs[i] != I2C_CLIENT_END; i++) {
 102                client->addr = micron_sensor_addrs[i];
 103                /* Read chip ID from register 0x00 */
 104                ret = i2c_smbus_read_word_data(client, 0x00); /* assumes LE */
 105                if (ret < 0) {
 106                        if (ret != -ENXIO)
 107                                dev_err(&dev->intf->dev,
 108                                        "couldn't read from i2c device 0x%02x: error %i\n",
 109                                       client->addr << 1, ret);
 110                        continue;
 111                }
 112                id = swab16(ret); /* LE -> BE */
 113                /* Read chip ID from register 0xff */
 114                ret = i2c_smbus_read_word_data(client, 0xff);
 115                if (ret < 0) {
 116                        dev_err(&dev->intf->dev,
 117                                "couldn't read from i2c device 0x%02x: error %i\n",
 118                                client->addr << 1, ret);
 119                        continue;
 120                }
 121                /* Validate chip ID to be sure we have a Micron device */
 122                if (id != swab16(ret))
 123                        continue;
 124                /* Check chip ID */
 125                switch (id) {
 126                case 0x1222:
 127                        name = "MT9V012"; /* MI370 */ /* 640x480 */
 128                        break;
 129                case 0x1229:
 130                        name = "MT9V112"; /* 640x480 */
 131                        break;
 132                case 0x1433:
 133                        name = "MT9M011"; /* 1280x1024 */
 134                        break;
 135                case 0x143a:    /* found in the ECS G200 */
 136                        name = "MT9M111"; /* MI1310 */ /* 1280x1024 */
 137                        dev->em28xx_sensor = EM28XX_MT9M111;
 138                        break;
 139                case 0x148c:
 140                        name = "MT9M112"; /* MI1320 */ /* 1280x1024 */
 141                        break;
 142                case 0x1511:
 143                        name = "MT9D011"; /* MI2010 */ /* 1600x1200 */
 144                        break;
 145                case 0x8232:
 146                case 0x8243:    /* rev B */
 147                        name = "MT9V011"; /* MI360 */ /* 640x480 */
 148                        dev->em28xx_sensor = EM28XX_MT9V011;
 149                        break;
 150                case 0x8431:
 151                        name = "MT9M001"; /* 1280x1024 */
 152                        dev->em28xx_sensor = EM28XX_MT9M001;
 153                        break;
 154                default:
 155                        dev_info(&dev->intf->dev,
 156                                 "unknown Micron sensor detected: 0x%04x\n",
 157                                 id);
 158                        return 0;
 159                }
 160
 161                if (dev->em28xx_sensor == EM28XX_NOSENSOR)
 162                        dev_info(&dev->intf->dev,
 163                                 "unsupported sensor detected: %s\n", name);
 164                else
 165                        dev_info(&dev->intf->dev,
 166                                 "sensor %s detected\n", name);
 167
 168                return 0;
 169        }
 170
 171        return -ENODEV;
 172}
 173
 174/*
 175 * Probes Omnivision sensors with 8 bit address and register width
 176 */
 177static int em28xx_probe_sensor_omnivision(struct em28xx *dev)
 178{
 179        int ret, i;
 180        char *name;
 181        u8 reg;
 182        u16 id;
 183        struct i2c_client *client = &dev->i2c_client[dev->def_i2c_bus];
 184
 185        dev->em28xx_sensor = EM28XX_NOSENSOR;
 186        /*
 187         * NOTE: these devices have the register auto incrementation disabled
 188         * by default, so we have to use single byte reads !
 189         */
 190        for (i = 0; omnivision_sensor_addrs[i] != I2C_CLIENT_END; i++) {
 191                client->addr = omnivision_sensor_addrs[i];
 192                /* Read manufacturer ID from registers 0x1c-0x1d (BE) */
 193                reg = 0x1c;
 194                ret = i2c_smbus_read_byte_data(client, reg);
 195                if (ret < 0) {
 196                        if (ret != -ENXIO)
 197                                dev_err(&dev->intf->dev,
 198                                        "couldn't read from i2c device 0x%02x: error %i\n",
 199                                        client->addr << 1, ret);
 200                        continue;
 201                }
 202                id = ret << 8;
 203                reg = 0x1d;
 204                ret = i2c_smbus_read_byte_data(client, reg);
 205                if (ret < 0) {
 206                        dev_err(&dev->intf->dev,
 207                                "couldn't read from i2c device 0x%02x: error %i\n",
 208                                client->addr << 1, ret);
 209                        continue;
 210                }
 211                id += ret;
 212                /* Check manufacturer ID */
 213                if (id != 0x7fa2)
 214                        continue;
 215                /* Read product ID from registers 0x0a-0x0b (BE) */
 216                reg = 0x0a;
 217                ret = i2c_smbus_read_byte_data(client, reg);
 218                if (ret < 0) {
 219                        dev_err(&dev->intf->dev,
 220                                "couldn't read from i2c device 0x%02x: error %i\n",
 221                                client->addr << 1, ret);
 222                        continue;
 223                }
 224                id = ret << 8;
 225                reg = 0x0b;
 226                ret = i2c_smbus_read_byte_data(client, reg);
 227                if (ret < 0) {
 228                        dev_err(&dev->intf->dev,
 229                                "couldn't read from i2c device 0x%02x: error %i\n",
 230                                client->addr << 1, ret);
 231                        continue;
 232                }
 233                id += ret;
 234                /* Check product ID */
 235                switch (id) {
 236                case 0x2642:
 237                        name = "OV2640";
 238                        dev->em28xx_sensor = EM28XX_OV2640;
 239                        break;
 240                case 0x7648:
 241                        name = "OV7648";
 242                        break;
 243                case 0x7660:
 244                        name = "OV7660";
 245                        break;
 246                case 0x7673:
 247                        name = "OV7670";
 248                        break;
 249                case 0x7720:
 250                        name = "OV7720";
 251                        break;
 252                case 0x7721:
 253                        name = "OV7725";
 254                        break;
 255                case 0x9648: /* Rev 2 */
 256                case 0x9649: /* Rev 3 */
 257                        name = "OV9640";
 258                        break;
 259                case 0x9650:
 260                case 0x9652: /* OV9653 */
 261                        name = "OV9650";
 262                        break;
 263                case 0x9656: /* Rev 4 */
 264                case 0x9657: /* Rev 5 */
 265                        name = "OV9655";
 266                        break;
 267                default:
 268                        dev_info(&dev->intf->dev,
 269                                 "unknown OmniVision sensor detected: 0x%04x\n",
 270                                id);
 271                        return 0;
 272                }
 273
 274                if (dev->em28xx_sensor == EM28XX_NOSENSOR)
 275                        dev_info(&dev->intf->dev,
 276                                 "unsupported sensor detected: %s\n", name);
 277                else
 278                        dev_info(&dev->intf->dev,
 279                                 "sensor %s detected\n", name);
 280
 281                return 0;
 282        }
 283
 284        return -ENODEV;
 285}
 286
 287int em28xx_detect_sensor(struct em28xx *dev)
 288{
 289        int ret;
 290
 291        ret = em28xx_probe_sensor_micron(dev);
 292
 293        if (dev->em28xx_sensor == EM28XX_NOSENSOR && ret < 0)
 294                ret = em28xx_probe_sensor_omnivision(dev);
 295
 296        /*
 297         * NOTE: the Windows driver also probes i2c addresses
 298         *       0x22 (Samsung ?) and 0x66 (Kodak ?)
 299         */
 300
 301        if (dev->em28xx_sensor == EM28XX_NOSENSOR && ret < 0) {
 302                dev_info(&dev->intf->dev,
 303                         "No sensor detected\n");
 304                return -ENODEV;
 305        }
 306
 307        return 0;
 308}
 309
 310int em28xx_init_camera(struct em28xx *dev)
 311{
 312        struct i2c_client *client = &dev->i2c_client[dev->def_i2c_bus];
 313        struct i2c_adapter *adap = &dev->i2c_adap[dev->def_i2c_bus];
 314        struct em28xx_v4l2 *v4l2 = dev->v4l2;
 315
 316        switch (dev->em28xx_sensor) {
 317        case EM28XX_MT9V011:
 318        {
 319                struct mt9v011_platform_data pdata;
 320                struct i2c_board_info mt9v011_info = {
 321                        .type = "mt9v011",
 322                        .addr = client->addr,
 323                        .platform_data = &pdata,
 324                };
 325
 326                v4l2->sensor_xres = 640;
 327                v4l2->sensor_yres = 480;
 328
 329                /*
 330                 * FIXME: mt9v011 uses I2S speed as xtal clk - at least with
 331                 * the Silvercrest cam I have here for testing - for higher
 332                 * resolutions, a high clock cause horizontal artifacts, so we
 333                 * need to use a lower xclk frequency.
 334                 * Yet, it would be possible to adjust xclk depending on the
 335                 * desired resolution, since this affects directly the
 336                 * frame rate.
 337                 */
 338                dev->board.xclk = EM28XX_XCLK_FREQUENCY_4_3MHZ;
 339                em28xx_write_reg(dev, EM28XX_R0F_XCLK, dev->board.xclk);
 340                v4l2->sensor_xtal = 4300000;
 341                pdata.xtal = v4l2->sensor_xtal;
 342                if (NULL ==
 343                    v4l2_i2c_new_subdev_board(&v4l2->v4l2_dev, adap,
 344                                              &mt9v011_info, NULL))
 345                        return -ENODEV;
 346                v4l2->vinmode = EM28XX_VINMODE_RGB8_GRBG;
 347                v4l2->vinctl = 0x00;
 348
 349                break;
 350        }
 351        case EM28XX_MT9M001:
 352                v4l2->sensor_xres = 1280;
 353                v4l2->sensor_yres = 1024;
 354
 355                em28xx_initialize_mt9m001(dev);
 356
 357                v4l2->vinmode = EM28XX_VINMODE_RGB8_BGGR;
 358                v4l2->vinctl = 0x00;
 359
 360                break;
 361        case EM28XX_MT9M111:
 362                v4l2->sensor_xres = 640;
 363                v4l2->sensor_yres = 512;
 364
 365                dev->board.xclk = EM28XX_XCLK_FREQUENCY_48MHZ;
 366                em28xx_write_reg(dev, EM28XX_R0F_XCLK, dev->board.xclk);
 367                em28xx_initialize_mt9m111(dev);
 368
 369                v4l2->vinmode = EM28XX_VINMODE_YUV422_UYVY;
 370                v4l2->vinctl = 0x00;
 371
 372                break;
 373        case EM28XX_OV2640:
 374        {
 375                struct v4l2_subdev *subdev;
 376                struct i2c_board_info ov2640_info = {
 377                        .type = "ov2640",
 378                        .flags = I2C_CLIENT_SCCB,
 379                        .addr = client->addr,
 380                };
 381                struct v4l2_subdev_format format = {
 382                        .which = V4L2_SUBDEV_FORMAT_ACTIVE,
 383                };
 384
 385                /*
 386                 * FIXME: sensor supports resolutions up to 1600x1200, but
 387                 * resolution setting/switching needs to be modified to
 388                 * - switch sensor output resolution (including further
 389                 *   configuration changes)
 390                 * - adjust bridge xclk
 391                 * - disable 16 bit (12 bit) output formats on high resolutions
 392                 */
 393                v4l2->sensor_xres = 640;
 394                v4l2->sensor_yres = 480;
 395
 396                subdev =
 397                     v4l2_i2c_new_subdev_board(&v4l2->v4l2_dev, adap,
 398                                               &ov2640_info, NULL);
 399                if (!subdev)
 400                        return -ENODEV;
 401
 402                format.format.code = MEDIA_BUS_FMT_YUYV8_2X8;
 403                format.format.width = 640;
 404                format.format.height = 480;
 405                v4l2_subdev_call(subdev, pad, set_fmt, NULL, &format);
 406
 407                /* NOTE: for UXGA=1600x1200 switch to 12MHz */
 408                dev->board.xclk = EM28XX_XCLK_FREQUENCY_24MHZ;
 409                em28xx_write_reg(dev, EM28XX_R0F_XCLK, dev->board.xclk);
 410                v4l2->vinmode = EM28XX_VINMODE_YUV422_YUYV;
 411                v4l2->vinctl = 0x00;
 412
 413                break;
 414        }
 415        case EM28XX_NOSENSOR:
 416        default:
 417                return -EINVAL;
 418        }
 419
 420        return 0;
 421}
 422EXPORT_SYMBOL_GPL(em28xx_init_camera);
 423