cx88-blackbird.c 33.8 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5
/*
 *
 *  Support for a cx23416 mpeg encoder via cx2388x host port.
 *  "blackbird" reference design.
 *
6
 *    (c) 2004 Jelle Foks <jelle@foks.us>
Linus Torvalds's avatar
Linus Torvalds committed
7 8
 *    (c) 2004 Gerd Knorr <kraxel@bytesex.org>
 *
9 10 11
 *    (c) 2005-2006 Mauro Carvalho Chehab <mchehab@infradead.org>
 *        - video_ioctl2 conversion
 *
12
 *  Includes parts from the ivtv driver <http://sourceforge.net/projects/ivtv/>
Linus Torvalds's avatar
Linus Torvalds committed
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/module.h>
#include <linux/init.h>
31
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
32 33 34 35
#include <linux/fs.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/firmware.h>
36
#include <media/v4l2-common.h>
37
#include <media/v4l2-ioctl.h>
38
#include <media/v4l2-event.h>
39
#include <media/cx2341x.h>
Linus Torvalds's avatar
Linus Torvalds committed
40 41 42 43

#include "cx88.h"

MODULE_DESCRIPTION("driver for cx2388x/cx23416 based mpeg encoder cards");
44
MODULE_AUTHOR("Jelle Foks <jelle@foks.us>, Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
Linus Torvalds's avatar
Linus Torvalds committed
45
MODULE_LICENSE("GPL");
46
MODULE_VERSION(CX88_VERSION);
Linus Torvalds's avatar
Linus Torvalds committed
47

48
static unsigned int debug;
Linus Torvalds's avatar
Linus Torvalds committed
49 50 51
module_param(debug,int,0644);
MODULE_PARM_DESC(debug,"enable debug messages [blackbird]");

52 53 54 55
#define dprintk(level, fmt, arg...) do {				      \
	if (debug + 1 > level)						      \
		printk(KERN_DEBUG "%s/2-bb: " fmt, dev->core->name , ## arg); \
} while(0)
Linus Torvalds's avatar
Linus Torvalds committed
56 57 58

/* ------------------------------------------------------------------ */

59
#define BLACKBIRD_FIRM_IMAGE_SIZE 376836
Linus Torvalds's avatar
Linus Torvalds committed
60 61 62 63 64

/* defines below are from ivtv-driver.h */

#define IVTV_CMD_HW_BLOCKS_RST 0xFFFFFFFF

65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
/* Firmware API commands */
#define IVTV_API_STD_TIMEOUT 500

enum blackbird_capture_type {
	BLACKBIRD_MPEG_CAPTURE,
	BLACKBIRD_RAW_CAPTURE,
	BLACKBIRD_RAW_PASSTHRU_CAPTURE
};
enum blackbird_capture_bits {
	BLACKBIRD_RAW_BITS_NONE             = 0x00,
	BLACKBIRD_RAW_BITS_YUV_CAPTURE      = 0x01,
	BLACKBIRD_RAW_BITS_PCM_CAPTURE      = 0x02,
	BLACKBIRD_RAW_BITS_VBI_CAPTURE      = 0x04,
	BLACKBIRD_RAW_BITS_PASSTHRU_CAPTURE = 0x08,
	BLACKBIRD_RAW_BITS_TO_HOST_CAPTURE  = 0x10
};
enum blackbird_capture_end {
	BLACKBIRD_END_AT_GOP, /* stop at the end of gop, generate irq */
	BLACKBIRD_END_NOW, /* stop immediately, no irq */
};
enum blackbird_framerate {
	BLACKBIRD_FRAMERATE_NTSC_30, /* NTSC: 30fps */
	BLACKBIRD_FRAMERATE_PAL_25   /* PAL: 25fps */
};
enum blackbird_stream_port {
	BLACKBIRD_OUTPUT_PORT_MEMORY,
	BLACKBIRD_OUTPUT_PORT_STREAMING,
	BLACKBIRD_OUTPUT_PORT_SERIAL
};
enum blackbird_data_xfer_status {
	BLACKBIRD_MORE_BUFFERS_FOLLOW,
	BLACKBIRD_LAST_BUFFER,
};
enum blackbird_picture_mask {
	BLACKBIRD_PICTURE_MASK_NONE,
	BLACKBIRD_PICTURE_MASK_I_FRAMES,
	BLACKBIRD_PICTURE_MASK_I_P_FRAMES = 0x3,
	BLACKBIRD_PICTURE_MASK_ALL_FRAMES = 0x7,
};
enum blackbird_vbi_mode_bits {
	BLACKBIRD_VBI_BITS_SLICED,
	BLACKBIRD_VBI_BITS_RAW,
};
enum blackbird_vbi_insertion_bits {
	BLACKBIRD_VBI_BITS_INSERT_IN_XTENSION_USR_DATA,
	BLACKBIRD_VBI_BITS_INSERT_IN_PRIVATE_PACKETS = 0x1 << 1,
	BLACKBIRD_VBI_BITS_SEPARATE_STREAM = 0x2 << 1,
	BLACKBIRD_VBI_BITS_SEPARATE_STREAM_USR_DATA = 0x4 << 1,
	BLACKBIRD_VBI_BITS_SEPARATE_STREAM_PRV_DATA = 0x5 << 1,
};
enum blackbird_dma_unit {
	BLACKBIRD_DMA_BYTES,
	BLACKBIRD_DMA_FRAMES,
};
enum blackbird_dma_transfer_status_bits {
	BLACKBIRD_DMA_TRANSFER_BITS_DONE = 0x01,
	BLACKBIRD_DMA_TRANSFER_BITS_ERROR = 0x04,
	BLACKBIRD_DMA_TRANSFER_BITS_LL_ERROR = 0x10,
};
enum blackbird_pause {
	BLACKBIRD_PAUSE_ENCODING,
	BLACKBIRD_RESUME_ENCODING,
};
enum blackbird_copyright {
	BLACKBIRD_COPYRIGHT_OFF,
	BLACKBIRD_COPYRIGHT_ON,
};
enum blackbird_notification_type {
	BLACKBIRD_NOTIFICATION_REFRESH,
};
enum blackbird_notification_status {
	BLACKBIRD_NOTIFICATION_OFF,
	BLACKBIRD_NOTIFICATION_ON,
};
enum blackbird_notification_mailbox {
	BLACKBIRD_NOTIFICATION_NO_MAILBOX = -1,
};
enum blackbird_field1_lines {
	BLACKBIRD_FIELD1_SAA7114 = 0x00EF, /* 239 */
	BLACKBIRD_FIELD1_SAA7115 = 0x00F0, /* 240 */
	BLACKBIRD_FIELD1_MICRONAS = 0x0105, /* 261 */
};
enum blackbird_field2_lines {
	BLACKBIRD_FIELD2_SAA7114 = 0x00EF, /* 239 */
	BLACKBIRD_FIELD2_SAA7115 = 0x00F0, /* 240 */
	BLACKBIRD_FIELD2_MICRONAS = 0x0106, /* 262 */
};
enum blackbird_custom_data_type {
	BLACKBIRD_CUSTOM_EXTENSION_USR_DATA,
	BLACKBIRD_CUSTOM_PRIVATE_PACKET,
};
enum blackbird_mute {
	BLACKBIRD_UNMUTE,
	BLACKBIRD_MUTE,
};
enum blackbird_mute_video_mask {
	BLACKBIRD_MUTE_VIDEO_V_MASK = 0x0000FF00,
	BLACKBIRD_MUTE_VIDEO_U_MASK = 0x00FF0000,
	BLACKBIRD_MUTE_VIDEO_Y_MASK = 0xFF000000,
};
enum blackbird_mute_video_shift {
	BLACKBIRD_MUTE_VIDEO_V_SHIFT = 8,
	BLACKBIRD_MUTE_VIDEO_U_SHIFT = 16,
	BLACKBIRD_MUTE_VIDEO_Y_SHIFT = 24,
};
Linus Torvalds's avatar
Linus Torvalds committed
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248

