/*
 * 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.
 */
/*
 * Copyright 2019 Joyent, Inc.
 */

/*
 * USB Serial CDC ACM driver
 *
 * 1. General Concepts
 * -------------------
 *
 * 1.1 Overview
 * ------------
 * This driver supports devices that comply with the USB Communication
 * Device Class Abstract Control Model (USB CDC ACM) specification,
 * which is available at http://www.usb.org. Given the broad nature
 * of communication equipment, this driver supports the following
 * types of devices:
 *      + Telecommunications devices: analog modems, mobile phones;
 *      + Networking devices: cable modems;
 * Except the above mentioned acm devices, this driver also supports
 * some devices which provide modem-like function and have pairs of
 * bulk in/out pipes.
 *
 * There are three classes that make up the definition for communication
 * devices: the Communication Device Class, the Communication Interface
 * Class and the Data Interface Class. The Communication Device Class
 * is a device level definition and is used by the host to properly
 * identify a communication device that may present several different
 * types of interfaces. The Communication Interface Class defines a
 * general-purpose mechanism that can be used to enable all types of
 * communication services on the Universal Serial Bus (USB). The Data
 * Interface Class defines a general-purpose mechanism to enable bulk
 * transfer on the USB when the data does not meet the requirements
 * for any other class.
 *
 * 1.2 Interface Definitions
 * -------------------------
 * Communication Class Interface is used for device management and,
 * optionally, call management. Device management includes the requests
 * that manage the operational state of a device, the device responses,
 * and event notifications. In Abstract Control Model, the device can
 * provide an internal implementation of call management over the Data
 * Class interface or the Communication Class interface.
 *
 * The Data Class defines a data interface as an interface with a class
 * type of Data Class. Data transmission on a communication device is
 * not restricted to interfaces using the Data Class. Rather, a data
 * interface is used to transmit and/or receive data that is not
 * defined by any other class. The data could be:
 *      + Some form of raw data from a communication line.
 *      + Legacy modem data.
 *      + Data using a proprietary format.
 *
 * 1.3 Endpoint Requirements
 * -------------------------
 * The Communication Class interface requires one endpoint, the management
 * element. Optionally, it can have an additional endpoint, the notification
 * element. The management element uses the default endpoint for all
 * standard and Communication Class-specific requests. The notification
 * element normally uses an interrupt endpoint.
 *
 * The type of endpoints belonging to a Data Class interface are restricted
 * to bulk, and are expected to exist in pairs of the same type (one In and
 * one Out).
 *
 * 1.4 ACM Function Characteristics
 * --------------------------------
 * With Abstract Control Model, the USB device understands standard
 * V.25ter (AT) commands. The device contains a Datapump and micro-
 * controller that handles the AT commands and relay controls. The
 * device uses both a Data Class interface and a Communication Class.
 * interface.
 *
 * A Communication Class interface of type Abstract Control Model will
 * consist of a minimum of two pipes; one is used to implement the
 * management element and the other to implement a notification element.
 * In addition, the device can use two pipes to implement channels over
 * which to carry unspecified data, typically over a Data Class interface.
 *
 * 1.5 ACM Serial Emulation
 * ------------------------
 * The Abstract Control Model can bridge the gap between legacy modem
 * devices and USB devices. To support certain types of legacy applications,
 * two problems need to be addressed. The first is supporting specific
 * legacy control signals and state variables which are addressed
 * directly by the various carrier modulation standards. To support these
 * requirement, additional requests and notifications have been created.
 * Please refer to macro, beginning with USB_CDC_REQ_* and
 * USB_CDC_NOTIFICATION_*.
 *
 * The second significant item which is needed to bridge the gap between
 * legacy modem designs and the Abstract Control Model is a means to
 * multiplex call control (AT commands) on the Data Class interface.
 * Legacy modem designs are limited by only supporting one channel for
 * both "AT" commands and the actual data. To allow this type of
 * functionality, the device must have a means to specify this limitation
 * to the host.
 *
 * When describing this type of device, the Communication Class interface
 * would still specify a Abstract Control Model, but call control would
 * actually occur over the Data Class interface. To describe this
 * particular characteristic, the Call Management Functional Descriptor
 * would have bit D1 of bmCapabilities set.
 *
 * 1.6 Other Bulk In/Out Devices
 * -----------------------------
 * Some devices don't conform to USB CDC specification, but they provide
 * modem-like function and have pairs of bulk in/out pipes. This driver
 * supports this kind of device and exports term nodes by their pipes.
 *
 * 2. Implementation
 * -----------------
 *
 * 2.1 Overview
 * ------------
 * It is a device-specific driver (DSD) working with USB generic serial
 * driver (GSD). It implements the USB-to-serial device-specific driver
 * interface (DSDI) which is offered by GSD. The interface is defined
 * by ds_ops_t structure.
 *
 * 2.2 Port States
 * ---------------
 * For USB CDC ACM devices, this driver is attached to its interface,
 * and exports one port for each interface. For other modem-like devices,
 * this driver can dynamically find the ports in the current device,
 * and export one port for each pair bulk in/out pipes. Each port can
 * be operated independently.
 *
 * port_state:
 *
 *              attach_ports
 *                  |
 *                  |
 *                  |
 *                  v
 *          USBSACM_PORT_CLOSED
 *              |           ^
 *              |           |
 *              V           |
 *         open_port    close_port
 *              |           ^
 *              |           |
 *              V           |
 *            USBSACM_PORT_OPEN
 *
 *
 * 2.3 Pipe States
 * ---------------
 * Each port has its own bulk in/out pipes and some ports could also have
 * its own interrupt pipes (traced by usbsacm_port structure), which are
 * opened during attach. The pipe status is as following:
 *
 * pipe_state:
 *
 *              usbsacm_init_alloc_ports  usbsacm_free_ports
 *                              |               ^
 *                              v               |
 *                |---->------ USBSACM_PORT_CLOSED ------>------+
 *                ^                                             |
 *                |                             reconnect/resume/open_port
 *                |                                             |
 *    disconnect/suspend/close_port                             |
 *                |                                             v
 *                +------<------ USBSACM_PIPE_IDLE ------<------|
 *                                  |           |
 *                                  V           ^
 *                                  |           |
 *                +-----------------+           +-----------+
 *                |                                         |
 *                V                                         ^
 *                |                                         |
 *      rx_start/tx_start----->------failed------->---------|
 *                |                                         |
 *                |                             bulkin_cb/bulkout_cb
 *                V                                         |
 *                |                                         ^
 *                |                                         |
 *                +----->----- USBSACM_PIPE_BUSY ---->------+
 *
 *
 * To get its status in a timely way, acm driver can get the status
 * of the device by polling the interrupt pipe.
 *
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/conf.h>
#include <sys/stream.h>
#include <sys/strsun.h>
#include <sys/termio.h>
#include <sys/termiox.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/byteorder.h>
#define USBDRV_MAJOR_VER        2
#define USBDRV_MINOR_VER        0
#include <sys/usb/usba.h>
#include <sys/usb/usbdevs.h>
#include <sys/usb/usba/usba_types.h>
#include <sys/usb/clients/usbser/usbser.h>
#include <sys/usb/clients/usbser/usbser_dsdi.h>
#include <sys/usb/clients/usbcdc/usb_cdc.h>
#include <sys/usb/clients/usbser/usbsacm/usbsacm.h>

/* devops entry points */
static int      usbsacm_attach(dev_info_t *, ddi_attach_cmd_t);
static int      usbsacm_detach(dev_info_t *, ddi_detach_cmd_t);
static int      usbsacm_getinfo(dev_info_t *, ddi_info_cmd_t, void *,
                void **);
static int      usbsacm_open(queue_t *, dev_t *, int, int, cred_t *);

/* DSD operations */
static int      usbsacm_ds_attach(ds_attach_info_t *);
static void     usbsacm_ds_detach(ds_hdl_t);
static int      usbsacm_ds_register_cb(ds_hdl_t, uint_t, ds_cb_t *);
static void     usbsacm_ds_unregister_cb(ds_hdl_t, uint_t);
static int      usbsacm_ds_open_port(ds_hdl_t, uint_t);
static int      usbsacm_ds_close_port(ds_hdl_t, uint_t);

/* standard UART operations */
static int      usbsacm_ds_set_port_params(ds_hdl_t, uint_t,
                ds_port_params_t *);
static int      usbsacm_ds_set_modem_ctl(ds_hdl_t, uint_t, int, int);
static int      usbsacm_ds_get_modem_ctl(ds_hdl_t, uint_t, int, int *);
static int      usbsacm_ds_break_ctl(ds_hdl_t, uint_t, int);

/* data xfer */
static int      usbsacm_ds_tx(ds_hdl_t, uint_t, mblk_t *);
static mblk_t   *usbsacm_ds_rx(ds_hdl_t, uint_t);
static void     usbsacm_ds_stop(ds_hdl_t, uint_t, int);
static void     usbsacm_ds_start(ds_hdl_t, uint_t, int);

/* fifo operations */
static int      usbsacm_ds_fifo_flush(ds_hdl_t, uint_t, int);
static int      usbsacm_ds_fifo_drain(ds_hdl_t, uint_t, int);
static int      usbsacm_wait_tx_drain(usbsacm_port_t *, int);
static int      usbsacm_fifo_flush_locked(usbsacm_state_t *, uint_t, int);

/* power management and CPR */
static int      usbsacm_ds_suspend(ds_hdl_t);
static int      usbsacm_ds_resume(ds_hdl_t);
static int      usbsacm_ds_disconnect(ds_hdl_t);
static int      usbsacm_ds_reconnect(ds_hdl_t);
static int      usbsacm_ds_usb_power(ds_hdl_t, int, int, int *);
static int      usbsacm_create_pm_components(usbsacm_state_t *);
static void     usbsacm_destroy_pm_components(usbsacm_state_t *);
static void     usbsacm_pm_set_busy(usbsacm_state_t *);
static void     usbsacm_pm_set_idle(usbsacm_state_t *);
static int      usbsacm_pwrlvl0(usbsacm_state_t *);
static int      usbsacm_pwrlvl1(usbsacm_state_t *);
static int      usbsacm_pwrlvl2(usbsacm_state_t *);
static int      usbsacm_pwrlvl3(usbsacm_state_t *);

/* event handling */
/* pipe callbacks */
static void     usbsacm_bulkin_cb(usb_pipe_handle_t, usb_bulk_req_t *);
static void     usbsacm_bulkout_cb(usb_pipe_handle_t, usb_bulk_req_t *);

/* interrupt pipe */
static void     usbsacm_pipe_start_polling(usbsacm_port_t *acmp);
static void     usbsacm_intr_cb(usb_pipe_handle_t ph, usb_intr_req_t *req);
static void     usbsacm_intr_ex_cb(usb_pipe_handle_t ph, usb_intr_req_t *req);
static void     usbsacm_parse_intr_data(usbsacm_port_t *acmp, mblk_t *data);

/* Utility functions */
/* data transfer routines */
static int      usbsacm_rx_start(usbsacm_port_t *);
static void     usbsacm_tx_start(usbsacm_port_t *);
static int      usbsacm_send_data(usbsacm_port_t *, mblk_t *);

/* Initialize or release resources */
static int      usbsacm_init_alloc_ports(usbsacm_state_t *);
static void     usbsacm_free_ports(usbsacm_state_t *);
static void     usbsacm_cleanup(usbsacm_state_t *);

/* analysis functional descriptors */
static int      usbsacm_get_descriptors(usbsacm_state_t *);

/* hotplug */
static int      usbsacm_restore_device_state(usbsacm_state_t *);
static int      usbsacm_restore_port_state(usbsacm_state_t *);

/* pipe operations */
static int      usbsacm_open_port_pipes(usbsacm_port_t *);
static void     usbsacm_close_port_pipes(usbsacm_port_t *);
static void     usbsacm_close_pipes(usbsacm_state_t *);
static void     usbsacm_disconnect_pipes(usbsacm_state_t *);
static int      usbsacm_reconnect_pipes(usbsacm_state_t *);

/* vendor-specific commands */
static int      usbsacm_req_write(usbsacm_port_t *, uchar_t, uint16_t,
                mblk_t **);
static int      usbsacm_set_line_coding(usbsacm_port_t *,
                usb_cdc_line_coding_t *);
static void     usbsacm_mctl2reg(int mask, int val, uint8_t *);
static int      usbsacm_reg2mctl(uint8_t);

/* misc */
static void     usbsacm_put_tail(mblk_t **, mblk_t *);
static void     usbsacm_put_head(mblk_t **, mblk_t *);


/*
 * Standard STREAMS driver definitions
 */
struct module_info usbsacm_modinfo = {
        0,                      /* module id */
        "usbsacm",              /* module name */
        USBSER_MIN_PKTSZ,       /* min pkt size */
        USBSER_MAX_PKTSZ,       /* max pkt size */
        USBSER_HIWAT,           /* hi watermark */
        USBSER_LOWAT            /* low watermark */
};

static struct qinit usbsacm_rinit = {
        NULL,
        usbser_rsrv,
        usbsacm_open,
        usbser_close,
        NULL,
        &usbsacm_modinfo,
        NULL
};

static struct qinit usbsacm_winit = {
        usbser_wput,
        usbser_wsrv,
        NULL,
        NULL,
        NULL,
        &usbsacm_modinfo,
        NULL
};


struct streamtab usbsacm_str_info = {
        &usbsacm_rinit, &usbsacm_winit, NULL, NULL
};

/* cb_ops structure */
static struct cb_ops usbsacm_cb_ops = {
        nodev,                  /* cb_open */
        nodev,                  /* cb_close */
        nodev,                  /* cb_strategy */
        nodev,                  /* cb_print */
        nodev,                  /* cb_dump */
        nodev,                  /* cb_read */
        nodev,                  /* cb_write */
        nodev,                  /* cb_ioctl */
        nodev,                  /* cb_devmap */
        nodev,                  /* cb_mmap */
        nodev,                  /* cb_segmap */
        nochpoll,               /* cb_chpoll */
        ddi_prop_op,            /* cb_prop_op */
        &usbsacm_str_info,      /* cb_stream */
        (int)(D_64BIT | D_NEW | D_MP | D_HOTPLUG)       /* cb_flag */
};

