/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _SYS_USB_USBVC_VAR_H
#define	_SYS_USB_USBVC_VAR_H


#ifdef	__cplusplus
extern "C" {
#endif

#include <sys/list.h>
#include <sys/sysmacros.h>
#include <sys/usb/usba/usbai_private.h>
#include <sys/videodev2.h>
#include <sys/usb/clients/video/usbvc/usbvc.h>

typedef struct usbvc_state usbvc_state_t;

/*
 * Power Management support
 */
typedef struct usbvc_power  {

	void		*usbvc_state;	/* points back to usbvc_state */
	uint8_t		usbvc_pwr_states; /* bit mask of device pwr states */
	int		usbvc_pm_busy;

	/* Wakeup and power transistion capabilites of an interface */
	uint8_t		usbvc_pm_capabilities;

	/* flag to indicate if driver is about to raise power level */
	boolean_t	usbvc_raise_power;

	uint8_t		usbvc_current_power;
	uint8_t		usbvc_wakeup_enabled;
} usbvc_power_t;

/* Raw data buf from the USB cam */
typedef struct usbvc_buf
{
	uchar_t *data;
	uint_t len;	/* the length of the allocated memory of data */
	uint_t filled;	/* number of bytes filled */
	uint_t len_read; /* bytes read */
	uchar_t status; /* empty, filling done, read done */

	/* cookie used for memory mapping */
	ddi_umem_cookie_t	umem_cookie;
	struct			v4l2_buffer v4l2_buf;
	list_node_t		buf_node;	/* list */
} usbvc_buf_t;

/* Group data buf related lists and other elements */
typedef struct usbvc_buf_grp
{
    list_t		uv_buf_free;
	list_t		uv_buf_done;
	usbvc_buf_t	*buf_filling;
	uint_t		buf_cnt;
	usbvc_buf_t	*buf_head;
} usbvc_buf_grp_t;

/*
 * UVC Spec: one format descriptor may be followed by sererval frame
 * descriptors, one still image descriptor and one color matching descriptor.
 * It is called a format group. There might be several format groups follow
 * one input/output header.
 */
typedef struct usbvc_format_group {
	usbvc_format_descr_t	*format;
	usbvc_frames_t		*frames;
	uint8_t			frame_cnt;

	/* bytes per pix, used to calculate bytesperline */
	uint8_t			v4l2_bpp;

	uint8_t			v4l2_color;
	uint32_t		v4l2_pixelformat;	/* fcc, pixelformat */
	usbvc_still_image_frame_t	*still;
	usbvc_color_matching_descr_t	*color;
	usbvc_frames_t			*cur_frame;
} usbvc_format_group_t;

/* A stream interface may have several format groups */
typedef struct usbvc_stream_if {

	/* The actual format groups we parsed for the stream interface */
	uint8_t			fmtgrp_cnt;

	usb_if_data_t		*if_descr;
	usbvc_input_header_t	*input_header;
	usbvc_output_header_t	*output_header;
	usbvc_format_group_t	*format_group;
	usbvc_format_group_t	*cur_format_group;
	usbvc_vs_probe_commit_t	ctrl_pc;
	usb_ep_descr_t		*curr_ep;	/* current isoc ep descr */
	usb_pipe_handle_t	datain_ph;	/* current isoc pipe handle */
	uint_t			curr_alt;	/* current alternate  */

	/* The max payload that the isoc data EPs can support */
	uint32_t	max_isoc_payload;

	uchar_t		start_polling;	/* indicate if isoc polling started */

	/*
	 * To flag if VIDIOC_STREAMON is executed, only used by STREAM mode
	 * for suspend/resume. If it's non-zero, we'll have to resume the
	 * device's isoc polling operation after resume.
	 */
	uint8_t		stream_on;

	uchar_t		fid;		/* the MJPEG FID bit */
	usbvc_buf_grp_t	buf_read;	/* buf used for read I/O */
	uint8_t			buf_read_num; /* desired buf num for read I/O */
	usbvc_buf_grp_t	buf_map;	/* buf used for mmap I/O */
	list_node_t	stream_if_node;
} usbvc_stream_if_t;

/* video interface collection */
typedef struct usbvc_vic {

	/* bFirstInterface, the video control infterface num of this VIC */
	uint8_t	vctrl_if_num;

	/*
	 * bInterfaceCount -1, the total number of stream interfaces
	 * belong to this VIC
	 */
	uint8_t	vstrm_if_cnt;
} usbvc_vic_t;

/* Macros */
#define	USBVC_OPEN		0x00000001

/* For serialization. */
#define	USBVC_SER_NOSIG	B_FALSE
#define	USBVC_SER_SIG		B_TRUE

/*
 * Masks for debug printing
 */
#define	PRINT_MASK_ATTA		0x00000001
#define	PRINT_MASK_OPEN 	0x00000002
#define	PRINT_MASK_CLOSE	0x00000004
#define	PRINT_MASK_READ		0x00000008
#define	PRINT_MASK_IOCTL	0x00000010
#define	PRINT_MASK_PM	0x00000020
#define	PRINT_MASK_CB	0x00000040
#define	PRINT_MASK_HOTPLUG	0x00000080
#define	PRINT_MASK_DEVCTRL	0x00000100
#define	PRINT_MASK_DEVMAP	0x00000200
#define	PRINT_MASK_ALL		0xFFFFFFFF

#define	USBVC_MAX_PKTS 40

#define	USBVC_DEFAULT_READ_BUF_NUM 3
#define	USBVC_MAX_READ_BUF_NUM 40
#define	USBVC_MAX_MAP_BUF_NUM 40

/* According to UVC specs, the frame interval is in 100ns unit */
#define	USBVC_FRAME_INTERVAL_DENOMINATOR	10000000

/* Only D3...D0 are writable, Table 4-6, UVC Spec */
#define	USBVC_POWER_MODE_MASK	0xf0;

enum usbvc_buf_status {
	USBVC_BUF_INIT		= 0,  /* Allocated, to be queued */
	    USBVC_BUF_MAPPED	= 1,  /* For map I/O only. Memory is mapped. */
	    USBVC_BUF_EMPTY		= 2, /* not initialized, to be filled */

	/*
	 * buf is filled with a full frame without any errors,
	 * it will be moved to full list.
	 */
	    USBVC_BUF_DONE		= 4,

	/*
	 * buf is filled to full but no EOF bit is found at the end
	 * of video data
	 */
	    USBVC_BUF_ERR		= 8
};

/*
 * This structure is used to map v4l2 controls to uvc controls. The structure
 * array is addressed by (V4L2_CID_BASE - V4L2_CID_*)
 */
typedef struct usbvc_v4l2_ctrl_map {
	char	name[32];
	uint8_t	selector; /* Control Selector */
	uint8_t	len;	/* wLength, defined in uvc spec chp 4 for each ctrl */

	/* The xth bit in bmControls bitmap of processing unit descriptor */
	uint8_t	bit;

	enum	v4l2_ctrl_type type;
} usbvc_v4l2_ctrl_map_t;

typedef struct usbvc_v4l2_ctrl {
	uint8_t			entity_id;
	usbvc_v4l2_ctrl_map_t	*ctrl_map;
} usbvc_v4l2_ctrl_t;


/*
 * State structure
 */
struct usbvc_state {
	dev_info_t		*usbvc_dip;	/* per-device info handle */
	usb_client_dev_data_t	*usbvc_reg;	/* registration data */
	int			usbvc_dev_state; /* USB device states. */
	int			usbvc_drv_state; /* driver states. */
	kmutex_t		usbvc_mutex;
	kcondvar_t		usbvc_serial_cv;
	boolean_t		usbvc_serial_inuse;
	boolean_t		usbvc_locks_initialized;

	usbvc_power_t		*usbvc_pm;

	usb_log_handle_t	usbvc_log_handle;	/* log handle */
	usb_pipe_handle_t	usbvc_default_ph; /* default pipe */

	/* Video ctrl interface header descriptor */
	usbvc_vc_header_t	*usbvc_vc_header;
	list_t			usbvc_term_list;
	list_t			usbvc_unit_list;

	list_t			usbvc_stream_list;
	usbvc_stream_if_t	*usbvc_curr_strm;
	kcondvar_t		usbvc_read_cv;	/* wait for read buf done */
	kcondvar_t		usbvc_mapio_cv;	/* wait for mmap I/O buf done */

	/* current I/O type: read or mmap. */
	uchar_t			usbvc_io_type;
};


/*
 * Used in ioctl entry to copy an argument from kernel space (arg_name)
 * to USER space (arg)
 */
#define	USBVC_COPYOUT(arg_name) \
if (ddi_copyout(&arg_name, (caddr_t)arg, sizeof (arg_name), mode)) { \
    rv = EFAULT; \
    break;	\
}

/*
 * Used in ioctl entry to copy an argument from USER space (arg) to
 * KERNEL space (arg_name)
 */
#define	USBVC_COPYIN(arg_name) \
if (ddi_copyin((caddr_t)arg, &arg_name, sizeof (arg_name), mode)) { \
	rv = EFAULT; \
	break;	\
}

/* Turn a little endian byte array to a uint32_t */
#define	LE_TO_UINT32(src, off, des)	{ \
				uint32_t tmp; \
				des = src[off + 3]; \
				des = des << 24; \
				tmp = src[off + 2]; \
				des |= tmp << 16; \
				tmp = src[off + 1]; \
				des |= tmp << 8; \
				des |= src[off]; \
				}

