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