]>
Commit | Line | Data |
---|---|---|
6b4c6ce8 | 1 | // SPDX-License-Identifier: GPL-2.0+ |
92b96797 FB |
2 | /* |
3 | * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc. | |
4 | * All rights reserved. | |
5 | * | |
92b96797 FB |
6 | * File: usbpipe.c |
7 | * | |
8 | * Purpose: Handle USB control endpoint | |
9 | * | |
10 | * Author: Warren Hsu | |
11 | * | |
12 | * Date: Mar. 29, 2005 | |
13 | * | |
14 | * Functions: | |
1390b02a | 15 | * vnt_control_out - Write variable length bytes to MEM/BB/MAC/EEPROM |
441c21c3 | 16 | * vnt_control_in - Read variable length bytes from MEM/BB/MAC/EEPROM |
285d58c4 | 17 | * vnt_control_out_u8 - Write one byte to MEM/BB/MAC/EEPROM |
53742906 | 18 | * vnt_control_in_u8 - Read one byte from MEM/BB/MAC/EEPROM |
92b96797 FB |
19 | * |
20 | * Revision History: | |
3b1d7533 AJ |
21 | * 04-05-2004 Jerry Chen: Initial release |
22 | * 11-24-2004 Warren Hsu: Add ControlvWriteByte,ControlvReadByte, | |
23 | * ControlvMaskByte | |
92b96797 FB |
24 | * |
25 | */ | |
26 | ||
92b96797 | 27 | #include "rxtx.h" |
92b96797 | 28 | #include "desc.h" |
92b96797 | 29 | #include "device.h" |
62c8526d | 30 | #include "usbpipe.h" |
10e9a359 | 31 | #include "mac.h" |
3c505f50 | 32 | #include "rf.h" |
92b96797 | 33 | |
b2435179 | 34 | #define USB_CTL_WAIT 500 /* ms */ |
92b96797 | 35 | |
1390b02a | 36 | int vnt_control_out(struct vnt_private *priv, u8 request, u16 value, |
747a64bd | 37 | u16 index, u16 length, const u8 *buffer) |
92b96797 | 38 | { |
59608cb1 | 39 | int ret = 0; |
12ecd24e | 40 | u8 *usb_buffer; |
92b96797 | 41 | |
59608cb1 QD |
42 | if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) { |
43 | ret = -EINVAL; | |
44 | goto end; | |
45 | } | |
e1feda13 | 46 | |
0f06a739 | 47 | mutex_lock(&priv->usb_lock); |
c91b1869 | 48 | |
12ecd24e MP |
49 | usb_buffer = kmemdup(buffer, length, GFP_KERNEL); |
50 | if (!usb_buffer) { | |
59608cb1 QD |
51 | ret = -ENOMEM; |
52 | goto end_unlock; | |
12ecd24e MP |
53 | } |
54 | ||
59608cb1 QD |
55 | ret = usb_control_msg(priv->usb, |
56 | usb_sndctrlpipe(priv->usb, 0), | |
57 | request, 0x40, value, | |
58 | index, usb_buffer, length, USB_CTL_WAIT); | |
12ecd24e MP |
59 | |
60 | kfree(usb_buffer); | |
ae5943de | 61 | |
58c3e681 MP |
62 | if (ret == (int)length) |
63 | ret = 0; | |
64 | else | |
59608cb1 | 65 | ret = -EIO; |
ae5943de | 66 | |
59608cb1 QD |
67 | end_unlock: |
68 | mutex_unlock(&priv->usb_lock); | |
69 | end: | |
70 | return ret; | |
92b96797 FB |
71 | } |
72 | ||
59608cb1 | 73 | int vnt_control_out_u8(struct vnt_private *priv, u8 reg, u8 reg_off, u8 data) |
285d58c4 | 74 | { |
59608cb1 QD |
75 | return vnt_control_out(priv, MESSAGE_TYPE_WRITE, |
76 | reg_off, reg, sizeof(u8), &data); | |
285d58c4 MP |
77 | } |
78 | ||
69cc1f92 MP |
79 | int vnt_control_out_blocks(struct vnt_private *priv, |
80 | u16 block, u8 reg, u16 length, u8 *data) | |
81 | { | |
82 | int ret = 0, i; | |
83 | ||
84 | for (i = 0; i < length; i += block) { | |
85 | u16 len = min_t(int, length - i, block); | |
86 | ||
87 | ret = vnt_control_out(priv, MESSAGE_TYPE_WRITE, | |
88 | i, reg, len, data + i); | |
89 | if (ret) | |
90 | goto end; | |
91 | } | |
92 | end: | |
93 | return ret; | |
94 | } | |
95 | ||
441c21c3 | 96 | int vnt_control_in(struct vnt_private *priv, u8 request, u16 value, |
3781f887 | 97 | u16 index, u16 length, u8 *buffer) |
92b96797 | 98 | { |
59608cb1 | 99 | int ret = 0; |
05c0cf88 | 100 | u8 *usb_buffer; |
731047f9 | 101 | |
59608cb1 QD |
102 | if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) { |
103 | ret = -EINVAL; | |
104 | goto end; | |
105 | } | |
ae5943de | 106 | |
9af49fdb | 107 | mutex_lock(&priv->usb_lock); |
c91b1869 | 108 | |
05c0cf88 MP |
109 | usb_buffer = kmalloc(length, GFP_KERNEL); |
110 | if (!usb_buffer) { | |
59608cb1 QD |
111 | ret = -ENOMEM; |
112 | goto end_unlock; | |
05c0cf88 MP |
113 | } |
114 | ||
59608cb1 QD |
115 | ret = usb_control_msg(priv->usb, |
116 | usb_rcvctrlpipe(priv->usb, 0), | |
117 | request, 0xc0, value, | |
118 | index, usb_buffer, length, USB_CTL_WAIT); | |
05c0cf88 | 119 | |
59608cb1 | 120 | if (ret == length) |
05c0cf88 MP |
121 | memcpy(buffer, usb_buffer, length); |
122 | ||
123 | kfree(usb_buffer); | |
92b96797 | 124 | |
58c3e681 MP |
125 | if (ret == (int)length) |
126 | ret = 0; | |
127 | else | |
59608cb1 | 128 | ret = -EIO; |
fe5d00eb | 129 | |
59608cb1 QD |
130 | end_unlock: |
131 | mutex_unlock(&priv->usb_lock); | |
132 | end: | |
133 | return ret; | |
92b96797 FB |
134 | } |
135 | ||
59608cb1 | 136 | int vnt_control_in_u8(struct vnt_private *priv, u8 reg, u8 reg_off, u8 *data) |
53742906 | 137 | { |
59608cb1 QD |
138 | return vnt_control_in(priv, MESSAGE_TYPE_READ, |
139 | reg_off, reg, sizeof(u8), data); | |
53742906 MP |
140 | } |
141 | ||
10e9a359 MP |
142 | static int vnt_int_report_rate(struct vnt_private *priv, u8 pkt_no, u8 tsr) |
143 | { | |
144 | struct vnt_usb_send_context *context; | |
145 | struct ieee80211_tx_info *info; | |
146 | u8 tx_retry = (tsr & 0xf0) >> 4; | |
147 | s8 idx; | |
148 | ||
149 | if (pkt_no >= priv->num_tx_context) | |
150 | return -EINVAL; | |
151 | ||
152 | context = priv->tx_context[pkt_no]; | |
153 | ||
154 | if (!context->skb) | |
155 | return -EINVAL; | |
156 | ||
157 | info = IEEE80211_SKB_CB(context->skb); | |
158 | idx = info->control.rates[0].idx; | |
159 | ||
160 | ieee80211_tx_info_clear_status(info); | |
161 | ||
162 | info->status.rates[0].count = tx_retry; | |
163 | ||
164 | if (!(tsr & TSR_TMO)) { | |
165 | info->status.rates[0].idx = idx; | |
166 | ||
167 | if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) | |
168 | info->flags |= IEEE80211_TX_STAT_ACK; | |
169 | } | |
170 | ||
171 | ieee80211_tx_status_irqsafe(priv->hw, context->skb); | |
172 | ||
173 | context->in_use = false; | |
174 | ||
175 | return 0; | |
176 | } | |
177 | ||
178 | static void vnt_int_process_data(struct vnt_private *priv) | |
179 | { | |
180 | struct vnt_interrupt_data *int_data; | |
181 | struct ieee80211_low_level_stats *low_stats = &priv->low_stats; | |
182 | ||
183 | dev_dbg(&priv->usb->dev, "---->s_nsInterruptProcessData\n"); | |
184 | ||
185 | int_data = (struct vnt_interrupt_data *)priv->int_buf.data_buf; | |
186 | ||
187 | if (int_data->tsr0 & TSR_VALID) | |
188 | vnt_int_report_rate(priv, int_data->pkt0, int_data->tsr0); | |
189 | ||
190 | if (int_data->tsr1 & TSR_VALID) | |
191 | vnt_int_report_rate(priv, int_data->pkt1, int_data->tsr1); | |
192 | ||
193 | if (int_data->tsr2 & TSR_VALID) | |
194 | vnt_int_report_rate(priv, int_data->pkt2, int_data->tsr2); | |
195 | ||
196 | if (int_data->tsr3 & TSR_VALID) | |
197 | vnt_int_report_rate(priv, int_data->pkt3, int_data->tsr3); | |
198 | ||
199 | if (int_data->isr0 != 0) { | |
200 | if (int_data->isr0 & ISR_BNTX && | |
201 | priv->op_mode == NL80211_IFTYPE_AP) | |
202 | vnt_schedule_command(priv, WLAN_CMD_BECON_SEND); | |
203 | ||
204 | if (int_data->isr0 & ISR_TBTT && | |
205 | priv->hw->conf.flags & IEEE80211_CONF_PS) { | |
206 | if (!priv->wake_up_count) | |
207 | priv->wake_up_count = | |
208 | priv->hw->conf.listen_interval; | |
209 | ||
ea81c348 MP |
210 | if (priv->wake_up_count) |
211 | --priv->wake_up_count; | |
10e9a359 MP |
212 | |
213 | /* Turn on wake up to listen next beacon */ | |
214 | if (priv->wake_up_count == 1) | |
215 | vnt_schedule_command(priv, | |
216 | WLAN_CMD_TBTT_WAKEUP); | |
217 | } | |
218 | priv->current_tsf = le64_to_cpu(int_data->tsf); | |
219 | ||
220 | low_stats->dot11RTSSuccessCount += int_data->rts_success; | |
221 | low_stats->dot11RTSFailureCount += int_data->rts_fail; | |
222 | low_stats->dot11ACKFailureCount += int_data->ack_fail; | |
223 | low_stats->dot11FCSErrorCount += int_data->fcs_err; | |
224 | } | |
10e9a359 MP |
225 | } |
226 | ||
34f98e3f | 227 | static void vnt_start_interrupt_urb_complete(struct urb *urb) |
92b96797 | 228 | { |
599e4b5c | 229 | struct vnt_private *priv = urb->context; |
b9183fdd | 230 | int status = urb->status; |
92b96797 | 231 | |
b9183fdd | 232 | switch (status) { |
c98fbf90 MP |
233 | case 0: |
234 | case -ETIMEDOUT: | |
235 | break; | |
236 | case -ECONNRESET: | |
237 | case -ENOENT: | |
238 | case -ESHUTDOWN: | |
c98fbf90 MP |
239 | return; |
240 | default: | |
241 | break; | |
242 | } | |
243 | ||
d1ec1242 | 244 | if (status) |
8a660261 | 245 | dev_dbg(&priv->usb->dev, "%s status = %d\n", __func__, status); |
d1ec1242 | 246 | else |
e360d2b8 | 247 | vnt_int_process_data(priv); |
92b96797 | 248 | |
3d582487 | 249 | status = usb_submit_urb(priv->interrupt_urb, GFP_ATOMIC); |
86140346 | 250 | if (status) |
8a660261 | 251 | dev_dbg(&priv->usb->dev, "Submit int URB failed %d\n", status); |
92b96797 FB |
252 | } |
253 | ||
eaa56792 MP |
254 | int vnt_start_interrupt_urb(struct vnt_private *priv) |
255 | { | |
59608cb1 | 256 | int ret = 0; |
eaa56792 | 257 | |
05f665dd MP |
258 | dev_dbg(&priv->usb->dev, "---->Interrupt Polling Thread\n"); |
259 | ||
eaa56792 MP |
260 | usb_fill_int_urb(priv->interrupt_urb, |
261 | priv->usb, | |
262 | usb_rcvintpipe(priv->usb, 1), | |
263 | priv->int_buf.data_buf, | |
264 | MAX_INTERRUPT_SIZE, | |
265 | vnt_start_interrupt_urb_complete, | |
266 | priv, | |
267 | priv->int_interval); | |
268 | ||
59608cb1 | 269 | ret = usb_submit_urb(priv->interrupt_urb, GFP_ATOMIC); |
d1ec1242 | 270 | if (ret) |
59608cb1 | 271 | dev_dbg(&priv->usb->dev, "Submit int URB failed %d\n", ret); |
59608cb1 | 272 | |
59608cb1 | 273 | return ret; |
eaa56792 MP |
274 | } |
275 | ||
3c505f50 MP |
276 | static int vnt_rx_data(struct vnt_private *priv, struct vnt_rcb *ptr_rcb, |
277 | unsigned long bytes_received) | |
278 | { | |
279 | struct ieee80211_hw *hw = priv->hw; | |
280 | struct ieee80211_supported_band *sband; | |
281 | struct sk_buff *skb; | |
282 | struct ieee80211_rx_status *rx_status; | |
283 | struct vnt_rx_header *head; | |
284 | struct vnt_rx_tail *tail; | |
285 | u32 frame_size; | |
286 | int ii; | |
287 | u16 rx_bitrate, pay_load_with_padding; | |
288 | u8 rate_idx = 0; | |
289 | long rx_dbm; | |
290 | ||
291 | skb = ptr_rcb->skb; | |
292 | rx_status = IEEE80211_SKB_RXCB(skb); | |
293 | ||
294 | /* [31:16]RcvByteCount ( not include 4-byte Status ) */ | |
295 | head = (struct vnt_rx_header *)skb->data; | |
296 | frame_size = head->wbk_status >> 16; | |
297 | frame_size += 4; | |
298 | ||
299 | if (bytes_received != frame_size) { | |
300 | dev_dbg(&priv->usb->dev, "------- WRONG Length 1\n"); | |
301 | return false; | |
302 | } | |
303 | ||
304 | if ((bytes_received > 2372) || (bytes_received <= 40)) { | |
305 | /* Frame Size error drop this packet.*/ | |
306 | dev_dbg(&priv->usb->dev, "------ WRONG Length 2\n"); | |
307 | return false; | |
308 | } | |
309 | ||
310 | /* real Frame Size = USBframe_size -4WbkStatus - 4RxStatus */ | |
311 | /* -8TSF - 4RSR - 4SQ3 - ?Padding */ | |
312 | ||
313 | /* if SQ3 the range is 24~27, if no SQ3 the range is 20~23 */ | |
314 | ||
315 | /*Fix hardware bug => PLCP_Length error */ | |
316 | if (((bytes_received - head->pay_load_len) > 27) || | |
317 | ((bytes_received - head->pay_load_len) < 24) || | |
318 | (bytes_received < head->pay_load_len)) { | |
319 | dev_dbg(&priv->usb->dev, "Wrong PLCP Length %x\n", | |
320 | head->pay_load_len); | |
321 | return false; | |
322 | } | |
323 | ||
324 | sband = hw->wiphy->bands[hw->conf.chandef.chan->band]; | |
325 | rx_bitrate = head->rx_rate * 5; /* rx_rate * 5 */ | |
326 | ||
327 | for (ii = 0; ii < sband->n_bitrates; ii++) { | |
328 | if (sband->bitrates[ii].bitrate == rx_bitrate) { | |
329 | rate_idx = ii; | |
330 | break; | |
331 | } | |
332 | } | |
333 | ||
334 | if (ii == sband->n_bitrates) { | |
335 | dev_dbg(&priv->usb->dev, "Wrong Rx Bit Rate %d\n", rx_bitrate); | |
336 | return false; | |
337 | } | |
338 | ||
339 | pay_load_with_padding = ((head->pay_load_len / 4) + | |
340 | ((head->pay_load_len % 4) ? 1 : 0)) * 4; | |
341 | ||
342 | tail = (struct vnt_rx_tail *)(skb->data + | |
343 | sizeof(*head) + pay_load_with_padding); | |
344 | priv->tsf_time = le64_to_cpu(tail->tsf_time); | |
345 | ||
346 | if (tail->rsr & (RSR_IVLDTYP | RSR_IVLDLEN)) | |
347 | return false; | |
348 | ||
349 | vnt_rf_rssi_to_dbm(priv, tail->rssi, &rx_dbm); | |
350 | ||
351 | priv->bb_pre_ed_rssi = (u8)-rx_dbm + 1; | |
352 | priv->current_rssi = priv->bb_pre_ed_rssi; | |
353 | ||
354 | skb_pull(skb, sizeof(*head)); | |
355 | skb_trim(skb, head->pay_load_len); | |
356 | ||
357 | rx_status->mactime = priv->tsf_time; | |
358 | rx_status->band = hw->conf.chandef.chan->band; | |
359 | rx_status->signal = rx_dbm; | |
360 | rx_status->flag = 0; | |
361 | rx_status->freq = hw->conf.chandef.chan->center_freq; | |
362 | ||
363 | if (!(tail->rsr & RSR_CRCOK)) | |
364 | rx_status->flag |= RX_FLAG_FAILED_FCS_CRC; | |
365 | ||
366 | rx_status->rate_idx = rate_idx; | |
367 | ||
368 | if (tail->new_rsr & NEWRSR_DECRYPTOK) | |
369 | rx_status->flag |= RX_FLAG_DECRYPTED; | |
370 | ||
371 | ieee80211_rx_irqsafe(priv->hw, skb); | |
372 | ||
373 | return true; | |
374 | } | |
375 | ||
08823af4 | 376 | static void vnt_submit_rx_urb_complete(struct urb *urb) |
92b96797 | 377 | { |
599e4b5c | 378 | struct vnt_rcb *rcb = urb->context; |
325de984 | 379 | struct vnt_private *priv = rcb->priv; |
92b96797 | 380 | |
67638980 MP |
381 | switch (urb->status) { |
382 | case 0: | |
67638980 MP |
383 | break; |
384 | case -ECONNRESET: | |
385 | case -ENOENT: | |
386 | case -ESHUTDOWN: | |
387 | return; | |
388 | case -ETIMEDOUT: | |
389 | default: | |
8a660261 | 390 | dev_dbg(&priv->usb->dev, "BULK In failed %d\n", urb->status); |
67638980 MP |
391 | break; |
392 | } | |
92b96797 | 393 | |
d4fa2ab0 | 394 | if (urb->actual_length) { |
f5283274 MP |
395 | if (vnt_rx_data(priv, rcb, urb->actual_length)) { |
396 | rcb->skb = dev_alloc_skb(priv->rx_buf_sz); | |
696089de | 397 | if (!rcb->skb) |
f5283274 | 398 | return; |
618ff9ce MP |
399 | } else { |
400 | skb_push(rcb->skb, skb_headroom(rcb->skb)); | |
401 | skb_trim(rcb->skb, 0); | |
8cffb3cf | 402 | } |
d4fa2ab0 | 403 | |
8cffb3cf | 404 | urb->transfer_buffer = skb_put(rcb->skb, |
44a22dc3 | 405 | skb_tailroom(rcb->skb)); |
8cffb3cf MP |
406 | } |
407 | ||
696089de | 408 | if (usb_submit_urb(urb, GFP_ATOMIC)) |
8cffb3cf | 409 | dev_dbg(&priv->usb->dev, "Failed to re submit rx skb\n"); |
92b96797 FB |
410 | } |
411 | ||
93eac3b1 MP |
412 | int vnt_submit_rx_urb(struct vnt_private *priv, struct vnt_rcb *rcb) |
413 | { | |
59608cb1 | 414 | int ret = 0; |
b9183fdd | 415 | struct urb *urb = rcb->urb; |
93eac3b1 | 416 | |
27f31cf9 | 417 | if (!rcb->skb) { |
93eac3b1 | 418 | dev_dbg(&priv->usb->dev, "rcb->skb is null\n"); |
59608cb1 QD |
419 | ret = -EINVAL; |
420 | goto end; | |
93eac3b1 MP |
421 | } |
422 | ||
423 | usb_fill_bulk_urb(urb, | |
424 | priv->usb, | |
425 | usb_rcvbulkpipe(priv->usb, 2), | |
426 | skb_put(rcb->skb, skb_tailroom(rcb->skb)), | |
427 | MAX_TOTAL_SIZE_WITH_ALL_HEADERS, | |
428 | vnt_submit_rx_urb_complete, | |
429 | rcb); | |
430 | ||
59608cb1 | 431 | ret = usb_submit_urb(urb, GFP_ATOMIC); |
696089de | 432 | if (ret) |
59608cb1 | 433 | dev_dbg(&priv->usb->dev, "Submit Rx URB failed %d\n", ret); |
59608cb1 QD |
434 | end: |
435 | return ret; | |
93eac3b1 MP |
436 | } |
437 | ||
ceebd903 | 438 | static void vnt_tx_context_complete(struct urb *urb) |
92b96797 | 439 | { |
599e4b5c | 440 | struct vnt_usb_send_context *context = urb->context; |
30a05b39 | 441 | struct vnt_private *priv = context->priv; |
92b96797 | 442 | |
e8152bfb MP |
443 | switch (urb->status) { |
444 | case 0: | |
8a660261 | 445 | dev_dbg(&priv->usb->dev, "Write %d bytes\n", context->buf_len); |
e8152bfb MP |
446 | break; |
447 | case -ECONNRESET: | |
448 | case -ENOENT: | |
449 | case -ESHUTDOWN: | |
30a05b39 | 450 | context->in_use = false; |
e8152bfb | 451 | return; |
d1b2a11d | 452 | case -ETIMEDOUT: |
e8152bfb | 453 | default: |
8a660261 | 454 | dev_dbg(&priv->usb->dev, "BULK Out failed %d\n", urb->status); |
e8152bfb MP |
455 | break; |
456 | } | |
457 | ||
d38b13aa MP |
458 | if (context->type == CONTEXT_DATA_PACKET) |
459 | ieee80211_wake_queues(priv->hw); | |
21aa212c | 460 | |
71d764ae MP |
461 | if (urb->status || context->type == CONTEXT_BEACON_PACKET) { |
462 | if (context->skb) | |
463 | ieee80211_free_txskb(priv->hw, context->skb); | |
464 | ||
465 | context->in_use = false; | |
466 | } | |
92b96797 | 467 | } |
664b044b MP |
468 | |
469 | int vnt_tx_context(struct vnt_private *priv, | |
470 | struct vnt_usb_send_context *context) | |
471 | { | |
472 | int status; | |
b9183fdd | 473 | struct urb *urb = context->urb; |
664b044b | 474 | |
cbcc9a36 | 475 | if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) { |
664b044b | 476 | context->in_use = false; |
2812ab89 | 477 | return -ENODEV; |
664b044b MP |
478 | } |
479 | ||
664b044b MP |
480 | usb_fill_bulk_urb(urb, |
481 | priv->usb, | |
482 | usb_sndbulkpipe(priv->usb, 3), | |
483 | context->data, | |
484 | context->buf_len, | |
485 | vnt_tx_context_complete, | |
486 | context); | |
487 | ||
488 | status = usb_submit_urb(urb, GFP_ATOMIC); | |
7aa47db9 | 489 | if (status) { |
664b044b MP |
490 | dev_dbg(&priv->usb->dev, "Submit Tx URB failed %d\n", status); |
491 | ||
492 | context->in_use = false; | |
664b044b MP |
493 | } |
494 | ||
2812ab89 | 495 | return status; |
664b044b | 496 | } |