drivers/media/pci/saa7146/hexium_gemini.c

   1 /*
   2     hexium_gemini.c - v4l2 driver for Hexium Gemini 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 pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  25
  26 #define DEBUG_VARIABLE debug
  27
  28 #include <media/drv-intf/saa7146_vv.h>
  29 #include <linux/module.h>
  30
  31 static int debug;
  32 module_param(debug, int, 0);
  33 MODULE_PARM_DESC(debug, "debug verbosity");
  34
  35 /* global variables */
  36 static int hexium_num;
  37
  38 #define HEXIUM_GEMINI                   4
  39 #define HEXIUM_GEMINI_DUAL              5
  40
  41 #define HEXIUM_INPUTS   9
  42 static struct v4l2_input hexium_inputs[HEXIUM_INPUTS] = {
  43         { 0, "CVBS 1",  V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
  44         { 1, "CVBS 2",  V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
  45         { 2, "CVBS 3",  V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
  46         { 3, "CVBS 4",  V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
  47         { 4, "CVBS 5",  V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
  48         { 5, "CVBS 6",  V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
  49         { 6, "Y/C 1",   V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
  50         { 7, "Y/C 2",   V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
  51         { 8, "Y/C 3",   V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
  52 };
  53
  54 #define HEXIUM_AUDIOS   0
  55
  56 struct hexium_data
  57 {
  58         s8 adr;
  59         u8 byte;
  60 };
  61
  62 #define HEXIUM_GEMINI_V_1_0             1
  63 #define HEXIUM_GEMINI_DUAL_V_1_0        2
  64
  65 struct hexium
  66 {
  67         int type;
  68
  69         struct video_device     video_dev;
  70         struct i2c_adapter      i2c_adapter;
  71
  72         int             cur_input;      /* current input */
  73         v4l2_std_id     cur_std;        /* current standard */
  74 };
  75
  76 /* Samsung KS0127B decoder default registers */
  77 static u8 hexium_ks0127b[0x100]={
  78 /*00*/ 0x00,0x52,0x30,0x40,0x01,0x0C,0x2A,0x10,
  79 /*08*/ 0x00,0x00,0x00,0x60,0x00,0x00,0x0F,0x06,
  80 /*10*/ 0x00,0x00,0xE4,0xC0,0x00,0x00,0x00,0x00,
  81 /*18*/ 0x14,0x9B,0xFE,0xFF,0xFC,0xFF,0x03,0x22,
  82 /*20*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  83 /*28*/ 0x00,0x00,0x00,0x00,0x00,0x2C,0x9B,0x00,
  84 /*30*/ 0x00,0x00,0x10,0x80,0x80,0x10,0x80,0x80,
  85 /*38*/ 0x01,0x04,0x00,0x00,0x00,0x29,0xC0,0x00,
  86 /*40*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  87 /*48*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  88 /*50*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  89 /*58*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  90 /*60*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  91 /*68*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  92 /*70*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  93 /*78*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  94 /*80*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  95 /*88*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  96 /*90*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  97 /*98*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  98 /*A0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  99 /*A8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 100 /*B0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 101 /*B8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 102 /*C0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 103 /*C8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 104 /*D0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 105 /*D8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 106 /*E0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 107 /*E8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 108 /*F0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 109 /*F8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
 110 };
 111
 112 static struct hexium_data hexium_pal[] = {
 113         { 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
 114 };
 115
 116 static struct hexium_data hexium_ntsc[] = {
 117         { 0x01, 0x53 }, { 0x12, 0x04 }, { 0x2D, 0x23 }, { 0x2E, 0x81 }, { -1 , 0xFF }
 118 };
 119
 120 static struct hexium_data hexium_secam[] = {
 121         { 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
 122 };
 123
 124 static struct hexium_data hexium_input_select[] = {
 125         { 0x02, 0x60 },
 126         { 0x02, 0x64 },
 127         { 0x02, 0x61 },
 128         { 0x02, 0x65 },
 129         { 0x02, 0x62 },
 130         { 0x02, 0x66 },
 131         { 0x02, 0x68 },
 132         { 0x02, 0x69 },
 133         { 0x02, 0x6A },
 134 };
 135
 136 /* fixme: h_offset = 0 for Hexium Gemini *Dual*, which
 137    are currently *not* supported*/
 138 static struct saa7146_standard hexium_standards[] = {
 139         {
 140                 .name   = "PAL",        .id     = V4L2_STD_PAL,
 141                 .v_offset       = 28,   .v_field        = 288,
 142                 .h_offset       = 1,    .h_pixels       = 680,
 143                 .v_max_out      = 576,  .h_max_out      = 768,
 144         }, {
 145                 .name   = "NTSC",       .id     = V4L2_STD_NTSC,
 146                 .v_offset       = 28,   .v_field        = 240,
 147                 .h_offset       = 1,    .h_pixels       = 640,
 148                 .v_max_out      = 480,  .h_max_out      = 640,
 149         }, {
 150                 .name   = "SECAM",      .id     = V4L2_STD_SECAM,
 151                 .v_offset       = 28,   .v_field        = 288,
 152                 .h_offset       = 1,    .h_pixels       = 720,
 153                 .v_max_out      = 576,  .h_max_out      = 768,
 154         }
 155 };
 156
 157 /* bring hardware to a sane state. this has to be done, just in case someone
 158    wants to capture from this device before it has been properly initialized.
 159    the capture engine would badly fail, because no valid signal arrives on the
 160    saa7146, thus leading to timeouts and stuff. */
 161 static int hexium_init_done(struct saa7146_dev *dev)
 162 {
 163         struct hexium *hexium = (struct hexium *) dev->ext_priv;
 164         union i2c_smbus_data data;
 165         int i = 0;
 166
 167         DEB_D("hexium_init_done called\n");
 168
 169         /* initialize the helper ics to useful values */
 170         for (i = 0; i < sizeof(hexium_ks0127b); i++) {
 171                 data.byte = hexium_ks0127b[i];
 172                 if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, i, I2C_SMBUS_BYTE_DATA, &data)) {
 173                         pr_err("hexium_init_done() failed for address 0x%02x\n",
 174                                i);
 175                 }
 176         }
 177
 178         return 0;
 179 }
 180
 181 static int hexium_set_input(struct hexium *hexium, int input)
 182 {
 183         union i2c_smbus_data data;
 184
 185         DEB_D("\n");
 186
 187         data.byte = hexium_input_select[input].byte;
 188         if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, hexium_input_select[input].adr, I2C_SMBUS_BYTE_DATA, &data)) {
 189                 return -1;
 190         }
 191
 192         return 0;
 193 }
 194
 195 static int hexium_set_standard(struct hexium *hexium, struct hexium_data *vdec)
 196 {
 197         union i2c_smbus_data data;
 198         int i = 0;
 199
 200         DEB_D("\n");
 201
 202         while (vdec[i].adr != -1) {
 203                 data.byte = vdec[i].byte;
 204                 if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, vdec[i].adr, I2C_SMBUS_BYTE_DATA, &data)) {
 205                         pr_err("hexium_init_done: hexium_set_standard() failed for address 0x%02x\n",
 206                                i);
 207                         return -1;
 208                 }
 209                 i++;
 210         }
 211         return 0;
 212 }
 213
 214 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
 215 {
 216         DEB_EE("VIDIOC_ENUMINPUT %d\n", i->index);
 217
 218         if (i->index >= HEXIUM_INPUTS)
 219                 return -EINVAL;
 220
 221         memcpy(i, &hexium_inputs[i->index], sizeof(struct v4l2_input));
 222
 223         DEB_D("v4l2_ioctl: VIDIOC_ENUMINPUT %d\n", i->index);
 224         return 0;
 225 }
 226
 227 static int vidioc_g_input(struct file *file, void *fh, unsigned int *input)
 228 {
 229         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 230         struct hexium *hexium = (struct hexium *) dev->ext_priv;
 231
 232         *input = hexium->cur_input;
 233
 234         DEB_D("VIDIOC_G_INPUT: %d\n", *input);
 235         return 0;
 236 }
 237
 238 static int vidioc_s_input(struct file *file, void *fh, unsigned int input)
 239 {
 240         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 241         struct hexium *hexium = (struct hexium *) dev->ext_priv;
 242
 243         DEB_EE("VIDIOC_S_INPUT %d\n", input);
 244
 245         if (input >= HEXIUM_INPUTS)
 246                 return -EINVAL;
 247
 248         hexium->cur_input = input;
 249         hexium_set_input(hexium, input);
 250         return 0;
 251 }
 252
 253 static struct saa7146_ext_vv vv_data;
 254
 255 /* this function only gets called when the probing was successful */
 256 static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
 257 {
 258         struct hexium *hexium;
 259         int ret;
 260
 261         DEB_EE("\n");
 262
 263         hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
 264         if (NULL == hexium) {
 265                 pr_err("not enough kernel memory in hexium_attach()\n");
 266                 return -ENOMEM;
 267         }
 268         dev->ext_priv = hexium;
 269
 270         /* enable i2c-port pins */
 271         saa7146_write(dev, MC1, (MASK_08 | MASK_24 | MASK_10 | MASK_26));
 272
 273         strscpy(hexium->i2c_adapter.name, "hexium gemini",
 274                 sizeof(hexium->i2c_adapter.name));
 275         saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
 276         if (i2c_add_adapter(&hexium->i2c_adapter) < 0) {
 277                 DEB_S("cannot register i2c-device. skipping.\n");
 278                 kfree(hexium);
 279                 return -EFAULT;
 280         }
 281
 282         /*  set HWControl GPIO number 2 */
 283         saa7146_setgpio(dev, 2, SAA7146_GPIO_OUTHI);
 284
 285         saa7146_write(dev, DD1_INIT, 0x07000700);
 286         saa7146_write(dev, DD1_STREAM_B, 0x00000000);
 287         saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
 288
 289         /* the rest */
 290         hexium->cur_input = 0;
 291         hexium_init_done(dev);
 292
 293         hexium_set_standard(hexium, hexium_pal);
 294         hexium->cur_std = V4L2_STD_PAL;
 295
 296         hexium_set_input(hexium, 0);
 297         hexium->cur_input = 0;
 298
 299         ret = saa7146_vv_init(dev, &vv_data);
 300         if (ret) {
 301                 i2c_del_adapter(&hexium->i2c_adapter);
 302                 kfree(hexium);
 303                 return ret;
 304         }
 305
 306         vv_data.vid_ops.vidioc_enum_input = vidioc_enum_input;
 307         vv_data.vid_ops.vidioc_g_input = vidioc_g_input;
 308         vv_data.vid_ops.vidioc_s_input = vidioc_s_input;
 309         ret = saa7146_register_device(&hexium->video_dev, dev, "hexium gemini", VFL_TYPE_GRABBER);
 310         if (ret < 0) {
 311                 pr_err("cannot register capture v4l2 device. skipping.\n");
 312                 saa7146_vv_release(dev);
 313                 i2c_del_adapter(&hexium->i2c_adapter);
 314                 kfree(hexium);
 315                 return ret;
 316         }
 317
 318         pr_info("found 'hexium gemini' frame grabber-%d\n", hexium_num);
 319         hexium_num++;
 320
 321         return 0;
 322 }
 323
 324 static int hexium_detach(struct saa7146_dev *dev)
 325 {
 326         struct hexium *hexium = (struct hexium *) dev->ext_priv;
 327
 328         DEB_EE("dev:%p\n", dev);
 329
 330         saa7146_unregister_device(&hexium->video_dev, dev);
 331         saa7146_vv_release(dev);
 332
 333         hexium_num--;
 334
 335         i2c_del_adapter(&hexium->i2c_adapter);
 336         kfree(hexium);
 337         return 0;
 338 }
 339
 340 static int std_callback(struct saa7146_dev *dev, struct saa7146_standard *std)
 341 {
 342         struct hexium *hexium = (struct hexium *) dev->ext_priv;
 343
 344         if (V4L2_STD_PAL == std->id) {
 345                 hexium_set_standard(hexium, hexium_pal);
 346                 hexium->cur_std = V4L2_STD_PAL;
 347                 return 0;
 348         } else if (V4L2_STD_NTSC == std->id) {
 349                 hexium_set_standard(hexium, hexium_ntsc);
 350                 hexium->cur_std = V4L2_STD_NTSC;
 351                 return 0;
 352         } else if (V4L2_STD_SECAM == std->id) {
 353                 hexium_set_standard(hexium, hexium_secam);
 354                 hexium->cur_std = V4L2_STD_SECAM;
 355                 return 0;
 356         }
 357
 358         return -1;
 359 }
 360
 361 static struct saa7146_extension hexium_extension;
 362
 363 static struct saa7146_pci_extension_data hexium_gemini_4bnc = {
 364         .ext_priv = "Hexium Gemini (4 BNC)",
 365         .ext = &hexium_extension,
 366 };
 367
 368 static struct saa7146_pci_extension_data hexium_gemini_dual_4bnc = {
 369         .ext_priv = "Hexium Gemini Dual (4 BNC)",
 370         .ext = &hexium_extension,
 371 };
 372
 373 static const struct pci_device_id pci_tbl[] = {
 374         {
 375          .vendor = PCI_VENDOR_ID_PHILIPS,
 376          .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
 377          .subvendor = 0x17c8,
 378          .subdevice = 0x2401,
 379          .driver_data = (unsigned long) &hexium_gemini_4bnc,
 380          },
 381         {
 382          .vendor = PCI_VENDOR_ID_PHILIPS,
 383          .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
 384          .subvendor = 0x17c8,
 385          .subdevice = 0x2402,
 386          .driver_data = (unsigned long) &hexium_gemini_dual_4bnc,
 387          },
 388         {
 389          .vendor = 0,
 390          }
 391 };
 392
 393 MODULE_DEVICE_TABLE(pci, pci_tbl);
 394
 395 static struct saa7146_ext_vv vv_data = {
 396         .inputs = HEXIUM_INPUTS,
 397         .capabilities = 0,
 398         .stds = &hexium_standards[0],
 399         .num_stds = sizeof(hexium_standards) / sizeof(struct saa7146_standard),
 400         .std_callback = &std_callback,
 401 };
 402
 403 static struct saa7146_extension hexium_extension = {
 404         .name = "hexium gemini",
 405         .flags = SAA7146_USE_I2C_IRQ,
 406
 407         .pci_tbl = &pci_tbl[0],
 408         .module = THIS_MODULE,
 409
 410         .attach = hexium_attach,
 411         .detach = hexium_detach,
 412
 413         .irq_mask = 0,
 414         .irq_func = NULL,
 415 };
 416
 417 static int __init hexium_init_module(void)
 418 {
 419         if (0 != saa7146_register_extension(&hexium_extension)) {
 420                 DEB_S("failed to register extension\n");
 421                 return -ENODEV;
 422         }
 423
 424         return 0;
 425 }
 426
 427 static void __exit hexium_cleanup_module(void)
 428 {
 429         saa7146_unregister_extension(&hexium_extension);
 430 }
 431
 432 module_init(hexium_init_module);
 433 module_exit(hexium_cleanup_module);
 434
 435 MODULE_DESCRIPTION("video4linux-2 driver for Hexium Gemini frame grabber cards");
 436 MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
 437 MODULE_LICENSE("GPL");