/******************************************************************************
 *
 * Copyright(c) 2019 Realtek Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 *****************************************************************************/
#define _HAL_USB_C_
#include "hal_headers.h"
#include "hal_usb.h"

#ifdef CONFIG_USB_HCI
u8 usb_read8(struct rtw_hal_com_t *hal, u32 addr)
{
	u8 request;
	u8 requesttype;
	u16 wvalue;
	u16 index;
	u16 len;
	u8 data = 0;

	request = 0x05;
	requesttype = 0x01;/* read_in */
	index = (u16)((addr & 0x00ff0000) >> 16);
	wvalue = (u16)(addr & 0x0000ffff);
	len = 1;

	_os_usbctrl_vendorreq(hal->drv_priv, request, wvalue, index,
				&data, len, requesttype);

	return data;
}

u16 usb_read16(struct rtw_hal_com_t *hal, u32 addr)
{
	u8 request;
	u8 requesttype;
	u16 wvalue;
	u16 index;
	u16 len;
	u16 data = 0;

	request = 0x05;
	requesttype = 0x01;/* read_in */
	index = (u16)((addr & 0x00ff0000) >> 16);
	wvalue = (u16)(addr & 0x0000ffff);
	len = 2;

	_os_usbctrl_vendorreq(hal->drv_priv, request, wvalue, index,
				&data, len, requesttype);
	return le16_to_cpu(data);

}

u32 usb_read32(struct rtw_hal_com_t *hal, u32 addr)
{
	u8 request;
	u8 requesttype;
	u16 wvalue;
	u16 index;
	u16 len;
	u32 data = 0;

	request = 0x05;
	requesttype = 0x01;/* read_in */
	index = (u16)((addr & 0x00ff0000) >> 16);
	wvalue = (u16)(addr & 0x0000ffff);
	len = 4;

	_os_usbctrl_vendorreq(hal->drv_priv, request, wvalue, index,
				&data, len, requesttype);
	return le32_to_cpu(data);
}

int usb_write8(struct rtw_hal_com_t *hal, u32 addr, u8 val)
{
	u8 request;
	u8 requesttype;
	u16 wvalue;
	u16 index;
	u16 len;
	u8 data;
	int ret;


	request = 0x05;
	requesttype = 0x00;/* write_out */
	index = (u16)((addr & 0x00ff0000) >> 16);
	wvalue = (u16)(addr & 0x0000ffff);
	len = 1;
	data = val;

	ret = _os_usbctrl_vendorreq(hal->drv_priv, 
			request, wvalue, index, &data, len, requesttype);
	return ret;
}

int usb_write16(struct rtw_hal_com_t *hal, u32 addr, u16 val)
{
	u8 request;
	u8 requesttype;
	u16 wvalue;
	u16 index;
	u16 len;
	u16 data;
	int ret;

	request = 0x05;
	requesttype = 0x00;/* write_out */
	index = (u16)((addr & 0x00ff0000) >> 16);
	wvalue = (u16)(addr & 0x0000ffff);
	len = 2;
	data = cpu_to_le16(val);

	ret = _os_usbctrl_vendorreq(hal->drv_priv,
			request, wvalue, index,	&data, len, requesttype);

	return ret;

}

int usb_write32(struct rtw_hal_com_t *hal, u32 addr, u32 val)
{
	u8 request;
	u8 requesttype;
	u16 wvalue;
	u16 index;
	u16 len;
	u32 data;
	int ret;

	request = 0x05;
	requesttype = 0x00;/* write_out */
	index = (u16)((addr & 0x00ff0000) >> 16);
	wvalue = (u16)(addr & 0x0000ffff);
	len = 4;
	data = cpu_to_le32(val);

	ret = _os_usbctrl_vendorreq(hal->drv_priv,
			request, wvalue, index,	&data, len, requesttype);

	return ret;

}

