Merge tag 'media/v4.10-1' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media

Pull media updates from Mauro Carvalho Chehab: - new Mediatek drivers: mtk-mdp and mtk-vcodec - some additions at the media documentation - the CEC core and drivers were promoted from staging to mainstream - some cleanups at the DVB core - the LIRC serial driver got promoted from staging to mainstream - added a driver for Renesas R-Car FDP1 driver - add DVBv5 statistics support to mn88473 driver - several fixes related to printk continuation lines - add support for HSV encoding formats - lots of other cleanups, fixups and driver improvements. * tag 'media/v4.10-1' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media: (496 commits) [media] v4l: tvp5150: Add missing break in set control handler [media] v4l: tvp5150: Don't inline the tvp5150_selmux() function [media] v4l: tvp5150: Compile tvp5150_link_setup out if !CONFIG_MEDIA_CONTROLLER [media] em28xx: don't store usb_device at struct em28xx [media] em28xx: use usb_interface for dev_foo() calls [media] em28xx: don't change the device's name [media] mn88472: fix chip id check on probe [media] mn88473: fix chip id check on probe [media] lirc: fix error paths in lirc_cdev_add() [media] s5p-mfc: Add support for MFC v8 available in Exynos 5433 SoCs [media] s5p-mfc: Rework clock handling [media] s5p-mfc: Don't keep clock prepared all the time [media] s5p-mfc: Kill all IS_ERR_OR_NULL in clocks management code [media] s5p-mfc: Remove dead conditional code [media] s5p-mfc: Ensure that clock is disabled before turning power off [media] s5p-mfc: Remove special clock rate management [media] s5p-mfc: Use printk_ratelimited for reporting ioctl errors [media] s5p-mfc: Set DMA_ATTR_ALLOC_SINGLE_PAGES [media] vivid: Set color_enc on HSV formats [media] v4l2-tpg: Init hv_enc field with a valid value ...

Linus Torvalds committed 9 years ago

Commit bd9999c2 parents 9dfe495 65390ea633 files · +27627 −13396Browse files

Showing the changes to include/uapi/linux (6 of 633 files). Show all

Unified · Split

6 files

include/uapi/linux/Kbuild +2 −0
include/uapi/linux/cec-funcs.h +1965 −0
include/uapi/linux/cec.h +1066 −0
include/uapi/linux/v4l2-controls.h +1 −0
include/uapi/linux/v4l2-dv-timings.h +63 −34
include/uapi/linux/videodev2.h +91 −27

include/uapi/linux/Kbuild+2−0

@@ -84,6 +84,8 @@ header-y += capi.h · 83 unmodified lines
84	84	header-y += cciss_defs.h
85	85	header-y += cciss_ioctl.h
86	86	header-y += cdrom.h
	87	+header-y += cec.h
	88	+header-y += cec-funcs.h
87	89	header-y += cgroupstats.h
88	90	header-y += chio.h
89	91	header-y += cm4000_cs.h

include/uapi/linux/cec-funcs.h+1965−0

