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