1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Device probe and register.
4  *
5  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
6  * Copyright (c) 2010, ST-Ericsson
7  * Copyright (c) 2008, Johannes Berg <johannes@sipsolutions.net>
8  * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
9  * Copyright (c) 2007-2009, Christian Lamparter <chunkeey@web.de>
10  * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
11  * Copyright (c) 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
12  */
13 #include <linux/module.h>
14 #include <linux/of.h>
15 #include <linux/of_net.h>
16 #include <linux/gpio/consumer.h>
17 #include <linux/mmc/sdio_func.h>
18 #include <linux/spi/spi.h>
19 #include <linux/etherdevice.h>
20 #include <linux/firmware.h>
21 
22 #include "main.h"
23 #include "wfx.h"
24 #include "fwio.h"
25 #include "hwio.h"
26 #include "bus.h"
27 #include "bh.h"
28 #include "sta.h"
29 #include "key.h"
30 #include "scan.h"
31 #include "debug.h"
32 #include "data_tx.h"
33 #include "hif_tx_mib.h"
34 #include "hif_api_cmd.h"
35 
36 #define WFX_PDS_TLV_TYPE 0x4450 // "PD" (Platform Data) in ascii little-endian
37 #define WFX_PDS_MAX_CHUNK_SIZE 1500
38 
39 MODULE_DESCRIPTION("Silicon Labs 802.11 Wireless LAN driver for WF200");
40 MODULE_AUTHOR("Jérôme Pouiller <jerome.pouiller@silabs.com>");
41 MODULE_LICENSE("GPL");
42 
43 #define RATETAB_ENT(_rate, _rateid, _flags) { \
44 	.bitrate  = (_rate),   \
45 	.hw_value = (_rateid), \
46 	.flags    = (_flags),  \
47 }
48 
49 static struct ieee80211_rate wfx_rates[] = {
50 	RATETAB_ENT(10,  0,  0),
51 	RATETAB_ENT(20,  1,  IEEE80211_RATE_SHORT_PREAMBLE),
52 	RATETAB_ENT(55,  2,  IEEE80211_RATE_SHORT_PREAMBLE),
53 	RATETAB_ENT(110, 3,  IEEE80211_RATE_SHORT_PREAMBLE),
54 	RATETAB_ENT(60,  6,  0),
55 	RATETAB_ENT(90,  7,  0),
56 	RATETAB_ENT(120, 8,  0),
57 	RATETAB_ENT(180, 9,  0),
58 	RATETAB_ENT(240, 10, 0),
59 	RATETAB_ENT(360, 11, 0),
60 	RATETAB_ENT(480, 12, 0),
61 	RATETAB_ENT(540, 13, 0),
62 };
63 
64 #define CHAN2G(_channel, _freq, _flags) { \
65 	.band = NL80211_BAND_2GHZ, \
66 	.center_freq = (_freq),    \
67 	.hw_value = (_channel),    \
68 	.flags = (_flags),         \
69 	.max_antenna_gain = 0,     \
70 	.max_power = 30,           \
71 }
72 
73 static struct ieee80211_channel wfx_2ghz_chantable[] = {
74 	CHAN2G(1,  2412, 0),
75 	CHAN2G(2,  2417, 0),
76 	CHAN2G(3,  2422, 0),
77 	CHAN2G(4,  2427, 0),
78 	CHAN2G(5,  2432, 0),
79 	CHAN2G(6,  2437, 0),
80 	CHAN2G(7,  2442, 0),
81 	CHAN2G(8,  2447, 0),
82 	CHAN2G(9,  2452, 0),
83 	CHAN2G(10, 2457, 0),
84 	CHAN2G(11, 2462, 0),
85 	CHAN2G(12, 2467, 0),
86 	CHAN2G(13, 2472, 0),
87 	CHAN2G(14, 2484, 0),
88 };
89 
90 static const struct ieee80211_supported_band wfx_band_2ghz = {
91 	.channels = wfx_2ghz_chantable,
92 	.n_channels = ARRAY_SIZE(wfx_2ghz_chantable),
93 	.bitrates = wfx_rates,
94 	.n_bitrates = ARRAY_SIZE(wfx_rates),
95 	.ht_cap = {
96 		/* Receive caps */
97 		.cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 |
98 		       IEEE80211_HT_CAP_MAX_AMSDU | (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT),
99 		.ht_supported = 1,
100 		.ampdu_factor = IEEE80211_HT_MAX_AMPDU_16K,
101 		.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE,
102 		.mcs = {
103 			.rx_mask = { 0xFF }, /* MCS0 to MCS7 */
104 			.rx_highest = cpu_to_le16(72),
105 			.tx_params = IEEE80211_HT_MCS_TX_DEFINED,
106 		},
107 	},
108 };
109 
110 static const struct ieee80211_iface_limit wdev_iface_limits[] = {
111 	{ .max = 1, .types = BIT(NL80211_IFTYPE_STATION) },
112 	{ .max = 1, .types = BIT(NL80211_IFTYPE_AP) },
113 };
114 
115 static const struct ieee80211_iface_combination wfx_iface_combinations[] = {
116 	{
117 		.num_different_channels = 2,
118 		.max_interfaces = 2,
119 		.limits = wdev_iface_limits,
120 		.n_limits = ARRAY_SIZE(wdev_iface_limits),
121 	}
122 };
123 
124 static const struct ieee80211_ops wfx_ops = {
125 	.start                   = wfx_start,
126 	.stop                    = wfx_stop,
127 	.add_interface           = wfx_add_interface,
128 	.remove_interface        = wfx_remove_interface,
129 	.config                  = wfx_config,
130 	.tx                      = wfx_tx,
131 	.join_ibss               = wfx_join_ibss,
132 	.leave_ibss              = wfx_leave_ibss,
133 	.conf_tx                 = wfx_conf_tx,
134 	.hw_scan                 = wfx_hw_scan,
135 	.cancel_hw_scan          = wfx_cancel_hw_scan,
136 	.start_ap                = wfx_start_ap,
137 	.stop_ap                 = wfx_stop_ap,
138 	.sta_add                 = wfx_sta_add,
139 	.sta_remove              = wfx_sta_remove,
140 	.set_tim                 = wfx_set_tim,
141 	.set_key                 = wfx_set_key,
142 	.set_rts_threshold       = wfx_set_rts_threshold,
143 	.set_default_unicast_key = wfx_set_default_unicast_key,
144 	.bss_info_changed        = wfx_bss_info_changed,
145 	.configure_filter        = wfx_configure_filter,
146 	.ampdu_action            = wfx_ampdu_action,
147 	.flush                   = wfx_flush,
148 	.add_chanctx             = wfx_add_chanctx,
149 	.remove_chanctx          = wfx_remove_chanctx,
150 	.change_chanctx          = wfx_change_chanctx,
151 	.assign_vif_chanctx      = wfx_assign_vif_chanctx,
152 	.unassign_vif_chanctx    = wfx_unassign_vif_chanctx,
153 };
154 
155 bool wfx_api_older_than(struct wfx_dev *wdev, int major, int minor)
156 {
157 	if (wdev->hw_caps.api_version_major < major)
158 		return true;
159 	if (wdev->hw_caps.api_version_major > major)
160 		return false;
161 	if (wdev->hw_caps.api_version_minor < minor)
162 		return true;
163 	return false;
164 }
165 
166 /* The device needs data about the antenna configuration. This information in provided by PDS
167  * (Platform Data Set, this is the wording used in WF200 documentation) files. For hardware
168  * integrators, the full process to create PDS files is described here:
169  *   https://github.com/SiliconLabs/wfx-firmware/blob/master/PDS/README.md
170  *
171  * The PDS file is an array of Time-Length-Value structs.
172  */
173 int wfx_send_pds(struct wfx_dev *wdev, u8 *buf, size_t len)
174 {
175 	int ret, chunk_type, chunk_len, chunk_num = 0;
176 
177 	if (*buf == '{') {
178 		dev_err(wdev->dev, "PDS: malformed file (legacy format?)\n");
179 		return -EINVAL;
180 	}
181 	while (len > 0) {
182 		chunk_type = get_unaligned_le16(buf + 0);
183 		chunk_len = get_unaligned_le16(buf + 2);
184 		if (chunk_len > len) {
185 			dev_err(wdev->dev, "PDS:%d: corrupted file\n", chunk_num);
186 			return -EINVAL;
187 		}
188 		if (chunk_type != WFX_PDS_TLV_TYPE) {
189 			dev_info(wdev->dev, "PDS:%d: skip unknown data\n", chunk_num);
190 			goto next;
191 		}
192 		if (chunk_len > WFX_PDS_MAX_CHUNK_SIZE)
193 			dev_warn(wdev->dev, "PDS:%d: unexpectedly large chunk\n", chunk_num);
194 		if (buf[4] != '{' || buf[chunk_len - 1] != '}')
195 			dev_warn(wdev->dev, "PDS:%d: unexpected content\n", chunk_num);
196 
197 		ret = wfx_hif_configuration(wdev, buf + 4, chunk_len - 4);
198 		if (ret > 0) {
199 			dev_err(wdev->dev, "PDS:%d: invalid data (unsupported options?)\n", chunk_num);
200 			return -EINVAL;
201 		}
202 		if (ret == -ETIMEDOUT) {
203 			dev_err(wdev->dev, "PDS:%d: chip didn't reply (corrupted file?)\n", chunk_num);
204 			return ret;
205 		}
206 		if (ret) {
207 			dev_err(wdev->dev, "PDS:%d: chip returned an unknown error\n", chunk_num);
208 			return -EIO;
209 		}
210 next:
211 		chunk_num++;
212 		len -= chunk_len;
213 		buf += chunk_len;
214 	}
215 	return 0;
216 }
217 
218 static int wfx_send_pdata_pds(struct wfx_dev *wdev)
219 {
220 	int ret = 0;
221 	const struct firmware *pds;
222 	u8 *tmp_buf;
223 
224 	ret = request_firmware(&pds, wdev->pdata.file_pds, wdev->dev);
225 	if (ret) {
226 		dev_err(wdev->dev, "can't load antenna parameters (PDS file %s). The device may be unstable.\n",
227 			wdev->pdata.file_pds);
228 		return ret;
229 	}
230 	tmp_buf = kmemdup(pds->data, pds->size, GFP_KERNEL);
231 	if (!tmp_buf) {
232 		ret = -ENOMEM;
233 		goto release_fw;
234 	}
235 	ret = wfx_send_pds(wdev, tmp_buf, pds->size);
236 	kfree(tmp_buf);
237 release_fw:
238 	release_firmware(pds);
239 	return ret;
240 }
241 
242 static void wfx_free_common(void *data)
243 {
244 	struct wfx_dev *wdev = data;
245 
246 	mutex_destroy(&wdev->tx_power_loop_info_lock);
247 	mutex_destroy(&wdev->rx_stats_lock);
248 	mutex_destroy(&wdev->conf_mutex);
249 	ieee80211_free_hw(wdev->hw);
250 }
251 
252 struct wfx_dev *wfx_init_common(struct device *dev, const struct wfx_platform_data *pdata,
253 				const struct wfx_hwbus_ops *hwbus_ops, void *hwbus_priv)
254 {
255 	struct ieee80211_hw *hw;
256 	struct wfx_dev *wdev;
257 
258 	hw = ieee80211_alloc_hw(sizeof(struct wfx_dev), &wfx_ops);
259 	if (!hw)
260 		return NULL;
261 
262 	SET_IEEE80211_DEV(hw, dev);
263 
264 	ieee80211_hw_set(hw, TX_AMPDU_SETUP_IN_HW);
265 	ieee80211_hw_set(hw, AMPDU_AGGREGATION);
266 	ieee80211_hw_set(hw, CONNECTION_MONITOR);
267 	ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
268 	ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
269 	ieee80211_hw_set(hw, SIGNAL_DBM);
270 	ieee80211_hw_set(hw, SUPPORTS_PS);
271 	ieee80211_hw_set(hw, MFP_CAPABLE);
272 
273 	hw->vif_data_size = sizeof(struct wfx_vif);
274 	hw->sta_data_size = sizeof(struct wfx_sta_priv);
275 	hw->queues = 4;
276 	hw->max_rates = 8;
277 	hw->max_rate_tries = 8;
278 	hw->extra_tx_headroom = sizeof(struct wfx_hif_msg) + sizeof(struct wfx_hif_req_tx) +
279 				4 /* alignment */ + 8 /* TKIP IV */;
280 	hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
281 				     BIT(NL80211_IFTYPE_ADHOC) |
282 				     BIT(NL80211_IFTYPE_AP);
283 	hw->wiphy->probe_resp_offload = NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
284 					NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
285 					NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P |
286 					NL80211_PROBE_RESP_OFFLOAD_SUPPORT_80211U;
287 	hw->wiphy->features |= NL80211_FEATURE_AP_SCAN;
288 	hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
289 	hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
290 	hw->wiphy->max_ap_assoc_sta = HIF_LINK_ID_MAX;
291 	hw->wiphy->max_scan_ssids = 2;
292 	hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
293 	hw->wiphy->n_iface_combinations = ARRAY_SIZE(wfx_iface_combinations);
294 	hw->wiphy->iface_combinations = wfx_iface_combinations;
295 	hw->wiphy->bands[NL80211_BAND_2GHZ] = devm_kmalloc(dev, sizeof(wfx_band_2ghz), GFP_KERNEL);
296 	if (!hw->wiphy->bands[NL80211_BAND_2GHZ])
297 		goto err;
298 
299 	/* FIXME: also copy wfx_rates and wfx_2ghz_chantable */
300 	memcpy(hw->wiphy->bands[NL80211_BAND_2GHZ], &wfx_band_2ghz, sizeof(wfx_band_2ghz));
301 
302 	wdev = hw->priv;
303 	wdev->hw = hw;
304 	wdev->dev = dev;
305 	wdev->hwbus_ops = hwbus_ops;
306 	wdev->hwbus_priv = hwbus_priv;
307 	memcpy(&wdev->pdata, pdata, sizeof(*pdata));
308 	of_property_read_string(dev->of_node, "silabs,antenna-config-file", &wdev->pdata.file_pds);
309 	wdev->pdata.gpio_wakeup = devm_gpiod_get_optional(dev, "wakeup", GPIOD_OUT_LOW);
310 	if (IS_ERR(wdev->pdata.gpio_wakeup))
311 		goto err;
312 
313 	if (wdev->pdata.gpio_wakeup)
314 		gpiod_set_consumer_name(wdev->pdata.gpio_wakeup, "wfx wakeup");
315 
316 	mutex_init(&wdev->conf_mutex);
317 	mutex_init(&wdev->rx_stats_lock);
318 	mutex_init(&wdev->tx_power_loop_info_lock);
319 	init_completion(&wdev->firmware_ready);
320 	INIT_DELAYED_WORK(&wdev->cooling_timeout_work, wfx_cooling_timeout_work);
321 	skb_queue_head_init(&wdev->tx_pending);
322 	init_waitqueue_head(&wdev->tx_dequeue);
323 	wfx_init_hif_cmd(&wdev->hif_cmd);
324 
325 	if (devm_add_action_or_reset(dev, wfx_free_common, wdev))
326 		return NULL;
327 
328 	return wdev;
329 
330 err:
331 	ieee80211_free_hw(hw);
332 	return NULL;
333 }
334 
335 int wfx_probe(struct wfx_dev *wdev)
336 {
337 	int i;
338 	int err;
339 	struct gpio_desc *gpio_saved;
340 
341 	/* During first part of boot, gpio_wakeup cannot yet been used. So prevent bh() to touch
342 	 * it.
343 	 */
344 	gpio_saved = wdev->pdata.gpio_wakeup;
345 	wdev->pdata.gpio_wakeup = NULL;
346 	wdev->poll_irq = true;
347 
348 	wdev->bh_wq = alloc_workqueue("wfx_bh_wq", WQ_HIGHPRI, 0);
349 	if (!wdev->bh_wq)
350 		return -ENOMEM;
351 
352 	wfx_bh_register(wdev);
353 
354 	err = wfx_init_device(wdev);
355 	if (err)
356 		goto bh_unregister;
357 
358 	wfx_bh_poll_irq(wdev);
359 	err = wait_for_completion_timeout(&wdev->firmware_ready, 1 * HZ);
360 	if (err <= 0) {
361 		if (err == 0) {
362 			dev_err(wdev->dev, "timeout while waiting for startup indication\n");
363 			err = -ETIMEDOUT;
364 		} else if (err == -ERESTARTSYS) {
365 			dev_info(wdev->dev, "probe interrupted by user\n");
366 		}
367 		goto bh_unregister;
368 	}
369 
370 	/* FIXME: fill wiphy::hw_version */
371 	dev_info(wdev->dev, "started firmware %d.%d.%d \"%s\" (API: %d.%d, keyset: %02X, caps: 0x%.8X)\n",
372 		 wdev->hw_caps.firmware_major, wdev->hw_caps.firmware_minor,
373 		 wdev->hw_caps.firmware_build, wdev->hw_caps.firmware_label,
374 		 wdev->hw_caps.api_version_major, wdev->hw_caps.api_version_minor,
375 		 wdev->keyset, wdev->hw_caps.link_mode);
376 	snprintf(wdev->hw->wiphy->fw_version,
377 		 sizeof(wdev->hw->wiphy->fw_version),
378 		 "%d.%d.%d",
379 		 wdev->hw_caps.firmware_major,
380 		 wdev->hw_caps.firmware_minor,
381 		 wdev->hw_caps.firmware_build);
382 
383 	if (wfx_api_older_than(wdev, 1, 0)) {
384 		dev_err(wdev->dev, "unsupported firmware API version (expect 1 while firmware returns %d)\n",
385 			wdev->hw_caps.api_version_major);
386 		err = -EOPNOTSUPP;
387 		goto bh_unregister;
388 	}
389 
390 	if (wdev->hw_caps.link_mode == SEC_LINK_ENFORCED) {
391 		dev_err(wdev->dev, "chip require secure_link, but can't negotiate it\n");
392 		goto bh_unregister;
393 	}
394 
395 	if (wdev->hw_caps.region_sel_mode) {
396 		wdev->hw->wiphy->regulatory_flags |= REGULATORY_DISABLE_BEACON_HINTS;
397 		wdev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels[11].flags |=
398 			IEEE80211_CHAN_NO_IR;
399 		wdev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels[12].flags |=
400 			IEEE80211_CHAN_NO_IR;
401 		wdev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels[13].flags |=
402 			IEEE80211_CHAN_DISABLED;
403 	}
404 
405 	dev_dbg(wdev->dev, "sending configuration file %s\n", wdev->pdata.file_pds);
406 	err = wfx_send_pdata_pds(wdev);
407 	if (err < 0 && err != -ENOENT)
408 		goto bh_unregister;
409 
410 	wdev->poll_irq = false;
411 	err = wdev->hwbus_ops->irq_subscribe(wdev->hwbus_priv);
412 	if (err)
413 		goto bh_unregister;
414 
415 	err = wfx_hif_use_multi_tx_conf(wdev, true);
416 	if (err)
417 		dev_err(wdev->dev, "misconfigured IRQ?\n");
418 
419 	wdev->pdata.gpio_wakeup = gpio_saved;
420 	if (wdev->pdata.gpio_wakeup) {
421 		dev_dbg(wdev->dev, "enable 'quiescent' power mode with wakeup GPIO and PDS file %s\n",
422 			wdev->pdata.file_pds);
423 		gpiod_set_value_cansleep(wdev->pdata.gpio_wakeup, 1);
424 		wfx_control_reg_write(wdev, 0);
425 		wfx_hif_set_operational_mode(wdev, HIF_OP_POWER_MODE_QUIESCENT);
426 	} else {
427 		wfx_hif_set_operational_mode(wdev, HIF_OP_POWER_MODE_DOZE);
428 	}
429 
430 	for (i = 0; i < ARRAY_SIZE(wdev->addresses); i++) {
431 		eth_zero_addr(wdev->addresses[i].addr);
432 		err = of_get_mac_address(wdev->dev->of_node, wdev->addresses[i].addr);
433 		if (!err)
434 			wdev->addresses[i].addr[ETH_ALEN - 1] += i;
435 		else
436 			ether_addr_copy(wdev->addresses[i].addr, wdev->hw_caps.mac_addr[i]);
437 		if (!is_valid_ether_addr(wdev->addresses[i].addr)) {
438 			dev_warn(wdev->dev, "using random MAC address\n");
439 			eth_random_addr(wdev->addresses[i].addr);
440 		}
441 		dev_info(wdev->dev, "MAC address %d: %pM\n", i, wdev->addresses[i].addr);
442 	}
443 	wdev->hw->wiphy->n_addresses = ARRAY_SIZE(wdev->addresses);
444 	wdev->hw->wiphy->addresses = wdev->addresses;
445 
446 	if (!wfx_api_older_than(wdev, 3, 8))
447 		wdev->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
448 
449 	err = ieee80211_register_hw(wdev->hw);
450 	if (err)
451 		goto irq_unsubscribe;
452 
453 	err = wfx_debug_init(wdev);
454 	if (err)
455 		goto ieee80211_unregister;
456 
457 	return 0;
458 
459 ieee80211_unregister:
460 	ieee80211_unregister_hw(wdev->hw);
461 irq_unsubscribe:
462 	wdev->hwbus_ops->irq_unsubscribe(wdev->hwbus_priv);
463 bh_unregister:
464 	wfx_bh_unregister(wdev);
465 	destroy_workqueue(wdev->bh_wq);
466 	return err;
467 }
468 
469 void wfx_release(struct wfx_dev *wdev)
470 {
471 	ieee80211_unregister_hw(wdev->hw);
472 	wfx_hif_shutdown(wdev);
473 	wdev->hwbus_ops->irq_unsubscribe(wdev->hwbus_priv);
474 	wfx_bh_unregister(wdev);
475 	destroy_workqueue(wdev->bh_wq);
476 }
477 
478 static int __init wfx_core_init(void)
479 {
480 	int ret = 0;
481 
482 	if (IS_ENABLED(CONFIG_SPI))
483 		ret = spi_register_driver(&wfx_spi_driver);
484 	if (IS_ENABLED(CONFIG_MMC) && !ret)
485 		ret = sdio_register_driver(&wfx_sdio_driver);
486 	return ret;
487 }
488 module_init(wfx_core_init);
489 
490 static void __exit wfx_core_exit(void)
491 {
492 	if (IS_ENABLED(CONFIG_MMC))
493 		sdio_unregister_driver(&wfx_sdio_driver);
494 	if (IS_ENABLED(CONFIG_SPI))
495 		spi_unregister_driver(&wfx_spi_driver);
496 }
497 module_exit(wfx_core_exit);
498