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