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_MAX_SIZE 1500
37
38 MODULE_DESCRIPTION("Silicon Labs 802.11 Wireless LAN driver for WFx");
39 MODULE_AUTHOR("Jérôme Pouiller <jerome.pouiller@silabs.com>");
40 MODULE_LICENSE("GPL");
41
42 #define RATETAB_ENT(_rate, _rateid, _flags) { \
43 .bitrate = (_rate), \
44 .hw_value = (_rateid), \
45 .flags = (_flags), \
46 }
47
48 static struct ieee80211_rate wfx_rates[] = {
49 RATETAB_ENT(10, 0, 0),
50 RATETAB_ENT(20, 1, IEEE80211_RATE_SHORT_PREAMBLE),
51 RATETAB_ENT(55, 2, IEEE80211_RATE_SHORT_PREAMBLE),
52 RATETAB_ENT(110, 3, IEEE80211_RATE_SHORT_PREAMBLE),
53 RATETAB_ENT(60, 6, 0),
54 RATETAB_ENT(90, 7, 0),
55 RATETAB_ENT(120, 8, 0),
56 RATETAB_ENT(180, 9, 0),
57 RATETAB_ENT(240, 10, 0),
58 RATETAB_ENT(360, 11, 0),
59 RATETAB_ENT(480, 12, 0),
60 RATETAB_ENT(540, 13, 0),
61 };
62
63 #define CHAN2G(_channel, _freq, _flags) { \
64 .band = NL80211_BAND_2GHZ, \
65 .center_freq = (_freq), \
66 .hw_value = (_channel), \
67 .flags = (_flags), \
68 .max_antenna_gain = 0, \
69 .max_power = 30, \
70 }
71
72 static struct ieee80211_channel wfx_2ghz_chantable[] = {
73 CHAN2G(1, 2412, 0),
74 CHAN2G(2, 2417, 0),
75 CHAN2G(3, 2422, 0),
76 CHAN2G(4, 2427, 0),
77 CHAN2G(5, 2432, 0),
78 CHAN2G(6, 2437, 0),
79 CHAN2G(7, 2442, 0),
80 CHAN2G(8, 2447, 0),
81 CHAN2G(9, 2452, 0),
82 CHAN2G(10, 2457, 0),
83 CHAN2G(11, 2462, 0),
84 CHAN2G(12, 2467, 0),
85 CHAN2G(13, 2472, 0),
86 CHAN2G(14, 2484, 0),
87 };
88
89 static const struct ieee80211_supported_band wfx_band_2ghz = {
90 .channels = wfx_2ghz_chantable,
91 .n_channels = ARRAY_SIZE(wfx_2ghz_chantable),
92 .bitrates = wfx_rates,
93 .n_bitrates = ARRAY_SIZE(wfx_rates),
94 .ht_cap = {
95 // Receive caps
96 .cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 |
97 IEEE80211_HT_CAP_MAX_AMSDU |
98 (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
wfx_api_older_than(struct wfx_dev * wdev,int major,int minor)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 /* NOTE: wfx_send_pds() destroy buf */
wfx_send_pds(struct wfx_dev * wdev,u8 * buf,size_t len)167 int wfx_send_pds(struct wfx_dev *wdev, u8 *buf, size_t len)
168 {
169 int ret;
170 int start, brace_level, i;
171
172 start = 0;
173 brace_level = 0;
174 if (buf[0] != '{') {
175 dev_err(wdev->dev, "valid PDS start with '{'. Did you forget to compress it?\n");
176 return -EINVAL;
177 }
178 for (i = 1; i < len - 1; i++) {
179 if (buf[i] == '{')
180 brace_level++;
181 if (buf[i] == '}')
182 brace_level--;
183 if (buf[i] == '}' && !brace_level) {
184 i++;
185 if (i - start + 1 > WFX_PDS_MAX_SIZE)
186 return -EFBIG;
187 buf[start] = '{';
188 buf[i] = 0;
189 dev_dbg(wdev->dev, "send PDS '%s}'\n", buf + start);
190 buf[i] = '}';
191 ret = hif_configuration(wdev, buf + start,
192 i - start + 1);
193 if (ret > 0) {
194 dev_err(wdev->dev, "PDS bytes %d to %d: invalid data (unsupported options?)\n",
195 start, i);
196 return -EINVAL;
197 }
198 if (ret == -ETIMEDOUT) {
199 dev_err(wdev->dev, "PDS bytes %d to %d: chip didn't reply (corrupted file?)\n",
200 start, i);
201 return ret;
202 }
203 if (ret) {
204 dev_err(wdev->dev, "PDS bytes %d to %d: chip returned an unknown error\n",
205 start, i);
206 return -EIO;
207 }
208 buf[i] = ',';
209 start = i;
210 }
211 }
212 return 0;
213 }
214
wfx_send_pdata_pds(struct wfx_dev * wdev)215 static int wfx_send_pdata_pds(struct wfx_dev *wdev)
216 {
217 int ret = 0;
218 const struct firmware *pds;
219 u8 *tmp_buf;
220
221 ret = request_firmware(&pds, wdev->pdata.file_pds, wdev->dev);
222 if (ret) {
223 dev_err(wdev->dev, "can't load PDS file %s\n",
224 wdev->pdata.file_pds);
225 goto err1;
226 }
227 tmp_buf = kmemdup(pds->data, pds->size, GFP_KERNEL);
228 if (!tmp_buf) {
229 ret = -ENOMEM;
230 goto err2;
231 }
232 ret = wfx_send_pds(wdev, tmp_buf, pds->size);
233 kfree(tmp_buf);
234 err2:
235 release_firmware(pds);
236 err1:
237 return ret;
238 }
239
wfx_free_common(void * data)240 static void wfx_free_common(void *data)
241 {
242 struct wfx_dev *wdev = data;
243
244 mutex_destroy(&wdev->tx_power_loop_info_lock);
245 mutex_destroy(&wdev->rx_stats_lock);
246 mutex_destroy(&wdev->conf_mutex);
247 ieee80211_free_hw(wdev->hw);
248 }
249
wfx_init_common(struct device * dev,const struct wfx_platform_data * pdata,const struct hwbus_ops * hwbus_ops,void * hwbus_priv)250 struct wfx_dev *wfx_init_common(struct device *dev,
251 const struct wfx_platform_data *pdata,
252 const struct hwbus_ops *hwbus_ops,
253 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 hif_msg)
279 + sizeof(struct hif_req_tx)
280 + 4 /* alignment */ + 8 /* TKIP IV */;
281 hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
282 BIT(NL80211_IFTYPE_ADHOC) |
283 BIT(NL80211_IFTYPE_AP);
284 hw->wiphy->probe_resp_offload = NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
285 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
286 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P |
287 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_80211U;
288 hw->wiphy->features |= NL80211_FEATURE_AP_SCAN;
289 hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
290 hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
291 hw->wiphy->max_ap_assoc_sta = HIF_LINK_ID_MAX;
292 hw->wiphy->max_scan_ssids = 2;
293 hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
294 hw->wiphy->n_iface_combinations = ARRAY_SIZE(wfx_iface_combinations);
295 hw->wiphy->iface_combinations = wfx_iface_combinations;
296 hw->wiphy->bands[NL80211_BAND_2GHZ] = devm_kmalloc(dev, sizeof(wfx_band_2ghz), GFP_KERNEL);
297 // FIXME: also copy wfx_rates and wfx_2ghz_chantable
298 memcpy(hw->wiphy->bands[NL80211_BAND_2GHZ], &wfx_band_2ghz,
299 sizeof(wfx_band_2ghz));
300
301 wdev = hw->priv;
302 wdev->hw = hw;
303 wdev->dev = dev;
304 wdev->hwbus_ops = hwbus_ops;
305 wdev->hwbus_priv = hwbus_priv;
306 memcpy(&wdev->pdata, pdata, sizeof(*pdata));
307 of_property_read_string(dev->of_node, "config-file",
308 &wdev->pdata.file_pds);
309 wdev->pdata.gpio_wakeup = devm_gpiod_get_optional(dev, "wakeup",
310 GPIOD_OUT_LOW);
311 if (IS_ERR(wdev->pdata.gpio_wakeup))
312 goto err;
313
314 if (wdev->pdata.gpio_wakeup)
315 gpiod_set_consumer_name(wdev->pdata.gpio_wakeup, "wfx wakeup");
316
317 mutex_init(&wdev->conf_mutex);
318 mutex_init(&wdev->rx_stats_lock);
319 mutex_init(&wdev->tx_power_loop_info_lock);
320 init_completion(&wdev->firmware_ready);
321 INIT_DELAYED_WORK(&wdev->cooling_timeout_work,
322 wfx_cooling_timeout_work);
323 skb_queue_head_init(&wdev->tx_pending);
324 init_waitqueue_head(&wdev->tx_dequeue);
325 wfx_init_hif_cmd(&wdev->hif_cmd);
326 wdev->force_ps_timeout = -1;
327
328 if (devm_add_action_or_reset(dev, wfx_free_common, wdev))
329 return NULL;
330
331 return wdev;
332
333 err:
334 ieee80211_free_hw(hw);
335 return NULL;
336 }
337
wfx_probe(struct wfx_dev * wdev)338 int wfx_probe(struct wfx_dev *wdev)
339 {
340 int i;
341 int err;
342 const void *macaddr;
343 struct gpio_desc *gpio_saved;
344
345 // During first part of boot, gpio_wakeup cannot yet been used. So
346 // prevent bh() to touch it.
347 gpio_saved = wdev->pdata.gpio_wakeup;
348 wdev->pdata.gpio_wakeup = NULL;
349 wdev->poll_irq = true;
350
351 wfx_bh_register(wdev);
352
353 err = wfx_init_device(wdev);
354 if (err)
355 goto err0;
356
357 wfx_bh_poll_irq(wdev);
358 err = wait_for_completion_timeout(&wdev->firmware_ready, 1 * HZ);
359 if (err <= 0) {
360 if (err == 0) {
361 dev_err(wdev->dev, "timeout while waiting for startup indication\n");
362 err = -ETIMEDOUT;
363 } else if (err == -ERESTARTSYS) {
364 dev_info(wdev->dev, "probe interrupted by user\n");
365 }
366 goto err0;
367 }
368
369 // FIXME: fill wiphy::hw_version
370 dev_info(wdev->dev, "started firmware %d.%d.%d \"%s\" (API: %d.%d, keyset: %02X, caps: 0x%.8X)\n",
371 wdev->hw_caps.firmware_major, wdev->hw_caps.firmware_minor,
372 wdev->hw_caps.firmware_build, wdev->hw_caps.firmware_label,
373 wdev->hw_caps.api_version_major, wdev->hw_caps.api_version_minor,
374 wdev->keyset, wdev->hw_caps.link_mode);
375 snprintf(wdev->hw->wiphy->fw_version,
376 sizeof(wdev->hw->wiphy->fw_version),
377 "%d.%d.%d",
378 wdev->hw_caps.firmware_major,
379 wdev->hw_caps.firmware_minor,
380 wdev->hw_caps.firmware_build);
381
382 if (wfx_api_older_than(wdev, 1, 0)) {
383 dev_err(wdev->dev,
384 "unsupported firmware API version (expect 1 while firmware returns %d)\n",
385 wdev->hw_caps.api_version_major);
386 err = -ENOTSUPP;
387 goto err0;
388 }
389
390 if (wdev->hw_caps.link_mode == SEC_LINK_ENFORCED) {
391 dev_err(wdev->dev,
392 "chip require secure_link, but can't negotiate it\n");
393 goto err0;
394 }
395
396 if (wdev->hw_caps.region_sel_mode) {
397 wdev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels[11].flags |= IEEE80211_CHAN_NO_IR;
398 wdev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels[12].flags |= IEEE80211_CHAN_NO_IR;
399 wdev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels[13].flags |= IEEE80211_CHAN_DISABLED;
400 }
401
402 dev_dbg(wdev->dev, "sending configuration file %s\n",
403 wdev->pdata.file_pds);
404 err = wfx_send_pdata_pds(wdev);
405 if (err < 0)
406 goto err0;
407
408 wdev->poll_irq = false;
409 err = wdev->hwbus_ops->irq_subscribe(wdev->hwbus_priv);
410 if (err)
411 goto err0;
412
413 err = hif_use_multi_tx_conf(wdev, true);
414 if (err)
415 dev_err(wdev->dev, "misconfigured IRQ?\n");
416
417 wdev->pdata.gpio_wakeup = gpio_saved;
418 if (wdev->pdata.gpio_wakeup) {
419 dev_dbg(wdev->dev,
420 "enable 'quiescent' power mode with wakeup GPIO and PDS file %s\n",
421 wdev->pdata.file_pds);
422 gpiod_set_value_cansleep(wdev->pdata.gpio_wakeup, 1);
423 control_reg_write(wdev, 0);
424 hif_set_operational_mode(wdev, HIF_OP_POWER_MODE_QUIESCENT);
425 } else {
426 hif_set_operational_mode(wdev, HIF_OP_POWER_MODE_DOZE);
427 }
428
429 for (i = 0; i < ARRAY_SIZE(wdev->addresses); i++) {
430 eth_zero_addr(wdev->addresses[i].addr);
431 macaddr = of_get_mac_address(wdev->dev->of_node);
432 if (!IS_ERR_OR_NULL(macaddr)) {
433 ether_addr_copy(wdev->addresses[i].addr, macaddr);
434 wdev->addresses[i].addr[ETH_ALEN - 1] += i;
435 } else {
436 ether_addr_copy(wdev->addresses[i].addr,
437 wdev->hw_caps.mac_addr[i]);
438 }
439 if (!is_valid_ether_addr(wdev->addresses[i].addr)) {
440 dev_warn(wdev->dev, "using random MAC address\n");
441 eth_random_addr(wdev->addresses[i].addr);
442 }
443 dev_info(wdev->dev, "MAC address %d: %pM\n", i,
444 wdev->addresses[i].addr);
445 }
446 wdev->hw->wiphy->n_addresses = ARRAY_SIZE(wdev->addresses);
447 wdev->hw->wiphy->addresses = wdev->addresses;
448
449 err = ieee80211_register_hw(wdev->hw);
450 if (err)
451 goto err1;
452
453 err = wfx_debug_init(wdev);
454 if (err)
455 goto err2;
456
457 return 0;
458
459 err2:
460 ieee80211_unregister_hw(wdev->hw);
461 err1:
462 wdev->hwbus_ops->irq_unsubscribe(wdev->hwbus_priv);
463 err0:
464 wfx_bh_unregister(wdev);
465 return err;
466 }
467
wfx_release(struct wfx_dev * wdev)468 void wfx_release(struct wfx_dev *wdev)
469 {
470 ieee80211_unregister_hw(wdev->hw);
471 hif_shutdown(wdev);
472 wdev->hwbus_ops->irq_unsubscribe(wdev->hwbus_priv);
473 wfx_bh_unregister(wdev);
474 }
475
wfx_core_init(void)476 static int __init wfx_core_init(void)
477 {
478 int ret = 0;
479
480 if (IS_ENABLED(CONFIG_SPI))
481 ret = spi_register_driver(&wfx_spi_driver);
482 if (IS_ENABLED(CONFIG_MMC) && !ret)
483 ret = sdio_register_driver(&wfx_sdio_driver);
484 return ret;
485 }
486 module_init(wfx_core_init);
487
wfx_core_exit(void)488 static void __exit wfx_core_exit(void)
489 {
490 if (IS_ENABLED(CONFIG_MMC))
491 sdio_unregister_driver(&wfx_sdio_driver);
492 if (IS_ENABLED(CONFIG_SPI))
493 spi_unregister_driver(&wfx_spi_driver);
494 }
495 module_exit(wfx_core_exit);
496