drivers/media/video/hexium_gemini.c

   1 /*
   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");