main.c 146.3 KB
Newer Older
1 2 3 4 5
/*

  Broadcom B43 wireless driver

  Copyright (c) 2005 Martin Langer <martin-langer@gmx.de>
6
  Copyright (c) 2005 Stefano Brivio <stefano.brivio@polimi.it>
M
Michael Büsch 已提交
7
  Copyright (c) 2005-2009 Michael Buesch <m@bues.ch>
8 9
  Copyright (c) 2005 Danny van Dyk <kugelfang@gentoo.org>
  Copyright (c) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
10
  Copyright (c) 2010-2011 Rafał Miłecki <zajec5@gmail.com>
11

12 13 14
  SDIO support
  Copyright (c) 2009 Albert Herranz <albert_herranz@yahoo.es>

15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
  Some parts of the code in this file are derived from the ipw2200
  driver  Copyright(c) 2003 - 2004 Intel Corporation.

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; see the file COPYING.  If not, write to
  the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
  Boston, MA 02110-1301, USA.

*/

#include <linux/delay.h>
#include <linux/init.h>
37
#include <linux/module.h>
38 39 40 41 42
#include <linux/if_arp.h>
#include <linux/etherdevice.h>
#include <linux/firmware.h>
#include <linux/workqueue.h>
#include <linux/skbuff.h>
43
#include <linux/io.h>
44
#include <linux/dma-mapping.h>
45
#include <linux/slab.h>
46 47 48 49 50
#include <asm/unaligned.h>

#include "b43.h"
#include "main.h"
#include "debugfs.h"
M
Michael Buesch 已提交
51 52
#include "phy_common.h"
#include "phy_g.h"
53
#include "phy_n.h"
54
#include "dma.h"
55
#include "pio.h"
56 57 58 59
#include "sysfs.h"
#include "xmit.h"
#include "lo.h"
#include "pcmcia.h"
60 61
#include "sdio.h"
#include <linux/mmc/sdio_func.h>
62 63 64 65 66

MODULE_DESCRIPTION("Broadcom B43 wireless driver");
MODULE_AUTHOR("Martin Langer");
MODULE_AUTHOR("Stefano Brivio");
MODULE_AUTHOR("Michael Buesch");
67
MODULE_AUTHOR("Gábor Stefanik");
68
MODULE_AUTHOR("Rafał Miłecki");
69 70
MODULE_LICENSE("GPL");

71 72 73 74
MODULE_FIRMWARE("b43/ucode11.fw");
MODULE_FIRMWARE("b43/ucode13.fw");
MODULE_FIRMWARE("b43/ucode14.fw");
MODULE_FIRMWARE("b43/ucode15.fw");
75
MODULE_FIRMWARE("b43/ucode16_mimo.fw");
76 77
MODULE_FIRMWARE("b43/ucode5.fw");
MODULE_FIRMWARE("b43/ucode9.fw");
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95

static int modparam_bad_frames_preempt;
module_param_named(bad_frames_preempt, modparam_bad_frames_preempt, int, 0444);
MODULE_PARM_DESC(bad_frames_preempt,
		 "enable(1) / disable(0) Bad Frames Preemption");

static char modparam_fwpostfix[16];
module_param_string(fwpostfix, modparam_fwpostfix, 16, 0444);
MODULE_PARM_DESC(fwpostfix, "Postfix for the .fw files to load.");

static int modparam_hwpctl;
module_param_named(hwpctl, modparam_hwpctl, int, 0444);
MODULE_PARM_DESC(hwpctl, "Enable hardware-side power control (default off)");

static int modparam_nohwcrypt;
module_param_named(nohwcrypt, modparam_nohwcrypt, int, 0444);
MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption.");

G
gregor kowski 已提交
96 97 98 99
static int modparam_hwtkip;
module_param_named(hwtkip, modparam_hwtkip, int, 0444);
MODULE_PARM_DESC(hwtkip, "Enable hardware tkip.");

M
Michael Buesch 已提交
100 101
static int modparam_qos = 1;
module_param_named(qos, modparam_qos, int, 0444);
M
Michael Buesch 已提交
102 103
MODULE_PARM_DESC(qos, "Enable QOS support (default on)");

104 105
static int modparam_btcoex = 1;
module_param_named(btcoex, modparam_btcoex, int, 0444);
106
MODULE_PARM_DESC(btcoex, "Enable Bluetooth coexistence (default on)");
107

108 109 110 111
int b43_modparam_verbose = B43_VERBOSITY_DEFAULT;
module_param_named(verbose, b43_modparam_verbose, int, 0644);
MODULE_PARM_DESC(verbose, "Log message verbosity: 0=error, 1=warn, 2=info(default), 3=debug");

112
static int b43_modparam_pio = 0;
113 114
module_param_named(pio, b43_modparam_pio, int, 0644);
MODULE_PARM_DESC(pio, "Use PIO accesses by default: 0=DMA, 1=PIO");
M
Michael Buesch 已提交
115

116 117 118 119
static int modparam_allhwsupport = !IS_ENABLED(CONFIG_BRCMSMAC);
module_param_named(allhwsupport, modparam_allhwsupport, int, 0444);
MODULE_PARM_DESC(allhwsupport, "Enable support for all hardware (even it if overlaps with the brcmsmac driver)");

120 121
#ifdef CONFIG_B43_BCMA
static const struct bcma_device_id b43_bcma_tbl[] = {
122
	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x11, BCMA_ANY_CLASS),
123 124 125 126 127 128 129 130
	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x17, BCMA_ANY_CLASS),
	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x18, BCMA_ANY_CLASS),
	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_80211, 0x1D, BCMA_ANY_CLASS),
	BCMA_CORETABLE_END
};
MODULE_DEVICE_TABLE(bcma, b43_bcma_tbl);
#endif

131
#ifdef CONFIG_B43_SSB
132 133 134 135 136 137
static const struct ssb_device_id b43_ssb_tbl[] = {
	SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 5),
	SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 6),
	SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 7),
	SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 9),
	SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 10),
M
Michael Buesch 已提交
138
	SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 11),
139
	SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 12),
140
	SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 13),
141
	SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 15),
J
Johannes Berg 已提交
142
	SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 16),
143 144 145
	SSB_DEVTABLE_END
};
MODULE_DEVICE_TABLE(ssb, b43_ssb_tbl);
146
#endif
147 148 149 150 151 152

/* Channel and ratetables are shared for all devices.
 * They can't be const, because ieee80211 puts some precalculated
 * data in there. This data is the same for all devices, so we don't
 * get concurrency issues */
#define RATETAB_ENT(_rateid, _flags) \
153 154 155 156
	{								\
		.bitrate	= B43_RATE_TO_BASE100KBPS(_rateid),	\
		.hw_value	= (_rateid),				\
		.flags		= (_flags),				\
157
	}
158 159 160 161 162

/*
 * NOTE: When changing this, sync with xmit.c's
 *	 b43_plcp_get_bitrate_idx_* functions!
 */
163
static struct ieee80211_rate __b43_ratetable[] = {
164 165 166 167 168 169 170 171 172 173 174 175
	RATETAB_ENT(B43_CCK_RATE_1MB, 0),
	RATETAB_ENT(B43_CCK_RATE_2MB, IEEE80211_RATE_SHORT_PREAMBLE),
	RATETAB_ENT(B43_CCK_RATE_5MB, IEEE80211_RATE_SHORT_PREAMBLE),
	RATETAB_ENT(B43_CCK_RATE_11MB, IEEE80211_RATE_SHORT_PREAMBLE),
	RATETAB_ENT(B43_OFDM_RATE_6MB, 0),
	RATETAB_ENT(B43_OFDM_RATE_9MB, 0),
	RATETAB_ENT(B43_OFDM_RATE_12MB, 0),
	RATETAB_ENT(B43_OFDM_RATE_18MB, 0),
	RATETAB_ENT(B43_OFDM_RATE_24MB, 0),
	RATETAB_ENT(B43_OFDM_RATE_36MB, 0),
	RATETAB_ENT(B43_OFDM_RATE_48MB, 0),
	RATETAB_ENT(B43_OFDM_RATE_54MB, 0),
176 177 178 179 180 181 182 183 184
};

#define b43_a_ratetable		(__b43_ratetable + 4)
#define b43_a_ratetable_size	8
#define b43_b_ratetable		(__b43_ratetable + 0)
#define b43_b_ratetable_size	4
#define b43_g_ratetable		(__b43_ratetable + 0)
#define b43_g_ratetable_size	12

M
Michael Buesch 已提交
185 186 187 188 189 190 191 192
#define CHAN4G(_channel, _freq, _flags) {			\
	.band			= IEEE80211_BAND_2GHZ,		\
	.center_freq		= (_freq),			\
	.hw_value		= (_channel),			\
	.flags			= (_flags),			\
	.max_antenna_gain	= 0,				\
	.max_power		= 30,				\
}
193
static struct ieee80211_channel b43_2ghz_chantable[] = {
M
Michael Buesch 已提交
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
	CHAN4G(1, 2412, 0),
	CHAN4G(2, 2417, 0),
	CHAN4G(3, 2422, 0),
	CHAN4G(4, 2427, 0),
	CHAN4G(5, 2432, 0),
	CHAN4G(6, 2437, 0),
	CHAN4G(7, 2442, 0),
	CHAN4G(8, 2447, 0),
	CHAN4G(9, 2452, 0),
	CHAN4G(10, 2457, 0),
	CHAN4G(11, 2462, 0),
	CHAN4G(12, 2467, 0),
	CHAN4G(13, 2472, 0),
	CHAN4G(14, 2484, 0),
};
#undef CHAN4G

#define CHAN5G(_channel, _flags) {				\
	.band			= IEEE80211_BAND_5GHZ,		\
	.center_freq		= 5000 + (5 * (_channel)),	\
	.hw_value		= (_channel),			\
	.flags			= (_flags),			\
	.max_antenna_gain	= 0,				\
	.max_power		= 30,				\
}
static struct ieee80211_channel b43_5ghz_nphy_chantable[] = {
	CHAN5G(32, 0),		CHAN5G(34, 0),
	CHAN5G(36, 0),		CHAN5G(38, 0),
	CHAN5G(40, 0),		CHAN5G(42, 0),
	CHAN5G(44, 0),		CHAN5G(46, 0),
	CHAN5G(48, 0),		CHAN5G(50, 0),
	CHAN5G(52, 0),		CHAN5G(54, 0),
	CHAN5G(56, 0),		CHAN5G(58, 0),
	CHAN5G(60, 0),		CHAN5G(62, 0),
	CHAN5G(64, 0),		CHAN5G(66, 0),
	CHAN5G(68, 0),		CHAN5G(70, 0),
	CHAN5G(72, 0),		CHAN5G(74, 0),
	CHAN5G(76, 0),		CHAN5G(78, 0),
	CHAN5G(80, 0),		CHAN5G(82, 0),
	CHAN5G(84, 0),		CHAN5G(86, 0),
	CHAN5G(88, 0),		CHAN5G(90, 0),
	CHAN5G(92, 0),		CHAN5G(94, 0),
	CHAN5G(96, 0),		CHAN5G(98, 0),
	CHAN5G(100, 0),		CHAN5G(102, 0),
	CHAN5G(104, 0),		CHAN5G(106, 0),
	CHAN5G(108, 0),		CHAN5G(110, 0),
	CHAN5G(112, 0),		CHAN5G(114, 0),
	CHAN5G(116, 0),		CHAN5G(118, 0),
	CHAN5G(120, 0),		CHAN5G(122, 0),
	CHAN5G(124, 0),		CHAN5G(126, 0),
	CHAN5G(128, 0),		CHAN5G(130, 0),
	CHAN5G(132, 0),		CHAN5G(134, 0),
	CHAN5G(136, 0),		CHAN5G(138, 0),
	CHAN5G(140, 0),		CHAN5G(142, 0),
	CHAN5G(144, 0),		CHAN5G(145, 0),
	CHAN5G(146, 0),		CHAN5G(147, 0),
	CHAN5G(148, 0),		CHAN5G(149, 0),
	CHAN5G(150, 0),		CHAN5G(151, 0),
	CHAN5G(152, 0),		CHAN5G(153, 0),
	CHAN5G(154, 0),		CHAN5G(155, 0),
	CHAN5G(156, 0),		CHAN5G(157, 0),
	CHAN5G(158, 0),		CHAN5G(159, 0),
	CHAN5G(160, 0),		CHAN5G(161, 0),
	CHAN5G(162, 0),		CHAN5G(163, 0),
	CHAN5G(164, 0),		CHAN5G(165, 0),
	CHAN5G(166, 0),		CHAN5G(168, 0),
	CHAN5G(170, 0),		CHAN5G(172, 0),
	CHAN5G(174, 0),		CHAN5G(176, 0),
	CHAN5G(178, 0),		CHAN5G(180, 0),
	CHAN5G(182, 0),		CHAN5G(184, 0),
	CHAN5G(186, 0),		CHAN5G(188, 0),
	CHAN5G(190, 0),		CHAN5G(192, 0),
	CHAN5G(194, 0),		CHAN5G(196, 0),
	CHAN5G(198, 0),		CHAN5G(200, 0),
	CHAN5G(202, 0),		CHAN5G(204, 0),
	CHAN5G(206, 0),		CHAN5G(208, 0),
	CHAN5G(210, 0),		CHAN5G(212, 0),
	CHAN5G(214, 0),		CHAN5G(216, 0),
	CHAN5G(218, 0),		CHAN5G(220, 0),
	CHAN5G(222, 0),		CHAN5G(224, 0),
	CHAN5G(226, 0),		CHAN5G(228, 0),
275 276
};

M
Michael Buesch 已提交
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
static struct ieee80211_channel b43_5ghz_aphy_chantable[] = {
	CHAN5G(34, 0),		CHAN5G(36, 0),
	CHAN5G(38, 0),		CHAN5G(40, 0),
	CHAN5G(42, 0),		CHAN5G(44, 0),
	CHAN5G(46, 0),		CHAN5G(48, 0),
	CHAN5G(52, 0),		CHAN5G(56, 0),
	CHAN5G(60, 0),		CHAN5G(64, 0),
	CHAN5G(100, 0),		CHAN5G(104, 0),
	CHAN5G(108, 0),		CHAN5G(112, 0),
	CHAN5G(116, 0),		CHAN5G(120, 0),
	CHAN5G(124, 0),		CHAN5G(128, 0),
	CHAN5G(132, 0),		CHAN5G(136, 0),
	CHAN5G(140, 0),		CHAN5G(149, 0),
	CHAN5G(153, 0),		CHAN5G(157, 0),
	CHAN5G(161, 0),		CHAN5G(165, 0),
	CHAN5G(184, 0),		CHAN5G(188, 0),
	CHAN5G(192, 0),		CHAN5G(196, 0),
	CHAN5G(200, 0),		CHAN5G(204, 0),
	CHAN5G(208, 0),		CHAN5G(212, 0),
	CHAN5G(216, 0),
};
#undef CHAN5G

static struct ieee80211_supported_band b43_band_5GHz_nphy = {
	.band		= IEEE80211_BAND_5GHZ,
	.channels	= b43_5ghz_nphy_chantable,
	.n_channels	= ARRAY_SIZE(b43_5ghz_nphy_chantable),
	.bitrates	= b43_a_ratetable,
	.n_bitrates	= b43_a_ratetable_size,
306
};
307

M
Michael Buesch 已提交
308 309 310 311 312 313
static struct ieee80211_supported_band b43_band_5GHz_aphy = {
	.band		= IEEE80211_BAND_5GHZ,
	.channels	= b43_5ghz_aphy_chantable,
	.n_channels	= ARRAY_SIZE(b43_5ghz_aphy_chantable),
	.bitrates	= b43_a_ratetable,
	.n_bitrates	= b43_a_ratetable_size,
314
};
315

316
static struct ieee80211_supported_band b43_band_2GHz = {
M
Michael Buesch 已提交
317 318 319 320 321
	.band		= IEEE80211_BAND_2GHZ,
	.channels	= b43_2ghz_chantable,
	.n_channels	= ARRAY_SIZE(b43_2ghz_chantable),
	.bitrates	= b43_g_ratetable,
	.n_bitrates	= b43_g_ratetable_size,
322 323
};

324 325
static void b43_wireless_core_exit(struct b43_wldev *dev);
static int b43_wireless_core_init(struct b43_wldev *dev);
M
Michael Buesch 已提交
326
static struct b43_wldev * b43_wireless_core_stop(struct b43_wldev *dev);
327
static int b43_wireless_core_start(struct b43_wldev *dev);
328 329 330 331
static void b43_op_bss_info_changed(struct ieee80211_hw *hw,
				    struct ieee80211_vif *vif,
				    struct ieee80211_bss_conf *conf,
				    u32 changed);
332 333 334 335 336 337 338 339 340 341 342 343 344 345

static int b43_ratelimit(struct b43_wl *wl)
{
	if (!wl || !wl->current_dev)
		return 1;
	if (b43_status(wl->current_dev) < B43_STAT_STARTED)
		return 1;
	/* We are up and running.
	 * Ratelimit the messages to avoid DoS over the net. */
	return net_ratelimit();
}

void b43info(struct b43_wl *wl, const char *fmt, ...)
{
346
	struct va_format vaf;
347 348
	va_list args;

349 350
	if (b43_modparam_verbose < B43_VERBOSITY_INFO)
		return;
351 352
	if (!b43_ratelimit(wl))
		return;
353

354
	va_start(args, fmt);
355 356 357 358 359 360 361

	vaf.fmt = fmt;
	vaf.va = &args;

	printk(KERN_INFO "b43-%s: %pV",
	       (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan", &vaf);

362 363 364 365 366
	va_end(args);
}

void b43err(struct b43_wl *wl, const char *fmt, ...)
{
367
	struct va_format vaf;
368 369
	va_list args;

370 371
	if (b43_modparam_verbose < B43_VERBOSITY_ERROR)
		return;
372 373
	if (!b43_ratelimit(wl))
		return;
374

375
	va_start(args, fmt);
376 377 378 379 380 381 382

	vaf.fmt = fmt;
	vaf.va = &args;

	printk(KERN_ERR "b43-%s ERROR: %pV",
	       (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan", &vaf);

383 384 385 386 387
	va_end(args);
}

void b43warn(struct b43_wl *wl, const char *fmt, ...)
{
388
	struct va_format vaf;
389 390
	va_list args;

391 392
	if (b43_modparam_verbose < B43_VERBOSITY_WARN)
		return;
393 394
	if (!b43_ratelimit(wl))
		return;
395

396
	va_start(args, fmt);
397 398 399 400 401 402 403

	vaf.fmt = fmt;
	vaf.va = &args;

	printk(KERN_WARNING "b43-%s warning: %pV",
	       (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan", &vaf);

404 405 406 407 408
	va_end(args);
}

void b43dbg(struct b43_wl *wl, const char *fmt, ...)
{
409
	struct va_format vaf;
410 411
	va_list args;

412 413
	if (b43_modparam_verbose < B43_VERBOSITY_DEBUG)
		return;
414

415
	va_start(args, fmt);
416 417 418 419 420 421 422

	vaf.fmt = fmt;
	vaf.va = &args;

	printk(KERN_DEBUG "b43-%s debug: %pV",
	       (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan", &vaf);

423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440
	va_end(args);
}

static void b43_ram_write(struct b43_wldev *dev, u16 offset, u32 val)
{
	u32 macctl;

	B43_WARN_ON(offset % 4 != 0);

	macctl = b43_read32(dev, B43_MMIO_MACCTL);
	if (macctl & B43_MACCTL_BE)
		val = swab32(val);

	b43_write32(dev, B43_MMIO_RAM_CONTROL, offset);
	mmiowb();
	b43_write32(dev, B43_MMIO_RAM_DATA, val);
}

441 442
static inline void b43_shm_control_word(struct b43_wldev *dev,
					u16 routing, u16 offset)
443 444 445 446 447 448 449 450 451 452
{
	u32 control;

	/* "offset" is the WORD offset. */
	control = routing;
	control <<= 16;
	control |= offset;
	b43_write32(dev, B43_MMIO_SHM_CONTROL, control);
}

M
Michael Buesch 已提交
453
u32 b43_shm_read32(struct b43_wldev *dev, u16 routing, u16 offset)
454 455 456 457 458 459 460 461 462 463
{
	u32 ret;

	if (routing == B43_SHM_SHARED) {
		B43_WARN_ON(offset & 0x0001);
		if (offset & 0x0003) {
			/* Unaligned access */
			b43_shm_control_word(dev, routing, offset >> 2);
			ret = b43_read16(dev, B43_MMIO_SHM_DATA_UNALIGNED);
			b43_shm_control_word(dev, routing, (offset >> 2) + 1);
464
			ret |= ((u32)b43_read16(dev, B43_MMIO_SHM_DATA)) << 16;
465

466
			goto out;
467 468 469 470 471
		}
		offset >>= 2;
	}
	b43_shm_control_word(dev, routing, offset);
	ret = b43_read32(dev, B43_MMIO_SHM_DATA);
472
out:
473 474 475
	return ret;
}

M
Michael Buesch 已提交
476
u16 b43_shm_read16(struct b43_wldev *dev, u16 routing, u16 offset)
477 478 479
{
	u16 ret;

480 481 482 483 484 485 486
	if (routing == B43_SHM_SHARED) {
		B43_WARN_ON(offset & 0x0001);
		if (offset & 0x0003) {
			/* Unaligned access */
			b43_shm_control_word(dev, routing, offset >> 2);
			ret = b43_read16(dev, B43_MMIO_SHM_DATA_UNALIGNED);

487
			goto out;
488 489 490 491 492
		}
		offset >>= 2;
	}
	b43_shm_control_word(dev, routing, offset);
	ret = b43_read16(dev, B43_MMIO_SHM_DATA);
493
out:
494 495 496
	return ret;
}

M
Michael Buesch 已提交
497
void b43_shm_write32(struct b43_wldev *dev, u16 routing, u16 offset, u32 value)
498
{
499 500 501 502 503 504
	if (routing == B43_SHM_SHARED) {
		B43_WARN_ON(offset & 0x0001);
		if (offset & 0x0003) {
			/* Unaligned access */
			b43_shm_control_word(dev, routing, offset >> 2);
			b43_write16(dev, B43_MMIO_SHM_DATA_UNALIGNED,
505
				    value & 0xFFFF);
506
			b43_shm_control_word(dev, routing, (offset >> 2) + 1);
507 508
			b43_write16(dev, B43_MMIO_SHM_DATA,
				    (value >> 16) & 0xFFFF);
509
			return;
510 511 512 513 514 515 516
		}
		offset >>= 2;
	}
	b43_shm_control_word(dev, routing, offset);
	b43_write32(dev, B43_MMIO_SHM_DATA, value);
}

M
Michael Buesch 已提交
517
void b43_shm_write16(struct b43_wldev *dev, u16 routing, u16 offset, u16 value)
518
{
519 520 521 522 523 524
	if (routing == B43_SHM_SHARED) {
		B43_WARN_ON(offset & 0x0001);
		if (offset & 0x0003) {
			/* Unaligned access */
			b43_shm_control_word(dev, routing, offset >> 2);
			b43_write16(dev, B43_MMIO_SHM_DATA_UNALIGNED, value);
525
			return;
526 527 528 529 530
		}
		offset >>= 2;
	}
	b43_shm_control_word(dev, routing, offset);
	b43_write16(dev, B43_MMIO_SHM_DATA, value);
531 532
}

533
/* Read HostFlags */
J
John Daiker 已提交
534
u64 b43_hf_read(struct b43_wldev *dev)
535
{
M
Michael Buesch 已提交
536
	u64 ret;
537

R
Rafał Miłecki 已提交
538
	ret = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_HOSTF3);
539
	ret <<= 16;
R
Rafał Miłecki 已提交
540
	ret |= b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_HOSTF2);
M
Michael Buesch 已提交
541
	ret <<= 16;
R
Rafał Miłecki 已提交
542
	ret |= b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_HOSTF1);
543 544 545 546 547

	return ret;
}

/* Write HostFlags */
M
Michael Buesch 已提交
548
void b43_hf_write(struct b43_wldev *dev, u64 value)
549
{
M
Michael Buesch 已提交
550 551 552 553 554
	u16 lo, mi, hi;

	lo = (value & 0x00000000FFFFULL);
	mi = (value & 0x0000FFFF0000ULL) >> 16;
	hi = (value & 0xFFFF00000000ULL) >> 32;
R
Rafał Miłecki 已提交
555 556 557
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_HOSTF1, lo);
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_HOSTF2, mi);
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_HOSTF3, hi);
558 559
}

M
Michael Buesch 已提交
560 561 562 563 564 565 566
/* Read the firmware capabilities bitmask (Opensource firmware only) */
static u16 b43_fwcapa_read(struct b43_wldev *dev)
{
	B43_WARN_ON(!dev->fw.opensource);
	return b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_FWCAPA);
}

567
void b43_tsf_read(struct b43_wldev *dev, u64 *tsf)
568
{
569 570
	u32 low, high;

571
	B43_WARN_ON(dev->dev->core_rev < 3);
572 573 574 575 576 577 578 579 580

	/* The hardware guarantees us an atomic read, if we
	 * read the low register first. */
	low = b43_read32(dev, B43_MMIO_REV3PLUS_TSF_LOW);
	high = b43_read32(dev, B43_MMIO_REV3PLUS_TSF_HIGH);

	*tsf = high;
	*tsf <<= 32;
	*tsf |= low;
581 582 583 584
}

static void b43_time_lock(struct b43_wldev *dev)
{
R
Rafał Miłecki 已提交
585
	b43_maskset32(dev, B43_MMIO_MACCTL, ~0, B43_MACCTL_TBTTHOLD);
586 587 588 589 590 591
	/* Commit the write */
	b43_read32(dev, B43_MMIO_MACCTL);
}

static void b43_time_unlock(struct b43_wldev *dev)
{
R
Rafał Miłecki 已提交
592
	b43_maskset32(dev, B43_MMIO_MACCTL, ~B43_MACCTL_TBTTHOLD, 0);
593 594 595 596 597 598
	/* Commit the write */
	b43_read32(dev, B43_MMIO_MACCTL);
}

static void b43_tsf_write_locked(struct b43_wldev *dev, u64 tsf)
{
599 600
	u32 low, high;

601
	B43_WARN_ON(dev->dev->core_rev < 3);
602 603 604 605 606 607 608 609 610

	low = tsf;
	high = (tsf >> 32);
	/* The hardware guarantees us an atomic write, if we
	 * write the low register first. */
	b43_write32(dev, B43_MMIO_REV3PLUS_TSF_LOW, low);
	mmiowb();
	b43_write32(dev, B43_MMIO_REV3PLUS_TSF_HIGH, high);
	mmiowb();
611 612 613 614 615 616 617 618 619 620
}

void b43_tsf_write(struct b43_wldev *dev, u64 tsf)
{
	b43_time_lock(dev);
	b43_tsf_write_locked(dev, tsf);
	b43_time_unlock(dev);
}

static
J
John Daiker 已提交
621
void b43_macfilter_set(struct b43_wldev *dev, u16 offset, const u8 *mac)
622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
{
	static const u8 zero_addr[ETH_ALEN] = { 0 };
	u16 data;

	if (!mac)
		mac = zero_addr;

	offset |= 0x0020;
	b43_write16(dev, B43_MMIO_MACFILTER_CONTROL, offset);

	data = mac[0];
	data |= mac[1] << 8;
	b43_write16(dev, B43_MMIO_MACFILTER_DATA, data);
	data = mac[2];
	data |= mac[3] << 8;
	b43_write16(dev, B43_MMIO_MACFILTER_DATA, data);
	data = mac[4];
	data |= mac[5] << 8;
	b43_write16(dev, B43_MMIO_MACFILTER_DATA, data);
}

static void b43_write_mac_bssid_templates(struct b43_wldev *dev)
{
	const u8 *mac;
	const u8 *bssid;
	u8 mac_bssid[ETH_ALEN * 2];
	int i;
	u32 tmp;

	bssid = dev->wl->bssid;
	mac = dev->wl->mac_addr;

	b43_macfilter_set(dev, B43_MACFILTER_BSSID, bssid);

	memcpy(mac_bssid, mac, ETH_ALEN);
	memcpy(mac_bssid + ETH_ALEN, bssid, ETH_ALEN);

	/* Write our MAC address and BSSID to template ram */
	for (i = 0; i < ARRAY_SIZE(mac_bssid); i += sizeof(u32)) {
		tmp = (u32) (mac_bssid[i + 0]);
		tmp |= (u32) (mac_bssid[i + 1]) << 8;
		tmp |= (u32) (mac_bssid[i + 2]) << 16;
		tmp |= (u32) (mac_bssid[i + 3]) << 24;
		b43_ram_write(dev, 0x20 + i, tmp);
	}
}

669
static void b43_upload_card_macaddress(struct b43_wldev *dev)
670 671
{
	b43_write_mac_bssid_templates(dev);
672
	b43_macfilter_set(dev, B43_MACFILTER_SELF, dev->wl->mac_addr);
673 674 675 676 677
}

static void b43_set_slot_time(struct b43_wldev *dev, u16 slot_time)
{
	/* slot_time is in usec. */
L
Larry Finger 已提交
678 679
	/* This test used to exit for all but a G PHY. */
	if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
680
		return;
L
Larry Finger 已提交
681 682 683 684 685 686 687 688
	b43_write16(dev, B43_MMIO_IFSSLOT, 510 + slot_time);
	/* Shared memory location 0x0010 is the slot time and should be
	 * set to slot_time; however, this register is initially 0 and changing
	 * the value adversely affects the transmit rate for BCM4311
	 * devices. Until this behavior is unterstood, delete this step
	 *
	 * b43_shm_write16(dev, B43_SHM_SHARED, 0x0010, slot_time);
	 */
689 690 691 692 693 694 695 696 697 698 699 700 701
}

static void b43_short_slot_timing_enable(struct b43_wldev *dev)
{
	b43_set_slot_time(dev, 9);
}

static void b43_short_slot_timing_disable(struct b43_wldev *dev)
{
	b43_set_slot_time(dev, 20);
}

/* DummyTransmission function, as documented on
702
 * http://bcm-v4.sipsolutions.net/802.11/DummyTransmission
703
 */
704
void b43_dummy_transmission(struct b43_wldev *dev, bool ofdm, bool pa_on)
705 706 707 708 709 710 711 712 713 714 715 716
{
	struct b43_phy *phy = &dev->phy;
	unsigned int i, max_loop;
	u16 value;
	u32 buffer[5] = {
		0x00000000,
		0x00D40000,
		0x00000000,
		0x01000000,
		0x00000000,
	};

717
	if (ofdm) {
718 719
		max_loop = 0x1E;
		buffer[0] = 0x000201CC;
720
	} else {
721 722 723 724 725 726 727
		max_loop = 0xFA;
		buffer[0] = 0x000B846E;
	}

	for (i = 0; i < 5; i++)
		b43_ram_write(dev, i * 4, buffer[i]);

R
Rafał Miłecki 已提交
728 729
	b43_write16(dev, B43_MMIO_XMTSEL, 0x0000);

730
	if (dev->dev->core_rev < 11)
R
Rafał Miłecki 已提交
731
		b43_write16(dev, B43_MMIO_WEPCTL, 0x0000);
732
	else
R
Rafał Miłecki 已提交
733 734
		b43_write16(dev, B43_MMIO_WEPCTL, 0x0100);

735
	value = (ofdm ? 0x41 : 0x40);
R
Rafał Miłecki 已提交
736
	b43_write16(dev, B43_MMIO_TXE0_PHYCTL, value);
R
Rafał Miłecki 已提交
737 738
	if (phy->type == B43_PHYTYPE_N || phy->type == B43_PHYTYPE_LP ||
	    phy->type == B43_PHYTYPE_LCN)
R
Rafał Miłecki 已提交
739 740 741 742 743 744 745 746 747
		b43_write16(dev, B43_MMIO_TXE0_PHYCTL1, 0x1A02);

	b43_write16(dev, B43_MMIO_TXE0_WM_0, 0x0000);
	b43_write16(dev, B43_MMIO_TXE0_WM_1, 0x0000);

	b43_write16(dev, B43_MMIO_XMTTPLATETXPTR, 0x0000);
	b43_write16(dev, B43_MMIO_XMTTXCNT, 0x0014);
	b43_write16(dev, B43_MMIO_XMTSEL, 0x0826);
	b43_write16(dev, B43_MMIO_TXE0_CTL, 0x0000);
R
Rafał Miłecki 已提交
748 749 750

	if (!pa_on && phy->type == B43_PHYTYPE_N)
		; /*b43_nphy_pa_override(dev, false) */
751 752 753

	switch (phy->type) {
	case B43_PHYTYPE_N:
R
Rafał Miłecki 已提交
754
	case B43_PHYTYPE_LCN:
R
Rafał Miłecki 已提交
755
		b43_write16(dev, B43_MMIO_TXE0_AUX, 0x00D0);
756 757
		break;
	case B43_PHYTYPE_LP:
R
Rafał Miłecki 已提交
758
		b43_write16(dev, B43_MMIO_TXE0_AUX, 0x0050);
759 760
		break;
	default:
R
Rafał Miłecki 已提交
761
		b43_write16(dev, B43_MMIO_TXE0_AUX, 0x0030);
762
	}
R
Rafał Miłecki 已提交
763
	b43_read16(dev, B43_MMIO_TXE0_AUX);
764 765 766 767

	if (phy->radio_ver == 0x2050 && phy->radio_rev <= 0x5)
		b43_radio_write16(dev, 0x0051, 0x0017);
	for (i = 0x00; i < max_loop; i++) {
R
Rafał Miłecki 已提交
768
		value = b43_read16(dev, B43_MMIO_TXE0_STATUS);
769 770 771 772 773
		if (value & 0x0080)
			break;
		udelay(10);
	}
	for (i = 0x00; i < 0x0A; i++) {
R
Rafał Miłecki 已提交
774
		value = b43_read16(dev, B43_MMIO_TXE0_STATUS);
775 776 777 778
		if (value & 0x0400)
			break;
		udelay(10);
	}
779
	for (i = 0x00; i < 0x19; i++) {
R
Rafał Miłecki 已提交
780
		value = b43_read16(dev, B43_MMIO_IFSSTAT);
781 782 783 784 785 786 787 788 789
		if (!(value & 0x0100))
			break;
		udelay(10);
	}
	if (phy->radio_ver == 0x2050 && phy->radio_rev <= 0x5)
		b43_radio_write16(dev, 0x0051, 0x0037);
}

static void key_write(struct b43_wldev *dev,
J
John Daiker 已提交
790
		      u8 index, u8 algorithm, const u8 *key)
791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
{
	unsigned int i;
	u32 offset;
	u16 value;
	u16 kidx;

	/* Key index/algo block */
	kidx = b43_kidx_to_fw(dev, index);
	value = ((kidx << 4) | algorithm);
	b43_shm_write16(dev, B43_SHM_SHARED,
			B43_SHM_SH_KEYIDXBLOCK + (kidx * 2), value);

	/* Write the key to the Key Table Pointer offset */
	offset = dev->ktp + (index * B43_SEC_KEYSIZE);
	for (i = 0; i < B43_SEC_KEYSIZE; i += 2) {
		value = key[i];
		value |= (u16) (key[i + 1]) << 8;
		b43_shm_write16(dev, B43_SHM_SHARED, offset + i, value);
	}
}

J
John Daiker 已提交
812
static void keymac_write(struct b43_wldev *dev, u8 index, const u8 *addr)
813 814
{
	u32 addrtmp[2] = { 0, 0, };
815
	u8 pairwise_keys_start = B43_NR_GROUP_KEYS * 2;
816 817

	if (b43_new_kidx_api(dev))
818
		pairwise_keys_start = B43_NR_GROUP_KEYS;
819

820 821
	B43_WARN_ON(index < pairwise_keys_start);
	/* We have four default TX keys and possibly four default RX keys.
822 823 824 825
	 * Physical mac 0 is mapped to physical key 4 or 8, depending
	 * on the firmware version.
	 * So we must adjust the index here.
	 */
826 827
	index -= pairwise_keys_start;
	B43_WARN_ON(index >= B43_NR_PAIRWISE_KEYS);
828 829 830 831 832 833 834 835 836 837

	if (addr) {
		addrtmp[0] = addr[0];
		addrtmp[0] |= ((u32) (addr[1]) << 8);
		addrtmp[0] |= ((u32) (addr[2]) << 16);
		addrtmp[0] |= ((u32) (addr[3]) << 24);
		addrtmp[1] = addr[4];
		addrtmp[1] |= ((u32) (addr[5]) << 8);
	}

838 839 840 841 842
	/* Receive match transmitter address (RCMTA) mechanism */
	b43_shm_write32(dev, B43_SHM_RCMTA,
			(index * 2) + 0, addrtmp[0]);
	b43_shm_write16(dev, B43_SHM_RCMTA,
			(index * 2) + 1, addrtmp[1]);
843 844
}

G
gregor kowski 已提交
845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898
/* The ucode will use phase1 key with TEK key to decrypt rx packets.
 * When a packet is received, the iv32 is checked.
 * - if it doesn't the packet is returned without modification (and software
 *   decryption can be done). That's what happen when iv16 wrap.
 * - if it does, the rc4 key is computed, and decryption is tried.
 *   Either it will success and B43_RX_MAC_DEC is returned,
 *   either it fails and B43_RX_MAC_DEC|B43_RX_MAC_DECERR is returned
 *   and the packet is not usable (it got modified by the ucode).
 * So in order to never have B43_RX_MAC_DECERR, we should provide
 * a iv32 and phase1key that match. Because we drop packets in case of
 * B43_RX_MAC_DECERR, if we have a correct iv32 but a wrong phase1key, all
 * packets will be lost without higher layer knowing (ie no resync possible
 * until next wrap).
 *
 * NOTE : this should support 50 key like RCMTA because
 * (B43_SHM_SH_KEYIDXBLOCK - B43_SHM_SH_TKIPTSCTTAK)/14 = 50
 */
static void rx_tkip_phase1_write(struct b43_wldev *dev, u8 index, u32 iv32,
		u16 *phase1key)
{
	unsigned int i;
	u32 offset;
	u8 pairwise_keys_start = B43_NR_GROUP_KEYS * 2;

	if (!modparam_hwtkip)
		return;

	if (b43_new_kidx_api(dev))
		pairwise_keys_start = B43_NR_GROUP_KEYS;

	B43_WARN_ON(index < pairwise_keys_start);
	/* We have four default TX keys and possibly four default RX keys.
	 * Physical mac 0 is mapped to physical key 4 or 8, depending
	 * on the firmware version.
	 * So we must adjust the index here.
	 */
	index -= pairwise_keys_start;
	B43_WARN_ON(index >= B43_NR_PAIRWISE_KEYS);

	if (b43_debug(dev, B43_DBG_KEYS)) {
		b43dbg(dev->wl, "rx_tkip_phase1_write : idx 0x%x, iv32 0x%x\n",
				index, iv32);
	}
	/* Write the key to the  RX tkip shared mem */
	offset = B43_SHM_SH_TKIPTSCTTAK + index * (10 + 4);
	for (i = 0; i < 10; i += 2) {
		b43_shm_write16(dev, B43_SHM_SHARED, offset + i,
				phase1key ? phase1key[i / 2] : 0);
	}
	b43_shm_write16(dev, B43_SHM_SHARED, offset + i, iv32);
	b43_shm_write16(dev, B43_SHM_SHARED, offset + i + 2, iv32 >> 16);
}

static void b43_op_update_tkip_key(struct ieee80211_hw *hw,
899 900 901 902
				   struct ieee80211_vif *vif,
				   struct ieee80211_key_conf *keyconf,
				   struct ieee80211_sta *sta,
				   u32 iv32, u16 *phase1key)
G
gregor kowski 已提交
903 904 905 906 907 908 909 910
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
	struct b43_wldev *dev;
	int index = keyconf->hw_key_idx;

	if (B43_WARN_ON(!modparam_hwtkip))
		return;

911 912 913
	/* This is only called from the RX path through mac80211, where
	 * our mutex is already locked. */
	B43_WARN_ON(!mutex_is_locked(&wl->mutex));
G
gregor kowski 已提交
914
	dev = wl->current_dev;
915
	B43_WARN_ON(!dev || b43_status(dev) < B43_STAT_INITIALIZED);
G
gregor kowski 已提交
916 917 918 919

	keymac_write(dev, index, NULL);	/* First zero out mac to avoid race */

	rx_tkip_phase1_write(dev, index, iv32, phase1key);
920 921
	/* only pairwise TKIP keys are supported right now */
	if (WARN_ON(!sta))
922
		return;
923
	keymac_write(dev, index, sta->addr);
G
gregor kowski 已提交
924 925
}

