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