1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc. 4 * All rights reserved. 5 * 6 * File: rxtx.c 7 * 8 * Purpose: handle WMAC/802.3/802.11 rx & tx functions 9 * 10 * Author: Lyndon Chen 11 * 12 * Date: May 20, 2003 13 * 14 * Functions: 15 * vnt_generate_tx_parameter - Generate tx dma required parameter. 16 * vnt_get_rsvtime- get frame reserved time 17 * vnt_fill_cts_head- fulfill CTS ctl header 18 * 19 * Revision History: 20 * 21 */ 22 23 #include <linux/etherdevice.h> 24 #include "device.h" 25 #include "rxtx.h" 26 #include "card.h" 27 #include "mac.h" 28 #include "rf.h" 29 #include "usbpipe.h" 30 31 static const u16 vnt_time_stampoff[2][MAX_RATE] = { 32 /* Long Preamble */ 33 {384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23}, 34 35 /* Short Preamble */ 36 {384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23}, 37 }; 38 39 #define DATADUR_B 10 40 #define DATADUR_A 11 41 42 static const u8 vnt_phy_signal[] = { 43 0x00, /* RATE_1M */ 44 0x01, /* RATE_2M */ 45 0x02, /* RATE_5M */ 46 0x03, /* RATE_11M */ 47 0x8b, /* RATE_6M */ 48 0x8f, /* RATE_9M */ 49 0x8a, /* RATE_12M */ 50 0x8e, /* RATE_18M */ 51 0x89, /* RATE_24M */ 52 0x8d, /* RATE_36M */ 53 0x88, /* RATE_48M */ 54 0x8c /* RATE_54M */ 55 }; 56 57 static struct vnt_usb_send_context 58 *vnt_get_free_context(struct vnt_private *priv) 59 { 60 struct vnt_usb_send_context *context = NULL; 61 int ii; 62 63 dev_dbg(&priv->usb->dev, "%s\n", __func__); 64 65 for (ii = 0; ii < priv->num_tx_context; ii++) { 66 if (!priv->tx_context[ii]) 67 return NULL; 68 69 context = priv->tx_context[ii]; 70 if (!context->in_use) { 71 context->in_use = true; 72 return context; 73 } 74 } 75 76 if (ii == priv->num_tx_context) { 77 dev_dbg(&priv->usb->dev, "%s No Free Tx Context\n", __func__); 78 79 ieee80211_stop_queues(priv->hw); 80 } 81 82 return NULL; 83 } 84 85 /* Get Length, Service, and Signal fields of Phy for Tx */ 86 static void vnt_get_phy_field(struct vnt_private *priv, u32 frame_length, 87 u16 tx_rate, u8 pkt_type, 88 struct vnt_phy_field *phy) 89 { 90 u32 bit_count; 91 u32 count = 0; 92 u32 tmp; 93 int ext_bit; 94 int i; 95 u8 mask = 0; 96 u8 preamble_type = priv->preamble_type; 97 98 bit_count = frame_length * 8; 99 ext_bit = false; 100 101 switch (tx_rate) { 102 case RATE_1M: 103 count = bit_count; 104 break; 105 case RATE_2M: 106 count = bit_count / 2; 107 break; 108 case RATE_5M: 109 count = DIV_ROUND_UP(bit_count * 10, 55); 110 break; 111 case RATE_11M: 112 count = bit_count / 11; 113 tmp = count * 11; 114 115 if (tmp != bit_count) { 116 count++; 117 118 if ((bit_count - tmp) <= 3) 119 ext_bit = true; 120 } 121 122 break; 123 } 124 125 if (tx_rate > RATE_11M) { 126 if (pkt_type == PK_TYPE_11A) 127 mask = BIT(4); 128 } else if (tx_rate > RATE_1M) { 129 if (preamble_type == PREAMBLE_SHORT) 130 mask = BIT(3); 131 } 132 133 i = tx_rate > RATE_54M ? RATE_54M : tx_rate; 134 phy->signal = vnt_phy_signal[i] | mask; 135 phy->service = 0x00; 136 137 if (pkt_type == PK_TYPE_11B) { 138 if (ext_bit) 139 phy->service |= 0x80; 140 phy->len = cpu_to_le16((u16)count); 141 } else { 142 phy->len = cpu_to_le16((u16)frame_length); 143 } 144 } 145 146 static __le16 vnt_time_stamp_off(struct vnt_private *priv, u16 rate) 147 { 148 return cpu_to_le16(vnt_time_stampoff[priv->preamble_type % 2] 149 [rate % MAX_RATE]); 150 } 151 152 static __le16 vnt_rxtx_rsvtime_le16(struct vnt_usb_send_context *context) 153 { 154 struct vnt_private *priv = context->priv; 155 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(context->skb); 156 struct ieee80211_rate *rate = ieee80211_get_tx_rate(priv->hw, info); 157 158 return ieee80211_generic_frame_duration(priv->hw, 159 info->control.vif, info->band, 160 context->frame_len, 161 rate); 162 } 163 164 static __le16 vnt_get_rts_duration(struct vnt_usb_send_context *context) 165 { 166 struct vnt_private *priv = context->priv; 167 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(context->skb); 168 169 return ieee80211_rts_duration(priv->hw, priv->vif, 170 context->frame_len, info); 171 } 172 173 static __le16 vnt_get_cts_duration(struct vnt_usb_send_context *context) 174 { 175 struct vnt_private *priv = context->priv; 176 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(context->skb); 177 178 return ieee80211_ctstoself_duration(priv->hw, priv->vif, 179 context->frame_len, info); 180 } 181 182 static void vnt_rxtx_datahead_g(struct vnt_usb_send_context *tx_context, 183 struct vnt_tx_datahead_g *buf) 184 { 185 struct vnt_private *priv = tx_context->priv; 186 struct ieee80211_hdr *hdr = 187 (struct ieee80211_hdr *)tx_context->skb->data; 188 u32 frame_len = tx_context->frame_len; 189 u16 rate = tx_context->tx_rate; 190 191 /* Get SignalField,ServiceField,Length */ 192 vnt_get_phy_field(priv, frame_len, rate, tx_context->pkt_type, &buf->a); 193 vnt_get_phy_field(priv, frame_len, priv->top_cck_basic_rate, 194 PK_TYPE_11B, &buf->b); 195 196 /* Get Duration and TimeStamp */ 197 buf->duration_a = hdr->duration_id; 198 buf->duration_b = hdr->duration_id; 199 buf->time_stamp_off_a = vnt_time_stamp_off(priv, rate); 200 buf->time_stamp_off_b = vnt_time_stamp_off(priv, 201 priv->top_cck_basic_rate); 202 } 203 204 static void vnt_rxtx_datahead_ab(struct vnt_usb_send_context *tx_context, 205 struct vnt_tx_datahead_ab *buf) 206 { 207 struct vnt_private *priv = tx_context->priv; 208 struct ieee80211_hdr *hdr = 209 (struct ieee80211_hdr *)tx_context->skb->data; 210 u32 frame_len = tx_context->frame_len; 211 u16 rate = tx_context->tx_rate; 212 213 /* Get SignalField,ServiceField,Length */ 214 vnt_get_phy_field(priv, frame_len, rate, 215 tx_context->pkt_type, &buf->ab); 216 217 /* Get Duration and TimeStampOff */ 218 buf->duration = hdr->duration_id; 219 buf->time_stamp_off = vnt_time_stamp_off(priv, rate); 220 } 221 222 static void vnt_fill_ieee80211_rts(struct vnt_usb_send_context *tx_context, 223 struct ieee80211_rts *rts, __le16 duration) 224 { 225 struct ieee80211_hdr *hdr = 226 (struct ieee80211_hdr *)tx_context->skb->data; 227 228 rts->duration = duration; 229 rts->frame_control = 230 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS); 231 232 ether_addr_copy(rts->ra, hdr->addr1); 233 ether_addr_copy(rts->ta, hdr->addr2); 234 } 235 236 static void vnt_rxtx_rts_g_head(struct vnt_usb_send_context *tx_context, 237 struct vnt_rts_g *buf) 238 { 239 struct vnt_private *priv = tx_context->priv; 240 u16 rts_frame_len = 20; 241 242 vnt_get_phy_field(priv, rts_frame_len, priv->top_cck_basic_rate, 243 PK_TYPE_11B, &buf->b); 244 vnt_get_phy_field(priv, rts_frame_len, priv->top_ofdm_basic_rate, 245 tx_context->pkt_type, &buf->a); 246 247 buf->duration_bb = vnt_get_rts_duration(tx_context); 248 buf->duration_aa = buf->duration_bb; 249 buf->duration_ba = buf->duration_bb; 250 251 vnt_fill_ieee80211_rts(tx_context, &buf->data, buf->duration_aa); 252 253 vnt_rxtx_datahead_g(tx_context, &buf->data_head); 254 } 255 256 static void vnt_rxtx_rts_ab_head(struct vnt_usb_send_context *tx_context, 257 struct vnt_rts_ab *buf) 258 { 259 struct vnt_private *priv = tx_context->priv; 260 u16 rts_frame_len = 20; 261 262 vnt_get_phy_field(priv, rts_frame_len, priv->top_ofdm_basic_rate, 263 tx_context->pkt_type, &buf->ab); 264 265 buf->duration = vnt_get_rts_duration(tx_context); 266 267 vnt_fill_ieee80211_rts(tx_context, &buf->data, buf->duration); 268 269 vnt_rxtx_datahead_ab(tx_context, &buf->data_head); 270 } 271 272 static void vnt_fill_cts_head(struct vnt_usb_send_context *tx_context, 273 union vnt_tx_data_head *head) 274 { 275 struct vnt_private *priv = tx_context->priv; 276 struct vnt_cts *buf = &head->cts_g; 277 u32 cts_frame_len = 14; 278 279 /* Get SignalField,ServiceField,Length */ 280 vnt_get_phy_field(priv, cts_frame_len, priv->top_cck_basic_rate, 281 PK_TYPE_11B, &buf->b); 282 /* Get CTSDuration_ba */ 283 buf->duration_ba = vnt_get_cts_duration(tx_context); 284 /*Get CTS Frame body*/ 285 buf->data.duration = buf->duration_ba; 286 buf->data.frame_control = 287 cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTS); 288 289 ether_addr_copy(buf->data.ra, priv->current_net_addr); 290 291 vnt_rxtx_datahead_g(tx_context, &buf->data_head); 292 } 293 294 /* returns true if mic_hdr is needed */ 295 static bool vnt_fill_txkey(struct vnt_tx_buffer *tx_buffer, struct sk_buff *skb) 296 { 297 struct vnt_tx_fifo_head *fifo = &tx_buffer->fifo_head; 298 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 299 struct ieee80211_key_conf *tx_key = info->control.hw_key; 300 struct vnt_mic_hdr *mic_hdr; 301 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; 302 u64 pn64; 303 u16 payload_len = skb->len; 304 u8 *iv = ((u8 *)hdr + ieee80211_get_hdrlen_from_skb(skb)); 305 306 /* strip header and icv len from payload */ 307 payload_len -= ieee80211_get_hdrlen_from_skb(skb); 308 payload_len -= tx_key->icv_len; 309 310 switch (tx_key->cipher) { 311 case WLAN_CIPHER_SUITE_WEP40: 312 case WLAN_CIPHER_SUITE_WEP104: 313 memcpy(fifo->tx_key, iv, 3); 314 memcpy(fifo->tx_key + 3, tx_key->key, tx_key->keylen); 315 316 if (tx_key->keylen == WLAN_KEY_LEN_WEP40) { 317 memcpy(fifo->tx_key + 8, iv, 3); 318 memcpy(fifo->tx_key + 11, 319 tx_key->key, WLAN_KEY_LEN_WEP40); 320 } 321 322 fifo->frag_ctl |= cpu_to_le16(FRAGCTL_LEGACY); 323 break; 324 case WLAN_CIPHER_SUITE_TKIP: 325 ieee80211_get_tkip_p2k(tx_key, skb, fifo->tx_key); 326 327 fifo->frag_ctl |= cpu_to_le16(FRAGCTL_TKIP); 328 break; 329 case WLAN_CIPHER_SUITE_CCMP: 330 if (info->control.use_cts_prot) { 331 if (info->control.use_rts) 332 mic_hdr = &tx_buffer->tx_head.tx_rts.tx.mic.hdr; 333 else 334 mic_hdr = &tx_buffer->tx_head.tx_cts.tx.mic.hdr; 335 } else { 336 mic_hdr = &tx_buffer->tx_head.tx_ab.tx.mic.hdr; 337 } 338 339 mic_hdr->id = 0x59; 340 mic_hdr->payload_len = cpu_to_be16(payload_len); 341 ether_addr_copy(mic_hdr->mic_addr2, hdr->addr2); 342 343 pn64 = atomic64_read(&tx_key->tx_pn); 344 mic_hdr->ccmp_pn[5] = pn64; 345 mic_hdr->ccmp_pn[4] = pn64 >> 8; 346 mic_hdr->ccmp_pn[3] = pn64 >> 16; 347 mic_hdr->ccmp_pn[2] = pn64 >> 24; 348 mic_hdr->ccmp_pn[1] = pn64 >> 32; 349 mic_hdr->ccmp_pn[0] = pn64 >> 40; 350 351 if (ieee80211_has_a4(hdr->frame_control)) 352 mic_hdr->hlen = cpu_to_be16(28); 353 else 354 mic_hdr->hlen = cpu_to_be16(22); 355 356 ether_addr_copy(mic_hdr->addr1, hdr->addr1); 357 ether_addr_copy(mic_hdr->addr2, hdr->addr2); 358 ether_addr_copy(mic_hdr->addr3, hdr->addr3); 359 360 mic_hdr->frame_control = cpu_to_le16( 361 le16_to_cpu(hdr->frame_control) & 0xc78f); 362 mic_hdr->seq_ctrl = cpu_to_le16( 363 le16_to_cpu(hdr->seq_ctrl) & 0xf); 364 365 if (ieee80211_has_a4(hdr->frame_control)) 366 ether_addr_copy(mic_hdr->addr4, hdr->addr4); 367 368 memcpy(fifo->tx_key, tx_key->key, WLAN_KEY_LEN_CCMP); 369 370 fifo->frag_ctl |= cpu_to_le16(FRAGCTL_AES); 371 return true; 372 default: 373 break; 374 } 375 376 return false; 377 } 378 379 static void vnt_rxtx_rts(struct vnt_usb_send_context *tx_context) 380 { 381 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_context->skb); 382 struct vnt_tx_buffer *tx_buffer = tx_context->tx_buffer; 383 union vnt_tx_head *tx_head = &tx_buffer->tx_head; 384 struct vnt_rrv_time_rts *buf = &tx_head->tx_rts.rts; 385 union vnt_tx_data_head *head = &tx_head->tx_rts.tx.head; 386 387 buf->rts_rrv_time_aa = vnt_get_rts_duration(tx_context); 388 buf->rts_rrv_time_ba = buf->rts_rrv_time_aa; 389 buf->rts_rrv_time_bb = buf->rts_rrv_time_aa; 390 391 buf->rrv_time_a = vnt_rxtx_rsvtime_le16(tx_context); 392 buf->rrv_time_b = buf->rrv_time_a; 393 394 if (info->control.hw_key) { 395 if (vnt_fill_txkey(tx_buffer, tx_context->skb)) 396 head = &tx_head->tx_rts.tx.mic.head; 397 } 398 399 vnt_rxtx_rts_g_head(tx_context, &head->rts_g); 400 } 401 402 static void vnt_rxtx_cts(struct vnt_usb_send_context *tx_context) 403 { 404 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_context->skb); 405 struct vnt_tx_buffer *tx_buffer = tx_context->tx_buffer; 406 union vnt_tx_head *tx_head = &tx_buffer->tx_head; 407 struct vnt_rrv_time_cts *buf = &tx_head->tx_cts.cts; 408 union vnt_tx_data_head *head = &tx_head->tx_cts.tx.head; 409 410 buf->rrv_time_a = vnt_rxtx_rsvtime_le16(tx_context); 411 buf->rrv_time_b = buf->rrv_time_a; 412 413 buf->cts_rrv_time_ba = vnt_get_cts_duration(tx_context); 414 415 if (info->control.hw_key) { 416 if (vnt_fill_txkey(tx_buffer, tx_context->skb)) 417 head = &tx_head->tx_cts.tx.mic.head; 418 } 419 420 vnt_fill_cts_head(tx_context, head); 421 } 422 423 static void vnt_rxtx_ab(struct vnt_usb_send_context *tx_context) 424 { 425 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_context->skb); 426 struct vnt_tx_buffer *tx_buffer = tx_context->tx_buffer; 427 union vnt_tx_head *tx_head = &tx_buffer->tx_head; 428 struct vnt_rrv_time_ab *buf = &tx_head->tx_ab.ab; 429 union vnt_tx_data_head *head = &tx_head->tx_ab.tx.head; 430 431 buf->rrv_time = vnt_rxtx_rsvtime_le16(tx_context); 432 433 if (info->control.hw_key) { 434 if (vnt_fill_txkey(tx_buffer, tx_context->skb)) 435 head = &tx_head->tx_ab.tx.mic.head; 436 } 437 438 if (info->control.use_rts) { 439 buf->rts_rrv_time = vnt_get_rts_duration(tx_context); 440 441 vnt_rxtx_rts_ab_head(tx_context, &head->rts_ab); 442 443 return; 444 } 445 446 vnt_rxtx_datahead_ab(tx_context, &head->data_head_ab); 447 } 448 449 static void vnt_generate_tx_parameter(struct vnt_usb_send_context *tx_context) 450 { 451 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_context->skb); 452 453 if (info->control.use_cts_prot) { 454 if (info->control.use_rts) { 455 vnt_rxtx_rts(tx_context); 456 457 return; 458 } 459 460 vnt_rxtx_cts(tx_context); 461 462 return; 463 } 464 465 vnt_rxtx_ab(tx_context); 466 } 467 468 static u16 vnt_get_hdr_size(struct ieee80211_tx_info *info) 469 { 470 u16 size = sizeof(struct vnt_tx_datahead_ab); 471 472 if (info->control.use_cts_prot) { 473 if (info->control.use_rts) 474 size = sizeof(struct vnt_rts_g); 475 else 476 size = sizeof(struct vnt_cts); 477 } else if (info->control.use_rts) { 478 size = sizeof(struct vnt_rts_ab); 479 } 480 481 if (info->control.hw_key) { 482 if (info->control.hw_key->cipher == WLAN_CIPHER_SUITE_CCMP) 483 size += sizeof(struct vnt_mic_hdr); 484 } 485 486 /* Get rrv_time header */ 487 if (info->control.use_cts_prot) { 488 if (info->control.use_rts) 489 size += sizeof(struct vnt_rrv_time_rts); 490 else 491 size += sizeof(struct vnt_rrv_time_cts); 492 } else { 493 size += sizeof(struct vnt_rrv_time_ab); 494 } 495 496 size += sizeof(struct vnt_tx_fifo_head); 497 498 return size; 499 } 500 501 int vnt_tx_packet(struct vnt_private *priv, struct sk_buff *skb) 502 { 503 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 504 struct ieee80211_tx_rate *tx_rate = &info->control.rates[0]; 505 struct ieee80211_rate *rate; 506 struct ieee80211_hdr *hdr; 507 struct vnt_tx_buffer *tx_buffer; 508 struct vnt_tx_fifo_head *tx_buffer_head; 509 struct vnt_usb_send_context *tx_context; 510 unsigned long flags; 511 u8 pkt_type; 512 513 hdr = (struct ieee80211_hdr *)(skb->data); 514 515 rate = ieee80211_get_tx_rate(priv->hw, info); 516 517 if (rate->hw_value > RATE_11M) { 518 if (info->band == NL80211_BAND_5GHZ) { 519 pkt_type = PK_TYPE_11A; 520 } else { 521 if (tx_rate->flags & IEEE80211_TX_RC_USE_CTS_PROTECT) { 522 if (priv->basic_rates & VNT_B_RATES) 523 pkt_type = PK_TYPE_11GB; 524 else 525 pkt_type = PK_TYPE_11GA; 526 } else { 527 pkt_type = PK_TYPE_11A; 528 } 529 } 530 } else { 531 pkt_type = PK_TYPE_11B; 532 } 533 534 spin_lock_irqsave(&priv->lock, flags); 535 536 tx_context = vnt_get_free_context(priv); 537 if (!tx_context) { 538 dev_dbg(&priv->usb->dev, "%s No free context\n", __func__); 539 spin_unlock_irqrestore(&priv->lock, flags); 540 return -ENOMEM; 541 } 542 543 tx_context->pkt_type = pkt_type; 544 tx_context->frame_len = skb->len + 4; 545 tx_context->tx_rate = rate->hw_value; 546 547 spin_unlock_irqrestore(&priv->lock, flags); 548 549 tx_context->skb = skb_clone(skb, GFP_ATOMIC); 550 if (!tx_context->skb) { 551 tx_context->in_use = false; 552 return -ENOMEM; 553 } 554 555 tx_buffer = skb_push(skb, vnt_get_hdr_size(info)); 556 tx_context->tx_buffer = tx_buffer; 557 tx_buffer_head = &tx_buffer->fifo_head; 558 559 tx_context->type = CONTEXT_DATA_PACKET; 560 561 /*Set fifo controls */ 562 if (pkt_type == PK_TYPE_11A) 563 tx_buffer_head->fifo_ctl = 0; 564 else if (pkt_type == PK_TYPE_11B) 565 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11B); 566 else if (pkt_type == PK_TYPE_11GB) 567 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GB); 568 else if (pkt_type == PK_TYPE_11GA) 569 tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GA); 570 571 if (!ieee80211_is_data(hdr->frame_control)) { 572 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT | 573 FIFOCTL_ISDMA0); 574 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_TMOEN); 575 576 tx_buffer_head->time_stamp = 577 cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us); 578 } else { 579 tx_buffer_head->time_stamp = 580 cpu_to_le16(DEFAULT_MSDU_LIFETIME_RES_64us); 581 } 582 583 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) 584 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_NEEDACK); 585 586 if (ieee80211_has_retry(hdr->frame_control)) 587 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LRETRY); 588 589 if (info->control.use_rts) 590 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_RTS); 591 592 if (ieee80211_has_a4(hdr->frame_control)) 593 tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LHEAD); 594 595 tx_buffer_head->frag_ctl = 596 cpu_to_le16(ieee80211_hdrlen(hdr->frame_control) << 10); 597 598 if (info->control.hw_key) 599 tx_context->frame_len += info->control.hw_key->icv_len; 600 601 tx_buffer_head->current_rate = cpu_to_le16(rate->hw_value); 602 603 vnt_generate_tx_parameter(tx_context); 604 605 tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_NONFRAG); 606 607 priv->seq_counter = (le16_to_cpu(hdr->seq_ctrl) & 608 IEEE80211_SCTL_SEQ) >> 4; 609 610 spin_lock_irqsave(&priv->lock, flags); 611 612 if (vnt_tx_context(priv, tx_context, skb)) { 613 dev_kfree_skb(tx_context->skb); 614 spin_unlock_irqrestore(&priv->lock, flags); 615 return -EIO; 616 } 617 618 dev_kfree_skb(skb); 619 620 spin_unlock_irqrestore(&priv->lock, flags); 621 622 return 0; 623 } 624 625 static int vnt_beacon_xmit(struct vnt_private *priv, struct sk_buff *skb) 626 { 627 struct vnt_tx_short_buf_head *short_head; 628 struct ieee80211_tx_info *info; 629 struct vnt_usb_send_context *context; 630 struct ieee80211_mgmt *mgmt_hdr; 631 unsigned long flags; 632 u32 frame_size = skb->len + 4; 633 u16 current_rate; 634 635 spin_lock_irqsave(&priv->lock, flags); 636 637 context = vnt_get_free_context(priv); 638 if (!context) { 639 dev_dbg(&priv->usb->dev, "%s No free context!\n", __func__); 640 spin_unlock_irqrestore(&priv->lock, flags); 641 return -ENOMEM; 642 } 643 644 context->skb = skb; 645 646 spin_unlock_irqrestore(&priv->lock, flags); 647 648 mgmt_hdr = (struct ieee80211_mgmt *)skb->data; 649 short_head = skb_push(skb, sizeof(*short_head)); 650 651 if (priv->bb_type == BB_TYPE_11A) { 652 current_rate = RATE_6M; 653 654 /* Get SignalField,ServiceField,Length */ 655 vnt_get_phy_field(priv, frame_size, current_rate, 656 PK_TYPE_11A, &short_head->ab); 657 658 /* Get TimeStampOff */ 659 short_head->time_stamp_off = 660 vnt_time_stamp_off(priv, current_rate); 661 } else { 662 current_rate = RATE_1M; 663 short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_11B); 664 665 /* Get SignalField,ServiceField,Length */ 666 vnt_get_phy_field(priv, frame_size, current_rate, 667 PK_TYPE_11B, &short_head->ab); 668 669 /* Get TimeStampOff */ 670 short_head->time_stamp_off = 671 vnt_time_stamp_off(priv, current_rate); 672 } 673 674 /* Get Duration */ 675 short_head->duration = mgmt_hdr->duration; 676 677 /* time stamp always 0 */ 678 mgmt_hdr->u.beacon.timestamp = 0; 679 680 info = IEEE80211_SKB_CB(skb); 681 if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) { 682 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)mgmt_hdr; 683 684 hdr->duration_id = 0; 685 hdr->seq_ctrl = cpu_to_le16(priv->seq_counter << 4); 686 } 687 688 priv->seq_counter++; 689 if (priv->seq_counter > 0x0fff) 690 priv->seq_counter = 0; 691 692 context->type = CONTEXT_BEACON_PACKET; 693 694 spin_lock_irqsave(&priv->lock, flags); 695 696 if (vnt_tx_context(priv, context, skb)) 697 ieee80211_free_txskb(priv->hw, context->skb); 698 699 spin_unlock_irqrestore(&priv->lock, flags); 700 701 return 0; 702 } 703 704 int vnt_beacon_make(struct vnt_private *priv, struct ieee80211_vif *vif) 705 { 706 struct sk_buff *beacon; 707 708 beacon = ieee80211_beacon_get(priv->hw, vif); 709 if (!beacon) 710 return -ENOMEM; 711 712 if (vnt_beacon_xmit(priv, beacon)) { 713 ieee80211_free_txskb(priv->hw, beacon); 714 return -ENODEV; 715 } 716 717 return 0; 718 } 719 720 int vnt_beacon_enable(struct vnt_private *priv, struct ieee80211_vif *vif, 721 struct ieee80211_bss_conf *conf) 722 { 723 vnt_mac_reg_bits_off(priv, MAC_REG_TCR, TCR_AUTOBCNTX); 724 725 vnt_mac_reg_bits_off(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTREN); 726 727 vnt_mac_set_beacon_interval(priv, conf->beacon_int); 728 729 vnt_clear_current_tsf(priv); 730 731 vnt_mac_reg_bits_on(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTREN); 732 733 vnt_reset_next_tbtt(priv, conf->beacon_int); 734 735 return vnt_beacon_make(priv, vif); 736 } 737