926 927
static void do_key_write(struct b43_wldev *dev,
			 u8 index, u8 algorithm,
J
John Daiker 已提交
928
			 const u8 *key, size_t key_len, const u8 *mac_addr)
929 930
{
	u8 buf[B43_SEC_KEYSIZE] = { 0, };
931
	u8 pairwise_keys_start = B43_NR_GROUP_KEYS * 2;
932 933

	if (b43_new_kidx_api(dev))
934
		pairwise_keys_start = B43_NR_GROUP_KEYS;
935

936
	B43_WARN_ON(index >= ARRAY_SIZE(dev->key));
937 938
	B43_WARN_ON(key_len > B43_SEC_KEYSIZE);

939
	if (index >= pairwise_keys_start)
940
		keymac_write(dev, index, NULL);	/* First zero out mac. */
G
gregor kowski 已提交
941 942 943 944 945 946 947 948 949 950 951 952 953
	if (algorithm == B43_SEC_ALGO_TKIP) {
		/*
		 * We should provide an initial iv32, phase1key pair.
		 * We could start with iv32=0 and compute the corresponding
		 * phase1key, but this means calling ieee80211_get_tkip_key
		 * with a fake skb (or export other tkip function).
		 * Because we are lazy we hope iv32 won't start with
		 * 0xffffffff and let's b43_op_update_tkip_key provide a
		 * correct pair.
		 */
		rx_tkip_phase1_write(dev, index, 0xffffffff, (u16*)buf);
	} else if (index >= pairwise_keys_start) /* clear it */
		rx_tkip_phase1_write(dev, index, 0, NULL);
954 955 956
	if (key)
		memcpy(buf, key, key_len);
	key_write(dev, index, algorithm, buf);
957
	if (index >= pairwise_keys_start)
958 959 960 961 962 963 964
		keymac_write(dev, index, mac_addr);

	dev->key[index].algorithm = algorithm;
}

static int b43_key_write(struct b43_wldev *dev,
			 int index, u8 algorithm,
J
John Daiker 已提交
965 966
			 const u8 *key, size_t key_len,
			 const u8 *mac_addr,
967 968 969
			 struct ieee80211_key_conf *keyconf)
{
	int i;
970
	int pairwise_keys_start;
971

G
gregor kowski 已提交
972 973 974 975 976 977 978 979 980
	/* For ALG_TKIP the key is encoded as a 256-bit (32 byte) data block:
	 * 	- Temporal Encryption Key (128 bits)
	 * 	- Temporal Authenticator Tx MIC Key (64 bits)
	 * 	- Temporal Authenticator Rx MIC Key (64 bits)
	 *
	 * 	Hardware only store TEK
	 */
	if (algorithm == B43_SEC_ALGO_TKIP && key_len == 32)
		key_len = 16;
981 982
	if (key_len > B43_SEC_KEYSIZE)
		return -EINVAL;
983
	for (i = 0; i < ARRAY_SIZE(dev->key); i++) {
984 985 986 987
		/* Check that we don't already have this key. */
		B43_WARN_ON(dev->key[i].keyconf == keyconf);
	}
	if (index < 0) {
M
Michael Buesch 已提交
988
		/* Pairwise key. Get an empty slot for the key. */
989
		if (b43_new_kidx_api(dev))
990
			pairwise_keys_start = B43_NR_GROUP_KEYS;
991
		else
992 993 994 995 996
			pairwise_keys_start = B43_NR_GROUP_KEYS * 2;
		for (i = pairwise_keys_start;
		     i < pairwise_keys_start + B43_NR_PAIRWISE_KEYS;
		     i++) {
			B43_WARN_ON(i >= ARRAY_SIZE(dev->key));
997 998 999 1000 1001 1002 1003
			if (!dev->key[i].keyconf) {
				/* found empty */
				index = i;
				break;
			}
		}
		if (index < 0) {
M
Michael Buesch 已提交
1004
			b43warn(dev->wl, "Out of hardware key memory\n");
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
			return -ENOSPC;
		}
	} else
		B43_WARN_ON(index > 3);

	do_key_write(dev, index, algorithm, key, key_len, mac_addr);
	if ((index <= 3) && !b43_new_kidx_api(dev)) {
		/* Default RX key */
		B43_WARN_ON(mac_addr);
		do_key_write(dev, index + 4, algorithm, key, key_len, NULL);
	}
	keyconf->hw_key_idx = index;
	dev->key[index].keyconf = keyconf;

	return 0;
}

static int b43_key_clear(struct b43_wldev *dev, int index)
{
1024
	if (B43_WARN_ON((index < 0) || (index >= ARRAY_SIZE(dev->key))))
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
		return -EINVAL;
	do_key_write(dev, index, B43_SEC_ALGO_NONE,
		     NULL, B43_SEC_KEYSIZE, NULL);
	if ((index <= 3) && !b43_new_kidx_api(dev)) {
		do_key_write(dev, index + 4, B43_SEC_ALGO_NONE,
			     NULL, B43_SEC_KEYSIZE, NULL);
	}
	dev->key[index].keyconf = NULL;

	return 0;
}

static void b43_clear_keys(struct b43_wldev *dev)
{
1039
	int i, count;
1040

1041 1042 1043 1044 1045
	if (b43_new_kidx_api(dev))
		count = B43_NR_GROUP_KEYS + B43_NR_PAIRWISE_KEYS;
	else
		count = B43_NR_GROUP_KEYS * 2 + B43_NR_PAIRWISE_KEYS;
	for (i = 0; i < count; i++)
1046 1047 1048
		b43_key_clear(dev, i);
}

M
Michael Buesch 已提交
1049 1050
static void b43_dump_keymemory(struct b43_wldev *dev)
{
1051
	unsigned int i, index, count, offset, pairwise_keys_start;
M
Michael Buesch 已提交
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
	u8 mac[ETH_ALEN];
	u16 algo;
	u32 rcmta0;
	u16 rcmta1;
	u64 hf;
	struct b43_key *key;

	if (!b43_debug(dev, B43_DBG_KEYS))
		return;

	hf = b43_hf_read(dev);
	b43dbg(dev->wl, "Hardware key memory dump:  USEDEFKEYS=%u\n",
	       !!(hf & B43_HF_USEDEFKEYS));
1065 1066 1067 1068 1069 1070 1071 1072
	if (b43_new_kidx_api(dev)) {
		pairwise_keys_start = B43_NR_GROUP_KEYS;
		count = B43_NR_GROUP_KEYS + B43_NR_PAIRWISE_KEYS;
	} else {
		pairwise_keys_start = B43_NR_GROUP_KEYS * 2;
		count = B43_NR_GROUP_KEYS * 2 + B43_NR_PAIRWISE_KEYS;
	}
	for (index = 0; index < count; index++) {
M
Michael Buesch 已提交
1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
		key = &(dev->key[index]);
		printk(KERN_DEBUG "Key slot %02u: %s",
		       index, (key->keyconf == NULL) ? " " : "*");
		offset = dev->ktp + (index * B43_SEC_KEYSIZE);
		for (i = 0; i < B43_SEC_KEYSIZE; i += 2) {
			u16 tmp = b43_shm_read16(dev, B43_SHM_SHARED, offset + i);
			printk("%02X%02X", (tmp & 0xFF), ((tmp >> 8) & 0xFF));
		}

		algo = b43_shm_read16(dev, B43_SHM_SHARED,
				      B43_SHM_SH_KEYIDXBLOCK + (index * 2));
		printk("   Algo: %04X/%02X", algo, key->algorithm);

1086
		if (index >= pairwise_keys_start) {
G
gregor kowski 已提交
1087 1088 1089 1090 1091 1092 1093 1094
			if (key->algorithm == B43_SEC_ALGO_TKIP) {
				printk("   TKIP: ");
				offset = B43_SHM_SH_TKIPTSCTTAK + (index - 4) * (10 + 4);
				for (i = 0; i < 14; i += 2) {
					u16 tmp = b43_shm_read16(dev, B43_SHM_SHARED, offset + i);
					printk("%02X%02X", (tmp & 0xFF), ((tmp >> 8) & 0xFF));
				}
			}
M
Michael Buesch 已提交
1095
			rcmta0 = b43_shm_read32(dev, B43_SHM_RCMTA,
1096
						((index - pairwise_keys_start) * 2) + 0);
M
Michael Buesch 已提交
1097
			rcmta1 = b43_shm_read16(dev, B43_SHM_RCMTA,
1098
						((index - pairwise_keys_start) * 2) + 1);
M
Michael Buesch 已提交
1099 1100
			*((__le32 *)(&mac[0])) = cpu_to_le32(rcmta0);
			*((__le16 *)(&mac[4])) = cpu_to_le16(rcmta1);
J
Johannes Berg 已提交
1101
			printk("   MAC: %pM", mac);
M
Michael Buesch 已提交
1102 1103 1104 1105 1106 1107
		} else
			printk("   DEFAULT KEY");
		printk("\n");
	}
}

1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
void b43_power_saving_ctl_bits(struct b43_wldev *dev, unsigned int ps_flags)
{
	u32 macctl;
	u16 ucstat;
	bool hwps;
	bool awake;
	int i;

	B43_WARN_ON((ps_flags & B43_PS_ENABLED) &&
		    (ps_flags & B43_PS_DISABLED));
	B43_WARN_ON((ps_flags & B43_PS_AWAKE) && (ps_flags & B43_PS_ASLEEP));

	if (ps_flags & B43_PS_ENABLED) {
1121
		hwps = true;
1122
	} else if (ps_flags & B43_PS_DISABLED) {
1123
		hwps = false;
1124 1125 1126 1127 1128
	} else {
		//TODO: If powersave is not off and FIXME is not set and we are not in adhoc
		//      and thus is not an AP and we are associated, set bit 25
	}
	if (ps_flags & B43_PS_AWAKE) {
1129
		awake = true;
1130
	} else if (ps_flags & B43_PS_ASLEEP) {
1131
		awake = false;
1132 1133 1134 1135 1136 1137 1138
	} else {
		//TODO: If the device is awake or this is an AP, or we are scanning, or FIXME,
		//      or we are associated, or FIXME, or the latest PS-Poll packet sent was
		//      successful, set bit26
	}

/* FIXME: For now we force awake-on and hwps-off */
1139 1140
	hwps = false;
	awake = true;
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153

	macctl = b43_read32(dev, B43_MMIO_MACCTL);
	if (hwps)
		macctl |= B43_MACCTL_HWPS;
	else
		macctl &= ~B43_MACCTL_HWPS;
	if (awake)
		macctl |= B43_MACCTL_AWAKE;
	else
		macctl &= ~B43_MACCTL_AWAKE;
	b43_write32(dev, B43_MMIO_MACCTL, macctl);
	/* Commit write */
	b43_read32(dev, B43_MMIO_MACCTL);
1154
	if (awake && dev->dev->core_rev >= 5) {
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
		/* Wait for the microcode to wake up. */
		for (i = 0; i < 100; i++) {
			ucstat = b43_shm_read16(dev, B43_SHM_SHARED,
						B43_SHM_SH_UCODESTAT);
			if (ucstat != B43_SHM_SH_UCODESTAT_SLEEP)
				break;
			udelay(10);
		}
	}
}

1166
#ifdef CONFIG_B43_BCMA
1167
static void b43_bcma_phy_reset(struct b43_wldev *dev)
1168
{
1169
	u32 flags;
1170

1171 1172 1173
	/* Put PHY into reset */
	flags = bcma_aread32(dev->dev->bdev, BCMA_IOCTL);
	flags |= B43_BCMA_IOCTL_PHY_RESET;
1174
	flags |= B43_BCMA_IOCTL_PHY_BW_20MHZ; /* Make 20 MHz def */
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
	bcma_awrite32(dev->dev->bdev, BCMA_IOCTL, flags);
	udelay(2);

	/* Take PHY out of reset */
	flags = bcma_aread32(dev->dev->bdev, BCMA_IOCTL);
	flags &= ~B43_BCMA_IOCTL_PHY_RESET;
	flags |= BCMA_IOCTL_FGC;
	bcma_awrite32(dev->dev->bdev, BCMA_IOCTL, flags);
	udelay(1);

	/* Do not force clock anymore */
	flags = bcma_aread32(dev->dev->bdev, BCMA_IOCTL);
	flags &= ~BCMA_IOCTL_FGC;
	bcma_awrite32(dev->dev->bdev, BCMA_IOCTL, flags);
	udelay(1);
}
1191

1192 1193
static void b43_bcma_wireless_core_reset(struct b43_wldev *dev, bool gmode)
{
1194 1195 1196 1197
	u32 req = B43_BCMA_CLKCTLST_80211_PLL_REQ |
		  B43_BCMA_CLKCTLST_PHY_PLL_REQ;
	u32 status = B43_BCMA_CLKCTLST_80211_PLL_ST |
		     B43_BCMA_CLKCTLST_PHY_PLL_ST;
1198 1199 1200 1201 1202 1203
	u32 flags;

	flags = B43_BCMA_IOCTL_PHY_CLKEN;
	if (gmode)
		flags |= B43_BCMA_IOCTL_GMODE;
	b43_device_enable(dev, flags);
1204

1205 1206
	bcma_core_set_clockmode(dev->dev->bdev, BCMA_CLKMODE_FAST);
	b43_bcma_phy_reset(dev);
1207
	bcma_core_pll_ctl(dev->dev->bdev, req, status, true);
1208 1209 1210
}
#endif

1211
#ifdef CONFIG_B43_SSB
1212
static void b43_ssb_wireless_core_reset(struct b43_wldev *dev, bool gmode)
1213
{
1214
	struct ssb_device *sdev = dev->dev->sdev;
1215
	u32 tmslow;
1216
	u32 flags = 0;
1217

1218 1219
	if (gmode)
		flags |= B43_TMSLOW_GMODE;
1220 1221
	flags |= B43_TMSLOW_PHYCLKEN;
	flags |= B43_TMSLOW_PHYRESET;
1222 1223
	if (dev->phy.type == B43_PHYTYPE_N)
		flags |= B43_TMSLOW_PHY_BANDWIDTH_20MHZ; /* Make 20 MHz def */
1224
	b43_device_enable(dev, flags);
1225 1226 1227
	msleep(2);		/* Wait for the PLL to turn on. */

	/* Now take the PHY out of Reset again */
1228
	tmslow = ssb_read32(sdev, SSB_TMSLOW);
1229 1230
	tmslow |= SSB_TMSLOW_FGC;
	tmslow &= ~B43_TMSLOW_PHYRESET;
1231 1232
	ssb_write32(sdev, SSB_TMSLOW, tmslow);
	ssb_read32(sdev, SSB_TMSLOW);	/* flush */
1233 1234
	msleep(1);
	tmslow &= ~SSB_TMSLOW_FGC;
1235 1236
	ssb_write32(sdev, SSB_TMSLOW, tmslow);
	ssb_read32(sdev, SSB_TMSLOW);	/* flush */
1237
	msleep(1);
R
Rafał Miłecki 已提交
1238
}
1239
#endif
R
Rafał Miłecki 已提交
1240

1241
void b43_wireless_core_reset(struct b43_wldev *dev, bool gmode)
R
Rafał Miłecki 已提交
1242 1243 1244
{
	u32 macctl;

1245
	switch (dev->dev->bus_type) {
1246 1247 1248 1249 1250
#ifdef CONFIG_B43_BCMA
	case B43_BUS_BCMA:
		b43_bcma_wireless_core_reset(dev, gmode);
		break;
#endif
1251 1252 1253 1254 1255 1256
#ifdef CONFIG_B43_SSB
	case B43_BUS_SSB:
		b43_ssb_wireless_core_reset(dev, gmode);
		break;
#endif
	}
1257

M
Michael Buesch 已提交
1258 1259 1260 1261 1262
	/* Turn Analog ON, but only if we already know the PHY-type.
	 * This protects against very early setup where we don't know the
	 * PHY-type, yet. wireless_core_reset will be called once again later,
	 * when we know the PHY-type. */
	if (dev->phy.ops)
1263
		dev->phy.ops->switch_analog(dev, 1);
1264 1265 1266

	macctl = b43_read32(dev, B43_MMIO_MACCTL);
	macctl &= ~B43_MACCTL_GMODE;
1267
	if (gmode)
1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304
		macctl |= B43_MACCTL_GMODE;
	macctl |= B43_MACCTL_IHR_ENABLED;
	b43_write32(dev, B43_MMIO_MACCTL, macctl);
}

static void handle_irq_transmit_status(struct b43_wldev *dev)
{
	u32 v0, v1;
	u16 tmp;
	struct b43_txstatus stat;

	while (1) {
		v0 = b43_read32(dev, B43_MMIO_XMITSTAT_0);
		if (!(v0 & 0x00000001))
			break;
		v1 = b43_read32(dev, B43_MMIO_XMITSTAT_1);

		stat.cookie = (v0 >> 16);
		stat.seq = (v1 & 0x0000FFFF);
		stat.phy_stat = ((v1 & 0x00FF0000) >> 16);
		tmp = (v0 & 0x0000FFFF);
		stat.frame_count = ((tmp & 0xF000) >> 12);
		stat.rts_count = ((tmp & 0x0F00) >> 8);
		stat.supp_reason = ((tmp & 0x001C) >> 2);
		stat.pm_indicated = !!(tmp & 0x0080);
		stat.intermediate = !!(tmp & 0x0040);
		stat.for_ampdu = !!(tmp & 0x0020);
		stat.acked = !!(tmp & 0x0002);

		b43_handle_txstatus(dev, &stat);
	}
}

static void drain_txstatus_queue(struct b43_wldev *dev)
{
	u32 dummy;

1305
	if (dev->dev->core_rev < 5)
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321
		return;
	/* Read all entries from the microcode TXstatus FIFO
	 * and throw them away.
	 */
	while (1) {
		dummy = b43_read32(dev, B43_MMIO_XMITSTAT_0);
		if (!(dummy & 0x00000001))
			break;
		dummy = b43_read32(dev, B43_MMIO_XMITSTAT_1);
	}
}

static u32 b43_jssi_read(struct b43_wldev *dev)
{
	u32 val = 0;

H
Hauke Mehrtens 已提交
1322
	val = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_JSSI1);
1323
	val <<= 16;
H
Hauke Mehrtens 已提交
1324
	val |= b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_JSSI0);
1325 1326 1327 1328 1329 1330

	return val;
}

static void b43_jssi_write(struct b43_wldev *dev, u32 jssi)
{
H
Hauke Mehrtens 已提交
1331 1332 1333 1334
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_JSSI0,
			(jssi & 0x0000FFFF));
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_JSSI1,
			(jssi & 0xFFFF0000) >> 16);
1335 1336 1337 1338 1339
}

static void b43_generate_noise_sample(struct b43_wldev *dev)
{
	b43_jssi_write(dev, 0x7F7F7F7F);
1340 1341
	b43_write32(dev, B43_MMIO_MACCMD,
		    b43_read32(dev, B43_MMIO_MACCMD) | B43_MACCMD_BGNOISE);
1342 1343 1344 1345 1346 1347
}

static void b43_calculate_link_quality(struct b43_wldev *dev)
{
	/* Top half of Link Quality calculation. */

M
Michael Buesch 已提交
1348 1349
	if (dev->phy.type != B43_PHYTYPE_G)
		return;
1350 1351
	if (dev->noisecalc.calculation_running)
		return;
1352
	dev->noisecalc.calculation_running = true;
1353 1354 1355 1356 1357 1358 1359
	dev->noisecalc.nr_samples = 0;

	b43_generate_noise_sample(dev);
}

