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