Subversion Repositories shark

Rev

Rev 621 | Rev 695 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
170 giacomo 1
/*
2
    bttv - Bt848 frame grabber driver
428 giacomo 3
 
4
    Copyright (C) 1996,97,98 Ralph  Metzler <rjkm@thp.uni-koeln.de>
5
                           & Marcus Metzler <mocm@thp.uni-koeln.de>
6
    (c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
7
 
8
    some v4l2 code lines are taken from Justin's bttv2 driver which is
9
    (c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za>
10
 
170 giacomo 11
    This program is free software; you can redistribute it and/or modify
12
    it under the terms of the GNU General Public License as published by
13
    the Free Software Foundation; either version 2 of the License, or
14
    (at your option) any later version.
428 giacomo 15
 
170 giacomo 16
    This program is distributed in the hope that it will be useful,
17
    but WITHOUT ANY WARRANTY; without even the implied warranty of
18
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
    GNU General Public License for more details.
428 giacomo 20
 
170 giacomo 21
    You should have received a copy of the GNU General Public License
22
    along with this program; if not, write to the Free Software
23
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24
*/
25
 
428 giacomo 26
#include <linuxcomp.h>
170 giacomo 27
 
428 giacomo 28
#include <linux/init.h>
29
#include <linux/module.h>
30
#include <linux/delay.h>
31
#include <linux/errno.h>
32
#include <linux/fs.h>
33
#include <linux/kernel.h>
34
#include <linux/sched.h>
35
#include <linux/interrupt.h>
36
#include <linux/kdev_t.h>
170 giacomo 37
 
428 giacomo 38
#include <asm/io.h>
39
#include <asm/byteorder.h>
170 giacomo 40
 
428 giacomo 41
#include "drivers/bttvp.h"
170 giacomo 42
 
428 giacomo 43
unsigned int bttv_num;                  /* number of Bt848s in use */
44
struct bttv bttvs[BTTV_MAX];
170 giacomo 45
 
614 giacomo 46
unsigned int bttv_debug = 0;
428 giacomo 47
unsigned int bttv_verbose = 1;
614 giacomo 48
unsigned int bttv_gpio = 0;
170 giacomo 49
 
428 giacomo 50
/* config variables */
51
#ifdef __BIG_ENDIAN
170 giacomo 52
static unsigned int bigendian=1;
53
#else
54
static unsigned int bigendian=0;
55
#endif
56
static unsigned int radio[BTTV_MAX];
57
static unsigned int irq_debug = 0;
428 giacomo 58
static unsigned int gbuffers = 8;
59
static unsigned int gbufsize = 0x208000;
170 giacomo 60
 
541 giacomo 61
static int video_nr = -1;
62
static int radio_nr = -1;
516 giacomo 63
//static int vbi_nr = -1;
170 giacomo 64
 
428 giacomo 65
static unsigned int fdsr = 0;
170 giacomo 66
 
428 giacomo 67
/* options */
68
static unsigned int combfilter  = 0;
69
static unsigned int lumafilter  = 0;
70
static unsigned int automute    = 1;
71
static unsigned int chroma_agc  = 0;
72
static unsigned int adc_crush   = 1;
73
static unsigned int vcr_hack    = 0;
74
static unsigned int irq_iswitch = 0;
170 giacomo 75
 
428 giacomo 76
/* API features (turn on/off stuff for testing) */
77
static unsigned int sloppy     = 0;
78
static unsigned int v4l2       = 1;
170 giacomo 79
 
80
 
428 giacomo 81
/* insmod args */
82
MODULE_PARM(radio,"1-" __stringify(BTTV_MAX) "i");
83
MODULE_PARM_DESC(radio,"The TV card supports radio, default is 0 (no)");
84
MODULE_PARM(bigendian,"i");
85
MODULE_PARM_DESC(bigendian,"byte order of the framebuffer, default is native endian");
86
MODULE_PARM(bttv_verbose,"i");
87
MODULE_PARM_DESC(bttv_verbose,"verbose startup messages, default is 1 (yes)");
88
MODULE_PARM(bttv_gpio,"i");
89
MODULE_PARM_DESC(bttv_gpio,"log gpio changes, default is 0 (no)");
90
MODULE_PARM(bttv_debug,"i");
91
MODULE_PARM_DESC(bttv_debug,"debug messages, default is 0 (no)");
92
MODULE_PARM(irq_debug,"i");
93
MODULE_PARM_DESC(irq_debug,"irq handler debug messages, default is 0 (no)");
94
MODULE_PARM(gbuffers,"i");
95
MODULE_PARM_DESC(gbuffers,"number of capture buffers. range 2-32, default 8");
96
MODULE_PARM(gbufsize,"i");
97
MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 0x208000");
170 giacomo 98
 
428 giacomo 99
MODULE_PARM(video_nr,"i");
100
MODULE_PARM(radio_nr,"i");
101
MODULE_PARM(vbi_nr,"i");
170 giacomo 102
 
428 giacomo 103
MODULE_PARM(fdsr,"i");
170 giacomo 104
 