/* Registers */
#define IVTV_REG_ENC_SDRAM_REFRESH (0x07F8 /*| IVTV_REG_OFFSET*/)
#define IVTV_REG_ENC_SDRAM_PRECHARGE (0x07FC /*| IVTV_REG_OFFSET*/)
#define IVTV_REG_SPU (0x9050 /*| IVTV_REG_OFFSET*/)
#define IVTV_REG_HW_BLOCKS (0x9054 /*| IVTV_REG_OFFSET*/)
#define IVTV_REG_VPU (0x9058 /*| IVTV_REG_OFFSET*/)
#define IVTV_REG_APU (0xA064 /*| IVTV_REG_OFFSET*/)

/* ------------------------------------------------------------------ */

static void host_setup(struct cx88_core *core)
{
	/* toggle reset of the host */
	cx_write(MO_GPHST_SOFT_RST, 1);
	udelay(100);
	cx_write(MO_GPHST_SOFT_RST, 0);
	udelay(100);

	/* host port setup */
	cx_write(MO_GPHST_WSC, 0x44444444U);
	cx_write(MO_GPHST_XFR, 0);
	cx_write(MO_GPHST_WDTH, 15);
	cx_write(MO_GPHST_HDSHK, 0);
	cx_write(MO_GPHST_MUX16, 0x44448888U);
	cx_write(MO_GPHST_MODE, 0);
}

/* ------------------------------------------------------------------ */

#define P1_MDATA0 0x390000
#define P1_MDATA1 0x390001
#define P1_MDATA2 0x390002
#define P1_MDATA3 0x390003
#define P1_MADDR2 0x390004
#define P1_MADDR1 0x390005
#define P1_MADDR0 0x390006
#define P1_RDATA0 0x390008
#define P1_RDATA1 0x390009
#define P1_RDATA2 0x39000A
#define P1_RDATA3 0x39000B
#define P1_RADDR0 0x39000C
#define P1_RADDR1 0x39000D
#define P1_RRDWR  0x39000E

static int wait_ready_gpio0_bit1(struct cx88_core *core, u32 state)
{
	unsigned long timeout = jiffies + msecs_to_jiffies(1);
	u32 gpio0,need;

	need = state ? 2 : 0;
	for (;;) {
		gpio0 = cx_read(MO_GP0_IO) & 2;
		if (need == gpio0)
			return 0;
		if (time_after(jiffies,timeout))
			return -1;
		udelay(1);
	}
}

static int memory_write(struct cx88_core *core, u32 address, u32 value)
{
	/* Warning: address is dword address (4 bytes) */
	cx_writeb(P1_MDATA0, (unsigned int)value);
	cx_writeb(P1_MDATA1, (unsigned int)(value >> 8));
	cx_writeb(P1_MDATA2, (unsigned int)(value >> 16));
	cx_writeb(P1_MDATA3, (unsigned int)(value >> 24));
	cx_writeb(P1_MADDR2, (unsigned int)(address >> 16) | 0x40);
	cx_writeb(P1_MADDR1, (unsigned int)(address >> 8));
	cx_writeb(P1_MADDR0, (unsigned int)address);
	cx_read(P1_MDATA0);
	cx_read(P1_MADDR0);

	return wait_ready_gpio0_bit1(core,1);
}

static int memory_read(struct cx88_core *core, u32 address, u32 *value)
{
249
	int retval;
Linus Torvalds's avatar
Linus Torvalds committed
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
	u32 val;

	/* Warning: address is dword address (4 bytes) */
	cx_writeb(P1_MADDR2, (unsigned int)(address >> 16) & ~0xC0);
	cx_writeb(P1_MADDR1, (unsigned int)(address >> 8));
	cx_writeb(P1_MADDR0, (unsigned int)address);
	cx_read(P1_MADDR0);

	retval = wait_ready_gpio0_bit1(core,1);

	cx_writeb(P1_MDATA3, 0);
	val     = (unsigned char)cx_read(P1_MDATA3) << 24;
	cx_writeb(P1_MDATA2, 0);
	val    |= (unsigned char)cx_read(P1_MDATA2) << 16;
	cx_writeb(P1_MDATA1, 0);
	val    |= (unsigned char)cx_read(P1_MDATA1) << 8;
	cx_writeb(P1_MDATA0, 0);
	val    |= (unsigned char)cx_read(P1_MDATA0);

	*value  = val;
	return retval;
}

static int register_write(struct cx88_core *core, u32 address, u32 value)
{
	cx_writeb(P1_RDATA0, (unsigned int)value);
	cx_writeb(P1_RDATA1, (unsigned int)(value >> 8));
	cx_writeb(P1_RDATA2, (unsigned int)(value >> 16));
	cx_writeb(P1_RDATA3, (unsigned int)(value >> 24));
	cx_writeb(P1_RADDR0, (unsigned int)address);
	cx_writeb(P1_RADDR1, (unsigned int)(address >> 8));
	cx_writeb(P1_RRDWR, 1);
	cx_read(P1_RDATA0);
	cx_read(P1_RADDR0);

	return wait_ready_gpio0_bit1(core,1);
}


static int register_read(struct cx88_core *core, u32 address, u32 *value)
{
	int retval;
	u32 val;

	cx_writeb(P1_RADDR0, (unsigned int)address);
	cx_writeb(P1_RADDR1, (unsigned int)(address >> 8));
	cx_writeb(P1_RRDWR, 0);
	cx_read(P1_RADDR0);

	retval  = wait_ready_gpio0_bit1(core,1);
	val     = (unsigned char)cx_read(P1_RDATA0);
	val    |= (unsigned char)cx_read(P1_RDATA1) << 8;
	val    |= (unsigned char)cx_read(P1_RDATA2) << 16;
	val    |= (unsigned char)cx_read(P1_RDATA3) << 24;

	*value  = val;
	return retval;
}

/* ------------------------------------------------------------------ */

