/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2024 Dell Inc.
 *
 *	Alvin Chen <weike_chen@dell.com, vico.chern@qq.com>
 *	Zhichao Li <Zhichao1.Li@Dell.com>
 *	Pillar Liang <Pillar.Liang@Dellteam.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * UVC spec:https://www.usb.org/sites/default/files/USB_Video_Class_1_5.zip
 */

#ifndef _DEV_USB_UVC_DRV_H
#define _DEV_USB_UVC_DRV_H

#include "uvc_buf.h"

/* Vendor */
#define USB_VENDOR_ID_LOGITECH			0x046D
/* Driver */
#define UVC_DRIVER_NAME				"uvcvideo"
/* V4l2 Version */
#define	V4L_VERSION(a, b, c)			(((a) << 16) + ((b) << 8) + (c))
#define	UVC_DEVICE_NAME				"video"
/* UVC Transfer */
#define	UVC_N_TRANSFER				2
#define	UVC_N_BULKTRANSFER			3
#define UVC_N_ISOFRAMES				0x8

#define	UVCINTR_N_TRANSFER			1

/* Format flags */
#define UVC_FMT_FLAG_COMPRESSED			0x00000001
#define UVC_FMT_FLAG_STREAM			0x00000002
#define UDESCSUB_VC_HEADER			0x1
#define UDESCSUB_VC_INPUT_TERMINAL		0x2
#define UDESCSUB_VC_OUTPUT_TERMINAL		0x3
#define UDESCSUB_VC_SELECTOR_UNIT		0x4
#define UDESCSUB_VC_PROCESSING_UNIT		0x5
#define UDESCSUB_VC_EXTENSION_UNIT		0x6
/* VideoStreaming class specific interface descriptor */
#define UDESCSUB_VS_UNDEFINED			0x00
#define UDESCSUB_VS_INPUT_HEADER		0x01
#define UDESCSUB_VS_OUTPUT_HEADER		0x02
#define UDESCSUB_VS_STILL_IMAGE_FRAME		0x03
#define UDESCSUB_VS_FORMAT_UNCOMPRESSED		0x04
#define UDESCSUB_VS_FRAME_UNCOMPRESSED		0x05
#define UDESCSUB_VS_FORMAT_MJPEG		0x06
#define UDESCSUB_VS_FRAME_MJPEG			0x07
#define UDESCSUB_VS_FORMAT_MPEG2TS		0x0a
#define UDESCSUB_VS_FORMAT_DV			0x0c
#define UDESCSUB_VS_COLORFORMAT			0x0d
#define UDESCSUB_VS_FORMAT_FRAME_BASED		0x10
#define UDESCSUB_VS_FRAME_FRAME_BASED		0x11
/* VideoStreaming interface controls */
#define VS_CONTROL_UNDEFINED			0x00
#define VS_PROBE_CONTROL			0x01
#define VS_COMMIT_CONTROL			0x02
#define VS_STILL_PROBE_CONTROL			0x03
#define VS_STILL_COMMIT_CONTROL			0x04
#define VS_STILL_IMAGE_TRIGGER_CONTROL		0x05
#define VS_STREAM_ERROR_CODE_CONTROL		0x06
#define VS_GENERATE_KEY_FRAME_CONTROL		0x07
#define VS_UPDATE_FRAME_SEGMENT_CONTROL		0x08
#define VS_SYNC_DELAY_CONTROL			0x09
/* Selector Unit controls */
#define SU_CONTROL_UNDEFINED			0x00
#define SU_INPUT_SELECT_CONTROL			0x01
/* Input Terminal types */
#define UVC_ITT_VENDOR_SPECIFIC			0x0200
#define UVC_ITT_CAMERA				0x0201
#define UVC_ITT_MEDIA_TRANSPORT_INPUT		0x0202
/* Request codes */
#define RC_UNDEFINED				0x00
#define SET_CUR					0x01
#define GET_CUR					0x81
#define GET_MIN					0x82
#define GET_MAX					0x83
#define GET_RES					0x84
#define GET_LEN					0x85
#define GET_INFO				0x86
#define GET_DEF					0x87

/* A.9.1. VideoControl Interface Control Selectors */
#define UVC_VC_CONTROL_UNDEFINED                        0x00
#define UVC_VC_VIDEO_POWER_MODE_CONTROL                 0x01
#define UVC_VC_REQUEST_ERROR_CODE_CONTROL               0x02