428 giacomo 105
MODULE_PARM(combfilter,"i");
106
MODULE_PARM(lumafilter,"i");
107
MODULE_PARM(automute,"i");
108
MODULE_PARM_DESC(automute,"mute audio on bad/missing video signal, default is 1 (yes)");
109
MODULE_PARM(chroma_agc,"i");
110
MODULE_PARM_DESC(chroma_agc,"enables the AGC of chroma signal, default is 0 (no)");
111
MODULE_PARM(adc_crush,"i");
112
MODULE_PARM_DESC(adc_crush,"enables the luminance ADC crush, default is 1 (yes)");
113
MODULE_PARM(vcr_hack,"i");
114
MODULE_PARM_DESC(vcr_hack,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
115
MODULE_PARM(irq_iswitch,"i");
116
MODULE_PARM_DESC(irq_iswitch,"switch inputs in irq handler");
170 giacomo 117
 
428 giacomo 118
MODULE_PARM(sloppy,"i");
119
MODULE_PARM(v4l2,"i");
170 giacomo 120
 
428 giacomo 121
MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
122
MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
123
MODULE_LICENSE("GPL");
170 giacomo 124
 
428 giacomo 125
/* kernel args */
126
#ifndef MODULE
127
static int __init p_radio(char *str) { return bttv_parse(str,BTTV_MAX,radio); }
128
__setup("bttv.radio=", p_radio);
129
#endif
130
 
131
/* ----------------------------------------------------------------------- */
132
/* sysfs                                                                   */
516 giacomo 133
/*
428 giacomo 134
static ssize_t show_card(struct class_device *cd, char *buf)
170 giacomo 135
{
428 giacomo 136
        struct video_device *vfd = to_video_device(cd);
137
        struct bttv *btv = dev_get_drvdata(vfd->dev);
463 giacomo 138
        return sprintf26(buf, "%d\n", btv ? btv->type : UNSET);
170 giacomo 139
}
516 giacomo 140
*/
141
//static CLASS_DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
170 giacomo 142
 
428 giacomo 143
/* ----------------------------------------------------------------------- */
144
/* static data                                                             */
145
 
146
/* special timing tables from conexant... */
147
static u8 SRAM_Table[][60] =
170 giacomo 148
{
428 giacomo 149
        /* PAL digital input over GPIO[7:0] */
150
        {
151
                45, // 45 bytes following
152
                0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
153
                0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
154
                0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
155
                0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
156
                0x37,0x00,0xAF,0x21,0x00
157
        },
158
        /* NTSC digital input over GPIO[7:0] */
159
        {
160
                51, // 51 bytes following
161
                0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
162
                0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
163
                0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
164
                0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
165
                0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
166
                0x00,
167
        },
168
        // TGB_NTSC392 // quartzsight
169
        // This table has been modified to be used for Fusion Rev D
170
        {
171
                0x2A, // size of table = 42
172
                0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
173
                0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
174
                0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
175
                0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
176
                0x20, 0x00
177
        }
178
};
170 giacomo 179
 
428 giacomo 180
const struct bttv_tvnorm bttv_tvnorms[] = {
181
        /* PAL-BDGHI */
182
        /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
183
        /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
184
        {
185
                .v4l2_id        = V4L2_STD_PAL,
186
                .name           = "PAL",
187
                .Fsc            = 35468950,
188
                .swidth         = 924,
189
                .sheight        = 576,
190
                .totalwidth     = 1135,
191
                .adelay         = 0x7f,
192
                .bdelay         = 0x72,
193
                .iform          = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
194
                .scaledtwidth   = 1135,
195
                .hdelayx1       = 186,
196
                .hactivex1      = 924,
197
                .vdelay         = 0x20,
198
                .vbipack        = 255,
199
                .sram           = 0,
200
        },{
201
                .v4l2_id        = V4L2_STD_NTSC_M,
202
                .name           = "NTSC",
203
                .Fsc            = 28636363,
204
                .swidth         = 768,
205
                .sheight        = 480,
206
                .totalwidth     = 910,
207
                .adelay         = 0x68,
208
                .bdelay         = 0x5d,
209
                .iform          = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
210
                .scaledtwidth   = 910,
211
                .hdelayx1       = 128,
212
                .hactivex1      = 910,
213
                .vdelay         = 0x1a,
214
                .vbipack        = 144,
215
                .sram           = 1,
216
        },{
217
                .v4l2_id        = V4L2_STD_SECAM,
218
                .name           = "SECAM",
219
                .Fsc            = 35468950,
220
                .swidth         = 924,
221
                .sheight        = 576,
222
                .totalwidth     = 1135,
223
                .adelay         = 0x7f,
224
                .bdelay         = 0xb0,
225
                .iform          = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
226
                .scaledtwidth   = 1135,
227
                .hdelayx1       = 186,
228
                .hactivex1      = 922,
229
                .vdelay         = 0x20,
230
                .vbipack        = 255,
231
                .sram           = 0, /* like PAL, correct? */
232
        },{
233
                .v4l2_id        = V4L2_STD_PAL_Nc,
234
                .name           = "PAL-Nc",
235
                .Fsc            = 28636363,
236
                .swidth         = 640,
237
                .sheight        = 576,
238
                .totalwidth     = 910,
239
                .adelay         = 0x68,
240
                .bdelay         = 0x5d,
241
                .iform          = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
242
                .scaledtwidth   = 780,
243
                .hdelayx1       = 130,
244
                .hactivex1      = 734,
245
                .vdelay         = 0x1a,
246
                .vbipack        = 144,
247
                .sram           = -1,
248
        },{
249
                .v4l2_id        = V4L2_STD_PAL_M,
250
                .name           = "PAL-M",
251
                .Fsc            = 28636363,
252
                .swidth         = 640,
253
                .sheight        = 480,
254
                .totalwidth     = 910,
255
                .adelay         = 0x68,
256
                .bdelay         = 0x5d,
257
                .iform          = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
258
                .scaledtwidth   = 780,
259
                .hdelayx1       = 135,
260
                .hactivex1      = 754,
261
                .vdelay         = 0x1a,
262
                .vbipack        = 144,
263
                .sram           = -1,
264
        },{
265
                .v4l2_id        = V4L2_STD_PAL_N,
266
                .name           = "PAL-N",
267
                .Fsc            = 35468950,
268
                .swidth         = 768,
269
                .sheight        = 576,
270
                .totalwidth     = 1135,
271
                .adelay         = 0x7f,
272
                .bdelay         = 0x72,
273
                .iform          = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
274
                .scaledtwidth   = 944,
275
                .hdelayx1       = 186,
276
                .hactivex1      = 922,
277
                .vdelay         = 0x20,
278
                .vbipack        = 144,
279
                .sram           = -1,
280
        },{
281
                .v4l2_id        = V4L2_STD_NTSC_M_JP,
282
                .name           = "NTSC-JP",
283
                .Fsc            = 28636363,
284
                .swidth         = 640,
285
                .sheight        = 480,
286
                .totalwidth     = 910,
287
                .adelay         = 0x68,
288
                .bdelay         = 0x5d,
289
                .iform          = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
290
                .scaledtwidth   = 780,
291
                .hdelayx1       = 135,
292
                .hactivex1      = 754,
293
                .vdelay         = 0x16,
294
                .vbipack        = 144,
295
                .sram           = -1,
296
        },{
297
                /* that one hopefully works with the strange timing
298
                 * which video recorders produce when playing a NTSC
299
                 * tape on a PAL TV ... */
300
                .v4l2_id        = V4L2_STD_PAL_60,
301
                .name           = "PAL-60",
302
                .Fsc            = 35468950,
303
                .swidth         = 924,
304
                .sheight        = 480,
305
                .totalwidth     = 1135,
306
                .adelay         = 0x7f,
307
                .bdelay         = 0x72,
308
                .iform          = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
309
                .scaledtwidth   = 1135,
310
                .hdelayx1       = 186,
311
                .hactivex1      = 924,
312
                .vdelay         = 0x1a,
313
                .vbipack        = 255,
314
                .vtotal         = 524,
315
                .sram           = -1,
316
        }
317
};
318
const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
170 giacomo 319
 
428 giacomo 320
/* ----------------------------------------------------------------------- */
321
/* bttv format list
322
   packed pixel formats must come first */
323
const struct bttv_format bttv_formats[] = {
324
        {
325
                .name     = "8 bpp, gray",
326
                .palette  = VIDEO_PALETTE_GREY,
327
                .fourcc   = V4L2_PIX_FMT_GREY,
328
                .btformat = BT848_COLOR_FMT_Y8,
329
                .depth    = 8,
330
                .flags    = FORMAT_FLAGS_PACKED,
331
        },{
332
                .name     = "8 bpp, dithered color",
333
                .palette  = VIDEO_PALETTE_HI240,
334
                .fourcc   = V4L2_PIX_FMT_HI240,
335
                .btformat = BT848_COLOR_FMT_RGB8,
336
                .depth    = 8,
337
                .flags    = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
338
        },{
339
                .name     = "15 bpp RGB, le",
340
                .palette  = VIDEO_PALETTE_RGB555,
341
                .fourcc   = V4L2_PIX_FMT_RGB555,
342
                .btformat = BT848_COLOR_FMT_RGB15,
343
                .depth    = 16,
344
                .flags    = FORMAT_FLAGS_PACKED,
345
        },{
346
                .name     = "15 bpp RGB, be",
347
                .palette  = -1,
348
                .fourcc   = V4L2_PIX_FMT_RGB555X,
349
                .btformat = BT848_COLOR_FMT_RGB15,
350
                .btswap   = 0x03, /* byteswap */
351
                .depth    = 16,
352
                .flags    = FORMAT_FLAGS_PACKED,
353
        },{
354
                .name     = "16 bpp RGB, le",
355
                .palette  = VIDEO_PALETTE_RGB565,
356
                .fourcc   = V4L2_PIX_FMT_RGB565,
357
                .btformat = BT848_COLOR_FMT_RGB16,
358
                .depth    = 16,
359
                .flags    = FORMAT_FLAGS_PACKED,
360
        },{
361
                .name     = "16 bpp RGB, be",
362
                .palette  = -1,
363
                .fourcc   = V4L2_PIX_FMT_RGB565X,
364
                .btformat = BT848_COLOR_FMT_RGB16,
365
                .btswap   = 0x03, /* byteswap */
366
                .depth    = 16,
367
                .flags    = FORMAT_FLAGS_PACKED,
368
        },{
369
                .name     = "24 bpp RGB, le",
370
                .palette  = VIDEO_PALETTE_RGB24,
371
                .fourcc   = V4L2_PIX_FMT_BGR24,
372
                .btformat = BT848_COLOR_FMT_RGB24,
373
                .depth    = 24,
374
                .flags    = FORMAT_FLAGS_PACKED,
375
        },{
376
                .name     = "32 bpp RGB, le",
377
                .palette  = VIDEO_PALETTE_RGB32,
378
                .fourcc   = V4L2_PIX_FMT_BGR32,
379
                .btformat = BT848_COLOR_FMT_RGB32,
380
                .depth    = 32,
381
                .flags    = FORMAT_FLAGS_PACKED,
382
        },{
383
                .name     = "32 bpp RGB, be",
384
                .palette  = -1,
385
                .fourcc   = V4L2_PIX_FMT_RGB32,
386
                .btformat = BT848_COLOR_FMT_RGB32,
387
                .btswap   = 0x0f, /* byte+word swap */
388
                .depth    = 32,
389
                .flags    = FORMAT_FLAGS_PACKED,
390
        },{
391
                .name     = "4:2:2, packed, YUYV",
392
                .palette  = VIDEO_PALETTE_YUV422,
393
                .fourcc   = V4L2_PIX_FMT_YUYV,
394
                .btformat = BT848_COLOR_FMT_YUY2,
395
                .depth    = 16,
396
                .flags    = FORMAT_FLAGS_PACKED,
397
        },{
398
                .name     = "4:2:2, packed, YUYV",
399
                .palette  = VIDEO_PALETTE_YUYV,
400
                .fourcc   = V4L2_PIX_FMT_YUYV,
401
                .btformat = BT848_COLOR_FMT_YUY2,
402
                .depth    = 16,
403
                .flags    = FORMAT_FLAGS_PACKED,
404
        },{
405
                .name     = "4:2:2, packed, UYVY",
406
                .palette  = VIDEO_PALETTE_UYVY,
407
                .fourcc   = V4L2_PIX_FMT_UYVY,
408
                .btformat = BT848_COLOR_FMT_YUY2,
409
                .btswap   = 0x03, /* byteswap */
410
                .depth    = 16,
411
                .flags    = FORMAT_FLAGS_PACKED,
412
        },{
413
                .name     = "4:2:2, planar, Y-Cb-Cr",
414
                .palette  = VIDEO_PALETTE_YUV422P,
415
                .fourcc   = V4L2_PIX_FMT_YUV422P,
416
                .btformat = BT848_COLOR_FMT_YCrCb422,
417
                .depth    = 16,
418
                .flags    = FORMAT_FLAGS_PLANAR,
419
                .hshift   = 1,
420
                .vshift   = 0,
421
        },{
422
                .name     = "4:2:0, planar, Y-Cb-Cr",
423
                .palette  = VIDEO_PALETTE_YUV420P,
424
                .fourcc   = V4L2_PIX_FMT_YUV420,
425
                .btformat = BT848_COLOR_FMT_YCrCb422,
426
                .depth    = 12,
427
                .flags    = FORMAT_FLAGS_PLANAR,
428
                .hshift   = 1,
429
                .vshift   = 1,
430
        },{
431
                .name     = "4:2:0, planar, Y-Cr-Cb",
432
                .palette  = -1,
433
                .fourcc   = V4L2_PIX_FMT_YVU420,
434
                .btformat = BT848_COLOR_FMT_YCrCb422,
435
                .depth    = 12,
436
                .flags    = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
437
                .hshift   = 1,
438
                .vshift   = 1,
439
        },{
440
                .name     = "4:1:1, planar, Y-Cb-Cr",
441
                .palette  = VIDEO_PALETTE_YUV411P,
442
                .fourcc   = V4L2_PIX_FMT_YUV411P,
443
                .btformat = BT848_COLOR_FMT_YCrCb411,
444
                .depth    = 12,
445
                .flags    = FORMAT_FLAGS_PLANAR,
446
                .hshift   = 2,
447
                .vshift   = 0,
448
        },{
449
                .name     = "4:1:0, planar, Y-Cb-Cr",
450
                .palette  = VIDEO_PALETTE_YUV410P,
451
                .fourcc   = V4L2_PIX_FMT_YUV410,
452
                .btformat = BT848_COLOR_FMT_YCrCb411,
453
                .depth    = 9,
454
                .flags    = FORMAT_FLAGS_PLANAR,
455
                .hshift   = 2,
456
                .vshift   = 2,
457
        },{
458
                .name     = "4:1:0, planar, Y-Cr-Cb",
459
                .palette  = -1,
460
                .fourcc   = V4L2_PIX_FMT_YVU410,
461
                .btformat = BT848_COLOR_FMT_YCrCb411,
462
                .depth    = 9,
463
                .flags    = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
464
                .hshift   = 2,
465
                .vshift   = 2,
466
        },{
467
                .name     = "raw scanlines",
468
                .palette  = VIDEO_PALETTE_RAW,
469
                .fourcc   = -1,
470
                .btformat = BT848_COLOR_FMT_RAW,
471
                .depth    = 8,
472
                .flags    = FORMAT_FLAGS_RAW,
473
        }
474
};
475
const unsigned int BTTV_FORMATS = ARRAY_SIZE(bttv_formats);
170 giacomo 476
 
428 giacomo 477
/* ----------------------------------------------------------------------- */
478
 
479
#define V4L2_CID_PRIVATE_CHROMA_AGC  (V4L2_CID_PRIVATE_BASE + 0)
480
#define V4L2_CID_PRIVATE_COMBFILTER  (V4L2_CID_PRIVATE_BASE + 1)
481
#define V4L2_CID_PRIVATE_AUTOMUTE    (V4L2_CID_PRIVATE_BASE + 2)
482
#define V4L2_CID_PRIVATE_LUMAFILTER  (V4L2_CID_PRIVATE_BASE + 3)
483
#define V4L2_CID_PRIVATE_AGC_CRUSH   (V4L2_CID_PRIVATE_BASE + 4)
484
#define V4L2_CID_PRIVATE_VCR_HACK    (V4L2_CID_PRIVATE_BASE + 5)
485
#define V4L2_CID_PRIVATE_LASTP1      (V4L2_CID_PRIVATE_BASE + 6)
486
 
487
static const struct v4l2_queryctrl no_ctl = {
488
        .name  = "42",
489
        .flags = V4L2_CTRL_FLAG_DISABLED,
490
};
491
static const struct v4l2_queryctrl bttv_ctls[] = {
492
        /* --- video --- */
493
        {
494
                .id            = V4L2_CID_BRIGHTNESS,
495
                .name          = "Brightness",
496
                .minimum       = 0,
497
                .maximum       = 65535,
498
                .step          = 256,
499
                .default_value = 32768,
500
                .type          = V4L2_CTRL_TYPE_INTEGER,
501
        },{
502
                .id            = V4L2_CID_CONTRAST,
503
                .name          = "Contrast",
504
                .minimum       = 0,
505
                .maximum       = 65535,
506
                .step          = 128,
507
                .default_value = 32768,
508
                .type          = V4L2_CTRL_TYPE_INTEGER,
509
        },{
510
                .id            = V4L2_CID_SATURATION,
511
                .name          = "Saturation",
512
                .minimum       = 0,
513
                .maximum       = 65535,
514
                .step          = 128,
515
                .default_value = 32768,
516
                .type          = V4L2_CTRL_TYPE_INTEGER,
517
        },{
518
                .id            = V4L2_CID_HUE,
519
                .name          = "Hue",
520
                .minimum       = 0,
521
                .maximum       = 65535,
522
                .step          = 256,
523
                .default_value = 32768,
524
                .type          = V4L2_CTRL_TYPE_INTEGER,
525
        },
526
        /* --- audio --- */
527
        {
528
                .id            = V4L2_CID_AUDIO_MUTE,
529
                .name          = "Mute",
530
                .minimum       = 0,
531
                .maximum       = 1,
532
                .type          = V4L2_CTRL_TYPE_BOOLEAN,
533
        },{
534
                .id            = V4L2_CID_AUDIO_VOLUME,
535
                .name          = "Volume",
536
                .minimum       = 0,
537
                .maximum       = 65535,
538
                .step          = 65535/100,
539
                .default_value = 65535,
540
                .type          = V4L2_CTRL_TYPE_INTEGER,
541
        },{
542
                .id            = V4L2_CID_AUDIO_BALANCE,
543
                .name          = "Balance",
544
                .minimum       = 0,
545
                .maximum       = 65535,
546
                .step          = 65535/100,
547
                .default_value = 32768,
548
                .type          = V4L2_CTRL_TYPE_INTEGER,
549
        },{
550
                .id            = V4L2_CID_AUDIO_BASS,
551
                .name          = "Bass",
552
                .minimum       = 0,
553
                .maximum       = 65535,
554
                .step          = 65535/100,
555
                .default_value = 32768,
556
                .type          = V4L2_CTRL_TYPE_INTEGER,
557
        },{
558
                .id            = V4L2_CID_AUDIO_TREBLE,
559
                .name          = "Treble",
560
                .minimum       = 0,
561
                .maximum       = 65535,
562
                .step          = 65535/100,
563
                .default_value = 32768,
564
                .type          = V4L2_CTRL_TYPE_INTEGER,
565
        },
566
        /* --- private --- */
567
        {
568
                .id            = V4L2_CID_PRIVATE_CHROMA_AGC,
569
                .name          = "chroma agc",
570
                .minimum       = 0,
571
                .maximum       = 1,
572
                .type          = V4L2_CTRL_TYPE_BOOLEAN,
573
        },{
574
                .id            = V4L2_CID_PRIVATE_COMBFILTER,
575
                .name          = "combfilter",
576
                .minimum       = 0,
577
                .maximum       = 1,
578
                .type          = V4L2_CTRL_TYPE_BOOLEAN,
579
        },{
580
                .id            = V4L2_CID_PRIVATE_AUTOMUTE,
581
                .name          = "automute",
582
                .minimum       = 0,
583
                .maximum       = 1,
584
                .type          = V4L2_CTRL_TYPE_BOOLEAN,
585
        },{
586
                .id            = V4L2_CID_PRIVATE_LUMAFILTER,
587
                .name          = "luma decimation filter",
588
                .minimum       = 0,
589
                .maximum       = 1,
590
                .type          = V4L2_CTRL_TYPE_BOOLEAN,
591
        },{
592
                .id            = V4L2_CID_PRIVATE_AGC_CRUSH,
593
                .name          = "agc crush",
594
                .minimum       = 0,
595
                .maximum       = 1,
596
                .type          = V4L2_CTRL_TYPE_BOOLEAN,
597
        },{
598
                .id            = V4L2_CID_PRIVATE_VCR_HACK,
599
                .name          = "vcr hack",
600
                .minimum       = 0,
601
                .maximum       = 1,
602
                .type          = V4L2_CTRL_TYPE_BOOLEAN,
603
        }
604
};
605
const int BTTV_CTLS = ARRAY_SIZE(bttv_ctls);
606
 
607
/* ----------------------------------------------------------------------- */
608
/* resource management                                                     */
609
 
610
static
611
int check_alloc_btres(struct bttv *btv, struct bttv_fh *fh, int bit)
170 giacomo 612
{
428 giacomo 613
        if (fh->resources & bit)
614
                /* have it already allocated */
615
                return 1;
170 giacomo 616
 
428 giacomo 617
        /* is it free? */
480 giacomo 618
        //down(&btv->reslock);
428 giacomo 619
        if (btv->resources & bit) {
620
                /* no, someone else uses it */
480 giacomo 621
                //up(&btv->reslock);
428 giacomo 622
                return 0;
623
        }
624
        /* it's free, grab it */
625
        fh->resources  |= bit;
626
        btv->resources |= bit;
480 giacomo 627
        //up(&btv->reslock);
428 giacomo 628
        return 1;
629
}
170 giacomo 630
 
428 giacomo 631
static
632
int check_btres(struct bttv_fh *fh, int bit)
633
{
634
        return (fh->resources & bit);
170 giacomo 635
}
636
 
428 giacomo 637
static
638
int locked_btres(struct bttv *btv, int bit)
170 giacomo 639
{
428 giacomo 640
        return (btv->resources & bit);
170 giacomo 641
}
642
 
428 giacomo 643
static
644
void free_btres(struct bttv *btv, struct bttv_fh *fh, int bits)
170 giacomo 645
{
428 giacomo 646
#if 1 /* DEBUG */
647
        if ((fh->resources & bits) != bits) {
648
                /* trying to free ressources not allocated by us ... */
649
                printk("bttv: BUG! (btres)\n");
650
        }
651
#endif
480 giacomo 652
        //down(&btv->reslock);
428 giacomo 653
        fh->resources  &= ~bits;
654
        btv->resources &= ~bits;
480 giacomo 655
        //up(&btv->reslock);
170 giacomo 656
}
657
 
428 giacomo 658
/* ----------------------------------------------------------------------- */
659
/* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC          */
170 giacomo 660
 
661
/* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
662
   PLL_X = Reference pre-divider (0=1, 1=2)
663
   PLL_C = Post divider (0=6, 1=4)
664
   PLL_I = Integer input
665
   PLL_F = Fractional input
666
 
667
   F_input = 28.636363 MHz:
668
   PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
669
*/
670
 
671
static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
672
{
673
        unsigned char fl, fh, fi;
674
 
675
        /* prevent overflows */
676
        fin/=4;
677
        fout/=4;
678
 
679
        fout*=12;
680
        fi=fout/fin;
681
 
682
        fout=(fout%fin)*256;
683
        fh=fout/fin;
684
 
685
        fout=(fout%fin)*256;
686
        fl=fout/fin;
687
 
688
        btwrite(fl, BT848_PLL_F_LO);
689
        btwrite(fh, BT848_PLL_F_HI);
690
        btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
691
}
692
 
428 giacomo 693
static void set_pll(struct bttv *btv)
170 giacomo 694
{
695
        int i;
696
 
697
        if (!btv->pll.pll_crystal)
428 giacomo 698
                return;
170 giacomo 699
 
428 giacomo 700
        if (btv->pll.pll_ofreq == btv->pll.pll_current) {
701
                dprintk("bttv%d: PLL: no change required\n",btv->nr);
702
                return;
703
        }
704
 
170 giacomo 705
        if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
706
                /* no PLL needed */
428 giacomo 707
                if (btv->pll.pll_current == 0)
708
                        return;
709
                vprintk(KERN_INFO "bttv%d: PLL can sleep, using XTAL (%d).\n",
710
                        btv->nr,btv->pll.pll_ifreq);
170 giacomo 711
                btwrite(0x00,BT848_TGCTRL);
712
                btwrite(0x00,BT848_PLL_XCI);
713
                btv->pll.pll_current = 0;
428 giacomo 714
                return;
170 giacomo 715
        }
716
 
428 giacomo 717
        vprintk(KERN_INFO "bttv%d: PLL: %d => %d ",btv->nr,
718
                btv->pll.pll_ifreq, btv->pll.pll_ofreq);
170 giacomo 719
        set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
720
 
428 giacomo 721
        for (i=0; i<10; i++) {
722
                /*  Let other people run while the PLL stabilizes */
723
                vprintk(".");
491 giacomo 724
                //current->state = TASK_INTERRUPTIBLE;
725
                //schedule_timeout(HZ/10);
428 giacomo 726
 
727
                if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
728
                        btwrite(0,BT848_DSTATUS);
729
                } else {
170 giacomo 730
                        btwrite(0x08,BT848_TGCTRL);
731
                        btv->pll.pll_current = btv->pll.pll_ofreq;
428 giacomo 732
                        vprintk(" ok\n");
733
                        return;
170 giacomo 734
                }
735
        }