/* dev_ops structure */
struct dev_ops usbsacm_ops = {
        DEVO_REV,               /* devo_rev */
        0,                      /* devo_refcnt */
        usbsacm_getinfo,        /* devo_getinfo */
        nulldev,                /* devo_identify */
        nulldev,                /* devo_probe */
        usbsacm_attach,         /* devo_attach */
        usbsacm_detach,         /* devo_detach */
        nodev,                  /* devo_reset */
        &usbsacm_cb_ops,        /* devo_cb_ops */
        (struct bus_ops *)NULL, /* devo_bus_ops */
        usbser_power,           /* devo_power */
        ddi_quiesce_not_needed, /* devo_quiesce */
};

extern struct mod_ops mod_driverops;
/* modldrv structure */
static struct modldrv modldrv = {
        &mod_driverops,         /* type of module - driver */
        "USB Serial CDC ACM driver",
        &usbsacm_ops,
};

/* modlinkage structure */
static struct modlinkage modlinkage = {
        MODREV_1,
        &modldrv,
        NULL
};

static void     *usbsacm_statep;        /* soft state */

/*
 * DSD definitions
 */
static ds_ops_t usbsacm_ds_ops = {
        DS_OPS_VERSION,
        usbsacm_ds_attach,
        usbsacm_ds_detach,
        usbsacm_ds_register_cb,
        usbsacm_ds_unregister_cb,
        usbsacm_ds_open_port,
        usbsacm_ds_close_port,
        usbsacm_ds_usb_power,
        usbsacm_ds_suspend,
        usbsacm_ds_resume,
        usbsacm_ds_disconnect,
        usbsacm_ds_reconnect,
        usbsacm_ds_set_port_params,
        usbsacm_ds_set_modem_ctl,
        usbsacm_ds_get_modem_ctl,
        usbsacm_ds_break_ctl,
        NULL,                   /* NULL if h/w doesn't support loopback */
        usbsacm_ds_tx,
        usbsacm_ds_rx,
        usbsacm_ds_stop,
        usbsacm_ds_start,
        usbsacm_ds_fifo_flush,
        usbsacm_ds_fifo_drain
};

/*
 * baud code -> baud rate (0 means unsupported rate)
 */
static int usbsacm_speedtab[] = {
        0,              /* B0 */
        50,             /* B50 */
        75,             /* B75 */
        110,            /* B110 */
        134,            /* B134 */
        150,            /* B150 */
        200,            /* B200 */
        300,            /* B300 */
        600,            /* B600 */
        1200,           /* B1200 */
        1800,           /* B1800 */
        2400,           /* B2400 */
        4800,           /* B4800 */
        9600,           /* B9600 */
        19200,          /* B19200 */
        38400,          /* B38400 */
        57600,          /* B57600 */
        76800,          /* B76800 */
        115200,         /* B115200 */
        153600,         /* B153600 */
        230400,         /* B230400 */
        307200,         /* B307200 */
        460800,         /* B460800 */
        921600,         /* B921600 */
        1000000,        /* B1000000 */
        1152000,        /* B1152000 */
        1500000,        /* B1500000 */
        2000000,        /* B2000000 */
        2500000,        /* B2500000 */
        3000000,        /* B3000000 */
        3500000,        /* B3500000 */
        4000000,        /* B4000000 */
};


static uint_t   usbsacm_errlevel = USB_LOG_L4;
static uint_t   usbsacm_errmask = 0xffffffff;
static uint_t   usbsacm_instance_debug = (uint_t)-1;


/*
 * usbsacm driver's entry points
 * -----------------------------
 */
/*
 * Module-wide initialization routine.
 */
int
_init(void)
{
        int    error;

        if ((error = mod_install(&modlinkage)) == 0) {

                error = ddi_soft_state_init(&usbsacm_statep,
                    usbser_soft_state_size(), 1);
        }

        return (error);
}


/*
 * Module-wide tear-down routine.
 */
int
_fini(void)
{
        int    error;

        if ((error = mod_remove(&modlinkage)) == 0) {
                ddi_soft_state_fini(&usbsacm_statep);
        }

        return (error);
}


int
_info(struct modinfo *modinfop)
{
        return (mod_info(&modlinkage, modinfop));
}


/*
 * Device configuration entry points
 */
static int
usbsacm_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        return (usbser_attach(dip, cmd, usbsacm_statep, &usbsacm_ds_ops));
}


static int
usbsacm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        return (usbser_detach(dip, cmd, usbsacm_statep));
}


int
usbsacm_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
    void **result)
{
        return (usbser_getinfo(dip, infocmd, arg, result, usbsacm_statep));
}


static int
usbsacm_open(queue_t *rq, dev_t *dev, int flag, int sflag, cred_t *cr)
{
        return (usbser_open(rq, dev, flag, sflag, cr, usbsacm_statep));
}

/*
 * usbsacm_ds_detach:
 *      attach device instance, called from GSD attach
 *      initialize state and device, including:
 *              state variables, locks, device node
 *              device registration with system
 *              power management
 */
static int
usbsacm_ds_attach(ds_attach_info_t *aip)
{
        usbsacm_state_t *acmp;

        acmp = (usbsacm_state_t *)kmem_zalloc(sizeof (usbsacm_state_t),
            KM_SLEEP);
        acmp->acm_dip = aip->ai_dip;
        acmp->acm_usb_events = aip->ai_usb_events;
        acmp->acm_ports = NULL;
        *aip->ai_hdl = (ds_hdl_t)acmp;

        /* registers usbsacm with the USBA framework */
        if (usb_client_attach(acmp->acm_dip, USBDRV_VERSION,
            0) != USB_SUCCESS) {

                goto fail;
        }

        /* Get the configuration information of device */
        if (usb_get_dev_data(acmp->acm_dip, &acmp->acm_dev_data,
            USB_PARSE_LVL_CFG, 0) != USB_SUCCESS) {

                goto fail;
        }
        acmp->acm_def_ph = acmp->acm_dev_data->dev_default_ph;
        acmp->acm_dev_state = USB_DEV_ONLINE;
        mutex_init(&acmp->acm_mutex, NULL, MUTEX_DRIVER,
            acmp->acm_dev_data->dev_iblock_cookie);

        acmp->acm_lh = usb_alloc_log_hdl(acmp->acm_dip, "usbsacm",
            &usbsacm_errlevel, &usbsacm_errmask, &usbsacm_instance_debug, 0);

        /* Create power management components */
        if (usbsacm_create_pm_components(acmp) != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_ds_attach: create pm components failed.");

                goto fail;
        }

        /* Register to get callbacks for USB events */
        if (usb_register_event_cbs(acmp->acm_dip, acmp->acm_usb_events, 0)
            != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_ds_attach: register event callback failed.");

                goto fail;
        }

        /*
         * If devices conform to acm spec, driver will attach using class id;
         * if not, using device id.
         */
        if ((strcmp(DEVI(acmp->acm_dip)->devi_binding_name,
            "usbif,class2.2") == 0) ||
            ((strcmp(DEVI(acmp->acm_dip)->devi_binding_name,
            "usb,class2.2.0") == 0))) {

                acmp->acm_compatibility = B_TRUE;
        } else {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_ds_attach: A nonstandard device is attaching to "
                    "usbsacm driver. This device doesn't conform to "
                    "usb cdc spec.");

                acmp->acm_compatibility = B_FALSE;
        }

        /* initialize state variables */
        if (usbsacm_init_alloc_ports(acmp) != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_ds_attach: initialize port structure failed.");

                goto fail;
        }
        *aip->ai_port_cnt = acmp->acm_port_cnt;

        /* Get max data size of bulk transfer */
        if (usb_pipe_get_max_bulk_transfer_size(acmp->acm_dip,
            &acmp->acm_xfer_sz) != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_ds_attach: get max size of transfer failed.");

                goto fail;
        }

        return (USB_SUCCESS);
fail:
        usbsacm_cleanup(acmp);

        return (USB_FAILURE);
}


/*
 * usbsacm_ds_detach:
 *      detach device instance, called from GSD detach
 */
static void
usbsacm_ds_detach(ds_hdl_t hdl)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;

        USB_DPRINTF_L4(PRINT_MASK_CLOSE, acmp->acm_lh,
            "usbsacm_ds_detach:");

        usbsacm_close_pipes(acmp);
        usbsacm_cleanup(acmp);
}


/*
 * usbsacm_ds_register_cb:
 *      GSD routine call ds_register_cb to register interrupt callbacks
 *      for the given port
 */
/*ARGSUSED*/
static int
usbsacm_ds_register_cb(ds_hdl_t hdl, uint_t port_num, ds_cb_t *cb)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        usbsacm_port_t  *acm_port;

        USB_DPRINTF_L4(PRINT_MASK_OPEN, acmp->acm_lh,
            "usbsacm_ds_register_cb: acmp = 0x%p port_num = %d",
            (void *)acmp, port_num);

        /* Check if port number is greater than actual port number. */
        if (port_num >= acmp->acm_port_cnt) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_ds_register_cb: port number is wrong.");

                return (USB_FAILURE);
        }
        acm_port = &acmp->acm_ports[port_num];
        acm_port->acm_cb = *cb;

        return (USB_SUCCESS);
}


/*
 * usbsacm_ds_unregister_cb:
 *      GSD routine call ds_unregister_cb to unregister
 *      interrupt callbacks for the given port
 */
/*ARGSUSED*/
static void
usbsacm_ds_unregister_cb(ds_hdl_t hdl, uint_t port_num)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        usbsacm_port_t  *acm_port;

        USB_DPRINTF_L4(PRINT_MASK_CLOSE, acmp->acm_lh,
            "usbsacm_ds_unregister_cb: ");

        if (port_num < acmp->acm_port_cnt) {
                /* Release callback function */
                acm_port = &acmp->acm_ports[port_num];
                bzero(&acm_port->acm_cb, sizeof (acm_port->acm_cb));
        }
}


/*
 * usbsacm_ds_open_port:
 *      GSD routine call ds_open_port
 *      to open the given port
 */
/*ARGSUSED*/
static int
usbsacm_ds_open_port(ds_hdl_t hdl, uint_t port_num)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        usbsacm_port_t  *acm_port = &acmp->acm_ports[port_num];

        USB_DPRINTF_L4(PRINT_MASK_OPEN, acmp->acm_lh,
            "usbsacm_ds_open_port: port_num = %d", port_num);

        mutex_enter(&acm_port->acm_port_mutex);
        /* Check the status of the given port and device */
        if ((acmp->acm_dev_state == USB_DEV_DISCONNECTED) ||
            (acm_port->acm_port_state != USBSACM_PORT_CLOSED)) {
                mutex_exit(&acm_port->acm_port_mutex);

                return (USB_FAILURE);
        }
        mutex_exit(&acm_port->acm_port_mutex);

        usbsacm_pm_set_busy(acmp);

        /* open pipes of port */
        if (usbsacm_open_port_pipes(acm_port) != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_OPEN, acmp->acm_lh,
                    "usbsacm_ds_open_port: open pipes failed.");

                return (USB_FAILURE);
        }

        mutex_enter(&acm_port->acm_port_mutex);
        /* data receipt */
        if (usbsacm_rx_start(acm_port) != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_OPEN, acmp->acm_lh,
                    "usbsacm_ds_open_port: start receive data failed.");
                mutex_exit(&acm_port->acm_port_mutex);

                return (USB_FAILURE);
        }
        acm_port->acm_port_state = USBSACM_PORT_OPEN;

        mutex_exit(&acm_port->acm_port_mutex);

        return (USB_SUCCESS);
}


/*
 * usbsacm_ds_close_port:
 *      GSD routine call ds_close_port
 *      to close the given port
 */
/*ARGSUSED*/
static int
usbsacm_ds_close_port(ds_hdl_t hdl, uint_t port_num)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        usbsacm_port_t  *acm_port = &acmp->acm_ports[port_num];
        int             rval = USB_SUCCESS;

        USB_DPRINTF_L4(PRINT_MASK_CLOSE, acmp->acm_lh,
            "usbsacm_ds_close_port: acmp = 0x%p", (void *)acmp);

        mutex_enter(&acm_port->acm_port_mutex);
        acm_port->acm_port_state = USBSACM_PORT_CLOSED;
        mutex_exit(&acm_port->acm_port_mutex);

        usbsacm_close_port_pipes(acm_port);

        mutex_enter(&acm_port->acm_port_mutex);
        rval = usbsacm_fifo_flush_locked(acmp, port_num, DS_TX | DS_RX);
        mutex_exit(&acm_port->acm_port_mutex);

        usbsacm_pm_set_idle(acmp);

        return (rval);
}


/*
 * usbsacm_ds_usb_power:
 *      GSD routine call ds_usb_power
 *      to set power level of the component
 */
