[mirror_ubuntu-jammy-kernel.git] / drivers / net / wireless / st / cw1200 / main.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * mac80211 glue code for mac80211 ST-Ericsson CW1200 drivers
 *
 * Copyright (c) 2010, ST-Ericsson
 * Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
 *
 * Based on:
 * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
 * Copyright (c) 2007-2009, Christian Lamparter <chunkeey@web.de>
 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
 *
 * Based on:
 * - the islsm (softmac prism54) driver, which is:
 *   Copyright 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
 * - stlc45xx driver
 *   Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
 */

#include <linux/module.h>
#include <linux/firmware.h>
#include <linux/etherdevice.h>
#include <linux/vmalloc.h>
#include <linux/random.h>
#include <linux/sched.h>
#include <net/mac80211.h>

#include "cw1200.h"
#include "txrx.h"
#include "hwbus.h"
#include "fwio.h"
#include "hwio.h"
#include "bh.h"
#include "sta.h"
#include "scan.h"
#include "debug.h"
#include "pm.h"

MODULE_AUTHOR("Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>");
MODULE_DESCRIPTION("Softmac ST-Ericsson CW1200 common code");
MODULE_LICENSE("GPL");
MODULE_ALIAS("cw1200_core");

/* Accept MAC address of the form macaddr=0x00,0x80,0xE1,0x30,0x40,0x50 */
static u8 cw1200_mac_template[ETH_ALEN] = {0x02, 0x80, 0xe1, 0x00, 0x00, 0x00};
module_param_array_named(macaddr, cw1200_mac_template, byte, NULL, 0444);
MODULE_PARM_DESC(macaddr, "Override platform_data MAC address");

static char *cw1200_sdd_path;
module_param(cw1200_sdd_path, charp, 0644);
MODULE_PARM_DESC(cw1200_sdd_path, "Override platform_data SDD file");
static int cw1200_refclk;
module_param(cw1200_refclk, int, 0644);
MODULE_PARM_DESC(cw1200_refclk, "Override platform_data reference clock");

int cw1200_power_mode = wsm_power_mode_quiescent;
module_param(cw1200_power_mode, int, 0644);
MODULE_PARM_DESC(cw1200_power_mode, "WSM power mode.  0 == active, 1 == doze, 2 == quiescent (default)");

#define RATETAB_ENT(_rate, _rateid, _flags)		\
	{						\
		.bitrate	= (_rate),		\
		.hw_value	= (_rateid),		\
		.flags		= (_flags),		\
	}

static struct ieee80211_rate cw1200_rates[] = {
	RATETAB_ENT(10,  0,   0),
	RATETAB_ENT(20,  1,   0),
	RATETAB_ENT(55,  2,   0),
	RATETAB_ENT(110, 3,   0),
	RATETAB_ENT(60,  6,  0),
	RATETAB_ENT(90,  7,  0),
	RATETAB_ENT(120, 8,  0),
	RATETAB_ENT(180, 9,  0),
	RATETAB_ENT(240, 10, 0),
	RATETAB_ENT(360, 11, 0),
	RATETAB_ENT(480, 12, 0),
	RATETAB_ENT(540, 13, 0),
};

static struct ieee80211_rate cw1200_mcs_rates[] = {
	RATETAB_ENT(65,  14, IEEE80211_TX_RC_MCS),
	RATETAB_ENT(130, 15, IEEE80211_TX_RC_MCS),
	RATETAB_ENT(195, 16, IEEE80211_TX_RC_MCS),
	RATETAB_ENT(260, 17, IEEE80211_TX_RC_MCS),
	RATETAB_ENT(390, 18, IEEE80211_TX_RC_MCS),
	RATETAB_ENT(520, 19, IEEE80211_TX_RC_MCS),
	RATETAB_ENT(585, 20, IEEE80211_TX_RC_MCS),
	RATETAB_ENT(650, 21, IEEE80211_TX_RC_MCS),
};

#define cw1200_a_rates		(cw1200_rates + 4)
#define cw1200_a_rates_size	(ARRAY_SIZE(cw1200_rates) - 4)
#define cw1200_g_rates		(cw1200_rates + 0)
#define cw1200_g_rates_size	(ARRAY_SIZE(cw1200_rates))
#define cw1200_n_rates		(cw1200_mcs_rates)
#define cw1200_n_rates_size	(ARRAY_SIZE(cw1200_mcs_rates))


#define CHAN2G(_channel, _freq, _flags) {			\
	.band			= NL80211_BAND_2GHZ,		\
	.center_freq		= (_freq),			\
	.hw_value		= (_channel),			\
	.flags			= (_flags),			\
	.max_antenna_gain	= 0,				\
	.max_power		= 30,				\
}

#define CHAN5G(_channel, _flags) {				\
	.band			= NL80211_BAND_5GHZ,		\
	.center_freq	= 5000 + (5 * (_channel)),		\
	.hw_value		= (_channel),			\
	.flags			= (_flags),			\
	.max_antenna_gain	= 0,				\
	.max_power		= 30,				\
}

static struct ieee80211_channel cw1200_2ghz_chantable[] = {
	CHAN2G(1, 2412, 0),
	CHAN2G(2, 2417, 0),
	CHAN2G(3, 2422, 0),
	CHAN2G(4, 2427, 0),
	CHAN2G(5, 2432, 0),
	CHAN2G(6, 2437, 0),
	CHAN2G(7, 2442, 0),
	CHAN2G(8, 2447, 0),
	CHAN2G(9, 2452, 0),
	CHAN2G(10, 2457, 0),
	CHAN2G(11, 2462, 0),
	CHAN2G(12, 2467, 0),
	CHAN2G(13, 2472, 0),
	CHAN2G(14, 2484, 0),
};