311
static int blackbird_mbox_func(void *priv, u32 command, int in, int out, u32 data[CX2341X_MBOX_MAX_DATA])
Linus Torvalds's avatar
Linus Torvalds committed
312
{
313
	struct cx8802_dev *dev = priv;
Linus Torvalds's avatar
Linus Torvalds committed
314 315 316 317
	unsigned long timeout;
	u32 value, flag, retval;
	int i;

318
	dprintk(1,"%s: 0x%X\n", __func__, command);
Linus Torvalds's avatar
Linus Torvalds committed
319 320 321 322 323 324

	/* this may not be 100% safe if we can't read any memory location
	   without side effects */
	memory_read(dev->core, dev->mailbox - 4, &value);
	if (value != 0x12345678) {
		dprintk(0, "Firmware and/or mailbox pointer not initialized or corrupted\n");
325
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
326 327 328 329 330
	}

	memory_read(dev->core, dev->mailbox, &flag);
	if (flag) {
		dprintk(0, "ERROR: Mailbox appears to be in use (%x)\n", flag);
331
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
332 333 334 335 336 337 338 339
	}

	flag |= 1; /* tell 'em we're working on it */
	memory_write(dev->core, dev->mailbox, flag);

	/* write command + args + fill remaining with zeros */
	memory_write(dev->core, dev->mailbox + 1, command); /* command code */
	memory_write(dev->core, dev->mailbox + 3, IVTV_API_STD_TIMEOUT); /* timeout */
340 341 342
	for (i = 0; i < in; i++) {
		memory_write(dev->core, dev->mailbox + 4 + i, data[i]);
		dprintk(1, "API Input %d = %d\n", i, data[i]);
Linus Torvalds's avatar
Linus Torvalds committed
343
	}
344
	for (; i < CX2341X_MBOX_MAX_DATA; i++)
Linus Torvalds's avatar
Linus Torvalds committed
345 346 347 348 349 350 351 352 353 354 355 356
		memory_write(dev->core, dev->mailbox + 4 + i, 0);

	flag |= 3; /* tell 'em we're done writing */
	memory_write(dev->core, dev->mailbox, flag);

	/* wait for firmware to handle the API command */
	timeout = jiffies + msecs_to_jiffies(10);
	for (;;) {
		memory_read(dev->core, dev->mailbox, &flag);
		if (0 != (flag & 4))
			break;
		if (time_after(jiffies,timeout)) {
357 358
			dprintk(0, "ERROR: API Mailbox timeout %x\n", command);
			return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
359 360 361 362 363
		}
		udelay(10);
	}

	/* read output values */
364 365 366
	for (i = 0; i < out; i++) {
		memory_read(dev->core, dev->mailbox + 4 + i, data + i);
		dprintk(1, "API Output %d = %d\n", i, data[i]);
Linus Torvalds's avatar
Linus Torvalds committed
367 368 369 370 371 372 373 374 375
	}

	memory_read(dev->core, dev->mailbox + 2, &retval);
	dprintk(1, "API result = %d\n",retval);

	flag = 0;
	memory_write(dev->core, dev->mailbox, flag);
	return retval;
}
376
/* ------------------------------------------------------------------ */
Linus Torvalds's avatar
Linus Torvalds committed
377

378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
/* We don't need to call the API often, so using just one mailbox will probably suffice */
static int blackbird_api_cmd(struct cx8802_dev *dev, u32 command,
			     u32 inputcnt, u32 outputcnt, ...)
{
	u32 data[CX2341X_MBOX_MAX_DATA];
	va_list vargs;
	int i, err;

	va_start(vargs, outputcnt);

	for (i = 0; i < inputcnt; i++) {
		data[i] = va_arg(vargs, int);
	}
	err = blackbird_mbox_func(dev, command, inputcnt, outputcnt, data);
	for (i = 0; i < outputcnt; i++) {
		int *vptr = va_arg(vargs, int *);
		*vptr = data[i];
	}
	va_end(vargs);
	return err;
}
Linus Torvalds's avatar
Linus Torvalds committed
399 400 401 402 403 404 405 406

static int blackbird_find_mailbox(struct cx8802_dev *dev)
{
	u32 signature[4]={0x12345678, 0x34567812, 0x56781234, 0x78123456};
	int signaturecnt=0;
	u32 value;
	int i;

407
	for (i = 0; i < BLACKBIRD_FIRM_IMAGE_SIZE; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
408 409 410 411 412 413 414 415 416 417 418
		memory_read(dev->core, i, &value);
		if (value == signature[signaturecnt])
			signaturecnt++;
		else
			signaturecnt = 0;
		if (4 == signaturecnt) {
			dprintk(1, "Mailbox signature found\n");
			return i+1;
		}
	}
	dprintk(0, "Mailbox signature values not found!\n");
419
	return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
420 421 422 423 424 425 426 427 428 429 430
}

static int blackbird_load_firmware(struct cx8802_dev *dev)
{
	static const unsigned char magic[8] = {
		0xa7, 0x0d, 0x00, 0x00, 0x66, 0xbb, 0x55, 0xaa
	};
	const struct firmware *firmware;
	int i, retval = 0;
	u32 value = 0;
	u32 checksum = 0;
431
	__le32 *dataptr;
Linus Torvalds's avatar
Linus Torvalds committed
432 433

	retval  = register_write(dev->core, IVTV_REG_VPU, 0xFFFFFFED);
434 435 436
	retval |= register_write(dev->core, IVTV_REG_HW_BLOCKS, IVTV_CMD_HW_BLOCKS_RST);
	retval |= register_write(dev->core, IVTV_REG_ENC_SDRAM_REFRESH, 0x80000640);
	retval |= register_write(dev->core, IVTV_REG_ENC_SDRAM_PRECHARGE, 0x1A);
Linus Torvalds's avatar
Linus Torvalds committed
437
	msleep(1);
438
	retval |= register_write(dev->core, IVTV_REG_APU, 0);
Linus Torvalds's avatar
Linus Torvalds committed
439 440 441 442

	if (retval < 0)
		dprintk(0, "Error with register_write\n");

443
	retval = request_firmware(&firmware, CX2341X_FIRM_ENC_FILENAME,
Linus Torvalds's avatar
Linus Torvalds committed
444
				  &dev->pci->dev);
445 446


Linus Torvalds's avatar
Linus Torvalds committed
447
	if (retval != 0) {
448
		pr_err("Hotplug firmware request failed (%s).\n",
449
			CX2341X_FIRM_ENC_FILENAME);
450 451
		pr_err("Please fix your hotplug setup, the board will not work without firmware loaded!\n");
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
452 453
	}

454
	if (firmware->size != BLACKBIRD_FIRM_IMAGE_SIZE) {
455
		pr_err("Firmware size mismatch (have %zd, expected %d)\n",
456
			firmware->size, BLACKBIRD_FIRM_IMAGE_SIZE);
457
		release_firmware(firmware);
458
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
459 460 461
	}

	if (0 != memcmp(firmware->data, magic, 8)) {
462
		pr_err("Firmware magic mismatch, wrong file?\n");
463
		release_firmware(firmware);
464
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
465 466 467 468
	}

	/* transfer to the chip */
	dprintk(1,"Loading firmware ...\n");
469
	dataptr = (__le32 *)firmware->data;
Linus Torvalds's avatar
Linus Torvalds committed
470
	for (i = 0; i < (firmware->size >> 2); i++) {
471
		value = le32_to_cpu(*dataptr);
Linus Torvalds's avatar
Linus Torvalds committed
472 473 474 475 476 477 478 479 480 481
		checksum += ~value;
		memory_write(dev->core, i, value);
		dataptr++;
	}

	/* read back to verify with the checksum */
	for (i--; i >= 0; i--) {
		memory_read(dev->core, i, &value);
		checksum -= ~value;
	}
482
	release_firmware(firmware);
Linus Torvalds's avatar
Linus Torvalds committed
483
	if (checksum) {
484 485
		pr_err("Firmware load might have failed (checksum mismatch).\n");
		return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
486 487 488
	}
	dprintk(0, "Firmware upload successful.\n");

489 490 491
	retval |= register_write(dev->core, IVTV_REG_HW_BLOCKS, IVTV_CMD_HW_BLOCKS_RST);
	retval |= register_read(dev->core, IVTV_REG_SPU, &value);
	retval |= register_write(dev->core, IVTV_REG_SPU, value & 0xFFFFFFFE);
Linus Torvalds's avatar
Linus Torvalds committed
492 493 494
	msleep(1);

	retval |= register_read(dev->core, IVTV_REG_VPU, &value);
495
	retval |= register_write(dev->core, IVTV_REG_VPU, value & 0xFFFFFFE8);
Linus Torvalds's avatar
Linus Torvalds committed
496 497 498 499 500 501

	if (retval < 0)
		dprintk(0, "Error with register_write\n");
	return 0;
}

