12b27bdccSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 290921014SLuciano Coelho /* 390921014SLuciano Coelho * This file is part of wl1251 490921014SLuciano Coelho * 590921014SLuciano Coelho * Copyright (C) 2008-2009 Nokia Corporation 690921014SLuciano Coelho */ 790921014SLuciano Coelho 890921014SLuciano Coelho #include <linux/module.h> 990921014SLuciano Coelho #include <linux/interrupt.h> 1090921014SLuciano Coelho #include <linux/firmware.h> 1190921014SLuciano Coelho #include <linux/delay.h> 1290921014SLuciano Coelho #include <linux/irq.h> 1390921014SLuciano Coelho #include <linux/crc32.h> 1490921014SLuciano Coelho #include <linux/etherdevice.h> 1590921014SLuciano Coelho #include <linux/vmalloc.h> 1690921014SLuciano Coelho #include <linux/slab.h> 179ed74ba0SDavid Gnedt #include <linux/netdevice.h> 1890921014SLuciano Coelho 1990921014SLuciano Coelho #include "wl1251.h" 2090921014SLuciano Coelho #include "wl12xx_80211.h" 2190921014SLuciano Coelho #include "reg.h" 2290921014SLuciano Coelho #include "io.h" 2390921014SLuciano Coelho #include "cmd.h" 2490921014SLuciano Coelho #include "event.h" 2590921014SLuciano Coelho #include "tx.h" 2690921014SLuciano Coelho #include "rx.h" 2790921014SLuciano Coelho #include "ps.h" 2890921014SLuciano Coelho #include "init.h" 2990921014SLuciano Coelho #include "debugfs.h" 3090921014SLuciano Coelho #include "boot.h" 3190921014SLuciano Coelho 3290921014SLuciano Coelho void wl1251_enable_interrupts(struct wl1251 *wl) 3390921014SLuciano Coelho { 3490921014SLuciano Coelho wl->if_ops->enable_irq(wl); 3590921014SLuciano Coelho } 3690921014SLuciano Coelho 3790921014SLuciano Coelho void wl1251_disable_interrupts(struct wl1251 *wl) 3890921014SLuciano Coelho { 3990921014SLuciano Coelho wl->if_ops->disable_irq(wl); 4090921014SLuciano Coelho } 4190921014SLuciano Coelho 4290921014SLuciano Coelho static int wl1251_power_off(struct wl1251 *wl) 4390921014SLuciano Coelho { 4490921014SLuciano Coelho return wl->if_ops->power(wl, false); 4590921014SLuciano Coelho } 4690921014SLuciano Coelho 4790921014SLuciano Coelho static int wl1251_power_on(struct wl1251 *wl) 4890921014SLuciano Coelho { 4990921014SLuciano Coelho return wl->if_ops->power(wl, true); 5090921014SLuciano Coelho } 5190921014SLuciano Coelho 5290921014SLuciano Coelho static int wl1251_fetch_firmware(struct wl1251 *wl) 5390921014SLuciano Coelho { 5490921014SLuciano Coelho const struct firmware *fw; 5590921014SLuciano Coelho struct device *dev = wiphy_dev(wl->hw->wiphy); 5690921014SLuciano Coelho int ret; 5790921014SLuciano Coelho 5890921014SLuciano Coelho ret = request_firmware(&fw, WL1251_FW_NAME, dev); 5990921014SLuciano Coelho 6090921014SLuciano Coelho if (ret < 0) { 6190921014SLuciano Coelho wl1251_error("could not get firmware: %d", ret); 6290921014SLuciano Coelho return ret; 6390921014SLuciano Coelho } 6490921014SLuciano Coelho 6590921014SLuciano Coelho if (fw->size % 4) { 6690921014SLuciano Coelho wl1251_error("firmware size is not multiple of 32 bits: %zu", 6790921014SLuciano Coelho fw->size); 6890921014SLuciano Coelho ret = -EILSEQ; 6990921014SLuciano Coelho goto out; 7090921014SLuciano Coelho } 7190921014SLuciano Coelho 7290921014SLuciano Coelho wl->fw_len = fw->size; 7390921014SLuciano Coelho wl->fw = vmalloc(wl->fw_len); 7490921014SLuciano Coelho 7590921014SLuciano Coelho if (!wl->fw) { 7690921014SLuciano Coelho wl1251_error("could not allocate memory for the firmware"); 7790921014SLuciano Coelho ret = -ENOMEM; 7890921014SLuciano Coelho goto out; 7990921014SLuciano Coelho } 8090921014SLuciano Coelho 8190921014SLuciano Coelho memcpy(wl->fw, fw->data, wl->fw_len); 8290921014SLuciano Coelho 8390921014SLuciano Coelho ret = 0; 8490921014SLuciano Coelho 8590921014SLuciano Coelho out: 8690921014SLuciano Coelho release_firmware(fw); 8790921014SLuciano Coelho 8890921014SLuciano Coelho return ret; 8990921014SLuciano Coelho } 9090921014SLuciano Coelho 9190921014SLuciano Coelho static int wl1251_fetch_nvs(struct wl1251 *wl) 9290921014SLuciano Coelho { 9390921014SLuciano Coelho const struct firmware *fw; 9490921014SLuciano Coelho struct device *dev = wiphy_dev(wl->hw->wiphy); 9590921014SLuciano Coelho int ret; 9690921014SLuciano Coelho 9790921014SLuciano Coelho ret = request_firmware(&fw, WL1251_NVS_NAME, dev); 9890921014SLuciano Coelho 9990921014SLuciano Coelho if (ret < 0) { 10090921014SLuciano Coelho wl1251_error("could not get nvs file: %d", ret); 10190921014SLuciano Coelho return ret; 10290921014SLuciano Coelho } 10390921014SLuciano Coelho 10490921014SLuciano Coelho if (fw->size % 4) { 10590921014SLuciano Coelho wl1251_error("nvs size is not multiple of 32 bits: %zu", 10690921014SLuciano Coelho fw->size); 10790921014SLuciano Coelho ret = -EILSEQ; 10890921014SLuciano Coelho goto out; 10990921014SLuciano Coelho } 11090921014SLuciano Coelho 111f63b4c97SPali Rohár wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL); 11290921014SLuciano Coelho 11390921014SLuciano Coelho if (!wl->nvs) { 11490921014SLuciano Coelho wl1251_error("could not allocate memory for the nvs file"); 11590921014SLuciano Coelho ret = -ENOMEM; 11690921014SLuciano Coelho goto out; 11790921014SLuciano Coelho } 11890921014SLuciano Coelho 119f63b4c97SPali Rohár wl->nvs_len = fw->size; 120f63b4c97SPali Rohár 12190921014SLuciano Coelho ret = 0; 12290921014SLuciano Coelho 12390921014SLuciano Coelho out: 12490921014SLuciano Coelho release_firmware(fw); 12590921014SLuciano Coelho 12690921014SLuciano Coelho return ret; 12790921014SLuciano Coelho } 12890921014SLuciano Coelho 12990921014SLuciano Coelho static void wl1251_fw_wakeup(struct wl1251 *wl) 13090921014SLuciano Coelho { 13190921014SLuciano Coelho u32 elp_reg; 13290921014SLuciano Coelho 13390921014SLuciano Coelho elp_reg = ELPCTRL_WAKE_UP; 13490921014SLuciano Coelho wl1251_write_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, elp_reg); 13590921014SLuciano Coelho elp_reg = wl1251_read_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR); 13690921014SLuciano Coelho 13790921014SLuciano Coelho if (!(elp_reg & ELPCTRL_WLAN_READY)) 13890921014SLuciano Coelho wl1251_warning("WLAN not ready"); 13990921014SLuciano Coelho } 14090921014SLuciano Coelho 14190921014SLuciano Coelho static int wl1251_chip_wakeup(struct wl1251 *wl) 14290921014SLuciano Coelho { 14390921014SLuciano Coelho int ret; 14490921014SLuciano Coelho 14590921014SLuciano Coelho ret = wl1251_power_on(wl); 14690921014SLuciano Coelho if (ret < 0) 14790921014SLuciano Coelho return ret; 14890921014SLuciano Coelho 14990921014SLuciano Coelho msleep(WL1251_POWER_ON_SLEEP); 15090921014SLuciano Coelho wl->if_ops->reset(wl); 15190921014SLuciano Coelho 15290921014SLuciano Coelho /* We don't need a real memory partition here, because we only want 15390921014SLuciano Coelho * to use the registers at this point. */ 15490921014SLuciano Coelho wl1251_set_partition(wl, 15590921014SLuciano Coelho 0x00000000, 15690921014SLuciano Coelho 0x00000000, 15790921014SLuciano Coelho REGISTERS_BASE, 15890921014SLuciano Coelho REGISTERS_DOWN_SIZE); 15990921014SLuciano Coelho 16090921014SLuciano Coelho /* ELP module wake up */ 16190921014SLuciano Coelho wl1251_fw_wakeup(wl); 16290921014SLuciano Coelho 16390921014SLuciano Coelho /* whal_FwCtrl_BootSm() */ 16490921014SLuciano Coelho 16590921014SLuciano Coelho /* 0. read chip id from CHIP_ID */ 16690921014SLuciano Coelho wl->chip_id = wl1251_reg_read32(wl, CHIP_ID_B); 16790921014SLuciano Coelho 16890921014SLuciano Coelho /* 1. check if chip id is valid */ 16990921014SLuciano Coelho 17090921014SLuciano Coelho switch (wl->chip_id) { 17190921014SLuciano Coelho case CHIP_ID_1251_PG12: 17290921014SLuciano Coelho wl1251_debug(DEBUG_BOOT, "chip id 0x%x (1251 PG12)", 17390921014SLuciano Coelho wl->chip_id); 17490921014SLuciano Coelho break; 17590921014SLuciano Coelho case CHIP_ID_1251_PG11: 17690921014SLuciano Coelho wl1251_debug(DEBUG_BOOT, "chip id 0x%x (1251 PG11)", 17790921014SLuciano Coelho wl->chip_id); 17890921014SLuciano Coelho break; 17990921014SLuciano Coelho case CHIP_ID_1251_PG10: 18090921014SLuciano Coelho default: 18190921014SLuciano Coelho wl1251_error("unsupported chip id: 0x%x", wl->chip_id); 18290921014SLuciano Coelho ret = -ENODEV; 18390921014SLuciano Coelho goto out; 18490921014SLuciano Coelho } 18590921014SLuciano Coelho 18690921014SLuciano Coelho if (wl->fw == NULL) { 18790921014SLuciano Coelho ret = wl1251_fetch_firmware(wl); 18890921014SLuciano Coelho if (ret < 0) 18990921014SLuciano Coelho goto out; 19090921014SLuciano Coelho } 19190921014SLuciano Coelho 19290921014SLuciano Coelho out: 19390921014SLuciano Coelho return ret; 19490921014SLuciano Coelho } 19590921014SLuciano Coelho 19690921014SLuciano Coelho #define WL1251_IRQ_LOOP_COUNT 10 19790921014SLuciano Coelho static void wl1251_irq_work(struct work_struct *work) 19890921014SLuciano Coelho { 19990921014SLuciano Coelho u32 intr, ctr = WL1251_IRQ_LOOP_COUNT; 20090921014SLuciano Coelho struct wl1251 *wl = 20190921014SLuciano Coelho container_of(work, struct wl1251, irq_work); 20290921014SLuciano Coelho int ret; 20390921014SLuciano Coelho 20490921014SLuciano Coelho mutex_lock(&wl->mutex); 20590921014SLuciano Coelho 20690921014SLuciano Coelho wl1251_debug(DEBUG_IRQ, "IRQ work"); 20790921014SLuciano Coelho 20890921014SLuciano Coelho if (wl->state == WL1251_STATE_OFF) 20990921014SLuciano Coelho goto out; 21090921014SLuciano Coelho 21190921014SLuciano Coelho ret = wl1251_ps_elp_wakeup(wl); 21290921014SLuciano Coelho if (ret < 0) 21390921014SLuciano Coelho goto out; 21490921014SLuciano Coelho 21590921014SLuciano Coelho wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, WL1251_ACX_INTR_ALL); 21690921014SLuciano Coelho 21790921014SLuciano Coelho intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR); 21890921014SLuciano Coelho wl1251_debug(DEBUG_IRQ, "intr: 0x%x", intr); 21990921014SLuciano Coelho 22090921014SLuciano Coelho do { 22190921014SLuciano Coelho if (wl->data_path) { 22290921014SLuciano Coelho wl->rx_counter = wl1251_mem_read32( 22390921014SLuciano Coelho wl, wl->data_path->rx_control_addr); 22490921014SLuciano Coelho 22590921014SLuciano Coelho /* We handle a frmware bug here */ 22690921014SLuciano Coelho switch ((wl->rx_counter - wl->rx_handled) & 0xf) { 22790921014SLuciano Coelho case 0: 22890921014SLuciano Coelho wl1251_debug(DEBUG_IRQ, 22990921014SLuciano Coelho "RX: FW and host in sync"); 23090921014SLuciano Coelho intr &= ~WL1251_ACX_INTR_RX0_DATA; 23190921014SLuciano Coelho intr &= ~WL1251_ACX_INTR_RX1_DATA; 23290921014SLuciano Coelho break; 23390921014SLuciano Coelho case 1: 23490921014SLuciano Coelho wl1251_debug(DEBUG_IRQ, "RX: FW +1"); 23590921014SLuciano Coelho intr |= WL1251_ACX_INTR_RX0_DATA; 23690921014SLuciano Coelho intr &= ~WL1251_ACX_INTR_RX1_DATA; 23790921014SLuciano Coelho break; 23890921014SLuciano Coelho case 2: 23990921014SLuciano Coelho wl1251_debug(DEBUG_IRQ, "RX: FW +2"); 24090921014SLuciano Coelho intr |= WL1251_ACX_INTR_RX0_DATA; 24190921014SLuciano Coelho intr |= WL1251_ACX_INTR_RX1_DATA; 24290921014SLuciano Coelho break; 24390921014SLuciano Coelho default: 24490921014SLuciano Coelho wl1251_warning( 24590921014SLuciano Coelho "RX: FW and host out of sync: %d", 24690921014SLuciano Coelho wl->rx_counter - wl->rx_handled); 24790921014SLuciano Coelho break; 24890921014SLuciano Coelho } 24990921014SLuciano Coelho 25090921014SLuciano Coelho wl->rx_handled = wl->rx_counter; 25190921014SLuciano Coelho 25290921014SLuciano Coelho wl1251_debug(DEBUG_IRQ, "RX counter: %d", 25390921014SLuciano Coelho wl->rx_counter); 25490921014SLuciano Coelho } 25590921014SLuciano Coelho 25690921014SLuciano Coelho intr &= wl->intr_mask; 25790921014SLuciano Coelho 25890921014SLuciano Coelho if (intr == 0) { 25990921014SLuciano Coelho wl1251_debug(DEBUG_IRQ, "INTR is 0"); 26090921014SLuciano Coelho goto out_sleep; 26190921014SLuciano Coelho } 26290921014SLuciano Coelho 26390921014SLuciano Coelho if (intr & WL1251_ACX_INTR_RX0_DATA) { 26490921014SLuciano Coelho wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX0_DATA"); 26590921014SLuciano Coelho wl1251_rx(wl); 26690921014SLuciano Coelho } 26790921014SLuciano Coelho 26890921014SLuciano Coelho if (intr & WL1251_ACX_INTR_RX1_DATA) { 26990921014SLuciano Coelho wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX1_DATA"); 27090921014SLuciano Coelho wl1251_rx(wl); 27190921014SLuciano Coelho } 27290921014SLuciano Coelho 27390921014SLuciano Coelho if (intr & WL1251_ACX_INTR_TX_RESULT) { 27490921014SLuciano Coelho wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_TX_RESULT"); 27590921014SLuciano Coelho wl1251_tx_complete(wl); 27690921014SLuciano Coelho } 27790921014SLuciano Coelho 27890921014SLuciano Coelho if (intr & WL1251_ACX_INTR_EVENT_A) { 27990921014SLuciano Coelho wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_EVENT_A"); 28090921014SLuciano Coelho wl1251_event_handle(wl, 0); 28190921014SLuciano Coelho } 28290921014SLuciano Coelho 28390921014SLuciano Coelho if (intr & WL1251_ACX_INTR_EVENT_B) { 28490921014SLuciano Coelho wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_EVENT_B"); 28590921014SLuciano Coelho wl1251_event_handle(wl, 1); 28690921014SLuciano Coelho } 28790921014SLuciano Coelho 28890921014SLuciano Coelho if (intr & WL1251_ACX_INTR_INIT_COMPLETE) 28990921014SLuciano Coelho wl1251_debug(DEBUG_IRQ, 29090921014SLuciano Coelho "WL1251_ACX_INTR_INIT_COMPLETE"); 29190921014SLuciano Coelho 29290921014SLuciano Coelho if (--ctr == 0) 29390921014SLuciano Coelho break; 29490921014SLuciano Coelho 29590921014SLuciano Coelho intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR); 29690921014SLuciano Coelho } while (intr); 29790921014SLuciano Coelho 29890921014SLuciano Coelho out_sleep: 29990921014SLuciano Coelho wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, ~(wl->intr_mask)); 30090921014SLuciano Coelho wl1251_ps_elp_sleep(wl); 30190921014SLuciano Coelho 30290921014SLuciano Coelho out: 30390921014SLuciano Coelho mutex_unlock(&wl->mutex); 30490921014SLuciano Coelho } 30590921014SLuciano Coelho 30690921014SLuciano Coelho static int wl1251_join(struct wl1251 *wl, u8 bss_type, u8 channel, 30790921014SLuciano Coelho u16 beacon_interval, u8 dtim_period) 30890921014SLuciano Coelho { 30990921014SLuciano Coelho int ret; 31090921014SLuciano Coelho 31190921014SLuciano Coelho ret = wl1251_acx_frame_rates(wl, DEFAULT_HW_GEN_TX_RATE, 31290921014SLuciano Coelho DEFAULT_HW_GEN_MODULATION_TYPE, 31390921014SLuciano Coelho wl->tx_mgmt_frm_rate, 31490921014SLuciano Coelho wl->tx_mgmt_frm_mod); 31590921014SLuciano Coelho if (ret < 0) 31690921014SLuciano Coelho goto out; 31790921014SLuciano Coelho 318a2d2bb86SGrazvydas Ignotas /* 319a2d2bb86SGrazvydas Ignotas * Join command applies filters, and if we are not associated, 320a2d2bb86SGrazvydas Ignotas * BSSID filter must be disabled for association to work. 321a2d2bb86SGrazvydas Ignotas */ 322a2d2bb86SGrazvydas Ignotas if (is_zero_ether_addr(wl->bssid)) 323a2d2bb86SGrazvydas Ignotas wl->rx_config &= ~CFG_BSSID_FILTER_EN; 32490921014SLuciano Coelho 32590921014SLuciano Coelho ret = wl1251_cmd_join(wl, bss_type, channel, beacon_interval, 32690921014SLuciano Coelho dtim_period); 32790921014SLuciano Coelho if (ret < 0) 32890921014SLuciano Coelho goto out; 32990921014SLuciano Coelho 33090921014SLuciano Coelho ret = wl1251_event_wait(wl, JOIN_EVENT_COMPLETE_ID, 100); 33190921014SLuciano Coelho if (ret < 0) 33290921014SLuciano Coelho wl1251_warning("join timeout"); 33390921014SLuciano Coelho 33490921014SLuciano Coelho out: 33590921014SLuciano Coelho return ret; 33690921014SLuciano Coelho } 33790921014SLuciano Coelho 33836323f81SThomas Huehn static void wl1251_op_tx(struct ieee80211_hw *hw, 33936323f81SThomas Huehn struct ieee80211_tx_control *control, 34036323f81SThomas Huehn struct sk_buff *skb) 34190921014SLuciano Coelho { 34290921014SLuciano Coelho struct wl1251 *wl = hw->priv; 34390921014SLuciano Coelho unsigned long flags; 34490921014SLuciano Coelho 34590921014SLuciano Coelho skb_queue_tail(&wl->tx_queue, skb); 34690921014SLuciano Coelho 34790921014SLuciano Coelho /* 34890921014SLuciano Coelho * The chip specific setup must run before the first TX packet - 34990921014SLuciano Coelho * before that, the tx_work will not be initialized! 35090921014SLuciano Coelho */ 35190921014SLuciano Coelho 35290921014SLuciano Coelho ieee80211_queue_work(wl->hw, &wl->tx_work); 35390921014SLuciano Coelho 35490921014SLuciano Coelho /* 35590921014SLuciano Coelho * The workqueue is slow to process the tx_queue and we need stop 35690921014SLuciano Coelho * the queue here, otherwise the queue will get too long. 35790921014SLuciano Coelho */ 35890921014SLuciano Coelho if (skb_queue_len(&wl->tx_queue) >= WL1251_TX_QUEUE_HIGH_WATERMARK) { 35990921014SLuciano Coelho wl1251_debug(DEBUG_TX, "op_tx: tx_queue full, stop queues"); 36090921014SLuciano Coelho 36190921014SLuciano Coelho spin_lock_irqsave(&wl->wl_lock, flags); 36290921014SLuciano Coelho ieee80211_stop_queues(wl->hw); 36390921014SLuciano Coelho wl->tx_queue_stopped = true; 36490921014SLuciano Coelho spin_unlock_irqrestore(&wl->wl_lock, flags); 36590921014SLuciano Coelho } 36690921014SLuciano Coelho } 36790921014SLuciano Coelho 36890921014SLuciano Coelho static int wl1251_op_start(struct ieee80211_hw *hw) 36990921014SLuciano Coelho { 37090921014SLuciano Coelho struct wl1251 *wl = hw->priv; 37190921014SLuciano Coelho struct wiphy *wiphy = hw->wiphy; 37290921014SLuciano Coelho int ret = 0; 37390921014SLuciano Coelho 37490921014SLuciano Coelho wl1251_debug(DEBUG_MAC80211, "mac80211 start"); 37590921014SLuciano Coelho 37690921014SLuciano Coelho mutex_lock(&wl->mutex); 37790921014SLuciano Coelho 37890921014SLuciano Coelho if (wl->state != WL1251_STATE_OFF) { 37990921014SLuciano Coelho wl1251_error("cannot start because not in off state: %d", 38090921014SLuciano Coelho wl->state); 38190921014SLuciano Coelho ret = -EBUSY; 38290921014SLuciano Coelho goto out; 38390921014SLuciano Coelho } 38490921014SLuciano Coelho 38590921014SLuciano Coelho ret = wl1251_chip_wakeup(wl); 38690921014SLuciano Coelho if (ret < 0) 38790921014SLuciano Coelho goto out; 38890921014SLuciano Coelho 38990921014SLuciano Coelho ret = wl1251_boot(wl); 39090921014SLuciano Coelho if (ret < 0) 39190921014SLuciano Coelho goto out; 39290921014SLuciano Coelho 39390921014SLuciano Coelho ret = wl1251_hw_init(wl); 39490921014SLuciano Coelho if (ret < 0) 39590921014SLuciano Coelho goto out; 39690921014SLuciano Coelho 39790921014SLuciano Coelho ret = wl1251_acx_station_id(wl); 39890921014SLuciano Coelho if (ret < 0) 39990921014SLuciano Coelho goto out; 40090921014SLuciano Coelho 40190921014SLuciano Coelho wl->state = WL1251_STATE_ON; 40290921014SLuciano Coelho 40390921014SLuciano Coelho wl1251_info("firmware booted (%s)", wl->fw_ver); 40490921014SLuciano Coelho 40590921014SLuciano Coelho /* update hw/fw version info in wiphy struct */ 40690921014SLuciano Coelho wiphy->hw_version = wl->chip_id; 40790921014SLuciano Coelho strncpy(wiphy->fw_version, wl->fw_ver, sizeof(wiphy->fw_version)); 40890921014SLuciano Coelho 40990921014SLuciano Coelho out: 41090921014SLuciano Coelho if (ret < 0) 41190921014SLuciano Coelho wl1251_power_off(wl); 41290921014SLuciano Coelho 41390921014SLuciano Coelho mutex_unlock(&wl->mutex); 41490921014SLuciano Coelho 41590921014SLuciano Coelho return ret; 41690921014SLuciano Coelho } 41790921014SLuciano Coelho 41890921014SLuciano Coelho static void wl1251_op_stop(struct ieee80211_hw *hw) 41990921014SLuciano Coelho { 42090921014SLuciano Coelho struct wl1251 *wl = hw->priv; 42190921014SLuciano Coelho 42290921014SLuciano Coelho wl1251_info("down"); 42390921014SLuciano Coelho 42490921014SLuciano Coelho wl1251_debug(DEBUG_MAC80211, "mac80211 stop"); 42590921014SLuciano Coelho 42690921014SLuciano Coelho mutex_lock(&wl->mutex); 42790921014SLuciano Coelho 42890921014SLuciano Coelho WARN_ON(wl->state != WL1251_STATE_ON); 42990921014SLuciano Coelho 43090921014SLuciano Coelho if (wl->scanning) { 4317947d3e0SAvraham Stern struct cfg80211_scan_info info = { 4327947d3e0SAvraham Stern .aborted = true, 4337947d3e0SAvraham Stern }; 4347947d3e0SAvraham Stern 4357947d3e0SAvraham Stern ieee80211_scan_completed(wl->hw, &info); 43690921014SLuciano Coelho wl->scanning = false; 43790921014SLuciano Coelho } 43890921014SLuciano Coelho 43990921014SLuciano Coelho wl->state = WL1251_STATE_OFF; 44090921014SLuciano Coelho 44190921014SLuciano Coelho wl1251_disable_interrupts(wl); 44290921014SLuciano Coelho 44390921014SLuciano Coelho mutex_unlock(&wl->mutex); 44490921014SLuciano Coelho 44590921014SLuciano Coelho cancel_work_sync(&wl->irq_work); 44690921014SLuciano Coelho cancel_work_sync(&wl->tx_work); 4470d6c4a2eSDavid S. Miller cancel_delayed_work_sync(&wl->elp_work); 44890921014SLuciano Coelho 44990921014SLuciano Coelho mutex_lock(&wl->mutex); 45090921014SLuciano Coelho 45190921014SLuciano Coelho /* let's notify MAC80211 about the remaining pending TX frames */ 45290921014SLuciano Coelho wl1251_tx_flush(wl); 45390921014SLuciano Coelho wl1251_power_off(wl); 45490921014SLuciano Coelho 45593803b33SJoe Perches eth_zero_addr(wl->bssid); 45690921014SLuciano Coelho wl->listen_int = 1; 45790921014SLuciano Coelho wl->bss_type = MAX_BSS_TYPE; 45890921014SLuciano Coelho 45990921014SLuciano Coelho wl->data_in_count = 0; 46090921014SLuciano Coelho wl->rx_counter = 0; 46190921014SLuciano Coelho wl->rx_handled = 0; 46290921014SLuciano Coelho wl->rx_current_buffer = 0; 46390921014SLuciano Coelho wl->rx_last_id = 0; 46490921014SLuciano Coelho wl->next_tx_complete = 0; 46590921014SLuciano Coelho wl->elp = false; 46690921014SLuciano Coelho wl->station_mode = STATION_ACTIVE_MODE; 467f7ad1eedSDavid Gnedt wl->psm_entry_retry = 0; 46890921014SLuciano Coelho wl->tx_queue_stopped = false; 46990921014SLuciano Coelho wl->power_level = WL1251_DEFAULT_POWER_LEVEL; 47090921014SLuciano Coelho wl->rssi_thold = 0; 47190921014SLuciano Coelho wl->channel = WL1251_DEFAULT_CHANNEL; 4724d09b537SDavid Gnedt wl->monitor_present = false; 473c8909e5aSDavid Gnedt wl->joined = false; 47490921014SLuciano Coelho 47590921014SLuciano Coelho wl1251_debugfs_reset(wl); 47690921014SLuciano Coelho 47790921014SLuciano Coelho mutex_unlock(&wl->mutex); 47890921014SLuciano Coelho } 47990921014SLuciano Coelho 48090921014SLuciano Coelho static int wl1251_op_add_interface(struct ieee80211_hw *hw, 48190921014SLuciano Coelho struct ieee80211_vif *vif) 48290921014SLuciano Coelho { 48390921014SLuciano Coelho struct wl1251 *wl = hw->priv; 48490921014SLuciano Coelho int ret = 0; 48590921014SLuciano Coelho 48690921014SLuciano Coelho vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER | 487848955ccSJohannes Berg IEEE80211_VIF_SUPPORTS_UAPSD | 48890921014SLuciano Coelho IEEE80211_VIF_SUPPORTS_CQM_RSSI; 48990921014SLuciano Coelho 49090921014SLuciano Coelho wl1251_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM", 49190921014SLuciano Coelho vif->type, vif->addr); 49290921014SLuciano Coelho 49390921014SLuciano Coelho mutex_lock(&wl->mutex); 49490921014SLuciano Coelho if (wl->vif) { 49590921014SLuciano Coelho ret = -EBUSY; 49690921014SLuciano Coelho goto out; 49790921014SLuciano Coelho } 49890921014SLuciano Coelho 49990921014SLuciano Coelho wl->vif = vif; 50090921014SLuciano Coelho 50190921014SLuciano Coelho switch (vif->type) { 50290921014SLuciano Coelho case NL80211_IFTYPE_STATION: 50390921014SLuciano Coelho wl->bss_type = BSS_TYPE_STA_BSS; 50490921014SLuciano Coelho break; 50590921014SLuciano Coelho case NL80211_IFTYPE_ADHOC: 50690921014SLuciano Coelho wl->bss_type = BSS_TYPE_IBSS; 50790921014SLuciano Coelho break; 50890921014SLuciano Coelho default: 50990921014SLuciano Coelho ret = -EOPNOTSUPP; 51090921014SLuciano Coelho goto out; 51190921014SLuciano Coelho } 51290921014SLuciano Coelho 513692e5167Sdingtianhong if (!ether_addr_equal_unaligned(wl->mac_addr, vif->addr)) { 51490921014SLuciano Coelho memcpy(wl->mac_addr, vif->addr, ETH_ALEN); 51590921014SLuciano Coelho SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr); 51690921014SLuciano Coelho ret = wl1251_acx_station_id(wl); 51790921014SLuciano Coelho if (ret < 0) 51890921014SLuciano Coelho goto out; 51990921014SLuciano Coelho } 52090921014SLuciano Coelho 52190921014SLuciano Coelho out: 52290921014SLuciano Coelho mutex_unlock(&wl->mutex); 52390921014SLuciano Coelho return ret; 52490921014SLuciano Coelho } 52590921014SLuciano Coelho 52690921014SLuciano Coelho static void wl1251_op_remove_interface(struct ieee80211_hw *hw, 52790921014SLuciano Coelho struct ieee80211_vif *vif) 52890921014SLuciano Coelho { 52990921014SLuciano Coelho struct wl1251 *wl = hw->priv; 53090921014SLuciano Coelho 53190921014SLuciano Coelho mutex_lock(&wl->mutex); 53290921014SLuciano Coelho wl1251_debug(DEBUG_MAC80211, "mac80211 remove interface"); 53390921014SLuciano Coelho wl->vif = NULL; 53493803b33SJoe Perches eth_zero_addr(wl->bssid); 53590921014SLuciano Coelho mutex_unlock(&wl->mutex); 53690921014SLuciano Coelho } 53790921014SLuciano Coelho 538a5640612SGrazvydas Ignotas static int wl1251_build_null_data(struct wl1251 *wl) 539a5640612SGrazvydas Ignotas { 540a5640612SGrazvydas Ignotas struct sk_buff *skb = NULL; 541a5640612SGrazvydas Ignotas int size; 542a5640612SGrazvydas Ignotas void *ptr; 543a5640612SGrazvydas Ignotas int ret = -ENOMEM; 544a5640612SGrazvydas Ignotas 545a5640612SGrazvydas Ignotas if (wl->bss_type == BSS_TYPE_IBSS) { 546a5640612SGrazvydas Ignotas size = sizeof(struct wl12xx_null_data_template); 547a5640612SGrazvydas Ignotas ptr = NULL; 548a5640612SGrazvydas Ignotas } else { 5497b6ddeafSJohannes Berg skb = ieee80211_nullfunc_get(wl->hw, wl->vif, false); 550a5640612SGrazvydas Ignotas if (!skb) 551a5640612SGrazvydas Ignotas goto out; 552a5640612SGrazvydas Ignotas size = skb->len; 553a5640612SGrazvydas Ignotas ptr = skb->data; 554a5640612SGrazvydas Ignotas } 555a5640612SGrazvydas Ignotas 556a5640612SGrazvydas Ignotas ret = wl1251_cmd_template_set(wl, CMD_NULL_DATA, ptr, size); 557a5640612SGrazvydas Ignotas 558a5640612SGrazvydas Ignotas out: 559a5640612SGrazvydas Ignotas dev_kfree_skb(skb); 560a5640612SGrazvydas Ignotas if (ret) 561db8655c6SColin Ian King wl1251_warning("cmd build null data failed: %d", ret); 562a5640612SGrazvydas Ignotas 563a5640612SGrazvydas Ignotas return ret; 564a5640612SGrazvydas Ignotas } 565a5640612SGrazvydas Ignotas 56690921014SLuciano Coelho static int wl1251_build_qos_null_data(struct wl1251 *wl) 56790921014SLuciano Coelho { 56890921014SLuciano Coelho struct ieee80211_qos_hdr template; 56990921014SLuciano Coelho 57090921014SLuciano Coelho memset(&template, 0, sizeof(template)); 57190921014SLuciano Coelho 57290921014SLuciano Coelho memcpy(template.addr1, wl->bssid, ETH_ALEN); 57390921014SLuciano Coelho memcpy(template.addr2, wl->mac_addr, ETH_ALEN); 57490921014SLuciano Coelho memcpy(template.addr3, wl->bssid, ETH_ALEN); 57590921014SLuciano Coelho 57690921014SLuciano Coelho template.frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA | 57790921014SLuciano Coelho IEEE80211_STYPE_QOS_NULLFUNC | 57890921014SLuciano Coelho IEEE80211_FCTL_TODS); 57990921014SLuciano Coelho 58090921014SLuciano Coelho /* FIXME: not sure what priority to use here */ 58190921014SLuciano Coelho template.qos_ctrl = cpu_to_le16(0); 58290921014SLuciano Coelho 58390921014SLuciano Coelho return wl1251_cmd_template_set(wl, CMD_QOS_NULL_DATA, &template, 58490921014SLuciano Coelho sizeof(template)); 58590921014SLuciano Coelho } 58690921014SLuciano Coelho 587dd4a560fSDavid Gnedt static bool wl1251_can_do_pm(struct ieee80211_conf *conf, struct wl1251 *wl) 588dd4a560fSDavid Gnedt { 589dd4a560fSDavid Gnedt return (conf->flags & IEEE80211_CONF_PS) && !wl->monitor_present; 590dd4a560fSDavid Gnedt } 591dd4a560fSDavid Gnedt 59290921014SLuciano Coelho static int wl1251_op_config(struct ieee80211_hw *hw, u32 changed) 59390921014SLuciano Coelho { 59490921014SLuciano Coelho struct wl1251 *wl = hw->priv; 59590921014SLuciano Coelho struct ieee80211_conf *conf = &hw->conf; 59690921014SLuciano Coelho int channel, ret = 0; 59790921014SLuciano Coelho 598675a0b04SKarl Beldan channel = ieee80211_frequency_to_channel( 599675a0b04SKarl Beldan conf->chandef.chan->center_freq); 60090921014SLuciano Coelho 6014d09b537SDavid Gnedt wl1251_debug(DEBUG_MAC80211, 6024d09b537SDavid Gnedt "mac80211 config ch %d monitor %s psm %s power %d", 60390921014SLuciano Coelho channel, 6044d09b537SDavid Gnedt conf->flags & IEEE80211_CONF_MONITOR ? "on" : "off", 60590921014SLuciano Coelho conf->flags & IEEE80211_CONF_PS ? "on" : "off", 60690921014SLuciano Coelho conf->power_level); 60790921014SLuciano Coelho 60890921014SLuciano Coelho mutex_lock(&wl->mutex); 60990921014SLuciano Coelho 61090921014SLuciano Coelho ret = wl1251_ps_elp_wakeup(wl); 61190921014SLuciano Coelho if (ret < 0) 61290921014SLuciano Coelho goto out; 61390921014SLuciano Coelho 6144d09b537SDavid Gnedt if (changed & IEEE80211_CONF_CHANGE_MONITOR) { 6154d09b537SDavid Gnedt u32 mode; 61690921014SLuciano Coelho 6174d09b537SDavid Gnedt if (conf->flags & IEEE80211_CONF_MONITOR) { 6184d09b537SDavid Gnedt wl->monitor_present = true; 6194d09b537SDavid Gnedt mode = DF_SNIFF_MODE_ENABLE | DF_ENCRYPTION_DISABLE; 6204d09b537SDavid Gnedt } else { 6214d09b537SDavid Gnedt wl->monitor_present = false; 6224d09b537SDavid Gnedt mode = 0; 6234d09b537SDavid Gnedt } 6244d09b537SDavid Gnedt 6254d09b537SDavid Gnedt ret = wl1251_acx_feature_cfg(wl, mode); 62690921014SLuciano Coelho if (ret < 0) 62790921014SLuciano Coelho goto out_sleep; 62890921014SLuciano Coelho } 62990921014SLuciano Coelho 63090921014SLuciano Coelho if (channel != wl->channel) { 63190921014SLuciano Coelho wl->channel = channel; 63290921014SLuciano Coelho 633ed3213c9SDavid Gnedt /* 634ed3213c9SDavid Gnedt * Use ENABLE_RX command for channel switching when no 635ed3213c9SDavid Gnedt * interface is present (monitor mode only). 636ed3213c9SDavid Gnedt * This leaves the tx path disabled in firmware, whereas 637ed3213c9SDavid Gnedt * the usual JOIN command seems to transmit some frames 638ed3213c9SDavid Gnedt * at firmware level. 639ed3213c9SDavid Gnedt */ 640ed3213c9SDavid Gnedt if (wl->vif == NULL) { 641c8909e5aSDavid Gnedt wl->joined = false; 642ed3213c9SDavid Gnedt ret = wl1251_cmd_data_path_rx(wl, wl->channel, 1); 643ed3213c9SDavid Gnedt } else { 64490921014SLuciano Coelho ret = wl1251_join(wl, wl->bss_type, wl->channel, 64590921014SLuciano Coelho wl->beacon_int, wl->dtim_period); 646ed3213c9SDavid Gnedt } 64790921014SLuciano Coelho if (ret < 0) 64890921014SLuciano Coelho goto out_sleep; 64990921014SLuciano Coelho } 65090921014SLuciano Coelho 651dd4a560fSDavid Gnedt if (wl1251_can_do_pm(conf, wl) && !wl->psm_requested) { 65290921014SLuciano Coelho wl1251_debug(DEBUG_PSM, "psm enabled"); 65390921014SLuciano Coelho 65490921014SLuciano Coelho wl->psm_requested = true; 65590921014SLuciano Coelho 65690921014SLuciano Coelho wl->dtim_period = conf->ps_dtim_period; 65790921014SLuciano Coelho 65890921014SLuciano Coelho ret = wl1251_acx_wr_tbtt_and_dtim(wl, wl->beacon_int, 65990921014SLuciano Coelho wl->dtim_period); 66090921014SLuciano Coelho 66190921014SLuciano Coelho /* 66290921014SLuciano Coelho * mac80211 enables PSM only if we're already associated. 66390921014SLuciano Coelho */ 66490921014SLuciano Coelho ret = wl1251_ps_set_mode(wl, STATION_POWER_SAVE_MODE); 66590921014SLuciano Coelho if (ret < 0) 66690921014SLuciano Coelho goto out_sleep; 667dd4a560fSDavid Gnedt } else if (!wl1251_can_do_pm(conf, wl) && wl->psm_requested) { 66890921014SLuciano Coelho wl1251_debug(DEBUG_PSM, "psm disabled"); 66990921014SLuciano Coelho 67090921014SLuciano Coelho wl->psm_requested = false; 67190921014SLuciano Coelho 67290921014SLuciano Coelho if (wl->station_mode != STATION_ACTIVE_MODE) { 67390921014SLuciano Coelho ret = wl1251_ps_set_mode(wl, STATION_ACTIVE_MODE); 67490921014SLuciano Coelho if (ret < 0) 67590921014SLuciano Coelho goto out_sleep; 67690921014SLuciano Coelho } 67790921014SLuciano Coelho } 67890921014SLuciano Coelho 679f1e3e051SJohannes Berg if (changed & IEEE80211_CONF_CHANGE_IDLE && !wl->scanning) { 68090921014SLuciano Coelho if (conf->flags & IEEE80211_CONF_IDLE) { 68190921014SLuciano Coelho ret = wl1251_ps_set_mode(wl, STATION_IDLE); 68290921014SLuciano Coelho if (ret < 0) 68390921014SLuciano Coelho goto out_sleep; 68490921014SLuciano Coelho } else { 68590921014SLuciano Coelho ret = wl1251_ps_set_mode(wl, STATION_ACTIVE_MODE); 68690921014SLuciano Coelho if (ret < 0) 68790921014SLuciano Coelho goto out_sleep; 68890921014SLuciano Coelho ret = wl1251_join(wl, wl->bss_type, wl->channel, 68990921014SLuciano Coelho wl->beacon_int, wl->dtim_period); 69090921014SLuciano Coelho if (ret < 0) 69190921014SLuciano Coelho goto out_sleep; 69290921014SLuciano Coelho } 69390921014SLuciano Coelho } 69490921014SLuciano Coelho 69590921014SLuciano Coelho if (conf->power_level != wl->power_level) { 69690921014SLuciano Coelho ret = wl1251_acx_tx_power(wl, conf->power_level); 69790921014SLuciano Coelho if (ret < 0) 69890921014SLuciano Coelho goto out_sleep; 69990921014SLuciano Coelho 70090921014SLuciano Coelho wl->power_level = conf->power_level; 70190921014SLuciano Coelho } 70290921014SLuciano Coelho 70390921014SLuciano Coelho out_sleep: 70490921014SLuciano Coelho wl1251_ps_elp_sleep(wl); 70590921014SLuciano Coelho 70690921014SLuciano Coelho out: 70790921014SLuciano Coelho mutex_unlock(&wl->mutex); 70890921014SLuciano Coelho 70990921014SLuciano Coelho return ret; 71090921014SLuciano Coelho } 71190921014SLuciano Coelho 7129ed74ba0SDavid Gnedt struct wl1251_filter_params { 7139ed74ba0SDavid Gnedt bool enabled; 7149ed74ba0SDavid Gnedt int mc_list_length; 7159ed74ba0SDavid Gnedt u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN]; 7169ed74ba0SDavid Gnedt }; 7179ed74ba0SDavid Gnedt 7189ed74ba0SDavid Gnedt static u64 wl1251_op_prepare_multicast(struct ieee80211_hw *hw, 7199ed74ba0SDavid Gnedt struct netdev_hw_addr_list *mc_list) 7209ed74ba0SDavid Gnedt { 7219ed74ba0SDavid Gnedt struct wl1251_filter_params *fp; 7229ed74ba0SDavid Gnedt struct netdev_hw_addr *ha; 7239ed74ba0SDavid Gnedt struct wl1251 *wl = hw->priv; 7249ed74ba0SDavid Gnedt 7259ed74ba0SDavid Gnedt if (unlikely(wl->state == WL1251_STATE_OFF)) 7269ed74ba0SDavid Gnedt return 0; 7279ed74ba0SDavid Gnedt 7289ed74ba0SDavid Gnedt fp = kzalloc(sizeof(*fp), GFP_ATOMIC); 7299ed74ba0SDavid Gnedt if (!fp) { 7309ed74ba0SDavid Gnedt wl1251_error("Out of memory setting filters."); 7319ed74ba0SDavid Gnedt return 0; 7329ed74ba0SDavid Gnedt } 7339ed74ba0SDavid Gnedt 7349ed74ba0SDavid Gnedt /* update multicast filtering parameters */ 7359ed74ba0SDavid Gnedt fp->mc_list_length = 0; 7369ed74ba0SDavid Gnedt if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) { 7379ed74ba0SDavid Gnedt fp->enabled = false; 7389ed74ba0SDavid Gnedt } else { 7399ed74ba0SDavid Gnedt fp->enabled = true; 7409ed74ba0SDavid Gnedt netdev_hw_addr_list_for_each(ha, mc_list) { 7419ed74ba0SDavid Gnedt memcpy(fp->mc_list[fp->mc_list_length], 7429ed74ba0SDavid Gnedt ha->addr, ETH_ALEN); 7439ed74ba0SDavid Gnedt fp->mc_list_length++; 7449ed74ba0SDavid Gnedt } 7459ed74ba0SDavid Gnedt } 7469ed74ba0SDavid Gnedt 7479ed74ba0SDavid Gnedt return (u64)(unsigned long)fp; 7489ed74ba0SDavid Gnedt } 7499ed74ba0SDavid Gnedt 750df140465SJohannes Berg #define WL1251_SUPPORTED_FILTERS (FIF_ALLMULTI | \ 75190921014SLuciano Coelho FIF_FCSFAIL | \ 75290921014SLuciano Coelho FIF_BCN_PRBRESP_PROMISC | \ 75390921014SLuciano Coelho FIF_CONTROL | \ 75484b60c14SGrazvydas Ignotas FIF_OTHER_BSS | \ 75584b60c14SGrazvydas Ignotas FIF_PROBE_REQ) 75690921014SLuciano Coelho 75790921014SLuciano Coelho static void wl1251_op_configure_filter(struct ieee80211_hw *hw, 75890921014SLuciano Coelho unsigned int changed, 75990921014SLuciano Coelho unsigned int *total, u64 multicast) 76090921014SLuciano Coelho { 7619ed74ba0SDavid Gnedt struct wl1251_filter_params *fp = (void *)(unsigned long)multicast; 76290921014SLuciano Coelho struct wl1251 *wl = hw->priv; 76384b60c14SGrazvydas Ignotas int ret; 76490921014SLuciano Coelho 76590921014SLuciano Coelho wl1251_debug(DEBUG_MAC80211, "mac80211 configure filter"); 76690921014SLuciano Coelho 76790921014SLuciano Coelho *total &= WL1251_SUPPORTED_FILTERS; 76890921014SLuciano Coelho changed &= WL1251_SUPPORTED_FILTERS; 76990921014SLuciano Coelho 7709ed74ba0SDavid Gnedt if (changed == 0) { 77190921014SLuciano Coelho /* no filters which we support changed */ 7729ed74ba0SDavid Gnedt kfree(fp); 77390921014SLuciano Coelho return; 7749ed74ba0SDavid Gnedt } 77590921014SLuciano Coelho 77684b60c14SGrazvydas Ignotas mutex_lock(&wl->mutex); 77790921014SLuciano Coelho 77890921014SLuciano Coelho wl->rx_config = WL1251_DEFAULT_RX_CONFIG; 77990921014SLuciano Coelho wl->rx_filter = WL1251_DEFAULT_RX_FILTER; 78090921014SLuciano Coelho 78190921014SLuciano Coelho if (*total & FIF_ALLMULTI) 78290921014SLuciano Coelho /* 78390921014SLuciano Coelho * CFG_MC_FILTER_EN in rx_config needs to be 0 to receive 78490921014SLuciano Coelho * all multicast frames 78590921014SLuciano Coelho */ 78690921014SLuciano Coelho wl->rx_config &= ~CFG_MC_FILTER_EN; 78790921014SLuciano Coelho if (*total & FIF_FCSFAIL) 78890921014SLuciano Coelho wl->rx_filter |= CFG_RX_FCS_ERROR; 78990921014SLuciano Coelho if (*total & FIF_BCN_PRBRESP_PROMISC) { 79090921014SLuciano Coelho wl->rx_config &= ~CFG_BSSID_FILTER_EN; 79190921014SLuciano Coelho wl->rx_config &= ~CFG_SSID_FILTER_EN; 79290921014SLuciano Coelho } 79390921014SLuciano Coelho if (*total & FIF_CONTROL) 79490921014SLuciano Coelho wl->rx_filter |= CFG_RX_CTL_EN; 79584b60c14SGrazvydas Ignotas if (*total & FIF_OTHER_BSS || is_zero_ether_addr(wl->bssid)) 79684b60c14SGrazvydas Ignotas wl->rx_config &= ~CFG_BSSID_FILTER_EN; 79784b60c14SGrazvydas Ignotas if (*total & FIF_PROBE_REQ) 79884b60c14SGrazvydas Ignotas wl->rx_filter |= CFG_RX_PREQ_EN; 79984b60c14SGrazvydas Ignotas 80084b60c14SGrazvydas Ignotas if (wl->state == WL1251_STATE_OFF) 80184b60c14SGrazvydas Ignotas goto out; 80284b60c14SGrazvydas Ignotas 80384b60c14SGrazvydas Ignotas ret = wl1251_ps_elp_wakeup(wl); 80484b60c14SGrazvydas Ignotas if (ret < 0) 80584b60c14SGrazvydas Ignotas goto out; 80684b60c14SGrazvydas Ignotas 807df140465SJohannes Berg if (*total & FIF_ALLMULTI) 8089ed74ba0SDavid Gnedt ret = wl1251_acx_group_address_tbl(wl, false, NULL, 0); 8099ed74ba0SDavid Gnedt else if (fp) 8109ed74ba0SDavid Gnedt ret = wl1251_acx_group_address_tbl(wl, fp->enabled, 8119ed74ba0SDavid Gnedt fp->mc_list, 8129ed74ba0SDavid Gnedt fp->mc_list_length); 8139ed74ba0SDavid Gnedt if (ret < 0) 8149ed74ba0SDavid Gnedt goto out; 8159ed74ba0SDavid Gnedt 81684b60c14SGrazvydas Ignotas /* send filters to firmware */ 81784b60c14SGrazvydas Ignotas wl1251_acx_rx_config(wl, wl->rx_config, wl->rx_filter); 81884b60c14SGrazvydas Ignotas 81984b60c14SGrazvydas Ignotas wl1251_ps_elp_sleep(wl); 82084b60c14SGrazvydas Ignotas 82184b60c14SGrazvydas Ignotas out: 82284b60c14SGrazvydas Ignotas mutex_unlock(&wl->mutex); 8239ed74ba0SDavid Gnedt kfree(fp); 82490921014SLuciano Coelho } 82590921014SLuciano Coelho 82690921014SLuciano Coelho /* HW encryption */ 82790921014SLuciano Coelho static int wl1251_set_key_type(struct wl1251 *wl, 82890921014SLuciano Coelho struct wl1251_cmd_set_keys *key, 82990921014SLuciano Coelho enum set_key_cmd cmd, 83090921014SLuciano Coelho struct ieee80211_key_conf *mac80211_key, 83190921014SLuciano Coelho const u8 *addr) 83290921014SLuciano Coelho { 83390921014SLuciano Coelho switch (mac80211_key->cipher) { 83490921014SLuciano Coelho case WLAN_CIPHER_SUITE_WEP40: 83590921014SLuciano Coelho case WLAN_CIPHER_SUITE_WEP104: 83690921014SLuciano Coelho if (is_broadcast_ether_addr(addr)) 83790921014SLuciano Coelho key->key_type = KEY_WEP_DEFAULT; 83890921014SLuciano Coelho else 83990921014SLuciano Coelho key->key_type = KEY_WEP_ADDR; 84090921014SLuciano Coelho 84190921014SLuciano Coelho mac80211_key->hw_key_idx = mac80211_key->keyidx; 84290921014SLuciano Coelho break; 84390921014SLuciano Coelho case WLAN_CIPHER_SUITE_TKIP: 84490921014SLuciano Coelho if (is_broadcast_ether_addr(addr)) 84590921014SLuciano Coelho key->key_type = KEY_TKIP_MIC_GROUP; 84690921014SLuciano Coelho else 84790921014SLuciano Coelho key->key_type = KEY_TKIP_MIC_PAIRWISE; 84890921014SLuciano Coelho 84990921014SLuciano Coelho mac80211_key->hw_key_idx = mac80211_key->keyidx; 85090921014SLuciano Coelho break; 85190921014SLuciano Coelho case WLAN_CIPHER_SUITE_CCMP: 85290921014SLuciano Coelho if (is_broadcast_ether_addr(addr)) 85390921014SLuciano Coelho key->key_type = KEY_AES_GROUP; 85490921014SLuciano Coelho else 85590921014SLuciano Coelho key->key_type = KEY_AES_PAIRWISE; 85690921014SLuciano Coelho mac80211_key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV; 85790921014SLuciano Coelho break; 85890921014SLuciano Coelho default: 85990921014SLuciano Coelho wl1251_error("Unknown key cipher 0x%x", mac80211_key->cipher); 86090921014SLuciano Coelho return -EOPNOTSUPP; 86190921014SLuciano Coelho } 86290921014SLuciano Coelho 86390921014SLuciano Coelho return 0; 86490921014SLuciano Coelho } 86590921014SLuciano Coelho 86690921014SLuciano Coelho static int wl1251_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 86790921014SLuciano Coelho struct ieee80211_vif *vif, 86890921014SLuciano Coelho struct ieee80211_sta *sta, 86990921014SLuciano Coelho struct ieee80211_key_conf *key) 87090921014SLuciano Coelho { 87190921014SLuciano Coelho struct wl1251 *wl = hw->priv; 87290921014SLuciano Coelho struct wl1251_cmd_set_keys *wl_cmd; 87390921014SLuciano Coelho const u8 *addr; 87490921014SLuciano Coelho int ret; 87590921014SLuciano Coelho 87690921014SLuciano Coelho static const u8 bcast_addr[ETH_ALEN] = 87790921014SLuciano Coelho { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 87890921014SLuciano Coelho 87990921014SLuciano Coelho wl1251_debug(DEBUG_MAC80211, "mac80211 set key"); 88090921014SLuciano Coelho 88190921014SLuciano Coelho wl_cmd = kzalloc(sizeof(*wl_cmd), GFP_KERNEL); 88290921014SLuciano Coelho if (!wl_cmd) { 88390921014SLuciano Coelho ret = -ENOMEM; 88490921014SLuciano Coelho goto out; 88590921014SLuciano Coelho } 88690921014SLuciano Coelho 88790921014SLuciano Coelho addr = sta ? sta->addr : bcast_addr; 88890921014SLuciano Coelho 88990921014SLuciano Coelho wl1251_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd); 89090921014SLuciano Coelho wl1251_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN); 89190921014SLuciano Coelho wl1251_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x", 89290921014SLuciano Coelho key->cipher, key->keyidx, key->keylen, key->flags); 89390921014SLuciano Coelho wl1251_dump(DEBUG_CRYPT, "KEY: ", key->key, key->keylen); 89490921014SLuciano Coelho 89590921014SLuciano Coelho if (is_zero_ether_addr(addr)) { 89690921014SLuciano Coelho /* We dont support TX only encryption */ 89790921014SLuciano Coelho ret = -EOPNOTSUPP; 89890921014SLuciano Coelho goto out; 89990921014SLuciano Coelho } 90090921014SLuciano Coelho 90190921014SLuciano Coelho mutex_lock(&wl->mutex); 90290921014SLuciano Coelho 90390921014SLuciano Coelho switch (cmd) { 90490921014SLuciano Coelho case SET_KEY: 9054d09b537SDavid Gnedt if (wl->monitor_present) { 9064d09b537SDavid Gnedt ret = -EOPNOTSUPP; 9074d09b537SDavid Gnedt goto out_unlock; 9084d09b537SDavid Gnedt } 90990921014SLuciano Coelho wl_cmd->key_action = KEY_ADD_OR_REPLACE; 91090921014SLuciano Coelho break; 91190921014SLuciano Coelho case DISABLE_KEY: 91290921014SLuciano Coelho wl_cmd->key_action = KEY_REMOVE; 91390921014SLuciano Coelho break; 91490921014SLuciano Coelho default: 91590921014SLuciano Coelho wl1251_error("Unsupported key cmd 0x%x", cmd); 91690921014SLuciano Coelho break; 91790921014SLuciano Coelho } 91890921014SLuciano Coelho 9194d09b537SDavid Gnedt ret = wl1251_ps_elp_wakeup(wl); 9204d09b537SDavid Gnedt if (ret < 0) 9214d09b537SDavid Gnedt goto out_unlock; 9224d09b537SDavid Gnedt 92390921014SLuciano Coelho ret = wl1251_set_key_type(wl, wl_cmd, cmd, key, addr); 92490921014SLuciano Coelho if (ret < 0) { 92590921014SLuciano Coelho wl1251_error("Set KEY type failed"); 92690921014SLuciano Coelho goto out_sleep; 92790921014SLuciano Coelho } 92890921014SLuciano Coelho 92990921014SLuciano Coelho if (wl_cmd->key_type != KEY_WEP_DEFAULT) 93090921014SLuciano Coelho memcpy(wl_cmd->addr, addr, ETH_ALEN); 93190921014SLuciano Coelho 93290921014SLuciano Coelho if ((wl_cmd->key_type == KEY_TKIP_MIC_GROUP) || 93390921014SLuciano Coelho (wl_cmd->key_type == KEY_TKIP_MIC_PAIRWISE)) { 93490921014SLuciano Coelho /* 93590921014SLuciano Coelho * We get the key in the following form: 93690921014SLuciano Coelho * TKIP (16 bytes) - TX MIC (8 bytes) - RX MIC (8 bytes) 93790921014SLuciano Coelho * but the target is expecting: 93890921014SLuciano Coelho * TKIP - RX MIC - TX MIC 93990921014SLuciano Coelho */ 94090921014SLuciano Coelho memcpy(wl_cmd->key, key->key, 16); 94190921014SLuciano Coelho memcpy(wl_cmd->key + 16, key->key + 24, 8); 94290921014SLuciano Coelho memcpy(wl_cmd->key + 24, key->key + 16, 8); 94390921014SLuciano Coelho 94490921014SLuciano Coelho } else { 94590921014SLuciano Coelho memcpy(wl_cmd->key, key->key, key->keylen); 94690921014SLuciano Coelho } 94790921014SLuciano Coelho wl_cmd->key_size = key->keylen; 94890921014SLuciano Coelho 94990921014SLuciano Coelho wl_cmd->id = key->keyidx; 95090921014SLuciano Coelho wl_cmd->ssid_profile = 0; 95190921014SLuciano Coelho 95290921014SLuciano Coelho wl1251_dump(DEBUG_CRYPT, "TARGET KEY: ", wl_cmd, sizeof(*wl_cmd)); 95390921014SLuciano Coelho 95490921014SLuciano Coelho ret = wl1251_cmd_send(wl, CMD_SET_KEYS, wl_cmd, sizeof(*wl_cmd)); 95590921014SLuciano Coelho if (ret < 0) { 95690921014SLuciano Coelho wl1251_warning("could not set keys"); 95790921014SLuciano Coelho goto out_sleep; 95890921014SLuciano Coelho } 95990921014SLuciano Coelho 96090921014SLuciano Coelho out_sleep: 96190921014SLuciano Coelho wl1251_ps_elp_sleep(wl); 96290921014SLuciano Coelho 96390921014SLuciano Coelho out_unlock: 96490921014SLuciano Coelho mutex_unlock(&wl->mutex); 96590921014SLuciano Coelho 96690921014SLuciano Coelho out: 96790921014SLuciano Coelho kfree(wl_cmd); 96890921014SLuciano Coelho 96990921014SLuciano Coelho return ret; 97090921014SLuciano Coelho } 97190921014SLuciano Coelho 97290921014SLuciano Coelho static int wl1251_op_hw_scan(struct ieee80211_hw *hw, 97390921014SLuciano Coelho struct ieee80211_vif *vif, 974c56ef672SDavid Spinadel struct ieee80211_scan_request *hw_req) 97590921014SLuciano Coelho { 976c56ef672SDavid Spinadel struct cfg80211_scan_request *req = &hw_req->req; 97790921014SLuciano Coelho struct wl1251 *wl = hw->priv; 97890921014SLuciano Coelho struct sk_buff *skb; 97990921014SLuciano Coelho size_t ssid_len = 0; 98090921014SLuciano Coelho u8 *ssid = NULL; 98190921014SLuciano Coelho int ret; 98290921014SLuciano Coelho 98390921014SLuciano Coelho wl1251_debug(DEBUG_MAC80211, "mac80211 hw scan"); 98490921014SLuciano Coelho 98590921014SLuciano Coelho if (req->n_ssids) { 98690921014SLuciano Coelho ssid = req->ssids[0].ssid; 98790921014SLuciano Coelho ssid_len = req->ssids[0].ssid_len; 98890921014SLuciano Coelho } 98990921014SLuciano Coelho 99090921014SLuciano Coelho mutex_lock(&wl->mutex); 99190921014SLuciano Coelho 99290921014SLuciano Coelho if (wl->scanning) { 99390921014SLuciano Coelho wl1251_debug(DEBUG_SCAN, "scan already in progress"); 99490921014SLuciano Coelho ret = -EINVAL; 99590921014SLuciano Coelho goto out; 99690921014SLuciano Coelho } 99790921014SLuciano Coelho 99890921014SLuciano Coelho ret = wl1251_ps_elp_wakeup(wl); 99990921014SLuciano Coelho if (ret < 0) 100090921014SLuciano Coelho goto out; 100190921014SLuciano Coelho 1002f1e3e051SJohannes Berg if (hw->conf.flags & IEEE80211_CONF_IDLE) { 1003f1e3e051SJohannes Berg ret = wl1251_ps_set_mode(wl, STATION_ACTIVE_MODE); 1004f1e3e051SJohannes Berg if (ret < 0) 1005f1e3e051SJohannes Berg goto out_sleep; 1006f1e3e051SJohannes Berg ret = wl1251_join(wl, wl->bss_type, wl->channel, 1007f1e3e051SJohannes Berg wl->beacon_int, wl->dtim_period); 1008f1e3e051SJohannes Berg if (ret < 0) 1009f1e3e051SJohannes Berg goto out_sleep; 1010f1e3e051SJohannes Berg } 1011f1e3e051SJohannes Berg 1012a344d677SJohannes Berg skb = ieee80211_probereq_get(wl->hw, wl->vif->addr, ssid, ssid_len, 1013b9a9ada1SJohannes Berg req->ie_len); 101490921014SLuciano Coelho if (!skb) { 101590921014SLuciano Coelho ret = -ENOMEM; 1016f1e3e051SJohannes Berg goto out_idle; 101790921014SLuciano Coelho } 1018b9a9ada1SJohannes Berg if (req->ie_len) 101959ae1d12SJohannes Berg skb_put_data(skb, req->ie, req->ie_len); 102090921014SLuciano Coelho 102190921014SLuciano Coelho ret = wl1251_cmd_template_set(wl, CMD_PROBE_REQ, skb->data, 102290921014SLuciano Coelho skb->len); 102390921014SLuciano Coelho dev_kfree_skb(skb); 102490921014SLuciano Coelho if (ret < 0) 1025f1e3e051SJohannes Berg goto out_idle; 102690921014SLuciano Coelho 102790921014SLuciano Coelho ret = wl1251_cmd_trigger_scan_to(wl, 0); 102890921014SLuciano Coelho if (ret < 0) 1029f1e3e051SJohannes Berg goto out_idle; 103090921014SLuciano Coelho 103190921014SLuciano Coelho wl->scanning = true; 103290921014SLuciano Coelho 103390921014SLuciano Coelho ret = wl1251_cmd_scan(wl, ssid, ssid_len, req->channels, 103490921014SLuciano Coelho req->n_channels, WL1251_SCAN_NUM_PROBES); 103590921014SLuciano Coelho if (ret < 0) { 103664322e28SDavid Gnedt wl1251_debug(DEBUG_SCAN, "scan failed %d", ret); 103790921014SLuciano Coelho wl->scanning = false; 1038f1e3e051SJohannes Berg goto out_idle; 103990921014SLuciano Coelho } 1040f1e3e051SJohannes Berg goto out_sleep; 104190921014SLuciano Coelho 1042f1e3e051SJohannes Berg out_idle: 1043f1e3e051SJohannes Berg if (hw->conf.flags & IEEE80211_CONF_IDLE) 1044f1e3e051SJohannes Berg ret = wl1251_ps_set_mode(wl, STATION_IDLE); 104590921014SLuciano Coelho out_sleep: 104690921014SLuciano Coelho wl1251_ps_elp_sleep(wl); 104790921014SLuciano Coelho 104890921014SLuciano Coelho out: 104990921014SLuciano Coelho mutex_unlock(&wl->mutex); 105090921014SLuciano Coelho 105190921014SLuciano Coelho return ret; 105290921014SLuciano Coelho } 105390921014SLuciano Coelho 105490921014SLuciano Coelho static int wl1251_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 105590921014SLuciano Coelho { 105690921014SLuciano Coelho struct wl1251 *wl = hw->priv; 105790921014SLuciano Coelho int ret; 105890921014SLuciano Coelho 105990921014SLuciano Coelho mutex_lock(&wl->mutex); 106090921014SLuciano Coelho 106190921014SLuciano Coelho ret = wl1251_ps_elp_wakeup(wl); 106290921014SLuciano Coelho if (ret < 0) 106390921014SLuciano Coelho goto out; 106490921014SLuciano Coelho 106590921014SLuciano Coelho ret = wl1251_acx_rts_threshold(wl, (u16) value); 106690921014SLuciano Coelho if (ret < 0) 106790921014SLuciano Coelho wl1251_warning("wl1251_op_set_rts_threshold failed: %d", ret); 106890921014SLuciano Coelho 106990921014SLuciano Coelho wl1251_ps_elp_sleep(wl); 107090921014SLuciano Coelho 107190921014SLuciano Coelho out: 107290921014SLuciano Coelho mutex_unlock(&wl->mutex); 107390921014SLuciano Coelho 107490921014SLuciano Coelho return ret; 107590921014SLuciano Coelho } 107690921014SLuciano Coelho 107790921014SLuciano Coelho static void wl1251_op_bss_info_changed(struct ieee80211_hw *hw, 107890921014SLuciano Coelho struct ieee80211_vif *vif, 107990921014SLuciano Coelho struct ieee80211_bss_conf *bss_conf, 108090921014SLuciano Coelho u32 changed) 108190921014SLuciano Coelho { 108290921014SLuciano Coelho struct wl1251 *wl = hw->priv; 108390921014SLuciano Coelho struct sk_buff *beacon, *skb; 1084204cc5c4SDavid Gnedt bool enable; 108590921014SLuciano Coelho int ret; 108690921014SLuciano Coelho 108790921014SLuciano Coelho wl1251_debug(DEBUG_MAC80211, "mac80211 bss info changed"); 108890921014SLuciano Coelho 108990921014SLuciano Coelho mutex_lock(&wl->mutex); 109090921014SLuciano Coelho 109190921014SLuciano Coelho ret = wl1251_ps_elp_wakeup(wl); 109290921014SLuciano Coelho if (ret < 0) 109390921014SLuciano Coelho goto out; 109490921014SLuciano Coelho 109590921014SLuciano Coelho if (changed & BSS_CHANGED_CQM) { 109690921014SLuciano Coelho ret = wl1251_acx_low_rssi(wl, bss_conf->cqm_rssi_thold, 109790921014SLuciano Coelho WL1251_DEFAULT_LOW_RSSI_WEIGHT, 109890921014SLuciano Coelho WL1251_DEFAULT_LOW_RSSI_DEPTH, 109990921014SLuciano Coelho WL1251_ACX_LOW_RSSI_TYPE_EDGE); 110090921014SLuciano Coelho if (ret < 0) 110190921014SLuciano Coelho goto out; 110290921014SLuciano Coelho wl->rssi_thold = bss_conf->cqm_rssi_thold; 110390921014SLuciano Coelho } 110490921014SLuciano Coelho 1105a5640612SGrazvydas Ignotas if ((changed & BSS_CHANGED_BSSID) && 1106a5640612SGrazvydas Ignotas memcmp(wl->bssid, bss_conf->bssid, ETH_ALEN)) { 110790921014SLuciano Coelho memcpy(wl->bssid, bss_conf->bssid, ETH_ALEN); 110890921014SLuciano Coelho 1109a5640612SGrazvydas Ignotas if (!is_zero_ether_addr(wl->bssid)) { 1110a5640612SGrazvydas Ignotas ret = wl1251_build_null_data(wl); 111190921014SLuciano Coelho if (ret < 0) 111290921014SLuciano Coelho goto out_sleep; 111390921014SLuciano Coelho 111490921014SLuciano Coelho ret = wl1251_build_qos_null_data(wl); 111590921014SLuciano Coelho if (ret < 0) 1116a5640612SGrazvydas Ignotas goto out_sleep; 111790921014SLuciano Coelho 111890921014SLuciano Coelho ret = wl1251_join(wl, wl->bss_type, wl->channel, 111990921014SLuciano Coelho wl->beacon_int, wl->dtim_period); 112090921014SLuciano Coelho if (ret < 0) 112190921014SLuciano Coelho goto out_sleep; 112290921014SLuciano Coelho } 112390921014SLuciano Coelho } 112490921014SLuciano Coelho 112590921014SLuciano Coelho if (changed & BSS_CHANGED_ASSOC) { 112690921014SLuciano Coelho if (bss_conf->assoc) { 112790921014SLuciano Coelho wl->beacon_int = bss_conf->beacon_int; 112890921014SLuciano Coelho 112990921014SLuciano Coelho skb = ieee80211_pspoll_get(wl->hw, wl->vif); 113090921014SLuciano Coelho if (!skb) 113190921014SLuciano Coelho goto out_sleep; 113290921014SLuciano Coelho 113390921014SLuciano Coelho ret = wl1251_cmd_template_set(wl, CMD_PS_POLL, 113490921014SLuciano Coelho skb->data, 113590921014SLuciano Coelho skb->len); 113690921014SLuciano Coelho dev_kfree_skb(skb); 113790921014SLuciano Coelho if (ret < 0) 113890921014SLuciano Coelho goto out_sleep; 113990921014SLuciano Coelho 114090921014SLuciano Coelho ret = wl1251_acx_aid(wl, bss_conf->aid); 114190921014SLuciano Coelho if (ret < 0) 114290921014SLuciano Coelho goto out_sleep; 114390921014SLuciano Coelho } else { 114490921014SLuciano Coelho /* use defaults when not associated */ 114590921014SLuciano Coelho wl->beacon_int = WL1251_DEFAULT_BEACON_INT; 114690921014SLuciano Coelho wl->dtim_period = WL1251_DEFAULT_DTIM_PERIOD; 114790921014SLuciano Coelho } 114890921014SLuciano Coelho } 114990921014SLuciano Coelho if (changed & BSS_CHANGED_ERP_SLOT) { 115090921014SLuciano Coelho if (bss_conf->use_short_slot) 115190921014SLuciano Coelho ret = wl1251_acx_slot(wl, SLOT_TIME_SHORT); 115290921014SLuciano Coelho else 115390921014SLuciano Coelho ret = wl1251_acx_slot(wl, SLOT_TIME_LONG); 115490921014SLuciano Coelho if (ret < 0) { 115590921014SLuciano Coelho wl1251_warning("Set slot time failed %d", ret); 115690921014SLuciano Coelho goto out_sleep; 115790921014SLuciano Coelho } 115890921014SLuciano Coelho } 115990921014SLuciano Coelho 116090921014SLuciano Coelho if (changed & BSS_CHANGED_ERP_PREAMBLE) { 116190921014SLuciano Coelho if (bss_conf->use_short_preamble) 116290921014SLuciano Coelho wl1251_acx_set_preamble(wl, ACX_PREAMBLE_SHORT); 116390921014SLuciano Coelho else 116490921014SLuciano Coelho wl1251_acx_set_preamble(wl, ACX_PREAMBLE_LONG); 116590921014SLuciano Coelho } 116690921014SLuciano Coelho 116790921014SLuciano Coelho if (changed & BSS_CHANGED_ERP_CTS_PROT) { 116890921014SLuciano Coelho if (bss_conf->use_cts_prot) 116990921014SLuciano Coelho ret = wl1251_acx_cts_protect(wl, CTSPROTECT_ENABLE); 117090921014SLuciano Coelho else 117190921014SLuciano Coelho ret = wl1251_acx_cts_protect(wl, CTSPROTECT_DISABLE); 117290921014SLuciano Coelho if (ret < 0) { 117390921014SLuciano Coelho wl1251_warning("Set ctsprotect failed %d", ret); 117490921014SLuciano Coelho goto out_sleep; 117590921014SLuciano Coelho } 117690921014SLuciano Coelho } 117790921014SLuciano Coelho 1178204cc5c4SDavid Gnedt if (changed & BSS_CHANGED_ARP_FILTER) { 1179204cc5c4SDavid Gnedt __be32 addr = bss_conf->arp_addr_list[0]; 1180204cc5c4SDavid Gnedt WARN_ON(wl->bss_type != BSS_TYPE_STA_BSS); 1181204cc5c4SDavid Gnedt 1182204cc5c4SDavid Gnedt enable = bss_conf->arp_addr_cnt == 1 && bss_conf->assoc; 1183ac1181c6SColin Ian King ret = wl1251_acx_arp_ip_filter(wl, enable, addr); 1184204cc5c4SDavid Gnedt if (ret < 0) 1185204cc5c4SDavid Gnedt goto out_sleep; 1186204cc5c4SDavid Gnedt } 1187204cc5c4SDavid Gnedt 118890921014SLuciano Coelho if (changed & BSS_CHANGED_BEACON) { 118990921014SLuciano Coelho beacon = ieee80211_beacon_get(hw, vif); 119090921014SLuciano Coelho if (!beacon) 119190921014SLuciano Coelho goto out_sleep; 119290921014SLuciano Coelho 119390921014SLuciano Coelho ret = wl1251_cmd_template_set(wl, CMD_BEACON, beacon->data, 119490921014SLuciano Coelho beacon->len); 119590921014SLuciano Coelho 119690921014SLuciano Coelho if (ret < 0) { 119790921014SLuciano Coelho dev_kfree_skb(beacon); 119890921014SLuciano Coelho goto out_sleep; 119990921014SLuciano Coelho } 120090921014SLuciano Coelho 120190921014SLuciano Coelho ret = wl1251_cmd_template_set(wl, CMD_PROBE_RESP, beacon->data, 120290921014SLuciano Coelho beacon->len); 120390921014SLuciano Coelho 120490921014SLuciano Coelho dev_kfree_skb(beacon); 120590921014SLuciano Coelho 120690921014SLuciano Coelho if (ret < 0) 120790921014SLuciano Coelho goto out_sleep; 120890921014SLuciano Coelho 1209863bdbc9SGrazvydas Ignotas ret = wl1251_join(wl, wl->bss_type, wl->channel, 1210863bdbc9SGrazvydas Ignotas wl->beacon_int, wl->dtim_period); 121190921014SLuciano Coelho 121290921014SLuciano Coelho if (ret < 0) 121390921014SLuciano Coelho goto out_sleep; 121490921014SLuciano Coelho } 121590921014SLuciano Coelho 121690921014SLuciano Coelho out_sleep: 121790921014SLuciano Coelho wl1251_ps_elp_sleep(wl); 121890921014SLuciano Coelho 121990921014SLuciano Coelho out: 122090921014SLuciano Coelho mutex_unlock(&wl->mutex); 122190921014SLuciano Coelho } 122290921014SLuciano Coelho 122390921014SLuciano Coelho 122490921014SLuciano Coelho /* can't be const, mac80211 writes to this */ 122590921014SLuciano Coelho static struct ieee80211_rate wl1251_rates[] = { 122690921014SLuciano Coelho { .bitrate = 10, 122790921014SLuciano Coelho .hw_value = 0x1, 122890921014SLuciano Coelho .hw_value_short = 0x1, }, 122990921014SLuciano Coelho { .bitrate = 20, 123090921014SLuciano Coelho .hw_value = 0x2, 123190921014SLuciano Coelho .hw_value_short = 0x2, 123290921014SLuciano Coelho .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 123390921014SLuciano Coelho { .bitrate = 55, 123490921014SLuciano Coelho .hw_value = 0x4, 123590921014SLuciano Coelho .hw_value_short = 0x4, 123690921014SLuciano Coelho .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 123790921014SLuciano Coelho { .bitrate = 110, 123890921014SLuciano Coelho .hw_value = 0x20, 123990921014SLuciano Coelho .hw_value_short = 0x20, 124090921014SLuciano Coelho .flags = IEEE80211_RATE_SHORT_PREAMBLE }, 124190921014SLuciano Coelho { .bitrate = 60, 124290921014SLuciano Coelho .hw_value = 0x8, 124390921014SLuciano Coelho .hw_value_short = 0x8, }, 124490921014SLuciano Coelho { .bitrate = 90, 124590921014SLuciano Coelho .hw_value = 0x10, 124690921014SLuciano Coelho .hw_value_short = 0x10, }, 124790921014SLuciano Coelho { .bitrate = 120, 124890921014SLuciano Coelho .hw_value = 0x40, 124990921014SLuciano Coelho .hw_value_short = 0x40, }, 125090921014SLuciano Coelho { .bitrate = 180, 125190921014SLuciano Coelho .hw_value = 0x80, 125290921014SLuciano Coelho .hw_value_short = 0x80, }, 125390921014SLuciano Coelho { .bitrate = 240, 125490921014SLuciano Coelho .hw_value = 0x200, 125590921014SLuciano Coelho .hw_value_short = 0x200, }, 125690921014SLuciano Coelho { .bitrate = 360, 125790921014SLuciano Coelho .hw_value = 0x400, 125890921014SLuciano Coelho .hw_value_short = 0x400, }, 125990921014SLuciano Coelho { .bitrate = 480, 126090921014SLuciano Coelho .hw_value = 0x800, 126190921014SLuciano Coelho .hw_value_short = 0x800, }, 126290921014SLuciano Coelho { .bitrate = 540, 126390921014SLuciano Coelho .hw_value = 0x1000, 126490921014SLuciano Coelho .hw_value_short = 0x1000, }, 126590921014SLuciano Coelho }; 126690921014SLuciano Coelho 126790921014SLuciano Coelho /* can't be const, mac80211 writes to this */ 126890921014SLuciano Coelho static struct ieee80211_channel wl1251_channels[] = { 126990921014SLuciano Coelho { .hw_value = 1, .center_freq = 2412}, 127090921014SLuciano Coelho { .hw_value = 2, .center_freq = 2417}, 127190921014SLuciano Coelho { .hw_value = 3, .center_freq = 2422}, 127290921014SLuciano Coelho { .hw_value = 4, .center_freq = 2427}, 127390921014SLuciano Coelho { .hw_value = 5, .center_freq = 2432}, 127490921014SLuciano Coelho { .hw_value = 6, .center_freq = 2437}, 127590921014SLuciano Coelho { .hw_value = 7, .center_freq = 2442}, 127690921014SLuciano Coelho { .hw_value = 8, .center_freq = 2447}, 127790921014SLuciano Coelho { .hw_value = 9, .center_freq = 2452}, 127890921014SLuciano Coelho { .hw_value = 10, .center_freq = 2457}, 127990921014SLuciano Coelho { .hw_value = 11, .center_freq = 2462}, 128090921014SLuciano Coelho { .hw_value = 12, .center_freq = 2467}, 128190921014SLuciano Coelho { .hw_value = 13, .center_freq = 2472}, 128290921014SLuciano Coelho }; 128390921014SLuciano Coelho 128490921014SLuciano Coelho static int wl1251_op_conf_tx(struct ieee80211_hw *hw, 128590921014SLuciano Coelho struct ieee80211_vif *vif, u16 queue, 128690921014SLuciano Coelho const struct ieee80211_tx_queue_params *params) 128790921014SLuciano Coelho { 128890921014SLuciano Coelho enum wl1251_acx_ps_scheme ps_scheme; 128990921014SLuciano Coelho struct wl1251 *wl = hw->priv; 129090921014SLuciano Coelho int ret; 129190921014SLuciano Coelho 129290921014SLuciano Coelho mutex_lock(&wl->mutex); 129390921014SLuciano Coelho 129490921014SLuciano Coelho wl1251_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue); 129590921014SLuciano Coelho 129690921014SLuciano Coelho ret = wl1251_ps_elp_wakeup(wl); 129790921014SLuciano Coelho if (ret < 0) 129890921014SLuciano Coelho goto out; 129990921014SLuciano Coelho 130090921014SLuciano Coelho /* mac80211 uses units of 32 usec */ 130190921014SLuciano Coelho ret = wl1251_acx_ac_cfg(wl, wl1251_tx_get_queue(queue), 130290921014SLuciano Coelho params->cw_min, params->cw_max, 130390921014SLuciano Coelho params->aifs, params->txop * 32); 130490921014SLuciano Coelho if (ret < 0) 130590921014SLuciano Coelho goto out_sleep; 130690921014SLuciano Coelho 130790921014SLuciano Coelho if (params->uapsd) 130890921014SLuciano Coelho ps_scheme = WL1251_ACX_PS_SCHEME_UPSD_TRIGGER; 130990921014SLuciano Coelho else 131090921014SLuciano Coelho ps_scheme = WL1251_ACX_PS_SCHEME_LEGACY; 131190921014SLuciano Coelho 131290921014SLuciano Coelho ret = wl1251_acx_tid_cfg(wl, wl1251_tx_get_queue(queue), 131390921014SLuciano Coelho CHANNEL_TYPE_EDCF, 131490921014SLuciano Coelho wl1251_tx_get_queue(queue), ps_scheme, 131590921014SLuciano Coelho WL1251_ACX_ACK_POLICY_LEGACY); 131690921014SLuciano Coelho if (ret < 0) 131790921014SLuciano Coelho goto out_sleep; 131890921014SLuciano Coelho 131990921014SLuciano Coelho out_sleep: 132090921014SLuciano Coelho wl1251_ps_elp_sleep(wl); 132190921014SLuciano Coelho 132290921014SLuciano Coelho out: 132390921014SLuciano Coelho mutex_unlock(&wl->mutex); 132490921014SLuciano Coelho 132590921014SLuciano Coelho return ret; 132690921014SLuciano Coelho } 132790921014SLuciano Coelho 132890921014SLuciano Coelho static int wl1251_op_get_survey(struct ieee80211_hw *hw, int idx, 132990921014SLuciano Coelho struct survey_info *survey) 133090921014SLuciano Coelho { 133190921014SLuciano Coelho struct wl1251 *wl = hw->priv; 133290921014SLuciano Coelho struct ieee80211_conf *conf = &hw->conf; 133390921014SLuciano Coelho 133490921014SLuciano Coelho if (idx != 0) 133590921014SLuciano Coelho return -ENOENT; 133690921014SLuciano Coelho 1337675a0b04SKarl Beldan survey->channel = conf->chandef.chan; 133890921014SLuciano Coelho survey->filled = SURVEY_INFO_NOISE_DBM; 133990921014SLuciano Coelho survey->noise = wl->noise; 134090921014SLuciano Coelho 134190921014SLuciano Coelho return 0; 134290921014SLuciano Coelho } 134390921014SLuciano Coelho 134490921014SLuciano Coelho /* can't be const, mac80211 writes to this */ 134590921014SLuciano Coelho static struct ieee80211_supported_band wl1251_band_2ghz = { 134690921014SLuciano Coelho .channels = wl1251_channels, 134790921014SLuciano Coelho .n_channels = ARRAY_SIZE(wl1251_channels), 134890921014SLuciano Coelho .bitrates = wl1251_rates, 134990921014SLuciano Coelho .n_bitrates = ARRAY_SIZE(wl1251_rates), 135090921014SLuciano Coelho }; 135190921014SLuciano Coelho 135290921014SLuciano Coelho static const struct ieee80211_ops wl1251_ops = { 135390921014SLuciano Coelho .start = wl1251_op_start, 135490921014SLuciano Coelho .stop = wl1251_op_stop, 135590921014SLuciano Coelho .add_interface = wl1251_op_add_interface, 135690921014SLuciano Coelho .remove_interface = wl1251_op_remove_interface, 135790921014SLuciano Coelho .config = wl1251_op_config, 13589ed74ba0SDavid Gnedt .prepare_multicast = wl1251_op_prepare_multicast, 135990921014SLuciano Coelho .configure_filter = wl1251_op_configure_filter, 136090921014SLuciano Coelho .tx = wl1251_op_tx, 136190921014SLuciano Coelho .set_key = wl1251_op_set_key, 136290921014SLuciano Coelho .hw_scan = wl1251_op_hw_scan, 136390921014SLuciano Coelho .bss_info_changed = wl1251_op_bss_info_changed, 136490921014SLuciano Coelho .set_rts_threshold = wl1251_op_set_rts_threshold, 136590921014SLuciano Coelho .conf_tx = wl1251_op_conf_tx, 136690921014SLuciano Coelho .get_survey = wl1251_op_get_survey, 136790921014SLuciano Coelho }; 136890921014SLuciano Coelho 136990921014SLuciano Coelho static int wl1251_read_eeprom_byte(struct wl1251 *wl, off_t offset, u8 *data) 137090921014SLuciano Coelho { 137190921014SLuciano Coelho unsigned long timeout; 137290921014SLuciano Coelho 137390921014SLuciano Coelho wl1251_reg_write32(wl, EE_ADDR, offset); 137490921014SLuciano Coelho wl1251_reg_write32(wl, EE_CTL, EE_CTL_READ); 137590921014SLuciano Coelho 137690921014SLuciano Coelho /* EE_CTL_READ clears when data is ready */ 137790921014SLuciano Coelho timeout = jiffies + msecs_to_jiffies(100); 137890921014SLuciano Coelho while (1) { 137990921014SLuciano Coelho if (!(wl1251_reg_read32(wl, EE_CTL) & EE_CTL_READ)) 138090921014SLuciano Coelho break; 138190921014SLuciano Coelho 138290921014SLuciano Coelho if (time_after(jiffies, timeout)) 138390921014SLuciano Coelho return -ETIMEDOUT; 138490921014SLuciano Coelho 138590921014SLuciano Coelho msleep(1); 138690921014SLuciano Coelho } 138790921014SLuciano Coelho 138890921014SLuciano Coelho *data = wl1251_reg_read32(wl, EE_DATA); 138990921014SLuciano Coelho return 0; 139090921014SLuciano Coelho } 139190921014SLuciano Coelho 139290921014SLuciano Coelho static int wl1251_read_eeprom(struct wl1251 *wl, off_t offset, 139390921014SLuciano Coelho u8 *data, size_t len) 139490921014SLuciano Coelho { 139590921014SLuciano Coelho size_t i; 139690921014SLuciano Coelho int ret; 139790921014SLuciano Coelho 139890921014SLuciano Coelho wl1251_reg_write32(wl, EE_START, 0); 139990921014SLuciano Coelho 140090921014SLuciano Coelho for (i = 0; i < len; i++) { 140190921014SLuciano Coelho ret = wl1251_read_eeprom_byte(wl, offset + i, &data[i]); 140290921014SLuciano Coelho if (ret < 0) 140390921014SLuciano Coelho return ret; 140490921014SLuciano Coelho } 140590921014SLuciano Coelho 140690921014SLuciano Coelho return 0; 140790921014SLuciano Coelho } 140890921014SLuciano Coelho 140990921014SLuciano Coelho static int wl1251_read_eeprom_mac(struct wl1251 *wl) 141090921014SLuciano Coelho { 141190921014SLuciano Coelho u8 mac[ETH_ALEN]; 141290921014SLuciano Coelho int i, ret; 141390921014SLuciano Coelho 141490921014SLuciano Coelho wl1251_set_partition(wl, 0, 0, REGISTERS_BASE, REGISTERS_DOWN_SIZE); 141590921014SLuciano Coelho 141690921014SLuciano Coelho ret = wl1251_read_eeprom(wl, 0x1c, mac, sizeof(mac)); 141790921014SLuciano Coelho if (ret < 0) { 141890921014SLuciano Coelho wl1251_warning("failed to read MAC address from EEPROM"); 141990921014SLuciano Coelho return ret; 142090921014SLuciano Coelho } 142190921014SLuciano Coelho 142290921014SLuciano Coelho /* MAC is stored in reverse order */ 142390921014SLuciano Coelho for (i = 0; i < ETH_ALEN; i++) 142490921014SLuciano Coelho wl->mac_addr[i] = mac[ETH_ALEN - i - 1]; 142590921014SLuciano Coelho 142690921014SLuciano Coelho return 0; 142790921014SLuciano Coelho } 142890921014SLuciano Coelho 14294f507d58SPali Rohár #define NVS_OFF_MAC_LEN 0x19 14304f507d58SPali Rohár #define NVS_OFF_MAC_ADDR_LO 0x1a 14314f507d58SPali Rohár #define NVS_OFF_MAC_ADDR_HI 0x1b 14324f507d58SPali Rohár #define NVS_OFF_MAC_DATA 0x1c 14334f507d58SPali Rohár 14344f507d58SPali Rohár static int wl1251_check_nvs_mac(struct wl1251 *wl) 14354f507d58SPali Rohár { 14364f507d58SPali Rohár if (wl->nvs_len < 0x24) 14374f507d58SPali Rohár return -ENODATA; 14384f507d58SPali Rohár 14394f507d58SPali Rohár /* length is 2 and data address is 0x546c (ANDed with 0xfffe) */ 14404f507d58SPali Rohár if (wl->nvs[NVS_OFF_MAC_LEN] != 2 || 14414f507d58SPali Rohár wl->nvs[NVS_OFF_MAC_ADDR_LO] != 0x6d || 14424f507d58SPali Rohár wl->nvs[NVS_OFF_MAC_ADDR_HI] != 0x54) 14434f507d58SPali Rohár return -EINVAL; 14444f507d58SPali Rohár 14454f507d58SPali Rohár return 0; 14464f507d58SPali Rohár } 14474f507d58SPali Rohár 14484f507d58SPali Rohár static int wl1251_read_nvs_mac(struct wl1251 *wl) 14494f507d58SPali Rohár { 14504f507d58SPali Rohár u8 mac[ETH_ALEN]; 14514f507d58SPali Rohár int i, ret; 14524f507d58SPali Rohár 14534f507d58SPali Rohár ret = wl1251_check_nvs_mac(wl); 14544f507d58SPali Rohár if (ret) 14554f507d58SPali Rohár return ret; 14564f507d58SPali Rohár 14574f507d58SPali Rohár /* MAC is stored in reverse order */ 14584f507d58SPali Rohár for (i = 0; i < ETH_ALEN; i++) 14594f507d58SPali Rohár mac[i] = wl->nvs[NVS_OFF_MAC_DATA + ETH_ALEN - i - 1]; 14604f507d58SPali Rohár 14614f507d58SPali Rohár /* 00:00:20:07:03:09 is in example file wl1251-nvs.bin, so invalid */ 14624f507d58SPali Rohár if (ether_addr_equal_unaligned(mac, "\x00\x00\x20\x07\x03\x09")) 14634f507d58SPali Rohár return -EINVAL; 14644f507d58SPali Rohár 14654f507d58SPali Rohár memcpy(wl->mac_addr, mac, ETH_ALEN); 14664f507d58SPali Rohár return 0; 14674f507d58SPali Rohár } 14684f507d58SPali Rohár 14693142467fSPali Rohár static int wl1251_write_nvs_mac(struct wl1251 *wl) 14703142467fSPali Rohár { 14713142467fSPali Rohár int i, ret; 14723142467fSPali Rohár 14733142467fSPali Rohár ret = wl1251_check_nvs_mac(wl); 14743142467fSPali Rohár if (ret) 14753142467fSPali Rohár return ret; 14763142467fSPali Rohár 14773142467fSPali Rohár /* MAC is stored in reverse order */ 14783142467fSPali Rohár for (i = 0; i < ETH_ALEN; i++) 14793142467fSPali Rohár wl->nvs[NVS_OFF_MAC_DATA + i] = wl->mac_addr[ETH_ALEN - i - 1]; 14803142467fSPali Rohár 14813142467fSPali Rohár return 0; 14823142467fSPali Rohár } 14833142467fSPali Rohár 148490921014SLuciano Coelho static int wl1251_register_hw(struct wl1251 *wl) 148590921014SLuciano Coelho { 148690921014SLuciano Coelho int ret; 148790921014SLuciano Coelho 148890921014SLuciano Coelho if (wl->mac80211_registered) 148990921014SLuciano Coelho return 0; 149090921014SLuciano Coelho 149190921014SLuciano Coelho SET_IEEE80211_PERM_ADDR(wl->hw, wl->mac_addr); 149290921014SLuciano Coelho 149390921014SLuciano Coelho ret = ieee80211_register_hw(wl->hw); 149490921014SLuciano Coelho if (ret < 0) { 149590921014SLuciano Coelho wl1251_error("unable to register mac80211 hw: %d", ret); 149690921014SLuciano Coelho return ret; 149790921014SLuciano Coelho } 149890921014SLuciano Coelho 149990921014SLuciano Coelho wl->mac80211_registered = true; 150090921014SLuciano Coelho 150190921014SLuciano Coelho wl1251_notice("loaded"); 150290921014SLuciano Coelho 150390921014SLuciano Coelho return 0; 150490921014SLuciano Coelho } 150590921014SLuciano Coelho 150690921014SLuciano Coelho int wl1251_init_ieee80211(struct wl1251 *wl) 150790921014SLuciano Coelho { 150890921014SLuciano Coelho int ret; 150990921014SLuciano Coelho 151090921014SLuciano Coelho /* The tx descriptor buffer and the TKIP space */ 151190921014SLuciano Coelho wl->hw->extra_tx_headroom = sizeof(struct tx_double_buffer_desc) 151290921014SLuciano Coelho + WL1251_TKIP_IV_SPACE; 151390921014SLuciano Coelho 151490921014SLuciano Coelho /* unit us */ 151590921014SLuciano Coelho /* FIXME: find a proper value */ 151690921014SLuciano Coelho 151730686bf7SJohannes Berg ieee80211_hw_set(wl->hw, SIGNAL_DBM); 151830686bf7SJohannes Berg ieee80211_hw_set(wl->hw, SUPPORTS_PS); 151990921014SLuciano Coelho 152090921014SLuciano Coelho wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 152190921014SLuciano Coelho BIT(NL80211_IFTYPE_ADHOC); 152290921014SLuciano Coelho wl->hw->wiphy->max_scan_ssids = 1; 152357fbcce3SJohannes Berg wl->hw->wiphy->bands[NL80211_BAND_2GHZ] = &wl1251_band_2ghz; 152490921014SLuciano Coelho 152590921014SLuciano Coelho wl->hw->queues = 4; 152690921014SLuciano Coelho 15274f507d58SPali Rohár if (wl->nvs == NULL && !wl->use_eeprom) { 15284f507d58SPali Rohár ret = wl1251_fetch_nvs(wl); 15294f507d58SPali Rohár if (ret < 0) 15304f507d58SPali Rohár goto out; 15314f507d58SPali Rohár } 15324f507d58SPali Rohár 153390921014SLuciano Coelho if (wl->use_eeprom) 1534562da3a3SPali Rohár ret = wl1251_read_eeprom_mac(wl); 1535562da3a3SPali Rohár else 15364f507d58SPali Rohár ret = wl1251_read_nvs_mac(wl); 1537562da3a3SPali Rohár 1538562da3a3SPali Rohár if (ret == 0 && !is_valid_ether_addr(wl->mac_addr)) 1539562da3a3SPali Rohár ret = -EINVAL; 1540562da3a3SPali Rohár 1541562da3a3SPali Rohár if (ret < 0) { 1542562da3a3SPali Rohár /* 1543562da3a3SPali Rohár * In case our MAC address is not correctly set, 1544562da3a3SPali Rohár * we use a random but Nokia MAC. 1545562da3a3SPali Rohár */ 1546562da3a3SPali Rohár static const u8 nokia_oui[3] = {0x00, 0x1f, 0xdf}; 1547562da3a3SPali Rohár memcpy(wl->mac_addr, nokia_oui, 3); 1548562da3a3SPali Rohár get_random_bytes(wl->mac_addr + 3, 3); 15493142467fSPali Rohár if (!wl->use_eeprom) 15503142467fSPali Rohár wl1251_write_nvs_mac(wl); 1551562da3a3SPali Rohár wl1251_warning("MAC address in eeprom or nvs data is not valid"); 1552562da3a3SPali Rohár wl1251_warning("Setting random MAC address: %pM", wl->mac_addr); 1553562da3a3SPali Rohár } 155490921014SLuciano Coelho 155590921014SLuciano Coelho ret = wl1251_register_hw(wl); 155690921014SLuciano Coelho if (ret) 155790921014SLuciano Coelho goto out; 155890921014SLuciano Coelho 155990921014SLuciano Coelho wl1251_debugfs_init(wl); 156090921014SLuciano Coelho wl1251_notice("initialized"); 156190921014SLuciano Coelho 156290921014SLuciano Coelho ret = 0; 156390921014SLuciano Coelho 156490921014SLuciano Coelho out: 156590921014SLuciano Coelho return ret; 156690921014SLuciano Coelho } 156790921014SLuciano Coelho EXPORT_SYMBOL_GPL(wl1251_init_ieee80211); 156890921014SLuciano Coelho 156990921014SLuciano Coelho struct ieee80211_hw *wl1251_alloc_hw(void) 157090921014SLuciano Coelho { 157190921014SLuciano Coelho struct ieee80211_hw *hw; 157290921014SLuciano Coelho struct wl1251 *wl; 157390921014SLuciano Coelho int i; 157490921014SLuciano Coelho 157590921014SLuciano Coelho hw = ieee80211_alloc_hw(sizeof(*wl), &wl1251_ops); 157690921014SLuciano Coelho if (!hw) { 157790921014SLuciano Coelho wl1251_error("could not alloc ieee80211_hw"); 157890921014SLuciano Coelho return ERR_PTR(-ENOMEM); 157990921014SLuciano Coelho } 158090921014SLuciano Coelho 158190921014SLuciano Coelho wl = hw->priv; 158290921014SLuciano Coelho memset(wl, 0, sizeof(*wl)); 158390921014SLuciano Coelho 158490921014SLuciano Coelho wl->hw = hw; 158590921014SLuciano Coelho 158690921014SLuciano Coelho wl->data_in_count = 0; 158790921014SLuciano Coelho 158890921014SLuciano Coelho skb_queue_head_init(&wl->tx_queue); 158990921014SLuciano Coelho 159090921014SLuciano Coelho INIT_DELAYED_WORK(&wl->elp_work, wl1251_elp_work); 159190921014SLuciano Coelho wl->channel = WL1251_DEFAULT_CHANNEL; 15924d09b537SDavid Gnedt wl->monitor_present = false; 1593c8909e5aSDavid Gnedt wl->joined = false; 159490921014SLuciano Coelho wl->scanning = false; 1595c8909e5aSDavid Gnedt wl->bss_type = MAX_BSS_TYPE; 159690921014SLuciano Coelho wl->default_key = 0; 159790921014SLuciano Coelho wl->listen_int = 1; 159890921014SLuciano Coelho wl->rx_counter = 0; 159990921014SLuciano Coelho wl->rx_handled = 0; 160090921014SLuciano Coelho wl->rx_current_buffer = 0; 160190921014SLuciano Coelho wl->rx_last_id = 0; 160290921014SLuciano Coelho wl->rx_config = WL1251_DEFAULT_RX_CONFIG; 160390921014SLuciano Coelho wl->rx_filter = WL1251_DEFAULT_RX_FILTER; 160490921014SLuciano Coelho wl->elp = false; 160590921014SLuciano Coelho wl->station_mode = STATION_ACTIVE_MODE; 160690921014SLuciano Coelho wl->psm_requested = false; 1607f7ad1eedSDavid Gnedt wl->psm_entry_retry = 0; 160890921014SLuciano Coelho wl->tx_queue_stopped = false; 160990921014SLuciano Coelho wl->power_level = WL1251_DEFAULT_POWER_LEVEL; 161090921014SLuciano Coelho wl->rssi_thold = 0; 161190921014SLuciano Coelho wl->beacon_int = WL1251_DEFAULT_BEACON_INT; 161290921014SLuciano Coelho wl->dtim_period = WL1251_DEFAULT_DTIM_PERIOD; 161390921014SLuciano Coelho wl->vif = NULL; 161490921014SLuciano Coelho 161590921014SLuciano Coelho for (i = 0; i < FW_TX_CMPLT_BLOCK_SIZE; i++) 161690921014SLuciano Coelho wl->tx_frames[i] = NULL; 161790921014SLuciano Coelho 161890921014SLuciano Coelho wl->next_tx_complete = 0; 161990921014SLuciano Coelho 162090921014SLuciano Coelho INIT_WORK(&wl->irq_work, wl1251_irq_work); 162190921014SLuciano Coelho INIT_WORK(&wl->tx_work, wl1251_tx_work); 162290921014SLuciano Coelho 162390921014SLuciano Coelho wl->state = WL1251_STATE_OFF; 162490921014SLuciano Coelho mutex_init(&wl->mutex); 1625f581a0ddSCong Wang spin_lock_init(&wl->wl_lock); 162690921014SLuciano Coelho 162790921014SLuciano Coelho wl->tx_mgmt_frm_rate = DEFAULT_HW_GEN_TX_RATE; 162890921014SLuciano Coelho wl->tx_mgmt_frm_mod = DEFAULT_HW_GEN_MODULATION_TYPE; 162990921014SLuciano Coelho 163090921014SLuciano Coelho wl->rx_descriptor = kmalloc(sizeof(*wl->rx_descriptor), GFP_KERNEL); 163190921014SLuciano Coelho if (!wl->rx_descriptor) { 163290921014SLuciano Coelho wl1251_error("could not allocate memory for rx descriptor"); 163390921014SLuciano Coelho ieee80211_free_hw(hw); 163490921014SLuciano Coelho return ERR_PTR(-ENOMEM); 163590921014SLuciano Coelho } 163690921014SLuciano Coelho 163790921014SLuciano Coelho return hw; 163890921014SLuciano Coelho } 163990921014SLuciano Coelho EXPORT_SYMBOL_GPL(wl1251_alloc_hw); 164090921014SLuciano Coelho 164190921014SLuciano Coelho int wl1251_free_hw(struct wl1251 *wl) 164290921014SLuciano Coelho { 164390921014SLuciano Coelho ieee80211_unregister_hw(wl->hw); 164490921014SLuciano Coelho 164590921014SLuciano Coelho wl1251_debugfs_exit(wl); 164690921014SLuciano Coelho 164790921014SLuciano Coelho kfree(wl->target_mem_map); 164890921014SLuciano Coelho kfree(wl->data_path); 164990921014SLuciano Coelho vfree(wl->fw); 165090921014SLuciano Coelho wl->fw = NULL; 165190921014SLuciano Coelho kfree(wl->nvs); 165290921014SLuciano Coelho wl->nvs = NULL; 165390921014SLuciano Coelho 165490921014SLuciano Coelho kfree(wl->rx_descriptor); 165590921014SLuciano Coelho wl->rx_descriptor = NULL; 165690921014SLuciano Coelho 165790921014SLuciano Coelho ieee80211_free_hw(wl->hw); 165890921014SLuciano Coelho 165990921014SLuciano Coelho return 0; 166090921014SLuciano Coelho } 166190921014SLuciano Coelho EXPORT_SYMBOL_GPL(wl1251_free_hw); 166290921014SLuciano Coelho 1663fcc658daSMasanari Iida MODULE_DESCRIPTION("TI wl1251 Wireless LAN Driver Core"); 166490921014SLuciano Coelho MODULE_LICENSE("GPL"); 166590921014SLuciano Coelho MODULE_AUTHOR("Kalle Valo <kvalo@adurom.com>"); 166690921014SLuciano Coelho MODULE_FIRMWARE(WL1251_FW_NAME); 1667deb6e6b7SPavel Machek MODULE_FIRMWARE(WL1251_NVS_NAME); 1668