/******************************************************************************
|
*
|
* Copyright(c) 2007 - 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 _USB_OPS_LINUX_C_
|
|
#include <drv_types.h>
|
#include <rtw_sreset.h>
|
|
int usbctrl_vendorreq(struct dvobj_priv *pdvobjpriv, u8 request, u16 value, u16 index, void *pdata, u16 len, u8 requesttype)
|
{
|
struct usb_device *udev = dvobj_to_usb(pdvobjpriv)->pusbdev;
|
|
unsigned int pipe;
|
int status = 0;
|
#ifdef CONFIG_USB_VENDOR_REQ_BUFFER_DYNAMIC_ALLOCATE
|
u32 tmp_buflen = 0;
|
#endif
|
u8 reqtype;
|
u8 *pIo_buf;
|
int vendorreq_times = 0;
|
|
#ifdef CONFIG_USB_VENDOR_REQ_BUFFER_DYNAMIC_ALLOCATE
|
u8 *tmp_buf;
|
#else /* use stack memory */
|
#ifndef CONFIG_USB_VENDOR_REQ_BUFFER_PREALLOC
|
u8 tmp_buf[MAX_USB_IO_CTL_SIZE];
|
#endif
|
#endif
|
|
/* RTW_INFO("%s %s:%d\n",__FUNCTION__, current->comm, current->pid); */
|
|
if (RTW_CANNOT_IO(pdvobjpriv)) {
|
status = -EPERM;
|
goto exit;
|
}
|
|
if (len > MAX_VENDOR_REQ_CMD_SIZE) {
|
RTW_INFO("[%s] Buffer len error ,vendor request failed\n", __FUNCTION__);
|
status = -EINVAL;
|
goto exit;
|
}
|
|
#ifdef CONFIG_USB_VENDOR_REQ_MUTEX
|
_rtw_mutex_lock(&dvobj_to_usb(pdvobjpriv)->usb_vendor_req_mutex);
|
#endif
|
|
|
/* Acquire IO memory for vendorreq */
|
#ifdef CONFIG_USB_VENDOR_REQ_BUFFER_PREALLOC
|
pIo_buf = dvobj_to_usb(pdvobjpriv)->usb_vendor_req_buf;
|
#else
|
#ifdef CONFIG_USB_VENDOR_REQ_BUFFER_DYNAMIC_ALLOCATE
|
tmp_buf = rtw_malloc((u32) len + ALIGNMENT_UNIT);
|
tmp_buflen = (u32)len + ALIGNMENT_UNIT;
|
#else /* use stack memory */
|
tmp_buflen = MAX_USB_IO_CTL_SIZE;
|
#endif
|
|
/* Added by Albert 2010/02/09 */
|
/* For mstar platform, mstar suggests the address for USB IO should be 16 bytes alignment. */
|
/* Trying to fix it here. */
|
pIo_buf = (tmp_buf == NULL) ? NULL : tmp_buf + ALIGNMENT_UNIT - ((SIZE_PTR)(tmp_buf) & 0x0f);
|
#endif
|
|
if (pIo_buf == NULL) {
|
RTW_INFO("[%s] pIo_buf == NULL\n", __FUNCTION__);
|
status = -ENOMEM;
|
goto release_mutex;
|
}
|
|
while (++vendorreq_times <= MAX_USBCTRL_VENDORREQ_TIMES) {
|
_rtw_memset(pIo_buf, 0, len);
|
|
if (requesttype == 0x01) {
|
pipe = usb_rcvctrlpipe(udev, 0);/* read_in */
|
reqtype = REALTEK_USB_VENQT_READ;
|
} else {
|
pipe = usb_sndctrlpipe(udev, 0);/* write_out */
|
reqtype = REALTEK_USB_VENQT_WRITE;
|
_rtw_memcpy(pIo_buf, pdata, len);
|
}
|
|
status = rtw_usb_control_msg(udev, pipe, request, reqtype, value, index, pIo_buf, len, RTW_USB_CONTROL_MSG_TIMEOUT);
|
|
if (status == len) { /* Success this control transfer. */
|
rtw_reset_continual_io_error(pdvobjpriv);
|
if (requesttype == 0x01) {
|
/* For Control read transfer, we have to copy the read data from pIo_buf to pdata. */
|
_rtw_memcpy(pdata, pIo_buf, len);
|
}
|
} else { /* error cases */
|
switch (len) {
|
case 1:
|
RTW_INFO("reg 0x%x, usb %s %u fail, status:%d value=0x%x, vendorreq_times:%d\n"
|
, (index << 16 | value), (requesttype == 0x01) ? "read" : "write" , len, status, *(u8 *)pdata, vendorreq_times);
|
break;
|
case 2:
|
RTW_INFO("reg 0x%x, usb %s %u fail, status:%d value=0x%x, vendorreq_times:%d\n"
|
, (index << 16 | value), (requesttype == 0x01) ? "read" : "write" , len, status, *(u16 *)pdata, vendorreq_times);
|
break;
|
case 4:
|
RTW_INFO("reg 0x%x, usb %s %u fail, status:%d value=0x%x, vendorreq_times:%d\n"
|
, (index << 16 | value), (requesttype == 0x01) ? "read" : "write" , len, status, *(u32 *)pdata, vendorreq_times);
|
break;
|
default:
|
RTW_INFO("reg 0x%x, usb %s %u fail, status:%d, vendorreq_times:%d\n"
|
, (index << 16 | value), (requesttype == 0x01) ? "read" : "write" , len, status, vendorreq_times);
|
break;
|
}
|
|
if (status < 0) {
|
if (status == (-ESHUTDOWN) || status == -ENODEV)
|
dev_set_surprise_removed(pdvobjpriv);
|
else {
|
|
}
|
} else { /* status != len && status >= 0 */
|
if (status > 0) {
|
if (requesttype == 0x01) {
|
/* For Control read transfer, we have to copy the read data from pIo_buf to pdata. */
|
_rtw_memcpy(pdata, pIo_buf, len);
|
}
|
}
|
}
|
|
if (rtw_inc_and_chk_continual_io_error(pdvobjpriv) == _TRUE) {
|
dev_set_surprise_removed(pdvobjpriv);
|
break;
|
}
|
|
}
|
|
if (status == len)
|
break;
|
|
}
|
|
/* release IO memory used by vendorreq */
|
#ifdef CONFIG_USB_VENDOR_REQ_BUFFER_DYNAMIC_ALLOCATE
|
rtw_mfree(tmp_buf, tmp_buflen);
|
#endif
|
|
release_mutex:
|
#ifdef CONFIG_USB_VENDOR_REQ_MUTEX
|
_rtw_mutex_unlock(&dvobj_to_usb(pdvobjpriv)->usb_vendor_req_mutex);
|
#endif
|
exit:
|
return status;
|
|
}
|
|
|
|
#if (KERNEL_VERSION(2, 5, 0) > LINUX_VERSION_CODE) ||\
|
(KERNEL_VERSION(2, 6, 18) < LINUX_VERSION_CODE)
|
/*#define _usbctrl_vendorreq_async_callback(urb, regs)\*/
|
/*_usbctrl_vendorreq_async_callback(urb)*/
|
/*#define usb_bulkout_zero_complete(purb, regs)\*/
|
/*usb_bulkout_zero_complete(purb)*/
|
#define rtw_usb_write_port_complete(purb, regs)\
|
rtw_usb_write_port_complete(purb)
|
#define rtw_usb_read_port_complete(purb, regs)\
|
rtw_usb_read_port_complete(purb)
|
#define rtw_usb_read_interrupt_complete(purb, regs)\
|
rtw_usb_read_interrupt_complete(purb)
|
#endif
|
|
static unsigned int bulkid2pipe(struct dvobj_priv *pdvobj, u32 addr, u8 bulk_out)
|
{
|
unsigned int pipe = 0, ep_num = 0;
|
PUSB_DATA usb_data = dvobj_to_usb(pdvobj);
|
struct usb_device *usbd = usb_data->pusbdev;
|
|
if (!bulk_out) {
|
if (usb_data->inpipe_type[addr] == REALTEK_USB_BULK_IN_EP_IDX)
|
pipe = usb_rcvbulkpipe(usbd, usb_data->RtInPipe[addr]);
|
else if (usb_data->inpipe_type[addr] == REALTEK_USB_IN_INT_EP_IDX)
|
pipe = usb_rcvintpipe(usbd, usb_data->RtInPipe[addr]);
|
} else if (addr < MAX_BULKOUT_NUM) {
|
ep_num = usb_data->RtOutPipe[addr];
|
pipe = usb_sndbulkpipe(usbd, ep_num);
|
}
|
return pipe;
|
}
|
|
int rtw_os_urb_resource_alloc(struct data_urb *dataurb)
|
{
|
dataurb->urb= usb_alloc_urb(0, GFP_KERNEL);
|
|
if (dataurb->urb == NULL) {
|
rtw_msleep_os(10);
|
dataurb->urb = usb_alloc_urb(0, GFP_KERNEL);
|
if (dataurb->urb == NULL) {
|
RTW_ERR("(dataurb->urb == NULL");
|
rtw_warn_on(1);
|
return _FAIL;
|
}
|
}
|
return _SUCCESS;
|
}
|
|
void rtw_os_urb_resource_free(struct data_urb *dataurb)
|
{
|
if (dataurb->urb) {
|
usb_free_urb(dataurb->urb);
|
dataurb->urb = NULL;
|
}
|
}
|
|
struct data_urb *rtw_alloc_dataurb(struct trx_urb_buf_q *urb_q)
|
{
|
struct data_urb *urb = NULL;
|
_list *urb_list, *urb_head;
|
_queue *free_urb_q = &urb_q->free_urb_buf_queue;
|
unsigned long sp_flags;
|
|
/* RTW_INFO("+rtw_alloc_litexmitbuf\n"); */
|
|
_rtw_spinlock_irq(&free_urb_q->lock, &sp_flags);
|
|
if (_rtw_queue_empty(free_urb_q) == _TRUE)
|
urb = NULL;
|
else {
|
|
urb_head = get_list_head(free_urb_q);
|
|
urb_list = get_next(urb_head);
|
|
urb = LIST_CONTAINOR(urb_list,
|
struct data_urb, list);
|
|
rtw_list_delete(&(urb->list));
|
}
|
|
if (urb != NULL)
|
urb_q->free_urb_buf_cnt--;
|
|
|
_rtw_spinunlock_irq(&free_urb_q->lock, &sp_flags);
|
|
|
return urb;
|
}
|
|
s32 rtw_free_dataurb(struct trx_urb_buf_q *urb_q,
|
struct data_urb *urb)
|
{
|
_queue *free_urb_q = &urb_q->free_urb_buf_queue;
|
unsigned long sp_flags;
|
|
/* RTW_INFO("+rtw_free_xmiturb\n"); */
|
|
if (urb_q == NULL)
|
return _FAIL;
|
|
if (urb == NULL)
|
return _FAIL;
|
|
_rtw_spinlock_irq(&free_urb_q->lock, &sp_flags);
|
|
rtw_list_delete(&urb->list);
|
|
rtw_list_insert_tail(&(urb->list),
|
get_list_head(free_urb_q));
|
|
urb_q->free_urb_buf_cnt++;
|
|
_rtw_spinunlock_irq(&free_urb_q->lock, &sp_flags);
|
|
return _SUCCESS;
|
}
|
|
static void rtw_usb_write_port_complete(struct urb *purb, struct pt_regs *regs)
|
{
|
|
struct lite_data_buf *litexmitbuf =
|
(struct lite_data_buf *)purb->context;
|
struct data_urb *xmiturb = litexmitbuf->dataurb;
|
struct dvobj_priv *pdvobj = litexmitbuf->dvobj;
|
unsigned long sp_flags;
|
|
if (RTW_CANNOT_TX(pdvobj)) {
|
RTW_INFO(
|
"%s(): TX Warning! bDriverStopped(%s) OR bSurpriseRemoved(%s)\n"
|
, __func__
|
, dev_is_drv_stopped(pdvobj) ? "True" : "False"
|
, dev_is_surprise_removed(pdvobj) ? "True" : "False");
|
|
goto check_completion;
|
}
|
|
|
if (purb->status == 0) {
|
|
} else {
|
RTW_INFO("###=> urb_write_port_complete status(%d)\n",
|
purb->status);
|
if ((purb->status == -EPIPE) || (purb->status == -EPROTO)) {
|
/* usb_clear_halt(pusbdev, purb->pipe); */
|
/* msleep(10); */
|
/*sreset_set_wifi_error_status(padapter,*/
|
/*USB_WRITE_PORT_FAIL);*/
|
} else if (purb->status == -EINPROGRESS) {
|
goto check_completion;
|
|
} else if (purb->status == -ENOENT) {
|
RTW_INFO("%s: -ENOENT\n", __func__);
|
goto check_completion;
|
|
} else if (purb->status == -ECONNRESET) {
|
RTW_INFO("%s: -ECONNRESET\n", __func__);
|
goto check_completion;
|
|
} else if (purb->status == -ESHUTDOWN) {
|
dev_set_drv_stopped(pdvobj);
|
|
goto check_completion;
|
} else {
|
dev_set_surprise_removed(pdvobj);
|
RTW_INFO("bSurpriseRemoved=TRUE\n");
|
|
goto check_completion;
|
}
|
}
|
|
|
check_completion:
|
|
|
rtw_sctx_done_err(&litexmitbuf->sctx,
|
purb->status ? RTW_SCTX_DONE_WRITE_PORT_ERR : RTW_SCTX_DONE_SUCCESS);
|
|
rtw_phl_recycle_tx_buf(pdvobj->phl, litexmitbuf->phl_buf_ptr);
|
rtw_free_litedatabuf(&pdvobj->litexmitbuf_q, litexmitbuf);
|
rtw_free_dataurb(&pdvobj->xmit_urb_q, xmiturb);
|
rtw_phl_tx_req_notify(pdvobj->phl);
|
|
}
|
|
|
u32 rtw_usb_write_port(void *d, u8 *phl_tx_buf_ptr,
|
u8 bulk_id, u32 len, u8 *pkt_data_buf)
|
{
|
|
int status;
|
unsigned int pipe;
|
u32 ret = _FAIL;
|
struct dvobj_priv *pdvobj = (struct dvobj_priv *)d;
|
struct usb_device *pusbd = dvobj_to_usb(pdvobj)->pusbdev;
|
struct lite_data_buf *litexmitbuf = NULL;
|
struct data_urb *xmiturb = NULL;
|
|
|
litexmitbuf = rtw_alloc_litedatabuf(&pdvobj->litexmitbuf_q);
|
if (litexmitbuf == NULL) {
|
RTW_INFO("%s,%d Can't alloc lite xmit buf\n",
|
__func__, __LINE__);
|
goto exit;
|
}
|
xmiturb = rtw_alloc_dataurb(&pdvobj->xmit_urb_q);
|
if (xmiturb == NULL) {
|
RTW_INFO("%s,%d Can't alloc lite xmit urb\n",
|
__func__, __LINE__);
|
goto exit;
|
}
|
|
if (RTW_CANNOT_TX(pdvobj)) {
|
#ifdef DBG_TX
|
RTW_INFO(" DBG_TX %s:%d bDriverStopped:%s, bSurpriseRemoved:%s\n"
|
,__func__, __LINE__,
|
dev_is_drv_stopped(pdvobj) ? "True" : "False",
|
dev_is_surprise_removed(pdvobj) ? "True" : "False");
|
#endif
|
rtw_sctx_done_err(&litexmitbuf->sctx, RTW_SCTX_DONE_TX_DENY);
|
goto exit;
|
}
|
|
litexmitbuf->dvobj = pdvobj;
|
litexmitbuf->pbuf = pkt_data_buf;
|
litexmitbuf->dataurb = xmiturb;
|
litexmitbuf->phl_buf_ptr = phl_tx_buf_ptr;
|
|
pipe = bulkid2pipe(pdvobj, bulk_id, _TRUE);
|
|
usb_fill_bulk_urb(xmiturb->urb, pusbd, pipe,
|
litexmitbuf->pbuf,
|
len,
|
rtw_usb_write_port_complete,
|
litexmitbuf);
|
xmiturb->urb->transfer_flags |= URB_ZERO_PACKET;
|
status = usb_submit_urb(xmiturb->urb, GFP_ATOMIC);
|
if (!status) {
|
|
} else {
|
rtw_sctx_done_err(&litexmitbuf->sctx,
|
RTW_SCTX_DONE_WRITE_PORT_ERR);
|
RTW_INFO("%s, status=%d\n", __func__, status);
|
|
switch (status) {
|
case -ENODEV:
|
dev_set_drv_stopped(pdvobj);
|
break;
|
default:
|
break;
|
}
|
goto exit;
|
}
|
|
ret = _SUCCESS;
|
|
exit:
|
if (ret != _SUCCESS) {
|
rtw_free_litedatabuf(&pdvobj->litexmitbuf_q, litexmitbuf);
|
rtw_free_dataurb(&pdvobj->xmit_urb_q, xmiturb);
|
}
|
|
if (ret == _SUCCESS)
|
ret = RTW_PHL_STATUS_SUCCESS;
|
else
|
ret = RTW_PHL_STATUS_FAILURE;
|
|
return ret;
|
|
}
|
|
|
void rtw_usb_write_port_cancel(void *d)
|
{
|
int i, j;
|
struct dvobj_priv *dvobj = (struct dvobj_priv *)d;
|
struct data_urb *xmiturb = (struct data_urb *)dvobj->xmit_urb_q.urb_buf;
|
u32 xmiturb_nr = RTW_XMITURB_NR;
|
|
|
if (dvobj == NULL) {
|
RTW_ERR("%s dvobj is NULL\n", __func__);
|
rtw_warn_on(1);
|
return;
|
}
|
|
RTW_INFO("%s\n", __func__);
|
|
for (i = 0; i < xmiturb_nr; i++) {
|
usb_kill_urb(xmiturb->urb);
|
xmiturb++;
|
}
|
|
|
}
|
|
static void rtw_usb_read_port_complete(struct urb *urb, struct pt_regs *regs)
|
{
|
struct lite_data_buf *literecvbuf =
|
(struct lite_data_buf *)urb->context;
|
struct data_urb *recvurb = literecvbuf->dataurb;
|
struct dvobj_priv *dvobj = literecvbuf->dvobj;
|
struct trx_data_buf_q *rx_data_buf_q = NULL;
|
struct trx_urb_buf_q *rx_urb_q = NULL;
|
u32 actual_length = urb->actual_length;
|
u32 transfer_buffer_length = urb->transfer_buffer_length;
|
u8 bulk_id = recvurb->bulk_id;
|
u8 minlen = recvurb->minlen;
|
unsigned long sp_flags;
|
u8 status = _SUCCESS;
|
|
|
if (bulk_id == REALTEK_USB_BULK_IN_EP_IDX) {
|
rx_data_buf_q = &dvobj->literecvbuf_q;
|
rx_urb_q = &dvobj->recv_urb_q;
|
ATOMIC_DEC(&(dvobj->rx_pending_cnt));
|
} else {
|
#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
|
rx_data_buf_q = &dvobj->intin_buf_q;
|
rx_urb_q = &dvobj->intin_urb_q;
|
#endif
|
}
|
|
if (RTW_CANNOT_RX(dvobj)) {
|
RTW_INFO("%s() RX Warning! bDriverStopped(%s) OR bSurpriseRemoved(%s)\n"
|
, __func__
|
, dev_is_drv_stopped(dvobj) ? "True" : "False"
|
, dev_is_surprise_removed(dvobj) ? "True" : "False");
|
|
status = _FAIL;
|
goto exit;
|
}
|
|
if (urb->status == 0) {
|
if ((actual_length > transfer_buffer_length) || (actual_length < minlen)) {
|
RTW_INFO("%s()-%d: actual_length:%u, transfer_buffer_length:%u, minlen:%u\n"
|
, __FUNCTION__, __LINE__, actual_length, transfer_buffer_length, minlen);
|
|
status = _FAIL;
|
goto exit;
|
} else {
|
rtw_reset_continual_io_error(dvobj);
|
status = _SUCCESS;
|
goto exit;
|
}
|
} if (urb->status == -ENOENT) {
|
/*use usb_kill_urb urb status code = -ENOENT*/
|
status = _FAIL;
|
goto exit;
|
} else {
|
|
RTW_INFO("###=> %s => urb.status(%d)\n", __func__, urb->status);
|
status = _FAIL;
|
|
if (rtw_inc_and_chk_continual_io_error(dvobj) == _TRUE)
|
dev_set_surprise_removed(dvobj);
|
|
switch (urb->status) {
|
case -EINVAL:
|
case -EPIPE:
|
case -ENODEV:
|
case -ESHUTDOWN:
|
dev_set_drv_stopped(dvobj);
|
break;
|
case -EPROTO:
|
case -EILSEQ:
|
case -ETIME:
|
case -ECOMM:
|
case -EOVERFLOW:
|
break;
|
case -EINPROGRESS:
|
RTW_INFO("ERROR: URB IS IN PROGRESS!/n");
|
break;
|
default:
|
break;
|
}
|
goto exit;
|
}
|
|
exit:
|
|
if (status == _SUCCESS)
|
status = RTW_PHL_STATUS_SUCCESS;
|
else
|
status = RTW_PHL_STATUS_FAILURE;
|
|
rtw_phl_post_in_complete(dvobj->phl, literecvbuf->phl_buf_ptr, actual_length, status);
|
rtw_free_litedatabuf(rx_data_buf_q, literecvbuf);
|
rtw_free_dataurb(rx_urb_q, recvurb);
|
}
|
|
u32 rtw_usb_read_port(void *d, void *rxobj,
|
u8 *inbuf, u32 inbuf_len, u8 bulk_id, u8 minlen)
|
{
|
int err;
|
unsigned int pipe;
|
u32 ret = _FAIL;
|
struct dvobj_priv *dvobj = (struct dvobj_priv *)d;
|
struct usb_device *usbd = dvobj_to_usb(dvobj)->pusbdev;
|
struct lite_data_buf *literecvbuf = NULL;
|
struct data_urb *recvurb = NULL;
|
struct trx_data_buf_q *rx_data_buf_q = NULL;
|
struct trx_urb_buf_q *rx_urb_q = NULL;
|
struct usb_data *usb_data = dvobj_to_usb(dvobj);
|
|
if (RTW_CANNOT_RX(dvobj) || (inbuf == NULL)) {
|
goto exit;
|
}
|
|
if (bulk_id == REALTEK_USB_BULK_IN_EP_IDX) {
|
rx_data_buf_q = &dvobj->literecvbuf_q;
|
rx_urb_q = &dvobj->recv_urb_q;
|
} else if (bulk_id == REALTEK_USB_IN_INT_EP_IDX) {
|
#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
|
rx_data_buf_q = &dvobj->intin_buf_q;
|
rx_urb_q = &dvobj->intin_urb_q;
|
#else
|
goto exit;
|
#endif
|
} else {
|
RTW_INFO("%s,%d Unkown bulk id:%d\n",
|
__func__, __LINE__, bulk_id);
|
ret = _FAIL;
|
goto exit;
|
}
|
|
literecvbuf = rtw_alloc_litedatabuf(rx_data_buf_q);
|
if (literecvbuf == NULL) {
|
RTW_INFO("%s,%d Can't alloc lite recv buf\n",
|
__func__, __LINE__);
|
goto exit;
|
}
|
recvurb = rtw_alloc_dataurb(rx_urb_q);
|
if (recvurb == NULL) {
|
RTW_INFO("%s,%d Can't alloc lite recv urb\n",
|
__func__, __LINE__);
|
goto exit;
|
}
|
|
recvurb->bulk_id = bulk_id;
|
recvurb->minlen = minlen;
|
literecvbuf->dvobj = dvobj;
|
literecvbuf->pbuf = inbuf;
|
literecvbuf->dataurb = recvurb;
|
literecvbuf->phl_buf_ptr = rxobj;
|
|
pipe = bulkid2pipe(dvobj, bulk_id, _FALSE);
|
|
if (bulk_id == REALTEK_USB_BULK_IN_EP_IDX) {
|
usb_fill_bulk_urb(recvurb->urb, usbd, pipe,
|
literecvbuf->pbuf,
|
inbuf_len,
|
rtw_usb_read_port_complete,
|
literecvbuf);
|
} else {
|
#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
|
if (usb_data->inpipe_type[bulk_id] == REALTEK_USB_BULK_IN_EP_IDX)
|
usb_fill_bulk_urb(recvurb->urb, usbd, pipe,
|
literecvbuf->pbuf,
|
inbuf_len,
|
rtw_usb_read_port_complete,
|
literecvbuf);
|
else
|
usb_fill_int_urb(recvurb->urb, usbd, pipe,
|
literecvbuf->pbuf,
|
inbuf_len,
|
rtw_usb_read_port_complete,
|
literecvbuf,
|
1);
|
#endif
|
}
|
|
err = usb_submit_urb(recvurb->urb, GFP_ATOMIC);
|
if ((err) && (err != (-EPERM))) {
|
RTW_INFO("cannot submit rx in-token(err = 0x%08x),urb_status = %d\n", err, recvurb->urb->status);
|
ret = _FAIL;
|
goto exit;
|
}
|
|
/* record usb bulk in */
|
if (bulk_id == REALTEK_USB_BULK_IN_EP_IDX)
|
ATOMIC_INC(&(dvobj->rx_pending_cnt));
|
|
ret = _SUCCESS;
|
exit:
|
if (ret != _SUCCESS) {
|
rtw_free_litedatabuf(rx_data_buf_q, literecvbuf);
|
rtw_free_dataurb(rx_urb_q, recvurb);
|
}
|
|
if (ret == _SUCCESS)
|
ret = RTW_PHL_STATUS_SUCCESS;
|
else
|
ret = RTW_PHL_STATUS_FAILURE;
|
|
return ret;
|
}
|
|
void rtw_usb_read_port_cancel(void *d)
|
{
|
int i;
|
struct dvobj_priv *dvobj = (struct dvobj_priv *)d;
|
struct data_urb *recvurb = (struct data_urb *)dvobj->recv_urb_q.urb_buf;
|
/*Elwin_todo need use correct literecvbuf_nr recvurb_nr */
|
u32 recvurb_nr = RTW_RECVURB_NR;
|
#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
|
u32 initinurb_nr = RTW_INTINURB_NR;
|
#endif
|
|
if (dvobj == NULL) {
|
RTW_ERR("%s dvobj is NULL\n", __func__);
|
rtw_warn_on(1);
|
return;
|
}
|
RTW_INFO("%s\n", __func__);
|
|
|
for (i = 0; i < recvurb_nr; i++) {
|
usb_kill_urb(recvurb->urb);
|
recvurb++;
|
}
|
|
|
#ifdef CONFIG_USB_INTERRUPT_IN_PIPE
|
recvurb = (struct data_urb *)dvobj->intin_urb_q.urb_buf;
|
for (i = 0; i < initinurb_nr; i++) {
|
usb_kill_urb(recvurb->urb);
|
recvurb++;
|
}
|
#endif
|
}
|
