← Back to branch summary

~isantop/system76-driver/pkexec

« back to all changes in this revision

Viewing changes to gspcav1/Mars-Semi/mr97311.h

  • Committer: Carl Richell
  • Date: 2007-05-29 03:36:10 UTC
  • Revision ID: carl@system76.com-20070529033610-9qeih4btk1oxo6sj
initial bazaar revision - System76 Driver 2.0.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
gspcav1/Mars-Semi/mr97311.h
 
1
/****************************************************************************
 
2
#               Mars-Semi MR97311A library                                  #
 
3
#               Copyright (C) 2005 <bradlch@hotmail.com>                    #
 
4
# Part of spca5xx project                                                   #
 
5
# This program is free software; you can redistribute it and/or modify      #
 
6
# it under the terms of the GNU General Public License as published by      #
 
7
# the Free Software Foundation; either version 2 of the License, or         #
 
8
# (at your option) any later version.                                       #
 
9
#                                                                           #
 
10
# This program is distributed in the hope that it will be useful,           #
 
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of            #
 
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             #
 
13
# GNU General Public License for more details.                              #
 
14
#                                                                           #
 
15
# You should have received a copy of the GNU General Public License         #
 
16
# along with this program; if not, write to the Free Software               #
 
17
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA #
 
18
#                                                                           #
 
19
****************************************************************************/
 
20
static int mr97311_init(struct usb_spca50x *pcam);
 
21
static void mr97311_start(struct usb_spca50x *pcam);
 
22
static void mr97311_stopN(struct usb_spca50x *pcam);
 
23
static void mr97311_stop0(struct usb_spca50x *pcam);
 
24
static int mr97311_config(struct usb_spca50x *pcam);
 
25
static __u16 mr97311_getbrightness(struct usb_spca50x *spca50x);
 
26
static __u16 mr97311_getcontrast(struct usb_spca50x *spca50x);
 
27
static __u16 mr97311_getcolors(struct usb_spca50x *spca50x);
 
28
static void mr97311_setbrightness(struct usb_spca50x *spca50x);
 
29
static void mr97311_setcontrast(struct usb_spca50x *spca50x);
 
30
static void mr97311_setcolors(struct usb_spca50x *spca50x);
 
31
static void mr97311_shutdown(struct usb_spca50x *spca50x);
 
32
static void mr97311_setAutobright(struct usb_spca50x *spca50x);
 
33
static void mr97311_setquality(struct usb_spca50x *spca50x);
 
34
static int mr97311_sofdetect(struct usb_spca50x *spca50x,struct spca50x_frame *frame, unsigned char *cdata,int *iPix, int seqnum, int *datalength);
 
35
/*****************************************************************/
 
36
static int mr97311_init(struct usb_spca50x *pcam){return 0;}
 
37
static __u16 mr97311_getbrightness(struct usb_spca50x *spca50x){return 0;}
 
38
static __u16 mr97311_getcontrast(struct usb_spca50x *spca50x){return 0;}
 
39
static __u16 mr97311_getcolors(struct usb_spca50x *spca50x){return 0;}
 
40
static void mr97311_setbrightness(struct usb_spca50x *spca50x){}
 
41
static void mr97311_setcontrast(struct usb_spca50x *spca50x){}
 
42
static void mr97311_setcolors(struct usb_spca50x *spca50x){}
 
43
 
 
44
static void mr97311_shutdown(struct usb_spca50x *spca50x){}
 
45
static void mr97311_setAutobright(struct usb_spca50x *spca50x){}
 
46
static void mr97311_setquality(struct usb_spca50x *spca50x){}
 
47
static void mr97311_stop0(struct usb_spca50x *pcam){}
 
48
/****************************************************************/
 
49
static struct cam_operation fmr97311 = {
 
50
        .initialize = mr97311_init,
 
51
        .configure = mr97311_config,
 
52
        .start = mr97311_start,
 
53
        .stopN = mr97311_stopN,
 
54
        .stop0 = mr97311_stop0,
 
55
        .get_bright = mr97311_getbrightness,
 
56
        .set_bright = mr97311_setbrightness,
 
57
        .get_contrast = mr97311_getcontrast,
 
58
        .set_contrast = mr97311_setcontrast,
 
59
        .get_colors = mr97311_getcolors,
 
60
        .set_colors = mr97311_setcolors,
 
61
        .set_autobright = mr97311_setAutobright,
 
62
        .set_quality = mr97311_setquality,
 
63
        .cam_shutdown = mr97311_shutdown,
 
64
        .sof_detect = mr97311_sofdetect,
 
65
 };
 
