OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [media/] [video/] [hexium_gemini.c] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/*
2
    hexium_gemini.c - v4l2 driver for Hexium Gemini frame grabber cards
3
 
4
    Visit http://www.mihu.de/linux/saa7146/ and follow the link
5
    to "hexium" for further details about this card.
6
 
7
    Copyright (C) 2003 Michael Hunold <michael@mihu.de>
8
 
9
    This program is free software; you can redistribute it and/or modify
10
    it under the terms of the GNU General Public License as published by
11
    the Free Software Foundation; either version 2 of the License, or
12
    (at your option) any later version.
13
 
14
    This program is distributed in the hope that it will be useful,
15
    but WITHOUT ANY WARRANTY; without even the implied warranty of
16
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
    GNU General Public License for more details.
18
 
19
    You should have received a copy of the GNU General Public License
20
    along with this program; if not, write to the Free Software
21
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22
*/
23
 
24
#define DEBUG_VARIABLE debug
25
 
26
#include <media/saa7146_vv.h>
27
 
28
static int debug = 0;
29
module_param(debug, int, 0);
30
MODULE_PARM_DESC(debug, "debug verbosity");
31
 
32
/* global variables */
33
static int hexium_num = 0;
34
 
35
#define HEXIUM_GEMINI                   4
36
#define HEXIUM_GEMINI_DUAL              5
37
 
