Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'media/v4.16-3' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media
Pull media fixes from Mauro Carvalho Chehab:
- some build fixes with randconfigs
- an m88ds3103 fix to prevent an OOPS if the chip doesn't provide the
right version during probe (with can happen if the hardware hangs)
- a potential out of array bounds reference in tvp5150
- some fixes and improvements in the DVB memory mapped API (added for
kernel 4.16)
* tag 'media/v4.16-3' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media:
media: vb2: Makefile: place vb2-trace together with vb2-core
media: Don't let tvp5150_get_vbi() go out of vbi_ram_default array
media: dvb: update buffer mmaped flags and frame counter
media: dvb: add continuity error indicators for memory mapped buffers
media: dmxdev: Fix the logic that enables DMA mmap support
media: dmxdev: fix error code for invalid ioctls
media: m88ds3103: don't call a non-initalized function
media: au0828: add VIDEO_V4L2 dependency
media: dvb: fix DVB_MMAP dependency
media: dvb: fix DVB_MMAP symbol name
media: videobuf2: fix build issues with vb2-trace
media: videobuf2: Add VIDEOBUF2_V4L2 Kconfig option for VB2 V4L2 part
+329
-175
+10
-4
Documentation/media/dmx.h.rst.exceptions
+10
-4
Documentation/media/dmx.h.rst.exceptions
···
50
50
replace typedef dmx_pes_type_t :c:type:`dmx_pes_type`
51
51
replace typedef dmx_input_t :c:type:`dmx_input`
52
52
53
-
ignore symbol DMX_OUT_DECODER
54
-
ignore symbol DMX_OUT_TAP
55
-
ignore symbol DMX_OUT_TS_TAP
56
-
ignore symbol DMX_OUT_TSDEMUX_TAP
53
+
replace symbol DMX_BUFFER_FLAG_HAD_CRC32_DISCARD :c:type:`dmx_buffer_flags`
54
+
replace symbol DMX_BUFFER_FLAG_TEI :c:type:`dmx_buffer_flags`
55
+
replace symbol DMX_BUFFER_PKT_COUNTER_MISMATCH :c:type:`dmx_buffer_flags`
56
+
replace symbol DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED :c:type:`dmx_buffer_flags`
57
+
replace symbol DMX_BUFFER_FLAG_DISCONTINUITY_INDICATOR :c:type:`dmx_buffer_flags`
58
+
59
+
replace symbol DMX_OUT_DECODER :c:type:`dmx_output`
60
+
replace symbol DMX_OUT_TAP :c:type:`dmx_output`
61
+
replace symbol DMX_OUT_TS_TAP :c:type:`dmx_output`
62
+
replace symbol DMX_OUT_TSDEMUX_TAP :c:type:`dmx_output`
57
63
58
64
replace ioctl DMX_DQBUF dmx_qbuf
+4
-3
Documentation/media/uapi/dvb/dmx-qbuf.rst
+4
-3
Documentation/media/uapi/dvb/dmx-qbuf.rst
···
51
51
the device is closed.
52
52
53
53
Applications call the ``DMX_DQBUF`` ioctl to dequeue a filled
54
-
(capturing) buffer from the driver's outgoing queue. They just set the ``reserved`` field array to zero. When ``DMX_DQBUF`` is called with a
55
-
pointer to this structure, the driver fills the remaining fields or
56
-
returns an error code.
54
+
(capturing) buffer from the driver's outgoing queue.
55
+
They just set the ``index`` field withe the buffer ID to be queued.
56
+
When ``DMX_DQBUF`` is called with a pointer to struct :c:type:`dmx_buffer`,
57
+
the driver fills the remaining fields or returns an error code.
57
58
58
59
By default ``DMX_DQBUF`` blocks when no buffer is in the outgoing
59
60
queue. When the ``O_NONBLOCK`` flag was given to the
+2
drivers/media/Kconfig
+2
drivers/media/Kconfig
+3
drivers/media/common/videobuf2/Kconfig
+3
drivers/media/common/videobuf2/Kconfig
+8
-1
drivers/media/common/videobuf2/Makefile
+8
-1
drivers/media/common/videobuf2/Makefile
···
1
+
# SPDX-License-Identifier: GPL-2.0
2
+
videobuf2-common-objs := videobuf2-core.o
1
3
2
-
obj-$(CONFIG_VIDEOBUF2_CORE) += videobuf2-core.o videobuf2-v4l2.o
4
+
ifeq ($(CONFIG_TRACEPOINTS),y)
5
+
videobuf2-common-objs += vb2-trace.o
6
+
endif
7
+
8
+
obj-$(CONFIG_VIDEOBUF2_CORE) += videobuf2-common.o
9
+
obj-$(CONFIG_VIDEOBUF2_V4L2) += videobuf2-v4l2.o
3
10
obj-$(CONFIG_VIDEOBUF2_MEMOPS) += videobuf2-memops.o
4
11
obj-$(CONFIG_VIDEOBUF2_VMALLOC) += videobuf2-vmalloc.o
5
12
obj-$(CONFIG_VIDEOBUF2_DMA_CONTIG) += videobuf2-dma-contig.o
+1
-1
drivers/media/dvb-core/Makefile
+1
-1
drivers/media/dvb-core/Makefile
+65
-50
drivers/media/dvb-core/dmxdev.c
+65
-50
drivers/media/dvb-core/dmxdev.c
···
128
128
struct dvb_device *dvbdev = file->private_data;
129
129
struct dmxdev *dmxdev = dvbdev->priv;
130
130
struct dmx_frontend *front;
131
-
#ifndef DVB_MMAP
132
131
bool need_ringbuffer = false;
133
-
#else
134
-
const bool need_ringbuffer = true;
135
-
#endif
136
132
137
133
dprintk("%s\n", __func__);
138
134
···
140
144
return -ENODEV;
141
145
}
142
146
143
-
#ifndef DVB_MMAP
147
+
dmxdev->may_do_mmap = 0;
148
+
149
+
/*
150
+
* The logic here is a little tricky due to the ifdef.
151
+
*
152
+
* The ringbuffer is used for both read and mmap.
153
+
*
154
+
* It is not needed, however, on two situations:
155
+
* - Write devices (access with O_WRONLY);
156
+
* - For duplex device nodes, opened with O_RDWR.
157
+
*/
158
+
144
159
if ((file->f_flags & O_ACCMODE) == O_RDONLY)
145
160
need_ringbuffer = true;
146
-
#else
147
-
if ((file->f_flags & O_ACCMODE) == O_RDWR) {
161
+
else if ((file->f_flags & O_ACCMODE) == O_RDWR) {
148
162
if (!(dmxdev->capabilities & DMXDEV_CAP_DUPLEX)) {
163
+
#ifdef CONFIG_DVB_MMAP
164
+
dmxdev->may_do_mmap = 1;
165
+
need_ringbuffer = true;
166
+
#else
149
167
mutex_unlock(&dmxdev->mutex);
150
168
return -EOPNOTSUPP;
169
+
#endif
151
170
}
152
171
}
153
-
#endif
154
172
155
173
if (need_ringbuffer) {
156
174
void *mem;
···
179
169
return -ENOMEM;
180
170
}
181
171
dvb_ringbuffer_init(&dmxdev->dvr_buffer, mem, DVR_BUFFER_SIZE);
182
-
dvb_vb2_init(&dmxdev->dvr_vb2_ctx, "dvr",
183
-
file->f_flags & O_NONBLOCK);
172
+
if (dmxdev->may_do_mmap)
173
+
dvb_vb2_init(&dmxdev->dvr_vb2_ctx, "dvr",
174
+
file->f_flags & O_NONBLOCK);
184
175
dvbdev->readers--;
185
176
}
186
177
···
211
200
{
212
201
struct dvb_device *dvbdev = file->private_data;
213
202
struct dmxdev *dmxdev = dvbdev->priv;
214
-
#ifndef DVB_MMAP
215
-
bool need_ringbuffer = false;
216
-
#else
217
-
const bool need_ringbuffer = true;
218
-
#endif
219
203
220
204
mutex_lock(&dmxdev->mutex);
221
205
···
219
213
dmxdev->demux->connect_frontend(dmxdev->demux,
220
214
dmxdev->dvr_orig_fe);
221
215
}
222
-
#ifndef DVB_MMAP
223
-
if ((file->f_flags & O_ACCMODE) == O_RDONLY)
224
-
need_ringbuffer = true;
225
-
#endif
226
216
227
-
if (need_ringbuffer) {
228
-
if (dvb_vb2_is_streaming(&dmxdev->dvr_vb2_ctx))
229
-
dvb_vb2_stream_off(&dmxdev->dvr_vb2_ctx);
230
-
dvb_vb2_release(&dmxdev->dvr_vb2_ctx);
217
+
if (((file->f_flags & O_ACCMODE) == O_RDONLY) ||
218
+
dmxdev->may_do_mmap) {
219
+
if (dmxdev->may_do_mmap) {
220
+
if (dvb_vb2_is_streaming(&dmxdev->dvr_vb2_ctx))
221
+
dvb_vb2_stream_off(&dmxdev->dvr_vb2_ctx);
222
+
dvb_vb2_release(&dmxdev->dvr_vb2_ctx);
223
+
}
231
224
dvbdev->readers++;
232
225
if (dmxdev->dvr_buffer.data) {
233
226
void *mem = dmxdev->dvr_buffer.data;
···
385
380
386
381
static int dvb_dmxdev_section_callback(const u8 *buffer1, size_t buffer1_len,
387
382
const u8 *buffer2, size_t buffer2_len,
388
-
struct dmx_section_filter *filter)
383
+
struct dmx_section_filter *filter,
384
+
u32 *buffer_flags)
389
385
{
390
386
struct dmxdev_filter *dmxdevfilter = filter->priv;
391
387
int ret;
···
405
399
dprintk("section callback %*ph\n", 6, buffer1);
406
400
if (dvb_vb2_is_streaming(&dmxdevfilter->vb2_ctx)) {
407
401
ret = dvb_vb2_fill_buffer(&dmxdevfilter->vb2_ctx,
408
-
buffer1, buffer1_len);
402
+
buffer1, buffer1_len,
403
+
buffer_flags);
409
404
if (ret == buffer1_len)
410
405
ret = dvb_vb2_fill_buffer(&dmxdevfilter->vb2_ctx,
411
-
buffer2, buffer2_len);
406
+
buffer2, buffer2_len,
407
+
buffer_flags);
412
408
} else {
413
409
ret = dvb_dmxdev_buffer_write(&dmxdevfilter->buffer,
414
410
buffer1, buffer1_len);
···
430
422
431
423
static int dvb_dmxdev_ts_callback(const u8 *buffer1, size_t buffer1_len,
432
424
const u8 *buffer2, size_t buffer2_len,
433
-
struct dmx_ts_feed *feed)
425
+
struct dmx_ts_feed *feed,
426
+
u32 *buffer_flags)
434
427
{
435
428
struct dmxdev_filter *dmxdevfilter = feed->priv;
436
429
struct dvb_ringbuffer *buffer;
437
-
#ifdef DVB_MMAP
430
+
#ifdef CONFIG_DVB_MMAP
438
431
struct dvb_vb2_ctx *ctx;
439
432
#endif
440
433
int ret;
···
449
440
if (dmxdevfilter->params.pes.output == DMX_OUT_TAP ||
450
441
dmxdevfilter->params.pes.output == DMX_OUT_TSDEMUX_TAP) {
451
442
buffer = &dmxdevfilter->buffer;
452
-
#ifdef DVB_MMAP
443
+
#ifdef CONFIG_DVB_MMAP
453
444
ctx = &dmxdevfilter->vb2_ctx;
454
445
#endif
455
446
} else {
456
447
buffer = &dmxdevfilter->dev->dvr_buffer;
457
-
#ifdef DVB_MMAP
448
+
#ifdef CONFIG_DVB_MMAP
458
449
ctx = &dmxdevfilter->dev->dvr_vb2_ctx;
459
450
#endif
460
451
}
461
452
462
453
if (dvb_vb2_is_streaming(ctx)) {
463
-
ret = dvb_vb2_fill_buffer(ctx, buffer1, buffer1_len);
454
+
ret = dvb_vb2_fill_buffer(ctx, buffer1, buffer1_len,
455
+
buffer_flags);
464
456
if (ret == buffer1_len)
465
-
ret = dvb_vb2_fill_buffer(ctx, buffer2, buffer2_len);
457
+
ret = dvb_vb2_fill_buffer(ctx, buffer2, buffer2_len,
458
+
buffer_flags);
466
459
} else {
467
460
if (buffer->error) {
468
461
spin_unlock(&dmxdevfilter->dev->lock);
···
813
802
mutex_init(&dmxdevfilter->mutex);
814
803
file->private_data = dmxdevfilter;
815
804
805
+
#ifdef CONFIG_DVB_MMAP
806
+
dmxdev->may_do_mmap = 1;
807
+
#else
808
+
dmxdev->may_do_mmap = 0;
809
+
#endif
810
+
816
811
dvb_ringbuffer_init(&dmxdevfilter->buffer, NULL, 8192);
817
812
dvb_vb2_init(&dmxdevfilter->vb2_ctx, "demux_filter",
818
813
file->f_flags & O_NONBLOCK);
···
1128
1111
mutex_unlock(&dmxdevfilter->mutex);
1129
1112
break;
1130
1113
1131
-
#ifdef DVB_MMAP
1114
+
#ifdef CONFIG_DVB_MMAP
1132
1115
case DMX_REQBUFS:
1133
1116
if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
1134
1117
mutex_unlock(&dmxdev->mutex);
···
1177
1160
break;
1178
1161
#endif
1179
1162
default:
1180
-
ret = -EINVAL;
1163
+
ret = -ENOTTY;
1181
1164
break;
1182
1165
}
1183
1166
mutex_unlock(&dmxdev->mutex);
···
1216
1199
return mask;
1217
1200
}
1218
1201
1219
-
#ifdef DVB_MMAP
1202
+
#ifdef CONFIG_DVB_MMAP
1220
1203
static int dvb_demux_mmap(struct file *file, struct vm_area_struct *vma)
1221
1204
{
1222
1205
struct dmxdev_filter *dmxdevfilter = file->private_data;
1223
1206
struct dmxdev *dmxdev = dmxdevfilter->dev;
1224
1207
int ret;
1208
+
1209
+
if (!dmxdev->may_do_mmap)
1210
+
return -ENOTTY;
1225
1211
1226
1212
if (mutex_lock_interruptible(&dmxdev->mutex))
1227
1213
return -ERESTARTSYS;
···
1269
1249
.release = dvb_demux_release,
1270
1250
.poll = dvb_demux_poll,
1271
1251
.llseek = default_llseek,
1272
-
#ifdef DVB_MMAP
1252
+
#ifdef CONFIG_DVB_MMAP
1273
1253
.mmap = dvb_demux_mmap,
1274
1254
#endif
1275
1255
};
···
1300
1280
ret = dvb_dvr_set_buffer_size(dmxdev, arg);
1301
1281
break;
1302
1282
1303
-
#ifdef DVB_MMAP
1283
+
#ifdef CONFIG_DVB_MMAP
1304
1284
case DMX_REQBUFS:
1305
1285
ret = dvb_vb2_reqbufs(&dmxdev->dvr_vb2_ctx, parg);
1306
1286
break;
···
1324
1304
break;
1325
1305
#endif
1326
1306
default:
1327
-
ret = -EINVAL;
1307
+
ret = -ENOTTY;
1328
1308
break;
1329
1309
}
1330
1310
mutex_unlock(&dmxdev->mutex);
···
1342
1322
struct dvb_device *dvbdev = file->private_data;
1343
1323
struct dmxdev *dmxdev = dvbdev->priv;
1344
1324
__poll_t mask = 0;
1345
-
#ifndef DVB_MMAP
1346
-
bool need_ringbuffer = false;
1347
-
#else
1348
-
const bool need_ringbuffer = true;
1349
-
#endif
1350
1325
1351
1326
dprintk("%s\n", __func__);
1352
1327
···
1352
1337
1353
1338
poll_wait(file, &dmxdev->dvr_buffer.queue, wait);
1354
1339
1355
-
#ifndef DVB_MMAP
1356
-
if ((file->f_flags & O_ACCMODE) == O_RDONLY)
1357
-
need_ringbuffer = true;
1358
-
#endif
1359
-
if (need_ringbuffer) {
1340
+
if (((file->f_flags & O_ACCMODE) == O_RDONLY) ||
1341
+
dmxdev->may_do_mmap) {
1360
1342
if (dmxdev->dvr_buffer.error)
1361
1343
mask |= (EPOLLIN | EPOLLRDNORM | EPOLLPRI | EPOLLERR);
1362
1344
···
1365
1353
return mask;
1366
1354
}
1367
1355
1368
-
#ifdef DVB_MMAP
1356
+
#ifdef CONFIG_DVB_MMAP
1369
1357
static int dvb_dvr_mmap(struct file *file, struct vm_area_struct *vma)
1370
1358
{
1371
1359
struct dvb_device *dvbdev = file->private_data;
1372
1360
struct dmxdev *dmxdev = dvbdev->priv;
1373
1361
int ret;
1362
+
1363
+
if (!dmxdev->may_do_mmap)
1364
+
return -ENOTTY;
1374
1365
1375
1366
if (dmxdev->exit)
1376
1367
return -ENODEV;
···
1396
1381
.release = dvb_dvr_release,
1397
1382
.poll = dvb_dvr_poll,
1398
1383
.llseek = default_llseek,
1399
-
#ifdef DVB_MMAP
1384
+
#ifdef CONFIG_DVB_MMAP
1400
1385
.mmap = dvb_dvr_mmap,
1401
1386
#endif
1402
1387
};
+73
-39
drivers/media/dvb-core/dvb_demux.c
+73
-39
drivers/media/dvb-core/dvb_demux.c
···
55
55
dprintk(x); \
56
56
} while (0)
57
57
58
+
#ifdef CONFIG_DVB_DEMUX_SECTION_LOSS_LOG
59
+
# define dprintk_sect_loss(x...) dprintk(x)
60
+
#else
61
+
# define dprintk_sect_loss(x...)
62
+
#endif
63
+
64
+
#define set_buf_flags(__feed, __flag) \
65
+
do { \
66
+
(__feed)->buffer_flags |= (__flag); \
67
+
} while (0)
68
+
58
69
/******************************************************************************
59
70
* static inlined helper functions
60
71
******************************************************************************/
···
115
104
{
116
105
int count = payload(buf);
117
106
int p;
118
-
#ifdef CONFIG_DVB_DEMUX_SECTION_LOSS_LOG
119
107
int ccok;
120
108
u8 cc;
121
-
#endif
122
109
123
110
if (count == 0)
124
111
return -1;
125
112
126
113
p = 188 - count;
127
114
128
-
#ifdef CONFIG_DVB_DEMUX_SECTION_LOSS_LOG
129
115
cc = buf[3] & 0x0f;
130
116
ccok = ((feed->cc + 1) & 0x0f) == cc;
131
117
feed->cc = cc;
132
-
if (!ccok)
133
-
dprintk("missed packet: %d instead of %d!\n",
134
-
cc, (feed->cc + 1) & 0x0f);
135
-
#endif
118
+
if (!ccok) {
119
+
set_buf_flags(feed, DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED);
120
+
dprintk_sect_loss("missed packet: %d instead of %d!\n",
121
+
cc, (feed->cc + 1) & 0x0f);
122
+
}
136
123
137
124
if (buf[1] & 0x40) // PUSI ?
138
125
feed->peslen = 0xfffa;
139
126
140
127
feed->peslen += count;
141
128
142
-
return feed->cb.ts(&buf[p], count, NULL, 0, &feed->feed.ts);
129
+
return feed->cb.ts(&buf[p], count, NULL, 0, &feed->feed.ts,
130
+
&feed->buffer_flags);
143
131
}
144
132
145
133
static int dvb_dmx_swfilter_sectionfilter(struct dvb_demux_feed *feed,
···
160
150
return 0;
161
151
162
152
return feed->cb.sec(feed->feed.sec.secbuf, feed->feed.sec.seclen,
163
-
NULL, 0, &f->filter);
153
+
NULL, 0, &f->filter, &feed->buffer_flags);
164
154
}
165
155
166
156
static inline int dvb_dmx_swfilter_section_feed(struct dvb_demux_feed *feed)
···
179
169
if (sec->check_crc) {
180
170
section_syntax_indicator = ((sec->secbuf[1] & 0x80) != 0);
181
171
if (section_syntax_indicator &&
182
-
demux->check_crc32(feed, sec->secbuf, sec->seclen))
172
+
demux->check_crc32(feed, sec->secbuf, sec->seclen)) {
173
+
set_buf_flags(feed, DMX_BUFFER_FLAG_HAD_CRC32_DISCARD);
183
174
return -1;
175
+
}
184
176
}
185
177
186
178
do {
···
199
187
{
200
188
struct dmx_section_feed *sec = &feed->feed.sec;
201
189
202
-
#ifdef CONFIG_DVB_DEMUX_SECTION_LOSS_LOG
203
190
if (sec->secbufp < sec->tsfeedp) {
204
191
int n = sec->tsfeedp - sec->secbufp;
205
192
···
208
197
* but just first and last.
209
198
*/
210
199
if (sec->secbuf[0] != 0xff || sec->secbuf[n - 1] != 0xff) {
211
-
dprintk("section ts padding loss: %d/%d\n",
212
-
n, sec->tsfeedp);
213
-
dprintk("pad data: %*ph\n", n, sec->secbuf);
200
+
set_buf_flags(feed,
201
+
DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED);
202
+
dprintk_sect_loss("section ts padding loss: %d/%d\n",
203
+
n, sec->tsfeedp);
204
+
dprintk_sect_loss("pad data: %*ph\n", n, sec->secbuf);
214
205
}
215
206
}
216
-
#endif
217
207
218
208
sec->tsfeedp = sec->secbufp = sec->seclen = 0;
219
209
sec->secbuf = sec->secbuf_base;
···
249
237
return 0;
250
238
251
239
if (sec->tsfeedp + len > DMX_MAX_SECFEED_SIZE) {
252
-
#ifdef CONFIG_DVB_DEMUX_SECTION_LOSS_LOG
253
-
dprintk("section buffer full loss: %d/%d\n",
254
-
sec->tsfeedp + len - DMX_MAX_SECFEED_SIZE,
255
-
DMX_MAX_SECFEED_SIZE);
256
-
#endif
240
+
set_buf_flags(feed, DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED);
241
+
dprintk_sect_loss("section buffer full loss: %d/%d\n",
242
+
sec->tsfeedp + len - DMX_MAX_SECFEED_SIZE,
243
+
DMX_MAX_SECFEED_SIZE);
257
244
len = DMX_MAX_SECFEED_SIZE - sec->tsfeedp;
258
245
}
259
246
···
280
269
sec->seclen = seclen;
281
270
sec->crc_val = ~0;
282
271
/* dump [secbuf .. secbuf+seclen) */
283
-
if (feed->pusi_seen)
272
+
if (feed->pusi_seen) {
284
273
dvb_dmx_swfilter_section_feed(feed);
285
-
#ifdef CONFIG_DVB_DEMUX_SECTION_LOSS_LOG
286
-
else
287
-
dprintk("pusi not seen, discarding section data\n");
288
-
#endif
274
+
} else {
275
+
set_buf_flags(feed,
276
+
DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED);
277
+
dprintk_sect_loss("pusi not seen, discarding section data\n");
278
+
}
289
279
sec->secbufp += seclen; /* secbufp and secbuf moving together is */
290
280
sec->secbuf += seclen; /* redundant but saves pointer arithmetic */
291
281
}
···
319
307
}
320
308
321
309
if (!ccok || dc_i) {
322
-
#ifdef CONFIG_DVB_DEMUX_SECTION_LOSS_LOG
323
-
if (dc_i)
324
-
dprintk("%d frame with disconnect indicator\n",
310
+
if (dc_i) {
311
+
set_buf_flags(feed,
312
+
DMX_BUFFER_FLAG_DISCONTINUITY_INDICATOR);
313
+
dprintk_sect_loss("%d frame with disconnect indicator\n",
325
314
cc);
326
-
else
327
-
dprintk("discontinuity: %d instead of %d. %d bytes lost\n",
315
+
} else {
316
+
set_buf_flags(feed,
317
+
DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED);
318
+
dprintk_sect_loss("discontinuity: %d instead of %d. %d bytes lost\n",
328
319
cc, (feed->cc + 1) & 0x0f, count + 4);
320
+
}
329
321
/*
330
-
* those bytes under sume circumstances will again be reported
322
+
* those bytes under some circumstances will again be reported
331
323
* in the following dvb_dmx_swfilter_section_new
332
324
*/
333
-
#endif
325
+
334
326
/*
335
327
* Discontinuity detected. Reset pusi_seen to
336
328
* stop feeding of suspicious data until next PUSI=1 arrives
···
342
326
* FIXME: does it make sense if the MPEG-TS is the one
343
327
* reporting discontinuity?
344
328
*/
329
+
345
330
feed->pusi_seen = false;
346
331
dvb_dmx_swfilter_section_new(feed);
347
332
}
···
362
345
dvb_dmx_swfilter_section_new(feed);
363
346
dvb_dmx_swfilter_section_copy_dump(feed, after,
364
347
after_len);
348
+
} else if (count > 0) {
349
+
set_buf_flags(feed,
350
+
DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED);
351
+
dprintk_sect_loss("PUSI=1 but %d bytes lost\n", count);
365
352
}
366
-
#ifdef CONFIG_DVB_DEMUX_SECTION_LOSS_LOG
367
-
else if (count > 0)
368
-
dprintk("PUSI=1 but %d bytes lost\n", count);
369
-
#endif
370
353
} else {
371
354
/* PUSI=0 (is not set), no section boundary */
372
355
dvb_dmx_swfilter_section_copy_dump(feed, &buf[p], count);
···
386
369
if (feed->ts_type & TS_PAYLOAD_ONLY)
387
370
dvb_dmx_swfilter_payload(feed, buf);
388
371
else
389
-
feed->cb.ts(buf, 188, NULL, 0, &feed->feed.ts);
372
+
feed->cb.ts(buf, 188, NULL, 0, &feed->feed.ts,
373
+
&feed->buffer_flags);
390
374
}
391
375
/* Used only on full-featured devices */
392
376
if (feed->ts_type & TS_DECODER)
···
448
430
}
449
431
450
432
if (buf[1] & 0x80) {
433
+
list_for_each_entry(feed, &demux->feed_list, list_head) {
434
+
if ((feed->pid != pid) && (feed->pid != 0x2000))
435
+
continue;
436
+
set_buf_flags(feed, DMX_BUFFER_FLAG_TEI);
437
+
}
451
438
dprintk_tscheck("TEI detected. PID=0x%x data1=0x%x\n",
452
439
pid, buf[1]);
453
440
/* data in this packet can't be trusted - drop it unless
···
468
445
(demux->cnt_storage[pid] + 1) & 0xf;
469
446
470
447
if ((buf[3] & 0xf) != demux->cnt_storage[pid]) {
448
+
list_for_each_entry(feed, &demux->feed_list, list_head) {
449
+
if ((feed->pid != pid) && (feed->pid != 0x2000))
450
+
continue;
451
+
set_buf_flags(feed,
452
+
DMX_BUFFER_PKT_COUNTER_MISMATCH);
453
+
}
454
+
471
455
dprintk_tscheck("TS packet counter mismatch. PID=0x%x expected 0x%x got 0x%x\n",
472
456
pid, demux->cnt_storage[pid],
473
457
buf[3] & 0xf);
···
496
466
if (feed->pid == pid)
497
467
dvb_dmx_swfilter_packet_type(feed, buf);
498
468
else if (feed->pid == 0x2000)
499
-
feed->cb.ts(buf, 188, NULL, 0, &feed->feed.ts);
469
+
feed->cb.ts(buf, 188, NULL, 0, &feed->feed.ts,
470
+
&feed->buffer_flags);
500
471
}
501
472
}
502
473
···
616
585
617
586
spin_lock_irqsave(&demux->lock, flags);
618
587
619
-
demux->feed->cb.ts(buf, count, NULL, 0, &demux->feed->feed.ts);
588
+
demux->feed->cb.ts(buf, count, NULL, 0, &demux->feed->feed.ts,
589
+
&demux->feed->buffer_flags);
620
590
621
591
spin_unlock_irqrestore(&demux->lock, flags);
622
592
}
···
817
785
feed->demux = demux;
818
786
feed->pid = 0xffff;
819
787
feed->peslen = 0xfffa;
788
+
feed->buffer_flags = 0;
820
789
821
790
(*ts_feed) = &feed->feed.ts;
822
791
(*ts_feed)->parent = dmx;
···
1075
1042
dvbdmxfeed->cb.sec = callback;
1076
1043
dvbdmxfeed->demux = dvbdmx;
1077
1044
dvbdmxfeed->pid = 0xffff;
1045
+
dvbdmxfeed->buffer_flags = 0;
1078
1046
dvbdmxfeed->feed.sec.secbuf = dvbdmxfeed->feed.sec.secbuf_base;
1079
1047
dvbdmxfeed->feed.sec.secbufp = dvbdmxfeed->feed.sec.seclen = 0;
1080
1048
dvbdmxfeed->feed.sec.tsfeedp = 0;
+3
-2
drivers/media/dvb-core/dvb_net.c
+3
-2
drivers/media/dvb-core/dvb_net.c
···
883
883
884
884
static int dvb_net_ts_callback(const u8 *buffer1, size_t buffer1_len,
885
885
const u8 *buffer2, size_t buffer2_len,
886
-
struct dmx_ts_feed *feed)
886
+
struct dmx_ts_feed *feed,
887
+
u32 *buffer_flags)
887
888
{
888
889
struct net_device *dev = feed->priv;
889
890
···
993
992
994
993
static int dvb_net_sec_callback(const u8 *buffer1, size_t buffer1_len,
995
994
const u8 *buffer2, size_t buffer2_len,
996
-
struct dmx_section_filter *filter)
995
+
struct dmx_section_filter *filter, u32 *buffer_flags)
997
996
{
998
997
struct net_device *dev = filter->priv;
999
998
+22
-9
drivers/media/dvb-core/dvb_vb2.c
+22
-9
drivers/media/dvb-core/dvb_vb2.c
···
256
256
}
257
257
258
258
int dvb_vb2_fill_buffer(struct dvb_vb2_ctx *ctx,
259
-
const unsigned char *src, int len)
259
+
const unsigned char *src, int len,
260
+
enum dmx_buffer_flags *buffer_flags)
260
261
{
261
262
unsigned long flags = 0;
262
263
void *vbuf = NULL;
···
265
264
unsigned char *psrc = (unsigned char *)src;
266
265
int ll = 0;
267
266
268
-
dprintk(3, "[%s] %d bytes are rcvd\n", ctx->name, len);
269
-
if (!src) {
270
-
dprintk(3, "[%s]:NULL pointer src\n", ctx->name);
271
-
/**normal case: This func is called twice from demux driver
272
-
* once with valid src pointer, second time with NULL pointer
273
-
*/
267
+
/*
268
+
* normal case: This func is called twice from demux driver
269
+
* one with valid src pointer, second time with NULL pointer
270
+
*/
271
+
if (!src || !len)
274
272
return 0;
275
-
}
276
273
spin_lock_irqsave(&ctx->slock, flags);
274
+
if (buffer_flags && *buffer_flags) {
275
+
ctx->flags |= *buffer_flags;
276
+
*buffer_flags = 0;
277
+
}
277
278
while (todo) {
278
279
if (!ctx->buf) {
279
280
if (list_empty(&ctx->dvb_q)) {
···
398
395
399
396
int dvb_vb2_dqbuf(struct dvb_vb2_ctx *ctx, struct dmx_buffer *b)
400
397
{
398
+
unsigned long flags;
401
399
int ret;
402
400
403
401
ret = vb2_core_dqbuf(&ctx->vb_q, &b->index, b, ctx->nonblocking);
···
406
402
dprintk(1, "[%s] errno=%d\n", ctx->name, ret);
407
403
return ret;
408
404
}
409
-
dprintk(5, "[%s] index=%d\n", ctx->name, b->index);
405
+
406
+
spin_lock_irqsave(&ctx->slock, flags);
407
+
b->count = ctx->count++;
408
+
b->flags = ctx->flags;
409
+
ctx->flags = 0;
410
+
spin_unlock_irqrestore(&ctx->slock, flags);
411
+
412
+
dprintk(5, "[%s] index=%d, count=%d, flags=%d\n",
413
+
ctx->name, b->index, ctx->count, b->flags);
414
+
410
415
411
416
return 0;
412
417
}
+5
-2
drivers/media/dvb-frontends/m88ds3103.c
+5
-2
drivers/media/dvb-frontends/m88ds3103.c
···
1262
1262
* New users must use I2C client binding directly!
1263
1263
*/
1264
1264
struct dvb_frontend *m88ds3103_attach(const struct m88ds3103_config *cfg,
1265
-
struct i2c_adapter *i2c, struct i2c_adapter **tuner_i2c_adapter)
1265
+
struct i2c_adapter *i2c,
1266
+
struct i2c_adapter **tuner_i2c_adapter)
1266
1267
{
1267
1268
struct i2c_client *client;
1268
1269
struct i2c_board_info board_info;
1269
-
struct m88ds3103_platform_data pdata;
1270
+
struct m88ds3103_platform_data pdata = {};
1270
1271
1271
1272
pdata.clk = cfg->clock;
1272
1273
pdata.i2c_wr_max = cfg->i2c_wr_max;
···
1410
1409
case M88DS3103_CHIP_ID:
1411
1410
break;
1412
1411
default:
1412
+
ret = -ENODEV;
1413
+
dev_err(&client->dev, "Unknown device. Chip_id=%02x\n", dev->chip_id);
1413
1414
goto err_kfree;
1414
1415
}
1415
1416
+45
-43
drivers/media/i2c/tvp5150.c
+45
-43
drivers/media/i2c/tvp5150.c
···
505
505
/* FIXME: Current api doesn't handle all VBI types, those not
506
506
yet supported are placed under #if 0 */
507
507
#if 0
508
-
{0x010, /* Teletext, SECAM, WST System A */
508
+
[0] = {0x010, /* Teletext, SECAM, WST System A */
509
509
{V4L2_SLICED_TELETEXT_SECAM,6,23,1},
510
510
{ 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x26,
511
511
0xe6, 0xb4, 0x0e, 0x00, 0x00, 0x00, 0x10, 0x00 }
512
512
},
513
513
#endif
514
-
{0x030, /* Teletext, PAL, WST System B */
514
+
[1] = {0x030, /* Teletext, PAL, WST System B */
515
515
{V4L2_SLICED_TELETEXT_B,6,22,1},
516
516
{ 0xaa, 0xaa, 0xff, 0xff, 0x27, 0x2e, 0x20, 0x2b,
517
517
0xa6, 0x72, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00 }
518
518
},
519
519
#if 0
520
-
{0x050, /* Teletext, PAL, WST System C */
520
+
[2] = {0x050, /* Teletext, PAL, WST System C */
521
521
{V4L2_SLICED_TELETEXT_PAL_C,6,22,1},
522
522
{ 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x22,
523
523
0xa6, 0x98, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 }
524
524
},
525
-
{0x070, /* Teletext, NTSC, WST System B */
525
+
[3] = {0x070, /* Teletext, NTSC, WST System B */
526
526
{V4L2_SLICED_TELETEXT_NTSC_B,10,21,1},
527
527
{ 0xaa, 0xaa, 0xff, 0xff, 0x27, 0x2e, 0x20, 0x23,
528
528
0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 }
529
529
},
530
-
{0x090, /* Tetetext, NTSC NABTS System C */
530
+
[4] = {0x090, /* Tetetext, NTSC NABTS System C */
531
531
{V4L2_SLICED_TELETEXT_NTSC_C,10,21,1},
532
532
{ 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x22,
533
533
0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x15, 0x00 }
534
534
},
535
-
{0x0b0, /* Teletext, NTSC-J, NABTS System D */
535
+
[5] = {0x0b0, /* Teletext, NTSC-J, NABTS System D */
536
536
{V4L2_SLICED_TELETEXT_NTSC_D,10,21,1},
537
537
{ 0xaa, 0xaa, 0xff, 0xff, 0xa7, 0x2e, 0x20, 0x23,
538
538
0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 }
539
539
},
540
-
{0x0d0, /* Closed Caption, PAL/SECAM */
540
+
[6] = {0x0d0, /* Closed Caption, PAL/SECAM */
541
541
{V4L2_SLICED_CAPTION_625,22,22,1},
542
542
{ 0xaa, 0x2a, 0xff, 0x3f, 0x04, 0x51, 0x6e, 0x02,
543
543
0xa6, 0x7b, 0x09, 0x00, 0x00, 0x00, 0x27, 0x00 }
544
544
},
545
545
#endif
546
-
{0x0f0, /* Closed Caption, NTSC */
546
+
[7] = {0x0f0, /* Closed Caption, NTSC */
547
547
{V4L2_SLICED_CAPTION_525,21,21,1},
548
548
{ 0xaa, 0x2a, 0xff, 0x3f, 0x04, 0x51, 0x6e, 0x02,
549
549
0x69, 0x8c, 0x09, 0x00, 0x00, 0x00, 0x27, 0x00 }
550
550
},
551
-
{0x110, /* Wide Screen Signal, PAL/SECAM */
551
+
[8] = {0x110, /* Wide Screen Signal, PAL/SECAM */
552
552
{V4L2_SLICED_WSS_625,23,23,1},
553
553
{ 0x5b, 0x55, 0xc5, 0xff, 0x00, 0x71, 0x6e, 0x42,
554
554
0xa6, 0xcd, 0x0f, 0x00, 0x00, 0x00, 0x3a, 0x00 }
555
555
},
556
556
#if 0
557
-
{0x130, /* Wide Screen Signal, NTSC C */
557
+
[9] = {0x130, /* Wide Screen Signal, NTSC C */
558
558
{V4L2_SLICED_WSS_525,20,20,1},
559
559
{ 0x38, 0x00, 0x3f, 0x00, 0x00, 0x71, 0x6e, 0x43,
560
560
0x69, 0x7c, 0x08, 0x00, 0x00, 0x00, 0x39, 0x00 }
561
561
},
562
-
{0x150, /* Vertical Interval Timecode (VITC), PAL/SECAM */
562
+
[10] = {0x150, /* Vertical Interval Timecode (VITC), PAL/SECAM */
563
563
{V4l2_SLICED_VITC_625,6,22,0},
564
564
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x6d, 0x49,
565
565
0xa6, 0x85, 0x08, 0x00, 0x00, 0x00, 0x4c, 0x00 }
566
566
},
567
-
{0x170, /* Vertical Interval Timecode (VITC), NTSC */
567
+
[11] = {0x170, /* Vertical Interval Timecode (VITC), NTSC */
568
568
{V4l2_SLICED_VITC_525,10,20,0},
569
569
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x6d, 0x49,
570
570
0x69, 0x94, 0x08, 0x00, 0x00, 0x00, 0x4c, 0x00 }
571
571
},
572
572
#endif
573
-
{0x190, /* Video Program System (VPS), PAL */
573
+
[12] = {0x190, /* Video Program System (VPS), PAL */
574
574
{V4L2_SLICED_VPS,16,16,0},
575
575
{ 0xaa, 0xaa, 0xff, 0xff, 0xba, 0xce, 0x2b, 0x0d,
576
576
0xa6, 0xda, 0x0b, 0x00, 0x00, 0x00, 0x60, 0x00 }
577
577
},
578
578
/* 0x1d0 User programmable */
579
-
580
-
/* End of struct */
581
-
{ (u16)-1 }
582
579
};
583
580
584
581
static int tvp5150_write_inittab(struct v4l2_subdev *sd,
···
588
591
return 0;
589
592
}
590
593
591
-
static int tvp5150_vdp_init(struct v4l2_subdev *sd,
592
-
const struct i2c_vbi_ram_value *regs)
594
+
static int tvp5150_vdp_init(struct v4l2_subdev *sd)
593
595
{
594
596
unsigned int i;
597
+
int j;
595
598
596
599
/* Disable Full Field */
597
600
tvp5150_write(sd, TVP5150_FULL_FIELD_ENA, 0);
···
601
604
tvp5150_write(sd, i, 0xff);
602
605
603
606
/* Load Ram Table */
604
-
while (regs->reg != (u16)-1) {
607
+
for (j = 0; j < ARRAY_SIZE(vbi_ram_default); j++) {
608
+
const struct i2c_vbi_ram_value *regs = &vbi_ram_default[j];
609
+
610
+
if (!regs->type.vbi_type)
611
+
continue;
612
+
605
613
tvp5150_write(sd, TVP5150_CONF_RAM_ADDR_HIGH, regs->reg >> 8);
606
614
tvp5150_write(sd, TVP5150_CONF_RAM_ADDR_LOW, regs->reg);
607
615
608
616
for (i = 0; i < 16; i++)
609
617
tvp5150_write(sd, TVP5150_VDP_CONF_RAM_DATA, regs->values[i]);
610
-
611
-
regs++;
612
618
}
613
619
return 0;
614
620
}
···
620
620
static int tvp5150_g_sliced_vbi_cap(struct v4l2_subdev *sd,
621
621
struct v4l2_sliced_vbi_cap *cap)
622
622
{
623
-
const struct i2c_vbi_ram_value *regs = vbi_ram_default;
624
-
int line;
623
+
int line, i;
625
624
626
625
dev_dbg_lvl(sd->dev, 1, debug, "g_sliced_vbi_cap\n");
627
626
memset(cap, 0, sizeof *cap);
628
627
629
-
while (regs->reg != (u16)-1 ) {
630
-
for (line=regs->type.ini_line;line<=regs->type.end_line;line++) {
628
+
for (i = 0; i < ARRAY_SIZE(vbi_ram_default); i++) {
629
+
const struct i2c_vbi_ram_value *regs = &vbi_ram_default[i];
630
+
631
+
if (!regs->type.vbi_type)
632
+
continue;
633
+
634
+
for (line = regs->type.ini_line;
635
+
line <= regs->type.end_line;
636
+
line++) {
631
637
cap->service_lines[0][line] |= regs->type.vbi_type;
632
638
}
633
639
cap->service_set |= regs->type.vbi_type;
634
-
635
-
regs++;
636
640
}
637
641
return 0;
638
642
}
···
655
651
* MSB = field2
656
652
*/
657
653
static int tvp5150_set_vbi(struct v4l2_subdev *sd,
658
-
const struct i2c_vbi_ram_value *regs,
659
654
unsigned int type,u8 flags, int line,
660
655
const int fields)
661
656
{
662
657
struct tvp5150 *decoder = to_tvp5150(sd);
663
658
v4l2_std_id std = decoder->norm;
664
659
u8 reg;
665
-
int pos = 0;
660
+
int i, pos = 0;
666
661
667
662
if (std == V4L2_STD_ALL) {
668
663
dev_err(sd->dev, "VBI can't be configured without knowing number of lines\n");
···
674
671
if (line < 6 || line > 27)
675
672
return 0;
676
673
677
-
while (regs->reg != (u16)-1) {
674
+
for (i = 0; i < ARRAY_SIZE(vbi_ram_default); i++) {
675
+
const struct i2c_vbi_ram_value *regs = &vbi_ram_default[i];
676
+
677
+
if (!regs->type.vbi_type)
678
+
continue;
679
+
678
680
if ((type & regs->type.vbi_type) &&
679
681
(line >= regs->type.ini_line) &&
680
682
(line <= regs->type.end_line))
681
683
break;
682
-
683
-
regs++;
684
684
pos++;
685
685
}
686
-
687
-
if (regs->reg == (u16)-1)
688
-
return 0;
689
686
690
687
type = pos | (flags & 0xf0);
691
688
reg = ((line - 6) << 1) + TVP5150_LINE_MODE_INI;
···
699
696
return type;
700
697
}
701
698
702
-
static int tvp5150_get_vbi(struct v4l2_subdev *sd,
703
-
const struct i2c_vbi_ram_value *regs, int line)
699
+
static int tvp5150_get_vbi(struct v4l2_subdev *sd, int line)
704
700
{
705
701
struct tvp5150 *decoder = to_tvp5150(sd);
706
702
v4l2_std_id std = decoder->norm;
···
728
726
return 0;
729
727
}
730
728
pos = ret & 0x0f;
731
-
if (pos < 0x0f)
732
-
type |= regs[pos].type.vbi_type;
729
+
if (pos < ARRAY_SIZE(vbi_ram_default))
730
+
type |= vbi_ram_default[pos].type.vbi_type;
733
731
}
734
732
735
733
return type;
···
790
788
tvp5150_write_inittab(sd, tvp5150_init_default);
791
789
792
790
/* Initializes VDP registers */
793
-
tvp5150_vdp_init(sd, vbi_ram_default);
791
+
tvp5150_vdp_init(sd);
794
792
795
793
/* Selects decoder input */
796
794
tvp5150_selmux(sd);
···
1123
1121
for (i = 0; i <= 23; i++) {
1124
1122
svbi->service_lines[1][i] = 0;
1125
1123
svbi->service_lines[0][i] =
1126
-
tvp5150_set_vbi(sd, vbi_ram_default,
1127
-
svbi->service_lines[0][i], 0xf0, i, 3);
1124
+
tvp5150_set_vbi(sd, svbi->service_lines[0][i],
1125
+
0xf0, i, 3);
1128
1126
}
1129
1127
/* Enables FIFO */
1130
1128
tvp5150_write(sd, TVP5150_FIFO_OUT_CTRL, 1);
···
1150
1148
1151
1149
for (i = 0; i <= 23; i++) {
1152
1150
svbi->service_lines[0][i] =
1153
-
tvp5150_get_vbi(sd, vbi_ram_default, i);
1151
+
tvp5150_get_vbi(sd, i);
1154
1152
mask |= svbi->service_lines[0][i];
1155
1153
}
1156
1154
svbi->service_set = mask;
+3
-2
drivers/media/pci/ttpci/av7110.c
+3
-2
drivers/media/pci/ttpci/av7110.c
···
324
324
}
325
325
return dvbdmxfilter->feed->cb.sec(buffer1, buffer1_len,
326
326
buffer2, buffer2_len,
327
-
&dvbdmxfilter->filter);
327
+
&dvbdmxfilter->filter, NULL);
328
328
case DMX_TYPE_TS:
329
329
if (!(dvbdmxfilter->feed->ts_type & TS_PACKET))
330
330
return 0;
331
331
if (dvbdmxfilter->feed->ts_type & TS_PAYLOAD_ONLY)
332
332
return dvbdmxfilter->feed->cb.ts(buffer1, buffer1_len,
333
333
buffer2, buffer2_len,
334
-
&dvbdmxfilter->feed->feed.ts);
334
+
&dvbdmxfilter->feed->feed.ts,
335
+
NULL);
335
336
else
336
337
av7110_p2t_write(buffer1, buffer1_len,
337
338
dvbdmxfilter->feed->pid,
+3
-3
drivers/media/pci/ttpci/av7110_av.c
+3
-3
drivers/media/pci/ttpci/av7110_av.c
···
99
99
buf[4] = buf[5] = 0;
100
100
if (dvbdmxfeed->ts_type & TS_PAYLOAD_ONLY)
101
101
return dvbdmxfeed->cb.ts(buf, len, NULL, 0,
102
-
&dvbdmxfeed->feed.ts);
102
+
&dvbdmxfeed->feed.ts, NULL);
103
103
else
104
104
return dvb_filter_pes2ts(p2t, buf, len, 1);
105
105
}
···
109
109
struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *) priv;
110
110
111
111
dvbdmxfeed->cb.ts(data, 188, NULL, 0,
112
-
&dvbdmxfeed->feed.ts);
112
+
&dvbdmxfeed->feed.ts, NULL);
113
113
return 0;
114
114
}
115
115
···
814
814
memcpy(obuf + l, buf + c, TS_SIZE - l);
815
815
c = length;
816
816
}
817
-
feed->cb.ts(obuf, 188, NULL, 0, &feed->feed.ts);
817
+
feed->cb.ts(obuf, 188, NULL, 0, &feed->feed.ts, NULL);
818
818
pes_start = 0;
819
819
}
820
820
}
+1
-1
drivers/media/usb/au0828/Kconfig
+1
-1
drivers/media/usb/au0828/Kconfig
+5
-5
drivers/media/usb/ttusb-dec/ttusb_dec.c
+5
-5
drivers/media/usb/ttusb-dec/ttusb_dec.c
···
428
428
struct ttusb_dec *dec = priv;
429
429
430
430
dec->audio_filter->feed->cb.ts(data, 188, NULL, 0,
431
-
&dec->audio_filter->feed->feed.ts);
431
+
&dec->audio_filter->feed->feed.ts, NULL);
432
432
433
433
return 0;
434
434
}
···
438
438
struct ttusb_dec *dec = priv;
439
439
440
440
dec->video_filter->feed->cb.ts(data, 188, NULL, 0,
441
-
&dec->video_filter->feed->feed.ts);
441
+
&dec->video_filter->feed->feed.ts, NULL);
442
442
443
443
return 0;
444
444
}
···
490
490
491
491
if (output_pva) {
492
492
dec->video_filter->feed->cb.ts(pva, length, NULL, 0,
493
-
&dec->video_filter->feed->feed.ts);
493
+
&dec->video_filter->feed->feed.ts, NULL);
494
494
return;
495
495
}
496
496
···
551
551
case 0x02: /* MainAudioStream */
552
552
if (output_pva) {
553
553
dec->audio_filter->feed->cb.ts(pva, length, NULL, 0,
554
-
&dec->audio_filter->feed->feed.ts);
554
+
&dec->audio_filter->feed->feed.ts, NULL);
555
555
return;
556
556
}
557
557
···
589
589
590
590
if (filter)
591
591
filter->feed->cb.sec(&packet[2], length - 2, NULL, 0,
592
-
&filter->filter);
592
+
&filter->filter, NULL);
593
593
}
594
594
595
595
static void ttusb_dec_process_packet(struct ttusb_dec *dec)
+1
drivers/media/v4l2-core/Kconfig
+1
drivers/media/v4l2-core/Kconfig
+1
-2
drivers/media/v4l2-core/Makefile
+1
-2
drivers/media/v4l2-core/Makefile
···
13
13
endif
14
14
obj-$(CONFIG_V4L2_FWNODE) += v4l2-fwnode.o
15
15
ifeq ($(CONFIG_TRACEPOINTS),y)
16
-
videodev-objs += vb2-trace.o v4l2-trace.o
16
+
videodev-objs += v4l2-trace.o
17
17
endif
18
18
videodev-$(CONFIG_MEDIA_CONTROLLER) += v4l2-mc.o
19
19
···
35
35
36
36
ccflags-y += -I$(srctree)/drivers/media/dvb-frontends
37
37
ccflags-y += -I$(srctree)/drivers/media/tuners
38
-
drivers/media/v4l2-core/vb2-trace.c
drivers/media/common/videobuf2/vb2-trace.c
drivers/media/v4l2-core/vb2-trace.c
drivers/media/common/videobuf2/vb2-trace.c
+16
-5
include/media/demux.h
+16
-5
include/media/demux.h
···
117
117
* specified by @filter_value that will be used on the filter
118
118
* match logic.
119
119
* @filter_mode: Contains a 16 bytes (128 bits) filter mode.
120
-
* @parent: Pointer to struct dmx_section_feed.
120
+
* @parent: Back-pointer to struct dmx_section_feed.
121
121
* @priv: Pointer to private data of the API client.
122
122
*
123
123
*
···
130
130
u8 filter_value[DMX_MAX_FILTER_SIZE];
131
131
u8 filter_mask[DMX_MAX_FILTER_SIZE];
132
132
u8 filter_mode[DMX_MAX_FILTER_SIZE];
133
-
struct dmx_section_feed *parent; /* Back-pointer */
134
-
void *priv; /* Pointer to private data of the API client */
133
+
struct dmx_section_feed *parent;
134
+
135
+
void *priv;
135
136
};
136
137
137
138
/**
···
194
193
* @buffer2: Pointer to the tail of the filtered TS packets, or NULL.
195
194
* @buffer2_length: Length of the TS data in buffer2.
196
195
* @source: Indicates which TS feed is the source of the callback.
196
+
* @buffer_flags: Address where buffer flags are stored. Those are
197
+
* used to report discontinuity users via DVB
198
+
* memory mapped API, as defined by
199
+
* &enum dmx_buffer_flags.
197
200
*
198
201
* This function callback prototype, provided by the client of the demux API,
199
202
* is called from the demux code. The function is only called when filtering
···
250
245
size_t buffer1_length,
251
246
const u8 *buffer2,
252
247
size_t buffer2_length,
253
-
struct dmx_ts_feed *source);
248
+
struct dmx_ts_feed *source,
249
+
u32 *buffer_flags);
254
250
255
251
/**
256
252
* typedef dmx_section_cb - DVB demux TS filter callback function prototype
···
267
261
* including headers and CRC.
268
262
* @source: Indicates which section feed is the source of the
269
263
* callback.
264
+
* @buffer_flags: Address where buffer flags are stored. Those are
265
+
* used to report discontinuity users via DVB
266
+
* memory mapped API, as defined by
267
+
* &enum dmx_buffer_flags.
270
268
*
271
269
* This function callback prototype, provided by the client of the demux API,
272
270
* is called from the demux code. The function is only called when
···
296
286
size_t buffer1_len,
297
287
const u8 *buffer2,
298
288
size_t buffer2_len,
299
-
struct dmx_section_filter *source);
289
+
struct dmx_section_filter *source,
290
+
u32 *buffer_flags);
300
291
301
292
/*
302
293
* DVB Front-End
+2
include/media/dmxdev.h
+2
include/media/dmxdev.h
···
163
163
* @demux: pointer to &struct dmx_demux.
164
164
* @filternum: number of filters.
165
165
* @capabilities: demux capabilities as defined by &enum dmx_demux_caps.
166
+
* @may_do_mmap: flag used to indicate if the device may do mmap.
166
167
* @exit: flag to indicate that the demux is being released.
167
168
* @dvr_orig_fe: pointer to &struct dmx_frontend.
168
169
* @dvr_buffer: embedded &struct dvb_ringbuffer for DVB output.
···
181
180
int filternum;
182
181
int capabilities;
183
182
183
+
unsigned int may_do_mmap:1;
184
184
unsigned int exit:1;
185
185
#define DMXDEV_CAP_DUPLEX 1
186
186
struct dmx_frontend *dvr_orig_fe;
+4
include/media/dvb_demux.h
+4
include/media/dvb_demux.h
···
115
115
* @pid: PID to be filtered.
116
116
* @timeout: feed timeout.
117
117
* @filter: pointer to &struct dvb_demux_filter.
118
+
* @buffer_flags: Buffer flags used to report discontinuity users via DVB
119
+
* memory mapped API, as defined by &enum dmx_buffer_flags.
118
120
* @ts_type: type of TS, as defined by &enum ts_filter_type.
119
121
* @pes_type: type of PES, as defined by &enum dmx_ts_pes.
120
122
* @cc: MPEG-TS packet continuity counter
···
146
144
147
145
ktime_t timeout;
148
146
struct dvb_demux_filter *filter;
147
+
148
+
u32 buffer_flags;
149
149
150
150
enum ts_filter_type ts_type;
151
151
enum dmx_ts_pes pes_type;
+17
-3
include/media/dvb_vb2.h
+17
-3
include/media/dvb_vb2.h
···
85
85
* @nonblocking:
86
86
* If different than zero, device is operating on non-blocking
87
87
* mode.
88
+
* @flags: buffer flags as defined by &enum dmx_buffer_flags.
89
+
* Filled only at &DMX_DQBUF. &DMX_QBUF should zero this field.
90
+
* @count: monotonic counter for filled buffers. Helps to identify
91
+
* data stream loses. Filled only at &DMX_DQBUF. &DMX_QBUF should
92
+
* zero this field.
93
+
*
88
94
* @name: name of the device type. Currently, it can either be
89
95
* "dvr" or "demux_filter".
90
96
*/
···
106
100
int buf_siz;
107
101
int buf_cnt;
108
102
int nonblocking;
103
+
104
+
enum dmx_buffer_flags flags;
105
+
u32 count;
106
+
109
107
char name[DVB_VB2_NAME_MAX + 1];
110
108
};
111
109
112
-
#ifndef DVB_MMAP
110
+
#ifndef CONFIG_DVB_MMAP
113
111
static inline int dvb_vb2_init(struct dvb_vb2_ctx *ctx,
114
112
const char *name, int non_blocking)
115
113
{
···
124
114
return 0;
125
115
};
126
116
#define dvb_vb2_is_streaming(ctx) (0)
127
-
#define dvb_vb2_fill_buffer(ctx, file, wait) (0)
117
+
#define dvb_vb2_fill_buffer(ctx, file, wait, flags) (0)
128
118
129
119
static inline __poll_t dvb_vb2_poll(struct dvb_vb2_ctx *ctx,
130
120
struct file *file,
···
163
153
* @ctx: control struct for VB2 handler
164
154
* @src: place where the data is stored
165
155
* @len: number of bytes to be copied from @src
156
+
* @buffer_flags:
157
+
* pointer to buffer flags as defined by &enum dmx_buffer_flags.
158
+
* can be NULL.
166
159
*/
167
160
int dvb_vb2_fill_buffer(struct dvb_vb2_ctx *ctx,
168
-
const unsigned char *src, int len);
161
+
const unsigned char *src, int len,
162
+
enum dmx_buffer_flags *buffer_flags);
169
163
170
164
/**
171
165
* dvb_vb2_poll - Wrapper to vb2_core_streamon() for Digital TV
+35
include/uapi/linux/dvb/dmx.h
+35
include/uapi/linux/dvb/dmx.h
···
212
212
};
213
213
214
214
/**
215
+
* enum dmx_buffer_flags - DMX memory-mapped buffer flags
216
+
*
217
+
* @DMX_BUFFER_FLAG_HAD_CRC32_DISCARD:
218
+
* Indicates that the Kernel discarded one or more frames due to wrong
219
+
* CRC32 checksum.
220
+
* @DMX_BUFFER_FLAG_TEI:
221
+
* Indicates that the Kernel has detected a Transport Error indicator
222
+
* (TEI) on a filtered pid.
223
+
* @DMX_BUFFER_PKT_COUNTER_MISMATCH:
224
+
* Indicates that the Kernel has detected a packet counter mismatch
225
+
* on a filtered pid.
226
+
* @DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED:
227
+
* Indicates that the Kernel has detected one or more frame discontinuity.
228
+
* @DMX_BUFFER_FLAG_DISCONTINUITY_INDICATOR:
229
+
* Received at least one packet with a frame discontinuity indicator.
230
+
*/
231
+
232
+
enum dmx_buffer_flags {
233
+
DMX_BUFFER_FLAG_HAD_CRC32_DISCARD = 1 << 0,
234
+
DMX_BUFFER_FLAG_TEI = 1 << 1,
235
+
DMX_BUFFER_PKT_COUNTER_MISMATCH = 1 << 2,
236
+
DMX_BUFFER_FLAG_DISCONTINUITY_DETECTED = 1 << 3,
237
+
DMX_BUFFER_FLAG_DISCONTINUITY_INDICATOR = 1 << 4,
238
+
};
239
+
240
+
/**
215
241
* struct dmx_buffer - dmx buffer info
216
242
*
217
243
* @index: id number of the buffer
···
246
220
* offset from the start of the device memory for this plane,
247
221
* (or a "cookie" that should be passed to mmap() as offset)
248
222
* @length: size in bytes of the buffer
223
+
* @flags: bit array of buffer flags as defined by &enum dmx_buffer_flags.
224
+
* Filled only at &DMX_DQBUF.
225
+
* @count: monotonic counter for filled buffers. Helps to identify
226
+
* data stream loses. Filled only at &DMX_DQBUF.
249
227
*
250
228
* Contains data exchanged by application and driver using one of the streaming
251
229
* I/O methods.
230
+
*
231
+
* Please notice that, for &DMX_QBUF, only @index should be filled.
232
+
* On &DMX_DQBUF calls, all fields will be filled by the Kernel.
252
233
*/
253
234
struct dmx_buffer {
254
235
__u32 index;
255
236
__u32 bytesused;
256
237
__u32 offset;
257
238
__u32 length;
239
+
__u32 flags;
240
+
__u32 count;
258
241
};
259
242
260
243
/**