2 * Copyright (c) 2010 Broadcom Corporation
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
11 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
13 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
14 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 #define __UNDEF_NO_VERSION__
19 #include <linux/etherdevice.h>
20 #include <linux/pci.h>
21 #include <linux/sched.h>
22 #include <linux/firmware.h>
23 #include <linux/interrupt.h>
24 #include <net/mac80211.h>
27 #include "phy/phy_int.h"
32 #include "ucode_loader.h"
33 #include "mac80211_if.h"
35 #define N_TX_QUEUES 4 /* #tx queues on mac80211<->driver interface */
37 #define LOCK(wl) spin_lock_bh(&(wl)->lock)
38 #define UNLOCK(wl) spin_unlock_bh(&(wl)->lock)
40 /* locking from inside brcms_isr */
41 #define ISR_LOCK(wl, flags)\
43 spin_lock(&(wl)->isr_lock);\
47 #define ISR_UNLOCK(wl, flags)\
49 spin_unlock(&(wl)->isr_lock);\
53 /* locking under LOCK() to synchronize with brcms_isr */
54 #define INT_LOCK(wl, flags) spin_lock_irqsave(&(wl)->isr_lock, flags)
55 #define INT_UNLOCK(wl, flags) spin_unlock_irqrestore(&(wl)->isr_lock, flags)
57 static void brcms_timer(unsigned long data
);
58 static void _brcms_timer(struct brcms_timer
*t
);
61 static int ieee_hw_init(struct ieee80211_hw
*hw
);
62 static int ieee_hw_rate_init(struct ieee80211_hw
*hw
);
64 static int wl_linux_watchdog(void *ctx
);
66 /* Flags we support */
67 #define MAC_FILTERS (FIF_PROMISC_IN_BSS | \
73 FIF_BCN_PRBRESP_PROMISC)
75 static int n_adapters_found
;
77 static int brcms_request_fw(struct brcms_info
*wl
, struct pci_dev
*pdev
);
78 static void brcms_release_fw(struct brcms_info
*wl
);
80 /* local prototypes */
81 static void brcms_dpc(unsigned long data
);
82 static irqreturn_t
brcms_isr(int irq
, void *dev_id
);
84 static int __devinit
brcms_pci_probe(struct pci_dev
*pdev
,
85 const struct pci_device_id
*ent
);
86 static void brcms_remove(struct pci_dev
*pdev
);
87 static void brcms_free(struct brcms_info
*wl
);
88 static void brcms_set_basic_rate(struct wl_rateset
*rs
, u16 rate
, bool is_br
);
90 MODULE_AUTHOR("Broadcom Corporation");
91 MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN driver.");
92 MODULE_SUPPORTED_DEVICE("Broadcom 802.11n WLAN cards");
93 MODULE_LICENSE("Dual BSD/GPL");
95 /* recognized PCI IDs */
96 static DEFINE_PCI_DEVICE_TABLE(brcms_pci_id_table
) = {
97 {PCI_VENDOR_ID_BROADCOM
, 0x4357, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0}, /* 43225 2G */
98 {PCI_VENDOR_ID_BROADCOM
, 0x4353, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0}, /* 43224 DUAL */
99 {PCI_VENDOR_ID_BROADCOM
, 0x4727, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0}, /* 4313 DUAL */
101 {PCI_VENDOR_ID_BROADCOM
, 0x0576, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0 },
105 MODULE_DEVICE_TABLE(pci
, brcms_pci_id_table
);
108 static int msglevel
= 0xdeadbeef;
109 module_param(msglevel
, int, 0);
110 static int phymsglevel
= 0xdeadbeef;
111 module_param(phymsglevel
, int, 0);
114 #define HW_TO_WL(hw) (hw->priv)
115 #define WL_TO_HW(wl) (wl->pub->ieee_hw)
117 /* MAC80211 callback functions */
118 static int brcms_ops_start(struct ieee80211_hw
*hw
);
119 static void brcms_ops_stop(struct ieee80211_hw
*hw
);
120 static int brcms_ops_add_interface(struct ieee80211_hw
*hw
,
121 struct ieee80211_vif
*vif
);
122 static void brcms_ops_remove_interface(struct ieee80211_hw
*hw
,
123 struct ieee80211_vif
*vif
);
124 static int brcms_ops_config(struct ieee80211_hw
*hw
, u32 changed
);
125 static void brcms_ops_bss_info_changed(struct ieee80211_hw
*hw
,
126 struct ieee80211_vif
*vif
,
127 struct ieee80211_bss_conf
*info
,
129 static void brcms_ops_configure_filter(struct ieee80211_hw
*hw
,
130 unsigned int changed_flags
,
131 unsigned int *total_flags
, u64 multicast
);
132 static int brcms_ops_set_tim(struct ieee80211_hw
*hw
, struct ieee80211_sta
*sta
,
134 static void brcms_ops_sw_scan_start(struct ieee80211_hw
*hw
);
135 static void brcms_ops_sw_scan_complete(struct ieee80211_hw
*hw
);
136 static void brcms_ops_set_tsf(struct ieee80211_hw
*hw
,
137 struct ieee80211_vif
*vif
, u64 tsf
);
138 static int brcms_ops_get_stats(struct ieee80211_hw
*hw
,
139 struct ieee80211_low_level_stats
*stats
);
140 static void brcms_ops_sta_notify(struct ieee80211_hw
*hw
,
141 struct ieee80211_vif
*vif
,
142 enum sta_notify_cmd cmd
,
143 struct ieee80211_sta
*sta
);
144 static int brcms_ops_conf_tx(struct ieee80211_hw
*hw
,
145 struct ieee80211_vif
*vif
, u16 queue
,
146 const struct ieee80211_tx_queue_params
*params
);
147 static u64
brcms_ops_get_tsf(struct ieee80211_hw
*hw
,
148 struct ieee80211_vif
*vif
);
149 static int brcms_ops_sta_add(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
150 struct ieee80211_sta
*sta
);
151 static int brcms_ops_sta_remove(struct ieee80211_hw
*hw
,
152 struct ieee80211_vif
*vif
,
153 struct ieee80211_sta
*sta
);
154 static int brcms_ops_ampdu_action(struct ieee80211_hw
*hw
,
155 struct ieee80211_vif
*vif
,
156 enum ieee80211_ampdu_mlme_action action
,
157 struct ieee80211_sta
*sta
, u16 tid
, u16
*ssn
,
159 static void brcms_ops_rfkill_poll(struct ieee80211_hw
*hw
);
160 static void brcms_ops_flush(struct ieee80211_hw
*hw
, bool drop
);
162 static void brcms_ops_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
164 struct brcms_info
*wl
= hw
->priv
;
168 wiphy_err(wl
->wiphy
, "ops->tx called while down\n");
172 brcms_c_sendpkt_mac80211(wl
->wlc
, skb
, hw
);
177 static int brcms_ops_start(struct ieee80211_hw
*hw
)
179 struct brcms_info
*wl
= hw
->priv
;
182 struct ieee80211_channel *curchan = hw->conf.channel;
185 ieee80211_wake_queues(hw
);
187 blocked
= brcms_rfkill_set_hw_state(wl
);
190 wiphy_rfkill_stop_polling(wl
->pub
->ieee_hw
->wiphy
);
195 static void brcms_ops_stop(struct ieee80211_hw
*hw
)
197 ieee80211_stop_queues(hw
);
201 brcms_ops_add_interface(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
203 struct brcms_info
*wl
;
206 /* Just STA for now */
207 if (vif
->type
!= NL80211_IFTYPE_AP
&&
208 vif
->type
!= NL80211_IFTYPE_MESH_POINT
&&
209 vif
->type
!= NL80211_IFTYPE_STATION
&&
210 vif
->type
!= NL80211_IFTYPE_WDS
&&
211 vif
->type
!= NL80211_IFTYPE_ADHOC
) {
212 wiphy_err(hw
->wiphy
, "%s: Attempt to add type %d, only"
213 " STA for now\n", __func__
, vif
->type
);
223 wiphy_err(hw
->wiphy
, "%s: brcms_up() returned %d\n", __func__
,
230 brcms_ops_remove_interface(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
232 struct brcms_info
*wl
;
236 /* put driver in down state */
243 * precondition: perimeter lock has been acquired
246 ieee_set_channel(struct ieee80211_hw
*hw
, struct ieee80211_channel
*chan
,
247 enum nl80211_channel_type type
)
249 struct brcms_info
*wl
= HW_TO_WL(hw
);
253 case NL80211_CHAN_HT20
:
254 case NL80211_CHAN_NO_HT
:
255 err
= brcms_c_set(wl
->wlc
, BRCM_SET_CHANNEL
, chan
->hw_value
);
257 case NL80211_CHAN_HT40MINUS
:
258 case NL80211_CHAN_HT40PLUS
:
260 "%s: Need to implement 40 Mhz Channels!\n", __func__
);
270 static int brcms_ops_config(struct ieee80211_hw
*hw
, u32 changed
)
272 struct ieee80211_conf
*conf
= &hw
->conf
;
273 struct brcms_info
*wl
= HW_TO_WL(hw
);
276 struct wiphy
*wiphy
= hw
->wiphy
;
279 if (changed
& IEEE80211_CONF_CHANGE_LISTEN_INTERVAL
) {
280 if (brcms_c_set_par(wl
->wlc
, IOV_BCN_LI_BCN
,
281 conf
->listen_interval
) < 0) {
282 wiphy_err(wiphy
, "%s: Error setting listen_interval\n",
287 brcms_c_get_par(wl
->wlc
, IOV_BCN_LI_BCN
, &new_int
);
289 if (changed
& IEEE80211_CONF_CHANGE_MONITOR
)
290 wiphy_err(wiphy
, "%s: change monitor mode: %s (implement)\n",
291 __func__
, conf
->flags
& IEEE80211_CONF_MONITOR
?
293 if (changed
& IEEE80211_CONF_CHANGE_PS
)
294 wiphy_err(wiphy
, "%s: change power-save mode: %s (implement)\n",
295 __func__
, conf
->flags
& IEEE80211_CONF_PS
?
298 if (changed
& IEEE80211_CONF_CHANGE_POWER
) {
299 if (brcms_c_set_par(wl
->wlc
, IOV_QTXPOWER
,
300 conf
->power_level
* 4) < 0) {
301 wiphy_err(wiphy
, "%s: Error setting power_level\n",
306 brcms_c_get_par(wl
->wlc
, IOV_QTXPOWER
, &new_int
);
307 if (new_int
!= (conf
->power_level
* 4))
308 wiphy_err(wiphy
, "%s: Power level req != actual, %d %d"
309 "\n", __func__
, conf
->power_level
* 4,
312 if (changed
& IEEE80211_CONF_CHANGE_CHANNEL
) {
313 err
= ieee_set_channel(hw
, conf
->channel
, conf
->channel_type
);
315 if (changed
& IEEE80211_CONF_CHANGE_RETRY_LIMITS
) {
317 (wl
->wlc
, BRCM_SET_SRL
,
318 conf
->short_frame_max_tx_count
) < 0) {
319 wiphy_err(wiphy
, "%s: Error setting srl\n", __func__
);
323 if (brcms_c_set(wl
->wlc
, BRCM_SET_LRL
,
324 conf
->long_frame_max_tx_count
) < 0) {
325 wiphy_err(wiphy
, "%s: Error setting lrl\n", __func__
);
337 brcms_ops_bss_info_changed(struct ieee80211_hw
*hw
,
338 struct ieee80211_vif
*vif
,
339 struct ieee80211_bss_conf
*info
, u32 changed
)
341 struct brcms_info
*wl
= HW_TO_WL(hw
);
342 struct wiphy
*wiphy
= hw
->wiphy
;
345 if (changed
& BSS_CHANGED_ASSOC
) {
346 /* association status changed (associated/disassociated)
347 * also implies a change in the AID.
349 wiphy_err(wiphy
, "%s: %s: %sassociated\n", KBUILD_MODNAME
,
350 __func__
, info
->assoc
? "" : "dis");
352 brcms_c_associate_upd(wl
->wlc
, info
->assoc
);
355 if (changed
& BSS_CHANGED_ERP_SLOT
) {
356 /* slot timing changed */
357 if (info
->use_short_slot
)
362 brcms_c_set(wl
->wlc
, BRCMS_SET_SHORTSLOT_OVERRIDE
, val
);
366 if (changed
& BSS_CHANGED_HT
) {
367 /* 802.11n parameters changed */
368 u16 mode
= info
->ht_operation_mode
;
371 brcms_c_protection_upd(wl
->wlc
, BRCMS_PROT_N_CFG
,
372 mode
& IEEE80211_HT_OP_MODE_PROTECTION
);
373 brcms_c_protection_upd(wl
->wlc
, BRCMS_PROT_N_NONGF
,
374 mode
& IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT
);
375 brcms_c_protection_upd(wl
->wlc
, BRCMS_PROT_N_OBSS
,
376 mode
& IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT
);
379 if (changed
& BSS_CHANGED_BASIC_RATES
) {
380 struct ieee80211_supported_band
*bi
;
383 struct wl_rateset rs
;
386 /* retrieve the current rates */
388 error
= brcms_c_ioctl(wl
->wlc
, BRCM_GET_CURR_RATESET
,
389 &rs
, sizeof(rs
), NULL
);
392 wiphy_err(wiphy
, "%s: retrieve rateset failed: %d\n",
396 br_mask
= info
->basic_rates
;
397 bi
= hw
->wiphy
->bands
[brcms_c_get_curband(wl
->wlc
)];
398 for (i
= 0; i
< bi
->n_bitrates
; i
++) {
399 /* convert to internal rate value */
400 rate
= (bi
->bitrates
[i
].bitrate
<< 1) / 10;
402 /* set/clear basic rate flag */
403 brcms_set_basic_rate(&rs
, rate
, br_mask
& 1);
407 /* update the rate set */
409 brcms_c_ioctl(wl
->wlc
, BRCM_SET_RATESET
, &rs
, sizeof(rs
), NULL
);
412 if (changed
& BSS_CHANGED_BEACON_INT
) {
413 /* Beacon interval changed */
415 brcms_c_set(wl
->wlc
, BRCM_SET_BCNPRD
, info
->beacon_int
);
418 if (changed
& BSS_CHANGED_BSSID
) {
419 /* BSSID changed, for whatever reason (IBSS and managed mode) */
421 brcms_c_set_addrmatch(wl
->wlc
, RCM_BSSID_OFFSET
,
425 if (changed
& BSS_CHANGED_BEACON
) {
426 /* Beacon data changed, retrieve new beacon (beaconing modes) */
427 wiphy_err(wiphy
, "%s: beacon changed\n", __func__
);
429 if (changed
& BSS_CHANGED_BEACON_ENABLED
) {
430 /* Beaconing should be enabled/disabled (beaconing modes) */
431 wiphy_err(wiphy
, "%s: Beacon enabled: %s\n", __func__
,
432 info
->enable_beacon
? "true" : "false");
434 if (changed
& BSS_CHANGED_CQM
) {
435 /* Connection quality monitor config changed */
436 wiphy_err(wiphy
, "%s: cqm change: threshold %d, hys %d "
437 " (implement)\n", __func__
, info
->cqm_rssi_thold
,
438 info
->cqm_rssi_hyst
);
440 if (changed
& BSS_CHANGED_IBSS
) {
441 /* IBSS join status changed */
442 wiphy_err(wiphy
, "%s: IBSS joined: %s (implement)\n", __func__
,
443 info
->ibss_joined
? "true" : "false");
445 if (changed
& BSS_CHANGED_ARP_FILTER
) {
446 /* Hardware ARP filter address list or state changed */
447 wiphy_err(wiphy
, "%s: arp filtering: enabled %s, count %d"
448 " (implement)\n", __func__
, info
->arp_filter_enabled
?
449 "true" : "false", info
->arp_addr_cnt
);
451 if (changed
& BSS_CHANGED_QOS
) {
453 * QoS for this association was enabled/disabled.
454 * Note that it is only ever disabled for station mode.
456 wiphy_err(wiphy
, "%s: qos enabled: %s (implement)\n", __func__
,
457 info
->qos
? "true" : "false");
463 brcms_ops_configure_filter(struct ieee80211_hw
*hw
,
464 unsigned int changed_flags
,
465 unsigned int *total_flags
, u64 multicast
)
467 struct brcms_info
*wl
= hw
->priv
;
468 struct wiphy
*wiphy
= hw
->wiphy
;
470 changed_flags
&= MAC_FILTERS
;
471 *total_flags
&= MAC_FILTERS
;
472 if (changed_flags
& FIF_PROMISC_IN_BSS
)
473 wiphy_err(wiphy
, "FIF_PROMISC_IN_BSS\n");
474 if (changed_flags
& FIF_ALLMULTI
)
475 wiphy_err(wiphy
, "FIF_ALLMULTI\n");
476 if (changed_flags
& FIF_FCSFAIL
)
477 wiphy_err(wiphy
, "FIF_FCSFAIL\n");
478 if (changed_flags
& FIF_PLCPFAIL
)
479 wiphy_err(wiphy
, "FIF_PLCPFAIL\n");
480 if (changed_flags
& FIF_CONTROL
)
481 wiphy_err(wiphy
, "FIF_CONTROL\n");
482 if (changed_flags
& FIF_OTHER_BSS
)
483 wiphy_err(wiphy
, "FIF_OTHER_BSS\n");
484 if (changed_flags
& FIF_BCN_PRBRESP_PROMISC
) {
486 if (*total_flags
& FIF_BCN_PRBRESP_PROMISC
) {
487 wl
->pub
->mac80211_state
|= MAC80211_PROMISC_BCNS
;
488 brcms_c_mac_bcn_promisc_change(wl
->wlc
, 1);
490 brcms_c_mac_bcn_promisc_change(wl
->wlc
, 0);
491 wl
->pub
->mac80211_state
&= ~MAC80211_PROMISC_BCNS
;
499 brcms_ops_set_tim(struct ieee80211_hw
*hw
, struct ieee80211_sta
*sta
, bool set
)
504 static void brcms_ops_sw_scan_start(struct ieee80211_hw
*hw
)
506 struct brcms_info
*wl
= hw
->priv
;
508 brcms_c_scan_start(wl
->wlc
);
513 static void brcms_ops_sw_scan_complete(struct ieee80211_hw
*hw
)
515 struct brcms_info
*wl
= hw
->priv
;
517 brcms_c_scan_stop(wl
->wlc
);
522 static void brcms_ops_set_tsf(struct ieee80211_hw
*hw
,
523 struct ieee80211_vif
*vif
, u64 tsf
)
525 wiphy_err(hw
->wiphy
, "%s: Enter\n", __func__
);
530 brcms_ops_get_stats(struct ieee80211_hw
*hw
,
531 struct ieee80211_low_level_stats
*stats
)
533 struct brcms_info
*wl
= hw
->priv
;
538 stats
->dot11ACKFailureCount
= 0;
539 stats
->dot11RTSFailureCount
= 0;
540 stats
->dot11FCSErrorCount
= 0;
541 stats
->dot11RTSSuccessCount
= 0;
547 brcms_ops_sta_notify(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
548 enum sta_notify_cmd cmd
, struct ieee80211_sta
*sta
)
552 wiphy_err(hw
->wiphy
, "%s: Unknown cmd = %d\n", __func__
,
560 brcms_ops_conf_tx(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
, u16 queue
,
561 const struct ieee80211_tx_queue_params
*params
)
563 struct brcms_info
*wl
= hw
->priv
;
566 brcms_c_wme_setparams(wl
->wlc
, queue
, params
, true);
572 static u64
brcms_ops_get_tsf(struct ieee80211_hw
*hw
,
573 struct ieee80211_vif
*vif
)
575 wiphy_err(hw
->wiphy
, "%s: Enter\n", __func__
);
580 brcms_ops_sta_add(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
581 struct ieee80211_sta
*sta
)
586 struct brcms_info
*wl
= hw
->priv
;
589 scb
= (struct scb
*)sta
->drv_priv
;
590 memset(scb
, 0, sizeof(struct scb
));
591 for (i
= 0; i
< NUMPRIO
; i
++)
592 scb
->seqctl
[i
] = 0xFFFF;
593 scb
->seqctl_nonqos
= 0xFFFF;
594 scb
->magic
= SCB_MAGIC
;
596 wl
->pub
->global_scb
= scb
;
597 wl
->pub
->global_ampdu
= &(scb
->scb_ampdu
);
598 wl
->pub
->global_ampdu
->scb
= scb
;
599 wl
->pub
->global_ampdu
->max_pdu
= 16;
600 brcmu_pktq_init(&scb
->scb_ampdu
.txq
, AMPDU_MAX_SCB_TID
,
601 AMPDU_MAX_SCB_TID
* PKTQ_LEN_DEFAULT
);
603 sta
->ht_cap
.ht_supported
= true;
604 sta
->ht_cap
.ampdu_factor
= IEEE80211_HT_MAX_AMPDU_64K
;
605 sta
->ht_cap
.ampdu_density
= AMPDU_DEF_MPDU_DENSITY
;
606 sta
->ht_cap
.cap
= IEEE80211_HT_CAP_GRN_FLD
|
607 IEEE80211_HT_CAP_SGI_20
|
608 IEEE80211_HT_CAP_SGI_40
| IEEE80211_HT_CAP_40MHZ_INTOLERANT
;
610 /* minstrel_ht initiates addBA on our behalf by calling ieee80211_start_tx_ba_session() */
615 brcms_ops_sta_remove(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
616 struct ieee80211_sta
*sta
)
622 brcms_ops_ampdu_action(struct ieee80211_hw
*hw
,
623 struct ieee80211_vif
*vif
,
624 enum ieee80211_ampdu_mlme_action action
,
625 struct ieee80211_sta
*sta
, u16 tid
, u16
*ssn
,
628 struct scb
*scb
= (struct scb
*)sta
->drv_priv
;
629 struct brcms_info
*wl
= hw
->priv
;
632 if (WARN_ON(scb
->magic
!= SCB_MAGIC
))
635 case IEEE80211_AMPDU_RX_START
:
637 case IEEE80211_AMPDU_RX_STOP
:
639 case IEEE80211_AMPDU_TX_START
:
641 status
= brcms_c_aggregatable(wl
->wlc
, tid
);
644 wiphy_err(wl
->wiphy
, "START: tid %d is not agg\'able\n",
648 /* Future improvement: Use the starting sequence number provided ... */
650 ieee80211_start_tx_ba_cb_irqsafe(vif
, sta
->addr
, tid
);
653 case IEEE80211_AMPDU_TX_STOP
:
655 brcms_c_ampdu_flush(wl
->wlc
, sta
, tid
);
657 ieee80211_stop_tx_ba_cb_irqsafe(vif
, sta
->addr
, tid
);
659 case IEEE80211_AMPDU_TX_OPERATIONAL
:
661 * BA window size from ADDBA response ('buf_size') defines how
662 * many outstanding MPDUs are allowed for the BA stream by
663 * recipient and traffic class. 'ampdu_factor' gives maximum
667 brcms_c_ampdu_tx_operational(wl
->wlc
, tid
, buf_size
,
668 (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR
+
669 sta
->ht_cap
.ampdu_factor
)) - 1);
671 /* Power save wakeup */
674 wiphy_err(wl
->wiphy
, "%s: Invalid command, ignoring\n",
681 static void brcms_ops_rfkill_poll(struct ieee80211_hw
*hw
)
683 struct brcms_info
*wl
= HW_TO_WL(hw
);
687 blocked
= brcms_c_check_radio_disabled(wl
->wlc
);
690 wiphy_rfkill_set_hw_state(wl
->pub
->ieee_hw
->wiphy
, blocked
);
693 static void brcms_ops_flush(struct ieee80211_hw
*hw
, bool drop
)
695 struct brcms_info
*wl
= HW_TO_WL(hw
);
697 no_printk("%s: drop = %s\n", __func__
, drop
? "true" : "false");
699 /* wait for packet queue and dma fifos to run empty */
701 brcms_c_wait_for_tx_completion(wl
->wlc
, drop
);
705 static const struct ieee80211_ops brcms_ops
= {
707 .start
= brcms_ops_start
,
708 .stop
= brcms_ops_stop
,
709 .add_interface
= brcms_ops_add_interface
,
710 .remove_interface
= brcms_ops_remove_interface
,
711 .config
= brcms_ops_config
,
712 .bss_info_changed
= brcms_ops_bss_info_changed
,
713 .configure_filter
= brcms_ops_configure_filter
,
714 .set_tim
= brcms_ops_set_tim
,
715 .sw_scan_start
= brcms_ops_sw_scan_start
,
716 .sw_scan_complete
= brcms_ops_sw_scan_complete
,
717 .set_tsf
= brcms_ops_set_tsf
,
718 .get_stats
= brcms_ops_get_stats
,
719 .sta_notify
= brcms_ops_sta_notify
,
720 .conf_tx
= brcms_ops_conf_tx
,
721 .get_tsf
= brcms_ops_get_tsf
,
722 .sta_add
= brcms_ops_sta_add
,
723 .sta_remove
= brcms_ops_sta_remove
,
724 .ampdu_action
= brcms_ops_ampdu_action
,
725 .rfkill_poll
= brcms_ops_rfkill_poll
,
726 .flush
= brcms_ops_flush
,
730 * is called in brcms_pci_probe() context, therefore no locking required.
732 static int brcms_set_hint(struct brcms_info
*wl
, char *abbrev
)
734 return regulatory_hint(wl
->pub
->ieee_hw
->wiphy
, abbrev
);
738 * attach to the WL device.
740 * Attach to the WL device identified by vendor and device parameters.
741 * regs is a host accessible memory address pointing to WL device registers.
743 * brcms_attach is not defined as static because in the case where no bus
744 * is defined, wl_attach will never be called, and thus, gcc will issue
745 * a warning that this function is defined but not used if we declare
749 * is called in brcms_pci_probe() context, therefore no locking required.
751 static struct brcms_info
*brcms_attach(u16 vendor
, u16 device
,
753 uint bustype
, void *btparam
, uint irq
)
755 struct brcms_info
*wl
= NULL
;
757 unsigned long base_addr
;
758 struct ieee80211_hw
*hw
;
761 unit
= n_adapters_found
;
768 /* allocate private info */
769 hw
= pci_get_drvdata(btparam
); /* btparam == pdev */
772 if (WARN_ON(hw
== NULL
) || WARN_ON(wl
== NULL
))
774 wl
->wiphy
= hw
->wiphy
;
776 atomic_set(&wl
->callbacks
, 0);
778 /* setup the bottom half handler */
779 tasklet_init(&wl
->tasklet
, brcms_dpc
, (unsigned long) wl
);
785 if (bustype
== PCI_BUS
|| bustype
== RPC_BUS
) {
789 BCMMSG(wl
->wiphy
, "force to PCI\n");
791 wl
->bcm_bustype
= bustype
;
793 wl
->regsva
= ioremap_nocache(base_addr
, PCI_BAR0_WINSZ
);
794 if (wl
->regsva
== NULL
) {
795 wiphy_err(wl
->wiphy
, "wl%d: ioremap() failed\n", unit
);
798 spin_lock_init(&wl
->lock
);
799 spin_lock_init(&wl
->isr_lock
);
802 if (brcms_request_fw(wl
, (struct pci_dev
*)btparam
) < 0) {
803 wiphy_err(wl
->wiphy
, "%s: Failed to find firmware usually in "
804 "%s\n", KBUILD_MODNAME
, "/lib/firmware/brcm");
805 brcms_release_fw(wl
);
806 brcms_remove((struct pci_dev
*)btparam
);
810 /* common load-time initialization */
811 wl
->wlc
= brcms_c_attach((void *)wl
, vendor
, device
, unit
, false,
812 wl
->regsva
, wl
->bcm_bustype
, btparam
, &err
);
813 brcms_release_fw(wl
);
815 wiphy_err(wl
->wiphy
, "%s: attach() failed with code %d\n",
816 KBUILD_MODNAME
, err
);
819 wl
->pub
= brcms_c_pub(wl
->wlc
);
821 wl
->pub
->ieee_hw
= hw
;
823 if (brcms_c_set_par(wl
->wlc
, IOV_MPC
, 0) < 0) {
824 wiphy_err(wl
->wiphy
, "wl%d: Error setting MPC variable to 0\n",
828 /* register our interrupt handler */
829 if (request_irq(irq
, brcms_isr
, IRQF_SHARED
, KBUILD_MODNAME
, wl
)) {
830 wiphy_err(wl
->wiphy
, "wl%d: request_irq() failed\n", unit
);
835 /* register module */
836 brcms_c_module_register(wl
->pub
, "linux", wl
, wl_linux_watchdog
, NULL
);
838 if (ieee_hw_init(hw
)) {
839 wiphy_err(wl
->wiphy
, "wl%d: %s: ieee_hw_init failed!\n", unit
,
844 memcpy(perm
, &wl
->pub
->cur_etheraddr
, ETH_ALEN
);
845 if (WARN_ON(!is_valid_ether_addr(perm
)))
847 SET_IEEE80211_PERM_ADDR(hw
, perm
);
849 err
= ieee80211_register_hw(hw
);
851 wiphy_err(wl
->wiphy
, "%s: ieee80211_register_hw failed, status"
852 "%d\n", __func__
, err
);
855 if (wl
->pub
->srom_ccode
[0])
856 err
= brcms_set_hint(wl
, wl
->pub
->srom_ccode
);
858 err
= brcms_set_hint(wl
, "US");
860 wiphy_err(wl
->wiphy
, "%s: regulatory_hint failed, status %d\n",
874 #define CHAN2GHZ(channel, freqency, chflags) { \
875 .band = IEEE80211_BAND_2GHZ, \
876 .center_freq = (freqency), \
877 .hw_value = (channel), \
879 .max_antenna_gain = 0, \
883 static struct ieee80211_channel brcms_2ghz_chantable
[] = {
884 CHAN2GHZ(1, 2412, IEEE80211_CHAN_NO_HT40MINUS
),
885 CHAN2GHZ(2, 2417, IEEE80211_CHAN_NO_HT40MINUS
),
886 CHAN2GHZ(3, 2422, IEEE80211_CHAN_NO_HT40MINUS
),
887 CHAN2GHZ(4, 2427, IEEE80211_CHAN_NO_HT40MINUS
),
888 CHAN2GHZ(5, 2432, 0),
889 CHAN2GHZ(6, 2437, 0),
890 CHAN2GHZ(7, 2442, 0),
891 CHAN2GHZ(8, 2447, IEEE80211_CHAN_NO_HT40PLUS
),
892 CHAN2GHZ(9, 2452, IEEE80211_CHAN_NO_HT40PLUS
),
893 CHAN2GHZ(10, 2457, IEEE80211_CHAN_NO_HT40PLUS
),
894 CHAN2GHZ(11, 2462, IEEE80211_CHAN_NO_HT40PLUS
),
896 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_IBSS
|
897 IEEE80211_CHAN_NO_HT40PLUS
),
899 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_IBSS
|
900 IEEE80211_CHAN_NO_HT40PLUS
),
902 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_IBSS
|
903 IEEE80211_CHAN_NO_HT40PLUS
| IEEE80211_CHAN_NO_HT40MINUS
)
906 #define CHAN5GHZ(channel, chflags) { \
907 .band = IEEE80211_BAND_5GHZ, \
908 .center_freq = 5000 + 5*(channel), \
909 .hw_value = (channel), \
911 .max_antenna_gain = 0, \
915 static struct ieee80211_channel brcms_5ghz_nphy_chantable
[] = {
917 CHAN5GHZ(36, IEEE80211_CHAN_NO_HT40MINUS
),
918 CHAN5GHZ(40, IEEE80211_CHAN_NO_HT40PLUS
),
919 CHAN5GHZ(44, IEEE80211_CHAN_NO_HT40MINUS
),
920 CHAN5GHZ(48, IEEE80211_CHAN_NO_HT40PLUS
),
923 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
924 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40MINUS
),
926 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
927 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40PLUS
),
929 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
930 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40MINUS
),
932 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
933 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40PLUS
),
936 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
937 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40MINUS
),
939 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
940 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40PLUS
),
942 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
943 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40MINUS
),
945 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
946 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40PLUS
),
948 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
949 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40MINUS
),
951 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
952 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40PLUS
),
954 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
955 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40MINUS
),
957 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
958 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40PLUS
),
960 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
961 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40MINUS
),
963 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
964 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40PLUS
),
966 IEEE80211_CHAN_RADAR
| IEEE80211_CHAN_NO_IBSS
|
967 IEEE80211_CHAN_PASSIVE_SCAN
| IEEE80211_CHAN_NO_HT40PLUS
|
968 IEEE80211_CHAN_NO_HT40MINUS
),
970 CHAN5GHZ(149, IEEE80211_CHAN_NO_HT40MINUS
),
971 CHAN5GHZ(153, IEEE80211_CHAN_NO_HT40PLUS
),
972 CHAN5GHZ(157, IEEE80211_CHAN_NO_HT40MINUS
),
973 CHAN5GHZ(161, IEEE80211_CHAN_NO_HT40PLUS
),
974 CHAN5GHZ(165, IEEE80211_CHAN_NO_HT40PLUS
| IEEE80211_CHAN_NO_HT40MINUS
)
977 #define RATE(rate100m, _flags) { \
978 .bitrate = (rate100m), \
980 .hw_value = (rate100m / 5), \
983 static struct ieee80211_rate legacy_ratetable
[] = {
985 RATE(20, IEEE80211_RATE_SHORT_PREAMBLE
),
986 RATE(55, IEEE80211_RATE_SHORT_PREAMBLE
),
987 RATE(110, IEEE80211_RATE_SHORT_PREAMBLE
),
998 static struct ieee80211_supported_band brcms_band_2GHz_nphy
= {
999 .band
= IEEE80211_BAND_2GHZ
,
1000 .channels
= brcms_2ghz_chantable
,
1001 .n_channels
= ARRAY_SIZE(brcms_2ghz_chantable
),
1002 .bitrates
= legacy_ratetable
,
1003 .n_bitrates
= ARRAY_SIZE(legacy_ratetable
),
1005 /* from include/linux/ieee80211.h */
1006 .cap
= IEEE80211_HT_CAP_GRN_FLD
|
1007 IEEE80211_HT_CAP_SGI_20
|
1008 IEEE80211_HT_CAP_SGI_40
| IEEE80211_HT_CAP_40MHZ_INTOLERANT
,
1009 .ht_supported
= true,
1010 .ampdu_factor
= IEEE80211_HT_MAX_AMPDU_64K
,
1011 .ampdu_density
= AMPDU_DEF_MPDU_DENSITY
,
1013 /* placeholders for now */
1014 .rx_mask
= {0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0},
1016 .tx_params
= IEEE80211_HT_MCS_TX_DEFINED
}
1020 static struct ieee80211_supported_band brcms_band_5GHz_nphy
= {
1021 .band
= IEEE80211_BAND_5GHZ
,
1022 .channels
= brcms_5ghz_nphy_chantable
,
1023 .n_channels
= ARRAY_SIZE(brcms_5ghz_nphy_chantable
),
1024 .bitrates
= legacy_ratetable
+ 4,
1025 .n_bitrates
= ARRAY_SIZE(legacy_ratetable
) - 4,
1027 /* use IEEE80211_HT_CAP_* from include/linux/ieee80211.h */
1028 .cap
= IEEE80211_HT_CAP_GRN_FLD
| IEEE80211_HT_CAP_SGI_20
| IEEE80211_HT_CAP_SGI_40
| IEEE80211_HT_CAP_40MHZ_INTOLERANT
, /* No 40 mhz yet */
1029 .ht_supported
= true,
1030 .ampdu_factor
= IEEE80211_HT_MAX_AMPDU_64K
,
1031 .ampdu_density
= AMPDU_DEF_MPDU_DENSITY
,
1033 /* placeholders for now */
1034 .rx_mask
= {0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0},
1036 .tx_params
= IEEE80211_HT_MCS_TX_DEFINED
}
1041 * is called in brcms_pci_probe() context, therefore no locking required.
1043 static int ieee_hw_rate_init(struct ieee80211_hw
*hw
)
1045 struct brcms_info
*wl
= HW_TO_WL(hw
);
1051 hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] = NULL
;
1052 hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] = NULL
;
1054 if (brcms_c_get(wl
->wlc
, BRCM_GET_PHYLIST
, (int *)&phy_list
) < 0)
1055 wiphy_err(hw
->wiphy
, "Phy list failed\n");
1057 if (phy_list
[0] == 'n' || phy_list
[0] == 'c') {
1058 if (phy_list
[0] == 'c') {
1060 brcms_band_2GHz_nphy
.ht_cap
.mcs
.rx_mask
[1] = 0;
1061 brcms_band_2GHz_nphy
.ht_cap
.mcs
.rx_highest
= 72;
1063 hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] = &brcms_band_2GHz_nphy
;
1068 /* Assume all bands use the same phy. True for 11n devices. */
1069 if (NBANDS_PUB(wl
->pub
) > 1) {
1071 if (phy_list
[0] == 'n' || phy_list
[0] == 'c') {
1072 hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] =
1073 &brcms_band_5GHz_nphy
;
1082 * is called in brcms_pci_probe() context, therefore no locking required.
1084 static int ieee_hw_init(struct ieee80211_hw
*hw
)
1086 hw
->flags
= IEEE80211_HW_SIGNAL_DBM
1087 /* | IEEE80211_HW_CONNECTION_MONITOR What is this? */
1088 | IEEE80211_HW_REPORTS_TX_ACK_STATUS
1089 | IEEE80211_HW_AMPDU_AGGREGATION
;
1091 hw
->extra_tx_headroom
= brcms_c_get_header_len();
1092 hw
->queues
= N_TX_QUEUES
;
1093 hw
->max_rates
= 2; /* Primary rate and 1 fallback rate */
1095 hw
->channel_change_time
= 7 * 1000; /* channel change time is dependent on chip and band */
1096 hw
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
);
1098 hw
->rate_control_algorithm
= "minstrel_ht";
1100 hw
->sta_data_size
= sizeof(struct scb
);
1101 return ieee_hw_rate_init(hw
);
1105 * determines if a device is a WL device, and if so, attaches it.
1107 * This function determines if a device pointed to by pdev is a WL device,
1108 * and if so, performs a brcms_attach() on it.
1110 * Perimeter lock is initialized in the course of this function.
1112 static int __devinit
1113 brcms_pci_probe(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
1116 struct brcms_info
*wl
;
1117 struct ieee80211_hw
*hw
;
1120 dev_info(&pdev
->dev
, "bus %d slot %d func %d irq %d\n",
1121 pdev
->bus
->number
, PCI_SLOT(pdev
->devfn
),
1122 PCI_FUNC(pdev
->devfn
), pdev
->irq
);
1124 if ((pdev
->vendor
!= PCI_VENDOR_ID_BROADCOM
) ||
1125 ((pdev
->device
!= 0x0576) &&
1126 ((pdev
->device
& 0xff00) != 0x4300) &&
1127 ((pdev
->device
& 0xff00) != 0x4700) &&
1128 ((pdev
->device
< 43000) || (pdev
->device
> 43999))))
1131 rc
= pci_enable_device(pdev
);
1133 pr_err("%s: Cannot enable device %d-%d_%d\n",
1134 __func__
, pdev
->bus
->number
, PCI_SLOT(pdev
->devfn
),
1135 PCI_FUNC(pdev
->devfn
));
1138 pci_set_master(pdev
);
1140 pci_read_config_dword(pdev
, 0x40, &val
);
1141 if ((val
& 0x0000ff00) != 0)
1142 pci_write_config_dword(pdev
, 0x40, val
& 0xffff00ff);
1144 hw
= ieee80211_alloc_hw(sizeof(struct brcms_info
), &brcms_ops
);
1146 pr_err("%s: ieee80211_alloc_hw failed\n", __func__
);
1150 SET_IEEE80211_DEV(hw
, &pdev
->dev
);
1152 pci_set_drvdata(pdev
, hw
);
1154 memset(hw
->priv
, 0, sizeof(*wl
));
1156 wl
= brcms_attach(pdev
->vendor
, pdev
->device
,
1157 pci_resource_start(pdev
, 0), PCI_BUS
, pdev
,
1161 pr_err("%s: %s: brcms_attach failed!\n", KBUILD_MODNAME
,
1168 static int brcms_suspend(struct pci_dev
*pdev
, pm_message_t state
)
1170 struct brcms_info
*wl
;
1171 struct ieee80211_hw
*hw
;
1173 hw
= pci_get_drvdata(pdev
);
1176 wiphy_err(wl
->wiphy
,
1177 "brcms_suspend: pci_get_drvdata failed\n");
1181 /* only need to flag hw is down for proper resume */
1183 wl
->pub
->hw_up
= false;
1186 pci_save_state(pdev
);
1187 pci_disable_device(pdev
);
1188 return pci_set_power_state(pdev
, PCI_D3hot
);
1191 static int brcms_resume(struct pci_dev
*pdev
)
1193 struct brcms_info
*wl
;
1194 struct ieee80211_hw
*hw
;
1198 hw
= pci_get_drvdata(pdev
);
1201 wiphy_err(wl
->wiphy
,
1202 "wl: brcms_resume: pci_get_drvdata failed\n");
1206 err
= pci_set_power_state(pdev
, PCI_D0
);
1210 pci_restore_state(pdev
);
1212 err
= pci_enable_device(pdev
);
1216 pci_set_master(pdev
);
1218 pci_read_config_dword(pdev
, 0x40, &val
);
1219 if ((val
& 0x0000ff00) != 0)
1220 pci_write_config_dword(pdev
, 0x40, val
& 0xffff00ff);
1223 * done. driver will be put in up state
1224 * in brcms_ops_add_interface() call.
1230 * called from both kernel as from this kernel module.
1231 * precondition: perimeter lock is not acquired.
1233 static void brcms_remove(struct pci_dev
*pdev
)
1235 struct brcms_info
*wl
;
1236 struct ieee80211_hw
*hw
;
1239 hw
= pci_get_drvdata(pdev
);
1242 pr_err("wl: brcms_remove: pci_get_drvdata failed\n");
1247 status
= brcms_c_chipmatch(pdev
->vendor
, pdev
->device
);
1250 wiphy_err(wl
->wiphy
, "wl: brcms_remove: chipmatch "
1255 wiphy_rfkill_set_hw_state(wl
->pub
->ieee_hw
->wiphy
, false);
1256 wiphy_rfkill_stop_polling(wl
->pub
->ieee_hw
->wiphy
);
1257 ieee80211_unregister_hw(hw
);
1262 pci_disable_device(pdev
);
1266 pci_set_drvdata(pdev
, NULL
);
1267 ieee80211_free_hw(hw
);
1270 static struct pci_driver brcms_pci_driver
= {
1271 .name
= KBUILD_MODNAME
,
1272 .probe
= brcms_pci_probe
,
1273 .suspend
= brcms_suspend
,
1274 .resume
= brcms_resume
,
1275 .remove
= __devexit_p(brcms_remove
),
1276 .id_table
= brcms_pci_id_table
,
1280 * This is the main entry point for the WL driver.
1282 * This function determines if a device pointed to by pdev is a WL device,
1283 * and if so, performs a brcms_attach() on it.
1286 static int __init
brcms_module_init(void)
1288 int error
= -ENODEV
;
1291 if (msglevel
!= 0xdeadbeef)
1292 brcm_msg_level
= msglevel
;
1293 if (phymsglevel
!= 0xdeadbeef)
1294 phyhal_msg_level
= phymsglevel
;
1297 error
= pci_register_driver(&brcms_pci_driver
);
1307 * This function unloads the WL driver from the system.
1309 * This function unconditionally unloads the WL driver module from the
1313 static void __exit
brcms_module_exit(void)
1315 pci_unregister_driver(&brcms_pci_driver
);
1319 module_init(brcms_module_init
);
1320 module_exit(brcms_module_exit
);
1323 * This function frees the WL per-device resources.
1325 * This function frees resources owned by the WL device pointed to
1326 * by the wl parameter.
1328 * precondition: can both be called locked and unlocked
1331 static void brcms_free(struct brcms_info
*wl
)
1333 struct brcms_timer
*t
, *next
;
1335 /* free ucode data */
1337 brcms_ucode_data_free();
1339 free_irq(wl
->irq
, wl
);
1342 tasklet_kill(&wl
->tasklet
);
1345 brcms_c_module_unregister(wl
->pub
, "linux", wl
);
1348 /* free common resources */
1350 brcms_c_detach(wl
->wlc
);
1355 /* virtual interface deletion is deferred so we cannot spinwait */
1357 /* wait for all pending callbacks to complete */
1358 while (atomic_read(&wl
->callbacks
) > 0)
1362 for (t
= wl
->timers
; t
; t
= next
) {
1371 * unregister_netdev() calls get_stats() which may read chip registers
1372 * so we cannot unmap the chip registers until after calling unregister_netdev() .
1374 if (wl
->regsva
&& wl
->bcm_bustype
!= SDIO_BUS
&&
1375 wl
->bcm_bustype
!= JTAG_BUS
) {
1376 iounmap((void *)wl
->regsva
);
1381 /* flags the given rate in rateset as requested */
1382 static void brcms_set_basic_rate(struct wl_rateset
*rs
, u16 rate
, bool is_br
)
1386 for (i
= 0; i
< rs
->count
; i
++) {
1387 if (rate
!= (rs
->rates
[i
] & 0x7f))
1391 rs
->rates
[i
] |= BRCMS_RATE_FLAG
;
1393 rs
->rates
[i
] &= BRCMS_RATE_MASK
;
1399 * precondition: perimeter lock has been acquired
1401 void brcms_txflowcontrol(struct brcms_info
*wl
, struct brcms_if
*wlif
,
1402 bool state
, int prio
)
1404 wiphy_err(wl
->wiphy
, "Shouldn't be here %s\n", __func__
);
1408 * precondition: perimeter lock has been acquired
1410 void brcms_init(struct brcms_info
*wl
)
1412 BCMMSG(WL_TO_HW(wl
)->wiphy
, "wl%d\n", wl
->pub
->unit
);
1415 brcms_c_init(wl
->wlc
);
1419 * precondition: perimeter lock has been acquired
1421 uint
brcms_reset(struct brcms_info
*wl
)
1423 BCMMSG(WL_TO_HW(wl
)->wiphy
, "wl%d\n", wl
->pub
->unit
);
1424 brcms_c_reset(wl
->wlc
);
1426 /* dpc will not be rescheduled */
1433 * These are interrupt on/off entry points. Disable interrupts
1434 * during interrupt state transition.
1436 void brcms_intrson(struct brcms_info
*wl
)
1438 unsigned long flags
;
1440 INT_LOCK(wl
, flags
);
1441 brcms_c_intrson(wl
->wlc
);
1442 INT_UNLOCK(wl
, flags
);
1446 * precondition: perimeter lock has been acquired
1448 bool wl_alloc_dma_resources(struct brcms_info
*wl
, uint addrwidth
)
1453 u32
brcms_intrsoff(struct brcms_info
*wl
)
1455 unsigned long flags
;
1458 INT_LOCK(wl
, flags
);
1459 status
= brcms_c_intrsoff(wl
->wlc
);
1460 INT_UNLOCK(wl
, flags
);
1464 void brcms_intrsrestore(struct brcms_info
*wl
, u32 macintmask
)
1466 unsigned long flags
;
1468 INT_LOCK(wl
, flags
);
1469 brcms_c_intrsrestore(wl
->wlc
, macintmask
);
1470 INT_UNLOCK(wl
, flags
);
1474 * precondition: perimeter lock has been acquired
1476 int brcms_up(struct brcms_info
*wl
)
1483 error
= brcms_c_up(wl
->wlc
);
1489 * precondition: perimeter lock has been acquired
1491 void brcms_down(struct brcms_info
*wl
)
1493 uint callbacks
, ret_val
= 0;
1495 /* call common down function */
1496 ret_val
= brcms_c_down(wl
->wlc
);
1497 callbacks
= atomic_read(&wl
->callbacks
) - ret_val
;
1499 /* wait for down callbacks to complete */
1502 /* For HIGH_only driver, it's important to actually schedule other work,
1503 * not just spin wait since everything runs at schedule level
1505 SPINWAIT((atomic_read(&wl
->callbacks
) > callbacks
), 100 * 1000);
1510 static irqreturn_t
brcms_isr(int irq
, void *dev_id
)
1512 struct brcms_info
*wl
;
1514 unsigned long flags
;
1516 wl
= (struct brcms_info
*) dev_id
;
1518 ISR_LOCK(wl
, flags
);
1520 /* call common first level interrupt handler */
1521 ours
= brcms_c_isr(wl
->wlc
, &wantdpc
);
1523 /* if more to do... */
1526 /* ...and call the second level interrupt handler */
1528 tasklet_schedule(&wl
->tasklet
);
1532 ISR_UNLOCK(wl
, flags
);
1534 return IRQ_RETVAL(ours
);
1537 static void brcms_dpc(unsigned long data
)
1539 struct brcms_info
*wl
;
1541 wl
= (struct brcms_info
*) data
;
1545 /* call the common second level interrupt handler */
1548 unsigned long flags
;
1550 INT_LOCK(wl
, flags
);
1551 brcms_c_intrsupd(wl
->wlc
);
1552 INT_UNLOCK(wl
, flags
);
1555 wl
->resched
= brcms_c_dpc(wl
->wlc
, true);
1558 /* brcms_c_dpc() may bring the driver down */
1562 /* re-schedule dpc */
1564 tasklet_schedule(&wl
->tasklet
);
1566 /* re-enable interrupts */
1575 * is called by the kernel from software irq context
1577 static void brcms_timer(unsigned long data
)
1579 _brcms_timer((struct brcms_timer
*) data
);
1583 * precondition: perimeter lock is not acquired
1585 static void _brcms_timer(struct brcms_timer
*t
)
1591 t
->timer
.expires
= jiffies
+ t
->ms
* HZ
/ 1000;
1592 atomic_inc(&t
->wl
->callbacks
);
1593 add_timer(&t
->timer
);
1601 atomic_dec(&t
->wl
->callbacks
);
1607 * Adds a timer to the list. Caller supplies a timer function.
1608 * Is called from wlc.
1610 * precondition: perimeter lock has been acquired
1612 struct brcms_timer
*brcms_init_timer(struct brcms_info
*wl
,
1613 void (*fn
) (void *arg
),
1614 void *arg
, const char *name
)
1616 struct brcms_timer
*t
;
1618 t
= kzalloc(sizeof(struct brcms_timer
), GFP_ATOMIC
);
1620 wiphy_err(wl
->wiphy
, "wl%d: brcms_init_timer: out of memory\n",
1625 init_timer(&t
->timer
);
1626 t
->timer
.data
= (unsigned long) t
;
1627 t
->timer
.function
= brcms_timer
;
1631 t
->next
= wl
->timers
;
1635 t
->name
= kmalloc(strlen(name
) + 1, GFP_ATOMIC
);
1637 strcpy(t
->name
, name
);
1643 /* BMAC_NOTE: Add timer adds only the kernel timer since it's going to be more accurate
1644 * as well as it's easier to make it periodic
1646 * precondition: perimeter lock has been acquired
1648 void brcms_add_timer(struct brcms_info
*wl
, struct brcms_timer
*t
, uint ms
,
1653 wiphy_err(wl
->wiphy
, "%s: Already set. Name: %s, per %d\n",
1654 __func__
, t
->name
, periodic
);
1658 t
->periodic
= (bool) periodic
;
1660 t
->timer
.expires
= jiffies
+ ms
* HZ
/ 1000;
1662 atomic_inc(&wl
->callbacks
);
1663 add_timer(&t
->timer
);
1667 * return true if timer successfully deleted, false if still pending
1669 * precondition: perimeter lock has been acquired
1671 bool brcms_del_timer(struct brcms_info
*wl
, struct brcms_timer
*t
)
1675 if (!del_timer(&t
->timer
)) {
1678 atomic_dec(&wl
->callbacks
);
1685 * precondition: perimeter lock has been acquired
1687 void brcms_free_timer(struct brcms_info
*wl
, struct brcms_timer
*t
)
1689 struct brcms_timer
*tmp
;
1691 /* delete the timer in case it is active */
1692 brcms_del_timer(wl
, t
);
1694 if (wl
->timers
== t
) {
1695 wl
->timers
= wl
->timers
->next
;
1706 if (tmp
->next
== t
) {
1707 tmp
->next
= t
->next
;
1720 * runs in software irq context
1722 * precondition: perimeter lock is not acquired
1724 static int wl_linux_watchdog(void *ctx
)
1729 struct firmware_hdr
{
1735 char *brcms_firmwares
[MAX_FW_IMAGES
] = {
1741 * precondition: perimeter lock has been acquired
1743 int brcms_ucode_init_buf(struct brcms_info
*wl
, void **pbuf
, u32 idx
)
1747 struct firmware_hdr
*hdr
;
1748 for (i
= 0; i
< wl
->fw
.fw_cnt
; i
++) {
1749 hdr
= (struct firmware_hdr
*)wl
->fw
.fw_hdr
[i
]->data
;
1750 for (entry
= 0; entry
< wl
->fw
.hdr_num_entries
[i
];
1752 if (hdr
->idx
== idx
) {
1753 pdata
= wl
->fw
.fw_bin
[i
]->data
+ hdr
->offset
;
1754 *pbuf
= kmalloc(hdr
->len
, GFP_ATOMIC
);
1755 if (*pbuf
== NULL
) {
1756 wiphy_err(wl
->wiphy
, "fail to alloc %d"
1757 " bytes\n", hdr
->len
);
1760 memcpy(*pbuf
, pdata
, hdr
->len
);
1765 wiphy_err(wl
->wiphy
, "ERROR: ucode buf tag:%d can not be found!\n",
1773 * Precondition: Since this function is called in brcms_pci_probe() context,
1774 * no locking is required.
1776 int brcms_ucode_init_uint(struct brcms_info
*wl
, u32
*data
, u32 idx
)
1780 struct firmware_hdr
*hdr
;
1781 for (i
= 0; i
< wl
->fw
.fw_cnt
; i
++) {
1782 hdr
= (struct firmware_hdr
*)wl
->fw
.fw_hdr
[i
]->data
;
1783 for (entry
= 0; entry
< wl
->fw
.hdr_num_entries
[i
];
1785 if (hdr
->idx
== idx
) {
1786 pdata
= wl
->fw
.fw_bin
[i
]->data
+ hdr
->offset
;
1787 if (hdr
->len
!= 4) {
1788 wiphy_err(wl
->wiphy
,
1789 "ERROR: fw hdr len\n");
1792 *data
= *((u32
*) pdata
);
1797 wiphy_err(wl
->wiphy
, "ERROR: ucode tag:%d can not be found!\n", idx
);
1802 * Precondition: Since this function is called in brcms_pci_probe() context,
1803 * no locking is required.
1805 static int brcms_request_fw(struct brcms_info
*wl
, struct pci_dev
*pdev
)
1808 struct device
*device
= &pdev
->dev
;
1812 memset((void *)&wl
->fw
, 0, sizeof(struct brcms_firmware
));
1813 for (i
= 0; i
< MAX_FW_IMAGES
; i
++) {
1814 if (brcms_firmwares
[i
] == NULL
)
1816 sprintf(fw_name
, "%s-%d.fw", brcms_firmwares
[i
],
1817 UCODE_LOADER_API_VER
);
1818 status
= request_firmware(&wl
->fw
.fw_bin
[i
], fw_name
, device
);
1820 wiphy_err(wl
->wiphy
, "%s: fail to load firmware %s\n",
1821 KBUILD_MODNAME
, fw_name
);
1824 sprintf(fw_name
, "%s_hdr-%d.fw", brcms_firmwares
[i
],
1825 UCODE_LOADER_API_VER
);
1826 status
= request_firmware(&wl
->fw
.fw_hdr
[i
], fw_name
, device
);
1828 wiphy_err(wl
->wiphy
, "%s: fail to load firmware %s\n",
1829 KBUILD_MODNAME
, fw_name
);
1832 wl
->fw
.hdr_num_entries
[i
] =
1833 wl
->fw
.fw_hdr
[i
]->size
/ (sizeof(struct firmware_hdr
));
1836 return brcms_ucode_data_init(wl
);
1840 * precondition: can both be called locked and unlocked
1842 void brcms_ucode_free_buf(void *p
)
1848 * Precondition: Since this function is called in brcms_pci_probe() context,
1849 * no locking is required.
1851 static void brcms_release_fw(struct brcms_info
*wl
)
1854 for (i
= 0; i
< MAX_FW_IMAGES
; i
++) {
1855 release_firmware(wl
->fw
.fw_bin
[i
]);
1856 release_firmware(wl
->fw
.fw_hdr
[i
]);
1862 * checks validity of all firmware images loaded from user space
1864 * Precondition: Since this function is called in brcms_pci_probe() context,
1865 * no locking is required.
1867 int brcms_check_firmwares(struct brcms_info
*wl
)
1872 const struct firmware
*fw
;
1873 const struct firmware
*fw_hdr
;
1874 struct firmware_hdr
*ucode_hdr
;
1875 for (i
= 0; i
< MAX_FW_IMAGES
&& rc
== 0; i
++) {
1876 fw
= wl
->fw
.fw_bin
[i
];
1877 fw_hdr
= wl
->fw
.fw_hdr
[i
];
1878 if (fw
== NULL
&& fw_hdr
== NULL
) {
1880 } else if (fw
== NULL
|| fw_hdr
== NULL
) {
1881 wiphy_err(wl
->wiphy
, "%s: invalid bin/hdr fw\n",
1884 } else if (fw_hdr
->size
% sizeof(struct firmware_hdr
)) {
1885 wiphy_err(wl
->wiphy
, "%s: non integral fw hdr file "
1886 "size %zu/%zu\n", __func__
, fw_hdr
->size
,
1887 sizeof(struct firmware_hdr
));
1889 } else if (fw
->size
< MIN_FW_SIZE
|| fw
->size
> MAX_FW_SIZE
) {
1890 wiphy_err(wl
->wiphy
, "%s: out of bounds fw file size "
1891 "%zu\n", __func__
, fw
->size
);
1894 /* check if ucode section overruns firmware image */
1895 ucode_hdr
= (struct firmware_hdr
*)fw_hdr
->data
;
1896 for (entry
= 0; entry
< wl
->fw
.hdr_num_entries
[i
] &&
1897 !rc
; entry
++, ucode_hdr
++) {
1898 if (ucode_hdr
->offset
+ ucode_hdr
->len
>
1900 wiphy_err(wl
->wiphy
,
1901 "%s: conflicting bin/hdr\n",
1908 if (rc
== 0 && wl
->fw
.fw_cnt
!= i
) {
1909 wiphy_err(wl
->wiphy
, "%s: invalid fw_cnt=%d\n", __func__
,
1917 * precondition: perimeter lock has been acquired
1919 bool brcms_rfkill_set_hw_state(struct brcms_info
*wl
)
1921 bool blocked
= brcms_c_check_radio_disabled(wl
->wlc
);
1924 wiphy_rfkill_set_hw_state(wl
->pub
->ieee_hw
->wiphy
, blocked
);
1926 wiphy_rfkill_start_polling(wl
->pub
->ieee_hw
->wiphy
);
1932 * precondition: perimeter lock has been acquired
1934 void brcms_msleep(struct brcms_info
*wl
, uint ms
)