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