502 503 504 505 506 507 508 509 510 511 512 513 514
/**
 Settings used by the windows tv app for PVR2000:
=================================================================================================================
Profile | Codec | Resolution | CBR/VBR | Video Qlty   | V. Bitrate | Frmrate | Audio Codec | A. Bitrate | A. Mode
-----------------------------------------------------------------------------------------------------------------
MPEG-1  | MPEG1 | 352x288PAL | (CBR)   | 1000:Optimal | 2000 Kbps  | 25fps   | MPG1 Layer2 | 224kbps    | Stereo
MPEG-2  | MPEG2 | 720x576PAL | VBR     | 600 :Good    | 4000 Kbps  | 25fps   | MPG1 Layer2 | 224kbps    | Stereo
VCD     | MPEG1 | 352x288PAL | (CBR)   | 1000:Optimal | 1150 Kbps  | 25fps   | MPG1 Layer2 | 224kbps    | Stereo
DVD     | MPEG2 | 720x576PAL | VBR     | 600 :Good    | 6000 Kbps  | 25fps   | MPG1 Layer2 | 224kbps    | Stereo
DB* DVD | MPEG2 | 720x576PAL | CBR     | 600 :Good    | 6000 Kbps  | 25fps   | MPG1 Layer2 | 224kbps    | Stereo
=================================================================================================================
*DB: "DirectBurn"
*/
515

516 517 518 519 520 521
static void blackbird_codec_settings(struct cx8802_dev *dev)
{
	/* assign frame size */
	blackbird_api_cmd(dev, CX2341X_ENC_SET_FRAME_SIZE, 2, 0,
				dev->height, dev->width);

522 523 524 525
	dev->cxhdl.width = dev->width;
	dev->cxhdl.height = dev->height;
	cx2341x_handler_set_50hz(&dev->cxhdl, dev->core->tvnorm & V4L2_STD_625_50);
	cx2341x_handler_setup(&dev->cxhdl);
526 527
}

Linus Torvalds's avatar
Linus Torvalds committed
528 529 530 531 532 533 534
static int blackbird_initialize_codec(struct cx8802_dev *dev)
{
	struct cx88_core *core = dev->core;
	int version;
	int retval;

	dprintk(1,"Initialize codec\n");
535
	retval = blackbird_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0); /* ping */
Linus Torvalds's avatar
Linus Torvalds committed
536
	if (retval < 0) {
537 538 539

		dev->mpeg_active = 0;

Linus Torvalds's avatar
Linus Torvalds committed
540 541 542 543 544 545 546
		/* ping was not successful, reset and upload firmware */
		cx_write(MO_SRST_IO, 0); /* SYS_RSTO=0 */
		cx_write(MO_SRST_IO, 1); /* SYS_RSTO=1 */
		retval = blackbird_load_firmware(dev);
		if (retval < 0)
			return retval;

547 548
		retval = blackbird_find_mailbox(dev);
		if (retval < 0)
Linus Torvalds's avatar
Linus Torvalds committed
549 550
			return -1;

551 552
		dev->mailbox = retval;

553
		retval = blackbird_api_cmd(dev, CX2341X_ENC_PING_FW, 0, 0); /* ping */
Linus Torvalds's avatar
Linus Torvalds committed
554 555 556 557 558
		if (retval < 0) {
			dprintk(0, "ERROR: Firmware ping failed!\n");
			return -1;
		}

559
		retval = blackbird_api_cmd(dev, CX2341X_ENC_GET_VERSION, 0, 1, &version);
Linus Torvalds's avatar
Linus Torvalds committed
560 561 562 563 564 565 566 567 568 569 570 571 572 573
		if (retval < 0) {
			dprintk(0, "ERROR: Firmware get encoder version failed!\n");
			return -1;
		}
		dprintk(0, "Firmware version is 0x%08x\n", version);
	}

	cx_write(MO_PINMUX_IO, 0x88); /* 656-8bit IO and enable MPEG parallel IO */
	cx_clear(MO_INPUT_FORMAT, 0x100); /* chroma subcarrier lock to normal? */
	cx_write(MO_VBOS_CONTROL, 0x84A00); /* no 656 mode, 8-bit pixels, disable VBI */
	cx_clear(MO_OUTPUT_FORMAT, 0x0008); /* Normal Y-limits to let the mpeg encoder sync */

	blackbird_codec_settings(dev);

574
	blackbird_api_cmd(dev, CX2341X_ENC_SET_NUM_VSYNC_LINES, 2, 0,
575
			BLACKBIRD_FIELD1_SAA7115,
576
			BLACKBIRD_FIELD2_SAA7115
577 578
		);

579
	blackbird_api_cmd(dev, CX2341X_ENC_SET_PLACEHOLDER, 12, 0,
580 581
			BLACKBIRD_CUSTOM_EXTENSION_USR_DATA,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
Linus Torvalds's avatar
Linus Torvalds committed
582

583 584 585
	return 0;
}

