blob: ad2c232baa6dce37bffb524bc68cf34591859bcc [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 hexium_gemini.c - v4l2 driver for Hexium Gemini frame grabber cards
Mauro Carvalho Chehaba8733ca2006-03-17 10:37:02 -03003
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 Visit http://www.mihu.de/linux/saa7146/ and follow the link
5 to "hexium" for further details about this card.
Mauro Carvalho Chehaba8733ca2006-03-17 10:37:02 -03006
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 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
Douglas Schilling Landgrafff699e62008-04-22 14:41:48 -030028static int debug;
Linus Torvalds1da177e2005-04-16 15:20:36 -070029module_param(debug, int, 0);
30MODULE_PARM_DESC(debug, "debug verbosity");
31
32/* global variables */
Douglas Schilling Landgrafff699e62008-04-22 14:41:48 -030033static int hexium_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35#define HEXIUM_GEMINI 4
36#define HEXIUM_GEMINI_DUAL 5
37
38#define HEXIUM_INPUTS 9
39static 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
53struct hexium_data
54{
55 s8 adr;
56 u8 byte;
57};
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#define HEXIUM_CONTROLS 1
60static struct v4l2_queryctrl hexium_controls[] = {
61 { V4L2_CID_PRIVATE_BASE, V4L2_CTRL_TYPE_BOOLEAN, "B/W", 0, 1, 1, 0, 0 },
62};
63
64#define HEXIUM_GEMINI_V_1_0 1
65#define HEXIUM_GEMINI_DUAL_V_1_0 2
66
67struct hexium
68{
69 int type;
70
71 struct video_device *video_dev;
72 struct i2c_adapter i2c_adapter;
Mauro Carvalho Chehaba8733ca2006-03-17 10:37:02 -030073
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 int cur_input; /* current input */
75 v4l2_std_id cur_std; /* current standard */
76 int cur_bw; /* current black/white status */
77};
78
79/* Samsung KS0127B decoder default registers */
80static u8 hexium_ks0127b[0x100]={
81/*00*/ 0x00,0x52,0x30,0x40,0x01,0x0C,0x2A,0x10,
82/*08*/ 0x00,0x00,0x00,0x60,0x00,0x00,0x0F,0x06,
83/*10*/ 0x00,0x00,0xE4,0xC0,0x00,0x00,0x00,0x00,
84/*18*/ 0x14,0x9B,0xFE,0xFF,0xFC,0xFF,0x03,0x22,
85/*20*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
86/*28*/ 0x00,0x00,0x00,0x00,0x00,0x2C,0x9B,0x00,
87/*30*/ 0x00,0x00,0x10,0x80,0x80,0x10,0x80,0x80,
88/*38*/ 0x01,0x04,0x00,0x00,0x00,0x29,0xC0,0x00,
89/*40*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
90/*48*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
91/*50*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
92/*58*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
93/*60*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
94/*68*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
95/*70*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
96/*78*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
97/*80*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
98/*88*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
99/*90*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
100/*98*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
101/*A0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
102/*A8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
103/*B0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
104/*B8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
105/*C0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
106/*C8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
107/*D0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
108/*D8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
109/*E0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
110/*E8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
111/*F0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
112/*F8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
113};
114
115static struct hexium_data hexium_pal[] = {
116 { 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
117};
118
119static struct hexium_data hexium_pal_bw[] = {
120 { 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
121};
122
123static struct hexium_data hexium_ntsc[] = {
124 { 0x01, 0x53 }, { 0x12, 0x04 }, { 0x2D, 0x23 }, { 0x2E, 0x81 }, { -1 , 0xFF }
125};
126
127static struct hexium_data hexium_ntsc_bw[] = {
128 { 0x01, 0x53 }, { 0x12, 0x04 }, { 0x2D, 0x23 }, { 0x2E, 0x81 }, { -1 , 0xFF }
129};
130
131static struct hexium_data hexium_secam[] = {
132 { 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
133};
134
135static struct hexium_data hexium_input_select[] = {
136 { 0x02, 0x60 },
137 { 0x02, 0x64 },
138 { 0x02, 0x61 },
139 { 0x02, 0x65 },
140 { 0x02, 0x62 },
141 { 0x02, 0x66 },
142 { 0x02, 0x68 },
143 { 0x02, 0x69 },
144 { 0x02, 0x6A },
145};
146
147/* fixme: h_offset = 0 for Hexium Gemini *Dual*, which
148 are currently *not* supported*/
149static struct saa7146_standard hexium_standards[] = {
150 {
151 .name = "PAL", .id = V4L2_STD_PAL,
152 .v_offset = 28, .v_field = 288,
153 .h_offset = 1, .h_pixels = 680,
154 .v_max_out = 576, .h_max_out = 768,
155 }, {
156 .name = "NTSC", .id = V4L2_STD_NTSC,
157 .v_offset = 28, .v_field = 240,
158 .h_offset = 1, .h_pixels = 640,
159 .v_max_out = 480, .h_max_out = 640,
160 }, {
161 .name = "SECAM", .id = V4L2_STD_SECAM,
162 .v_offset = 28, .v_field = 288,
163 .h_offset = 1, .h_pixels = 720,
164 .v_max_out = 576, .h_max_out = 768,
165 }
Mauro Carvalho Chehaba8733ca2006-03-17 10:37:02 -0300166};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
168/* bring hardware to a sane state. this has to be done, just in case someone
169 wants to capture from this device before it has been properly initialized.
170 the capture engine would badly fail, because no valid signal arrives on the
171 saa7146, thus leading to timeouts and stuff. */
172static int hexium_init_done(struct saa7146_dev *dev)
173{
174 struct hexium *hexium = (struct hexium *) dev->ext_priv;
175 union i2c_smbus_data data;
176 int i = 0;
177
178 DEB_D(("hexium_init_done called.\n"));
179
180 /* initialize the helper ics to useful values */
181 for (i = 0; i < sizeof(hexium_ks0127b); i++) {
182 data.byte = hexium_ks0127b[i];
183 if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, i, I2C_SMBUS_BYTE_DATA, &data)) {
184 printk("hexium_gemini: hexium_init_done() failed for address 0x%02x\n", i);
185 }
186 }
187
188 return 0;
189}
190
191static int hexium_set_input(struct hexium *hexium, int input)
192{
193 union i2c_smbus_data data;
194
195 DEB_D((".\n"));
196
197 data.byte = hexium_input_select[input].byte;
198 if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, hexium_input_select[input].adr, I2C_SMBUS_BYTE_DATA, &data)) {
199 return -1;
200 }
201
202 return 0;
203}
204
205static int hexium_set_standard(struct hexium *hexium, struct hexium_data *vdec)
206{
207 union i2c_smbus_data data;
208 int i = 0;
209
210 DEB_D((".\n"));
211
212 while (vdec[i].adr != -1) {
213 data.byte = vdec[i].byte;
214 if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, vdec[i].adr, I2C_SMBUS_BYTE_DATA, &data)) {
215 printk("hexium_init_done: hexium_set_standard() failed for address 0x%02x\n", i);
216 return -1;
217 }
218 i++;
219 }
220 return 0;
221}
222
Hans Verkuilb9600742009-01-18 19:59:11 -0300223static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
224{
225 DEB_EE(("VIDIOC_ENUMINPUT %d.\n", i->index));
226
Roel Kluin223ffe52009-05-02 16:38:47 -0300227 if (i->index >= HEXIUM_INPUTS)
Hans Verkuilb9600742009-01-18 19:59:11 -0300228 return -EINVAL;
229
230 memcpy(i, &hexium_inputs[i->index], sizeof(struct v4l2_input));
231
232 DEB_D(("v4l2_ioctl: VIDIOC_ENUMINPUT %d.\n", i->index));
233 return 0;
234}
235
236static int vidioc_g_input(struct file *file, void *fh, unsigned int *input)
237{
238 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
239 struct hexium *hexium = (struct hexium *) dev->ext_priv;
240
241 *input = hexium->cur_input;
242
243 DEB_D(("VIDIOC_G_INPUT: %d\n", *input));
244 return 0;
245}
246
247static int vidioc_s_input(struct file *file, void *fh, unsigned int input)
248{
249 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
250 struct hexium *hexium = (struct hexium *) dev->ext_priv;
251
252 DEB_EE(("VIDIOC_S_INPUT %d.\n", input));
253
Roel Kluinf14a2972009-10-23 07:59:42 -0300254 if (input >= HEXIUM_INPUTS)
Hans Verkuilb9600742009-01-18 19:59:11 -0300255 return -EINVAL;
256
257 hexium->cur_input = input;
258 hexium_set_input(hexium, input);
259 return 0;
260}
261
262/* the saa7146 provides some controls (brightness, contrast, saturation)
263 which gets registered *after* this function. because of this we have
264 to return with a value != 0 even if the function succeded.. */
265static int vidioc_queryctrl(struct file *file, void *fh, struct v4l2_queryctrl *qc)
266{
267 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
268 int i;
269
270 for (i = HEXIUM_CONTROLS - 1; i >= 0; i--) {
271 if (hexium_controls[i].id == qc->id) {
272 *qc = hexium_controls[i];
273 DEB_D(("VIDIOC_QUERYCTRL %d.\n", qc->id));
274 return 0;
275 }
276 }
277 return dev->ext_vv_data->core_ops->vidioc_queryctrl(file, fh, qc);
278}
279
280static int vidioc_g_ctrl(struct file *file, void *fh, struct v4l2_control *vc)
281{
282 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
283 struct hexium *hexium = (struct hexium *) dev->ext_priv;
284 int i;
285
286 for (i = HEXIUM_CONTROLS - 1; i >= 0; i--) {
287 if (hexium_controls[i].id == vc->id)
288 break;
289 }
290
291 if (i < 0)
292 return dev->ext_vv_data->core_ops->vidioc_g_ctrl(file, fh, vc);
293
294 if (vc->id == V4L2_CID_PRIVATE_BASE) {
295 vc->value = hexium->cur_bw;
296 DEB_D(("VIDIOC_G_CTRL BW:%d.\n", vc->value));
297 return 0;
298 }
299 return -EINVAL;
300}
301
302static int vidioc_s_ctrl(struct file *file, void *fh, struct v4l2_control *vc)
303{
304 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
305 struct hexium *hexium = (struct hexium *) dev->ext_priv;
306 int i = 0;
307
308 for (i = HEXIUM_CONTROLS - 1; i >= 0; i--) {
309 if (hexium_controls[i].id == vc->id)
310 break;
311 }
312
313 if (i < 0)
314 return dev->ext_vv_data->core_ops->vidioc_s_ctrl(file, fh, vc);
315
316 if (vc->id == V4L2_CID_PRIVATE_BASE)
317 hexium->cur_bw = vc->value;
318
319 DEB_D(("VIDIOC_S_CTRL BW:%d.\n", hexium->cur_bw));
320
321 if (0 == hexium->cur_bw && V4L2_STD_PAL == hexium->cur_std) {
322 hexium_set_standard(hexium, hexium_pal);
323 return 0;
324 }
325 if (0 == hexium->cur_bw && V4L2_STD_NTSC == hexium->cur_std) {
326 hexium_set_standard(hexium, hexium_ntsc);
327 return 0;
328 }
329 if (0 == hexium->cur_bw && V4L2_STD_SECAM == hexium->cur_std) {
330 hexium_set_standard(hexium, hexium_secam);
331 return 0;
332 }
333 if (1 == hexium->cur_bw && V4L2_STD_PAL == hexium->cur_std) {
334 hexium_set_standard(hexium, hexium_pal_bw);
335 return 0;
336 }
337 if (1 == hexium->cur_bw && V4L2_STD_NTSC == hexium->cur_std) {
338 hexium_set_standard(hexium, hexium_ntsc_bw);
339 return 0;
340 }
341 if (1 == hexium->cur_bw && V4L2_STD_SECAM == hexium->cur_std)
342 /* fixme: is there no bw secam mode? */
343 return -EINVAL;
344
345 return -EINVAL;
346}
347
348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349static struct saa7146_ext_vv vv_data;
350
351/* this function only gets called when the probing was successful */
352static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
353{
354 struct hexium *hexium = (struct hexium *) dev->ext_priv;
Hans Verkuilcd7d9be2010-02-20 07:56:25 -0300355 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
357 DEB_EE((".\n"));
358
Panagiotis Issaris74081872006-01-11 19:40:56 -0200359 hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 if (NULL == hexium) {
361 printk("hexium_gemini: not enough kernel memory in hexium_attach().\n");
362 return -ENOMEM;
363 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 dev->ext_priv = hexium;
365
366 /* enable i2c-port pins */
367 saa7146_write(dev, MC1, (MASK_08 | MASK_24 | MASK_10 | MASK_26));
368
369 hexium->i2c_adapter = (struct i2c_adapter) {
370 .class = I2C_CLASS_TV_ANALOG,
371 .name = "hexium gemini",
372 };
373 saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
374 if (i2c_add_adapter(&hexium->i2c_adapter) < 0) {
375 DEB_S(("cannot register i2c-device. skipping.\n"));
376 kfree(hexium);
377 return -EFAULT;
378 }
379
380 /* set HWControl GPIO number 2 */
381 saa7146_setgpio(dev, 2, SAA7146_GPIO_OUTHI);
382
383 saa7146_write(dev, DD1_INIT, 0x07000700);
384 saa7146_write(dev, DD1_STREAM_B, 0x00000000);
385 saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
386
387 /* the rest */
388 hexium->cur_input = 0;
389 hexium_init_done(dev);
390
391 hexium_set_standard(hexium, hexium_pal);
392 hexium->cur_std = V4L2_STD_PAL;
393
394 hexium_set_input(hexium, 0);
395 hexium->cur_input = 0;
396
397 saa7146_vv_init(dev, &vv_data);
Hans Verkuilb9600742009-01-18 19:59:11 -0300398 vv_data.ops.vidioc_queryctrl = vidioc_queryctrl;
399 vv_data.ops.vidioc_g_ctrl = vidioc_g_ctrl;
400 vv_data.ops.vidioc_s_ctrl = vidioc_s_ctrl;
401 vv_data.ops.vidioc_enum_input = vidioc_enum_input;
402 vv_data.ops.vidioc_g_input = vidioc_g_input;
403 vv_data.ops.vidioc_s_input = vidioc_s_input;
Hans Verkuilcd7d9be2010-02-20 07:56:25 -0300404 ret = saa7146_register_device(&hexium->video_dev, dev, "hexium gemini", VFL_TYPE_GRABBER);
405 if (ret < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 printk("hexium_gemini: cannot register capture v4l2 device. skipping.\n");
Hans Verkuilcd7d9be2010-02-20 07:56:25 -0300407 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 }
409
410 printk("hexium_gemini: found 'hexium gemini' frame grabber-%d.\n", hexium_num);
411 hexium_num++;
412
413 return 0;
414}
415
416static int hexium_detach(struct saa7146_dev *dev)
417{
418 struct hexium *hexium = (struct hexium *) dev->ext_priv;
419
420 DEB_EE(("dev:%p\n", dev));
421
422 saa7146_unregister_device(&hexium->video_dev, dev);
423 saa7146_vv_release(dev);
424
425 hexium_num--;
426
427 i2c_del_adapter(&hexium->i2c_adapter);
428 kfree(hexium);
429 return 0;
430}
431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432static int std_callback(struct saa7146_dev *dev, struct saa7146_standard *std)
433{
434 struct hexium *hexium = (struct hexium *) dev->ext_priv;
435
436 if (V4L2_STD_PAL == std->id) {
437 hexium_set_standard(hexium, hexium_pal);
438 hexium->cur_std = V4L2_STD_PAL;
439 return 0;
440 } else if (V4L2_STD_NTSC == std->id) {
441 hexium_set_standard(hexium, hexium_ntsc);
442 hexium->cur_std = V4L2_STD_NTSC;
443 return 0;
444 } else if (V4L2_STD_SECAM == std->id) {
445 hexium_set_standard(hexium, hexium_secam);
446 hexium->cur_std = V4L2_STD_SECAM;
447 return 0;
448 }
449
450 return -1;
451}
452
453static struct saa7146_extension hexium_extension;
454
455static struct saa7146_pci_extension_data hexium_gemini_4bnc = {
456 .ext_priv = "Hexium Gemini (4 BNC)",
457 .ext = &hexium_extension,
458};
459
460static struct saa7146_pci_extension_data hexium_gemini_dual_4bnc = {
461 .ext_priv = "Hexium Gemini Dual (4 BNC)",
462 .ext = &hexium_extension,
463};
464
465static struct pci_device_id pci_tbl[] = {
466 {
467 .vendor = PCI_VENDOR_ID_PHILIPS,
468 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
469 .subvendor = 0x17c8,
470 .subdevice = 0x2401,
471 .driver_data = (unsigned long) &hexium_gemini_4bnc,
472 },
473 {
474 .vendor = PCI_VENDOR_ID_PHILIPS,
475 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
476 .subvendor = 0x17c8,
477 .subdevice = 0x2402,
478 .driver_data = (unsigned long) &hexium_gemini_dual_4bnc,
479 },
480 {
481 .vendor = 0,
482 }
483};
484
485MODULE_DEVICE_TABLE(pci, pci_tbl);
486
487static struct saa7146_ext_vv vv_data = {
488 .inputs = HEXIUM_INPUTS,
489 .capabilities = 0,
490 .stds = &hexium_standards[0],
491 .num_stds = sizeof(hexium_standards) / sizeof(struct saa7146_standard),
492 .std_callback = &std_callback,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493};
494
495static struct saa7146_extension hexium_extension = {
496 .name = "hexium gemini",
497 .flags = SAA7146_USE_I2C_IRQ,
498
499 .pci_tbl = &pci_tbl[0],
500 .module = THIS_MODULE,
501
502 .attach = hexium_attach,
503 .detach = hexium_detach,
504
505 .irq_mask = 0,
506 .irq_func = NULL,
507};
508
509static int __init hexium_init_module(void)
510{
511 if (0 != saa7146_register_extension(&hexium_extension)) {
512 DEB_S(("failed to register extension.\n"));
513 return -ENODEV;
514 }
515
516 return 0;
517}
518
519static void __exit hexium_cleanup_module(void)
520{
521 saa7146_unregister_extension(&hexium_extension);
522}
523
524module_init(hexium_init_module);
525module_exit(hexium_cleanup_module);
526
527MODULE_DESCRIPTION("video4linux-2 driver for Hexium Gemini frame grabber cards");
528MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
529MODULE_LICENSE("GPL");