static void handle_irq_noise(struct b43_wldev *dev)
{
M
Michael Buesch 已提交
1360
	struct b43_phy_g *phy = dev->phy.g;
1361 1362 1363 1364 1365 1366 1367
	u16 tmp;
	u8 noise[4];
	u8 i, j;
	s32 average;

	/* Bottom half of Link Quality calculation. */

M
Michael Buesch 已提交
1368 1369 1370
	if (dev->phy.type != B43_PHYTYPE_G)
		return;

1371 1372 1373 1374 1375 1376 1377 1378 1379
	/* Possible race condition: It might be possible that the user
	 * changed to a different channel in the meantime since we
	 * started the calculation. We ignore that fact, since it's
	 * not really that much of a problem. The background noise is
	 * an estimation only anyway. Slightly wrong results will get damped
	 * by the averaging of the 8 sample rounds. Additionally the
	 * value is shortlived. So it will be replaced by the next noise
	 * calculation round soon. */

1380
	B43_WARN_ON(!dev->noisecalc.calculation_running);
M
Michael Buesch 已提交
1381
	*((__le32 *)noise) = cpu_to_le32(b43_jssi_read(dev));
1382 1383 1384 1385 1386 1387 1388
	if (noise[0] == 0x7F || noise[1] == 0x7F ||
	    noise[2] == 0x7F || noise[3] == 0x7F)
		goto generate_new;

	/* Get the noise samples. */
	B43_WARN_ON(dev->noisecalc.nr_samples >= 8);
	i = dev->noisecalc.nr_samples;
1389 1390 1391 1392
	noise[0] = clamp_val(noise[0], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
	noise[1] = clamp_val(noise[1], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
	noise[2] = clamp_val(noise[2], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
	noise[3] = clamp_val(noise[3], 0, ARRAY_SIZE(phy->nrssi_lt) - 1);
1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420
	dev->noisecalc.samples[i][0] = phy->nrssi_lt[noise[0]];
	dev->noisecalc.samples[i][1] = phy->nrssi_lt[noise[1]];
	dev->noisecalc.samples[i][2] = phy->nrssi_lt[noise[2]];
	dev->noisecalc.samples[i][3] = phy->nrssi_lt[noise[3]];
	dev->noisecalc.nr_samples++;
	if (dev->noisecalc.nr_samples == 8) {
		/* Calculate the Link Quality by the noise samples. */
		average = 0;
		for (i = 0; i < 8; i++) {
			for (j = 0; j < 4; j++)
				average += dev->noisecalc.samples[i][j];
		}
		average /= (8 * 4);
		average *= 125;
		average += 64;
		average /= 128;
		tmp = b43_shm_read16(dev, B43_SHM_SHARED, 0x40C);
		tmp = (tmp / 128) & 0x1F;
		if (tmp >= 8)
			average += 2;
		else
			average -= 25;
		if (tmp == 8)
			average -= 72;
		else
			average -= 48;

		dev->stats.link_noise = average;
1421
		dev->noisecalc.calculation_running = false;
1422 1423
		return;
	}
1424
generate_new:
1425 1426 1427 1428 1429
	b43_generate_noise_sample(dev);
}

static void handle_irq_tbtt_indication(struct b43_wldev *dev)
{
1430
	if (b43_is_mode(dev->wl, NL80211_IFTYPE_AP)) {
1431 1432 1433 1434 1435
		///TODO: PS TBTT
	} else {
		if (1 /*FIXME: the last PSpoll frame was sent successfully */ )
			b43_power_saving_ctl_bits(dev, 0);
	}
1436
	if (b43_is_mode(dev->wl, NL80211_IFTYPE_ADHOC))
1437
		dev->dfq_valid = true;
1438 1439 1440 1441
}

static void handle_irq_atim_end(struct b43_wldev *dev)
{
1442 1443 1444 1445
	if (dev->dfq_valid) {
		b43_write32(dev, B43_MMIO_MACCMD,
			    b43_read32(dev, B43_MMIO_MACCMD)
			    | B43_MACCMD_DFQ_VALID);
1446
		dev->dfq_valid = false;
1447
	}
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
}

static void handle_irq_pmq(struct b43_wldev *dev)
{
	u32 tmp;

	//TODO: AP mode.

	while (1) {
		tmp = b43_read32(dev, B43_MMIO_PS_STATUS);
		if (!(tmp & 0x00000008))
			break;
	}
	/* 16bit write is odd, but correct. */
	b43_write16(dev, B43_MMIO_PS_STATUS, 0x0002);
}

static void b43_write_template_common(struct b43_wldev *dev,
J
John Daiker 已提交
1466
				      const u8 *data, u16 size,
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497
				      u16 ram_offset,
				      u16 shm_size_offset, u8 rate)
{
	u32 i, tmp;
	struct b43_plcp_hdr4 plcp;

	plcp.data = 0;
	b43_generate_plcp_hdr(&plcp, size + FCS_LEN, rate);
	b43_ram_write(dev, ram_offset, le32_to_cpu(plcp.data));
	ram_offset += sizeof(u32);
	/* The PLCP is 6 bytes long, but we only wrote 4 bytes, yet.
	 * So leave the first two bytes of the next write blank.
	 */
	tmp = (u32) (data[0]) << 16;
	tmp |= (u32) (data[1]) << 24;
	b43_ram_write(dev, ram_offset, tmp);
	ram_offset += sizeof(u32);
	for (i = 2; i < size; i += sizeof(u32)) {
		tmp = (u32) (data[i + 0]);
		if (i + 1 < size)
			tmp |= (u32) (data[i + 1]) << 8;
		if (i + 2 < size)
			tmp |= (u32) (data[i + 2]) << 16;
		if (i + 3 < size)
			tmp |= (u32) (data[i + 3]) << 24;
		b43_ram_write(dev, ram_offset + i - 2, tmp);
	}
	b43_shm_write16(dev, B43_SHM_SHARED, shm_size_offset,
			size + sizeof(struct b43_plcp_hdr6));
}

1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512
/* Check if the use of the antenna that ieee80211 told us to
 * use is possible. This will fall back to DEFAULT.
 * "antenna_nr" is the antenna identifier we got from ieee80211. */
u8 b43_ieee80211_antenna_sanitize(struct b43_wldev *dev,
				  u8 antenna_nr)
{
	u8 antenna_mask;

	if (antenna_nr == 0) {
		/* Zero means "use default antenna". That's always OK. */
		return 0;
	}

	/* Get the mask of available antennas. */
	if (dev->phy.gmode)
R
Rafał Miłecki 已提交
1513
		antenna_mask = dev->dev->bus_sprom->ant_available_bg;
1514
	else
R
Rafał Miłecki 已提交
1515
		antenna_mask = dev->dev->bus_sprom->ant_available_a;
1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536

	if (!(antenna_mask & (1 << (antenna_nr - 1)))) {
		/* This antenna is not available. Fall back to default. */
		return 0;
	}

	return antenna_nr;
}

/* Convert a b43 antenna number value to the PHY TX control value. */
static u16 b43_antenna_to_phyctl(int antenna)
{
	switch (antenna) {
	case B43_ANTENNA0:
		return B43_TXH_PHY_ANT0;
	case B43_ANTENNA1:
		return B43_TXH_PHY_ANT1;
	case B43_ANTENNA2:
		return B43_TXH_PHY_ANT2;
	case B43_ANTENNA3:
		return B43_TXH_PHY_ANT3;
1537 1538
	case B43_ANTENNA_AUTO0:
	case B43_ANTENNA_AUTO1:
1539 1540 1541 1542 1543 1544
		return B43_TXH_PHY_ANT01AUTO;
	}
	B43_WARN_ON(1);
	return 0;
}

1545 1546
static void b43_write_beacon_template(struct b43_wldev *dev,
				      u16 ram_offset,
1547
				      u16 shm_size_offset)
1548
{
1549
	unsigned int i, len, variable_len;
1550 1551
	const struct ieee80211_mgmt *bcn;
	const u8 *ie;
1552
	bool tim_found = false;
1553 1554 1555
	unsigned int rate;
	u16 ctl;
	int antenna;
1556
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(dev->wl->current_beacon);
1557

1558
	bcn = (const struct ieee80211_mgmt *)(dev->wl->current_beacon->data);
S
Silvan Jegen 已提交
1559
	len = min_t(size_t, dev->wl->current_beacon->len,
1560
		  0x200 - sizeof(struct b43_plcp_hdr6));
1561
	rate = ieee80211_get_tx_rate(dev->wl->hw, info)->hw_value;
1562 1563

	b43_write_template_common(dev, (const u8 *)bcn,
1564
				  len, ram_offset, shm_size_offset, rate);
1565

1566
	/* Write the PHY TX control parameters. */
1567
	antenna = B43_ANTENNA_DEFAULT;
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580
	antenna = b43_antenna_to_phyctl(antenna);
	ctl = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_BEACPHYCTL);
	/* We can't send beacons with short preamble. Would get PHY errors. */
	ctl &= ~B43_TXH_PHY_SHORTPRMBL;
	ctl &= ~B43_TXH_PHY_ANT;
	ctl &= ~B43_TXH_PHY_ENC;
	ctl |= antenna;
	if (b43_is_cck_rate(rate))
		ctl |= B43_TXH_PHY_ENC_CCK;
	else
		ctl |= B43_TXH_PHY_ENC_OFDM;
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_BEACPHYCTL, ctl);

1581 1582 1583
	/* Find the position of the TIM and the DTIM_period value
	 * and write them to SHM. */
	ie = bcn->u.beacon.variable;
1584 1585
	variable_len = len - offsetof(struct ieee80211_mgmt, u.beacon.variable);
	for (i = 0; i < variable_len - 2; ) {
1586 1587 1588 1589 1590 1591 1592 1593 1594 1595
		uint8_t ie_id, ie_len;

		ie_id = ie[i];
		ie_len = ie[i + 1];
		if (ie_id == 5) {
			u16 tim_position;
			u16 dtim_period;
			/* This is the TIM Information Element */

			/* Check whether the ie_len is in the beacon data range. */
1596
			if (variable_len < ie_len + 2 + i)
1597 1598 1599 1600
				break;
			/* A valid TIM is at least 4 bytes long. */
			if (ie_len < 4)
				break;
1601
			tim_found = true;
1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617

			tim_position = sizeof(struct b43_plcp_hdr6);
			tim_position += offsetof(struct ieee80211_mgmt, u.beacon.variable);
			tim_position += i;

			dtim_period = ie[i + 3];

			b43_shm_write16(dev, B43_SHM_SHARED,
					B43_SHM_SH_TIMBPOS, tim_position);
			b43_shm_write16(dev, B43_SHM_SHARED,
					B43_SHM_SH_DTIMPER, dtim_period);
			break;
		}
		i += ie_len + 2;
	}
	if (!tim_found) {
J
Johannes Berg 已提交
1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628
		/*
		 * If ucode wants to modify TIM do it behind the beacon, this
		 * will happen, for example, when doing mesh networking.
		 */
		b43_shm_write16(dev, B43_SHM_SHARED,
				B43_SHM_SH_TIMBPOS,
				len + sizeof(struct b43_plcp_hdr6));
		b43_shm_write16(dev, B43_SHM_SHARED,
				B43_SHM_SH_DTIMPER, 0);
	}
	b43dbg(dev->wl, "Updated beacon template at 0x%x\n", ram_offset);
1629 1630
}

1631 1632 1633 1634 1635 1636
static void b43_upload_beacon0(struct b43_wldev *dev)
{
	struct b43_wl *wl = dev->wl;

	if (wl->beacon0_uploaded)
		return;
H
Hauke Mehrtens 已提交
1637
	b43_write_beacon_template(dev, B43_SHM_SH_BT_BASE0, B43_SHM_SH_BTL0);
1638
	wl->beacon0_uploaded = true;
1639 1640 1641 1642 1643 1644 1645 1646
}

static void b43_upload_beacon1(struct b43_wldev *dev)
{
	struct b43_wl *wl = dev->wl;

	if (wl->beacon1_uploaded)
		return;
H
Hauke Mehrtens 已提交
1647
	b43_write_beacon_template(dev, B43_SHM_SH_BT_BASE1, B43_SHM_SH_BTL1);
1648
	wl->beacon1_uploaded = true;
1649 1650
}

M
Michael Buesch 已提交
1651 1652 1653 1654 1655
static void handle_irq_beacon(struct b43_wldev *dev)
{
	struct b43_wl *wl = dev->wl;
	u32 cmd, beacon0_valid, beacon1_valid;

1656
	if (!b43_is_mode(wl, NL80211_IFTYPE_AP) &&
1657 1658
	    !b43_is_mode(wl, NL80211_IFTYPE_MESH_POINT) &&
	    !b43_is_mode(wl, NL80211_IFTYPE_ADHOC))
M
Michael Buesch 已提交
1659 1660 1661 1662 1663
		return;

	/* This is the bottom half of the asynchronous beacon update. */

	/* Ignore interrupt in the future. */
1664
	dev->irq_mask &= ~B43_IRQ_BEACON;
M
Michael Buesch 已提交
1665 1666 1667 1668 1669 1670 1671 1672

	cmd = b43_read32(dev, B43_MMIO_MACCMD);
	beacon0_valid = (cmd & B43_MACCMD_BEACON0_VALID);
	beacon1_valid = (cmd & B43_MACCMD_BEACON1_VALID);

	/* Schedule interrupt manually, if busy. */
	if (beacon0_valid && beacon1_valid) {
		b43_write32(dev, B43_MMIO_GEN_IRQ_REASON, B43_IRQ_BEACON);
1673
		dev->irq_mask |= B43_IRQ_BEACON;
M
Michael Buesch 已提交
1674 1675 1676
		return;
	}

1677 1678 1679
	if (unlikely(wl->beacon_templates_virgin)) {
		/* We never uploaded a beacon before.
		 * Upload both templates now, but only mark one valid. */
1680
		wl->beacon_templates_virgin = false;
1681 1682
		b43_upload_beacon0(dev);
		b43_upload_beacon1(dev);
M
Michael Buesch 已提交
1683 1684 1685
		cmd = b43_read32(dev, B43_MMIO_MACCMD);
		cmd |= B43_MACCMD_BEACON0_VALID;
		b43_write32(dev, B43_MMIO_MACCMD, cmd);
1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696
	} else {
		if (!beacon0_valid) {
			b43_upload_beacon0(dev);
			cmd = b43_read32(dev, B43_MMIO_MACCMD);
			cmd |= B43_MACCMD_BEACON0_VALID;
			b43_write32(dev, B43_MMIO_MACCMD, cmd);
		} else if (!beacon1_valid) {
			b43_upload_beacon1(dev);
			cmd = b43_read32(dev, B43_MMIO_MACCMD);
			cmd |= B43_MACCMD_BEACON1_VALID;
			b43_write32(dev, B43_MMIO_MACCMD, cmd);
M
Michael Buesch 已提交
1697 1698 1699 1700
		}
	}
}

M
Michael Buesch 已提交
1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721
static void b43_do_beacon_update_trigger_work(struct b43_wldev *dev)
{
	u32 old_irq_mask = dev->irq_mask;

	/* update beacon right away or defer to irq */
	handle_irq_beacon(dev);
	if (old_irq_mask != dev->irq_mask) {
		/* The handler updated the IRQ mask. */
		B43_WARN_ON(!dev->irq_mask);
		if (b43_read32(dev, B43_MMIO_GEN_IRQ_MASK)) {
			b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, dev->irq_mask);
		} else {
			/* Device interrupts are currently disabled. That means
			 * we just ran the hardirq handler and scheduled the
			 * IRQ thread. The thread will write the IRQ mask when
			 * it finished, so there's nothing to do here. Writing
			 * the mask _here_ would incorrectly re-enable IRQs. */
		}
	}
}

M
Michael Buesch 已提交
1722 1723 1724 1725 1726 1727 1728 1729 1730
static void b43_beacon_update_trigger_work(struct work_struct *work)
{
	struct b43_wl *wl = container_of(work, struct b43_wl,
					 beacon_update_trigger);
	struct b43_wldev *dev;

	mutex_lock(&wl->mutex);
	dev = wl->current_dev;
	if (likely(dev && (b43_status(dev) >= B43_STAT_INITIALIZED))) {
1731
		if (b43_bus_host_is_sdio(dev->dev)) {
M
Michael Buesch 已提交
1732 1733 1734 1735 1736 1737 1738 1739 1740
			/* wl->mutex is enough. */
			b43_do_beacon_update_trigger_work(dev);
			mmiowb();
		} else {
			spin_lock_irq(&wl->hardirq_lock);
			b43_do_beacon_update_trigger_work(dev);
			mmiowb();
			spin_unlock_irq(&wl->hardirq_lock);
		}
M
Michael Buesch 已提交
1741 1742 1743 1744
	}
	mutex_unlock(&wl->mutex);
}

1745
/* Asynchronously update the packet templates in template RAM.
M
Michael Buesch 已提交
1746
 * Locking: Requires wl->mutex to be locked. */
1747
static void b43_update_templates(struct b43_wl *wl)
1748
{
1749 1750
	struct sk_buff *beacon;

1751 1752 1753 1754 1755
	/* This is the top half of the ansynchronous beacon update.
	 * The bottom half is the beacon IRQ.
	 * Beacon update must be asynchronous to avoid sending an
	 * invalid beacon. This can happen for example, if the firmware
	 * transmits a beacon while we are updating it. */
1756

1757 1758 1759 1760 1761 1762 1763 1764
	/* We could modify the existing beacon and set the aid bit in
	 * the TIM field, but that would probably require resizing and
	 * moving of data within the beacon template.
	 * Simply request a new beacon and let mac80211 do the hard work. */
	beacon = ieee80211_beacon_get(wl->hw, wl->vif);
	if (unlikely(!beacon))
		return;

1765 1766 1767
	if (wl->current_beacon)
		dev_kfree_skb_any(wl->current_beacon);
	wl->current_beacon = beacon;
1768 1769
	wl->beacon0_uploaded = false;
	wl->beacon1_uploaded = false;
1770
	ieee80211_queue_work(wl->hw, &wl->beacon_update_trigger);
1771 1772 1773 1774 1775
}

static void b43_set_beacon_int(struct b43_wldev *dev, u16 beacon_int)
{
	b43_time_lock(dev);
1776
	if (dev->dev->core_rev >= 3) {
M
Michael Buesch 已提交
1777 1778
		b43_write32(dev, B43_MMIO_TSF_CFP_REP, (beacon_int << 16));
		b43_write32(dev, B43_MMIO_TSF_CFP_START, (beacon_int << 10));
1779 1780 1781 1782 1783
	} else {
		b43_write16(dev, 0x606, (beacon_int >> 6));
		b43_write16(dev, 0x610, beacon_int);
	}
	b43_time_unlock(dev);
M
Michael Buesch 已提交
1784
	b43dbg(dev->wl, "Set beacon interval to %u\n", beacon_int);
1785 1786
}

1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810
static void b43_handle_firmware_panic(struct b43_wldev *dev)
{
	u16 reason;

	/* Read the register that contains the reason code for the panic. */
	reason = b43_shm_read16(dev, B43_SHM_SCRATCH, B43_FWPANIC_REASON_REG);
	b43err(dev->wl, "Whoopsy, firmware panic! Reason: %u\n", reason);

	switch (reason) {
	default:
		b43dbg(dev->wl, "The panic reason is unknown.\n");
		/* fallthrough */
	case B43_FWPANIC_DIE:
		/* Do not restart the controller or firmware.
		 * The device is nonfunctional from now on.
		 * Restarting would result in this panic to trigger again,
		 * so we avoid that recursion. */
		break;
	case B43_FWPANIC_RESTART:
		b43_controller_restart(dev, "Microcode panic");
		break;
	}
}

1811 1812
static void handle_irq_ucode_debug(struct b43_wldev *dev)
{
1813
	unsigned int i, cnt;
1814
	u16 reason, marker_id, marker_line;
1815 1816 1817 1818 1819 1820
	__le16 *buf;

	/* The proprietary firmware doesn't have this IRQ. */
	if (!dev->fw.opensource)
		return;

1821 1822 1823
	/* Read the register that contains the reason code for this IRQ. */
	reason = b43_shm_read16(dev, B43_SHM_SCRATCH, B43_DEBUGIRQ_REASON_REG);

1824 1825
	switch (reason) {
	case B43_DEBUGIRQ_PANIC:
1826
		b43_handle_firmware_panic(dev);
1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861
		break;
	case B43_DEBUGIRQ_DUMP_SHM:
		if (!B43_DEBUG)
			break; /* Only with driver debugging enabled. */
		buf = kmalloc(4096, GFP_ATOMIC);
		if (!buf) {
			b43dbg(dev->wl, "SHM-dump: Failed to allocate memory\n");
			goto out;
		}
		for (i = 0; i < 4096; i += 2) {
			u16 tmp = b43_shm_read16(dev, B43_SHM_SHARED, i);
			buf[i / 2] = cpu_to_le16(tmp);
		}
		b43info(dev->wl, "Shared memory dump:\n");
		print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET,
			       16, 2, buf, 4096, 1);
		kfree(buf);
		break;
	case B43_DEBUGIRQ_DUMP_REGS:
		if (!B43_DEBUG)
			break; /* Only with driver debugging enabled. */
		b43info(dev->wl, "Microcode register dump:\n");
		for (i = 0, cnt = 0; i < 64; i++) {
			u16 tmp = b43_shm_read16(dev, B43_SHM_SCRATCH, i);
			if (cnt == 0)
				printk(KERN_INFO);
			printk("r%02u: 0x%04X  ", i, tmp);
			cnt++;
			if (cnt == 6) {
				printk("\n");
				cnt = 0;
			}
		}
		printk("\n");
		break;
1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872
	case B43_DEBUGIRQ_MARKER:
		if (!B43_DEBUG)
			break; /* Only with driver debugging enabled. */
		marker_id = b43_shm_read16(dev, B43_SHM_SCRATCH,
					   B43_MARKER_ID_REG);
		marker_line = b43_shm_read16(dev, B43_SHM_SCRATCH,
					     B43_MARKER_LINE_REG);
		b43info(dev->wl, "The firmware just executed the MARKER(%u) "
			"at line number %u\n",
			marker_id, marker_line);
		break;
1873 1874 1875 1876 1877
	default:
		b43dbg(dev->wl, "Debug-IRQ triggered for unknown reason: %u\n",
		       reason);
	}
out:
1878 1879 1880
	/* Acknowledge the debug-IRQ, so the firmware can continue. */
	b43_shm_write16(dev, B43_SHM_SCRATCH,
			B43_DEBUGIRQ_REASON_REG, B43_DEBUGIRQ_ACK);
1881 1882
}

M
Michael Buesch 已提交
1883
static void b43_do_interrupt_thread(struct b43_wldev *dev)
1884 1885 1886 1887
{
	u32 reason;
	u32 dma_reason[ARRAY_SIZE(dev->dma_reason)];
	u32 merged_dma_reason = 0;
M
Michael Buesch 已提交
1888
	int i;
1889

M
Michael Buesch 已提交
1890 1891
	if (unlikely(b43_status(dev) != B43_STAT_STARTED))
		return;
1892 1893 1894 1895 1896 1897 1898 1899 1900 1901

	reason = dev->irq_reason;
	for (i = 0; i < ARRAY_SIZE(dma_reason); i++) {
		dma_reason[i] = dev->dma_reason[i];
		merged_dma_reason |= dma_reason[i];
	}

	if (unlikely(reason & B43_IRQ_MAC_TXERR))
		b43err(dev->wl, "MAC transmission error\n");

1902
	if (unlikely(reason & B43_IRQ_PHY_TXERR)) {
1903
		b43err(dev->wl, "PHY transmission error\n");
1904 1905 1906 1907 1908 1909 1910 1911 1912
		rmb();
		if (unlikely(atomic_dec_and_test(&dev->phy.txerr_cnt))) {
			atomic_set(&dev->phy.txerr_cnt,
				   B43_PHY_TX_BADNESS_LIMIT);
			b43err(dev->wl, "Too many PHY TX errors, "
					"restarting the controller\n");
			b43_controller_restart(dev, "PHY TX errors");
		}
	}
1913

1914 1915 1916 1917 1918 1919 1920
	if (unlikely(merged_dma_reason & (B43_DMAIRQ_FATALMASK))) {
		b43err(dev->wl,
			"Fatal DMA error: 0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X\n",
			dma_reason[0], dma_reason[1],
			dma_reason[2], dma_reason[3],
			dma_reason[4], dma_reason[5]);
		b43err(dev->wl, "This device does not support DMA "
1921
			       "on your system. It will now be switched to PIO.\n");
1922 1923 1924 1925
		/* Fall back to PIO transfers if we get fatal DMA errors! */
		dev->use_pio = true;
		b43_controller_restart(dev, "DMA error");
		return;
1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937
	}

	if (unlikely(reason & B43_IRQ_UCODE_DEBUG))
		handle_irq_ucode_debug(dev);
	if (reason & B43_IRQ_TBTT_INDI)
		handle_irq_tbtt_indication(dev);
	if (reason & B43_IRQ_ATIM_END)
		handle_irq_atim_end(dev);
	if (reason & B43_IRQ_BEACON)
		handle_irq_beacon(dev);
	if (reason & B43_IRQ_PMQ)
		handle_irq_pmq(dev);
M
Michael Buesch 已提交
1938 1939 1940
	if (reason & B43_IRQ_TXFIFO_FLUSH_OK)
		;/* TODO */
	if (reason & B43_IRQ_NOISESAMPLE_OK)
1941 1942 1943
		handle_irq_noise(dev);

	/* Check the DMA reason registers for received data. */
1944 1945 1946 1947 1948
	if (dma_reason[0] & B43_DMAIRQ_RDESC_UFLOW) {
		if (B43_DEBUG)
			b43warn(dev->wl, "RX descriptor underrun\n");
		b43_dma_handle_rx_overflow(dev->dma.rx_ring);
	}
1949 1950 1951 1952 1953 1954
	if (dma_reason[0] & B43_DMAIRQ_RX_DONE) {
		if (b43_using_pio_transfers(dev))
			b43_pio_rx(dev->pio.rx_queue);
		else
			b43_dma_rx(dev->dma.rx_ring);
	}
1955 1956
	B43_WARN_ON(dma_reason[1] & B43_DMAIRQ_RX_DONE);
	B43_WARN_ON(dma_reason[2] & B43_DMAIRQ_RX_DONE);
1957
	B43_WARN_ON(dma_reason[3] & B43_DMAIRQ_RX_DONE);
1958 1959 1960
	B43_WARN_ON(dma_reason[4] & B43_DMAIRQ_RX_DONE);
	B43_WARN_ON(dma_reason[5] & B43_DMAIRQ_RX_DONE);

M
Michael Buesch 已提交
1961
	if (reason & B43_IRQ_TX_OK)
1962 1963
		handle_irq_transmit_status(dev);

M
Michael Buesch 已提交
1964
	/* Re-enable interrupts on the device by restoring the current interrupt mask. */
1965
	b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, dev->irq_mask);
1966 1967 1968 1969 1970 1971 1972 1973 1974 1975

#if B43_DEBUG
	if (b43_debug(dev, B43_DBG_VERBOSESTATS)) {
		dev->irq_count++;
		for (i = 0; i < ARRAY_SIZE(dev->irq_bit_count); i++) {
			if (reason & (1 << i))
				dev->irq_bit_count[i]++;
		}
	}
#endif
1976 1977
}

M
Michael Buesch 已提交
1978 1979
/* Interrupt thread handler. Handles device interrupts in thread context. */
static irqreturn_t b43_interrupt_thread_handler(int irq, void *dev_id)
1980
{
M
Michael Buesch 已提交
1981
	struct b43_wldev *dev = dev_id;
1982

M
Michael Buesch 已提交
1983 1984 1985 1986 1987 1988
	mutex_lock(&dev->wl->mutex);
	b43_do_interrupt_thread(dev);
	mmiowb();
	mutex_unlock(&dev->wl->mutex);

	return IRQ_HANDLED;
1989 1990
}

M
Michael Buesch 已提交
1991
static irqreturn_t b43_do_interrupt(struct b43_wldev *dev)
1992 1993 1994
{
	u32 reason;

M
Michael Buesch 已提交
1995 1996
	/* This code runs under wl->hardirq_lock, but _only_ on non-SDIO busses.
	 * On SDIO, this runs under wl->mutex. */
1997 1998 1999

	reason = b43_read32(dev, B43_MMIO_GEN_IRQ_REASON);
	if (reason == 0xffffffff)	/* shared IRQ */
M
Michael Buesch 已提交
2000
		return IRQ_NONE;
2001
	reason &= dev->irq_mask;
2002
	if (!reason)
2003
		return IRQ_NONE;
2004 2005

	dev->dma_reason[0] = b43_read32(dev, B43_MMIO_DMA0_REASON)
2006
	    & 0x0001FC00;
2007 2008 2009 2010 2011 2012 2013 2014
	dev->dma_reason[1] = b43_read32(dev, B43_MMIO_DMA1_REASON)
	    & 0x0000DC00;
	dev->dma_reason[2] = b43_read32(dev, B43_MMIO_DMA2_REASON)
	    & 0x0000DC00;
	dev->dma_reason[3] = b43_read32(dev, B43_MMIO_DMA3_REASON)
	    & 0x0001DC00;
	dev->dma_reason[4] = b43_read32(dev, B43_MMIO_DMA4_REASON)
	    & 0x0000DC00;
2015
/* Unused ring
2016 2017
	dev->dma_reason[5] = b43_read32(dev, B43_MMIO_DMA5_REASON)
	    & 0x0000DC00;
2018
*/
2019

M
Michael Buesch 已提交
2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031
	/* ACK the interrupt. */
	b43_write32(dev, B43_MMIO_GEN_IRQ_REASON, reason);
	b43_write32(dev, B43_MMIO_DMA0_REASON, dev->dma_reason[0]);
	b43_write32(dev, B43_MMIO_DMA1_REASON, dev->dma_reason[1]);
	b43_write32(dev, B43_MMIO_DMA2_REASON, dev->dma_reason[2]);
	b43_write32(dev, B43_MMIO_DMA3_REASON, dev->dma_reason[3]);
	b43_write32(dev, B43_MMIO_DMA4_REASON, dev->dma_reason[4]);
/* Unused ring
	b43_write32(dev, B43_MMIO_DMA5_REASON, dev->dma_reason[5]);
*/

	/* Disable IRQs on the device. The IRQ thread handler will re-enable them. */
2032
	b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, 0);
M
Michael Buesch 已提交
2033
	/* Save the reason bitmasks for the IRQ thread handler. */
2034
	dev->irq_reason = reason;
M
Michael Buesch 已提交
2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049

	return IRQ_WAKE_THREAD;
}

/* Interrupt handler top-half. This runs with interrupts disabled. */
static irqreturn_t b43_interrupt_handler(int irq, void *dev_id)
{
	struct b43_wldev *dev = dev_id;
	irqreturn_t ret;

	if (unlikely(b43_status(dev) < B43_STAT_STARTED))
		return IRQ_NONE;

	spin_lock(&dev->wl->hardirq_lock);
	ret = b43_do_interrupt(dev);
2050
	mmiowb();
M
Michael Buesch 已提交
2051
	spin_unlock(&dev->wl->hardirq_lock);
2052 2053 2054 2055

	return ret;
}

2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070
/* SDIO interrupt handler. This runs in process context. */
static void b43_sdio_interrupt_handler(struct b43_wldev *dev)
{
	struct b43_wl *wl = dev->wl;
	irqreturn_t ret;

	mutex_lock(&wl->mutex);

	ret = b43_do_interrupt(dev);
	if (ret == IRQ_WAKE_THREAD)
		b43_do_interrupt_thread(dev);

	mutex_unlock(&wl->mutex);
}

