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