/**
 * @file usb_ctrl_transfer.c
 * @brief usb 控制传输接口
 * @author chenrixin@zh-jieli.com
 * @version 1.00
 * @date 2017-02-09
 */

#include "usb/host/usb_host.h"
#include "usb_ctrl_transfer.h"
#include "app_config.h"
#include "device_drive.h"
#include "gpio.h"
#include "usb/scsi.h"

#define LOG_TAG_CONST       USB
#define LOG_TAG             "[USB]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE
#include "debug.h"

#if USB_HOST_ENABLE

_WEAK_
void usb_dis_ep0_txdly(const usb_dev id)
{
}
static void ep0_h_isr(struct usb_host_device *host_dev, u32 ep)
{
    usb_dev usb_id = host_device2id(host_dev);
    usb_sem_post(host_dev);
}
/**
 * @brief usb_ctlXfer
 *
 * @param host_dev
 * @param urb
 *
 * @return
 */
static int usb_ctlXfer(struct usb_host_device *host_dev, struct ctlXfer *urb)
{
    u32 ret = DEV_ERR_NONE;
    u8 reg = 0;
    u32 data_len;
    usb_dev usb_id = host_device2id(host_dev);
    u8 devnum = host_dev->private_data.devnum;
    u32 max_packet_size = host_dev->private_data.ep0_max_packet_size;

    usb_write_faddr(usb_id, devnum);

    switch (urb->stage) {
    case USB_PID_SETUP :
        usb_write_ep0(usb_id, (u8 *)&urb->setup, 8);
        reg = CSR0H_SetupPkt | CSR0H_TxPktRdy;
        break;
    case USB_PID_IN :
        if (urb->setup.wLength) {
            reg = CSR0H_ReqPkt;
        } else {
            reg = CSR0H_StatusPkt | CSR0H_ReqPkt;
        }
        break;
    case USB_PID_OUT:
        if (urb->setup.wLength) {
            data_len = min(urb->setup.wLength, max_packet_size);
            reg = CSR0H_TxPktRdy;
            usb_write_ep0(usb_id, urb->buffer, data_len);
            urb->setup.wLength -= data_len;
            urb->buffer += data_len;
        } else {
            reg = CSR0H_StatusPkt | CSR0H_TxPktRdy;
        }
        break;
    default :
        break;
    }

#if USB_HOST_ASYNC
    //config ep0 callback fun
    usb_h_set_ep_isr(host_dev, 0, ep0_h_isr, host_dev);
    usb_set_intr_txe(usb_id, 0);
#endif

    usb_write_csr0(usb_id, reg);

    u32 st = 0;
    u32 ot = get_jiffies() + 500;
    while (1) {
        if (usb_host_timeout(ot)) {
            log_error("time out %x\n", reg);
            ret = -DEV_ERR_TIMEOUT;
            goto __exit;
        }
        if (usb_h_dev_status(usb_id)) {
            st ++;
        } else {
            st = 0;
        }
        if (((usb_read_devctl(usb_id) & BIT(2)) == 0) || (st > 1000)) {
            log_error("usb%d_offline\n", usb_id);
            ret = -DEV_ERR_OFFLINE;
            goto __exit;
        }

#if USB_HOST_ASYNC
        ret = usb_sem_pend(host_dev, 250); //wait isr
        if (ret) {
            log_error("usb%d_offline\n", usb_id);
            ret = -DEV_ERR_OFFLINE;
            goto __exit;
        }
#endif

        reg = usb_read_csr0(usb_id);
        if (reg & CSR0H_RxStall) {
            log_error(" rxStall CSR0:0x%x", reg);
            ret = -DEV_ERR_CONTROL_STALL;
            goto __exit;
        }
        if (reg & CSR0H_Error) {
            log_error(" Error CSR0:0x%x", reg);
            usb_write_csr0(usb_id, 0);
            ret = -DEV_ERR_CONTROL;
            goto __exit;
        }
        if (USB_PID_IN == urb->stage) {

            if (reg & CSR0H_RxPktRdy) {
                data_len = usb_read_count0(usb_id);
                data_len = min(data_len, urb->setup.wLength);
                usb_read_ep0(usb_id, urb->buffer, data_len);;
                urb->buffer += data_len;
                urb->setup.wLength -= data_len;
                if (data_len < max_packet_size) {
                    urb->setup.wLength = 0;
                }
                if (urb->setup.wLength) {
                    usb_write_csr0(usb_id, CSR0H_ReqPkt);
                } else {
                    usb_write_csr0(usb_id, 0);
                    break;
                }
            }
        } else {
            if (!(reg & CSR0H_TxPktRdy)) {
                break;
            }
        }
    }
__exit:
    usb_clr_intr_txe(usb_id, 0);
    usb_dis_ep0_txdly(usb_id);
    return ret;
}
/**
 * @brief usb_control_transfers
 *
 * @param struct host_dev
 * @param urb
 *
 * @return
 */