int usb_write_mem(struct rtw_hal_com_t *hal, u32 addr, u32 length, u8 *pdata)
{
	u8 request;
	u8 requesttype;
	u16 wvalue;
	u16 index;
	u16 len;
	int ret;
	u8 buf[MAX_VENDOR_REQ_CMD_SIZE] = {0};

	request = 0x05;
	requesttype = 0x00;/* write_out */
	index = (u16)((addr & 0x00ff0000) >> 16);
	wvalue = (u16)(addr & 0x0000ffff);
	len = (u16)length;

	_os_mem_cpy(hal->drv_priv, buf, pdata, len);

	ret = _os_usbctrl_vendorreq(hal->drv_priv,
			request, wvalue, index, pdata, len, requesttype);

	return ret;

}
#ifdef RTW_WKARD_BUS_WRITE
static int usb_write_post_cfg(struct rtw_hal_com_t *hal, u32 addr, u32 val)
{
	struct hal_info_t	*hal_info = hal->hal_priv;
	struct hal_ops_t	*hal_ops = hal_get_ops(hal_info);

	enum rtw_hal_status hal_status = RTW_HAL_STATUS_FAILURE;
	
	if(NULL != hal_ops->write_reg_post_cfg) {
		hal_status = hal_ops->write_reg_post_cfg(hal_info, addr, val);
	}

	return hal_status;
}
#endif
static void hal_usb_set_io_ops_gen(struct rtw_hal_com_t *hal, struct hal_io_ops *pops)
{
	/*_rtw_memset((u8 *)pops, 0, sizeof(struct hal_io_ops));*/
	_os_mem_set(hal->drv_priv, (u8 *)pops, 0, sizeof(struct hal_io_ops));

	pops->_read8 = &usb_read8;
	pops->_read16 = &usb_read16;
	pops->_read32 = &usb_read32;
	pops->_read_mem = NULL;

	pops->_write8 = &usb_write8;
	pops->_write16 = &usb_write16;
	pops->_write32 = &usb_write32;
	pops->_write_mem = &usb_write_mem;
#ifdef RTW_WKARD_BUS_WRITE
	pops->_write_post_cfg = &usb_write_post_cfg;
#endif
}

void hal_usb_set_io_ops(struct rtw_hal_com_t *hal, struct hal_io_ops *pops)
{
	hal_usb_set_io_ops_gen(hal, pops);
	/*hal_usb_set_io_ops_8852au(hal, pops);*/
}


/* To avoid RX affect TX throughput */
#ifdef CONFIG_PHL_USB_RX_AGGREGATION
void rtw_hal_usb_adjust_txagg(void *h)
{
	#if 0
	struct hal_info_t *hal = (struct hal_info_t *)h;
	struct registry_priv *registry_par = &padapter->registrypriv;

	if (!registry_par->dynamic_agg_enable)
		return;

	if (IS_HARDWARE_TYPE_8822BU(padapter) || IS_HARDWARE_TYPE_8821CU(padapter)
		|| IS_HARDWARE_TYPE_8822CU(padapter) || IS_HARDWARE_TYPE_8814BU(padapter))
		rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, NULL);
	#endif
}
#endif /* CONFIG_PHL_USB_RX_AGGREGATION */

enum rtw_hal_status rtw_hal_force_usb_switch(void *h, enum usb_type type)
{
	struct hal_info_t *hal = (struct hal_info_t *)h;
	u32 mode = hal_mac_get_cur_usb_mode(hal);
	bool bswitch = false;

	bswitch = ((enum usb_type)mode != type) ? (true) : (false);
	PHL_INFO("%s, switch from %d to %d\n", __func__,
							mode , type);
	if(bswitch)
		return hal_mac_force_usb_switch(hal);
	else
		return RTW_HAL_STATUS_SUCCESS;
}

u32 rtwl_hal_get_cur_usb_mode(void *h)
{
	struct hal_info_t *hal = (struct hal_info_t *)h;
	/*refer to enum usb_type*/
	return hal_mac_get_cur_usb_mode(hal);
}
u32 rtwl_hal_get_usb_support_ability(void *h)
{
	struct hal_info_t *hal = (struct hal_info_t *)h;
	/*
	* refers to _usb.h
	* #define SWITCHMODE           0x2
	* #define FORCEUSB3MODE        0x1
	* #define FORCEUSB2MODE        0x0
	*/
	return hal_mac_get_usb_support_ability(hal);
}

enum rtw_rx_status rtw_hal_get_usb_status(void *h)
{
	struct hal_info_t *hal = (struct hal_info_t *)h;
	struct mac_ax_adapter *mac = hal_to_mac(hal);
	struct mac_ax_ops *hal_mac_ops = mac->ops;
	u32 mac_usb_sts;
	u32 val;

	mac_usb_sts = hal_mac_ops->get_hw_value(mac, MAC_AX_HW_GET_USB_STS, &val);

	switch (mac_usb_sts) {
	case MACSUCCESS:
	case MACNOITEM:
		return RTW_STATUS_RX_OK;
	case MACRXDMAHANG:
		return RTW_STATUS_RXDMA_HANG;
	case MACUSBRXHANG:
		return RTW_STATUS_RXFIFO_HANG;
	default:
		return RTW_STATUS_RX_OK;
	}
}
#endif /*CONFIG_USB_HCI*/