428 giacomo 736
        btv->pll.pll_current = -1;
737
        vprintk("failed\n");
738
        return;
170 giacomo 739
}
740
 
428 giacomo 741
/* used to switch between the bt848's analog/digital video capture modes */
742
void bt848A_set_timing(struct bttv *btv)
170 giacomo 743
{
428 giacomo 744
        int i, len;
745
        int table_idx = bttv_tvnorms[btv->tvnorm].sram;
746
        int fsc       = bttv_tvnorms[btv->tvnorm].Fsc;
747
 
748
        if (UNSET == bttv_tvcards[btv->type].muxsel[btv->input]) {
749
                dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
750
                        btv->nr,table_idx);
751
 
752
                /* timing change...reset timing generator address */
753
                btwrite(0x00, BT848_TGCTRL);
754
                btwrite(0x02, BT848_TGCTRL);
755
                btwrite(0x00, BT848_TGCTRL);
756
 
757
                len=SRAM_Table[table_idx][0];
758
                for(i = 1; i <= len; i++)
759
                        btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
760
                btv->pll.pll_ofreq = 27000000;
761
 
762
                set_pll(btv);
763
                btwrite(0x11, BT848_TGCTRL);
764
                btwrite(0x41, BT848_DVSIF);
765
        } else {
766
                btv->pll.pll_ofreq = fsc;
767
                set_pll(btv);
768
                btwrite(0x0, BT848_DVSIF);
769
        }
770
}
771
 
772
/* ----------------------------------------------------------------------- */
773
 
774
static void bt848_bright(struct bttv *btv, int bright)
775
{
776
        int value;
777
 
778
        btv->bright = bright;
779
 
780
        /* We want -128 to 127 we get 0-65535 */
781
        value = (bright >> 8) - 128;
782
        btwrite(value & 0xff, BT848_BRIGHT);
783
}
784
 
785
static void bt848_hue(struct bttv *btv, int hue)
786
{
787
        int value;
788
 
789
        btv->hue = hue;
790
 
791
        /* -128 to 127 */
792
        value = (hue >> 8) - 128;
793
        btwrite(value & 0xff, BT848_HUE);
794
}
795
 
796
static void bt848_contrast(struct bttv *btv, int cont)
797
{
798
        int value,hibit;
799
 
800
        btv->contrast = cont;
801
 
802
        /* 0-511 */
803
        value = (cont  >> 7);
804
        hibit = (value >> 6) & 4;
805
        btwrite(value & 0xff, BT848_CONTRAST_LO);
806
        btaor(hibit, ~4, BT848_E_CONTROL);
807
        btaor(hibit, ~4, BT848_O_CONTROL);
808
}
809
 
810
static void bt848_sat(struct bttv *btv, int color)
811
{
812
        int val_u,val_v,hibits;
813
 
814
        btv->saturation = color;
815
 
816
        /* 0-511 for the color */
817
        val_u   = color >> 7;
818
        val_v   = ((color>>7)*180L)/254;
819
        hibits  = (val_u >> 7) & 2;
820
        hibits |= (val_v >> 8) & 1;
821
        btwrite(val_u & 0xff, BT848_SAT_U_LO);
822
        btwrite(val_v & 0xff, BT848_SAT_V_LO);
823
        btaor(hibits, ~3, BT848_E_CONTROL);
824
        btaor(hibits, ~3, BT848_O_CONTROL);
825
}
826
 
827
/* ----------------------------------------------------------------------- */
828
 
829
static int
830
video_mux(struct bttv *btv, unsigned int input)
831
{
832
        int mux,mask2;
833
 
834
        if (input >= bttv_tvcards[btv->type].video_inputs)
835
                return -EINVAL;
836
 
170 giacomo 837
        /* needed by RemoteVideo MX */
428 giacomo 838
        mask2 = bttv_tvcards[btv->type].gpiomask2;
839
        if (mask2)
840
                btaor(mask2,~mask2,BT848_GPIO_OUT_EN);
170 giacomo 841
 
428 giacomo 842
        if (input == btv->svhs)  {
170 giacomo 843
                btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
844
                btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
428 giacomo 845
        } else {
170 giacomo 846
                btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
847
                btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
848
        }
428 giacomo 849
        mux = bttv_tvcards[btv->type].muxsel[input] & 3;
850
        btaor(mux<<5, ~(3<<5), BT848_IFORM);
851
        dprintk(KERN_DEBUG "bttv%d: video mux: input=%d mux=%d\n",
852
                btv->nr,input,mux);
170 giacomo 853
 
428 giacomo 854
        /* card specific hook */
855
        if(bttv_tvcards[btv->type].muxsel_hook)
856
                bttv_tvcards[btv->type].muxsel_hook (btv, input);
857
        return 0;
858
}
170 giacomo 859
 
428 giacomo 860
static char *audio_modes[] = {
861
        "audio: tuner", "audio: radio", "audio: extern",
862
        "audio: intern", "audio: off"
863
};
170 giacomo 864
 
428 giacomo 865
static int
866
audio_mux(struct bttv *btv, int mode)
867
{
868
        int val,mux,i2c_mux,signal;
869
 
870
        btaor(bttv_tvcards[btv->type].gpiomask,
871
              ~bttv_tvcards[btv->type].gpiomask,BT848_GPIO_OUT_EN);
872
        signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
170 giacomo 873
 
428 giacomo 874
        switch (mode) {
875
        case AUDIO_MUTE:
876
                btv->audio |= AUDIO_MUTE;
877
                break;
878
        case AUDIO_UNMUTE:
879
                btv->audio &= ~AUDIO_MUTE;
880
                break;
881
        case AUDIO_TUNER:
882
        case AUDIO_RADIO:
883
        case AUDIO_EXTERN:
884
        case AUDIO_INTERN:
885
                btv->audio &= AUDIO_MUTE;
886
                btv->audio |= mode;
887
        }
888
        i2c_mux = mux = (btv->audio & AUDIO_MUTE) ? AUDIO_OFF : btv->audio;
889
        if (btv->opt_automute && !signal && !btv->radio_user)
890
                mux = AUDIO_OFF;
891
#if 0
892
        printk("bttv%d: amux: mode=%d audio=%d signal=%s mux=%d/%d irq=%s\n",
893
               btv->nr, mode, btv->audio, signal ? "yes" : "no",
894
               mux, i2c_mux, in_interrupt() ? "yes" : "no");
895
#endif
896
 
897
        val = bttv_tvcards[btv->type].audiomux[mux];
898
        btaor(val,~bttv_tvcards[btv->type].gpiomask, BT848_GPIO_DATA);
170 giacomo 899
        if (bttv_gpio)
428 giacomo 900
                bttv_gpio_tracking(btv,audio_modes[mux]);
901
        if (!in_interrupt())
902
                bttv_call_i2c_clients(btv,AUDC_SET_INPUT,&(i2c_mux));
903
        return 0;
904
}
170 giacomo 905
 
428 giacomo 906
static void
907
i2c_vidiocschan(struct bttv *btv)
908
{
909
        struct video_channel c;
910
 
911
        memset(&c,0,sizeof(c));
912
        c.norm    = btv->tvnorm;
913
        c.channel = btv->input;
914
        bttv_call_i2c_clients(btv,VIDIOCSCHAN,&c);
915
        if (btv->type == BTTV_VOODOOTV_FM)
916
                bttv_tda9880_setnorm(btv,c.norm);
170 giacomo 917
}
918
 
428 giacomo 919
static int
920
set_tvnorm(struct bttv *btv, unsigned int norm)
170 giacomo 921
{
428 giacomo 922
        const struct bttv_tvnorm *tvnorm;
170 giacomo 923
 
428 giacomo 924
        if (norm < 0 || norm >= BTTV_TVNORMS)
925
                return -EINVAL;
170 giacomo 926
 
428 giacomo 927
        btv->tvnorm = norm;
928
        tvnorm = &bttv_tvnorms[norm];
929
 
930
        btwrite(tvnorm->adelay, BT848_ADELAY);
931
        btwrite(tvnorm->bdelay, BT848_BDELAY);
932
        btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
933
              BT848_IFORM);
934
        btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
935
        btwrite(1, BT848_VBI_PACK_DEL);
936
        bt848A_set_timing(btv);
937
 
938
        switch (btv->type) {
939
        case BTTV_VOODOOTV_FM:
940
                bttv_tda9880_setnorm(btv,norm);
941
                break;
170 giacomo 942
#if 0
428 giacomo 943
        case BTTV_OSPREY540:
944
                osprey_540_set_norm(btv,norm);
945
                break;
170 giacomo 946
#endif
428 giacomo 947
        }
948
        return 0;
949
}
170 giacomo 950
 
428 giacomo 951
static void
952
set_input(struct bttv *btv, unsigned int input)
170 giacomo 953
{
428 giacomo 954
        unsigned long flags;
955
 
956
        btv->input = input;
957
        if (irq_iswitch) {
958
                spin_lock_irqsave(&btv->s_lock,flags);
959
                if (btv->curr.irqflags) {
960
                        /* active capture -> delayed input switch */
961
                        btv->new_input = input;
962
                } else {
963
                        video_mux(btv,input);
964
                }
965
                spin_unlock_irqrestore(&btv->s_lock,flags);
966
        } else {
967
                video_mux(btv,input);
170 giacomo 968
        }
428 giacomo 969
        audio_mux(btv,(input == bttv_tvcards[btv->type].tuner ?
970
                       AUDIO_TUNER : AUDIO_EXTERN));
971
        set_tvnorm(btv,btv->tvnorm);
972
}
170 giacomo 973
 
428 giacomo 974
static void init_bt848(struct bttv *btv)
975
{
976
        int val;
977
 
978
        btwrite(0, BT848_SRESET);
979
        btwrite(0x00, BT848_CAP_CTL);
980
        btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
981
        btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
982
 
983
        /* set planar and packed mode trigger points and         */
984
        /* set rising edge of inverted GPINTR pin as irq trigger */
985
        btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
986
                BT848_GPIO_DMA_CTL_PLTP1_16|
987
                BT848_GPIO_DMA_CTL_PLTP23_16|
988
                BT848_GPIO_DMA_CTL_GPINTC|
989
                BT848_GPIO_DMA_CTL_GPINTI,
990
                BT848_GPIO_DMA_CTL);