Hans Verkuil's avatar
Hans Verkuil committed
586
static int blackbird_start_codec(struct cx8802_dev *dev)
587 588 589 590 591 592 593 594 595
{
	struct cx88_core *core = dev->core;
	/* start capturing to the host interface */
	u32 reg;

	int i;
	int lastchange = -1;
	int lastval = 0;

596
	for (i = 0; (i < 10) && (i < (lastchange + 4)); i++) {
597 598
		reg = cx_read(AUD_STATUS);

599 600
		dprintk(1, "AUD_STATUS:%dL: 0x%x\n", i, reg);
		if ((reg & 0x0F) != lastval) {
601 602 603 604 605 606 607 608
			lastval = reg & 0x0F;
			lastchange = i;
		}
		msleep(100);
	}

	/* unmute audio source */
	cx_clear(AUD_VOL_CTL, (1 << 6));
Linus Torvalds's avatar
Linus Torvalds committed
609

610
	blackbird_api_cmd(dev, CX2341X_ENC_REFRESH_INPUT, 0, 0);
611 612 613 614

	/* initialize the video input */
	blackbird_api_cmd(dev, CX2341X_ENC_INITIALIZE_INPUT, 0, 0);

615 616
	cx2341x_handler_set_busy(&dev->cxhdl, 1);

617
	/* start capturing to the host interface */
618
	blackbird_api_cmd(dev, CX2341X_ENC_START_CAPTURE, 2, 0,
619 620
			BLACKBIRD_MPEG_CAPTURE,
			BLACKBIRD_RAW_BITS_NONE
621
		);
Linus Torvalds's avatar
Linus Torvalds committed
622

623 624 625 626 627 628 629 630 631 632 633 634
	dev->mpeg_active = 1;
	return 0;
}

static int blackbird_stop_codec(struct cx8802_dev *dev)
{
	blackbird_api_cmd(dev, CX2341X_ENC_STOP_CAPTURE, 3, 0,
			BLACKBIRD_END_NOW,
			BLACKBIRD_MPEG_CAPTURE,
			BLACKBIRD_RAW_BITS_NONE
		);

635 636
	cx2341x_handler_set_busy(&dev->cxhdl, 0);

637
	dev->mpeg_active = 0;
Linus Torvalds's avatar
Linus Torvalds committed
638 639 640 641 642
	return 0;
}

/* ------------------------------------------------------------------ */

Hans Verkuil's avatar
Hans Verkuil committed
643 644 645
static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt,
			   unsigned int *num_buffers, unsigned int *num_planes,
			   unsigned int sizes[], void *alloc_ctxs[])
Linus Torvalds's avatar
Linus Torvalds committed
646
{
Hans Verkuil's avatar
Hans Verkuil committed
647
	struct cx8802_dev *dev = q->drv_priv;
Linus Torvalds's avatar
Linus Torvalds committed
648

Hans Verkuil's avatar
Hans Verkuil committed
649 650 651 652
	*num_planes = 1;
	dev->ts_packet_size  = 188 * 4;
	dev->ts_packet_count  = 32;
	sizes[0] = dev->ts_packet_size * dev->ts_packet_count;
Linus Torvalds's avatar
Linus Torvalds committed
653 654 655
	return 0;
}

Hans Verkuil's avatar
Hans Verkuil committed
656
static int buffer_prepare(struct vb2_buffer *vb)
Linus Torvalds's avatar
Linus Torvalds committed
657
{
Hans Verkuil's avatar
Hans Verkuil committed
658 659 660 661
	struct cx8802_dev *dev = vb->vb2_queue->drv_priv;
	struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);

	return cx8802_buf_prepare(vb->vb2_queue, dev, buf, dev->field);
Linus Torvalds's avatar
Linus Torvalds committed
662 663
}

Hans Verkuil's avatar
Hans Verkuil committed
664
static void buffer_finish(struct vb2_buffer *vb)
Linus Torvalds's avatar
Linus Torvalds committed
665
{
Hans Verkuil's avatar
Hans Verkuil committed
666 667 668 669
	struct cx8802_dev *dev = vb->vb2_queue->drv_priv;
	struct cx88_buffer *buf = container_of(vb, struct cx88_buffer, vb);
	struct sg_table *sgt = vb2_dma_sg_plane_desc(vb, 0);

670
	btcx_riscmem_free(dev->pci, &buf->risc);
Hans Verkuil's avatar
Hans Verkuil committed
671 672

	dma_unmap_sg(&dev->pci->dev, sgt->sgl, sgt->nents, DMA_FROM_DEVICE);
Linus Torvalds's avatar
Linus Torvalds committed
673 674
}

Hans Verkuil's avatar
Hans Verkuil committed
675
static void buffer_queue(struct vb2_buffer *vb)
Linus Torvalds's avatar
Linus Torvalds committed
676
{
Hans Verkuil's avatar
Hans Verkuil committed
677 678 679 680
	struct cx8802_dev *dev = vb->vb2_queue->drv_priv;
	struct cx88_buffer    *buf = container_of(vb, struct cx88_buffer, vb);

	cx8802_buf_queue(dev, buf);
Linus Torvalds's avatar
Linus Torvalds committed
681 682
}

Hans Verkuil's avatar
Hans Verkuil committed
683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767
static int start_streaming(struct vb2_queue *q, unsigned int count)
{
	struct cx8802_dev *dev = q->drv_priv;
	struct cx88_dmaqueue *dmaq = &dev->mpegq;
	struct cx8802_driver *drv;
	struct cx88_buffer *buf;
	unsigned long flags;
	int err;

	/* Make sure we can acquire the hardware */
	drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
	if (!drv) {
		dprintk(1, "%s: blackbird driver is not loaded\n", __func__);
		err = -ENODEV;
		goto fail;
	}

	err = drv->request_acquire(drv);
	if (err != 0) {
		dprintk(1, "%s: Unable to acquire hardware, %d\n", __func__, err);
		goto fail;
	}

	if (blackbird_initialize_codec(dev) < 0) {
		drv->request_release(drv);
		err = -EINVAL;
		goto fail;
	}

	err = blackbird_start_codec(dev);
	if (err == 0) {
		buf = list_entry(dmaq->active.next, struct cx88_buffer, list);
		cx8802_start_dma(dev, dmaq, buf);
		return 0;
	}

fail:
	spin_lock_irqsave(&dev->slock, flags);
	while (!list_empty(&dmaq->active)) {
		struct cx88_buffer *buf = list_entry(dmaq->active.next,
			struct cx88_buffer, list);

		list_del(&buf->list);
		vb2_buffer_done(&buf->vb, VB2_BUF_STATE_QUEUED);
	}
	spin_unlock_irqrestore(&dev->slock, flags);
	return err;
}

static void stop_streaming(struct vb2_queue *q)
{
	struct cx8802_dev *dev = q->drv_priv;
	struct cx88_dmaqueue *dmaq = &dev->mpegq;
	struct cx8802_driver *drv = NULL;
	unsigned long flags;

	cx8802_cancel_buffers(dev);
	blackbird_stop_codec(dev);

	/* Make sure we release the hardware */
	drv = cx8802_get_driver(dev, CX88_MPEG_BLACKBIRD);
	WARN_ON(!drv);
	if (drv)
		drv->request_release(drv);

	spin_lock_irqsave(&dev->slock, flags);
	while (!list_empty(&dmaq->active)) {
		struct cx88_buffer *buf = list_entry(dmaq->active.next,
			struct cx88_buffer, list);

		list_del(&buf->list);
		vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
	}
	spin_unlock_irqrestore(&dev->slock, flags);
}

static struct vb2_ops blackbird_qops = {
	.queue_setup    = queue_setup,
	.buf_prepare  = buffer_prepare,
	.buf_finish = buffer_finish,
	.buf_queue    = buffer_queue,
	.wait_prepare = vb2_ops_wait_prepare,
	.wait_finish = vb2_ops_wait_finish,
	.start_streaming = start_streaming,
	.stop_streaming = stop_streaming,
Linus Torvalds's avatar
Linus Torvalds committed
768 769 770 771
};

