/*
* 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 */