/*ARGSUSED*/
static int
usbsacm_ds_usb_power(ds_hdl_t hdl, int comp, int level, int *new_state)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        usbsacm_pm_t    *pm = acmp->acm_pm;
        int             rval = USB_SUCCESS;

        USB_DPRINTF_L4(PRINT_MASK_PM, acmp->acm_lh,
            "usbsacm_ds_usb_power: ");

        /* check if pm is NULL */
        if (pm == NULL) {
                USB_DPRINTF_L2(PRINT_MASK_PM, acmp->acm_lh,
                    "usbsacm_ds_usb_power: pm is NULL.");

                return (USB_FAILURE);
        }

        mutex_enter(&acmp->acm_mutex);
        /*
         * check if we are transitioning to a legal power level
         */
        if (USB_DEV_PWRSTATE_OK(pm->pm_pwr_states, level)) {
                USB_DPRINTF_L2(PRINT_MASK_PM, acmp->acm_lh,
                    "usbsacm_ds_usb_power: "
                    "illegal power level %d, pwr_states=%x",
                    level, pm->pm_pwr_states);
                mutex_exit(&acmp->acm_mutex);

                return (USB_FAILURE);
        }

        /*
         * if we are about to raise power and asked to lower power, fail
         */
        if (pm->pm_raise_power && (level < (int)pm->pm_cur_power)) {
                USB_DPRINTF_L2(PRINT_MASK_PM, acmp->acm_lh,
                    "usbsacm_ds_usb_power: wrong condition.");
                mutex_exit(&acmp->acm_mutex);

                return (USB_FAILURE);
        }

        /*
         * Set the power status of device by request level.
         */
        switch (level) {
        case USB_DEV_OS_PWR_OFF:
                rval = usbsacm_pwrlvl0(acmp);

                break;
        case USB_DEV_OS_PWR_1:
                rval = usbsacm_pwrlvl1(acmp);

                break;
        case USB_DEV_OS_PWR_2:
                rval = usbsacm_pwrlvl2(acmp);

                break;
        case USB_DEV_OS_FULL_PWR:
                rval = usbsacm_pwrlvl3(acmp);
                /*
                 * If usbser dev_state is DISCONNECTED or SUSPENDED, it shows
                 * that the usb serial device is disconnected/suspended while it
                 * is under power down state, now the device is powered up
                 * before it is reconnected/resumed. xxx_pwrlvl3() will set dev
                 * state to ONLINE, we need to set the dev state back to
                 * DISCONNECTED/SUSPENDED.
                 */
                if ((rval == USB_SUCCESS) &&
                    ((*new_state == USB_DEV_DISCONNECTED) ||
                    (*new_state == USB_DEV_SUSPENDED))) {
                        acmp->acm_dev_state = *new_state;
                }

                break;
        }

        *new_state = acmp->acm_dev_state;
        mutex_exit(&acmp->acm_mutex);

        return (rval);
}


/*
 * usbsacm_ds_suspend:
 *      GSD routine call ds_suspend
 *      during CPR suspend
 */
static int
usbsacm_ds_suspend(ds_hdl_t hdl)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        int             state = USB_DEV_SUSPENDED;

        USB_DPRINTF_L4(PRINT_MASK_PM, acmp->acm_lh,
            "usbsacm_ds_suspend: ");
        /*
         * If the device is suspended while it is under PWRED_DOWN state, we
         * need to keep the PWRED_DOWN state so that it could be powered up
         * later. In the mean while, usbser dev state will be changed to
         * SUSPENDED state.
         */
        mutex_enter(&acmp->acm_mutex);
        if (acmp->acm_dev_state != USB_DEV_PWRED_DOWN) {
                /* set device status to suspend */
                acmp->acm_dev_state = USB_DEV_SUSPENDED;
        }
        mutex_exit(&acmp->acm_mutex);

        usbsacm_disconnect_pipes(acmp);

        return (state);
}

/*
 * usbsacm_ds_resume:
 *      GSD routine call ds_resume
 *      during CPR resume
 */
/*ARGSUSED*/
static int
usbsacm_ds_resume(ds_hdl_t hdl)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        int             current_state;
        int             ret;

        USB_DPRINTF_L4(PRINT_MASK_PM, acmp->acm_lh,
            "usbsacm_ds_resume: ");

        mutex_enter(&acmp->acm_mutex);
        current_state = acmp->acm_dev_state;
        mutex_exit(&acmp->acm_mutex);

        /* restore the status of device */
        if (current_state != USB_DEV_ONLINE) {
                ret = usbsacm_restore_device_state(acmp);
        } else {
                ret = USB_DEV_ONLINE;
        }

        return (ret);
}

/*
 * usbsacm_ds_disconnect:
 *      GSD routine call ds_disconnect
 *      to disconnect USB device
 */
static int
usbsacm_ds_disconnect(ds_hdl_t hdl)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        int             state = USB_DEV_DISCONNECTED;

        USB_DPRINTF_L4(PRINT_MASK_CLOSE, acmp->acm_lh,
            "usbsacm_ds_disconnect: ");

        /*
         * If the device is disconnected while it is under PWRED_DOWN state, we
         * need to keep the PWRED_DOWN state so that it could be powered up
         * later. In the mean while, usbser dev state will be changed to
         * DISCONNECTED state.
         */
        mutex_enter(&acmp->acm_mutex);
        if (acmp->acm_dev_state != USB_DEV_PWRED_DOWN) {
                /* set device status to disconnected */
                acmp->acm_dev_state = USB_DEV_DISCONNECTED;
        }
        mutex_exit(&acmp->acm_mutex);

        usbsacm_disconnect_pipes(acmp);

        return (state);
}


/*
 * usbsacm_ds_reconnect:
 *      GSD routine call ds_reconnect
 *      to reconnect USB device
 */
/*ARGSUSED*/
static int
usbsacm_ds_reconnect(ds_hdl_t hdl)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;

        USB_DPRINTF_L4(PRINT_MASK_OPEN, acmp->acm_lh,
            "usbsacm_ds_reconnect: ");

        return (usbsacm_restore_device_state(acmp));
}


/*
 * usbsacm_ds_set_port_params:
 *      GSD routine call ds_set_port_params
 *      to set one or more port parameters
 */
/*ARGSUSED*/
static int
usbsacm_ds_set_port_params(ds_hdl_t hdl, uint_t port_num, ds_port_params_t *tp)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        usbsacm_port_t  *acm_port = &acmp->acm_ports[port_num];
        int             i;
        uint_t          ui;
        ds_port_param_entry_t *pe;
        usb_cdc_line_coding_t lc;
        int             ret;

        USB_DPRINTF_L4(PRINT_MASK_ALL, acmp->acm_lh,
            "usbsacm_ds_set_port_params: acmp = 0x%p", (void *)acmp);

        mutex_enter(&acm_port->acm_port_mutex);
        /*
         * If device conform to acm spec, check if it support to set port param.
         */
        if ((acm_port->acm_cap & USB_CDC_ACM_CAP_SERIAL_LINE) == 0 &&
            acmp->acm_compatibility == B_TRUE) {

                mutex_exit(&acm_port->acm_port_mutex);
                USB_DPRINTF_L2(PRINT_MASK_ALL, acmp->acm_lh,
                    "usbsacm_ds_set_port_params: "
                    "don't support Set_Line_Coding.");

                return (USB_FAILURE);
        }

        lc = acm_port->acm_line_coding;
        mutex_exit(&acm_port->acm_port_mutex);
        pe = tp->tp_entries;
        /* Get parameter information from ds_port_params_t */
        for (i = 0; i < tp->tp_cnt; i++, pe++) {
                switch (pe->param) {
                case DS_PARAM_BAUD:
                        /* Data terminal rate, in bits per second. */
                        ui = pe->val.ui;

                        /* if we don't support this speed, return USB_FAILURE */
                        if ((ui >= NELEM(usbsacm_speedtab)) ||
                            ((ui > 0) && (usbsacm_speedtab[ui] == 0))) {
                                USB_DPRINTF_L2(PRINT_MASK_EVENTS, acmp->acm_lh,
                                    "usbsacm_ds_set_port_params: "
                                    " error baud rate");

                                return (USB_FAILURE);
                        }
                        lc.dwDTERate = LE_32(usbsacm_speedtab[ui]);

                        break;
                case DS_PARAM_PARITY:
                        /* Parity Type */
                        if (pe->val.ui & PARENB) {
                                if (pe->val.ui & PARODD) {
                                        lc.bParityType = USB_CDC_PARITY_ODD;
                                } else {
                                        lc.bParityType = USB_CDC_PARITY_EVEN;
                                }
                        } else {
                                lc.bParityType = USB_CDC_PARITY_NO;
                        }

                        break;
                case DS_PARAM_STOPB:
                        /* Stop bit */
                        if (pe->val.ui & CSTOPB) {
                                lc.bCharFormat = USB_CDC_STOP_BITS_2;
                        } else {
                                lc.bCharFormat = USB_CDC_STOP_BITS_1;
                        }

                        break;
                case DS_PARAM_CHARSZ:
                        /* Data Bits */
                        switch (pe->val.ui) {
                        case CS5:
                                lc.bDataBits = 5;
                                break;
                        case CS6:
                                lc.bDataBits = 6;
                                break;
                        case CS7:
                                lc.bDataBits = 7;
                                break;
                        case CS8:
                        default:
                                lc.bDataBits = 8;
                                break;
                        }

                        break;
                default:
                        USB_DPRINTF_L2(PRINT_MASK_EVENTS, acmp->acm_lh,
                            "usbsacm_ds_set_port_params: "
                            "parameter 0x%x isn't supported",
                            pe->param);

                        break;
                }
        }

        if ((ret = usbsacm_set_line_coding(acm_port, &lc)) == USB_SUCCESS) {
                mutex_enter(&acm_port->acm_port_mutex);
                acm_port->acm_line_coding = lc;
                mutex_exit(&acm_port->acm_port_mutex);
        }

        /*
         * If device don't conform to acm spec, return success directly.
         */
        if (acmp->acm_compatibility != B_TRUE) {
                ret = USB_SUCCESS;
        }

        return (ret);
}


/*
 * usbsacm_ds_set_modem_ctl:
 *      GSD routine call ds_set_modem_ctl
 *      to set modem control of the given port
 */
/*ARGSUSED*/
static int
usbsacm_ds_set_modem_ctl(ds_hdl_t hdl, uint_t port_num, int mask, int val)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        usbsacm_port_t  *acm_port = &acmp->acm_ports[port_num];
        uint8_t         new_mctl;
        int             ret;

        USB_DPRINTF_L4(PRINT_MASK_ALL, acmp->acm_lh,
            "usbsacm_ds_set_modem_ctl: mask = 0x%x val = 0x%x",
            mask, val);

        mutex_enter(&acm_port->acm_port_mutex);
        /*
         * If device conform to acm spec, check if it support to set modem
         * controls.
         */
        if ((acm_port->acm_cap & USB_CDC_ACM_CAP_SERIAL_LINE) == 0 &&
            acmp->acm_compatibility == B_TRUE) {

                mutex_exit(&acm_port->acm_port_mutex);
                USB_DPRINTF_L2(PRINT_MASK_ALL, acmp->acm_lh,
                    "usbsacm_ds_set_modem_ctl: "
                    "don't support Set_Control_Line_State.");

                return (USB_FAILURE);
        }

        new_mctl = acm_port->acm_mctlout;
        mutex_exit(&acm_port->acm_port_mutex);

        usbsacm_mctl2reg(mask, val, &new_mctl);

        if ((acmp->acm_compatibility == B_FALSE) || ((ret =
            usbsacm_req_write(acm_port, USB_CDC_REQ_SET_CONTROL_LINE_STATE,
            new_mctl, NULL)) == USB_SUCCESS)) {
                mutex_enter(&acm_port->acm_port_mutex);
                acm_port->acm_mctlout = new_mctl;
                mutex_exit(&acm_port->acm_port_mutex);
        }

        /*
         * If device don't conform to acm spec, return success directly.
         */
        if (acmp->acm_compatibility != B_TRUE) {
                ret = USB_SUCCESS;
        }

        return (ret);
}


/*
 * usbsacm_ds_get_modem_ctl:
 *      GSD routine call ds_get_modem_ctl
 *      to get modem control/status of the given port
 */
/*ARGSUSED*/
static int
usbsacm_ds_get_modem_ctl(ds_hdl_t hdl, uint_t port_num, int mask, int *valp)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        usbsacm_port_t  *acm_port = &acmp->acm_ports[port_num];

        mutex_enter(&acm_port->acm_port_mutex);
        *valp = usbsacm_reg2mctl(acm_port->acm_mctlout) & mask;
        /*
         * If device conform to acm spec, polling function can modify the value
         * of acm_mctlin; else set to default value.
         */
        if (acmp->acm_compatibility) {
                *valp |= usbsacm_reg2mctl(acm_port->acm_mctlin) & mask;
                *valp |= (mask & (TIOCM_CD | TIOCM_CTS));
        } else {
                *valp |= (mask & (TIOCM_CD | TIOCM_CTS | TIOCM_DSR | TIOCM_RI));
        }
        mutex_exit(&acm_port->acm_port_mutex);

        USB_DPRINTF_L4(PRINT_MASK_ALL, acmp->acm_lh,
            "usbsacm_ds_get_modem_ctl: val = 0x%x", *valp);

        return (USB_SUCCESS);
}


/*
 * usbsacm_ds_tx:
 *      GSD routine call ds_break_ctl
 *      to set/clear break
 */
/*ARGSUSED*/
static int
usbsacm_ds_break_ctl(ds_hdl_t hdl, uint_t port_num, int ctl)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        usbsacm_port_t  *acm_port = &acmp->acm_ports[port_num];

        USB_DPRINTF_L4(PRINT_MASK_ALL, acmp->acm_lh,
            "usbsacm_ds_break_ctl: ");

        mutex_enter(&acm_port->acm_port_mutex);
        /*
         * If device conform to acm spec, check if it support to send break.
         */
        if ((acm_port->acm_cap & USB_CDC_ACM_CAP_SEND_BREAK) == 0 &&
            acmp->acm_compatibility == B_TRUE) {

                mutex_exit(&acm_port->acm_port_mutex);
                USB_DPRINTF_L2(PRINT_MASK_ALL, acmp->acm_lh,
                    "usbsacm_ds_break_ctl: don't support send break.");

                return (USB_FAILURE);
        }
        mutex_exit(&acm_port->acm_port_mutex);

        return (usbsacm_req_write(acm_port, USB_CDC_REQ_SEND_BREAK,
            ((ctl == DS_ON) ? 0xffff : 0), NULL));
}


/*
 * usbsacm_ds_tx:
 *      GSD routine call ds_tx
 *      to data transmit
 */