/* ------------------------------------------------------------------ */

Hans Verkuil's avatar
Hans Verkuil committed
772
static int vidioc_querycap(struct file *file, void  *priv,
773
					struct v4l2_capability *cap)
Linus Torvalds's avatar
Linus Torvalds committed
774
{
Hans Verkuil's avatar
Hans Verkuil committed
775 776
	struct cx8802_dev *dev = video_drvdata(file);
	struct cx88_core *core = dev->core;
Linus Torvalds's avatar
Linus Torvalds committed
777

778
	strcpy(cap->driver, "cx88_blackbird");
Hans Verkuil's avatar
Hans Verkuil committed
779 780
	sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
	cx88_querycap(file, core, cap);
781 782 783
	return 0;
}

784
static int vidioc_enum_fmt_vid_cap (struct file *file, void  *priv,
785 786 787 788
					struct v4l2_fmtdesc *f)
{
	if (f->index != 0)
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
789

790 791
	strlcpy(f->description, "MPEG", sizeof(f->description));
	f->pixelformat = V4L2_PIX_FMT_MPEG;
792
	f->flags = V4L2_FMT_FLAG_COMPRESSED;
793 794
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
795

796
static int vidioc_g_fmt_vid_cap (struct file *file, void *priv,
797 798
					struct v4l2_format *f)
{
Hans Verkuil's avatar
Hans Verkuil committed
799
	struct cx8802_dev *dev = video_drvdata(file);
800 801 802

	f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
	f->fmt.pix.bytesperline = 0;
Hans Verkuil's avatar
Hans Verkuil committed
803
	f->fmt.pix.sizeimage    = dev->ts_packet_size * dev->ts_packet_count;
804
	f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
805 806
	f->fmt.pix.width        = dev->width;
	f->fmt.pix.height       = dev->height;
Hans Verkuil's avatar
Hans Verkuil committed
807
	f->fmt.pix.field        = dev->field;
808
	dprintk(1, "VIDIOC_G_FMT: w: %d, h: %d, f: %d\n",
Hans Verkuil's avatar
Hans Verkuil committed
809
		dev->width, dev->height, dev->field);
810 811
	return 0;
}
812

813
static int vidioc_try_fmt_vid_cap (struct file *file, void *priv,
814 815
			struct v4l2_format *f)
{
Hans Verkuil's avatar
Hans Verkuil committed
816
	struct cx8802_dev *dev = video_drvdata(file);
817 818 819

