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