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 "ov7670.h"
  34 #include "ov965x.h"
  35 #include "mt9vx11.h"
  36 #include "ov7660.h"
  37
  38 struct sensor_info sensors[] = {
  39         {
  40                 .id = OV9650_SENSOR,
  41                 .name = "OV9650",
  42                 .probe = ov_probe
  43         },
  44         {
  45                 .id = OV9655_SENSOR,
  46                 .name = "OV9655",
  47                 .probe = ov_probe
  48         },
  49         {
  50                 .id = SOI968_SENSOR,
  51                 .name = "SOI968",
  52                 .probe = ov_probe
  53         },
  54         {
  55                 .id = OV7660_SENSOR,
  56                 .name = "OV7660",
  57                 .probe = ov_probe
  58         },
  59         {
  60                 .id = OV7670_SENSOR,
  61                 .name = "OV7670",
  62                 .probe = ov_probe
  63         },
  64         {
  65                 .id = MT9M111_SENSOR,
  66                 .name = "MT9M111",
  67                 .probe = mt9m111_probe
  68         },
  69         {
  70                 .id = MT9V111_SENSOR,
  71                 .name = "MT9V111",
  72                 .probe = mt9v111_probe
  73         },
  74         {
  75                 .id = MT9V011_SENSOR,
  76                 .name = "MT9V011",
  77                 .probe = mt9v011_probe
  78         },
  79         {
  80                 .id = MT9M001_SENSOR,
  81                 .name = "MT9M001",
  82                 .probe = mt9m001_probe
  83         },
  84 };
  85
  86 /**
  87  * @brief Wrapper function for camera-setting functions
  88  *
  89  * @param dev Pointer to device structure
  90  *
  91  * @returns 0
  92  */
  93 int dev_microdia_camera_settings(struct usb_microdia *dev)
  94 {
  95         dev_microdia_camera_set_contrast(dev);
  96         dev_microdia_camera_set_brightness(dev);
  97         dev_microdia_camera_set_gamma(dev);
  98         dev_microdia_camera_set_exposure(dev);
  99         dev_microdia_camera_set_hvflip(dev);
 100         dev_microdia_camera_set_sharpness(dev);
 101         dev_microdia_camera_set_rgb_gain(dev);
 102         dev_microdia_camera_set_auto_exposure(dev);
 103         dev_microdia_camera_set_auto_whitebalance(dev);
 104         return 0;
 105 }
 106
 107 /**
 108  * @brief Wrapper function for device-specific contrast functions
 109  *
 110  * @param dev Pointer to device structure
 111  *
 112  * @returns 0 or negative error value
 113  *
 114  */
 115 int dev_microdia_camera_set_contrast(struct usb_microdia *dev)
 116 {
 117         int ret = -ENODEV;
 118         if (dev && dev->camera.set_contrast)
 119                 ret = dev->camera.set_contrast(dev);
 120         return ret;
 121 }
 122
 123 /**
 124  * @brief Wrapper function for device-specific brightness functions
 125  *
 126  * @param dev Pointer to device structure
 127  *
 128  * @returns 0 or negative error value
 129  *
 130  */
 131 int dev_microdia_camera_set_brightness(struct usb_microdia *dev)
 132 {
 133         int ret = -ENODEV;
 134         if (dev && dev->camera.set_brightness)
 135                 ret = dev->camera.set_brightness(dev);
 136         return ret;
 137 }
 138
 139 /**
 140  * @brief Wrapper function for device-specific gamma functions
 141  *
 142  * @param dev Pointer to device structure
 143  *
 144  * @returns 0 or negative error value
 145  *
 146  */
 147 int dev_microdia_camera_set_gamma(struct usb_microdia *dev)
 148 {
 149         int ret = -ENODEV;
 150         if (dev && dev->camera.set_gamma)
 151                 ret = dev->camera.set_gamma(dev);
 152         return ret;
 153 }
 154
 155 /**
 156  * @brief Wrapper function for device-specific exposure functions
 157  *
 158  * @param dev Pointer to device structure
 159  *
 160  * @returns 0 or negative error value
 161  *
 162  */
 163 int dev_microdia_camera_set_exposure(struct usb_microdia *dev)
 164 {
 165         if (dev && dev->camera.set_exposure != NULL)
 166                 return dev->camera.set_exposure(dev);
 167
 168         return 0;
 169 }
 170
 171 /**
 172  * @brief Wrapper function for device-specific hvflip functions
 173  *
 174  * @param dev Pointer to device structure
 175  *
 176  * @returns 0 or negative error value
 177  *
 178  */
 179 int dev_microdia_camera_set_hvflip(struct usb_microdia *dev)
 180 {
 181         int ret = -ENODEV;
 182         if (dev && dev->camera.set_hvflip)
 183                 ret = dev->camera.set_hvflip(dev);
 184
 185         return ret;
 186 }
 187
 188 /**
 189  * @brief Wrapper function for device-specific sharpness functions
 190  *
 191  * @param dev Pointer to device structure
 192  *
 193  * @returns 0 or negative error value
 194  *
 195  */
 196 int dev_microdia_camera_set_sharpness(struct usb_microdia *dev)
 197 {
 198         int ret = -ENODEV;
 199         if (dev && dev->camera.set_sharpness)
 200                 ret = dev->camera.set_sharpness(dev);
 201
 202         return ret;
 203 }
 204
 205 /**
 206  * @brief Wrapper function for device-specific rgb-gain functions
 207  *
 208  * @param dev Pointer to device structure
 209  *
 210  * @returns 0 or negative error value
 211  *
 212  */
 213 int dev_microdia_camera_set_rgb_gain(struct usb_microdia *dev)
 214 {
 215         int ret = -ENODEV;
 216         if (dev && dev->camera.set_rgb_gain)
 217                 ret = dev->camera.set_rgb_gain(dev);
 218
 219         return ret;
 220 }
 221
 222 /**
 223  * @brief Wrapper function for device-specific auto-exposure functions
 224  *
 225  * @param dev Pointer to device structure
 226  *
 227  * @returns 0 or negative error value
 228  *
 229  */
 230 int dev_microdia_camera_set_auto_exposure(struct usb_microdia *dev)
 231 {
 232         int ret = -ENODEV;
 233         if (dev && dev->camera.set_auto_exposure)
 234                 ret = dev->camera.set_auto_exposure(dev);
 235
 236         return ret;
 237 }
 238
 239 /**
 240  * @brief Wrapper function for device-specific auto-whitebalance functions
 241  *
 242  * @param dev Pointer to device structure
 243  *
 244  * @returns 0 or negative error value
 245  *
 246  */
 247 int dev_microdia_camera_set_auto_whitebalance(struct usb_microdia *dev)
 248 {
 249         int ret = -ENODEV;
 250         if (dev && dev->camera.set_auto_whitebalance)
 251                 ret = dev->camera.set_auto_whitebalance(dev);
 252
 253         return ret;
 254 }
 255
 256 /**
 257  * @brief function to probe sensor attached to bridge
 258  *
 259  * @param dev pointer to device structure
 260  *
 261  * @returns 0 or negative error value
 262  *
 263  * This function will probe the bridge for the proper sensor
 264  */
 265 int dev_microdia_probe_sensor(struct usb_microdia *dev)
 266 {
 267         int i, ret;
 268         dev->camera.sensor_flags = SN9C20X_I2C_2WIRE;
 269
 270         for (i = 0; i < ARRAY_SIZE(sensors); i++) {
 271                 ret = sensors[i].probe(dev);
 272                 if (ret == sensors[i].id) {
 273                         UDIA_INFO("Detected sensor: %s\n", sensors[i].name);
 274                         return ret;
 275                 }
 276         }
 277
 278         return UNKNOWN_SENSOR;
 279 }
 280
 281 /**
 282  * @brief Wrapper function for device-specific initialization functions
 283  *
 284  * @param dev Pointer to device structure
 285  * @param flags
 286  *
 287  * @returns 0 or negative error value
 288  *
 289  */
 290 int dev_microdia_initialize_device(struct usb_microdia *dev, __u32 flags)
 291 {
 292         switch (flags >> 16) {
 293         case (SN9C20X_BRIDGE >> 16):
 294                 UDIA_INFO("Detected SN9C20X Bridge\n");
 295                 return sn9c20x_initialize(dev);
 296         default:
 297                 UDIA_INFO("Unsupported bridge\n");
 298         }
 299         return -ENODEV;
 300 }
 301
 302 /**
 303  * @brief Wrapper function for for enable video stream for specific bridge
 304  *
 305  * @param dev Pointer to device structure
 306  * @param enable Contains the wanted state
 307  *
 308  * @returns 0
 309  *
 310  */
 311 int dev_microdia_enable_video(struct usb_microdia *dev, int enable)
 312 {
 313         int ret = -ENODEV;
 314         if (dev && dev->camera.enable_video)
 315                 ret = dev->camera.enable_video(dev, enable);
 316
 317         return ret;
 318 }