saa7164-encoder.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  Driver for the NXP SAA7164 PCIe bridge
   4 *
   5 *  Copyright (c) 2010-2015 Steven Toth <stoth@kernellabs.com>
   6 */
   7
   8#include "saa7164.h"
   9
  10#define ENCODER_MAX_BITRATE 6500000
  11#define ENCODER_MIN_BITRATE 1000000
  12#define ENCODER_DEF_BITRATE 5000000
  13
  14/*
  15 * This is a dummy non-zero value for the sizeimage field of v4l2_pix_format.
  16 * It is not actually used for anything since this driver does not support
  17 * stream I/O, only read(), and because this driver produces an MPEG stream
  18 * and not discrete frames. But the V4L2 spec doesn't allow for this value
  19 * to be 0, so set it to 0x10000 instead.
  20 *
  21 * If we ever change this driver to support stream I/O, then this field
  22 * will be the size of the streaming buffers.
  23 */
  24#define SAA7164_SIZEIMAGE (0x10000)
  25
  26static struct saa7164_tvnorm saa7164_tvnorms[] = {
  27	{
  28		.name      = "NTSC-M",
  29		.id        = V4L2_STD_NTSC_M,
  30	}, {
  31		.name      = "NTSC-JP",
  32		.id        = V4L2_STD_NTSC_M_JP,
  33	}
  34};
  35
  36/* Take the encoder configuration form the port struct and
  37 * flush it to the hardware.
  38 */
  39static void saa7164_encoder_configure(struct saa7164_port *port)
  40{
  41	struct saa7164_dev *dev = port->dev;
  42	dprintk(DBGLVL_ENC, "%s()\n", __func__);
  43
  44	port->encoder_params.width = port->width;
  45	port->encoder_params.height = port->height;
  46	port->encoder_params.is_50hz =
  47		(port->encodernorm.id & V4L2_STD_625_50) != 0;
  48
  49	/* Set up the DIF (enable it) for analog mode by default */
  50	saa7164_api_initialize_dif(port);
  51
  52	/* Configure the correct video standard */
  53	saa7164_api_configure_dif(port, port->encodernorm.id);
  54
  55	/* Ensure the audio decoder is correct configured */
  56	saa7164_api_set_audio_std(port);
  57}
  58
  59static int saa7164_encoder_buffers_dealloc(struct saa7164_port *port)
  60{
  61	struct list_head *c, *n, *p, *q, *l, *v;
  62	struct saa7164_dev *dev = port->dev;
  63	struct saa7164_buffer *buf;
  64	struct saa7164_user_buffer *ubuf;
  65
  66	/* Remove any allocated buffers */
  67	mutex_lock(&port->dmaqueue_lock);
  68
  69	dprintk(DBGLVL_ENC, "%s(port=%d) dmaqueue\n", __func__, port->nr);
  70	list_for_each_safe(c, n, &port->dmaqueue.list) {
  71		buf = list_entry(c, struct saa7164_buffer, list);
  72		list_del(c);
  73		saa7164_buffer_dealloc(buf);
  74	}
  75
  76	dprintk(DBGLVL_ENC, "%s(port=%d) used\n", __func__, port->nr);
  77	list_for_each_safe(p, q, &port->list_buf_used.list) {
  78		ubuf = list_entry(p, struct saa7164_user_buffer, list);
  79		list_del(p);
  80		saa7164_buffer_dealloc_user(ubuf);
  81	}
  82
  83	dprintk(DBGLVL_ENC, "%s(port=%d) free\n", __func__, port->nr);
  84	list_for_each_safe(l, v, &port->list_buf_free.list) {
  85		ubuf = list_entry(l, struct saa7164_user_buffer, list);
  86		list_del(l);
  87		saa7164_buffer_dealloc_user(ubuf);
  88	}
  89
  90	mutex_unlock(&port->dmaqueue_lock);
  91	dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
  92
  93	return 0;
  94}
  95
  96/* Dynamic buffer switch at encoder start time */
  97static int saa7164_encoder_buffers_alloc(struct saa7164_port *port)
  98{
  99	struct saa7164_dev *dev = port->dev;
 100	struct saa7164_buffer *buf;
 101	struct saa7164_user_buffer *ubuf;
 102	struct tmHWStreamParameters *params = &port->hw_streamingparams;
 103	int result = -ENODEV, i;
 104	int len = 0;
 105
 106	dprintk(DBGLVL_ENC, "%s()\n", __func__);
 107
 108	if (port->encoder_params.stream_type ==
 109		V4L2_MPEG_STREAM_TYPE_MPEG2_PS) {
 110		dprintk(DBGLVL_ENC,
 111			"%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_PS\n",
 112			__func__);
 113		params->samplesperline = 128;
 114		params->numberoflines = 256;
 115		params->pitch = 128;
 116		params->numpagetables = 2 +
 117			((SAA7164_PS_NUMBER_OF_LINES * 128) / PAGE_SIZE);
 118	} else
 119	if (port->encoder_params.stream_type ==
 120		V4L2_MPEG_STREAM_TYPE_MPEG2_TS) {
 121		dprintk(DBGLVL_ENC,
 122			"%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_TS\n",
 123			__func__);
 124		params->samplesperline = 188;
 125		params->numberoflines = 312;
 126		params->pitch = 188;
 127		params->numpagetables = 2 +
 128			((SAA7164_TS_NUMBER_OF_LINES * 188) / PAGE_SIZE);
 129	} else
 130		BUG();
 131
 132	/* Init and establish defaults */
 133	params->bitspersample = 8;
 134	params->linethreshold = 0;
 135	params->pagetablelistvirt = NULL;
 136	params->pagetablelistphys = NULL;
 137	params->numpagetableentries = port->hwcfg.buffercount;
 138
 139	/* Allocate the PCI resources, buffers (hard) */
 140	for (i = 0; i < port->hwcfg.buffercount; i++) {
 141		buf = saa7164_buffer_alloc(port,
 142			params->numberoflines *
 143			params->pitch);
 144
 145		if (!buf) {
 146			printk(KERN_ERR "%s() failed (errno = %d), unable to allocate buffer\n",
 147				__func__, result);
 148			result = -ENOMEM;
 149			goto failed;
 150		} else {
 151
 152			mutex_lock(&port->dmaqueue_lock);
 153			list_add_tail(&buf->list, &port->dmaqueue.list);
 154			mutex_unlock(&port->dmaqueue_lock);
 155
 156		}
 157	}
 158
 159	/* Allocate some kernel buffers for copying
 160	 * to userpsace.
 161	 */
 162	len = params->numberoflines * params->pitch;
 163
 164	if (encoder_buffers < 16)
 165		encoder_buffers = 16;
 166	if (encoder_buffers > 512)
 167		encoder_buffers = 512;
 168
 169	for (i = 0; i < encoder_buffers; i++) {
 170
 171		ubuf = saa7164_buffer_alloc_user(dev, len);
 172		if (ubuf) {
 173			mutex_lock(&port->dmaqueue_lock);
 174			list_add_tail(&ubuf->list, &port->list_buf_free.list);
 175			mutex_unlock(&port->dmaqueue_lock);
 176		}
 177
 178	}
 179
 180	result = 0;
 181
 182failed:
 183	return result;
 184}
 185
 186static int saa7164_encoder_initialize(struct saa7164_port *port)
 187{
 188	saa7164_encoder_configure(port);
 189	return 0;
 190}
 191
 192/* -- V4L2 --------------------------------------------------------- */
 193int saa7164_s_std(struct saa7164_port *port, v4l2_std_id id)
 194{
 195	struct saa7164_dev *dev = port->dev;
 196	unsigned int i;
 197
 198	dprintk(DBGLVL_ENC, "%s(id=0x%x)\n", __func__, (u32)id);
 199
 200	for (i = 0; i < ARRAY_SIZE(saa7164_tvnorms); i++) {
 201		if (id & saa7164_tvnorms[i].id)
 202			break;
 203	}
 204	if (i == ARRAY_SIZE(saa7164_tvnorms))
 205		return -EINVAL;
 206
 207	port->encodernorm = saa7164_tvnorms[i];
 208	port->std = id;
 209
 210	/* Update the audio decoder while is not running in
 211	 * auto detect mode.
 212	 */
 213	saa7164_api_set_audio_std(port);
 214
 215	dprintk(DBGLVL_ENC, "%s(id=0x%x) OK\n", __func__, (u32)id);
 216
 217	return 0;
 218}
 219
 220static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id)
 221{
 222	struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file);
 223
 224	return saa7164_s_std(fh->port, id);
 225}
 226
 227int saa7164_g_std(struct saa7164_port *port, v4l2_std_id *id)
 228{
 229	*id = port->std;
 230	return 0;
 231}
 232
 233static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
 234{
 235	struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file);
 236
 237	return saa7164_g_std(fh->port, id);
 238}
 239
 240int saa7164_enum_input(struct file *file, void *priv, struct v4l2_input *i)
 241{
 242	static const char * const inputs[] = {
 243		"tuner", "composite", "svideo", "aux",
 244		"composite 2", "svideo 2", "aux 2"
 245	};
 246	int n;
 247
 248	if (i->index >= 7)
 249		return -EINVAL;
 250
 251	strscpy(i->name, inputs[i->index], sizeof(i->name));
 252
 253	if (i->index == 0)
 254		i->type = V4L2_INPUT_TYPE_TUNER;
 255	else
 256		i->type  = V4L2_INPUT_TYPE_CAMERA;
 257
 258	for (n = 0; n < ARRAY_SIZE(saa7164_tvnorms); n++)
 259		i->std |= saa7164_tvnorms[n].id;
 260
 261	return 0;
 262}
 263
 264int saa7164_g_input(struct saa7164_port *port, unsigned int *i)
 265{
 266	struct saa7164_dev *dev = port->dev;
 267
 268	if (saa7164_api_get_videomux(port) != SAA_OK)
 269		return -EIO;
 270
 271	*i = (port->mux_input - 1);
 272
 273	dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, *i);
 274
 275	return 0;
 276}
 277
 278static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
 279{
 280	struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file);
 281
 282	return saa7164_g_input(fh->port, i);
 283}
 284
 285int saa7164_s_input(struct saa7164_port *port, unsigned int i)
 286{
 287	struct saa7164_dev *dev = port->dev;
 288
 289	dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, i);
 290
 291	if (i >= 7)
 292		return -EINVAL;
 293
 294	port->mux_input = i + 1;
 295
 296	if (saa7164_api_set_videomux(port) != SAA_OK)
 297		return -EIO;
 298
 299	return 0;
 300}
 301
 302static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
 303{
 304	struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file);
 305
 306	return saa7164_s_input(fh->port, i);
 307}
 308
 309int saa7164_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
 310{
 311	struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file);
 312	struct saa7164_port *port = fh->port;
 313	struct saa7164_dev *dev = port->dev;
 314
 315	if (0 != t->index)
 316		return -EINVAL;
 317
 318	strscpy(t->name, "tuner", sizeof(t->name));
 319	t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO;
 320	t->rangelow = SAA7164_TV_MIN_FREQ;
 321	t->rangehigh = SAA7164_TV_MAX_FREQ;
 322
 323	dprintk(DBGLVL_ENC, "VIDIOC_G_TUNER: tuner type %d\n", t->type);
 324
 325	return 0;
 326}
 327
 328int saa7164_s_tuner(struct file *file, void *priv,
 329			   const struct v4l2_tuner *t)
 330{
 331	if (0 != t->index)
 332		return -EINVAL;
 333
 334	/* Update the A/V core */
 335	return 0;
 336}
 337
 338int saa7164_g_frequency(struct saa7164_port *port, struct v4l2_frequency *f)
 339{
 340	if (f->tuner)
 341		return -EINVAL;
 342
 343	f->frequency = port->freq;
 344	return 0;
 345}
 346
 347static int vidioc_g_frequency(struct file *file, void *priv,
 348	struct v4l2_frequency *f)
 349{
 350	struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file);
 351
 352	return saa7164_g_frequency(fh->port, f);
 353}
 354
 355int saa7164_s_frequency(struct saa7164_port *port,
 356			const struct v4l2_frequency *f)
 357{
 358	struct saa7164_dev *dev = port->dev;
 359	struct saa7164_port *tsport;
 360	struct dvb_frontend *fe;
 361
 362	/* TODO: Pull this for the std */
 363	struct analog_parameters params = {
 364		.mode      = V4L2_TUNER_ANALOG_TV,
 365		.audmode   = V4L2_TUNER_MODE_STEREO,
 366		.std       = port->encodernorm.id,
 367		.frequency = f->frequency
 368	};
 369
 370	/* Stop the encoder */
 371	dprintk(DBGLVL_ENC, "%s() frequency=%d tuner=%d\n", __func__,
 372		f->frequency, f->tuner);
 373
 374	if (f->tuner != 0)
 375		return -EINVAL;
 376
 377	port->freq = clamp(f->frequency,
 378			   SAA7164_TV_MIN_FREQ, SAA7164_TV_MAX_FREQ);
 379
 380	/* Update the hardware */
 381	if (port->nr == SAA7164_PORT_ENC1)
 382		tsport = &dev->ports[SAA7164_PORT_TS1];
 383	else if (port->nr == SAA7164_PORT_ENC2)
 384		tsport = &dev->ports[SAA7164_PORT_TS2];
 385	else
 386		return -EINVAL; /* should not happen */
 387
 388	fe = tsport->dvb.frontend;
 389
 390	if (fe && fe->ops.tuner_ops.set_analog_params)
 391		fe->ops.tuner_ops.set_analog_params(fe, &params);
 392	else
 393		printk(KERN_ERR "%s() No analog tuner, aborting\n", __func__);
 394
 395	saa7164_encoder_initialize(port);
 396
 397	return 0;
 398}
 399
 400static int vidioc_s_frequency(struct file *file, void *priv,
 401			      const struct v4l2_frequency *f)
 402{
 403	struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file);
 404
 405	return saa7164_s_frequency(fh->port, f);
 406}
 407
 408static int saa7164_s_ctrl(struct v4l2_ctrl *ctrl)
 409{
 410	struct saa7164_port *port =
 411		container_of(ctrl->handler, struct saa7164_port, ctrl_handler);
 412	struct saa7164_encoder_params *params = &port->encoder_params;
 413	int ret = 0;
 414
 415	switch (ctrl->id) {
 416	case V4L2_CID_BRIGHTNESS:
 417		port->ctl_brightness = ctrl->val;
 418		saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL);
 419		break;
 420	case V4L2_CID_CONTRAST:
 421		port->ctl_contrast = ctrl->val;
 422		saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
 423		break;
 424	case V4L2_CID_SATURATION:
 425		port->ctl_saturation = ctrl->val;
 426		saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL);
 427		break;
 428	case V4L2_CID_HUE:
 429		port->ctl_hue = ctrl->val;
 430		saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
 431		break;
 432	case V4L2_CID_SHARPNESS:
 433		port->ctl_sharpness = ctrl->val;
 434		saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
 435		break;
 436	case V4L2_CID_AUDIO_VOLUME:
 437		port->ctl_volume = ctrl->val;
 438		saa7164_api_set_audio_volume(port, port->ctl_volume);
 439		break;
 440	case V4L2_CID_MPEG_VIDEO_BITRATE:
 441		params->bitrate = ctrl->val;
 442		break;
 443	case V4L2_CID_MPEG_STREAM_TYPE:
 444		params->stream_type = ctrl->val;
 445		break;
 446	case V4L2_CID_MPEG_AUDIO_MUTE:
 447		params->ctl_mute = ctrl->val;
 448		ret = saa7164_api_audio_mute(port, params->ctl_mute);
 449		if (ret != SAA_OK) {
 450			printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
 451				ret);
 452			ret = -EIO;
 453		}
 454		break;
 455	case V4L2_CID_MPEG_VIDEO_ASPECT:
 456		params->ctl_aspect = ctrl->val;
 457		ret = saa7164_api_set_aspect_ratio(port);
 458		if (ret != SAA_OK) {
 459			printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
 460				ret);
 461			ret = -EIO;
 462		}
 463		break;
 464	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
 465		params->bitrate_mode = ctrl->val;
 466		break;
 467	case V4L2_CID_MPEG_VIDEO_B_FRAMES:
 468		params->refdist = ctrl->val;
 469		break;
 470	case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
 471		params->bitrate_peak = ctrl->val;
 472		break;
 473	case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
 474		params->gop_size = ctrl->val;
 475		break;
 476	default:
 477		ret = -EINVAL;
 478	}
 479
 480	return ret;
 481}
 482
 483static int vidioc_querycap(struct file *file, void  *priv,
 484	struct v4l2_capability *cap)
 485{
 486	struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file);
 487	struct saa7164_port *port = fh->port;
 488	struct saa7164_dev *dev = port->dev;
 489
 490	strscpy(cap->driver, dev->name, sizeof(cap->driver));
 491	strscpy(cap->card, saa7164_boards[dev->board].name,
 492		sizeof(cap->card));
 493	cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
 494			    V4L2_CAP_TUNER | V4L2_CAP_VBI_CAPTURE |
 495			    V4L2_CAP_DEVICE_CAPS;
 496	return 0;
 497}
 498
 499static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
 500	struct v4l2_fmtdesc *f)
 501{
 502	if (f->index != 0)
 503		return -EINVAL;
 504
 505	f->pixelformat = V4L2_PIX_FMT_MPEG;
 506
 507	return 0;
 508}
 509
 510static int vidioc_fmt_vid_cap(struct file *file, void *priv,
 511				struct v4l2_format *f)
 512{
 513	struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file);
 514	struct saa7164_port *port = fh->port;
 515
 516	f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
 517	f->fmt.pix.bytesperline = 0;
 518	f->fmt.pix.sizeimage    = SAA7164_SIZEIMAGE;
 519	f->fmt.pix.field        = V4L2_FIELD_INTERLACED;
 520	f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
 521	f->fmt.pix.width        = port->width;
 522	f->fmt.pix.height       = port->height;
 523	return 0;
 524}
 525
 526static int saa7164_encoder_stop_port(struct saa7164_port *port)
 527{
 528	struct saa7164_dev *dev = port->dev;
 529	int ret;
 530
 531	ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 532	if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
 533		printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
 534			__func__, ret);
 535		ret = -EIO;
 536	} else {
 537		dprintk(DBGLVL_ENC, "%s()    Stopped\n", __func__);
 538		ret = 0;
 539	}
 540
 541	return ret;
 542}
 543
 544static int saa7164_encoder_acquire_port(struct saa7164_port *port)
 545{
 546	struct saa7164_dev *dev = port->dev;
 547	int ret;
 548
 549	ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
 550	if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
 551		printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
 552			__func__, ret);
 553		ret = -EIO;
 554	} else {
 555		dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__);
 556		ret = 0;
 557	}
 558
 559	return ret;
 560}
 561
 562static int saa7164_encoder_pause_port(struct saa7164_port *port)
 563{
 564	struct saa7164_dev *dev = port->dev;
 565	int ret;
 566
 567	ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
 568	if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
 569		printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
 570			__func__, ret);
 571		ret = -EIO;
 572	} else {
 573		dprintk(DBGLVL_ENC, "%s()   Paused\n", __func__);
 574		ret = 0;
 575	}
 576
 577	return ret;
 578}
 579
 580/* Firmware is very windows centric, meaning you have to transition
 581 * the part through AVStream / KS Windows stages, forwards or backwards.
 582 * States are: stopped, acquired (h/w), paused, started.
 583 * We have to leave here will all of the soft buffers on the free list,
 584 * else the cfg_post() func won't have soft buffers to correctly configure.
 585 */
 586static int saa7164_encoder_stop_streaming(struct saa7164_port *port)
 587{
 588	struct saa7164_dev *dev = port->dev;
 589	struct saa7164_buffer *buf;
 590	struct saa7164_user_buffer *ubuf;
 591	struct list_head *c, *n;
 592	int ret;
 593
 594	dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
 595
 596	ret = saa7164_encoder_pause_port(port);
 597	ret = saa7164_encoder_acquire_port(port);
 598	ret = saa7164_encoder_stop_port(port);
 599
 600	dprintk(DBGLVL_ENC, "%s(port=%d) Hardware stopped\n", __func__,
 601		port->nr);
 602
 603	/* Reset the state of any allocated buffer resources */
 604	mutex_lock(&port->dmaqueue_lock);
 605
 606	/* Reset the hard and soft buffer state */
 607	list_for_each_safe(c, n, &port->dmaqueue.list) {
 608		buf = list_entry(c, struct saa7164_buffer, list);
 609		buf->flags = SAA7164_BUFFER_FREE;
 610		buf->pos = 0;
 611	}
 612
 613	list_for_each_safe(c, n, &port->list_buf_used.list) {
 614		ubuf = list_entry(c, struct saa7164_user_buffer, list);
 615		ubuf->pos = 0;
 616		list_move_tail(&ubuf->list, &port->list_buf_free.list);
 617	}
 618
 619	mutex_unlock(&port->dmaqueue_lock);
 620
 621	/* Free any allocated resources */
 622	saa7164_encoder_buffers_dealloc(port);
 623
 624	dprintk(DBGLVL_ENC, "%s(port=%d) Released\n", __func__, port->nr);
 625
 626	return ret;
 627}
 628
 629static int saa7164_encoder_start_streaming(struct saa7164_port *port)
 630{
 631	struct saa7164_dev *dev = port->dev;
 632	int result, ret = 0;
 633
 634	dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
 635
 636	port->done_first_interrupt = 0;
 637
 638	/* allocate all of the PCIe DMA buffer resources on the fly,
 639	 * allowing switching between TS and PS payloads without
 640	 * requiring a complete driver reload.
 641	 */
 642	saa7164_encoder_buffers_alloc(port);
 643
 644	/* Configure the encoder with any cache values */
 645	saa7164_api_set_encoder(port);
 646	saa7164_api_get_encoder(port);
 647
 648	/* Place the empty buffers on the hardware */
 649	saa7164_buffer_cfg_port(port);
 650
 651	/* Acquire the hardware */
 652	result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
 653	if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 654		printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
 655			__func__, result);
 656
 657		/* Stop the hardware, regardless */
 658		result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 659		if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 660			printk(KERN_ERR "%s() acquire/forced stop transition failed, res = 0x%x\n",
 661			       __func__, result);
 662		}
 663		ret = -EIO;
 664		goto out;
 665	} else
 666		dprintk(DBGLVL_ENC, "%s()   Acquired\n", __func__);
 667
 668	/* Pause the hardware */
 669	result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
 670	if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 671		printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
 672				__func__, result);
 673
 674		/* Stop the hardware, regardless */
 675		result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 676		if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 677			printk(KERN_ERR "%s() pause/forced stop transition failed, res = 0x%x\n",
 678			       __func__, result);
 679		}
 680
 681		ret = -EIO;
 682		goto out;
 683	} else
 684		dprintk(DBGLVL_ENC, "%s()   Paused\n", __func__);
 685
 686	/* Start the hardware */
 687	result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
 688	if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 689		printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
 690				__func__, result);
 691
 692		/* Stop the hardware, regardless */
 693		result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
 694		if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
 695			printk(KERN_ERR "%s() run/forced stop transition failed, res = 0x%x\n",
 696			       __func__, result);
 697		}
 698
 699		ret = -EIO;
 700	} else
 701		dprintk(DBGLVL_ENC, "%s()   Running\n", __func__);
 702
 703out:
 704	return ret;
 705}
 706
 707static int fops_open(struct file *file)
 708{
 709	struct saa7164_dev *dev;
 710	struct saa7164_port *port;
 711	struct saa7164_encoder_fh *fh;
 712
 713	port = (struct saa7164_port *)video_get_drvdata(video_devdata(file));
 714	if (!port)
 715		return -ENODEV;
 716
 717	dev = port->dev;
 718
 719	dprintk(DBGLVL_ENC, "%s()\n", __func__);
 720
 721	/* allocate + initialize per filehandle data */
 722	fh = kzalloc(sizeof(*fh), GFP_KERNEL);
 723	if (NULL == fh)
 724		return -ENOMEM;
 725
 726	fh->port = port;
 727	v4l2_fh_init(&fh->fh, video_devdata(file));
 728	v4l2_fh_add(&fh->fh, file);
 729
 730	return 0;
 731}
 732
 733static int fops_release(struct file *file)
 734{
 735	struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file);
 736	struct saa7164_port *port = fh->port;
 737	struct saa7164_dev *dev = port->dev;
 738
 739	dprintk(DBGLVL_ENC, "%s()\n", __func__);
 740
 741	/* Shut device down on last close */
 742	if (atomic_cmpxchg(&fh->v4l_reading, 1, 0) == 1) {
 743		if (atomic_dec_return(&port->v4l_reader_count) == 0) {
 744			/* stop mpeg capture then cancel buffers */
 745			saa7164_encoder_stop_streaming(port);
 746		}
 747	}
 748
 749	v4l2_fh_del(&fh->fh, file);
 750	v4l2_fh_exit(&fh->fh);
 751	kfree(fh);
 752
 753	return 0;
 754}
 755
 756static struct
 757saa7164_user_buffer *saa7164_enc_next_buf(struct saa7164_port *port)
 758{
 759	struct saa7164_user_buffer *ubuf = NULL;
 760	struct saa7164_dev *dev = port->dev;
 761	u32 crc;
 762
 763	mutex_lock(&port->dmaqueue_lock);
 764	if (!list_empty(&port->list_buf_used.list)) {
 765		ubuf = list_first_entry(&port->list_buf_used.list,
 766			struct saa7164_user_buffer, list);
 767
 768		if (crc_checking) {
 769			crc = crc32(0, ubuf->data, ubuf->actual_size);
 770			if (crc != ubuf->crc) {
 771				printk(KERN_ERR
 772		"%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n",
 773					__func__,
 774					ubuf, ubuf->crc, crc);
 775			}
 776		}
 777
 778	}
 779	mutex_unlock(&port->dmaqueue_lock);
 780
 781	dprintk(DBGLVL_ENC, "%s() returns %p\n", __func__, ubuf);
 782
 783	return ubuf;
 784}
 785
 786static ssize_t fops_read(struct file *file, char __user *buffer,
 787	size_t count, loff_t *pos)
 788{
 789	struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file);
 790	struct saa7164_port *port = fh->port;
 791	struct saa7164_user_buffer *ubuf = NULL;
 792	struct saa7164_dev *dev = port->dev;
 793	int ret = 0;
 794	int rem, cnt;
 795	u8 *p;
 796
 797	port->last_read_msecs_diff = port->last_read_msecs;
 798	port->last_read_msecs = jiffies_to_msecs(jiffies);
 799	port->last_read_msecs_diff = port->last_read_msecs -
 800		port->last_read_msecs_diff;
 801
 802	saa7164_histogram_update(&port->read_interval,
 803		port->last_read_msecs_diff);
 804
 805	if (*pos) {
 806		printk(KERN_ERR "%s() ESPIPE\n", __func__);
 807		return -ESPIPE;
 808	}
 809
 810	if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
 811		if (atomic_inc_return(&port->v4l_reader_count) == 1) {
 812
 813			if (saa7164_encoder_initialize(port) < 0) {
 814				printk(KERN_ERR "%s() EINVAL\n", __func__);
 815				return -EINVAL;
 816			}
 817
 818			saa7164_encoder_start_streaming(port);
 819			msleep(200);
 820		}
 821	}
 822
 823	/* blocking wait for buffer */
 824	if ((file->f_flags & O_NONBLOCK) == 0) {
 825		if (wait_event_interruptible(port->wait_read,
 826			saa7164_enc_next_buf(port))) {
 827				printk(KERN_ERR "%s() ERESTARTSYS\n", __func__);
 828				return -ERESTARTSYS;
 829		}
 830	}
 831
 832	/* Pull the first buffer from the used list */
 833	ubuf = saa7164_enc_next_buf(port);
 834
 835	while ((count > 0) && ubuf) {
 836
 837		/* set remaining bytes to copy */
 838		rem = ubuf->actual_size - ubuf->pos;
 839		cnt = rem > count ? count : rem;
 840
 841		p = ubuf->data + ubuf->pos;
 842
 843		dprintk(DBGLVL_ENC,
 844			"%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n",
 845			__func__, (int)count, cnt, rem, ubuf, ubuf->pos);
 846
 847		if (copy_to_user(buffer, p, cnt)) {
 848			printk(KERN_ERR "%s() copy_to_user failed\n", __func__);
 849			if (!ret) {
 850				printk(KERN_ERR "%s() EFAULT\n", __func__);
 851				ret = -EFAULT;
 852			}
 853			goto err;
 854		}
 855
 856		ubuf->pos += cnt;
 857		count -= cnt;
 858		buffer += cnt;
 859		ret += cnt;
 860
 861		if (ubuf->pos > ubuf->actual_size)
 862			printk(KERN_ERR "read() pos > actual, huh?\n");
 863
 864		if (ubuf->pos == ubuf->actual_size) {
 865
 866			/* finished with current buffer, take next buffer */
 867
 868			/* Requeue the buffer on the free list */
 869			ubuf->pos = 0;
 870
 871			mutex_lock(&port->dmaqueue_lock);
 872			list_move_tail(&ubuf->list, &port->list_buf_free.list);
 873			mutex_unlock(&port->dmaqueue_lock);
 874
 875			/* Dequeue next */
 876			if ((file->f_flags & O_NONBLOCK) == 0) {
 877				if (wait_event_interruptible(port->wait_read,
 878					saa7164_enc_next_buf(port))) {
 879						break;
 880				}
 881			}
 882			ubuf = saa7164_enc_next_buf(port);
 883		}
 884	}
 885err:
 886	if (!ret && !ubuf)
 887		ret = -EAGAIN;
 888
 889	return ret;
 890}
 891
 892static __poll_t fops_poll(struct file *file, poll_table *wait)
 893{
 894	__poll_t req_events = poll_requested_events(wait);
 895	struct saa7164_encoder_fh *fh = to_saa7164_encoder_fh(file);
 896	struct saa7164_port *port = fh->port;
 897	__poll_t mask = v4l2_ctrl_poll(file, wait);
 898
 899	port->last_poll_msecs_diff = port->last_poll_msecs;
 900	port->last_poll_msecs = jiffies_to_msecs(jiffies);
 901	port->last_poll_msecs_diff = port->last_poll_msecs -
 902		port->last_poll_msecs_diff;
 903
 904	saa7164_histogram_update(&port->poll_interval,
 905		port->last_poll_msecs_diff);
 906
 907	if (!(req_events & (EPOLLIN | EPOLLRDNORM)))
 908		return mask;
 909
 910	if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
 911		if (atomic_inc_return(&port->v4l_reader_count) == 1) {
 912			if (saa7164_encoder_initialize(port) < 0)
 913				return mask | EPOLLERR;
 914			saa7164_encoder_start_streaming(port);
 915			msleep(200);
 916		}
 917	}
 918
 919	/* Pull the first buffer from the used list */
 920	if (!list_empty(&port->list_buf_used.list))
 921		mask |= EPOLLIN | EPOLLRDNORM;
 922
 923	return mask;
 924}
 925
 926static const struct v4l2_ctrl_ops saa7164_ctrl_ops = {
 927	.s_ctrl = saa7164_s_ctrl,
 928};
 929
 930static const struct v4l2_file_operations mpeg_fops = {
 931	.owner		= THIS_MODULE,
 932	.open		= fops_open,
 933	.release	= fops_release,
 934	.read		= fops_read,
 935	.poll		= fops_poll,
 936	.unlocked_ioctl	= video_ioctl2,
 937};
 938
 939static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
 940	.vidioc_s_std		 = vidioc_s_std,
 941	.vidioc_g_std		 = vidioc_g_std,
 942	.vidioc_enum_input	 = saa7164_enum_input,
 943	.vidioc_g_input		 = vidioc_g_input,
 944	.vidioc_s_input		 = vidioc_s_input,
 945	.vidioc_g_tuner		 = saa7164_g_tuner,
 946	.vidioc_s_tuner		 = saa7164_s_tuner,
 947	.vidioc_g_frequency	 = vidioc_g_frequency,
 948	.vidioc_s_frequency	 = vidioc_s_frequency,
 949	.vidioc_querycap	 = vidioc_querycap,
 950	.vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
 951	.vidioc_g_fmt_vid_cap	 = vidioc_fmt_vid_cap,
 952	.vidioc_try_fmt_vid_cap	 = vidioc_fmt_vid_cap,
 953	.vidioc_s_fmt_vid_cap	 = vidioc_fmt_vid_cap,
 954	.vidioc_log_status	 = v4l2_ctrl_log_status,
 955	.vidioc_subscribe_event  = v4l2_ctrl_subscribe_event,
 956	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 957};
 958
 959static struct video_device saa7164_mpeg_template = {
 960	.name          = "saa7164",
 961	.fops          = &mpeg_fops,
 962	.ioctl_ops     = &mpeg_ioctl_ops,
 963	.minor         = -1,
 964	.tvnorms       = SAA7164_NORMS,
 965	.device_caps   = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
 966			 V4L2_CAP_TUNER,
 967};
 968
 969static struct video_device *saa7164_encoder_alloc(
 970	struct saa7164_port *port,
 971	struct pci_dev *pci,
 972	struct video_device *template,
 973	char *type)
 974{
 975	struct video_device *vfd;
 976	struct saa7164_dev *dev = port->dev;
 977
 978	dprintk(DBGLVL_ENC, "%s()\n", __func__);
 979
 980	vfd = video_device_alloc();
 981	if (NULL == vfd)
 982		return NULL;
 983
 984	*vfd = *template;
 985	snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name,
 986		type, saa7164_boards[dev->board].name);
 987
 988	vfd->v4l2_dev  = &dev->v4l2_dev;
 989	vfd->release = video_device_release;
 990	return vfd;
 991}
 992
 993int saa7164_encoder_register(struct saa7164_port *port)
 994{
 995	struct saa7164_dev *dev = port->dev;
 996	struct v4l2_ctrl_handler *hdl = &port->ctrl_handler;
 997	int result = -ENODEV;
 998
 999	dprintk(DBGLVL_ENC, "%s()\n", __func__);
1000
1001	BUG_ON(port->type != SAA7164_MPEG_ENCODER);
1002
1003	/* Sanity check that the PCI configuration space is active */
1004	if (port->hwcfg.BARLocation == 0) {
1005		printk(KERN_ERR "%s() failed (errno = %d), NO PCI configuration\n",
1006			__func__, result);
1007		result = -ENOMEM;
1008		goto fail_pci;
1009	}
1010
1011	/* Establish encoder defaults here */
1012	/* Set default TV standard */
1013	port->encodernorm = saa7164_tvnorms[0];
1014	port->width = 720;
1015	port->mux_input = 1; /* Composite */
1016	port->video_format = EU_VIDEO_FORMAT_MPEG_2;
1017	port->audio_format = 0;
1018	port->video_resolution = 0;
1019	port->freq = SAA7164_TV_MIN_FREQ;
1020
1021	v4l2_ctrl_handler_init(hdl, 14);
1022	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1023			  V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1024	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1025			  V4L2_CID_CONTRAST, 0, 255, 1, 66);
1026	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1027			  V4L2_CID_SATURATION, 0, 255, 1, 62);
1028	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1029			  V4L2_CID_HUE, 0, 255, 1, 128);
1030	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1031			  V4L2_CID_SHARPNESS, 0x0, 0x0f, 1, 8);
1032	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1033			  V4L2_CID_MPEG_AUDIO_MUTE, 0x0, 0x01, 1, 0);
1034	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1035			  V4L2_CID_AUDIO_VOLUME, -83, 24, 1, 20);
1036	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1037			  V4L2_CID_MPEG_VIDEO_BITRATE,
1038			  ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
1039			  100000, ENCODER_DEF_BITRATE);
1040	v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops,
1041			       V4L2_CID_MPEG_STREAM_TYPE,
1042			       V4L2_MPEG_STREAM_TYPE_MPEG2_TS, 0,
1043			       V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
1044	v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops,
1045			       V4L2_CID_MPEG_VIDEO_ASPECT,
1046			       V4L2_MPEG_VIDEO_ASPECT_221x100, 0,
1047			       V4L2_MPEG_VIDEO_ASPECT_4x3);
1048	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1049			  V4L2_CID_MPEG_VIDEO_GOP_SIZE, 1, 255, 1, 15);
1050	v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops,
1051			       V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
1052			       V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 0,
1053			       V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
1054	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1055			  V4L2_CID_MPEG_VIDEO_B_FRAMES, 1, 3, 1, 1);
1056	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1057			  V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
1058			  ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
1059			  100000, ENCODER_DEF_BITRATE);
1060	if (hdl->error) {
1061		result = hdl->error;
1062		goto fail_hdl;
1063	}
1064
1065	port->std = V4L2_STD_NTSC_M;
1066
1067	if (port->encodernorm.id & V4L2_STD_525_60)
1068		port->height = 480;
1069	else
1070		port->height = 576;
1071
1072	/* Allocate and register the video device node */
1073	port->v4l_device = saa7164_encoder_alloc(port,
1074		dev->pci, &saa7164_mpeg_template, "mpeg");
1075
1076	if (!port->v4l_device) {
1077		printk(KERN_INFO "%s: can't allocate mpeg device\n",
1078			dev->name);
1079		result = -ENOMEM;
1080		goto fail_hdl;
1081	}
1082
1083	port->v4l_device->ctrl_handler = hdl;
1084	v4l2_ctrl_handler_setup(hdl);
1085	video_set_drvdata(port->v4l_device, port);
1086	result = video_register_device(port->v4l_device,
1087		VFL_TYPE_VIDEO, -1);
1088	if (result < 0) {
1089		printk(KERN_INFO "%s: can't register mpeg device\n",
1090			dev->name);
1091		goto fail_reg;
1092	}
1093
1094	printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
1095		dev->name, port->v4l_device->num);
1096
1097	/* Configure the hardware defaults */
1098	saa7164_api_set_videomux(port);
1099	saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL);
1100	saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
1101	saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
1102	saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL);
1103	saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
1104	saa7164_api_audio_mute(port, 0);
1105	saa7164_api_set_audio_volume(port, 20);
1106	saa7164_api_set_aspect_ratio(port);
1107
1108	/* Disable audio standard detection, it's buggy */
1109	saa7164_api_set_audio_detection(port, 0);
1110
1111	saa7164_api_set_encoder(port);
1112	saa7164_api_get_encoder(port);
1113	return 0;
1114
1115fail_reg:
1116	video_device_release(port->v4l_device);
1117	port->v4l_device = NULL;
1118fail_hdl:
1119	v4l2_ctrl_handler_free(hdl);
1120fail_pci:
1121	return result;
1122}
1123
1124void saa7164_encoder_unregister(struct saa7164_port *port)
1125{
1126	struct saa7164_dev *dev = port->dev;
1127
1128	dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
1129
1130	BUG_ON(port->type != SAA7164_MPEG_ENCODER);
1131
1132	if (port->v4l_device) {
1133		if (port->v4l_device->minor != -1)
1134			video_unregister_device(port->v4l_device);
1135		else
1136			video_device_release(port->v4l_device);
1137
1138		port->v4l_device = NULL;
1139	}
1140	v4l2_ctrl_handler_free(&port->ctrl_handler);
1141
1142	dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
1143}
1144