static int usb_control_transfers(struct usb_host_device *host_dev, struct ctlXfer *urb)
{
    usb_dev usb_id = host_device2id(host_dev);

    int res;
    /*SETUP*/

    urb->stage = USB_PID_SETUP;		//SETUP transaction

    res = usb_ctlXfer(host_dev, urb);

    if (res) {
        return res;
    }

    /*IN or OUT*/
    urb->stage = USB_PID_IN;


    while (urb->setup.wLength) {
        if (urb->setup.bRequestType & USB_DIR_IN) {	//Request Direction
            urb->stage = USB_PID_IN;	//IN transaction

            res = usb_ctlXfer(host_dev, urb);

            if (res) {
                return res;
            }

            urb->stage = USB_PID_OUT;
        } else {
            urb->stage = USB_PID_OUT;	//OUT transaction

            res = usb_ctlXfer(host_dev, urb);

            if (res) {
                return res;
            }

            urb->stage = USB_PID_IN;
        }
    }

    res = usb_ctlXfer(host_dev, urb);

    if (res) {
        return res;
    }

    return DEV_ERR_NONE;
}

/**
 * @brief usb_control_msg
 *
 * @param host_dev
 * @param request
 * @param requesttype
 * @param value
 * @param index
 * @param data
 * @param size
 *
 * @return
 */
static int usb_control_msg(struct usb_host_device *host_dev,
                           u8 request, u8 requesttype,
                           u16 value, u16 index,
                           void *data, u16 size)
{
    struct ctlXfer urb;
    urb.setup.bRequestType = requesttype;
    urb.setup.bRequest = request;
    urb.setup.wValue = cpu_to_le16(value);
    urb.setup.wIndex = cpu_to_le16(index);
    urb.setup.wLength = cpu_to_le16(size);
    urb.buffer = data;

    return usb_control_transfers(host_dev, &urb);

}

/**
 * @brief usb_clear_feature
 *
 * @param host_dev
 * @param ep
 *
 * @return
 */
int usb_clear_feature(struct usb_host_device *host_dev, u32 ep)
{
    return usb_control_msg(host_dev,  USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0, ep, NULL, 0);
}

int set_address(struct usb_host_device *host_dev, u8 devnum)
{
    return usb_control_msg(host_dev, USB_REQ_SET_ADDRESS, 0,  devnum, 0, NULL, 0);
}

int usb_get_device_descriptor(struct usb_host_device *host_dev, struct usb_device_descriptor *desc)
{
    return usb_control_msg(host_dev,
                           USB_REQ_GET_DESCRIPTOR,
                           USB_DIR_IN,
                           (USB_DT_DEVICE << 8),
                           0,
                           desc,
                           USB_DT_DEVICE_SIZE
                          );
}

int usb_get_string_descriptor(struct usb_host_device *host_dev, struct usb_device_descriptor *desc)
{
    int ret = DEV_ERR_NONE;
#if 0
    struct usb_private_data *private_data = host_dev->private_data ;
    /**********get string language*********/
    u8 buf[16];
    memset(buf, 0x0, sizeof(buf));
    ret = usb_control_msg(host_dev,
                          USB_REQ_GET_DESCRIPTOR,
                          USB_DIR_IN,
                          (USB_DT_STRING << 8),
                          0,
                          desc,
                          sizeof(buf)
                         );
    if (ret) {
        return ret;
    }
    memcpy(&private_data->language, buf + 2, sizeof(private_data->language));

    /**********get manufacturer string**********/
    memset(private_data->manufacturer, 0x0, sizeof(private_data->manufacturer));
    if (desc->iManufacturer) {
        ret = usb_control_msg(host_dev,
                              USB_REQ_GET_DESCRIPTOR,
                              USB_DIR_IN,
                              (USB_DT_STRING << 8) | desc->iManufacturer,
                              0,
                              private_data->manufacturer,
                              sizeof(private_data->manufacturer)
                             );
        if (ret) {
            return ret;
        }
    }
    /**********get product string**********/
    memset(private_data->product, 0x0, sizeof(private_data->product));
    if (desc->iProduct) {
        ret = usb_control_msg(host_dev,
                              USB_REQ_GET_DESCRIPTOR,
                              USB_DIR_IN,
                              (USB_DT_STRING << 8) | desc->iProduct,
                              0,
                              private_data->product,
                              sizeof(private_data->product)
                             );
        if (ret) {
            return ret;
        }
    }
#endif
    return ret;
}

