// SPDX-License-Identifier: GPL-2.0-or-later
/* GSPCA subdrivers for Genesys Logic webcams with the GL860 chip
* Subdriver core
*
* 2009/09/24 Olivier Lorin <o.lorin@laposte.net>
* GSPCA by Jean-Francois Moine <http://moinejf.free.fr>
* Thanks BUGabundo and Malmostoso for your amazing help!
*/
#define pr_fmt(fmt) KBUILD_MODNAME
": " fmt
#include "gspca.h"
#include "gl860.h"
MODULE_AUTHOR(
"Olivier Lorin <o.lorin@laposte.net>");
MODULE_DESCRIPTION(
"Genesys Logic USB PC Camera Driver");
MODULE_LICENSE(
"GPL");
/*======================== static function declarations ====================*/
static void (*dev_init_settings)(
struct gspca_dev *gspca_dev);
static int sd_config(
struct gspca_dev *gspca_dev,
const struct usb_device_id *id);
static int sd_init(
struct gspca_dev *gspca_dev);
static int sd_isoc_init(
struct gspca_dev *gspca_dev);
static int sd_start(
struct gspca_dev *gspca_dev);
static void sd_stop0(
struct gspca_dev *gspca_dev);
static void sd_pkt_scan(
struct gspca_dev *gspca_dev,
u8 *data,
int len);
static void sd_callback(
struct gspca_dev *gspca_dev);
static int gl860_guess_sensor(
struct gspca_dev *gspca_dev,
u16 vendor_id, u16 product_id);
/*============================ driver options ==============================*/
static s32 AC50Hz =
0xff;
module_param(AC50Hz,
int,
0644);
MODULE_PARM_DESC(AC50Hz,
" Does AC power frequency is 50Hz? (0/1)");
static char sensor[
7];
module_param_string(sensor, sensor,
sizeof(sensor),
0644);
MODULE_PARM_DESC(sensor,
" Driver sensor ('MI1320'/'MI2020'/'OV9655'/'OV2640')");
/*============================ webcam controls =============================*/
static int sd_s_ctrl(
struct v4l2_ctrl *ctrl)
{
struct gspca_dev *gspca_dev =
container_of(ctrl->handler,
struct gspca_dev, ctrl_handler);
struct sd *sd = (
struct sd *) gspca_dev;
switch (ctrl->id) {
case V4L2_CID_BRIGHTNESS:
sd->vcur.brightness = ctrl->val;
break;
case V4L2_CID_CONTRAST:
sd->vcur.contrast = ctrl->val;
break;
case V4L2_CID_SATURATION:
sd->vcur.saturation = ctrl->val;
break;
case V4L2_CID_HUE:
sd->vcur.hue = ctrl->val;
break;
case V4L2_CID_GAMMA:
sd->vcur.gamma = ctrl->val;
break;
case V4L2_CID_HFLIP:
sd->vcur.mirror = ctrl->val;
break;
case V4L2_CID_VFLIP:
sd->vcur.flip = ctrl->val;
break;
case V4L2_CID_POWER_LINE_FREQUENCY:
sd->vcur.AC50Hz = ctrl->val;
break;
case V4L2_CID_WHITE_BALANCE_TEMPERATURE:
sd->vcur.whitebal = ctrl->val;
break;
case V4L2_CID_SHARPNESS:
sd->vcur.sharpness = ctrl->val;
break;
case V4L2_CID_BACKLIGHT_COMPENSATION:
sd->vcur.backlight = ctrl->val;
break;
default:
return -EINVAL;
}
if (gspca_dev->streaming)
sd->waitSet =
1;
return 0;
}
static const struct v4l2_ctrl_ops sd_ctrl_ops = {
.s_ctrl = sd_s_ctrl,
};
static int sd_init_controls(
struct gspca_dev *gspca_dev)
{
struct sd *sd = (
struct sd *) gspca_dev;
struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
gspca_dev->vdev.ctrl_handler = hdl;
v4l2_ctrl_handler_init(hdl,
11);
if (sd->vmax.brightness)
v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_BRIGHTNESS,
0, sd->vmax.brightness,
1,
sd->vcur.brightness);
if (sd->vmax.contrast)
v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_CONTRAST,
0, sd->vmax.contrast,
1,
sd->vcur.contrast);
if (sd->vmax.saturation)
v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_SATURATION,
0, sd->vmax.saturation,
1,
sd->vcur.saturation);
if (sd->vmax.hue)
v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_HUE,
0, sd->vmax.hue,
1, sd->vcur.hue);
if (sd->vmax.gamma)
v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_GAMMA,
0, sd->vmax.gamma,
1, sd->vcur.gamma);
if (sd->vmax.mirror)
v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_HFLIP,
0, sd->vmax.mirror,
1, sd->vcur.mirror);
if (sd->vmax.flip)
v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_VFLIP,
0, sd->vmax.flip,
1, sd->vcur.flip);
if (sd->vmax.AC50Hz)
v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
V4L2_CID_POWER_LINE_FREQUENCY,
sd->vmax.AC50Hz,
0, sd->vcur.AC50Hz);
if (sd->vmax.whitebal)
v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
V4L2_CID_WHITE_BALANCE_TEMPERATURE,
0, sd->vmax.whitebal,
1, sd->vcur.whitebal);
if (sd->vmax.sharpness)
v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_SHARPNESS,
0, sd->vmax.sharpness,
1,
sd->vcur.sharpness);
if (sd->vmax.backlight)
v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
V4L2_CID_BACKLIGHT_COMPENSATION,
0, sd->vmax.backlight,
1,
sd->vcur.backlight);
if (hdl->error) {
pr_err(
"Could not initialize controls\n");
return hdl->error;
}
return 0;
}
/*==================== sud-driver structure initialisation =================*/
static const struct sd_desc sd_desc_mi1320 = {
.name = MODULE_NAME,
.config = sd_config,
.init = sd_init,
.init_controls = sd_init_controls,
.isoc_init = sd_isoc_init,
.start = sd_start,
.stop0 = sd_stop0,
.pkt_scan = sd_pkt_scan,
.dq_callback = sd_callback,
};
static const struct sd_desc sd_desc_mi2020 = {
.name = MODULE_NAME,
.config = sd_config,
.init = sd_init,
.init_controls = sd_init_controls,
.isoc_init = sd_isoc_init,
.start = sd_start,
.stop0 = sd_stop0,
.pkt_scan = sd_pkt_scan,
.dq_callback = sd_callback,
};
static const struct sd_desc sd_desc_ov2640 = {
.name = MODULE_NAME,
.config = sd_config,
.init = sd_init,
.init_controls = sd_init_controls,
.isoc_init = sd_isoc_init,
.start = sd_start,
.stop0 = sd_stop0,
.pkt_scan = sd_pkt_scan,
.dq_callback = sd_callback,
};
static const struct sd_desc sd_desc_ov9655 = {
.name = MODULE_NAME,
.config = sd_config,
.init = sd_init,
.init_controls = sd_init_controls,
.isoc_init = sd_isoc_init,
.start = sd_start,
.stop0 = sd_stop0,
.pkt_scan = sd_pkt_scan,
.dq_callback = sd_callback,
};
/*=========================== sub-driver image sizes =======================*/
static struct v4l2_pix_format mi2020_mode[] = {
{
640,
480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
.bytesperline =
640,
.sizeimage =
640 *
480,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv =
0
},
{
800,
598, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
.bytesperline =
800,
.sizeimage =
800 *
598,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv =
1
},
{
1280,
1024, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
.bytesperline =
1280,
.sizeimage =
1280 *
1024,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv =
2
},
{
1600,
1198, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
.bytesperline =
1600,
.sizeimage =
1600 *
1198,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv =
3
},
};
static struct v4l2_pix_format ov2640_mode[] = {
{
640,
480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
.bytesperline =
640,
.sizeimage =
640 *
480,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv =
0
},
{
800,
600, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
.bytesperline =
800,
.sizeimage =
800 *
600,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv =
1
},
{
1280,
960, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
.bytesperline =
1280,
.sizeimage =
1280 *
960,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv =
2
},
{
1600,
1200, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
.bytesperline =
1600,
.sizeimage =
1600 *
1200,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv =
3
},
};
static struct v4l2_pix_format mi1320_mode[] = {
{
640,
480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
.bytesperline =
640,
.sizeimage =
640 *
480,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv =
0
},
{
800,
600, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
.bytesperline =
800,
.sizeimage =
800 *
600,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv =
1
},
{
1280,
960, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
.bytesperline =
1280,
.sizeimage =
1280 *
960,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv =
2
},
};
static struct v4l2_pix_format ov9655_mode[] = {
{
640,
480, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
.bytesperline =
640,
.sizeimage =
640 *
480,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv =
0
},
{
1280,
960, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
.bytesperline =
1280,
.sizeimage =
1280 *
960,
.colorspace = V4L2_COLORSPACE_SRGB,
.priv =
1
},
};
/*========================= sud-driver functions ===========================*/
/* This function is called at probe time */
static int sd_config(
struct gspca_dev *gspca_dev,
const struct usb_device_id *id)
{
struct sd *sd = (
struct sd *) gspca_dev;
struct cam *cam;
u16 vendor_id, product_id;
/* Get USB VendorID and ProductID */
vendor_id = id->idVendor;
product_id = id->idProduct;
sd->nbRightUp =
1;
sd->nbIm = -
1;
sd->sensor =
0xff;
if (strcmp(sensor,
"MI1320") ==
0)
sd->sensor = ID_MI1320;
else if (strcmp(sensor,
"OV2640") ==
0)
sd->sensor = ID_OV2640;
else if (strcmp(sensor,
"OV9655") ==
0)
sd->sensor = ID_OV9655;
else if (strcmp(sensor,
"MI2020") ==
0)
sd->sensor = ID_MI2020;
/* Get sensor and set the suitable init/start/../stop functions */
if (gl860_guess_sensor(gspca_dev, vendor_id, product_id) == -
1)
return -
1;
cam = &gspca_dev->cam;
switch (sd->sensor) {
case ID_MI1320:
gspca_dev->sd_desc = &sd_desc_mi1320;
cam->cam_mode = mi1320_mode;
cam->nmodes = ARRAY_SIZE(mi1320_mode);
dev_init_settings = mi1320_init_settings;
break;
case ID_MI2020:
gspca_dev->sd_desc = &sd_desc_mi2020;
cam->cam_mode = mi2020_mode;
cam->nmodes = ARRAY_SIZE(mi2020_mode);
dev_init_settings = mi2020_init_settings;
break;
case ID_OV2640:
gspca_dev->sd_desc = &sd_desc_ov2640;
cam->cam_mode = ov2640_mode;
cam->nmodes = ARRAY_SIZE(ov2640_mode);
dev_init_settings = ov2640_init_settings;
break;
case ID_OV9655:
gspca_dev->sd_desc = &sd_desc_ov9655;
cam->cam_mode = ov9655_mode;
cam->nmodes = ARRAY_SIZE(ov9655_mode);
dev_init_settings = ov9655_init_settings;
break;
}
dev_init_settings(gspca_dev);
if (AC50Hz !=
0xff)
((
struct sd *) gspca_dev)->vcur.AC50Hz = AC50Hz;
return 0;
}
/* This function is called at probe time after sd_config */
static int sd_init(
struct gspca_dev *gspca_dev)
{
struct sd *sd = (
struct sd *) gspca_dev;
return sd->dev_init_at_startup(gspca_dev);
}
/* This function is called before to choose the alt setting */
static int sd_isoc_init(
struct gspca_dev *gspca_dev)
{
struct sd *sd = (
struct sd *) gspca_dev;
return sd->dev_configure_alt(gspca_dev);
}
/* This function is called to start the webcam */
static int sd_start(
struct gspca_dev *gspca_dev)
{
struct sd *sd = (
struct sd *) gspca_dev;
return sd->dev_init_pre_alt(gspca_dev);
}
/* This function is called to stop the webcam */
static void sd_stop0(
struct gspca_dev *gspca_dev)
{
struct sd *sd = (
struct sd *) gspca_dev;
if (!sd->gspca_dev.present)
return;
return sd->dev_post_unset_alt(gspca_dev);
}
/* This function is called when an image is being received */
static void sd_pkt_scan(
struct gspca_dev *gspca_dev,
u8 *data,
int len)
{
struct sd *sd = (
struct sd *) gspca_dev;
static s32 nSkipped;
s32 mode = (s32) gspca_dev->curr_mode;
s32 nToSkip =
sd->swapRB * (gspca_dev->cam.cam_mode[mode].bytesperline +
1);
/* Test only against 0202h, so endianness does not matter */
switch (*(s16 *) data) {
case 0x0202:
/* End of frame, start a new one */
gspca_frame_add(gspca_dev, LAST_PACKET, NULL,
0);
nSkipped =
0;
if (sd->nbIm >=
0 && sd->nbIm <
10)
sd->nbIm++;
gspca_frame_add(gspca_dev, FIRST_PACKET, NULL,
0);
break;
default:
data +=
2;
len -=
2;
if (nSkipped + len <= nToSkip)
nSkipped += len;
else {
if (nSkipped < nToSkip && nSkipped + len > nToSkip) {
data += nToSkip - nSkipped;
len -= nToSkip - nSkipped;
nSkipped = nToSkip +
1;
}
gspca_frame_add(gspca_dev,
INTER_PACKET, data, len);
}
break;
}
}
/* This function is called when an image has been read */
/* This function is used to monitor webcam orientation */
static void sd_callback(
struct gspca_dev *gspca_dev)
{
struct sd *sd = (
struct sd *) gspca_dev;
if (!_OV9655_) {
u8 state;
u8 upsideDown;
/* Probe sensor orientation */
ctrl_in(gspca_dev,
0xc0,
2,
0x0000,
0x0000,
1, (
void *)&state);
/* C8/40 means upside-down (looking backwards) */
/* D8/50 means right-up (looking onwards) */
upsideDown = (state ==
0xc8 || state ==
0x40);
if (upsideDown && sd->nbRightUp > -
4) {
if (sd->nbRightUp >
0)
sd->nbRightUp =
0;
if (sd->nbRightUp == -
3) {
sd->mirrorMask =
1;
sd->waitSet =
1;
}
sd->nbRightUp--;
}
if (!upsideDown && sd->nbRightUp <
4) {
if (sd->nbRightUp <
0)
sd->nbRightUp =
0;
if (sd->nbRightUp ==
3) {
sd->mirrorMask =
0;
sd->waitSet =
1;
}
sd->nbRightUp++;
}
}
if (sd->waitSet)
sd->dev_camera_settings(gspca_dev);
}
/*=================== USB driver structure initialisation ==================*/
static const struct usb_device_id device_table[] = {
{USB_DEVICE(
0x05e3,
0x0503)},
{USB_DEVICE(
0x05e3,
0xf191)},
{}
};
MODULE_DEVICE_TABLE(usb, device_table);
static int sd_probe(
struct usb_interface *intf,
const struct usb_device_id *id)
{
return gspca_dev_probe(intf, id,
&sd_desc_mi1320,
sizeof(
struct sd), THIS_MODULE);
}
static void sd_disconnect(
struct usb_interface *intf)
{
gspca_disconnect(intf);
}
static struct usb_driver sd_driver = {
.name = MODULE_NAME,
.id_table = device_table,
.probe = sd_probe,
.disconnect = sd_disconnect,
#ifdef CONFIG_PM
.suspend = gspca_suspend,
.resume = gspca_resume,
.reset_resume = gspca_resume,
#endif
};
/*====================== Init and Exit module functions ====================*/
module_usb_driver(sd_driver);
/*==========================================================================*/
int gl860_RTx(
struct gspca_dev *gspca_dev,
unsigned char pref, u32 req, u16 val, u16 index,
s32 len,
void *pdata)
{
struct usb_device *udev = gspca_dev->dev;
s32 r =
0;
if (pref ==
0x40) {
/* Send */
if (len >
0) {
memcpy(gspca_dev->usb_buf, pdata, len);
r = usb_control_msg(udev, usb_sndctrlpipe(udev,
0),
req, pref, val, index,
gspca_dev->usb_buf,
len,
400 +
200 * (len >
1));
}
else {
r = usb_control_msg(udev, usb_sndctrlpipe(udev,
0),
req, pref, val, index, NULL, len,
400);
}
}
else {
/* Receive */
if (len >
0) {
r = usb_control_msg(udev, usb_rcvctrlpipe(udev,
0),
req, pref, val, index,
gspca_dev->usb_buf,
len,
400 +
200 * (len >
1));
memcpy(pdata, gspca_dev->usb_buf, len);
}
else {
gspca_err(gspca_dev,
"zero-length read request\n");
r = -EINVAL;
}
}
if (r <
0)
pr_err(
"ctrl transfer failed %4d [p%02x r%d v%04x i%04x len%d]\n",
r, pref, req, val, index, len);
else if (len >
1 && r < len)
gspca_err(gspca_dev,
"short ctrl transfer %d/%d\n", r, len);
msleep(
1);
return r;
}
int fetch_validx(
struct gspca_dev *gspca_dev,
struct validx *tbl,
int len)
{
int n;
for (n =
0; n < len; n++) {
if (tbl[n].idx !=
0xffff)
ctrl_out(gspca_dev,
0x40,
1, tbl[n].val,
tbl[n].idx,
0, NULL);
else if (tbl[n].val ==
0xffff)
break;
else
msleep(tbl[n].val);
}
return n;
}
int keep_on_fetching_validx(
struct gspca_dev *gspca_dev,
struct validx *tbl,
int len,
int n)
{
while (++n < len) {
if (tbl[n].idx !=
0xffff)
ctrl_out(gspca_dev,
0x40,
1, tbl[n].val, tbl[n].idx,
0, NULL);
else if (tbl[n].val ==
0xffff)
break;
else
msleep(tbl[n].val);
}
return n;
}
void fetch_idxdata(
struct gspca_dev *gspca_dev,
struct idxdata *tbl,
int len)
{
int n;
for (n =
0; n < len; n++) {
if (memcmp(tbl[n].data,
"\xff\xff\xff",
3) !=
0)
ctrl_out(gspca_dev,
0x40,
3,
0x7a00, tbl[n].idx,
3, tbl[n].data);
else
msleep(tbl[n].idx);
}
}
static int gl860_guess_sensor(
struct gspca_dev *gspca_dev,
u16 vendor_id, u16 product_id)
{
struct sd *sd = (
struct sd *) gspca_dev;
u8 probe, nb26, nb96, nOV, ntry;
if (product_id ==
0xf191)
sd->sensor = ID_MI1320;
if (sd->sensor ==
0xff) {
ctrl_in(gspca_dev,
0xc0,
2,
0x0000,
0x0004,
1, &probe);
ctrl_in(gspca_dev,
0xc0,
2,
0x0000,
0x0004,
1, &probe);
ctrl_out(gspca_dev,
0x40,
1,
0x0000,
0x0000,
0, NULL);
msleep(
3);
ctrl_out(gspca_dev,
0x40,
1,
0x0010,
0x0010,
0, NULL);
msleep(
3);
ctrl_out(gspca_dev,
0x40,
1,
0x0008,
0x00c0,
0, NULL);
msleep(
3);
ctrl_out(gspca_dev,
0x40,
1,
0x0001,
0x00c1,
0, NULL);
msleep(
3);
ctrl_out(gspca_dev,
0x40,
1,
0x0001,
0x00c2,
0, NULL);
msleep(
3);
ctrl_out(gspca_dev,
0x40,
1,
0x0020,
0x0006,
0, NULL);
msleep(
3);
ctrl_out(gspca_dev,
0x40,
1,
0x006a,
0x000d,
0, NULL);
msleep(
56);
gspca_dbg(gspca_dev, D_PROBE,
"probing for sensor MI2020 or OVXXXX\n");
nOV =
0;
for (ntry =
0; ntry <
4; ntry++) {
ctrl_out(gspca_dev,
0x40,
1,
0x0040,
0x0000,
0, NULL);
msleep(
3);
ctrl_out(gspca_dev,
0x40,
1,
0x0063,
0x0006,
0, NULL);
msleep(
3);
ctrl_out(gspca_dev,
0x40,
1,
0x7a00,
0x8030,
0, NULL);
msleep(
10);
ctrl_in(gspca_dev,
0xc0,
2,
0x7a00,
0x8030,
1, &probe);
gspca_dbg(gspca_dev, D_PROBE,
"probe=0x%02x\n", probe);
if (probe ==
0xff)
nOV++;
}
if (nOV) {
gspca_dbg(gspca_dev, D_PROBE,
"0xff -> OVXXXX\n");
gspca_dbg(gspca_dev, D_PROBE,
"probing for sensor OV2640 or OV9655");
nb26 = nb96 =
0;
for (ntry =
0; ntry <
4; ntry++) {
ctrl_out(gspca_dev,
0x40,
1,
0x0040,
0x0000,
0, NULL);
msleep(
3);
ctrl_out(gspca_dev,
0x40,
1,
0x6000,
0x800a,
0, NULL);
msleep(
10);
/* Wait for 26(OV2640) or 96(OV9655) */
ctrl_in(gspca_dev,
0xc0,
2,
0x6000,
0x800a,
1, &probe);
if (probe ==
0x26 || probe ==
0x40) {
gspca_dbg(gspca_dev, D_PROBE,
"probe=0x%02x -> OV2640\n",
probe);
sd->sensor = ID_OV2640;
nb26 +=
4;
break;
}
if (probe ==
0x96 || probe ==
0x55) {
gspca_dbg(gspca_dev, D_PROBE,
"probe=0x%02x -> OV9655\n",
probe);
sd->sensor = ID_OV9655;
nb96 +=
4;
break;
}
gspca_dbg(gspca_dev, D_PROBE,
"probe=0x%02x\n",
probe);
if (probe ==
0x00)
nb26++;
if (probe ==
0xff)
nb96++;
msleep(
3);
}
if (nb26 <
4 && nb96 <
4)
return -
1;
}
else {
gspca_dbg(gspca_dev, D_PROBE,
"Not any 0xff -> MI2020\n");
sd->sensor = ID_MI2020;
}
}
if (_MI1320_) {
gspca_dbg(gspca_dev, D_PROBE,
"05e3:f191 sensor MI1320 (1.3M)\n");
}
else if (_MI2020_) {
gspca_dbg(gspca_dev, D_PROBE,
"05e3:0503 sensor MI2020 (2.0M)\n");
}
else if (_OV9655_) {
gspca_dbg(gspca_dev, D_PROBE,
"05e3:0503 sensor OV9655 (1.3M)\n");
}
else if (_OV2640_) {
gspca_dbg(gspca_dev, D_PROBE,
"05e3:0503 sensor OV2640 (2.0M)\n");
}
else {
gspca_dbg(gspca_dev, D_PROBE,
"***** Unknown sensor *****\n");
return -
1;
}
return 0;
}
