1 /* 2 * drivers/net/wireless/mwl8k.c 3 * Driver for Marvell TOPDOG 802.11 Wireless cards 4 * 5 * Copyright (C) 2008, 2009, 2010 Marvell Semiconductor Inc. 6 * 7 * This file is licensed under the terms of the GNU General Public 8 * License version 2. This program is licensed "as is" without any 9 * warranty of any kind, whether express or implied. 10 */ 11 12 #include <linux/interrupt.h> 13 #include <linux/module.h> 14 #include <linux/kernel.h> 15 #include <linux/sched.h> 16 #include <linux/spinlock.h> 17 #include <linux/list.h> 18 #include <linux/pci.h> 19 #include <linux/delay.h> 20 #include <linux/completion.h> 21 #include <linux/etherdevice.h> 22 #include <linux/slab.h> 23 #include <net/mac80211.h> 24 #include <linux/moduleparam.h> 25 #include <linux/firmware.h> 26 #include <linux/workqueue.h> 27 28 #define MWL8K_DESC "Marvell TOPDOG(R) 802.11 Wireless Network Driver" 29 #define MWL8K_NAME KBUILD_MODNAME 30 #define MWL8K_VERSION "0.13" 31 32 /* Module parameters */ 33 static bool ap_mode_default; 34 module_param(ap_mode_default, bool, 0); 35 MODULE_PARM_DESC(ap_mode_default, 36 "Set to 1 to make ap mode the default instead of sta mode"); 37 38 /* Register definitions */ 39 #define MWL8K_HIU_GEN_PTR 0x00000c10 40 #define MWL8K_MODE_STA 0x0000005a 41 #define MWL8K_MODE_AP 0x000000a5 42 #define MWL8K_HIU_INT_CODE 0x00000c14 43 #define MWL8K_FWSTA_READY 0xf0f1f2f4 44 #define MWL8K_FWAP_READY 0xf1f2f4a5 45 #define MWL8K_INT_CODE_CMD_FINISHED 0x00000005 46 #define MWL8K_HIU_SCRATCH 0x00000c40 47 48 /* Host->device communications */ 49 #define MWL8K_HIU_H2A_INTERRUPT_EVENTS 0x00000c18 50 #define MWL8K_HIU_H2A_INTERRUPT_STATUS 0x00000c1c 51 #define MWL8K_HIU_H2A_INTERRUPT_MASK 0x00000c20 52 #define MWL8K_HIU_H2A_INTERRUPT_CLEAR_SEL 0x00000c24 53 #define MWL8K_HIU_H2A_INTERRUPT_STATUS_MASK 0x00000c28 54 #define MWL8K_H2A_INT_DUMMY (1 << 20) 55 #define MWL8K_H2A_INT_RESET (1 << 15) 56 #define MWL8K_H2A_INT_DOORBELL (1 << 1) 57 #define MWL8K_H2A_INT_PPA_READY (1 << 0) 58 59 /* Device->host communications */ 60 #define MWL8K_HIU_A2H_INTERRUPT_EVENTS 0x00000c2c 61 #define MWL8K_HIU_A2H_INTERRUPT_STATUS 0x00000c30 62 #define MWL8K_HIU_A2H_INTERRUPT_MASK 0x00000c34 63 #define MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL 0x00000c38 64 #define MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK 0x00000c3c 65 #define MWL8K_A2H_INT_DUMMY (1 << 20) 66 #define MWL8K_A2H_INT_BA_WATCHDOG (1 << 14) 67 #define MWL8K_A2H_INT_CHNL_SWITCHED (1 << 11) 68 #define MWL8K_A2H_INT_QUEUE_EMPTY (1 << 10) 69 #define MWL8K_A2H_INT_RADAR_DETECT (1 << 7) 70 #define MWL8K_A2H_INT_RADIO_ON (1 << 6) 71 #define MWL8K_A2H_INT_RADIO_OFF (1 << 5) 72 #define MWL8K_A2H_INT_MAC_EVENT (1 << 3) 73 #define MWL8K_A2H_INT_OPC_DONE (1 << 2) 74 #define MWL8K_A2H_INT_RX_READY (1 << 1) 75 #define MWL8K_A2H_INT_TX_DONE (1 << 0) 76 77 /* HW micro second timer register 78 * located at offset 0xA600. This 79 * will be used to timestamp tx 80 * packets. 81 */ 82 83 #define MWL8K_HW_TIMER_REGISTER 0x0000a600 84 #define BBU_RXRDY_CNT_REG 0x0000a860 85 #define NOK_CCA_CNT_REG 0x0000a6a0 86 #define BBU_AVG_NOISE_VAL 0x67 87 88 #define MWL8K_A2H_EVENTS (MWL8K_A2H_INT_DUMMY | \ 89 MWL8K_A2H_INT_CHNL_SWITCHED | \ 90 MWL8K_A2H_INT_QUEUE_EMPTY | \ 91 MWL8K_A2H_INT_RADAR_DETECT | \ 92 MWL8K_A2H_INT_RADIO_ON | \ 93 MWL8K_A2H_INT_RADIO_OFF | \ 94 MWL8K_A2H_INT_MAC_EVENT | \ 95 MWL8K_A2H_INT_OPC_DONE | \ 96 MWL8K_A2H_INT_RX_READY | \ 97 MWL8K_A2H_INT_TX_DONE | \ 98 MWL8K_A2H_INT_BA_WATCHDOG) 99 100 #define MWL8K_RX_QUEUES 1 101 #define MWL8K_TX_WMM_QUEUES 4 102 #define MWL8K_MAX_AMPDU_QUEUES 8 103 #define MWL8K_MAX_TX_QUEUES (MWL8K_TX_WMM_QUEUES + MWL8K_MAX_AMPDU_QUEUES) 104 #define mwl8k_tx_queues(priv) (MWL8K_TX_WMM_QUEUES + (priv)->num_ampdu_queues) 105 106 /* txpriorities are mapped with hw queues. 107 * Each hw queue has a txpriority. 108 */ 109 #define TOTAL_HW_TX_QUEUES 8 110 111 /* Each HW queue can have one AMPDU stream. 112 * But, because one of the hw queue is reserved, 113 * maximum AMPDU queues that can be created are 114 * one short of total tx queues. 115 */ 116 #define MWL8K_NUM_AMPDU_STREAMS (TOTAL_HW_TX_QUEUES - 1) 117 118 #define MWL8K_NUM_CHANS 18 119 120 struct rxd_ops { 121 int rxd_size; 122 void (*rxd_init)(void *rxd, dma_addr_t next_dma_addr); 123 void (*rxd_refill)(void *rxd, dma_addr_t addr, int len); 124 int (*rxd_process)(void *rxd, struct ieee80211_rx_status *status, 125 __le16 *qos, s8 *noise); 126 }; 127 128 struct mwl8k_device_info { 129 char *part_name; 130 char *helper_image; 131 char *fw_image_sta; 132 char *fw_image_ap; 133 struct rxd_ops *ap_rxd_ops; 134 u32 fw_api_ap; 135 }; 136 137 struct mwl8k_rx_queue { 138 int rxd_count; 139 140 /* hw receives here */ 141 int head; 142 143 /* refill descs here */ 144 int tail; 145 146 void *rxd; 147 dma_addr_t rxd_dma; 148 struct { 149 struct sk_buff *skb; 150 DEFINE_DMA_UNMAP_ADDR(dma); 151 } *buf; 152 }; 153 154 struct mwl8k_tx_queue { 155 /* hw transmits here */ 156 int head; 157 158 /* sw appends here */ 159 int tail; 160 161 unsigned int len; 162 struct mwl8k_tx_desc *txd; 163 dma_addr_t txd_dma; 164 struct sk_buff **skb; 165 }; 166 167 enum { 168 AMPDU_NO_STREAM, 169 AMPDU_STREAM_NEW, 170 AMPDU_STREAM_IN_PROGRESS, 171 AMPDU_STREAM_ACTIVE, 172 }; 173 174 struct mwl8k_ampdu_stream { 175 struct ieee80211_sta *sta; 176 u8 tid; 177 u8 state; 178 u8 idx; 179 }; 180 181 struct mwl8k_priv { 182 struct ieee80211_hw *hw; 183 struct pci_dev *pdev; 184 int irq; 185 186 struct mwl8k_device_info *device_info; 187 188 void __iomem *sram; 189 void __iomem *regs; 190 191 /* firmware */ 192 const struct firmware *fw_helper; 193 const struct firmware *fw_ucode; 194 195 /* hardware/firmware parameters */ 196 bool ap_fw; 197 struct rxd_ops *rxd_ops; 198 struct ieee80211_supported_band band_24; 199 struct ieee80211_channel channels_24[14]; 200 struct ieee80211_rate rates_24[13]; 201 struct ieee80211_supported_band band_50; 202 struct ieee80211_channel channels_50[9]; 203 struct ieee80211_rate rates_50[8]; 204 u32 ap_macids_supported; 205 u32 sta_macids_supported; 206 207 /* Ampdu stream information */ 208 u8 num_ampdu_queues; 209 spinlock_t stream_lock; 210 struct mwl8k_ampdu_stream ampdu[MWL8K_MAX_AMPDU_QUEUES]; 211 struct work_struct watchdog_ba_handle; 212 213 /* firmware access */ 214 struct mutex fw_mutex; 215 struct task_struct *fw_mutex_owner; 216 struct task_struct *hw_restart_owner; 217 int fw_mutex_depth; 218 struct completion *hostcmd_wait; 219 220 atomic_t watchdog_event_pending; 221 222 /* lock held over TX and TX reap */ 223 spinlock_t tx_lock; 224 225 /* TX quiesce completion, protected by fw_mutex and tx_lock */ 226 struct completion *tx_wait; 227 228 /* List of interfaces. */ 229 u32 macids_used; 230 struct list_head vif_list; 231 232 /* power management status cookie from firmware */ 233 u32 *cookie; 234 dma_addr_t cookie_dma; 235 236 u16 num_mcaddrs; 237 u8 hw_rev; 238 u32 fw_rev; 239 u32 caps; 240 241 /* 242 * Running count of TX packets in flight, to avoid 243 * iterating over the transmit rings each time. 244 */ 245 int pending_tx_pkts; 246 247 struct mwl8k_rx_queue rxq[MWL8K_RX_QUEUES]; 248 struct mwl8k_tx_queue txq[MWL8K_MAX_TX_QUEUES]; 249 u32 txq_offset[MWL8K_MAX_TX_QUEUES]; 250 251 bool radio_on; 252 bool radio_short_preamble; 253 bool sniffer_enabled; 254 bool wmm_enabled; 255 256 /* XXX need to convert this to handle multiple interfaces */ 257 bool capture_beacon; 258 u8 capture_bssid[ETH_ALEN]; 259 struct sk_buff *beacon_skb; 260 261 /* 262 * This FJ worker has to be global as it is scheduled from the 263 * RX handler. At this point we don't know which interface it 264 * belongs to until the list of bssids waiting to complete join 265 * is checked. 266 */ 267 struct work_struct finalize_join_worker; 268 269 /* Tasklet to perform TX reclaim. */ 270 struct tasklet_struct poll_tx_task; 271 272 /* Tasklet to perform RX. */ 273 struct tasklet_struct poll_rx_task; 274 275 /* Most recently reported noise in dBm */ 276 s8 noise; 277 278 /* 279 * preserve the queue configurations so they can be restored if/when 280 * the firmware image is swapped. 281 */ 282 struct ieee80211_tx_queue_params wmm_params[MWL8K_TX_WMM_QUEUES]; 283 284 /* To perform the task of reloading the firmware */ 285 struct work_struct fw_reload; 286 bool hw_restart_in_progress; 287 288 /* async firmware loading state */ 289 unsigned fw_state; 290 char *fw_pref; 291 char *fw_alt; 292 bool is_8764; 293 struct completion firmware_loading_complete; 294 295 /* bitmap of running BSSes */ 296 u32 running_bsses; 297 298 /* ACS related */ 299 bool sw_scan_start; 300 struct ieee80211_channel *acs_chan; 301 unsigned long channel_time; 302 struct survey_info survey[MWL8K_NUM_CHANS]; 303 }; 304 305 #define MAX_WEP_KEY_LEN 13 306 #define NUM_WEP_KEYS 4 307 308 /* Per interface specific private data */ 309 struct mwl8k_vif { 310 struct list_head list; 311 struct ieee80211_vif *vif; 312 313 /* Firmware macid for this vif. */ 314 int macid; 315 316 /* Non AMPDU sequence number assigned by driver. */ 317 u16 seqno; 318 319 /* Saved WEP keys */ 320 struct { 321 u8 enabled; 322 u8 key[sizeof(struct ieee80211_key_conf) + MAX_WEP_KEY_LEN]; 323 } wep_key_conf[NUM_WEP_KEYS]; 324 325 /* BSSID */ 326 u8 bssid[ETH_ALEN]; 327 328 /* A flag to indicate is HW crypto is enabled for this bssid */ 329 bool is_hw_crypto_enabled; 330 }; 331 #define MWL8K_VIF(_vif) ((struct mwl8k_vif *)&((_vif)->drv_priv)) 332 #define IEEE80211_KEY_CONF(_u8) ((struct ieee80211_key_conf *)(_u8)) 333 334 struct tx_traffic_info { 335 u32 start_time; 336 u32 pkts; 337 }; 338 339 #define MWL8K_MAX_TID 8 340 struct mwl8k_sta { 341 /* Index into station database. Returned by UPDATE_STADB. */ 342 u8 peer_id; 343 u8 is_ampdu_allowed; 344 struct tx_traffic_info tx_stats[MWL8K_MAX_TID]; 345 }; 346 #define MWL8K_STA(_sta) ((struct mwl8k_sta *)&((_sta)->drv_priv)) 347 348 static const struct ieee80211_channel mwl8k_channels_24[] = { 349 { .band = NL80211_BAND_2GHZ, .center_freq = 2412, .hw_value = 1, }, 350 { .band = NL80211_BAND_2GHZ, .center_freq = 2417, .hw_value = 2, }, 351 { .band = NL80211_BAND_2GHZ, .center_freq = 2422, .hw_value = 3, }, 352 { .band = NL80211_BAND_2GHZ, .center_freq = 2427, .hw_value = 4, }, 353 { .band = NL80211_BAND_2GHZ, .center_freq = 2432, .hw_value = 5, }, 354 { .band = NL80211_BAND_2GHZ, .center_freq = 2437, .hw_value = 6, }, 355 { .band = NL80211_BAND_2GHZ, .center_freq = 2442, .hw_value = 7, }, 356 { .band = NL80211_BAND_2GHZ, .center_freq = 2447, .hw_value = 8, }, 357 { .band = NL80211_BAND_2GHZ, .center_freq = 2452, .hw_value = 9, }, 358 { .band = NL80211_BAND_2GHZ, .center_freq = 2457, .hw_value = 10, }, 359 { .band = NL80211_BAND_2GHZ, .center_freq = 2462, .hw_value = 11, }, 360 { .band = NL80211_BAND_2GHZ, .center_freq = 2467, .hw_value = 12, }, 361 { .band = NL80211_BAND_2GHZ, .center_freq = 2472, .hw_value = 13, }, 362 { .band = NL80211_BAND_2GHZ, .center_freq = 2484, .hw_value = 14, }, 363 }; 364 365 static const struct ieee80211_rate mwl8k_rates_24[] = { 366 { .bitrate = 10, .hw_value = 2, }, 367 { .bitrate = 20, .hw_value = 4, }, 368 { .bitrate = 55, .hw_value = 11, }, 369 { .bitrate = 110, .hw_value = 22, }, 370 { .bitrate = 220, .hw_value = 44, }, 371 { .bitrate = 60, .hw_value = 12, }, 372 { .bitrate = 90, .hw_value = 18, }, 373 { .bitrate = 120, .hw_value = 24, }, 374 { .bitrate = 180, .hw_value = 36, }, 375 { .bitrate = 240, .hw_value = 48, }, 376 { .bitrate = 360, .hw_value = 72, }, 377 { .bitrate = 480, .hw_value = 96, }, 378 { .bitrate = 540, .hw_value = 108, }, 379 }; 380 381 static const struct ieee80211_channel mwl8k_channels_50[] = { 382 { .band = NL80211_BAND_5GHZ, .center_freq = 5180, .hw_value = 36, }, 383 { .band = NL80211_BAND_5GHZ, .center_freq = 5200, .hw_value = 40, }, 384 { .band = NL80211_BAND_5GHZ, .center_freq = 5220, .hw_value = 44, }, 385 { .band = NL80211_BAND_5GHZ, .center_freq = 5240, .hw_value = 48, }, 386 { .band = NL80211_BAND_5GHZ, .center_freq = 5745, .hw_value = 149, }, 387 { .band = NL80211_BAND_5GHZ, .center_freq = 5765, .hw_value = 153, }, 388 { .band = NL80211_BAND_5GHZ, .center_freq = 5785, .hw_value = 157, }, 389 { .band = NL80211_BAND_5GHZ, .center_freq = 5805, .hw_value = 161, }, 390 { .band = NL80211_BAND_5GHZ, .center_freq = 5825, .hw_value = 165, }, 391 }; 392 393 static const struct ieee80211_rate mwl8k_rates_50[] = { 394 { .bitrate = 60, .hw_value = 12, }, 395 { .bitrate = 90, .hw_value = 18, }, 396 { .bitrate = 120, .hw_value = 24, }, 397 { .bitrate = 180, .hw_value = 36, }, 398 { .bitrate = 240, .hw_value = 48, }, 399 { .bitrate = 360, .hw_value = 72, }, 400 { .bitrate = 480, .hw_value = 96, }, 401 { .bitrate = 540, .hw_value = 108, }, 402 }; 403 404 /* Set or get info from Firmware */ 405 #define MWL8K_CMD_GET 0x0000 406 #define MWL8K_CMD_SET 0x0001 407 #define MWL8K_CMD_SET_LIST 0x0002 408 409 /* Firmware command codes */ 410 #define MWL8K_CMD_CODE_DNLD 0x0001 411 #define MWL8K_CMD_GET_HW_SPEC 0x0003 412 #define MWL8K_CMD_SET_HW_SPEC 0x0004 413 #define MWL8K_CMD_MAC_MULTICAST_ADR 0x0010 414 #define MWL8K_CMD_GET_STAT 0x0014 415 #define MWL8K_CMD_BBP_REG_ACCESS 0x001a 416 #define MWL8K_CMD_RADIO_CONTROL 0x001c 417 #define MWL8K_CMD_RF_TX_POWER 0x001e 418 #define MWL8K_CMD_TX_POWER 0x001f 419 #define MWL8K_CMD_RF_ANTENNA 0x0020 420 #define MWL8K_CMD_SET_BEACON 0x0100 /* per-vif */ 421 #define MWL8K_CMD_SET_PRE_SCAN 0x0107 422 #define MWL8K_CMD_SET_POST_SCAN 0x0108 423 #define MWL8K_CMD_SET_RF_CHANNEL 0x010a 424 #define MWL8K_CMD_SET_AID 0x010d 425 #define MWL8K_CMD_SET_RATE 0x0110 426 #define MWL8K_CMD_SET_FINALIZE_JOIN 0x0111 427 #define MWL8K_CMD_RTS_THRESHOLD 0x0113 428 #define MWL8K_CMD_SET_SLOT 0x0114 429 #define MWL8K_CMD_SET_EDCA_PARAMS 0x0115 430 #define MWL8K_CMD_SET_WMM_MODE 0x0123 431 #define MWL8K_CMD_MIMO_CONFIG 0x0125 432 #define MWL8K_CMD_USE_FIXED_RATE 0x0126 433 #define MWL8K_CMD_ENABLE_SNIFFER 0x0150 434 #define MWL8K_CMD_SET_MAC_ADDR 0x0202 /* per-vif */ 435 #define MWL8K_CMD_SET_RATEADAPT_MODE 0x0203 436 #define MWL8K_CMD_GET_WATCHDOG_BITMAP 0x0205 437 #define MWL8K_CMD_DEL_MAC_ADDR 0x0206 /* per-vif */ 438 #define MWL8K_CMD_BSS_START 0x1100 /* per-vif */ 439 #define MWL8K_CMD_SET_NEW_STN 0x1111 /* per-vif */ 440 #define MWL8K_CMD_UPDATE_ENCRYPTION 0x1122 /* per-vif */ 441 #define MWL8K_CMD_UPDATE_STADB 0x1123 442 #define MWL8K_CMD_BASTREAM 0x1125 443 444 #define MWL8K_LEGACY_5G_RATE_OFFSET \ 445 (ARRAY_SIZE(mwl8k_rates_24) - ARRAY_SIZE(mwl8k_rates_50)) 446 447 static const char *mwl8k_cmd_name(__le16 cmd, char *buf, int bufsize) 448 { 449 u16 command = le16_to_cpu(cmd); 450 451 #define MWL8K_CMDNAME(x) case MWL8K_CMD_##x: do {\ 452 snprintf(buf, bufsize, "%s", #x);\ 453 return buf;\ 454 } while (0) 455 switch (command & ~0x8000) { 456 MWL8K_CMDNAME(CODE_DNLD); 457 MWL8K_CMDNAME(GET_HW_SPEC); 458 MWL8K_CMDNAME(SET_HW_SPEC); 459 MWL8K_CMDNAME(MAC_MULTICAST_ADR); 460 MWL8K_CMDNAME(GET_STAT); 461 MWL8K_CMDNAME(RADIO_CONTROL); 462 MWL8K_CMDNAME(RF_TX_POWER); 463 MWL8K_CMDNAME(TX_POWER); 464 MWL8K_CMDNAME(RF_ANTENNA); 465 MWL8K_CMDNAME(SET_BEACON); 466 MWL8K_CMDNAME(SET_PRE_SCAN); 467 MWL8K_CMDNAME(SET_POST_SCAN); 468 MWL8K_CMDNAME(SET_RF_CHANNEL); 469 MWL8K_CMDNAME(SET_AID); 470 MWL8K_CMDNAME(SET_RATE); 471 MWL8K_CMDNAME(SET_FINALIZE_JOIN); 472 MWL8K_CMDNAME(RTS_THRESHOLD); 473 MWL8K_CMDNAME(SET_SLOT); 474 MWL8K_CMDNAME(SET_EDCA_PARAMS); 475 MWL8K_CMDNAME(SET_WMM_MODE); 476 MWL8K_CMDNAME(MIMO_CONFIG); 477 MWL8K_CMDNAME(USE_FIXED_RATE); 478 MWL8K_CMDNAME(ENABLE_SNIFFER); 479 MWL8K_CMDNAME(SET_MAC_ADDR); 480 MWL8K_CMDNAME(SET_RATEADAPT_MODE); 481 MWL8K_CMDNAME(BSS_START); 482 MWL8K_CMDNAME(SET_NEW_STN); 483 MWL8K_CMDNAME(UPDATE_ENCRYPTION); 484 MWL8K_CMDNAME(UPDATE_STADB); 485 MWL8K_CMDNAME(BASTREAM); 486 MWL8K_CMDNAME(GET_WATCHDOG_BITMAP); 487 default: 488 snprintf(buf, bufsize, "0x%x", cmd); 489 } 490 #undef MWL8K_CMDNAME 491 492 return buf; 493 } 494 495 /* Hardware and firmware reset */ 496 static void mwl8k_hw_reset(struct mwl8k_priv *priv) 497 { 498 iowrite32(MWL8K_H2A_INT_RESET, 499 priv->regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS); 500 iowrite32(MWL8K_H2A_INT_RESET, 501 priv->regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS); 502 msleep(20); 503 } 504 505 /* Release fw image */ 506 static void mwl8k_release_fw(const struct firmware **fw) 507 { 508 if (*fw == NULL) 509 return; 510 release_firmware(*fw); 511 *fw = NULL; 512 } 513 514 static void mwl8k_release_firmware(struct mwl8k_priv *priv) 515 { 516 mwl8k_release_fw(&priv->fw_ucode); 517 mwl8k_release_fw(&priv->fw_helper); 518 } 519 520 /* states for asynchronous f/w loading */ 521 static void mwl8k_fw_state_machine(const struct firmware *fw, void *context); 522 enum { 523 FW_STATE_INIT = 0, 524 FW_STATE_LOADING_PREF, 525 FW_STATE_LOADING_ALT, 526 FW_STATE_ERROR, 527 }; 528 529 /* Request fw image */ 530 static int mwl8k_request_fw(struct mwl8k_priv *priv, 531 const char *fname, const struct firmware **fw, 532 bool nowait) 533 { 534 /* release current image */ 535 if (*fw != NULL) 536 mwl8k_release_fw(fw); 537 538 if (nowait) 539 return request_firmware_nowait(THIS_MODULE, 1, fname, 540 &priv->pdev->dev, GFP_KERNEL, 541 priv, mwl8k_fw_state_machine); 542 else 543 return request_firmware(fw, fname, &priv->pdev->dev); 544 } 545 546 static int mwl8k_request_firmware(struct mwl8k_priv *priv, char *fw_image, 547 bool nowait) 548 { 549 struct mwl8k_device_info *di = priv->device_info; 550 int rc; 551 552 if (di->helper_image != NULL) { 553 if (nowait) 554 rc = mwl8k_request_fw(priv, di->helper_image, 555 &priv->fw_helper, true); 556 else 557 rc = mwl8k_request_fw(priv, di->helper_image, 558 &priv->fw_helper, false); 559 if (rc) 560 printk(KERN_ERR "%s: Error requesting helper fw %s\n", 561 pci_name(priv->pdev), di->helper_image); 562 563 if (rc || nowait) 564 return rc; 565 } 566 567 if (nowait) { 568 /* 569 * if we get here, no helper image is needed. Skip the 570 * FW_STATE_INIT state. 571 */ 572 priv->fw_state = FW_STATE_LOADING_PREF; 573 rc = mwl8k_request_fw(priv, fw_image, 574 &priv->fw_ucode, 575 true); 576 } else 577 rc = mwl8k_request_fw(priv, fw_image, 578 &priv->fw_ucode, false); 579 if (rc) { 580 printk(KERN_ERR "%s: Error requesting firmware file %s\n", 581 pci_name(priv->pdev), fw_image); 582 mwl8k_release_fw(&priv->fw_helper); 583 return rc; 584 } 585 586 return 0; 587 } 588 589 struct mwl8k_cmd_pkt { 590 __le16 code; 591 __le16 length; 592 __u8 seq_num; 593 __u8 macid; 594 __le16 result; 595 char payload[]; 596 } __packed; 597 598 /* 599 * Firmware loading. 600 */ 601 static int 602 mwl8k_send_fw_load_cmd(struct mwl8k_priv *priv, void *data, int length) 603 { 604 void __iomem *regs = priv->regs; 605 dma_addr_t dma_addr; 606 int loops; 607 608 dma_addr = dma_map_single(&priv->pdev->dev, data, length, 609 DMA_TO_DEVICE); 610 if (dma_mapping_error(&priv->pdev->dev, dma_addr)) 611 return -ENOMEM; 612 613 iowrite32(dma_addr, regs + MWL8K_HIU_GEN_PTR); 614 iowrite32(0, regs + MWL8K_HIU_INT_CODE); 615 iowrite32(MWL8K_H2A_INT_DOORBELL, 616 regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS); 617 iowrite32(MWL8K_H2A_INT_DUMMY, 618 regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS); 619 620 loops = 1000; 621 do { 622 u32 int_code; 623 if (priv->is_8764) { 624 int_code = ioread32(regs + 625 MWL8K_HIU_H2A_INTERRUPT_STATUS); 626 if (int_code == 0) 627 break; 628 } else { 629 int_code = ioread32(regs + MWL8K_HIU_INT_CODE); 630 if (int_code == MWL8K_INT_CODE_CMD_FINISHED) { 631 iowrite32(0, regs + MWL8K_HIU_INT_CODE); 632 break; 633 } 634 } 635 cond_resched(); 636 udelay(1); 637 } while (--loops); 638 639 dma_unmap_single(&priv->pdev->dev, dma_addr, length, DMA_TO_DEVICE); 640 641 return loops ? 0 : -ETIMEDOUT; 642 } 643 644 static int mwl8k_load_fw_image(struct mwl8k_priv *priv, 645 const u8 *data, size_t length) 646 { 647 struct mwl8k_cmd_pkt *cmd; 648 int done; 649 int rc = 0; 650 651 cmd = kmalloc(sizeof(*cmd) + 256, GFP_KERNEL); 652 if (cmd == NULL) 653 return -ENOMEM; 654 655 cmd->code = cpu_to_le16(MWL8K_CMD_CODE_DNLD); 656 cmd->seq_num = 0; 657 cmd->macid = 0; 658 cmd->result = 0; 659 660 done = 0; 661 while (length) { 662 int block_size = length > 256 ? 256 : length; 663 664 memcpy(cmd->payload, data + done, block_size); 665 cmd->length = cpu_to_le16(block_size); 666 667 rc = mwl8k_send_fw_load_cmd(priv, cmd, 668 sizeof(*cmd) + block_size); 669 if (rc) 670 break; 671 672 done += block_size; 673 length -= block_size; 674 } 675 676 if (!rc) { 677 cmd->length = 0; 678 rc = mwl8k_send_fw_load_cmd(priv, cmd, sizeof(*cmd)); 679 } 680 681 kfree(cmd); 682 683 return rc; 684 } 685 686 static int mwl8k_feed_fw_image(struct mwl8k_priv *priv, 687 const u8 *data, size_t length) 688 { 689 unsigned char *buffer; 690 int may_continue, rc = 0; 691 u32 done, prev_block_size; 692 693 buffer = kmalloc(1024, GFP_KERNEL); 694 if (buffer == NULL) 695 return -ENOMEM; 696 697 done = 0; 698 prev_block_size = 0; 699 may_continue = 1000; 700 while (may_continue > 0) { 701 u32 block_size; 702 703 block_size = ioread32(priv->regs + MWL8K_HIU_SCRATCH); 704 if (block_size & 1) { 705 block_size &= ~1; 706 may_continue--; 707 } else { 708 done += prev_block_size; 709 length -= prev_block_size; 710 } 711 712 if (block_size > 1024 || block_size > length) { 713 rc = -EOVERFLOW; 714 break; 715 } 716 717 if (length == 0) { 718 rc = 0; 719 break; 720 } 721 722 if (block_size == 0) { 723 rc = -EPROTO; 724 may_continue--; 725 udelay(1); 726 continue; 727 } 728 729 prev_block_size = block_size; 730 memcpy(buffer, data + done, block_size); 731 732 rc = mwl8k_send_fw_load_cmd(priv, buffer, block_size); 733 if (rc) 734 break; 735 } 736 737 if (!rc && length != 0) 738 rc = -EREMOTEIO; 739 740 kfree(buffer); 741 742 return rc; 743 } 744 745 static int mwl8k_load_firmware(struct ieee80211_hw *hw) 746 { 747 struct mwl8k_priv *priv = hw->priv; 748 const struct firmware *fw = priv->fw_ucode; 749 int rc; 750 int loops; 751 752 if (!memcmp(fw->data, "\x01\x00\x00\x00", 4) && !priv->is_8764) { 753 const struct firmware *helper = priv->fw_helper; 754 755 if (helper == NULL) { 756 printk(KERN_ERR "%s: helper image needed but none " 757 "given\n", pci_name(priv->pdev)); 758 return -EINVAL; 759 } 760 761 rc = mwl8k_load_fw_image(priv, helper->data, helper->size); 762 if (rc) { 763 printk(KERN_ERR "%s: unable to load firmware " 764 "helper image\n", pci_name(priv->pdev)); 765 return rc; 766 } 767 msleep(20); 768 769 rc = mwl8k_feed_fw_image(priv, fw->data, fw->size); 770 } else { 771 if (priv->is_8764) 772 rc = mwl8k_feed_fw_image(priv, fw->data, fw->size); 773 else 774 rc = mwl8k_load_fw_image(priv, fw->data, fw->size); 775 } 776 777 if (rc) { 778 printk(KERN_ERR "%s: unable to load firmware image\n", 779 pci_name(priv->pdev)); 780 return rc; 781 } 782 783 iowrite32(MWL8K_MODE_STA, priv->regs + MWL8K_HIU_GEN_PTR); 784 785 loops = 500000; 786 do { 787 u32 ready_code; 788 789 ready_code = ioread32(priv->regs + MWL8K_HIU_INT_CODE); 790 if (ready_code == MWL8K_FWAP_READY) { 791 priv->ap_fw = true; 792 break; 793 } else if (ready_code == MWL8K_FWSTA_READY) { 794 priv->ap_fw = false; 795 break; 796 } 797 798 cond_resched(); 799 udelay(1); 800 } while (--loops); 801 802 return loops ? 0 : -ETIMEDOUT; 803 } 804 805 806 /* DMA header used by firmware and hardware. */ 807 struct mwl8k_dma_data { 808 __le16 fwlen; 809 struct ieee80211_hdr wh; 810 char data[]; 811 } __packed __aligned(2); 812 813 /* Routines to add/remove DMA header from skb. */ 814 static inline void mwl8k_remove_dma_header(struct sk_buff *skb, __le16 qos) 815 { 816 struct mwl8k_dma_data *tr; 817 int hdrlen; 818 819 tr = (struct mwl8k_dma_data *)skb->data; 820 hdrlen = ieee80211_hdrlen(tr->wh.frame_control); 821 822 if (hdrlen != sizeof(tr->wh)) { 823 if (ieee80211_is_data_qos(tr->wh.frame_control)) { 824 memmove(tr->data - hdrlen, &tr->wh, hdrlen - 2); 825 *((__le16 *)(tr->data - 2)) = qos; 826 } else { 827 memmove(tr->data - hdrlen, &tr->wh, hdrlen); 828 } 829 } 830 831 if (hdrlen != sizeof(*tr)) 832 skb_pull(skb, sizeof(*tr) - hdrlen); 833 } 834 835 #define REDUCED_TX_HEADROOM 8 836 837 static void 838 mwl8k_add_dma_header(struct mwl8k_priv *priv, struct sk_buff *skb, 839 int head_pad, int tail_pad) 840 { 841 struct ieee80211_hdr *wh; 842 int hdrlen; 843 int reqd_hdrlen; 844 struct mwl8k_dma_data *tr; 845 846 /* 847 * Add a firmware DMA header; the firmware requires that we 848 * present a 2-byte payload length followed by a 4-address 849 * header (without QoS field), followed (optionally) by any 850 * WEP/ExtIV header (but only filled in for CCMP). 851 */ 852 wh = (struct ieee80211_hdr *)skb->data; 853 854 hdrlen = ieee80211_hdrlen(wh->frame_control); 855 856 /* 857 * Check if skb_resize is required because of 858 * tx_headroom adjustment. 859 */ 860 if (priv->ap_fw && (hdrlen < (sizeof(struct ieee80211_cts) 861 + REDUCED_TX_HEADROOM))) { 862 if (pskb_expand_head(skb, REDUCED_TX_HEADROOM, 0, GFP_ATOMIC)) { 863 864 wiphy_err(priv->hw->wiphy, 865 "Failed to reallocate TX buffer\n"); 866 return; 867 } 868 skb->truesize += REDUCED_TX_HEADROOM; 869 } 870 871 reqd_hdrlen = sizeof(*tr) + head_pad; 872 873 if (hdrlen != reqd_hdrlen) 874 skb_push(skb, reqd_hdrlen - hdrlen); 875 876 if (ieee80211_is_data_qos(wh->frame_control)) 877 hdrlen -= IEEE80211_QOS_CTL_LEN; 878 879 tr = (struct mwl8k_dma_data *)skb->data; 880 if (wh != &tr->wh) 881 memmove(&tr->wh, wh, hdrlen); 882 if (hdrlen != sizeof(tr->wh)) 883 memset(((void *)&tr->wh) + hdrlen, 0, sizeof(tr->wh) - hdrlen); 884 885 /* 886 * Firmware length is the length of the fully formed "802.11 887 * payload". That is, everything except for the 802.11 header. 888 * This includes all crypto material including the MIC. 889 */ 890 tr->fwlen = cpu_to_le16(skb->len - sizeof(*tr) + tail_pad); 891 } 892 893 static void mwl8k_encapsulate_tx_frame(struct mwl8k_priv *priv, 894 struct sk_buff *skb) 895 { 896 struct ieee80211_hdr *wh; 897 struct ieee80211_tx_info *tx_info; 898 struct ieee80211_key_conf *key_conf; 899 int data_pad; 900 int head_pad = 0; 901 902 wh = (struct ieee80211_hdr *)skb->data; 903 904 tx_info = IEEE80211_SKB_CB(skb); 905 906 key_conf = NULL; 907 if (ieee80211_is_data(wh->frame_control)) 908 key_conf = tx_info->control.hw_key; 909 910 /* 911 * Make sure the packet header is in the DMA header format (4-address 912 * without QoS), and add head & tail padding when HW crypto is enabled. 913 * 914 * We have the following trailer padding requirements: 915 * - WEP: 4 trailer bytes (ICV) 916 * - TKIP: 12 trailer bytes (8 MIC + 4 ICV) 917 * - CCMP: 8 trailer bytes (MIC) 918 */ 919 data_pad = 0; 920 if (key_conf != NULL) { 921 head_pad = key_conf->iv_len; 922 switch (key_conf->cipher) { 923 case WLAN_CIPHER_SUITE_WEP40: 924 case WLAN_CIPHER_SUITE_WEP104: 925 data_pad = 4; 926 break; 927 case WLAN_CIPHER_SUITE_TKIP: 928 data_pad = 12; 929 break; 930 case WLAN_CIPHER_SUITE_CCMP: 931 data_pad = 8; 932 break; 933 } 934 } 935 mwl8k_add_dma_header(priv, skb, head_pad, data_pad); 936 } 937 938 /* 939 * Packet reception for 88w8366/88w8764 AP firmware. 940 */ 941 struct mwl8k_rxd_ap { 942 __le16 pkt_len; 943 __u8 sq2; 944 __u8 rate; 945 __le32 pkt_phys_addr; 946 __le32 next_rxd_phys_addr; 947 __le16 qos_control; 948 __le16 htsig2; 949 __le32 hw_rssi_info; 950 __le32 hw_noise_floor_info; 951 __u8 noise_floor; 952 __u8 pad0[3]; 953 __u8 rssi; 954 __u8 rx_status; 955 __u8 channel; 956 __u8 rx_ctrl; 957 } __packed; 958 959 #define MWL8K_AP_RATE_INFO_MCS_FORMAT 0x80 960 #define MWL8K_AP_RATE_INFO_40MHZ 0x40 961 #define MWL8K_AP_RATE_INFO_RATEID(x) ((x) & 0x3f) 962 963 #define MWL8K_AP_RX_CTRL_OWNED_BY_HOST 0x80 964 965 /* 8366/8764 AP rx_status bits */ 966 #define MWL8K_AP_RXSTAT_DECRYPT_ERR_MASK 0x80 967 #define MWL8K_AP_RXSTAT_GENERAL_DECRYPT_ERR 0xFF 968 #define MWL8K_AP_RXSTAT_TKIP_DECRYPT_MIC_ERR 0x02 969 #define MWL8K_AP_RXSTAT_WEP_DECRYPT_ICV_ERR 0x04 970 #define MWL8K_AP_RXSTAT_TKIP_DECRYPT_ICV_ERR 0x08 971 972 static void mwl8k_rxd_ap_init(void *_rxd, dma_addr_t next_dma_addr) 973 { 974 struct mwl8k_rxd_ap *rxd = _rxd; 975 976 rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr); 977 rxd->rx_ctrl = MWL8K_AP_RX_CTRL_OWNED_BY_HOST; 978 } 979 980 static void mwl8k_rxd_ap_refill(void *_rxd, dma_addr_t addr, int len) 981 { 982 struct mwl8k_rxd_ap *rxd = _rxd; 983 984 rxd->pkt_len = cpu_to_le16(len); 985 rxd->pkt_phys_addr = cpu_to_le32(addr); 986 wmb(); 987 rxd->rx_ctrl = 0; 988 } 989 990 static int 991 mwl8k_rxd_ap_process(void *_rxd, struct ieee80211_rx_status *status, 992 __le16 *qos, s8 *noise) 993 { 994 struct mwl8k_rxd_ap *rxd = _rxd; 995 996 if (!(rxd->rx_ctrl & MWL8K_AP_RX_CTRL_OWNED_BY_HOST)) 997 return -1; 998 rmb(); 999 1000 memset(status, 0, sizeof(*status)); 1001 1002 status->signal = -rxd->rssi; 1003 *noise = -rxd->noise_floor; 1004 1005 if (rxd->rate & MWL8K_AP_RATE_INFO_MCS_FORMAT) { 1006 status->encoding = RX_ENC_HT; 1007 if (rxd->rate & MWL8K_AP_RATE_INFO_40MHZ) 1008 status->bw = RATE_INFO_BW_40; 1009 status->rate_idx = MWL8K_AP_RATE_INFO_RATEID(rxd->rate); 1010 } else { 1011 int i; 1012 1013 for (i = 0; i < ARRAY_SIZE(mwl8k_rates_24); i++) { 1014 if (mwl8k_rates_24[i].hw_value == rxd->rate) { 1015 status->rate_idx = i; 1016 break; 1017 } 1018 } 1019 } 1020 1021 if (rxd->channel > 14) { 1022 status->band = NL80211_BAND_5GHZ; 1023 if (!(status->encoding == RX_ENC_HT) && 1024 status->rate_idx >= MWL8K_LEGACY_5G_RATE_OFFSET) 1025 status->rate_idx -= MWL8K_LEGACY_5G_RATE_OFFSET; 1026 } else { 1027 status->band = NL80211_BAND_2GHZ; 1028 } 1029 status->freq = ieee80211_channel_to_frequency(rxd->channel, 1030 status->band); 1031 1032 *qos = rxd->qos_control; 1033 1034 if ((rxd->rx_status != MWL8K_AP_RXSTAT_GENERAL_DECRYPT_ERR) && 1035 (rxd->rx_status & MWL8K_AP_RXSTAT_DECRYPT_ERR_MASK) && 1036 (rxd->rx_status & MWL8K_AP_RXSTAT_TKIP_DECRYPT_MIC_ERR)) 1037 status->flag |= RX_FLAG_MMIC_ERROR; 1038 1039 return le16_to_cpu(rxd->pkt_len); 1040 } 1041 1042 static struct rxd_ops rxd_ap_ops = { 1043 .rxd_size = sizeof(struct mwl8k_rxd_ap), 1044 .rxd_init = mwl8k_rxd_ap_init, 1045 .rxd_refill = mwl8k_rxd_ap_refill, 1046 .rxd_process = mwl8k_rxd_ap_process, 1047 }; 1048 1049 /* 1050 * Packet reception for STA firmware. 1051 */ 1052 struct mwl8k_rxd_sta { 1053 __le16 pkt_len; 1054 __u8 link_quality; 1055 __u8 noise_level; 1056 __le32 pkt_phys_addr; 1057 __le32 next_rxd_phys_addr; 1058 __le16 qos_control; 1059 __le16 rate_info; 1060 __le32 pad0[4]; 1061 __u8 rssi; 1062 __u8 channel; 1063 __le16 pad1; 1064 __u8 rx_ctrl; 1065 __u8 rx_status; 1066 __u8 pad2[2]; 1067 } __packed; 1068 1069 #define MWL8K_STA_RATE_INFO_SHORTPRE 0x8000 1070 #define MWL8K_STA_RATE_INFO_ANTSELECT(x) (((x) >> 11) & 0x3) 1071 #define MWL8K_STA_RATE_INFO_RATEID(x) (((x) >> 3) & 0x3f) 1072 #define MWL8K_STA_RATE_INFO_40MHZ 0x0004 1073 #define MWL8K_STA_RATE_INFO_SHORTGI 0x0002 1074 #define MWL8K_STA_RATE_INFO_MCS_FORMAT 0x0001 1075 1076 #define MWL8K_STA_RX_CTRL_OWNED_BY_HOST 0x02 1077 #define MWL8K_STA_RX_CTRL_DECRYPT_ERROR 0x04 1078 /* ICV=0 or MIC=1 */ 1079 #define MWL8K_STA_RX_CTRL_DEC_ERR_TYPE 0x08 1080 /* Key is uploaded only in failure case */ 1081 #define MWL8K_STA_RX_CTRL_KEY_INDEX 0x30 1082 1083 static void mwl8k_rxd_sta_init(void *_rxd, dma_addr_t next_dma_addr) 1084 { 1085 struct mwl8k_rxd_sta *rxd = _rxd; 1086 1087 rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr); 1088 rxd->rx_ctrl = MWL8K_STA_RX_CTRL_OWNED_BY_HOST; 1089 } 1090 1091 static void mwl8k_rxd_sta_refill(void *_rxd, dma_addr_t addr, int len) 1092 { 1093 struct mwl8k_rxd_sta *rxd = _rxd; 1094 1095 rxd->pkt_len = cpu_to_le16(len); 1096 rxd->pkt_phys_addr = cpu_to_le32(addr); 1097 wmb(); 1098 rxd->rx_ctrl = 0; 1099 } 1100 1101 static int 1102 mwl8k_rxd_sta_process(void *_rxd, struct ieee80211_rx_status *status, 1103 __le16 *qos, s8 *noise) 1104 { 1105 struct mwl8k_rxd_sta *rxd = _rxd; 1106 u16 rate_info; 1107 1108 if (!(rxd->rx_ctrl & MWL8K_STA_RX_CTRL_OWNED_BY_HOST)) 1109 return -1; 1110 rmb(); 1111 1112 rate_info = le16_to_cpu(rxd->rate_info); 1113 1114 memset(status, 0, sizeof(*status)); 1115 1116 status->signal = -rxd->rssi; 1117 *noise = -rxd->noise_level; 1118 status->antenna = MWL8K_STA_RATE_INFO_ANTSELECT(rate_info); 1119 status->rate_idx = MWL8K_STA_RATE_INFO_RATEID(rate_info); 1120 1121 if (rate_info & MWL8K_STA_RATE_INFO_SHORTPRE) 1122 status->enc_flags |= RX_ENC_FLAG_SHORTPRE; 1123 if (rate_info & MWL8K_STA_RATE_INFO_40MHZ) 1124 status->bw = RATE_INFO_BW_40; 1125 if (rate_info & MWL8K_STA_RATE_INFO_SHORTGI) 1126 status->enc_flags |= RX_ENC_FLAG_SHORT_GI; 1127 if (rate_info & MWL8K_STA_RATE_INFO_MCS_FORMAT) 1128 status->encoding = RX_ENC_HT; 1129 1130 if (rxd->channel > 14) { 1131 status->band = NL80211_BAND_5GHZ; 1132 if (!(status->encoding == RX_ENC_HT) && 1133 status->rate_idx >= MWL8K_LEGACY_5G_RATE_OFFSET) 1134 status->rate_idx -= MWL8K_LEGACY_5G_RATE_OFFSET; 1135 } else { 1136 status->band = NL80211_BAND_2GHZ; 1137 } 1138 status->freq = ieee80211_channel_to_frequency(rxd->channel, 1139 status->band); 1140 1141 *qos = rxd->qos_control; 1142 if ((rxd->rx_ctrl & MWL8K_STA_RX_CTRL_DECRYPT_ERROR) && 1143 (rxd->rx_ctrl & MWL8K_STA_RX_CTRL_DEC_ERR_TYPE)) 1144 status->flag |= RX_FLAG_MMIC_ERROR; 1145 1146 return le16_to_cpu(rxd->pkt_len); 1147 } 1148 1149 static struct rxd_ops rxd_sta_ops = { 1150 .rxd_size = sizeof(struct mwl8k_rxd_sta), 1151 .rxd_init = mwl8k_rxd_sta_init, 1152 .rxd_refill = mwl8k_rxd_sta_refill, 1153 .rxd_process = mwl8k_rxd_sta_process, 1154 }; 1155 1156 1157 #define MWL8K_RX_DESCS 256 1158 #define MWL8K_RX_MAXSZ 3800 1159 1160 static int mwl8k_rxq_init(struct ieee80211_hw *hw, int index) 1161 { 1162 struct mwl8k_priv *priv = hw->priv; 1163 struct mwl8k_rx_queue *rxq = priv->rxq + index; 1164 int size; 1165 int i; 1166 1167 rxq->rxd_count = 0; 1168 rxq->head = 0; 1169 rxq->tail = 0; 1170 1171 size = MWL8K_RX_DESCS * priv->rxd_ops->rxd_size; 1172 1173 rxq->rxd = dma_alloc_coherent(&priv->pdev->dev, size, &rxq->rxd_dma, 1174 GFP_KERNEL); 1175 if (rxq->rxd == NULL) { 1176 wiphy_err(hw->wiphy, "failed to alloc RX descriptors\n"); 1177 return -ENOMEM; 1178 } 1179 1180 rxq->buf = kcalloc(MWL8K_RX_DESCS, sizeof(*rxq->buf), GFP_KERNEL); 1181 if (rxq->buf == NULL) { 1182 dma_free_coherent(&priv->pdev->dev, size, rxq->rxd, 1183 rxq->rxd_dma); 1184 return -ENOMEM; 1185 } 1186 1187 for (i = 0; i < MWL8K_RX_DESCS; i++) { 1188 int desc_size; 1189 void *rxd; 1190 int nexti; 1191 dma_addr_t next_dma_addr; 1192 1193 desc_size = priv->rxd_ops->rxd_size; 1194 rxd = rxq->rxd + (i * priv->rxd_ops->rxd_size); 1195 1196 nexti = i + 1; 1197 if (nexti == MWL8K_RX_DESCS) 1198 nexti = 0; 1199 next_dma_addr = rxq->rxd_dma + (nexti * desc_size); 1200 1201 priv->rxd_ops->rxd_init(rxd, next_dma_addr); 1202 } 1203 1204 return 0; 1205 } 1206 1207 static int rxq_refill(struct ieee80211_hw *hw, int index, int limit) 1208 { 1209 struct mwl8k_priv *priv = hw->priv; 1210 struct mwl8k_rx_queue *rxq = priv->rxq + index; 1211 int refilled = 0; 1212 1213 while (rxq->rxd_count < MWL8K_RX_DESCS && limit--) { 1214 struct sk_buff *skb; 1215 dma_addr_t addr; 1216 int rx; 1217 void *rxd; 1218 1219 skb = dev_alloc_skb(MWL8K_RX_MAXSZ); 1220 if (skb == NULL) 1221 break; 1222 1223 addr = dma_map_single(&priv->pdev->dev, skb->data, 1224 MWL8K_RX_MAXSZ, DMA_FROM_DEVICE); 1225 1226 rxq->rxd_count++; 1227 rx = rxq->tail++; 1228 if (rxq->tail == MWL8K_RX_DESCS) 1229 rxq->tail = 0; 1230 rxq->buf[rx].skb = skb; 1231 dma_unmap_addr_set(&rxq->buf[rx], dma, addr); 1232 1233 rxd = rxq->rxd + (rx * priv->rxd_ops->rxd_size); 1234 priv->rxd_ops->rxd_refill(rxd, addr, MWL8K_RX_MAXSZ); 1235 1236 refilled++; 1237 } 1238 1239 return refilled; 1240 } 1241 1242 /* Must be called only when the card's reception is completely halted */ 1243 static void mwl8k_rxq_deinit(struct ieee80211_hw *hw, int index) 1244 { 1245 struct mwl8k_priv *priv = hw->priv; 1246 struct mwl8k_rx_queue *rxq = priv->rxq + index; 1247 int i; 1248 1249 if (rxq->rxd == NULL) 1250 return; 1251 1252 for (i = 0; i < MWL8K_RX_DESCS; i++) { 1253 if (rxq->buf[i].skb != NULL) { 1254 dma_unmap_single(&priv->pdev->dev, 1255 dma_unmap_addr(&rxq->buf[i], dma), 1256 MWL8K_RX_MAXSZ, DMA_FROM_DEVICE); 1257 dma_unmap_addr_set(&rxq->buf[i], dma, 0); 1258 1259 kfree_skb(rxq->buf[i].skb); 1260 rxq->buf[i].skb = NULL; 1261 } 1262 } 1263 1264 kfree(rxq->buf); 1265 rxq->buf = NULL; 1266 1267 dma_free_coherent(&priv->pdev->dev, 1268 MWL8K_RX_DESCS * priv->rxd_ops->rxd_size, rxq->rxd, 1269 rxq->rxd_dma); 1270 rxq->rxd = NULL; 1271 } 1272 1273 1274 /* 1275 * Scan a list of BSSIDs to process for finalize join. 1276 * Allows for extension to process multiple BSSIDs. 1277 */ 1278 static inline int 1279 mwl8k_capture_bssid(struct mwl8k_priv *priv, struct ieee80211_hdr *wh) 1280 { 1281 return priv->capture_beacon && 1282 ieee80211_is_beacon(wh->frame_control) && 1283 ether_addr_equal_64bits(wh->addr3, priv->capture_bssid); 1284 } 1285 1286 static inline void mwl8k_save_beacon(struct ieee80211_hw *hw, 1287 struct sk_buff *skb) 1288 { 1289 struct mwl8k_priv *priv = hw->priv; 1290 1291 priv->capture_beacon = false; 1292 eth_zero_addr(priv->capture_bssid); 1293 1294 /* 1295 * Use GFP_ATOMIC as rxq_process is called from 1296 * the primary interrupt handler, memory allocation call 1297 * must not sleep. 1298 */ 1299 priv->beacon_skb = skb_copy(skb, GFP_ATOMIC); 1300 if (priv->beacon_skb != NULL) 1301 ieee80211_queue_work(hw, &priv->finalize_join_worker); 1302 } 1303 1304 static inline struct mwl8k_vif *mwl8k_find_vif_bss(struct list_head *vif_list, 1305 u8 *bssid) 1306 { 1307 struct mwl8k_vif *mwl8k_vif; 1308 1309 list_for_each_entry(mwl8k_vif, 1310 vif_list, list) { 1311 if (memcmp(bssid, mwl8k_vif->bssid, 1312 ETH_ALEN) == 0) 1313 return mwl8k_vif; 1314 } 1315 1316 return NULL; 1317 } 1318 1319 static int rxq_process(struct ieee80211_hw *hw, int index, int limit) 1320 { 1321 struct mwl8k_priv *priv = hw->priv; 1322 struct mwl8k_vif *mwl8k_vif = NULL; 1323 struct mwl8k_rx_queue *rxq = priv->rxq + index; 1324 int processed; 1325 1326 processed = 0; 1327 while (rxq->rxd_count && limit--) { 1328 struct sk_buff *skb; 1329 void *rxd; 1330 int pkt_len; 1331 struct ieee80211_rx_status status; 1332 struct ieee80211_hdr *wh; 1333 __le16 qos; 1334 1335 skb = rxq->buf[rxq->head].skb; 1336 if (skb == NULL) 1337 break; 1338 1339 rxd = rxq->rxd + (rxq->head * priv->rxd_ops->rxd_size); 1340 1341 pkt_len = priv->rxd_ops->rxd_process(rxd, &status, &qos, 1342 &priv->noise); 1343 if (pkt_len < 0) 1344 break; 1345 1346 rxq->buf[rxq->head].skb = NULL; 1347 1348 dma_unmap_single(&priv->pdev->dev, 1349 dma_unmap_addr(&rxq->buf[rxq->head], dma), 1350 MWL8K_RX_MAXSZ, DMA_FROM_DEVICE); 1351 dma_unmap_addr_set(&rxq->buf[rxq->head], dma, 0); 1352 1353 rxq->head++; 1354 if (rxq->head == MWL8K_RX_DESCS) 1355 rxq->head = 0; 1356 1357 rxq->rxd_count--; 1358 1359 wh = &((struct mwl8k_dma_data *)skb->data)->wh; 1360 1361 /* 1362 * Check for a pending join operation. Save a 1363 * copy of the beacon and schedule a tasklet to 1364 * send a FINALIZE_JOIN command to the firmware. 1365 */ 1366 if (mwl8k_capture_bssid(priv, (void *)skb->data)) 1367 mwl8k_save_beacon(hw, skb); 1368 1369 if (ieee80211_has_protected(wh->frame_control)) { 1370 1371 /* Check if hw crypto has been enabled for 1372 * this bss. If yes, set the status flags 1373 * accordingly 1374 */ 1375 mwl8k_vif = mwl8k_find_vif_bss(&priv->vif_list, 1376 wh->addr1); 1377 1378 if (mwl8k_vif != NULL && 1379 mwl8k_vif->is_hw_crypto_enabled) { 1380 /* 1381 * When MMIC ERROR is encountered 1382 * by the firmware, payload is 1383 * dropped and only 32 bytes of 1384 * mwl8k Firmware header is sent 1385 * to the host. 1386 * 1387 * We need to add four bytes of 1388 * key information. In it 1389 * MAC80211 expects keyidx set to 1390 * 0 for triggering Counter 1391 * Measure of MMIC failure. 1392 */ 1393 if (status.flag & RX_FLAG_MMIC_ERROR) { 1394 struct mwl8k_dma_data *tr; 1395 tr = (struct mwl8k_dma_data *)skb->data; 1396 memset((void *)&(tr->data), 0, 4); 1397 pkt_len += 4; 1398 } 1399 1400 if (!ieee80211_is_auth(wh->frame_control)) 1401 status.flag |= RX_FLAG_IV_STRIPPED | 1402 RX_FLAG_DECRYPTED | 1403 RX_FLAG_MMIC_STRIPPED; 1404 } 1405 } 1406 1407 skb_put(skb, pkt_len); 1408 mwl8k_remove_dma_header(skb, qos); 1409 memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status)); 1410 ieee80211_rx_irqsafe(hw, skb); 1411 1412 processed++; 1413 } 1414 1415 return processed; 1416 } 1417 1418 1419 /* 1420 * Packet transmission. 1421 */ 1422 1423 #define MWL8K_TXD_STATUS_OK 0x00000001 1424 #define MWL8K_TXD_STATUS_OK_RETRY 0x00000002 1425 #define MWL8K_TXD_STATUS_OK_MORE_RETRY 0x00000004 1426 #define MWL8K_TXD_STATUS_MULTICAST_TX 0x00000008 1427 #define MWL8K_TXD_STATUS_FW_OWNED 0x80000000 1428 1429 #define MWL8K_QOS_QLEN_UNSPEC 0xff00 1430 #define MWL8K_QOS_ACK_POLICY_MASK 0x0060 1431 #define MWL8K_QOS_ACK_POLICY_NORMAL 0x0000 1432 #define MWL8K_QOS_ACK_POLICY_BLOCKACK 0x0060 1433 #define MWL8K_QOS_EOSP 0x0010 1434 1435 struct mwl8k_tx_desc { 1436 __le32 status; 1437 __u8 data_rate; 1438 __u8 tx_priority; 1439 __le16 qos_control; 1440 __le32 pkt_phys_addr; 1441 __le16 pkt_len; 1442 __u8 dest_MAC_addr[ETH_ALEN]; 1443 __le32 next_txd_phys_addr; 1444 __le32 timestamp; 1445 __le16 rate_info; 1446 __u8 peer_id; 1447 __u8 tx_frag_cnt; 1448 } __packed; 1449 1450 #define MWL8K_TX_DESCS 128 1451 1452 static int mwl8k_txq_init(struct ieee80211_hw *hw, int index) 1453 { 1454 struct mwl8k_priv *priv = hw->priv; 1455 struct mwl8k_tx_queue *txq = priv->txq + index; 1456 int size; 1457 int i; 1458 1459 txq->len = 0; 1460 txq->head = 0; 1461 txq->tail = 0; 1462 1463 size = MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc); 1464 1465 txq->txd = dma_alloc_coherent(&priv->pdev->dev, size, &txq->txd_dma, 1466 GFP_KERNEL); 1467 if (txq->txd == NULL) { 1468 wiphy_err(hw->wiphy, "failed to alloc TX descriptors\n"); 1469 return -ENOMEM; 1470 } 1471 1472 txq->skb = kcalloc(MWL8K_TX_DESCS, sizeof(*txq->skb), GFP_KERNEL); 1473 if (txq->skb == NULL) { 1474 dma_free_coherent(&priv->pdev->dev, size, txq->txd, 1475 txq->txd_dma); 1476 return -ENOMEM; 1477 } 1478 1479 for (i = 0; i < MWL8K_TX_DESCS; i++) { 1480 struct mwl8k_tx_desc *tx_desc; 1481 int nexti; 1482 1483 tx_desc = txq->txd + i; 1484 nexti = (i + 1) % MWL8K_TX_DESCS; 1485 1486 tx_desc->status = 0; 1487 tx_desc->next_txd_phys_addr = 1488 cpu_to_le32(txq->txd_dma + nexti * sizeof(*tx_desc)); 1489 } 1490 1491 return 0; 1492 } 1493 1494 static inline void mwl8k_tx_start(struct mwl8k_priv *priv) 1495 { 1496 iowrite32(MWL8K_H2A_INT_PPA_READY, 1497 priv->regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS); 1498 iowrite32(MWL8K_H2A_INT_DUMMY, 1499 priv->regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS); 1500 ioread32(priv->regs + MWL8K_HIU_INT_CODE); 1501 } 1502 1503 static void mwl8k_dump_tx_rings(struct ieee80211_hw *hw) 1504 { 1505 struct mwl8k_priv *priv = hw->priv; 1506 int i; 1507 1508 for (i = 0; i < mwl8k_tx_queues(priv); i++) { 1509 struct mwl8k_tx_queue *txq = priv->txq + i; 1510 int fw_owned = 0; 1511 int drv_owned = 0; 1512 int unused = 0; 1513 int desc; 1514 1515 for (desc = 0; desc < MWL8K_TX_DESCS; desc++) { 1516 struct mwl8k_tx_desc *tx_desc = txq->txd + desc; 1517 u32 status; 1518 1519 status = le32_to_cpu(tx_desc->status); 1520 if (status & MWL8K_TXD_STATUS_FW_OWNED) 1521 fw_owned++; 1522 else 1523 drv_owned++; 1524 1525 if (tx_desc->pkt_len == 0) 1526 unused++; 1527 } 1528 1529 wiphy_err(hw->wiphy, 1530 "txq[%d] len=%d head=%d tail=%d " 1531 "fw_owned=%d drv_owned=%d unused=%d\n", 1532 i, 1533 txq->len, txq->head, txq->tail, 1534 fw_owned, drv_owned, unused); 1535 } 1536 } 1537 1538 /* 1539 * Must be called with priv->fw_mutex held and tx queues stopped. 1540 */ 1541 #define MWL8K_TX_WAIT_TIMEOUT_MS 5000 1542 1543 static int mwl8k_tx_wait_empty(struct ieee80211_hw *hw) 1544 { 1545 struct mwl8k_priv *priv = hw->priv; 1546 DECLARE_COMPLETION_ONSTACK(tx_wait); 1547 int retry; 1548 int rc; 1549 1550 might_sleep(); 1551 1552 /* Since fw restart is in progress, allow only the firmware 1553 * commands from the restart code and block the other 1554 * commands since they are going to fail in any case since 1555 * the firmware has crashed 1556 */ 1557 if (priv->hw_restart_in_progress) { 1558 if (priv->hw_restart_owner == current) 1559 return 0; 1560 else 1561 return -EBUSY; 1562 } 1563 1564 if (atomic_read(&priv->watchdog_event_pending)) 1565 return 0; 1566 1567 /* 1568 * The TX queues are stopped at this point, so this test 1569 * doesn't need to take ->tx_lock. 1570 */ 1571 if (!priv->pending_tx_pkts) 1572 return 0; 1573 1574 retry = 1; 1575 rc = 0; 1576 1577 spin_lock_bh(&priv->tx_lock); 1578 priv->tx_wait = &tx_wait; 1579 while (!rc) { 1580 int oldcount; 1581 unsigned long timeout; 1582 1583 oldcount = priv->pending_tx_pkts; 1584 1585 spin_unlock_bh(&priv->tx_lock); 1586 timeout = wait_for_completion_timeout(&tx_wait, 1587 msecs_to_jiffies(MWL8K_TX_WAIT_TIMEOUT_MS)); 1588 1589 if (atomic_read(&priv->watchdog_event_pending)) { 1590 spin_lock_bh(&priv->tx_lock); 1591 priv->tx_wait = NULL; 1592 spin_unlock_bh(&priv->tx_lock); 1593 return 0; 1594 } 1595 1596 spin_lock_bh(&priv->tx_lock); 1597 1598 if (timeout || !priv->pending_tx_pkts) { 1599 WARN_ON(priv->pending_tx_pkts); 1600 if (retry) 1601 wiphy_notice(hw->wiphy, "tx rings drained\n"); 1602 break; 1603 } 1604 1605 if (retry) { 1606 mwl8k_tx_start(priv); 1607 retry = 0; 1608 continue; 1609 } 1610 1611 if (priv->pending_tx_pkts < oldcount) { 1612 wiphy_notice(hw->wiphy, 1613 "waiting for tx rings to drain (%d -> %d pkts)\n", 1614 oldcount, priv->pending_tx_pkts); 1615 retry = 1; 1616 continue; 1617 } 1618 1619 priv->tx_wait = NULL; 1620 1621 wiphy_err(hw->wiphy, "tx rings stuck for %d ms\n", 1622 MWL8K_TX_WAIT_TIMEOUT_MS); 1623 mwl8k_dump_tx_rings(hw); 1624 priv->hw_restart_in_progress = true; 1625 ieee80211_queue_work(hw, &priv->fw_reload); 1626 1627 rc = -ETIMEDOUT; 1628 } 1629 priv->tx_wait = NULL; 1630 spin_unlock_bh(&priv->tx_lock); 1631 1632 return rc; 1633 } 1634 1635 #define MWL8K_TXD_SUCCESS(status) \ 1636 ((status) & (MWL8K_TXD_STATUS_OK | \ 1637 MWL8K_TXD_STATUS_OK_RETRY | \ 1638 MWL8K_TXD_STATUS_OK_MORE_RETRY)) 1639 1640 static int mwl8k_tid_queue_mapping(u8 tid) 1641 { 1642 BUG_ON(tid > 7); 1643 1644 switch (tid) { 1645 case 0: 1646 case 3: 1647 return IEEE80211_AC_BE; 1648 case 1: 1649 case 2: 1650 return IEEE80211_AC_BK; 1651 case 4: 1652 case 5: 1653 return IEEE80211_AC_VI; 1654 case 6: 1655 case 7: 1656 return IEEE80211_AC_VO; 1657 default: 1658 return -1; 1659 } 1660 } 1661 1662 /* The firmware will fill in the rate information 1663 * for each packet that gets queued in the hardware 1664 * and these macros will interpret that info. 1665 */ 1666 1667 #define RI_FORMAT(a) (a & 0x0001) 1668 #define RI_RATE_ID_MCS(a) ((a & 0x01f8) >> 3) 1669 1670 static int 1671 mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int limit, int force) 1672 { 1673 struct mwl8k_priv *priv = hw->priv; 1674 struct mwl8k_tx_queue *txq = priv->txq + index; 1675 int processed; 1676 1677 processed = 0; 1678 while (txq->len > 0 && limit--) { 1679 int tx; 1680 struct mwl8k_tx_desc *tx_desc; 1681 unsigned long addr; 1682 int size; 1683 struct sk_buff *skb; 1684 struct ieee80211_tx_info *info; 1685 u32 status; 1686 struct ieee80211_sta *sta; 1687 struct mwl8k_sta *sta_info = NULL; 1688 u16 rate_info; 1689 struct ieee80211_hdr *wh; 1690 1691 tx = txq->head; 1692 tx_desc = txq->txd + tx; 1693 1694 status = le32_to_cpu(tx_desc->status); 1695 1696 if (status & MWL8K_TXD_STATUS_FW_OWNED) { 1697 if (!force) 1698 break; 1699 tx_desc->status &= 1700 ~cpu_to_le32(MWL8K_TXD_STATUS_FW_OWNED); 1701 } 1702 1703 txq->head = (tx + 1) % MWL8K_TX_DESCS; 1704 BUG_ON(txq->len == 0); 1705 txq->len--; 1706 priv->pending_tx_pkts--; 1707 1708 addr = le32_to_cpu(tx_desc->pkt_phys_addr); 1709 size = le16_to_cpu(tx_desc->pkt_len); 1710 skb = txq->skb[tx]; 1711 txq->skb[tx] = NULL; 1712 1713 BUG_ON(skb == NULL); 1714 dma_unmap_single(&priv->pdev->dev, addr, size, DMA_TO_DEVICE); 1715 1716 mwl8k_remove_dma_header(skb, tx_desc->qos_control); 1717 1718 wh = (struct ieee80211_hdr *) skb->data; 1719 1720 /* Mark descriptor as unused */ 1721 tx_desc->pkt_phys_addr = 0; 1722 tx_desc->pkt_len = 0; 1723 1724 info = IEEE80211_SKB_CB(skb); 1725 if (ieee80211_is_data(wh->frame_control)) { 1726 rcu_read_lock(); 1727 sta = ieee80211_find_sta_by_ifaddr(hw, wh->addr1, 1728 wh->addr2); 1729 if (sta) { 1730 sta_info = MWL8K_STA(sta); 1731 BUG_ON(sta_info == NULL); 1732 rate_info = le16_to_cpu(tx_desc->rate_info); 1733 /* If rate is < 6.5 Mpbs for an ht station 1734 * do not form an ampdu. If the station is a 1735 * legacy station (format = 0), do not form an 1736 * ampdu 1737 */ 1738 if (RI_RATE_ID_MCS(rate_info) < 1 || 1739 RI_FORMAT(rate_info) == 0) { 1740 sta_info->is_ampdu_allowed = false; 1741 } else { 1742 sta_info->is_ampdu_allowed = true; 1743 } 1744 } 1745 rcu_read_unlock(); 1746 } 1747 1748 ieee80211_tx_info_clear_status(info); 1749 1750 /* Rate control is happening in the firmware. 1751 * Ensure no tx rate is being reported. 1752 */ 1753 info->status.rates[0].idx = -1; 1754 info->status.rates[0].count = 1; 1755 1756 if (MWL8K_TXD_SUCCESS(status)) 1757 info->flags |= IEEE80211_TX_STAT_ACK; 1758 1759 ieee80211_tx_status_irqsafe(hw, skb); 1760 1761 processed++; 1762 } 1763 1764 return processed; 1765 } 1766 1767 /* must be called only when the card's transmit is completely halted */ 1768 static void mwl8k_txq_deinit(struct ieee80211_hw *hw, int index) 1769 { 1770 struct mwl8k_priv *priv = hw->priv; 1771 struct mwl8k_tx_queue *txq = priv->txq + index; 1772 1773 if (txq->txd == NULL) 1774 return; 1775 1776 mwl8k_txq_reclaim(hw, index, INT_MAX, 1); 1777 1778 kfree(txq->skb); 1779 txq->skb = NULL; 1780 1781 dma_free_coherent(&priv->pdev->dev, 1782 MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc), 1783 txq->txd, txq->txd_dma); 1784 txq->txd = NULL; 1785 } 1786 1787 /* caller must hold priv->stream_lock when calling the stream functions */ 1788 static struct mwl8k_ampdu_stream * 1789 mwl8k_add_stream(struct ieee80211_hw *hw, struct ieee80211_sta *sta, u8 tid) 1790 { 1791 struct mwl8k_ampdu_stream *stream; 1792 struct mwl8k_priv *priv = hw->priv; 1793 int i; 1794 1795 for (i = 0; i < MWL8K_NUM_AMPDU_STREAMS; i++) { 1796 stream = &priv->ampdu[i]; 1797 if (stream->state == AMPDU_NO_STREAM) { 1798 stream->sta = sta; 1799 stream->state = AMPDU_STREAM_NEW; 1800 stream->tid = tid; 1801 stream->idx = i; 1802 wiphy_debug(hw->wiphy, "Added a new stream for %pM %d", 1803 sta->addr, tid); 1804 return stream; 1805 } 1806 } 1807 return NULL; 1808 } 1809 1810 static int 1811 mwl8k_start_stream(struct ieee80211_hw *hw, struct mwl8k_ampdu_stream *stream) 1812 { 1813 int ret; 1814 1815 /* if the stream has already been started, don't start it again */ 1816 if (stream->state != AMPDU_STREAM_NEW) 1817 return 0; 1818 ret = ieee80211_start_tx_ba_session(stream->sta, stream->tid, 0); 1819 if (ret) 1820 wiphy_debug(hw->wiphy, "Failed to start stream for %pM %d: " 1821 "%d\n", stream->sta->addr, stream->tid, ret); 1822 else 1823 wiphy_debug(hw->wiphy, "Started stream for %pM %d\n", 1824 stream->sta->addr, stream->tid); 1825 return ret; 1826 } 1827 1828 static void 1829 mwl8k_remove_stream(struct ieee80211_hw *hw, struct mwl8k_ampdu_stream *stream) 1830 { 1831 wiphy_debug(hw->wiphy, "Remove stream for %pM %d\n", stream->sta->addr, 1832 stream->tid); 1833 memset(stream, 0, sizeof(*stream)); 1834 } 1835 1836 static struct mwl8k_ampdu_stream * 1837 mwl8k_lookup_stream(struct ieee80211_hw *hw, u8 *addr, u8 tid) 1838 { 1839 struct mwl8k_priv *priv = hw->priv; 1840 int i; 1841 1842 for (i = 0; i < MWL8K_NUM_AMPDU_STREAMS; i++) { 1843 struct mwl8k_ampdu_stream *stream; 1844 stream = &priv->ampdu[i]; 1845 if (stream->state == AMPDU_NO_STREAM) 1846 continue; 1847 if (!memcmp(stream->sta->addr, addr, ETH_ALEN) && 1848 stream->tid == tid) 1849 return stream; 1850 } 1851 return NULL; 1852 } 1853 1854 #define MWL8K_AMPDU_PACKET_THRESHOLD 64 1855 static inline bool mwl8k_ampdu_allowed(struct ieee80211_sta *sta, u8 tid) 1856 { 1857 struct mwl8k_sta *sta_info = MWL8K_STA(sta); 1858 struct tx_traffic_info *tx_stats; 1859 1860 BUG_ON(tid >= MWL8K_MAX_TID); 1861 tx_stats = &sta_info->tx_stats[tid]; 1862 1863 return sta_info->is_ampdu_allowed && 1864 tx_stats->pkts > MWL8K_AMPDU_PACKET_THRESHOLD; 1865 } 1866 1867 static inline void mwl8k_tx_count_packet(struct ieee80211_sta *sta, u8 tid) 1868 { 1869 struct mwl8k_sta *sta_info = MWL8K_STA(sta); 1870 struct tx_traffic_info *tx_stats; 1871 1872 BUG_ON(tid >= MWL8K_MAX_TID); 1873 tx_stats = &sta_info->tx_stats[tid]; 1874 1875 if (tx_stats->start_time == 0) 1876 tx_stats->start_time = jiffies; 1877 1878 /* reset the packet count after each second elapses. If the number of 1879 * packets ever exceeds the ampdu_min_traffic threshold, we will allow 1880 * an ampdu stream to be started. 1881 */ 1882 if (jiffies - tx_stats->start_time > HZ) { 1883 tx_stats->pkts = 0; 1884 tx_stats->start_time = 0; 1885 } else 1886 tx_stats->pkts++; 1887 } 1888 1889 /* The hardware ampdu queues start from 5. 1890 * txpriorities for ampdu queues are 1891 * 5 6 7 0 1 2 3 4 ie., queue 5 is highest 1892 * and queue 3 is lowest (queue 4 is reserved) 1893 */ 1894 #define BA_QUEUE 5 1895 1896 static void 1897 mwl8k_txq_xmit(struct ieee80211_hw *hw, 1898 int index, 1899 struct ieee80211_sta *sta, 1900 struct sk_buff *skb) 1901 { 1902 struct mwl8k_priv *priv = hw->priv; 1903 struct ieee80211_tx_info *tx_info; 1904 struct mwl8k_vif *mwl8k_vif; 1905 struct ieee80211_hdr *wh; 1906 struct mwl8k_tx_queue *txq; 1907 struct mwl8k_tx_desc *tx; 1908 dma_addr_t dma; 1909 u32 txstatus; 1910 u8 txdatarate; 1911 u16 qos; 1912 int txpriority; 1913 u8 tid = 0; 1914 struct mwl8k_ampdu_stream *stream = NULL; 1915 bool start_ba_session = false; 1916 bool mgmtframe = false; 1917 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)skb->data; 1918 bool eapol_frame = false; 1919 1920 wh = (struct ieee80211_hdr *)skb->data; 1921 if (ieee80211_is_data_qos(wh->frame_control)) 1922 qos = le16_to_cpu(*((__le16 *)ieee80211_get_qos_ctl(wh))); 1923 else 1924 qos = 0; 1925 1926 if (skb->protocol == cpu_to_be16(ETH_P_PAE)) 1927 eapol_frame = true; 1928 1929 if (ieee80211_is_mgmt(wh->frame_control)) 1930 mgmtframe = true; 1931 1932 if (priv->ap_fw) 1933 mwl8k_encapsulate_tx_frame(priv, skb); 1934 else 1935 mwl8k_add_dma_header(priv, skb, 0, 0); 1936 1937 wh = &((struct mwl8k_dma_data *)skb->data)->wh; 1938 1939 tx_info = IEEE80211_SKB_CB(skb); 1940 mwl8k_vif = MWL8K_VIF(tx_info->control.vif); 1941 1942 if (tx_info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) { 1943 wh->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG); 1944 wh->seq_ctrl |= cpu_to_le16(mwl8k_vif->seqno); 1945 mwl8k_vif->seqno += 0x10; 1946 } 1947 1948 /* Setup firmware control bit fields for each frame type. */ 1949 txstatus = 0; 1950 txdatarate = 0; 1951 if (ieee80211_is_mgmt(wh->frame_control) || 1952 ieee80211_is_ctl(wh->frame_control)) { 1953 txdatarate = 0; 1954 qos |= MWL8K_QOS_QLEN_UNSPEC | MWL8K_QOS_EOSP; 1955 } else if (ieee80211_is_data(wh->frame_control)) { 1956 txdatarate = 1; 1957 if (is_multicast_ether_addr(wh->addr1)) 1958 txstatus |= MWL8K_TXD_STATUS_MULTICAST_TX; 1959 1960 qos &= ~MWL8K_QOS_ACK_POLICY_MASK; 1961 if (tx_info->flags & IEEE80211_TX_CTL_AMPDU) 1962 qos |= MWL8K_QOS_ACK_POLICY_BLOCKACK; 1963 else 1964 qos |= MWL8K_QOS_ACK_POLICY_NORMAL; 1965 } 1966 1967 /* Queue ADDBA request in the respective data queue. While setting up 1968 * the ampdu stream, mac80211 queues further packets for that 1969 * particular ra/tid pair. However, packets piled up in the hardware 1970 * for that ra/tid pair will still go out. ADDBA request and the 1971 * related data packets going out from different queues asynchronously 1972 * will cause a shift in the receiver window which might result in 1973 * ampdu packets getting dropped at the receiver after the stream has 1974 * been setup. 1975 */ 1976 if (unlikely(ieee80211_is_action(wh->frame_control) && 1977 mgmt->u.action.category == WLAN_CATEGORY_BACK && 1978 mgmt->u.action.u.addba_req.action_code == WLAN_ACTION_ADDBA_REQ && 1979 priv->ap_fw)) { 1980 u16 capab = le16_to_cpu(mgmt->u.action.u.addba_req.capab); 1981 tid = (capab & IEEE80211_ADDBA_PARAM_TID_MASK) >> 2; 1982 index = mwl8k_tid_queue_mapping(tid); 1983 } 1984 1985 txpriority = index; 1986 1987 if (priv->ap_fw && sta && sta->ht_cap.ht_supported && !eapol_frame && 1988 ieee80211_is_data_qos(wh->frame_control)) { 1989 tid = qos & 0xf; 1990 mwl8k_tx_count_packet(sta, tid); 1991 spin_lock(&priv->stream_lock); 1992 stream = mwl8k_lookup_stream(hw, sta->addr, tid); 1993 if (stream != NULL) { 1994 if (stream->state == AMPDU_STREAM_ACTIVE) { 1995 WARN_ON(!(qos & MWL8K_QOS_ACK_POLICY_BLOCKACK)); 1996 txpriority = (BA_QUEUE + stream->idx) % 1997 TOTAL_HW_TX_QUEUES; 1998 if (stream->idx <= 1) 1999 index = stream->idx + 2000 MWL8K_TX_WMM_QUEUES; 2001 2002 } else if (stream->state == AMPDU_STREAM_NEW) { 2003 /* We get here if the driver sends us packets 2004 * after we've initiated a stream, but before 2005 * our ampdu_action routine has been called 2006 * with IEEE80211_AMPDU_TX_START to get the SSN 2007 * for the ADDBA request. So this packet can 2008 * go out with no risk of sequence number 2009 * mismatch. No special handling is required. 2010 */ 2011 } else { 2012 /* Drop packets that would go out after the 2013 * ADDBA request was sent but before the ADDBA 2014 * response is received. If we don't do this, 2015 * the recipient would probably receive it 2016 * after the ADDBA request with SSN 0. This 2017 * will cause the recipient's BA receive window 2018 * to shift, which would cause the subsequent 2019 * packets in the BA stream to be discarded. 2020 * mac80211 queues our packets for us in this 2021 * case, so this is really just a safety check. 2022 */ 2023 wiphy_warn(hw->wiphy, 2024 "Cannot send packet while ADDBA " 2025 "dialog is underway.\n"); 2026 spin_unlock(&priv->stream_lock); 2027 dev_kfree_skb(skb); 2028 return; 2029 } 2030 } else { 2031 /* Defer calling mwl8k_start_stream so that the current 2032 * skb can go out before the ADDBA request. This 2033 * prevents sequence number mismatch at the recepient 2034 * as described above. 2035 */ 2036 if (mwl8k_ampdu_allowed(sta, tid)) { 2037 stream = mwl8k_add_stream(hw, sta, tid); 2038 if (stream != NULL) 2039 start_ba_session = true; 2040 } 2041 } 2042 spin_unlock(&priv->stream_lock); 2043 } else { 2044 qos &= ~MWL8K_QOS_ACK_POLICY_MASK; 2045 qos |= MWL8K_QOS_ACK_POLICY_NORMAL; 2046 } 2047 2048 dma = dma_map_single(&priv->pdev->dev, skb->data, skb->len, 2049 DMA_TO_DEVICE); 2050 2051 if (dma_mapping_error(&priv->pdev->dev, dma)) { 2052 wiphy_debug(hw->wiphy, 2053 "failed to dma map skb, dropping TX frame.\n"); 2054 if (start_ba_session) { 2055 spin_lock(&priv->stream_lock); 2056 mwl8k_remove_stream(hw, stream); 2057 spin_unlock(&priv->stream_lock); 2058 } 2059 dev_kfree_skb(skb); 2060 return; 2061 } 2062 2063 spin_lock_bh(&priv->tx_lock); 2064 2065 txq = priv->txq + index; 2066 2067 /* Mgmt frames that go out frequently are probe 2068 * responses. Other mgmt frames got out relatively 2069 * infrequently. Hence reserve 2 buffers so that 2070 * other mgmt frames do not get dropped due to an 2071 * already queued probe response in one of the 2072 * reserved buffers. 2073 */ 2074 2075 if (txq->len >= MWL8K_TX_DESCS - 2) { 2076 if (!mgmtframe || txq->len == MWL8K_TX_DESCS) { 2077 if (start_ba_session) { 2078 spin_lock(&priv->stream_lock); 2079 mwl8k_remove_stream(hw, stream); 2080 spin_unlock(&priv->stream_lock); 2081 } 2082 mwl8k_tx_start(priv); 2083 spin_unlock_bh(&priv->tx_lock); 2084 dma_unmap_single(&priv->pdev->dev, dma, skb->len, 2085 DMA_TO_DEVICE); 2086 dev_kfree_skb(skb); 2087 return; 2088 } 2089 } 2090 2091 BUG_ON(txq->skb[txq->tail] != NULL); 2092 txq->skb[txq->tail] = skb; 2093 2094 tx = txq->txd + txq->tail; 2095 tx->data_rate = txdatarate; 2096 tx->tx_priority = txpriority; 2097 tx->qos_control = cpu_to_le16(qos); 2098 tx->pkt_phys_addr = cpu_to_le32(dma); 2099 tx->pkt_len = cpu_to_le16(skb->len); 2100 tx->rate_info = 0; 2101 if (!priv->ap_fw && sta != NULL) 2102 tx->peer_id = MWL8K_STA(sta)->peer_id; 2103 else 2104 tx->peer_id = 0; 2105 2106 if (priv->ap_fw && ieee80211_is_data(wh->frame_control) && !eapol_frame) 2107 tx->timestamp = cpu_to_le32(ioread32(priv->regs + 2108 MWL8K_HW_TIMER_REGISTER)); 2109 else 2110 tx->timestamp = 0; 2111 2112 wmb(); 2113 tx->status = cpu_to_le32(MWL8K_TXD_STATUS_FW_OWNED | txstatus); 2114 2115 txq->len++; 2116 priv->pending_tx_pkts++; 2117 2118 txq->tail++; 2119 if (txq->tail == MWL8K_TX_DESCS) 2120 txq->tail = 0; 2121 2122 mwl8k_tx_start(priv); 2123 2124 spin_unlock_bh(&priv->tx_lock); 2125 2126 /* Initiate the ampdu session here */ 2127 if (start_ba_session) { 2128 spin_lock(&priv->stream_lock); 2129 if (mwl8k_start_stream(hw, stream)) 2130 mwl8k_remove_stream(hw, stream); 2131 spin_unlock(&priv->stream_lock); 2132 } 2133 } 2134 2135 2136 /* 2137 * Firmware access. 2138 * 2139 * We have the following requirements for issuing firmware commands: 2140 * - Some commands require that the packet transmit path is idle when 2141 * the command is issued. (For simplicity, we'll just quiesce the 2142 * transmit path for every command.) 2143 * - There are certain sequences of commands that need to be issued to 2144 * the hardware sequentially, with no other intervening commands. 2145 * 2146 * This leads to an implementation of a "firmware lock" as a mutex that 2147 * can be taken recursively, and which is taken by both the low-level 2148 * command submission function (mwl8k_post_cmd) as well as any users of 2149 * that function that require issuing of an atomic sequence of commands, 2150 * and quiesces the transmit path whenever it's taken. 2151 */ 2152 static int mwl8k_fw_lock(struct ieee80211_hw *hw) 2153 { 2154 struct mwl8k_priv *priv = hw->priv; 2155 2156 if (priv->fw_mutex_owner != current) { 2157 int rc; 2158 2159 mutex_lock(&priv->fw_mutex); 2160 ieee80211_stop_queues(hw); 2161 2162 rc = mwl8k_tx_wait_empty(hw); 2163 if (rc) { 2164 if (!priv->hw_restart_in_progress) 2165 ieee80211_wake_queues(hw); 2166 2167 mutex_unlock(&priv->fw_mutex); 2168 2169 return rc; 2170 } 2171 2172 priv->fw_mutex_owner = current; 2173 } 2174 2175 priv->fw_mutex_depth++; 2176 2177 return 0; 2178 } 2179 2180 static void mwl8k_fw_unlock(struct ieee80211_hw *hw) 2181 { 2182 struct mwl8k_priv *priv = hw->priv; 2183 2184 if (!--priv->fw_mutex_depth) { 2185 if (!priv->hw_restart_in_progress) 2186 ieee80211_wake_queues(hw); 2187 2188 priv->fw_mutex_owner = NULL; 2189 mutex_unlock(&priv->fw_mutex); 2190 } 2191 } 2192 2193 static void mwl8k_enable_bsses(struct ieee80211_hw *hw, bool enable, 2194 u32 bitmap); 2195 2196 /* 2197 * Command processing. 2198 */ 2199 2200 /* Timeout firmware commands after 10s */ 2201 #define MWL8K_CMD_TIMEOUT_MS 10000 2202 2203 static int mwl8k_post_cmd(struct ieee80211_hw *hw, struct mwl8k_cmd_pkt *cmd) 2204 { 2205 DECLARE_COMPLETION_ONSTACK(cmd_wait); 2206 struct mwl8k_priv *priv = hw->priv; 2207 void __iomem *regs = priv->regs; 2208 dma_addr_t dma_addr; 2209 unsigned int dma_size; 2210 int rc; 2211 unsigned long timeout = 0; 2212 u8 buf[32]; 2213 u32 bitmap = 0; 2214 2215 wiphy_dbg(hw->wiphy, "Posting %s [%d]\n", 2216 mwl8k_cmd_name(cmd->code, buf, sizeof(buf)), cmd->macid); 2217 2218 /* Before posting firmware commands that could change the hardware 2219 * characteristics, make sure that all BSSes are stopped temporary. 2220 * Enable these stopped BSSes after completion of the commands 2221 */ 2222 2223 rc = mwl8k_fw_lock(hw); 2224 if (rc) 2225 return rc; 2226 2227 if (priv->ap_fw && priv->running_bsses) { 2228 switch (le16_to_cpu(cmd->code)) { 2229 case MWL8K_CMD_SET_RF_CHANNEL: 2230 case MWL8K_CMD_RADIO_CONTROL: 2231 case MWL8K_CMD_RF_TX_POWER: 2232 case MWL8K_CMD_TX_POWER: 2233 case MWL8K_CMD_RF_ANTENNA: 2234 case MWL8K_CMD_RTS_THRESHOLD: 2235 case MWL8K_CMD_MIMO_CONFIG: 2236 bitmap = priv->running_bsses; 2237 mwl8k_enable_bsses(hw, false, bitmap); 2238 break; 2239 } 2240 } 2241 2242 cmd->result = (__force __le16) 0xffff; 2243 dma_size = le16_to_cpu(cmd->length); 2244 dma_addr = dma_map_single(&priv->pdev->dev, cmd, dma_size, 2245 DMA_BIDIRECTIONAL); 2246 if (dma_mapping_error(&priv->pdev->dev, dma_addr)) { 2247 rc = -ENOMEM; 2248 goto exit; 2249 } 2250 2251 priv->hostcmd_wait = &cmd_wait; 2252 iowrite32(dma_addr, regs + MWL8K_HIU_GEN_PTR); 2253 iowrite32(MWL8K_H2A_INT_DOORBELL, 2254 regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS); 2255 iowrite32(MWL8K_H2A_INT_DUMMY, 2256 regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS); 2257 2258 timeout = wait_for_completion_timeout(&cmd_wait, 2259 msecs_to_jiffies(MWL8K_CMD_TIMEOUT_MS)); 2260 2261 priv->hostcmd_wait = NULL; 2262 2263 2264 dma_unmap_single(&priv->pdev->dev, dma_addr, dma_size, 2265 DMA_BIDIRECTIONAL); 2266 2267 if (!timeout) { 2268 wiphy_err(hw->wiphy, "Command %s timeout after %u ms\n", 2269 mwl8k_cmd_name(cmd->code, buf, sizeof(buf)), 2270 MWL8K_CMD_TIMEOUT_MS); 2271 rc = -ETIMEDOUT; 2272 } else { 2273 int ms; 2274 2275 ms = MWL8K_CMD_TIMEOUT_MS - jiffies_to_msecs(timeout); 2276 2277 rc = cmd->result ? -EINVAL : 0; 2278 if (rc) 2279 wiphy_err(hw->wiphy, "Command %s error 0x%x\n", 2280 mwl8k_cmd_name(cmd->code, buf, sizeof(buf)), 2281 le16_to_cpu(cmd->result)); 2282 else if (ms > 2000) 2283 wiphy_notice(hw->wiphy, "Command %s took %d ms\n", 2284 mwl8k_cmd_name(cmd->code, 2285 buf, sizeof(buf)), 2286 ms); 2287 } 2288 2289 exit: 2290 if (bitmap) 2291 mwl8k_enable_bsses(hw, true, bitmap); 2292 2293 mwl8k_fw_unlock(hw); 2294 2295 return rc; 2296 } 2297 2298 static int mwl8k_post_pervif_cmd(struct ieee80211_hw *hw, 2299 struct ieee80211_vif *vif, 2300 struct mwl8k_cmd_pkt *cmd) 2301 { 2302 if (vif != NULL) 2303 cmd->macid = MWL8K_VIF(vif)->macid; 2304 return mwl8k_post_cmd(hw, cmd); 2305 } 2306 2307 /* 2308 * Setup code shared between STA and AP firmware images. 2309 */ 2310 static void mwl8k_setup_2ghz_band(struct ieee80211_hw *hw) 2311 { 2312 struct mwl8k_priv *priv = hw->priv; 2313 2314 BUILD_BUG_ON(sizeof(priv->channels_24) != sizeof(mwl8k_channels_24)); 2315 memcpy(priv->channels_24, mwl8k_channels_24, sizeof(mwl8k_channels_24)); 2316 2317 BUILD_BUG_ON(sizeof(priv->rates_24) != sizeof(mwl8k_rates_24)); 2318 memcpy(priv->rates_24, mwl8k_rates_24, sizeof(mwl8k_rates_24)); 2319 2320 priv->band_24.band = NL80211_BAND_2GHZ; 2321 priv->band_24.channels = priv->channels_24; 2322 priv->band_24.n_channels = ARRAY_SIZE(mwl8k_channels_24); 2323 priv->band_24.bitrates = priv->rates_24; 2324 priv->band_24.n_bitrates = ARRAY_SIZE(mwl8k_rates_24); 2325 2326 hw->wiphy->bands[NL80211_BAND_2GHZ] = &priv->band_24; 2327 } 2328 2329 static void mwl8k_setup_5ghz_band(struct ieee80211_hw *hw) 2330 { 2331 struct mwl8k_priv *priv = hw->priv; 2332 2333 BUILD_BUG_ON(sizeof(priv->channels_50) != sizeof(mwl8k_channels_50)); 2334 memcpy(priv->channels_50, mwl8k_channels_50, sizeof(mwl8k_channels_50)); 2335 2336 BUILD_BUG_ON(sizeof(priv->rates_50) != sizeof(mwl8k_rates_50)); 2337 memcpy(priv->rates_50, mwl8k_rates_50, sizeof(mwl8k_rates_50)); 2338 2339 priv->band_50.band = NL80211_BAND_5GHZ; 2340 priv->band_50.channels = priv->channels_50; 2341 priv->band_50.n_channels = ARRAY_SIZE(mwl8k_channels_50); 2342 priv->band_50.bitrates = priv->rates_50; 2343 priv->band_50.n_bitrates = ARRAY_SIZE(mwl8k_rates_50); 2344 2345 hw->wiphy->bands[NL80211_BAND_5GHZ] = &priv->band_50; 2346 } 2347 2348 /* 2349 * CMD_GET_HW_SPEC (STA version). 2350 */ 2351 struct mwl8k_cmd_get_hw_spec_sta { 2352 struct mwl8k_cmd_pkt header; 2353 __u8 hw_rev; 2354 __u8 host_interface; 2355 __le16 num_mcaddrs; 2356 __u8 perm_addr[ETH_ALEN]; 2357 __le16 region_code; 2358 __le32 fw_rev; 2359 __le32 ps_cookie; 2360 __le32 caps; 2361 __u8 mcs_bitmap[16]; 2362 __le32 rx_queue_ptr; 2363 __le32 num_tx_queues; 2364 __le32 tx_queue_ptrs[MWL8K_TX_WMM_QUEUES]; 2365 __le32 caps2; 2366 __le32 num_tx_desc_per_queue; 2367 __le32 total_rxd; 2368 } __packed; 2369 2370 #define MWL8K_CAP_MAX_AMSDU 0x20000000 2371 #define MWL8K_CAP_GREENFIELD 0x08000000 2372 #define MWL8K_CAP_AMPDU 0x04000000 2373 #define MWL8K_CAP_RX_STBC 0x01000000 2374 #define MWL8K_CAP_TX_STBC 0x00800000 2375 #define MWL8K_CAP_SHORTGI_40MHZ 0x00400000 2376 #define MWL8K_CAP_SHORTGI_20MHZ 0x00200000 2377 #define MWL8K_CAP_RX_ANTENNA_MASK 0x000e0000 2378 #define MWL8K_CAP_TX_ANTENNA_MASK 0x0001c000 2379 #define MWL8K_CAP_DELAY_BA 0x00003000 2380 #define MWL8K_CAP_MIMO 0x00000200 2381 #define MWL8K_CAP_40MHZ 0x00000100 2382 #define MWL8K_CAP_BAND_MASK 0x00000007 2383 #define MWL8K_CAP_5GHZ 0x00000004 2384 #define MWL8K_CAP_2GHZ4 0x00000001 2385 2386 static void 2387 mwl8k_set_ht_caps(struct ieee80211_hw *hw, 2388 struct ieee80211_supported_band *band, u32 cap) 2389 { 2390 int rx_streams; 2391 int tx_streams; 2392 2393 band->ht_cap.ht_supported = 1; 2394 2395 if (cap & MWL8K_CAP_MAX_AMSDU) 2396 band->ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU; 2397 if (cap & MWL8K_CAP_GREENFIELD) 2398 band->ht_cap.cap |= IEEE80211_HT_CAP_GRN_FLD; 2399 if (cap & MWL8K_CAP_AMPDU) { 2400 ieee80211_hw_set(hw, AMPDU_AGGREGATION); 2401 band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 2402 band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE; 2403 } 2404 if (cap & MWL8K_CAP_RX_STBC) 2405 band->ht_cap.cap |= IEEE80211_HT_CAP_RX_STBC; 2406 if (cap & MWL8K_CAP_TX_STBC) 2407 band->ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC; 2408 if (cap & MWL8K_CAP_SHORTGI_40MHZ) 2409 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40; 2410 if (cap & MWL8K_CAP_SHORTGI_20MHZ) 2411 band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20; 2412 if (cap & MWL8K_CAP_DELAY_BA) 2413 band->ht_cap.cap |= IEEE80211_HT_CAP_DELAY_BA; 2414 if (cap & MWL8K_CAP_40MHZ) 2415 band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40; 2416 2417 rx_streams = hweight32(cap & MWL8K_CAP_RX_ANTENNA_MASK); 2418 tx_streams = hweight32(cap & MWL8K_CAP_TX_ANTENNA_MASK); 2419 2420 band->ht_cap.mcs.rx_mask[0] = 0xff; 2421 if (rx_streams >= 2) 2422 band->ht_cap.mcs.rx_mask[1] = 0xff; 2423 if (rx_streams >= 3) 2424 band->ht_cap.mcs.rx_mask[2] = 0xff; 2425 band->ht_cap.mcs.rx_mask[4] = 0x01; 2426 band->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED; 2427 2428 if (rx_streams != tx_streams) { 2429 band->ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF; 2430 band->ht_cap.mcs.tx_params |= (tx_streams - 1) << 2431 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT; 2432 } 2433 } 2434 2435 static void 2436 mwl8k_set_caps(struct ieee80211_hw *hw, u32 caps) 2437 { 2438 struct mwl8k_priv *priv = hw->priv; 2439 2440 if (priv->caps) 2441 return; 2442 2443 if ((caps & MWL8K_CAP_2GHZ4) || !(caps & MWL8K_CAP_BAND_MASK)) { 2444 mwl8k_setup_2ghz_band(hw); 2445 if (caps & MWL8K_CAP_MIMO) 2446 mwl8k_set_ht_caps(hw, &priv->band_24, caps); 2447 } 2448 2449 if (caps & MWL8K_CAP_5GHZ) { 2450 mwl8k_setup_5ghz_band(hw); 2451 if (caps & MWL8K_CAP_MIMO) 2452 mwl8k_set_ht_caps(hw, &priv->band_50, caps); 2453 } 2454 2455 priv->caps = caps; 2456 } 2457 2458 static int mwl8k_cmd_get_hw_spec_sta(struct ieee80211_hw *hw) 2459 { 2460 struct mwl8k_priv *priv = hw->priv; 2461 struct mwl8k_cmd_get_hw_spec_sta *cmd; 2462 int rc; 2463 int i; 2464 2465 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 2466 if (cmd == NULL) 2467 return -ENOMEM; 2468 2469 cmd->header.code = cpu_to_le16(MWL8K_CMD_GET_HW_SPEC); 2470 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 2471 2472 memset(cmd->perm_addr, 0xff, sizeof(cmd->perm_addr)); 2473 cmd->ps_cookie = cpu_to_le32(priv->cookie_dma); 2474 cmd->rx_queue_ptr = cpu_to_le32(priv->rxq[0].rxd_dma); 2475 cmd->num_tx_queues = cpu_to_le32(mwl8k_tx_queues(priv)); 2476 for (i = 0; i < mwl8k_tx_queues(priv); i++) 2477 cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[i].txd_dma); 2478 cmd->num_tx_desc_per_queue = cpu_to_le32(MWL8K_TX_DESCS); 2479 cmd->total_rxd = cpu_to_le32(MWL8K_RX_DESCS); 2480 2481 rc = mwl8k_post_cmd(hw, &cmd->header); 2482 2483 if (!rc) { 2484 SET_IEEE80211_PERM_ADDR(hw, cmd->perm_addr); 2485 priv->num_mcaddrs = le16_to_cpu(cmd->num_mcaddrs); 2486 priv->fw_rev = le32_to_cpu(cmd->fw_rev); 2487 priv->hw_rev = cmd->hw_rev; 2488 mwl8k_set_caps(hw, le32_to_cpu(cmd->caps)); 2489 priv->ap_macids_supported = 0x00000000; 2490 priv->sta_macids_supported = 0x00000001; 2491 } 2492 2493 kfree(cmd); 2494 return rc; 2495 } 2496 2497 /* 2498 * CMD_GET_HW_SPEC (AP version). 2499 */ 2500 struct mwl8k_cmd_get_hw_spec_ap { 2501 struct mwl8k_cmd_pkt header; 2502 __u8 hw_rev; 2503 __u8 host_interface; 2504 __le16 num_wcb; 2505 __le16 num_mcaddrs; 2506 __u8 perm_addr[ETH_ALEN]; 2507 __le16 region_code; 2508 __le16 num_antenna; 2509 __le32 fw_rev; 2510 __le32 wcbbase0; 2511 __le32 rxwrptr; 2512 __le32 rxrdptr; 2513 __le32 ps_cookie; 2514 __le32 wcbbase1; 2515 __le32 wcbbase2; 2516 __le32 wcbbase3; 2517 __le32 fw_api_version; 2518 __le32 caps; 2519 __le32 num_of_ampdu_queues; 2520 __le32 wcbbase_ampdu[MWL8K_MAX_AMPDU_QUEUES]; 2521 } __packed; 2522 2523 static int mwl8k_cmd_get_hw_spec_ap(struct ieee80211_hw *hw) 2524 { 2525 struct mwl8k_priv *priv = hw->priv; 2526 struct mwl8k_cmd_get_hw_spec_ap *cmd; 2527 int rc, i; 2528 u32 api_version; 2529 2530 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 2531 if (cmd == NULL) 2532 return -ENOMEM; 2533 2534 cmd->header.code = cpu_to_le16(MWL8K_CMD_GET_HW_SPEC); 2535 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 2536 2537 memset(cmd->perm_addr, 0xff, sizeof(cmd->perm_addr)); 2538 cmd->ps_cookie = cpu_to_le32(priv->cookie_dma); 2539 2540 rc = mwl8k_post_cmd(hw, &cmd->header); 2541 2542 if (!rc) { 2543 int off; 2544 2545 api_version = le32_to_cpu(cmd->fw_api_version); 2546 if (priv->device_info->fw_api_ap != api_version) { 2547 printk(KERN_ERR "%s: Unsupported fw API version for %s." 2548 " Expected %d got %d.\n", MWL8K_NAME, 2549 priv->device_info->part_name, 2550 priv->device_info->fw_api_ap, 2551 api_version); 2552 rc = -EINVAL; 2553 goto done; 2554 } 2555 SET_IEEE80211_PERM_ADDR(hw, cmd->perm_addr); 2556 priv->num_mcaddrs = le16_to_cpu(cmd->num_mcaddrs); 2557 priv->fw_rev = le32_to_cpu(cmd->fw_rev); 2558 priv->hw_rev = cmd->hw_rev; 2559 mwl8k_set_caps(hw, le32_to_cpu(cmd->caps)); 2560 priv->ap_macids_supported = 0x000000ff; 2561 priv->sta_macids_supported = 0x00000100; 2562 priv->num_ampdu_queues = le32_to_cpu(cmd->num_of_ampdu_queues); 2563 if (priv->num_ampdu_queues > MWL8K_MAX_AMPDU_QUEUES) { 2564 wiphy_warn(hw->wiphy, "fw reported %d ampdu queues" 2565 " but we only support %d.\n", 2566 priv->num_ampdu_queues, 2567 MWL8K_MAX_AMPDU_QUEUES); 2568 priv->num_ampdu_queues = MWL8K_MAX_AMPDU_QUEUES; 2569 } 2570 off = le32_to_cpu(cmd->rxwrptr) & 0xffff; 2571 iowrite32(priv->rxq[0].rxd_dma, priv->sram + off); 2572 2573 off = le32_to_cpu(cmd->rxrdptr) & 0xffff; 2574 iowrite32(priv->rxq[0].rxd_dma, priv->sram + off); 2575 2576 priv->txq_offset[0] = le32_to_cpu(cmd->wcbbase0) & 0xffff; 2577 priv->txq_offset[1] = le32_to_cpu(cmd->wcbbase1) & 0xffff; 2578 priv->txq_offset[2] = le32_to_cpu(cmd->wcbbase2) & 0xffff; 2579 priv->txq_offset[3] = le32_to_cpu(cmd->wcbbase3) & 0xffff; 2580 2581 for (i = 0; i < priv->num_ampdu_queues; i++) 2582 priv->txq_offset[i + MWL8K_TX_WMM_QUEUES] = 2583 le32_to_cpu(cmd->wcbbase_ampdu[i]) & 0xffff; 2584 } 2585 2586 done: 2587 kfree(cmd); 2588 return rc; 2589 } 2590 2591 /* 2592 * CMD_SET_HW_SPEC. 2593 */ 2594 struct mwl8k_cmd_set_hw_spec { 2595 struct mwl8k_cmd_pkt header; 2596 __u8 hw_rev; 2597 __u8 host_interface; 2598 __le16 num_mcaddrs; 2599 __u8 perm_addr[ETH_ALEN]; 2600 __le16 region_code; 2601 __le32 fw_rev; 2602 __le32 ps_cookie; 2603 __le32 caps; 2604 __le32 rx_queue_ptr; 2605 __le32 num_tx_queues; 2606 __le32 tx_queue_ptrs[MWL8K_MAX_TX_QUEUES]; 2607 __le32 flags; 2608 __le32 num_tx_desc_per_queue; 2609 __le32 total_rxd; 2610 } __packed; 2611 2612 /* If enabled, MWL8K_SET_HW_SPEC_FLAG_ENABLE_LIFE_TIME_EXPIRY will cause 2613 * packets to expire 500 ms after the timestamp in the tx descriptor. That is, 2614 * the packets that are queued for more than 500ms, will be dropped in the 2615 * hardware. This helps minimizing the issues caused due to head-of-line 2616 * blocking where a slow client can hog the bandwidth and affect traffic to a 2617 * faster client. 2618 */ 2619 #define MWL8K_SET_HW_SPEC_FLAG_ENABLE_LIFE_TIME_EXPIRY 0x00000400 2620 #define MWL8K_SET_HW_SPEC_FLAG_GENERATE_CCMP_HDR 0x00000200 2621 #define MWL8K_SET_HW_SPEC_FLAG_HOST_DECR_MGMT 0x00000080 2622 #define MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_PROBERESP 0x00000020 2623 #define MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_BEACON 0x00000010 2624 2625 static int mwl8k_cmd_set_hw_spec(struct ieee80211_hw *hw) 2626 { 2627 struct mwl8k_priv *priv = hw->priv; 2628 struct mwl8k_cmd_set_hw_spec *cmd; 2629 int rc; 2630 int i; 2631 2632 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 2633 if (cmd == NULL) 2634 return -ENOMEM; 2635 2636 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_HW_SPEC); 2637 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 2638 2639 cmd->ps_cookie = cpu_to_le32(priv->cookie_dma); 2640 cmd->rx_queue_ptr = cpu_to_le32(priv->rxq[0].rxd_dma); 2641 cmd->num_tx_queues = cpu_to_le32(mwl8k_tx_queues(priv)); 2642 2643 /* 2644 * Mac80211 stack has Q0 as highest priority and Q3 as lowest in 2645 * that order. Firmware has Q3 as highest priority and Q0 as lowest 2646 * in that order. Map Q3 of mac80211 to Q0 of firmware so that the 2647 * priority is interpreted the right way in firmware. 2648 */ 2649 for (i = 0; i < mwl8k_tx_queues(priv); i++) { 2650 int j = mwl8k_tx_queues(priv) - 1 - i; 2651 cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[j].txd_dma); 2652 } 2653 2654 cmd->flags = cpu_to_le32(MWL8K_SET_HW_SPEC_FLAG_HOST_DECR_MGMT | 2655 MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_PROBERESP | 2656 MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_BEACON | 2657 MWL8K_SET_HW_SPEC_FLAG_ENABLE_LIFE_TIME_EXPIRY | 2658 MWL8K_SET_HW_SPEC_FLAG_GENERATE_CCMP_HDR); 2659 cmd->num_tx_desc_per_queue = cpu_to_le32(MWL8K_TX_DESCS); 2660 cmd->total_rxd = cpu_to_le32(MWL8K_RX_DESCS); 2661 2662 rc = mwl8k_post_cmd(hw, &cmd->header); 2663 kfree(cmd); 2664 2665 return rc; 2666 } 2667 2668 /* 2669 * CMD_MAC_MULTICAST_ADR. 2670 */ 2671 struct mwl8k_cmd_mac_multicast_adr { 2672 struct mwl8k_cmd_pkt header; 2673 __le16 action; 2674 __le16 numaddr; 2675 __u8 addr[][ETH_ALEN]; 2676 }; 2677 2678 #define MWL8K_ENABLE_RX_DIRECTED 0x0001 2679 #define MWL8K_ENABLE_RX_MULTICAST 0x0002 2680 #define MWL8K_ENABLE_RX_ALL_MULTICAST 0x0004 2681 #define MWL8K_ENABLE_RX_BROADCAST 0x0008 2682 2683 static struct mwl8k_cmd_pkt * 2684 __mwl8k_cmd_mac_multicast_adr(struct ieee80211_hw *hw, int allmulti, 2685 struct netdev_hw_addr_list *mc_list) 2686 { 2687 struct mwl8k_priv *priv = hw->priv; 2688 struct mwl8k_cmd_mac_multicast_adr *cmd; 2689 int size; 2690 int mc_count = 0; 2691 2692 if (mc_list) 2693 mc_count = netdev_hw_addr_list_count(mc_list); 2694 2695 if (allmulti || mc_count > priv->num_mcaddrs) { 2696 allmulti = 1; 2697 mc_count = 0; 2698 } 2699 2700 size = sizeof(*cmd) + mc_count * ETH_ALEN; 2701 2702 cmd = kzalloc(size, GFP_ATOMIC); 2703 if (cmd == NULL) 2704 return NULL; 2705 2706 cmd->header.code = cpu_to_le16(MWL8K_CMD_MAC_MULTICAST_ADR); 2707 cmd->header.length = cpu_to_le16(size); 2708 cmd->action = cpu_to_le16(MWL8K_ENABLE_RX_DIRECTED | 2709 MWL8K_ENABLE_RX_BROADCAST); 2710 2711 if (allmulti) { 2712 cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_ALL_MULTICAST); 2713 } else if (mc_count) { 2714 struct netdev_hw_addr *ha; 2715 int i = 0; 2716 2717 cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_MULTICAST); 2718 cmd->numaddr = cpu_to_le16(mc_count); 2719 netdev_hw_addr_list_for_each(ha, mc_list) { 2720 memcpy(cmd->addr[i], ha->addr, ETH_ALEN); 2721 } 2722 } 2723 2724 return &cmd->header; 2725 } 2726 2727 /* 2728 * CMD_GET_STAT. 2729 */ 2730 struct mwl8k_cmd_get_stat { 2731 struct mwl8k_cmd_pkt header; 2732 __le32 stats[64]; 2733 } __packed; 2734 2735 #define MWL8K_STAT_ACK_FAILURE 9 2736 #define MWL8K_STAT_RTS_FAILURE 12 2737 #define MWL8K_STAT_FCS_ERROR 24 2738 #define MWL8K_STAT_RTS_SUCCESS 11 2739 2740 static int mwl8k_cmd_get_stat(struct ieee80211_hw *hw, 2741 struct ieee80211_low_level_stats *stats) 2742 { 2743 struct mwl8k_cmd_get_stat *cmd; 2744 int rc; 2745 2746 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 2747 if (cmd == NULL) 2748 return -ENOMEM; 2749 2750 cmd->header.code = cpu_to_le16(MWL8K_CMD_GET_STAT); 2751 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 2752 2753 rc = mwl8k_post_cmd(hw, &cmd->header); 2754 if (!rc) { 2755 stats->dot11ACKFailureCount = 2756 le32_to_cpu(cmd->stats[MWL8K_STAT_ACK_FAILURE]); 2757 stats->dot11RTSFailureCount = 2758 le32_to_cpu(cmd->stats[MWL8K_STAT_RTS_FAILURE]); 2759 stats->dot11FCSErrorCount = 2760 le32_to_cpu(cmd->stats[MWL8K_STAT_FCS_ERROR]); 2761 stats->dot11RTSSuccessCount = 2762 le32_to_cpu(cmd->stats[MWL8K_STAT_RTS_SUCCESS]); 2763 } 2764 kfree(cmd); 2765 2766 return rc; 2767 } 2768 2769 /* 2770 * CMD_RADIO_CONTROL. 2771 */ 2772 struct mwl8k_cmd_radio_control { 2773 struct mwl8k_cmd_pkt header; 2774 __le16 action; 2775 __le16 control; 2776 __le16 radio_on; 2777 } __packed; 2778 2779 static int 2780 mwl8k_cmd_radio_control(struct ieee80211_hw *hw, bool enable, bool force) 2781 { 2782 struct mwl8k_priv *priv = hw->priv; 2783 struct mwl8k_cmd_radio_control *cmd; 2784 int rc; 2785 2786 if (enable == priv->radio_on && !force) 2787 return 0; 2788 2789 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 2790 if (cmd == NULL) 2791 return -ENOMEM; 2792 2793 cmd->header.code = cpu_to_le16(MWL8K_CMD_RADIO_CONTROL); 2794 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 2795 cmd->action = cpu_to_le16(MWL8K_CMD_SET); 2796 cmd->control = cpu_to_le16(priv->radio_short_preamble ? 3 : 1); 2797 cmd->radio_on = cpu_to_le16(enable ? 0x0001 : 0x0000); 2798 2799 rc = mwl8k_post_cmd(hw, &cmd->header); 2800 kfree(cmd); 2801 2802 if (!rc) 2803 priv->radio_on = enable; 2804 2805 return rc; 2806 } 2807 2808 static int mwl8k_cmd_radio_disable(struct ieee80211_hw *hw) 2809 { 2810 return mwl8k_cmd_radio_control(hw, 0, 0); 2811 } 2812 2813 static int mwl8k_cmd_radio_enable(struct ieee80211_hw *hw) 2814 { 2815 return mwl8k_cmd_radio_control(hw, 1, 0); 2816 } 2817 2818 static int 2819 mwl8k_set_radio_preamble(struct ieee80211_hw *hw, bool short_preamble) 2820 { 2821 struct mwl8k_priv *priv = hw->priv; 2822 2823 priv->radio_short_preamble = short_preamble; 2824 2825 return mwl8k_cmd_radio_control(hw, 1, 1); 2826 } 2827 2828 /* 2829 * CMD_RF_TX_POWER. 2830 */ 2831 #define MWL8K_RF_TX_POWER_LEVEL_TOTAL 8 2832 2833 struct mwl8k_cmd_rf_tx_power { 2834 struct mwl8k_cmd_pkt header; 2835 __le16 action; 2836 __le16 support_level; 2837 __le16 current_level; 2838 __le16 reserved; 2839 __le16 power_level_list[MWL8K_RF_TX_POWER_LEVEL_TOTAL]; 2840 } __packed; 2841 2842 static int mwl8k_cmd_rf_tx_power(struct ieee80211_hw *hw, int dBm) 2843 { 2844 struct mwl8k_cmd_rf_tx_power *cmd; 2845 int rc; 2846 2847 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 2848 if (cmd == NULL) 2849 return -ENOMEM; 2850 2851 cmd->header.code = cpu_to_le16(MWL8K_CMD_RF_TX_POWER); 2852 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 2853 cmd->action = cpu_to_le16(MWL8K_CMD_SET); 2854 cmd->support_level = cpu_to_le16(dBm); 2855 2856 rc = mwl8k_post_cmd(hw, &cmd->header); 2857 kfree(cmd); 2858 2859 return rc; 2860 } 2861 2862 /* 2863 * CMD_TX_POWER. 2864 */ 2865 #define MWL8K_TX_POWER_LEVEL_TOTAL 12 2866 2867 struct mwl8k_cmd_tx_power { 2868 struct mwl8k_cmd_pkt header; 2869 __le16 action; 2870 __le16 band; 2871 __le16 channel; 2872 __le16 bw; 2873 __le16 sub_ch; 2874 __le16 power_level_list[MWL8K_TX_POWER_LEVEL_TOTAL]; 2875 } __packed; 2876 2877 static int mwl8k_cmd_tx_power(struct ieee80211_hw *hw, 2878 struct ieee80211_conf *conf, 2879 unsigned short pwr) 2880 { 2881 struct ieee80211_channel *channel = conf->chandef.chan; 2882 enum nl80211_channel_type channel_type = 2883 cfg80211_get_chandef_type(&conf->chandef); 2884 struct mwl8k_cmd_tx_power *cmd; 2885 int rc; 2886 int i; 2887 2888 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 2889 if (cmd == NULL) 2890 return -ENOMEM; 2891 2892 cmd->header.code = cpu_to_le16(MWL8K_CMD_TX_POWER); 2893 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 2894 cmd->action = cpu_to_le16(MWL8K_CMD_SET_LIST); 2895 2896 if (channel->band == NL80211_BAND_2GHZ) 2897 cmd->band = cpu_to_le16(0x1); 2898 else if (channel->band == NL80211_BAND_5GHZ) 2899 cmd->band = cpu_to_le16(0x4); 2900 2901 cmd->channel = cpu_to_le16(channel->hw_value); 2902 2903 if (channel_type == NL80211_CHAN_NO_HT || 2904 channel_type == NL80211_CHAN_HT20) { 2905 cmd->bw = cpu_to_le16(0x2); 2906 } else { 2907 cmd->bw = cpu_to_le16(0x4); 2908 if (channel_type == NL80211_CHAN_HT40MINUS) 2909 cmd->sub_ch = cpu_to_le16(0x3); 2910 else if (channel_type == NL80211_CHAN_HT40PLUS) 2911 cmd->sub_ch = cpu_to_le16(0x1); 2912 } 2913 2914 for (i = 0; i < MWL8K_TX_POWER_LEVEL_TOTAL; i++) 2915 cmd->power_level_list[i] = cpu_to_le16(pwr); 2916 2917 rc = mwl8k_post_cmd(hw, &cmd->header); 2918 kfree(cmd); 2919 2920 return rc; 2921 } 2922 2923 /* 2924 * CMD_RF_ANTENNA. 2925 */ 2926 struct mwl8k_cmd_rf_antenna { 2927 struct mwl8k_cmd_pkt header; 2928 __le16 antenna; 2929 __le16 mode; 2930 } __packed; 2931 2932 #define MWL8K_RF_ANTENNA_RX 1 2933 #define MWL8K_RF_ANTENNA_TX 2 2934 2935 static int 2936 mwl8k_cmd_rf_antenna(struct ieee80211_hw *hw, int antenna, int mask) 2937 { 2938 struct mwl8k_cmd_rf_antenna *cmd; 2939 int rc; 2940 2941 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 2942 if (cmd == NULL) 2943 return -ENOMEM; 2944 2945 cmd->header.code = cpu_to_le16(MWL8K_CMD_RF_ANTENNA); 2946 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 2947 cmd->antenna = cpu_to_le16(antenna); 2948 cmd->mode = cpu_to_le16(mask); 2949 2950 rc = mwl8k_post_cmd(hw, &cmd->header); 2951 kfree(cmd); 2952 2953 return rc; 2954 } 2955 2956 /* 2957 * CMD_SET_BEACON. 2958 */ 2959 struct mwl8k_cmd_set_beacon { 2960 struct mwl8k_cmd_pkt header; 2961 __le16 beacon_len; 2962 __u8 beacon[]; 2963 }; 2964 2965 static int mwl8k_cmd_set_beacon(struct ieee80211_hw *hw, 2966 struct ieee80211_vif *vif, u8 *beacon, int len) 2967 { 2968 struct mwl8k_cmd_set_beacon *cmd; 2969 int rc; 2970 2971 cmd = kzalloc(sizeof(*cmd) + len, GFP_KERNEL); 2972 if (cmd == NULL) 2973 return -ENOMEM; 2974 2975 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_BEACON); 2976 cmd->header.length = cpu_to_le16(sizeof(*cmd) + len); 2977 cmd->beacon_len = cpu_to_le16(len); 2978 memcpy(cmd->beacon, beacon, len); 2979 2980 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header); 2981 kfree(cmd); 2982 2983 return rc; 2984 } 2985 2986 /* 2987 * CMD_SET_PRE_SCAN. 2988 */ 2989 struct mwl8k_cmd_set_pre_scan { 2990 struct mwl8k_cmd_pkt header; 2991 } __packed; 2992 2993 static int mwl8k_cmd_set_pre_scan(struct ieee80211_hw *hw) 2994 { 2995 struct mwl8k_cmd_set_pre_scan *cmd; 2996 int rc; 2997 2998 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 2999 if (cmd == NULL) 3000 return -ENOMEM; 3001 3002 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_PRE_SCAN); 3003 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3004 3005 rc = mwl8k_post_cmd(hw, &cmd->header); 3006 kfree(cmd); 3007 3008 return rc; 3009 } 3010 3011 /* 3012 * CMD_BBP_REG_ACCESS. 3013 */ 3014 struct mwl8k_cmd_bbp_reg_access { 3015 struct mwl8k_cmd_pkt header; 3016 __le16 action; 3017 __le16 offset; 3018 u8 value; 3019 u8 rsrv[3]; 3020 } __packed; 3021 3022 static int 3023 mwl8k_cmd_bbp_reg_access(struct ieee80211_hw *hw, 3024 u16 action, 3025 u16 offset, 3026 u8 *value) 3027 { 3028 struct mwl8k_cmd_bbp_reg_access *cmd; 3029 int rc; 3030 3031 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3032 if (cmd == NULL) 3033 return -ENOMEM; 3034 3035 cmd->header.code = cpu_to_le16(MWL8K_CMD_BBP_REG_ACCESS); 3036 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3037 cmd->action = cpu_to_le16(action); 3038 cmd->offset = cpu_to_le16(offset); 3039 3040 rc = mwl8k_post_cmd(hw, &cmd->header); 3041 3042 if (!rc) 3043 *value = cmd->value; 3044 else 3045 *value = 0; 3046 3047 kfree(cmd); 3048 3049 return rc; 3050 } 3051 3052 /* 3053 * CMD_SET_POST_SCAN. 3054 */ 3055 struct mwl8k_cmd_set_post_scan { 3056 struct mwl8k_cmd_pkt header; 3057 __le32 isibss; 3058 __u8 bssid[ETH_ALEN]; 3059 } __packed; 3060 3061 static int 3062 mwl8k_cmd_set_post_scan(struct ieee80211_hw *hw, const __u8 *mac) 3063 { 3064 struct mwl8k_cmd_set_post_scan *cmd; 3065 int rc; 3066 3067 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3068 if (cmd == NULL) 3069 return -ENOMEM; 3070 3071 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_POST_SCAN); 3072 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3073 cmd->isibss = 0; 3074 memcpy(cmd->bssid, mac, ETH_ALEN); 3075 3076 rc = mwl8k_post_cmd(hw, &cmd->header); 3077 kfree(cmd); 3078 3079 return rc; 3080 } 3081 3082 static int freq_to_idx(struct mwl8k_priv *priv, int freq) 3083 { 3084 struct ieee80211_supported_band *sband; 3085 int band, ch, idx = 0; 3086 3087 for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; band++) { 3088 sband = priv->hw->wiphy->bands[band]; 3089 if (!sband) 3090 continue; 3091 3092 for (ch = 0; ch < sband->n_channels; ch++, idx++) 3093 if (sband->channels[ch].center_freq == freq) 3094 goto exit; 3095 } 3096 3097 exit: 3098 return idx; 3099 } 3100 3101 static void mwl8k_update_survey(struct mwl8k_priv *priv, 3102 struct ieee80211_channel *channel) 3103 { 3104 u32 cca_cnt, rx_rdy; 3105 s8 nf = 0, idx; 3106 struct survey_info *survey; 3107 3108 idx = freq_to_idx(priv, priv->acs_chan->center_freq); 3109 if (idx >= MWL8K_NUM_CHANS) { 3110 wiphy_err(priv->hw->wiphy, "Failed to update survey\n"); 3111 return; 3112 } 3113 3114 survey = &priv->survey[idx]; 3115 3116 cca_cnt = ioread32(priv->regs + NOK_CCA_CNT_REG); 3117 cca_cnt /= 1000; /* uSecs to mSecs */ 3118 survey->time_busy = (u64) cca_cnt; 3119 3120 rx_rdy = ioread32(priv->regs + BBU_RXRDY_CNT_REG); 3121 rx_rdy /= 1000; /* uSecs to mSecs */ 3122 survey->time_rx = (u64) rx_rdy; 3123 3124 priv->channel_time = jiffies - priv->channel_time; 3125 survey->time = jiffies_to_msecs(priv->channel_time); 3126 3127 survey->channel = channel; 3128 3129 mwl8k_cmd_bbp_reg_access(priv->hw, 0, BBU_AVG_NOISE_VAL, &nf); 3130 3131 /* Make sure sign is negative else ACS at hostapd fails */ 3132 survey->noise = nf * -1; 3133 3134 survey->filled = SURVEY_INFO_NOISE_DBM | 3135 SURVEY_INFO_TIME | 3136 SURVEY_INFO_TIME_BUSY | 3137 SURVEY_INFO_TIME_RX; 3138 } 3139 3140 /* 3141 * CMD_SET_RF_CHANNEL. 3142 */ 3143 struct mwl8k_cmd_set_rf_channel { 3144 struct mwl8k_cmd_pkt header; 3145 __le16 action; 3146 __u8 current_channel; 3147 __le32 channel_flags; 3148 } __packed; 3149 3150 static int mwl8k_cmd_set_rf_channel(struct ieee80211_hw *hw, 3151 struct ieee80211_conf *conf) 3152 { 3153 struct ieee80211_channel *channel = conf->chandef.chan; 3154 enum nl80211_channel_type channel_type = 3155 cfg80211_get_chandef_type(&conf->chandef); 3156 struct mwl8k_cmd_set_rf_channel *cmd; 3157 struct mwl8k_priv *priv = hw->priv; 3158 int rc; 3159 3160 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3161 if (cmd == NULL) 3162 return -ENOMEM; 3163 3164 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RF_CHANNEL); 3165 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3166 cmd->action = cpu_to_le16(MWL8K_CMD_SET); 3167 cmd->current_channel = channel->hw_value; 3168 3169 if (channel->band == NL80211_BAND_2GHZ) 3170 cmd->channel_flags |= cpu_to_le32(0x00000001); 3171 else if (channel->band == NL80211_BAND_5GHZ) 3172 cmd->channel_flags |= cpu_to_le32(0x00000004); 3173 3174 if (!priv->sw_scan_start) { 3175 if (channel_type == NL80211_CHAN_NO_HT || 3176 channel_type == NL80211_CHAN_HT20) 3177 cmd->channel_flags |= cpu_to_le32(0x00000080); 3178 else if (channel_type == NL80211_CHAN_HT40MINUS) 3179 cmd->channel_flags |= cpu_to_le32(0x000001900); 3180 else if (channel_type == NL80211_CHAN_HT40PLUS) 3181 cmd->channel_flags |= cpu_to_le32(0x000000900); 3182 } else { 3183 cmd->channel_flags |= cpu_to_le32(0x00000080); 3184 } 3185 3186 if (priv->sw_scan_start) { 3187 /* Store current channel stats 3188 * before switching to newer one. 3189 * This will be processed only for AP fw. 3190 */ 3191 if (priv->channel_time != 0) 3192 mwl8k_update_survey(priv, priv->acs_chan); 3193 3194 priv->channel_time = jiffies; 3195 priv->acs_chan = channel; 3196 } 3197 3198 rc = mwl8k_post_cmd(hw, &cmd->header); 3199 kfree(cmd); 3200 3201 return rc; 3202 } 3203 3204 /* 3205 * CMD_SET_AID. 3206 */ 3207 #define MWL8K_FRAME_PROT_DISABLED 0x00 3208 #define MWL8K_FRAME_PROT_11G 0x07 3209 #define MWL8K_FRAME_PROT_11N_HT_40MHZ_ONLY 0x02 3210 #define MWL8K_FRAME_PROT_11N_HT_ALL 0x06 3211 3212 struct mwl8k_cmd_update_set_aid { 3213 struct mwl8k_cmd_pkt header; 3214 __le16 aid; 3215 3216 /* AP's MAC address (BSSID) */ 3217 __u8 bssid[ETH_ALEN]; 3218 __le16 protection_mode; 3219 __u8 supp_rates[14]; 3220 } __packed; 3221 3222 static void legacy_rate_mask_to_array(u8 *rates, u32 mask) 3223 { 3224 int i; 3225 int j; 3226 3227 /* 3228 * Clear nonstandard rate 4. 3229 */ 3230 mask &= 0x1fef; 3231 3232 for (i = 0, j = 0; i < 13; i++) { 3233 if (mask & (1 << i)) 3234 rates[j++] = mwl8k_rates_24[i].hw_value; 3235 } 3236 } 3237 3238 static int 3239 mwl8k_cmd_set_aid(struct ieee80211_hw *hw, 3240 struct ieee80211_vif *vif, u32 legacy_rate_mask) 3241 { 3242 struct mwl8k_cmd_update_set_aid *cmd; 3243 u16 prot_mode; 3244 int rc; 3245 3246 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3247 if (cmd == NULL) 3248 return -ENOMEM; 3249 3250 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_AID); 3251 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3252 cmd->aid = cpu_to_le16(vif->bss_conf.aid); 3253 memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN); 3254 3255 if (vif->bss_conf.use_cts_prot) { 3256 prot_mode = MWL8K_FRAME_PROT_11G; 3257 } else { 3258 switch (vif->bss_conf.ht_operation_mode & 3259 IEEE80211_HT_OP_MODE_PROTECTION) { 3260 case IEEE80211_HT_OP_MODE_PROTECTION_20MHZ: 3261 prot_mode = MWL8K_FRAME_PROT_11N_HT_40MHZ_ONLY; 3262 break; 3263 case IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED: 3264 prot_mode = MWL8K_FRAME_PROT_11N_HT_ALL; 3265 break; 3266 default: 3267 prot_mode = MWL8K_FRAME_PROT_DISABLED; 3268 break; 3269 } 3270 } 3271 cmd->protection_mode = cpu_to_le16(prot_mode); 3272 3273 legacy_rate_mask_to_array(cmd->supp_rates, legacy_rate_mask); 3274 3275 rc = mwl8k_post_cmd(hw, &cmd->header); 3276 kfree(cmd); 3277 3278 return rc; 3279 } 3280 3281 /* 3282 * CMD_SET_RATE. 3283 */ 3284 struct mwl8k_cmd_set_rate { 3285 struct mwl8k_cmd_pkt header; 3286 __u8 legacy_rates[14]; 3287 3288 /* Bitmap for supported MCS codes. */ 3289 __u8 mcs_set[16]; 3290 __u8 reserved[16]; 3291 } __packed; 3292 3293 static int 3294 mwl8k_cmd_set_rate(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 3295 u32 legacy_rate_mask, u8 *mcs_rates) 3296 { 3297 struct mwl8k_cmd_set_rate *cmd; 3298 int rc; 3299 3300 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3301 if (cmd == NULL) 3302 return -ENOMEM; 3303 3304 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATE); 3305 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3306 legacy_rate_mask_to_array(cmd->legacy_rates, legacy_rate_mask); 3307 memcpy(cmd->mcs_set, mcs_rates, 16); 3308 3309 rc = mwl8k_post_cmd(hw, &cmd->header); 3310 kfree(cmd); 3311 3312 return rc; 3313 } 3314 3315 /* 3316 * CMD_FINALIZE_JOIN. 3317 */ 3318 #define MWL8K_FJ_BEACON_MAXLEN 128 3319 3320 struct mwl8k_cmd_finalize_join { 3321 struct mwl8k_cmd_pkt header; 3322 __le32 sleep_interval; /* Number of beacon periods to sleep */ 3323 __u8 beacon_data[MWL8K_FJ_BEACON_MAXLEN]; 3324 } __packed; 3325 3326 static int mwl8k_cmd_finalize_join(struct ieee80211_hw *hw, void *frame, 3327 int framelen, int dtim) 3328 { 3329 struct mwl8k_cmd_finalize_join *cmd; 3330 struct ieee80211_mgmt *payload = frame; 3331 int payload_len; 3332 int rc; 3333 3334 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3335 if (cmd == NULL) 3336 return -ENOMEM; 3337 3338 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_FINALIZE_JOIN); 3339 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3340 cmd->sleep_interval = cpu_to_le32(dtim ? dtim : 1); 3341 3342 payload_len = framelen - ieee80211_hdrlen(payload->frame_control); 3343 if (payload_len < 0) 3344 payload_len = 0; 3345 else if (payload_len > MWL8K_FJ_BEACON_MAXLEN) 3346 payload_len = MWL8K_FJ_BEACON_MAXLEN; 3347 3348 memcpy(cmd->beacon_data, &payload->u.beacon, payload_len); 3349 3350 rc = mwl8k_post_cmd(hw, &cmd->header); 3351 kfree(cmd); 3352 3353 return rc; 3354 } 3355 3356 /* 3357 * CMD_SET_RTS_THRESHOLD. 3358 */ 3359 struct mwl8k_cmd_set_rts_threshold { 3360 struct mwl8k_cmd_pkt header; 3361 __le16 action; 3362 __le16 threshold; 3363 } __packed; 3364 3365 static int 3366 mwl8k_cmd_set_rts_threshold(struct ieee80211_hw *hw, int rts_thresh) 3367 { 3368 struct mwl8k_cmd_set_rts_threshold *cmd; 3369 int rc; 3370 3371 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3372 if (cmd == NULL) 3373 return -ENOMEM; 3374 3375 cmd->header.code = cpu_to_le16(MWL8K_CMD_RTS_THRESHOLD); 3376 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3377 cmd->action = cpu_to_le16(MWL8K_CMD_SET); 3378 cmd->threshold = cpu_to_le16(rts_thresh); 3379 3380 rc = mwl8k_post_cmd(hw, &cmd->header); 3381 kfree(cmd); 3382 3383 return rc; 3384 } 3385 3386 /* 3387 * CMD_SET_SLOT. 3388 */ 3389 struct mwl8k_cmd_set_slot { 3390 struct mwl8k_cmd_pkt header; 3391 __le16 action; 3392 __u8 short_slot; 3393 } __packed; 3394 3395 static int mwl8k_cmd_set_slot(struct ieee80211_hw *hw, bool short_slot_time) 3396 { 3397 struct mwl8k_cmd_set_slot *cmd; 3398 int rc; 3399 3400 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3401 if (cmd == NULL) 3402 return -ENOMEM; 3403 3404 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_SLOT); 3405 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3406 cmd->action = cpu_to_le16(MWL8K_CMD_SET); 3407 cmd->short_slot = short_slot_time; 3408 3409 rc = mwl8k_post_cmd(hw, &cmd->header); 3410 kfree(cmd); 3411 3412 return rc; 3413 } 3414 3415 /* 3416 * CMD_SET_EDCA_PARAMS. 3417 */ 3418 struct mwl8k_cmd_set_edca_params { 3419 struct mwl8k_cmd_pkt header; 3420 3421 /* See MWL8K_SET_EDCA_XXX below */ 3422 __le16 action; 3423 3424 /* TX opportunity in units of 32 us */ 3425 __le16 txop; 3426 3427 union { 3428 struct { 3429 /* Log exponent of max contention period: 0...15 */ 3430 __le32 log_cw_max; 3431 3432 /* Log exponent of min contention period: 0...15 */ 3433 __le32 log_cw_min; 3434 3435 /* Adaptive interframe spacing in units of 32us */ 3436 __u8 aifs; 3437 3438 /* TX queue to configure */ 3439 __u8 txq; 3440 } ap; 3441 struct { 3442 /* Log exponent of max contention period: 0...15 */ 3443 __u8 log_cw_max; 3444 3445 /* Log exponent of min contention period: 0...15 */ 3446 __u8 log_cw_min; 3447 3448 /* Adaptive interframe spacing in units of 32us */ 3449 __u8 aifs; 3450 3451 /* TX queue to configure */ 3452 __u8 txq; 3453 } sta; 3454 }; 3455 } __packed; 3456 3457 #define MWL8K_SET_EDCA_CW 0x01 3458 #define MWL8K_SET_EDCA_TXOP 0x02 3459 #define MWL8K_SET_EDCA_AIFS 0x04 3460 3461 #define MWL8K_SET_EDCA_ALL (MWL8K_SET_EDCA_CW | \ 3462 MWL8K_SET_EDCA_TXOP | \ 3463 MWL8K_SET_EDCA_AIFS) 3464 3465 static int 3466 mwl8k_cmd_set_edca_params(struct ieee80211_hw *hw, __u8 qnum, 3467 __u16 cw_min, __u16 cw_max, 3468 __u8 aifs, __u16 txop) 3469 { 3470 struct mwl8k_priv *priv = hw->priv; 3471 struct mwl8k_cmd_set_edca_params *cmd; 3472 int rc; 3473 3474 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3475 if (cmd == NULL) 3476 return -ENOMEM; 3477 3478 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_EDCA_PARAMS); 3479 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3480 cmd->action = cpu_to_le16(MWL8K_SET_EDCA_ALL); 3481 cmd->txop = cpu_to_le16(txop); 3482 if (priv->ap_fw) { 3483 cmd->ap.log_cw_max = cpu_to_le32(ilog2(cw_max + 1)); 3484 cmd->ap.log_cw_min = cpu_to_le32(ilog2(cw_min + 1)); 3485 cmd->ap.aifs = aifs; 3486 cmd->ap.txq = qnum; 3487 } else { 3488 cmd->sta.log_cw_max = (u8)ilog2(cw_max + 1); 3489 cmd->sta.log_cw_min = (u8)ilog2(cw_min + 1); 3490 cmd->sta.aifs = aifs; 3491 cmd->sta.txq = qnum; 3492 } 3493 3494 rc = mwl8k_post_cmd(hw, &cmd->header); 3495 kfree(cmd); 3496 3497 return rc; 3498 } 3499 3500 /* 3501 * CMD_SET_WMM_MODE. 3502 */ 3503 struct mwl8k_cmd_set_wmm_mode { 3504 struct mwl8k_cmd_pkt header; 3505 __le16 action; 3506 } __packed; 3507 3508 static int mwl8k_cmd_set_wmm_mode(struct ieee80211_hw *hw, bool enable) 3509 { 3510 struct mwl8k_priv *priv = hw->priv; 3511 struct mwl8k_cmd_set_wmm_mode *cmd; 3512 int rc; 3513 3514 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3515 if (cmd == NULL) 3516 return -ENOMEM; 3517 3518 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_WMM_MODE); 3519 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3520 cmd->action = cpu_to_le16(!!enable); 3521 3522 rc = mwl8k_post_cmd(hw, &cmd->header); 3523 kfree(cmd); 3524 3525 if (!rc) 3526 priv->wmm_enabled = enable; 3527 3528 return rc; 3529 } 3530 3531 /* 3532 * CMD_MIMO_CONFIG. 3533 */ 3534 struct mwl8k_cmd_mimo_config { 3535 struct mwl8k_cmd_pkt header; 3536 __le32 action; 3537 __u8 rx_antenna_map; 3538 __u8 tx_antenna_map; 3539 } __packed; 3540 3541 static int mwl8k_cmd_mimo_config(struct ieee80211_hw *hw, __u8 rx, __u8 tx) 3542 { 3543 struct mwl8k_cmd_mimo_config *cmd; 3544 int rc; 3545 3546 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3547 if (cmd == NULL) 3548 return -ENOMEM; 3549 3550 cmd->header.code = cpu_to_le16(MWL8K_CMD_MIMO_CONFIG); 3551 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3552 cmd->action = cpu_to_le32((u32)MWL8K_CMD_SET); 3553 cmd->rx_antenna_map = rx; 3554 cmd->tx_antenna_map = tx; 3555 3556 rc = mwl8k_post_cmd(hw, &cmd->header); 3557 kfree(cmd); 3558 3559 return rc; 3560 } 3561 3562 /* 3563 * CMD_USE_FIXED_RATE (STA version). 3564 */ 3565 struct mwl8k_cmd_use_fixed_rate_sta { 3566 struct mwl8k_cmd_pkt header; 3567 __le32 action; 3568 __le32 allow_rate_drop; 3569 __le32 num_rates; 3570 struct { 3571 __le32 is_ht_rate; 3572 __le32 enable_retry; 3573 __le32 rate; 3574 __le32 retry_count; 3575 } rate_entry[8]; 3576 __le32 rate_type; 3577 __le32 reserved1; 3578 __le32 reserved2; 3579 } __packed; 3580 3581 #define MWL8K_USE_AUTO_RATE 0x0002 3582 #define MWL8K_UCAST_RATE 0 3583 3584 static int mwl8k_cmd_use_fixed_rate_sta(struct ieee80211_hw *hw) 3585 { 3586 struct mwl8k_cmd_use_fixed_rate_sta *cmd; 3587 int rc; 3588 3589 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3590 if (cmd == NULL) 3591 return -ENOMEM; 3592 3593 cmd->header.code = cpu_to_le16(MWL8K_CMD_USE_FIXED_RATE); 3594 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3595 cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE); 3596 cmd->rate_type = cpu_to_le32(MWL8K_UCAST_RATE); 3597 3598 rc = mwl8k_post_cmd(hw, &cmd->header); 3599 kfree(cmd); 3600 3601 return rc; 3602 } 3603 3604 /* 3605 * CMD_USE_FIXED_RATE (AP version). 3606 */ 3607 struct mwl8k_cmd_use_fixed_rate_ap { 3608 struct mwl8k_cmd_pkt header; 3609 __le32 action; 3610 __le32 allow_rate_drop; 3611 __le32 num_rates; 3612 struct mwl8k_rate_entry_ap { 3613 __le32 is_ht_rate; 3614 __le32 enable_retry; 3615 __le32 rate; 3616 __le32 retry_count; 3617 } rate_entry[4]; 3618 u8 multicast_rate; 3619 u8 multicast_rate_type; 3620 u8 management_rate; 3621 } __packed; 3622 3623 static int 3624 mwl8k_cmd_use_fixed_rate_ap(struct ieee80211_hw *hw, int mcast, int mgmt) 3625 { 3626 struct mwl8k_cmd_use_fixed_rate_ap *cmd; 3627 int rc; 3628 3629 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3630 if (cmd == NULL) 3631 return -ENOMEM; 3632 3633 cmd->header.code = cpu_to_le16(MWL8K_CMD_USE_FIXED_RATE); 3634 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3635 cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE); 3636 cmd->multicast_rate = mcast; 3637 cmd->management_rate = mgmt; 3638 3639 rc = mwl8k_post_cmd(hw, &cmd->header); 3640 kfree(cmd); 3641 3642 return rc; 3643 } 3644 3645 /* 3646 * CMD_ENABLE_SNIFFER. 3647 */ 3648 struct mwl8k_cmd_enable_sniffer { 3649 struct mwl8k_cmd_pkt header; 3650 __le32 action; 3651 } __packed; 3652 3653 static int mwl8k_cmd_enable_sniffer(struct ieee80211_hw *hw, bool enable) 3654 { 3655 struct mwl8k_cmd_enable_sniffer *cmd; 3656 int rc; 3657 3658 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3659 if (cmd == NULL) 3660 return -ENOMEM; 3661 3662 cmd->header.code = cpu_to_le16(MWL8K_CMD_ENABLE_SNIFFER); 3663 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3664 cmd->action = cpu_to_le32(!!enable); 3665 3666 rc = mwl8k_post_cmd(hw, &cmd->header); 3667 kfree(cmd); 3668 3669 return rc; 3670 } 3671 3672 struct mwl8k_cmd_update_mac_addr { 3673 struct mwl8k_cmd_pkt header; 3674 union { 3675 struct { 3676 __le16 mac_type; 3677 __u8 mac_addr[ETH_ALEN]; 3678 } mbss; 3679 __u8 mac_addr[ETH_ALEN]; 3680 }; 3681 } __packed; 3682 3683 #define MWL8K_MAC_TYPE_PRIMARY_CLIENT 0 3684 #define MWL8K_MAC_TYPE_SECONDARY_CLIENT 1 3685 #define MWL8K_MAC_TYPE_PRIMARY_AP 2 3686 #define MWL8K_MAC_TYPE_SECONDARY_AP 3 3687 3688 static int mwl8k_cmd_update_mac_addr(struct ieee80211_hw *hw, 3689 struct ieee80211_vif *vif, u8 *mac, bool set) 3690 { 3691 struct mwl8k_priv *priv = hw->priv; 3692 struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif); 3693 struct mwl8k_cmd_update_mac_addr *cmd; 3694 int mac_type; 3695 int rc; 3696 3697 mac_type = MWL8K_MAC_TYPE_PRIMARY_AP; 3698 if (vif != NULL && vif->type == NL80211_IFTYPE_STATION) { 3699 if (mwl8k_vif->macid + 1 == ffs(priv->sta_macids_supported)) 3700 if (priv->ap_fw) 3701 mac_type = MWL8K_MAC_TYPE_SECONDARY_CLIENT; 3702 else 3703 mac_type = MWL8K_MAC_TYPE_PRIMARY_CLIENT; 3704 else 3705 mac_type = MWL8K_MAC_TYPE_SECONDARY_CLIENT; 3706 } else if (vif != NULL && vif->type == NL80211_IFTYPE_AP) { 3707 if (mwl8k_vif->macid + 1 == ffs(priv->ap_macids_supported)) 3708 mac_type = MWL8K_MAC_TYPE_PRIMARY_AP; 3709 else 3710 mac_type = MWL8K_MAC_TYPE_SECONDARY_AP; 3711 } 3712 3713 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3714 if (cmd == NULL) 3715 return -ENOMEM; 3716 3717 if (set) 3718 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_MAC_ADDR); 3719 else 3720 cmd->header.code = cpu_to_le16(MWL8K_CMD_DEL_MAC_ADDR); 3721 3722 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3723 if (priv->ap_fw) { 3724 cmd->mbss.mac_type = cpu_to_le16(mac_type); 3725 memcpy(cmd->mbss.mac_addr, mac, ETH_ALEN); 3726 } else { 3727 memcpy(cmd->mac_addr, mac, ETH_ALEN); 3728 } 3729 3730 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header); 3731 kfree(cmd); 3732 3733 return rc; 3734 } 3735 3736 /* 3737 * MWL8K_CMD_SET_MAC_ADDR. 3738 */ 3739 static inline int mwl8k_cmd_set_mac_addr(struct ieee80211_hw *hw, 3740 struct ieee80211_vif *vif, u8 *mac) 3741 { 3742 return mwl8k_cmd_update_mac_addr(hw, vif, mac, true); 3743 } 3744 3745 /* 3746 * MWL8K_CMD_DEL_MAC_ADDR. 3747 */ 3748 static inline int mwl8k_cmd_del_mac_addr(struct ieee80211_hw *hw, 3749 struct ieee80211_vif *vif, u8 *mac) 3750 { 3751 return mwl8k_cmd_update_mac_addr(hw, vif, mac, false); 3752 } 3753 3754 /* 3755 * CMD_SET_RATEADAPT_MODE. 3756 */ 3757 struct mwl8k_cmd_set_rate_adapt_mode { 3758 struct mwl8k_cmd_pkt header; 3759 __le16 action; 3760 __le16 mode; 3761 } __packed; 3762 3763 static int mwl8k_cmd_set_rateadapt_mode(struct ieee80211_hw *hw, __u16 mode) 3764 { 3765 struct mwl8k_cmd_set_rate_adapt_mode *cmd; 3766 int rc; 3767 3768 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3769 if (cmd == NULL) 3770 return -ENOMEM; 3771 3772 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATEADAPT_MODE); 3773 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3774 cmd->action = cpu_to_le16(MWL8K_CMD_SET); 3775 cmd->mode = cpu_to_le16(mode); 3776 3777 rc = mwl8k_post_cmd(hw, &cmd->header); 3778 kfree(cmd); 3779 3780 return rc; 3781 } 3782 3783 /* 3784 * CMD_GET_WATCHDOG_BITMAP. 3785 */ 3786 struct mwl8k_cmd_get_watchdog_bitmap { 3787 struct mwl8k_cmd_pkt header; 3788 u8 bitmap; 3789 } __packed; 3790 3791 static int mwl8k_cmd_get_watchdog_bitmap(struct ieee80211_hw *hw, u8 *bitmap) 3792 { 3793 struct mwl8k_cmd_get_watchdog_bitmap *cmd; 3794 int rc; 3795 3796 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3797 if (cmd == NULL) 3798 return -ENOMEM; 3799 3800 cmd->header.code = cpu_to_le16(MWL8K_CMD_GET_WATCHDOG_BITMAP); 3801 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3802 3803 rc = mwl8k_post_cmd(hw, &cmd->header); 3804 if (!rc) 3805 *bitmap = cmd->bitmap; 3806 3807 kfree(cmd); 3808 3809 return rc; 3810 } 3811 3812 #define MWL8K_WMM_QUEUE_NUMBER 3 3813 3814 static void mwl8k_destroy_ba(struct ieee80211_hw *hw, 3815 u8 idx); 3816 3817 static void mwl8k_watchdog_ba_events(struct work_struct *work) 3818 { 3819 int rc; 3820 u8 bitmap = 0, stream_index; 3821 struct mwl8k_ampdu_stream *streams; 3822 struct mwl8k_priv *priv = 3823 container_of(work, struct mwl8k_priv, watchdog_ba_handle); 3824 struct ieee80211_hw *hw = priv->hw; 3825 int i; 3826 u32 status = 0; 3827 3828 mwl8k_fw_lock(hw); 3829 3830 rc = mwl8k_cmd_get_watchdog_bitmap(priv->hw, &bitmap); 3831 if (rc) 3832 goto done; 3833 3834 spin_lock(&priv->stream_lock); 3835 3836 /* the bitmap is the hw queue number. Map it to the ampdu queue. */ 3837 for (i = 0; i < TOTAL_HW_TX_QUEUES; i++) { 3838 if (bitmap & (1 << i)) { 3839 stream_index = (i + MWL8K_WMM_QUEUE_NUMBER) % 3840 TOTAL_HW_TX_QUEUES; 3841 streams = &priv->ampdu[stream_index]; 3842 if (streams->state == AMPDU_STREAM_ACTIVE) { 3843 ieee80211_stop_tx_ba_session(streams->sta, 3844 streams->tid); 3845 spin_unlock(&priv->stream_lock); 3846 mwl8k_destroy_ba(hw, stream_index); 3847 spin_lock(&priv->stream_lock); 3848 } 3849 } 3850 } 3851 3852 spin_unlock(&priv->stream_lock); 3853 done: 3854 atomic_dec(&priv->watchdog_event_pending); 3855 status = ioread32(priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK); 3856 iowrite32((status | MWL8K_A2H_INT_BA_WATCHDOG), 3857 priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK); 3858 mwl8k_fw_unlock(hw); 3859 return; 3860 } 3861 3862 3863 /* 3864 * CMD_BSS_START. 3865 */ 3866 struct mwl8k_cmd_bss_start { 3867 struct mwl8k_cmd_pkt header; 3868 __le32 enable; 3869 } __packed; 3870 3871 static int mwl8k_cmd_bss_start(struct ieee80211_hw *hw, 3872 struct ieee80211_vif *vif, int enable) 3873 { 3874 struct mwl8k_cmd_bss_start *cmd; 3875 struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif); 3876 struct mwl8k_priv *priv = hw->priv; 3877 int rc; 3878 3879 if (enable && (priv->running_bsses & (1 << mwl8k_vif->macid))) 3880 return 0; 3881 3882 if (!enable && !(priv->running_bsses & (1 << mwl8k_vif->macid))) 3883 return 0; 3884 3885 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3886 if (cmd == NULL) 3887 return -ENOMEM; 3888 3889 cmd->header.code = cpu_to_le16(MWL8K_CMD_BSS_START); 3890 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3891 cmd->enable = cpu_to_le32(enable); 3892 3893 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header); 3894 kfree(cmd); 3895 3896 if (!rc) { 3897 if (enable) 3898 priv->running_bsses |= (1 << mwl8k_vif->macid); 3899 else 3900 priv->running_bsses &= ~(1 << mwl8k_vif->macid); 3901 } 3902 return rc; 3903 } 3904 3905 static void mwl8k_enable_bsses(struct ieee80211_hw *hw, bool enable, u32 bitmap) 3906 { 3907 struct mwl8k_priv *priv = hw->priv; 3908 struct mwl8k_vif *mwl8k_vif, *tmp_vif; 3909 struct ieee80211_vif *vif; 3910 3911 list_for_each_entry_safe(mwl8k_vif, tmp_vif, &priv->vif_list, list) { 3912 vif = mwl8k_vif->vif; 3913 3914 if (!(bitmap & (1 << mwl8k_vif->macid))) 3915 continue; 3916 3917 if (vif->type == NL80211_IFTYPE_AP) 3918 mwl8k_cmd_bss_start(hw, vif, enable); 3919 } 3920 } 3921 /* 3922 * CMD_BASTREAM. 3923 */ 3924 3925 /* 3926 * UPSTREAM is tx direction 3927 */ 3928 #define BASTREAM_FLAG_DIRECTION_UPSTREAM 0x00 3929 #define BASTREAM_FLAG_IMMEDIATE_TYPE 0x01 3930 3931 enum ba_stream_action_type { 3932 MWL8K_BA_CREATE, 3933 MWL8K_BA_UPDATE, 3934 MWL8K_BA_DESTROY, 3935 MWL8K_BA_FLUSH, 3936 MWL8K_BA_CHECK, 3937 }; 3938 3939 3940 struct mwl8k_create_ba_stream { 3941 __le32 flags; 3942 __le32 idle_thrs; 3943 __le32 bar_thrs; 3944 __le32 window_size; 3945 u8 peer_mac_addr[6]; 3946 u8 dialog_token; 3947 u8 tid; 3948 u8 queue_id; 3949 u8 param_info; 3950 __le32 ba_context; 3951 u8 reset_seq_no_flag; 3952 __le16 curr_seq_no; 3953 u8 sta_src_mac_addr[6]; 3954 } __packed; 3955 3956 struct mwl8k_destroy_ba_stream { 3957 __le32 flags; 3958 __le32 ba_context; 3959 } __packed; 3960 3961 struct mwl8k_cmd_bastream { 3962 struct mwl8k_cmd_pkt header; 3963 __le32 action; 3964 union { 3965 struct mwl8k_create_ba_stream create_params; 3966 struct mwl8k_destroy_ba_stream destroy_params; 3967 }; 3968 } __packed; 3969 3970 static int 3971 mwl8k_check_ba(struct ieee80211_hw *hw, struct mwl8k_ampdu_stream *stream, 3972 struct ieee80211_vif *vif) 3973 { 3974 struct mwl8k_cmd_bastream *cmd; 3975 int rc; 3976 3977 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 3978 if (cmd == NULL) 3979 return -ENOMEM; 3980 3981 cmd->header.code = cpu_to_le16(MWL8K_CMD_BASTREAM); 3982 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 3983 3984 cmd->action = cpu_to_le32(MWL8K_BA_CHECK); 3985 3986 cmd->create_params.queue_id = stream->idx; 3987 memcpy(&cmd->create_params.peer_mac_addr[0], stream->sta->addr, 3988 ETH_ALEN); 3989 cmd->create_params.tid = stream->tid; 3990 3991 cmd->create_params.flags = 3992 cpu_to_le32(BASTREAM_FLAG_IMMEDIATE_TYPE) | 3993 cpu_to_le32(BASTREAM_FLAG_DIRECTION_UPSTREAM); 3994 3995 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header); 3996 3997 kfree(cmd); 3998 3999 return rc; 4000 } 4001 4002 static int 4003 mwl8k_create_ba(struct ieee80211_hw *hw, struct mwl8k_ampdu_stream *stream, 4004 u8 buf_size, struct ieee80211_vif *vif) 4005 { 4006 struct mwl8k_cmd_bastream *cmd; 4007 int rc; 4008 4009 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 4010 if (cmd == NULL) 4011 return -ENOMEM; 4012 4013 4014 cmd->header.code = cpu_to_le16(MWL8K_CMD_BASTREAM); 4015 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 4016 4017 cmd->action = cpu_to_le32(MWL8K_BA_CREATE); 4018 4019 cmd->create_params.bar_thrs = cpu_to_le32((u32)buf_size); 4020 cmd->create_params.window_size = cpu_to_le32((u32)buf_size); 4021 cmd->create_params.queue_id = stream->idx; 4022 4023 memcpy(cmd->create_params.peer_mac_addr, stream->sta->addr, ETH_ALEN); 4024 cmd->create_params.tid = stream->tid; 4025 cmd->create_params.curr_seq_no = cpu_to_le16(0); 4026 cmd->create_params.reset_seq_no_flag = 1; 4027 4028 cmd->create_params.param_info = 4029 (stream->sta->ht_cap.ampdu_factor & 4030 IEEE80211_HT_AMPDU_PARM_FACTOR) | 4031 ((stream->sta->ht_cap.ampdu_density << 2) & 4032 IEEE80211_HT_AMPDU_PARM_DENSITY); 4033 4034 cmd->create_params.flags = 4035 cpu_to_le32(BASTREAM_FLAG_IMMEDIATE_TYPE | 4036 BASTREAM_FLAG_DIRECTION_UPSTREAM); 4037 4038 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header); 4039 4040 wiphy_debug(hw->wiphy, "Created a BA stream for %pM : tid %d\n", 4041 stream->sta->addr, stream->tid); 4042 kfree(cmd); 4043 4044 return rc; 4045 } 4046 4047 static void mwl8k_destroy_ba(struct ieee80211_hw *hw, 4048 u8 idx) 4049 { 4050 struct mwl8k_cmd_bastream *cmd; 4051 4052 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 4053 if (cmd == NULL) 4054 return; 4055 4056 cmd->header.code = cpu_to_le16(MWL8K_CMD_BASTREAM); 4057 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 4058 cmd->action = cpu_to_le32(MWL8K_BA_DESTROY); 4059 4060 cmd->destroy_params.ba_context = cpu_to_le32(idx); 4061 mwl8k_post_cmd(hw, &cmd->header); 4062 4063 wiphy_debug(hw->wiphy, "Deleted BA stream index %d\n", idx); 4064 4065 kfree(cmd); 4066 } 4067 4068 /* 4069 * CMD_SET_NEW_STN. 4070 */ 4071 struct mwl8k_cmd_set_new_stn { 4072 struct mwl8k_cmd_pkt header; 4073 __le16 aid; 4074 __u8 mac_addr[6]; 4075 __le16 stn_id; 4076 __le16 action; 4077 __le16 rsvd; 4078 __le32 legacy_rates; 4079 __u8 ht_rates[4]; 4080 __le16 cap_info; 4081 __le16 ht_capabilities_info; 4082 __u8 mac_ht_param_info; 4083 __u8 rev; 4084 __u8 control_channel; 4085 __u8 add_channel; 4086 __le16 op_mode; 4087 __le16 stbc; 4088 __u8 add_qos_info; 4089 __u8 is_qos_sta; 4090 __le32 fw_sta_ptr; 4091 } __packed; 4092 4093 #define MWL8K_STA_ACTION_ADD 0 4094 #define MWL8K_STA_ACTION_REMOVE 2 4095 4096 static int mwl8k_cmd_set_new_stn_add(struct ieee80211_hw *hw, 4097 struct ieee80211_vif *vif, 4098 struct ieee80211_sta *sta) 4099 { 4100 struct mwl8k_cmd_set_new_stn *cmd; 4101 u32 rates; 4102 int rc; 4103 4104 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 4105 if (cmd == NULL) 4106 return -ENOMEM; 4107 4108 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_NEW_STN); 4109 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 4110 cmd->aid = cpu_to_le16(sta->aid); 4111 memcpy(cmd->mac_addr, sta->addr, ETH_ALEN); 4112 cmd->stn_id = cpu_to_le16(sta->aid); 4113 cmd->action = cpu_to_le16(MWL8K_STA_ACTION_ADD); 4114 if (hw->conf.chandef.chan->band == NL80211_BAND_2GHZ) 4115 rates = sta->supp_rates[NL80211_BAND_2GHZ]; 4116 else 4117 rates = sta->supp_rates[NL80211_BAND_5GHZ] << 5; 4118 cmd->legacy_rates = cpu_to_le32(rates); 4119 if (sta->ht_cap.ht_supported) { 4120 cmd->ht_rates[0] = sta->ht_cap.mcs.rx_mask[0]; 4121 cmd->ht_rates[1] = sta->ht_cap.mcs.rx_mask[1]; 4122 cmd->ht_rates[2] = sta->ht_cap.mcs.rx_mask[2]; 4123 cmd->ht_rates[3] = sta->ht_cap.mcs.rx_mask[3]; 4124 cmd->ht_capabilities_info = cpu_to_le16(sta->ht_cap.cap); 4125 cmd->mac_ht_param_info = (sta->ht_cap.ampdu_factor & 3) | 4126 ((sta->ht_cap.ampdu_density & 7) << 2); 4127 cmd->is_qos_sta = 1; 4128 } 4129 4130 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header); 4131 kfree(cmd); 4132 4133 return rc; 4134 } 4135 4136 static int mwl8k_cmd_set_new_stn_add_self(struct ieee80211_hw *hw, 4137 struct ieee80211_vif *vif) 4138 { 4139 struct mwl8k_cmd_set_new_stn *cmd; 4140 int rc; 4141 4142 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 4143 if (cmd == NULL) 4144 return -ENOMEM; 4145 4146 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_NEW_STN); 4147 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 4148 memcpy(cmd->mac_addr, vif->addr, ETH_ALEN); 4149 4150 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header); 4151 kfree(cmd); 4152 4153 return rc; 4154 } 4155 4156 static int mwl8k_cmd_set_new_stn_del(struct ieee80211_hw *hw, 4157 struct ieee80211_vif *vif, u8 *addr) 4158 { 4159 struct mwl8k_cmd_set_new_stn *cmd; 4160 struct mwl8k_priv *priv = hw->priv; 4161 int rc, i; 4162 u8 idx; 4163 4164 spin_lock(&priv->stream_lock); 4165 /* Destroy any active ampdu streams for this sta */ 4166 for (i = 0; i < MWL8K_NUM_AMPDU_STREAMS; i++) { 4167 struct mwl8k_ampdu_stream *s; 4168 s = &priv->ampdu[i]; 4169 if (s->state != AMPDU_NO_STREAM) { 4170 if (memcmp(s->sta->addr, addr, ETH_ALEN) == 0) { 4171 if (s->state == AMPDU_STREAM_ACTIVE) { 4172 idx = s->idx; 4173 spin_unlock(&priv->stream_lock); 4174 mwl8k_destroy_ba(hw, idx); 4175 spin_lock(&priv->stream_lock); 4176 } else if (s->state == AMPDU_STREAM_NEW) { 4177 mwl8k_remove_stream(hw, s); 4178 } 4179 } 4180 } 4181 } 4182 4183 spin_unlock(&priv->stream_lock); 4184 4185 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 4186 if (cmd == NULL) 4187 return -ENOMEM; 4188 4189 cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_NEW_STN); 4190 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 4191 memcpy(cmd->mac_addr, addr, ETH_ALEN); 4192 cmd->action = cpu_to_le16(MWL8K_STA_ACTION_REMOVE); 4193 4194 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header); 4195 kfree(cmd); 4196 4197 return rc; 4198 } 4199 4200 /* 4201 * CMD_UPDATE_ENCRYPTION. 4202 */ 4203 4204 #define MAX_ENCR_KEY_LENGTH 16 4205 #define MIC_KEY_LENGTH 8 4206 4207 struct mwl8k_cmd_update_encryption { 4208 struct mwl8k_cmd_pkt header; 4209 4210 __le32 action; 4211 __le32 reserved; 4212 __u8 mac_addr[6]; 4213 __u8 encr_type; 4214 4215 } __packed; 4216 4217 struct mwl8k_cmd_set_key { 4218 struct mwl8k_cmd_pkt header; 4219 4220 __le32 action; 4221 __le32 reserved; 4222 __le16 length; 4223 __le16 key_type_id; 4224 __le32 key_info; 4225 __le32 key_id; 4226 __le16 key_len; 4227 __u8 key_material[MAX_ENCR_KEY_LENGTH]; 4228 __u8 tkip_tx_mic_key[MIC_KEY_LENGTH]; 4229 __u8 tkip_rx_mic_key[MIC_KEY_LENGTH]; 4230 __le16 tkip_rsc_low; 4231 __le32 tkip_rsc_high; 4232 __le16 tkip_tsc_low; 4233 __le32 tkip_tsc_high; 4234 __u8 mac_addr[6]; 4235 } __packed; 4236 4237 enum { 4238 MWL8K_ENCR_ENABLE, 4239 MWL8K_ENCR_SET_KEY, 4240 MWL8K_ENCR_REMOVE_KEY, 4241 MWL8K_ENCR_SET_GROUP_KEY, 4242 }; 4243 4244 #define MWL8K_UPDATE_ENCRYPTION_TYPE_WEP 0 4245 #define MWL8K_UPDATE_ENCRYPTION_TYPE_DISABLE 1 4246 #define MWL8K_UPDATE_ENCRYPTION_TYPE_TKIP 4 4247 #define MWL8K_UPDATE_ENCRYPTION_TYPE_MIXED 7 4248 #define MWL8K_UPDATE_ENCRYPTION_TYPE_AES 8 4249 4250 enum { 4251 MWL8K_ALG_WEP, 4252 MWL8K_ALG_TKIP, 4253 MWL8K_ALG_CCMP, 4254 }; 4255 4256 #define MWL8K_KEY_FLAG_TXGROUPKEY 0x00000004 4257 #define MWL8K_KEY_FLAG_PAIRWISE 0x00000008 4258 #define MWL8K_KEY_FLAG_TSC_VALID 0x00000040 4259 #define MWL8K_KEY_FLAG_WEP_TXKEY 0x01000000 4260 #define MWL8K_KEY_FLAG_MICKEY_VALID 0x02000000 4261 4262 static int mwl8k_cmd_update_encryption_enable(struct ieee80211_hw *hw, 4263 struct ieee80211_vif *vif, 4264 u8 *addr, 4265 u8 encr_type) 4266 { 4267 struct mwl8k_cmd_update_encryption *cmd; 4268 int rc; 4269 4270 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 4271 if (cmd == NULL) 4272 return -ENOMEM; 4273 4274 cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_ENCRYPTION); 4275 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 4276 cmd->action = cpu_to_le32(MWL8K_ENCR_ENABLE); 4277 memcpy(cmd->mac_addr, addr, ETH_ALEN); 4278 cmd->encr_type = encr_type; 4279 4280 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header); 4281 kfree(cmd); 4282 4283 return rc; 4284 } 4285 4286 static int mwl8k_encryption_set_cmd_info(struct mwl8k_cmd_set_key *cmd, 4287 u8 *addr, 4288 struct ieee80211_key_conf *key) 4289 { 4290 cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_ENCRYPTION); 4291 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 4292 cmd->length = cpu_to_le16(sizeof(*cmd) - 4293 offsetof(struct mwl8k_cmd_set_key, length)); 4294 cmd->key_id = cpu_to_le32(key->keyidx); 4295 cmd->key_len = cpu_to_le16(key->keylen); 4296 memcpy(cmd->mac_addr, addr, ETH_ALEN); 4297 4298 switch (key->cipher) { 4299 case WLAN_CIPHER_SUITE_WEP40: 4300 case WLAN_CIPHER_SUITE_WEP104: 4301 cmd->key_type_id = cpu_to_le16(MWL8K_ALG_WEP); 4302 if (key->keyidx == 0) 4303 cmd->key_info = cpu_to_le32(MWL8K_KEY_FLAG_WEP_TXKEY); 4304 4305 break; 4306 case WLAN_CIPHER_SUITE_TKIP: 4307 cmd->key_type_id = cpu_to_le16(MWL8K_ALG_TKIP); 4308 cmd->key_info = (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 4309 ? cpu_to_le32(MWL8K_KEY_FLAG_PAIRWISE) 4310 : cpu_to_le32(MWL8K_KEY_FLAG_TXGROUPKEY); 4311 cmd->key_info |= cpu_to_le32(MWL8K_KEY_FLAG_MICKEY_VALID 4312 | MWL8K_KEY_FLAG_TSC_VALID); 4313 break; 4314 case WLAN_CIPHER_SUITE_CCMP: 4315 cmd->key_type_id = cpu_to_le16(MWL8K_ALG_CCMP); 4316 cmd->key_info = (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 4317 ? cpu_to_le32(MWL8K_KEY_FLAG_PAIRWISE) 4318 : cpu_to_le32(MWL8K_KEY_FLAG_TXGROUPKEY); 4319 break; 4320 default: 4321 return -ENOTSUPP; 4322 } 4323 4324 return 0; 4325 } 4326 4327 static int mwl8k_cmd_encryption_set_key(struct ieee80211_hw *hw, 4328 struct ieee80211_vif *vif, 4329 u8 *addr, 4330 struct ieee80211_key_conf *key) 4331 { 4332 struct mwl8k_cmd_set_key *cmd; 4333 int rc; 4334 int keymlen; 4335 u32 action; 4336 u8 idx; 4337 struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif); 4338 4339 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 4340 if (cmd == NULL) 4341 return -ENOMEM; 4342 4343 rc = mwl8k_encryption_set_cmd_info(cmd, addr, key); 4344 if (rc < 0) 4345 goto done; 4346 4347 idx = key->keyidx; 4348 4349 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) 4350 action = MWL8K_ENCR_SET_KEY; 4351 else 4352 action = MWL8K_ENCR_SET_GROUP_KEY; 4353 4354 switch (key->cipher) { 4355 case WLAN_CIPHER_SUITE_WEP40: 4356 case WLAN_CIPHER_SUITE_WEP104: 4357 if (!mwl8k_vif->wep_key_conf[idx].enabled) { 4358 memcpy(mwl8k_vif->wep_key_conf[idx].key, key, 4359 sizeof(*key) + key->keylen); 4360 mwl8k_vif->wep_key_conf[idx].enabled = 1; 4361 } 4362 4363 keymlen = key->keylen; 4364 action = MWL8K_ENCR_SET_KEY; 4365 break; 4366 case WLAN_CIPHER_SUITE_TKIP: 4367 keymlen = MAX_ENCR_KEY_LENGTH + 2 * MIC_KEY_LENGTH; 4368 break; 4369 case WLAN_CIPHER_SUITE_CCMP: 4370 keymlen = key->keylen; 4371 break; 4372 default: 4373 rc = -ENOTSUPP; 4374 goto done; 4375 } 4376 4377 memcpy(cmd->key_material, key->key, keymlen); 4378 cmd->action = cpu_to_le32(action); 4379 4380 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header); 4381 done: 4382 kfree(cmd); 4383 4384 return rc; 4385 } 4386 4387 static int mwl8k_cmd_encryption_remove_key(struct ieee80211_hw *hw, 4388 struct ieee80211_vif *vif, 4389 u8 *addr, 4390 struct ieee80211_key_conf *key) 4391 { 4392 struct mwl8k_cmd_set_key *cmd; 4393 int rc; 4394 struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif); 4395 4396 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 4397 if (cmd == NULL) 4398 return -ENOMEM; 4399 4400 rc = mwl8k_encryption_set_cmd_info(cmd, addr, key); 4401 if (rc < 0) 4402 goto done; 4403 4404 if (key->cipher == WLAN_CIPHER_SUITE_WEP40 || 4405 key->cipher == WLAN_CIPHER_SUITE_WEP104) 4406 mwl8k_vif->wep_key_conf[key->keyidx].enabled = 0; 4407 4408 cmd->action = cpu_to_le32(MWL8K_ENCR_REMOVE_KEY); 4409 4410 rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header); 4411 done: 4412 kfree(cmd); 4413 4414 return rc; 4415 } 4416 4417 static int mwl8k_set_key(struct ieee80211_hw *hw, 4418 enum set_key_cmd cmd_param, 4419 struct ieee80211_vif *vif, 4420 struct ieee80211_sta *sta, 4421 struct ieee80211_key_conf *key) 4422 { 4423 int rc = 0; 4424 u8 encr_type; 4425 u8 *addr; 4426 struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif); 4427 struct mwl8k_priv *priv = hw->priv; 4428 4429 if (vif->type == NL80211_IFTYPE_STATION && !priv->ap_fw) 4430 return -EOPNOTSUPP; 4431 4432 if (sta == NULL) 4433 addr = vif->addr; 4434 else 4435 addr = sta->addr; 4436 4437 if (cmd_param == SET_KEY) { 4438 rc = mwl8k_cmd_encryption_set_key(hw, vif, addr, key); 4439 if (rc) 4440 goto out; 4441 4442 if ((key->cipher == WLAN_CIPHER_SUITE_WEP40) 4443 || (key->cipher == WLAN_CIPHER_SUITE_WEP104)) 4444 encr_type = MWL8K_UPDATE_ENCRYPTION_TYPE_WEP; 4445 else 4446 encr_type = MWL8K_UPDATE_ENCRYPTION_TYPE_MIXED; 4447 4448 rc = mwl8k_cmd_update_encryption_enable(hw, vif, addr, 4449 encr_type); 4450 if (rc) 4451 goto out; 4452 4453 mwl8k_vif->is_hw_crypto_enabled = true; 4454 4455 } else { 4456 rc = mwl8k_cmd_encryption_remove_key(hw, vif, addr, key); 4457 4458 if (rc) 4459 goto out; 4460 } 4461 out: 4462 return rc; 4463 } 4464 4465 /* 4466 * CMD_UPDATE_STADB. 4467 */ 4468 struct ewc_ht_info { 4469 __le16 control1; 4470 __le16 control2; 4471 __le16 control3; 4472 } __packed; 4473 4474 struct peer_capability_info { 4475 /* Peer type - AP vs. STA. */ 4476 __u8 peer_type; 4477 4478 /* Basic 802.11 capabilities from assoc resp. */ 4479 __le16 basic_caps; 4480 4481 /* Set if peer supports 802.11n high throughput (HT). */ 4482 __u8 ht_support; 4483 4484 /* Valid if HT is supported. */ 4485 __le16 ht_caps; 4486 __u8 extended_ht_caps; 4487 struct ewc_ht_info ewc_info; 4488 4489 /* Legacy rate table. Intersection of our rates and peer rates. */ 4490 __u8 legacy_rates[12]; 4491 4492 /* HT rate table. Intersection of our rates and peer rates. */ 4493 __u8 ht_rates[16]; 4494 __u8 pad[16]; 4495 4496 /* If set, interoperability mode, no proprietary extensions. */ 4497 __u8 interop; 4498 __u8 pad2; 4499 __u8 station_id; 4500 __le16 amsdu_enabled; 4501 } __packed; 4502 4503 struct mwl8k_cmd_update_stadb { 4504 struct mwl8k_cmd_pkt header; 4505 4506 /* See STADB_ACTION_TYPE */ 4507 __le32 action; 4508 4509 /* Peer MAC address */ 4510 __u8 peer_addr[ETH_ALEN]; 4511 4512 __le32 reserved; 4513 4514 /* Peer info - valid during add/update. */ 4515 struct peer_capability_info peer_info; 4516 } __packed; 4517 4518 #define MWL8K_STA_DB_MODIFY_ENTRY 1 4519 #define MWL8K_STA_DB_DEL_ENTRY 2 4520 4521 /* Peer Entry flags - used to define the type of the peer node */ 4522 #define MWL8K_PEER_TYPE_ACCESSPOINT 2 4523 4524 static int mwl8k_cmd_update_stadb_add(struct ieee80211_hw *hw, 4525 struct ieee80211_vif *vif, 4526 struct ieee80211_sta *sta) 4527 { 4528 struct mwl8k_cmd_update_stadb *cmd; 4529 struct peer_capability_info *p; 4530 u32 rates; 4531 int rc; 4532 4533 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 4534 if (cmd == NULL) 4535 return -ENOMEM; 4536 4537 cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_STADB); 4538 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 4539 cmd->action = cpu_to_le32(MWL8K_STA_DB_MODIFY_ENTRY); 4540 memcpy(cmd->peer_addr, sta->addr, ETH_ALEN); 4541 4542 p = &cmd->peer_info; 4543 p->peer_type = MWL8K_PEER_TYPE_ACCESSPOINT; 4544 p->basic_caps = cpu_to_le16(vif->bss_conf.assoc_capability); 4545 p->ht_support = sta->ht_cap.ht_supported; 4546 p->ht_caps = cpu_to_le16(sta->ht_cap.cap); 4547 p->extended_ht_caps = (sta->ht_cap.ampdu_factor & 3) | 4548 ((sta->ht_cap.ampdu_density & 7) << 2); 4549 if (hw->conf.chandef.chan->band == NL80211_BAND_2GHZ) 4550 rates = sta->supp_rates[NL80211_BAND_2GHZ]; 4551 else 4552 rates = sta->supp_rates[NL80211_BAND_5GHZ] << 5; 4553 legacy_rate_mask_to_array(p->legacy_rates, rates); 4554 memcpy(p->ht_rates, sta->ht_cap.mcs.rx_mask, 16); 4555 p->interop = 1; 4556 p->amsdu_enabled = 0; 4557 4558 rc = mwl8k_post_cmd(hw, &cmd->header); 4559 if (!rc) 4560 rc = p->station_id; 4561 kfree(cmd); 4562 4563 return rc; 4564 } 4565 4566 static int mwl8k_cmd_update_stadb_del(struct ieee80211_hw *hw, 4567 struct ieee80211_vif *vif, u8 *addr) 4568 { 4569 struct mwl8k_cmd_update_stadb *cmd; 4570 int rc; 4571 4572 cmd = kzalloc(sizeof(*cmd), GFP_KERNEL); 4573 if (cmd == NULL) 4574 return -ENOMEM; 4575 4576 cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_STADB); 4577 cmd->header.length = cpu_to_le16(sizeof(*cmd)); 4578 cmd->action = cpu_to_le32(MWL8K_STA_DB_DEL_ENTRY); 4579 memcpy(cmd->peer_addr, addr, ETH_ALEN); 4580 4581 rc = mwl8k_post_cmd(hw, &cmd->header); 4582 kfree(cmd); 4583 4584 return rc; 4585 } 4586 4587 4588 /* 4589 * Interrupt handling. 4590 */ 4591 static irqreturn_t mwl8k_interrupt(int irq, void *dev_id) 4592 { 4593 struct ieee80211_hw *hw = dev_id; 4594 struct mwl8k_priv *priv = hw->priv; 4595 u32 status; 4596 4597 status = ioread32(priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS); 4598 if (!status) 4599 return IRQ_NONE; 4600 4601 if (status & MWL8K_A2H_INT_TX_DONE) { 4602 status &= ~MWL8K_A2H_INT_TX_DONE; 4603 tasklet_schedule(&priv->poll_tx_task); 4604 } 4605 4606 if (status & MWL8K_A2H_INT_RX_READY) { 4607 status &= ~MWL8K_A2H_INT_RX_READY; 4608 tasklet_schedule(&priv->poll_rx_task); 4609 } 4610 4611 if (status & MWL8K_A2H_INT_BA_WATCHDOG) { 4612 iowrite32(~MWL8K_A2H_INT_BA_WATCHDOG, 4613 priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK); 4614 4615 atomic_inc(&priv->watchdog_event_pending); 4616 status &= ~MWL8K_A2H_INT_BA_WATCHDOG; 4617 ieee80211_queue_work(hw, &priv->watchdog_ba_handle); 4618 } 4619 4620 if (status) 4621 iowrite32(~status, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS); 4622 4623 if (status & MWL8K_A2H_INT_OPC_DONE) { 4624 if (priv->hostcmd_wait != NULL) 4625 complete(priv->hostcmd_wait); 4626 } 4627 4628 if (status & MWL8K_A2H_INT_QUEUE_EMPTY) { 4629 if (!mutex_is_locked(&priv->fw_mutex) && 4630 priv->radio_on && priv->pending_tx_pkts) 4631 mwl8k_tx_start(priv); 4632 } 4633 4634 return IRQ_HANDLED; 4635 } 4636 4637 static void mwl8k_tx_poll(struct tasklet_struct *t) 4638 { 4639 struct mwl8k_priv *priv = from_tasklet(priv, t, poll_tx_task); 4640 struct ieee80211_hw *hw = pci_get_drvdata(priv->pdev); 4641 int limit; 4642 int i; 4643 4644 limit = 32; 4645 4646 spin_lock(&priv->tx_lock); 4647 4648 for (i = 0; i < mwl8k_tx_queues(priv); i++) 4649 limit -= mwl8k_txq_reclaim(hw, i, limit, 0); 4650 4651 if (!priv->pending_tx_pkts && priv->tx_wait != NULL) { 4652 complete(priv->tx_wait); 4653 priv->tx_wait = NULL; 4654 } 4655 4656 spin_unlock(&priv->tx_lock); 4657 4658 if (limit) { 4659 writel(~MWL8K_A2H_INT_TX_DONE, 4660 priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS); 4661 } else { 4662 tasklet_schedule(&priv->poll_tx_task); 4663 } 4664 } 4665 4666 static void mwl8k_rx_poll(struct tasklet_struct *t) 4667 { 4668 struct mwl8k_priv *priv = from_tasklet(priv, t, poll_rx_task); 4669 struct ieee80211_hw *hw = pci_get_drvdata(priv->pdev); 4670 int limit; 4671 4672 limit = 32; 4673 limit -= rxq_process(hw, 0, limit); 4674 limit -= rxq_refill(hw, 0, limit); 4675 4676 if (limit) { 4677 writel(~MWL8K_A2H_INT_RX_READY, 4678 priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS); 4679 } else { 4680 tasklet_schedule(&priv->poll_rx_task); 4681 } 4682 } 4683 4684 4685 /* 4686 * Core driver operations. 4687 */ 4688 static void mwl8k_tx(struct ieee80211_hw *hw, 4689 struct ieee80211_tx_control *control, 4690 struct sk_buff *skb) 4691 { 4692 struct mwl8k_priv *priv = hw->priv; 4693 int index = skb_get_queue_mapping(skb); 4694 4695 if (!priv->radio_on) { 4696 wiphy_debug(hw->wiphy, 4697 "dropped TX frame since radio disabled\n"); 4698 dev_kfree_skb(skb); 4699 return; 4700 } 4701 4702 mwl8k_txq_xmit(hw, index, control->sta, skb); 4703 } 4704 4705 static int mwl8k_start(struct ieee80211_hw *hw) 4706 { 4707 struct mwl8k_priv *priv = hw->priv; 4708 int rc; 4709 4710 rc = request_irq(priv->pdev->irq, mwl8k_interrupt, 4711 IRQF_SHARED, MWL8K_NAME, hw); 4712 if (rc) { 4713 priv->irq = -1; 4714 wiphy_err(hw->wiphy, "failed to register IRQ handler\n"); 4715 return -EIO; 4716 } 4717 priv->irq = priv->pdev->irq; 4718 4719 /* Enable TX reclaim and RX tasklets. */ 4720 tasklet_enable(&priv->poll_tx_task); 4721 tasklet_enable(&priv->poll_rx_task); 4722 4723 /* Enable interrupts */ 4724 iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK); 4725 iowrite32(MWL8K_A2H_EVENTS, 4726 priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK); 4727 4728 rc = mwl8k_fw_lock(hw); 4729 if (!rc) { 4730 rc = mwl8k_cmd_radio_enable(hw); 4731 4732 if (!priv->ap_fw) { 4733 if (!rc) 4734 rc = mwl8k_cmd_enable_sniffer(hw, 0); 4735 4736 if (!rc) 4737 rc = mwl8k_cmd_set_pre_scan(hw); 4738 4739 if (!rc) 4740 rc = mwl8k_cmd_set_post_scan(hw, 4741 "\x00\x00\x00\x00\x00\x00"); 4742 } 4743 4744 if (!rc) 4745 rc = mwl8k_cmd_set_rateadapt_mode(hw, 0); 4746 4747 if (!rc) 4748 rc = mwl8k_cmd_set_wmm_mode(hw, 0); 4749 4750 mwl8k_fw_unlock(hw); 4751 } 4752 4753 if (rc) { 4754 iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK); 4755 free_irq(priv->pdev->irq, hw); 4756 priv->irq = -1; 4757 tasklet_disable(&priv->poll_tx_task); 4758 tasklet_disable(&priv->poll_rx_task); 4759 } else { 4760 ieee80211_wake_queues(hw); 4761 } 4762 4763 return rc; 4764 } 4765 4766 static void mwl8k_stop(struct ieee80211_hw *hw) 4767 { 4768 struct mwl8k_priv *priv = hw->priv; 4769 int i; 4770 4771 if (!priv->hw_restart_in_progress) 4772 mwl8k_cmd_radio_disable(hw); 4773 4774 ieee80211_stop_queues(hw); 4775 4776 /* Disable interrupts */ 4777 iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK); 4778 if (priv->irq != -1) { 4779 free_irq(priv->pdev->irq, hw); 4780 priv->irq = -1; 4781 } 4782 4783 /* Stop finalize join worker */ 4784 cancel_work_sync(&priv->finalize_join_worker); 4785 cancel_work_sync(&priv->watchdog_ba_handle); 4786 if (priv->beacon_skb != NULL) 4787 dev_kfree_skb(priv->beacon_skb); 4788 4789 /* Stop TX reclaim and RX tasklets. */ 4790 tasklet_disable(&priv->poll_tx_task); 4791 tasklet_disable(&priv->poll_rx_task); 4792 4793 /* Return all skbs to mac80211 */ 4794 for (i = 0; i < mwl8k_tx_queues(priv); i++) 4795 mwl8k_txq_reclaim(hw, i, INT_MAX, 1); 4796 } 4797 4798 static int mwl8k_reload_firmware(struct ieee80211_hw *hw, char *fw_image); 4799 4800 static int mwl8k_add_interface(struct ieee80211_hw *hw, 4801 struct ieee80211_vif *vif) 4802 { 4803 struct mwl8k_priv *priv = hw->priv; 4804 struct mwl8k_vif *mwl8k_vif; 4805 u32 macids_supported; 4806 int macid, rc; 4807 struct mwl8k_device_info *di; 4808 4809 /* 4810 * Reject interface creation if sniffer mode is active, as 4811 * STA operation is mutually exclusive with hardware sniffer 4812 * mode. (Sniffer mode is only used on STA firmware.) 4813 */ 4814 if (priv->sniffer_enabled) { 4815 wiphy_info(hw->wiphy, 4816 "unable to create STA interface because sniffer mode is enabled\n"); 4817 return -EINVAL; 4818 } 4819 4820 di = priv->device_info; 4821 switch (vif->type) { 4822 case NL80211_IFTYPE_AP: 4823 if (!priv->ap_fw && di->fw_image_ap) { 4824 /* we must load the ap fw to meet this request */ 4825 if (!list_empty(&priv->vif_list)) 4826 return -EBUSY; 4827 rc = mwl8k_reload_firmware(hw, di->fw_image_ap); 4828 if (rc) 4829 return rc; 4830 } 4831 macids_supported = priv->ap_macids_supported; 4832 break; 4833 case NL80211_IFTYPE_STATION: 4834 if (priv->ap_fw && di->fw_image_sta) { 4835 if (!list_empty(&priv->vif_list)) { 4836 wiphy_warn(hw->wiphy, "AP interface is running.\n" 4837 "Adding STA interface for WDS"); 4838 } else { 4839 /* we must load the sta fw to 4840 * meet this request. 4841 */ 4842 rc = mwl8k_reload_firmware(hw, 4843 di->fw_image_sta); 4844 if (rc) 4845 return rc; 4846 } 4847 } 4848 macids_supported = priv->sta_macids_supported; 4849 break; 4850 default: 4851 return -EINVAL; 4852 } 4853 4854 macid = ffs(macids_supported & ~priv->macids_used); 4855 if (!macid--) 4856 return -EBUSY; 4857 4858 /* Setup driver private area. */ 4859 mwl8k_vif = MWL8K_VIF(vif); 4860 memset(mwl8k_vif, 0, sizeof(*mwl8k_vif)); 4861 mwl8k_vif->vif = vif; 4862 mwl8k_vif->macid = macid; 4863 mwl8k_vif->seqno = 0; 4864 memcpy(mwl8k_vif->bssid, vif->addr, ETH_ALEN); 4865 mwl8k_vif->is_hw_crypto_enabled = false; 4866 4867 /* Set the mac address. */ 4868 mwl8k_cmd_set_mac_addr(hw, vif, vif->addr); 4869 4870 if (vif->type == NL80211_IFTYPE_AP) 4871 mwl8k_cmd_set_new_stn_add_self(hw, vif); 4872 4873 priv->macids_used |= 1 << mwl8k_vif->macid; 4874 list_add_tail(&mwl8k_vif->list, &priv->vif_list); 4875 4876 return 0; 4877 } 4878 4879 static void mwl8k_remove_vif(struct mwl8k_priv *priv, struct mwl8k_vif *vif) 4880 { 4881 /* Has ieee80211_restart_hw re-added the removed interfaces? */ 4882 if (!priv->macids_used) 4883 return; 4884 4885 priv->macids_used &= ~(1 << vif->macid); 4886 list_del(&vif->list); 4887 } 4888 4889 static void mwl8k_remove_interface(struct ieee80211_hw *hw, 4890 struct ieee80211_vif *vif) 4891 { 4892 struct mwl8k_priv *priv = hw->priv; 4893 struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif); 4894 4895 if (vif->type == NL80211_IFTYPE_AP) 4896 mwl8k_cmd_set_new_stn_del(hw, vif, vif->addr); 4897 4898 mwl8k_cmd_del_mac_addr(hw, vif, vif->addr); 4899 4900 mwl8k_remove_vif(priv, mwl8k_vif); 4901 } 4902 4903 static void mwl8k_hw_restart_work(struct work_struct *work) 4904 { 4905 struct mwl8k_priv *priv = 4906 container_of(work, struct mwl8k_priv, fw_reload); 4907 struct ieee80211_hw *hw = priv->hw; 4908 struct mwl8k_device_info *di; 4909 int rc; 4910 4911 /* If some command is waiting for a response, clear it */ 4912 if (priv->hostcmd_wait != NULL) { 4913 complete(priv->hostcmd_wait); 4914 priv->hostcmd_wait = NULL; 4915 } 4916 4917 priv->hw_restart_owner = current; 4918 di = priv->device_info; 4919 mwl8k_fw_lock(hw); 4920 4921 if (priv->ap_fw) 4922 rc = mwl8k_reload_firmware(hw, di->fw_image_ap); 4923 else 4924 rc = mwl8k_reload_firmware(hw, di->fw_image_sta); 4925 4926 if (rc) 4927 goto fail; 4928 4929 priv->hw_restart_owner = NULL; 4930 priv->hw_restart_in_progress = false; 4931 4932 /* 4933 * This unlock will wake up the queues and 4934 * also opens the command path for other 4935 * commands 4936 */ 4937 mwl8k_fw_unlock(hw); 4938 4939 ieee80211_restart_hw(hw); 4940 4941 wiphy_err(hw->wiphy, "Firmware restarted successfully\n"); 4942 4943 return; 4944 fail: 4945 mwl8k_fw_unlock(hw); 4946 4947 wiphy_err(hw->wiphy, "Firmware restart failed\n"); 4948 } 4949 4950 static int mwl8k_config(struct ieee80211_hw *hw, u32 changed) 4951 { 4952 struct ieee80211_conf *conf = &hw->conf; 4953 struct mwl8k_priv *priv = hw->priv; 4954 int rc; 4955 4956 rc = mwl8k_fw_lock(hw); 4957 if (rc) 4958 return rc; 4959 4960 if (conf->flags & IEEE80211_CONF_IDLE) 4961 rc = mwl8k_cmd_radio_disable(hw); 4962 else 4963 rc = mwl8k_cmd_radio_enable(hw); 4964 if (rc) 4965 goto out; 4966 4967 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { 4968 rc = mwl8k_cmd_set_rf_channel(hw, conf); 4969 if (rc) 4970 goto out; 4971 } 4972 4973 if (conf->power_level > 18) 4974 conf->power_level = 18; 4975 4976 if (priv->ap_fw) { 4977 4978 if (conf->flags & IEEE80211_CONF_CHANGE_POWER) { 4979 rc = mwl8k_cmd_tx_power(hw, conf, conf->power_level); 4980 if (rc) 4981 goto out; 4982 } 4983 4984 4985 } else { 4986 rc = mwl8k_cmd_rf_tx_power(hw, conf->power_level); 4987 if (rc) 4988 goto out; 4989 rc = mwl8k_cmd_mimo_config(hw, 0x7, 0x7); 4990 } 4991 4992 out: 4993 mwl8k_fw_unlock(hw); 4994 4995 return rc; 4996 } 4997 4998 static void 4999 mwl8k_bss_info_changed_sta(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 5000 struct ieee80211_bss_conf *info, u32 changed) 5001 { 5002 struct mwl8k_priv *priv = hw->priv; 5003 u32 ap_legacy_rates = 0; 5004 u8 ap_mcs_rates[16]; 5005 int rc; 5006 5007 if (mwl8k_fw_lock(hw)) 5008 return; 5009 5010 /* 5011 * No need to capture a beacon if we're no longer associated. 5012 */ 5013 if ((changed & BSS_CHANGED_ASSOC) && !vif->bss_conf.assoc) 5014 priv->capture_beacon = false; 5015 5016 /* 5017 * Get the AP's legacy and MCS rates. 5018 */ 5019 if (vif->bss_conf.assoc) { 5020 struct ieee80211_sta *ap; 5021 5022 rcu_read_lock(); 5023 5024 ap = ieee80211_find_sta(vif, vif->bss_conf.bssid); 5025 if (ap == NULL) { 5026 rcu_read_unlock(); 5027 goto out; 5028 } 5029 5030 if (hw->conf.chandef.chan->band == NL80211_BAND_2GHZ) { 5031 ap_legacy_rates = ap->supp_rates[NL80211_BAND_2GHZ]; 5032 } else { 5033 ap_legacy_rates = 5034 ap->supp_rates[NL80211_BAND_5GHZ] << 5; 5035 } 5036 memcpy(ap_mcs_rates, ap->ht_cap.mcs.rx_mask, 16); 5037 5038 rcu_read_unlock(); 5039 5040 if (changed & BSS_CHANGED_ASSOC) { 5041 if (!priv->ap_fw) { 5042 rc = mwl8k_cmd_set_rate(hw, vif, 5043 ap_legacy_rates, 5044 ap_mcs_rates); 5045 if (rc) 5046 goto out; 5047 5048 rc = mwl8k_cmd_use_fixed_rate_sta(hw); 5049 if (rc) 5050 goto out; 5051 } else { 5052 int idx; 5053 int rate; 5054 5055 /* Use AP firmware specific rate command. 5056 */ 5057 idx = ffs(vif->bss_conf.basic_rates); 5058 if (idx) 5059 idx--; 5060 5061 if (hw->conf.chandef.chan->band == 5062 NL80211_BAND_2GHZ) 5063 rate = mwl8k_rates_24[idx].hw_value; 5064 else 5065 rate = mwl8k_rates_50[idx].hw_value; 5066 5067 mwl8k_cmd_use_fixed_rate_ap(hw, rate, rate); 5068 } 5069 } 5070 } 5071 5072 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 5073 rc = mwl8k_set_radio_preamble(hw, 5074 vif->bss_conf.use_short_preamble); 5075 if (rc) 5076 goto out; 5077 } 5078 5079 if ((changed & BSS_CHANGED_ERP_SLOT) && !priv->ap_fw) { 5080 rc = mwl8k_cmd_set_slot(hw, vif->bss_conf.use_short_slot); 5081 if (rc) 5082 goto out; 5083 } 5084 5085 if (vif->bss_conf.assoc && !priv->ap_fw && 5086 (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_ERP_CTS_PROT | 5087 BSS_CHANGED_HT))) { 5088 rc = mwl8k_cmd_set_aid(hw, vif, ap_legacy_rates); 5089 if (rc) 5090 goto out; 5091 } 5092 5093 if (vif->bss_conf.assoc && 5094 (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_BEACON_INT))) { 5095 /* 5096 * Finalize the join. Tell rx handler to process 5097 * next beacon from our BSSID. 5098 */ 5099 memcpy(priv->capture_bssid, vif->bss_conf.bssid, ETH_ALEN); 5100 priv->capture_beacon = true; 5101 } 5102 5103 out: 5104 mwl8k_fw_unlock(hw); 5105 } 5106 5107 static void 5108 mwl8k_bss_info_changed_ap(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 5109 struct ieee80211_bss_conf *info, u32 changed) 5110 { 5111 int rc; 5112 5113 if (mwl8k_fw_lock(hw)) 5114 return; 5115 5116 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 5117 rc = mwl8k_set_radio_preamble(hw, 5118 vif->bss_conf.use_short_preamble); 5119 if (rc) 5120 goto out; 5121 } 5122 5123 if (changed & BSS_CHANGED_BASIC_RATES) { 5124 int idx; 5125 int rate; 5126 5127 /* 5128 * Use lowest supported basic rate for multicasts 5129 * and management frames (such as probe responses -- 5130 * beacons will always go out at 1 Mb/s). 5131 */ 5132 idx = ffs(vif->bss_conf.basic_rates); 5133 if (idx) 5134 idx--; 5135 5136 if (hw->conf.chandef.chan->band == NL80211_BAND_2GHZ) 5137 rate = mwl8k_rates_24[idx].hw_value; 5138 else 5139 rate = mwl8k_rates_50[idx].hw_value; 5140 5141 mwl8k_cmd_use_fixed_rate_ap(hw, rate, rate); 5142 } 5143 5144 if (changed & (BSS_CHANGED_BEACON_INT | BSS_CHANGED_BEACON)) { 5145 struct sk_buff *skb; 5146 5147 skb = ieee80211_beacon_get(hw, vif); 5148 if (skb != NULL) { 5149 mwl8k_cmd_set_beacon(hw, vif, skb->data, skb->len); 5150 kfree_skb(skb); 5151 } 5152 } 5153 5154 if (changed & BSS_CHANGED_BEACON_ENABLED) 5155 mwl8k_cmd_bss_start(hw, vif, info->enable_beacon); 5156 5157 out: 5158 mwl8k_fw_unlock(hw); 5159 } 5160 5161 static void 5162 mwl8k_bss_info_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 5163 struct ieee80211_bss_conf *info, u32 changed) 5164 { 5165 if (vif->type == NL80211_IFTYPE_STATION) 5166 mwl8k_bss_info_changed_sta(hw, vif, info, changed); 5167 if (vif->type == NL80211_IFTYPE_AP) 5168 mwl8k_bss_info_changed_ap(hw, vif, info, changed); 5169 } 5170 5171 static u64 mwl8k_prepare_multicast(struct ieee80211_hw *hw, 5172 struct netdev_hw_addr_list *mc_list) 5173 { 5174 struct mwl8k_cmd_pkt *cmd; 5175 5176 /* 5177 * Synthesize and return a command packet that programs the 5178 * hardware multicast address filter. At this point we don't 5179 * know whether FIF_ALLMULTI is being requested, but if it is, 5180 * we'll end up throwing this packet away and creating a new 5181 * one in mwl8k_configure_filter(). 5182 */ 5183 cmd = __mwl8k_cmd_mac_multicast_adr(hw, 0, mc_list); 5184 5185 return (unsigned long)cmd; 5186 } 5187 5188 static int 5189 mwl8k_configure_filter_sniffer(struct ieee80211_hw *hw, 5190 unsigned int changed_flags, 5191 unsigned int *total_flags) 5192 { 5193 struct mwl8k_priv *priv = hw->priv; 5194 5195 /* 5196 * Hardware sniffer mode is mutually exclusive with STA 5197 * operation, so refuse to enable sniffer mode if a STA 5198 * interface is active. 5199 */ 5200 if (!list_empty(&priv->vif_list)) { 5201 if (net_ratelimit()) 5202 wiphy_info(hw->wiphy, 5203 "not enabling sniffer mode because STA interface is active\n"); 5204 return 0; 5205 } 5206 5207 if (!priv->sniffer_enabled) { 5208 if (mwl8k_cmd_enable_sniffer(hw, 1)) 5209 return 0; 5210 priv->sniffer_enabled = true; 5211 } 5212 5213 *total_flags &= FIF_ALLMULTI | 5214 FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL | 5215 FIF_OTHER_BSS; 5216 5217 return 1; 5218 } 5219 5220 static struct mwl8k_vif *mwl8k_first_vif(struct mwl8k_priv *priv) 5221 { 5222 if (!list_empty(&priv->vif_list)) 5223 return list_entry(priv->vif_list.next, struct mwl8k_vif, list); 5224 5225 return NULL; 5226 } 5227 5228 static void mwl8k_configure_filter(struct ieee80211_hw *hw, 5229 unsigned int changed_flags, 5230 unsigned int *total_flags, 5231 u64 multicast) 5232 { 5233 struct mwl8k_priv *priv = hw->priv; 5234 struct mwl8k_cmd_pkt *cmd = (void *)(unsigned long)multicast; 5235 5236 /* 5237 * AP firmware doesn't allow fine-grained control over 5238 * the receive filter. 5239 */ 5240 if (priv->ap_fw) { 5241 *total_flags &= FIF_ALLMULTI | FIF_BCN_PRBRESP_PROMISC; 5242 kfree(cmd); 5243 return; 5244 } 5245 5246 /* 5247 * Enable hardware sniffer mode if FIF_CONTROL or 5248 * FIF_OTHER_BSS is requested. 5249 */ 5250 if (*total_flags & (FIF_CONTROL | FIF_OTHER_BSS) && 5251 mwl8k_configure_filter_sniffer(hw, changed_flags, total_flags)) { 5252 kfree(cmd); 5253 return; 5254 } 5255 5256 /* Clear unsupported feature flags */ 5257 *total_flags &= FIF_ALLMULTI | FIF_BCN_PRBRESP_PROMISC; 5258 5259 if (mwl8k_fw_lock(hw)) { 5260 kfree(cmd); 5261 return; 5262 } 5263 5264 if (priv->sniffer_enabled) { 5265 mwl8k_cmd_enable_sniffer(hw, 0); 5266 priv->sniffer_enabled = false; 5267 } 5268 5269 if (changed_flags & FIF_BCN_PRBRESP_PROMISC) { 5270 if (*total_flags & FIF_BCN_PRBRESP_PROMISC) { 5271 /* 5272 * Disable the BSS filter. 5273 */ 5274 mwl8k_cmd_set_pre_scan(hw); 5275 } else { 5276 struct mwl8k_vif *mwl8k_vif; 5277 const u8 *bssid; 5278 5279 /* 5280 * Enable the BSS filter. 5281 * 5282 * If there is an active STA interface, use that 5283 * interface's BSSID, otherwise use a dummy one 5284 * (where the OUI part needs to be nonzero for 5285 * the BSSID to be accepted by POST_SCAN). 5286 */ 5287 mwl8k_vif = mwl8k_first_vif(priv); 5288 if (mwl8k_vif != NULL) 5289 bssid = mwl8k_vif->vif->bss_conf.bssid; 5290 else 5291 bssid = "\x01\x00\x00\x00\x00\x00"; 5292 5293 mwl8k_cmd_set_post_scan(hw, bssid); 5294 } 5295 } 5296 5297 /* 5298 * If FIF_ALLMULTI is being requested, throw away the command 5299 * packet that ->prepare_multicast() built and replace it with 5300 * a command packet that enables reception of all multicast 5301 * packets. 5302 */ 5303 if (*total_flags & FIF_ALLMULTI) { 5304 kfree(cmd); 5305 cmd = __mwl8k_cmd_mac_multicast_adr(hw, 1, NULL); 5306 } 5307 5308 if (cmd != NULL) { 5309 mwl8k_post_cmd(hw, cmd); 5310 kfree(cmd); 5311 } 5312 5313 mwl8k_fw_unlock(hw); 5314 } 5315 5316 static int mwl8k_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 5317 { 5318 return mwl8k_cmd_set_rts_threshold(hw, value); 5319 } 5320 5321 static int mwl8k_sta_remove(struct ieee80211_hw *hw, 5322 struct ieee80211_vif *vif, 5323 struct ieee80211_sta *sta) 5324 { 5325 struct mwl8k_priv *priv = hw->priv; 5326 5327 if (priv->ap_fw) 5328 return mwl8k_cmd_set_new_stn_del(hw, vif, sta->addr); 5329 else 5330 return mwl8k_cmd_update_stadb_del(hw, vif, sta->addr); 5331 } 5332 5333 static int mwl8k_sta_add(struct ieee80211_hw *hw, 5334 struct ieee80211_vif *vif, 5335 struct ieee80211_sta *sta) 5336 { 5337 struct mwl8k_priv *priv = hw->priv; 5338 int ret; 5339 int i; 5340 struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif); 5341 struct ieee80211_key_conf *key; 5342 5343 if (!priv->ap_fw) { 5344 ret = mwl8k_cmd_update_stadb_add(hw, vif, sta); 5345 if (ret >= 0) { 5346 MWL8K_STA(sta)->peer_id = ret; 5347 if (sta->ht_cap.ht_supported) 5348 MWL8K_STA(sta)->is_ampdu_allowed = true; 5349 ret = 0; 5350 } 5351 5352 } else { 5353 ret = mwl8k_cmd_set_new_stn_add(hw, vif, sta); 5354 } 5355 5356 for (i = 0; i < NUM_WEP_KEYS; i++) { 5357 key = IEEE80211_KEY_CONF(mwl8k_vif->wep_key_conf[i].key); 5358 if (mwl8k_vif->wep_key_conf[i].enabled) 5359 mwl8k_set_key(hw, SET_KEY, vif, sta, key); 5360 } 5361 return ret; 5362 } 5363 5364 static int mwl8k_conf_tx(struct ieee80211_hw *hw, 5365 struct ieee80211_vif *vif, u16 queue, 5366 const struct ieee80211_tx_queue_params *params) 5367 { 5368 struct mwl8k_priv *priv = hw->priv; 5369 int rc; 5370 5371 rc = mwl8k_fw_lock(hw); 5372 if (!rc) { 5373 BUG_ON(queue > MWL8K_TX_WMM_QUEUES - 1); 5374 memcpy(&priv->wmm_params[queue], params, sizeof(*params)); 5375 5376 if (!priv->wmm_enabled) 5377 rc = mwl8k_cmd_set_wmm_mode(hw, 1); 5378 5379 if (!rc) { 5380 int q = MWL8K_TX_WMM_QUEUES - 1 - queue; 5381 rc = mwl8k_cmd_set_edca_params(hw, q, 5382 params->cw_min, 5383 params->cw_max, 5384 params->aifs, 5385 params->txop); 5386 } 5387 5388 mwl8k_fw_unlock(hw); 5389 } 5390 5391 return rc; 5392 } 5393 5394 static int mwl8k_get_stats(struct ieee80211_hw *hw, 5395 struct ieee80211_low_level_stats *stats) 5396 { 5397 return mwl8k_cmd_get_stat(hw, stats); 5398 } 5399 5400 static int mwl8k_get_survey(struct ieee80211_hw *hw, int idx, 5401 struct survey_info *survey) 5402 { 5403 struct mwl8k_priv *priv = hw->priv; 5404 struct ieee80211_conf *conf = &hw->conf; 5405 struct ieee80211_supported_band *sband; 5406 5407 if (priv->ap_fw) { 5408 sband = hw->wiphy->bands[NL80211_BAND_2GHZ]; 5409 5410 if (sband && idx >= sband->n_channels) { 5411 idx -= sband->n_channels; 5412 sband = NULL; 5413 } 5414 5415 if (!sband) 5416 sband = hw->wiphy->bands[NL80211_BAND_5GHZ]; 5417 5418 if (!sband || idx >= sband->n_channels) 5419 return -ENOENT; 5420 5421 memcpy(survey, &priv->survey[idx], sizeof(*survey)); 5422 survey->channel = &sband->channels[idx]; 5423 5424 return 0; 5425 } 5426 5427 if (idx != 0) 5428 return -ENOENT; 5429 5430 survey->channel = conf->chandef.chan; 5431 survey->filled = SURVEY_INFO_NOISE_DBM; 5432 survey->noise = priv->noise; 5433 5434 return 0; 5435 } 5436 5437 #define MAX_AMPDU_ATTEMPTS 5 5438 5439 static int 5440 mwl8k_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 5441 struct ieee80211_ampdu_params *params) 5442 { 5443 struct ieee80211_sta *sta = params->sta; 5444 enum ieee80211_ampdu_mlme_action action = params->action; 5445 u16 tid = params->tid; 5446 u16 *ssn = ¶ms->ssn; 5447 u8 buf_size = params->buf_size; 5448 int i, rc = 0; 5449 struct mwl8k_priv *priv = hw->priv; 5450 struct mwl8k_ampdu_stream *stream; 5451 u8 *addr = sta->addr, idx; 5452 struct mwl8k_sta *sta_info = MWL8K_STA(sta); 5453 5454 if (!ieee80211_hw_check(hw, AMPDU_AGGREGATION)) 5455 return -ENOTSUPP; 5456 5457 spin_lock(&priv->stream_lock); 5458 stream = mwl8k_lookup_stream(hw, addr, tid); 5459 5460 switch (action) { 5461 case IEEE80211_AMPDU_RX_START: 5462 case IEEE80211_AMPDU_RX_STOP: 5463 break; 5464 case IEEE80211_AMPDU_TX_START: 5465 /* By the time we get here the hw queues may contain outgoing 5466 * packets for this RA/TID that are not part of this BA 5467 * session. The hw will assign sequence numbers to these 5468 * packets as they go out. So if we query the hw for its next 5469 * sequence number and use that for the SSN here, it may end up 5470 * being wrong, which will lead to sequence number mismatch at 5471 * the recipient. To avoid this, we reset the sequence number 5472 * to O for the first MPDU in this BA stream. 5473 */ 5474 *ssn = 0; 5475 if (stream == NULL) { 5476 /* This means that somebody outside this driver called 5477 * ieee80211_start_tx_ba_session. This is unexpected 5478 * because we do our own rate control. Just warn and 5479 * move on. 5480 */ 5481 wiphy_warn(hw->wiphy, "Unexpected call to %s. " 5482 "Proceeding anyway.\n", __func__); 5483 stream = mwl8k_add_stream(hw, sta, tid); 5484 } 5485 if (stream == NULL) { 5486 wiphy_debug(hw->wiphy, "no free AMPDU streams\n"); 5487 rc = -EBUSY; 5488 break; 5489 } 5490 stream->state = AMPDU_STREAM_IN_PROGRESS; 5491 5492 /* Release the lock before we do the time consuming stuff */ 5493 spin_unlock(&priv->stream_lock); 5494 for (i = 0; i < MAX_AMPDU_ATTEMPTS; i++) { 5495 5496 /* Check if link is still valid */ 5497 if (!sta_info->is_ampdu_allowed) { 5498 spin_lock(&priv->stream_lock); 5499 mwl8k_remove_stream(hw, stream); 5500 spin_unlock(&priv->stream_lock); 5501 return -EBUSY; 5502 } 5503 5504 rc = mwl8k_check_ba(hw, stream, vif); 5505 5506 /* If HW restart is in progress mwl8k_post_cmd will 5507 * return -EBUSY. Avoid retrying mwl8k_check_ba in 5508 * such cases 5509 */ 5510 if (!rc || rc == -EBUSY) 5511 break; 5512 /* 5513 * HW queues take time to be flushed, give them 5514 * sufficient time 5515 */ 5516 5517 msleep(1000); 5518 } 5519 spin_lock(&priv->stream_lock); 5520 if (rc) { 5521 wiphy_err(hw->wiphy, "Stream for tid %d busy after %d" 5522 " attempts\n", tid, MAX_AMPDU_ATTEMPTS); 5523 mwl8k_remove_stream(hw, stream); 5524 rc = -EBUSY; 5525 break; 5526 } 5527 rc = IEEE80211_AMPDU_TX_START_IMMEDIATE; 5528 break; 5529 case IEEE80211_AMPDU_TX_STOP_CONT: 5530 case IEEE80211_AMPDU_TX_STOP_FLUSH: 5531 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 5532 if (stream) { 5533 if (stream->state == AMPDU_STREAM_ACTIVE) { 5534 idx = stream->idx; 5535 spin_unlock(&priv->stream_lock); 5536 mwl8k_destroy_ba(hw, idx); 5537 spin_lock(&priv->stream_lock); 5538 } 5539 mwl8k_remove_stream(hw, stream); 5540 } 5541 ieee80211_stop_tx_ba_cb_irqsafe(vif, addr, tid); 5542 break; 5543 case IEEE80211_AMPDU_TX_OPERATIONAL: 5544 BUG_ON(stream == NULL); 5545 BUG_ON(stream->state != AMPDU_STREAM_IN_PROGRESS); 5546 spin_unlock(&priv->stream_lock); 5547 rc = mwl8k_create_ba(hw, stream, buf_size, vif); 5548 spin_lock(&priv->stream_lock); 5549 if (!rc) 5550 stream->state = AMPDU_STREAM_ACTIVE; 5551 else { 5552 idx = stream->idx; 5553 spin_unlock(&priv->stream_lock); 5554 mwl8k_destroy_ba(hw, idx); 5555 spin_lock(&priv->stream_lock); 5556 wiphy_debug(hw->wiphy, 5557 "Failed adding stream for sta %pM tid %d\n", 5558 addr, tid); 5559 mwl8k_remove_stream(hw, stream); 5560 } 5561 break; 5562 5563 default: 5564 rc = -ENOTSUPP; 5565 } 5566 5567 spin_unlock(&priv->stream_lock); 5568 return rc; 5569 } 5570 5571 static void mwl8k_sw_scan_start(struct ieee80211_hw *hw, 5572 struct ieee80211_vif *vif, 5573 const u8 *mac_addr) 5574 { 5575 struct mwl8k_priv *priv = hw->priv; 5576 u8 tmp; 5577 5578 if (!priv->ap_fw) 5579 return; 5580 5581 /* clear all stats */ 5582 priv->channel_time = 0; 5583 ioread32(priv->regs + BBU_RXRDY_CNT_REG); 5584 ioread32(priv->regs + NOK_CCA_CNT_REG); 5585 mwl8k_cmd_bbp_reg_access(priv->hw, 0, BBU_AVG_NOISE_VAL, &tmp); 5586 5587 priv->sw_scan_start = true; 5588 } 5589 5590 static void mwl8k_sw_scan_complete(struct ieee80211_hw *hw, 5591 struct ieee80211_vif *vif) 5592 { 5593 struct mwl8k_priv *priv = hw->priv; 5594 u8 tmp; 5595 5596 if (!priv->ap_fw) 5597 return; 5598 5599 priv->sw_scan_start = false; 5600 5601 /* clear all stats */ 5602 priv->channel_time = 0; 5603 ioread32(priv->regs + BBU_RXRDY_CNT_REG); 5604 ioread32(priv->regs + NOK_CCA_CNT_REG); 5605 mwl8k_cmd_bbp_reg_access(priv->hw, 0, BBU_AVG_NOISE_VAL, &tmp); 5606 } 5607 5608 static const struct ieee80211_ops mwl8k_ops = { 5609 .tx = mwl8k_tx, 5610 .start = mwl8k_start, 5611 .stop = mwl8k_stop, 5612 .add_interface = mwl8k_add_interface, 5613 .remove_interface = mwl8k_remove_interface, 5614 .config = mwl8k_config, 5615 .bss_info_changed = mwl8k_bss_info_changed, 5616 .prepare_multicast = mwl8k_prepare_multicast, 5617 .configure_filter = mwl8k_configure_filter, 5618 .set_key = mwl8k_set_key, 5619 .set_rts_threshold = mwl8k_set_rts_threshold, 5620 .sta_add = mwl8k_sta_add, 5621 .sta_remove = mwl8k_sta_remove, 5622 .conf_tx = mwl8k_conf_tx, 5623 .get_stats = mwl8k_get_stats, 5624 .get_survey = mwl8k_get_survey, 5625 .ampdu_action = mwl8k_ampdu_action, 5626 .sw_scan_start = mwl8k_sw_scan_start, 5627 .sw_scan_complete = mwl8k_sw_scan_complete, 5628 }; 5629 5630 static void mwl8k_finalize_join_worker(struct work_struct *work) 5631 { 5632 struct mwl8k_priv *priv = 5633 container_of(work, struct mwl8k_priv, finalize_join_worker); 5634 struct sk_buff *skb = priv->beacon_skb; 5635 struct ieee80211_mgmt *mgmt = (void *)skb->data; 5636 int len = skb->len - offsetof(struct ieee80211_mgmt, u.beacon.variable); 5637 const u8 *tim = cfg80211_find_ie(WLAN_EID_TIM, 5638 mgmt->u.beacon.variable, len); 5639 int dtim_period = 1; 5640 5641 if (tim && tim[1] >= 2) 5642 dtim_period = tim[3]; 5643 5644 mwl8k_cmd_finalize_join(priv->hw, skb->data, skb->len, dtim_period); 5645 5646 dev_kfree_skb(skb); 5647 priv->beacon_skb = NULL; 5648 } 5649 5650 enum { 5651 MWL8363 = 0, 5652 MWL8687, 5653 MWL8366, 5654 MWL8764, 5655 }; 5656 5657 #define MWL8K_8366_AP_FW_API 3 5658 #define _MWL8K_8366_AP_FW(api) "mwl8k/fmimage_8366_ap-" #api ".fw" 5659 #define MWL8K_8366_AP_FW(api) _MWL8K_8366_AP_FW(api) 5660 5661 #define MWL8K_8764_AP_FW_API 1 5662 #define _MWL8K_8764_AP_FW(api) "mwl8k/fmimage_8764_ap-" #api ".fw" 5663 #define MWL8K_8764_AP_FW(api) _MWL8K_8764_AP_FW(api) 5664 5665 static struct mwl8k_device_info mwl8k_info_tbl[] = { 5666 [MWL8363] = { 5667 .part_name = "88w8363", 5668 .helper_image = "mwl8k/helper_8363.fw", 5669 .fw_image_sta = "mwl8k/fmimage_8363.fw", 5670 }, 5671 [MWL8687] = { 5672 .part_name = "88w8687", 5673 .helper_image = "mwl8k/helper_8687.fw", 5674 .fw_image_sta = "mwl8k/fmimage_8687.fw", 5675 }, 5676 [MWL8366] = { 5677 .part_name = "88w8366", 5678 .helper_image = "mwl8k/helper_8366.fw", 5679 .fw_image_sta = "mwl8k/fmimage_8366.fw", 5680 .fw_image_ap = MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API), 5681 .fw_api_ap = MWL8K_8366_AP_FW_API, 5682 .ap_rxd_ops = &rxd_ap_ops, 5683 }, 5684 [MWL8764] = { 5685 .part_name = "88w8764", 5686 .fw_image_ap = MWL8K_8764_AP_FW(MWL8K_8764_AP_FW_API), 5687 .fw_api_ap = MWL8K_8764_AP_FW_API, 5688 .ap_rxd_ops = &rxd_ap_ops, 5689 }, 5690 }; 5691 5692 MODULE_FIRMWARE("mwl8k/helper_8363.fw"); 5693 MODULE_FIRMWARE("mwl8k/fmimage_8363.fw"); 5694 MODULE_FIRMWARE("mwl8k/helper_8687.fw"); 5695 MODULE_FIRMWARE("mwl8k/fmimage_8687.fw"); 5696 MODULE_FIRMWARE("mwl8k/helper_8366.fw"); 5697 MODULE_FIRMWARE("mwl8k/fmimage_8366.fw"); 5698 MODULE_FIRMWARE(MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API)); 5699 5700 static const struct pci_device_id mwl8k_pci_id_table[] = { 5701 { PCI_VDEVICE(MARVELL, 0x2a0a), .driver_data = MWL8363, }, 5702 { PCI_VDEVICE(MARVELL, 0x2a0c), .driver_data = MWL8363, }, 5703 { PCI_VDEVICE(MARVELL, 0x2a24), .driver_data = MWL8363, }, 5704 { PCI_VDEVICE(MARVELL, 0x2a2b), .driver_data = MWL8687, }, 5705 { PCI_VDEVICE(MARVELL, 0x2a30), .driver_data = MWL8687, }, 5706 { PCI_VDEVICE(MARVELL, 0x2a40), .driver_data = MWL8366, }, 5707 { PCI_VDEVICE(MARVELL, 0x2a41), .driver_data = MWL8366, }, 5708 { PCI_VDEVICE(MARVELL, 0x2a42), .driver_data = MWL8366, }, 5709 { PCI_VDEVICE(MARVELL, 0x2a43), .driver_data = MWL8366, }, 5710 { PCI_VDEVICE(MARVELL, 0x2b36), .driver_data = MWL8764, }, 5711 { }, 5712 }; 5713 MODULE_DEVICE_TABLE(pci, mwl8k_pci_id_table); 5714 5715 static int mwl8k_request_alt_fw(struct mwl8k_priv *priv) 5716 { 5717 int rc; 5718 printk(KERN_ERR "%s: Error requesting preferred fw %s.\n" 5719 "Trying alternative firmware %s\n", pci_name(priv->pdev), 5720 priv->fw_pref, priv->fw_alt); 5721 rc = mwl8k_request_fw(priv, priv->fw_alt, &priv->fw_ucode, true); 5722 if (rc) { 5723 printk(KERN_ERR "%s: Error requesting alt fw %s\n", 5724 pci_name(priv->pdev), priv->fw_alt); 5725 return rc; 5726 } 5727 return 0; 5728 } 5729 5730 static int mwl8k_firmware_load_success(struct mwl8k_priv *priv); 5731 static void mwl8k_fw_state_machine(const struct firmware *fw, void *context) 5732 { 5733 struct mwl8k_priv *priv = context; 5734 struct mwl8k_device_info *di = priv->device_info; 5735 int rc; 5736 5737 switch (priv->fw_state) { 5738 case FW_STATE_INIT: 5739 if (!fw) { 5740 printk(KERN_ERR "%s: Error requesting helper fw %s\n", 5741 pci_name(priv->pdev), di->helper_image); 5742 goto fail; 5743 } 5744 priv->fw_helper = fw; 5745 rc = mwl8k_request_fw(priv, priv->fw_pref, &priv->fw_ucode, 5746 true); 5747 if (rc && priv->fw_alt) { 5748 rc = mwl8k_request_alt_fw(priv); 5749 if (rc) 5750 goto fail; 5751 priv->fw_state = FW_STATE_LOADING_ALT; 5752 } else if (rc) 5753 goto fail; 5754 else 5755 priv->fw_state = FW_STATE_LOADING_PREF; 5756 break; 5757 5758 case FW_STATE_LOADING_PREF: 5759 if (!fw) { 5760 if (priv->fw_alt) { 5761 rc = mwl8k_request_alt_fw(priv); 5762 if (rc) 5763 goto fail; 5764 priv->fw_state = FW_STATE_LOADING_ALT; 5765 } else 5766 goto fail; 5767 } else { 5768 priv->fw_ucode = fw; 5769 rc = mwl8k_firmware_load_success(priv); 5770 if (rc) 5771 goto fail; 5772 else 5773 complete(&priv->firmware_loading_complete); 5774 } 5775 break; 5776 5777 case FW_STATE_LOADING_ALT: 5778 if (!fw) { 5779 printk(KERN_ERR "%s: Error requesting alt fw %s\n", 5780 pci_name(priv->pdev), di->helper_image); 5781 goto fail; 5782 } 5783 priv->fw_ucode = fw; 5784 rc = mwl8k_firmware_load_success(priv); 5785 if (rc) 5786 goto fail; 5787 else 5788 complete(&priv->firmware_loading_complete); 5789 break; 5790 5791 default: 5792 printk(KERN_ERR "%s: Unexpected firmware loading state: %d\n", 5793 MWL8K_NAME, priv->fw_state); 5794 BUG_ON(1); 5795 } 5796 5797 return; 5798 5799 fail: 5800 priv->fw_state = FW_STATE_ERROR; 5801 complete(&priv->firmware_loading_complete); 5802 device_release_driver(&priv->pdev->dev); 5803 mwl8k_release_firmware(priv); 5804 } 5805 5806 #define MAX_RESTART_ATTEMPTS 1 5807 static int mwl8k_init_firmware(struct ieee80211_hw *hw, char *fw_image, 5808 bool nowait) 5809 { 5810 struct mwl8k_priv *priv = hw->priv; 5811 int rc; 5812 int count = MAX_RESTART_ATTEMPTS; 5813 5814 retry: 5815 /* Reset firmware and hardware */ 5816 mwl8k_hw_reset(priv); 5817 5818 /* Ask userland hotplug daemon for the device firmware */ 5819 rc = mwl8k_request_firmware(priv, fw_image, nowait); 5820 if (rc) { 5821 wiphy_err(hw->wiphy, "Firmware files not found\n"); 5822 return rc; 5823 } 5824 5825 if (nowait) 5826 return rc; 5827 5828 /* Load firmware into hardware */ 5829 rc = mwl8k_load_firmware(hw); 5830 if (rc) 5831 wiphy_err(hw->wiphy, "Cannot start firmware\n"); 5832 5833 /* Reclaim memory once firmware is successfully loaded */ 5834 mwl8k_release_firmware(priv); 5835 5836 if (rc && count) { 5837 /* FW did not start successfully; 5838 * lets try one more time 5839 */ 5840 count--; 5841 wiphy_err(hw->wiphy, "Trying to reload the firmware again\n"); 5842 msleep(20); 5843 goto retry; 5844 } 5845 5846 return rc; 5847 } 5848 5849 static int mwl8k_init_txqs(struct ieee80211_hw *hw) 5850 { 5851 struct mwl8k_priv *priv = hw->priv; 5852 int rc = 0; 5853 int i; 5854 5855 for (i = 0; i < mwl8k_tx_queues(priv); i++) { 5856 rc = mwl8k_txq_init(hw, i); 5857 if (rc) 5858 break; 5859 if (priv->ap_fw) 5860 iowrite32(priv->txq[i].txd_dma, 5861 priv->sram + priv->txq_offset[i]); 5862 } 5863 return rc; 5864 } 5865 5866 /* initialize hw after successfully loading a firmware image */ 5867 static int mwl8k_probe_hw(struct ieee80211_hw *hw) 5868 { 5869 struct mwl8k_priv *priv = hw->priv; 5870 int rc = 0; 5871 int i; 5872 5873 if (priv->ap_fw) { 5874 priv->rxd_ops = priv->device_info->ap_rxd_ops; 5875 if (priv->rxd_ops == NULL) { 5876 wiphy_err(hw->wiphy, 5877 "Driver does not have AP firmware image support for this hardware\n"); 5878 rc = -ENOENT; 5879 goto err_stop_firmware; 5880 } 5881 } else { 5882 priv->rxd_ops = &rxd_sta_ops; 5883 } 5884 5885 priv->sniffer_enabled = false; 5886 priv->wmm_enabled = false; 5887 priv->pending_tx_pkts = 0; 5888 atomic_set(&priv->watchdog_event_pending, 0); 5889 5890 rc = mwl8k_rxq_init(hw, 0); 5891 if (rc) 5892 goto err_stop_firmware; 5893 rxq_refill(hw, 0, INT_MAX); 5894 5895 /* For the sta firmware, we need to know the dma addresses of tx queues 5896 * before sending MWL8K_CMD_GET_HW_SPEC. So we must initialize them 5897 * prior to issuing this command. But for the AP case, we learn the 5898 * total number of queues from the result CMD_GET_HW_SPEC, so for this 5899 * case we must initialize the tx queues after. 5900 */ 5901 priv->num_ampdu_queues = 0; 5902 if (!priv->ap_fw) { 5903 rc = mwl8k_init_txqs(hw); 5904 if (rc) 5905 goto err_free_queues; 5906 } 5907 5908 iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS); 5909 iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK); 5910 iowrite32(MWL8K_A2H_INT_TX_DONE|MWL8K_A2H_INT_RX_READY| 5911 MWL8K_A2H_INT_BA_WATCHDOG, 5912 priv->regs + MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL); 5913 iowrite32(MWL8K_A2H_INT_OPC_DONE, 5914 priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK); 5915 5916 rc = request_irq(priv->pdev->irq, mwl8k_interrupt, 5917 IRQF_SHARED, MWL8K_NAME, hw); 5918 if (rc) { 5919 wiphy_err(hw->wiphy, "failed to register IRQ handler\n"); 5920 goto err_free_queues; 5921 } 5922 5923 /* 5924 * When hw restart is requested, 5925 * mac80211 will take care of clearing 5926 * the ampdu streams, so do not clear 5927 * the ampdu state here 5928 */ 5929 if (!priv->hw_restart_in_progress) 5930 memset(priv->ampdu, 0, sizeof(priv->ampdu)); 5931 5932 /* 5933 * Temporarily enable interrupts. Initial firmware host 5934 * commands use interrupts and avoid polling. Disable 5935 * interrupts when done. 5936 */ 5937 iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK); 5938 5939 /* Get config data, mac addrs etc */ 5940 if (priv->ap_fw) { 5941 rc = mwl8k_cmd_get_hw_spec_ap(hw); 5942 if (!rc) 5943 rc = mwl8k_init_txqs(hw); 5944 if (!rc) 5945 rc = mwl8k_cmd_set_hw_spec(hw); 5946 } else { 5947 rc = mwl8k_cmd_get_hw_spec_sta(hw); 5948 } 5949 if (rc) { 5950 wiphy_err(hw->wiphy, "Cannot initialise firmware\n"); 5951 goto err_free_irq; 5952 } 5953 5954 /* Turn radio off */ 5955 rc = mwl8k_cmd_radio_disable(hw); 5956 if (rc) { 5957 wiphy_err(hw->wiphy, "Cannot disable\n"); 5958 goto err_free_irq; 5959 } 5960 5961 /* Clear MAC address */ 5962 rc = mwl8k_cmd_set_mac_addr(hw, NULL, "\x00\x00\x00\x00\x00\x00"); 5963 if (rc) { 5964 wiphy_err(hw->wiphy, "Cannot clear MAC address\n"); 5965 goto err_free_irq; 5966 } 5967 5968 /* Configure Antennas */ 5969 rc = mwl8k_cmd_rf_antenna(hw, MWL8K_RF_ANTENNA_RX, 0x3); 5970 if (rc) 5971 wiphy_warn(hw->wiphy, "failed to set # of RX antennas"); 5972 rc = mwl8k_cmd_rf_antenna(hw, MWL8K_RF_ANTENNA_TX, 0x7); 5973 if (rc) 5974 wiphy_warn(hw->wiphy, "failed to set # of TX antennas"); 5975 5976 5977 /* Disable interrupts */ 5978 iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK); 5979 free_irq(priv->pdev->irq, hw); 5980 5981 wiphy_info(hw->wiphy, "%s v%d, %pm, %s firmware %u.%u.%u.%u\n", 5982 priv->device_info->part_name, 5983 priv->hw_rev, hw->wiphy->perm_addr, 5984 priv->ap_fw ? "AP" : "STA", 5985 (priv->fw_rev >> 24) & 0xff, (priv->fw_rev >> 16) & 0xff, 5986 (priv->fw_rev >> 8) & 0xff, priv->fw_rev & 0xff); 5987 5988 return 0; 5989 5990 err_free_irq: 5991 iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK); 5992 free_irq(priv->pdev->irq, hw); 5993 5994 err_free_queues: 5995 for (i = 0; i < mwl8k_tx_queues(priv); i++) 5996 mwl8k_txq_deinit(hw, i); 5997 mwl8k_rxq_deinit(hw, 0); 5998 5999 err_stop_firmware: 6000 mwl8k_hw_reset(priv); 6001 6002 return rc; 6003 } 6004 6005 /* 6006 * invoke mwl8k_reload_firmware to change the firmware image after the device 6007 * has already been registered 6008 */ 6009 static int mwl8k_reload_firmware(struct ieee80211_hw *hw, char *fw_image) 6010 { 6011 int i, rc = 0; 6012 struct mwl8k_priv *priv = hw->priv; 6013 struct mwl8k_vif *vif, *tmp_vif; 6014 6015 mwl8k_stop(hw); 6016 mwl8k_rxq_deinit(hw, 0); 6017 6018 /* 6019 * All the existing interfaces are re-added by the ieee80211_reconfig; 6020 * which means driver should remove existing interfaces before calling 6021 * ieee80211_restart_hw 6022 */ 6023 if (priv->hw_restart_in_progress) 6024 list_for_each_entry_safe(vif, tmp_vif, &priv->vif_list, list) 6025 mwl8k_remove_vif(priv, vif); 6026 6027 for (i = 0; i < mwl8k_tx_queues(priv); i++) 6028 mwl8k_txq_deinit(hw, i); 6029 6030 rc = mwl8k_init_firmware(hw, fw_image, false); 6031 if (rc) 6032 goto fail; 6033 6034 rc = mwl8k_probe_hw(hw); 6035 if (rc) 6036 goto fail; 6037 6038 if (priv->hw_restart_in_progress) 6039 return rc; 6040 6041 rc = mwl8k_start(hw); 6042 if (rc) 6043 goto fail; 6044 6045 rc = mwl8k_config(hw, ~0); 6046 if (rc) 6047 goto fail; 6048 6049 for (i = 0; i < MWL8K_TX_WMM_QUEUES; i++) { 6050 rc = mwl8k_conf_tx(hw, NULL, i, &priv->wmm_params[i]); 6051 if (rc) 6052 goto fail; 6053 } 6054 6055 return rc; 6056 6057 fail: 6058 printk(KERN_WARNING "mwl8k: Failed to reload firmware image.\n"); 6059 return rc; 6060 } 6061 6062 static const struct ieee80211_iface_limit ap_if_limits[] = { 6063 { .max = 8, .types = BIT(NL80211_IFTYPE_AP) }, 6064 { .max = 1, .types = BIT(NL80211_IFTYPE_STATION) }, 6065 }; 6066 6067 static const struct ieee80211_iface_combination ap_if_comb = { 6068 .limits = ap_if_limits, 6069 .n_limits = ARRAY_SIZE(ap_if_limits), 6070 .max_interfaces = 8, 6071 .num_different_channels = 1, 6072 }; 6073 6074 6075 static int mwl8k_firmware_load_success(struct mwl8k_priv *priv) 6076 { 6077 struct ieee80211_hw *hw = priv->hw; 6078 int i, rc; 6079 6080 rc = mwl8k_load_firmware(hw); 6081 mwl8k_release_firmware(priv); 6082 if (rc) { 6083 wiphy_err(hw->wiphy, "Cannot start firmware\n"); 6084 return rc; 6085 } 6086 6087 /* 6088 * Extra headroom is the size of the required DMA header 6089 * minus the size of the smallest 802.11 frame (CTS frame). 6090 */ 6091 hw->extra_tx_headroom = 6092 sizeof(struct mwl8k_dma_data) - sizeof(struct ieee80211_cts); 6093 6094 hw->extra_tx_headroom -= priv->ap_fw ? REDUCED_TX_HEADROOM : 0; 6095 6096 hw->queues = MWL8K_TX_WMM_QUEUES; 6097 6098 /* Set rssi values to dBm */ 6099 ieee80211_hw_set(hw, SIGNAL_DBM); 6100 ieee80211_hw_set(hw, HAS_RATE_CONTROL); 6101 6102 /* 6103 * Ask mac80211 to not to trigger PS mode 6104 * based on PM bit of incoming frames. 6105 */ 6106 if (priv->ap_fw) 6107 ieee80211_hw_set(hw, AP_LINK_PS); 6108 6109 hw->vif_data_size = sizeof(struct mwl8k_vif); 6110 hw->sta_data_size = sizeof(struct mwl8k_sta); 6111 6112 priv->macids_used = 0; 6113 INIT_LIST_HEAD(&priv->vif_list); 6114 6115 /* Set default radio state and preamble */ 6116 priv->radio_on = false; 6117 priv->radio_short_preamble = false; 6118 6119 /* Finalize join worker */ 6120 INIT_WORK(&priv->finalize_join_worker, mwl8k_finalize_join_worker); 6121 /* Handle watchdog ba events */ 6122 INIT_WORK(&priv->watchdog_ba_handle, mwl8k_watchdog_ba_events); 6123 /* To reload the firmware if it crashes */ 6124 INIT_WORK(&priv->fw_reload, mwl8k_hw_restart_work); 6125 6126 /* TX reclaim and RX tasklets. */ 6127 tasklet_setup(&priv->poll_tx_task, mwl8k_tx_poll); 6128 tasklet_disable(&priv->poll_tx_task); 6129 tasklet_setup(&priv->poll_rx_task, mwl8k_rx_poll); 6130 tasklet_disable(&priv->poll_rx_task); 6131 6132 /* Power management cookie */ 6133 priv->cookie = dma_alloc_coherent(&priv->pdev->dev, 4, 6134 &priv->cookie_dma, GFP_KERNEL); 6135 if (priv->cookie == NULL) 6136 return -ENOMEM; 6137 6138 mutex_init(&priv->fw_mutex); 6139 priv->fw_mutex_owner = NULL; 6140 priv->fw_mutex_depth = 0; 6141 priv->hostcmd_wait = NULL; 6142 6143 spin_lock_init(&priv->tx_lock); 6144 6145 spin_lock_init(&priv->stream_lock); 6146 6147 priv->tx_wait = NULL; 6148 6149 rc = mwl8k_probe_hw(hw); 6150 if (rc) 6151 goto err_free_cookie; 6152 6153 hw->wiphy->interface_modes = 0; 6154 6155 if (priv->ap_macids_supported || priv->device_info->fw_image_ap) { 6156 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP); 6157 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_STATION); 6158 hw->wiphy->iface_combinations = &ap_if_comb; 6159 hw->wiphy->n_iface_combinations = 1; 6160 } 6161 6162 if (priv->sta_macids_supported || priv->device_info->fw_image_sta) 6163 hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_STATION); 6164 6165 wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 6166 6167 rc = ieee80211_register_hw(hw); 6168 if (rc) { 6169 wiphy_err(hw->wiphy, "Cannot register device\n"); 6170 goto err_unprobe_hw; 6171 } 6172 6173 return 0; 6174 6175 err_unprobe_hw: 6176 for (i = 0; i < mwl8k_tx_queues(priv); i++) 6177 mwl8k_txq_deinit(hw, i); 6178 mwl8k_rxq_deinit(hw, 0); 6179 6180 err_free_cookie: 6181 if (priv->cookie != NULL) 6182 dma_free_coherent(&priv->pdev->dev, 4, priv->cookie, 6183 priv->cookie_dma); 6184 6185 return rc; 6186 } 6187 static int mwl8k_probe(struct pci_dev *pdev, 6188 const struct pci_device_id *id) 6189 { 6190 static int printed_version; 6191 struct ieee80211_hw *hw; 6192 struct mwl8k_priv *priv; 6193 struct mwl8k_device_info *di; 6194 int rc; 6195 6196 if (!printed_version) { 6197 printk(KERN_INFO "%s version %s\n", MWL8K_DESC, MWL8K_VERSION); 6198 printed_version = 1; 6199 } 6200 6201 6202 rc = pci_enable_device(pdev); 6203 if (rc) { 6204 printk(KERN_ERR "%s: Cannot enable new PCI device\n", 6205 MWL8K_NAME); 6206 return rc; 6207 } 6208 6209 rc = pci_request_regions(pdev, MWL8K_NAME); 6210 if (rc) { 6211 printk(KERN_ERR "%s: Cannot obtain PCI resources\n", 6212 MWL8K_NAME); 6213 goto err_disable_device; 6214 } 6215 6216 pci_set_master(pdev); 6217 6218 6219 hw = ieee80211_alloc_hw(sizeof(*priv), &mwl8k_ops); 6220 if (hw == NULL) { 6221 printk(KERN_ERR "%s: ieee80211 alloc failed\n", MWL8K_NAME); 6222 rc = -ENOMEM; 6223 goto err_free_reg; 6224 } 6225 6226 SET_IEEE80211_DEV(hw, &pdev->dev); 6227 pci_set_drvdata(pdev, hw); 6228 6229 priv = hw->priv; 6230 priv->hw = hw; 6231 priv->pdev = pdev; 6232 priv->device_info = &mwl8k_info_tbl[id->driver_data]; 6233 6234 if (id->driver_data == MWL8764) 6235 priv->is_8764 = true; 6236 6237 priv->sram = pci_iomap(pdev, 0, 0x10000); 6238 if (priv->sram == NULL) { 6239 wiphy_err(hw->wiphy, "Cannot map device SRAM\n"); 6240 rc = -EIO; 6241 goto err_iounmap; 6242 } 6243 6244 /* 6245 * If BAR0 is a 32 bit BAR, the register BAR will be BAR1. 6246 * If BAR0 is a 64 bit BAR, the register BAR will be BAR2. 6247 */ 6248 priv->regs = pci_iomap(pdev, 1, 0x10000); 6249 if (priv->regs == NULL) { 6250 priv->regs = pci_iomap(pdev, 2, 0x10000); 6251 if (priv->regs == NULL) { 6252 wiphy_err(hw->wiphy, "Cannot map device registers\n"); 6253 rc = -EIO; 6254 goto err_iounmap; 6255 } 6256 } 6257 6258 /* 6259 * Choose the initial fw image depending on user input. If a second 6260 * image is available, make it the alternative image that will be 6261 * loaded if the first one fails. 6262 */ 6263 init_completion(&priv->firmware_loading_complete); 6264 di = priv->device_info; 6265 if (ap_mode_default && di->fw_image_ap) { 6266 priv->fw_pref = di->fw_image_ap; 6267 priv->fw_alt = di->fw_image_sta; 6268 } else if (!ap_mode_default && di->fw_image_sta) { 6269 priv->fw_pref = di->fw_image_sta; 6270 priv->fw_alt = di->fw_image_ap; 6271 } else if (ap_mode_default && !di->fw_image_ap && di->fw_image_sta) { 6272 printk(KERN_WARNING "AP fw is unavailable. Using STA fw."); 6273 priv->fw_pref = di->fw_image_sta; 6274 } else if (!ap_mode_default && !di->fw_image_sta && di->fw_image_ap) { 6275 printk(KERN_WARNING "STA fw is unavailable. Using AP fw."); 6276 priv->fw_pref = di->fw_image_ap; 6277 } 6278 rc = mwl8k_init_firmware(hw, priv->fw_pref, true); 6279 if (rc) 6280 goto err_stop_firmware; 6281 6282 priv->hw_restart_in_progress = false; 6283 6284 priv->running_bsses = 0; 6285 6286 return rc; 6287 6288 err_stop_firmware: 6289 mwl8k_hw_reset(priv); 6290 6291 err_iounmap: 6292 if (priv->regs != NULL) 6293 pci_iounmap(pdev, priv->regs); 6294 6295 if (priv->sram != NULL) 6296 pci_iounmap(pdev, priv->sram); 6297 6298 ieee80211_free_hw(hw); 6299 6300 err_free_reg: 6301 pci_release_regions(pdev); 6302 6303 err_disable_device: 6304 pci_disable_device(pdev); 6305 6306 return rc; 6307 } 6308 6309 static void mwl8k_remove(struct pci_dev *pdev) 6310 { 6311 struct ieee80211_hw *hw = pci_get_drvdata(pdev); 6312 struct mwl8k_priv *priv; 6313 int i; 6314 6315 if (hw == NULL) 6316 return; 6317 priv = hw->priv; 6318 6319 wait_for_completion(&priv->firmware_loading_complete); 6320 6321 if (priv->fw_state == FW_STATE_ERROR) { 6322 mwl8k_hw_reset(priv); 6323 goto unmap; 6324 } 6325 6326 ieee80211_stop_queues(hw); 6327 6328 ieee80211_unregister_hw(hw); 6329 6330 /* Remove TX reclaim and RX tasklets. */ 6331 tasklet_kill(&priv->poll_tx_task); 6332 tasklet_kill(&priv->poll_rx_task); 6333 6334 /* Stop hardware */ 6335 mwl8k_hw_reset(priv); 6336 6337 /* Return all skbs to mac80211 */ 6338 for (i = 0; i < mwl8k_tx_queues(priv); i++) 6339 mwl8k_txq_reclaim(hw, i, INT_MAX, 1); 6340 6341 for (i = 0; i < mwl8k_tx_queues(priv); i++) 6342 mwl8k_txq_deinit(hw, i); 6343 6344 mwl8k_rxq_deinit(hw, 0); 6345 6346 dma_free_coherent(&priv->pdev->dev, 4, priv->cookie, priv->cookie_dma); 6347 6348 unmap: 6349 pci_iounmap(pdev, priv->regs); 6350 pci_iounmap(pdev, priv->sram); 6351 ieee80211_free_hw(hw); 6352 pci_release_regions(pdev); 6353 pci_disable_device(pdev); 6354 } 6355 6356 static struct pci_driver mwl8k_driver = { 6357 .name = MWL8K_NAME, 6358 .id_table = mwl8k_pci_id_table, 6359 .probe = mwl8k_probe, 6360 .remove = mwl8k_remove, 6361 }; 6362 6363 module_pci_driver(mwl8k_driver); 6364 6365 MODULE_DESCRIPTION(MWL8K_DESC); 6366 MODULE_VERSION(MWL8K_VERSION); 6367 MODULE_AUTHOR("Lennert Buytenhek <buytenh@marvell.com>"); 6368 MODULE_LICENSE("GPL"); 6369