← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/media/video/gspca/zc3xx.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/media/video/gspca/zc3xx.c
1
1
/*
2
2
 * Z-Star/Vimicro zc301/zc302p/vc30x library
3
3
 *
4
 
 * Copyright (C) 2009-2010 Jean-Francois Moine <http://moinejf.free.fr>
 
4
 * Copyright (C) 2009-2011 Jean-Francois Moine <http://moinejf.free.fr>
5
5
 * Copyright (C) 2004 2005 2006 Michel Xhaard mxhaard@magic.fr
6
6
 *
7
7
 * This program is free software; you can redistribute it and/or modify
39
39
enum e_ctrl {
40
40
        BRIGHTNESS,
41
41
        CONTRAST,
 
42
        EXPOSURE,
42
43
        GAMMA,
43
44
        AUTOGAIN,
44
45
        LIGHTFREQ,
46
47
        NCTRLS          /* number of controls */
47
48
};
48
49
 
 
50
#define AUTOGAIN_DEF 1
 
51
 
49
52
/* specific webcam descriptor */
50
53
struct sd {
51
54
        struct gspca_dev gspca_dev;     /* !! must be the first item */
73
76
        SENSOR_CS2102K,
74
77
        SENSOR_GC0303,
75
78
        SENSOR_GC0305,
76
 
        SENSOR_HDCS2020b,
 
79
        SENSOR_HDCS2020,
77
80
        SENSOR_HV7131B,
78
81
        SENSOR_HV7131R,
79
82
        SENSOR_ICM105A,
92
95
 
93
96
/* V4L2 controls supported by the driver */
94
97
static void setcontrast(struct gspca_dev *gspca_dev);
95
 
static void setautogain(struct gspca_dev *gspca_dev);
 
98
static void setexposure(struct gspca_dev *gspca_dev);
 
99
static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val);
96
100
static void setlightfreq(struct gspca_dev *gspca_dev);
97
101
static void setsharpness(struct gspca_dev *gspca_dev);
98
102
 
121
125
            },
122
126
            .set_control = setcontrast
123
127
        },
 
128
[EXPOSURE] = {
 
129
            {
 
130
                .id      = V4L2_CID_EXPOSURE,
 
131
                .type    = V4L2_CTRL_TYPE_INTEGER,
 
132
                .name    = "Exposure",
 
133
                .minimum = 0x30d,
 
134
                .maximum        = 0x493e,
 
135
                .step           = 1,
 
136
                .default_value  = 0x927
 
137
            },
 
138
            .set_control = setexposure
 
139
        },
124
140
[GAMMA] = {
125
141
            {
126
142
                .id      = V4L2_CID_GAMMA,
141
157
                .minimum = 0,
142
158
                .maximum = 1,
143
159
                .step    = 1,
144
 
                .default_value = 1,
 
160
                .default_value = AUTOGAIN_DEF,
 
161
                .flags   = V4L2_CTRL_FLAG_UPDATE
145
162
            },
146
 
            .set_control = setautogain
 
163
            .set = sd_setautogain
147
164
        },