38
#define HEXIUM_INPUTS   9
39
static struct v4l2_input hexium_inputs[HEXIUM_INPUTS] = {
40
        { 0, "CVBS 1",   V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
41
        { 1, "CVBS 2",  V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
42
        { 2, "CVBS 3",  V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
43
        { 3, "CVBS 4",  V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
44
        { 4, "CVBS 5",  V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
45
        { 5, "CVBS 6",  V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
46
        { 6, "Y/C 1",   V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
47
        { 7, "Y/C 2",   V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
48
        { 8, "Y/C 3",   V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
49
};
50
 
51
#define HEXIUM_AUDIOS   0
52
 
53
struct hexium_data
54
{
55
        s8 adr;
56
        u8 byte;
57
};
58
 
59
static struct saa7146_extension_ioctls ioctls[] = {
60
        { VIDIOC_G_INPUT,       SAA7146_EXCLUSIVE },
61
        { VIDIOC_S_INPUT,       SAA7146_EXCLUSIVE },
62
        { VIDIOC_QUERYCTRL,     SAA7146_BEFORE },
63
        { VIDIOC_ENUMINPUT,     SAA7146_EXCLUSIVE },
64
        { VIDIOC_S_STD,         SAA7146_AFTER },
65
        { VIDIOC_G_CTRL,        SAA7146_BEFORE },
66
        { VIDIOC_S_CTRL,        SAA7146_BEFORE },
67
        { 0,                     0 }
68
};
69
 
70
#define HEXIUM_CONTROLS 1
71
static struct v4l2_queryctrl hexium_controls[] = {
72
        { V4L2_CID_PRIVATE_BASE, V4L2_CTRL_TYPE_BOOLEAN, "B/W", 0, 1, 1, 0, 0 },
73
};
74
 
75
#define HEXIUM_GEMINI_V_1_0             1
76
#define HEXIUM_GEMINI_DUAL_V_1_0        2
77
 
78
struct hexium
79
{
80
        int type;
81
 
82
        struct video_device     *video_dev;
83
        struct i2c_adapter      i2c_adapter;
84
 
85
        int             cur_input;      /* current input */
86
        v4l2_std_id     cur_std;        /* current standard */
87
        int             cur_bw;         /* current black/white status */
88
};
89
 
90
/* Samsung KS0127B decoder default registers */
91
static u8 hexium_ks0127b[0x100]={
92
/*00*/ 0x00,0x52,0x30,0x40,0x01,0x0C,0x2A,0x10,
93
/*08*/ 0x00,0x00,0x00,0x60,0x00,0x00,0x0F,0x06,
94
/*10*/ 0x00,0x00,0xE4,0xC0,0x00,0x00,0x00,0x00,
95
/*18*/ 0x14,0x9B,0xFE,0xFF,0xFC,0xFF,0x03,0x22,
96
/*20*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
97
/*28*/ 0x00,0x00,0x00,0x00,0x00,0x2C,0x9B,0x00,
98
/*30*/ 0x00,0x00,0x10,0x80,0x80,0x10,0x80,0x80,
99
/*38*/ 0x01,0x04,0x00,0x00,0x00,0x29,0xC0,0x00,
100
/*40*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
101
/*48*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
102
/*50*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
103
/*58*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
104
/*60*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
105
/*68*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
106
/*70*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
107
/*78*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
108
/*80*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
109
/*88*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
110
/*90*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
111
/*98*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
112
/*A0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
113
/*A8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
114
/*B0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
115
/*B8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
116
/*C0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
117
/*C8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
118
/*D0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
119
/*D8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
120
/*E0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
121
/*E8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
122
/*F0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
123
/*F8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
124
};
125
 
126
static struct hexium_data hexium_pal[] = {
127
        { 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
128
};
129
 
130
static struct hexium_data hexium_pal_bw[] = {
131
        { 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
132
};
133
 
134
static struct hexium_data hexium_ntsc[] = {
135
        { 0x01, 0x53 }, { 0x12, 0x04 }, { 0x2D, 0x23 }, { 0x2E, 0x81 }, { -1 , 0xFF }
136
};
137
 
138
static struct hexium_data hexium_ntsc_bw[] = {
139
        { 0x01, 0x53 }, { 0x12, 0x04 }, { 0x2D, 0x23 }, { 0x2E, 0x81 }, { -1 , 0xFF }
140
};
141
 
142
static struct hexium_data hexium_secam[] = {
143
        { 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
144
};
145
 
146
static struct hexium_data hexium_input_select[] = {
147
        { 0x02, 0x60 },
148
        { 0x02, 0x64 },
149
        { 0x02, 0x61 },
150
        { 0x02, 0x65 },
151
        { 0x02, 0x62 },
152
        { 0x02, 0x66 },
153
        { 0x02, 0x68 },
154
        { 0x02, 0x69 },
155
        { 0x02, 0x6A },
156
};
157
 
158
/* fixme: h_offset = 0 for Hexium Gemini *Dual*, which
159
   are currently *not* supported*/
160
static struct saa7146_standard hexium_standards[] = {
161
        {
162
                .name   = "PAL",        .id     = V4L2_STD_PAL,
163
                .v_offset       = 28,   .v_field        = 288,
164
                .h_offset       = 1,    .h_pixels       = 680,
165
                .v_max_out      = 576,  .h_max_out      = 768,
166
        }, {
167
                .name   = "NTSC",       .id     = V4L2_STD_NTSC,
168
                .v_offset       = 28,   .v_field        = 240,
169
                .h_offset       = 1,    .h_pixels       = 640,
170
                .v_max_out      = 480,  .h_max_out      = 640,
171
        }, {
172
                .name   = "SECAM",      .id     = V4L2_STD_SECAM,
173
                .v_offset       = 28,   .v_field        = 288,
174
                .h_offset       = 1,    .h_pixels       = 720,
175
                .v_max_out      = 576,  .h_max_out      = 768,
176
        }
177
};
178
 
179
/* bring hardware to a sane state. this has to be done, just in case someone
180
   wants to capture from this device before it has been properly initialized.
181
   the capture engine would badly fail, because no valid signal arrives on the
182
   saa7146, thus leading to timeouts and stuff. */
183
static int hexium_init_done(struct saa7146_dev *dev)
184
{
185
        struct hexium *hexium = (struct hexium *) dev->ext_priv;
186
        union i2c_smbus_data data;
187
        int i = 0;
188
 
189
        DEB_D(("hexium_init_done called.\n"));
190
 
191
        /* initialize the helper ics to useful values */
192
        for (i = 0; i < sizeof(hexium_ks0127b); i++) {
193
                data.byte = hexium_ks0127b[i];
194
                if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, i, I2C_SMBUS_BYTE_DATA, &data)) {
195
                        printk("hexium_gemini: hexium_init_done() failed for address 0x%02x\n", i);
196
                }
197
        }
198
 
199
        return 0;
200
}
201
 
202
static int hexium_set_input(struct hexium *hexium, int input)
203
{
204
        union i2c_smbus_data data;
205
 
206
        DEB_D((".\n"));
207
 
208
        data.byte = hexium_input_select[input].byte;
209
        if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, hexium_input_select[input].adr, I2C_SMBUS_BYTE_DATA, &data)) {
210
                return -1;
211
        }
212
 
213
        return 0;
214
}
215
 
216
static int hexium_set_standard(struct hexium *hexium, struct hexium_data *vdec)
217
{
218
        union i2c_smbus_data data;
219
        int i = 0;
220
 
221
        DEB_D((".\n"));
222
 
223
        while (vdec[i].adr != -1) {
224
                data.byte = vdec[i].byte;
225
                if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, vdec[i].adr, I2C_SMBUS_BYTE_DATA, &data)) {
226
                        printk("hexium_init_done: hexium_set_standard() failed for address 0x%02x\n", i);
227
                        return -1;
228
                }
229
                i++;
230
        }
231
        return 0;
232
}
233
 
234
static struct saa7146_ext_vv vv_data;
235
 
236
/* this function only gets called when the probing was successful */
237
static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
238
{
239
        struct hexium *hexium = (struct hexium *) dev->ext_priv;
240
 
241
        DEB_EE((".\n"));
242
 
243
        hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
244
        if (NULL == hexium) {
245
                printk("hexium_gemini: not enough kernel memory in hexium_attach().\n");
246
                return -ENOMEM;
247
        }
248
        dev->ext_priv = hexium;
249
 
250
        /* enable i2c-port pins */
251
        saa7146_write(dev, MC1, (MASK_08 | MASK_24 | MASK_10 | MASK_26));
252
 
253
        hexium->i2c_adapter = (struct i2c_adapter) {
254
                .class = I2C_CLASS_TV_ANALOG,
255
                .name = "hexium gemini",
256
        };
257
        saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
258
        if (i2c_add_adapter(&hexium->i2c_adapter) < 0) {
259
                DEB_S(("cannot register i2c-device. skipping.\n"));
260
                kfree(hexium);
261
                return -EFAULT;
262
        }
263
 
264
        /*  set HWControl GPIO number 2 */
265
        saa7146_setgpio(dev, 2, SAA7146_GPIO_OUTHI);
266
 
267
        saa7146_write(dev, DD1_INIT, 0x07000700);
268
        saa7146_write(dev, DD1_STREAM_B, 0x00000000);
269
        saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
270
 
271
        /* the rest */
272
        hexium->cur_input = 0;
273
        hexium_init_done(dev);
274
 
275
        hexium_set_standard(hexium, hexium_pal);
276
        hexium->cur_std = V4L2_STD_PAL;
277
 
278
        hexium_set_input(hexium, 0);
279
        hexium->cur_input = 0;
280
 
281
        saa7146_vv_init(dev, &vv_data);
282
        if (0 != saa7146_register_device(&hexium->video_dev, dev, "hexium gemini", VFL_TYPE_GRABBER)) {
283
                printk("hexium_gemini: cannot register capture v4l2 device. skipping.\n");
284
                return -1;
285
        }
286
 
287
        printk("hexium_gemini: found 'hexium gemini' frame grabber-%d.\n", hexium_num);
288
        hexium_num++;
289
 
290
        return 0;
291
}
292
 
293
static int hexium_detach(struct saa7146_dev *dev)
294
{
295
        struct hexium *hexium = (struct hexium *) dev->ext_priv;
296
 
297
        DEB_EE(("dev:%p\n", dev));
298
 
299
        saa7146_unregister_device(&hexium->video_dev, dev);
300
        saa7146_vv_release(dev);
301
 
302
        hexium_num--;
303
 
304
        i2c_del_adapter(&hexium->i2c_adapter);
305
        kfree(hexium);
306
        return 0;
307
}
308
 
309
static int hexium_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
310
{
311
        struct saa7146_dev *dev = fh->dev;
312
        struct hexium *hexium = (struct hexium *) dev->ext_priv;
313
/*
314
        struct saa7146_vv *vv = dev->vv_data;
315
*/
316
        switch (cmd) {
317
        case VIDIOC_ENUMINPUT:
318
                {
319
                        struct v4l2_input *i = arg;
320
                        DEB_EE(("VIDIOC_ENUMINPUT %d.\n", i->index));
321
 
322
                        if (i->index < 0 || i->index >= HEXIUM_INPUTS) {
323
                                return -EINVAL;
324
                        }
325
 
326
                        memcpy(i, &hexium_inputs[i->index], sizeof(struct v4l2_input));
327
 
328
                        DEB_D(("v4l2_ioctl: VIDIOC_ENUMINPUT %d.\n", i->index));
329
                        return 0;
330
                }
331
        case VIDIOC_G_INPUT:
332
                {
333
                        int *input = (int *) arg;
334
                        *input = hexium->cur_input;
335
 
336
                        DEB_D(("VIDIOC_G_INPUT: %d\n", *input));
337
                        return 0;
338
                }
339
        case VIDIOC_S_INPUT:
340
                {
341
                        int input = *(int *) arg;
342
 
343
                        DEB_EE(("VIDIOC_S_INPUT %d.\n", input));
344
 
345
                        if (input < 0 || input >= HEXIUM_INPUTS) {
346
                                return -EINVAL;
347
                        }
348
 
349
                        hexium->cur_input = input;
350
                        hexium_set_input(hexium, input);
351
 
352
                        return 0;
353
                }
354
                /* the saa7146 provides some controls (brightness, contrast, saturation)
355
                   which gets registered *after* this function. because of this we have
356
                   to return with a value != 0 even if the function succeded.. */
357
        case VIDIOC_QUERYCTRL:
358
                {
359
                        struct v4l2_queryctrl *qc = arg;
360
                        int i;
361
 
362
                        for (i = HEXIUM_CONTROLS - 1; i >= 0; i--) {
363
                                if (hexium_controls[i].id == qc->id) {
364
                                        *qc = hexium_controls[i];
365
                                        DEB_D(("VIDIOC_QUERYCTRL %d.\n", qc->id));
366
                                        return 0;
367
                                }
368
                        }
369
                        return -EAGAIN;
370
                }
371
        case VIDIOC_G_CTRL:
372
                {
373
                        struct v4l2_control *vc = arg;
374
                        int i;
375
 
376
                        for (i = HEXIUM_CONTROLS - 1; i >= 0; i--) {
377
                                if (hexium_controls[i].id == vc->id) {
378
                                        break;
379
                                }
380
                        }
381
 
382
                        if (i < 0) {
383
                                return -EAGAIN;
384
                        }
385
 
386
                        switch (vc->id) {
387
                        case V4L2_CID_PRIVATE_BASE:{
388
                                        vc->value = hexium->cur_bw;
389
                                        DEB_D(("VIDIOC_G_CTRL BW:%d.\n", vc->value));
390
                                        return 0;
391
                                }
392
                        }
393
                        return -EINVAL;
394
                }
395
 
396
        case VIDIOC_S_CTRL:
397
                {
398
                        struct v4l2_control *vc = arg;
399
                        int i = 0;
400
 
401
                        for (i = HEXIUM_CONTROLS - 1; i >= 0; i--) {
402
                                if (hexium_controls[i].id == vc->id) {
403
                                        break;
404
                                }
405
                        }
406
 
407
                        if (i < 0) {
408
                                return -EAGAIN;
409
                        }
410
 
411
                        switch (vc->id) {
412
                        case V4L2_CID_PRIVATE_BASE:{
413
                                        hexium->cur_bw = vc->value;
414
                                        break;
415
                                }
416
                        }
417
 
418
                        DEB_D(("VIDIOC_S_CTRL BW:%d.\n", hexium->cur_bw));
419
 
420
                        if (0 == hexium->cur_bw && V4L2_STD_PAL == hexium->cur_std) {
421
                                hexium_set_standard(hexium, hexium_pal);
422
                                return 0;
423
                        }
424
                        if (0 == hexium->cur_bw && V4L2_STD_NTSC == hexium->cur_std) {
425
                                hexium_set_standard(hexium, hexium_ntsc);
426
                                return 0;
427
                        }
428
                        if (0 == hexium->cur_bw && V4L2_STD_SECAM == hexium->cur_std) {
429
                                hexium_set_standard(hexium, hexium_secam);
430
                                return 0;
431
                        }
432
                        if (1 == hexium->cur_bw && V4L2_STD_PAL == hexium->cur_std) {
433
                                hexium_set_standard(hexium, hexium_pal_bw);
434
                                return 0;
435
                        }
436
                        if (1 == hexium->cur_bw && V4L2_STD_NTSC == hexium->cur_std) {
437
                                hexium_set_standard(hexium, hexium_ntsc_bw);
438
                                return 0;
439
                        }
440
                        if (1 == hexium->cur_bw && V4L2_STD_SECAM == hexium->cur_std) {
441
                                /* fixme: is there no bw secam mode? */
442
                                return -EINVAL;
443
                        }
444
 
445
                        return -EINVAL;
446
                }
447
        default:
448
/*
449
                DEB_D(("hexium_ioctl() does not handle this ioctl.\n"));
450
*/
451
                return -ENOIOCTLCMD;
452
        }
453
        return 0;
454
}
455
 
456
static int std_callback(struct saa7146_dev *dev, struct saa7146_standard *std)
457
{
458
        struct hexium *hexium = (struct hexium *) dev->ext_priv;
459
 
460
        if (V4L2_STD_PAL == std->id) {
461
                hexium_set_standard(hexium, hexium_pal);
462
                hexium->cur_std = V4L2_STD_PAL;
463
                return 0;
464
        } else if (V4L2_STD_NTSC == std->id) {
465
                hexium_set_standard(hexium, hexium_ntsc);
466
                hexium->cur_std = V4L2_STD_NTSC;
467
                return 0;
468
        } else if (V4L2_STD_SECAM == std->id) {
469
                hexium_set_standard(hexium, hexium_secam);
470
                hexium->cur_std = V4L2_STD_SECAM;
471
                return 0;
472
        }
473
 
474
        return -1;
475
}
476
 
477
static struct saa7146_extension hexium_extension;
478
 
479
static struct saa7146_pci_extension_data hexium_gemini_4bnc = {
480
        .ext_priv = "Hexium Gemini (4 BNC)",
481
        .ext = &hexium_extension,
482
};
483
 
484
static struct saa7146_pci_extension_data hexium_gemini_dual_4bnc = {
485
        .ext_priv = "Hexium Gemini Dual (4 BNC)",
486
        .ext = &hexium_extension,
487
};
488
 
489
static struct pci_device_id pci_tbl[] = {
490
        {
491
         .vendor = PCI_VENDOR_ID_PHILIPS,
492
         .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
493
         .subvendor = 0x17c8,
494
         .subdevice = 0x2401,
495
         .driver_data = (unsigned long) &hexium_gemini_4bnc,
496
         },
497
        {
498
         .vendor = PCI_VENDOR_ID_PHILIPS,
499
         .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
500
         .subvendor = 0x17c8,
501
         .subdevice = 0x2402,
502
         .driver_data = (unsigned long) &hexium_gemini_dual_4bnc,
503
         },
504
        {
505
         .vendor = 0,
506
         }
507
};
508
 
509
MODULE_DEVICE_TABLE(pci, pci_tbl);
510
 
511
static struct saa7146_ext_vv vv_data = {
512
        .inputs = HEXIUM_INPUTS,
513
        .capabilities = 0,
514
        .stds = &hexium_standards[0],
515
        .num_stds = sizeof(hexium_standards) / sizeof(struct saa7146_standard),
516
        .std_callback = &std_callback,
517
        .ioctls = &ioctls[0],
518
        .ioctl = hexium_ioctl,
519
};
520
 
521
static struct saa7146_extension hexium_extension = {
522
        .name = "hexium gemini",
523
        .flags = SAA7146_USE_I2C_IRQ,
524
 
525
        .pci_tbl = &pci_tbl[0],
526
        .module = THIS_MODULE,
527
 
528
        .attach = hexium_attach,
529
        .detach = hexium_detach,
530
 
531
        .irq_mask = 0,
532
        .irq_func = NULL,
533
};
534
 
535
static int __init hexium_init_module(void)
536
{
537
        if (0 != saa7146_register_extension(&hexium_extension)) {
538
                DEB_S(("failed to register extension.\n"));
539
                return -ENODEV;
540
        }
541
 
542
        return 0;
543
}
544
 
545
static void __exit hexium_cleanup_module(void)
546
{
547
        saa7146_unregister_extension(&hexium_extension);
548
}
549
 
550
module_init(hexium_init_module);
551
module_exit(hexium_cleanup_module);
552
 
553
MODULE_DESCRIPTION("video4linux-2 driver for Hexium Gemini frame grabber cards");
554
MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
555
MODULE_LICENSE("GPL");

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.