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