| // SPDX-License-Identifier: GPL-2.0+ | |
| /* | |
| * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc. | |
| * All rights reserved. | |
| * | |
| * Purpose: Handle USB control endpoint | |
| * | |
| * Author: Warren Hsu | |
| * | |
| * Date: Mar. 29, 2005 | |
| * | |
| * Functions: | |
| * vnt_control_out - Write variable length bytes to MEM/BB/MAC/EEPROM | |
| * vnt_control_in - Read variable length bytes from MEM/BB/MAC/EEPROM | |
| * vnt_control_out_u8 - Write one byte to MEM/BB/MAC/EEPROM | |
| * vnt_control_in_u8 - Read one byte from MEM/BB/MAC/EEPROM | |
| * | |
| * Revision History: | |
| * 04-05-2004 Jerry Chen: Initial release | |
| * 11-24-2004 Warren Hsu: Add ControlvWriteByte,ControlvReadByte, | |
| * ControlvMaskByte | |
| * | |
| */ | |
| #include "rxtx.h" | |
| #include "desc.h" | |
| #include "device.h" | |
| #include "usbpipe.h" | |
| #include "mac.h" | |
| #include "rf.h" | |
| #define USB_CTL_WAIT 500 /* ms */ | |
| int vnt_control_out(struct vnt_private *priv, u8 request, u16 value, | |
| u16 index, u16 length, const u8 *buffer) | |
| { | |
| int ret = 0; | |
| u8 *usb_buffer; | |
| if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) { | |
| ret = -EINVAL; | |
| goto end; | |
| } | |
| mutex_lock(&priv->usb_lock); | |
| usb_buffer = kmemdup(buffer, length, GFP_KERNEL); | |
| if (!usb_buffer) { | |
| ret = -ENOMEM; | |
| goto end_unlock; | |
| } | |
| ret = usb_control_msg(priv->usb, | |
| usb_sndctrlpipe(priv->usb, 0), | |
| request, 0x40, value, | |
| index, usb_buffer, length, USB_CTL_WAIT); | |
| kfree(usb_buffer); | |
| if (ret == (int)length) | |
| ret = 0; | |
| else | |
| ret = -EIO; | |
| end_unlock: | |
| mutex_unlock(&priv->usb_lock); | |
| end: | |
| return ret; | |
| } | |
| int vnt_control_out_u8(struct vnt_private *priv, u8 reg, u8 reg_off, u8 data) | |
| { | |
| return vnt_control_out(priv, MESSAGE_TYPE_WRITE, | |
| reg_off, reg, sizeof(u8), &data); | |
| } | |
| int vnt_control_out_blocks(struct vnt_private *priv, | |
| u16 block, u8 reg, u16 length, const u8 *data) | |
| { | |
| int ret = 0, i; | |
| for (i = 0; i < length; i += block) { | |
| u16 len = min_t(int, length - i, block); | |
| ret = vnt_control_out(priv, MESSAGE_TYPE_WRITE, | |
| i, reg, len, data + i); | |
| if (ret) | |
| goto end; | |
| } | |
| end: | |
| return ret; | |
| } | |
| int vnt_control_in(struct vnt_private *priv, u8 request, u16 value, | |
| u16 index, u16 length, u8 *buffer) | |
| { | |
| int ret = 0; | |
| u8 *usb_buffer; | |
| if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) { | |
| ret = -EINVAL; | |
| goto end; | |
| } | |
| mutex_lock(&priv->usb_lock); | |
| usb_buffer = kmalloc(length, GFP_KERNEL); | |
| if (!usb_buffer) { | |
| ret = -ENOMEM; | |
| goto end_unlock; | |
| } | |
| ret = usb_control_msg(priv->usb, | |
| usb_rcvctrlpipe(priv->usb, 0), | |
| request, 0xc0, value, | |
| index, usb_buffer, length, USB_CTL_WAIT); | |
| if (ret == length) | |
| memcpy(buffer, usb_buffer, length); | |
| kfree(usb_buffer); | |
| if (ret == (int)length) | |
| ret = 0; | |
| else | |
| ret = -EIO; | |
| end_unlock: | |
| mutex_unlock(&priv->usb_lock); | |
| end: | |
| return ret; | |
| } | |
| int vnt_control_in_u8(struct vnt_private *priv, u8 reg, u8 reg_off, u8 *data) | |
| { | |
| return vnt_control_in(priv, MESSAGE_TYPE_READ, | |
| reg_off, reg, sizeof(u8), data); | |
| } | |
| static int vnt_int_report_rate(struct vnt_private *priv, u8 pkt_no, u8 tsr) | |
| { | |
| struct vnt_usb_send_context *context; | |
| struct ieee80211_tx_info *info; | |
| u8 tx_retry = (tsr & 0xf0) >> 4; | |
| s8 idx; | |
| if (pkt_no >= priv->num_tx_context) | |
| return -EINVAL; | |
| context = priv->tx_context[pkt_no]; | |
| if (!context->skb) | |
| return -EINVAL; | |
| info = IEEE80211_SKB_CB(context->skb); | |
| idx = info->control.rates[0].idx; | |
| ieee80211_tx_info_clear_status(info); | |
| info->status.rates[0].count = tx_retry; | |
| if (!(tsr & TSR_TMO)) { | |
| info->status.rates[0].idx = idx; | |
| if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) | |
| info->flags |= IEEE80211_TX_STAT_ACK; | |
| } | |
| ieee80211_tx_status_irqsafe(priv->hw, context->skb); | |
| context->in_use = false; | |
| return 0; | |
| } | |
| static void vnt_int_process_data(struct vnt_private *priv) | |
| { | |
| struct vnt_interrupt_data *int_data; | |
| struct ieee80211_low_level_stats *low_stats = &priv->low_stats; | |
| dev_dbg(&priv->usb->dev, "---->s_nsInterruptProcessData\n"); | |
| int_data = (struct vnt_interrupt_data *)priv->int_buf.data_buf; | |
| if (int_data->tsr0 & TSR_VALID) | |
| vnt_int_report_rate(priv, int_data->pkt0, int_data->tsr0); | |
| if (int_data->tsr1 & TSR_VALID) | |
| vnt_int_report_rate(priv, int_data->pkt1, int_data->tsr1); | |
| if (int_data->tsr2 & TSR_VALID) | |
| vnt_int_report_rate(priv, int_data->pkt2, int_data->tsr2); | |
| if (int_data->tsr3 & TSR_VALID) | |
| vnt_int_report_rate(priv, int_data->pkt3, int_data->tsr3); | |
| if (!int_data->isr0) | |
| return; | |
| if (int_data->isr0 & ISR_BNTX && priv->op_mode == NL80211_IFTYPE_AP) | |
| vnt_schedule_command(priv, WLAN_CMD_BECON_SEND); | |
| priv->current_tsf = le64_to_cpu(int_data->tsf); | |
| low_stats->dot11RTSSuccessCount += int_data->rts_success; | |
| low_stats->dot11RTSFailureCount += int_data->rts_fail; | |
| low_stats->dot11ACKFailureCount += int_data->ack_fail; | |
| low_stats->dot11FCSErrorCount += int_data->fcs_err; | |
| } | |
| static void vnt_start_interrupt_urb_complete(struct urb *urb) | |
| { | |
| struct vnt_private *priv = urb->context; | |
| int status = urb->status; | |
| switch (status) { | |
| case 0: | |
| case -ETIMEDOUT: | |
| break; | |
| case -ECONNRESET: | |
| case -ENOENT: | |
| case -ESHUTDOWN: | |
| return; | |
| default: | |
| break; | |
| } | |
| if (status) | |
| dev_dbg(&priv->usb->dev, "%s status = %d\n", __func__, status); | |
| else | |
| vnt_int_process_data(priv); | |
| if (!test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) | |
| status = usb_submit_urb(priv->interrupt_urb, GFP_ATOMIC); | |
| if (status) | |
| dev_dbg(&priv->usb->dev, "Submit int URB failed %d\n", status); | |
| } | |
| int vnt_start_interrupt_urb(struct vnt_private *priv) | |
| { | |
| int ret = 0; | |
| dev_dbg(&priv->usb->dev, "---->Interrupt Polling Thread\n"); | |
| usb_fill_int_urb(priv->interrupt_urb, | |
| priv->usb, | |
| usb_rcvintpipe(priv->usb, 1), | |
| priv->int_buf.data_buf, | |
| MAX_INTERRUPT_SIZE, | |
| vnt_start_interrupt_urb_complete, | |
| priv, | |
| priv->int_interval); | |
| ret = usb_submit_urb(priv->interrupt_urb, GFP_ATOMIC); | |
| if (ret) | |
| dev_dbg(&priv->usb->dev, "Submit int URB failed %d\n", ret); | |
| return ret; | |
| } | |
| static int vnt_rx_data(struct vnt_private *priv, struct vnt_rcb *ptr_rcb, | |
| unsigned long bytes_received) | |
| { | |
| struct ieee80211_hw *hw = priv->hw; | |
| struct ieee80211_supported_band *sband; | |
| struct sk_buff *skb; | |
| struct ieee80211_rx_status *rx_status; | |
| struct vnt_rx_header *head; | |
| struct vnt_rx_tail *tail; | |
| u32 frame_size; | |
| int ii; | |
| u16 rx_bitrate, pay_load_with_padding; | |
| u8 rate_idx = 0; | |
| long rx_dbm; | |
| skb = ptr_rcb->skb; | |
| rx_status = IEEE80211_SKB_RXCB(skb); | |
| /* [31:16]RcvByteCount ( not include 4-byte Status ) */ | |
| head = (struct vnt_rx_header *)skb->data; | |
| frame_size = head->wbk_status >> 16; | |
| frame_size += 4; | |
| if (bytes_received != frame_size) { | |
| dev_dbg(&priv->usb->dev, "------- WRONG Length 1\n"); | |
| return false; | |
| } | |
| if ((bytes_received > 2372) || (bytes_received <= 40)) { | |
| /* Frame Size error drop this packet.*/ | |
| dev_dbg(&priv->usb->dev, "------ WRONG Length 2\n"); | |
| return false; | |
| } | |
| /* real Frame Size = USBframe_size -4WbkStatus - 4RxStatus */ | |
| /* -8TSF - 4RSR - 4SQ3 - ?Padding */ | |
| /* if SQ3 the range is 24~27, if no SQ3 the range is 20~23 */ | |
| /*Fix hardware bug => PLCP_Length error */ | |
| if (((bytes_received - head->pay_load_len) > 27) || | |
| ((bytes_received - head->pay_load_len) < 24) || | |
| (bytes_received < head->pay_load_len)) { | |
| dev_dbg(&priv->usb->dev, "Wrong PLCP Length %x\n", | |
| head->pay_load_len); | |
| return false; | |
| } | |
| sband = hw->wiphy->bands[hw->conf.chandef.chan->band]; | |
| rx_bitrate = head->rx_rate * 5; /* rx_rate * 5 */ | |
| for (ii = 0; ii < sband->n_bitrates; ii++) { | |
| if (sband->bitrates[ii].bitrate == rx_bitrate) { | |
| rate_idx = ii; | |
| break; | |
| } | |
| } | |
| if (ii == sband->n_bitrates) { | |
| dev_dbg(&priv->usb->dev, "Wrong Rx Bit Rate %d\n", rx_bitrate); | |
| return false; | |
| } | |
| pay_load_with_padding = ((head->pay_load_len / 4) + | |
| ((head->pay_load_len % 4) ? 1 : 0)) * 4; | |
| tail = (struct vnt_rx_tail *)(skb->data + | |
| sizeof(*head) + pay_load_with_padding); | |
| priv->tsf_time = le64_to_cpu(tail->tsf_time); | |
| if (tail->rsr & (RSR_IVLDTYP | RSR_IVLDLEN)) | |
| return false; | |
| vnt_rf_rssi_to_dbm(priv, tail->rssi, &rx_dbm); | |
| priv->bb_pre_ed_rssi = (u8)-rx_dbm + 1; | |
| priv->current_rssi = priv->bb_pre_ed_rssi; | |
| skb_pull(skb, sizeof(*head)); | |
| skb_trim(skb, head->pay_load_len); | |
| rx_status->mactime = priv->tsf_time; | |
| rx_status->band = hw->conf.chandef.chan->band; | |
| rx_status->signal = rx_dbm; | |
| rx_status->flag = 0; | |
| rx_status->freq = hw->conf.chandef.chan->center_freq; | |
| if (!(tail->rsr & RSR_CRCOK)) | |
| rx_status->flag |= RX_FLAG_FAILED_FCS_CRC; | |
| rx_status->rate_idx = rate_idx; | |
| if (tail->new_rsr & NEWRSR_DECRYPTOK) | |
| rx_status->flag |= RX_FLAG_DECRYPTED; | |
| ieee80211_rx_irqsafe(priv->hw, skb); | |
| return true; | |
| } | |
| static void vnt_submit_rx_urb_complete(struct urb *urb) | |
| { | |
| struct vnt_rcb *rcb = urb->context; | |
| struct vnt_private *priv = rcb->priv; | |
| switch (urb->status) { | |
| case 0: | |
| break; | |
| case -ECONNRESET: | |
| case -ENOENT: | |
| case -ESHUTDOWN: | |
| return; | |
| case -ETIMEDOUT: | |
| default: | |
| dev_dbg(&priv->usb->dev, "BULK In failed %d\n", urb->status); | |
| break; | |
| } | |
| if (urb->actual_length) { | |
| if (vnt_rx_data(priv, rcb, urb->actual_length)) { | |
| rcb->skb = dev_alloc_skb(priv->rx_buf_sz); | |
| if (!rcb->skb) | |
| return; | |
| } else { | |
| skb_push(rcb->skb, skb_headroom(rcb->skb)); | |
| skb_trim(rcb->skb, 0); | |
| } | |
| urb->transfer_buffer = skb_put(rcb->skb, | |
| skb_tailroom(rcb->skb)); | |
| } | |
| if (usb_submit_urb(urb, GFP_ATOMIC)) | |
| dev_dbg(&priv->usb->dev, "Failed to re submit rx skb\n"); | |
| } | |
| int vnt_submit_rx_urb(struct vnt_private *priv, struct vnt_rcb *rcb) | |
| { | |
| int ret = 0; | |
| struct urb *urb = rcb->urb; | |
| if (!rcb->skb) { | |
| dev_dbg(&priv->usb->dev, "rcb->skb is null\n"); | |
| ret = -EINVAL; | |
| goto end; | |
| } | |
| usb_fill_bulk_urb(urb, | |
| priv->usb, | |
| usb_rcvbulkpipe(priv->usb, 2), | |
| skb_put(rcb->skb, skb_tailroom(rcb->skb)), | |
| MAX_TOTAL_SIZE_WITH_ALL_HEADERS, | |
| vnt_submit_rx_urb_complete, | |
| rcb); | |
| ret = usb_submit_urb(urb, GFP_ATOMIC); | |
| if (ret) | |
| dev_dbg(&priv->usb->dev, "Submit Rx URB failed %d\n", ret); | |
| end: | |
| return ret; | |
| } | |
| static void vnt_tx_context_complete(struct urb *urb) | |
| { | |
| struct vnt_usb_send_context *context = urb->context; | |
| struct vnt_private *priv = context->priv; | |
| switch (urb->status) { | |
| case 0: | |
| dev_dbg(&priv->usb->dev, | |
| "Write %d bytes\n", urb->actual_length); | |
| break; | |
| case -ECONNRESET: | |
| case -ENOENT: | |
| case -ESHUTDOWN: | |
| context->in_use = false; | |
| return; | |
| case -ETIMEDOUT: | |
| default: | |
| dev_dbg(&priv->usb->dev, "BULK Out failed %d\n", urb->status); | |
| break; | |
| } | |
| if (context->type == CONTEXT_DATA_PACKET) | |
| ieee80211_wake_queues(priv->hw); | |
| if (urb->status || context->type == CONTEXT_BEACON_PACKET) { | |
| if (context->skb) | |
| ieee80211_free_txskb(priv->hw, context->skb); | |
| context->in_use = false; | |
| } | |
| } | |
| int vnt_tx_context(struct vnt_private *priv, | |
| struct vnt_usb_send_context *context, | |
| struct sk_buff *skb) | |
| { | |
| struct vnt_tx_usb_header *usb; | |
| struct urb *urb; | |
| int status; | |
| u16 count = skb->len; | |
| usb = skb_push(skb, sizeof(*usb)); | |
| usb->tx_byte_count = cpu_to_le16(count); | |
| usb->pkt_no = context->pkt_no; | |
| usb->type = context->type; | |
| if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) { | |
| context->in_use = false; | |
| return -ENODEV; | |
| } | |
| if (skb->len > MAX_TOTAL_SIZE_WITH_ALL_HEADERS) { | |
| context->in_use = false; | |
| return -E2BIG; | |
| } | |
| urb = usb_alloc_urb(0, GFP_ATOMIC); | |
| if (!urb) { | |
| context->in_use = false; | |
| return -ENOMEM; | |
| } | |
| usb_fill_bulk_urb(urb, | |
| priv->usb, | |
| usb_sndbulkpipe(priv->usb, 3), | |
| skb->data, | |
| skb->len, | |
| vnt_tx_context_complete, | |
| context); | |
| usb_anchor_urb(urb, &priv->tx_submitted); | |
| status = usb_submit_urb(urb, GFP_ATOMIC); | |
| if (status) { | |
| dev_dbg(&priv->usb->dev, "Submit Tx URB failed %d\n", status); | |
| usb_unanchor_urb(urb); | |
| context->in_use = false; | |
| } | |
| usb_free_urb(urb); | |
| return status; | |
| } |