/* Turn a uint32_t to a little endian byte array */
#define	UINT32_TO_LE(src, off, des)	{ \
				des[off + 0] = 0xff & src; \
				des[off + 1] = 0xff & (src >> 8); \
				des[off + 2] = 0xff & (src >> 16); \
				des[off + 3] = 0xff & (src >> 24); \
				}

/* Turn a little endian byte array to a uint16_t */
#define	LE_TO_UINT16(src, off, des)	 \
				des = src[off + 1]; \
				des = des << 8; \
				des |= src[off];

/* Turn a uint16_t to alittle endian byte array */
#define	UINT16_TO_LE(src, off, des)	{ \
				des[off + 0] = 0xff & src; \
				des[off + 1] = 0xff & (src >> 8); \
				}

#define	NELEM(a)	(sizeof (a) / sizeof (*(a)))

/* Minimum length of class specific descriptors */
#define	USBVC_C_HEAD_LEN_MIN	12	/* ctrl header */
#define	USBVC_I_TERM_LEN_MIN	8	/* input term */
#define	USBVC_O_TERM_LEN_MIN	9	/* output term */
#define	USBVC_P_UNIT_LEN_MIN	8	/* processing unit */
#define	USBVC_S_UNIT_LEN_MIN	5	/* selector unit */
#define	USBVC_E_UNIT_LEN_MIN	22	/* extension unit */
#define	USBVC_FRAME_LEN_MIN	26	/* Frame descriptor */

