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