static struct ieee80211_channel cw1200_5ghz_chantable[] = {
	CHAN5G(34, 0),		CHAN5G(36, 0),
	CHAN5G(38, 0),		CHAN5G(40, 0),
	CHAN5G(42, 0),		CHAN5G(44, 0),
	CHAN5G(46, 0),		CHAN5G(48, 0),
	CHAN5G(52, 0),		CHAN5G(56, 0),
	CHAN5G(60, 0),		CHAN5G(64, 0),
	CHAN5G(100, 0),		CHAN5G(104, 0),
	CHAN5G(108, 0),		CHAN5G(112, 0),
	CHAN5G(116, 0),		CHAN5G(120, 0),
	CHAN5G(124, 0),		CHAN5G(128, 0),
	CHAN5G(132, 0),		CHAN5G(136, 0),
	CHAN5G(140, 0),		CHAN5G(149, 0),
	CHAN5G(153, 0),		CHAN5G(157, 0),
	CHAN5G(161, 0),		CHAN5G(165, 0),
	CHAN5G(184, 0),		CHAN5G(188, 0),
	CHAN5G(192, 0),		CHAN5G(196, 0),
	CHAN5G(200, 0),		CHAN5G(204, 0),
	CHAN5G(208, 0),		CHAN5G(212, 0),
	CHAN5G(216, 0),
};

static struct ieee80211_supported_band cw1200_band_2ghz = {
	.channels = cw1200_2ghz_chantable,
	.n_channels = ARRAY_SIZE(cw1200_2ghz_chantable),
	.bitrates = cw1200_g_rates,
	.n_bitrates = cw1200_g_rates_size,
	.ht_cap = {
		.cap = IEEE80211_HT_CAP_GRN_FLD |
			(1 << IEEE80211_HT_CAP_RX_STBC_SHIFT) |
			IEEE80211_HT_CAP_MAX_AMSDU,
		.ht_supported = 1,
		.ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K,
		.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE,
		.mcs = {
			.rx_mask[0] = 0xFF,
			.rx_highest = __cpu_to_le16(0x41),
			.tx_params = IEEE80211_HT_MCS_TX_DEFINED,
		},
	},
};

static struct ieee80211_supported_band cw1200_band_5ghz = {
	.channels = cw1200_5ghz_chantable,
	.n_channels = ARRAY_SIZE(cw1200_5ghz_chantable),
	.bitrates = cw1200_a_rates,
	.n_bitrates = cw1200_a_rates_size,
	.ht_cap = {
		.cap = IEEE80211_HT_CAP_GRN_FLD |
			(1 << IEEE80211_HT_CAP_RX_STBC_SHIFT) |
			IEEE80211_HT_CAP_MAX_AMSDU,
		.ht_supported = 1,
		.ampdu_factor = IEEE80211_HT_MAX_AMPDU_8K,
		.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE,
		.mcs = {
			.rx_mask[0] = 0xFF,
			.rx_highest = __cpu_to_le16(0x41),
			.tx_params = IEEE80211_HT_MCS_TX_DEFINED,
		},
	},
};

static const unsigned long cw1200_ttl[] = {
	1 * HZ,	/* VO */
	2 * HZ,	/* VI */
	5 * HZ, /* BE */
	10 * HZ	/* BK */
};

static const struct ieee80211_ops cw1200_ops = {
	.start			= cw1200_start,
	.stop			= cw1200_stop,
	.add_interface		= cw1200_add_interface,
	.remove_interface	= cw1200_remove_interface,
	.change_interface	= cw1200_change_interface,
	.tx			= cw1200_tx,
	.hw_scan		= cw1200_hw_scan,
	.set_tim		= cw1200_set_tim,
	.sta_notify		= cw1200_sta_notify,
	.sta_add		= cw1200_sta_add,
	.sta_remove		= cw1200_sta_remove,
	.set_key		= cw1200_set_key,
	.set_rts_threshold	= cw1200_set_rts_threshold,
	.config			= cw1200_config,
	.bss_info_changed	= cw1200_bss_info_changed,
	.prepare_multicast	= cw1200_prepare_multicast,
	.configure_filter	= cw1200_configure_filter,
	.conf_tx		= cw1200_conf_tx,
	.get_stats		= cw1200_get_stats,
	.ampdu_action		= cw1200_ampdu_action,
	.flush			= cw1200_flush,
#ifdef CONFIG_PM
	.suspend		= cw1200_wow_suspend,
	.resume			= cw1200_wow_resume,
#endif
	/* Intentionally not offloaded:					*/
	/*.channel_switch	= cw1200_channel_switch,		*/
	/*.remain_on_channel	= cw1200_remain_on_channel,		*/
	/*.cancel_remain_on_channel = cw1200_cancel_remain_on_channel,	*/
};

static int cw1200_ba_rx_tids = -1;
static int cw1200_ba_tx_tids = -1;
module_param(cw1200_ba_rx_tids, int, 0644);
module_param(cw1200_ba_tx_tids, int, 0644);
MODULE_PARM_DESC(cw1200_ba_rx_tids, "Block ACK RX TIDs");
MODULE_PARM_DESC(cw1200_ba_tx_tids, "Block ACK TX TIDs");