66
static int pcam_reg_write(struct usb_device *dev,
 
67
                          __u16 index, unsigned char *value, int length);
 
68
 
 
69
static void MISensor_BulkWrite(struct usb_device *dev, unsigned short *pch,
 
70
                               char Address, int length, char controlbyte);
 
71
 
 
72
//MI Register table //elvis
 
73
enum {
 
74
    REG_HW_MI_0,
 
75
    REG_HW_MI_1,
 
76
    REG_HW_MI_2,
 
77
    REG_HW_MI_3,
 
78
    REG_HW_MI_4,
 
79
    REG_HW_MI_5,
 
80
    REG_HW_MI_6,
 
81
    REG_HW_MI_7,
 
82
    REG_HW_MI_9 = 0x09,
 
83
    REG_HW_MI_B = 0x0B,
 
84
    REG_HW_MI_C,
 
85
    REG_HW_MI_D,
 
86
    REG_HW_MI_1E = 0x1E,
 
87
    REG_HW_MI_20 = 0x20,
 
88
    REG_HW_MI_2B = 0x2B,
 
89
    REG_HW_MI_2C,
 
90
    REG_HW_MI_2D,
 
91
    REG_HW_MI_2E,
 
92
    REG_HW_MI_35 = 0x35,
 
93
    REG_HW_MI_5F = 0x5F,
 
94
    REG_HW_MI_60,
 
95
    REG_HW_MI_61,
 
96
    REG_HW_MI_62,
 
97
    REG_HW_MI_63,
 
98
    REG_HW_MI_64,
 
99
    REG_HW_MI_F1 = 0xF1,
 
100
    ATTR_TOTAL_MI_REG = 242
 
101
};
 
102
static void mr97311_stopN(struct usb_spca50x *pcam)
 
103
{
 
104
    int result;
 
105
    char data[2];
 
106
    memset(data, 0, 2);
 
107
    data[0] = 1;
 
108
    data[1] = 0;
 
109
    result = pcam_reg_write(pcam->dev, data[0], data, 2);
 
110
    if (result < 0)
 
111
        printk("Camera Stop failed \n");
 
112
 
 
113
}
 
114
static int pcam_reg_write(struct usb_device *dev,
 
115
                          __u16 index, unsigned char *value, int length)
 
116
{
 
117
    unsigned char buf[12];
 
118
    int rc;
 
119
    int i;
 
120
    unsigned char index_value = 0;
 
121
 
 
122
    memset(buf, 0, sizeof(buf));
 
123
 
 
124
    for (i = 0; i < length; i++)
 
125
        buf[i] = value[i];
 
126
 
 
127
    rc = usb_control_msg(dev,
 
128
                         usb_sndbulkpipe(dev, 4),
 
129
                         0x12,
 
130
                         0xc8, index_value, index, value, length, 5 * HZ);
 
131
 
 
132
    PDEBUG(1, "reg write: 0x%02X , result = 0x%x \n", index, rc);
 
133
 
 
134
    if (rc < 0) {
 
135
        PDEBUG(1, "reg write: error %d \n", rc);
 
136
    }
 
137
    return rc;
 
138
}
 
139
 
 
140
static void mr97311_start(struct usb_spca50x *pcam)
 
