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

   1 /*
   2     hexium_orion.c - v4l2 driver for the Hexium Orion frame grabber cards
   3
   4     Visit http://www.mihu.de/linux/saa7146/ and follow the link
   5     to "hexium" for further details about this card.
   6
   7     Copyright (C) 2003 Michael Hunold <michael@mihu.de>
   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
  28 static int debug;
  29 module_param(debug, int, 0);
  30 MODULE_PARM_DESC(debug, "debug verbosity");
  31
  32 /* global variables */
  33 static int hexium_num;
  34
  35 #define HEXIUM_HV_PCI6_ORION            1
  36 #define HEXIUM_ORION_1SVHS_3BNC         2
  37 #define HEXIUM_ORION_4BNC               3
  38
  39 #define HEXIUM_INPUTS   9
  40 static struct v4l2_input hexium_inputs[HEXIUM_INPUTS] = {
  41         { 0, "CVBS 1",  V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  42         { 1, "CVBS 2",  V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  43         { 2, "CVBS 3",  V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  44         { 3, "CVBS 4",  V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  45         { 4, "CVBS 5",  V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  46         { 5, "CVBS 6",  V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  47         { 6, "Y/C 1",   V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  48         { 7, "Y/C 2",   V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  49         { 8, "Y/C 3",   V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
  50 };
  51
  52 #define HEXIUM_AUDIOS   0
  53
  54 struct hexium_data
  55 {
  56         s8 adr;
  57         u8 byte;
  58 };
  59
  60 struct hexium
  61 {
  62         int type;
  63         struct video_device     *video_dev;
  64         struct i2c_adapter      i2c_adapter;
  65
  66         int cur_input;  /* current input */
  67 };
  68
  69 /* Philips SAA7110 decoder default registers */
  70 static u8 hexium_saa7110[53]={
  71 /*00*/ 0x4C,0x3C,0x0D,0xEF,0xBD,0xF0,0x00,0x00,
  72 /*08*/ 0xF8,0xF8,0x60,0x60,0x40,0x86,0x18,0x90,
  73 /*10*/ 0x00,0x2C,0x40,0x46,0x42,0x1A,0xFF,0xDA,
  74 /*18*/ 0xF0,0x8B,0x00,0x00,0x00,0x00,0x00,0x00,
  75 /*20*/ 0xD9,0x17,0x40,0x41,0x80,0x41,0x80,0x4F,
  76 /*28*/ 0xFE,0x01,0x0F,0x0F,0x03,0x01,0x81,0x03,
  77 /*30*/ 0x44,0x75,0x01,0x8C,0x03
  78 };
  79
  80 static struct {
  81         struct hexium_data data[8];
  82 } hexium_input_select[] = {
  83 {
  84         { /* cvbs 1 */
  85                 { 0x06, 0x00 },
  86                 { 0x20, 0xD9 },
  87                 { 0x21, 0x17 }, // 0x16,
  88                 { 0x22, 0x40 },
  89                 { 0x2C, 0x03 },
  90                 { 0x30, 0x44 },
  91                 { 0x31, 0x75 }, // ??
  92                 { 0x21, 0x16 }, // 0x03,
  93         }
  94 }, {
  95         { /* cvbs 2 */
  96                 { 0x06, 0x00 },
  97                 { 0x20, 0x78 },
  98                 { 0x21, 0x07 }, // 0x03,
  99                 { 0x22, 0xD2 },
 100                 { 0x2C, 0x83 },
 101                 { 0x30, 0x60 },
 102                 { 0x31, 0xB5 }, // ?
 103                 { 0x21, 0x03 },
 104         }
 105 }, {
 106         { /* cvbs 3 */
 107                 { 0x06, 0x00 },
 108                 { 0x20, 0xBA },
 109                 { 0x21, 0x07 }, // 0x05,
 110                 { 0x22, 0x91 },
 111                 { 0x2C, 0x03 },
 112                 { 0x30, 0x60 },
 113                 { 0x31, 0xB5 }, // ??
 114                 { 0x21, 0x05 }, // 0x03,
 115         }
 116 }, {
 117         { /* cvbs 4 */
 118                 { 0x06, 0x00 },
 119                 { 0x20, 0xD8 },
 120                 { 0x21, 0x17 }, // 0x16,
 121                 { 0x22, 0x40 },
 122                 { 0x2C, 0x03 },
 123                 { 0x30, 0x44 },
 124                 { 0x31, 0x75 }, // ??
 125                 { 0x21, 0x16 }, // 0x03,
 126         }
 127 }, {
 128         { /* cvbs 5 */
 129                 { 0x06, 0x00 },
 130                 { 0x20, 0xB8 },
 131                 { 0x21, 0x07 }, // 0x05,
 132                 { 0x22, 0x91 },
 133                 { 0x2C, 0x03 },
 134                 { 0x30, 0x60 },
 135                 { 0x31, 0xB5 }, // ??
 136                 { 0x21, 0x05 }, // 0x03,
 137         }
 138 }, {
 139         { /* cvbs 6 */
 140                 { 0x06, 0x00 },
 141                 { 0x20, 0x7C },
 142                 { 0x21, 0x07 }, // 0x03
 143                 { 0x22, 0xD2 },
 144                 { 0x2C, 0x83 },
 145                 { 0x30, 0x60 },
 146                 { 0x31, 0xB5 }, // ??
 147                 { 0x21, 0x03 },
 148         }
 149 }, {
 150         { /* y/c 1 */
 151                 { 0x06, 0x80 },
 152                 { 0x20, 0x59 },
 153                 { 0x21, 0x17 },
 154                 { 0x22, 0x42 },
 155                 { 0x2C, 0xA3 },
 156                 { 0x30, 0x44 },
 157                 { 0x31, 0x75 },
 158                 { 0x21, 0x12 },
 159         }
 160 }, {
 161         { /* y/c 2 */
 162                 { 0x06, 0x80 },
 163                 { 0x20, 0x9A },
 164                 { 0x21, 0x17 },
 165                 { 0x22, 0xB1 },
 166                 { 0x2C, 0x13 },
 167                 { 0x30, 0x60 },
 168                 { 0x31, 0xB5 },
 169                 { 0x21, 0x14 },
 170         }
 171 }, {
 172         { /* y/c 3 */
 173                 { 0x06, 0x80 },
 174                 { 0x20, 0x3C },
 175                 { 0x21, 0x27 },
 176                 { 0x22, 0xC1 },
 177                 { 0x2C, 0x23 },
 178                 { 0x30, 0x44 },
 179                 { 0x31, 0x75 },
 180                 { 0x21, 0x21 },
 181         }
 182 }
 183 };
 184
 185 static struct saa7146_standard hexium_standards[] = {
 186         {
 187                 .name   = "PAL",        .id     = V4L2_STD_PAL,
 188                 .v_offset       = 16,   .v_field        = 288,
 189                 .h_offset       = 1,    .h_pixels       = 680,
 190                 .v_max_out      = 576,  .h_max_out      = 768,
 191         }, {
 192                 .name   = "NTSC",       .id     = V4L2_STD_NTSC,
 193                 .v_offset       = 16,   .v_field        = 240,
 194                 .h_offset       = 1,    .h_pixels       = 640,
 195                 .v_max_out      = 480,  .h_max_out      = 640,
 196         }, {
 197                 .name   = "SECAM",      .id     = V4L2_STD_SECAM,
 198                 .v_offset       = 16,   .v_field        = 288,
 199                 .h_offset       = 1,    .h_pixels       = 720,
 200                 .v_max_out      = 576,  .h_max_out      = 768,
 201         }
 202 };
 203
 204 /* this is only called for old HV-PCI6/Orion cards
 205    without eeprom */
 206 static int hexium_probe(struct saa7146_dev *dev)
 207 {
 208         struct hexium *hexium = NULL;
 209         union i2c_smbus_data data;
 210         int err = 0;
 211
 212         DEB_EE((".\n"));
 213
 214         /* there are no hexium orion cards with revision 0 saa7146s */
 215         if (0 == dev->revision) {
 216                 return -EFAULT;
 217         }
 218
 219         hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
 220         if (NULL == hexium) {
 221                 printk("hexium_orion: hexium_probe: not enough kernel memory.\n");
 222                 return -ENOMEM;
 223         }
 224
 225         /* enable i2c-port pins */
 226         saa7146_write(dev, MC1, (MASK_08 | MASK_24 | MASK_10 | MASK_26));
 227
 228         saa7146_write(dev, DD1_INIT, 0x01000100);
 229         saa7146_write(dev, DD1_STREAM_B, 0x00000000);
 230         saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
 231
 232         hexium->i2c_adapter = (struct i2c_adapter) {
 233                 .class = I2C_CLASS_TV_ANALOG,
 234                 .name = "hexium orion",
 235         };
 236         saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
 237         if (i2c_add_adapter(&hexium->i2c_adapter) < 0) {
 238                 DEB_S(("cannot register i2c-device. skipping.\n"));
 239                 kfree(hexium);
 240                 return -EFAULT;
 241         }
 242
 243         /* set SAA7110 control GPIO 0 */
 244         saa7146_setgpio(dev, 0, SAA7146_GPIO_OUTHI);
 245         /*  set HWControl GPIO number 2 */
 246         saa7146_setgpio(dev, 2, SAA7146_GPIO_OUTHI);
 247
 248         mdelay(10);
 249
 250         /* detect newer Hexium Orion cards by subsystem ids */
 251         if (0x17c8 == dev->pci->subsystem_vendor && 0x0101 == dev->pci->subsystem_device) {
 252                 printk("hexium_orion: device is a Hexium Orion w/ 1 SVHS + 3 BNC inputs.\n");
 253                 /* we store the pointer in our private data field */
 254                 dev->ext_priv = hexium;
 255                 hexium->type = HEXIUM_ORION_1SVHS_3BNC;
 256                 return 0;
 257         }
 258
 259         if (0x17c8 == dev->pci->subsystem_vendor && 0x2101 == dev->pci->subsystem_device) {
 260                 printk("hexium_orion: device is a Hexium Orion w/ 4 BNC inputs.\n");
 261                 /* we store the pointer in our private data field */
 262                 dev->ext_priv = hexium;
 263                 hexium->type = HEXIUM_ORION_4BNC;
 264                 return 0;
 265         }
 266
 267         /* check if this is an old hexium Orion card by looking at
 268            a saa7110 at address 0x4e */
 269         if (0 == (err = i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_READ, 0x00, I2C_SMBUS_BYTE_DATA, &data))) {
 270                 printk("hexium_orion: device is a Hexium HV-PCI6/Orion (old).\n");
 271                 /* we store the pointer in our private data field */
 272                 dev->ext_priv = hexium;
 273                 hexium->type = HEXIUM_HV_PCI6_ORION;
 274                 return 0;
 275         }
 276
 277         i2c_del_adapter(&hexium->i2c_adapter);
 278         kfree(hexium);
 279         return -EFAULT;
 280 }
 281
 282 /* bring hardware to a sane state. this has to be done, just in case someone
 283    wants to capture from this device before it has been properly initialized.
 284    the capture engine would badly fail, because no valid signal arrives on the
 285    saa7146, thus leading to timeouts and stuff. */
 286 static int hexium_init_done(struct saa7146_dev *dev)
 287 {
 288         struct hexium *hexium = (struct hexium *) dev->ext_priv;
 289         union i2c_smbus_data data;
 290         int i = 0;
 291
 292         DEB_D(("hexium_init_done called.\n"));
 293
 294         /* initialize the helper ics to useful values */
 295         for (i = 0; i < sizeof(hexium_saa7110); i++) {
 296                 data.byte = hexium_saa7110[i];
 297                 if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_WRITE, i, I2C_SMBUS_BYTE_DATA, &data)) {
 298                         printk("hexium_orion: failed for address 0x%02x\n", i);
 299                 }
 300         }
 301
 302         return 0;
 303 }
 304
 305 static int hexium_set_input(struct hexium *hexium, int input)
 306 {
 307         union i2c_smbus_data data;
 308         int i = 0;
 309
 310         DEB_D((".\n"));
 311
 312         for (i = 0; i < 8; i++) {
 313                 int adr = hexium_input_select[input].data[i].adr;
 314                 data.byte = hexium_input_select[input].data[i].byte;
 315                 if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_WRITE, adr, I2C_SMBUS_BYTE_DATA, &data)) {
 316                         return -1;
 317                 }
 318                 printk("%d: 0x%02x => 0x%02x\n",input, adr,data.byte);
 319         }
 320
 321         return 0;
 322 }
 323
 324 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
 325 {
 326         DEB_EE(("VIDIOC_ENUMINPUT %d.\n", i->index));
 327
 328         if (i->index < 0 || i->index >= HEXIUM_INPUTS)
 329                 return -EINVAL;
 330
 331         memcpy(i, &hexium_inputs[i->index], sizeof(struct v4l2_input));
 332
 333         DEB_D(("v4l2_ioctl: VIDIOC_ENUMINPUT %d.\n", i->index));
 334         return 0;
 335 }
 336
 337 static int vidioc_g_input(struct file *file, void *fh, unsigned int *input)
 338 {
 339         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 340         struct hexium *hexium = (struct hexium *) dev->ext_priv;
 341
 342         *input = hexium->cur_input;
 343
 344         DEB_D(("VIDIOC_G_INPUT: %d\n", *input));
 345         return 0;
 346 }
 347
 348 static int vidioc_s_input(struct file *file, void *fh, unsigned int input)
 349 {
 350         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 351         struct hexium *hexium = (struct hexium *) dev->ext_priv;
 352
 353         if (input < 0 || input >= HEXIUM_INPUTS)
 354                 return -EINVAL;
 355
 356         hexium->cur_input = input;
 357         hexium_set_input(hexium, input);
 358
 359         return 0;
 360 }
 361
 362 static struct saa7146_ext_vv vv_data;
 363
 364 /* this function only gets called when the probing was successful */
 365 static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
 366 {
 367         struct hexium *hexium = (struct hexium *) dev->ext_priv;
 368
 369         DEB_EE((".\n"));
 370
 371         saa7146_vv_init(dev, &vv_data);
 372         vv_data.ops.vidioc_enum_input = vidioc_enum_input;
 373         vv_data.ops.vidioc_g_input = vidioc_g_input;
 374         vv_data.ops.vidioc_s_input = vidioc_s_input;
 375         if (0 != saa7146_register_device(&hexium->video_dev, dev, "hexium orion", VFL_TYPE_GRABBER)) {
 376                 printk("hexium_orion: cannot register capture v4l2 device. skipping.\n");
 377                 return -1;
 378         }
 379
 380         printk("hexium_orion: found 'hexium orion' frame grabber-%d.\n", hexium_num);
 381         hexium_num++;
 382
 383         /* the rest */
 384         hexium->cur_input = 0;
 385         hexium_init_done(dev);
 386
 387         return 0;
 388 }
 389
 390 static int hexium_detach(struct saa7146_dev *dev)
 391 {
 392         struct hexium *hexium = (struct hexium *) dev->ext_priv;
 393
 394         DEB_EE(("dev:%p\n", dev));
 395
 396         saa7146_unregister_device(&hexium->video_dev, dev);
 397         saa7146_vv_release(dev);
 398
 399         hexium_num--;
 400
 401         i2c_del_adapter(&hexium->i2c_adapter);
 402         kfree(hexium);
 403         return 0;
 404 }
 405
 406 static int std_callback(struct saa7146_dev *dev, struct saa7146_standard *std)
 407 {
 408         return 0;
 409 }
 410
 411 static struct saa7146_extension extension;
 412
 413 static struct saa7146_pci_extension_data hexium_hv_pci6 = {
 414         .ext_priv = "Hexium HV-PCI6 / Orion",
 415         .ext = &extension,
 416 };
 417
 418 static struct saa7146_pci_extension_data hexium_orion_1svhs_3bnc = {
 419         .ext_priv = "Hexium HV-PCI6 / Orion (1 SVHS/3 BNC)",
 420         .ext = &extension,
 421 };
 422
 423 static struct saa7146_pci_extension_data hexium_orion_4bnc = {
 424         .ext_priv = "Hexium HV-PCI6 / Orion (4 BNC)",
 425         .ext = &extension,
 426 };
 427
 428 static struct pci_device_id pci_tbl[] = {
 429         {
 430          .vendor = PCI_VENDOR_ID_PHILIPS,
 431          .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
 432          .subvendor = 0x0000,
 433          .subdevice = 0x0000,
 434          .driver_data = (unsigned long) &hexium_hv_pci6,
 435          },
 436         {
 437          .vendor = PCI_VENDOR_ID_PHILIPS,
 438          .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
 439          .subvendor = 0x17c8,
 440          .subdevice = 0x0101,
 441          .driver_data = (unsigned long) &hexium_orion_1svhs_3bnc,
 442          },
 443         {
 444          .vendor = PCI_VENDOR_ID_PHILIPS,
 445          .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
 446          .subvendor = 0x17c8,
 447          .subdevice = 0x2101,
 448          .driver_data = (unsigned long) &hexium_orion_4bnc,
 449          },
 450         {
 451          .vendor = 0,
 452          }
 453 };
 454
 455 MODULE_DEVICE_TABLE(pci, pci_tbl);
 456
 457 static struct saa7146_ext_vv vv_data = {
 458         .inputs = HEXIUM_INPUTS,
 459         .capabilities = 0,
 460         .stds = &hexium_standards[0],
 461         .num_stds = sizeof(hexium_standards) / sizeof(struct saa7146_standard),
 462         .std_callback = &std_callback,
 463 };
 464
 465 static struct saa7146_extension extension = {
 466         .name = "hexium HV-PCI6 Orion",
 467         .flags = 0,             // SAA7146_USE_I2C_IRQ,
 468
 469         .pci_tbl = &pci_tbl[0],
 470         .module = THIS_MODULE,
 471
 472         .probe = hexium_probe,
 473         .attach = hexium_attach,
 474         .detach = hexium_detach,
 475
 476         .irq_mask = 0,
 477         .irq_func = NULL,
 478 };
 479
 480 static int __init hexium_init_module(void)
 481 {
 482         if (0 != saa7146_register_extension(&extension)) {
 483                 DEB_S(("failed to register extension.\n"));
 484                 return -ENODEV;
 485         }
 486
 487         return 0;
 488 }
 489
 490 static void __exit hexium_cleanup_module(void)
 491 {
 492         saa7146_unregister_extension(&extension);
 493 }
 494
 495 module_init(hexium_init_module);
 496 module_exit(hexium_cleanup_module);
 497
 498 MODULE_DESCRIPTION("video4linux-2 driver for Hexium Orion frame grabber cards");
 499 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
 500 MODULE_LICENSE("GPL");