2071
void b43_do_release_fw(struct b43_firmware_file *fw)
M
Michael Buesch 已提交
2072 2073 2074 2075 2076 2077
{
	release_firmware(fw->data);
	fw->data = NULL;
	fw->filename = NULL;
}

2078 2079
static void b43_release_firmware(struct b43_wldev *dev)
{
2080
	complete(&dev->fw_load_complete);
2081 2082 2083 2084
	b43_do_release_fw(&dev->fw.ucode);
	b43_do_release_fw(&dev->fw.pcm);
	b43_do_release_fw(&dev->fw.initvals);
	b43_do_release_fw(&dev->fw.initvals_band);
2085 2086
}

2087
static void b43_print_fw_helptext(struct b43_wl *wl, bool error)
2088
{
2089 2090 2091 2092 2093
	const char text[] =
		"You must go to " \
		"http://wireless.kernel.org/en/users/Drivers/b43#devicefirmware " \
		"and download the correct firmware for this driver version. " \
		"Please carefully read all instructions on this website.\n";
2094 2095 2096 2097 2098

	if (error)
		b43err(wl, text);
	else
		b43warn(wl, text);
2099 2100
}

2101 2102 2103 2104 2105
static void b43_fw_cb(const struct firmware *firmware, void *context)
{
	struct b43_request_fw_context *ctx = context;

	ctx->blob = firmware;
2106
	complete(&ctx->dev->fw_load_complete);
2107 2108
}

2109 2110
int b43_do_request_fw(struct b43_request_fw_context *ctx,
		      const char *name,
2111
		      struct b43_firmware_file *fw, bool async)
2112 2113 2114 2115 2116
{
	struct b43_fw_header *hdr;
	u32 size;
	int err;

M
Michael Buesch 已提交
2117 2118
	if (!name) {
		/* Don't fetch anything. Free possibly cached firmware. */
2119 2120 2121
		/* FIXME: We should probably keep it anyway, to save some headache
		 * on suspend/resume with multiband devices. */
		b43_do_release_fw(fw);
2122
		return 0;
M
Michael Buesch 已提交
2123 2124
	}
	if (fw->filename) {
2125 2126
		if ((fw->type == ctx->req_type) &&
		    (strcmp(fw->filename, name) == 0))
M
Michael Buesch 已提交
2127 2128
			return 0; /* Already have this fw. */
		/* Free the cached firmware first. */
2129 2130 2131 2132 2133
		/* FIXME: We should probably do this later after we successfully
		 * got the new fw. This could reduce headache with multiband devices.
		 * We could also redesign this to cache the firmware for all possible
		 * bands all the time. */
		b43_do_release_fw(fw);
M
Michael Buesch 已提交
2134
	}
2135

2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
	switch (ctx->req_type) {
	case B43_FWTYPE_PROPRIETARY:
		snprintf(ctx->fwname, sizeof(ctx->fwname),
			 "b43%s/%s.fw",
			 modparam_fwpostfix, name);
		break;
	case B43_FWTYPE_OPENSOURCE:
		snprintf(ctx->fwname, sizeof(ctx->fwname),
			 "b43-open%s/%s.fw",
			 modparam_fwpostfix, name);
		break;
	default:
		B43_WARN_ON(1);
		return -ENOSYS;
	}
2151 2152
	if (async) {
		/* do this part asynchronously */
2153
		init_completion(&ctx->dev->fw_load_complete);
2154 2155 2156 2157 2158 2159 2160
		err = request_firmware_nowait(THIS_MODULE, 1, ctx->fwname,
					      ctx->dev->dev->dev, GFP_KERNEL,
					      ctx, b43_fw_cb);
		if (err < 0) {
			pr_err("Unable to load firmware\n");
			return err;
		}
2161
		wait_for_completion(&ctx->dev->fw_load_complete);
2162 2163 2164
		if (ctx->blob)
			goto fw_ready;
	/* On some ARM systems, the async request will fail, but the next sync
2165
	 * request works. For this reason, we fall through here
2166 2167 2168 2169
	 */
	}
	err = request_firmware(&ctx->blob, ctx->fwname,
			       ctx->dev->dev->dev);
2170
	if (err == -ENOENT) {
2171 2172
		snprintf(ctx->errors[ctx->req_type],
			 sizeof(ctx->errors[ctx->req_type]),
2173 2174
			 "Firmware file \"%s\" not found\n",
			 ctx->fwname);
2175 2176
		return err;
	} else if (err) {
2177 2178 2179 2180
		snprintf(ctx->errors[ctx->req_type],
			 sizeof(ctx->errors[ctx->req_type]),
			 "Firmware file \"%s\" request failed (err=%d)\n",
			 ctx->fwname, err);
2181 2182
		return err;
	}
2183 2184
fw_ready:
	if (ctx->blob->size < sizeof(struct b43_fw_header))
2185
		goto err_format;
2186
	hdr = (struct b43_fw_header *)(ctx->blob->data);
2187 2188 2189 2190
	switch (hdr->type) {
	case B43_FW_TYPE_UCODE:
	case B43_FW_TYPE_PCM:
		size = be32_to_cpu(hdr->size);
2191
		if (size != ctx->blob->size - sizeof(struct b43_fw_header))
2192 2193 2194 2195 2196 2197 2198 2199 2200 2201
			goto err_format;
		/* fallthrough */
	case B43_FW_TYPE_IV:
		if (hdr->ver != 1)
			goto err_format;
		break;
	default:
		goto err_format;
	}

2202
	fw->data = ctx->blob;
M
Michael Buesch 已提交
2203
	fw->filename = name;
2204
	fw->type = ctx->req_type;
M
Michael Buesch 已提交
2205 2206

	return 0;
2207 2208

err_format:
2209 2210 2211
	snprintf(ctx->errors[ctx->req_type],
		 sizeof(ctx->errors[ctx->req_type]),
		 "Firmware file \"%s\" format error.\n", ctx->fwname);
2212
	release_firmware(ctx->blob);
M
Michael Buesch 已提交
2213

2214 2215 2216
	return -EPROTO;
}

2217
static int b43_try_request_fw(struct b43_request_fw_context *ctx)
2218
{
2219 2220
	struct b43_wldev *dev = ctx->dev;
	struct b43_firmware *fw = &ctx->dev->fw;
2221
	const u8 rev = ctx->dev->dev->core_rev;
2222 2223 2224 2225
	const char *filename;
	u32 tmshigh;
	int err;

2226 2227
	/* Files for HT and LCN were found by trying one by one */

M
Michael Buesch 已提交
2228
	/* Get microcode */
2229
	if ((rev >= 5) && (rev <= 10)) {
M
Michael Buesch 已提交
2230
		filename = "ucode5";
2231
	} else if ((rev >= 11) && (rev <= 12)) {
M
Michael Buesch 已提交
2232
		filename = "ucode11";
2233
	} else if (rev == 13) {
M
Michael Buesch 已提交
2234
		filename = "ucode13";
2235
	} else if (rev == 14) {
2236
		filename = "ucode14";
2237
	} else if (rev == 15) {
2238
		filename = "ucode15";
2239 2240 2241 2242 2243 2244 2245 2246
	} else {
		switch (dev->phy.type) {
		case B43_PHYTYPE_N:
			if (rev >= 16)
				filename = "ucode16_mimo";
			else
				goto err_no_ucode;
			break;
2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258
		case B43_PHYTYPE_HT:
			if (rev == 29)
				filename = "ucode29_mimo";
			else
				goto err_no_ucode;
			break;
		case B43_PHYTYPE_LCN:
			if (rev == 24)
				filename = "ucode24_mimo";
			else
				goto err_no_ucode;
			break;
2259 2260 2261 2262
		default:
			goto err_no_ucode;
		}
	}
2263
	err = b43_do_request_fw(ctx, filename, &fw->ucode, true);
M
Michael Buesch 已提交
2264 2265 2266 2267 2268 2269 2270 2271 2272 2273
	if (err)
		goto err_load;

	/* Get PCM code */
	if ((rev >= 5) && (rev <= 10))
		filename = "pcm5";
	else if (rev >= 11)
		filename = NULL;
	else
		goto err_no_pcm;
2274
	fw->pcm_request_failed = false;
2275
	err = b43_do_request_fw(ctx, filename, &fw->pcm, false);
2276 2277 2278
	if (err == -ENOENT) {
		/* We did not find a PCM file? Not fatal, but
		 * core rev <= 10 must do without hwcrypto then. */
2279
		fw->pcm_request_failed = true;
2280
	} else if (err)
M
Michael Buesch 已提交
2281 2282 2283 2284 2285 2286
		goto err_load;

	/* Get initvals */
	switch (dev->phy.type) {
	case B43_PHYTYPE_A:
		if ((rev >= 5) && (rev <= 10)) {
2287
			tmshigh = ssb_read32(dev->dev->sdev, SSB_TMSHIGH);
M
Michael Buesch 已提交
2288 2289 2290 2291 2292 2293 2294 2295
			if (tmshigh & B43_TMSHIGH_HAVE_2GHZ_PHY)
				filename = "a0g1initvals5";
			else
				filename = "a0g0initvals5";
		} else
			goto err_no_initvals;
		break;
	case B43_PHYTYPE_G:
2296
		if ((rev >= 5) && (rev <= 10))
M
Michael Buesch 已提交
2297
			filename = "b0g0initvals5";
2298
		else if (rev >= 13)
2299
			filename = "b0g0initvals13";
2300
		else
M
Michael Buesch 已提交
2301 2302 2303
			goto err_no_initvals;
		break;
	case B43_PHYTYPE_N:
2304 2305 2306
		if (rev >= 16)
			filename = "n0initvals16";
		else if ((rev >= 11) && (rev <= 12))
M
Michael Buesch 已提交
2307 2308 2309 2310
			filename = "n0initvals11";
		else
			goto err_no_initvals;
		break;
2311 2312 2313 2314 2315 2316 2317 2318 2319 2320
	case B43_PHYTYPE_LP:
		if (rev == 13)
			filename = "lp0initvals13";
		else if (rev == 14)
			filename = "lp0initvals14";
		else if (rev >= 15)
			filename = "lp0initvals15";
		else
			goto err_no_initvals;
		break;
2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332
	case B43_PHYTYPE_HT:
		if (rev == 29)
			filename = "ht0initvals29";
		else
			goto err_no_initvals;
		break;
	case B43_PHYTYPE_LCN:
		if (rev == 24)
			filename = "lcn0initvals24";
		else
			goto err_no_initvals;
		break;
M
Michael Buesch 已提交
2333 2334
	default:
		goto err_no_initvals;
2335
	}
2336
	err = b43_do_request_fw(ctx, filename, &fw->initvals, false);
M
Michael Buesch 已提交
2337 2338 2339 2340 2341 2342 2343
	if (err)
		goto err_load;

	/* Get bandswitch initvals */
	switch (dev->phy.type) {
	case B43_PHYTYPE_A:
		if ((rev >= 5) && (rev <= 10)) {
2344
			tmshigh = ssb_read32(dev->dev->sdev, SSB_TMSHIGH);
M
Michael Buesch 已提交
2345 2346 2347 2348 2349 2350 2351 2352 2353 2354
			if (tmshigh & B43_TMSHIGH_HAVE_2GHZ_PHY)
				filename = "a0g1bsinitvals5";
			else
				filename = "a0g0bsinitvals5";
		} else if (rev >= 11)
			filename = NULL;
		else
			goto err_no_initvals;
		break;
	case B43_PHYTYPE_G:
2355
		if ((rev >= 5) && (rev <= 10))
M
Michael Buesch 已提交
2356
			filename = "b0g0bsinitvals5";
2357 2358 2359 2360
		else if (rev >= 11)
			filename = NULL;
		else
			goto err_no_initvals;
M
Michael Buesch 已提交
2361 2362
		break;
	case B43_PHYTYPE_N:
2363 2364 2365
		if (rev >= 16)
			filename = "n0bsinitvals16";
		else if ((rev >= 11) && (rev <= 12))
M
Michael Buesch 已提交
2366 2367
			filename = "n0bsinitvals11";
		else
2368
			goto err_no_initvals;
M
Michael Buesch 已提交
2369
		break;
2370 2371 2372 2373 2374 2375 2376 2377 2378 2379
	case B43_PHYTYPE_LP:
		if (rev == 13)
			filename = "lp0bsinitvals13";
		else if (rev == 14)
			filename = "lp0bsinitvals14";
		else if (rev >= 15)
			filename = "lp0bsinitvals15";
		else
			goto err_no_initvals;
		break;
2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391
	case B43_PHYTYPE_HT:
		if (rev == 29)
			filename = "ht0bsinitvals29";
		else
			goto err_no_initvals;
		break;
	case B43_PHYTYPE_LCN:
		if (rev == 24)
			filename = "lcn0bsinitvals24";
		else
			goto err_no_initvals;
		break;
M
Michael Buesch 已提交
2392 2393
	default:
		goto err_no_initvals;
2394
	}
2395
	err = b43_do_request_fw(ctx, filename, &fw->initvals_band, false);
M
Michael Buesch 已提交
2396 2397
	if (err)
		goto err_load;
2398

J
Johannes Berg 已提交
2399 2400
	fw->opensource = (ctx->req_type == B43_FWTYPE_OPENSOURCE);

2401 2402 2403
	return 0;

err_no_ucode:
2404 2405 2406
	err = ctx->fatal_failure = -EOPNOTSUPP;
	b43err(dev->wl, "The driver does not know which firmware (ucode) "
	       "is required for your device (wl-core rev %u)\n", rev);
2407 2408 2409
	goto error;

err_no_pcm:
2410 2411 2412
	err = ctx->fatal_failure = -EOPNOTSUPP;
	b43err(dev->wl, "The driver does not know which firmware (PCM) "
	       "is required for your device (wl-core rev %u)\n", rev);
2413 2414 2415
	goto error;

err_no_initvals:
2416 2417 2418 2419 2420 2421 2422 2423 2424
	err = ctx->fatal_failure = -EOPNOTSUPP;
	b43err(dev->wl, "The driver does not know which firmware (initvals) "
	       "is required for your device (wl-core rev %u)\n", rev);
	goto error;

err_load:
	/* We failed to load this firmware image. The error message
	 * already is in ctx->errors. Return and let our caller decide
	 * what to do. */
2425 2426 2427 2428 2429 2430 2431
	goto error;

error:
	b43_release_firmware(dev);
	return err;
}

2432 2433
static int b43_one_core_attach(struct b43_bus_dev *dev, struct b43_wl *wl);
static void b43_one_core_detach(struct b43_bus_dev *dev);
L
Larry Finger 已提交
2434
static int b43_rng_init(struct b43_wl *wl);
2435 2436

static void b43_request_firmware(struct work_struct *work)
2437
{
2438 2439 2440
	struct b43_wl *wl = container_of(work,
			    struct b43_wl, firmware_load);
	struct b43_wldev *dev = wl->current_dev;
2441 2442 2443 2444 2445 2446 2447
	struct b43_request_fw_context *ctx;
	unsigned int i;
	int err;
	const char *errmsg;

	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
	if (!ctx)
2448
		return;
2449 2450 2451 2452 2453
	ctx->dev = dev;

	ctx->req_type = B43_FWTYPE_PROPRIETARY;
	err = b43_try_request_fw(ctx);
	if (!err)
2454 2455 2456
		goto start_ieee80211; /* Successfully loaded it. */
	/* Was fw version known? */
	if (ctx->fatal_failure)
2457 2458
		goto out;

2459
	/* proprietary fw not found, try open source */
2460 2461 2462
	ctx->req_type = B43_FWTYPE_OPENSOURCE;
	err = b43_try_request_fw(ctx);
	if (!err)
2463 2464
		goto start_ieee80211; /* Successfully loaded it. */
	if(ctx->fatal_failure)
2465 2466 2467 2468 2469 2470
		goto out;

	/* Could not find a usable firmware. Print the errors. */
	for (i = 0; i < B43_NR_FWTYPES; i++) {
		errmsg = ctx->errors[i];
		if (strlen(errmsg))
2471
			b43err(dev->wl, "%s", errmsg);
2472 2473
	}
	b43_print_fw_helptext(dev->wl, 1);
2474 2475 2476
	goto out;

start_ieee80211:
J
Johannes Berg 已提交
2477 2478 2479 2480
	wl->hw->queues = B43_QOS_QUEUE_NUM;
	if (!modparam_qos || dev->fw.opensource)
		wl->hw->queues = 1;

2481 2482 2483
	err = ieee80211_register_hw(wl->hw);
	if (err)
		goto err_one_core_detach;
2484
	wl->hw_registred = true;
2485
	b43_leds_register(wl->current_dev);
L
Larry Finger 已提交
2486 2487 2488 2489

	/* Register HW RNG driver */
	b43_rng_init(wl);

2490 2491 2492 2493
	goto out;

err_one_core_detach:
	b43_one_core_detach(dev->dev);
2494 2495 2496 2497 2498

out:
	kfree(ctx);
}

2499 2500
static int b43_upload_microcode(struct b43_wldev *dev)
{
2501
	struct wiphy *wiphy = dev->wl->hw->wiphy;
2502 2503 2504 2505
	const size_t hdr_len = sizeof(struct b43_fw_header);
	const __be32 *data;
	unsigned int i, len;
	u16 fwrev, fwpatch, fwdate, fwtime;
2506
	u32 tmp, macctl;
2507 2508
	int err = 0;

2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519
	/* Jump the microcode PSM to offset 0 */
	macctl = b43_read32(dev, B43_MMIO_MACCTL);
	B43_WARN_ON(macctl & B43_MACCTL_PSM_RUN);
	macctl |= B43_MACCTL_PSM_JMP0;
	b43_write32(dev, B43_MMIO_MACCTL, macctl);
	/* Zero out all microcode PSM registers and shared memory. */
	for (i = 0; i < 64; i++)
		b43_shm_write16(dev, B43_SHM_SCRATCH, i, 0);
	for (i = 0; i < 4096; i += 2)
		b43_shm_write16(dev, B43_SHM_SHARED, i, 0);

2520
	/* Upload Microcode. */
M
Michael Buesch 已提交
2521 2522
	data = (__be32 *) (dev->fw.ucode.data->data + hdr_len);
	len = (dev->fw.ucode.data->size - hdr_len) / sizeof(__be32);
2523 2524 2525 2526 2527 2528
	b43_shm_control_word(dev, B43_SHM_UCODE | B43_SHM_AUTOINC_W, 0x0000);
	for (i = 0; i < len; i++) {
		b43_write32(dev, B43_MMIO_SHM_DATA, be32_to_cpu(data[i]));
		udelay(10);
	}

M
Michael Buesch 已提交
2529
	if (dev->fw.pcm.data) {
2530
		/* Upload PCM data. */
M
Michael Buesch 已提交
2531 2532
		data = (__be32 *) (dev->fw.pcm.data->data + hdr_len);
		len = (dev->fw.pcm.data->size - hdr_len) / sizeof(__be32);
2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543
		b43_shm_control_word(dev, B43_SHM_HW, 0x01EA);
		b43_write32(dev, B43_MMIO_SHM_DATA, 0x00004000);
		/* No need for autoinc bit in SHM_HW */
		b43_shm_control_word(dev, B43_SHM_HW, 0x01EB);
		for (i = 0; i < len; i++) {
			b43_write32(dev, B43_MMIO_SHM_DATA, be32_to_cpu(data[i]));
			udelay(10);
		}
	}

	b43_write32(dev, B43_MMIO_GEN_IRQ_REASON, B43_IRQ_ALL);
2544 2545

	/* Start the microcode PSM */
R
Rafał Miłecki 已提交
2546 2547
	b43_maskset32(dev, B43_MMIO_MACCTL, ~B43_MACCTL_PSM_JMP0,
		      B43_MACCTL_PSM_RUN);
2548 2549 2550 2551 2552 2553 2554 2555

	/* Wait for the microcode to load and respond */
	i = 0;
	while (1) {
		tmp = b43_read32(dev, B43_MMIO_GEN_IRQ_REASON);
		if (tmp == B43_IRQ_MAC_SUSPENDED)
			break;
		i++;
2556
		if (i >= 20) {
2557
			b43err(dev->wl, "Microcode not responding\n");
2558
			b43_print_fw_helptext(dev->wl, 1);
2559
			err = -ENODEV;
2560 2561
			goto error;
		}
M
Michael Buesch 已提交
2562
		msleep(50);
2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575
	}
	b43_read32(dev, B43_MMIO_GEN_IRQ_REASON);	/* dummy read */

	/* Get and check the revisions. */
	fwrev = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_UCODEREV);
	fwpatch = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_UCODEPATCH);
	fwdate = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_UCODEDATE);
	fwtime = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_UCODETIME);

	if (fwrev <= 0x128) {
		b43err(dev->wl, "YOUR FIRMWARE IS TOO OLD. Firmware from "
		       "binary drivers older than version 4.x is unsupported. "
		       "You must upgrade your firmware files.\n");
2576
		b43_print_fw_helptext(dev->wl, 1);
2577
		err = -EOPNOTSUPP;
2578
		goto error;
2579 2580 2581
	}
	dev->fw.rev = fwrev;
	dev->fw.patch = fwpatch;
2582 2583 2584
	if (dev->fw.rev >= 598)
		dev->fw.hdr_format = B43_FW_HDR_598;
	else if (dev->fw.rev >= 410)
2585 2586 2587
		dev->fw.hdr_format = B43_FW_HDR_410;
	else
		dev->fw.hdr_format = B43_FW_HDR_351;
J
Johannes Berg 已提交
2588
	WARN_ON(dev->fw.opensource != (fwdate == 0xFFFF));
2589

J
Johannes Berg 已提交
2590
	dev->qos_enabled = dev->wl->hw->queues > 1;
M
Michael Buesch 已提交
2591
	/* Default to firmware/hardware crypto acceleration. */
2592
	dev->hwcrypto_enabled = true;
M
Michael Buesch 已提交
2593

2594
	if (dev->fw.opensource) {
M
Michael Buesch 已提交
2595 2596
		u16 fwcapa;

2597 2598
		/* Patchlevel info is encoded in the "time" field. */
		dev->fw.patch = fwtime;
M
Michael Buesch 已提交
2599 2600 2601 2602 2603 2604 2605
		b43info(dev->wl, "Loading OpenSource firmware version %u.%u\n",
			dev->fw.rev, dev->fw.patch);

		fwcapa = b43_fwcapa_read(dev);
		if (!(fwcapa & B43_FWCAPA_HWCRYPTO) || dev->fw.pcm_request_failed) {
			b43info(dev->wl, "Hardware crypto acceleration not supported by firmware\n");
			/* Disable hardware crypto and fall back to software crypto. */
2606
			dev->hwcrypto_enabled = false;
M
Michael Buesch 已提交
2607
		}
J
Johannes Berg 已提交
2608 2609
		/* adding QoS support should use an offline discovery mechanism */
		WARN(fwcapa & B43_FWCAPA_QOS, "QoS in OpenFW not supported\n");
2610 2611 2612 2613 2614 2615
	} else {
		b43info(dev->wl, "Loading firmware version %u.%u "
			"(20%.2i-%.2i-%.2i %.2i:%.2i:%.2i)\n",
			fwrev, fwpatch,
			(fwdate >> 12) & 0xF, (fwdate >> 8) & 0xF, fwdate & 0xFF,
			(fwtime >> 11) & 0x1F, (fwtime >> 5) & 0x3F, fwtime & 0x1F);
2616 2617 2618 2619 2620
		if (dev->fw.pcm_request_failed) {
			b43warn(dev->wl, "No \"pcm5.fw\" firmware file found. "
				"Hardware accelerated cryptography is disabled.\n");
			b43_print_fw_helptext(dev->wl, 0);
		}
2621
	}
2622

2623 2624
	snprintf(wiphy->fw_version, sizeof(wiphy->fw_version), "%u.%u",
			dev->fw.rev, dev->fw.patch);
2625
	wiphy->hw_version = dev->dev->core_id;
2626

2627
	if (dev->fw.hdr_format == B43_FW_HDR_351) {
2628 2629
		/* We're over the deadline, but we keep support for old fw
		 * until it turns out to be in major conflict with something new. */
2630
		b43warn(dev->wl, "You are using an old firmware image. "
2631 2632
			"Support for old firmware will be removed soon "
			"(official deadline was July 2008).\n");
2633 2634 2635
		b43_print_fw_helptext(dev->wl, 0);
	}

2636 2637 2638
	return 0;

error:
R
Rafał Miłecki 已提交
2639 2640 2641
	/* Stop the microcode PSM. */
	b43_maskset32(dev, B43_MMIO_MACCTL, ~B43_MACCTL_PSM_RUN,
		      B43_MACCTL_PSM_JMP0);
2642

2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673
	return err;
}

static int b43_write_initvals(struct b43_wldev *dev,
			      const struct b43_iv *ivals,
			      size_t count,
			      size_t array_size)
{
	const struct b43_iv *iv;
	u16 offset;
	size_t i;
	bool bit32;

	BUILD_BUG_ON(sizeof(struct b43_iv) != 6);
	iv = ivals;
	for (i = 0; i < count; i++) {
		if (array_size < sizeof(iv->offset_size))
			goto err_format;
		array_size -= sizeof(iv->offset_size);
		offset = be16_to_cpu(iv->offset_size);
		bit32 = !!(offset & B43_IV_32BIT);
		offset &= B43_IV_OFFSET_MASK;
		if (offset >= 0x1000)
			goto err_format;
		if (bit32) {
			u32 value;

			if (array_size < sizeof(iv->data.d32))
				goto err_format;
			array_size -= sizeof(iv->data.d32);

2674
			value = get_unaligned_be32(&iv->data.d32);
2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701
			b43_write32(dev, offset, value);

			iv = (const struct b43_iv *)((const uint8_t *)iv +
							sizeof(__be16) +
							sizeof(__be32));
		} else {
			u16 value;

			if (array_size < sizeof(iv->data.d16))
				goto err_format;
			array_size -= sizeof(iv->data.d16);

			value = be16_to_cpu(iv->data.d16);
			b43_write16(dev, offset, value);

			iv = (const struct b43_iv *)((const uint8_t *)iv +
							sizeof(__be16) +
							sizeof(__be16));
		}
	}
	if (array_size)
		goto err_format;

	return 0;

err_format:
	b43err(dev->wl, "Initial Values Firmware file-format error.\n");
2702
	b43_print_fw_helptext(dev->wl, 1);
2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715

	return -EPROTO;
}

static int b43_upload_initvals(struct b43_wldev *dev)
{
	const size_t hdr_len = sizeof(struct b43_fw_header);
	const struct b43_fw_header *hdr;
	struct b43_firmware *fw = &dev->fw;
	const struct b43_iv *ivals;
	size_t count;
	int err;

M
Michael Buesch 已提交
2716 2717
	hdr = (const struct b43_fw_header *)(fw->initvals.data->data);
	ivals = (const struct b43_iv *)(fw->initvals.data->data + hdr_len);
2718 2719
	count = be32_to_cpu(hdr->size);
	err = b43_write_initvals(dev, ivals, count,
M
Michael Buesch 已提交
2720
				 fw->initvals.data->size - hdr_len);
2721 2722
	if (err)
		goto out;
M
Michael Buesch 已提交
2723 2724 2725
	if (fw->initvals_band.data) {
		hdr = (const struct b43_fw_header *)(fw->initvals_band.data->data);
		ivals = (const struct b43_iv *)(fw->initvals_band.data->data + hdr_len);
2726 2727
		count = be32_to_cpu(hdr->size);
		err = b43_write_initvals(dev, ivals, count,
M
Michael Buesch 已提交
2728
					 fw->initvals_band.data->size - hdr_len);
2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739
		if (err)
			goto out;
	}
out:

	return err;
}

/* Initialize the GPIOs
 * http://bcm-specs.sipsolutions.net/GPIO
 */
2740 2741

#ifdef CONFIG_B43_SSB
2742
static struct ssb_device *b43_ssb_gpio_dev(struct b43_wldev *dev)
2743
{
2744
	struct ssb_bus *bus = dev->dev->sdev->bus;
2745 2746 2747 2748 2749 2750 2751

#ifdef CONFIG_SSB_DRIVER_PCICORE
	return (bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev);
#else
	return bus->chipco.dev;
#endif
}
2752
#endif
2753

2754 2755
static int b43_gpio_init(struct b43_wldev *dev)
{
2756
#ifdef CONFIG_B43_SSB
2757
	struct ssb_device *gpiodev;
2758
#endif
2759 2760
	u32 mask, set;

R
Rafał Miłecki 已提交
2761 2762
	b43_maskset32(dev, B43_MMIO_MACCTL, ~B43_MACCTL_GPOUTSMSK, 0);
	b43_maskset16(dev, B43_MMIO_GPIO_MASK, ~0, 0xF);
2763 2764 2765

	mask = 0x0000001F;
	set = 0x0000000F;
R
Rafał Miłecki 已提交
2766
	if (dev->dev->chip_id == 0x4301) {
2767 2768
		mask |= 0x0060;
		set |= 0x0060;
R
Rafał Miłecki 已提交
2769 2770 2771
	} else if (dev->dev->chip_id == 0x5354) {
		/* Don't allow overtaking buttons GPIOs */
		set &= 0x2; /* 0x2 is LED GPIO on BCM5354 */
2772
	}
R
Rafał Miłecki 已提交
2773

2774 2775 2776 2777
	if (0 /* FIXME: conditional unknown */ ) {
		b43_write16(dev, B43_MMIO_GPIO_MASK,
			    b43_read16(dev, B43_MMIO_GPIO_MASK)
			    | 0x0100);
R
Rafał Miłecki 已提交
2778 2779 2780 2781 2782 2783
		/* BT Coexistance Input */
		mask |= 0x0080;
		set |= 0x0080;
		/* BT Coexistance Out */
		mask |= 0x0100;
		set |= 0x0100;
2784
	}
R
Rafał Miłecki 已提交
2785
	if (dev->dev->bus_sprom->boardflags_lo & B43_BFL_PACTRL) {
R
Rafał Miłecki 已提交
2786
		/* PA is controlled by gpio 9, let ucode handle it */
2787 2788 2789 2790 2791 2792 2793
		b43_write16(dev, B43_MMIO_GPIO_MASK,
			    b43_read16(dev, B43_MMIO_GPIO_MASK)
			    | 0x0200);
		mask |= 0x0200;
		set |= 0x0200;
	}

2794
	switch (dev->dev->bus_type) {
2795 2796
#ifdef CONFIG_B43_BCMA
	case B43_BUS_BCMA:
2797
		bcma_chipco_gpio_control(&dev->dev->bdev->bus->drv_cc, mask, set);
2798 2799
		break;
#endif
2800 2801 2802 2803 2804 2805
#ifdef CONFIG_B43_SSB
	case B43_BUS_SSB:
		gpiodev = b43_ssb_gpio_dev(dev);
		if (gpiodev)
			ssb_write32(gpiodev, B43_GPIO_CONTROL,
				    (ssb_read32(gpiodev, B43_GPIO_CONTROL)
R
Rafał Miłecki 已提交
2806
				    & ~mask) | set);
2807 2808 2809
		break;
#endif
	}
2810 2811 2812 2813 2814 2815 2816

	return 0;
}