	f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
	f->fmt.pix.bytesperline = 0;
Hans Verkuil's avatar
Hans Verkuil committed
820
	f->fmt.pix.sizeimage    = dev->ts_packet_size * dev->ts_packet_count;
821
	f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
822
	dprintk(1, "VIDIOC_TRY_FMT: w: %d, h: %d, f: %d\n",
Hans Verkuil's avatar
Hans Verkuil committed
823
		dev->width, dev->height, dev->field);
824 825
	return 0;
}
826

827
static int vidioc_s_fmt_vid_cap (struct file *file, void *priv,
828 829
					struct v4l2_format *f)
{
Hans Verkuil's avatar
Hans Verkuil committed
830
	struct cx8802_dev *dev = video_drvdata(file);
831
	struct cx88_core  *core = dev->core;
832

833 834
	f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
	f->fmt.pix.bytesperline = 0;
Hans Verkuil's avatar
Hans Verkuil committed
835
	f->fmt.pix.sizeimage    = dev->ts_packet_size * dev->ts_packet_count;
836
	f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
837 838
	dev->width              = f->fmt.pix.width;
	dev->height             = f->fmt.pix.height;
Hans Verkuil's avatar
Hans Verkuil committed
839
	dev->field         = f->fmt.pix.field;
840 841 842
	cx88_set_scale(core, f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
	blackbird_api_cmd(dev, CX2341X_ENC_SET_FRAME_SIZE, 2, 0,
				f->fmt.pix.height, f->fmt.pix.width);
843
	dprintk(1, "VIDIOC_S_FMT: w: %d, h: %d, f: %d\n",
844 845 846
		f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field );
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
847

848
static int vidioc_s_frequency (struct file *file, void *priv,
849
				const struct v4l2_frequency *f)
850
{
Hans Verkuil's avatar
Hans Verkuil committed
851 852
	struct cx8802_dev *dev = video_drvdata(file);
	struct cx88_core *core = dev->core;
853

854 855 856 857
	if (unlikely(UNSET == core->board.tuner_type))
		return -EINVAL;
	if (unlikely(f->tuner != 0))
		return -EINVAL;
858 859 860
	if (dev->mpeg_active)
		blackbird_stop_codec(dev);

861 862 863
	cx88_set_freq (core,f);
	blackbird_initialize_codec(dev);
	cx88_set_scale(dev->core, dev->width, dev->height,
Hans Verkuil's avatar
Hans Verkuil committed
864
			dev->field);
865 866
	return 0;
}
867

868 869
static int vidioc_log_status (struct file *file, void *priv)
{
Hans Verkuil's avatar
Hans Verkuil committed
870 871
	struct cx8802_dev *dev = video_drvdata(file);
	struct cx88_core *core = dev->core;
872 873 874
	char name[32 + 2];

	snprintf(name, sizeof(name), "%s/2", core->name);
875
	call_all(core, core, log_status);
876
	v4l2_ctrl_handler_log_status(&dev->cxhdl.hdl, name);
877 878
	return 0;
}
879

880 881 882
static int vidioc_enum_input (struct file *file, void *priv,
				struct v4l2_input *i)
{
Hans Verkuil's avatar
Hans Verkuil committed
883 884
	struct cx8802_dev *dev = video_drvdata(file);
	struct cx88_core *core = dev->core;
885 886
	return cx88_enum_input (core,i);
}
887

888 889 890
static int vidioc_g_frequency (struct file *file, void *priv,
				struct v4l2_frequency *f)
{
Hans Verkuil's avatar
Hans Verkuil committed
891 892
	struct cx8802_dev *dev = video_drvdata(file);
	struct cx88_core *core = dev->core;
893

894
	if (unlikely(UNSET == core->board.tuner_type))
895
		return -EINVAL;
896 897
	if (unlikely(f->tuner != 0))
		return -EINVAL;
898

899
	f->frequency = core->freq;
900
	call_all(core, tuner, g_frequency, f);
901

902 903
	return 0;
}
904

905 906
static int vidioc_g_input (struct file *file, void *priv, unsigned int *i)
{
Hans Verkuil's avatar
Hans Verkuil committed
907 908
	struct cx8802_dev *dev = video_drvdata(file);
	struct cx88_core *core = dev->core;
909

910 911 912
	*i = core->input;
	return 0;
}
913

914 915
static int vidioc_s_input (struct file *file, void *priv, unsigned int i)
{
Hans Verkuil's avatar
Hans Verkuil committed
916 917
	struct cx8802_dev *dev = video_drvdata(file);
	struct cx88_core *core = dev->core;
918

919 920
	if (i >= 4)
		return -EINVAL;
921 922
	if (0 == INPUT(i).type)
		return -EINVAL;
923 924 925

	cx88_newstation(core);
	cx88_video_mux(core,i);
926 927 928
	return 0;
}

929 930 931
static int vidioc_g_tuner (struct file *file, void *priv,
				struct v4l2_tuner *t)
{
Hans Verkuil's avatar
Hans Verkuil committed
932 933
	struct cx8802_dev *dev = video_drvdata(file);
	struct cx88_core *core = dev->core;
934 935
	u32 reg;

936
	if (unlikely(UNSET == core->board.tuner_type))
937
		return -EINVAL;
938 939
	if (0 != t->index)
		return -EINVAL;
940 941 942 943

	strcpy(t->name, "Television");
	t->capability = V4L2_TUNER_CAP_NORM;
	t->rangehigh  = 0xffffffffUL;
944
	call_all(core, tuner, g_tuner, t);
945 946 947 948 949 950

	cx88_get_stereo(core ,t);
	reg = cx_read(MO_DEVICE_STATUS);
	t->signal = (reg & (1<<5)) ? 0xffff : 0x0000;
	return 0;
}
951

952
static int vidioc_s_tuner (struct file *file, void *priv,
953
				const struct v4l2_tuner *t)
954
{
Hans Verkuil's avatar
Hans Verkuil committed
955 956
	struct cx8802_dev *dev = video_drvdata(file);
	struct cx88_core *core = dev->core;
957

958
	if (UNSET == core->board.tuner_type)
959 960 961 962 963 964
		return -EINVAL;
	if (0 != t->index)
		return -EINVAL;

	cx88_set_stereo(core, t->audmode, 1);
	return 0;
965 966
}

967 968
static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *tvnorm)
{
Hans Verkuil's avatar
Hans Verkuil committed
969 970
	struct cx8802_dev *dev = video_drvdata(file);
	struct cx88_core *core = dev->core;
971 972 973 974 975

	*tvnorm = core->tvnorm;
	return 0;
}

976
static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id)
Linus Torvalds's avatar
Linus Torvalds committed
977
{
978
	struct cx8802_dev *dev = video_drvdata(file);
Hans Verkuil's avatar
Hans Verkuil committed
979
	struct cx88_core *core = dev->core;
980

Hans Verkuil's avatar
Hans Verkuil committed
981
	cx88_set_tvnorm(core, id);
Linus Torvalds's avatar
Linus Torvalds committed
982 983 984
	return 0;
}

985
static const struct v4l2_file_operations mpeg_fops =
Linus Torvalds's avatar
Linus Torvalds committed
986 987
{
	.owner	       = THIS_MODULE,
Hans Verkuil's avatar
Hans Verkuil committed
988 989 990 991 992
	.open	       = v4l2_fh_open,
	.release       = vb2_fop_release,
	.read	       = vb2_fop_read,
	.poll          = vb2_fop_poll,
	.mmap	       = vb2_fop_mmap,
993
	.unlocked_ioctl = video_ioctl2,
Linus Torvalds's avatar
Linus Torvalds committed
994 995
};

996
static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
997
	.vidioc_querycap      = vidioc_querycap,
998 999 1000 1001
	.vidioc_enum_fmt_vid_cap  = vidioc_enum_fmt_vid_cap,
	.vidioc_g_fmt_vid_cap     = vidioc_g_fmt_vid_cap,
	.vidioc_try_fmt_vid_cap   = vidioc_try_fmt_vid_cap,
	.vidioc_s_fmt_vid_cap     = vidioc_s_fmt_vid_cap,
Hans Verkuil's avatar
Hans Verkuil committed
1002 1003 1004 1005 1006 1007
	.vidioc_reqbufs       = vb2_ioctl_reqbufs,
	.vidioc_querybuf      = vb2_ioctl_querybuf,
	.vidioc_qbuf          = vb2_ioctl_qbuf,
	.vidioc_dqbuf         = vb2_ioctl_dqbuf,
	.vidioc_streamon      = vb2_ioctl_streamon,
	.vidioc_streamoff     = vb2_ioctl_streamoff,
1008 1009 1010 1011 1012 1013 1014 1015
	.vidioc_s_frequency   = vidioc_s_frequency,
	.vidioc_log_status    = vidioc_log_status,
	.vidioc_enum_input    = vidioc_enum_input,
	.vidioc_g_frequency   = vidioc_g_frequency,
	.vidioc_g_input       = vidioc_g_input,
	.vidioc_s_input       = vidioc_s_input,
	.vidioc_g_tuner       = vidioc_g_tuner,
	.vidioc_s_tuner       = vidioc_s_tuner,
1016
	.vidioc_g_std         = vidioc_g_std,
1017
	.vidioc_s_std         = vidioc_s_std,
1018 1019
	.vidioc_subscribe_event      = v4l2_ctrl_subscribe_event,
	.vidioc_unsubscribe_event    = v4l2_event_unsubscribe,
1020 1021 1022 1023 1024 1025
};

static struct video_device cx8802_mpeg_template = {
	.name                 = "cx8802",
	.fops                 = &mpeg_fops,
	.ioctl_ops 	      = &mpeg_ioctl_ops,
1026
	.tvnorms              = CX88_NORMS,
Linus Torvalds's avatar
Linus Torvalds committed
1027 1028 1029 1030
};

/* ------------------------------------------------------------------ */

1031 1032 1033 1034 1035 1036
/* The CX8802 MPEG API will call this when we can use the hardware */
static int cx8802_blackbird_advise_acquire(struct cx8802_driver *drv)
{
	struct cx88_core *core = drv->core;
	int err = 0;

1037
	switch (core->boardnr) {
1038 1039 1040 1041 1042 1043
	case CX88_BOARD_HAUPPAUGE_HVR1300:
		/* By default, core setup will leave the cx22702 out of reset, on the bus.
		 * We left the hardware on power up with the cx22702 active.
		 * We're being given access to re-arrange the GPIOs.
		 * Take the bus off the cx22702 and put the cx23416 on it.
		 */
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053
		/* Toggle reset on cx22702 leaving i2c active */
		cx_set(MO_GP0_IO, 0x00000080);
		udelay(1000);
		cx_clear(MO_GP0_IO, 0x00000080);
		udelay(50);
		cx_set(MO_GP0_IO, 0x00000080);
		udelay(1000);
		/* tri-state the cx22702 pins */
		cx_set(MO_GP0_IO, 0x00000004);
		udelay(1000);
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
		break;
	default:
		err = -ENODEV;
	}
	return err;
}

/* The CX8802 MPEG API will call this when we need to release the hardware */
static int cx8802_blackbird_advise_release(struct cx8802_driver *drv)
{
	struct cx88_core *core = drv->core;
	int err = 0;

1067
	switch (core->boardnr) {
1068 1069 1070 1071 1072 1073 1074 1075 1076
	case CX88_BOARD_HAUPPAUGE_HVR1300:
		/* Exit leaving the cx23416 on the bus */
		break;
	default:
		err = -ENODEV;
	}
	return err;
}

