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 28static int debug = 0; 29module_param(debug, int, 0); 30MODULE_PARM_DESC(debug, "debug verbosity"); 31 32/* global variables */ 33static int hexium_num = 0; 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 40static 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 54struct hexium_data 55{ 56 s8 adr; 57 u8 byte; 58}; 59 60static 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 68struct 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 */ 78static 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 88static 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 193static 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 */ 214static 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. */ 294static 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 313static 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 332static struct saa7146_ext_vv vv_data; 333 334/* this function only gets called when the probing was successful */ 335static 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 357static 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 373static int 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 425static int std_callback(struct saa7146_dev *dev, struct saa7146_standard *std) 426{ 427 return 0; 428} 429 430static struct saa7146_extension extension; 431 432static struct saa7146_pci_extension_data hexium_hv_pci6 = { 433 .ext_priv = "Hexium HV-PCI6 / Orion", 434 .ext = &extension, 435}; 436 437static 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 442static struct saa7146_pci_extension_data hexium_orion_4bnc = { 443 .ext_priv = "Hexium HV-PCI6 / Orion (4 BNC)", 444 .ext = &extension, 445}; 446 447static 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 474MODULE_DEVICE_TABLE(pci, pci_tbl); 475 476static 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 486static 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 501static 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 511static void __exit hexium_cleanup_module(void) 512{ 513 saa7146_unregister_extension(&extension); 514} 515 516module_init(hexium_init_module); 517module_exit(hexium_cleanup_module); 518 519MODULE_DESCRIPTION("video4linux-2 driver for Hexium Orion frame grabber cards"); 520MODULE_AUTHOR("Michael Hunold <michael@mihu.de>"); 521MODULE_LICENSE("GPL"); 522