/* Turn off all GPIO stuff. Call this on module unload, for example. */
static void b43_gpio_cleanup(struct b43_wldev *dev)
{
2817
#ifdef CONFIG_B43_SSB
2818
	struct ssb_device *gpiodev;
2819
#endif
2820

2821
	switch (dev->dev->bus_type) {
2822 2823
#ifdef CONFIG_B43_BCMA
	case B43_BUS_BCMA:
2824
		bcma_chipco_gpio_control(&dev->dev->bdev->bus->drv_cc, ~0, 0);
2825 2826
		break;
#endif
2827 2828 2829 2830 2831 2832 2833 2834
#ifdef CONFIG_B43_SSB
	case B43_BUS_SSB:
		gpiodev = b43_ssb_gpio_dev(dev);
		if (gpiodev)
			ssb_write32(gpiodev, B43_GPIO_CONTROL, 0);
		break;
#endif
	}
2835 2836 2837
}

/* http://bcm-specs.sipsolutions.net/EnableMac */
2838
void b43_mac_enable(struct b43_wldev *dev)
2839
{
2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852
	if (b43_debug(dev, B43_DBG_FIRMWARE)) {
		u16 fwstate;

		fwstate = b43_shm_read16(dev, B43_SHM_SHARED,
					 B43_SHM_SH_UCODESTAT);
		if ((fwstate != B43_SHM_SH_UCODESTAT_SUSP) &&
		    (fwstate != B43_SHM_SH_UCODESTAT_SLEEP)) {
			b43err(dev->wl, "b43_mac_enable(): The firmware "
			       "should be suspended, but current state is %u\n",
			       fwstate);
		}
	}

2853 2854 2855
	dev->mac_suspended--;
	B43_WARN_ON(dev->mac_suspended < 0);
	if (dev->mac_suspended == 0) {
R
Rafał Miłecki 已提交
2856
		b43_maskset32(dev, B43_MMIO_MACCTL, ~0, B43_MACCTL_ENABLED);
2857 2858 2859 2860 2861 2862 2863 2864 2865 2866
		b43_write32(dev, B43_MMIO_GEN_IRQ_REASON,
			    B43_IRQ_MAC_SUSPENDED);
		/* Commit writes */
		b43_read32(dev, B43_MMIO_MACCTL);
		b43_read32(dev, B43_MMIO_GEN_IRQ_REASON);
		b43_power_saving_ctl_bits(dev, 0);
	}
}

/* http://bcm-specs.sipsolutions.net/SuspendMAC */
2867
void b43_mac_suspend(struct b43_wldev *dev)
2868 2869 2870 2871
{
	int i;
	u32 tmp;

2872
	might_sleep();
2873
	B43_WARN_ON(dev->mac_suspended < 0);
2874

2875 2876
	if (dev->mac_suspended == 0) {
		b43_power_saving_ctl_bits(dev, B43_PS_AWAKE);
R
Rafał Miłecki 已提交
2877
		b43_maskset32(dev, B43_MMIO_MACCTL, ~B43_MACCTL_ENABLED, 0);
2878 2879
		/* force pci to flush the write */
		b43_read32(dev, B43_MMIO_MACCTL);
2880 2881 2882 2883 2884 2885 2886
		for (i = 35; i; i--) {
			tmp = b43_read32(dev, B43_MMIO_GEN_IRQ_REASON);
			if (tmp & B43_IRQ_MAC_SUSPENDED)
				goto out;
			udelay(10);
		}
		/* Hm, it seems this will take some time. Use msleep(). */
2887
		for (i = 40; i; i--) {
2888 2889 2890
			tmp = b43_read32(dev, B43_MMIO_GEN_IRQ_REASON);
			if (tmp & B43_IRQ_MAC_SUSPENDED)
				goto out;
2891
			msleep(1);
2892 2893 2894
		}
		b43err(dev->wl, "MAC suspend failed\n");
	}
2895
out:
2896 2897 2898
	dev->mac_suspended++;
}

2899 2900 2901
/* http://bcm-v4.sipsolutions.net/802.11/PHY/N/MacPhyClkSet */
void b43_mac_phy_clock_set(struct b43_wldev *dev, bool on)
{
2902 2903 2904
	u32 tmp;

	switch (dev->dev->bus_type) {
2905 2906
#ifdef CONFIG_B43_BCMA
	case B43_BUS_BCMA:
2907
		tmp = bcma_aread32(dev->dev->bdev, BCMA_IOCTL);
2908 2909 2910 2911
		if (on)
			tmp |= B43_BCMA_IOCTL_MACPHYCLKEN;
		else
			tmp &= ~B43_BCMA_IOCTL_MACPHYCLKEN;
2912
		bcma_awrite32(dev->dev->bdev, BCMA_IOCTL, tmp);
2913 2914
		break;
#endif
2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925
#ifdef CONFIG_B43_SSB
	case B43_BUS_SSB:
		tmp = ssb_read32(dev->dev->sdev, SSB_TMSLOW);
		if (on)
			tmp |= B43_TMSLOW_MACPHYCLKEN;
		else
			tmp &= ~B43_TMSLOW_MACPHYCLKEN;
		ssb_write32(dev->dev->sdev, SSB_TMSLOW, tmp);
		break;
#endif
	}
2926 2927
}

2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940
static void b43_adjust_opmode(struct b43_wldev *dev)
{
	struct b43_wl *wl = dev->wl;
	u32 ctl;
	u16 cfp_pretbtt;

	ctl = b43_read32(dev, B43_MMIO_MACCTL);
	/* Reset status to STA infrastructure mode. */
	ctl &= ~B43_MACCTL_AP;
	ctl &= ~B43_MACCTL_KEEP_CTL;
	ctl &= ~B43_MACCTL_KEEP_BADPLCP;
	ctl &= ~B43_MACCTL_KEEP_BAD;
	ctl &= ~B43_MACCTL_PROMISC;
2941
	ctl &= ~B43_MACCTL_BEACPROMISC;
2942 2943
	ctl |= B43_MACCTL_INFRA;

2944 2945
	if (b43_is_mode(wl, NL80211_IFTYPE_AP) ||
	    b43_is_mode(wl, NL80211_IFTYPE_MESH_POINT))
2946
		ctl |= B43_MACCTL_AP;
2947
	else if (b43_is_mode(wl, NL80211_IFTYPE_ADHOC))
2948 2949 2950
		ctl &= ~B43_MACCTL_INFRA;

	if (wl->filter_flags & FIF_CONTROL)
2951
		ctl |= B43_MACCTL_KEEP_CTL;
2952 2953 2954 2955 2956
	if (wl->filter_flags & FIF_FCSFAIL)
		ctl |= B43_MACCTL_KEEP_BAD;
	if (wl->filter_flags & FIF_PLCPFAIL)
		ctl |= B43_MACCTL_KEEP_BADPLCP;
	if (wl->filter_flags & FIF_PROMISC_IN_BSS)
2957
		ctl |= B43_MACCTL_PROMISC;
2958 2959 2960
	if (wl->filter_flags & FIF_BCN_PRBRESP_PROMISC)
		ctl |= B43_MACCTL_BEACPROMISC;

2961 2962 2963
	/* Workaround: On old hardware the HW-MAC-address-filter
	 * doesn't work properly, so always run promisc in filter
	 * it in software. */
2964
	if (dev->dev->core_rev <= 4)
2965 2966 2967 2968 2969 2970
		ctl |= B43_MACCTL_PROMISC;

	b43_write32(dev, B43_MMIO_MACCTL, ctl);

	cfp_pretbtt = 2;
	if ((ctl & B43_MACCTL_INFRA) && !(ctl & B43_MACCTL_AP)) {
R
Rafał Miłecki 已提交
2971 2972
		if (dev->dev->chip_id == 0x4306 &&
		    dev->dev->chip_rev == 3)
2973 2974 2975 2976 2977
			cfp_pretbtt = 100;
		else
			cfp_pretbtt = 50;
	}
	b43_write16(dev, 0x612, cfp_pretbtt);
M
Michael Buesch 已提交
2978 2979 2980 2981 2982

	/* FIXME: We don't currently implement the PMQ mechanism,
	 *        so always disable it. If we want to implement PMQ,
	 *        we need to enable it here (clear DISCPMQ) in AP mode.
	 */
R
Rafał Miłecki 已提交
2983 2984 2985 2986
	if (0  /* ctl & B43_MACCTL_AP */)
		b43_maskset32(dev, B43_MMIO_MACCTL, ~B43_MACCTL_DISCPMQ, 0);
	else
		b43_maskset32(dev, B43_MMIO_MACCTL, ~0, B43_MACCTL_DISCPMQ);
2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008
}

static void b43_rate_memory_write(struct b43_wldev *dev, u16 rate, int is_ofdm)
{
	u16 offset;

	if (is_ofdm) {
		offset = 0x480;
		offset += (b43_plcp_get_ratecode_ofdm(rate) & 0x000F) * 2;
	} else {
		offset = 0x4C0;
		offset += (b43_plcp_get_ratecode_cck(rate) & 0x000F) * 2;
	}
	b43_shm_write16(dev, B43_SHM_SHARED, offset + 0x20,
			b43_shm_read16(dev, B43_SHM_SHARED, offset));
}

static void b43_rate_memory_init(struct b43_wldev *dev)
{
	switch (dev->phy.type) {
	case B43_PHYTYPE_A:
	case B43_PHYTYPE_G:
M
Michael Buesch 已提交
3009
	case B43_PHYTYPE_N:
G
Gábor Stefanik 已提交
3010
	case B43_PHYTYPE_LP:
3011
	case B43_PHYTYPE_HT:
R
Rafał Miłecki 已提交
3012
	case B43_PHYTYPE_LCN:
3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033
		b43_rate_memory_write(dev, B43_OFDM_RATE_6MB, 1);
		b43_rate_memory_write(dev, B43_OFDM_RATE_12MB, 1);
		b43_rate_memory_write(dev, B43_OFDM_RATE_18MB, 1);
		b43_rate_memory_write(dev, B43_OFDM_RATE_24MB, 1);
		b43_rate_memory_write(dev, B43_OFDM_RATE_36MB, 1);
		b43_rate_memory_write(dev, B43_OFDM_RATE_48MB, 1);
		b43_rate_memory_write(dev, B43_OFDM_RATE_54MB, 1);
		if (dev->phy.type == B43_PHYTYPE_A)
			break;
		/* fallthrough */
	case B43_PHYTYPE_B:
		b43_rate_memory_write(dev, B43_CCK_RATE_1MB, 0);
		b43_rate_memory_write(dev, B43_CCK_RATE_2MB, 0);
		b43_rate_memory_write(dev, B43_CCK_RATE_5MB, 0);
		b43_rate_memory_write(dev, B43_CCK_RATE_11MB, 0);
		break;
	default:
		B43_WARN_ON(1);
	}
}

3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047
/* Set the default values for the PHY TX Control Words. */
static void b43_set_phytxctl_defaults(struct b43_wldev *dev)
{
	u16 ctl = 0;

	ctl |= B43_TXH_PHY_ENC_CCK;
	ctl |= B43_TXH_PHY_ANT01AUTO;
	ctl |= B43_TXH_PHY_TXPWR;

	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_BEACPHYCTL, ctl);
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_ACKCTSPHYCTL, ctl);
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_PRPHYCTL, ctl);
}

3048 3049 3050
/* Set the TX-Antenna for management frames sent by firmware. */
static void b43_mgmtframe_txantenna(struct b43_wldev *dev, int antenna)
{
3051
	u16 ant;
3052 3053
	u16 tmp;

3054
	ant = b43_antenna_to_phyctl(antenna);
3055 3056 3057

	/* For ACK/CTS */
	tmp = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_ACKCTSPHYCTL);
3058
	tmp = (tmp & ~B43_TXH_PHY_ANT) | ant;
3059 3060 3061
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_ACKCTSPHYCTL, tmp);
	/* For Probe Resposes */
	tmp = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_PRPHYCTL);
3062
	tmp = (tmp & ~B43_TXH_PHY_ANT) | ant;
3063 3064 3065 3066 3067 3068
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_PRPHYCTL, tmp);
}

/* This is the opposite of b43_chip_init() */
static void b43_chip_exit(struct b43_wldev *dev)
{
M
Michael Buesch 已提交
3069
	b43_phy_exit(dev);
3070 3071 3072 3073 3074 3075 3076 3077 3078 3079
	b43_gpio_cleanup(dev);
	/* firmware is released later */
}

/* Initialize the chip
 * http://bcm-specs.sipsolutions.net/ChipInit
 */
static int b43_chip_init(struct b43_wldev *dev)
{
	struct b43_phy *phy = &dev->phy;
M
Michael Buesch 已提交
3080
	int err;
3081
	u32 macctl;
3082 3083
	u16 value16;

3084 3085 3086 3087 3088 3089
	/* Initialize the MAC control */
	macctl = B43_MACCTL_IHR_ENABLED | B43_MACCTL_SHM_ENABLED;
	if (dev->phy.gmode)
		macctl |= B43_MACCTL_GMODE;
	macctl |= B43_MACCTL_INFRA;
	b43_write32(dev, B43_MMIO_MACCTL, macctl);
3090 3091 3092 3093 3094 3095 3096 3097

	err = b43_upload_microcode(dev);
	if (err)
		goto out;	/* firmware is released later */

	err = b43_gpio_init(dev);
	if (err)
		goto out;	/* firmware is released later */
M
Michael Buesch 已提交
3098

3099 3100
	err = b43_upload_initvals(dev);
	if (err)
L
Larry Finger 已提交
3101
		goto err_gpio_clean;
3102

3103 3104
	/* Turn the Analog on and initialize the PHY. */
	phy->ops->switch_analog(dev, 1);
3105 3106
	err = b43_phy_init(dev);
	if (err)
M
Michael Buesch 已提交
3107
		goto err_gpio_clean;
3108

M
Michael Buesch 已提交
3109 3110 3111
	/* Disable Interference Mitigation. */
	if (phy->ops->interf_mitigation)
		phy->ops->interf_mitigation(dev, B43_INTERFMODE_NONE);
3112

M
Michael Buesch 已提交
3113 3114 3115
	/* Select the antennae */
	if (phy->ops->set_rx_antenna)
		phy->ops->set_rx_antenna(dev, B43_ANTENNA_DEFAULT);
3116 3117 3118 3119 3120 3121 3122 3123
	b43_mgmtframe_txantenna(dev, B43_ANTENNA_DEFAULT);

	if (phy->type == B43_PHYTYPE_B) {
		value16 = b43_read16(dev, 0x005E);
		value16 |= 0x0004;
		b43_write16(dev, 0x005E, value16);
	}
	b43_write32(dev, 0x0100, 0x01000000);
3124
	if (dev->dev->core_rev < 5)
3125 3126
		b43_write32(dev, 0x010C, 0x01000000);

R
Rafał Miłecki 已提交
3127 3128
	b43_maskset32(dev, B43_MMIO_MACCTL, ~B43_MACCTL_INFRA, 0);
	b43_maskset32(dev, B43_MMIO_MACCTL, ~0, B43_MACCTL_INFRA);
3129 3130 3131

	/* Probe Response Timeout value */
	/* FIXME: Default to 0, has to be set by ioctl probably... :-/ */
H
Hauke Mehrtens 已提交
3132
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_PRMAXTIME, 0);
3133 3134 3135 3136

	/* Initially set the wireless operation mode. */
	b43_adjust_opmode(dev);

3137
	if (dev->dev->core_rev < 3) {
3138 3139 3140 3141 3142 3143 3144 3145 3146
		b43_write16(dev, 0x060E, 0x0000);
		b43_write16(dev, 0x0610, 0x8000);
		b43_write16(dev, 0x0604, 0x0000);
		b43_write16(dev, 0x0606, 0x0200);
	} else {
		b43_write32(dev, 0x0188, 0x80000000);
		b43_write32(dev, 0x018C, 0x02000000);
	}
	b43_write32(dev, B43_MMIO_GEN_IRQ_REASON, 0x00004000);
3147
	b43_write32(dev, B43_MMIO_DMA0_IRQ_MASK, 0x0001FC00);
3148 3149 3150 3151 3152 3153
	b43_write32(dev, B43_MMIO_DMA1_IRQ_MASK, 0x0000DC00);
	b43_write32(dev, B43_MMIO_DMA2_IRQ_MASK, 0x0000DC00);
	b43_write32(dev, B43_MMIO_DMA3_IRQ_MASK, 0x0001DC00);
	b43_write32(dev, B43_MMIO_DMA4_IRQ_MASK, 0x0000DC00);
	b43_write32(dev, B43_MMIO_DMA5_IRQ_MASK, 0x0000DC00);

3154
	b43_mac_phy_clock_set(dev, true);
3155

3156
	switch (dev->dev->bus_type) {
3157 3158 3159 3160 3161 3162
#ifdef CONFIG_B43_BCMA
	case B43_BUS_BCMA:
		/* FIXME: 0xE74 is quite common, but should be read from CC */
		b43_write16(dev, B43_MMIO_POWERUP_DELAY, 0xE74);
		break;
#endif
3163 3164 3165 3166 3167 3168 3169
#ifdef CONFIG_B43_SSB
	case B43_BUS_SSB:
		b43_write16(dev, B43_MMIO_POWERUP_DELAY,
			    dev->dev->sdev->bus->chipco.fast_pwrup_delay);
		break;
#endif
	}
3170 3171 3172

	err = 0;
	b43dbg(dev->wl, "Chip initialized\n");
M
Michael Buesch 已提交
3173
out:
3174 3175
	return err;

L
Larry Finger 已提交
3176
err_gpio_clean:
3177
	b43_gpio_cleanup(dev);
M
Michael Buesch 已提交
3178
	return err;
3179 3180 3181 3182
}

static void b43_periodic_every60sec(struct b43_wldev *dev)
{
M
Michael Buesch 已提交
3183
	const struct b43_phy_operations *ops = dev->phy.ops;
3184

M
Michael Buesch 已提交
3185 3186
	if (ops->pwork_60sec)
		ops->pwork_60sec(dev);
3187 3188 3189

	/* Force check the TX power emission now. */
	b43_phy_txpower_check(dev, B43_TXPWR_IGNORE_TIME);
3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200
}

static void b43_periodic_every30sec(struct b43_wldev *dev)
{
	/* Update device statistics. */
	b43_calculate_link_quality(dev);
}

static void b43_periodic_every15sec(struct b43_wldev *dev)
{
	struct b43_phy *phy = &dev->phy;
3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215
	u16 wdr;

	if (dev->fw.opensource) {
		/* Check if the firmware is still alive.
		 * It will reset the watchdog counter to 0 in its idle loop. */
		wdr = b43_shm_read16(dev, B43_SHM_SCRATCH, B43_WATCHDOG_REG);
		if (unlikely(wdr)) {
			b43err(dev->wl, "Firmware watchdog: The firmware died!\n");
			b43_controller_restart(dev, "Firmware watchdog");
			return;
		} else {
			b43_shm_write16(dev, B43_SHM_SCRATCH,
					B43_WATCHDOG_REG, 1);
		}
	}
3216

M
Michael Buesch 已提交
3217 3218 3219
	if (phy->ops->pwork_15sec)
		phy->ops->pwork_15sec(dev);

3220 3221
	atomic_set(&phy->txerr_cnt, B43_PHY_TX_BADNESS_LIMIT);
	wmb();
3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242

#if B43_DEBUG
	if (b43_debug(dev, B43_DBG_VERBOSESTATS)) {
		unsigned int i;

		b43dbg(dev->wl, "Stats: %7u IRQs/sec, %7u TX/sec, %7u RX/sec\n",
		       dev->irq_count / 15,
		       dev->tx_count / 15,
		       dev->rx_count / 15);
		dev->irq_count = 0;
		dev->tx_count = 0;
		dev->rx_count = 0;
		for (i = 0; i < ARRAY_SIZE(dev->irq_bit_count); i++) {
			if (dev->irq_bit_count[i]) {
				b43dbg(dev->wl, "Stats: %7u IRQ-%02u/sec (0x%08X)\n",
				       dev->irq_bit_count[i] / 15, i, (1 << i));
				dev->irq_bit_count[i] = 0;
			}
		}
	}
#endif
3243 3244 3245 3246 3247 3248 3249
}

static void do_periodic_work(struct b43_wldev *dev)
{
	unsigned int state;

	state = dev->periodic_state;
3250
	if (state % 4 == 0)
3251
		b43_periodic_every60sec(dev);
3252
	if (state % 2 == 0)
3253
		b43_periodic_every30sec(dev);
3254
	b43_periodic_every15sec(dev);
3255 3256
}

3257 3258 3259
/* Periodic work locking policy:
 * 	The whole periodic work handler is protected by
 * 	wl->mutex. If another lock is needed somewhere in the
3260
 * 	pwork callchain, it's acquired in-place, where it's needed.
3261 3262 3263
 */
static void b43_periodic_work_handler(struct work_struct *work)
{
3264 3265 3266 3267
	struct b43_wldev *dev = container_of(work, struct b43_wldev,
					     periodic_work.work);
	struct b43_wl *wl = dev->wl;
	unsigned long delay;
3268

3269
	mutex_lock(&wl->mutex);
3270 3271 3272 3273 3274 3275

	if (unlikely(b43_status(dev) != B43_STAT_STARTED))
		goto out;
	if (b43_debug(dev, B43_DBG_PWORK_STOP))
		goto out_requeue;

3276
	do_periodic_work(dev);
3277 3278

	dev->periodic_state++;
3279
out_requeue:
3280 3281 3282
	if (b43_debug(dev, B43_DBG_PWORK_FAST))
		delay = msecs_to_jiffies(50);
	else
3283
		delay = round_jiffies_relative(HZ * 15);
3284
	ieee80211_queue_delayed_work(wl->hw, &dev->periodic_work, delay);
3285
out:
3286
	mutex_unlock(&wl->mutex);
3287 3288 3289 3290 3291 3292 3293 3294
}

static void b43_periodic_tasks_setup(struct b43_wldev *dev)
{
	struct delayed_work *work = &dev->periodic_work;

	dev->periodic_state = 0;
	INIT_DELAYED_WORK(work, b43_periodic_work_handler);
3295
	ieee80211_queue_delayed_work(dev->wl->hw, work, 0);
3296 3297
}

3298
/* Check if communication with the device works correctly. */
3299 3300
static int b43_validate_chipaccess(struct b43_wldev *dev)
{
3301
	u32 v, backup0, backup4;
3302

3303 3304
	backup0 = b43_shm_read32(dev, B43_SHM_SHARED, 0);
	backup4 = b43_shm_read32(dev, B43_SHM_SHARED, 4);
3305 3306

	/* Check for read/write and endianness problems. */
3307 3308 3309
	b43_shm_write32(dev, B43_SHM_SHARED, 0, 0x55AAAA55);
	if (b43_shm_read32(dev, B43_SHM_SHARED, 0) != 0x55AAAA55)
		goto error;
3310 3311
	b43_shm_write32(dev, B43_SHM_SHARED, 0, 0xAA5555AA);
	if (b43_shm_read32(dev, B43_SHM_SHARED, 0) != 0xAA5555AA)
3312 3313
		goto error;

3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330
	/* Check if unaligned 32bit SHM_SHARED access works properly.
	 * However, don't bail out on failure, because it's noncritical. */
	b43_shm_write16(dev, B43_SHM_SHARED, 0, 0x1122);
	b43_shm_write16(dev, B43_SHM_SHARED, 2, 0x3344);
	b43_shm_write16(dev, B43_SHM_SHARED, 4, 0x5566);
	b43_shm_write16(dev, B43_SHM_SHARED, 6, 0x7788);
	if (b43_shm_read32(dev, B43_SHM_SHARED, 2) != 0x55663344)
		b43warn(dev->wl, "Unaligned 32bit SHM read access is broken\n");
	b43_shm_write32(dev, B43_SHM_SHARED, 2, 0xAABBCCDD);
	if (b43_shm_read16(dev, B43_SHM_SHARED, 0) != 0x1122 ||
	    b43_shm_read16(dev, B43_SHM_SHARED, 2) != 0xCCDD ||
	    b43_shm_read16(dev, B43_SHM_SHARED, 4) != 0xAABB ||
	    b43_shm_read16(dev, B43_SHM_SHARED, 6) != 0x7788)
		b43warn(dev->wl, "Unaligned 32bit SHM write access is broken\n");

	b43_shm_write32(dev, B43_SHM_SHARED, 0, backup0);
	b43_shm_write32(dev, B43_SHM_SHARED, 4, backup4);
3331

3332
	if ((dev->dev->core_rev >= 3) && (dev->dev->core_rev <= 10)) {
3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346
		/* The 32bit register shadows the two 16bit registers
		 * with update sideeffects. Validate this. */
		b43_write16(dev, B43_MMIO_TSF_CFP_START, 0xAAAA);
		b43_write32(dev, B43_MMIO_TSF_CFP_START, 0xCCCCBBBB);
		if (b43_read16(dev, B43_MMIO_TSF_CFP_START_LOW) != 0xBBBB)
			goto error;
		if (b43_read16(dev, B43_MMIO_TSF_CFP_START_HIGH) != 0xCCCC)
			goto error;
	}
	b43_write32(dev, B43_MMIO_TSF_CFP_START, 0);

	v = b43_read32(dev, B43_MMIO_MACCTL);
	v |= B43_MACCTL_GMODE;
	if (v != (B43_MACCTL_GMODE | B43_MACCTL_IHR_ENABLED))
3347 3348 3349
		goto error;

	return 0;
3350
error:
3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361
	b43err(dev->wl, "Failed to validate the chipaccess\n");
	return -ENODEV;
}

static void b43_security_init(struct b43_wldev *dev)
{
	dev->ktp = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_KTP);
	/* KTP is a word address, but we address SHM bytewise.
	 * So multiply by two.
	 */
	dev->ktp *= 2;
3362 3363 3364
	/* Number of RCMTA address slots */
	b43_write16(dev, B43_MMIO_RCMTA_COUNT, B43_NR_PAIRWISE_KEYS);
	/* Clear the key memory. */
3365 3366 3367
	b43_clear_keys(dev);
}

M
Michael Buesch 已提交
3368
#ifdef CONFIG_B43_HWRNG
J
John Daiker 已提交
3369
static int b43_rng_read(struct hwrng *rng, u32 *data)
3370 3371
{
	struct b43_wl *wl = (struct b43_wl *)rng->priv;
3372 3373
	struct b43_wldev *dev;
	int count = -ENODEV;
3374

3375 3376 3377 3378 3379 3380 3381
	mutex_lock(&wl->mutex);
	dev = wl->current_dev;
	if (likely(dev && b43_status(dev) >= B43_STAT_INITIALIZED)) {
		*data = b43_read16(dev, B43_MMIO_RNG);
		count = sizeof(u16);
	}
	mutex_unlock(&wl->mutex);
3382

3383
	return count;
3384
}
M
Michael Buesch 已提交
3385
#endif /* CONFIG_B43_HWRNG */
3386

3387
static void b43_rng_exit(struct b43_wl *wl)
3388
{
M
Michael Buesch 已提交
3389
#ifdef CONFIG_B43_HWRNG
3390
	if (wl->rng_initialized)
3391
		hwrng_unregister(&wl->rng);
M
Michael Buesch 已提交
3392
#endif /* CONFIG_B43_HWRNG */
3393 3394 3395 3396
}

static int b43_rng_init(struct b43_wl *wl)
{
M
Michael Buesch 已提交
3397
	int err = 0;
3398

M
Michael Buesch 已提交
3399
#ifdef CONFIG_B43_HWRNG
3400 3401 3402 3403 3404
	snprintf(wl->rng_name, ARRAY_SIZE(wl->rng_name),
		 "%s_%s", KBUILD_MODNAME, wiphy_name(wl->hw->wiphy));
	wl->rng.name = wl->rng_name;
	wl->rng.data_read = b43_rng_read;
	wl->rng.priv = (unsigned long)wl;
3405
	wl->rng_initialized = true;
3406 3407
	err = hwrng_register(&wl->rng);
	if (err) {
3408
		wl->rng_initialized = false;
3409 3410 3411
		b43err(wl, "Failed to register the random "
		       "number generator (%d)\n", err);
	}
M
Michael Buesch 已提交
3412
#endif /* CONFIG_B43_HWRNG */
3413 3414 3415 3416

	return err;
}

M
Michael Buesch 已提交
3417
static void b43_tx_work(struct work_struct *work)
3418
{
M
Michael Buesch 已提交
3419 3420 3421
	struct b43_wl *wl = container_of(work, struct b43_wl, tx_work);
	struct b43_wldev *dev;
	struct sk_buff *skb;
3422
	int queue_num;
M
Michael Buesch 已提交
3423
	int err = 0;
3424

M
Michael Buesch 已提交
3425 3426 3427 3428 3429
	mutex_lock(&wl->mutex);
	dev = wl->current_dev;
	if (unlikely(!dev || b43_status(dev) < B43_STAT_STARTED)) {
		mutex_unlock(&wl->mutex);
		return;
3430
	}
3431

3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445
	for (queue_num = 0; queue_num < B43_QOS_QUEUE_NUM; queue_num++) {
		while (skb_queue_len(&wl->tx_queue[queue_num])) {
			skb = skb_dequeue(&wl->tx_queue[queue_num]);
			if (b43_using_pio_transfers(dev))
				err = b43_pio_tx(dev, skb);
			else
				err = b43_dma_tx(dev, skb);
			if (err == -ENOSPC) {
				wl->tx_queue_stopped[queue_num] = 1;
				ieee80211_stop_queue(wl->hw, queue_num);
				skb_queue_head(&wl->tx_queue[queue_num], skb);
				break;
			}
			if (unlikely(err))
F
Felix Fietkau 已提交
3446
				ieee80211_free_txskb(wl->hw, skb);
3447 3448
			err = 0;
		}
3449

3450 3451
		if (!err)
			wl->tx_queue_stopped[queue_num] = 0;
3452 3453
	}

3454 3455 3456
#if B43_DEBUG
	dev->tx_count++;
#endif
M
Michael Buesch 已提交
3457 3458
	mutex_unlock(&wl->mutex);
}
3459

