1/* 2 * This file is part of wl1251 3 * 4 * Copyright (c) 1998-2007 Texas Instruments Incorporated 5 * Copyright (C) 2008 Nokia Corporation 6 * 7 * Contact: Kalle Valo <kalle.valo@nokia.com> 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License 11 * version 2 as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 21 * 02110-1301 USA 22 * 23 */ 24 25#include <linux/kernel.h> 26#include <linux/module.h> 27 28#include "wl1251.h" 29#include "wl1251_reg.h" 30#include "wl1251_tx.h" 31#include "wl1251_ps.h" 32#include "wl1251_io.h" 33 34static bool wl1251_tx_double_buffer_busy(struct wl1251 *wl, u32 data_out_count) 35{ 36 int used, data_in_count; 37 38 data_in_count = wl->data_in_count; 39 40 if (data_in_count < data_out_count) 41 /* data_in_count has wrapped */ 42 data_in_count += TX_STATUS_DATA_OUT_COUNT_MASK + 1; 43 44 used = data_in_count - data_out_count; 45 46 WARN_ON(used < 0); 47 WARN_ON(used > DP_TX_PACKET_RING_CHUNK_NUM); 48 49 if (used >= DP_TX_PACKET_RING_CHUNK_NUM) 50 return true; 51 else 52 return false; 53} 54 55static int wl1251_tx_path_status(struct wl1251 *wl) 56{ 57 u32 status, addr, data_out_count; 58 bool busy; 59 60 addr = wl->data_path->tx_control_addr; 61 status = wl1251_mem_read32(wl, addr); 62 data_out_count = status & TX_STATUS_DATA_OUT_COUNT_MASK; 63 busy = wl1251_tx_double_buffer_busy(wl, data_out_count); 64 65 if (busy) 66 return -EBUSY; 67 68 return 0; 69} 70 71static int wl1251_tx_id(struct wl1251 *wl, struct sk_buff *skb) 72{ 73 int i; 74 75 for (i = 0; i < FW_TX_CMPLT_BLOCK_SIZE; i++) 76 if (wl->tx_frames[i] == NULL) { 77 wl->tx_frames[i] = skb; 78 return i; 79 } 80 81 return -EBUSY; 82} 83 84static void wl1251_tx_control(struct tx_double_buffer_desc *tx_hdr, 85 struct ieee80211_tx_info *control, u16 fc) 86{ 87 *(u16 *)&tx_hdr->control = 0; 88 89 tx_hdr->control.rate_policy = 0; 90 91 /* 802.11 packets */ 92 tx_hdr->control.packet_type = 0; 93 94 if (control->flags & IEEE80211_TX_CTL_NO_ACK) 95 tx_hdr->control.ack_policy = 1; 96 97 tx_hdr->control.tx_complete = 1; 98 99 if ((fc & IEEE80211_FTYPE_DATA) && 100 ((fc & IEEE80211_STYPE_QOS_DATA) || 101 (fc & IEEE80211_STYPE_QOS_NULLFUNC))) 102 tx_hdr->control.qos = 1; 103} 104 105/* RSN + MIC = 8 + 8 = 16 bytes (worst case - AES). */ 106#define MAX_MSDU_SECURITY_LENGTH 16 107#define MAX_MPDU_SECURITY_LENGTH 16 108#define WLAN_QOS_HDR_LEN 26 109#define MAX_MPDU_HEADER_AND_SECURITY (MAX_MPDU_SECURITY_LENGTH + \ 110 WLAN_QOS_HDR_LEN) 111#define HW_BLOCK_SIZE 252 112static void wl1251_tx_frag_block_num(struct tx_double_buffer_desc *tx_hdr) 113{ 114 u16 payload_len, frag_threshold, mem_blocks; 115 u16 num_mpdus, mem_blocks_per_frag; 116 117 frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD; 118 tx_hdr->frag_threshold = cpu_to_le16(frag_threshold); 119 120 payload_len = le16_to_cpu(tx_hdr->length) + MAX_MSDU_SECURITY_LENGTH; 121 122 if (payload_len > frag_threshold) { 123 mem_blocks_per_frag = 124 ((frag_threshold + MAX_MPDU_HEADER_AND_SECURITY) / 125 HW_BLOCK_SIZE) + 1; 126 num_mpdus = payload_len / frag_threshold; 127 mem_blocks = num_mpdus * mem_blocks_per_frag; 128 payload_len -= num_mpdus * frag_threshold; 129 num_mpdus++; 130 131 } else { 132 mem_blocks_per_frag = 0; 133 mem_blocks = 0; 134 num_mpdus = 1; 135 } 136 137 mem_blocks += (payload_len / HW_BLOCK_SIZE) + 1; 138 139 if (num_mpdus > 1) 140 mem_blocks += min(num_mpdus, mem_blocks_per_frag); 141 142 tx_hdr->num_mem_blocks = mem_blocks; 143} 144 145static int wl1251_tx_fill_hdr(struct wl1251 *wl, struct sk_buff *skb, 146 struct ieee80211_tx_info *control) 147{ 148 struct tx_double_buffer_desc *tx_hdr; 149 struct ieee80211_rate *rate; 150 int id; 151 u16 fc; 152 153 if (!skb) 154 return -EINVAL; 155 156 id = wl1251_tx_id(wl, skb); 157 if (id < 0) 158 return id; 159 160 fc = *(u16 *)skb->data; 161 tx_hdr = (struct tx_double_buffer_desc *) skb_push(skb, 162 sizeof(*tx_hdr)); 163 164 tx_hdr->length = cpu_to_le16(skb->len - sizeof(*tx_hdr)); 165 rate = ieee80211_get_tx_rate(wl->hw, control); 166 tx_hdr->rate = cpu_to_le16(rate->hw_value); 167 tx_hdr->expiry_time = cpu_to_le32(1 << 16); 168 tx_hdr->id = id; 169 170 tx_hdr->xmit_queue = wl1251_tx_get_queue(skb_get_queue_mapping(skb)); 171 172 wl1251_tx_control(tx_hdr, control, fc); 173 wl1251_tx_frag_block_num(tx_hdr); 174 175 return 0; 176} 177 178/* We copy the packet to the target */ 179static int wl1251_tx_send_packet(struct wl1251 *wl, struct sk_buff *skb, 180 struct ieee80211_tx_info *control) 181{ 182 struct tx_double_buffer_desc *tx_hdr; 183 int len; 184 u32 addr; 185 186 if (!skb) 187 return -EINVAL; 188 189 tx_hdr = (struct tx_double_buffer_desc *) skb->data; 190 191 if (control->control.hw_key && 192 control->control.hw_key->alg == ALG_TKIP) { 193 int hdrlen; 194 __le16 fc; 195 u16 length; 196 u8 *pos; 197 198 fc = *(__le16 *)(skb->data + sizeof(*tx_hdr)); 199 length = le16_to_cpu(tx_hdr->length) + WL1251_TKIP_IV_SPACE; 200 tx_hdr->length = cpu_to_le16(length); 201 202 hdrlen = ieee80211_hdrlen(fc); 203 204 pos = skb_push(skb, WL1251_TKIP_IV_SPACE); 205 memmove(pos, pos + WL1251_TKIP_IV_SPACE, 206 sizeof(*tx_hdr) + hdrlen); 207 } 208 209 if (unlikely((long)skb->data & 0x03)) { 210 int offset = (4 - (long)skb->data) & 0x03; 211 wl1251_debug(DEBUG_TX, "skb offset %d", offset); 212 213 /* check whether the current skb can be used */ 214 if (!skb_cloned(skb) && (skb_tailroom(skb) >= offset)) { 215 unsigned char *src = skb->data; 216 217 /* align the buffer on a 4-byte boundary */ 218 skb_reserve(skb, offset); 219 memmove(skb->data, src, skb->len); 220 tx_hdr = (struct tx_double_buffer_desc *) skb->data; 221 } else { 222 wl1251_info("No handler, fixme!"); 223 return -EINVAL; 224 } 225 } 226 227 /* Our skb->data at this point includes the HW header */ 228 len = WL1251_TX_ALIGN(skb->len); 229 230 if (wl->data_in_count & 0x1) 231 addr = wl->data_path->tx_packet_ring_addr + 232 wl->data_path->tx_packet_ring_chunk_size; 233 else 234 addr = wl->data_path->tx_packet_ring_addr; 235 236 wl1251_mem_write(wl, addr, skb->data, len); 237 238 wl1251_debug(DEBUG_TX, "tx id %u skb 0x%p payload %u rate 0x%x " 239 "queue %d", tx_hdr->id, skb, tx_hdr->length, 240 tx_hdr->rate, tx_hdr->xmit_queue); 241 242 return 0; 243} 244 245static void wl1251_tx_trigger(struct wl1251 *wl) 246{ 247 u32 data, addr; 248 249 if (wl->data_in_count & 0x1) { 250 addr = ACX_REG_INTERRUPT_TRIG_H; 251 data = INTR_TRIG_TX_PROC1; 252 } else { 253 addr = ACX_REG_INTERRUPT_TRIG; 254 data = INTR_TRIG_TX_PROC0; 255 } 256 257 wl1251_reg_write32(wl, addr, data); 258 259 /* Bumping data in */ 260 wl->data_in_count = (wl->data_in_count + 1) & 261 TX_STATUS_DATA_OUT_COUNT_MASK; 262} 263 264/* caller must hold wl->mutex */ 265static int wl1251_tx_frame(struct wl1251 *wl, struct sk_buff *skb) 266{ 267 struct ieee80211_tx_info *info; 268 int ret = 0; 269 u8 idx; 270 271 info = IEEE80211_SKB_CB(skb); 272 273 if (info->control.hw_key) { 274 idx = info->control.hw_key->hw_key_idx; 275 if (unlikely(wl->default_key != idx)) { 276 ret = wl1251_acx_default_key(wl, idx); 277 if (ret < 0) 278 return ret; 279 } 280 } 281 282 ret = wl1251_tx_path_status(wl); 283 if (ret < 0) 284 return ret; 285 286 ret = wl1251_tx_fill_hdr(wl, skb, info); 287 if (ret < 0) 288 return ret; 289 290 ret = wl1251_tx_send_packet(wl, skb, info); 291 if (ret < 0) 292 return ret; 293 294 wl1251_tx_trigger(wl); 295 296 return ret; 297} 298 299void wl1251_tx_work(struct work_struct *work) 300{ 301 struct wl1251 *wl = container_of(work, struct wl1251, tx_work); 302 struct sk_buff *skb; 303 bool woken_up = false; 304 int ret; 305 306 mutex_lock(&wl->mutex); 307 308 if (unlikely(wl->state == WL1251_STATE_OFF)) 309 goto out; 310 311 while ((skb = skb_dequeue(&wl->tx_queue))) { 312 if (!woken_up) { 313 ret = wl1251_ps_elp_wakeup(wl); 314 if (ret < 0) 315 goto out; 316 woken_up = true; 317 } 318 319 ret = wl1251_tx_frame(wl, skb); 320 if (ret == -EBUSY) { 321 /* firmware buffer is full, stop queues */ 322 wl1251_debug(DEBUG_TX, "tx_work: fw buffer full, " 323 "stop queues"); 324 ieee80211_stop_queues(wl->hw); 325 wl->tx_queue_stopped = true; 326 skb_queue_head(&wl->tx_queue, skb); 327 goto out; 328 } else if (ret < 0) { 329 dev_kfree_skb(skb); 330 goto out; 331 } 332 } 333 334out: 335 if (woken_up) 336 wl1251_ps_elp_sleep(wl); 337 338 mutex_unlock(&wl->mutex); 339} 340 341static const char *wl1251_tx_parse_status(u8 status) 342{ 343 /* 8 bit status field, one character per bit plus null */ 344 static char buf[9]; 345 int i = 0; 346 347 memset(buf, 0, sizeof(buf)); 348 349 if (status & TX_DMA_ERROR) 350 buf[i++] = 'm'; 351 if (status & TX_DISABLED) 352 buf[i++] = 'd'; 353 if (status & TX_RETRY_EXCEEDED) 354 buf[i++] = 'r'; 355 if (status & TX_TIMEOUT) 356 buf[i++] = 't'; 357 if (status & TX_KEY_NOT_FOUND) 358 buf[i++] = 'k'; 359 if (status & TX_ENCRYPT_FAIL) 360 buf[i++] = 'e'; 361 if (status & TX_UNAVAILABLE_PRIORITY) 362 buf[i++] = 'p'; 363 364 /* bit 0 is unused apparently */ 365 366 return buf; 367} 368 369static void wl1251_tx_packet_cb(struct wl1251 *wl, 370 struct tx_result *result) 371{ 372 struct ieee80211_tx_info *info; 373 struct sk_buff *skb; 374 int hdrlen, ret; 375 u8 *frame; 376 377 skb = wl->tx_frames[result->id]; 378 if (skb == NULL) { 379 wl1251_error("SKB for packet %d is NULL", result->id); 380 return; 381 } 382 383 info = IEEE80211_SKB_CB(skb); 384 385 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK) && 386 (result->status == TX_SUCCESS)) 387 info->flags |= IEEE80211_TX_STAT_ACK; 388 389 info->status.rates[0].count = result->ack_failures + 1; 390 wl->stats.retry_count += result->ack_failures; 391 392 /* 393 * We have to remove our private TX header before pushing 394 * the skb back to mac80211. 395 */ 396 frame = skb_pull(skb, sizeof(struct tx_double_buffer_desc)); 397 if (info->control.hw_key && 398 info->control.hw_key->alg == ALG_TKIP) { 399 hdrlen = ieee80211_get_hdrlen_from_skb(skb); 400 memmove(frame + WL1251_TKIP_IV_SPACE, frame, hdrlen); 401 skb_pull(skb, WL1251_TKIP_IV_SPACE); 402 } 403 404 wl1251_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x" 405 " status 0x%x (%s)", 406 result->id, skb, result->ack_failures, result->rate, 407 result->status, wl1251_tx_parse_status(result->status)); 408 409 410 ieee80211_tx_status(wl->hw, skb); 411 412 wl->tx_frames[result->id] = NULL; 413 414 if (wl->tx_queue_stopped) { 415 wl1251_debug(DEBUG_TX, "cb: queue was stopped"); 416 417 skb = skb_dequeue(&wl->tx_queue); 418 419 /* The skb can be NULL because tx_work might have been 420 scheduled before the queue was stopped making the 421 queue empty */ 422 423 if (skb) { 424 ret = wl1251_tx_frame(wl, skb); 425 if (ret == -EBUSY) { 426 /* firmware buffer is still full */ 427 wl1251_debug(DEBUG_TX, "cb: fw buffer " 428 "still full"); 429 skb_queue_head(&wl->tx_queue, skb); 430 return; 431 } else if (ret < 0) { 432 dev_kfree_skb(skb); 433 return; 434 } 435 } 436 437 wl1251_debug(DEBUG_TX, "cb: waking queues"); 438 ieee80211_wake_queues(wl->hw); 439 wl->tx_queue_stopped = false; 440 } 441} 442 443/* Called upon reception of a TX complete interrupt */ 444void wl1251_tx_complete(struct wl1251 *wl) 445{ 446 int i, result_index, num_complete = 0; 447 struct tx_result result[FW_TX_CMPLT_BLOCK_SIZE], *result_ptr; 448 449 if (unlikely(wl->state != WL1251_STATE_ON)) 450 return; 451 452 /* First we read the result */ 453 wl1251_mem_read(wl, wl->data_path->tx_complete_addr, 454 result, sizeof(result)); 455 456 result_index = wl->next_tx_complete; 457 458 for (i = 0; i < ARRAY_SIZE(result); i++) { 459 result_ptr = &result[result_index]; 460 461 if (result_ptr->done_1 == 1 && 462 result_ptr->done_2 == 1) { 463 wl1251_tx_packet_cb(wl, result_ptr); 464 465 result_ptr->done_1 = 0; 466 result_ptr->done_2 = 0; 467 468 result_index = (result_index + 1) & 469 (FW_TX_CMPLT_BLOCK_SIZE - 1); 470 num_complete++; 471 } else { 472 break; 473 } 474 } 475 476 /* Every completed frame needs to be acknowledged */ 477 if (num_complete) { 478 /* 479 * If we've wrapped, we have to clear 480 * the results in 2 steps. 481 */ 482 if (result_index > wl->next_tx_complete) { 483 /* Only 1 write is needed */ 484 wl1251_mem_write(wl, 485 wl->data_path->tx_complete_addr + 486 (wl->next_tx_complete * 487 sizeof(struct tx_result)), 488 &result[wl->next_tx_complete], 489 num_complete * 490 sizeof(struct tx_result)); 491 492 493 } else if (result_index < wl->next_tx_complete) { 494 /* 2 writes are needed */ 495 wl1251_mem_write(wl, 496 wl->data_path->tx_complete_addr + 497 (wl->next_tx_complete * 498 sizeof(struct tx_result)), 499 &result[wl->next_tx_complete], 500 (FW_TX_CMPLT_BLOCK_SIZE - 501 wl->next_tx_complete) * 502 sizeof(struct tx_result)); 503 504 wl1251_mem_write(wl, 505 wl->data_path->tx_complete_addr, 506 result, 507 (num_complete - 508 FW_TX_CMPLT_BLOCK_SIZE + 509 wl->next_tx_complete) * 510 sizeof(struct tx_result)); 511 512 } else { 513 /* We have to write the whole array */ 514 wl1251_mem_write(wl, 515 wl->data_path->tx_complete_addr, 516 result, 517 FW_TX_CMPLT_BLOCK_SIZE * 518 sizeof(struct tx_result)); 519 } 520 521 } 522 523 wl->next_tx_complete = result_index; 524} 525 526/* caller must hold wl->mutex */ 527void wl1251_tx_flush(struct wl1251 *wl) 528{ 529 int i; 530 struct sk_buff *skb; 531 struct ieee80211_tx_info *info; 532 533 /* TX failure */ 534 535 while ((skb = skb_dequeue(&wl->tx_queue))) { 536 info = IEEE80211_SKB_CB(skb); 537 538 wl1251_debug(DEBUG_TX, "flushing skb 0x%p", skb); 539 540 if (!(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS)) 541 continue; 542 543 ieee80211_tx_status(wl->hw, skb); 544 } 545 546 for (i = 0; i < FW_TX_CMPLT_BLOCK_SIZE; i++) 547 if (wl->tx_frames[i] != NULL) { 548 skb = wl->tx_frames[i]; 549 info = IEEE80211_SKB_CB(skb); 550 551 if (!(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS)) 552 continue; 553 554 ieee80211_tx_status(wl->hw, skb); 555 wl->tx_frames[i] = NULL; 556 } 557} 558