991
 
992
        val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
993
        btwrite(val, BT848_E_SCLOOP);
994
        btwrite(val, BT848_O_SCLOOP);
995
 
996
        btwrite(0x20, BT848_E_VSCALE_HI);
997
        btwrite(0x20, BT848_O_VSCALE_HI);
998
        btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
999
                BT848_ADC);
1000
 
1001
        if (btv->opt_lumafilter) {
1002
                btwrite(0, BT848_E_CONTROL);
1003
                btwrite(0, BT848_O_CONTROL);
1004
        } else {
1005
                btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1006
                btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
170 giacomo 1007
        }
541 giacomo 1008
 
428 giacomo 1009
        btwrite(0xfffffUL, BT848_INT_STAT);
1010
        btwrite((btv->triton1)  |
1011
                BT848_INT_GPINT |
1012
                BT848_INT_SCERR |
1013
                (fdsr ? BT848_INT_FDSR : 0) |
1014
                BT848_INT_RISCI|BT848_INT_OCERR|BT848_INT_VPRES|
1015
                BT848_INT_FMTCHG|BT848_INT_HLOCK,
1016
                BT848_INT_MASK);
537 giacomo 1017
 
541 giacomo 1018
 
170 giacomo 1019
}
1020
 
428 giacomo 1021
extern void bttv_reinit_bt848(struct bttv *btv)
1022
{
1023
        unsigned long flags;
170 giacomo 1024
 
428 giacomo 1025
        if (bttv_verbose)
1026
                printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->nr);
1027
        spin_lock_irqsave(&btv->s_lock,flags);
1028
        btv->errors=0;
1029
        bttv_set_dma(btv,0,0);
1030
        spin_unlock_irqrestore(&btv->s_lock,flags);
170 giacomo 1031
 
428 giacomo 1032
        init_bt848(btv);
1033
        btv->pll.pll_current = -1;
1034
        set_input(btv,btv->input);
1035
}
1036
 
1037
static int get_control(struct bttv *btv, struct v4l2_control *c)
170 giacomo 1038
{
428 giacomo 1039
        struct video_audio va;
1040
        int i;
1041
 
1042
        for (i = 0; i < BTTV_CTLS; i++)
1043
                if (bttv_ctls[i].id == c->id)
1044
                        break;
1045
        if (i == BTTV_CTLS)
1046
                return -EINVAL;
1047
        if (i >= 4 && i <= 8) {
1048
                memset(&va,0,sizeof(va));
1049
                bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
1050
                if (btv->audio_hook)
1051
                        btv->audio_hook(btv,&va,0);
1052
        }
1053
        switch (c->id) {
1054
        case V4L2_CID_BRIGHTNESS:
1055
                c->value = btv->bright;
1056
                break;
1057
        case V4L2_CID_HUE:
1058
                c->value = btv->hue;
1059
                break;
1060
        case V4L2_CID_CONTRAST:
1061
                c->value = btv->contrast;
1062
                break;
1063
        case V4L2_CID_SATURATION:
1064
                c->value = btv->saturation;
1065
                break;
170 giacomo 1066
 
428 giacomo 1067
        case V4L2_CID_AUDIO_MUTE:
1068
                c->value = (VIDEO_AUDIO_MUTE & va.flags) ? 1 : 0;
1069
                break;
1070
        case V4L2_CID_AUDIO_VOLUME:
1071
                c->value = va.volume;
1072
                break;
1073
        case V4L2_CID_AUDIO_BALANCE:
1074
                c->value = va.balance;
1075
                break;
1076
        case V4L2_CID_AUDIO_BASS:
1077
                c->value = va.bass;
1078
                break;
1079
        case V4L2_CID_AUDIO_TREBLE:
1080
                c->value = va.treble;
1081
                break;
170 giacomo 1082
 
428 giacomo 1083
        case V4L2_CID_PRIVATE_CHROMA_AGC:
1084
                c->value = btv->opt_chroma_agc;
1085
                break;
1086
        case V4L2_CID_PRIVATE_COMBFILTER:
1087
                c->value = btv->opt_combfilter;
1088
                break;
1089
        case V4L2_CID_PRIVATE_LUMAFILTER:
1090
                c->value = btv->opt_lumafilter;
1091
                break;
1092
        case V4L2_CID_PRIVATE_AUTOMUTE:
1093
                c->value = btv->opt_automute;
1094
                break;
1095
        case V4L2_CID_PRIVATE_AGC_CRUSH:
1096
                c->value = btv->opt_adc_crush;
1097
                break;
1098
        case V4L2_CID_PRIVATE_VCR_HACK:
1099
                c->value = btv->opt_vcr_hack;
1100
                break;
1101
        default:
1102
                return -EINVAL;
170 giacomo 1103
        }
1104
        return 0;
1105
}
1106
 
428 giacomo 1107
static int set_control(struct bttv *btv, struct v4l2_control *c)
170 giacomo 1108
{
428 giacomo 1109
        struct video_audio va;
1110
        int i,val;
170 giacomo 1111
 
428 giacomo 1112
        for (i = 0; i < BTTV_CTLS; i++)
1113
                if (bttv_ctls[i].id == c->id)
1114
                        break;
1115
        if (i == BTTV_CTLS)
1116
                return -EINVAL;
1117
        if (i >= 4 && i <= 8) {
1118
                memset(&va,0,sizeof(va));
1119
                bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
1120
                if (btv->audio_hook)
1121
                        btv->audio_hook(btv,&va,0);
170 giacomo 1122
        }
428 giacomo 1123
        switch (c->id) {
1124
        case V4L2_CID_BRIGHTNESS:
1125
                bt848_bright(btv,c->value);
1126
                break;
1127
        case V4L2_CID_HUE:
1128
                bt848_hue(btv,c->value);
1129
                break;
1130
        case V4L2_CID_CONTRAST:
1131
                bt848_contrast(btv,c->value);
1132
                break;
1133
        case V4L2_CID_SATURATION:
1134
                bt848_sat(btv,c->value);
1135
                break;
1136
        case V4L2_CID_AUDIO_MUTE:
1137
                if (c->value) {
1138
                        va.flags |= VIDEO_AUDIO_MUTE;
1139
                        audio_mux(btv, AUDIO_MUTE);
1140
                } else {
1141
                        va.flags &= ~VIDEO_AUDIO_MUTE;
1142
                        audio_mux(btv, AUDIO_UNMUTE);
170 giacomo 1143
                }
428 giacomo 1144
                break;
170 giacomo 1145
 
428 giacomo 1146
        case V4L2_CID_AUDIO_VOLUME:
1147
                va.volume = c->value;
1148
                break;
1149
        case V4L2_CID_AUDIO_BALANCE:
1150
                va.balance = c->value;
1151
                break;
1152
        case V4L2_CID_AUDIO_BASS:
1153
                va.bass = c->value;
1154
                break;
1155
        case V4L2_CID_AUDIO_TREBLE:
1156
                va.treble = c->value;
1157
                break;
170 giacomo 1158
 
428 giacomo 1159
        case V4L2_CID_PRIVATE_CHROMA_AGC:
1160
                btv->opt_chroma_agc = c->value;
1161
                val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1162
                btwrite(val, BT848_E_SCLOOP);
1163
                btwrite(val, BT848_O_SCLOOP);
1164
                break;
1165
        case V4L2_CID_PRIVATE_COMBFILTER:
1166
                btv->opt_combfilter = c->value;
1167
                break;
1168
        case V4L2_CID_PRIVATE_LUMAFILTER:
1169
                btv->opt_lumafilter = c->value;
1170
                if (btv->opt_lumafilter) {
1171
                        btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1172
                        btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1173
                } else {
1174
                        btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1175
                        btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
170 giacomo 1176
                }
428 giacomo 1177
                break;
1178
        case V4L2_CID_PRIVATE_AUTOMUTE:
1179
                btv->opt_automute = c->value;
1180
                break;
1181
        case V4L2_CID_PRIVATE_AGC_CRUSH:
1182
                btv->opt_adc_crush = c->value;
1183
                btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1184
                        BT848_ADC);
1185
                break;
1186
        case V4L2_CID_PRIVATE_VCR_HACK:
1187
                btv->opt_vcr_hack = c->value;
1188
                break;
1189
        default:
1190
                return -EINVAL;
170 giacomo 1191
        }
428 giacomo 1192
        if (i >= 4 && i <= 8) {
1193
                bttv_call_i2c_clients(btv, VIDIOCSAUDIO, &va);
1194
                if (btv->audio_hook)
1195
                        btv->audio_hook(btv,&va,1);
1196
        }
170 giacomo 1197
        return 0;
1198
}
428 giacomo 1199
 
1200
/* ----------------------------------------------------------------------- */
1201
 
1202
void bttv_gpio_tracking(struct bttv *btv, char *comment)
170 giacomo 1203
{
428 giacomo 1204
        unsigned int outbits, data;
1205
        outbits = btread(BT848_GPIO_OUT_EN);
1206
        data    = btread(BT848_GPIO_DATA);
1207
        printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1208
               btv->nr,outbits,data & outbits, data & ~outbits, comment);
1209
}
170 giacomo 1210
 
428 giacomo 1211
void bttv_field_count(struct bttv *btv)
1212
{
1213
        int need_count = 0;
170 giacomo 1214
 
428 giacomo 1215
        if (btv->users)
1216
                need_count++;
170 giacomo 1217
 
428 giacomo 1218
        if (need_count) {
1219
                /* start field counter */
1220
                btor(BT848_INT_VSYNC,BT848_INT_MASK);
1221
        } else {
1222
                /* stop field counter */
1223
                btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1224
                btv->field_count = 0;
170 giacomo 1225
        }
1226
}
1227
 
428 giacomo 1228
static const struct bttv_format*
1229
format_by_palette(int palette)
170 giacomo 1230
{
428 giacomo 1231
        unsigned int i;
170 giacomo 1232
 
428 giacomo 1233
        for (i = 0; i < BTTV_FORMATS; i++) {
1234
                if (-1 == bttv_formats[i].palette)
1235
                        continue;
1236
                if (bttv_formats[i].palette == palette)
1237
                        return bttv_formats+i;
1238
        }
1239
        return NULL;
1240
}
170 giacomo 1241
 
428 giacomo 1242
static const struct bttv_format*
1243
format_by_fourcc(int fourcc)
1244
{
1245
        unsigned int i;
170 giacomo 1246
 
428 giacomo 1247
        for (i = 0; i < BTTV_FORMATS; i++) {
1248
                if (-1 == bttv_formats[i].fourcc)
1249
                        continue;
1250
                if (bttv_formats[i].fourcc == fourcc)
1251
                        return bttv_formats+i;
1252
        }
1253
        return NULL;
170 giacomo 1254
}
1255
 
428 giacomo 1256
/* ----------------------------------------------------------------------- */
1257
/* misc helpers                                                            */
1258
 
1259
static int
1260
bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1261
                    struct bttv_buffer *new)
170 giacomo 1262
{
428 giacomo 1263
        struct bttv_buffer *old;
1264
        unsigned long flags;
1265
        int retval = 0;
170 giacomo 1266
 
607 giacomo 1267
        dprintk("switch_overlay: enter [new=%x]\n",(int)new);
428 giacomo 1268
        if (new)
1269
                new->vb.state = STATE_DONE;
1270
        spin_lock_irqsave(&btv->s_lock,flags);
1271
        old = btv->screen;
1272
        btv->screen = new;
1273
        bttv_set_dma(btv, 0x03, 1);
1274
        spin_unlock_irqrestore(&btv->s_lock,flags);
1275
        if (NULL == new)
1276
                free_btres(btv,fh,RESOURCE_OVERLAY);
1277
        if (NULL != old) {
607 giacomo 1278
                dprintk("switch_overlay: old=%x state is %d\n",(int)old,old->vb.state);
608 giacomo 1279
                bttv_dma_free(btv, old);
428 giacomo 1280
                kfree(old);
1281
        }
1282
        dprintk("switch_overlay: done\n");
1283
        return retval;
1284
}
170 giacomo 1285
 
428 giacomo 1286
/* ----------------------------------------------------------------------- */
1287
/* video4linux (1) interface                                               */
170 giacomo 1288
 
428 giacomo 1289
static int bttv_prepare_buffer(struct bttv *btv, struct bttv_buffer *buf,
1290
                               const struct bttv_format *fmt,
1291
                               unsigned int width, unsigned int height,
1292
                               enum v4l2_field field)
1293
{
1294
        int redo_dma_risc = 0;
1295
        int rc;
1296
 
1297
        /* check settings */
1298
        if (NULL == fmt)
1299
                return -EINVAL;
1300
        if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1301
                width  = RAW_BPL;
1302
                height = RAW_LINES*2;
1303
                if (width*height > buf->vb.bsize)
1304
                        return -EINVAL;
1305
                buf->vb.size = buf->vb.bsize;
1306
        } else {
1307
                if (width  < 48 ||
1308
                    height < 32 ||
1309
                    width  > bttv_tvnorms[btv->tvnorm].swidth ||
1310
                    height > bttv_tvnorms[btv->tvnorm].sheight)
1311
                        return -EINVAL;
1312
                buf->vb.size = (width * height * fmt->depth) >> 3;
1313
                if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
1314
                        return -EINVAL;
170 giacomo 1315
        }
1316
 
