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