1/* $NetBSD: dtv_demux.c,v 1.6 2014/08/09 13:34:10 jmcneill Exp $ */
2
3/*-
4 * Copyright (c) 2011 Jared D. McNeill <jmcneill@invisible.ca>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by Jared D. McNeill.
18 * 4. Neither the name of The NetBSD Foundation nor the names of its
19 * contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
23 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32 * POSSIBILITY OF SUCH DAMAGE.
33 */
34
35/*
36 * This file contains support for the /dev/dvb/adapter<n>/demux0 device.
37 *
38 * The demux device is implemented as a cloning device. Each instance can
39 * be in one of three modes: unconfigured (NONE), section filter (SECTION),
40 * or PID filter (PES).
41 *
42 * An instance in section filter mode extracts PSI sections based on a
43 * filter configured by the DMX_SET_FILTER ioctl. When an entire section is
44 * received, it is made available to userspace via read method. Data is fed
45 * into the section filter using the dtv_demux_write function.
46 *
47 * An instance in PID filter mode extracts TS packets that match the
48 * specified PID filter configured by the DMX_SET_PES_FILTER, DMX_ADD_PID,
49 * and DMX_REMOVE_PID ioctls. As this driver only implements the
50 * DMX_OUT_TS_TAP output, these TS packets are made available to userspace
51 * by calling read on the /dev/dvb/adapter<n>/dvr0 device.
52 */
53
54#include <sys/cdefs.h>
55__KERNEL_RCSID(0, "$NetBSD: dtv_demux.c,v 1.6 2014/08/09 13:34:10 jmcneill Exp $");
56
57#include <sys/param.h>
58#include <sys/types.h>
59#include <sys/conf.h>
60#include <sys/kmem.h>
61#include <sys/device.h>
62#include <sys/select.h>
63#include <sys/filedesc.h>
64#include <sys/file.h>
65#include <sys/poll.h>
66#include <sys/vnode.h>
67#include <sys/queue.h>
68
69#include <dev/dtv/dtvvar.h>
70
71static int dtv_demux_read(struct file *, off_t *, struct uio *,
72 kauth_cred_t, int);
73static int dtv_demux_ioctl(struct file *, u_long, void *);
74static int dtv_demux_poll(struct file *, int);
75static int dtv_demux_close(struct file *);
76
77static const struct fileops dtv_demux_fileops = {
78 .fo_read = dtv_demux_read,
79 .fo_write = fbadop_write,
80 .fo_ioctl = dtv_demux_ioctl,
81 .fo_fcntl = fnullop_fcntl,
82 .fo_poll = dtv_demux_poll,
83 .fo_stat = fbadop_stat,
84 .fo_close = dtv_demux_close,
85 .fo_kqfilter = fnullop_kqfilter,
86 .fo_restart = fnullop_restart,
87};
88
89static uint32_t crc_table[256] = {
90 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9,
91 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
92 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
93 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
94 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9,
95 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
96 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011,
97 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
98 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
99 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
100 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81,
101 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
102 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49,
103 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
104 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
105 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
106 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae,
107 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
108 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
109 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,
110 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
111 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
112 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066,
113 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
114 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e,
115 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
116 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
117 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
118 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
119 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
120 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686,
121 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
122 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
123 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
124 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f,
125 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
126 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47,
127 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
128 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
129 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
130 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7,
131 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
132 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f,
133 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
134 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
135 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
136 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f,
137 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
138 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
139 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
140 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
141 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
142 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30,
143 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
144 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088,
145 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
146 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
147 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
148 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
149 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
150 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0,
151 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
152 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
153 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
154};
155
156/* ISO/IEC 13818-1 Annex A "CRC Decoder Model" */
157static uint32_t
158dtv_demux_crc32(uint8_t *buf, int len)
159{
160 const uint32_t *crc_tab = crc_table;
161 uint32_t CRC = 0xffffffff;
162 int i;
163
164 for (i = 0; i < len; i++)
165 CRC = (CRC << 8) ^ crc_tab[((CRC >> 24) ^ *buf++) & 0xff];
166
167 return CRC;
168}
169
170/*
171 * Start running the demux.
172 */
173static int
174dtv_demux_start(struct dtv_demux *demux)
175{
176 struct dtv_softc *sc = demux->dd_sc;
177 int error = 0;
178 bool dostart = false;
179
180 /*
181 * If the demux is not running, mark it as running and update the
182 * global demux run counter.
183 */
184 mutex_enter(&sc->sc_lock);
185 KASSERT(sc->sc_demux_runcnt >= 0);
186 if (demux->dd_running == false) {
187 sc->sc_demux_runcnt++;
188 demux->dd_running = true;
189 /* If this is the first demux running, trigger device start */
190 dostart = sc->sc_demux_runcnt == 1;
191 }
192 mutex_exit(&sc->sc_lock);
193
194 if (dostart) {
195 /* Setup receive buffers and trigger device start */
196 error = dtv_buffer_setup(sc);
197 if (error == 0)
198 error = dtv_device_start_transfer(sc);
199 }
200
201 /*
202 * If something went wrong, restore the run counter and mark this
203 * demux instance as halted.
204 */
205 if (error) {
206 mutex_enter(&sc->sc_lock);
207 sc->sc_demux_runcnt--;
208 demux->dd_running = false;
209 mutex_exit(&sc->sc_lock);
210 }
211
212 return error;
213}
214
215/*
216 * Stop running the demux.
217 */
218static int
219dtv_demux_stop(struct dtv_demux *demux)
220{
221 struct dtv_softc *sc = demux->dd_sc;
222 int error = 0;
223 bool dostop = false;
224
225 /*
226 * If the demux is running, mark it as halted and update the
227 * global demux run counter.
228 */
229 mutex_enter(&sc->sc_lock);
230 if (demux->dd_running == true) {
231 KASSERT(sc->sc_demux_runcnt > 0);
232 demux->dd_running = false;
233 sc->sc_demux_runcnt--;
234 /* If this was the last demux running, trigger device stop */
235 dostop = sc->sc_demux_runcnt == 0;
236 }
237 mutex_exit(&sc->sc_lock);
238
239 if (dostop) {
240 /* Trigger device stop */
241 error = dtv_device_stop_transfer(sc);
242 }
243
244 /*
245 * If something went wrong, restore the run counter and mark this
246 * demux instance as running.
247 */
248 if (error) {
249 mutex_enter(&sc->sc_lock);
250 sc->sc_demux_runcnt++;
251 demux->dd_running = true;
252 mutex_exit(&sc->sc_lock);
253 }
254
255 return error;
256}
257
258/*
259 * Put the demux into PID filter mode and update the PID filter table.
260 */
261static int
262dtv_demux_set_pidfilter(struct dtv_demux *demux, uint16_t pid, bool onoff)
263{
264 struct dtv_softc *sc = demux->dd_sc;
265
266 /*
267 * TS PID is 13 bits; demux device uses special PID 0x2000 to mean
268 * "all PIDs". Verify that the requested PID is in range.
269 */
270 if (pid > 0x2000)
271 return EINVAL;
272
273 /* Set demux mode */
274 demux->dd_mode = DTV_DEMUX_MODE_PES;
275 /*
276 * If requesting "all PIDs", set the on/off flag for all PIDs in
277 * the PID map, otherwise set the on/off flag for the requested
278 * PID.
279 */
280 if (pid == 0x2000) {
281 memset(sc->sc_ts.ts_pidfilter, onoff,
282 sizeof(sc->sc_ts.ts_pidfilter));
283 } else {
284 sc->sc_ts.ts_pidfilter[pid] = onoff;
285 }
286
287 return 0;
288}
289
290/*
291 * Open a new instance of the demux cloning device.
292 */
293int
294dtv_demux_open(struct dtv_softc *sc, int flags, int mode, lwp_t *l)
295{
296 struct file *fp;
297 struct dtv_demux *demux;
298 int error, fd;
299
300 /* Allocate private storage */
301 demux = kmem_zalloc(sizeof(*demux), KM_SLEEP);
302 if (demux == NULL)
303 return ENOMEM;
304 demux->dd_sc = sc;
305 /* Default operation mode is unconfigured */
306 demux->dd_mode = DTV_DEMUX_MODE_NONE;
307 selinit(&demux->dd_sel);
308 mutex_init(&demux->dd_lock, MUTEX_DEFAULT, IPL_SCHED);
309 cv_init(&demux->dd_section_cv, "dtvsec");
310
311 error = fd_allocfile(&fp, &fd);
312 if (error) {
313 kmem_free(demux, sizeof(*demux));
314 return error;
315 }
316
317 /* Add the demux to the list of demux instances */
318 mutex_enter(&sc->sc_demux_lock);
319 TAILQ_INSERT_TAIL(&sc->sc_demux_list, demux, dd_entries);
320 mutex_exit(&sc->sc_demux_lock);
321
322 return fd_clone(fp, fd, flags, &dtv_demux_fileops, demux);
323}
324
325/*
326 * Close the instance of the demux cloning device.
327 */
328int
329dtv_demux_close(struct file *fp)
330{
331 struct dtv_demux *demux = fp->f_data;
332 struct dtv_softc *sc;
333 int error;
334
335 if (demux == NULL)
336 return ENXIO;
337
338 fp->f_data = NULL;
339
340 sc = demux->dd_sc;
341
342 /* If the demux is still running, stop it */
343 if (demux->dd_running) {
344 error = dtv_demux_stop(demux);
345 if (error)
346 return error;
347 }
348
349 /* Remove the demux from the list of demux instances */
350 mutex_enter(&sc->sc_demux_lock);
351 TAILQ_REMOVE(&sc->sc_demux_list, demux, dd_entries);
352 mutex_exit(&sc->sc_demux_lock);
353
354 mutex_destroy(&demux->dd_lock);
355 cv_destroy(&demux->dd_section_cv);
356 kmem_free(demux, sizeof(*demux));
357
358 /* Update the global device open count */
359 dtv_common_close(sc);
360
361 return 0;
362}
363
364/*
365 * Handle demux ioctl requests
366 */
367static int
368dtv_demux_ioctl(struct file *fp, u_long cmd, void *data)
369{
370 struct dtv_demux *demux = fp->f_data;
371 struct dmx_pes_filter_params *pesfilt;
372 struct dmx_sct_filter_params *sctfilt;
373 uint16_t pid;
374 int error;
375
376 if (demux == NULL)
377 return ENXIO;
378
379 switch (cmd) {
380 case DMX_START:
381 return dtv_demux_start(demux);
382 case DMX_STOP:
383 return dtv_demux_stop(demux);
384 case DMX_SET_BUFFER_SIZE:
385 /*
386 * The demux driver doesn't support configurable buffer sizes,
387 * but software relies on this command succeeding.
388 */
389 return 0;
390 case DMX_SET_FILTER:
391 sctfilt = data;
392
393 /* Verify that the requested PID is in range. */
394 if (sctfilt->pid >= 0x2000)
395 return EINVAL;
396
397 /*
398 * Update section filter parameters, reset read/write ptrs,
399 * clear section count and overflow flag, and set the
400 * demux instance mode to section filter.
401 */
402 demux->dd_secfilt.params = *sctfilt;
403 demux->dd_secfilt.rp = demux->dd_secfilt.wp = 0;
404 demux->dd_secfilt.nsections = 0;
405 demux->dd_secfilt.overflow = false;
406 demux->dd_mode = DTV_DEMUX_MODE_SECTION;
407
408 /*
409 * If the DMX_IMMEDIATE_START flag is present in the request,
410 * start running the demux immediately (no need for a
411 * subsequent DMX_START ioctl).
412 */
413 if (sctfilt->flags & DMX_IMMEDIATE_START) {
414 error = dtv_demux_start(demux);
415 if (error)
416 return error;
417 }
418
419 return 0;
420 case DMX_SET_PES_FILTER:
421 pesfilt = data;
422
423 /* The driver only supports input from the frontend */
424 if (pesfilt->input != DMX_IN_FRONTEND)
425 return EINVAL;
426 /*
427 * The driver only supports output to the TS TAP in PID
428 * filter mode.
429 */
430 if (pesfilt->output != DMX_OUT_TS_TAP)
431 return EINVAL;
432
433 /* Update PID filter table */
434 error = dtv_demux_set_pidfilter(demux, pesfilt->pid, true);
435 if (error)
436 return error;
437
438 /*
439 * If the DMX_IMMEDIATE_START flag is present in the request,
440 * start running the demux immediately (no need for a
441 * subsequent DMX_START ioctl).
442 */
443 if (pesfilt->flags & DMX_IMMEDIATE_START) {
444 error = dtv_demux_start(demux);
445 if (error)
446 return error;
447 }
448 return 0;
449 case DMX_ADD_PID:
450 pid = *(uint16_t *)data;
451 return dtv_demux_set_pidfilter(demux, pid, true);
452 case DMX_REMOVE_PID:
453 pid = *(uint16_t *)data;
454 return dtv_demux_set_pidfilter(demux, pid, false);
455 default:
456 return EINVAL;
457 }
458}
459
460/*
461 * Test for I/O readiness
462 */
463static int
464dtv_demux_poll(struct file *fp, int events)
465{
466 struct dtv_demux *demux = fp->f_data;
467 int revents = 0;
468
469 if (demux == NULL)
470 return POLLERR;
471
472 /*
473 * If the demux instance is in section filter mode, wait for an
474 * entire section to become ready.
475 */
476 mutex_enter(&demux->dd_lock);
477 if (demux->dd_mode == DTV_DEMUX_MODE_SECTION &&
478 demux->dd_secfilt.nsections > 0) {
479 revents |= POLLIN;
480 } else {
481 selrecord(curlwp, &demux->dd_sel);
482 }
483 mutex_exit(&demux->dd_lock);
484
485 return revents;
486}
487
488/*
489 * Read from the demux instance
490 */
491static int
492dtv_demux_read(struct file *fp, off_t *offp, struct uio *uio,
493 kauth_cred_t cred, int flags)
494{
495 struct dtv_demux *demux = fp->f_data;
496 struct dtv_ts_section sec;
497 int error;
498
499 if (demux == NULL)
500 return ENXIO;
501
502 /* Only support read if the instance is in section filter mode */
503 if (demux->dd_mode != DTV_DEMUX_MODE_SECTION)
504 return EIO;
505
506 /* Wait for a complete PSI section */
507 mutex_enter(&demux->dd_lock);
508 while (demux->dd_secfilt.nsections == 0) {
509 if (flags & IO_NDELAY) {
510 mutex_exit(&demux->dd_lock);
511 /* No data available */
512 return EWOULDBLOCK;
513 }
514 error = cv_wait_sig(&demux->dd_section_cv, &demux->dd_lock);
515 if (error) {
516 mutex_exit(&demux->dd_lock);
517 return error;
518 }
519 }
520 /* Copy the completed PSI section */
521 sec = demux->dd_secfilt.section[demux->dd_secfilt.rp];
522 /* Update read pointer */
523 demux->dd_secfilt.rp++;
524 if (demux->dd_secfilt.rp >= __arraycount(demux->dd_secfilt.section))
525 demux->dd_secfilt.rp = 0;
526 /* Update section count */
527 demux->dd_secfilt.nsections--;
528 mutex_exit(&demux->dd_lock);
529
530 /*
531 * If the filter parameters specify the DMX_ONESHOT flag, stop
532 * the demux after one PSI section is received.
533 */
534 if (demux->dd_secfilt.params.flags & DMX_ONESHOT)
535 dtv_demux_stop(demux);
536
537 /*
538 * Copy the PSI section to userspace. If the receiving buffer is
539 * too small, the rest of the payload will be discarded. Although
540 * this behaviour differs from the Linux implementation, in practice
541 * it should not be an issue as PSI sections have a max size of 4KB
542 * (and callers will generally provide a big enough buffer).
543 */
544 return uiomove(sec.sec_buf, sec.sec_length, uio);
545}
546
547/*
548 * Verify the CRC of a PSI section.
549 */
550static bool
551dtv_demux_check_crc(struct dtv_demux *demux, struct dtv_ts_section *sec)
552{
553 uint32_t crc, sec_crc;
554
555 /*
556 * If section_syntax_indicator is not set, the PSI section does
557 * not include a CRC field.
558 */
559 if ((sec->sec_buf[1] & 0x80) == 0)
560 return false;
561
562 sec_crc = be32dec(&sec->sec_buf[sec->sec_length - 4]);
563 crc = dtv_demux_crc32(&sec->sec_buf[0], sec->sec_length - 4);
564
565 return crc == sec_crc;
566}
567
568/*
569 * Process a single TS packet and extract PSI sections based on the
570 * instance's section filter.
571 */
572static int
573dtv_demux_process(struct dtv_demux *demux, const uint8_t *tspkt,
574 size_t tspktlen)
575{
576 struct dtv_ts_section *sec;
577 dmx_filter_t *dmxfilt = &demux->dd_secfilt.params.filter;
578 const uint8_t *p;
579 uint16_t section_length;
580 int brem, avail;
581
582 KASSERT(tspktlen == TS_PKTLEN);
583
584 /* If the demux instance is not running, ignore the packet */
585 if (demux->dd_running == false)
586 return 0;
587
588 /*
589 * If the demux instance is not in section filter mode, ignore
590 * the packet
591 */
592 if (demux->dd_mode != DTV_DEMUX_MODE_SECTION)
593 return 0;
594 /*
595 * If the packet's TS PID does not match the section filter PID,
596 * ignore the packet
597 */
598 if (TS_PID(tspkt) != demux->dd_secfilt.params.pid)
599 return 0;
600 /*
601 * If the TS packet does not contain a payload, ignore the packet
602 */
603 if (TS_HAS_PAYLOAD(tspkt) == 0)
604 return 0;
605
606 mutex_enter(&demux->dd_lock);
607
608 /* If the section buffer is full, set the overflow flag and return */
609 if (demux->dd_secfilt.nsections ==
610 __arraycount(demux->dd_secfilt.section)) {
611 demux->dd_secfilt.overflow = true;
612 goto done;
613 }
614 sec = &demux->dd_secfilt.section[demux->dd_secfilt.wp];
615 /* If we have no bytes in our buffer, wait for payload unit start */
616 if (sec->sec_bytesused == 0 && TS_HAS_PUSI(tspkt) == 0)
617 goto done;
618
619 /* find payload start */
620 p = tspkt + 4;
621 if (TS_HAS_AF(tspkt)) {
622 if (*p > 182) /* AF length with payload is between 0-182 */
623 goto done;
624 p += (1 + *p);
625 }
626 if (TS_HAS_PUSI(tspkt)) {
627 p += (1 + *p);
628 }
629
630 brem = tspktlen - (p - tspkt);
631
632 if (TS_HAS_PUSI(tspkt)) {
633 if (brem < 16)
634 goto done;
635
636 section_length = ((p[1] & 0xf) << 8) | p[2];
637
638 /* table_id filter */
639 if (dmxfilt->mask[0]) {
640 if ((p[0] & dmxfilt->mask[0]) != dmxfilt->filter[0])
641 goto done;
642 }
643 /* table_id_ext filter */
644 if (dmxfilt->mask[1] && dmxfilt->mask[2]) {
645 /*
646 * table_id_ext is only valid if
647 * section_syntax_indicator is set
648 */
649 if (section_length < 2 || (p[1] & 0x80) == 0)
650 goto done;
651 if ((p[3] & dmxfilt->mask[1]) != dmxfilt->filter[1])
652 goto done;
653 if ((p[4] & dmxfilt->mask[2]) != dmxfilt->filter[2])
654 goto done;
655 }
656
657 sec->sec_length = section_length + 3;
658
659 /* maximum section length is 4KB */
660 if (sec->sec_length > sizeof(sec->sec_buf)) {
661 sec->sec_bytesused = sec->sec_length = 0;
662 goto done;
663 }
664
665 }
666
667 /* If we have bytes pending and we see payload unit start, flush buf */
668 if (sec->sec_bytesused > 0 && TS_HAS_PUSI(tspkt))
669 sec->sec_bytesused = sec->sec_length = 0;
670
671 /* Copy data into section buffer */
672 avail = min(sec->sec_length - sec->sec_bytesused, brem);
673 if (avail < 0)
674 goto done;
675 memcpy(&sec->sec_buf[sec->sec_bytesused], p, avail);
676 sec->sec_bytesused += avail;
677
678 /*
679 * If a complete section has been received, update section count
680 * and notify readers.
681 */
682 if (sec->sec_bytesused == sec->sec_length) {
683 /*
684 * If the DMX_CHECK_CRC flag was present in the DMX_SET_FILTER
685 * parameters, verify the PSI section checksum. If the
686 * checksum is invalid, discard the entire corrupt section.
687 */
688 if ((demux->dd_secfilt.params.flags & DMX_CHECK_CRC) &&
689 dtv_demux_check_crc(demux, sec) == false) {
690 /* discard section */
691 sec->sec_bytesused = sec->sec_length = 0;
692 goto done;
693 }
694
695 demux->dd_secfilt.wp++;
696 if (demux->dd_secfilt.wp >=
697 __arraycount(demux->dd_secfilt.section))
698 demux->dd_secfilt.wp = 0;
699 demux->dd_secfilt.nsections++;
700 cv_broadcast(&demux->dd_section_cv);
701 selnotify(&demux->dd_sel, 0, 0);
702 }
703
704done:
705 mutex_exit(&demux->dd_lock);
706 return 0;
707}
708
709/*
710 * Submit TS data to all demux instances
711 */
712void
713dtv_demux_write(struct dtv_softc *sc, const uint8_t *tspkt, size_t tspktlen)
714{
715 struct dtv_demux *demux;
716
717 mutex_enter(&sc->sc_demux_lock);
718 TAILQ_FOREACH(demux, &sc->sc_demux_list, dd_entries) {
719 dtv_demux_process(demux, tspkt, tspktlen);
720 }
721 mutex_exit(&sc->sc_demux_lock);
722}
723