/******************************************************************************
|
*
|
* 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 _PHL_TRX_USB_C_
|
#include "../phl_headers.h"
|
#include "phl_trx_usb.h"
|
|
#define IDX_NONE (0xffffffff)
|
#define GET_SHIFT_OFFSET(_bulk_size) \
|
((_bulk_size) == USB_SUPER_SPEED_BULK_SIZE) ? (10) : \
|
(((_bulk_size) == USB_HIGH_SPEED_BULK_SIZE) ? (9) : (6))
|
|
enum rtw_phl_status
|
phl_release_rxbuf_usb(struct phl_info_t *phl_info, void *r, u8 ch, enum rtw_rx_type type);
|
|
static enum rtw_phl_status enqueue_usb_buf(
|
struct phl_info_t *phl_info,
|
struct phl_queue *pool_list,
|
struct phl_usb_buf *usb_buf, u8 pos)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
_os_spinlockfg sp_flags;
|
|
if (usb_buf != NULL) {
|
_os_spinlock(drv, &pool_list->lock, _irq, &sp_flags);
|
if (_tail == pos)
|
list_add_tail(&usb_buf->list, &pool_list->queue);
|
else if (_first == pos)
|
list_add(&usb_buf->list, &pool_list->queue);
|
pool_list->cnt++;
|
_os_spinunlock(drv, &pool_list->lock, _irq, &sp_flags);
|
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
}
|
|
return pstatus;
|
|
}
|
|
static struct phl_usb_buf *dequeue_usb_buf(struct phl_info_t *phl_info,
|
struct phl_queue *pool_list)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
struct phl_usb_buf *usb_buf = NULL;
|
_os_spinlockfg sp_flags;
|
|
_os_spinlock(drv, &pool_list->lock, _irq, &sp_flags);
|
if (list_empty(&pool_list->queue)) {
|
usb_buf = NULL;
|
} else {
|
usb_buf = list_first_entry(&pool_list->queue, struct phl_usb_buf, list);
|
|
list_del(&usb_buf->list);
|
pool_list->cnt--;
|
}
|
_os_spinunlock(drv, &pool_list->lock, _irq, &sp_flags);
|
return usb_buf;
|
}
|
|
static void _phl_free_txbuf_usb(struct phl_info_t *phl_info,
|
struct phl_usb_buf *tx_buf)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
|
if (NULL != tx_buf) {
|
if (tx_buf->buffer) {
|
_os_kmem_free(drv, tx_buf->buffer, tx_buf->buf_len);
|
tx_buf->buffer = NULL;
|
}
|
_os_mem_free(drv, tx_buf, sizeof(struct phl_usb_buf));
|
tx_buf = NULL;
|
}
|
}
|
|
|
static void _phl_free_txbuf_pool_usb(struct phl_info_t *phl_info, u8 *txbuf_pool)
|
{
|
struct phl_usb_tx_buf_resource *ring = NULL;
|
struct phl_usb_buf *tx_buf = NULL;
|
FUNCIN();
|
|
ring = (struct phl_usb_tx_buf_resource *)txbuf_pool;
|
if (NULL != ring) {
|
while (1) {
|
tx_buf = dequeue_usb_buf(phl_info, &ring->idle_txbuf_list);
|
if (tx_buf == NULL)
|
break;
|
|
_phl_free_txbuf_usb(phl_info, tx_buf);
|
}
|
while (1) {
|
tx_buf = dequeue_usb_buf(phl_info, &ring->mgmt_txbuf_list);
|
if (tx_buf == NULL)
|
break;
|
|
_phl_free_txbuf_usb(phl_info, tx_buf);
|
}
|
while (1) {
|
tx_buf = dequeue_usb_buf(phl_info, &ring->h2c_txbuf_list);
|
if (tx_buf == NULL)
|
break;
|
|
_phl_free_txbuf_usb(phl_info, tx_buf);
|
}
|
_os_mem_free(phl_to_drvpriv(phl_info), ring,
|
sizeof(struct phl_usb_tx_buf_resource));
|
ring = NULL;
|
}
|
|
FUNCOUT();
|
}
|
|
|
static struct phl_usb_buf *
|
_phl_alloc_txbuf_usb(struct phl_info_t *phl_info, u32 tx_buf_size)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
struct phl_usb_buf *tx_buf = NULL;
|
|
tx_buf = _os_mem_alloc(phl_to_drvpriv(phl_info), sizeof(struct phl_usb_buf));
|
if (tx_buf != NULL) {
|
tx_buf->buffer= _os_kmem_alloc(phl_to_drvpriv(phl_info),
|
tx_buf_size);
|
if (NULL == tx_buf->buffer) {
|
pstatus = RTW_PHL_STATUS_RESOURCE;
|
goto exit;
|
}
|
tx_buf->buf_len = tx_buf_size;
|
INIT_LIST_HEAD(&tx_buf->list);
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
}
|
|
return tx_buf;
|
|
exit:
|
if (RTW_PHL_STATUS_SUCCESS != pstatus)
|
_phl_free_txbuf_usb(phl_info, tx_buf);
|
|
return tx_buf;
|
}
|
|
static enum rtw_phl_status
|
_phl_alloc_txbuf_pool_usb(struct phl_info_t *phl_info)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
struct phl_usb_tx_buf_resource *tx_buf_ring = NULL;
|
struct phl_usb_buf *tx_buf = NULL;
|
struct rtw_hal_com_t *hal_com = rtw_hal_get_halcom(phl_info->hal);
|
struct bus_cap_t *bus_cap = &hal_com->bus_cap;
|
u32 i;
|
FUNCIN_WSTS(pstatus);
|
|
tx_buf_ring = _os_mem_alloc(phl_to_drvpriv(phl_info), sizeof(struct phl_usb_tx_buf_resource));
|
|
if (NULL != tx_buf_ring) {
|
INIT_LIST_HEAD(&tx_buf_ring->mgmt_txbuf_list.queue);
|
INIT_LIST_HEAD(&tx_buf_ring->idle_txbuf_list.queue);
|
INIT_LIST_HEAD(&tx_buf_ring->h2c_txbuf_list.queue);
|
_os_spinlock_init(phl_to_drvpriv(phl_info), &tx_buf_ring->mgmt_txbuf_list.lock);
|
_os_spinlock_init(phl_to_drvpriv(phl_info), &tx_buf_ring->idle_txbuf_list.lock);
|
_os_spinlock_init(phl_to_drvpriv(phl_info), &tx_buf_ring->h2c_txbuf_list.lock);
|
for (i = 0; i < bus_cap->tx_buf_num; i++) {
|
|
/*YiWei_todo tx_buf_size need do n bytes aligment*/
|
tx_buf = _phl_alloc_txbuf_usb(phl_info, bus_cap->tx_buf_size);
|
if (NULL == tx_buf) {
|
pstatus = RTW_PHL_STATUS_RESOURCE;
|
goto exit;
|
}
|
tx_buf->type = RTW_PHL_PKT_TYPE_DATA;
|
enqueue_usb_buf(phl_info, &tx_buf_ring->idle_txbuf_list, tx_buf, _tail);
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
}
|
for (i = 0; i < bus_cap->tx_mgnt_buf_num; i++) {
|
/*YiWei_todo tx_buf_size need do n bytes aligment*/
|
tx_buf = _phl_alloc_txbuf_usb(phl_info, bus_cap->tx_mgnt_buf_size);
|
if (NULL == tx_buf) {
|
pstatus = RTW_PHL_STATUS_RESOURCE;
|
goto exit;
|
}
|
tx_buf->type = RTW_PHL_PKT_TYPE_MGNT;
|
enqueue_usb_buf(phl_info, &tx_buf_ring->mgmt_txbuf_list, tx_buf, _tail);
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
}
|
for (i = 0; i < bus_cap->tx_h2c_buf_num; i++) {
|
|
tx_buf = _os_mem_alloc(phl_to_drvpriv(phl_info),
|
sizeof(struct phl_usb_buf));
|
if (NULL == tx_buf) {
|
pstatus = RTW_PHL_STATUS_RESOURCE;
|
goto exit;
|
}
|
tx_buf->type = RTW_PHL_PKT_TYPE_H2C;
|
enqueue_usb_buf(phl_info, &tx_buf_ring->h2c_txbuf_list, tx_buf, _tail);
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
}
|
/*PHL_INFO("%s, mgmt_buf_cnt = %d\n", __func__,
|
tx_buf_ring->mgmt_txbuf_list.cnt);
|
PHL_INFO("%s, idle_buf_cnt = %d\n", __func__,
|
tx_buf_ring->idle_txbuf_list.cnt);
|
PHL_INFO("%s, h2c_buf_cnt = %d\n", __func__,
|
tx_buf_ring->h2c_txbuf_list.cnt);*/
|
}
|
|
if (RTW_PHL_STATUS_SUCCESS == pstatus) {
|
phl_info->hci->txbuf_pool = (u8 *)tx_buf_ring;
|
}
|
FUNCOUT_WSTS(pstatus);
|
exit:
|
if (RTW_PHL_STATUS_SUCCESS != pstatus)
|
_phl_free_txbuf_pool_usb(phl_info, (u8 *)tx_buf_ring);
|
|
return pstatus;
|
|
}
|
|
|
void _phl_fill_tx_meta_data_usb(struct rtw_t_meta_data *mdata,
|
u16 packet_len)
|
{
|
mdata->wp_offset = 0;
|
mdata->wd_page_size = 1;
|
mdata->pktlen = packet_len;
|
mdata->hw_amsdu = 0;
|
mdata->bk = 1;
|
mdata->ampdu_en = 0;
|
}
|
|
/* [SD7_Ref] HalUsbInMpdu */
|
enum rtw_phl_status _phl_in_token_usb(struct phl_info_t *phl_info, u8 pipe_idx)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
enum rtw_hal_status hstatus = RTW_HAL_STATUS_FAILURE;
|
struct hci_info_t *hci_info = (struct hci_info_t *)phl_info->hci;
|
struct rtw_rx_buf_ring *rx_buf_ring = (struct rtw_rx_buf_ring *)hci_info->rxbuf_pool;
|
u8 rx_desc_sz=0;
|
struct rtw_rx_buf *rx_buf = NULL;
|
_os_list* obj = NULL;
|
|
//PHL_TRACE(COMP_PHL_RECV, _PHL_DEBUG_, "[1] %s:: 000 idle_rxbuf_list.cnt=%d\n",
|
// __FUNCTION__, rx_buf_ring->idle_rxbuf_list.cnt);
|
|
if(pq_pop(drv, &rx_buf_ring->idle_rxbuf_list, &obj, _first, _irq)) {
|
rx_buf = (struct rtw_rx_buf*)obj;
|
}
|
else
|
return RTW_PHL_STATUS_RESOURCE;
|
|
PHL_TRACE(COMP_PHL_RECV, _PHL_DEBUG_, "[1] %s:: ==> [%p] idle_rxbuf_list.cnt=%d\n",
|
__FUNCTION__, rx_buf, rx_buf_ring->idle_rxbuf_list.cnt);
|
|
hstatus = rtw_hal_query_info(phl_info->hal, RTW_HAL_RXDESC_SIZE, &rx_desc_sz);
|
if(RTW_HAL_STATUS_FAILURE == hstatus)
|
return RTW_PHL_STATUS_FAILURE;
|
|
/* Send the bulk IN request down. */
|
rx_buf->pipe_idx = pipe_idx;
|
|
pq_push(drv, &rx_buf_ring->busy_rxbuf_list, &rx_buf->list, _tail, _irq);
|
|
if(os_send_usb_in_token(drv, (void*)rx_buf, rx_buf->buffer,
|
rx_buf->buf_len, pipe_idx, rx_desc_sz) != RTW_PHL_STATUS_SUCCESS)
|
{
|
/* TODO:: temp::error hanlding */
|
PHL_TRACE(COMP_PHL_RECV, _PHL_WARNING_, "[1] %s:: [Error] os_send_usb_in_token\n",
|
__FUNCTION__);
|
pq_del_node(drv, &rx_buf_ring->busy_rxbuf_list, &rx_buf->list, _irq);
|
phl_release_rxbuf_usb(phl_info, rx_buf, 0, RTW_RX_TYPE_MAX); // usb doesn't care rtw_rx_type
|
|
return RTW_PHL_STATUS_FAILURE;
|
}
|
|
PHL_TRACE(COMP_PHL_RECV, _PHL_DEBUG_, "[1] %s:: <== [%p] busy_rxbuf_list.cnt=%d\n",
|
__FUNCTION__, rx_buf, rx_buf_ring->busy_rxbuf_list.cnt);
|
|
return RTW_PHL_STATUS_SUCCESS;
|
}
|
|
enum rtw_phl_status _phl_rx_start_usb(struct phl_info_t *phl_info)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_SUCCESS;
|
struct hal_spec_t *hal_spec = phl_get_ic_spec(phl_info->phl_com);
|
struct hci_info_t *hci_info = (struct hci_info_t *)phl_info->hci;
|
struct rtw_rx_buf_ring *rx_buf_ring = (struct rtw_rx_buf_ring *)hci_info->rxbuf_pool;
|
struct rtw_hal_com_t *hal_com = rtw_hal_get_halcom(phl_info->hal);
|
struct bus_cap_t *bus_cap = &hal_com->bus_cap;
|
u8 pipe_idx = 0;
|
|
for (pipe_idx = 0; pipe_idx < hal_spec->max_bulkin_num ; pipe_idx++) {
|
|
/* Send the bulk IN request down. */
|
if( pipe_idx==WLAN_IN_MPDU_PIPE_IDX )
|
{
|
while(rx_buf_ring->busy_rxbuf_list.cnt < (int)(bus_cap->in_token_num))
|
{
|
PHL_TRACE(COMP_PHL_RECV, _PHL_DEBUG_, "[0] %s:: rx_buf_ring->busy_rxbuf_list.cnt =%d\n",
|
__FUNCTION__, rx_buf_ring->busy_rxbuf_list.cnt );
|
|
pstatus = _phl_in_token_usb(phl_info, pipe_idx);
|
|
if(pstatus != RTW_PHL_STATUS_SUCCESS)
|
{
|
break;
|
}
|
}
|
}
|
/*else if( pipe_idx==WLAN_IN_INTERRUPT_PIPE_IDX )
|
{
|
if(_phl_in_token_usb(phl_info, pipe_idx) != RTW_PHL_STATUS_SUCCESS)
|
{
|
pstatus = RTW_PHL_STATUS_FAILURE;
|
break;
|
}
|
}*/
|
}
|
|
return pstatus;
|
}
|
|
|
void _phl_rx_stop_usb(struct phl_info_t *phl_info)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
struct hci_info_t *hci_info = (struct hci_info_t *)phl_info->hci;
|
struct rtw_rx_buf_ring *rx_buf_ring = (struct rtw_rx_buf_ring *)hci_info->rxbuf_pool;
|
|
_os_cancel_timer(drv, &rx_buf_ring->deferred_timer);
|
}
|
|
|
/* [ERROR Handling]: driver call this function to check pipe status */
|
static void _phl_rx_deferred_in_token(void *phl)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_SUCCESS;
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl;
|
void *drv = phl_to_drvpriv(phl_info);
|
struct hci_info_t *hci_info = (struct hci_info_t *)phl_info->hci;
|
struct rtw_rx_buf_ring *rx_buf_ring = (struct rtw_rx_buf_ring *)hci_info->rxbuf_pool;
|
|
PHL_TRACE(COMP_PHL_DBG, _PHL_WARNING_, "[5] %s:: ==>\n",
|
__FUNCTION__);
|
|
/* [1] Check driver/nic state*/
|
|
/* [2] Check in token num*/
|
pstatus = _phl_rx_start_usb(phl_info);
|
|
// set timer again
|
if(pstatus == RTW_PHL_STATUS_RESOURCE){
|
_phl_indic_new_rxpkt(phl_info);
|
_os_set_timer(drv, &rx_buf_ring->deferred_timer, 10);
|
}
|
}
|
|
/* [SD7_Ref] : HalUsbAllocInResource */
|
/* [SD4_Ref] : _rtw_init_recv_priv */
|
/* [phl_ref] : _phl_alloc_rxbuf_pool_pcie */
|
static enum rtw_phl_status
|
_phl_rx_init_usb(struct phl_info_t *phl_info, u8 pipe_cnt, u32 num_rxbuf)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
struct rtw_rx_buf_ring *rx_buf_ring = NULL;
|
struct rtw_rx_buf *rx_buf = NULL;
|
struct rtw_hal_com_t *hal_com = rtw_hal_get_halcom(phl_info->hal);
|
struct bus_cap_t *bus_cap = &hal_com->bus_cap;
|
|
u16 i = 0;
|
FUNCIN_WSTS(pstatus);
|
|
rx_buf_ring = _os_mem_alloc(drv, sizeof(struct rtw_rx_buf_ring));
|
if (NULL != rx_buf_ring) {
|
|
/* Initialize list for available rtw_rx_buf objects. */
|
_os_spinlock_init(drv, &rx_buf_ring->idle_rxbuf_list.lock);
|
_os_spinlock_init(drv, &rx_buf_ring->busy_rxbuf_list.lock);
|
_os_spinlock_init(drv, &rx_buf_ring->pend_rxbuf_list.lock);
|
INIT_LIST_HEAD(&rx_buf_ring->idle_rxbuf_list.queue);
|
INIT_LIST_HEAD(&rx_buf_ring->busy_rxbuf_list.queue);
|
INIT_LIST_HEAD(&rx_buf_ring->pend_rxbuf_list.queue);
|
rx_buf_ring->idle_rxbuf_list.cnt = 0;
|
rx_buf_ring->busy_rxbuf_list.cnt = 0;
|
rx_buf_ring->pend_rxbuf_list.cnt = 0;
|
|
rx_buf_ring->block_cnt_alloc = pipe_cnt * num_rxbuf;
|
|
/* Allocate memory for rtw_rx_buf objects. */
|
rx_buf_ring->total_blocks_size = sizeof(struct rtw_rx_buf) * rx_buf_ring->block_cnt_alloc;
|
|
rx_buf_ring->rxbufblock= _os_mem_alloc(drv, rx_buf_ring->total_blocks_size);
|
if (NULL != rx_buf_ring->rxbufblock) {
|
/* Initialize all rtw_rx_buf objects allocated and */
|
/* put them into the list for further use. */
|
rx_buf = (struct rtw_rx_buf*)rx_buf_ring->rxbufblock;
|
for (i = 0; i < rx_buf_ring->block_cnt_alloc; i++) {
|
/* MAX_RECEIVE_BUFFER_SIZE = 512(RX_AGG_BLOCK_SIZE) * 60(MAX_RX_AGG_BLKCNT) */
|
rx_buf->buf_len = bus_cap->rx_buf_size;
|
rx_buf->buffer = _os_kmem_alloc(drv, rx_buf->buf_len);
|
if (NULL == rx_buf->buffer) {
|
pstatus = RTW_PHL_STATUS_FAILURE;
|
break;
|
}
|
|
INIT_LIST_HEAD(&rx_buf->list);
|
_os_spinlock_init(drv, &rx_buf->lock);
|
rx_buf->pktcnt = 0;
|
|
pq_push(drv, &rx_buf_ring->idle_rxbuf_list, &rx_buf->list, _tail, _irq);
|
|
rx_buf++;
|
}
|
|
_os_init_timer(drv, &rx_buf_ring->deferred_timer,
|
_phl_rx_deferred_in_token, phl_info, "phl_rx_deferred_timer");
|
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
}
|
}
|
|
|
if (RTW_PHL_STATUS_SUCCESS == pstatus)
|
phl_info->hci->rxbuf_pool = (u8 *)rx_buf_ring;
|
|
FUNCOUT_WSTS(pstatus);
|
|
return pstatus;
|
}
|
|
static void _phl_rx_deinit_usb(struct phl_info_t *phl_info)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
struct hci_info_t *hci_info = (struct hci_info_t *)phl_info->hci;
|
struct rtw_rx_buf_ring *rx_buf_ring = (struct rtw_rx_buf_ring *)hci_info->rxbuf_pool;
|
struct rtw_rx_buf *rx_buf = NULL;
|
u32 total_cnt = 0;
|
//_os_list* obj = NULL;
|
u16 i = 0;
|
|
_os_cancel_timer(drv, &rx_buf_ring->deferred_timer);
|
_os_release_timer(drv, &rx_buf_ring->deferred_timer);
|
|
total_cnt = rx_buf_ring->idle_rxbuf_list.cnt +
|
rx_buf_ring->busy_rxbuf_list.cnt +
|
rx_buf_ring->pend_rxbuf_list.cnt;
|
|
if(total_cnt != rx_buf_ring->block_cnt_alloc)
|
PHL_ERR("%s:: alloc(%d)!=idle(%d)+ busy(%d)+ pend(%d)\n", __FUNCTION__,
|
rx_buf_ring->block_cnt_alloc, rx_buf_ring->idle_rxbuf_list.cnt,
|
rx_buf_ring->busy_rxbuf_list.cnt, rx_buf_ring->pend_rxbuf_list.cnt);
|
|
#if 0
|
// rtw_rx_buf may queue in phl_rx or recv_pkt , check it later.
|
while(rx_buf_ring->idle_rxbuf_list.cnt)
|
{
|
obj = NULL;
|
if(pq_pop(drv, &rx_buf_ring->idle_rxbuf_list, &obj, _first, _irq)) {
|
rx_buf = (struct rtw_rx_buf*)obj;
|
_os_spinlock_free(drv, &rx_buf->lock);
|
_os_kmem_free(drv, rx_buf->buffer, rx_buf->buf_len);
|
}
|
}
|
|
while(rx_buf_ring->pend_rxbuf_list.cnt)
|
{
|
obj = NULL;
|
if(pq_pop(drv, &rx_buf_ring->pend_rxbuf_list, &obj, _first, _irq)) {
|
rx_buf = (struct rtw_rx_buf*)obj;
|
_os_spinlock_free(drv, &rx_buf->lock);
|
_os_kmem_free(drv, rx_buf->buffer, rx_buf->buf_len);
|
}
|
}
|
|
while(rx_buf_ring->busy_rxbuf_list.cnt)
|
{
|
obj = NULL;
|
if(pq_pop(drv, &rx_buf_ring->busy_rxbuf_list, &obj, _first, _irq)) {
|
rx_buf = (struct rtw_rx_buf*)obj;
|
_os_spinlock_free(drv, &rx_buf->lock);
|
_os_kmem_free(drv, rx_buf->buffer, rx_buf->buf_len);
|
}
|
}
|
|
#else
|
// DeInitialize all rtw_rx_buf objects.
|
//
|
rx_buf = (struct rtw_rx_buf *)rx_buf_ring->rxbufblock;
|
for (i = 0; i < rx_buf_ring->block_cnt_alloc; i++)
|
{
|
//
|
// Free of this rtw_usb_rx_buf->buffer object.
|
//
|
_os_spinlock_free(drv, &rx_buf->lock);
|
_os_kmem_free(drv, rx_buf->buffer, rx_buf->buf_len);
|
rx_buf++;
|
}
|
#endif
|
|
/* Free memory block allocated for phl_usb_buf objects. */
|
_os_mem_free(drv, rx_buf_ring->rxbufblock, rx_buf_ring->total_blocks_size);
|
|
_os_mem_free(drv, rx_buf_ring, sizeof(struct rtw_rx_buf_ring));
|
}
|
|
void phl_rx_handle_normal(struct phl_info_t *phl_info,
|
struct rtw_phl_rx_pkt *phl_rx)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
_os_list frames;
|
|
INIT_LIST_HEAD(&frames);
|
|
if (phl_rx->r.mdata.rx_rate <= RTW_DATA_RATE_HE_NSS4_MCS11)
|
phl_info->phl_com->phl_stats.rx_rate_nmr[phl_rx->r.mdata.rx_rate]++;
|
|
pstatus = phl_rx_reorder(phl_info, phl_rx, &frames);
|
if (pstatus == RTW_PHL_STATUS_SUCCESS)
|
phl_handle_rx_frame_list(phl_info, &frames);
|
else
|
PHL_TRACE(COMP_PHL_RECV, _PHL_WARNING_, "[WARNING]handle normal rx error (0x%08X)!\n", pstatus);
|
}
|
|
enum rtw_phl_status phl_tx_release_buf_usb(void *phl, u8 *tx_buf_ptr)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl;
|
struct phl_usb_tx_buf_resource *tx_buf_res = NULL;
|
struct phl_usb_buf *release_tx_buf = (struct phl_usb_buf *)tx_buf_ptr;
|
|
tx_buf_res =
|
(struct phl_usb_tx_buf_resource *)phl_info->hci->txbuf_pool;
|
|
if (release_tx_buf->type == RTW_PHL_PKT_TYPE_H2C) {
|
phl_enqueue_idle_h2c_pkt(phl_info,
|
(struct rtw_h2c_pkt *)release_tx_buf->buffer);
|
release_tx_buf->buffer = NULL;
|
pstatus = enqueue_usb_buf(phl_info,
|
&tx_buf_res->h2c_txbuf_list, release_tx_buf, _tail);
|
} else if (release_tx_buf->type == RTW_PHL_PKT_TYPE_MGNT)
|
pstatus = enqueue_usb_buf(phl_info,
|
&tx_buf_res->mgmt_txbuf_list, release_tx_buf, _tail);
|
else
|
pstatus = enqueue_usb_buf(phl_info,
|
&tx_buf_res->idle_txbuf_list, release_tx_buf, _tail);
|
|
return pstatus;
|
}
|
|
enum rtw_phl_status
|
phl_prepare_tx_usb(struct phl_info_t *phl_info, struct rtw_xmit_req *tx_req)
|
{
|
return true;
|
}
|
|
|
enum rtw_phl_status
|
_phl_prepare_tx_usb(struct phl_info_t *phl_info, struct rtw_xmit_req *tx_req,
|
u8 *tx_buf_data, u32 *packet_len)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
enum rtw_hal_status hstatus = RTW_HAL_STATUS_FAILURE;
|
enum rtw_phl_status precycle = RTW_PHL_STATUS_FAILURE;
|
/* struct hci_info_t *hci_info = (struct hci_info_t *)phl_info->hci; */
|
struct rtw_pkt_buf_list *pkt_buf = NULL;
|
/* struct rtw_phl_pkt_req phl_pkt_req; */
|
struct rtw_phl_evt_ops *ops = &phl_info->phl_com->evt_ops;
|
u32 wd_len = 0;
|
u8 dummy = 0;
|
u8 i = 0;
|
|
do {
|
if (NULL == tx_req)
|
break;
|
|
/*tx_req->mdata.usb_pkt_ofst = 1;*/
|
|
hstatus = rtw_hal_fill_wd(phl_info->hal, tx_req, tx_buf_data, &wd_len);
|
if (hstatus != RTW_HAL_STATUS_SUCCESS) {
|
PHL_ERR("%s, fill_wd fail hstatus = %d\n", __func__, hstatus);
|
break;
|
} else {
|
/*PHL_INFO("%s, wd_len = %d\n", __func__, wd_len);*/
|
if(tx_req->mdata.usb_pkt_ofst == 1)
|
dummy = PKT_OFFSET_DUMMY;
|
tx_buf_data = tx_buf_data + wd_len + dummy;
|
*packet_len = *packet_len + wd_len + dummy;
|
/*PHL_INFO("%s, packet_len = %d\n", __func__, *packet_len);*/
|
}
|
|
/*tx_buf_data = tx_buf_data + 8;*/
|
/**packet_len = *packet_len + 8;*/
|
|
pkt_buf = (struct rtw_pkt_buf_list *)tx_req->pkt_list;
|
for (i = 0; i < tx_req->pkt_cnt; i++) {
|
/*PHL_INFO("%s, pkt[%d] 0x%p length = %d\n", __func__, i,
|
(void *)pkt_buf->vir_addr, pkt_buf->length);*/
|
if (pkt_buf->vir_addr) {
|
_os_mem_cpy(phl_to_drvpriv(phl_info),
|
tx_buf_data, pkt_buf->vir_addr, pkt_buf->length);
|
tx_buf_data = tx_buf_data + pkt_buf->length;
|
*packet_len = *packet_len + pkt_buf->length;
|
/*PHL_INFO("%s, packet_len = %d\n", __func__, *packet_len);*/
|
}
|
pkt_buf++;
|
}
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
|
} while (false);
|
|
if (RTW_PHL_TREQ_TYPE_TEST_PATTERN == tx_req->treq_type) {
|
if (NULL != ops->tx_test_recycle) {
|
precycle = ops->tx_test_recycle(phl_info, tx_req);
|
if (RTW_PHL_STATUS_SUCCESS != precycle)
|
PHL_WARN("tx_test_recycle fail\n");
|
}
|
} else if (RTW_PHL_TREQ_TYPE_NORMAL == tx_req->treq_type) {
|
if (NULL != ops->tx_recycle) {
|
precycle = ops->tx_recycle(phl_to_drvpriv(phl_info),
|
tx_req);
|
if (RTW_PHL_STATUS_SUCCESS != precycle)
|
PHL_WARN("tx recycle fail\n");
|
}
|
}
|
|
return pstatus;
|
}
|
|
static enum rtw_phl_status phl_tx_usb(struct phl_info_t *phl_info)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
|
return pstatus;
|
}
|
|
|
void phl_trx_deinit_usb(struct phl_info_t *phl_info)
|
{
|
FUNCIN();
|
|
os_out_token_free(phl_to_drvpriv(phl_info));
|
_phl_free_txbuf_pool_usb(phl_info, phl_info->hci->txbuf_pool);
|
|
os_in_token_free(phl_to_drvpriv(phl_info));
|
_phl_rx_deinit_usb(phl_info);
|
|
FUNCOUT();
|
}
|
|
void phl_req_tx_stop_usb(struct phl_info_t *phl_info)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
|
_os_atomic_set(drv, &phl_info->phl_sw_tx_sts,
|
PHL_TX_STATUS_STOP_INPROGRESS);
|
}
|
|
void phl_tx_stop_usb(struct phl_info_t *phl_info)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
|
_os_atomic_set(drv, &phl_info->phl_sw_tx_sts, PHL_TX_STATUS_SW_PAUSE);
|
}
|
|
void phl_req_rx_stop_usb(struct phl_info_t *phl_info)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
|
_os_atomic_set(drv, &phl_info->phl_sw_rx_sts,
|
PHL_RX_STATUS_STOP_INPROGRESS);
|
}
|
|
void phl_rx_stop_usb(struct phl_info_t *phl_info)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
|
_os_atomic_set(drv, &phl_info->phl_sw_rx_sts, PHL_RX_STATUS_SW_PAUSE);
|
}
|
|
bool phl_is_tx_sw_pause_usb(struct phl_info_t *phl_info)
|
{
|
void *drvpriv = phl_to_drvpriv(phl_info);
|
|
if (PHL_TX_STATUS_SW_PAUSE == _os_atomic_read(drvpriv,
|
&phl_info->phl_sw_tx_sts))
|
return true;
|
else
|
return false;
|
}
|
|
bool phl_is_rx_sw_pause_usb(struct phl_info_t *phl_info)
|
{
|
void *drvpriv = phl_to_drvpriv(phl_info);
|
|
if (PHL_RX_STATUS_SW_PAUSE == _os_atomic_read(drvpriv,
|
&phl_info->phl_sw_rx_sts))
|
return true;
|
else
|
return false;
|
}
|
|
void phl_tx_resume_usb(struct phl_info_t *phl_info)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
_os_atomic_set(drv, &phl_info->phl_sw_tx_sts, PHL_TX_STATUS_RUNNING);
|
}
|
|
void phl_rx_resume_usb(struct phl_info_t *phl_info)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
_os_atomic_set(drv, &phl_info->phl_sw_rx_sts, PHL_RX_STATUS_RUNNING);
|
}
|
|
void phl_trx_resume_usb(struct phl_info_t *phl_info, u8 type)
|
{
|
if (PHL_CTRL_TX & type)
|
phl_tx_resume_usb(phl_info);
|
|
if (PHL_CTRL_RX & type)
|
phl_rx_resume_usb(phl_info);
|
}
|
|
void phl_reset_tx_usb(struct phl_info_t *phl_info)
|
{
|
|
}
|
|
void phl_reset_rx_usb(struct phl_info_t *phl_info)
|
{
|
|
}
|
|
void phl_trx_reset_usb(struct phl_info_t *phl_info, u8 type)
|
{
|
struct rtw_phl_com_t *phl_com = phl_info->phl_com;
|
struct rtw_stats *phl_stats = &phl_com->phl_stats;
|
|
if (PHL_CTRL_TX & type) {
|
phl_reset_tx_usb(phl_info);
|
phl_reset_tx_stats(phl_stats);
|
}
|
|
if (PHL_CTRL_RX & type) {
|
phl_reset_rx_usb(phl_info);
|
phl_reset_rx_stats(phl_stats);
|
}
|
}
|
|
static void _phl_tx_flow_ctrl_usb(struct phl_info_t *phl_info,
|
struct phl_ring_status *target_ring,
|
struct phl_usb_buf **tx_buf)
|
{
|
struct phl_usb_tx_buf_resource *reso = NULL;
|
|
reso = (struct phl_usb_tx_buf_resource *)phl_info->hci->txbuf_pool;
|
/*PHL_INFO("%s, idle_txbuf_cnt = %d\n", __func__, reso->idle_txbuf_cnt);*/
|
|
if (reso) {
|
if (target_ring) {
|
if (target_ring->ring_ptr->tid == MGMT_TID)
|
*tx_buf = dequeue_usb_buf(phl_info, &reso->mgmt_txbuf_list);
|
else
|
*tx_buf = dequeue_usb_buf(phl_info, &reso->idle_txbuf_list);
|
}
|
} else {
|
PHL_ERR("%s, phl_usb_tx_buf_resource == NULL\n", __func__);
|
}
|
|
if (*tx_buf == NULL && target_ring != NULL) {
|
if (target_ring->ring_ptr->tid == MGMT_TID)
|
PHL_WARN("%s, mgnt tx_buf NULL free ring sts\n", __func__);
|
else
|
PHL_DBG("%s, idle tx_buf NULL free ring sts\n", __func__);
|
phl_release_ring_sts(phl_info, target_ring);
|
target_ring = NULL;
|
}
|
}
|
|
static void _usb_tx_agg_preprocess(struct phl_info_t *phl_info, u8 max_bulkout_wd_num,
|
struct phl_ring_status *ring_sts,
|
u32 *last_idx, u8 *add_dummy)
|
{
|
struct rtw_phl_tx_ring *tring = ring_sts->ring_ptr;
|
struct rtw_xmit_req *tx_req = NULL;
|
struct rtw_hal_com_t *hal_com = rtw_hal_get_halcom(phl_info->hal);
|
struct bus_cap_t *bus_cap = &hal_com->bus_cap;
|
u32 total = ring_sts->req_busy;
|
u16 cnt = 0;
|
u16 rptr = 0;
|
void *drv_priv = phl_to_drvpriv(phl_info);
|
u32 bulk_size = phl_info->hci->usb_bulkout_size;
|
u32 tx_len = 0;
|
u32 wd_len = MAX_WD_LEN;
|
u32 packet_len = 0;
|
u32 packet_align_len = 0;
|
u8 trasc_agg_cnt = 0;
|
u8 trasc_idx = 0;
|
u8 shift_offset = GET_SHIFT_OFFSET(bulk_size);
|
u16 idx = 0;
|
|
*last_idx = IDX_NONE;
|
*add_dummy = false;
|
|
rptr = (u16)_os_atomic_read(drv_priv, &tring->phl_next_idx);
|
while(cnt < total) {
|
idx = (rptr + cnt) % MAX_PHL_RING_ENTRY_NUM;
|
tx_req = (struct rtw_xmit_req *)tring->entry[idx];
|
if (NULL == tx_req) {
|
*last_idx = (cnt) ? (cnt - 1) : (IDX_NONE);
|
break;
|
}
|
if (tx_req->mdata.wdinfo_en ==1)
|
wd_len = MAX_WD_LEN;
|
else
|
wd_len = MAX_WD_BODY_LEN;
|
if (( _ALIGN(wd_len + tx_req->total_len,
|
8) + tx_len) > bus_cap->tx_buf_size - PKT_OFFSET_DUMMY) {
|
*last_idx = (cnt) ? (cnt - 1) : (IDX_NONE);
|
break;
|
}
|
/* packet_len represens the length of PREVIOUS copied tx req
|
* not the current one.
|
*/
|
packet_align_len = _ALIGN(packet_len, 8);
|
packet_align_len -= packet_len;
|
#ifdef RTW_WKARD_USB_TXAGG_BULK_END_WD
|
if(! ((tx_len + wd_len + packet_align_len) % bulk_size)) {
|
*last_idx = (cnt) ? (cnt - 1) : (IDX_NONE);
|
break;
|
}
|
#endif
|
/* if current tx req is accepted for aggregation
|
* 8 byte alignment is required before copying current data.
|
*/
|
tx_len += packet_align_len;
|
|
/* update packet_len for next alignment reference */
|
packet_len = wd_len + tx_req->total_len;
|
tx_len += packet_len;
|
/* chip only allow a limited number of WD
|
* placed inside per bulk transaction.
|
* */
|
trasc_agg_cnt++;
|
if(trasc_idx != tx_len >> shift_offset) {
|
trasc_idx = (u8)(tx_len >> shift_offset);
|
trasc_agg_cnt = 0;
|
}
|
if (trasc_agg_cnt >= max_bulkout_wd_num) {
|
*last_idx = cnt;
|
break;
|
}
|
cnt++;
|
if( tx_req->mdata.type != RTW_PHL_PKT_TYPE_DATA)
|
break;
|
#ifndef CONFIG_PHL_USB_TX_AGGREGATION
|
break;
|
#endif
|
}
|
if(*last_idx == IDX_NONE && tx_len && cnt <= total)
|
*last_idx = cnt - 1;
|
if( tx_len && ! (tx_len % bulk_size) )
|
*add_dummy = true;
|
}
|
static void _phl_tx_callback_usb(void *context);
|
static enum rtw_phl_status _phl_handle_xmit_ring_usb(struct phl_info_t *phl_info,
|
struct phl_ring_status *ring_sts, struct phl_usb_buf *tx_buf)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
/* struct phl_hci_trx_ops *hci_trx_ops = phl_info->hci_trx_ops; */
|
struct rtw_phl_tx_ring *tring = ring_sts->ring_ptr;
|
struct rtw_xmit_req *tx_req = NULL;
|
struct phl_usb_tx_buf_resource *tx_buf_res = NULL;
|
struct rtw_hal_com_t *hal_com = rtw_hal_get_halcom(phl_info->hal);
|
struct bus_cap_t *bus_cap = &hal_com->bus_cap;
|
u16 rptr = 0, next_idx = 0;
|
u32 packet_len = 0;
|
u32 packet_align_len = 0;
|
u32 tx_len = 0;
|
u8 *tx_buf_data = NULL;
|
u8 bulk_id = 0;
|
u8 agg_cnt = 0;
|
u8 dma_ch = tring->dma_ch;
|
enum rtw_packet_type type = 0;
|
u8 is_dummy = false;
|
u8 trasc_agg_cnt = 0;
|
u32 wd_len = 0;
|
u32 bulk_size = phl_info->hci->usb_bulkout_size;
|
u32 last_idx = IDX_NONE;
|
#ifdef CONFIG_PHL_USB_TX_AGGREGATION
|
u8 agg_en = 1;
|
u8 trasc_idx = 0;
|
u8 shift_offset = GET_SHIFT_OFFSET(bulk_size);
|
u8 max_bulkout_wd_num = rtw_hal_get_max_bulkout_wd_num(phl_info->hal);
|
#endif
|
void *drv_priv = phl_to_drvpriv(phl_info);
|
#ifdef CONFIG_PHL_USB_TX_PADDING_CHK
|
_usb_tx_agg_preprocess(phl_info, max_bulkout_wd_num, ring_sts,
|
&last_idx, &is_dummy);
|
#endif
|
tx_buf_data = tx_buf->buffer;
|
while (0 != ring_sts->req_busy) {
|
rptr = (u16)_os_atomic_read(drv_priv, &tring->phl_next_idx);
|
|
tx_req = (struct rtw_xmit_req *)tring->entry[rptr];
|
if (NULL == tx_req) {
|
PHL_ERR("tx_req is NULL!\n");
|
break;
|
}
|
|
tx_req->mdata.macid = ring_sts->macid;
|
tx_req->mdata.band = ring_sts->band;
|
tx_req->mdata.wmm = ring_sts->wmm;
|
tx_req->mdata.hal_port = ring_sts->port;
|
/*tx_req->mdata.mbssid = ring_sts->mbssid;*/
|
tx_req->mdata.tid = tring->tid;
|
tx_req->mdata.dma_ch = tring->dma_ch;
|
tx_req->mdata.pktlen = (u16)tx_req->total_len;
|
type = tx_req->mdata.type;
|
if (tx_req->mdata.wdinfo_en == 1)
|
wd_len = MAX_WD_LEN;
|
else
|
wd_len = MAX_WD_BODY_LEN;
|
if(last_idx != IDX_NONE && agg_cnt == (u8)last_idx && is_dummy) {
|
tx_req->mdata.usb_pkt_ofst = 1;
|
wd_len += PKT_OFFSET_DUMMY;
|
}
|
#ifdef CONFIG_PHL_USB_TX_PADDING_CHK
|
if (_ALIGN(wd_len + tx_req->total_len,
|
8) + tx_len > (bus_cap->tx_buf_size - PKT_OFFSET_DUMMY))
|
break;
|
#else
|
if (_ALIGN(wd_len + tx_req->total_len,
|
8) + tx_len > bus_cap->tx_buf_size)
|
break;
|
#endif
|
|
#ifdef CONFIG_PHL_USB_TX_AGGREGATION
|
if (agg_en && type == RTW_PHL_PKT_TYPE_DATA) {
|
packet_align_len = _ALIGN(packet_len, 8);
|
tx_buf_data = tx_buf_data + packet_align_len;
|
|
#ifdef RTW_WKARD_USB_TXAGG_BULK_END_WD
|
if (tx_len !=0) {
|
int check_len = 0;
|
check_len = tx_len + wd_len + packet_align_len - packet_len;
|
/*PHL_INFO("%s, tx_len(%d),wd_len(%d),packet_align_len(%d),packet_len(%d)\n",
|
__func__, tx_len, wd_len ,packet_align_len ,packet_len);*/
|
if(! (check_len % bulk_size)) {
|
PHL_TRACE(COMP_PHL_XMIT, _PHL_DEBUG_, "%s:AGG break!\n", __func__);
|
break;
|
}
|
}
|
#endif
|
|
if (packet_align_len > packet_len)
|
tx_len = tx_len + (packet_align_len - packet_len);
|
}
|
#endif
|
|
packet_len = 0;
|
pstatus = _phl_prepare_tx_usb(phl_info, tx_req,
|
tx_buf_data, &packet_len);
|
/*PHL_INFO("%s, packet_len = %d\n", __func__, packet_len);*/
|
|
tx_len = tx_len + packet_len;
|
/*PHL_INFO("%s, tx_len = %d\n", __func__, tx_len);*/
|
|
if (RTW_PHL_STATUS_SUCCESS == pstatus) {
|
ring_sts->req_busy--;
|
|
/* hana_todo, workaround here to update phl_index */
|
_os_atomic_set(drv_priv, &tring->phl_idx, rptr);
|
|
agg_cnt++;
|
trasc_agg_cnt++;
|
|
if (type != RTW_PHL_PKT_TYPE_DATA)
|
break;
|
|
#ifdef CONFIG_PHL_USB_TX_AGGREGATION
|
/* chip only allow a limited number of WD
|
* placed inside per bulk transaction.
|
* */
|
if(trasc_idx != tx_len >> shift_offset) {
|
trasc_idx = (u8)(tx_len >> shift_offset);
|
trasc_agg_cnt = 0;
|
}
|
if (trasc_agg_cnt >= max_bulkout_wd_num) {
|
/*PHL_PRINT("%s, hit wd limit(%d), break agg\n",
|
__func__, max_bulkout_wd_num);*/
|
break;
|
}
|
#else
|
if (agg_cnt == 1)
|
break;
|
#endif
|
|
if (0 != ring_sts->req_busy) {
|
next_idx = rptr + 1;
|
|
if (next_idx >= MAX_PHL_RING_ENTRY_NUM) {
|
_os_atomic_set(drv_priv,
|
&tring->phl_next_idx, 0);
|
|
} else {
|
_os_atomic_inc(drv_priv,
|
&tring->phl_next_idx);
|
}
|
}
|
|
} else {
|
_os_atomic_set(drv_priv, &tring->phl_idx, rptr);
|
PHL_INFO("HCI prepare tx fail\n");
|
break;
|
}
|
}
|
|
if (pstatus == RTW_PHL_STATUS_SUCCESS) {
|
tx_buf_data = tx_buf->buffer;
|
#ifdef CONFIG_PHL_USB_TX_PADDING_CHK
|
if( ! (tx_len % bulk_size) )
|
PHL_ERR("%s: no padding dummy\n", __func__);
|
#endif
|
#ifdef CONFIG_PHL_USB_TX_AGGREGATION
|
/*PHL_INFO("%s, agg_cnt = %d\n", __func__, agg_cnt);*/
|
if (agg_en && type == RTW_PHL_PKT_TYPE_DATA && agg_cnt > 1)
|
rtw_hal_usb_tx_agg_cfg(phl_info->hal, tx_buf_data, agg_cnt);
|
#endif
|
bulk_id = rtw_hal_get_bulkout_id(phl_info->hal,
|
dma_ch, 0);
|
pstatus = os_usb_tx(phl_to_drvpriv(phl_info),
|
(u8 *)tx_buf, bulk_id, tx_len, tx_buf_data);
|
}
|
|
if (pstatus != RTW_PHL_STATUS_SUCCESS) {
|
PHL_TRACE(COMP_PHL_DBG, _PHL_WARNING_, "[WARNING] phl_tx fail!\n");
|
if (tx_buf) {
|
tx_buf_res =
|
(struct phl_usb_tx_buf_resource *)phl_info->hci->txbuf_pool;
|
|
if (tring->tid == MGMT_TID)
|
pstatus = enqueue_usb_buf(phl_info,
|
&tx_buf_res->mgmt_txbuf_list, tx_buf, _tail);
|
else
|
pstatus = enqueue_usb_buf(phl_info,
|
&tx_buf_res->idle_txbuf_list, tx_buf, _tail);
|
}
|
}
|
|
phl_release_ring_sts(phl_info, ring_sts);
|
|
return pstatus;
|
}
|
|
static void _phl_tx_callback_usb(void *context)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
struct rtw_phl_handler *phl_handler
|
= (struct rtw_phl_handler *)phl_container_of(context,
|
struct rtw_phl_handler,
|
os_handler);
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl_handler->context;
|
/* struct phl_hci_trx_ops *hci_trx_ops = phl_info->hci_trx_ops; */
|
struct phl_ring_status *ring_sts = NULL, *t;
|
struct phl_usb_buf *tx_buf = NULL;
|
void *drvpriv = phl_to_drvpriv(phl_info);
|
_os_list sta_list;
|
bool tx_pause = false;
|
#ifdef CONFIG_POWER_SAVE
|
_os_atomic *trx_more = &phl_info->phl_sw_tx_more;
|
#endif
|
|
INIT_LIST_HEAD(&sta_list);
|
|
/* check datapath sw state */
|
tx_pause = phl_datapath_chk_trx_pause(phl_info, PHL_CTRL_TX);
|
if (true == tx_pause)
|
goto end;
|
|
#ifdef CONFIG_POWER_SAVE
|
/* check ps state when tx is not paused */
|
if ((true == _os_atomic_read(drvpriv, trx_more)) && (false == phl_ps_is_datapath_allowed(phl_info))) {
|
PHL_WARN("%s(): datapath is not allowed now... may in low power.\n", __func__);
|
goto chk_stop;
|
}
|
#endif
|
|
if (true == phl_check_xmit_ring_resource(phl_info, &sta_list)) {
|
phl_tx_flow_ctrl(phl_info, &sta_list);
|
|
phl_list_for_loop_safe(ring_sts, t, struct phl_ring_status,
|
&phl_info->t_fctrl_result, list) {
|
|
list_del(&ring_sts->list);
|
_phl_tx_flow_ctrl_usb(phl_info, ring_sts, &tx_buf);
|
|
if (ring_sts && tx_buf)
|
pstatus = _phl_handle_xmit_ring_usb(phl_info,
|
ring_sts,
|
tx_buf);
|
else if (!ring_sts)
|
PHL_DBG("%s, ring_sts NULL\n", __func__);
|
else if (!tx_buf)
|
PHL_DBG("%s, tx_buf NULL\n", __func__);
|
}
|
|
/*pstatus = hci_trx_ops->tx(phl_info);*/
|
}
|
#ifdef CONFIG_POWER_SAVE
|
chk_stop:
|
#endif
|
/* for the pause PHL Tx handshake with USB SER */
|
if (PHL_TX_STATUS_STOP_INPROGRESS ==
|
_os_atomic_read(drvpriv, &phl_info->phl_sw_tx_sts))
|
phl_tx_stop_usb(phl_info);
|
|
end:
|
phl_free_deferred_tx_ring(phl_info);
|
}
|
|
static void _phl_rx_callback_usb(void *context)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
struct rtw_phl_handler *phl_handler
|
= (struct rtw_phl_handler *)phl_container_of(context,
|
struct rtw_phl_handler,
|
os_handler);
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl_handler->context;
|
struct phl_hci_trx_ops *hci_trx_ops = phl_info->hci_trx_ops;
|
bool rx_pause = false;
|
|
/* check datapath sw state */
|
rx_pause = phl_datapath_chk_trx_pause(phl_info, PHL_CTRL_RX);
|
if (true == rx_pause)
|
goto end;
|
|
do {
|
if (false == phl_check_recv_ring_resource(phl_info))
|
break;
|
|
pstatus = hci_trx_ops->rx(phl_info);
|
|
if (RTW_PHL_STATUS_FAILURE == pstatus) {
|
PHL_TRACE(COMP_PHL_RECV, _PHL_WARNING_, "[WARNING] hci_trx_ops->rx fail!\n");
|
}
|
} while (false);
|
|
end:
|
return;
|
}
|
|
enum rtw_phl_status phl_trx_init_usb(struct phl_info_t *phl_info)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
struct hal_spec_t *hal_spec = phl_get_ic_spec(phl_info->phl_com);
|
struct rtw_phl_handler *tx_handler = &phl_info->phl_tx_handler;
|
struct rtw_phl_handler *rx_handler = &phl_info->phl_rx_handler;
|
struct rtw_hal_com_t *hal_com = rtw_hal_get_halcom(phl_info->hal);
|
struct bus_cap_t *bus_cap = &hal_com->bus_cap;
|
void *drv_priv = phl_to_drvpriv(phl_info);
|
|
FUNCIN_WSTS(pstatus);
|
PHL_INFO("%s, bus_cap->tx_buf_num(%d)\n", __func__, bus_cap->tx_buf_num);
|
PHL_INFO("%s, bus_cap->tx_buf_size(%d)\n", __func__, bus_cap->tx_buf_size);
|
PHL_INFO("%s, bus_cap->tx_mgnt_buf_num(%d)\n", __func__, bus_cap->tx_mgnt_buf_num);
|
PHL_INFO("%s, bus_cap->tx_mgnt_buf_size(%d)\n", __func__, bus_cap->tx_mgnt_buf_size);
|
PHL_INFO("%s, bus_cap->tx_h2c_buf_num(%d)\n", __func__, bus_cap->tx_h2c_buf_num);
|
PHL_INFO("%s, bus_cap->rx_buf_num(%d)\n", __func__, bus_cap->rx_buf_num);
|
PHL_INFO("%s, bus_cap->rx_buf_size(%d)\n", __func__, bus_cap->rx_buf_size);
|
PHL_INFO("%s, bus_cap->in_token_num(%d)\n", __func__, bus_cap->in_token_num);
|
do {
|
tx_handler->type = RTW_PHL_HANDLER_PRIO_HIGH; /* tasklet */
|
tx_handler->callback = _phl_tx_callback_usb;
|
tx_handler->context = phl_info;
|
tx_handler->drv_priv = drv_priv;
|
pstatus = phl_register_handler(phl_info->phl_com, tx_handler);
|
if (RTW_PHL_STATUS_SUCCESS != pstatus)
|
break;
|
|
rx_handler->type = RTW_PHL_HANDLER_PRIO_HIGH;
|
rx_handler->callback = _phl_rx_callback_usb;
|
rx_handler->context = phl_info;
|
rx_handler->drv_priv = drv_priv;
|
pstatus = phl_register_handler(phl_info->phl_com, rx_handler);
|
if (RTW_PHL_STATUS_SUCCESS != pstatus)
|
break;
|
|
/* usb tx sw resource */
|
/*YiWei_to need use correct txbuf num and txbuf size*/
|
pstatus = _phl_alloc_txbuf_pool_usb(phl_info);
|
if (RTW_PHL_STATUS_SUCCESS != pstatus)
|
break;
|
|
/* allocate rx packet buffer block */
|
pstatus = _phl_rx_init_usb(phl_info, hal_spec->max_bulkin_num, bus_cap->rx_buf_num);
|
if (RTW_PHL_STATUS_SUCCESS != pstatus)
|
break;
|
|
/* allocate platform in token */
|
/* OS maintain in token (number/init/free)*/
|
pstatus = os_in_token_alloc(phl_to_drvpriv(phl_info));
|
if (RTW_PHL_STATUS_SUCCESS != pstatus)
|
break;
|
|
pstatus = os_out_token_alloc(phl_to_drvpriv(phl_info));
|
if (RTW_PHL_STATUS_SUCCESS != pstatus)
|
break;
|
|
os_enable_usb_out_pipes(phl_to_drvpriv(phl_info));
|
os_enable_usb_in_pipes(phl_to_drvpriv(phl_info));
|
|
} while (false);
|
|
if (RTW_PHL_STATUS_SUCCESS != pstatus)
|
phl_trx_deinit_usb(phl_info);
|
|
FUNCOUT_WSTS(pstatus);
|
return pstatus;
|
}
|
|
/* phl_trx_start_usb */
|
enum rtw_phl_status phl_trx_cfg_usb(struct phl_info_t *phl_info)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_SUCCESS;
|
|
#ifdef CONFIG_PHL_USB_RX_AGGREGATION
|
rtw_hal_usb_rx_agg_cfg(phl_info->hal, PHL_RX_AGG_DEFAULT,
|
0, 0, 0, 0, 0);
|
#endif
|
os_enable_usb_out_pipes(phl_to_drvpriv(phl_info));
|
os_enable_usb_in_pipes(phl_to_drvpriv(phl_info));
|
|
pstatus = _phl_rx_start_usb(phl_info);
|
|
return pstatus;
|
}
|
|
|
void phl_trx_stop_usb(struct phl_info_t *phl_info)
|
{
|
_phl_rx_stop_usb(phl_info);
|
os_disable_usb_out_pipes(phl_to_drvpriv(phl_info));
|
os_disable_usb_in_pipes(phl_to_drvpriv(phl_info));
|
}
|
|
|
/*enqueue */
|
/* usb_read_port_complete */
|
enum rtw_phl_status
|
phl_pend_rxbuf_usb(struct phl_info_t *phl_info, void *rxobj, u32 inbuf_len, u8 status_code)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
void *drv = phl_to_drvpriv(phl_info);
|
struct hci_info_t *hci_info = (struct hci_info_t *)phl_info->hci;
|
struct rtw_rx_buf_ring *rx_buf_ring = (struct rtw_rx_buf_ring *)hci_info->rxbuf_pool;
|
struct rtw_rx_buf *rx_buf = (struct rtw_rx_buf *)rxobj;
|
|
if(!list_empty(&rx_buf_ring->busy_rxbuf_list.queue)) {
|
|
pq_del_node(drv, &rx_buf_ring->busy_rxbuf_list, &rx_buf->list, _irq);
|
}
|
else
|
PHL_ASSERT("[2] %s:: [Notice] rxbuf isn't in busy_rxbuf_list\n", __FUNCTION__);
|
|
if(status_code == RTW_PHL_STATUS_SUCCESS)
|
{
|
rx_buf->transfer_len = inbuf_len;
|
if(pq_push(drv, &rx_buf_ring->pend_rxbuf_list, &rx_buf->list, _tail, _irq))
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
}
|
else
|
{
|
PHL_TRACE(COMP_PHL_RECV, _PHL_INFO_, "[2] %s:: [Error] Complete\n",
|
__FUNCTION__);
|
phl_release_rxbuf_usb(phl_info, rx_buf, 0, RTW_RX_TYPE_MAX); // usb doesn't care rtw_rx_type
|
}
|
|
#if 0
|
/* for the pause PHL Rx handshake with USB SER */
|
if (PHL_RX_STATUS_SW_PAUSE == _os_atomic_read(drv,
|
&phl_info->phl_sw_rx_sts))
|
return RTW_PHL_STATUS_SUCCESS;
|
#endif
|
|
if(status_code == RTW_PHL_STATUS_SUCCESS)
|
{
|
if(_phl_in_token_usb(phl_info, rx_buf->pipe_idx) == RTW_PHL_STATUS_RESOURCE)
|
{
|
PHL_TRACE(COMP_PHL_DBG, _PHL_WARNING_, "[5] RTW_PHL_STATUS_RESOURCE :: idle_rxbuf_list or in_token empty \n");
|
|
_os_set_timer(drv, &rx_buf_ring->deferred_timer, 10);
|
}
|
}
|
|
return pstatus;
|
}
|
|
enum rtw_phl_status
|
phl_release_rxbuf_usb(struct phl_info_t *phl_info, void *r, u8 ch, enum rtw_rx_type type)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
struct hci_info_t *hci_info = (struct hci_info_t *)phl_info->hci;
|
struct rtw_rx_buf_ring *rx_buf_ring = NULL;
|
struct rtw_rx_buf *rx_buf = (struct rtw_rx_buf *)r;
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
_os_spinlockfg sp_flags;
|
bool ret = false;
|
|
rx_buf_ring = (struct rtw_rx_buf_ring *)hci_info->rxbuf_pool;
|
if (rx_buf_ring != NULL && rx_buf != NULL) {
|
|
_os_spinlock(drv, &rx_buf->lock, _irq, &sp_flags);
|
if(rx_buf->pktcnt)
|
rx_buf->pktcnt--;
|
|
if(!rx_buf->pktcnt)
|
{
|
_os_mem_set(drv, rx_buf->buffer, 0, rx_buf->buf_len);
|
INIT_LIST_HEAD(&rx_buf->list);
|
_os_spinunlock(drv, &rx_buf->lock, _irq, &sp_flags);
|
|
ret = pq_push(drv, &rx_buf_ring->idle_rxbuf_list, &rx_buf->list, _tail, _irq);
|
if(ret)
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
|
PHL_TRACE(COMP_PHL_RECV, _PHL_DEBUG_, "[4] %s:: [%p] idle_rxbuf_list.cnt=%d\n", __FUNCTION__, rx_buf, rx_buf_ring->idle_rxbuf_list.cnt);
|
}
|
else
|
{
|
_os_spinunlock(drv, &rx_buf->lock, _irq, &sp_flags);
|
|
PHL_TRACE(COMP_PHL_RECV, _PHL_DEBUG_, "[4] %s:: [%p] pktcnt =%d\n", __FUNCTION__, rx_buf, rx_buf->pktcnt);
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
}
|
}
|
|
return pstatus;
|
}
|
|
struct rtw_phl_rx_pkt *phl_get_single_rx(struct phl_info_t *phl_info,
|
struct rtw_rx_buf *rx_buf)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
enum rtw_hal_status hstatus = RTW_HAL_STATUS_FAILURE;
|
void *drv = phl_to_drvpriv(phl_info);
|
struct rtw_phl_rx_pkt *phl_rx = NULL, *phl_rxhead = NULL;
|
|
u8 *pkt_buf, *pkt_buf_end, ref_cnt = 0;
|
u8 *netbuf = NULL;
|
s32 transfer_len = 0;
|
s32 pkt_offset = 0, align_offset = 0;
|
bool brel = true, balloc = false;
|
_os_spinlockfg sp_flags;
|
u8 mfrag = 0, frag_num = 0;
|
u16 netbuf_len = 0;
|
|
//initialize for compiler
|
pkt_buf = rx_buf->buffer;
|
pkt_buf_end = rx_buf->buffer + rx_buf->transfer_len;
|
transfer_len = (s32)rx_buf->transfer_len;
|
|
do {
|
balloc = false;
|
phl_rx = rtw_phl_query_phl_rx(phl_info);
|
if (NULL == phl_rx) {
|
PHL_TRACE(COMP_PHL_RECV, _PHL_ERR_, "[3] %s(%d):: [Error] phl_rx out of resource\n",
|
__func__, __LINE__);
|
|
pstatus = RTW_PHL_STATUS_RESOURCE;
|
break;
|
|
}
|
|
// TODO:: Hal handle rx packet (rx desc/physts/hal rx data statistic)
|
hstatus = rtw_hal_handle_rx_buffer(phl_info->phl_com,
|
phl_info->hal,
|
pkt_buf, transfer_len,
|
phl_rx);
|
|
if (RTW_HAL_STATUS_SUCCESS != hstatus) {
|
phl_release_phl_rx(phl_info, phl_rx);
|
phl_rx = NULL;
|
pstatus = RTW_PHL_STATUS_FAILURE;
|
|
/*ToDo:: Should we take care that one of ampdu damaged?*/
|
if(ref_cnt)
|
PHL_ASSERT("[3] %s:: [Notice] one of ampdu damaged\n", __FUNCTION__);
|
break;
|
}
|
|
pkt_offset = (s32)(phl_rx->r.pkt_list[0].vir_addr - pkt_buf) + phl_rx->r.pkt_list[0].length;
|
|
#ifdef CONFIG_PHL_USB_RX_AGGREGATION
|
align_offset = _ALIGN(pkt_offset, 8); /*8 bytes aligned*/
|
#else
|
align_offset = pkt_offset;
|
#endif
|
|
if(phl_rxhead == NULL)
|
{
|
phl_rxhead = phl_rx;
|
INIT_LIST_HEAD(&phl_rxhead->list);
|
|
PHL_TRACE(COMP_PHL_RECV, _PHL_DEBUG_, "[3] %s:: [head %p]: transfer_len=%d\n",
|
__FUNCTION__, phl_rx->r.pkt_list[0].vir_addr, transfer_len);
|
}
|
else
|
{
|
list_add_tail(&phl_rx->list, &phl_rxhead->list);
|
|
PHL_TRACE(COMP_PHL_RECV, _PHL_DEBUG_,"[3] %s:: [child %p]: offset[%d -> %d] transfer_len=%d\n",
|
__FUNCTION__, phl_rx->r.pkt_list[0].vir_addr, pkt_offset, align_offset, transfer_len);
|
}
|
|
//shift buffer pointer
|
pkt_buf = pkt_buf + align_offset;
|
|
transfer_len -= align_offset;
|
|
if (phl_rx->type == RTW_RX_TYPE_WIFI)
|
{
|
/* Pre-alloc netbuf and replace pkt_list[0].vir_addr */
|
|
/* For first fragment packet, driver need allocate 1536 to defrag packet.*/
|
mfrag = PHL_GET_80211_HDR_MORE_FRAG(phl_rx->r.pkt_list[0].vir_addr);
|
frag_num = PHL_GET_80211_HDR_FRAG_NUM(phl_rx->r.pkt_list[0].vir_addr);
|
|
if (mfrag == 1 && frag_num == 0) {
|
if (phl_rx->r.pkt_list[0].length < RTW_MAX_ETH_PKT_LEN)
|
netbuf_len = RTW_MAX_ETH_PKT_LEN;
|
else
|
netbuf_len = phl_rx->r.pkt_list[0].length;
|
} else {
|
netbuf_len = phl_rx->r.pkt_list[0].length;
|
}
|
|
netbuf = _os_alloc_netbuf(drv,
|
netbuf_len,
|
&(phl_rx->r.os_priv));
|
|
if (netbuf) {
|
_os_mem_cpy(drv, netbuf,
|
phl_rx->r.pkt_list[0].vir_addr, phl_rx->r.pkt_list[0].length);
|
phl_rx->r.pkt_list[0].vir_addr = netbuf;
|
phl_rx->r.os_netbuf_len = netbuf_len;
|
balloc = true;
|
}
|
}
|
|
if(!balloc)
|
{
|
/* every phl_rx assign the same rx_buf */
|
phl_rx->rxbuf_ptr = (u8 *)rx_buf;
|
brel = false;
|
ref_cnt++;
|
}
|
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
|
} while (transfer_len > 0);
|
|
|
if(phl_rxhead)
|
{
|
if(brel)
|
{
|
PHL_TRACE(COMP_PHL_RECV, _PHL_DEBUG_, "[3] %s:: prealloc netbuff for all ampdu\n",
|
__FUNCTION__);
|
phl_release_rxbuf_usb(phl_info, rx_buf, phl_rxhead->r.mdata.dma_ch, phl_rxhead->type);
|
}
|
else
|
{
|
_os_spinlock(drv, &rx_buf->lock, _irq, &sp_flags);
|
rx_buf->pktcnt= ref_cnt;
|
_os_spinunlock(drv, &rx_buf->lock, _irq, &sp_flags);
|
/*PHL_TRACE(COMP_PHL_RECV,_PHL_DEBUG_,"[3] %s:: phl_rx=%p, ref_cnt= %d\n",
|
__FUNCTION__, phl_rx, ref_cnt);*/
|
}
|
}
|
return phl_rxhead;
|
}
|
|
void rtw_phl_post_in_complete(void *phl, void *rxobj, u32 inbuf_len, u8 status_code)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl;
|
struct phl_hci_trx_ops *hci_trx_ops = phl_info->hci_trx_ops;
|
|
pstatus = hci_trx_ops->pend_rxbuf(phl_info, rxobj, inbuf_len, status_code);
|
|
if(pstatus==RTW_PHL_STATUS_SUCCESS)
|
rtw_phl_start_rx_process(phl);
|
}
|
|
void phl_wp_report_record_sts_usb(struct phl_info_t *phl_info, u8 macid, u16 ac_queue,
|
u8 txsts)
|
{
|
struct rtw_phl_stainfo_t *phl_sta = NULL;
|
struct rtw_hal_stainfo_t *hal_sta = NULL;
|
struct rtw_wp_rpt_stats *wp_rpt_stats= NULL;
|
|
phl_sta = rtw_phl_get_stainfo_by_macid(phl_info, macid);
|
|
if (phl_sta) {
|
hal_sta = phl_sta->hal_sta;
|
/* Record Per ac queue statistics */
|
wp_rpt_stats = &hal_sta->trx_stat.wp_rpt_stats[ac_queue];
|
|
_os_spinlock(phl_to_drvpriv(phl_info), &hal_sta->trx_stat.tx_sts_lock, _bh, NULL);
|
if (TX_STATUS_TX_DONE == txsts) {
|
/* record total tx ok*/
|
hal_sta->trx_stat.tx_ok_cnt++;
|
/* record per ac queue tx ok*/
|
wp_rpt_stats->tx_ok_cnt++;
|
} else {
|
/* record total tx fail*/
|
hal_sta->trx_stat.tx_fail_cnt++;
|
/* record per ac queue tx fail*/
|
if (TX_STATUS_TX_FAIL_REACH_RTY_LMT == txsts)
|
wp_rpt_stats->rty_fail_cnt++;
|
else if (TX_STATUS_TX_FAIL_LIFETIME_DROP == txsts)
|
wp_rpt_stats->lifetime_drop_cnt++;
|
else if (TX_STATUS_TX_FAIL_MACID_DROP == txsts)
|
wp_rpt_stats->macid_drop_cnt++;
|
}
|
_os_spinunlock(phl_to_drvpriv(phl_info), &hal_sta->trx_stat.tx_sts_lock, _bh, NULL);
|
|
PHL_TRACE(COMP_PHL_DBG, _PHL_DEBUG_,"macid: %u, ac_queue: %u, tx_ok_cnt: %u, rty_fail_cnt: %u, "
|
"lifetime_drop_cnt: %u, macid_drop_cnt: %u\n"
|
, macid, ac_queue, wp_rpt_stats->tx_ok_cnt, wp_rpt_stats->rty_fail_cnt
|
, wp_rpt_stats->lifetime_drop_cnt, wp_rpt_stats->macid_drop_cnt);
|
PHL_TRACE(COMP_PHL_DBG, _PHL_DEBUG_,"totoal tx ok: %u \n totoal tx fail: %u\n"
|
, hal_sta->trx_stat.tx_ok_cnt, hal_sta->trx_stat.tx_fail_cnt);
|
} else {
|
PHL_TRACE(COMP_PHL_DBG, _PHL_DEBUG_, "%s: PHL_STA not found\n",
|
__FUNCTION__);
|
}
|
}
|
|
void _phl_rx_handle_wp_report_usb(struct phl_info_t *phl_info,
|
struct rtw_phl_rx_pkt *phl_rx)
|
{
|
struct rtw_recv_pkt *r = &phl_rx->r;
|
u8 *pkt = NULL;
|
u16 pkt_len = 0;
|
u16 rsize = 0;
|
u8 macid = 0, ac_queue = 0, txsts = 0;
|
|
pkt = r->pkt_list[0].vir_addr;
|
pkt_len = r->pkt_list[0].length;
|
|
while (pkt_len > 0) {
|
rsize = rtw_hal_handle_wp_rpt_usb(phl_info->hal, pkt, pkt_len,
|
&macid, &ac_queue, &txsts);
|
if (0 == rsize)
|
break;
|
|
phl_wp_report_record_sts_usb(phl_info, macid, ac_queue, txsts);
|
pkt += rsize;
|
pkt_len -= rsize;
|
}
|
}
|
|
|
static void phl_rx_process_usb(struct phl_info_t *phl_info,
|
struct rtw_phl_rx_pkt *phl_rxhead)
|
{
|
struct rtw_phl_rx_pkt *phl_rx = NULL;
|
|
do {
|
/* Get head of link list */
|
phl_rx = phl_rxhead;
|
|
/* assign next entry to head */
|
phl_rxhead = list_entry(phl_rx->list.next, struct rtw_phl_rx_pkt, list);
|
|
if(phl_rx == phl_rxhead)
|
phl_rxhead=NULL;
|
|
list_del(&phl_rx->list);
|
|
switch (phl_rx->type) {
|
case RTW_RX_TYPE_WIFI:
|
// phl_recycle_rx_buf would in phl_rx_handle_normal or core_rx.
|
#ifdef CONFIG_PHL_RX_PSTS_PER_PKT
|
if (false == phl_rx_proc_wait_phy_sts(phl_info, phl_rx)) {
|
PHL_TRACE(COMP_PHL_PSTS, _PHL_DEBUG_,
|
"phl_rx_proc_wait_phy_sts() return false \n");
|
phl_rx_handle_normal(phl_info, phl_rx);
|
}
|
#else
|
phl_rx_handle_normal(phl_info, phl_rx);
|
#endif
|
break;
|
case RTW_RX_TYPE_PPDU_STATUS:
|
phl_rx_proc_ppdu_sts(phl_info, phl_rx);
|
#ifdef CONFIG_PHL_RX_PSTS_PER_PKT
|
phl_rx_proc_phy_sts(phl_info, phl_rx);
|
#endif
|
phl_recycle_rx_buf(phl_info, phl_rx);
|
break;
|
case RTW_RX_TYPE_TX_WP_RELEASE_HOST:
|
#ifdef CONFIG_PHL_USB_RELEASE_RPT_ENABLE
|
_phl_rx_handle_wp_report_usb(phl_info, phl_rx);
|
phl_recycle_rx_buf(phl_info, phl_rx);
|
phl_rx = NULL;
|
break;
|
#endif /* CONFIG_PHL_USB_RELEASE_RPT_ENABLE */
|
case RTW_RX_TYPE_C2H:
|
case RTW_RX_TYPE_CHANNEL_INFO:
|
case RTW_RX_TYPE_TX_RPT:
|
case RTW_RX_TYPE_DFS_RPT:
|
case RTW_RX_TYPE_MAX:
|
PHL_TRACE(COMP_PHL_RECV, _PHL_DEBUG_, "phl_rx_process_usb(): Unsupported case:%d, please check it\n",
|
phl_rx->type);
|
phl_recycle_rx_buf(phl_info, phl_rx);
|
phl_rx = NULL;
|
break;
|
default :
|
PHL_TRACE(COMP_PHL_RECV, _PHL_INFO_, "[3] %s:: [Warning] rx type(0x%X) recycle \n",
|
__FUNCTION__, phl_rx->type);
|
phl_recycle_rx_buf(phl_info, phl_rx);
|
phl_rx = NULL;
|
break;
|
}
|
} while(phl_rxhead != NULL);
|
}
|
|
static enum rtw_phl_status phl_rx_usb(struct phl_info_t *phl_info)
|
{
|
void *drv = phl_to_drvpriv(phl_info);
|
struct hci_info_t *hci_info = (struct hci_info_t *)phl_info->hci;
|
struct rtw_phl_rx_pkt *phl_rx = NULL;
|
struct rtw_rx_buf_ring *rx_buf_ring = (struct rtw_rx_buf_ring *)hci_info->rxbuf_pool;
|
struct rtw_rx_buf *rx_buf = NULL;
|
_os_list* obj = NULL;
|
|
while (rx_buf_ring->pend_rxbuf_list.cnt)
|
{
|
PHL_TRACE(COMP_PHL_RECV, _PHL_DEBUG_, "[3] %s:: pend_rxbuf_list.cnt =%d\n",
|
__FUNCTION__, rx_buf_ring->pend_rxbuf_list.cnt );
|
|
if(pq_pop(drv, &rx_buf_ring->pend_rxbuf_list, &obj, _first, _irq)) {
|
rx_buf = (struct rtw_rx_buf*)obj;
|
}
|
else
|
break;
|
|
switch(rx_buf->pipe_idx){
|
case WLAN_IN_MPDU_PIPE_IDX:
|
{
|
/* phl_rx maybe single or link-list */
|
phl_rx = phl_get_single_rx(phl_info, rx_buf);
|
|
if(phl_rx)
|
{
|
phl_rx_process_usb(phl_info, phl_rx);
|
}
|
}
|
break;
|
|
case WLAN_IN_INTERRUPT_PIPE_IDX:
|
break;
|
|
default:
|
break;
|
}
|
|
if (phl_rx==NULL && NULL != rx_buf) {
|
PHL_TRACE(COMP_PHL_RECV, _PHL_INFO_, "[3] %s:: [Error] [%p] pipe_idx = %d \n",
|
__FUNCTION__, rx_buf, rx_buf->pipe_idx);
|
phl_release_rxbuf_usb(phl_info, rx_buf, 0, RTW_RX_TYPE_MAX); // usb doesn't care rtw_rx_type
|
rx_buf=NULL;
|
}
|
|
}
|
|
return RTW_PHL_STATUS_SUCCESS;
|
}
|
|
enum rtw_phl_status phl_pltfm_tx_usb(struct phl_info_t *phl_info,
|
void *pkt)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
struct rtw_h2c_pkt *h2c_pkt = (struct rtw_h2c_pkt *)pkt;
|
struct phl_usb_tx_buf_resource *reso = NULL;
|
struct phl_usb_buf *tx_buf = NULL;
|
u8 bulk_id = 0;
|
u8 dma_ch = rtw_hal_get_fwcmd_queue_idx(phl_info->hal);
|
|
reso = (struct phl_usb_tx_buf_resource *)phl_info->hci->txbuf_pool;
|
|
if (reso)
|
tx_buf = dequeue_usb_buf(phl_info, &reso->h2c_txbuf_list);
|
else
|
PHL_DBG("%s, phl_usb_tx_buf_resource == NULL\n", __func__);
|
|
if (tx_buf) {
|
tx_buf->buffer = (u8 *)h2c_pkt;
|
|
bulk_id = rtw_hal_get_bulkout_id(phl_info->hal,
|
dma_ch, 0);
|
pstatus = os_usb_tx(phl_to_drvpriv(phl_info),
|
(u8 *)tx_buf, bulk_id, h2c_pkt->data_len, h2c_pkt->vir_head);
|
if (pstatus == RTW_PHL_STATUS_FAILURE) {
|
phl_enqueue_idle_h2c_pkt(phl_info,
|
(struct rtw_h2c_pkt *)tx_buf->buffer);
|
tx_buf->buffer = NULL;
|
enqueue_usb_buf(phl_info,
|
&reso->h2c_txbuf_list, tx_buf, _tail);
|
}
|
}
|
return pstatus;
|
}
|
|
static void _phl_free_h2c_pkt_buf_usb(struct phl_info_t *phl_info,
|
struct rtw_h2c_pkt *_h2c_pkt)
|
{
|
struct rtw_h2c_pkt *h2c_pkt = _h2c_pkt;
|
|
_os_kmem_free(phl_to_drvpriv(phl_info),
|
h2c_pkt->vir_head, h2c_pkt->buf_len);
|
}
|
|
enum rtw_phl_status _phl_alloc_h2c_pkt_buf_usb(struct phl_info_t *phl_info,
|
struct rtw_h2c_pkt *_h2c_pkt,
|
u32 buf_len)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
struct rtw_h2c_pkt *h2c_pkt = _h2c_pkt;
|
|
h2c_pkt->vir_head = _os_kmem_alloc(phl_to_drvpriv(phl_info), buf_len);
|
|
if (h2c_pkt->vir_head)
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
|
return pstatus;
|
}
|
|
void *phl_get_txbd_buf_usb(struct phl_info_t *phl_info)
|
{
|
return NULL;
|
}
|
|
void *phl_get_rxbd_buf_usb(struct phl_info_t *phl_info)
|
{
|
return NULL;
|
}
|
|
void phl_recycle_rx_pkt_usb(struct phl_info_t *phl_info,
|
struct rtw_phl_rx_pkt *phl_rx)
|
{
|
/* Using r.os_priv seems imprperly. */
|
/* free netbuff for error case*/
|
if (phl_rx->r.os_priv)
|
_os_free_netbuf(phl_to_drvpriv(phl_info),
|
phl_rx->r.pkt_list[0].vir_addr,
|
phl_rx->r.os_netbuf_len,
|
phl_rx->r.os_priv);
|
|
phl_recycle_rx_buf(phl_info, phl_rx);
|
}
|
|
enum rtw_phl_status phl_register_trx_hdlr_usb(struct phl_info_t *phl_info)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
struct rtw_phl_handler *tx_handler = &phl_info->phl_tx_handler;
|
struct rtw_phl_handler *rx_handler = &phl_info->phl_rx_handler;
|
void *drv_priv = phl_to_drvpriv(phl_info);
|
|
tx_handler->type = RTW_PHL_HANDLER_PRIO_HIGH; /* tasklet */
|
tx_handler->callback = _phl_tx_callback_usb;
|
tx_handler->context = phl_info;
|
tx_handler->drv_priv = drv_priv;
|
pstatus = phl_register_handler(phl_info->phl_com, tx_handler);
|
if (RTW_PHL_STATUS_SUCCESS != pstatus)
|
PHL_ERR("%s : register tx_handler fail.\n", __FUNCTION__);
|
|
rx_handler->type = RTW_PHL_HANDLER_PRIO_HIGH;
|
rx_handler->callback = _phl_rx_callback_usb;
|
rx_handler->context = phl_info;
|
rx_handler->drv_priv = drv_priv;
|
pstatus = phl_register_handler(phl_info->phl_com, rx_handler);
|
if (RTW_PHL_STATUS_SUCCESS != pstatus)
|
PHL_ERR("%s : register rx_handler fail.\n", __FUNCTION__);
|
|
return pstatus;
|
}
|
|
void phl_tx_watchdog_usb(struct phl_info_t *phl_info)
|
{
|
|
}
|
|
static struct phl_hci_trx_ops ops= {
|
.hci_trx_init = phl_trx_init_usb,
|
.hci_trx_deinit = phl_trx_deinit_usb,
|
.prepare_tx = phl_prepare_tx_usb,
|
.recycle_tx_buf = phl_tx_release_buf_usb,
|
.recycle_rx_buf = phl_release_rxbuf_usb,
|
.tx = phl_tx_usb,
|
.rx = phl_rx_usb,
|
.trx_cfg = phl_trx_cfg_usb,
|
.trx_stop = phl_trx_stop_usb,
|
.pend_rxbuf = phl_pend_rxbuf_usb,
|
.pltfm_tx = phl_pltfm_tx_usb,
|
.alloc_h2c_pkt_buf = _phl_alloc_h2c_pkt_buf_usb,
|
.free_h2c_pkt_buf = _phl_free_h2c_pkt_buf_usb,
|
.trx_reset = phl_trx_reset_usb,
|
.trx_resume = phl_trx_resume_usb,
|
.req_tx_stop = phl_req_tx_stop_usb,
|
.req_rx_stop = phl_req_rx_stop_usb,
|
.is_tx_pause = phl_is_tx_sw_pause_usb,
|
.is_rx_pause = phl_is_rx_sw_pause_usb,
|
.get_txbd_buf = phl_get_txbd_buf_usb,
|
.get_rxbd_buf = phl_get_rxbd_buf_usb,
|
.recycle_rx_pkt = phl_recycle_rx_pkt_usb,
|
.register_trx_hdlr = phl_register_trx_hdlr_usb,
|
.rx_handle_normal = phl_rx_handle_normal,
|
.tx_watchdog = phl_tx_watchdog_usb
|
};
|
|
enum rtw_phl_status phl_hook_trx_ops_usb(struct phl_info_t *phl_info)
|
{
|
enum rtw_phl_status pstatus = RTW_PHL_STATUS_FAILURE;
|
|
if (NULL != phl_info) {
|
phl_info->hci_trx_ops = &ops;
|
pstatus = RTW_PHL_STATUS_SUCCESS;
|
}
|
|
return pstatus;
|
}
|
|
u8 rtw_phl_usb_tx_ep_id(void *phl, u16 macid, u8 tid, u8 band)
|
{
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl;
|
u8 dma_ch = 0;
|
u8 bulk_id = 0;
|
dma_ch = rtw_hal_tx_chnl_mapping(phl_info->hal, macid,
|
tid, band);
|
bulk_id = rtw_hal_get_bulkout_id(phl_info->hal,
|
dma_ch, 0);
|
return bulk_id;
|
}
|
|
enum rtw_phl_status
|
phl_force_usb_switch(struct phl_info_t *phl_info, u32 speed)
|
{
|
|
if(speed <= RTW_USB_SPEED_HIGH)
|
rtw_hal_force_usb_switch(phl_info->hal, USB_2_0);
|
else if(speed < RTW_USB_SPEED_MAX)
|
rtw_hal_force_usb_switch(phl_info->hal, USB_3_0);
|
PHL_INFO("%s (%d) !!\n", __FUNCTION__, speed);
|
|
return RTW_PHL_STATUS_SUCCESS;
|
}
|
#ifdef CONFIG_CMD_DISP
|
enum rtw_phl_status
|
rtw_phl_cmd_force_usb_switch(void *phl, u32 speed,
|
enum phl_band_idx band_idx,
|
enum phl_cmd_type cmd_type, u32 cmd_timeout)
|
{
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl;
|
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
|
u32 usb_speed = speed;
|
|
if (cmd_type == PHL_CMD_DIRECTLY)
|
psts = phl_force_usb_switch(phl_info, usb_speed);
|
else {
|
psts = phl_cmd_enqueue(phl_info,
|
band_idx,
|
MSG_EVT_FORCE_USB_SW,
|
(u8*)&usb_speed,
|
sizeof(u32),
|
NULL,
|
PHL_CMD_WAIT,
|
0);
|
|
if (is_cmd_failure(psts)) {
|
/* Send cmd success, but wait cmd fail*/
|
psts = RTW_PHL_STATUS_FAILURE;
|
} else if (psts != RTW_PHL_STATUS_SUCCESS) {
|
/* Send cmd fail */
|
psts = RTW_PHL_STATUS_FAILURE;
|
}
|
}
|
return psts;
|
}
|
#else /*for FSM*/
|
enum rtw_phl_status
|
rtw_phl_cmd_force_usb_switch(void *phl, u32 speed,
|
enum phl_band_idx band_idx,
|
enum phl_cmd_type cmd_type, u32 cmd_timeout)
|
{
|
return phl_force_usb_switch((struct phl_info_t *)phl, speed);
|
}
|
#endif /*CONFIG_CMD_DISP*/
|
|
enum rtw_phl_status
|
rtw_phl_cmd_get_usb_speed(void *phl, u32* speed,
|
enum phl_band_idx band_idx,
|
enum phl_cmd_type cmd_type, u32 cmd_timeout)
|
{
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl;
|
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
|
|
#ifdef CONFIG_CMD_DISP
|
psts = phl_cmd_enqueue(phl_info,
|
band_idx,
|
MSG_EVT_GET_USB_SPEED,
|
(u8*)speed,
|
sizeof(u32),
|
NULL,
|
PHL_CMD_WAIT,
|
0);
|
if (is_cmd_failure(psts)) {
|
/* Send cmd success, but wait cmd fail*/
|
psts = RTW_PHL_STATUS_FAILURE;
|
} else if (psts != RTW_PHL_STATUS_SUCCESS) {
|
/* Send cmd fail */
|
psts = RTW_PHL_STATUS_FAILURE;
|
}
|
#else
|
psts = phl_get_cur_usb_speed(phl_info, speed);
|
#endif
|
return psts;
|
}
|
enum rtw_phl_status
|
rtw_phl_cmd_get_usb_support_ability(void *phl, u32* ability,
|
enum phl_band_idx band_idx,
|
enum phl_cmd_type cmd_type, u32 cmd_timeout)
|
{
|
struct phl_info_t *phl_info = (struct phl_info_t *)phl;
|
enum rtw_phl_status psts = RTW_PHL_STATUS_FAILURE;
|
|
#ifdef CONFIG_CMD_DISP
|
psts = phl_cmd_enqueue(phl_info,
|
band_idx,
|
MSG_EVT_GET_USB_SW_ABILITY,
|
(u8*)ability,
|
sizeof(u32),
|
NULL,
|
PHL_CMD_WAIT,
|
0);
|
|
if (is_cmd_failure(psts)) {
|
/* Send cmd success, but wait cmd fail*/
|
psts = RTW_PHL_STATUS_FAILURE;
|
} else if (psts != RTW_PHL_STATUS_SUCCESS) {
|
/* Send cmd fail */
|
psts = RTW_PHL_STATUS_FAILURE;
|
}
|
#else
|
psts = phl_get_usb_support_ability(phl_info, ability);
|
#endif
|
return psts;
|
}
|
|
enum rtw_phl_status phl_get_cur_usb_speed(struct phl_info_t *phl_info, u32 *speed)
|
{
|
u32 mode = rtwl_hal_get_cur_usb_mode(phl_info->hal);
|
struct hci_info_t *hci = phl_info->hci;
|
|
switch(mode) {
|
case USB_1_1:
|
*speed = RTW_USB_SPEED_FULL;
|
hci->usb_bulkout_size = USB_FULL_SPEED_BULK_SIZE;
|
break;
|
case USB_2_0:
|
*speed = RTW_USB_SPEED_HIGH;
|
hci->usb_bulkout_size = USB_HIGH_SPEED_BULK_SIZE;
|
break;
|
case USB_3_0:
|
*speed = RTW_USB_SPEED_SUPER;
|
hci->usb_bulkout_size = USB_SUPER_SPEED_BULK_SIZE;
|
break;
|
default:
|
*speed = RTW_USB_SPEED_UNKNOWN;
|
break;
|
}
|
PHL_PRINT("%s (%d) bulk size(%d) !!\n", __FUNCTION__, *speed,
|
phl_info->hci->usb_bulkout_size);
|
|
return RTW_PHL_STATUS_SUCCESS;
|
}
|
enum rtw_phl_status
|
phl_get_usb_support_ability(struct phl_info_t *phl_info, u32 *ability)
|
{
|
*ability = rtwl_hal_get_usb_support_ability(phl_info->hal);
|
/* refer enum rtw_usb_sw_ability for definition of ability */
|
PHL_INFO("%s (%d) !!\n", __FUNCTION__, *ability);
|
return RTW_PHL_STATUS_SUCCESS;
|
}
|