#ifdef CONFIG_PM
static const struct wiphy_wowlan_support cw1200_wowlan_support = {
	/* Support only for limited wowlan functionalities */
	.flags = WIPHY_WOWLAN_ANY | WIPHY_WOWLAN_DISCONNECT,
};
#endif


static struct ieee80211_hw *cw1200_init_common(const u8 *macaddr,
						const bool have_5ghz)
{
	int i, band;
	struct ieee80211_hw *hw;
	struct cw1200_common *priv;

	hw = ieee80211_alloc_hw(sizeof(struct cw1200_common), &cw1200_ops);
	if (!hw)
		return NULL;

	priv = hw->priv;
	priv->hw = hw;
	priv->hw_type = -1;
	priv->mode = NL80211_IFTYPE_UNSPECIFIED;
	priv->rates = cw1200_rates; /* TODO: fetch from FW */
	priv->mcs_rates = cw1200_n_rates;
	if (cw1200_ba_rx_tids != -1)
		priv->ba_rx_tid_mask = cw1200_ba_rx_tids;
	else
		priv->ba_rx_tid_mask = 0xFF; /* Enable RX BLKACK for all TIDs */
	if (cw1200_ba_tx_tids != -1)
		priv->ba_tx_tid_mask = cw1200_ba_tx_tids;
	else
		priv->ba_tx_tid_mask = 0xff; /* Enable TX BLKACK for all TIDs */

	ieee80211_hw_set(hw, NEED_DTIM_BEFORE_ASSOC);
	ieee80211_hw_set(hw, TX_AMPDU_SETUP_IN_HW);
	ieee80211_hw_set(hw, AMPDU_AGGREGATION);
	ieee80211_hw_set(hw, CONNECTION_MONITOR);
	ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
	ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
	ieee80211_hw_set(hw, SIGNAL_DBM);
	ieee80211_hw_set(hw, SUPPORTS_PS);

	hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
					  BIT(NL80211_IFTYPE_ADHOC) |
					  BIT(NL80211_IFTYPE_AP) |
					  BIT(NL80211_IFTYPE_MESH_POINT) |
					  BIT(NL80211_IFTYPE_P2P_CLIENT) |
					  BIT(NL80211_IFTYPE_P2P_GO);

#ifdef CONFIG_PM
	hw->wiphy->wowlan = &cw1200_wowlan_support;
#endif

	hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;

	hw->queues = 4;

	priv->rts_threshold = -1;

	hw->max_rates = 8;
	hw->max_rate_tries = 15;
	hw->extra_tx_headroom = WSM_TX_EXTRA_HEADROOM +
		8;  /* TKIP IV */

	hw->sta_data_size = sizeof(struct cw1200_sta_priv);

	hw->wiphy->bands[NL80211_BAND_2GHZ] = &cw1200_band_2ghz;
	if (have_5ghz)
		hw->wiphy->bands[NL80211_BAND_5GHZ] = &cw1200_band_5ghz;

	/* Channel params have to be cleared before registering wiphy again */
	for (band = 0; band < NUM_NL80211_BANDS; band++) {
		struct ieee80211_supported_band *sband = hw->wiphy->bands[band];
		if (!sband)
			continue;
		for (i = 0; i < sband->n_channels; i++) {
			sband->channels[i].flags = 0;
			sband->channels[i].max_antenna_gain = 0;
			sband->channels[i].max_power = 30;
		}
	}

	hw->wiphy->max_scan_ssids = 2;
	hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;

	if (macaddr)
		SET_IEEE80211_PERM_ADDR(hw, (u8 *)macaddr);
	else
		SET_IEEE80211_PERM_ADDR(hw, cw1200_mac_template);

	/* Fix up mac address if necessary */
	if (hw->wiphy->perm_addr[3] == 0 &&
	    hw->wiphy->perm_addr[4] == 0 &&
	    hw->wiphy->perm_addr[5] == 0) {
		get_random_bytes(&hw->wiphy->perm_addr[3], 3);
	}

	mutex_init(&priv->wsm_cmd_mux);
	mutex_init(&priv->conf_mutex);
	priv->workqueue = create_singlethread_workqueue("cw1200_wq");
	if (!priv->workqueue) {
		ieee80211_free_hw(hw);
		return NULL;
	}

	sema_init(&priv->scan.lock, 1);
	INIT_WORK(&priv->scan.work, cw1200_scan_work);
	INIT_DELAYED_WORK(&priv->scan.probe_work, cw1200_probe_work);
	INIT_DELAYED_WORK(&priv->scan.timeout, cw1200_scan_timeout);
	INIT_DELAYED_WORK(&priv->clear_recent_scan_work,
			  cw1200_clear_recent_scan_work);
	INIT_DELAYED_WORK(&priv->join_timeout, cw1200_join_timeout);
	INIT_WORK(&priv->unjoin_work, cw1200_unjoin_work);
	INIT_WORK(&priv->join_complete_work, cw1200_join_complete_work);
	INIT_WORK(&priv->wep_key_work, cw1200_wep_key_work);
	INIT_WORK(&priv->tx_policy_upload_work, tx_policy_upload_work);
	spin_lock_init(&priv->event_queue_lock);
	INIT_LIST_HEAD(&priv->event_queue);
	INIT_WORK(&priv->event_handler, cw1200_event_handler);
	INIT_DELAYED_WORK(&priv->bss_loss_work, cw1200_bss_loss_work);
	INIT_WORK(&priv->bss_params_work, cw1200_bss_params_work);
	spin_lock_init(&priv->bss_loss_lock);
	spin_lock_init(&priv->ps_state_lock);
	INIT_WORK(&priv->set_cts_work, cw1200_set_cts_work);
	INIT_WORK(&priv->set_tim_work, cw1200_set_tim_work);
	INIT_WORK(&priv->multicast_start_work, cw1200_multicast_start_work);
	INIT_WORK(&priv->multicast_stop_work, cw1200_multicast_stop_work);
	INIT_WORK(&priv->link_id_work, cw1200_link_id_work);
	INIT_DELAYED_WORK(&priv->link_id_gc_work, cw1200_link_id_gc_work);
	INIT_WORK(&priv->linkid_reset_work, cw1200_link_id_reset);
	INIT_WORK(&priv->update_filtering_work, cw1200_update_filtering_work);
	INIT_WORK(&priv->set_beacon_wakeup_period_work,
		  cw1200_set_beacon_wakeup_period_work);
	timer_setup(&priv->mcast_timeout, cw1200_mcast_timeout, 0);

	if (cw1200_queue_stats_init(&priv->tx_queue_stats,
				    CW1200_LINK_ID_MAX,
				    cw1200_skb_dtor,
				    priv)) {
		ieee80211_free_hw(hw);
		return NULL;
	}

	for (i = 0; i < 4; ++i) {
		if (cw1200_queue_init(&priv->tx_queue[i],
				      &priv->tx_queue_stats, i, 16,
				      cw1200_ttl[i])) {
			for (; i > 0; i--)
				cw1200_queue_deinit(&priv->tx_queue[i - 1]);
			cw1200_queue_stats_deinit(&priv->tx_queue_stats);
			ieee80211_free_hw(hw);
			return NULL;
		}
	}

	init_waitqueue_head(&priv->channel_switch_done);
	init_waitqueue_head(&priv->wsm_cmd_wq);
	init_waitqueue_head(&priv->wsm_startup_done);
	init_waitqueue_head(&priv->ps_mode_switch_done);
	wsm_buf_init(&priv->wsm_cmd_buf);
	spin_lock_init(&priv->wsm_cmd.lock);
	priv->wsm_cmd.done = 1;
	tx_policy_init(priv);

	return hw;
}

