]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blame - drivers/net/wireless/b43/main.c
projects / mirror_ubuntu-hirsute-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
b43: drop Copyright for not really copyrightable info
[mirror_ubuntu-hirsute-kernel.git] / drivers / net / wireless / b43 / main.c
CommitLineData
e4d6b795
MB		 1/*
2
3 Broadcom B43 wireless driver
4
5 Copyright (c) 2005 Martin Langer <martin-langer@gmx.de>
1f21ad2a 6 Copyright (c) 2005 Stefano Brivio <stefano.brivio@polimi.it>
eb032b98 7 Copyright (c) 2005-2009 Michael Buesch <m@bues.ch>
e4d6b795
MB		 8 Copyright (c) 2005 Danny van Dyk <kugelfang@gentoo.org>
9 Copyright (c) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
10
3dbba8e2
AH		 11 SDIO support
12 Copyright (c) 2009 Albert Herranz <albert_herranz@yahoo.es>
13
e4d6b795
MB		 14 Some parts of the code in this file are derived from the ipw2200
15 driver Copyright(c) 2003 - 2004 Intel Corporation.
16
17 This program is free software; you can redistribute it and/or modify
18 it under the terms of the GNU General Public License as published by
19 the Free Software Foundation; either version 2 of the License, or
20 (at your option) any later version.
21
22 This program is distributed in the hope that it will be useful,
23 but WITHOUT ANY WARRANTY; without even the implied warranty of
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 GNU General Public License for more details.
26
27 You should have received a copy of the GNU General Public License
28 along with this program; see the file COPYING. If not, write to
29 the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
30 Boston, MA 02110-1301, USA.
31
32*/
33
34#include <linux/delay.h>
35#include <linux/init.h>
36#include <linux/moduleparam.h>
37#include <linux/if_arp.h>
38#include <linux/etherdevice.h>
e4d6b795 39#include <linux/firmware.h>
e4d6b795
MB		 40#include <linux/workqueue.h>
41#include <linux/skbuff.h>
96cf49a2 42#include <linux/io.h>
e4d6b795 43#include <linux/dma-mapping.h>
5a0e3ad6 44#include <linux/slab.h>
e4d6b795
MB		 45#include <asm/unaligned.h>
46
47#include "b43.h"
48#include "main.h"
49#include "debugfs.h"
ef1a628d
MB		 50#include "phy_common.h"
51#include "phy_g.h"
3d0da751 52#include "phy_n.h"
e4d6b795 53#include "dma.h"
5100d5ac 54#include "pio.h"
e4d6b795
MB		 55#include "sysfs.h"
56#include "xmit.h"
e4d6b795
MB		 57#include "lo.h"
58#include "pcmcia.h"
3dbba8e2
AH		 59#include "sdio.h"
60#include <linux/mmc/sdio_func.h>
e4d6b795
MB		 61
62MODULE_DESCRIPTION("Broadcom B43 wireless driver");
63MODULE_AUTHOR("Martin Langer");
64MODULE_AUTHOR("Stefano Brivio");
65MODULE_AUTHOR("Michael Buesch");
0136e51e 66MODULE_AUTHOR("Gábor Stefanik");
e4d6b795
MB		 67MODULE_LICENSE("GPL");
68
6021e08d
TG		 69MODULE_FIRMWARE("b43/ucode11.fw");
70MODULE_FIRMWARE("b43/ucode13.fw");
71MODULE_FIRMWARE("b43/ucode14.fw");
72MODULE_FIRMWARE("b43/ucode15.fw");
f6158394 73MODULE_FIRMWARE("b43/ucode16_mimo.fw");
6021e08d
TG		 74MODULE_FIRMWARE("b43/ucode5.fw");
75MODULE_FIRMWARE("b43/ucode9.fw");
e4d6b795
MB		 76
77static int modparam_bad_frames_preempt;
78module_param_named(bad_frames_preempt, modparam_bad_frames_preempt, int, 0444);
79MODULE_PARM_DESC(bad_frames_preempt,
80 "enable(1) / disable(0) Bad Frames Preemption");
81
e4d6b795
MB		 82static char modparam_fwpostfix[16];
83module_param_string(fwpostfix, modparam_fwpostfix, 16, 0444);
84MODULE_PARM_DESC(fwpostfix, "Postfix for the .fw files to load.");
85
e4d6b795
MB		 86static int modparam_hwpctl;
87module_param_named(hwpctl, modparam_hwpctl, int, 0444);
88MODULE_PARM_DESC(hwpctl, "Enable hardware-side power control (default off)");
89
90static int modparam_nohwcrypt;
91module_param_named(nohwcrypt, modparam_nohwcrypt, int, 0444);
92MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption.");
93
035d0243 94static int modparam_hwtkip;
95module_param_named(hwtkip, modparam_hwtkip, int, 0444);
96MODULE_PARM_DESC(hwtkip, "Enable hardware tkip.");
97
403a3a13
MB		 98static int modparam_qos = 1;
99module_param_named(qos, modparam_qos, int, 0444);
e6f5b934
MB		 100MODULE_PARM_DESC(qos, "Enable QOS support (default on)");
101
1855ba78
MB		 102static int modparam_btcoex = 1;
103module_param_named(btcoex, modparam_btcoex, int, 0444);
c71dbd33 104MODULE_PARM_DESC(btcoex, "Enable Bluetooth coexistence (default on)");
1855ba78 105
060210f9
MB		 106int b43_modparam_verbose = B43_VERBOSITY_DEFAULT;
107module_param_named(verbose, b43_modparam_verbose, int, 0644);
108MODULE_PARM_DESC(verbose, "Log message verbosity: 0=error, 1=warn, 2=info(default), 3=debug");
109
df766267 110static int b43_modparam_pio = 0;
9e3bd919
LT		 111module_param_named(pio, b43_modparam_pio, int, 0644);
112MODULE_PARM_DESC(pio, "Use PIO accesses by default: 0=DMA, 1=PIO");
e6f5b934 113
3c65ab62
RM		 114#ifdef CONFIG_B43_BCMA
115static const struct bcma_device_id b43_bcma_tbl[] = {
c027ed4c 116 BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x11, BCMA_ANY_CLASS),
3c65ab62
RM		 117 BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x17, BCMA_ANY_CLASS),
118 BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x18, BCMA_ANY_CLASS),
119 BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x1D, BCMA_ANY_CLASS),
120 BCMA_CORETABLE_END
121};
122MODULE_DEVICE_TABLE(bcma, b43_bcma_tbl);
123#endif
124
aec7ffdf 125#ifdef CONFIG_B43_SSB
e4d6b795
MB		 126static const struct ssb_device_id b43_ssb_tbl[] = {
127 SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 5),
128 SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 6),
129 SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 7),
130 SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 9),
131 SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 10),
d5c71e46 132 SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 11),
003d6d27 133 SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 12),
013978b6 134 SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 13),
6b1c7c67 135 SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 15),
92d6128e 136 SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 16),
e4d6b795
MB		 137 SSB_DEVTABLE_END
138};
e4d6b795 139MODULE_DEVICE_TABLE(ssb, b43_ssb_tbl);
aec7ffdf 140#endif
e4d6b795
MB		 141
142/* Channel and ratetables are shared for all devices.
143 * They can't be const, because ieee80211 puts some precalculated
144 * data in there. This data is the same for all devices, so we don't
145 * get concurrency issues */
146#define RATETAB_ENT(_rateid, _flags) \
8318d78a
JB		 147 { \
148 .bitrate = B43_RATE_TO_BASE100KBPS(_rateid), \
149 .hw_value = (_rateid), \
150 .flags = (_flags), \
e4d6b795 151 }
8318d78a
JB		 152
153/*
154 * NOTE: When changing this, sync with xmit.c's
155 * b43_plcp_get_bitrate_idx_* functions!
156 */
e4d6b795 157static struct ieee80211_rate __b43_ratetable[] = {
8318d78a
JB		 158 RATETAB_ENT(B43_CCK_RATE_1MB, 0),
159 RATETAB_ENT(B43_CCK_RATE_2MB, IEEE80211_RATE_SHORT_PREAMBLE),
160 RATETAB_ENT(B43_CCK_RATE_5MB, IEEE80211_RATE_SHORT_PREAMBLE),
161 RATETAB_ENT(B43_CCK_RATE_11MB, IEEE80211_RATE_SHORT_PREAMBLE),
162 RATETAB_ENT(B43_OFDM_RATE_6MB, 0),
163 RATETAB_ENT(B43_OFDM_RATE_9MB, 0),
164 RATETAB_ENT(B43_OFDM_RATE_12MB, 0),
165 RATETAB_ENT(B43_OFDM_RATE_18MB, 0),
166 RATETAB_ENT(B43_OFDM_RATE_24MB, 0),
167 RATETAB_ENT(B43_OFDM_RATE_36MB, 0),
168 RATETAB_ENT(B43_OFDM_RATE_48MB, 0),
169 RATETAB_ENT(B43_OFDM_RATE_54MB, 0),
e4d6b795
MB		 170};
171
172#define b43_a_ratetable (__b43_ratetable + 4)
173#define b43_a_ratetable_size 8
174#define b43_b_ratetable (__b43_ratetable + 0)
175#define b43_b_ratetable_size 4
176#define b43_g_ratetable (__b43_ratetable + 0)
177#define b43_g_ratetable_size 12
178
bb1eeff1
MB		 179#define CHAN4G(_channel, _freq, _flags) { \
180 .band = IEEE80211_BAND_2GHZ, \
181 .center_freq = (_freq), \
182 .hw_value = (_channel), \
183 .flags = (_flags), \
184 .max_antenna_gain = 0, \
185 .max_power = 30, \
186}
96c755a3 187static struct ieee80211_channel b43_2ghz_chantable[] = {
bb1eeff1
MB		 188 CHAN4G(1, 2412, 0),
189 CHAN4G(2, 2417, 0),
190 CHAN4G(3, 2422, 0),
191 CHAN4G(4, 2427, 0),
192 CHAN4G(5, 2432, 0),
193 CHAN4G(6, 2437, 0),
194 CHAN4G(7, 2442, 0),
195 CHAN4G(8, 2447, 0),
196 CHAN4G(9, 2452, 0),
197 CHAN4G(10, 2457, 0),
198 CHAN4G(11, 2462, 0),
199 CHAN4G(12, 2467, 0),
200 CHAN4G(13, 2472, 0),
201 CHAN4G(14, 2484, 0),
202};
203#undef CHAN4G
204
205#define CHAN5G(_channel, _flags) { \
206 .band = IEEE80211_BAND_5GHZ, \
207 .center_freq = 5000 + (5 * (_channel)), \
208 .hw_value = (_channel), \
209 .flags = (_flags), \
210 .max_antenna_gain = 0, \
211 .max_power = 30, \
212}
213static struct ieee80211_channel b43_5ghz_nphy_chantable[] = {
214 CHAN5G(32, 0), CHAN5G(34, 0),
215 CHAN5G(36, 0), CHAN5G(38, 0),
216 CHAN5G(40, 0), CHAN5G(42, 0),
217 CHAN5G(44, 0), CHAN5G(46, 0),
218 CHAN5G(48, 0), CHAN5G(50, 0),
219 CHAN5G(52, 0), CHAN5G(54, 0),
220 CHAN5G(56, 0), CHAN5G(58, 0),
221 CHAN5G(60, 0), CHAN5G(62, 0),
222 CHAN5G(64, 0), CHAN5G(66, 0),
223 CHAN5G(68, 0), CHAN5G(70, 0),
224 CHAN5G(72, 0), CHAN5G(74, 0),
225 CHAN5G(76, 0), CHAN5G(78, 0),
226 CHAN5G(80, 0), CHAN5G(82, 0),
227 CHAN5G(84, 0), CHAN5G(86, 0),
228 CHAN5G(88, 0), CHAN5G(90, 0),
229 CHAN5G(92, 0), CHAN5G(94, 0),
230 CHAN5G(96, 0), CHAN5G(98, 0),
231 CHAN5G(100, 0), CHAN5G(102, 0),
232 CHAN5G(104, 0), CHAN5G(106, 0),
233 CHAN5G(108, 0), CHAN5G(110, 0),
234 CHAN5G(112, 0), CHAN5G(114, 0),
235 CHAN5G(116, 0), CHAN5G(118, 0),
236 CHAN5G(120, 0), CHAN5G(122, 0),
237 CHAN5G(124, 0), CHAN5G(126, 0),
238 CHAN5G(128, 0), CHAN5G(130, 0),
239 CHAN5G(132, 0), CHAN5G(134, 0),
240 CHAN5G(136, 0), CHAN5G(138, 0),
241 CHAN5G(140, 0), CHAN5G(142, 0),
242 CHAN5G(144, 0), CHAN5G(145, 0),
243 CHAN5G(146, 0), CHAN5G(147, 0),
244 CHAN5G(148, 0), CHAN5G(149, 0),
245 CHAN5G(150, 0), CHAN5G(151, 0),
246 CHAN5G(152, 0), CHAN5G(153, 0),
247 CHAN5G(154, 0), CHAN5G(155, 0),
248 CHAN5G(156, 0), CHAN5G(157, 0),
249 CHAN5G(158, 0), CHAN5G(159, 0),
250 CHAN5G(160, 0), CHAN5G(161, 0),
251 CHAN5G(162, 0), CHAN5G(163, 0),
252 CHAN5G(164, 0), CHAN5G(165, 0),
253 CHAN5G(166, 0), CHAN5G(168, 0),
254 CHAN5G(170, 0), CHAN5G(172, 0),
255 CHAN5G(174, 0), CHAN5G(176, 0),
256 CHAN5G(178, 0), CHAN5G(180, 0),
257 CHAN5G(182, 0), CHAN5G(184, 0),
258 CHAN5G(186, 0), CHAN5G(188, 0),
259 CHAN5G(190, 0), CHAN5G(192, 0),
260 CHAN5G(194, 0), CHAN5G(196, 0),
261 CHAN5G(198, 0), CHAN5G(200, 0),
262 CHAN5G(202, 0), CHAN5G(204, 0),
263 CHAN5G(206, 0), CHAN5G(208, 0),
264 CHAN5G(210, 0), CHAN5G(212, 0),
265 CHAN5G(214, 0), CHAN5G(216, 0),
266 CHAN5G(218, 0), CHAN5G(220, 0),
267 CHAN5G(222, 0), CHAN5G(224, 0),
268 CHAN5G(226, 0), CHAN5G(228, 0),
e4d6b795
MB		 269};
270
bb1eeff1
MB		 271static struct ieee80211_channel b43_5ghz_aphy_chantable[] = {
272 CHAN5G(34, 0), CHAN5G(36, 0),
273 CHAN5G(38, 0), CHAN5G(40, 0),
274 CHAN5G(42, 0), CHAN5G(44, 0),
275 CHAN5G(46, 0), CHAN5G(48, 0),
276 CHAN5G(52, 0), CHAN5G(56, 0),
277 CHAN5G(60, 0), CHAN5G(64, 0),
278 CHAN5G(100, 0), CHAN5G(104, 0),
279 CHAN5G(108, 0), CHAN5G(112, 0),
280 CHAN5G(116, 0), CHAN5G(120, 0),
281 CHAN5G(124, 0), CHAN5G(128, 0),
282 CHAN5G(132, 0), CHAN5G(136, 0),
283 CHAN5G(140, 0), CHAN5G(149, 0),
284 CHAN5G(153, 0), CHAN5G(157, 0),
285 CHAN5G(161, 0), CHAN5G(165, 0),
286 CHAN5G(184, 0), CHAN5G(188, 0),
287 CHAN5G(192, 0), CHAN5G(196, 0),
288 CHAN5G(200, 0), CHAN5G(204, 0),
289 CHAN5G(208, 0), CHAN5G(212, 0),
290 CHAN5G(216, 0),
291};
292#undef CHAN5G
293
294static struct ieee80211_supported_band b43_band_5GHz_nphy = {
295 .band = IEEE80211_BAND_5GHZ,
296 .channels = b43_5ghz_nphy_chantable,
297 .n_channels = ARRAY_SIZE(b43_5ghz_nphy_chantable),
298 .bitrates = b43_a_ratetable,
299 .n_bitrates = b43_a_ratetable_size,
e4d6b795 300};
8318d78a 301
bb1eeff1
MB		 302static struct ieee80211_supported_band b43_band_5GHz_aphy = {
303 .band = IEEE80211_BAND_5GHZ,
304 .channels = b43_5ghz_aphy_chantable,
305 .n_channels = ARRAY_SIZE(b43_5ghz_aphy_chantable),
306 .bitrates = b43_a_ratetable,
307 .n_bitrates = b43_a_ratetable_size,
8318d78a 308};
e4d6b795 309
8318d78a 310static struct ieee80211_supported_band b43_band_2GHz = {
bb1eeff1
MB		 311 .band = IEEE80211_BAND_2GHZ,
312 .channels = b43_2ghz_chantable,
313 .n_channels = ARRAY_SIZE(b43_2ghz_chantable),
314 .bitrates = b43_g_ratetable,
315 .n_bitrates = b43_g_ratetable_size,
8318d78a
JB		 316};
317
e4d6b795
MB		 318static void b43_wireless_core_exit(struct b43_wldev *dev);
319static int b43_wireless_core_init(struct b43_wldev *dev);
36dbd954 320static struct b43_wldev * b43_wireless_core_stop(struct b43_wldev *dev);
e4d6b795 321static int b43_wireless_core_start(struct b43_wldev *dev);
2a190322
FF		 322static void b43_op_bss_info_changed(struct ieee80211_hw *hw,
323 struct ieee80211_vif *vif,
324 struct ieee80211_bss_conf *conf,
325 u32 changed);
e4d6b795
MB		 326
327static int b43_ratelimit(struct b43_wl *wl)
328{
329 if (!wl || !wl->current_dev)
330 return 1;
331 if (b43_status(wl->current_dev) < B43_STAT_STARTED)
332 return 1;
333 /* We are up and running.
334 * Ratelimit the messages to avoid DoS over the net. */
335 return net_ratelimit();
336}
337
338void b43info(struct b43_wl *wl, const char *fmt, ...)
339{
5b736d42 340 struct va_format vaf;
e4d6b795
MB		 341 va_list args;
342
060210f9
MB		 343 if (b43_modparam_verbose < B43_VERBOSITY_INFO)
344 return;
e4d6b795
MB		 345 if (!b43_ratelimit(wl))
346 return;
5b736d42 347
e4d6b795 348 va_start(args, fmt);
5b736d42
JP		 349
350 vaf.fmt = fmt;
351 vaf.va = &args;
352
353 printk(KERN_INFO "b43-%s: %pV",
354 (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan", &vaf);
355
e4d6b795
MB		 356 va_end(args);
357}
358
359void b43err(struct b43_wl *wl, const char *fmt, ...)
360{
5b736d42 361 struct va_format vaf;
e4d6b795
MB		 362 va_list args;
363
060210f9
MB		 364 if (b43_modparam_verbose < B43_VERBOSITY_ERROR)
365 return;
e4d6b795
MB		 366 if (!b43_ratelimit(wl))
367 return;
5b736d42 368
e4d6b795 369 va_start(args, fmt);
5b736d42
JP		 370
371 vaf.fmt = fmt;
372 vaf.va = &args;
373
374 printk(KERN_ERR "b43-%s ERROR: %pV",
375 (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan", &vaf);
376
e4d6b795
MB		 377 va_end(args);
378}
379
380void b43warn(struct b43_wl *wl, const char *fmt, ...)
381{
5b736d42 382 struct va_format vaf;
e4d6b795
MB		 383 va_list args;
384
060210f9
MB		 385 if (b43_modparam_verbose < B43_VERBOSITY_WARN)
386 return;
e4d6b795
MB		 387 if (!b43_ratelimit(wl))
388 return;
5b736d42 389
e4d6b795 390 va_start(args, fmt);
5b736d42
JP		 391
392 vaf.fmt = fmt;
393 vaf.va = &args;
394
395 printk(KERN_WARNING "b43-%s warning: %pV",
396 (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan", &vaf);
397
e4d6b795
MB		 398 va_end(args);
399}
400
e4d6b795
MB		 401void b43dbg(struct b43_wl *wl, const char *fmt, ...)
402{
5b736d42 403 struct va_format vaf;
e4d6b795
MB		 404 va_list args;
405
060210f9
MB		 406 if (b43_modparam_verbose < B43_VERBOSITY_DEBUG)
407 return;
5b736d42 408
e4d6b795 409 va_start(args, fmt);
5b736d42
JP		 410
411 vaf.fmt = fmt;
412 vaf.va = &args;
413
414 printk(KERN_DEBUG "b43-%s debug: %pV",
415 (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan", &vaf);
416
e4d6b795
MB		 417 va_end(args);
418}
e4d6b795
MB		 419
420static void b43_ram_write(struct b43_wldev *dev, u16 offset, u32 val)
421{
422 u32 macctl;
423
424 B43_WARN_ON(offset % 4 != 0);
425
426 macctl = b43_read32(dev, B43_MMIO_MACCTL);
427 if (macctl & B43_MACCTL_BE)
428 val = swab32(val);
429
430 b43_write32(dev, B43_MMIO_RAM_CONTROL, offset);
431 mmiowb();
432 b43_write32(dev, B43_MMIO_RAM_DATA, val);
433}
434
280d0e16
MB		 435static inline void b43_shm_control_word(struct b43_wldev *dev,
436 u16 routing, u16 offset)
e4d6b795
MB		 437{
438 u32 control;
439
440 /* "offset" is the WORD offset. */
e4d6b795
MB		 441 control = routing;
442 control <<= 16;
443 control |= offset;
444 b43_write32(dev, B43_MMIO_SHM_CONTROL, control);
445}
446
69eddc8a 447u32 b43_shm_read32(struct b43_wldev *dev, u16 routing, u16 offset)
e4d6b795
MB		 448{
449 u32 ret;
450
451 if (routing == B43_SHM_SHARED) {
452 B43_WARN_ON(offset & 0x0001);
453 if (offset & 0x0003) {
454 /* Unaligned access */
455 b43_shm_control_word(dev, routing, offset >> 2);
456 ret = b43_read16(dev, B43_MMIO_SHM_DATA_UNALIGNED);
e4d6b795 457 b43_shm_control_word(dev, routing, (offset >> 2) + 1);
f62ae6cd 458 ret |= ((u32)b43_read16(dev, B43_MMIO_SHM_DATA)) << 16;
e4d6b795 459
280d0e16 460 goto out;
e4d6b795
MB		 461 }
462 offset >>= 2;
463 }
464 b43_shm_control_word(dev, routing, offset);
465 ret = b43_read32(dev, B43_MMIO_SHM_DATA);
280d0e16 466out:
e4d6b795
MB		 467 return ret;
468}
469
69eddc8a 470u16 b43_shm_read16(struct b43_wldev *dev, u16 routing, u16 offset)
6bbc321a
MB		 471{
472 u16 ret;
473
e4d6b795
MB		 474 if (routing == B43_SHM_SHARED) {
475 B43_WARN_ON(offset & 0x0001);
476 if (offset & 0x0003) {
477 /* Unaligned access */
478 b43_shm_control_word(dev, routing, offset >> 2);
479 ret = b43_read16(dev, B43_MMIO_SHM_DATA_UNALIGNED);
480
280d0e16 481 goto out;
e4d6b795
MB		 482 }
483 offset >>= 2;
484 }
485 b43_shm_control_word(dev, routing, offset);
486 ret = b43_read16(dev, B43_MMIO_SHM_DATA);
280d0e16 487out:
e4d6b795
MB		 488 return ret;
489}
490
69eddc8a 491void b43_shm_write32(struct b43_wldev *dev, u16 routing, u16 offset, u32 value)
6bbc321a 492{
e4d6b795
MB		 493 if (routing == B43_SHM_SHARED) {
494 B43_WARN_ON(offset & 0x0001);
495 if (offset & 0x0003) {
496 /* Unaligned access */
497 b43_shm_control_word(dev, routing, offset >> 2);
e4d6b795 498 b43_write16(dev, B43_MMIO_SHM_DATA_UNALIGNED,
f62ae6cd 499 value & 0xFFFF);
e4d6b795 500 b43_shm_control_word(dev, routing, (offset >> 2) + 1);
f62ae6cd
MB		 501 b43_write16(dev, B43_MMIO_SHM_DATA,
502 (value >> 16) & 0xFFFF);
6bbc321a 503 return;
e4d6b795
MB		 504 }
505 offset >>= 2;
506 }
507 b43_shm_control_word(dev, routing, offset);
e4d6b795
MB		 508 b43_write32(dev, B43_MMIO_SHM_DATA, value);
509}
510
69eddc8a 511void b43_shm_write16(struct b43_wldev *dev, u16 routing, u16 offset, u16 value)
6bbc321a 512{
e4d6b795
MB		 513 if (routing == B43_SHM_SHARED) {
514 B43_WARN_ON(offset & 0x0001);
515 if (offset & 0x0003) {
516 /* Unaligned access */
517 b43_shm_control_word(dev, routing, offset >> 2);
e4d6b795 518 b43_write16(dev, B43_MMIO_SHM_DATA_UNALIGNED, value);
6bbc321a 519 return;
e4d6b795
MB		 520 }
521 offset >>= 2;
522 }
523 b43_shm_control_word(dev, routing, offset);
e4d6b795 524 b43_write16(dev, B43_MMIO_SHM_DATA, value);
6bbc321a
MB		 525}
526
e4d6b795 527/* Read HostFlags */
99da185a 528u64 b43_hf_read(struct b43_wldev *dev)
e4d6b795 529{
35f0d354 530 u64 ret;
e4d6b795
MB		 531
532 ret = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_HOSTFHI);
533 ret <<= 16;
35f0d354
MB		 534 ret |= b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_HOSTFMI);
535 ret <<= 16;
e4d6b795
MB		 536 ret |= b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_HOSTFLO);
537
538 return ret;
539}
540
541/* Write HostFlags */
35f0d354 542void b43_hf_write(struct b43_wldev *dev, u64 value)
e4d6b795 543{
35f0d354
MB		 544 u16 lo, mi, hi;
545
546 lo = (value & 0x00000000FFFFULL);
547 mi = (value & 0x0000FFFF0000ULL) >> 16;
548 hi = (value & 0xFFFF00000000ULL) >> 32;
549 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_HOSTFLO, lo);
550 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_HOSTFMI, mi);
551 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_HOSTFHI, hi);
e4d6b795
MB		 552}
553
403a3a13
MB		 554/* Read the firmware capabilities bitmask (Opensource firmware only) */
555static u16 b43_fwcapa_read(struct b43_wldev *dev)
556{
557 B43_WARN_ON(!dev->fw.opensource);
558 return b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_FWCAPA);
559}
560
3ebbbb56 561void b43_tsf_read(struct b43_wldev *dev, u64 *tsf)
e4d6b795 562{
3ebbbb56
MB		 563 u32 low, high;
564
21d889d4 565 B43_WARN_ON(dev->dev->core_rev < 3);
3ebbbb56
MB		 566
567 /* The hardware guarantees us an atomic read, if we
568 * read the low register first. */
569 low = b43_read32(dev, B43_MMIO_REV3PLUS_TSF_LOW);
570 high = b43_read32(dev, B43_MMIO_REV3PLUS_TSF_HIGH);
571
572 *tsf = high;
573 *tsf <<= 32;
574 *tsf |= low;
e4d6b795
MB		 575}
576
577static void b43_time_lock(struct b43_wldev *dev)
578{
579 u32 macctl;
580
581 macctl = b43_read32(dev, B43_MMIO_MACCTL);
582 macctl |= B43_MACCTL_TBTTHOLD;
583 b43_write32(dev, B43_MMIO_MACCTL, macctl);
584 /* Commit the write */
585 b43_read32(dev, B43_MMIO_MACCTL);
586}
587
588static void b43_time_unlock(struct b43_wldev *dev)
589{
590 u32 macctl;
591
592 macctl = b43_read32(dev, B43_MMIO_MACCTL);
593 macctl &= ~B43_MACCTL_TBTTHOLD;
594 b43_write32(dev, B43_MMIO_MACCTL, macctl);
595 /* Commit the write */
596 b43_read32(dev, B43_MMIO_MACCTL);
597}
598
599static void b43_tsf_write_locked(struct b43_wldev *dev, u64 tsf)
600{
3ebbbb56
MB		 601 u32 low, high;
602
21d889d4 603 B43_WARN_ON(dev->dev->core_rev < 3);
3ebbbb56
MB		 604
605 low = tsf;
606 high = (tsf >> 32);
607 /* The hardware guarantees us an atomic write, if we
608 * write the low register first. */
609 b43_write32(dev, B43_MMIO_REV3PLUS_TSF_LOW, low);
610 mmiowb();
611 b43_write32(dev, B43_MMIO_REV3PLUS_TSF_HIGH, high);
612 mmiowb();
e4d6b795
MB		 613}
614
615void b43_tsf_write(struct b43_wldev *dev, u64 tsf)
616{
617 b43_time_lock(dev);
618 b43_tsf_write_locked(dev, tsf);
619 b43_time_unlock(dev);
620}
621
622static
99da185a 623void b43_macfilter_set(struct b43_wldev *dev, u16 offset, const u8 *mac)
e4d6b795
MB		 624{
625 static const u8 zero_addr[ETH_ALEN] = { 0 };
626 u16 data;
627
628 if (!mac)
629 mac = zero_addr;
630
631 offset |= 0x0020;
632 b43_write16(dev, B43_MMIO_MACFILTER_CONTROL, offset);
633
634 data = mac[0];
635 data |= mac[1] << 8;
636 b43_write16(dev, B43_MMIO_MACFILTER_DATA, data);
637 data = mac[2];
638 data |= mac[3] << 8;
639 b43_write16(dev, B43_MMIO_MACFILTER_DATA, data);
640 data = mac[4];
641 data |= mac[5] << 8;
642 b43_write16(dev, B43_MMIO_MACFILTER_DATA, data);
643}
644
645static void b43_write_mac_bssid_templates(struct b43_wldev *dev)
646{
647 const u8 *mac;
648 const u8 *bssid;
649 u8 mac_bssid[ETH_ALEN * 2];
650 int i;
651 u32 tmp;
652
653 bssid = dev->wl->bssid;
654 mac = dev->wl->mac_addr;
655
656 b43_macfilter_set(dev, B43_MACFILTER_BSSID, bssid);
657
658 memcpy(mac_bssid, mac, ETH_ALEN);
659 memcpy(mac_bssid + ETH_ALEN, bssid, ETH_ALEN);
660
661 /* Write our MAC address and BSSID to template ram */
662 for (i = 0; i < ARRAY_SIZE(mac_bssid); i += sizeof(u32)) {
663 tmp = (u32) (mac_bssid[i + 0]);
664 tmp |= (u32) (mac_bssid[i + 1]) << 8;
665 tmp |= (u32) (mac_bssid[i + 2]) << 16;
666 tmp |= (u32) (mac_bssid[i + 3]) << 24;
667 b43_ram_write(dev, 0x20 + i, tmp);
668 }
669}
670
4150c572 671static void b43_upload_card_macaddress(struct b43_wldev *dev)
e4d6b795 672{
e4d6b795 673 b43_write_mac_bssid_templates(dev);
4150c572 674 b43_macfilter_set(dev, B43_MACFILTER_SELF, dev->wl->mac_addr);
e4d6b795
MB		 675}
676
677static void b43_set_slot_time(struct b43_wldev *dev, u16 slot_time)
678{
679 /* slot_time is in usec. */
b6c3f5be
LF		 680 /* This test used to exit for all but a G PHY. */
681 if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
e4d6b795 682 return;
b6c3f5be
LF		 683 b43_write16(dev, B43_MMIO_IFSSLOT, 510 + slot_time);
684 /* Shared memory location 0x0010 is the slot time and should be
685 * set to slot_time; however, this register is initially 0 and changing
686 * the value adversely affects the transmit rate for BCM4311
687 * devices. Until this behavior is unterstood, delete this step
688 *
689 * b43_shm_write16(dev, B43_SHM_SHARED, 0x0010, slot_time);
690 */
e4d6b795
MB		 691}
692
693static void b43_short_slot_timing_enable(struct b43_wldev *dev)
694{
695 b43_set_slot_time(dev, 9);
e4d6b795
MB		 696}
697
698static void b43_short_slot_timing_disable(struct b43_wldev *dev)
699{
700 b43_set_slot_time(dev, 20);
e4d6b795
MB		 701}
702
e4d6b795 703/* DummyTransmission function, as documented on
2f19c287 704 * http://bcm-v4.sipsolutions.net/802.11/DummyTransmission
e4d6b795 705 */
2f19c287 706void b43_dummy_transmission(struct b43_wldev *dev, bool ofdm, bool pa_on)
e4d6b795
MB		 707{
708 struct b43_phy *phy = &dev->phy;
709 unsigned int i, max_loop;
710 u16 value;
711 u32 buffer[5] = {
712 0x00000000,
713 0x00D40000,
714 0x00000000,
715 0x01000000,
716 0x00000000,
717 };
718
2f19c287 719 if (ofdm) {
e4d6b795
MB		 720 max_loop = 0x1E;
721 buffer[0] = 0x000201CC;
2f19c287 722 } else {
e4d6b795
MB		 723 max_loop = 0xFA;
724 buffer[0] = 0x000B846E;
e4d6b795
MB		 725 }
726
727 for (i = 0; i < 5; i++)
728 b43_ram_write(dev, i * 4, buffer[i]);
729
e4d6b795 730 b43_write16(dev, 0x0568, 0x0000);
21d889d4 731 if (dev->dev->core_rev < 11)
2f19c287
GS		 732 b43_write16(dev, 0x07C0, 0x0000);
733 else
734 b43_write16(dev, 0x07C0, 0x0100);
735 value = (ofdm ? 0x41 : 0x40);
e4d6b795 736 b43_write16(dev, 0x050C, value);
2f19c287
GS		 737 if ((phy->type == B43_PHYTYPE_N) || (phy->type == B43_PHYTYPE_LP))
738 b43_write16(dev, 0x0514, 0x1A02);
e4d6b795
MB		 739 b43_write16(dev, 0x0508, 0x0000);
740 b43_write16(dev, 0x050A, 0x0000);
741 b43_write16(dev, 0x054C, 0x0000);
742 b43_write16(dev, 0x056A, 0x0014);
743 b43_write16(dev, 0x0568, 0x0826);
744 b43_write16(dev, 0x0500, 0x0000);
2f19c287
GS		 745 if (!pa_on && (phy->type == B43_PHYTYPE_N)) {
746 //SPEC TODO
747 }
748
749 switch (phy->type) {
750 case B43_PHYTYPE_N:
751 b43_write16(dev, 0x0502, 0x00D0);
752 break;
753 case B43_PHYTYPE_LP:
754 b43_write16(dev, 0x0502, 0x0050);
755 break;
756 default:
757 b43_write16(dev, 0x0502, 0x0030);
758 }
e4d6b795
MB		 759
760 if (phy->radio_ver == 0x2050 && phy->radio_rev <= 0x5)
761 b43_radio_write16(dev, 0x0051, 0x0017);
762 for (i = 0x00; i < max_loop; i++) {
763 value = b43_read16(dev, 0x050E);
764 if (value & 0x0080)
765 break;
766 udelay(10);
767 }
768 for (i = 0x00; i < 0x0A; i++) {
769 value = b43_read16(dev, 0x050E);
770 if (value & 0x0400)
771 break;
772 udelay(10);
773 }
1d280ddc 774 for (i = 0x00; i < 0x19; i++) {
e4d6b795
MB		 775 value = b43_read16(dev, 0x0690);
776 if (!(value & 0x0100))
777 break;
778 udelay(10);
779 }
780 if (phy->radio_ver == 0x2050 && phy->radio_rev <= 0x5)
781 b43_radio_write16(dev, 0x0051, 0x0037);
782}
783
784static void key_write(struct b43_wldev *dev,
99da185a 785 u8 index, u8 algorithm, const u8 *key)
e4d6b795
MB		 786{
787 unsigned int i;
788 u32 offset;
789 u16 value;
790 u16 kidx;
791
792 /* Key index/algo block */
793 kidx = b43_kidx_to_fw(dev, index);
794 value = ((kidx << 4) | algorithm);
795 b43_shm_write16(dev, B43_SHM_SHARED,
796 B43_SHM_SH_KEYIDXBLOCK + (kidx * 2), value);
797
798 /* Write the key to the Key Table Pointer offset */
799 offset = dev->ktp + (index * B43_SEC_KEYSIZE);
800 for (i = 0; i < B43_SEC_KEYSIZE; i += 2) {
801 value = key[i];
802 value |= (u16) (key[i + 1]) << 8;
803 b43_shm_write16(dev, B43_SHM_SHARED, offset + i, value);
804 }
805}
806
99da185a 807static void keymac_write(struct b43_wldev *dev, u8 index, const u8 *addr)
e4d6b795
MB		 808{
809 u32 addrtmp[2] = { 0, 0, };
66d2d089 810 u8 pairwise_keys_start = B43_NR_GROUP_KEYS * 2;
e4d6b795
MB		 811
812 if (b43_new_kidx_api(dev))
66d2d089 813 pairwise_keys_start = B43_NR_GROUP_KEYS;
e4d6b795 814
66d2d089
MB		 815 B43_WARN_ON(index < pairwise_keys_start);
816 /* We have four default TX keys and possibly four default RX keys.
e4d6b795
MB		 817 * Physical mac 0 is mapped to physical key 4 or 8, depending
818 * on the firmware version.
819 * So we must adjust the index here.
820 */
66d2d089
MB		 821 index -= pairwise_keys_start;
822 B43_WARN_ON(index >= B43_NR_PAIRWISE_KEYS);
e4d6b795
MB		 823
824 if (addr) {
825 addrtmp[0] = addr[0];
826 addrtmp[0] |= ((u32) (addr[1]) << 8);
827 addrtmp[0] |= ((u32) (addr[2]) << 16);
828 addrtmp[0] |= ((u32) (addr[3]) << 24);
829 addrtmp[1] = addr[4];
830 addrtmp[1] |= ((u32) (addr[5]) << 8);
831 }
832
66d2d089
MB		 833 /* Receive match transmitter address (RCMTA) mechanism */
834 b43_shm_write32(dev, B43_SHM_RCMTA,
835 (index * 2) + 0, addrtmp[0]);
836 b43_shm_write16(dev, B43_SHM_RCMTA,
837 (index * 2) + 1, addrtmp[1]);
e4d6b795
MB		 838}
839
035d0243 840/* The ucode will use phase1 key with TEK key to decrypt rx packets.
841 * When a packet is received, the iv32 is checked.
842 * - if it doesn't the packet is returned without modification (and software
843 * decryption can be done). That's what happen when iv16 wrap.
844 * - if it does, the rc4 key is computed, and decryption is tried.
845 * Either it will success and B43_RX_MAC_DEC is returned,
846 * either it fails and B43_RX_MAC_DEC|B43_RX_MAC_DECERR is returned
847 * and the packet is not usable (it got modified by the ucode).
848 * So in order to never have B43_RX_MAC_DECERR, we should provide
849 * a iv32 and phase1key that match. Because we drop packets in case of
850 * B43_RX_MAC_DECERR, if we have a correct iv32 but a wrong phase1key, all
851 * packets will be lost without higher layer knowing (ie no resync possible
852 * until next wrap).
853 *
854 * NOTE : this should support 50 key like RCMTA because
855 * (B43_SHM_SH_KEYIDXBLOCK - B43_SHM_SH_TKIPTSCTTAK)/14 = 50
856 */
857static void rx_tkip_phase1_write(struct b43_wldev *dev, u8 index, u32 iv32,
858 u16 *phase1key)
859{
860 unsigned int i;
861 u32 offset;
862 u8 pairwise_keys_start = B43_NR_GROUP_KEYS * 2;
863
864 if (!modparam_hwtkip)
865 return;
866
867 if (b43_new_kidx_api(dev))
868 pairwise_keys_start = B43_NR_GROUP_KEYS;
869
870 B43_WARN_ON(index < pairwise_keys_start);
871 /* We have four default TX keys and possibly four default RX keys.
872 * Physical mac 0 is mapped to physical key 4 or 8, depending
873 * on the firmware version.
874 * So we must adjust the index here.
875 */
876 index -= pairwise_keys_start;
877 B43_WARN_ON(index >= B43_NR_PAIRWISE_KEYS);
878
879 if (b43_debug(dev, B43_DBG_KEYS)) {
880 b43dbg(dev->wl, "rx_tkip_phase1_write : idx 0x%x, iv32 0x%x\n",
881 index, iv32);
882 }
883 /* Write the key to the RX tkip shared mem */
884 offset = B43_SHM_SH_TKIPTSCTTAK + index * (10 + 4);
885 for (i = 0; i < 10; i += 2) {
886 b43_shm_write16(dev, B43_SHM_SHARED, offset + i,
887 phase1key ? phase1key[i / 2] : 0);
888 }
889 b43_shm_write16(dev, B43_SHM_SHARED, offset + i, iv32);
890 b43_shm_write16(dev, B43_SHM_SHARED, offset + i + 2, iv32 >> 16);
891}
892
893static void b43_op_update_tkip_key(struct ieee80211_hw *hw,
b3fbdcf4
JB		 894 struct ieee80211_vif *vif,
895 struct ieee80211_key_conf *keyconf,
896 struct ieee80211_sta *sta,
897 u32 iv32, u16 *phase1key)
035d0243 898{
899 struct b43_wl *wl = hw_to_b43_wl(hw);
900 struct b43_wldev *dev;
901 int index = keyconf->hw_key_idx;
902
903 if (B43_WARN_ON(!modparam_hwtkip))
904 return;
905
96869a39
MB		 906 /* This is only called from the RX path through mac80211, where
907 * our mutex is already locked. */
908 B43_WARN_ON(!mutex_is_locked(&wl->mutex));
035d0243 909 dev = wl->current_dev;
96869a39 910 B43_WARN_ON(!dev || b43_status(dev) < B43_STAT_INITIALIZED);
035d0243 911
912 keymac_write(dev, index, NULL); /* First zero out mac to avoid race */
913
914 rx_tkip_phase1_write(dev, index, iv32, phase1key);
b3fbdcf4
JB		 915 /* only pairwise TKIP keys are supported right now */
916 if (WARN_ON(!sta))
96869a39 917 return;
b3fbdcf4 918 keymac_write(dev, index, sta->addr);
035d0243 919}
920
e4d6b795
MB		 921static void do_key_write(struct b43_wldev *dev,
922 u8 index, u8 algorithm,
99da185a 923 const u8 *key, size_t key_len, const u8 *mac_addr)
e4d6b795
MB		 924{
925 u8 buf[B43_SEC_KEYSIZE] = { 0, };
66d2d089 926 u8 pairwise_keys_start = B43_NR_GROUP_KEYS * 2;
e4d6b795
MB		 927
928 if (b43_new_kidx_api(dev))
66d2d089 929 pairwise_keys_start = B43_NR_GROUP_KEYS;
e4d6b795 930
66d2d089 931 B43_WARN_ON(index >= ARRAY_SIZE(dev->key));
e4d6b795
MB		 932 B43_WARN_ON(key_len > B43_SEC_KEYSIZE);
933
66d2d089 934 if (index >= pairwise_keys_start)
e4d6b795 935 keymac_write(dev, index, NULL); /* First zero out mac. */
035d0243 936 if (algorithm == B43_SEC_ALGO_TKIP) {
937 /*
938 * We should provide an initial iv32, phase1key pair.
939 * We could start with iv32=0 and compute the corresponding
940 * phase1key, but this means calling ieee80211_get_tkip_key
941 * with a fake skb (or export other tkip function).
942 * Because we are lazy we hope iv32 won't start with
943 * 0xffffffff and let's b43_op_update_tkip_key provide a
944 * correct pair.
945 */
946 rx_tkip_phase1_write(dev, index, 0xffffffff, (u16*)buf);
947 } else if (index >= pairwise_keys_start) /* clear it */
948 rx_tkip_phase1_write(dev, index, 0, NULL);
e4d6b795
MB		 949 if (key)
950 memcpy(buf, key, key_len);
951 key_write(dev, index, algorithm, buf);
66d2d089 952 if (index >= pairwise_keys_start)
e4d6b795
MB		 953 keymac_write(dev, index, mac_addr);
954
955 dev->key[index].algorithm = algorithm;
956}
957
958static int b43_key_write(struct b43_wldev *dev,
959 int index, u8 algorithm,
99da185a
JD		 960 const u8 *key, size_t key_len,
961 const u8 *mac_addr,
e4d6b795
MB		 962 struct ieee80211_key_conf *keyconf)
963{
964 int i;
66d2d089 965 int pairwise_keys_start;
e4d6b795 966
035d0243 967 /* For ALG_TKIP the key is encoded as a 256-bit (32 byte) data block:
968 * - Temporal Encryption Key (128 bits)
969 * - Temporal Authenticator Tx MIC Key (64 bits)
970 * - Temporal Authenticator Rx MIC Key (64 bits)
971 *
972 * Hardware only store TEK
973 */
974 if (algorithm == B43_SEC_ALGO_TKIP && key_len == 32)
975 key_len = 16;
e4d6b795
MB		 976 if (key_len > B43_SEC_KEYSIZE)
977 return -EINVAL;
66d2d089 978 for (i = 0; i < ARRAY_SIZE(dev->key); i++) {
e4d6b795
MB		 979 /* Check that we don't already have this key. */
980 B43_WARN_ON(dev->key[i].keyconf == keyconf);
981 }
982 if (index < 0) {
e808e586 983 /* Pairwise key. Get an empty slot for the key. */
e4d6b795 984 if (b43_new_kidx_api(dev))
66d2d089 985 pairwise_keys_start = B43_NR_GROUP_KEYS;
e4d6b795 986 else
66d2d089
MB		 987 pairwise_keys_start = B43_NR_GROUP_KEYS * 2;
988 for (i = pairwise_keys_start;
989 i < pairwise_keys_start + B43_NR_PAIRWISE_KEYS;
990 i++) {
991 B43_WARN_ON(i >= ARRAY_SIZE(dev->key));
e4d6b795
MB		 992 if (!dev->key[i].keyconf) {
993 /* found empty */
994 index = i;
995 break;
996 }
997 }
998 if (index < 0) {
e808e586 999 b43warn(dev->wl, "Out of hardware key memory\n");
e4d6b795
MB		 1000 return -ENOSPC;
1001 }
1002 } else
1003 B43_WARN_ON(index > 3);
1004
1005 do_key_write(dev, index, algorithm, key, key_len, mac_addr);
1006 if ((index <= 3) && !b43_new_kidx_api(dev)) {
1007 /* Default RX key */
1008 B43_WARN_ON(mac_addr);
1009 do_key_write(dev, index + 4, algorithm, key, key_len, NULL);
1010 }
1011 keyconf->hw_key_idx = index;
1012 dev->key[index].keyconf = keyconf;
1013
1014 return 0;
1015}
1016
1017static int b43_key_clear(struct b43_wldev *dev, int index)
1018{
66d2d089 1019 if (B43_WARN_ON((index < 0) || (index >= ARRAY_SIZE(dev->key))))
e4d6b795
MB		 1020 return -EINVAL;
1021 do_key_write(dev, index, B43_SEC_ALGO_NONE,
1022 NULL, B43_SEC_KEYSIZE, NULL);
1023 if ((index <= 3) && !b43_new_kidx_api(dev)) {
1024 do_key_write(dev, index + 4, B43_SEC_ALGO_NONE,
1025 NULL, B43_SEC_KEYSIZE, NULL);
1026 }
1027 dev->key[index].keyconf = NULL;
1028
1029 return 0;
1030}
1031
1032static void b43_clear_keys(struct b43_wldev *dev)
1033{
66d2d089 1034 int i, count;
e4d6b795 1035
66d2d089
MB		 1036 if (b43_new_kidx_api(dev))
1037 count = B43_NR_GROUP_KEYS + B43_NR_PAIRWISE_KEYS;
1038 else
1039 count = B43_NR_GROUP_KEYS * 2 + B43_NR_PAIRWISE_KEYS;
1040 for (i = 0; i < count; i++)
e4d6b795
MB		 1041 b43_key_clear(dev, i);
1042}
1043
9cf7f247
MB		 1044static void b43_dump_keymemory(struct b43_wldev *dev)
1045{
66d2d089 1046 unsigned int i, index, count, offset, pairwise_keys_start;
9cf7f247
MB		 1047 u8 mac[ETH_ALEN];
1048 u16 algo;
1049 u32 rcmta0;
1050 u16 rcmta1;
1051 u64 hf;
1052 struct b43_key *key;
1053
1054 if (!b43_debug(dev, B43_DBG_KEYS))
1055 return;
1056
1057 hf = b43_hf_read(dev);
1058 b43dbg(dev->wl, "Hardware key memory dump: USEDEFKEYS=%u\n",
1059 !!(hf & B43_HF_USEDEFKEYS));
66d2d089
MB		 1060 if (b43_new_kidx_api(dev)) {
1061 pairwise_keys_start = B43_NR_GROUP_KEYS;
1062 count = B43_NR_GROUP_KEYS + B43_NR_PAIRWISE_KEYS;
1063 } else {
1064 pairwise_keys_start = B43_NR_GROUP_KEYS * 2;
1065 count = B43_NR_GROUP_KEYS * 2 + B43_NR_PAIRWISE_KEYS;
1066 }
1067 for (index = 0; index < count; index++) {
9cf7f247
MB		 1068 key = &(dev->key[index]);
1069 printk(KERN_DEBUG "Key slot %02u: %s",
1070 index, (key->keyconf == NULL) ? " " : "*");
1071 offset = dev->ktp + (index * B43_SEC_KEYSIZE);
1072 for (i = 0; i < B43_SEC_KEYSIZE; i += 2) {
1073 u16 tmp = b43_shm_read16(dev, B43_SHM_SHARED, offset + i);
1074 printk("%02X%02X", (tmp & 0xFF), ((tmp >> 8) & 0xFF));
1075 }
1076
1077 algo = b43_shm_read16(dev, B43_SHM_SHARED,
1078 B43_SHM_SH_KEYIDXBLOCK + (index * 2));
1079 printk(" Algo: %04X/%02X", algo, key->algorithm);
1080
66d2d089 1081 if (index >= pairwise_keys_start) {
035d0243 1082 if (key->algorithm == B43_SEC_ALGO_TKIP) {
1083 printk(" TKIP: ");
1084 offset = B43_SHM_SH_TKIPTSCTTAK + (index - 4) * (10 + 4);
1085 for (i = 0; i < 14; i += 2) {
1086 u16 tmp = b43_shm_read16(dev, B43_SHM_SHARED, offset + i);
1087 printk("%02X%02X", (tmp & 0xFF), ((tmp >> 8) & 0xFF));
1088 }
1089 }
9cf7f247 1090 rcmta0 = b43_shm_read32(dev, B43_SHM_RCMTA,
66d2d089 1091 ((index - pairwise_keys_start) * 2) + 0);
9cf7f247 1092 rcmta1 = b43_shm_read16(dev, B43_SHM_RCMTA,
66d2d089 1093 ((index - pairwise_keys_start) * 2) + 1);
9cf7f247
MB		 1094 *((__le32 *)(&mac[0])) = cpu_to_le32(rcmta0);
1095 *((__le16 *)(&mac[4])) = cpu_to_le16(rcmta1);
e91d8334 1096 printk(" MAC: %pM", mac);
9cf7f247
MB		 1097 } else
1098 printk(" DEFAULT KEY");
1099 printk("\n");
1100 }
1101}
1102
e4d6b795
MB		 1103void b43_power_saving_ctl_bits(struct b43_wldev *dev, unsigned int ps_flags)
1104{
1105 u32 macctl;
1106 u16 ucstat;
1107 bool hwps;
1108 bool awake;
1109 int i;
1110
1111 B43_WARN_ON((ps_flags & B43_PS_ENABLED) &&
1112 (ps_flags & B43_PS_DISABLED));
1113 B43_WARN_ON((ps_flags & B43_PS_AWAKE) && (ps_flags & B43_PS_ASLEEP));
1114
1115 if (ps_flags & B43_PS_ENABLED) {
1116 hwps = 1;
1117 } else if (ps_flags & B43_PS_DISABLED) {
1118 hwps = 0;
1119 } else {
1120 //TODO: If powersave is not off and FIXME is not set and we are not in adhoc
1121 // and thus is not an AP and we are associated, set bit 25
1122 }
1123 if (ps_flags & B43_PS_AWAKE) {
1124 awake = 1;
1125 } else if (ps_flags & B43_PS_ASLEEP) {
1126 awake = 0;
1127 } else {
1128 //TODO: If the device is awake or this is an AP, or we are scanning, or FIXME,
1129 // or we are associated, or FIXME, or the latest PS-Poll packet sent was
1130 // successful, set bit26
1131 }
1132
1133/* FIXME: For now we force awake-on and hwps-off */
1134 hwps = 0;
1135 awake = 1;
1136
1137 macctl = b43_read32(dev, B43_MMIO_MACCTL);
1138 if (hwps)
1139 macctl |= B43_MACCTL_HWPS;
1140 else
1141 macctl &= ~B43_MACCTL_HWPS;
1142 if (awake)
1143 macctl |= B43_MACCTL_AWAKE;
1144 else
1145 macctl &= ~B43_MACCTL_AWAKE;
1146 b43_write32(dev, B43_MMIO_MACCTL, macctl);
1147 /* Commit write */
1148 b43_read32(dev, B43_MMIO_MACCTL);
21d889d4 1149 if (awake && dev->dev->core_rev >= 5) {
e4d6b795
MB		 1150 /* Wait for the microcode to wake up. */
1151 for (i = 0; i < 100; i++) {
1152 ucstat = b43_shm_read16(dev, B43_SHM_SHARED,
1153 B43_SHM_SH_UCODESTAT);
1154 if (ucstat != B43_SHM_SH_UCODESTAT_SLEEP)
1155 break;
1156 udelay(10);
1157 }
1158 }
1159}
1160
42c9a458 1161#ifdef CONFIG_B43_BCMA
49173592 1162static void b43_bcma_phy_reset(struct b43_wldev *dev)
42c9a458 1163{
49173592 1164 u32 flags;
42c9a458 1165
49173592
RM		 1166 /* Put PHY into reset */
1167 flags = bcma_aread32(dev->dev->bdev, BCMA_IOCTL);
1168 flags |= B43_BCMA_IOCTL_PHY_RESET;
42c9a458 1169 flags |= B43_BCMA_IOCTL_PHY_BW_20MHZ; /* Make 20 MHz def */
49173592
RM		 1170 bcma_awrite32(dev->dev->bdev, BCMA_IOCTL, flags);
1171 udelay(2);
1172
1173 /* Take PHY out of reset */
1174 flags = bcma_aread32(dev->dev->bdev, BCMA_IOCTL);
1175 flags &= ~B43_BCMA_IOCTL_PHY_RESET;
1176 flags |= BCMA_IOCTL_FGC;
1177 bcma_awrite32(dev->dev->bdev, BCMA_IOCTL, flags);
1178 udelay(1);
1179
1180 /* Do not force clock anymore */
1181 flags = bcma_aread32(dev->dev->bdev, BCMA_IOCTL);
1182 flags &= ~BCMA_IOCTL_FGC;
1183 bcma_awrite32(dev->dev->bdev, BCMA_IOCTL, flags);
1184 udelay(1);
1185}
42c9a458 1186
49173592
RM		 1187static void b43_bcma_wireless_core_reset(struct b43_wldev *dev, bool gmode)
1188{
1189 b43_device_enable(dev, B43_BCMA_IOCTL_PHY_CLKEN);
1190 bcma_core_set_clockmode(dev->dev->bdev, BCMA_CLKMODE_FAST);
1191 b43_bcma_phy_reset(dev);
1192 bcma_core_pll_ctl(dev->dev->bdev, 0x300, 0x3000000, true);
42c9a458
RM		 1193}
1194#endif
1195
4da909e7 1196static void b43_ssb_wireless_core_reset(struct b43_wldev *dev, bool gmode)
e4d6b795 1197{
d48ae5c8 1198 struct ssb_device *sdev = dev->dev->sdev;
e4d6b795 1199 u32 tmslow;
4da909e7 1200 u32 flags = 0;
e4d6b795 1201
4da909e7
RM		 1202 if (gmode)
1203 flags |= B43_TMSLOW_GMODE;
e4d6b795
MB		 1204 flags |= B43_TMSLOW_PHYCLKEN;
1205 flags |= B43_TMSLOW_PHYRESET;
42ab135f
RM		 1206 if (dev->phy.type == B43_PHYTYPE_N)
1207 flags |= B43_TMSLOW_PHY_BANDWIDTH_20MHZ; /* Make 20 MHz def */
24ca39d6 1208 b43_device_enable(dev, flags);
e4d6b795
MB		 1209 msleep(2); /* Wait for the PLL to turn on. */
1210
1211 /* Now take the PHY out of Reset again */
d48ae5c8 1212 tmslow = ssb_read32(sdev, SSB_TMSLOW);
e4d6b795
MB		 1213 tmslow |= SSB_TMSLOW_FGC;
1214 tmslow &= ~B43_TMSLOW_PHYRESET;
d48ae5c8
RM		 1215 ssb_write32(sdev, SSB_TMSLOW, tmslow);
1216 ssb_read32(sdev, SSB_TMSLOW); /* flush */
e4d6b795
MB		 1217 msleep(1);
1218 tmslow &= ~SSB_TMSLOW_FGC;
d48ae5c8
RM		 1219 ssb_write32(sdev, SSB_TMSLOW, tmslow);
1220 ssb_read32(sdev, SSB_TMSLOW); /* flush */
e4d6b795 1221 msleep(1);
1495298d
RM		 1222}
1223
4da909e7 1224void b43_wireless_core_reset(struct b43_wldev *dev, bool gmode)
1495298d
RM		 1225{
1226 u32 macctl;
1227
6cbab0d9 1228 switch (dev->dev->bus_type) {
42c9a458
RM		 1229#ifdef CONFIG_B43_BCMA
1230 case B43_BUS_BCMA:
1231 b43_bcma_wireless_core_reset(dev, gmode);
1232 break;
1233#endif
6cbab0d9
RM		 1234#ifdef CONFIG_B43_SSB
1235 case B43_BUS_SSB:
1236 b43_ssb_wireless_core_reset(dev, gmode);
1237 break;
1238#endif
1239 }
e4d6b795 1240
fb11137a
MB		 1241 /* Turn Analog ON, but only if we already know the PHY-type.
1242 * This protects against very early setup where we don't know the
1243 * PHY-type, yet. wireless_core_reset will be called once again later,
1244 * when we know the PHY-type. */
1245 if (dev->phy.ops)
cb24f57f 1246 dev->phy.ops->switch_analog(dev, 1);
e4d6b795
MB		 1247
1248 macctl = b43_read32(dev, B43_MMIO_MACCTL);
1249 macctl &= ~B43_MACCTL_GMODE;
4da909e7 1250 if (gmode)
e4d6b795
MB		 1251 macctl |= B43_MACCTL_GMODE;
1252 macctl |= B43_MACCTL_IHR_ENABLED;
1253 b43_write32(dev, B43_MMIO_MACCTL, macctl);
1254}
1255
1256static void handle_irq_transmit_status(struct b43_wldev *dev)
1257{
1258 u32 v0, v1;
1259 u16 tmp;
1260 struct b43_txstatus stat;
1261
1262 while (1) {
1263 v0 = b43_read32(dev, B43_MMIO_XMITSTAT_0);
1264 if (!(v0 & 0x00000001))
1265 break;
1266 v1 = b43_read32(dev, B43_MMIO_XMITSTAT_1);
1267
1268 stat.cookie = (v0 >> 16);
1269 stat.seq = (v1 & 0x0000FFFF);
1270 stat.phy_stat = ((v1 & 0x00FF0000) >> 16);
1271 tmp = (v0 & 0x0000FFFF);
1272 stat.frame_count = ((tmp & 0xF000) >> 12);
1273 stat.rts_count = ((tmp & 0x0F00) >> 8);
1274 stat.supp_reason = ((tmp & 0x001C) >> 2);
1275 stat.pm_indicated = !!(tmp & 0x0080);
1276 stat.intermediate = !!(tmp & 0x0040);
1277 stat.for_ampdu = !!(tmp & 0x0020);
1278 stat.acked = !!(tmp & 0x0002);
1279
1280 b43_handle_txstatus(dev, &stat);
1281 }
1282}
1283
1284static void drain_txstatus_queue(struct b43_wldev *dev)
1285{
1286 u32 dummy;
1287
21d889d4 1288 if (dev->dev->core_rev < 5)
e4d6b795
MB		 1289 return;
1290 /* Read all entries from the microcode TXstatus FIFO
1291 * and throw them away.
1292 */
1293 while (1) {
1294 dummy = b43_read32(dev, B43_MMIO_XMITSTAT_0);
1295 if (!(dummy & 0x00000001))
1296 break;
1297 dummy = b43_read32(dev, B43_MMIO_XMITSTAT_1);
1298 }
1299}
1300
1301static u32 b43_jssi_read(struct b43_wldev *dev)
1302{
1303 u32 val = 0;
1304
1305 val = b43_shm_read16(dev, B43_SHM_SHARED, 0x08A);
1306 val <<= 16;
1307 val |= b43_shm_read16(dev, B43_SHM_SHARED, 0x088);
1308
1309 return val;
1310}
1311
1312static void b43_jssi_write(struct b43_wldev *dev, u32 jssi)
1313{
1314 b43_shm_write16(dev, B43_SHM_SHARED, 0x088, (jssi & 0x0000FFFF));
1315 b43_shm_write16(dev, B43_SHM_SHARED, 0x08A, (jssi & 0xFFFF0000) >> 16);
1316}
1317
1318static void b43_generate_noise_sample(struct b43_wldev *dev)
1319{
1320 b43_jssi_write(dev, 0x7F7F7F7F);
aa6c7ae2
MB		 1321 b43_write32(dev, B43_MMIO_MACCMD,
1322 b43_read32(dev, B43_MMIO_MACCMD) | B43_MACCMD_BGNOISE);
e4d6b795
MB		 1323}
1324
1325static void b43_calculate_link_quality(struct b43_wldev *dev)
1326{
1327 /* Top half of Link Quality calculation. */
1328
ef1a628d
MB		 1329 if (dev->phy.type != B43_PHYTYPE_G)
1330 return;
e4d6b795
MB		 1331 if (dev->noisecalc.calculation_running)
1332 return;
e4d6b795
MB		 1333 dev->noisecalc.calculation_running = 1;
1334 dev->noisecalc.nr_samples = 0;
1335
1336 b43_generate_noise_sample(dev);
1337}
1338
1339static void handle_irq_noise(struct b43_wldev *dev)
1340{
ef1a628d 1341 struct b43_phy_g *phy = dev->phy.g;
e4d6b795
MB		 1342 u16 tmp;
1343 u8 noise[4];
1344 u8 i, j;
1345 s32 average;
1346
1347 /* Bottom half of Link Quality calculation. */
1348
ef1a628d
MB		 1349 if (dev->phy.type != B43_PHYTYPE_G)
1350 return;
1351
98a3b2fe
MB		 1352 /* Possible race condition: It might be possible that the user
1353 * changed to a different channel in the meantime since we
1354 * started the calculation. We ignore that fact, since it's
1355 * not really that much of a problem. The background noise is
1356 * an estimation only anyway. Slightly wrong results will get damped
1357 * by the averaging of the 8 sample rounds. Additionally the
1358 * value is shortlived. So it will be replaced by the next noise
1359 * calculation round soon. */
1360
e4d6b795 1361 B43_WARN_ON(!dev->noisecalc.calculation_running);
1a09404a 1362 *((__le32 *)noise) = cpu_to_le32(b43_jssi_read(dev));
e4d6b795
MB		 1363 if (noise[0] == 0x7F || noise[1] == 0x7F ||
1364 noise[2] == 0x7F || noise[3] == 0x7F)
1365 goto generate_new;
1366
1367 /* Get the noise samples. */
1368 B43_WARN_ON(dev->noisecalc.nr_samples >= 8);
1369 i = dev->noisecalc.nr_samples;
cdbf0846
HH		 1370 noise[0] = clamp_val(noise[0], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
1371 noise[1] = clamp_val(noise[1], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
1372 noise[2] = clamp_val(noise[2], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
1373 noise[3] = clamp_val(noise[3], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
e4d6b795
MB		 1374 dev->noisecalc.samples[i][0] = phy->nrssi_lt[noise[0]];
1375 dev->noisecalc.samples[i][1] = phy->nrssi_lt[noise[1]];
1376 dev->noisecalc.samples[i][2] = phy->nrssi_lt[noise[2]];
1377 dev->noisecalc.samples[i][3] = phy->nrssi_lt[noise[3]];
1378 dev->noisecalc.nr_samples++;
1379 if (dev->noisecalc.nr_samples == 8) {
1380 /* Calculate the Link Quality by the noise samples. */
1381 average = 0;
1382 for (i = 0; i < 8; i++) {
1383 for (j = 0; j < 4; j++)
1384 average += dev->noisecalc.samples[i][j];
1385 }
1386 average /= (8 * 4);
1387 average *= 125;
1388 average += 64;
1389 average /= 128;
1390 tmp = b43_shm_read16(dev, B43_SHM_SHARED, 0x40C);
1391 tmp = (tmp / 128) & 0x1F;
1392 if (tmp >= 8)
1393 average += 2;
1394 else
1395 average -= 25;
1396 if (tmp == 8)
1397 average -= 72;
1398 else
1399 average -= 48;
1400
1401 dev->stats.link_noise = average;
e4d6b795
MB		 1402 dev->noisecalc.calculation_running = 0;
1403 return;
1404 }
98a3b2fe 1405generate_new:
e4d6b795
MB		 1406 b43_generate_noise_sample(dev);
1407}
1408
1409static void handle_irq_tbtt_indication(struct b43_wldev *dev)
1410{
05c914fe 1411 if (b43_is_mode(dev->wl, NL80211_IFTYPE_AP)) {
e4d6b795
MB		 1412 ///TODO: PS TBTT
1413 } else {
1414 if (1 /*FIXME: the last PSpoll frame was sent successfully */ )
1415 b43_power_saving_ctl_bits(dev, 0);
1416 }
05c914fe 1417 if (b43_is_mode(dev->wl, NL80211_IFTYPE_ADHOC))
aa6c7ae2 1418 dev->dfq_valid = 1;
e4d6b795
MB		 1419}
1420
1421static void handle_irq_atim_end(struct b43_wldev *dev)
1422{
aa6c7ae2
MB		 1423 if (dev->dfq_valid) {
1424 b43_write32(dev, B43_MMIO_MACCMD,
1425 b43_read32(dev, B43_MMIO_MACCMD)
1426 | B43_MACCMD_DFQ_VALID);
1427 dev->dfq_valid = 0;
1428 }
e4d6b795
MB		 1429}
1430
1431static void handle_irq_pmq(struct b43_wldev *dev)
1432{
1433 u32 tmp;
1434
1435 //TODO: AP mode.
1436
1437 while (1) {
1438 tmp = b43_read32(dev, B43_MMIO_PS_STATUS);
1439 if (!(tmp & 0x00000008))
1440 break;
1441 }
1442 /* 16bit write is odd, but correct. */
1443 b43_write16(dev, B43_MMIO_PS_STATUS, 0x0002);
1444}
1445
1446static void b43_write_template_common(struct b43_wldev *dev,
99da185a 1447 const u8 *data, u16 size,
e4d6b795
MB		 1448 u16 ram_offset,
1449 u16 shm_size_offset, u8 rate)
1450{
1451 u32 i, tmp;
1452 struct b43_plcp_hdr4 plcp;
1453
1454 plcp.data = 0;
1455 b43_generate_plcp_hdr(&plcp, size + FCS_LEN, rate);
1456 b43_ram_write(dev, ram_offset, le32_to_cpu(plcp.data));
1457 ram_offset += sizeof(u32);
1458 /* The PLCP is 6 bytes long, but we only wrote 4 bytes, yet.
1459 * So leave the first two bytes of the next write blank.
1460 */
1461 tmp = (u32) (data[0]) << 16;
1462 tmp |= (u32) (data[1]) << 24;
1463 b43_ram_write(dev, ram_offset, tmp);
1464 ram_offset += sizeof(u32);
1465 for (i = 2; i < size; i += sizeof(u32)) {
1466 tmp = (u32) (data[i + 0]);
1467 if (i + 1 < size)
1468 tmp |= (u32) (data[i + 1]) << 8;
1469 if (i + 2 < size)
1470 tmp |= (u32) (data[i + 2]) << 16;
1471 if (i + 3 < size)
1472 tmp |= (u32) (data[i + 3]) << 24;
1473 b43_ram_write(dev, ram_offset + i - 2, tmp);
1474 }
1475 b43_shm_write16(dev, B43_SHM_SHARED, shm_size_offset,
1476 size + sizeof(struct b43_plcp_hdr6));
1477}
1478
5042c507
MB		 1479/* Check if the use of the antenna that ieee80211 told us to
1480 * use is possible. This will fall back to DEFAULT.
1481 * "antenna_nr" is the antenna identifier we got from ieee80211. */
1482u8 b43_ieee80211_antenna_sanitize(struct b43_wldev *dev,
1483 u8 antenna_nr)
1484{
1485 u8 antenna_mask;
1486
1487 if (antenna_nr == 0) {
1488 /* Zero means "use default antenna". That's always OK. */
1489 return 0;
1490 }
1491
1492 /* Get the mask of available antennas. */
1493 if (dev->phy.gmode)
0581483a 1494 antenna_mask = dev->dev->bus_sprom->ant_available_bg;
5042c507 1495 else
0581483a 1496 antenna_mask = dev->dev->bus_sprom->ant_available_a;
5042c507
MB		 1497
1498 if (!(antenna_mask & (1 << (antenna_nr - 1)))) {
1499 /* This antenna is not available. Fall back to default. */
1500 return 0;
1501 }
1502
1503 return antenna_nr;
1504}
1505
5042c507
MB		 1506/* Convert a b43 antenna number value to the PHY TX control value. */
1507static u16 b43_antenna_to_phyctl(int antenna)
1508{
1509 switch (antenna) {
1510 case B43_ANTENNA0:
1511 return B43_TXH_PHY_ANT0;
1512 case B43_ANTENNA1:
1513 return B43_TXH_PHY_ANT1;
1514 case B43_ANTENNA2:
1515 return B43_TXH_PHY_ANT2;
1516 case B43_ANTENNA3:
1517 return B43_TXH_PHY_ANT3;
64e368bf
GS		 1518 case B43_ANTENNA_AUTO0:
1519 case B43_ANTENNA_AUTO1:
5042c507
MB		 1520 return B43_TXH_PHY_ANT01AUTO;
1521 }
1522 B43_WARN_ON(1);
1523 return 0;
1524}
1525
e4d6b795
MB		 1526static void b43_write_beacon_template(struct b43_wldev *dev,
1527 u16 ram_offset,
5042c507 1528 u16 shm_size_offset)
e4d6b795 1529{
47f76ca3 1530 unsigned int i, len, variable_len;
e66fee6a
MB		 1531 const struct ieee80211_mgmt *bcn;
1532 const u8 *ie;
1533 bool tim_found = 0;
5042c507
MB		 1534 unsigned int rate;
1535 u16 ctl;
1536 int antenna;
e039fa4a 1537 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(dev->wl->current_beacon);
e4d6b795 1538
e66fee6a
MB		 1539 bcn = (const struct ieee80211_mgmt *)(dev->wl->current_beacon->data);
1540 len = min((size_t) dev->wl->current_beacon->len,
e4d6b795 1541 0x200 - sizeof(struct b43_plcp_hdr6));
e039fa4a 1542 rate = ieee80211_get_tx_rate(dev->wl->hw, info)->hw_value;
e66fee6a
MB		 1543
1544 b43_write_template_common(dev, (const u8 *)bcn,
e4d6b795 1545 len, ram_offset, shm_size_offset, rate);
e66fee6a 1546
5042c507 1547 /* Write the PHY TX control parameters. */
0f4ac38b 1548 antenna = B43_ANTENNA_DEFAULT;
5042c507
MB		 1549 antenna = b43_antenna_to_phyctl(antenna);
1550 ctl = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_BEACPHYCTL);
1551 /* We can't send beacons with short preamble. Would get PHY errors. */
1552 ctl &= ~B43_TXH_PHY_SHORTPRMBL;
1553 ctl &= ~B43_TXH_PHY_ANT;
1554 ctl &= ~B43_TXH_PHY_ENC;
1555 ctl |= antenna;
1556 if (b43_is_cck_rate(rate))
1557 ctl |= B43_TXH_PHY_ENC_CCK;
1558 else
1559 ctl |= B43_TXH_PHY_ENC_OFDM;
1560 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_BEACPHYCTL, ctl);
1561
e66fee6a
MB		 1562 /* Find the position of the TIM and the DTIM_period value
1563 * and write them to SHM. */
1564 ie = bcn->u.beacon.variable;
47f76ca3
MB		 1565 variable_len = len - offsetof(struct ieee80211_mgmt, u.beacon.variable);
1566 for (i = 0; i < variable_len - 2; ) {
e66fee6a
MB		 1567 uint8_t ie_id, ie_len;
1568
1569 ie_id = ie[i];
1570 ie_len = ie[i + 1];
1571 if (ie_id == 5) {
1572 u16 tim_position;
1573 u16 dtim_period;
1574 /* This is the TIM Information Element */
1575
1576 /* Check whether the ie_len is in the beacon data range. */
47f76ca3 1577 if (variable_len < ie_len + 2 + i)
e66fee6a
MB		 1578 break;
1579 /* A valid TIM is at least 4 bytes long. */
1580 if (ie_len < 4)
1581 break;
1582 tim_found = 1;
1583
1584 tim_position = sizeof(struct b43_plcp_hdr6);
1585 tim_position += offsetof(struct ieee80211_mgmt, u.beacon.variable);
1586 tim_position += i;
1587
1588 dtim_period = ie[i + 3];
1589
1590 b43_shm_write16(dev, B43_SHM_SHARED,
1591 B43_SHM_SH_TIMBPOS, tim_position);
1592 b43_shm_write16(dev, B43_SHM_SHARED,
1593 B43_SHM_SH_DTIMPER, dtim_period);
1594 break;
1595 }
1596 i += ie_len + 2;
1597 }
1598 if (!tim_found) {
04dea136
JB		 1599 /*
1600 * If ucode wants to modify TIM do it behind the beacon, this
1601 * will happen, for example, when doing mesh networking.
1602 */
1603 b43_shm_write16(dev, B43_SHM_SHARED,
1604 B43_SHM_SH_TIMBPOS,
1605 len + sizeof(struct b43_plcp_hdr6));
1606 b43_shm_write16(dev, B43_SHM_SHARED,
1607 B43_SHM_SH_DTIMPER, 0);
1608 }
1609 b43dbg(dev->wl, "Updated beacon template at 0x%x\n", ram_offset);
e4d6b795
MB		 1610}
1611
6b4bec01
MB		 1612static void b43_upload_beacon0(struct b43_wldev *dev)
1613{
1614 struct b43_wl *wl = dev->wl;
1615
1616 if (wl->beacon0_uploaded)
1617 return;
1618 b43_write_beacon_template(dev, 0x68, 0x18);
6b4bec01
MB		 1619 wl->beacon0_uploaded = 1;
1620}
1621
1622static void b43_upload_beacon1(struct b43_wldev *dev)
1623{
1624 struct b43_wl *wl = dev->wl;
1625
1626 if (wl->beacon1_uploaded)
1627 return;
1628 b43_write_beacon_template(dev, 0x468, 0x1A);
1629 wl->beacon1_uploaded = 1;
1630}
1631
c97a4ccc
MB		 1632static void handle_irq_beacon(struct b43_wldev *dev)
1633{
1634 struct b43_wl *wl = dev->wl;
1635 u32 cmd, beacon0_valid, beacon1_valid;
1636
05c914fe
JB		 1637 if (!b43_is_mode(wl, NL80211_IFTYPE_AP) &&
1638 !b43_is_mode(wl, NL80211_IFTYPE_MESH_POINT))
c97a4ccc
MB		 1639 return;
1640
1641 /* This is the bottom half of the asynchronous beacon update. */
1642
1643 /* Ignore interrupt in the future. */
13790728 1644 dev->irq_mask &= ~B43_IRQ_BEACON;
c97a4ccc
MB		 1645
1646 cmd = b43_read32(dev, B43_MMIO_MACCMD);
1647 beacon0_valid = (cmd & B43_MACCMD_BEACON0_VALID);
1648 beacon1_valid = (cmd & B43_MACCMD_BEACON1_VALID);
1649
1650 /* Schedule interrupt manually, if busy. */
1651 if (beacon0_valid && beacon1_valid) {
1652 b43_write32(dev, B43_MMIO_GEN_IRQ_REASON, B43_IRQ_BEACON);
13790728 1653 dev->irq_mask |= B43_IRQ_BEACON;
c97a4ccc
MB		 1654 return;
1655 }
1656
6b4bec01
MB		 1657 if (unlikely(wl->beacon_templates_virgin)) {
1658 /* We never uploaded a beacon before.
1659 * Upload both templates now, but only mark one valid. */
1660 wl->beacon_templates_virgin = 0;
1661 b43_upload_beacon0(dev);
1662 b43_upload_beacon1(dev);
c97a4ccc
MB		 1663 cmd = b43_read32(dev, B43_MMIO_MACCMD);
1664 cmd |= B43_MACCMD_BEACON0_VALID;
1665 b43_write32(dev, B43_MMIO_MACCMD, cmd);
6b4bec01
MB		 1666 } else {
1667 if (!beacon0_valid) {
1668 b43_upload_beacon0(dev);
1669 cmd = b43_read32(dev, B43_MMIO_MACCMD);
1670 cmd |= B43_MACCMD_BEACON0_VALID;
1671 b43_write32(dev, B43_MMIO_MACCMD, cmd);
1672 } else if (!beacon1_valid) {
1673 b43_upload_beacon1(dev);
1674 cmd = b43_read32(dev, B43_MMIO_MACCMD);
1675 cmd |= B43_MACCMD_BEACON1_VALID;
1676 b43_write32(dev, B43_MMIO_MACCMD, cmd);
c97a4ccc 1677 }
c97a4ccc
MB		 1678 }
1679}
1680
36dbd954
MB		 1681static void b43_do_beacon_update_trigger_work(struct b43_wldev *dev)
1682{
1683 u32 old_irq_mask = dev->irq_mask;
1684
1685 /* update beacon right away or defer to irq */
1686 handle_irq_beacon(dev);
1687 if (old_irq_mask != dev->irq_mask) {
1688 /* The handler updated the IRQ mask. */
1689 B43_WARN_ON(!dev->irq_mask);
1690 if (b43_read32(dev, B43_MMIO_GEN_IRQ_MASK)) {
1691 b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, dev->irq_mask);
1692 } else {
1693 /* Device interrupts are currently disabled. That means
1694 * we just ran the hardirq handler and scheduled the
1695 * IRQ thread. The thread will write the IRQ mask when
1696 * it finished, so there's nothing to do here. Writing
1697 * the mask _here_ would incorrectly re-enable IRQs. */
1698 }
1699 }
1700}
1701
a82d9922
MB		 1702static void b43_beacon_update_trigger_work(struct work_struct *work)
1703{
1704 struct b43_wl *wl = container_of(work, struct b43_wl,
1705 beacon_update_trigger);
1706 struct b43_wldev *dev;
1707
1708 mutex_lock(&wl->mutex);
1709 dev = wl->current_dev;
1710 if (likely(dev && (b43_status(dev) >= B43_STAT_INITIALIZED))) {
505fb019 1711 if (b43_bus_host_is_sdio(dev->dev)) {
36dbd954
MB		 1712 /* wl->mutex is enough. */
1713 b43_do_beacon_update_trigger_work(dev);
1714 mmiowb();
1715 } else {
1716 spin_lock_irq(&wl->hardirq_lock);
1717 b43_do_beacon_update_trigger_work(dev);
1718 mmiowb();
1719 spin_unlock_irq(&wl->hardirq_lock);
1720 }
a82d9922
MB		 1721 }
1722 mutex_unlock(&wl->mutex);
1723}
1724
d4df6f1a 1725/* Asynchronously update the packet templates in template RAM.
36dbd954 1726 * Locking: Requires wl->mutex to be locked. */
9d139c81 1727static void b43_update_templates(struct b43_wl *wl)
e4d6b795 1728{
9d139c81
JB		 1729 struct sk_buff *beacon;
1730
e66fee6a
MB		 1731 /* This is the top half of the ansynchronous beacon update.
1732 * The bottom half is the beacon IRQ.
1733 * Beacon update must be asynchronous to avoid sending an
1734 * invalid beacon. This can happen for example, if the firmware
1735 * transmits a beacon while we are updating it. */
e4d6b795 1736
9d139c81
JB		 1737 /* We could modify the existing beacon and set the aid bit in
1738 * the TIM field, but that would probably require resizing and
1739 * moving of data within the beacon template.
1740 * Simply request a new beacon and let mac80211 do the hard work. */
1741 beacon = ieee80211_beacon_get(wl->hw, wl->vif);
1742 if (unlikely(!beacon))
1743 return;
1744
e66fee6a
MB		 1745 if (wl->current_beacon)
1746 dev_kfree_skb_any(wl->current_beacon);
1747 wl->current_beacon = beacon;
1748 wl->beacon0_uploaded = 0;
1749 wl->beacon1_uploaded = 0;
42935eca 1750 ieee80211_queue_work(wl->hw, &wl->beacon_update_trigger);
e4d6b795
MB		 1751}
1752
e4d6b795
MB		 1753static void b43_set_beacon_int(struct b43_wldev *dev, u16 beacon_int)
1754{
1755 b43_time_lock(dev);
21d889d4 1756 if (dev->dev->core_rev >= 3) {
a82d9922
MB		 1757 b43_write32(dev, B43_MMIO_TSF_CFP_REP, (beacon_int << 16));
1758 b43_write32(dev, B43_MMIO_TSF_CFP_START, (beacon_int << 10));
e4d6b795
MB		 1759 } else {
1760 b43_write16(dev, 0x606, (beacon_int >> 6));
1761 b43_write16(dev, 0x610, beacon_int);
1762 }
1763 b43_time_unlock(dev);
a82d9922 1764 b43dbg(dev->wl, "Set beacon interval to %u\n", beacon_int);
e4d6b795
MB		 1765}
1766
afa83e23
MB		 1767static void b43_handle_firmware_panic(struct b43_wldev *dev)
1768{
1769 u16 reason;
1770
1771 /* Read the register that contains the reason code for the panic. */
1772 reason = b43_shm_read16(dev, B43_SHM_SCRATCH, B43_FWPANIC_REASON_REG);
1773 b43err(dev->wl, "Whoopsy, firmware panic! Reason: %u\n", reason);
1774
1775 switch (reason) {
1776 default:
1777 b43dbg(dev->wl, "The panic reason is unknown.\n");
1778 /* fallthrough */
1779 case B43_FWPANIC_DIE:
1780 /* Do not restart the controller or firmware.
1781 * The device is nonfunctional from now on.
1782 * Restarting would result in this panic to trigger again,
1783 * so we avoid that recursion. */
1784 break;
1785 case B43_FWPANIC_RESTART:
1786 b43_controller_restart(dev, "Microcode panic");
1787 break;
1788 }
1789}
1790
e4d6b795
MB		 1791static void handle_irq_ucode_debug(struct b43_wldev *dev)
1792{
e48b0eeb 1793 unsigned int i, cnt;
53c06856 1794 u16 reason, marker_id, marker_line;
e48b0eeb
MB		 1795 __le16 *buf;
1796
1797 /* The proprietary firmware doesn't have this IRQ. */
1798 if (!dev->fw.opensource)
1799 return;
1800
afa83e23
MB		 1801 /* Read the register that contains the reason code for this IRQ. */
1802 reason = b43_shm_read16(dev, B43_SHM_SCRATCH, B43_DEBUGIRQ_REASON_REG);
1803
e48b0eeb
MB		 1804 switch (reason) {
1805 case B43_DEBUGIRQ_PANIC:
afa83e23 1806 b43_handle_firmware_panic(dev);
e48b0eeb
MB		 1807 break;
1808 case B43_DEBUGIRQ_DUMP_SHM:
1809 if (!B43_DEBUG)
1810 break; /* Only with driver debugging enabled. */
1811 buf = kmalloc(4096, GFP_ATOMIC);
1812 if (!buf) {
1813 b43dbg(dev->wl, "SHM-dump: Failed to allocate memory\n");
1814 goto out;
1815 }
1816 for (i = 0; i < 4096; i += 2) {
1817 u16 tmp = b43_shm_read16(dev, B43_SHM_SHARED, i);
1818 buf[i / 2] = cpu_to_le16(tmp);
1819 }
1820 b43info(dev->wl, "Shared memory dump:\n");
1821 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET,
1822 16, 2, buf, 4096, 1);
1823 kfree(buf);
1824 break;
1825 case B43_DEBUGIRQ_DUMP_REGS:
1826 if (!B43_DEBUG)
1827 break; /* Only with driver debugging enabled. */
1828 b43info(dev->wl, "Microcode register dump:\n");
1829 for (i = 0, cnt = 0; i < 64; i++) {
1830 u16 tmp = b43_shm_read16(dev, B43_SHM_SCRATCH, i);
1831 if (cnt == 0)
1832 printk(KERN_INFO);
1833 printk("r%02u: 0x%04X ", i, tmp);
1834 cnt++;
1835 if (cnt == 6) {
1836 printk("\n");
1837 cnt = 0;
1838 }
1839 }
1840 printk("\n");
1841 break;
53c06856
MB		 1842 case B43_DEBUGIRQ_MARKER:
1843 if (!B43_DEBUG)
1844 break; /* Only with driver debugging enabled. */
1845 marker_id = b43_shm_read16(dev, B43_SHM_SCRATCH,
1846 B43_MARKER_ID_REG);
1847 marker_line = b43_shm_read16(dev, B43_SHM_SCRATCH,
1848 B43_MARKER_LINE_REG);
1849 b43info(dev->wl, "The firmware just executed the MARKER(%u) "
1850 "at line number %u\n",
1851 marker_id, marker_line);
1852 break;
e48b0eeb
MB		 1853 default:
1854 b43dbg(dev->wl, "Debug-IRQ triggered for unknown reason: %u\n",
1855 reason);
1856 }
1857out:
afa83e23
MB		 1858 /* Acknowledge the debug-IRQ, so the firmware can continue. */
1859 b43_shm_write16(dev, B43_SHM_SCRATCH,
1860 B43_DEBUGIRQ_REASON_REG, B43_DEBUGIRQ_ACK);
e4d6b795
MB		 1861}
1862
36dbd954 1863static void b43_do_interrupt_thread(struct b43_wldev *dev)
e4d6b795
MB		 1864{
1865 u32 reason;
1866 u32 dma_reason[ARRAY_SIZE(dev->dma_reason)];
1867 u32 merged_dma_reason = 0;
21954c36 1868 int i;
e4d6b795 1869
36dbd954
MB		 1870 if (unlikely(b43_status(dev) != B43_STAT_STARTED))
1871 return;
e4d6b795
MB		 1872
1873 reason = dev->irq_reason;
1874 for (i = 0; i < ARRAY_SIZE(dma_reason); i++) {
1875 dma_reason[i] = dev->dma_reason[i];
1876 merged_dma_reason |= dma_reason[i];
1877 }
1878
1879 if (unlikely(reason & B43_IRQ_MAC_TXERR))
1880 b43err(dev->wl, "MAC transmission error\n");
1881
00e0b8cb 1882 if (unlikely(reason & B43_IRQ_PHY_TXERR)) {
e4d6b795 1883 b43err(dev->wl, "PHY transmission error\n");
00e0b8cb
SB		 1884 rmb();
1885 if (unlikely(atomic_dec_and_test(&dev->phy.txerr_cnt))) {
1886 atomic_set(&dev->phy.txerr_cnt,
1887 B43_PHY_TX_BADNESS_LIMIT);
1888 b43err(dev->wl, "Too many PHY TX errors, "
1889 "restarting the controller\n");
1890 b43_controller_restart(dev, "PHY TX errors");
1891 }
1892 }
e4d6b795
MB		 1893
1894 if (unlikely(merged_dma_reason & (B43_DMAIRQ_FATALMASK |
1895 B43_DMAIRQ_NONFATALMASK))) {
1896 if (merged_dma_reason & B43_DMAIRQ_FATALMASK) {
1897 b43err(dev->wl, "Fatal DMA error: "
1898 "0x%08X, 0x%08X, 0x%08X, "
1899 "0x%08X, 0x%08X, 0x%08X\n",
1900 dma_reason[0], dma_reason[1],
1901 dma_reason[2], dma_reason[3],
1902 dma_reason[4], dma_reason[5]);
214ac9a4 1903 b43err(dev->wl, "This device does not support DMA "
bb64d95e 1904 "on your system. It will now be switched to PIO.\n");
9e3bd919
LT		 1905 /* Fall back to PIO transfers if we get fatal DMA errors! */
1906 dev->use_pio = 1;
1907 b43_controller_restart(dev, "DMA error");
e4d6b795
MB		 1908 return;
1909 }
1910 if (merged_dma_reason & B43_DMAIRQ_NONFATALMASK) {
1911 b43err(dev->wl, "DMA error: "
1912 "0x%08X, 0x%08X, 0x%08X, "
1913 "0x%08X, 0x%08X, 0x%08X\n",
1914 dma_reason[0], dma_reason[1],
1915 dma_reason[2], dma_reason[3],
1916 dma_reason[4], dma_reason[5]);
1917 }
1918 }
1919
1920 if (unlikely(reason & B43_IRQ_UCODE_DEBUG))
1921 handle_irq_ucode_debug(dev);
1922 if (reason & B43_IRQ_TBTT_INDI)
1923 handle_irq_tbtt_indication(dev);
1924 if (reason & B43_IRQ_ATIM_END)
1925 handle_irq_atim_end(dev);
1926 if (reason & B43_IRQ_BEACON)
1927 handle_irq_beacon(dev);
1928 if (reason & B43_IRQ_PMQ)
1929 handle_irq_pmq(dev);
21954c36
MB		 1930 if (reason & B43_IRQ_TXFIFO_FLUSH_OK)
1931 ;/* TODO */
1932 if (reason & B43_IRQ_NOISESAMPLE_OK)
e4d6b795
MB		 1933 handle_irq_noise(dev);
1934
1935 /* Check the DMA reason registers for received data. */
5100d5ac
MB		 1936 if (dma_reason[0] & B43_DMAIRQ_RX_DONE) {
1937 if (b43_using_pio_transfers(dev))
1938 b43_pio_rx(dev->pio.rx_queue);
1939 else
1940 b43_dma_rx(dev->dma.rx_ring);
1941 }
e4d6b795
MB		 1942 B43_WARN_ON(dma_reason[1] & B43_DMAIRQ_RX_DONE);
1943 B43_WARN_ON(dma_reason[2] & B43_DMAIRQ_RX_DONE);
b27faf8e 1944 B43_WARN_ON(dma_reason[3] & B43_DMAIRQ_RX_DONE);
e4d6b795
MB		 1945 B43_WARN_ON(dma_reason[4] & B43_DMAIRQ_RX_DONE);
1946 B43_WARN_ON(dma_reason[5] & B43_DMAIRQ_RX_DONE);
1947
21954c36 1948 if (reason & B43_IRQ_TX_OK)
e4d6b795 1949 handle_irq_transmit_status(dev);
e4d6b795 1950
36dbd954 1951 /* Re-enable interrupts on the device by restoring the current interrupt mask. */
13790728 1952 b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, dev->irq_mask);
990b86f4
MB		 1953
1954#if B43_DEBUG
1955 if (b43_debug(dev, B43_DBG_VERBOSESTATS)) {
1956 dev->irq_count++;
1957 for (i = 0; i < ARRAY_SIZE(dev->irq_bit_count); i++) {
1958 if (reason & (1 << i))
1959 dev->irq_bit_count[i]++;
1960 }
1961 }
1962#endif
e4d6b795
MB		 1963}
1964
36dbd954
MB		 1965/* Interrupt thread handler. Handles device interrupts in thread context. */
1966static irqreturn_t b43_interrupt_thread_handler(int irq, void *dev_id)
e4d6b795 1967{
36dbd954 1968 struct b43_wldev *dev = dev_id;
e4d6b795 1969
36dbd954
MB		 1970 mutex_lock(&dev->wl->mutex);
1971 b43_do_interrupt_thread(dev);
1972 mmiowb();
1973 mutex_unlock(&dev->wl->mutex);
1974
1975 return IRQ_HANDLED;
e4d6b795
MB		 1976}
1977
36dbd954 1978static irqreturn_t b43_do_interrupt(struct b43_wldev *dev)
e4d6b795 1979{
e4d6b795
MB		 1980 u32 reason;
1981
36dbd954
MB		 1982 /* This code runs under wl->hardirq_lock, but _only_ on non-SDIO busses.
1983 * On SDIO, this runs under wl->mutex. */
e4d6b795 1984
e4d6b795
MB		 1985 reason = b43_read32(dev, B43_MMIO_GEN_IRQ_REASON);
1986 if (reason == 0xffffffff) /* shared IRQ */
36dbd954 1987 return IRQ_NONE;
13790728 1988 reason &= dev->irq_mask;
e4d6b795 1989 if (!reason)
cae56147 1990 return IRQ_NONE;
e4d6b795
MB		 1991
1992 dev->dma_reason[0] = b43_read32(dev, B43_MMIO_DMA0_REASON)
1993 & 0x0001DC00;
1994 dev->dma_reason[1] = b43_read32(dev, B43_MMIO_DMA1_REASON)
1995 & 0x0000DC00;
1996 dev->dma_reason[2] = b43_read32(dev, B43_MMIO_DMA2_REASON)
1997 & 0x0000DC00;
1998 dev->dma_reason[3] = b43_read32(dev, B43_MMIO_DMA3_REASON)
1999 & 0x0001DC00;
2000 dev->dma_reason[4] = b43_read32(dev, B43_MMIO_DMA4_REASON)
2001 & 0x0000DC00;
13790728 2002/* Unused ring
e4d6b795
MB		 2003 dev->dma_reason[5] = b43_read32(dev, B43_MMIO_DMA5_REASON)
2004 & 0x0000DC00;
13790728 2005*/
e4d6b795 2006
36dbd954
MB		 2007 /* ACK the interrupt. */
2008 b43_write32(dev, B43_MMIO_GEN_IRQ_REASON, reason);
2009 b43_write32(dev, B43_MMIO_DMA0_REASON, dev->dma_reason[0]);
2010 b43_write32(dev, B43_MMIO_DMA1_REASON, dev->dma_reason[1]);
2011 b43_write32(dev, B43_MMIO_DMA2_REASON, dev->dma_reason[2]);
2012 b43_write32(dev, B43_MMIO_DMA3_REASON, dev->dma_reason[3]);
2013 b43_write32(dev, B43_MMIO_DMA4_REASON, dev->dma_reason[4]);
2014/* Unused ring
2015 b43_write32(dev, B43_MMIO_DMA5_REASON, dev->dma_reason[5]);
2016*/
2017
2018 /* Disable IRQs on the device. The IRQ thread handler will re-enable them. */
13790728 2019 b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, 0);
36dbd954 2020 /* Save the reason bitmasks for the IRQ thread handler. */
e4d6b795 2021 dev->irq_reason = reason;
36dbd954
MB		 2022
2023 return IRQ_WAKE_THREAD;
2024}
2025
2026/* Interrupt handler top-half. This runs with interrupts disabled. */
2027static irqreturn_t b43_interrupt_handler(int irq, void *dev_id)
2028{
2029 struct b43_wldev *dev = dev_id;
2030 irqreturn_t ret;
2031
2032 if (unlikely(b43_status(dev) < B43_STAT_STARTED))
2033 return IRQ_NONE;
2034
2035 spin_lock(&dev->wl->hardirq_lock);
2036 ret = b43_do_interrupt(dev);
e4d6b795 2037 mmiowb();
36dbd954 2038 spin_unlock(&dev->wl->hardirq_lock);
e4d6b795
MB		 2039
2040 return ret;
2041}
2042
3dbba8e2
AH		 2043/* SDIO interrupt handler. This runs in process context. */
2044static void b43_sdio_interrupt_handler(struct b43_wldev *dev)
2045{
2046 struct b43_wl *wl = dev->wl;
3dbba8e2
AH		 2047 irqreturn_t ret;
2048
3dbba8e2 2049 mutex_lock(&wl->mutex);
3dbba8e2
AH		 2050
2051 ret = b43_do_interrupt(dev);
2052 if (ret == IRQ_WAKE_THREAD)
2053 b43_do_interrupt_thread(dev);
2054
3dbba8e2
AH		 2055 mutex_unlock(&wl->mutex);
2056}
2057
1a9f5093 2058void b43_do_release_fw(struct b43_firmware_file *fw)
61cb5dd6
MB		 2059{
2060 release_firmware(fw->data);
2061 fw->data = NULL;
2062 fw->filename = NULL;
2063}
2064
e4d6b795
MB		 2065static void b43_release_firmware(struct b43_wldev *dev)
2066{
1a9f5093
MB		 2067 b43_do_release_fw(&dev->fw.ucode);
2068 b43_do_release_fw(&dev->fw.pcm);
2069 b43_do_release_fw(&dev->fw.initvals);
2070 b43_do_release_fw(&dev->fw.initvals_band);
e4d6b795
MB		 2071}
2072
eb189d8b 2073static void b43_print_fw_helptext(struct b43_wl *wl, bool error)
e4d6b795 2074{
fc68ed4f
HE		 2075 const char text[] =
2076 "You must go to " \
2077 "http://wireless.kernel.org/en/users/Drivers/b43#devicefirmware " \
2078 "and download the correct firmware for this driver version. " \
2079 "Please carefully read all instructions on this website.\n";
eb189d8b 2080
eb189d8b
MB		 2081 if (error)
2082 b43err(wl, text);
2083 else
2084 b43warn(wl, text);
e4d6b795
MB		 2085}
2086
1a9f5093
MB		 2087int b43_do_request_fw(struct b43_request_fw_context *ctx,
2088 const char *name,
2089 struct b43_firmware_file *fw)
e4d6b795 2090{
61cb5dd6 2091 const struct firmware *blob;
e4d6b795
MB		 2092 struct b43_fw_header *hdr;
2093 u32 size;
2094 int err;
2095
61cb5dd6
MB		 2096 if (!name) {
2097 /* Don't fetch anything. Free possibly cached firmware. */
1a9f5093
MB		 2098 /* FIXME: We should probably keep it anyway, to save some headache
2099 * on suspend/resume with multiband devices. */
2100 b43_do_release_fw(fw);
e4d6b795 2101 return 0;
61cb5dd6
MB		 2102 }
2103 if (fw->filename) {
1a9f5093
MB		 2104 if ((fw->type == ctx->req_type) &&
2105 (strcmp(fw->filename, name) == 0))
61cb5dd6
MB		 2106 return 0; /* Already have this fw. */
2107 /* Free the cached firmware first. */
1a9f5093
MB		 2108 /* FIXME: We should probably do this later after we successfully
2109 * got the new fw. This could reduce headache with multiband devices.
2110 * We could also redesign this to cache the firmware for all possible
2111 * bands all the time. */
2112 b43_do_release_fw(fw);
61cb5dd6 2113 }
e4d6b795 2114
1a9f5093
MB		 2115 switch (ctx->req_type) {
2116 case B43_FWTYPE_PROPRIETARY:
2117 snprintf(ctx->fwname, sizeof(ctx->fwname),
2118 "b43%s/%s.fw",
2119 modparam_fwpostfix, name);
2120 break;
2121 case B43_FWTYPE_OPENSOURCE:
2122 snprintf(ctx->fwname, sizeof(ctx->fwname),
2123 "b43-open%s/%s.fw",
2124 modparam_fwpostfix, name);
2125 break;
2126 default:
2127 B43_WARN_ON(1);
2128 return -ENOSYS;
2129 }
a18c715e 2130 err = request_firmware(&blob, ctx->fwname, ctx->dev->dev->dev);
68217832 2131 if (err == -ENOENT) {
1a9f5093
MB		 2132 snprintf(ctx->errors[ctx->req_type],
2133 sizeof(ctx->errors[ctx->req_type]),
2134 "Firmware file \"%s\" not found\n", ctx->fwname);
68217832
MB		 2135 return err;
2136 } else if (err) {
1a9f5093
MB		 2137 snprintf(ctx->errors[ctx->req_type],
2138 sizeof(ctx->errors[ctx->req_type]),
2139 "Firmware file \"%s\" request failed (err=%d)\n",
2140 ctx->fwname, err);
e4d6b795
MB		 2141 return err;
2142 }
61cb5dd6 2143 if (blob->size < sizeof(struct b43_fw_header))
e4d6b795 2144 goto err_format;
61cb5dd6 2145 hdr = (struct b43_fw_header *)(blob->data);
e4d6b795
MB		 2146 switch (hdr->type) {
2147 case B43_FW_TYPE_UCODE:
2148 case B43_FW_TYPE_PCM:
2149 size = be32_to_cpu(hdr->size);
61cb5dd6 2150 if (size != blob->size - sizeof(struct b43_fw_header))
e4d6b795
MB		 2151 goto err_format;
2152 /* fallthrough */
2153 case B43_FW_TYPE_IV:
2154 if (hdr->ver != 1)
2155 goto err_format;
2156 break;
2157 default:
2158 goto err_format;
2159 }
2160
61cb5dd6
MB		 2161 fw->data = blob;
2162 fw->filename = name;
1a9f5093 2163 fw->type = ctx->req_type;
61cb5dd6
MB		 2164
2165 return 0;
e4d6b795
MB		 2166
2167err_format:
1a9f5093
MB		 2168 snprintf(ctx->errors[ctx->req_type],
2169 sizeof(ctx->errors[ctx->req_type]),
2170 "Firmware file \"%s\" format error.\n", ctx->fwname);
61cb5dd6
MB		 2171 release_firmware(blob);
2172
e4d6b795
MB		 2173 return -EPROTO;
2174}
2175
1a9f5093 2176static int b43_try_request_fw(struct b43_request_fw_context *ctx)
e4d6b795 2177{
1a9f5093
MB		 2178 struct b43_wldev *dev = ctx->dev;
2179 struct b43_firmware *fw = &ctx->dev->fw;
21d889d4 2180 const u8 rev = ctx->dev->dev->core_rev;
e4d6b795
MB		 2181 const char *filename;
2182 u32 tmshigh;
2183 int err;
2184
8b9bda75
RM		 2185 /* Files for HT and LCN were found by trying one by one */
2186
61cb5dd6 2187 /* Get microcode */
6ff1e5cf 2188 if ((rev >= 5) && (rev <= 10)) {
61cb5dd6 2189 filename = "ucode5";
6ff1e5cf 2190 } else if ((rev >= 11) && (rev <= 12)) {
61cb5dd6 2191 filename = "ucode11";
6ff1e5cf 2192 } else if (rev == 13) {
61cb5dd6 2193 filename = "ucode13";
6ff1e5cf 2194 } else if (rev == 14) {
759b973b 2195 filename = "ucode14";
6ff1e5cf 2196 } else if (rev == 15) {
759b973b 2197 filename = "ucode15";
6ff1e5cf
RM		 2198 } else {
2199 switch (dev->phy.type) {
2200 case B43_PHYTYPE_N:
2201 if (rev >= 16)
2202 filename = "ucode16_mimo";
2203 else
2204 goto err_no_ucode;
2205 break;
8b9bda75
RM		 2206 case B43_PHYTYPE_HT:
2207 if (rev == 29)
2208 filename = "ucode29_mimo";
2209 else
2210 goto err_no_ucode;
2211 break;
2212 case B43_PHYTYPE_LCN:
2213 if (rev == 24)
2214 filename = "ucode24_mimo";
2215 else
2216 goto err_no_ucode;
2217 break;
6ff1e5cf
RM		 2218 default:
2219 goto err_no_ucode;
2220 }
2221 }
1a9f5093 2222 err = b43_do_request_fw(ctx, filename, &fw->ucode);
61cb5dd6
MB		 2223 if (err)
2224 goto err_load;
2225
2226 /* Get PCM code */
2227 if ((rev >= 5) && (rev <= 10))
2228 filename = "pcm5";
2229 else if (rev >= 11)
2230 filename = NULL;
2231 else
2232 goto err_no_pcm;
68217832 2233 fw->pcm_request_failed = 0;
1a9f5093 2234 err = b43_do_request_fw(ctx, filename, &fw->pcm);
68217832
MB		 2235 if (err == -ENOENT) {
2236 /* We did not find a PCM file? Not fatal, but
2237 * core rev <= 10 must do without hwcrypto then. */
2238 fw->pcm_request_failed = 1;
2239 } else if (err)
61cb5dd6
MB		 2240 goto err_load;
2241
2242 /* Get initvals */
2243 switch (dev->phy.type) {
2244 case B43_PHYTYPE_A:
2245 if ((rev >= 5) && (rev <= 10)) {
d48ae5c8 2246 tmshigh = ssb_read32(dev->dev->sdev, SSB_TMSHIGH);
61cb5dd6
MB		 2247 if (tmshigh & B43_TMSHIGH_HAVE_2GHZ_PHY)
2248 filename = "a0g1initvals5";
2249 else
2250 filename = "a0g0initvals5";
2251 } else
2252 goto err_no_initvals;
2253 break;
2254 case B43_PHYTYPE_G:
e4d6b795 2255 if ((rev >= 5) && (rev <= 10))
61cb5dd6 2256 filename = "b0g0initvals5";
e4d6b795 2257 else if (rev >= 13)
e9304882 2258 filename = "b0g0initvals13";
e4d6b795 2259 else
61cb5dd6
MB		 2260 goto err_no_initvals;
2261 break;
2262 case B43_PHYTYPE_N:
e41596a1
RM		 2263 if (rev >= 16)
2264 filename = "n0initvals16";
2265 else if ((rev >= 11) && (rev <= 12))
61cb5dd6
MB		 2266 filename = "n0initvals11";
2267 else
2268 goto err_no_initvals;
2269 break;
759b973b
GS		 2270 case B43_PHYTYPE_LP:
2271 if (rev == 13)
2272 filename = "lp0initvals13";
2273 else if (rev == 14)
2274 filename = "lp0initvals14";
2275 else if (rev >= 15)
2276 filename = "lp0initvals15";
2277 else
2278 goto err_no_initvals;
2279 break;
8b9bda75
RM		 2280 case B43_PHYTYPE_HT:
2281 if (rev == 29)
2282 filename = "ht0initvals29";
2283 else
2284 goto err_no_initvals;
2285 break;
2286 case B43_PHYTYPE_LCN:
2287 if (rev == 24)
2288 filename = "lcn0initvals24";
2289 else
2290 goto err_no_initvals;
2291 break;
61cb5dd6
MB		 2292 default:
2293 goto err_no_initvals;
e4d6b795 2294 }
1a9f5093 2295 err = b43_do_request_fw(ctx, filename, &fw->initvals);
61cb5dd6
MB		 2296 if (err)
2297 goto err_load;
2298
2299 /* Get bandswitch initvals */
2300 switch (dev->phy.type) {
2301 case B43_PHYTYPE_A:
2302 if ((rev >= 5) && (rev <= 10)) {
d48ae5c8 2303 tmshigh = ssb_read32(dev->dev->sdev, SSB_TMSHIGH);
61cb5dd6
MB		 2304 if (tmshigh & B43_TMSHIGH_HAVE_2GHZ_PHY)
2305 filename = "a0g1bsinitvals5";
2306 else
2307 filename = "a0g0bsinitvals5";
2308 } else if (rev >= 11)
2309 filename = NULL;
2310 else
2311 goto err_no_initvals;
2312 break;
2313 case B43_PHYTYPE_G:
e4d6b795 2314 if ((rev >= 5) && (rev <= 10))
61cb5dd6 2315 filename = "b0g0bsinitvals5";
e4d6b795
MB		 2316 else if (rev >= 11)
2317 filename = NULL;
2318 else
e4d6b795 2319 goto err_no_initvals;
61cb5dd6
MB		 2320 break;
2321 case B43_PHYTYPE_N:
e41596a1
RM		 2322 if (rev >= 16)
2323 filename = "n0bsinitvals16";
2324 else if ((rev >= 11) && (rev <= 12))
61cb5dd6
MB		 2325 filename = "n0bsinitvals11";
2326 else
e4d6b795 2327 goto err_no_initvals;
61cb5dd6 2328 break;
759b973b
GS		 2329 case B43_PHYTYPE_LP:
2330 if (rev == 13)
2331 filename = "lp0bsinitvals13";
2332 else if (rev == 14)
2333 filename = "lp0bsinitvals14";
2334 else if (rev >= 15)
2335 filename = "lp0bsinitvals15";
2336 else
2337 goto err_no_initvals;
2338 break;
8b9bda75
RM		 2339 case B43_PHYTYPE_HT:
2340 if (rev == 29)
2341 filename = "ht0bsinitvals29";
2342 else
2343 goto err_no_initvals;
2344 break;
2345 case B43_PHYTYPE_LCN:
2346 if (rev == 24)
2347 filename = "lcn0bsinitvals24";
2348 else
2349 goto err_no_initvals;
2350 break;
61cb5dd6
MB		 2351 default:
2352 goto err_no_initvals;
e4d6b795 2353 }
1a9f5093 2354 err = b43_do_request_fw(ctx, filename, &fw->initvals_band);
61cb5dd6
MB		 2355 if (err)
2356 goto err_load;
e4d6b795
MB		 2357
2358 return 0;
2359
e4d6b795 2360err_no_ucode:
1a9f5093
MB		 2361 err = ctx->fatal_failure = -EOPNOTSUPP;
2362 b43err(dev->wl, "The driver does not know which firmware (ucode) "
2363 "is required for your device (wl-core rev %u)\n", rev);
e4d6b795
MB		 2364 goto error;
2365
2366err_no_pcm:
1a9f5093
MB		 2367 err = ctx->fatal_failure = -EOPNOTSUPP;
2368 b43err(dev->wl, "The driver does not know which firmware (PCM) "
2369 "is required for your device (wl-core rev %u)\n", rev);
e4d6b795
MB		 2370 goto error;
2371
2372err_no_initvals:
1a9f5093
MB		 2373 err = ctx->fatal_failure = -EOPNOTSUPP;
2374 b43err(dev->wl, "The driver does not know which firmware (initvals) "
2375 "is required for your device (wl-core rev %u)\n", rev);
2376 goto error;
2377
2378err_load:
2379 /* We failed to load this firmware image. The error message
2380 * already is in ctx->errors. Return and let our caller decide
2381 * what to do. */
e4d6b795
MB		 2382 goto error;
2383
2384error:
2385 b43_release_firmware(dev);
2386 return err;
2387}
2388
1a9f5093
MB		 2389static int b43_request_firmware(struct b43_wldev *dev)
2390{
2391 struct b43_request_fw_context *ctx;
2392 unsigned int i;
2393 int err;
2394 const char *errmsg;
2395
2396 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
2397 if (!ctx)
2398 return -ENOMEM;
2399 ctx->dev = dev;
2400
2401 ctx->req_type = B43_FWTYPE_PROPRIETARY;
2402 err = b43_try_request_fw(ctx);
2403 if (!err)
2404 goto out; /* Successfully loaded it. */
2405 err = ctx->fatal_failure;
2406 if (err)
2407 goto out;
2408
2409 ctx->req_type = B43_FWTYPE_OPENSOURCE;
2410 err = b43_try_request_fw(ctx);
2411 if (!err)
2412 goto out; /* Successfully loaded it. */
2413 err = ctx->fatal_failure;
2414 if (err)
2415 goto out;
2416
2417 /* Could not find a usable firmware. Print the errors. */
2418 for (i = 0; i < B43_NR_FWTYPES; i++) {
2419 errmsg = ctx->errors[i];
2420 if (strlen(errmsg))
2421 b43err(dev->wl, errmsg);
2422 }
2423 b43_print_fw_helptext(dev->wl, 1);
2424 err = -ENOENT;
2425
2426out:
2427 kfree(ctx);
2428 return err;
2429}
2430
e4d6b795
MB		 2431static int b43_upload_microcode(struct b43_wldev *dev)
2432{
652caa5b 2433 struct wiphy *wiphy = dev->wl->hw->wiphy;
e4d6b795
MB		 2434 const size_t hdr_len = sizeof(struct b43_fw_header);
2435 const __be32 *data;
2436 unsigned int i, len;
2437 u16 fwrev, fwpatch, fwdate, fwtime;
1f7d87b0 2438 u32 tmp, macctl;
e4d6b795
MB		 2439 int err = 0;
2440
1f7d87b0
MB		 2441 /* Jump the microcode PSM to offset 0 */
2442 macctl = b43_read32(dev, B43_MMIO_MACCTL);
2443 B43_WARN_ON(macctl & B43_MACCTL_PSM_RUN);
2444 macctl |= B43_MACCTL_PSM_JMP0;
2445 b43_write32(dev, B43_MMIO_MACCTL, macctl);
2446 /* Zero out all microcode PSM registers and shared memory. */
2447 for (i = 0; i < 64; i++)
2448 b43_shm_write16(dev, B43_SHM_SCRATCH, i, 0);
2449 for (i = 0; i < 4096; i += 2)
2450 b43_shm_write16(dev, B43_SHM_SHARED, i, 0);
2451
e4d6b795 2452 /* Upload Microcode. */
61cb5dd6
MB		 2453 data = (__be32 *) (dev->fw.ucode.data->data + hdr_len);
2454 len = (dev->fw.ucode.data->size - hdr_len) / sizeof(__be32);
e4d6b795
MB		 2455 b43_shm_control_word(dev, B43_SHM_UCODE | B43_SHM_AUTOINC_W, 0x0000);
2456 for (i = 0; i < len; i++) {
2457 b43_write32(dev, B43_MMIO_SHM_DATA, be32_to_cpu(data[i]));
2458 udelay(10);
2459 }
2460
61cb5dd6 2461 if (dev->fw.pcm.data) {
e4d6b795 2462 /* Upload PCM data. */
61cb5dd6
MB		 2463 data = (__be32 *) (dev->fw.pcm.data->data + hdr_len);
2464 len = (dev->fw.pcm.data->size - hdr_len) / sizeof(__be32);
e4d6b795
MB		 2465 b43_shm_control_word(dev, B43_SHM_HW, 0x01EA);
2466 b43_write32(dev, B43_MMIO_SHM_DATA, 0x00004000);
2467 /* No need for autoinc bit in SHM_HW */
2468 b43_shm_control_word(dev, B43_SHM_HW, 0x01EB);
2469 for (i = 0; i < len; i++) {
2470 b43_write32(dev, B43_MMIO_SHM_DATA, be32_to_cpu(data[i]));
2471 udelay(10);
2472 }
2473 }
2474
2475 b43_write32(dev, B43_MMIO_GEN_IRQ_REASON, B43_IRQ_ALL);
1f7d87b0
MB		 2476
2477 /* Start the microcode PSM */
2478 macctl = b43_read32(dev, B43_MMIO_MACCTL);
2479 macctl &= ~B43_MACCTL_PSM_JMP0;
2480 macctl |= B43_MACCTL_PSM_RUN;
2481 b43_write32(dev, B43_MMIO_MACCTL, macctl);
e4d6b795
MB		 2482
2483 /* Wait for the microcode to load and respond */
2484 i = 0;
2485 while (1) {
2486 tmp = b43_read32(dev, B43_MMIO_GEN_IRQ_REASON);
2487 if (tmp == B43_IRQ_MAC_SUSPENDED)
2488 break;
2489 i++;
1f7d87b0 2490 if (i >= 20) {
e4d6b795 2491 b43err(dev->wl, "Microcode not responding\n");
eb189d8b 2492 b43_print_fw_helptext(dev->wl, 1);
e4d6b795 2493 err = -ENODEV;
1f7d87b0
MB		 2494 goto error;
2495 }
e175e996 2496 msleep(50);
e4d6b795
MB		 2497 }
2498 b43_read32(dev, B43_MMIO_GEN_IRQ_REASON); /* dummy read */
2499
2500 /* Get and check the revisions. */
2501 fwrev = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_UCODEREV);
2502 fwpatch = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_UCODEPATCH);
2503 fwdate = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_UCODEDATE);
2504 fwtime = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_UCODETIME);
2505
2506 if (fwrev <= 0x128) {
2507 b43err(dev->wl, "YOUR FIRMWARE IS TOO OLD. Firmware from "
2508 "binary drivers older than version 4.x is unsupported. "
2509 "You must upgrade your firmware files.\n");
eb189d8b 2510 b43_print_fw_helptext(dev->wl, 1);
e4d6b795 2511 err = -EOPNOTSUPP;
1f7d87b0 2512 goto error;
e4d6b795 2513 }
e4d6b795
MB		 2514 dev->fw.rev = fwrev;
2515 dev->fw.patch = fwpatch;
5d852905
RM		 2516 if (dev->fw.rev >= 598)
2517 dev->fw.hdr_format = B43_FW_HDR_598;
2518 else if (dev->fw.rev >= 410)
efe0249b
RM		 2519 dev->fw.hdr_format = B43_FW_HDR_410;
2520 else
2521 dev->fw.hdr_format = B43_FW_HDR_351;
e48b0eeb
MB		 2522 dev->fw.opensource = (fwdate == 0xFFFF);
2523
403a3a13
MB		 2524 /* Default to use-all-queues. */
2525 dev->wl->hw->queues = dev->wl->mac80211_initially_registered_queues;
2526 dev->qos_enabled = !!modparam_qos;
2527 /* Default to firmware/hardware crypto acceleration. */
2528 dev->hwcrypto_enabled = 1;
2529
e48b0eeb 2530 if (dev->fw.opensource) {
403a3a13
MB		 2531 u16 fwcapa;
2532
e48b0eeb
MB		 2533 /* Patchlevel info is encoded in the "time" field. */
2534 dev->fw.patch = fwtime;
403a3a13
MB		 2535 b43info(dev->wl, "Loading OpenSource firmware version %u.%u\n",
2536 dev->fw.rev, dev->fw.patch);
2537
2538 fwcapa = b43_fwcapa_read(dev);
2539 if (!(fwcapa & B43_FWCAPA_HWCRYPTO) || dev->fw.pcm_request_failed) {
2540 b43info(dev->wl, "Hardware crypto acceleration not supported by firmware\n");
2541 /* Disable hardware crypto and fall back to software crypto. */
2542 dev->hwcrypto_enabled = 0;
2543 }
2544 if (!(fwcapa & B43_FWCAPA_QOS)) {
2545 b43info(dev->wl, "QoS not supported by firmware\n");
2546 /* Disable QoS. Tweak hw->queues to 1. It will be restored before
2547 * ieee80211_unregister to make sure the networking core can
2548 * properly free possible resources. */
2549 dev->wl->hw->queues = 1;
2550 dev->qos_enabled = 0;
2551 }
e48b0eeb
MB		 2552 } else {
2553 b43info(dev->wl, "Loading firmware version %u.%u "
2554 "(20%.2i-%.2i-%.2i %.2i:%.2i:%.2i)\n",
2555 fwrev, fwpatch,
2556 (fwdate >> 12) & 0xF, (fwdate >> 8) & 0xF, fwdate & 0xFF,
2557 (fwtime >> 11) & 0x1F, (fwtime >> 5) & 0x3F, fwtime & 0x1F);
68217832
MB		 2558 if (dev->fw.pcm_request_failed) {
2559 b43warn(dev->wl, "No \"pcm5.fw\" firmware file found. "
2560 "Hardware accelerated cryptography is disabled.\n");
2561 b43_print_fw_helptext(dev->wl, 0);
2562 }
e48b0eeb 2563 }
e4d6b795 2564
652caa5b
JL		 2565 snprintf(wiphy->fw_version, sizeof(wiphy->fw_version), "%u.%u",
2566 dev->fw.rev, dev->fw.patch);
21d889d4 2567 wiphy->hw_version = dev->dev->core_id;
652caa5b 2568
efe0249b 2569 if (dev->fw.hdr_format == B43_FW_HDR_351) {
c557289c
MB		 2570 /* We're over the deadline, but we keep support for old fw
2571 * until it turns out to be in major conflict with something new. */
eb189d8b 2572 b43warn(dev->wl, "You are using an old firmware image. "
c557289c
MB		 2573 "Support for old firmware will be removed soon "
2574 "(official deadline was July 2008).\n");
eb189d8b
MB		 2575 b43_print_fw_helptext(dev->wl, 0);
2576 }
2577
1f7d87b0
MB		 2578 return 0;
2579
2580error:
2581 macctl = b43_read32(dev, B43_MMIO_MACCTL);
2582 macctl &= ~B43_MACCTL_PSM_RUN;
2583 macctl |= B43_MACCTL_PSM_JMP0;
2584 b43_write32(dev, B43_MMIO_MACCTL, macctl);
2585
e4d6b795
MB		 2586 return err;
2587}
2588
2589static int b43_write_initvals(struct b43_wldev *dev,
2590 const struct b43_iv *ivals,
2591 size_t count,
2592 size_t array_size)
2593{
2594 const struct b43_iv *iv;
2595 u16 offset;
2596 size_t i;
2597 bool bit32;
2598
2599 BUILD_BUG_ON(sizeof(struct b43_iv) != 6);
2600 iv = ivals;
2601 for (i = 0; i < count; i++) {
2602 if (array_size < sizeof(iv->offset_size))
2603 goto err_format;
2604 array_size -= sizeof(iv->offset_size);
2605 offset = be16_to_cpu(iv->offset_size);
2606 bit32 = !!(offset & B43_IV_32BIT);
2607 offset &= B43_IV_OFFSET_MASK;
2608 if (offset >= 0x1000)
2609 goto err_format;
2610 if (bit32) {
2611 u32 value;
2612
2613 if (array_size < sizeof(iv->data.d32))
2614 goto err_format;
2615 array_size -= sizeof(iv->data.d32);
2616
533dd1b0 2617 value = get_unaligned_be32(&iv->data.d32);
e4d6b795
MB		 2618 b43_write32(dev, offset, value);
2619
2620 iv = (const struct b43_iv *)((const uint8_t *)iv +
2621 sizeof(__be16) +
2622 sizeof(__be32));
2623 } else {
2624 u16 value;
2625
2626 if (array_size < sizeof(iv->data.d16))
2627 goto err_format;
2628 array_size -= sizeof(iv->data.d16);
2629
2630 value = be16_to_cpu(iv->data.d16);
2631 b43_write16(dev, offset, value);
2632
2633 iv = (const struct b43_iv *)((const uint8_t *)iv +
2634 sizeof(__be16) +
2635 sizeof(__be16));
2636 }
2637 }
2638 if (array_size)
2639 goto err_format;
2640
2641 return 0;
2642
2643err_format:
2644 b43err(dev->wl, "Initial Values Firmware file-format error.\n");
eb189d8b 2645 b43_print_fw_helptext(dev->wl, 1);
e4d6b795
MB		 2646
2647 return -EPROTO;
2648}
2649
2650static int b43_upload_initvals(struct b43_wldev *dev)
2651{
2652 const size_t hdr_len = sizeof(struct b43_fw_header);
2653 const struct b43_fw_header *hdr;
2654 struct b43_firmware *fw = &dev->fw;
2655 const struct b43_iv *ivals;
2656 size_t count;
2657 int err;
2658
61cb5dd6
MB		 2659 hdr = (const struct b43_fw_header *)(fw->initvals.data->data);
2660 ivals = (const struct b43_iv *)(fw->initvals.data->data + hdr_len);
e4d6b795
MB		 2661 count = be32_to_cpu(hdr->size);
2662 err = b43_write_initvals(dev, ivals, count,
61cb5dd6 2663 fw->initvals.data->size - hdr_len);
e4d6b795
MB		 2664 if (err)
2665 goto out;
61cb5dd6
MB		 2666 if (fw->initvals_band.data) {
2667 hdr = (const struct b43_fw_header *)(fw->initvals_band.data->data);
2668 ivals = (const struct b43_iv *)(fw->initvals_band.data->data + hdr_len);
e4d6b795
MB		 2669 count = be32_to_cpu(hdr->size);
2670 err = b43_write_initvals(dev, ivals, count,
61cb5dd6 2671 fw->initvals_band.data->size - hdr_len);
e4d6b795
MB		 2672 if (err)
2673 goto out;
2674 }
2675out:
2676
2677 return err;
2678}
2679
2680/* Initialize the GPIOs
2681 * http://bcm-specs.sipsolutions.net/GPIO
2682 */
c4a2a081 2683static struct ssb_device *b43_ssb_gpio_dev(struct b43_wldev *dev)
e4d6b795 2684{
d48ae5c8 2685 struct ssb_bus *bus = dev->dev->sdev->bus;
c4a2a081
RM		 2686
2687#ifdef CONFIG_SSB_DRIVER_PCICORE
2688 return (bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev);
2689#else
2690 return bus->chipco.dev;
2691#endif
2692}
2693
e4d6b795
MB		 2694static int b43_gpio_init(struct b43_wldev *dev)
2695{
c4a2a081 2696 struct ssb_device *gpiodev;
e4d6b795
MB		 2697 u32 mask, set;
2698
2699 b43_write32(dev, B43_MMIO_MACCTL, b43_read32(dev, B43_MMIO_MACCTL)
2700 & ~B43_MACCTL_GPOUTSMSK);
2701
e4d6b795
MB		 2702 b43_write16(dev, B43_MMIO_GPIO_MASK, b43_read16(dev, B43_MMIO_GPIO_MASK)
2703 | 0x000F);
2704
2705 mask = 0x0000001F;
2706 set = 0x0000000F;
c244e08c 2707 if (dev->dev->chip_id == 0x4301) {
e4d6b795
MB		 2708 mask |= 0x0060;
2709 set |= 0x0060;
2710 }
2711 if (0 /* FIXME: conditional unknown */ ) {
2712 b43_write16(dev, B43_MMIO_GPIO_MASK,
2713 b43_read16(dev, B43_MMIO_GPIO_MASK)
2714 | 0x0100);
2715 mask |= 0x0180;
2716 set |= 0x0180;
2717 }
0581483a 2718 if (dev->dev->bus_sprom->boardflags_lo & B43_BFL_PACTRL) {
e4d6b795
MB		 2719 b43_write16(dev, B43_MMIO_GPIO_MASK,
2720 b43_read16(dev, B43_MMIO_GPIO_MASK)
2721 | 0x0200);
2722 mask |= 0x0200;
2723 set |= 0x0200;
2724 }
21d889d4 2725 if (dev->dev->core_rev >= 2)
e4d6b795
MB		 2726 mask |= 0x0010; /* FIXME: This is redundant. */
2727
6cbab0d9 2728 switch (dev->dev->bus_type) {
42c9a458
RM		 2729#ifdef CONFIG_B43_BCMA
2730 case B43_BUS_BCMA:
2731 bcma_cc_write32(&dev->dev->bdev->bus->drv_cc, BCMA_CC_GPIOCTL,
2732 (bcma_cc_read32(&dev->dev->bdev->bus->drv_cc,
2733 BCMA_CC_GPIOCTL) & mask) | set);
2734 break;
2735#endif
6cbab0d9
RM		 2736#ifdef CONFIG_B43_SSB
2737 case B43_BUS_SSB:
2738 gpiodev = b43_ssb_gpio_dev(dev);
2739 if (gpiodev)
2740 ssb_write32(gpiodev, B43_GPIO_CONTROL,
2741 (ssb_read32(gpiodev, B43_GPIO_CONTROL)
2742 & mask) | set);
2743 break;
2744#endif
2745 }
e4d6b795
MB		 2746
2747 return 0;
2748}
2749
2750/* Turn off all GPIO stuff. Call this on module unload, for example. */
2751static void b43_gpio_cleanup(struct b43_wldev *dev)
2752{
c4a2a081 2753 struct ssb_device *gpiodev;
e4d6b795 2754
6cbab0d9 2755 switch (dev->dev->bus_type) {
42c9a458
RM		 2756#ifdef CONFIG_B43_BCMA
2757 case B43_BUS_BCMA:
2758 bcma_cc_write32(&dev->dev->bdev->bus->drv_cc, BCMA_CC_GPIOCTL,
2759 0);
2760 break;
2761#endif
6cbab0d9
RM		 2762#ifdef CONFIG_B43_SSB
2763 case B43_BUS_SSB:
2764 gpiodev = b43_ssb_gpio_dev(dev);
2765 if (gpiodev)
2766 ssb_write32(gpiodev, B43_GPIO_CONTROL, 0);
2767 break;
2768#endif
2769 }
e4d6b795
MB		 2770}
2771
2772/* http://bcm-specs.sipsolutions.net/EnableMac */
f5eda47f 2773void b43_mac_enable(struct b43_wldev *dev)
e4d6b795 2774{
923fd703
MB		 2775 if (b43_debug(dev, B43_DBG_FIRMWARE)) {
2776 u16 fwstate;
2777
2778 fwstate = b43_shm_read16(dev, B43_SHM_SHARED,
2779 B43_SHM_SH_UCODESTAT);
2780 if ((fwstate != B43_SHM_SH_UCODESTAT_SUSP) &&
2781 (fwstate != B43_SHM_SH_UCODESTAT_SLEEP)) {
2782 b43err(dev->wl, "b43_mac_enable(): The firmware "
2783 "should be suspended, but current state is %u\n",
2784 fwstate);
2785 }
2786 }
2787
e4d6b795
MB		 2788 dev->mac_suspended--;
2789 B43_WARN_ON(dev->mac_suspended < 0);
2790 if (dev->mac_suspended == 0) {
2791 b43_write32(dev, B43_MMIO_MACCTL,
2792 b43_read32(dev, B43_MMIO_MACCTL)
2793 | B43_MACCTL_ENABLED);
2794 b43_write32(dev, B43_MMIO_GEN_IRQ_REASON,
2795 B43_IRQ_MAC_SUSPENDED);
2796 /* Commit writes */
2797 b43_read32(dev, B43_MMIO_MACCTL);
2798 b43_read32(dev, B43_MMIO_GEN_IRQ_REASON);
2799 b43_power_saving_ctl_bits(dev, 0);
2800 }
2801}
2802
2803/* http://bcm-specs.sipsolutions.net/SuspendMAC */
f5eda47f 2804void b43_mac_suspend(struct b43_wldev *dev)
e4d6b795
MB		 2805{
2806 int i;
2807 u32 tmp;
2808
05b64b36 2809 might_sleep();
e4d6b795 2810 B43_WARN_ON(dev->mac_suspended < 0);
05b64b36 2811
e4d6b795
MB		 2812 if (dev->mac_suspended == 0) {
2813 b43_power_saving_ctl_bits(dev, B43_PS_AWAKE);
2814 b43_write32(dev, B43_MMIO_MACCTL,
2815 b43_read32(dev, B43_MMIO_MACCTL)
2816 & ~B43_MACCTL_ENABLED);
2817 /* force pci to flush the write */
2818 b43_read32(dev, B43_MMIO_MACCTL);
ba380013
MB		 2819 for (i = 35; i; i--) {
2820 tmp = b43_read32(dev, B43_MMIO_GEN_IRQ_REASON);
2821 if (tmp & B43_IRQ_MAC_SUSPENDED)
2822 goto out;
2823 udelay(10);
2824 }
2825 /* Hm, it seems this will take some time. Use msleep(). */
05b64b36 2826 for (i = 40; i; i--) {
e4d6b795
MB		 2827 tmp = b43_read32(dev, B43_MMIO_GEN_IRQ_REASON);
2828 if (tmp & B43_IRQ_MAC_SUSPENDED)
2829 goto out;
05b64b36 2830 msleep(1);
e4d6b795
MB		 2831 }
2832 b43err(dev->wl, "MAC suspend failed\n");
2833 }
05b64b36 2834out:
e4d6b795
MB		 2835 dev->mac_suspended++;
2836}
2837
858a1652
RM		 2838/* http://bcm-v4.sipsolutions.net/802.11/PHY/N/MacPhyClkSet */
2839void b43_mac_phy_clock_set(struct b43_wldev *dev, bool on)
2840{
6cbab0d9
RM		 2841 u32 tmp;
2842
2843 switch (dev->dev->bus_type) {
42c9a458
RM		 2844#ifdef CONFIG_B43_BCMA
2845 case B43_BUS_BCMA:
36677874 2846 tmp = bcma_aread32(dev->dev->bdev, BCMA_IOCTL);
42c9a458
RM		 2847 if (on)
2848 tmp |= B43_BCMA_IOCTL_MACPHYCLKEN;
2849 else
2850 tmp &= ~B43_BCMA_IOCTL_MACPHYCLKEN;
36677874 2851 bcma_awrite32(dev->dev->bdev, BCMA_IOCTL, tmp);
42c9a458
RM		 2852 break;
2853#endif
6cbab0d9
RM		 2854#ifdef CONFIG_B43_SSB
2855 case B43_BUS_SSB:
2856 tmp = ssb_read32(dev->dev->sdev, SSB_TMSLOW);
2857 if (on)
2858 tmp |= B43_TMSLOW_MACPHYCLKEN;
2859 else
2860 tmp &= ~B43_TMSLOW_MACPHYCLKEN;
2861 ssb_write32(dev->dev->sdev, SSB_TMSLOW, tmp);
2862 break;
2863#endif
2864 }
858a1652
RM		 2865}
2866
e4d6b795
MB		 2867static void b43_adjust_opmode(struct b43_wldev *dev)
2868{
2869 struct b43_wl *wl = dev->wl;
2870 u32 ctl;
2871 u16 cfp_pretbtt;
2872
2873 ctl = b43_read32(dev, B43_MMIO_MACCTL);
2874 /* Reset status to STA infrastructure mode. */
2875 ctl &= ~B43_MACCTL_AP;
2876 ctl &= ~B43_MACCTL_KEEP_CTL;
2877 ctl &= ~B43_MACCTL_KEEP_BADPLCP;
2878 ctl &= ~B43_MACCTL_KEEP_BAD;
2879 ctl &= ~B43_MACCTL_PROMISC;
4150c572 2880 ctl &= ~B43_MACCTL_BEACPROMISC;
e4d6b795
MB		 2881 ctl |= B43_MACCTL_INFRA;
2882
05c914fe
JB		 2883 if (b43_is_mode(wl, NL80211_IFTYPE_AP) ||
2884 b43_is_mode(wl, NL80211_IFTYPE_MESH_POINT))
4150c572 2885 ctl |= B43_MACCTL_AP;
05c914fe 2886 else if (b43_is_mode(wl, NL80211_IFTYPE_ADHOC))
4150c572
JB		 2887 ctl &= ~B43_MACCTL_INFRA;
2888
2889 if (wl->filter_flags & FIF_CONTROL)
e4d6b795 2890 ctl |= B43_MACCTL_KEEP_CTL;
4150c572
JB		 2891 if (wl->filter_flags & FIF_FCSFAIL)
2892 ctl |= B43_MACCTL_KEEP_BAD;
2893 if (wl->filter_flags & FIF_PLCPFAIL)
2894 ctl |= B43_MACCTL_KEEP_BADPLCP;
2895 if (wl->filter_flags & FIF_PROMISC_IN_BSS)
e4d6b795 2896 ctl |= B43_MACCTL_PROMISC;
4150c572
JB		 2897 if (wl->filter_flags & FIF_BCN_PRBRESP_PROMISC)
2898 ctl |= B43_MACCTL_BEACPROMISC;
2899
e4d6b795
MB		 2900 /* Workaround: On old hardware the HW-MAC-address-filter
2901 * doesn't work properly, so always run promisc in filter
2902 * it in software. */
21d889d4 2903 if (dev->dev->core_rev <= 4)
e4d6b795
MB		 2904 ctl |= B43_MACCTL_PROMISC;
2905
2906 b43_write32(dev, B43_MMIO_MACCTL, ctl);
2907
2908 cfp_pretbtt = 2;
2909 if ((ctl & B43_MACCTL_INFRA) && !(ctl & B43_MACCTL_AP)) {
c244e08c
RM		 2910 if (dev->dev->chip_id == 0x4306 &&
2911 dev->dev->chip_rev == 3)
e4d6b795
MB		 2912 cfp_pretbtt = 100;
2913 else
2914 cfp_pretbtt = 50;
2915 }
2916 b43_write16(dev, 0x612, cfp_pretbtt);
09ebe2f9
MB		 2917
2918 /* FIXME: We don't currently implement the PMQ mechanism,
2919 * so always disable it. If we want to implement PMQ,
2920 * we need to enable it here (clear DISCPMQ) in AP mode.
2921 */
2922 if (0 /* ctl & B43_MACCTL_AP */) {
2923 b43_write32(dev, B43_MMIO_MACCTL,
2924 b43_read32(dev, B43_MMIO_MACCTL)
2925 & ~B43_MACCTL_DISCPMQ);
2926 } else {
2927 b43_write32(dev, B43_MMIO_MACCTL,
2928 b43_read32(dev, B43_MMIO_MACCTL)
2929 | B43_MACCTL_DISCPMQ);
2930 }
e4d6b795
MB		 2931}
2932
2933static void b43_rate_memory_write(struct b43_wldev *dev, u16 rate, int is_ofdm)
2934{
2935 u16 offset;
2936
2937 if (is_ofdm) {
2938 offset = 0x480;
2939 offset += (b43_plcp_get_ratecode_ofdm(rate) & 0x000F) * 2;
2940 } else {
2941 offset = 0x4C0;
2942 offset += (b43_plcp_get_ratecode_cck(rate) & 0x000F) * 2;
2943 }
2944 b43_shm_write16(dev, B43_SHM_SHARED, offset + 0x20,
2945 b43_shm_read16(dev, B43_SHM_SHARED, offset));
2946}
2947
2948static void b43_rate_memory_init(struct b43_wldev *dev)
2949{
2950 switch (dev->phy.type) {
2951 case B43_PHYTYPE_A:
2952 case B43_PHYTYPE_G:
53a6e234 2953 case B43_PHYTYPE_N:
9d86a2d5 2954 case B43_PHYTYPE_LP:
6a461c23 2955 case B43_PHYTYPE_HT:
0b4ff45d 2956 case B43_PHYTYPE_LCN:
e4d6b795
MB		 2957 b43_rate_memory_write(dev, B43_OFDM_RATE_6MB, 1);
2958 b43_rate_memory_write(dev, B43_OFDM_RATE_12MB, 1);
2959 b43_rate_memory_write(dev, B43_OFDM_RATE_18MB, 1);
2960 b43_rate_memory_write(dev, B43_OFDM_RATE_24MB, 1);
2961 b43_rate_memory_write(dev, B43_OFDM_RATE_36MB, 1);
2962 b43_rate_memory_write(dev, B43_OFDM_RATE_48MB, 1);
2963 b43_rate_memory_write(dev, B43_OFDM_RATE_54MB, 1);
2964 if (dev->phy.type == B43_PHYTYPE_A)
2965 break;
2966 /* fallthrough */
2967 case B43_PHYTYPE_B:
2968 b43_rate_memory_write(dev, B43_CCK_RATE_1MB, 0);
2969 b43_rate_memory_write(dev, B43_CCK_RATE_2MB, 0);
2970 b43_rate_memory_write(dev, B43_CCK_RATE_5MB, 0);
2971 b43_rate_memory_write(dev, B43_CCK_RATE_11MB, 0);
2972 break;
2973 default:
2974 B43_WARN_ON(1);
2975 }
2976}
2977
5042c507
MB		 2978/* Set the default values for the PHY TX Control Words. */
2979static void b43_set_phytxctl_defaults(struct b43_wldev *dev)
2980{
2981 u16 ctl = 0;
2982
2983 ctl |= B43_TXH_PHY_ENC_CCK;
2984 ctl |= B43_TXH_PHY_ANT01AUTO;
2985 ctl |= B43_TXH_PHY_TXPWR;
2986
2987 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_BEACPHYCTL, ctl);
2988 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_ACKCTSPHYCTL, ctl);
2989 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_PRPHYCTL, ctl);
2990}
2991
e4d6b795
MB		 2992/* Set the TX-Antenna for management frames sent by firmware. */
2993static void b43_mgmtframe_txantenna(struct b43_wldev *dev, int antenna)
2994{
5042c507 2995 u16 ant;
e4d6b795
MB		 2996 u16 tmp;
2997
5042c507 2998 ant = b43_antenna_to_phyctl(antenna);
e4d6b795 2999
e4d6b795
MB		 3000 /* For ACK/CTS */
3001 tmp = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_ACKCTSPHYCTL);
eb189d8b 3002 tmp = (tmp & ~B43_TXH_PHY_ANT) | ant;
e4d6b795
MB		 3003 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_ACKCTSPHYCTL, tmp);
3004 /* For Probe Resposes */
3005 tmp = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_PRPHYCTL);
eb189d8b 3006 tmp = (tmp & ~B43_TXH_PHY_ANT) | ant;
e4d6b795
MB		 3007 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_PRPHYCTL, tmp);
3008}
3009
3010/* This is the opposite of b43_chip_init() */
3011static void b43_chip_exit(struct b43_wldev *dev)
3012{
fb11137a 3013 b43_phy_exit(dev);
e4d6b795
MB		 3014 b43_gpio_cleanup(dev);
3015 /* firmware is released later */
3016}
3017
3018/* Initialize the chip
3019 * http://bcm-specs.sipsolutions.net/ChipInit
3020 */
3021static int b43_chip_init(struct b43_wldev *dev)
3022{
3023 struct b43_phy *phy = &dev->phy;
ef1a628d 3024 int err;
858a1652 3025 u32 macctl;
e4d6b795
MB		 3026 u16 value16;
3027
1f7d87b0
MB		 3028 /* Initialize the MAC control */
3029 macctl = B43_MACCTL_IHR_ENABLED | B43_MACCTL_SHM_ENABLED;
3030 if (dev->phy.gmode)
3031 macctl |= B43_MACCTL_GMODE;
3032 macctl |= B43_MACCTL_INFRA;
3033 b43_write32(dev, B43_MMIO_MACCTL, macctl);
e4d6b795
MB		 3034
3035 err = b43_request_firmware(dev);
3036 if (err)
3037 goto out;
3038 err = b43_upload_microcode(dev);
3039 if (err)
3040 goto out; /* firmware is released later */
3041
3042 err = b43_gpio_init(dev);
3043 if (err)
3044 goto out; /* firmware is released later */
21954c36 3045
e4d6b795
MB		 3046 err = b43_upload_initvals(dev);
3047 if (err)
1a8d1227 3048 goto err_gpio_clean;
e4d6b795 3049
0b7dcd96
MB		 3050 /* Turn the Analog on and initialize the PHY. */
3051 phy->ops->switch_analog(dev, 1);
e4d6b795
MB		 3052 err = b43_phy_init(dev);
3053 if (err)
ef1a628d 3054 goto err_gpio_clean;
e4d6b795 3055
ef1a628d
MB		 3056 /* Disable Interference Mitigation. */
3057 if (phy->ops->interf_mitigation)
3058 phy->ops->interf_mitigation(dev, B43_INTERFMODE_NONE);
e4d6b795 3059
ef1a628d
MB		 3060 /* Select the antennae */
3061 if (phy->ops->set_rx_antenna)
3062 phy->ops->set_rx_antenna(dev, B43_ANTENNA_DEFAULT);
e4d6b795
MB		 3063 b43_mgmtframe_txantenna(dev, B43_ANTENNA_DEFAULT);
3064
3065 if (phy->type == B43_PHYTYPE_B) {
3066 value16 = b43_read16(dev, 0x005E);
3067 value16 |= 0x0004;
3068 b43_write16(dev, 0x005E, value16);
3069 }
3070 b43_write32(dev, 0x0100, 0x01000000);
21d889d4 3071 if (dev->dev->core_rev < 5)
e4d6b795
MB		 3072 b43_write32(dev, 0x010C, 0x01000000);
3073
3074 b43_write32(dev, B43_MMIO_MACCTL, b43_read32(dev, B43_MMIO_MACCTL)
3075 & ~B43_MACCTL_INFRA);
3076 b43_write32(dev, B43_MMIO_MACCTL, b43_read32(dev, B43_MMIO_MACCTL)
3077 | B43_MACCTL_INFRA);
e4d6b795 3078
e4d6b795
MB		 3079 /* Probe Response Timeout value */
3080 /* FIXME: Default to 0, has to be set by ioctl probably... :-/ */
3081 b43_shm_write16(dev, B43_SHM_SHARED, 0x0074, 0x0000);
3082
3083 /* Initially set the wireless operation mode. */
3084 b43_adjust_opmode(dev);
3085
21d889d4 3086 if (dev->dev->core_rev < 3) {
e4d6b795
MB		 3087 b43_write16(dev, 0x060E, 0x0000);
3088 b43_write16(dev, 0x0610, 0x8000);
3089 b43_write16(dev, 0x0604, 0x0000);
3090 b43_write16(dev, 0x0606, 0x0200);
3091 } else {
3092 b43_write32(dev, 0x0188, 0x80000000);
3093 b43_write32(dev, 0x018C, 0x02000000);
3094 }
3095 b43_write32(dev, B43_MMIO_GEN_IRQ_REASON, 0x00004000);
3096 b43_write32(dev, B43_MMIO_DMA0_IRQ_MASK, 0x0001DC00);
3097 b43_write32(dev, B43_MMIO_DMA1_IRQ_MASK, 0x0000DC00);
3098 b43_write32(dev, B43_MMIO_DMA2_IRQ_MASK, 0x0000DC00);
3099 b43_write32(dev, B43_MMIO_DMA3_IRQ_MASK, 0x0001DC00);
3100 b43_write32(dev, B43_MMIO_DMA4_IRQ_MASK, 0x0000DC00);
3101 b43_write32(dev, B43_MMIO_DMA5_IRQ_MASK, 0x0000DC00);
3102
858a1652 3103 b43_mac_phy_clock_set(dev, true);
e4d6b795 3104
6cbab0d9 3105 switch (dev->dev->bus_type) {
42c9a458
RM		 3106#ifdef CONFIG_B43_BCMA
3107 case B43_BUS_BCMA:
3108 /* FIXME: 0xE74 is quite common, but should be read from CC */
3109 b43_write16(dev, B43_MMIO_POWERUP_DELAY, 0xE74);
3110 break;
3111#endif
6cbab0d9
RM		 3112#ifdef CONFIG_B43_SSB
3113 case B43_BUS_SSB:
3114 b43_write16(dev, B43_MMIO_POWERUP_DELAY,
3115 dev->dev->sdev->bus->chipco.fast_pwrup_delay);
3116 break;
3117#endif
3118 }
e4d6b795
MB		 3119
3120 err = 0;
3121 b43dbg(dev->wl, "Chip initialized\n");
21954c36 3122out:
e4d6b795
MB		 3123 return err;
3124
1a8d1227 3125err_gpio_clean:
e4d6b795 3126 b43_gpio_cleanup(dev);
21954c36 3127 return err;
e4d6b795
MB		 3128}
3129
e4d6b795
MB		 3130static void b43_periodic_every60sec(struct b43_wldev *dev)
3131{
ef1a628d 3132 const struct b43_phy_operations *ops = dev->phy.ops;
e4d6b795 3133
ef1a628d
MB		 3134 if (ops->pwork_60sec)
3135 ops->pwork_60sec(dev);
18c8adeb
MB		 3136
3137 /* Force check the TX power emission now. */
3138 b43_phy_txpower_check(dev, B43_TXPWR_IGNORE_TIME);
e4d6b795
MB		 3139}
3140
3141static void b43_periodic_every30sec(struct b43_wldev *dev)
3142{
3143 /* Update device statistics. */
3144 b43_calculate_link_quality(dev);
3145}
3146
3147static void b43_periodic_every15sec(struct b43_wldev *dev)
3148{
3149 struct b43_phy *phy = &dev->phy;
9b839a74
MB		 3150 u16 wdr;
3151
3152 if (dev->fw.opensource) {
3153 /* Check if the firmware is still alive.
3154 * It will reset the watchdog counter to 0 in its idle loop. */
3155 wdr = b43_shm_read16(dev, B43_SHM_SCRATCH, B43_WATCHDOG_REG);
3156 if (unlikely(wdr)) {
3157 b43err(dev->wl, "Firmware watchdog: The firmware died!\n");
3158 b43_controller_restart(dev, "Firmware watchdog");
3159 return;
3160 } else {
3161 b43_shm_write16(dev, B43_SHM_SCRATCH,
3162 B43_WATCHDOG_REG, 1);
3163 }
3164 }
e4d6b795 3165
ef1a628d
MB		 3166 if (phy->ops->pwork_15sec)
3167 phy->ops->pwork_15sec(dev);
3168
00e0b8cb
SB		 3169 atomic_set(&phy->txerr_cnt, B43_PHY_TX_BADNESS_LIMIT);
3170 wmb();
990b86f4
MB		 3171
3172#if B43_DEBUG
3173 if (b43_debug(dev, B43_DBG_VERBOSESTATS)) {
3174 unsigned int i;
3175
3176 b43dbg(dev->wl, "Stats: %7u IRQs/sec, %7u TX/sec, %7u RX/sec\n",
3177 dev->irq_count / 15,
3178 dev->tx_count / 15,
3179 dev->rx_count / 15);
3180 dev->irq_count = 0;
3181 dev->tx_count = 0;
3182 dev->rx_count = 0;
3183 for (i = 0; i < ARRAY_SIZE(dev->irq_bit_count); i++) {
3184 if (dev->irq_bit_count[i]) {
3185 b43dbg(dev->wl, "Stats: %7u IRQ-%02u/sec (0x%08X)\n",
3186 dev->irq_bit_count[i] / 15, i, (1 << i));
3187 dev->irq_bit_count[i] = 0;
3188 }
3189 }
3190 }
3191#endif
e4d6b795
MB		 3192}
3193
e4d6b795
MB		 3194static void do_periodic_work(struct b43_wldev *dev)
3195{
3196 unsigned int state;
3197
3198 state = dev->periodic_state;
42bb4cd5 3199 if (state % 4 == 0)
e4d6b795 3200 b43_periodic_every60sec(dev);
42bb4cd5 3201 if (state % 2 == 0)
e4d6b795 3202 b43_periodic_every30sec(dev);
42bb4cd5 3203 b43_periodic_every15sec(dev);
e4d6b795
MB		 3204}
3205
05b64b36
MB		 3206/* Periodic work locking policy:
3207 * The whole periodic work handler is protected by
3208 * wl->mutex. If another lock is needed somewhere in the
21ae2956 3209 * pwork callchain, it's acquired in-place, where it's needed.
e4d6b795 3210 */
e4d6b795
MB		 3211static void b43_periodic_work_handler(struct work_struct *work)
3212{
05b64b36
MB		 3213 struct b43_wldev *dev = container_of(work, struct b43_wldev,
3214 periodic_work.work);
3215 struct b43_wl *wl = dev->wl;
3216 unsigned long delay;
e4d6b795 3217
05b64b36 3218 mutex_lock(&wl->mutex);
e4d6b795
MB		 3219
3220 if (unlikely(b43_status(dev) != B43_STAT_STARTED))
3221 goto out;
3222 if (b43_debug(dev, B43_DBG_PWORK_STOP))
3223 goto out_requeue;
3224
05b64b36 3225 do_periodic_work(dev);
e4d6b795 3226
e4d6b795 3227 dev->periodic_state++;
42bb4cd5 3228out_requeue:
e4d6b795
MB		 3229 if (b43_debug(dev, B43_DBG_PWORK_FAST))
3230 delay = msecs_to_jiffies(50);
3231 else
82cd682d 3232 delay = round_jiffies_relative(HZ * 15);
42935eca 3233 ieee80211_queue_delayed_work(wl->hw, &dev->periodic_work, delay);
42bb4cd5 3234out:
05b64b36 3235 mutex_unlock(&wl->mutex);
e4d6b795
MB		 3236}
3237
3238static void b43_periodic_tasks_setup(struct b43_wldev *dev)
3239{
3240 struct delayed_work *work = &dev->periodic_work;
3241
3242 dev->periodic_state = 0;
3243 INIT_DELAYED_WORK(work, b43_periodic_work_handler);
42935eca 3244 ieee80211_queue_delayed_work(dev->wl->hw, work, 0);
e4d6b795
MB		 3245}
3246
f3dd3fcc 3247/* Check if communication with the device works correctly. */
e4d6b795
MB		 3248static int b43_validate_chipaccess(struct b43_wldev *dev)
3249{
f62ae6cd 3250 u32 v, backup0, backup4;
e4d6b795 3251
f62ae6cd
MB		 3252 backup0 = b43_shm_read32(dev, B43_SHM_SHARED, 0);
3253 backup4 = b43_shm_read32(dev, B43_SHM_SHARED, 4);
f3dd3fcc
MB		 3254
3255 /* Check for read/write and endianness problems. */
e4d6b795
MB		 3256 b43_shm_write32(dev, B43_SHM_SHARED, 0, 0x55AAAA55);
3257 if (b43_shm_read32(dev, B43_SHM_SHARED, 0) != 0x55AAAA55)
3258 goto error;
f3dd3fcc
MB		 3259 b43_shm_write32(dev, B43_SHM_SHARED, 0, 0xAA5555AA);
3260 if (b43_shm_read32(dev, B43_SHM_SHARED, 0) != 0xAA5555AA)
e4d6b795
MB		 3261 goto error;
3262
f62ae6cd
MB		 3263 /* Check if unaligned 32bit SHM_SHARED access works properly.
3264 * However, don't bail out on failure, because it's noncritical. */
3265 b43_shm_write16(dev, B43_SHM_SHARED, 0, 0x1122);
3266 b43_shm_write16(dev, B43_SHM_SHARED, 2, 0x3344);
3267 b43_shm_write16(dev, B43_SHM_SHARED, 4, 0x5566);
3268 b43_shm_write16(dev, B43_SHM_SHARED, 6, 0x7788);
3269 if (b43_shm_read32(dev, B43_SHM_SHARED, 2) != 0x55663344)
3270 b43warn(dev->wl, "Unaligned 32bit SHM read access is broken\n");
3271 b43_shm_write32(dev, B43_SHM_SHARED, 2, 0xAABBCCDD);
3272 if (b43_shm_read16(dev, B43_SHM_SHARED, 0) != 0x1122 ||
3273 b43_shm_read16(dev, B43_SHM_SHARED, 2) != 0xCCDD ||
3274 b43_shm_read16(dev, B43_SHM_SHARED, 4) != 0xAABB ||
3275 b43_shm_read16(dev, B43_SHM_SHARED, 6) != 0x7788)
3276 b43warn(dev->wl, "Unaligned 32bit SHM write access is broken\n");
3277
3278 b43_shm_write32(dev, B43_SHM_SHARED, 0, backup0);
3279 b43_shm_write32(dev, B43_SHM_SHARED, 4, backup4);
f3dd3fcc 3280
21d889d4 3281 if ((dev->dev->core_rev >= 3) && (dev->dev->core_rev <= 10)) {
f3dd3fcc
MB		 3282 /* The 32bit register shadows the two 16bit registers
3283 * with update sideeffects. Validate this. */
3284 b43_write16(dev, B43_MMIO_TSF_CFP_START, 0xAAAA);
3285 b43_write32(dev, B43_MMIO_TSF_CFP_START, 0xCCCCBBBB);
3286 if (b43_read16(dev, B43_MMIO_TSF_CFP_START_LOW) != 0xBBBB)
3287 goto error;
3288 if (b43_read16(dev, B43_MMIO_TSF_CFP_START_HIGH) != 0xCCCC)
3289 goto error;
3290 }
3291 b43_write32(dev, B43_MMIO_TSF_CFP_START, 0);
3292
3293 v = b43_read32(dev, B43_MMIO_MACCTL);
3294 v |= B43_MACCTL_GMODE;
3295 if (v != (B43_MACCTL_GMODE | B43_MACCTL_IHR_ENABLED))
e4d6b795
MB		 3296 goto error;
3297
3298 return 0;
f3dd3fcc 3299error:
e4d6b795
MB		 3300 b43err(dev->wl, "Failed to validate the chipaccess\n");
3301 return -ENODEV;
3302}
3303
3304static void b43_security_init(struct b43_wldev *dev)
3305{
e4d6b795
MB		 3306 dev->ktp = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_KTP);
3307 /* KTP is a word address, but we address SHM bytewise.
3308 * So multiply by two.
3309 */
3310 dev->ktp *= 2;
66d2d089
MB		 3311 /* Number of RCMTA address slots */
3312 b43_write16(dev, B43_MMIO_RCMTA_COUNT, B43_NR_PAIRWISE_KEYS);
3313 /* Clear the key memory. */
e4d6b795
MB		 3314 b43_clear_keys(dev);
3315}
3316
616de35d 3317#ifdef CONFIG_B43_HWRNG
99da185a 3318static int b43_rng_read(struct hwrng *rng, u32 *data)
e4d6b795
MB		 3319{
3320 struct b43_wl *wl = (struct b43_wl *)rng->priv;
a78b3bb2
MB		 3321 struct b43_wldev *dev;
3322 int count = -ENODEV;
e4d6b795 3323
a78b3bb2
MB		 3324 mutex_lock(&wl->mutex);
3325 dev = wl->current_dev;
3326 if (likely(dev && b43_status(dev) >= B43_STAT_INITIALIZED)) {
3327 *data = b43_read16(dev, B43_MMIO_RNG);
3328 count = sizeof(u16);
3329 }
3330 mutex_unlock(&wl->mutex);
e4d6b795 3331
a78b3bb2 3332 return count;
e4d6b795 3333}
616de35d 3334#endif /* CONFIG_B43_HWRNG */
e4d6b795 3335
b844eba2 3336static void b43_rng_exit(struct b43_wl *wl)
e4d6b795 3337{
616de35d 3338#ifdef CONFIG_B43_HWRNG
e4d6b795 3339 if (wl->rng_initialized)
b844eba2 3340 hwrng_unregister(&wl->rng);
616de35d 3341#endif /* CONFIG_B43_HWRNG */
e4d6b795
MB		 3342}
3343
3344static int b43_rng_init(struct b43_wl *wl)
3345{
616de35d 3346 int err = 0;
e4d6b795 3347
616de35d 3348#ifdef CONFIG_B43_HWRNG
e4d6b795
MB		 3349 snprintf(wl->rng_name, ARRAY_SIZE(wl->rng_name),
3350 "%s_%s", KBUILD_MODNAME, wiphy_name(wl->hw->wiphy));
3351 wl->rng.name = wl->rng_name;
3352 wl->rng.data_read = b43_rng_read;
3353 wl->rng.priv = (unsigned long)wl;
3354 wl->rng_initialized = 1;
3355 err = hwrng_register(&wl->rng);
3356 if (err) {
3357 wl->rng_initialized = 0;
3358 b43err(wl, "Failed to register the random "
3359 "number generator (%d)\n", err);
3360 }
616de35d 3361#endif /* CONFIG_B43_HWRNG */
e4d6b795
MB		 3362
3363 return err;
3364}
3365
f5d40eed 3366static void b43_tx_work(struct work_struct *work)
e4d6b795 3367{
f5d40eed
MB		 3368 struct b43_wl *wl = container_of(work, struct b43_wl, tx_work);
3369 struct b43_wldev *dev;
3370 struct sk_buff *skb;
3371 int err = 0;
e4d6b795 3372
f5d40eed
MB		 3373 mutex_lock(&wl->mutex);
3374 dev = wl->current_dev;
3375 if (unlikely(!dev || b43_status(dev) < B43_STAT_STARTED)) {
3376 mutex_unlock(&wl->mutex);
3377 return;
5100d5ac 3378 }
21a75d77 3379
f5d40eed
MB		 3380 while (skb_queue_len(&wl->tx_queue)) {
3381 skb = skb_dequeue(&wl->tx_queue);
21a75d77 3382
21a75d77 3383 if (b43_using_pio_transfers(dev))
e039fa4a 3384 err = b43_pio_tx(dev, skb);
21a75d77 3385 else
e039fa4a 3386 err = b43_dma_tx(dev, skb);
f5d40eed
MB		 3387 if (unlikely(err))
3388 dev_kfree_skb(skb); /* Drop it */
21a75d77
MB		 3389 }
3390
990b86f4
MB		 3391#if B43_DEBUG
3392 dev->tx_count++;
3393#endif
f5d40eed
MB		 3394 mutex_unlock(&wl->mutex);
3395}
21a75d77 3396
7bb45683 3397static void b43_op_tx(struct ieee80211_hw *hw,
f5d40eed
MB		 3398 struct sk_buff *skb)
3399{
3400 struct b43_wl *wl = hw_to_b43_wl(hw);
3401
3402 if (unlikely(skb->len < 2 + 2 + 6)) {
3403 /* Too short, this can't be a valid frame. */
3404 dev_kfree_skb_any(skb);
7bb45683 3405 return;
f5d40eed
MB		 3406 }
3407 B43_WARN_ON(skb_shinfo(skb)->nr_frags);
3408
3409 skb_queue_tail(&wl->tx_queue, skb);
3410 ieee80211_queue_work(wl->hw, &wl->tx_work);
e4d6b795
MB		 3411}
3412
e6f5b934
MB		 3413static void b43_qos_params_upload(struct b43_wldev *dev,
3414 const struct ieee80211_tx_queue_params *p,
3415 u16 shm_offset)
3416{
3417 u16 params[B43_NR_QOSPARAMS];
0b57664c 3418 int bslots, tmp;
e6f5b934
MB		 3419 unsigned int i;
3420
b0544eb6
MB		 3421 if (!dev->qos_enabled)
3422 return;
3423
0b57664c 3424 bslots = b43_read16(dev, B43_MMIO_RNG) & p->cw_min;
e6f5b934
MB		 3425
3426 memset(&params, 0, sizeof(params));
3427
3428 params[B43_QOSPARAM_TXOP] = p->txop * 32;
0b57664c
JB		 3429 params[B43_QOSPARAM_CWMIN] = p->cw_min;
3430 params[B43_QOSPARAM_CWMAX] = p->cw_max;
3431 params[B43_QOSPARAM_CWCUR] = p->cw_min;
3432 params[B43_QOSPARAM_AIFS] = p->aifs;
e6f5b934 3433 params[B43_QOSPARAM_BSLOTS] = bslots;
0b57664c 3434 params[B43_QOSPARAM_REGGAP] = bslots + p->aifs;
e6f5b934
MB		 3435
3436 for (i = 0; i < ARRAY_SIZE(params); i++) {
3437 if (i == B43_QOSPARAM_STATUS) {
3438 tmp = b43_shm_read16(dev, B43_SHM_SHARED,
3439 shm_offset + (i * 2));
3440 /* Mark the parameters as updated. */
3441 tmp |= 0x100;
3442 b43_shm_write16(dev, B43_SHM_SHARED,
3443 shm_offset + (i * 2),
3444 tmp);
3445 } else {
3446 b43_shm_write16(dev, B43_SHM_SHARED,
3447 shm_offset + (i * 2),
3448 params[i]);
3449 }
3450 }
3451}
3452
c40c1129
MB		 3453/* Mapping of mac80211 queue numbers to b43 QoS SHM offsets. */
3454static const u16 b43_qos_shm_offsets[] = {
3455 /* [mac80211-queue-nr] = SHM_OFFSET, */
3456 [0] = B43_QOS_VOICE,
3457 [1] = B43_QOS_VIDEO,
3458 [2] = B43_QOS_BESTEFFORT,
3459 [3] = B43_QOS_BACKGROUND,
3460};
3461
5a5f3b40
MB		 3462/* Update all QOS parameters in hardware. */
3463static void b43_qos_upload_all(struct b43_wldev *dev)
e6f5b934
MB		 3464{
3465 struct b43_wl *wl = dev->wl;
3466 struct b43_qos_params *params;
e6f5b934
MB		 3467 unsigned int i;
3468
b0544eb6
MB		 3469 if (!dev->qos_enabled)
3470 return;
3471
c40c1129
MB		 3472 BUILD_BUG_ON(ARRAY_SIZE(b43_qos_shm_offsets) !=
3473 ARRAY_SIZE(wl->qos_params));
e6f5b934
MB		 3474
3475 b43_mac_suspend(dev);
e6f5b934
MB		 3476 for (i = 0; i < ARRAY_SIZE(wl->qos_params); i++) {
3477 params = &(wl->qos_params[i]);
5a5f3b40
MB		 3478 b43_qos_params_upload(dev, &(params->p),
3479 b43_qos_shm_offsets[i]);
e6f5b934 3480 }
e6f5b934
MB		 3481 b43_mac_enable(dev);
3482}
3483
3484static void b43_qos_clear(struct b43_wl *wl)
3485{
3486 struct b43_qos_params *params;
3487 unsigned int i;
3488
c40c1129
MB		 3489 /* Initialize QoS parameters to sane defaults. */
3490
3491 BUILD_BUG_ON(ARRAY_SIZE(b43_qos_shm_offsets) !=
3492 ARRAY_SIZE(wl->qos_params));
3493
e6f5b934
MB		 3494 for (i = 0; i < ARRAY_SIZE(wl->qos_params); i++) {
3495 params = &(wl->qos_params[i]);
3496
c40c1129
MB		 3497 switch (b43_qos_shm_offsets[i]) {
3498 case B43_QOS_VOICE:
3499 params->p.txop = 0;
3500 params->p.aifs = 2;
3501 params->p.cw_min = 0x0001;
3502 params->p.cw_max = 0x0001;
3503 break;
3504 case B43_QOS_VIDEO:
3505 params->p.txop = 0;
3506 params->p.aifs = 2;
3507 params->p.cw_min = 0x0001;
3508 params->p.cw_max = 0x0001;
3509 break;
3510 case B43_QOS_BESTEFFORT:
3511 params->p.txop = 0;
3512 params->p.aifs = 3;
3513 params->p.cw_min = 0x0001;
3514 params->p.cw_max = 0x03FF;
3515 break;
3516 case B43_QOS_BACKGROUND:
3517 params->p.txop = 0;
3518 params->p.aifs = 7;
3519 params->p.cw_min = 0x0001;
3520 params->p.cw_max = 0x03FF;
3521 break;
3522 default:
3523 B43_WARN_ON(1);
3524 }
e6f5b934
MB		 3525 }
3526}
3527
3528/* Initialize the core's QOS capabilities */
3529static void b43_qos_init(struct b43_wldev *dev)
3530{
b0544eb6
MB		 3531 if (!dev->qos_enabled) {
3532 /* Disable QOS support. */
3533 b43_hf_write(dev, b43_hf_read(dev) & ~B43_HF_EDCF);
3534 b43_write16(dev, B43_MMIO_IFSCTL,
3535 b43_read16(dev, B43_MMIO_IFSCTL)
3536 & ~B43_MMIO_IFSCTL_USE_EDCF);
3537 b43dbg(dev->wl, "QoS disabled\n");
3538 return;
3539 }
3540
e6f5b934 3541 /* Upload the current QOS parameters. */
5a5f3b40 3542 b43_qos_upload_all(dev);
e6f5b934
MB		 3543
3544 /* Enable QOS support. */
3545 b43_hf_write(dev, b43_hf_read(dev) | B43_HF_EDCF);
3546 b43_write16(dev, B43_MMIO_IFSCTL,
3547 b43_read16(dev, B43_MMIO_IFSCTL)
3548 | B43_MMIO_IFSCTL_USE_EDCF);
b0544eb6 3549 b43dbg(dev->wl, "QoS enabled\n");
e6f5b934
MB		 3550}
3551
e100bb64 3552static int b43_op_conf_tx(struct ieee80211_hw *hw, u16 _queue,
40faacc4 3553 const struct ieee80211_tx_queue_params *params)
e4d6b795 3554{
e6f5b934 3555 struct b43_wl *wl = hw_to_b43_wl(hw);
5a5f3b40 3556 struct b43_wldev *dev;
e6f5b934 3557 unsigned int queue = (unsigned int)_queue;
5a5f3b40 3558 int err = -ENODEV;
e6f5b934
MB		 3559
3560 if (queue >= ARRAY_SIZE(wl->qos_params)) {
3561 /* Queue not available or don't support setting
3562 * params on this queue. Return success to not
3563 * confuse mac80211. */
3564 return 0;
3565 }
5a5f3b40
MB		 3566 BUILD_BUG_ON(ARRAY_SIZE(b43_qos_shm_offsets) !=
3567 ARRAY_SIZE(wl->qos_params));
e6f5b934 3568
5a5f3b40
MB		 3569 mutex_lock(&wl->mutex);
3570 dev = wl->current_dev;
3571 if (unlikely(!dev || (b43_status(dev) < B43_STAT_INITIALIZED)))
3572 goto out_unlock;
e6f5b934 3573
5a5f3b40
MB		 3574 memcpy(&(wl->qos_params[queue].p), params, sizeof(*params));
3575 b43_mac_suspend(dev);
3576 b43_qos_params_upload(dev, &(wl->qos_params[queue].p),
3577 b43_qos_shm_offsets[queue]);
3578 b43_mac_enable(dev);
3579 err = 0;
e6f5b934 3580
5a5f3b40
MB		 3581out_unlock:
3582 mutex_unlock(&wl->mutex);
3583
3584 return err;
e4d6b795
MB		 3585}
3586
40faacc4
MB		 3587static int b43_op_get_stats(struct ieee80211_hw *hw,
3588 struct ieee80211_low_level_stats *stats)
e4d6b795
MB		 3589{
3590 struct b43_wl *wl = hw_to_b43_wl(hw);
e4d6b795 3591
36dbd954 3592 mutex_lock(&wl->mutex);
e4d6b795 3593 memcpy(stats, &wl->ieee_stats, sizeof(*stats));
36dbd954 3594 mutex_unlock(&wl->mutex);
e4d6b795
MB		 3595
3596 return 0;
3597}
3598
08e87a83
AF		 3599static u64 b43_op_get_tsf(struct ieee80211_hw *hw)
3600{
3601 struct b43_wl *wl = hw_to_b43_wl(hw);
3602 struct b43_wldev *dev;
3603 u64 tsf;
3604
3605 mutex_lock(&wl->mutex);
08e87a83
AF		 3606 dev = wl->current_dev;
3607
3608 if (dev && (b43_status(dev) >= B43_STAT_INITIALIZED))
3609 b43_tsf_read(dev, &tsf);
3610 else
3611 tsf = 0;
3612
08e87a83
AF		 3613 mutex_unlock(&wl->mutex);
3614
3615 return tsf;
3616}
3617
3618static void b43_op_set_tsf(struct ieee80211_hw *hw, u64 tsf)
3619{
3620 struct b43_wl *wl = hw_to_b43_wl(hw);
3621 struct b43_wldev *dev;
3622
3623 mutex_lock(&wl->mutex);
08e87a83
AF		 3624 dev = wl->current_dev;
3625
3626 if (dev && (b43_status(dev) >= B43_STAT_INITIALIZED))
3627 b43_tsf_write(dev, tsf);
3628
08e87a83
AF		 3629 mutex_unlock(&wl->mutex);
3630}
3631
e4d6b795
MB		 3632static void b43_put_phy_into_reset(struct b43_wldev *dev)
3633{
6cbab0d9 3634 u32 tmp;
e4d6b795 3635
6cbab0d9 3636 switch (dev->dev->bus_type) {
42c9a458
RM		 3637#ifdef CONFIG_B43_BCMA
3638 case B43_BUS_BCMA:
3639 b43err(dev->wl,
3640 "Putting PHY into reset not supported on BCMA\n");
3641 break;
3642#endif
6cbab0d9
RM		 3643#ifdef CONFIG_B43_SSB
3644 case B43_BUS_SSB:
3645 tmp = ssb_read32(dev->dev->sdev, SSB_TMSLOW);
3646 tmp &= ~B43_TMSLOW_GMODE;
3647 tmp |= B43_TMSLOW_PHYRESET;
3648 tmp |= SSB_TMSLOW_FGC;
3649 ssb_write32(dev->dev->sdev, SSB_TMSLOW, tmp);
3650 msleep(1);
3651
3652 tmp = ssb_read32(dev->dev->sdev, SSB_TMSLOW);
3653 tmp &= ~SSB_TMSLOW_FGC;
3654 tmp |= B43_TMSLOW_PHYRESET;
3655 ssb_write32(dev->dev->sdev, SSB_TMSLOW, tmp);
3656 msleep(1);
e4d6b795 3657
6cbab0d9
RM		 3658 break;
3659#endif
3660 }
e4d6b795
MB		 3661}
3662
99da185a 3663static const char *band_to_string(enum ieee80211_band band)
bb1eeff1
MB		 3664{
3665 switch (band) {
3666 case IEEE80211_BAND_5GHZ:
3667 return "5";
3668 case IEEE80211_BAND_2GHZ:
3669 return "2.4";
3670 default:
3671 break;
3672 }
3673 B43_WARN_ON(1);
3674 return "";
3675}
3676
e4d6b795 3677/* Expects wl->mutex locked */
bb1eeff1 3678static int b43_switch_band(struct b43_wl *wl, struct ieee80211_channel *chan)
e4d6b795 3679{
bb1eeff1 3680 struct b43_wldev *up_dev = NULL;
e4d6b795 3681 struct b43_wldev *down_dev;
bb1eeff1 3682 struct b43_wldev *d;
e4d6b795 3683 int err;
922d8a0b 3684 bool uninitialized_var(gmode);
e4d6b795
MB		 3685 int prev_status;
3686
bb1eeff1
MB		 3687 /* Find a device and PHY which supports the band. */
3688 list_for_each_entry(d, &wl->devlist, list) {
3689 switch (chan->band) {
3690 case IEEE80211_BAND_5GHZ:
3691 if (d->phy.supports_5ghz) {
3692 up_dev = d;
3693 gmode = 0;
3694 }
3695 break;
3696 case IEEE80211_BAND_2GHZ:
3697 if (d->phy.supports_2ghz) {
3698 up_dev = d;
3699 gmode = 1;
3700 }
3701 break;
3702 default:
3703 B43_WARN_ON(1);
3704 return -EINVAL;
3705 }
3706 if (up_dev)
3707 break;
3708 }
3709 if (!up_dev) {
3710 b43err(wl, "Could not find a device for %s-GHz band operation\n",
3711 band_to_string(chan->band));
3712 return -ENODEV;
e4d6b795
MB		 3713 }
3714 if ((up_dev == wl->current_dev) &&
3715 (!!wl->current_dev->phy.gmode == !!gmode)) {
3716 /* This device is already running. */
3717 return 0;
3718 }
bb1eeff1
MB		 3719 b43dbg(wl, "Switching to %s-GHz band\n",
3720 band_to_string(chan->band));
e4d6b795
MB		 3721 down_dev = wl->current_dev;
3722
3723 prev_status = b43_status(down_dev);
3724 /* Shutdown the currently running core. */
3725 if (prev_status >= B43_STAT_STARTED)
36dbd954 3726 down_dev = b43_wireless_core_stop(down_dev);
e4d6b795
MB		 3727 if (prev_status >= B43_STAT_INITIALIZED)
3728 b43_wireless_core_exit(down_dev);
3729
3730 if (down_dev != up_dev) {
3731 /* We switch to a different core, so we put PHY into
3732 * RESET on the old core. */
3733 b43_put_phy_into_reset(down_dev);
3734 }
3735
3736 /* Now start the new core. */
3737 up_dev->phy.gmode = gmode;
3738 if (prev_status >= B43_STAT_INITIALIZED) {
3739 err = b43_wireless_core_init(up_dev);
3740 if (err) {
3741 b43err(wl, "Fatal: Could not initialize device for "
bb1eeff1
MB		 3742 "selected %s-GHz band\n",
3743 band_to_string(chan->band));
e4d6b795
MB		 3744 goto init_failure;
3745 }
3746 }
3747 if (prev_status >= B43_STAT_STARTED) {
3748 err = b43_wireless_core_start(up_dev);
3749 if (err) {
3750 b43err(wl, "Fatal: Coult not start device for "
bb1eeff1
MB		 3751 "selected %s-GHz band\n",
3752 band_to_string(chan->band));
e4d6b795
MB		 3753 b43_wireless_core_exit(up_dev);
3754 goto init_failure;
3755 }
3756 }
3757 B43_WARN_ON(b43_status(up_dev) != prev_status);
3758
3759 wl->current_dev = up_dev;
3760
3761 return 0;
bb1eeff1 3762init_failure:
e4d6b795
MB		 3763 /* Whoops, failed to init the new core. No core is operating now. */
3764 wl->current_dev = NULL;
3765 return err;
3766}
3767
9124b077
JB		 3768/* Write the short and long frame retry limit values. */
3769static void b43_set_retry_limits(struct b43_wldev *dev,
3770 unsigned int short_retry,
3771 unsigned int long_retry)
3772{
3773 /* The retry limit is a 4-bit counter. Enforce this to avoid overflowing
3774 * the chip-internal counter. */
3775 short_retry = min(short_retry, (unsigned int)0xF);
3776 long_retry = min(long_retry, (unsigned int)0xF);
3777
3778 b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_SRLIMIT,
3779 short_retry);
3780 b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_LRLIMIT,
3781 long_retry);
3782}
3783
e8975581 3784static int b43_op_config(struct ieee80211_hw *hw, u32 changed)
e4d6b795
MB		 3785{
3786 struct b43_wl *wl = hw_to_b43_wl(hw);
3787 struct b43_wldev *dev;
3788 struct b43_phy *phy;
e8975581 3789 struct ieee80211_conf *conf = &hw->conf;
9db1f6d7 3790 int antenna;
e4d6b795 3791 int err = 0;
2a190322 3792 bool reload_bss = false;
e4d6b795 3793
e4d6b795
MB		 3794 mutex_lock(&wl->mutex);
3795
2a190322
FF		 3796 dev = wl->current_dev;
3797
bb1eeff1
MB		 3798 /* Switch the band (if necessary). This might change the active core. */
3799 err = b43_switch_band(wl, conf->channel);
e4d6b795
MB		 3800 if (err)
3801 goto out_unlock_mutex;
2a190322
FF		 3802
3803 /* Need to reload all settings if the core changed */
3804 if (dev != wl->current_dev) {
3805 dev = wl->current_dev;
3806 changed = ~0;
3807 reload_bss = true;
3808 }
3809
e4d6b795
MB		 3810 phy = &dev->phy;
3811
aa4c7b2a
RM		 3812 if (conf_is_ht(conf))
3813 phy->is_40mhz =
3814 (conf_is_ht40_minus(conf) || conf_is_ht40_plus(conf));
3815 else
3816 phy->is_40mhz = false;
3817
d10d0e57
MB		 3818 b43_mac_suspend(dev);
3819
9124b077
JB		 3820 if (changed & IEEE80211_CONF_CHANGE_RETRY_LIMITS)
3821 b43_set_retry_limits(dev, conf->short_frame_max_tx_count,
3822 conf->long_frame_max_tx_count);
3823 changed &= ~IEEE80211_CONF_CHANGE_RETRY_LIMITS;
3824 if (!changed)
d10d0e57 3825 goto out_mac_enable;
e4d6b795
MB		 3826
3827 /* Switch to the requested channel.
3828 * The firmware takes care of races with the TX handler. */
8318d78a 3829 if (conf->channel->hw_value != phy->channel)
ef1a628d 3830 b43_switch_channel(dev, conf->channel->hw_value);
e4d6b795 3831
0869aea0 3832 dev->wl->radiotap_enabled = !!(conf->flags & IEEE80211_CONF_MONITOR);
d42ce84a 3833
e4d6b795
MB		 3834 /* Adjust the desired TX power level. */
3835 if (conf->power_level != 0) {
18c8adeb
MB		 3836 if (conf->power_level != phy->desired_txpower) {
3837 phy->desired_txpower = conf->power_level;
3838 b43_phy_txpower_check(dev, B43_TXPWR_IGNORE_TIME |
3839 B43_TXPWR_IGNORE_TSSI);
e4d6b795
MB		 3840 }
3841 }
3842
3843 /* Antennas for RX and management frame TX. */
0f4ac38b 3844 antenna = B43_ANTENNA_DEFAULT;
9db1f6d7 3845 b43_mgmtframe_txantenna(dev, antenna);
0f4ac38b 3846 antenna = B43_ANTENNA_DEFAULT;
ef1a628d
MB		 3847 if (phy->ops->set_rx_antenna)
3848 phy->ops->set_rx_antenna(dev, antenna);
e4d6b795 3849
fd4973c5
LF		 3850 if (wl->radio_enabled != phy->radio_on) {
3851 if (wl->radio_enabled) {
19d337df 3852 b43_software_rfkill(dev, false);
fda9abcf
MB		 3853 b43info(dev->wl, "Radio turned on by software\n");
3854 if (!dev->radio_hw_enable) {
3855 b43info(dev->wl, "The hardware RF-kill button "
3856 "still turns the radio physically off. "
3857 "Press the button to turn it on.\n");
3858 }
3859 } else {
19d337df 3860 b43_software_rfkill(dev, true);
fda9abcf
MB		 3861 b43info(dev->wl, "Radio turned off by software\n");
3862 }
3863 }
3864
d10d0e57
MB		 3865out_mac_enable:
3866 b43_mac_enable(dev);
3867out_unlock_mutex:
e4d6b795
MB		 3868 mutex_unlock(&wl->mutex);
3869
2a190322
FF		 3870 if (wl->vif && reload_bss)
3871 b43_op_bss_info_changed(hw, wl->vif, &wl->vif->bss_conf, ~0);
3872
e4d6b795
MB		 3873 return err;
3874}
3875
881d948c 3876static void b43_update_basic_rates(struct b43_wldev *dev, u32 brates)
c7ab5ef9
JB		 3877{
3878 struct ieee80211_supported_band *sband =
3879 dev->wl->hw->wiphy->bands[b43_current_band(dev->wl)];
3880 struct ieee80211_rate *rate;
3881 int i;
3882 u16 basic, direct, offset, basic_offset, rateptr;
3883
3884 for (i = 0; i < sband->n_bitrates; i++) {
3885 rate = &sband->bitrates[i];
3886
3887 if (b43_is_cck_rate(rate->hw_value)) {
3888 direct = B43_SHM_SH_CCKDIRECT;
3889 basic = B43_SHM_SH_CCKBASIC;
3890 offset = b43_plcp_get_ratecode_cck(rate->hw_value);
3891 offset &= 0xF;
3892 } else {
3893 direct = B43_SHM_SH_OFDMDIRECT;
3894 basic = B43_SHM_SH_OFDMBASIC;
3895 offset = b43_plcp_get_ratecode_ofdm(rate->hw_value);
3896 offset &= 0xF;
3897 }
3898
3899 rate = ieee80211_get_response_rate(sband, brates, rate->bitrate);
3900
3901 if (b43_is_cck_rate(rate->hw_value)) {
3902 basic_offset = b43_plcp_get_ratecode_cck(rate->hw_value);
3903 basic_offset &= 0xF;
3904 } else {
3905 basic_offset = b43_plcp_get_ratecode_ofdm(rate->hw_value);
3906 basic_offset &= 0xF;
3907 }
3908
3909 /*
3910 * Get the pointer that we need to point to
3911 * from the direct map
3912 */
3913 rateptr = b43_shm_read16(dev, B43_SHM_SHARED,
3914 direct + 2 * basic_offset);
3915 /* and write it to the basic map */
3916 b43_shm_write16(dev, B43_SHM_SHARED, basic + 2 * offset,
3917 rateptr);
3918 }
3919}
3920
3921static void b43_op_bss_info_changed(struct ieee80211_hw *hw,
3922 struct ieee80211_vif *vif,
3923 struct ieee80211_bss_conf *conf,
3924 u32 changed)
3925{
3926 struct b43_wl *wl = hw_to_b43_wl(hw);
3927 struct b43_wldev *dev;
c7ab5ef9
JB		 3928
3929 mutex_lock(&wl->mutex);
3930
3931 dev = wl->current_dev;
d10d0e57 3932 if (!dev || b43_status(dev) < B43_STAT_STARTED)
c7ab5ef9 3933 goto out_unlock_mutex;
2d0ddec5
JB		 3934
3935 B43_WARN_ON(wl->vif != vif);
3936
3937 if (changed & BSS_CHANGED_BSSID) {
2d0ddec5
JB		 3938 if (conf->bssid)
3939 memcpy(wl->bssid, conf->bssid, ETH_ALEN);
3940 else
3941 memset(wl->bssid, 0, ETH_ALEN);
3f0d843b 3942 }
2d0ddec5 3943
3f0d843b
JB		 3944 if (b43_status(dev) >= B43_STAT_INITIALIZED) {
3945 if (changed & BSS_CHANGED_BEACON &&
3946 (b43_is_mode(wl, NL80211_IFTYPE_AP) ||
3947 b43_is_mode(wl, NL80211_IFTYPE_MESH_POINT) ||
3948 b43_is_mode(wl, NL80211_IFTYPE_ADHOC)))
3949 b43_update_templates(wl);
3950
3951 if (changed & BSS_CHANGED_BSSID)
2d0ddec5 3952 b43_write_mac_bssid_templates(dev);
2d0ddec5
JB		 3953 }
3954
c7ab5ef9
JB		 3955 b43_mac_suspend(dev);
3956
57c4d7b4
JB		 3957 /* Update templates for AP/mesh mode. */
3958 if (changed & BSS_CHANGED_BEACON_INT &&
3959 (b43_is_mode(wl, NL80211_IFTYPE_AP) ||
3960 b43_is_mode(wl, NL80211_IFTYPE_MESH_POINT) ||
2a190322
FF		 3961 b43_is_mode(wl, NL80211_IFTYPE_ADHOC)) &&
3962 conf->beacon_int)
57c4d7b4
JB		 3963 b43_set_beacon_int(dev, conf->beacon_int);
3964
c7ab5ef9
JB		 3965 if (changed & BSS_CHANGED_BASIC_RATES)
3966 b43_update_basic_rates(dev, conf->basic_rates);
3967
3968 if (changed & BSS_CHANGED_ERP_SLOT) {
3969 if (conf->use_short_slot)
3970 b43_short_slot_timing_enable(dev);
3971 else
3972 b43_short_slot_timing_disable(dev);
3973 }
3974
3975 b43_mac_enable(dev);
d10d0e57 3976out_unlock_mutex:
c7ab5ef9 3977 mutex_unlock(&wl->mutex);
c7ab5ef9
JB		 3978}
3979
40faacc4 3980static int b43_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
dc822b5d
JB		 3981 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3982 struct ieee80211_key_conf *key)
e4d6b795
MB		 3983{
3984 struct b43_wl *wl = hw_to_b43_wl(hw);
c6dfc9a8 3985 struct b43_wldev *dev;
e4d6b795
MB		 3986 u8 algorithm;
3987 u8 index;
c6dfc9a8 3988 int err;
060210f9 3989 static const u8 bcast_addr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
e4d6b795
MB		 3990
3991 if (modparam_nohwcrypt)
3992 return -ENOSPC; /* User disabled HW-crypto */
3993
c6dfc9a8 3994 mutex_lock(&wl->mutex);
c6dfc9a8
MB		 3995
3996 dev = wl->current_dev;
3997 err = -ENODEV;
3998 if (!dev || b43_status(dev) < B43_STAT_INITIALIZED)
3999 goto out_unlock;
4000
403a3a13 4001 if (dev->fw.pcm_request_failed || !dev->hwcrypto_enabled) {
68217832
MB		 4002 /* We don't have firmware for the crypto engine.
4003 * Must use software-crypto. */
4004 err = -EOPNOTSUPP;
4005 goto out_unlock;
4006 }
4007
c6dfc9a8 4008 err = -EINVAL;
97359d12
JB		 4009 switch (key->cipher) {
4010 case WLAN_CIPHER_SUITE_WEP40:
4011 algorithm = B43_SEC_ALGO_WEP40;
4012 break;
4013 case WLAN_CIPHER_SUITE_WEP104:
4014 algorithm = B43_SEC_ALGO_WEP104;
e4d6b795 4015 break;
97359d12 4016 case WLAN_CIPHER_SUITE_TKIP:
e4d6b795
MB		 4017 algorithm = B43_SEC_ALGO_TKIP;
4018 break;
97359d12 4019 case WLAN_CIPHER_SUITE_CCMP:
e4d6b795
MB		 4020 algorithm = B43_SEC_ALGO_AES;
4021 break;
4022 default:
4023 B43_WARN_ON(1);
c6dfc9a8 4024 goto out_unlock;
e4d6b795 4025 }
e4d6b795
MB		 4026 index = (u8) (key->keyidx);
4027 if (index > 3)
e4d6b795 4028 goto out_unlock;
e4d6b795
MB		 4029
4030 switch (cmd) {
4031 case SET_KEY:
035d0243 4032 if (algorithm == B43_SEC_ALGO_TKIP &&
4033 (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE) ||
4034 !modparam_hwtkip)) {
4035 /* We support only pairwise key */
e4d6b795
MB		 4036 err = -EOPNOTSUPP;
4037 goto out_unlock;
4038 }
4039
e808e586 4040 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
dc822b5d
JB		 4041 if (WARN_ON(!sta)) {
4042 err = -EOPNOTSUPP;
4043 goto out_unlock;
4044 }
e808e586 4045 /* Pairwise key with an assigned MAC address. */
e4d6b795 4046 err = b43_key_write(dev, -1, algorithm,
dc822b5d
JB		 4047 key->key, key->keylen,
4048 sta->addr, key);
e808e586
MB		 4049 } else {
4050 /* Group key */
4051 err = b43_key_write(dev, index, algorithm,
4052 key->key, key->keylen, NULL, key);
e4d6b795
MB		 4053 }
4054 if (err)
4055 goto out_unlock;
4056
4057 if (algorithm == B43_SEC_ALGO_WEP40 ||
4058 algorithm == B43_SEC_ALGO_WEP104) {
4059 b43_hf_write(dev, b43_hf_read(dev) | B43_HF_USEDEFKEYS);
4060 } else {
4061 b43_hf_write(dev,
4062 b43_hf_read(dev) & ~B43_HF_USEDEFKEYS);
4063 }
4064 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
035d0243 4065 if (algorithm == B43_SEC_ALGO_TKIP)
4066 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
e4d6b795
MB		 4067 break;
4068 case DISABLE_KEY: {
4069 err = b43_key_clear(dev, key->hw_key_idx);
4070 if (err)
4071 goto out_unlock;
4072 break;
4073 }
4074 default:
4075 B43_WARN_ON(1);
4076 }
9cf7f247 4077
e4d6b795 4078out_unlock:
e4d6b795
MB		 4079 if (!err) {
4080 b43dbg(wl, "%s hardware based encryption for keyidx: %d, "
e174961c 4081 "mac: %pM\n",
e4d6b795 4082 cmd == SET_KEY ? "Using" : "Disabling", key->keyidx,
a1d88210 4083 sta ? sta->addr : bcast_addr);
9cf7f247 4084 b43_dump_keymemory(dev);
e4d6b795 4085 }
9cf7f247
MB		 4086 mutex_unlock(&wl->mutex);
4087
e4d6b795
MB		 4088 return err;
4089}
4090
40faacc4
MB		 4091static void b43_op_configure_filter(struct ieee80211_hw *hw,
4092 unsigned int changed, unsigned int *fflags,
3ac64bee 4093 u64 multicast)
e4d6b795
MB		 4094{
4095 struct b43_wl *wl = hw_to_b43_wl(hw);
36dbd954 4096 struct b43_wldev *dev;
e4d6b795 4097
36dbd954
MB		 4098 mutex_lock(&wl->mutex);
4099 dev = wl->current_dev;
4150c572
JB		 4100 if (!dev) {
4101 *fflags = 0;
36dbd954 4102 goto out_unlock;
e4d6b795 4103 }
4150c572 4104
4150c572
JB		 4105 *fflags &= FIF_PROMISC_IN_BSS |
4106 FIF_ALLMULTI |
4107 FIF_FCSFAIL |
4108 FIF_PLCPFAIL |
4109 FIF_CONTROL |
4110 FIF_OTHER_BSS |
4111 FIF_BCN_PRBRESP_PROMISC;
4112
4113 changed &= FIF_PROMISC_IN_BSS |
4114 FIF_ALLMULTI |
4115 FIF_FCSFAIL |
4116 FIF_PLCPFAIL |
4117 FIF_CONTROL |
4118 FIF_OTHER_BSS |
4119 FIF_BCN_PRBRESP_PROMISC;
4120
4121 wl->filter_flags = *fflags;
4122
4123 if (changed && b43_status(dev) >= B43_STAT_INITIALIZED)
4124 b43_adjust_opmode(dev);
36dbd954
MB		 4125
4126out_unlock:
4127 mutex_unlock(&wl->mutex);
e4d6b795
MB		 4128}
4129
36dbd954
MB		 4130/* Locking: wl->mutex
4131 * Returns the current dev. This might be different from the passed in dev,
4132 * because the core might be gone away while we unlocked the mutex. */
4133static struct b43_wldev * b43_wireless_core_stop(struct b43_wldev *dev)
e4d6b795 4134{
9a53bf54 4135 struct b43_wl *wl;
36dbd954 4136 struct b43_wldev *orig_dev;
49d965c8 4137 u32 mask;
e4d6b795 4138
9a53bf54
LF		 4139 if (!dev)
4140 return NULL;
4141 wl = dev->wl;
36dbd954
MB		 4142redo:
4143 if (!dev || b43_status(dev) < B43_STAT_STARTED)
4144 return dev;
a19d12d7 4145
f5d40eed 4146 /* Cancel work. Unlock to avoid deadlocks. */
36dbd954
MB		 4147 mutex_unlock(&wl->mutex);
4148 cancel_delayed_work_sync(&dev->periodic_work);
f5d40eed 4149 cancel_work_sync(&wl->tx_work);
36dbd954
MB		 4150 mutex_lock(&wl->mutex);
4151 dev = wl->current_dev;
4152 if (!dev || b43_status(dev) < B43_STAT_STARTED) {
4153 /* Whoops, aliens ate up the device while we were unlocked. */
4154 return dev;
4155 }
a19d12d7 4156
36dbd954 4157 /* Disable interrupts on the device. */
e4d6b795 4158 b43_set_status(dev, B43_STAT_INITIALIZED);
505fb019 4159 if (b43_bus_host_is_sdio(dev->dev)) {
36dbd954
MB		 4160 /* wl->mutex is locked. That is enough. */
4161 b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, 0);
4162 b43_read32(dev, B43_MMIO_GEN_IRQ_MASK); /* Flush */
4163 } else {
4164 spin_lock_irq(&wl->hardirq_lock);
4165 b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, 0);
4166 b43_read32(dev, B43_MMIO_GEN_IRQ_MASK); /* Flush */
4167 spin_unlock_irq(&wl->hardirq_lock);
4168 }
176e9f6a 4169 /* Synchronize and free the interrupt handlers. Unlock to avoid deadlocks. */
36dbd954 4170 orig_dev = dev;
e4d6b795 4171 mutex_unlock(&wl->mutex);
505fb019 4172 if (b43_bus_host_is_sdio(dev->dev)) {
176e9f6a
MB		 4173 b43_sdio_free_irq(dev);
4174 } else {
a18c715e
RM		 4175 synchronize_irq(dev->dev->irq);
4176 free_irq(dev->dev->irq, dev);
176e9f6a 4177 }
e4d6b795 4178 mutex_lock(&wl->mutex);
36dbd954
MB		 4179 dev = wl->current_dev;
4180 if (!dev)
4181 return dev;
4182 if (dev != orig_dev) {
4183 if (b43_status(dev) >= B43_STAT_STARTED)
4184 goto redo;
4185 return dev;
4186 }
49d965c8
MB		 4187 mask = b43_read32(dev, B43_MMIO_GEN_IRQ_MASK);
4188 B43_WARN_ON(mask != 0xFFFFFFFF && mask);
e4d6b795 4189
f5d40eed
MB		 4190 /* Drain the TX queue */
4191 while (skb_queue_len(&wl->tx_queue))
4192 dev_kfree_skb(skb_dequeue(&wl->tx_queue));
4193
e4d6b795 4194 b43_mac_suspend(dev);
a78b3bb2 4195 b43_leds_exit(dev);
e4d6b795 4196 b43dbg(wl, "Wireless interface stopped\n");
36dbd954
MB		 4197
4198 return dev;
e4d6b795
MB		 4199}
4200
4201/* Locking: wl->mutex */
4202static int b43_wireless_core_start(struct b43_wldev *dev)
4203{
4204 int err;
4205
4206 B43_WARN_ON(b43_status(dev) != B43_STAT_INITIALIZED);
4207
4208 drain_txstatus_queue(dev);
505fb019 4209 if (b43_bus_host_is_sdio(dev->dev)) {
3dbba8e2
AH		 4210 err = b43_sdio_request_irq(dev, b43_sdio_interrupt_handler);
4211 if (err) {
4212 b43err(dev->wl, "Cannot request SDIO IRQ\n");
4213 goto out;
4214 }
4215 } else {
a18c715e 4216 err = request_threaded_irq(dev->dev->irq, b43_interrupt_handler,
3dbba8e2
AH		 4217 b43_interrupt_thread_handler,
4218 IRQF_SHARED, KBUILD_MODNAME, dev);
4219 if (err) {
dedb1eb9 4220 b43err(dev->wl, "Cannot request IRQ-%d\n",
a18c715e 4221 dev->dev->irq);
3dbba8e2
AH		 4222 goto out;
4223 }
e4d6b795
MB		 4224 }
4225
4226 /* We are ready to run. */
0866b03c 4227 ieee80211_wake_queues(dev->wl->hw);
e4d6b795
MB		 4228 b43_set_status(dev, B43_STAT_STARTED);
4229
4230 /* Start data flow (TX/RX). */
4231 b43_mac_enable(dev);
13790728 4232 b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, dev->irq_mask);
e4d6b795 4233
25985edc 4234 /* Start maintenance work */
e4d6b795
MB		 4235 b43_periodic_tasks_setup(dev);
4236
a78b3bb2
MB		 4237 b43_leds_init(dev);
4238
e4d6b795 4239 b43dbg(dev->wl, "Wireless interface started\n");
a78b3bb2 4240out:
e4d6b795
MB		 4241 return err;
4242}
4243
4244/* Get PHY and RADIO versioning numbers */
4245static int b43_phy_versioning(struct b43_wldev *dev)
4246{
4247 struct b43_phy *phy = &dev->phy;
4248 u32 tmp;
4249 u8 analog_type;
4250 u8 phy_type;
4251 u8 phy_rev;
4252 u16 radio_manuf;
4253 u16 radio_ver;
4254 u16 radio_rev;
4255 int unsupported = 0;
4256
4257 /* Get PHY versioning */
4258 tmp = b43_read16(dev, B43_MMIO_PHY_VER);
4259 analog_type = (tmp & B43_PHYVER_ANALOG) >> B43_PHYVER_ANALOG_SHIFT;
4260 phy_type = (tmp & B43_PHYVER_TYPE) >> B43_PHYVER_TYPE_SHIFT;
4261 phy_rev = (tmp & B43_PHYVER_VERSION);
4262 switch (phy_type) {
4263 case B43_PHYTYPE_A:
4264 if (phy_rev >= 4)
4265 unsupported = 1;
4266 break;
4267 case B43_PHYTYPE_B:
4268 if (phy_rev != 2 && phy_rev != 4 && phy_rev != 6
4269 && phy_rev != 7)
4270 unsupported = 1;
4271 break;
4272 case B43_PHYTYPE_G:
013978b6 4273 if (phy_rev > 9)
e4d6b795
MB		 4274 unsupported = 1;
4275 break;
692d2c0f 4276#ifdef CONFIG_B43_PHY_N
d5c71e46 4277 case B43_PHYTYPE_N:
ab72efdf 4278 if (phy_rev > 9)
d5c71e46
MB		 4279 unsupported = 1;
4280 break;
6b1c7c67
MB		 4281#endif
4282#ifdef CONFIG_B43_PHY_LP
4283 case B43_PHYTYPE_LP:
9d86a2d5 4284 if (phy_rev > 2)
6b1c7c67
MB		 4285 unsupported = 1;
4286 break;
d7520b1d
RM		 4287#endif
4288#ifdef CONFIG_B43_PHY_HT
4289 case B43_PHYTYPE_HT:
4290 if (phy_rev > 1)
4291 unsupported = 1;
4292 break;
1d738e64
RM		 4293#endif
4294#ifdef CONFIG_B43_PHY_LCN
4295 case B43_PHYTYPE_LCN:
4296 if (phy_rev > 1)
4297 unsupported = 1;
4298 break;
d5c71e46 4299#endif
e4d6b795
MB		 4300 default:
4301 unsupported = 1;
6403eab1 4302 }
e4d6b795
MB		 4303 if (unsupported) {
4304 b43err(dev->wl, "FOUND UNSUPPORTED PHY "
4305 "(Analog %u, Type %u, Revision %u)\n",
4306 analog_type, phy_type, phy_rev);
4307 return -EOPNOTSUPP;
4308 }
4309 b43dbg(dev->wl, "Found PHY: Analog %u, Type %u, Revision %u\n",
4310 analog_type, phy_type, phy_rev);
4311
4312 /* Get RADIO versioning */
3fd48508 4313 if (dev->dev->core_rev >= 24) {
544e5d8b
RM		 4314 u16 radio24[3];
4315
4316 for (tmp = 0; tmp < 3; tmp++) {
4317 b43_write16(dev, B43_MMIO_RADIO24_CONTROL, tmp);
4318 radio24[tmp] = b43_read16(dev, B43_MMIO_RADIO24_DATA);
4319 }
4320
4321 /* Broadcom uses "id" for our "ver" and has separated "ver" */
4322 /* radio_ver = (radio24[0] & 0xF0) >> 4; */
4323
4324 radio_manuf = 0x17F;
4325 radio_ver = (radio24[2] << 8) | radio24[1];
4326 radio_rev = (radio24[0] & 0xF);
e4d6b795 4327 } else {
3fd48508
RM		 4328 if (dev->dev->chip_id == 0x4317) {
4329 if (dev->dev->chip_rev == 0)
4330 tmp = 0x3205017F;
4331 else if (dev->dev->chip_rev == 1)
4332 tmp = 0x4205017F;
4333 else
4334 tmp = 0x5205017F;
4335 } else {
4336 b43_write16(dev, B43_MMIO_RADIO_CONTROL,
4337 B43_RADIOCTL_ID);
4338 tmp = b43_read16(dev, B43_MMIO_RADIO_DATA_LOW);
4339 b43_write16(dev, B43_MMIO_RADIO_CONTROL,
4340 B43_RADIOCTL_ID);
4341 tmp |= (u32)b43_read16(dev, B43_MMIO_RADIO_DATA_HIGH)
4342 << 16;
4343 }
4344 radio_manuf = (tmp & 0x00000FFF);
4345 radio_ver = (tmp & 0x0FFFF000) >> 12;
4346 radio_rev = (tmp & 0xF0000000) >> 28;
e4d6b795 4347 }
3fd48508 4348
96c755a3
MB		 4349 if (radio_manuf != 0x17F /* Broadcom */)
4350 unsupported = 1;
e4d6b795
MB		 4351 switch (phy_type) {
4352 case B43_PHYTYPE_A:
4353 if (radio_ver != 0x2060)
4354 unsupported = 1;
4355 if (radio_rev != 1)
4356 unsupported = 1;
4357 if (radio_manuf != 0x17F)
4358 unsupported = 1;
4359 break;
4360 case B43_PHYTYPE_B:
4361 if ((radio_ver & 0xFFF0) != 0x2050)
4362 unsupported = 1;
4363 break;
4364 case B43_PHYTYPE_G:
4365 if (radio_ver != 0x2050)
4366 unsupported = 1;
4367 break;
96c755a3 4368 case B43_PHYTYPE_N:
bb519bee 4369 if (radio_ver != 0x2055 && radio_ver != 0x2056)
96c755a3
MB		 4370 unsupported = 1;
4371 break;
6b1c7c67 4372 case B43_PHYTYPE_LP:
9d86a2d5 4373 if (radio_ver != 0x2062 && radio_ver != 0x2063)
6b1c7c67
MB		 4374 unsupported = 1;
4375 break;
d7520b1d
RM		 4376 case B43_PHYTYPE_HT:
4377 if (radio_ver != 0x2059)
4378 unsupported = 1;
4379 break;
1d738e64
RM		 4380 case B43_PHYTYPE_LCN:
4381 if (radio_ver != 0x2064)
4382 unsupported = 1;
4383 break;
e4d6b795
MB		 4384 default:
4385 B43_WARN_ON(1);
4386 }
4387 if (unsupported) {
4388 b43err(dev->wl, "FOUND UNSUPPORTED RADIO "
4389 "(Manuf 0x%X, Version 0x%X, Revision %u)\n",
4390 radio_manuf, radio_ver, radio_rev);
4391 return -EOPNOTSUPP;
4392 }
4393 b43dbg(dev->wl, "Found Radio: Manuf 0x%X, Version 0x%X, Revision %u\n",
4394 radio_manuf, radio_ver, radio_rev);
4395
4396 phy->radio_manuf = radio_manuf;
4397 phy->radio_ver = radio_ver;
4398 phy->radio_rev = radio_rev;
4399
4400 phy->analog = analog_type;
4401 phy->type = phy_type;
4402 phy->rev = phy_rev;
4403
4404 return 0;
4405}
4406
4407static void setup_struct_phy_for_init(struct b43_wldev *dev,
4408 struct b43_phy *phy)
4409{
e4d6b795 4410 phy->hardware_power_control = !!modparam_hwpctl;
18c8adeb 4411 phy->next_txpwr_check_time = jiffies;
8ed7fc48
MB		 4412 /* PHY TX errors counter. */
4413 atomic_set(&phy->txerr_cnt, B43_PHY_TX_BADNESS_LIMIT);
591f3dc2
MB		 4414
4415#if B43_DEBUG
4416 phy->phy_locked = 0;
4417 phy->radio_locked = 0;
4418#endif
e4d6b795
MB		 4419}
4420
4421static void setup_struct_wldev_for_init(struct b43_wldev *dev)
4422{
aa6c7ae2
MB		 4423 dev->dfq_valid = 0;
4424
6a724d68
MB		 4425 /* Assume the radio is enabled. If it's not enabled, the state will
4426 * immediately get fixed on the first periodic work run. */
4427 dev->radio_hw_enable = 1;
e4d6b795
MB		 4428
4429 /* Stats */
4430 memset(&dev->stats, 0, sizeof(dev->stats));
4431
4432 setup_struct_phy_for_init(dev, &dev->phy);
4433
4434 /* IRQ related flags */
4435 dev->irq_reason = 0;
4436 memset(dev->dma_reason, 0, sizeof(dev->dma_reason));
13790728 4437 dev->irq_mask = B43_IRQ_MASKTEMPLATE;
3e3ccb3d 4438 if (b43_modparam_verbose < B43_VERBOSITY_DEBUG)
13790728 4439 dev->irq_mask &= ~B43_IRQ_PHY_TXERR;
e4d6b795
MB		 4440
4441 dev->mac_suspended = 1;
4442
4443 /* Noise calculation context */
4444 memset(&dev->noisecalc, 0, sizeof(dev->noisecalc));
4445}
4446
4447static void b43_bluetooth_coext_enable(struct b43_wldev *dev)
4448{
0581483a 4449 struct ssb_sprom *sprom = dev->dev->bus_sprom;
a259d6a4 4450 u64 hf;
e4d6b795 4451
1855ba78
MB		 4452 if (!modparam_btcoex)
4453 return;
95de2841 4454 if (!(sprom->boardflags_lo & B43_BFL_BTCOEXIST))
e4d6b795
MB		 4455 return;
4456 if (dev->phy.type != B43_PHYTYPE_B && !dev->phy.gmode)
4457 return;
4458
4459 hf = b43_hf_read(dev);
95de2841 4460 if (sprom->boardflags_lo & B43_BFL_BTCMOD)
e4d6b795
MB		 4461 hf |= B43_HF_BTCOEXALT;
4462 else
4463 hf |= B43_HF_BTCOEX;
4464 b43_hf_write(dev, hf);
e4d6b795
MB		 4465}
4466
4467static void b43_bluetooth_coext_disable(struct b43_wldev *dev)
1855ba78
MB		 4468{
4469 if (!modparam_btcoex)
4470 return;
4471 //TODO
e4d6b795
MB		 4472}
4473
4474static void b43_imcfglo_timeouts_workaround(struct b43_wldev *dev)
4475{
d48ae5c8 4476 struct ssb_bus *bus;
e4d6b795
MB		 4477 u32 tmp;
4478
d48ae5c8
RM		 4479 if (dev->dev->bus_type != B43_BUS_SSB)
4480 return;
4481
4482 bus = dev->dev->sdev->bus;
4483
0fd82eaf
RM		 4484 if ((bus->chip_id == 0x4311 && bus->chip_rev == 2) ||
4485 (bus->chip_id == 0x4312)) {
d48ae5c8 4486 tmp = ssb_read32(dev->dev->sdev, SSB_IMCFGLO);
0fd82eaf
RM		 4487 tmp &= ~SSB_IMCFGLO_REQTO;
4488 tmp &= ~SSB_IMCFGLO_SERTO;
4489 tmp |= 0x3;
d48ae5c8 4490 ssb_write32(dev->dev->sdev, SSB_IMCFGLO, tmp);
0fd82eaf 4491 ssb_commit_settings(bus);
e4d6b795 4492 }
e4d6b795
MB		 4493}
4494
d59f720d
MB		 4495static void b43_set_synth_pu_delay(struct b43_wldev *dev, bool idle)
4496{
4497 u16 pu_delay;
4498
4499 /* The time value is in microseconds. */
4500 if (dev->phy.type == B43_PHYTYPE_A)
4501 pu_delay = 3700;
4502 else
4503 pu_delay = 1050;
05c914fe 4504 if (b43_is_mode(dev->wl, NL80211_IFTYPE_ADHOC) || idle)
d59f720d
MB		 4505 pu_delay = 500;
4506 if ((dev->phy.radio_ver == 0x2050) && (dev->phy.radio_rev == 8))
4507 pu_delay = max(pu_delay, (u16)2400);
4508
4509 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_SPUWKUP, pu_delay);
4510}
4511
4512/* Set the TSF CFP pre-TargetBeaconTransmissionTime. */
4513static void b43_set_pretbtt(struct b43_wldev *dev)
4514{
4515 u16 pretbtt;
4516
4517 /* The time value is in microseconds. */
05c914fe 4518 if (b43_is_mode(dev->wl, NL80211_IFTYPE_ADHOC)) {
d59f720d
MB		 4519 pretbtt = 2;
4520 } else {
4521 if (dev->phy.type == B43_PHYTYPE_A)
4522 pretbtt = 120;
4523 else
4524 pretbtt = 250;
4525 }
4526 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_PRETBTT, pretbtt);
4527 b43_write16(dev, B43_MMIO_TSF_CFP_PRETBTT, pretbtt);
4528}
4529
e4d6b795
MB		 4530/* Shutdown a wireless core */
4531/* Locking: wl->mutex */
4532static void b43_wireless_core_exit(struct b43_wldev *dev)
4533{
1f7d87b0 4534 u32 macctl;
e4d6b795 4535
36dbd954
MB		 4536 B43_WARN_ON(dev && b43_status(dev) > B43_STAT_INITIALIZED);
4537 if (!dev || b43_status(dev) != B43_STAT_INITIALIZED)
e4d6b795 4538 return;
84c164a3
JL		 4539
4540 /* Unregister HW RNG driver */
4541 b43_rng_exit(dev->wl);
4542
e4d6b795
MB		 4543 b43_set_status(dev, B43_STAT_UNINIT);
4544
1f7d87b0
MB		 4545 /* Stop the microcode PSM. */
4546 macctl = b43_read32(dev, B43_MMIO_MACCTL);
4547 macctl &= ~B43_MACCTL_PSM_RUN;
4548 macctl |= B43_MACCTL_PSM_JMP0;
4549 b43_write32(dev, B43_MMIO_MACCTL, macctl);
4550
e4d6b795 4551 b43_dma_free(dev);
5100d5ac 4552 b43_pio_free(dev);
e4d6b795 4553 b43_chip_exit(dev);
cb24f57f 4554 dev->phy.ops->switch_analog(dev, 0);
e66fee6a
MB		 4555 if (dev->wl->current_beacon) {
4556 dev_kfree_skb_any(dev->wl->current_beacon);
4557 dev->wl->current_beacon = NULL;
4558 }
4559
24ca39d6
RM		 4560 b43_device_disable(dev, 0);
4561 b43_bus_may_powerdown(dev);
e4d6b795
MB		 4562}
4563
4564/* Initialize a wireless core */
4565static int b43_wireless_core_init(struct b43_wldev *dev)
4566{
0581483a 4567 struct ssb_sprom *sprom = dev->dev->bus_sprom;
e4d6b795
MB		 4568 struct b43_phy *phy = &dev->phy;
4569 int err;
a259d6a4 4570 u64 hf;
e4d6b795
MB		 4571
4572 B43_WARN_ON(b43_status(dev) != B43_STAT_UNINIT);
4573
24ca39d6 4574 err = b43_bus_powerup(dev, 0);
e4d6b795
MB		 4575 if (err)
4576 goto out;
4da909e7
RM		 4577 if (!b43_device_is_enabled(dev))
4578 b43_wireless_core_reset(dev, phy->gmode);
e4d6b795 4579
fb11137a 4580 /* Reset all data structures. */
e4d6b795 4581 setup_struct_wldev_for_init(dev);
fb11137a 4582 phy->ops->prepare_structs(dev);
e4d6b795
MB		 4583
4584 /* Enable IRQ routing to this device. */
6cbab0d9 4585 switch (dev->dev->bus_type) {
42c9a458
RM		 4586#ifdef CONFIG_B43_BCMA
4587 case B43_BUS_BCMA:
4588 bcma_core_pci_irq_ctl(&dev->dev->bdev->bus->drv_pci,
4589 dev->dev->bdev, true);
4590 break;
4591#endif
6cbab0d9
RM		 4592#ifdef CONFIG_B43_SSB
4593 case B43_BUS_SSB:
4594 ssb_pcicore_dev_irqvecs_enable(&dev->dev->sdev->bus->pcicore,
4595 dev->dev->sdev);
4596 break;
4597#endif
4598 }
e4d6b795
MB		 4599
4600 b43_imcfglo_timeouts_workaround(dev);
4601 b43_bluetooth_coext_disable(dev);
fb11137a
MB		 4602 if (phy->ops->prepare_hardware) {
4603 err = phy->ops->prepare_hardware(dev);
ef1a628d 4604 if (err)
fb11137a 4605 goto err_busdown;
ef1a628d 4606 }
e4d6b795
MB		 4607 err = b43_chip_init(dev);
4608 if (err)
fb11137a 4609 goto err_busdown;
e4d6b795 4610 b43_shm_write16(dev, B43_SHM_SHARED,
21d889d4 4611 B43_SHM_SH_WLCOREREV, dev->dev->core_rev);
e4d6b795
MB		 4612 hf = b43_hf_read(dev);
4613 if (phy->type == B43_PHYTYPE_G) {
4614 hf |= B43_HF_SYMW;
4615 if (phy->rev == 1)
4616 hf |= B43_HF_GDCW;
95de2841 4617 if (sprom->boardflags_lo & B43_BFL_PACTRL)
e4d6b795 4618 hf |= B43_HF_OFDMPABOOST;
969d15cf
MB		 4619 }
4620 if (phy->radio_ver == 0x2050) {
4621 if (phy->radio_rev == 6)
4622 hf |= B43_HF_4318TSSI;
4623 if (phy->radio_rev < 6)
4624 hf |= B43_HF_VCORECALC;
e4d6b795 4625 }
1cc8f476
MB		 4626 if (sprom->boardflags_lo & B43_BFL_XTAL_NOSLOW)
4627 hf |= B43_HF_DSCRQ; /* Disable slowclock requests from ucode. */
1a77733c 4628#ifdef CONFIG_SSB_DRIVER_PCICORE
6cbab0d9
RM		 4629 if (dev->dev->bus_type == B43_BUS_SSB &&
4630 dev->dev->sdev->bus->bustype == SSB_BUSTYPE_PCI &&
4631 dev->dev->sdev->bus->pcicore.dev->id.revision <= 10)
8821905c 4632 hf |= B43_HF_PCISCW; /* PCI slow clock workaround. */
1a77733c 4633#endif
25d3ef59 4634 hf &= ~B43_HF_SKCFPUP;
e4d6b795
MB		 4635 b43_hf_write(dev, hf);
4636
74cfdba7
MB		 4637 b43_set_retry_limits(dev, B43_DEFAULT_SHORT_RETRY_LIMIT,
4638 B43_DEFAULT_LONG_RETRY_LIMIT);
e4d6b795
MB		 4639 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_SFFBLIM, 3);
4640 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_LFFBLIM, 2);
4641
4642 /* Disable sending probe responses from firmware.
4643 * Setting the MaxTime to one usec will always trigger
4644 * a timeout, so we never send any probe resp.
4645 * A timeout of zero is infinite. */
4646 b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_PRMAXTIME, 1);
4647
4648 b43_rate_memory_init(dev);
5042c507 4649 b43_set_phytxctl_defaults(dev);
e4d6b795
MB		 4650
4651 /* Minimum Contention Window */
c5a079f4 4652 if (phy->type == B43_PHYTYPE_B)
e4d6b795 4653 b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_MINCONT, 0x1F);
c5a079f4 4654 else
e4d6b795 4655 b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_MINCONT, 0xF);
e4d6b795
MB		 4656 /* Maximum Contention Window */
4657 b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_MAXCONT, 0x3FF);
4658
505fb019 4659 if (b43_bus_host_is_pcmcia(dev->dev) ||
cbe1e82a
RM		 4660 b43_bus_host_is_sdio(dev->dev)) {
4661 dev->__using_pio_transfers = 1;
4662 err = b43_pio_init(dev);
4663 } else if (dev->use_pio) {
4664 b43warn(dev->wl, "Forced PIO by use_pio module parameter. "
4665 "This should not be needed and will result in lower "
4666 "performance.\n");
5100d5ac
MB		 4667 dev->__using_pio_transfers = 1;
4668 err = b43_pio_init(dev);
4669 } else {
4670 dev->__using_pio_transfers = 0;
4671 err = b43_dma_init(dev);
4672 }
e4d6b795
MB		 4673 if (err)
4674 goto err_chip_exit;
03b29773 4675 b43_qos_init(dev);
d59f720d 4676 b43_set_synth_pu_delay(dev, 1);
e4d6b795
MB		 4677 b43_bluetooth_coext_enable(dev);
4678
24ca39d6 4679 b43_bus_powerup(dev, !(sprom->boardflags_lo & B43_BFL_XTAL_NOSLOW));
4150c572 4680 b43_upload_card_macaddress(dev);
e4d6b795 4681 b43_security_init(dev);
e4d6b795 4682
5ab9549a 4683 ieee80211_wake_queues(dev->wl->hw);
e4d6b795
MB		 4684
4685 b43_set_status(dev, B43_STAT_INITIALIZED);
4686
84c164a3
JL		 4687 /* Register HW RNG driver */
4688 b43_rng_init(dev->wl);
4689
1a8d1227 4690out:
e4d6b795
MB		 4691 return err;
4692
ef1a628d 4693err_chip_exit:
e4d6b795 4694 b43_chip_exit(dev);
ef1a628d 4695err_busdown:
24ca39d6 4696 b43_bus_may_powerdown(dev);
e4d6b795
MB		 4697 B43_WARN_ON(b43_status(dev) != B43_STAT_UNINIT);
4698 return err;
4699}
4700
40faacc4 4701static int b43_op_add_interface(struct ieee80211_hw *hw,
1ed32e4f 4702 struct ieee80211_vif *vif)
e4d6b795
MB		 4703{
4704 struct b43_wl *wl = hw_to_b43_wl(hw);
4705 struct b43_wldev *dev;
e4d6b795 4706 int err = -EOPNOTSUPP;
4150c572
JB		 4707
4708 /* TODO: allow WDS/AP devices to coexist */
4709
1ed32e4f
JB		 4710 if (vif->type != NL80211_IFTYPE_AP &&
4711 vif->type != NL80211_IFTYPE_MESH_POINT &&
4712 vif->type != NL80211_IFTYPE_STATION &&
4713 vif->type != NL80211_IFTYPE_WDS &&
4714 vif->type != NL80211_IFTYPE_ADHOC)
4150c572 4715 return -EOPNOTSUPP;
e4d6b795
MB		 4716
4717 mutex_lock(&wl->mutex);
4150c572 4718 if (wl->operating)
e4d6b795
MB		 4719 goto out_mutex_unlock;
4720
1ed32e4f 4721 b43dbg(wl, "Adding Interface type %d\n", vif->type);
e4d6b795
MB		 4722
4723 dev = wl->current_dev;
4150c572 4724 wl->operating = 1;
1ed32e4f
JB		 4725 wl->vif = vif;
4726 wl->if_type = vif->type;
4727 memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
4150c572 4728
4150c572 4729 b43_adjust_opmode(dev);
d59f720d
MB		 4730 b43_set_pretbtt(dev);
4731 b43_set_synth_pu_delay(dev, 0);
4150c572 4732 b43_upload_card_macaddress(dev);
4150c572
JB		 4733
4734 err = 0;
4735 out_mutex_unlock:
4736 mutex_unlock(&wl->mutex);
4737
2a190322
FF		 4738 if (err == 0)
4739 b43_op_bss_info_changed(hw, vif, &vif->bss_conf, ~0);
4740
4150c572
JB		 4741 return err;
4742}
4743
40faacc4 4744static void b43_op_remove_interface(struct ieee80211_hw *hw,
1ed32e4f 4745 struct ieee80211_vif *vif)
4150c572
JB		 4746{
4747 struct b43_wl *wl = hw_to_b43_wl(hw);
4748 struct b43_wldev *dev = wl->current_dev;
4150c572 4749
1ed32e4f 4750 b43dbg(wl, "Removing Interface type %d\n", vif->type);
4150c572
JB		 4751
4752 mutex_lock(&wl->mutex);
4753
4754 B43_WARN_ON(!wl->operating);
1ed32e4f 4755 B43_WARN_ON(wl->vif != vif);
32bfd35d 4756 wl->vif = NULL;
4150c572
JB		 4757
4758 wl->operating = 0;
4759
4150c572
JB		 4760 b43_adjust_opmode(dev);
4761 memset(wl->mac_addr, 0, ETH_ALEN);
4762 b43_upload_card_macaddress(dev);
4150c572
JB		 4763
4764 mutex_unlock(&wl->mutex);
4765}
4766
40faacc4 4767static int b43_op_start(struct ieee80211_hw *hw)
4150c572
JB		 4768{
4769 struct b43_wl *wl = hw_to_b43_wl(hw);
4770 struct b43_wldev *dev = wl->current_dev;
4771 int did_init = 0;
923403b8 4772 int err = 0;
4150c572 4773
7be1bb6b
MB		 4774 /* Kill all old instance specific information to make sure
4775 * the card won't use it in the short timeframe between start
4776 * and mac80211 reconfiguring it. */
4777 memset(wl->bssid, 0, ETH_ALEN);
4778 memset(wl->mac_addr, 0, ETH_ALEN);
4779 wl->filter_flags = 0;
4780 wl->radiotap_enabled = 0;
e6f5b934 4781 b43_qos_clear(wl);
6b4bec01
MB		 4782 wl->beacon0_uploaded = 0;
4783 wl->beacon1_uploaded = 0;
4784 wl->beacon_templates_virgin = 1;
fd4973c5 4785 wl->radio_enabled = 1;
7be1bb6b 4786
4150c572
JB		 4787 mutex_lock(&wl->mutex);
4788
e4d6b795
MB		 4789 if (b43_status(dev) < B43_STAT_INITIALIZED) {
4790 err = b43_wireless_core_init(dev);
f41f3f37 4791 if (err)
e4d6b795
MB		 4792 goto out_mutex_unlock;
4793 did_init = 1;
4794 }
4150c572 4795
e4d6b795
MB		 4796 if (b43_status(dev) < B43_STAT_STARTED) {
4797 err = b43_wireless_core_start(dev);
4798 if (err) {
4799 if (did_init)
4800 b43_wireless_core_exit(dev);
4801 goto out_mutex_unlock;
4802 }
4803 }
4804
f41f3f37
JB		 4805 /* XXX: only do if device doesn't support rfkill irq */
4806 wiphy_rfkill_start_polling(hw->wiphy);
4807
4150c572 4808 out_mutex_unlock:
e4d6b795
MB		 4809 mutex_unlock(&wl->mutex);
4810
2a190322
FF		 4811 /* reload configuration */
4812 b43_op_config(hw, ~0);
4813
e4d6b795
MB		 4814 return err;
4815}
4816
40faacc4 4817static void b43_op_stop(struct ieee80211_hw *hw)
e4d6b795
MB		 4818{
4819 struct b43_wl *wl = hw_to_b43_wl(hw);
4150c572 4820 struct b43_wldev *dev = wl->current_dev;
e4d6b795 4821
a82d9922 4822 cancel_work_sync(&(wl->beacon_update_trigger));
1a8d1227 4823
e4d6b795 4824 mutex_lock(&wl->mutex);
36dbd954
MB		 4825 if (b43_status(dev) >= B43_STAT_STARTED) {
4826 dev = b43_wireless_core_stop(dev);
4827 if (!dev)
4828 goto out_unlock;
4829 }
4150c572 4830 b43_wireless_core_exit(dev);
fd4973c5 4831 wl->radio_enabled = 0;
36dbd954
MB		 4832
4833out_unlock:
e4d6b795 4834 mutex_unlock(&wl->mutex);
18c8adeb
MB		 4835
4836 cancel_work_sync(&(wl->txpower_adjust_work));
e4d6b795
MB		 4837}
4838
17741cdc
JB		 4839static int b43_op_beacon_set_tim(struct ieee80211_hw *hw,
4840 struct ieee80211_sta *sta, bool set)
e66fee6a
MB		 4841{
4842 struct b43_wl *wl = hw_to_b43_wl(hw);
4843
8f611288 4844 /* FIXME: add locking */
9d139c81 4845 b43_update_templates(wl);
e66fee6a
MB		 4846
4847 return 0;
4848}
4849
38968d09
JB		 4850static void b43_op_sta_notify(struct ieee80211_hw *hw,
4851 struct ieee80211_vif *vif,
4852 enum sta_notify_cmd notify_cmd,
17741cdc 4853 struct ieee80211_sta *sta)
38968d09
JB		 4854{
4855 struct b43_wl *wl = hw_to_b43_wl(hw);
4856
4857 B43_WARN_ON(!vif || wl->vif != vif);
4858}
4859
25d3ef59
MB		 4860static void b43_op_sw_scan_start_notifier(struct ieee80211_hw *hw)
4861{
4862 struct b43_wl *wl = hw_to_b43_wl(hw);
4863 struct b43_wldev *dev;
4864
4865 mutex_lock(&wl->mutex);
4866 dev = wl->current_dev;
4867 if (dev && (b43_status(dev) >= B43_STAT_INITIALIZED)) {
4868 /* Disable CFP update during scan on other channels. */
4869 b43_hf_write(dev, b43_hf_read(dev) | B43_HF_SKCFPUP);
4870 }
4871 mutex_unlock(&wl->mutex);
4872}
4873
4874static void b43_op_sw_scan_complete_notifier(struct ieee80211_hw *hw)
4875{
4876 struct b43_wl *wl = hw_to_b43_wl(hw);
4877 struct b43_wldev *dev;
4878
4879 mutex_lock(&wl->mutex);
4880 dev = wl->current_dev;
4881 if (dev && (b43_status(dev) >= B43_STAT_INITIALIZED)) {
4882 /* Re-enable CFP update. */
4883 b43_hf_write(dev, b43_hf_read(dev) & ~B43_HF_SKCFPUP);
4884 }
4885 mutex_unlock(&wl->mutex);
4886}
4887
354b4f04
JL		 4888static int b43_op_get_survey(struct ieee80211_hw *hw, int idx,
4889 struct survey_info *survey)
4890{
4891 struct b43_wl *wl = hw_to_b43_wl(hw);
4892 struct b43_wldev *dev = wl->current_dev;
4893 struct ieee80211_conf *conf = &hw->conf;
4894
4895 if (idx != 0)
4896 return -ENOENT;
4897
4898 survey->channel = conf->channel;
4899 survey->filled = SURVEY_INFO_NOISE_DBM;
4900 survey->noise = dev->stats.link_noise;
4901
4902 return 0;
4903}
4904
e4d6b795 4905static const struct ieee80211_ops b43_hw_ops = {
40faacc4
MB		 4906 .tx = b43_op_tx,
4907 .conf_tx = b43_op_conf_tx,
4908 .add_interface = b43_op_add_interface,
4909 .remove_interface = b43_op_remove_interface,
4910 .config = b43_op_config,
c7ab5ef9 4911 .bss_info_changed = b43_op_bss_info_changed,
40faacc4
MB		 4912 .configure_filter = b43_op_configure_filter,
4913 .set_key = b43_op_set_key,
035d0243 4914 .update_tkip_key = b43_op_update_tkip_key,
40faacc4 4915 .get_stats = b43_op_get_stats,
08e87a83
AF		 4916 .get_tsf = b43_op_get_tsf,
4917 .set_tsf = b43_op_set_tsf,
40faacc4
MB		 4918 .start = b43_op_start,
4919 .stop = b43_op_stop,
e66fee6a 4920 .set_tim = b43_op_beacon_set_tim,
38968d09 4921 .sta_notify = b43_op_sta_notify,
25d3ef59
MB		 4922 .sw_scan_start = b43_op_sw_scan_start_notifier,
4923 .sw_scan_complete = b43_op_sw_scan_complete_notifier,
354b4f04 4924 .get_survey = b43_op_get_survey,
f41f3f37 4925 .rfkill_poll = b43_rfkill_poll,
e4d6b795
MB		 4926};
4927
4928/* Hard-reset the chip. Do not call this directly.
4929 * Use b43_controller_restart()
4930 */
4931static void b43_chip_reset(struct work_struct *work)
4932{
4933 struct b43_wldev *dev =
4934 container_of(work, struct b43_wldev, restart_work);
4935 struct b43_wl *wl = dev->wl;
4936 int err = 0;
4937 int prev_status;
4938
4939 mutex_lock(&wl->mutex);
4940
4941 prev_status = b43_status(dev);
4942 /* Bring the device down... */
36dbd954
MB		 4943 if (prev_status >= B43_STAT_STARTED) {
4944 dev = b43_wireless_core_stop(dev);
4945 if (!dev) {
4946 err = -ENODEV;
4947 goto out;
4948 }
4949 }
e4d6b795
MB		 4950 if (prev_status >= B43_STAT_INITIALIZED)
4951 b43_wireless_core_exit(dev);
4952
4953 /* ...and up again. */
4954 if (prev_status >= B43_STAT_INITIALIZED) {
4955 err = b43_wireless_core_init(dev);
4956 if (err)
4957 goto out;
4958 }
4959 if (prev_status >= B43_STAT_STARTED) {
4960 err = b43_wireless_core_start(dev);
4961 if (err) {
4962 b43_wireless_core_exit(dev);
4963 goto out;
4964 }
4965 }
3bf0a32e
MB		 4966out:
4967 if (err)
4968 wl->current_dev = NULL; /* Failed to init the dev. */
e4d6b795 4969 mutex_unlock(&wl->mutex);
2a190322
FF		 4970
4971 if (err) {
e4d6b795 4972 b43err(wl, "Controller restart FAILED\n");
2a190322
FF		 4973 return;
4974 }
4975
4976 /* reload configuration */
4977 b43_op_config(wl->hw, ~0);
4978 if (wl->vif)
4979 b43_op_bss_info_changed(wl->hw, wl->vif, &wl->vif->bss_conf, ~0);
4980
4981 b43info(wl, "Controller restarted\n");
e4d6b795
MB		 4982}
4983
bb1eeff1 4984static int b43_setup_bands(struct b43_wldev *dev,
96c755a3 4985 bool have_2ghz_phy, bool have_5ghz_phy)
e4d6b795
MB		 4986{
4987 struct ieee80211_hw *hw = dev->wl->hw;
e4d6b795 4988
bb1eeff1
MB		 4989 if (have_2ghz_phy)
4990 hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &b43_band_2GHz;
4991 if (dev->phy.type == B43_PHYTYPE_N) {
4992 if (have_5ghz_phy)
4993 hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &b43_band_5GHz_nphy;
4994 } else {
4995 if (have_5ghz_phy)
4996 hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &b43_band_5GHz_aphy;
4997 }
96c755a3 4998
bb1eeff1
MB		 4999 dev->phy.supports_2ghz = have_2ghz_phy;
5000 dev->phy.supports_5ghz = have_5ghz_phy;
e4d6b795
MB		 5001
5002 return 0;
5003}
5004
5005static void b43_wireless_core_detach(struct b43_wldev *dev)
5006{
5007 /* We release firmware that late to not be required to re-request
5008 * is all the time when we reinit the core. */
5009 b43_release_firmware(dev);
fb11137a 5010 b43_phy_free(dev);
e4d6b795
MB		 5011}
5012
5013static int b43_wireless_core_attach(struct b43_wldev *dev)
5014{
5015 struct b43_wl *wl = dev->wl;
6cbab0d9 5016 struct pci_dev *pdev = NULL;
e4d6b795 5017 int err;
40c62269 5018 u32 tmp;
96c755a3 5019 bool have_2ghz_phy = 0, have_5ghz_phy = 0;
e4d6b795
MB		 5020
5021 /* Do NOT do any device initialization here.
5022 * Do it in wireless_core_init() instead.
5023 * This function is for gathering basic information about the HW, only.
5024 * Also some structs may be set up here. But most likely you want to have
5025 * that in core_init(), too.
5026 */
5027
6cbab0d9
RM		 5028#ifdef CONFIG_B43_SSB
5029 if (dev->dev->bus_type == B43_BUS_SSB &&
5030 dev->dev->sdev->bus->bustype == SSB_BUSTYPE_PCI)
5031 pdev = dev->dev->sdev->bus->host_pci;
5032#endif
5033
24ca39d6 5034 err = b43_bus_powerup(dev, 0);
e4d6b795
MB		 5035 if (err) {
5036 b43err(wl, "Bus powerup failed\n");
5037 goto out;
5038 }
e4d6b795 5039
6cbab0d9
RM		 5040 /* Get the PHY type. */
5041 switch (dev->dev->bus_type) {
42c9a458
RM		 5042#ifdef CONFIG_B43_BCMA
5043 case B43_BUS_BCMA:
40c62269
RM		 5044 tmp = bcma_aread32(dev->dev->bdev, BCMA_IOST);
5045 have_2ghz_phy = !!(tmp & B43_BCMA_IOST_2G_PHY);
5046 have_5ghz_phy = !!(tmp & B43_BCMA_IOST_5G_PHY);
42c9a458
RM		 5047 break;
5048#endif
6cbab0d9
RM		 5049#ifdef CONFIG_B43_SSB
5050 case B43_BUS_SSB:
5051 if (dev->dev->core_rev >= 5) {
40c62269
RM		 5052 tmp = ssb_read32(dev->dev->sdev, SSB_TMSHIGH);
5053 have_2ghz_phy = !!(tmp & B43_TMSHIGH_HAVE_2GHZ_PHY);
5054 have_5ghz_phy = !!(tmp & B43_TMSHIGH_HAVE_5GHZ_PHY);
6cbab0d9
RM		 5055 } else
5056 B43_WARN_ON(1);
5057 break;
5058#endif
5059 }
e4d6b795 5060
96c755a3 5061 dev->phy.gmode = have_2ghz_phy;
fd4973c5 5062 dev->phy.radio_on = 1;
4da909e7 5063 b43_wireless_core_reset(dev, dev->phy.gmode);
e4d6b795
MB		 5064
5065 err = b43_phy_versioning(dev);
5066 if (err)
21954c36 5067 goto err_powerdown;
e4d6b795
MB		 5068 /* Check if this device supports multiband. */
5069 if (!pdev ||
5070 (pdev->device != 0x4312 &&
5071 pdev->device != 0x4319 && pdev->device != 0x4324)) {
5072 /* No multiband support. */
96c755a3
MB		 5073 have_2ghz_phy = 0;
5074 have_5ghz_phy = 0;
e4d6b795
MB		 5075 switch (dev->phy.type) {
5076 case B43_PHYTYPE_A:
96c755a3 5077 have_5ghz_phy = 1;
e4d6b795 5078 break;
9d86a2d5 5079 case B43_PHYTYPE_LP: //FIXME not always!
86b2892a 5080#if 0 //FIXME enabling 5GHz causes a NULL pointer dereference
9d86a2d5 5081 have_5ghz_phy = 1;
86b2892a 5082#endif
e4d6b795 5083 case B43_PHYTYPE_G:
96c755a3 5084 case B43_PHYTYPE_N:
8b9bda75
RM		 5085 case B43_PHYTYPE_HT:
5086 case B43_PHYTYPE_LCN:
96c755a3 5087 have_2ghz_phy = 1;
e4d6b795
MB		 5088 break;
5089 default:
5090 B43_WARN_ON(1);
5091 }
5092 }
96c755a3
MB		 5093 if (dev->phy.type == B43_PHYTYPE_A) {
5094 /* FIXME */
5095 b43err(wl, "IEEE 802.11a devices are unsupported\n");
5096 err = -EOPNOTSUPP;
5097 goto err_powerdown;
5098 }
2e35af14
MB		 5099 if (1 /* disable A-PHY */) {
5100 /* FIXME: For now we disable the A-PHY on multi-PHY devices. */
9d86a2d5
GS		 5101 if (dev->phy.type != B43_PHYTYPE_N &&
5102 dev->phy.type != B43_PHYTYPE_LP) {
2e35af14
MB		 5103 have_2ghz_phy = 1;
5104 have_5ghz_phy = 0;
5105 }
5106 }
5107
fb11137a
MB		 5108 err = b43_phy_allocate(dev);
5109 if (err)
5110 goto err_powerdown;
5111
96c755a3 5112 dev->phy.gmode = have_2ghz_phy;
4da909e7 5113 b43_wireless_core_reset(dev, dev->phy.gmode);
e4d6b795
MB		 5114
5115 err = b43_validate_chipaccess(dev);
5116 if (err)
fb11137a 5117 goto err_phy_free;
bb1eeff1 5118 err = b43_setup_bands(dev, have_2ghz_phy, have_5ghz_phy);
e4d6b795 5119 if (err)
fb11137a 5120 goto err_phy_free;
e4d6b795
MB		 5121
5122 /* Now set some default "current_dev" */
5123 if (!wl->current_dev)
5124 wl->current_dev = dev;
5125 INIT_WORK(&dev->restart_work, b43_chip_reset);
5126
cb24f57f 5127 dev->phy.ops->switch_analog(dev, 0);
24ca39d6
RM		 5128 b43_device_disable(dev, 0);
5129 b43_bus_may_powerdown(dev);
e4d6b795
MB		 5130
5131out:
5132 return err;
5133
fb11137a
MB		 5134err_phy_free:
5135 b43_phy_free(dev);
e4d6b795 5136err_powerdown:
24ca39d6 5137 b43_bus_may_powerdown(dev);
e4d6b795
MB		 5138 return err;
5139}
5140
482f0538 5141static void b43_one_core_detach(struct b43_bus_dev *dev)
e4d6b795
MB		 5142{
5143 struct b43_wldev *wldev;
5144 struct b43_wl *wl;
5145
3bf0a32e
MB		 5146 /* Do not cancel ieee80211-workqueue based work here.
5147 * See comment in b43_remove(). */
5148
74abacb6 5149 wldev = b43_bus_get_wldev(dev);
e4d6b795 5150 wl = wldev->wl;
e4d6b795
MB		 5151 b43_debugfs_remove_device(wldev);
5152 b43_wireless_core_detach(wldev);
5153 list_del(&wldev->list);
5154 wl->nr_devs--;
74abacb6 5155 b43_bus_set_wldev(dev, NULL);
e4d6b795
MB		 5156 kfree(wldev);
5157}
5158
482f0538 5159static int b43_one_core_attach(struct b43_bus_dev *dev, struct b43_wl *wl)
e4d6b795
MB		 5160{
5161 struct b43_wldev *wldev;
e4d6b795
MB		 5162 int err = -ENOMEM;
5163
e4d6b795
MB		 5164 wldev = kzalloc(sizeof(*wldev), GFP_KERNEL);
5165 if (!wldev)
5166 goto out;
5167
9e3bd919 5168 wldev->use_pio = b43_modparam_pio;
482f0538 5169 wldev->dev = dev;
e4d6b795
MB		 5170 wldev->wl = wl;
5171 b43_set_status(wldev, B43_STAT_UNINIT);
5172 wldev->bad_frames_preempt = modparam_bad_frames_preempt;
e4d6b795
MB		 5173 INIT_LIST_HEAD(&wldev->list);
5174
5175 err = b43_wireless_core_attach(wldev);
5176 if (err)
5177 goto err_kfree_wldev;
5178
5179 list_add(&wldev->list, &wl->devlist);
5180 wl->nr_devs++;
74abacb6 5181 b43_bus_set_wldev(dev, wldev);
e4d6b795
MB		 5182 b43_debugfs_add_device(wldev);
5183
5184 out:
5185 return err;
5186
5187 err_kfree_wldev:
5188 kfree(wldev);
5189 return err;
5190}
5191
9fc38458
MB		 5192#define IS_PDEV(pdev, _vendor, _device, _subvendor, _subdevice) ( \
5193 (pdev->vendor == PCI_VENDOR_ID_##_vendor) && \
5194 (pdev->device == _device) && \
5195 (pdev->subsystem_vendor == PCI_VENDOR_ID_##_subvendor) && \
5196 (pdev->subsystem_device == _subdevice) )
5197
e4d6b795
MB		 5198static void b43_sprom_fixup(struct ssb_bus *bus)
5199{
1855ba78
MB		 5200 struct pci_dev *pdev;
5201
e4d6b795
MB		 5202 /* boardflags workarounds */
5203 if (bus->boardinfo.vendor == SSB_BOARDVENDOR_DELL &&
5204 bus->chip_id == 0x4301 && bus->boardinfo.rev == 0x74)
95de2841 5205 bus->sprom.boardflags_lo |= B43_BFL_BTCOEXIST;
e4d6b795
MB		 5206 if (bus->boardinfo.vendor == PCI_VENDOR_ID_APPLE &&
5207 bus->boardinfo.type == 0x4E && bus->boardinfo.rev > 0x40)
95de2841 5208 bus->sprom.boardflags_lo |= B43_BFL_PACTRL;
1855ba78
MB		 5209 if (bus->bustype == SSB_BUSTYPE_PCI) {
5210 pdev = bus->host_pci;
9fc38458 5211 if (IS_PDEV(pdev, BROADCOM, 0x4318, ASUSTEK, 0x100F) ||
430cd47f 5212 IS_PDEV(pdev, BROADCOM, 0x4320, DELL, 0x0003) ||
570bdfb1 5213 IS_PDEV(pdev, BROADCOM, 0x4320, HP, 0x12f8) ||
9fc38458 5214 IS_PDEV(pdev, BROADCOM, 0x4320, LINKSYS, 0x0015) ||
a58d4522 5215 IS_PDEV(pdev, BROADCOM, 0x4320, LINKSYS, 0x0014) ||
3bb91bff
LF		 5216 IS_PDEV(pdev, BROADCOM, 0x4320, LINKSYS, 0x0013) ||
5217 IS_PDEV(pdev, BROADCOM, 0x4320, MOTOROLA, 0x7010))
1855ba78
MB		 5218 bus->sprom.boardflags_lo &= ~B43_BFL_BTCOEXIST;
5219 }
e4d6b795
MB		 5220}
5221
482f0538 5222static void b43_wireless_exit(struct b43_bus_dev *dev, struct b43_wl *wl)
e4d6b795
MB		 5223{
5224 struct ieee80211_hw *hw = wl->hw;
5225
482f0538 5226 ssb_set_devtypedata(dev->sdev, NULL);
e4d6b795
MB		 5227 ieee80211_free_hw(hw);
5228}
5229
d1507051 5230static struct b43_wl *b43_wireless_init(struct b43_bus_dev *dev)
e4d6b795 5231{
d1507051 5232 struct ssb_sprom *sprom = dev->bus_sprom;
e4d6b795
MB		 5233 struct ieee80211_hw *hw;
5234 struct b43_wl *wl;
2729df25 5235 char chip_name[6];
e4d6b795
MB		 5236
5237 hw = ieee80211_alloc_hw(sizeof(*wl), &b43_hw_ops);
5238 if (!hw) {
5239 b43err(NULL, "Could not allocate ieee80211 device\n");
0355a345 5240 return ERR_PTR(-ENOMEM);
e4d6b795 5241 }
403a3a13 5242 wl = hw_to_b43_wl(hw);
e4d6b795
MB		 5243
5244 /* fill hw info */
605a0bd6 5245 hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
f5c044e5 5246 IEEE80211_HW_SIGNAL_DBM;
566bfe5a 5247
f59ac048
LR		 5248 hw->wiphy->interface_modes =
5249 BIT(NL80211_IFTYPE_AP) |
5250 BIT(NL80211_IFTYPE_MESH_POINT) |
5251 BIT(NL80211_IFTYPE_STATION) |
5252 BIT(NL80211_IFTYPE_WDS) |
5253 BIT(NL80211_IFTYPE_ADHOC);
5254
403a3a13
MB		 5255 hw->queues = modparam_qos ? 4 : 1;
5256 wl->mac80211_initially_registered_queues = hw->queues;
e6a9854b 5257 hw->max_rates = 2;
e4d6b795 5258 SET_IEEE80211_DEV(hw, dev->dev);
95de2841
LF		 5259 if (is_valid_ether_addr(sprom->et1mac))
5260 SET_IEEE80211_PERM_ADDR(hw, sprom->et1mac);
e4d6b795 5261 else
95de2841 5262 SET_IEEE80211_PERM_ADDR(hw, sprom->il0mac);
e4d6b795 5263
403a3a13 5264 /* Initialize struct b43_wl */
e4d6b795 5265 wl->hw = hw;
e4d6b795 5266 mutex_init(&wl->mutex);
36dbd954 5267 spin_lock_init(&wl->hardirq_lock);
e4d6b795 5268 INIT_LIST_HEAD(&wl->devlist);
a82d9922 5269 INIT_WORK(&wl->beacon_update_trigger, b43_beacon_update_trigger_work);
18c8adeb 5270 INIT_WORK(&wl->txpower_adjust_work, b43_phy_txpower_adjust_work);
f5d40eed
MB		 5271 INIT_WORK(&wl->tx_work, b43_tx_work);
5272 skb_queue_head_init(&wl->tx_queue);
e4d6b795 5273
2729df25
RM		 5274 snprintf(chip_name, ARRAY_SIZE(chip_name),
5275 (dev->chip_id > 0x9999) ? "%d" : "%04X", dev->chip_id);
5276 b43info(wl, "Broadcom %s WLAN found (core revision %u)\n", chip_name,
5277 dev->core_rev);
0355a345 5278 return wl;
e4d6b795
MB		 5279}
5280
3c65ab62
RM		 5281#ifdef CONFIG_B43_BCMA
5282static int b43_bcma_probe(struct bcma_device *core)
5283{
397915c3 5284 struct b43_bus_dev *dev;
24aad3f4
RM		 5285 struct b43_wl *wl;
5286 int err;
397915c3
RM		 5287
5288 dev = b43_bus_dev_bcma_init(core);
5289 if (!dev)
5290 return -ENODEV;
5291
24aad3f4
RM		 5292 wl = b43_wireless_init(dev);
5293 if (IS_ERR(wl)) {
5294 err = PTR_ERR(wl);
5295 goto bcma_out;
5296 }
5297
5298 err = b43_one_core_attach(dev, wl);
5299 if (err)
5300 goto bcma_err_wireless_exit;
5301
5302 err = ieee80211_register_hw(wl->hw);
5303 if (err)
5304 goto bcma_err_one_core_detach;
5305 b43_leds_register(wl->current_dev);
5306
5307bcma_out:
5308 return err;
5309
5310bcma_err_one_core_detach:
5311 b43_one_core_detach(dev);
5312bcma_err_wireless_exit:
5313 ieee80211_free_hw(wl->hw);
5314 return err;
3c65ab62
RM		 5315}
5316
5317static void b43_bcma_remove(struct bcma_device *core)
5318{
24aad3f4
RM		 5319 struct b43_wldev *wldev = bcma_get_drvdata(core);
5320 struct b43_wl *wl = wldev->wl;
5321
5322 /* We must cancel any work here before unregistering from ieee80211,
5323 * as the ieee80211 unreg will destroy the workqueue. */
5324 cancel_work_sync(&wldev->restart_work);
5325
5326 /* Restore the queues count before unregistering, because firmware detect
5327 * might have modified it. Restoring is important, so the networking
5328 * stack can properly free resources. */
5329 wl->hw->queues = wl->mac80211_initially_registered_queues;
5330 b43_leds_stop(wldev);
5331 ieee80211_unregister_hw(wl->hw);
5332
5333 b43_one_core_detach(wldev->dev);
5334
5335 b43_leds_unregister(wl);
5336
5337 ieee80211_free_hw(wl->hw);
3c65ab62
RM		 5338}
5339
5340static struct bcma_driver b43_bcma_driver = {
5341 .name = KBUILD_MODNAME,
5342 .id_table = b43_bcma_tbl,
5343 .probe = b43_bcma_probe,
5344 .remove = b43_bcma_remove,
5345};
5346#endif
5347
aec7ffdf 5348#ifdef CONFIG_B43_SSB
aa63418a
RM		 5349static
5350int b43_ssb_probe(struct ssb_device *sdev, const struct ssb_device_id *id)
e4d6b795 5351{
482f0538 5352 struct b43_bus_dev *dev;
e4d6b795
MB		 5353 struct b43_wl *wl;
5354 int err;
5355 int first = 0;
5356
482f0538 5357 dev = b43_bus_dev_ssb_init(sdev);
5b49b35a
DC		 5358 if (!dev)
5359 return -ENOMEM;
482f0538 5360
aa63418a 5361 wl = ssb_get_devtypedata(sdev);
e4d6b795
MB		 5362 if (!wl) {
5363 /* Probing the first core. Must setup common struct b43_wl */
5364 first = 1;
aa63418a 5365 b43_sprom_fixup(sdev->bus);
d1507051 5366 wl = b43_wireless_init(dev);
0355a345
RM		 5367 if (IS_ERR(wl)) {
5368 err = PTR_ERR(wl);
e4d6b795 5369 goto out;
0355a345 5370 }
aa63418a
RM		 5371 ssb_set_devtypedata(sdev, wl);
5372 B43_WARN_ON(ssb_get_devtypedata(sdev) != wl);
e4d6b795
MB		 5373 }
5374 err = b43_one_core_attach(dev, wl);
5375 if (err)
5376 goto err_wireless_exit;
5377
5378 if (first) {
5379 err = ieee80211_register_hw(wl->hw);
5380 if (err)
5381 goto err_one_core_detach;
a78b3bb2 5382 b43_leds_register(wl->current_dev);
e4d6b795
MB		 5383 }
5384
5385 out:
5386 return err;
5387
5388 err_one_core_detach:
5389 b43_one_core_detach(dev);
5390 err_wireless_exit:
5391 if (first)
5392 b43_wireless_exit(dev, wl);
5393 return err;
5394}
5395
aa63418a 5396static void b43_ssb_remove(struct ssb_device *sdev)
e4d6b795 5397{
aa63418a
RM		 5398 struct b43_wl *wl = ssb_get_devtypedata(sdev);
5399 struct b43_wldev *wldev = ssb_get_drvdata(sdev);
e61b52d1 5400 struct b43_bus_dev *dev = wldev->dev;
e4d6b795 5401
3bf0a32e
MB		 5402 /* We must cancel any work here before unregistering from ieee80211,
5403 * as the ieee80211 unreg will destroy the workqueue. */
5404 cancel_work_sync(&wldev->restart_work);
5405
e4d6b795 5406 B43_WARN_ON(!wl);
403a3a13
MB		 5407 if (wl->current_dev == wldev) {
5408 /* Restore the queues count before unregistering, because firmware detect
5409 * might have modified it. Restoring is important, so the networking
5410 * stack can properly free resources. */
5411 wl->hw->queues = wl->mac80211_initially_registered_queues;
82905ace 5412 b43_leds_stop(wldev);
e4d6b795 5413 ieee80211_unregister_hw(wl->hw);
403a3a13 5414 }
e4d6b795 5415
e61b52d1 5416 b43_one_core_detach(dev);
e4d6b795
MB		 5417
5418 if (list_empty(&wl->devlist)) {
727c9885 5419 b43_leds_unregister(wl);
e4d6b795
MB		 5420 /* Last core on the chip unregistered.
5421 * We can destroy common struct b43_wl.
5422 */
e61b52d1 5423 b43_wireless_exit(dev, wl);
e4d6b795
MB		 5424 }
5425}
5426
aec7ffdf
RM		 5427static struct ssb_driver b43_ssb_driver = {
5428 .name = KBUILD_MODNAME,
5429 .id_table = b43_ssb_tbl,
5430 .probe = b43_ssb_probe,
5431 .remove = b43_ssb_remove,
5432};
5433#endif /* CONFIG_B43_SSB */
5434
e4d6b795
MB		 5435/* Perform a hardware reset. This can be called from any context. */
5436void b43_controller_restart(struct b43_wldev *dev, const char *reason)
5437{
5438 /* Must avoid requeueing, if we are in shutdown. */
5439 if (b43_status(dev) < B43_STAT_INITIALIZED)
5440 return;
5441 b43info(dev->wl, "Controller RESET (%s) ...\n", reason);
42935eca 5442 ieee80211_queue_work(dev->wl->hw, &dev->restart_work);
e4d6b795
MB		 5443}
5444
26bc783f
MB		 5445static void b43_print_driverinfo(void)
5446{
5447 const char *feat_pci = "", *feat_pcmcia = "", *feat_nphy = "",
3dbba8e2 5448 *feat_leds = "", *feat_sdio = "";
26bc783f
MB		 5449
5450#ifdef CONFIG_B43_PCI_AUTOSELECT
5451 feat_pci = "P";
5452#endif
5453#ifdef CONFIG_B43_PCMCIA
5454 feat_pcmcia = "M";
5455#endif
692d2c0f 5456#ifdef CONFIG_B43_PHY_N
26bc783f
MB		 5457 feat_nphy = "N";
5458#endif
5459#ifdef CONFIG_B43_LEDS
5460 feat_leds = "L";
3dbba8e2
AH		 5461#endif
5462#ifdef CONFIG_B43_SDIO
5463 feat_sdio = "S";
26bc783f
MB		 5464#endif
5465 printk(KERN_INFO "Broadcom 43xx driver loaded "
8b0be90c 5466 "[ Features: %s%s%s%s%s ]\n",
26bc783f 5467 feat_pci, feat_pcmcia, feat_nphy,
3dbba8e2 5468 feat_leds, feat_sdio);
26bc783f
MB		 5469}
5470
e4d6b795
MB		 5471static int __init b43_init(void)
5472{
5473 int err;
5474
5475 b43_debugfs_init();
5476 err = b43_pcmcia_init();
5477 if (err)
5478 goto err_dfs_exit;
3dbba8e2 5479 err = b43_sdio_init();
e4d6b795
MB		 5480 if (err)
5481 goto err_pcmcia_exit;
3c65ab62
RM		 5482#ifdef CONFIG_B43_BCMA
5483 err = bcma_driver_register(&b43_bcma_driver);
3dbba8e2
AH		 5484 if (err)
5485 goto err_sdio_exit;
3c65ab62 5486#endif
aec7ffdf 5487#ifdef CONFIG_B43_SSB
3c65ab62
RM		 5488 err = ssb_driver_register(&b43_ssb_driver);
5489 if (err)
5490 goto err_bcma_driver_exit;
aec7ffdf 5491#endif
26bc783f 5492 b43_print_driverinfo();
e4d6b795
MB		 5493
5494 return err;
5495
aec7ffdf 5496#ifdef CONFIG_B43_SSB
3c65ab62 5497err_bcma_driver_exit:
aec7ffdf 5498#endif
3c65ab62
RM		 5499#ifdef CONFIG_B43_BCMA
5500 bcma_driver_unregister(&b43_bcma_driver);
3dbba8e2 5501err_sdio_exit:
3c65ab62 5502#endif
3dbba8e2 5503 b43_sdio_exit();
e4d6b795
MB		 5504err_pcmcia_exit:
5505 b43_pcmcia_exit();
5506err_dfs_exit:
5507 b43_debugfs_exit();
5508 return err;
5509}
5510
5511static void __exit b43_exit(void)
5512{
aec7ffdf 5513#ifdef CONFIG_B43_SSB
e4d6b795 5514 ssb_driver_unregister(&b43_ssb_driver);
aec7ffdf 5515#endif
3c65ab62
RM		 5516#ifdef CONFIG_B43_BCMA
5517 bcma_driver_unregister(&b43_bcma_driver);
5518#endif
3dbba8e2 5519 b43_sdio_exit();
e4d6b795
MB		 5520 b43_pcmcia_exit();
5521 b43_debugfs_exit();
5522}
5523
5524module_init(b43_init)
5525module_exit(b43_exit)
Ubuntu Hirsute Linux kernel mirror