int set_configuration(struct usb_host_device *host_dev)
{
    return  usb_control_msg(host_dev, USB_REQ_SET_CONFIGURATION, 0, 1, 0, NULL, 0);
}
int set_configuration_add_value(struct usb_host_device *host_dev, u16 value)
{
    return  usb_control_msg(host_dev, USB_REQ_SET_CONFIGURATION, 0, value, 0, NULL, 0);
}
int get_config_descriptor(struct usb_host_device *host_dev, void *cfg_desc, u32 len)
{
    return usb_control_msg(host_dev,
                           USB_REQ_GET_DESCRIPTOR,
                           USB_DIR_IN,
                           (USB_DT_CONFIG << 8),
                           0,
                           cfg_desc,
                           len);
}

int get_config_descriptor_add_value_l(struct usb_host_device *host_dev, void *cfg_desc, u32 len, u8 value_l)
{
    return usb_control_msg(host_dev,
                           USB_REQ_GET_DESCRIPTOR,
                           USB_DIR_IN,
                           (USB_DT_CONFIG << 8) | value_l,
                           0,
                           cfg_desc,
                           len);
}


int get_msd_max_lun(struct usb_host_device *host_dev, void *lun)
{
    return usb_control_msg(host_dev,
                           USB_MSD_MAX_LUN,
                           USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                           0,
                           0,
                           lun,
                           1);
}
int set_msd_reset(struct usb_host_device *host_dev)
{
    return usb_control_msg(host_dev,
                           0xff,
                           USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                           0,
                           0,
                           NULL,
                           0);
}

int hid_set_idle(struct usb_host_device *host_dev, u32 id)
{
    return usb_control_msg(host_dev, 0x0a, 0x21, 0, id << 8, NULL, 0);
}
int hid_get_report(struct usb_host_device *host_dev, u8 *report, u8 report_id, u16 report_len)
{
    return usb_control_msg(host_dev,
                           USB_REQ_GET_DESCRIPTOR,
                           USB_DIR_IN | USB_RECIP_INTERFACE,
                           0x2200,
                           report_id,
                           report,
                           report_len);
}
int hid_set_output_report(struct usb_host_device *host_dev, u8 *report, u8 report_id, u8 report_len)
{
    return usb_control_msg(host_dev,
                           0x09,
                           USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                           0x0201,
                           report_id,
                           report,
                           report_len);
}
int usb_set_remote_wakeup(struct usb_host_device *host_dev)
{
    return usb_control_msg(host_dev, USB_REQ_SET_FEATURE, USB_RECIP_DEVICE,
                           USB_DEVICE_REMOTE_WAKEUP, 0, NULL, 0);
}
int get_device_status(struct usb_host_device *host_dev)
{
    u16 status;
    return usb_control_msg(host_dev, USB_REQ_GET_STATUS, USB_DIR_IN, 0, 0, (u8 *)&status, 2);
}
int usb_get_device_qualifier(struct usb_host_device *host_dev, u8 *buffer)
{
    return usb_control_msg(host_dev,
                           USB_REQ_GET_DESCRIPTOR,
                           USB_DIR_IN,
                           (USB_DT_DEVICE_QUALIFIER << 8),
                           0,
                           buffer,
                           0x0a);

}
#define     AOA_CMD51   0x33
#define     AOA_CMD52   0x34
#define     AOA_CMD53   0x35




int usb_get_aoa_version(struct usb_host_device *host_dev, u16 *version)
{
    return usb_control_msg(host_dev,
                           AOA_CMD51,
                           USB_DIR_IN | USB_TYPE_VENDOR,
                           0,
                           0,
                           version,
                           2);
}
int usb_set_credentials(struct usb_host_device *host_dev, const char *string, int index)
{
    return usb_control_msg(host_dev,
                           AOA_CMD52,
                           USB_DIR_OUT | USB_TYPE_VENDOR,
                           0,
                           index,
                           (u8 *)string,
                           strlen(string));
}
int usb_switch2aoa(struct usb_host_device *host_dev)
{
    return usb_control_msg(host_dev,
                           AOA_CMD53,
                           USB_DIR_OUT | USB_TYPE_VENDOR,
                           0,
                           0,
                           NULL,
                           0);
}
int usb_switch2slave(struct usb_host_device *host_dev)
{
    return usb_control_msg(host_dev,
                           0x51,
                           USB_DIR_OUT | USB_TYPE_VENDOR,
                           0,
                           0,
                           NULL,
                           0);
}
/* Control request for registering a HID device.
 * Upon registering, a unique ID is sent by the accessory in the
 * value parameter. This ID will be used for future commands for
 * the device
 *
 *  requestType:    USB_DIR_OUT | USB_TYPE_VENDOR
 *  request:        ACCESSORY_REGISTER_HID_DEVICE
 *  value:          Accessory assigned ID for the HID device
 *  index:          total length of the HID report descriptor
 *  data            none
 */
