usb/usba/whcdi.h

	whcdi.h revision 489b7c4ab76ae8df137fbfcc2214f7baa52883a0
/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _SYS_USB_WHCDI_H
#define _SYS_USB_WHCDI_H

#ifdef  __cplusplus
extern "C" {
#endif

#include <sys/usb/usba/usba_types.h>
#include <sys/usb/usba/wusba.h>
#include <sys/usb/usba/wusba_io.h>
#include <sys/usb/usba/wa.h>    /* for wusb_secrt_data_t */


/*
 * This file contains data structures and functions that might be
 * shared by HWA and WHCI drivers.
 */

typedef struct wusb_hc_cc_list {
    wusb_cc_t       cc;
    struct wusb_hc_cc_list  *next;
} wusb_hc_cc_list_t;

struct wusb_hc_data;

typedef struct wusb_dev_info {
    struct wusb_hc_data *wdev_hc; /* the HC this device attaches */
    uint8_t         wdev_cdid[16];
    uint16_t        wdev_addr;
    uint16_t        wdev_state;
    uint8_t         wdev_is_newconn;
    uint8_t         wdev_beacon_attr;
    usb_pipe_handle_t   wdev_ph;    /* used before authenticated */
    wusb_secrt_data_t   wdev_secrt_data;
    usb_uwb_cap_descr_t *wdev_uwb_descr;
    wusb_cc_t       *wdev_cc;
    uint8_t         wdev_ptk[16];
    uint8_t         wdev_tkid[3];
    timeout_id_t        wdev_trust_timer; /* TrustTimeout timer */
    uint8_t         wdev_active;
} wusb_dev_info_t;

_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_dev_info::wdev_addr))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_dev_info::wdev_uwb_descr))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_dev_info::wdev_hc))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_dev_info::wdev_secrt_data))

/*
 * According to WUSB 1.0 spec, WUSB hosts can support up to 127 devices.
 * To comply with USB bus convention that bus address 1 is assigned
 * to the host controller device, the addresses assigned to WUSB devices
 * would start from 2. So the max device number is reduced to 126.
 */
#define WUSB_MAX_PORTS      126

#define WUSB_CHILD_ZAP      0x1

typedef struct wusb_hc_data {
    dev_info_t      *hc_dip;
    void            *hc_private_data;
    uint8_t         hc_chid[16];
    uint8_t         hc_cluster_id;
    uint8_t         hc_num_mmcies;
    kmutex_t        hc_mutex;
    wusb_ie_header_t    **hc_mmcie_list;

    boolean_t       hc_newcon_enabled;

    /* save the often used IEs so as not to allocate them each time */
    wusb_ie_keepalive_t     hc_alive_ie;

    /* children info structures */
    uint8_t         hc_num_ports;
    wusb_dev_info_t     **hc_dev_infos;
    dev_info_t      **hc_children_dips;
    size_t          hc_cd_list_length;
    usba_device_t       **hc_usba_devices;

    /* for bus unconfig */
    uint8_t         hc_children_state[WUSB_MAX_PORTS + 1];

    /* child connection functions */
    void    (*disconnect_dev)(dev_info_t *, usb_port_t);
    void    (*reconnect_dev)(dev_info_t *, usb_port_t);
    int (*create_child)(dev_info_t *, usb_port_t);
    int (*destroy_child)(dev_info_t *, usb_port_t);

    /*
     * some necessary host functions:
     * Both HWA and HCI must implement these entries to support basic
     * host controller operations.
     */
    int (*set_encrypt)(dev_info_t *, usb_port_t, uint8_t);
    int (*set_ptk)(dev_info_t *, usb_key_descr_t *, size_t, usb_port_t);
    int (*set_gtk)(dev_info_t *, usb_key_descr_t *, size_t);
    int (*set_device_info)(dev_info_t *, wusb_dev_info_t *, usb_port_t);
    int (*set_cluster_id) (dev_info_t *, uint8_t id);
    int (*set_stream_idx) (dev_info_t *, uint8_t idx);
    int (*set_wusb_mas) (dev_info_t *, uint8_t *data);
    int (*add_mmc_ie)   (dev_info_t *, uint8_t interval, uint8_t rcnt,
                uint8_t iehdl, uint16_t len, uint8_t *data);
    int (*rem_mmc_ie)   (dev_info_t *, uint8_t iehdl);
    int (*stop_ch)  (dev_info_t *, uint32_t time);
    int (*set_num_dnts) (dev_info_t *, uint8_t interval, uint8_t nslot);
    int (*get_time) (dev_info_t *, uint8_t timetype,
                uint16_t timelen, uint32_t *time);

    /* host addr in MAC layer */
    uint16_t        hc_addr;

    /* beaconing channel */
    uint8_t         hc_channel;

    /* reserved MASes. bitmaps */
    uint8_t         hc_mas[WUSB_SET_WUSB_MAS_LEN];

    /* connection context list for the host */
    wusb_hc_cc_list_t   *hc_cc_list;

    /* group temporal key */
    usb_key_descr_t     hc_gtk;
    uint8_t         hc_gtk_padding[15];
} wusb_hc_data_t;