static int cw1200_register_common(struct ieee80211_hw *dev)
{
	struct cw1200_common *priv = dev->priv;
	int err;

#ifdef CONFIG_PM
	err = cw1200_pm_init(&priv->pm_state, priv);
	if (err) {
		pr_err("Cannot init PM. (%d).\n",
		       err);
		return err;
	}
#endif

	err = ieee80211_register_hw(dev);
	if (err) {
		pr_err("Cannot register device (%d).\n",
		       err);
#ifdef CONFIG_PM
		cw1200_pm_deinit(&priv->pm_state);
#endif
		return err;
	}

	cw1200_debug_init(priv);

	pr_info("Registered as '%s'\n", wiphy_name(dev->wiphy));
	return 0;
}

static void cw1200_free_common(struct ieee80211_hw *dev)
{
	ieee80211_free_hw(dev);
}

static void cw1200_unregister_common(struct ieee80211_hw *dev)
{
	struct cw1200_common *priv = dev->priv;
	int i;

	ieee80211_unregister_hw(dev);

	del_timer_sync(&priv->mcast_timeout);
	cw1200_unregister_bh(priv);

	cw1200_debug_release(priv);

	mutex_destroy(&priv->conf_mutex);

	wsm_buf_deinit(&priv->wsm_cmd_buf);

	destroy_workqueue(priv->workqueue);
	priv->workqueue = NULL;

	if (priv->sdd) {
		release_firmware(priv->sdd);
		priv->sdd = NULL;
	}

	for (i = 0; i < 4; ++i)
		cw1200_queue_deinit(&priv->tx_queue[i]);

	cw1200_queue_stats_deinit(&priv->tx_queue_stats);
#ifdef CONFIG_PM
	cw1200_pm_deinit(&priv->pm_state);
#endif
}

/* Clock is in KHz */
u32 cw1200_dpll_from_clk(u16 clk_khz)
{
	switch (clk_khz) {
	case 0x32C8: /* 13000 KHz */
		return 0x1D89D241;
	case 0x3E80: /* 16000 KHz */
		return 0x000001E1;
	case 0x41A0: /* 16800 KHz */
		return 0x124931C1;
	case 0x4B00: /* 19200 KHz */
		return 0x00000191;
	case 0x5DC0: /* 24000 KHz */
		return 0x00000141;
	case 0x6590: /* 26000 KHz */
		return 0x0EC4F121;
	case 0x8340: /* 33600 KHz */
		return 0x092490E1;
	case 0x9600: /* 38400 KHz */
		return 0x100010C1;
	case 0x9C40: /* 40000 KHz */
		return 0x000000C1;
	case 0xBB80: /* 48000 KHz */
		return 0x000000A1;
	case 0xCB20: /* 52000 KHz */
		return 0x07627091;
	default:
		pr_err("Unknown Refclk freq (0x%04x), using 26000KHz\n",
		       clk_khz);
		return 0x0EC4F121;
	}
}