3460
static void b43_op_tx(struct ieee80211_hw *hw,
3461 3462
		      struct ieee80211_tx_control *control,
		      struct sk_buff *skb)
M
Michael Buesch 已提交
3463 3464 3465 3466 3467
{
	struct b43_wl *wl = hw_to_b43_wl(hw);

	if (unlikely(skb->len < 2 + 2 + 6)) {
		/* Too short, this can't be a valid frame. */
F
Felix Fietkau 已提交
3468
		ieee80211_free_txskb(hw, skb);
3469
		return;
M
Michael Buesch 已提交
3470 3471 3472
	}
	B43_WARN_ON(skb_shinfo(skb)->nr_frags);

3473 3474 3475 3476 3477 3478
	skb_queue_tail(&wl->tx_queue[skb->queue_mapping], skb);
	if (!wl->tx_queue_stopped[skb->queue_mapping]) {
		ieee80211_queue_work(wl->hw, &wl->tx_work);
	} else {
		ieee80211_stop_queue(wl->hw, skb->queue_mapping);
	}
3479 3480
}

M
Michael Buesch 已提交
3481 3482 3483 3484 3485
static void b43_qos_params_upload(struct b43_wldev *dev,
				  const struct ieee80211_tx_queue_params *p,
				  u16 shm_offset)
{
	u16 params[B43_NR_QOSPARAMS];
3486
	int bslots, tmp;
M
Michael Buesch 已提交
3487 3488
	unsigned int i;

3489 3490 3491
	if (!dev->qos_enabled)
		return;

3492
	bslots = b43_read16(dev, B43_MMIO_RNG) & p->cw_min;
M
Michael Buesch 已提交
3493 3494 3495 3496

	memset(&params, 0, sizeof(params));

	params[B43_QOSPARAM_TXOP] = p->txop * 32;
3497 3498 3499 3500
	params[B43_QOSPARAM_CWMIN] = p->cw_min;
	params[B43_QOSPARAM_CWMAX] = p->cw_max;
	params[B43_QOSPARAM_CWCUR] = p->cw_min;
	params[B43_QOSPARAM_AIFS] = p->aifs;
M
Michael Buesch 已提交
3501
	params[B43_QOSPARAM_BSLOTS] = bslots;
3502
	params[B43_QOSPARAM_REGGAP] = bslots + p->aifs;
M
Michael Buesch 已提交
3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520

	for (i = 0; i < ARRAY_SIZE(params); i++) {
		if (i == B43_QOSPARAM_STATUS) {
			tmp = b43_shm_read16(dev, B43_SHM_SHARED,
					     shm_offset + (i * 2));
			/* Mark the parameters as updated. */
			tmp |= 0x100;
			b43_shm_write16(dev, B43_SHM_SHARED,
					shm_offset + (i * 2),
					tmp);
		} else {
			b43_shm_write16(dev, B43_SHM_SHARED,
					shm_offset + (i * 2),
					params[i]);
		}
	}
}

M
Michael Buesch 已提交
3521 3522 3523 3524 3525 3526 3527 3528 3529
/* Mapping of mac80211 queue numbers to b43 QoS SHM offsets. */
static const u16 b43_qos_shm_offsets[] = {
	/* [mac80211-queue-nr] = SHM_OFFSET, */
	[0] = B43_QOS_VOICE,
	[1] = B43_QOS_VIDEO,
	[2] = B43_QOS_BESTEFFORT,
	[3] = B43_QOS_BACKGROUND,
};

3530 3531
/* Update all QOS parameters in hardware. */
static void b43_qos_upload_all(struct b43_wldev *dev)
M
Michael Buesch 已提交
3532 3533 3534 3535 3536
{
	struct b43_wl *wl = dev->wl;
	struct b43_qos_params *params;
	unsigned int i;

3537 3538 3539
	if (!dev->qos_enabled)
		return;

M
Michael Buesch 已提交
3540 3541
	BUILD_BUG_ON(ARRAY_SIZE(b43_qos_shm_offsets) !=
		     ARRAY_SIZE(wl->qos_params));
M
Michael Buesch 已提交
3542 3543 3544 3545

	b43_mac_suspend(dev);
	for (i = 0; i < ARRAY_SIZE(wl->qos_params); i++) {
		params = &(wl->qos_params[i]);
3546 3547
		b43_qos_params_upload(dev, &(params->p),
				      b43_qos_shm_offsets[i]);
M
Michael Buesch 已提交
3548 3549 3550 3551 3552 3553 3554 3555 3556
	}
	b43_mac_enable(dev);
}

static void b43_qos_clear(struct b43_wl *wl)
{
	struct b43_qos_params *params;
	unsigned int i;

M
Michael Buesch 已提交
3557 3558 3559 3560 3561
	/* Initialize QoS parameters to sane defaults. */

	BUILD_BUG_ON(ARRAY_SIZE(b43_qos_shm_offsets) !=
		     ARRAY_SIZE(wl->qos_params));

M
Michael Buesch 已提交
3562 3563 3564
	for (i = 0; i < ARRAY_SIZE(wl->qos_params); i++) {
		params = &(wl->qos_params[i]);

M
Michael Buesch 已提交
3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592
		switch (b43_qos_shm_offsets[i]) {
		case B43_QOS_VOICE:
			params->p.txop = 0;
			params->p.aifs = 2;
			params->p.cw_min = 0x0001;
			params->p.cw_max = 0x0001;
			break;
		case B43_QOS_VIDEO:
			params->p.txop = 0;
			params->p.aifs = 2;
			params->p.cw_min = 0x0001;
			params->p.cw_max = 0x0001;
			break;
		case B43_QOS_BESTEFFORT:
			params->p.txop = 0;
			params->p.aifs = 3;
			params->p.cw_min = 0x0001;
			params->p.cw_max = 0x03FF;
			break;
		case B43_QOS_BACKGROUND:
			params->p.txop = 0;
			params->p.aifs = 7;
			params->p.cw_min = 0x0001;
			params->p.cw_max = 0x03FF;
			break;
		default:
			B43_WARN_ON(1);
		}
M
Michael Buesch 已提交
3593 3594 3595 3596 3597 3598
	}
}

/* Initialize the core's QOS capabilities */
static void b43_qos_init(struct b43_wldev *dev)
{
3599 3600 3601 3602 3603 3604 3605 3606 3607 3608
	if (!dev->qos_enabled) {
		/* Disable QOS support. */
		b43_hf_write(dev, b43_hf_read(dev) & ~B43_HF_EDCF);
		b43_write16(dev, B43_MMIO_IFSCTL,
			    b43_read16(dev, B43_MMIO_IFSCTL)
			    & ~B43_MMIO_IFSCTL_USE_EDCF);
		b43dbg(dev->wl, "QoS disabled\n");
		return;
	}

M
Michael Buesch 已提交
3609
	/* Upload the current QOS parameters. */
3610
	b43_qos_upload_all(dev);
M
Michael Buesch 已提交
3611 3612 3613 3614 3615 3616

	/* Enable QOS support. */
	b43_hf_write(dev, b43_hf_read(dev) | B43_HF_EDCF);
	b43_write16(dev, B43_MMIO_IFSCTL,
		    b43_read16(dev, B43_MMIO_IFSCTL)
		    | B43_MMIO_IFSCTL_USE_EDCF);
3617
	b43dbg(dev->wl, "QoS enabled\n");
M
Michael Buesch 已提交
3618 3619
}

3620 3621
static int b43_op_conf_tx(struct ieee80211_hw *hw,
			  struct ieee80211_vif *vif, u16 _queue,
3622
			  const struct ieee80211_tx_queue_params *params)
3623
{
M
Michael Buesch 已提交
3624
	struct b43_wl *wl = hw_to_b43_wl(hw);
3625
	struct b43_wldev *dev;
M
Michael Buesch 已提交
3626
	unsigned int queue = (unsigned int)_queue;
3627
	int err = -ENODEV;
M
Michael Buesch 已提交
3628 3629 3630 3631 3632 3633 3634

	if (queue >= ARRAY_SIZE(wl->qos_params)) {
		/* Queue not available or don't support setting
		 * params on this queue. Return success to not
		 * confuse mac80211. */
		return 0;
	}
3635 3636
	BUILD_BUG_ON(ARRAY_SIZE(b43_qos_shm_offsets) !=
		     ARRAY_SIZE(wl->qos_params));
M
Michael Buesch 已提交
3637

3638 3639 3640 3641
	mutex_lock(&wl->mutex);
	dev = wl->current_dev;
	if (unlikely(!dev || (b43_status(dev) < B43_STAT_INITIALIZED)))
		goto out_unlock;
M
Michael Buesch 已提交
3642

3643 3644 3645 3646 3647 3648
	memcpy(&(wl->qos_params[queue].p), params, sizeof(*params));
	b43_mac_suspend(dev);
	b43_qos_params_upload(dev, &(wl->qos_params[queue].p),
			      b43_qos_shm_offsets[queue]);
	b43_mac_enable(dev);
	err = 0;
M
Michael Buesch 已提交
3649

3650 3651 3652 3653
out_unlock:
	mutex_unlock(&wl->mutex);

	return err;
3654 3655
}

3656 3657
static int b43_op_get_stats(struct ieee80211_hw *hw,
			    struct ieee80211_low_level_stats *stats)
3658 3659 3660
{
	struct b43_wl *wl = hw_to_b43_wl(hw);

M
Michael Buesch 已提交
3661
	mutex_lock(&wl->mutex);
3662
	memcpy(stats, &wl->ieee_stats, sizeof(*stats));
M
Michael Buesch 已提交
3663
	mutex_unlock(&wl->mutex);
3664 3665 3666 3667

	return 0;
}

3668
static u64 b43_op_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
	struct b43_wldev *dev;
	u64 tsf;

	mutex_lock(&wl->mutex);
	dev = wl->current_dev;

	if (dev && (b43_status(dev) >= B43_STAT_INITIALIZED))
		b43_tsf_read(dev, &tsf);
	else
		tsf = 0;

	mutex_unlock(&wl->mutex);

	return tsf;
}

3687 3688
static void b43_op_set_tsf(struct ieee80211_hw *hw,
			   struct ieee80211_vif *vif, u64 tsf)
3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
	struct b43_wldev *dev;

	mutex_lock(&wl->mutex);
	dev = wl->current_dev;

	if (dev && (b43_status(dev) >= B43_STAT_INITIALIZED))
		b43_tsf_write(dev, tsf);

	mutex_unlock(&wl->mutex);
}

3702 3703
static void b43_put_phy_into_reset(struct b43_wldev *dev)
{
3704
#ifdef CONFIG_B43_SSB
3705
	u32 tmp;
3706
#endif
3707

3708
	switch (dev->dev->bus_type) {
3709 3710 3711 3712 3713 3714
#ifdef CONFIG_B43_BCMA
	case B43_BUS_BCMA:
		b43err(dev->wl,
		       "Putting PHY into reset not supported on BCMA\n");
		break;
#endif
3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728
#ifdef CONFIG_B43_SSB
	case B43_BUS_SSB:
		tmp = ssb_read32(dev->dev->sdev, SSB_TMSLOW);
		tmp &= ~B43_TMSLOW_GMODE;
		tmp |= B43_TMSLOW_PHYRESET;
		tmp |= SSB_TMSLOW_FGC;
		ssb_write32(dev->dev->sdev, SSB_TMSLOW, tmp);
		msleep(1);

		tmp = ssb_read32(dev->dev->sdev, SSB_TMSLOW);
		tmp &= ~SSB_TMSLOW_FGC;
		tmp |= B43_TMSLOW_PHYRESET;
		ssb_write32(dev->dev->sdev, SSB_TMSLOW, tmp);
		msleep(1);
3729

3730 3731 3732
		break;
#endif
	}
3733 3734
}

J
John Daiker 已提交
3735
static const char *band_to_string(enum ieee80211_band band)
M
Michael Buesch 已提交
3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748
{
	switch (band) {
	case IEEE80211_BAND_5GHZ:
		return "5";
	case IEEE80211_BAND_2GHZ:
		return "2.4";
	default:
		break;
	}
	B43_WARN_ON(1);
	return "";
}

3749
/* Expects wl->mutex locked */
M
Michael Buesch 已提交
3750
static int b43_switch_band(struct b43_wl *wl, struct ieee80211_channel *chan)
3751
{
M
Michael Buesch 已提交
3752
	struct b43_wldev *up_dev = NULL;
3753 3754
	struct b43_wldev *down_dev;
	int err;
3755
	bool uninitialized_var(gmode);
3756 3757
	int prev_status;

M
Michael Buesch 已提交
3758
	/* Find a device and PHY which supports the band. */
3759 3760 3761 3762 3763
	switch (chan->band) {
	case IEEE80211_BAND_5GHZ:
		if (wl->current_dev->phy.supports_5ghz) {
			up_dev = wl->current_dev;
			gmode = false;
M
Michael Buesch 已提交
3764
		}
3765 3766 3767 3768 3769 3770 3771 3772 3773 3774
		break;
	case IEEE80211_BAND_2GHZ:
		if (wl->current_dev->phy.supports_2ghz) {
			up_dev = wl->current_dev;
			gmode = true;
		}
		break;
	default:
		B43_WARN_ON(1);
		return -EINVAL;
M
Michael Buesch 已提交
3775
	}
3776

M
Michael Buesch 已提交
3777 3778 3779 3780
	if (!up_dev) {
		b43err(wl, "Could not find a device for %s-GHz band operation\n",
		       band_to_string(chan->band));
		return -ENODEV;
3781
	}
3782
	if (!!wl->current_dev->phy.gmode == !!gmode) {
3783 3784 3785
		/* This device is already running. */
		return 0;
	}
M
Michael Buesch 已提交
3786 3787
	b43dbg(wl, "Switching to %s-GHz band\n",
	       band_to_string(chan->band));
3788 3789 3790 3791 3792
	down_dev = wl->current_dev;

	prev_status = b43_status(down_dev);
	/* Shutdown the currently running core. */
	if (prev_status >= B43_STAT_STARTED)
M
Michael Buesch 已提交
3793
		down_dev = b43_wireless_core_stop(down_dev);
3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808
	if (prev_status >= B43_STAT_INITIALIZED)
		b43_wireless_core_exit(down_dev);

	if (down_dev != up_dev) {
		/* We switch to a different core, so we put PHY into
		 * RESET on the old core. */
		b43_put_phy_into_reset(down_dev);
	}

	/* Now start the new core. */
	up_dev->phy.gmode = gmode;
	if (prev_status >= B43_STAT_INITIALIZED) {
		err = b43_wireless_core_init(up_dev);
		if (err) {
			b43err(wl, "Fatal: Could not initialize device for "
M
Michael Buesch 已提交
3809 3810
			       "selected %s-GHz band\n",
			       band_to_string(chan->band));
3811 3812 3813 3814 3815 3816
			goto init_failure;
		}
	}
	if (prev_status >= B43_STAT_STARTED) {
		err = b43_wireless_core_start(up_dev);
		if (err) {
A
Anatol Pomozov 已提交
3817
			b43err(wl, "Fatal: Could not start device for "
M
Michael Buesch 已提交
3818 3819
			       "selected %s-GHz band\n",
			       band_to_string(chan->band));
3820 3821 3822 3823 3824 3825 3826 3827 3828
			b43_wireless_core_exit(up_dev);
			goto init_failure;
		}
	}
	B43_WARN_ON(b43_status(up_dev) != prev_status);

	wl->current_dev = up_dev;

	return 0;
M
Michael Buesch 已提交
3829
init_failure:
3830 3831 3832 3833 3834
	/* Whoops, failed to init the new core. No core is operating now. */
	wl->current_dev = NULL;
	return err;
}

3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850
/* Write the short and long frame retry limit values. */
static void b43_set_retry_limits(struct b43_wldev *dev,
				 unsigned int short_retry,
				 unsigned int long_retry)
{
	/* The retry limit is a 4-bit counter. Enforce this to avoid overflowing
	 * the chip-internal counter. */
	short_retry = min(short_retry, (unsigned int)0xF);
	long_retry = min(long_retry, (unsigned int)0xF);

	b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_SRLIMIT,
			short_retry);
	b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_LRLIMIT,
			long_retry);
}

3851
static int b43_op_config(struct ieee80211_hw *hw, u32 changed)
3852 3853 3854 3855
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
	struct b43_wldev *dev;
	struct b43_phy *phy;
3856
	struct ieee80211_conf *conf = &hw->conf;
3857
	int antenna;
3858
	int err = 0;
3859
	bool reload_bss = false;
3860 3861 3862

	mutex_lock(&wl->mutex);

3863 3864
	dev = wl->current_dev;

M
Michael Buesch 已提交
3865
	/* Switch the band (if necessary). This might change the active core. */
3866
	err = b43_switch_band(wl, conf->chandef.chan);
3867 3868
	if (err)
		goto out_unlock_mutex;
3869 3870 3871 3872 3873 3874 3875 3876

	/* Need to reload all settings if the core changed */
	if (dev != wl->current_dev) {
		dev = wl->current_dev;
		changed = ~0;
		reload_bss = true;
	}

3877 3878
	phy = &dev->phy;

R
Rafał Miłecki 已提交
3879 3880 3881 3882 3883 3884
	if (conf_is_ht(conf))
		phy->is_40mhz =
			(conf_is_ht40_minus(conf) || conf_is_ht40_plus(conf));
	else
		phy->is_40mhz = false;

M
Michael Buesch 已提交
3885 3886
	b43_mac_suspend(dev);

3887 3888 3889 3890 3891
	if (changed & IEEE80211_CONF_CHANGE_RETRY_LIMITS)
		b43_set_retry_limits(dev, conf->short_frame_max_tx_count,
					  conf->long_frame_max_tx_count);
	changed &= ~IEEE80211_CONF_CHANGE_RETRY_LIMITS;
	if (!changed)
M
Michael Buesch 已提交
3892
		goto out_mac_enable;
3893 3894 3895

	/* Switch to the requested channel.
	 * The firmware takes care of races with the TX handler. */
3896 3897
	if (conf->chandef.chan->hw_value != phy->channel)
		b43_switch_channel(dev, conf->chandef.chan->hw_value);
3898

J
Johannes Berg 已提交
3899
	dev->wl->radiotap_enabled = !!(conf->flags & IEEE80211_CONF_MONITOR);
3900

3901 3902
	/* Adjust the desired TX power level. */
	if (conf->power_level != 0) {
3903 3904 3905 3906
		if (conf->power_level != phy->desired_txpower) {
			phy->desired_txpower = conf->power_level;
			b43_phy_txpower_check(dev, B43_TXPWR_IGNORE_TIME |
						   B43_TXPWR_IGNORE_TSSI);
3907 3908 3909 3910
		}
	}

	/* Antennas for RX and management frame TX. */
3911
	antenna = B43_ANTENNA_DEFAULT;
3912
	b43_mgmtframe_txantenna(dev, antenna);
3913
	antenna = B43_ANTENNA_DEFAULT;
M
Michael Buesch 已提交
3914 3915
	if (phy->ops->set_rx_antenna)
		phy->ops->set_rx_antenna(dev, antenna);
3916

3917 3918
	if (wl->radio_enabled != phy->radio_on) {
		if (wl->radio_enabled) {
J
Johannes Berg 已提交
3919
			b43_software_rfkill(dev, false);
3920 3921 3922 3923 3924 3925 3926
			b43info(dev->wl, "Radio turned on by software\n");
			if (!dev->radio_hw_enable) {
				b43info(dev->wl, "The hardware RF-kill button "
					"still turns the radio physically off. "
					"Press the button to turn it on.\n");
			}
		} else {
J
Johannes Berg 已提交
3927
			b43_software_rfkill(dev, true);
3928 3929 3930 3931
			b43info(dev->wl, "Radio turned off by software\n");
		}
	}

M
Michael Buesch 已提交
3932 3933 3934
out_mac_enable:
	b43_mac_enable(dev);
out_unlock_mutex:
3935 3936
	mutex_unlock(&wl->mutex);

3937 3938 3939
	if (wl->vif && reload_bss)
		b43_op_bss_info_changed(hw, wl->vif, &wl->vif->bss_conf, ~0);

3940 3941 3942
	return err;
}

3943
static void b43_update_basic_rates(struct b43_wldev *dev, u32 brates)
3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998
{
	struct ieee80211_supported_band *sband =
		dev->wl->hw->wiphy->bands[b43_current_band(dev->wl)];
	struct ieee80211_rate *rate;
	int i;
	u16 basic, direct, offset, basic_offset, rateptr;

	for (i = 0; i < sband->n_bitrates; i++) {
		rate = &sband->bitrates[i];

		if (b43_is_cck_rate(rate->hw_value)) {
			direct = B43_SHM_SH_CCKDIRECT;
			basic = B43_SHM_SH_CCKBASIC;
			offset = b43_plcp_get_ratecode_cck(rate->hw_value);
			offset &= 0xF;
		} else {
			direct = B43_SHM_SH_OFDMDIRECT;
			basic = B43_SHM_SH_OFDMBASIC;
			offset = b43_plcp_get_ratecode_ofdm(rate->hw_value);
			offset &= 0xF;
		}

		rate = ieee80211_get_response_rate(sband, brates, rate->bitrate);

		if (b43_is_cck_rate(rate->hw_value)) {
			basic_offset = b43_plcp_get_ratecode_cck(rate->hw_value);
			basic_offset &= 0xF;
		} else {
			basic_offset = b43_plcp_get_ratecode_ofdm(rate->hw_value);
			basic_offset &= 0xF;
		}

		/*
		 * Get the pointer that we need to point to
		 * from the direct map
		 */
		rateptr = b43_shm_read16(dev, B43_SHM_SHARED,
					 direct + 2 * basic_offset);
		/* and write it to the basic map */
		b43_shm_write16(dev, B43_SHM_SHARED, basic + 2 * offset,
				rateptr);
	}
}

static void b43_op_bss_info_changed(struct ieee80211_hw *hw,
				    struct ieee80211_vif *vif,
				    struct ieee80211_bss_conf *conf,
				    u32 changed)
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
	struct b43_wldev *dev;

	mutex_lock(&wl->mutex);

	dev = wl->current_dev;
M
Michael Buesch 已提交
3999
	if (!dev || b43_status(dev) < B43_STAT_STARTED)
4000
		goto out_unlock_mutex;
4001 4002 4003 4004 4005 4006 4007 4008

	B43_WARN_ON(wl->vif != vif);

	if (changed & BSS_CHANGED_BSSID) {
		if (conf->bssid)
			memcpy(wl->bssid, conf->bssid, ETH_ALEN);
		else
			memset(wl->bssid, 0, ETH_ALEN);
4009
	}
4010

4011 4012 4013 4014 4015 4016 4017 4018
	if (b43_status(dev) >= B43_STAT_INITIALIZED) {
		if (changed & BSS_CHANGED_BEACON &&
		    (b43_is_mode(wl, NL80211_IFTYPE_AP) ||
		     b43_is_mode(wl, NL80211_IFTYPE_MESH_POINT) ||
		     b43_is_mode(wl, NL80211_IFTYPE_ADHOC)))
			b43_update_templates(wl);

		if (changed & BSS_CHANGED_BSSID)
4019 4020 4021
			b43_write_mac_bssid_templates(dev);
	}

4022 4023
	b43_mac_suspend(dev);

4024 4025 4026 4027
	/* Update templates for AP/mesh mode. */
	if (changed & BSS_CHANGED_BEACON_INT &&
	    (b43_is_mode(wl, NL80211_IFTYPE_AP) ||
	     b43_is_mode(wl, NL80211_IFTYPE_MESH_POINT) ||
4028 4029
	     b43_is_mode(wl, NL80211_IFTYPE_ADHOC)) &&
	    conf->beacon_int)
4030 4031
		b43_set_beacon_int(dev, conf->beacon_int);

4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042
	if (changed & BSS_CHANGED_BASIC_RATES)
		b43_update_basic_rates(dev, conf->basic_rates);

	if (changed & BSS_CHANGED_ERP_SLOT) {
		if (conf->use_short_slot)
			b43_short_slot_timing_enable(dev);
		else
			b43_short_slot_timing_disable(dev);
	}

	b43_mac_enable(dev);
M
Michael Buesch 已提交
4043
out_unlock_mutex:
4044 4045 4046
	mutex_unlock(&wl->mutex);
}

4047
static int b43_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
4048 4049
			  struct ieee80211_vif *vif, struct ieee80211_sta *sta,
			  struct ieee80211_key_conf *key)
4050 4051
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
4052
	struct b43_wldev *dev;
4053 4054
	u8 algorithm;
	u8 index;
4055
	int err;
4056
	static const u8 bcast_addr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
4057 4058 4059 4060

	if (modparam_nohwcrypt)
		return -ENOSPC; /* User disabled HW-crypto */

4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074
	if ((vif->type == NL80211_IFTYPE_ADHOC ||
	     vif->type == NL80211_IFTYPE_MESH_POINT) &&
	    (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
	     key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
	    !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
		/*
		 * For now, disable hw crypto for the RSN IBSS group keys. This
		 * could be optimized in the future, but until that gets
		 * implemented, use of software crypto for group addressed
		 * frames is a acceptable to allow RSN IBSS to be used.
		 */
		return -EOPNOTSUPP;
	}

4075 4076 4077 4078 4079 4080 4081
	mutex_lock(&wl->mutex);

	dev = wl->current_dev;
	err = -ENODEV;
	if (!dev || b43_status(dev) < B43_STAT_INITIALIZED)
		goto out_unlock;

M
Michael Buesch 已提交
4082
	if (dev->fw.pcm_request_failed || !dev->hwcrypto_enabled) {
4083 4084 4085 4086 4087 4088
		/* We don't have firmware for the crypto engine.
		 * Must use software-crypto. */
		err = -EOPNOTSUPP;
		goto out_unlock;
	}

4089
	err = -EINVAL;
4090 4091 4092 4093 4094 4095
	switch (key->cipher) {
	case WLAN_CIPHER_SUITE_WEP40:
		algorithm = B43_SEC_ALGO_WEP40;
		break;
	case WLAN_CIPHER_SUITE_WEP104:
		algorithm = B43_SEC_ALGO_WEP104;
4096
		break;
4097
	case WLAN_CIPHER_SUITE_TKIP:
4098 4099
		algorithm = B43_SEC_ALGO_TKIP;
		break;
4100
	case WLAN_CIPHER_SUITE_CCMP:
4101 4102 4103 4104
		algorithm = B43_SEC_ALGO_AES;
		break;
	default:
		B43_WARN_ON(1);
4105
		goto out_unlock;
4106 4107 4108 4109 4110 4111 4112
	}
	index = (u8) (key->keyidx);
	if (index > 3)
		goto out_unlock;

	switch (cmd) {
	case SET_KEY:
G
gregor kowski 已提交
4113 4114 4115 4116
		if (algorithm == B43_SEC_ALGO_TKIP &&
		    (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE) ||
		    !modparam_hwtkip)) {
			/* We support only pairwise key */
4117 4118 4119 4120
			err = -EOPNOTSUPP;
			goto out_unlock;
		}

M
Michael Buesch 已提交
4121
		if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE) {
4122 4123 4124 4125
			if (WARN_ON(!sta)) {
				err = -EOPNOTSUPP;
				goto out_unlock;
			}
M
Michael Buesch 已提交
4126
			/* Pairwise key with an assigned MAC address. */
4127
			err = b43_key_write(dev, -1, algorithm,
4128 4129
					    key->key, key->keylen,
					    sta->addr, key);
M
Michael Buesch 已提交
4130 4131 4132 4133
		} else {
			/* Group key */
			err = b43_key_write(dev, index, algorithm,
					    key->key, key->keylen, NULL, key);
4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145
		}
		if (err)
			goto out_unlock;

		if (algorithm == B43_SEC_ALGO_WEP40 ||
		    algorithm == B43_SEC_ALGO_WEP104) {
			b43_hf_write(dev, b43_hf_read(dev) | B43_HF_USEDEFKEYS);
		} else {
			b43_hf_write(dev,
				     b43_hf_read(dev) & ~B43_HF_USEDEFKEYS);
		}
		key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
G
gregor kowski 已提交
4146 4147
		if (algorithm == B43_SEC_ALGO_TKIP)
			key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
4148 4149 4150 4151 4152 4153 4154 4155 4156 4157
		break;
	case DISABLE_KEY: {
		err = b43_key_clear(dev, key->hw_key_idx);
		if (err)
			goto out_unlock;
		break;
	}
	default:
		B43_WARN_ON(1);
	}
M
Michael Buesch 已提交
4158

4159 4160 4161
out_unlock:
	if (!err) {
		b43dbg(wl, "%s hardware based encryption for keyidx: %d, "
J
Johannes Berg 已提交
4162
		       "mac: %pM\n",
4163
		       cmd == SET_KEY ? "Using" : "Disabling", key->keyidx,
4164
		       sta ? sta->addr : bcast_addr);
M
Michael Buesch 已提交
4165
		b43_dump_keymemory(dev);
4166
	}
M
Michael Buesch 已提交
4167 4168
	mutex_unlock(&wl->mutex);

4169 4170 4171
	return err;
}

4172 4173
static void b43_op_configure_filter(struct ieee80211_hw *hw,
				    unsigned int changed, unsigned int *fflags,
4174
				    u64 multicast)
4175 4176
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
M
Michael Buesch 已提交
4177
	struct b43_wldev *dev;
4178

M
Michael Buesch 已提交
4179 4180
	mutex_lock(&wl->mutex);
	dev = wl->current_dev;
4181 4182
	if (!dev) {
		*fflags = 0;
M
Michael Buesch 已提交
4183
		goto out_unlock;
4184
	}
4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205

	*fflags &= FIF_PROMISC_IN_BSS |
		  FIF_ALLMULTI |
		  FIF_FCSFAIL |
		  FIF_PLCPFAIL |
		  FIF_CONTROL |
		  FIF_OTHER_BSS |
		  FIF_BCN_PRBRESP_PROMISC;

	changed &= FIF_PROMISC_IN_BSS |
		   FIF_ALLMULTI |
		   FIF_FCSFAIL |
		   FIF_PLCPFAIL |
		   FIF_CONTROL |
		   FIF_OTHER_BSS |
		   FIF_BCN_PRBRESP_PROMISC;

	wl->filter_flags = *fflags;

	if (changed && b43_status(dev) >= B43_STAT_INITIALIZED)
		b43_adjust_opmode(dev);
M
Michael Buesch 已提交
4206 4207 4208