148
165
[LIGHTFREQ] = {
149
166
            {
1498
1515
        {}
1499
1516
};
1500
1517
 
1501
 
static const struct usb_action hdcs2020b_InitialScale[] = {
 
1518
static const struct usb_action hdcs2020_InitialScale[] = {
1502
1519
        {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
1503
1520
        {0xa0, 0x11, ZC3XX_R002_CLOCKSELECT},
1504
1521
        {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},  /* qtable 0x05 */
1630
1647
        {0xa0, 0x40, ZC3XX_R118_BGAIN},
1631
1648
        {}
1632
1649
};
1633
 
static const struct usb_action hdcs2020b_Initial[] = {
 
1650
static const struct usb_action hdcs2020_Initial[] = {
1634
1651
        {0xa0, 0x01, ZC3XX_R000_SYSTEMCONTROL},
1635
1652
        {0xa0, 0x00, ZC3XX_R002_CLOCKSELECT},
1636
1653
        {0xa0, 0x03, ZC3XX_R008_CLOCKSETTING},
1758
1775
        {0xa0, 0x40, ZC3XX_R118_BGAIN},
1759
1776
        {}
1760
1777
};
1761
 
static const struct usb_action hdcs2020b_50HZ[] = {
 
1778
static const struct usb_action hdcs2020_50HZ[] = {
1762
1779
        {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
1763
1780
        {0xaa, 0x13, 0x0018},                   /* 00,13,18,aa */
1764
1781
        {0xaa, 0x14, 0x0001},                   /* 00,14,01,aa */
1779
1796
        {0xa0, 0x2f, ZC3XX_R01F_HSYNC_2}, /* 00,1f,2f,cc */
1780
1797
        {}
1781
1798
};
1782
 
static const struct usb_action hdcs2020b_60HZ[] = {
 
1799
static const struct usb_action hdcs2020_60HZ[] = {
1783
1800
        {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
1784
1801
        {0xaa, 0x13, 0x0031},                   /* 00,13,31,aa */
1785
1802
        {0xaa, 0x14, 0x0001},                   /* 00,14,01,aa */
1800
1817
        {0xa0, 0x2c, ZC3XX_R01F_HSYNC_2}, /* 00,1f,2c,cc */
1801
1818
        {}
1802
1819
};
1803
 
static const struct usb_action hdcs2020b_NoFliker[] = {
 
1820
static const struct usb_action hdcs2020_NoFliker[] = {
1804
1821
        {0xa0, 0x00, ZC3XX_R019_AUTOADJUSTFPS}, /* 00,19,00,cc */
1805
1822
        {0xaa, 0x13, 0x0010},                   /* 00,13,10,aa */
1806
1823
        {0xaa, 0x14, 0x0001},                   /* 00,14,01,aa */
2126
2143
        {0xa0, 0x80, ZC3XX_R004_FRAMEWIDTHLOW},
2127
2144
        {0xa0, 0x01, ZC3XX_R005_FRAMEHEIGHTHIGH},
2128
2145
        {0xa0, 0xe0, ZC3XX_R006_FRAMEHEIGHTLOW},
2129
 
 
2130
2146
        {0xa0, 0x00, ZC3XX_R098_WINYSTARTLOW},
2131
2147
        {0xa0, 0x00, ZC3XX_R09A_WINXSTARTLOW},
2132
2148
        {0xa0, 0x01, ZC3XX_R09B_WINHEIGHTHIGH},
2878
2894
        {0xaa, 0x11, 0x0001}, /* 00,11,01,aa */
2879
2895
        {0xaa, 0x30, 0x0000}, /* 00,30,00,aa */
2880
2896
        {0xaa, 0x60, 0x0000}, /* 00,60,00,aa */
2881
 
        {0xaa, 0xa0, ZC3XX_R01A_LASTFRAMESTATE}, /* 00,a0,1a,aa */
 
2897
        {0xaa, 0xa0, 0x001a}, /* 00,a0,1a,aa */
2882
2898
        {0xaa, 0xa1, 0x0000}, /* 00,a1,00,aa */
2883
2899
        {0xaa, 0xa2, 0x003f}, /* 00,a2,3f,aa */
2884
2900
        {0xaa, 0xa3, 0x0028}, /* 00,a3,28,aa */
2998
3014
        {0xaa, 0x11, 0x0001}, /* 00,11,01,aa */
2999
3015
        {0xaa, 0x30, 0x0000}, /* 00,30,00,aa */
3000
3016
        {0xaa, 0x60, 0x0000}, /* 00,60,00,aa */
3001
 
        {0xaa, 0xa0, ZC3XX_R01A_LASTFRAMESTATE}, /* 00,a0,1a,aa */
 
3017
        {0xaa, 0xa0, 0x001a}, /* 00,a0,1a,aa */
3002
3018
        {0xaa, 0xa1, 0x0000}, /* 00,a1,00,aa */
3003
3019
        {0xaa, 0xa2, 0x003f}, /* 00,a2,3f,aa */
3004
3020
        {0xaa, 0xa3, 0x0028}, /* 00,a3,28,aa */
3049
3065
        {0xaa, 0x55, 0x0010}, /* 00,55,10,aa */
3050
3066
        {0xa0, 0xf0, 0x0199}, /* 01,99,F0,cc */
3051
3067
        {0xa0, 0x80, 0x019a}, /* 01,9A,80,cc */
3052
 
        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
3053
 
        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
3054
 
        {0xaa, 0x36, 0x001d}, /* 00,36,1D,aa */
3055
 
        {0xaa, 0x37, 0x004c}, /* 00,37,4C,aa */
3056
 
        {0xaa, 0x3b, 0x001d}, /* 00,3B,1D,aa */
3057
3068
        {}
3058
3069
};
3059
3070
 
3060
 
static const struct usb_action mc501cb_50HZScale[] = {
 
3071
static const struct usb_action mc501cb_50HZ[] = {
3061
3072
        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
3062
3073
        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
3063
3074
        {0xaa, 0x36, 0x001d}, /* 00,36,1D,aa */
3066
3077
        {0xaa, 0x3c, 0x004c}, /* 00,3C,4C,aa */
3067
3078
        {0xaa, 0x3d, 0x001d}, /* 00,3D,1D,aa */
3068
3079
        {0xaa, 0x3e, 0x004c}, /* 00,3E,4C,aa */
3069
 
        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
3070
 
        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
3071
 
        {0xaa, 0x36, 0x003a}, /* 00,36,3A,aa */
3072
 
        {0xaa, 0x37, 0x0098}, /* 00,37,98,aa */
3073
 
        {0xaa, 0x3b, 0x003a}, /* 00,3B,3A,aa */
3074
3080
        {}
3075
3081
};
3076
3082
 
3077
 
static const struct usb_action mc501cb_50HZ[] = {
 
3083
static const struct usb_action mc501cb_50HZScale[] = {
3078
3084
        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
3079
3085
        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
3080
3086
        {0xaa, 0x36, 0x003a}, /* 00,36,3A,aa */
3083
3089
        {0xaa, 0x3c, 0x0098}, /* 00,3C,98,aa */
3084
3090
        {0xaa, 0x3d, 0x003a}, /* 00,3D,3A,aa */
3085
3091
        {0xaa, 0x3e, 0x0098}, /* 00,3E,98,aa */
 
3092
        {}
 
3093
};
 
3094
 
 
3095
static const struct usb_action mc501cb_60HZ[] = {
3086
3096
        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
3087
3097
        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
3088
3098
        {0xaa, 0x36, 0x0018}, /* 00,36,18,aa */
3089
3099
        {0xaa, 0x37, 0x006a}, /* 00,37,6A,aa */
3090
3100
        {0xaa, 0x3d, 0x0018}, /* 00,3D,18,aa */
 
3101
        {0xaa, 0x3e, 0x006a}, /* 00,3E,6A,aa */
 
3102
        {0xaa, 0x3b, 0x0018}, /* 00,3B,18,aa */
 
3103
        {0xaa, 0x3c, 0x006a}, /* 00,3C,6A,aa */
3091
3104
        {}
3092
3105
};
3093
3106
 
3094
3107
static const struct usb_action mc501cb_60HZScale[] = {
3095
3108
        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
3096
3109
        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
 
3110
        {0xaa, 0x36, 0x0030}, /* 00,36,30,aa */
 
3111
        {0xaa, 0x37, 0x00d4}, /* 00,37,D4,aa */
 
3112
        {0xaa, 0x3d, 0x0030}, /* 00,3D,30,aa */
 
3113
        {0xaa, 0x3e, 0x00d4}, /* 00,3E,D4,aa */
 
3114
        {0xaa, 0x3b, 0x0030}, /* 00,3B,30,aa */
 
3115
        {0xaa, 0x3c, 0x00d4}, /* 00,3C,D4,aa */
 
3116
        {}
 
3117
};
 
3118
 
 
3119
static const struct usb_action mc501cb_NoFliker[] = {
 
3120
        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
 
3121
        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
3097
3122
        {0xaa, 0x36, 0x0018}, /* 00,36,18,aa */
3098
3123
        {0xaa, 0x37, 0x006a}, /* 00,37,6A,aa */
3099
3124
        {0xaa, 0x3d, 0x0018}, /* 00,3D,18,aa */
3100
3125
        {0xaa, 0x3e, 0x006a}, /* 00,3E,6A,aa */
3101
3126
        {0xaa, 0x3b, 0x0018}, /* 00,3B,18,aa */
3102
3127
        {0xaa, 0x3c, 0x006a}, /* 00,3C,6A,aa */
3103
 
        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
3104
 
        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
3105
 
        {0xaa, 0x36, 0x0030}, /* 00,36,30,aa */
3106
 
        {0xaa, 0x37, 0x00d4}, /* 00,37,D4,aa */
3107
 
        {0xaa, 0x3d, 0x0030}, /* 00,3D,30,aa */
3108
 
        {}
3109
 
};
3110
 
 
3111
 
static const struct usb_action mc501cb_60HZ[] = {
3112
 
        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
3113
 
        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
3114
 
        {0xaa, 0x36, 0x0030}, /* 00,36,30,aa */
3115
 
        {0xaa, 0x37, 0x00d4}, /* 00,37,D4,aa */
3116
 
        {0xaa, 0x3d, 0x0030}, /* 00,3D,30,aa */
3117
 
        {0xaa, 0x3e, 0x00d4}, /* 00,3E,D4,aa */
3118
 
        {0xaa, 0x3b, 0x0030}, /* 00,3B,30,aa */
3119
 
        {0xaa, 0x3c, 0x00d4}, /* 00,3C,D4,aa */
3120
 
        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
3121
 
        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
3122
 
        {0xaa, 0x36, 0x0018}, /* 00,36,18,aa */
3123
 
        {0xaa, 0x37, 0x006a}, /* 00,37,6A,aa */
3124
 
        {0xaa, 0x3d, 0x0018}, /* 00,3D,18,aa */
3125
3128
        {}
3126
3129
};
3127
3130
 
3128
3131
static const struct usb_action mc501cb_NoFlikerScale[] = {
3129
3132
        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
3130
3133
        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
3131
 
        {0xaa, 0x36, 0x0018}, /* 00,36,18,aa */
3132
 
        {0xaa, 0x37, 0x006a}, /* 00,37,6A,aa */
3133
 
        {0xaa, 0x3d, 0x0018}, /* 00,3D,18,aa */
3134
 
        {0xaa, 0x3e, 0x006a}, /* 00,3E,6A,aa */
3135
 
        {0xaa, 0x3b, 0x0018}, /* 00,3B,18,aa */
3136
 
        {0xaa, 0x3c, 0x006a}, /* 00,3C,6A,aa */
3137
 
        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
3138
 
        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
3139
 
        {0xaa, 0x36, 0x0030}, /* 00,36,30,aa */
3140
 
        {0xaa, 0x37, 0x00d4}, /* 00,37,D4,aa */
3141
 
        {0xaa, 0x3d, 0x0030}, /* 00,3D,30,aa */
3142
 
        {}
3143
 
};
3144
 
 
3145
 
static const struct usb_action mc501cb_NoFliker[] = {
3146
 
        {0xaa, 0x03, 0x0003}, /* 00,03,03,aa */
3147
 
        {0xaa, 0x10, 0x00fc}, /* 00,10,fc,aa */
3148
3134
        {0xaa, 0x36, 0x0030}, /* 00,36,30,aa */
3149
3135
        {0xaa, 0x37, 0x00d4}, /* 00,37,D4,aa */
3150
3136
        {0xaa, 0x3d, 0x0030}, /* 00,3D,30,aa */
3310
3296
        {0xaa, 0x10, 0x0082},                           /* 00,10,82,aa */
3311
3297
        {0xaa, 0x76, 0x0003},                           /* 00,76,03,aa */
3312
3298
/*      {0xa0, 0x40, ZC3XX_R002_CLOCKSELECT},            * 00,02,40,cc
3313
 
                                                         if mode0 (640x480) */
 
3299
                                                         * if mode0 (640x480) */
3314
3300
        {}
3315
3301
};
3316
3302
static const struct usb_action ov7620_60HZ[] = {
5828
5814
                [SENSOR_CS2102K] =      NULL,
5829
5815
                [SENSOR_GC0303] =       gc0303_matrix,
5830
5816
                [SENSOR_GC0305] =       gc0305_matrix,
5831
 
                [SENSOR_HDCS2020b] =    NULL,
 
5817
                [SENSOR_HDCS2020] =     NULL,
5832
5818
                [SENSOR_HV7131B] =      NULL,
5833
5819
                [SENSOR_HV7131R] =      po2030_matrix,
5834
5820
                [SENSOR_ICM105A] =      po2030_matrix,
5927
5913
                reg_w(gspca_dev, gr[i], 0x0130 + i);    /* gradient */
5928
5914
}
5929
5915
 
 
5916
static void getexposure(struct gspca_dev *gspca_dev)
 
5917
{
 
5918
        struct sd *sd = (struct sd *) gspca_dev;
 
5919
 
 
5920
        sd->ctrls[EXPOSURE].val = (i2c_read(gspca_dev, 0x25) << 9)
 
5921
                | (i2c_read(gspca_dev, 0x26) << 1)
 
5922
                | (i2c_read(gspca_dev, 0x27) >> 7);
 
5923
}
 
5924
 
 
5925
static void setexposure(struct gspca_dev *gspca_dev)
 
5926
{
 
5927
        struct sd *sd = (struct sd *) gspca_dev;
 
5928
        int val;
 
5929
 
 
5930
        val = sd->ctrls[EXPOSURE].val;
 
5931
        i2c_write(gspca_dev, 0x25, val >> 9, 0x00);
 
5932
        i2c_write(gspca_dev, 0x26, val >> 1, 0x00);
 
5933
        i2c_write(gspca_dev, 0x27, val << 7, 0x00);
 
5934
}
 
5935
 
5930
5936
static void setquality(struct gspca_dev *gspca_dev)
5931
5937
{
5932
5938
        struct sd *sd = (struct sd *) gspca_dev;
5990
5996
                {gc0305_NoFliker, gc0305_NoFliker,
5991
5997
                 gc0305_50HZ, gc0305_50HZ,
5992
5998
                 gc0305_60HZ, gc0305_60HZ},
5993
 
        [SENSOR_HDCS2020b] =
5994
 
                {hdcs2020b_NoFliker, hdcs2020b_NoFliker,
5995
 
                 hdcs2020b_50HZ, hdcs2020b_50HZ,
5996
 
                 hdcs2020b_60HZ, hdcs2020b_60HZ},
 
5999
        [SENSOR_HDCS2020] =
 
6000
                {hdcs2020_NoFliker, hdcs2020_NoFliker,
 
6001
                 hdcs2020_50HZ, hdcs2020_50HZ,
 
6002
                 hdcs2020_60HZ, hdcs2020_60HZ},
5997
6003
        [SENSOR_HV7131B] =
5998
6004
                {hv7131b_NoFliker, hv7131b_NoFlikerScale,
5999
6005
                 hv7131b_50HZ, hv7131b_50HZScale,
6091
6097
 
6092
6098
static void send_unknown(struct gspca_dev *gspca_dev, int sensor)
6093
6099
{
6094
 
        reg_w(gspca_dev, 0x01, 0x0000);         /* led off */
 
6100
        reg_w(gspca_dev, 0x01, 0x0000);         /* bridge reset */
6095
6101
        switch (sensor) {
6096
6102
        case SENSOR_PAS106:
6097
6103
                reg_w(gspca_dev, 0x03, 0x003a);
6260
6266
{
6261
6267
        struct sd *sd = (struct sd *) gspca_dev;
6262
6268
        int i;
6263
 
        u8 retbyte;
6264
6269
        u16 retword;
6265
6270
 
6266
6271
/*fixme: lack of 8b=b3 (11,12)-> 10, 8b=e0 (14,15,16)-> 12 found in gspcav1*/
6310
6315
                return 0x0a;                    /* PB0330 */
6311
6316
        }
6312
6317
 
 
6318
        /* probe gc0303 / gc0305 */
6313
6319
        reg_w(gspca_dev, 0x01, 0x0000);
6314
6320
        reg_w(gspca_dev, 0x01, 0x0001);
6315
6321
        reg_w(gspca_dev, 0x98, 0x008b);
6352
6358
        retword |= i2c_read(gspca_dev, 0x01);           /* ID 1 */
6353
6359
        PDEBUG(D_PROBE, "probe 3wr vga 2 0x%04x", retword);
6354
6360
        if (retword == 0x2030) {
 
6361
#ifdef GSPCA_DEBUG
 
6362
                u8 retbyte;
 
6363
 
6355
6364
                retbyte = i2c_read(gspca_dev, 0x02);    /* revision number */
6356
6365
                PDEBUG(D_PROBE, "sensor PO2030 rev 0x%02x", retbyte);
 
6366
#endif
6357
6367
                send_unknown(gspca_dev, SENSOR_PO2030);
6358
6368
                return retword;
6359
6369
        }
6414
6424
        gspca_dev->cam.ctrls = sd->ctrls;
6415
6425
        sd->quality = QUALITY_DEF;
6416
6426
 
 
6427
        /* if USB 1.1, let some bandwidth for the audio device */
 
6428
        if (gspca_dev->audio && gspca_dev->dev->speed < USB_SPEED_HIGH)
 
6429
                gspca_dev->nbalt--;
 
6430
 
6417
6431
        return 0;
6418
6432
}
6419
6433
 
6429
6443
                [SENSOR_CS2102K] =      5,
6430
6444
                [SENSOR_GC0303] =       3,
6431
6445
                [SENSOR_GC0305] =       4,
6432
 
                [SENSOR_HDCS2020b] =    4,
 
6446
                [SENSOR_HDCS2020] =     4,
6433
6447
                [SENSOR_HV7131B] =      4,
6434
6448
                [SENSOR_HV7131R] =      4,
6435
6449
                [SENSOR_ICM105A] =      4,
6450
6464
                [SENSOR_CS2102K] =      1,
6451
6465
                [SENSOR_GC0303] =       1,
6452
6466
                [SENSOR_GC0305] =       1,
6453
 
                [SENSOR_HDCS2020b] =    1,
 
6467
                [SENSOR_HDCS2020] =     1,
6454
6468
                [SENSOR_HV7131B] =      1,
6455
6469
                [SENSOR_HV7131R] =      1,
6456
6470
                [SENSOR_ICM105A] =      1,
6513
6527
                        sd->sensor = SENSOR_CS2102;
6514
6528
                        break;
6515
6529
                case 0x08:
6516
 
                        PDEBUG(D_PROBE, "Find Sensor HDCS2020(b)");
6517
 
                        sd->sensor = SENSOR_HDCS2020b;
 
6530
                        PDEBUG(D_PROBE, "Find Sensor HDCS2020");
 
6531
                        sd->sensor = SENSOR_HDCS2020;
6518
6532
                        break;
6519
6533
                case 0x0a:
6520
6534
                        PDEBUG(D_PROBE,
6619
6633
        sd->ctrls[GAMMA].def = gamma[sd->sensor];
6620
6634
 
6621
6635
        switch (sd->sensor) {
 
6636
        case SENSOR_HV7131R:
 
6637
                break;
6622
6638
        case SENSOR_OV7630C:
6623
 
                gspca_dev->ctrl_dis = (1 << LIGHTFREQ);
 
6639
                gspca_dev->ctrl_dis = (1 << LIGHTFREQ) | (1 << EXPOSURE);
 
6640
                break;
 
6641
        default:
 
6642
                gspca_dev->ctrl_dis = (1 << EXPOSURE);
6624
6643
                break;
6625
6644
        }
 
6645
#if AUTOGAIN_DEF
 
6646
        if (sd->ctrls[AUTOGAIN].val)
 
6647
                gspca_dev->ctrl_inac = (1 << EXPOSURE);
 
6648
#endif
6626
6649
 
6627
6650
        /* switch off the led */
6628
6651
        reg_w(gspca_dev, 0x01, 0x0000);
6644
6667
                {gc0303_Initial, gc0303_InitialScale},
6645
6668
        [SENSOR_GC0305] =
6646
6669
                        {gc0305_Initial, gc0305_InitialScale},
6647
 
        [SENSOR_HDCS2020b] =
6648
 
                        {hdcs2020b_Initial, hdcs2020b_InitialScale},
 
6670
        [SENSOR_HDCS2020] =
 
6671
                        {hdcs2020_Initial, hdcs2020_InitialScale},
6649
6672
        [SENSOR_HV7131B] =
6650
6673
                        {hv7131b_Initial, hv7131b_InitialScale},
6651
6674
        [SENSOR_HV7131R] =
6739
6762
        /* set the gamma tables when not set */
6740
6763
        switch (sd->sensor) {
6741
6764
        case SENSOR_CS2102K:            /* gamma set in xxx_Initial */
6742
 
        case SENSOR_HDCS2020b:
 
6765
        case SENSOR_HDCS2020:
6743
6766
        case SENSOR_OV7630C:
6744
6767
                break;
6745
6768
        default:
6768
6791
                reg_w(gspca_dev, 0x40, 0x0117);
6769
6792
                break;
6770
6793
        case SENSOR_HV7131R:
6771
 
                i2c_write(gspca_dev, 0x25, 0x04, 0x00); /* exposure */
6772
 
                i2c_write(gspca_dev, 0x26, 0x93, 0x00);
6773
 
                i2c_write(gspca_dev, 0x27, 0xe0, 0x00);
 
6794
                if (!sd->ctrls[AUTOGAIN].val)
 
6795
                        setexposure(gspca_dev);
6774
6796
                reg_w(gspca_dev, 0x00, ZC3XX_R1A7_CALCGLOBALMEAN);
6775
6797
                break;
6776
6798
        case SENSOR_GC0305:
6848
6870
        gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
6849
6871
}
6850
6872
 
 
6873
static int sd_setautogain(struct gspca_dev *gspca_dev, __s32 val)
 
6874
{
 
6875
        struct sd *sd = (struct sd *) gspca_dev;
 
6876
 
 
6877
        sd->ctrls[AUTOGAIN].val = val;
 
6878
        if (val) {
 
6879
                gspca_dev->ctrl_inac |= (1 << EXPOSURE);
 
6880
        } else {
 
6881
                gspca_dev->ctrl_inac &= ~(1 << EXPOSURE);
 
6882
                if (gspca_dev->streaming)
 
6883
                        getexposure(gspca_dev);
 
6884
        }
 
6885
        if (gspca_dev->streaming)
 
6886
                setautogain(gspca_dev);
 
6887
        return gspca_dev->usb_err;
 
6888
}
 
6889
 
6851
6890
static int sd_querymenu(struct gspca_dev *gspca_dev,
6852
6891
                        struct v4l2_querymenu *menu)
6853
6892
{