428 giacomo 1317
        /* alloc + fill struct bttv_buffer (if changed) */
1318
        if (buf->vb.width != width || buf->vb.height != height ||
1319
            buf->vb.field != field ||
1320
            buf->tvnorm != btv->tvnorm || buf->fmt != fmt) {
1321
                buf->vb.width  = width;
1322
                buf->vb.height = height;
1323
                buf->vb.field  = field;
1324
                buf->tvnorm    = btv->tvnorm;
1325
                buf->fmt       = fmt;
1326
                redo_dma_risc = 1;
170 giacomo 1327
        }
1328
 
428 giacomo 1329
        /* alloc risc memory */
1330
        if (STATE_NEEDS_INIT == buf->vb.state) {
1331
                redo_dma_risc = 1;
1332
                if (0 != (rc = videobuf_iolock(btv->dev,&buf->vb,&btv->fbuf)))
1333
                        goto fail;
1334
        }
170 giacomo 1335
 
428 giacomo 1336
        if (redo_dma_risc)
1337
                if (0 != (rc = bttv_buffer_risc(btv,buf)))
1338
                        goto fail;
1339
 
1340
        buf->vb.state = STATE_PREPARED;
1341
        return 0;
1342
 
1343
 fail:
1344
        bttv_dma_free(btv,buf);
1345
        return rc;
170 giacomo 1346
}
1347
 
428 giacomo 1348
static int
1349
buffer_setup(struct file *file, unsigned int *count, unsigned int *size)
170 giacomo 1350
{
428 giacomo 1351
        struct bttv_fh *fh = file->private_data;
1352
 
1353
        *size = fh->fmt->depth*fh->width*fh->height >> 3;
1354
        if (0 == *count)
1355
                *count = gbuffers;
1356
        while (*size * *count > gbuffers * gbufsize)
1357
                (*count)--;
1358
        return 0;
1359
}
170 giacomo 1360
 
428 giacomo 1361
static int
1362
buffer_prepare(struct file *file, struct videobuf_buffer *vb,
1363
               enum v4l2_field field)
1364
{
1365
        struct bttv_buffer *buf = (struct bttv_buffer*)vb;
1366
        struct bttv_fh *fh = file->private_data;
170 giacomo 1367
 
428 giacomo 1368
        return bttv_prepare_buffer(fh->btv, buf, fh->fmt,
1369
                                   fh->width, fh->height, field);
170 giacomo 1370
}
1371
 
428 giacomo 1372
static void
1373
buffer_queue(struct file *file, struct videobuf_buffer *vb)
170 giacomo 1374
{
428 giacomo 1375
        struct bttv_buffer *buf = (struct bttv_buffer*)vb;
1376
        struct bttv_fh *fh = file->private_data;
170 giacomo 1377
 
428 giacomo 1378
        buf->vb.state = STATE_QUEUED;
1379
        list_add_tail(&buf->vb.queue,&fh->btv->capture);
1380
        bttv_set_dma(fh->btv, 0x03, 1);
1381
}
170 giacomo 1382
 
428 giacomo 1383
static void buffer_release(struct file *file, struct videobuf_buffer *vb)
1384
{
1385
        struct bttv_buffer *buf = (struct bttv_buffer*)vb;
1386
        struct bttv_fh *fh = file->private_data;
170 giacomo 1387
 
428 giacomo 1388
        bttv_dma_free(fh->btv,buf);
170 giacomo 1389
}
1390
 
428 giacomo 1391
static struct videobuf_queue_ops bttv_video_qops = {
1392
        .buf_setup    = buffer_setup,
1393
        .buf_prepare  = buffer_prepare,
1394
        .buf_queue    = buffer_queue,
1395
        .buf_release  = buffer_release,
170 giacomo 1396
};
1397
 
516 giacomo 1398
/*
428 giacomo 1399
static const char *v4l1_ioctls[] = {
1400
        "?", "CGAP", "GCHAN", "SCHAN", "GTUNER", "STUNER", "GPICT", "SPICT",
1401
        "CCAPTURE", "GWIN", "SWIN", "GFBUF", "SFBUF", "KEY", "GFREQ",
1402
        "SFREQ", "GAUDIO", "SAUDIO", "SYNC", "MCAPTURE", "GMBUF", "GUNIT",
1403
        "GCAPTURE", "SCAPTURE", "SPLAYMODE", "SWRITEMODE", "GPLAYINFO",
1404
        "SMICROCODE", "GVBIFMT", "SVBIFMT" };
516 giacomo 1405
*/
428 giacomo 1406
#define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
1407
 
1408
int bttv_common_ioctls(struct bttv *btv, unsigned int cmd, void *arg)
170 giacomo 1409
{
428 giacomo 1410
        switch (cmd) {
1411
        case BTTV_VERSION:
1412
                return BTTV_VERSION_CODE;
170 giacomo 1413
 
428 giacomo 1414
        /* ***  v4l1  *** ************************************************ */
1415
        case VIDIOCGFREQ:
1416
        {
1417
                unsigned long *freq = arg;
1418
                *freq = btv->freq;
1419
                return 0;
170 giacomo 1420
        }
428 giacomo 1421
        case VIDIOCSFREQ:
1422
        {
1423
                unsigned long *freq = arg;
480 giacomo 1424
                //down(&btv->lock);
428 giacomo 1425
                btv->freq=*freq;
1426
                bttv_call_i2c_clients(btv,VIDIOCSFREQ,freq);
1427
                if (btv->has_matchbox && btv->radio_user)
1428
                        tea5757_set_freq(btv,*freq);
480 giacomo 1429
                //up(&btv->lock);
428 giacomo 1430
                return 0;
170 giacomo 1431
        }
1432
 
428 giacomo 1433
        case VIDIOCGTUNER:
1434
        {
1435
                struct video_tuner *v = arg;
1436
 
1437
                if (UNSET == bttv_tvcards[btv->type].tuner)
1438
                        return -EINVAL;
1439
                if (v->tuner) /* Only tuner 0 */
1440
                        return -EINVAL;
1441
                strcpy(v->name, "Television");
1442
                v->rangelow  = 0;
1443
                v->rangehigh = 0x7FFFFFFF;
1444
                v->flags     = VIDEO_TUNER_PAL|VIDEO_TUNER_NTSC|VIDEO_TUNER_SECAM;
1445
                v->mode      = btv->tvnorm;
1446
                v->signal    = (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC) ? 0xFFFF : 0;
1447
                bttv_call_i2c_clients(btv,cmd,v);
1448
                return 0;
1449
        }
1450
        case VIDIOCSTUNER:
1451
        {
1452
                struct video_tuner *v = arg;
170 giacomo 1453
 
428 giacomo 1454
                if (v->tuner) /* Only tuner 0 */
1455
                        return -EINVAL;
1456
                if (v->mode >= BTTV_TVNORMS)
1457
                        return -EINVAL;
170 giacomo 1458
 
480 giacomo 1459
                //down(&btv->lock);
428 giacomo 1460
                set_tvnorm(btv,v->mode);
1461
                bttv_call_i2c_clients(btv,cmd,v);
480 giacomo 1462
                //up(&btv->lock);
428 giacomo 1463
                return 0;
1464
        }
1465
 
1466
        case VIDIOCGCHAN:
1467
        {
1468
                struct video_channel *v = arg;
1469
                unsigned int channel = v->channel;
170 giacomo 1470
 
428 giacomo 1471
                if (channel >= bttv_tvcards[btv->type].video_inputs)
1472
                        return -EINVAL;
1473
                v->tuners=0;
1474
                v->flags = VIDEO_VC_AUDIO;
1475
                v->type = VIDEO_TYPE_CAMERA;
1476
                v->norm = btv->tvnorm;
1477
                if (channel == bttv_tvcards[btv->type].tuner)  {
1478
                        strcpy(v->name,"Television");
1479
                        v->flags|=VIDEO_VC_TUNER;
1480
                        v->type=VIDEO_TYPE_TV;
1481
                        v->tuners=1;
1482
                } else if (channel == btv->svhs) {
1483
                        strcpy(v->name,"S-Video");
1484
                } else {
463 giacomo 1485
                        sprintf26(v->name,"Composite%d",channel);
428 giacomo 1486
                }
1487
                return 0;
1488
        }
1489
        case VIDIOCSCHAN:
1490
        {
1491
                struct video_channel *v = arg;
1492
                unsigned int channel = v->channel;
170 giacomo 1493
 
428 giacomo 1494
                if (channel >= bttv_tvcards[btv->type].video_inputs)
1495
                        return -EINVAL;
1496
                if (v->norm >= BTTV_TVNORMS)
1497
                        return -EINVAL;
480 giacomo 1498
                //down(&btv->lock);
428 giacomo 1499
                if (channel == btv->input &&
1500
                    v->norm == btv->tvnorm) {
1501
                        /* nothing to do */
480 giacomo 1502
                        //up(&btv->lock);
428 giacomo 1503
                        return 0;
1504
                }
170 giacomo 1505
 
428 giacomo 1506
                btv->tvnorm = v->norm;
1507
                set_input(btv,v->channel);
480 giacomo 1508
                //up(&btv->lock);
428 giacomo 1509
                return 0;
1510
        }
170 giacomo 1511
 
428 giacomo 1512
        case VIDIOCGAUDIO:
1513
        {
1514
                struct video_audio *v = arg;
170 giacomo 1515
 
428 giacomo 1516
                memset(v,0,sizeof(*v));
1517
                strcpy(v->name,"Television");
1518
                v->flags |= VIDEO_AUDIO_MUTABLE;
1519
                v->mode  = VIDEO_SOUND_MONO;
170 giacomo 1520
 
480 giacomo 1521
                //down(&btv->lock);
428 giacomo 1522
                bttv_call_i2c_clients(btv,cmd,v);
170 giacomo 1523
 
428 giacomo 1524
                /* card specific hooks */
1525
                if (btv->audio_hook)
1526
                        btv->audio_hook(btv,v,0);
170 giacomo 1527
 
480 giacomo 1528
                //up(&btv->lock);
428 giacomo 1529
                return 0;
1530
        }
1531
        case VIDIOCSAUDIO:
1532
        {
1533
                struct video_audio *v = arg;
1534
                unsigned int audio = v->audio;
170 giacomo 1535
 
428 giacomo 1536
                if (audio >= bttv_tvcards[btv->type].audio_inputs)
1537
                        return -EINVAL;
170 giacomo 1538
 
480 giacomo 1539
                //down(&btv->lock);
428 giacomo 1540
                audio_mux(btv, (v->flags&VIDEO_AUDIO_MUTE) ? AUDIO_MUTE : AUDIO_UNMUTE);
1541
                bttv_call_i2c_clients(btv,cmd,v);
170 giacomo 1542
 
428 giacomo 1543
                /* card specific hooks */
1544
                if (btv->audio_hook)
1545
                        btv->audio_hook(btv,v,1);
1546
 
480 giacomo 1547
                //up(&btv->lock);
428 giacomo 1548
                return 0;
1549
        }
170 giacomo 1550
 
428 giacomo 1551
        /* ***  v4l2  *** ************************************************ */
1552
        case VIDIOC_ENUMSTD:
1553
        {
1554
                struct v4l2_standard *e = arg;
1555
                unsigned int index = e->index;
1556
 
1557
                if (index >= BTTV_TVNORMS)
1558
                        return -EINVAL;
516 giacomo 1559
                //v4l2_video_std_construct(e, bttv_tvnorms[e->index].v4l2_id,
1560
                //                       bttv_tvnorms[e->index].name);
428 giacomo 1561
                e->index = index;
1562
                return 0;
1563
        }
1564
        case VIDIOC_G_STD:
1565
        {
1566
                v4l2_std_id *id = arg;
1567
                *id = bttv_tvnorms[btv->tvnorm].v4l2_id;
1568
                return 0;
1569
        }
1570
        case VIDIOC_S_STD:
1571
        {
1572
                v4l2_std_id *id = arg;
1573
                unsigned int i;
170 giacomo 1574
 
428 giacomo 1575
                for (i = 0; i < BTTV_TVNORMS; i++)
1576
                        if (*id & bttv_tvnorms[i].v4l2_id)
1577
                                break;
1578
                if (i == BTTV_TVNORMS)
1579
                        return -EINVAL;
170 giacomo 1580
 
480 giacomo 1581
                //down(&btv->lock);
428 giacomo 1582
                set_tvnorm(btv,i);
1583
                i2c_vidiocschan(btv);
480 giacomo 1584
                //up(&btv->lock);
428 giacomo 1585
                return 0;
1586
        }
1587
        case VIDIOC_QUERYSTD:
1588
        {
1589
                v4l2_std_id *id = arg;
1590
 
1591
                if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1592
                        *id = V4L2_STD_625_50;
1593
                else
1594
                        *id = V4L2_STD_525_60;
1595
                return 0;
1596
        }
170 giacomo 1597
 
428 giacomo 1598
        case VIDIOC_ENUMINPUT:
1599
        {
1600
                struct v4l2_input *i = arg;
1601
                unsigned int n;
1602
 
1603
                n = i->index;
1604
                if (n >= bttv_tvcards[btv->type].video_inputs)
1605
                        return -EINVAL;
1606
                memset(i,0,sizeof(*i));
1607
                i->index    = n;
1608
                i->type     = V4L2_INPUT_TYPE_CAMERA;
1609
                i->audioset = 1;
1610
                if (i->index == bttv_tvcards[btv->type].tuner) {
463 giacomo 1611
                        sprintf26(i->name, "Television");
428 giacomo 1612
                        i->type  = V4L2_INPUT_TYPE_TUNER;
1613
                        i->tuner = 0;
1614
                } else if (i->index == btv->svhs) {
463 giacomo 1615
                        sprintf26(i->name, "S-Video");
428 giacomo 1616
                } else {
463 giacomo 1617
                        sprintf26(i->name,"Composite%d",i->index);
428 giacomo 1618
                }
1619
                if (i->index == btv->input) {
1620
                        __u32 dstatus = btread(BT848_DSTATUS);
1621
                        if (0 == (dstatus & BT848_DSTATUS_PRES))
1622
                                i->status |= V4L2_IN_ST_NO_SIGNAL;
1623
                        if (0 == (dstatus & BT848_DSTATUS_HLOC))
1624
                                i->status |= V4L2_IN_ST_NO_H_LOCK;
1625
                }
1626
                for (n = 0; n < BTTV_TVNORMS; n++)
1627
                        i->std |= bttv_tvnorms[n].v4l2_id;
1628
                return 0;
1629
        }
1630
        case VIDIOC_G_INPUT:
1631
        {
1632
                int *i = arg;
1633
                *i = btv->input;
1634
                return 0;
1635
        }
1636
        case VIDIOC_S_INPUT:
1637
        {
1638
                unsigned int *i = arg;
1639
 
1640
                if (*i > bttv_tvcards[btv->type].video_inputs)
1641
                        return -EINVAL;
480 giacomo 1642
                //down(&btv->lock);
428 giacomo 1643
                set_input(btv,*i);
1644
                i2c_vidiocschan(btv);
480 giacomo 1645
                //up(&btv->lock);
428 giacomo 1646
                return 0;
1647
        }
1648
 
1649
        case VIDIOC_G_TUNER:
1650
        {
1651
                struct v4l2_tuner *t = arg;
170 giacomo 1652
 
428 giacomo 1653
                if (UNSET == bttv_tvcards[btv->type].tuner)
1654
                        return -EINVAL;
1655
                if (0 != t->index)
1656
                        return -EINVAL;
480 giacomo 1657
                //down(&btv->lock);
428 giacomo 1658
                memset(t,0,sizeof(*t));
1659
                strcpy(t->name, "Television");
1660
                t->type       = V4L2_TUNER_ANALOG_TV;
1661
                t->rangehigh  = 0xffffffffUL;
1662
                t->capability = V4L2_TUNER_CAP_NORM;
1663
                t->rxsubchans = V4L2_TUNER_SUB_MONO;
1664
                if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
1665
                        t->signal = 0xffff;
1666
                {
1667
                        /* Hmmm ... */
1668
                        struct video_audio va;
1669
                        memset(&va, 0, sizeof(struct video_audio));
1670
                        bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
1671
                        if (btv->audio_hook)
1672
                                btv->audio_hook(btv,&va,0);
1673
                        if(va.mode & VIDEO_SOUND_STEREO) {
1674
                                t->audmode     = V4L2_TUNER_MODE_STEREO;
1675
                                t->rxsubchans |= V4L2_TUNER_SUB_STEREO;
1676
                        }
1677
                        if(va.mode & VIDEO_SOUND_LANG1) {
1678
                                t->audmode    = V4L2_TUNER_MODE_LANG1;
1679
                                t->rxsubchans = V4L2_TUNER_SUB_LANG1
1680
                                        | V4L2_TUNER_SUB_LANG2;
1681
                        }
1682
                }
1683
                /* FIXME: fill capability+audmode */
480 giacomo 1684
                //up(&btv->lock);
428 giacomo 1685
                return 0;
1686
        }
1687
        case VIDIOC_S_TUNER:
1688
        {
1689
                struct v4l2_tuner *t = arg;
170 giacomo 1690
 
428 giacomo 1691
                if (UNSET == bttv_tvcards[btv->type].tuner)
1692
                        return -EINVAL;
1693
                if (0 != t->index)
1694
                        return -EINVAL;
480 giacomo 1695
                //down(&btv->lock);
428 giacomo 1696
                {
1697
                        struct video_audio va;
1698
                        memset(&va, 0, sizeof(struct video_audio));
1699
                        bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
1700
                        if (t->audmode == V4L2_TUNER_MODE_MONO)
1701
                                va.mode = VIDEO_SOUND_MONO;
1702
                        else if (t->audmode == V4L2_TUNER_MODE_STEREO)
1703
                                va.mode = VIDEO_SOUND_STEREO;
1704
                        else if (t->audmode == V4L2_TUNER_MODE_LANG1)
1705
                                va.mode = VIDEO_SOUND_LANG1;
1706
                        else if (t->audmode == V4L2_TUNER_MODE_LANG2)
1707
                                va.mode = VIDEO_SOUND_LANG2;
1708
                        bttv_call_i2c_clients(btv, VIDIOCSAUDIO, &va);
1709
                        if (btv->audio_hook)
1710
                                btv->audio_hook(btv,&va,1);
1711
                }
480 giacomo 1712
                //up(&btv->lock);
428 giacomo 1713
                return 0;
1714
        }
1715
 
1716
        case VIDIOC_G_FREQUENCY:
1717
        {
1718
                struct v4l2_frequency *f = arg;
1719
 
1720
                memset(f,0,sizeof(*f));
1721
                f->type = V4L2_TUNER_ANALOG_TV;
1722
                f->frequency = btv->freq;
1723
                return 0;
1724
        }
1725
        case VIDIOC_S_FREQUENCY:
1726
        {
1727
                struct v4l2_frequency *f = arg;
1728
 
1729
                if (unlikely(f->tuner != 0))
1730
                        return -EINVAL;
1731
                if (unlikely(f->type != V4L2_TUNER_ANALOG_TV))
1732
                        return -EINVAL;
480 giacomo 1733
                //down(&btv->lock);
428 giacomo 1734
                btv->freq = f->frequency;
1735
                bttv_call_i2c_clients(btv,VIDIOCSFREQ,&btv->freq);
1736
                if (btv->has_matchbox && btv->radio_user)
1737
                        tea5757_set_freq(btv,btv->freq);
480 giacomo 1738
                //up(&btv->lock);
428 giacomo 1739
                return 0;
1740
        }
1741
 
1742
        default:
1743
                return -ENOIOCTLCMD;
1744
 
1745
        }
1746
        return 0;
170 giacomo 1747
}
1748
 
