av7110_av.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * driver for the SAA7146 based AV110 cards
   4 * - audio and video MPEG decoder stuff
   5 *
   6 * Copyright (C) 1999-2002 Ralph  Metzler
   7 *                       & Marcus Metzler for convergence integrated media GmbH
   8 *
   9 * originally based on code by:
  10 * Copyright (C) 1998,1999 Christian Theiss <mistert@rz.fh-augsburg.de>
  11 *
  12 * the project's page is at https://linuxtv.org
  13 */
  14
  15#include <linux/ethtool.h>
  16#include <linux/types.h>
  17#include <linux/kernel.h>
  18#include <linux/string.h>
  19#include <linux/delay.h>
  20#include <linux/fs.h>
  21
  22#include "av7110.h"
  23#include "av7110_hw.h"
  24#include "av7110_av.h"
  25#include "av7110_ipack.h"
  26
  27/* MPEG-2 (ISO 13818 / H.222.0) stream types */
  28#define PROG_STREAM_MAP  0xBC
  29#define PRIVATE_STREAM1  0xBD
  30#define PADDING_STREAM	 0xBE
  31#define PRIVATE_STREAM2  0xBF
  32#define AUDIO_STREAM_S	 0xC0
  33#define AUDIO_STREAM_E	 0xDF
  34#define VIDEO_STREAM_S	 0xE0
  35#define VIDEO_STREAM_E	 0xEF
  36#define ECM_STREAM	 0xF0
  37#define EMM_STREAM	 0xF1
  38#define DSM_CC_STREAM	 0xF2
  39#define ISO13522_STREAM  0xF3
  40#define PROG_STREAM_DIR  0xFF
  41
  42#define PTS_DTS_FLAGS	 0xC0
  43
  44//pts_dts flags
  45#define PTS_ONLY	 0x80
  46#define PTS_DTS		 0xC0
  47#define TS_SIZE		 188
  48#define TRANS_ERROR	 0x80
  49#define PAY_START	 0x40
  50#define TRANS_PRIO	 0x20
  51#define PID_MASK_HI	 0x1F
  52//flags
  53#define TRANS_SCRMBL1	 0x80
  54#define TRANS_SCRMBL2	 0x40
  55#define ADAPT_FIELD	 0x20
  56#define PAYLOAD		 0x10
  57#define COUNT_MASK	 0x0F
  58
  59// adaptation flags
  60#define DISCON_IND	 0x80
  61#define RAND_ACC_IND	 0x40
  62#define ES_PRI_IND	 0x20
  63#define PCR_FLAG	 0x10
  64#define OPCR_FLAG	 0x08
  65#define SPLICE_FLAG	 0x04
  66#define TRANS_PRIV	 0x02
  67#define ADAP_EXT_FLAG	 0x01
  68
  69// adaptation extension flags
  70#define LTW_FLAG	 0x80
  71#define PIECE_RATE	 0x40
  72#define SEAM_SPLICE	 0x20
  73
  74static void p_to_t(u8 const *buf, long length, u16 pid,
  75		   u8 *counter, struct dvb_demux_feed *feed);
  76static int write_ts_to_decoder(struct av7110 *av7110, int type, const u8 *buf, size_t len);
  77
  78int av7110_record_cb(struct dvb_filter_pes2ts *p2t, u8 *buf, size_t len)
  79{
  80	struct dvb_demux_feed *dvbdmxfeed = p2t->priv;
  81
  82	if (!(dvbdmxfeed->ts_type & TS_PACKET))
  83		return 0;
  84	if (buf[3] == 0xe0) {	 // video PES do not have a length in TS
  85		buf[4] = 0;
  86		buf[5] = 0;
  87	}
  88	if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)
  89		return dvbdmxfeed->cb.ts(buf, len, NULL, 0,
  90					 &dvbdmxfeed->feed.ts, NULL);
  91	else
  92		return dvb_filter_pes2ts(p2t, buf, len, 1);
  93}
  94
  95static int dvb_filter_pes2ts_cb(void *priv, unsigned char *data)
  96{
  97	struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)priv;
  98
  99	dvbdmxfeed->cb.ts(data, 188, NULL, 0,
 100			  &dvbdmxfeed->feed.ts, NULL);
 101	return 0;
 102}
 103
 104int av7110_av_start_record(struct av7110 *av7110, int av,
 105			   struct dvb_demux_feed *dvbdmxfeed)
 106{
 107	int ret = 0;
 108	struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
 109
 110	dprintk(2, "av7110:%p, dvb_demux_feed:%p\n", av7110, dvbdmxfeed);
 111
 112	if (av7110->playing || (av7110->rec_mode & av))
 113		return -EBUSY;
 114	av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Stop, 0);
 115	dvbdmx->recording = 1;
 116	av7110->rec_mode |= av;
 117
 118	switch (av7110->rec_mode) {
 119	case RP_AUDIO:
 120		dvb_filter_pes2ts_init(&av7110->p2t[0],
 121				       dvbdmx->pesfilter[0]->pid,
 122				       dvb_filter_pes2ts_cb,
 123				       (void *)dvbdmx->pesfilter[0]);
 124		ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Record, 2, AudioPES, 0);
 125		break;
 126
 127	case RP_VIDEO:
 128		dvb_filter_pes2ts_init(&av7110->p2t[1],
 129				       dvbdmx->pesfilter[1]->pid,
 130				       dvb_filter_pes2ts_cb,
 131				       (void *)dvbdmx->pesfilter[1]);
 132		ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Record, 2, VideoPES, 0);
 133		break;
 134
 135	case RP_AV:
 136		dvb_filter_pes2ts_init(&av7110->p2t[0],
 137				       dvbdmx->pesfilter[0]->pid,
 138				       dvb_filter_pes2ts_cb,
 139				       (void *)dvbdmx->pesfilter[0]);
 140		dvb_filter_pes2ts_init(&av7110->p2t[1],
 141				       dvbdmx->pesfilter[1]->pid,
 142				       dvb_filter_pes2ts_cb,
 143				       (void *)dvbdmx->pesfilter[1]);
 144		ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Record, 2, AV_PES, 0);
 145		break;
 146	}
 147	return ret;
 148}
 149
 150int av7110_av_start_play(struct av7110 *av7110, int av)
 151{
 152	int ret = 0;
 153
 154	dprintk(2, "av7110:%p\n", av7110);
 155
 156	if (av7110->rec_mode)
 157		return -EBUSY;
 158	if (av7110->playing & av)
 159		return -EBUSY;
 160
 161	av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Stop, 0);
 162
 163	if (av7110->playing == RP_NONE) {
 164		av7110_ipack_reset(&av7110->ipack[0]);
 165		av7110_ipack_reset(&av7110->ipack[1]);
 166	}
 167
 168	av7110->playing |= av;
 169	switch (av7110->playing) {
 170	case RP_AUDIO:
 171		ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Play, 2, AudioPES, 0);
 172		break;
 173	case RP_VIDEO:
 174		ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Play, 2, VideoPES, 0);
 175		av7110->sinfo = 0;
 176		break;
 177	case RP_AV:
 178		av7110->sinfo = 0;
 179		ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Play, 2, AV_PES, 0);
 180		break;
 181	}
 182	return ret;
 183}
 184
 185int av7110_av_stop(struct av7110 *av7110, int av)
 186{
 187	int ret = 0;
 188
 189	dprintk(2, "av7110:%p\n", av7110);
 190
 191	if (!(av7110->playing & av) && !(av7110->rec_mode & av))
 192		return 0;
 193	av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Stop, 0);
 194	if (av7110->playing) {
 195		av7110->playing &= ~av;
 196		switch (av7110->playing) {
 197		case RP_AUDIO:
 198			ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Play, 2, AudioPES, 0);
 199			break;
 200		case RP_VIDEO:
 201			ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Play, 2, VideoPES, 0);
 202			break;
 203		case RP_NONE:
 204			ret = av7110_set_vidmode(av7110, av7110->vidmode);
 205			break;
 206		}
 207	} else {
 208		av7110->rec_mode &= ~av;
 209		switch (av7110->rec_mode) {
 210		case RP_AUDIO:
 211			ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Record, 2, AudioPES, 0);
 212			break;
 213		case RP_VIDEO:
 214			ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Record, 2, VideoPES, 0);
 215			break;
 216		case RP_NONE:
 217			break;
 218		}
 219	}
 220	return ret;
 221}
 222
 223int av7110_pes_play(void *dest, struct dvb_ringbuffer *buf, int dlen)
 224{
 225	int len;
 226	u32 sync;
 227	u16 blen;
 228
 229	if (!dlen) {
 230		wake_up(&buf->queue);
 231		return -1;
 232	}
 233	while (1) {
 234		len = dvb_ringbuffer_avail(buf);
 235		if (len < 6) {
 236			wake_up(&buf->queue);
 237			return -1;
 238		}
 239		sync =  DVB_RINGBUFFER_PEEK(buf, 0) << 24;
 240		sync |= DVB_RINGBUFFER_PEEK(buf, 1) << 16;
 241		sync |= DVB_RINGBUFFER_PEEK(buf, 2) << 8;
 242		sync |= DVB_RINGBUFFER_PEEK(buf, 3);
 243
 244		if (((sync & ~0x0f) == 0x000001e0) ||
 245		    ((sync & ~0x1f) == 0x000001c0) ||
 246		    (sync == 0x000001bd))
 247			break;
 248		pr_info("resync\n");
 249		DVB_RINGBUFFER_SKIP(buf, 1);
 250	}
 251	blen =  DVB_RINGBUFFER_PEEK(buf, 4) << 8;
 252	blen |= DVB_RINGBUFFER_PEEK(buf, 5);
 253	blen += 6;
 254	if (len < blen || blen > dlen) {
 255		//pr_info("buffer empty - avail %d blen %u dlen %d\n", len, blen, dlen);
 256		wake_up(&buf->queue);
 257		return -1;
 258	}
 259
 260	dvb_ringbuffer_read(buf, dest, (size_t)blen);
 261
 262	dprintk(2, "pread=0x%08lx, pwrite=0x%08lx\n",
 263		(unsigned long)buf->pread, (unsigned long)buf->pwrite);
 264	wake_up(&buf->queue);
 265	return blen;
 266}
 267
 268int av7110_set_volume(struct av7110 *av7110, unsigned int volleft,
 269		      unsigned int volright)
 270{
 271	unsigned int vol, val, balance = 0;
 272	int err;
 273
 274	dprintk(2, "av7110:%p\n", av7110);
 275
 276	av7110->mixer.volume_left = volleft;
 277	av7110->mixer.volume_right = volright;
 278
 279	switch (av7110->adac_type) {
 280	case DVB_ADAC_TI:
 281		volleft = (volleft * 256) / 1036;
 282		volright = (volright * 256) / 1036;
 283		if (volleft > 0x3f)
 284			volleft = 0x3f;
 285		if (volright > 0x3f)
 286			volright = 0x3f;
 287		err = SendDAC(av7110, 3, 0x80 + volleft);
 288		if (err)
 289			return err;
 290		return SendDAC(av7110, 4, volright);
 291
 292	case DVB_ADAC_CRYSTAL:
 293		volleft = 127 - volleft / 2;
 294		volright = 127 - volright / 2;
 295		i2c_writereg(av7110, 0x20, 0x03, volleft);
 296		i2c_writereg(av7110, 0x20, 0x04, volright);
 297		return 0;
 298
 299	case DVB_ADAC_MSP34x0:
 300		vol  = (volleft > volright) ? volleft : volright;
 301		val	= (vol * 0x73 / 255) << 8;
 302		if (vol > 0)
 303			balance = ((volright - volleft) * 127) / vol;
 304		msp_writereg(av7110, MSP_WR_DSP, 0x0001, balance << 8);
 305		msp_writereg(av7110, MSP_WR_DSP, 0x0000, val); /* loudspeaker */
 306		msp_writereg(av7110, MSP_WR_DSP, 0x0006, val); /* headphonesr */
 307		return 0;
 308
 309	case DVB_ADAC_MSP34x5:
 310		vol = (volleft > volright) ? volleft : volright;
 311		val = (vol * 0x73 / 255) << 8;
 312		if (vol > 0)
 313			balance = ((volright - volleft) * 127) / vol;
 314		msp_writereg(av7110, MSP_WR_DSP, 0x0001, balance << 8);
 315		msp_writereg(av7110, MSP_WR_DSP, 0x0000, val); /* loudspeaker */
 316		return 0;
 317	}
 318
 319	return 0;
 320}
 321
 322int av7110_set_vidmode(struct av7110 *av7110, enum av7110_video_mode mode)
 323{
 324	int ret;
 325
 326	dprintk(2, "av7110:%p\n", av7110);
 327
 328	ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, LoadVidCode, 1, mode);
 329
 330	if (!ret && !av7110->playing) {
 331		ret = ChangePIDs(av7110, av7110->pids[DMX_PES_VIDEO],
 332				 av7110->pids[DMX_PES_AUDIO],
 333			   av7110->pids[DMX_PES_TELETEXT],
 334			   0, av7110->pids[DMX_PES_PCR]);
 335		if (!ret)
 336			ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, Scan, 0);
 337	}
 338	return ret;
 339}
 340
 341static enum av7110_video_mode sw2mode[16] = {
 342	AV7110_VIDEO_MODE_PAL, AV7110_VIDEO_MODE_NTSC,
 343	AV7110_VIDEO_MODE_NTSC, AV7110_VIDEO_MODE_PAL,
 344	AV7110_VIDEO_MODE_NTSC, AV7110_VIDEO_MODE_NTSC,
 345	AV7110_VIDEO_MODE_PAL, AV7110_VIDEO_MODE_NTSC,
 346	AV7110_VIDEO_MODE_PAL, AV7110_VIDEO_MODE_PAL,
 347	AV7110_VIDEO_MODE_PAL, AV7110_VIDEO_MODE_PAL,
 348	AV7110_VIDEO_MODE_PAL, AV7110_VIDEO_MODE_PAL,
 349	AV7110_VIDEO_MODE_PAL, AV7110_VIDEO_MODE_PAL,
 350};
 351
 352static int get_video_format(struct av7110 *av7110, u8 *buf, int count)
 353{
 354	int i;
 355	int hsize, vsize;
 356	int sw;
 357	u8 *p;
 358	int ret = 0;
 359
 360	dprintk(2, "av7110:%p\n", av7110);
 361
 362	if (av7110->sinfo)
 363		return 0;
 364	for (i = 7; i < count - 10; i++) {
 365		p = buf + i;
 366		if (p[0] || p[1] || p[2] != 0x01 || p[3] != 0xb3)
 367			continue;
 368		p += 4;
 369		hsize = ((p[1] & 0xF0) >> 4) | (p[0] << 4);
 370		vsize = ((p[1] & 0x0F) << 8) | (p[2]);
 371		sw = (p[3] & 0x0F);
 372		ret = av7110_set_vidmode(av7110, sw2mode[sw]);
 373		if (!ret) {
 374			dprintk(2, "playback %dx%d fr=%d\n", hsize, vsize, sw);
 375			av7110->sinfo = 1;
 376		}
 377		break;
 378	}
 379	return ret;
 380}
 381
 382/****************************************************************************
 383 * I/O buffer management and control
 384 ****************************************************************************/
 385
 386static inline long aux_ring_buffer_write(struct dvb_ringbuffer *rbuf,
 387					 const u8 *buf, unsigned long count)
 388{
 389	unsigned long todo = count;
 390	int free;
 391
 392	while (todo > 0) {
 393		if (dvb_ringbuffer_free(rbuf) < 2048) {
 394			if (wait_event_interruptible(rbuf->queue,
 395						     (dvb_ringbuffer_free(rbuf) >= 2048)))
 396				return count - todo;
 397		}
 398		free = dvb_ringbuffer_free(rbuf);
 399		if (free > todo)
 400			free = todo;
 401		dvb_ringbuffer_write(rbuf, buf, free);
 402		todo -= free;
 403		buf += free;
 404	}
 405
 406	return count - todo;
 407}
 408
 409static void play_video_cb(u8 *buf, int count, void *priv)
 410{
 411	struct av7110 *av7110 = (struct av7110 *)priv;
 412
 413	dprintk(2, "av7110:%p\n", av7110);
 414
 415	if ((buf[3] & 0xe0) == 0xe0) {
 416		get_video_format(av7110, buf, count);
 417		aux_ring_buffer_write(&av7110->avout, buf, count);
 418	} else {
 419		aux_ring_buffer_write(&av7110->aout, buf, count);
 420	}
 421}
 422
 423static void play_audio_cb(u8 *buf, int count, void *priv)
 424{
 425	struct av7110 *av7110 = (struct av7110 *)priv;
 426
 427	dprintk(2, "av7110:%p\n", av7110);
 428
 429	aux_ring_buffer_write(&av7110->aout, buf, count);
 430}
 431
 432#define FREE_COND_TS (dvb_ringbuffer_free(rb) >= 4096)
 433
 434static ssize_t ts_play(struct av7110 *av7110, const char __user *buf,
 435		       unsigned long count, int nonblock, int type)
 436{
 437	struct dvb_ringbuffer *rb;
 438	u8 *kb;
 439	unsigned long todo = count;
 440
 441	dprintk(2, "type %d cnt %lu\n", type, count);
 442
 443	rb = (type) ? &av7110->avout : &av7110->aout;
 444	kb = av7110->kbuf[type];
 445
 446	if (!kb)
 447		return -ENOBUFS;
 448
 449	if (nonblock && !FREE_COND_TS)
 450		return -EWOULDBLOCK;
 451
 452	while (todo >= TS_SIZE) {
 453		if (!FREE_COND_TS) {
 454			if (nonblock)
 455				return count - todo;
 456			if (wait_event_interruptible(rb->queue, FREE_COND_TS))
 457				return count - todo;
 458		}
 459		if (copy_from_user(kb, buf, TS_SIZE))
 460			return -EFAULT;
 461		write_ts_to_decoder(av7110, type, kb, TS_SIZE);
 462		todo -= TS_SIZE;
 463		buf += TS_SIZE;
 464	}
 465
 466	return count - todo;
 467}
 468
 469#define FREE_COND (dvb_ringbuffer_free(&av7110->avout) >= 20 * 1024 && \
 470		   dvb_ringbuffer_free(&av7110->aout) >= 20 * 1024)
 471
 472static ssize_t dvb_play(struct av7110 *av7110, const char __user *buf,
 473			unsigned long count, int nonblock, int type)
 474{
 475	unsigned long todo = count, n;
 476
 477	dprintk(2, "av7110:%p\n", av7110);
 478
 479	if (!av7110->kbuf[type])
 480		return -ENOBUFS;
 481
 482	if (nonblock && !FREE_COND)
 483		return -EWOULDBLOCK;
 484
 485	while (todo > 0) {
 486		if (!FREE_COND) {
 487			if (nonblock)
 488				return count - todo;
 489			if (wait_event_interruptible(av7110->avout.queue,
 490						     FREE_COND))
 491				return count - todo;
 492		}
 493		n = todo;
 494		if (n > IPACKS * 2)
 495			n = IPACKS * 2;
 496		if (copy_from_user(av7110->kbuf[type], buf, n))
 497			return -EFAULT;
 498		av7110_ipack_instant_repack(av7110->kbuf[type], n,
 499					    &av7110->ipack[type]);
 500		todo -= n;
 501		buf += n;
 502	}
 503	return count - todo;
 504}
 505
 506static ssize_t dvb_play_kernel(struct av7110 *av7110, const u8 *buf,
 507			       unsigned long count, int nonblock, int type)
 508{
 509	unsigned long todo = count, n;
 510
 511	dprintk(2, "av7110:%p\n", av7110);
 512
 513	if (!av7110->kbuf[type])
 514		return -ENOBUFS;
 515
 516	if (nonblock && !FREE_COND)
 517		return -EWOULDBLOCK;
 518
 519	while (todo > 0) {
 520		if (!FREE_COND) {
 521			if (nonblock)
 522				return count - todo;
 523			if (wait_event_interruptible(av7110->avout.queue,
 524						     FREE_COND))
 525				return count - todo;
 526		}
 527		n = todo;
 528		if (n > IPACKS * 2)
 529			n = IPACKS * 2;
 530		av7110_ipack_instant_repack(buf, n, &av7110->ipack[type]);
 531		todo -= n;
 532		buf += n;
 533	}
 534	return count - todo;
 535}
 536
 537static ssize_t dvb_aplay(struct av7110 *av7110, const char __user *buf,
 538			 unsigned long count, int nonblock, int type)
 539{
 540	unsigned long todo = count, n;
 541
 542	dprintk(2, "av7110:%p\n", av7110);
 543
 544	if (!av7110->kbuf[type])
 545		return -ENOBUFS;
 546	if (nonblock && dvb_ringbuffer_free(&av7110->aout) < 20 * 1024)
 547		return -EWOULDBLOCK;
 548
 549	while (todo > 0) {
 550		if (dvb_ringbuffer_free(&av7110->aout) < 20 * 1024) {
 551			if (nonblock)
 552				return count - todo;
 553			if (wait_event_interruptible(av7110->aout.queue,
 554						     (dvb_ringbuffer_free(&av7110->aout) >= 20 * 1024)))
 555				return count - todo;
 556		}
 557		n = todo;
 558		if (n > IPACKS * 2)
 559			n = IPACKS * 2;
 560		if (copy_from_user(av7110->kbuf[type], buf, n))
 561			return -EFAULT;
 562		av7110_ipack_instant_repack(av7110->kbuf[type], n,
 563					    &av7110->ipack[type]);
 564		todo -= n;
 565		buf += n;
 566	}
 567	return count - todo;
 568}
 569
 570void av7110_p2t_init(struct av7110_p2t *p, struct dvb_demux_feed *feed)
 571{
 572	memset(p->pes, 0, TS_SIZE);
 573	p->counter = 0;
 574	p->pos = 0;
 575	p->frags = 0;
 576	if (feed)
 577		p->feed = feed;
 578}
 579
 580static void clear_p2t(struct av7110_p2t *p)
 581{
 582	memset(p->pes, 0, TS_SIZE);
 583//	p->counter = 0;
 584	p->pos = 0;
 585	p->frags = 0;
 586}
 587
 588static int find_pes_header(u8 const *buf, long length, int *frags)
 589{
 590	int c = 0;
 591	int found = 0;
 592
 593	*frags = 0;
 594
 595	while (c < length - 3 && !found) {
 596		if (buf[c] == 0x00 && buf[c + 1] == 0x00 &&
 597		    buf[c + 2] == 0x01) {
 598			switch (buf[c + 3]) {
 599			case PROG_STREAM_MAP:
 600			case PRIVATE_STREAM2:
 601			case PROG_STREAM_DIR:
 602			case ECM_STREAM:
 603			case EMM_STREAM:
 604			case PADDING_STREAM:
 605			case DSM_CC_STREAM:
 606			case ISO13522_STREAM:
 607			case PRIVATE_STREAM1:
 608			case AUDIO_STREAM_S ... AUDIO_STREAM_E:
 609			case VIDEO_STREAM_S ... VIDEO_STREAM_E:
 610				found = 1;
 611				break;
 612
 613			default:
 614				c++;
 615				break;
 616			}
 617		} else {
 618			c++;
 619		}
 620	}
 621	if (c == length - 3 && !found) {
 622		if (buf[length - 1] == 0x00)
 623			*frags = 1;
 624		if (buf[length - 2] == 0x00 &&
 625		    buf[length - 1] == 0x00)
 626			*frags = 2;
 627		if (buf[length - 3] == 0x00 &&
 628		    buf[length - 2] == 0x00 &&
 629		    buf[length - 1] == 0x01)
 630			*frags = 3;
 631		return -1;
 632	}
 633
 634	return c;
 635}
 636
 637void av7110_p2t_write(u8 const *buf, long length, u16 pid, struct av7110_p2t *p)
 638{
 639	int c, c2, l, add;
 640	int check, rest;
 641
 642	c = 0;
 643	c2 = 0;
 644	if (p->frags) {
 645		check = 0;
 646		switch (p->frags) {
 647		case 1:
 648			if (buf[c] == 0x00 && buf[c + 1] == 0x01) {
 649				check = 1;
 650				c += 2;
 651			}
 652			break;
 653		case 2:
 654			if (buf[c] == 0x01) {
 655				check = 1;
 656				c++;
 657			}
 658			break;
 659		case 3:
 660			check = 1;
 661		}
 662		if (check) {
 663			switch (buf[c]) {
 664			case PROG_STREAM_MAP:
 665			case PRIVATE_STREAM2:
 666			case PROG_STREAM_DIR:
 667			case ECM_STREAM:
 668			case EMM_STREAM:
 669			case PADDING_STREAM:
 670			case DSM_CC_STREAM:
 671			case ISO13522_STREAM:
 672			case PRIVATE_STREAM1:
 673			case AUDIO_STREAM_S ... AUDIO_STREAM_E:
 674			case VIDEO_STREAM_S ... VIDEO_STREAM_E:
 675				p->pes[0] = 0x00;
 676				p->pes[1] = 0x00;
 677				p->pes[2] = 0x01;
 678				p->pes[3] = buf[c];
 679				p->pos = 4;
 680				memcpy(p->pes + p->pos, buf + c, (TS_SIZE - 4) - p->pos);
 681				c += (TS_SIZE - 4) - p->pos;
 682				p_to_t(p->pes, (TS_SIZE - 4), pid, &p->counter, p->feed);
 683				clear_p2t(p);
 684				break;
 685
 686			default:
 687				c = 0;
 688				break;
 689			}
 690		}
 691		p->frags = 0;
 692	}
 693
 694	if (p->pos) {
 695		c2 = find_pes_header(buf + c, length - c, &p->frags);
 696		if (c2 >= 0 && c2 < (TS_SIZE - 4) - p->pos)
 697			l = c2 + c;
 698		else
 699			l = (TS_SIZE - 4) - p->pos;
 700		memcpy(p->pes + p->pos, buf, l);
 701		c += l;
 702		p->pos += l;
 703		p_to_t(p->pes, p->pos, pid, &p->counter, p->feed);
 704		clear_p2t(p);
 705	}
 706
 707	add = 0;
 708	while (c < length) {
 709		c2 = find_pes_header(buf + c + add, length - c - add, &p->frags);
 710		if (c2 >= 0) {
 711			c2 += c + add;
 712			if (c2 > c) {
 713				p_to_t(buf + c, c2 - c, pid, &p->counter, p->feed);
 714				c = c2;
 715				clear_p2t(p);
 716				add = 0;
 717			} else {
 718				add = 1;
 719			}
 720		} else {
 721			l = length - c;
 722			rest = l % (TS_SIZE - 4);
 723			l -= rest;
 724			p_to_t(buf + c, l, pid, &p->counter, p->feed);
 725			memcpy(p->pes, buf + c + l, rest);
 726			p->pos = rest;
 727			c = length;
 728		}
 729	}
 730}
 731
 732static int write_ts_header2(u16 pid, u8 *counter, int pes_start, u8 *buf, u8 length)
 733{
 734	int i;
 735	int c = 0;
 736	int fill;
 737	u8 tshead[4] = { 0x47, 0x00, 0x00, 0x10 };
 738
 739	fill = (TS_SIZE - 4) - length;
 740	if (pes_start)
 741		tshead[1] = 0x40;
 742	if (fill)
 743		tshead[3] = 0x30;
 744	tshead[1] |= (u8)((pid & 0x1F00) >> 8);
 745	tshead[2] |= (u8)(pid & 0x00FF);
 746	tshead[3] |= ((*counter)++ & 0x0F);
 747	memcpy(buf, tshead, 4);
 748	c += 4;
 749
 750	if (fill) {
 751		buf[4] = fill - 1;
 752		c++;
 753		if (fill > 1) {
 754			buf[5] = 0x00;
 755			c++;
 756		}
 757		for (i = 6; i < fill + 4; i++) {
 758			buf[i] = 0xFF;
 759			c++;
 760		}
 761	}
 762
 763	return c;
 764}
 765
 766static void p_to_t(u8 const *buf, long length, u16 pid, u8 *counter,
 767		   struct dvb_demux_feed *feed)
 768{
 769	int l, pes_start;
 770	u8 obuf[TS_SIZE];
 771	long c = 0;
 772
 773	pes_start = 0;
 774	if (length > 3 &&
 775	    buf[0] == 0x00 && buf[1] == 0x00 && buf[2] == 0x01)
 776		switch (buf[3]) {
 777		case PROG_STREAM_MAP:
 778		case PRIVATE_STREAM2:
 779		case PROG_STREAM_DIR:
 780		case ECM_STREAM:
 781		case EMM_STREAM:
 782		case PADDING_STREAM:
 783		case DSM_CC_STREAM:
 784		case ISO13522_STREAM:
 785		case PRIVATE_STREAM1:
 786		case AUDIO_STREAM_S ... AUDIO_STREAM_E:
 787		case VIDEO_STREAM_S ... VIDEO_STREAM_E:
 788			pes_start = 1;
 789			break;
 790
 791		default:
 792			break;
 793		}
 794
 795	while (c < length) {
 796		memset(obuf, 0, TS_SIZE);
 797		if (length - c >= (TS_SIZE - 4)) {
 798			l = write_ts_header2(pid, counter, pes_start,
 799					     obuf, (TS_SIZE - 4));
 800			memcpy(obuf + l, buf + c, TS_SIZE - l);
 801			c += TS_SIZE - l;
 802		} else {
 803			l = write_ts_header2(pid, counter, pes_start,
 804					     obuf, length - c);
 805			memcpy(obuf + l, buf + c, TS_SIZE - l);
 806			c = length;
 807		}
 808		feed->cb.ts(obuf, 188, NULL, 0, &feed->feed.ts, NULL);
 809		pes_start = 0;
 810	}
 811}
 812
 813static int write_ts_to_decoder(struct av7110 *av7110, int type, const u8 *buf, size_t len)
 814{
 815	struct ipack *ipack = &av7110->ipack[type];
 816
 817	if (buf[1] & TRANS_ERROR) {
 818		av7110_ipack_reset(ipack);
 819		return -1;
 820	}
 821
 822	if (!(buf[3] & PAYLOAD))
 823		return -1;
 824
 825	if (buf[1] & PAY_START)
 826		av7110_ipack_flush(ipack);
 827
 828	if (buf[3] & ADAPT_FIELD) {
 829		if (buf[4] > len - 1 - 4)
 830			return 0;
 831		len -= buf[4] + 1;
 832		buf += buf[4] + 1;
 833	}
 834
 835	av7110_ipack_instant_repack(buf + 4, len - 4, ipack);
 836	return 0;
 837}
 838
 839int av7110_write_to_decoder(struct dvb_demux_feed *feed, const u8 *buf, size_t len)
 840{
 841	struct dvb_demux *demux = feed->demux;
 842	struct av7110 *av7110 = demux->priv;
 843
 844	dprintk(2, "av7110:%p\n", av7110);
 845
 846	if (av7110->full_ts && demux->dmx.frontend->source != DMX_MEMORY_FE)
 847		return 0;
 848
 849	switch (feed->pes_type) {
 850	case 0:
 851		if (av7110->audiostate.stream_source == AUDIO_SOURCE_MEMORY)
 852			return -EINVAL;
 853		break;
 854	case 1:
 855		if (av7110->videostate.stream_source == VIDEO_SOURCE_MEMORY)
 856			return -EINVAL;
 857		break;
 858	default:
 859		return -1;
 860	}
 861
 862	return write_ts_to_decoder(av7110, feed->pes_type, buf, len);
 863}
 864
 865/******************************************************************************
 866 * Video MPEG decoder events
 867 ******************************************************************************/
 868void dvb_video_add_event(struct av7110 *av7110, struct video_event *event)
 869{
 870	struct dvb_video_events *events = &av7110->video_events;
 871	int wp;
 872
 873	spin_lock_bh(&events->lock);
 874
 875	wp = (events->eventw + 1) % MAX_VIDEO_EVENT;
 876	if (wp == events->eventr) {
 877		events->overflow = 1;
 878		events->eventr = (events->eventr + 1) % MAX_VIDEO_EVENT;
 879	}
 880
 881	//FIXME: timestamp?
 882	memcpy(&events->events[events->eventw], event, sizeof(struct video_event));
 883	events->eventw = wp;
 884
 885	spin_unlock_bh(&events->lock);
 886
 887	wake_up_interruptible(&events->wait_queue);
 888}
 889
 890static int dvb_video_get_event(struct av7110 *av7110, struct video_event *event, int flags)
 891{
 892	struct dvb_video_events *events = &av7110->video_events;
 893
 894	if (events->overflow) {
 895		events->overflow = 0;
 896		return -EOVERFLOW;
 897	}
 898	if (events->eventw == events->eventr) {
 899		int ret;
 900
 901		if (flags & O_NONBLOCK)
 902			return -EWOULDBLOCK;
 903
 904		ret = wait_event_interruptible(events->wait_queue,
 905					       events->eventw != events->eventr);
 906		if (ret < 0)
 907			return ret;
 908	}
 909
 910	spin_lock_bh(&events->lock);
 911
 912	memcpy(event, &events->events[events->eventr],
 913	       sizeof(struct video_event));
 914	events->eventr = (events->eventr + 1) % MAX_VIDEO_EVENT;
 915
 916	spin_unlock_bh(&events->lock);
 917
 918	return 0;
 919}
 920
 921/******************************************************************************
 922 * DVB device file operations
 923 ******************************************************************************/
 924
 925static __poll_t dvb_video_poll(struct file *file, poll_table *wait)
 926{
 927	struct dvb_device *dvbdev = file->private_data;
 928	struct av7110 *av7110 = dvbdev->priv;
 929	__poll_t mask = 0;
 930
 931	dprintk(2, "av7110:%p\n", av7110);
 932
 933	if ((file->f_flags & O_ACCMODE) != O_RDONLY)
 934		poll_wait(file, &av7110->avout.queue, wait);
 935
 936	poll_wait(file, &av7110->video_events.wait_queue, wait);
 937
 938	if (av7110->video_events.eventw != av7110->video_events.eventr)
 939		mask = EPOLLPRI;
 940
 941	if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
 942		if (av7110->playing) {
 943			if (FREE_COND)
 944				mask |= (EPOLLOUT | EPOLLWRNORM);
 945		} else {
 946			/* if not playing: may play if asked for */
 947			mask |= (EPOLLOUT | EPOLLWRNORM);
 948		}
 949	}
 950
 951	return mask;
 952}
 953
 954static ssize_t dvb_video_write(struct file *file, const char __user *buf,
 955			       size_t count, loff_t *ppos)
 956{
 957	struct dvb_device *dvbdev = file->private_data;
 958	struct av7110 *av7110 = dvbdev->priv;
 959	unsigned char c;
 960
 961	dprintk(2, "av7110:%p\n", av7110);
 962
 963	if ((file->f_flags & O_ACCMODE) == O_RDONLY)
 964		return -EPERM;
 965
 966	if (av7110->videostate.stream_source != VIDEO_SOURCE_MEMORY)
 967		return -EPERM;
 968
 969	if (get_user(c, buf))
 970		return -EFAULT;
 971	if (c == 0x47 && count % TS_SIZE == 0)
 972		return ts_play(av7110, buf, count, file->f_flags & O_NONBLOCK, 1);
 973	else
 974		return dvb_play(av7110, buf, count, file->f_flags & O_NONBLOCK, 1);
 975}
 976
 977static __poll_t dvb_audio_poll(struct file *file, poll_table *wait)
 978{
 979	struct dvb_device *dvbdev = file->private_data;
 980	struct av7110 *av7110 = dvbdev->priv;
 981	__poll_t mask = 0;
 982
 983	dprintk(2, "av7110:%p\n", av7110);
 984
 985	poll_wait(file, &av7110->aout.queue, wait);
 986
 987	if (av7110->playing) {
 988		if (dvb_ringbuffer_free(&av7110->aout) >= 20 * 1024)
 989			mask |= (EPOLLOUT | EPOLLWRNORM);
 990	} else {
 991		/* if not playing: may play if asked for */
 992		mask = (EPOLLOUT | EPOLLWRNORM);
 993	}
 994
 995	return mask;
 996}
 997
 998static ssize_t dvb_audio_write(struct file *file, const char __user *buf,
 999			       size_t count, loff_t *ppos)