out_unlock:
	mutex_unlock(&wl->mutex);
4209 4210
}

M
Michael Buesch 已提交
4211 4212 4213 4214
/* Locking: wl->mutex
 * Returns the current dev. This might be different from the passed in dev,
 * because the core might be gone away while we unlocked the mutex. */
static struct b43_wldev * b43_wireless_core_stop(struct b43_wldev *dev)
4215
{
L
Larry Finger 已提交
4216
	struct b43_wl *wl;
M
Michael Buesch 已提交
4217
	struct b43_wldev *orig_dev;
4218
	u32 mask;
4219
	int queue_num;
4220

L
Larry Finger 已提交
4221 4222 4223
	if (!dev)
		return NULL;
	wl = dev->wl;
M
Michael Buesch 已提交
4224 4225 4226
redo:
	if (!dev || b43_status(dev) < B43_STAT_STARTED)
		return dev;
4227

M
Michael Buesch 已提交
4228
	/* Cancel work. Unlock to avoid deadlocks. */
M
Michael Buesch 已提交
4229 4230
	mutex_unlock(&wl->mutex);
	cancel_delayed_work_sync(&dev->periodic_work);
M
Michael Buesch 已提交
4231
	cancel_work_sync(&wl->tx_work);
M
Michael Buesch 已提交
4232 4233 4234 4235 4236 4237
	mutex_lock(&wl->mutex);
	dev = wl->current_dev;
	if (!dev || b43_status(dev) < B43_STAT_STARTED) {
		/* Whoops, aliens ate up the device while we were unlocked. */
		return dev;
	}
4238

M
Michael Buesch 已提交
4239
	/* Disable interrupts on the device. */
4240
	b43_set_status(dev, B43_STAT_INITIALIZED);
4241
	if (b43_bus_host_is_sdio(dev->dev)) {
M
Michael Buesch 已提交
4242 4243 4244 4245 4246 4247 4248 4249 4250
		/* wl->mutex is locked. That is enough. */
		b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, 0);
		b43_read32(dev, B43_MMIO_GEN_IRQ_MASK);	/* Flush */
	} else {
		spin_lock_irq(&wl->hardirq_lock);
		b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, 0);
		b43_read32(dev, B43_MMIO_GEN_IRQ_MASK);	/* Flush */
		spin_unlock_irq(&wl->hardirq_lock);
	}
M
Michael Buesch 已提交
4251
	/* Synchronize and free the interrupt handlers. Unlock to avoid deadlocks. */
M
Michael Buesch 已提交
4252
	orig_dev = dev;
4253
	mutex_unlock(&wl->mutex);
4254
	if (b43_bus_host_is_sdio(dev->dev)) {
M
Michael Buesch 已提交
4255 4256
		b43_sdio_free_irq(dev);
	} else {
4257 4258
		synchronize_irq(dev->dev->irq);
		free_irq(dev->dev->irq, dev);
M
Michael Buesch 已提交
4259
	}
4260
	mutex_lock(&wl->mutex);
M
Michael Buesch 已提交
4261 4262 4263 4264 4265 4266 4267 4268
	dev = wl->current_dev;
	if (!dev)
		return dev;
	if (dev != orig_dev) {
		if (b43_status(dev) >= B43_STAT_STARTED)
			goto redo;
		return dev;
	}
4269 4270
	mask = b43_read32(dev, B43_MMIO_GEN_IRQ_MASK);
	B43_WARN_ON(mask != 0xFFFFFFFF && mask);
4271

4272 4273
	/* Drain all TX queues. */
	for (queue_num = 0; queue_num < B43_QOS_QUEUE_NUM; queue_num++) {
F
Felix Fietkau 已提交
4274 4275 4276 4277 4278 4279
		while (skb_queue_len(&wl->tx_queue[queue_num])) {
			struct sk_buff *skb;

			skb = skb_dequeue(&wl->tx_queue[queue_num]);
			ieee80211_free_txskb(wl->hw, skb);
		}
4280
	}
M
Michael Buesch 已提交
4281

4282
	b43_mac_suspend(dev);
4283
	b43_leds_exit(dev);
4284
	b43dbg(wl, "Wireless interface stopped\n");
M
Michael Buesch 已提交
4285 4286

	return dev;
4287 4288 4289 4290 4291 4292 4293 4294 4295 4296
}

/* Locking: wl->mutex */
static int b43_wireless_core_start(struct b43_wldev *dev)
{
	int err;

	B43_WARN_ON(b43_status(dev) != B43_STAT_INITIALIZED);

	drain_txstatus_queue(dev);
4297
	if (b43_bus_host_is_sdio(dev->dev)) {
4298 4299 4300 4301 4302 4303
		err = b43_sdio_request_irq(dev, b43_sdio_interrupt_handler);
		if (err) {
			b43err(dev->wl, "Cannot request SDIO IRQ\n");
			goto out;
		}
	} else {
4304
		err = request_threaded_irq(dev->dev->irq, b43_interrupt_handler,
4305 4306 4307
					   b43_interrupt_thread_handler,
					   IRQF_SHARED, KBUILD_MODNAME, dev);
		if (err) {
4308
			b43err(dev->wl, "Cannot request IRQ-%d\n",
4309
			       dev->dev->irq);
4310 4311
			goto out;
		}
4312 4313 4314
	}

	/* We are ready to run. */
4315
	ieee80211_wake_queues(dev->wl->hw);
4316 4317 4318 4319
	b43_set_status(dev, B43_STAT_STARTED);

	/* Start data flow (TX/RX). */
	b43_mac_enable(dev);
4320
	b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, dev->irq_mask);
4321

L
Lucas De Marchi 已提交
4322
	/* Start maintenance work */
4323 4324
	b43_periodic_tasks_setup(dev);

4325 4326
	b43_leds_init(dev);

4327
	b43dbg(dev->wl, "Wireless interface started\n");
4328
out:
4329 4330 4331
	return err;
}

4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360
static char *b43_phy_name(struct b43_wldev *dev, u8 phy_type)
{
	switch (phy_type) {
	case B43_PHYTYPE_A:
		return "A";
	case B43_PHYTYPE_B:
		return "B";
	case B43_PHYTYPE_G:
		return "G";
	case B43_PHYTYPE_N:
		return "N";
	case B43_PHYTYPE_LP:
		return "LP";
	case B43_PHYTYPE_SSLPN:
		return "SSLPN";
	case B43_PHYTYPE_HT:
		return "HT";
	case B43_PHYTYPE_LCN:
		return "LCN";
	case B43_PHYTYPE_LCNXN:
		return "LCNXN";
	case B43_PHYTYPE_LCN40:
		return "LCN40";
	case B43_PHYTYPE_AC:
		return "AC";
	}
	return "UNKNOWN";
}

4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389
/* Get PHY and RADIO versioning numbers */
static int b43_phy_versioning(struct b43_wldev *dev)
{
	struct b43_phy *phy = &dev->phy;
	u32 tmp;
	u8 analog_type;
	u8 phy_type;
	u8 phy_rev;
	u16 radio_manuf;
	u16 radio_ver;
	u16 radio_rev;
	int unsupported = 0;

	/* Get PHY versioning */
	tmp = b43_read16(dev, B43_MMIO_PHY_VER);
	analog_type = (tmp & B43_PHYVER_ANALOG) >> B43_PHYVER_ANALOG_SHIFT;
	phy_type = (tmp & B43_PHYVER_TYPE) >> B43_PHYVER_TYPE_SHIFT;
	phy_rev = (tmp & B43_PHYVER_VERSION);
	switch (phy_type) {
	case B43_PHYTYPE_A:
		if (phy_rev >= 4)
			unsupported = 1;
		break;
	case B43_PHYTYPE_B:
		if (phy_rev != 2 && phy_rev != 4 && phy_rev != 6
		    && phy_rev != 7)
			unsupported = 1;
		break;
	case B43_PHYTYPE_G:
4390
		if (phy_rev > 9)
4391 4392
			unsupported = 1;
		break;
4393
#ifdef CONFIG_B43_PHY_N
M
Michael Buesch 已提交
4394
	case B43_PHYTYPE_N:
4395
		if (phy_rev > 9)
M
Michael Buesch 已提交
4396 4397
			unsupported = 1;
		break;
4398 4399 4400
#endif
#ifdef CONFIG_B43_PHY_LP
	case B43_PHYTYPE_LP:
G
Gábor Stefanik 已提交
4401
		if (phy_rev > 2)
4402 4403
			unsupported = 1;
		break;
4404 4405 4406 4407 4408 4409
#endif
#ifdef CONFIG_B43_PHY_HT
	case B43_PHYTYPE_HT:
		if (phy_rev > 1)
			unsupported = 1;
		break;
4410 4411 4412 4413 4414 4415
#endif
#ifdef CONFIG_B43_PHY_LCN
	case B43_PHYTYPE_LCN:
		if (phy_rev > 1)
			unsupported = 1;
		break;
M
Michael Buesch 已提交
4416
#endif
4417 4418
	default:
		unsupported = 1;
4419
	}
4420
	if (unsupported) {
4421 4422 4423
		b43err(dev->wl, "FOUND UNSUPPORTED PHY (Analog %u, Type %d (%s), Revision %u)\n",
		       analog_type, phy_type, b43_phy_name(dev, phy_type),
		       phy_rev);
4424 4425
		return -EOPNOTSUPP;
	}
4426 4427
	b43info(dev->wl, "Found PHY: Analog %u, Type %d (%s), Revision %u\n",
		analog_type, phy_type, b43_phy_name(dev, phy_type), phy_rev);
4428 4429

	/* Get RADIO versioning */
4430
	if (dev->dev->core_rev >= 24) {
4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443
		u16 radio24[3];

		for (tmp = 0; tmp < 3; tmp++) {
			b43_write16(dev, B43_MMIO_RADIO24_CONTROL, tmp);
			radio24[tmp] = b43_read16(dev, B43_MMIO_RADIO24_DATA);
		}

		/* Broadcom uses "id" for our "ver" and has separated "ver" */
		/* radio_ver = (radio24[0] & 0xF0) >> 4; */

		radio_manuf = 0x17F;
		radio_ver = (radio24[2] << 8) | radio24[1];
		radio_rev = (radio24[0] & 0xF);
4444
	} else {
4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463
		if (dev->dev->chip_id == 0x4317) {
			if (dev->dev->chip_rev == 0)
				tmp = 0x3205017F;
			else if (dev->dev->chip_rev == 1)
				tmp = 0x4205017F;
			else
				tmp = 0x5205017F;
		} else {
			b43_write16(dev, B43_MMIO_RADIO_CONTROL,
				    B43_RADIOCTL_ID);
			tmp = b43_read16(dev, B43_MMIO_RADIO_DATA_LOW);
			b43_write16(dev, B43_MMIO_RADIO_CONTROL,
				    B43_RADIOCTL_ID);
			tmp |= (u32)b43_read16(dev, B43_MMIO_RADIO_DATA_HIGH)
				<< 16;
		}
		radio_manuf = (tmp & 0x00000FFF);
		radio_ver = (tmp & 0x0FFFF000) >> 12;
		radio_rev = (tmp & 0xF0000000) >> 28;
4464
	}
4465

4466 4467
	if (radio_manuf != 0x17F /* Broadcom */)
		unsupported = 1;
4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484
	switch (phy_type) {
	case B43_PHYTYPE_A:
		if (radio_ver != 0x2060)
			unsupported = 1;
		if (radio_rev != 1)
			unsupported = 1;
		if (radio_manuf != 0x17F)
			unsupported = 1;
		break;
	case B43_PHYTYPE_B:
		if ((radio_ver & 0xFFF0) != 0x2050)
			unsupported = 1;
		break;
	case B43_PHYTYPE_G:
		if (radio_ver != 0x2050)
			unsupported = 1;
		break;
4485
	case B43_PHYTYPE_N:
J
Johannes Berg 已提交
4486
		if (radio_ver != 0x2055 && radio_ver != 0x2056)
4487 4488
			unsupported = 1;
		break;
4489
	case B43_PHYTYPE_LP:
G
Gábor Stefanik 已提交
4490
		if (radio_ver != 0x2062 && radio_ver != 0x2063)
4491 4492
			unsupported = 1;
		break;
4493 4494 4495 4496
	case B43_PHYTYPE_HT:
		if (radio_ver != 0x2059)
			unsupported = 1;
		break;
4497 4498 4499 4500
	case B43_PHYTYPE_LCN:
		if (radio_ver != 0x2064)
			unsupported = 1;
		break;
4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527
	default:
		B43_WARN_ON(1);
	}
	if (unsupported) {
		b43err(dev->wl, "FOUND UNSUPPORTED RADIO "
		       "(Manuf 0x%X, Version 0x%X, Revision %u)\n",
		       radio_manuf, radio_ver, radio_rev);
		return -EOPNOTSUPP;
	}
	b43dbg(dev->wl, "Found Radio: Manuf 0x%X, Version 0x%X, Revision %u\n",
	       radio_manuf, radio_ver, radio_rev);

	phy->radio_manuf = radio_manuf;
	phy->radio_ver = radio_ver;
	phy->radio_rev = radio_rev;

	phy->analog = analog_type;
	phy->type = phy_type;
	phy->rev = phy_rev;

	return 0;
}

static void setup_struct_phy_for_init(struct b43_wldev *dev,
				      struct b43_phy *phy)
{
	phy->hardware_power_control = !!modparam_hwpctl;
4528
	phy->next_txpwr_check_time = jiffies;
4529 4530
	/* PHY TX errors counter. */
	atomic_set(&phy->txerr_cnt, B43_PHY_TX_BADNESS_LIMIT);
4531 4532

#if B43_DEBUG
4533 4534
	phy->phy_locked = false;
	phy->radio_locked = false;
4535
#endif
4536 4537 4538 4539
}

static void setup_struct_wldev_for_init(struct b43_wldev *dev)
{
4540
	dev->dfq_valid = false;
4541

4542 4543
	/* Assume the radio is enabled. If it's not enabled, the state will
	 * immediately get fixed on the first periodic work run. */
4544
	dev->radio_hw_enable = true;
4545 4546 4547 4548 4549 4550 4551 4552 4553

	/* Stats */
	memset(&dev->stats, 0, sizeof(dev->stats));

	setup_struct_phy_for_init(dev, &dev->phy);

	/* IRQ related flags */
	dev->irq_reason = 0;
	memset(dev->dma_reason, 0, sizeof(dev->dma_reason));
4554
	dev->irq_mask = B43_IRQ_MASKTEMPLATE;
4555
	if (b43_modparam_verbose < B43_VERBOSITY_DEBUG)
4556
		dev->irq_mask &= ~B43_IRQ_PHY_TXERR;
4557 4558 4559 4560 4561 4562 4563 4564 4565

	dev->mac_suspended = 1;

	/* Noise calculation context */
	memset(&dev->noisecalc, 0, sizeof(dev->noisecalc));
}

static void b43_bluetooth_coext_enable(struct b43_wldev *dev)
{
R
Rafał Miłecki 已提交
4566
	struct ssb_sprom *sprom = dev->dev->bus_sprom;
M
Michael Buesch 已提交
4567
	u64 hf;
4568

4569 4570
	if (!modparam_btcoex)
		return;
4571
	if (!(sprom->boardflags_lo & B43_BFL_BTCOEXIST))
4572 4573 4574 4575 4576
		return;
	if (dev->phy.type != B43_PHYTYPE_B && !dev->phy.gmode)
		return;

	hf = b43_hf_read(dev);
4577
	if (sprom->boardflags_lo & B43_BFL_BTCMOD)
4578 4579 4580 4581 4582 4583 4584
		hf |= B43_HF_BTCOEXALT;
	else
		hf |= B43_HF_BTCOEX;
	b43_hf_write(dev, hf);
}

static void b43_bluetooth_coext_disable(struct b43_wldev *dev)
4585 4586 4587 4588
{
	if (!modparam_btcoex)
		return;
	//TODO
4589 4590 4591 4592
}

static void b43_imcfglo_timeouts_workaround(struct b43_wldev *dev)
{
4593
	struct ssb_bus *bus;
4594 4595
	u32 tmp;

4596
#ifdef CONFIG_B43_SSB
4597 4598
	if (dev->dev->bus_type != B43_BUS_SSB)
		return;
4599 4600 4601
#else
	return;
#endif
4602 4603 4604

	bus = dev->dev->sdev->bus;

4605 4606
	if ((bus->chip_id == 0x4311 && bus->chip_rev == 2) ||
	    (bus->chip_id == 0x4312)) {
4607
		tmp = ssb_read32(dev->dev->sdev, SSB_IMCFGLO);
4608 4609 4610
		tmp &= ~SSB_IMCFGLO_REQTO;
		tmp &= ~SSB_IMCFGLO_SERTO;
		tmp |= 0x3;
4611
		ssb_write32(dev->dev->sdev, SSB_IMCFGLO, tmp);
4612
		ssb_commit_settings(bus);
4613 4614 4615
	}
}

M
Michael Buesch 已提交
4616 4617 4618 4619 4620 4621 4622 4623 4624
static void b43_set_synth_pu_delay(struct b43_wldev *dev, bool idle)
{
	u16 pu_delay;

	/* The time value is in microseconds. */
	if (dev->phy.type == B43_PHYTYPE_A)
		pu_delay = 3700;
	else
		pu_delay = 1050;
4625
	if (b43_is_mode(dev->wl, NL80211_IFTYPE_ADHOC) || idle)
M
Michael Buesch 已提交
4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638
		pu_delay = 500;
	if ((dev->phy.radio_ver == 0x2050) && (dev->phy.radio_rev == 8))
		pu_delay = max(pu_delay, (u16)2400);

	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_SPUWKUP, pu_delay);
}

/* Set the TSF CFP pre-TargetBeaconTransmissionTime. */
static void b43_set_pretbtt(struct b43_wldev *dev)
{
	u16 pretbtt;

	/* The time value is in microseconds. */
4639
	if (b43_is_mode(dev->wl, NL80211_IFTYPE_ADHOC)) {
M
Michael Buesch 已提交
4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650
		pretbtt = 2;
	} else {
		if (dev->phy.type == B43_PHYTYPE_A)
			pretbtt = 120;
		else
			pretbtt = 250;
	}
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_PRETBTT, pretbtt);
	b43_write16(dev, B43_MMIO_TSF_CFP_PRETBTT, pretbtt);
}

4651 4652 4653 4654
/* Shutdown a wireless core */
/* Locking: wl->mutex */
static void b43_wireless_core_exit(struct b43_wldev *dev)
{
M
Michael Buesch 已提交
4655 4656
	B43_WARN_ON(dev && b43_status(dev) > B43_STAT_INITIALIZED);
	if (!dev || b43_status(dev) != B43_STAT_INITIALIZED)
4657
		return;
4658

4659 4660
	b43_set_status(dev, B43_STAT_UNINIT);

4661
	/* Stop the microcode PSM. */
R
Rafał Miłecki 已提交
4662 4663
	b43_maskset32(dev, B43_MMIO_MACCTL, ~B43_MACCTL_PSM_RUN,
		      B43_MACCTL_PSM_JMP0);
4664

4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677
	switch (dev->dev->bus_type) {
#ifdef CONFIG_B43_BCMA
	case B43_BUS_BCMA:
		bcma_core_pci_down(dev->dev->bdev->bus);
		break;
#endif
#ifdef CONFIG_B43_SSB
	case B43_BUS_SSB:
		/* TODO */
		break;
#endif
	}

4678
	b43_dma_free(dev);
4679
	b43_pio_free(dev);
4680
	b43_chip_exit(dev);
4681
	dev->phy.ops->switch_analog(dev, 0);
4682 4683 4684 4685 4686
	if (dev->wl->current_beacon) {
		dev_kfree_skb_any(dev->wl->current_beacon);
		dev->wl->current_beacon = NULL;
	}

4687 4688
	b43_device_disable(dev, 0);
	b43_bus_may_powerdown(dev);
4689 4690 4691 4692 4693
}

/* Initialize a wireless core */
static int b43_wireless_core_init(struct b43_wldev *dev)
{
R
Rafał Miłecki 已提交
4694
	struct ssb_sprom *sprom = dev->dev->bus_sprom;
4695 4696
	struct b43_phy *phy = &dev->phy;
	int err;
M
Michael Buesch 已提交
4697
	u64 hf;
4698 4699 4700

	B43_WARN_ON(b43_status(dev) != B43_STAT_UNINIT);

4701
	err = b43_bus_powerup(dev, 0);
4702 4703
	if (err)
		goto out;
4704 4705
	if (!b43_device_is_enabled(dev))
		b43_wireless_core_reset(dev, phy->gmode);
4706

M
Michael Buesch 已提交
4707
	/* Reset all data structures. */
4708
	setup_struct_wldev_for_init(dev);
M
Michael Buesch 已提交
4709
	phy->ops->prepare_structs(dev);
4710 4711

	/* Enable IRQ routing to this device. */
4712
	switch (dev->dev->bus_type) {
4713 4714
#ifdef CONFIG_B43_BCMA
	case B43_BUS_BCMA:
4715
		bcma_core_pci_irq_ctl(&dev->dev->bdev->bus->drv_pci[0],
4716
				      dev->dev->bdev, true);
4717
		bcma_core_pci_up(dev->dev->bdev->bus);
4718 4719
		break;
#endif
4720 4721 4722 4723 4724 4725 4726
#ifdef CONFIG_B43_SSB
	case B43_BUS_SSB:
		ssb_pcicore_dev_irqvecs_enable(&dev->dev->sdev->bus->pcicore,
					       dev->dev->sdev);
		break;
#endif
	}
4727 4728 4729

	b43_imcfglo_timeouts_workaround(dev);
	b43_bluetooth_coext_disable(dev);
M
Michael Buesch 已提交
4730 4731
	if (phy->ops->prepare_hardware) {
		err = phy->ops->prepare_hardware(dev);
M
Michael Buesch 已提交
4732
		if (err)
M
Michael Buesch 已提交
4733
			goto err_busdown;
M
Michael Buesch 已提交
4734
	}
4735 4736
	err = b43_chip_init(dev);
	if (err)
M
Michael Buesch 已提交
4737
		goto err_busdown;
4738
	b43_shm_write16(dev, B43_SHM_SHARED,
4739
			B43_SHM_SH_WLCOREREV, dev->dev->core_rev);
4740 4741 4742 4743 4744
	hf = b43_hf_read(dev);
	if (phy->type == B43_PHYTYPE_G) {
		hf |= B43_HF_SYMW;
		if (phy->rev == 1)
			hf |= B43_HF_GDCW;
4745
		if (sprom->boardflags_lo & B43_BFL_PACTRL)
4746
			hf |= B43_HF_OFDMPABOOST;
M
Michael Buesch 已提交
4747 4748 4749 4750 4751 4752
	}
	if (phy->radio_ver == 0x2050) {
		if (phy->radio_rev == 6)
			hf |= B43_HF_4318TSSI;
		if (phy->radio_rev < 6)
			hf |= B43_HF_VCORECALC;
4753
	}
4754 4755
	if (sprom->boardflags_lo & B43_BFL_XTAL_NOSLOW)
		hf |= B43_HF_DSCRQ; /* Disable slowclock requests from ucode. */
4756
#if defined(CONFIG_B43_SSB) && defined(CONFIG_SSB_DRIVER_PCICORE)
4757 4758 4759
	if (dev->dev->bus_type == B43_BUS_SSB &&
	    dev->dev->sdev->bus->bustype == SSB_BUSTYPE_PCI &&
	    dev->dev->sdev->bus->pcicore.dev->id.revision <= 10)
4760
		hf |= B43_HF_PCISCW; /* PCI slow clock workaround. */
4761
#endif
4762
	hf &= ~B43_HF_SKCFPUP;
4763 4764
	b43_hf_write(dev, hf);

4765 4766
	b43_set_retry_limits(dev, B43_DEFAULT_SHORT_RETRY_LIMIT,
			     B43_DEFAULT_LONG_RETRY_LIMIT);
4767 4768 4769 4770 4771 4772 4773 4774 4775 4776
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_SFFBLIM, 3);
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_LFFBLIM, 2);

	/* Disable sending probe responses from firmware.
	 * Setting the MaxTime to one usec will always trigger
	 * a timeout, so we never send any probe resp.
	 * A timeout of zero is infinite. */
	b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_PRMAXTIME, 1);

	b43_rate_memory_init(dev);
4777
	b43_set_phytxctl_defaults(dev);
4778 4779

	/* Minimum Contention Window */
4780
	if (phy->type == B43_PHYTYPE_B)
4781
		b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_MINCONT, 0x1F);
4782
	else
4783 4784 4785 4786
		b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_MINCONT, 0xF);
	/* Maximum Contention Window */
	b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_MAXCONT, 0x3FF);

4787
	if (b43_bus_host_is_pcmcia(dev->dev) ||
4788
	    b43_bus_host_is_sdio(dev->dev)) {
4789
		dev->__using_pio_transfers = true;
4790 4791 4792 4793 4794
		err = b43_pio_init(dev);
	} else if (dev->use_pio) {
		b43warn(dev->wl, "Forced PIO by use_pio module parameter. "
			"This should not be needed and will result in lower "
			"performance.\n");
4795
		dev->__using_pio_transfers = true;
4796 4797
		err = b43_pio_init(dev);
	} else {
4798
		dev->__using_pio_transfers = false;
4799 4800
		err = b43_dma_init(dev);
	}
4801 4802
	if (err)
		goto err_chip_exit;
M
Michael Buesch 已提交
4803
	b43_qos_init(dev);
M
Michael Buesch 已提交
4804
	b43_set_synth_pu_delay(dev, 1);
4805 4806
	b43_bluetooth_coext_enable(dev);

4807
	b43_bus_powerup(dev, !(sprom->boardflags_lo & B43_BFL_XTAL_NOSLOW));
4808
	b43_upload_card_macaddress(dev);
4809 4810
	b43_security_init(dev);

M
Michael Buesch 已提交
4811
	ieee80211_wake_queues(dev->wl->hw);
4812 4813 4814

	b43_set_status(dev, B43_STAT_INITIALIZED);

L
Larry Finger 已提交
4815
out:
4816 4817
	return err;

M
Michael Buesch 已提交
4818
err_chip_exit:
4819
	b43_chip_exit(dev);
M
Michael Buesch 已提交
4820
err_busdown:
4821
	b43_bus_may_powerdown(dev);
4822 4823 4824 4825
	B43_WARN_ON(b43_status(dev) != B43_STAT_UNINIT);
	return err;
}

4826
static int b43_op_add_interface(struct ieee80211_hw *hw,
4827
				struct ieee80211_vif *vif)
4828 4829 4830 4831
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
	struct b43_wldev *dev;
	int err = -EOPNOTSUPP;
4832 4833 4834

	/* TODO: allow WDS/AP devices to coexist */

4835 4836 4837 4838 4839
	if (vif->type != NL80211_IFTYPE_AP &&
	    vif->type != NL80211_IFTYPE_MESH_POINT &&
	    vif->type != NL80211_IFTYPE_STATION &&
	    vif->type != NL80211_IFTYPE_WDS &&
	    vif->type != NL80211_IFTYPE_ADHOC)
4840
		return -EOPNOTSUPP;
4841 4842

	mutex_lock(&wl->mutex);
4843
	if (wl->operating)
4844 4845
		goto out_mutex_unlock;

4846
	b43dbg(wl, "Adding Interface type %d\n", vif->type);
4847 4848

	dev = wl->current_dev;
4849
	wl->operating = true;
4850 4851 4852
	wl->vif = vif;
	wl->if_type = vif->type;
	memcpy(wl->mac_addr, vif->addr, ETH_ALEN);
4853 4854

	b43_adjust_opmode(dev);
M
Michael Buesch 已提交
4855 4856
	b43_set_pretbtt(dev);
	b43_set_synth_pu_delay(dev, 0);
4857 4858 4859 4860 4861 4862
	b43_upload_card_macaddress(dev);

	err = 0;
 out_mutex_unlock:
	mutex_unlock(&wl->mutex);

4863 4864 4865
	if (err == 0)
		b43_op_bss_info_changed(hw, vif, &vif->bss_conf, ~0);

4866 4867 4868
	return err;
}

4869
static void b43_op_remove_interface(struct ieee80211_hw *hw,
4870
				    struct ieee80211_vif *vif)
4871 4872 4873 4874
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
	struct b43_wldev *dev = wl->current_dev;

4875
	b43dbg(wl, "Removing Interface type %d\n", vif->type);
4876 4877 4878 4879

	mutex_lock(&wl->mutex);

	B43_WARN_ON(!wl->operating);
4880
	B43_WARN_ON(wl->vif != vif);
4881
	wl->vif = NULL;
4882

4883
	wl->operating = false;
4884 4885 4886 4887 4888 4889 4890 4891

	b43_adjust_opmode(dev);
	memset(wl->mac_addr, 0, ETH_ALEN);
	b43_upload_card_macaddress(dev);

	mutex_unlock(&wl->mutex);
}

4892
static int b43_op_start(struct ieee80211_hw *hw)
4893 4894 4895 4896
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
	struct b43_wldev *dev = wl->current_dev;
	int did_init = 0;
4897
	int err = 0;
4898

M
Michael Buesch 已提交
4899 4900 4901 4902 4903 4904
	/* Kill all old instance specific information to make sure
	 * the card won't use it in the short timeframe between start
	 * and mac80211 reconfiguring it. */
	memset(wl->bssid, 0, ETH_ALEN);
	memset(wl->mac_addr, 0, ETH_ALEN);
	wl->filter_flags = 0;
4905
	wl->radiotap_enabled = false;
M
Michael Buesch 已提交
4906
	b43_qos_clear(wl);
4907 4908 4909 4910
	wl->beacon0_uploaded = false;
	wl->beacon1_uploaded = false;
	wl->beacon_templates_virgin = true;
	wl->radio_enabled = true;
M
Michael Buesch 已提交
4911

4912 4913
	mutex_lock(&wl->mutex);

4914 4915
	if (b43_status(dev) < B43_STAT_INITIALIZED) {
		err = b43_wireless_core_init(dev);
4916
		if (err)
4917 4918 4919
			goto out_mutex_unlock;
		did_init = 1;
	}
4920

4921 4922 4923 4924 4925 4926 4927 4928 4929
	if (b43_status(dev) < B43_STAT_STARTED) {
		err = b43_wireless_core_start(dev);
		if (err) {
			if (did_init)
				b43_wireless_core_exit(dev);
			goto out_mutex_unlock;
		}
	}

4930 4931 4932
	/* XXX: only do if device doesn't support rfkill irq */
	wiphy_rfkill_start_polling(hw->wiphy);

4933
 out_mutex_unlock:
