V4L/DVB (12954): gspca - gl860: Addition of GL860 based webcams
- add the Genesys Logic 05e3:0503 and 05e3:f191 webcam Signed-off-by: Olivier Lorin <o.lorin@laposte.net> Signed-off-by: Jean-Francois Moine <moinejf@free.fr> Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
This commit is contained in:
Olivier Lorin
Mauro Carvalho Chehab
parent
ba624ce4ad
commit
4f7cb8837c
|
|
@ -173,6 +173,8 @@ ov519 05a9:8519 OmniVision
|
|||
ov519 05a9:a518 D-Link DSB-C310 Webcam
|
||||
sunplus 05da:1018 Digital Dream Enigma 1.3
|
||||
stk014 05e1:0893 Syntek DV4000
|
||||
gl860 05e3:0503 Genesys Logic PC Camera
|
||||
gl860 05e3:f191 Genesys Logic PC Camera
|
||||
spca561 060b:a001 Maxell Compact Pc PM3
|
||||
zc3xx 0698:2003 CTX M730V built in
|
||||
spca500 06bd:0404 Agfa CL20
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ if USB_GSPCA && VIDEO_V4L2
|
|||
|
||||
source "drivers/media/video/gspca/m5602/Kconfig"
|
||||
source "drivers/media/video/gspca/stv06xx/Kconfig"
|
||||
source "drivers/media/video/gspca/gl860/Kconfig"
|
||||
|
||||
config USB_GSPCA_CONEX
|
||||
tristate "Conexant Camera Driver"
|
||||
|
|
|
|||
|
|
@ -58,3 +58,4 @@ gspca_zc3xx-objs := zc3xx.o
|
|||
|
||||
obj-$(CONFIG_USB_M5602) += m5602/
|
||||
obj-$(CONFIG_USB_STV06XX) += stv06xx/
|
||||
obj-$(CONFIG_USB_GL860) += gl860/
|
||||
|
|
|
|||
|
|
@ -0,0 +1,8 @@
|
|||
config USB_GL860
|
||||
tristate "GL860 USB Camera Driver"
|
||||
depends on VIDEO_V4L2 && USB_GSPCA
|
||||
help
|
||||
Say Y here if you want support for cameras based on the GL860 chip.
|
||||
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called gspca_gl860.
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
obj-$(CONFIG_USB_GL860) += gspca_gl860.o
|
||||
|
||||
gspca_gl860-objs := gl860.o \
|
||||
gl860-mi1320.o \
|
||||
gl860-ov2640.o \
|
||||
gl860-ov9655.o \
|
||||
gl860-mi2020.o
|
||||
|
||||
EXTRA_CFLAGS += -Idrivers/media/video/gspca
|
||||
|
||||
|
|
@ -0,0 +1,537 @@
|
|||
/* @file gl860-mi1320.c
|
||||
* @author Olivier LORIN from my logs
|
||||
* @date 2009-08-27
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/* Sensor : MI1320 */
|
||||
|
||||
#include "gl860.h"
|
||||
|
||||
static struct validx tbl_common[] = {
|
||||
{0xba00, 0x00f0}, {0xba00, 0x00f1}, {0xba51, 0x0066}, {0xba02, 0x00f1},
|
||||
{0xba05, 0x0067}, {0xba05, 0x00f1}, {0xbaa0, 0x0065}, {0xba00, 0x00f1},
|
||||
{0xffff, 0xffff},
|
||||
{0xba00, 0x00f0}, {0xba02, 0x00f1}, {0xbafa, 0x0028}, {0xba02, 0x00f1},
|
||||
{0xba00, 0x00f0}, {0xba01, 0x00f1}, {0xbaf0, 0x0006}, {0xba0e, 0x00f1},
|
||||
{0xba70, 0x0006}, {0xba0e, 0x00f1},
|
||||
{0xffff, 0xffff},
|
||||
{0xba74, 0x0006}, {0xba0e, 0x00f1},
|
||||
{0xffff, 0xffff},
|
||||
{0x0061, 0x0000}, {0x0068, 0x000d},
|
||||
};
|
||||
|
||||
static struct validx tbl_init_at_startup[] = {
|
||||
{0x0000, 0x0000}, {0x0010, 0x0010},
|
||||
{35, 0xffff},
|
||||
{0x0008, 0x00c0}, {0x0001, 0x00c1}, {0x0001, 0x00c2}, {0x0020, 0x0006},
|
||||
{0x006a, 0x000d},
|
||||
};
|
||||
|
||||
static struct validx tbl_sensor_settings_common[] = {
|
||||
{0x0010, 0x0010}, {0x0003, 0x00c1}, {0x0042, 0x00c2}, {0x0040, 0x0000},
|
||||
{0x006a, 0x0007}, {0x006a, 0x000d}, {0x0063, 0x0006},
|
||||
};
|
||||
static struct validx tbl_sensor_settings_1280[] = {
|
||||
{0xba00, 0x00f0}, {0xba00, 0x00f1}, {0xba5a, 0x0066}, {0xba02, 0x00f1},
|
||||
{0xba05, 0x0067}, {0xba05, 0x00f1}, {0xba20, 0x0065}, {0xba00, 0x00f1},
|
||||
};
|
||||
static struct validx tbl_sensor_settings_800[] = {
|
||||
{0xba00, 0x00f0}, {0xba00, 0x00f1}, {0xba5a, 0x0066}, {0xba02, 0x00f1},
|
||||
{0xba05, 0x0067}, {0xba05, 0x00f1}, {0xba20, 0x0065}, {0xba00, 0x00f1},
|
||||
};
|
||||
static struct validx tbl_sensor_settings_640[] = {
|
||||
{0xba00, 0x00f0}, {0xba00, 0x00f1}, {0xbaa0, 0x0065}, {0xba00, 0x00f1},
|
||||
{0xba51, 0x0066}, {0xba02, 0x00f1}, {0xba05, 0x0067}, {0xba05, 0x00f1},
|
||||
{0xba20, 0x0065}, {0xba00, 0x00f1},
|
||||
};
|
||||
static struct validx tbl_post_unset_alt[] = {
|
||||
{0xba00, 0x00f0}, {0xba00, 0x00f1}, {0xbaa0, 0x0065}, {0xba00, 0x00f1},
|
||||
{0x0061, 0x0000}, {0x0068, 0x000d},
|
||||
};
|
||||
|
||||
static u8 *tbl_1280[] = {
|
||||
"\x0d\x80\xf1\x08\x03\x04\xf1\x00" "\x04\x05\xf1\x02\x05\x00\xf1\xf1"
|
||||
"\x06\x00\xf1\x0d\x20\x01\xf1\x00" "\x21\x84\xf1\x00\x0d\x00\xf1\x08"
|
||||
"\xf0\x00\xf1\x01\x34\x00\xf1\x00" "\x9b\x43\xf1\x00\xa6\x05\xf1\x00"
|
||||
"\xa9\x04\xf1\x00\xa1\x05\xf1\x00" "\xa4\x04\xf1\x00\xae\x0a\xf1\x08"
|
||||
,
|
||||
"\xf0\x00\xf1\x02\x3a\x05\xf1\xf1" "\x3c\x05\xf1\xf1\x59\x01\xf1\x47"
|
||||
"\x5a\x01\xf1\x88\x5c\x0a\xf1\x06" "\x5d\x0e\xf1\x0a\x64\x5e\xf1\x1c"
|
||||
"\xd2\x00\xf1\xcf\xcb\x00\xf1\x01"
|
||||
,
|
||||
"\xd3\x02\xd4\x28\xd5\x01\xd0\x02" "\xd1\x18\xd2\xc1"
|
||||
};
|
||||
|
||||
static u8 *tbl_800[] = {
|
||||
"\x0d\x80\xf1\x08\x03\x03\xf1\xc0" "\x04\x05\xf1\x02\x05\x00\xf1\xf1"
|
||||
"\x06\x00\xf1\x0d\x20\x01\xf1\x00" "\x21\x84\xf1\x00\x0d\x00\xf1\x08"
|
||||
"\xf0\x00\xf1\x01\x34\x00\xf1\x00" "\x9b\x43\xf1\x00\xa6\x05\xf1\x00"
|
||||
"\xa9\x03\xf1\xc0\xa1\x03\xf1\x20" "\xa4\x02\xf1\x5a\xae\x0a\xf1\x08"
|
||||
,
|
||||
"\xf0\x00\xf1\x02\x3a\x05\xf1\xf1" "\x3c\x05\xf1\xf1\x59\x01\xf1\x47"
|
||||
"\x5a\x01\xf1\x88\x5c\x0a\xf1\x06" "\x5d\x0e\xf1\x0a\x64\x5e\xf1\x1c"
|
||||
"\xd2\x00\xf1\xcf\xcb\x00\xf1\x01"
|
||||
,
|
||||
"\xd3\x02\xd4\x18\xd5\x21\xd0\x02" "\xd1\x10\xd2\x59"
|
||||
};
|
||||
|
||||
static u8 *tbl_640[] = {
|
||||
"\x0d\x80\xf1\x08\x03\x04\xf1\x04" "\x04\x05\xf1\x02\x07\x01\xf1\x7c"
|
||||
"\x08\x00\xf1\x0e\x21\x80\xf1\x00" "\x0d\x00\xf1\x08\xf0\x00\xf1\x01"
|
||||
"\x34\x10\xf1\x10\x3a\x43\xf1\x00" "\xa6\x05\xf1\x02\xa9\x04\xf1\x04"
|
||||
"\xa7\x02\xf1\x81\xaa\x01\xf1\xe2" "\xae\x0c\xf1\x09"
|
||||
,
|
||||
"\xf0\x00\xf1\x02\x39\x03\xf1\xfc" "\x3b\x04\xf1\x04\x57\x01\xf1\xb6"
|
||||
"\x58\x02\xf1\x0d\x5c\x1f\xf1\x19" "\x5d\x24\xf1\x1e\x64\x5e\xf1\x1c"
|
||||
"\xd2\x00\xf1\x00\xcb\x00\xf1\x01"
|
||||
,
|
||||
"\xd3\x02\xd4\x10\xd5\x81\xd0\x02" "\xd1\x08\xd2\xe1"
|
||||
};
|
||||
|
||||
static s32 tbl_sat[] = {0x25, 0x1d, 0x15, 0x0d, 0x05, 0x4d, 0x55, 0x5d, 0x2d};
|
||||
static s32 tbl_bright[] = {0, 8, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70};
|
||||
static s32 tbl_backlight[] = {0x0e, 0x06, 0x02};
|
||||
|
||||
static s32 tbl_cntr1[] = {
|
||||
0x90, 0x98, 0xa0, 0xa8, 0xb0, 0xb8, 0xc0, 0xc8, 0xd0, 0xe0, 0xf0};
|
||||
static s32 tbl_cntr2[] = {
|
||||
0x70, 0x68, 0x60, 0x58, 0x50, 0x48, 0x40, 0x38, 0x30, 0x20, 0x10};
|
||||
|
||||
static u8 dat_wbalNL[] =
|
||||
"\xf0\x00\xf1\x01\x05\x00\xf1\x06" "\x3b\x04\xf1\x2a\x47\x10\xf1\x10"
|
||||
"\x9d\x3c\xf1\xae\xaf\x10\xf1\x00" "\xf0\x00\xf1\x02\x2f\x91\xf1\x20"
|
||||
"\x9c\x91\xf1\x20\x37\x03\xf1\x00" "\x9d\xc5\xf1\x0f\xf0\x00\xf1\x00";
|
||||
|
||||
static u8 dat_wbalLL[] =
|
||||
"\xf0\x00\xf1\x01\x05\x00\xf1\x0c" "\x3b\x04\xf1\x2a\x47\x40\xf1\x40"
|
||||
"\x9d\x20\xf1\xae\xaf\x10\xf1\x00" "\xf0\x00\xf1\x02\x2f\xd1\xf1\x00"
|
||||
"\x9c\xd1\xf1\x00\x37\x03\xf1\x00" "\x9d\xc5\xf1\x3f\xf0\x00\xf1\x00";
|
||||
|
||||
static u8 dat_wbalBL[] =
|
||||
"\xf0\x00\xf1\x01\x05\x00\xf1\x06" "\x47\x10\xf1\x30\x9d\x3c\xf1\xae"
|
||||
"\xaf\x10\xf1\x00\xf0\x00\xf1\x02" "\x2f\x91\xf1\x20\x9c\x91\xf1\x20"
|
||||
"\x37\x03\xf1\x00\x9d\xc5\xf1\x2f" "\xf0\x00\xf1\x00";
|
||||
|
||||
static u8 dat_hvflip1[] = {0xf0, 0x00, 0xf1, 0x00};
|
||||
|
||||
static u8 s000[] =
|
||||
"\x00\x01\x07\x6a\x06\x63\x0d\x6a" "\xc0\x00\x10\x10\xc1\x03\xc2\x42"
|
||||
"\xd8\x04\x58\x00\x04\x02";
|
||||
static u8 s001[] =
|
||||
"\x0d\x00\xf1\x0b\x0d\x00\xf1\x08" "\x35\x00\xf1\x22\x68\x00\xf1\x5d"
|
||||
"\xf0\x00\xf1\x01\x06\x70\xf1\x0e" "\xf0\x00\xf1\x02\xdd\x18\xf1\xe0";
|
||||
static u8 s002[] =
|
||||
"\x05\x01\xf1\x84\x06\x00\xf1\x44" "\x07\x00\xf1\xbe\x08\x00\xf1\x1e"
|
||||
"\x20\x01\xf1\x03\x21\x84\xf1\x00" "\x22\x0d\xf1\x0f\x24\x80\xf1\x00"
|
||||
"\x34\x18\xf1\x2d\x35\x00\xf1\x22" "\x43\x83\xf1\x83\x59\x00\xf1\xff";
|
||||
static u8 s003[] =
|
||||
"\xf0\x00\xf1\x02\x39\x06\xf1\x8c" "\x3a\x06\xf1\x8c\x3b\x03\xf1\xda"
|
||||
"\x3c\x05\xf1\x30\x57\x01\xf1\x0c" "\x58\x01\xf1\x42\x59\x01\xf1\x0c"
|
||||
"\x5a\x01\xf1\x42\x5c\x13\xf1\x0e" "\x5d\x17\xf1\x12\x64\x1e\xf1\x1c";
|
||||
static u8 s004[] =
|
||||
"\xf0\x00\xf1\x02\x24\x5f\xf1\x20" "\x28\xea\xf1\x02\x5f\x41\xf1\x43";
|
||||
static u8 s005[] =
|
||||
"\x02\x00\xf1\xee\x03\x29\xf1\x1a" "\x04\x02\xf1\xa4\x09\x00\xf1\x68"
|
||||
"\x0a\x00\xf1\x2a\x0b\x00\xf1\x04" "\x0c\x00\xf1\x93\x0d\x00\xf1\x82"
|
||||
"\x0e\x00\xf1\x40\x0f\x00\xf1\x5f" "\x10\x00\xf1\x4e\x11\x00\xf1\x5b";
|
||||
static u8 s006[] =
|
||||
"\x15\x00\xf1\xc9\x16\x00\xf1\x5e" "\x17\x00\xf1\x9d\x18\x00\xf1\x06"
|
||||
"\x19\x00\xf1\x89\x1a\x00\xf1\x12" "\x1b\x00\xf1\xa1\x1c\x00\xf1\xe4"
|
||||
"\x1d\x00\xf1\x7a\x1e\x00\xf1\x64" "\xf6\x00\xf1\x5f";
|
||||
static u8 s007[] =
|
||||
"\xf0\x00\xf1\x01\x53\x09\xf1\x03" "\x54\x3d\xf1\x1c\x55\x99\xf1\x72"
|
||||
"\x56\xc1\xf1\xb1\x57\xd8\xf1\xce" "\x58\xe0\xf1\x00\xdc\x0a\xf1\x03"
|
||||
"\xdd\x45\xf1\x20\xde\xae\xf1\x82" "\xdf\xdc\xf1\xc9\xe0\xf6\xf1\xea"
|
||||
"\xe1\xff\xf1\x00";
|
||||
static u8 s008[] =
|
||||
"\xf0\x00\xf1\x01\x80\x00\xf1\x06" "\x81\xf6\xf1\x08\x82\xfb\xf1\xf7"
|
||||
"\x83\x00\xf1\xfe\xb6\x07\xf1\x03" "\xb7\x18\xf1\x0c\x84\xfb\xf1\x06"
|
||||
"\x85\xfb\xf1\xf9\x86\x00\xf1\xff" "\xb8\x07\xf1\x04\xb9\x16\xf1\x0a";
|
||||
static u8 s009[] =
|
||||
"\x87\xfa\xf1\x05\x88\xfc\xf1\xf9" "\x89\x00\xf1\xff\xba\x06\xf1\x03"
|
||||
"\xbb\x17\xf1\x09\x8a\xe8\xf1\x14" "\x8b\xf7\xf1\xf0\x8c\xfd\xf1\xfa"
|
||||
"\x8d\x00\xf1\x00\xbc\x05\xf1\x01" "\xbd\x0c\xf1\x08\xbe\x00\xf1\x14";
|
||||
static u8 s010[] =
|
||||
"\x8e\xea\xf1\x13\x8f\xf7\xf1\xf2" "\x90\xfd\xf1\xfa\x91\x00\xf1\x00"
|
||||
"\xbf\x05\xf1\x01\xc0\x0a\xf1\x08" "\xc1\x00\xf1\x0c\x92\xed\xf1\x0f"
|
||||
"\x93\xf9\xf1\xf4\x94\xfe\xf1\xfb" "\x95\x00\xf1\x00\xc2\x04\xf1\x01"
|
||||
"\xc3\x0a\xf1\x07\xc4\x00\xf1\x10";
|
||||
static u8 s011[] =
|
||||
"\xf0\x00\xf1\x01\x05\x00\xf1\x06" "\x25\x00\xf1\x55\x34\x10\xf1\x10"
|
||||
"\x35\xf0\xf1\x10\x3a\x02\xf1\x03" "\x3b\x04\xf1\x2a\x9b\x43\xf1\x00"
|
||||
"\xa4\x03\xf1\xc0\xa7\x02\xf1\x81";
|
||||
|
||||
static int mi1320_init_at_startup(struct gspca_dev *gspca_dev);
|
||||
static int mi1320_configure_alt(struct gspca_dev *gspca_dev);
|
||||
static int mi1320_init_pre_alt(struct gspca_dev *gspca_dev);
|
||||
static int mi1320_init_post_alt(struct gspca_dev *gspca_dev);
|
||||
static void mi1320_post_unset_alt(struct gspca_dev *gspca_dev);
|
||||
static int mi1320_sensor_settings(struct gspca_dev *gspca_dev);
|
||||
static int mi1320_camera_settings(struct gspca_dev *gspca_dev);
|
||||
/*==========================================================================*/
|
||||
|
||||
void mi1320_init_settings(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
|
||||
sd->vcur.backlight = 0;
|
||||
sd->vcur.brightness = 0;
|
||||
sd->vcur.sharpness = 6;
|
||||
sd->vcur.contrast = 10;
|
||||
sd->vcur.gamma = 20;
|
||||
sd->vcur.hue = 0;
|
||||
sd->vcur.saturation = 6;
|
||||
sd->vcur.whitebal = 0;
|
||||
sd->vcur.mirror = 0;
|
||||
sd->vcur.flip = 0;
|
||||
sd->vcur.AC50Hz = 1;
|
||||
|
||||
sd->vmax.backlight = 2;
|
||||
sd->vmax.brightness = 8;
|
||||
sd->vmax.sharpness = 7;
|
||||
sd->vmax.contrast = 0; /* 10 but not working with tihs driver */
|
||||
sd->vmax.gamma = 40;
|
||||
sd->vmax.hue = 5 + 1;
|
||||
sd->vmax.saturation = 8;
|
||||
sd->vmax.whitebal = 2;
|
||||
sd->vmax.mirror = 1;
|
||||
sd->vmax.flip = 1;
|
||||
sd->vmax.AC50Hz = 1;
|
||||
|
||||
sd->dev_camera_settings = mi1320_camera_settings;
|
||||
sd->dev_init_at_startup = mi1320_init_at_startup;
|
||||
sd->dev_configure_alt = mi1320_configure_alt;
|
||||
sd->dev_init_pre_alt = mi1320_init_pre_alt;
|
||||
sd->dev_post_unset_alt = mi1320_post_unset_alt;
|
||||
}
|
||||
|
||||
/*==========================================================================*/
|
||||
|
||||
static void common(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
s32 n; /* reserved for FETCH macros */
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 22, s000);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x0000, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 32, s001);
|
||||
n = fetch_validx(gspca_dev, tbl_common, ARRAY_SIZE(tbl_common));
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 48, s002);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 48, s003);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 16, s004);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 48, s005);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 44, s006);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_common,
|
||||
ARRAY_SIZE(tbl_common), n);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 52, s007);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 48, s008);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 48, s009);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 56, s010);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_common,
|
||||
ARRAY_SIZE(tbl_common), n);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 40, s011);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_common,
|
||||
ARRAY_SIZE(tbl_common), n);
|
||||
}
|
||||
|
||||
static int mi1320_init_at_startup(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
fetch_validx(gspca_dev, tbl_init_at_startup,
|
||||
ARRAY_SIZE(tbl_init_at_startup));
|
||||
|
||||
common(gspca_dev);
|
||||
|
||||
/* ctrl_out(gspca_dev, 0x40, 11, 0x0000, 0x0000, 0, NULL); */
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mi1320_init_pre_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
|
||||
sd->mirrorMask = 0;
|
||||
|
||||
sd->vold.backlight = -1;
|
||||
sd->vold.brightness = -1;
|
||||
sd->vold.sharpness = -1;
|
||||
sd->vold.contrast = -1;
|
||||
sd->vold.saturation = -1;
|
||||
sd->vold.gamma = -1;
|
||||
sd->vold.hue = -1;
|
||||
sd->vold.whitebal = -1;
|
||||
sd->vold.mirror = -1;
|
||||
sd->vold.flip = -1;
|
||||
sd->vold.AC50Hz = -1;
|
||||
|
||||
common(gspca_dev);
|
||||
|
||||
mi1320_sensor_settings(gspca_dev);
|
||||
|
||||
mi1320_init_post_alt(gspca_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mi1320_init_post_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
mi1320_camera_settings(gspca_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mi1320_sensor_settings(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 5, 0x0001, 0x0000, 0, NULL);
|
||||
|
||||
fetch_validx(gspca_dev, tbl_sensor_settings_common,
|
||||
ARRAY_SIZE(tbl_sensor_settings_common));
|
||||
|
||||
switch (reso) {
|
||||
case IMAGE_1280:
|
||||
fetch_validx(gspca_dev, tbl_sensor_settings_1280,
|
||||
ARRAY_SIZE(tbl_sensor_settings_1280));
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 64, tbl_1280[0]);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 40, tbl_1280[1]);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, tbl_1280[2]);
|
||||
break;
|
||||
|
||||
case IMAGE_800:
|
||||
fetch_validx(gspca_dev, tbl_sensor_settings_800,
|
||||
ARRAY_SIZE(tbl_sensor_settings_800));
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 64, tbl_800[0]);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 40, tbl_800[1]);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, tbl_800[2]);
|
||||
break;
|
||||
|
||||
default:
|
||||
fetch_validx(gspca_dev, tbl_sensor_settings_640,
|
||||
ARRAY_SIZE(tbl_sensor_settings_640));
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 60, tbl_640[0]);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 40, tbl_640[1]);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, tbl_640[2]);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mi1320_configure_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
|
||||
|
||||
switch (reso) {
|
||||
case IMAGE_640:
|
||||
gspca_dev->alt = 3 + 1;
|
||||
break;
|
||||
|
||||
case IMAGE_800:
|
||||
case IMAGE_1280:
|
||||
gspca_dev->alt = 1 + 1;
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mi1320_camera_settings(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
|
||||
s32 backlight = sd->vcur.backlight;
|
||||
s32 bright = sd->vcur.brightness;
|
||||
s32 sharp = sd->vcur.sharpness;
|
||||
s32 cntr = sd->vcur.contrast;
|
||||
s32 gam = sd->vcur.gamma;
|
||||
s32 hue = sd->vcur.hue;
|
||||
s32 sat = sd->vcur.saturation;
|
||||
s32 wbal = sd->vcur.whitebal;
|
||||
s32 mirror = (((sd->vcur.mirror > 0) ^ sd->mirrorMask) > 0);
|
||||
s32 flip = (((sd->vcur.flip > 0) ^ sd->mirrorMask) > 0);
|
||||
s32 freq = (sd->vcur.AC50Hz > 0);
|
||||
s32 i;
|
||||
|
||||
if (freq != sd->vold.AC50Hz) {
|
||||
sd->vold.AC50Hz = freq;
|
||||
|
||||
freq = 2 * (freq == 0);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba02, 0x00f1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00 , 0x005b, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba01 + freq, 0x00f1, 0, NULL);
|
||||
}
|
||||
|
||||
if (wbal != sd->vold.whitebal) {
|
||||
sd->vold.whitebal = wbal;
|
||||
if (wbal < 0 || wbal > sd->vmax.whitebal)
|
||||
wbal = 0;
|
||||
|
||||
for (i = 0; i < 2; i++) {
|
||||
if (wbal == 0) { /* Normal light */
|
||||
ctrl_out(gspca_dev, 0x40, 1,
|
||||
0x0010, 0x0010, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1,
|
||||
0x0003, 0x00c1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1,
|
||||
0x0042, 0x00c2, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 3,
|
||||
0xba00, 0x0200, 48, dat_wbalNL);
|
||||
}
|
||||
|
||||
if (wbal == 1) { /* Low light */
|
||||
ctrl_out(gspca_dev, 0x40, 1,
|
||||
0x0010, 0x0010, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1,
|
||||
0x0004, 0x00c1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1,
|
||||
0x0043, 0x00c2, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 3,
|
||||
0xba00, 0x0200, 48, dat_wbalLL);
|
||||
}
|
||||
|
||||
if (wbal == 2) { /* Back light */
|
||||
ctrl_out(gspca_dev, 0x40, 1,
|
||||
0x0010, 0x0010, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1,
|
||||
0x0003, 0x00c1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1,
|
||||
0x0042, 0x00c2, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 3,
|
||||
0xba00, 0x0200, 44, dat_wbalBL);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (bright != sd->vold.brightness) {
|
||||
sd->vold.brightness = bright;
|
||||
if (bright < 0 || bright > sd->vmax.brightness)
|
||||
bright = 0;
|
||||
|
||||
bright = tbl_bright[bright];
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00 + bright, 0x0034, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00 + bright, 0x00f1, 0, NULL);
|
||||
}
|
||||
|
||||
if (sat != sd->vold.saturation) {
|
||||
sd->vold.saturation = sat;
|
||||
if (sat < 0 || sat > sd->vmax.saturation)
|
||||
sat = 0;
|
||||
|
||||
sat = tbl_sat[sat];
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00 , 0x0025, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00 + sat, 0x00f1, 0, NULL);
|
||||
}
|
||||
|
||||
if (sharp != sd->vold.sharpness) {
|
||||
sd->vold.sharpness = sharp;
|
||||
if (sharp < 0 || sharp > sd->vmax.sharpness)
|
||||
sharp = 0;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00 , 0x0005, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00 + sharp, 0x00f1, 0, NULL);
|
||||
}
|
||||
|
||||
if (hue != sd->vold.hue) {
|
||||
/* 0=normal 1=NB 2="sepia" 3=negative 4=other 5=other2 */
|
||||
if (hue < 0 || hue > sd->vmax.hue)
|
||||
hue = 0;
|
||||
if (hue == sd->vmax.hue)
|
||||
sd->swapRB = 1;
|
||||
else
|
||||
sd->swapRB = 0;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba70, 0x00e2, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00 + hue * (hue < 6), 0x00f1,
|
||||
0, NULL);
|
||||
}
|
||||
|
||||
if (backlight != sd->vold.backlight) {
|
||||
sd->vold.backlight = backlight;
|
||||
if (backlight < 0 || backlight > sd->vmax.backlight)
|
||||
backlight = 0;
|
||||
|
||||
backlight = tbl_backlight[backlight];
|
||||
for (i = 0; i < 2; i++) {
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba74, 0x0006, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba80 + backlight, 0x00f1,
|
||||
0, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
if (hue != sd->vold.hue) {
|
||||
sd->vold.hue = hue;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba70, 0x00e2, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00 + hue * (hue < 6), 0x00f1,
|
||||
0, NULL);
|
||||
}
|
||||
|
||||
if (mirror != sd->vold.mirror || flip != sd->vold.flip) {
|
||||
u8 dat_hvflip2[4] = {0x20, 0x01, 0xf1, 0x00};
|
||||
sd->vold.mirror = mirror;
|
||||
sd->vold.flip = flip;
|
||||
|
||||
dat_hvflip2[3] = flip + 2 * mirror;
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 4, dat_hvflip1);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0xba00, 0x0200, 4, dat_hvflip2);
|
||||
}
|
||||
|
||||
if (gam != sd->vold.gamma) {
|
||||
sd->vold.gamma = gam;
|
||||
if (gam < 0 || gam > sd->vmax.gamma)
|
||||
gam = 0;
|
||||
|
||||
gam = 2 * gam;
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba04 , 0x003b, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba02 + gam, 0x00f1, 0, NULL);
|
||||
}
|
||||
|
||||
if (cntr != sd->vold.contrast) {
|
||||
sd->vold.contrast = cntr;
|
||||
if (cntr < 0 || cntr > sd->vmax.contrast)
|
||||
cntr = 0;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00, 0x00f0, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba01, 0x00f1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00 + tbl_cntr1[cntr], 0x0035,
|
||||
0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0xba00 + tbl_cntr2[cntr], 0x00f1,
|
||||
0, NULL);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void mi1320_post_unset_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
ctrl_out(gspca_dev, 0x40, 5, 0x0000, 0x0000, 0, NULL);
|
||||
|
||||
fetch_validx(gspca_dev, tbl_post_unset_alt,
|
||||
ARRAY_SIZE(tbl_post_unset_alt));
|
||||
}
|
||||
|
|
@ -0,0 +1,937 @@
|
|||
/* @file gl860-mi2020.c
|
||||
* @author Olivier LORIN, from Ice/Soro2005's logs(A), Fret_saw/Hulkie's
|
||||
* logs(B) and Tricid"s logs(C). With the help of Kytrix/BUGabundo/Blazercist.
|
||||
* @date 2009-08-27
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/* Sensor : MI2020 */
|
||||
|
||||
#include "gl860.h"
|
||||
|
||||
static u8 dat_bright1[] = {0x8c, 0xa2, 0x06};
|
||||
static u8 dat_bright3[] = {0x8c, 0xa1, 0x02};
|
||||
static u8 dat_bright4[] = {0x90, 0x00, 0x0f};
|
||||
static u8 dat_bright5[] = {0x8c, 0xa1, 0x03};
|
||||
static u8 dat_bright6[] = {0x90, 0x00, 0x05};
|
||||
|
||||
static u8 dat_dummy1[] = {0x90, 0x00, 0x06};
|
||||
/*static u8 dummy2[] = {0x8c, 0xa1, 0x02};*/
|
||||
/*static u8 dummy3[] = {0x90, 0x00, 0x1f};*/
|
||||
|
||||
static u8 dat_hvflip1[] = {0x8c, 0x27, 0x19};
|
||||
static u8 dat_hvflip3[] = {0x8c, 0x27, 0x3b};
|
||||
static u8 dat_hvflip5[] = {0x8c, 0xa1, 0x03};
|
||||
static u8 dat_hvflip6[] = {0x90, 0x00, 0x06};
|
||||
|
||||
static u8 dat_freq1[] = { 0x8c, 0xa4, 0x04 };
|
||||
|
||||
static u8 dat_multi5[] = { 0x8c, 0xa1, 0x03 };
|
||||
static u8 dat_multi6[] = { 0x90, 0x00, 0x05 };
|
||||
|
||||
static struct validx tbl_common_a[] = {
|
||||
{0x0000, 0x0000},
|
||||
{1, 0xffff}, /* msleep(35); */
|
||||
{0x006a, 0x0007}, {0x0063, 0x0006}, {0x006a, 0x000d}, {0x0000, 0x00c0},
|
||||
{0x0010, 0x0010}, {0x0003, 0x00c1}, {0x0042, 0x00c2}, {0x0004, 0x00d8},
|
||||
{0x0000, 0x0058}, {0x0002, 0x0004}, {0x0041, 0x0000},
|
||||
};
|
||||
|
||||
static struct validx tbl_common_b[] = {
|
||||
{0x006a, 0x0007},
|
||||
{35, 0xffff},
|
||||
{0x00ef, 0x0006},
|
||||
{35, 0xffff},
|
||||
{0x006a, 0x000d},
|
||||
{35, 0xffff},
|
||||
{0x0000, 0x00c0}, {0x0010, 0x0010}, {0x0003, 0x00c1}, {0x0042, 0x00c2},
|
||||
{0x0004, 0x00d8}, {0x0000, 0x0058}, {0x0041, 0x0000},
|
||||
};
|
||||
|
||||
static struct idxdata tbl_common_c[] = {
|
||||
{0x32, "\x02\x00\x08"}, {0x33, "\xf4\x03\x1d"},
|
||||
{6, "\xff\xff\xff"}, /* 12 */
|
||||
{0x34, "\x1e\x8f\x09"}, {0x34, "\x1c\x01\x28"}, {0x34, "\x1e\x8f\x09"},
|
||||
{2, "\xff\xff\xff"}, /* - */
|
||||
{0x34, "\x1e\x8f\x09"}, {0x32, "\x14\x06\xe6"}, {0x33, "\x8c\x22\x23"},
|
||||
{0x33, "\x90\x00\x00"}, {0x33, "\x8c\xa2\x0f"}, {0x33, "\x90\x00\x0d"},
|
||||
{0x33, "\x8c\xa2\x10"}, {0x33, "\x90\x00\x0b"}, {0x33, "\x8c\xa2\x11"},
|
||||
{0x33, "\x90\x00\x07"}, {0x33, "\xf4\x03\x1d"}, {0x35, "\xa2\x00\xe2"},
|
||||
{0x33, "\x8c\xab\x05"}, {0x33, "\x90\x00\x01"}, {0x32, "\x6e\x00\x86"},
|
||||
{0x32, "\x70\x0f\xaa"}, {0x32, "\x72\x0f\xe4"}, {0x33, "\x8c\xa3\x4a"},
|
||||
{0x33, "\x90\x00\x5a"}, {0x33, "\x8c\xa3\x4b"}, {0x33, "\x90\x00\xa6"},
|
||||
{0x33, "\x8c\xa3\x61"}, {0x33, "\x90\x00\xc8"}, {0x33, "\x8c\xa3\x62"},
|
||||
{0x33, "\x90\x00\xe1"}, {0x34, "\xce\x01\xa8"}, {0x34, "\xd0\x66\x33"},
|
||||
{0x34, "\xd2\x31\x9a"}, {0x34, "\xd4\x94\x63"}, {0x34, "\xd6\x4b\x25"},
|
||||
{0x34, "\xd8\x26\x70"}, {0x34, "\xda\x72\x4c"}, {0x34, "\xdc\xff\x04"},
|
||||
{0x34, "\xde\x01\x5b"}, {0x34, "\xe6\x01\x13"}, {0x34, "\xee\x0b\xf0"},
|
||||
{0x34, "\xf6\x0b\xa4"}, {0x35, "\x00\xf6\xe7"}, {0x35, "\x08\x0d\xfd"},
|
||||
{0x35, "\x10\x25\x63"}, {0x35, "\x18\x35\x6c"}, {0x35, "\x20\x42\x7e"},
|
||||
{0x35, "\x28\x19\x44"}, {0x35, "\x30\x39\xd4"}, {0x35, "\x38\xf5\xa8"},
|
||||
{0x35, "\x4c\x07\x90"}, {0x35, "\x44\x07\xb8"}, {0x35, "\x5c\x06\x88"},
|
||||
{0x35, "\x54\x07\xff"}, {0x34, "\xe0\x01\x52"}, {0x34, "\xe8\x00\xcc"},
|
||||
{0x34, "\xf0\x0d\x83"}, {0x34, "\xf8\x0c\xb3"}, {0x35, "\x02\xfe\xba"},
|
||||
{0x35, "\x0a\x04\xe0"}, {0x35, "\x12\x1c\x63"}, {0x35, "\x1a\x2b\x5a"},
|
||||
{0x35, "\x22\x32\x5e"}, {0x35, "\x2a\x0d\x28"}, {0x35, "\x32\x2c\x02"},
|
||||
{0x35, "\x3a\xf4\xfa"}, {0x35, "\x4e\x07\xef"}, {0x35, "\x46\x07\x88"},
|
||||
{0x35, "\x5e\x07\xc1"}, {0x35, "\x56\x04\x64"}, {0x34, "\xe4\x01\x15"},
|
||||
{0x34, "\xec\x00\x82"}, {0x34, "\xf4\x0c\xce"}, {0x34, "\xfc\x0c\xba"},
|
||||
{0x35, "\x06\x1f\x02"}, {0x35, "\x0e\x02\xe3"}, {0x35, "\x16\x1a\x50"},
|
||||
{0x35, "\x1e\x24\x39"}, {0x35, "\x26\x23\x4c"}, {0x35, "\x2e\xf9\x1b"},
|
||||
{0x35, "\x36\x23\x19"}, {0x35, "\x3e\x12\x08"}, {0x35, "\x52\x07\x22"},
|
||||
{0x35, "\x4a\x03\xd3"}, {0x35, "\x62\x06\x54"}, {0x35, "\x5a\x04\x5d"},
|
||||
{0x34, "\xe2\x01\x04"}, {0x34, "\xea\x00\xa0"}, {0x34, "\xf2\x0c\xbc"},
|
||||
{0x34, "\xfa\x0c\x5b"}, {0x35, "\x04\x17\xf2"}, {0x35, "\x0c\x02\x08"},
|
||||
{0x35, "\x14\x28\x43"}, {0x35, "\x1c\x28\x62"}, {0x35, "\x24\x2b\x60"},
|
||||
{0x35, "\x2c\x07\x33"}, {0x35, "\x34\x1f\xb0"}, {0x35, "\x3c\xed\xcd"},
|
||||
{0x35, "\x50\x00\x06"}, {0x35, "\x48\x07\xff"}, {0x35, "\x60\x05\x89"},
|
||||
{0x35, "\x58\x07\xff"}, {0x35, "\x40\x00\xa0"}, {0x35, "\x42\x00\x00"},
|
||||
{0x32, "\x10\x01\xfc"}, {0x33, "\x8c\xa1\x18"}, {0x33, "\x90\x00\x3c"},
|
||||
{1, "\xff\xff\xff"},
|
||||
{0x33, "\x78\x00\x00"},
|
||||
{1, "\xff\xff\xff"},
|
||||
{0x35, "\xb8\x1f\x20"}, {0x33, "\x8c\xa2\x06"}, {0x33, "\x90\x00\x10"},
|
||||
{0x33, "\x8c\xa2\x07"}, {0x33, "\x90\x00\x08"}, {0x33, "\x8c\xa2\x42"},
|
||||
{0x33, "\x90\x00\x0b"}, {0x33, "\x8c\xa2\x4a"}, {0x33, "\x90\x00\x8c"},
|
||||
{0x35, "\xba\xfa\x08"}, {0x33, "\x8c\xa2\x02"}, {0x33, "\x90\x00\x22"},
|
||||
{0x33, "\x8c\xa2\x03"}, {0x33, "\x90\x00\xbb"},
|
||||
};
|
||||
|
||||
static struct idxdata tbl_common_d[] = {
|
||||
{0x33, "\x8c\x22\x2e"}, {0x33, "\x90\x00\xa0"}, {0x33, "\x8c\xa4\x08"},
|
||||
{0x33, "\x90\x00\x1f"}, {0x33, "\x8c\xa4\x09"}, {0x33, "\x90\x00\x21"},
|
||||
{0x33, "\x8c\xa4\x0a"}, {0x33, "\x90\x00\x25"}, {0x33, "\x8c\xa4\x0b"},
|
||||
{0x33, "\x90\x00\x27"}, {0x33, "\x8c\x24\x11"}, {0x33, "\x90\x00\xa0"},
|
||||
{0x33, "\x8c\x24\x13"}, {0x33, "\x90\x00\xc0"}, {0x33, "\x8c\x24\x15"},
|
||||
{0x33, "\x90\x00\xa0"}, {0x33, "\x8c\x24\x17"}, {0x33, "\x90\x00\xc0"},
|
||||
};
|
||||
|
||||
static struct idxdata tbl_common_e[] = {
|
||||
{0x33, "\x8c\xa4\x04"}, {0x33, "\x90\x00\x80"}, {0x33, "\x8c\xa7\x9d"},
|
||||
{0x33, "\x90\x00\x00"}, {0x33, "\x8c\xa7\x9e"}, {0x33, "\x90\x00\x00"},
|
||||
{0x33, "\x8c\xa2\x0c"}, {0x33, "\x90\x00\x17"}, {0x33, "\x8c\xa2\x15"},
|
||||
{0x33, "\x90\x00\x04"}, {0x33, "\x8c\xa2\x14"}, {0x33, "\x90\x00\x20"},
|
||||
{0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x17"},
|
||||
/* msleep(53); */
|
||||
{0x33, "\x90\x21\x11"}, {0x33, "\x8c\x27\x1b"}, {0x33, "\x90\x02\x4f"},
|
||||
{0x33, "\x8c\x27\x25"}, {0x33, "\x90\x06\x0f"}, {0x33, "\x8c\x27\x39"},
|
||||
{0x33, "\x90\x21\x11"}, {0x33, "\x8c\x27\x3d"}, {0x33, "\x90\x01\x20"},
|
||||
{0x33, "\x8c\x27\x47"}, {0x33, "\x90\x09\x4c"}, {0x33, "\x8c\x27\x03"},
|
||||
{0x33, "\x90\x02\x84"}, {0x33, "\x8c\x27\x05"}, {0x33, "\x90\x01\xe2"},
|
||||
{0x33, "\x8c\x27\x07"}, {0x33, "\x90\x06\x40"}, {0x33, "\x8c\x27\x09"},
|
||||
{0x33, "\x90\x04\xb0"}, {0x33, "\x8c\x27\x0d"}, {0x33, "\x90\x00\x00"},
|
||||
{0x33, "\x8c\x27\x0f"}, {0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x11"},
|
||||
{0x33, "\x90\x04\xbd"}, {0x33, "\x8c\x27\x13"}, {0x33, "\x90\x06\x4d"},
|
||||
{0x33, "\x8c\x27\x15"}, {0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x17"},
|
||||
{0x33, "\x90\x21\x11"}, {0x33, "\x8c\x27\x19"}, {0x33, "\x90\x04\x6c"},
|
||||
{0x33, "\x8c\x27\x1b"}, {0x33, "\x90\x02\x4f"}, {0x33, "\x8c\x27\x1d"},
|
||||
{0x33, "\x90\x01\x02"}, {0x33, "\x8c\x27\x1f"}, {0x33, "\x90\x02\x79"},
|
||||
{0x33, "\x8c\x27\x21"}, {0x33, "\x90\x01\x55"}, {0x33, "\x8c\x27\x23"},
|
||||
{0x33, "\x90\x02\x85"}, {0x33, "\x8c\x27\x25"}, {0x33, "\x90\x06\x0f"},
|
||||
{0x33, "\x8c\x27\x27"}, {0x33, "\x90\x20\x20"}, {0x33, "\x8c\x27\x29"},
|
||||
{0x33, "\x90\x20\x20"}, {0x33, "\x8c\x27\x2b"}, {0x33, "\x90\x10\x20"},
|
||||
{0x33, "\x8c\x27\x2d"}, {0x33, "\x90\x20\x07"}, {0x33, "\x8c\x27\x2f"},
|
||||
{0x33, "\x90\x00\x04"}, {0x33, "\x8c\x27\x31"}, {0x33, "\x90\x00\x04"},
|
||||
{0x33, "\x8c\x27\x33"}, {0x33, "\x90\x04\xbb"}, {0x33, "\x8c\x27\x35"},
|
||||
{0x33, "\x90\x06\x4b"}, {0x33, "\x8c\x27\x37"}, {0x33, "\x90\x00\x00"},
|
||||
{0x33, "\x8c\x27\x39"}, {0x33, "\x90\x21\x11"}, {0x33, "\x8c\x27\x3b"},
|
||||
{0x33, "\x90\x00\x24"}, {0x33, "\x8c\x27\x3d"}, {0x33, "\x90\x01\x20"},
|
||||
{0x33, "\x8c\x27\x41"}, {0x33, "\x90\x01\x69"}, {0x33, "\x8c\x27\x45"},
|
||||
{0x33, "\x90\x04\xed"}, {0x33, "\x8c\x27\x47"}, {0x33, "\x90\x09\x4c"},
|
||||
{0x33, "\x8c\x27\x51"}, {0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x53"},
|
||||
{0x33, "\x90\x03\x20"}, {0x33, "\x8c\x27\x55"}, {0x33, "\x90\x00\x00"},
|
||||
{0x33, "\x8c\x27\x57"}, {0x33, "\x90\x02\x58"}, {0x33, "\x8c\x27\x5f"},
|
||||
{0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x61"}, {0x33, "\x90\x06\x40"},
|
||||
{0x33, "\x8c\x27\x63"}, {0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x65"},
|
||||
{0x33, "\x90\x04\xb0"}, {0x33, "\x8c\x22\x2e"}, {0x33, "\x90\x00\xa1"},
|
||||
{0x33, "\x8c\xa4\x08"}, {0x33, "\x90\x00\x1f"}, {0x33, "\x8c\xa4\x09"},
|
||||
{0x33, "\x90\x00\x21"}, {0x33, "\x8c\xa4\x0a"}, {0x33, "\x90\x00\x25"},
|
||||
{0x33, "\x8c\xa4\x0b"}, {0x33, "\x90\x00\x27"}, {0x33, "\x8c\x24\x11"},
|
||||
{0x33, "\x90\x00\xa1"}, {0x33, "\x8c\x24\x13"}, {0x33, "\x90\x00\xc1"},
|
||||
{0x33, "\x8c\x24\x15"},
|
||||
};
|
||||
|
||||
static struct validx tbl_init_at_startup[] = {
|
||||
{0x0000, 0x0000},
|
||||
{53, 0xffff},
|
||||
{0x0010, 0x0010},
|
||||
{53, 0xffff},
|
||||
{0x0008, 0x00c0},
|
||||
{53, 0xffff},
|
||||
{0x0001, 0x00c1},
|
||||
{53, 0xffff},
|
||||
{0x0001, 0x00c2},
|
||||
{53, 0xffff},
|
||||
{0x0020, 0x0006},
|
||||
{53, 0xffff},
|
||||
{0x006a, 0x000d},
|
||||
{53, 0xffff},
|
||||
};
|
||||
|
||||
static struct idxdata tbl_init_post_alt_low_a[] = {
|
||||
{0x33, "\x8c\x27\x15"}, {0x33, "\x90\x00\x25"}, {0x33, "\x8c\x22\x2e"},
|
||||
{0x33, "\x90\x00\x81"}, {0x33, "\x8c\xa4\x08"}, {0x33, "\x90\x00\x17"},
|
||||
{0x33, "\x8c\xa4\x09"}, {0x33, "\x90\x00\x1a"}, {0x33, "\x8c\xa4\x0a"},
|
||||
{0x33, "\x90\x00\x1d"}, {0x33, "\x8c\xa4\x0b"}, {0x33, "\x90\x00\x20"},
|
||||
{0x33, "\x8c\x24\x11"}, {0x33, "\x90\x00\x81"}, {0x33, "\x8c\x24\x13"},
|
||||
{0x33, "\x90\x00\x9b"},
|
||||
};
|
||||
|
||||
static struct idxdata tbl_init_post_alt_low_b[] = {
|
||||
{0x33, "\x8c\x27\x03"}, {0x33, "\x90\x03\x24"}, {0x33, "\x8c\x27\x05"},
|
||||
{0x33, "\x90\x02\x58"}, {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x05"},
|
||||
{2, "\xff\xff\xff"},
|
||||
{0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x06"},
|
||||
{2, "\xff\xff\xff"},
|
||||
};
|
||||
|
||||
static struct idxdata tbl_init_post_alt_low_c[] = {
|
||||
{0x34, "\x1e\x8f\x09"}, {0x34, "\x1c\x01\x28"}, {0x34, "\x1e\x8f\x09"},
|
||||
{2, "\xff\xff\xff"},
|
||||
{0x34, "\x1e\x8f\x09"}, {0x32, "\x14\x06\xe6"}, {0x33, "\x8c\xa1\x20"},
|
||||
{0x33, "\x90\x00\x00"}, {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x01"},
|
||||
{0x33, "\x2e\x01\x00"}, {0x34, "\x04\x00\x2a"}, {0x33, "\x8c\xa7\x02"},
|
||||
{0x33, "\x90\x00\x00"}, {0x33, "\x8c\x27\x95"}, {0x33, "\x90\x01\x00"},
|
||||
{2, "\xff\xff\xff"},
|
||||
{0x33, "\x8c\xa1\x20"}, {0x33, "\x90\x00\x72"}, {0x33, "\x8c\xa1\x03"},
|
||||
{0x33, "\x90\x00\x02"}, {0x33, "\x8c\xa7\x02"}, {0x33, "\x90\x00\x01"},
|
||||
{2, "\xff\xff\xff"},
|
||||
{0x33, "\x8c\xa1\x20"}, {0x33, "\x90\x00\x00"}, {0x33, "\x8c\xa1\x03"},
|
||||
{0x33, "\x90\x00\x01"}, {0x33, "\x8c\xa7\x02"}, {0x33, "\x90\x00\x00"},
|
||||
{2, "\xff\xff\xff"}, /* - * */
|
||||
{0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x05"},
|
||||
{2, "\xff\xff\xff"},
|
||||
{0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x06"},
|
||||
{2, "\xff\xff\xff"},
|
||||
{0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x05"},
|
||||
{2, "\xff\xff\xff"},
|
||||
{0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x06"},
|
||||
{1, "\xff\xff\xff"},
|
||||
};
|
||||
|
||||
static struct idxdata tbl_init_post_alt_low_d[] = {
|
||||
{0x32, "\x10\x01\xf8"}, {0x34, "\xce\x01\xa8"}, {0x34, "\xd0\x66\x33"},
|
||||
{0x34, "\xd2\x31\x9a"}, {0x34, "\xd4\x94\x63"}, {0x34, "\xd6\x4b\x25"},
|
||||
{0x34, "\xd8\x26\x70"}, {0x34, "\xda\x72\x4c"}, {0x34, "\xdc\xff\x04"},
|
||||
{0x34, "\xde\x01\x5b"}, {0x34, "\xe6\x01\x13"}, {0x34, "\xee\x0b\xf0"},
|
||||
{0x34, "\xf6\x0b\xa4"}, {0x35, "\x00\xf6\xe7"}, {0x35, "\x08\x0d\xfd"},
|
||||
{0x35, "\x10\x25\x63"}, {0x35, "\x18\x35\x6c"}, {0x35, "\x20\x42\x7e"},
|
||||
{0x35, "\x28\x19\x44"}, {0x35, "\x30\x39\xd4"}, {0x35, "\x38\xf5\xa8"},
|
||||
{0x35, "\x4c\x07\x90"}, {0x35, "\x44\x07\xb8"}, {0x35, "\x5c\x06\x88"},
|
||||
{0x35, "\x54\x07\xff"}, {0x34, "\xe0\x01\x52"}, {0x34, "\xe8\x00\xcc"},
|
||||
{0x34, "\xf0\x0d\x83"}, {0x34, "\xf8\x0c\xb3"}, {0x35, "\x02\xfe\xba"},
|
||||
{0x35, "\x0a\x04\xe0"}, {0x35, "\x12\x1c\x63"}, {0x35, "\x1a\x2b\x5a"},
|
||||
{0x35, "\x22\x32\x5e"}, {0x35, "\x2a\x0d\x28"}, {0x35, "\x32\x2c\x02"},
|
||||
{0x35, "\x3a\xf4\xfa"}, {0x35, "\x4e\x07\xef"}, {0x35, "\x46\x07\x88"},
|
||||
{0x35, "\x5e\x07\xc1"}, {0x35, "\x56\x04\x64"}, {0x34, "\xe4\x01\x15"},
|
||||
{0x34, "\xec\x00\x82"}, {0x34, "\xf4\x0c\xce"}, {0x34, "\xfc\x0c\xba"},
|
||||
{0x35, "\x06\x1f\x02"}, {0x35, "\x0e\x02\xe3"}, {0x35, "\x16\x1a\x50"},
|
||||
{0x35, "\x1e\x24\x39"}, {0x35, "\x26\x23\x4c"}, {0x35, "\x2e\xf9\x1b"},
|
||||
{0x35, "\x36\x23\x19"}, {0x35, "\x3e\x12\x08"}, {0x35, "\x52\x07\x22"},
|
||||
{0x35, "\x4a\x03\xd3"}, {0x35, "\x62\x06\x54"}, {0x35, "\x5a\x04\x5d"},
|
||||
{0x34, "\xe2\x01\x04"}, {0x34, "\xea\x00\xa0"}, {0x34, "\xf2\x0c\xbc"},
|
||||
{0x34, "\xfa\x0c\x5b"}, {0x35, "\x04\x17\xf2"}, {0x35, "\x0c\x02\x08"},
|
||||
{0x35, "\x14\x28\x43"}, {0x35, "\x1c\x28\x62"}, {0x35, "\x24\x2b\x60"},
|
||||
{0x35, "\x2c\x07\x33"}, {0x35, "\x34\x1f\xb0"}, {0x35, "\x3c\xed\xcd"},
|
||||
{0x35, "\x50\x00\x06"}, {0x35, "\x48\x07\xff"}, {0x35, "\x60\x05\x89"},
|
||||
{0x35, "\x58\x07\xff"}, {0x35, "\x40\x00\xa0"}, {0x35, "\x42\x00\x00"},
|
||||
{0x32, "\x10\x01\xfc"}, {0x33, "\x8c\xa1\x18"},
|
||||
/* Flip/Mirror h/v=1 */
|
||||
{0x33, "\x90\x00\x3c"}, {0x33, "\x8c\x27\x19"}, {0x33, "\x90\x04\x6c"},
|
||||
{0x33, "\x8c\x27\x3b"}, {0x33, "\x90\x00\x24"}, {0x33, "\x8c\xa1\x03"},
|
||||
{0x33, "\x90\x00\x06"},
|
||||
{130, "\xff\xff\xff"},
|
||||
{0x33, "\x90\x00\x06"}, {0x33, "\x90\x00\x06"}, {0x33, "\x90\x00\x06"},
|
||||
{0x33, "\x90\x00\x06"}, {0x33, "\x90\x00\x06"}, {0x33, "\x90\x00\x06"},
|
||||
{100, "\xff\xff\xff"},
|
||||
/* ?? */
|
||||
{0x33, "\x8c\xa1\x02"}, {0x33, "\x90\x00\x1f"}, {0x33, "\x8c\xa1\x02"},
|
||||
{0x33, "\x90\x00\x1f"}, {0x33, "\x8c\xa1\x02"}, {0x33, "\x90\x00\x1f"},
|
||||
{0x33, "\x8c\xa1\x02"}, {0x33, "\x90\x00\x1f"},
|
||||
/* Brigthness=70 */
|
||||
{0x33, "\x8c\xa2\x06"}, {0x33, "\x90\x00\x46"}, {0x33, "\x8c\xa1\x02"},
|
||||
{0x33, "\x90\x00\x0f"}, {0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x05"},
|
||||
/* Sharpness=20 */
|
||||
{0x32, "\x6c\x14\x08"},
|
||||
};
|
||||
|
||||
static struct idxdata tbl_init_post_alt_big_a[] = {
|
||||
{0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x05"},
|
||||
{2, "\xff\xff\xff"},
|
||||
{0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x06"},
|
||||
{2, "\xff\xff\xff"},
|
||||
{0x34, "\x1e\x8f\x09"}, {0x34, "\x1c\x01\x28"}, {0x34, "\x1e\x8f\x09"},
|
||||
{0x34, "\x1e\x8f\x09"}, {0x32, "\x14\x06\xe6"}, {0x33, "\x8c\xa1\x03"},
|
||||
{0x33, "\x90\x00\x05"},
|
||||
{2, "\xff\xff\xff"},
|
||||
{0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x06"},
|
||||
{2, "\xff\xff\xff"},
|
||||
{0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x05"},
|
||||
{2, "\xff\xff\xff"},
|
||||
{0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x06"}, {0x33, "\x8c\xa1\x20"},
|
||||
{0x33, "\x90\x00\x72"}, {0x33, "\x8c\xa1\x30"}, {0x33, "\x90\x00\x03"},
|
||||
{0x33, "\x8c\xa1\x31"}, {0x33, "\x90\x00\x02"}, {0x33, "\x8c\xa1\x32"},
|
||||
{0x33, "\x90\x00\x03"}, {0x33, "\x8c\xa1\x34"}, {0x33, "\x90\x00\x03"},
|
||||
{0x33, "\x8c\xa1\x03"}, {0x33, "\x90\x00\x02"}, {0x33, "\x2e\x01\x00"},
|
||||
{0x34, "\x04\x00\x2a"}, {0x33, "\x8c\xa7\x02"}, {0x33, "\x90\x00\x01"},
|
||||
};
|
||||
|
||||
static struct idxdata tbl_init_post_alt_big_b[] = {
|
||||
{0x32, "\x10\x01\xf8"}, {0x34, "\xce\x01\xa8"}, {0x34, "\xd0\x66\x33"},
|
||||
{0x34, "\xd2\x31\x9a"}, {0x34, "\xd4\x94\x63"}, {0x34, "\xd6\x4b\x25"},
|
||||
{0x34, "\xd8\x26\x70"}, {0x34, "\xda\x72\x4c"}, {0x34, "\xdc\xff\x04"},
|
||||
{0x34, "\xde\x01\x5b"}, {0x34, "\xe6\x01\x13"}, {0x34, "\xee\x0b\xf0"},
|
||||
{0x34, "\xf6\x0b\xa4"}, {0x35, "\x00\xf6\xe7"}, {0x35, "\x08\x0d\xfd"},
|
||||
{0x35, "\x10\x25\x63"}, {0x35, "\x18\x35\x6c"}, {0x35, "\x20\x42\x7e"},
|
||||
{0x35, "\x28\x19\x44"}, {0x35, "\x30\x39\xd4"}, {0x35, "\x38\xf5\xa8"},
|
||||
{0x35, "\x4c\x07\x90"}, {0x35, "\x44\x07\xb8"}, {0x35, "\x5c\x06\x88"},
|
||||
{0x35, "\x54\x07\xff"}, {0x34, "\xe0\x01\x52"}, {0x34, "\xe8\x00\xcc"},
|
||||
{0x34, "\xf0\x0d\x83"}, {0x34, "\xf8\x0c\xb3"}, {0x35, "\x02\xfe\xba"},
|
||||
{0x35, "\x0a\x04\xe0"}, {0x35, "\x12\x1c\x63"}, {0x35, "\x1a\x2b\x5a"},
|
||||
{0x35, "\x22\x32\x5e"}, {0x35, "\x2a\x0d\x28"}, {0x35, "\x32\x2c\x02"},
|
||||
{0x35, "\x3a\xf4\xfa"}, {0x35, "\x4e\x07\xef"}, {0x35, "\x46\x07\x88"},
|
||||
{0x35, "\x5e\x07\xc1"}, {0x35, "\x56\x04\x64"}, {0x34, "\xe4\x01\x15"},
|
||||
{0x34, "\xec\x00\x82"}, {0x34, "\xf4\x0c\xce"}, {0x34, "\xfc\x0c\xba"},
|
||||
{0x35, "\x06\x1f\x02"}, {0x35, "\x0e\x02\xe3"}, {0x35, "\x16\x1a\x50"},
|
||||
{0x35, "\x1e\x24\x39"}, {0x35, "\x26\x23\x4c"}, {0x35, "\x2e\xf9\x1b"},
|
||||
{0x35, "\x36\x23\x19"}, {0x35, "\x3e\x12\x08"}, {0x35, "\x52\x07\x22"},
|
||||
{0x35, "\x4a\x03\xd3"}, {0x35, "\x62\x06\x54"}, {0x35, "\x5a\x04\x5d"},
|
||||
{0x34, "\xe2\x01\x04"}, {0x34, "\xea\x00\xa0"}, {0x34, "\xf2\x0c\xbc"},
|
||||
{0x34, "\xfa\x0c\x5b"}, {0x35, "\x04\x17\xf2"}, {0x35, "\x0c\x02\x08"},
|
||||
{0x35, "\x14\x28\x43"}, {0x35, "\x1c\x28\x62"}, {0x35, "\x24\x2b\x60"},
|
||||
{0x35, "\x2c\x07\x33"}, {0x35, "\x34\x1f\xb0"}, {0x35, "\x3c\xed\xcd"},
|
||||
{0x35, "\x50\x00\x06"}, {0x35, "\x48\x07\xff"}, {0x35, "\x60\x05\x89"},
|
||||
{0x35, "\x58\x07\xff"}, {0x35, "\x40\x00\xa0"}, {0x35, "\x42\x00\x00"},
|
||||
{0x32, "\x10\x01\xfc"}, {0x33, "\x8c\xa1\x18"}, {0x33, "\x90\x00\x3c"},
|
||||
};
|
||||
|
||||
static struct idxdata tbl_init_post_alt_big_c[] = {
|
||||
{0x33, "\x8c\xa1\x02"},
|
||||
{0x33, "\x90\x00\x1f"},
|
||||
{0x33, "\x8c\xa1\x02"},
|
||||
{0x33, "\x90\x00\x1f"},
|
||||
{0x33, "\x8c\xa1\x02"},
|
||||
{0x33, "\x90\x00\x1f"},
|
||||
{0x33, "\x8c\xa1\x02"},
|
||||
{0x33, "\x90\x00\x1f"},
|
||||
};
|
||||
|
||||
static u8 *dat_640 = "\xd0\x02\xd1\x08\xd2\xe1\xd3\x02\xd4\x10\xd5\x81";
|
||||
static u8 *dat_800 = "\xd0\x02\xd1\x10\xd2\x57\xd3\x02\xd4\x18\xd5\x21";
|
||||
static u8 *dat_1280 = "\xd0\x02\xd1\x20\xd2\x01\xd3\x02\xd4\x28\xd5\x01";
|
||||
static u8 *dat_1600 = "\xd0\x02\xd1\x20\xd2\xaf\xd3\x02\xd4\x30\xd5\x41";
|
||||
|
||||
static int mi2020_init_at_startup(struct gspca_dev *gspca_dev);
|
||||
static int mi2020_configure_alt(struct gspca_dev *gspca_dev);
|
||||
static int mi2020_init_pre_alt(struct gspca_dev *gspca_dev);
|
||||
static int mi2020_init_post_alt(struct gspca_dev *gspca_dev);
|
||||
static void mi2020_post_unset_alt(struct gspca_dev *gspca_dev);
|
||||
static int mi2020_camera_settings(struct gspca_dev *gspca_dev);
|
||||
/*==========================================================================*/
|
||||
|
||||
void mi2020_init_settings(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
|
||||
sd->vcur.backlight = 0;
|
||||
sd->vcur.brightness = 70;
|
||||
sd->vcur.sharpness = 20;
|
||||
sd->vcur.contrast = 0;
|
||||
sd->vcur.gamma = 0;
|
||||
sd->vcur.hue = 0;
|
||||
sd->vcur.saturation = 60;
|
||||
sd->vcur.whitebal = 50;
|
||||
sd->vcur.mirror = 0;
|
||||
sd->vcur.flip = 0;
|
||||
sd->vcur.AC50Hz = 1;
|
||||
|
||||
sd->vmax.backlight = 64;
|
||||
sd->vmax.brightness = 128;
|
||||
sd->vmax.sharpness = 40;
|
||||
sd->vmax.contrast = 3;
|
||||
sd->vmax.gamma = 2;
|
||||
sd->vmax.hue = 0 + 1; /* 200 */
|
||||
sd->vmax.saturation = 0; /* 100 */
|
||||
sd->vmax.whitebal = 0; /* 100 */
|
||||
sd->vmax.mirror = 1;
|
||||
sd->vmax.flip = 1;
|
||||
sd->vmax.AC50Hz = 1;
|
||||
if (_MI2020b_) {
|
||||
sd->vmax.contrast = 0;
|
||||
sd->vmax.gamma = 0;
|
||||
sd->vmax.backlight = 0;
|
||||
}
|
||||
|
||||
sd->dev_camera_settings = mi2020_camera_settings;
|
||||
sd->dev_init_at_startup = mi2020_init_at_startup;
|
||||
sd->dev_configure_alt = mi2020_configure_alt;
|
||||
sd->dev_init_pre_alt = mi2020_init_pre_alt;
|
||||
sd->dev_post_unset_alt = mi2020_post_unset_alt;
|
||||
}
|
||||
|
||||
/*==========================================================================*/
|
||||
|
||||
static void common(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
|
||||
|
||||
if (_MI2020b_) {
|
||||
fetch_validx(gspca_dev, tbl_common_a, ARRAY_SIZE(tbl_common_a));
|
||||
} else {
|
||||
if (_MI2020_)
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0008, 0x0004, 0, NULL);
|
||||
else
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0002, 0x0004, 0, NULL);
|
||||
msleep(35);
|
||||
fetch_validx(gspca_dev, tbl_common_b, ARRAY_SIZE(tbl_common_b));
|
||||
}
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x86\x25\x01");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x86\x25\x00");
|
||||
msleep(2); /* - * */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0030, 3, "\x1a\x0a\xcc");
|
||||
if (reso == IMAGE_1600)
|
||||
msleep(2); /* 1600 */
|
||||
fetch_idxdata(gspca_dev, tbl_common_c, ARRAY_SIZE(tbl_common_c));
|
||||
|
||||
if (_MI2020b_ || _MI2020_)
|
||||
fetch_idxdata(gspca_dev, tbl_common_d,
|
||||
ARRAY_SIZE(tbl_common_d));
|
||||
|
||||
fetch_idxdata(gspca_dev, tbl_common_e, ARRAY_SIZE(tbl_common_e));
|
||||
if (_MI2020b_ || _MI2020_) {
|
||||
/* Different from fret */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x78");
|
||||
/* Same as fret */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\x24\x17");
|
||||
/* Different from fret */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x90");
|
||||
} else {
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x6a");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\x24\x17");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x80");
|
||||
}
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x03");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x05");
|
||||
msleep(2);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x03");
|
||||
if (reso == IMAGE_1600)
|
||||
msleep(14); /* 1600 */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x06");
|
||||
msleep(2);
|
||||
}
|
||||
|
||||
static int mi2020_init_at_startup(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
u8 c;
|
||||
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0004, 1, &c);
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0004, 1, &c);
|
||||
|
||||
fetch_validx(gspca_dev, tbl_init_at_startup,
|
||||
ARRAY_SIZE(tbl_init_at_startup));
|
||||
|
||||
common(gspca_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mi2020_init_pre_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
|
||||
sd->mirrorMask = 0;
|
||||
|
||||
sd->vold.backlight = -1;
|
||||
sd->vold.brightness = -1;
|
||||
sd->vold.sharpness = -1;
|
||||
sd->vold.contrast = -1;
|
||||
sd->vold.gamma = -1;
|
||||
sd->vold.hue = -1;
|
||||
sd->vold.mirror = -1;
|
||||
sd->vold.flip = -1;
|
||||
sd->vold.AC50Hz = -1;
|
||||
|
||||
mi2020_init_post_alt(gspca_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mi2020_init_post_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
|
||||
|
||||
s32 backlight = sd->vcur.backlight;
|
||||
s32 mirror = (((sd->vcur.mirror > 0) ^ sd->mirrorMask) > 0);
|
||||
s32 flip = (((sd->vcur.flip > 0) ^ sd->mirrorMask) > 0);
|
||||
s32 freq = (sd->vcur.AC50Hz > 0);
|
||||
|
||||
u8 dat_freq2[] = {0x90, 0x00, 0x80};
|
||||
u8 dat_multi1[] = {0x8c, 0xa7, 0x00};
|
||||
u8 dat_multi2[] = {0x90, 0x00, 0x00};
|
||||
u8 dat_multi3[] = {0x8c, 0xa7, 0x00};
|
||||
u8 dat_multi4[] = {0x90, 0x00, 0x00};
|
||||
u8 dat_hvflip2[] = {0x90, 0x04, 0x6c};
|
||||
u8 dat_hvflip4[] = {0x90, 0x00, 0x24};
|
||||
u8 c;
|
||||
|
||||
sd->nbIm = -1;
|
||||
|
||||
dat_freq2[2] = freq ? 0xc0 : 0x80;
|
||||
dat_multi1[2] = 0x9d;
|
||||
dat_multi3[2] = dat_multi1[2] + 1;
|
||||
dat_multi4[2] = dat_multi2[2] = backlight;
|
||||
dat_hvflip2[2] = 0x6c + 2 * (1 - flip) + (1 - mirror);
|
||||
dat_hvflip4[2] = 0x24 + 2 * (1 - flip) + (1 - mirror);
|
||||
|
||||
msleep(200);
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 5, 0x0001, 0x0000, 0, NULL);
|
||||
msleep(3); /* 35 * */
|
||||
|
||||
common(gspca_dev);
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x0000, 0, NULL);
|
||||
msleep(70);
|
||||
|
||||
if (_MI2020b_)
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0040, 0x0000, 0, NULL);
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0010, 0x0010, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0003, 0x00c1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0042, 0x00c2, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x006a, 0x000d, 0, NULL);
|
||||
|
||||
switch (reso) {
|
||||
case IMAGE_640:
|
||||
case IMAGE_800:
|
||||
if (reso != IMAGE_800)
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
|
||||
12, dat_640);
|
||||
else
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
|
||||
12, dat_800);
|
||||
|
||||
if (_MI2020c_)
|
||||
fetch_idxdata(gspca_dev, tbl_init_post_alt_low_a,
|
||||
ARRAY_SIZE(tbl_init_post_alt_low_a));
|
||||
|
||||
if (reso == IMAGE_800)
|
||||
fetch_idxdata(gspca_dev, tbl_init_post_alt_low_b,
|
||||
ARRAY_SIZE(tbl_init_post_alt_low_b));
|
||||
|
||||
fetch_idxdata(gspca_dev, tbl_init_post_alt_low_c,
|
||||
ARRAY_SIZE(tbl_init_post_alt_low_c));
|
||||
|
||||
if (_MI2020b_) {
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x0010, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0000, 0x00c1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x00c2, 0, NULL);
|
||||
msleep(150);
|
||||
} else if (_MI2020c_) {
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0010, 0x0010, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0000, 0x00c1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x00c2, 0, NULL);
|
||||
msleep(120);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0040, 0x0000, 0, NULL);
|
||||
msleep(30);
|
||||
} else if (_MI2020_) {
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x0010, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0000, 0x00c1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x00c2, 0, NULL);
|
||||
msleep(120);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0040, 0x0000, 0, NULL);
|
||||
msleep(30);
|
||||
}
|
||||
|
||||
/* AC power frequency */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_freq1);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_freq2);
|
||||
msleep(20);
|
||||
/* backlight */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi1);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi2);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi3);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi4);
|
||||
/* at init time but not after */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa2\x0c");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x17");
|
||||
/* finish the backlight */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi6);
|
||||
msleep(5);/* " */
|
||||
|
||||
if (_MI2020c_) {
|
||||
fetch_idxdata(gspca_dev, tbl_init_post_alt_low_d,
|
||||
ARRAY_SIZE(tbl_init_post_alt_low_d));
|
||||
} else {
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0000, 1, &c);
|
||||
msleep(14); /* 0xd8 */
|
||||
|
||||
/* flip/mirror */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, dat_hvflip1);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, dat_hvflip2);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, dat_hvflip3);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, dat_hvflip4);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, dat_hvflip5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, dat_hvflip6);
|
||||
msleep(21);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, dat_dummy1);
|
||||
msleep(5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, dat_dummy1);
|
||||
msleep(5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, dat_dummy1);
|
||||
msleep(5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, dat_dummy1);
|
||||
msleep(5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, dat_dummy1);
|
||||
msleep(5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, dat_dummy1);
|
||||
/* end of flip/mirror main part */
|
||||
msleep(246); /* 146 */
|
||||
|
||||
sd->nbIm = 0;
|
||||
}
|
||||
break;
|
||||
|
||||
case IMAGE_1280:
|
||||
case IMAGE_1600:
|
||||
if (reso == IMAGE_1280) {
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
|
||||
12, dat_1280);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, "\x8c\x27\x07");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, "\x90\x05\x04");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, "\x8c\x27\x09");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, "\x90\x04\x02");
|
||||
} else {
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
|
||||
12, dat_1600);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, "\x8c\x27\x07");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, "\x90\x06\x40");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, "\x8c\x27\x09");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033,
|
||||
3, "\x90\x04\xb0");
|
||||
}
|
||||
|
||||
fetch_idxdata(gspca_dev, tbl_init_post_alt_big_a,
|
||||
ARRAY_SIZE(tbl_init_post_alt_big_a));
|
||||
|
||||
if (reso == IMAGE_1600)
|
||||
msleep(13); /* 1600 */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\x27\x97");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x01\x00");
|
||||
msleep(53);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x20");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x00");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x03");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x01");
|
||||
if (reso == IMAGE_1600)
|
||||
msleep(13); /* 1600 */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa7\x02");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x00");
|
||||
msleep(53);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x20");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x72");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x03");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x02");
|
||||
if (reso == IMAGE_1600)
|
||||
msleep(13); /* 1600 */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa7\x02");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x01");
|
||||
msleep(53);
|
||||
|
||||
if (_MI2020b_) {
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x0010, 0, NULL);
|
||||
if (reso == IMAGE_1600)
|
||||
msleep(500); /* 1600 */
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0000, 0x00c1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x00c2, 0, NULL);
|
||||
msleep(1850);
|
||||
} else if (_MI2020c_ || _MI2020_) {
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x0010, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0000, 0x00c1, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x00c2, 0, NULL);
|
||||
msleep(1850);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0040, 0x0000, 0, NULL);
|
||||
msleep(30);
|
||||
}
|
||||
|
||||
/* AC power frequency */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_freq1);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_freq2);
|
||||
msleep(20);
|
||||
/* backlight */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi1);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi2);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi3);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi4);
|
||||
/* at init time but not after */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa2\x0c");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x17");
|
||||
/* finish the backlight */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi6);
|
||||
msleep(6); /* " */
|
||||
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0000, 1, &c);
|
||||
msleep(14);
|
||||
|
||||
if (_MI2020c_)
|
||||
fetch_idxdata(gspca_dev, tbl_init_post_alt_big_b,
|
||||
ARRAY_SIZE(tbl_init_post_alt_big_b));
|
||||
|
||||
/* flip/mirror */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip1);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip2);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip3);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip4);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip6);
|
||||
/* end of flip/mirror main part */
|
||||
msleep(16);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x03");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x01");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x20");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x00");
|
||||
if (reso == IMAGE_1600)
|
||||
msleep(25); /* 1600 */
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa7\x02");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x00");
|
||||
msleep(103);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x03");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x02");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa1\x20");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x72");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x8c\xa7\x02");
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, "\x90\x00\x01");
|
||||
sd->nbIm = 0;
|
||||
|
||||
if (_MI2020c_)
|
||||
fetch_idxdata(gspca_dev, tbl_init_post_alt_big_c,
|
||||
ARRAY_SIZE(tbl_init_post_alt_big_c));
|
||||
}
|
||||
|
||||
sd->vold.mirror = mirror;
|
||||
sd->vold.flip = flip;
|
||||
sd->vold.AC50Hz = freq;
|
||||
sd->vold.backlight = backlight;
|
||||
|
||||
mi2020_camera_settings(gspca_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mi2020_configure_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
|
||||
|
||||
switch (reso) {
|
||||
case IMAGE_640:
|
||||
gspca_dev->alt = 3 + 1;
|
||||
break;
|
||||
|
||||
case IMAGE_800:
|
||||
case IMAGE_1280:
|
||||
case IMAGE_1600:
|
||||
gspca_dev->alt = 1 + 1;
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mi2020_camera_settings(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
|
||||
s32 backlight = sd->vcur.backlight;
|
||||
s32 bright = sd->vcur.brightness;
|
||||
s32 sharp = sd->vcur.sharpness;
|
||||
s32 cntr = sd->vcur.contrast;
|
||||
s32 gam = sd->vcur.gamma;
|
||||
s32 hue = (sd->vcur.hue > 0);
|
||||
s32 mirror = (((sd->vcur.mirror > 0) ^ sd->mirrorMask) > 0);
|
||||
s32 flip = (((sd->vcur.flip > 0) ^ sd->mirrorMask) > 0);
|
||||
s32 freq = (sd->vcur.AC50Hz > 0);
|
||||
|
||||
u8 dat_sharp[] = {0x6c, 0x00, 0x08};
|
||||
u8 dat_bright2[] = {0x90, 0x00, 0x00};
|
||||
u8 dat_freq2[] = {0x90, 0x00, 0x80};
|
||||
u8 dat_multi1[] = {0x8c, 0xa7, 0x00};
|
||||
u8 dat_multi2[] = {0x90, 0x00, 0x00};
|
||||
u8 dat_multi3[] = {0x8c, 0xa7, 0x00};
|
||||
u8 dat_multi4[] = {0x90, 0x00, 0x00};
|
||||
u8 dat_hvflip2[] = {0x90, 0x04, 0x6c};
|
||||
u8 dat_hvflip4[] = {0x90, 0x00, 0x24};
|
||||
|
||||
/* Less than 4 images received -> too early to set the settings */
|
||||
if (sd->nbIm < 4) {
|
||||
sd->waitSet = 1;
|
||||
return 0;
|
||||
}
|
||||
sd->waitSet = 0;
|
||||
|
||||
if (freq != sd->vold.AC50Hz) {
|
||||
sd->vold.AC50Hz = freq;
|
||||
|
||||
dat_freq2[2] = freq ? 0xc0 : 0x80;
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_freq1);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_freq2);
|
||||
msleep(20);
|
||||
}
|
||||
|
||||
if (mirror != sd->vold.mirror || flip != sd->vold.flip) {
|
||||
sd->vold.mirror = mirror;
|
||||
sd->vold.flip = flip;
|
||||
|
||||
dat_hvflip2[2] = 0x6c + 2 * (1 - flip) + (1 - mirror);
|
||||
dat_hvflip4[2] = 0x24 + 2 * (1 - flip) + (1 - mirror);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip1);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip2);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip3);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip4);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_hvflip6);
|
||||
msleep(130);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_dummy1);
|
||||
msleep(6);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_dummy1);
|
||||
msleep(6);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_dummy1);
|
||||
msleep(6);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_dummy1);
|
||||
msleep(6);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_dummy1);
|
||||
msleep(6);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_dummy1);
|
||||
msleep(6);
|
||||
|
||||
/* Sometimes present, sometimes not, useful? */
|
||||
/* ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy2);
|
||||
* ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy3);
|
||||
* ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy2);
|
||||
* ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy3);
|
||||
* ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy2);
|
||||
* ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy3);
|
||||
* ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy2);
|
||||
* ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dummy3);*/
|
||||
}
|
||||
|
||||
if (backlight != sd->vold.backlight) {
|
||||
sd->vold.backlight = backlight;
|
||||
if (backlight < 0 || backlight > sd->vmax.backlight)
|
||||
backlight = 0;
|
||||
|
||||
dat_multi1[2] = 0x9d;
|
||||
dat_multi3[2] = dat_multi1[2] + 1;
|
||||
dat_multi4[2] = dat_multi2[2] = backlight;
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi1);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi2);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi3);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi4);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi6);
|
||||
}
|
||||
|
||||
if (gam != sd->vold.gamma) {
|
||||
sd->vold.gamma = gam;
|
||||
if (gam < 0 || gam > sd->vmax.gamma)
|
||||
gam = 0;
|
||||
|
||||
dat_multi1[2] = 0x6d;
|
||||
dat_multi3[2] = dat_multi1[2] + 1;
|
||||
dat_multi4[2] = dat_multi2[2] = 0x40 + gam;
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi1);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi2);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi3);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi4);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi6);
|
||||
}
|
||||
|
||||
if (cntr != sd->vold.contrast) {
|
||||
sd->vold.contrast = cntr;
|
||||
if (cntr < 0 || cntr > sd->vmax.contrast)
|
||||
cntr = 0;
|
||||
|
||||
dat_multi1[2] = 0x6d;
|
||||
dat_multi3[2] = dat_multi1[2] + 1;
|
||||
dat_multi4[2] = dat_multi2[2] = 0x12 + 16 * cntr;
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi1);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi2);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi3);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi4);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_multi6);
|
||||
}
|
||||
|
||||
if (bright != sd->vold.brightness) {
|
||||
sd->vold.brightness = bright;
|
||||
if (bright < 0 || bright > sd->vmax.brightness)
|
||||
bright = 0;
|
||||
|
||||
dat_bright2[2] = bright;
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_bright1);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_bright2);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_bright3);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_bright4);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_bright5);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0033, 3, dat_bright6);
|
||||
}
|
||||
|
||||
if (sharp != sd->vold.sharpness) {
|
||||
sd->vold.sharpness = sharp;
|
||||
if (sharp < 0 || sharp > sd->vmax.sharpness)
|
||||
sharp = 0;
|
||||
|
||||
dat_sharp[1] = sharp;
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x7a00, 0x0032, 3, dat_sharp);
|
||||
}
|
||||
|
||||
if (hue != sd->vold.hue) {
|
||||
sd->swapRB = hue;
|
||||
sd->vold.hue = hue;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void mi2020_post_unset_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
ctrl_out(gspca_dev, 0x40, 5, 0x0000, 0x0000, 0, NULL);
|
||||
msleep(20);
|
||||
if (_MI2020c_ || _MI2020_)
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0001, 0x0000, 0, NULL);
|
||||
else
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0041, 0x0000, 0, NULL);
|
||||
}
|
||||
|
|
@ -0,0 +1,505 @@
|
|||
/* @file gl860-ov2640.c
|
||||
* @author Olivier LORIN, from Malmostoso's logs
|
||||
* @date 2009-08-27
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/* Sensor : OV2640 */
|
||||
|
||||
#include "gl860.h"
|
||||
|
||||
static u8 dat_init1[] = "\x00\x41\x07\x6a\x06\x61\x0d\x6a" "\x10\x10\xc1\x01";
|
||||
static u8 dat_init2[] = {0x61}; /* expected */
|
||||
static u8 dat_init3[] = {0x51}; /* expected */
|
||||
|
||||
static u8 dat_post[] =
|
||||
"\x00\x41\x07\x6a\x06\xef\x0d\x6a" "\x10\x10\xc1\x01";
|
||||
|
||||
static u8 dat_640[] = "\xd0\x01\xd1\x08\xd2\xe0\xd3\x02\xd4\x10\xd5\x81";
|
||||
static u8 dat_800[] = "\xd0\x01\xd1\x10\xd2\x58\xd3\x02\xd4\x18\xd5\x21";
|
||||
static u8 dat_1280[] = "\xd0\x01\xd1\x18\xd2\xc0\xd3\x02\xd4\x28\xd5\x01";
|
||||
static u8 dat_1600[] = "\xd0\x01\xd1\x20\xd2\xb0\xd3\x02\xd4\x30\xd5\x41";
|
||||
|
||||
static u8 c50[] = {0x50}; /* expected */
|
||||
static u8 c28[] = {0x28}; /* expected */
|
||||
static u8 ca8[] = {0xa8}; /* expected */
|
||||
|
||||
static struct validx tbl_init_at_startup[] = {
|
||||
{0x0000, 0x0000}, {0x0010, 0x0010}, {0x0008, 0x00c0}, {0x0001, 0x00c1},
|
||||
{0x0001, 0x00c2}, {0x0020, 0x0006}, {0x006a, 0x000d},
|
||||
{0x0050, 0x0000}, {0x0041, 0x0000}, {0x006a, 0x0007}, {0x0061, 0x0006},
|
||||
{0x006a, 0x000d}, {0x0000, 0x00c0}, {0x0010, 0x0010}, {0x0001, 0x00c1},
|
||||
{0x0041, 0x00c2}, {0x0004, 0x00d8}, {0x0012, 0x0004}, {0x0000, 0x0058},
|
||||
{0x0041, 0x0000}, {0x0061, 0x0000},
|
||||
};
|
||||
|
||||
static struct validx tbl_common[] = {
|
||||
{0x6000, 0x00ff}, {0x60ff, 0x002c}, {0x60df, 0x002e}, {0x6001, 0x00ff},
|
||||
{0x6080, 0x0012}, {0x6000, 0x0000}, {0x6000, 0x0045}, {0x6000, 0x0010},
|
||||
{0x6035, 0x003c}, {0x6000, 0x0011}, {0x6028, 0x0004}, {0x60e5, 0x0013},
|
||||
{0x6088, 0x0014}, {0x600c, 0x002c}, {0x6078, 0x0033}, {0x60f7, 0x003b},
|
||||
{0x6000, 0x003e}, {0x6011, 0x0043}, {0x6010, 0x0016}, {0x6082, 0x0039},
|
||||
{0x6088, 0x0035}, {0x600a, 0x0022}, {0x6040, 0x0037}, {0x6000, 0x0023},
|
||||
{0x60a0, 0x0034}, {0x601a, 0x0036}, {0x6002, 0x0006}, {0x60c0, 0x0007},
|
||||
{0x60b7, 0x000d}, {0x6001, 0x000e}, {0x6000, 0x004c}, {0x6081, 0x004a},
|
||||
{0x6099, 0x0021}, {0x6002, 0x0009}, {0x603e, 0x0024}, {0x6034, 0x0025},
|
||||
{0x6081, 0x0026}, {0x6000, 0x0000}, {0x6000, 0x0045}, {0x6000, 0x0010},
|
||||
{0x6000, 0x005c}, {0x6000, 0x0063}, {0x6000, 0x007c}, {0x6070, 0x0061},
|
||||
{0x6080, 0x0062}, {0x6080, 0x0020}, {0x6030, 0x0028}, {0x6000, 0x006c},
|
||||
{0x6000, 0x006e}, {0x6002, 0x0070}, {0x6094, 0x0071}, {0x60c1, 0x0073},
|
||||
{0x6034, 0x003d}, {0x6057, 0x005a}, {0x60bb, 0x004f}, {0x609c, 0x0050},
|
||||
{0x6080, 0x006d}, {0x6002, 0x0039}, {0x6033, 0x003a}, {0x60f1, 0x003b},
|
||||
{0x6031, 0x003c}, {0x6000, 0x00ff}, {0x6014, 0x00e0}, {0x60ff, 0x0076},
|
||||
{0x60a0, 0x0033}, {0x6020, 0x0042}, {0x6018, 0x0043}, {0x6000, 0x004c},
|
||||
{0x60d0, 0x0087}, {0x600f, 0x0088}, {0x6003, 0x00d7}, {0x6010, 0x00d9},
|
||||
{0x6005, 0x00da}, {0x6082, 0x00d3}, {0x60c0, 0x00f9}, {0x6006, 0x0044},
|
||||
{0x6007, 0x00d1}, {0x6002, 0x00d2}, {0x6000, 0x00d2}, {0x6011, 0x00d8},
|
||||
{0x6008, 0x00c8}, {0x6080, 0x00c9}, {0x6008, 0x007c}, {0x6020, 0x007d},
|
||||
{0x6020, 0x007d}, {0x6000, 0x0090}, {0x600e, 0x0091}, {0x601a, 0x0091},
|
||||
{0x6031, 0x0091}, {0x605a, 0x0091}, {0x6069, 0x0091}, {0x6075, 0x0091},
|
||||
{0x607e, 0x0091}, {0x6088, 0x0091}, {0x608f, 0x0091}, {0x6096, 0x0091},
|
||||
{0x60a3, 0x0091}, {0x60af, 0x0091}, {0x60c4, 0x0091}, {0x60d7, 0x0091},
|
||||
{0x60e8, 0x0091}, {0x6020, 0x0091}, {0x6000, 0x0092}, {0x6006, 0x0093},
|
||||
{0x60e3, 0x0093}, {0x6005, 0x0093}, {0x6005, 0x0093}, {0x6000, 0x0093},
|
||||
{0x6004, 0x0093}, {0x6000, 0x0093}, {0x6000, 0x0093}, {0x6000, 0x0093},
|
||||
{0x6000, 0x0093}, {0x6000, 0x0093}, {0x6000, 0x0093}, {0x6000, 0x0093},
|
||||
{0x6000, 0x0096}, {0x6008, 0x0097}, {0x6019, 0x0097}, {0x6002, 0x0097},
|
||||
{0x600c, 0x0097}, {0x6024, 0x0097}, {0x6030, 0x0097}, {0x6028, 0x0097},
|
||||
{0x6026, 0x0097}, {0x6002, 0x0097}, {0x6098, 0x0097}, {0x6080, 0x0097},
|
||||
{0x6000, 0x0097}, {0x6000, 0x0097}, {0x60ed, 0x00c3}, {0x609a, 0x00c4},
|
||||
{0x6000, 0x00a4}, {0x6011, 0x00c5}, {0x6051, 0x00c6}, {0x6010, 0x00c7},
|
||||
{0x6066, 0x00b6}, {0x60a5, 0x00b8}, {0x6064, 0x00b7}, {0x607c, 0x00b9},
|
||||
{0x60af, 0x00b3}, {0x6097, 0x00b4}, {0x60ff, 0x00b5}, {0x60c5, 0x00b0},
|
||||
{0x6094, 0x00b1}, {0x600f, 0x00b2}, {0x605c, 0x00c4}, {0x6000, 0x00a8},
|
||||
{0x60c8, 0x00c0}, {0x6096, 0x00c1}, {0x601d, 0x0086}, {0x6000, 0x0050},
|
||||
{0x6090, 0x0051}, {0x6018, 0x0052}, {0x6000, 0x0053}, {0x6000, 0x0054},
|
||||
{0x6088, 0x0055}, {0x6000, 0x0057}, {0x6090, 0x005a}, {0x6018, 0x005b},
|
||||
{0x6005, 0x005c}, {0x60ed, 0x00c3}, {0x6000, 0x007f}, {0x6005, 0x00da},
|
||||
{0x601f, 0x00e5}, {0x6067, 0x00e1}, {0x6000, 0x00e0}, {0x60ff, 0x00dd},
|
||||
{0x6000, 0x0005}, {0x6001, 0x00ff}, {0x6000, 0x0000}, {0x6000, 0x0045},
|
||||
{0x6000, 0x0010},
|
||||
};
|
||||
|
||||
static struct validx tbl_sensor_settings_common_a[] = {
|
||||
{0x0041, 0x0000}, {0x006a, 0x0007}, {0x00ef, 0x0006}, {0x006a, 0x000d},
|
||||
{0x0000, 0x00c0}, {0x0010, 0x0010}, {0x0001, 0x00c1}, {0x0041, 0x00c2},
|
||||
{0x0004, 0x00d8}, {0x0012, 0x0004}, {0x0000, 0x0058}, {0x0041, 0x0000},
|
||||
{50, 0xffff},
|
||||
{0x0061, 0x0000},
|
||||
{0xffff, 0xffff},
|
||||
{0x6000, 0x00ff}, {0x6000, 0x007c}, {0x6007, 0x007d},
|
||||
{30, 0xffff},
|
||||
{0x0040, 0x0000},
|
||||
};
|
||||
|
||||
static struct validx tbl_sensor_settings_common_b[] = {
|
||||
{0x6001, 0x00ff}, {0x6038, 0x000c},
|
||||
{10, 0xffff},
|
||||
{0x6000, 0x0011},
|
||||
/* backlight=31/64 */
|
||||
{0x6001, 0x00ff}, {0x603e, 0x0024}, {0x6034, 0x0025},
|
||||
/* bright=0/256 */
|
||||
{0x6000, 0x00ff}, {0x6009, 0x007c}, {0x6000, 0x007d},
|
||||
/* wbal=64/128 */
|
||||
{0x6000, 0x00ff}, {0x6003, 0x007c}, {0x6040, 0x007d},
|
||||
/* cntr=0/256 */
|
||||
{0x6000, 0x00ff}, {0x6007, 0x007c}, {0x6000, 0x007d},
|
||||
/* sat=128/256 */
|
||||
{0x6000, 0x00ff}, {0x6001, 0x007c}, {0x6080, 0x007d},
|
||||
/* sharpness=0/32 */
|
||||
{0x6000, 0x00ff}, {0x6001, 0x0092}, {0x60c0, 0x0093},
|
||||
/* hue=0/256 */
|
||||
{0x6000, 0x00ff}, {0x6002, 0x007c}, {0x6000, 0x007d},
|
||||
/* gam=32/64 */
|
||||
{0x6000, 0x00ff}, {0x6008, 0x007c}, {0x6020, 0x007d},
|
||||
/* image right up */
|
||||
{0xffff, 0xffff},
|
||||
{15, 0xffff},
|
||||
{0x6001, 0x00ff}, {0x6000, 0x8004},
|
||||
{0xffff, 0xffff},
|
||||
{0x60a8, 0x0004},
|
||||
{15, 0xffff},
|
||||
{0x6001, 0x00ff}, {0x6000, 0x8004},
|
||||
{0xffff, 0xffff},
|
||||
{0x60f8, 0x0004},
|
||||
/* image right up */
|
||||
{0xffff, 0xffff},
|
||||
/* backlight=31/64 */
|
||||
{0x6001, 0x00ff}, {0x603e, 0x0024}, {0x6034, 0x0025},
|
||||
};
|
||||
|
||||
static struct validx tbl_640[] = {
|
||||
{0x6000, 0x00ff}, {0x60f1, 0x00dd}, {0x6004, 0x00e0}, {0x6067, 0x00e1},
|
||||
{0x6004, 0x00da}, {0x6000, 0x00ff}, {0x60f1, 0x00dd}, {0x6004, 0x00e0},
|
||||
{0x6001, 0x00ff}, {0x6000, 0x0012}, {0x6000, 0x0011}, {0x6011, 0x0017},
|
||||
{0x6075, 0x0018}, {0x6001, 0x0019}, {0x6097, 0x001a}, {0x6036, 0x0032},
|
||||
{0x60bb, 0x004f}, {0x6057, 0x005a}, {0x609c, 0x0050}, {0x6080, 0x006d},
|
||||
{0x6092, 0x0026}, {0x60ff, 0x0020}, {0x6000, 0x0027}, {0x6000, 0x00ff},
|
||||
{0x60c8, 0x00c0}, {0x6096, 0x00c1}, {0x6000, 0x008c}, {0x603d, 0x0086},
|
||||
{0x6089, 0x0050}, {0x6090, 0x0051}, {0x602c, 0x0052}, {0x6000, 0x0053},
|
||||
{0x6000, 0x0054}, {0x6088, 0x0055}, {0x6000, 0x0057}, {0x60a0, 0x005a},
|
||||
{0x6078, 0x005b}, {0x6000, 0x005c}, {0x6004, 0x00d3}, {0x6000, 0x00e0},
|
||||
{0x60ff, 0x00dd}, {0x60a1, 0x005a},
|
||||
};
|
||||
|
||||
static struct validx tbl_800[] = {
|
||||
{0x6000, 0x00ff}, {0x60f1, 0x00dd}, {0x6004, 0x00e0}, {0x6067, 0x00e1},
|
||||
{0x6004, 0x00da}, {0x6000, 0x00ff}, {0x60f1, 0x00dd}, {0x6004, 0x00e0},
|
||||
{0x6001, 0x00ff}, {0x6040, 0x0012}, {0x6000, 0x0011}, {0x6011, 0x0017},
|
||||
{0x6043, 0x0018}, {0x6000, 0x0019}, {0x604b, 0x001a}, {0x6009, 0x0032},
|
||||
{0x60ca, 0x004f}, {0x60a8, 0x0050}, {0x6000, 0x006d}, {0x6038, 0x003d},
|
||||
{0x60c8, 0x0035}, {0x6000, 0x0022}, {0x6092, 0x0026}, {0x60ff, 0x0020},
|
||||
{0x6000, 0x0027}, {0x6000, 0x00ff}, {0x6064, 0x00c0}, {0x604b, 0x00c1},
|
||||
{0x6000, 0x008c}, {0x601d, 0x0086}, {0x6082, 0x00d3}, {0x6000, 0x00e0},
|
||||
{0x60ff, 0x00dd}, {0x6020, 0x008c}, {0x6001, 0x00ff}, {0x6044, 0x0018},
|
||||
};
|
||||
|
||||
static struct validx tbl_big_a[] = {
|
||||
{0x0002, 0x00c1}, {0x6000, 0x00ff}, {0x60f1, 0x00dd}, {0x6004, 0x00e0},
|
||||
{0x6001, 0x00ff}, {0x6000, 0x0012}, {0x6000, 0x0000}, {0x6000, 0x0045},
|
||||
{0x6000, 0x0010}, {0x6000, 0x0011}, {0x6011, 0x0017}, {0x6075, 0x0018},
|
||||
{0x6001, 0x0019}, {0x6097, 0x001a}, {0x6036, 0x0032}, {0x60bb, 0x004f},
|
||||
{0x609c, 0x0050}, {0x6057, 0x005a}, {0x6080, 0x006d}, {0x6043, 0x000f},
|
||||
{0x608f, 0x0003}, {0x6005, 0x007c}, {0x6081, 0x0026}, {0x6000, 0x00ff},
|
||||
{0x60c8, 0x00c0}, {0x6096, 0x00c1}, {0x6000, 0x008c},
|
||||
};
|
||||
|
||||
static struct validx tbl_big_b[] = {
|
||||
{0x603d, 0x0086}, {0x6000, 0x0050}, {0x6090, 0x0051}, {0x602c, 0x0052},
|
||||
{0x6000, 0x0053}, {0x6000, 0x0054}, {0x6088, 0x0055}, {0x6000, 0x0057},
|
||||
{0x6040, 0x005a}, {0x60f0, 0x005b}, {0x6001, 0x005c}, {0x6082, 0x00d3},
|
||||
{0x6000, 0x008e},
|
||||
};
|
||||
|
||||
static struct validx tbl_big_c[] = {
|
||||
{0x6004, 0x00da}, {0x6000, 0x00e0}, {0x6067, 0x00e1}, {0x60ff, 0x00dd},
|
||||
{0x6001, 0x00ff}, {0x6000, 0x00ff}, {0x60f1, 0x00dd}, {0x6004, 0x00e0},
|
||||
{0x6001, 0x00ff}, {0x6000, 0x0011}, {0x6000, 0x00ff}, {0x6010, 0x00c7},
|
||||
{0x6000, 0x0092}, {0x6006, 0x0093}, {0x60e3, 0x0093}, {0x6005, 0x0093},
|
||||
{0x6005, 0x0093}, {0x60ed, 0x00c3}, {0x6000, 0x00a4}, {0x60d0, 0x0087},
|
||||
{0x6003, 0x0096}, {0x600c, 0x0097}, {0x6024, 0x0097}, {0x6030, 0x0097},
|
||||
{0x6028, 0x0097}, {0x6026, 0x0097}, {0x6002, 0x0097}, {0x6001, 0x00ff},
|
||||
{0x6043, 0x000f}, {0x608f, 0x0003}, {0x6000, 0x002d}, {0x6000, 0x002e},
|
||||
{0x600a, 0x0022}, {0x6002, 0x0070}, {0x6008, 0x0014}, {0x6048, 0x0014},
|
||||
{0x6000, 0x00ff}, {0x6000, 0x00e0}, {0x60ff, 0x00dd},
|
||||
};
|
||||
|
||||
static struct validx tbl_post_unset_alt[] = {
|
||||
{0x006a, 0x000d}, {0x6001, 0x00ff}, {0x6081, 0x0026}, {0x6000, 0x0000},
|
||||
{0x6000, 0x0045}, {0x6000, 0x0010}, {0x6068, 0x000d},
|
||||
{50, 0xffff},
|
||||
{0x0021, 0x0000},
|
||||
};
|
||||
|
||||
static int ov2640_init_at_startup(struct gspca_dev *gspca_dev);
|
||||
static int ov2640_configure_alt(struct gspca_dev *gspca_dev);
|
||||
static int ov2640_init_pre_alt(struct gspca_dev *gspca_dev);
|
||||
static int ov2640_init_post_alt(struct gspca_dev *gspca_dev);
|
||||
static void ov2640_post_unset_alt(struct gspca_dev *gspca_dev);
|
||||
static int ov2640_camera_settings(struct gspca_dev *gspca_dev);
|
||||
/*==========================================================================*/
|
||||
|
||||
void ov2640_init_settings(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
|
||||
sd->vcur.backlight = 32;
|
||||
sd->vcur.brightness = 0;
|
||||
sd->vcur.sharpness = 6;
|
||||
sd->vcur.contrast = 0;
|
||||
sd->vcur.gamma = 32;
|
||||
sd->vcur.hue = 0;
|
||||
sd->vcur.saturation = 128;
|
||||
sd->vcur.whitebal = 64;
|
||||
|
||||
sd->vmax.backlight = 64;
|
||||
sd->vmax.brightness = 255;
|
||||
sd->vmax.sharpness = 31;
|
||||
sd->vmax.contrast = 255;
|
||||
sd->vmax.gamma = 64;
|
||||
sd->vmax.hue = 255 + 1;
|
||||
sd->vmax.saturation = 255;
|
||||
sd->vmax.whitebal = 128;
|
||||
sd->vmax.mirror = 0;
|
||||
sd->vmax.flip = 0;
|
||||
sd->vmax.AC50Hz = 0;
|
||||
|
||||
sd->dev_camera_settings = ov2640_camera_settings;
|
||||
sd->dev_init_at_startup = ov2640_init_at_startup;
|
||||
sd->dev_configure_alt = ov2640_configure_alt;
|
||||
sd->dev_init_pre_alt = ov2640_init_pre_alt;
|
||||
sd->dev_post_unset_alt = ov2640_post_unset_alt;
|
||||
}
|
||||
|
||||
/*==========================================================================*/
|
||||
|
||||
static void common(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
fetch_validx(gspca_dev, tbl_common, ARRAY_SIZE(tbl_common));
|
||||
}
|
||||
|
||||
static int ov2640_init_at_startup(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
fetch_validx(gspca_dev, tbl_init_at_startup,
|
||||
ARRAY_SIZE(tbl_init_at_startup));
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, dat_init1);
|
||||
|
||||
common(gspca_dev);
|
||||
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0006, 1, dat_init2);
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x00ef, 0x0006, 0, NULL);
|
||||
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0000, 1, dat_init3);
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0051, 0x0000, 0, NULL);
|
||||
/* ctrl_out(gspca_dev, 0x40, 11, 0x0000, 0x0000, 0, NULL); */
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ov2640_init_pre_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
|
||||
sd->vold.backlight = -1;
|
||||
sd->vold.brightness = -1;
|
||||
sd->vold.sharpness = -1;
|
||||
sd->vold.contrast = -1;
|
||||
sd->vold.saturation = -1;
|
||||
sd->vold.gamma = -1;
|
||||
sd->vold.hue = -1;
|
||||
sd->vold.whitebal = -1;
|
||||
|
||||
ov2640_init_post_alt(gspca_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ov2640_init_post_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
|
||||
s32 n; /* reserved for FETCH macros */
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 5, 0x0001, 0x0000, 0, NULL);
|
||||
|
||||
n = fetch_validx(gspca_dev, tbl_sensor_settings_common_a,
|
||||
ARRAY_SIZE(tbl_sensor_settings_common_a));
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, dat_post);
|
||||
common(gspca_dev);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_sensor_settings_common_a,
|
||||
ARRAY_SIZE(tbl_sensor_settings_common_a), n);
|
||||
|
||||
switch (reso) {
|
||||
case IMAGE_640:
|
||||
n = fetch_validx(gspca_dev, tbl_640, ARRAY_SIZE(tbl_640));
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, dat_640);
|
||||
break;
|
||||
|
||||
case IMAGE_800:
|
||||
n = fetch_validx(gspca_dev, tbl_800, ARRAY_SIZE(tbl_800));
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 12, dat_800);
|
||||
break;
|
||||
|
||||
case IMAGE_1600:
|
||||
case IMAGE_1280:
|
||||
n = fetch_validx(gspca_dev, tbl_big_a, ARRAY_SIZE(tbl_big_a));
|
||||
|
||||
if (reso == IMAGE_1280) {
|
||||
n = fetch_validx(gspca_dev, tbl_big_b,
|
||||
ARRAY_SIZE(tbl_big_b));
|
||||
} else {
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x601d, 0x0086, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6001, 0x00d7, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6082, 0x00d3, 0, NULL);
|
||||
}
|
||||
|
||||
n = fetch_validx(gspca_dev, tbl_big_c, ARRAY_SIZE(tbl_big_c));
|
||||
|
||||
if (reso == IMAGE_1280) {
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6001, 0x00ff, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
|
||||
12, dat_1280);
|
||||
} else {
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6020, 0x008c, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6001, 0x00ff, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6076, 0x0018, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
|
||||
12, dat_1600);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
n = fetch_validx(gspca_dev, tbl_sensor_settings_common_b,
|
||||
ARRAY_SIZE(tbl_sensor_settings_common_b));
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0000, 1, c50);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_sensor_settings_common_b,
|
||||
ARRAY_SIZE(tbl_sensor_settings_common_b), n);
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x8004, 1, c28);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_sensor_settings_common_b,
|
||||
ARRAY_SIZE(tbl_sensor_settings_common_b), n);
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x8004, 1, ca8);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_sensor_settings_common_b,
|
||||
ARRAY_SIZE(tbl_sensor_settings_common_b), n);
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x0000, 0x0000, 1, c50);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_sensor_settings_common_b,
|
||||
ARRAY_SIZE(tbl_sensor_settings_common_b), n);
|
||||
|
||||
ov2640_camera_settings(gspca_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ov2640_configure_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
|
||||
|
||||
switch (reso) {
|
||||
case IMAGE_640:
|
||||
gspca_dev->alt = 3 + 1;
|
||||
break;
|
||||
|
||||
case IMAGE_800:
|
||||
case IMAGE_1280:
|
||||
case IMAGE_1600:
|
||||
gspca_dev->alt = 1 + 1;
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ov2640_camera_settings(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
|
||||
s32 backlight = sd->vcur.backlight;
|
||||
s32 bright = sd->vcur.brightness;
|
||||
s32 sharp = sd->vcur.sharpness;
|
||||
s32 gam = sd->vcur.gamma;
|
||||
s32 cntr = sd->vcur.contrast;
|
||||
s32 sat = sd->vcur.saturation;
|
||||
s32 hue = sd->vcur.hue;
|
||||
s32 wbal = sd->vcur.whitebal;
|
||||
|
||||
if (backlight != sd->vold.backlight) {
|
||||
if (backlight < 0 || backlight > sd->vmax.backlight)
|
||||
backlight = 0;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6001 , 0x00ff,
|
||||
0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x601f + backlight , 0x0024,
|
||||
0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x601f + backlight - 10, 0x0025,
|
||||
0, NULL);
|
||||
/* No sd->vold.backlight=backlight; (to be done again later) */
|
||||
}
|
||||
|
||||
if (bright != sd->vold.brightness) {
|
||||
sd->vold.brightness = bright;
|
||||
if (bright < 0 || bright > sd->vmax.brightness)
|
||||
bright = 0;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6000 , 0x00ff, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6009 , 0x007c, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6000 + bright, 0x007d, 0, NULL);
|
||||
}
|
||||
|
||||
if (wbal != sd->vold.whitebal) {
|
||||
sd->vold.whitebal = wbal;
|
||||
if (wbal < 0 || wbal > sd->vmax.whitebal)
|
||||
wbal = 0;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6000 , 0x00ff, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6003 , 0x007c, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6000 + wbal, 0x007d, 0, NULL);
|
||||
}
|
||||
|
||||
if (cntr != sd->vold.contrast) {
|
||||
sd->vold.contrast = cntr;
|
||||
if (cntr < 0 || cntr > sd->vmax.contrast)
|
||||
cntr = 0;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6000 , 0x00ff, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6007 , 0x007c, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6000 + cntr, 0x007d, 0, NULL);
|
||||
}
|
||||
|
||||
if (sat != sd->vold.saturation) {
|
||||
sd->vold.saturation = sat;
|
||||
if (sat < 0 || sat > sd->vmax.saturation)
|
||||
sat = 0;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6000 , 0x00ff, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6001 , 0x007c, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6000 + sat, 0x007d, 0, NULL);
|
||||
}
|
||||
|
||||
if (sharp != sd->vold.sharpness) {
|
||||
sd->vold.sharpness = sharp;
|
||||
if (sharp < 0 || sharp > sd->vmax.sharpness)
|
||||
sharp = 0;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6000 , 0x00ff, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6001 , 0x0092, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x60c0 + sharp, 0x0093, 0, NULL);
|
||||
}
|
||||
|
||||
if (hue != sd->vold.hue) {
|
||||
sd->vold.hue = hue;
|
||||
if (hue < 0 || hue > sd->vmax.hue)
|
||||
hue = 0;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6000 , 0x00ff, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6002 , 0x007c, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6000 + hue * (hue < 255), 0x007d,
|
||||
0, NULL);
|
||||
if (hue >= sd->vmax.hue)
|
||||
sd->swapRB = 1;
|
||||
else
|
||||
sd->swapRB = 0;
|
||||
}
|
||||
|
||||
if (gam != sd->vold.gamma) {
|
||||
sd->vold.gamma = gam;
|
||||
if (gam < 0 || gam > sd->vmax.gamma)
|
||||
gam = 0;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6000 , 0x00ff, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6008 , 0x007c, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6000 + gam, 0x007d, 0, NULL);
|
||||
}
|
||||
|
||||
if (backlight != sd->vold.backlight) {
|
||||
sd->vold.backlight = backlight;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x6001 , 0x00ff,
|
||||
0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x601f + backlight , 0x0024,
|
||||
0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x601f + backlight - 10, 0x0025,
|
||||
0, NULL);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void ov2640_post_unset_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
ctrl_out(gspca_dev, 0x40, 5, 0x0000, 0x0000, 0, NULL);
|
||||
msleep(20);
|
||||
fetch_validx(gspca_dev, tbl_post_unset_alt,
|
||||
ARRAY_SIZE(tbl_post_unset_alt));
|
||||
}
|
||||
|
|
@ -0,0 +1,337 @@
|
|||
/* @file gl860-ov9655.c
|
||||
* @author Olivier LORIN, from logs done by Simon (Sur3) and Almighurt
|
||||
* on dsd's weblog
|
||||
* @date 2009-08-27
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/* Sensor : OV9655 */
|
||||
|
||||
#include "gl860.h"
|
||||
|
||||
static struct validx tbl_init_at_startup[] = {
|
||||
{0x0000, 0x0000}, {0x0010, 0x0010}, {0x0008, 0x00c0}, {0x0001, 0x00c1},
|
||||
{0x0001, 0x00c2}, {0x0020, 0x0006}, {0x006a, 0x000d},
|
||||
|
||||
{0x0040, 0x0000},
|
||||
};
|
||||
|
||||
static struct validx tbl_commmon[] = {
|
||||
{0x0041, 0x0000}, {0x006a, 0x0007}, {0x0063, 0x0006}, {0x006a, 0x000d},
|
||||
{0x0000, 0x00c0}, {0x0010, 0x0010}, {0x0001, 0x00c1}, {0x0041, 0x00c2},
|
||||
{0x0004, 0x00d8}, {0x0012, 0x0004}, {0x0000, 0x0058}, {0x0040, 0x0000},
|
||||
{0x00f3, 0x0006}, {0x0058, 0x0000}, {0x0048, 0x0000}, {0x0061, 0x0000},
|
||||
};
|
||||
|
||||
static s32 tbl_length[] = {12, 56, 52, 54, 56, 42, 32, 12};
|
||||
|
||||
static u8 *tbl_640[] = {
|
||||
"\x00\x40\x07\x6a\x06\xf3\x0d\x6a" "\x10\x10\xc1\x01"
|
||||
,
|
||||
"\x12\x80\x00\x00\x01\x98\x02\x80" "\x03\x12\x04\x03\x0b\x57\x0e\x61"
|
||||
"\x0f\x42\x11\x01\x12\x60\x13\x00" "\x14\x3a\x16\x24\x17\x14\x18\x00"
|
||||
"\x19\x01\x1a\x3d\x1e\x04\x24\x3c" "\x25\x36\x26\x72\x27\x08\x28\x08"
|
||||
"\x29\x15\x2a\x00\x2b\x00\x2c\x08"
|
||||
,
|
||||
"\x32\xff\x33\x00\x34\x3d\x35\x00" "\x36\xfa\x38\x72\x39\x57\x3a\x00"
|
||||
"\x3b\x0c\x3d\x99\x3e\x0c\x3f\xc1" "\x40\xc0\x41\x00\x42\xc0\x43\x0a"
|
||||
"\x44\xf0\x45\x46\x46\x62\x47\x2a" "\x48\x3c\x4a\xee\x4b\xe7\x4c\xe7"
|
||||
"\x4d\xe7\x4e\xe7"
|
||||
,
|
||||
"\x4f\x98\x50\x98\x51\x00\x52\x28" "\x53\x70\x54\x98\x58\x1a\x59\x85"
|
||||
"\x5a\xa9\x5b\x64\x5c\x84\x5d\x53" "\x5e\x0e\x5f\xf0\x60\xf0\x61\xf0"
|
||||
"\x62\x00\x63\x00\x64\x02\x65\x20" "\x66\x00\x69\x0a\x6b\x5a\x6c\x04"
|
||||
"\x6d\x55\x6e\x00\x6f\x9d"
|
||||
,
|
||||
"\x70\x15\x71\x78\x72\x00\x73\x00" "\x74\x3a\x75\x35\x76\x01\x77\x02"
|
||||
"\x7a\x24\x7b\x04\x7c\x07\x7d\x10" "\x7e\x28\x7f\x36\x80\x44\x81\x52"
|
||||
"\x82\x60\x83\x6c\x84\x78\x85\x8c" "\x86\x9e\x87\xbb\x88\xd2\x89\xe5"
|
||||
"\x8a\x23\x8c\x8d\x90\x7c\x91\x7b"
|
||||
,
|
||||
"\x9d\x02\x9e\x02\x9f\x74\xa0\x73" "\xa1\x40\xa4\x50\xa5\x68\xa6\x70"
|
||||
"\xa8\xc1\xa9\xef\xaa\x92\xab\x04" "\xac\x80\xad\x80\xae\x80\xaf\x80"
|
||||
"\xb2\xf2\xb3\x20\xb4\x20\xb5\x00" "\xb6\xaf"
|
||||
,
|
||||
"\xbb\xae\xbc\x4f\xbd\x4e\xbe\x6a" "\xbf\x68\xc0\xaa\xc1\xc0\xc2\x01"
|
||||
"\xc3\x4e\xc6\x85\xc7\x81\xc9\xe0" "\xca\xe8\xcb\xf0\xcc\xd8\xcd\x93"
|
||||
,
|
||||
"\xd0\x01\xd1\x08\xd2\xe0\xd3\x01" "\xd4\x10\xd5\x80"
|
||||
};
|
||||
|
||||
static u8 *tbl_800[] = {
|
||||
"\x00\x40\x07\x6a\x06\xf3\x0d\x6a" "\x10\x10\xc1\x01"
|
||||
,
|
||||
"\x12\x80\x00\x00\x01\x98\x02\x80" "\x03\x12\x04\x01\x0b\x57\x0e\x61"
|
||||
"\x0f\x42\x11\x00\x12\x00\x13\x00" "\x14\x3a\x16\x24\x17\x1b\x18\xbb"
|
||||
"\x19\x01\x1a\x81\x1e\x04\x24\x3c" "\x25\x36\x26\x72\x27\x08\x28\x08"
|
||||
"\x29\x15\x2a\x00\x2b\x00\x2c\x08"
|
||||
,
|
||||
"\x32\xa4\x33\x00\x34\x3d\x35\x00" "\x36\xf8\x38\x72\x39\x57\x3a\x00"
|
||||
"\x3b\x0c\x3d\x99\x3e\x0c\x3f\xc2" "\x40\xc0\x41\x00\x42\xc0\x43\x0a"
|
||||
"\x44\xf0\x45\x46\x46\x62\x47\x2a" "\x48\x3c\x4a\xec\x4b\xe8\x4c\xe8"
|
||||
"\x4d\xe8\x4e\xe8"
|
||||
,
|
||||
"\x4f\x98\x50\x98\x51\x00\x52\x28" "\x53\x70\x54\x98\x58\x1a\x59\x85"
|
||||
"\x5a\xa9\x5b\x64\x5c\x84\x5d\x53" "\x5e\x0e\x5f\xf0\x60\xf0\x61\xf0"
|
||||
"\x62\x00\x63\x00\x64\x02\x65\x20" "\x66\x00\x69\x02\x6b\x5a\x6c\x04"
|
||||
"\x6d\x55\x6e\x00\x6f\x9d"
|
||||
,
|
||||
"\x70\x08\x71\x78\x72\x00\x73\x01" "\x74\x3a\x75\x35\x76\x01\x77\x02"
|
||||
"\x7a\x24\x7b\x04\x7c\x07\x7d\x10" "\x7e\x28\x7f\x36\x80\x44\x81\x52"
|
||||
"\x82\x60\x83\x6c\x84\x78\x85\x8c" "\x86\x9e\x87\xbb\x88\xd2\x89\xe5"
|
||||
"\x8a\x23\x8c\x0d\x90\x90\x91\x90"
|
||||
,
|
||||
"\x9d\x02\x9e\x02\x9f\x94\xa0\x94" "\xa1\x01\xa4\x50\xa5\x68\xa6\x70"
|
||||
"\xa8\xc1\xa9\xef\xaa\x92\xab\x04" "\xac\x80\xad\x80\xae\x80\xaf\x80"
|
||||
"\xb2\xf2\xb3\x20\xb4\x20\xb5\x00" "\xb6\xaf"
|
||||
,
|
||||
"\xbb\xae\xbc\x38\xbd\x39\xbe\x01" "\xbf\x01\xc0\xe2\xc1\xc0\xc2\x01"
|
||||
"\xc3\x4e\xc6\x85\xc7\x81\xc9\xe0" "\xca\xe8\xcb\xf0\xcc\xd8\xcd\x93"
|
||||
,
|
||||
"\xd0\x21\xd1\x18\xd2\xe0\xd3\x01" "\xd4\x28\xd5\x00"
|
||||
};
|
||||
|
||||
static u8 c04[] = {0x04};
|
||||
static u8 dat_post_1[] = "\x04\x00\x10\x20\xa1\x00\x00\x02";
|
||||
static u8 dat_post_2[] = "\x10\x10\xc1\x02";
|
||||
static u8 dat_post_3[] = "\x04\x00\x10\x7c\xa1\x00\x00\x04";
|
||||
static u8 dat_post_4[] = "\x10\x02\xc1\x06";
|
||||
static u8 dat_post_5[] = "\x04\x00\x10\x7b\xa1\x00\x00\x08";
|
||||
static u8 dat_post_6[] = "\x10\x10\xc1\x05";
|
||||
static u8 dat_post_7[] = "\x04\x00\x10\x7c\xa1\x00\x00\x08";
|
||||
static u8 dat_post_8[] = "\x04\x00\x10\x7c\xa1\x00\x00\x09";
|
||||
|
||||
static struct validx tbl_init_post_alt[] = {
|
||||
{0x6032, 0x00ff}, {0x6032, 0x00ff}, {0x6032, 0x00ff}, {0x603c, 0x00ff},
|
||||
{0x6003, 0x00ff}, {0x6032, 0x00ff}, {0x6032, 0x00ff}, {0x6001, 0x00ff},
|
||||
{0x6000, 0x801e},
|
||||
{0xffff, 0xffff},
|
||||
{0x6004, 0x001e}, {0x6000, 0x801e},
|
||||
{0xffff, 0xffff},
|
||||
{0x6004, 0x001e}, {0x6012, 0x0003}, {0x6000, 0x801e},
|
||||
{0xffff, 0xffff},
|
||||
{0x6004, 0x001e}, {0x6000, 0x801e},
|
||||
{0xffff, 0xffff},
|
||||
{0x6004, 0x001e}, {0x6012, 0x0003},
|
||||
{0xffff, 0xffff},
|
||||
{0x6000, 0x801e},
|
||||
{0xffff, 0xffff},
|
||||
{0x6004, 0x001e}, {0x6000, 0x801e},
|
||||
{0xffff, 0xffff},
|
||||
{0x6004, 0x001e}, {0x6012, 0x0003}, {0x6000, 0x801e},
|
||||
{0xffff, 0xffff},
|
||||
{0x6004, 0x001e}, {0x6000, 0x801e},
|
||||
{0xffff, 0xffff},
|
||||
{0x6004, 0x001e}, {0x6012, 0x0003},
|
||||
{0xffff, 0xffff},
|
||||
{0x6000, 0x801e},
|
||||
{0xffff, 0xffff},
|
||||
{0x6004, 0x001e}, {0x6000, 0x801e},
|
||||
{0xffff, 0xffff},
|
||||
{0x6004, 0x001e}, {0x6012, 0x0003},
|
||||
};
|
||||
|
||||
static int ov9655_init_at_startup(struct gspca_dev *gspca_dev);
|
||||
static int ov9655_configure_alt(struct gspca_dev *gspca_dev);
|
||||
static int ov9655_init_pre_alt(struct gspca_dev *gspca_dev);
|
||||
static int ov9655_init_post_alt(struct gspca_dev *gspca_dev);
|
||||
static void ov9655_post_unset_alt(struct gspca_dev *gspca_dev);
|
||||
static int ov9655_camera_settings(struct gspca_dev *gspca_dev);
|
||||
/*==========================================================================*/
|
||||
|
||||
void ov9655_init_settings(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
|
||||
sd->vcur.backlight = 0;
|
||||
sd->vcur.brightness = 128;
|
||||
sd->vcur.sharpness = 0;
|
||||
sd->vcur.contrast = 0;
|
||||
sd->vcur.gamma = 0;
|
||||
sd->vcur.hue = 0;
|
||||
sd->vcur.saturation = 0;
|
||||
sd->vcur.whitebal = 0;
|
||||
|
||||
sd->vmax.backlight = 0;
|
||||
sd->vmax.brightness = 255;
|
||||
sd->vmax.sharpness = 0;
|
||||
sd->vmax.contrast = 0;
|
||||
sd->vmax.gamma = 0;
|
||||
sd->vmax.hue = 0 + 1;
|
||||
sd->vmax.saturation = 0;
|
||||
sd->vmax.whitebal = 0;
|
||||
sd->vmax.mirror = 0;
|
||||
sd->vmax.flip = 0;
|
||||
sd->vmax.AC50Hz = 0;
|
||||
|
||||
sd->dev_camera_settings = ov9655_camera_settings;
|
||||
sd->dev_init_at_startup = ov9655_init_at_startup;
|
||||
sd->dev_configure_alt = ov9655_configure_alt;
|
||||
sd->dev_init_pre_alt = ov9655_init_pre_alt;
|
||||
sd->dev_post_unset_alt = ov9655_post_unset_alt;
|
||||
}
|
||||
|
||||
/*==========================================================================*/
|
||||
|
||||
static int ov9655_init_at_startup(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
fetch_validx(gspca_dev, tbl_init_at_startup,
|
||||
ARRAY_SIZE(tbl_init_at_startup));
|
||||
fetch_validx(gspca_dev, tbl_commmon, ARRAY_SIZE(tbl_commmon));
|
||||
/* ctrl_out(gspca_dev, 0x40, 11, 0x0000, 0x0000, 0, NULL);*/
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ov9655_init_pre_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
|
||||
sd->vold.brightness = -1;
|
||||
sd->vold.hue = -1;
|
||||
|
||||
fetch_validx(gspca_dev, tbl_commmon, ARRAY_SIZE(tbl_commmon));
|
||||
|
||||
ov9655_init_post_alt(gspca_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ov9655_init_post_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
|
||||
s32 n; /* reserved for FETCH macros */
|
||||
s32 i;
|
||||
u8 **tbl;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 5, 0x0001, 0x0000, 0, NULL);
|
||||
|
||||
tbl = (reso == IMAGE_640) ? tbl_640 : tbl_800;
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
|
||||
tbl_length[0], tbl[0]);
|
||||
for (i = 1; i < 7; i++)
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200,
|
||||
tbl_length[i], tbl[i]);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200,
|
||||
tbl_length[7], tbl[7]);
|
||||
|
||||
n = fetch_validx(gspca_dev, tbl_init_post_alt,
|
||||
ARRAY_SIZE(tbl_init_post_alt));
|
||||
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
|
||||
ARRAY_SIZE(tbl_init_post_alt), n);
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
|
||||
ARRAY_SIZE(tbl_init_post_alt), n);
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
|
||||
ARRAY_SIZE(tbl_init_post_alt), n);
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
|
||||
ARRAY_SIZE(tbl_init_post_alt), n);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_1);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
|
||||
ARRAY_SIZE(tbl_init_post_alt), n);
|
||||
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
|
||||
ARRAY_SIZE(tbl_init_post_alt), n);
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
|
||||
ARRAY_SIZE(tbl_init_post_alt), n);
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
|
||||
ARRAY_SIZE(tbl_init_post_alt), n);
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
|
||||
ARRAY_SIZE(tbl_init_post_alt), n);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_1);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
|
||||
ARRAY_SIZE(tbl_init_post_alt), n);
|
||||
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
|
||||
ARRAY_SIZE(tbl_init_post_alt), n);
|
||||
ctrl_in(gspca_dev, 0xc0, 2, 0x6000, 0x801e, 1, c04);
|
||||
keep_on_fetching_validx(gspca_dev, tbl_init_post_alt,
|
||||
ARRAY_SIZE(tbl_init_post_alt), n);
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_1);
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 4, dat_post_2);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_3);
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 4, dat_post_4);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_5);
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x0000, 0x0200, 4, dat_post_6);
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_7);
|
||||
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_post_8);
|
||||
|
||||
ov9655_camera_settings(gspca_dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ov9655_configure_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
s32 reso = gspca_dev->cam.cam_mode[(s32) gspca_dev->curr_mode].priv;
|
||||
|
||||
switch (reso) {
|
||||
case IMAGE_640:
|
||||
gspca_dev->alt = 1 + 1;
|
||||
break;
|
||||
|
||||
default:
|
||||
gspca_dev->alt = 1 + 1;
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ov9655_camera_settings(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
|
||||
u8 dat_bright[] = "\x04\x00\x10\x7c\xa1\x00\x00\x70";
|
||||
|
||||
s32 bright = sd->vcur.brightness;
|
||||
s32 hue = sd->vcur.hue;
|
||||
|
||||
if (bright != sd->vold.brightness) {
|
||||
sd->vold.brightness = bright;
|
||||
if (bright < 0 || bright > sd->vmax.brightness)
|
||||
bright = 0;
|
||||
|
||||
dat_bright[3] = bright;
|
||||
ctrl_out(gspca_dev, 0x40, 3, 0x6000, 0x0200, 8, dat_bright);
|
||||
}
|
||||
|
||||
if (hue != sd->vold.hue) {
|
||||
sd->vold.hue = hue;
|
||||
sd->swapRB = (hue != 0);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void ov9655_post_unset_alt(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
ctrl_out(gspca_dev, 0x40, 5, 0x0000, 0x0000, 0, NULL);
|
||||
ctrl_out(gspca_dev, 0x40, 1, 0x0061, 0x0000, 0, NULL);
|
||||
}
|
||||
|
|
@ -0,0 +1,783 @@
|
|||
/* @file gl860.c
|
||||
* @date 2009-08-27
|
||||
*
|
||||
* Genesys Logic webcam with gl860 subdrivers
|
||||
*
|
||||
* Driver by Olivier Lorin <o.lorin@laposte.net>
|
||||
* GSPCA by Jean-Francois Moine <http://moinejf.free.fr>
|
||||
* Thanks BUGabundo and Malmostoso for your amazing help!
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
#include "gspca.h"
|
||||
#include "gl860.h"
|
||||
|
||||
MODULE_AUTHOR("Olivier Lorin <lorin@laposte.net>");
|
||||
MODULE_DESCRIPTION("GSPCA/Genesys Logic GL860 USB 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,
|
||||
struct gspca_frame *frame, u8 *data, s32 len);
|
||||
static void sd_callback(struct gspca_dev *gspca_dev);
|
||||
|
||||
static int gl860_guess_sensor(struct gspca_dev *gspca_dev,
|
||||
s32 vendor_id, s32 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 =============================*/
|
||||
|
||||
/* Functions to get and set a control value */
|
||||
#define SD_SETGET(thename) \
|
||||
static int sd_set_##thename(struct gspca_dev *gspca_dev, s32 val)\
|
||||
{\
|
||||
struct sd *sd = (struct sd *) gspca_dev;\
|
||||
\
|
||||
sd->vcur.thename = val;\
|
||||
if (gspca_dev->streaming)\
|
||||
sd->dev_camera_settings(gspca_dev);\
|
||||
return 0;\
|
||||
} \
|
||||
static int sd_get_##thename(struct gspca_dev *gspca_dev, s32 *val)\
|
||||
{\
|
||||
struct sd *sd = (struct sd *) gspca_dev;\
|
||||
\
|
||||
*val = sd->vcur.thename;\
|
||||
return 0;\
|
||||
}
|
||||
|
||||
SD_SETGET(mirror)
|
||||
SD_SETGET(flip)
|
||||
SD_SETGET(AC50Hz)
|
||||
SD_SETGET(backlight)
|
||||
SD_SETGET(brightness)
|
||||
SD_SETGET(gamma)
|
||||
SD_SETGET(hue)
|
||||
SD_SETGET(saturation)
|
||||
SD_SETGET(sharpness)
|
||||
SD_SETGET(whitebal)
|
||||
SD_SETGET(contrast)
|
||||
|
||||
#define GL860_NCTRLS 11
|
||||
|
||||
/* control table */
|
||||
static struct ctrl sd_ctrls_mi1320[GL860_NCTRLS];
|
||||
static struct ctrl sd_ctrls_mi2020[GL860_NCTRLS];
|
||||
static struct ctrl sd_ctrls_mi2020b[GL860_NCTRLS];
|
||||
static struct ctrl sd_ctrls_ov2640[GL860_NCTRLS];
|
||||
static struct ctrl sd_ctrls_ov9655[GL860_NCTRLS];
|
||||
|
||||
#define SET_MY_CTRL(theid, \
|
||||
thetype, thelabel, thename) \
|
||||
if (sd->vmax.thename != 0) {\
|
||||
sd_ctrls[nCtrls].qctrl.id = theid;\
|
||||
sd_ctrls[nCtrls].qctrl.type = thetype;\
|
||||
strcpy(sd_ctrls[nCtrls].qctrl.name, thelabel);\
|
||||
sd_ctrls[nCtrls].qctrl.minimum = 0;\
|
||||
sd_ctrls[nCtrls].qctrl.maximum = sd->vmax.thename;\
|
||||
sd_ctrls[nCtrls].qctrl.default_value = sd->vcur.thename;\
|
||||
sd_ctrls[nCtrls].qctrl.step = \
|
||||
(sd->vmax.thename < 16) ? 1 : sd->vmax.thename/16;\
|
||||
sd_ctrls[nCtrls].set = sd_set_##thename;\
|
||||
sd_ctrls[nCtrls].get = sd_get_##thename;\
|
||||
nCtrls++;\
|
||||
}
|
||||
|
||||
static int gl860_build_control_table(struct gspca_dev *gspca_dev)
|
||||
{
|
||||
struct sd *sd = (struct sd *) gspca_dev;
|
||||
struct ctrl *sd_ctrls;
|
||||
int nCtrls = 0;
|
||||
|
||||
if (_MI1320_)
|
||||
sd_ctrls = sd_ctrls_mi1320;
|
||||
else if (_MI2020_)
|
||||
sd_ctrls = sd_ctrls_mi2020;
|
||||
else if (_MI2020b_)
|
||||
sd_ctrls = sd_ctrls_mi2020b;
|
||||
else if (_OV2640_)
|
||||
sd_ctrls = sd_ctrls_ov2640;
|
||||
else if (_OV9655_)
|
||||
sd_ctrls = sd_ctrls_ov9655;
|
||||
|
||||
memset(sd_ctrls, 0, GL860_NCTRLS * sizeof(struct ctrl));
|
||||
|
||||
SET_MY_CTRL(V4L2_CID_BRIGHTNESS,
|
||||
V4L2_CTRL_TYPE_INTEGER, "Brightness", brightness)
|
||||
SET_MY_CTRL(V4L2_CID_SHARPNESS,
|
||||
V4L2_CTRL_TYPE_INTEGER, "Sharpness", sharpness)
|
||||
SET_MY_CTRL(V4L2_CID_CONTRAST,
|
||||
V4L2_CTRL_TYPE_INTEGER, "Contrast", contrast)
|
||||
SET_MY_CTRL(V4L2_CID_GAMMA,
|
||||
V4L2_CTRL_TYPE_INTEGER, "Gamma", gamma)
|
||||
SET_MY_CTRL(V4L2_CID_HUE,
|
||||
V4L2_CTRL_TYPE_INTEGER, "Palette", hue)
|
||||
SET_MY_CTRL(V4L2_CID_SATURATION,
|
||||
V4L2_CTRL_TYPE_INTEGER, "Saturation", saturation)
|
||||
SET_MY_CTRL(V4L2_CID_WHITE_BALANCE_TEMPERATURE,
|
||||
V4L2_CTRL_TYPE_INTEGER, "White Bal.", whitebal)
|
||||
SET_MY_CTRL(V4L2_CID_BACKLIGHT_COMPENSATION,
|
||||
V4L2_CTRL_TYPE_INTEGER, "Backlight" , backlight)
|
||||
|
||||
SET_MY_CTRL(V4L2_CID_HFLIP,
|
||||
V4L2_CTRL_TYPE_BOOLEAN, "Mirror", mirror)
|
||||
SET_MY_CTRL(V4L2_CID_VFLIP,
|
||||
V4L2_CTRL_TYPE_BOOLEAN, "Flip", flip)
|
||||
SET_MY_CTRL(V4L2_CID_POWER_LINE_FREQUENCY,
|
||||
V4L2_CTRL_TYPE_BOOLEAN, "50Hz", AC50Hz)
|
||||
|
||||
return nCtrls;
|
||||
}
|
||||
|
||||
/*==================== sud-driver structure initialisation =================*/
|
||||
|
||||
static struct sd_desc sd_desc_mi1320 = {
|
||||
.name = MODULE_NAME,
|
||||
.ctrls = sd_ctrls_mi1320,
|
||||
.nctrls = GL860_NCTRLS,
|
||||
.config = sd_config,
|
||||
.init = sd_init,
|
||||
.isoc_init = sd_isoc_init,
|
||||
.start = sd_start,
|
||||
.stop0 = sd_stop0,
|
||||
.pkt_scan = sd_pkt_scan,
|
||||
.dq_callback = sd_callback,
|
||||
};
|
||||
|
||||
static struct sd_desc sd_desc_mi2020 = {
|
||||
.name = MODULE_NAME,
|
||||
.ctrls = sd_ctrls_mi2020,
|
||||
.nctrls = GL860_NCTRLS,
|
||||
.config = sd_config,
|
||||
.init = sd_init,
|
||||
.isoc_init = sd_isoc_init,
|
||||
.start = sd_start,
|
||||
.stop0 = sd_stop0,
|
||||
.pkt_scan = sd_pkt_scan,
|
||||
.dq_callback = sd_callback,
|
||||
};
|
||||
|
||||
static struct sd_desc sd_desc_mi2020b = {
|
||||
.name = MODULE_NAME,
|
||||
.ctrls = sd_ctrls_mi2020b,
|
||||
.nctrls = GL860_NCTRLS,
|
||||
.config = sd_config,
|
||||
.init = sd_init,
|
||||
.isoc_init = sd_isoc_init,
|
||||
.start = sd_start,
|
||||
.stop0 = sd_stop0,
|
||||
.pkt_scan = sd_pkt_scan,
|
||||
.dq_callback = sd_callback,
|
||||
};
|
||||
|
||||
static struct sd_desc sd_desc_ov2640 = {
|
||||
.name = MODULE_NAME,
|
||||
.ctrls = sd_ctrls_ov2640,
|
||||
.nctrls = GL860_NCTRLS,
|
||||
.config = sd_config,
|
||||
.init = sd_init,
|
||||
.isoc_init = sd_isoc_init,
|
||||
.start = sd_start,
|
||||
.stop0 = sd_stop0,
|
||||
.pkt_scan = sd_pkt_scan,
|
||||
.dq_callback = sd_callback,
|
||||
};
|
||||
|
||||
static struct sd_desc sd_desc_ov9655 = {
|
||||
.name = MODULE_NAME,
|
||||
.ctrls = sd_ctrls_ov9655,
|
||||
.nctrls = GL860_NCTRLS,
|
||||
.config = sd_config,
|
||||
.init = sd_init,
|
||||
.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, 600, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
|
||||
.bytesperline = 800,
|
||||
.sizeimage = 800 * 600,
|
||||
.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, 1200, V4L2_PIX_FMT_SGBRG8, V4L2_FIELD_NONE,
|
||||
.bytesperline = 1600,
|
||||
.sizeimage = 1600 * 1200,
|
||||
.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;
|
||||
s32 vendor_id, product_id;
|
||||
|
||||
/* Get USB VendorID and ProductID */
|
||||
vendor_id = le16_to_cpu(id->idVendor);
|
||||
product_id = le16_to_cpu(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;
|
||||
else if (strcmp(sensor, "MI2020b") == 0)
|
||||
sd->sensor = ID_MI2020b;
|
||||
|
||||
/* 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;
|
||||
gspca_dev->nbalt = 4;
|
||||
|
||||
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_MI2020b:
|
||||
gspca_dev->sd_desc = &sd_desc_mi2020b;
|
||||
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;
|
||||
gl860_build_control_table(gspca_dev);
|
||||
|
||||
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;
|
||||
|
||||
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,
|
||||
struct gspca_frame *frame, u8 *data, s32 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 endianess does not matter */
|
||||
switch (*(s16 *) data) {
|
||||
case 0x0202: /* End of frame, start a new one */
|
||||
frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame, data, 0);
|
||||
nSkipped = 0;
|
||||
if (sd->nbIm >= 0 && sd->nbIm < 10)
|
||||
sd->nbIm++;
|
||||
gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, 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, frame, 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 __devinitdata 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)
|
||||
{
|
||||
struct gspca_dev *gspca_dev;
|
||||
s32 ret;
|
||||
|
||||
ret = gspca_dev_probe(intf, id,
|
||||
&sd_desc_mi1320, sizeof(struct sd), THIS_MODULE);
|
||||
|
||||
if (ret >= 0) {
|
||||
gspca_dev = usb_get_intfdata(intf);
|
||||
|
||||
PDEBUG(D_PROBE,
|
||||
"Camera is now controlling video device /dev/video%d",
|
||||
gspca_dev->vdev.minor);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
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,
|
||||
#endif
|
||||
};
|
||||
|
||||
/*====================== Init and Exit module functions ====================*/
|
||||
|
||||
static int __init sd_mod_init(void)
|
||||
{
|
||||
PDEBUG(D_PROBE, "driver startup - version %s", DRIVER_VERSION);
|
||||
|
||||
if (usb_register(&sd_driver) < 0)
|
||||
return -1;
|
||||
PDEBUG(D_PROBE, "driver registered");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __exit sd_mod_exit(void)
|
||||
{
|
||||
usb_deregister(&sd_driver);
|
||||
PDEBUG(D_PROBE, "driver deregistered");
|
||||
}
|
||||
|
||||
module_init(sd_mod_init);
|
||||
module_exit(sd_mod_exit);
|
||||
|
||||
/*==========================================================================*/
|
||||
|
||||
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 {
|
||||
r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
|
||||
req, pref, val, index, NULL, len, 400);
|
||||
}
|
||||
}
|
||||
|
||||
if (r < 0)
|
||||
PDEBUG(D_ERR,
|
||||
"ctrl transfer failed %4d "
|
||||
"[p%02x r%d v%04x i%04x len%d]",
|
||||
r, pref, req, val, index, len);
|
||||
else if (len > 1 && r < len)
|
||||
PDEBUG(D_ERR, "short ctrl transfer %d/%d", r, len);
|
||||
|
||||
if ((_MI2020_ || _MI2020b_ || _MI2020c_) && (val || index))
|
||||
msleep(1);
|
||||
if (_OV2640_)
|
||||
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,
|
||||
s32 vendor_id, s32 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);
|
||||
|
||||
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);
|
||||
PDEBUG(D_PROBE, "1st probe=%02x", probe);
|
||||
if (probe == 0xff)
|
||||
nOV++;
|
||||
}
|
||||
|
||||
if (nOV) {
|
||||
PDEBUG(D_PROBE, "0xff -> sensor OVXXXX");
|
||||
PDEBUG(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);
|
||||
|
||||
PDEBUG(D_PROBE, "2nd probe=%02x", probe);
|
||||
if (probe == 0x00)
|
||||
nb26++;
|
||||
if (probe == 0x26 || probe == 0x40) {
|
||||
sd->sensor = ID_OV2640;
|
||||
nb26 += 4;
|
||||
break;
|
||||
}
|
||||
if (probe == 0x96 || probe == 0x55) {
|
||||
sd->sensor = ID_OV9655;
|
||||
nb96 += 4;
|
||||
break;
|
||||
}
|
||||
if (probe == 0xff)
|
||||
nb96++;
|
||||
msleep(3);
|
||||
}
|
||||
if (nb26 < 4 && nb96 < 4) {
|
||||
PDEBUG(D_PROBE, "No relevant answer ");
|
||||
PDEBUG(D_PROBE, "* 1.3Mpixels -> use OV9655");
|
||||
PDEBUG(D_PROBE, "* 2.0Mpixels -> use OV2640");
|
||||
PDEBUG(D_PROBE,
|
||||
"To force a sensor, add that line to "
|
||||
"/etc/modprobe.d/options.conf:");
|
||||
PDEBUG(D_PROBE, "options gspca_gl860 "
|
||||
"sensor=\"OV2640\" or \"OV9655\"");
|
||||
return -1;
|
||||
}
|
||||
} else { /* probe = 0 */
|
||||
PDEBUG(D_PROBE, "No 0xff -> sensor MI2020");
|
||||
sd->sensor = ID_MI2020;
|
||||
}
|
||||
}
|
||||
|
||||
if (_MI1320_) {
|
||||
PDEBUG(D_PROBE, "05e3:f191 sensor MI1320 (1.3M)");
|
||||
} else if (_MI2020_) {
|
||||
PDEBUG(D_PROBE, "05e3:0503 sensor MI2020 (2.0M)");
|
||||
} else if (_MI2020b_) {
|
||||
PDEBUG(D_PROBE, "05e3:0503 sensor MI2020 alt. driver (2.0M)");
|
||||
} else if (_OV9655_) {
|
||||
PDEBUG(D_PROBE, "05e3:0503 sensor OV9655 (1.3M)");
|
||||
} else if (_OV2640_) {
|
||||
PDEBUG(D_PROBE, "05e3:0503 sensor OV2640 (2.0M)");
|
||||
} else {
|
||||
PDEBUG(D_PROBE, "***** Unknown sensor *****");
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
/* @file gl860.h
|
||||
* @author Olivier LORIN, tiré du pilote Syntek par Nicolas VIVIEN
|
||||
* @date 2009-08-27
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
#ifndef GL860_DEV_H
|
||||
#define GL860_DEV_H
|
||||
#include <linux/version.h>
|
||||
|
||||
#include "gspca.h"
|
||||
|
||||
#define MODULE_NAME "gspca_gl860"
|
||||
#define DRIVER_VERSION "0.9d10"
|
||||
|
||||
#define ctrl_in gl860_RTx
|
||||
#define ctrl_out gl860_RTx
|
||||
|
||||
#define ID_MI1320 1
|
||||
#define ID_OV2640 2
|
||||
#define ID_OV9655 4
|
||||
#define ID_MI2020 8
|
||||
#define ID_MI2020b 16
|
||||
|
||||
#define _MI1320_ (((struct sd *) gspca_dev)->sensor == ID_MI1320)
|
||||
#define _MI2020_ (((struct sd *) gspca_dev)->sensor == ID_MI2020)
|
||||
#define _MI2020b_ (((struct sd *) gspca_dev)->sensor == ID_MI2020b)
|
||||
#define _MI2020c_ 0
|
||||
#define _OV2640_ (((struct sd *) gspca_dev)->sensor == ID_OV2640)
|
||||
#define _OV9655_ (((struct sd *) gspca_dev)->sensor == ID_OV9655)
|
||||
|
||||
#define IMAGE_640 0
|
||||
#define IMAGE_800 1
|
||||
#define IMAGE_1280 2
|
||||
#define IMAGE_1600 3
|
||||
|
||||
struct sd_gl860 {
|
||||
u16 backlight;
|
||||
u16 brightness;
|
||||
u16 sharpness;
|
||||
u16 contrast;
|
||||
u16 gamma;
|
||||
u16 hue;
|
||||
u16 saturation;
|
||||
u16 whitebal;
|
||||
u8 mirror;
|
||||
u8 flip;
|
||||
u8 AC50Hz;
|
||||
};
|
||||
|
||||
/* Specific webcam descriptor */
|
||||
struct sd {
|
||||
struct gspca_dev gspca_dev; /* !! must be the first item */
|
||||
|
||||
struct sd_gl860 vcur;
|
||||
struct sd_gl860 vold;
|
||||
struct sd_gl860 vmax;
|
||||
|
||||
int (*dev_configure_alt) (struct gspca_dev *);
|
||||
int (*dev_init_at_startup)(struct gspca_dev *);
|
||||
int (*dev_init_pre_alt) (struct gspca_dev *);
|
||||
void (*dev_post_unset_alt) (struct gspca_dev *);
|
||||
int (*dev_camera_settings)(struct gspca_dev *);
|
||||
|
||||
u8 swapRB;
|
||||
u8 mirrorMask;
|
||||
u8 sensor;
|
||||
s32 nbIm;
|
||||
s32 nbRightUp;
|
||||
u8 waitSet;
|
||||
};
|
||||
|
||||
struct validx {
|
||||
u16 val;
|
||||
u16 idx;
|
||||
};
|
||||
|
||||
struct idxdata {
|
||||
u8 idx;
|
||||
u8 data[3];
|
||||
};
|
||||
|
||||
int fetch_validx(struct gspca_dev *gspca_dev, struct validx *tbl, int len);
|
||||
int keep_on_fetching_validx(struct gspca_dev *gspca_dev, struct validx *tbl,
|
||||
int len, int n);
|
||||
void fetch_idxdata(struct gspca_dev *gspca_dev, struct idxdata *tbl, int len);
|
||||
|
||||
int gl860_RTx(struct gspca_dev *gspca_dev,
|
||||
unsigned char pref, u32 req, u16 val, u16 index,
|
||||
s32 len, void *pdata);
|
||||
|
||||
void mi1320_init_settings(struct gspca_dev *);
|
||||
void ov2640_init_settings(struct gspca_dev *);
|
||||
void ov9655_init_settings(struct gspca_dev *);
|
||||
void mi2020_init_settings(struct gspca_dev *);
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue