xref: /illumos-gate/usr/src/uts/common/sys/usb/clients/usbser/usbser_keyspan/keyspan_var.h (revision d29f5a71)

/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _SYS_USB_USBSER_KEYSPAN_VAR_H
#define	_SYS_USB_USBSER_KEYSPAN_VAR_H


/*
 * keyspan implementation definitions
 */

#include <sys/types.h>
#include <sys/dditypes.h>
#include <sys/note.h>

#include <sys/usb/clients/usbser/usbser_dsdi.h>

#include <sys/usb/clients/usbser/usbser_keyspan/usa90msg.h>
#include <sys/usb/clients/usbser/usbser_keyspan/usa49msg.h>

#ifdef	__cplusplus
extern "C" {
#endif

/* product id */
#define	KEYSPAN_USA19HS_PID		0x121
#define	KEYSPAN_USA49WLC_PID		0x12a
#define	KEYSPAN_USA49WG_PID		0x131

#define	KEYSPAN_MAX_PORT_NUM		4

/*
 * forward typedefs needed to resolve recursive header dependencies
 */
typedef struct keyspan_pre_state keyspan_pre_state_t;
typedef struct keyspan_state keyspan_state_t;
typedef struct keyspan_port keyspan_port_t;

#include <sys/usb/clients/usbser/usbser_keyspan/keyspan_pipe.h>

/*
 * temporary soft state for pre_attach
 */
struct keyspan_pre_state {
	dev_info_t		*kb_dip;	/* device info */
	int			kb_instance;	/* instance */
	usb_client_dev_data_t	*kb_dev_data;	/* registration data */
	usb_log_handle_t	kb_lh;		/* USBA log handle */
	keyspan_pipe_t		kb_def_pipe;	/* default pipe */
};

/* Firmware structure */
typedef struct usbser_keyspan_fw_record {
	uint16_t address;
	uint8_t data_len;
	uint8_t data[64];
} usbser_keyspan_fw_record_t;

#define	ezusb_hex_record usbser_keyspan_fw_record

/*
 * PM support
 */
typedef struct keyspan_power {
	uint8_t		pm_wakeup_enabled;	/* remote wakeup enabled */
	uint8_t		pm_pwr_states;	/* bit mask of power states */
	boolean_t	pm_raise_power;	/* driver is about to raise power */
	uint8_t		pm_cur_power;	/* current power level */
	uint_t		pm_busy_cnt;	/* number of set_busy requests */
} keyspan_pm_t;

/*
 * device specific info structure
 */
typedef struct keyspan_dev_spec {

	uint16_t	id_product;	/* product ID value */
	uint8_t		port_cnt;	/* How many ports on the device */
	uint8_t	ctrl_ep_addr;	/* Endpoint used to control the device */
	uint8_t	stat_ep_addr;	/* Endpoint used to get device status */
	uint8_t	dataout_ep_addr[4];	/* Endpoint used to send data */

	/* Endpoint used to get data from device */
	uint8_t	datain_ep_addr[4];
} keyspan_dev_spec_t;

/*
 * To support different keyspan adapters, use union type
 * for different cmd msg format.
 */
typedef union keyspan_port_ctrl_msg {
	keyspan_usa19hs_port_ctrl_msg_t	usa19hs;
	keyspan_usa49_port_ctrl_msg_t usa49;
} keyspan_port_ctrl_msg_t;

/*
 * To support different keyspan adapters, use union type
 * for different status msg format.
 */
typedef union keyspan_port_status_msg {
	keyspan_usa19hs_port_status_msg_t	usa19hs;
	keyspan_usa49_port_status_msg_t usa49;
} keyspan_port_status_msg_t;

/*
 * per device state structure
 */
struct keyspan_state {
	kmutex_t		ks_mutex;	/* structure lock */
	dev_info_t		*ks_dip;	/* device info */
	keyspan_port_t		*ks_ports;	/* per port structs */
	keyspan_dev_spec_t	ks_dev_spec;	/* device specific info */

	/*
	 * we use semaphore to serialize pipe open/close by different ports.
	 * mutex could be used too, but it causes trouble when warlocking
	 * with USBA: some functions inside usb_pipe_close() wait on cv
	 *
	 * since semaphore is only used for serialization during
	 * open/close and suspend/resume, there is no deadlock hazard
	 */
	ksema_t			ks_pipes_sema;

	/*
	 * USBA related
	 */
	usb_client_dev_data_t	*ks_dev_data;	/* registration data */
	usb_event_t		*ks_usb_events;	/* usb events */

	keyspan_pipe_t		ks_def_pipe;	/* default pipe */

	/* bulk in pipe for getting device status */
	keyspan_pipe_t		ks_statin_pipe;

	/* bulk out pipe for sending control cmd to device */
	keyspan_pipe_t		ks_ctrlout_pipe;

	usb_log_handle_t	ks_lh;		/* USBA log handle */
	int			ks_dev_state;	/* USB device state */
	keyspan_pm_t		*ks_pm;		/* PM support */

	/*
	 * The following only used on USA_49WG
	 */
	/* Shared bulk in pipe handle */
	usb_pipe_handle_t	ks_datain_pipe_handle;

	/* counter for opened bulk in pipe */
	uint8_t			ks_datain_open_cnt;

	/* Flag for device reconnect */
	uint8_t			ks_reconnect_flag;

};

_NOTE(MUTEX_PROTECTS_DATA(keyspan_state::ks_mutex, keyspan_state))
_NOTE(DATA_READABLE_WITHOUT_LOCK(keyspan_state::{
	ks_dip
	ks_dev_data
	ks_usb_events
	ks_dev_spec
	ks_ports
	ks_def_pipe
	ks_ctrlout_pipe.pipe_handle
	ks_statin_pipe.pipe_handle
	ks_lh
	ks_pm
}))

/*
 * per port structure
 */
struct keyspan_port {
	kmutex_t	kp_mutex;	/* structure lock */
	keyspan_state_t	*kp_ksp;	/* back pointer to the state */
	char		kp_lh_name[16];	/* log handle name */
	usb_log_handle_t kp_lh;		/* log handle */
	uint_t		kp_port_num;	/* port number */
	int		kp_state;	/* port state */
	int		kp_flags;	/* port flags */
	ds_cb_t		kp_cb;		/* DSD callbacks */
	kcondvar_t	kp_tx_cv;	/* cv to wait for tx completion */
	/*
	 * data receipt and transmit
	 */
	mblk_t		*kp_rx_mp;	/* received data */
	mblk_t		*kp_tx_mp;	/* data to transmit */
	boolean_t	kp_no_more_reads; /* disable reads */

	/* The control cmd sent to the port */
	keyspan_port_ctrl_msg_t	kp_ctrl_msg;

	/* status msg of the port */
	keyspan_port_status_msg_t	kp_status_msg;

	uint_t kp_baud;	/* the current baud speed code */
	uint8_t	kp_lcr;	/* the current lcr value */
	/*
	 * the current port status, including: rts, dtr,
	 * break, loopback, enable.
	 */
	uint8_t	kp_status_flag;

	keyspan_pipe_t		kp_datain_pipe;	/* bulk in data pipe */
	keyspan_pipe_t		kp_dataout_pipe; /* bulk out data pipe */

	uint_t		kp_read_len;	/* max length of bulkin request */
	uint_t		kp_write_len;	/* max length of bulkout request */
};

_NOTE(MUTEX_PROTECTS_DATA(keyspan_port::kp_mutex, keyspan_port))
_NOTE(DATA_READABLE_WITHOUT_LOCK(keyspan_port::{
	kp_ksp
	kp_lh
	kp_port_num
	kp_read_len
	kp_write_len
	kp_cb
	kp_datain_pipe.pipe_handle
	kp_datain_pipe.pipe_ep_descr
}))

/* lock relationships */
_NOTE(LOCK_ORDER(keyspan_state::ks_mutex keyspan_port::kp_mutex))
_NOTE(LOCK_ORDER(keyspan_port::kp_mutex keyspan_pipe::pipe_mutex))

/* port status flags */
enum {
	KEYSPAN_PORT_ENABLE = 0x0001,		/* port is enabled */
	KEYSPAN_PORT_RTS = 0x0002,		/* port's rts is set */
	KEYSPAN_PORT_DTR = 0x0004,		/* port's dtr is set */
	KEYSPAN_PORT_TXBREAK = 0x0008,		/* port is in TX break mod */
	KEYSPAN_PORT_LOOPBACK = 0x0010,		/* port is in loopback mod */

	/* the ctrl cmd sent to this port is responded */
	KEYSPAN_PORT_CTRLRESP = 0x0020,
	KEYSPAN_PORT_RXBREAK = 0x0040		/* port is in RX break mod */
};

/* port state */
enum {
	KEYSPAN_PORT_NOT_INIT = 0,	/* port is not initialized */
	KEYSPAN_PORT_CLOSED,		/* port is closed */
	KEYSPAN_PORT_OPENING,		/* port is being opened */
	KEYSPAN_PORT_OPEN		/* port is open */
};

/* port flags */
enum {
	KEYSPAN_PORT_TX_STOPPED	= 0x0001	/* transmit not allowed */
};

/* various tunables */
enum {
	KEYSPAN_BULK_TIMEOUT		= 3,	/* transfer timeout */
	KEYSPAN_BULKIN_MAX_LEN		= 64,	/* bulk in max length */
	KEYSPAN_BULKIN_MAX_LEN_49WG	= 512,	/* bulk in max length */
	/*
	 * From keyspan spec, USA49WLC max packet length for bulk out transfer
	 * is 64, the format is [status byte][up to 63 data bytes], so the
	 * max data length per transfer is 63 bytes, USA19HS doesn't need
	 * extra status byte. USA49WG max packet length for bulk out transfer
	 * is 512, the format is [status byte][63 data bytes]...[status byte]
	 * [up to 63 data bytes], so the max data length per transfer is 504
	 * bytes, while the port0 use intr out pipe send data, the packet
	 * format is the same as USA49WLC, so the max data length for USA49WG
	 * port0 is 63 bytes.
	 */
	KEYSPAN_BULKOUT_MAX_LEN_19HS	= 64,	/* for 19HS only */
	KEYSPAN_BULKOUT_MAX_LEN_49WLC	= 63,	/* for 49WLC and 49WG port0 */
	KEYSPAN_BULKOUT_MAX_LEN_49WG	= 504,	/* for 49WG other ports */
	KEYSPAN_STATIN_MAX_LEN		= 16	/* status in max length */
};

/* This flag indicates if the firmware already downloaded to the device */
#define	KEYSPAN_FW_FLAG 0x8000

/* Vendor specific ctrl req, used to set/download bytes in the device memory */
#define	KEYSPAN_REQ_SET 0xa0
/* Vendor specific ctrl req, used to send ctrl command for USA_49WG model */
#define	KEYSPAN_SET_CONTROL_REQUEST	0xB0

/*
 * debug printing masks
 */
#define	DPRINT_ATTACH		0x00000001
#define	DPRINT_OPEN		0x00000002
#define	DPRINT_CLOSE		0x00000004
#define	DPRINT_DEF_PIPE		0x00000010
#define	DPRINT_IN_PIPE		0x00000020
#define	DPRINT_OUT_PIPE		0x00000040
#define	DPRINT_INTR_PIPE	0x00000080
#define	DPRINT_PIPE_RESET	0x00000100
#define	DPRINT_IN_DATA		0x00000200
#define	DPRINT_OUT_DATA		0x00000400
#define	DPRINT_CTLOP		0x00000800
#define	DPRINT_HOTPLUG		0x00001000
#define	DPRINT_PM		0x00002000
#define	DPRINT_MASK_ALL		0xFFFFFFFF

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

/* common DSD functions */
int	keyspan_tx_copy_data(keyspan_port_t *, mblk_t *, int);
void	keyspan_tx_start(keyspan_port_t *, int *);
void	keyspan_put_tail(mblk_t **, mblk_t *);
void	keyspan_put_head(mblk_t **, mblk_t *, keyspan_port_t *);

void	keyspan_bulkin_cb(usb_pipe_handle_t, usb_bulk_req_t *);
void	keyspan_bulkout_cb(usb_pipe_handle_t, usb_bulk_req_t *);

int	keyspan_restore_device(keyspan_state_t *);
int	keyspan_send_cmd(keyspan_port_t *);

int	keyspan_dev_is_online(keyspan_state_t *);


#ifdef	__cplusplus
}
#endif

#endif	/* _SYS_USB_USBSER_KEYSPAN_VAR_H */