1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Zoran zr36057/zr36067 PCI controller driver, for the
4  * Pinnacle/Miro DC10/DC10+/DC30/DC30+, Iomega Buz, Linux
5  * Media Labs LML33/LML33R10.
6  *
7  * This part handles card-specific data and detection
8  *
9  * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
10  */
11 
12 #include <linux/delay.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 
17 #include <linux/i2c.h>
18 #include <linux/i2c-algo-bit.h>
19 #include <linux/videodev2.h>
20 #include <linux/spinlock.h>
21 
22 #include <linux/pci.h>
23 #include <linux/interrupt.h>
24 #include <linux/io.h>
25 #include <media/v4l2-common.h>
26 #include <media/i2c/bt819.h>
27 
28 #include "videocodec.h"
29 #include "zoran.h"
30 #include "zoran_card.h"
31 #include "zoran_device.h"
32 #include "zr36016.h"
33 #include "zr36050.h"
34 #include "zr36060.h"
35 
36 extern const struct zoran_format zoran_formats[];
37 
38 static int card[BUZ_MAX] = { [0 ... (BUZ_MAX - 1)] = -1 };
39 module_param_array(card, int, NULL, 0444);
40 MODULE_PARM_DESC(card, "Card type");
41 
42 /* Default input and video norm at startup of the driver. */
43 
44 static unsigned int default_input;	/* default 0 = Composite, 1 = S-Video */
45 module_param(default_input, uint, 0444);
46 MODULE_PARM_DESC(default_input,
47 		 "Default input (0=Composite, 1=S-Video, 2=Internal)");
48 
49 static int default_mux = 1;	/* 6 Eyes input selection */
50 module_param(default_mux, int, 0644);
51 MODULE_PARM_DESC(default_mux,
52 		 "Default 6 Eyes mux setting (Input selection)");
53 
54 static int default_norm;	/* default 0 = PAL, 1 = NTSC 2 = SECAM */
55 module_param(default_norm, int, 0444);
56 MODULE_PARM_DESC(default_norm, "Default norm (0=PAL, 1=NTSC, 2=SECAM)");
57 
58 /* /dev/videoN, -1 for autodetect */
59 static int video_nr[BUZ_MAX] = { [0 ... (BUZ_MAX - 1)] = -1 };
60 module_param_array(video_nr, int, NULL, 0444);
61 MODULE_PARM_DESC(video_nr, "Video device number (-1=Auto)");
62 
63 /* 1=Pass through TV signal when device is not used */
64 /* 0=Show color bar when device is not used (LML33: only if lml33dpath=1) */
65 int pass_through;
66 module_param(pass_through, int, 0644);
67 MODULE_PARM_DESC(pass_through,
68 		 "Pass TV signal through to TV-out when idling");
69 
70 int zr36067_debug = 1;
71 module_param_named(debug, zr36067_debug, int, 0644);
72 MODULE_PARM_DESC(debug, "Debug level (0-5)");
73 
74 #define ZORAN_VERSION "0.10.1"
75 
76 MODULE_DESCRIPTION("Zoran-36057/36067 JPEG codec driver");
77 MODULE_AUTHOR("Serguei Miridonov");
78 MODULE_LICENSE("GPL");
79 MODULE_VERSION(ZORAN_VERSION);
80 
81 #define ZR_DEVICE(subven, subdev, data)	{ \
82 	.vendor = PCI_VENDOR_ID_ZORAN, .device = PCI_DEVICE_ID_ZORAN_36057, \
83 	.subvendor = (subven), .subdevice = (subdev), .driver_data = (data) }
84 
85 static const struct pci_device_id zr36067_pci_tbl[] = {
86 	ZR_DEVICE(PCI_VENDOR_ID_MIRO, PCI_DEVICE_ID_MIRO_DC10PLUS, DC10_PLUS),
87 	ZR_DEVICE(PCI_VENDOR_ID_MIRO, PCI_DEVICE_ID_MIRO_DC30PLUS, DC30_PLUS),
88 	ZR_DEVICE(PCI_VENDOR_ID_ELECTRONICDESIGNGMBH, PCI_DEVICE_ID_LML_33R10, LML33R10),
89 	ZR_DEVICE(PCI_VENDOR_ID_IOMEGA, PCI_DEVICE_ID_IOMEGA_BUZ, BUZ),
90 	ZR_DEVICE(PCI_ANY_ID, PCI_ANY_ID, NUM_CARDS),
91 	{0}
92 };
93 MODULE_DEVICE_TABLE(pci, zr36067_pci_tbl);
94 
95 static unsigned int zoran_num;		/* number of cards found */
96 
97 /* videocodec bus functions ZR36060 */
zr36060_read(struct videocodec * codec,u16 reg)98 static u32 zr36060_read(struct videocodec *codec, u16 reg)
99 {
100 	struct zoran *zr = (struct zoran *)codec->master_data->data;
101 	__u32 data;
102 
103 	if (post_office_wait(zr) || post_office_write(zr, 0, 1, reg >> 8) ||
104 	    post_office_write(zr, 0, 2, reg & 0xff))
105 		return -1;
106 
107 	data = post_office_read(zr, 0, 3) & 0xff;
108 	return data;
109 }
110 
zr36060_write(struct videocodec * codec,u16 reg,u32 val)111 static void zr36060_write(struct videocodec *codec, u16 reg, u32 val)
112 {
113 	struct zoran *zr = (struct zoran *)codec->master_data->data;
114 
115 	if (post_office_wait(zr) || post_office_write(zr, 0, 1, reg >> 8) ||
116 	    post_office_write(zr, 0, 2, reg & 0xff))
117 		return;
118 
119 	post_office_write(zr, 0, 3, val & 0xff);
120 }
121 
122 /* videocodec bus functions ZR36050 */
zr36050_read(struct videocodec * codec,u16 reg)123 static u32 zr36050_read(struct videocodec *codec, u16 reg)
124 {
125 	struct zoran *zr = (struct zoran *)codec->master_data->data;
126 	__u32 data;
127 
128 	if (post_office_wait(zr) || post_office_write(zr, 1, 0, reg >> 2))	// reg. HIGHBYTES
129 		return -1;
130 
131 	data = post_office_read(zr, 0, reg & 0x03) & 0xff;	// reg. LOWBYTES + read
132 	return data;
133 }
134 
zr36050_write(struct videocodec * codec,u16 reg,u32 val)135 static void zr36050_write(struct videocodec *codec, u16 reg, u32 val)
136 {
137 	struct zoran *zr = (struct zoran *)codec->master_data->data;
138 
139 	if (post_office_wait(zr) || post_office_write(zr, 1, 0, reg >> 2))	// reg. HIGHBYTES
140 		return;
141 
142 	post_office_write(zr, 0, reg & 0x03, val & 0xff);	// reg. LOWBYTES + wr. data
143 }
144 
145 /* videocodec bus functions ZR36016 */
zr36016_read(struct videocodec * codec,u16 reg)146 static u32 zr36016_read(struct videocodec *codec, u16 reg)
147 {
148 	struct zoran *zr = (struct zoran *)codec->master_data->data;
149 	__u32 data;
150 
151 	if (post_office_wait(zr))
152 		return -1;
153 
154 	data = post_office_read(zr, 2, reg & 0x03) & 0xff;	// read
155 	return data;
156 }
157 
158 /* hack for in zoran_device.c */
zr36016_write(struct videocodec * codec,u16 reg,u32 val)159 void zr36016_write(struct videocodec *codec, u16 reg, u32 val)
160 {
161 	struct zoran *zr = (struct zoran *)codec->master_data->data;
162 
163 	if (post_office_wait(zr))
164 		return;
165 
166 	post_office_write(zr, 2, reg & 0x03, val & 0x0ff);	// wr. data
167 }
168 
169 /*
170  * Board specific information
171  */
172 
dc10_init(struct zoran * zr)173 static void dc10_init(struct zoran *zr)
174 {
175 	/* Pixel clock selection */
176 	GPIO(zr, 4, 0);
177 	GPIO(zr, 5, 1);
178 	/* Enable the video bus sync signals */
179 	GPIO(zr, 7, 0);
180 }
181 
dc10plus_init(struct zoran * zr)182 static void dc10plus_init(struct zoran *zr)
183 {
184 }
185 
buz_init(struct zoran * zr)186 static void buz_init(struct zoran *zr)
187 {
188 	/* some stuff from Iomega */
189 	pci_write_config_dword(zr->pci_dev, 0xfc, 0x90680f15);
190 	pci_write_config_dword(zr->pci_dev, 0x0c, 0x00012020);
191 	pci_write_config_dword(zr->pci_dev, 0xe8, 0xc0200000);
192 }
193 
lml33_init(struct zoran * zr)194 static void lml33_init(struct zoran *zr)
195 {
196 	GPIO(zr, 2, 1);		// Set Composite input/output
197 }
198 
avs6eyes_init(struct zoran * zr)199 static void avs6eyes_init(struct zoran *zr)
200 {
201 	// AverMedia 6-Eyes original driver by Christer Weinigel
202 
203 	// Lifted straight from Christer's old driver and
204 	// modified slightly by Martin Samuelsson.
205 
206 	int mux = default_mux; /* 1 = BT866, 7 = VID1 */
207 
208 	GPIO(zr, 4, 1); /* Bt866 SLEEP on */
209 	udelay(2);
210 
211 	GPIO(zr, 0, 1); /* ZR36060 /RESET on */
212 	GPIO(zr, 1, 0); /* ZR36060 /SLEEP on */
213 	GPIO(zr, 2, mux & 1);   /* MUX S0 */
214 	GPIO(zr, 3, 0); /* /FRAME on */
215 	GPIO(zr, 4, 0); /* Bt866 SLEEP off */
216 	GPIO(zr, 5, mux & 2);   /* MUX S1 */
217 	GPIO(zr, 6, 0); /* ? */
218 	GPIO(zr, 7, mux & 4);   /* MUX S2 */
219 }
220 
codecid_to_modulename(u16 codecid)221 static const char *codecid_to_modulename(u16 codecid)
222 {
223 	const char *name = NULL;
224 
225 	switch (codecid) {
226 	case CODEC_TYPE_ZR36060:
227 		name = "zr36060";
228 		break;
229 	case CODEC_TYPE_ZR36050:
230 		name = "zr36050";
231 		break;
232 	case CODEC_TYPE_ZR36016:
233 		name = "zr36016";
234 		break;
235 	}
236 
237 	return name;
238 }
239 
codec_init(struct zoran * zr,u16 codecid)240 static int codec_init(struct zoran *zr, u16 codecid)
241 {
242 	switch (codecid) {
243 	case CODEC_TYPE_ZR36060:
244 #ifdef CONFIG_VIDEO_ZORAN_ZR36060
245 		return zr36060_init_module();
246 #else
247 		pci_err(zr->pci_dev, "ZR36060 support is not enabled\n");
248 		return -EINVAL;
249 #endif
250 		break;
251 	case CODEC_TYPE_ZR36050:
252 #ifdef CONFIG_VIDEO_ZORAN_DC30
253 		return zr36050_init_module();
254 #else
255 		pci_err(zr->pci_dev, "ZR36050 support is not enabled\n");
256 		return -EINVAL;
257 #endif
258 		break;
259 	case CODEC_TYPE_ZR36016:
260 #ifdef CONFIG_VIDEO_ZORAN_DC30
261 		return zr36016_init_module();
262 #else
263 		pci_err(zr->pci_dev, "ZR36016 support is not enabled\n");
264 		return -EINVAL;
265 #endif
266 		break;
267 	}
268 
269 	pci_err(zr->pci_dev, "unknown codec id %x\n", codecid);
270 	return -EINVAL;
271 }
272 
codec_exit(struct zoran * zr,u16 codecid)273 static void codec_exit(struct zoran *zr, u16 codecid)
274 {
275 	switch (codecid) {
276 	case CODEC_TYPE_ZR36060:
277 #ifdef CONFIG_VIDEO_ZORAN_ZR36060
278 		zr36060_cleanup_module();
279 #endif
280 		break;
281 	case CODEC_TYPE_ZR36050:
282 #ifdef CONFIG_VIDEO_ZORAN_DC30
283 		zr36050_cleanup_module();
284 #endif
285 		break;
286 	case CODEC_TYPE_ZR36016:
287 #ifdef CONFIG_VIDEO_ZORAN_DC30
288 		zr36016_cleanup_module();
289 #endif
290 		break;
291 	}
292 }
293 
videocodec_init(struct zoran * zr)294 static int videocodec_init(struct zoran *zr)
295 {
296 	const char *codec_name, *vfe_name;
297 	int result;
298 
299 	codec_name = codecid_to_modulename(zr->card.video_codec);
300 	if (codec_name) {
301 		result = codec_init(zr, zr->card.video_codec);
302 		if (result < 0) {
303 			pci_err(zr->pci_dev, "failed to load video codec %s: %d\n",
304 				codec_name, result);
305 			return result;
306 		}
307 	}
308 	vfe_name = codecid_to_modulename(zr->card.video_vfe);
309 	if (vfe_name) {
310 		result = codec_init(zr, zr->card.video_vfe);
311 		if (result < 0) {
312 			pci_err(zr->pci_dev, "failed to load video vfe %s: %d\n",
313 				vfe_name, result);
314 			if (codec_name)
315 				codec_exit(zr, zr->card.video_codec);
316 			return result;
317 		}
318 	}
319 	return 0;
320 }
321 
videocodec_exit(struct zoran * zr)322 static void videocodec_exit(struct zoran *zr)
323 {
324 	if (zr->card.video_codec != CODEC_TYPE_NONE)
325 		codec_exit(zr, zr->card.video_codec);
326 	if (zr->card.video_vfe != CODEC_TYPE_NONE)
327 		codec_exit(zr, zr->card.video_vfe);
328 }
329 
330 static const struct tvnorm f50sqpixel = { 944, 768, 83, 880, 625, 576, 16 };
331 static const struct tvnorm f60sqpixel = { 780, 640, 51, 716, 525, 480, 12 };
332 static const struct tvnorm f50ccir601 = { 864, 720, 75, 804, 625, 576, 18 };
333 static const struct tvnorm f60ccir601 = { 858, 720, 57, 788, 525, 480, 16 };
334 
335 static const struct tvnorm f50ccir601_lml33 = { 864, 720, 75 + 34, 804, 625, 576, 18 };
336 static const struct tvnorm f60ccir601_lml33 = { 858, 720, 57 + 34, 788, 525, 480, 16 };
337 
338 /* The DC10 (57/16/50) uses VActive as HSync, so h_start must be 0 */
339 static const struct tvnorm f50sqpixel_dc10 = { 944, 768, 0, 880, 625, 576, 0 };
340 static const struct tvnorm f60sqpixel_dc10 = { 780, 640, 0, 716, 525, 480, 12 };
341 
342 /*
343  * FIXME: I cannot swap U and V in saa7114, so i do one pixel left shift in zoran (75 -> 74)
344  * (Maxim Yevtyushkin <max@linuxmedialabs.com>)
345  */
346 static const struct tvnorm f50ccir601_lm33r10 = { 864, 720, 74 + 54, 804, 625, 576, 18 };
347 static const struct tvnorm f60ccir601_lm33r10 = { 858, 720, 56 + 54, 788, 525, 480, 16 };
348 
349 /*
350  * FIXME: The ks0127 seem incapable of swapping U and V, too, which is why I copy Maxim's left
351  * shift hack for the 6 Eyes.
352  *
353  * Christer's driver used the unshifted norms, though...
354  * /Sam
355  */
356 static const struct tvnorm f50ccir601_avs6eyes = { 864, 720, 74, 804, 625, 576, 18 };
357 static const struct tvnorm f60ccir601_avs6eyes = { 858, 720, 56, 788, 525, 480, 16 };
358 
359 static const unsigned short vpx3220_addrs[] = { 0x43, 0x47, I2C_CLIENT_END };
360 static const unsigned short saa7110_addrs[] = { 0x4e, 0x4f, I2C_CLIENT_END };
361 static const unsigned short saa7111_addrs[] = { 0x25, 0x24, I2C_CLIENT_END };
362 static const unsigned short saa7114_addrs[] = { 0x21, 0x20, I2C_CLIENT_END };
363 static const unsigned short adv717x_addrs[] = { 0x6a, 0x6b, 0x2a, 0x2b, I2C_CLIENT_END };
364 static const unsigned short ks0127_addrs[] = { 0x6c, 0x6d, I2C_CLIENT_END };
365 static const unsigned short saa7185_addrs[] = { 0x44, I2C_CLIENT_END };
366 static const unsigned short bt819_addrs[] = { 0x45, I2C_CLIENT_END };
367 static const unsigned short bt856_addrs[] = { 0x44, I2C_CLIENT_END };
368 static const unsigned short bt866_addrs[] = { 0x44, I2C_CLIENT_END };
369 
370 static struct card_info zoran_cards[NUM_CARDS] = {
371 	{
372 		.type = DC10_OLD,
373 		.name = "DC10(old)",
374 		.i2c_decoder = "vpx3220a",
375 		.addrs_decoder = vpx3220_addrs,
376 		.video_codec = CODEC_TYPE_ZR36050,
377 		.video_vfe = CODEC_TYPE_ZR36016,
378 
379 		.inputs = 3,
380 		.input = {
381 			{ 1, "Composite" },
382 			{ 2, "S-Video" },
383 			{ 0, "Internal/comp" }
384 		},
385 		.norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
386 		.tvn = {
387 			&f50sqpixel_dc10,
388 			&f60sqpixel_dc10,
389 			&f50sqpixel_dc10
390 		},
391 		.jpeg_int = 0,
392 		.vsync_int = ZR36057_ISR_GIRQ1,
393 		.gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
394 		.gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
395 		.gpcs = { -1, 0 },
396 		.vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
397 		.gws_not_connected = 0,
398 		.input_mux = 0,
399 		.init = &dc10_init,
400 	}, {
401 		.type = DC10_NEW,
402 		.name = "DC10(new)",
403 		.i2c_decoder = "saa7110",
404 		.addrs_decoder = saa7110_addrs,
405 		.i2c_encoder = "adv7175",
406 		.addrs_encoder = adv717x_addrs,
407 		.video_codec = CODEC_TYPE_ZR36060,
408 
409 		.inputs = 3,
410 		.input = {
411 				{ 0, "Composite" },
412 				{ 7, "S-Video" },
413 				{ 5, "Internal/comp" }
414 			},
415 		.norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
416 		.tvn = {
417 				&f50sqpixel,
418 				&f60sqpixel,
419 				&f50sqpixel},
420 		.jpeg_int = ZR36057_ISR_GIRQ0,
421 		.vsync_int = ZR36057_ISR_GIRQ1,
422 		.gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
423 		.gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
424 		.gpcs = { -1, 1},
425 		.vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
426 		.gws_not_connected = 0,
427 		.input_mux = 0,
428 		.init = &dc10plus_init,
429 	}, {
430 		.type = DC10_PLUS,
431 		.name = "DC10_PLUS",
432 		.i2c_decoder = "saa7110",
433 		.addrs_decoder = saa7110_addrs,
434 		.i2c_encoder = "adv7175",
435 		.addrs_encoder = adv717x_addrs,
436 		.video_codec = CODEC_TYPE_ZR36060,
437 
438 		.inputs = 3,
439 		.input = {
440 			{ 0, "Composite" },
441 			{ 7, "S-Video" },
442 			{ 5, "Internal/comp" }
443 		},
444 		.norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
445 		.tvn = {
446 			&f50sqpixel,
447 			&f60sqpixel,
448 			&f50sqpixel
449 		},
450 		.jpeg_int = ZR36057_ISR_GIRQ0,
451 		.vsync_int = ZR36057_ISR_GIRQ1,
452 		.gpio = { 3, 0, 6, 1, 2, -1, 4, 5 },
453 		.gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
454 		.gpcs = { -1, 1 },
455 		.vfe_pol = { 1, 1, 1, 1, 0, 0, 0, 0 },
456 		.gws_not_connected = 0,
457 		.input_mux = 0,
458 		.init = &dc10plus_init,
459 	}, {
460 		.type = DC30,
461 		.name = "DC30",
462 		.i2c_decoder = "vpx3220a",
463 		.addrs_decoder = vpx3220_addrs,
464 		.i2c_encoder = "adv7175",
465 		.addrs_encoder = adv717x_addrs,
466 		.video_codec = CODEC_TYPE_ZR36050,
467 		.video_vfe = CODEC_TYPE_ZR36016,
468 
469 		.inputs = 3,
470 		.input = {
471 			{ 1, "Composite" },
472 			{ 2, "S-Video" },
473 			{ 0, "Internal/comp" }
474 		},
475 		.norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
476 		.tvn = {
477 			&f50sqpixel_dc10,
478 			&f60sqpixel_dc10,
479 			&f50sqpixel_dc10
480 		},
481 		.jpeg_int = 0,
482 		.vsync_int = ZR36057_ISR_GIRQ1,
483 		.gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
484 		.gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
485 		.gpcs = { -1, 0 },
486 		.vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
487 		.gws_not_connected = 0,
488 		.input_mux = 0,
489 		.init = &dc10_init,
490 	}, {
491 		.type = DC30_PLUS,
492 		.name = "DC30_PLUS",
493 		.i2c_decoder = "vpx3220a",
494 		.addrs_decoder = vpx3220_addrs,
495 		.i2c_encoder = "adv7175",
496 		.addrs_encoder = adv717x_addrs,
497 		.video_codec = CODEC_TYPE_ZR36050,
498 		.video_vfe = CODEC_TYPE_ZR36016,
499 
500 		.inputs = 3,
501 		.input = {
502 			{ 1, "Composite" },
503 			{ 2, "S-Video" },
504 			{ 0, "Internal/comp" }
505 		},
506 		.norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
507 		.tvn = {
508 			&f50sqpixel_dc10,
509 			&f60sqpixel_dc10,
510 			&f50sqpixel_dc10
511 		},
512 		.jpeg_int = 0,
513 		.vsync_int = ZR36057_ISR_GIRQ1,
514 		.gpio = { 2, 1, -1, 3, 7, 0, 4, 5 },
515 		.gpio_pol = { 0, 0, 0, 1, 0, 0, 0, 0 },
516 		.gpcs = { -1, 0 },
517 		.vfe_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
518 		.gws_not_connected = 0,
519 		.input_mux = 0,
520 		.init = &dc10_init,
521 	}, {
522 		.type = LML33,
523 		.name = "LML33",
524 		.i2c_decoder = "bt819a",
525 		.addrs_decoder = bt819_addrs,
526 		.i2c_encoder = "bt856",
527 		.addrs_encoder = bt856_addrs,
528 		.video_codec = CODEC_TYPE_ZR36060,
529 
530 		.inputs = 2,
531 		.input = {
532 			{ 0, "Composite" },
533 			{ 7, "S-Video" }
534 		},
535 		.norms = V4L2_STD_NTSC | V4L2_STD_PAL,
536 		.tvn = {
537 			&f50ccir601_lml33,
538 			&f60ccir601_lml33,
539 			NULL
540 		},
541 		.jpeg_int = ZR36057_ISR_GIRQ1,
542 		.vsync_int = ZR36057_ISR_GIRQ0,
543 		.gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
544 		.gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
545 		.gpcs = { 3, 1 },
546 		.vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
547 		.gws_not_connected = 1,
548 		.input_mux = 0,
549 		.init = &lml33_init,
550 	}, {
551 		.type = LML33R10,
552 		.name = "LML33R10",
553 		.i2c_decoder = "saa7114",
554 		.addrs_decoder = saa7114_addrs,
555 		.i2c_encoder = "adv7170",
556 		.addrs_encoder = adv717x_addrs,
557 		.video_codec = CODEC_TYPE_ZR36060,
558 
559 		.inputs = 2,
560 		.input = {
561 			{ 0, "Composite" },
562 			{ 7, "S-Video" }
563 		},
564 		.norms = V4L2_STD_NTSC | V4L2_STD_PAL,
565 		.tvn = {
566 			&f50ccir601_lm33r10,
567 			&f60ccir601_lm33r10,
568 			NULL
569 		},
570 		.jpeg_int = ZR36057_ISR_GIRQ1,
571 		.vsync_int = ZR36057_ISR_GIRQ0,
572 		.gpio = { 1, -1, 3, 5, 7, -1, -1, -1 },
573 		.gpio_pol = { 0, 0, 0, 0, 1, 0, 0, 0 },
574 		.gpcs = { 3, 1 },
575 		.vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
576 		.gws_not_connected = 1,
577 		.input_mux = 0,
578 		.init = &lml33_init,
579 	}, {
580 		.type = BUZ,
581 		.name = "Buz",
582 		.i2c_decoder = "saa7111",
583 		.addrs_decoder = saa7111_addrs,
584 		.i2c_encoder = "saa7185",
585 		.addrs_encoder = saa7185_addrs,
586 		.video_codec = CODEC_TYPE_ZR36060,
587 
588 		.inputs = 2,
589 		.input = {
590 			{ 3, "Composite" },
591 			{ 7, "S-Video" }
592 		},
593 		.norms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM,
594 		.tvn = {
595 			&f50ccir601,
596 			&f60ccir601,
597 			&f50ccir601
598 		},
599 		.jpeg_int = ZR36057_ISR_GIRQ1,
600 		.vsync_int = ZR36057_ISR_GIRQ0,
601 		.gpio = { 1, -1, 3, -1, -1, -1, -1, -1 },
602 		.gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 },
603 		.gpcs = { 3, 1 },
604 		.vfe_pol = { 1, 1, 0, 0, 0, 1, 0, 0 },
605 		.gws_not_connected = 1,
606 		.input_mux = 0,
607 		.init = &buz_init,
608 	}, {
609 		.type = AVS6EYES,
610 		.name = "6-Eyes",
611 		/*
612 		 * AverMedia chose not to brand the 6-Eyes. Thus it can't be
613 		 * autodetected, and requires card=x.
614 		 */
615 		.i2c_decoder = "ks0127",
616 		.addrs_decoder = ks0127_addrs,
617 		.i2c_encoder = "bt866",
618 		.addrs_encoder = bt866_addrs,
619 		.video_codec = CODEC_TYPE_ZR36060,
620 
621 		.inputs = 10,
622 		.input = {
623 			{ 0, "Composite 1" },
624 			{ 1, "Composite 2" },
625 			{ 2, "Composite 3" },
626 			{ 4, "Composite 4" },
627 			{ 5, "Composite 5" },
628 			{ 6, "Composite 6" },
629 			{ 8, "S-Video 1" },
630 			{ 9, "S-Video 2" },
631 			{10, "S-Video 3" },
632 			{15, "YCbCr" }
633 		},
634 		.norms = V4L2_STD_NTSC | V4L2_STD_PAL,
635 		.tvn = {
636 			&f50ccir601_avs6eyes,
637 			&f60ccir601_avs6eyes,
638 			NULL
639 		},
640 		.jpeg_int = ZR36057_ISR_GIRQ1,
641 		.vsync_int = ZR36057_ISR_GIRQ0,
642 		.gpio = { 1, 0, 3, -1, -1, -1, -1, -1 },// Validity unknown /Sam
643 		.gpio_pol = { 0, 0, 0, 0, 0, 0, 0, 0 }, // Validity unknown /Sam
644 		.gpcs = { 3, 1 },			// Validity unknown /Sam
645 		.vfe_pol = { 1, 0, 0, 0, 0, 1, 0, 0 },  // Validity unknown /Sam
646 		.gws_not_connected = 1,
647 		.input_mux = 1,
648 		.init = &avs6eyes_init,
649 	}
650 
651 };
652 
653 /*
654  * I2C functions
655  */
656 /* software I2C functions */
zoran_i2c_getsda(void * data)657 static int zoran_i2c_getsda(void *data)
658 {
659 	struct zoran *zr = (struct zoran *)data;
660 
661 	return (btread(ZR36057_I2CBR) >> 1) & 1;
662 }
663 
zoran_i2c_getscl(void * data)664 static int zoran_i2c_getscl(void *data)
665 {
666 	struct zoran *zr = (struct zoran *)data;
667 
668 	return btread(ZR36057_I2CBR) & 1;
669 }
670 
zoran_i2c_setsda(void * data,int state)671 static void zoran_i2c_setsda(void *data, int state)
672 {
673 	struct zoran *zr = (struct zoran *)data;
674 
675 	if (state)
676 		zr->i2cbr |= 2;
677 	else
678 		zr->i2cbr &= ~2;
679 	btwrite(zr->i2cbr, ZR36057_I2CBR);
680 }
681 
zoran_i2c_setscl(void * data,int state)682 static void zoran_i2c_setscl(void *data, int state)
683 {
684 	struct zoran *zr = (struct zoran *)data;
685 
686 	if (state)
687 		zr->i2cbr |= 1;
688 	else
689 		zr->i2cbr &= ~1;
690 	btwrite(zr->i2cbr, ZR36057_I2CBR);
691 }
692 
693 static const struct i2c_algo_bit_data zoran_i2c_bit_data_template = {
694 	.setsda = zoran_i2c_setsda,
695 	.setscl = zoran_i2c_setscl,
696 	.getsda = zoran_i2c_getsda,
697 	.getscl = zoran_i2c_getscl,
698 	.udelay = 10,
699 	.timeout = 100,
700 };
701 
zoran_register_i2c(struct zoran * zr)702 static int zoran_register_i2c(struct zoran *zr)
703 {
704 	zr->i2c_algo = zoran_i2c_bit_data_template;
705 	zr->i2c_algo.data = zr;
706 	strscpy(zr->i2c_adapter.name, ZR_DEVNAME(zr),
707 		sizeof(zr->i2c_adapter.name));
708 	i2c_set_adapdata(&zr->i2c_adapter, &zr->v4l2_dev);
709 	zr->i2c_adapter.algo_data = &zr->i2c_algo;
710 	zr->i2c_adapter.dev.parent = &zr->pci_dev->dev;
711 	return i2c_bit_add_bus(&zr->i2c_adapter);
712 }
713 
zoran_unregister_i2c(struct zoran * zr)714 static void zoran_unregister_i2c(struct zoran *zr)
715 {
716 	i2c_del_adapter(&zr->i2c_adapter);
717 }
718 
719 /* Check a zoran_params struct for correctness, insert default params */
zoran_check_jpg_settings(struct zoran * zr,struct zoran_jpg_settings * settings,int try)720 int zoran_check_jpg_settings(struct zoran *zr,
721 			     struct zoran_jpg_settings *settings, int try)
722 {
723 	int err = 0, err0 = 0;
724 
725 	pci_dbg(zr->pci_dev, "%s - dec: %d, Hdcm: %d, Vdcm: %d, Tdcm: %d\n",
726 		__func__, settings->decimation, settings->hor_dcm,
727 		settings->ver_dcm, settings->tmp_dcm);
728 	pci_dbg(zr->pci_dev, "%s - x: %d, y: %d, w: %d, y: %d\n", __func__,
729 		settings->img_x, settings->img_y,
730 		settings->img_width, settings->img_height);
731 	/* Check decimation, set default values for decimation = 1, 2, 4 */
732 	switch (settings->decimation) {
733 	case 1:
734 
735 		settings->hor_dcm = 1;
736 		settings->ver_dcm = 1;
737 		settings->tmp_dcm = 1;
738 		settings->field_per_buff = 2;
739 		settings->img_x = 0;
740 		settings->img_y = 0;
741 		settings->img_width = BUZ_MAX_WIDTH;
742 		settings->img_height = BUZ_MAX_HEIGHT / 2;
743 		break;
744 	case 2:
745 
746 		settings->hor_dcm = 2;
747 		settings->ver_dcm = 1;
748 		settings->tmp_dcm = 2;
749 		settings->field_per_buff = 1;
750 		settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
751 		settings->img_y = 0;
752 		settings->img_width =
753 		    (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
754 		settings->img_height = BUZ_MAX_HEIGHT / 2;
755 		break;
756 	case 4:
757 
758 		if (zr->card.type == DC10_NEW) {
759 			pci_dbg(zr->pci_dev,
760 				"%s - HDec by 4 is not supported on the DC10\n",
761 				__func__);
762 			err0++;
763 			break;
764 		}
765 
766 		settings->hor_dcm = 4;
767 		settings->ver_dcm = 2;
768 		settings->tmp_dcm = 2;
769 		settings->field_per_buff = 1;
770 		settings->img_x = (BUZ_MAX_WIDTH == 720) ? 8 : 0;
771 		settings->img_y = 0;
772 		settings->img_width =
773 		    (BUZ_MAX_WIDTH == 720) ? 704 : BUZ_MAX_WIDTH;
774 		settings->img_height = BUZ_MAX_HEIGHT / 2;
775 		break;
776 	case 0:
777 
778 		/* We have to check the data the user has set */
779 
780 		if (settings->hor_dcm != 1 && settings->hor_dcm != 2 &&
781 		    (zr->card.type == DC10_NEW || settings->hor_dcm != 4)) {
782 			settings->hor_dcm = clamp(settings->hor_dcm, 1, 2);
783 			err0++;
784 		}
785 		if (settings->ver_dcm != 1 && settings->ver_dcm != 2) {
786 			settings->ver_dcm = clamp(settings->ver_dcm, 1, 2);
787 			err0++;
788 		}
789 		if (settings->tmp_dcm != 1 && settings->tmp_dcm != 2) {
790 			settings->tmp_dcm = clamp(settings->tmp_dcm, 1, 2);
791 			err0++;
792 		}
793 		if (settings->field_per_buff != 1 &&
794 		    settings->field_per_buff != 2) {
795 			settings->field_per_buff = clamp(settings->field_per_buff, 1, 2);
796 			err0++;
797 		}
798 		if (settings->img_x < 0) {
799 			settings->img_x = 0;
800 			err0++;
801 		}
802 		if (settings->img_y < 0) {
803 			settings->img_y = 0;
804 			err0++;
805 		}
806 		if (settings->img_width < 0 || settings->img_width > BUZ_MAX_WIDTH) {
807 			settings->img_width = clamp(settings->img_width, 0, (int)BUZ_MAX_WIDTH);
808 			err0++;
809 		}
810 		if (settings->img_height < 0 || settings->img_height > BUZ_MAX_HEIGHT / 2) {
811 			settings->img_height = clamp(settings->img_height, 0, BUZ_MAX_HEIGHT / 2);
812 			err0++;
813 		}
814 		if (settings->img_x + settings->img_width > BUZ_MAX_WIDTH) {
815 			settings->img_x = BUZ_MAX_WIDTH - settings->img_width;
816 			err0++;
817 		}
818 		if (settings->img_y + settings->img_height > BUZ_MAX_HEIGHT / 2) {
819 			settings->img_y = BUZ_MAX_HEIGHT / 2 - settings->img_height;
820 			err0++;
821 		}
822 		if (settings->img_width % (16 * settings->hor_dcm) != 0) {
823 			settings->img_width -= settings->img_width % (16 * settings->hor_dcm);
824 			if (settings->img_width == 0)
825 				settings->img_width = 16 * settings->hor_dcm;
826 			err0++;
827 		}
828 		if (settings->img_height % (8 * settings->ver_dcm) != 0) {
829 			settings->img_height -= settings->img_height % (8 * settings->ver_dcm);
830 			if (settings->img_height == 0)
831 				settings->img_height = 8 * settings->ver_dcm;
832 			err0++;
833 		}
834 
835 		if (!try && err0) {
836 			pci_err(zr->pci_dev, "%s - error in params for decimation = 0\n", __func__);
837 			err++;
838 		}
839 		break;
840 	default:
841 		pci_err(zr->pci_dev, "%s - decimation = %d, must be 0, 1, 2 or 4\n",
842 			__func__, settings->decimation);
843 		err++;
844 		break;
845 	}
846 
847 	if (settings->jpg_comp.quality > 100)
848 		settings->jpg_comp.quality = 100;
849 	if (settings->jpg_comp.quality < 5)
850 		settings->jpg_comp.quality = 5;
851 	if (settings->jpg_comp.APPn < 0)
852 		settings->jpg_comp.APPn = 0;
853 	if (settings->jpg_comp.APPn > 15)
854 		settings->jpg_comp.APPn = 15;
855 	if (settings->jpg_comp.APP_len < 0)
856 		settings->jpg_comp.APP_len = 0;
857 	if (settings->jpg_comp.APP_len > 60)
858 		settings->jpg_comp.APP_len = 60;
859 	if (settings->jpg_comp.COM_len < 0)
860 		settings->jpg_comp.COM_len = 0;
861 	if (settings->jpg_comp.COM_len > 60)
862 		settings->jpg_comp.COM_len = 60;
863 	if (err)
864 		return -EINVAL;
865 	return 0;
866 }
867 
zoran_init_video_device(struct zoran * zr,struct video_device * video_dev,int dir)868 static int zoran_init_video_device(struct zoran *zr, struct video_device *video_dev, int dir)
869 {
870 	int err;
871 
872 	/* Now add the template and register the device unit. */
873 	*video_dev = zoran_template;
874 	video_dev->v4l2_dev = &zr->v4l2_dev;
875 	video_dev->lock = &zr->lock;
876 	video_dev->device_caps = V4L2_CAP_STREAMING | dir;
877 
878 	strscpy(video_dev->name, ZR_DEVNAME(zr), sizeof(video_dev->name));
879 	video_dev->vfl_dir = VFL_DIR_RX;
880 	zoran_queue_init(zr, &zr->vq, V4L2_BUF_TYPE_VIDEO_CAPTURE);
881 
882 	err = video_register_device(video_dev, VFL_TYPE_VIDEO, video_nr[zr->id]);
883 	if (err < 0)
884 		return err;
885 	video_set_drvdata(video_dev, zr);
886 	return 0;
887 }
888 
zoran_exit_video_devices(struct zoran * zr)889 static void zoran_exit_video_devices(struct zoran *zr)
890 {
891 	video_unregister_device(zr->video_dev);
892 	kfree(zr->video_dev);
893 }
894 
zoran_init_video_devices(struct zoran * zr)895 static int zoran_init_video_devices(struct zoran *zr)
896 {
897 	int err;
898 
899 	zr->video_dev = video_device_alloc();
900 	if (!zr->video_dev)
901 		return -ENOMEM;
902 
903 	err = zoran_init_video_device(zr, zr->video_dev, V4L2_CAP_VIDEO_CAPTURE);
904 	if (err)
905 		kfree(zr->video_dev);
906 	return err;
907 }
908 
909 /*
910  * v4l2_device_unregister() will care about removing zr->encoder/zr->decoder
911  * via v4l2_i2c_subdev_unregister()
912  */
zoran_i2c_init(struct zoran * zr)913 static int zoran_i2c_init(struct zoran *zr)
914 {
915 	int err;
916 
917 	pci_info(zr->pci_dev, "Initializing i2c bus...\n");
918 
919 	err = zoran_register_i2c(zr);
920 	if (err) {
921 		pci_err(zr->pci_dev, "%s - cannot initialize i2c bus\n", __func__);
922 		return err;
923 	}
924 
925 	zr->decoder = v4l2_i2c_new_subdev(&zr->v4l2_dev, &zr->i2c_adapter,
926 					  zr->card.i2c_decoder, 0,
927 					  zr->card.addrs_decoder);
928 	if (!zr->decoder) {
929 		pci_err(zr->pci_dev, "Fail to get decoder %s\n", zr->card.i2c_decoder);
930 		err = -EINVAL;
931 		goto error_decoder;
932 	}
933 
934 	if (zr->card.i2c_encoder) {
935 		zr->encoder = v4l2_i2c_new_subdev(&zr->v4l2_dev, &zr->i2c_adapter,
936 						  zr->card.i2c_encoder, 0,
937 						  zr->card.addrs_encoder);
938 		if (!zr->encoder) {
939 			pci_err(zr->pci_dev, "Fail to get encoder %s\n", zr->card.i2c_encoder);
940 			err = -EINVAL;
941 			goto error_decoder;
942 		}
943 	}
944 	return 0;
945 
946 error_decoder:
947 	zoran_unregister_i2c(zr);
948 	return err;
949 }
950 
zoran_i2c_exit(struct zoran * zr)951 static void zoran_i2c_exit(struct zoran *zr)
952 {
953 	zoran_unregister_i2c(zr);
954 }
955 
zoran_open_init_params(struct zoran * zr)956 void zoran_open_init_params(struct zoran *zr)
957 {
958 	int i;
959 
960 	zr->v4l_settings.width = 192;
961 	zr->v4l_settings.height = 144;
962 	zr->v4l_settings.format = &zoran_formats[7];	/* YUY2 - YUV-4:2:2 packed */
963 	zr->v4l_settings.bytesperline = zr->v4l_settings.width *
964 		((zr->v4l_settings.format->depth + 7) / 8);
965 
966 	/* Set necessary params and call zoran_check_jpg_settings to set the defaults */
967 	zr->jpg_settings.decimation = 1;
968 	zr->jpg_settings.jpg_comp.quality = 50;	/* default compression factor 8 */
969 	if (zr->card.type != BUZ)
970 		zr->jpg_settings.odd_even = 1;
971 	else
972 		zr->jpg_settings.odd_even = 0;
973 	zr->jpg_settings.jpg_comp.APPn = 0;
974 	zr->jpg_settings.jpg_comp.APP_len = 0;	/* No APPn marker */
975 	memset(zr->jpg_settings.jpg_comp.APP_data, 0,
976 	       sizeof(zr->jpg_settings.jpg_comp.APP_data));
977 	zr->jpg_settings.jpg_comp.COM_len = 0;	/* No COM marker */
978 	memset(zr->jpg_settings.jpg_comp.COM_data, 0,
979 	       sizeof(zr->jpg_settings.jpg_comp.COM_data));
980 	zr->jpg_settings.jpg_comp.jpeg_markers =
981 	    V4L2_JPEG_MARKER_DHT | V4L2_JPEG_MARKER_DQT;
982 	i = zoran_check_jpg_settings(zr, &zr->jpg_settings, 0);
983 	if (i)
984 		pci_err(zr->pci_dev, "%s internal error\n", __func__);
985 
986 	zr->buffer_size = zr->v4l_settings.bytesperline * zr->v4l_settings.height;
987 
988 	clear_interrupt_counters(zr);
989 }
990 
zr36057_init(struct zoran * zr)991 static int zr36057_init(struct zoran *zr)
992 {
993 	int j, err;
994 
995 	pci_info(zr->pci_dev, "initializing card[%d]\n", zr->id);
996 
997 	/* Avoid nonsense settings from user for default input/norm */
998 	if (default_norm < 0 || default_norm > 2)
999 		default_norm = 0;
1000 	if (default_norm == 0) {
1001 		zr->norm = V4L2_STD_PAL;
1002 		zr->timing = zr->card.tvn[ZR_NORM_PAL];
1003 	} else if (default_norm == 1) {
1004 		zr->norm = V4L2_STD_NTSC;
1005 		zr->timing = zr->card.tvn[ZR_NORM_NTSC];
1006 	} else {
1007 		zr->norm = V4L2_STD_SECAM;
1008 		zr->timing = zr->card.tvn[ZR_NORM_SECAM];
1009 	}
1010 	if (!zr->timing) {
1011 		pci_warn(zr->pci_dev,
1012 			 "%s - default TV standard not supported by hardware. PAL will be used.\n",
1013 			 __func__);
1014 		zr->norm = V4L2_STD_PAL;
1015 		zr->timing = zr->card.tvn[ZR_NORM_PAL];
1016 	}
1017 
1018 	if (default_input > zr->card.inputs - 1) {
1019 		pci_warn(zr->pci_dev, "default_input value %d out of range (0-%d)\n",
1020 			 default_input, zr->card.inputs - 1);
1021 		default_input = 0;
1022 	}
1023 	zr->input = default_input;
1024 
1025 	/* default setup (will be repeated at every open) */
1026 	zoran_open_init_params(zr);
1027 
1028 	/* allocate memory *before* doing anything to the hardware in case allocation fails */
1029 	zr->stat_com = dma_alloc_coherent(&zr->pci_dev->dev,
1030 					  BUZ_NUM_STAT_COM * sizeof(u32),
1031 					  &zr->p_sc, GFP_KERNEL);
1032 	if (!zr->stat_com)
1033 		return -ENOMEM;
1034 
1035 	for (j = 0; j < BUZ_NUM_STAT_COM; j++)
1036 		zr->stat_com[j] = cpu_to_le32(1); /* mark as unavailable to zr36057 */
1037 
1038 	zr->stat_comb = dma_alloc_coherent(&zr->pci_dev->dev,
1039 					   BUZ_NUM_STAT_COM * sizeof(u32) * 2,
1040 					   &zr->p_scb, GFP_KERNEL);
1041 	if (!zr->stat_comb) {
1042 		err = -ENOMEM;
1043 		goto exit_statcom;
1044 	}
1045 
1046 	err = zoran_init_video_devices(zr);
1047 	if (err)
1048 		goto exit_statcomb;
1049 
1050 	zoran_init_hardware(zr);
1051 	if (!pass_through) {
1052 		decoder_call(zr, video, s_stream, 0);
1053 		encoder_call(zr, video, s_routing, 2, 0, 0);
1054 	}
1055 
1056 	zr->initialized = 1;
1057 	return 0;
1058 
1059 exit_statcomb:
1060 	dma_free_coherent(&zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32) * 2,
1061 			  zr->stat_comb, zr->p_scb);
1062 exit_statcom:
1063 	dma_free_coherent(&zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32),
1064 			  zr->stat_com, zr->p_sc);
1065 	return err;
1066 }
1067 
zoran_remove(struct pci_dev * pdev)1068 static void zoran_remove(struct pci_dev *pdev)
1069 {
1070 	struct v4l2_device *v4l2_dev = dev_get_drvdata(&pdev->dev);
1071 	struct zoran *zr = to_zoran(v4l2_dev);
1072 
1073 	if (!zr->initialized)
1074 		goto exit_free;
1075 
1076 	debugfs_remove_recursive(zr->dbgfs_dir);
1077 
1078 	zoran_queue_exit(zr);
1079 
1080 	/* unregister videocodec bus */
1081 	if (zr->codec)
1082 		videocodec_detach(zr->codec);
1083 	if (zr->vfe)
1084 		videocodec_detach(zr->vfe);
1085 	videocodec_exit(zr);
1086 
1087 	/* unregister i2c bus */
1088 	zoran_i2c_exit(zr);
1089 	/* disable PCI bus-mastering */
1090 	zoran_set_pci_master(zr, 0);
1091 	/* put chip into reset */
1092 	btwrite(0, ZR36057_SPGPPCR);
1093 	pci_free_irq(zr->pci_dev, 0, zr);
1094 	/* unmap and free memory */
1095 	dma_free_coherent(&zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32),
1096 			  zr->stat_com, zr->p_sc);
1097 	dma_free_coherent(&zr->pci_dev->dev, BUZ_NUM_STAT_COM * sizeof(u32) * 2,
1098 			  zr->stat_comb, zr->p_scb);
1099 	pci_release_regions(pdev);
1100 	pci_disable_device(zr->pci_dev);
1101 	zoran_exit_video_devices(zr);
1102 exit_free:
1103 	v4l2_ctrl_handler_free(&zr->hdl);
1104 	v4l2_device_unregister(&zr->v4l2_dev);
1105 }
1106 
zoran_vdev_release(struct video_device * vdev)1107 void zoran_vdev_release(struct video_device *vdev)
1108 {
1109 	kfree(vdev);
1110 }
1111 
zoran_setup_videocodec(struct zoran * zr,int type)1112 static struct videocodec_master *zoran_setup_videocodec(struct zoran *zr,
1113 							int type)
1114 {
1115 	struct videocodec_master *m = NULL;
1116 
1117 	m = devm_kmalloc(&zr->pci_dev->dev, sizeof(*m), GFP_KERNEL);
1118 	if (!m)
1119 		return m;
1120 
1121 	/*
1122 	 * magic and type are unused for master struct. Makes sense only at codec structs.
1123 	 * In the past, .type were initialized to the old V4L1 .hardware value,
1124 	 * as VID_HARDWARE_ZR36067
1125 	 */
1126 	m->magic = 0L;
1127 	m->type = 0;
1128 
1129 	m->flags = CODEC_FLAG_ENCODER | CODEC_FLAG_DECODER;
1130 	strscpy(m->name, ZR_DEVNAME(zr), sizeof(m->name));
1131 	m->data = zr;
1132 
1133 	switch (type) {
1134 	case CODEC_TYPE_ZR36060:
1135 		m->readreg = zr36060_read;
1136 		m->writereg = zr36060_write;
1137 		m->flags |= CODEC_FLAG_JPEG | CODEC_FLAG_VFE;
1138 		break;
1139 	case CODEC_TYPE_ZR36050:
1140 		m->readreg = zr36050_read;
1141 		m->writereg = zr36050_write;
1142 		m->flags |= CODEC_FLAG_JPEG;
1143 		break;
1144 	case CODEC_TYPE_ZR36016:
1145 		m->readreg = zr36016_read;
1146 		m->writereg = zr36016_write;
1147 		m->flags |= CODEC_FLAG_VFE;
1148 		break;
1149 	}
1150 
1151 	return m;
1152 }
1153 
zoran_subdev_notify(struct v4l2_subdev * sd,unsigned int cmd,void * arg)1154 static void zoran_subdev_notify(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1155 {
1156 	struct zoran *zr = to_zoran(sd->v4l2_dev);
1157 
1158 	/*
1159 	 * Bt819 needs to reset its FIFO buffer using #FRST pin and
1160 	 * LML33 card uses GPIO(7) for that.
1161 	 */
1162 	if (cmd == BT819_FIFO_RESET_LOW)
1163 		GPIO(zr, 7, 0);
1164 	else if (cmd == BT819_FIFO_RESET_HIGH)
1165 		GPIO(zr, 7, 1);
1166 }
1167 
zoran_video_set_ctrl(struct v4l2_ctrl * ctrl)1168 static int zoran_video_set_ctrl(struct v4l2_ctrl *ctrl)
1169 {
1170 	struct zoran *zr = container_of(ctrl->handler, struct zoran, hdl);
1171 
1172 	switch (ctrl->id) {
1173 	case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1174 		zr->jpg_settings.jpg_comp.quality = ctrl->val;
1175 		return zoran_check_jpg_settings(zr, &zr->jpg_settings, 0);
1176 	default:
1177 		return -EINVAL;
1178 	}
1179 
1180 	return 0;
1181 }
1182 
1183 static const struct v4l2_ctrl_ops zoran_video_ctrl_ops = {
1184 	.s_ctrl = zoran_video_set_ctrl,
1185 };
1186 
zoran_debugfs_show(struct seq_file * seq,void * v)1187 static int zoran_debugfs_show(struct seq_file *seq, void *v)
1188 {
1189 	struct zoran *zr = seq->private;
1190 
1191 	seq_printf(seq, "Running mode %x\n", zr->running);
1192 	seq_printf(seq, "Codec mode %x\n", zr->codec_mode);
1193 	seq_printf(seq, "Norm %llx\n", zr->norm);
1194 	seq_printf(seq, "Input %d\n", zr->input);
1195 	seq_printf(seq, "Buffersize %d\n", zr->buffer_size);
1196 
1197 	seq_printf(seq, "V4L width %dx%d\n", zr->v4l_settings.width, zr->v4l_settings.height);
1198 	seq_printf(seq, "V4L bytesperline %d\n", zr->v4l_settings.bytesperline);
1199 
1200 	seq_printf(seq, "JPG decimation %u\n", zr->jpg_settings.decimation);
1201 	seq_printf(seq, "JPG hor_dcm %u\n", zr->jpg_settings.hor_dcm);
1202 	seq_printf(seq, "JPG ver_dcm %u\n", zr->jpg_settings.ver_dcm);
1203 	seq_printf(seq, "JPG tmp_dcm %u\n", zr->jpg_settings.tmp_dcm);
1204 	seq_printf(seq, "JPG odd_even %u\n", zr->jpg_settings.odd_even);
1205 	seq_printf(seq, "JPG crop %dx%d %d %d\n",
1206 		   zr->jpg_settings.img_x,
1207 		   zr->jpg_settings.img_y,
1208 		   zr->jpg_settings.img_width,
1209 		   zr->jpg_settings.img_height);
1210 
1211 	seq_printf(seq, "Prepared %u\n", zr->prepared);
1212 	seq_printf(seq, "Queued %u\n", zr->queued);
1213 
1214 	videocodec_debugfs_show(seq);
1215 	return 0;
1216 }
1217 
1218 DEFINE_SHOW_ATTRIBUTE(zoran_debugfs);
1219 
1220 /*
1221  *   Scan for a Buz card (actually for the PCI controller ZR36057),
1222  *   request the irq and map the io memory
1223  */
zoran_probe(struct pci_dev * pdev,const struct pci_device_id * ent)1224 static int zoran_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
1225 {
1226 	unsigned char latency, need_latency;
1227 	struct zoran *zr;
1228 	int result;
1229 	struct videocodec_master *master_vfe = NULL;
1230 	struct videocodec_master *master_codec = NULL;
1231 	int card_num;
1232 	unsigned int nr;
1233 	int err;
1234 
1235 	pci_info(pdev, "Zoran MJPEG board driver version %s\n", ZORAN_VERSION);
1236 
1237 	/* some mainboards might not do PCI-PCI data transfer well */
1238 	if (pci_pci_problems & (PCIPCI_FAIL | PCIAGP_FAIL | PCIPCI_ALIMAGIK))
1239 		pci_warn(pdev, "%s: chipset does not support reliable PCI-PCI DMA\n",
1240 			 ZORAN_NAME);
1241 
1242 	err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
1243 	if (err)
1244 		return err;
1245 	err = vb2_dma_contig_set_max_seg_size(&pdev->dev, U32_MAX);
1246 	if (err)
1247 		return err;
1248 
1249 	nr = zoran_num++;
1250 	if (nr >= BUZ_MAX) {
1251 		pci_err(pdev, "driver limited to %d card(s) maximum\n", BUZ_MAX);
1252 		return -ENOENT;
1253 	}
1254 
1255 	zr = devm_kzalloc(&pdev->dev, sizeof(*zr), GFP_KERNEL);
1256 	if (!zr)
1257 		return -ENOMEM;
1258 
1259 	zr->v4l2_dev.notify = zoran_subdev_notify;
1260 	if (v4l2_device_register(&pdev->dev, &zr->v4l2_dev))
1261 		goto zr_free_mem;
1262 	zr->pci_dev = pdev;
1263 	zr->id = nr;
1264 	snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "MJPEG[%u]", zr->id);
1265 	if (v4l2_ctrl_handler_init(&zr->hdl, 10))
1266 		goto zr_unreg;
1267 	zr->v4l2_dev.ctrl_handler = &zr->hdl;
1268 	v4l2_ctrl_new_std(&zr->hdl, &zoran_video_ctrl_ops,
1269 			  V4L2_CID_JPEG_COMPRESSION_QUALITY, 0,
1270 			  100, 1, 50);
1271 	spin_lock_init(&zr->spinlock);
1272 	mutex_init(&zr->lock);
1273 	if (pci_enable_device(pdev))
1274 		goto zr_unreg;
1275 	zr->revision = zr->pci_dev->revision;
1276 
1277 	pci_info(zr->pci_dev, "Zoran ZR360%c7 (rev %d), irq: %d, memory: 0x%08llx\n",
1278 		 zr->revision < 2 ? '5' : '6', zr->revision,
1279 		 zr->pci_dev->irq, (uint64_t)pci_resource_start(zr->pci_dev, 0));
1280 	if (zr->revision >= 2)
1281 		pci_info(zr->pci_dev, "Subsystem vendor=0x%04x id=0x%04x\n",
1282 			 zr->pci_dev->subsystem_vendor, zr->pci_dev->subsystem_device);
1283 
1284 	/* Use auto-detected card type? */
1285 	if (card[nr] == -1) {
1286 		if (zr->revision < 2) {
1287 			pci_err(pdev, "No card type specified, please use the card=X module parameter\n");
1288 			pci_err(pdev, "It is not possible to auto-detect ZR36057 based cards\n");
1289 			goto zr_unreg;
1290 		}
1291 
1292 		card_num = ent->driver_data;
1293 		if (card_num >= NUM_CARDS) {
1294 			pci_err(pdev, "Unknown card, try specifying card=X module parameter\n");
1295 			goto zr_unreg;
1296 		}
1297 		pci_info(zr->pci_dev, "%s() - card %s detected\n", __func__,
1298 			 zoran_cards[card_num].name);
1299 	} else {
1300 		card_num = card[nr];
1301 		if (card_num >= NUM_CARDS || card_num < 0) {
1302 			pci_err(pdev, "User specified card type %d out of range (0 .. %d)\n",
1303 				card_num, NUM_CARDS - 1);
1304 			goto zr_unreg;
1305 		}
1306 	}
1307 
1308 	/*
1309 	 * even though we make this a non pointer and thus
1310 	 * theoretically allow for making changes to this struct
1311 	 * on a per-individual card basis at runtime, this is
1312 	 * strongly discouraged. This structure is intended to
1313 	 * keep general card information, no settings or anything
1314 	 */
1315 	zr->card = zoran_cards[card_num];
1316 	snprintf(ZR_DEVNAME(zr), sizeof(ZR_DEVNAME(zr)), "%s[%u]",
1317 		 zr->card.name, zr->id);
1318 
1319 	err = pci_request_regions(pdev, ZR_DEVNAME(zr));
1320 	if (err)
1321 		goto zr_unreg;
1322 
1323 	zr->zr36057_mem = devm_ioremap(&pdev->dev, pci_resource_start(pdev, 0),
1324 				       pci_resource_len(pdev, 0));
1325 	if (!zr->zr36057_mem) {
1326 		pci_err(pdev, "%s() - ioremap failed\n", __func__);
1327 		goto zr_pci_release;
1328 	}
1329 
1330 	result = pci_request_irq(pdev, 0, zoran_irq, NULL, zr, ZR_DEVNAME(zr));
1331 	if (result < 0) {
1332 		if (result == -EINVAL) {
1333 			pci_err(pdev, "%s - bad IRQ number or handler\n", __func__);
1334 		} else if (result == -EBUSY) {
1335 			pci_err(pdev, "%s - IRQ %d busy, change your PnP config in BIOS\n",
1336 				__func__, zr->pci_dev->irq);
1337 		} else {
1338 			pci_err(pdev, "%s - cannot assign IRQ, error code %d\n", __func__, result);
1339 		}
1340 		goto zr_pci_release;
1341 	}
1342 
1343 	/* set PCI latency timer */
1344 	pci_read_config_byte(zr->pci_dev, PCI_LATENCY_TIMER,
1345 			     &latency);
1346 	need_latency = zr->revision > 1 ? 32 : 48;
1347 	if (latency != need_latency) {
1348 		pci_info(zr->pci_dev, "Changing PCI latency from %d to %d\n",
1349 			 latency, need_latency);
1350 		pci_write_config_byte(zr->pci_dev, PCI_LATENCY_TIMER, need_latency);
1351 	}
1352 
1353 	zr36057_restart(zr);
1354 
1355 	err = zoran_i2c_init(zr);
1356 	if (err)
1357 		goto zr_free_irq;
1358 
1359 	pci_info(zr->pci_dev, "Initializing videocodec bus...\n");
1360 	err = videocodec_init(zr);
1361 	if (err)
1362 		goto zr_unreg_i2c;
1363 
1364 	/* reset JPEG codec */
1365 	jpeg_codec_sleep(zr, 1);
1366 	jpeg_codec_reset(zr);
1367 	/* video bus enabled */
1368 	/* display codec revision */
1369 	if (zr->card.video_codec != 0) {
1370 		master_codec = zoran_setup_videocodec(zr, zr->card.video_codec);
1371 		if (!master_codec)
1372 			goto zr_unreg_videocodec;
1373 		zr->codec = videocodec_attach(master_codec);
1374 		if (!zr->codec) {
1375 			pci_err(pdev, "%s - no codec found\n", __func__);
1376 			goto zr_unreg_videocodec;
1377 		}
1378 		if (zr->codec->type != zr->card.video_codec) {
1379 			pci_err(pdev, "%s - wrong codec\n", __func__);
1380 			goto zr_unreg_videocodec;
1381 		}
1382 	}
1383 	if (zr->card.video_vfe != 0) {
1384 		master_vfe = zoran_setup_videocodec(zr, zr->card.video_vfe);
1385 		if (!master_vfe)
1386 			goto zr_detach_codec;
1387 		zr->vfe = videocodec_attach(master_vfe);
1388 		if (!zr->vfe) {
1389 			pci_err(pdev, "%s - no VFE found\n", __func__);
1390 			goto zr_detach_codec;
1391 		}
1392 		if (zr->vfe->type != zr->card.video_vfe) {
1393 			pci_err(pdev, "%s = wrong VFE\n", __func__);
1394 			goto zr_detach_vfe;
1395 		}
1396 	}
1397 
1398 	/* take care of Natoma chipset and a revision 1 zr36057 */
1399 	if ((pci_pci_problems & PCIPCI_NATOMA) && zr->revision <= 1)
1400 		pci_info(zr->pci_dev, "ZR36057/Natoma bug, max. buffer size is 128K\n");
1401 
1402 	if (zr36057_init(zr) < 0)
1403 		goto zr_detach_vfe;
1404 
1405 	zr->map_mode = ZORAN_MAP_MODE_RAW;
1406 
1407 	zr->dbgfs_dir = debugfs_create_dir(ZR_DEVNAME(zr), NULL);
1408 	debugfs_create_file("debug", 0444, zr->dbgfs_dir, zr,
1409 			    &zoran_debugfs_fops);
1410 	return 0;
1411 
1412 zr_detach_vfe:
1413 	videocodec_detach(zr->vfe);
1414 zr_detach_codec:
1415 	videocodec_detach(zr->codec);
1416 zr_unreg_videocodec:
1417 	videocodec_exit(zr);
1418 zr_unreg_i2c:
1419 	zoran_i2c_exit(zr);
1420 zr_free_irq:
1421 	btwrite(0, ZR36057_SPGPPCR);
1422 	pci_free_irq(zr->pci_dev, 0, zr);
1423 zr_pci_release:
1424 	pci_release_regions(pdev);
1425 zr_unreg:
1426 	v4l2_ctrl_handler_free(&zr->hdl);
1427 	v4l2_device_unregister(&zr->v4l2_dev);
1428 zr_free_mem:
1429 
1430 	return -ENODEV;
1431 }
1432 
1433 static struct pci_driver zoran_driver = {
1434 	.name = "zr36067",
1435 	.id_table = zr36067_pci_tbl,
1436 	.probe = zoran_probe,
1437 	.remove = zoran_remove,
1438 };
1439 
1440 module_pci_driver(zoran_driver);
1441