Changeset 10466


Ignore:
Timestamp:
2008-02-15T23:47:47+01:00 (10 years ago)
Author:
mb
Message:

Upgrade b43 and mac80211.

This also temporarly disables hostapd support for mac80211, as hostapd needs patches to compile against latest mac80211.
Will do that in a seperate patch.

Location:
trunk/package
Files:
14 added
23 deleted
66 edited

Legend:

Unmodified
Added
Removed
  • trunk/package/b43/Makefile

    r9954 r10466  
    2424 
    2525PKG_FWCUTTER_NAME:=b43-fwcutter 
    26 PKG_FWCUTTER_VERSION=008 
     26PKG_FWCUTTER_VERSION=011 
    2727 
    2828PKG_FWCUTTER_SOURCE:=$(PKG_FWCUTTER_NAME)-$(PKG_FWCUTTER_VERSION).tar.bz2 
    29 PKG_FWCUTTER_SOURCE_URL:=http://download.berlios.de/bcm43xx/ 
    30 PKG_FWCUTTER_MD5SUM:=3f7fbf4f8dcd296c6d1b0d42eab0f9ac 
     29PKG_FWCUTTER_SOURCE_URL:=http://bu3sch.de/b43/fwcutter/ 
     30PKG_FWCUTTER_MD5SUM:=3db2f4de85a459451f5b391cf67a8d44 
    3131 
    3232define KernelPackage/b43 
     
    4444EXTRA_KCONFIG:= \ 
    4545        CONFIG_B43=m \ 
    46         CONFIG_B43_DMA=y \ 
    4746        $(if $(CONFIG_LEDS_TRIGGERS),CONFIG_B43_LEDS=y) \ 
    4847 
     
    7473        tar xjf "$(DL_DIR)/$(PKG_FWV4_SOURCE)" -C "$(PKG_BUILD_DIR)" 
    7574        tar xjf "$(DL_DIR)/$(PKG_FWCUTTER_SOURCE)" -C "$(PKG_BUILD_DIR)" 
     75        $(Build/Patch) 
     76        $(if $(QUILT),touch $(PKG_BUILD_DIR)/.quilt_used) 
    7677endef 
    7778 
  • trunk/package/b43/src/Kconfig

    r9293 r10466  
    6262          If unsure, say N. 
    6363 
    64 # LED support 
     64config B43_NPHY 
     65        bool "Pre IEEE 802.11n support (BROKEN)" 
     66        depends on B43 && EXPERIMENTAL && BROKEN 
     67        ---help--- 
     68          Support for the IEEE 802.11n draft. 
     69 
     70          THIS IS BROKEN AND DOES NOT WORK YET. 
     71 
     72          SAY N. 
     73 
     74# This config option automatically enables b43 LEDS support, 
     75# if it's possible. 
    6576config B43_LEDS 
    6677        bool 
    67         depends on B43 && MAC80211_LEDS 
     78        depends on B43 && MAC80211_LEDS && (LEDS_CLASS = y || LEDS_CLASS = B43) 
    6879        default y 
    6980 
    70 # RFKILL support 
     81# This config option automatically enables b43 RFKILL support, 
     82# if it's possible. 
    7183config B43_RFKILL 
    7284        bool 
    73         depends on B43 && RFKILL && RFKILL_INPUT && INPUT_POLLDEV 
     85        depends on B43 && (RFKILL = y || RFKILL = B43) && RFKILL_INPUT && (INPUT_POLLDEV = y || INPUT_POLLDEV = B43) 
    7486        default y 
    7587 
     
    8294          Say Y, if you want to find out why the driver does not 
    8395          work for you. 
    84  
    85 config B43_DMA 
    86         bool 
    87         depends on B43 
    88 config B43_PIO 
    89         bool 
    90         depends on B43 
    91  
    92 choice 
    93         prompt "Broadcom 43xx data transfer mode" 
    94         depends on B43 
    95         default B43_DMA_AND_PIO_MODE 
    96  
    97 config B43_DMA_AND_PIO_MODE 
    98         bool "DMA + PIO" 
    99         select B43_DMA 
    100         select B43_PIO 
    101         ---help--- 
    102           Include both, Direct Memory Access (DMA) and Programmed I/O (PIO) 
    103           data transfer modes. 
    104           The actually used mode is selectable through the module 
    105           parameter "pio". If the module parameter is pio=0, DMA is used. 
    106           Otherwise PIO is used. DMA is default. 
    107  
    108           If unsure, choose this option. 
    109  
    110 config B43_DMA_MODE 
    111         bool "DMA (Direct Memory Access) only" 
    112         select B43_DMA 
    113         ---help--- 
    114           Only include Direct Memory Access (DMA). 
    115           This reduces the size of the driver module, by omitting the PIO code. 
    116  
    117 config B43_PIO_MODE 
    118         bool "PIO (Programmed I/O) only" 
    119         select B43_PIO 
    120         ---help--- 
    121           Only include Programmed I/O (PIO). 
    122           This reduces the size of the driver module, by omitting the DMA code. 
    123           Please note that PIO transfers are slow (compared to DMA). 
    124  
    125           Also note that not all devices of the 43xx series support PIO. 
    126           The 4306 (Apple Airport Extreme and others) supports PIO, while 
    127           the 4318 is known to _not_ support PIO. 
    128  
    129           Only use PIO, if DMA does not work for you. 
    130  
    131 endchoice 
  • trunk/package/b43/src/Makefile

    r9293 r10466  
    1 # b43 core 
    21b43-y                           += main.o 
    32b43-y                           += tables.o 
     3b43-y                           += tables_nphy.o 
    44b43-y                           += phy.o 
     5b43-y                           += nphy.o 
    56b43-y                           += sysfs.o 
    67b43-y                           += xmit.o 
    78b43-y                           += lo.o 
    8 # b43 RFKILL button support 
     9b43-y                           += wa.o 
     10b43-y                           += dma.o 
    911b43-$(CONFIG_B43_RFKILL)        += rfkill.o 
    10 # b43 LED support 
    1112b43-$(CONFIG_B43_LEDS)          += leds.o 
    12 # b43 PCMCIA support 
    1313b43-$(CONFIG_B43_PCMCIA)        += pcmcia.o 
    14 # b43 debugging 
    1514b43-$(CONFIG_B43_DEBUG)         += debugfs.o 
    16 # b43 DMA and PIO 
    17 b43-$(CONFIG_B43_DMA)           += dma.o 
    18 b43-$(CONFIG_B43_PIO)           += pio.o 
    1915 
    2016obj-$(CONFIG_B43)               += b43.o 
  • trunk/package/b43/src/b43.h

    r9293 r10466  
    3636#define B43_MMIO_DMA5_REASON            0x48 
    3737#define B43_MMIO_DMA5_IRQ_MASK          0x4C 
    38 #define B43_MMIO_MACCTL                 0x120 
    39 #define B43_MMIO_STATUS2_BITFIELD       0x124 
     38#define B43_MMIO_MACCTL                 0x120   /* MAC control */ 
     39#define B43_MMIO_MACCMD                 0x124   /* MAC command */ 
    4040#define B43_MMIO_GEN_IRQ_REASON         0x128 
    4141#define B43_MMIO_GEN_IRQ_MASK           0x12C 
     
    5151#define B43_MMIO_REV3PLUS_TSF_LOW       0x180   /* core rev >= 3 only */ 
    5252#define B43_MMIO_REV3PLUS_TSF_HIGH      0x184   /* core rev >= 3 only */ 
     53#define B43_MMIO_TSF_CFP_REP            0x188 
     54#define B43_MMIO_TSF_CFP_START          0x18C 
     55#define B43_MMIO_TSF_CFP_MAXDUR         0x190 
    5356 
    5457/* 32-bit DMA */ 
     
    6669#define B43_MMIO_DMA64_BASE4            0x300 
    6770#define B43_MMIO_DMA64_BASE5            0x340 
    68 /* PIO */ 
    69 #define B43_MMIO_PIO1_BASE              0x300 
    70 #define B43_MMIO_PIO2_BASE              0x310 
    71 #define B43_MMIO_PIO3_BASE              0x320 
    72 #define B43_MMIO_PIO4_BASE              0x330 
    7371 
    7472#define B43_MMIO_PHY_VER                0x3E0 
     
    8987#define B43_MMIO_GPIO_CONTROL           0x49C 
    9088#define B43_MMIO_GPIO_MASK              0x49E 
     89#define B43_MMIO_TSF_CFP_START_LOW      0x604 
     90#define B43_MMIO_TSF_CFP_START_HIGH     0x606 
    9191#define B43_MMIO_TSF_0                  0x632   /* core rev < 3 only */ 
    9292#define B43_MMIO_TSF_1                  0x634   /* core rev < 3 only */ 
     
    171171#define B43_SHM_SH_DTIMPER              0x0012  /* DTIM period */ 
    172172#define B43_SHM_SH_NOSLPZNATDTIM        0x004C  /* NOSLPZNAT DTIM */ 
    173 /* SHM_SHARED beacon variables */ 
     173/* SHM_SHARED beacon/AP variables */ 
    174174#define B43_SHM_SH_BTL0                 0x0018  /* Beacon template length 0 */ 
    175175#define B43_SHM_SH_BTL1                 0x001A  /* Beacon template length 1 */ 
    176176#define B43_SHM_SH_BTSFOFF              0x001C  /* Beacon TSF offset */ 
    177177#define B43_SHM_SH_TIMBPOS              0x001E  /* TIM B position in beacon */ 
     178#define B43_SHM_SH_DTIMP                0x0012  /* DTIP period */ 
     179#define B43_SHM_SH_MCASTCOOKIE          0x00A8  /* Last bcast/mcast frame ID */ 
    178180#define B43_SHM_SH_SFFBLIM              0x0044  /* Short frame fallback retry limit */ 
    179181#define B43_SHM_SH_LFFBLIM              0x0046  /* Long frame fallback retry limit */ 
    180182#define B43_SHM_SH_BEACPHYCTL           0x0054  /* Beacon PHY TX control word (see PHY TX control) */ 
     183#define B43_SHM_SH_EXTNPHYCTL           0x00B0  /* Extended bytes for beacon PHY control (N) */ 
    181184/* SHM_SHARED ACK/CTS control */ 
    182185#define B43_SHM_SH_ACKCTSPHYCTL         0x0022  /* ACK/CTS PHY control word (see PHY TX control) */ 
     
    274277#define B43_PHYTYPE_B                   0x01 
    275278#define B43_PHYTYPE_G                   0x02 
     279#define B43_PHYTYPE_N                   0x04 
     280#define B43_PHYTYPE_LP                  0x05 
    276281 
    277282/* PHYRegisters */ 
     
    320325#define B43_MACCTL_GMODE                0x80000000      /* G Mode */ 
    321326 
    322 /* 802.11 core specific TM State Low flags */ 
     327/* MAC Command bitfield */ 
     328#define B43_MACCMD_BEACON0_VALID        0x00000001      /* Beacon 0 in template RAM is busy/valid */ 
     329#define B43_MACCMD_BEACON1_VALID        0x00000002      /* Beacon 1 in template RAM is busy/valid */ 
     330#define B43_MACCMD_DFQ_VALID            0x00000004      /* Directed frame queue valid (IBSS PS mode, ATIM) */ 
     331#define B43_MACCMD_CCA                  0x00000008      /* Clear channel assessment */ 
     332#define B43_MACCMD_BGNOISE              0x00000010      /* Background noise */ 
     333 
     334/* 802.11 core specific TM State Low (SSB_TMSLOW) flags */ 
    323335#define B43_TMSLOW_GMODE                0x20000000      /* G Mode Enable */ 
    324 #define B43_TMSLOW_PLLREFSEL            0x00200000      /* PLL Frequency Reference Select */ 
     336#define B43_TMSLOW_PHYCLKSPEED          0x00C00000      /* PHY clock speed mask (N-PHY only) */ 
     337#define  B43_TMSLOW_PHYCLKSPEED_40MHZ   0x00000000      /* 40 MHz PHY */ 
     338#define  B43_TMSLOW_PHYCLKSPEED_80MHZ   0x00400000      /* 80 MHz PHY */ 
     339#define  B43_TMSLOW_PHYCLKSPEED_160MHZ  0x00800000      /* 160 MHz PHY */ 
     340#define B43_TMSLOW_PLLREFSEL            0x00200000      /* PLL Frequency Reference Select (rev >= 5) */ 
    325341#define B43_TMSLOW_MACPHYCLKEN          0x00100000      /* MAC PHY Clock Control Enable (rev >= 5) */ 
    326342#define B43_TMSLOW_PHYRESET             0x00080000      /* PHY Reset */ 
    327343#define B43_TMSLOW_PHYCLKEN             0x00040000      /* PHY Clock Enable */ 
    328344 
    329 /* 802.11 core specific TM State High flags */ 
     345/* 802.11 core specific TM State High (SSB_TMSHIGH) flags */ 
     346#define B43_TMSHIGH_DUALBAND_PHY        0x00080000      /* Dualband PHY available */ 
    330347#define B43_TMSHIGH_FCLOCK              0x00040000      /* Fast Clock Available (rev >= 5) */ 
    331 #define B43_TMSHIGH_APHY                0x00020000      /* A-PHY available (rev >= 5) */ 
    332 #define B43_TMSHIGH_GPHY                0x00010000      /* G-PHY available (rev >= 5) */ 
     348#define B43_TMSHIGH_HAVE_5GHZ_PHY       0x00020000      /* 5 GHz PHY available (rev >= 5) */ 
     349#define B43_TMSHIGH_HAVE_2GHZ_PHY       0x00010000      /* 2.4 GHz PHY available (rev >= 5) */ 
    333350 
    334351/* Generic-Interrupt reasons. */ 
     
    392409#define B43_DEFAULT_LONG_RETRY_LIMIT    4 
    393410 
     411#define B43_PHY_TX_BADNESS_LIMIT        1000 
     412 
    394413/* Max size of a security key */ 
    395414#define B43_SEC_KEYSIZE                 16 
     
    444463        /* GMODE bit enabled? */ 
    445464        bool gmode; 
    446         /* Possible ieee80211 subsystem hwmodes for this PHY. 
    447          * Which mode is selected, depends on thr GMODE enabled bit */ 
    448 #define B43_MAX_PHYHWMODES      2 
    449         struct ieee80211_hw_mode hwmodes[B43_MAX_PHYHWMODES]; 
    450465 
    451466        /* Analog Type */ 
     
    461476        u8 radio_rev;           /* Radio revision */ 
    462477 
    463         bool locked;            /* Only used in b43_phy_{un}lock() */ 
    464478        bool dyn_tssi_tbl;      /* tssi2dbm is kmalloc()ed. */ 
    465479 
     
    498512        s16 pga_gain;           /* PGA */ 
    499513 
    500         /* PHY lock for core.rev < 3 
    501          * This lock is only used by b43_phy_{un}lock() 
    502          */ 
    503         spinlock_t lock; 
    504  
    505514        /* Desired TX power level (in dBm). 
    506515         * This is set by the user and adjusted in b43_phy_xmitpower(). */ 
     
    513522        struct b43_rfatt rfatt; 
    514523        u8 tx_control;          /* B43_TXCTL_XXX */ 
    515 #ifdef CONFIG_B43_DEBUG 
    516         bool manual_txpower_control;    /* Manual TX-power control enabled? */ 
    517 #endif 
     524 
    518525        /* Hardware Power Control enabled? */ 
    519526        bool hardware_power_control; 
     
    543550 
    544551        u16 initval;            //FIXME rename? 
     552 
     553        /* PHY TX errors counter. */ 
     554        atomic_t txerr_cnt; 
     555 
     556        /* The device does address auto increment for the OFDM tables. 
     557         * We cache the previously used address here and omit the address 
     558         * write on the next table access, if possible. */ 
     559        u16 ofdmtab_addr; /* The address currently set in hardware. */ 
     560        enum { /* The last data flow direction. */ 
     561                B43_OFDMTAB_DIRECTION_UNKNOWN = 0, 
     562                B43_OFDMTAB_DIRECTION_READ, 
     563                B43_OFDMTAB_DIRECTION_WRITE, 
     564        } ofdmtab_addr_direction; 
     565 
     566#if B43_DEBUG 
     567        /* Manual TX-power control enabled? */ 
     568        bool manual_txpower_control; 
     569        /* PHY registers locked by b43_phy_lock()? */ 
     570        bool phy_locked; 
     571#endif /* B43_DEBUG */ 
    545572}; 
    546573 
     
    558585}; 
    559586 
    560 /* Data structures for PIO transmission, per 80211 core. */ 
    561 struct b43_pio { 
    562         struct b43_pioqueue *queue0; 
    563         struct b43_pioqueue *queue1; 
    564         struct b43_pioqueue *queue2; 
    565         struct b43_pioqueue *queue3; 
    566 }; 
    567  
    568587/* Context information for a noise calculation (Link Quality). */ 
    569588struct b43_noise_calculation { 
     
    598617        struct ieee80211_hw *hw; 
    599618 
     619        struct mutex mutex; 
    600620        spinlock_t irq_lock; 
    601         struct mutex mutex; 
     621        /* Lock for LEDs access. */ 
    602622        spinlock_t leds_lock; 
     623        /* Lock for SHM access. */ 
     624        spinlock_t shm_lock; 
    603625 
    604626        /* We can only have one operating interface (802.11 core) 
     
    606628         */ 
    607629 
    608         /* Opaque ID of the operating interface from the ieee80211 
    609          * subsystem. Do not modify. 
    610          */ 
    611         int if_id; 
     630        struct ieee80211_vif *vif; 
    612631        /* The MAC address of the operating interface. */ 
    613632        u8 mac_addr[ETH_ALEN]; 
     
    633652        struct list_head devlist; 
    634653        u8 nr_devs; 
     654 
     655        bool radiotap_enabled; 
     656 
     657        /* The beacon we are currently using (AP or IBSS mode). 
     658         * This beacon stuff is protected by the irq_lock. */ 
     659        struct sk_buff *current_beacon; 
     660        bool beacon0_uploaded; 
     661        bool beacon1_uploaded; 
     662}; 
     663 
     664/* In-memory representation of a cached microcode file. */ 
     665struct b43_firmware_file { 
     666        const char *filename; 
     667        const struct firmware *data; 
    635668}; 
    636669 
     
    638671struct b43_firmware { 
    639672        /* Microcode */ 
    640         const struct firmware *ucode; 
     673        struct b43_firmware_file ucode; 
    641674        /* PCM code */ 
    642         const struct firmware *pcm; 
     675        struct b43_firmware_file pcm; 
    643676        /* Initial MMIO values for the firmware */ 
    644         const struct firmware *initvals; 
     677        struct b43_firmware_file initvals; 
    645678        /* Initial MMIO values for the firmware, band-specific */ 
    646         const struct firmware *initvals_band; 
     679        struct b43_firmware_file initvals_band; 
     680 
    647681        /* Firmware revision */ 
    648682        u16 rev; 
     
    682716        int suspend_init_status; 
    683717 
    684         bool __using_pio;       /* Internal, use b43_using_pio(). */ 
    685718        bool bad_frames_preempt;        /* Use "Bad Frames Preemption" (default off) */ 
    686         bool reg124_set_0x4;    /* Some variable to keep track of IRQ stuff. */ 
    687         bool short_preamble;    /* TRUE, if short preamble is enabled. */ 
     719        bool dfq_valid;         /* Directed frame queue valid (IBSS PS mode, ATIM) */ 
    688720        bool short_slot;        /* TRUE, if short slot timing is enabled. */ 
    689721        bool radio_hw_enable;   /* saved state of radio hardware enabled state */ 
     
    691723        /* PHY/Radio device. */ 
    692724        struct b43_phy phy; 
    693         union { 
    694                 /* DMA engines. */ 
    695                 struct b43_dma dma; 
    696                 /* PIO engines. */ 
    697                 struct b43_pio pio; 
    698         }; 
     725 
     726        /* DMA engines. */ 
     727        struct b43_dma dma; 
    699728 
    700729        /* Various statistics about the physical device. */ 
     
    731760        struct b43_key key[58]; 
    732761 
    733         /* Cached beacon template while uploading the template. */ 
    734         struct sk_buff *cached_beacon; 
    735  
    736762        /* Firmware data */ 
    737763        struct b43_firmware fw; 
     
    750776        return hw->priv; 
    751777} 
    752  
    753 /* Helper function, which returns a boolean. 
    754  * TRUE, if PIO is used; FALSE, if DMA is used. 
    755  */ 
    756 #if defined(CONFIG_B43_DMA) && defined(CONFIG_B43_PIO) 
    757 static inline int b43_using_pio(struct b43_wldev *dev) 
    758 { 
    759         return dev->__using_pio; 
    760 } 
    761 #elif defined(CONFIG_B43_DMA) 
    762 static inline int b43_using_pio(struct b43_wldev *dev) 
    763 { 
    764         return 0; 
    765 } 
    766 #elif defined(CONFIG_B43_PIO) 
    767 static inline int b43_using_pio(struct b43_wldev *dev) 
    768 { 
    769         return 1; 
    770 } 
    771 #else 
    772 # error "Using neither DMA nor PIO? Confused..." 
    773 #endif 
    774778 
    775779static inline struct b43_wldev *dev_to_b43_wldev(struct device *dev) 
  • trunk/package/b43/src/debugfs.c

    r9535 r10466  
    3535#include "debugfs.h" 
    3636#include "dma.h" 
    37 #include "pio.h" 
    3837#include "xmit.h" 
    3938 
     
    129128 
    130129        for (i = 0; i < 0x1000; i++) { 
    131                 if (bufsize <= 0) 
     130                if (bufsize < sizeof(tmp)) 
    132131                        break; 
    133132                tmp = b43_shm_read16(dev, B43_SHM_SHARED, 2 * i); 
     
    224223                                const char *buf, size_t count) 
    225224{ 
    226         unsigned long phy_flags; 
    227  
    228225        if (dev->phy.type != B43_PHYTYPE_G) 
    229226                return -ENODEV; 
     
    249246                if (pa3db) 
    250247                        dev->phy.tx_control |= B43_TXCTL_PA3DB; 
    251                 b43_phy_lock(dev, phy_flags); 
     248                b43_phy_lock(dev); 
    252249                b43_radio_lock(dev); 
    253250                b43_set_txpower_g(dev, &dev->phy.bbatt, 
    254251                                  &dev->phy.rfatt, dev->phy.tx_control); 
    255252                b43_radio_unlock(dev); 
    256                 b43_phy_unlock(dev, phy_flags); 
     253                b43_phy_unlock(dev); 
    257254        } 
    258255 
     
    353350        struct b43_debugfs_fops *dfops; 
    354351        struct b43_dfs_file *dfile; 
    355         ssize_t ret; 
     352        ssize_t uninitialized_var(ret); 
    356353        char *buf; 
    357354        const size_t bufsize = 1024 * 128; 
  • trunk/package/b43/src/dma.c

    r9293 r10466  
    3838#include <linux/delay.h> 
    3939#include <linux/skbuff.h> 
     40#include <linux/etherdevice.h> 
     41 
    4042 
    4143/* 32bit DMA ops. */ 
     
    166168        addrext = (((u64) dmaaddr >> 32) & SSB_DMA_TRANSLATION_MASK) 
    167169            >> SSB_DMA_TRANSLATION_SHIFT; 
    168         addrhi |= ssb_dma_translation(ring->dev->dev); 
     170        addrhi |= (ssb_dma_translation(ring->dev->dev) << 1); 
    169171        if (slot == ring->nr_slots - 1) 
    170172                ctl0 |= B43_DMA64_DCTL0_DTABLEEND; 
     
    316318                ring = dev->dma.tx_ring0; 
    317319                break; 
    318         case 4: 
    319                 ring = dev->dma.tx_ring4; 
    320                 break; 
    321         case 5: 
    322                 ring = dev->dma.tx_ring5; 
    323                 break; 
    324320        } 
    325321 
     
    327323} 
    328324 
    329 /* Bcm43xx-ring to mac80211-queue mapping */ 
     325/* b43-ring to mac80211-queue mapping */ 
    330326static inline int txring_to_priority(struct b43_dmaring *ring) 
    331327{ 
    332         static const u8 idx_to_prio[] = { 3, 2, 1, 0, 4, 5, }; 
     328        static const u8 idx_to_prio[] = { 3, 2, 1, 0, }; 
     329        unsigned int index; 
    333330 
    334331/*FIXME: have only one queue, for now */ 
    335332        return 0; 
    336333 
    337         return idx_to_prio[ring->index]; 
    338 } 
    339  
    340 u16 b43_dmacontroller_base(int dma64bit, int controller_idx) 
     334        index = ring->index; 
     335        if (B43_WARN_ON(index >= ARRAY_SIZE(idx_to_prio))) 
     336                index = 0; 
     337        return idx_to_prio[index]; 
     338} 
     339 
     340static u16 b43_dmacontroller_base(enum b43_dmatype type, int controller_idx) 
    341341{ 
    342342        static const u16 map64[] = { 
     
    357357        }; 
    358358 
    359         if (dma64bit) { 
     359        if (type == B43_DMA_64BIT) { 
    360360                B43_WARN_ON(!(controller_idx >= 0 && 
    361361                              controller_idx < ARRAY_SIZE(map64))); 
     
    427427{ 
    428428        struct device *dev = ring->dev->dev->dev; 
    429  
     429        gfp_t flags = GFP_KERNEL; 
     430 
     431        /* The specs call for 4K buffers for 30- and 32-bit DMA with 4K 
     432         * alignment and 8K buffers for 64-bit DMA with 8K alignment. Testing 
     433         * has shown that 4K is sufficient for the latter as long as the buffer 
     434         * does not cross an 8K boundary. 
     435         * 
     436         * For unknown reasons - possibly a hardware error - the BCM4311 rev 
     437         * 02, which uses 64-bit DMA, needs the ring buffer in very low memory, 
     438         * which accounts for the GFP_DMA flag below. 
     439         */ 
     440        if (ring->type == B43_DMA_64BIT) 
     441                flags |= GFP_DMA; 
    430442        ring->descbase = dma_alloc_coherent(dev, B43_DMA_RINGMEMSIZE, 
    431                                             &(ring->dmabase), GFP_KERNEL); 
     443                                            &(ring->dmabase), flags); 
    432444        if (!ring->descbase) { 
    433445                b43err(ring->dev->wl, "DMA ringmemory allocation failed\n"); 
     
    448460 
    449461/* Reset the RX DMA channel */ 
    450 int b43_dmacontroller_rx_reset(struct b43_wldev *dev, u16 mmio_base, int dma64) 
     462static int b43_dmacontroller_rx_reset(struct b43_wldev *dev, u16 mmio_base, 
     463                                      enum b43_dmatype type) 
    451464{ 
    452465        int i; 
     
    456469        might_sleep(); 
    457470 
    458         offset = dma64 ? B43_DMA64_RXCTL : B43_DMA32_RXCTL; 
     471        offset = (type == B43_DMA_64BIT) ? B43_DMA64_RXCTL : B43_DMA32_RXCTL; 
    459472        b43_write32(dev, mmio_base + offset, 0); 
    460473        for (i = 0; i < 10; i++) { 
    461                 offset = dma64 ? B43_DMA64_RXSTATUS : B43_DMA32_RXSTATUS; 
     474                offset = (type == B43_DMA_64BIT) ? B43_DMA64_RXSTATUS : 
     475                                                   B43_DMA32_RXSTATUS; 
    462476                value = b43_read32(dev, mmio_base + offset); 
    463                 if (dma64) { 
     477                if (type == B43_DMA_64BIT) { 
    464478                        value &= B43_DMA64_RXSTAT; 
    465479                        if (value == B43_DMA64_RXSTAT_DISABLED) { 
     
    484498} 
    485499 
    486 /* Reset the RX DMA channel */ 
    487 int b43_dmacontroller_tx_reset(struct b43_wldev *dev, u16 mmio_base, int dma64) 
     500/* Reset the TX DMA channel */ 
     501static int b43_dmacontroller_tx_reset(struct b43_wldev *dev, u16 mmio_base, 
     502                                      enum b43_dmatype type) 
    488503{ 
    489504        int i; 
     
    494509 
    495510        for (i = 0; i < 10; i++) { 
    496                 offset = dma64 ? B43_DMA64_TXSTATUS : B43_DMA32_TXSTATUS; 
     511                offset = (type == B43_DMA_64BIT) ? B43_DMA64_TXSTATUS : 
     512                                                   B43_DMA32_TXSTATUS; 
    497513                value = b43_read32(dev, mmio_base + offset); 
    498                 if (dma64) { 
     514                if (type == B43_DMA_64BIT) { 
    499515                        value &= B43_DMA64_TXSTAT; 
    500516                        if (value == B43_DMA64_TXSTAT_DISABLED || 
     
    511527                msleep(1); 
    512528        } 
    513         offset = dma64 ? B43_DMA64_TXCTL : B43_DMA32_TXCTL; 
     529        offset = (type == B43_DMA_64BIT) ? B43_DMA64_TXCTL : B43_DMA32_TXCTL; 
    514530        b43_write32(dev, mmio_base + offset, 0); 
    515531        for (i = 0; i < 10; i++) { 
    516                 offset = dma64 ? B43_DMA64_TXSTATUS : B43_DMA32_TXSTATUS; 
     532                offset = (type == B43_DMA_64BIT) ? B43_DMA64_TXSTATUS : 
     533                                                   B43_DMA32_TXSTATUS; 
    517534                value = b43_read32(dev, mmio_base + offset); 
    518                 if (dma64) { 
     535                if (type == B43_DMA_64BIT) { 
    519536                        value &= B43_DMA64_TXSTAT; 
    520537                        if (value == B43_DMA64_TXSTAT_DISABLED) { 
     
    541558} 
    542559 
     560/* Check if a DMA mapping address is invalid. */ 
     561static bool b43_dma_mapping_error(struct b43_dmaring *ring, 
     562                                  dma_addr_t addr, 
     563                                  size_t buffersize) 
     564{ 
     565        if (unlikely(dma_mapping_error(addr))) 
     566                return 1; 
     567 
     568        switch (ring->type) { 
     569        case B43_DMA_30BIT: 
     570                if ((u64)addr + buffersize > (1ULL << 30)) 
     571                        return 1; 
     572                break; 
     573        case B43_DMA_32BIT: 
     574                if ((u64)addr + buffersize > (1ULL << 32)) 
     575                        return 1; 
     576                break; 
     577        case B43_DMA_64BIT: 
     578                /* Currently we can't have addresses beyond 
     579                 * 64bit in the kernel. */ 
     580                break; 
     581        } 
     582 
     583        /* The address is OK. */ 
     584        return 0; 
     585} 
     586 
    543587static int setup_rx_descbuffer(struct b43_dmaring *ring, 
    544588                               struct b43_dmadesc_generic *desc, 
     
    556600                return -ENOMEM; 
    557601        dmaaddr = map_descbuffer(ring, skb->data, ring->rx_buffersize, 0); 
    558         if (dma_mapping_error(dmaaddr)) { 
     602        if (b43_dma_mapping_error(ring, dmaaddr, ring->rx_buffersize)) { 
    559603                /* ugh. try to realloc in zone_dma */ 
    560604                gfp_flags |= GFP_DMA; 
     
    569613        } 
    570614 
    571         if (dma_mapping_error(dmaaddr)) { 
     615        if (b43_dma_mapping_error(ring, dmaaddr, ring->rx_buffersize)) { 
    572616                dev_kfree_skb_any(skb); 
    573617                return -EIO; 
     
    634678 
    635679        if (ring->tx) { 
    636                 if (ring->dma64) { 
     680                if (ring->type == B43_DMA_64BIT) { 
    637681                        u64 ringbase = (u64) (ring->dmabase); 
    638682 
     
    648692                                      ((ringbase >> 32) & 
    649693                                       ~SSB_DMA_TRANSLATION_MASK) 
    650                                       | trans); 
     694                                      | (trans << 1)); 
    651695                } else { 
    652696                        u32 ringbase = (u32) (ring->dmabase); 
     
    666710                if (err) 
    667711                        goto out; 
    668                 if (ring->dma64) { 
     712                if (ring->type == B43_DMA_64BIT) { 
    669713                        u64 ringbase = (u64) (ring->dmabase); 
    670714 
     
    681725                                      ((ringbase >> 32) & 
    682726                                       ~SSB_DMA_TRANSLATION_MASK) 
    683                                       | trans); 
    684                         b43_dma_write(ring, B43_DMA64_RXINDEX, 200); 
     727                                      | (trans << 1)); 
     728                        b43_dma_write(ring, B43_DMA64_RXINDEX, ring->nr_slots * 
     729                                      sizeof(struct b43_dmadesc64)); 
    685730                } else { 
    686731                        u32 ringbase = (u32) (ring->dmabase); 
     
    696741                                      (ringbase & ~SSB_DMA_TRANSLATION_MASK) 
    697742                                      | trans); 
    698                         b43_dma_write(ring, B43_DMA32_RXINDEX, 200); 
    699                 } 
    700         } 
    701  
    702       out: 
     743                        b43_dma_write(ring, B43_DMA32_RXINDEX, ring->nr_slots * 
     744                                      sizeof(struct b43_dmadesc32)); 
     745                } 
     746        } 
     747 
     748out: 
    703749        return err; 
    704750} 
     
    709755        if (ring->tx) { 
    710756                b43_dmacontroller_tx_reset(ring->dev, ring->mmio_base, 
    711                                            ring->dma64); 
    712                 if (ring->dma64) { 
     757                                           ring->type); 
     758                if (ring->type == B43_DMA_64BIT) { 
    713759                        b43_dma_write(ring, B43_DMA64_TXRINGLO, 0); 
    714760                        b43_dma_write(ring, B43_DMA64_TXRINGHI, 0); 
     
    717763        } else { 
    718764                b43_dmacontroller_rx_reset(ring->dev, ring->mmio_base, 
    719                                            ring->dma64); 
    720                 if (ring->dma64) { 
     765                                           ring->type); 
     766                if (ring->type == B43_DMA_64BIT) { 
    721767                        b43_dma_write(ring, B43_DMA64_RXRINGLO, 0); 
    722768                        b43_dma_write(ring, B43_DMA64_RXRINGHI, 0); 
     
    773819struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev, 
    774820                                      int controller_index, 
    775                                       int for_tx, int dma64) 
     821                                      int for_tx, 
     822                                      enum b43_dmatype type) 
    776823{ 
    777824        struct b43_dmaring *ring; 
     
    783830        if (!ring) 
    784831                goto out; 
     832        ring->type = type; 
    785833 
    786834        nr_slots = B43_RXRING_SLOTS; 
     
    794842        if (for_tx) { 
    795843                ring->txhdr_cache = kcalloc(nr_slots, 
    796                                             sizeof(struct b43_txhdr_fw4), 
     844                                            b43_txhdr_size(dev), 
    797845                                            GFP_KERNEL); 
    798846                if (!ring->txhdr_cache) 
     
    802850                dma_test = dma_map_single(dev->dev->dev, 
    803851                                          ring->txhdr_cache, 
    804                                           sizeof(struct b43_txhdr_fw4), 
     852                                          b43_txhdr_size(dev), 
    805853                                          DMA_TO_DEVICE); 
    806854 
    807                 if (dma_mapping_error(dma_test)) { 
     855                if (b43_dma_mapping_error(ring, dma_test, b43_txhdr_size(dev))) { 
    808856                        /* ugh realloc */ 
    809857                        kfree(ring->txhdr_cache); 
    810858                        ring->txhdr_cache = kcalloc(nr_slots, 
    811                                                     sizeof(struct 
    812                                                            b43_txhdr_fw4), 
     859                                                    b43_txhdr_size(dev), 
    813860                                                    GFP_KERNEL | GFP_DMA); 
    814861                        if (!ring->txhdr_cache) 
     
    817864                        dma_test = dma_map_single(dev->dev->dev, 
    818865                                                  ring->txhdr_cache, 
    819                                                   sizeof(struct b43_txhdr_fw4), 
     866                                                  b43_txhdr_size(dev), 
    820867                                                  DMA_TO_DEVICE); 
    821868 
    822                         if (dma_mapping_error(dma_test)) 
     869                        if (b43_dma_mapping_error(ring, dma_test, 
     870                                                  b43_txhdr_size(dev))) 
    823871                                goto err_kfree_txhdr_cache; 
    824872                } 
    825873 
    826874                dma_unmap_single(dev->dev->dev, 
    827                                  dma_test, sizeof(struct b43_txhdr_fw4), 
     875                                 dma_test, b43_txhdr_size(dev), 
    828876                                 DMA_TO_DEVICE); 
    829877        } 
     
    831879        ring->dev = dev; 
    832880        ring->nr_slots = nr_slots; 
    833         ring->mmio_base = b43_dmacontroller_base(dma64, controller_index); 
     881        ring->mmio_base = b43_dmacontroller_base(type, controller_index); 
    834882        ring->index = controller_index; 
    835         ring->dma64 = !!dma64; 
    836         if (dma64) 
     883        if (type == B43_DMA_64BIT) 
    837884                ring->ops = &dma64_ops; 
    838885        else 
     
    884931                return; 
    885932 
    886         b43dbg(ring->dev->wl, "DMA-%s 0x%04X (%s) max used slots: %d/%d\n", 
    887                (ring->dma64) ? "64" : "32", 
     933        b43dbg(ring->dev->wl, "DMA-%u 0x%04X (%s) max used slots: %d/%d\n", 
     934               (unsigned int)(ring->type), 
    888935               ring->mmio_base, 
    889936               (ring->tx) ? "TX" : "RX", ring->max_used_slots, ring->nr_slots); 
     
    902949void b43_dma_free(struct b43_wldev *dev) 
    903950{ 
    904         struct b43_dma *dma; 
    905  
    906         if (b43_using_pio(dev)) 
    907                 return; 
    908         dma = &dev->dma; 
     951        struct b43_dma *dma = &dev->dma; 
    909952 
    910953        b43_destroy_dmaring(dma->rx_ring3); 
     
    933976        int err; 
    934977        u64 dmamask; 
    935         int dma64 = 0; 
     978        enum b43_dmatype type; 
    936979 
    937980        dmamask = supported_dma_mask(dev); 
    938         if (dmamask == DMA_64BIT_MASK) 
    939                 dma64 = 1; 
    940  
     981        switch (dmamask) { 
     982        default: 
     983                B43_WARN_ON(1); 
     984        case DMA_30BIT_MASK: 
     985                type = B43_DMA_30BIT; 
     986                break; 
     987        case DMA_32BIT_MASK: 
     988                type = B43_DMA_32BIT; 
     989                break; 
     990        case DMA_64BIT_MASK: 
     991                type = B43_DMA_64BIT; 
     992                break; 
     993        } 
    941994        err = ssb_dma_set_mask(dev->dev, dmamask); 
    942995        if (err) { 
    943 #ifdef B43_PIO 
    944                 b43warn(dev->wl, "DMA for this device not supported. " 
    945                         "Falling back to PIO\n"); 
    946                 dev->__using_pio = 1; 
    947                 return -EAGAIN; 
    948 #else 
    949                 b43err(dev->wl, "DMA for this device not supported and " 
    950                        "no PIO support compiled in\n"); 
     996                b43err(dev->wl, "The machine/kernel does not support " 
     997                       "the required DMA mask (0x%08X%08X)\n", 
     998                       (unsigned int)((dmamask & 0xFFFFFFFF00000000ULL) >> 32), 
     999                       (unsigned int)(dmamask & 0x00000000FFFFFFFFULL)); 
    9511000                return -EOPNOTSUPP; 
    952 #endif 
    9531001        } 
    9541002 
    9551003        err = -ENOMEM; 
    9561004        /* setup TX DMA channels. */ 
    957         ring = b43_setup_dmaring(dev, 0, 1, dma64); 
     1005        ring = b43_setup_dmaring(dev, 0, 1, type); 
    9581006        if (!ring) 
    9591007                goto out; 
    9601008        dma->tx_ring0 = ring; 
    9611009 
    962         ring = b43_setup_dmaring(dev, 1, 1, dma64); 
     1010        ring = b43_setup_dmaring(dev, 1, 1, type); 
    9631011        if (!ring) 
    9641012                goto err_destroy_tx0; 
    9651013        dma->tx_ring1 = ring; 
    9661014 
    967         ring = b43_setup_dmaring(dev, 2, 1, dma64); 
     1015        ring = b43_setup_dmaring(dev, 2, 1, type); 
    9681016        if (!ring) 
    9691017                goto err_destroy_tx1; 
    9701018        dma->tx_ring2 = ring; 
    9711019 
    972         ring = b43_setup_dmaring(dev, 3, 1, dma64); 
     1020        ring = b43_setup_dmaring(dev, 3, 1, type); 
    9731021        if (!ring) 
    9741022                goto err_destroy_tx2; 
    9751023        dma->tx_ring3 = ring; 
    9761024 
    977         ring = b43_setup_dmaring(dev, 4, 1, dma64); 
     1025        ring = b43_setup_dmaring(dev, 4, 1, type); 
    9781026        if (!ring) 
    9791027                goto err_destroy_tx3; 
    9801028        dma->tx_ring4 = ring; 
    9811029 
    982         ring = b43_setup_dmaring(dev, 5, 1, dma64); 
     1030        ring = b43_setup_dmaring(dev, 5, 1, type); 
    9831031        if (!ring) 
    9841032                goto err_destroy_tx4; 
     
    9861034 
    9871035        /* setup RX DMA channels. */ 
    988         ring = b43_setup_dmaring(dev, 0, 0, dma64); 
     1036        ring = b43_setup_dmaring(dev, 0, 0, type); 
    9891037        if (!ring) 
    9901038                goto err_destroy_tx5; 
     
    9921040 
    9931041        if (dev->dev->id.revision < 5) { 
    994                 ring = b43_setup_dmaring(dev, 3, 0, dma64); 
     1042                ring = b43_setup_dmaring(dev, 3, 0, type); 
    9951043                if (!ring) 
    9961044                        goto err_destroy_rx0; 
     
    9981046        } 
    9991047 
    1000         b43dbg(dev->wl, "%d-bit DMA initialized\n", 
    1001                (dmamask == DMA_64BIT_MASK) ? 64 : 
    1002                (dmamask == DMA_32BIT_MASK) ? 32 : 30); 
     1048        b43dbg(dev->wl, "%u-bit DMA initialized\n", 
     1049               (unsigned int)type); 
    10031050        err = 0; 
    10041051      out: 
     
    10391086         * Note that the cookie must never be 0, as this 
    10401087         * is a special value used in RX path. 
     1088         * It can also not be 0xFFFF because that is special 
     1089         * for multicast frames. 
    10411090         */ 
    10421091        switch (ring->index) { 
    10431092        case 0: 
    1044                 cookie = 0xA000; 
     1093                cookie = 0x1000; 
    10451094                break; 
    10461095        case 1: 
    1047                 cookie = 0xB000; 
     1096                cookie = 0x2000; 
    10481097                break; 
    10491098        case 2: 
    1050                 cookie = 0xC000; 
     1099                cookie = 0x3000; 
    10511100                break; 
    10521101        case 3: 
    1053                 cookie = 0xD000; 
     1102                cookie = 0x4000; 
    10541103                break; 
    10551104        case 4: 
    1056                 cookie = 0xE000; 
     1105                cookie = 0x5000; 
    10571106                break; 
    10581107        case 5: 
    1059                 cookie = 0xF000; 
    1060                 break; 
     1108                cookie = 0x6000; 
     1109                break; 
     1110        default: 
     1111                B43_WARN_ON(1); 
    10611112        } 
    10621113        B43_WARN_ON(slot & ~0x0FFF); 
     
    10741125 
    10751126        switch (cookie & 0xF000) { 
    1076         case 0xA000: 
     1127        case 0x1000: 
    10771128                ring = dma->tx_ring0; 
    10781129                break; 
    1079         case 0xB000: 
     1130        case 0x2000: 
    10801131                ring = dma->tx_ring1; 
    10811132                break; 
    1082         case 0xC000: 
     1133        case 0x3000: 
    10831134                ring = dma->tx_ring2; 
    10841135                break; 
    1085         case 0xD000: 
     1136        case 0x4000: 
    10861137                ring = dma->tx_ring3; 
    10871138                break; 
    1088         case 0xE000: 
     1139        case 0x5000: 
    10891140                ring = dma->tx_ring4; 
    10901141                break; 
    1091         case 0xF000: 
     1142        case 0x6000: 
    10921143                ring = dma->tx_ring5; 
    10931144                break; 
     
    11071158        const struct b43_dma_ops *ops = ring->ops; 
    11081159        u8 *header; 
    1109         int slot; 
     1160        int slot, old_top_slot, old_used_slots; 
    11101161        int err; 
    11111162        struct b43_dmadesc_generic *desc; 
     
    11131164        struct b43_dmadesc_meta *meta_hdr; 
    11141165        struct sk_buff *bounce_skb; 
     1166        u16 cookie; 
     1167        size_t hdrsize = b43_txhdr_size(ring->dev); 
    11151168 
    11161169#define SLOTS_PER_PACKET  2 
    11171170        B43_WARN_ON(skb_shinfo(skb)->nr_frags); 
     1171 
     1172        old_top_slot = ring->current_slot; 
     1173        old_used_slots = ring->used_slots; 
    11181174 
    11191175        /* Get a slot for the header. */ 
     
    11221178        memset(meta_hdr, 0, sizeof(*meta_hdr)); 
    11231179 
    1124         header = &(ring->txhdr_cache[slot * sizeof(struct b43_txhdr_fw4)]); 
    1125         b43_generate_txhdr(ring->dev, header, 
    1126                            skb->data, skb->len, ctl, 
    1127                            generate_cookie(ring, slot)); 
     1180        header = &(ring->txhdr_cache[slot * hdrsize]); 
     1181        cookie = generate_cookie(ring, slot); 
     1182        err = b43_generate_txhdr(ring->dev, header, 
     1183                                 skb->data, skb->len, ctl, cookie); 
     1184        if (unlikely(err)) { 
     1185                ring->current_slot = old_top_slot; 
     1186                ring->used_slots = old_used_slots; 
     1187                return err; 
     1188        } 
    11281189 
    11291190        meta_hdr->dmaaddr = map_descbuffer(ring, (unsigned char *)header, 
    1130                                            sizeof(struct b43_txhdr_fw4), 1); 
    1131         if (dma_mapping_error(meta_hdr->dmaaddr)) 
     1191                                           hdrsize, 1); 
     1192        if (b43_dma_mapping_error(ring, meta_hdr->dmaaddr, hdrsize)) { 
     1193                ring->current_slot = old_top_slot; 
     1194                ring->used_slots = old_used_slots; 
    11321195                return -EIO; 
     1196        } 
    11331197        ops->fill_descriptor(ring, desc, meta_hdr->dmaaddr, 
    1134                              sizeof(struct b43_txhdr_fw4), 1, 0, 0); 
     1198                             hdrsize, 1, 0, 0); 
    11351199 
    11361200        /* Get a slot for the payload. */ 
     
    11451209        meta->dmaaddr = map_descbuffer(ring, skb->data, skb->len, 1); 
    11461210        /* create a bounce buffer in zone_dma on mapping failure. */ 
    1147         if (dma_mapping_error(meta->dmaaddr)) { 
     1211        if (b43_dma_mapping_error(ring, meta->dmaaddr, skb->len)) { 
    11481212                bounce_skb = __dev_alloc_skb(skb->len, GFP_ATOMIC | GFP_DMA); 
    11491213                if (!bounce_skb) { 
     1214                        ring->current_slot = old_top_slot; 
     1215                        ring->used_slots = old_used_slots; 
    11501216                        err = -ENOMEM; 
    11511217                        goto out_unmap_hdr; 
     
    11571223                meta->skb = skb; 
    11581224                meta->dmaaddr = map_descbuffer(ring, skb->data, skb->len, 1); 
    1159                 if (dma_mapping_error(meta->dmaaddr)) { 
     1225                if (b43_dma_mapping_error(ring, meta->dmaaddr, skb->len)) { 
     1226                        ring->current_slot = old_top_slot; 
     1227                        ring->used_slots = old_used_slots; 
    11601228                        err = -EIO; 
    11611229                        goto out_free_bounce; 
     
    11651233        ops->fill_descriptor(ring, desc, meta->dmaaddr, skb->len, 0, 1, 1); 
    11661234 
     1235        if (ctl->flags & IEEE80211_TXCTL_SEND_AFTER_DTIM) { 
     1236                /* Tell the firmware about the cookie of the last 
     1237                 * mcast frame, so it can clear the more-data bit in it. */ 
     1238                b43_shm_write16(ring->dev, B43_SHM_SHARED, 
     1239                                B43_SHM_SH_MCASTCOOKIE, cookie); 
     1240        } 
    11671241        /* Now transfer the whole frame. */ 
    11681242        wmb(); 
     
    11701244        return 0; 
    11711245 
    1172       out_free_bounce: 
     1246out_free_bounce: 
    11731247        dev_kfree_skb_any(skb); 
    1174       out_unmap_hdr: 
     1248out_unmap_hdr: 
    11751249        unmap_descbuffer(ring, meta_hdr->dmaaddr, 
    1176                          sizeof(struct b43_txhdr_fw4), 1); 
     1250                         hdrsize, 1); 
    11771251        return err; 
    11781252} 
     
    12031277{ 
    12041278        struct b43_dmaring *ring; 
     1279        struct ieee80211_hdr *hdr; 
    12051280        int err = 0; 
    12061281        unsigned long flags; 
    12071282 
    1208         ring = priority_to_txring(dev, ctl->queue); 
     1283        if (unlikely(skb->len < 2 + 2 + 6)) { 
     1284                /* Too short, this can't be a valid frame. */ 
     1285                return -EINVAL; 
     1286        } 
     1287 
     1288        hdr = (struct ieee80211_hdr *)skb->data; 
     1289        if (ctl->flags & IEEE80211_TXCTL_SEND_AFTER_DTIM) { 
     1290                /* The multicast ring will be sent after the DTIM */ 
     1291                ring = dev->dma.tx_ring4; 
     1292                /* Set the more-data bit. Ucode will clear it on 
     1293                 * the last frame for us. */ 
     1294                hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_MOREDATA); 
     1295        } else { 
     1296                /* Decide by priority where to put this frame. */ 
     1297                ring = priority_to_txring(dev, ctl->queue); 
     1298        } 
     1299 
    12091300        spin_lock_irqsave(&ring->lock, flags); 
    12101301        B43_WARN_ON(!ring->tx); 
     
    12201311 
    12211312        err = dma_tx_fragment(ring, skb, ctl); 
     1313        if (unlikely(err == -ENOKEY)) { 
     1314                /* Drop this packet, as we don't have the encryption key 
     1315                 * anymore and must not transmit it unencrypted. */ 
     1316                dev_kfree_skb_any(skb); 
     1317                err = 0; 
     1318                goto out_unlock; 
     1319        } 
    12221320        if (unlikely(err)) { 
    12231321                b43err(dev->wl, "DMA tx mapping failure\n"); 
     
    12341332                } 
    12351333        } 
    1236       out_unlock: 
     1334out_unlock: 
    12371335        spin_unlock_irqrestore(&ring->lock, flags); 
    12381336 
     
    12661364                else 
    12671365                        unmap_descbuffer(ring, meta->dmaaddr, 
    1268                                          sizeof(struct b43_txhdr_fw4), 1); 
     1366                                         b43_txhdr_size(dev), 1); 
    12691367 
    12701368                if (meta->is_last_fragment) { 
  • trunk/package/b43/src/dma.h

    r9293 r10466  
    171171#define B43_DMA3_RX_BUFFERSIZE  16 
    172172 
    173 #ifdef CONFIG_B43_DMA 
    174  
    175173struct sk_buff; 
    176174struct b43_private; 
     
    204202        int (*get_current_rxslot) (struct b43_dmaring * ring); 
    205203        void (*set_current_rxslot) (struct b43_dmaring * ring, int slot); 
     204}; 
     205 
     206enum b43_dmatype { 
     207        B43_DMA_30BIT   = 30, 
     208        B43_DMA_32BIT   = 32, 
     209        B43_DMA_64BIT   = 64, 
    206210}; 
    207211 
     
    238242        /* Boolean. Is this a TX ring? */ 
    239243        bool tx; 
    240         /* Boolean. 64bit DMA if true, 32bit DMA otherwise. */ 
    241         bool dma64; 
     244        /* The type of DMA engine used. */ 
     245        enum b43_dmatype type; 
    242246        /* Boolean. Is this ring stopped at ieee80211 level? */ 
    243247        bool stopped; 
     
    258262} 
    259263 
    260 static inline 
    261     void b43_dma_write(struct b43_dmaring *ring, u16 offset, u32 value) 
     264static inline void b43_dma_write(struct b43_dmaring *ring, u16 offset, u32 value) 
    262265{ 
    263266        b43_write32(ring->dev, ring->mmio_base + offset, value); 
     
    266269int b43_dma_init(struct b43_wldev *dev); 
    267270void b43_dma_free(struct b43_wldev *dev); 
    268  
    269 int b43_dmacontroller_rx_reset(struct b43_wldev *dev, 
    270                                u16 dmacontroller_mmio_base, int dma64); 
    271 int b43_dmacontroller_tx_reset(struct b43_wldev *dev, 
    272                                u16 dmacontroller_mmio_base, int dma64); 
    273  
    274 u16 b43_dmacontroller_base(int dma64bit, int dmacontroller_idx); 
    275271 
    276272void b43_dma_tx_suspend(struct b43_wldev *dev); 
     
    287283void b43_dma_rx(struct b43_dmaring *ring); 
    288284 
    289 #else /* CONFIG_B43_DMA */ 
    290  
    291 static inline int b43_dma_init(struct b43_wldev *dev) 
    292 { 
    293         return 0; 
    294 } 
    295 static inline void b43_dma_free(struct b43_wldev *dev) 
    296 { 
    297 } 
    298 static inline 
    299     int b43_dmacontroller_rx_reset(struct b43_wldev *dev, 
    300                                    u16 dmacontroller_mmio_base, int dma64) 
    301 { 
    302         return 0; 
    303 } 
    304 static inline 
    305     int b43_dmacontroller_tx_reset(struct b43_wldev *dev, 
    306                                    u16 dmacontroller_mmio_base, int dma64) 
    307 { 
    308         return 0; 
    309 } 
    310 static inline 
    311     void b43_dma_get_tx_stats(struct b43_wldev *dev, 
    312                               struct ieee80211_tx_queue_stats *stats) 
    313 { 
    314 } 
    315 static inline 
    316     int b43_dma_tx(struct b43_wldev *dev, 
    317                    struct sk_buff *skb, struct ieee80211_tx_control *ctl) 
    318 { 
    319         return 0; 
    320 } 
    321 static inline 
    322     void b43_dma_handle_txstatus(struct b43_wldev *dev, 
    323                                  const struct b43_txstatus *status) 
    324 { 
    325 } 
    326 static inline void b43_dma_rx(struct b43_dmaring *ring) 
    327 { 
    328 } 
    329 static inline void b43_dma_tx_suspend(struct b43_wldev *dev) 
    330 { 
    331 } 
    332 static inline void b43_dma_tx_resume(struct b43_wldev *dev) 
    333 { 
    334 } 
    335  
    336 #endif /* CONFIG_B43_DMA */ 
    337285#endif /* B43_DMA_H_ */ 
  • trunk/package/b43/src/leds.c

    r9535 r10466  
    55 
    66  Copyright (c) 2005 Martin Langer <martin-langer@gmx.de>, 
    7   Copyright (c) 2005 Stefano Brivio <st3@riseup.net> 
     7  Copyright (c) 2005 Stefano Brivio <stefano.brivio@polimi.it> 
    88  Copyright (c) 2005-2007 Michael Buesch <mb@bu3sch.de> 
    99  Copyright (c) 2005 Danny van Dyk <kugelfang@gentoo.org> 
     
    164164                                 b43_rfkill_led_name(dev), 
    165165                                 led_index, activelow); 
     166                /* Sync the RF-kill LED state with the switch state. */ 
     167                if (dev->radio_hw_enable) 
     168                        b43_led_turn_on(dev, led_index, activelow); 
    166169                break; 
    167170        case B43_LED_WEIRD: 
     
    188191        bool activelow; 
    189192 
    190         sprom[0] = bus->sprom.r1.gpio0; 
    191         sprom[1] = bus->sprom.r1.gpio1; 
    192         sprom[2] = bus->sprom.r1.gpio2; 
    193         sprom[3] = bus->sprom.r1.gpio3; 
     193        sprom[0] = bus->sprom.gpio0; 
     194        sprom[1] = bus->sprom.gpio1; 
     195        sprom[2] = bus->sprom.gpio2; 
     196        sprom[3] = bus->sprom.gpio3; 
    194197 
    195198        for (i = 0; i < 4; i++) { 
     
    233236        b43_unregister_led(&dev->led_rx); 
    234237        b43_unregister_led(&dev->led_assoc); 
    235 } 
     238        b43_unregister_led(&dev->led_radio); 
     239} 
  • trunk/package/b43/src/lo.c

    r9293 r10466  
    66 
    77  Copyright (c) 2005 Martin Langer <martin-langer@gmx.de>, 
    8   Copyright (c) 2005, 2006 Stefano Brivio <st3@riseup.net> 
     8  Copyright (c) 2005, 2006 Stefano Brivio <stefano.brivio@polimi.it> 
    99  Copyright (c) 2005-2007 Michael Buesch <mb@bu3sch.de> 
    1010  Copyright (c) 2005, 2006 Danny van Dyk <kugelfang@gentoo.org> 
     
    265265                rfover |= lna; 
    266266                rfover |= trsw_rx; 
    267                 if ((dev->dev->bus->sprom.r1.boardflags_lo & B43_BFL_EXTLNA) && 
    268                     phy->rev > 6) 
     267                if ((dev->dev->bus->sprom.boardflags_lo & B43_BFL_EXTLNA) 
     268                    && phy->rev > 6) 
    269269                        rfover |= B43_PHY_RFOVERVAL_EXTLNA; 
    270270 
     
    556556        u16 phy_dacctl_hwpctl; 
    557557        u16 phy_dacctl; 
    558         u16 phy_base_14; 
     558        u16 phy_cck_14; 
    559559        u16 phy_hpwr_tssictl; 
    560560        u16 phy_analogover; 
     
    563563        u16 phy_rfoverval; 
    564564        u16 phy_classctl; 
    565         u16 phy_base_3E; 
     565        u16 phy_cck_3E; 
    566566        u16 phy_crs0; 
    567567        u16 phy_pgactl; 
    568         u16 phy_base_2A; 
     568        u16 phy_cck_2A; 
    569569        u16 phy_syncctl; 
    570         u16 phy_base_30; 
    571         u16 phy_base_06; 
     570        u16 phy_cck_30; 
     571        u16 phy_cck_06; 
    572572 
    573573        /* Radio registers */ 
     
    589589                sav->phy_extg_01 = b43_phy_read(dev, B43_PHY_EXTG(0x01)); 
    590590                sav->phy_dacctl_hwpctl = b43_phy_read(dev, B43_PHY_DACCTL); 
    591                 sav->phy_base_14 = b43_phy_read(dev, B43_PHY_BASE(0x14)); 
     591                sav->phy_cck_14 = b43_phy_read(dev, B43_PHY_CCK(0x14)); 
    592592                sav->phy_hpwr_tssictl = b43_phy_read(dev, B43_PHY_HPWR_TSSICTL); 
    593593 
     
    601601                              b43_phy_read(dev, B43_PHY_DACCTL) 
    602602                              | 0x40); 
    603                 b43_phy_write(dev, B43_PHY_BASE(0x14), 
    604                               b43_phy_read(dev, B43_PHY_BASE(0x14)) 
     603                b43_phy_write(dev, B43_PHY_CCK(0x14), 
     604                              b43_phy_read(dev, B43_PHY_CCK(0x14)) 
    605605                              | 0x200); 
    606606        } 
    607607        if (phy->type == B43_PHYTYPE_B && 
    608608            phy->radio_ver == 0x2050 && phy->radio_rev < 6) { 
    609                 b43_phy_write(dev, B43_PHY_BASE(0x16), 0x410); 
    610                 b43_phy_write(dev, B43_PHY_BASE(0x17), 0x820); 
     609                b43_phy_write(dev, B43_PHY_CCK(0x16), 0x410); 
     610                b43_phy_write(dev, B43_PHY_CCK(0x17), 0x820); 
    611611        } 
    612612        if (!lo->rebuild && b43_has_hardware_pctl(phy)) 
     
    619619                sav->phy_rfoverval = b43_phy_read(dev, B43_PHY_RFOVERVAL); 
    620620                sav->phy_classctl = b43_phy_read(dev, B43_PHY_CLASSCTL); 
    621                 sav->phy_base_3E = b43_phy_read(dev, B43_PHY_BASE(0x3E)); 
     621                sav->phy_cck_3E = b43_phy_read(dev, B43_PHY_CCK(0x3E)); 
    622622                sav->phy_crs0 = b43_phy_read(dev, B43_PHY_CRS0); 
    623623 
     
    635635                if (phy->type == B43_PHYTYPE_G) { 
    636636                        if ((phy->rev >= 7) && 
    637                             (sprom->r1.boardflags_lo & B43_BFL_EXTLNA)) { 
     637                            (sprom->boardflags_lo & B43_BFL_EXTLNA)) { 
    638638                                b43_phy_write(dev, B43_PHY_RFOVER, 0x933); 
    639639                        } else { 
     
    643643                        b43_phy_write(dev, B43_PHY_RFOVER, 0); 
    644644                } 
    645                 b43_phy_write(dev, B43_PHY_BASE(0x3E), 0); 
     645                b43_phy_write(dev, B43_PHY_CCK(0x3E), 0); 
    646646        } 
    647647        sav->reg_3F4 = b43_read16(dev, 0x3F4); 
     
    650650        sav->radio_7A = b43_radio_read16(dev, 0x7A); 
    651651        sav->phy_pgactl = b43_phy_read(dev, B43_PHY_PGACTL); 
    652         sav->phy_base_2A = b43_phy_read(dev, B43_PHY_BASE(0x2A)); 
     652        sav->phy_cck_2A = b43_phy_read(dev, B43_PHY_CCK(0x2A)); 
    653653        sav->phy_syncctl = b43_phy_read(dev, B43_PHY_SYNCCTL); 
    654654        sav->phy_dacctl = b43_phy_read(dev, B43_PHY_DACCTL); 
     
    659659        } 
    660660        if (phy->type == B43_PHYTYPE_B) { 
    661                 sav->phy_base_30 = b43_phy_read(dev, B43_PHY_BASE(0x30)); 
    662                 sav->phy_base_06 = b43_phy_read(dev, B43_PHY_BASE(0x06)); 
    663                 b43_phy_write(dev, B43_PHY_BASE(0x30), 0x00FF); 
    664                 b43_phy_write(dev, B43_PHY_BASE(0x06), 0x3F3F); 
     661                sav->phy_cck_30 = b43_phy_read(dev, B43_PHY_CCK(0x30)); 
     662                sav->phy_cck_06 = b43_phy_read(dev, B43_PHY_CCK(0x06)); 
     663                b43_phy_write(dev, B43_PHY_CCK(0x30), 0x00FF); 
     664                b43_phy_write(dev, B43_PHY_CCK(0x06), 0x3F3F); 
    665665        } else { 
    666666                b43_write16(dev, 0x3E2, b43_read16(dev, 0x3E2) 
     
    671671 
    672672        tmp = 
    673             (phy->type == B43_PHYTYPE_G) ? B43_PHY_LO_MASK : B43_PHY_BASE(0x2E); 
     673            (phy->type == B43_PHYTYPE_G) ? B43_PHY_LO_MASK : B43_PHY_CCK(0x2E); 
    674674        b43_phy_write(dev, tmp, 0x007F); 
    675675 
     
    679679        b43_radio_write16(dev, 0x007A, tmp & 0xFFF0); 
    680680 
    681         b43_phy_write(dev, B43_PHY_BASE(0x2A), 0x8A3); 
     681        b43_phy_write(dev, B43_PHY_CCK(0x2A), 0x8A3); 
    682682        if (phy->type == B43_PHYTYPE_G || 
    683683            (phy->type == B43_PHYTYPE_B && 
    684684             phy->radio_ver == 0x2050 && phy->radio_rev >= 6)) { 
    685                 b43_phy_write(dev, B43_PHY_BASE(0x2B), 0x1003); 
     685                b43_phy_write(dev, B43_PHY_CCK(0x2B), 0x1003); 
    686686        } else 
    687                 b43_phy_write(dev, B43_PHY_BASE(0x2B), 0x0802); 
     687                b43_phy_write(dev, B43_PHY_CCK(0x2B), 0x0802); 
    688688        if (phy->rev >= 2) 
    689689                b43_dummy_transmission(dev); 
     
    691691        b43_radio_read16(dev, 0x51);    /* dummy read */ 
    692692        if (phy->type == B43_PHYTYPE_G) 
    693                 b43_phy_write(dev, B43_PHY_BASE(0x2F), 0); 
     693                b43_phy_write(dev, B43_PHY_CCK(0x2F), 0); 
    694694        if (lo->rebuild) 
    695695                lo_measure_txctl_values(dev); 
     
    698698        } else { 
    699699                if (phy->type == B43_PHYTYPE_B) 
    700                         b43_phy_write(dev, B43_PHY_BASE(0x2E), 0x8078); 
     700                        b43_phy_write(dev, B43_PHY_CCK(0x2E), 0x8078); 
    701701                else 
    702702                        b43_phy_write(dev, B43_PHY_LO_MASK, 0x8078); 
     
    733733        if (phy->type == B43_PHYTYPE_G) { 
    734734                if (phy->rev >= 3) 
    735                         b43_phy_write(dev, B43_PHY_BASE(0x2E), 0xC078); 
     735                        b43_phy_write(dev, B43_PHY_CCK(0x2E), 0xC078); 
    736736                else 
    737                         b43_phy_write(dev, B43_PHY_BASE(0x2E), 0x8078); 
     737                        b43_phy_write(dev, B43_PHY_CCK(0x2E), 0x8078); 
    738738                if (phy->rev >= 2) 
    739                         b43_phy_write(dev, B43_PHY_BASE(0x2F), 0x0202); 
     739                        b43_phy_write(dev, B43_PHY_CCK(0x2F), 0x0202); 
    740740                else 
    741                         b43_phy_write(dev, B43_PHY_BASE(0x2F), 0x0101); 
     741                        b43_phy_write(dev, B43_PHY_CCK(0x2F), 0x0101); 
    742742        } 
    743743        b43_write16(dev, 0x3F4, sav->reg_3F4); 
    744744        b43_phy_write(dev, B43_PHY_PGACTL, sav->phy_pgactl); 
    745         b43_phy_write(dev, B43_PHY_BASE(0x2A), sav->phy_base_2A); 
     745        b43_phy_write(dev, B43_PHY_CCK(0x2A), sav->phy_cck_2A); 
    746746        b43_phy_write(dev, B43_PHY_SYNCCTL, sav->phy_syncctl); 
    747747        b43_phy_write(dev, B43_PHY_DACCTL, sav->phy_dacctl); 
     
    756756        if (phy->type == B43_PHYTYPE_B && 
    757757            phy->radio_ver == 0x2050 && phy->radio_rev <= 5) { 
    758                 b43_phy_write(dev, B43_PHY_BASE(0x30), sav->phy_base_30); 
    759                 b43_phy_write(dev, B43_PHY_BASE(0x06), sav->phy_base_06); 
     758                b43_phy_write(dev, B43_PHY_CCK(0x30), sav->phy_cck_30); 
     759                b43_phy_write(dev, B43_PHY_CCK(0x06), sav->phy_cck_06); 
    760760        } 
    761761        if (phy->rev >= 2) { 
     
    766766                b43_phy_write(dev, B43_PHY_RFOVER, sav->phy_rfover); 
    767767                b43_phy_write(dev, B43_PHY_RFOVERVAL, sav->phy_rfoverval); 
    768                 b43_phy_write(dev, B43_PHY_BASE(0x3E), sav->phy_base_3E); 
     768                b43_phy_write(dev, B43_PHY_CCK(0x3E), sav->phy_cck_3E); 
    769769                b43_phy_write(dev, B43_PHY_CRS0, sav->phy_crs0); 
    770770        } 
     
    774774                b43_phy_write(dev, B43_PHY_EXTG(0x01), sav->phy_extg_01); 
    775775                b43_phy_write(dev, B43_PHY_DACCTL, sav->phy_dacctl_hwpctl); 
    776                 b43_phy_write(dev, B43_PHY_BASE(0x14), sav->phy_base_14); 
     776                b43_phy_write(dev, B43_PHY_CCK(0x14), sav->phy_cck_14); 
    777777                b43_phy_write(dev, B43_PHY_HPWR_TSSICTL, sav->phy_hpwr_tssictl); 
    778778        } 
  • trunk/package/b43/src/main.c

    r9535 r10466  
    44 
    55  Copyright (c) 2005 Martin Langer <martin-langer@gmx.de> 
    6   Copyright (c) 2005 Stefano Brivio <st3@riseup.net> 
     6  Copyright (c) 2005 Stefano Brivio <stefano.brivio@polimi.it> 
    77  Copyright (c) 2005, 2006 Michael Buesch <mb@bu3sch.de> 
    88  Copyright (c) 2005 Danny van Dyk <kugelfang@gentoo.org> 
     
    4747#include "phy.h" 
    4848#include "dma.h" 
    49 #include "pio.h" 
    5049#include "sysfs.h" 
    5150#include "xmit.h" 
     
    5958MODULE_LICENSE("GPL"); 
    6059 
    61 extern char *nvram_get(char *name); 
    62  
    63 #if defined(CONFIG_B43_DMA) && defined(CONFIG_B43_PIO) 
    64 static int modparam_pio; 
    65 module_param_named(pio, modparam_pio, int, 0444); 
    66 MODULE_PARM_DESC(pio, "enable(1) / disable(0) PIO mode"); 
    67 #elif defined(CONFIG_B43_DMA) 
    68 # define modparam_pio   0 
    69 #elif defined(CONFIG_B43_PIO) 
    70 # define modparam_pio   1 
    71 #endif 
    7260 
    7361static int modparam_bad_frames_preempt; 
     
    7563MODULE_PARM_DESC(bad_frames_preempt, 
    7664                 "enable(1) / disable(0) Bad Frames Preemption"); 
    77  
    78 static int modparam_short_retry = B43_DEFAULT_SHORT_RETRY_LIMIT; 
    79 module_param_named(short_retry, modparam_short_retry, int, 0444); 
    80 MODULE_PARM_DESC(short_retry, "Short-Retry-Limit (0 - 15)"); 
    81  
    82 static int modparam_long_retry = B43_DEFAULT_LONG_RETRY_LIMIT; 
    83 module_param_named(long_retry, modparam_long_retry, int, 0444); 
    84 MODULE_PARM_DESC(long_retry, "Long-Retry-Limit (0 - 15)"); 
    8565 
    8666static char modparam_fwpostfix[16]; 
     
    10282        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 9), 
    10383        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 10), 
     84        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 11), 
     85        SSB_DEVICE(SSB_VENDOR_BROADCOM, SSB_DEV_80211, 13), 
    10486        SSB_DEVTABLE_END 
    10587}; 
     
    10789MODULE_DEVICE_TABLE(ssb, b43_ssb_tbl); 
    10890 
    109 static const struct pci_device_id b43_pci_bridge_tbl[] = { 
    110         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4311) }, 
    111         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4312) }, 
    112         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4318) }, 
    113         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4319) }, 
    114         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4320) }, 
    115         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4321) }, 
    116         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4324) }, 
    117         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4325) }, 
    118         { 0, }, 
    119 }; 
    120 MODULE_DEVICE_TABLE(pci, b43_pci_bridge_tbl); 
    121  
    122 static struct pci_driver b43_pci_bridge_driver = { 
    123         .name = "b43-pci-bridge", 
    124         .id_table = b43_pci_bridge_tbl, 
    125 }; 
    12691/* Channel and ratetables are shared for all devices. 
    12792 * They can't be const, because ieee80211 puts some precalculated 
     
    12994 * get concurrency issues */ 
    13095#define RATETAB_ENT(_rateid, _flags) \ 
    131         {                                                       \ 
    132                 .rate   = B43_RATE_TO_BASE100KBPS(_rateid),     \ 
    133                 .val    = (_rateid),                            \ 
    134                 .val2   = (_rateid),                            \ 
    135                 .flags  = (_flags),                             \ 
    136         } 
     96        {                                                               \ 
     97                .bitrate        = B43_RATE_TO_BASE100KBPS(_rateid),     \ 
     98                .hw_value       = (_rateid),                            \ 
     99                .flags          = (_flags),                             \ 
     100        } 
     101 
     102/* 
     103 * NOTE: When changing this, sync with xmit.c's 
     104 *       b43_plcp_get_bitrate_idx_* functions! 
     105 */ 
    137106static struct ieee80211_rate __b43_ratetable[] = { 
    138         RATETAB_ENT(B43_CCK_RATE_1MB, IEEE80211_RATE_CCK), 
    139         RATETAB_ENT(B43_CCK_RATE_2MB, IEEE80211_RATE_CCK_2), 
    140         RATETAB_ENT(B43_CCK_RATE_5MB, IEEE80211_RATE_CCK_2), 
    141         RATETAB_ENT(B43_CCK_RATE_11MB, IEEE80211_RATE_CCK_2), 
    142         RATETAB_ENT(B43_OFDM_RATE_6MB, IEEE80211_RATE_OFDM), 
    143         RATETAB_ENT(B43_OFDM_RATE_9MB, IEEE80211_RATE_OFDM), 
    144         RATETAB_ENT(B43_OFDM_RATE_12MB, IEEE80211_RATE_OFDM), 
    145         RATETAB_ENT(B43_OFDM_RATE_18MB, IEEE80211_RATE_OFDM), 
    146         RATETAB_ENT(B43_OFDM_RATE_24MB, IEEE80211_RATE_OFDM), 
    147         RATETAB_ENT(B43_OFDM_RATE_36MB, IEEE80211_RATE_OFDM), 
    148         RATETAB_ENT(B43_OFDM_RATE_48MB, IEEE80211_RATE_OFDM), 
    149         RATETAB_ENT(B43_OFDM_RATE_54MB, IEEE80211_RATE_OFDM), 
     107        RATETAB_ENT(B43_CCK_RATE_1MB, 0), 
     108        RATETAB_ENT(B43_CCK_RATE_2MB, IEEE80211_RATE_SHORT_PREAMBLE), 
     109        RATETAB_ENT(B43_CCK_RATE_5MB, IEEE80211_RATE_SHORT_PREAMBLE), 
     110        RATETAB_ENT(B43_CCK_RATE_11MB, IEEE80211_RATE_SHORT_PREAMBLE), 
     111        RATETAB_ENT(B43_OFDM_RATE_6MB, 0), 
     112        RATETAB_ENT(B43_OFDM_RATE_9MB, 0), 
     113        RATETAB_ENT(B43_OFDM_RATE_12MB, 0), 
     114        RATETAB_ENT(B43_OFDM_RATE_18MB, 0), 
     115        RATETAB_ENT(B43_OFDM_RATE_24MB, 0), 
     116        RATETAB_ENT(B43_OFDM_RATE_36MB, 0), 
     117        RATETAB_ENT(B43_OFDM_RATE_48MB, 0), 
     118        RATETAB_ENT(B43_OFDM_RATE_54MB, 0), 
    150119}; 
    151120 
     
    159128#define CHANTAB_ENT(_chanid, _freq) \ 
    160129        {                                                       \ 
    161                 .chan   = (_chanid),                            \ 
    162                 .freq   = (_freq),                              \ 
    163                 .val    = (_chanid),                            \ 
    164                 .flag   = IEEE80211_CHAN_W_SCAN |               \ 
    165                           IEEE80211_CHAN_W_ACTIVE_SCAN |        \ 
    166                           IEEE80211_CHAN_W_IBSS,                \ 
    167                 .power_level    = 0xFF,                         \ 
    168                 .antenna_max    = 0xFF,                         \ 
    169         } 
    170 static struct ieee80211_channel b43_bg_chantable[] = { 
     130                .center_freq    = (_freq),                      \ 
     131                .hw_value       = (_chanid),                    \ 
     132        } 
     133static struct ieee80211_channel b43_2ghz_chantable[] = { 
    171134        CHANTAB_ENT(1, 2412), 
    172135        CHANTAB_ENT(2, 2417), 
     
    185148}; 
    186149 
    187 #define b43_bg_chantable_size   ARRAY_SIZE(b43_bg_chantable) 
    188 static struct ieee80211_channel b43_a_chantable[] = { 
     150#ifdef NOTYET 
     151static struct ieee80211_channel b43_5ghz_chantable[] = { 
    189152        CHANTAB_ENT(36, 5180), 
    190153        CHANTAB_ENT(40, 5200), 
     
    202165}; 
    203166 
    204 #define b43_a_chantable_size    ARRAY_SIZE(b43_a_chantable) 
     167static struct ieee80211_supported_band b43_band_5GHz = { 
     168        .channels = b43_5ghz_chantable, 
     169        .n_channels = ARRAY_SIZE(b43_5ghz_chantable), 
     170        .bitrates = b43_a_ratetable, 
     171        .n_bitrates = b43_a_ratetable_size, 
     172}; 
     173#endif 
     174 
     175static struct ieee80211_supported_band b43_band_2GHz = { 
     176        .channels = b43_2ghz_chantable, 
     177        .n_channels = ARRAY_SIZE(b43_2ghz_chantable), 
     178        .bitrates = b43_g_ratetable, 
     179        .n_bitrates = b43_g_ratetable_size, 
     180}; 
    205181 
    206182static void b43_wireless_core_exit(struct b43_wldev *dev); 
     
    287263} 
    288264 
    289 static inline 
    290     void b43_shm_control_word(struct b43_wldev *dev, u16 routing, u16 offset) 
     265static inline void b43_shm_control_word(struct b43_wldev *dev, 
     266                                        u16 routing, u16 offset) 
    291267{ 
    292268        u32 control; 
    293269 
    294270        /* "offset" is the WORD offset. */ 
    295  
    296271        control = routing; 
    297272        control <<= 16; 
     
    302277u32 b43_shm_read32(struct b43_wldev *dev, u16 routing, u16 offset) 
    303278{ 
     279        struct b43_wl *wl = dev->wl; 
     280        unsigned long flags; 
    304281        u32 ret; 
    305282 
     283        spin_lock_irqsave(&wl->shm_lock, flags); 
    306284        if (routing == B43_SHM_SHARED) { 
    307285                B43_WARN_ON(offset & 0x0001); 
     
    314292                        ret |= b43_read16(dev, B43_MMIO_SHM_DATA); 
    315293 
    316                         return ret; 
     294                        goto out; 
    317295                } 
    318296                offset >>= 2; 
     
    320298        b43_shm_control_word(dev, routing, offset); 
    321299        ret = b43_read32(dev, B43_MMIO_SHM_DATA); 
     300out: 
     301        spin_unlock_irqrestore(&wl->shm_lock, flags); 
    322302 
    323303        return ret; 
     
    326306u16 b43_shm_read16(struct b43_wldev * dev, u16 routing, u16 offset) 
    327307{ 
     308        struct b43_wl *wl = dev->wl; 
     309        unsigned long flags; 
    328310        u16 ret; 
    329311 
     312        spin_lock_irqsave(&wl->shm_lock, flags); 
    330313        if (routing == B43_SHM_SHARED) { 
    331314                B43_WARN_ON(offset & 0x0001); 
     
    335318                        ret = b43_read16(dev, B43_MMIO_SHM_DATA_UNALIGNED); 
    336319 
    337                         return ret; 
     320                        goto out; 
    338321                } 
    339322                offset >>= 2; 
     
    341324        b43_shm_control_word(dev, routing, offset); 
    342325        ret = b43_read16(dev, B43_MMIO_SHM_DATA); 
     326out: 
     327        spin_unlock_irqrestore(&wl->shm_lock, flags); 
    343328 
    344329        return ret; 
     
    347332void b43_shm_write32(struct b43_wldev *dev, u16 routing, u16 offset, u32 value) 
    348333{ 
     334        struct b43_wl *wl = dev->wl; 
     335        unsigned long flags; 
     336 
     337        spin_lock_irqsave(&wl->shm_lock, flags); 
    349338        if (routing == B43_SHM_SHARED) { 
    350339                B43_WARN_ON(offset & 0x0001); 
     
    352341                        /* Unaligned access */ 
    353342                        b43_shm_control_word(dev, routing, offset >> 2); 
    354                         mmiowb(); 
    355343                        b43_write16(dev, B43_MMIO_SHM_DATA_UNALIGNED, 
    356344                                    (value >> 16) & 0xffff); 
    357                         mmiowb(); 
    358345                        b43_shm_control_word(dev, routing, (offset >> 2) + 1); 
    359                         mmiowb(); 
    360346                        b43_write16(dev, B43_MMIO_SHM_DATA, value & 0xffff); 
    361                         return; 
     347                        goto out; 
    362348                } 
    363349                offset >>= 2; 
    364350        } 
    365351        b43_shm_control_word(dev, routing, offset); 
    366         mmiowb(); 
    367352        b43_write32(dev, B43_MMIO_SHM_DATA, value); 
     353out: 
     354        spin_unlock_irqrestore(&wl->shm_lock, flags); 
    368355} 
    369356 
    370357void b43_shm_write16(struct b43_wldev *dev, u16 routing, u16 offset, u16 value) 
    371358{ 
     359        struct b43_wl *wl = dev->wl; 
     360        unsigned long flags; 
     361 
     362        spin_lock_irqsave(&wl->shm_lock, flags); 
    372363        if (routing == B43_SHM_SHARED) { 
    373364                B43_WARN_ON(offset & 0x0001); 
     
    375366                        /* Unaligned access */ 
    376367                        b43_shm_control_word(dev, routing, offset >> 2); 
    377                         mmiowb(); 
    378368                        b43_write16(dev, B43_MMIO_SHM_DATA_UNALIGNED, value); 
    379                         return; 
     369                        goto out; 
    380370                } 
    381371                offset >>= 2; 
    382372        } 
    383373        b43_shm_control_word(dev, routing, offset); 
    384         mmiowb(); 
    385374        b43_write16(dev, B43_MMIO_SHM_DATA, value); 
     375out: 
     376        spin_unlock_irqrestore(&wl->shm_lock, flags); 
    386377} 
    387378 
     
    10301021{ 
    10311022        b43_jssi_write(dev, 0x7F7F7F7F); 
    1032         b43_write32(dev, B43_MMIO_STATUS2_BITFIELD, 
    1033                     b43_read32(dev, B43_MMIO_STATUS2_BITFIELD) 
    1034                     | (1 << 4)); 
     1023        b43_write32(dev, B43_MMIO_MACCMD, 
     1024                    b43_read32(dev, B43_MMIO_MACCMD) | B43_MACCMD_BGNOISE); 
    10351025        B43_WARN_ON(dev->noisecalc.channel_at_start != dev->phy.channel); 
    10361026} 
     
    11181108                        b43_power_saving_ctl_bits(dev, 0); 
    11191109        } 
    1120         dev->reg124_set_0x4 = 0; 
    11211110        if (b43_is_mode(dev->wl, IEEE80211_IF_TYPE_IBSS)) 
    1122                 dev->reg124_set_0x4 = 1; 
     1111                dev->dfq_valid = 1; 
    11231112} 
    11241113 
    11251114static void handle_irq_atim_end(struct b43_wldev *dev) 
    11261115{ 
    1127         if (!dev->reg124_set_0x4 /*FIXME rename this variable */ ) 
    1128                 return; 
    1129         b43_write32(dev, B43_MMIO_STATUS2_BITFIELD, 
    1130                     b43_read32(dev, B43_MMIO_STATUS2_BITFIELD) 
    1131                     | 0x4); 
     1116        if (dev->dfq_valid) { 
     1117                b43_write32(dev, B43_MMIO_MACCMD, 
     1118                            b43_read32(dev, B43_MMIO_MACCMD) 
     1119                            | B43_MACCMD_DFQ_VALID); 
     1120                dev->dfq_valid = 0; 
     1121        } 
    11321122} 
    11331123 
     
    11841174                                      u16 shm_size_offset, u8 rate) 
    11851175{ 
    1186         int len; 
    1187         const u8 *data; 
    1188  
    1189         B43_WARN_ON(!dev->cached_beacon); 
    1190         len = min((size_t) dev->cached_beacon->len, 
     1176        unsigned int i, len, variable_len; 
     1177        const struct ieee80211_mgmt *bcn; 
     1178        const u8 *ie; 
     1179        bool tim_found = 0; 
     1180 
     1181        bcn = (const struct ieee80211_mgmt *)(dev->wl->current_beacon->data); 
     1182        len = min((size_t) dev->wl->current_beacon->len, 
    11911183                  0x200 - sizeof(struct b43_plcp_hdr6)); 
    1192         data = (const u8 *)(dev->cached_beacon->data); 
    1193         b43_write_template_common(dev, data, 
     1184 
     1185        b43_write_template_common(dev, (const u8 *)bcn, 
    11941186                                  len, ram_offset, shm_size_offset, rate); 
     1187 
     1188        /* Find the position of the TIM and the DTIM_period value 
     1189         * and write them to SHM. */ 
     1190        ie = bcn->u.beacon.variable; 
     1191        variable_len = len - offsetof(struct ieee80211_mgmt, u.beacon.variable); 
     1192        for (i = 0; i < variable_len - 2; ) { 
     1193                uint8_t ie_id, ie_len; 
     1194 
     1195                ie_id = ie[i]; 
     1196                ie_len = ie[i + 1]; 
     1197                if (ie_id == 5) { 
     1198                        u16 tim_position; 
     1199                        u16 dtim_period; 
     1200                        /* This is the TIM Information Element */ 
     1201 
     1202                        /* Check whether the ie_len is in the beacon data range. */ 
     1203                        if (variable_len < ie_len + 2 + i) 
     1204                                break; 
     1205                        /* A valid TIM is at least 4 bytes long. */ 
     1206                        if (ie_len < 4) 
     1207                                break; 
     1208                        tim_found = 1; 
     1209 
     1210                        tim_position = sizeof(struct b43_plcp_hdr6); 
     1211                        tim_position += offsetof(struct ieee80211_mgmt, u.beacon.variable); 
     1212                        tim_position += i; 
     1213 
     1214                        dtim_period = ie[i + 3]; 
     1215 
     1216                        b43_shm_write16(dev, B43_SHM_SHARED, 
     1217                                        B43_SHM_SH_TIMBPOS, tim_position); 
     1218                        b43_shm_write16(dev, B43_SHM_SHARED, 
     1219                                        B43_SHM_SH_DTIMPER, dtim_period); 
     1220                        break; 
     1221                } 
     1222                i += ie_len + 2; 
     1223        } 
     1224        if (!tim_found) { 
     1225                b43warn(dev->wl, "Did not find a valid TIM IE in " 
     1226                        "the beacon template packet. AP or IBSS operation " 
     1227                        "may be broken.\n"); 
     1228        } 
    11951229} 
    11961230 
    11971231static void b43_write_probe_resp_plcp(struct b43_wldev *dev, 
    1198                                       u16 shm_offset, u16 size, u8 rate) 
     1232                                      u16 shm_offset, u16 size, 
     1233                                      struct ieee80211_rate *rate) 
    11991234{ 
    12001235        struct b43_plcp_hdr4 plcp; 
     
    12031238 
    12041239        plcp.data = 0; 
    1205         b43_generate_plcp_hdr(&plcp, size + FCS_LEN, rate); 
     1240        b43_generate_plcp_hdr(&plcp, size + FCS_LEN, rate->hw_value); 
    12061241        dur = ieee80211_generic_frame_duration(dev->wl->hw, 
    1207                                                dev->wl->if_id, size, 
    1208                                                B43_RATE_TO_BASE100KBPS(rate)); 
     1242                                               dev->wl->vif, size, 
     1243                                               rate); 
    12091244        /* Write PLCP in two parts and timing for packet transfer */ 
    12101245        tmp = le32_to_cpu(plcp.data); 
     
    12201255 * 3) Stripping TIM 
    12211256 */ 
    1222 static u8 *b43_generate_probe_resp(struct b43_wldev *dev, 
    1223                                    u16 * dest_size, u8 rate) 
     1257static const u8 * b43_generate_probe_resp(struct b43_wldev *dev, 
     1258                                          u16 *dest_size, 
     1259                                          struct ieee80211_rate *rate) 
    12241260{ 
    12251261        const u8 *src_data; 
     
    12281264        __le16 dur; 
    12291265        struct ieee80211_hdr *hdr; 
    1230  
    1231         B43_WARN_ON(!dev->cached_beacon); 
    1232         src_size = dev->cached_beacon->len; 
    1233         src_data = (const u8 *)dev->cached_beacon->data; 
    1234  
    1235         if (unlikely(src_size < 0x24)) { 
    1236                 b43dbg(dev->wl, "b43_generate_probe_resp: " "invalid beacon\n"); 
     1266        size_t ie_start; 
     1267 
     1268        src_size = dev->wl->current_beacon->len; 
     1269        src_data = (const u8 *)dev->wl->current_beacon->data; 
     1270 
     1271        /* Get the start offset of the variable IEs in the packet. */ 
     1272        ie_start = offsetof(struct ieee80211_mgmt, u.probe_resp.variable); 
     1273        B43_WARN_ON(ie_start != offsetof(struct ieee80211_mgmt, u.beacon.variable)); 
     1274 
     1275        if (B43_WARN_ON(src_size < ie_start)) 
    12371276                return NULL; 
    1238         } 
    12391277 
    12401278        dest_data = kmalloc(src_size, GFP_ATOMIC); 
     
    12421280                return NULL; 
    12431281 
    1244         /* 0x24 is offset of first variable-len Information-Element 
    1245          * in beacon frame. 
    1246          */ 
    1247         memcpy(dest_data, src_data, 0x24); 
    1248         src_pos = dest_pos = 0x24; 
    1249         for (; src_pos < src_size - 2; src_pos += elem_size) { 
     1282        /* Copy the static data and all Information Elements, except the TIM. */ 
     1283        memcpy(dest_data, src_data, ie_start); 
     1284        src_pos = ie_start; 
     1285        dest_pos = ie_start; 
     1286        for ( ; src_pos < src_size - 2; src_pos += elem_size) { 
    12501287                elem_size = src_data[src_pos + 1] + 2; 
    1251                 if (src_data[src_pos] != 0x05) {        /* TIM */ 
    1252                         memcpy(dest_data + dest_pos, src_data + src_pos, 
    1253                                elem_size); 
    1254                         dest_pos += elem_size; 
     1288                if (src_data[src_pos] == 5) { 
     1289                        /* This is the TIM. */ 
     1290                        continue; 
    12551291                } 
     1292                memcpy(dest_data + dest_pos, src_data + src_pos, 
     1293                       elem_size); 
     1294                dest_pos += elem_size; 
    12561295        } 
    12571296        *dest_size = dest_pos; 
     
    12621301                                         IEEE80211_STYPE_PROBE_RESP); 
    12631302        dur = ieee80211_generic_frame_duration(dev->wl->hw, 
    1264                                                dev->wl->if_id, *dest_size, 
    1265                                                B43_RATE_TO_BASE100KBPS(rate)); 
     1303                                               dev->wl->vif, *dest_size, 
     1304                                               rate); 
    12661305        hdr->duration_id = dur; 
    12671306 
     
    12711310static void b43_write_probe_resp_template(struct b43_wldev *dev, 
    12721311                                          u16 ram_offset, 
    1273                                           u16 shm_size_offset, u8 rate) 
    1274 { 
    1275         u8 *probe_resp_data; 
     1312                                          u16 shm_size_offset, 
     1313                                          struct ieee80211_rate *rate) 
     1314{ 
     1315        const u8 *probe_resp_data; 
    12761316        u16 size; 
    12771317 
    1278         B43_WARN_ON(!dev->cached_beacon); 
    1279         size = dev->cached_beacon->len; 
     1318        size = dev->wl->current_beacon->len; 
    12801319        probe_resp_data = b43_generate_probe_resp(dev, &size, rate); 
    12811320        if (unlikely(!probe_resp_data)) 
     
    12851324         * all possible basic rates 
    12861325         */ 
    1287         b43_write_probe_resp_plcp(dev, 0x31A, size, B43_CCK_RATE_1MB); 
    1288         b43_write_probe_resp_plcp(dev, 0x32C, size, B43_CCK_RATE_2MB); 
    1289         b43_write_probe_resp_plcp(dev, 0x33E, size, B43_CCK_RATE_5MB); 
    1290         b43_write_probe_resp_plcp(dev, 0x350, size, B43_CCK_RATE_11MB); 
     1326        b43_write_probe_resp_plcp(dev, 0x31A, size, &b43_b_ratetable[0]); 
     1327        b43_write_probe_resp_plcp(dev, 0x32C, size, &b43_b_ratetable[1]); 
     1328        b43_write_probe_resp_plcp(dev, 0x33E, size, &b43_b_ratetable[2]); 
     1329        b43_write_probe_resp_plcp(dev, 0x350, size, &b43_b_ratetable[3]); 
    12911330 
    12921331        size = min((size_t) size, 0x200 - sizeof(struct b43_plcp_hdr6)); 
    12931332        b43_write_template_common(dev, probe_resp_data, 
    1294                                   size, ram_offset, shm_size_offset, rate); 
     1333                                  size, ram_offset, shm_size_offset, 
     1334                                  rate->hw_value); 
    12951335        kfree(probe_resp_data); 
    12961336} 
    12971337 
    1298 static int b43_refresh_cached_beacon(struct b43_wldev *dev, 
    1299                                      struct sk_buff *beacon) 
    1300 { 
    1301         if (dev->cached_beacon) 
    1302                 kfree_skb(dev->cached_beacon); 
    1303         dev->cached_beacon = beacon; 
    1304  
    1305         return 0; 
    1306 } 
    1307  
    1308 static void b43_update_templates(struct b43_wldev *dev) 
    1309 { 
    1310         u32 status; 
    1311  
    1312         B43_WARN_ON(!dev->cached_beacon); 
    1313  
    1314         b43_write_beacon_template(dev, 0x68, 0x18, B43_CCK_RATE_1MB); 
    1315         b43_write_beacon_template(dev, 0x468, 0x1A, B43_CCK_RATE_1MB); 
    1316         b43_write_probe_resp_template(dev, 0x268, 0x4A, B43_CCK_RATE_11MB); 
    1317  
    1318         status = b43_read32(dev, B43_MMIO_STATUS2_BITFIELD); 
    1319         status |= 0x03; 
    1320         b43_write32(dev, B43_MMIO_STATUS2_BITFIELD, status); 
    1321 } 
    1322  
    1323 static void b43_refresh_templates(struct b43_wldev *dev, struct sk_buff *beacon) 
    1324 { 
    1325         int err; 
    1326  
    1327         err = b43_refresh_cached_beacon(dev, beacon); 
    1328         if (unlikely(err)) 
    1329                 return; 
    1330         b43_update_templates(dev); 
     1338/* Asynchronously update the packet templates in template RAM. 
     1339 * Locking: Requires wl->irq_lock to be locked. */ 
     1340static void b43_update_templates(struct b43_wl *wl, struct sk_buff *beacon) 
     1341{ 
     1342        /* This is the top half of the ansynchronous beacon update. 
     1343         * The bottom half is the beacon IRQ. 
     1344         * Beacon update must be asynchronous to avoid sending an 
     1345         * invalid beacon. This can happen for example, if the firmware 
     1346         * transmits a beacon while we are updating it. */ 
     1347 
     1348        if (wl->current_beacon) 
     1349                dev_kfree_skb_any(wl->current_beacon); 
     1350        wl->current_beacon = beacon; 
     1351        wl->beacon0_uploaded = 0; 
     1352        wl->beacon1_uploaded = 0; 
    13311353} 
    13321354 
     
    13641386static void handle_irq_beacon(struct b43_wldev *dev) 
    13651387{ 
    1366         u32 status; 
    1367  
    1368         if (!b43_is_mode(dev->wl, IEEE80211_IF_TYPE_AP)) 
     1388        struct b43_wl *wl = dev->wl; 
     1389        u32 cmd; 
     1390 
     1391        if (!b43_is_mode(wl, IEEE80211_IF_TYPE_AP)) 
    13691392                return; 
    13701393 
    1371         dev->irq_savedstate &= ~B43_IRQ_BEACON; 
    1372         status = b43_read32(dev, B43_MMIO_STATUS2_BITFIELD); 
    1373  
    1374         if (!dev->cached_beacon || ((status & 0x1) && (status & 0x2))) { 
    1375                 /* ACK beacon IRQ. */ 
    1376                 b43_write32(dev, B43_MMIO_GEN_IRQ_REASON, B43_IRQ_BEACON); 
    1377                 dev->irq_savedstate |= B43_IRQ_BEACON; 
    1378                 if (dev->cached_beacon) 
    1379                         kfree_skb(dev->cached_beacon); 
    1380                 dev->cached_beacon = NULL; 
    1381                 return; 
    1382         } 
    1383         if (!(status & 0x1)) { 
    1384                 b43_write_beacon_template(dev, 0x68, 0x18, B43_CCK_RATE_1MB); 
    1385                 status |= 0x1; 
    1386                 b43_write32(dev, B43_MMIO_STATUS2_BITFIELD, status); 
    1387         } 
    1388         if (!(status & 0x2)) { 
    1389                 b43_write_beacon_template(dev, 0x468, 0x1A, B43_CCK_RATE_1MB); 
    1390                 status |= 0x2; 
    1391                 b43_write32(dev, B43_MMIO_STATUS2_BITFIELD, status); 
    1392         } 
     1394        /* This is the bottom half of the asynchronous beacon update. */ 
     1395 
     1396        cmd = b43_read32(dev, B43_MMIO_MACCMD); 
     1397        if (!(cmd & B43_MACCMD_BEACON0_VALID)) { 
     1398                if (!wl->beacon0_uploaded) { 
     1399                        b43_write_beacon_template(dev, 0x68, 0x18, 
     1400                                                  B43_CCK_RATE_1MB); 
     1401                        b43_write_probe_resp_template(dev, 0x268, 0x4A, 
     1402                                                      &__b43_ratetable[3]); 
     1403                        wl->beacon0_uploaded = 1; 
     1404                } 
     1405                cmd |= B43_MACCMD_BEACON0_VALID; 
     1406        } 
     1407        if (!(cmd & B43_MACCMD_BEACON1_VALID)) { 
     1408                if (!wl->beacon1_uploaded) { 
     1409                        b43_write_beacon_template(dev, 0x468, 0x1A, 
     1410                                                  B43_CCK_RATE_1MB); 
     1411                        wl->beacon1_uploaded = 1; 
     1412                } 
     1413                cmd |= B43_MACCMD_BEACON1_VALID; 
     1414        } 
     1415        b43_write32(dev, B43_MMIO_MACCMD, cmd); 
    13931416} 
    13941417 
     
    14201443                b43err(dev->wl, "MAC transmission error\n"); 
    14211444 
    1422         if (unlikely(reason & B43_IRQ_PHY_TXERR)) 
     1445        if (unlikely(reason & B43_IRQ_PHY_TXERR)) { 
    14231446                b43err(dev->wl, "PHY transmission error\n"); 
     1447                rmb(); 
     1448                if (unlikely(atomic_dec_and_test(&dev->phy.txerr_cnt))) { 
     1449                        atomic_set(&dev->phy.txerr_cnt, 
     1450                                   B43_PHY_TX_BADNESS_LIMIT); 
     1451                        b43err(dev->wl, "Too many PHY TX errors, " 
     1452                                        "restarting the controller\n"); 
     1453                        b43_controller_restart(dev, "PHY TX errors"); 
     1454                } 
     1455        } 
    14241456 
    14251457        if (unlikely(merged_dma_reason & (B43_DMAIRQ_FATALMASK | 
     
    14631495 
    14641496        /* Check the DMA reason registers for received data. */ 
    1465         if (dma_reason[0] & B43_DMAIRQ_RX_DONE) { 
    1466                 if (b43_using_pio(dev)) 
    1467                         b43_pio_rx(dev->pio.queue0); 
    1468                 else 
    1469                         b43_dma_rx(dev->dma.rx_ring0); 
    1470         } 
     1497        if (dma_reason[0] & B43_DMAIRQ_RX_DONE) 
     1498                b43_dma_rx(dev->dma.rx_ring0); 
     1499        if (dma_reason[3] & B43_DMAIRQ_RX_DONE) 
     1500                b43_dma_rx(dev->dma.rx_ring3); 
    14711501        B43_WARN_ON(dma_reason[1] & B43_DMAIRQ_RX_DONE); 
    14721502        B43_WARN_ON(dma_reason[2] & B43_DMAIRQ_RX_DONE); 
    1473         if (dma_reason[3] & B43_DMAIRQ_RX_DONE) { 
    1474                 if (b43_using_pio(dev)) 
    1475                         b43_pio_rx(dev->pio.queue3); 
    1476                 else 
    1477                         b43_dma_rx(dev->dma.rx_ring3); 
    1478         } 
    14791503        B43_WARN_ON(dma_reason[4] & B43_DMAIRQ_RX_DONE); 
    14801504        B43_WARN_ON(dma_reason[5] & B43_DMAIRQ_RX_DONE); 
     
    14881512} 
    14891513 
    1490 static void pio_irq_workaround(struct b43_wldev *dev, u16 base, int queueidx) 
    1491 { 
    1492         u16 rxctl; 
    1493  
    1494         rxctl = b43_read16(dev, base + B43_PIO_RXCTL); 
    1495         if (rxctl & B43_PIO_RXCTL_DATAAVAILABLE) 
    1496                 dev->dma_reason[queueidx] |= B43_DMAIRQ_RX_DONE; 
    1497         else 
    1498                 dev->dma_reason[queueidx] &= ~B43_DMAIRQ_RX_DONE; 
    1499 } 
    1500  
    15011514static void b43_interrupt_ack(struct b43_wldev *dev, u32 reason) 
    15021515{ 
    1503         if (b43_using_pio(dev) && 
    1504             (dev->dev->id.revision < 3) && 
    1505             (!(reason & B43_IRQ_PIO_WORKAROUND))) { 
    1506                 /* Apply a PIO specific workaround to the dma_reasons */ 
    1507                 pio_irq_workaround(dev, B43_MMIO_PIO1_BASE, 0); 
    1508                 pio_irq_workaround(dev, B43_MMIO_PIO2_BASE, 1); 
    1509                 pio_irq_workaround(dev, B43_MMIO_PIO3_BASE, 2); 
    1510                 pio_irq_workaround(dev, B43_MMIO_PIO4_BASE, 3); 
    1511         } 
    1512  
    15131516        b43_write32(dev, B43_MMIO_GEN_IRQ_REASON, reason); 
    15141517 
     
    15691572} 
    15701573 
     1574static void do_release_fw(struct b43_firmware_file *fw) 
     1575{ 
     1576        release_firmware(fw->data); 
     1577        fw->data = NULL; 
     1578        fw->filename = NULL; 
     1579} 
     1580 
    15711581static void b43_release_firmware(struct b43_wldev *dev) 
    15721582{ 
    1573         release_firmware(dev->fw.ucode); 
    1574         dev->fw.ucode = NULL; 
    1575         release_firmware(dev->fw.pcm); 
    1576         dev->fw.pcm = NULL; 
    1577         release_firmware(dev->fw.initvals); 
    1578         dev->fw.initvals = NULL; 
    1579         release_firmware(dev->fw.initvals_band); 
    1580         dev->fw.initvals_band = NULL; 
    1581 } 
    1582  
    1583 static void b43_print_fw_helptext(struct b43_wl *wl) 
    1584 { 
    1585         b43err(wl, "You must go to " 
    1586                "http://linuxwireless.org/en/users/Drivers/bcm43xx#devicefirmware " 
    1587                "and download the correct firmware (version 4).\n"); 
     1583        do_release_fw(&dev->fw.ucode); 
     1584        do_release_fw(&dev->fw.pcm); 
     1585        do_release_fw(&dev->fw.initvals); 
     1586        do_release_fw(&dev->fw.initvals_band); 
     1587} 
     1588 
     1589static void b43_print_fw_helptext(struct b43_wl *wl, bool error) 
     1590{ 
     1591        const char *text; 
     1592 
     1593        text = "You must go to " 
     1594               "http://linuxwireless.org/en/users/Drivers/b43#devicefirmware " 
     1595               "and download the latest firmware (version 4).\n"; 
     1596        if (error) 
     1597                b43err(wl, text); 
     1598        else 
     1599                b43warn(wl, text); 
    15881600} 
    15891601 
    15901602static int do_request_fw(struct b43_wldev *dev, 
    15911603                         const char *name, 
    1592                          const struct firmware **fw) 
     1604                         struct b43_firmware_file *fw) 
    15931605{ 
    15941606        char path[sizeof(modparam_fwpostfix) + 32]; 
     1607        const struct firmware *blob; 
    15951608        struct b43_fw_header *hdr; 
    15961609        u32 size; 
    15971610        int err; 
    15981611 
    1599         if (!name) 
     1612        if (!name) { 
     1613                /* Don't fetch anything. Free possibly cached firmware. */ 
     1614                do_release_fw(fw); 
    16001615                return 0; 
     1616        } 
     1617        if (fw->filename) { 
     1618                if (strcmp(fw->filename, name) == 0) 
     1619                        return 0; /* Already have this fw. */ 
     1620                /* Free the cached firmware first. */ 
     1621                do_release_fw(fw); 
     1622        } 
    16011623 
    16021624        snprintf(path, ARRAY_SIZE(path), 
    16031625                 "b43%s/%s.fw", 
    16041626                 modparam_fwpostfix, name); 
    1605         err = request_firmware(fw, path, dev->dev->dev); 
     1627        err = request_firmware(&blob, path, dev->dev->dev); 
    16061628        if (err) { 
    16071629                b43err(dev->wl, "Firmware file \"%s\" not found " 
     
    16091631                return err; 
    16101632        } 
    1611         if ((*fw)->size < sizeof(struct b43_fw_header)) 
     1633        if (blob->size < sizeof(struct b43_fw_header)) 
    16121634                goto err_format; 
    1613         hdr = (struct b43_fw_header *)((*fw)->data); 
     1635        hdr = (struct b43_fw_header *)(blob->data); 
    16141636        switch (hdr->type) { 
    16151637        case B43_FW_TYPE_UCODE: 
    16161638        case B43_FW_TYPE_PCM: 
    16171639                size = be32_to_cpu(hdr->size); 
    1618                 if (size != (*fw)->size - sizeof(struct b43_fw_header)) 
     1640                if (size != blob->size - sizeof(struct b43_fw_header)) 
    16191641                        goto err_format; 
    16201642                /* fallthrough */ 
     
    16271649        } 
    16281650 
    1629         return err; 
     1651        fw->data = blob; 
     1652        fw->filename = name; 
     1653 
     1654        return 0; 
    16301655 
    16311656err_format: 
    16321657        b43err(dev->wl, "Firmware file \"%s\" format error.\n", path); 
     1658        release_firmware(blob); 
     1659 
    16331660        return -EPROTO; 
    16341661} 
     
    16421669        int err; 
    16431670 
     1671        /* Get microcode */ 
    16441672        tmshigh = ssb_read32(dev->dev, SSB_TMSHIGH); 
    1645         if (!fw->ucode) { 
     1673        if ((rev >= 5) && (rev <= 10)) 
     1674                filename = "ucode5"; 
     1675        else if ((rev >= 11) && (rev <= 12)) 
     1676                filename = "ucode11"; 
     1677        else if (rev >= 13) 
     1678                filename = "ucode13"; 
     1679        else 
     1680                goto err_no_ucode; 
     1681        err = do_request_fw(dev, filename, &fw->ucode); 
     1682        if (err) 
     1683                goto err_load; 
     1684 
     1685        /* Get PCM code */ 
     1686        if ((rev >= 5) && (rev <= 10)) 
     1687                filename = "pcm5"; 
     1688        else if (rev >= 11) 
     1689                filename = NULL; 
     1690        else 
     1691                goto err_no_pcm; 
     1692        err = do_request_fw(dev, filename, &fw->pcm); 
     1693        if (err) 
     1694                goto err_load; 
     1695 
     1696        /* Get initvals */ 
     1697        switch (dev->phy.type) { 
     1698        case B43_PHYTYPE_A: 
     1699                if ((rev >= 5) && (rev <= 10)) { 
     1700                        if (tmshigh & B43_TMSHIGH_HAVE_2GHZ_PHY) 
     1701                                filename = "a0g1initvals5"; 
     1702                        else 
     1703                                filename = "a0g0initvals5"; 
     1704                } else 
     1705                        goto err_no_initvals; 
     1706                break; 
     1707        case B43_PHYTYPE_G: 
    16461708                if ((rev >= 5) && (rev <= 10)) 
    1647                         filename = "ucode5"; 
    1648                 else if ((rev >= 11) && (rev <= 12)) 
    1649                         filename = "ucode11"; 
     1709                        filename = "b0g0initvals5"; 
    16501710                else if (rev >= 13) 
    1651                         filename = "ucode13"; 
     1711                        filename = "lp0initvals13"; 
    16521712                else 
    1653                         goto err_no_ucode; 
    1654                 err = do_request_fw(dev, filename, &fw->ucode); 
    1655                 if (err) 
    1656                         goto err_load; 
    1657         } 
    1658         if (!fw->pcm) { 
     1713                        goto err_no_initvals; 
     1714                break; 
     1715        case B43_PHYTYPE_N: 
     1716                if ((rev >= 11) && (rev <= 12)) 
     1717                        filename = "n0initvals11"; 
     1718                else 
     1719                        goto err_no_initvals; 
     1720                break; 
     1721        default: 
     1722                goto err_no_initvals; 
     1723        } 
     1724        err = do_request_fw(dev, filename, &fw->initvals); 
     1725        if (err) 
     1726                goto err_load; 
     1727 
     1728        /* Get bandswitch initvals */ 
     1729        switch (dev->phy.type) { 
     1730        case B43_PHYTYPE_A: 
     1731                if ((rev >= 5) && (rev <= 10)) { 
     1732                        if (tmshigh & B43_TMSHIGH_HAVE_2GHZ_PHY) 
     1733                                filename = "a0g1bsinitvals5"; 
     1734                        else 
     1735                                filename = "a0g0bsinitvals5"; 
     1736                } else if (rev >= 11) 
     1737                        filename = NULL; 
     1738                else 
     1739                        goto err_no_initvals; 
     1740                break; 
     1741        case B43_PHYTYPE_G: 
    16591742                if ((rev >= 5) && (rev <= 10)) 
    1660                         filename = "pcm5"; 
     1743                        filename = "b0g0bsinitvals5"; 
    16611744                else if (rev >= 11) 
    16621745                        filename = NULL; 
    16631746                else 
    1664                         goto err_no_pcm; 
    1665                 err = do_request_fw(dev, filename, &fw->pcm); 
    1666                 if (err) 
    1667                         goto err_load; 
    1668         } 
    1669         if (!fw->initvals) { 
    1670                 switch (dev->phy.type) { 
    1671                 case B43_PHYTYPE_A: 
    1672                         if ((rev >= 5) && (rev <= 10)) { 
    1673                                 if (tmshigh & B43_TMSHIGH_GPHY) 
    1674                                         filename = "a0g1initvals5"; 
    1675                                 else 
    1676                                         filename = "a0g0initvals5"; 
    1677                         } else 
    1678                                 goto err_no_initvals; 
    1679                         break; 
    1680                 case B43_PHYTYPE_G: 
    1681                         if ((rev >= 5) && (rev <= 10)) 
    1682                                 filename = "b0g0initvals5"; 
    1683                         else if (rev >= 13) 
    1684                                 filename = "lp0initvals13"; 
    1685                         else 
    1686                                 goto err_no_initvals; 
    1687                         break; 
    1688                 default: 
    16891747                        goto err_no_initvals; 
    1690                 } 
    1691                 err = do_request_fw(dev, filename, &fw->initvals); 
    1692                 if (err) 
    1693                         goto err_load; 
    1694         } 
    1695         if (!fw->initvals_band) { 
    1696                 switch (dev->phy.type) { 
    1697                 case B43_PHYTYPE_A: 
    1698                         if ((rev >= 5) && (rev <= 10)) { 
    1699                                 if (tmshigh & B43_TMSHIGH_GPHY) 
    1700                                         filename = "a0g1bsinitvals5"; 
    1701                                 else 
    1702                                         filename = "a0g0bsinitvals5"; 
    1703                         } else if (rev >= 11) 
    1704                                 filename = NULL; 
    1705                         else 
    1706                                 goto err_no_initvals; 
    1707                         break; 
    1708                 case B43_PHYTYPE_G: 
    1709                         if ((rev >= 5) && (rev <= 10)) 
    1710                                 filename = "b0g0bsinitvals5"; 
    1711                         else if (rev >= 11) 
    1712                                 filename = NULL; 
    1713                         else 
    1714                                 goto err_no_initvals; 
    1715                         break; 
    1716                 default: 
     1748                break; 
     1749        case B43_PHYTYPE_N: 
     1750                if ((rev >= 11) && (rev <= 12)) 
     1751                        filename = "n0bsinitvals11"; 
     1752                else 
    17171753                        goto err_no_initvals; 
    1718                 } 
    1719                 err = do_request_fw(dev, filename, &fw->initvals_band); 
    1720                 if (err) 
    1721                         goto err_load; 
    1722         } 
     1754                break; 
     1755        default: 
     1756                goto err_no_initvals; 
     1757        } 
     1758        err = do_request_fw(dev, filename, &fw->initvals_band); 
     1759        if (err) 
     1760                goto err_load; 
    17231761 
    17241762        return 0; 
    17251763 
    17261764err_load: 
    1727         b43_print_fw_helptext(dev->wl); 
     1765        b43_print_fw_helptext(dev->wl, 1); 
    17281766        goto error; 
    17291767 
     
    17551793        unsigned int i, len; 
    17561794        u16 fwrev, fwpatch, fwdate, fwtime; 
    1757         u32 tmp; 
     1795        u32 tmp, macctl; 
    17581796        int err = 0; 
    17591797 
     1798        /* Jump the microcode PSM to offset 0 */ 
     1799        macctl = b43_read32(dev, B43_MMIO_MACCTL); 
     1800        B43_WARN_ON(macctl & B43_MACCTL_PSM_RUN); 
     1801        macctl |= B43_MACCTL_PSM_JMP0; 
     1802        b43_write32(dev, B43_MMIO_MACCTL, macctl); 
     1803        /* Zero out all microcode PSM registers and shared memory. */ 
     1804        for (i = 0; i < 64; i++) 
     1805                b43_shm_write16(dev, B43_SHM_SCRATCH, i, 0); 
     1806        for (i = 0; i < 4096; i += 2) 
     1807                b43_shm_write16(dev, B43_SHM_SHARED, i, 0); 
     1808 
    17601809        /* Upload Microcode. */ 
    1761         data = (__be32 *) (dev->fw.ucode->data + hdr_len); 
    1762         len = (dev->fw.ucode->size - hdr_len) / sizeof(__be32); 
     1810        data = (__be32 *) (dev->fw.ucode.data->data + hdr_len); 
     1811        len = (dev->fw.ucode.data->size - hdr_len) / sizeof(__be32); 
    17631812        b43_shm_control_word(dev, B43_SHM_UCODE | B43_SHM_AUTOINC_W, 0x0000); 
    17641813        for (i = 0; i < len; i++) { 
     
    17671816        } 
    17681817 
    1769         if (dev->fw.pcm) { 
     1818        if (dev->fw.pcm.data) { 
    17701819                /* Upload PCM data. */ 
    1771                 data = (__be32 *) (dev->fw.pcm->data + hdr_len); 
    1772                 len = (dev->fw.pcm->size - hdr_len) / sizeof(__be32); 
     1820                data = (__be32 *) (dev->fw.pcm.data->data + hdr_len); 
     1821                len = (dev->fw.pcm.data->size - hdr_len) / sizeof(__be32); 
    17731822                b43_shm_control_word(dev, B43_SHM_HW, 0x01EA); 
    17741823                b43_write32(dev, B43_MMIO_SHM_DATA, 0x00004000); 
     
    17821831 
    17831832        b43_write32(dev, B43_MMIO_GEN_IRQ_REASON, B43_IRQ_ALL); 
    1784         b43_write32(dev, B43_MMIO_MACCTL, 
    1785                     B43_MACCTL_PSM_RUN | 
    1786                     B43_MACCTL_IHR_ENABLED | B43_MACCTL_INFRA); 
     1833 
     1834        /* Start the microcode PSM */ 
     1835        macctl = b43_read32(dev, B43_MMIO_MACCTL); 
     1836        macctl &= ~B43_MACCTL_PSM_JMP0; 
     1837        macctl |= B43_MACCTL_PSM_RUN; 
     1838        b43_write32(dev, B43_MMIO_MACCTL, macctl); 
    17871839 
    17881840        /* Wait for the microcode to load and respond */ 
     
    17931845                        break; 
    17941846                i++; 
    1795                 if (i >= 50) { 
     1847                if (i >= 20) { 
    17961848                        b43err(dev->wl, "Microcode not responding\n"); 
    1797                         b43_print_fw_helptext(dev->wl); 
     1849                        b43_print_fw_helptext(dev->wl, 1); 
    17981850                        err = -ENODEV; 
    1799                         goto out; 
     1851                        goto error; 
    18001852                } 
    1801                 udelay(10); 
     1853                msleep_interruptible(50); 
     1854                if (signal_pending(current)) { 
     1855                        err = -EINTR; 
     1856                        goto error; 
     1857                } 
    18021858        } 
    18031859        b43_read32(dev, B43_MMIO_GEN_IRQ_REASON);       /* dummy read */ 
     
    18131869                       "binary drivers older than version 4.x is unsupported. " 
    18141870                       "You must upgrade your firmware files.\n"); 
    1815                 b43_print_fw_helptext(dev->wl); 
    1816                 b43_write32(dev, B43_MMIO_MACCTL, 0); 
     1871                b43_print_fw_helptext(dev->wl, 1); 
    18171872                err = -EOPNOTSUPP; 
    1818                 goto out; 
     1873                goto error; 
    18191874        } 
    18201875        b43dbg(dev->wl, "Loading firmware version %u.%u " 
     
    18271882        dev->fw.patch = fwpatch; 
    18281883 
    1829       out: 
     1884        if (b43_is_old_txhdr_format(dev)) { 
     1885                b43warn(dev->wl, "You are using an old firmware image. " 
     1886                        "Support for old firmware will be removed in July 2008.\n"); 
     1887                b43_print_fw_helptext(dev->wl, 0); 
     1888        } 
     1889 
     1890        return 0; 
     1891 
     1892error: 
     1893        macctl = b43_read32(dev, B43_MMIO_MACCTL); 
     1894        macctl &= ~B43_MACCTL_PSM_RUN; 
     1895        macctl |= B43_MACCTL_PSM_JMP0; 
     1896        b43_write32(dev, B43_MMIO_MACCTL, macctl); 
     1897 
    18301898        return err; 
    18311899} 
     
    18871955err_format: 
    18881956        b43err(dev->wl, "Initial Values Firmware file-format error.\n"); 
    1889         b43_print_fw_helptext(dev->wl); 
     1957        b43_print_fw_helptext(dev->wl, 1); 
    18901958 
    18911959        return -EPROTO; 
     
    19011969        int err; 
    19021970 
    1903         hdr = (const struct b43_fw_header *)(fw->initvals->data); 
    1904         ivals = (const struct b43_iv *)(fw->initvals->data + hdr_len); 
     1971        hdr = (const struct b43_fw_header *)(fw->initvals.data->data); 
     1972        ivals = (const struct b43_iv *)(fw->initvals.data->data + hdr_len); 
    19051973        count = be32_to_cpu(hdr->size); 
    19061974        err = b43_write_initvals(dev, ivals, count, 
    1907                                  fw->initvals->size - hdr_len); 
     1975                                 fw->initvals.data->size - hdr_len); 
    19081976        if (err) 
    19091977                goto out; 
    1910         if (fw->initvals_band) { 
    1911                 hdr = (const struct b43_fw_header *)(fw->initvals_band->data); 
    1912                 ivals = (const struct b43_iv *)(fw->initvals_band->data + hdr_len); 
     1978        if (fw->initvals_band.data) { 
     1979                hdr = (const struct b43_fw_header *)(fw->initvals_band.data->data); 
     1980                ivals = (const struct b43_iv *)(fw->initvals_band.data->data + hdr_len); 
    19131981                count = be32_to_cpu(hdr->size); 
    19141982                err = b43_write_initvals(dev, ivals, count, 
    1915                                          fw->initvals_band->size - hdr_len); 
     1983                                         fw->initvals_band.data->size - hdr_len); 
    19161984                if (err) 
    19171985                        goto out; 
     
    19502018                set |= 0x0180; 
    19512019        } 
    1952         if (dev->dev->bus->sprom.r1.boardflags_lo & B43_BFL_PACTRL) { 
     2020        if (dev->dev->bus->sprom.boardflags_lo & B43_BFL_PACTRL) { 
    19532021                b43_write16(dev, B43_MMIO_GPIO_MASK, 
    19542022                            b43_read16(dev, B43_MMIO_GPIO_MASK) 
     
    21202188        case B43_PHYTYPE_A: 
    21212189        case B43_PHYTYPE_G: 
     2190        case B43_PHYTYPE_N: 
    21222191                b43_rate_memory_write(dev, B43_OFDM_RATE_6MB, 1); 
    21232192                b43_rate_memory_write(dev, B43_OFDM_RATE_12MB, 1); 
     
    21492218        switch (antenna) { 
    21502219        case B43_ANTENNA0: 
    2151                 ant |= B43_TX4_PHY_ANT0; 
     2220                ant |= B43_TXH_PHY_ANT0; 
    21522221                break; 
    21532222        case B43_ANTENNA1: 
    2154                 ant |= B43_TX4_PHY_ANT1; 
     2223                ant |= B43_TXH_PHY_ANT1; 
     2224                break; 
     2225        case B43_ANTENNA2: 
     2226                ant |= B43_TXH_PHY_ANT2; 
     2227                break; 
     2228        case B43_ANTENNA3: 
     2229                ant |= B43_TXH_PHY_ANT3; 
    21552230                break; 
    21562231        case B43_ANTENNA_AUTO: 
    2157                 ant |= B43_TX4_PHY_ANTLAST; 
     2232                ant |= B43_TXH_PHY_ANT01AUTO; 
    21582233                break; 
    21592234        default: 
     
    21652240        /* For Beacons */ 
    21662241        tmp = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_BEACPHYCTL); 
    2167         tmp = (tmp & ~B43_TX4_PHY_ANT) | ant; 
     2242        tmp = (tmp & ~B43_TXH_PHY_ANT) | ant; 
    21682243        b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_BEACPHYCTL, tmp); 
    21692244        /* For ACK/CTS */ 
    21702245        tmp = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_ACKCTSPHYCTL); 
    2171         tmp = (tmp & ~B43_TX4_PHY_ANT) | ant; 
     2246        tmp = (tmp & ~B43_TXH_PHY_ANT) | ant; 
    21722247        b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_ACKCTSPHYCTL, tmp); 
    21732248        /* For Probe Resposes */ 
    21742249        tmp = b43_shm_read16(dev, B43_SHM_SHARED, B43_SHM_SH_PRPHYCTL); 
    2175         tmp = (tmp & ~B43_TX4_PHY_ANT) | ant; 
     2250        tmp = (tmp & ~B43_TXH_PHY_ANT) | ant; 
    21762251        b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_PRPHYCTL, tmp); 
    21772252} 
     
    21812256{ 
    21822257        b43_radio_turn_off(dev, 1); 
    2183         b43_leds_exit(dev); 
    21842258        b43_gpio_cleanup(dev); 
    21852259        /* firmware is released later */ 
     
    21932267        struct b43_phy *phy = &dev->phy; 
    21942268        int err, tmp; 
    2195         u32 value32; 
     2269        u32 value32, macctl; 
    21962270        u16 value16; 
    21972271 
    2198         b43_write32(dev, B43_MMIO_MACCTL, 
    2199                     B43_MACCTL_PSM_JMP0 | B43_MACCTL_IHR_ENABLED); 
     2272        /* Initialize the MAC control */ 
     2273        macctl = B43_MACCTL_IHR_ENABLED | B43_MACCTL_SHM_ENABLED; 
     2274        if (dev->phy.gmode) 
     2275                macctl |= B43_MACCTL_GMODE; 
     2276        macctl |= B43_MACCTL_INFRA; 
     2277        b43_write32(dev, B43_MMIO_MACCTL, macctl); 
    22002278 
    22012279        err = b43_request_firmware(dev); 
     
    22092287        if (err) 
    22102288                goto out;       /* firmware is released later */ 
    2211         b43_leds_init(dev); 
    22122289 
    22132290        err = b43_upload_initvals(dev); 
    22142291        if (err) 
    2215                 goto err_leds_exit; 
     2292                goto err_gpio_clean; 
    22162293        b43_radio_turn_on(dev); 
    22172294 
     
    22422319        b43_write32(dev, B43_MMIO_MACCTL, b43_read32(dev, B43_MMIO_MACCTL) 
    22432320                    | B43_MACCTL_INFRA); 
    2244  
    2245         if (b43_using_pio(dev)) { 
    2246                 b43_write32(dev, 0x0210, 0x00000100); 
    2247                 b43_write32(dev, 0x0230, 0x00000100); 
    2248                 b43_write32(dev, 0x0250, 0x00000100); 
    2249                 b43_write32(dev, 0x0270, 0x00000100); 
    2250                 b43_shm_write16(dev, B43_SHM_SHARED, 0x0034, 0x0000); 
    2251         } 
    22522321 
    22532322        /* Probe Response Timeout value */ 
     
    22892358err_radio_off: 
    22902359        b43_radio_turn_off(dev, 1); 
    2291 err_leds_exit: 
    2292         b43_leds_exit(dev); 
     2360err_gpio_clean: 
    22932361        b43_gpio_cleanup(dev); 
    22942362        return err; 
     
    23132381        struct b43_phy *phy = &dev->phy; 
    23142382 
     2383        if (phy->type != B43_PHYTYPE_G) 
     2384                return; 
    23152385        if (!b43_has_hardware_pctl(phy)) 
    23162386                b43_lo_g_ctl_mark_all_unused(dev); 
    2317         if (dev->dev->bus->sprom.r1.boardflags_lo & B43_BFL_RSSI) { 
     2387        if (dev->dev->bus->sprom.boardflags_lo & B43_BFL_RSSI) { 
    23182388                b43_mac_suspend(dev); 
    23192389                b43_calc_nrssi_slope(dev); 
     
    23672437        b43_phy_xmitpower(dev); //FIXME: unless scanning? 
    23682438        //TODO for APHY (temperature?) 
     2439 
     2440        atomic_set(&phy->txerr_cnt, B43_PHY_TX_BADNESS_LIMIT); 
     2441        wmb(); 
    23692442} 
    23702443 
     
    24242497} 
    24252498 
    2426 /* Validate access to the chip (SHM) */ 
     2499/* Check if communication with the device works correctly. */ 
    24272500static int b43_validate_chipaccess(struct b43_wldev *dev) 
    24282501{ 
    2429         u32 value; 
    2430         u32 shm_backup; 
    2431  
    2432         shm_backup = b43_shm_read32(dev, B43_SHM_SHARED, 0); 
     2502        u32 v, backup; 
     2503 
     2504        backup = b43_shm_read32(dev, B43_SHM_SHARED, 0); 
     2505 
     2506        /* Check for read/write and endianness problems. */ 
     2507        b43_shm_write32(dev, B43_SHM_SHARED, 0, 0x55AAAA55); 
     2508        if (b43_shm_read32(dev, B43_SHM_SHARED, 0) != 0x55AAAA55) 
     2509                goto error; 
    24332510        b43_shm_write32(dev, B43_SHM_SHARED, 0, 0xAA5555AA); 
    24342511        if (b43_shm_read32(dev, B43_SHM_SHARED, 0) != 0xAA5555AA) 
    24352512                goto error; 
    2436         b43_shm_write32(dev, B43_SHM_SHARED, 0, 0x55AAAA55); 
    2437         if (b43_shm_read32(dev, B43_SHM_SHARED, 0) != 0x55AAAA55) 
     2513 
     2514        b43_shm_write32(dev, B43_SHM_SHARED, 0, backup); 
     2515 
     2516        if ((dev->dev->id.revision >= 3) && (dev->dev->id.revision <= 10)) { 
     2517                /* The 32bit register shadows the two 16bit registers 
     2518                 * with update sideeffects. Validate this. */ 
     2519                b43_write16(dev, B43_MMIO_TSF_CFP_START, 0xAAAA); 
     2520                b43_write32(dev, B43_MMIO_TSF_CFP_START, 0xCCCCBBBB); 
     2521                if (b43_read16(dev, B43_MMIO_TSF_CFP_START_LOW) != 0xBBBB) 
     2522                        goto error; 
     2523                if (b43_read16(dev, B43_MMIO_TSF_CFP_START_HIGH) != 0xCCCC) 
     2524                        goto error; 
     2525        } 
     2526        b43_write32(dev, B43_MMIO_TSF_CFP_START, 0); 
     2527 
     2528        v = b43_read32(dev, B43_MMIO_MACCTL); 
     2529        v |= B43_MACCTL_GMODE; 
     2530        if (v != (B43_MACCTL_GMODE | B43_MACCTL_IHR_ENABLED)) 
    24382531                goto error; 
    2439         b43_shm_write32(dev, B43_SHM_SHARED, 0, shm_backup); 
    2440  
    2441         value = b43_read32(dev, B43_MMIO_MACCTL); 
    2442         if ((value | B43_MACCTL_GMODE) != 
    2443             (B43_MACCTL_GMODE | B43_MACCTL_IHR_ENABLED)) 
    2444                 goto error; 
    2445  
    2446         value = b43_read32(dev, B43_MMIO_GEN_IRQ_REASON); 
    2447         if (value) 
    2448                 goto error; 
    24492532 
    24502533        return 0; 
    2451       error: 
     2534error: 
    24522535        b43err(dev->wl, "Failed to validate the chipaccess\n"); 
    24532536        return -ENODEV; 
     
    25122595} 
    25132596 
    2514 static int b43_tx(struct ieee80211_hw *hw, 
    2515                   struct sk_buff *skb, struct ieee80211_tx_control *ctl) 
     2597static int b43_op_tx(struct ieee80211_hw *hw, 
     2598                     struct sk_buff *skb, 
     2599                     struct ieee80211_tx_control *ctl) 
    25162600{ 
    25172601        struct b43_wl *wl = hw_to_b43_wl(hw); 
    25182602        struct b43_wldev *dev = wl->current_dev; 
    25192603        int err = -ENODEV; 
    2520         unsigned long flags; 
    25212604 
    25222605        if (unlikely(!dev)) 
     
    25252608                goto out; 
    25262609        /* DMA-TX is done without a global lock. */ 
    2527         if (b43_using_pio(dev)) { 
    2528                 spin_lock_irqsave(&wl->irq_lock, flags); 
    2529                 err = b43_pio_tx(dev, skb, ctl); 
    2530                 spin_unlock_irqrestore(&wl->irq_lock, flags); 
    2531         } else 
    2532                 err = b43_dma_tx(dev, skb, ctl); 
    2533       out: 
     2610        err = b43_dma_tx(dev, skb, ctl); 
     2611out: 
    25342612        if (unlikely(err)) 
    25352613                return NETDEV_TX_BUSY; 
     
    25372615} 
    25382616 
    2539 static int b43_conf_tx(struct ieee80211_hw *hw, 
    2540                        int queue, 
    2541                        const struct ieee80211_tx_queue_params *params) 
     2617static int b43_op_conf_tx(struct ieee80211_hw *hw, 
     2618                          int queue, 
     2619                          const struct ieee80211_tx_queue_params *params) 
    25422620{ 
    25432621        return 0; 
    25442622} 
    25452623 
    2546 static int b43_get_tx_stats(struct ieee80211_hw *hw, 
    2547                             struct ieee80211_tx_queue_stats *stats) 
     2624static int b43_op_get_tx_stats(struct ieee80211_hw *hw, 
     2625                               struct ieee80211_tx_queue_stats *stats) 
    25482626{ 
    25492627        struct b43_wl *wl = hw_to_b43_wl(hw); 
     
    25562634        spin_lock_irqsave(&wl->irq_lock, flags); 
    25572635        if (likely(b43_status(dev) >= B43_STAT_STARTED)) { 
    2558                 if (b43_using_pio(dev)) 
    2559                         b43_pio_get_tx_stats(dev, stats); 
    2560                 else 
    2561                         b43_dma_get_tx_stats(dev, stats); 
     2636                b43_dma_get_tx_stats(dev, stats); 
    25622637                err = 0; 
    25632638        } 
    25642639        spin_unlock_irqrestore(&wl->irq_lock, flags); 
    2565       out: 
     2640out: 
    25662641        return err; 
    25672642} 
    25682643 
    2569 static int b43_get_stats(struct ieee80211_hw *hw, 
    2570                          struct ieee80211_low_level_stats *stats) 
     2644static int b43_op_get_stats(struct ieee80211_hw *hw, 
     2645                            struct ieee80211_low_level_stats *stats) 
    25712646{ 
    25722647        struct b43_wl *wl = hw_to_b43_wl(hw); 
     
    27072782} 
    27082783 
    2709 static int b43_antenna_from_ieee80211(u8 antenna) 
    2710 { 
     2784/* Check if the use of the antenna that ieee80211 told us to 
     2785 * use is possible. This will fall back to DEFAULT. 
     2786 * "antenna_nr" is the antenna identifier we got from ieee80211. */ 
     2787u8 b43_ieee80211_antenna_sanitize(struct b43_wldev *dev, 
     2788                                  u8 antenna_nr) 
     2789{ 
     2790        u8 antenna_mask; 
     2791 
     2792        if (antenna_nr == 0) { 
     2793                /* Zero means "use default antenna". That's always OK. */ 
     2794                return 0; 
     2795        } 
     2796 
     2797        /* Get the mask of available antennas. */ 
     2798        if (dev->phy.gmode) 
     2799                antenna_mask = dev->dev->bus->sprom.ant_available_bg; 
     2800        else 
     2801                antenna_mask = dev->dev->bus->sprom.ant_available_a; 
     2802 
     2803        if (!(antenna_mask & (1 << (antenna_nr - 1)))) { 
     2804                /* This antenna is not available. Fall back to default. */ 
     2805                return 0; 
     2806        } 
     2807 
     2808        return antenna_nr; 
     2809} 
     2810 
     2811static int b43_antenna_from_ieee80211(struct b43_wldev *dev, u8 antenna) 
     2812{ 
     2813        antenna = b43_ieee80211_antenna_sanitize(dev, antenna); 
    27112814        switch (antenna) { 
    27122815        case 0:         /* default/diversity */ 
     
    27162819        case 2:         /* Antenna 1 */ 
    27172820                return B43_ANTENNA1; 
     2821        case 3:         /* Antenna 2 */ 
     2822                return B43_ANTENNA2; 
     2823        case 4:         /* Antenna 3 */ 
     2824                return B43_ANTENNA3; 
    27182825        default: 
    27192826                return B43_ANTENNA_DEFAULT; 
     
    27212828} 
    27222829 
    2723 static int b43_dev_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf) 
     2830static int b43_op_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf) 
    27242831{ 
    27252832        struct b43_wl *wl = hw_to_b43_wl(hw); 
     
    27282835        unsigned long flags; 
    27292836        unsigned int new_phymode = 0xFFFF; 
    2730         int antenna_tx; 
    2731         int antenna_rx; 
     2837        int antenna; 
    27322838        int err = 0; 
    27332839        u32 savedirqs; 
    27342840 
    2735         antenna_tx = b43_antenna_from_ieee80211(conf->antenna_sel_tx); 
    2736         antenna_rx = b43_antenna_from_ieee80211(conf->antenna_sel_rx); 
    2737  
    27382841        mutex_lock(&wl->mutex); 
    27392842 
    27402843        /* Switch the PHY mode (if necessary). */ 
    2741         switch (conf->phymode) { 
    2742         case MODE_IEEE80211A: 
     2844        switch (conf->channel->band) { 
     2845        case IEEE80211_BAND_5GHZ: 
    27432846                new_phymode = B43_PHYMODE_A; 
    27442847                break; 
    2745         case MODE_IEEE80211B: 
    2746                 new_phymode = B43_PHYMODE_B; 
    2747                 break; 
    2748         case MODE_IEEE80211G: 
     2848        case IEEE80211_BAND_2GHZ: 
    27492849                new_phymode = B43_PHYMODE_G; 
    27502850                break; 
     
    27722872        /* Switch to the requested channel. 
    27732873         * The firmware takes care of races with the TX handler. */ 
    2774         if (conf->channel_val != phy->channel) 
    2775                 b43_radio_selectchannel(dev, conf->channel_val, 0); 
     2874        if (conf->channel->hw_value != phy->channel) 
     2875                b43_radio_selectchannel(dev, conf->channel->hw_value, 0); 
    27762876 
    27772877        /* Enable/Disable ShortSlot timing. */ 
     
    27852885        } 
    27862886 
     2887        dev->wl->radiotap_enabled = !!(conf->flags & IEEE80211_CONF_RADIOTAP); 
     2888 
    27872889        /* Adjust the desired TX power level. */ 
    27882890        if (conf->power_level != 0) { 
     
    27942896 
    27952897        /* Antennas for RX and management frame TX. */ 
    2796         b43_mgmtframe_txantenna(dev, antenna_tx); 
    2797         b43_set_rx_antenna(dev, antenna_rx); 
     2898        antenna = b43_antenna_from_ieee80211(dev, conf->antenna_sel_tx); 
     2899        b43_mgmtframe_txantenna(dev, antenna); 
     2900        antenna = b43_antenna_from_ieee80211(dev, conf->antenna_sel_rx); 
     2901        b43_set_rx_antenna(dev, antenna); 
    27982902 
    27992903        /* Update templates for AP mode. */ 
     
    28262930} 
    28272931 
    2828 static int b43_dev_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 
     2932static int b43_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 
    28292933                           const u8 *local_addr, const u8 *addr, 
    28302934                           struct ieee80211_key_conf *key) 
    28312935{ 
    28322936        struct b43_wl *wl = hw_to_b43_wl(hw); 
    2833         struct b43_wldev *dev = wl->current_dev; 
     2937        struct b43_wldev *dev; 
    28342938        unsigned long flags; 
    28352939        u8 algorithm; 
    28362940        u8 index; 
    2837         int err = -EINVAL; 
     2941        int err; 
     2942        DECLARE_MAC_BUF(mac); 
    28382943 
    28392944        if (modparam_nohwcrypt) 
    28402945                return -ENOSPC; /* User disabled HW-crypto */ 
    28412946 
    2842         if (!dev) 
    2843                 return -ENODEV; 
     2947        mutex_lock(&wl->mutex); 
     2948        spin_lock_irqsave(&wl->irq_lock, flags); 
     2949 
     2950        dev = wl->current_dev; 
     2951        err = -ENODEV; 
     2952        if (!dev || b43_status(dev) < B43_STAT_INITIALIZED) 
     2953                goto out_unlock; 
     2954 
     2955        err = -EINVAL; 
    28442956        switch (key->alg) { 
    28452957        case ALG_WEP: 
     
    28572969        default: 
    28582970                B43_WARN_ON(1); 
    2859                 goto out; 
    2860         } 
    2861  
     2971                goto out_unlock; 
     2972        } 
    28622973        index = (u8) (key->keyidx); 
    28632974        if (index > 3) 
    2864                 goto out; 
    2865  
    2866         mutex_lock(&wl->mutex); 
    2867         spin_lock_irqsave(&wl->irq_lock, flags); 
    2868  
    2869         if (b43_status(dev) < B43_STAT_INITIALIZED) { 
    2870                 err = -ENODEV; 
    28712975                goto out_unlock; 
    2872         } 
    28732976 
    28742977        switch (cmd) { 
     
    29163019        spin_unlock_irqrestore(&wl->irq_lock, flags); 
    29173020        mutex_unlock(&wl->mutex); 
    2918 out: 
    29193021        if (!err) { 
    29203022                b43dbg(wl, "%s hardware based encryption for keyidx: %d, " 
    2921                        "mac: " MAC_FMT "\n", 
     3023                       "mac: %s\n", 
    29223024                       cmd == SET_KEY ? "Using" : "Disabling", key->keyidx, 
    2923                        MAC_ARG(addr)); 
     3025                       print_mac(mac, addr)); 
    29243026        } 
    29253027        return err; 
    29263028} 
    29273029 
    2928 static void b43_configure_filter(struct ieee80211_hw *hw, 
    2929                                  unsigned int changed, unsigned int *fflags, 
    2930                                  int mc_count, struct dev_addr_list *mc_list) 
     3030static void b43_op_configure_filter(struct ieee80211_hw *hw, 
     3031                                    unsigned int changed, unsigned int *fflags, 
     3032                                    int mc_count, struct dev_addr_list *mc_list) 
    29313033{ 
    29323034        struct b43_wl *wl = hw_to_b43_wl(hw); 
     
    29633065} 
    29643066 
    2965 static int b43_config_interface(struct ieee80211_hw *hw, 
    2966                                 int if_id, struct ieee80211_if_conf *conf) 
     3067static int b43_op_config_interface(struct ieee80211_hw *hw, 
     3068                                   struct ieee80211_vif *vif, 
     3069                                   struct ieee80211_if_conf *conf) 
    29673070{ 
    29683071        struct b43_wl *wl = hw_to_b43_wl(hw); 
     
    29743077        mutex_lock(&wl->mutex); 
    29753078        spin_lock_irqsave(&wl->irq_lock, flags); 
    2976         B43_WARN_ON(wl->if_id != if_id); 
     3079        B43_WARN_ON(wl->vif != vif); 
    29773080        if (conf->bssid) 
    29783081                memcpy(wl->bssid, conf->bssid, ETH_ALEN); 
     
    29843087                        b43_set_ssid(dev, conf->ssid, conf->ssid_len); 
    29853088                        if (conf->beacon) 
    2986                                 b43_refresh_templates(dev, conf->beacon); 
     3089                                b43_update_templates(wl, conf->beacon); 
    29873090                } 
    29883091                b43_write_mac_bssid_templates(dev); 
     
    30023105        if (b43_status(dev) < B43_STAT_STARTED) 
    30033106                return; 
     3107 
     3108        /* Disable and sync interrupts. We must do this before than 
     3109         * setting the status to INITIALIZED, as the interrupt handler 
     3110         * won't care about IRQs then. */ 
     3111        spin_lock_irqsave(&wl->irq_lock, flags); 
     3112        dev->irq_savedstate = b43_interrupt_disable(dev, B43_IRQ_ALL); 
     3113        b43_read32(dev, B43_MMIO_GEN_IRQ_MASK); /* flush */ 
     3114        spin_unlock_irqrestore(&wl->irq_lock, flags); 
     3115        b43_synchronize_irq(dev); 
     3116 
    30043117        b43_set_status(dev, B43_STAT_INITIALIZED); 
    30053118 
     
    30113124 
    30123125        ieee80211_stop_queues(wl->hw);  //FIXME this could cause a deadlock, as mac80211 seems buggy. 
    3013  
    3014         /* Disable and sync interrupts. */ 
    3015         spin_lock_irqsave(&wl->irq_lock, flags); 
    3016         dev->irq_savedstate = b43_interrupt_disable(dev, B43_IRQ_ALL); 
    3017         b43_read32(dev, B43_MMIO_GEN_IRQ_MASK); /* flush */ 
    3018         spin_unlock_irqrestore(&wl->irq_lock, flags); 
    3019         b43_synchronize_irq(dev); 
    30203126 
    30213127        b43_mac_suspend(dev); 
     
    30843190                break; 
    30853191        case B43_PHYTYPE_G: 
    3086                 if (phy_rev > 8) 
     3192                if (phy_rev > 9) 
    30873193                        unsupported = 1; 
    30883194                break; 
     3195#ifdef CONFIG_B43_NPHY 
     3196        case B43_PHYTYPE_N: 
     3197                if (phy_rev > 1) 
     3198                        unsupported = 1; 
     3199                break; 
     3200#endif 
    30893201        default: 
    30903202                unsupported = 1; 
     
    31093221        } else { 
    31103222                b43_write16(dev, B43_MMIO_RADIO_CONTROL, B43_RADIOCTL_ID); 
    3111                 tmp = b43_read16(dev, B43_MMIO_RADIO_DATA_HIGH); 
    3112                 tmp <<= 16; 
     3223                tmp = b43_read16(dev, B43_MMIO_RADIO_DATA_LOW); 
    31133224                b43_write16(dev, B43_MMIO_RADIO_CONTROL, B43_RADIOCTL_ID); 
    3114                 tmp |= b43_read16(dev, B43_MMIO_RADIO_DATA_LOW); 
     3225                tmp |= (u32)b43_read16(dev, B43_MMIO_RADIO_DATA_HIGH) << 16; 
    31153226        } 
    31163227        radio_manuf = (tmp & 0x00000FFF); 
    31173228        radio_ver = (tmp & 0x0FFFF000) >> 12; 
    31183229        radio_rev = (tmp & 0xF0000000) >> 28; 
     3230        if (radio_manuf != 0x17F /* Broadcom */) 
     3231                unsupported = 1; 
    31193232        switch (phy_type) { 
    31203233        case B43_PHYTYPE_A: 
     
    31343247                        unsupported = 1; 
    31353248                break; 
     3249        case B43_PHYTYPE_N: 
     3250                if (radio_ver != 0x2055) 
     3251                        unsupported = 1; 
     3252                break; 
    31363253        default: 
    31373254                B43_WARN_ON(1); 
     
    31653282        memset(phy->minlowsig, 0xFF, sizeof(phy->minlowsig)); 
    31663283        memset(phy->minlowsigpos, 0, sizeof(phy->minlowsigpos)); 
    3167  
    3168         /* Flags */ 
    3169         phy->locked = 0; 
    31703284 
    31713285        phy->aci_enable = 0; 
     
    31953309        phy->initval = 0xFFFF; 
    31963310 
    3197         spin_lock_init(&phy->lock); 
    31983311        phy->interfmode = B43_INTERFMODE_NONE; 
    31993312        phy->channel = 0xFF; 
    32003313 
    32013314        phy->hardware_power_control = !!modparam_hwpctl; 
     3315 
     3316        /* PHY TX errors counter. */ 
     3317        atomic_set(&phy->txerr_cnt, B43_PHY_TX_BADNESS_LIMIT); 
     3318 
     3319        /* OFDM-table address caching. */ 
     3320        phy->ofdmtab_addr_direction = B43_OFDMTAB_DIRECTION_UNKNOWN; 
    32023321} 
    32033322 
    32043323static void setup_struct_wldev_for_init(struct b43_wldev *dev) 
    32053324{ 
    3206         /* Flags */ 
    3207         dev->reg124_set_0x4 = 0; 
     3325        dev->dfq_valid = 0; 
     3326 
    32083327        /* Assume the radio is enabled. If it's not enabled, the state will 
    32093328         * immediately get fixed on the first periodic work run. */ 
     
    32313350        u32 hf; 
    32323351 
    3233         if (!(sprom->r1.boardflags_lo & B43_BFL_BTCOEXIST)) 
     3352        if (!(sprom->boardflags_lo & B43_BFL_BTCOEXIST)) 
    32343353                return; 
    32353354        if (dev->phy.type != B43_PHYTYPE_B && !dev->phy.gmode) 
     
    32373356 
    32383357        hf = b43_hf_read(dev); 
    3239         if (sprom->r1.boardflags_lo & B43_BFL_BTCMOD) 
     3358        if (sprom->boardflags_lo & B43_BFL_BTCMOD) 
    32403359                hf |= B43_HF_BTCOEXALT; 
    32413360        else 
     
    32763395} 
    32773396 
     3397/* Write the short and long frame retry limit values. */ 
     3398static void b43_set_retry_limits(struct b43_wldev *dev, 
     3399                                 unsigned int short_retry, 
     3400                                 unsigned int long_retry) 
     3401{ 
     3402        /* The retry limit is a 4-bit counter. Enforce this to avoid overflowing 
     3403         * the chip-internal counter. */ 
     3404        short_retry = min(short_retry, (unsigned int)0xF); 
     3405        long_retry = min(long_retry, (unsigned int)0xF); 
     3406 
     3407        b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_SRLIMIT, 
     3408                        short_retry); 
     3409        b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_LRLIMIT, 
     3410                        long_retry); 
     3411} 
     3412 
    32783413/* Shutdown a wireless core */ 
    32793414/* Locking: wl->mutex */ 
     
    32813416{ 
    32823417        struct b43_phy *phy = &dev->phy; 
     3418        u32 macctl; 
    32833419 
    32843420        B43_WARN_ON(b43_status(dev) > B43_STAT_INITIALIZED); 
     
    32873423        b43_set_status(dev, B43_STAT_UNINIT); 
    32883424 
    3289         mutex_unlock(&dev->wl->mutex); 
    3290         b43_rfkill_exit(dev); 
    3291         mutex_lock(&dev->wl->mutex); 
    3292  
     3425        /* Stop the microcode PSM. */ 
     3426        macctl = b43_read32(dev, B43_MMIO_MACCTL); 
     3427        macctl &= ~B43_MACCTL_PSM_RUN; 
     3428        macctl |= B43_MACCTL_PSM_JMP0; 
     3429        b43_write32(dev, B43_MMIO_MACCTL, macctl); 
     3430 
     3431        b43_leds_exit(dev); 
    32933432        b43_rng_exit(dev->wl); 
    3294         b43_pio_free(dev); 
    32953433        b43_dma_free(dev); 
    32963434        b43_chip_exit(dev); 
     
    33013439        kfree(phy->lo_control); 
    33023440        phy->lo_control = NULL; 
     3441        if (dev->wl->current_beacon) { 
     3442                dev_kfree_skb_any(dev->wl->current_beacon); 
     3443                dev->wl->current_beacon = NULL; 
     3444        } 
     3445 
    33033446        ssb_device_disable(dev->dev, 0); 
    33043447        ssb_bus_may_powerdown(dev->dev->bus); 
     
    33553498                if (phy->rev == 1) 
    33563499                        hf |= B43_HF_GDCW; 
    3357                 if (sprom->r1.boardflags_lo & B43_BFL_PACTRL) 
     3500                if (sprom->boardflags_lo & B43_BFL_PACTRL) 
    33583501                        hf |= B43_HF_OFDMPABOOST; 
    33593502        } else if (phy->type == B43_PHYTYPE_B) { 
     
    33643507        b43_hf_write(dev, hf); 
    33653508 
    3366         /* Short/Long Retry Limit. 
    3367          * The retry-limit is a 4-bit counter. Enforce this to avoid overflowing 
    3368          * the chip-internal counter. 
    3369          */ 
    3370         tmp = limit_value(modparam_short_retry, 0, 0xF); 
    3371         b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_SRLIMIT, tmp); 
    3372         tmp = limit_value(modparam_long_retry, 0, 0xF); 
    3373         b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_LRLIMIT, tmp); 
    3374  
     3509        b43_set_retry_limits(dev, B43_DEFAULT_SHORT_RETRY_LIMIT, 
     3510                             B43_DEFAULT_LONG_RETRY_LIMIT); 
    33753511        b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_SFFBLIM, 3); 
    33763512        b43_shm_write16(dev, B43_SHM_SHARED, B43_SHM_SH_LFFBLIM, 2); 
     
    33933529        b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_MAXCONT, 0x3FF); 
    33943530 
    3395         do { 
    3396                 if (b43_using_pio(dev)) { 
    3397                         err = b43_pio_init(dev); 
    3398                 } else { 
    3399                         err = b43_dma_init(dev); 
    3400                         if (!err) 
    3401                                 b43_qos_init(dev); 
    3402                 } 
    3403         } while (err == -EAGAIN); 
     3531        err = b43_dma_init(dev); 
    34043532        if (err) 
    34053533                goto err_chip_exit; 
     3534        b43_qos_init(dev); 
    34063535 
    34073536//FIXME 
     
    34153544 
    34163545        ssb_bus_powerup(bus, 1);        /* Enable dynamic PCTL */ 
    3417         memset(wl->bssid, 0, ETH_ALEN); 
    3418         memset(wl->mac_addr, 0, ETH_ALEN); 
    34193546        b43_upload_card_macaddress(dev); 
    34203547        b43_security_init(dev); 
    3421         b43_rfkill_init(dev); 
    34223548        b43_rng_init(wl); 
    34233549 
    34243550        b43_set_status(dev, B43_STAT_INITIALIZED); 
    34253551 
    3426       out: 
     3552        b43_leds_init(dev); 
     3553out: 
    34273554        return err; 
    34283555 
     
    34413568} 
    34423569 
    3443 static int b43_add_interface(struct ieee80211_hw *hw, 
    3444                              struct ieee80211_if_init_conf *conf) 
     3570static int b43_op_add_interface(struct ieee80211_hw *hw, 
     3571                                struct ieee80211_if_init_conf *conf) 
    34453572{ 
    34463573        struct b43_wl *wl = hw_to_b43_wl(hw); 
     
    34653592        dev = wl->current_dev; 
    34663593        wl->operating = 1; 
    3467         wl->if_id = conf->if_id; 
     3594        wl->vif = conf->vif; 
    34683595        wl->if_type = conf->type; 
    34693596        memcpy(wl->mac_addr, conf->mac_addr, ETH_ALEN); 
     
    34813608} 
    34823609 
    3483 static void b43_remove_interface(struct ieee80211_hw *hw, 
    3484                                  struct ieee80211_if_init_conf *conf) 
     3610static void b43_op_remove_interface(struct ieee80211_hw *hw, 
     3611                                    struct ieee80211_if_init_conf *conf) 
    34853612{ 
    34863613        struct b43_wl *wl = hw_to_b43_wl(hw); 
     
    34933620 
    34943621        B43_WARN_ON(!wl->operating); 
    3495         B43_WARN_ON(wl->if_id != conf->if_id); 
     3622        B43_WARN_ON(wl->vif != conf->vif); 
     3623        wl->vif = NULL; 
    34963624 
    34973625        wl->operating = 0; 
     
    35063634} 
    35073635 
    3508 static int b43_start(struct ieee80211_hw *hw) 
     3636static int b43_op_start(struct ieee80211_hw *hw) 
    35093637{ 
    35103638        struct b43_wl *wl = hw_to_b43_wl(hw); 
     
    35123640        int did_init = 0; 
    35133641        int err = 0; 
     3642        bool do_rfkill_exit = 0; 
     3643 
     3644        /* Kill all old instance specific information to make sure 
     3645         * the card won't use it in the short timeframe between start 
     3646         * and mac80211 reconfiguring it. */ 
     3647        memset(wl->bssid, 0, ETH_ALEN); 
     3648        memset(wl->mac_addr, 0, ETH_ALEN); 
     3649        wl->filter_flags = 0; 
     3650        wl->radiotap_enabled = 0; 
     3651 
     3652        /* First register RFkill. 
     3653         * LEDs that are registered later depend on it. */ 
     3654        b43_rfkill_init(dev); 
    35143655 
    35153656        mutex_lock(&wl->mutex); 
     
    35173658        if (b43_status(dev) < B43_STAT_INITIALIZED) { 
    35183659                err = b43_wireless_core_init(dev); 
    3519                 if (err) 
     3660                if (err) { 
     3661                        do_rfkill_exit = 1; 
    35203662                        goto out_mutex_unlock; 
     3663                } 
    35213664                did_init = 1; 
    35223665        } 
     
    35273670                        if (did_init) 
    35283671                                b43_wireless_core_exit(dev); 
     3672                        do_rfkill_exit = 1; 
    35293673                        goto out_mutex_unlock; 
    35303674                } 
     
    35343678        mutex_unlock(&wl->mutex); 
    35353679 
     3680        if (do_rfkill_exit) 
     3681                b43_rfkill_exit(dev); 
     3682 
    35363683        return err; 
    35373684} 
    35383685 
    3539 static void b43_stop(struct ieee80211_hw *hw) 
     3686static void b43_op_stop(struct ieee80211_hw *hw) 
    35403687{ 
    35413688        struct b43_wl *wl = hw_to_b43_wl(hw); 
    35423689        struct b43_wldev *dev = wl->current_dev; 
     3690 
     3691        b43_rfkill_exit(dev); 
    35433692 
    35443693        mutex_lock(&wl->mutex); 
     
    35493698} 
    35503699 
     3700static int b43_op_set_retry_limit(struct ieee80211_hw *hw, 
     3701                                  u32 short_retry_limit, u32 long_retry_limit) 
     3702{ 
     3703        struct b43_wl *wl = hw_to_b43_wl(hw); 
     3704        struct b43_wldev *dev; 
     3705        int err = 0; 
     3706 
     3707        mutex_lock(&wl->mutex); 
     3708        dev = wl->current_dev; 
     3709        if (unlikely(!dev || (b43_status(dev) < B43_STAT_INITIALIZED))) { 
     3710                err = -ENODEV; 
     3711                goto out_unlock; 
     3712        } 
     3713        b43_set_retry_limits(dev, short_retry_limit, long_retry_limit); 
     3714out_unlock: 
     3715        mutex_unlock(&wl->mutex); 
     3716 
     3717        return err; 
     3718} 
     3719 
     3720static int b43_op_beacon_set_tim(struct ieee80211_hw *hw, int aid, int set) 
     3721{ 
     3722        struct b43_wl *wl = hw_to_b43_wl(hw); 
     3723        struct sk_buff *beacon; 
     3724        unsigned long flags; 
     3725 
     3726        /* We could modify the existing beacon and set the aid bit in 
     3727         * the TIM field, but that would probably require resizing and 
     3728         * moving of data within the beacon template. 
     3729         * Simply request a new beacon and let mac80211 do the hard work. */ 
     3730        beacon = ieee80211_beacon_get(hw, wl->vif, NULL); 
     3731        if (unlikely(!beacon)) 
     3732                return -ENOMEM; 
     3733        spin_lock_irqsave(&wl->irq_lock, flags); 
     3734        b43_update_templates(wl, beacon); 
     3735        spin_unlock_irqrestore(&wl->irq_lock, flags); 
     3736 
     3737        return 0; 
     3738} 
     3739 
     3740static int b43_op_ibss_beacon_update(struct ieee80211_hw *hw, 
     3741                                     struct sk_buff *beacon, 
     3742                                     struct ieee80211_tx_control *ctl) 
     3743{ 
     3744        struct b43_wl *wl = hw_to_b43_wl(hw); 
     3745        unsigned long flags; 
     3746 
     3747        spin_lock_irqsave(&wl->irq_lock, flags); 
     3748        b43_update_templates(wl, beacon); 
     3749        spin_unlock_irqrestore(&wl->irq_lock, flags); 
     3750 
     3751        return 0; 
     3752} 
     3753 
    35513754static const struct ieee80211_ops b43_hw_ops = { 
    3552         .tx = b43_tx, 
    3553         .conf_tx = b43_conf_tx, 
    3554         .add_interface = b43_add_interface, 
    3555         .remove_interface = b43_remove_interface, 
    3556         .config = b43_dev_config, 
    3557         .config_interface = b43_config_interface, 
    3558         .configure_filter = b43_configure_filter, 
    3559         .set_key = b43_dev_set_key, 
    3560         .get_stats = b43_get_stats, 
    3561         .get_tx_stats = b43_get_tx_stats, 
    3562         .start = b43_start, 
    3563         .stop = b43_stop, 
     3755        .tx                     = b43_op_tx, 
     3756        .conf_tx                = b43_op_conf_tx, 
     3757        .add_interface          = b43_op_add_interface, 
     3758        .remove_interface       = b43_op_remove_interface, 
     3759        .config                 = b43_op_config, 
     3760        .config_interface       = b43_op_config_interface, 
     3761        .configure_filter       = b43_op_configure_filter, 
     3762        .set_key                = b43_op_set_key, 
     3763        .get_stats              = b43_op_get_stats, 
     3764        .get_tx_stats           = b43_op_get_tx_stats, 
     3765        .start                  = b43_op_start, 
     3766        .stop                   = b43_op_stop, 
     3767        .set_retry_limit        = b43_op_set_retry_limit, 
     3768        .set_tim                = b43_op_beacon_set_tim, 
     3769        .beacon_update          = b43_op_ibss_beacon_update, 
    35643770}; 
    35653771 
     
    36063812 
    36073813static int b43_setup_modes(struct b43_wldev *dev, 
    3608                            int have_aphy, int have_bphy, int have_gphy) 
     3814                           bool have_2ghz_phy, bool have_5ghz_phy) 
    36093815{ 
    36103816        struct ieee80211_hw *hw = dev->wl->hw; 
    3611         struct ieee80211_hw_mode *mode; 
    36123817        struct b43_phy *phy = &dev->phy; 
    3613         int cnt = 0; 
    3614         int err; 
    3615  
    3616 /*FIXME: Don't tell ieee80211 about an A-PHY, because we currently don't support A-PHY. */ 
    3617         have_aphy = 0; 
    3618  
    3619         phy->possible_phymodes = 0; 
    3620         for (; 1; cnt++) { 
    3621                 if (have_aphy) { 
    3622                         B43_WARN_ON(cnt >= B43_MAX_PHYHWMODES); 
    3623                         mode = &phy->hwmodes[cnt]; 
    3624  
    3625                         mode->mode = MODE_IEEE80211A; 
    3626                         mode->num_channels = b43_a_chantable_size; 
    3627                         mode->channels = b43_a_chantable; 
    3628                         mode->num_rates = b43_a_ratetable_size; 
    3629                         mode->rates = b43_a_ratetable; 
    3630                         err = ieee80211_register_hwmode(hw, mode); 
    3631                         if (err) 
    3632                                 return err; 
    3633  
    3634                         phy->possible_phymodes |= B43_PHYMODE_A; 
    3635                         have_aphy = 0; 
    3636                         continue; 
    3637                 } 
    3638                 if (have_bphy) { 
    3639                         B43_WARN_ON(cnt >= B43_MAX_PHYHWMODES); 
    3640                         mode = &phy->hwmodes[cnt]; 
    3641  
    3642                         mode->mode = MODE_IEEE80211B; 
    3643                         mode->num_channels = b43_bg_chantable_size; 
    3644                         mode->channels = b43_bg_chantable; 
    3645                         mode->num_rates = b43_b_ratetable_size; 
    3646                         mode->rates = b43_b_ratetable; 
    3647                         err = ieee80211_register_hwmode(hw, mode); 
    3648                         if (err) 
    3649                                 return err; 
    3650  
    3651                         phy->possible_phymodes |= B43_PHYMODE_B; 
    3652                         have_bphy = 0; 
    3653                         continue; 
    3654                 } 
    3655                 if (have_gphy) { 
    3656                         B43_WARN_ON(cnt >= B43_MAX_PHYHWMODES); 
    3657                         mode = &phy->hwmodes[cnt]; 
    3658  
    3659                         mode->mode = MODE_IEEE80211G; 
    3660                         mode->num_channels = b43_bg_chantable_size; 
    3661                         mode->channels = b43_bg_chantable; 
    3662                         mode->num_rates = b43_g_ratetable_size; 
    3663                         mode->rates = b43_g_ratetable; 
    3664                         err = ieee80211_register_hwmode(hw, mode); 
    3665                         if (err) 
    3666                                 return err; 
    3667  
    3668                         phy->possible_phymodes |= B43_PHYMODE_G; 
    3669                         have_gphy = 0; 
    3670                         continue; 
    3671                 } 
    3672                 break; 
    3673         } 
     3818 
     3819        /* XXX: This function will go away soon, when mac80211 
     3820         *      band stuff is rewritten. So this is just a hack. 
     3821         *      For now we always claim GPHY mode, as there is no 
     3822         *      support for NPHY and APHY in the device, yet. 
     3823         *      This assumption is OK, as any B, N or A PHY will already 
     3824         *      have died a horrible sanity check death earlier. */ 
     3825 
     3826        hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &b43_band_2GHz; 
     3827        phy->possible_phymodes |= B43_PHYMODE_G; 
    36743828 
    36753829        return 0; 
     
    36783832static void b43_wireless_core_detach(struct b43_wldev *dev) 
    36793833{ 
    3680         b43_rfkill_free(dev); 
    36813834        /* We release firmware that late to not be required to re-request 
    36823835         * is all the time when we reinit the core. */ 
     
    36903843        struct pci_dev *pdev = bus->host_pci; 
    36913844        int err; 
    3692         int have_aphy = 0, have_bphy = 0, have_gphy = 0; 
     3845        bool have_2ghz_phy = 0, have_5ghz_phy = 0; 
    36933846        u32 tmp; 
    36943847 
     
    37103863 
    37113864                tmshigh = ssb_read32(dev->dev, SSB_TMSHIGH); 
    3712                 have_aphy = !!(tmshigh & B43_TMSHIGH_APHY); 
    3713                 have_gphy = !!(tmshigh & B43_TMSHIGH_GPHY); 
    3714                 if (!have_aphy && !have_gphy) 
    3715                         have_bphy = 1; 
    3716         } else if (dev->dev->id.revision == 4) { 
    3717                 have_gphy = 1; 
    3718                 have_aphy = 1; 
     3865                have_2ghz_phy = !!(tmshigh & B43_TMSHIGH_HAVE_2GHZ_PHY); 
     3866                have_5ghz_phy = !!(tmshigh & B43_TMSHIGH_HAVE_5GHZ_PHY); 
    37193867        } else 
    3720                 have_bphy = 1; 
    3721  
    3722         dev->phy.gmode = (have_gphy || have_bphy); 
     3868                B43_WARN_ON(1); 
     3869 
     3870        dev->phy.gmode = have_2ghz_phy; 
    37233871        tmp = dev->phy.gmode ? B43_TMSLOW_GMODE : 0; 
    37243872        b43_wireless_core_reset(dev, tmp); 
     
    37323880             pdev->device != 0x4319 && pdev->device != 0x4324)) { 
    37333881                /* No multiband support. */ 
    3734                 have_aphy = 0; 
    3735                 have_bphy = 0; 
    3736                 have_gphy = 0; 
     3882                have_2ghz_phy = 0; 
     3883                have_5ghz_phy = 0; 
    37373884                switch (dev->phy.type) { 
    37383885                case B43_PHYTYPE_A: 
    3739                         have_aphy = 1; 
    3740                         break; 
    3741                 case B43_PHYTYPE_B: 
    3742                         have_bphy = 1; 
     3886                        have_5ghz_phy = 1; 
    37433887                        break; 
    37443888                case B43_PHYTYPE_G: 
    3745                         have_gphy = 1; 
     3889                case B43_PHYTYPE_N: 
     3890                        have_2ghz_phy = 1; 
    37463891                        break; 
    37473892                default: 
     
    37493894                } 
    37503895        } 
    3751         dev->phy.gmode = (have_gphy || have_bphy); 
     3896        if (dev->phy.type == B43_PHYTYPE_A) { 
     3897                /* FIXME */ 
     3898                b43err(wl, "IEEE 802.11a devices are unsupported\n"); 
     3899                err = -EOPNOTSUPP; 
     3900                goto err_powerdown; 
     3901        } 
     3902        dev->phy.gmode = have_2ghz_phy; 
    37523903        tmp = dev->phy.gmode ? B43_TMSLOW_GMODE : 0; 
    37533904        b43_wireless_core_reset(dev, tmp); 
     
    37563907        if (err) 
    37573908                goto err_powerdown; 
    3758         err = b43_setup_modes(dev, have_aphy, have_bphy, have_gphy); 
     3909        err = b43_setup_modes(dev, have_2ghz_phy, have_5ghz_phy); 
    37593910        if (err) 
    37603911                goto err_powerdown; 
     
    37643915                wl->current_dev = dev; 
    37653916        INIT_WORK(&dev->restart_work, b43_chip_reset); 
    3766         b43_rfkill_alloc(dev); 
    37673917 
    37683918        b43_radio_turn_off(dev, 1); 
     
    38283978                     (void (*)(unsigned long))b43_interrupt_tasklet, 
    38293979                     (unsigned long)wldev); 
    3830         if (modparam_pio) 
    3831                 wldev->__using_pio = 1; 
    38323980        INIT_LIST_HEAD(&wldev->list); 
    38333981 
     
    38544002        if (bus->boardinfo.vendor == SSB_BOARDVENDOR_DELL && 
    38554003            bus->chip_id == 0x4301 && bus->boardinfo.rev == 0x74) 
    3856                 bus->sprom.r1.boardflags_lo |= B43_BFL_BTCOEXIST; 
     4004                bus->sprom.boardflags_lo |= B43_BFL_BTCOEXIST; 
    38574005        if (bus->boardinfo.vendor == PCI_VENDOR_ID_APPLE && 
    38584006            bus->boardinfo.type == 0x4E && bus->boardinfo.rev > 0x40) 
    3859                 bus->sprom.r1.boardflags_lo |= B43_BFL_PACTRL; 
    3860  
    3861         /* Handle case when gain is not set in sprom */ 
    3862         if (bus->sprom.r1.antenna_gain_a == 0xFF) 
    3863                 bus->sprom.r1.antenna_gain_a = 2; 
    3864         if (bus->sprom.r1.antenna_gain_bg == 0xFF) 
    3865                 bus->sprom.r1.antenna_gain_bg = 2; 
    3866  
    3867         /* Convert Antennagain values to Q5.2 */ 
    3868         bus->sprom.r1.antenna_gain_a <<= 2; 
    3869         bus->sprom.r1.antenna_gain_bg <<= 2; 
     4007                bus->sprom.boardflags_lo |= B43_BFL_PACTRL; 
    38704008} 
    38714009 
     
    38944032 
    38954033        /* fill hw info */ 
    3896         hw->flags = IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE; 
     4034        hw->flags = IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE | 
     4035                    IEEE80211_HW_RX_INCLUDES_FCS; 
    38974036        hw->max_signal = 100; 
    38984037        hw->max_rssi = -110; 
     
    39004039        hw->queues = 1;         /* FIXME: hardware has more queues */ 
    39014040        SET_IEEE80211_DEV(hw, dev->dev); 
    3902         if (is_valid_ether_addr(sprom->r1.et1mac)) 
    3903                 SET_IEEE80211_PERM_ADDR(hw, sprom->r1.et1mac); 
     4041        if (is_valid_ether_addr(sprom->et1mac)) 
     4042                SET_IEEE80211_PERM_ADDR(hw, sprom->et1mac); 
    39044043        else 
    3905                 SET_IEEE80211_PERM_ADDR(hw, sprom->r1.il0mac); 
     4044                SET_IEEE80211_PERM_ADDR(hw, sprom->il0mac); 
    39064045 
    39074046        /* Get and initialize struct b43_wl */ 
     
    39114050        spin_lock_init(&wl->irq_lock); 
    39124051        spin_lock_init(&wl->leds_lock); 
     4052        spin_lock_init(&wl->shm_lock); 
    39134053        mutex_init(&wl->mutex); 
    39144054        INIT_LIST_HEAD(&wl->devlist); 
     
    40544194}; 
    40554195 
    4056 inline int b43_pci_ssb_bridge_init(void) 
    4057 { 
    4058         return ssb_pcihost_register(&b43_pci_bridge_driver); 
    4059 } 
    4060  
    4061 inline void b43_pci_ssb_bridge_exit(void) 
    4062 { 
    4063         ssb_pcihost_unregister(&b43_pci_bridge_driver); 
    4064 } 
    4065  
    40664196static int __init b43_init(void) 
    40674197{ 
     
    40724202        if (err) 
    40734203                goto err_dfs_exit; 
    4074  
    4075         err = b43_pci_ssb_bridge_init(); 
     4204        err = ssb_driver_register(&b43_ssb_driver); 
    40764205        if (err) 
    40774206                goto err_pcmcia_exit; 
    40784207 
    4079         err = ssb_driver_register(&b43_ssb_driver); 
    4080         if (err) 
    4081                 goto err_pci_exit; 
    4082  
    40834208        return err; 
    40844209 
    4085 err_pci_exit: 
    4086         b43_pci_ssb_bridge_exit(); 
    40874210err_pcmcia_exit: 
    40884211        b43_pcmcia_exit(); 
     
    40954218{ 
    40964219        ssb_driver_unregister(&b43_ssb_driver); 
    4097         b43_pci_ssb_bridge_exit(); 
    40984220        b43_pcmcia_exit(); 
    40994221        b43_debugfs_exit(); 
  • trunk/package/b43/src/main.h

    r9293 r10466  
    44 
    55  Copyright (c) 2005 Martin Langer <martin-langer@gmx.de>, 
    6                      Stefano Brivio <st3@riseup.net> 
     6                     Stefano Brivio <stefano.brivio@polimi.it> 
    77                     Michael Buesch <mb@bu3sch.de> 
    88                     Danny van Dyk <kugelfang@gentoo.org> 
     
    4040 
    4141/* Lightweight function to convert a frequency (in Mhz) to a channel number. */ 
    42 static inline u8 b43_freq_to_channel_a(int freq) 
     42static inline u8 b43_freq_to_channel_5ghz(int freq) 
    4343{ 
    4444        return ((freq - 5000) / 5); 
    4545} 
    46 static inline u8 b43_freq_to_channel_bg(int freq) 
     46static inline u8 b43_freq_to_channel_2ghz(int freq) 
    4747{ 
    4848        u8 channel; 
     
    5555        return channel; 
    5656} 
    57 static inline u8 b43_freq_to_channel(struct b43_wldev *dev, int freq) 
    58 { 
    59         if (dev->phy.type == B43_PHYTYPE_A) 
    60                 return b43_freq_to_channel_a(freq); 
    61         return b43_freq_to_channel_bg(freq); 
    62 } 
    6357 
    6458/* Lightweight function to convert a channel number to a frequency (in Mhz). */ 
    65 static inline int b43_channel_to_freq_a(u8 channel) 
     59static inline int b43_channel_to_freq_5ghz(u8 channel) 
    6660{ 
    6761        return (5000 + (5 * channel)); 
    6862} 
    69 static inline int b43_channel_to_freq_bg(u8 channel) 
     63static inline int b43_channel_to_freq_2ghz(u8 channel) 
    7064{ 
    7165        int freq; 
     
    7771 
    7872        return freq; 
    79 } 
    80 static inline int b43_channel_to_freq(struct b43_wldev *dev, u8 channel) 
    81 { 
    82         if (dev->phy.type == B43_PHYTYPE_A) 
    83                 return b43_channel_to_freq_a(channel); 
    84         return b43_channel_to_freq_bg(channel); 
    8573} 
    8674 
     
    9684        return !b43_is_cck_rate(rate); 
    9785} 
     86 
     87u8 b43_ieee80211_antenna_sanitize(struct b43_wldev *dev, 
     88                                  u8 antenna_nr); 
    9889 
    9990void b43_tsf_read(struct b43_wldev *dev, u64 * tsf); 
  • trunk/package/b43/src/pcmcia.c

    r9535 r10466  
    6666        cisparse_t parse; 
    6767        int err = -ENOMEM; 
    68         int res; 
     68        int res = 0; 
    6969        unsigned char buf[64]; 
    7070 
    7171        ssb = kzalloc(sizeof(*ssb), GFP_KERNEL); 
    7272        if (!ssb) 
    73                 goto out; 
     73                goto out_error; 
    7474 
    7575        err = -ENODEV; 
     
    9797        dev->io.Attributes2 = 0; 
    9898 
    99         win.Attributes = WIN_MEMORY_TYPE_CM | WIN_ENABLE | WIN_USE_WAIT; 
     99        win.Attributes = WIN_ADDR_SPACE_MEM | WIN_MEMORY_TYPE_CM | 
     100                         WIN_ENABLE | WIN_DATA_WIDTH_16 | 
     101                         WIN_USE_WAIT; 
    100102        win.Base = 0; 
    101103        win.Size = SSB_CORE_SIZE; 
    102         win.AccessSpeed = 1000; 
     104        win.AccessSpeed = 250; 
    103105        res = pcmcia_request_window(&dev, &win, &dev->win); 
    104106        if (res != CS_SUCCESS) 
     
    109111        res = pcmcia_map_mem_page(dev->win, &mem); 
    110112        if (res != CS_SUCCESS) 
    111                 goto err_kfree_ssb; 
     113                goto err_disable; 
     114 
     115        dev->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING | IRQ_FIRST_SHARED; 
     116        dev->irq.IRQInfo1 = IRQ_LEVEL_ID | IRQ_SHARE_ID; 
     117        dev->irq.Handler = NULL; /* The handler is registered later. */ 
     118        dev->irq.Instance = NULL; 
     119        res = pcmcia_request_irq(dev, &dev->irq); 
     120        if (res != CS_SUCCESS) 
     121                goto err_disable; 
    112122 
    113123        res = pcmcia_request_configuration(dev, &dev->conf); 
     
    116126 
    117127        err = ssb_bus_pcmciabus_register(ssb, dev, win.Base); 
     128        if (err) 
     129                goto err_disable; 
    118130        dev->priv = ssb; 
    119131 
    120       out: 
    121         return err; 
    122       err_disable: 
     132        return 0; 
     133 
     134err_disable: 
    123135        pcmcia_disable_device(dev); 
    124       err_kfree_ssb: 
     136err_kfree_ssb: 
    125137        kfree(ssb); 
     138out_error: 
     139        printk(KERN_ERR "b43-pcmcia: Initialization failed (%d, %d)\n", 
     140               res, err); 
    126141        return err; 
    127142} 
     
    132147 
    133148        ssb_bus_unregister(ssb); 
    134         pcmcia_release_window(dev->win); 
    135149        pcmcia_disable_device(dev); 
    136150        kfree(ssb); 
     
    139153 
    140154static struct pcmcia_driver b43_pcmcia_driver = { 
    141         .owner = THIS_MODULE, 
    142         .drv = { 
    143                 .name = "b43-pcmcia", 
    144                 }, 
    145         .id_table = b43_pcmcia_tbl, 
    146         .probe = b43_pcmcia_probe, 
    147         .remove = b43_pcmcia_remove, 
    148         .suspend = b43_pcmcia_suspend, 
    149         .resume = b43_pcmcia_resume, 
     155        .owner          = THIS_MODULE, 
     156        .drv            = { 
     157                                .name = "b43-pcmcia", 
     158                        }, 
     159        .id_table       = b43_pcmcia_tbl, 
     160        .probe          = b43_pcmcia_probe, 
     161        .remove         = __devexit_p(b43_pcmcia_remove), 
     162        .suspend        = b43_pcmcia_suspend, 
     163        .resume         = b43_pcmcia_resume, 
    150164}; 
    151165 
  • trunk/package/b43/src/phy.c

    r9535 r10466  
    44 
    55  Copyright (c) 2005 Martin Langer <martin-langer@gmx.de>, 
    6   Copyright (c) 2005, 2006 Stefano Brivio <st3@riseup.net> 
     6  Copyright (c) 2005-2007 Stefano Brivio <stefano.brivio@polimi.it> 
    77  Copyright (c) 2005, 2006 Michael Buesch <mb@bu3sch.de> 
    88  Copyright (c) 2005, 2006 Danny van Dyk <kugelfang@gentoo.org> 
     
    3232#include "b43.h" 
    3333#include "phy.h" 
     34#include "nphy.h" 
    3435#include "main.h" 
    3536#include "tables.h" 
    3637#include "lo.h" 
     38#include "wa.h" 
     39 
    3740 
    3841static const s8 b43_tssi2dbm_b_table[] = { 
     
    226229} 
    227230 
    228 void b43_raw_phy_lock(struct b43_wldev *dev) 
    229 { 
    230         struct b43_phy *phy = &dev->phy; 
    231  
    232         B43_WARN_ON(!irqs_disabled()); 
    233  
    234         /* We had a check for MACCTL==0 here, but I think that doesn't 
    235          * make sense, as MACCTL is never 0 when this is called. 
    236          *      --mb */ 
    237         B43_WARN_ON(b43_read32(dev, B43_MMIO_MACCTL) == 0); 
    238  
    239         if (dev->dev->id.revision < 3) { 
    240                 b43_mac_suspend(dev); 
    241                 spin_lock(&phy->lock); 
    242         } else { 
    243                 if (!b43_is_mode(dev->wl, IEEE80211_IF_TYPE_AP)) 
    244                         b43_power_saving_ctl_bits(dev, B43_PS_AWAKE); 
    245         } 
    246         phy->locked = 1; 
    247 } 
    248  
    249 void b43_raw_phy_unlock(struct b43_wldev *dev) 
    250 { 
    251         struct b43_phy *phy = &dev->phy; 
    252  
    253         B43_WARN_ON(!irqs_disabled()); 
    254         if (dev->dev->id.revision < 3) { 
    255                 if (phy->locked) { 
    256                         spin_unlock(&phy->lock); 
    257                         b43_mac_enable(dev); 
    258                 } 
    259         } else { 
    260                 if (!b43_is_mode(dev->wl, IEEE80211_IF_TYPE_AP)) 
    261                         b43_power_saving_ctl_bits(dev, 0); 
    262         } 
    263         phy->locked = 0; 
     231/* Lock the PHY registers against concurrent access from the microcode. 
     232 * This lock is nonrecursive. */ 
     233void b43_phy_lock(struct b43_wldev *dev) 
     234{ 
     235#if B43_DEBUG 
     236        B43_WARN_ON(dev->phy.phy_locked); 
     237        dev->phy.phy_locked = 1; 
     238#endif 
     239        B43_WARN_ON(dev->dev->id.revision < 3); 
     240 
     241        if (!b43_is_mode(dev->wl, IEEE80211_IF_TYPE_AP)) 
     242                b43_power_saving_ctl_bits(dev, B43_PS_AWAKE); 
     243} 
     244 
     245void b43_phy_unlock(struct b43_wldev *dev) 
     246{ 
     247#if B43_DEBUG 
     248        B43_WARN_ON(!dev->phy.phy_locked); 
     249        dev->phy.phy_locked = 0; 
     250#endif 
     251        B43_WARN_ON(dev->dev->id.revision < 3); 
     252 
     253        if (!b43_is_mode(dev->wl, IEEE80211_IF_TYPE_AP)) 
     254                b43_power_saving_ctl_bits(dev, 0); 
    264255} 
    265256 
     
    272263        if (phy->type == B43_PHYTYPE_A) { 
    273264                /* OFDM registers are base-registers for the A-PHY. */ 
    274                 offset &= ~B43_PHYROUTE_OFDM_GPHY; 
    275         } 
    276         if (offset & B43_PHYROUTE_EXT_GPHY) { 
     265                if ((offset & B43_PHYROUTE) == B43_PHYROUTE_OFDM_GPHY) { 
     266                        offset &= ~B43_PHYROUTE; 
     267                        offset |= B43_PHYROUTE_BASE; 
     268                } 
     269        } 
     270 
     271#if B43_DEBUG 
     272        if ((offset & B43_PHYROUTE) == B43_PHYROUTE_EXT_GPHY) { 
    277273                /* Ext-G registers are only available on G-PHYs */ 
    278274                if (phy->type != B43_PHYTYPE_G) { 
    279                         b43dbg(dev->wl, "EXT-G PHY access at " 
    280                                "0x%04X on %u type PHY\n", offset, phy->type); 
    281                 } 
    282         } 
     275                        b43err(dev->wl, "Invalid EXT-G PHY access at " 
     276                               "0x%04X on PHY type %u\n", offset, phy->type); 
     277                        dump_stack(); 
     278                } 
     279        } 
     280        if ((offset & B43_PHYROUTE) == B43_PHYROUTE_N_BMODE) { 
     281                /* N-BMODE registers are only available on N-PHYs */ 
     282                if (phy->type != B43_PHYTYPE_N) { 
     283                        b43err(dev->wl, "Invalid N-BMODE PHY access at " 
     284                               "0x%04X on PHY type %u\n", offset, phy->type); 
     285                        dump_stack(); 
     286                } 
     287        } 
     288#endif /* B43_DEBUG */ 
    283289 
    284290        return offset; 
     
    300306        offset = adjust_phyreg_for_phytype(phy, offset, dev); 
    301307        b43_write16(dev, B43_MMIO_PHY_CONTROL, offset); 
    302         mmiowb(); 
    303308        b43_write16(dev, B43_MMIO_PHY_DATA, val); 
    304309} 
    305310 
    306 static void b43_radio_set_txpower_a(struct b43_wldev *dev, u16 txpower); 
     311void b43_phy_mask(struct b43_wldev *dev, u16 offset, u16 mask) 
     312{ 
     313        b43_phy_write(dev, offset, 
     314                      b43_phy_read(dev, offset) & mask); 
     315} 
     316 
     317void b43_phy_set(struct b43_wldev *dev, u16 offset, u16 set) 
     318{ 
     319        b43_phy_write(dev, offset, 
     320                      b43_phy_read(dev, offset) | set); 
     321} 
     322 
     323void b43_phy_maskset(struct b43_wldev *dev, u16 offset, u16 mask, u16 set) 
     324{ 
     325        b43_phy_write(dev, offset, 
     326                      (b43_phy_read(dev, offset) & mask) | set); 
     327} 
    307328 
    308329/* Adjust the transmission power output (G-PHY) */ 
     
    764785} 
    765786 
    766 static void b43_phy_agcsetup(struct b43_wldev *dev) 
    767 { 
    768         struct b43_phy *phy = &dev->phy; 
    769         u16 offset = 0x0000; 
    770  
    771         if (phy->rev == 1) 
    772                 offset = 0x4C00; 
    773  
    774         b43_ofdmtab_write16(dev, offset, 0, 0x00FE); 
    775         b43_ofdmtab_write16(dev, offset, 1, 0x000D); 
    776         b43_ofdmtab_write16(dev, offset, 2, 0x0013); 
    777         b43_ofdmtab_write16(dev, offset, 3, 0x0019); 
    778  
    779         if (phy->rev == 1) { 
    780                 b43_ofdmtab_write16(dev, 0x1800, 0, 0x2710); 
    781                 b43_ofdmtab_write16(dev, 0x1801, 0, 0x9B83); 
    782                 b43_ofdmtab_write16(dev, 0x1802, 0, 0x9B83); 
    783                 b43_ofdmtab_write16(dev, 0x1803, 0, 0x0F8D); 
    784                 b43_phy_write(dev, 0x0455, 0x0004); 
    785         } 
    786  
    787         b43_phy_write(dev, 0x04A5, (b43_phy_read(dev, 0x04A5) 
    788                                     & 0x00FF) | 0x5700); 
    789         b43_phy_write(dev, 0x041A, (b43_phy_read(dev, 0x041A) 
    790                                     & 0xFF80) | 0x000F); 
    791         b43_phy_write(dev, 0x041A, (b43_phy_read(dev, 0x041A) 
    792                                     & 0xC07F) | 0x2B80); 
    793         b43_phy_write(dev, 0x048C, (b43_phy_read(dev, 0x048C) 
    794                                     & 0xF0FF) | 0x0300); 
    795  
    796         b43_radio_write16(dev, 0x007A, b43_radio_read16(dev, 0x007A) 
    797                           | 0x0008); 
    798  
    799         b43_phy_write(dev, 0x04A0, (b43_phy_read(dev, 0x04A0) 
    800                                     & 0xFFF0) | 0x0008); 
    801         b43_phy_write(dev, 0x04A1, (b43_phy_read(dev, 0x04A1) 
    802                                     & 0xF0FF) | 0x0600); 
    803         b43_phy_write(dev, 0x04A2, (b43_phy_read(dev, 0x04A2) 
    804                                     & 0xF0FF) | 0x0700); 
    805         b43_phy_write(dev, 0x04A0, (b43_phy_read(dev, 0x04A0) 
    806                                     & 0xF0FF) | 0x0100); 
    807  
    808         if (phy->rev == 1) { 
    809                 b43_phy_write(dev, 0x04A2, (b43_phy_read(dev, 0x04A2) 
    810                                             & 0xFFF0) | 0x0007); 
    811         } 
    812  
    813         b43_phy_write(dev, 0x0488, (b43_phy_read(dev, 0x0488) 
    814                                     & 0xFF00) | 0x001C); 
    815         b43_phy_write(dev, 0x0488, (b43_phy_read(dev, 0x0488) 
    816                                     & 0xC0FF) | 0x0200); 
    817         b43_phy_write(dev, 0x0496, (b43_phy_read(dev, 0x0496) 
    818                                     & 0xFF00) | 0x001C); 
    819         b43_phy_write(dev, 0x0489, (b43_phy_read(dev, 0x0489) 
    820                                     & 0xFF00) | 0x0020); 
    821         b43_phy_write(dev, 0x0489, (b43_phy_read(dev, 0x0489) 
    822                                     & 0xC0FF) | 0x0200); 
    823         b43_phy_write(dev, 0x0482, (b43_phy_read(dev, 0x0482) 
    824                                     & 0xFF00) | 0x002E); 
    825         b43_phy_write(dev, 0x0496, (b43_phy_read(dev, 0x0496) 
    826                                     & 0x00FF) | 0x1A00); 
    827         b43_phy_write(dev, 0x0481, (b43_phy_read(dev, 0x0481) 
    828                                     & 0xFF00) | 0x0028); 
    829         b43_phy_write(dev, 0x0481, (b43_phy_read(dev, 0x0481) 
    830                                     & 0x00FF) | 0x2C00); 
    831  
    832         if (phy->rev == 1) { 
    833                 b43_phy_write(dev, 0x0430, 0x092B); 
    834                 b43_phy_write(dev, 0x041B, (b43_phy_read(dev, 0x041B) 
    835                                             & 0xFFE1) | 0x0002); 
     787static void b43_phy_rssiagc(struct b43_wldev *dev, u8 enable) 
     788{ 
     789        int i; 
     790 
     791        if (dev->phy.rev < 3) { 
     792                if (enable) 
     793                        for (i = 0; i < B43_TAB_RSSIAGC1_SIZE; i++) { 
     794                                b43_ofdmtab_write16(dev, 
     795                                        B43_OFDMTAB_LNAHPFGAIN1, i, 0xFFF8); 
     796                                b43_ofdmtab_write16(dev, 
     797                                        B43_OFDMTAB_WRSSI, i, 0xFFF8); 
     798                        } 
     799                else 
     800                        for (i = 0; i < B43_TAB_RSSIAGC1_SIZE; i++) { 
     801                                b43_ofdmtab_write16(dev, 
     802                                        B43_OFDMTAB_LNAHPFGAIN1, i, b43_tab_rssiagc1[i]); 
     803                                b43_ofdmtab_write16(dev, 
     804                                        B43_OFDMTAB_WRSSI, i, b43_tab_rssiagc1[i]); 
     805                        } 
    836806        } else { 
    837                 b43_phy_write(dev, 0x041B, b43_phy_read(dev, 0x041B) 
    838                               & 0xFFE1); 
    839                 b43_phy_write(dev, 0x041F, 0x287A); 
    840                 b43_phy_write(dev, 0x0420, (b43_phy_read(dev, 0x0420) 
    841                                             & 0xFFF0) | 0x0004); 
    842         } 
    843  
    844         if (phy->rev >= 6) { 
    845                 b43_phy_write(dev, 0x0422, 0x287A); 
    846                 b43_phy_write(dev, 0x0420, (b43_phy_read(dev, 0x0420) 
    847                                             & 0x0FFF) | 0x3000); 
    848         } 
    849  
    850         b43_phy_write(dev, 0x04A8, (b43_phy_read(dev, 0x04A8) 
    851                                     & 0x8080) | 0x7874); 
    852         b43_phy_write(dev, 0x048E, 0x1C00); 
    853  
    854         offset = 0x0800; 
    855         if (phy->rev == 1) { 
    856                 offset = 0x5400; 
    857                 b43_phy_write(dev, 0x04AB, (b43_phy_read(dev, 0x04AB) 
    858                                             & 0xF0FF) | 0x0600); 
    859                 b43_phy_write(dev, 0x048B, 0x005E); 
    860                 b43_phy_write(dev, 0x048C, (b43_phy_read(dev, 0x048C) 
    861                                             & 0xFF00) | 0x001E); 
    862                 b43_phy_write(dev, 0x048D, 0x0002); 
    863         } 
    864         b43_ofdmtab_write16(dev, offset, 0, 0x00); 
    865         b43_ofdmtab_write16(dev, offset, 1, 0x07); 
    866         b43_ofdmtab_write16(dev, offset, 2, 0x10); 
    867         b43_ofdmtab_write16(dev, offset, 3, 0x1C); 
    868  
    869         if (phy->rev >= 6) { 
    870                 b43_phy_write(dev, 0x0426, b43_phy_read(dev, 0x0426) 
    871                               & 0xFFFC); 
    872                 b43_phy_write(dev, 0x0426, b43_phy_read(dev, 0x0426) 
    873                               & 0xEFFF); 
    874         } 
    875 } 
    876  
    877 static void b43_phy_setupg(struct b43_wldev *dev) 
    878 { 
    879         struct ssb_bus *bus = dev->dev->bus; 
    880         struct b43_phy *phy = &dev->phy; 
    881         u16 i; 
    882  
    883         B43_WARN_ON(phy->type != B43_PHYTYPE_G); 
    884         if (phy->rev == 1) { 
    885                 b43_phy_write(dev, 0x0406, 0x4F19); 
    886                 b43_phy_write(dev, B43_PHY_G_CRS, 
    887                               (b43_phy_read(dev, B43_PHY_G_CRS) & 0xFC3F) | 
    888                               0x0340); 
    889                 b43_phy_write(dev, 0x042C, 0x005A); 
    890                 b43_phy_write(dev, 0x0427, 0x001A); 
    891  
    892                 for (i = 0; i < B43_TAB_FINEFREQG_SIZE; i++) 
    893                         b43_ofdmtab_write16(dev, 0x5800, i, 
    894                                             b43_tab_finefreqg[i]); 
    895                 for (i = 0; i < B43_TAB_NOISEG1_SIZE; i++) 
    896                         b43_ofdmtab_write16(dev, 0x1800, i, b43_tab_noiseg1[i]); 
    897                 for (i = 0; i < B43_TAB_ROTOR_SIZE; i++) 
    898                         b43_ofdmtab_write16(dev, 0x2000, i, b43_tab_rotor[i]); 
    899         } else { 
    900                 /* nrssi values are signed 6-bit values. Not sure why we write 0x7654 here... */ 
    901                 b43_nrssi_hw_write(dev, 0xBA98, (s16) 0x7654); 
    902  
    903                 if (phy->rev == 2) { 
    904                         b43_phy_write(dev, 0x04C0, 0x1861); 
    905                         b43_phy_write(dev, 0x04C1, 0x0271); 
    906                 } else if (phy->rev > 2) { 
    907                         b43_phy_write(dev, 0x04C0, 0x0098); 
    908                         b43_phy_write(dev, 0x04C1, 0x0070); 
    909                         b43_phy_write(dev, 0x04C9, 0x0080); 
    910                 } 
    911                 b43_phy_write(dev, 0x042B, b43_phy_read(dev, 0x042B) | 0x800); 
    912  
    913                 for (i = 0; i < 64; i++) 
    914                         b43_ofdmtab_write16(dev, 0x4000, i, i); 
    915                 for (i = 0; i < B43_TAB_NOISEG2_SIZE; i++) 
    916                         b43_ofdmtab_write16(dev, 0x1800, i, b43_tab_noiseg2[i]); 
    917         } 
    918  
    919         if (phy->rev <= 2) 
    920                 for (i = 0; i < B43_TAB_NOISESCALEG_SIZE; i++) 
    921                         b43_ofdmtab_write16(dev, 0x1400, i, 
    922                                             b43_tab_noisescaleg1[i]); 
    923         else if ((phy->rev >= 7) && (b43_phy_read(dev, 0x0449) & 0x0200)) 
    924                 for (i = 0; i < B43_TAB_NOISESCALEG_SIZE; i++) 
    925                         b43_ofdmtab_write16(dev, 0x1400, i, 
    926                                             b43_tab_noisescaleg3[i]); 
    927         else 
    928                 for (i = 0; i < B43_TAB_NOISESCALEG_SIZE; i++) 
    929                         b43_ofdmtab_write16(dev, 0x1400, i, 
    930                                             b43_tab_noisescaleg2[i]); 
    931  
    932         if (phy->rev == 2) 
    933                 for (i = 0; i < B43_TAB_SIGMASQR_SIZE; i++) 
    934                         b43_ofdmtab_write16(dev, 0x5000, i, 
    935                                             b43_tab_sigmasqr1[i]); 
    936         else if ((phy->rev > 2) && (phy->rev <= 8)) 
    937                 for (i = 0; i < B43_TAB_SIGMASQR_SIZE; i++) 
    938                         b43_ofdmtab_write16(dev, 0x5000, i, 
    939                                             b43_tab_sigmasqr2[i]); 
    940  
    941         if (phy->rev == 1) { 
    942                 for (i = 0; i < B43_TAB_RETARD_SIZE; i++) 
    943                         b43_ofdmtab_write32(dev, 0x2400, i, b43_tab_retard[i]); 
    944                 for (i = 4; i < 20; i++) 
    945                         b43_ofdmtab_write16(dev, 0x5400, i, 0x0020); 
    946                 b43_phy_agcsetup(dev); 
    947  
    948                 if ((bus->boardinfo.vendor == SSB_BOARDVENDOR_BCM) && 
    949                     (bus->boardinfo.type == SSB_BOARD_BU4306) && 
    950                     (bus->boardinfo.rev == 0x17)) 
    951                         return; 
    952  
    953                 b43_ofdmtab_write16(dev, 0x5001, 0, 0x0002); 
    954                 b43_ofdmtab_write16(dev, 0x5002, 0, 0x0001); 
    955         } else { 
    956                 for (i = 0; i < 0x20; i++) 
    957                         b43_ofdmtab_write16(dev, 0x1000, i, 0x0820); 
    958                 b43_phy_agcsetup(dev); 
    959                 b43_phy_read(dev, 0x0400);      /* dummy read */ 
    960                 b43_phy_write(dev, 0x0403, 0x1000); 
    961                 b43_ofdmtab_write16(dev, 0x3C02, 0, 0x000F); 
    962                 b43_ofdmtab_write16(dev, 0x3C03, 0, 0x0014); 
    963  
    964                 if ((bus->boardinfo.vendor == SSB_BOARDVENDOR_BCM) && 
    965                     (bus->boardinfo.type == SSB_BOARD_BU4306) && 
    966                     (bus->boardinfo.rev == 0x17)) 
    967                         return; 
    968  
    969                 b43_ofdmtab_write16(dev, 0x0401, 0, 0x0002); 
    970                 b43_ofdmtab_write16(dev, 0x0402, 0, 0x0001); 
    971         } 
    972 } 
    973  
    974 /* Initialize the noisescaletable for APHY */ 
    975 static void b43_phy_init_noisescaletbl(struct b43_wldev *dev) 
    976 { 
    977         struct b43_phy *phy = &dev->phy; 
     807                if (enable) 
     808                        for (i = 0; i < B43_TAB_RSSIAGC1_SIZE; i++) 
     809                                b43_ofdmtab_write16(dev, 
     810                                        B43_OFDMTAB_WRSSI, i, 0x0820); 
     811                else 
     812                        for (i = 0; i < B43_TAB_RSSIAGC2_SIZE; i++) 
     813                                b43_ofdmtab_write16(dev, 
     814                                        B43_OFDMTAB_WRSSI, i, b43_tab_rssiagc2[i]); 
     815        } 
     816} 
     817 
     818static void b43_phy_ww(struct b43_wldev *dev) 
     819{ 
     820        u16 b, curr_s, best_s = 0xFFFF; 
    978821        int i; 
    979822 
    980         for (i = 0; i < 12; i++) { 
    981                 if (phy->rev == 2) 
    982                         b43_ofdmtab_write16(dev, 0x1400, i, 0x6767); 
    983                 else 
    984                         b43_ofdmtab_write16(dev, 0x1400, i, 0x2323); 
    985         } 
    986         if (phy->rev == 2) 
    987                 b43_ofdmtab_write16(dev, 0x1400, i, 0x6700); 
    988         else 
    989                 b43_ofdmtab_write16(dev, 0x1400, i, 0x2300); 
    990         for (i = 0; i < 11; i++) { 
    991                 if (phy->rev == 2) 
    992                         b43_ofdmtab_write16(dev, 0x1400, i, 0x6767); 
    993                 else 
    994                         b43_ofdmtab_write16(dev, 0x1400, i, 0x2323); 
    995         } 
    996         if (phy->rev == 2) 
    997                 b43_ofdmtab_write16(dev, 0x1400, i, 0x0067); 
    998         else 
    999                 b43_ofdmtab_write16(dev, 0x1400, i, 0x0023); 
    1000 } 
    1001  
    1002 static void b43_phy_setupa(struct b43_wldev *dev) 
    1003 { 
    1004         struct b43_phy *phy = &dev->phy; 
    1005         u16 i; 
    1006  
    1007         B43_WARN_ON(phy->type != B43_PHYTYPE_A); 
    1008         switch (phy->rev) { 
    1009         case 2: 
    1010                 b43_phy_write(dev, 0x008E, 0x3800); 
    1011                 b43_phy_write(dev, 0x0035, 0x03FF); 
    1012                 b43_phy_write(dev, 0x0036, 0x0400); 
    1013  
    1014                 b43_ofdmtab_write16(dev, 0x3807, 0, 0x0051); 
    1015  
    1016                 b43_phy_write(dev, 0x001C, 0x0FF9); 
    1017                 b43_phy_write(dev, 0x0020, b43_phy_read(dev, 0x0020) & 0xFF0F); 
    1018                 b43_ofdmtab_write16(dev, 0x3C0C, 0, 0x07BF); 
    1019                 b43_radio_write16(dev, 0x0002, 0x07BF); 
    1020  
    1021                 b43_phy_write(dev, 0x0024, 0x4680); 
    1022                 b43_phy_write(dev, 0x0020, 0x0003); 
    1023                 b43_phy_write(dev, 0x001D, 0x0F40); 
    1024                 b43_phy_write(dev, 0x001F, 0x1C00); 
    1025  
    1026                 b43_phy_write(dev, 0x002A, (b43_phy_read(dev, 0x002A) 
    1027                                             & 0x00FF) | 0x0400); 
    1028                 b43_phy_write(dev, 0x002B, b43_phy_read(dev, 0x002B) 
    1029                               & 0xFBFF); 
    1030                 b43_phy_write(dev, 0x008E, 0x58C1); 
    1031  
    1032                 b43_ofdmtab_write16(dev, 0x0803, 0, 0x000F); 
    1033                 b43_ofdmtab_write16(dev, 0x0804, 0, 0x001F); 
    1034                 b43_ofdmtab_write16(dev, 0x0805, 0, 0x002A); 
    1035                 b43_ofdmtab_write16(dev, 0x0805, 0, 0x0030); 
    1036                 b43_ofdmtab_write16(dev, 0x0807, 0, 0x003A); 
    1037  
    1038                 b43_ofdmtab_write16(dev, 0x0000, 0, 0x0013); 
    1039                 b43_ofdmtab_write16(dev, 0x0000, 1, 0x0013); 
    1040                 b43_ofdmtab_write16(dev, 0x0000, 2, 0x0013); 
    1041                 b43_ofdmtab_write16(dev, 0x0000, 3, 0x0013); 
    1042                 b43_ofdmtab_write16(dev, 0x0000, 4, 0x0015); 
    1043                 b43_ofdmtab_write16(dev, 0x0000, 5, 0x0015); 
    1044                 b43_ofdmtab_write16(dev, 0x0000, 6, 0x0019); 
    1045  
    1046                 b43_ofdmtab_write16(dev, 0x0404, 0, 0x0003); 
    1047                 b43_ofdmtab_write16(dev, 0x0405, 0, 0x0003); 
    1048                 b43_ofdmtab_write16(dev, 0x0406, 0, 0x0007); 
    1049  
    1050                 for (i = 0; i < 16; i++) 
    1051                         b43_ofdmtab_write16(dev, 0x4000, i, (0x8 + i) & 0x000F); 
    1052  
    1053                 b43_ofdmtab_write16(dev, 0x3003, 0, 0x1044); 
    1054                 b43_ofdmtab_write16(dev, 0x3004, 0, 0x7201); 
    1055                 b43_ofdmtab_write16(dev, 0x3006, 0, 0x0040); 
    1056                 b43_ofdmtab_write16(dev, 0x3001, 0, 
    1057                                     (b43_ofdmtab_read16(dev, 0x3001, 0) & 
    1058                                      0x0010) | 0x0008); 
    1059  
    1060                 for (i = 0; i < B43_TAB_FINEFREQA_SIZE; i++) 
    1061                         b43_ofdmtab_write16(dev, 0x5800, i, 
    1062                                             b43_tab_finefreqa[i]); 
    1063                 for (i = 0; i < B43_TAB_NOISEA2_SIZE; i++) 
    1064                         b43_ofdmtab_write16(dev, 0x1800, i, b43_tab_noisea2[i]); 
    1065                 for (i = 0; i < B43_TAB_ROTOR_SIZE; i++) 
    1066                         b43_ofdmtab_write32(dev, 0x2000, i, b43_tab_rotor[i]); 
    1067                 b43_phy_init_noisescaletbl(dev); 
    1068                 for (i = 0; i < B43_TAB_RETARD_SIZE; i++) 
    1069                         b43_ofdmtab_write32(dev, 0x2400, i, b43_tab_retard[i]); 
    1070                 break; 
    1071         case 3: 
    1072                 for (i = 0; i < 64; i++) 
    1073                         b43_ofdmtab_write16(dev, 0x4000, i, i); 
    1074  
    1075                 b43_ofdmtab_write16(dev, 0x3807, 0, 0x0051); 
    1076  
    1077                 b43_phy_write(dev, 0x001C, 0x0FF9); 
    1078                 b43_phy_write(dev, 0x0020, b43_phy_read(dev, 0x0020) & 0xFF0F); 
    1079                 b43_radio_write16(dev, 0x0002, 0x07BF); 
    1080  
    1081                 b43_phy_write(dev, 0x0024, 0x4680); 
    1082                 b43_phy_write(dev, 0x0020, 0x0003); 
    1083                 b43_phy_write(dev, 0x001D, 0x0F40); 
    1084                 b43_phy_write(dev, 0x001F, 0x1C00); 
    1085                 b43_phy_write(dev, 0x002A, (b43_phy_read(dev, 0x002A) 
    1086                                             & 0x00FF) | 0x0400); 
    1087  
    1088                 b43_ofdmtab_write16(dev, 0x3000, 1, 
    1089                                     (b43_ofdmtab_read16(dev, 0x3000, 1) 
    1090                                      & 0x0010) | 0x0008); 
    1091                 for (i = 0; i < B43_TAB_NOISEA3_SIZE; i++) { 
    1092                         b43_ofdmtab_write16(dev, 0x1800, i, b43_tab_noisea3[i]); 
    1093                 } 
    1094                 b43_phy_init_noisescaletbl(dev); 
    1095                 for (i = 0; i < B43_TAB_SIGMASQR_SIZE; i++) { 
    1096                         b43_ofdmtab_write16(dev, 0x5000, i, 
    1097                                             b43_tab_sigmasqr1[i]); 
    1098                 } 
    1099  
    1100                 b43_phy_write(dev, 0x0003, 0x1808); 
    1101  
    1102                 b43_ofdmtab_write16(dev, 0x0803, 0, 0x000F); 
    1103                 b43_ofdmtab_write16(dev, 0x0804, 0, 0x001F); 
    1104                 b43_ofdmtab_write16(dev, 0x0805, 0, 0x002A); 
    1105                 b43_ofdmtab_write16(dev, 0x0805, 0, 0x0030); 
    1106                 b43_ofdmtab_write16(dev, 0x0807, 0, 0x003A); 
    1107  
    1108                 b43_ofdmtab_write16(dev, 0x0000, 0, 0x0013); 
    1109                 b43_ofdmtab_write16(dev, 0x0001, 0, 0x0013); 
    1110                 b43_ofdmtab_write16(dev, 0x0002, 0, 0x0013); 
    1111                 b43_ofdmtab_write16(dev, 0x0003, 0, 0x0013); 
    1112                 b43_ofdmtab_write16(dev, 0x0004, 0, 0x0015); 
    1113                 b43_ofdmtab_write16(dev, 0x0005, 0, 0x0015); 
    1114                 b43_ofdmtab_write16(dev, 0x0006, 0, 0x0019); 
    1115  
    1116                 b43_ofdmtab_write16(dev, 0x0404, 0, 0x0003); 
    1117                 b43_ofdmtab_write16(dev, 0x0405, 0, 0x0003); 
    1118                 b43_ofdmtab_write16(dev, 0x0406, 0, 0x0007); 
    1119  
    1120                 b43_ofdmtab_write16(dev, 0x3C02, 0, 0x000F); 
    1121                 b43_ofdmtab_write16(dev, 0x3C03, 0, 0x0014); 
    1122                 break; 
    1123         default: 
    1124                 B43_WARN_ON(1); 
    1125         } 
     823        b43_phy_write(dev, B43_PHY_CRS0, 
     824                b43_phy_read(dev, B43_PHY_CRS0) & ~B43_PHY_CRS0_EN); 
     825        b43_phy_write(dev, B43_PHY_OFDM(0x1B), 
     826                b43_phy_read(dev, B43_PHY_OFDM(0x1B)) | 0x1000); 
     827        b43_phy_write(dev, B43_PHY_OFDM(0x82), 
     828                (b43_phy_read(dev, B43_PHY_OFDM(0x82)) & 0xF0FF) | 0x0300); 
     829        b43_radio_write16(dev, 0x0009, 
     830                b43_radio_read16(dev, 0x0009) | 0x0080); 
     831        b43_radio_write16(dev, 0x0012, 
     832                (b43_radio_read16(dev, 0x0012) & 0xFFFC) | 0x0002); 
     833        b43_wa_initgains(dev); 
     834        b43_phy_write(dev, B43_PHY_OFDM(0xBA), 0x3ED5); 
     835        b = b43_phy_read(dev, B43_PHY_PWRDOWN); 
     836        b43_phy_write(dev, B43_PHY_PWRDOWN, (b & 0xFFF8) | 0x0005); 
     837        b43_radio_write16(dev, 0x0004, 
     838                b43_radio_read16(dev, 0x0004) | 0x0004); 
     839        for (i = 0x10; i <= 0x20; i++) { 
     840                b43_radio_write16(dev, 0x0013, i); 
     841                curr_s = b43_phy_read(dev, B43_PHY_OTABLEQ) & 0x00FF; 
     842                if (!curr_s) { 
     843                        best_s = 0x0000; 
     844                        break; 
     845                } else if (curr_s >= 0x0080) 
     846                        curr_s = 0x0100 - curr_s; 
     847                if (curr_s < best_s) 
     848                        best_s = curr_s; 
     849        } 
     850        b43_phy_write(dev, B43_PHY_PWRDOWN, b); 
     851        b43_radio_write16(dev, 0x0004, 
     852                b43_radio_read16(dev, 0x0004) & 0xFFFB); 
     853        b43_radio_write16(dev, 0x0013, best_s); 
     854        b43_ofdmtab_write16(dev, B43_OFDMTAB_AGC1_R1, 0, 0xFFEC); 
     855        b43_phy_write(dev, B43_PHY_OFDM(0xB7), 0x1E80); 
     856        b43_phy_write(dev, B43_PHY_OFDM(0xB6), 0x1C00); 
     857        b43_phy_write(dev, B43_PHY_OFDM(0xB5), 0x0EC0); 
     858        b43_phy_write(dev, B43_PHY_OFDM(0xB2), 0x00C0); 
     859        b43_phy_write(dev, B43_PHY_OFDM(0xB9), 0x1FFF); 
     860        b43_phy_write(dev, B43_PHY_OFDM(0xBB), 
     861                (b43_phy_read(dev, B43_PHY_OFDM(0xBB)) & 0xF000) | 0x0053); 
     862        b43_phy_write(dev, B43_PHY_OFDM61, 
     863                (b43_phy_read(dev, B43_PHY_OFDM61 & 0xFE1F)) | 0x0120); 
     864        b43_phy_write(dev, B43_PHY_OFDM(0x13), 
     865              &