_NOTE(MUTEX_PROTECTS_DATA(wusb_hc_data_t::hc_mutex, wusb_dev_info_t))
_NOTE(MUTEX_PROTECTS_DATA(wusb_hc_data_t::hc_mutex, wusb_hc_data_t))

_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::hc_num_ports))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::hc_num_mmcies))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::hc_dip))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::hc_gtk))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::add_mmc_ie))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::rem_mmc_ie))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::set_cluster_id))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::set_encrypt))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::set_gtk))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::set_ptk))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::set_num_dnts))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::set_stream_idx))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::set_wusb_mas))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::stop_ch))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::create_child))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::destroy_child))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::disconnect_dev))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::reconnect_dev))
_NOTE(DATA_READABLE_WITHOUT_LOCK(wusb_hc_data_t::get_time))

_NOTE(SCHEME_PROTECTS_DATA("local use only",
                wusb_ie_host_disconnect::bLength))
_NOTE(SCHEME_PROTECTS_DATA("local use only",
                wusb_ie_host_disconnect::bIEIdentifier))
_NOTE(SCHEME_PROTECTS_DATA("local use only",
                wusb_ccm_nonce::sfn))
/*
 * WUSB 1.0 4.3.8.5 says the range of cluster id is in 0x80-0xfe,
 * we limit the maximum WUSB host controller numbers to 31 now,
 * and take the upper portion of this range as the broadcast
 * cluster id
 */
#define WUSB_CLUSTER_ID_COUNT       31
#define WUSB_MIN_CLUSTER_ID     0xe0

#define WUSB_TRUST_TIMEOUT  4 /* WUSB 4.15.1 TrustTimeout = 4s */
#define WUSB_TRUST_TIMEOUT_US   WUSB_TRUST_TIMEOUT * MICROSEC

#define WUSB_PERIODIC_ENDPOINT(endpoint) (((endpoint->bmAttributes & \
    USB_EP_ATTR_MASK) == USB_EP_ATTR_INTR) ||\
    ((endpoint->bmAttributes &\
    USB_EP_ATTR_MASK) == USB_EP_ATTR_ISOCH))

#define WUSB_ISOC_ENDPOINT(endpoint) (((endpoint->bmAttributes &\
    USB_EP_ATTR_MASK) == USB_EP_ATTR_ISOCH))

#define WUSB_INTR_ENDPOINT(endpoint) (((endpoint->bmAttributes &\
    USB_EP_ATTR_MASK) == USB_EP_ATTR_INTR))

/* helper functions */
uint8_t wusb_hc_get_cluster_id();
void    wusb_hc_free_cluster_id(uint8_t id);
int wusb_hc_get_iehdl(wusb_hc_data_t *hc_data, wusb_ie_header_t *hdr,
    uint8_t *iehdl);
void    wusb_hc_free_iehdl(wusb_hc_data_t *hc_data, uint8_t iehdl);

uint_t  wusb_hc_is_dev_connected(wusb_hc_data_t *hc_data, uint8_t *cdid,
    usb_port_t *port);
uint_t  wusb_hc_is_addr_valid(wusb_hc_data_t *hc_data, uint8_t addr,
    usb_port_t *port);
usb_port_t  wusb_hc_get_free_port(wusb_hc_data_t *hc_data);

/* device notification support */
int wusb_hc_ack_conn(wusb_hc_data_t *hc_data, usb_port_t port);
int wusb_hc_ack_disconn(wusb_hc_data_t *hc_data, uint8_t addr);
void    wusb_hc_rm_ack(wusb_hc_data_t *hc_data);
int wusb_hc_send_keepalive_ie(wusb_hc_data_t *hc_data, uint8_t addr);
int wusb_hc_auth_dev(wusb_hc_data_t *hc_data, usb_port_t port,
    usb_pipe_handle_t ph, uint8_t ifc, wusb_secrt_data_t *secrt_data);
int wusb_hc_handle_port_connect(wusb_hc_data_t *hc_data, usb_port_t port,
    usb_pipe_handle_t ph, uint8_t ifc, wusb_secrt_data_t *secrt_data);
void    wusb_hc_handle_dn_connect(wusb_hc_data_t *hc_data,
    usb_pipe_handle_t ph, uint8_t ifc, uint8_t *data, size_t len,
    wusb_secrt_data_t *secrt_data);
void    wusb_hc_handle_dn_disconnect(wusb_hc_data_t *hc_data, uint8_t addr,
    uint8_t *data, size_t len);

/* wusb common device function */
int wusb_create_child_devi(dev_info_t *dip, char *node_name,
    usba_hcdi_ops_t *usba_hcdi_ops, dev_info_t *usb_root_hub_dip,
    usb_port_status_t port_status, usba_device_t *usba_device,
    dev_info_t **child_dip);
