Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'media/v5.9-3' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media
Pull media fixes from Mauro Carvalho Chehab:
- fix a regression at the CEC adapter core
- two uAPI patches (one revert) for changes in this development cycle
* tag 'media/v5.9-3' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media:
media: dt-bindings: media: imx274: Convert to json-schema
media: media/v4l2: remove V4L2_FLAG_MEMORY_NON_CONSISTENT flag
media: cec-adap.c: don't use flush_scheduled_work()
+101
-175
-38
Documentation/devicetree/bindings/media/i2c/imx274.txt
-38
Documentation/devicetree/bindings/media/i2c/imx274.txt
···
1
-
* Sony 1/2.5-Inch 8.51Mp CMOS Digital Image Sensor
2
-
3
-
The Sony imx274 is a 1/2.5-inch CMOS active pixel digital image sensor with
4
-
an active array size of 3864H x 2202V. It is programmable through I2C
5
-
interface. The I2C address is fixed to 0x1a as per sensor data sheet.
6
-
Image data is sent through MIPI CSI-2, which is configured as 4 lanes
7
-
at 1440 Mbps.
8
-
9
-
10
-
Required Properties:
11
-
- compatible: value should be "sony,imx274" for imx274 sensor
12
-
- reg: I2C bus address of the device
13
-
14
-
Optional Properties:
15
-
- reset-gpios: Sensor reset GPIO
16
-
- clocks: Reference to the input clock.
17
-
- clock-names: Should be "inck".
18
-
- VANA-supply: Sensor 2.8v analog supply.
19
-
- VDIG-supply: Sensor 1.8v digital core supply.
20
-
- VDDL-supply: Sensor digital IO 1.2v supply.
21
-
22
-
The imx274 device node should contain one 'port' child node with
23
-
an 'endpoint' subnode. For further reading on port node refer to
24
-
Documentation/devicetree/bindings/media/video-interfaces.txt.
25
-
26
-
Example:
27
-
sensor@1a {
28
-
compatible = "sony,imx274";
29
-
reg = <0x1a>;
30
-
#address-cells = <1>;
31
-
#size-cells = <0>;
32
-
reset-gpios = <&gpio_sensor 0 0>;
33
-
port {
34
-
sensor_out: endpoint {
35
-
remote-endpoint = <&csiss_in>;
36
-
};
37
-
};
38
-
};
+76
Documentation/devicetree/bindings/media/i2c/sony,imx274.yaml
+76
Documentation/devicetree/bindings/media/i2c/sony,imx274.yaml
···
1
+
# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2
+
%YAML 1.2
3
+
---
4
+
$id: http://devicetree.org/schemas/media/i2c/sony,imx274.yaml#
5
+
$schema: http://devicetree.org/meta-schemas/core.yaml#
6
+
7
+
title: Sony 1/2.5-Inch 8.51MP CMOS Digital Image Sensor
8
+
9
+
maintainers:
10
+
- Leon Luo <leonl@leopardimaging.com>
11
+
12
+
description: |
13
+
The Sony IMX274 is a 1/2.5-inch CMOS active pixel digital image sensor with an
14
+
active array size of 3864H x 2202V. It is programmable through I2C interface.
15
+
Image data is sent through MIPI CSI-2, which is configured as 4 lanes at 1440
16
+
Mbps.
17
+
18
+
properties:
19
+
compatible:
20
+
const: sony,imx274
21
+
22
+
reg:
23
+
const: 0x1a
24
+
25
+
reset-gpios:
26
+
maxItems: 1
27
+
28
+
clocks:
29
+
maxItems: 1
30
+
31
+
clock-names:
32
+
const: inck
33
+
34
+
vana-supply:
35
+
description: Sensor 2.8 V analog supply.
36
+
maxItems: 1
37
+
38
+
vdig-supply:
39
+
description: Sensor 1.8 V digital core supply.
40
+
maxItems: 1
41
+
42
+
vddl-supply:
43
+
description: Sensor digital IO 1.2 V supply.
44
+
maxItems: 1
45
+
46
+
port:
47
+
type: object
48
+
description: Output video port. See ../video-interfaces.txt.
49
+
50
+
required:
51
+
- compatible
52
+
- reg
53
+
- port
54
+
55
+
additionalProperties: false
56
+
57
+
examples:
58
+
- |
59
+
i2c0 {
60
+
#address-cells = <1>;
61
+
#size-cells = <0>;
62
+
63
+
imx274: camera-sensor@1a {
64
+
compatible = "sony,imx274";
65
+
reg = <0x1a>;
66
+
reset-gpios = <&gpio_sensor 0 0>;
67
+
68
+
port {
69
+
sensor_out: endpoint {
70
+
remote-endpoint = <&csiss_in>;
71
+
};
72
+
};
73
+
};
74
+
};
75
+
76
+
...
-17
Documentation/userspace-api/media/v4l/buffer.rst
-17
Documentation/userspace-api/media/v4l/buffer.rst
···
701
701
:stub-columns: 0
702
702
:widths: 3 1 4
703
703
704
-
* .. _`V4L2-FLAG-MEMORY-NON-CONSISTENT`:
705
-
706
-
- ``V4L2_FLAG_MEMORY_NON_CONSISTENT``
707
-
- 0x00000001
708
-
- A buffer is allocated either in consistent (it will be automatically
709
-
coherent between the CPU and the bus) or non-consistent memory. The
710
-
latter can provide performance gains, for instance the CPU cache
711
-
sync/flush operations can be avoided if the buffer is accessed by the
712
-
corresponding device only and the CPU does not read/write to/from that
713
-
buffer. However, this requires extra care from the driver -- it must
714
-
guarantee memory consistency by issuing a cache flush/sync when
715
-
consistency is needed. If this flag is set V4L2 will attempt to
716
-
allocate the buffer in non-consistent memory. The flag takes effect
717
-
only if the buffer is used for :ref:`memory mapping <mmap>` I/O and the
718
-
queue reports the :ref:`V4L2_BUF_CAP_SUPPORTS_MMAP_CACHE_HINTS
719
-
<V4L2-BUF-CAP-SUPPORTS-MMAP-CACHE-HINTS>` capability.
720
-
721
704
.. c:type:: v4l2_memory
722
705
723
706
enum v4l2_memory
+1
-5
Documentation/userspace-api/media/v4l/vidioc-create-bufs.rst
+1
-5
Documentation/userspace-api/media/v4l/vidioc-create-bufs.rst
···
120
120
If you want to just query the capabilities without making any
121
121
other changes, then set ``count`` to 0, ``memory`` to
122
122
``V4L2_MEMORY_MMAP`` and ``format.type`` to the buffer type.
123
-
* - __u32
124
-
- ``flags``
125
-
- Specifies additional buffer management attributes.
126
-
See :ref:`memory-flags`.
127
123
128
124
* - __u32
129
-
- ``reserved``\ [6]
125
+
- ``reserved``\ [7]
130
126
- A place holder for future extensions. Drivers and applications
131
127
must set the array to zero.
132
128
+2
-10
Documentation/userspace-api/media/v4l/vidioc-reqbufs.rst
+2
-10
Documentation/userspace-api/media/v4l/vidioc-reqbufs.rst
···
112
112
``V4L2_MEMORY_MMAP`` and ``type`` set to the buffer type. This will
113
113
free any previously allocated buffers, so this is typically something
114
114
that will be done at the start of the application.
115
-
* - union {
116
-
- (anonymous)
117
-
* - __u32
118
-
- ``flags``
119
-
- Specifies additional buffer management attributes.
120
-
See :ref:`memory-flags`.
121
115
* - __u32
122
116
- ``reserved``\ [1]
123
-
- Kept for backwards compatibility. Use ``flags`` instead.
124
-
* - }
125
-
-
117
+
- A place holder for future extensions. Drivers and applications
118
+
must set the array to zero.
126
119
127
120
.. tabularcolumns:: |p{6.1cm}|p{2.2cm}|p{8.7cm}|
128
121
···
162
169
- This capability is set by the driver to indicate that the queue supports
163
170
cache and memory management hints. However, it's only valid when the
164
171
queue is used for :ref:`memory mapping <mmap>` streaming I/O. See
165
-
:ref:`V4L2_FLAG_MEMORY_NON_CONSISTENT <V4L2-FLAG-MEMORY-NON-CONSISTENT>`,
166
172
:ref:`V4L2_BUF_FLAG_NO_CACHE_INVALIDATE <V4L2-BUF-FLAG-NO-CACHE-INVALIDATE>` and
167
173
:ref:`V4L2_BUF_FLAG_NO_CACHE_CLEAN <V4L2-BUF-FLAG-NO-CACHE-CLEAN>`.
168
174
+1
-1
MAINTAINERS
+1
-1
MAINTAINERS
···
16154
16154
L: linux-media@vger.kernel.org
16155
16155
S: Maintained
16156
16156
T: git git://linuxtv.org/media_tree.git
16157
-
F: Documentation/devicetree/bindings/media/i2c/imx274.txt
16157
+
F: Documentation/devicetree/bindings/media/i2c/sony,imx274.yaml
16158
16158
F: drivers/media/i2c/imx274.c
16159
16159
16160
16160
SONY IMX290 SENSOR DRIVER
+1
-1
drivers/media/cec/core/cec-adap.c
+1
-1
drivers/media/cec/core/cec-adap.c
+6
-40
drivers/media/common/videobuf2/videobuf2-core.c
+6
-40
drivers/media/common/videobuf2/videobuf2-core.c
···
721
721
}
722
722
EXPORT_SYMBOL(vb2_verify_memory_type);
723
723
724
-
static void set_queue_consistency(struct vb2_queue *q, bool consistent_mem)
725
-
{
726
-
q->dma_attrs &= ~DMA_ATTR_NON_CONSISTENT;
727
-
728
-
if (!vb2_queue_allows_cache_hints(q))
729
-
return;
730
-
if (!consistent_mem)
731
-
q->dma_attrs |= DMA_ATTR_NON_CONSISTENT;
732
-
}
733
-
734
-
static bool verify_consistency_attr(struct vb2_queue *q, bool consistent_mem)
735
-
{
736
-
bool queue_is_consistent = !(q->dma_attrs & DMA_ATTR_NON_CONSISTENT);
737
-
738
-
if (consistent_mem != queue_is_consistent) {
739
-
dprintk(q, 1, "memory consistency model mismatch\n");
740
-
return false;
741
-
}
742
-
return true;
743
-
}
744
-
745
724
int vb2_core_reqbufs(struct vb2_queue *q, enum vb2_memory memory,
746
-
unsigned int flags, unsigned int *count)
725
+
unsigned int *count)
747
726
{
748
727
unsigned int num_buffers, allocated_buffers, num_planes = 0;
749
728
unsigned plane_sizes[VB2_MAX_PLANES] = { };
750
-
bool consistent_mem = true;
751
729
unsigned int i;
752
730
int ret;
753
-
754
-
if (flags & V4L2_FLAG_MEMORY_NON_CONSISTENT)
755
-
consistent_mem = false;
756
731
757
732
if (q->streaming) {
758
733
dprintk(q, 1, "streaming active\n");
···
740
765
}
741
766
742
767
if (*count == 0 || q->num_buffers != 0 ||
743
-
(q->memory != VB2_MEMORY_UNKNOWN && q->memory != memory) ||
744
-
!verify_consistency_attr(q, consistent_mem)) {
768
+
(q->memory != VB2_MEMORY_UNKNOWN && q->memory != memory)) {
745
769
/*
746
770
* We already have buffers allocated, so first check if they
747
771
* are not in use and can be freed.
···
777
803
num_buffers = min_t(unsigned int, num_buffers, VB2_MAX_FRAME);
778
804
memset(q->alloc_devs, 0, sizeof(q->alloc_devs));
779
805
q->memory = memory;
780
-
set_queue_consistency(q, consistent_mem);
781
806
782
807
/*
783
808
* Ask the driver how many buffers and planes per buffer it requires.
···
861
888
EXPORT_SYMBOL_GPL(vb2_core_reqbufs);
862
889
863
890
int vb2_core_create_bufs(struct vb2_queue *q, enum vb2_memory memory,
864
-
unsigned int flags, unsigned int *count,
891
+
unsigned int *count,
865
892
unsigned int requested_planes,
866
893
const unsigned int requested_sizes[])
867
894
{
868
895
unsigned int num_planes = 0, num_buffers, allocated_buffers;
869
896
unsigned plane_sizes[VB2_MAX_PLANES] = { };
870
-
bool consistent_mem = true;
871
897
int ret;
872
-
873
-
if (flags & V4L2_FLAG_MEMORY_NON_CONSISTENT)
874
-
consistent_mem = false;
875
898
876
899
if (q->num_buffers == VB2_MAX_FRAME) {
877
900
dprintk(q, 1, "maximum number of buffers already allocated\n");
···
881
912
}
882
913
memset(q->alloc_devs, 0, sizeof(q->alloc_devs));
883
914
q->memory = memory;
884
-
set_queue_consistency(q, consistent_mem);
885
915
q->waiting_for_buffers = !q->is_output;
886
916
} else {
887
917
if (q->memory != memory) {
888
918
dprintk(q, 1, "memory model mismatch\n");
889
919
return -EINVAL;
890
920
}
891
-
if (!verify_consistency_attr(q, consistent_mem))
892
-
return -EINVAL;
893
921
}
894
922
895
923
num_buffers = min(*count, VB2_MAX_FRAME - q->num_buffers);
···
2547
2581
fileio->memory = VB2_MEMORY_MMAP;
2548
2582
fileio->type = q->type;
2549
2583
q->fileio = fileio;
2550
-
ret = vb2_core_reqbufs(q, fileio->memory, 0, &fileio->count);
2584
+
ret = vb2_core_reqbufs(q, fileio->memory, &fileio->count);
2551
2585
if (ret)
2552
2586
goto err_kfree;
2553
2587
···
2604
2638
2605
2639
err_reqbufs:
2606
2640
fileio->count = 0;
2607
-
vb2_core_reqbufs(q, fileio->memory, 0, &fileio->count);
2641
+
vb2_core_reqbufs(q, fileio->memory, &fileio->count);
2608
2642
2609
2643
err_kfree:
2610
2644
q->fileio = NULL;
···
2624
2658
vb2_core_streamoff(q, q->type);
2625
2659
q->fileio = NULL;
2626
2660
fileio->count = 0;
2627
-
vb2_core_reqbufs(q, fileio->memory, 0, &fileio->count);
2661
+
vb2_core_reqbufs(q, fileio->memory, &fileio->count);
2628
2662
kfree(fileio);
2629
2663
dprintk(q, 3, "file io emulator closed\n");
2630
2664
}
-19
drivers/media/common/videobuf2/videobuf2-dma-contig.c
-19
drivers/media/common/videobuf2/videobuf2-dma-contig.c
···
42
42
struct dma_buf_attachment *db_attach;
43
43
};
44
44
45
-
static inline bool vb2_dc_buffer_consistent(unsigned long attr)
46
-
{
47
-
return !(attr & DMA_ATTR_NON_CONSISTENT);
48
-
}
49
-
50
45
/*********************************************/
51
46
/* scatterlist table functions */
52
47
/*********************************************/
···
336
341
vb2_dc_dmabuf_ops_begin_cpu_access(struct dma_buf *dbuf,
337
342
enum dma_data_direction direction)
338
343
{
339
-
struct vb2_dc_buf *buf = dbuf->priv;
340
-
struct sg_table *sgt = buf->dma_sgt;
341
-
342
-
if (vb2_dc_buffer_consistent(buf->attrs))
343
-
return 0;
344
-
345
-
dma_sync_sg_for_cpu(buf->dev, sgt->sgl, sgt->nents, buf->dma_dir);
346
344
return 0;
347
345
}
348
346
···
343
355
vb2_dc_dmabuf_ops_end_cpu_access(struct dma_buf *dbuf,
344
356
enum dma_data_direction direction)
345
357
{
346
-
struct vb2_dc_buf *buf = dbuf->priv;
347
-
struct sg_table *sgt = buf->dma_sgt;
348
-
349
-
if (vb2_dc_buffer_consistent(buf->attrs))
350
-
return 0;
351
-
352
-
dma_sync_sg_for_device(buf->dev, sgt->sgl, sgt->nents, buf->dma_dir);
353
358
return 0;
354
359
}
355
360
+1
-2
drivers/media/common/videobuf2/videobuf2-dma-sg.c
+1
-2
drivers/media/common/videobuf2/videobuf2-dma-sg.c
···
123
123
/*
124
124
* NOTE: dma-sg allocates memory using the page allocator directly, so
125
125
* there is no memory consistency guarantee, hence dma-sg ignores DMA
126
-
* attributes passed from the upper layer. That means that
127
-
* V4L2_FLAG_MEMORY_NON_CONSISTENT has no effect on dma-sg buffers.
126
+
* attributes passed from the upper layer.
128
127
*/
129
128
buf->pages = kvmalloc_array(buf->num_pages, sizeof(struct page *),
130
129
GFP_KERNEL | __GFP_ZERO);
+2
-16
drivers/media/common/videobuf2/videobuf2-v4l2.c
+2
-16
drivers/media/common/videobuf2/videobuf2-v4l2.c
···
722
722
#endif
723
723
}
724
724
725
-
static void clear_consistency_attr(struct vb2_queue *q,
726
-
int memory,
727
-
unsigned int *flags)
728
-
{
729
-
if (!q->allow_cache_hints || memory != V4L2_MEMORY_MMAP)
730
-
*flags &= ~V4L2_FLAG_MEMORY_NON_CONSISTENT;
731
-
}
732
-
733
725
int vb2_reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req)
734
726
{
735
727
int ret = vb2_verify_memory_type(q, req->memory, req->type);
736
728
737
729
fill_buf_caps(q, &req->capabilities);
738
-
clear_consistency_attr(q, req->memory, &req->flags);
739
-
return ret ? ret : vb2_core_reqbufs(q, req->memory,
740
-
req->flags, &req->count);
730
+
return ret ? ret : vb2_core_reqbufs(q, req->memory, &req->count);
741
731
}
742
732
EXPORT_SYMBOL_GPL(vb2_reqbufs);
743
733
···
759
769
unsigned i;
760
770
761
771
fill_buf_caps(q, &create->capabilities);
762
-
clear_consistency_attr(q, create->memory, &create->flags);
763
772
create->index = q->num_buffers;
764
773
if (create->count == 0)
765
774
return ret != -EBUSY ? ret : 0;
···
802
813
if (requested_sizes[i] == 0)
803
814
return -EINVAL;
804
815
return ret ? ret : vb2_core_create_bufs(q, create->memory,
805
-
create->flags,
806
816
&create->count,
807
817
requested_planes,
808
818
requested_sizes);
···
986
998
int res = vb2_verify_memory_type(vdev->queue, p->memory, p->type);
987
999
988
1000
fill_buf_caps(vdev->queue, &p->capabilities);
989
-
clear_consistency_attr(vdev->queue, p->memory, &p->flags);
990
1001
if (res)
991
1002
return res;
992
1003
if (vb2_queue_is_busy(vdev, file))
993
1004
return -EBUSY;
994
-
res = vb2_core_reqbufs(vdev->queue, p->memory, p->flags, &p->count);
1005
+
res = vb2_core_reqbufs(vdev->queue, p->memory, &p->count);
995
1006
/* If count == 0, then the owner has released all buffers and he
996
1007
is no longer owner of the queue. Otherwise we have a new owner. */
997
1008
if (res == 0)
···
1008
1021
1009
1022
p->index = vdev->queue->num_buffers;
1010
1023
fill_buf_caps(vdev->queue, &p->capabilities);
1011
-
clear_consistency_attr(vdev->queue, p->memory, &p->flags);
1012
1024
/*
1013
1025
* If count == 0, then just check if memory and type are valid.
1014
1026
* Any -EBUSY result from vb2_verify_memory_type can be mapped to 0.
+1
-1
drivers/media/dvb-core/dvb_vb2.c
+1
-1
drivers/media/dvb-core/dvb_vb2.c
···
342
342
343
343
ctx->buf_siz = req->size;
344
344
ctx->buf_cnt = req->count;
345
-
ret = vb2_core_reqbufs(&ctx->vb_q, VB2_MEMORY_MMAP, 0, &req->count);
345
+
ret = vb2_core_reqbufs(&ctx->vb_q, VB2_MEMORY_MMAP, &req->count);
346
346
if (ret) {
347
347
ctx->state = DVB_VB2_STATE_NONE;
348
348
dprintk(1, "[%s] count=%d size=%d errno=%d\n", ctx->name,
+2
-8
drivers/media/v4l2-core/v4l2-compat-ioctl32.c
+2
-8
drivers/media/v4l2-core/v4l2-compat-ioctl32.c
···
246
246
* @memory: buffer memory type
247
247
* @format: frame format, for which buffers are requested
248
248
* @capabilities: capabilities of this buffer type.
249
-
* @flags: additional buffer management attributes (ignored unless the
250
-
* queue has V4L2_BUF_CAP_SUPPORTS_MMAP_CACHE_HINTS capability and
251
-
* configured for MMAP streaming I/O).
252
249
* @reserved: future extensions
253
250
*/
254
251
struct v4l2_create_buffers32 {
···
254
257
__u32 memory; /* enum v4l2_memory */
255
258
struct v4l2_format32 format;
256
259
__u32 capabilities;
257
-
__u32 flags;
258
-
__u32 reserved[6];
260
+
__u32 reserved[7];
259
261
};
260
262
261
263
static int __bufsize_v4l2_format(struct v4l2_format32 __user *p32, u32 *size)
···
355
359
{
356
360
if (!access_ok(p32, sizeof(*p32)) ||
357
361
copy_in_user(p64, p32,
358
-
offsetof(struct v4l2_create_buffers32, format)) ||
359
-
assign_in_user(&p64->flags, &p32->flags))
362
+
offsetof(struct v4l2_create_buffers32, format)))
360
363
return -EFAULT;
361
364
return __get_v4l2_format32(&p64->format, &p32->format,
362
365
aux_buf, aux_space);
···
417
422
copy_in_user(p32, p64,
418
423
offsetof(struct v4l2_create_buffers32, format)) ||
419
424
assign_in_user(&p32->capabilities, &p64->capabilities) ||
420
-
assign_in_user(&p32->flags, &p64->flags) ||
421
425
copy_in_user(p32->reserved, p64->reserved, sizeof(p64->reserved)))
422
426
return -EFAULT;
423
427
return __put_v4l2_format32(&p64->format, &p32->format);
+4
-1
drivers/media/v4l2-core/v4l2-ioctl.c
+4
-1
drivers/media/v4l2-core/v4l2-ioctl.c
···
2042
2042
2043
2043
if (ret)
2044
2044
return ret;
2045
+
2046
+
CLEAR_AFTER_FIELD(p, capabilities);
2047
+
2045
2048
return ops->vidioc_reqbufs(file, fh, p);
2046
2049
}
2047
2050
···
2084
2081
if (ret)
2085
2082
return ret;
2086
2083
2087
-
CLEAR_AFTER_FIELD(create, flags);
2084
+
CLEAR_AFTER_FIELD(create, capabilities);
2088
2085
2089
2086
v4l_sanitize_format(&create->format);
2090
2087
+2
-5
include/media/videobuf2-core.h
+2
-5
include/media/videobuf2-core.h
···
744
744
* vb2_core_reqbufs() - Initiate streaming.
745
745
* @q: pointer to &struct vb2_queue with videobuf2 queue.
746
746
* @memory: memory type, as defined by &enum vb2_memory.
747
-
* @flags: auxiliary queue/buffer management flags. Currently, the only
748
-
* used flag is %V4L2_FLAG_MEMORY_NON_CONSISTENT.
749
747
* @count: requested buffer count.
750
748
*
751
749
* Videobuf2 core helper to implement VIDIOC_REQBUF() operation. It is called
···
768
770
* Return: returns zero on success; an error code otherwise.
769
771
*/
770
772
int vb2_core_reqbufs(struct vb2_queue *q, enum vb2_memory memory,
771
-
unsigned int flags, unsigned int *count);
773
+
unsigned int *count);
772
774
773
775
/**
774
776
* vb2_core_create_bufs() - Allocate buffers and any required auxiliary structs
775
777
* @q: pointer to &struct vb2_queue with videobuf2 queue.
776
778
* @memory: memory type, as defined by &enum vb2_memory.
777
-
* @flags: auxiliary queue/buffer management flags.
778
779
* @count: requested buffer count.
779
780
* @requested_planes: number of planes requested.
780
781
* @requested_sizes: array with the size of the planes.
···
791
794
* Return: returns zero on success; an error code otherwise.
792
795
*/
793
796
int vb2_core_create_bufs(struct vb2_queue *q, enum vb2_memory memory,
794
-
unsigned int flags, unsigned int *count,
797
+
unsigned int *count,
795
798
unsigned int requested_planes,
796
799
const unsigned int requested_sizes[]);
797
800
+2
-11
include/uapi/linux/videodev2.h
+2
-11
include/uapi/linux/videodev2.h
···
191
191
V4L2_MEMORY_DMABUF = 4,
192
192
};
193
193
194
-
#define V4L2_FLAG_MEMORY_NON_CONSISTENT (1 << 0)
195
-
196
194
/* see also http://vektor.theorem.ca/graphics/ycbcr/ */
197
195
enum v4l2_colorspace {
198
196
/*
···
947
949
__u32 type; /* enum v4l2_buf_type */
948
950
__u32 memory; /* enum v4l2_memory */
949
951
__u32 capabilities;
950
-
union {
951
-
__u32 flags;
952
-
__u32 reserved[1];
953
-
};
952
+
__u32 reserved[1];
954
953
};
955
954
956
955
/* capabilities for struct v4l2_requestbuffers and v4l2_create_buffers */
···
2451
2456
* @memory: enum v4l2_memory; buffer memory type
2452
2457
* @format: frame format, for which buffers are requested
2453
2458
* @capabilities: capabilities of this buffer type.
2454
-
* @flags: additional buffer management attributes (ignored unless the
2455
-
* queue has V4L2_BUF_CAP_SUPPORTS_MMAP_CACHE_HINTS capability
2456
-
* and configured for MMAP streaming I/O).
2457
2459
* @reserved: future extensions
2458
2460
*/
2459
2461
struct v4l2_create_buffers {
···
2459
2467
__u32 memory;
2460
2468
struct v4l2_format format;
2461
2469
__u32 capabilities;
2462
-
__u32 flags;
2463
-
__u32 reserved[6];
2470
+
__u32 reserved[7];
2464
2471
};
2465
2472
2466
2473
/*