| 1 |
// SPDX-License-Identifier: GPL-2.0-only |
| 2 |
/* |
| 3 |
* mac80211 glue code for mac80211 ST-Ericsson CW1200 drivers |
| 4 |
* |
| 5 |
* Copyright (c) 2010, ST-Ericsson |
| 6 |
* Author: Dmitry Tarnyagin <[email protected]> |
| 7 |
* |
| 8 |
* Based on: |
| 9 |
* Copyright (c) 2006, Michael Wu <[email protected]> |
| 10 |
* Copyright (c) 2007-2009, Christian Lamparter <[email protected]> |
| 11 |
* Copyright 2008, Johannes Berg <[email protected]> |
| 12 |
* |
| 13 |
* Based on: |
| 14 |
* - the islsm (softmac prism54) driver, which is: |
| 15 |
* Copyright 2004-2006 Jean-Baptiste Note <[email protected]>, et al. |
| 16 |
* - stlc45xx driver |
| 17 |
* Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies). |
| 18 |
*/ |
| 19 |
|
| 20 |
#include <linux/module.h> |
| 21 |
#include <linux/firmware.h> |
| 22 |
#include <linux/etherdevice.h> |
| 23 |
#include <linux/vmalloc.h> |
| 24 |
#include <linux/random.h> |
| 25 |
#include <linux/sched.h> |
| 26 |
#include <net/mac80211.h> |
| 27 |
|
| 28 |
#include "cw1200.h" |
| 29 |
#include "txrx.h" |
| 30 |
#include "hwbus.h" |
| 31 |
#include "fwio.h" |
| 32 |
#include "hwio.h" |
| 33 |
#include "bh.h" |
| 34 |
#include "sta.h" |
| 35 |
#include "scan.h" |
| 36 |
#include "debug.h" |
| 37 |
#include "pm.h" |
| 38 |
|
| 39 |
MODULE_AUTHOR("Dmitry Tarnyagin <[email protected]>"); |
| 40 |
MODULE_DESCRIPTION("Softmac ST-Ericsson CW1200 common code"); |
| 41 |
MODULE_LICENSE("GPL"); |
| 42 |
MODULE_ALIAS("cw1200_core"); |
| 43 |
|
| 44 |
/* Accept MAC address of the form macaddr=0x00,0x80,0xE1,0x30,0x40,0x50 */ |
| 45 |
static u8 cw1200_mac_template[ETH_ALEN] = {0x02, 0x80, 0xe1, 0x00, 0x00, 0x00}; |
| 46 |
module_param_array_named(macaddr, cw1200_mac_template, byte, NULL, 0444); |
| 47 |
MODULE_PARM_DESC(macaddr, "Override platform_data MAC address"); |
| 48 |
|
| 49 |
static char *cw1200_sdd_path; |
| 50 |
module_param(cw1200_sdd_path, charp, 0644); |
| 51 |
MODULE_PARM_DESC(cw1200_sdd_path, "Override platform_data SDD file"); |
| 52 |
static int cw1200_refclk; |
| 53 |
module_param(cw1200_refclk, int, 0644); |
| 54 |
MODULE_PARM_DESC(cw1200_refclk, "Override platform_data reference clock"); |
| 55 |
|
| 56 |
int cw1200_power_mode = wsm_power_mode_quiescent; |
| 57 |
module_param(cw1200_power_mode, int, 0644); |
| 58 |
MODULE_PARM_DESC(cw1200_power_mode, "WSM power mode. 0 == active, 1 == doze, 2 == quiescent (default)"); |
| 59 |
|
| 60 |
#define RATETAB_ENT(_rate, _rateid, _flags) \ |
| 61 |
{ \ |
| 62 |
.bitrate = (_rate), \ |
| 63 |
.hw_value = (_rateid), \ |
| 64 |
.flags = (_flags), \ |
| 65 |
} |
| 66 |
|
| 67 |
static struct ieee80211_rate cw1200_rates[] = { |
| 68 |
RATETAB_ENT(10, 0, 0), |
| 69 |
RATETAB_ENT(20, 1, 0), |
| 70 |
RATETAB_ENT(55, 2, 0), |
| 71 |
RATETAB_ENT(110, 3, 0), |
| 72 |
RATETAB_ENT(60, 6, 0), |
| 73 |
RATETAB_ENT(90, 7, 0), |
| 74 |
RATETAB_ENT(120, 8, 0), |
| 75 |
RATETAB_ENT(180, 9, 0), |
| 76 |
RATETAB_ENT(240, 10, 0), |
| 77 |
RATETAB_ENT(360, 11, 0), |
| 78 |
RATETAB_ENT(480, 12, 0), |
| 79 |
RATETAB_ENT(540, 13, 0), |
| 80 |
}; |
| 81 |
|
| 82 |
static struct ieee80211_rate cw1200_mcs_rates[] = { |
| 83 |
RATETAB_ENT(65, 14, IEEE80211_TX_RC_MCS), |
| 84 |
RATETAB_ENT(130, 15, IEEE80211_TX_RC_MCS), |
| 85 |
RATETAB_ENT(195, 16, IEEE80211_TX_RC_MCS), |
| 86 |
RATETAB_ENT(260, 17, IEEE80211_TX_RC_MCS), |
| 87 |
RATETAB_ENT(390, 18, IEEE80211_TX_RC_MCS), |
| 88 |
RATETAB_ENT(520, 19, IEEE80211_TX_RC_MCS), |
| 89 |
RATETAB_ENT(585, 20, IEEE80211_TX_RC_MCS), |
| 90 |
RATETAB_ENT(650, 21, IEEE80211_TX_RC_MCS), |
| 91 |
}; |
| 92 |
|
| 93 |
#define cw1200_a_rates (cw1200_rates + 4) |
| 94 |
#define cw1200_a_rates_size (ARRAY_SIZE(cw1200_rates) - 4) |
| 95 |
#define cw1200_g_rates (cw1200_rates + 0) |
| 96 |
#define cw1200_g_rates_size (ARRAY_SIZE(cw1200_rates)) |
| 97 |
#define cw1200_n_rates (cw1200_mcs_rates) |
| 98 |
#define cw1200_n_rates_size (ARRAY_SIZE(cw1200_mcs_rates)) |
| 99 |
|
| 100 |
|
| 101 |
#define CHAN2G(_channel, _freq, _flags) { \ |
| 102 |
.band = NL80211_BAND_2GHZ, \ |
| 103 |
.center_freq = (_freq), \ |
| 104 |
.hw_value = (_channel), \ |
| 105 |
.flags = (_flags), \ |
| 106 |
.max_antenna_gain = 0, \ |
| 107 |
.max_power = 30, \ |
| 108 |
} |
| 109 |
|
| 110 |
#define CHAN5G(_channel, _flags) { \ |
| 111 |
.band = NL80211_BAND_5GHZ, \ |
| 112 |
.center_freq = 5000 + (5 * (_channel)), \ |
| 113 |
.hw_value = (_channel), \ |
| 114 |
.flags = (_flags), \ |
| 115 |
.max_antenna_gain = 0, \ |
| 116 |
.max_power = 30, \ |
| 117 |
} |
| 118 |
|
| 119 |
static struct ieee80211_channel cw1200_2ghz_chantable[] = { |
| 120 |
CHAN2G(1, 2412, 0), |
| 121 |
CHAN2G(2, 2417, 0), |
| 122 |
CHAN2G(3, 2422, 0), |
| 123 |
CHAN2G(4, 2427, 0), |
| 124 |
CHAN2G(5, 2432, 0), |
| 125 |
CHAN2G(6, 2437, 0), |
| 126 |
CHAN2G(7, 2442, 0), |
| 127 |
CHAN2G(8, 2447, 0), |
| 128 |
CHAN2G(9, 2452, 0), |
| 129 |
CHAN2G(10, 2457, 0), |
| 130 |
CHAN2G(11, 2462, 0), |
| 131 |
CHAN2G(12, 2467, 0), |
| 132 |
CHAN2G(13, 2472, 0), |
| 133 |
CHAN2G(14, 2484, 0), |
| 134 |
}; |
| 135 |
|
| 136 |
static struct ieee80211_channel cw1200_5ghz_chantable[] = { |
| 137 |
CHAN5G(34, 0), CHAN5G(36, 0), |
| 138 |
CHAN5G(38, 0), CHAN5G(40, 0), |
| 139 |
CHAN5G(42, 0), CHAN5G(44, 0), |
| 140 |
CHAN5G(46, 0), CHAN5G(48, 0), |
| 141 |
CHAN5G(52, 0), CHAN5G(56, 0), |
| 142 |
CHAN5G(60, 0), CHAN5G(64, 0), |
| 143 |
CHAN5G(100, 0), CHAN5G(104, 0), |
| 144 |
CHAN5G(108, 0), CHAN5G(112, 0), |
| 145 |
CHAN5G(116, 0), CHAN5G(120, 0), |
| 146 |
CHAN5G(124, 0), CHAN5G(128, 0), |
| 147 |
CHAN5G(132, 0), CHAN5G(136, 0), |
| 148 |
CHAN5G(140, 0), CHAN5G(149, 0), |
| 149 |
CHAN5G(153, 0), CHAN5G(157, 0), |
| 150 |
CHAN5G(161, 0), CHAN5G(165, 0), |
| 151 |
CHAN5G(184, 0), CHAN5G(188, 0), |
| 152 |
CHAN5G(192, 0), CHAN5G(196, 0), |
| 153 |
CHAN5G(200, 0), CHAN5G(204, 0), |
| 154 |
CHAN5G(208, 0), CHAN5G(212, 0), |
| 155 |
CHAN5G(216, 0), |
| 156 |
}; |
| 157 |
|
| 158 |
static struct ieee80211_supported_band cw1200_band_2ghz = { |
| 159 |
.channels = cw1200_2ghz_chantable, |
| 160 |
.n_channels = ARRAY_SIZE(cw1200_2ghz_chantable), |
| 161 |
.bitrates = cw1200_g_rates, |
| 162 |
.n_bitrates = cw1200_g_rates_size, |
| 163 |
.ht_cap = { |
| 164 |
.cap = IEEE80211_HT_CAP_GRN_FLD | |
| 165 |
(1 << IEEE80211_HT_CAP_RX_STBC_SHIFT) | |
| 166 |
IEEE80211_HT_CAP_MAX_AMSDU, |
| 167 |
.ht_supported = 1, |
| 168 |
.ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, |
| 169 |
.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE, |
| 170 |
.mcs = { |
| 171 |
.rx_mask[0] = 0xFF, |
| 172 |
.rx_highest = __cpu_to_le16(0x41), |
| 173 |
.tx_params = IEEE80211_HT_MCS_TX_DEFINED, |
| 174 |
}, |
| 175 |
}, |
| 176 |
}; |
| 177 |
|
| 178 |
static struct ieee80211_supported_band cw1200_band_5ghz = { |
| 179 |
.channels = cw1200_5ghz_chantable, |
| 180 |
.n_channels = ARRAY_SIZE(cw1200_5ghz_chantable), |
| 181 |
.bitrates = cw1200_a_rates, |
| 182 |
.n_bitrates = cw1200_a_rates_size, |
| 183 |
.ht_cap = { |
| 184 |
.cap = IEEE80211_HT_CAP_GRN_FLD | |
| 185 |
(1 << IEEE80211_HT_CAP_RX_STBC_SHIFT) | |
| 186 |
IEEE80211_HT_CAP_MAX_AMSDU, |
| 187 |
.ht_supported = 1, |
| 188 |
.ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K, |
| 189 |
.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE, |
| 190 |
.mcs = { |
| 191 |
.rx_mask[0] = 0xFF, |
| 192 |
.rx_highest = __cpu_to_le16(0x41), |
| 193 |
.tx_params = IEEE80211_HT_MCS_TX_DEFINED, |
| 194 |
}, |
| 195 |
}, |
| 196 |
}; |
| 197 |
|
| 198 |
static const unsigned long cw1200_ttl[] = { |
| 199 |
1 * HZ, /* VO */ |
| 200 |
2 * HZ, /* VI */ |
| 201 |
5 * HZ, /* BE */ |
| 202 |
10 * HZ /* BK */ |
| 203 |
}; |
| 204 |
|
| 205 |
static const struct ieee80211_ops cw1200_ops = { |
| 206 |
.add_chanctx = ieee80211_emulate_add_chanctx, |
| 207 |
.remove_chanctx = ieee80211_emulate_remove_chanctx, |
| 208 |
.change_chanctx = ieee80211_emulate_change_chanctx, |
| 209 |
.switch_vif_chanctx = ieee80211_emulate_switch_vif_chanctx, |
| 210 |
.start = cw1200_start, |
| 211 |
.stop = cw1200_stop, |
| 212 |
.add_interface = cw1200_add_interface, |
| 213 |
.remove_interface = cw1200_remove_interface, |
| 214 |
.change_interface = cw1200_change_interface, |
| 215 |
.tx = cw1200_tx, |
| 216 |
.wake_tx_queue = ieee80211_handle_wake_tx_queue, |
| 217 |
.hw_scan = cw1200_hw_scan, |
| 218 |
.set_tim = cw1200_set_tim, |
| 219 |
.sta_notify = cw1200_sta_notify, |
| 220 |
.sta_add = cw1200_sta_add, |
| 221 |
.sta_remove = cw1200_sta_remove, |
| 222 |
.set_key = cw1200_set_key, |
| 223 |
.set_rts_threshold = cw1200_set_rts_threshold, |
| 224 |
.config = cw1200_config, |
| 225 |
.bss_info_changed = cw1200_bss_info_changed, |
| 226 |
.prepare_multicast = cw1200_prepare_multicast, |
| 227 |
.configure_filter = cw1200_configure_filter, |
| 228 |
.conf_tx = cw1200_conf_tx, |
| 229 |
.get_stats = cw1200_get_stats, |
| 230 |
.ampdu_action = cw1200_ampdu_action, |
| 231 |
.flush = cw1200_flush, |
| 232 |
#ifdef CONFIG_PM |
| 233 |
.suspend = cw1200_wow_suspend, |
| 234 |
.resume = cw1200_wow_resume, |
| 235 |
#endif |
| 236 |
/* Intentionally not offloaded: */ |
| 237 |
/*.channel_switch = cw1200_channel_switch, */ |
| 238 |
/*.remain_on_channel = cw1200_remain_on_channel, */ |
| 239 |
/*.cancel_remain_on_channel = cw1200_cancel_remain_on_channel, */ |
| 240 |
}; |
| 241 |
|
| 242 |
static int cw1200_ba_rx_tids = -1; |
| 243 |
static int cw1200_ba_tx_tids = -1; |
| 244 |
module_param(cw1200_ba_rx_tids, int, 0644); |
| 245 |
module_param(cw1200_ba_tx_tids, int, 0644); |
| 246 |
MODULE_PARM_DESC(cw1200_ba_rx_tids, "Block ACK RX TIDs"); |
| 247 |
MODULE_PARM_DESC(cw1200_ba_tx_tids, "Block ACK TX TIDs"); |
| 248 |
|
| 249 |
#ifdef CONFIG_PM |
| 250 |
static const struct wiphy_wowlan_support cw1200_wowlan_support = { |
| 251 |
/* Support only for limited wowlan functionalities */ |
| 252 |
.flags = WIPHY_WOWLAN_ANY | WIPHY_WOWLAN_DISCONNECT, |
| 253 |
}; |
| 254 |
#endif |
| 255 |
|
| 256 |
|
| 257 |
static struct ieee80211_hw *cw1200_init_common(const u8 *macaddr, |
| 258 |
const bool have_5ghz) |
| 259 |
{ |
| 260 |
int i, band; |
| 261 |
struct ieee80211_hw *hw; |
| 262 |
struct cw1200_common *priv; |
| 263 |
|
| 264 |
hw = ieee80211_alloc_hw(sizeof(struct cw1200_common), &cw1200_ops); |
| 265 |
if (!hw) |
| 266 |
return NULL; |
| 267 |
|
| 268 |
priv = hw->priv; |
| 269 |
priv->hw = hw; |
| 270 |
priv->hw_type = -1; |
| 271 |
priv->mode = NL80211_IFTYPE_UNSPECIFIED; |
| 272 |
priv->rates = cw1200_rates; /* TODO: fetch from FW */ |
| 273 |
priv->mcs_rates = cw1200_n_rates; |
| 274 |
if (cw1200_ba_rx_tids != -1) |
| 275 |
priv->ba_rx_tid_mask = cw1200_ba_rx_tids; |
| 276 |
else |
| 277 |
priv->ba_rx_tid_mask = 0xFF; /* Enable RX BLKACK for all TIDs */ |
| 278 |
if (cw1200_ba_tx_tids != -1) |
| 279 |
priv->ba_tx_tid_mask = cw1200_ba_tx_tids; |
| 280 |
else |
| 281 |
priv->ba_tx_tid_mask = 0xff; /* Enable TX BLKACK for all TIDs */ |
| 282 |
|
| 283 |
ieee80211_hw_set(hw, NEED_DTIM_BEFORE_ASSOC); |
| 284 |
ieee80211_hw_set(hw, TX_AMPDU_SETUP_IN_HW); |
| 285 |
ieee80211_hw_set(hw, AMPDU_AGGREGATION); |
| 286 |
ieee80211_hw_set(hw, CONNECTION_MONITOR); |
| 287 |
ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS); |
| 288 |
ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS); |
| 289 |
ieee80211_hw_set(hw, SIGNAL_DBM); |
| 290 |
ieee80211_hw_set(hw, SUPPORTS_PS); |
| 291 |
|
| 292 |
hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | |
| 293 |
BIT(NL80211_IFTYPE_ADHOC) | |
| 294 |
BIT(NL80211_IFTYPE_AP) | |
| 295 |
BIT(NL80211_IFTYPE_MESH_POINT) | |
| 296 |
BIT(NL80211_IFTYPE_P2P_CLIENT) | |
| 297 |
BIT(NL80211_IFTYPE_P2P_GO); |
| 298 |
|
| 299 |
#ifdef CONFIG_PM |
| 300 |
hw->wiphy->wowlan = &cw1200_wowlan_support; |
| 301 |
#endif |
| 302 |
|
| 303 |
hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD; |
| 304 |
|
| 305 |
hw->queues = 4; |
| 306 |
|
| 307 |
priv->rts_threshold = -1; |
| 308 |
|
| 309 |
hw->max_rates = 8; |
| 310 |
hw->max_rate_tries = 15; |
| 311 |
hw->extra_tx_headroom = WSM_TX_EXTRA_HEADROOM + |
| 312 |
8; /* TKIP IV */ |
| 313 |
|
| 314 |
hw->sta_data_size = sizeof(struct cw1200_sta_priv); |
| 315 |
|
| 316 |
hw->wiphy->bands[NL80211_BAND_2GHZ] = &cw1200_band_2ghz; |
| 317 |
if (have_5ghz) |
| 318 |
hw->wiphy->bands[NL80211_BAND_5GHZ] = &cw1200_band_5ghz; |
| 319 |
|
| 320 |
/* Channel params have to be cleared before registering wiphy again */ |
| 321 |
for (band = 0; band < NUM_NL80211_BANDS; band++) { |
| 322 |
struct ieee80211_supported_band *sband = hw->wiphy->bands[band]; |
| 323 |
if (!sband) |
| 324 |
continue; |
| 325 |
for (i = 0; i < sband->n_channels; i++) { |
| 326 |
sband->channels[i].flags = 0; |
| 327 |
sband->channels[i].max_antenna_gain = 0; |
| 328 |
sband->channels[i].max_power = 30; |
| 329 |
} |
| 330 |
} |
| 331 |
|
| 332 |
hw->wiphy->max_scan_ssids = 2; |
| 333 |
hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN; |
| 334 |
|
| 335 |
if (macaddr) |
| 336 |
SET_IEEE80211_PERM_ADDR(hw, (u8 *)macaddr); |
| 337 |
else |
| 338 |
SET_IEEE80211_PERM_ADDR(hw, cw1200_mac_template); |
| 339 |
|
| 340 |
/* Fix up mac address if necessary */ |
| 341 |
if (hw->wiphy->perm_addr[3] == 0 && |
| 342 |
hw->wiphy->perm_addr[4] == 0 && |
| 343 |
hw->wiphy->perm_addr[5] == 0) { |
| 344 |
get_random_bytes(&hw->wiphy->perm_addr[3], 3); |
| 345 |
} |
| 346 |
|
| 347 |
mutex_init(&priv->wsm_cmd_mux); |
| 348 |
mutex_init(&priv->conf_mutex); |
| 349 |
priv->workqueue = create_singlethread_workqueue("cw1200_wq"); |
| 350 |
if (!priv->workqueue) { |
| 351 |
ieee80211_free_hw(hw); |
| 352 |
return NULL; |
| 353 |
} |
| 354 |
|
| 355 |
sema_init(&priv->scan.lock, 1); |
| 356 |
INIT_WORK(&priv->scan.work, cw1200_scan_work); |
| 357 |
INIT_DELAYED_WORK(&priv->scan.probe_work, cw1200_probe_work); |
| 358 |
INIT_DELAYED_WORK(&priv->scan.timeout, cw1200_scan_timeout); |
| 359 |
INIT_DELAYED_WORK(&priv->clear_recent_scan_work, |
| 360 |
cw1200_clear_recent_scan_work); |
| 361 |
INIT_DELAYED_WORK(&priv->join_timeout, cw1200_join_timeout); |
| 362 |
INIT_WORK(&priv->unjoin_work, cw1200_unjoin_work); |
| 363 |
INIT_WORK(&priv->join_complete_work, cw1200_join_complete_work); |
| 364 |
INIT_WORK(&priv->wep_key_work, cw1200_wep_key_work); |
| 365 |
INIT_WORK(&priv->tx_policy_upload_work, tx_policy_upload_work); |
| 366 |
spin_lock_init(&priv->event_queue_lock); |
| 367 |
INIT_LIST_HEAD(&priv->event_queue); |
| 368 |
INIT_WORK(&priv->event_handler, cw1200_event_handler); |
| 369 |
INIT_DELAYED_WORK(&priv->bss_loss_work, cw1200_bss_loss_work); |
| 370 |
INIT_WORK(&priv->bss_params_work, cw1200_bss_params_work); |
| 371 |
spin_lock_init(&priv->bss_loss_lock); |
| 372 |
spin_lock_init(&priv->ps_state_lock); |
| 373 |
INIT_WORK(&priv->set_cts_work, cw1200_set_cts_work); |
| 374 |
INIT_WORK(&priv->set_tim_work, cw1200_set_tim_work); |
| 375 |
INIT_WORK(&priv->multicast_start_work, cw1200_multicast_start_work); |
| 376 |
INIT_WORK(&priv->multicast_stop_work, cw1200_multicast_stop_work); |
| 377 |
INIT_WORK(&priv->link_id_work, cw1200_link_id_work); |
| 378 |
INIT_DELAYED_WORK(&priv->link_id_gc_work, cw1200_link_id_gc_work); |
| 379 |
INIT_WORK(&priv->linkid_reset_work, cw1200_link_id_reset); |
| 380 |
INIT_WORK(&priv->update_filtering_work, cw1200_update_filtering_work); |
| 381 |
INIT_WORK(&priv->set_beacon_wakeup_period_work, |
| 382 |
cw1200_set_beacon_wakeup_period_work); |
| 383 |
timer_setup(&priv->mcast_timeout, cw1200_mcast_timeout, 0); |
| 384 |
|
| 385 |
if (cw1200_queue_stats_init(&priv->tx_queue_stats, |
| 386 |
CW1200_LINK_ID_MAX, |
| 387 |
cw1200_skb_dtor, |
| 388 |
priv)) { |
| 389 |
destroy_workqueue(priv->workqueue); |
| 390 |
ieee80211_free_hw(hw); |
| 391 |
return NULL; |
| 392 |
} |
| 393 |
|
| 394 |
for (i = 0; i < 4; ++i) { |
| 395 |
if (cw1200_queue_init(&priv->tx_queue[i], |
| 396 |
&priv->tx_queue_stats, i, 16, |
| 397 |
cw1200_ttl[i])) { |
| 398 |
for (; i > 0; i--) |
| 399 |
cw1200_queue_deinit(&priv->tx_queue[i - 1]); |
| 400 |
cw1200_queue_stats_deinit(&priv->tx_queue_stats); |
| 401 |
destroy_workqueue(priv->workqueue); |
| 402 |
ieee80211_free_hw(hw); |
| 403 |
return NULL; |
| 404 |
} |
| 405 |
} |
| 406 |
|
| 407 |
init_waitqueue_head(&priv->channel_switch_done); |
| 408 |
init_waitqueue_head(&priv->wsm_cmd_wq); |
| 409 |
init_waitqueue_head(&priv->wsm_startup_done); |
| 410 |
init_waitqueue_head(&priv->ps_mode_switch_done); |
| 411 |
wsm_buf_init(&priv->wsm_cmd_buf); |
| 412 |
spin_lock_init(&priv->wsm_cmd.lock); |
| 413 |
priv->wsm_cmd.done = 1; |
| 414 |
tx_policy_init(priv); |
| 415 |
|
| 416 |
return hw; |
| 417 |
} |
| 418 |
|
| 419 |
static int cw1200_register_common(struct ieee80211_hw *dev) |
| 420 |
{ |
| 421 |
struct cw1200_common *priv = dev->priv; |
| 422 |
int err; |
| 423 |
|
| 424 |
#ifdef CONFIG_PM |
| 425 |
err = cw1200_pm_init(&priv->pm_state, priv); |
| 426 |
if (err) { |
| 427 |
pr_err("Cannot init PM. (%d).\n", |
| 428 |
err); |
| 429 |
return err; |
| 430 |
} |
| 431 |
#endif |
| 432 |
|
| 433 |
err = ieee80211_register_hw(dev); |
| 434 |
if (err) { |
| 435 |
pr_err("Cannot register device (%d).\n", |
| 436 |
err); |
| 437 |
#ifdef CONFIG_PM |
| 438 |
cw1200_pm_deinit(&priv->pm_state); |
| 439 |
#endif |
| 440 |
return err; |
| 441 |
} |
| 442 |
|
| 443 |
cw1200_debug_init(priv); |
| 444 |
|
| 445 |
pr_info("Registered as '%s'\n", wiphy_name(dev->wiphy)); |
| 446 |
return 0; |
| 447 |
} |
| 448 |
|
| 449 |
static void cw1200_free_common(struct ieee80211_hw *dev) |
| 450 |
{ |
| 451 |
ieee80211_free_hw(dev); |
| 452 |
} |
| 453 |
|
| 454 |
static void cw1200_unregister_common(struct ieee80211_hw *dev) |
| 455 |
{ |
| 456 |
struct cw1200_common *priv = dev->priv; |
| 457 |
int i; |
| 458 |
|
| 459 |
ieee80211_unregister_hw(dev); |
| 460 |
|
| 461 |
timer_delete_sync(&priv->mcast_timeout); |
| 462 |
cw1200_unregister_bh(priv); |
| 463 |
|
| 464 |
cw1200_debug_release(priv); |
| 465 |
|
| 466 |
mutex_destroy(&priv->conf_mutex); |
| 467 |
|
| 468 |
wsm_buf_deinit(&priv->wsm_cmd_buf); |
| 469 |
|
| 470 |
destroy_workqueue(priv->workqueue); |
| 471 |
priv->workqueue = NULL; |
| 472 |
|
| 473 |
if (priv->sdd) { |
| 474 |
release_firmware(priv->sdd); |
| 475 |
priv->sdd = NULL; |
| 476 |
} |
| 477 |
|
| 478 |
for (i = 0; i < 4; ++i) |
| 479 |
cw1200_queue_deinit(&priv->tx_queue[i]); |
| 480 |
|
| 481 |
cw1200_queue_stats_deinit(&priv->tx_queue_stats); |
| 482 |
#ifdef CONFIG_PM |
| 483 |
cw1200_pm_deinit(&priv->pm_state); |
| 484 |
#endif |
| 485 |
} |
| 486 |
|
| 487 |
/* Clock is in KHz */ |
| 488 |
u32 cw1200_dpll_from_clk(u16 clk_khz) |
| 489 |
{ |
| 490 |
switch (clk_khz) { |
| 491 |
case 0x32C8: /* 13000 KHz */ |
| 492 |
return 0x1D89D241; |
| 493 |
case 0x3E80: /* 16000 KHz */ |
| 494 |
return 0x000001E1; |
| 495 |
case 0x41A0: /* 16800 KHz */ |
| 496 |
return 0x124931C1; |
| 497 |
case 0x4B00: /* 19200 KHz */ |
| 498 |
return 0x00000191; |
| 499 |
case 0x5DC0: /* 24000 KHz */ |
| 500 |
return 0x00000141; |
| 501 |
case 0x6590: /* 26000 KHz */ |
| 502 |
return 0x0EC4F121; |
| 503 |
case 0x8340: /* 33600 KHz */ |
| 504 |
return 0x092490E1; |
| 505 |
case 0x9600: /* 38400 KHz */ |
| 506 |
return 0x100010C1; |
| 507 |
case 0x9C40: /* 40000 KHz */ |
| 508 |
return 0x000000C1; |
| 509 |
case 0xBB80: /* 48000 KHz */ |
| 510 |
return 0x000000A1; |
| 511 |
case 0xCB20: /* 52000 KHz */ |
| 512 |
return 0x07627091; |
| 513 |
default: |
| 514 |
pr_err("Unknown Refclk freq (0x%04x), using 26000KHz\n", |
| 515 |
clk_khz); |
| 516 |
return 0x0EC4F121; |
| 517 |
} |
| 518 |
} |
| 519 |
|
| 520 |
int cw1200_core_probe(const struct hwbus_ops *hwbus_ops, |
| 521 |
struct hwbus_priv *hwbus, |
| 522 |
struct device *pdev, |
| 523 |
struct cw1200_common **core, |
| 524 |
int ref_clk, const u8 *macaddr, |
| 525 |
const char *sdd_path, bool have_5ghz) |
| 526 |
{ |
| 527 |
int err = -EINVAL; |
| 528 |
struct ieee80211_hw *dev; |
| 529 |
struct cw1200_common *priv; |
| 530 |
struct wsm_operational_mode mode = { |
| 531 |
.power_mode = cw1200_power_mode, |
| 532 |
.disable_more_flag_usage = true, |
| 533 |
}; |
| 534 |
|
| 535 |
dev = cw1200_init_common(macaddr, have_5ghz); |
| 536 |
if (!dev) |
| 537 |
goto err; |
| 538 |
|
| 539 |
priv = dev->priv; |
| 540 |
priv->hw_refclk = ref_clk; |
| 541 |
if (cw1200_refclk) |
| 542 |
priv->hw_refclk = cw1200_refclk; |
| 543 |
|
| 544 |
priv->sdd_path = (char *)sdd_path; |
| 545 |
if (cw1200_sdd_path) |
| 546 |
priv->sdd_path = cw1200_sdd_path; |
| 547 |
|
| 548 |
priv->hwbus_ops = hwbus_ops; |
| 549 |
priv->hwbus_priv = hwbus; |
| 550 |
priv->pdev = pdev; |
| 551 |
SET_IEEE80211_DEV(priv->hw, pdev); |
| 552 |
|
| 553 |
/* Pass struct cw1200_common back up */ |
| 554 |
*core = priv; |
| 555 |
|
| 556 |
err = cw1200_register_bh(priv); |
| 557 |
if (err) |
| 558 |
goto err1; |
| 559 |
|
| 560 |
err = cw1200_load_firmware(priv); |
| 561 |
if (err) |
| 562 |
goto err2; |
| 563 |
|
| 564 |
if (wait_event_interruptible_timeout(priv->wsm_startup_done, |
| 565 |
priv->firmware_ready, |
| 566 |
3*HZ) <= 0) { |
| 567 |
/* TODO: Need to find how to reset device |
| 568 |
in QUEUE mode properly. |
| 569 |
*/ |
| 570 |
pr_err("Timeout waiting on device startup\n"); |
| 571 |
err = -ETIMEDOUT; |
| 572 |
goto err2; |
| 573 |
} |
| 574 |
|
| 575 |
/* Set low-power mode. */ |
| 576 |
wsm_set_operational_mode(priv, &mode); |
| 577 |
|
| 578 |
/* Enable multi-TX confirmation */ |
| 579 |
wsm_use_multi_tx_conf(priv, true); |
| 580 |
|
| 581 |
err = cw1200_register_common(dev); |
| 582 |
if (err) |
| 583 |
goto err2; |
| 584 |
|
| 585 |
return err; |
| 586 |
|
| 587 |
err2: |
| 588 |
cw1200_unregister_bh(priv); |
| 589 |
err1: |
| 590 |
cw1200_free_common(dev); |
| 591 |
err: |
| 592 |
*core = NULL; |
| 593 |
return err; |
| 594 |
} |
| 595 |
EXPORT_SYMBOL_GPL(cw1200_core_probe); |
| 596 |
|
| 597 |
void cw1200_core_release(struct cw1200_common *self) |
| 598 |
{ |
| 599 |
/* Disable device interrupts */ |
| 600 |
self->hwbus_ops->lock(self->hwbus_priv); |
| 601 |
__cw1200_irq_enable(self, 0); |
| 602 |
self->hwbus_ops->unlock(self->hwbus_priv); |
| 603 |
|
| 604 |
/* And then clean up */ |
| 605 |
cw1200_unregister_common(self->hw); |
| 606 |
cw1200_free_common(self->hw); |
| 607 |
return; |
| 608 |
} |
| 609 |
EXPORT_SYMBOL_GPL(cw1200_core_release); |