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