/* Length of the Frame descriptor which has continuous frame intervals */
#define	USBVC_FRAME_LEN_CON	38


/*
 * According to usb2.0 spec (table 9-13), for all ep, bits 10..0 specify the
 * max pkt size; for high speed ep, bits 12..11 specify the number of
 * additional transaction opportunities per microframe.
 */
#define	HS_PKT_SIZE(pktsize) (pktsize & 0x07ff) * (1 + ((pktsize >> 11) & 3))

/*
 * warlock directives
 * _NOTE is an advice for locklint.  Locklint checks lock use for deadlocks.
 */
_NOTE(MUTEX_PROTECTS_DATA(usbvc_state_t::usbvc_mutex, usbvc_state_t))
_NOTE(DATA_READABLE_WITHOUT_LOCK(usbvc_state_t::{
	usbvc_dip
	usbvc_pm
	usbvc_log_handle
	usbvc_reg
	usbvc_default_ph
	usbvc_vc_header
	usbvc_term_list
	usbvc_unit_list
	usbvc_stream_list
}))

_NOTE(SCHEME_PROTECTS_DATA("stable data", usb_pipe_policy))
_NOTE(SCHEME_PROTECTS_DATA("USBA", usbvc_stream_if::datain_ph))
_NOTE(SCHEME_PROTECTS_DATA("USBA", usbvc_stream_if::curr_alt))
_NOTE(SCHEME_PROTECTS_DATA("USBA", usbvc_stream_if::curr_ep))
_NOTE(SCHEME_PROTECTS_DATA("unshared data", usbvc_buf::umem_cookie))
_NOTE(SCHEME_PROTECTS_DATA("unshared data", usbvc_buf::data))
_NOTE(SCHEME_PROTECTS_DATA("unshared data", usbvc_v4l2_ctrl))
_NOTE(SCHEME_PROTECTS_DATA("unshared data", usbvc_v4l2_ctrl_map))
_NOTE(SCHEME_PROTECTS_DATA("unshared data", mblk_t))
_NOTE(SCHEME_PROTECTS_DATA("unshared data", buf))
_NOTE(SCHEME_PROTECTS_DATA("unshared data", usb_isoc_req))
_NOTE(SCHEME_PROTECTS_DATA("unshared data", v4l2_queryctrl))
_NOTE(SCHEME_PROTECTS_DATA("unshared data", v4l2_format))
_NOTE(SCHEME_PROTECTS_DATA("unshared data", v4l2_control))
_NOTE(SCHEME_PROTECTS_DATA("unshared data", v4l2_streamparm))

int	usbvc_open_isoc_pipe(usbvc_state_t *, usbvc_stream_if_t *);
int	usbvc_start_isoc_polling(usbvc_state_t *, usbvc_stream_if_t *, uchar_t);
int	usbvc_vc_set_ctrl(usbvc_state_t *, uint8_t,  uint8_t,
		uint16_t, uint16_t, mblk_t *);
int	usbvc_vc_get_ctrl(usbvc_state_t *, uint8_t,  uint8_t,
		uint16_t, uint16_t, mblk_t *);
int	usbvc_vs_set_probe_commit(usbvc_state_t *, usbvc_stream_if_t *,
	usbvc_vs_probe_commit_t *, uchar_t);
void	usbvc_free_map_bufs(usbvc_state_t *, usbvc_stream_if_t *);
int	usbvc_alloc_map_bufs(usbvc_state_t *, usbvc_stream_if_t *, int, int);
int	usbvc_vs_get_probe(usbvc_state_t *, usbvc_stream_if_t *,
		usbvc_vs_probe_commit_t *, uchar_t);

/* Functions specific for V4L2 API */
uint8_t		usbvc_v4l2_colorspace(uint8_t);
uint32_t	usbvc_v4l2_guid2fcc(uint8_t *);
int		usbvc_v4l2_ioctl(usbvc_state_t *, int, intptr_t, int);


#ifdef __cplusplus
}
#endif

#endif	/* _SYS_USB_USBVC_VAR_H */