141
{
 
142
    int err_code;
 
143
    unsigned char data[242];
 
144
    unsigned short MI_buf[242];
 
145
    int h_size, v_size;
 
146
    int intpipe;
 
147
    //struct usb_device *dev = pcam->dev;
 
148
    memset(data, 0, 242);
 
149
    memset(MI_buf, 0, 242);
 
150
 
 
151
    PDEBUG(1,
 
152
           "usb_set_interface in pcamCameraStart , interface %d , alt 8 \n",
 
153
           pcam->iface);
 
154
    if (usb_set_interface(pcam->dev, pcam->iface, 8) < 0) {
 
155
        err("Set packet size: set interface error");
 
156
        return ;
 
157
    }
 
158
 
 
159
    data[0] = 0x01;             //address
 
160
    data[1] = 0x01;
 
161
 
 
162
    err_code = pcam_reg_write(pcam->dev, data[0], data, 0x02);
 
163
    if (err_code < 0) {
 
164
        printk("Register write failed \n");
 
165
        return ;
 
166
    }
 
167
 
 
168
 
 
169
    /*
 
170
       Initialize the MR97113 chip register
 
171
     */
 
172
 
 
173
    data[0] = 0x00;             //address
 
174
    data[1] = 0x0c | 0x01;      //reg 0
 
175
    data[2] = 0x01;             //reg 1
 
176
 
 
177
    switch (pcam->width) {
 
178
    case 1280:
 
179
        h_size = 1280;
 
180
        v_size = 1024;
 
181
        break;
 
182
    case 640:
 
183
        h_size = 640;
 
184
        v_size = 480;
 
185
        break;
 
186
    case 384:
 
187
        h_size = 384;
 
188
        v_size = 288;
 
189
        break;
 
190
    case 352:
 
191
        h_size = 352;
 
192
        v_size = 288;
 
193
        break;
 
194
    case 320:
 
195
        h_size = 320;
 
196
        v_size = 240;
 
197
        break;
 
198
    default:
 
199
        h_size = 352;
 
200
        v_size = 288;
 
201
        break;
 
202
    }
 
203
    data[3] = h_size / 8;       //h_size , reg 2
 
204
    data[4] = v_size / 8;       //v_size , reg 3
 
205
    data[5] = 0x30;             // reg 4, MI, PAS5101 : 0x30 for 24mhz , 0x28 for 12mhz
 
206
    data[6] = 4;                // reg 5, H start
 
207
    data[7] = 0xc0;             // reg 6, gamma 1.5
 
208
    data[8] = 3;                // reg 7, V start
 
209
    //if(pcam->width == 320 )
 
210
    //data[9]= 0x56;        // reg 8, 24MHz, 2:1 scale down
 
211
    //else
 
212
    data[9] = 0x52;             // reg 8, 24MHz, no scale down
 
213
    data[10] = 0x5d;            // reg 9, I2C device address [for PAS5101 (0x40)] [for MI (0x5d)]
 
214
 
 
215
    err_code = pcam_reg_write(pcam->dev, data[0], data, 0x0b);
 
216
    if (err_code < 0) {
 
217
        PDEBUG(1, "Register write failed \n");
 
218
        return ;
 
219
    }
 
220
 
 
221
 
 
222
    data[0] = 0x23;             //address
 
223
    data[1] = 0x09;             // reg 35, append frame header
 
224
 
 
225
    err_code = pcam_reg_write(pcam->dev, data[0], data, 0x02);
 
226
    if (err_code < 0) {
 
227
        PDEBUG(1, "Register write failed \n");
 
228
        return ;
 
229
    }
 
230
 
 
231
 
 
232
 
 
233
    data[0] = 0x3C;             //address
 
234
    if (pcam->width == 1280)
 
235
        data[1] = 200;          // reg 60, pc-cam frame size (unit: 4KB) 800KB
 
236
    else
 
237
        data[1] = 50;           // 50 reg 60, pc-cam frame size (unit: 4KB) 200KB
 
238
    err_code = pcam_reg_write(pcam->dev, data[0], data, 0x02);
 
239
    if (err_code < 0) {
 
240
        PDEBUG(1, "Register write failed \n");
 
241
        return ;
 
242
    }
 
243
 
 
244
 
 
245
    if (0) {                    // fixed dark-gain
 
246
        data[1] = 0;            // reg 94, Y Gain (1.75)
 
247
        data[2] = 0;            // reg 95, UV Gain (1.75)
 
248
        data[3] = 0x3f;         // reg 96, Y Gain/UV Gain/disable auto dark-gain
 
249
        data[4] = 0;            // reg 97, set fixed dark level
 
250
        data[5] = 0;            // reg 98, don't care
 
251
    } else {                    // auto dark-gain
 
252
        data[1] = 0;            // reg 94, Y Gain (auto)
 
253
        data[2] = 0;            // reg 95, UV Gain (1.75)
 
254
        data[3] = 0x78;         // reg 96, Y Gain/UV Gain/disable auto dark-gain
 
255
        switch (pcam->width) {
 
256
        case 1280:
 
257
            data[4] = 154;      // reg 97, %3 shadow point (unit: 256 pixel)
 
258
            data[5] = 51;       // reg 98, %1 highlight point (uint: 256 pixel)
 
259
            break;
 
260
        case 640:
 
261
            data[4] = 36;       // reg 97, %3 shadow point (unit: 256 pixel)
 
262
            data[5] = 12;       // reg 98, %1 highlight point (uint: 256 pixel)
 
263
            break;
 
264
        case 320:
 
265
            data[4] = 9;        // reg 97, %3 shadow point (unit: 256 pixel)
 
266
            data[5] = 3;        // reg 98, %1 highlight point (uint: 256 pixel)
 
267
            break;
 
268
        }
 
269
    }
 
270
    // auto dark-gain
 
271
    data[0] = 0x5E;             // address
 
272
 
 
273
    err_code = pcam_reg_write(pcam->dev, data[0], data, 0x06);
 
274
    if (err_code < 0) {
 
275
        PDEBUG(1, "Register write failed \n");
 
276
        return ;
 
277
    }
 
278
 
 
279
 
 
280
 
 
281
    data[0] = 0x67;
 
282
    data[1] = 0x13;             // reg 103, first pixel B, disable sharpness
 
283
    err_code = pcam_reg_write(pcam->dev, data[0], data, 0x02);
 
284
    if (err_code < 0) {
 
285
        PDEBUG(1, "Register write failed \n");
 
286
        return ;
 
287
    }
 
288
 
 
289
 
 
290
    /*
 
291
       initialize the value of MI sensor...
 
292
     */
 
293
 
 
294
    MI_buf[REG_HW_MI_1] = 0x000a;
 
295
    MI_buf[REG_HW_MI_2] = 0x000c;
 
296
    MI_buf[REG_HW_MI_3] = 0x0405;
 
297
    MI_buf[REG_HW_MI_4] = 0x0507;
 
298
    //mi_Attr_Reg_[REG_HW_MI_5]     = 0x01ff;//13
 
299
    MI_buf[REG_HW_MI_5] = 0x0013;       //13
 
300
    MI_buf[REG_HW_MI_6] = 0x001f;       // vertical blanking
 
301
    //mi_Attr_Reg_[REG_HW_MI_6]     = 0x0400;  // vertical blanking
 
302
    MI_buf[REG_HW_MI_7] = 0x0002;
 
303
    //mi_Attr_Reg_[REG_HW_MI_9]     = 0x015f;
 
304
    //mi_Attr_Reg_[REG_HW_MI_9]     = 0x030f;
 
305
    MI_buf[REG_HW_MI_9] = 0x0374;
 
306
    MI_buf[REG_HW_MI_B] = 0x0000;
 
307
    MI_buf[REG_HW_MI_C] = 0x0000;
 
308
    MI_buf[REG_HW_MI_D] = 0x0000;
 
309
    MI_buf[REG_HW_MI_1E] = 0x8000;
 
310
//      mi_Attr_Reg_[REG_HW_MI_20]      = 0x1104;
 
311
    MI_buf[REG_HW_MI_20] = 0x1104;      //0x111c;
 
312
    MI_buf[REG_HW_MI_2B] = 0x0008;
 
313
//      mi_Attr_Reg_[REG_HW_MI_2C]      = 0x000f;
 
314
    MI_buf[REG_HW_MI_2C] = 0x001f;      //lita suggest
 
315
    MI_buf[REG_HW_MI_2D] = 0x0008;
 
316
    MI_buf[REG_HW_MI_2E] = 0x0008;
 
317
    MI_buf[REG_HW_MI_35] = 0x0051;
 
318
    MI_buf[REG_HW_MI_5F] = 0x0904;      //fail to write
 
319
    MI_buf[REG_HW_MI_60] = 0x0000;
 
320
    MI_buf[REG_HW_MI_61] = 0x0000;
 
321
    MI_buf[REG_HW_MI_62] = 0x0498;
 
322
    MI_buf[REG_HW_MI_63] = 0x0000;
 
323
    MI_buf[REG_HW_MI_64] = 0x0000;
 
324
    MI_buf[REG_HW_MI_F1] = 0x0001;
 
325
    //changing while setting up the different value of dx/dy
 
326
 
 
327
    if (pcam->width != 1280) {
 
328
        MI_buf[0x01] = 0x010a;
 
329
        MI_buf[0x02] = 0x014c;
 
330
        MI_buf[0x03] = 0x01e5;
 
331
        MI_buf[0x04] = 0x0287;
 
332
    }
 
333
    MI_buf[0x20] = 0x1104;
 
334
 
 
335
    MISensor_BulkWrite(pcam->dev, MI_buf + 1, 1, 1, 0);
 
336
 
 
337
 
 
338
    MISensor_BulkWrite(pcam->dev, MI_buf + 2, 2, 1, 0);
 
339
 
 
340
 
 
341
    MISensor_BulkWrite(pcam->dev, MI_buf + 3, 3, 1, 0);
 
342
 
 
343
 
 
344
    MISensor_BulkWrite(pcam->dev, MI_buf + 4, 4, 1, 0);
 
345
 
 
346
 
 
347
    MISensor_BulkWrite(pcam->dev, MI_buf + 5, 5, 1, 0);
 
348
 
 
349
 
 
350
    MISensor_BulkWrite(pcam->dev, MI_buf + 6, 6, 1, 0);
 
351
 
 
352
 
 
353
    MISensor_BulkWrite(pcam->dev, MI_buf + 7, 7, 1, 0);
 
354
 
 
355
 
 
356
    MISensor_BulkWrite(pcam->dev, MI_buf + 9, 9, 1, 0);
 
357
 
 
358
 
 
359
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x0B, 0x0B, 1, 0);
 
