zoran_card.c

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