int cw1200_core_probe(const struct hwbus_ops *hwbus_ops,
		      struct hwbus_priv *hwbus,
		      struct device *pdev,
		      struct cw1200_common **core,
		      int ref_clk, const u8 *macaddr,
		      const char *sdd_path, bool have_5ghz)
{
	int err = -EINVAL;
	struct ieee80211_hw *dev;
	struct cw1200_common *priv;
	struct wsm_operational_mode mode = {
		.power_mode = cw1200_power_mode,
		.disable_more_flag_usage = true,
	};

	dev = cw1200_init_common(macaddr, have_5ghz);
	if (!dev)
		goto err;

	priv = dev->priv;
	priv->hw_refclk = ref_clk;
	if (cw1200_refclk)
		priv->hw_refclk = cw1200_refclk;

	priv->sdd_path = (char *)sdd_path;
	if (cw1200_sdd_path)
		priv->sdd_path = cw1200_sdd_path;

	priv->hwbus_ops = hwbus_ops;
	priv->hwbus_priv = hwbus;
	priv->pdev = pdev;
	SET_IEEE80211_DEV(priv->hw, pdev);

	/* Pass struct cw1200_common back up */
	*core = priv;

	err = cw1200_register_bh(priv);
	if (err)
		goto err1;

	err = cw1200_load_firmware(priv);
	if (err)
		goto err2;

	if (wait_event_interruptible_timeout(priv->wsm_startup_done,
					     priv->firmware_ready,
					     3*HZ) <= 0) {
		/* TODO: Need to find how to reset device
		   in QUEUE mode properly.
		*/
		pr_err("Timeout waiting on device startup\n");
		err = -ETIMEDOUT;
		goto err2;
	}

	/* Set low-power mode. */
	wsm_set_operational_mode(priv, &mode);

	/* Enable multi-TX confirmation */
	wsm_use_multi_tx_conf(priv, true);

	err = cw1200_register_common(dev);
	if (err)
		goto err2;

	return err;

err2:
	cw1200_unregister_bh(priv);
err1:
	cw1200_free_common(dev);
err:
	*core = NULL;
	return err;
}
EXPORT_SYMBOL_GPL(cw1200_core_probe);

void cw1200_core_release(struct cw1200_common *self)
{
	/* Disable device interrupts */
	self->hwbus_ops->lock(self->hwbus_priv);
	__cw1200_irq_enable(self, 0);
	self->hwbus_ops->unlock(self->hwbus_priv);

	/* And then clean up */
	cw1200_unregister_common(self->hw);
	cw1200_free_common(self->hw);
	return;
}
EXPORT_SYMBOL_GPL(cw1200_core_release);
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
a910e4a9 SP	2	/*
	3	* mac80211 glue code for mac80211 ST-Ericsson CW1200 drivers
	4	*
	5	* Copyright (c) 2010, ST-Ericsson
	6	* Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
	7	*
	8	* Based on:
	9	* Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
	10	* Copyright (c) 2007-2009, Christian Lamparter <chunkeey@web.de>
	11	* Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
	12	*
	13	* Based on:
	14	* - the islsm (softmac prism54) driver, which is:
	15	* Copyright 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
	16	* - stlc45xx driver
	17	* Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies).
a910e4a9 SP	18	*/
	19
	20	#include <linux/module.h>
a910e4a9 SP	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"
911373cc	30	#include "hwbus.h"
a910e4a9 SP	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 <dmitry.tarnyagin@lockless.no>");
	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};
2ef00c53	46	module_param_array_named(macaddr, cw1200_mac_template, byte, NULL, 0444);
a910e4a9 SP	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
a910e4a9 SP	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) { \
57fbcce3	102	.band = NL80211_BAND_2GHZ, \
a910e4a9 SP	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) { \
57fbcce3	111	.band = NL80211_BAND_5GHZ, \
a910e4a9 SP	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	.start = cw1200_start,
207	.stop = cw1200_stop,
208	.add_interface = cw1200_add_interface,
209	.remove_interface = cw1200_remove_interface,
210	.change_interface = cw1200_change_interface,
211	.tx = cw1200_tx,
212	.hw_scan = cw1200_hw_scan,
213	.set_tim = cw1200_set_tim,
214	.sta_notify = cw1200_sta_notify,
215	.sta_add = cw1200_sta_add,
216	.sta_remove = cw1200_sta_remove,
217	.set_key = cw1200_set_key,
218	.set_rts_threshold = cw1200_set_rts_threshold,
219	.config = cw1200_config,
220	.bss_info_changed = cw1200_bss_info_changed,
221	.prepare_multicast = cw1200_prepare_multicast,
222	.configure_filter = cw1200_configure_filter,
223	.conf_tx = cw1200_conf_tx,
224	.get_stats = cw1200_get_stats,
225	.ampdu_action = cw1200_ampdu_action,
226	.flush = cw1200_flush,
4e17b87e	227	#ifdef CONFIG_PM
a910e4a9 SP	228	.suspend = cw1200_wow_suspend,
a910e4a9 SP	229	.resume = cw1200_wow_resume,
4e17b87e	230	#endif
a910e4a9 SP	231	/* Intentionally not offloaded: */
	232	/.channel_switch = cw1200_channel_switch, /
	233	/.remain_on_channel = cw1200_remain_on_channel, /
	234	/.cancel_remain_on_channel = cw1200_cancel_remain_on_channel, /
	235	};
	236
