microdia-dev.c

   1 /**
   2  * @file microdia-dev.c
   3  * @author Nicolas VIVIEN
   4  * @date 2008-02-01
   5  *
   6  * @brief Device specific functions
   7  *
   8  * @note Copyright (C) Nicolas VIVIEN
   9  *
  10  * @par Licences
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  25  */
  26
  27 #include <linux/errno.h>
  28 #include <linux/string.h>
  29 #include <stdarg.h>
  30
  31 #include "microdia.h"
  32 #include "sn9c20x.h"
  33 #include "omnivision.h"
  34 #include "micron.h"
  35
  36 struct sensor_info sensors[] = {
  37         {
  38                 .id = OV9650_SENSOR,
  39                 .name = "OV9650",
  40                 .address = 0x30,
  41                 .probe = ov_probe
  42         },
  43         {
  44                 .id = OV9655_SENSOR,
  45                 .name = "OV9655",
  46                 .address = 0x30,
  47                 .probe = ov_probe
  48         },
  49         {
  50                 .id = SOI968_SENSOR,
  51                 .name = "SOI968",
  52                 .address = 0x30,
  53                 .probe = ov_probe
  54         },
  55         {
  56                 .id = OV7660_SENSOR,
  57                 .name = "OV7660",
  58                 .address = 0x21,
  59                 .probe = ov_probe
  60         },
  61         {
  62                 .id = OV7670_SENSOR,
  63                 .name = "OV7670",
  64                 .address = 0x21,
  65                 .probe = ov_probe
  66         },
  67         {
  68                 .id = MT9M111_SENSOR,
  69                 .name = "MT9M111",
  70                 .address = 0x5d,
  71                 .probe = mt9m111_probe
  72         },
  73         {
  74                 .id = MT9V111_SENSOR,
  75                 .name = "MT9V111",
  76                 .address = 0x5c,
  77                 .probe = mt9v111_probe
  78         },
  79         {
  80                 .id = MT9V011_SENSOR,
  81                 .name = "MT9V011",
  82                 .address = 0x5d,
  83                 .probe = mt9v011_probe
  84         },
  85         {
  86                 .id = MT9M001_SENSOR,
  87                 .name = "MT9M001",
  88                 .address = 0x5d,
  89                 .probe = mt9m001_probe
  90         },
  91 };
  92
  93 /**
  94  * @brief Wrapper function for camera-setting functions
  95  *
  96  * @param dev Pointer to device structure
  97  *
  98  * @returns 0
  99  */
 100 int dev_microdia_camera_settings(struct usb_microdia *dev)
 101 {
 102         dev_microdia_camera_set_contrast(dev);
 103         dev_microdia_camera_set_brightness(dev);
 104         dev_microdia_camera_set_gamma(dev);
 105         dev_microdia_camera_set_exposure(dev);
 106         dev_microdia_camera_set_hvflip(dev);
 107         dev_microdia_camera_set_sharpness(dev);
 108         dev_microdia_camera_set_rgb_gain(dev);
 109         dev_microdia_camera_set_auto_exposure(dev);
 110         dev_microdia_camera_set_auto_whitebalance(dev);
 111         return 0;
 112 }
 113
 114 /**
 115  * @brief Wrapper function for device-specific contrast functions
 116  *
 117  * @param dev Pointer to device structure
 118  *
 119  * @returns 0 or negative error value
 120  *
 121  */
 122 int dev_microdia_camera_set_contrast(struct usb_microdia *dev)
 123 {
 124         int ret = -ENODEV;
 125         if (dev && dev->camera.set_contrast)
 126                 ret = dev->camera.set_contrast(dev);
 127         return ret;
 128 }
 129
 130 /**
 131  * @brief Wrapper function for device-specific brightness functions
 132  *
 133  * @param dev Pointer to device structure
 134  *
 135  * @returns 0 or negative error value
 136  *
 137  */
 138 int dev_microdia_camera_set_brightness(struct usb_microdia *dev)
 139 {
 140         int ret = -ENODEV;
 141         if (dev && dev->camera.set_brightness)
 142                 ret = dev->camera.set_brightness(dev);
 143         return ret;
 144 }
 145
 146 /**
 147  * @brief Wrapper function for device-specific gamma functions
 148  *
 149  * @param dev Pointer to device structure
 150  *
 151  * @returns 0 or negative error value
 152  *
 153  */
 154 int dev_microdia_camera_set_gamma(struct usb_microdia *dev)
 155 {
 156         int ret = -ENODEV;
 157         if (dev && dev->camera.set_gamma)
 158                 ret = dev->camera.set_gamma(dev);
 159         return ret;
 160 }
 161
 162 /**
 163  * @brief Wrapper function for device-specific exposure functions
 164  *
 165  * @param dev Pointer to device structure
 166  *
 167  * @returns 0 or negative error value
 168  *
 169  */
 170 int dev_microdia_camera_set_exposure(struct usb_microdia *dev)
 171 {
 172         if (dev && dev->camera.set_exposure != NULL)
 173                 return dev->camera.set_exposure(dev);
 174
 175         return 0;
 176 }
 177
 178 /**
 179  * @brief Wrapper function for device-specific hvflip functions
 180  *
 181  * @param dev Pointer to device structure
 182  *
 183  * @returns 0 or negative error value
 184  *
 185  */
 186 int dev_microdia_camera_set_hvflip(struct usb_microdia *dev)
 187 {
 188         int ret = -ENODEV;
 189         if (dev && dev->camera.set_hvflip)
 190                 ret = dev->camera.set_hvflip(dev);
 191
 192         return ret;
 193 }
 194
 195 /**
 196  * @brief Wrapper function for device-specific sharpness functions
 197  *
 198  * @param dev Pointer to device structure
 199  *
 200  * @returns 0 or negative error value
 201  *
 202  */
 203 int dev_microdia_camera_set_sharpness(struct usb_microdia *dev)
 204 {
 205         int ret = -ENODEV;
 206         if (dev && dev->camera.set_sharpness)
 207                 ret = dev->camera.set_sharpness(dev);
 208
 209         return ret;
 210 }
 211
 212 /**
 213  * @brief Wrapper function for device-specific rgb-gain functions
 214  *
 215  * @param dev Pointer to device structure
 216  *
 217  * @returns 0 or negative error value
 218  *
 219  */
 220 int dev_microdia_camera_set_rgb_gain(struct usb_microdia *dev)
 221 {
 222         int ret = -ENODEV;
 223         if (dev && dev->camera.set_rgb_gain)
 224                 ret = dev->camera.set_rgb_gain(dev);
 225
 226         return ret;
 227 }
 228
 229 /**
 230  * @brief Wrapper function for device-specific auto-exposure functions
 231  *
 232  * @param dev Pointer to device structure
 233  *
 234  * @returns 0 or negative error value
 235  *
 236  */
 237 int dev_microdia_camera_set_auto_exposure(struct usb_microdia *dev)
 238 {
 239         int ret = -ENODEV;
 240         if (dev && dev->camera.set_auto_exposure)
 241                 ret = dev->camera.set_auto_exposure(dev);
 242
 243         return ret;
 244 }
 245
 246 /**
 247  * @brief Wrapper function for device-specific auto-whitebalance functions
 248  *
 249  * @param dev Pointer to device structure
 250  *
 251  * @returns 0 or negative error value
 252  *
 253  */
 254 int dev_microdia_camera_set_auto_whitebalance(struct usb_microdia *dev)
 255 {
 256         int ret = -ENODEV;
 257         if (dev && dev->camera.set_auto_whitebalance)
 258                 ret = dev->camera.set_auto_whitebalance(dev);
 259
 260         return ret;
 261 }
 262
 263 /**
 264  * @brief function to probe sensor attached to bridge
 265  *
 266  * @param dev pointer to device structure
 267  *
 268  * @returns 0 or negative error value
 269  *
 270  * This function will probe the bridge for the proper sensor
 271  */
 272 int dev_microdia_probe_sensor(struct usb_microdia *dev)
 273 {
 274         int i, ret;
 275         dev->camera.sensor_flags = SN9C20X_I2C_2WIRE;
 276
 277         for (i = 0; i < ARRAY_SIZE(sensors); i++) {
 278                 dev->camera.sensor_slave_address = sensors[i].address;
 279                 ret = sensors[i].probe(dev);
 280                 if (ret == sensors[i].id) {
 281                         UDIA_INFO("Detected sensor: %s\n", sensors[i].name);
 282                         return ret;
 283                 }
 284         }
 285
 286         return UNKNOWN_SENSOR;
 287 }
 288
 289 /**
 290  * @brief Wrapper function for device-specific initialization functions
 291  *
 292  * @param dev Pointer to device structure
 293  * @param flags
 294  *
 295  * @returns 0 or negative error value
 296  *
 297  */
 298 int dev_microdia_initialize_device(struct usb_microdia *dev, __u32 flags)
 299 {
 300         switch (flags >> 16) {
 301         case (SN9C20X_BRIDGE >> 16):
 302                 UDIA_INFO("Detected SN9C20X Bridge\n");
 303                 return sn9c20x_initialize(dev);
 304         default:
 305                 UDIA_INFO("Unsupported bridge\n");
 306         }
 307         return -ENODEV;
 308 }
 309
 310 /**
 311  * @brief Wrapper function for for enable video stream for specific bridge
 312  *
 313  * @param dev Pointer to device structure
 314  * @param enable Contains the wanted state
 315  *
 316  * @returns 0
 317  *
 318  */
 319 int dev_microdia_enable_video(struct usb_microdia *dev, int enable)
 320 {
 321         int ret = -ENODEV;
 322         if (dev && dev->camera.enable_video)
 323                 ret = dev->camera.enable_video(dev, enable);
 324
 325         return ret;
 326 }