/* A.9.2. Terminal Control Selectors */
#define UVC_TE_CONTROL_UNDEFINED                        0x00

/* A.9.3. Selector Unit Control Selectors */
#define UVC_SU_CONTROL_UNDEFINED                        0x00
#define UVC_SU_INPUT_SELECT_CONTROL                     0x01

/* A.9.4. Camera Terminal Control Selectors */
#define UVC_CT_CONTROL_UNDEFINED                        0x00
#define UVC_CT_SCANNING_MODE_CONTROL                    0x01
#define UVC_CT_AE_MODE_CONTROL                          0x02
#define UVC_CT_AE_PRIORITY_CONTROL                      0x03
#define UVC_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL           0x04
#define UVC_CT_EXPOSURE_TIME_RELATIVE_CONTROL           0x05
#define UVC_CT_FOCUS_ABSOLUTE_CONTROL                   0x06
#define UVC_CT_FOCUS_RELATIVE_CONTROL                   0x07
#define UVC_CT_FOCUS_AUTO_CONTROL                       0x08
#define UVC_CT_IRIS_ABSOLUTE_CONTROL                    0x09
#define UVC_CT_IRIS_RELATIVE_CONTROL                    0x0a
#define UVC_CT_ZOOM_ABSOLUTE_CONTROL                    0x0b
#define UVC_CT_ZOOM_RELATIVE_CONTROL                    0x0c
#define UVC_CT_PANTILT_ABSOLUTE_CONTROL                 0x0d
#define UVC_CT_PANTILT_RELATIVE_CONTROL                 0x0e
#define UVC_CT_ROLL_ABSOLUTE_CONTROL                    0x0f
#define UVC_CT_ROLL_RELATIVE_CONTROL                    0x10
#define UVC_CT_PRIVACY_CONTROL                          0x11

/* A.9.5. Processing Unit Control Selectors */
#define UVC_PU_CONTROL_UNDEFINED                        0x00
#define UVC_PU_BACKLIGHT_COMPENSATION_CONTROL           0x01
#define UVC_PU_BRIGHTNESS_CONTROL                       0x02
#define UVC_PU_CONTRAST_CONTROL                         0x03
#define UVC_PU_GAIN_CONTROL                             0x04
#define UVC_PU_POWER_LINE_FREQUENCY_CONTROL             0x05
#define UVC_PU_HUE_CONTROL                              0x06
#define UVC_PU_SATURATION_CONTROL                       0x07
#define UVC_PU_SHARPNESS_CONTROL                        0x08
#define UVC_PU_GAMMA_CONTROL                            0x09
#define UVC_PU_WHITE_BALANCE_TEMPERATURE_CONTROL        0x0a
#define UVC_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL   0x0b
#define UVC_PU_WHITE_BALANCE_COMPONENT_CONTROL          0x0c
#define UVC_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL     0x0d
#define UVC_PU_DIGITAL_MULTIPLIER_CONTROL               0x0e
#define UVC_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL         0x0f
#define UVC_PU_HUE_AUTO_CONTROL                         0x10
#define UVC_PU_ANALOG_VIDEO_STANDARD_CONTROL            0x11
#define UVC_PU_ANALOG_LOCK_STATUS_CONTROL               0x12

/* --------------------------------------------------------------------------
 * UVC constants
 */

#define UVC_TERM_INPUT                  0x0000
#define UVC_TERM_OUTPUT                 0x8000
#define UVC_TERM_DIRECTION(term)        ((term)->type & 0x8000)

#define UVC_ENT_TYPE(ent)		((ent)->node_type & 0x7fff)
#define UVC_ENT_IS_UNIT(ent)		(((ent)->node_type & 0xff00) == 0)
#define UVC_ENT_IS_TERM(ent)		(((ent)->node_type & 0xff00) != 0)
#define UVC_ENT_IS_ITERM(ent) \
	(UVC_ENT_IS_TERM(ent) && \
	((ent)->node_type & 0x8000) == UVC_TERM_INPUT)
#define UVC_ENT_IS_OTERM(ent) \
	(UVC_ENT_IS_TERM(ent) && \
	((ent)->node_type & 0x8000) == UVC_TERM_OUTPUT)