7258416c SP	237	static int cw1200_ba_rx_tids = -1;
7258416c SP	238	static int cw1200_ba_tx_tids = -1;
a910e4a9 SP	239	module_param(cw1200_ba_rx_tids, int, 0644);
	240	module_param(cw1200_ba_tx_tids, int, 0644);
	241	MODULE_PARM_DESC(cw1200_ba_rx_tids, "Block ACK RX TIDs");
	242	MODULE_PARM_DESC(cw1200_ba_tx_tids, "Block ACK TX TIDs");
	243
51217cee JB	244	#ifdef CONFIG_PM
	245	static const struct wiphy_wowlan_support cw1200_wowlan_support = {
	246	/* Support only for limited wowlan functionalities */
	247	.flags = WIPHY_WOWLAN_ANY \| WIPHY_WOWLAN_DISCONNECT,
	248	};
	249	#endif
	250
	251
a910e4a9 SP	252	static struct ieee80211_hw cw1200_init_common(const u8 macaddr,
	253	const bool have_5ghz)
	254	{
	255	int i, band;
	256	struct ieee80211_hw *hw;
	257	struct cw1200_common *priv;
	258
	259	hw = ieee80211_alloc_hw(sizeof(struct cw1200_common), &cw1200_ops);
	260	if (!hw)
	261	return NULL;
	262
	263	priv = hw->priv;
	264	priv->hw = hw;
	265	priv->hw_type = -1;
	266	priv->mode = NL80211_IFTYPE_UNSPECIFIED;
	267	priv->rates = cw1200_rates; /* TODO: fetch from FW */
	268	priv->mcs_rates = cw1200_n_rates;
	269	if (cw1200_ba_rx_tids != -1)
	270	priv->ba_rx_tid_mask = cw1200_ba_rx_tids;
	271	else
	272	priv->ba_rx_tid_mask = 0xFF; /* Enable RX BLKACK for all TIDs */
	273	if (cw1200_ba_tx_tids != -1)
	274	priv->ba_tx_tid_mask = cw1200_ba_tx_tids;
	275	else
	276	priv->ba_tx_tid_mask = 0xff; /* Enable TX BLKACK for all TIDs */
	277
30686bf7 JB	278	ieee80211_hw_set(hw, NEED_DTIM_BEFORE_ASSOC);
	279	ieee80211_hw_set(hw, TX_AMPDU_SETUP_IN_HW);
	280	ieee80211_hw_set(hw, AMPDU_AGGREGATION);
	281	ieee80211_hw_set(hw, CONNECTION_MONITOR);
	282	ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
	283	ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
	284	ieee80211_hw_set(hw, SIGNAL_DBM);
	285	ieee80211_hw_set(hw, SUPPORTS_PS);
a910e4a9 SP	286
	287	hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) \|
	288	BIT(NL80211_IFTYPE_ADHOC) \|
	289	BIT(NL80211_IFTYPE_AP) \|
	290	BIT(NL80211_IFTYPE_MESH_POINT) \|
	291	BIT(NL80211_IFTYPE_P2P_CLIENT) \|
	292	BIT(NL80211_IFTYPE_P2P_GO);
	293
4e17b87e	294	#ifdef CONFIG_PM
51217cee	295	hw->wiphy->wowlan = &cw1200_wowlan_support;
4e17b87e	296	#endif
a910e4a9 SP	297
	298	hw->wiphy->flags \|= WIPHY_FLAG_AP_UAPSD;
	299
a910e4a9 SP	300	hw->queues = 4;
	301
	302	priv->rts_threshold = -1;
	303
	304	hw->max_rates = 8;
	305	hw->max_rate_tries = 15;
	306	hw->extra_tx_headroom = WSM_TX_EXTRA_HEADROOM +
	307	8; /* TKIP IV */
	308
	309	hw->sta_data_size = sizeof(struct cw1200_sta_priv);
	310
57fbcce3	311	hw->wiphy->bands[NL80211_BAND_2GHZ] = &cw1200_band_2ghz;
a910e4a9	312	if (have_5ghz)
57fbcce3	313	hw->wiphy->bands[NL80211_BAND_5GHZ] = &cw1200_band_5ghz;
a910e4a9 SP	314
a910e4a9 SP	315	/* Channel params have to be cleared before registering wiphy again */
57fbcce3	316	for (band = 0; band < NUM_NL80211_BANDS; band++) {
a910e4a9 SP	317	struct ieee80211_supported_band *sband = hw->wiphy->bands[band];
	318	if (!sband)
	319	continue;
	320	for (i = 0; i < sband->n_channels; i++) {
	321	sband->channels[i].flags = 0;
	322	sband->channels[i].max_antenna_gain = 0;
	323	sband->channels[i].max_power = 30;
	324	}
	325	}
	326
	327	hw->wiphy->max_scan_ssids = 2;
	328	hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
	329
	330	if (macaddr)
	331	SET_IEEE80211_PERM_ADDR(hw, (u8 *)macaddr);
	332	else
	333	SET_IEEE80211_PERM_ADDR(hw, cw1200_mac_template);
	334
	335	/* Fix up mac address if necessary */
	336	if (hw->wiphy->perm_addr[3] == 0 &&
	337	hw->wiphy->perm_addr[4] == 0 &&
	338	hw->wiphy->perm_addr[5] == 0) {
	339	get_random_bytes(&hw->wiphy->perm_addr[3], 3);
	340	}
	341
	342	mutex_init(&priv->wsm_cmd_mux);
	343	mutex_init(&priv->conf_mutex);
	344	priv->workqueue = create_singlethread_workqueue("cw1200_wq");