/*ARGSUSED*/
static int
usbsacm_ds_tx(ds_hdl_t hdl, uint_t port_num, mblk_t *mp)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        usbsacm_port_t  *acm_port = &acmp->acm_ports[port_num];

        USB_DPRINTF_L4(PRINT_MASK_ALL, acmp->acm_lh,
            "usbsacm_ds_tx: mp = 0x%p acmp = 0x%p", (void *)mp, (void *)acmp);

        /* sanity checks */
        if (mp == NULL) {

                return (USB_SUCCESS);
        }
        if (MBLKL(mp) < 1) {
                freemsg(mp);

                return (USB_SUCCESS);
        }

        mutex_enter(&acm_port->acm_port_mutex);
        /* put mblk to tail of mblk chain */
        usbsacm_put_tail(&acm_port->acm_tx_mp, mp);
        usbsacm_tx_start(acm_port);
        mutex_exit(&acm_port->acm_port_mutex);

        return (USB_SUCCESS);
}


/*
 * usbsacm_ds_rx:
 *      GSD routine call ds_rx;
 *      to data receipt
 */
/*ARGSUSED*/
static mblk_t *
usbsacm_ds_rx(ds_hdl_t hdl, uint_t port_num)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        usbsacm_port_t  *acm_port = &acmp->acm_ports[port_num];
        mblk_t          *mp;

        USB_DPRINTF_L4(PRINT_MASK_ALL, acmp->acm_lh,
            "usbsacm_ds_rx: acmp = 0x%p", (void *)acmp);

        mutex_enter(&acm_port->acm_port_mutex);

        mp = acm_port->acm_rx_mp;
        acm_port->acm_rx_mp = NULL;
        mutex_exit(&acm_port->acm_port_mutex);

        return (mp);
}


/*
 * usbsacm_ds_stop:
 *      GSD routine call ds_stop;
 *      but acm spec don't define this function
 */
/*ARGSUSED*/
static void
usbsacm_ds_stop(ds_hdl_t hdl, uint_t port_num, int dir)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;

        USB_DPRINTF_L2(PRINT_MASK_EVENTS, acmp->acm_lh,
            "usbsacm_ds_stop: don't support!");
}


/*
 * usbsacm_ds_start:
 *      GSD routine call ds_start;
 *      but acm spec don't define this function
 */
/*ARGSUSED*/
static void
usbsacm_ds_start(ds_hdl_t hdl, uint_t port_num, int dir)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;

        USB_DPRINTF_L2(PRINT_MASK_EVENTS, acmp->acm_lh,
            "usbsacm_ds_start: don't support!");
}


/*
 * usbsacm_ds_fifo_flush:
 *      GSD routine call ds_fifo_flush
 *      to flush FIFOs
 */
/*ARGSUSED*/
static int
usbsacm_ds_fifo_flush(ds_hdl_t hdl, uint_t port_num, int dir)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        usbsacm_port_t  *acm_port = &acmp->acm_ports[port_num];
        int             ret = USB_SUCCESS;

        USB_DPRINTF_L4(PRINT_MASK_ALL, acmp->acm_lh,
            "usbsacm_ds_fifo_flush: ");

        mutex_enter(&acm_port->acm_port_mutex);
        ret = usbsacm_fifo_flush_locked(acmp, port_num, dir);
        mutex_exit(&acm_port->acm_port_mutex);

        return (ret);
}


/*
 * usbsacm_ds_fifo_drain:
 *      GSD routine call ds_fifo_drain
 *      to wait until empty output FIFO
 */
/*ARGSUSED*/
static int
usbsacm_ds_fifo_drain(ds_hdl_t hdl, uint_t port_num, int timeout)
{
        usbsacm_state_t *acmp = (usbsacm_state_t *)hdl;
        usbsacm_port_t  *acm_port = &acmp->acm_ports[port_num];
        int             rval = USB_SUCCESS;

        USB_DPRINTF_L4(PRINT_MASK_EVENTS, acmp->acm_lh,
            "usbsacm_ds_fifo_drain: ");

        mutex_enter(&acm_port->acm_port_mutex);
        ASSERT(acm_port->acm_port_state == USBSACM_PORT_OPEN);

        if (usbsacm_wait_tx_drain(acm_port, timeout) != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_EVENTS, acmp->acm_lh,
                    "usbsacm_ds_fifo_drain: fifo drain failed.");
                mutex_exit(&acm_port->acm_port_mutex);

                return (USB_FAILURE);
        }

        mutex_exit(&acm_port->acm_port_mutex);

        return (rval);
}


/*
 * usbsacm_fifo_flush_locked:
 *      flush FIFOs of the given ports
 */
/*ARGSUSED*/
static int
usbsacm_fifo_flush_locked(usbsacm_state_t *acmp, uint_t port_num, int dir)
{
        usbsacm_port_t  *acm_port = &acmp->acm_ports[port_num];

        USB_DPRINTF_L4(PRINT_MASK_EVENTS, acmp->acm_lh,
            "usbsacm_fifo_flush_locked: ");

        /* flush transmit FIFO if DS_TX is set */
        if ((dir & DS_TX) && acm_port->acm_tx_mp) {
                freemsg(acm_port->acm_tx_mp);
                acm_port->acm_tx_mp = NULL;
        }
        /* flush received FIFO if DS_RX is set */
        if ((dir & DS_RX) && acm_port->acm_rx_mp) {
                freemsg(acm_port->acm_rx_mp);
                acm_port->acm_rx_mp = NULL;
        }

        return (USB_SUCCESS);
}


/*
 * usbsacm_get_bulk_pipe_number:
 *      Calculate the number of bulk in or out pipes in current device.
 */
static int
usbsacm_get_bulk_pipe_number(usbsacm_state_t *acmp, uint_t dir)
{
        int             count = 0;
        int             i, skip;
        usb_if_data_t   *cur_if;
        int             ep_num;
        int             if_num;

        USB_DPRINTF_L4(PRINT_MASK_ATTA, acmp->acm_lh,
            "usbsacm_get_bulk_pipe_number: ");

        cur_if = acmp->acm_dev_data->dev_curr_cfg->cfg_if;
        if_num = acmp->acm_dev_data->dev_curr_cfg->cfg_n_if;

        /* search each interface which have bulk endpoint */
        for (i = 0; i < if_num; i++) {
                ep_num = cur_if->if_alt->altif_n_ep;

                /*
                 * search endpoints in current interface,
                 * which type is input parameter 'dir'
                 */
                for (skip = 0; skip < ep_num; skip++) {
                        if (usb_lookup_ep_data(acmp->acm_dip,
                            acmp->acm_dev_data, i, 0, skip,
                            USB_EP_ATTR_BULK, dir) == NULL) {

                                /*
                                 * If not found, skip the internal loop
                                 * and search the next interface.
                                 */
                                break;
                        }
                        count++;
                }

                cur_if++;
        }

        return (count);
}


/*
 * port management
 * ---------------
 *      initialize, release port.
 *
 *
 * usbsacm_init_ports_status:
 *      Initialize the port status for the current device.
 */
static int
usbsacm_init_ports_status(usbsacm_state_t *acmp)
{
        usbsacm_port_t  *cur_port;
        int             i, skip;
        int             if_num;
        int             intr_if_no = 0;
        int             ep_num;
        usb_if_data_t   *cur_if;

        USB_DPRINTF_L4(PRINT_MASK_OPEN, acmp->acm_lh,
            "usbsacm_init_ports_status: acmp = 0x%p", (void *)acmp);

        /* Initialize the port status to default value */
        for (i = 0; i < acmp->acm_port_cnt; i++) {
                cur_port = &acmp->acm_ports[i];

                cv_init(&cur_port->acm_tx_cv, NULL, CV_DRIVER, NULL);

                cur_port->acm_port_state = USBSACM_PORT_CLOSED;

                cur_port->acm_line_coding.dwDTERate = LE_32((uint32_t)9600);
                cur_port->acm_line_coding.bCharFormat = 0;
                cur_port->acm_line_coding.bParityType = USB_CDC_PARITY_NO;
                cur_port->acm_line_coding.bDataBits = 8;
                cur_port->acm_device = acmp;
                mutex_init(&cur_port->acm_port_mutex, NULL, MUTEX_DRIVER,
                    acmp->acm_dev_data->dev_iblock_cookie);
        }

        /*
         * If device conform to cdc acm spec, parse function descriptors.
         */
        if (acmp->acm_compatibility == B_TRUE) {

                if (usbsacm_get_descriptors(acmp) != USB_SUCCESS) {

                        return (USB_FAILURE);
                }

                return (USB_SUCCESS);
        }

        /*
         * If device don't conform to spec, search pairs of bulk in/out
         * endpoints and fill port structure.
         */
        cur_if = acmp->acm_dev_data->dev_curr_cfg->cfg_if;
        if_num = acmp->acm_dev_data->dev_curr_cfg->cfg_n_if;
        cur_port = acmp->acm_ports;

        /* search each interface which have bulk in and out */
        for (i = 0; i < if_num; i++) {
                ep_num = cur_if->if_alt->altif_n_ep;

                for (skip = 0; skip < ep_num; skip++) {

                /* search interrupt pipe. */
                if ((usb_lookup_ep_data(acmp->acm_dip, acmp->acm_dev_data,
                    i, 0, skip, USB_EP_ATTR_INTR, USB_EP_DIR_IN) != NULL)) {

                        intr_if_no = i;
                }

                /* search pair of bulk in/out endpoints. */
                if ((usb_lookup_ep_data(acmp->acm_dip, acmp->acm_dev_data,
                    i, 0, skip, USB_EP_ATTR_BULK, USB_EP_DIR_IN) == NULL) ||
                    (usb_lookup_ep_data(acmp->acm_dip, acmp->acm_dev_data,
                    i, 0, skip, USB_EP_ATTR_BULK, USB_EP_DIR_OUT) == NULL)) {

                        continue;
                }

                cur_port->acm_data_if_no = i;
                cur_port->acm_ctrl_if_no = intr_if_no;
                cur_port->acm_data_port_no = skip;
                cur_port++;
                intr_if_no = 0;
                }

                cur_if++;
        }

        return (USB_SUCCESS);
}


/*
 * usbsacm_init_alloc_ports:
 *      Allocate memory and initialize the port state for the current device.
 */
static int
usbsacm_init_alloc_ports(usbsacm_state_t *acmp)
{
        int             rval = USB_SUCCESS;
        int             count_in = 0, count_out = 0;

        if (acmp->acm_compatibility) {
                acmp->acm_port_cnt = 1;
        } else {
                /* Calculate the number of the bulk in/out endpoints */
                count_in = usbsacm_get_bulk_pipe_number(acmp, USB_EP_DIR_IN);
                count_out = usbsacm_get_bulk_pipe_number(acmp, USB_EP_DIR_OUT);

                USB_DPRINTF_L3(PRINT_MASK_OPEN, acmp->acm_lh,
                    "usbsacm_init_alloc_ports: count_in = %d, count_out = %d",
                    count_in, count_out);

                acmp->acm_port_cnt = min(count_in, count_out);
        }

        /* return if not found any pair of bulk in/out endpoint. */
        if (acmp->acm_port_cnt == 0) {
                USB_DPRINTF_L2(PRINT_MASK_OPEN, acmp->acm_lh,
                    "usbsacm_init_alloc_ports: port count is zero.");

                return (USB_FAILURE);
        }

        /* allocate memory for ports */
        acmp->acm_ports = (usbsacm_port_t *)kmem_zalloc(acmp->acm_port_cnt *
            sizeof (usbsacm_port_t), KM_SLEEP);
        if (acmp->acm_ports == NULL) {
                USB_DPRINTF_L2(PRINT_MASK_OPEN, acmp->acm_lh,
                    "usbsacm_init_alloc_ports: allocate memory failed.");

                return (USB_FAILURE);
        }

        /* fill the status of port structure. */
        rval = usbsacm_init_ports_status(acmp);
        if (rval != USB_SUCCESS) {
                usbsacm_free_ports(acmp);
        }

        return (rval);
}


/*
 * usbsacm_free_ports:
 *      Release ports and deallocate memory.
 */
static void
usbsacm_free_ports(usbsacm_state_t *acmp)
{
        int             i;

        USB_DPRINTF_L4(PRINT_MASK_CLOSE, acmp->acm_lh,
            "usbsacm_free_ports: ");

        /* Release memory and data structure for each port */
        for (i = 0; i < acmp->acm_port_cnt; i++) {
                cv_destroy(&acmp->acm_ports[i].acm_tx_cv);
                mutex_destroy(&acmp->acm_ports[i].acm_port_mutex);
        }
        kmem_free((caddr_t)acmp->acm_ports, sizeof (usbsacm_port_t) *
            acmp->acm_port_cnt);
        acmp->acm_ports = NULL;
}


/*
 * usbsacm_get_descriptors:
 *      analysis functional descriptors of acm device
 */