@@ -0,0 +1,1965 @@
	1	+/*
	2	+ * cec - HDMI Consumer Electronics Control message functions
	3	+ *
	4	+ * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
	5	+ *
	6	+ * This program is free software; you may redistribute it and/or modify
	7	+ * it under the terms of the GNU General Public License as published by
	8	+ * the Free Software Foundation; version 2 of the License.
	9	+ *
	10	+ * Alternatively you can redistribute this file under the terms of the
	11	+ * BSD license as stated below:
	12	+ *
	13	+ * Redistribution and use in source and binary forms, with or without
	14	+ * modification, are permitted provided that the following conditions
	15	+ * are met:
	16	+ * 1. Redistributions of source code must retain the above copyright
	17	+ * notice, this list of conditions and the following disclaimer.
	18	+ * 2. Redistributions in binary form must reproduce the above copyright
	19	+ * notice, this list of conditions and the following disclaimer in
	20	+ * the documentation and/or other materials provided with the
	21	+ * distribution.
	22	+ * 3. The names of its contributors may not be used to endorse or promote
	23	+ * products derived from this software without specific prior written
	24	+ * permission.
	25	+ *
	26	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	27	+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	28	+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	29	+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	30	+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	31	+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	32	+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	33	+ * SOFTWARE.
	34	+ */
	35	+
	36	+#ifndef _CEC_UAPI_FUNCS_H
	37	+#define _CEC_UAPI_FUNCS_H
	38	+
	39	+#include <linux/cec.h>
	40	+
	41	+/* One Touch Play Feature */
	42	+static inline void cec_msg_active_source(struct cec_msg *msg, __u16 phys_addr)
	43	+{
	44	+ msg->len = 4;
	45	+ msg->msg[0] \|= 0xf; /* broadcast */
	46	+ msg->msg[1] = CEC_MSG_ACTIVE_SOURCE;
	47	+ msg->msg[2] = phys_addr >> 8;
	48	+ msg->msg[3] = phys_addr & 0xff;
	49	+}
	50	+
	51	+static inline void cec_ops_active_source(const struct cec_msg *msg,
	52	+ __u16 *phys_addr)
	53	+{
	54	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	55	+}
	56	+
	57	+static inline void cec_msg_image_view_on(struct cec_msg *msg)
	58	+{
	59	+ msg->len = 2;
	60	+ msg->msg[1] = CEC_MSG_IMAGE_VIEW_ON;
	61	+}
	62	+
	63	+static inline void cec_msg_text_view_on(struct cec_msg *msg)
	64	+{
	65	+ msg->len = 2;
	66	+ msg->msg[1] = CEC_MSG_TEXT_VIEW_ON;
	67	+}
	68	+
	69	+
	70	+/* Routing Control Feature */
	71	+static inline void cec_msg_inactive_source(struct cec_msg *msg,
	72	+ __u16 phys_addr)
	73	+{
	74	+ msg->len = 4;
	75	+ msg->msg[1] = CEC_MSG_INACTIVE_SOURCE;
	76	+ msg->msg[2] = phys_addr >> 8;
	77	+ msg->msg[3] = phys_addr & 0xff;
	78	+}
	79	+
	80	+static inline void cec_ops_inactive_source(const struct cec_msg *msg,
	81	+ __u16 *phys_addr)
	82	+{
	83	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	84	+}
	85	+
	86	+static inline void cec_msg_request_active_source(struct cec_msg *msg,
	87	+ int reply)
	88	+{
	89	+ msg->len = 2;
	90	+ msg->msg[0] \|= 0xf; /* broadcast */
	91	+ msg->msg[1] = CEC_MSG_REQUEST_ACTIVE_SOURCE;
	92	+ msg->reply = reply ? CEC_MSG_ACTIVE_SOURCE : 0;
	93	+}
	94	+
	95	+static inline void cec_msg_routing_information(struct cec_msg *msg,
	96	+ __u16 phys_addr)
	97	+{
	98	+ msg->len = 4;
	99	+ msg->msg[0] \|= 0xf; /* broadcast */
	100	+ msg->msg[1] = CEC_MSG_ROUTING_INFORMATION;
	101	+ msg->msg[2] = phys_addr >> 8;
	102	+ msg->msg[3] = phys_addr & 0xff;
	103	+}
	104	+
	105	+static inline void cec_ops_routing_information(const struct cec_msg *msg,
	106	+ __u16 *phys_addr)
	107	+{
	108	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	109	+}
	110	+
	111	+static inline void cec_msg_routing_change(struct cec_msg *msg,
	112	+ int reply,
	113	+ __u16 orig_phys_addr,
	114	+ __u16 new_phys_addr)
	115	+{
	116	+ msg->len = 6;
	117	+ msg->msg[0] \|= 0xf; /* broadcast */
	118	+ msg->msg[1] = CEC_MSG_ROUTING_CHANGE;
	119	+ msg->msg[2] = orig_phys_addr >> 8;
	120	+ msg->msg[3] = orig_phys_addr & 0xff;
	121	+ msg->msg[4] = new_phys_addr >> 8;
	122	+ msg->msg[5] = new_phys_addr & 0xff;
	123	+ msg->reply = reply ? CEC_MSG_ROUTING_INFORMATION : 0;
	124	+}
	125	+
	126	+static inline void cec_ops_routing_change(const struct cec_msg *msg,
	127	+ __u16 *orig_phys_addr,
	128	+ __u16 *new_phys_addr)
	129	+{
	130	+ *orig_phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	131	+ *new_phys_addr = (msg->msg[4] << 8) \| msg->msg[5];
	132	+}
	133	+
	134	+static inline void cec_msg_set_stream_path(struct cec_msg *msg, __u16 phys_addr)
	135	+{
	136	+ msg->len = 4;
	137	+ msg->msg[0] \|= 0xf; /* broadcast */
	138	+ msg->msg[1] = CEC_MSG_SET_STREAM_PATH;
	139	+ msg->msg[2] = phys_addr >> 8;
	140	+ msg->msg[3] = phys_addr & 0xff;
	141	+}
	142	+
	143	+static inline void cec_ops_set_stream_path(const struct cec_msg *msg,
	144	+ __u16 *phys_addr)
	145	+{
	146	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	147	+}
	148	+
	149	+
	150	+/* Standby Feature */
	151	+static inline void cec_msg_standby(struct cec_msg *msg)
	152	+{
	153	+ msg->len = 2;
	154	+ msg->msg[1] = CEC_MSG_STANDBY;
	155	+}
	156	+
	157	+
	158	+/* One Touch Record Feature */
	159	+static inline void cec_msg_record_off(struct cec_msg *msg, int reply)
	160	+{
	161	+ msg->len = 2;
	162	+ msg->msg[1] = CEC_MSG_RECORD_OFF;
	163	+ msg->reply = reply ? CEC_MSG_RECORD_STATUS : 0;
	164	+}
	165	+
	166	+struct cec_op_arib_data {
	167	+ __u16 transport_id;
	168	+ __u16 service_id;
	169	+ __u16 orig_network_id;
	170	+};
	171	+
	172	+struct cec_op_atsc_data {
	173	+ __u16 transport_id;
	174	+ __u16 program_number;
	175	+};
	176	+
	177	+struct cec_op_dvb_data {
	178	+ __u16 transport_id;
	179	+ __u16 service_id;
	180	+ __u16 orig_network_id;
	181	+};
	182	+
	183	+struct cec_op_channel_data {
	184	+ __u8 channel_number_fmt;
	185	+ __u16 major;
	186	+ __u16 minor;
	187	+};
	188	+
	189	+struct cec_op_digital_service_id {
	190	+ __u8 service_id_method;
	191	+ __u8 dig_bcast_system;
	192	+ union {
	193	+ struct cec_op_arib_data arib;
	194	+ struct cec_op_atsc_data atsc;
	195	+ struct cec_op_dvb_data dvb;
	196	+ struct cec_op_channel_data channel;
	197	+ };
	198	+};
	199	+
	200	+struct cec_op_record_src {
	201	+ __u8 type;
	202	+ union {
	203	+ struct cec_op_digital_service_id digital;
	204	+ struct {
	205	+ __u8 ana_bcast_type;
	206	+ __u16 ana_freq;
	207	+ __u8 bcast_system;
	208	+ } analog;
	209	+ struct {
	210	+ __u8 plug;
	211	+ } ext_plug;
	212	+ struct {
	213	+ __u16 phys_addr;
	214	+ } ext_phys_addr;
	215	+ };
	216	+};
	217	+
	218	+static inline void cec_set_digital_service_id(__u8 *msg,
	219	+ const struct cec_op_digital_service_id *digital)
	220	+{
	221	+ *msg++ = (digital->service_id_method << 7) \| digital->dig_bcast_system;
	222	+ if (digital->service_id_method == CEC_OP_SERVICE_ID_METHOD_BY_CHANNEL) {
	223	+ *msg++ = (digital->channel.channel_number_fmt << 2) \|
	224	+ (digital->channel.major >> 8);
	225	+ *msg++ = digital->channel.major & 0xff;
	226	+ *msg++ = digital->channel.minor >> 8;
	227	+ *msg++ = digital->channel.minor & 0xff;
	228	+ *msg++ = 0;
	229	+ *msg++ = 0;
	230	+ return;
	231	+ }
	232	+ switch (digital->dig_bcast_system) {
	233	+ case CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ATSC_GEN:
	234	+ case CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ATSC_CABLE:
	235	+ case CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ATSC_SAT:
	236	+ case CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ATSC_T:
	237	+ *msg++ = digital->atsc.transport_id >> 8;
	238	+ *msg++ = digital->atsc.transport_id & 0xff;
	239	+ *msg++ = digital->atsc.program_number >> 8;
	240	+ *msg++ = digital->atsc.program_number & 0xff;
	241	+ *msg++ = 0;
	242	+ *msg++ = 0;
	243	+ break;
	244	+ default:
	245	+ *msg++ = digital->dvb.transport_id >> 8;
	246	+ *msg++ = digital->dvb.transport_id & 0xff;
	247	+ *msg++ = digital->dvb.service_id >> 8;
	248	+ *msg++ = digital->dvb.service_id & 0xff;
	249	+ *msg++ = digital->dvb.orig_network_id >> 8;
	250	+ *msg++ = digital->dvb.orig_network_id & 0xff;
	251	+ break;
	252	+ }
	253	+}
	254	+
	255	+static inline void cec_get_digital_service_id(const __u8 *msg,
	256	+ struct cec_op_digital_service_id *digital)
	257	+{
	258	+ digital->service_id_method = msg[0] >> 7;
	259	+ digital->dig_bcast_system = msg[0] & 0x7f;
	260	+ if (digital->service_id_method == CEC_OP_SERVICE_ID_METHOD_BY_CHANNEL) {
	261	+ digital->channel.channel_number_fmt = msg[1] >> 2;
	262	+ digital->channel.major = ((msg[1] & 3) << 6) \| msg[2];
	263	+ digital->channel.minor = (msg[3] << 8) \| msg[4];
	264	+ return;
	265	+ }
	266	+ digital->dvb.transport_id = (msg[1] << 8) \| msg[2];
	267	+ digital->dvb.service_id = (msg[3] << 8) \| msg[4];
	268	+ digital->dvb.orig_network_id = (msg[5] << 8) \| msg[6];
	269	+}
	270	+
	271	+static inline void cec_msg_record_on_own(struct cec_msg *msg)
	272	+{
	273	+ msg->len = 3;
	274	+ msg->msg[1] = CEC_MSG_RECORD_ON;
	275	+ msg->msg[2] = CEC_OP_RECORD_SRC_OWN;
	276	+}
	277	+
	278	+static inline void cec_msg_record_on_digital(struct cec_msg *msg,
	279	+ const struct cec_op_digital_service_id *digital)
	280	+{
	281	+ msg->len = 10;
	282	+ msg->msg[1] = CEC_MSG_RECORD_ON;
	283	+ msg->msg[2] = CEC_OP_RECORD_SRC_DIGITAL;
	284	+ cec_set_digital_service_id(msg->msg + 3, digital);
	285	+}
	286	+
	287	+static inline void cec_msg_record_on_analog(struct cec_msg *msg,
	288	+ __u8 ana_bcast_type,
	289	+ __u16 ana_freq,
	290	+ __u8 bcast_system)
	291	+{
	292	+ msg->len = 7;
	293	+ msg->msg[1] = CEC_MSG_RECORD_ON;
	294	+ msg->msg[2] = CEC_OP_RECORD_SRC_ANALOG;
	295	+ msg->msg[3] = ana_bcast_type;
	296	+ msg->msg[4] = ana_freq >> 8;
	297	+ msg->msg[5] = ana_freq & 0xff;
	298	+ msg->msg[6] = bcast_system;
	299	+}
	300	+
	301	+static inline void cec_msg_record_on_plug(struct cec_msg *msg,
	302	+ __u8 plug)
	303	+{
	304	+ msg->len = 4;
	305	+ msg->msg[1] = CEC_MSG_RECORD_ON;
	306	+ msg->msg[2] = CEC_OP_RECORD_SRC_EXT_PLUG;
	307	+ msg->msg[3] = plug;
	308	+}
	309	+
	310	+static inline void cec_msg_record_on_phys_addr(struct cec_msg *msg,
	311	+ __u16 phys_addr)
	312	+{
	313	+ msg->len = 5;
	314	+ msg->msg[1] = CEC_MSG_RECORD_ON;
	315	+ msg->msg[2] = CEC_OP_RECORD_SRC_EXT_PHYS_ADDR;
	316	+ msg->msg[3] = phys_addr >> 8;
	317	+ msg->msg[4] = phys_addr & 0xff;
	318	+}
	319	+
	320	+static inline void cec_msg_record_on(struct cec_msg *msg,
	321	+ int reply,
	322	+ const struct cec_op_record_src *rec_src)
	323	+{
	324	+ switch (rec_src->type) {
	325	+ case CEC_OP_RECORD_SRC_OWN:
	326	+ cec_msg_record_on_own(msg);
	327	+ break;
	328	+ case CEC_OP_RECORD_SRC_DIGITAL:
	329	+ cec_msg_record_on_digital(msg, &rec_src->digital);
	330	+ break;
	331	+ case CEC_OP_RECORD_SRC_ANALOG:
	332	+ cec_msg_record_on_analog(msg,
	333	+ rec_src->analog.ana_bcast_type,
	334	+ rec_src->analog.ana_freq,
	335	+ rec_src->analog.bcast_system);
	336	+ break;
	337	+ case CEC_OP_RECORD_SRC_EXT_PLUG:
	338	+ cec_msg_record_on_plug(msg, rec_src->ext_plug.plug);
	339	+ break;
	340	+ case CEC_OP_RECORD_SRC_EXT_PHYS_ADDR:
	341	+ cec_msg_record_on_phys_addr(msg,
	342	+ rec_src->ext_phys_addr.phys_addr);
	343	+ break;
	344	+ }
	345	+ msg->reply = reply ? CEC_MSG_RECORD_STATUS : 0;
	346	+}
	347	+
	348	+static inline void cec_ops_record_on(const struct cec_msg *msg,
	349	+ struct cec_op_record_src *rec_src)
	350	+{
	351	+ rec_src->type = msg->msg[2];
	352	+ switch (rec_src->type) {
	353	+ case CEC_OP_RECORD_SRC_OWN:
	354	+ break;
	355	+ case CEC_OP_RECORD_SRC_DIGITAL:
	356	+ cec_get_digital_service_id(msg->msg + 3, &rec_src->digital);
	357	+ break;
	358	+ case CEC_OP_RECORD_SRC_ANALOG:
	359	+ rec_src->analog.ana_bcast_type = msg->msg[3];
	360	+ rec_src->analog.ana_freq =
	361	+ (msg->msg[4] << 8) \| msg->msg[5];
	362	+ rec_src->analog.bcast_system = msg->msg[6];
	363	+ break;
	364	+ case CEC_OP_RECORD_SRC_EXT_PLUG:
	365	+ rec_src->ext_plug.plug = msg->msg[3];
	366	+ break;
	367	+ case CEC_OP_RECORD_SRC_EXT_PHYS_ADDR:
	368	+ rec_src->ext_phys_addr.phys_addr =
	369	+ (msg->msg[3] << 8) \| msg->msg[4];
	370	+ break;
	371	+ }
	372	+}
	373	+
	374	+static inline void cec_msg_record_status(struct cec_msg *msg, __u8 rec_status)
	375	+{
	376	+ msg->len = 3;
	377	+ msg->msg[1] = CEC_MSG_RECORD_STATUS;
	378	+ msg->msg[2] = rec_status;
	379	+}
	380	+
	381	+static inline void cec_ops_record_status(const struct cec_msg *msg,
	382	+ __u8 *rec_status)
	383	+{
	384	+ *rec_status = msg->msg[2];
	385	+}
	386	+
	387	+static inline void cec_msg_record_tv_screen(struct cec_msg *msg,
	388	+ int reply)
	389	+{
	390	+ msg->len = 2;
	391	+ msg->msg[1] = CEC_MSG_RECORD_TV_SCREEN;
	392	+ msg->reply = reply ? CEC_MSG_RECORD_ON : 0;
	393	+}
	394	+
	395	+
	396	+/* Timer Programming Feature */
	397	+static inline void cec_msg_timer_status(struct cec_msg *msg,
	398	+ __u8 timer_overlap_warning,
	399	+ __u8 media_info,
	400	+ __u8 prog_info,
	401	+ __u8 prog_error,
	402	+ __u8 duration_hr,
	403	+ __u8 duration_min)
	404	+{
	405	+ msg->len = 3;
	406	+ msg->msg[1] = CEC_MSG_TIMER_STATUS;
	407	+ msg->msg[2] = (timer_overlap_warning << 7) \|
	408	+ (media_info << 5) \|
	409	+ (prog_info ? 0x10 : 0) \|
	410	+ (prog_info ? prog_info : prog_error);
	411	+ if (prog_info == CEC_OP_PROG_INFO_NOT_ENOUGH_SPACE \|\|
	412	+ prog_info == CEC_OP_PROG_INFO_MIGHT_NOT_BE_ENOUGH_SPACE \|\|
	413	+ prog_error == CEC_OP_PROG_ERROR_DUPLICATE) {
	414	+ msg->len += 2;
	415	+ msg->msg[3] = ((duration_hr / 10) << 4) \| (duration_hr % 10);
	416	+ msg->msg[4] = ((duration_min / 10) << 4) \| (duration_min % 10);
	417	+ }
	418	+}
	419	+
	420	+static inline void cec_ops_timer_status(const struct cec_msg *msg,
	421	+ __u8 *timer_overlap_warning,
	422	+ __u8 *media_info,
	423	+ __u8 *prog_info,
	424	+ __u8 *prog_error,
	425	+ __u8 *duration_hr,
	426	+ __u8 *duration_min)
	427	+{
	428	+ *timer_overlap_warning = msg->msg[2] >> 7;
	429	+ *media_info = (msg->msg[2] >> 5) & 3;
	430	+ if (msg->msg[2] & 0x10) {
	431	+ *prog_info = msg->msg[2] & 0xf;
	432	+ *prog_error = 0;
	433	+ } else {
	434	+ *prog_info = 0;
	435	+ *prog_error = msg->msg[2] & 0xf;
	436	+ }
	437	+ if (*prog_info == CEC_OP_PROG_INFO_NOT_ENOUGH_SPACE \|\|
	438	+ *prog_info == CEC_OP_PROG_INFO_MIGHT_NOT_BE_ENOUGH_SPACE \|\|
	439	+ *prog_error == CEC_OP_PROG_ERROR_DUPLICATE) {
	440	+ duration_hr = (msg->msg[3] >> 4) 10 + (msg->msg[3] & 0xf);
	441	+ duration_min = (msg->msg[4] >> 4) 10 + (msg->msg[4] & 0xf);
	442	+ } else {
	443	+ duration_hr = duration_min = 0;
	444	+ }
	445	+}
	446	+
	447	+static inline void cec_msg_timer_cleared_status(struct cec_msg *msg,
	448	+ __u8 timer_cleared_status)
	449	+{
	450	+ msg->len = 3;
	451	+ msg->msg[1] = CEC_MSG_TIMER_CLEARED_STATUS;
	452	+ msg->msg[2] = timer_cleared_status;
	453	+}
	454	+
	455	+static inline void cec_ops_timer_cleared_status(const struct cec_msg *msg,
	456	+ __u8 *timer_cleared_status)
	457	+{
	458	+ *timer_cleared_status = msg->msg[2];
	459	+}
	460	+
	461	+static inline void cec_msg_clear_analogue_timer(struct cec_msg *msg,
	462	+ int reply,
	463	+ __u8 day,
	464	+ __u8 month,
	465	+ __u8 start_hr,
	466	+ __u8 start_min,
	467	+ __u8 duration_hr,
	468	+ __u8 duration_min,
	469	+ __u8 recording_seq,
	470	+ __u8 ana_bcast_type,
	471	+ __u16 ana_freq,
	472	+ __u8 bcast_system)
	473	+{
	474	+ msg->len = 13;
	475	+ msg->msg[1] = CEC_MSG_CLEAR_ANALOGUE_TIMER;
	476	+ msg->msg[2] = day;
	477	+ msg->msg[3] = month;
	478	+ /* Hours and minutes are in BCD format */
	479	+ msg->msg[4] = ((start_hr / 10) << 4) \| (start_hr % 10);
	480	+ msg->msg[5] = ((start_min / 10) << 4) \| (start_min % 10);
	481	+ msg->msg[6] = ((duration_hr / 10) << 4) \| (duration_hr % 10);
	482	+ msg->msg[7] = ((duration_min / 10) << 4) \| (duration_min % 10);
	483	+ msg->msg[8] = recording_seq;
	484	+ msg->msg[9] = ana_bcast_type;
	485	+ msg->msg[10] = ana_freq >> 8;
	486	+ msg->msg[11] = ana_freq & 0xff;
	487	+ msg->msg[12] = bcast_system;
	488	+ msg->reply = reply ? CEC_MSG_TIMER_CLEARED_STATUS : 0;
	489	+}
	490	+
	491	+static inline void cec_ops_clear_analogue_timer(const struct cec_msg *msg,
	492	+ __u8 *day,
	493	+ __u8 *month,
	494	+ __u8 *start_hr,
	495	+ __u8 *start_min,
	496	+ __u8 *duration_hr,
	497	+ __u8 *duration_min,
	498	+ __u8 *recording_seq,
	499	+ __u8 *ana_bcast_type,
	500	+ __u16 *ana_freq,
	501	+ __u8 *bcast_system)
	502	+{
	503	+ *day = msg->msg[2];
	504	+ *month = msg->msg[3];
	505	+ /* Hours and minutes are in BCD format */
	506	+ start_hr = (msg->msg[4] >> 4) 10 + (msg->msg[4] & 0xf);
	507	+ start_min = (msg->msg[5] >> 4) 10 + (msg->msg[5] & 0xf);
	508	+ duration_hr = (msg->msg[6] >> 4) 10 + (msg->msg[6] & 0xf);
	509	+ duration_min = (msg->msg[7] >> 4) 10 + (msg->msg[7] & 0xf);
	510	+ *recording_seq = msg->msg[8];
	511	+ *ana_bcast_type = msg->msg[9];
	512	+ *ana_freq = (msg->msg[10] << 8) \| msg->msg[11];
	513	+ *bcast_system = msg->msg[12];
	514	+}
	515	+
	516	+static inline void cec_msg_clear_digital_timer(struct cec_msg *msg,
	517	+ int reply,
	518	+ __u8 day,
	519	+ __u8 month,
	520	+ __u8 start_hr,
	521	+ __u8 start_min,
	522	+ __u8 duration_hr,
	523	+ __u8 duration_min,
	524	+ __u8 recording_seq,
	525	+ const struct cec_op_digital_service_id *digital)
	526	+{
	527	+ msg->len = 16;
	528	+ msg->reply = reply ? CEC_MSG_TIMER_CLEARED_STATUS : 0;
	529	+ msg->msg[1] = CEC_MSG_CLEAR_DIGITAL_TIMER;
	530	+ msg->msg[2] = day;
	531	+ msg->msg[3] = month;
	532	+ /* Hours and minutes are in BCD format */
	533	+ msg->msg[4] = ((start_hr / 10) << 4) \| (start_hr % 10);
	534	+ msg->msg[5] = ((start_min / 10) << 4) \| (start_min % 10);
	535	+ msg->msg[6] = ((duration_hr / 10) << 4) \| (duration_hr % 10);
	536	+ msg->msg[7] = ((duration_min / 10) << 4) \| (duration_min % 10);
	537	+ msg->msg[8] = recording_seq;
	538	+ cec_set_digital_service_id(msg->msg + 9, digital);
	539	+}
	540	+
	541	+static inline void cec_ops_clear_digital_timer(const struct cec_msg *msg,
	542	+ __u8 *day,
	543	+ __u8 *month,
	544	+ __u8 *start_hr,
	545	+ __u8 *start_min,
	546	+ __u8 *duration_hr,
	547	+ __u8 *duration_min,
	548	+ __u8 *recording_seq,
	549	+ struct cec_op_digital_service_id *digital)
	550	+{
	551	+ *day = msg->msg[2];
	552	+ *month = msg->msg[3];
	553	+ /* Hours and minutes are in BCD format */
	554	+ start_hr = (msg->msg[4] >> 4) 10 + (msg->msg[4] & 0xf);
	555	+ start_min = (msg->msg[5] >> 4) 10 + (msg->msg[5] & 0xf);
	556	+ duration_hr = (msg->msg[6] >> 4) 10 + (msg->msg[6] & 0xf);
	557	+ duration_min = (msg->msg[7] >> 4) 10 + (msg->msg[7] & 0xf);
	558	+ *recording_seq = msg->msg[8];
	559	+ cec_get_digital_service_id(msg->msg + 9, digital);
	560	+}
	561	+
	562	+static inline void cec_msg_clear_ext_timer(struct cec_msg *msg,
	563	+ int reply,
	564	+ __u8 day,
	565	+ __u8 month,
	566	+ __u8 start_hr,
	567	+ __u8 start_min,
	568	+ __u8 duration_hr,
	569	+ __u8 duration_min,
	570	+ __u8 recording_seq,
	571	+ __u8 ext_src_spec,
	572	+ __u8 plug,
	573	+ __u16 phys_addr)
	574	+{
	575	+ msg->len = 13;
	576	+ msg->msg[1] = CEC_MSG_CLEAR_EXT_TIMER;
	577	+ msg->msg[2] = day;
	578	+ msg->msg[3] = month;
	579	+ /* Hours and minutes are in BCD format */
	580	+ msg->msg[4] = ((start_hr / 10) << 4) \| (start_hr % 10);
	581	+ msg->msg[5] = ((start_min / 10) << 4) \| (start_min % 10);
	582	+ msg->msg[6] = ((duration_hr / 10) << 4) \| (duration_hr % 10);
	583	+ msg->msg[7] = ((duration_min / 10) << 4) \| (duration_min % 10);
	584	+ msg->msg[8] = recording_seq;
	585	+ msg->msg[9] = ext_src_spec;
	586	+ msg->msg[10] = plug;
	587	+ msg->msg[11] = phys_addr >> 8;
	588	+ msg->msg[12] = phys_addr & 0xff;
	589	+ msg->reply = reply ? CEC_MSG_TIMER_CLEARED_STATUS : 0;
	590	+}
	591	+
	592	+static inline void cec_ops_clear_ext_timer(const struct cec_msg *msg,
	593	+ __u8 *day,
	594	+ __u8 *month,
	595	+ __u8 *start_hr,
	596	+ __u8 *start_min,
	597	+ __u8 *duration_hr,
	598	+ __u8 *duration_min,
	599	+ __u8 *recording_seq,
	600	+ __u8 *ext_src_spec,
	601	+ __u8 *plug,
	602	+ __u16 *phys_addr)
	603	+{
	604	+ *day = msg->msg[2];
	605	+ *month = msg->msg[3];
	606	+ /* Hours and minutes are in BCD format */
	607	+ start_hr = (msg->msg[4] >> 4) 10 + (msg->msg[4] & 0xf);
	608	+ start_min = (msg->msg[5] >> 4) 10 + (msg->msg[5] & 0xf);
	609	+ duration_hr = (msg->msg[6] >> 4) 10 + (msg->msg[6] & 0xf);
	610	+ duration_min = (msg->msg[7] >> 4) 10 + (msg->msg[7] & 0xf);
	611	+ *recording_seq = msg->msg[8];
	612	+ *ext_src_spec = msg->msg[9];
	613	+ *plug = msg->msg[10];
	614	+ *phys_addr = (msg->msg[11] << 8) \| msg->msg[12];
	615	+}
	616	+
	617	+static inline void cec_msg_set_analogue_timer(struct cec_msg *msg,
	618	+ int reply,
	619	+ __u8 day,
	620	+ __u8 month,
	621	+ __u8 start_hr,
	622	+ __u8 start_min,
	623	+ __u8 duration_hr,
	624	+ __u8 duration_min,
	625	+ __u8 recording_seq,
	626	+ __u8 ana_bcast_type,
	627	+ __u16 ana_freq,
	628	+ __u8 bcast_system)
	629	+{
	630	+ msg->len = 13;
	631	+ msg->msg[1] = CEC_MSG_SET_ANALOGUE_TIMER;
	632	+ msg->msg[2] = day;
	633	+ msg->msg[3] = month;
	634	+ /* Hours and minutes are in BCD format */
	635	+ msg->msg[4] = ((start_hr / 10) << 4) \| (start_hr % 10);
	636	+ msg->msg[5] = ((start_min / 10) << 4) \| (start_min % 10);
	637	+ msg->msg[6] = ((duration_hr / 10) << 4) \| (duration_hr % 10);
	638	+ msg->msg[7] = ((duration_min / 10) << 4) \| (duration_min % 10);
	639	+ msg->msg[8] = recording_seq;
	640	+ msg->msg[9] = ana_bcast_type;
	641	+ msg->msg[10] = ana_freq >> 8;
	642	+ msg->msg[11] = ana_freq & 0xff;
	643	+ msg->msg[12] = bcast_system;
	644	+ msg->reply = reply ? CEC_MSG_TIMER_STATUS : 0;
	645	+}
	646	+
	647	+static inline void cec_ops_set_analogue_timer(const struct cec_msg *msg,
	648	+ __u8 *day,
	649	+ __u8 *month,
	650	+ __u8 *start_hr,
	651	+ __u8 *start_min,
	652	+ __u8 *duration_hr,
	653	+ __u8 *duration_min,
	654	+ __u8 *recording_seq,
	655	+ __u8 *ana_bcast_type,
	656	+ __u16 *ana_freq,
	657	+ __u8 *bcast_system)
	658	+{
	659	+ *day = msg->msg[2];
	660	+ *month = msg->msg[3];
	661	+ /* Hours and minutes are in BCD format */
	662	+ start_hr = (msg->msg[4] >> 4) 10 + (msg->msg[4] & 0xf);
	663	+ start_min = (msg->msg[5] >> 4) 10 + (msg->msg[5] & 0xf);
	664	+ duration_hr = (msg->msg[6] >> 4) 10 + (msg->msg[6] & 0xf);
	665	+ duration_min = (msg->msg[7] >> 4) 10 + (msg->msg[7] & 0xf);
	666	+ *recording_seq = msg->msg[8];
	667	+ *ana_bcast_type = msg->msg[9];
	668	+ *ana_freq = (msg->msg[10] << 8) \| msg->msg[11];
	669	+ *bcast_system = msg->msg[12];
	670	+}
	671	+
	672	+static inline void cec_msg_set_digital_timer(struct cec_msg *msg,
	673	+ int reply,
	674	+ __u8 day,
	675	+ __u8 month,
	676	+ __u8 start_hr,
	677	+ __u8 start_min,
	678	+ __u8 duration_hr,
	679	+ __u8 duration_min,
	680	+ __u8 recording_seq,
	681	+ const struct cec_op_digital_service_id *digital)
	682	+{
	683	+ msg->len = 16;
	684	+ msg->reply = reply ? CEC_MSG_TIMER_STATUS : 0;
	685	+ msg->msg[1] = CEC_MSG_SET_DIGITAL_TIMER;
	686	+ msg->msg[2] = day;
	687	+ msg->msg[3] = month;
	688	+ /* Hours and minutes are in BCD format */
	689	+ msg->msg[4] = ((start_hr / 10) << 4) \| (start_hr % 10);
	690	+ msg->msg[5] = ((start_min / 10) << 4) \| (start_min % 10);
	691	+ msg->msg[6] = ((duration_hr / 10) << 4) \| (duration_hr % 10);
	692	+ msg->msg[7] = ((duration_min / 10) << 4) \| (duration_min % 10);
	693	+ msg->msg[8] = recording_seq;
	694	+ cec_set_digital_service_id(msg->msg + 9, digital);
	695	+}
	696	+
	697	+static inline void cec_ops_set_digital_timer(const struct cec_msg *msg,
	698	+ __u8 *day,
	699	+ __u8 *month,
	700	+ __u8 *start_hr,
	701	+ __u8 *start_min,
	702	+ __u8 *duration_hr,
	703	+ __u8 *duration_min,
	704	+ __u8 *recording_seq,
	705	+ struct cec_op_digital_service_id *digital)
	706	+{
	707	+ *day = msg->msg[2];
	708	+ *month = msg->msg[3];
	709	+ /* Hours and minutes are in BCD format */
	710	+ start_hr = (msg->msg[4] >> 4) 10 + (msg->msg[4] & 0xf);
	711	+ start_min = (msg->msg[5] >> 4) 10 + (msg->msg[5] & 0xf);
	712	+ duration_hr = (msg->msg[6] >> 4) 10 + (msg->msg[6] & 0xf);
	713	+ duration_min = (msg->msg[7] >> 4) 10 + (msg->msg[7] & 0xf);
	714	+ *recording_seq = msg->msg[8];
	715	+ cec_get_digital_service_id(msg->msg + 9, digital);
	716	+}
	717	+
	718	+static inline void cec_msg_set_ext_timer(struct cec_msg *msg,
	719	+ int reply,
	720	+ __u8 day,
	721	+ __u8 month,
	722	+ __u8 start_hr,
	723	+ __u8 start_min,
	724	+ __u8 duration_hr,
	725	+ __u8 duration_min,
	726	+ __u8 recording_seq,
	727	+ __u8 ext_src_spec,
	728	+ __u8 plug,
	729	+ __u16 phys_addr)
	730	+{
	731	+ msg->len = 13;
	732	+ msg->msg[1] = CEC_MSG_SET_EXT_TIMER;
	733	+ msg->msg[2] = day;
	734	+ msg->msg[3] = month;
	735	+ /* Hours and minutes are in BCD format */
	736	+ msg->msg[4] = ((start_hr / 10) << 4) \| (start_hr % 10);
	737	+ msg->msg[5] = ((start_min / 10) << 4) \| (start_min % 10);
	738	+ msg->msg[6] = ((duration_hr / 10) << 4) \| (duration_hr % 10);
	739	+ msg->msg[7] = ((duration_min / 10) << 4) \| (duration_min % 10);
	740	+ msg->msg[8] = recording_seq;
	741	+ msg->msg[9] = ext_src_spec;
	742	+ msg->msg[10] = plug;
	743	+ msg->msg[11] = phys_addr >> 8;
	744	+ msg->msg[12] = phys_addr & 0xff;
	745	+ msg->reply = reply ? CEC_MSG_TIMER_STATUS : 0;
	746	+}
	747	+
	748	+static inline void cec_ops_set_ext_timer(const struct cec_msg *msg,
	749	+ __u8 *day,
	750	+ __u8 *month,
	751	+ __u8 *start_hr,
	752	+ __u8 *start_min,
	753	+ __u8 *duration_hr,
	754	+ __u8 *duration_min,
	755	+ __u8 *recording_seq,
	756	+ __u8 *ext_src_spec,
	757	+ __u8 *plug,
	758	+ __u16 *phys_addr)
	759	+{
	760	+ *day = msg->msg[2];
	761	+ *month = msg->msg[3];
	762	+ /* Hours and minutes are in BCD format */
	763	+ start_hr = (msg->msg[4] >> 4) 10 + (msg->msg[4] & 0xf);
	764	+ start_min = (msg->msg[5] >> 4) 10 + (msg->msg[5] & 0xf);
	765	+ duration_hr = (msg->msg[6] >> 4) 10 + (msg->msg[6] & 0xf);
	766	+ duration_min = (msg->msg[7] >> 4) 10 + (msg->msg[7] & 0xf);
	767	+ *recording_seq = msg->msg[8];
	768	+ *ext_src_spec = msg->msg[9];
	769	+ *plug = msg->msg[10];
	770	+ *phys_addr = (msg->msg[11] << 8) \| msg->msg[12];
	771	+}
	772	+
	773	+static inline void cec_msg_set_timer_program_title(struct cec_msg *msg,
	774	+ const char *prog_title)
	775	+{
	776	+ unsigned int len = strlen(prog_title);
	777	+
	778	+ if (len > 14)
	779	+ len = 14;
	780	+ msg->len = 2 + len;
	781	+ msg->msg[1] = CEC_MSG_SET_TIMER_PROGRAM_TITLE;
	782	+ memcpy(msg->msg + 2, prog_title, len);
	783	+}
	784	+
	785	+static inline void cec_ops_set_timer_program_title(const struct cec_msg *msg,
	786	+ char *prog_title)
	787	+{
	788	+ unsigned int len = msg->len > 2 ? msg->len - 2 : 0;
	789	+
	790	+ if (len > 14)
	791	+ len = 14;
	792	+ memcpy(prog_title, msg->msg + 2, len);
	793	+ prog_title[len] = '\0';
	794	+}
	795	+
	796	+/* System Information Feature */
	797	+static inline void cec_msg_cec_version(struct cec_msg *msg, __u8 cec_version)
	798	+{
	799	+ msg->len = 3;
	800	+ msg->msg[1] = CEC_MSG_CEC_VERSION;
	801	+ msg->msg[2] = cec_version;
	802	+}
	803	+
	804	+static inline void cec_ops_cec_version(const struct cec_msg *msg,
	805	+ __u8 *cec_version)
	806	+{
	807	+ *cec_version = msg->msg[2];
	808	+}
	809	+
	810	+static inline void cec_msg_get_cec_version(struct cec_msg *msg,
	811	+ int reply)
	812	+{
	813	+ msg->len = 2;
	814	+ msg->msg[1] = CEC_MSG_GET_CEC_VERSION;
	815	+ msg->reply = reply ? CEC_MSG_CEC_VERSION : 0;
	816	+}
	817	+
	818	+static inline void cec_msg_report_physical_addr(struct cec_msg *msg,
	819	+ __u16 phys_addr, __u8 prim_devtype)
	820	+{
	821	+ msg->len = 5;
	822	+ msg->msg[0] \|= 0xf; /* broadcast */
	823	+ msg->msg[1] = CEC_MSG_REPORT_PHYSICAL_ADDR;
	824	+ msg->msg[2] = phys_addr >> 8;
	825	+ msg->msg[3] = phys_addr & 0xff;
	826	+ msg->msg[4] = prim_devtype;
	827	+}
	828	+
	829	+static inline void cec_ops_report_physical_addr(const struct cec_msg *msg,
	830	+ __u16 phys_addr, __u8 prim_devtype)
	831	+{
	832	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	833	+ *prim_devtype = msg->msg[4];
	834	+}
	835	+
	836	+static inline void cec_msg_give_physical_addr(struct cec_msg *msg,
	837	+ int reply)
	838	+{
	839	+ msg->len = 2;
	840	+ msg->msg[1] = CEC_MSG_GIVE_PHYSICAL_ADDR;
	841	+ msg->reply = reply ? CEC_MSG_REPORT_PHYSICAL_ADDR : 0;
	842	+}
	843	+
	844	+static inline void cec_msg_set_menu_language(struct cec_msg *msg,
	845	+ const char *language)
	846	+{
	847	+ msg->len = 5;
	848	+ msg->msg[0] \|= 0xf; /* broadcast */
	849	+ msg->msg[1] = CEC_MSG_SET_MENU_LANGUAGE;
	850	+ memcpy(msg->msg + 2, language, 3);
	851	+}
	852	+
	853	+static inline void cec_ops_set_menu_language(const struct cec_msg *msg,
	854	+ char *language)
	855	+{
	856	+ memcpy(language, msg->msg + 2, 3);
	857	+ language[3] = '\0';
	858	+}
	859	+
	860	+static inline void cec_msg_get_menu_language(struct cec_msg *msg,
	861	+ int reply)
	862	+{
	863	+ msg->len = 2;
	864	+ msg->msg[1] = CEC_MSG_GET_MENU_LANGUAGE;
	865	+ msg->reply = reply ? CEC_MSG_SET_MENU_LANGUAGE : 0;
	866	+}
	867	+
	868	+/*
	869	+ * Assumes a single RC Profile byte and a single Device Features byte,
	870	+ * i.e. no extended features are supported by this helper function.
	871	+ *
	872	+ * As of CEC 2.0 no extended features are defined, should those be added
	873	+ * in the future, then this function needs to be adapted or a new function
	874	+ * should be added.
	875	+ */
	876	+static inline void cec_msg_report_features(struct cec_msg *msg,
	877	+ __u8 cec_version, __u8 all_device_types,
	878	+ __u8 rc_profile, __u8 dev_features)
	879	+{
	880	+ msg->len = 6;
	881	+ msg->msg[0] \|= 0xf; /* broadcast */
	882	+ msg->msg[1] = CEC_MSG_REPORT_FEATURES;
	883	+ msg->msg[2] = cec_version;
	884	+ msg->msg[3] = all_device_types;
	885	+ msg->msg[4] = rc_profile;
	886	+ msg->msg[5] = dev_features;
	887	+}
	888	+
	889	+static inline void cec_ops_report_features(const struct cec_msg *msg,
	890	+ __u8 cec_version, __u8 all_device_types,
	891	+ const __u8 rc_profile, const __u8 dev_features)
	892	+{
	893	+ const __u8 *p = &msg->msg[4];
	894	+
	895	+ *cec_version = msg->msg[2];
	896	+ *all_device_types = msg->msg[3];
	897	+ *rc_profile = p;
	898	+ while (p < &msg->msg[14] && (*p & CEC_OP_FEAT_EXT))
	899	+ p++;
	900	+ if (!(*p & CEC_OP_FEAT_EXT)) {
	901	+ *dev_features = p + 1;
	902	+ while (p < &msg->msg[15] && (*p & CEC_OP_FEAT_EXT))
	903	+ p++;
	904	+ }
	905	+ if (*p & CEC_OP_FEAT_EXT)
	906	+ rc_profile = dev_features = NULL;
	907	+}
	908	+
	909	+static inline void cec_msg_give_features(struct cec_msg *msg,
	910	+ int reply)
	911	+{
	912	+ msg->len = 2;
	913	+ msg->msg[1] = CEC_MSG_GIVE_FEATURES;
	914	+ msg->reply = reply ? CEC_MSG_REPORT_FEATURES : 0;
	915	+}
	916	+
	917	+/* Deck Control Feature */
	918	+static inline void cec_msg_deck_control(struct cec_msg *msg,
	919	+ __u8 deck_control_mode)
	920	+{
	921	+ msg->len = 3;
	922	+ msg->msg[1] = CEC_MSG_DECK_CONTROL;
	923	+ msg->msg[2] = deck_control_mode;
	924	+}
	925	+
	926	+static inline void cec_ops_deck_control(const struct cec_msg *msg,
	927	+ __u8 *deck_control_mode)
	928	+{
	929	+ *deck_control_mode = msg->msg[2];
	930	+}
	931	+
	932	+static inline void cec_msg_deck_status(struct cec_msg *msg,
	933	+ __u8 deck_info)
	934	+{
	935	+ msg->len = 3;
	936	+ msg->msg[1] = CEC_MSG_DECK_STATUS;
	937	+ msg->msg[2] = deck_info;
	938	+}
	939	+
	940	+static inline void cec_ops_deck_status(const struct cec_msg *msg,
	941	+ __u8 *deck_info)
	942	+{
	943	+ *deck_info = msg->msg[2];
	944	+}
	945	+
	946	+static inline void cec_msg_give_deck_status(struct cec_msg *msg,
	947	+ int reply,
	948	+ __u8 status_req)
	949	+{
	950	+ msg->len = 3;
	951	+ msg->msg[1] = CEC_MSG_GIVE_DECK_STATUS;
	952	+ msg->msg[2] = status_req;
	953	+ msg->reply = reply ? CEC_MSG_DECK_STATUS : 0;
	954	+}
	955	+
	956	+static inline void cec_ops_give_deck_status(const struct cec_msg *msg,
	957	+ __u8 *status_req)
	958	+{
	959	+ *status_req = msg->msg[2];
	960	+}
	961	+
	962	+static inline void cec_msg_play(struct cec_msg *msg,
	963	+ __u8 play_mode)
	964	+{
	965	+ msg->len = 3;
	966	+ msg->msg[1] = CEC_MSG_PLAY;
	967	+ msg->msg[2] = play_mode;
	968	+}
	969	+
	970	+static inline void cec_ops_play(const struct cec_msg *msg,
	971	+ __u8 *play_mode)
	972	+{
	973	+ *play_mode = msg->msg[2];
	974	+}
	975	+
	976	+
	977	+/* Tuner Control Feature */
	978	+struct cec_op_tuner_device_info {
	979	+ __u8 rec_flag;
	980	+ __u8 tuner_display_info;
	981	+ __u8 is_analog;
	982	+ union {
	983	+ struct cec_op_digital_service_id digital;
	984	+ struct {
	985	+ __u8 ana_bcast_type;
	986	+ __u16 ana_freq;
	987	+ __u8 bcast_system;
	988	+ } analog;
	989	+ };
	990	+};
	991	+
	992	+static inline void cec_msg_tuner_device_status_analog(struct cec_msg *msg,
	993	+ __u8 rec_flag,
	994	+ __u8 tuner_display_info,
	995	+ __u8 ana_bcast_type,
	996	+ __u16 ana_freq,
	997	+ __u8 bcast_system)
	998	+{
	999	+ msg->len = 7;
	1000	+ msg->msg[1] = CEC_MSG_TUNER_DEVICE_STATUS;
	1001	+ msg->msg[2] = (rec_flag << 7) \| tuner_display_info;
	1002	+ msg->msg[3] = ana_bcast_type;
	1003	+ msg->msg[4] = ana_freq >> 8;
	1004	+ msg->msg[5] = ana_freq & 0xff;
	1005	+ msg->msg[6] = bcast_system;
	1006	+}
	1007	+
	1008	+static inline void cec_msg_tuner_device_status_digital(struct cec_msg *msg,
	1009	+ __u8 rec_flag, __u8 tuner_display_info,
	1010	+ const struct cec_op_digital_service_id *digital)
	1011	+{
	1012	+ msg->len = 10;
	1013	+ msg->msg[1] = CEC_MSG_TUNER_DEVICE_STATUS;
	1014	+ msg->msg[2] = (rec_flag << 7) \| tuner_display_info;
	1015	+ cec_set_digital_service_id(msg->msg + 3, digital);
	1016	+}
	1017	+
	1018	+static inline void cec_msg_tuner_device_status(struct cec_msg *msg,
	1019	+ const struct cec_op_tuner_device_info *tuner_dev_info)
	1020	+{
	1021	+ if (tuner_dev_info->is_analog)
	1022	+ cec_msg_tuner_device_status_analog(msg,
	1023	+ tuner_dev_info->rec_flag,
	1024	+ tuner_dev_info->tuner_display_info,
	1025	+ tuner_dev_info->analog.ana_bcast_type,
	1026	+ tuner_dev_info->analog.ana_freq,
	1027	+ tuner_dev_info->analog.bcast_system);
	1028	+ else
	1029	+ cec_msg_tuner_device_status_digital(msg,
	1030	+ tuner_dev_info->rec_flag,
	1031	+ tuner_dev_info->tuner_display_info,
	1032	+ &tuner_dev_info->digital);
	1033	+}
	1034	+
	1035	+static inline void cec_ops_tuner_device_status(const struct cec_msg *msg,
	1036	+ struct cec_op_tuner_device_info *tuner_dev_info)
	1037	+{
	1038	+ tuner_dev_info->is_analog = msg->len < 10;
	1039	+ tuner_dev_info->rec_flag = msg->msg[2] >> 7;
	1040	+ tuner_dev_info->tuner_display_info = msg->msg[2] & 0x7f;
	1041	+ if (tuner_dev_info->is_analog) {
	1042	+ tuner_dev_info->analog.ana_bcast_type = msg->msg[3];
	1043	+ tuner_dev_info->analog.ana_freq = (msg->msg[4] << 8) \| msg->msg[5];
	1044	+ tuner_dev_info->analog.bcast_system = msg->msg[6];
	1045	+ return;
	1046	+ }
	1047	+ cec_get_digital_service_id(msg->msg + 3, &tuner_dev_info->digital);
	1048	+}
	1049	+
	1050	+static inline void cec_msg_give_tuner_device_status(struct cec_msg *msg,
	1051	+ int reply,
	1052	+ __u8 status_req)
	1053	+{
	1054	+ msg->len = 3;
	1055	+ msg->msg[1] = CEC_MSG_GIVE_TUNER_DEVICE_STATUS;
	1056	+ msg->msg[2] = status_req;
	1057	+ msg->reply = reply ? CEC_MSG_TUNER_DEVICE_STATUS : 0;
	1058	+}
	1059	+
	1060	+static inline void cec_ops_give_tuner_device_status(const struct cec_msg *msg,
	1061	+ __u8 *status_req)
	1062	+{
	1063	+ *status_req = msg->msg[2];
	1064	+}
	1065	+
	1066	+static inline void cec_msg_select_analogue_service(struct cec_msg *msg,
	1067	+ __u8 ana_bcast_type,
	1068	+ __u16 ana_freq,
	1069	+ __u8 bcast_system)
	1070	+{
	1071	+ msg->len = 6;
	1072	+ msg->msg[1] = CEC_MSG_SELECT_ANALOGUE_SERVICE;
	1073	+ msg->msg[2] = ana_bcast_type;
	1074	+ msg->msg[3] = ana_freq >> 8;
	1075	+ msg->msg[4] = ana_freq & 0xff;
	1076	+ msg->msg[5] = bcast_system;
	1077	+}
	1078	+
	1079	+static inline void cec_ops_select_analogue_service(const struct cec_msg *msg,
	1080	+ __u8 *ana_bcast_type,
	1081	+ __u16 *ana_freq,
	1082	+ __u8 *bcast_system)
	1083	+{
	1084	+ *ana_bcast_type = msg->msg[2];
	1085	+ *ana_freq = (msg->msg[3] << 8) \| msg->msg[4];
	1086	+ *bcast_system = msg->msg[5];
	1087	+}
	1088	+
	1089	+static inline void cec_msg_select_digital_service(struct cec_msg *msg,
	1090	+ const struct cec_op_digital_service_id *digital)
	1091	+{
	1092	+ msg->len = 9;
	1093	+ msg->msg[1] = CEC_MSG_SELECT_DIGITAL_SERVICE;
	1094	+ cec_set_digital_service_id(msg->msg + 2, digital);
	1095	+}
	1096	+
	1097	+static inline void cec_ops_select_digital_service(const struct cec_msg *msg,
	1098	+ struct cec_op_digital_service_id *digital)
	1099	+{
	1100	+ cec_get_digital_service_id(msg->msg + 2, digital);
	1101	+}
	1102	+
	1103	+static inline void cec_msg_tuner_step_decrement(struct cec_msg *msg)
	1104	+{
	1105	+ msg->len = 2;
	1106	+ msg->msg[1] = CEC_MSG_TUNER_STEP_DECREMENT;
	1107	+}
	1108	+
	1109	+static inline void cec_msg_tuner_step_increment(struct cec_msg *msg)
	1110	+{
	1111	+ msg->len = 2;
	1112	+ msg->msg[1] = CEC_MSG_TUNER_STEP_INCREMENT;
	1113	+}
	1114	+
	1115	+
	1116	+/* Vendor Specific Commands Feature */
	1117	+static inline void cec_msg_device_vendor_id(struct cec_msg *msg, __u32 vendor_id)
	1118	+{
	1119	+ msg->len = 5;
	1120	+ msg->msg[0] \|= 0xf; /* broadcast */
	1121	+ msg->msg[1] = CEC_MSG_DEVICE_VENDOR_ID;
	1122	+ msg->msg[2] = vendor_id >> 16;
	1123	+ msg->msg[3] = (vendor_id >> 8) & 0xff;
	1124	+ msg->msg[4] = vendor_id & 0xff;
	1125	+}
	1126	+
	1127	+static inline void cec_ops_device_vendor_id(const struct cec_msg *msg,
	1128	+ __u32 *vendor_id)
	1129	+{
	1130	+ *vendor_id = (msg->msg[2] << 16) \| (msg->msg[3] << 8) \| msg->msg[4];
	1131	+}
	1132	+
	1133	+static inline void cec_msg_give_device_vendor_id(struct cec_msg *msg,
	1134	+ int reply)
	1135	+{
	1136	+ msg->len = 2;
	1137	+ msg->msg[1] = CEC_MSG_GIVE_DEVICE_VENDOR_ID;
	1138	+ msg->reply = reply ? CEC_MSG_DEVICE_VENDOR_ID : 0;
	1139	+}
	1140	+
	1141	+static inline void cec_msg_vendor_command(struct cec_msg *msg,
	1142	+ __u8 size, const __u8 *vendor_cmd)
	1143	+{
	1144	+ if (size > 14)
	1145	+ size = 14;
	1146	+ msg->len = 2 + size;
	1147	+ msg->msg[1] = CEC_MSG_VENDOR_COMMAND;
	1148	+ memcpy(msg->msg + 2, vendor_cmd, size);
	1149	+}
	1150	+
	1151	+static inline void cec_ops_vendor_command(const struct cec_msg *msg,
	1152	+ __u8 *size,
	1153	+ const __u8 **vendor_cmd)
	1154	+{
	1155	+ *size = msg->len - 2;
	1156	+
	1157	+ if (*size > 14)
	1158	+ *size = 14;
	1159	+ *vendor_cmd = msg->msg + 2;
	1160	+}
	1161	+
	1162	+static inline void cec_msg_vendor_command_with_id(struct cec_msg *msg,
	1163	+ __u32 vendor_id, __u8 size,
	1164	+ const __u8 *vendor_cmd)
	1165	+{
	1166	+ if (size > 11)
	1167	+ size = 11;
	1168	+ msg->len = 5 + size;
	1169	+ msg->msg[1] = CEC_MSG_VENDOR_COMMAND_WITH_ID;
	1170	+ msg->msg[2] = vendor_id >> 16;
	1171	+ msg->msg[3] = (vendor_id >> 8) & 0xff;
	1172	+ msg->msg[4] = vendor_id & 0xff;
	1173	+ memcpy(msg->msg + 5, vendor_cmd, size);
	1174	+}
	1175	+
	1176	+static inline void cec_ops_vendor_command_with_id(const struct cec_msg *msg,
	1177	+ __u32 vendor_id, __u8 size,
	1178	+ const __u8 **vendor_cmd)
	1179	+{
	1180	+ *size = msg->len - 5;
	1181	+
	1182	+ if (*size > 11)
	1183	+ *size = 11;
	1184	+ *vendor_id = (msg->msg[2] << 16) \| (msg->msg[3] << 8) \| msg->msg[4];
	1185	+ *vendor_cmd = msg->msg + 5;
	1186	+}
	1187	+
	1188	+static inline void cec_msg_vendor_remote_button_down(struct cec_msg *msg,
	1189	+ __u8 size,
	1190	+ const __u8 *rc_code)
	1191	+{
	1192	+ if (size > 14)
	1193	+ size = 14;
	1194	+ msg->len = 2 + size;
	1195	+ msg->msg[1] = CEC_MSG_VENDOR_REMOTE_BUTTON_DOWN;
	1196	+ memcpy(msg->msg + 2, rc_code, size);
	1197	+}
	1198	+
	1199	+static inline void cec_ops_vendor_remote_button_down(const struct cec_msg *msg,
	1200	+ __u8 *size,
	1201	+ const __u8 **rc_code)
	1202	+{
	1203	+ *size = msg->len - 2;
	1204	+
	1205	+ if (*size > 14)
	1206	+ *size = 14;
	1207	+ *rc_code = msg->msg + 2;
	1208	+}
	1209	+
	1210	+static inline void cec_msg_vendor_remote_button_up(struct cec_msg *msg)
	1211	+{
	1212	+ msg->len = 2;
	1213	+ msg->msg[1] = CEC_MSG_VENDOR_REMOTE_BUTTON_UP;
	1214	+}
	1215	+
	1216	+
	1217	+/* OSD Display Feature */
	1218	+static inline void cec_msg_set_osd_string(struct cec_msg *msg,
	1219	+ __u8 disp_ctl,
	1220	+ const char *osd)
	1221	+{
	1222	+ unsigned int len = strlen(osd);
	1223	+
	1224	+ if (len > 13)
	1225	+ len = 13;
	1226	+ msg->len = 3 + len;
	1227	+ msg->msg[1] = CEC_MSG_SET_OSD_STRING;
	1228	+ msg->msg[2] = disp_ctl;
	1229	+ memcpy(msg->msg + 3, osd, len);
	1230	+}
	1231	+
	1232	+static inline void cec_ops_set_osd_string(const struct cec_msg *msg,
	1233	+ __u8 *disp_ctl,
	1234	+ char *osd)
	1235	+{
	1236	+ unsigned int len = msg->len > 3 ? msg->len - 3 : 0;
	1237	+
	1238	+ *disp_ctl = msg->msg[2];
	1239	+ if (len > 13)
	1240	+ len = 13;
	1241	+ memcpy(osd, msg->msg + 3, len);
	1242	+ osd[len] = '\0';
	1243	+}
	1244	+
	1245	+
	1246	+/* Device OSD Transfer Feature */
	1247	+static inline void cec_msg_set_osd_name(struct cec_msg msg, const char name)
	1248	+{
	1249	+ unsigned int len = strlen(name);
	1250	+
	1251	+ if (len > 14)
	1252	+ len = 14;
	1253	+ msg->len = 2 + len;
	1254	+ msg->msg[1] = CEC_MSG_SET_OSD_NAME;
	1255	+ memcpy(msg->msg + 2, name, len);
	1256	+}
	1257	+
	1258	+static inline void cec_ops_set_osd_name(const struct cec_msg *msg,
	1259	+ char *name)
	1260	+{
	1261	+ unsigned int len = msg->len > 2 ? msg->len - 2 : 0;
	1262	+
	1263	+ if (len > 14)
	1264	+ len = 14;
	1265	+ memcpy(name, msg->msg + 2, len);
	1266	+ name[len] = '\0';
	1267	+}
	1268	+
	1269	+static inline void cec_msg_give_osd_name(struct cec_msg *msg,
	1270	+ int reply)
	1271	+{
	1272	+ msg->len = 2;
	1273	+ msg->msg[1] = CEC_MSG_GIVE_OSD_NAME;
	1274	+ msg->reply = reply ? CEC_MSG_SET_OSD_NAME : 0;
	1275	+}
	1276	+
	1277	+
	1278	+/* Device Menu Control Feature */
	1279	+static inline void cec_msg_menu_status(struct cec_msg *msg,
	1280	+ __u8 menu_state)
	1281	+{
	1282	+ msg->len = 3;
	1283	+ msg->msg[1] = CEC_MSG_MENU_STATUS;
	1284	+ msg->msg[2] = menu_state;
	1285	+}
	1286	+
	1287	+static inline void cec_ops_menu_status(const struct cec_msg *msg,
	1288	+ __u8 *menu_state)
	1289	+{
	1290	+ *menu_state = msg->msg[2];
	1291	+}
	1292	+
	1293	+static inline void cec_msg_menu_request(struct cec_msg *msg,
	1294	+ int reply,
	1295	+ __u8 menu_req)
	1296	+{
	1297	+ msg->len = 3;
	1298	+ msg->msg[1] = CEC_MSG_MENU_REQUEST;
	1299	+ msg->msg[2] = menu_req;
	1300	+ msg->reply = reply ? CEC_MSG_MENU_STATUS : 0;
	1301	+}
	1302	+
	1303	+static inline void cec_ops_menu_request(const struct cec_msg *msg,
	1304	+ __u8 *menu_req)
	1305	+{
	1306	+ *menu_req = msg->msg[2];
	1307	+}
	1308	+
	1309	+struct cec_op_ui_command {
	1310	+ __u8 ui_cmd;
	1311	+ __u8 has_opt_arg;
	1312	+ union {
	1313	+ struct cec_op_channel_data channel_identifier;
	1314	+ __u8 ui_broadcast_type;
	1315	+ __u8 ui_sound_presentation_control;
	1316	+ __u8 play_mode;
	1317	+ __u8 ui_function_media;
	1318	+ __u8 ui_function_select_av_input;
	1319	+ __u8 ui_function_select_audio_input;
	1320	+ };
	1321	+};
	1322	+
	1323	+static inline void cec_msg_user_control_pressed(struct cec_msg *msg,
	1324	+ const struct cec_op_ui_command *ui_cmd)
	1325	+{
	1326	+ msg->len = 3;
	1327	+ msg->msg[1] = CEC_MSG_USER_CONTROL_PRESSED;
	1328	+ msg->msg[2] = ui_cmd->ui_cmd;
	1329	+ if (!ui_cmd->has_opt_arg)
	1330	+ return;
	1331	+ switch (ui_cmd->ui_cmd) {
	1332	+ case 0x56:
	1333	+ case 0x57:
	1334	+ case 0x60:
	1335	+ case 0x68:
	1336	+ case 0x69:
	1337	+ case 0x6a:
	1338	+ /* The optional operand is one byte for all these ui commands */
	1339	+ msg->len++;
	1340	+ msg->msg[3] = ui_cmd->play_mode;
	1341	+ break;
	1342	+ case 0x67:
	1343	+ msg->len += 4;
	1344	+ msg->msg[3] = (ui_cmd->channel_identifier.channel_number_fmt << 2) \|
	1345	+ (ui_cmd->channel_identifier.major >> 8);
	1346	+ msg->msg[4] = ui_cmd->channel_identifier.major & 0xff;
	1347	+ msg->msg[5] = ui_cmd->channel_identifier.minor >> 8;
	1348	+ msg->msg[6] = ui_cmd->channel_identifier.minor & 0xff;
	1349	+ break;
	1350	+ }
	1351	+}
	1352	+
	1353	+static inline void cec_ops_user_control_pressed(const struct cec_msg *msg,
	1354	+ struct cec_op_ui_command *ui_cmd)
	1355	+{
	1356	+ ui_cmd->ui_cmd = msg->msg[2];
	1357	+ ui_cmd->has_opt_arg = 0;
	1358	+ if (msg->len == 3)
	1359	+ return;
	1360	+ switch (ui_cmd->ui_cmd) {
	1361	+ case 0x56:
	1362	+ case 0x57:
	1363	+ case 0x60:
	1364	+ case 0x68:
	1365	+ case 0x69:
	1366	+ case 0x6a:
	1367	+ /* The optional operand is one byte for all these ui commands */
	1368	+ ui_cmd->play_mode = msg->msg[3];
	1369	+ ui_cmd->has_opt_arg = 1;
	1370	+ break;
	1371	+ case 0x67:
	1372	+ if (msg->len < 7)
	1373	+ break;
	1374	+ ui_cmd->has_opt_arg = 1;
	1375	+ ui_cmd->channel_identifier.channel_number_fmt = msg->msg[3] >> 2;
	1376	+ ui_cmd->channel_identifier.major = ((msg->msg[3] & 3) << 6) \| msg->msg[4];
	1377	+ ui_cmd->channel_identifier.minor = (msg->msg[5] << 8) \| msg->msg[6];
	1378	+ break;
	1379	+ }
	1380	+}
	1381	+
	1382	+static inline void cec_msg_user_control_released(struct cec_msg *msg)
	1383	+{
	1384	+ msg->len = 2;
	1385	+ msg->msg[1] = CEC_MSG_USER_CONTROL_RELEASED;
	1386	+}
	1387	+
	1388	+/* Remote Control Passthrough Feature */
	1389	+
	1390	+/* Power Status Feature */
	1391	+static inline void cec_msg_report_power_status(struct cec_msg *msg,
	1392	+ __u8 pwr_state)
	1393	+{
	1394	+ msg->len = 3;
	1395	+ msg->msg[1] = CEC_MSG_REPORT_POWER_STATUS;
	1396	+ msg->msg[2] = pwr_state;
	1397	+}
	1398	+
	1399	+static inline void cec_ops_report_power_status(const struct cec_msg *msg,
	1400	+ __u8 *pwr_state)
	1401	+{
	1402	+ *pwr_state = msg->msg[2];
	1403	+}
	1404	+
	1405	+static inline void cec_msg_give_device_power_status(struct cec_msg *msg,
	1406	+ int reply)
	1407	+{
	1408	+ msg->len = 2;
	1409	+ msg->msg[1] = CEC_MSG_GIVE_DEVICE_POWER_STATUS;
	1410	+ msg->reply = reply ? CEC_MSG_REPORT_POWER_STATUS : 0;
	1411	+}
	1412	+
	1413	+/* General Protocol Messages */
	1414	+static inline void cec_msg_feature_abort(struct cec_msg *msg,
	1415	+ __u8 abort_msg, __u8 reason)
	1416	+{
	1417	+ msg->len = 4;
	1418	+ msg->msg[1] = CEC_MSG_FEATURE_ABORT;
	1419	+ msg->msg[2] = abort_msg;
	1420	+ msg->msg[3] = reason;
	1421	+}
	1422	+
	1423	+static inline void cec_ops_feature_abort(const struct cec_msg *msg,
	1424	+ __u8 abort_msg, __u8 reason)
	1425	+{
	1426	+ *abort_msg = msg->msg[2];
	1427	+ *reason = msg->msg[3];
	1428	+}
	1429	+
	1430	+/* This changes the current message into a feature abort message */
	1431	+static inline void cec_msg_reply_feature_abort(struct cec_msg *msg, __u8 reason)
	1432	+{
	1433	+ cec_msg_set_reply_to(msg, msg);
	1434	+ msg->len = 4;
	1435	+ msg->msg[2] = msg->msg[1];
	1436	+ msg->msg[3] = reason;
	1437	+ msg->msg[1] = CEC_MSG_FEATURE_ABORT;
	1438	+}
	1439	+
	1440	+static inline void cec_msg_abort(struct cec_msg *msg)
	1441	+{
	1442	+ msg->len = 2;
	1443	+ msg->msg[1] = CEC_MSG_ABORT;
	1444	+}
	1445	+
	1446	+
	1447	+/* System Audio Control Feature */
	1448	+static inline void cec_msg_report_audio_status(struct cec_msg *msg,
	1449	+ __u8 aud_mute_status,
	1450	+ __u8 aud_vol_status)
	1451	+{
	1452	+ msg->len = 3;
	1453	+ msg->msg[1] = CEC_MSG_REPORT_AUDIO_STATUS;
	1454	+ msg->msg[2] = (aud_mute_status << 7) \| (aud_vol_status & 0x7f);
	1455	+}
	1456	+
	1457	+static inline void cec_ops_report_audio_status(const struct cec_msg *msg,
	1458	+ __u8 *aud_mute_status,
	1459	+ __u8 *aud_vol_status)
	1460	+{
	1461	+ *aud_mute_status = msg->msg[2] >> 7;
	1462	+ *aud_vol_status = msg->msg[2] & 0x7f;
	1463	+}
	1464	+
	1465	+static inline void cec_msg_give_audio_status(struct cec_msg *msg,
	1466	+ int reply)
	1467	+{
	1468	+ msg->len = 2;
	1469	+ msg->msg[1] = CEC_MSG_GIVE_AUDIO_STATUS;
	1470	+ msg->reply = reply ? CEC_MSG_REPORT_AUDIO_STATUS : 0;
	1471	+}
	1472	+
	1473	+static inline void cec_msg_set_system_audio_mode(struct cec_msg *msg,
	1474	+ __u8 sys_aud_status)
	1475	+{
	1476	+ msg->len = 3;
	1477	+ msg->msg[1] = CEC_MSG_SET_SYSTEM_AUDIO_MODE;
	1478	+ msg->msg[2] = sys_aud_status;
	1479	+}
	1480	+
	1481	+static inline void cec_ops_set_system_audio_mode(const struct cec_msg *msg,
	1482	+ __u8 *sys_aud_status)
	1483	+{
	1484	+ *sys_aud_status = msg->msg[2];
	1485	+}
	1486	+
	1487	+static inline void cec_msg_system_audio_mode_request(struct cec_msg *msg,
	1488	+ int reply,
	1489	+ __u16 phys_addr)
	1490	+{
	1491	+ msg->len = phys_addr == 0xffff ? 2 : 4;
	1492	+ msg->msg[1] = CEC_MSG_SYSTEM_AUDIO_MODE_REQUEST;
	1493	+ msg->msg[2] = phys_addr >> 8;
	1494	+ msg->msg[3] = phys_addr & 0xff;
	1495	+ msg->reply = reply ? CEC_MSG_SET_SYSTEM_AUDIO_MODE : 0;
	1496	+
	1497	+}
	1498	+
	1499	+static inline void cec_ops_system_audio_mode_request(const struct cec_msg *msg,
	1500	+ __u16 *phys_addr)
	1501	+{
	1502	+ if (msg->len < 4)
	1503	+ *phys_addr = 0xffff;
	1504	+ else
	1505	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	1506	+}
	1507	+
	1508	+static inline void cec_msg_system_audio_mode_status(struct cec_msg *msg,
	1509	+ __u8 sys_aud_status)
	1510	+{
	1511	+ msg->len = 3;
	1512	+ msg->msg[1] = CEC_MSG_SYSTEM_AUDIO_MODE_STATUS;
	1513	+ msg->msg[2] = sys_aud_status;
	1514	+}
	1515	+
	1516	+static inline void cec_ops_system_audio_mode_status(const struct cec_msg *msg,
	1517	+ __u8 *sys_aud_status)
	1518	+{
	1519	+ *sys_aud_status = msg->msg[2];
	1520	+}
	1521	+
	1522	+static inline void cec_msg_give_system_audio_mode_status(struct cec_msg *msg,
	1523	+ int reply)
	1524	+{
	1525	+ msg->len = 2;
	1526	+ msg->msg[1] = CEC_MSG_GIVE_SYSTEM_AUDIO_MODE_STATUS;
	1527	+ msg->reply = reply ? CEC_MSG_SYSTEM_AUDIO_MODE_STATUS : 0;
	1528	+}
	1529	+
	1530	+static inline void cec_msg_report_short_audio_descriptor(struct cec_msg *msg,
	1531	+ __u8 num_descriptors,
	1532	+ const __u32 *descriptors)
	1533	+{
	1534	+ unsigned int i;
	1535	+
	1536	+ if (num_descriptors > 4)
	1537	+ num_descriptors = 4;
	1538	+ msg->len = 2 + num_descriptors * 3;
	1539	+ msg->msg[1] = CEC_MSG_REPORT_SHORT_AUDIO_DESCRIPTOR;
	1540	+ for (i = 0; i < num_descriptors; i++) {
	1541	+ msg->msg[2 + i * 3] = (descriptors[i] >> 16) & 0xff;
	1542	+ msg->msg[3 + i * 3] = (descriptors[i] >> 8) & 0xff;
	1543	+ msg->msg[4 + i * 3] = descriptors[i] & 0xff;
	1544	+ }
	1545	+}
	1546	+
	1547	+static inline void cec_ops_report_short_audio_descriptor(const struct cec_msg *msg,
	1548	+ __u8 *num_descriptors,
	1549	+ __u32 *descriptors)
	1550	+{
	1551	+ unsigned int i;
	1552	+
	1553	+ *num_descriptors = (msg->len - 2) / 3;
	1554	+ if (*num_descriptors > 4)
	1555	+ *num_descriptors = 4;
	1556	+ for (i = 0; i < *num_descriptors; i++)
	1557	+ descriptors[i] = (msg->msg[2 + i * 3] << 16) \|
	1558	+ (msg->msg[3 + i * 3] << 8) \|
	1559	+ msg->msg[4 + i * 3];
	1560	+}
	1561	+
	1562	+static inline void cec_msg_request_short_audio_descriptor(struct cec_msg *msg,
	1563	+ int reply,
	1564	+ __u8 num_descriptors,
	1565	+ const __u8 *audio_format_id,
	1566	+ const __u8 *audio_format_code)
	1567	+{
	1568	+ unsigned int i;
	1569	+
	1570	+ if (num_descriptors > 4)
	1571	+ num_descriptors = 4;
	1572	+ msg->len = 2 + num_descriptors;
	1573	+ msg->msg[1] = CEC_MSG_REQUEST_SHORT_AUDIO_DESCRIPTOR;
	1574	+ msg->reply = reply ? CEC_MSG_REPORT_SHORT_AUDIO_DESCRIPTOR : 0;
	1575	+ for (i = 0; i < num_descriptors; i++)
	1576	+ msg->msg[2 + i] = (audio_format_id[i] << 6) \|
	1577	+ (audio_format_code[i] & 0x3f);
	1578	+}
	1579	+
	1580	+static inline void cec_ops_request_short_audio_descriptor(const struct cec_msg *msg,
	1581	+ __u8 *num_descriptors,
	1582	+ __u8 *audio_format_id,
	1583	+ __u8 *audio_format_code)
	1584	+{
	1585	+ unsigned int i;
	1586	+
	1587	+ *num_descriptors = msg->len - 2;
	1588	+ if (*num_descriptors > 4)
	1589	+ *num_descriptors = 4;
	1590	+ for (i = 0; i < *num_descriptors; i++) {
	1591	+ audio_format_id[i] = msg->msg[2 + i] >> 6;
	1592	+ audio_format_code[i] = msg->msg[2 + i] & 0x3f;
	1593	+ }
	1594	+}
	1595	+
	1596	+
	1597	+/* Audio Rate Control Feature */
	1598	+static inline void cec_msg_set_audio_rate(struct cec_msg *msg,
	1599	+ __u8 audio_rate)
	1600	+{
	1601	+ msg->len = 3;
	1602	+ msg->msg[1] = CEC_MSG_SET_AUDIO_RATE;
	1603	+ msg->msg[2] = audio_rate;
	1604	+}
	1605	+
	1606	+static inline void cec_ops_set_audio_rate(const struct cec_msg *msg,
	1607	+ __u8 *audio_rate)
	1608	+{
	1609	+ *audio_rate = msg->msg[2];
	1610	+}
	1611	+
	1612	+
	1613	+/* Audio Return Channel Control Feature */
	1614	+static inline void cec_msg_report_arc_initiated(struct cec_msg *msg)
	1615	+{
	1616	+ msg->len = 2;
	1617	+ msg->msg[1] = CEC_MSG_REPORT_ARC_INITIATED;
	1618	+}
	1619	+
	1620	+static inline void cec_msg_initiate_arc(struct cec_msg *msg,
	1621	+ int reply)
	1622	+{
	1623	+ msg->len = 2;
	1624	+ msg->msg[1] = CEC_MSG_INITIATE_ARC;
	1625	+ msg->reply = reply ? CEC_MSG_REPORT_ARC_INITIATED : 0;
	1626	+}
	1627	+
	1628	+static inline void cec_msg_request_arc_initiation(struct cec_msg *msg,
	1629	+ int reply)
	1630	+{
	1631	+ msg->len = 2;
	1632	+ msg->msg[1] = CEC_MSG_REQUEST_ARC_INITIATION;
	1633	+ msg->reply = reply ? CEC_MSG_INITIATE_ARC : 0;
	1634	+}
	1635	+
	1636	+static inline void cec_msg_report_arc_terminated(struct cec_msg *msg)
	1637	+{
	1638	+ msg->len = 2;
	1639	+ msg->msg[1] = CEC_MSG_REPORT_ARC_TERMINATED;
	1640	+}
	1641	+
	1642	+static inline void cec_msg_terminate_arc(struct cec_msg *msg,
	1643	+ int reply)
	1644	+{
	1645	+ msg->len = 2;
	1646	+ msg->msg[1] = CEC_MSG_TERMINATE_ARC;
	1647	+ msg->reply = reply ? CEC_MSG_REPORT_ARC_TERMINATED : 0;
	1648	+}
	1649	+
	1650	+static inline void cec_msg_request_arc_termination(struct cec_msg *msg,
	1651	+ int reply)
	1652	+{
	1653	+ msg->len = 2;
	1654	+ msg->msg[1] = CEC_MSG_REQUEST_ARC_TERMINATION;
	1655	+ msg->reply = reply ? CEC_MSG_TERMINATE_ARC : 0;
	1656	+}
	1657	+
	1658	+
	1659	+/* Dynamic Audio Lipsync Feature */
	1660	+/* Only for CEC 2.0 and up */
	1661	+static inline void cec_msg_report_current_latency(struct cec_msg *msg,
	1662	+ __u16 phys_addr,
	1663	+ __u8 video_latency,
	1664	+ __u8 low_latency_mode,
	1665	+ __u8 audio_out_compensated,
	1666	+ __u8 audio_out_delay)
	1667	+{
	1668	+ msg->len = 7;
	1669	+ msg->msg[0] \|= 0xf; /* broadcast */
	1670	+ msg->msg[1] = CEC_MSG_REPORT_CURRENT_LATENCY;
	1671	+ msg->msg[2] = phys_addr >> 8;
	1672	+ msg->msg[3] = phys_addr & 0xff;
	1673	+ msg->msg[4] = video_latency;
	1674	+ msg->msg[5] = (low_latency_mode << 2) \| audio_out_compensated;
	1675	+ msg->msg[6] = audio_out_delay;
	1676	+}
	1677	+
	1678	+static inline void cec_ops_report_current_latency(const struct cec_msg *msg,
	1679	+ __u16 *phys_addr,
	1680	+ __u8 *video_latency,
	1681	+ __u8 *low_latency_mode,
	1682	+ __u8 *audio_out_compensated,
	1683	+ __u8 *audio_out_delay)
	1684	+{
	1685	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	1686	+ *video_latency = msg->msg[4];
	1687	+ *low_latency_mode = (msg->msg[5] >> 2) & 1;
	1688	+ *audio_out_compensated = msg->msg[5] & 3;
	1689	+ *audio_out_delay = msg->msg[6];
	1690	+}
	1691	+
	1692	+static inline void cec_msg_request_current_latency(struct cec_msg *msg,
	1693	+ int reply,
	1694	+ __u16 phys_addr)
	1695	+{
	1696	+ msg->len = 4;
	1697	+ msg->msg[0] \|= 0xf; /* broadcast */
	1698	+ msg->msg[1] = CEC_MSG_REQUEST_CURRENT_LATENCY;
	1699	+ msg->msg[2] = phys_addr >> 8;
	1700	+ msg->msg[3] = phys_addr & 0xff;
	1701	+ msg->reply = reply ? CEC_MSG_REPORT_CURRENT_LATENCY : 0;
	1702	+}
	1703	+
	1704	+static inline void cec_ops_request_current_latency(const struct cec_msg *msg,
	1705	+ __u16 *phys_addr)
	1706	+{
	1707	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	1708	+}
	1709	+
	1710	+
	1711	+/* Capability Discovery and Control Feature */
	1712	+static inline void cec_msg_cdc_hec_inquire_state(struct cec_msg *msg,
	1713	+ __u16 phys_addr1,
	1714	+ __u16 phys_addr2)
	1715	+{
	1716	+ msg->len = 9;
	1717	+ msg->msg[0] \|= 0xf; /* broadcast */
	1718	+ msg->msg[1] = CEC_MSG_CDC_MESSAGE;
	1719	+ /* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
	1720	+ msg->msg[4] = CEC_MSG_CDC_HEC_INQUIRE_STATE;
	1721	+ msg->msg[5] = phys_addr1 >> 8;
	1722	+ msg->msg[6] = phys_addr1 & 0xff;
	1723	+ msg->msg[7] = phys_addr2 >> 8;
	1724	+ msg->msg[8] = phys_addr2 & 0xff;
	1725	+}
	1726	+
	1727	+static inline void cec_ops_cdc_hec_inquire_state(const struct cec_msg *msg,
	1728	+ __u16 *phys_addr,
	1729	+ __u16 *phys_addr1,
	1730	+ __u16 *phys_addr2)
	1731	+{
	1732	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	1733	+ *phys_addr1 = (msg->msg[5] << 8) \| msg->msg[6];
	1734	+ *phys_addr2 = (msg->msg[7] << 8) \| msg->msg[8];
	1735	+}
	1736	+
	1737	+static inline void cec_msg_cdc_hec_report_state(struct cec_msg *msg,
	1738	+ __u16 target_phys_addr,
	1739	+ __u8 hec_func_state,
	1740	+ __u8 host_func_state,
	1741	+ __u8 enc_func_state,
	1742	+ __u8 cdc_errcode,
	1743	+ __u8 has_field,
	1744	+ __u16 hec_field)
	1745	+{
	1746	+ msg->len = has_field ? 10 : 8;
	1747	+ msg->msg[0] \|= 0xf; /* broadcast */
	1748	+ msg->msg[1] = CEC_MSG_CDC_MESSAGE;
	1749	+ /* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
	1750	+ msg->msg[4] = CEC_MSG_CDC_HEC_REPORT_STATE;
	1751	+ msg->msg[5] = target_phys_addr >> 8;
	1752	+ msg->msg[6] = target_phys_addr & 0xff;
	1753	+ msg->msg[7] = (hec_func_state << 6) \|
	1754	+ (host_func_state << 4) \|
	1755	+ (enc_func_state << 2) \|
	1756	+ cdc_errcode;
	1757	+ if (has_field) {
	1758	+ msg->msg[8] = hec_field >> 8;
	1759	+ msg->msg[9] = hec_field & 0xff;
	1760	+ }
	1761	+}
	1762	+
	1763	+static inline void cec_ops_cdc_hec_report_state(const struct cec_msg *msg,
	1764	+ __u16 *phys_addr,
	1765	+ __u16 *target_phys_addr,
	1766	+ __u8 *hec_func_state,
	1767	+ __u8 *host_func_state,
	1768	+ __u8 *enc_func_state,
	1769	+ __u8 *cdc_errcode,
	1770	+ __u8 *has_field,
	1771	+ __u16 *hec_field)
	1772	+{
	1773	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	1774	+ *target_phys_addr = (msg->msg[5] << 8) \| msg->msg[6];
	1775	+ *hec_func_state = msg->msg[7] >> 6;
	1776	+ *host_func_state = (msg->msg[7] >> 4) & 3;
	1777	+ *enc_func_state = (msg->msg[7] >> 4) & 3;
	1778	+ *cdc_errcode = msg->msg[7] & 3;
	1779	+ *has_field = msg->len >= 10;
	1780	+ hec_field = has_field ? ((msg->msg[8] << 8) \| msg->msg[9]) : 0;
	1781	+}
	1782	+
	1783	+static inline void cec_msg_cdc_hec_set_state(struct cec_msg *msg,
	1784	+ __u16 phys_addr1,
	1785	+ __u16 phys_addr2,
	1786	+ __u8 hec_set_state,
	1787	+ __u16 phys_addr3,
	1788	+ __u16 phys_addr4,
	1789	+ __u16 phys_addr5)
	1790	+{
	1791	+ msg->len = 10;
	1792	+ msg->msg[0] \|= 0xf; /* broadcast */
	1793	+ msg->msg[1] = CEC_MSG_CDC_MESSAGE;
	1794	+ /* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
	1795	+ msg->msg[4] = CEC_MSG_CDC_HEC_INQUIRE_STATE;
	1796	+ msg->msg[5] = phys_addr1 >> 8;
	1797	+ msg->msg[6] = phys_addr1 & 0xff;
	1798	+ msg->msg[7] = phys_addr2 >> 8;
	1799	+ msg->msg[8] = phys_addr2 & 0xff;
	1800	+ msg->msg[9] = hec_set_state;
	1801	+ if (phys_addr3 != CEC_PHYS_ADDR_INVALID) {
	1802	+ msg->msg[msg->len++] = phys_addr3 >> 8;
	1803	+ msg->msg[msg->len++] = phys_addr3 & 0xff;
	1804	+ if (phys_addr4 != CEC_PHYS_ADDR_INVALID) {
	1805	+ msg->msg[msg->len++] = phys_addr4 >> 8;
	1806	+ msg->msg[msg->len++] = phys_addr4 & 0xff;
	1807	+ if (phys_addr5 != CEC_PHYS_ADDR_INVALID) {
	1808	+ msg->msg[msg->len++] = phys_addr5 >> 8;
	1809	+ msg->msg[msg->len++] = phys_addr5 & 0xff;
	1810	+ }
	1811	+ }
	1812	+ }
	1813	+}
	1814	+
	1815	+static inline void cec_ops_cdc_hec_set_state(const struct cec_msg *msg,
	1816	+ __u16 *phys_addr,
	1817	+ __u16 *phys_addr1,
	1818	+ __u16 *phys_addr2,
	1819	+ __u8 *hec_set_state,
	1820	+ __u16 *phys_addr3,
	1821	+ __u16 *phys_addr4,
	1822	+ __u16 *phys_addr5)
	1823	+{
	1824	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	1825	+ *phys_addr1 = (msg->msg[5] << 8) \| msg->msg[6];
	1826	+ *phys_addr2 = (msg->msg[7] << 8) \| msg->msg[8];
	1827	+ *hec_set_state = msg->msg[9];
	1828	+ phys_addr3 = phys_addr4 = *phys_addr5 = CEC_PHYS_ADDR_INVALID;
	1829	+ if (msg->len >= 12)
	1830	+ *phys_addr3 = (msg->msg[10] << 8) \| msg->msg[11];
	1831	+ if (msg->len >= 14)
	1832	+ *phys_addr4 = (msg->msg[12] << 8) \| msg->msg[13];
	1833	+ if (msg->len >= 16)
	1834	+ *phys_addr5 = (msg->msg[14] << 8) \| msg->msg[15];
	1835	+}
	1836	+
	1837	+static inline void cec_msg_cdc_hec_set_state_adjacent(struct cec_msg *msg,
	1838	+ __u16 phys_addr1,
	1839	+ __u8 hec_set_state)
	1840	+{
	1841	+ msg->len = 8;
	1842	+ msg->msg[0] \|= 0xf; /* broadcast */
	1843	+ msg->msg[1] = CEC_MSG_CDC_MESSAGE;
	1844	+ /* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
	1845	+ msg->msg[4] = CEC_MSG_CDC_HEC_SET_STATE_ADJACENT;
	1846	+ msg->msg[5] = phys_addr1 >> 8;
	1847	+ msg->msg[6] = phys_addr1 & 0xff;
	1848	+ msg->msg[7] = hec_set_state;
	1849	+}
	1850	+
	1851	+static inline void cec_ops_cdc_hec_set_state_adjacent(const struct cec_msg *msg,
	1852	+ __u16 *phys_addr,
	1853	+ __u16 *phys_addr1,
	1854	+ __u8 *hec_set_state)
	1855	+{
	1856	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	1857	+ *phys_addr1 = (msg->msg[5] << 8) \| msg->msg[6];
	1858	+ *hec_set_state = msg->msg[7];
	1859	+}
	1860	+
	1861	+static inline void cec_msg_cdc_hec_request_deactivation(struct cec_msg *msg,
	1862	+ __u16 phys_addr1,
	1863	+ __u16 phys_addr2,
	1864	+ __u16 phys_addr3)
	1865	+{
	1866	+ msg->len = 11;
	1867	+ msg->msg[0] \|= 0xf; /* broadcast */
	1868	+ msg->msg[1] = CEC_MSG_CDC_MESSAGE;
	1869	+ /* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
	1870	+ msg->msg[4] = CEC_MSG_CDC_HEC_REQUEST_DEACTIVATION;
	1871	+ msg->msg[5] = phys_addr1 >> 8;
	1872	+ msg->msg[6] = phys_addr1 & 0xff;
	1873	+ msg->msg[7] = phys_addr2 >> 8;
	1874	+ msg->msg[8] = phys_addr2 & 0xff;
	1875	+ msg->msg[9] = phys_addr3 >> 8;
	1876	+ msg->msg[10] = phys_addr3 & 0xff;
	1877	+}
	1878	+
	1879	+static inline void cec_ops_cdc_hec_request_deactivation(const struct cec_msg *msg,
	1880	+ __u16 *phys_addr,
	1881	+ __u16 *phys_addr1,
	1882	+ __u16 *phys_addr2,
	1883	+ __u16 *phys_addr3)
	1884	+{
	1885	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	1886	+ *phys_addr1 = (msg->msg[5] << 8) \| msg->msg[6];
	1887	+ *phys_addr2 = (msg->msg[7] << 8) \| msg->msg[8];
	1888	+ *phys_addr3 = (msg->msg[9] << 8) \| msg->msg[10];
	1889	+}
	1890	+
	1891	+static inline void cec_msg_cdc_hec_notify_alive(struct cec_msg *msg)
	1892	+{
	1893	+ msg->len = 5;
	1894	+ msg->msg[0] \|= 0xf; /* broadcast */
	1895	+ msg->msg[1] = CEC_MSG_CDC_MESSAGE;
	1896	+ /* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
	1897	+ msg->msg[4] = CEC_MSG_CDC_HEC_NOTIFY_ALIVE;
	1898	+}
	1899	+
	1900	+static inline void cec_ops_cdc_hec_notify_alive(const struct cec_msg *msg,
	1901	+ __u16 *phys_addr)
	1902	+{
	1903	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	1904	+}
	1905	+
	1906	+static inline void cec_msg_cdc_hec_discover(struct cec_msg *msg)
	1907	+{
	1908	+ msg->len = 5;
	1909	+ msg->msg[0] \|= 0xf; /* broadcast */
	1910	+ msg->msg[1] = CEC_MSG_CDC_MESSAGE;
	1911	+ /* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
	1912	+ msg->msg[4] = CEC_MSG_CDC_HEC_DISCOVER;
	1913	+}
	1914	+
	1915	+static inline void cec_ops_cdc_hec_discover(const struct cec_msg *msg,
	1916	+ __u16 *phys_addr)
	1917	+{
	1918	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	1919	+}
	1920	+
	1921	+static inline void cec_msg_cdc_hpd_set_state(struct cec_msg *msg,
	1922	+ __u8 input_port,
	1923	+ __u8 hpd_state)
	1924	+{
	1925	+ msg->len = 6;
	1926	+ msg->msg[0] \|= 0xf; /* broadcast */
	1927	+ msg->msg[1] = CEC_MSG_CDC_MESSAGE;
	1928	+ /* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
	1929	+ msg->msg[4] = CEC_MSG_CDC_HPD_SET_STATE;
	1930	+ msg->msg[5] = (input_port << 4) \| hpd_state;
	1931	+}
	1932	+
	1933	+static inline void cec_ops_cdc_hpd_set_state(const struct cec_msg *msg,
	1934	+ __u16 *phys_addr,
	1935	+ __u8 *input_port,
	1936	+ __u8 *hpd_state)
	1937	+{
	1938	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	1939	+ *input_port = msg->msg[5] >> 4;
	1940	+ *hpd_state = msg->msg[5] & 0xf;
	1941	+}
	1942	+
	1943	+static inline void cec_msg_cdc_hpd_report_state(struct cec_msg *msg,
	1944	+ __u8 hpd_state,
	1945	+ __u8 hpd_error)
	1946	+{
	1947	+ msg->len = 6;
	1948	+ msg->msg[0] \|= 0xf; /* broadcast */
	1949	+ msg->msg[1] = CEC_MSG_CDC_MESSAGE;
	1950	+ /* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
	1951	+ msg->msg[4] = CEC_MSG_CDC_HPD_REPORT_STATE;
	1952	+ msg->msg[5] = (hpd_state << 4) \| hpd_error;
	1953	+}
	1954	+
	1955	+static inline void cec_ops_cdc_hpd_report_state(const struct cec_msg *msg,
	1956	+ __u16 *phys_addr,
	1957	+ __u8 *hpd_state,
	1958	+ __u8 *hpd_error)
	1959	+{
	1960	+ *phys_addr = (msg->msg[2] << 8) \| msg->msg[3];
	1961	+ *hpd_state = msg->msg[5] >> 4;
	1962	+ *hpd_error = msg->msg[5] & 0xf;
	1963	+}
	1964	+
	1965	+#endif

include/uapi/linux/cec.h+1066−0

@@ -0,0 +1,1066 @@
	1	+/*
	2	+ * cec - HDMI Consumer Electronics Control public header
	3	+ *
	4	+ * Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
	5	+ *
	6	+ * This program is free software; you may redistribute it and/or modify
	7	+ * it under the terms of the GNU General Public License as published by
	8	+ * the Free Software Foundation; version 2 of the License.
	9	+ *
	10	+ * Alternatively you can redistribute this file under the terms of the
	11	+ * BSD license as stated below:
	12	+ *
	13	+ * Redistribution and use in source and binary forms, with or without
	14	+ * modification, are permitted provided that the following conditions
	15	+ * are met:
	16	+ * 1. Redistributions of source code must retain the above copyright
	17	+ * notice, this list of conditions and the following disclaimer.
	18	+ * 2. Redistributions in binary form must reproduce the above copyright
	19	+ * notice, this list of conditions and the following disclaimer in
	20	+ * the documentation and/or other materials provided with the
	21	+ * distribution.
	22	+ * 3. The names of its contributors may not be used to endorse or promote
	23	+ * products derived from this software without specific prior written
	24	+ * permission.
	25	+ *
	26	+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	27	+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	28	+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	29	+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	30	+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	31	+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	32	+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	33	+ * SOFTWARE.
	34	+ */
	35	+
	36	+#ifndef _CEC_UAPI_H
	37	+#define _CEC_UAPI_H
	38	+
	39	+#include <linux/types.h>
	40	+#include <linux/string.h>
	41	+
	42	+#define CEC_MAX_MSG_SIZE 16
	43	+
	44	+/**
	45	+ * struct cec_msg - CEC message structure.
	46	+ * @tx_ts: Timestamp in nanoseconds using CLOCK_MONOTONIC. Set by the
	47	+ * driver when the message transmission has finished.
	48	+ * @rx_ts: Timestamp in nanoseconds using CLOCK_MONOTONIC. Set by the
	49	+ * driver when the message was received.
	50	+ * @len: Length in bytes of the message.
	51	+ * @timeout: The timeout (in ms) that is used to timeout CEC_RECEIVE.
	52	+ * Set to 0 if you want to wait forever. This timeout can also be
	53	+ * used with CEC_TRANSMIT as the timeout for waiting for a reply.
	54	+ * If 0, then it will use a 1 second timeout instead of waiting
	55	+ * forever as is done with CEC_RECEIVE.
	56	+ * @sequence: The framework assigns a sequence number to messages that are
	57	+ * sent. This can be used to track replies to previously sent
	58	+ * messages.
	59	+ * @flags: Set to 0.
	60	+ * @msg: The message payload.
	61	+ * @reply: This field is ignored with CEC_RECEIVE and is only used by
	62	+ * CEC_TRANSMIT. If non-zero, then wait for a reply with this
	63	+ * opcode. Set to CEC_MSG_FEATURE_ABORT if you want to wait for
	64	+ * a possible ABORT reply. If there was an error when sending the
	65	+ * msg or FeatureAbort was returned, then reply is set to 0.
	66	+ * If reply is non-zero upon return, then len/msg are set to
	67	+ * the received message.
	68	+ * If reply is zero upon return and status has the
	69	+ * CEC_TX_STATUS_FEATURE_ABORT bit set, then len/msg are set to
	70	+ * the received feature abort message.
	71	+ * If reply is zero upon return and status has the
	72	+ * CEC_TX_STATUS_MAX_RETRIES bit set, then no reply was seen at
	73	+ * all. If reply is non-zero for CEC_TRANSMIT and the message is a
	74	+ * broadcast, then -EINVAL is returned.
	75	+ * if reply is non-zero, then timeout is set to 1000 (the required
	76	+ * maximum response time).
	77	+ * @rx_status: The message receive status bits. Set by the driver.
	78	+ * @tx_status: The message transmit status bits. Set by the driver.
	79	+ * @tx_arb_lost_cnt: The number of 'Arbitration Lost' events. Set by the driver.
	80	+ * @tx_nack_cnt: The number of 'Not Acknowledged' events. Set by the driver.
	81	+ * @tx_low_drive_cnt: The number of 'Low Drive Detected' events. Set by the
	82	+ * driver.
	83	+ * @tx_error_cnt: The number of 'Error' events. Set by the driver.
	84	+ */
	85	+struct cec_msg {
	86	+ __u64 tx_ts;
	87	+ __u64 rx_ts;
	88	+ __u32 len;
	89	+ __u32 timeout;
	90	+ __u32 sequence;
	91	+ __u32 flags;
	92	+ __u8 msg[CEC_MAX_MSG_SIZE];
	93	+ __u8 reply;
	94	+ __u8 rx_status;
	95	+ __u8 tx_status;
	96	+ __u8 tx_arb_lost_cnt;
	97	+ __u8 tx_nack_cnt;
	98	+ __u8 tx_low_drive_cnt;
	99	+ __u8 tx_error_cnt;
	100	+};
	101	+
	102	+/**
	103	+ * cec_msg_initiator - return the initiator's logical address.
	104	+ * @msg: the message structure
	105	+ */
	106	+static inline __u8 cec_msg_initiator(const struct cec_msg *msg)
	107	+{
	108	+ return msg->msg[0] >> 4;
	109	+}
	110	+
	111	+/**
	112	+ * cec_msg_destination - return the destination's logical address.
	113	+ * @msg: the message structure
	114	+ */
	115	+static inline __u8 cec_msg_destination(const struct cec_msg *msg)
	116	+{
	117	+ return msg->msg[0] & 0xf;
	118	+}
	119	+
	120	+/**
	121	+ * cec_msg_opcode - return the opcode of the message, -1 for poll
	122	+ * @msg: the message structure
	123	+ */
	124	+static inline int cec_msg_opcode(const struct cec_msg *msg)
	125	+{
	126	+ return msg->len > 1 ? msg->msg[1] : -1;
	127	+}
	128	+
	129	+/**
	130	+ * cec_msg_is_broadcast - return true if this is a broadcast message.
	131	+ * @msg: the message structure
	132	+ */
	133	+static inline int cec_msg_is_broadcast(const struct cec_msg *msg)
	134	+{
	135	+ return (msg->msg[0] & 0xf) == 0xf;
	136	+}
	137	+
	138	+/**
	139	+ * cec_msg_init - initialize the message structure.
	140	+ * @msg: the message structure
	141	+ * @initiator: the logical address of the initiator
	142	+ * @destination:the logical address of the destination (0xf for broadcast)
	143	+ *
	144	+ * The whole structure is zeroed, the len field is set to 1 (i.e. a poll
	145	+ * message) and the initiator and destination are filled in.
	146	+ */
	147	+static inline void cec_msg_init(struct cec_msg *msg,
	148	+ __u8 initiator, __u8 destination)
	149	+{
	150	+ memset(msg, 0, sizeof(*msg));
	151	+ msg->msg[0] = (initiator << 4) \| destination;
	152	+ msg->len = 1;
	153	+}
	154	+
	155	+/**
	156	+ * cec_msg_set_reply_to - fill in destination/initiator in a reply message.
	157	+ * @msg: the message structure for the reply
	158	+ * @orig: the original message structure
	159	+ *
	160	+ * Set the msg destination to the orig initiator and the msg initiator to the
	161	+ * orig destination. Note that msg and orig may be the same pointer, in which
	162	+ * case the change is done in place.
	163	+ */
	164	+static inline void cec_msg_set_reply_to(struct cec_msg *msg,
	165	+ struct cec_msg *orig)
	166	+{
	167	+ /* The destination becomes the initiator and vice versa */
	168	+ msg->msg[0] = (cec_msg_destination(orig) << 4) \|
	169	+ cec_msg_initiator(orig);
	170	+ msg->reply = msg->timeout = 0;
	171	+}
	172	+
	173	+/* cec_msg flags field */
	174	+#define CEC_MSG_FL_REPLY_TO_FOLLOWERS (1 << 0)
	175	+
	176	+/* cec_msg tx/rx_status field */
	177	+#define CEC_TX_STATUS_OK (1 << 0)
	178	+#define CEC_TX_STATUS_ARB_LOST (1 << 1)
	179	+#define CEC_TX_STATUS_NACK (1 << 2)
	180	+#define CEC_TX_STATUS_LOW_DRIVE (1 << 3)
	181	+#define CEC_TX_STATUS_ERROR (1 << 4)
	182	+#define CEC_TX_STATUS_MAX_RETRIES (1 << 5)
	183	+
	184	+#define CEC_RX_STATUS_OK (1 << 0)
	185	+#define CEC_RX_STATUS_TIMEOUT (1 << 1)
	186	+#define CEC_RX_STATUS_FEATURE_ABORT (1 << 2)
	187	+
	188	+static inline int cec_msg_status_is_ok(const struct cec_msg *msg)
	189	+{
	190	+ if (msg->tx_status && !(msg->tx_status & CEC_TX_STATUS_OK))
	191	+ return 0;
	192	+ if (msg->rx_status && !(msg->rx_status & CEC_RX_STATUS_OK))
	193	+ return 0;
	194	+ if (!msg->tx_status && !msg->rx_status)
	195	+ return 0;
	196	+ return !(msg->rx_status & CEC_RX_STATUS_FEATURE_ABORT);
	197	+}
	198	+
	199	+#define CEC_LOG_ADDR_INVALID 0xff
	200	+#define CEC_PHYS_ADDR_INVALID 0xffff
	201	+
	202	+/*
	203	+ * The maximum number of logical addresses one device can be assigned to.
	204	+ * The CEC 2.0 spec allows for only 2 logical addresses at the moment. The
	205	+ * Analog Devices CEC hardware supports 3. So let's go wild and go for 4.
	206	+ */
	207	+#define CEC_MAX_LOG_ADDRS 4
	208	+
	209	+/* The logical addresses defined by CEC 2.0 */
	210	+#define CEC_LOG_ADDR_TV 0
	211	+#define CEC_LOG_ADDR_RECORD_1 1
	212	+#define CEC_LOG_ADDR_RECORD_2 2
	213	+#define CEC_LOG_ADDR_TUNER_1 3
	214	+#define CEC_LOG_ADDR_PLAYBACK_1 4
	215	+#define CEC_LOG_ADDR_AUDIOSYSTEM 5
	216	+#define CEC_LOG_ADDR_TUNER_2 6
	217	+#define CEC_LOG_ADDR_TUNER_3 7
	218	+#define CEC_LOG_ADDR_PLAYBACK_2 8
	219	+#define CEC_LOG_ADDR_RECORD_3 9
	220	+#define CEC_LOG_ADDR_TUNER_4 10
	221	+#define CEC_LOG_ADDR_PLAYBACK_3 11
	222	+#define CEC_LOG_ADDR_BACKUP_1 12
	223	+#define CEC_LOG_ADDR_BACKUP_2 13
	224	+#define CEC_LOG_ADDR_SPECIFIC 14
	225	+#define CEC_LOG_ADDR_UNREGISTERED 15 /* as initiator address */
	226	+#define CEC_LOG_ADDR_BROADCAST 15 /* ad destination address */
	227	+
	228	+/* The logical address types that the CEC device wants to claim */
	229	+#define CEC_LOG_ADDR_TYPE_TV 0
	230	+#define CEC_LOG_ADDR_TYPE_RECORD 1
	231	+#define CEC_LOG_ADDR_TYPE_TUNER 2
	232	+#define CEC_LOG_ADDR_TYPE_PLAYBACK 3
	233	+#define CEC_LOG_ADDR_TYPE_AUDIOSYSTEM 4
	234	+#define CEC_LOG_ADDR_TYPE_SPECIFIC 5
	235	+#define CEC_LOG_ADDR_TYPE_UNREGISTERED 6
	236	+/*
	237	+ * Switches should use UNREGISTERED.
	238	+ * Processors should use SPECIFIC.
	239	+ */
	240	+
	241	+#define CEC_LOG_ADDR_MASK_TV (1 << CEC_LOG_ADDR_TV)
	242	+#define CEC_LOG_ADDR_MASK_RECORD ((1 << CEC_LOG_ADDR_RECORD_1) \| \
	243	+ (1 << CEC_LOG_ADDR_RECORD_2) \| \
	244	+ (1 << CEC_LOG_ADDR_RECORD_3))
	245	+#define CEC_LOG_ADDR_MASK_TUNER ((1 << CEC_LOG_ADDR_TUNER_1) \| \
	246	+ (1 << CEC_LOG_ADDR_TUNER_2) \| \
	247	+ (1 << CEC_LOG_ADDR_TUNER_3) \| \
	248	+ (1 << CEC_LOG_ADDR_TUNER_4))
	249	+#define CEC_LOG_ADDR_MASK_PLAYBACK ((1 << CEC_LOG_ADDR_PLAYBACK_1) \| \
	250	+ (1 << CEC_LOG_ADDR_PLAYBACK_2) \| \
	251	+ (1 << CEC_LOG_ADDR_PLAYBACK_3))
	252	+#define CEC_LOG_ADDR_MASK_AUDIOSYSTEM (1 << CEC_LOG_ADDR_AUDIOSYSTEM)
	253	+#define CEC_LOG_ADDR_MASK_BACKUP ((1 << CEC_LOG_ADDR_BACKUP_1) \| \
	254	+ (1 << CEC_LOG_ADDR_BACKUP_2))
	255	+#define CEC_LOG_ADDR_MASK_SPECIFIC (1 << CEC_LOG_ADDR_SPECIFIC)
	256	+#define CEC_LOG_ADDR_MASK_UNREGISTERED (1 << CEC_LOG_ADDR_UNREGISTERED)
	257	+
	258	+static inline int cec_has_tv(__u16 log_addr_mask)
	259	+{
	260	+ return log_addr_mask & CEC_LOG_ADDR_MASK_TV;
	261	+}
	262	+
	263	+static inline int cec_has_record(__u16 log_addr_mask)
	264	+{
	265	+ return log_addr_mask & CEC_LOG_ADDR_MASK_RECORD;
	266	+}
	267	+
	268	+static inline int cec_has_tuner(__u16 log_addr_mask)
	269	+{
	270	+ return log_addr_mask & CEC_LOG_ADDR_MASK_TUNER;
	271	+}
	272	+
	273	+static inline int cec_has_playback(__u16 log_addr_mask)
	274	+{
	275	+ return log_addr_mask & CEC_LOG_ADDR_MASK_PLAYBACK;
	276	+}
	277	+
	278	+static inline int cec_has_audiosystem(__u16 log_addr_mask)
	279	+{
	280	+ return log_addr_mask & CEC_LOG_ADDR_MASK_AUDIOSYSTEM;
	281	+}
	282	+
	283	+static inline int cec_has_backup(__u16 log_addr_mask)
	284	+{
	285	+ return log_addr_mask & CEC_LOG_ADDR_MASK_BACKUP;
	286	+}
	287	+
	288	+static inline int cec_has_specific(__u16 log_addr_mask)
	289	+{
	290	+ return log_addr_mask & CEC_LOG_ADDR_MASK_SPECIFIC;
	291	+}
	292	+
	293	+static inline int cec_is_unregistered(__u16 log_addr_mask)
	294	+{
	295	+ return log_addr_mask & CEC_LOG_ADDR_MASK_UNREGISTERED;
	296	+}
	297	+
	298	+static inline int cec_is_unconfigured(__u16 log_addr_mask)
	299	+{
	300	+ return log_addr_mask == 0;
	301	+}
	302	+
	303	+/*
	304	+ * Use this if there is no vendor ID (CEC_G_VENDOR_ID) or if the vendor ID
	305	+ * should be disabled (CEC_S_VENDOR_ID)
	306	+ */
	307	+#define CEC_VENDOR_ID_NONE 0xffffffff
	308	+
	309	+/* The message handling modes */
	310	+/* Modes for initiator */
	311	+#define CEC_MODE_NO_INITIATOR (0x0 << 0)
	312	+#define CEC_MODE_INITIATOR (0x1 << 0)
	313	+#define CEC_MODE_EXCL_INITIATOR (0x2 << 0)
	314	+#define CEC_MODE_INITIATOR_MSK 0x0f
	315	+
	316	+/* Modes for follower */
	317	+#define CEC_MODE_NO_FOLLOWER (0x0 << 4)
	318	+#define CEC_MODE_FOLLOWER (0x1 << 4)
	319	+#define CEC_MODE_EXCL_FOLLOWER (0x2 << 4)
	320	+#define CEC_MODE_EXCL_FOLLOWER_PASSTHRU (0x3 << 4)
	321	+#define CEC_MODE_MONITOR (0xe << 4)
	322	+#define CEC_MODE_MONITOR_ALL (0xf << 4)
	323	+#define CEC_MODE_FOLLOWER_MSK 0xf0
	324	+
	325	+/* Userspace has to configure the physical address */
	326	+#define CEC_CAP_PHYS_ADDR (1 << 0)
	327	+/* Userspace has to configure the logical addresses */
	328	+#define CEC_CAP_LOG_ADDRS (1 << 1)
	329	+/* Userspace can transmit messages (and thus become follower as well) */
	330	+#define CEC_CAP_TRANSMIT (1 << 2)
	331	+/*
	332	+ * Passthrough all messages instead of processing them.
	333	+ */
	334	+#define CEC_CAP_PASSTHROUGH (1 << 3)
	335	+/* Supports remote control */
	336	+#define CEC_CAP_RC (1 << 4)
	337	+/* Hardware can monitor all messages, not just directed and broadcast. */
	338	+#define CEC_CAP_MONITOR_ALL (1 << 5)
	339	+
	340	+/**
	341	+ * struct cec_caps - CEC capabilities structure.
	342	+ * @driver: name of the CEC device driver.
	343	+ * @name: name of the CEC device. @driver + @name must be unique.
	344	+ * @available_log_addrs: number of available logical addresses.
	345	+ * @capabilities: capabilities of the CEC adapter.
	346	+ * @version: version of the CEC adapter framework.
	347	+ */
	348	+struct cec_caps {
	349	+ char driver[32];
	350	+ char name[32];
	351	+ __u32 available_log_addrs;
	352	+ __u32 capabilities;
	353	+ __u32 version;
	354	+};
	355	+
	356	+/**
	357	+ * struct cec_log_addrs - CEC logical addresses structure.
	358	+ * @log_addr: the claimed logical addresses. Set by the driver.
	359	+ * @log_addr_mask: current logical address mask. Set by the driver.
	360	+ * @cec_version: the CEC version that the adapter should implement. Set by the
	361	+ * caller.
	362	+ * @num_log_addrs: how many logical addresses should be claimed. Set by the
	363	+ * caller.
	364	+ * @vendor_id: the vendor ID of the device. Set by the caller.
	365	+ * @flags: flags.
	366	+ * @osd_name: the OSD name of the device. Set by the caller.
	367	+ * @primary_device_type: the primary device type for each logical address.
	368	+ * Set by the caller.
	369	+ * @log_addr_type: the logical address types. Set by the caller.
	370	+ * @all_device_types: CEC 2.0: all device types represented by the logical
	371	+ * address. Set by the caller.
	372	+ * @features: CEC 2.0: The logical address features. Set by the caller.
	373	+ */
	374	+struct cec_log_addrs {
	375	+ __u8 log_addr[CEC_MAX_LOG_ADDRS];
	376	+ __u16 log_addr_mask;
	377	+ __u8 cec_version;
	378	+ __u8 num_log_addrs;
	379	+ __u32 vendor_id;
	380	+ __u32 flags;
	381	+ char osd_name[15];
	382	+ __u8 primary_device_type[CEC_MAX_LOG_ADDRS];
	383	+ __u8 log_addr_type[CEC_MAX_LOG_ADDRS];
	384	+
	385	+ /* CEC 2.0 */
	386	+ __u8 all_device_types[CEC_MAX_LOG_ADDRS];
	387	+ __u8 features[CEC_MAX_LOG_ADDRS][12];
	388	+};
	389	+
	390	+/* Allow a fallback to unregistered */
	391	+#define CEC_LOG_ADDRS_FL_ALLOW_UNREG_FALLBACK (1 << 0)
	392	+/* Passthrough RC messages to the input subsystem */
	393	+#define CEC_LOG_ADDRS_FL_ALLOW_RC_PASSTHRU (1 << 1)
	394	+/* CDC-Only device: supports only CDC messages */
	395	+#define CEC_LOG_ADDRS_FL_CDC_ONLY (1 << 2)
	396	+
	397	+/* Events */
	398	+
	399	+/* Event that occurs when the adapter state changes */
	400	+#define CEC_EVENT_STATE_CHANGE 1
	401	+/*
	402	+ * This event is sent when messages are lost because the application
	403	+ * didn't empty the message queue in time
	404	+ */
	405	+#define CEC_EVENT_LOST_MSGS 2
	406	+
	407	+#define CEC_EVENT_FL_INITIAL_STATE (1 << 0)
	408	+
	409	+/**
	410	+ * struct cec_event_state_change - used when the CEC adapter changes state.
	411	+ * @phys_addr: the current physical address
	412	+ * @log_addr_mask: the current logical address mask
	413	+ */
	414	+struct cec_event_state_change {
	415	+ __u16 phys_addr;
	416	+ __u16 log_addr_mask;
	417	+};
	418	+
	419	+/**
	420	+ * struct cec_event_lost_msgs - tells you how many messages were lost due.
	421	+ * @lost_msgs: how many messages were lost.
	422	+ */
	423	+struct cec_event_lost_msgs {
	424	+ __u32 lost_msgs;
	425	+};
	426	+
	427	+/**
	428	+ * struct cec_event - CEC event structure
	429	+ * @ts: the timestamp of when the event was sent.
	430	+ * @event: the event.
	431	+ * array.
	432	+ * @state_change: the event payload for CEC_EVENT_STATE_CHANGE.
	433	+ * @lost_msgs: the event payload for CEC_EVENT_LOST_MSGS.
	434	+ * @raw: array to pad the union.
	435	+ */
	436	+struct cec_event {
	437	+ __u64 ts;
	438	+ __u32 event;
	439	+ __u32 flags;
	440	+ union {
	441	+ struct cec_event_state_change state_change;
	442	+ struct cec_event_lost_msgs lost_msgs;
	443	+ __u32 raw[16];
	444	+ };
	445	+};
	446	+
	447	+/* ioctls */
	448	+
	449	+/* Adapter capabilities */
	450	+#define CEC_ADAP_G_CAPS _IOWR('a', 0, struct cec_caps)
	451	+
	452	+/*
	453	+ * phys_addr is either 0 (if this is the CEC root device)
	454	+ * or a valid physical address obtained from the sink's EDID
	455	+ * as read by this CEC device (if this is a source device)
	456	+ * or a physical address obtained and modified from a sink
	457	+ * EDID and used for a sink CEC device.
	458	+ * If nothing is connected, then phys_addr is 0xffff.
	459	+ * See HDMI 1.4b, section 8.7 (Physical Address).
	460	+ *
	461	+ * The CEC_ADAP_S_PHYS_ADDR ioctl may not be available if that is handled
	462	+ * internally.
	463	+ */
	464	+#define CEC_ADAP_G_PHYS_ADDR _IOR('a', 1, __u16)
	465	+#define CEC_ADAP_S_PHYS_ADDR _IOW('a', 2, __u16)
	466	+
	467	+/*
	468	+ * Configure the CEC adapter. It sets the device type and which
	469	+ * logical types it will try to claim. It will return which
	470	+ * logical addresses it could actually claim.
	471	+ * An error is returned if the adapter is disabled or if there
	472	+ * is no physical address assigned.
	473	+ */
	474	+
	475	+#define CEC_ADAP_G_LOG_ADDRS _IOR('a', 3, struct cec_log_addrs)
	476	+#define CEC_ADAP_S_LOG_ADDRS _IOWR('a', 4, struct cec_log_addrs)
	477	+
	478	+/* Transmit/receive a CEC command */
	479	+#define CEC_TRANSMIT _IOWR('a', 5, struct cec_msg)
	480	+#define CEC_RECEIVE _IOWR('a', 6, struct cec_msg)
	481	+
	482	+/* Dequeue CEC events */
	483	+#define CEC_DQEVENT _IOWR('a', 7, struct cec_event)
	484	+
	485	+/*
	486	+ * Get and set the message handling mode for this filehandle.
	487	+ */
	488	+#define CEC_G_MODE _IOR('a', 8, __u32)
	489	+#define CEC_S_MODE _IOW('a', 9, __u32)
	490	+
	491	+/*
	492	+ * The remainder of this header defines all CEC messages and operands.
	493	+ * The format matters since it the cec-ctl utility parses it to generate
	494	+ * code for implementing all these messages.
	495	+ *
	496	+ * Comments ending with 'Feature' group messages for each feature.
	497	+ * If messages are part of multiple features, then the "Has also"
	498	+ * comment is used to list the previously defined messages that are
	499	+ * supported by the feature.
	500	+ *
	501	+ * Before operands are defined a comment is added that gives the
	502	+ * name of the operand and in brackets the variable name of the
	503	+ * corresponding argument in the cec-funcs.h function.
	504	+ */
	505	+
	506	+/* Messages */
	507	+
	508	+/* One Touch Play Feature */
	509	+#define CEC_MSG_ACTIVE_SOURCE 0x82
	510	+#define CEC_MSG_IMAGE_VIEW_ON 0x04
	511	+#define CEC_MSG_TEXT_VIEW_ON 0x0d
	512	+
	513	+
	514	+/* Routing Control Feature */
	515	+
	516	+/*
	517	+ * Has also:
	518	+ * CEC_MSG_ACTIVE_SOURCE
	519	+ */
	520	+
	521	+#define CEC_MSG_INACTIVE_SOURCE 0x9d
	522	+#define CEC_MSG_REQUEST_ACTIVE_SOURCE 0x85
	523	+#define CEC_MSG_ROUTING_CHANGE 0x80
	524	+#define CEC_MSG_ROUTING_INFORMATION 0x81
	525	+#define CEC_MSG_SET_STREAM_PATH 0x86
	526	+
	527	+
	528	+/* Standby Feature */
	529	+#define CEC_MSG_STANDBY 0x36
	530	+
	531	+
	532	+/* One Touch Record Feature */
	533	+#define CEC_MSG_RECORD_OFF 0x0b
	534	+#define CEC_MSG_RECORD_ON 0x09
	535	+/* Record Source Type Operand (rec_src_type) */
	536	+#define CEC_OP_RECORD_SRC_OWN 1
	537	+#define CEC_OP_RECORD_SRC_DIGITAL 2
	538	+#define CEC_OP_RECORD_SRC_ANALOG 3
	539	+#define CEC_OP_RECORD_SRC_EXT_PLUG 4
	540	+#define CEC_OP_RECORD_SRC_EXT_PHYS_ADDR 5
	541	+/* Service Identification Method Operand (service_id_method) */
	542	+#define CEC_OP_SERVICE_ID_METHOD_BY_DIG_ID 0
	543	+#define CEC_OP_SERVICE_ID_METHOD_BY_CHANNEL 1
	544	+/* Digital Service Broadcast System Operand (dig_bcast_system) */
	545	+#define CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ARIB_GEN 0x00
	546	+#define CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ATSC_GEN 0x01
	547	+#define CEC_OP_DIG_SERVICE_BCAST_SYSTEM_DVB_GEN 0x02
	548	+#define CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ARIB_BS 0x08
	549	+#define CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ARIB_CS 0x09
	550	+#define CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ARIB_T 0x0a
	551	+#define CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ATSC_CABLE 0x10
	552	+#define CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ATSC_SAT 0x11
	553	+#define CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ATSC_T 0x12
	554	+#define CEC_OP_DIG_SERVICE_BCAST_SYSTEM_DVB_C 0x18
	555	+#define CEC_OP_DIG_SERVICE_BCAST_SYSTEM_DVB_S 0x19
	556	+#define CEC_OP_DIG_SERVICE_BCAST_SYSTEM_DVB_S2 0x1a
	557	+#define CEC_OP_DIG_SERVICE_BCAST_SYSTEM_DVB_T 0x1b
	558	+/* Analogue Broadcast Type Operand (ana_bcast_type) */
	559	+#define CEC_OP_ANA_BCAST_TYPE_CABLE 0
	560	+#define CEC_OP_ANA_BCAST_TYPE_SATELLITE 1
	561	+#define CEC_OP_ANA_BCAST_TYPE_TERRESTRIAL 2
	562	+/* Broadcast System Operand (bcast_system) */
	563	+#define CEC_OP_BCAST_SYSTEM_PAL_BG 0x00
	564	+#define CEC_OP_BCAST_SYSTEM_SECAM_LQ 0x01 /* SECAM L' */
	565	+#define CEC_OP_BCAST_SYSTEM_PAL_M 0x02
	566	+#define CEC_OP_BCAST_SYSTEM_NTSC_M 0x03
	567	+#define CEC_OP_BCAST_SYSTEM_PAL_I 0x04
	568	+#define CEC_OP_BCAST_SYSTEM_SECAM_DK 0x05
	569	+#define CEC_OP_BCAST_SYSTEM_SECAM_BG 0x06
	570	+#define CEC_OP_BCAST_SYSTEM_SECAM_L 0x07
	571	+#define CEC_OP_BCAST_SYSTEM_PAL_DK 0x08
	572	+#define CEC_OP_BCAST_SYSTEM_OTHER 0x1f
	573	+/* Channel Number Format Operand (channel_number_fmt) */
	574	+#define CEC_OP_CHANNEL_NUMBER_FMT_1_PART 0x01
	575	+#define CEC_OP_CHANNEL_NUMBER_FMT_2_PART 0x02
	576	+
	577	+#define CEC_MSG_RECORD_STATUS 0x0a
	578	+/* Record Status Operand (rec_status) */
	579	+#define CEC_OP_RECORD_STATUS_CUR_SRC 0x01
	580	+#define CEC_OP_RECORD_STATUS_DIG_SERVICE 0x02
	581	+#define CEC_OP_RECORD_STATUS_ANA_SERVICE 0x03
	582	+#define CEC_OP_RECORD_STATUS_EXT_INPUT 0x04
	583	+#define CEC_OP_RECORD_STATUS_NO_DIG_SERVICE 0x05
	584	+#define CEC_OP_RECORD_STATUS_NO_ANA_SERVICE 0x06
	585	+#define CEC_OP_RECORD_STATUS_NO_SERVICE 0x07
	586	+#define CEC_OP_RECORD_STATUS_INVALID_EXT_PLUG 0x09
	587	+#define CEC_OP_RECORD_STATUS_INVALID_EXT_PHYS_ADDR 0x0a
	588	+#define CEC_OP_RECORD_STATUS_UNSUP_CA 0x0b
	589	+#define CEC_OP_RECORD_STATUS_NO_CA_ENTITLEMENTS 0x0c
	590	+#define CEC_OP_RECORD_STATUS_CANT_COPY_SRC 0x0d
	591	+#define CEC_OP_RECORD_STATUS_NO_MORE_COPIES 0x0e
	592	+#define CEC_OP_RECORD_STATUS_NO_MEDIA 0x10
	593	+#define CEC_OP_RECORD_STATUS_PLAYING 0x11
	594	+#define CEC_OP_RECORD_STATUS_ALREADY_RECORDING 0x12
	595	+#define CEC_OP_RECORD_STATUS_MEDIA_PROT 0x13
	596	+#define CEC_OP_RECORD_STATUS_NO_SIGNAL 0x14
	597	+#define CEC_OP_RECORD_STATUS_MEDIA_PROBLEM 0x15
	598	+#define CEC_OP_RECORD_STATUS_NO_SPACE 0x16
	599	+#define CEC_OP_RECORD_STATUS_PARENTAL_LOCK 0x17
	600	+#define CEC_OP_RECORD_STATUS_TERMINATED_OK 0x1a
	601	+#define CEC_OP_RECORD_STATUS_ALREADY_TERM 0x1b
	602	+#define CEC_OP_RECORD_STATUS_OTHER 0x1f
	603	+
	604	+#define CEC_MSG_RECORD_TV_SCREEN 0x0f
	605	+
	606	+
	607	+/* Timer Programming Feature */
	608	+#define CEC_MSG_CLEAR_ANALOGUE_TIMER 0x33
	609	+/* Recording Sequence Operand (recording_seq) */
	610	+#define CEC_OP_REC_SEQ_SUNDAY 0x01
	611	+#define CEC_OP_REC_SEQ_MONDAY 0x02
	612	+#define CEC_OP_REC_SEQ_TUESDAY 0x04
	613	+#define CEC_OP_REC_SEQ_WEDNESDAY 0x08
	614	+#define CEC_OP_REC_SEQ_THURSDAY 0x10
	615	+#define CEC_OP_REC_SEQ_FRIDAY 0x20
	616	+#define CEC_OP_REC_SEQ_SATERDAY 0x40
	617	+#define CEC_OP_REC_SEQ_ONCE_ONLY 0x00
	618	+
	619	+#define CEC_MSG_CLEAR_DIGITAL_TIMER 0x99
	620	+
	621	+#define CEC_MSG_CLEAR_EXT_TIMER 0xa1
	622	+/* External Source Specifier Operand (ext_src_spec) */
	623	+#define CEC_OP_EXT_SRC_PLUG 0x04
	624	+#define CEC_OP_EXT_SRC_PHYS_ADDR 0x05
	625	+
	626	+#define CEC_MSG_SET_ANALOGUE_TIMER 0x34
	627	+#define CEC_MSG_SET_DIGITAL_TIMER 0x97
	628	+#define CEC_MSG_SET_EXT_TIMER 0xa2
	629	+
	630	+#define CEC_MSG_SET_TIMER_PROGRAM_TITLE 0x67
	631	+#define CEC_MSG_TIMER_CLEARED_STATUS 0x43
	632	+/* Timer Cleared Status Data Operand (timer_cleared_status) */
	633	+#define CEC_OP_TIMER_CLR_STAT_RECORDING 0x00
	634	+#define CEC_OP_TIMER_CLR_STAT_NO_MATCHING 0x01
	635	+#define CEC_OP_TIMER_CLR_STAT_NO_INFO 0x02
	636	+#define CEC_OP_TIMER_CLR_STAT_CLEARED 0x80
	637	+
	638	+#define CEC_MSG_TIMER_STATUS 0x35
	639	+/* Timer Overlap Warning Operand (timer_overlap_warning) */
	640	+#define CEC_OP_TIMER_OVERLAP_WARNING_NO_OVERLAP 0
	641	+#define CEC_OP_TIMER_OVERLAP_WARNING_OVERLAP 1
	642	+/* Media Info Operand (media_info) */
	643	+#define CEC_OP_MEDIA_INFO_UNPROT_MEDIA 0
	644	+#define CEC_OP_MEDIA_INFO_PROT_MEDIA 1
	645	+#define CEC_OP_MEDIA_INFO_NO_MEDIA 2
	646	+/* Programmed Indicator Operand (prog_indicator) */
	647	+#define CEC_OP_PROG_IND_NOT_PROGRAMMED 0
	648	+#define CEC_OP_PROG_IND_PROGRAMMED 1
	649	+/* Programmed Info Operand (prog_info) */
	650	+#define CEC_OP_PROG_INFO_ENOUGH_SPACE 0x08
	651	+#define CEC_OP_PROG_INFO_NOT_ENOUGH_SPACE 0x09
	652	+#define CEC_OP_PROG_INFO_MIGHT_NOT_BE_ENOUGH_SPACE 0x0b
	653	+#define CEC_OP_PROG_INFO_NONE_AVAILABLE 0x0a
	654	+/* Not Programmed Error Info Operand (prog_error) */
	655	+#define CEC_OP_PROG_ERROR_NO_FREE_TIMER 0x01
	656	+#define CEC_OP_PROG_ERROR_DATE_OUT_OF_RANGE 0x02
	657	+#define CEC_OP_PROG_ERROR_REC_SEQ_ERROR 0x03
	658	+#define CEC_OP_PROG_ERROR_INV_EXT_PLUG 0x04
	659	+#define CEC_OP_PROG_ERROR_INV_EXT_PHYS_ADDR 0x05
	660	+#define CEC_OP_PROG_ERROR_CA_UNSUPP 0x06
	661	+#define CEC_OP_PROG_ERROR_INSUF_CA_ENTITLEMENTS 0x07
	662	+#define CEC_OP_PROG_ERROR_RESOLUTION_UNSUPP 0x08
	663	+#define CEC_OP_PROG_ERROR_PARENTAL_LOCK 0x09
	664	+#define CEC_OP_PROG_ERROR_CLOCK_FAILURE 0x0a
	665	+#define CEC_OP_PROG_ERROR_DUPLICATE 0x0e
	666	+
	667	+
	668	+/* System Information Feature */
	669	+#define CEC_MSG_CEC_VERSION 0x9e
	670	+/* CEC Version Operand (cec_version) */
	671	+#define CEC_OP_CEC_VERSION_1_3A 4
	672	+#define CEC_OP_CEC_VERSION_1_4 5
	673	+#define CEC_OP_CEC_VERSION_2_0 6
	674	+
	675	+#define CEC_MSG_GET_CEC_VERSION 0x9f
	676	+#define CEC_MSG_GIVE_PHYSICAL_ADDR 0x83
	677	+#define CEC_MSG_GET_MENU_LANGUAGE 0x91
	678	+#define CEC_MSG_REPORT_PHYSICAL_ADDR 0x84
	679	+/* Primary Device Type Operand (prim_devtype) */
	680	+#define CEC_OP_PRIM_DEVTYPE_TV 0
	681	+#define CEC_OP_PRIM_DEVTYPE_RECORD 1
	682	+#define CEC_OP_PRIM_DEVTYPE_TUNER 3
	683	+#define CEC_OP_PRIM_DEVTYPE_PLAYBACK 4
	684	+#define CEC_OP_PRIM_DEVTYPE_AUDIOSYSTEM 5
	685	+#define CEC_OP_PRIM_DEVTYPE_SWITCH 6
	686	+#define CEC_OP_PRIM_DEVTYPE_PROCESSOR 7
	687	+
	688	+#define CEC_MSG_SET_MENU_LANGUAGE 0x32
	689	+#define CEC_MSG_REPORT_FEATURES 0xa6 /* HDMI 2.0 */
	690	+/* All Device Types Operand (all_device_types) */
	691	+#define CEC_OP_ALL_DEVTYPE_TV 0x80
	692	+#define CEC_OP_ALL_DEVTYPE_RECORD 0x40
	693	+#define CEC_OP_ALL_DEVTYPE_TUNER 0x20
	694	+#define CEC_OP_ALL_DEVTYPE_PLAYBACK 0x10
	695	+#define CEC_OP_ALL_DEVTYPE_AUDIOSYSTEM 0x08
	696	+#define CEC_OP_ALL_DEVTYPE_SWITCH 0x04
	697	+/*
	698	+ * And if you wondering what happened to PROCESSOR devices: those should
	699	+ * be mapped to a SWITCH.
	700	+ */
	701	+
	702	+/* Valid for RC Profile and Device Feature operands */
	703	+#define CEC_OP_FEAT_EXT 0x80 /* Extension bit */
	704	+/* RC Profile Operand (rc_profile) */
	705	+#define CEC_OP_FEAT_RC_TV_PROFILE_NONE 0x00
	706	+#define CEC_OP_FEAT_RC_TV_PROFILE_1 0x02
	707	+#define CEC_OP_FEAT_RC_TV_PROFILE_2 0x06
	708	+#define CEC_OP_FEAT_RC_TV_PROFILE_3 0x0a
	709	+#define CEC_OP_FEAT_RC_TV_PROFILE_4 0x0e
	710	+#define CEC_OP_FEAT_RC_SRC_HAS_DEV_ROOT_MENU 0x50
	711	+#define CEC_OP_FEAT_RC_SRC_HAS_DEV_SETUP_MENU 0x48
	712	+#define CEC_OP_FEAT_RC_SRC_HAS_CONTENTS_MENU 0x44
	713	+#define CEC_OP_FEAT_RC_SRC_HAS_MEDIA_TOP_MENU 0x42
	714	+#define CEC_OP_FEAT_RC_SRC_HAS_MEDIA_CONTEXT_MENU 0x41
	715	+/* Device Feature Operand (dev_features) */
	716	+#define CEC_OP_FEAT_DEV_HAS_RECORD_TV_SCREEN 0x40
	717	+#define CEC_OP_FEAT_DEV_HAS_SET_OSD_STRING 0x20
	718	+#define CEC_OP_FEAT_DEV_HAS_DECK_CONTROL 0x10
	719	+#define CEC_OP_FEAT_DEV_HAS_SET_AUDIO_RATE 0x08
	720	+#define CEC_OP_FEAT_DEV_SINK_HAS_ARC_TX 0x04
	721	+#define CEC_OP_FEAT_DEV_SOURCE_HAS_ARC_RX 0x02
	722	+
	723	+#define CEC_MSG_GIVE_FEATURES 0xa5 /* HDMI 2.0 */
	724	+
	725	+
	726	+/* Deck Control Feature */
	727	+#define CEC_MSG_DECK_CONTROL 0x42
	728	+/* Deck Control Mode Operand (deck_control_mode) */
	729	+#define CEC_OP_DECK_CTL_MODE_SKIP_FWD 1
	730	+#define CEC_OP_DECK_CTL_MODE_SKIP_REV 2
	731	+#define CEC_OP_DECK_CTL_MODE_STOP 3
	732	+#define CEC_OP_DECK_CTL_MODE_EJECT 4
	733	+
	734	+#define CEC_MSG_DECK_STATUS 0x1b
	735	+/* Deck Info Operand (deck_info) */
	736	+#define CEC_OP_DECK_INFO_PLAY 0x11
	737	+#define CEC_OP_DECK_INFO_RECORD 0x12
	738	+#define CEC_OP_DECK_INFO_PLAY_REV 0x13
	739	+#define CEC_OP_DECK_INFO_STILL 0x14
	740	+#define CEC_OP_DECK_INFO_SLOW 0x15
	741	+#define CEC_OP_DECK_INFO_SLOW_REV 0x16
	742	+#define CEC_OP_DECK_INFO_FAST_FWD 0x17
	743	+#define CEC_OP_DECK_INFO_FAST_REV 0x18
	744	+#define CEC_OP_DECK_INFO_NO_MEDIA 0x19
	745	+#define CEC_OP_DECK_INFO_STOP 0x1a
	746	+#define CEC_OP_DECK_INFO_SKIP_FWD 0x1b
	747	+#define CEC_OP_DECK_INFO_SKIP_REV 0x1c
	748	+#define CEC_OP_DECK_INFO_INDEX_SEARCH_FWD 0x1d
	749	+#define CEC_OP_DECK_INFO_INDEX_SEARCH_REV 0x1e
	750	+#define CEC_OP_DECK_INFO_OTHER 0x1f
	751	+
	752	+#define CEC_MSG_GIVE_DECK_STATUS 0x1a
	753	+/* Status Request Operand (status_req) */
	754	+#define CEC_OP_STATUS_REQ_ON 1
	755	+#define CEC_OP_STATUS_REQ_OFF 2
	756	+#define CEC_OP_STATUS_REQ_ONCE 3
	757	+
	758	+#define CEC_MSG_PLAY 0x41
	759	+/* Play Mode Operand (play_mode) */
	760	+#define CEC_OP_PLAY_MODE_PLAY_FWD 0x24
	761	+#define CEC_OP_PLAY_MODE_PLAY_REV 0x20
	762	+#define CEC_OP_PLAY_MODE_PLAY_STILL 0x25
	763	+#define CEC_OP_PLAY_MODE_PLAY_FAST_FWD_MIN 0x05
	764	+#define CEC_OP_PLAY_MODE_PLAY_FAST_FWD_MED 0x06
	765	+#define CEC_OP_PLAY_MODE_PLAY_FAST_FWD_MAX 0x07
	766	+#define CEC_OP_PLAY_MODE_PLAY_FAST_REV_MIN 0x09
	767	+#define CEC_OP_PLAY_MODE_PLAY_FAST_REV_MED 0x0a
	768	+#define CEC_OP_PLAY_MODE_PLAY_FAST_REV_MAX 0x0b
	769	+#define CEC_OP_PLAY_MODE_PLAY_SLOW_FWD_MIN 0x15
	770	+#define CEC_OP_PLAY_MODE_PLAY_SLOW_FWD_MED 0x16
	771	+#define CEC_OP_PLAY_MODE_PLAY_SLOW_FWD_MAX 0x17
	772	+#define CEC_OP_PLAY_MODE_PLAY_SLOW_REV_MIN 0x19
	773	+#define CEC_OP_PLAY_MODE_PLAY_SLOW_REV_MED 0x1a
	774	+#define CEC_OP_PLAY_MODE_PLAY_SLOW_REV_MAX 0x1b
	775	+
	776	+
	777	+/* Tuner Control Feature */
	778	+#define CEC_MSG_GIVE_TUNER_DEVICE_STATUS 0x08
	779	+#define CEC_MSG_SELECT_ANALOGUE_SERVICE 0x92
	780	+#define CEC_MSG_SELECT_DIGITAL_SERVICE 0x93
	781	+#define CEC_MSG_TUNER_DEVICE_STATUS 0x07
	782	+/* Recording Flag Operand (rec_flag) */
	783	+#define CEC_OP_REC_FLAG_USED 0
	784	+#define CEC_OP_REC_FLAG_NOT_USED 1
	785	+/* Tuner Display Info Operand (tuner_display_info) */
	786	+#define CEC_OP_TUNER_DISPLAY_INFO_DIGITAL 0
	787	+#define CEC_OP_TUNER_DISPLAY_INFO_NONE 1
	788	+#define CEC_OP_TUNER_DISPLAY_INFO_ANALOGUE 2
	789	+
	790	+#define CEC_MSG_TUNER_STEP_DECREMENT 0x06
	791	+#define CEC_MSG_TUNER_STEP_INCREMENT 0x05
	792	+
	793	+
	794	+/* Vendor Specific Commands Feature */
	795	+
	796	+/*
	797	+ * Has also:
	798	+ * CEC_MSG_CEC_VERSION
	799	+ * CEC_MSG_GET_CEC_VERSION
	800	+ */
	801	+#define CEC_MSG_DEVICE_VENDOR_ID 0x87
	802	+#define CEC_MSG_GIVE_DEVICE_VENDOR_ID 0x8c
	803	+#define CEC_MSG_VENDOR_COMMAND 0x89
	804	+#define CEC_MSG_VENDOR_COMMAND_WITH_ID 0xa0
	805	+#define CEC_MSG_VENDOR_REMOTE_BUTTON_DOWN 0x8a
	806	+#define CEC_MSG_VENDOR_REMOTE_BUTTON_UP 0x8b
	807	+
	808	+
	809	+/* OSD Display Feature */
	810	+#define CEC_MSG_SET_OSD_STRING 0x64
	811	+/* Display Control Operand (disp_ctl) */
	812	+#define CEC_OP_DISP_CTL_DEFAULT 0x00
	813	+#define CEC_OP_DISP_CTL_UNTIL_CLEARED 0x40
	814	+#define CEC_OP_DISP_CTL_CLEAR 0x80
	815	+
	816	+
	817	+/* Device OSD Transfer Feature */
	818	+#define CEC_MSG_GIVE_OSD_NAME 0x46
	819	+#define CEC_MSG_SET_OSD_NAME 0x47
	820	+
	821	+
	822	+/* Device Menu Control Feature */
	823	+#define CEC_MSG_MENU_REQUEST 0x8d
	824	+/* Menu Request Type Operand (menu_req) */
	825	+#define CEC_OP_MENU_REQUEST_ACTIVATE 0x00
	826	+#define CEC_OP_MENU_REQUEST_DEACTIVATE 0x01
	827	+#define CEC_OP_MENU_REQUEST_QUERY 0x02
	828	+
	829	+#define CEC_MSG_MENU_STATUS 0x8e
	830	+/* Menu State Operand (menu_state) */
	831	+#define CEC_OP_MENU_STATE_ACTIVATED 0x00
	832	+#define CEC_OP_MENU_STATE_DEACTIVATED 0x01
	833	+
	834	+#define CEC_MSG_USER_CONTROL_PRESSED 0x44
	835	+/* UI Broadcast Type Operand (ui_bcast_type) */
	836	+#define CEC_OP_UI_BCAST_TYPE_TOGGLE_ALL 0x00
	837	+#define CEC_OP_UI_BCAST_TYPE_TOGGLE_DIG_ANA 0x01
	838	+#define CEC_OP_UI_BCAST_TYPE_ANALOGUE 0x10
	839	+#define CEC_OP_UI_BCAST_TYPE_ANALOGUE_T 0x20
	840	+#define CEC_OP_UI_BCAST_TYPE_ANALOGUE_CABLE 0x30
	841	+#define CEC_OP_UI_BCAST_TYPE_ANALOGUE_SAT 0x40
	842	+#define CEC_OP_UI_BCAST_TYPE_DIGITAL 0x50
	843	+#define CEC_OP_UI_BCAST_TYPE_DIGITAL_T 0x60
	844	+#define CEC_OP_UI_BCAST_TYPE_DIGITAL_CABLE 0x70
	845	+#define CEC_OP_UI_BCAST_TYPE_DIGITAL_SAT 0x80
	846	+#define CEC_OP_UI_BCAST_TYPE_DIGITAL_COM_SAT 0x90
	847	+#define CEC_OP_UI_BCAST_TYPE_DIGITAL_COM_SAT2 0x91
	848	+#define CEC_OP_UI_BCAST_TYPE_IP 0xa0
	849	+/* UI Sound Presentation Control Operand (ui_snd_pres_ctl) */
	850	+#define CEC_OP_UI_SND_PRES_CTL_DUAL_MONO 0x10
	851	+#define CEC_OP_UI_SND_PRES_CTL_KARAOKE 0x20
	852	+#define CEC_OP_UI_SND_PRES_CTL_DOWNMIX 0x80
	853	+#define CEC_OP_UI_SND_PRES_CTL_REVERB 0x90
	854	+#define CEC_OP_UI_SND_PRES_CTL_EQUALIZER 0xa0
	855	+#define CEC_OP_UI_SND_PRES_CTL_BASS_UP 0xb1
	856	+#define CEC_OP_UI_SND_PRES_CTL_BASS_NEUTRAL 0xb2
	857	+#define CEC_OP_UI_SND_PRES_CTL_BASS_DOWN 0xb3
	858	+#define CEC_OP_UI_SND_PRES_CTL_TREBLE_UP 0xc1
	859	+#define CEC_OP_UI_SND_PRES_CTL_TREBLE_NEUTRAL 0xc2
	860	+#define CEC_OP_UI_SND_PRES_CTL_TREBLE_DOWN 0xc3
	861	+
	862	+#define CEC_MSG_USER_CONTROL_RELEASED 0x45
	863	+
	864	+
	865	+/* Remote Control Passthrough Feature */
	866	+
	867	+/*
	868	+ * Has also:
	869	+ * CEC_MSG_USER_CONTROL_PRESSED
	870	+ * CEC_MSG_USER_CONTROL_RELEASED
	871	+ */
	872	+
	873	+
	874	+/* Power Status Feature */
	875	+#define CEC_MSG_GIVE_DEVICE_POWER_STATUS 0x8f
	876	+#define CEC_MSG_REPORT_POWER_STATUS 0x90
	877	+/* Power Status Operand (pwr_state) */
	878	+#define CEC_OP_POWER_STATUS_ON 0
	879	+#define CEC_OP_POWER_STATUS_STANDBY 1
	880	+#define CEC_OP_POWER_STATUS_TO_ON 2
	881	+#define CEC_OP_POWER_STATUS_TO_STANDBY 3
	882	+
	883	+
	884	+/* General Protocol Messages */
	885	+#define CEC_MSG_FEATURE_ABORT 0x00
	886	+/* Abort Reason Operand (reason) */
	887	+#define CEC_OP_ABORT_UNRECOGNIZED_OP 0
	888	+#define CEC_OP_ABORT_INCORRECT_MODE 1
	889	+#define CEC_OP_ABORT_NO_SOURCE 2
	890	+#define CEC_OP_ABORT_INVALID_OP 3
	891	+#define CEC_OP_ABORT_REFUSED 4
	892	+#define CEC_OP_ABORT_UNDETERMINED 5
	893	+
	894	+#define CEC_MSG_ABORT 0xff
	895	+
	896	+
	897	+/* System Audio Control Feature */
	898	+
	899	+/*
	900	+ * Has also:
	901	+ * CEC_MSG_USER_CONTROL_PRESSED
	902	+ * CEC_MSG_USER_CONTROL_RELEASED
	903	+ */
	904	+#define CEC_MSG_GIVE_AUDIO_STATUS 0x71
	905	+#define CEC_MSG_GIVE_SYSTEM_AUDIO_MODE_STATUS 0x7d
	906	+#define CEC_MSG_REPORT_AUDIO_STATUS 0x7a
	907	+/* Audio Mute Status Operand (aud_mute_status) */
	908	+#define CEC_OP_AUD_MUTE_STATUS_OFF 0
	909	+#define CEC_OP_AUD_MUTE_STATUS_ON 1
	910	+
	911	+#define CEC_MSG_REPORT_SHORT_AUDIO_DESCRIPTOR 0xa3
	912	+#define CEC_MSG_REQUEST_SHORT_AUDIO_DESCRIPTOR 0xa4
	913	+#define CEC_MSG_SET_SYSTEM_AUDIO_MODE 0x72
	914	+/* System Audio Status Operand (sys_aud_status) */
	915	+#define CEC_OP_SYS_AUD_STATUS_OFF 0
	916	+#define CEC_OP_SYS_AUD_STATUS_ON 1
	917	+
	918	+#define CEC_MSG_SYSTEM_AUDIO_MODE_REQUEST 0x70
	919	+#define CEC_MSG_SYSTEM_AUDIO_MODE_STATUS 0x7e
	920	+/* Audio Format ID Operand (audio_format_id) */
	921	+#define CEC_OP_AUD_FMT_ID_CEA861 0
	922	+#define CEC_OP_AUD_FMT_ID_CEA861_CXT 1
	923	+
	924	+
	925	+/* Audio Rate Control Feature */
	926	+#define CEC_MSG_SET_AUDIO_RATE 0x9a
	927	+/* Audio Rate Operand (audio_rate) */
	928	+#define CEC_OP_AUD_RATE_OFF 0
	929	+#define CEC_OP_AUD_RATE_WIDE_STD 1
	930	+#define CEC_OP_AUD_RATE_WIDE_FAST 2
	931	+#define CEC_OP_AUD_RATE_WIDE_SLOW 3
	932	+#define CEC_OP_AUD_RATE_NARROW_STD 4
	933	+#define CEC_OP_AUD_RATE_NARROW_FAST 5
	934	+#define CEC_OP_AUD_RATE_NARROW_SLOW 6
	935	+
	936	+
	937	+/* Audio Return Channel Control Feature */
	938	+#define CEC_MSG_INITIATE_ARC 0xc0
	939	+#define CEC_MSG_REPORT_ARC_INITIATED 0xc1
	940	+#define CEC_MSG_REPORT_ARC_TERMINATED 0xc2
	941	+#define CEC_MSG_REQUEST_ARC_INITIATION 0xc3
	942	+#define CEC_MSG_REQUEST_ARC_TERMINATION 0xc4
	943	+#define CEC_MSG_TERMINATE_ARC 0xc5
	944	+
	945	+
	946	+/* Dynamic Audio Lipsync Feature */
	947	+/* Only for CEC 2.0 and up */
	948	+#define CEC_MSG_REQUEST_CURRENT_LATENCY 0xa7
	949	+#define CEC_MSG_REPORT_CURRENT_LATENCY 0xa8
	950	+/* Low Latency Mode Operand (low_latency_mode) */
	951	+#define CEC_OP_LOW_LATENCY_MODE_OFF 0
	952	+#define CEC_OP_LOW_LATENCY_MODE_ON 1
	953	+/* Audio Output Compensated Operand (audio_out_compensated) */
	954	+#define CEC_OP_AUD_OUT_COMPENSATED_NA 0
	955	+#define CEC_OP_AUD_OUT_COMPENSATED_DELAY 1
	956	+#define CEC_OP_AUD_OUT_COMPENSATED_NO_DELAY 2
	957	+#define CEC_OP_AUD_OUT_COMPENSATED_PARTIAL_DELAY 3
	958	+
	959	+
	960	+/* Capability Discovery and Control Feature */
	961	+#define CEC_MSG_CDC_MESSAGE 0xf8
	962	+/* Ethernet-over-HDMI: nobody ever does this... */
	963	+#define CEC_MSG_CDC_HEC_INQUIRE_STATE 0x00
	964	+#define CEC_MSG_CDC_HEC_REPORT_STATE 0x01
	965	+/* HEC Functionality State Operand (hec_func_state) */
	966	+#define CEC_OP_HEC_FUNC_STATE_NOT_SUPPORTED 0
	967	+#define CEC_OP_HEC_FUNC_STATE_INACTIVE 1
	968	+#define CEC_OP_HEC_FUNC_STATE_ACTIVE 2
	969	+#define CEC_OP_HEC_FUNC_STATE_ACTIVATION_FIELD 3
	970	+/* Host Functionality State Operand (host_func_state) */
	971	+#define CEC_OP_HOST_FUNC_STATE_NOT_SUPPORTED 0
	972	+#define CEC_OP_HOST_FUNC_STATE_INACTIVE 1
	973	+#define CEC_OP_HOST_FUNC_STATE_ACTIVE 2
	974	+/* ENC Functionality State Operand (enc_func_state) */
	975	+#define CEC_OP_ENC_FUNC_STATE_EXT_CON_NOT_SUPPORTED 0
	976	+#define CEC_OP_ENC_FUNC_STATE_EXT_CON_INACTIVE 1
	977	+#define CEC_OP_ENC_FUNC_STATE_EXT_CON_ACTIVE 2
	978	+/* CDC Error Code Operand (cdc_errcode) */
	979	+#define CEC_OP_CDC_ERROR_CODE_NONE 0
	980	+#define CEC_OP_CDC_ERROR_CODE_CAP_UNSUPPORTED 1
	981	+#define CEC_OP_CDC_ERROR_CODE_WRONG_STATE 2
	982	+#define CEC_OP_CDC_ERROR_CODE_OTHER 3
	983	+/* HEC Support Operand (hec_support) */
	984	+#define CEC_OP_HEC_SUPPORT_NO 0
	985	+#define CEC_OP_HEC_SUPPORT_YES 1
	986	+/* HEC Activation Operand (hec_activation) */
	987	+#define CEC_OP_HEC_ACTIVATION_ON 0
	988	+#define CEC_OP_HEC_ACTIVATION_OFF 1
	989	+
	990	+#define CEC_MSG_CDC_HEC_SET_STATE_ADJACENT 0x02
	991	+#define CEC_MSG_CDC_HEC_SET_STATE 0x03
	992	+/* HEC Set State Operand (hec_set_state) */
	993	+#define CEC_OP_HEC_SET_STATE_DEACTIVATE 0
	994	+#define CEC_OP_HEC_SET_STATE_ACTIVATE 1
	995	+
	996	+#define CEC_MSG_CDC_HEC_REQUEST_DEACTIVATION 0x04
	997	+#define CEC_MSG_CDC_HEC_NOTIFY_ALIVE 0x05
	998	+#define CEC_MSG_CDC_HEC_DISCOVER 0x06
	999	+/* Hotplug Detect messages */
	1000	+#define CEC_MSG_CDC_HPD_SET_STATE 0x10
	1001	+/* HPD State Operand (hpd_state) */
	1002	+#define CEC_OP_HPD_STATE_CP_EDID_DISABLE 0
	1003	+#define CEC_OP_HPD_STATE_CP_EDID_ENABLE 1
	1004	+#define CEC_OP_HPD_STATE_CP_EDID_DISABLE_ENABLE 2
	1005	+#define CEC_OP_HPD_STATE_EDID_DISABLE 3
	1006	+#define CEC_OP_HPD_STATE_EDID_ENABLE 4
	1007	+#define CEC_OP_HPD_STATE_EDID_DISABLE_ENABLE 5
	1008	+#define CEC_MSG_CDC_HPD_REPORT_STATE 0x11
	1009	+/* HPD Error Code Operand (hpd_error) */
	1010	+#define CEC_OP_HPD_ERROR_NONE 0
	1011	+#define CEC_OP_HPD_ERROR_INITIATOR_NOT_CAPABLE 1
	1012	+#define CEC_OP_HPD_ERROR_INITIATOR_WRONG_STATE 2
	1013	+#define CEC_OP_HPD_ERROR_OTHER 3
	1014	+#define CEC_OP_HPD_ERROR_NONE_NO_VIDEO 4
	1015	+
	1016	+/* End of Messages */
	1017	+
	1018	+/* Helper functions to identify the 'special' CEC devices */
	1019	+
	1020	+static inline int cec_is_2nd_tv(const struct cec_log_addrs *las)
	1021	+{
	1022	+ /*
	1023	+ * It is a second TV if the logical address is 14 or 15 and the
	1024	+ * primary device type is a TV.
	1025	+ */
	1026	+ return las->num_log_addrs &&
	1027	+ las->log_addr[0] >= CEC_LOG_ADDR_SPECIFIC &&
	1028	+ las->primary_device_type[0] == CEC_OP_PRIM_DEVTYPE_TV;
	1029	+}
	1030	+
	1031	+static inline int cec_is_processor(const struct cec_log_addrs *las)
	1032	+{
	1033	+ /*
	1034	+ * It is a processor if the logical address is 12-15 and the
	1035	+ * primary device type is a Processor.
	1036	+ */
	1037	+ return las->num_log_addrs &&
	1038	+ las->log_addr[0] >= CEC_LOG_ADDR_BACKUP_1 &&
	1039	+ las->primary_device_type[0] == CEC_OP_PRIM_DEVTYPE_PROCESSOR;
	1040	+}
	1041	+
	1042	+static inline int cec_is_switch(const struct cec_log_addrs *las)
	1043	+{
	1044	+ /*
	1045	+ * It is a switch if the logical address is 15 and the
	1046	+ * primary device type is a Switch and the CDC-Only flag is not set.
	1047	+ */
	1048	+ return las->num_log_addrs == 1 &&
	1049	+ las->log_addr[0] == CEC_LOG_ADDR_UNREGISTERED &&
	1050	+ las->primary_device_type[0] == CEC_OP_PRIM_DEVTYPE_SWITCH &&
	1051	+ !(las->flags & CEC_LOG_ADDRS_FL_CDC_ONLY);
	1052	+}
	1053	+
	1054	+static inline int cec_is_cdc_only(const struct cec_log_addrs *las)
	1055	+{
	1056	+ /*
	1057	+ * It is a CDC-only device if the logical address is 15 and the
	1058	+ * primary device type is a Switch and the CDC-Only flag is set.
	1059	+ */
	1060	+ return las->num_log_addrs == 1 &&
	1061	+ las->log_addr[0] == CEC_LOG_ADDR_UNREGISTERED &&
	1062	+ las->primary_device_type[0] == CEC_OP_PRIM_DEVTYPE_SWITCH &&
	1063	+ (las->flags & CEC_LOG_ADDRS_FL_CDC_ONLY);
	1064	+}
	1065	+
	1066	+#endif