0ed2a005 KL	345	if (!priv->workqueue) {
	346	ieee80211_free_hw(hw);
	347	return NULL;
	348	}
	349
a910e4a9 SP	350	sema_init(&priv->scan.lock, 1);
	351	INIT_WORK(&priv->scan.work, cw1200_scan_work);
	352	INIT_DELAYED_WORK(&priv->scan.probe_work, cw1200_probe_work);
	353	INIT_DELAYED_WORK(&priv->scan.timeout, cw1200_scan_timeout);
	354	INIT_DELAYED_WORK(&priv->clear_recent_scan_work,
	355	cw1200_clear_recent_scan_work);
	356	INIT_DELAYED_WORK(&priv->join_timeout, cw1200_join_timeout);
	357	INIT_WORK(&priv->unjoin_work, cw1200_unjoin_work);
	358	INIT_WORK(&priv->join_complete_work, cw1200_join_complete_work);
	359	INIT_WORK(&priv->wep_key_work, cw1200_wep_key_work);
	360	INIT_WORK(&priv->tx_policy_upload_work, tx_policy_upload_work);
	361	spin_lock_init(&priv->event_queue_lock);
	362	INIT_LIST_HEAD(&priv->event_queue);
	363	INIT_WORK(&priv->event_handler, cw1200_event_handler);
	364	INIT_DELAYED_WORK(&priv->bss_loss_work, cw1200_bss_loss_work);
	365	INIT_WORK(&priv->bss_params_work, cw1200_bss_params_work);
	366	spin_lock_init(&priv->bss_loss_lock);
	367	spin_lock_init(&priv->ps_state_lock);
	368	INIT_WORK(&priv->set_cts_work, cw1200_set_cts_work);
	369	INIT_WORK(&priv->set_tim_work, cw1200_set_tim_work);
	370	INIT_WORK(&priv->multicast_start_work, cw1200_multicast_start_work);
	371	INIT_WORK(&priv->multicast_stop_work, cw1200_multicast_stop_work);
	372	INIT_WORK(&priv->link_id_work, cw1200_link_id_work);
	373	INIT_DELAYED_WORK(&priv->link_id_gc_work, cw1200_link_id_gc_work);
	374	INIT_WORK(&priv->linkid_reset_work, cw1200_link_id_reset);
	375	INIT_WORK(&priv->update_filtering_work, cw1200_update_filtering_work);
	376	INIT_WORK(&priv->set_beacon_wakeup_period_work,
	377	cw1200_set_beacon_wakeup_period_work);
e3dcf8bb	378	timer_setup(&priv->mcast_timeout, cw1200_mcast_timeout, 0);
a910e4a9 SP	379
	380	if (cw1200_queue_stats_init(&priv->tx_queue_stats,
	381	CW1200_LINK_ID_MAX,
	382	cw1200_skb_dtor,
	383	priv)) {
	384	ieee80211_free_hw(hw);
	385	return NULL;
	386	}
	387
	388	for (i = 0; i < 4; ++i) {
	389	if (cw1200_queue_init(&priv->tx_queue[i],
	390	&priv->tx_queue_stats, i, 16,
	391	cw1200_ttl[i])) {
	392	for (; i > 0; i--)
	393	cw1200_queue_deinit(&priv->tx_queue[i - 1]);
	394	cw1200_queue_stats_deinit(&priv->tx_queue_stats);
	395	ieee80211_free_hw(hw);
	396	return NULL;
	397	}
	398	}
	399
	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);
	408
	409	return hw;
	410	}
	411
	412	static int cw1200_register_common(struct ieee80211_hw *dev)
	413	{
	414	struct cw1200_common *priv = dev->priv;
	415	int err;
	416
4e17b87e	417	#ifdef CONFIG_PM
a910e4a9 SP	418	err = cw1200_pm_init(&priv->pm_state, priv);
	419	if (err) {
	420	pr_err("Cannot init PM. (%d).\n",
	421	err);
	422	return err;
	423	}
4e17b87e	424	#endif
a910e4a9 SP	425
	426	err = ieee80211_register_hw(dev);
	427	if (err) {
	428	pr_err("Cannot register device (%d).\n",
	429	err);
4e17b87e	430	#ifdef CONFIG_PM
a910e4a9	431	cw1200_pm_deinit(&priv->pm_state);
4e17b87e	432	#endif
a910e4a9 SP	433	return err;
	434	}
	435
a910e4a9 SP	436	cw1200_debug_init(priv);
	437
	438	pr_info("Registered as '%s'\n", wiphy_name(dev->wiphy));
	439	return 0;
	440	}
	441
	442	static void cw1200_free_common(struct ieee80211_hw *dev)
	443	{
	444	ieee80211_free_hw(dev);
	445	}
	446
	447	static void cw1200_unregister_common(struct ieee80211_hw *dev)
	448	{
	449	struct cw1200_common *priv = dev->priv;
	450	int i;
	451
19db5778	452	ieee80211_unregister_hw(dev);
a910e4a9 SP	453
	454	del_timer_sync(&priv->mcast_timeout);
	455	cw1200_unregister_bh(priv);
	456
	457	cw1200_debug_release(priv);
	458
	459	mutex_destroy(&priv->conf_mutex);
	460
	461	wsm_buf_deinit(&priv->wsm_cmd_buf);
	462
	463	destroy_workqueue(priv->workqueue);
	464	priv->workqueue = NULL;
	465
	466	if (priv->sdd) {
	467	release_firmware(priv->sdd);
	468	priv->sdd = NULL;
	469	}
	470
	471	for (i = 0; i < 4; ++i)
	472	cw1200_queue_deinit(&priv->tx_queue[i]);
	473
	474	cw1200_queue_stats_deinit(&priv->tx_queue_stats);
4e17b87e	475	#ifdef CONFIG_PM
a910e4a9	476	cw1200_pm_deinit(&priv->pm_state);
4e17b87e	477	#endif
a910e4a9 SP	478	}
	479
	480	/* Clock is in KHz */
	481	u32 cw1200_dpll_from_clk(u16 clk_khz)
	482	{
	483	switch (clk_khz) {
	484	case 0x32C8: /* 13000 KHz */
	485	return 0x1D89D241;
	486	case 0x3E80: /* 16000 KHz */
	487	return 0x000001E1;
	488	case 0x41A0: /* 16800 KHz */
	489	return 0x124931C1;
	490	case 0x4B00: /* 19200 KHz */
	491	return 0x00000191;
	492	case 0x5DC0: /* 24000 KHz */
	493	return 0x00000141;
	494	case 0x6590: /* 26000 KHz */
	495	return 0x0EC4F121;
	496	case 0x8340: /* 33600 KHz */
	497	return 0x092490E1;
	498	case 0x9600: /* 38400 KHz */
	499	return 0x100010C1;
	500	case 0x9C40: /* 40000 KHz */
	501	return 0x000000C1;
	502	case 0xBB80: /* 48000 KHz */
	503	return 0x000000A1;
	504	case 0xCB20: /* 52000 KHz */
	505	return 0x07627091;
	506	default:
7f190230	507	pr_err("Unknown Refclk freq (0x%04x), using 26000KHz\n",
a910e4a9 SP	508	clk_khz);
	509	return 0x0EC4F121;
	510	}
	511	}
	512