1000{
1001	struct dvb_device *dvbdev = file->private_data;
1002	struct av7110 *av7110 = dvbdev->priv;
1003	unsigned char c;
1004
1005	dprintk(2, "av7110:%p\n", av7110);
1006
1007	if (av7110->audiostate.stream_source != AUDIO_SOURCE_MEMORY) {
1008		pr_err("not audio source memory\n");
1009		return -EPERM;
1010	}
1011
1012	if (get_user(c, buf))
1013		return -EFAULT;
1014	if (c == 0x47 && count % TS_SIZE == 0)
1015		return ts_play(av7110, buf, count, file->f_flags & O_NONBLOCK, 0);
1016	else
1017		return dvb_aplay(av7110, buf, count, file->f_flags & O_NONBLOCK, 0);
1018}
1019
1020static u8 iframe_header[] = { 0x00, 0x00, 0x01, 0xe0, 0x00, 0x00, 0x80, 0x00, 0x00 };
1021
1022#define MIN_IFRAME 400000
1023
1024static int play_iframe(struct av7110 *av7110, char __user *buf, unsigned int len, int nonblock)
1025{
1026	unsigned int i, n;
1027	int progressive = 0;
1028	int match = 0;
1029
1030	dprintk(2, "av7110:%p\n", av7110);
1031
1032	if (len == 0)
1033		return 0;
1034
1035	if (!(av7110->playing & RP_VIDEO)) {
1036		if (av7110_av_start_play(av7110, RP_VIDEO) < 0)
1037			return -EBUSY;
1038	}
1039
1040	/* search in buf for instances of 00 00 01 b5 1? */
1041	for (i = 0; i < len; i++) {
1042		unsigned char c;
1043
1044		if (get_user(c, buf + i))
1045			return -EFAULT;
1046		if (match == 5) {
1047			progressive = c & 0x08;
1048			match = 0;
1049		}
1050		if (c == 0x00) {
1051			match = (match == 1 || match == 2) ? 2 : 1;
1052			continue;
1053		}
1054		switch (match++) {
1055		case 2:
1056			if (c == 0x01)
1057				continue;
1058			break;
1059		case 3:
1060			if (c == 0xb5)
1061				continue;
1062			break;
1063		case 4:
1064			if ((c & 0xf0) == 0x10)
1065				continue;
1066			break;
1067		}
1068		match = 0;
1069	}
1070
1071	/* setting n always > 1, fixes problems when playing stillframes
1072	 * consisting of I- and P-Frames
1073	 */
1074	n = MIN_IFRAME / len + 1;
1075
1076	/* FIXME: nonblock? */
1077	dvb_play_kernel(av7110, iframe_header, sizeof(iframe_header), 0, 1);
1078
1079	for (i = 0; i < n; i++)
1080		dvb_play(av7110, buf, len, 0, 1);
1081
1082	av7110_ipack_flush(&av7110->ipack[1]);
1083
1084	if (progressive)
1085		return vidcom(av7110, AV_VIDEO_CMD_FREEZE, 1);
1086	else
1087		return 0;
1088}
1089
1090#ifdef CONFIG_COMPAT
1091struct compat_video_still_picture {
1092	compat_uptr_t iFrame;
1093	s32 size;
1094};
1095
1096#define VIDEO_STILLPICTURE32 _IOW('o', 30, struct compat_video_still_picture)
1097
1098struct compat_video_event {
1099	__s32 type;
1100	/* unused, make sure to use atomic time for y2038 if it ever gets used */
1101	compat_long_t timestamp;
1102	union {
1103		video_size_t size;
1104		unsigned int frame_rate;        /* in frames per 1000sec */
1105		unsigned char vsync_field;      /* unknown/odd/even/progressive */
1106	} u;
1107};
1108
1109#define VIDEO_GET_EVENT32 _IOR('o', 28, struct compat_video_event)
1110
1111static int dvb_compat_video_get_event(struct av7110 *av7110,
1112				      struct compat_video_event *event, int flags)
1113{
1114	struct video_event ev;
1115	int ret;
1116
1117	ret = dvb_video_get_event(av7110, &ev, flags);
1118
1119	*event = (struct compat_video_event) {
1120		.type = ev.type,
1121		.timestamp = ev.timestamp,
1122		.u.size = ev.u.size,
1123	};
1124
1125	return ret;
1126}
1127#endif
1128
1129static int dvb_video_ioctl(struct file *file,
1130			   unsigned int cmd, void *parg)
1131{
1132	struct dvb_device *dvbdev = file->private_data;
1133	struct av7110 *av7110 = dvbdev->priv;
1134	unsigned long arg = (unsigned long)parg;
1135	int ret = 0;
1136
1137	dprintk(1, "av7110:%p, cmd=%04x\n", av7110, cmd);
1138
1139	if ((file->f_flags & O_ACCMODE) == O_RDONLY) {
1140		if (cmd != VIDEO_GET_STATUS && cmd != VIDEO_GET_EVENT &&
1141		    cmd != VIDEO_GET_SIZE) {
1142			return -EPERM;
1143		}
1144	}
1145
1146	if (mutex_lock_interruptible(&av7110->ioctl_mutex))
1147		return -ERESTARTSYS;
1148
1149	switch (cmd) {
1150	case VIDEO_STOP:
1151		av7110->videostate.play_state = VIDEO_STOPPED;
1152		if (av7110->videostate.stream_source == VIDEO_SOURCE_MEMORY)
1153			ret = av7110_av_stop(av7110, RP_VIDEO);
1154		else
1155			ret = vidcom(av7110, AV_VIDEO_CMD_STOP,
1156				     av7110->videostate.video_blank ? 0 : 1);
1157		if (!ret)
1158			av7110->trickmode = TRICK_NONE;
1159		break;
1160
1161	case VIDEO_PLAY:
1162		av7110->trickmode = TRICK_NONE;
1163		if (av7110->videostate.play_state == VIDEO_FREEZED) {
1164			av7110->videostate.play_state = VIDEO_PLAYING;
1165			ret = vidcom(av7110, AV_VIDEO_CMD_PLAY, 0);
1166			if (ret)
1167				break;
1168		}
1169		if (av7110->videostate.stream_source == VIDEO_SOURCE_MEMORY) {
1170			if (av7110->playing == RP_AV) {
1171				ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Stop, 0);
1172				if (ret)
1173					break;
1174				av7110->playing &= ~RP_VIDEO;
1175			}
1176			ret = av7110_av_start_play(av7110, RP_VIDEO);
1177		}
1178		if (!ret)
1179			ret = vidcom(av7110, AV_VIDEO_CMD_PLAY, 0);
1180		if (!ret)
1181			av7110->videostate.play_state = VIDEO_PLAYING;
1182		break;
1183
1184	case VIDEO_FREEZE:
1185		av7110->videostate.play_state = VIDEO_FREEZED;
1186		if (av7110->playing & RP_VIDEO)
1187			ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Pause, 0);
1188		else
1189			ret = vidcom(av7110, AV_VIDEO_CMD_FREEZE, 1);
1190		if (!ret)
1191			av7110->trickmode = TRICK_FREEZE;
1192		break;
1193
1194	case VIDEO_CONTINUE:
1195		if (av7110->playing & RP_VIDEO)
1196			ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Continue, 0);
1197		if (!ret)
1198			ret = vidcom(av7110, AV_VIDEO_CMD_PLAY, 0);
1199		if (!ret) {
1200			av7110->videostate.play_state = VIDEO_PLAYING;
1201			av7110->trickmode = TRICK_NONE;
1202		}
1203		break;
1204
1205	case VIDEO_SELECT_SOURCE:
1206		av7110->videostate.stream_source = (video_stream_source_t)arg;
1207		break;
1208
1209	case VIDEO_SET_BLANK:
1210		av7110->videostate.video_blank = (int)arg;
1211		break;
1212
1213	case VIDEO_GET_STATUS:
1214		memcpy(parg, &av7110->videostate, sizeof(struct video_status));
1215		break;
1216
1217#ifdef CONFIG_COMPAT
1218	case VIDEO_GET_EVENT32:
1219		ret = dvb_compat_video_get_event(av7110, parg, file->f_flags);
1220		break;
1221#endif
1222
1223	case VIDEO_GET_EVENT:
1224		ret = dvb_video_get_event(av7110, parg, file->f_flags);
1225		break;
1226
1227	case VIDEO_GET_SIZE:
1228		memcpy(parg, &av7110->video_size, sizeof(video_size_t));
1229		break;
1230
1231	case VIDEO_SET_DISPLAY_FORMAT:
1232	{
1233		video_displayformat_t format = (video_displayformat_t)arg;
1234
1235		switch (format) {
1236		case VIDEO_PAN_SCAN:
1237			av7110->display_panscan = VID_PAN_SCAN_PREF;
1238			break;
1239		case VIDEO_LETTER_BOX:
1240			av7110->display_panscan = VID_VC_AND_PS_PREF;
1241			break;
1242		case VIDEO_CENTER_CUT_OUT:
1243			av7110->display_panscan = VID_CENTRE_CUT_PREF;
1244			break;
1245		default:
1246			ret = -EINVAL;
1247		}
1248		if (ret < 0)
1249			break;
1250		av7110->videostate.display_format = format;
1251		ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetPanScanType,
1252				    1, av7110->display_panscan);
1253		break;
1254	}
1255
1256	case VIDEO_SET_FORMAT:
1257		if (arg > 1) {
1258			ret = -EINVAL;
1259			break;
1260		}
1261		av7110->display_ar = arg;
1262		ret = av7110_fw_cmd(av7110, COMTYPE_ENCODER, SetMonitorType,
1263				    1, (u16)arg);
1264		break;
1265
1266#ifdef CONFIG_COMPAT
1267	case VIDEO_STILLPICTURE32:
1268	{
1269		struct compat_video_still_picture *pic =
1270			(struct compat_video_still_picture *)parg;
1271		av7110->videostate.stream_source = VIDEO_SOURCE_MEMORY;
1272		dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
1273		ret = play_iframe(av7110, compat_ptr(pic->iFrame),
1274				  pic->size, file->f_flags & O_NONBLOCK);
1275		break;
1276	}
1277#endif
1278
1279	case VIDEO_STILLPICTURE:
1280	{
1281		struct video_still_picture *pic =
1282			(struct video_still_picture *)parg;
1283		av7110->videostate.stream_source = VIDEO_SOURCE_MEMORY;
1284		dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
1285		ret = play_iframe(av7110, pic->iFrame, pic->size,
1286				  file->f_flags & O_NONBLOCK);
1287		break;
1288	}
1289
1290	case VIDEO_FAST_FORWARD:
1291		//note: arg is ignored by firmware
1292		if (av7110->playing & RP_VIDEO)
1293			ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY,
1294					    __Scan_I, 2, AV_PES, 0);
1295		else
1296			ret = vidcom(av7110, AV_VIDEO_CMD_FFWD, arg);
1297		if (!ret) {
1298			av7110->trickmode = TRICK_FAST;
1299			av7110->videostate.play_state = VIDEO_PLAYING;
1300		}
1301		break;
1302
1303	case VIDEO_SLOWMOTION:
1304		if (av7110->playing & RP_VIDEO) {
1305			if (av7110->trickmode != TRICK_SLOW)
1306				ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY, __Slow, 2, 0, 0);
1307			if (!ret)
1308				ret = vidcom(av7110, AV_VIDEO_CMD_SLOW, arg);
1309		} else {
1310			ret = vidcom(av7110, AV_VIDEO_CMD_PLAY, 0);
1311			if (!ret)
1312				ret = vidcom(av7110, AV_VIDEO_CMD_STOP, 0);
1313			if (!ret)
1314				ret = vidcom(av7110, AV_VIDEO_CMD_SLOW, arg);
1315		}
1316		if (!ret) {
1317			av7110->trickmode = TRICK_SLOW;
1318			av7110->videostate.play_state = VIDEO_PLAYING;
1319		}
1320		break;
1321
1322	case VIDEO_GET_CAPABILITIES:
1323		*(int *)parg = VIDEO_CAP_MPEG1 | VIDEO_CAP_MPEG2 |
1324			VIDEO_CAP_SYS | VIDEO_CAP_PROG;
1325		break;
1326
1327	case VIDEO_CLEAR_BUFFER:
1328		dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
1329		av7110_ipack_reset(&av7110->ipack[1]);
1330		if (av7110->playing == RP_AV) {
1331			ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY,
1332					    __Play, 2, AV_PES, 0);
1333			if (ret)
1334				break;
1335			if (av7110->trickmode == TRICK_FAST)
1336				ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY,
1337						    __Scan_I, 2, AV_PES, 0);
1338			if (av7110->trickmode == TRICK_SLOW) {
1339				ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY,
1340						    __Slow, 2, 0, 0);
1341				if (!ret)
1342					ret = vidcom(av7110, AV_VIDEO_CMD_SLOW, arg);
1343			}
1344			if (av7110->trickmode == TRICK_FREEZE)
1345				ret = vidcom(av7110, AV_VIDEO_CMD_STOP, 1);
1346		}
1347		break;
1348
1349	case VIDEO_SET_STREAMTYPE:
1350		break;
1351
1352	default:
1353		ret = -ENOIOCTLCMD;
1354		break;
1355	}
1356
1357	mutex_unlock(&av7110->ioctl_mutex);
1358	return ret;
1359}
1360
1361static int dvb_audio_ioctl(struct file *file,
1362			   unsigned int cmd, void *parg)
1363{
1364	struct dvb_device *dvbdev = file->private_data;
1365	struct av7110 *av7110 = dvbdev->priv;
1366	unsigned long arg = (unsigned long)parg;
1367	int ret = 0;
1368
1369	dprintk(1, "av7110:%p, cmd=%04x\n", av7110, cmd);
1370
1371	if (((file->f_flags & O_ACCMODE) == O_RDONLY) &&
1372	    (cmd != AUDIO_GET_STATUS))
1373		return -EPERM;
1374
1375	if (mutex_lock_interruptible(&av7110->ioctl_mutex))
1376		return -ERESTARTSYS;
1377
1378	switch (cmd) {
1379	case AUDIO_STOP:
1380		if (av7110->audiostate.stream_source == AUDIO_SOURCE_MEMORY)
1381			ret = av7110_av_stop(av7110, RP_AUDIO);
1382		else
1383			ret = audcom(av7110, AUDIO_CMD_MUTE);
1384		if (!ret)
1385			av7110->audiostate.play_state = AUDIO_STOPPED;
1386		break;
1387
1388	case AUDIO_PLAY:
1389		if (av7110->audiostate.stream_source == AUDIO_SOURCE_MEMORY)
1390			ret = av7110_av_start_play(av7110, RP_AUDIO);
1391		if (!ret)
1392			ret = audcom(av7110, AUDIO_CMD_UNMUTE);
1393		if (!ret)
1394			av7110->audiostate.play_state = AUDIO_PLAYING;
1395		break;
1396
1397	case AUDIO_PAUSE:
1398		ret = audcom(av7110, AUDIO_CMD_MUTE);
1399		if (!ret)
1400			av7110->audiostate.play_state = AUDIO_PAUSED;
1401		break;
1402
1403	case AUDIO_CONTINUE:
1404		if (av7110->audiostate.play_state == AUDIO_PAUSED) {
1405			av7110->audiostate.play_state = AUDIO_PLAYING;
1406			ret = audcom(av7110, AUDIO_CMD_UNMUTE | AUDIO_CMD_PCM16);
1407		}
1408		break;
1409
1410	case AUDIO_SELECT_SOURCE:
1411		av7110->audiostate.stream_source = (audio_stream_source_t)arg;
1412		break;
1413
1414	case AUDIO_SET_MUTE:
1415	{
1416		ret = audcom(av7110, arg ? AUDIO_CMD_MUTE : AUDIO_CMD_UNMUTE);
1417		if (!ret)
1418			av7110->audiostate.mute_state = (int)arg;
1419		break;
1420	}
1421
1422	case AUDIO_SET_AV_SYNC:
1423		av7110->audiostate.AV_sync_state = (int)arg;
1424		ret = audcom(av7110, arg ? AUDIO_CMD_SYNC_ON : AUDIO_CMD_SYNC_OFF);
1425		break;
1426
1427	case AUDIO_SET_BYPASS_MODE:
1428		if (FW_VERSION(av7110->arm_app) < 0x2621)
1429			ret = -EINVAL;
1430		av7110->audiostate.bypass_mode = (int)arg;
1431		break;
1432
1433	case AUDIO_CHANNEL_SELECT:
1434		av7110->audiostate.channel_select = (audio_channel_select_t)arg;
1435		switch (av7110->audiostate.channel_select) {
1436		case AUDIO_STEREO:
1437			ret = audcom(av7110, AUDIO_CMD_STEREO);
1438			if (!ret) {
1439				if (av7110->adac_type == DVB_ADAC_CRYSTAL)
1440					i2c_writereg(av7110, 0x20, 0x02, 0x49);
1441				else if (av7110->adac_type == DVB_ADAC_MSP34x5)
1442					msp_writereg(av7110, MSP_WR_DSP, 0x0008, 0x0220);
1443			}
1444			break;
1445		case AUDIO_MONO_LEFT:
1446			ret = audcom(av7110, AUDIO_CMD_MONO_L);
1447			if (!ret) {
1448				if (av7110->adac_type == DVB_ADAC_CRYSTAL)
1449					i2c_writereg(av7110, 0x20, 0x02, 0x4a);
1450				else if (av7110->adac_type == DVB_ADAC_MSP34x5)
1451					msp_writereg(av7110, MSP_WR_DSP, 0x0008, 0x0200);
1452			}
1453			break;
1454		case AUDIO_MONO_RIGHT:
1455			ret = audcom(av7110, AUDIO_CMD_MONO_R);
1456			if (!ret) {
1457				if (av7110->adac_type == DVB_ADAC_CRYSTAL)
1458					i2c_writereg(av7110, 0x20, 0x02, 0x45);
1459				else if (av7110->adac_type == DVB_ADAC_MSP34x5)
1460					msp_writereg(av7110, MSP_WR_DSP, 0x0008, 0x0210);
1461			}
1462			break;
1463		default:
1464			ret = -EINVAL;
1465			break;
1466		}
1467		break;
1468
1469	case AUDIO_GET_STATUS:
1470		memcpy(parg, &av7110->audiostate, sizeof(struct audio_status));
1471		break;
1472
1473	case AUDIO_GET_CAPABILITIES:
1474		if (FW_VERSION(av7110->arm_app) < 0x2621)
1475			*(unsigned int *)parg = AUDIO_CAP_LPCM | AUDIO_CAP_MP1 | AUDIO_CAP_MP2;
1476		else
1477			*(unsigned int *)parg = AUDIO_CAP_LPCM | AUDIO_CAP_DTS | AUDIO_CAP_AC3 |
1478						AUDIO_CAP_MP1 | AUDIO_CAP_MP2;
1479		break;
1480
1481	case AUDIO_CLEAR_BUFFER:
1482		dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout);
1483		av7110_ipack_reset(&av7110->ipack[0]);
1484		if (av7110->playing == RP_AV)
1485			ret = av7110_fw_cmd(av7110, COMTYPE_REC_PLAY,
1486					    __Play, 2, AV_PES, 0);
1487		break;
1488
1489	case AUDIO_SET_ID:
1490		break;
1491
1492	case AUDIO_SET_MIXER:
1493	{
1494		struct audio_mixer *amix = (struct audio_mixer *)parg;
1495
1496		ret = av7110_set_volume(av7110, amix->volume_left, amix->volume_right);
1497		break;
1498	}
1499
1500	case AUDIO_SET_STREAMTYPE:
1501		break;
1502
1503	default:
1504		ret = -ENOIOCTLCMD;
1505	}
1506
1507	mutex_unlock(&av7110->ioctl_mutex);
1508	return ret;
1509}
1510
1511static int dvb_video_open(struct inode *inode, struct file *file)
1512{
1513	struct dvb_device *dvbdev = file->private_data;
1514	struct av7110 *av7110 = dvbdev->priv;
1515	int err;
1516
1517	dprintk(2, "av7110:%p\n", av7110);
1518
1519	err = dvb_generic_open(inode, file);
1520	if (err < 0)
1521		return err;
1522
1523	if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
1524		dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout);
1525		dvb_ringbuffer_flush_spinlock_wakeup(&av7110->avout);
1526		av7110->video_blank = 1;
1527		av7110->audiostate.AV_sync_state = 1;
1528		av7110->videostate.stream_source = VIDEO_SOURCE_DEMUX;
1529
1530		/*  empty event queue */
1531		av7110->video_events.eventr = 0;
1532		av7110->video_events.eventw = 0;
1533	}
1534
1535	return 0;
1536}
1537
1538static int dvb_video_release(struct inode *inode, struct file *file)
1539{
1540	struct dvb_device *dvbdev = file->private_data;
1541	struct av7110 *av7110 = dvbdev->priv;
1542
1543	dprintk(2, "av7110:%p\n", av7110);
1544
1545	if ((file->f_flags & O_ACCMODE) != O_RDONLY)
1546		av7110_av_stop(av7110, RP_VIDEO);
1547
1548	return dvb_generic_release(inode, file);
1549}
1550
1551static int dvb_audio_open(struct inode *inode, struct file *file)
1552{
1553	struct dvb_device *dvbdev = file->private_data;
1554	struct av7110 *av7110 = dvbdev->priv;
1555	int err = dvb_generic_open(inode, file);
1556
1557	dprintk(2, "av7110:%p\n", av7110);
1558
1559	if (err < 0)
1560		return err;
1561	dvb_ringbuffer_flush_spinlock_wakeup(&av7110->aout);
1562	av7110->audiostate.stream_source = AUDIO_SOURCE_DEMUX;
1563	return 0;
1564}
1565
1566static int dvb_audio_release(struct inode *inode, struct file *file)
1567{
1568	struct dvb_device *dvbdev = file->private_data;
1569	struct av7110 *av7110 = dvbdev->priv;
1570
1571	dprintk(2, "av7110:%p\n", av7110);
1572
1573	av7110_av_stop(av7110, RP_AUDIO);
1574	return dvb_generic_release(inode, file);
1575}
1576
1577/******************************************************************************
1578 * driver registration
1579 ******************************************************************************/
1580
1581static const struct file_operations dvb_video_fops = {
1582	.owner		= THIS_MODULE,
1583	.write		= dvb_video_write,
1584	.unlocked_ioctl	= dvb_generic_ioctl,
1585	.compat_ioctl	= dvb_generic_ioctl,
1586	.open		= dvb_video_open,
1587	.release	= dvb_video_release,
1588	.poll		= dvb_video_poll,
1589	.llseek		= noop_llseek,
1590};
1591
1592static struct dvb_device dvbdev_video = {
1593	.priv		= NULL,
1594	.users		= 6,
1595	.readers	= 5,	/* arbitrary */
1596	.writers	= 1,
1597	.fops		= &dvb_video_fops,
1598	.kernel_ioctl	= dvb_video_ioctl,
1599};
1600
1601static const struct file_operations dvb_audio_fops = {
1602	.owner		= THIS_MODULE,
1603	.write		= dvb_audio_write,
1604	.unlocked_ioctl	= dvb_generic_ioctl,
1605	.compat_ioctl	= dvb_generic_ioctl,
1606	.open		= dvb_audio_open,
1607	.release	= dvb_audio_release,
1608	.poll		= dvb_audio_poll,
1609	.llseek		= noop_llseek,
1610};
1611
1612static struct dvb_device dvbdev_audio = {
1613	.priv		= NULL,
1614	.users		= 1,
1615	.writers	= 1,
1616	.fops		= &dvb_audio_fops,
1617	.kernel_ioctl	= dvb_audio_ioctl,
1618};
1619
1620int av7110_av_register(struct av7110 *av7110)
1621{
1622	av7110->audiostate.AV_sync_state = 0;
1623	av7110->audiostate.mute_state = 0;
1624	av7110->audiostate.play_state = AUDIO_STOPPED;
1625	av7110->audiostate.stream_source = AUDIO_SOURCE_DEMUX;
1626	av7110->audiostate.channel_select = AUDIO_STEREO;
1627	av7110->audiostate.bypass_mode = 0;
1628
1629	av7110->videostate.video_blank = 0;
1630	av7110->videostate.play_state = VIDEO_STOPPED;
1631	av7110->videostate.stream_source = VIDEO_SOURCE_DEMUX;
1632	av7110->videostate.video_format = VIDEO_FORMAT_4_3;
1633	av7110->videostate.display_format = VIDEO_LETTER_BOX;
1634	av7110->display_ar = VIDEO_FORMAT_4_3;
1635	av7110->display_panscan = VID_VC_AND_PS_PREF;
1636
1637	init_waitqueue_head(&av7110->video_events.wait_queue);
1638	spin_lock_init(&av7110->video_events.lock);
1639	av7110->video_events.eventw = 0;
1640	av7110->video_events.eventr = 0;
1641	av7110->video_events.overflow = 0;
1642	memset(&av7110->video_size, 0, sizeof(video_size_t));
1643
1644	dvb_register_device(&av7110->dvb_adapter, &av7110->video_dev,
1645			    &dvbdev_video, av7110, DVB_DEVICE_VIDEO, 0);
1646
1647	dvb_register_device(&av7110->dvb_adapter, &av7110->audio_dev,
1648			    &dvbdev_audio, av7110, DVB_DEVICE_AUDIO, 0);
1649
1650	return 0;
1651}
1652
1653void av7110_av_unregister(struct av7110 *av7110)
1654{
1655	dvb_unregister_device(av7110->audio_dev);
1656	dvb_unregister_device(av7110->video_dev);
1657}
1658
1659int av7110_av_init(struct av7110 *av7110)
1660{
1661	void (*play[])(u8 *, int, void *) = { play_audio_cb, play_video_cb };
1662	int i, ret;
1663
1664	for (i = 0; i < 2; i++) {
1665		struct ipack *ipack = av7110->ipack + i;
1666
1667		ret = av7110_ipack_init(ipack, IPACKS, play[i]);
1668		if (ret < 0) {
1669			if (i)
1670				av7110_ipack_free(--ipack);
1671			goto out;
1672		}
1673		ipack->data = av7110;
1674	}
1675
1676	dvb_ringbuffer_init(&av7110->avout, av7110->iobuf, AVOUTLEN);
1677	dvb_ringbuffer_init(&av7110->aout, av7110->iobuf + AVOUTLEN, AOUTLEN);
1678
1679	av7110->kbuf[0] = (u8 *)(av7110->iobuf + AVOUTLEN + AOUTLEN + BMPLEN);
1680	av7110->kbuf[1] = av7110->kbuf[0] + 2 * IPACKS;
1681out:
1682	return ret;
1683}
1684
1685void av7110_av_exit(struct av7110 *av7110)
1686{
1687	av7110_ipack_free(&av7110->ipack[0]);
1688	av7110_ipack_free(&av7110->ipack[1]);
1689}