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 <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).
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 <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};
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 	.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,
227 #ifdef CONFIG_PM
228 	.suspend		= cw1200_wow_suspend,
229 	.resume			= cw1200_wow_resume,
230 #endif
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 
237 static int cw1200_ba_rx_tids = -1;
238 static int cw1200_ba_tx_tids = -1;
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 
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 
cw1200_init_common(const u8 * macaddr,const bool have_5ghz)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 
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);
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 
294 #ifdef CONFIG_PM
295 	hw->wiphy->wowlan = &cw1200_wowlan_support;
296 #endif
297 
298 	hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
299 
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 
311 	hw->wiphy->bands[NL80211_BAND_2GHZ] = &cw1200_band_2ghz;
312 	if (have_5ghz)
313 		hw->wiphy->bands[NL80211_BAND_5GHZ] = &cw1200_band_5ghz;
314 
315 	/* Channel params have to be cleared before registering wiphy again */
316 	for (band = 0; band < NUM_NL80211_BANDS; band++) {
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");
345 	if (!priv->workqueue) {
346 		ieee80211_free_hw(hw);
347 		return NULL;
348 	}
349 
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);
378 	timer_setup(&priv->mcast_timeout, cw1200_mcast_timeout, 0);
379 
380 	if (cw1200_queue_stats_init(&priv->tx_queue_stats,
381 				    CW1200_LINK_ID_MAX,
382 				    cw1200_skb_dtor,
383 				    priv)) {
384 		destroy_workqueue(priv->workqueue);
385 		ieee80211_free_hw(hw);
386 		return NULL;
387 	}
388 
389 	for (i = 0; i < 4; ++i) {
390 		if (cw1200_queue_init(&priv->tx_queue[i],
391 				      &priv->tx_queue_stats, i, 16,
392 				      cw1200_ttl[i])) {
393 			for (; i > 0; i--)
394 				cw1200_queue_deinit(&priv->tx_queue[i - 1]);
395 			cw1200_queue_stats_deinit(&priv->tx_queue_stats);
396 			destroy_workqueue(priv->workqueue);
397 			ieee80211_free_hw(hw);
398 			return NULL;
399 		}
400 	}
401 
402 	init_waitqueue_head(&priv->channel_switch_done);
403 	init_waitqueue_head(&priv->wsm_cmd_wq);
404 	init_waitqueue_head(&priv->wsm_startup_done);
405 	init_waitqueue_head(&priv->ps_mode_switch_done);
406 	wsm_buf_init(&priv->wsm_cmd_buf);
407 	spin_lock_init(&priv->wsm_cmd.lock);
408 	priv->wsm_cmd.done = 1;
409 	tx_policy_init(priv);
410 
411 	return hw;
412 }
413 
cw1200_register_common(struct ieee80211_hw * dev)414 static int cw1200_register_common(struct ieee80211_hw *dev)
415 {
416 	struct cw1200_common *priv = dev->priv;
417 	int err;
418 
419 #ifdef CONFIG_PM
420 	err = cw1200_pm_init(&priv->pm_state, priv);
421 	if (err) {
422 		pr_err("Cannot init PM. (%d).\n",
423 		       err);
424 		return err;
425 	}
426 #endif
427 
428 	err = ieee80211_register_hw(dev);
429 	if (err) {
430 		pr_err("Cannot register device (%d).\n",
431 		       err);
432 #ifdef CONFIG_PM
433 		cw1200_pm_deinit(&priv->pm_state);
434 #endif
435 		return err;
436 	}
437 
438 	cw1200_debug_init(priv);
439 
440 	pr_info("Registered as '%s'\n", wiphy_name(dev->wiphy));
441 	return 0;
442 }
443 
cw1200_free_common(struct ieee80211_hw * dev)444 static void cw1200_free_common(struct ieee80211_hw *dev)
445 {
446 	ieee80211_free_hw(dev);
447 }
448 
cw1200_unregister_common(struct ieee80211_hw * dev)449 static void cw1200_unregister_common(struct ieee80211_hw *dev)
450 {
451 	struct cw1200_common *priv = dev->priv;
452 	int i;
453 
454 	ieee80211_unregister_hw(dev);
455 
456 	del_timer_sync(&priv->mcast_timeout);
457 	cw1200_unregister_bh(priv);
458 
459 	cw1200_debug_release(priv);
460 
461 	mutex_destroy(&priv->conf_mutex);
462 
463 	wsm_buf_deinit(&priv->wsm_cmd_buf);
464 
465 	destroy_workqueue(priv->workqueue);
466 	priv->workqueue = NULL;
467 
468 	if (priv->sdd) {
469 		release_firmware(priv->sdd);
470 		priv->sdd = NULL;
471 	}
472 
473 	for (i = 0; i < 4; ++i)
474 		cw1200_queue_deinit(&priv->tx_queue[i]);
475 
476 	cw1200_queue_stats_deinit(&priv->tx_queue_stats);
477 #ifdef CONFIG_PM
478 	cw1200_pm_deinit(&priv->pm_state);
479 #endif
480 }
481 
482 /* Clock is in KHz */
cw1200_dpll_from_clk(u16 clk_khz)483 u32 cw1200_dpll_from_clk(u16 clk_khz)
484 {
485 	switch (clk_khz) {
486 	case 0x32C8: /* 13000 KHz */
487 		return 0x1D89D241;
488 	case 0x3E80: /* 16000 KHz */
489 		return 0x000001E1;
490 	case 0x41A0: /* 16800 KHz */
491 		return 0x124931C1;
492 	case 0x4B00: /* 19200 KHz */
493 		return 0x00000191;
494 	case 0x5DC0: /* 24000 KHz */
495 		return 0x00000141;
496 	case 0x6590: /* 26000 KHz */
497 		return 0x0EC4F121;
498 	case 0x8340: /* 33600 KHz */
499 		return 0x092490E1;
500 	case 0x9600: /* 38400 KHz */
501 		return 0x100010C1;
502 	case 0x9C40: /* 40000 KHz */
503 		return 0x000000C1;
504 	case 0xBB80: /* 48000 KHz */
505 		return 0x000000A1;
506 	case 0xCB20: /* 52000 KHz */
507 		return 0x07627091;
508 	default:
509 		pr_err("Unknown Refclk freq (0x%04x), using 26000KHz\n",
510 		       clk_khz);
511 		return 0x0EC4F121;
512 	}
513 }
514 
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)515 int cw1200_core_probe(const struct hwbus_ops *hwbus_ops,
516 		      struct hwbus_priv *hwbus,
517 		      struct device *pdev,
518 		      struct cw1200_common **core,
519 		      int ref_clk, const u8 *macaddr,
520 		      const char *sdd_path, bool have_5ghz)
521 {
522 	int err = -EINVAL;
523 	struct ieee80211_hw *dev;
524 	struct cw1200_common *priv;
525 	struct wsm_operational_mode mode = {
526 		.power_mode = cw1200_power_mode,
527 		.disable_more_flag_usage = true,
528 	};
529 
530 	dev = cw1200_init_common(macaddr, have_5ghz);
531 	if (!dev)
532 		goto err;
533 
534 	priv = dev->priv;
535 	priv->hw_refclk = ref_clk;
536 	if (cw1200_refclk)
537 		priv->hw_refclk = cw1200_refclk;
538 
539 	priv->sdd_path = (char *)sdd_path;
540 	if (cw1200_sdd_path)
541 		priv->sdd_path = cw1200_sdd_path;
542 
543 	priv->hwbus_ops = hwbus_ops;
544 	priv->hwbus_priv = hwbus;
545 	priv->pdev = pdev;
546 	SET_IEEE80211_DEV(priv->hw, pdev);
547 
548 	/* Pass struct cw1200_common back up */
549 	*core = priv;
550 
551 	err = cw1200_register_bh(priv);
552 	if (err)
553 		goto err1;
554 
555 	err = cw1200_load_firmware(priv);
556 	if (err)
557 		goto err2;
558 
559 	if (wait_event_interruptible_timeout(priv->wsm_startup_done,
560 					     priv->firmware_ready,
561 					     3*HZ) <= 0) {
562 		/* TODO: Need to find how to reset device
563 		   in QUEUE mode properly.
564 		*/
565 		pr_err("Timeout waiting on device startup\n");
566 		err = -ETIMEDOUT;
567 		goto err2;
568 	}
569 
570 	/* Set low-power mode. */
571 	wsm_set_operational_mode(priv, &mode);
572 
573 	/* Enable multi-TX confirmation */
574 	wsm_use_multi_tx_conf(priv, true);
575 
576 	err = cw1200_register_common(dev);
577 	if (err)
578 		goto err2;
579 
580 	return err;
581 
582 err2:
583 	cw1200_unregister_bh(priv);
584 err1:
585 	cw1200_free_common(dev);
586 err:
587 	*core = NULL;
588 	return err;
589 }
590 EXPORT_SYMBOL_GPL(cw1200_core_probe);
591 
cw1200_core_release(struct cw1200_common * self)592 void cw1200_core_release(struct cw1200_common *self)
593 {
594 	/* Disable device interrupts */
595 	self->hwbus_ops->lock(self->hwbus_priv);
596 	__cw1200_irq_enable(self, 0);
597 	self->hwbus_ops->unlock(self->hwbus_priv);
598 
599 	/* And then clean up */
600 	cw1200_unregister_common(self->hw);
601 	cw1200_free_common(self->hw);
602 	return;
603 }
604 EXPORT_SYMBOL_GPL(cw1200_core_release);
605