911373cc SP	513	int cw1200_core_probe(const struct hwbus_ops *hwbus_ops,
911373cc SP	514	struct hwbus_priv *hwbus,
a910e4a9 SP	515	struct device *pdev,
	516	struct cw1200_common **core,
	517	int ref_clk, const u8 *macaddr,
	518	const char *sdd_path, bool have_5ghz)
	519	{
	520	int err = -EINVAL;
	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,
	526	};
	527
	528	dev = cw1200_init_common(macaddr, have_5ghz);
	529	if (!dev)
	530	goto err;
	531
	532	priv = dev->priv;
	533	priv->hw_refclk = ref_clk;
	534	if (cw1200_refclk)
	535	priv->hw_refclk = cw1200_refclk;
	536
	537	priv->sdd_path = (char *)sdd_path;
	538	if (cw1200_sdd_path)
	539	priv->sdd_path = cw1200_sdd_path;
	540
911373cc SP	541	priv->hwbus_ops = hwbus_ops;
911373cc SP	542	priv->hwbus_priv = hwbus;
a910e4a9 SP	543	priv->pdev = pdev;
	544	SET_IEEE80211_DEV(priv->hw, pdev);
	545
	546	/* Pass struct cw1200_common back up */
	547	*core = priv;
	548
	549	err = cw1200_register_bh(priv);
	550	if (err)
	551	goto err1;
	552
a910e4a9 SP	553	err = cw1200_load_firmware(priv);
	554	if (err)
	555	goto err2;
	556
	557	if (wait_event_interruptible_timeout(priv->wsm_startup_done,
	558	priv->firmware_ready,
	559	3*HZ) <= 0) {
	560	/* TODO: Need to find how to reset device
	561	in QUEUE mode properly.
	562	*/
	563	pr_err("Timeout waiting on device startup\n");
	564	err = -ETIMEDOUT;
	565	goto err2;
	566	}
	567
	568	/* Set low-power mode. */
	569	wsm_set_operational_mode(priv, &mode);
	570
	571	/* Enable multi-TX confirmation */
	572	wsm_use_multi_tx_conf(priv, true);
	573
a910e4a9 SP	574	err = cw1200_register_common(dev);
	575	if (err)
	576	goto err2;
	577
	578	return err;
	579
	580	err2:
	581	cw1200_unregister_bh(priv);
	582	err1:
	583	cw1200_free_common(dev);
	584	err:
	585	*core = NULL;
	586	return err;
	587	}
	588	EXPORT_SYMBOL_GPL(cw1200_core_probe);
	589
	590	void cw1200_core_release(struct cw1200_common *self)
	591	{
	592	/* Disable device interrupts */
911373cc	593	self->hwbus_ops->lock(self->hwbus_priv);
a910e4a9	594	__cw1200_irq_enable(self, 0);
911373cc	595	self->hwbus_ops->unlock(self->hwbus_priv);
a910e4a9 SP	596
	597	/* And then clean up */
	598	cw1200_unregister_common(self->hw);
	599	cw1200_free_common(self->hw);
	600	return;
	601	}
	602	EXPORT_SYMBOL_GPL(cw1200_core_release);