static int
usbsacm_get_descriptors(usbsacm_state_t *acmp)
{
        int                     i;
        usb_cfg_data_t          *cfg;
        usb_alt_if_data_t       *altif;
        usb_cvs_data_t          *cvs;
        int                     mgmt_cap = 0;
        int                     master_if = -1, slave_if = -1;
        usbsacm_port_t          *acm_port = acmp->acm_ports;
        usb_dev_descr_t         *dd;

        USB_DPRINTF_L4(PRINT_MASK_ATTA, acmp->acm_lh,
            "usbsacm_get_descriptors: ");

        dd = acmp->acm_dev_data->dev_descr;
        cfg = acmp->acm_dev_data->dev_curr_cfg;
        /* set default control and data interface */
        acm_port->acm_ctrl_if_no = acm_port->acm_data_if_no = 0;

        /* get current interfaces */
        acm_port->acm_ctrl_if_no = acmp->acm_dev_data->dev_curr_if;
        if (cfg->cfg_if[acm_port->acm_ctrl_if_no].if_n_alt == 0) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_get_descriptors: elements in if_alt is %d",
                    cfg->cfg_if[acm_port->acm_ctrl_if_no].if_n_alt);

                return (USB_FAILURE);
        }

        altif = &cfg->cfg_if[acm_port->acm_ctrl_if_no].if_alt[0];

        /*
         * Based on CDC specification, ACM devices usually include the
         * following function descriptors: Header, ACM, Union and Call
         * Management function descriptors. This loop search tree data
         * structure for each acm class descriptor.
         */
        for (i = 0; i < altif->altif_n_cvs; i++) {

                cvs = &altif->altif_cvs[i];

                if ((cvs->cvs_buf == NULL) ||
                    (cvs->cvs_buf[1] != USB_CDC_CS_INTERFACE)) {
                        continue;
                }

                switch (cvs->cvs_buf[2]) {
                case USB_CDC_DESCR_TYPE_CALL_MANAGEMENT:
                        /* parse call management functional descriptor. */
                        if (cvs->cvs_buf_len >= 5) {
                                mgmt_cap = cvs->cvs_buf[3];
                                acm_port->acm_data_if_no = cvs->cvs_buf[4];
                        }
                        break;
                case USB_CDC_DESCR_TYPE_ACM:
                        /* parse ACM functional descriptor. */
                        if (cvs->cvs_buf_len >= 4) {
                                acm_port->acm_cap = cvs->cvs_buf[3];
                        }

                        /*
                         * The Sigma Designs, Inc. USB device does not report
                         * itself as implementing the full ACM spec. However,
                         * it does function as a usb serial modem, so we opt to
                         * scribble in the reported functionality if we
                         * determine the USB device matches this vendor
                         * and product ID.
                         */
                        if (dd->idVendor == USB_VENDOR_SIGMADESIGNS &&
                            dd->idProduct == USB_PRODUCT_SIGMADESIGNS_ZW090) {
                                acm_port->acm_cap |=
                                    USB_CDC_ACM_CAP_SERIAL_LINE;
                        }
                        break;
                case USB_CDC_DESCR_TYPE_UNION:
                        /* parse Union functional descriptor. */
                        if (cvs->cvs_buf_len >= 5) {
                                master_if = cvs->cvs_buf[3];
                                slave_if = cvs->cvs_buf[4];
                        }
                        break;
                default:
                        break;
                }
        }

        /* For usb acm devices, it must satisfy the following options. */
        if (cfg->cfg_n_if < 2) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_get_descriptors: # of interfaces %d < 2",
                    cfg->cfg_n_if);

                return (USB_FAILURE);
        }

        if (acm_port->acm_data_if_no == 0 &&
            slave_if != acm_port->acm_data_if_no) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_get_descriptors: Device hasn't call management "
                    "descriptor and use Union Descriptor.");

                acm_port->acm_data_if_no = slave_if;
        }

        if ((master_if != acm_port->acm_ctrl_if_no) ||
            (slave_if != acm_port->acm_data_if_no)) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_get_descriptors: control interface or "
                    "data interface don't match.");

                return (USB_FAILURE);
        }

        /*
         * We usually need both call and data capabilities, but
         * some devices, such as Nokia mobile phones, don't provide
         * call management descriptor, so we just give a warning
         * message.
         */
        if (((mgmt_cap & USB_CDC_CALL_MGMT_CAP_CALL_MGMT) == 0) ||
            ((mgmt_cap & USB_CDC_CALL_MGMT_CAP_DATA_INTERFACE) == 0)) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_get_descriptors: "
                    "insufficient mgmt capabilities %x",
                    mgmt_cap);
        }

        if ((acm_port->acm_ctrl_if_no >= cfg->cfg_n_if) ||
            (acm_port->acm_data_if_no >= cfg->cfg_n_if)) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_get_descriptors: control interface %d or "
                    "data interface %d out of range.",
                    acm_port->acm_ctrl_if_no, acm_port->acm_data_if_no);

                return (USB_FAILURE);
        }

        /* control interface must have interrupt endpoint */
        if (usb_lookup_ep_data(acmp->acm_dip, acmp->acm_dev_data,
            acm_port->acm_ctrl_if_no, 0, 0, USB_EP_ATTR_INTR,
            USB_EP_DIR_IN) == NULL) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_get_descriptors: "
                    "ctrl interface %d has no interrupt endpoint",
                    acm_port->acm_data_if_no);

                return (USB_FAILURE);
        }

        /* data interface must have bulk in and out */
        if (usb_lookup_ep_data(acmp->acm_dip, acmp->acm_dev_data,
            acm_port->acm_data_if_no, 0, 0, USB_EP_ATTR_BULK,
            USB_EP_DIR_IN) == NULL) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_get_descriptors: "
                    "data interface %d has no bulk in endpoint",
                    acm_port->acm_data_if_no);

                return (USB_FAILURE);
        }
        if (usb_lookup_ep_data(acmp->acm_dip, acmp->acm_dev_data,
            acm_port->acm_data_if_no, 0, 0, USB_EP_ATTR_BULK,
            USB_EP_DIR_OUT) == NULL) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_get_descriptors: "
                    "data interface %d has no bulk out endpoint",
                    acm_port->acm_data_if_no);

                return (USB_FAILURE);
        }

        return (USB_SUCCESS);
}


/*
 * usbsacm_cleanup:
 *      Release resources of current device during detach.
 */
static void
usbsacm_cleanup(usbsacm_state_t *acmp)
{
        USB_DPRINTF_L4(PRINT_MASK_CLOSE, acmp->acm_lh,
            "usbsacm_cleanup: ");

        if (acmp != NULL) {
                /* free ports */
                if (acmp->acm_ports != NULL) {
                        usbsacm_free_ports(acmp);
                }

                /* unregister callback function */
                if (acmp->acm_usb_events != NULL) {
                        usb_unregister_event_cbs(acmp->acm_dip,
                            acmp->acm_usb_events);
                }

                /* destroy power management components */
                if (acmp->acm_pm != NULL) {
                        usbsacm_destroy_pm_components(acmp);
                }

                /* free description of device tree. */
                if (acmp->acm_def_ph != NULL) {
                        mutex_destroy(&acmp->acm_mutex);

                        usb_free_descr_tree(acmp->acm_dip, acmp->acm_dev_data);
                        acmp->acm_def_ph = NULL;
                }

                if (acmp->acm_lh != NULL) {
                        usb_free_log_hdl(acmp->acm_lh);
                        acmp->acm_lh = NULL;
                }

                /* detach client device */
                if (acmp->acm_dev_data != NULL) {
                        usb_client_detach(acmp->acm_dip, acmp->acm_dev_data);
                }

                kmem_free((caddr_t)acmp, sizeof (usbsacm_state_t));
        }
}


/*
 * usbsacm_restore_device_state:
 *      restore device state after CPR resume or reconnect
 */
static int
usbsacm_restore_device_state(usbsacm_state_t *acmp)
{
        int     state;

        USB_DPRINTF_L4(PRINT_MASK_ALL, acmp->acm_lh,
            "usbsacm_restore_device_state: ");

        mutex_enter(&acmp->acm_mutex);
        state = acmp->acm_dev_state;
        mutex_exit(&acmp->acm_mutex);

        /* Check device status */
        if ((state != USB_DEV_DISCONNECTED) && (state != USB_DEV_SUSPENDED)) {

                return (state);
        }

        /* Check if we are talking to the same device */
        if (usb_check_same_device(acmp->acm_dip, acmp->acm_lh, USB_LOG_L0,
            -1, USB_CHK_ALL, NULL) != USB_SUCCESS) {
                mutex_enter(&acmp->acm_mutex);
                state = acmp->acm_dev_state = USB_DEV_DISCONNECTED;
                mutex_exit(&acmp->acm_mutex);

                return (state);
        }

        if (state == USB_DEV_DISCONNECTED) {
                USB_DPRINTF_L1(PRINT_MASK_ALL, acmp->acm_lh,
                    "usbsacm_restore_device_state: Device has been reconnected "
                    "but data may have been lost");
        }

        /* reconnect pipes */
        if (usbsacm_reconnect_pipes(acmp) != USB_SUCCESS) {

                return (state);
        }

        /*
         * init device state
         */
        mutex_enter(&acmp->acm_mutex);
        state = acmp->acm_dev_state = USB_DEV_ONLINE;
        mutex_exit(&acmp->acm_mutex);

        if ((usbsacm_restore_port_state(acmp) != USB_SUCCESS)) {
                USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                    "usbsacm_restore_device_state: failed");
        }

        return (state);
}


/*
 * usbsacm_restore_port_state:
 *      restore ports state after CPR resume or reconnect
 */
static int
usbsacm_restore_port_state(usbsacm_state_t *acmp)
{
        int             i, ret = USB_SUCCESS;
        usbsacm_port_t  *cur_port;

        USB_DPRINTF_L4(PRINT_MASK_ALL, acmp->acm_lh,
            "usbsacm_restore_port_state: ");

        /* restore status of all ports */
        for (i = 0; i < acmp->acm_port_cnt; i++) {
                cur_port = &acmp->acm_ports[i];
                mutex_enter(&cur_port->acm_port_mutex);
                if (cur_port->acm_port_state != USBSACM_PORT_OPEN) {
                        mutex_exit(&cur_port->acm_port_mutex);

                        continue;
                }
                mutex_exit(&cur_port->acm_port_mutex);

                if ((ret = usbsacm_set_line_coding(cur_port,
                    &cur_port->acm_line_coding)) != USB_SUCCESS) {
                        USB_DPRINTF_L2(PRINT_MASK_ATTA, acmp->acm_lh,
                            "usbsacm_restore_port_state: failed.");
                }
        }

        return (ret);
}


/*
 * pipe management
 * ---------------
 *
 *
 * usbsacm_open_port_pipes:
 *      Open pipes of one port and set port structure;
 *      Each port includes three pipes: bulk in, bulk out and interrupt.
 */
static int
usbsacm_open_port_pipes(usbsacm_port_t *acm_port)
{
        int             rval = USB_SUCCESS;
        usbsacm_state_t *acmp = acm_port->acm_device;
        usb_ep_data_t   *in_data, *out_data, *intr_pipe;
        usb_pipe_policy_t policy;

        USB_DPRINTF_L4(PRINT_MASK_OPEN, acmp->acm_lh,
            "usbsacm_open_port_pipes: acmp = 0x%p", (void *)acmp);

        /* Get bulk and interrupt endpoint data */
        intr_pipe = usb_lookup_ep_data(acmp->acm_dip, acmp->acm_dev_data,
            acm_port->acm_ctrl_if_no, 0, 0,
            USB_EP_ATTR_INTR, USB_EP_DIR_IN);
        in_data = usb_lookup_ep_data(acmp->acm_dip, acmp->acm_dev_data,
            acm_port->acm_data_if_no, 0, acm_port->acm_data_port_no,
            USB_EP_ATTR_BULK, USB_EP_DIR_IN);
        out_data = usb_lookup_ep_data(acmp->acm_dip, acmp->acm_dev_data,
            acm_port->acm_data_if_no, 0, acm_port->acm_data_port_no,
            USB_EP_ATTR_BULK, USB_EP_DIR_OUT);

        /* Bulk in and out must exist meanwhile. */
        if ((in_data == NULL) || (out_data == NULL)) {
                USB_DPRINTF_L2(PRINT_MASK_OPEN, acmp->acm_lh,
                    "usbsacm_open_port_pipes: look up bulk pipe failed in "
                    "interface %d port %d",
                    acm_port->acm_data_if_no, acm_port->acm_data_port_no);

                return (USB_FAILURE);
        }

        /*
         * If device conform to acm spec, it must have an interrupt pipe
         * for this port.
         */
        if (acmp->acm_compatibility == B_TRUE && intr_pipe == NULL) {
                USB_DPRINTF_L2(PRINT_MASK_OPEN, acmp->acm_lh,
                    "usbsacm_open_port_pipes: look up interrupt pipe failed in "
                    "interface %d", acm_port->acm_ctrl_if_no);

                return (USB_FAILURE);
        }

        policy.pp_max_async_reqs = 2;

        /* Open bulk in endpoint */
        if (usb_pipe_open(acmp->acm_dip, &in_data->ep_descr, &policy,
            USB_FLAGS_SLEEP, &acm_port->acm_bulkin_ph) != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_OPEN, acmp->acm_lh,
                    "usbsacm_open_port_pipes: open bulkin pipe failed!");

                return (USB_FAILURE);
        }

        /* Open bulk out endpoint */
        if (usb_pipe_open(acmp->acm_dip, &out_data->ep_descr, &policy,
            USB_FLAGS_SLEEP, &acm_port->acm_bulkout_ph) != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_OPEN, acmp->acm_lh,
                    "usbsacm_open_port_pipes: open bulkout pipe failed!");

                usb_pipe_close(acmp->acm_dip, acm_port->acm_bulkin_ph,
                    USB_FLAGS_SLEEP, NULL, NULL);

                return (USB_FAILURE);
        }

        /* Open interrupt endpoint if found. */
        if (intr_pipe != NULL) {

                if (usb_pipe_open(acmp->acm_dip, &intr_pipe->ep_descr, &policy,
                    USB_FLAGS_SLEEP, &acm_port->acm_intr_ph) != USB_SUCCESS) {
                        USB_DPRINTF_L2(PRINT_MASK_OPEN, acmp->acm_lh,
                            "usbsacm_open_port_pipes: "
                            "open control pipe failed");

                        usb_pipe_close(acmp->acm_dip, acm_port->acm_bulkin_ph,
                            USB_FLAGS_SLEEP, NULL, NULL);
                        usb_pipe_close(acmp->acm_dip, acm_port->acm_bulkout_ph,
                            USB_FLAGS_SLEEP, NULL, NULL);

                        return (USB_FAILURE);
                }
        }

        /* initialize the port structure. */
        mutex_enter(&acm_port->acm_port_mutex);
        acm_port->acm_bulkin_size = in_data->ep_descr.wMaxPacketSize;
        acm_port->acm_bulkin_state = USBSACM_PIPE_IDLE;
        acm_port->acm_bulkout_state = USBSACM_PIPE_IDLE;
        if (acm_port->acm_intr_ph != NULL) {
                acm_port->acm_intr_state = USBSACM_PIPE_IDLE;
                acm_port->acm_intr_ep_descr = intr_pipe->ep_descr;
        }
        mutex_exit(&acm_port->acm_port_mutex);

        if (acm_port->acm_intr_ph != NULL) {

                usbsacm_pipe_start_polling(acm_port);
        }

        return (rval);
}