#define ACCESSORY_REGISTER_HID         54
int usb_aoa_register_hid(struct usb_host_device *host_dev, u16 value, u16 index)
{
    return usb_control_msg(host_dev,
                           ACCESSORY_REGISTER_HID,
                           USB_DIR_OUT | USB_TYPE_VENDOR,
                           value,
                           index,
                           NULL,
                           0);
}
/* Control request for unregistering a HID device.
 *
 *  requestType:    USB_DIR_OUT | USB_TYPE_VENDOR
 *  request:        ACCESSORY_REGISTER_HID
 *  value:          Accessory assigned ID for the HID device
 *  index:          0
 *  data            none
 */
#define ACCESSORY_UNREGISTER_HID         55
int usb_aoa_unregister_hid(struct usb_host_device *host_dev, u16 value)
{
    return usb_control_msg(host_dev,
                           ACCESSORY_UNREGISTER_HID,
                           USB_DIR_OUT | USB_TYPE_VENDOR,
                           value,
                           0,
                           NULL,
                           0);
}

/* Control request for sending the HID report descriptor.
 * If the HID descriptor is longer than the endpoint zero max packet size,
 * the descriptor will be sent in multiple ACCESSORY_SET_HID_REPORT_DESC
 * commands. The data for the descriptor must be sent sequentially
 * if multiple packets are needed.
 *
 *  requestType:    USB_DIR_OUT | USB_TYPE_VENDOR
 *  request:        ACCESSORY_SET_HID_REPORT_DESC
 *  value:          Accessory assigned ID for the HID device
 *  index:          offset of data in descriptor
 *                      (needed when HID descriptor is too big for one packet)
 *  data            the HID report descriptor
 */
#define ACCESSORY_SET_HID_REPORT_DESC         56
int usb_aoa_set_hid_report_desc(struct usb_host_device *host_dev, u16 value, u16 offset, const char *pbuf, u32 len)
{
    return usb_control_msg(host_dev,
                           ACCESSORY_SET_HID_REPORT_DESC,
                           USB_DIR_OUT | USB_TYPE_VENDOR,
                           value,
                           offset,
                           (u8 *)pbuf,
                           len);
}

/* Control request for sending HID events.
 *
 *  requestType:    USB_DIR_OUT | USB_TYPE_VENDOR
 *  request:        ACCESSORY_SEND_HID_EVENT
 *  value:          Accessory assigned ID for the HID device
 *  index:          0
 *  data            the HID report for the event
 */
#define ACCESSORY_SEND_HID_EVENT         57
int usb_aoa_send_hid_event(struct usb_host_device *host_dev, u16 value, const u8 *pbuf, u32 len)
{
    return usb_control_msg(host_dev,
                           ACCESSORY_SEND_HID_EVENT,
                           USB_DIR_OUT | USB_TYPE_VENDOR,
                           value,
                           0,
                           (u8 *)pbuf,
                           len);
}
int get_ms_extended_compat_id(struct usb_host_device *host_dev,  u8 *buffer)
{
    return usb_control_msg(host_dev,
                           0x01,
                           USB_DIR_IN | USB_RECIP_DEVICE | USB_TYPE_VENDOR,
                           0x0000,
                           4,
                           buffer,
                           0x28);
}


int usb_set_interface(struct usb_host_device *host_dev, u8 interface, u8 alternateSetting)
{
    log_info("%s Set Interface:%d AlternateSetting:%d", __func__, interface, alternateSetting);
    return usb_control_msg(host_dev,
                           USB_REQ_SET_INTERFACE,
                           USB_RECIP_INTERFACE,
                           alternateSetting,
                           interface,
                           NULL,
                           0);

}

int usb_audio_sampling_frequency_control(struct usb_host_device *host_dev, u32 ep, u32 sampe_rate)
{
    log_info("%s ep:%d sampe_rate:%d", __func__, ep, sampe_rate);
    return usb_control_msg(host_dev,
                           1,
                           USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
                           0x0100,
                           ep,
                           &sampe_rate,
                           3);
}
int usb_audio_volume_control(struct usb_host_device *host_dev, u8 feature_id, u8 channel_num, u16 volume)
{
    log_info("%s featureID:%d vol:%x", __func__, feature_id, volume);
    return usb_control_msg(host_dev,
                           1,
                           USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                           (0x02 << 8) | channel_num,
                           feature_id << 8,
                           &volume,
                           2);
}
int usb_audio_mute_control(struct usb_host_device *host_dev, u8 feature_id, u8 mute)
{
    log_info("%s featureID:%d mute:%d", __func__, feature_id, mute);
    return usb_control_msg(host_dev,
                           1,
                           USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                           0x0100,
                           feature_id << 8,
                           &mute,
                           1);
}
#endif