428 giacomo 1749
static int verify_window(const struct bttv_tvnorm *tvn,
1750
                         struct v4l2_window *win, int fixup)
170 giacomo 1751
{
428 giacomo 1752
        enum v4l2_field field;
1753
        int maxw, maxh;
170 giacomo 1754
 
428 giacomo 1755
        if (win->w.width  < 48 || win->w.height < 32)
1756
                return -EINVAL;
1757
        if (win->clipcount > 2048)
1758
                return -EINVAL;
170 giacomo 1759
 
428 giacomo 1760
        field = win->field;
1761
        maxw  = tvn->swidth;
1762
        maxh  = tvn->sheight;
170 giacomo 1763
 
428 giacomo 1764
        if (V4L2_FIELD_ANY == field) {
1765
                field = (win->w.height > maxh/2)
1766
                        ? V4L2_FIELD_INTERLACED
1767
                        : V4L2_FIELD_TOP;
1768
        }
1769
        switch (field) {
1770
        case V4L2_FIELD_TOP:
1771
        case V4L2_FIELD_BOTTOM:
1772
                maxh = maxh / 2;
1773
                break;
1774
        case V4L2_FIELD_INTERLACED:
1775
                break;
1776
        default:
1777
                return -EINVAL;
1778
        }
170 giacomo 1779
 
428 giacomo 1780
        if (!fixup && (win->w.width > maxw || win->w.height > maxh))
1781
                return -EINVAL;
170 giacomo 1782
 
428 giacomo 1783
        if (win->w.width > maxw)
1784
                win->w.width = maxw;
1785
        if (win->w.height > maxh)
1786
                win->w.height = maxh;
1787
        win->field = field;
1788
        return 0;
170 giacomo 1789
}
1790
 
428 giacomo 1791
static int setup_window(struct bttv_fh *fh, struct bttv *btv,
1792
                        struct v4l2_window *win, int fixup)
170 giacomo 1793
{
428 giacomo 1794
        struct v4l2_clip *clips = NULL;
1795
        int n,size,retval = 0;
170 giacomo 1796
 
428 giacomo 1797
        if (NULL == fh->ovfmt)
1798
                return -EINVAL;
1799
        retval = verify_window(&bttv_tvnorms[btv->tvnorm],win,fixup);
1800
        if (0 != retval)
1801
                return retval;
257 giacomo 1802
 
428 giacomo 1803
        /* copy clips  --  luckily v4l1 + v4l2 are binary
1804
           compatible here ...*/
1805
        n = win->clipcount;
1806
        size = sizeof(*clips)*(n+4);
1807
        clips = kmalloc(size,GFP_KERNEL);
1808
        if (NULL == clips)
1809
                return -ENOMEM;
1810
        if (n > 0) {
1811
                if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
1812
                        kfree(clips);
1813
                        return -EFAULT;
1814
                }
1815
        }
541 giacomo 1816
 
428 giacomo 1817
        /* clip against screen */
1818
        if (NULL != btv->fbuf.base)
1819
                n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
1820
                                      &win->w, clips, n);
1821
        btcx_sort_clips(clips,n);
1822
 
1823
        /* 4-byte alignments */
1824
        switch (fh->ovfmt->depth) {
1825
        case 8:
1826
        case 24:
1827
                btcx_align(&win->w, clips, n, 3);
1828
                break;
1829
        case 16:
1830
                btcx_align(&win->w, clips, n, 1);
1831
                break;
1832
        case 32:
1833
                /* no alignment fixups needed */
1834
                break;
1835
        default:
1836
                BUG();
1837
        }
179 giacomo 1838
 
480 giacomo 1839
        //down(&fh->cap.lock);
428 giacomo 1840
        if (fh->ov.clips)
1841
                kfree(fh->ov.clips);
1842
        fh->ov.clips    = clips;
1843
        fh->ov.nclips   = n;
1844
 
1845
        fh->ov.w        = win->w;
1846
        fh->ov.field    = win->field;
1847
        fh->ov.setup_ok = 1;
1848
        btv->init.ov.w.width   = win->w.width;
1849
        btv->init.ov.w.height  = win->w.height;
1850
        btv->init.ov.field     = win->field;
1851
 
1852
        /* update overlay if needed */
1853
        retval = 0;
1854
        if (check_btres(fh, RESOURCE_OVERLAY)) {
1855
                struct bttv_buffer *new;
1856
 
1857
                new = videobuf_alloc(sizeof(*new));
1858
                bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
1859
                retval = bttv_switch_overlay(btv,fh,new);
1860
        }
541 giacomo 1861
 
480 giacomo 1862
        //up(&fh->cap.lock);
428 giacomo 1863
        return retval;
170 giacomo 1864
}
1865
 
428 giacomo 1866
/* ----------------------------------------------------------------------- */
170 giacomo 1867
 
428 giacomo 1868
static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
170 giacomo 1869
{
428 giacomo 1870
        struct videobuf_queue* q = NULL;
1871
 
1872
        switch (fh->type) {
1873
        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1874
                q = &fh->cap;
1875
                break;
1876
        case V4L2_BUF_TYPE_VBI_CAPTURE:
1877
                q = &fh->vbi;
1878
                break;
1879
        default:
1880
                BUG();
1881
        }
1882
        return q;
170 giacomo 1883
}
1884
 
428 giacomo 1885
static int bttv_resource(struct bttv_fh *fh)
170 giacomo 1886
{
428 giacomo 1887
        int res = 0;
1888
 
1889
        switch (fh->type) {
1890
        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1891
                res = RESOURCE_VIDEO;
1892
                break;
1893
        case V4L2_BUF_TYPE_VBI_CAPTURE:
1894
                res = RESOURCE_VBI;
1895
                break;
1896
        default:
1897
                BUG();
1898
        }
1899
        return res;
170 giacomo 1900
}
1901
 
428 giacomo 1902
static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
170 giacomo 1903
{
428 giacomo 1904
        struct videobuf_queue *q = bttv_queue(fh);
1905
        int res = bttv_resource(fh);
170 giacomo 1906
 
428 giacomo 1907
        if (check_btres(fh,res))
1908
                return -EBUSY;
1909
        if (videobuf_queue_is_busy(q))
1910
                return -EBUSY;
1911
        fh->type = type;
1912
        return 0;
170 giacomo 1913
}
1914
 
428 giacomo 1915
static int bttv_g_fmt(struct bttv_fh *fh, struct v4l2_format *f)
170 giacomo 1916
{
428 giacomo 1917
        switch (f->type) {
1918
        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1919
                memset(&f->fmt.pix,0,sizeof(struct v4l2_pix_format));
1920
                f->fmt.pix.width        = fh->width;
1921
                f->fmt.pix.height       = fh->height;
1922
                f->fmt.pix.field        = fh->cap.field;
1923
                f->fmt.pix.pixelformat  = fh->fmt->fourcc;
1924
                f->fmt.pix.bytesperline =
1925
                        (f->fmt.pix.width * fh->fmt->depth) >> 3;
1926
                f->fmt.pix.sizeimage =
1927
                        f->fmt.pix.height * f->fmt.pix.bytesperline;
1928
                return 0;
1929
        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1930
                memset(&f->fmt.win,0,sizeof(struct v4l2_window));
1931
                f->fmt.win.w     = fh->ov.w;
1932
                f->fmt.win.field = fh->ov.field;
1933
                return 0;
1934
        case V4L2_BUF_TYPE_VBI_CAPTURE:
516 giacomo 1935
                //bttv_vbi_get_fmt(fh,f);
428 giacomo 1936
                return 0;
1937
        default:
1938
                return -EINVAL;
1939
        }
1940
}
170 giacomo 1941
 
