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