// 2.3 Video Function Topology
enum uvc_topo_type {
	UVC_TOPO_TYPE_UNKNOWN,
	UVC_TOPO_TYPE_INPUT_TERMINAL,
	UVC_TOPO_TYPE_OUTPUT_TERMINAL,
	UVC_TOPO_TYPE_SELECTOR_UNIT,
	UVC_TOPO_TYPE_PROCESSING_UNIT,
	UVC_TOPO_TYPE_ENCODING_UNIT,
	UVC_TOPO_TYPE_EXTENSION_UNIT,
	UVC_TOPO_TYPE_CAMERA_TERMINAL,
	UVC_TOPO_TYPE_MEDIA_TRANSPORT_TERMINAL
};

/* ------------------------------------------------------------------------
 * GUIDs
 */
#define UVC_GUID_LOGITECH_DEV_INFO \
	{0x82, 0x06, 0x61, 0x63, 0x70, 0x50, 0xab, 0x49, \
	0xb8, 0xcc, 0xb3, 0x85, 0x5e, 0x8d, 0x22, 0x1e}
#define UVC_GUID_LOGITECH_USER_HW \
	{0x82, 0x06, 0x61, 0x63, 0x70, 0x50, 0xab, 0x49, \
	0xb8, 0xcc, 0xb3, 0x85, 0x5e, 0x8d, 0x22, 0x1f}
#define UVC_GUID_LOGITECH_VIDEO \
	{0x82, 0x06, 0x61, 0x63, 0x70, 0x50, 0xab, 0x49, \
	0xb8, 0xcc, 0xb3, 0x85, 0x5e, 0x8d, 0x22, 0x50}
#define UVC_GUID_LOGITECH_MOTOR \
	{0x82, 0x06, 0x61, 0x63, 0x70, 0x50, 0xab, 0x49, \
	0xb8, 0xcc, 0xb3, 0x85, 0x5e, 0x8d, 0x22, 0x56}

