drivers/media/video/mxb.c

   1 /*
   2     mxb - v4l2 driver for the Multimedia eXtension Board
   3
   4     Copyright (C) 1998-2003 Michael Hunold <michael@mihu.de>
   5
   6     Visit http://www.mihu.de/linux/saa7146/mxb/
   7     for further details about this card.
   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 #include <media/tuner.h>
  28 #include <linux/video_decoder.h>
  29
  30 #include "mxb.h"
  31 #include "tea6415c.h"
  32 #include "tea6420.h"
  33 #include "tda9840.h"
  34
  35 #define I2C_SAA7111 0x24
  36
  37 #define MXB_BOARD_CAN_DO_VBI(dev)   (dev->revision != 0)
  38
  39 /* global variable */
  40 static int mxb_num = 0;
  41
  42 /* initial frequence the tuner will be tuned to.
  43    in verden (lower saxony, germany) 4148 is a
  44    channel called "phoenix" */
  45 static int freq = 4148;
  46 module_param(freq, int, 0644);
  47 MODULE_PARM_DESC(freq, "initial frequency the tuner will be tuned to while setup");
  48
  49 static int debug = 0;
  50 module_param(debug, int, 0644);
  51 MODULE_PARM_DESC(debug, "Turn on/off device debugging (default:off).");
  52
  53 #define MXB_INPUTS 4
  54 enum { TUNER, AUX1, AUX3, AUX3_YC };
  55
  56 static struct v4l2_input mxb_inputs[MXB_INPUTS] = {
  57         { TUNER,        "Tuner",                V4L2_INPUT_TYPE_TUNER,  1, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  58         { AUX1,         "AUX1",                 V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  59         { AUX3,         "AUX3 Composite",       V4L2_INPUT_TYPE_CAMERA, 4, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  60         { AUX3_YC,      "AUX3 S-Video",         V4L2_INPUT_TYPE_CAMERA, 4, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  61 };
  62
  63 /* this array holds the information, which port of the saa7146 each
  64    input actually uses. the mxb uses port 0 for every input */
  65 static struct {
  66         int hps_source;
  67         int hps_sync;
  68 } input_port_selection[MXB_INPUTS] = {
  69         { SAA7146_HPS_SOURCE_PORT_A, SAA7146_HPS_SYNC_PORT_A },
  70         { SAA7146_HPS_SOURCE_PORT_A, SAA7146_HPS_SYNC_PORT_A },
  71         { SAA7146_HPS_SOURCE_PORT_A, SAA7146_HPS_SYNC_PORT_A },
  72         { SAA7146_HPS_SOURCE_PORT_A, SAA7146_HPS_SYNC_PORT_A },
  73 };
  74
  75 /* this array holds the information of the audio source (mxb_audios),
  76    which has to be switched corresponding to the video source (mxb_channels) */
  77 static int video_audio_connect[MXB_INPUTS] =
  78         { 0, 1, 3, 3 };
  79
  80 /* these are the necessary input-output-pins for bringing one audio source
  81 (see above) to the CD-output */
  82 static struct tea6420_multiplex TEA6420_cd[MXB_AUDIOS+1][2] =
  83                 {
  84                 {{1,1,0},{1,1,0}},      /* Tuner */
  85                 {{5,1,0},{6,1,0}},      /* AUX 1 */
  86                 {{4,1,0},{6,1,0}},      /* AUX 2 */
  87                 {{3,1,0},{6,1,0}},      /* AUX 3 */
  88                 {{1,1,0},{3,1,0}},      /* Radio */
  89                 {{1,1,0},{2,1,0}},      /* CD-Rom */
  90                 {{6,1,0},{6,1,0}}       /* Mute */
  91                 };
  92
  93 /* these are the necessary input-output-pins for bringing one audio source
  94 (see above) to the line-output */
  95 static struct tea6420_multiplex TEA6420_line[MXB_AUDIOS+1][2] =
  96                 {
  97                 {{2,3,0},{1,2,0}},
  98                 {{5,3,0},{6,2,0}},
  99                 {{4,3,0},{6,2,0}},
 100                 {{3,3,0},{6,2,0}},
 101                 {{2,3,0},{3,2,0}},
 102                 {{2,3,0},{2,2,0}},
 103                 {{6,3,0},{6,2,0}}       /* Mute */
 104                 };
 105
 106 #define MAXCONTROLS     1
 107 static struct v4l2_queryctrl mxb_controls[] = {
 108         { V4L2_CID_AUDIO_MUTE, V4L2_CTRL_TYPE_BOOLEAN, "Mute", 0, 1, 1, 0, 0 },
 109 };
 110
 111 static struct saa7146_extension_ioctls ioctls[] = {
 112         { VIDIOC_ENUMINPUT,     SAA7146_EXCLUSIVE },
 113         { VIDIOC_G_INPUT,       SAA7146_EXCLUSIVE },
 114         { VIDIOC_S_INPUT,       SAA7146_EXCLUSIVE },
 115         { VIDIOC_QUERYCTRL,     SAA7146_BEFORE },
 116         { VIDIOC_G_CTRL,        SAA7146_BEFORE },
 117         { VIDIOC_S_CTRL,        SAA7146_BEFORE },
 118         { VIDIOC_G_TUNER,       SAA7146_EXCLUSIVE },
 119         { VIDIOC_S_TUNER,       SAA7146_EXCLUSIVE },
 120         { VIDIOC_G_FREQUENCY,   SAA7146_EXCLUSIVE },
 121         { VIDIOC_S_FREQUENCY,   SAA7146_EXCLUSIVE },
 122         { VIDIOC_G_AUDIO,       SAA7146_EXCLUSIVE },
 123         { VIDIOC_S_AUDIO,       SAA7146_EXCLUSIVE },
 124         { MXB_S_AUDIO_CD,       SAA7146_EXCLUSIVE },    /* custom control */
 125         { MXB_S_AUDIO_LINE,     SAA7146_EXCLUSIVE },    /* custom control */
 126         { 0,                    0 }
 127 };
 128
 129 struct mxb
 130 {
 131         struct video_device     *video_dev;
 132         struct video_device     *vbi_dev;
 133
 134         struct i2c_adapter      i2c_adapter;
 135
 136         struct i2c_client*      saa7111a;
 137         struct i2c_client*      tda9840;
 138         struct i2c_client*      tea6415c;
 139         struct i2c_client*      tuner;
 140         struct i2c_client*      tea6420_1;
 141         struct i2c_client*      tea6420_2;
 142
 143         int     cur_mode;       /* current audio mode (mono, stereo, ...) */
 144         int     cur_input;      /* current input */
 145         int     cur_mute;       /* current mute status */
 146         struct v4l2_frequency   cur_freq;       /* current frequency the tuner is tuned to */
 147 };
 148
 149 static struct saa7146_extension extension;
 150
 151 static int mxb_probe(struct saa7146_dev* dev)
 152 {
 153         struct mxb* mxb = NULL;
 154         struct i2c_client *client;
 155         struct list_head *item;
 156         int result;
 157
 158         if ((result = request_module("saa7111")) < 0) {
 159                 printk("mxb: saa7111 i2c module not available.\n");
 160                 return -ENODEV;
 161         }
 162         if ((result = request_module("tuner")) < 0) {
 163                 printk("mxb: tuner i2c module not available.\n");
 164                 return -ENODEV;
 165         }
 166         if ((result = request_module("tea6420")) < 0) {
 167                 printk("mxb: tea6420 i2c module not available.\n");
 168                 return -ENODEV;
 169         }
 170         if ((result = request_module("tea6415c")) < 0) {
 171                 printk("mxb: tea6415c i2c module not available.\n");
 172                 return -ENODEV;
 173         }
 174         if ((result = request_module("tda9840")) < 0) {
 175                 printk("mxb: tda9840 i2c module not available.\n");
 176                 return -ENODEV;
 177         }
 178
 179         mxb = (struct mxb*)kmalloc(sizeof(struct mxb), GFP_KERNEL);
 180         if( NULL == mxb ) {
 181                 DEB_D(("not enough kernel memory.\n"));
 182                 return -ENOMEM;
 183         }
 184         memset(mxb, 0x0, sizeof(struct mxb));
 185
 186         mxb->i2c_adapter = (struct i2c_adapter) {
 187                 .class = I2C_CLASS_TV_ANALOG,
 188                 .name = "mxb",
 189         };
 190
 191         saa7146_i2c_adapter_prepare(dev, &mxb->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
 192         if(i2c_add_adapter(&mxb->i2c_adapter) < 0) {
 193                 DEB_S(("cannot register i2c-device. skipping.\n"));
 194                 kfree(mxb);
 195                 return -EFAULT;
 196         }
 197
 198         /* loop through all i2c-devices on the bus and look who is there */
 199         list_for_each(item,&mxb->i2c_adapter.clients) {
 200                 client = list_entry(item, struct i2c_client, list);
 201                 if( I2C_TEA6420_1 == client->addr )
 202                         mxb->tea6420_1 = client;
 203                 if( I2C_TEA6420_2 == client->addr )
 204                         mxb->tea6420_2 = client;
 205                 if( I2C_TEA6415C_2 == client->addr )
 206                         mxb->tea6415c = client;
 207                 if( I2C_TDA9840 == client->addr )
 208                         mxb->tda9840 = client;
 209                 if( I2C_SAA7111 == client->addr )
 210                         mxb->saa7111a = client;
 211                 if( 0x60 == client->addr )
 212                         mxb->tuner = client;
 213         }
 214
 215         /* check if all devices are present */
 216         if(    0 == mxb->tea6420_1      || 0 == mxb->tea6420_2  || 0 == mxb->tea6415c
 217             || 0 == mxb->tda9840        || 0 == mxb->saa7111a   || 0 == mxb->tuner ) {
 218
 219                 printk("mxb: did not find all i2c devices. aborting\n");
 220                 i2c_del_adapter(&mxb->i2c_adapter);
 221                 kfree(mxb);
 222                 return -ENODEV;
 223         }
 224
 225         /* all devices are present, probe was successful */
 226
 227         /* we store the pointer in our private data field */
 228         dev->ext_priv = mxb;
 229
 230         return 0;
 231 }
 232
 233 /* some init data for the saa7740, the so-called 'sound arena module'.
 234    there are no specs available, so we simply use some init values */
 235 static struct {
 236         int     length;
 237         char    data[9];
 238 } mxb_saa7740_init[] = {
 239         { 3, { 0x80, 0x00, 0x00 } },{ 3, { 0x80, 0x89, 0x00 } },
 240         { 3, { 0x80, 0xb0, 0x0a } },{ 3, { 0x00, 0x00, 0x00 } },
 241         { 3, { 0x49, 0x00, 0x00 } },{ 3, { 0x4a, 0x00, 0x00 } },
 242         { 3, { 0x4b, 0x00, 0x00 } },{ 3, { 0x4c, 0x00, 0x00 } },
 243         { 3, { 0x4d, 0x00, 0x00 } },{ 3, { 0x4e, 0x00, 0x00 } },
 244         { 3, { 0x4f, 0x00, 0x00 } },{ 3, { 0x50, 0x00, 0x00 } },
 245         { 3, { 0x51, 0x00, 0x00 } },{ 3, { 0x52, 0x00, 0x00 } },
 246         { 3, { 0x53, 0x00, 0x00 } },{ 3, { 0x54, 0x00, 0x00 } },
 247         { 3, { 0x55, 0x00, 0x00 } },{ 3, { 0x56, 0x00, 0x00 } },
 248         { 3, { 0x57, 0x00, 0x00 } },{ 3, { 0x58, 0x00, 0x00 } },
 249         { 3, { 0x59, 0x00, 0x00 } },{ 3, { 0x5a, 0x00, 0x00 } },
 250         { 3, { 0x5b, 0x00, 0x00 } },{ 3, { 0x5c, 0x00, 0x00 } },
 251         { 3, { 0x5d, 0x00, 0x00 } },{ 3, { 0x5e, 0x00, 0x00 } },
 252         { 3, { 0x5f, 0x00, 0x00 } },{ 3, { 0x60, 0x00, 0x00 } },
 253         { 3, { 0x61, 0x00, 0x00 } },{ 3, { 0x62, 0x00, 0x00 } },
 254         { 3, { 0x63, 0x00, 0x00 } },{ 3, { 0x64, 0x00, 0x00 } },
 255         { 3, { 0x65, 0x00, 0x00 } },{ 3, { 0x66, 0x00, 0x00 } },
 256         { 3, { 0x67, 0x00, 0x00 } },{ 3, { 0x68, 0x00, 0x00 } },
 257         { 3, { 0x69, 0x00, 0x00 } },{ 3, { 0x6a, 0x00, 0x00 } },
 258         { 3, { 0x6b, 0x00, 0x00 } },{ 3, { 0x6c, 0x00, 0x00 } },
 259         { 3, { 0x6d, 0x00, 0x00 } },{ 3, { 0x6e, 0x00, 0x00 } },
 260         { 3, { 0x6f, 0x00, 0x00 } },{ 3, { 0x70, 0x00, 0x00 } },
 261         { 3, { 0x71, 0x00, 0x00 } },{ 3, { 0x72, 0x00, 0x00 } },
 262         { 3, { 0x73, 0x00, 0x00 } },{ 3, { 0x74, 0x00, 0x00 } },
 263         { 3, { 0x75, 0x00, 0x00 } },{ 3, { 0x76, 0x00, 0x00 } },
 264         { 3, { 0x77, 0x00, 0x00 } },{ 3, { 0x41, 0x00, 0x42 } },
 265         { 3, { 0x42, 0x10, 0x42 } },{ 3, { 0x43, 0x20, 0x42 } },
 266         { 3, { 0x44, 0x30, 0x42 } },{ 3, { 0x45, 0x00, 0x01 } },
 267         { 3, { 0x46, 0x00, 0x01 } },{ 3, { 0x47, 0x00, 0x01 } },
 268         { 3, { 0x48, 0x00, 0x01 } },
 269         { 9, { 0x01, 0x03, 0xc5, 0x5c, 0x7a, 0x85, 0x01, 0x00, 0x54 } },
 270         { 9, { 0x21, 0x03, 0xc5, 0x5c, 0x7a, 0x85, 0x01, 0x00, 0x54 } },
 271         { 9, { 0x09, 0x0b, 0xb4, 0x6b, 0x74, 0x85, 0x95, 0x00, 0x34 } },
 272         { 9, { 0x29, 0x0b, 0xb4, 0x6b, 0x74, 0x85, 0x95, 0x00, 0x34 } },
 273         { 9, { 0x11, 0x17, 0x43, 0x62, 0x68, 0x89, 0xd1, 0xff, 0xb0 } },
 274         { 9, { 0x31, 0x17, 0x43, 0x62, 0x68, 0x89, 0xd1, 0xff, 0xb0 } },
 275         { 9, { 0x19, 0x20, 0x62, 0x51, 0x5a, 0x95, 0x19, 0x01, 0x50 } },
 276         { 9, { 0x39, 0x20, 0x62, 0x51, 0x5a, 0x95, 0x19, 0x01, 0x50 } },
 277         { 9, { 0x05, 0x3e, 0xd2, 0x69, 0x4e, 0x9a, 0x51, 0x00, 0xf0 } },
 278         { 9, { 0x25, 0x3e, 0xd2, 0x69, 0x4e, 0x9a, 0x51, 0x00, 0xf0 } },
 279         { 9, { 0x0d, 0x3d, 0xa1, 0x40, 0x7d, 0x9f, 0x29, 0xfe, 0x14 } },
 280         { 9, { 0x2d, 0x3d, 0xa1, 0x40, 0x7d, 0x9f, 0x29, 0xfe, 0x14 } },
 281         { 9, { 0x15, 0x73, 0xa1, 0x50, 0x5d, 0xa6, 0xf5, 0xfe, 0x38 } },
 282         { 9, { 0x35, 0x73, 0xa1, 0x50, 0x5d, 0xa6, 0xf5, 0xfe, 0x38 } },
 283         { 9, { 0x1d, 0xed, 0xd0, 0x68, 0x29, 0xb4, 0xe1, 0x00, 0xb8 } },
 284         { 9, { 0x3d, 0xed, 0xd0, 0x68, 0x29, 0xb4, 0xe1, 0x00, 0xb8 } },
 285         { 3, { 0x80, 0xb3, 0x0a } },
 286         {-1, { 0} }
 287 };
 288
 289 static const unsigned char mxb_saa7111_init[] = {
 290         0x00, 0x00,       /* 00 - ID byte */
 291         0x01, 0x00,       /* 01 - reserved */
 292
 293         /*front end */
 294         0x02, 0xd8,       /* 02 - FUSE=x, GUDL=x, MODE=x */
 295         0x03, 0x23,       /* 03 - HLNRS=0, VBSL=1, WPOFF=0, HOLDG=0, GAFIX=0, GAI1=256, GAI2=256 */
 296         0x04, 0x00,       /* 04 - GAI1=256 */
 297         0x05, 0x00,       /* 05 - GAI2=256 */
 298
 299         /* decoder */
 300         0x06, 0xf0,       /* 06 - HSB at  xx(50Hz) /  xx(60Hz) pixels after end of last line */
 301         0x07, 0x30,       /* 07 - HSS at  xx(50Hz) /  xx(60Hz) pixels after end of last line */
 302         0x08, 0xa8,       /* 08 - AUFD=x, FSEL=x, EXFIL=x, VTRC=x, HPLL=x, VNOI=x */
 303         0x09, 0x02,       /* 09 - BYPS=x, PREF=x, BPSS=x, VBLB=x, UPTCV=x, APER=x */
 304         0x0a, 0x80,       /* 0a - BRIG=128 */
 305         0x0b, 0x47,       /* 0b - CONT=1.109 */
 306         0x0c, 0x40,       /* 0c - SATN=1.0 */
 307         0x0d, 0x00,       /* 0d - HUE=0 */
 308         0x0e, 0x01,       /* 0e - CDTO=0, CSTD=0, DCCF=0, FCTC=0, CHBW=1 */
 309         0x0f, 0x00,       /* 0f - reserved */
 310         0x10, 0xd0,       /* 10 - OFTS=x, HDEL=x, VRLN=x, YDEL=x */
 311         0x11, 0x8c,       /* 11 - GPSW=x, CM99=x, FECO=x, COMPO=x, OEYC=1, OEHV=1, VIPB=0, COLO=0 */
 312         0x12, 0x80,       /* 12 - xx output control 2 */
 313         0x13, 0x30,       /* 13 - xx output control 3 */
 314         0x14, 0x00,       /* 14 - reserved */
 315         0x15, 0x15,       /* 15 - VBI */
 316         0x16, 0x04,       /* 16 - VBI */
 317         0x17, 0x00,       /* 17 - VBI */
 318 };
 319
 320 /* bring hardware to a sane state. this has to be done, just in case someone
 321    wants to capture from this device before it has been properly initialized.
 322    the capture engine would badly fail, because no valid signal arrives on the
 323    saa7146, thus leading to timeouts and stuff. */
 324 static int mxb_init_done(struct saa7146_dev* dev)
 325 {
 326         struct mxb* mxb = (struct mxb*)dev->ext_priv;
 327         struct video_decoder_init init;
 328         struct i2c_msg msg;
 329         struct tuner_setup tun_setup;
 330
 331         int i = 0, err = 0;
 332         struct  tea6415c_multiplex vm;
 333
 334         /* select video mode in saa7111a */
 335         i = VIDEO_MODE_PAL;
 336         /* fixme: currently pointless: gets overwritten by configuration below */
 337         mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_SET_NORM, &i);
 338
 339         /* write configuration to saa7111a */
 340         init.data = mxb_saa7111_init;
 341         init.len = sizeof(mxb_saa7111_init);
 342         mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_INIT, &init);
 343
 344         /* select tuner-output on saa7111a */
 345         i = 0;
 346         mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_SET_INPUT, &i);
 347
 348         /* enable vbi bypass */
 349         i = 1;
 350         mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_SET_VBI_BYPASS, &i);
 351
 352         /* select a tuner type */
 353         tun_setup.mode_mask = T_ANALOG_TV;
 354         tun_setup.addr = ADDR_UNSET;
 355         tun_setup.type = TUNER_PHILIPS_PAL;
 356         mxb->tuner->driver->command(mxb->tuner,TUNER_SET_TYPE_ADDR, &tun_setup);
 357         /* tune in some frequency on tuner */
 358         mxb->cur_freq.tuner = 0;
 359         mxb->cur_freq.type = V4L2_TUNER_ANALOG_TV;
 360         mxb->cur_freq.frequency = freq;
 361         mxb->tuner->driver->command(mxb->tuner, VIDIOC_S_FREQUENCY,
 362                                         &mxb->cur_freq);
 363
 364         /* mute audio on tea6420s */
 365         mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_line[6][0]);
 366         mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_line[6][1]);
 367         mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_cd[6][0]);
 368         mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_cd[6][1]);
 369
 370         /* switch to tuner-channel on tea6415c*/
 371         vm.out = 17;
 372         vm.in  = 3;
 373         mxb->tea6415c->driver->command(mxb->tea6415c,TEA6415C_SWITCH, &vm);
 374
 375         /* select tuner-output on multicable on tea6415c*/
 376         vm.in  = 3;
 377         vm.out = 13;
 378         mxb->tea6415c->driver->command(mxb->tea6415c,TEA6415C_SWITCH, &vm);
 379
 380         /* the rest for mxb */
 381         mxb->cur_input = 0;
 382         mxb->cur_mute = 1;
 383
 384         mxb->cur_mode = V4L2_TUNER_MODE_STEREO;
 385         mxb->tda9840->driver->command(mxb->tda9840, TDA9840_SWITCH, &mxb->cur_mode);
 386
 387         /* check if the saa7740 (aka 'sound arena module') is present
 388            on the mxb. if so, we must initialize it. due to lack of
 389            informations about the saa7740, the values were reverse
 390            engineered. */
 391         msg.addr = 0x1b;
 392         msg.flags = 0;
 393         msg.len = mxb_saa7740_init[0].length;
 394         msg.buf = &mxb_saa7740_init[0].data[0];
 395
 396         if( 1 == (err = i2c_transfer(&mxb->i2c_adapter, &msg, 1))) {
 397                 /* the sound arena module is a pos, that's probably the reason
 398                    philips refuses to hand out a datasheet for the saa7740...
 399                    it seems to screw up the i2c bus, so we disable fast irq
 400                    based i2c transactions here and rely on the slow and safe
 401                    polling method ... */
 402                 extension.flags &= ~SAA7146_USE_I2C_IRQ;
 403                 for(i = 1;;i++) {
 404                         if( -1 == mxb_saa7740_init[i].length ) {
 405                                 break;
 406                         }
 407
 408                         msg.len = mxb_saa7740_init[i].length;
 409                         msg.buf = &mxb_saa7740_init[i].data[0];
 410                         if( 1 != (err = i2c_transfer(&mxb->i2c_adapter, &msg, 1))) {
 411                                 DEB_D(("failed to initialize 'sound arena module'.\n"));
 412                                 goto err;
 413                         }
 414                 }
 415                 INFO(("'sound arena module' detected.\n"));
 416         }
 417 err:
 418         /* the rest for saa7146: you should definitely set some basic values
 419            for the input-port handling of the saa7146. */
 420
 421         /* ext->saa has been filled by the core driver */
 422
 423         /* some stuff is done via variables */
 424         saa7146_set_hps_source_and_sync(dev, input_port_selection[mxb->cur_input].hps_source, input_port_selection[mxb->cur_input].hps_sync);
 425
 426         /* some stuff is done via direct write to the registers */
 427
 428         /* this is ugly, but because of the fact that this is completely
 429            hardware dependend, it should be done directly... */
 430         saa7146_write(dev, DD1_STREAM_B,        0x00000000);
 431         saa7146_write(dev, DD1_INIT,            0x02000200);
 432         saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
 433
 434         return 0;
 435 }
 436
 437 /* interrupt-handler. this gets called when irq_mask is != 0.
 438    it must clear the interrupt-bits in irq_mask it has handled */
 439 /*
 440 void mxb_irq_bh(struct saa7146_dev* dev, u32* irq_mask)
 441 {
 442         struct mxb* mxb = (struct mxb*)dev->ext_priv;
 443 }
 444 */
 445
 446 static struct saa7146_ext_vv vv_data;
 447
 448 /* this function only gets called when the probing was successful */
 449 static int mxb_attach(struct saa7146_dev* dev, struct saa7146_pci_extension_data *info)
 450 {
 451         struct mxb* mxb = (struct mxb*)dev->ext_priv;
 452
 453         DEB_EE(("dev:%p\n",dev));
 454
 455         /* checking for i2c-devices can be omitted here, because we
 456            already did this in "mxb_vl42_probe" */
 457
 458         saa7146_vv_init(dev,&vv_data);
 459         if( 0 != saa7146_register_device(&mxb->video_dev, dev, "mxb", VFL_TYPE_GRABBER)) {
 460                 ERR(("cannot register capture v4l2 device. skipping.\n"));
 461                 return -1;
 462         }
 463
 464         /* initialization stuff (vbi) (only for revision > 0 and for extensions which want it)*/
 465         if( 0 != MXB_BOARD_CAN_DO_VBI(dev)) {
 466                 if( 0 != saa7146_register_device(&mxb->vbi_dev, dev, "mxb", VFL_TYPE_VBI)) {
 467                         ERR(("cannot register vbi v4l2 device. skipping.\n"));
 468                 }
 469         }
 470
 471         i2c_use_client(mxb->tea6420_1);
 472         i2c_use_client(mxb->tea6420_2);
 473         i2c_use_client(mxb->tea6415c);
 474         i2c_use_client(mxb->tda9840);
 475         i2c_use_client(mxb->saa7111a);
 476         i2c_use_client(mxb->tuner);
 477
 478         printk("mxb: found 'Multimedia eXtension Board'-%d.\n",mxb_num);
 479
 480         mxb_num++;
 481         mxb_init_done(dev);
 482         return 0;
 483 }
 484
 485 static int mxb_detach(struct saa7146_dev* dev)
 486 {
 487         struct mxb* mxb = (struct mxb*)dev->ext_priv;
 488
 489         DEB_EE(("dev:%p\n",dev));
 490
 491         i2c_release_client(mxb->tea6420_1);
 492         i2c_release_client(mxb->tea6420_2);
 493         i2c_release_client(mxb->tea6415c);
 494         i2c_release_client(mxb->tda9840);
 495         i2c_release_client(mxb->saa7111a);
 496         i2c_release_client(mxb->tuner);
 497
 498         saa7146_unregister_device(&mxb->video_dev,dev);
 499         if( 0 != MXB_BOARD_CAN_DO_VBI(dev)) {
 500                 saa7146_unregister_device(&mxb->vbi_dev,dev);
 501         }
 502         saa7146_vv_release(dev);
 503
 504         mxb_num--;
 505
 506         i2c_del_adapter(&mxb->i2c_adapter);
 507         kfree(mxb);
 508
 509         return 0;
 510 }
 511
 512 static int mxb_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
 513 {
 514         struct saa7146_dev *dev = fh->dev;
 515         struct mxb* mxb = (struct mxb*)dev->ext_priv;
 516         struct saa7146_vv *vv = dev->vv_data;
 517
 518         switch(cmd) {
 519         case VIDIOC_ENUMINPUT:
 520         {
 521                 struct v4l2_input *i = arg;
 522
 523                 DEB_EE(("VIDIOC_ENUMINPUT %d.\n",i->index));
 524                 if( i->index < 0 || i->index >= MXB_INPUTS) {
 525                         return -EINVAL;
 526                 }
 527                 memcpy(i, &mxb_inputs[i->index], sizeof(struct v4l2_input));
 528
 529                 return 0;
 530         }
 531         /* the saa7146 provides some controls (brightness, contrast, saturation)
 532            which gets registered *after* this function. because of this we have
 533            to return with a value != 0 even if the function succeded.. */
 534         case VIDIOC_QUERYCTRL:
 535         {
 536                 struct v4l2_queryctrl *qc = arg;
 537                 int i;
 538
 539                 for (i = MAXCONTROLS - 1; i >= 0; i--) {
 540                         if (mxb_controls[i].id == qc->id) {
 541                                 *qc = mxb_controls[i];
 542                                 DEB_D(("VIDIOC_QUERYCTRL %d.\n",qc->id));
 543                                 return 0;
 544                         }
 545                 }
 546                 return -EAGAIN;
 547         }
 548         case VIDIOC_G_CTRL:
 549         {
 550                 struct v4l2_control *vc = arg;
 551                 int i;
 552
 553                 for (i = MAXCONTROLS - 1; i >= 0; i--) {
 554                         if (mxb_controls[i].id == vc->id) {
 555                                 break;
 556                         }
 557                 }
 558
 559                 if( i < 0 ) {
 560                         return -EAGAIN;
 561                 }
 562
 563                 switch (vc->id ) {
 564                         case V4L2_CID_AUDIO_MUTE: {
 565                                 vc->value = mxb->cur_mute;
 566                                 DEB_D(("VIDIOC_G_CTRL V4L2_CID_AUDIO_MUTE:%d.\n",vc->value));
 567                                 return 0;
 568                         }
 569                 }
 570
 571                 DEB_EE(("VIDIOC_G_CTRL V4L2_CID_AUDIO_MUTE:%d.\n",vc->value));
 572                 return 0;
 573         }
 574
 575         case VIDIOC_S_CTRL:
 576         {
 577                 struct  v4l2_control    *vc = arg;
 578                 int i = 0;
 579
 580                 for (i = MAXCONTROLS - 1; i >= 0; i--) {
 581                         if (mxb_controls[i].id == vc->id) {
 582                                 break;
 583                         }
 584                 }
 585
 586                 if( i < 0 ) {
 587                         return -EAGAIN;
 588                 }
 589
 590                 switch (vc->id ) {
 591                         case V4L2_CID_AUDIO_MUTE: {
 592                                 mxb->cur_mute = vc->value;
 593                                 if( 0 == vc->value ) {
 594                                         /* switch the audio-source */
 595                                         mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_line[video_audio_connect[mxb->cur_input]][0]);
 596                                         mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_line[video_audio_connect[mxb->cur_input]][1]);
 597                                 } else {
 598                                         mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_line[6][0]);
 599                                         mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_line[6][1]);
 600                                 }
 601                                 DEB_EE(("VIDIOC_S_CTRL, V4L2_CID_AUDIO_MUTE: %d.\n",vc->value));
 602                                 break;
 603                         }
 604                 }
 605                 return 0;
 606         }
 607         case VIDIOC_G_INPUT:
 608         {
 609                 int *input = (int *)arg;
 610                 *input = mxb->cur_input;
 611
 612                 DEB_EE(("VIDIOC_G_INPUT %d.\n",*input));
 613                 return 0;
 614         }
 615         case VIDIOC_S_INPUT:
 616         {
 617                 int input = *(int *)arg;
 618                 struct  tea6415c_multiplex vm;
 619                 int i = 0;
 620
 621                 DEB_EE(("VIDIOC_S_INPUT %d.\n",input));
 622
 623                 if (input < 0 || input >= MXB_INPUTS) {
 624                         return -EINVAL;
 625                 }
 626
 627                 /* fixme: locke das setzen des inputs mit hilfe des mutexes
 628                 down(&dev->lock);
 629                 video_mux(dev,*i);
 630                 up(&dev->lock);
 631                 */
 632
 633                 /* fixme: check if streaming capture
 634                 if ( 0 != dev->streaming ) {
 635                         DEB_D(("VIDIOC_S_INPUT illegal while streaming.\n"));
 636                         return -EPERM;
 637                 }
 638                 */
 639
 640                 mxb->cur_input = input;
 641
 642                 saa7146_set_hps_source_and_sync(dev, input_port_selection[input].hps_source, input_port_selection[input].hps_sync);
 643
 644                 /* prepare switching of tea6415c and saa7111a;
 645                    have a look at the 'background'-file for further informations  */
 646                 switch( input ) {
 647
 648                         case TUNER:
 649                         {
 650                                 i = 0;
 651                                 vm.in  = 3;
 652                                 vm.out = 17;
 653
 654                         if ( 0 != mxb->tea6415c->driver->command(mxb->tea6415c,TEA6415C_SWITCH, &vm)) {
 655                                         printk("VIDIOC_S_INPUT: could not address tea6415c #1\n");
 656                                         return -EFAULT;
 657                                 }
 658                                 /* connect tuner-output always to multicable */
 659                                 vm.in  = 3;
 660                                 vm.out = 13;
 661                                 break;
 662                         }
 663                         case AUX3_YC:
 664                         {
 665                                 /* nothing to be done here. aux3_yc is
 666                                    directly connected to the saa711a */
 667                                 i = 5;
 668                                 break;
 669                         }
 670                         case AUX3:
 671                         {
 672                                 /* nothing to be done here. aux3 is
 673                                    directly connected to the saa711a */
 674                                 i = 1;
 675                                 break;
 676                         }
 677                         case AUX1:
 678                         {
 679                                 i = 0;
 680                                 vm.in  = 1;
 681                                 vm.out = 17;
 682                                 break;
 683                         }
 684                 }
 685
 686                 /* switch video in tea6415c only if necessary */
 687                 switch( input ) {
 688                         case TUNER:
 689                         case AUX1:
 690                         {
 691                                 if ( 0 != mxb->tea6415c->driver->command(mxb->tea6415c,TEA6415C_SWITCH, &vm)) {
 692                                         printk("VIDIOC_S_INPUT: could not address tea6415c #3\n");
 693                                         return -EFAULT;
 694                                 }
 695                                 break;
 696                         }
 697                         default:
 698                         {
 699                                 break;
 700                         }
 701                 }
 702
 703                 /* switch video in saa7111a */
 704                 if ( 0 != mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_SET_INPUT, &i)) {
 705                         printk("VIDIOC_S_INPUT: could not address saa7111a #1.\n");
 706                 }
 707
 708                 /* switch the audio-source only if necessary */
 709                 if( 0 == mxb->cur_mute ) {
 710                         mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_line[video_audio_connect[input]][0]);
 711                         mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_line[video_audio_connect[input]][1]);
 712                 }
 713
 714                 return 0;
 715         }
 716         case VIDIOC_G_TUNER:
 717         {
 718                 struct v4l2_tuner *t = arg;
 719                 int byte = 0;
 720
 721                 if( 0 != t->index ) {
 722                         DEB_D(("VIDIOC_G_TUNER: channel %d does not have a tuner attached.\n", t->index));
 723                         return -EINVAL;
 724                 }
 725
 726                 DEB_EE(("VIDIOC_G_TUNER: %d\n", t->index));
 727
 728                 memset(t,0,sizeof(*t));
 729                 strcpy(t->name, "Television");
 730
 731                 t->type = V4L2_TUNER_ANALOG_TV;
 732                 t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
 733                 t->rangelow = 772;      /* 48.25 MHZ / 62.5 kHz = 772, see fi1216mk2-specs, page 2 */
 734                 t->rangehigh = 13684;   /* 855.25 MHz / 62.5 kHz = 13684 */
 735                 /* FIXME: add the real signal strength here */
 736                 t->signal = 0xffff;
 737                 t->afc = 0;
 738
 739                 mxb->tda9840->driver->command(mxb->tda9840,TDA9840_DETECT, &byte);
 740                 t->audmode = mxb->cur_mode;
 741
 742                 if( byte < 0 ) {
 743                         t->rxsubchans  = V4L2_TUNER_SUB_MONO;
 744                 } else {
 745                         switch(byte) {
 746                                 case TDA9840_MONO_DETECT: {
 747                                         t->rxsubchans   = V4L2_TUNER_SUB_MONO;
 748                                         DEB_D(("VIDIOC_G_TUNER: V4L2_TUNER_MODE_MONO.\n"));
 749                                         break;
 750                                 }
 751                                 case TDA9840_DUAL_DETECT: {
 752                                         t->rxsubchans   = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
 753                                         DEB_D(("VIDIOC_G_TUNER: V4L2_TUNER_MODE_LANG1.\n"));
 754                                         break;
 755                                 }
 756                                 case TDA9840_STEREO_DETECT: {
 757                                         t->rxsubchans   = V4L2_TUNER_SUB_STEREO | V4L2_TUNER_SUB_MONO;
 758                                         DEB_D(("VIDIOC_G_TUNER: V4L2_TUNER_MODE_STEREO.\n"));
 759                                         break;
 760                                 }
 761                                 default: { /* TDA9840_INCORRECT_DETECT */
 762                                         t->rxsubchans   = V4L2_TUNER_MODE_MONO;
 763                                         DEB_D(("VIDIOC_G_TUNER: TDA9840_INCORRECT_DETECT => V4L2_TUNER_MODE_MONO\n"));
 764                                         break;
 765                                 }
 766                         }
 767                 }
 768
 769                 return 0;
 770         }
 771         case VIDIOC_S_TUNER:
 772         {
 773                 struct v4l2_tuner *t = arg;
 774                 int result = 0;
 775                 int byte = 0;
 776
 777                 if( 0 != t->index ) {
 778                         DEB_D(("VIDIOC_S_TUNER: channel %d does not have a tuner attached.\n",t->index));
 779                         return -EINVAL;
 780                 }
 781
 782                 switch(t->audmode) {
 783                         case V4L2_TUNER_MODE_STEREO: {
 784                                 mxb->cur_mode = V4L2_TUNER_MODE_STEREO;
 785                                 byte = TDA9840_SET_STEREO;
 786                                 DEB_D(("VIDIOC_S_TUNER: V4L2_TUNER_MODE_STEREO\n"));
 787                                 break;
 788                         }
 789                         case V4L2_TUNER_MODE_LANG1: {
 790                                 mxb->cur_mode = V4L2_TUNER_MODE_LANG1;
 791                                 byte = TDA9840_SET_LANG1;
 792                                 DEB_D(("VIDIOC_S_TUNER: V4L2_TUNER_MODE_LANG1\n"));
 793                                 break;
 794                         }
 795                         case V4L2_TUNER_MODE_LANG2: {
 796                                 mxb->cur_mode = V4L2_TUNER_MODE_LANG2;
 797                                 byte = TDA9840_SET_LANG2;
 798                                 DEB_D(("VIDIOC_S_TUNER: V4L2_TUNER_MODE_LANG2\n"));
 799                                 break;
 800                         }
 801                         default: { /* case V4L2_TUNER_MODE_MONO: {*/
 802                                 mxb->cur_mode = V4L2_TUNER_MODE_MONO;
 803                                 byte = TDA9840_SET_MONO;
 804                                 DEB_D(("VIDIOC_S_TUNER: TDA9840_SET_MONO\n"));
 805                                 break;
 806                         }
 807                 }
 808
 809                 if( 0 != (result = mxb->tda9840->driver->command(mxb->tda9840, TDA9840_SWITCH, &byte))) {
 810                         printk("VIDIOC_S_TUNER error. result:%d, byte:%d\n",result,byte);
 811                 }
 812
 813                 return 0;
 814         }
 815         case VIDIOC_G_FREQUENCY:
 816         {
 817                 struct v4l2_frequency *f = arg;
 818
 819                 if(0 != mxb->cur_input) {
 820                         DEB_D(("VIDIOC_G_FREQ: channel %d does not have a tuner!\n",mxb->cur_input));
 821                         return -EINVAL;
 822                 }
 823
 824                 *f = mxb->cur_freq;
 825
 826                 DEB_EE(("VIDIOC_G_FREQ: freq:0x%08x.\n", mxb->cur_freq.frequency));
 827                 return 0;
 828         }
 829         case VIDIOC_S_FREQUENCY:
 830         {
 831                 struct v4l2_frequency *f = arg;
 832
 833                 if (0 != f->tuner)
 834                         return -EINVAL;
 835
 836                 if (V4L2_TUNER_ANALOG_TV != f->type)
 837                         return -EINVAL;
 838
 839                 if(0 != mxb->cur_input) {
 840                         DEB_D(("VIDIOC_S_FREQ: channel %d does not have a tuner!\n",mxb->cur_input));
 841                         return -EINVAL;
 842                 }
 843
 844                 mxb->cur_freq = *f;
 845                 DEB_EE(("VIDIOC_S_FREQUENCY: freq:0x%08x.\n", mxb->cur_freq.frequency));
 846
 847                 /* tune in desired frequency */
 848                 mxb->tuner->driver->command(mxb->tuner, VIDIOC_S_FREQUENCY, &mxb->cur_freq);
 849
 850                 /* hack: changing the frequency should invalidate the vbi-counter (=> alevt) */
 851                 spin_lock(&dev->slock);
 852                 vv->vbi_fieldcount = 0;
 853                 spin_unlock(&dev->slock);
 854
 855                 return 0;
 856         }
 857         case MXB_S_AUDIO_CD:
 858         {
 859                 int i = *(int*)arg;
 860
 861                 if( i < 0 || i >= MXB_AUDIOS ) {
 862                         DEB_D(("illegal argument to MXB_S_AUDIO_CD: i:%d.\n",i));
 863                         return -EINVAL;
 864                 }
 865
 866                 DEB_EE(("MXB_S_AUDIO_CD: i:%d.\n",i));
 867
 868                 mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_cd[i][0]);
 869                 mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_cd[i][1]);
 870
 871                 return 0;
 872         }
 873         case MXB_S_AUDIO_LINE:
 874         {
 875                 int i = *(int*)arg;
 876
 877                 if( i < 0 || i >= MXB_AUDIOS ) {
 878                         DEB_D(("illegal argument to MXB_S_AUDIO_LINE: i:%d.\n",i));
 879                         return -EINVAL;
 880                 }
 881
 882                 DEB_EE(("MXB_S_AUDIO_LINE: i:%d.\n",i));
 883                 mxb->tea6420_1->driver->command(mxb->tea6420_1,TEA6420_SWITCH, &TEA6420_line[i][0]);
 884                 mxb->tea6420_2->driver->command(mxb->tea6420_2,TEA6420_SWITCH, &TEA6420_line[i][1]);
 885
 886                 return 0;
 887         }
 888         case VIDIOC_G_AUDIO:
 889         {
 890                 struct v4l2_audio *a = arg;
 891
 892                 if( a->index < 0 || a->index > MXB_INPUTS ) {
 893                         DEB_D(("VIDIOC_G_AUDIO %d out of range.\n",a->index));
 894                         return -EINVAL;
 895                 }
 896
 897                 DEB_EE(("VIDIOC_G_AUDIO %d.\n",a->index));
 898                 memcpy(a, &mxb_audios[video_audio_connect[mxb->cur_input]], sizeof(struct v4l2_audio));
 899
 900                 return 0;
 901         }
 902         case VIDIOC_S_AUDIO:
 903         {
 904                 struct v4l2_audio *a = arg;
 905                 DEB_D(("VIDIOC_S_AUDIO %d.\n",a->index));
 906                 return 0;
 907         }
 908         default:
 909 /*
 910                 DEB2(printk("does not handle this ioctl.\n"));
 911 */
 912                 return -ENOIOCTLCMD;
 913         }
 914         return 0;
 915 }
 916
 917 static int std_callback(struct saa7146_dev* dev, struct saa7146_standard *std)
 918 {
 919         struct mxb* mxb = (struct mxb*)dev->ext_priv;
 920         int zero = 0;
 921         int one = 1;
 922
 923         if(V4L2_STD_PAL_I == std->id ) {
 924                 DEB_D(("VIDIOC_S_STD: setting mxb for PAL_I.\n"));
 925                 /* set the 7146 gpio register -- I don't know what this does exactly */
 926                 saa7146_write(dev, GPIO_CTRL, 0x00404050);
 927                 /* unset the 7111 gpio register -- I don't know what this does exactly */
 928                 mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_SET_GPIO, &zero);
 929         } else {
 930                 DEB_D(("VIDIOC_S_STD: setting mxb for PAL/NTSC/SECAM.\n"));
 931                 /* set the 7146 gpio register -- I don't know what this does exactly */
 932                 saa7146_write(dev, GPIO_CTRL, 0x00404050);
 933                 /* set the 7111 gpio register -- I don't know what this does exactly */
 934                 mxb->saa7111a->driver->command(mxb->saa7111a,DECODER_SET_GPIO, &one);
 935         }
 936         return 0;
 937 }
 938
 939 static struct saa7146_standard standard[] = {
 940         {
 941                 .name   = "PAL-BG",     .id     = V4L2_STD_PAL_BG,
 942                 .v_offset       = 0x17, .v_field        = 288,
 943                 .h_offset       = 0x14, .h_pixels       = 680,
 944                 .v_max_out      = 576,  .h_max_out      = 768,
 945         }, {
 946                 .name   = "PAL-I",      .id     = V4L2_STD_PAL_I,
 947                 .v_offset       = 0x17, .v_field        = 288,
 948                 .h_offset       = 0x14, .h_pixels       = 680,
 949                 .v_max_out      = 576,  .h_max_out      = 768,
 950         }, {
 951                 .name   = "NTSC",       .id     = V4L2_STD_NTSC,
 952                 .v_offset       = 0x16, .v_field        = 240,
 953                 .h_offset       = 0x06, .h_pixels       = 708,
 954                 .v_max_out      = 480,  .h_max_out      = 640,
 955         }, {
 956                 .name   = "SECAM",      .id     = V4L2_STD_SECAM,
 957                 .v_offset       = 0x14, .v_field        = 288,
 958                 .h_offset       = 0x14, .h_pixels       = 720,
 959                 .v_max_out      = 576,  .h_max_out      = 768,
 960         }
 961 };
 962
 963 static struct saa7146_pci_extension_data mxb = {
 964         .ext_priv = "Multimedia eXtension Board",
 965         .ext = &extension,
 966 };
 967
 968 static struct pci_device_id pci_tbl[] = {
 969         {
 970                 .vendor    = PCI_VENDOR_ID_PHILIPS,
 971                 .device    = PCI_DEVICE_ID_PHILIPS_SAA7146,
 972                 .subvendor = 0x0000,
 973                 .subdevice = 0x0000,
 974                 .driver_data = (unsigned long)&mxb,
 975         }, {
 976                 .vendor = 0,
 977         }
 978 };
 979
 980 MODULE_DEVICE_TABLE(pci, pci_tbl);
 981
 982 static struct saa7146_ext_vv vv_data = {
 983         .inputs         = MXB_INPUTS,
 984         .capabilities   = V4L2_CAP_TUNER | V4L2_CAP_VBI_CAPTURE,
 985         .stds           = &standard[0],
 986         .num_stds       = sizeof(standard)/sizeof(struct saa7146_standard),
 987         .std_callback   = &std_callback,
 988         .ioctls         = &ioctls[0],
 989         .ioctl          = mxb_ioctl,
 990 };
 991
 992 static struct saa7146_extension extension = {
 993         .name           = MXB_IDENTIFIER,
 994         .flags          = SAA7146_USE_I2C_IRQ,
 995
 996         .pci_tbl        = &pci_tbl[0],
 997         .module         = THIS_MODULE,
 998
 999         .probe          = mxb_probe,
1000         .attach         = mxb_attach,
1001         .detach         = mxb_detach,
1002
1003         .irq_mask       = 0,
1004         .irq_func       = NULL,
1005 };
1006
1007 static int __init mxb_init_module(void)
1008 {
1009         if( 0 != saa7146_register_extension(&extension)) {
1010                 DEB_S(("failed to register extension.\n"));
1011                 return -ENODEV;
1012         }
1013
1014         return 0;
1015 }
1016
1017 static void __exit mxb_cleanup_module(void)
1018 {
1019         saa7146_unregister_extension(&extension);
1020 }
1021
1022 module_init(mxb_init_module);
1023 module_exit(mxb_cleanup_module);
1024
1025 MODULE_DESCRIPTION("video4linux-2 driver for the Siemens-Nixdorf 'Multimedia eXtension board'");
1026 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
1027 MODULE_LICENSE("GPL");