428 giacomo 1942
static int bttv_try_fmt(struct bttv_fh *fh, struct bttv *btv,
1943
                        struct v4l2_format *f)
1944
{
1945
        switch (f->type) {
1946
        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1947
        {
1948
                const struct bttv_format *fmt;
1949
                enum v4l2_field field;
1950
                unsigned int maxw,maxh;
1951
 
1952
                fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1953
                if (NULL == fmt)
1954
                        return -EINVAL;
1955
 
1956
                /* fixup format */
1957
                maxw  = bttv_tvnorms[btv->tvnorm].swidth;
1958
                maxh  = bttv_tvnorms[btv->tvnorm].sheight;
1959
                field = f->fmt.pix.field;
1960
                if (V4L2_FIELD_ANY == field)
1961
                        field = (f->fmt.pix.height > maxh/2)
1962
                                ? V4L2_FIELD_INTERLACED
1963
                                : V4L2_FIELD_BOTTOM;
1964
                if (V4L2_FIELD_SEQ_BT == field)
1965
                        field = V4L2_FIELD_SEQ_TB;
1966
                switch (field) {
1967
                case V4L2_FIELD_TOP:
1968
                case V4L2_FIELD_BOTTOM:
1969
                case V4L2_FIELD_ALTERNATE:
1970
                        maxh = maxh/2;
1971
                        break;
1972
                case V4L2_FIELD_INTERLACED:
1973
                        break;
1974
                case V4L2_FIELD_SEQ_TB:
1975
                        if (fmt->flags & FORMAT_FLAGS_PLANAR)
1976
                                return -EINVAL;
1977
                        break;
1978
                default:
1979
                        return -EINVAL;
1980
                }
1981
 
1982
                /* update data for the application */
1983
                f->fmt.pix.field = field;
1984
                if (f->fmt.pix.width  < 48)
1985
                        f->fmt.pix.width  = 48;
1986
                if (f->fmt.pix.height < 32)
1987
                        f->fmt.pix.height = 32;
1988
                if (f->fmt.pix.width  > maxw)
1989
                        f->fmt.pix.width = maxw;
1990
                if (f->fmt.pix.height > maxh)
1991
                        f->fmt.pix.height = maxh;
1992
                f->fmt.pix.bytesperline =
1993
                        (f->fmt.pix.width * fmt->depth) >> 3;
1994
                f->fmt.pix.sizeimage =
1995
                        f->fmt.pix.height * f->fmt.pix.bytesperline;
1996
 
1997
                return 0;
1998
        }
1999
        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2000
                return verify_window(&bttv_tvnorms[btv->tvnorm],
2001
                                     &f->fmt.win, 1);
2002
        case V4L2_BUF_TYPE_VBI_CAPTURE:
516 giacomo 2003
                //bttv_vbi_try_fmt(fh,f);
428 giacomo 2004
                return 0;
2005
        default:
2006
                return -EINVAL;
2007
        }
170 giacomo 2008
}
2009
 
428 giacomo 2010
static int bttv_s_fmt(struct bttv_fh *fh, struct bttv *btv,
2011
                      struct v4l2_format *f)
170 giacomo 2012
{
428 giacomo 2013
        int retval;
2014
 
2015
        switch (f->type) {
2016
        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2017
        {
2018
                const struct bttv_format *fmt;
170 giacomo 2019
 
428 giacomo 2020
                retval = bttv_switch_type(fh,f->type);
2021
                if (0 != retval)
2022
                        return retval;
2023
                retval = bttv_try_fmt(fh,btv,f);
2024
                if (0 != retval)
2025
                        return retval;
2026
                fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2027
 
2028
                /* update our state informations */
480 giacomo 2029
                //down(&fh->cap.lock);
428 giacomo 2030
                fh->fmt              = fmt;
2031
                fh->cap.field        = f->fmt.pix.field;
2032
                fh->cap.last         = V4L2_FIELD_NONE;
2033
                fh->width            = f->fmt.pix.width;
2034
                fh->height           = f->fmt.pix.height;
2035
                btv->init.fmt        = fmt;
2036
                btv->init.width      = f->fmt.pix.width;
2037
                btv->init.height     = f->fmt.pix.height;
480 giacomo 2038
                //up(&fh->cap.lock);
428 giacomo 2039
 
2040
                return 0;
2041
        }
2042
        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2043
                return setup_window(fh, btv, &f->fmt.win, 1);
2044
        case V4L2_BUF_TYPE_VBI_CAPTURE:
2045
                retval = bttv_switch_type(fh,f->type);
2046
                if (0 != retval)
2047
                        return retval;
2048
                if (locked_btres(fh->btv, RESOURCE_VBI))
2049
                        return -EBUSY;
516 giacomo 2050
                //bttv_vbi_try_fmt(fh,f);
2051
                //bttv_vbi_setlines(fh,btv,f->fmt.vbi.count[0]);
2052
                //bttv_vbi_get_fmt(fh,f);
428 giacomo 2053
                return 0;
2054
        default:
2055
                return -EINVAL;
2056
        }
170 giacomo 2057
}
2058
 
516 giacomo 2059
int bttv_do_ioctl(struct inode *inode, struct file *file,
428 giacomo 2060
                         unsigned int cmd, void *arg)
