1 /* $OpenBSD: if_iwm.c,v 1.39 2015/03/23 00:35:19 jsg Exp $ */
2
3 /*
4 * Copyright (c) 2014 genua mbh <info@genua.de>
5 * Copyright (c) 2014 Fixup Software Ltd.
6 *
7 * Permission to use, copy, modify, and distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
10 *
11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 */
19
20 /*-
21 * Based on BSD-licensed source modules in the Linux iwlwifi driver,
22 * which were used as the reference documentation for this implementation.
23 *
24 * Driver version we are currently based off of is
25 * Linux 3.14.3 (tag id a2df521e42b1d9a23f620ac79dbfe8655a8391dd)
26 *
27 ***********************************************************************
28 *
29 * This file is provided under a dual BSD/GPLv2 license. When using or
30 * redistributing this file, you may do so under either license.
31 *
32 * GPL LICENSE SUMMARY
33 *
34 * Copyright(c) 2007 - 2013 Intel Corporation. All rights reserved.
35 *
36 * This program is free software; you can redistribute it and/or modify
37 * it under the terms of version 2 of the GNU General Public License as
38 * published by the Free Software Foundation.
39 *
40 * This program is distributed in the hope that it will be useful, but
41 * WITHOUT ANY WARRANTY; without even the implied warranty of
42 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
43 * General Public License for more details.
44 *
45 * You should have received a copy of the GNU General Public License
46 * along with this program; if not, write to the Free Software
47 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
48 * USA
49 *
50 * The full GNU General Public License is included in this distribution
51 * in the file called COPYING.
52 *
53 * Contact Information:
54 * Intel Linux Wireless <ilw@linux.intel.com>
55 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
56 *
57 *
58 * BSD LICENSE
59 *
60 * Copyright(c) 2005 - 2013 Intel Corporation. All rights reserved.
61 * All rights reserved.
62 *
63 * Redistribution and use in source and binary forms, with or without
64 * modification, are permitted provided that the following conditions
65 * are met:
66 *
67 * * Redistributions of source code must retain the above copyright
68 * notice, this list of conditions and the following disclaimer.
69 * * Redistributions in binary form must reproduce the above copyright
70 * notice, this list of conditions and the following disclaimer in
71 * the documentation and/or other materials provided with the
72 * distribution.
73 * * Neither the name Intel Corporation nor the names of its
74 * contributors may be used to endorse or promote products derived
75 * from this software without specific prior written permission.
76 *
77 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
78 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
79 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
80 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
81 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
82 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
83 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
84 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
85 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
86 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
87 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
88 */
89 #include <sys/cdefs.h>
90 #include "opt_wlan.h"
91 #include "opt_iwm.h"
92
93 #include <sys/param.h>
94 #include <sys/bus.h>
95 #include <sys/conf.h>
96 #include <sys/endian.h>
97 #include <sys/firmware.h>
98 #include <sys/kernel.h>
99 #include <sys/malloc.h>
100 #include <sys/mbuf.h>
101 #include <sys/mutex.h>
102 #include <sys/module.h>
103 #include <sys/proc.h>
104 #include <sys/rman.h>
105 #include <sys/socket.h>
106 #include <sys/sockio.h>
107 #include <sys/sysctl.h>
108 #include <sys/linker.h>
109
110 #include <machine/bus.h>
111 #include <machine/endian.h>
112 #include <machine/resource.h>
113
114 #include <dev/pci/pcivar.h>
115 #include <dev/pci/pcireg.h>
116
117 #include <net/bpf.h>
118
119 #include <net/if.h>
120 #include <net/if_var.h>
121 #include <net/if_arp.h>
122 #include <net/if_dl.h>
123 #include <net/if_media.h>
124 #include <net/if_types.h>
125
126 #include <netinet/in.h>
127 #include <netinet/in_systm.h>
128 #include <netinet/if_ether.h>
129 #include <netinet/ip.h>
130
131 #include <net80211/ieee80211_var.h>
132 #include <net80211/ieee80211_regdomain.h>
133 #include <net80211/ieee80211_ratectl.h>
134 #include <net80211/ieee80211_radiotap.h>
135
136 #include <dev/iwm/if_iwmreg.h>
137 #include <dev/iwm/if_iwmvar.h>
138 #include <dev/iwm/if_iwm_debug.h>
139 #include <dev/iwm/if_iwm_constants.h>
140 #include <dev/iwm/if_iwm_util.h>
141 #include <dev/iwm/if_iwm_power.h>
142
143 static int iwm_power_scheme = IWM_POWER_SCHEME_BPS;
144
145 TUNABLE_INT("hw.iwm.power_scheme", &iwm_power_scheme);
146
147 /*
148 * BEGIN mvm/power.c
149 */
150
151 #define IWM_POWER_KEEP_ALIVE_PERIOD_SEC 25
152
153 static int
iwm_beacon_filter_send_cmd(struct iwm_softc * sc,struct iwm_beacon_filter_cmd * cmd)154 iwm_beacon_filter_send_cmd(struct iwm_softc *sc,
155 struct iwm_beacon_filter_cmd *cmd)
156 {
157 int ret;
158
159 ret = iwm_send_cmd_pdu(sc, IWM_REPLY_BEACON_FILTERING_CMD,
160 0, sizeof(struct iwm_beacon_filter_cmd), cmd);
161
162 if (!ret) {
163 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
164 "ba_enable_beacon_abort is: %d\n",
165 le32toh(cmd->ba_enable_beacon_abort));
166 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
167 "ba_escape_timer is: %d\n",
168 le32toh(cmd->ba_escape_timer));
169 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
170 "bf_debug_flag is: %d\n",
171 le32toh(cmd->bf_debug_flag));
172 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
173 "bf_enable_beacon_filter is: %d\n",
174 le32toh(cmd->bf_enable_beacon_filter));
175 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
176 "bf_energy_delta is: %d\n",
177 le32toh(cmd->bf_energy_delta));
178 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
179 "bf_escape_timer is: %d\n",
180 le32toh(cmd->bf_escape_timer));
181 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
182 "bf_roaming_energy_delta is: %d\n",
183 le32toh(cmd->bf_roaming_energy_delta));
184 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
185 "bf_roaming_state is: %d\n",
186 le32toh(cmd->bf_roaming_state));
187 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
188 "bf_temp_threshold is: %d\n",
189 le32toh(cmd->bf_temp_threshold));
190 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
191 "bf_temp_fast_filter is: %d\n",
192 le32toh(cmd->bf_temp_fast_filter));
193 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
194 "bf_temp_slow_filter is: %d\n",
195 le32toh(cmd->bf_temp_slow_filter));
196 }
197 return ret;
198 }
199
200 static void
iwm_beacon_filter_set_cqm_params(struct iwm_softc * sc,struct iwm_vap * ivp,struct iwm_beacon_filter_cmd * cmd)201 iwm_beacon_filter_set_cqm_params(struct iwm_softc *sc,
202 struct iwm_vap *ivp, struct iwm_beacon_filter_cmd *cmd)
203 {
204 cmd->ba_enable_beacon_abort = htole32(sc->sc_bf.ba_enabled);
205 }
206
207 static void
iwm_power_log(struct iwm_softc * sc,struct iwm_mac_power_cmd * cmd)208 iwm_power_log(struct iwm_softc *sc, struct iwm_mac_power_cmd *cmd)
209 {
210 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
211 "Sending power table command on mac id 0x%X for "
212 "power level %d, flags = 0x%X\n",
213 cmd->id_and_color, iwm_power_scheme, le16toh(cmd->flags));
214 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
215 "Keep alive = %u sec\n", le16toh(cmd->keep_alive_seconds));
216
217 if (!(cmd->flags & htole16(IWM_POWER_FLAGS_POWER_MANAGEMENT_ENA_MSK))) {
218 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
219 "Disable power management\n");
220 return;
221 }
222
223 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
224 "Rx timeout = %u usec\n", le32toh(cmd->rx_data_timeout));
225 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
226 "Tx timeout = %u usec\n", le32toh(cmd->tx_data_timeout));
227 if (cmd->flags & htole16(IWM_POWER_FLAGS_SKIP_OVER_DTIM_MSK))
228 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
229 "DTIM periods to skip = %u\n", cmd->skip_dtim_periods);
230 }
231
232 static boolean_t
iwm_power_is_radar(struct iwm_softc * sc)233 iwm_power_is_radar(struct iwm_softc *sc)
234 {
235 struct ieee80211com *ic = &sc->sc_ic;
236 struct ieee80211_channel *chan;
237 boolean_t radar_detect = FALSE;
238
239 chan = ic->ic_bsschan;
240 if (chan == IEEE80211_CHAN_ANYC ||
241 (chan->ic_flags & IEEE80211_CHAN_DFS) != 0) {
242 radar_detect = TRUE;
243 }
244
245 return radar_detect;
246 }
247
248 static void
iwm_power_config_skip_dtim(struct iwm_softc * sc,struct iwm_mac_power_cmd * cmd)249 iwm_power_config_skip_dtim(struct iwm_softc *sc,
250 struct iwm_mac_power_cmd *cmd)
251 {
252 struct ieee80211com *ic = &sc->sc_ic;
253 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
254 int dtimper = vap->iv_dtim_period ?: 1;
255 int skip;
256
257 /* disable, in case we're supposed to override */
258 cmd->skip_dtim_periods = 0;
259 cmd->flags &= ~htole16(IWM_POWER_FLAGS_SKIP_OVER_DTIM_MSK);
260
261 if (iwm_power_is_radar(sc))
262 return;
263
264 if (dtimper >= 10)
265 return;
266
267 /* TODO: check that multicast wake lock is off */
268
269 if (iwm_power_scheme != IWM_POWER_SCHEME_LP)
270 return;
271 skip = 2;
272
273 /* the firmware really expects "look at every X DTIMs", so add 1 */
274 cmd->skip_dtim_periods = 1 + skip;
275 cmd->flags |= htole16(IWM_POWER_FLAGS_SKIP_OVER_DTIM_MSK);
276 }
277
278 static void
iwm_power_build_cmd(struct iwm_softc * sc,struct iwm_vap * ivp,struct iwm_mac_power_cmd * cmd)279 iwm_power_build_cmd(struct iwm_softc *sc, struct iwm_vap *ivp,
280 struct iwm_mac_power_cmd *cmd)
281 {
282 struct ieee80211vap *vap = &ivp->iv_vap;
283 struct ieee80211_node *ni = vap->iv_bss;
284 int dtimper, dtimper_msec;
285 int keep_alive;
286 boolean_t bss_conf_ps = FALSE;
287
288 cmd->id_and_color = htole32(IWM_FW_CMD_ID_AND_COLOR(ivp->id,
289 ivp->color));
290 dtimper = vap->iv_dtim_period ?: 1;
291
292 /*
293 * Regardless of power management state the driver must set
294 * keep alive period. FW will use it for sending keep alive NDPs
295 * immediately after association. Check that keep alive period
296 * is at least 3 * DTIM
297 */
298 dtimper_msec = dtimper * ni->ni_intval;
299 keep_alive
300 = imax(3 * dtimper_msec, 1000 * IWM_POWER_KEEP_ALIVE_PERIOD_SEC);
301 keep_alive = roundup(keep_alive, 1000) / 1000;
302 cmd->keep_alive_seconds = htole16(keep_alive);
303
304 if (sc->sc_ps_disabled)
305 return;
306
307 cmd->flags |= htole16(IWM_POWER_FLAGS_POWER_SAVE_ENA_MSK);
308
309 if (IWM_NODE(ni)->in_assoc &&
310 (vap->iv_flags & IEEE80211_F_PMGTON) != 0) {
311 bss_conf_ps = TRUE;
312 }
313 if (!bss_conf_ps)
314 return;
315
316 cmd->flags |= htole16(IWM_POWER_FLAGS_POWER_MANAGEMENT_ENA_MSK);
317
318 iwm_power_config_skip_dtim(sc, cmd);
319
320 cmd->rx_data_timeout =
321 htole32(IWM_DEFAULT_PS_RX_DATA_TIMEOUT);
322 cmd->tx_data_timeout =
323 htole32(IWM_DEFAULT_PS_TX_DATA_TIMEOUT);
324 }
325
326 static int
iwm_power_send_cmd(struct iwm_softc * sc,struct iwm_vap * ivp)327 iwm_power_send_cmd(struct iwm_softc *sc, struct iwm_vap *ivp)
328 {
329 struct iwm_mac_power_cmd cmd = {};
330
331 iwm_power_build_cmd(sc, ivp, &cmd);
332 iwm_power_log(sc, &cmd);
333
334 return iwm_send_cmd_pdu(sc, IWM_MAC_PM_POWER_TABLE, 0,
335 sizeof(cmd), &cmd);
336 }
337
338 static int
_iwm_enable_beacon_filter(struct iwm_softc * sc,struct iwm_vap * ivp,struct iwm_beacon_filter_cmd * cmd)339 _iwm_enable_beacon_filter(struct iwm_softc *sc, struct iwm_vap *ivp,
340 struct iwm_beacon_filter_cmd *cmd)
341 {
342 int ret;
343
344 iwm_beacon_filter_set_cqm_params(sc, ivp, cmd);
345 ret = iwm_beacon_filter_send_cmd(sc, cmd);
346
347 if (!ret)
348 sc->sc_bf.bf_enabled = 1;
349
350 return ret;
351 }
352
353 int
iwm_enable_beacon_filter(struct iwm_softc * sc,struct iwm_vap * ivp)354 iwm_enable_beacon_filter(struct iwm_softc *sc, struct iwm_vap *ivp)
355 {
356 struct iwm_beacon_filter_cmd cmd = {
357 IWM_BF_CMD_CONFIG_DEFAULTS,
358 .bf_enable_beacon_filter = htole32(1),
359 };
360
361 return _iwm_enable_beacon_filter(sc, ivp, &cmd);
362 }
363
364 int
iwm_disable_beacon_filter(struct iwm_softc * sc)365 iwm_disable_beacon_filter(struct iwm_softc *sc)
366 {
367 struct iwm_beacon_filter_cmd cmd = {};
368 int ret;
369
370 ret = iwm_beacon_filter_send_cmd(sc, &cmd);
371 if (ret == 0)
372 sc->sc_bf.bf_enabled = 0;
373
374 return ret;
375 }
376
377 static int
iwm_power_set_ps(struct iwm_softc * sc)378 iwm_power_set_ps(struct iwm_softc *sc)
379 {
380 struct ieee80211vap *vap;
381 boolean_t disable_ps;
382 int ret;
383
384 /* disable PS if CAM */
385 disable_ps = (iwm_power_scheme == IWM_POWER_SCHEME_CAM);
386 /* ...or if any of the vifs require PS to be off */
387 TAILQ_FOREACH(vap, &sc->sc_ic.ic_vaps, iv_next) {
388 struct iwm_vap *ivp = IWM_VAP(vap);
389 if (ivp->phy_ctxt != NULL && ivp->ps_disabled)
390 disable_ps = TRUE;
391 }
392
393 /* update device power state if it has changed */
394 if (sc->sc_ps_disabled != disable_ps) {
395 boolean_t old_ps_disabled = sc->sc_ps_disabled;
396
397 sc->sc_ps_disabled = disable_ps;
398 ret = iwm_power_update_device(sc);
399 if (ret) {
400 sc->sc_ps_disabled = old_ps_disabled;
401 return ret;
402 }
403 }
404
405 return 0;
406 }
407
408 static int
iwm_power_set_ba(struct iwm_softc * sc,struct iwm_vap * ivp)409 iwm_power_set_ba(struct iwm_softc *sc, struct iwm_vap *ivp)
410 {
411 struct iwm_beacon_filter_cmd cmd = {
412 IWM_BF_CMD_CONFIG_DEFAULTS,
413 .bf_enable_beacon_filter = htole32(1),
414 };
415 struct ieee80211vap *vap = &ivp->iv_vap;
416 struct ieee80211_node *ni = vap->iv_bss;
417 boolean_t bss_conf_ps = FALSE;
418
419 if (!sc->sc_bf.bf_enabled)
420 return 0;
421
422 if (ni != NULL && IWM_NODE(ni)->in_assoc &&
423 (vap->iv_flags & IEEE80211_F_PMGTON) != 0) {
424 bss_conf_ps = TRUE;
425 }
426 sc->sc_bf.ba_enabled = !sc->sc_ps_disabled && bss_conf_ps;
427
428 return _iwm_enable_beacon_filter(sc, ivp, &cmd);
429 }
430
431 int
iwm_power_update_ps(struct iwm_softc * sc)432 iwm_power_update_ps(struct iwm_softc *sc)
433 {
434 struct ieee80211vap *vap = TAILQ_FIRST(&sc->sc_ic.ic_vaps);
435 int ret;
436
437 ret = iwm_power_set_ps(sc);
438 if (ret)
439 return ret;
440
441 if (vap != NULL)
442 return iwm_power_set_ba(sc, IWM_VAP(vap));
443
444 return 0;
445 }
446
447 int
iwm_power_update_mac(struct iwm_softc * sc)448 iwm_power_update_mac(struct iwm_softc *sc)
449 {
450 struct ieee80211vap *vap = TAILQ_FIRST(&sc->sc_ic.ic_vaps);
451 int ret;
452
453 ret = iwm_power_set_ps(sc);
454 if (ret)
455 return ret;
456
457 if (vap != NULL) {
458 ret = iwm_power_send_cmd(sc, IWM_VAP(vap));
459 if (ret)
460 return ret;
461 }
462
463 if (vap != NULL)
464 return iwm_power_set_ba(sc, IWM_VAP(vap));
465
466 return 0;
467 }
468
469 int
iwm_power_update_device(struct iwm_softc * sc)470 iwm_power_update_device(struct iwm_softc *sc)
471 {
472 struct iwm_device_power_cmd cmd = {
473 .flags = 0,
474 };
475
476 if (iwm_power_scheme == IWM_POWER_SCHEME_CAM)
477 sc->sc_ps_disabled = TRUE;
478
479 if (!sc->sc_ps_disabled)
480 cmd.flags |= htole16(IWM_DEVICE_POWER_FLAGS_POWER_SAVE_ENA_MSK);
481
482 IWM_DPRINTF(sc, IWM_DEBUG_PWRSAVE | IWM_DEBUG_CMD,
483 "Sending device power command with flags = 0x%X\n", cmd.flags);
484
485 return iwm_send_cmd_pdu(sc,
486 IWM_POWER_TABLE_CMD, 0, sizeof(cmd), &cmd);
487 }
488