/*
 * usbsacm_close_port_pipes:
 *      Close pipes of one port and reset port structure to closed;
 *      Each port includes three pipes: bulk in, bulk out and interrupt.
 */
static void
usbsacm_close_port_pipes(usbsacm_port_t *acm_port)
{
        usbsacm_state_t *acmp = acm_port->acm_device;

        mutex_enter(&acm_port->acm_port_mutex);
        USB_DPRINTF_L4(PRINT_MASK_CLOSE, acmp->acm_lh,
            "usbsacm_close_port_pipes: acm_bulkin_state = %d",
            acm_port->acm_bulkin_state);

        /*
         * Check the status of the given port. If port is closing or closed,
         * return directly.
         */
        if ((acm_port->acm_bulkin_state == USBSACM_PIPE_CLOSED) ||
            (acm_port->acm_bulkin_state == USBSACM_PIPE_CLOSING)) {
                USB_DPRINTF_L2(PRINT_MASK_CLOSE, acmp->acm_lh,
                    "usbsacm_close_port_pipes: port is closing or has closed");
                mutex_exit(&acm_port->acm_port_mutex);

                return;
        }

        acm_port->acm_bulkin_state = USBSACM_PIPE_CLOSING;
        mutex_exit(&acm_port->acm_port_mutex);

        /* Close pipes */
        usb_pipe_reset(acmp->acm_dip, acm_port->acm_bulkin_ph,
            USB_FLAGS_SLEEP, 0, 0);
        usb_pipe_close(acmp->acm_dip, acm_port->acm_bulkin_ph,
            USB_FLAGS_SLEEP, 0, 0);
        usb_pipe_close(acmp->acm_dip, acm_port->acm_bulkout_ph,
            USB_FLAGS_SLEEP, 0, 0);
        if (acm_port->acm_intr_ph != NULL) {
                usb_pipe_stop_intr_polling(acm_port->acm_intr_ph,
                    USB_FLAGS_SLEEP);
                usb_pipe_close(acmp->acm_dip, acm_port->acm_intr_ph,
                    USB_FLAGS_SLEEP, 0, 0);
        }

        mutex_enter(&acm_port->acm_port_mutex);
        /* Reset the status of pipes to closed */
        acm_port->acm_bulkin_state = USBSACM_PIPE_CLOSED;
        acm_port->acm_bulkin_ph = NULL;
        acm_port->acm_bulkout_state = USBSACM_PIPE_CLOSED;
        acm_port->acm_bulkout_ph = NULL;
        if (acm_port->acm_intr_ph != NULL) {
                acm_port->acm_intr_state = USBSACM_PIPE_CLOSED;
                acm_port->acm_intr_ph = NULL;
        }

        mutex_exit(&acm_port->acm_port_mutex);

        USB_DPRINTF_L4(PRINT_MASK_CLOSE, acmp->acm_lh,
            "usbsacm_close_port_pipes: port has been closed.");
}


/*
 * usbsacm_close_pipes:
 *      close all opened pipes of current devices.
 */
static void
usbsacm_close_pipes(usbsacm_state_t *acmp)
{
        int             i;

        USB_DPRINTF_L4(PRINT_MASK_CLOSE, acmp->acm_lh,
            "usbsacm_close_pipes: ");

        /* Close all ports */
        for (i = 0; i < acmp->acm_port_cnt; i++) {
                usbsacm_close_port_pipes(&acmp->acm_ports[i]);
        }
}


/*
 * usbsacm_disconnect_pipes:
 *      this function just call usbsacm_close_pipes.
 */
static void
usbsacm_disconnect_pipes(usbsacm_state_t *acmp)
{
        USB_DPRINTF_L4(PRINT_MASK_CLOSE, acmp->acm_lh,
            "usbsacm_disconnect_pipes: ");

        usbsacm_close_pipes(acmp);
}


/*
 * usbsacm_reconnect_pipes:
 *      reconnect pipes in CPR resume or reconnect
 */
static int
usbsacm_reconnect_pipes(usbsacm_state_t *acmp)
{
        usbsacm_port_t  *cur_port = acmp->acm_ports;
        int             i;

        USB_DPRINTF_L4(PRINT_MASK_OPEN, acmp->acm_lh,
            "usbsacm_reconnect_pipes: ");

        /* reopen all ports of current device. */
        for (i = 0; i < acmp->acm_port_cnt; i++) {
                cur_port = &acmp->acm_ports[i];

                mutex_enter(&cur_port->acm_port_mutex);
                /*
                 * If port status is open, reopen it;
                 * else retain the current status.
                 */
                if (cur_port->acm_port_state == USBSACM_PORT_OPEN) {

                        mutex_exit(&cur_port->acm_port_mutex);
                        if (usbsacm_open_port_pipes(cur_port) != USB_SUCCESS) {
                                USB_DPRINTF_L4(PRINT_MASK_OPEN, acmp->acm_lh,
                                    "usbsacm_reconnect_pipes: "
                                    "open port %d failed.", i);

                                return (USB_FAILURE);
                        }
                        mutex_enter(&cur_port->acm_port_mutex);
                }
                mutex_exit(&cur_port->acm_port_mutex);
        }

        return (USB_SUCCESS);
}

/*
 * usbsacm_bulkin_cb:
 *      Bulk In regular and exeception callback;
 *      USBA framework will call this callback
 *      after deal with bulkin request.
 */
/*ARGSUSED*/
static void
usbsacm_bulkin_cb(usb_pipe_handle_t pipe, usb_bulk_req_t *req)
{
        usbsacm_port_t  *acm_port = (usbsacm_port_t *)req->bulk_client_private;
        usbsacm_state_t *acmp = acm_port->acm_device;
        mblk_t          *data;
        int             data_len;

        data = req->bulk_data;
        data_len = (data) ? MBLKL(data) : 0;

        mutex_enter(&acm_port->acm_port_mutex);
        USB_DPRINTF_L4(PRINT_MASK_EVENTS, acmp->acm_lh,
            "usbsacm_bulkin_cb: "
            "acm_bulkin_state = %d acm_port_state = %d data_len = %d",
            acm_port->acm_bulkin_state, acm_port->acm_port_state, data_len);

        if ((acm_port->acm_port_state == USBSACM_PORT_OPEN) && (data_len) &&
            (req->bulk_completion_reason == USB_CR_OK)) {
                mutex_exit(&acm_port->acm_port_mutex);
                /* prevent USBA from freeing data along with the request */
                req->bulk_data = NULL;

                /* save data on the receive list */
                usbsacm_put_tail(&acm_port->acm_rx_mp, data);

                /* invoke GSD receive callback */
                if (acm_port->acm_cb.cb_rx) {
                        acm_port->acm_cb.cb_rx(acm_port->acm_cb.cb_arg);
                }
                mutex_enter(&acm_port->acm_port_mutex);
        }
        mutex_exit(&acm_port->acm_port_mutex);

        usb_free_bulk_req(req);

        /* receive more */
        mutex_enter(&acm_port->acm_port_mutex);
        if (((acm_port->acm_bulkin_state == USBSACM_PIPE_BUSY) ||
            (acm_port->acm_bulkin_state == USBSACM_PIPE_IDLE)) &&
            (acm_port->acm_port_state == USBSACM_PORT_OPEN) &&
            (acmp->acm_dev_state == USB_DEV_ONLINE)) {
                if (usbsacm_rx_start(acm_port) != USB_SUCCESS) {
                        USB_DPRINTF_L2(PRINT_MASK_EVENTS, acmp->acm_lh,
                            "usbsacm_bulkin_cb: restart rx fail "
                            "acm_port_state = %d", acm_port->acm_port_state);
                }
        } else if (acm_port->acm_bulkin_state == USBSACM_PIPE_BUSY) {
                acm_port->acm_bulkin_state = USBSACM_PIPE_IDLE;
        }
        mutex_exit(&acm_port->acm_port_mutex);
}


/*
 * usbsacm_bulkout_cb:
 *      Bulk Out regular and exeception callback;
 *      USBA framework will call this callback function
 *      after deal with bulkout request.
 */
/*ARGSUSED*/
static void
usbsacm_bulkout_cb(usb_pipe_handle_t pipe, usb_bulk_req_t *req)
{
        usbsacm_port_t  *acm_port = (usbsacm_port_t *)req->bulk_client_private;
        usbsacm_state_t *acmp = acm_port->acm_device;
        int             data_len;
        mblk_t          *data = req->bulk_data;

        USB_DPRINTF_L4(PRINT_MASK_EVENTS, acmp->acm_lh,
            "usbsacm_bulkout_cb: acmp = 0x%p", (void *)acmp);

        data_len = (req->bulk_data) ? MBLKL(req->bulk_data) : 0;

        /* put untransferred residue back on the transfer list */
        if (req->bulk_completion_reason && (data_len > 0)) {
                usbsacm_put_head(&acm_port->acm_tx_mp, data);
                req->bulk_data = NULL;
        }

        usb_free_bulk_req(req);

        /* invoke GSD transmit callback */
        if (acm_port->acm_cb.cb_tx) {
                acm_port->acm_cb.cb_tx(acm_port->acm_cb.cb_arg);
        }

        /* send more */
        mutex_enter(&acm_port->acm_port_mutex);
        acm_port->acm_bulkout_state = USBSACM_PIPE_IDLE;
        if (acm_port->acm_tx_mp == NULL) {
                cv_broadcast(&acm_port->acm_tx_cv);
        } else {
                usbsacm_tx_start(acm_port);
        }
        mutex_exit(&acm_port->acm_port_mutex);
}


/*
 * usbsacm_rx_start:
 *      start data receipt
 */
static int
usbsacm_rx_start(usbsacm_port_t *acm_port)
{
        usbsacm_state_t *acmp = acm_port->acm_device;
        usb_bulk_req_t  *br;
        int             rval = USB_FAILURE;
        int             data_len;

        USB_DPRINTF_L4(PRINT_MASK_EVENTS, acmp->acm_lh,
            "usbsacm_rx_start: acm_xfer_sz = 0x%lx acm_bulkin_size = 0x%lx",
            acmp->acm_xfer_sz, acm_port->acm_bulkin_size);

        acm_port->acm_bulkin_state = USBSACM_PIPE_BUSY;
        /*
         * Qualcomm CDMA card won't response the first request,
         * if the following code don't multiply by 2.
         */
        data_len = min(acmp->acm_xfer_sz, acm_port->acm_bulkin_size * 2);
        mutex_exit(&acm_port->acm_port_mutex);

        br = usb_alloc_bulk_req(acmp->acm_dip, data_len, USB_FLAGS_SLEEP);
        if (br == NULL) {
                USB_DPRINTF_L2(PRINT_MASK_EVENTS, acmp->acm_lh,
                    "usbsacm_rx_start: allocate bulk request failed");

                mutex_enter(&acm_port->acm_port_mutex);

                return (USB_FAILURE);
        }
        /* initialize bulk in request. */
        br->bulk_len = data_len;
        br->bulk_timeout = USBSACM_BULKIN_TIMEOUT;
        br->bulk_cb = usbsacm_bulkin_cb;
        br->bulk_exc_cb = usbsacm_bulkin_cb;
        br->bulk_client_private = (usb_opaque_t)acm_port;
        br->bulk_attributes = USB_ATTRS_AUTOCLEARING
            | USB_ATTRS_SHORT_XFER_OK;

        rval = usb_pipe_bulk_xfer(acm_port->acm_bulkin_ph, br, 0);

        mutex_enter(&acm_port->acm_port_mutex);
        if (rval != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_EVENTS, acmp->acm_lh,
                    "usbsacm_rx_start: bulk transfer failed %d", rval);
                usb_free_bulk_req(br);
                acm_port->acm_bulkin_state = USBSACM_PIPE_IDLE;
        }

        return (rval);
}


/*
 * usbsacm_tx_start:
 *      start data transmit
 */
static void
usbsacm_tx_start(usbsacm_port_t *acm_port)
{
        int             len;            /* bytes we can transmit */
        mblk_t          *data;          /* data to be transmitted */
        int             data_len;       /* bytes in 'data' */
        mblk_t          *mp;            /* current msgblk */
        int             copylen;        /* bytes copy from 'mp' to 'data' */
        int             rval;
        usbsacm_state_t *acmp = acm_port->acm_device;

        USB_DPRINTF_L4(PRINT_MASK_ALL, acmp->acm_lh,
            "usbsacm_tx_start: ");

        /* check the transmitted data. */
        if (acm_port->acm_tx_mp == NULL) {
                USB_DPRINTF_L2(PRINT_MASK_EVENTS, acmp->acm_lh,
                    "usbsacm_tx_start: acm_tx_mp is NULL");

                return;
        }

        /* check pipe status */
        if (acm_port->acm_bulkout_state != USBSACM_PIPE_IDLE) {

                USB_DPRINTF_L2(PRINT_MASK_EVENTS, acmp->acm_lh,
                    "usbsacm_tx_start: error state in bulkout endpoint");

                return;
        }
        ASSERT(MBLKL(acm_port->acm_tx_mp) > 0);

        /* send as much data as port can receive */
        len = min(msgdsize(acm_port->acm_tx_mp), acmp->acm_xfer_sz);

        if (len == 0) {
                USB_DPRINTF_L2(PRINT_MASK_EVENTS, acmp->acm_lh,
                    "usbsacm_tx_start: data len is 0");

                return;
        }

        /* allocate memory for sending data. */
        if ((data = allocb(len, BPRI_LO)) == NULL) {
                USB_DPRINTF_L2(PRINT_MASK_EVENTS, acmp->acm_lh,
                    "usbsacm_tx_start: failure in allocate memory");

                return;
        }

        /*
         * copy no more than 'len' bytes from mblk chain to transmit mblk 'data'
         */
        data_len = 0;
        while ((data_len < len) && acm_port->acm_tx_mp) {
                /* Get the first mblk from chain. */
                mp = acm_port->acm_tx_mp;
                copylen = min(MBLKL(mp), len - data_len);
                bcopy(mp->b_rptr, data->b_wptr, copylen);
                mp->b_rptr += copylen;
                data->b_wptr += copylen;
                data_len += copylen;

                if (MBLKL(mp) < 1) {
                        acm_port->acm_tx_mp = unlinkb(mp);
                        freeb(mp);
                } else {
                        ASSERT(data_len == len);
                }
        }

        if (data_len <= 0) {
                freeb(data);

                return;
        }

        acm_port->acm_bulkout_state = USBSACM_PIPE_BUSY;

        mutex_exit(&acm_port->acm_port_mutex);
        /* send request. */
        rval = usbsacm_send_data(acm_port, data);
        mutex_enter(&acm_port->acm_port_mutex);

        /*
         * If send failed, retransmit data when acm_tx_mp is null.
         */
        if (rval != USB_SUCCESS) {
                acm_port->acm_bulkout_state = USBSACM_PIPE_IDLE;
                if (acm_port->acm_tx_mp == NULL) {
                        usbsacm_put_head(&acm_port->acm_tx_mp, data);
                }
        }
}


