2 * mac80211 glue code for mac80211 ST-Ericsson CW1200 drivers
4 * Copyright (c) 2010, ST-Ericsson
5 * Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
8 * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
9 * Copyright (c) 2007-2009, Christian Lamparter <chunkeey@web.de>
10 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
13 * - the islsm (softmac prism54) driver, which is:
14 * Copyright 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
16 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
18 * This program is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License version 2 as
20 * published by the Free Software Foundation.
23 #include <linux/module.h>
24 #include <linux/firmware.h>
25 #include <linux/etherdevice.h>
26 #include <linux/vmalloc.h>
27 #include <linux/random.h>
28 #include <linux/sched.h>
29 #include <net/mac80211.h>
42 MODULE_AUTHOR("Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>");
43 MODULE_DESCRIPTION("Softmac ST-Ericsson CW1200 common code");
44 MODULE_LICENSE("GPL");
45 MODULE_ALIAS("cw1200_core");
47 /* Accept MAC address of the form macaddr=0x00,0x80,0xE1,0x30,0x40,0x50 */
48 static u8 cw1200_mac_template[ETH_ALEN] = {0x02, 0x80, 0xe1, 0x00, 0x00, 0x00};
49 module_param_array_named(macaddr, cw1200_mac_template, byte, NULL, S_IRUGO);
50 MODULE_PARM_DESC(macaddr, "Override platform_data MAC address");
52 static char *cw1200_sdd_path;
53 module_param(cw1200_sdd_path, charp, 0644);
54 MODULE_PARM_DESC(cw1200_sdd_path, "Override platform_data SDD file");
55 static int cw1200_refclk;
56 module_param(cw1200_refclk, int, 0644);
57 MODULE_PARM_DESC(cw1200_refclk, "Override platform_data reference clock");
59 int cw1200_power_mode = wsm_power_mode_quiescent;
60 module_param(cw1200_power_mode, int, 0644);
61 MODULE_PARM_DESC(cw1200_power_mode, "WSM power mode. 0 == active, 1 == doze, 2 == quiescent (default)");
63 #define RATETAB_ENT(_rate, _rateid, _flags) \
66 .hw_value = (_rateid), \
70 static struct ieee80211_rate cw1200_rates[] = {
71 RATETAB_ENT(10, 0, 0),
72 RATETAB_ENT(20, 1, 0),
73 RATETAB_ENT(55, 2, 0),
74 RATETAB_ENT(110, 3, 0),
75 RATETAB_ENT(60, 6, 0),
76 RATETAB_ENT(90, 7, 0),
77 RATETAB_ENT(120, 8, 0),
78 RATETAB_ENT(180, 9, 0),
79 RATETAB_ENT(240, 10, 0),
80 RATETAB_ENT(360, 11, 0),
81 RATETAB_ENT(480, 12, 0),
82 RATETAB_ENT(540, 13, 0),
85 static struct ieee80211_rate cw1200_mcs_rates[] = {
86 RATETAB_ENT(65, 14, IEEE80211_TX_RC_MCS),
87 RATETAB_ENT(130, 15, IEEE80211_TX_RC_MCS),
88 RATETAB_ENT(195, 16, IEEE80211_TX_RC_MCS),
89 RATETAB_ENT(260, 17, IEEE80211_TX_RC_MCS),
90 RATETAB_ENT(390, 18, IEEE80211_TX_RC_MCS),
91 RATETAB_ENT(520, 19, IEEE80211_TX_RC_MCS),
92 RATETAB_ENT(585, 20, IEEE80211_TX_RC_MCS),
93 RATETAB_ENT(650, 21, IEEE80211_TX_RC_MCS),
96 #define cw1200_a_rates (cw1200_rates + 4)
97 #define cw1200_a_rates_size (ARRAY_SIZE(cw1200_rates) - 4)
98 #define cw1200_g_rates (cw1200_rates + 0)
99 #define cw1200_g_rates_size (ARRAY_SIZE(cw1200_rates))
100 #define cw1200_n_rates (cw1200_mcs_rates)
101 #define cw1200_n_rates_size (ARRAY_SIZE(cw1200_mcs_rates))
104 #define CHAN2G(_channel, _freq, _flags) { \
105 .band = IEEE80211_BAND_2GHZ, \
106 .center_freq = (_freq), \
107 .hw_value = (_channel), \
109 .max_antenna_gain = 0, \
113 #define CHAN5G(_channel, _flags) { \
114 .band = IEEE80211_BAND_5GHZ, \
115 .center_freq = 5000 + (5 * (_channel)), \
116 .hw_value = (_channel), \
118 .max_antenna_gain = 0, \
122 static struct ieee80211_channel cw1200_2ghz_chantable[] = {
139 static struct ieee80211_channel cw1200_5ghz_chantable[] = {
140 CHAN5G(34, 0), CHAN5G(36, 0),
141 CHAN5G(38, 0), CHAN5G(40, 0),
142 CHAN5G(42, 0), CHAN5G(44, 0),
143 CHAN5G(46, 0), CHAN5G(48, 0),
144 CHAN5G(52, 0), CHAN5G(56, 0),
145 CHAN5G(60, 0), CHAN5G(64, 0),
146 CHAN5G(100, 0), CHAN5G(104, 0),
147 CHAN5G(108, 0), CHAN5G(112, 0),
148 CHAN5G(116, 0), CHAN5G(120, 0),
149 CHAN5G(124, 0), CHAN5G(128, 0),
150 CHAN5G(132, 0), CHAN5G(136, 0),
151 CHAN5G(140, 0), CHAN5G(149, 0),
152 CHAN5G(153, 0), CHAN5G(157, 0),
153 CHAN5G(161, 0), CHAN5G(165, 0),
154 CHAN5G(184, 0), CHAN5G(188, 0),
155 CHAN5G(192, 0), CHAN5G(196, 0),
156 CHAN5G(200, 0), CHAN5G(204, 0),
157 CHAN5G(208, 0), CHAN5G(212, 0),
161 static struct ieee80211_supported_band cw1200_band_2ghz = {
162 .channels = cw1200_2ghz_chantable,
163 .n_channels = ARRAY_SIZE(cw1200_2ghz_chantable),
164 .bitrates = cw1200_g_rates,
165 .n_bitrates = cw1200_g_rates_size,
167 .cap = IEEE80211_HT_CAP_GRN_FLD |
168 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT) |
169 IEEE80211_HT_CAP_MAX_AMSDU,
171 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K,
172 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE,
175 .rx_highest = __cpu_to_le16(0x41),
176 .tx_params = IEEE80211_HT_MCS_TX_DEFINED,
181 static struct ieee80211_supported_band cw1200_band_5ghz = {
182 .channels = cw1200_5ghz_chantable,
183 .n_channels = ARRAY_SIZE(cw1200_5ghz_chantable),
184 .bitrates = cw1200_a_rates,
185 .n_bitrates = cw1200_a_rates_size,
187 .cap = IEEE80211_HT_CAP_GRN_FLD |
188 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT) |
189 IEEE80211_HT_CAP_MAX_AMSDU,
191 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K,
192 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE,
195 .rx_highest = __cpu_to_le16(0x41),
196 .tx_params = IEEE80211_HT_MCS_TX_DEFINED,
201 static const unsigned long cw1200_ttl[] = {
208 static const struct ieee80211_ops cw1200_ops = {
209 .start = cw1200_start,
211 .add_interface = cw1200_add_interface,
212 .remove_interface = cw1200_remove_interface,
213 .change_interface = cw1200_change_interface,
215 .hw_scan = cw1200_hw_scan,
216 .set_tim = cw1200_set_tim,
217 .sta_notify = cw1200_sta_notify,
218 .sta_add = cw1200_sta_add,
219 .sta_remove = cw1200_sta_remove,
220 .set_key = cw1200_set_key,
221 .set_rts_threshold = cw1200_set_rts_threshold,
222 .config = cw1200_config,
223 .bss_info_changed = cw1200_bss_info_changed,
224 .prepare_multicast = cw1200_prepare_multicast,
225 .configure_filter = cw1200_configure_filter,
226 .conf_tx = cw1200_conf_tx,
227 .get_stats = cw1200_get_stats,
228 .ampdu_action = cw1200_ampdu_action,
229 .flush = cw1200_flush,
231 .suspend = cw1200_wow_suspend,
232 .resume = cw1200_wow_resume,
234 /* Intentionally not offloaded: */
235 /*.channel_switch = cw1200_channel_switch, */
236 /*.remain_on_channel = cw1200_remain_on_channel, */
237 /*.cancel_remain_on_channel = cw1200_cancel_remain_on_channel, */
240 static int cw1200_ba_rx_tids = -1;
241 static int cw1200_ba_tx_tids = -1;
242 module_param(cw1200_ba_rx_tids, int, 0644);
243 module_param(cw1200_ba_tx_tids, int, 0644);
244 MODULE_PARM_DESC(cw1200_ba_rx_tids, "Block ACK RX TIDs");
245 MODULE_PARM_DESC(cw1200_ba_tx_tids, "Block ACK TX TIDs");
248 static const struct wiphy_wowlan_support cw1200_wowlan_support = {
249 /* Support only for limited wowlan functionalities */
250 .flags = WIPHY_WOWLAN_ANY | WIPHY_WOWLAN_DISCONNECT,
255 static struct ieee80211_hw *cw1200_init_common(const u8 *macaddr,
256 const bool have_5ghz)
259 struct ieee80211_hw *hw;
260 struct cw1200_common *priv;
262 hw = ieee80211_alloc_hw(sizeof(struct cw1200_common), &cw1200_ops);
269 priv->mode = NL80211_IFTYPE_UNSPECIFIED;
270 priv->rates = cw1200_rates; /* TODO: fetch from FW */
271 priv->mcs_rates = cw1200_n_rates;
272 if (cw1200_ba_rx_tids != -1)
273 priv->ba_rx_tid_mask = cw1200_ba_rx_tids;
275 priv->ba_rx_tid_mask = 0xFF; /* Enable RX BLKACK for all TIDs */
276 if (cw1200_ba_tx_tids != -1)
277 priv->ba_tx_tid_mask = cw1200_ba_tx_tids;
279 priv->ba_tx_tid_mask = 0xff; /* Enable TX BLKACK for all TIDs */
281 hw->flags = IEEE80211_HW_SIGNAL_DBM |
282 IEEE80211_HW_SUPPORTS_PS |
283 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
284 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
285 IEEE80211_HW_SUPPORTS_UAPSD |
286 IEEE80211_HW_CONNECTION_MONITOR |
287 IEEE80211_HW_AMPDU_AGGREGATION |
288 IEEE80211_HW_TX_AMPDU_SETUP_IN_HW |
289 IEEE80211_HW_NEED_DTIM_BEFORE_ASSOC;
291 hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
292 BIT(NL80211_IFTYPE_ADHOC) |
293 BIT(NL80211_IFTYPE_AP) |
294 BIT(NL80211_IFTYPE_MESH_POINT) |
295 BIT(NL80211_IFTYPE_P2P_CLIENT) |
296 BIT(NL80211_IFTYPE_P2P_GO);
299 hw->wiphy->wowlan = &cw1200_wowlan_support;
302 hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
306 priv->rts_threshold = -1;
309 hw->max_rate_tries = 15;
310 hw->extra_tx_headroom = WSM_TX_EXTRA_HEADROOM +
313 hw->sta_data_size = sizeof(struct cw1200_sta_priv);
315 hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &cw1200_band_2ghz;
317 hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &cw1200_band_5ghz;
319 /* Channel params have to be cleared before registering wiphy again */
320 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
321 struct ieee80211_supported_band *sband = hw->wiphy->bands[band];
324 for (i = 0; i < sband->n_channels; i++) {
325 sband->channels[i].flags = 0;
326 sband->channels[i].max_antenna_gain = 0;
327 sband->channels[i].max_power = 30;
331 hw->wiphy->max_scan_ssids = 2;
332 hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
335 SET_IEEE80211_PERM_ADDR(hw, (u8 *)macaddr);
337 SET_IEEE80211_PERM_ADDR(hw, cw1200_mac_template);
339 /* Fix up mac address if necessary */
340 if (hw->wiphy->perm_addr[3] == 0 &&
341 hw->wiphy->perm_addr[4] == 0 &&
342 hw->wiphy->perm_addr[5] == 0) {
343 get_random_bytes(&hw->wiphy->perm_addr[3], 3);
346 mutex_init(&priv->wsm_cmd_mux);
347 mutex_init(&priv->conf_mutex);
348 priv->workqueue = create_singlethread_workqueue("cw1200_wq");
349 sema_init(&priv->scan.lock, 1);
350 INIT_WORK(&priv->scan.work, cw1200_scan_work);
351 INIT_DELAYED_WORK(&priv->scan.probe_work, cw1200_probe_work);
352 INIT_DELAYED_WORK(&priv->scan.timeout, cw1200_scan_timeout);
353 INIT_DELAYED_WORK(&priv->clear_recent_scan_work,
354 cw1200_clear_recent_scan_work);
355 INIT_DELAYED_WORK(&priv->join_timeout, cw1200_join_timeout);
356 INIT_WORK(&priv->unjoin_work, cw1200_unjoin_work);
357 INIT_WORK(&priv->join_complete_work, cw1200_join_complete_work);
358 INIT_WORK(&priv->wep_key_work, cw1200_wep_key_work);
359 INIT_WORK(&priv->tx_policy_upload_work, tx_policy_upload_work);
360 spin_lock_init(&priv->event_queue_lock);
361 INIT_LIST_HEAD(&priv->event_queue);
362 INIT_WORK(&priv->event_handler, cw1200_event_handler);
363 INIT_DELAYED_WORK(&priv->bss_loss_work, cw1200_bss_loss_work);
364 INIT_WORK(&priv->bss_params_work, cw1200_bss_params_work);
365 spin_lock_init(&priv->bss_loss_lock);
366 spin_lock_init(&priv->ps_state_lock);
367 INIT_WORK(&priv->set_cts_work, cw1200_set_cts_work);
368 INIT_WORK(&priv->set_tim_work, cw1200_set_tim_work);
369 INIT_WORK(&priv->multicast_start_work, cw1200_multicast_start_work);
370 INIT_WORK(&priv->multicast_stop_work, cw1200_multicast_stop_work);
371 INIT_WORK(&priv->link_id_work, cw1200_link_id_work);
372 INIT_DELAYED_WORK(&priv->link_id_gc_work, cw1200_link_id_gc_work);
373 INIT_WORK(&priv->linkid_reset_work, cw1200_link_id_reset);
374 INIT_WORK(&priv->update_filtering_work, cw1200_update_filtering_work);
375 INIT_WORK(&priv->set_beacon_wakeup_period_work,
376 cw1200_set_beacon_wakeup_period_work);
377 setup_timer(&priv->mcast_timeout, cw1200_mcast_timeout,
378 (unsigned long)priv);
380 if (cw1200_queue_stats_init(&priv->tx_queue_stats,
384 ieee80211_free_hw(hw);
388 for (i = 0; i < 4; ++i) {
389 if (cw1200_queue_init(&priv->tx_queue[i],
390 &priv->tx_queue_stats, i, 16,
393 cw1200_queue_deinit(&priv->tx_queue[i - 1]);
394 cw1200_queue_stats_deinit(&priv->tx_queue_stats);
395 ieee80211_free_hw(hw);
400 init_waitqueue_head(&priv->channel_switch_done);
401 init_waitqueue_head(&priv->wsm_cmd_wq);
402 init_waitqueue_head(&priv->wsm_startup_done);
403 init_waitqueue_head(&priv->ps_mode_switch_done);
404 wsm_buf_init(&priv->wsm_cmd_buf);
405 spin_lock_init(&priv->wsm_cmd.lock);
406 priv->wsm_cmd.done = 1;
407 tx_policy_init(priv);
412 static int cw1200_register_common(struct ieee80211_hw *dev)
414 struct cw1200_common *priv = dev->priv;
418 err = cw1200_pm_init(&priv->pm_state, priv);
420 pr_err("Cannot init PM. (%d).\n",
426 err = ieee80211_register_hw(dev);
428 pr_err("Cannot register device (%d).\n",
431 cw1200_pm_deinit(&priv->pm_state);
436 cw1200_debug_init(priv);
438 pr_info("Registered as '%s'\n", wiphy_name(dev->wiphy));
442 static void cw1200_free_common(struct ieee80211_hw *dev)
444 ieee80211_free_hw(dev);
447 static void cw1200_unregister_common(struct ieee80211_hw *dev)
449 struct cw1200_common *priv = dev->priv;
452 ieee80211_unregister_hw(dev);
454 del_timer_sync(&priv->mcast_timeout);
455 cw1200_unregister_bh(priv);
457 cw1200_debug_release(priv);
459 mutex_destroy(&priv->conf_mutex);
461 wsm_buf_deinit(&priv->wsm_cmd_buf);
463 destroy_workqueue(priv->workqueue);
464 priv->workqueue = NULL;
467 release_firmware(priv->sdd);
471 for (i = 0; i < 4; ++i)
472 cw1200_queue_deinit(&priv->tx_queue[i]);
474 cw1200_queue_stats_deinit(&priv->tx_queue_stats);
476 cw1200_pm_deinit(&priv->pm_state);
480 /* Clock is in KHz */
481 u32 cw1200_dpll_from_clk(u16 clk_khz)
484 case 0x32C8: /* 13000 KHz */
486 case 0x3E80: /* 16000 KHz */
488 case 0x41A0: /* 16800 KHz */
490 case 0x4B00: /* 19200 KHz */
492 case 0x5DC0: /* 24000 KHz */
494 case 0x6590: /* 26000 KHz */
496 case 0x8340: /* 33600 KHz */
498 case 0x9600: /* 38400 KHz */
500 case 0x9C40: /* 40000 KHz */
502 case 0xBB80: /* 48000 KHz */
504 case 0xCB20: /* 52000 KHz */
507 pr_err("Unknown Refclk freq (0x%04x), using 26000KHz\n",
513 int cw1200_core_probe(const struct hwbus_ops *hwbus_ops,
514 struct hwbus_priv *hwbus,
516 struct cw1200_common **core,
517 int ref_clk, const u8 *macaddr,
518 const char *sdd_path, bool have_5ghz)
521 struct ieee80211_hw *dev;
522 struct cw1200_common *priv;
523 struct wsm_operational_mode mode = {
524 .power_mode = cw1200_power_mode,
525 .disable_more_flag_usage = true,
528 dev = cw1200_init_common(macaddr, have_5ghz);
533 priv->hw_refclk = ref_clk;
535 priv->hw_refclk = cw1200_refclk;
537 priv->sdd_path = (char *)sdd_path;
539 priv->sdd_path = cw1200_sdd_path;
541 priv->hwbus_ops = hwbus_ops;
542 priv->hwbus_priv = hwbus;
544 SET_IEEE80211_DEV(priv->hw, pdev);
546 /* Pass struct cw1200_common back up */
549 err = cw1200_register_bh(priv);
553 err = cw1200_load_firmware(priv);
557 if (wait_event_interruptible_timeout(priv->wsm_startup_done,
558 priv->firmware_ready,
560 /* TODO: Need to find how to reset device
561 in QUEUE mode properly.
563 pr_err("Timeout waiting on device startup\n");
568 /* Set low-power mode. */
569 wsm_set_operational_mode(priv, &mode);
571 /* Enable multi-TX confirmation */
572 wsm_use_multi_tx_conf(priv, true);
574 err = cw1200_register_common(dev);
581 cw1200_unregister_bh(priv);
583 cw1200_free_common(dev);
588 EXPORT_SYMBOL_GPL(cw1200_core_probe);
590 void cw1200_core_release(struct cw1200_common *self)
592 /* Disable device interrupts */
593 self->hwbus_ops->lock(self->hwbus_priv);
594 __cw1200_irq_enable(self, 0);
595 self->hwbus_ops->unlock(self->hwbus_priv);
597 /* And then clean up */
598 cw1200_unregister_common(self->hw);
599 cw1200_free_common(self->hw);
602 EXPORT_SYMBOL_GPL(cw1200_core_release);