360
 
 
361
 
 
362
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x0C, 0x0C, 1, 0);
 
363
 
 
364
 
 
365
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x0D, 0x0D, 1, 0);
 
366
 
 
367
 
 
368
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x1E, 0x1E, 1, 0);
 
369
 
 
370
 
 
371
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x20, 0x20, 1, 0);
 
372
 
 
373
 
 
374
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x2B, 0x2B, 1, 0);
 
375
 
 
376
 
 
377
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x2C, 0x2C, 1, 0);
 
378
 
 
379
 
 
380
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x2D, 0x2D, 1, 0);
 
381
 
 
382
 
 
383
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x2E, 0x2E, 1, 0);
 
384
 
 
385
 
 
386
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x35, 0x35, 1, 0);
 
387
 
 
388
 
 
389
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x5F, 0x5F, 1, 0);
 
390
 
 
391
 
 
392
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x60, 0x60, 1, 0);
 
393
 
 
394
 
 
395
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x61, 0x61, 1, 0);
 
396
 
 
397
 
 
398
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x62, 0x62, 1, 0);
 
399
 
 
400
 
 
401
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x63, 0x63, 1, 0);
 
402
 
 
403
 
 
404
    MISensor_BulkWrite(pcam->dev, MI_buf + 0x64, 0x64, 1, 0);
 