/*
 * usbsacm_send_data:
 *      data transfer
 */
static int
usbsacm_send_data(usbsacm_port_t *acm_port, mblk_t *data)
{
        usbsacm_state_t *acmp = acm_port->acm_device;
        usb_bulk_req_t  *br;
        int             rval;
        int             data_len = MBLKL(data);

        USB_DPRINTF_L4(PRINT_MASK_EVENTS, acmp->acm_lh,
            "usbsacm_send_data: data address is 0x%p, length = %d",
            (void *)data, data_len);

        br = usb_alloc_bulk_req(acmp->acm_dip, 0, USB_FLAGS_SLEEP);
        if (br == NULL) {
                USB_DPRINTF_L2(PRINT_MASK_OPEN, acmp->acm_lh,
                    "usbsacm_send_data: alloc req failed.");

                return (USB_FAILURE);
        }

        /* initialize the bulk out request */
        br->bulk_data = data;
        br->bulk_len = data_len;
        br->bulk_timeout = USBSACM_BULKOUT_TIMEOUT;
        br->bulk_cb = usbsacm_bulkout_cb;
        br->bulk_exc_cb = usbsacm_bulkout_cb;
        br->bulk_client_private = (usb_opaque_t)acm_port;
        br->bulk_attributes = USB_ATTRS_AUTOCLEARING;

        rval = usb_pipe_bulk_xfer(acm_port->acm_bulkout_ph, br, 0);

        if (rval != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_EVENTS, acmp->acm_lh,
                    "usbsacm_send_data: Send Data failed.");

                /*
                 * Don't free it in usb_free_bulk_req because it will
                 * be linked in usbsacm_put_head
                 */
                br->bulk_data = NULL;

                usb_free_bulk_req(br);
        }

        return (rval);
}

/*
 * usbsacm_wait_tx_drain:
 *      wait until local tx buffer drains.
 *      'timeout' is in seconds, zero means wait forever
 */
static int
usbsacm_wait_tx_drain(usbsacm_port_t *acm_port, int timeout)
{
        clock_t         until;
        int             over = 0;

        until = ddi_get_lbolt() + drv_usectohz(1000 * 1000 * timeout);

        while (acm_port->acm_tx_mp && !over) {
                if (timeout > 0) {
                        over = (cv_timedwait_sig(&acm_port->acm_tx_cv,
                            &acm_port->acm_port_mutex, until) <= 0);
                } else {
                        over = (cv_wait_sig(&acm_port->acm_tx_cv,
                            &acm_port->acm_port_mutex) == 0);
                }
        }

        return ((acm_port->acm_tx_mp == NULL) ? USB_SUCCESS : USB_FAILURE);
}


/*
 * usbsacm_req_write:
 *      send command over control pipe
 */
static int
usbsacm_req_write(usbsacm_port_t *acm_port, uchar_t request, uint16_t value,
    mblk_t **data)
{
        usbsacm_state_t *acmp = acm_port->acm_device;
        usb_ctrl_setup_t setup;
        usb_cb_flags_t  cb_flags;
        usb_cr_t        cr;

        USB_DPRINTF_L4(PRINT_MASK_ALL, acmp->acm_lh,
            "usbsacm_req_write: ");

        /* initialize the control request. */
        setup.bmRequestType = USBSACM_REQ_WRITE_IF;
        setup.bRequest = request;
        setup.wValue = value;
        setup.wIndex = acm_port->acm_ctrl_if_no;
        setup.wLength = ((data != NULL) && (*data != NULL)) ? MBLKL(*data) : 0;
        setup.attrs = 0;

        return (usb_pipe_ctrl_xfer_wait(acmp->acm_def_ph, &setup, data,
            &cr, &cb_flags, 0));
}


/*
 * usbsacm_set_line_coding:
 *      Send USB_CDC_REQ_SET_LINE_CODING request
 */
static int
usbsacm_set_line_coding(usbsacm_port_t *acm_port, usb_cdc_line_coding_t *lc)
{
        mblk_t          *bp;
        int             ret;

        /* allocate mblk and copy supplied structure into it */
        if ((bp = allocb(USB_CDC_LINE_CODING_LEN, BPRI_HI)) == NULL) {

                return (USB_NO_RESOURCES);
        }

#ifndef __lock_lint /* warlock gets confused here */
        /* LINTED E_BAD_PTR_CAST_ALIGN */
        *((usb_cdc_line_coding_t *)bp->b_wptr) = *lc;
        bp->b_wptr += USB_CDC_LINE_CODING_LEN;
#endif

        ret = usbsacm_req_write(acm_port, USB_CDC_REQ_SET_LINE_CODING, 0, &bp);

        if (bp != NULL) {
                freeb(bp);
        }

        return (ret);
}



/*
 * usbsacm_mctl2reg:
 *      Set Modem control status
 */
static void
usbsacm_mctl2reg(int mask, int val, uint8_t *line_ctl)
{
        if (mask & TIOCM_RTS) {
                if (val & TIOCM_RTS) {
                        *line_ctl |= USB_CDC_ACM_CONTROL_RTS;
                } else {
                        *line_ctl &= ~USB_CDC_ACM_CONTROL_RTS;
                }
        }
        if (mask & TIOCM_DTR) {
                if (val & TIOCM_DTR) {
                        *line_ctl |= USB_CDC_ACM_CONTROL_DTR;
                } else {
                        *line_ctl &= ~USB_CDC_ACM_CONTROL_DTR;
                }
        }
}


/*
 * usbsacm_reg2mctl:
 *      Get Modem control status
 */
static int
usbsacm_reg2mctl(uint8_t line_ctl)
{
        int     val = 0;

        if (line_ctl & USB_CDC_ACM_CONTROL_RTS) {
                val |= TIOCM_RTS;
        }
        if (line_ctl & USB_CDC_ACM_CONTROL_DTR) {
                val |= TIOCM_DTR;
        }
        if (line_ctl & USB_CDC_ACM_CONTROL_DSR) {
                val |= TIOCM_DSR;
        }
        if (line_ctl & USB_CDC_ACM_CONTROL_RNG) {
                val |= TIOCM_RI;
        }

        return (val);
}


/*
 * misc routines
 * -------------
 *
 */

/*
 * usbsacm_put_tail:
 *      link a message block to tail of message
 *      account for the case when message is null
 */
static void
usbsacm_put_tail(mblk_t **mpp, mblk_t *bp)
{
        if (*mpp) {
                linkb(*mpp, bp);
        } else {
                *mpp = bp;
        }
}


/*
 * usbsacm_put_head:
 *      put a message block at the head of the message
 *      account for the case when message is null
 */
static void
usbsacm_put_head(mblk_t **mpp, mblk_t *bp)
{
        if (*mpp) {
                linkb(bp, *mpp);
        }
        *mpp = bp;
}


/*
 * power management
 * ----------------
 *
 * usbsacm_create_pm_components:
 *      create PM components
 */
static int
usbsacm_create_pm_components(usbsacm_state_t *acmp)
{
        dev_info_t      *dip = acmp->acm_dip;
        usbsacm_pm_t    *pm;
        uint_t          pwr_states;
        usb_dev_descr_t *dev_descr;

        USB_DPRINTF_L4(PRINT_MASK_PM, acmp->acm_lh,
            "usbsacm_create_pm_components: ");

        if (usb_create_pm_components(dip, &pwr_states) != USB_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_PM, acmp->acm_lh,
                    "usbsacm_create_pm_components: failed");

                return (USB_SUCCESS);
        }

        pm = acmp->acm_pm =
            (usbsacm_pm_t *)kmem_zalloc(sizeof (usbsacm_pm_t), KM_SLEEP);

        pm->pm_pwr_states = (uint8_t)pwr_states;
        pm->pm_cur_power = USB_DEV_OS_FULL_PWR;
        /*
         * Qualcomm CDMA card won't response the following control commands
         * after receive USB_REMOTE_WAKEUP_ENABLE. So we just set
         * pm_wakeup_enable to 0 for this specific device.
         */
        dev_descr = acmp->acm_dev_data->dev_descr;
        if (dev_descr->idVendor == 0x5c6 && dev_descr->idProduct == 0x3100) {
                pm->pm_wakeup_enabled = 0;
        } else {
                pm->pm_wakeup_enabled = (usb_handle_remote_wakeup(dip,
                    USB_REMOTE_WAKEUP_ENABLE) == USB_SUCCESS);
        }

        (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);

        return (USB_SUCCESS);
}


/*
 * usbsacm_destroy_pm_components:
 *      destroy PM components
 */
static void
usbsacm_destroy_pm_components(usbsacm_state_t *acmp)
{
        usbsacm_pm_t    *pm = acmp->acm_pm;
        dev_info_t      *dip = acmp->acm_dip;
        int             rval;

        USB_DPRINTF_L4(PRINT_MASK_CLOSE, acmp->acm_lh,
            "usbsacm_destroy_pm_components: ");

        if (acmp->acm_dev_state != USB_DEV_DISCONNECTED) {
                if (pm->pm_wakeup_enabled) {
                        rval = pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);
                        if (rval != DDI_SUCCESS) {
                                USB_DPRINTF_L2(PRINT_MASK_PM, acmp->acm_lh,
                                    "usbsacm_destroy_pm_components: "
                                    "raising power failed (%d)", rval);
                        }

                        rval = usb_handle_remote_wakeup(dip,
                            USB_REMOTE_WAKEUP_DISABLE);
                        if (rval != USB_SUCCESS) {
                                USB_DPRINTF_L2(PRINT_MASK_PM, acmp->acm_lh,
                                    "usbsacm_destroy_pm_components: "
                                    "disable remote wakeup failed (%d)", rval);
                        }
                }

                (void) pm_lower_power(dip, 0, USB_DEV_OS_PWR_OFF);
        }
        kmem_free((caddr_t)pm, sizeof (usbsacm_pm_t));
        acmp->acm_pm = NULL;
}


/*
 * usbsacm_pm_set_busy:
 *      mark device busy and raise power
 */
static void
usbsacm_pm_set_busy(usbsacm_state_t *acmp)
{
        usbsacm_pm_t    *pm = acmp->acm_pm;
        dev_info_t      *dip = acmp->acm_dip;
        int             rval;

        USB_DPRINTF_L4(PRINT_MASK_PM, acmp->acm_lh,
            "usbsacm_pm_set_busy: pm = 0x%p", (void *)pm);

        if (pm == NULL) {

                return;
        }

        mutex_enter(&acmp->acm_mutex);
        /* if already marked busy, just increment the counter */
        if (pm->pm_busy_cnt++ > 0) {
                mutex_exit(&acmp->acm_mutex);

                return;
        }

        (void) pm_busy_component(dip, 0);

        if (pm->pm_cur_power == USB_DEV_OS_FULL_PWR) {
                mutex_exit(&acmp->acm_mutex);

                return;
        }

        /* need to raise power  */
        pm->pm_raise_power = B_TRUE;
        mutex_exit(&acmp->acm_mutex);

        rval = pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR);
        if (rval != DDI_SUCCESS) {
                USB_DPRINTF_L2(PRINT_MASK_PM, acmp->acm_lh,
                    "usbsacm_pm_set_busy: raising power failed");
        }

        mutex_enter(&acmp->acm_mutex);
        pm->pm_raise_power = B_FALSE;
        mutex_exit(&acmp->acm_mutex);
}


/*
 * usbsacm_pm_set_idle:
 *      mark device idle
 */
static void
usbsacm_pm_set_idle(usbsacm_state_t *acmp)
{
        usbsacm_pm_t    *pm = acmp->acm_pm;
        dev_info_t      *dip = acmp->acm_dip;

        USB_DPRINTF_L4(PRINT_MASK_PM, acmp->acm_lh,
            "usbsacm_pm_set_idle: ");

        if (pm == NULL) {

                return;
        }

        /*
         * if more ports use the device, do not mark as yet
         */
        mutex_enter(&acmp->acm_mutex);
        if (--pm->pm_busy_cnt > 0) {
                mutex_exit(&acmp->acm_mutex);

                return;
        }

        if (pm) {
                (void) pm_idle_component(dip, 0);
        }
        mutex_exit(&acmp->acm_mutex);
}


/*
 * usbsacm_pwrlvl0:
 *      Functions to handle power transition for OS levels 0 -> 3
 *      The same level as OS state, different from USB state
 */
