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