int wusb_get_dev_security_descr(usb_pipe_handle_t ph,
    wusb_secrt_data_t *secrt_data);
int wusb_get_bos_cloud(dev_info_t *child_dip, usba_device_t *child_ud);
int wusb_get_rc_dev_by_hc(dev_info_t *dip, dev_t *dev);

int16_t wusb_get_ccm_encryption_value(wusb_secrt_data_t *secrt_data);

/* device dynamical configuration functions */
void    wusb_hc_disconnect_dev(wusb_hc_data_t *hc_data, usb_port_t port);
void    wusb_hc_reconnect_dev(wusb_hc_data_t *hc_data, usb_port_t port);
int wusb_hc_create_child(wusb_hc_data_t *hc_data, usb_port_t port);
int wusb_hc_destroy_child(wusb_hc_data_t *hc_data, usb_port_t port);

/* WUSB HC common requests */
int wusb_hc_set_cluster_id(wusb_hc_data_t *hc_data, uint8_t cluster_id);

int wusb_hc_set_stream_idx(wusb_hc_data_t *hc_data, uint8_t stream_idx);

int wusb_hc_set_wusb_mas(wusb_hc_data_t *hc_data, uint8_t *data);

int wusb_hc_add_mmc_ie(wusb_hc_data_t *hc_data, uint8_t interval,
    uint8_t rcnt, uint8_t iehdl, uint16_t len, uint8_t *data);

int wusb_hc_remove_mmc_ie(wusb_hc_data_t *hc_data, uint8_t iehdl);
void    wusb_hc_rem_ie(wusb_hc_data_t *hc_data, wusb_ie_header_t *ieh);

int wusb_hc_stop_ch(wusb_hc_data_t *hc_data, uint32_t timeoff);

int wusb_hc_set_num_dnts(wusb_hc_data_t *hc_data, uint8_t interval,
    uint8_t nslots);

int wusb_hc_get_time(wusb_hc_data_t *hc_data, uint8_t time_type,
    uint16_t len, uint32_t *time);

int wusb_hc_add_host_info(wusb_hc_data_t *hc_data, uint8_t stream_idx);

void    wusb_hc_rem_host_info(wusb_hc_data_t *hc_data);

int wusb_hc_send_host_disconnect(wusb_hc_data_t *hc_data);

int wusb_hc_set_device_info(wusb_hc_data_t *hc_data, usb_port_t port);

/* WUSB HC connection context list operations */
void    wusb_hc_add_cc(wusb_hc_cc_list_t **cc_list, wusb_hc_cc_list_t *new_cc);
void    wusb_hc_rem_cc(wusb_hc_cc_list_t **cc_list, wusb_cc_t *old_cc);
void    wusb_hc_free_cc_list(wusb_hc_cc_list_t *cc_list);
wusb_cc_t *wusb_hc_cc_matched(wusb_hc_cc_list_t *cc_list, uint8_t *cdid);

/* security functions */
int wusb_dev_set_encrypt(usb_pipe_handle_t ph, uint8_t value);
int wusb_enable_dev_encrypt(wusb_hc_data_t *hc, wusb_dev_info_t *dev_info);
int wusb_dev_set_key(usb_pipe_handle_t ph, uint8_t key_index,
    usb_key_descr_t *key, size_t klen);
int wusb_hc_set_encrypt(wusb_hc_data_t *hc_data, usb_port_t port,
    uint8_t type);
int wusb_hc_set_ptk(wusb_hc_data_t *hc_data, uint8_t *key_data,
    usb_port_t port);
int wusb_hc_set_gtk(wusb_hc_data_t *hc_data, uint8_t *key_data,
    uint8_t *tkid);

/* crypto functions */
int PRF(const uchar_t *key, size_t klen, wusb_ccm_nonce_t *nonce,
    const uchar_t *adata, size_t alen,
    const uchar_t *bdata, size_t blen,
    uchar_t *out, size_t bitlen);

#define PRF_64(key, klen, nonce, adata, alen, bdata, blen, out) \
    PRF(key, klen, nonce, adata, alen, bdata, blen, out, 64)

#define PRF_128(key, klen, nonce, adata, alen, bdata, blen, out)    \
    PRF(key, klen, nonce, adata, alen, bdata, blen, out, 128)

#define PRF_256(key, klen, nonce, adata, alen, bdata, blen, out)    \
    PRF(key, klen, nonce, adata, alen, bdata, blen, out, 256)

int wusb_gen_random_nonce(wusb_hc_data_t *hc_data,
    wusb_dev_info_t *dev_info, uchar_t *rbuf);

int wusb_4way_handshake(wusb_hc_data_t *hc_data, usb_port_t port,
    usb_pipe_handle_t ph, uint8_t ifc);

#ifdef __cplusplus
}
#endif

#endif  /* _SYS_USB_WHCDI_H */