Skip to content

L
linux
Commit 89125618 authored by Ajay Singh's avatar Ajay Singh Committed by Greg Kroah-Hartman
Browse files
Options

staging: wilc1000: remove unnecessary while(0) in wilc_wlan_handle_txq() 

Refactor wilc_wlan_handle_txq() by removing unnecessary while(0)
loop. "Line over 80 char" issues in wilc_wlan_handle_txq() are fix by
reducing extra leading tab.
Signed-off-by: default avatarAjay Singh <ajay.kathat@microchip.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent c8d4e2e1
Hide whitespace changes
Inline Side-by-side
Showing with 141 additions and 154 deletions
drivers/staging/wilc1000/wilc_wlan.c
View file @ 89125618
...@@ -583,200 +583,187 @@ int wilc_wlan_handle_txq(struct net_device *dev, u32 *txq_count) ...@@ -583,200 +583,187 @@ int wilc_wlan_handle_txq(struct net_device *dev, u32 *txq_count)
txb = wilc->tx_buffer; txb = wilc->tx_buffer;
wilc->txq_exit = 0; wilc->txq_exit = 0;
if (wilc->quit)
goto out;
mutex_lock(&wilc->txq_add_to_head_cs);
wilc_wlan_txq_filter_dup_tcp_ack(dev);
tqe = wilc_wlan_txq_get_first(wilc);
i = 0;
sum = 0;
do { do {
if (wilc->quit) if (tqe && (i < (WILC_VMM_TBL_SIZE - 1))) {
break; if (tqe->type == WILC_CFG_PKT)
vmm_sz = ETH_CONFIG_PKT_HDR_OFFSET;
mutex_lock(&wilc->txq_add_to_head_cs); else if (tqe->type == WILC_NET_PKT)
wilc_wlan_txq_filter_dup_tcp_ack(dev); vmm_sz = ETH_ETHERNET_HDR_OFFSET;
tqe = wilc_wlan_txq_get_first(wilc);
i = 0;
sum = 0;
do {
if (tqe && (i < (WILC_VMM_TBL_SIZE - 1))) {
if (tqe->type == WILC_CFG_PKT)
vmm_sz = ETH_CONFIG_PKT_HDR_OFFSET;
else if (tqe->type == WILC_NET_PKT) else
vmm_sz = ETH_ETHERNET_HDR_OFFSET; vmm_sz = HOST_HDR_OFFSET;
else vmm_sz += tqe->buffer_size;
vmm_sz = HOST_HDR_OFFSET;
vmm_sz += tqe->buffer_size; if (vmm_sz & 0x3)
vmm_sz = (vmm_sz + 4) & ~0x3;
if (vmm_sz & 0x3) if ((sum + vmm_sz) > LINUX_TX_SIZE)
vmm_sz = (vmm_sz + 4) & ~0x3; break;
if ((sum + vmm_sz) > LINUX_TX_SIZE) vmm_table[i] = vmm_sz / 4;
break; if (tqe->type == WILC_CFG_PKT)
vmm_table[i] |= BIT(10);
vmm_table[i] = cpu_to_le32(vmm_table[i]);
vmm_table[i] = vmm_sz / 4; i++;
if (tqe->type == WILC_CFG_PKT) sum += vmm_sz;
vmm_table[i] |= BIT(10); tqe = wilc_wlan_txq_get_next(wilc, tqe);
vmm_table[i] = cpu_to_le32(vmm_table[i]); } else {
break;
}
} while (1);
i++; if (i == 0)
sum += vmm_sz; goto out;
tqe = wilc_wlan_txq_get_next(wilc, tqe); vmm_table[i] = 0x0;
} else {
break;
}
} while (1);
if (i == 0) acquire_bus(wilc, ACQUIRE_AND_WAKEUP);
counter = 0;
func = wilc->hif_func;
do {
ret = func->hif_read_reg(wilc, WILC_HOST_TX_CTRL, &reg);
if (!ret)
break; break;
vmm_table[i] = 0x0;
acquire_bus(wilc, ACQUIRE_AND_WAKEUP); if ((reg & 0x1) == 0)
counter = 0; break;
func = wilc->hif_func;
do {
ret = func->hif_read_reg(wilc, WILC_HOST_TX_CTRL, &reg);
if (!ret)
break;
if ((reg & 0x1) == 0) counter++;
break; if (counter > 200) {
counter = 0;
ret = func->hif_write_reg(wilc, WILC_HOST_TX_CTRL, 0);
break;
}
} while (!wilc->quit);
counter++; if (!ret)
if (counter > 200) { goto _end_;
counter = 0;
ret = func->hif_write_reg(wilc,
WILC_HOST_TX_CTRL, 0);
break;
}
} while (!wilc->quit);
timeout = 200;
do {
ret = func->hif_block_tx(wilc,
WILC_VMM_TBL_RX_SHADOW_BASE,
(u8 *)vmm_table,
((i + 1) * 4));
if (!ret) if (!ret)
goto _end_; break;
timeout = 200; ret = func->hif_write_reg(wilc, WILC_HOST_VMM_CTL, 0x2);
do { if (!ret)
ret = func->hif_block_tx(wilc, break;
WILC_VMM_TBL_RX_SHADOW_BASE,
(u8 *)vmm_table,
((i + 1) * 4));
if (!ret)
break;
ret = func->hif_write_reg(wilc, WILC_HOST_VMM_CTL, 0x2); do {
ret = func->hif_read_reg(wilc, WILC_HOST_VMM_CTL, &reg);
if (!ret) if (!ret)
break; break;
if ((reg >> 2) & 0x1) {
do { entries = ((reg >> 3) & 0x3f);
ret = func->hif_read_reg(wilc,
WILC_HOST_VMM_CTL,
&reg);
if (!ret)
break;
if ((reg >> 2) & 0x1) {
entries = ((reg >> 3) & 0x3f);
break;
}
release_bus(wilc, RELEASE_ALLOW_SLEEP);
} while (--timeout);
if (timeout <= 0) {
ret = func->hif_write_reg(wilc,
WILC_HOST_VMM_CTL,
0x0);
break; break;
} }
release_bus(wilc, RELEASE_ALLOW_SLEEP);
} while (--timeout);
if (timeout <= 0) {
ret = func->hif_write_reg(wilc, WILC_HOST_VMM_CTL, 0x0);
break;
}
if (!ret)
break;
if (entries == 0) {
ret = func->hif_read_reg(wilc, WILC_HOST_TX_CTRL, &reg);
if (!ret) if (!ret)
break; break;
reg &= ~BIT(0);
if (entries == 0) { ret = func->hif_write_reg(wilc, WILC_HOST_TX_CTRL, reg);
ret = func->hif_read_reg(wilc, if (!ret)
WILC_HOST_TX_CTRL,
&reg);
if (!ret)
break;
reg &= ~BIT(0);
ret = func->hif_write_reg(wilc,
WILC_HOST_TX_CTRL,
reg);
if (!ret)
break;
break; break;
}
break; break;
} while (1); }
break;
} while (1);
if (!ret) if (!ret)
goto _end_; goto _end_;
if (entries == 0) { if (entries == 0) {
ret = WILC_TX_ERR_NO_BUF; ret = WILC_TX_ERR_NO_BUF;
goto _end_; goto _end_;
} }
release_bus(wilc, RELEASE_ALLOW_SLEEP); release_bus(wilc, RELEASE_ALLOW_SLEEP);
offset = 0; offset = 0;
i = 0; i = 0;
do { do {
tqe = wilc_wlan_txq_remove_from_head(dev); tqe = wilc_wlan_txq_remove_from_head(dev);
if (tqe && vmm_table[i] != 0) { if (tqe && vmm_table[i] != 0) {
u32 header, buffer_offset; u32 header, buffer_offset;
vmm_table[i] = cpu_to_le32(vmm_table[i]); vmm_table[i] = cpu_to_le32(vmm_table[i]);
vmm_sz = (vmm_table[i] & 0x3ff); vmm_sz = (vmm_table[i] & 0x3ff);
vmm_sz *= 4; vmm_sz *= 4;
header = (tqe->type << 31) | header = (tqe->type << 31) |
(tqe->buffer_size << 15) | (tqe->buffer_size << 15) |
vmm_sz; vmm_sz;
if (tqe->type == WILC_MGMT_PKT) if (tqe->type == WILC_MGMT_PKT)
header |= BIT(30); header |= BIT(30);
else else
header &= ~BIT(30); header &= ~BIT(30);
header = cpu_to_le32(header);
memcpy(&txb[offset], &header, 4);
if (tqe->type == WILC_CFG_PKT) {
buffer_offset = ETH_CONFIG_PKT_HDR_OFFSET;
} else if (tqe->type == WILC_NET_PKT) {
char *bssid = ((struct tx_complete_data *)(tqe->priv))->bssid;
buffer_offset = ETH_ETHERNET_HDR_OFFSET;
memcpy(&txb[offset + 8], bssid, 6);
} else {
buffer_offset = HOST_HDR_OFFSET;
}
memcpy(&txb[offset + buffer_offset], header = cpu_to_le32(header);
tqe->buffer, tqe->buffer_size); memcpy(&txb[offset], &header, 4);
offset += vmm_sz; if (tqe->type == WILC_CFG_PKT) {
i++; buffer_offset = ETH_CONFIG_PKT_HDR_OFFSET;
tqe->status = 1; } else if (tqe->type == WILC_NET_PKT) {
if (tqe->tx_complete_func) char *bssid = ((struct tx_complete_data *)(tqe->priv))->bssid;
tqe->tx_complete_func(tqe->priv,
tqe->status); buffer_offset = ETH_ETHERNET_HDR_OFFSET;
if (tqe->tcp_pending_ack_idx != NOT_TCP_ACK && memcpy(&txb[offset + 8], bssid, 6);
tqe->tcp_pending_ack_idx < MAX_PENDING_ACKS)
pending_acks_info[tqe->tcp_pending_ack_idx].txqe = NULL;
kfree(tqe);
} else { } else {
break; buffer_offset = HOST_HDR_OFFSET;
} }
} while (--entries);
acquire_bus(wilc, ACQUIRE_AND_WAKEUP); memcpy(&txb[offset + buffer_offset],
tqe->buffer, tqe->buffer_size);
offset += vmm_sz;
i++;
tqe->status = 1;
if (tqe->tx_complete_func)
tqe->tx_complete_func(tqe->priv,
tqe->status);
if (tqe->tcp_pending_ack_idx != NOT_TCP_ACK &&
tqe->tcp_pending_ack_idx < MAX_PENDING_ACKS)
pending_acks_info[tqe->tcp_pending_ack_idx].txqe = NULL;
kfree(tqe);
} else {
break;
}
} while (--entries);
ret = func->hif_clear_int_ext(wilc, ENABLE_TX_VMM); acquire_bus(wilc, ACQUIRE_AND_WAKEUP);
if (!ret)
goto _end_;
ret = func->hif_block_tx_ext(wilc, 0, txb, offset); ret = func->hif_clear_int_ext(wilc, ENABLE_TX_VMM);
if (!ret) if (!ret)
goto _end_; goto _end_;
ret = func->hif_block_tx_ext(wilc, 0, txb, offset);
_end_: _end_:
release_bus(wilc, RELEASE_ALLOW_SLEEP);
release_bus(wilc, RELEASE_ALLOW_SLEEP); out:
if (ret != 1)
break;
} while (0);
mutex_unlock(&wilc->txq_add_to_head_cs); mutex_unlock(&wilc->txq_add_to_head_cs);
wilc->txq_exit = 1; wilc->txq_exit = 1;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7