405
 
 
406
 
 
407
    MISensor_BulkWrite(pcam->dev, MI_buf + 0xF1, 0xF1, 1, 0);
 
408
 
 
409
 
 
410
 
 
411
    intpipe = usb_sndintpipe(pcam->dev, 0);
 
412
    err_code = usb_clear_halt(pcam->dev, intpipe);
 
413
 
 
414
    data[0] = 0x00;
 
415
    data[1] = 0x4D;             // ISOC transfering enable...
 
416
    err_code = pcam_reg_write(pcam->dev, data[0], data, 0x02);
 
417
    if (err_code < 0) {
 
418
        PDEBUG(1, "Register write failed \n");
 
419
        return ;
 
420
    }
 
421
 
 
422
 
 
423
    return ;
 
424
}
 
425
static void MISensor_BulkWrite(struct usb_device *dev, unsigned short *pch,
 
426
                               char Address, int length, char controlbyte)
 
427
{
 
428
    int dest, src, result;
 
429
    unsigned char data[6];
 
430
 
 
431
    memset(data, 0, 6);
 
432
 
 
433
    for (dest = 3, src = 0; src < length; src++) {
 
434
        data[0] = 0x1f;
 
435
        data[1] = controlbyte;
 
436
        data[2] = Address + src;
 
437
        data[dest] = pch[src] >> 8;     //high byte;
 
438
        data[dest + 1] = pch[src];      //low byte;
 
439
        data[dest + 2] = 0;
 
440
 
 
441
        result = usb_control_msg(dev,
 
442
                                 usb_sndbulkpipe(dev, 4),
 
443
                                 0x12, 0xc8, 0, Address, data, 5, 5 * HZ);
 
444
 
 
445
        PDEBUG(1, "reg write: 0x%02X , result = 0x%x \n", Address, result);
 
446
 
 
447
        if (result < 0) {
 
448
            printk("reg write: error %d \n", result);
 
449
        }
 
450
 
 
451
    }
 
452
 
 
453
}
 
454
static int mr97311_config(struct usb_spca50x *spca50x)
 