Linus Torvalds's avatar
Linus Torvalds committed
1077 1078 1079
static void blackbird_unregister_video(struct cx8802_dev *dev)
{
	if (dev->mpeg_dev) {
1080
		if (video_is_registered(dev->mpeg_dev))
Linus Torvalds's avatar
Linus Torvalds committed
1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
			video_unregister_device(dev->mpeg_dev);
		else
			video_device_release(dev->mpeg_dev);
		dev->mpeg_dev = NULL;
	}
}

static int blackbird_register_video(struct cx8802_dev *dev)
{
	int err;

Hans Verkuil's avatar
Hans Verkuil committed
1092 1093
	dev->mpeg_dev = cx88_vdev_init(dev->core, dev->pci,
				       &cx8802_mpeg_template, "mpeg");
1094
	dev->mpeg_dev->ctrl_handler = &dev->cxhdl.hdl;
1095
	video_set_drvdata(dev->mpeg_dev, dev);
Hans Verkuil's avatar
Hans Verkuil committed
1096 1097
	dev->mpeg_dev->queue = &dev->vb2_mpegq;
	err = video_register_device(dev->mpeg_dev, VFL_TYPE_GRABBER, -1);
Linus Torvalds's avatar
Linus Torvalds committed
1098 1099 1100 1101 1102
	if (err < 0) {
		printk(KERN_INFO "%s/2: can't register mpeg device\n",
		       dev->core->name);
		return err;
	}
1103 1104
	printk(KERN_INFO "%s/2: registered device %s [mpeg]\n",
	       dev->core->name, video_device_node_name(dev->mpeg_dev));
Linus Torvalds's avatar
Linus Torvalds committed
1105 1106 1107 1108 1109
	return 0;
}

/* ----------------------------------------------------------- */

1110
static int cx8802_blackbird_probe(struct cx8802_driver *drv)
Linus Torvalds's avatar
Linus Torvalds committed
1111
{
1112 1113
	struct cx88_core *core = drv->core;
	struct cx8802_dev *dev = core->dvbdev;
Hans Verkuil's avatar
Hans Verkuil committed
1114
	struct vb2_queue *q;
Linus Torvalds's avatar
Linus Torvalds committed
1115 1116
	int err;

1117
	dprintk( 1, "%s\n", __func__);
1118
	dprintk( 1, " ->being probed by Card=%d Name=%s, PCI %02x:%02x\n",
1119
		core->boardnr,
1120 1121 1122
		core->name,
		core->pci_bus,
		core->pci_slot);
Linus Torvalds's avatar
Linus Torvalds committed
1123 1124

	err = -ENODEV;
1125
	if (!(core->board.mpeg & CX88_MPEG_BLACKBIRD))
Linus Torvalds's avatar
Linus Torvalds committed
1126 1127
		goto fail_core;

1128
	dev->width = 720;
1129
	if (core->tvnorm & V4L2_STD_525_60) {
1130 1131 1132
		dev->height = 480;
	} else {
		dev->height = 576;
1133
	}
Hans Verkuil's avatar
Hans Verkuil committed
1134
	dev->field = V4L2_FIELD_INTERLACED;
1135 1136 1137 1138 1139 1140 1141 1142
	dev->cxhdl.port = CX2341X_PORT_STREAMING;
	dev->cxhdl.width = dev->width;
	dev->cxhdl.height = dev->height;
	dev->cxhdl.func = blackbird_mbox_func;
	dev->cxhdl.priv = dev;
	err = cx2341x_handler_init(&dev->cxhdl, 36);
	if (err)
		goto fail_core;
1143
	v4l2_ctrl_add_handler(&dev->cxhdl.hdl, &core->video_hdl, NULL);
1144

Linus Torvalds's avatar
Linus Torvalds committed
1145 1146 1147 1148 1149
	/* blackbird stuff */
	printk("%s/2: cx23416 based mpeg encoder (blackbird reference design)\n",
	       core->name);
	host_setup(dev->core);

1150
	blackbird_initialize_codec(dev);
1151 1152

	/* initial device configuration: needed ? */
1153 1154 1155
//	init_controls(core);
	cx88_set_tvnorm(core,core->tvnorm);
	cx88_video_mux(core,0);
1156 1157
	cx2341x_handler_set_50hz(&dev->cxhdl, dev->height == 576);
	cx2341x_handler_setup(&dev->cxhdl);
Hans Verkuil's avatar
Hans Verkuil committed
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174

	q = &dev->vb2_mpegq;
	q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
	q->gfp_flags = GFP_DMA32;
	q->min_buffers_needed = 2;
	q->drv_priv = dev;
	q->buf_struct_size = sizeof(struct cx88_buffer);
	q->ops = &blackbird_qops;
	q->mem_ops = &vb2_dma_sg_memops;
	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
	q->lock = &core->lock;

	err = vb2_queue_init(q);
	if (err < 0)
		goto fail_core;

1175
	blackbird_register_video(dev);
1176

Linus Torvalds's avatar
Linus Torvalds committed
1177 1178
	return 0;

Hans Verkuil's avatar
Hans Verkuil committed
1179
fail_core:
Linus Torvalds's avatar
Linus Torvalds committed
1180 1181 1182
	return err;
}

1183
static int cx8802_blackbird_remove(struct cx8802_driver *drv)
Linus Torvalds's avatar
Linus Torvalds committed
1184
{
1185 1186 1187
	struct cx88_core *core = drv->core;
	struct cx8802_dev *dev = core->dvbdev;

Linus Torvalds's avatar
Linus Torvalds committed
1188
	/* blackbird */
1189
	blackbird_unregister_video(drv->core->dvbdev);
1190
	v4l2_ctrl_handler_free(&dev->cxhdl.hdl);
Linus Torvalds's avatar
Linus Torvalds committed
1191

1192
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1193 1194
}

1195 1196 1197 1198 1199 1200 1201
static struct cx8802_driver cx8802_blackbird_driver = {
	.type_id	= CX88_MPEG_BLACKBIRD,
	.hw_access	= CX8802_DRVCTL_SHARED,
	.probe		= cx8802_blackbird_probe,
	.remove		= cx8802_blackbird_remove,
	.advise_acquire	= cx8802_blackbird_advise_acquire,
	.advise_release	= cx8802_blackbird_advise_release,
Linus Torvalds's avatar
Linus Torvalds committed
1202 1203
};

1204
static int __init blackbird_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
1205
{
1206 1207
	printk(KERN_INFO "cx2388x blackbird driver version %s loaded\n",
	       CX88_VERSION);
1208
	return cx8802_register_driver(&cx8802_blackbird_driver);
Linus Torvalds's avatar
Linus Torvalds committed
1209 1210
}

1211
static void __exit blackbird_fini(void)
Linus Torvalds's avatar
Linus Torvalds committed
1212
{
1213
	cx8802_unregister_driver(&cx8802_blackbird_driver);
Linus Torvalds's avatar
Linus Torvalds committed
1214 1215 1216 1217 1218
}

module_init(blackbird_init);
module_exit(blackbird_fini);

1219 1220
module_param_named(video_debug,cx8802_mpeg_template.debug, int, 0644);
MODULE_PARM_DESC(debug,"enable debug messages [video]");