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