SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/mxb.c

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