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