170 giacomo 2061
{
428 giacomo 2062
        struct bttv_fh *fh  = file->private_data;
2063
        struct bttv    *btv = fh->btv;
2064
        unsigned long flags;
2065
        int retval = 0;
170 giacomo 2066
 
428 giacomo 2067
        if (bttv_debug > 1) {
2068
                switch (_IOC_TYPE(cmd)) {
2069
                case 'v':
516 giacomo 2070
                        //printk("bttv%d: ioctl 0x%x (v4l1, VIDIOC%s)\n",
2071
                        //       btv->nr, cmd, (_IOC_NR(cmd) < V4L1_IOCTLS) ?
2072
                        //       v4l1_ioctls[_IOC_NR(cmd)] : "???");
428 giacomo 2073
                        break;
2074
                case 'V':
516 giacomo 2075
                        //printk("bttv%d: ioctl 0x%x (v4l2, %s)\n",
2076
                        //       btv->nr, cmd,  v4l2_ioctl_names[_IOC_NR(cmd)]);
428 giacomo 2077
                        break;
2078
                default:
2079
                        printk("bttv%d: ioctl 0x%x ()\n",
2080
                               btv->nr, cmd);
2081
                }
2082
        }
2083
        if (btv->errors)
2084
                bttv_reinit_bt848(btv);
170 giacomo 2085
 
428 giacomo 2086
#ifdef VIDIOC_G_PRIORITY
170 giacomo 2087
        switch (cmd) {
428 giacomo 2088
        case VIDIOCSFREQ:
2089
        case VIDIOCSTUNER:
2090
        case VIDIOCSCHAN:
2091
        case VIDIOC_S_CTRL:
2092
        case VIDIOC_S_STD:
2093
        case VIDIOC_S_INPUT:
2094
        case VIDIOC_S_TUNER:
2095
        case VIDIOC_S_FREQUENCY:
2096
                retval = v4l2_prio_check(&btv->prio,&fh->prio);
2097
                if (0 != retval)
2098
                        return retval;
2099
        };
2100
#endif
605 giacomo 2101
 
428 giacomo 2102
        switch (cmd) {
2103
 
2104
        /* ***  v4l1  *** ************************************************ */
170 giacomo 2105
        case VIDIOCGCAP:
2106
        {
428 giacomo 2107
                struct video_capability *cap = arg;
2108
 
2109
                memset(cap,0,sizeof(*cap));
2110
                strcpy(cap->name,btv->video_dev->name);
2111
                if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
2112
                        /* vbi */
2113
                        cap->type = VID_TYPE_TUNER|VID_TYPE_TELETEXT;
2114
                } else {
2115
                        /* others */
2116
                        cap->type = VID_TYPE_CAPTURE|
2117
                                VID_TYPE_TUNER|
2118
                                VID_TYPE_OVERLAY|
2119
                                VID_TYPE_CLIPPING|
2120
                                VID_TYPE_SCALES;
2121
                        cap->channels  = bttv_tvcards[btv->type].video_inputs;
2122
                        cap->audios    = bttv_tvcards[btv->type].audio_inputs;
2123
                        cap->maxwidth  = bttv_tvnorms[btv->tvnorm].swidth;
2124
                        cap->maxheight = bttv_tvnorms[btv->tvnorm].sheight;
2125
                        cap->minwidth  = 48;
2126
                        cap->minheight = 32;
2127
                }
2128
                return 0;
170 giacomo 2129
        }
428 giacomo 2130
 
2131
        case VIDIOCGPICT:
170 giacomo 2132
        {
428 giacomo 2133
                struct video_picture *pic = arg;
2134
 
2135
                memset(pic,0,sizeof(*pic));
2136
                pic->brightness = btv->bright;
2137
                pic->contrast   = btv->contrast;
2138
                pic->hue        = btv->hue;
2139
                pic->colour     = btv->saturation;
2140
                if (fh->fmt) {
2141
                        pic->depth   = fh->fmt->depth;
2142
                        pic->palette = fh->fmt->palette;
2143
                }
170 giacomo 2144
                return 0;
2145
        }
428 giacomo 2146
        case VIDIOCSPICT:
170 giacomo 2147
        {
428 giacomo 2148
                struct video_picture *pic = arg;
2149
                const struct bttv_format *fmt;
170 giacomo 2150
 
428 giacomo 2151
                fmt = format_by_palette(pic->palette);
2152
                if (NULL == fmt)
170 giacomo 2153
                        return -EINVAL;
480 giacomo 2154
                //down(&fh->cap.lock);
428 giacomo 2155
                if (fmt->depth != pic->depth && !sloppy) {
2156
                        retval = -EINVAL;
2157
                        goto fh_unlock_and_return;
2158
                }
2159
                fh->ovfmt   = fmt;
2160
                fh->fmt     = fmt;
2161
                btv->init.ovfmt   = fmt;
2162
                btv->init.fmt     = fmt;
2163
                if (bigendian) {
2164
                        /* dirty hack time:  swap bytes for overlay if the
2165
                           display adaptor is big endian (insmod option) */
2166
                        if (fmt->palette == VIDEO_PALETTE_RGB555 ||
2167
                            fmt->palette == VIDEO_PALETTE_RGB565 ||
2168
                            fmt->palette == VIDEO_PALETTE_RGB32) {
2169
                                fh->ovfmt = fmt+1;
2170
                        }
2171
                }
2172
                bt848_bright(btv,pic->brightness);
2173
                bt848_contrast(btv,pic->contrast);
2174
                bt848_hue(btv,pic->hue);
2175
                bt848_sat(btv,pic->colour);
480 giacomo 2176
                //up(&fh->cap.lock);
428 giacomo 2177
                return 0;
2178
        }
170 giacomo 2179
 
428 giacomo 2180
        case VIDIOCGWIN:
2181
        {
2182
                struct video_window *win = arg;
2183
 
2184
                memset(win,0,sizeof(*win));
2185
                win->x      = fh->ov.w.left;
2186
                win->y      = fh->ov.w.top;
2187
                win->width  = fh->ov.w.width;
2188
                win->height = fh->ov.w.height;
170 giacomo 2189
                return 0;
2190
        }
428 giacomo 2191
        case VIDIOCSWIN:
170 giacomo 2192
        {
428 giacomo 2193
                struct video_window *win = arg;
2194
                struct v4l2_window w2;
2195
 
2196
                w2.field = V4L2_FIELD_ANY;
2197
                w2.w.left    = win->x;
2198
                w2.w.top     = win->y;
2199
                w2.w.width   = win->width;
2200
                w2.w.height  = win->height;
2201
                w2.clipcount = win->clipcount;
2202
                w2.clips     = (struct v4l2_clip*)win->clips;
2203
                retval = setup_window(fh, btv, &w2, 0);
2204
                if (0 == retval) {
2205
                        /* on v4l1 this ioctl affects the read() size too */
2206
                        fh->width  = fh->ov.w.width;
2207
                        fh->height = fh->ov.w.height;
2208
                        btv->init.width  = fh->ov.w.width;
2209
                        btv->init.height = fh->ov.w.height;
2210
                }
2211
                return retval;
2212
        }
2213
 
2214
        case VIDIOCGFBUF:
2215
        {
2216
                struct video_buffer *fbuf = arg;
2217
 
2218
                fbuf->base          = btv->fbuf.base;
2219
                fbuf->width         = btv->fbuf.fmt.width;
2220
                fbuf->height        = btv->fbuf.fmt.height;
2221
                fbuf->bytesperline  = btv->fbuf.fmt.bytesperline;
2222
                if (fh->ovfmt)
2223
                        fbuf->depth = fh->ovfmt->depth;
170 giacomo 2224
                return 0;
2225
        }
428 giacomo 2226
        case VIDIOCSFBUF:
170 giacomo 2227
        {
428 giacomo 2228
                struct video_buffer *fbuf = arg;
2229
                const struct bttv_format *fmt;
2230
                unsigned long end;
2231
 
2232
                end = (unsigned long)fbuf->base +
2233
                        fbuf->height * fbuf->bytesperline;
480 giacomo 2234
                //down(&fh->cap.lock);
428 giacomo 2235
                retval = -EINVAL;
2236
                if (sloppy) {
2237
                        /* also set the default palette -- for backward
2238
                           compatibility with older versions */
2239
                        switch (fbuf->depth) {
2240
                        case 8:
2241
                                fmt = format_by_palette(VIDEO_PALETTE_HI240);
2242
                                break;
2243
                        case 16:
2244
                                fmt = format_by_palette(VIDEO_PALETTE_RGB565);
2245
                                break;
2246
                        case 24:
2247
                                fmt = format_by_palette(VIDEO_PALETTE_RGB24);
2248
                                break;
2249
                        case 32:
2250
                                fmt = format_by_palette(VIDEO_PALETTE_RGB32);
2251
                                break;
2252
                        case 15:
2253
                                fbuf->depth = 16;
2254
                                fmt = format_by_palette(VIDEO_PALETTE_RGB555);
2255
                                break;
2256
                        default:
2257
                                fmt = NULL;
2258
                                break;
2259
                        }
2260
                        if (NULL == fmt)
2261
                                goto fh_unlock_and_return;
2262
                        fh->ovfmt = fmt;
2263
                        fh->fmt   = fmt;
2264
                        btv->init.ovfmt = fmt;
2265
                        btv->init.fmt   = fmt;
2266
                } else {
2267
                        if (15 == fbuf->depth)
2268
                                fbuf->depth = 16;
2269
                        if (fbuf->depth !=  8 && fbuf->depth != 16 &&
2270
                            fbuf->depth != 24 && fbuf->depth != 32)
2271
                                goto fh_unlock_and_return;
170 giacomo 2272
                }
428 giacomo 2273
                btv->fbuf.base             = fbuf->base;
2274
                btv->fbuf.fmt.width        = fbuf->width;
2275
                btv->fbuf.fmt.height       = fbuf->height;
2276
                if (fbuf->bytesperline)
2277
                        btv->fbuf.fmt.bytesperline = fbuf->bytesperline;
2278
                else
2279
                        btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fbuf->depth/8;
480 giacomo 2280
                //up(&fh->cap.lock);
170 giacomo 2281
                return 0;
2282
        }
428 giacomo 2283
 
2284
        case VIDIOCCAPTURE:
2285
        case VIDIOC_OVERLAY:
170 giacomo 2286
        {
428 giacomo 2287
                struct bttv_buffer *new;
2288
                int *on = arg;
2289
 
2290
                if (*on) {
2291
                        /* verify args */
2292
                        if (NULL == btv->fbuf.base)
2293
                                return -EINVAL;
2294
                        if (!fh->ov.setup_ok) {
623 giacomo 2295
                                //dprintk("bttv%d: overlay: !setup_ok\n",btv->nr);
428 giacomo 2296
                                return -EINVAL;
2297
                        }
2298
                }
2299
 
2300
                if (!check_alloc_btres(btv,fh,RESOURCE_OVERLAY))
2301
                        return -EBUSY;
2302
 
480 giacomo 2303
                //down(&fh->cap.lock);
428 giacomo 2304
                if (*on) {
2305
                        fh->ov.tvnorm = btv->tvnorm;
2306
                        new = videobuf_alloc(sizeof(*new));
2307
                        bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2308
                } else {
2309
                        new = NULL;
2310
                }
2311
 
2312
                /* switch over */
2313
                retval = bttv_switch_overlay(btv,fh,new);
480 giacomo 2314
                //up(&fh->cap.lock);
428 giacomo 2315
                return retval;
2316
        }
2317
 
2318
        case VIDIOCGMBUF:
2319
        {
2320
                struct video_mbuf *mbuf = arg;
2321
                unsigned int i;
2322
 
480 giacomo 2323
                //down(&fh->cap.lock);
428 giacomo 2324
                retval = videobuf_mmap_setup(file,&fh->cap,gbuffers,gbufsize,
2325
                                             V4L2_MEMORY_MMAP);
2326
                if (retval < 0)
2327
                        goto fh_unlock_and_return;
2328
                memset(mbuf,0,sizeof(*mbuf));
2329
                mbuf->frames = gbuffers;
2330
                mbuf->size   = gbuffers * gbufsize;
2331
                for (i = 0; i < gbuffers; i++)
2332
                        mbuf->offsets[i] = i * gbufsize;
480 giacomo 2333
                //up(&fh->cap.lock);
170 giacomo 2334
                return 0;
2335
        }
428 giacomo 2336
        case VIDIOCMCAPTURE:
170 giacomo 2337
        {
428 giacomo 2338
                struct video_mmap *vm = arg;
2339
                struct bttv_buffer *buf;
2340
                enum v4l2_field field;
2341
 
2342
                if (vm->frame >= VIDEO_MAX_FRAME)
170 giacomo 2343
                        return -EINVAL;
428 giacomo 2344
 
480 giacomo 2345
                //down(&fh->cap.lock);
428 giacomo 2346
                retval = -EINVAL;
2347
                buf = (struct bttv_buffer *)fh->cap.bufs[vm->frame];
2348
                if (NULL == buf)
2349
                        goto fh_unlock_and_return;
606 giacomo 2350
 
428 giacomo 2351
                if (0 == buf->vb.baddr)
2352
                        goto fh_unlock_and_return;
541 giacomo 2353
 
428 giacomo 2354
                if (buf->vb.state == STATE_QUEUED ||
2355
                    buf->vb.state == STATE_ACTIVE)
2356
                        goto fh_unlock_and_return;
2357
 
2358
                field = (vm->height > bttv_tvnorms[btv->tvnorm].sheight/2)
2359
                        ? V4L2_FIELD_INTERLACED
2360
                        : V4L2_FIELD_BOTTOM;
2361
                retval = bttv_prepare_buffer(btv,buf,
2362
                                             format_by_palette(vm->format),
2363
                                             vm->width,vm->height,field);
2364
                if (0 != retval)
2365
                        goto fh_unlock_and_return;
2366
                spin_lock_irqsave(&btv->s_lock,flags);
2367
                buffer_queue(file,&buf->vb);
2368
                spin_unlock_irqrestore(&btv->s_lock,flags);
480 giacomo 2369
                //up(&fh->cap.lock);
170 giacomo 2370
                return 0;
2371
        }
428 giacomo 2372
        case VIDIOCSYNC:
170 giacomo 2373
        {
428 giacomo 2374
                int *frame = arg;
2375
                struct bttv_buffer *buf;
170 giacomo 2376
 
428 giacomo 2377
                if (*frame >= VIDEO_MAX_FRAME)
170 giacomo 2378
                        return -EINVAL;
2379
 
480 giacomo 2380
                //down(&fh->cap.lock);
428 giacomo 2381
                retval = -EINVAL;
2382
                buf = (struct bttv_buffer *)fh->cap.bufs[*frame];
2383
                if (NULL == buf)
2384
                        goto fh_unlock_and_return;
2385
                retval = videobuf_waiton(&buf->vb,0,1);
2386
                if (0 != retval)
2387
                        goto fh_unlock_and_return;
2388
                switch (buf->vb.state) {
2389
                case STATE_ERROR:
2390
                        retval = -EIO;
2391
                        /* fall through */
2392
                case STATE_DONE:
516 giacomo 2393
                        //videobuf_dma_pci_sync(btv->dev,&buf->vb.dma);
428 giacomo 2394
                        bttv_dma_free(btv,buf);
2395
                        break;
2396
                default:
2397
                        retval = -EINVAL;
2398
                        break;
170 giacomo 2399
                }
480 giacomo 2400
                //up(&fh->cap.lock);
428 giacomo 2401
                return retval;
170 giacomo 2402
        }
428 giacomo 2403
 
2404
        case VIDIOCGVBIFMT:
170 giacomo 2405
        {
428 giacomo 2406
                struct vbi_format *fmt = (void *) arg;
2407
                struct v4l2_format fmt2;
2408
 
2409
                if (fh->type != V4L2_BUF_TYPE_VBI_CAPTURE) {
2410
                        retval = bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
2411
                        if (0 != retval)
2412
                                return retval;
2413
                }
516 giacomo 2414
                //bttv_vbi_get_fmt(fh, &fmt2);
428 giacomo 2415
 
2416
                memset(fmt,0,sizeof(*fmt));
2417
                fmt->sampling_rate    = fmt2.fmt.vbi.sampling_rate;
2418
                fmt->samples_per_line = fmt2.fmt.vbi.samples_per_line;
2419
                fmt->sample_format    = VIDEO_PALETTE_RAW;
2420
                fmt->start[0]         = fmt2.fmt.vbi.start[0];
2421
                fmt->count[0]         = fmt2.fmt.vbi.count[0];
2422
                fmt->start[1]         = fmt2.fmt.vbi.start[1];
2423
                fmt->count[1]         = fmt2.fmt.vbi.count[1];
2424
                if (fmt2.fmt.vbi.flags & VBI_UNSYNC)
2425
                        fmt->flags   |= V4L2_VBI_UNSYNC;
2426
                if (fmt2.fmt.vbi.flags & VBI_INTERLACED)
2427
                        fmt->flags   |= V4L2_VBI_INTERLACED;
170 giacomo 2428
                return 0;
2429
        }
428 giacomo 2430
        case VIDIOCSVBIFMT:
170 giacomo 2431
        {
428 giacomo 2432
                struct vbi_format *fmt = (void *) arg;
2433
                struct v4l2_format fmt2;
2434
 
2435
                retval = bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
2436
                if (0 != retval)
2437
                        return retval;
516 giacomo 2438
                //bttv_vbi_get_fmt(fh, &fmt2);
428 giacomo 2439
 
2440
                if (fmt->sampling_rate    != fmt2.fmt.vbi.sampling_rate     ||
2441
                    fmt->samples_per_line != fmt2.fmt.vbi.samples_per_line  ||
2442
                    fmt->sample_format    != VIDEO_PALETTE_RAW              ||
2443
                    fmt->start[0]         != fmt2.fmt.vbi.start[0]          ||
2444
                    fmt->start[1]         != fmt2.fmt.vbi.start[1]          ||
2445
                    fmt->count[0]         != fmt->count[1]                  ||
2446
                    fmt->count[0]         <  1                              ||
2447
                    fmt->count[0]         >  32 /* VBI_MAXLINES */)
170 giacomo 2448
                        return -EINVAL;
428 giacomo 2449
 
516 giacomo 2450
                //bttv_vbi_setlines(fh,btv,fmt->count[0]);
170 giacomo 2451
                return 0;
2452
        }
428 giacomo 2453
 
2454
        case BTTV_VERSION:
2455
        case VIDIOCGFREQ:
2456
        case VIDIOCSFREQ:
2457
        case VIDIOCGTUNER:
2458
        case VIDIOCSTUNER:
2459
        case VIDIOCGCHAN:
2460
        case VIDIOCSCHAN:
2461
        case VIDIOCGAUDIO:
2462
        case VIDIOCSAUDIO:
2463
                return bttv_common_ioctls(btv,cmd,arg);
2464
 
2465
        /* ***  v4l2  *** ************************************************ */
2466
        case VIDIOC_QUERYCAP:
170 giacomo 2467
        {
428 giacomo 2468
                struct v4l2_capability *cap = arg;
2469
 
2470
                if (0 == v4l2)
2471
                        return -EINVAL;
2472
                strcpy(cap->driver,"bttv");
516 giacomo 2473
                strncpy(cap->card,btv->video_dev->name,sizeof(cap->card));
463 giacomo 2474
                sprintf26(cap->bus_info,"PCI:%s",pci_name(btv->dev));
428 giacomo 2475
                cap->version = BTTV_VERSION_CODE;
2476
                cap->capabilities =
2477
                        V4L2_CAP_VIDEO_CAPTURE |
2478
                        V4L2_CAP_VIDEO_OVERLAY |
2479
                        V4L2_CAP_VBI_CAPTURE |
2480
                        V4L2_CAP_TUNER |
2481
                        V4L2_CAP_READWRITE |
2482
                        V4L2_CAP_STREAMING;
170 giacomo 2483
                return 0;
2484
        }
428 giacomo 2485
 
2486
        case VIDIOC_ENUM_FMT:
170 giacomo 2487
        {
428 giacomo 2488
                struct v4l2_fmtdesc *f = arg;
2489
                enum v4l2_buf_type type;
2490
                unsigned int i;
2491
                int index;
2492
 
2493
                type  = f->type;
2494
                if (V4L2_BUF_TYPE_VBI_CAPTURE == type) {
2495
                        /* vbi */
2496
                        index = f->index;
2497
                        if (0 != index)
2498
                                return -EINVAL;
2499
                        memset(f,0,sizeof(*f));
2500
                        f->index       = index;
2501
                        f->type        = type;
2502
                        f->pixelformat = V4L2_PIX_FMT_GREY;
2503
                        strcpy(f->description,"vbi data");
2504
                        return 0;
2505
                }
2506
 
2507
                /* video capture + overlay */
2508
                index = -1;
2509
                for (i = 0; i < BTTV_FORMATS; i++) {
2510
                        if (bttv_formats[i].fourcc != -1)
2511
                                index++;
2512
                        if ((unsigned int)index == f->index)
2513
                                break;
2514
                }
2515
                if (BTTV_FORMATS == i)
170 giacomo 2516
                        return -EINVAL;
2517
 
428 giacomo 2518
                switch (f->type) {
2519
                case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2520
                        break;
2521
                case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2522
                        if (!(bttv_formats[i].flags & FORMAT_FLAGS_PACKED))
2523
                                return -EINVAL;
2524
                        break;
2525
                default:
2526
                        return -EINVAL;
170 giacomo 2527
                }
428 giacomo 2528
                memset(f,0,sizeof(*f));
2529
                f->index       = index;
2530
                f->type        = type;
2531
                f->pixelformat = bttv_formats[i].fourcc;
516 giacomo 2532
                strncpy(f->description,bttv_formats[i].name,sizeof(f->description));
428 giacomo 2533
                return 0;
170 giacomo 2534
        }
428 giacomo 2535
 
2536
        case VIDIOC_TRY_FMT:
170 giacomo 2537
        {
428 giacomo 2538
                struct v4l2_format *f = arg;
2539
                return bttv_try_fmt(fh,btv,f);