4934 4935
	mutex_unlock(&wl->mutex);

4936 4937 4938 4939 4940 4941 4942 4943
	/*
	 * Configuration may have been overwritten during initialization.
	 * Reload the configuration, but only if initialization was
	 * successful. Reloading the configuration after a failed init
	 * may hang the system.
	 */
	if (!err)
		b43_op_config(hw, ~0);
4944

4945 4946 4947
	return err;
}

4948
static void b43_op_stop(struct ieee80211_hw *hw)
4949 4950
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
4951
	struct b43_wldev *dev = wl->current_dev;
4952

M
Michael Buesch 已提交
4953
	cancel_work_sync(&(wl->beacon_update_trigger));
L
Larry Finger 已提交
4954

4955 4956 4957
	if (!dev)
		goto out;

4958
	mutex_lock(&wl->mutex);
M
Michael Buesch 已提交
4959 4960 4961 4962 4963
	if (b43_status(dev) >= B43_STAT_STARTED) {
		dev = b43_wireless_core_stop(dev);
		if (!dev)
			goto out_unlock;
	}
4964
	b43_wireless_core_exit(dev);
4965
	wl->radio_enabled = false;
M
Michael Buesch 已提交
4966 4967

out_unlock:
4968
	mutex_unlock(&wl->mutex);
4969
out:
4970
	cancel_work_sync(&(wl->txpower_adjust_work));
4971 4972
}

4973 4974
static int b43_op_beacon_set_tim(struct ieee80211_hw *hw,
				 struct ieee80211_sta *sta, bool set)
4975 4976 4977
{
	struct b43_wl *wl = hw_to_b43_wl(hw);

4978
	/* FIXME: add locking */
4979
	b43_update_templates(wl);
4980 4981 4982 4983

	return 0;
}

4984 4985 4986
static void b43_op_sta_notify(struct ieee80211_hw *hw,
			      struct ieee80211_vif *vif,
			      enum sta_notify_cmd notify_cmd,
4987
			      struct ieee80211_sta *sta)
4988 4989 4990 4991 4992 4993
{
	struct b43_wl *wl = hw_to_b43_wl(hw);

	B43_WARN_ON(!vif || wl->vif != vif);
}

4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021
static void b43_op_sw_scan_start_notifier(struct ieee80211_hw *hw)
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
	struct b43_wldev *dev;

	mutex_lock(&wl->mutex);
	dev = wl->current_dev;
	if (dev && (b43_status(dev) >= B43_STAT_INITIALIZED)) {
		/* Disable CFP update during scan on other channels. */
		b43_hf_write(dev, b43_hf_read(dev) | B43_HF_SKCFPUP);
	}
	mutex_unlock(&wl->mutex);
}

static void b43_op_sw_scan_complete_notifier(struct ieee80211_hw *hw)
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
	struct b43_wldev *dev;

	mutex_lock(&wl->mutex);
	dev = wl->current_dev;
	if (dev && (b43_status(dev) >= B43_STAT_INITIALIZED)) {
		/* Re-enable CFP update. */
		b43_hf_write(dev, b43_hf_read(dev) & ~B43_HF_SKCFPUP);
	}
	mutex_unlock(&wl->mutex);
}

5022 5023 5024 5025 5026 5027 5028 5029 5030 5031
static int b43_op_get_survey(struct ieee80211_hw *hw, int idx,
			     struct survey_info *survey)
{
	struct b43_wl *wl = hw_to_b43_wl(hw);
	struct b43_wldev *dev = wl->current_dev;
	struct ieee80211_conf *conf = &hw->conf;

	if (idx != 0)
		return -ENOENT;

5032
	survey->channel = conf->chandef.chan;
5033 5034 5035 5036 5037 5038
	survey->filled = SURVEY_INFO_NOISE_DBM;
	survey->noise = dev->stats.link_noise;

	return 0;
}

5039
static const struct ieee80211_ops b43_hw_ops = {
5040 5041 5042 5043 5044
	.tx			= b43_op_tx,
	.conf_tx		= b43_op_conf_tx,
	.add_interface		= b43_op_add_interface,
	.remove_interface	= b43_op_remove_interface,
	.config			= b43_op_config,
5045
	.bss_info_changed	= b43_op_bss_info_changed,
5046 5047
	.configure_filter	= b43_op_configure_filter,
	.set_key		= b43_op_set_key,
G
gregor kowski 已提交
5048
	.update_tkip_key	= b43_op_update_tkip_key,
5049
	.get_stats		= b43_op_get_stats,
5050 5051
	.get_tsf		= b43_op_get_tsf,
	.set_tsf		= b43_op_set_tsf,
5052 5053
	.start			= b43_op_start,
	.stop			= b43_op_stop,
5054
	.set_tim		= b43_op_beacon_set_tim,
5055
	.sta_notify		= b43_op_sta_notify,
5056 5057
	.sw_scan_start		= b43_op_sw_scan_start_notifier,
	.sw_scan_complete	= b43_op_sw_scan_complete_notifier,
5058
	.get_survey		= b43_op_get_survey,
5059
	.rfkill_poll		= b43_rfkill_poll,
5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076
};

/* Hard-reset the chip. Do not call this directly.
 * Use b43_controller_restart()
 */
static void b43_chip_reset(struct work_struct *work)
{
	struct b43_wldev *dev =
	    container_of(work, struct b43_wldev, restart_work);
	struct b43_wl *wl = dev->wl;
	int err = 0;
	int prev_status;

	mutex_lock(&wl->mutex);

	prev_status = b43_status(dev);
	/* Bring the device down... */
M
Michael Buesch 已提交
5077 5078 5079 5080 5081 5082 5083
	if (prev_status >= B43_STAT_STARTED) {
		dev = b43_wireless_core_stop(dev);
		if (!dev) {
			err = -ENODEV;
			goto out;
		}
	}
5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099
	if (prev_status >= B43_STAT_INITIALIZED)
		b43_wireless_core_exit(dev);

	/* ...and up again. */
	if (prev_status >= B43_STAT_INITIALIZED) {
		err = b43_wireless_core_init(dev);
		if (err)
			goto out;
	}
	if (prev_status >= B43_STAT_STARTED) {
		err = b43_wireless_core_start(dev);
		if (err) {
			b43_wireless_core_exit(dev);
			goto out;
		}
	}
5100 5101 5102
out:
	if (err)
		wl->current_dev = NULL; /* Failed to init the dev. */
5103
	mutex_unlock(&wl->mutex);
5104 5105

	if (err) {
5106
		b43err(wl, "Controller restart FAILED\n");
5107 5108 5109 5110 5111 5112 5113 5114 5115
		return;
	}

	/* reload configuration */
	b43_op_config(wl->hw, ~0);
	if (wl->vif)
		b43_op_bss_info_changed(wl->hw, wl->vif, &wl->vif->bss_conf, ~0);

	b43info(wl, "Controller restarted\n");
5116 5117
}

M
Michael Buesch 已提交
5118
static int b43_setup_bands(struct b43_wldev *dev,
5119
			   bool have_2ghz_phy, bool have_5ghz_phy)
5120 5121 5122
{
	struct ieee80211_hw *hw = dev->wl->hw;

M
Michael Buesch 已提交
5123 5124 5125 5126 5127 5128 5129 5130 5131
	if (have_2ghz_phy)
		hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &b43_band_2GHz;
	if (dev->phy.type == B43_PHYTYPE_N) {
		if (have_5ghz_phy)
			hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &b43_band_5GHz_nphy;
	} else {
		if (have_5ghz_phy)
			hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &b43_band_5GHz_aphy;
	}
5132

M
Michael Buesch 已提交
5133 5134
	dev->phy.supports_2ghz = have_2ghz_phy;
	dev->phy.supports_5ghz = have_5ghz_phy;
5135 5136 5137 5138 5139 5140 5141 5142 5143

	return 0;
}

static void b43_wireless_core_detach(struct b43_wldev *dev)
{
	/* We release firmware that late to not be required to re-request
	 * is all the time when we reinit the core. */
	b43_release_firmware(dev);
M
Michael Buesch 已提交
5144
	b43_phy_free(dev);
5145 5146 5147 5148 5149
}

static int b43_wireless_core_attach(struct b43_wldev *dev)
{
	struct b43_wl *wl = dev->wl;
5150
	struct pci_dev *pdev = NULL;
5151
	int err;
5152
	u32 tmp;
5153
	bool have_2ghz_phy = false, have_5ghz_phy = false;
5154 5155 5156 5157 5158 5159 5160 5161

	/* Do NOT do any device initialization here.
	 * Do it in wireless_core_init() instead.
	 * This function is for gathering basic information about the HW, only.
	 * Also some structs may be set up here. But most likely you want to have
	 * that in core_init(), too.
	 */

5162 5163 5164 5165 5166 5167
#ifdef CONFIG_B43_SSB
	if (dev->dev->bus_type == B43_BUS_SSB &&
	    dev->dev->sdev->bus->bustype == SSB_BUSTYPE_PCI)
		pdev = dev->dev->sdev->bus->host_pci;
#endif

5168
	err = b43_bus_powerup(dev, 0);
5169 5170 5171 5172 5173
	if (err) {
		b43err(wl, "Bus powerup failed\n");
		goto out;
	}

5174 5175
	/* Get the PHY type. */
	switch (dev->dev->bus_type) {
5176 5177
#ifdef CONFIG_B43_BCMA
	case B43_BUS_BCMA:
5178 5179 5180
		tmp = bcma_aread32(dev->dev->bdev, BCMA_IOST);
		have_2ghz_phy = !!(tmp & B43_BCMA_IOST_2G_PHY);
		have_5ghz_phy = !!(tmp & B43_BCMA_IOST_5G_PHY);
5181 5182
		break;
#endif
5183 5184 5185
#ifdef CONFIG_B43_SSB
	case B43_BUS_SSB:
		if (dev->dev->core_rev >= 5) {
5186 5187 5188
			tmp = ssb_read32(dev->dev->sdev, SSB_TMSHIGH);
			have_2ghz_phy = !!(tmp & B43_TMSHIGH_HAVE_2GHZ_PHY);
			have_5ghz_phy = !!(tmp & B43_TMSHIGH_HAVE_5GHZ_PHY);
5189 5190 5191 5192 5193
		} else
			B43_WARN_ON(1);
		break;
#endif
	}
5194

5195
	dev->phy.gmode = have_2ghz_phy;
5196
	b43_wireless_core_reset(dev, dev->phy.gmode);
5197 5198 5199

	err = b43_phy_versioning(dev);
	if (err)
M
Michael Buesch 已提交
5200
		goto err_powerdown;
5201 5202 5203 5204 5205
	/* Check if this device supports multiband. */
	if (!pdev ||
	    (pdev->device != 0x4312 &&
	     pdev->device != 0x4319 && pdev->device != 0x4324)) {
		/* No multiband support. */
5206 5207
		have_2ghz_phy = false;
		have_5ghz_phy = false;
5208 5209
		switch (dev->phy.type) {
		case B43_PHYTYPE_A:
5210
			have_5ghz_phy = true;
5211
			break;
G
Gábor Stefanik 已提交
5212
		case B43_PHYTYPE_LP: //FIXME not always!
5213
#if 0 //FIXME enabling 5GHz causes a NULL pointer dereference
G
Gábor Stefanik 已提交
5214
			have_5ghz_phy = 1;
5215
#endif
5216
		case B43_PHYTYPE_G:
5217
		case B43_PHYTYPE_N:
5218 5219
		case B43_PHYTYPE_HT:
		case B43_PHYTYPE_LCN:
5220
			have_2ghz_phy = true;
5221 5222 5223 5224 5225
			break;
		default:
			B43_WARN_ON(1);
		}
	}
5226 5227 5228 5229 5230 5231
	if (dev->phy.type == B43_PHYTYPE_A) {
		/* FIXME */
		b43err(wl, "IEEE 802.11a devices are unsupported\n");
		err = -EOPNOTSUPP;
		goto err_powerdown;
	}
M
Michael Buesch 已提交
5232 5233
	if (1 /* disable A-PHY */) {
		/* FIXME: For now we disable the A-PHY on multi-PHY devices. */
G
Gábor Stefanik 已提交
5234 5235
		if (dev->phy.type != B43_PHYTYPE_N &&
		    dev->phy.type != B43_PHYTYPE_LP) {
5236 5237
			have_2ghz_phy = true;
			have_5ghz_phy = false;
M
Michael Buesch 已提交
5238 5239 5240
		}
	}

M
Michael Buesch 已提交
5241 5242 5243 5244
	err = b43_phy_allocate(dev);
	if (err)
		goto err_powerdown;

5245
	dev->phy.gmode = have_2ghz_phy;
5246
	b43_wireless_core_reset(dev, dev->phy.gmode);
5247 5248 5249

	err = b43_validate_chipaccess(dev);
	if (err)
M
Michael Buesch 已提交
5250
		goto err_phy_free;
M
Michael Buesch 已提交
5251
	err = b43_setup_bands(dev, have_2ghz_phy, have_5ghz_phy);
5252
	if (err)
M
Michael Buesch 已提交
5253
		goto err_phy_free;
5254 5255 5256 5257 5258 5259

	/* Now set some default "current_dev" */
	if (!wl->current_dev)
		wl->current_dev = dev;
	INIT_WORK(&dev->restart_work, b43_chip_reset);

5260
	dev->phy.ops->switch_analog(dev, 0);
5261 5262
	b43_device_disable(dev, 0);
	b43_bus_may_powerdown(dev);
5263 5264 5265 5266

out:
	return err;

M
Michael Buesch 已提交
5267 5268
err_phy_free:
	b43_phy_free(dev);
5269
err_powerdown:
5270
	b43_bus_may_powerdown(dev);
5271 5272 5273
	return err;
}

5274
static void b43_one_core_detach(struct b43_bus_dev *dev)
5275 5276 5277 5278
{
	struct b43_wldev *wldev;
	struct b43_wl *wl;

5279 5280 5281
	/* Do not cancel ieee80211-workqueue based work here.
	 * See comment in b43_remove(). */

5282
	wldev = b43_bus_get_wldev(dev);
5283 5284 5285 5286
	wl = wldev->wl;
	b43_debugfs_remove_device(wldev);
	b43_wireless_core_detach(wldev);
	list_del(&wldev->list);
5287
	b43_bus_set_wldev(dev, NULL);
5288 5289 5290
	kfree(wldev);
}

5291
static int b43_one_core_attach(struct b43_bus_dev *dev, struct b43_wl *wl)
5292 5293 5294 5295 5296 5297 5298 5299
{
	struct b43_wldev *wldev;
	int err = -ENOMEM;

	wldev = kzalloc(sizeof(*wldev), GFP_KERNEL);
	if (!wldev)
		goto out;

5300
	wldev->use_pio = b43_modparam_pio;
5301
	wldev->dev = dev;
5302 5303 5304 5305 5306 5307 5308 5309 5310
	wldev->wl = wl;
	b43_set_status(wldev, B43_STAT_UNINIT);
	wldev->bad_frames_preempt = modparam_bad_frames_preempt;
	INIT_LIST_HEAD(&wldev->list);

	err = b43_wireless_core_attach(wldev);
	if (err)
		goto err_kfree_wldev;

5311
	b43_bus_set_wldev(dev, wldev);
5312 5313 5314 5315 5316 5317 5318 5319 5320 5321
	b43_debugfs_add_device(wldev);

      out:
	return err;

      err_kfree_wldev:
	kfree(wldev);
	return err;
}

5322 5323 5324 5325 5326 5327
#define IS_PDEV(pdev, _vendor, _device, _subvendor, _subdevice)		( \
	(pdev->vendor == PCI_VENDOR_ID_##_vendor) &&			\
	(pdev->device == _device) &&					\
	(pdev->subsystem_vendor == PCI_VENDOR_ID_##_subvendor) &&	\
	(pdev->subsystem_device == _subdevice)				)

5328
#ifdef CONFIG_B43_SSB
5329 5330
static void b43_sprom_fixup(struct ssb_bus *bus)
{
5331 5332
	struct pci_dev *pdev;

5333 5334
	/* boardflags workarounds */
	if (bus->boardinfo.vendor == SSB_BOARDVENDOR_DELL &&
H
Hauke Mehrtens 已提交
5335
	    bus->chip_id == 0x4301 && bus->sprom.board_rev == 0x74)
5336
		bus->sprom.boardflags_lo |= B43_BFL_BTCOEXIST;
5337
	if (bus->boardinfo.vendor == PCI_VENDOR_ID_APPLE &&
H
Hauke Mehrtens 已提交
5338
	    bus->boardinfo.type == 0x4E && bus->sprom.board_rev > 0x40)
5339
		bus->sprom.boardflags_lo |= B43_BFL_PACTRL;
5340 5341
	if (bus->bustype == SSB_BUSTYPE_PCI) {
		pdev = bus->host_pci;
5342
		if (IS_PDEV(pdev, BROADCOM, 0x4318, ASUSTEK, 0x100F) ||
5343
		    IS_PDEV(pdev, BROADCOM, 0x4320,    DELL, 0x0003) ||
5344
		    IS_PDEV(pdev, BROADCOM, 0x4320,      HP, 0x12f8) ||
5345
		    IS_PDEV(pdev, BROADCOM, 0x4320, LINKSYS, 0x0015) ||
5346
		    IS_PDEV(pdev, BROADCOM, 0x4320, LINKSYS, 0x0014) ||
5347 5348
		    IS_PDEV(pdev, BROADCOM, 0x4320, LINKSYS, 0x0013) ||
		    IS_PDEV(pdev, BROADCOM, 0x4320, MOTOROLA, 0x7010))
5349 5350
			bus->sprom.boardflags_lo &= ~B43_BFL_BTCOEXIST;
	}
5351 5352
}

5353
static void b43_wireless_exit(struct b43_bus_dev *dev, struct b43_wl *wl)
5354 5355 5356
{
	struct ieee80211_hw *hw = wl->hw;

5357
	ssb_set_devtypedata(dev->sdev, NULL);
5358 5359
	ieee80211_free_hw(hw);
}
5360
#endif
5361

5362
static struct b43_wl *b43_wireless_init(struct b43_bus_dev *dev)
5363
{
5364
	struct ssb_sprom *sprom = dev->bus_sprom;
5365 5366
	struct ieee80211_hw *hw;
	struct b43_wl *wl;
5367
	char chip_name[6];
5368
	int queue_num;
5369 5370 5371 5372

	hw = ieee80211_alloc_hw(sizeof(*wl), &b43_hw_ops);
	if (!hw) {
		b43err(NULL, "Could not allocate ieee80211 device\n");
5373
		return ERR_PTR(-ENOMEM);
5374
	}
M
Michael Buesch 已提交
5375
	wl = hw_to_b43_wl(hw);
5376 5377

	/* fill hw info */
5378
	hw->flags = IEEE80211_HW_RX_INCLUDES_FCS |
5379
		    IEEE80211_HW_SIGNAL_DBM;
5380

5381 5382 5383 5384 5385 5386 5387
	hw->wiphy->interface_modes =
		BIT(NL80211_IFTYPE_AP) |
		BIT(NL80211_IFTYPE_MESH_POINT) |
		BIT(NL80211_IFTYPE_STATION) |
		BIT(NL80211_IFTYPE_WDS) |
		BIT(NL80211_IFTYPE_ADHOC);

5388 5389
	hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;

5390
	wl->hw_registred = false;
5391
	hw->max_rates = 2;
5392
	SET_IEEE80211_DEV(hw, dev->dev);
5393 5394
	if (is_valid_ether_addr(sprom->et1mac))
		SET_IEEE80211_PERM_ADDR(hw, sprom->et1mac);
5395
	else
5396
		SET_IEEE80211_PERM_ADDR(hw, sprom->il0mac);
5397

M
Michael Buesch 已提交
5398
	/* Initialize struct b43_wl */
5399 5400
	wl->hw = hw;
	mutex_init(&wl->mutex);
M
Michael Buesch 已提交
5401
	spin_lock_init(&wl->hardirq_lock);
M
Michael Buesch 已提交
5402
	INIT_WORK(&wl->beacon_update_trigger, b43_beacon_update_trigger_work);
5403
	INIT_WORK(&wl->txpower_adjust_work, b43_phy_txpower_adjust_work);
M
Michael Buesch 已提交
5404
	INIT_WORK(&wl->tx_work, b43_tx_work);
5405 5406 5407 5408 5409 5410

	/* Initialize queues and flags. */
	for (queue_num = 0; queue_num < B43_QOS_QUEUE_NUM; queue_num++) {
		skb_queue_head_init(&wl->tx_queue[queue_num]);
		wl->tx_queue_stopped[queue_num] = 0;
	}
5411

5412 5413 5414 5415
	snprintf(chip_name, ARRAY_SIZE(chip_name),
		 (dev->chip_id > 0x9999) ? "%d" : "%04X", dev->chip_id);
	b43info(wl, "Broadcom %s WLAN found (core revision %u)\n", chip_name,
		dev->core_rev);
5416
	return wl;
5417 5418
}

5419 5420 5421
#ifdef CONFIG_B43_BCMA
static int b43_bcma_probe(struct bcma_device *core)
{
R
Rafał Miłecki 已提交
5422
	struct b43_bus_dev *dev;
5423 5424
	struct b43_wl *wl;
	int err;
R
Rafał Miłecki 已提交
5425

5426 5427 5428 5429 5430 5431
	if (!modparam_allhwsupport &&
	    (core->id.rev == 0x17 || core->id.rev == 0x18)) {
		pr_err("Support for cores revisions 0x17 and 0x18 disabled by module param allhwsupport=0. Try b43.allhwsupport=1\n");
		return -ENOTSUPP;
	}

R
Rafał Miłecki 已提交
5432 5433 5434 5435
	dev = b43_bus_dev_bcma_init(core);
	if (!dev)
		return -ENODEV;

5436 5437 5438 5439 5440 5441 5442 5443 5444 5445
	wl = b43_wireless_init(dev);
	if (IS_ERR(wl)) {
		err = PTR_ERR(wl);
		goto bcma_out;
	}

	err = b43_one_core_attach(dev, wl);
	if (err)
		goto bcma_err_wireless_exit;

5446 5447 5448
	/* setup and start work to load firmware */
	INIT_WORK(&wl->firmware_load, b43_request_firmware);
	schedule_work(&wl->firmware_load);
5449 5450 5451 5452 5453 5454 5455

bcma_out:
	return err;

bcma_err_wireless_exit:
	ieee80211_free_hw(wl->hw);
	return err;
5456 5457 5458 5459
}

static void b43_bcma_remove(struct bcma_device *core)
{
5460 5461 5462 5463 5464 5465
	struct b43_wldev *wldev = bcma_get_drvdata(core);
	struct b43_wl *wl = wldev->wl;

	/* We must cancel any work here before unregistering from ieee80211,
	 * as the ieee80211 unreg will destroy the workqueue. */
	cancel_work_sync(&wldev->restart_work);
5466
	cancel_work_sync(&wl->firmware_load);
5467

5468
	B43_WARN_ON(!wl);
5469 5470
	if (!wldev->fw.ucode.data)
		return;			/* NULL if firmware never loaded */
5471 5472 5473 5474
	if (wl->current_dev == wldev && wl->hw_registred) {
		b43_leds_stop(wldev);
		ieee80211_unregister_hw(wl->hw);
	}
5475 5476 5477

	b43_one_core_detach(wldev->dev);

L
Larry Finger 已提交
5478 5479 5480
	/* Unregister HW RNG driver */
	b43_rng_exit(wl);

5481 5482 5483
	b43_leds_unregister(wl);

	ieee80211_free_hw(wl->hw);
5484 5485 5486 5487 5488 5489 5490 5491 5492 5493
}

static struct bcma_driver b43_bcma_driver = {
	.name		= KBUILD_MODNAME,
	.id_table	= b43_bcma_tbl,
	.probe		= b43_bcma_probe,
	.remove		= b43_bcma_remove,
};
#endif

5494
#ifdef CONFIG_B43_SSB
5495 5496
static
int b43_ssb_probe(struct ssb_device *sdev, const struct ssb_device_id *id)
5497
{
5498
	struct b43_bus_dev *dev;
5499 5500 5501
	struct b43_wl *wl;
	int err;

5502
	dev = b43_bus_dev_ssb_init(sdev);
5503 5504
	if (!dev)
		return -ENOMEM;
5505

5506
	wl = ssb_get_devtypedata(sdev);
5507 5508 5509 5510
	if (wl) {
		b43err(NULL, "Dual-core devices are not supported\n");
		err = -ENOTSUPP;
		goto err_ssb_kfree_dev;
5511
	}
5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522

	b43_sprom_fixup(sdev->bus);

	wl = b43_wireless_init(dev);
	if (IS_ERR(wl)) {
		err = PTR_ERR(wl);
		goto err_ssb_kfree_dev;
	}
	ssb_set_devtypedata(sdev, wl);
	B43_WARN_ON(ssb_get_devtypedata(sdev) != wl);

5523 5524
	err = b43_one_core_attach(dev, wl);
	if (err)
5525
		goto err_ssb_wireless_exit;
5526

5527 5528 5529
	/* setup and start work to load firmware */
	INIT_WORK(&wl->firmware_load, b43_request_firmware);
	schedule_work(&wl->firmware_load);
5530 5531 5532

	return err;

5533 5534 5535 5536
err_ssb_wireless_exit:
	b43_wireless_exit(dev, wl);
err_ssb_kfree_dev:
	kfree(dev);
5537 5538 5539
	return err;
}

5540
static void b43_ssb_remove(struct ssb_device *sdev)
5541
{
5542 5543
	struct b43_wl *wl = ssb_get_devtypedata(sdev);
	struct b43_wldev *wldev = ssb_get_drvdata(sdev);
5544
	struct b43_bus_dev *dev = wldev->dev;
5545

5546 5547 5548
	/* We must cancel any work here before unregistering from ieee80211,
	 * as the ieee80211 unreg will destroy the workqueue. */
	cancel_work_sync(&wldev->restart_work);
5549
	cancel_work_sync(&wl->firmware_load);
5550

5551
	B43_WARN_ON(!wl);
5552 5553
	if (!wldev->fw.ucode.data)
		return;			/* NULL if firmware never loaded */
5554
	if (wl->current_dev == wldev && wl->hw_registred) {
5555
		b43_leds_stop(wldev);
5556
		ieee80211_unregister_hw(wl->hw);
M
Michael Buesch 已提交
5557
	}
5558

5559
	b43_one_core_detach(dev);
5560

L
Larry Finger 已提交
5561 5562 5563
	/* Unregister HW RNG driver */
	b43_rng_exit(wl);

5564 5565
	b43_leds_unregister(wl);
	b43_wireless_exit(dev, wl);
5566 5567
}

5568 5569 5570 5571 5572 5573 5574 5575
static struct ssb_driver b43_ssb_driver = {
	.name		= KBUILD_MODNAME,
	.id_table	= b43_ssb_tbl,
	.probe		= b43_ssb_probe,
	.remove		= b43_ssb_remove,
};
#endif /* CONFIG_B43_SSB */

5576 5577 5578 5579 5580 5581 5582
/* Perform a hardware reset. This can be called from any context. */
void b43_controller_restart(struct b43_wldev *dev, const char *reason)
{
	/* Must avoid requeueing, if we are in shutdown. */
	if (b43_status(dev) < B43_STAT_INITIALIZED)
		return;
	b43info(dev->wl, "Controller RESET (%s) ...\n", reason);
5583
	ieee80211_queue_work(dev->wl->hw, &dev->restart_work);
5584 5585
}

M
Michael Buesch 已提交
5586 5587 5588
static void b43_print_driverinfo(void)
{
	const char *feat_pci = "", *feat_pcmcia = "", *feat_nphy = "",
5589
		   *feat_leds = "", *feat_sdio = "";
M
Michael Buesch 已提交
5590 5591 5592 5593 5594 5595 5596

#ifdef CONFIG_B43_PCI_AUTOSELECT
	feat_pci = "P";
#endif
#ifdef CONFIG_B43_PCMCIA
	feat_pcmcia = "M";
#endif
5597
#ifdef CONFIG_B43_PHY_N
M
Michael Buesch 已提交
5598 5599 5600 5601
	feat_nphy = "N";
#endif
#ifdef CONFIG_B43_LEDS
	feat_leds = "L";
5602 5603 5604
#endif
#ifdef CONFIG_B43_SDIO
	feat_sdio = "S";
M
Michael Buesch 已提交
5605 5606
#endif
	printk(KERN_INFO "Broadcom 43xx driver loaded "
M
Michael Büsch 已提交
5607
	       "[ Features: %s%s%s%s%s ]\n",
M
Michael Buesch 已提交
5608
	       feat_pci, feat_pcmcia, feat_nphy,
5609
	       feat_leds, feat_sdio);
M
Michael Buesch 已提交
5610 5611
}

5612 5613 5614 5615 5616 5617 5618 5619
static int __init b43_init(void)
{
	int err;

	b43_debugfs_init();
	err = b43_pcmcia_init();
	if (err)
		goto err_dfs_exit;
5620
	err = b43_sdio_init();
5621 5622
	if (err)
		goto err_pcmcia_exit;
5623 5624
#ifdef CONFIG_B43_BCMA
	err = bcma_driver_register(&b43_bcma_driver);
5625 5626
	if (err)
		goto err_sdio_exit;
5627
#endif
5628
#ifdef CONFIG_B43_SSB
5629 5630 5631
	err = ssb_driver_register(&b43_ssb_driver);
	if (err)
		goto err_bcma_driver_exit;
5632
#endif
M
Michael Buesch 已提交
5633
	b43_print_driverinfo();
5634 5635 5636

	return err;

5637
#ifdef CONFIG_B43_SSB
5638
err_bcma_driver_exit:
5639
#endif
5640 5641
#ifdef CONFIG_B43_BCMA
	bcma_driver_unregister(&b43_bcma_driver);
5642
err_sdio_exit:
5643
#endif
5644
	b43_sdio_exit();
5645 5646 5647 5648 5649 5650 5651 5652 5653
err_pcmcia_exit:
	b43_pcmcia_exit();
err_dfs_exit:
	b43_debugfs_exit();
	return err;
}

static void __exit b43_exit(void)
{
5654
#ifdef CONFIG_B43_SSB
5655
	ssb_driver_unregister(&b43_ssb_driver);
5656
#endif
5657 5658 5659
#ifdef CONFIG_B43_BCMA
	bcma_driver_unregister(&b43_bcma_driver);
#endif
5660
	b43_sdio_exit();
5661 5662 5663 5664 5665 5666
	b43_pcmcia_exit();
	b43_debugfs_exit();
}

module_init(b43_init)
module_exit(b43_exit)