include/uapi/linux/v4l2-controls.h+1−0

@@ -892,6 +892,7 @@ enum v4l2_jpeg_chroma_subsampling { · 891 unmodified lines
892	892	#define V4L2_CID_LINK_FREQ (V4L2_CID_IMAGE_PROC_CLASS_BASE + 1)
893	893	#define V4L2_CID_PIXEL_RATE (V4L2_CID_IMAGE_PROC_CLASS_BASE + 2)
894	894	#define V4L2_CID_TEST_PATTERN (V4L2_CID_IMAGE_PROC_CLASS_BASE + 3)
	895	+#define V4L2_CID_DEINTERLACING_MODE (V4L2_CID_IMAGE_PROC_CLASS_BASE + 4)
895	896
896	897
897	898	/* DV-class control IDs defined by V4L2 */

include/uapi/linux/v4l2-dv-timings.h+63−34

@@ -1,7 +1,7 @@
1	1	/*
2	2	* V4L2 DV timings header.
3	3	*
4		− * Copyright (C) 2012 Hans Verkuil <hans.verkuil@cisco.com>
	4	+ * Copyright (C) 2012-2016 Hans Verkuil <hans.verkuil@cisco.com>
5	5	*
6	6	* This program is free software; you can redistribute it and/or
7	7	* modify it under the terms of the GNU General Public License
@@ -11,11 +11,6 @@ · 3 unmodified lines
11	11	* WITHOUT ANY WARRANTY; without even the implied warranty of
12	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13	13	* General Public License for more details.
14		− *
15		− * You should have received a copy of the GNU General Public License
16		− * along with this program; if not, write to the Free Software
17		− * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18		− * 02110-1301 USA
19	14	*/
20	15
21	16	#ifndef _V4L2_DV_TIMINGS_H
@@ -33,13 +28,14 @@ · 11 unmodified lines
33	28	.bt = { _width , ## args }
34	29	#endif
35	30
36		−/* CEA-861-E timings (i.e. standard HDTV timings) */
	31	+/* CEA-861-F timings (i.e. standard HDTV timings) */
37	32
38	33	#define V4L2_DV_BT_CEA_640X480P59_94 { \
39	34	.type = V4L2_DV_BT_656_1120, \
40	35	V4L2_INIT_BT_TIMINGS(640, 480, 0, 0, \
41	36	25175000, 16, 96, 48, 10, 2, 33, 0, 0, 0, \
42		− V4L2_DV_BT_STD_DMT \| V4L2_DV_BT_STD_CEA861, 0) \
	37	+ V4L2_DV_BT_STD_DMT \| V4L2_DV_BT_STD_CEA861, \
	38	+ V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 1) \
43	39	}
44	40
45	41	/* Note: these are the nominal timings, for HDMI links this format is typically
@@ -49,14 +45,18 @@ · 3 unmodified lines
49	45	V4L2_INIT_BT_TIMINGS(720, 480, 1, 0, \
50	46	13500000, 19, 62, 57, 4, 3, 15, 4, 3, 16, \
51	47	V4L2_DV_BT_STD_CEA861, \
52		− V4L2_DV_FL_HALF_LINE \| V4L2_DV_FL_IS_CE_VIDEO) \
	48	+ V4L2_DV_FL_HALF_LINE \| V4L2_DV_FL_IS_CE_VIDEO \| \
	49	+ V4L2_DV_FL_HAS_PICTURE_ASPECT \| V4L2_DV_FL_HAS_CEA861_VIC, \
	50	+ { 4, 3 }, 6) \
53	51	}
54	52
55	53	#define V4L2_DV_BT_CEA_720X480P59_94 { \
56	54	.type = V4L2_DV_BT_656_1120, \
57	55	V4L2_INIT_BT_TIMINGS(720, 480, 0, 0, \
58	56	27000000, 16, 62, 60, 9, 6, 30, 0, 0, 0, \
59		− V4L2_DV_BT_STD_CEA861, V4L2_DV_FL_IS_CE_VIDEO) \
	57	+ V4L2_DV_BT_STD_CEA861, \
	58	+ V4L2_DV_FL_IS_CE_VIDEO \| V4L2_DV_FL_HAS_PICTURE_ASPECT \| \
	59	+ V4L2_DV_FL_HAS_CEA861_VIC, { 4, 3 }, 2) \
60	60	}
61	61
62	62	/* Note: these are the nominal timings, for HDMI links this format is typically
@@ -66,14 +66,18 @@ · 3 unmodified lines
66	66	V4L2_INIT_BT_TIMINGS(720, 576, 1, 0, \
67	67	13500000, 12, 63, 69, 2, 3, 19, 2, 3, 20, \
68	68	V4L2_DV_BT_STD_CEA861, \
69		− V4L2_DV_FL_HALF_LINE \| V4L2_DV_FL_IS_CE_VIDEO) \
	69	+ V4L2_DV_FL_HALF_LINE \| V4L2_DV_FL_IS_CE_VIDEO \| \
	70	+ V4L2_DV_FL_HAS_PICTURE_ASPECT \| V4L2_DV_FL_HAS_CEA861_VIC, \
	71	+ { 4, 3 }, 21) \
70	72	}
71	73
72	74	#define V4L2_DV_BT_CEA_720X576P50 { \
73	75	.type = V4L2_DV_BT_656_1120, \
74	76	V4L2_INIT_BT_TIMINGS(720, 576, 0, 0, \
75	77	27000000, 12, 64, 68, 5, 5, 39, 0, 0, 0, \
76		− V4L2_DV_BT_STD_CEA861, V4L2_DV_FL_IS_CE_VIDEO) \
	78	+ V4L2_DV_BT_STD_CEA861, \
	79	+ V4L2_DV_FL_IS_CE_VIDEO \| V4L2_DV_FL_HAS_PICTURE_ASPECT \| \
	80	+ V4L2_DV_FL_HAS_CEA861_VIC, { 4, 3 }, 17) \
77	81	}
78	82
79	83	#define V4L2_DV_BT_CEA_1280X720P24 { \
@@ -82,7 +86,7 @@ · 2 unmodified lines
82	86	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
83	87	59400000, 1760, 40, 220, 5, 5, 20, 0, 0, 0, \
84	88	V4L2_DV_BT_STD_DMT \| V4L2_DV_BT_STD_CEA861, \
85		− V4L2_DV_FL_CAN_REDUCE_FPS) \
	89	+ V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 60) \
86	90	}
87	91
88	92	#define V4L2_DV_BT_CEA_1280X720P25 { \
@@ -90,7 +94,8 @@ · 1 unmodified line
90	94	V4L2_INIT_BT_TIMINGS(1280, 720, 0, \
91	95	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
92	96	74250000, 2420, 40, 220, 5, 5, 20, 0, 0, 0, \
93		− V4L2_DV_BT_STD_CEA861, V4L2_DV_FL_IS_CE_VIDEO) \
	97	+ V4L2_DV_BT_STD_CEA861, \
	98	+ V4L2_DV_FL_IS_CE_VIDEO \| V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 61) \
94	99	}
95	100
96	101	#define V4L2_DV_BT_CEA_1280X720P30 { \
@@ -99,7 +104,8 @@ · 2 unmodified lines
99	104	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
100	105	74250000, 1760, 40, 220, 5, 5, 20, 0, 0, 0, \
101	106	V4L2_DV_BT_STD_CEA861, \
102		− V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO) \
	107	+ V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO \| \
	108	+ V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 62) \
103	109	}
104	110
105	111	#define V4L2_DV_BT_CEA_1280X720P50 { \
@@ -107,7 +113,8 @@ · 1 unmodified line
107	113	V4L2_INIT_BT_TIMINGS(1280, 720, 0, \
108	114	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
109	115	74250000, 440, 40, 220, 5, 5, 20, 0, 0, 0, \
110		− V4L2_DV_BT_STD_CEA861, V4L2_DV_FL_IS_CE_VIDEO) \
	116	+ V4L2_DV_BT_STD_CEA861, \
	117	+ V4L2_DV_FL_IS_CE_VIDEO \| V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 19) \
111	118	}
112	119
113	120	#define V4L2_DV_BT_CEA_1280X720P60 { \
@@ -116,7 +123,8 @@ · 2 unmodified lines
116	123	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
117	124	74250000, 110, 40, 220, 5, 5, 20, 0, 0, 0, \
118	125	V4L2_DV_BT_STD_CEA861, \
119		− V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO) \
	126	+ V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO \| \
	127	+ V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 4) \
120	128	}
121	129
122	130	#define V4L2_DV_BT_CEA_1920X1080P24 { \
@@ -125,7 +133,8 @@ · 2 unmodified lines
125	133	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
126	134	74250000, 638, 44, 148, 4, 5, 36, 0, 0, 0, \
127	135	V4L2_DV_BT_STD_CEA861, \
128		− V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO) \
	136	+ V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO \| \
	137	+ V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 32) \
129	138	}
130	139
131	140	#define V4L2_DV_BT_CEA_1920X1080P25 { \
@@ -133,7 +142,8 @@ · 1 unmodified line
133	142	V4L2_INIT_BT_TIMINGS(1920, 1080, 0, \
134	143	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
135	144	74250000, 528, 44, 148, 4, 5, 36, 0, 0, 0, \
136		− V4L2_DV_BT_STD_CEA861, V4L2_DV_FL_IS_CE_VIDEO) \
	145	+ V4L2_DV_BT_STD_CEA861, \
	146	+ V4L2_DV_FL_IS_CE_VIDEO \| V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 33) \
137	147	}
138	148
139	149	#define V4L2_DV_BT_CEA_1920X1080P30 { \
@@ -142,7 +152,8 @@ · 2 unmodified lines
142	152	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
143	153	74250000, 88, 44, 148, 4, 5, 36, 0, 0, 0, \
144	154	V4L2_DV_BT_STD_CEA861, \
145		− V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO) \
	155	+ V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO \| \
	156	+ V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 34) \
146	157	}
147	158
148	159	#define V4L2_DV_BT_CEA_1920X1080I50 { \
@@ -151,7 +162,8 @@ · 2 unmodified lines
151	162	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
152	163	74250000, 528, 44, 148, 2, 5, 15, 2, 5, 16, \
153	164	V4L2_DV_BT_STD_CEA861, \
154		− V4L2_DV_FL_HALF_LINE \| V4L2_DV_FL_IS_CE_VIDEO) \
	165	+ V4L2_DV_FL_HALF_LINE \| V4L2_DV_FL_IS_CE_VIDEO \| \
	166	+ V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 20) \
155	167	}
156	168
157	169	#define V4L2_DV_BT_CEA_1920X1080P50 { \
@@ -159,7 +171,8 @@ · 1 unmodified line
159	171	V4L2_INIT_BT_TIMINGS(1920, 1080, 0, \
160	172	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
161	173	148500000, 528, 44, 148, 4, 5, 36, 0, 0, 0, \
162		− V4L2_DV_BT_STD_CEA861, V4L2_DV_FL_IS_CE_VIDEO) \
	174	+ V4L2_DV_BT_STD_CEA861, \
	175	+ V4L2_DV_FL_IS_CE_VIDEO \| V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 31) \
163	176	}
164	177
165	178	#define V4L2_DV_BT_CEA_1920X1080I60 { \
@@ -169,7 +182,8 @@ · 3 unmodified lines
169	182	74250000, 88, 44, 148, 2, 5, 15, 2, 5, 16, \
170	183	V4L2_DV_BT_STD_CEA861, \
171	184	V4L2_DV_FL_CAN_REDUCE_FPS \| \
172		− V4L2_DV_FL_HALF_LINE \| V4L2_DV_FL_IS_CE_VIDEO) \
	185	+ V4L2_DV_FL_HALF_LINE \| V4L2_DV_FL_IS_CE_VIDEO \| \
	186	+ V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 5) \
173	187	}
174	188
175	189	#define V4L2_DV_BT_CEA_1920X1080P60 { \
@@ -178,7 +192,8 @@ · 2 unmodified lines
178	192	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
179	193	148500000, 88, 44, 148, 4, 5, 36, 0, 0, 0, \
180	194	V4L2_DV_BT_STD_DMT \| V4L2_DV_BT_STD_CEA861, \
181		− V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO) \
	195	+ V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO \| \
	196	+ V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 16) \
182	197	}
183	198
184	199	#define V4L2_DV_BT_CEA_3840X2160P24 { \
@@ -187,7 +202,9 @@ · 2 unmodified lines
187	202	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
188	203	297000000, 1276, 88, 296, 8, 10, 72, 0, 0, 0, \
189	204	V4L2_DV_BT_STD_CEA861, \
190		− V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO) \
	205	+ V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO \| \
	206	+ V4L2_DV_FL_HAS_CEA861_VIC \| V4L2_DV_FL_HAS_HDMI_VIC, \
	207	+ { 0, 0 }, 93, 3) \
191	208	}
192	209
193	210	#define V4L2_DV_BT_CEA_3840X2160P25 { \
@@ -195,7 +212,9 @@ · 1 unmodified line
195	212	V4L2_INIT_BT_TIMINGS(3840, 2160, 0, \
196	213	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
197	214	297000000, 1056, 88, 296, 8, 10, 72, 0, 0, 0, \
198		− V4L2_DV_BT_STD_CEA861, V4L2_DV_FL_IS_CE_VIDEO) \
	215	+ V4L2_DV_BT_STD_CEA861, \
	216	+ V4L2_DV_FL_IS_CE_VIDEO \| V4L2_DV_FL_HAS_CEA861_VIC \| \
	217	+ V4L2_DV_FL_HAS_HDMI_VIC, { 0, 0 }, 94, 2) \
199	218	}
200	219
201	220	#define V4L2_DV_BT_CEA_3840X2160P30 { \
@@ -204,7 +223,9 @@ · 2 unmodified lines
204	223	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
205	224	297000000, 176, 88, 296, 8, 10, 72, 0, 0, 0, \
206	225	V4L2_DV_BT_STD_CEA861, \
207		− V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO) \
	226	+ V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO \| \
	227	+ V4L2_DV_FL_HAS_CEA861_VIC \| V4L2_DV_FL_HAS_HDMI_VIC, \
	228	+ { 0, 0 }, 95, 1) \
208	229	}
209	230
210	231	#define V4L2_DV_BT_CEA_3840X2160P50 { \
@@ -212,7 +233,8 @@ · 1 unmodified line
212	233	V4L2_INIT_BT_TIMINGS(3840, 2160, 0, \
213	234	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
214	235	594000000, 1056, 88, 296, 8, 10, 72, 0, 0, 0, \
215		− V4L2_DV_BT_STD_CEA861, V4L2_DV_FL_IS_CE_VIDEO) \
	236	+ V4L2_DV_BT_STD_CEA861, \
	237	+ V4L2_DV_FL_IS_CE_VIDEO \| V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 96) \
216	238	}
217	239
218	240	#define V4L2_DV_BT_CEA_3840X2160P60 { \
@@ -221,7 +243,8 @@ · 2 unmodified lines
221	243	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
222	244	594000000, 176, 88, 296, 8, 10, 72, 0, 0, 0, \
223	245	V4L2_DV_BT_STD_CEA861, \
224		− V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO) \
	246	+ V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO \| \
	247	+ V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 97) \
225	248	}
226	249
227	250	#define V4L2_DV_BT_CEA_4096X2160P24 { \
@@ -230,7 +253,9 @@ · 2 unmodified lines
230	253	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
231	254	297000000, 1020, 88, 296, 8, 10, 72, 0, 0, 0, \
232	255	V4L2_DV_BT_STD_CEA861, \
233		− V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO) \
	256	+ V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO \| \
	257	+ V4L2_DV_FL_HAS_CEA861_VIC \| V4L2_DV_FL_HAS_HDMI_VIC, \
	258	+ { 0, 0 }, 98, 4) \
234	259	}
235	260
236	261	#define V4L2_DV_BT_CEA_4096X2160P25 { \
@@ -238,7 +263,8 @@ · 1 unmodified line
238	263	V4L2_INIT_BT_TIMINGS(4096, 2160, 0, \
239	264	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
240	265	297000000, 968, 88, 128, 8, 10, 72, 0, 0, 0, \
241		− V4L2_DV_BT_STD_CEA861, V4L2_DV_FL_IS_CE_VIDEO) \
	266	+ V4L2_DV_BT_STD_CEA861, \
	267	+ V4L2_DV_FL_IS_CE_VIDEO \| V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 99) \
242	268	}
243	269
244	270	#define V4L2_DV_BT_CEA_4096X2160P30 { \
@@ -247,7 +273,8 @@ · 2 unmodified lines
247	273	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
248	274	297000000, 88, 88, 128, 8, 10, 72, 0, 0, 0, \
249	275	V4L2_DV_BT_STD_CEA861, \
250		− V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO) \
	276	+ V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO \| \
	277	+ V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 100) \
251	278	}
252	279
253	280	#define V4L2_DV_BT_CEA_4096X2160P50 { \
@@ -255,7 +282,8 @@ · 1 unmodified line
255	282	V4L2_INIT_BT_TIMINGS(4096, 2160, 0, \
256	283	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
257	284	594000000, 968, 88, 128, 8, 10, 72, 0, 0, 0, \
258		− V4L2_DV_BT_STD_CEA861, V4L2_DV_FL_IS_CE_VIDEO) \
	285	+ V4L2_DV_BT_STD_CEA861, \
	286	+ V4L2_DV_FL_IS_CE_VIDEO \| V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 101) \
259	287	}
260	288
261	289	#define V4L2_DV_BT_CEA_4096X2160P60 { \
@@ -264,7 +292,8 @@ · 2 unmodified lines
264	292	V4L2_DV_HSYNC_POS_POL \| V4L2_DV_VSYNC_POS_POL, \
265	293	594000000, 88, 88, 128, 8, 10, 72, 0, 0, 0, \
266	294	V4L2_DV_BT_STD_CEA861, \
267		− V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO) \
	295	+ V4L2_DV_FL_CAN_REDUCE_FPS \| V4L2_DV_FL_IS_CE_VIDEO \| \
	296	+ V4L2_DV_FL_HAS_CEA861_VIC, { 0, 0 }, 102) \
268	297	}
269	298
270	299

include/uapi/linux/videodev2.h+91−27

@@ -334,6 +334,19 @@ enum v4l2_ycbcr_encoding { · 333 unmodified lines
334	334	V4L2_YCBCR_ENC_SMPTE240M = 8,
335	335	};
336	336
	337	+/*
	338	+ * enum v4l2_hsv_encoding values should not collide with the ones from
	339	+ * enum v4l2_ycbcr_encoding.
	340	+ */
	341	+enum v4l2_hsv_encoding {
	342	+
	343	+ /* Hue mapped to 0 - 179 */
	344	+ V4L2_HSV_ENC_180 = 128,
	345	+
	346	+ /* Hue mapped to 0-255 */
	347	+ V4L2_HSV_ENC_256 = 129,
	348	+};
	349	+