455
{
 
456
    memset(spca50x->mode_cam, 0x00, TOTMODE * sizeof(struct mwebcam));
 
457
    spca50x->mode_cam[VGA].width = 640;
 
458
    spca50x->mode_cam[VGA].height = 480;
 
459
    spca50x->mode_cam[VGA].t_palette =
 
460
        P_JPEG | P_RAW | P_YUV420 | P_RGB32 | P_RGB24 | P_RGB16;
 
461
    spca50x->mode_cam[VGA].pipe = 1023;
 
462
    spca50x->mode_cam[VGA].method = 0;
 
463
    spca50x->mode_cam[VGA].mode = 1;
 
464
    spca50x->mode_cam[PAL].width = 384;
 
465
    spca50x->mode_cam[PAL].height = 288;
 
466
    spca50x->mode_cam[PAL].t_palette =
 
467
        P_YUV420 | P_RGB32 | P_RGB24 | P_RGB16;
 
468
    spca50x->mode_cam[PAL].pipe = 1023;
 
469
    spca50x->mode_cam[PAL].method = 1;
 
470
    spca50x->mode_cam[PAL].mode = 1;
 
471
    spca50x->mode_cam[SIF].width = 352;
 
472
    spca50x->mode_cam[SIF].height = 288;
 
473
    spca50x->mode_cam[SIF].t_palette =
 
474
        P_YUV420 | P_RGB32 | P_RGB24 | P_RGB16;
 
475
    spca50x->mode_cam[SIF].pipe = 1023;
 
476
    spca50x->mode_cam[SIF].method = 1;
 
477
    spca50x->mode_cam[SIF].mode = 1;
 
478
    spca50x->mode_cam[CIF].width = 320;
 
479
    spca50x->mode_cam[CIF].height = 240;
 
480
    spca50x->mode_cam[CIF].t_palette =
 
481
        P_JPEG | P_RAW | P_YUV420 | P_RGB32 | P_RGB24 | P_RGB16;
 
482
    spca50x->mode_cam[CIF].pipe = 896;
 
483
    spca50x->mode_cam[CIF].method = 0;
 
484
    spca50x->mode_cam[CIF].mode = 2;
 
485
    spca50x->mode_cam[QPAL].width = 192;
 
486
    spca50x->mode_cam[QPAL].height = 144;
 
487
    spca50x->mode_cam[QPAL].t_palette =
 
488
        P_YUV420 | P_RGB32 | P_RGB24 | P_RGB16;
 
489
    spca50x->mode_cam[QPAL].pipe = 896;
 
490
    spca50x->mode_cam[QPAL].method = 1;
 
491
    spca50x->mode_cam[QPAL].mode = 2;
 
492
    spca50x->mode_cam[QSIF].width = 176;
 
493
    spca50x->mode_cam[QSIF].height = 144;
 
494
    spca50x->mode_cam[QSIF].t_palette =
 
495
        P_YUV420 | P_RGB32 | P_RGB24 | P_RGB16;
 
496
    spca50x->mode_cam[QSIF].pipe = 896;
 
497
    spca50x->mode_cam[QSIF].method = 1;
 
498
    spca50x->mode_cam[QSIF].mode = 2;
 
499
    spca50x->qindex = 1;        // set quantization table
 
500
    return 0;
 
501
}
 
502
static int mr97311_sofdetect(struct usb_spca50x *spca50x,struct spca50x_frame *frame, unsigned char *cdata,int *iPix, int seqnum, int *datalength)
 
503
{
 
504
        int sof = 0;
 
505
        int p;
 
506
                
 
507
                if (*datalength < 6)
 
508
                    return -1;
 
509
                else {
 
510
                    for (p = 0; p < *datalength - 6; p++) {
 
511
                        if ((cdata[0 + p] == 0xFF)
 
512
                            && (cdata[1 + p] == 0xFF)
 
513
                            && (cdata[2 + p] == 0x00)
 
514
                            && (cdata[3 + p] == 0xFF)
 
515
                            && (cdata[4 + p] == 0x96)
 
516
                            ) {
 
517
                            if ((cdata[5 + p] == 0x64)
 
518
                                || (cdata[5 + p] == 0x65)
 
519
                                || (cdata[5 + p] == 0x66)
 
520
                                || (cdata[5 + p] == 0x67)) {
 
521
                                sof = 1;
 
522
                                break;
 
523
                            }
 
524
                        }
 
525
                    }
 
526
 
 
527
                    if (sof) {
 
528
                        *iPix = p + 16;
 
529
                        *datalength -= *iPix;
 
530
                        PDEBUG(5,
 
531
                               "Pcam header packet found, %d datalength %d !",
 
532
                               p, *datalength );
 
533
                               return 0;
 
534
                    } else {
 
535
                        *iPix = 0;
 
536
                        return (seqnum+1);
 
537
                    }
 
538
 
 
539
                }
 
540
}