git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/dpc7146.c

   1 /*
   2     dpc7146.c - v4l2 driver for the dpc7146 demonstration board
   3
   4     Copyright (C) 2000-2003 Michael Hunold <michael@mihu.de>
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #define DEBUG_VARIABLE debug
  22
  23 #include <media/saa7146_vv.h>
  24 #include <linux/video_decoder.h>        /* for saa7111a */
  25
  26 #define I2C_SAA7111A            0x24
  27
  28 /* All unused bytes are reserverd. */
  29 #define SAA711X_CHIP_VERSION            0x00
  30 #define SAA711X_ANALOG_INPUT_CONTROL_1  0x02
  31 #define SAA711X_ANALOG_INPUT_CONTROL_2  0x03
  32 #define SAA711X_ANALOG_INPUT_CONTROL_3  0x04
  33 #define SAA711X_ANALOG_INPUT_CONTROL_4  0x05
  34 #define SAA711X_HORIZONTAL_SYNC_START   0x06
  35 #define SAA711X_HORIZONTAL_SYNC_STOP    0x07
  36 #define SAA711X_SYNC_CONTROL            0x08
  37 #define SAA711X_LUMINANCE_CONTROL       0x09
  38 #define SAA711X_LUMINANCE_BRIGHTNESS    0x0A
  39 #define SAA711X_LUMINANCE_CONTRAST      0x0B
  40 #define SAA711X_CHROMA_SATURATION       0x0C
  41 #define SAA711X_CHROMA_HUE_CONTROL      0x0D
  42 #define SAA711X_CHROMA_CONTROL          0x0E
  43 #define SAA711X_FORMAT_DELAY_CONTROL    0x10
  44 #define SAA711X_OUTPUT_CONTROL_1        0x11
  45 #define SAA711X_OUTPUT_CONTROL_2        0x12
  46 #define SAA711X_OUTPUT_CONTROL_3        0x13
  47 #define SAA711X_V_GATE_1_START          0x15
  48 #define SAA711X_V_GATE_1_STOP           0x16
  49 #define SAA711X_V_GATE_1_MSB            0x17
  50 #define SAA711X_TEXT_SLICER_STATUS      0x1A
  51 #define SAA711X_DECODED_BYTES_OF_TS_1   0x1B
  52 #define SAA711X_DECODED_BYTES_OF_TS_2   0x1C
  53 #define SAA711X_STATUS_BYTE             0x1F
  54
  55 #define DPC_BOARD_CAN_DO_VBI(dev)   (dev->revision != 0)
  56
  57 static int debug = 0;
  58 module_param(debug, int, 0);
  59 MODULE_PARM_DESC(debug, "debug verbosity");
  60
  61 static int dpc_num = 0;
  62
  63 #define DPC_INPUTS      2
  64 static struct v4l2_input dpc_inputs[DPC_INPUTS] = {
  65         { 0, "Port A",  V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  66         { 1, "Port B",  V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  67 };
  68
  69 #define DPC_AUDIOS      0
  70
  71 static struct saa7146_extension_ioctls ioctls[] = {
  72         { VIDIOC_G_INPUT,       SAA7146_EXCLUSIVE },
  73         { VIDIOC_S_INPUT,       SAA7146_EXCLUSIVE },
  74         { VIDIOC_ENUMINPUT,     SAA7146_EXCLUSIVE },
  75         { VIDIOC_S_STD,         SAA7146_AFTER },
  76         { 0,                    0 }
  77 };
  78
  79 struct dpc
  80 {
  81         struct video_device     *video_dev;
  82         struct video_device     *vbi_dev;
  83
  84         struct i2c_adapter      i2c_adapter;
  85         struct i2c_client       *saa7111a;
  86
  87         int cur_input;  /* current input */
  88 };
  89
  90 static int dpc_check_clients(struct device *dev, void *data)
  91 {
  92         struct dpc* dpc = data;
  93         struct i2c_client *client = i2c_verify_client(dev);
  94
  95         if( !client )
  96                 return 0;
  97
  98         if( I2C_SAA7111A == client->addr )
  99                 dpc->saa7111a = client;
 100
 101         return 0;
 102 }
 103
 104 /* fixme: add vbi stuff here */
 105 static int dpc_probe(struct saa7146_dev* dev)
 106 {
 107         struct dpc* dpc = NULL;
 108
 109         dpc = kzalloc(sizeof(struct dpc), GFP_KERNEL);
 110         if( NULL == dpc ) {
 111                 printk("dpc_v4l2.o: dpc_probe: not enough kernel memory.\n");
 112                 return -ENOMEM;
 113         }
 114
 115         /* FIXME: enable i2c-port pins, video-port-pins
 116            video port pins should be enabled here ?! */
 117         saa7146_write(dev, MC1, (MASK_08 | MASK_24 | MASK_10 | MASK_26));
 118
 119         dpc->i2c_adapter = (struct i2c_adapter) {
 120                 .class = I2C_CLASS_TV_ANALOG,
 121                 .name = "dpc7146",
 122         };
 123         saa7146_i2c_adapter_prepare(dev, &dpc->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
 124         if(i2c_add_adapter(&dpc->i2c_adapter) < 0) {
 125                 DEB_S(("cannot register i2c-device. skipping.\n"));
 126                 kfree(dpc);
 127                 return -EFAULT;
 128         }
 129
 130         /* loop through all i2c-devices on the bus and look who is there */
 131         device_for_each_child(&dpc->i2c_adapter.dev, dpc, dpc_check_clients);
 132
 133         /* check if all devices are present */
 134         if (!dpc->saa7111a) {
 135                 DEB_D(("dpc_v4l2.o: dpc_attach failed for this device.\n"));
 136                 i2c_del_adapter(&dpc->i2c_adapter);
 137                 kfree(dpc);
 138                 return -ENODEV;
 139         }
 140
 141         /* all devices are present, probe was successful */
 142         DEB_D(("dpc_v4l2.o: dpc_probe succeeded for this device.\n"));
 143
 144         /* we store the pointer in our private data field */
 145         dev->ext_priv = dpc;
 146
 147         return 0;
 148 }
 149
 150 /* bring hardware to a sane state. this has to be done, just in case someone
 151    wants to capture from this device before it has been properly initialized.
 152    the capture engine would badly fail, because no valid signal arrives on the
 153    saa7146, thus leading to timeouts and stuff. */
 154 static int dpc_init_done(struct saa7146_dev* dev)
 155 {
 156         struct dpc* dpc = (struct dpc*)dev->ext_priv;
 157
 158         DEB_D(("dpc_v4l2.o: dpc_init_done called.\n"));
 159
 160         /* initialize the helper ics to useful values */
 161         i2c_smbus_write_byte_data(dpc->saa7111a, 0x00, 0x11);
 162
 163         i2c_smbus_write_byte_data(dpc->saa7111a, 0x02, 0xc0);
 164         i2c_smbus_write_byte_data(dpc->saa7111a, 0x03, 0x30);
 165         i2c_smbus_write_byte_data(dpc->saa7111a, 0x04, 0x00);
 166         i2c_smbus_write_byte_data(dpc->saa7111a, 0x05, 0x00);
 167         i2c_smbus_write_byte_data(dpc->saa7111a, 0x06, 0xde);
 168         i2c_smbus_write_byte_data(dpc->saa7111a, 0x07, 0xad);
 169         i2c_smbus_write_byte_data(dpc->saa7111a, 0x08, 0xa8);
 170         i2c_smbus_write_byte_data(dpc->saa7111a, 0x09, 0x00);
 171         i2c_smbus_write_byte_data(dpc->saa7111a, 0x0a, 0x80);
 172         i2c_smbus_write_byte_data(dpc->saa7111a, 0x0b, 0x47);
 173         i2c_smbus_write_byte_data(dpc->saa7111a, 0x0c, 0x40);
 174         i2c_smbus_write_byte_data(dpc->saa7111a, 0x0d, 0x00);
 175         i2c_smbus_write_byte_data(dpc->saa7111a, 0x0e, 0x03);
 176
 177         i2c_smbus_write_byte_data(dpc->saa7111a, 0x10, 0xd0);
 178         i2c_smbus_write_byte_data(dpc->saa7111a, 0x11, 0x1c);
 179         i2c_smbus_write_byte_data(dpc->saa7111a, 0x12, 0xc1);
 180         i2c_smbus_write_byte_data(dpc->saa7111a, 0x13, 0x30);
 181
 182         i2c_smbus_write_byte_data(dpc->saa7111a, 0x1f, 0x81);
 183
 184         return 0;
 185 }
 186
 187 static struct saa7146_ext_vv vv_data;
 188
 189 /* this function only gets called when the probing was successful */
 190 static int dpc_attach(struct saa7146_dev* dev, struct saa7146_pci_extension_data *info)
 191 {
 192         struct dpc* dpc = (struct dpc*)dev->ext_priv;
 193
 194         DEB_D(("dpc_v4l2.o: dpc_attach called.\n"));
 195
 196         /* checking for i2c-devices can be omitted here, because we
 197            already did this in "dpc_vl42_probe" */
 198
 199         saa7146_vv_init(dev,&vv_data);
 200         if( 0 != saa7146_register_device(&dpc->video_dev, dev, "dpc", VFL_TYPE_GRABBER)) {
 201                 ERR(("cannot register capture v4l2 device. skipping.\n"));
 202                 return -1;
 203         }
 204
 205         /* initialization stuff (vbi) (only for revision > 0 and for extensions which want it)*/
 206         if( 0 != DPC_BOARD_CAN_DO_VBI(dev)) {
 207                 if( 0 != saa7146_register_device(&dpc->vbi_dev, dev, "dpc", VFL_TYPE_VBI)) {
 208                         ERR(("cannot register vbi v4l2 device. skipping.\n"));
 209                 }
 210         }
 211
 212         i2c_use_client(dpc->saa7111a);
 213
 214         printk("dpc: found 'dpc7146 demonstration board'-%d.\n",dpc_num);
 215         dpc_num++;
 216
 217         /* the rest */
 218         dpc->cur_input = 0;
 219         dpc_init_done(dev);
 220
 221         return 0;
 222 }
 223
 224 static int dpc_detach(struct saa7146_dev* dev)
 225 {
 226         struct dpc* dpc = (struct dpc*)dev->ext_priv;
 227
 228         DEB_EE(("dev:%p\n",dev));
 229
 230         i2c_release_client(dpc->saa7111a);
 231
 232         saa7146_unregister_device(&dpc->video_dev,dev);
 233         if( 0 != DPC_BOARD_CAN_DO_VBI(dev)) {
 234                 saa7146_unregister_device(&dpc->vbi_dev,dev);
 235         }
 236         saa7146_vv_release(dev);
 237
 238         dpc_num--;
 239
 240         i2c_del_adapter(&dpc->i2c_adapter);
 241         kfree(dpc);
 242         return 0;
 243 }
 244
 245 #ifdef axa
 246 int dpc_vbi_bypass(struct saa7146_dev* dev)
 247 {
 248         struct dpc* dpc = (struct dpc*)dev->ext_priv;
 249
 250         int i = 1;
 251
 252         /* switch bypass in saa7111a */
 253         if ( 0 != dpc->saa7111a->driver->command(dpc->saa7111a,SAA711X_VBI_BYPASS, &i)) {
 254                 printk("dpc_v4l2.o: VBI_BYPASS: could not address saa7111a.\n");
 255                 return -1;
 256         }
 257
 258         return 0;
 259 }
 260 #endif
 261
 262 static int dpc_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
 263 {
 264         struct saa7146_dev *dev = fh->dev;
 265         struct dpc* dpc = (struct dpc*)dev->ext_priv;
 266 /*
 267         struct saa7146_vv *vv = dev->vv_data;
 268 */
 269         switch(cmd)
 270         {
 271         case VIDIOC_ENUMINPUT:
 272         {
 273                 struct v4l2_input *i = arg;
 274                 DEB_EE(("VIDIOC_ENUMINPUT %d.\n",i->index));
 275
 276                 if( i->index < 0 || i->index >= DPC_INPUTS) {
 277                         return -EINVAL;
 278                 }
 279
 280                 memcpy(i, &dpc_inputs[i->index], sizeof(struct v4l2_input));
 281
 282                 DEB_D(("dpc_v4l2.o: v4l2_ioctl: VIDIOC_ENUMINPUT %d.\n",i->index));
 283                 return 0;
 284         }
 285         case VIDIOC_G_INPUT:
 286         {
 287                 int *input = (int *)arg;
 288                 *input = dpc->cur_input;
 289
 290                 DEB_D(("dpc_v4l2.o: VIDIOC_G_INPUT: %d\n",*input));
 291                 return 0;
 292         }
 293         case VIDIOC_S_INPUT:
 294         {
 295                 int     input = *(int *)arg;
 296
 297                 if (input < 0 || input >= DPC_INPUTS) {
 298                         return -EINVAL;
 299                 }
 300
 301                 dpc->cur_input = input;
 302
 303                 /* fixme: switch input here, switch audio, too! */
 304 //              saa7146_set_hps_source_and_sync(dev, input_port_selection[input].hps_source, input_port_selection[input].hps_sync);
 305                 printk("dpc_v4l2.o: VIDIOC_S_INPUT: fixme switch input.\n");
 306
 307                 return 0;
 308         }
 309         default:
 310 /*
 311                 DEB_D(("dpc_v4l2.o: v4l2_ioctl does not handle this ioctl.\n"));
 312 */
 313                 return -ENOIOCTLCMD;
 314         }
 315         return 0;
 316 }
 317
 318 static int std_callback(struct saa7146_dev* dev, struct saa7146_standard *std)
 319 {
 320         return 0;
 321 }
 322
 323 static struct saa7146_standard standard[] = {
 324         {
 325                 .name   = "PAL",        .id     = V4L2_STD_PAL,
 326                 .v_offset       = 0x17, .v_field        = 288,
 327                 .h_offset       = 0x14, .h_pixels       = 680,
 328                 .v_max_out      = 576,  .h_max_out      = 768,
 329         }, {
 330                 .name   = "NTSC",       .id     = V4L2_STD_NTSC,
 331                 .v_offset       = 0x16, .v_field        = 240,
 332                 .h_offset       = 0x06, .h_pixels       = 708,
 333                 .v_max_out      = 480,  .h_max_out      = 640,
 334         }, {
 335                 .name   = "SECAM",      .id     = V4L2_STD_SECAM,
 336                 .v_offset       = 0x14, .v_field        = 288,
 337                 .h_offset       = 0x14, .h_pixels       = 720,
 338                 .v_max_out      = 576,  .h_max_out      = 768,
 339         }
 340 };
 341
 342 static struct saa7146_extension extension;
 343
 344 static struct saa7146_pci_extension_data dpc = {
 345         .ext_priv = "Multimedia eXtension Board",
 346         .ext = &extension,
 347 };
 348
 349 static struct pci_device_id pci_tbl[] = {
 350         {
 351                 .vendor    = PCI_VENDOR_ID_PHILIPS,
 352                 .device    = PCI_DEVICE_ID_PHILIPS_SAA7146,
 353                 .subvendor = 0x0000,
 354                 .subdevice = 0x0000,
 355                 .driver_data = (unsigned long)&dpc,
 356         }, {
 357                 .vendor = 0,
 358         }
 359 };
 360
 361 MODULE_DEVICE_TABLE(pci, pci_tbl);
 362
 363 static struct saa7146_ext_vv vv_data = {
 364         .inputs         = DPC_INPUTS,
 365         .capabilities   = V4L2_CAP_VBI_CAPTURE,
 366         .stds           = &standard[0],
 367         .num_stds       = sizeof(standard)/sizeof(struct saa7146_standard),
 368         .std_callback   = &std_callback,
 369         .ioctls         = &ioctls[0],
 370         .ioctl          = dpc_ioctl,
 371 };
 372
 373 static struct saa7146_extension extension = {
 374         .name           = "dpc7146 demonstration board",
 375         .flags          = SAA7146_USE_I2C_IRQ,
 376
 377         .pci_tbl        = &pci_tbl[0],
 378         .module         = THIS_MODULE,
 379
 380         .probe          = dpc_probe,
 381         .attach         = dpc_attach,
 382         .detach         = dpc_detach,
 383
 384         .irq_mask       = 0,
 385         .irq_func       = NULL,
 386 };
 387
 388 static int __init dpc_init_module(void)
 389 {
 390         if( 0 != saa7146_register_extension(&extension)) {
 391                 DEB_S(("failed to register extension.\n"));
 392                 return -ENODEV;
 393         }
 394
 395         return 0;
 396 }
 397
 398 static void __exit dpc_cleanup_module(void)
 399 {
 400         saa7146_unregister_extension(&extension);
 401 }
 402
 403 module_init(dpc_init_module);
 404 module_exit(dpc_cleanup_module);
 405
 406 MODULE_DESCRIPTION("video4linux-2 driver for the 'dpc7146 demonstration board'");
 407 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
 408 MODULE_LICENSE("GPL");