static int
usbsacm_pwrlvl0(usbsacm_state_t *acmp)
{
        int             rval;
        int             i;
        usbsacm_port_t  *cur_port = acmp->acm_ports;

        USB_DPRINTF_L4(PRINT_MASK_PM, acmp->acm_lh,
            "usbsacm_pwrlvl0: ");

        switch (acmp->acm_dev_state) {
        case USB_DEV_ONLINE:
                /* issue USB D3 command to the device */
                rval = usb_set_device_pwrlvl3(acmp->acm_dip);
                ASSERT(rval == USB_SUCCESS);

                if (cur_port != NULL) {
                        for (i = 0; i < acmp->acm_port_cnt; i++) {
                                cur_port = &acmp->acm_ports[i];
                                if (cur_port->acm_intr_ph != NULL &&
                                    cur_port->acm_port_state !=
                                    USBSACM_PORT_CLOSED) {

                                        mutex_exit(&acmp->acm_mutex);
                                        usb_pipe_stop_intr_polling(
                                            cur_port->acm_intr_ph,
                                            USB_FLAGS_SLEEP);
                                        mutex_enter(&acmp->acm_mutex);

                                        mutex_enter(&cur_port->acm_port_mutex);
                                        cur_port->acm_intr_state =
                                            USBSACM_PIPE_IDLE;
                                        mutex_exit(&cur_port->acm_port_mutex);
                                }
                        }
                }

                acmp->acm_dev_state = USB_DEV_PWRED_DOWN;
                acmp->acm_pm->pm_cur_power = USB_DEV_OS_PWR_OFF;

                /* FALLTHRU */
        case USB_DEV_DISCONNECTED:
        case USB_DEV_SUSPENDED:
                /* allow a disconnect/cpr'ed device to go to lower power */

                return (USB_SUCCESS);
        case USB_DEV_PWRED_DOWN:
        default:
                USB_DPRINTF_L2(PRINT_MASK_PM, acmp->acm_lh,
                    "usbsacm_pwrlvl0: illegal device state");

                return (USB_FAILURE);
        }
}


/*
 * usbsacm_pwrlvl1:
 *      Functions to handle power transition for OS levels 1 -> 2
 */
static int
usbsacm_pwrlvl1(usbsacm_state_t *acmp)
{
        /* issue USB D2 command to the device */
        (void) usb_set_device_pwrlvl2(acmp->acm_dip);

        return (USB_FAILURE);
}


/*
 * usbsacm_pwrlvl2:
 *      Functions to handle power transition for OS levels 2 -> 1
 */
static int
usbsacm_pwrlvl2(usbsacm_state_t *acmp)
{
        /* issue USB D1 command to the device */
        (void) usb_set_device_pwrlvl1(acmp->acm_dip);

        return (USB_FAILURE);
}


/*
 * usbsacm_pwrlvl3:
 *      Functions to handle power transition for OS levels 3 -> 0
 *      The same level as OS state, different from USB state
 */
static int
usbsacm_pwrlvl3(usbsacm_state_t *acmp)
{
        int             rval;
        int             i;
        usbsacm_port_t  *cur_port = acmp->acm_ports;

        USB_DPRINTF_L4(PRINT_MASK_PM, acmp->acm_lh,
            "usbsacm_pwrlvl3: ");

        switch (acmp->acm_dev_state) {
        case USB_DEV_PWRED_DOWN:
                /* Issue USB D0 command to the device here */
                rval = usb_set_device_pwrlvl0(acmp->acm_dip);
                ASSERT(rval == USB_SUCCESS);

                if (cur_port != NULL) {
                        for (i = 0; i < acmp->acm_port_cnt; i++) {
                                cur_port = &acmp->acm_ports[i];
                                if (cur_port->acm_intr_ph != NULL &&
                                    cur_port->acm_port_state !=
                                    USBSACM_PORT_CLOSED) {

                                        mutex_exit(&acmp->acm_mutex);
                                        usbsacm_pipe_start_polling(cur_port);
                                        mutex_enter(&acmp->acm_mutex);
                                }
                        }
                }

                acmp->acm_dev_state = USB_DEV_ONLINE;
                acmp->acm_pm->pm_cur_power = USB_DEV_OS_FULL_PWR;

                /* FALLTHRU */
        case USB_DEV_ONLINE:
                /* we are already in full power */

                /* FALLTHRU */
        case USB_DEV_DISCONNECTED:
        case USB_DEV_SUSPENDED:

                return (USB_SUCCESS);
        default:
                USB_DPRINTF_L2(PRINT_MASK_PM, acmp->acm_lh,
                    "usbsacm_pwrlvl3: illegal device state");

                return (USB_FAILURE);
        }
}


/*
 * usbsacm_pipe_start_polling:
 *      start polling on the interrupt pipe
 */
static void
usbsacm_pipe_start_polling(usbsacm_port_t *acm_port)
{
        usb_intr_req_t  *intr;
        int             rval;
        usbsacm_state_t *acmp = acm_port->acm_device;

        USB_DPRINTF_L4(PRINT_MASK_ATTA, acmp->acm_lh,
            "usbsacm_pipe_start_polling: ");

        if (acm_port->acm_intr_ph == NULL) {

                return;
        }

        intr = usb_alloc_intr_req(acmp->acm_dip, 0, USB_FLAGS_SLEEP);

        /*
         * If it is in interrupt context, usb_alloc_intr_req will return NULL if
         * called with SLEEP flag.
         */
        if (!intr) {
                USB_DPRINTF_L2(PRINT_MASK_OPEN, acmp->acm_lh,
                    "usbsacm_pipe_start_polling: alloc req failed.");

                return;
        }

        /* initialize the interrupt request. */
        intr->intr_attributes = USB_ATTRS_SHORT_XFER_OK |
            USB_ATTRS_AUTOCLEARING;
        mutex_enter(&acm_port->acm_port_mutex);
        intr->intr_len = acm_port->acm_intr_ep_descr.wMaxPacketSize;
        mutex_exit(&acm_port->acm_port_mutex);
        intr->intr_client_private = (usb_opaque_t)acm_port;
        intr->intr_cb = usbsacm_intr_cb;
        intr->intr_exc_cb = usbsacm_intr_ex_cb;

        rval = usb_pipe_intr_xfer(acm_port->acm_intr_ph, intr, USB_FLAGS_SLEEP);

        mutex_enter(&acm_port->acm_port_mutex);
        if (rval == USB_SUCCESS) {
                acm_port->acm_intr_state = USBSACM_PIPE_BUSY;
        } else {
                usb_free_intr_req(intr);
                acm_port->acm_intr_state = USBSACM_PIPE_IDLE;
                USB_DPRINTF_L3(PRINT_MASK_OPEN, acmp->acm_lh,
                    "usbsacm_pipe_start_polling: failed (%d)", rval);
        }
        mutex_exit(&acm_port->acm_port_mutex);
}


/*
 * usbsacm_intr_cb:
 *      interrupt pipe normal callback
 */
/*ARGSUSED*/
static void
usbsacm_intr_cb(usb_pipe_handle_t ph, usb_intr_req_t *req)
{
        usbsacm_port_t  *acm_port = (usbsacm_port_t *)req->intr_client_private;
        usbsacm_state_t *acmp = acm_port->acm_device;
        mblk_t          *data = req->intr_data;
        int             data_len;

        USB_DPRINTF_L4(PRINT_MASK_CB, acmp->acm_lh,
            "usbsacm_intr_cb: ");

        data_len = (data) ? MBLKL(data) : 0;

        /* check data length */
        if (data_len < 8) {
                USB_DPRINTF_L2(PRINT_MASK_CB, acmp->acm_lh,
                    "usbsacm_intr_cb: %d packet too short", data_len);
                usb_free_intr_req(req);

                return;
        }
        req->intr_data = NULL;
        usb_free_intr_req(req);

        mutex_enter(&acm_port->acm_port_mutex);
        /* parse interrupt data. */
        usbsacm_parse_intr_data(acm_port, data);
        mutex_exit(&acm_port->acm_port_mutex);
}


/*
 * usbsacm_intr_ex_cb:
 *      interrupt pipe exception callback
 */
/*ARGSUSED*/
static void
usbsacm_intr_ex_cb(usb_pipe_handle_t ph, usb_intr_req_t *req)
{
        usbsacm_port_t  *acm_port = (usbsacm_port_t *)req->intr_client_private;
        usbsacm_state_t *acmp = acm_port->acm_device;
        usb_cr_t        cr = req->intr_completion_reason;

        USB_DPRINTF_L4(PRINT_MASK_CB, acmp->acm_lh,
            "usbsacm_intr_ex_cb: ");

        usb_free_intr_req(req);

        /*
         * If completion reason isn't USB_CR_PIPE_CLOSING and
         * USB_CR_STOPPED_POLLING, restart polling.
         */
        if ((cr != USB_CR_PIPE_CLOSING) && (cr != USB_CR_STOPPED_POLLING)) {
                mutex_enter(&acmp->acm_mutex);

                if (acmp->acm_dev_state != USB_DEV_ONLINE) {

                        USB_DPRINTF_L3(PRINT_MASK_CB, acmp->acm_lh,
                            "usbsacm_intr_ex_cb: state = %d",
                            acmp->acm_dev_state);

                        mutex_exit(&acmp->acm_mutex);

                        return;
                }
                mutex_exit(&acmp->acm_mutex);

                usbsacm_pipe_start_polling(acm_port);
        }
}


/*
 * usbsacm_parse_intr_data:
 *      Parse data received from interrupt callback
 */
static void
usbsacm_parse_intr_data(usbsacm_port_t *acm_port, mblk_t *data)
{
        usbsacm_state_t *acmp = acm_port->acm_device;
        uint8_t         bmRequestType;
        uint8_t         bNotification;
        uint16_t        wValue;
        uint16_t        wLength;
        uint16_t        wData;

        USB_DPRINTF_L4(PRINT_MASK_ALL, acmp->acm_lh,
            "usbsacm_parse_intr_data: ");

        bmRequestType = data->b_rptr[0];
        bNotification = data->b_rptr[1];
        /*
         * If Notification type is NETWORK_CONNECTION, wValue is 0 or 1,
         * mLength is 0. If Notification type is SERIAL_TYPE, mValue is 0,
         * mLength is 2. So we directly get the value from the byte.
         */
        wValue = data->b_rptr[2];
        wLength = data->b_rptr[6];

        if (bmRequestType != USB_CDC_NOTIFICATION_REQUEST_TYPE) {
                USB_DPRINTF_L2(PRINT_MASK_CB, acmp->acm_lh,
                    "usbsacm_parse_intr_data: unknown request type - 0x%x",
                    bmRequestType);

                freemsg(data);

                return;
        }

        /*
         * Check the return value of device
         */
        switch (bNotification) {
        case USB_CDC_NOTIFICATION_NETWORK_CONNECTION:
                USB_DPRINTF_L3(PRINT_MASK_CB, acmp->acm_lh,
                    "usbsacm_parse_intr_data: %s network!",
                    wValue ? "connected to" :"disconnected from");

                break;
        case USB_CDC_NOTIFICATION_RESPONSE_AVAILABLE:
                USB_DPRINTF_L3(PRINT_MASK_CB, acmp->acm_lh,
                    "usbsacm_parse_intr_data: A response is a available.");

                break;
        case USB_CDC_NOTIFICATION_SERIAL_STATE:
                /* check the parameter's length. */
                if (wLength != 2) {

                        USB_DPRINTF_L3(PRINT_MASK_CB, acmp->acm_lh,
                            "usbsacm_parse_intr_data: error data length.");
                } else {
                        /*
                         * The Data field is a bitmapped value that contains
                         * the current state of carrier detect, transmission
                         * carrier, break, ring signal and device overrun
                         * error.
                         */
                        wData = data->b_rptr[8];
                        /*
                         * Check the serial state of the current port.
                         */
                        if (wData & USB_CDC_ACM_CONTROL_DCD) {

                                USB_DPRINTF_L3(PRINT_MASK_CB, acmp->acm_lh,
                                    "usbsacm_parse_intr_data: "
                                    "receiver carrier is set.");
                        }
                        if (wData & USB_CDC_ACM_CONTROL_DSR) {

                                USB_DPRINTF_L3(PRINT_MASK_CB, acmp->acm_lh,
                                    "usbsacm_parse_intr_data: "
                                    "transmission carrier is set.");

                                acm_port->acm_mctlin |= USB_CDC_ACM_CONTROL_DSR;
                        }
                        if (wData & USB_CDC_ACM_CONTROL_BREAK) {

                                USB_DPRINTF_L3(PRINT_MASK_CB, acmp->acm_lh,
                                    "usbsacm_parse_intr_data: "
                                    "break detection mechanism is set.");
                        }
                        if (wData & USB_CDC_ACM_CONTROL_RNG) {

                                USB_DPRINTF_L3(PRINT_MASK_CB, acmp->acm_lh,
                                    "usbsacm_parse_intr_data: "
                                    "ring signal detection is set.");

                                acm_port->acm_mctlin |= USB_CDC_ACM_CONTROL_RNG;
                        }
                        if (wData & USB_CDC_ACM_CONTROL_FRAMING) {

                                USB_DPRINTF_L3(PRINT_MASK_CB, acmp->acm_lh,
                                    "usbsacm_parse_intr_data: "
                                    "A framing error has occurred.");
                        }
                        if (wData & USB_CDC_ACM_CONTROL_PARITY) {

                                USB_DPRINTF_L3(PRINT_MASK_CB, acmp->acm_lh,
                                    "usbsacm_parse_intr_data: "
                                    "A parity error has occurred.");
                        }
                        if (wData & USB_CDC_ACM_CONTROL_OVERRUN) {

                                USB_DPRINTF_L3(PRINT_MASK_CB, acmp->acm_lh,
                                    "usbsacm_parse_intr_data: "
                                    "Received data has been discarded "
                                    "due to overrun.");
                        }
                }

                break;
        default:
                USB_DPRINTF_L3(PRINT_MASK_CB, acmp->acm_lh,
                    "usbsacm_parse_intr_data: unknown notification - 0x%x!",
                    bNotification);

                break;
        }

        freemsg(data);
}