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