#define UVC_GUID_FORMAT_MJPEG \
	{ 'M',  'J',  'P',  'G', 0x00, 0x00, 0x10, 0x00, \
	0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
#define UVC_GUID_FORMAT_YUY2 \
	{ 'Y',  'U',  'Y',  '2', 0x00, 0x00, 0x10, 0x00, \
	0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
#define UVC_GUID_FORMAT_NV12 \
	{ 'N',  'V',  '1',  '2', 0x00, 0x00, 0x10, 0x00, \
	0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
#define UVC_GUID_FORMAT_YV12 \
	{ 'Y',  'V',  '1',  '2', 0x00, 0x00, 0x10, 0x00, \
	0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
#define UVC_GUID_FORMAT_I420 \
	{ 'I',  '4',  '2',  '0', 0x00, 0x00, 0x10, 0x00, \
	0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
#define UVC_GUID_FORMAT_UYVY \
	{ 'U',  'Y',  'V',  'Y', 0x00, 0x00, 0x10, 0x00, \
	0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
#define UVC_GUID_FORMAT_Y800 \
	{ 'Y',  '8',  '0',  '0', 0x00, 0x00, 0x10, 0x00, \
	0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
#define UVC_GUID_FORMAT_BY8 \
	{ 'B',  'Y',  '8',  ' ', 0x00, 0x00, 0x10, 0x00, \
	0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}
#define UVC_GUID_FORMAT_H264 \
	{ 'H',  '2',  '6',  '4', 0x00, 0x00, 0x10, 0x00, \
	0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}


struct uvc_softc;
struct uvc_v4l2;
struct uvc_buf_queue;

/* Video Descriptor */
struct uvc_vc_header_desc {
	uByte	bLength;
	uByte	bDescriptorType;
	uByte	bDescriptorSubtype;
	uWord	wRevision;
	uWord	wTotalLen;
	uDWord	dClockFreq;
	uByte	bIfaceNums;
	uByte   bIfaceList[0];		/*  Interface Index Lists   */
} __packed;

struct uvc_vc_input_terminal_desc {
	uByte	bLength;
	uByte	bDescriptorType;
	uByte	bDescriptorSubtype;
	uByte	bTerminalID;
	uWord	wTerminalType;
	uByte	bAssocTerminal;
	uByte	bITerminal;
} __packed;

struct uvc_vc_output_terminal_desc {
	uByte bLength;
	uByte bDescriptorType;
	uByte bDescriptorSubType;
	uByte bTerminalID;
	uWord wTerminalType;
	uByte bAssocTerminal;
	uByte bSourceID;
	uByte bITerminal;
} __packed;

struct uvc_vc_selector_unit_desc {
	uByte bLength;
	uByte bDescriptorType;
	uByte bDescriptorSubType;
	uByte bUnitID;
	uByte bNrInPins;
	uByte baSourceID[0];
	uByte iSelector;
} __packed;

struct uvc_vc_processing_unit_desc {
	uByte bLength;
	uByte bDescriptorType;
	uByte bDescriptorSubType;
	uByte bUnitID;
	uByte bSourceID;
	uWord wMaxMultiplier;
	uByte bControlSize;
	uByte bmControls[2];
	uByte iProcessing;
	uByte bmVideoStandards;
} __packed;

struct uvc_vc_extension_unit_desc {
	uByte bLength;
	uByte bDescriptorType;
	uByte bDescriptorSubType;
	uByte bUnitID;
	uByte guidExtensionCode[16];
	uByte bNumControls;
	uByte bNrInPins;
	uByte baSourceID[0];
	uByte bControlSize;
	uByte bmControls[0];
	uByte iExtension;
} __packed;

struct uvc_vs_in_header_desc {
	uByte bLength;
	uByte bDescriptorType;
	uByte bDescriptorSubtype;
	uByte bFormatNum;
	uWord wTotalLen;
	uByte bEp;
	uByte bInfo;
	uByte bTerminalLink;
	uByte bStillCaptureMethod;
	uByte bTriggerSupport;
	uByte bTriggerUsage;
	uByte bControlSize;
	uByte bControls[0];         /* Controls */
} __packed;

struct uvc_vs_color_desc {
	uByte bLength;
	uByte bDescriptorType;
	uByte bDescriptorSubtype;
	uByte bColorPris;
	uByte bTranChars;
	uByte bMatrix;
};

struct uvc_vs_uncompressed_format_desc {
	uByte bLength;
	uByte bDescriptorType;
	uByte bDescriptorSubtype;
	uByte bFormatIndex;
	uByte bFrameNum;
	uByte bGuidFmt[16];
	uByte bBpp;
	uByte bDefaultFrameIndex;
	uByte bAspectRadiox;
	uByte bAspectRadioy;
	uByte bInterlaceFlags;
	uByte bCopyProtect;
} __packed;

struct uvc_vs_frame_based_format_desc {
	uByte bLength;
	uByte bDescriptorType;
	uByte bDescriptorSubtype;
	uByte bFormatIndex;
	uByte bFrameNum;
	uByte bGuidFmt[16];
	uByte bBitsPerpixel;
	uByte bDefaultFrameIndex;
	uByte bAspectRadiox;
	uByte bAspectRadioy;
	uByte bInterlaceFlags;
	uByte bCopyProtect;
	uByte bVariableSize;
} __packed;

struct uvc_vs_frame_desc {
	uByte	bLength;
	uByte	bDescriptorType;
	uByte	bDescriptorSubtype;
	uByte	bFrameIndex;
	uByte	bCapabilities;
	uWord	wWidth;
	uWord	wHeight;
	uDWord	dMinBitRate;
	uDWord	dMaxBitRate;
	uDWord	dMaxFrameBufferSize;
	uDWord	dDefaultFrameInterval;
	uByte	bFrameIntervalType;
	uDWord	dFrameInterval[0];
} __packed;

struct uvc_vs_frame_based_desc {
	uByte	bLength;
	uByte	bDescriptorType;
	uByte	bDescriptorSubtype;
	uByte	bFrameIndex;
	uByte	bCapabilities;
	uWord	wWidth;
	uWord	wHeight;
	uDWord	dMinBitRate;
	uDWord	dMaxBitRate;
	uDWord	dDefaultFrameInterval;
	uByte	bFrameIntervalType;
	uDWord	dwBytesPerLine;
	uDWord	dFrameInterval[0];
} __packed;

struct uvc_data_request {
	uWord wHint;
	uByte bFormatIndex;
	uByte bFrameIndex;
	uDWord dwFrameInterval;
	uWord wKeyFrameRate;
	uWord wPFrameRate;
	uWord wCompQuality;
	uWord wCompWindowSize;
	uWord wDelay;
	uDWord dwMaxFrameSize;
	uDWord dwMaxPayloadSize;
	uDWord dwClockFrequency;
	uByte bFramingInfo;
	uByte bPreferedVersion;
	uByte bMinVersion;
	uByte bMaxVersion;
	uByte __dummy[14];
} __packed;

typedef char assert_uvc_data_request_is_48_bytes[(!!(sizeof(struct uvc_data_request)==48))*2-1];

struct uvc_data_payload_header {
	uint8_t	len;
#define	UVC_PL_HEADER_BIT_FID		(1)
#define	UVC_PL_HEADER_BIT_EOF		(1 << 1)
#define	UVC_PL_HEADER_BIT_PTS		(1 << 2)
#define	UVC_PL_HEADER_BIT_SCR		(1 << 3)
#define	UVC_PL_HEADER_BIT_RES		(1 << 4)
#define	UVC_PL_HEADER_BIT_STI		(1 << 5)
#define	UVC_PL_HEADER_BIT_ERR		(1 << 6)
#define	UVC_PL_HEADER_BIT_EOH		(1 << 7)
	uint8_t	header;
#if 0
	uint32_t pts;
	uint8_t scr[6];
#endif
} __attribute__ ((packed));

/*
 *  * Dynamic controls
 */

/* Data types for UVC control data */
#define UVC_CTRL_DATA_RAW          0
#define UVC_CTRL_DATA_SIGNED       1
#define UVC_CTRL_DATA_UNSIGNED     2
#define UVC_CTRL_DATA_BOOLEAN      3
#define UVC_CTRL_DATA_ENUM         4
#define UVC_CTRL_DATA_BITMASK      5

/* Control flags */
#define UVC_CTRL_SET_CUR           0x0001
#define UVC_CTRL_GET_CUR           0x0002
#define UVC_CTRL_GET_MIN           0x0004
#define UVC_CTRL_GET_MAX           0x0008
#define UVC_CTRL_GET_RES           0x0010
#define UVC_CTRL_GET_DEF           0x0020
#define UVC_CTRL_RESTORE           0x0040
#define UVC_CTRL_AUTO_UPDATE       0x0080
#define UVC_CTRL_ASYNCHRONOUS	0x0100

#define UVC_CTRL_GET_RANGE \
	(UVC_CTRL_GET_CUR | UVC_CTRL_GET_MIN | \
	UVC_CTRL_GET_MAX | UVC_CTRL_GET_RES | \
	UVC_CTRL_GET_DEF)

struct uvc_ctrl_menu_item {
	uint32_t value;
	char name[32];
};

struct uvc_ctrl_menu {
	uint32_t item_num;
	struct uvc_ctrl_menu_item* menu_data;
};

struct uvc_ctrl_info {
	uint8_t index;       /* Bit index in bmControls */

	enum uvc_topo_type topo_type;
	uint8_t selector;

	uint16_t byte_size;
	uint32_t flags;
	uint32_t data_type;

#define MAX_MAPPING_NUM 5
	uint8_t sub_info_num;
	struct uvc_ctrl_sub_info* sub_infos[MAX_MAPPING_NUM];
	struct uvc_ctrl_menu menus[MAX_MAPPING_NUM];

	uint8_t cached_sub_info_idx;
};

struct uvc_ctrl_sub_info {
	struct uvc_ctrl_info* uvc_info;

	uint32_t v4l2_id;
	uint8_t v4l2_name[32];
	enum v4l2_ctrl_type v4l2_type;

	uint8_t bit_offset;
	uint8_t bit_size;

	/*
		superior & inferior is used to determine flag 'inactive';
		E.g. Setting the V4L2_CID_HUE when V4L2_CID_HUE_AUTO is selected doesn't do anything.
		Only when the V4L2_CID_HUE_AUTO is turned off can you set the gain control.
		In this case, V4L2_CID_HUE_AUTO is superior of V4L2_CID_HUE.
	*/
	uint32_t superior_v4l2_id;
	uint32_t superior_manual;
	uint32_t inferior_v4l2_ids[2];

	int32_t (*get)(struct uvc_ctrl_sub_info *this, uint8_t query,
		       const uint8_t *data);
	void (*set)(struct uvc_ctrl_sub_info *this, int32_t value,
		    uint8_t *data);
};


struct uvc_control {
	struct uvc_topo_node *topo_node;
	struct uvc_ctrl_info info;
	uint8_t index; /*
			*  Used to match the uvc_control entry
			*  with a uvc_ctrl_info
			*/
	uint8_t dirty:1,
		loaded:1,
		modified:1,
		cached:1,
		initialized:1;

	uint8_t *uvc_data;
	/* File handle that last changed the control. */
	struct uvc_drv_video *video;
};
struct uvc_ct_node_info {
	uint16_t wObjectiveFocalLengthMin;
	uint16_t wObjectiveFocalLengthMax;
	uint16_t wOcularFocalLength;
	uint8_t bControlSize;
	uint8_t *bmControls;
}; // Camera Terminal

struct uvc_media_node_info {
	uint8_t bControlSize;
	uint8_t *bmControls;
	uint8_t bTransportModeSize;
	uint8_t *bmTransportModes;
}; // MEDIA Transport Terminal

struct uvc_pu_node_info {
	uint16_t wMaxMultiplier;
	uint8_t bControlSize;
	uint8_t *bmControls;
	uint8_t bmVideoStandards;
}; // Processing Unit

struct uvc_xu_node_info {
	uint8_t guidExtensionCode[16];
	uint8_t bNumControls;
	uint8_t bControlSize;
	uint8_t *bmControls;
	uint8_t *bmControlsType;
}; // Extension Unit

struct uvc_topo_node {
	STAILQ_ENTRY(uvc_topo_node) link;

	char node_name[64];

	uint16_t node_type;

	uint32_t flags;

	uint8_t node_id;
	// e.g.:
	// If Video Function Topology like this:
	//  o---o
	//  | 2 |
	//  o---o
	//    \___ o---o
	//     ___ | 5 |
	//    /    o---o
	//  o---o
	//  | 3 |
	//  o---o
	//
	// node 5 has two source ids,
	// one is node 2, another is node 3.
	uint16_t src_ids_num;
	uint8_t *src_ids;

	// mask of controls
	uint16_t controls_mask_len;
	uint8_t *controls_mask;

	uint32_t controls_num;
	struct uvc_control *controls;

	// data pointed by node_info is specified by topo_type
	void *node_info;
};

struct uvc_data_interval {
	uint32_t val;
};

struct uvc_data_frame {
/* begin interval for this frame */
	struct uvc_data_interval *interval;
	/* interval nums, desc string */
	uint8_t interval_type;

/* attribute */
	uint8_t index;
	uint8_t cap;
	uint8_t nouse;
	uint32_t min_bit_rate;
	uint32_t max_bit_rate;
	uint32_t default_interval;
	uint32_t max_buffer_size;

/* important */
	uint16_t width;
	uint16_t height;
};

struct uvc_data_format {
/* begin frame for this format */
	struct uvc_data_frame *frm;
	uint64_t nfrm;
	/* for COMPRESSED or not */
	uint64_t flags;

/* attributes */
	uint32_t fcc;
	uint8_t index;
	uint8_t bpp;
	uint8_t colorspace;
	uint8_t unuse;
	char name[64];
};

struct uvc_drv_data {
/* interface */
	struct usb_interface	*iface;
	/* for device configure iface_num + unit */
	uint8_t	iface_num;
	/* for usb framework */
	uint8_t	iface_index;
	/*for distinguishing bulk and iso uvc*/
	uint8_t num_altsetting;

	uint16_t maxpsize;

/* transfer */
	//struct usb_xfer	*xfer[UVC_N_TRANSFER];
	struct usb_xfer	*xfer[UVC_N_BULKTRANSFER];

/* data format */
	uint8_t nfmt;
	uint8_t nfrm;
	uint8_t nitv;
	uint8_t unuse[3];
	struct uvc_data_format *fmt;
};

struct uvc_drv_ctrl {
/* interface */
	struct usb_interface	*iface;
	/* for device configure iface_num + unit */
	uint8_t	iface_num;
	/* for usb framework */
	uint8_t	iface_index;
	struct lock	mtx;

/* desc infomation */
	STAILQ_HEAD(, uvc_topo_node) topo_nodes;
	uint8_t	sid;
	uint8_t	h264id;
	uint8_t unuse;
	uint16_t	revision;
	uint16_t	clock_freq;
};

struct uvc_drv_video {
	uint64_t		unit;
	uint64_t		users;
	uint64_t		pri;
	uint64_t		htsf;

	struct uvc_softc	*sc;
	struct uvc_drv_ctrl	*ctrl;
	struct uvc_drv_data	*data;
	struct usb_xfer		*intr_xfer[UVCINTR_N_TRANSFER];

	struct lock mtx;
	struct uvc_data_request	req;
	struct uvc_data_format *cur_fmt;
	struct uvc_data_frame *cur_frm;
	uint64_t enable;
	uint64_t bad_frame;
	enum v4l2_buf_type type;
	uint8_t last_fid;

	struct {
		uint8_t header[256];
		uint8_t last_fid;
		uint32_t header_size;
		uint32_t skip_payload;
		uint32_t payload_size;
		uint32_t max_payload_size;
	} bulk;

	struct uvc_v4l2 *v4l2;
	struct uvc_buf_queue bq;
};

struct uvc_drv_format_desc {
	char *name;
	uint8_t guid[16];
	uint32_t fcc;
};

struct uvc_softc {
	char	name[64];
	device_t		dev;
	struct usb_device	*udev;
	struct usb_interface	*iface;

	struct uvc_drv_ctrl	*ctrl;
	/* TODO: not only one */
	struct uvc_drv_data	*data;
	struct uvc_drv_video	*video;
	enum v4l2_buf_type	type;
	//struct uvc_buf_queue	*bq;
#define UVC_DROP_UNCOMPRESS_FORMAT 0x1
#define UVC_QUIRK_PROBE_MINMAX	   0x2
#define UVC_BIGGER_TRANSFER_BUF	   0x4
#define UVC_COMMIT_IN_ADVANCE	   0x8
#define UVC_DISABLE_HUB_U1U2	   0x16
#define UVC_NO_EOF		   (1<<6)
	uint8_t			quirks;
};

extern int uvc_debug;
struct uvc_xu_control_query;

MALLOC_DECLARE(M_UVC);

int uvc_drv_check_video_context(struct uvc_drv_video *v, unsigned char *data,
	uint32_t len);
int uvc_drv_get_v4l2_fmt(struct uvc_drv_video *v, struct v4l2_format *f);
int uvc_drv_enum_v4l2_fmt(struct uvc_drv_video *v, struct v4l2_fmtdesc *vfmt);
int uvc_drv_enum_v4l2_framesizes(struct uvc_drv_video *v,
	struct v4l2_frmsizeenum *fs);
int uvc_drv_enum_v4l2_frameintervals(struct uvc_drv_video *v,
	struct v4l2_frmivalenum *itv);
int uvc_drv_try_v4l2_fmt(struct uvc_drv_video *video, struct v4l2_format *vfmt,
	struct uvc_data_request *req, struct uvc_data_format **rfmt,
	struct uvc_data_frame **rfrm);
int uvc_drv_set_video(struct uvc_drv_video *video,
	struct uvc_data_request *req, struct uvc_data_format *fmt,
	struct uvc_data_frame *frm);
int uvc_drv_xu_ctrl_query(struct uvc_drv_video *v,
	struct uvc_xu_control_query *q);
int uvc_drv_start_video(struct uvc_drv_video *video);
int uvc_drv_stop_video(struct uvc_drv_video *video, int close);
int uvc_drv_set_streampar(struct uvc_drv_video *v, struct v4l2_streamparm *a);
int uvc_drv_get_selection(struct uvc_drv_video *v, struct v4l2_selection *sel);
int uvc_drv_get_pixelaspect(void);
//uvc controls
int uvc_ctrl_init_dev(struct uvc_softc *sc, struct uvc_drv_ctrl *ctrls);
void uvc_ctrl_destroy_mappings(struct uvc_control *ctrl);
int uvc_query_v4l2_ctrl(struct uvc_drv_video *video,
			struct v4l2_queryctrl *v4l2_ctrl);
int uvc_query_v4l2_menu(struct uvc_drv_video *video,
			struct v4l2_querymenu *qm);
#endif /* end _DEV_USB_UVC_DRV_H */