337	350	/*
338	351	* Determine how YCBCR_ENC_DEFAULT should map to a proper Y'CbCr encoding.
339	352	* This depends on the colorspace.
@@ -362,9 +375,10 @@ enum v4l2_quantization { · 22 unmodified lines
362	375	* This depends on whether the image is RGB or not, the colorspace and the
363	376	* Y'CbCr encoding.
364	377	*/
365		−#define V4L2_MAP_QUANTIZATION_DEFAULT(is_rgb, colsp, ycbcr_enc) \
366		− (((is_rgb) && (colsp) == V4L2_COLORSPACE_BT2020) ? V4L2_QUANTIZATION_LIM_RANGE : \
367		− (((is_rgb) \|\| (ycbcr_enc) == V4L2_YCBCR_ENC_XV601 \|\| \
	378	+#define V4L2_MAP_QUANTIZATION_DEFAULT(is_rgb_or_hsv, colsp, ycbcr_enc) \
	379	+ (((is_rgb_or_hsv) && (colsp) == V4L2_COLORSPACE_BT2020) ? \
	380	+ V4L2_QUANTIZATION_LIM_RANGE : \
	381	+ (((is_rgb_or_hsv) \|\| (ycbcr_enc) == V4L2_YCBCR_ENC_XV601 \|\| \
368	382	(ycbcr_enc) == V4L2_YCBCR_ENC_XV709 \|\| (colsp) == V4L2_COLORSPACE_JPEG) \|\| \
369	383	(colsp) == V4L2_COLORSPACE_ADOBERGB \|\| (colsp) == V4L2_COLORSPACE_SRGB ? \
370	384	V4L2_QUANTIZATION_FULL_RANGE : V4L2_QUANTIZATION_LIM_RANGE))
@@ -462,7 +476,12 @@ struct v4l2_pix_format { · 91 unmodified lines
462	476	__u32 colorspace; /* enum v4l2_colorspace */
463	477	__u32 priv; /* private data, depends on pixelformat */
464	478	__u32 flags; /* format flags (V4L2_PIX_FMT_FLAG_) /
465		− __u32 ycbcr_enc; /* enum v4l2_ycbcr_encoding */
	479	+ union {
	480	+ /* enum v4l2_ycbcr_encoding */
	481	+ __u32 ycbcr_enc;
	482	+ /* enum v4l2_hsv_encoding */
	483	+ __u32 hsv_enc;
	484	+ };
466	485	__u32 quantization; /* enum v4l2_quantization */
467	486	__u32 xfer_func; /* enum v4l2_xfer_func */
468	487	};
@@ -586,6 +605,13 @@ struct v4l2_pix_format { · 117 unmodified lines
586	605	#define V4L2_PIX_FMT_SGRBG12 v4l2_fourcc('B', 'A', '1', '2') /* 12 GRGR.. BGBG.. */
587	606	#define V4L2_PIX_FMT_SRGGB12 v4l2_fourcc('R', 'G', '1', '2') /* 12 RGRG.. GBGB.. */
588	607	#define V4L2_PIX_FMT_SBGGR16 v4l2_fourcc('B', 'Y', 'R', '2') /* 16 BGBG.. GRGR.. */
	608	+#define V4L2_PIX_FMT_SGBRG16 v4l2_fourcc('G', 'B', '1', '6') /* 16 GBGB.. RGRG.. */
	609	+#define V4L2_PIX_FMT_SGRBG16 v4l2_fourcc('G', 'R', '1', '6') /* 16 GRGR.. BGBG.. */
	610	+#define V4L2_PIX_FMT_SRGGB16 v4l2_fourcc('R', 'G', '1', '6') /* 16 RGRG.. GBGB.. */
	611	+
	612	+/* HSV formats */
	613	+#define V4L2_PIX_FMT_HSV24 v4l2_fourcc('H', 'S', 'V', '3')
	614	+#define V4L2_PIX_FMT_HSV32 v4l2_fourcc('H', 'S', 'V', '4')
589	615
590	616	/* compressed formats */
591	617	#define V4L2_PIX_FMT_MJPEG v4l2_fourcc('M', 'J', 'P', 'G') /* Motion-JPEG */
@@ -603,6 +629,7 @@ struct v4l2_pix_format { · 11 unmodified lines
603	629	#define V4L2_PIX_FMT_VC1_ANNEX_G v4l2_fourcc('V', 'C', '1', 'G') /* SMPTE 421M Annex G compliant stream */
604	630	#define V4L2_PIX_FMT_VC1_ANNEX_L v4l2_fourcc('V', 'C', '1', 'L') /* SMPTE 421M Annex L compliant stream */
605	631	#define V4L2_PIX_FMT_VP8 v4l2_fourcc('V', 'P', '8', '0') /* VP8 */
	632	+#define V4L2_PIX_FMT_VP9 v4l2_fourcc('V', 'P', '9', '0') /* VP9 */
606	633
607	634	/* Vendor-specific formats */
608	635	#define V4L2_PIX_FMT_CPIA1 v4l2_fourcc('C', 'P', 'I', 'A') /* cpia1 YUV */
@@ -634,6 +661,7 @@ struct v4l2_pix_format { · 25 unmodified lines
634	661	#define V4L2_PIX_FMT_Y8I v4l2_fourcc('Y', '8', 'I', ' ') /* Greyscale 8-bit L/R interleaved */
635	662	#define V4L2_PIX_FMT_Y12I v4l2_fourcc('Y', '1', '2', 'I') /* Greyscale 12-bit L/R interleaved */
636	663	#define V4L2_PIX_FMT_Z16 v4l2_fourcc('Z', '1', '6', ' ') /* Depth data 16-bit */
	664	+#define V4L2_PIX_FMT_MT21C v4l2_fourcc('M', 'T', '2', '1') /* Mediatek compressed block mode */
637	665
638	666	/* SDR formats - used only for Software Defined Radio devices */
639	667	#define V4L2_SDR_FMT_CU8 v4l2_fourcc('C', 'U', '0', '8') /* IQ u8 */
@@ -1229,6 +1257,9 @@ struct v4l2_standard { · 589 unmodified lines
1229	1257	* (aka field 2) of interlaced field formats
1230	1258	* @standards: Standards the timing belongs to
1231	1259	* @flags: Flags
	1260	+ * @picture_aspect: The picture aspect ratio (hor/vert).
	1261	+ * @cea861_vic: VIC code as per the CEA-861 standard.
	1262	+ * @hdmi_vic: VIC code as per the HDMI standard.
1232	1263	* @reserved: Reserved fields, must be zeroed.
1233	1264	*
1234	1265	* A note regarding vertical interlaced timings: height refers to the total
@@ -1258,7 +1289,10 @@ struct v4l2_bt_timings { · 23 unmodified lines
1258	1289	__u32 il_vbackporch;
1259	1290	__u32 standards;
1260	1291	__u32 flags;
1261		− __u32 reserved[14];
	1292	+ struct v4l2_fract picture_aspect;
	1293	+ __u8 cea861_vic;
	1294	+ __u8 hdmi_vic;
	1295	+ __u8 reserved[46];
1262	1296	} __attribute__ ((packed));
1263	1297
1264	1298	/* Interlaced or progressive format */
@@ -1278,39 +1312,66 @@ struct v4l2_bt_timings { · 13 unmodified lines
1278	1312
1279	1313	/* Flags */
1280	1314
1281		−/* CVT/GTF specific: timing uses reduced blanking (CVT) or the 'Secondary
1282		− GTF' curve (GTF). In both cases the horizontal and/or vertical blanking
1283		− intervals are reduced, allowing a higher resolution over the same
1284		− bandwidth. This is a read-only flag. */
	1315	+/*
	1316	+ * CVT/GTF specific: timing uses reduced blanking (CVT) or the 'Secondary
	1317	+ * GTF' curve (GTF). In both cases the horizontal and/or vertical blanking
	1318	+ * intervals are reduced, allowing a higher resolution over the same
	1319	+ * bandwidth. This is a read-only flag.
	1320	+ */
1285	1321	#define V4L2_DV_FL_REDUCED_BLANKING (1 << 0)
1286		−/* CEA-861 specific: set for CEA-861 formats with a framerate of a multiple
1287		− of six. These formats can be optionally played at 1 / 1.001 speed.
1288		− This is a read-only flag. */
	1322	+/*
	1323	+ * CEA-861 specific: set for CEA-861 formats with a framerate of a multiple
	1324	+ * of six. These formats can be optionally played at 1 / 1.001 speed.
	1325	+ * This is a read-only flag.
	1326	+ */
1289	1327	#define V4L2_DV_FL_CAN_REDUCE_FPS (1 << 1)
1290		−/* CEA-861 specific: only valid for video transmitters, the flag is cleared
1291		− by receivers.
1292		− If the framerate of the format is a multiple of six, then the pixelclock
1293		− used to set up the transmitter is divided by 1.001 to make it compatible
1294		− with 60 Hz based standards such as NTSC and PAL-M that use a framerate of
1295		− 29.97 Hz. Otherwise this flag is cleared. If the transmitter can't generate
1296		− such frequencies, then the flag will also be cleared. */
	1328	+/*
	1329	+ * CEA-861 specific: only valid for video transmitters, the flag is cleared
	1330	+ * by receivers.
	1331	+ * If the framerate of the format is a multiple of six, then the pixelclock
	1332	+ * used to set up the transmitter is divided by 1.001 to make it compatible
	1333	+ * with 60 Hz based standards such as NTSC and PAL-M that use a framerate of
	1334	+ * 29.97 Hz. Otherwise this flag is cleared. If the transmitter can't generate
	1335	+ * such frequencies, then the flag will also be cleared.
	1336	+ */
1297	1337	#define V4L2_DV_FL_REDUCED_FPS (1 << 2)
1298		−/* Specific to interlaced formats: if set, then field 1 is really one half-line
1299		− longer and field 2 is really one half-line shorter, so each field has
1300		− exactly the same number of half-lines. Whether half-lines can be detected
1301		− or used depends on the hardware. */
	1338	+/*
	1339	+ * Specific to interlaced formats: if set, then field 1 is really one half-line
	1340	+ * longer and field 2 is really one half-line shorter, so each field has
	1341	+ * exactly the same number of half-lines. Whether half-lines can be detected
	1342	+ * or used depends on the hardware.
	1343	+ */
1302	1344	#define V4L2_DV_FL_HALF_LINE (1 << 3)
1303		−/* If set, then this is a Consumer Electronics (CE) video format. Such formats
	1345	+/*
	1346	+ * If set, then this is a Consumer Electronics (CE) video format. Such formats
1304	1347	* differ from other formats (commonly called IT formats) in that if RGB
1305	1348	* encoding is used then by default the RGB values use limited range (i.e.
1306	1349	* use the range 16-235) as opposed to 0-255. All formats defined in CEA-861
1307		− * except for the 640x480 format are CE formats. */
	1350	+ * except for the 640x480 format are CE formats.
	1351	+ */
1308	1352	#define V4L2_DV_FL_IS_CE_VIDEO (1 << 4)
1309	1353	/* Some formats like SMPTE-125M have an interlaced signal with a odd
1310	1354	* total height. For these formats, if this flag is set, the first
1311	1355	* field has the extra line. If not, it is the second field.
1312	1356	*/
1313		−#define V4L2_DV_FL_FIRST_FIELD_EXTRA_LINE (1 << 5)
	1357	+#define V4L2_DV_FL_FIRST_FIELD_EXTRA_LINE (1 << 5)
	1358	+/*
	1359	+ * If set, then the picture_aspect field is valid. Otherwise assume that the
	1360	+ * pixels are square, so the picture aspect ratio is the same as the width to
	1361	+ * height ratio.
	1362	+ */
	1363	+#define V4L2_DV_FL_HAS_PICTURE_ASPECT (1 << 6)
	1364	+/*
	1365	+ * If set, then the cea861_vic field is valid and contains the Video
	1366	+ * Identification Code as per the CEA-861 standard.
	1367	+ */
	1368	+#define V4L2_DV_FL_HAS_CEA861_VIC (1 << 7)
	1369	+/*
	1370	+ * If set, then the hdmi_vic field is valid and contains the Video
	1371	+ * Identification Code as per the HDMI standard (HDMI Vendor Specific
	1372	+ * InfoFrame).
	1373	+ */
	1374	+#define V4L2_DV_FL_HAS_HDMI_VIC (1 << 8)
1314	1375
1315	1376	/* A few useful defines to calculate the total blanking and frame sizes */
1316	1377	#define V4L2_DV_BT_BLANKING_WIDTH(bt) \
@@ -2006,7 +2067,10 @@ struct v4l2_pix_format_mplane { · 689 unmodified lines
2006	2067	struct v4l2_plane_pix_format plane_fmt[VIDEO_MAX_PLANES];
2007	2068	__u8 num_planes;
2008	2069	__u8 flags;
2009		− __u8 ycbcr_enc;
	2070	+ union {
	2071	+ __u8 ycbcr_enc;
	2072	+ __u8 hsv_enc;
	2073	+ };
2010	2074	__u8 quantization;
2011	2075	__u8 xfer_func;
2012	2076	__u8 reserved[7];