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