source: trunk/package/mac80211/patches/820-b43-backport.patch @ 27734

Last change on this file since 27734 was 27734, checked in by hauke, 5 years ago

mca80211: add support for b43 on bcma bus.

This makes b43 work on broadcom SoCs using bcma as system bus.

File size: 82.6 KB
  • drivers/net/wireless/b43/Kconfig

    a b config B43_SDIO 
    9090 
    9191#Data transfers to the device via PIO. We want it as a fallback even 
    9292# if we can do DMA. 
     93config B43_BCMA_PIO 
     94        bool 
     95        depends on B43_BCMA 
     96        select BCMA_BLOCKIO 
     97        default y 
     98 
    9399config B43_PIO 
    94100        bool 
    95101        depends on B43 
    config B43_PHY_HT 
    125131 
    126132          Say N, this is BROKEN and crashes driver. 
    127133 
     134config B43_PHY_LCN 
     135        bool "Support for LCN-PHY devices (BROKEN)" 
     136        depends on B43 && BROKEN 
     137        ---help--- 
     138          Support for the LCN-PHY. 
     139 
     140          Say N, this is BROKEN and crashes driver. 
     141 
    128142# This config option automatically enables b43 LEDS support, 
    129143# if it's possible. 
    130144config B43_LEDS 
  • drivers/net/wireless/b43/Makefile

    a b b43-$(CONFIG_B43_PHY_N) += phy_n.o 
    1111b43-$(CONFIG_B43_PHY_LP)        += phy_lp.o 
    1212b43-$(CONFIG_B43_PHY_LP)        += tables_lpphy.o 
    1313b43-$(CONFIG_B43_PHY_HT)        += phy_ht.o 
     14b43-$(CONFIG_B43_PHY_HT)        += tables_phy_ht.o 
    1415b43-$(CONFIG_B43_PHY_HT)        += radio_2059.o 
     16b43-$(CONFIG_B43_PHY_LCN)       += phy_lcn.o tables_phy_lcn.o 
    1517b43-y                           += sysfs.o 
    1618b43-y                           += xmit.o 
    1719b43-y                           += lo.o 
  • drivers/net/wireless/b43/b43.h

    a b enum { 
    433433#define  B43_BCMA_IOCTL_PHY_BW_40MHZ    0x00000080      /* 40 MHz bandwidth, 160 MHz PHY */ 
    434434#define B43_BCMA_IOCTL_GMODE            0x00002000      /* G Mode Enable */ 
    435435 
     436/* BCMA 802.11 core specific IO status (BCMA_IOST) flags */ 
     437#define B43_BCMA_IOST_2G_PHY            0x00000001      /* 2.4G capable phy */ 
     438#define B43_BCMA_IOST_5G_PHY            0x00000002      /* 5G capable phy */ 
     439#define B43_BCMA_IOST_FASTCLKA          0x00000004      /* Fast Clock Available */ 
     440#define B43_BCMA_IOST_DUALB_PHY         0x00000008      /* Dualband phy */ 
     441 
    436442/* 802.11 core specific TM State Low (SSB_TMSLOW) flags */ 
    437443#define B43_TMSLOW_GMODE                0x20000000      /* G Mode Enable */ 
    438444#define B43_TMSLOW_PHY_BANDWIDTH        0x00C00000      /* PHY band width and clock speed mask (N-PHY only) */ 
    struct b43_dma { 
    588594        struct b43_dmaring *rx_ring; 
    589595 
    590596        u32 translation; /* Routing bits */ 
     597        bool parity; /* Check for parity */ 
    591598}; 
    592599 
    593600struct b43_pio_txqueue; 
    enum { 
    726733 
    727734/* Data structure for one wireless device (802.11 core) */ 
    728735struct b43_wldev { 
    729         struct ssb_device *sdev; /* TODO: remove when b43_bus_dev is ready */ 
    730736        struct b43_bus_dev *dev; 
    731737        struct b43_wl *wl; 
    732738 
  • drivers/net/wireless/b43/bus.c

    a b  
    2323#include "b43.h" 
    2424#include "bus.h" 
    2525 
     26/* BCMA */ 
     27#ifdef CONFIG_B43_BCMA 
     28static int b43_bus_bcma_bus_may_powerdown(struct b43_bus_dev *dev) 
     29{ 
     30        return 0; /* bcma_bus_may_powerdown(dev->bdev->bus); */ 
     31} 
     32static int b43_bus_bcma_bus_powerup(struct b43_bus_dev *dev, 
     33                                          bool dynamic_pctl) 
     34{ 
     35        return 0; /* bcma_bus_powerup(dev->sdev->bus, dynamic_pctl); */ 
     36} 
     37static int b43_bus_bcma_device_is_enabled(struct b43_bus_dev *dev) 
     38{ 
     39        return bcma_core_is_enabled(dev->bdev); 
     40} 
     41static void b43_bus_bcma_device_enable(struct b43_bus_dev *dev, 
     42                                             u32 core_specific_flags) 
     43{ 
     44        bcma_core_enable(dev->bdev, core_specific_flags); 
     45} 
     46static void b43_bus_bcma_device_disable(struct b43_bus_dev *dev, 
     47                                              u32 core_specific_flags) 
     48{ 
     49        bcma_core_disable(dev->bdev, core_specific_flags); 
     50} 
     51static u16 b43_bus_bcma_read16(struct b43_bus_dev *dev, u16 offset) 
     52{ 
     53        return bcma_read16(dev->bdev, offset); 
     54} 
     55static u32 b43_bus_bcma_read32(struct b43_bus_dev *dev, u16 offset) 
     56{ 
     57        return bcma_read32(dev->bdev, offset); 
     58} 
     59static 
     60void b43_bus_bcma_write16(struct b43_bus_dev *dev, u16 offset, u16 value) 
     61{ 
     62        bcma_write16(dev->bdev, offset, value); 
     63} 
     64static 
     65void b43_bus_bcma_write32(struct b43_bus_dev *dev, u16 offset, u32 value) 
     66{ 
     67        bcma_write32(dev->bdev, offset, value); 
     68} 
     69static 
     70void b43_bus_bcma_block_read(struct b43_bus_dev *dev, void *buffer, 
     71                             size_t count, u16 offset, u8 reg_width) 
     72{ 
     73        bcma_block_read(dev->bdev, buffer, count, offset, reg_width); 
     74} 
     75static 
     76void b43_bus_bcma_block_write(struct b43_bus_dev *dev, const void *buffer, 
     77                              size_t count, u16 offset, u8 reg_width) 
     78{ 
     79        bcma_block_write(dev->bdev, buffer, count, offset, reg_width); 
     80} 
     81 
     82struct b43_bus_dev *b43_bus_dev_bcma_init(struct bcma_device *core) 
     83{ 
     84        struct b43_bus_dev *dev = kzalloc(sizeof(*dev), GFP_KERNEL); 
     85        if (!dev) 
     86                return NULL; 
     87 
     88        dev->bus_type = B43_BUS_BCMA; 
     89        dev->bdev = core; 
     90 
     91        dev->bus_may_powerdown = b43_bus_bcma_bus_may_powerdown; 
     92        dev->bus_powerup = b43_bus_bcma_bus_powerup; 
     93        dev->device_is_enabled = b43_bus_bcma_device_is_enabled; 
     94        dev->device_enable = b43_bus_bcma_device_enable; 
     95        dev->device_disable = b43_bus_bcma_device_disable; 
     96 
     97        dev->read16 = b43_bus_bcma_read16; 
     98        dev->read32 = b43_bus_bcma_read32; 
     99        dev->write16 = b43_bus_bcma_write16; 
     100        dev->write32 = b43_bus_bcma_write32; 
     101        dev->block_read = b43_bus_bcma_block_read; 
     102        dev->block_write = b43_bus_bcma_block_write; 
     103 
     104        dev->dev = &core->dev; 
     105        dev->dma_dev = core->dma_dev; 
     106        dev->irq = core->irq; 
     107 
     108        /* 
     109        dev->board_vendor = core->bus->boardinfo.vendor; 
     110        dev->board_type = core->bus->boardinfo.type; 
     111        dev->board_rev = core->bus->boardinfo.rev; 
     112        */ 
     113 
     114        dev->chip_id = core->bus->chipinfo.id; 
     115        dev->chip_rev = core->bus->chipinfo.rev; 
     116        dev->chip_pkg = core->bus->chipinfo.pkg; 
     117 
     118        dev->bus_sprom = &core->bus->sprom; 
     119 
     120        dev->core_id = core->id.id; 
     121        dev->core_rev = core->id.rev; 
     122 
     123        return dev; 
     124} 
     125#endif /* CONFIG_B43_BCMA */ 
    26126 
    27127/* SSB */ 
    28128#ifdef CONFIG_B43_SSB 
    29 static inline int b43_bus_ssb_bus_may_powerdown(struct b43_bus_dev *dev) 
     129static int b43_bus_ssb_bus_may_powerdown(struct b43_bus_dev *dev) 
    30130{ 
    31131        return ssb_bus_may_powerdown(dev->sdev->bus); 
    32132} 
    33 static inline int b43_bus_ssb_bus_powerup(struct b43_bus_dev *dev, 
     133static int b43_bus_ssb_bus_powerup(struct b43_bus_dev *dev, 
    34134                                          bool dynamic_pctl) 
    35135{ 
    36136        return ssb_bus_powerup(dev->sdev->bus, dynamic_pctl); 
    37137} 
    38 static inline int b43_bus_ssb_device_is_enabled(struct b43_bus_dev *dev) 
     138static int b43_bus_ssb_device_is_enabled(struct b43_bus_dev *dev) 
    39139{ 
    40140        return ssb_device_is_enabled(dev->sdev); 
    41141} 
    42 static inline void b43_bus_ssb_device_enable(struct b43_bus_dev *dev, 
     142static void b43_bus_ssb_device_enable(struct b43_bus_dev *dev, 
    43143                                             u32 core_specific_flags) 
    44144{ 
    45145        ssb_device_enable(dev->sdev, core_specific_flags); 
    46146} 
    47 static inline void b43_bus_ssb_device_disable(struct b43_bus_dev *dev, 
     147static void b43_bus_ssb_device_disable(struct b43_bus_dev *dev, 
    48148                                              u32 core_specific_flags) 
    49149{ 
    50150        ssb_device_disable(dev->sdev, core_specific_flags); 
    51151} 
    52152 
    53 static inline u16 b43_bus_ssb_read16(struct b43_bus_dev *dev, u16 offset) 
     153static u16 b43_bus_ssb_read16(struct b43_bus_dev *dev, u16 offset) 
    54154{ 
    55155        return ssb_read16(dev->sdev, offset); 
    56156} 
    57 static inline u32 b43_bus_ssb_read32(struct b43_bus_dev *dev, u16 offset) 
     157static u32 b43_bus_ssb_read32(struct b43_bus_dev *dev, u16 offset) 
    58158{ 
    59159        return ssb_read32(dev->sdev, offset); 
    60160} 
    61 static inline 
    62 void b43_bus_ssb_write16(struct b43_bus_dev *dev, u16 offset, u16 value) 
     161static void b43_bus_ssb_write16(struct b43_bus_dev *dev, u16 offset, u16 value) 
    63162{ 
    64163        ssb_write16(dev->sdev, offset, value); 
    65164} 
    66 static inline 
    67 void b43_bus_ssb_write32(struct b43_bus_dev *dev, u16 offset, u32 value) 
     165static void b43_bus_ssb_write32(struct b43_bus_dev *dev, u16 offset, u32 value) 
    68166{ 
    69167        ssb_write32(dev->sdev, offset, value); 
    70168} 
    71 static inline 
    72 void b43_bus_ssb_block_read(struct b43_bus_dev *dev, void *buffer, 
    73                             size_t count, u16 offset, u8 reg_width) 
     169static void b43_bus_ssb_block_read(struct b43_bus_dev *dev, void *buffer, 
     170                                   size_t count, u16 offset, u8 reg_width) 
    74171{ 
    75172        ssb_block_read(dev->sdev, buffer, count, offset, reg_width); 
    76173} 
    77 static inline 
     174static 
    78175void b43_bus_ssb_block_write(struct b43_bus_dev *dev, const void *buffer, 
    79176                             size_t count, u16 offset, u8 reg_width) 
    80177{ 
    struct b43_bus_dev *b43_bus_dev_ssb_init 
    125222        return dev; 
    126223} 
    127224#endif /* CONFIG_B43_SSB */ 
     225 
     226void *b43_bus_get_wldev(struct b43_bus_dev *dev) 
     227{ 
     228        switch (dev->bus_type) { 
     229#ifdef CONFIG_B43_BCMA 
     230        case B43_BUS_BCMA: 
     231                return bcma_get_drvdata(dev->bdev); 
     232#endif 
     233#ifdef CONFIG_B43_SSB 
     234        case B43_BUS_SSB: 
     235                return ssb_get_drvdata(dev->sdev); 
     236#endif 
     237        } 
     238        return NULL; 
     239} 
     240 
     241void b43_bus_set_wldev(struct b43_bus_dev *dev, void *wldev) 
     242{ 
     243        switch (dev->bus_type) { 
     244#ifdef CONFIG_B43_BCMA 
     245        case B43_BUS_BCMA: 
     246                bcma_set_drvdata(dev->bdev, wldev); 
     247#endif 
     248#ifdef CONFIG_B43_SSB 
     249        case B43_BUS_SSB: 
     250                ssb_set_drvdata(dev->sdev, wldev); 
     251#endif 
     252        } 
     253} 
  • drivers/net/wireless/b43/bus.h

    a b  
    22#define B43_BUS_H_ 
    33 
    44enum b43_bus_type { 
     5#ifdef CONFIG_B43_BCMA 
     6        B43_BUS_BCMA, 
     7#endif 
    58        B43_BUS_SSB, 
    69}; 
    710 
    811struct b43_bus_dev { 
    912        enum b43_bus_type bus_type; 
    1013        union { 
     14                struct bcma_device *bdev; 
    1115                struct ssb_device *sdev; 
    1216        }; 
    1317 
    static inline bool b43_bus_host_is_sdio( 
    5761                dev->sdev->bus->bustype == SSB_BUSTYPE_SDIO); 
    5862} 
    5963 
     64struct b43_bus_dev *b43_bus_dev_bcma_init(struct bcma_device *core); 
    6065struct b43_bus_dev *b43_bus_dev_ssb_init(struct ssb_device *sdev); 
    6166 
     67void *b43_bus_get_wldev(struct b43_bus_dev *dev); 
     68void b43_bus_set_wldev(struct b43_bus_dev *dev, void *data); 
     69 
    6270#endif /* B43_BUS_H_ */ 
  • drivers/net/wireless/b43/dma.c

    a b static void op64_fill_descriptor(struct 
    174174        addrhi = (((u64) dmaaddr >> 32) & ~SSB_DMA_TRANSLATION_MASK); 
    175175        addrext = (((u64) dmaaddr >> 32) & SSB_DMA_TRANSLATION_MASK) 
    176176            >> SSB_DMA_TRANSLATION_SHIFT; 
    177         addrhi |= (ring->dev->dma.translation << 1); 
     177        addrhi |= ring->dev->dma.translation; 
    178178        if (slot == ring->nr_slots - 1) 
    179179                ctl0 |= B43_DMA64_DCTL0_DTABLEEND; 
    180180        if (start) 
    static int dmacontroller_setup(struct b4 
    659659        u32 value; 
    660660        u32 addrext; 
    661661        u32 trans = ring->dev->dma.translation; 
     662        bool parity = ring->dev->dma.parity; 
    662663 
    663664        if (ring->tx) { 
    664665                if (ring->type == B43_DMA_64BIT) { 
    static int dmacontroller_setup(struct b4 
    669670                        value = B43_DMA64_TXENABLE; 
    670671                        value |= (addrext << B43_DMA64_TXADDREXT_SHIFT) 
    671672                            & B43_DMA64_TXADDREXT_MASK; 
     673                        if (!parity) 
     674                                value |= B43_DMA64_TXPARITYDISABLE; 
    672675                        b43_dma_write(ring, B43_DMA64_TXCTL, value); 
    673676                        b43_dma_write(ring, B43_DMA64_TXRINGLO, 
    674677                                      (ringbase & 0xFFFFFFFF)); 
    675678                        b43_dma_write(ring, B43_DMA64_TXRINGHI, 
    676679                                      ((ringbase >> 32) & 
    677680                                       ~SSB_DMA_TRANSLATION_MASK) 
    678                                       | (trans << 1)); 
     681                                      | trans); 
    679682                } else { 
    680683                        u32 ringbase = (u32) (ring->dmabase); 
    681684 
    static int dmacontroller_setup(struct b4 
    684687                        value = B43_DMA32_TXENABLE; 
    685688                        value |= (addrext << B43_DMA32_TXADDREXT_SHIFT) 
    686689                            & B43_DMA32_TXADDREXT_MASK; 
     690                        if (!parity) 
     691                                value |= B43_DMA32_TXPARITYDISABLE; 
    687692                        b43_dma_write(ring, B43_DMA32_TXCTL, value); 
    688693                        b43_dma_write(ring, B43_DMA32_TXRING, 
    689694                                      (ringbase & ~SSB_DMA_TRANSLATION_MASK) 
    static int dmacontroller_setup(struct b4 
    702707                        value |= B43_DMA64_RXENABLE; 
    703708                        value |= (addrext << B43_DMA64_RXADDREXT_SHIFT) 
    704709                            & B43_DMA64_RXADDREXT_MASK; 
     710                        if (!parity) 
     711                                value |= B43_DMA64_RXPARITYDISABLE; 
    705712                        b43_dma_write(ring, B43_DMA64_RXCTL, value); 
    706713                        b43_dma_write(ring, B43_DMA64_RXRINGLO, 
    707714                                      (ringbase & 0xFFFFFFFF)); 
    708715                        b43_dma_write(ring, B43_DMA64_RXRINGHI, 
    709716                                      ((ringbase >> 32) & 
    710717                                       ~SSB_DMA_TRANSLATION_MASK) 
    711                                       | (trans << 1)); 
     718                                      | trans); 
    712719                        b43_dma_write(ring, B43_DMA64_RXINDEX, ring->nr_slots * 
    713720                                      sizeof(struct b43_dmadesc64)); 
    714721                } else { 
    static int dmacontroller_setup(struct b4 
    720727                        value |= B43_DMA32_RXENABLE; 
    721728                        value |= (addrext << B43_DMA32_RXADDREXT_SHIFT) 
    722729                            & B43_DMA32_RXADDREXT_MASK; 
     730                        if (!parity) 
     731                                value |= B43_DMA32_RXPARITYDISABLE; 
    723732                        b43_dma_write(ring, B43_DMA32_RXCTL, value); 
    724733                        b43_dma_write(ring, B43_DMA32_RXRING, 
    725734                                      (ringbase & ~SSB_DMA_TRANSLATION_MASK) 
    int b43_dma_init(struct b43_wldev *dev) 
    10551064        err = b43_dma_set_mask(dev, dmamask); 
    10561065        if (err) 
    10571066                return err; 
    1058         dma->translation = ssb_dma_translation(dev->sdev); 
     1067 
     1068        switch (dev->dev->bus_type) { 
     1069#ifdef CONFIG_B43_BCMA 
     1070        case B43_BUS_BCMA: 
     1071                dma->translation = bcma_core_dma_translation(dev->dev->bdev); 
     1072                break; 
     1073#endif 
     1074#ifdef CONFIG_B43_SSB 
     1075        case B43_BUS_SSB: 
     1076                dma->translation = ssb_dma_translation(dev->dev->sdev); 
     1077                break; 
     1078#endif 
     1079        } 
     1080 
     1081        dma->parity = true; 
     1082#ifdef CONFIG_B43_BCMA 
     1083        /* TODO: find out which SSB devices need disabling parity */ 
     1084        if (dev->dev->bus_type == B43_BUS_BCMA) 
     1085                dma->parity = false; 
     1086#endif 
    10591087 
    10601088        err = -ENOMEM; 
    10611089        /* setup TX DMA channels. */ 
    void b43_dma_rx(struct b43_dmaring *ring 
    16001628                dma_rx(ring, &slot); 
    16011629                update_max_used_slots(ring, ++used_slots); 
    16021630        } 
     1631        wmb(); 
    16031632        ops->set_current_rxslot(ring, slot); 
    16041633        ring->current_slot = slot; 
    16051634} 
  • drivers/net/wireless/b43/dma.h

    a b  
    2020#define         B43_DMA32_TXSUSPEND                     0x00000002 
    2121#define         B43_DMA32_TXLOOPBACK            0x00000004 
    2222#define         B43_DMA32_TXFLUSH                       0x00000010 
     23#define         B43_DMA32_TXPARITYDISABLE               0x00000800 
    2324#define         B43_DMA32_TXADDREXT_MASK                0x00030000 
    2425#define         B43_DMA32_TXADDREXT_SHIFT               16 
    2526#define B43_DMA32_TXRING                                0x04 
     
    4445#define         B43_DMA32_RXFROFF_MASK          0x000000FE 
    4546#define         B43_DMA32_RXFROFF_SHIFT         1 
    4647#define         B43_DMA32_RXDIRECTFIFO          0x00000100 
     48#define         B43_DMA32_RXPARITYDISABLE               0x00000800 
    4749#define         B43_DMA32_RXADDREXT_MASK                0x00030000 
    4850#define         B43_DMA32_RXADDREXT_SHIFT               16 
    4951#define B43_DMA32_RXRING                                0x14 
    struct b43_dmadesc32 { 
    8486#define         B43_DMA64_TXSUSPEND                     0x00000002 
    8587#define         B43_DMA64_TXLOOPBACK            0x00000004 
    8688#define         B43_DMA64_TXFLUSH                       0x00000010 
     89#define         B43_DMA64_TXPARITYDISABLE               0x00000800 
    8790#define         B43_DMA64_TXADDREXT_MASK                0x00030000 
    8891#define         B43_DMA64_TXADDREXT_SHIFT               16 
    8992#define B43_DMA64_TXINDEX                               0x04 
    struct b43_dmadesc32 { 
    111114#define         B43_DMA64_RXFROFF_MASK          0x000000FE 
    112115#define         B43_DMA64_RXFROFF_SHIFT         1 
    113116#define         B43_DMA64_RXDIRECTFIFO          0x00000100 
     117#define         B43_DMA64_RXPARITYDISABLE               0x00000800 
    114118#define         B43_DMA64_RXADDREXT_MASK                0x00030000 
    115119#define         B43_DMA64_RXADDREXT_SHIFT               16 
    116120#define B43_DMA64_RXINDEX                               0x24 
  • drivers/net/wireless/b43/main.c

    a b void b43_power_saving_ctl_bits(struct b4 
    11361136        } 
    11371137} 
    11381138 
     1139#ifdef CONFIG_B43_BCMA 
     1140static void b43_bcma_phy_reset(struct b43_wldev *dev) 
     1141{ 
     1142        u32 flags; 
     1143 
     1144        /* Put PHY into reset */ 
     1145        flags = bcma_aread32(dev->dev->bdev, BCMA_IOCTL); 
     1146        flags |= B43_BCMA_IOCTL_PHY_RESET; 
     1147        flags |= B43_BCMA_IOCTL_PHY_BW_20MHZ; /* Make 20 MHz def */ 
     1148        bcma_awrite32(dev->dev->bdev, BCMA_IOCTL, flags); 
     1149        udelay(2); 
     1150 
     1151        /* Take PHY out of reset */ 
     1152        flags = bcma_aread32(dev->dev->bdev, BCMA_IOCTL); 
     1153        flags &= ~B43_BCMA_IOCTL_PHY_RESET; 
     1154        flags |= BCMA_IOCTL_FGC; 
     1155        bcma_awrite32(dev->dev->bdev, BCMA_IOCTL, flags); 
     1156        udelay(1); 
     1157 
     1158        /* Do not force clock anymore */ 
     1159        flags = bcma_aread32(dev->dev->bdev, BCMA_IOCTL); 
     1160        flags &= ~BCMA_IOCTL_FGC; 
     1161        bcma_awrite32(dev->dev->bdev, BCMA_IOCTL, flags); 
     1162        udelay(1); 
     1163} 
     1164 
     1165static void b43_bcma_wireless_core_reset(struct b43_wldev *dev, bool gmode) 
     1166{ 
     1167        b43_device_enable(dev, B43_BCMA_IOCTL_PHY_CLKEN); 
     1168        bcma_core_set_clockmode(dev->dev->bdev, BCMA_CLKMODE_FAST); 
     1169        b43_bcma_phy_reset(dev); 
     1170        bcma_core_pll_ctl(dev->dev->bdev, 0x300, 0x3000000, true); 
     1171} 
     1172#endif 
     1173 
    11391174static void b43_ssb_wireless_core_reset(struct b43_wldev *dev, bool gmode) 
    11401175{ 
    11411176        struct ssb_device *sdev = dev->dev->sdev; 
    void b43_wireless_core_reset(struct b43_ 
    11681203{ 
    11691204        u32 macctl; 
    11701205 
    1171         b43_ssb_wireless_core_reset(dev, gmode); 
     1206        switch (dev->dev->bus_type) { 
     1207#ifdef CONFIG_B43_BCMA 
     1208        case B43_BUS_BCMA: 
     1209                b43_bcma_wireless_core_reset(dev, gmode); 
     1210                break; 
     1211#endif 
     1212#ifdef CONFIG_B43_SSB 
     1213        case B43_BUS_SSB: 
     1214                b43_ssb_wireless_core_reset(dev, gmode); 
     1215                break; 
     1216#endif 
     1217        } 
    11721218 
    11731219        /* Turn Analog ON, but only if we already know the PHY-type. 
    11741220         * This protects against very early setup where we don't know the 
    static irqreturn_t b43_do_interrupt(stru 
    19211967                return IRQ_NONE; 
    19221968        reason &= dev->irq_mask; 
    19231969        if (!reason) 
    1924                 return IRQ_HANDLED; 
     1970                return IRQ_NONE; 
    19251971 
    19261972        dev->dma_reason[0] = b43_read32(dev, B43_MMIO_DMA0_REASON) 
    19271973            & 0x0001DC00; 
    static int b43_try_request_fw(struct b43 
    21162162        u32 tmshigh; 
    21172163        int err; 
    21182164 
     2165        /* Files for HT and LCN were found by trying one by one */ 
     2166 
    21192167        /* Get microcode */ 
    2120         if ((rev >= 5) && (rev <= 10)) 
     2168        if ((rev >= 5) && (rev <= 10)) { 
    21212169                filename = "ucode5"; 
    2122         else if ((rev >= 11) && (rev <= 12)) 
     2170        } else if ((rev >= 11) && (rev <= 12)) { 
    21232171                filename = "ucode11"; 
    2124         else if (rev == 13) 
     2172        } else if (rev == 13) { 
    21252173                filename = "ucode13"; 
    2126         else if (rev == 14) 
     2174        } else if (rev == 14) { 
    21272175                filename = "ucode14"; 
    2128         else if (rev == 15) 
     2176        } else if (rev == 15) { 
    21292177                filename = "ucode15"; 
    2130         else if ((rev >= 16) && (rev <= 20)) 
    2131                 filename = "ucode16_mimo"; 
    2132         else 
    2133                 goto err_no_ucode; 
     2178        } else { 
     2179                switch (dev->phy.type) { 
     2180                case B43_PHYTYPE_N: 
     2181                        if (rev >= 16) 
     2182                                filename = "ucode16_mimo"; 
     2183                        else 
     2184                                goto err_no_ucode; 
     2185                        break; 
     2186                case B43_PHYTYPE_HT: 
     2187                        if (rev == 29) 
     2188                                filename = "ucode29_mimo"; 
     2189                        else 
     2190                                goto err_no_ucode; 
     2191                        break; 
     2192                case B43_PHYTYPE_LCN: 
     2193                        if (rev == 24) 
     2194                                filename = "ucode24_mimo"; 
     2195                        else 
     2196                                goto err_no_ucode; 
     2197                        break; 
     2198                default: 
     2199                        goto err_no_ucode; 
     2200                } 
     2201        } 
    21342202        err = b43_do_request_fw(ctx, filename, &fw->ucode); 
    21352203        if (err) 
    21362204                goto err_load; 
    static int b43_try_request_fw(struct b43 
    21892257                else 
    21902258                        goto err_no_initvals; 
    21912259                break; 
     2260        case B43_PHYTYPE_HT: 
     2261                if (rev == 29) 
     2262                        filename = "ht0initvals29"; 
     2263                else 
     2264                        goto err_no_initvals; 
     2265                break; 
     2266        case B43_PHYTYPE_LCN: 
     2267                if (rev == 24) 
     2268                        filename = "lcn0initvals24"; 
     2269                else 
     2270                        goto err_no_initvals; 
     2271                break; 
    21922272        default: 
    21932273                goto err_no_initvals; 
    21942274        } 
    static int b43_try_request_fw(struct b43 
    22362316                else 
    22372317                        goto err_no_initvals; 
    22382318                break; 
     2319        case B43_PHYTYPE_HT: 
     2320                if (rev == 29) 
     2321                        filename = "ht0bsinitvals29"; 
     2322                else 
     2323                        goto err_no_initvals; 
     2324                break; 
     2325        case B43_PHYTYPE_LCN: 
     2326                if (rev == 24) 
     2327                        filename = "lcn0bsinitvals24"; 
     2328                else 
     2329                        goto err_no_initvals; 
     2330                break; 
    22392331        default: 
    22402332                goto err_no_initvals; 
    22412333        } 
    static int b43_gpio_init(struct b43_wlde 
    26072699        if (dev->dev->core_rev >= 2) 
    26082700                mask |= 0x0010; /* FIXME: This is redundant. */ 
    26092701 
    2610         gpiodev = b43_ssb_gpio_dev(dev); 
    2611         if (gpiodev) 
    2612                 ssb_write32(gpiodev, B43_GPIO_CONTROL, 
    2613                             (ssb_read32(gpiodev, B43_GPIO_CONTROL) 
    2614                              & mask) | set); 
     2702        switch (dev->dev->bus_type) { 
     2703#ifdef CONFIG_B43_BCMA 
     2704        case B43_BUS_BCMA: 
     2705                bcma_cc_write32(&dev->dev->bdev->bus->drv_cc, BCMA_CC_GPIOCTL, 
     2706                                (bcma_cc_read32(&dev->dev->bdev->bus->drv_cc, 
     2707                                        BCMA_CC_GPIOCTL) & mask) | set); 
     2708                break; 
     2709#endif 
     2710#ifdef CONFIG_B43_SSB 
     2711        case B43_BUS_SSB: 
     2712                gpiodev = b43_ssb_gpio_dev(dev); 
     2713                if (gpiodev) 
     2714                        ssb_write32(gpiodev, B43_GPIO_CONTROL, 
     2715                                    (ssb_read32(gpiodev, B43_GPIO_CONTROL) 
     2716                                    & mask) | set); 
     2717                break; 
     2718#endif 
     2719        } 
    26152720 
    26162721        return 0; 
    26172722} 
    static void b43_gpio_cleanup(struct b43_ 
    26212726{ 
    26222727        struct ssb_device *gpiodev; 
    26232728 
    2624         gpiodev = b43_ssb_gpio_dev(dev); 
    2625         if (gpiodev) 
    2626                 ssb_write32(gpiodev, B43_GPIO_CONTROL, 0); 
     2729        switch (dev->dev->bus_type) { 
     2730#ifdef CONFIG_B43_BCMA 
     2731        case B43_BUS_BCMA: 
     2732                bcma_cc_write32(&dev->dev->bdev->bus->drv_cc, BCMA_CC_GPIOCTL, 
     2733                                0); 
     2734                break; 
     2735#endif 
     2736#ifdef CONFIG_B43_SSB 
     2737        case B43_BUS_SSB: 
     2738                gpiodev = b43_ssb_gpio_dev(dev); 
     2739                if (gpiodev) 
     2740                        ssb_write32(gpiodev, B43_GPIO_CONTROL, 0); 
     2741                break; 
     2742#endif 
     2743        } 
    26272744} 
    26282745 
    26292746/* http://bcm-specs.sipsolutions.net/EnableMac */ 
    out: 
    26952812/* http://bcm-v4.sipsolutions.net/802.11/PHY/N/MacPhyClkSet */ 
    26962813void b43_mac_phy_clock_set(struct b43_wldev *dev, bool on) 
    26972814{ 
    2698         u32 tmslow = ssb_read32(dev->sdev, SSB_TMSLOW); 
    2699         if (on) 
    2700                 tmslow |= B43_TMSLOW_MACPHYCLKEN; 
    2701         else 
    2702                 tmslow &= ~B43_TMSLOW_MACPHYCLKEN; 
    2703         ssb_write32(dev->sdev, SSB_TMSLOW, tmslow); 
     2815        u32 tmp; 
     2816 
     2817        switch (dev->dev->bus_type) { 
     2818#ifdef CONFIG_B43_BCMA 
     2819        case B43_BUS_BCMA: 
     2820                tmp = bcma_aread32(dev->dev->bdev, BCMA_IOCTL); 
     2821                if (on) 
     2822                        tmp |= B43_BCMA_IOCTL_MACPHYCLKEN; 
     2823                else 
     2824                        tmp &= ~B43_BCMA_IOCTL_MACPHYCLKEN; 
     2825                bcma_awrite32(dev->dev->bdev, BCMA_IOCTL, tmp); 
     2826                break; 
     2827#endif 
     2828#ifdef CONFIG_B43_SSB 
     2829        case B43_BUS_SSB: 
     2830                tmp = ssb_read32(dev->dev->sdev, SSB_TMSLOW); 
     2831                if (on) 
     2832                        tmp |= B43_TMSLOW_MACPHYCLKEN; 
     2833                else 
     2834                        tmp &= ~B43_TMSLOW_MACPHYCLKEN; 
     2835                ssb_write32(dev->dev->sdev, SSB_TMSLOW, tmp); 
     2836                break; 
     2837#endif 
     2838        } 
    27042839} 
    27052840 
    27062841static void b43_adjust_opmode(struct b43_wldev *dev) 
    static int b43_chip_init(struct b43_wlde 
    29393074 
    29403075        b43_mac_phy_clock_set(dev, true); 
    29413076 
    2942         b43_write16(dev, B43_MMIO_POWERUP_DELAY, 
    2943                     dev->sdev->bus->chipco.fast_pwrup_delay); 
     3077        switch (dev->dev->bus_type) { 
     3078#ifdef CONFIG_B43_BCMA 
     3079        case B43_BUS_BCMA: 
     3080                /* FIXME: 0xE74 is quite common, but should be read from CC */ 
     3081                b43_write16(dev, B43_MMIO_POWERUP_DELAY, 0xE74); 
     3082                break; 
     3083#endif 
     3084#ifdef CONFIG_B43_SSB 
     3085        case B43_BUS_SSB: 
     3086                b43_write16(dev, B43_MMIO_POWERUP_DELAY, 
     3087                            dev->dev->sdev->bus->chipco.fast_pwrup_delay); 
     3088                break; 
     3089#endif 
     3090        } 
    29443091 
    29453092        err = 0; 
    29463093        b43dbg(dev->wl, "Chip initialized\n"); 
    static void b43_op_set_tsf(struct ieee80 
    34563603 
    34573604static void b43_put_phy_into_reset(struct b43_wldev *dev) 
    34583605{ 
    3459         struct ssb_device *sdev = dev->sdev; 
    3460         u32 tmslow; 
     3606        u32 tmp; 
    34613607 
    3462         tmslow = ssb_read32(sdev, SSB_TMSLOW); 
    3463         tmslow &= ~B43_TMSLOW_GMODE; 
    3464         tmslow |= B43_TMSLOW_PHYRESET; 
    3465         tmslow |= SSB_TMSLOW_FGC; 
    3466         ssb_write32(sdev, SSB_TMSLOW, tmslow); 
    3467         msleep(1); 
     3608        switch (dev->dev->bus_type) { 
     3609#ifdef CONFIG_B43_BCMA 
     3610        case B43_BUS_BCMA: 
     3611                b43err(dev->wl, 
     3612                       "Putting PHY into reset not supported on BCMA\n"); 
     3613                break; 
     3614#endif 
     3615#ifdef CONFIG_B43_SSB 
     3616        case B43_BUS_SSB: 
     3617                tmp = ssb_read32(dev->dev->sdev, SSB_TMSLOW); 
     3618                tmp &= ~B43_TMSLOW_GMODE; 
     3619                tmp |= B43_TMSLOW_PHYRESET; 
     3620                tmp |= SSB_TMSLOW_FGC; 
     3621                ssb_write32(dev->dev->sdev, SSB_TMSLOW, tmp); 
     3622                msleep(1); 
     3623 
     3624                tmp = ssb_read32(dev->dev->sdev, SSB_TMSLOW); 
     3625                tmp &= ~SSB_TMSLOW_FGC; 
     3626                tmp |= B43_TMSLOW_PHYRESET; 
     3627                ssb_write32(dev->dev->sdev, SSB_TMSLOW, tmp); 
     3628                msleep(1); 
    34683629 
    3469         tmslow = ssb_read32(sdev, SSB_TMSLOW); 
    3470         tmslow &= ~SSB_TMSLOW_FGC; 
    3471         tmslow |= B43_TMSLOW_PHYRESET; 
    3472         ssb_write32(sdev, SSB_TMSLOW, tmslow); 
    3473         msleep(1); 
     3630                break; 
     3631#endif 
     3632        } 
    34743633} 
    34753634 
    34763635static const char *band_to_string(enum ieee80211_band band) 
    static int b43_phy_versioning(struct b43 
    41004259                        unsupported = 1; 
    41014260                break; 
    41024261#endif 
     4262#ifdef CONFIG_B43_PHY_LCN 
     4263        case B43_PHYTYPE_LCN: 
     4264                if (phy_rev > 1) 
     4265                        unsupported = 1; 
     4266                break; 
     4267#endif 
    41034268        default: 
    41044269                unsupported = 1; 
    41054270        }; 
    static int b43_phy_versioning(struct b43 
    41134278               analog_type, phy_type, phy_rev); 
    41144279 
    41154280        /* Get RADIO versioning */ 
    4116         if (dev->dev->chip_id == 0x4317) { 
    4117                 if (dev->dev->chip_rev == 0) 
    4118                         tmp = 0x3205017F; 
    4119                 else if (dev->dev->chip_rev == 1) 
    4120                         tmp = 0x4205017F; 
    4121                 else 
    4122                         tmp = 0x5205017F; 
     4281        if (dev->dev->core_rev >= 24) { 
     4282                u16 radio24[3]; 
     4283 
     4284                for (tmp = 0; tmp < 3; tmp++) { 
     4285                        b43_write16(dev, B43_MMIO_RADIO24_CONTROL, tmp); 
     4286                        radio24[tmp] = b43_read16(dev, B43_MMIO_RADIO24_DATA); 
     4287                } 
     4288 
     4289                /* Broadcom uses "id" for our "ver" and has separated "ver" */ 
     4290                /* radio_ver = (radio24[0] & 0xF0) >> 4; */ 
     4291 
     4292                radio_manuf = 0x17F; 
     4293                radio_ver = (radio24[2] << 8) | radio24[1]; 
     4294                radio_rev = (radio24[0] & 0xF); 
    41234295        } else { 
    4124                 b43_write16(dev, B43_MMIO_RADIO_CONTROL, B43_RADIOCTL_ID); 
    4125                 tmp = b43_read16(dev, B43_MMIO_RADIO_DATA_LOW); 
    4126                 b43_write16(dev, B43_MMIO_RADIO_CONTROL, B43_RADIOCTL_ID); 
    4127                 tmp |= (u32)b43_read16(dev, B43_MMIO_RADIO_DATA_HIGH) << 16; 
    4128         } 
    4129         radio_manuf = (tmp & 0x00000FFF); 
    4130         radio_ver = (tmp & 0x0FFFF000) >> 12; 
    4131         radio_rev = (tmp & 0xF0000000) >> 28; 
     4296                if (dev->dev->chip_id == 0x4317) { 
     4297                        if (dev->dev->chip_rev == 0) 
     4298                                tmp = 0x3205017F; 
     4299                        else if (dev->dev->chip_rev == 1) 
     4300                                tmp = 0x4205017F; 
     4301                        else 
     4302                                tmp = 0x5205017F; 
     4303                } else { 
     4304                        b43_write16(dev, B43_MMIO_RADIO_CONTROL, 
     4305                                    B43_RADIOCTL_ID); 
     4306                        tmp = b43_read16(dev, B43_MMIO_RADIO_DATA_LOW); 
     4307                        b43_write16(dev, B43_MMIO_RADIO_CONTROL, 
     4308                                    B43_RADIOCTL_ID); 
     4309                        tmp |= (u32)b43_read16(dev, B43_MMIO_RADIO_DATA_HIGH) 
     4310                                << 16; 
     4311                } 
     4312                radio_manuf = (tmp & 0x00000FFF); 
     4313                radio_ver = (tmp & 0x0FFFF000) >> 12; 
     4314                radio_rev = (tmp & 0xF0000000) >> 28; 
     4315        } 
     4316 
    41324317        if (radio_manuf != 0x17F /* Broadcom */) 
    41334318                unsupported = 1; 
    41344319        switch (phy_type) { 
    static int b43_phy_versioning(struct b43 
    41604345                if (radio_ver != 0x2059) 
    41614346                        unsupported = 1; 
    41624347                break; 
     4348        case B43_PHYTYPE_LCN: 
     4349                if (radio_ver != 0x2064) 
     4350                        unsupported = 1; 
     4351                break; 
    41634352        default: 
    41644353                B43_WARN_ON(1); 
    41654354        } 
    static void b43_wireless_core_exit(struc 
    43434532/* Initialize a wireless core */ 
    43444533static int b43_wireless_core_init(struct b43_wldev *dev) 
    43454534{ 
    4346         struct ssb_bus *bus = dev->sdev->bus; 
    43474535        struct ssb_sprom *sprom = dev->dev->bus_sprom; 
    43484536        struct b43_phy *phy = &dev->phy; 
    43494537        int err; 
    static int b43_wireless_core_init(struct 
    43624550        phy->ops->prepare_structs(dev); 
    43634551 
    43644552        /* Enable IRQ routing to this device. */ 
    4365         ssb_pcicore_dev_irqvecs_enable(&bus->pcicore, dev->sdev); 
     4553        switch (dev->dev->bus_type) { 
     4554#ifdef CONFIG_B43_BCMA 
     4555        case B43_BUS_BCMA: 
     4556                bcma_core_pci_irq_ctl(&dev->dev->bdev->bus->drv_pci, 
     4557                                      dev->dev->bdev, true); 
     4558                break; 
     4559#endif 
     4560#ifdef CONFIG_B43_SSB 
     4561        case B43_BUS_SSB: 
     4562                ssb_pcicore_dev_irqvecs_enable(&dev->dev->sdev->bus->pcicore, 
     4563                                               dev->dev->sdev); 
     4564                break; 
     4565#endif 
     4566        } 
    43664567 
    43674568        b43_imcfglo_timeouts_workaround(dev); 
    43684569        b43_bluetooth_coext_disable(dev); 
    static int b43_wireless_core_init(struct 
    43934594        if (sprom->boardflags_lo & B43_BFL_XTAL_NOSLOW) 
    43944595                hf |= B43_HF_DSCRQ; /* Disable slowclock requests from ucode. */ 
    43954596#ifdef CONFIG_SSB_DRIVER_PCICORE 
    4396         if ((bus->bustype == SSB_BUSTYPE_PCI) && 
    4397             (bus->pcicore.dev->id.revision <= 10)) 
     4597        if (dev->dev->bus_type == B43_BUS_SSB && 
     4598            dev->dev->sdev->bus->bustype == SSB_BUSTYPE_PCI && 
     4599            dev->dev->sdev->bus->pcicore.dev->id.revision <= 10) 
    43984600                hf |= B43_HF_PCISCW; /* PCI slow clock workaround. */ 
    43994601#endif 
    44004602        hf &= ~B43_HF_SKCFPUP; 
    static void b43_wireless_core_detach(str 
    47644966static int b43_wireless_core_attach(struct b43_wldev *dev) 
    47654967{ 
    47664968        struct b43_wl *wl = dev->wl; 
    4767         struct ssb_bus *bus = dev->sdev->bus; 
    4768         struct pci_dev *pdev = (bus->bustype == SSB_BUSTYPE_PCI) ? bus->host_pci : NULL; 
     4969        struct pci_dev *pdev = NULL; 
    47694970        int err; 
     4971        u32 tmp; 
    47704972        bool have_2ghz_phy = 0, have_5ghz_phy = 0; 
    47714973 
    47724974        /* Do NOT do any device initialization here. 
    static int b43_wireless_core_attach(stru 
    47764978         * that in core_init(), too. 
    47774979         */ 
    47784980 
     4981#ifdef CONFIG_B43_SSB 
     4982        if (dev->dev->bus_type == B43_BUS_SSB && 
     4983            dev->dev->sdev->bus->bustype == SSB_BUSTYPE_PCI) 
     4984                pdev = dev->dev->sdev->bus->host_pci; 
     4985#endif 
     4986 
    47794987        err = b43_bus_powerup(dev, 0); 
    47804988        if (err) { 
    47814989                b43err(wl, "Bus powerup failed\n"); 
    47824990                goto out; 
    47834991        } 
    4784         /* Get the PHY type. */ 
    4785         if (dev->dev->core_rev >= 5) { 
    4786                 u32 tmshigh; 
    47874992 
    4788                 tmshigh = ssb_read32(dev->sdev, SSB_TMSHIGH); 
    4789                 have_2ghz_phy = !!(tmshigh & B43_TMSHIGH_HAVE_2GHZ_PHY); 
    4790                 have_5ghz_phy = !!(tmshigh & B43_TMSHIGH_HAVE_5GHZ_PHY); 
    4791         } else 
    4792                 B43_WARN_ON(1); 
     4993        /* Get the PHY type. */ 
     4994        switch (dev->dev->bus_type) { 
     4995#ifdef CONFIG_B43_BCMA 
     4996        case B43_BUS_BCMA: 
     4997                tmp = bcma_aread32(dev->dev->bdev, BCMA_IOST); 
     4998                have_2ghz_phy = !!(tmp & B43_BCMA_IOST_2G_PHY); 
     4999                have_5ghz_phy = !!(tmp & B43_BCMA_IOST_5G_PHY); 
     5000                break; 
     5001#endif 
     5002#ifdef CONFIG_B43_SSB 
     5003        case B43_BUS_SSB: 
     5004                if (dev->dev->core_rev >= 5) { 
     5005                        tmp = ssb_read32(dev->dev->sdev, SSB_TMSHIGH); 
     5006                        have_2ghz_phy = !!(tmp & B43_TMSHIGH_HAVE_2GHZ_PHY); 
     5007                        have_5ghz_phy = !!(tmp & B43_TMSHIGH_HAVE_5GHZ_PHY); 
     5008                } else 
     5009                        B43_WARN_ON(1); 
     5010                break; 
     5011#endif 
     5012        } 
    47935013 
    47945014        dev->phy.gmode = have_2ghz_phy; 
    47955015        dev->phy.radio_on = 1; 
    static int b43_wireless_core_attach(stru 
    48155035#endif 
    48165036                case B43_PHYTYPE_G: 
    48175037                case B43_PHYTYPE_N: 
     5038                case B43_PHYTYPE_HT: 
     5039                case B43_PHYTYPE_LCN: 
    48185040                        have_2ghz_phy = 1; 
    48195041                        break; 
    48205042                default: 
    static void b43_one_core_detach(struct b 
    48775099        /* Do not cancel ieee80211-workqueue based work here. 
    48785100         * See comment in b43_remove(). */ 
    48795101 
    4880         wldev = ssb_get_drvdata(dev->sdev); 
     5102        wldev = b43_bus_get_wldev(dev); 
    48815103        wl = wldev->wl; 
    48825104        b43_debugfs_remove_device(wldev); 
    48835105        b43_wireless_core_detach(wldev); 
    48845106        list_del(&wldev->list); 
    48855107        wl->nr_devs--; 
    4886         ssb_set_drvdata(dev->sdev, NULL); 
     5108        b43_bus_set_wldev(dev, NULL); 
    48875109        kfree(wldev); 
    48885110} 
    48895111 
    static int b43_one_core_attach(struct b4 
    48985120 
    48995121        wldev->use_pio = b43_modparam_pio; 
    49005122        wldev->dev = dev; 
    4901         wldev->sdev = dev->sdev; /* TODO: Remove when not needed */ 
    49025123        wldev->wl = wl; 
    49035124        b43_set_status(wldev, B43_STAT_UNINIT); 
    49045125        wldev->bad_frames_preempt = modparam_bad_frames_preempt; 
    static int b43_one_core_attach(struct b4 
    49105131 
    49115132        list_add(&wldev->list, &wl->devlist); 
    49125133        wl->nr_devs++; 
    4913         ssb_set_drvdata(dev->sdev, wldev); 
     5134        b43_bus_set_wldev(dev, wldev); 
    49145135        b43_debugfs_add_device(wldev); 
    49155136 
    49165137      out: 
    static void b43_wireless_exit(struct b43 
    49595180        ieee80211_free_hw(hw); 
    49605181} 
    49615182 
    4962 static struct b43_wl *b43_wireless_init(struct ssb_device *dev) 
     5183static struct b43_wl *b43_wireless_init(struct b43_bus_dev *dev) 
    49635184{ 
    4964         struct ssb_sprom *sprom = &dev->bus->sprom; 
     5185        struct ssb_sprom *sprom = dev->bus_sprom; 
    49655186        struct ieee80211_hw *hw; 
    49665187        struct b43_wl *wl; 
     5188        char chip_name[6]; 
    49675189 
    49685190        hw = ieee80211_alloc_hw(sizeof(*wl), &b43_hw_ops); 
    49695191        if (!hw) { 
    static struct b43_wl *b43_wireless_init( 
    50025224        INIT_WORK(&wl->tx_work, b43_tx_work); 
    50035225        skb_queue_head_init(&wl->tx_queue); 
    50045226 
    5005         b43info(wl, "Broadcom %04X WLAN found (core revision %u)\n", 
    5006                 dev->bus->chip_id, dev->id.revision); 
     5227        snprintf(chip_name, ARRAY_SIZE(chip_name), 
     5228                 (dev->chip_id > 0x9999) ? "%d" : "%04X", dev->chip_id); 
     5229        b43info(wl, "Broadcom %s WLAN found (core revision %u)\n", chip_name, 
     5230                dev->core_rev); 
    50075231        return wl; 
    50085232} 
    50095233 
    50105234#ifdef CONFIG_B43_BCMA 
    50115235static int b43_bcma_probe(struct bcma_device *core) 
    50125236{ 
    5013         b43err(NULL, "BCMA is not supported yet!"); 
    5014         return -EOPNOTSUPP; 
     5237        struct b43_bus_dev *dev; 
     5238        struct b43_wl *wl; 
     5239        int err; 
     5240 
     5241        dev = b43_bus_dev_bcma_init(core); 
     5242        if (!dev) 
     5243                return -ENODEV; 
     5244 
     5245        wl = b43_wireless_init(dev); 
     5246        if (IS_ERR(wl)) { 
     5247                err = PTR_ERR(wl); 
     5248                goto bcma_out; 
     5249        } 
     5250 
     5251        err = b43_one_core_attach(dev, wl); 
     5252        if (err) 
     5253                goto bcma_err_wireless_exit; 
     5254 
     5255        err = ieee80211_register_hw(wl->hw); 
     5256        if (err) 
     5257                goto bcma_err_one_core_detach; 
     5258        b43_leds_register(wl->current_dev); 
     5259 
     5260bcma_out: 
     5261        return err; 
     5262 
     5263bcma_err_one_core_detach: 
     5264        b43_one_core_detach(dev); 
     5265bcma_err_wireless_exit: 
     5266        ieee80211_free_hw(wl->hw); 
     5267        return err; 
    50155268} 
    50165269 
    50175270static void b43_bcma_remove(struct bcma_device *core) 
    50185271{ 
    5019         /* TODO */ 
     5272        struct b43_wldev *wldev = bcma_get_drvdata(core); 
     5273        struct b43_wl *wl = wldev->wl; 
     5274 
     5275        /* We must cancel any work here before unregistering from ieee80211, 
     5276         * as the ieee80211 unreg will destroy the workqueue. */ 
     5277        cancel_work_sync(&wldev->restart_work); 
     5278 
     5279        /* Restore the queues count before unregistering, because firmware detect 
     5280         * might have modified it. Restoring is important, so the networking 
     5281         * stack can properly free resources. */ 
     5282        wl->hw->queues = wl->mac80211_initially_registered_queues; 
     5283        b43_leds_stop(wldev); 
     5284        ieee80211_unregister_hw(wl->hw); 
     5285 
     5286        b43_one_core_detach(wldev->dev); 
     5287 
     5288        b43_leds_unregister(wl); 
     5289 
     5290        ieee80211_free_hw(wl->hw); 
    50205291} 
    50215292 
    50225293static struct bcma_driver b43_bcma_driver = { 
    int b43_ssb_probe(struct ssb_device *sde 
    50455316                /* Probing the first core. Must setup common struct b43_wl */ 
    50465317                first = 1; 
    50475318                b43_sprom_fixup(sdev->bus); 
    5048                 wl = b43_wireless_init(sdev); 
     5319                wl = b43_wireless_init(dev); 
    50495320                if (IS_ERR(wl)) { 
    50505321                        err = PTR_ERR(wl); 
    50515322                        goto out; 
  • drivers/net/wireless/b43/phy_common.c

    a b  
    3232#include "phy_n.h" 
    3333#include "phy_lp.h" 
    3434#include "phy_ht.h" 
     35#include "phy_lcn.h" 
    3536#include "b43.h" 
    3637#include "main.h" 
    3738 
    int b43_phy_allocate(struct b43_wldev *d 
    6566                phy->ops = &b43_phyops_ht; 
    6667#endif 
    6768                break; 
     69        case B43_PHYTYPE_LCN: 
     70#ifdef CONFIG_B43_PHY_LCN 
     71                phy->ops = &b43_phyops_lcn; 
     72#endif 
     73                break; 
    6874        } 
    6975        if (B43_WARN_ON(!phy->ops)) 
    7076                return -ENODEV; 
  • drivers/net/wireless/b43/phy_common.h

    a b struct b43_phy_g; 
    198198struct b43_phy_n; 
    199199struct b43_phy_lp; 
    200200struct b43_phy_ht; 
     201struct b43_phy_lcn; 
    201202 
    202203struct b43_phy { 
    203204        /* Hardware operation callbacks. */ 
    struct b43_phy { 
    222223                struct b43_phy_lp *lp; 
    223224                /* HT-PHY specific information */ 
    224225                struct b43_phy_ht *ht; 
     226                /* LCN-PHY specific information */ 
     227                struct b43_phy_lcn *lcn; 
    225228        }; 
    226229 
    227230        /* Band support flags. */ 
  • drivers/net/wireless/b43/phy_ht.c

    a b  
    2424 
    2525#include "b43.h" 
    2626#include "phy_ht.h" 
     27#include "tables_phy_ht.h" 
    2728#include "radio_2059.h" 
    2829#include "main.h" 
    2930 
     31/************************************************** 
     32 * Radio 2059. 
     33 **************************************************/ 
     34 
    3035static void b43_radio_2059_channel_setup(struct b43_wldev *dev, 
    3136                        const struct b43_phy_ht_channeltab_e_radio2059 *e) 
    3237{ 
    static void b43_radio_2059_channel_setup 
    5661        b43_radio_write(dev, 0x98, e->radio_syn98); 
    5762 
    5863        for (i = 0; i < 2; i++) { 
    59                 routing = i ? 0x800 : 0x400; 
     64                routing = i ? R2059_RXRX1 : R2059_TXRX0; 
    6065                b43_radio_write(dev, routing | 0x4a, e->radio_rxtx4a); 
    6166                b43_radio_write(dev, routing | 0x58, e->radio_rxtx58); 
    6267                b43_radio_write(dev, routing | 0x5a, e->radio_rxtx5a); 
    static void b43_radio_2059_channel_setup 
    7883        udelay(300); 
    7984} 
    8085 
     86static void b43_radio_2059_init(struct b43_wldev *dev) 
     87{ 
     88        const u16 routing[] = { R2059_SYN, R2059_TXRX0, R2059_RXRX1 }; 
     89        const u16 radio_values[3][2] = { 
     90                { 0x61, 0xE9 }, { 0x69, 0xD5 }, { 0x73, 0x99 }, 
     91        }; 
     92        u16 i, j; 
     93 
     94        b43_radio_write(dev, R2059_ALL | 0x51, 0x0070); 
     95        b43_radio_write(dev, R2059_ALL | 0x5a, 0x0003); 
     96 
     97        for (i = 0; i < ARRAY_SIZE(routing); i++) 
     98                b43_radio_set(dev, routing[i] | 0x146, 0x3); 
     99 
     100        b43_radio_set(dev, 0x2e, 0x0078); 
     101        b43_radio_set(dev, 0xc0, 0x0080); 
     102        msleep(2); 
     103        b43_radio_mask(dev, 0x2e, ~0x0078); 
     104        b43_radio_mask(dev, 0xc0, ~0x0080); 
     105 
     106        if (1) { /* FIXME */ 
     107                b43_radio_set(dev, R2059_RXRX1 | 0x4, 0x1); 
     108                udelay(10); 
     109                b43_radio_set(dev, R2059_RXRX1 | 0x0BF, 0x1); 
     110                b43_radio_maskset(dev, R2059_RXRX1 | 0x19B, 0x3, 0x2); 
     111 
     112                b43_radio_set(dev, R2059_RXRX1 | 0x4, 0x2); 
     113                udelay(100); 
     114                b43_radio_mask(dev, R2059_RXRX1 | 0x4, ~0x2); 
     115 
     116                for (i = 0; i < 10000; i++) { 
     117                        if (b43_radio_read(dev, R2059_RXRX1 | 0x145) & 1) { 
     118                                i = 0; 
     119                                break; 
     120                        } 
     121                        udelay(100); 
     122                } 
     123                if (i) 
     124                        b43err(dev->wl, "radio 0x945 timeout\n"); 
     125 
     126                b43_radio_mask(dev, R2059_RXRX1 | 0x4, ~0x1); 
     127                b43_radio_set(dev, 0xa, 0x60); 
     128 
     129                for (i = 0; i < 3; i++) { 
     130                        b43_radio_write(dev, 0x17F, radio_values[i][0]); 
     131                        b43_radio_write(dev, 0x13D, 0x6E); 
     132                        b43_radio_write(dev, 0x13E, radio_values[i][1]); 
     133                        b43_radio_write(dev, 0x13C, 0x55); 
     134 
     135                        for (j = 0; j < 10000; j++) { 
     136                                if (b43_radio_read(dev, 0x140) & 2) { 
     137                                        j = 0; 
     138                                        break; 
     139                                } 
     140                                udelay(500); 
     141                        } 
     142                        if (j) 
     143                                b43err(dev->wl, "radio 0x140 timeout\n"); 
     144 
     145                        b43_radio_write(dev, 0x13C, 0x15); 
     146                } 
     147 
     148                b43_radio_mask(dev, 0x17F, ~0x1); 
     149        } 
     150 
     151        b43_radio_mask(dev, 0x11, ~0x0008); 
     152} 
     153 
     154/************************************************** 
     155 * Channel switching ops. 
     156 **************************************************/ 
     157 
    81158static void b43_phy_ht_channel_setup(struct b43_wldev *dev, 
    82159                                const struct b43_phy_ht_channeltab_e_phy *e, 
    83160                                struct ieee80211_channel *new_channel) 
    84161{ 
    85         /* TODO */ 
     162        bool old_band_5ghz; 
     163        u8 i; 
     164 
     165        old_band_5ghz = b43_phy_read(dev, B43_PHY_HT_BANDCTL) & 0; /* FIXME */ 
     166        if (new_channel->band == IEEE80211_BAND_5GHZ && !old_band_5ghz) { 
     167                /* TODO */ 
     168        } else if (new_channel->band == IEEE80211_BAND_2GHZ && old_band_5ghz) { 
     169                /* TODO */ 
     170        } 
     171 
     172        b43_phy_write(dev, B43_PHY_HT_BW1, e->bw1); 
     173        b43_phy_write(dev, B43_PHY_HT_BW2, e->bw2); 
     174        b43_phy_write(dev, B43_PHY_HT_BW3, e->bw3); 
     175        b43_phy_write(dev, B43_PHY_HT_BW4, e->bw4); 
     176        b43_phy_write(dev, B43_PHY_HT_BW5, e->bw5); 
     177        b43_phy_write(dev, B43_PHY_HT_BW6, e->bw6); 
     178 
     179        /* TODO: some ops on PHY regs 0x0B0 and 0xC0A */ 
     180 
     181        /* TODO: separated function? */ 
     182        for (i = 0; i < 3; i++) { 
     183                u16 mask; 
     184                u32 tmp = b43_httab_read(dev, B43_HTTAB32(26, 0xE8)); 
     185 
     186                if (0) /* FIXME */ 
     187                        mask = 0x2 << (i * 4); 
     188                else 
     189                        mask = 0; 
     190                b43_phy_mask(dev, B43_PHY_EXTG(0x108), mask); 
     191 
     192                b43_httab_write(dev, B43_HTTAB16(7, 0x110 + i), tmp >> 16); 
     193                b43_httab_write(dev, B43_HTTAB8(13, 0x63 + (i * 4)), 
     194                                tmp & 0xFF); 
     195                b43_httab_write(dev, B43_HTTAB8(13, 0x73 + (i * 4)), 
     196                                tmp & 0xFF); 
     197        } 
     198 
     199        b43_phy_write(dev, 0x017e, 0x3830); 
    86200} 
    87201 
    88202static int b43_phy_ht_set_channel(struct b43_wldev *dev, 
    static void b43_phy_ht_op_prepare_struct 
    139253        memset(phy_ht, 0, sizeof(*phy_ht)); 
    140254} 
    141255 
     256static int b43_phy_ht_op_init(struct b43_wldev *dev) 
     257{ 
     258        b43_phy_ht_tables_init(dev); 
     259 
     260        return 0; 
     261} 
     262 
    142263static void b43_phy_ht_op_free(struct b43_wldev *dev) 
    143264{ 
    144265        struct b43_phy *phy = &dev->phy; 
    static void b43_phy_ht_op_software_rfkil 
    155276        if (b43_read32(dev, B43_MMIO_MACCTL) & B43_MACCTL_ENABLED) 
    156277                b43err(dev->wl, "MAC not suspended\n"); 
    157278 
     279        /* In the following PHY ops we copy wl's dummy behaviour. 
     280         * TODO: Find out if reads (currently hidden in masks/masksets) are 
     281         * needed and replace following ops with just writes or w&r. 
     282         * Note: B43_PHY_HT_RF_CTL1 register is tricky, wrong operation can 
     283         * cause delayed (!) machine lock up. */ 
    158284        if (blocked) { 
    159                 b43_phy_mask(dev, B43_PHY_HT_RF_CTL1, ~0); 
     285                b43_phy_mask(dev, B43_PHY_HT_RF_CTL1, 0); 
    160286        } else { 
    161                 b43_phy_mask(dev, B43_PHY_HT_RF_CTL1, ~0); 
    162                 b43_phy_maskset(dev, B43_PHY_HT_RF_CTL1, ~0, 0x1); 
    163                 b43_phy_mask(dev, B43_PHY_HT_RF_CTL1, ~0); 
    164                 b43_phy_maskset(dev, B43_PHY_HT_RF_CTL1, ~0, 0x2); 
     287                b43_phy_mask(dev, B43_PHY_HT_RF_CTL1, 0); 
     288                b43_phy_maskset(dev, B43_PHY_HT_RF_CTL1, 0, 0x1); 
     289                b43_phy_mask(dev, B43_PHY_HT_RF_CTL1, 0); 
     290                b43_phy_maskset(dev, B43_PHY_HT_RF_CTL1, 0, 0x2); 
     291 
     292                if (dev->phy.radio_ver == 0x2059) 
     293                        b43_radio_2059_init(dev); 
     294                else 
     295                        B43_WARN_ON(1); 
     296 
     297                b43_switch_channel(dev, dev->phy.channel); 
    165298        } 
    166299} 
    167300 
    static int b43_phy_ht_op_switch_channel( 
    203336static unsigned int b43_phy_ht_op_get_default_chan(struct b43_wldev *dev) 
    204337{ 
    205338        if (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ) 
    206                 return 1; 
     339                return 11; 
    207340        return 36; 
    208341} 
    209342 
    static void b43_phy_ht_op_radio_write(st 
    247380        b43_write16(dev, B43_MMIO_RADIO24_DATA, value); 
    248381} 
    249382 
     383static enum b43_txpwr_result 
     384b43_phy_ht_op_recalc_txpower(struct b43_wldev *dev, bool ignore_tssi) 
     385{ 
     386        return B43_TXPWR_RES_DONE; 
     387} 
     388 
     389static void b43_phy_ht_op_adjust_txpower(struct b43_wldev *dev) 
     390{ 
     391} 
     392 
    250393/************************************************** 
    251394 * PHY ops struct. 
    252395 **************************************************/ 
    const struct b43_phy_operations b43_phyo 
    255398        .allocate               = b43_phy_ht_op_allocate, 
    256399        .free                   = b43_phy_ht_op_free, 
    257400        .prepare_structs        = b43_phy_ht_op_prepare_structs, 
    258         /* 
    259401        .init                   = b43_phy_ht_op_init, 
    260         */ 
    261402        .phy_read               = b43_phy_ht_op_read, 
    262403        .phy_write              = b43_phy_ht_op_write, 
    263404        .phy_maskset            = b43_phy_ht_op_maskset, 
    const struct b43_phy_operations b43_phyo 
    267408        .switch_analog          = b43_phy_ht_op_switch_analog, 
    268409        .switch_channel         = b43_phy_ht_op_switch_channel, 
    269410        .get_default_chan       = b43_phy_ht_op_get_default_chan, 
    270         /* 
    271411        .recalc_txpower         = b43_phy_ht_op_recalc_txpower, 
    272412        .adjust_txpower         = b43_phy_ht_op_adjust_txpower, 
    273         */ 
    274413}; 
  • drivers/net/wireless/b43/phy_ht.h

    a b  
    44#include "phy_common.h" 
    55 
    66 
     7#define B43_PHY_HT_BANDCTL                      0x009 /* Band control */ 
    78#define B43_PHY_HT_TABLE_ADDR                   0x072 /* Table address */ 
    89#define B43_PHY_HT_TABLE_DATALO                 0x073 /* Table data low */ 
    910#define B43_PHY_HT_TABLE_DATAHI                 0x074 /* Table data high */ 
     11#define B43_PHY_HT_BW1                          0x1CE 
     12#define B43_PHY_HT_BW2                          0x1CF 
     13#define B43_PHY_HT_BW3                          0x1D0 
     14#define B43_PHY_HT_BW4                          0x1D1 
     15#define B43_PHY_HT_BW5                          0x1D2 
     16#define B43_PHY_HT_BW6                          0x1D3 
    1017 
    1118#define B43_PHY_HT_RF_CTL1                      B43_PHY_EXTG(0x010) 
    1219 
     
    2027 
    2128/* Values for PHY registers used on channel switching */ 
    2229struct b43_phy_ht_channeltab_e_phy { 
    23         /* TODO */ 
     30        u16 bw1; 
     31        u16 bw2; 
     32        u16 bw3; 
     33        u16 bw4; 
     34        u16 bw5; 
     35        u16 bw6; 
    2436}; 
    2537 
    2638 
  • new file drivers/net/wireless/b43/phy_lcn.c

    - +  
     1/* 
     2 
     3  Broadcom B43 wireless driver 
     4  IEEE 802.11n LCN-PHY support 
     5 
     6  This program is free software; you can redistribute it and/or modify 
     7  it under the terms of the GNU General Public License as published by 
     8  the Free Software Foundation; either version 2 of the License, or 
     9  (at your option) any later version. 
     10 
     11  This program is distributed in the hope that it will be useful, 
     12  but WITHOUT ANY WARRANTY; without even the implied warranty of 
     13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     14  GNU General Public License for more details. 
     15 
     16  You should have received a copy of the GNU General Public License 
     17  along with this program; see the file COPYING.  If not, write to 
     18  the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor, 
     19  Boston, MA 02110-1301, USA. 
     20 
     21*/ 
     22 
     23#include <linux/slab.h> 
     24 
     25#include "b43.h" 
     26#include "phy_lcn.h" 
     27#include "tables_phy_lcn.h" 
     28#include "main.h" 
     29 
     30/************************************************** 
     31 * PHY ops struct. 
     32 **************************************************/ 
     33 
     34const struct b43_phy_operations b43_phyops_lcn = { 
     35        /* 
     36        .allocate               = b43_phy_lcn_op_allocate, 
     37        .free                   = b43_phy_lcn_op_free, 
     38        .prepare_structs        = b43_phy_lcn_op_prepare_structs, 
     39        .init                   = b43_phy_lcn_op_init, 
     40        .phy_read               = b43_phy_lcn_op_read, 
     41        .phy_write              = b43_phy_lcn_op_write, 
     42        .phy_maskset            = b43_phy_lcn_op_maskset, 
     43        .radio_read             = b43_phy_lcn_op_radio_read, 
     44        .radio_write            = b43_phy_lcn_op_radio_write, 
     45        .software_rfkill        = b43_phy_lcn_op_software_rfkill, 
     46        .switch_analog          = b43_phy_lcn_op_switch_analog, 
     47        .switch_channel         = b43_phy_lcn_op_switch_channel, 
     48        .get_default_chan       = b43_phy_lcn_op_get_default_chan, 
     49        .recalc_txpower         = b43_phy_lcn_op_recalc_txpower, 
     50        .adjust_txpower         = b43_phy_lcn_op_adjust_txpower, 
     51        */ 
     52}; 
  • new file drivers/net/wireless/b43/phy_lcn.h

    - +  
     1#ifndef B43_PHY_LCN_H_ 
     2#define B43_PHY_LCN_H_ 
     3 
     4#include "phy_common.h" 
     5 
     6 
     7struct b43_phy_lcn { 
     8}; 
     9 
     10 
     11struct b43_phy_operations; 
     12extern const struct b43_phy_operations b43_phyops_lcn; 
     13 
     14#endif /* B43_PHY_LCN_H_ */ 
     15 No newline at end of file 
  • drivers/net/wireless/b43/phy_n.c

    a b static void b43_nphy_tx_lp_fbw(struct b4 
    603603/* http://bcm-v4.sipsolutions.net/802.11/PHY/N/BmacPhyClkFgc */ 
    604604static void b43_nphy_bmac_clock_fgc(struct b43_wldev *dev, bool force) 
    605605{ 
    606         u32 tmslow; 
     606        u32 tmp; 
    607607 
    608608        if (dev->phy.type != B43_PHYTYPE_N) 
    609609                return; 
    610610 
    611         tmslow = ssb_read32(dev->sdev, SSB_TMSLOW); 
    612         if (force) 
    613                 tmslow |= SSB_TMSLOW_FGC; 
    614         else 
    615                 tmslow &= ~SSB_TMSLOW_FGC; 
    616         ssb_write32(dev->sdev, SSB_TMSLOW, tmslow); 
     611        switch (dev->dev->bus_type) { 
     612#ifdef CONFIG_B43_BCMA 
     613        case B43_BUS_BCMA: 
     614                tmp = bcma_aread32(dev->dev->bdev, BCMA_IOCTL); 
     615                if (force) 
     616                        tmp |= BCMA_IOCTL_FGC; 
     617                else 
     618                        tmp &= ~BCMA_IOCTL_FGC; 
     619                bcma_awrite32(dev->dev->bdev, BCMA_IOCTL, tmp); 
     620                break; 
     621#endif 
     622#ifdef CONFIG_B43_SSB 
     623        case B43_BUS_SSB: 
     624                tmp = ssb_read32(dev->dev->sdev, SSB_TMSLOW); 
     625                if (force) 
     626                        tmp |= SSB_TMSLOW_FGC; 
     627                else 
     628                        tmp &= ~SSB_TMSLOW_FGC; 
     629                ssb_write32(dev->dev->sdev, SSB_TMSLOW, tmp); 
     630                break; 
     631#endif 
     632        } 
    617633} 
    618634 
    619635/* http://bcm-v4.sipsolutions.net/802.11/PHY/N/CCA */ 
    static void b43_nphy_superswitch_init(st 
    958974                b43_phy_write(dev, B43_NPHY_GPIO_LOOEN, 0); 
    959975                b43_phy_write(dev, B43_NPHY_GPIO_HIOEN, 0); 
    960976 
    961                 ssb_chipco_gpio_control(&dev->sdev->bus->chipco, 0xFC00, 
    962                                         0xFC00); 
     977                switch (dev->dev->bus_type) { 
     978#ifdef CONFIG_B43_BCMA 
     979                case B43_BUS_BCMA: 
     980                        bcma_chipco_gpio_control(&dev->dev->bdev->bus->drv_cc, 
     981                                                 0xFC00, 0xFC00); 
     982                        break; 
     983#endif 
     984#ifdef CONFIG_B43_SSB 
     985                case B43_BUS_SSB: 
     986                        ssb_chipco_gpio_control(&dev->dev->sdev->bus->chipco, 
     987                                                0xFC00, 0xFC00); 
     988                        break; 
     989#endif 
     990                } 
     991 
    963992                b43_write32(dev, B43_MMIO_MACCTL, 
    964993                        b43_read32(dev, B43_MMIO_MACCTL) & 
    965994                        ~B43_MACCTL_GPOUTSMSK); 
    int b43_phy_initn(struct b43_wldev *dev) 
    36003629        if ((dev->phy.rev >= 3) && 
    36013630           (sprom->boardflags_lo & B43_BFL_EXTLNA) && 
    36023631           (b43_current_band(dev->wl) == IEEE80211_BAND_2GHZ)) { 
    3603                 chipco_set32(&dev->sdev->bus->chipco, SSB_CHIPCO_CHIPCTL, 0x40); 
     3632                switch (dev->dev->bus_type) { 
     3633#ifdef CONFIG_B43_BCMA 
     3634                case B43_BUS_BCMA: 
     3635                        bcma_cc_set32(&dev->dev->bdev->bus->drv_cc, 
     3636                                      BCMA_CC_CHIPCTL, 0x40); 
     3637                        break; 
     3638#endif 
     3639#ifdef CONFIG_B43_SSB 
     3640                case B43_BUS_SSB: 
     3641                        chipco_set32(&dev->dev->sdev->bus->chipco, 
     3642                                     SSB_CHIPCO_CHIPCTL, 0x40); 
     3643                        break; 
     3644#endif 
     3645                } 
    36043646        } 
    36053647        nphy->deaf_count = 0; 
    36063648        b43_nphy_tables_init(dev); 
  • drivers/net/wireless/b43/radio_2059.c

    a b  
    2323#include "b43.h" 
    2424#include "radio_2059.h" 
    2525 
     26#define RADIOREGS(r00, r01, r02, r03, r04, r05, r06, r07, r08, r09, \ 
     27                  r10, r11, r12, r13, r14, r15, r16, r17, r18, r19, \ 
     28                  r20, r21, r22, r23, r24, r25, r26, r27, r28) \ 
     29        .radio_syn16                    = r00,  \ 
     30        .radio_syn17                    = r01,  \ 
     31        .radio_syn22                    = r02,  \ 
     32        .radio_syn25                    = r03,  \ 
     33        .radio_syn27                    = r04,  \ 
     34        .radio_syn28                    = r05,  \ 
     35        .radio_syn29                    = r06,  \ 
     36        .radio_syn2c                    = r07,  \ 
     37        .radio_syn2d                    = r08,  \ 
     38        .radio_syn37                    = r09,  \ 
     39        .radio_syn41                    = r10,  \ 
     40        .radio_syn43                    = r11,  \ 
     41        .radio_syn47                    = r12,  \ 
     42        .radio_syn4a                    = r13,  \ 
     43        .radio_syn58                    = r14,  \ 
     44        .radio_syn5a                    = r15,  \ 
     45        .radio_syn6a                    = r16,  \ 
     46        .radio_syn6d                    = r17,  \ 
     47        .radio_syn6e                    = r18,  \ 
     48        .radio_syn92                    = r19,  \ 
     49        .radio_syn98                    = r20,  \ 
     50        .radio_rxtx4a                   = r21,  \ 
     51        .radio_rxtx58                   = r22,  \ 
     52        .radio_rxtx5a                   = r23,  \ 
     53        .radio_rxtx6a                   = r24,  \ 
     54        .radio_rxtx6d                   = r25,  \ 
     55        .radio_rxtx6e                   = r26,  \ 
     56        .radio_rxtx92                   = r27,  \ 
     57        .radio_rxtx98                   = r28 
     58 
     59#define PHYREGS(r0, r1, r2, r3, r4, r5) \ 
     60        .phy_regs.bw1   = r0,   \ 
     61        .phy_regs.bw2   = r1,   \ 
     62        .phy_regs.bw3   = r2,   \ 
     63        .phy_regs.bw4   = r3,   \ 
     64        .phy_regs.bw5   = r4,   \ 
     65        .phy_regs.bw6   = r5 
     66 
     67static const struct b43_phy_ht_channeltab_e_radio2059 b43_phy_ht_channeltab_radio2059[] = { 
     68  {     .freq                   = 2412, 
     69        RADIOREGS(0x48, 0x16, 0x30, 0x1b, 0x0a, 0x0a, 0x30, 0x6c, 
     70                  0x09, 0x0f, 0x0a, 0x00, 0x0a, 0x00, 0x61, 0x03, 
     71                  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x61, 0x03, 
     72                  0x00, 0x00, 0x00, 0xf0, 0x00), 
     73        PHYREGS(0x03c9, 0x03c5, 0x03c1, 0x043a, 0x043f, 0x0443), 
     74  }, 
     75  {     .freq                   = 2417, 
     76        RADIOREGS(0x4b, 0x16, 0x30, 0x1b, 0x0a, 0x0a, 0x30, 0x71, 
     77                  0x09, 0x0f, 0x0a, 0x00, 0x0a, 0x00, 0x61, 0x03, 
     78                  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x61, 0x03, 
     79                  0x00, 0x00, 0x00, 0xf0, 0x00), 
     80        PHYREGS(0x03cb, 0x03c7, 0x03c3, 0x0438, 0x043d, 0x0441), 
     81  }, 
     82  {     .freq                   = 2422, 
     83        RADIOREGS(0x4e, 0x16, 0x30, 0x1b, 0x0a, 0x0a, 0x30, 0x76, 
     84                  0x09, 0x0f, 0x09, 0x00, 0x09, 0x00, 0x61, 0x03, 
     85                  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x61, 0x03, 
     86                  0x00, 0x00, 0x00, 0xf0, 0x00), 
     87        PHYREGS(0x03cd, 0x03c9, 0x03c5, 0x0436, 0x043a, 0x043f), 
     88  }, 
     89  {     .freq                   = 2427, 
     90        RADIOREGS(0x52, 0x16, 0x30, 0x1b, 0x0a, 0x0a, 0x30, 0x7b, 
     91                  0x09, 0x0f, 0x09, 0x00, 0x09, 0x00, 0x61, 0x03, 
     92                  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x61, 0x03, 
     93                  0x00, 0x00, 0x00, 0xf0, 0x00), 
     94        PHYREGS(0x03cf, 0x03cb, 0x03c7, 0x0434, 0x0438, 0x043d), 
     95  }, 
     96  {     .freq                   = 2432, 
     97        RADIOREGS(0x55, 0x16, 0x30, 0x1b, 0x0a, 0x0a, 0x30, 0x80, 
     98                  0x09, 0x0f, 0x08, 0x00, 0x08, 0x00, 0x61, 0x03, 
     99                  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x61, 0x03, 
     100                  0x00, 0x00, 0x00, 0xf0, 0x00), 
     101        PHYREGS(0x03d1, 0x03cd, 0x03c9, 0x0431, 0x0436, 0x043a), 
     102  }, 
     103  {     .freq                   = 2437, 
     104        RADIOREGS(0x58, 0x16, 0x30, 0x1b, 0x0a, 0x0a, 0x30, 0x85, 
     105                  0x09, 0x0f, 0x08, 0x00, 0x08, 0x00, 0x61, 0x03, 
     106                  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x61, 0x03, 
     107                  0x00, 0x00, 0x00, 0xf0, 0x00), 
     108        PHYREGS(0x03d3, 0x03cf, 0x03cb, 0x042f, 0x0434, 0x0438), 
     109  }, 
     110  {     .freq                   = 2442, 
     111        RADIOREGS(0x5c, 0x16, 0x30, 0x1b, 0x0a, 0x0a, 0x30, 0x8a, 
     112                  0x09, 0x0f, 0x07, 0x00, 0x07, 0x00, 0x61, 0x03, 
     113                  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x61, 0x03, 
     114                  0x00, 0x00, 0x00, 0xf0, 0x00), 
     115        PHYREGS(0x03d5, 0x03d1, 0x03cd, 0x042d, 0x0431, 0x0436), 
     116  }, 
     117  {     .freq                   = 2447, 
     118        RADIOREGS(0x5f, 0x16, 0x30, 0x1b, 0x0a, 0x0a, 0x30, 0x8f, 
     119                  0x09, 0x0f, 0x07, 0x00, 0x07, 0x00, 0x61, 0x03, 
     120                  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x61, 0x03, 
     121                  0x00, 0x00, 0x00, 0xf0, 0x00), 
     122        PHYREGS(0x03d7, 0x03d3, 0x03cf, 0x042b, 0x042f, 0x0434), 
     123  }, 
     124  {     .freq                   = 2452, 
     125        RADIOREGS(0x62, 0x16, 0x30, 0x1b, 0x0a, 0x0a, 0x30, 0x94, 
     126                  0x09, 0x0f, 0x07, 0x00, 0x07, 0x00, 0x61, 0x03, 
     127                  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x61, 0x03, 
     128                  0x00, 0x00, 0x00, 0xf0, 0x00), 
     129        PHYREGS(0x03d9, 0x03d5, 0x03d1, 0x0429, 0x042d, 0x0431), 
     130  }, 
     131  {     .freq                   = 2457, 
     132        RADIOREGS(0x66, 0x16, 0x30, 0x1b, 0x0a, 0x0a, 0x30, 0x99, 
     133                  0x09, 0x0f, 0x06, 0x00, 0x06, 0x00, 0x61, 0x03, 
     134                  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x61, 0x03, 
     135                  0x00, 0x00, 0x00, 0xf0, 0x00), 
     136        PHYREGS(0x03db, 0x03d7, 0x03d3, 0x0427, 0x042b, 0x042f), 
     137  }, 
     138  {     .freq                   = 2462, 
     139        RADIOREGS(0x69, 0x16, 0x30, 0x1b, 0x0a, 0x0a, 0x30, 0x9e, 
     140                  0x09, 0x0f, 0x06, 0x00, 0x06, 0x00, 0x61, 0x03, 
     141                  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x61, 0x03, 
     142                  0x00, 0x00, 0x00, 0xf0, 0x00), 
     143        PHYREGS(0x03dd, 0x03d9, 0x03d5, 0x0424, 0x0429, 0x042d), 
     144  }, 
     145  {     .freq                   = 2467, 
     146        RADIOREGS(0x6c, 0x16, 0x30, 0x1b, 0x0a, 0x0a, 0x30, 0xa3, 
     147                  0x09, 0x0f, 0x05, 0x00, 0x05, 0x00, 0x61, 0x03, 
     148                  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x61, 0x03, 
     149                  0x00, 0x00, 0x00, 0xf0, 0x00), 
     150        PHYREGS(0x03df, 0x03db, 0x03d7, 0x0422, 0x0427, 0x042b), 
     151  }, 
     152  {     .freq                   = 2472, 
     153        RADIOREGS(0x70, 0x16, 0x30, 0x1b, 0x0a, 0x0a, 0x30, 0xa8, 
     154                  0x09, 0x0f, 0x05, 0x00, 0x05, 0x00, 0x61, 0x03, 
     155                  0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x61, 0x03, 
     156                  0x00, 0x00, 0x00, 0xf0, 0x00), 
     157        PHYREGS(0x03e1, 0x03dd, 0x03d9, 0x0420, 0x0424, 0x0429), 
     158  }, 
     159}; 
     160 
    26161const struct b43_phy_ht_channeltab_e_radio2059 
    27162*b43_phy_ht_get_channeltab_e_r2059(struct b43_wldev *dev, u16 freq) 
    28163{ 
     164        const struct b43_phy_ht_channeltab_e_radio2059 *e; 
     165        unsigned int i; 
     166 
     167        e = b43_phy_ht_channeltab_radio2059; 
     168        for (i = 0; i < ARRAY_SIZE(b43_phy_ht_channeltab_radio2059); i++, e++) { 
     169                if (e->freq == freq) 
     170                        return e; 
     171        } 
     172 
    29173        return NULL; 
    30174} 
  • drivers/net/wireless/b43/radio_2059.h

    a b  
    55 
    66#include "phy_ht.h" 
    77 
     8#define R2059_SYN                       0x000 
     9#define R2059_TXRX0                     0x400 
     10#define R2059_RXRX1                     0x800 
     11#define R2059_ALL                       0xC00 
     12 
    813/* Values for various registers uploaded on channel switching */ 
    914struct b43_phy_ht_channeltab_e_radio2059 { 
    1015        /* The channel frequency in MHz */ 
  • new file drivers/net/wireless/b43/tables_phy_ht.c

    - +  
     1/* 
     2 
     3  Broadcom B43 wireless driver 
     4  IEEE 802.11n HT-PHY data tables 
     5 
     6  This program is free software; you can redistribute it and/or modify 
     7  it under the terms of the GNU General Public License as published by 
     8  the Free Software Foundation; either version 2 of the License, or 
     9  (at your option) any later version. 
     10 
     11  This program is distributed in the hope that it will be useful, 
     12  but WITHOUT ANY WARRANTY; without even the implied warranty of 
     13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     14  GNU General Public License for more details. 
     15 
     16  You should have received a copy of the GNU General Public License 
     17  along with this program; see the file COPYING.  If not, write to 
     18  the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor, 
     19  Boston, MA 02110-1301, USA. 
     20 
     21*/ 
     22 
     23#include "b43.h" 
     24#include "tables_phy_ht.h" 
     25#include "phy_common.h" 
     26#include "phy_ht.h" 
     27 
     28static const u16 b43_httab_0x12[] = { 
     29        0x0000, 0x0008, 0x000a, 0x0010, 0x0012, 0x0019, 
     30        0x001a, 0x001c, 0x0080, 0x0088, 0x008a, 0x0090, 
     31        0x0092, 0x0099, 0x009a, 0x009c, 0x0100, 0x0108, 
     32        0x010a, 0x0110, 0x0112, 0x0119, 0x011a, 0x011c, 
     33        0x0180, 0x0188, 0x018a, 0x0190, 0x0192, 0x0199, 
     34        0x019a, 0x019c, 0x0000, 0x0098, 0x00a0, 0x00a8, 
     35        0x009a, 0x00a2, 0x00aa, 0x0120, 0x0128, 0x0128, 
     36        0x0130, 0x0138, 0x0138, 0x0140, 0x0122, 0x012a, 
     37        0x012a, 0x0132, 0x013a, 0x013a, 0x0142, 0x01a8, 
     38        0x01b0, 0x01b8, 0x01b0, 0x01b8, 0x01c0, 0x01c8, 
     39        0x01c0, 0x01c8, 0x01d0, 0x01d0, 0x01d8, 0x01aa, 
     40        0x01b2, 0x01ba, 0x01b2, 0x01ba, 0x01c2, 0x01ca, 
     41        0x01c2, 0x01ca, 0x01d2, 0x01d2, 0x01da, 0x0001, 
     42        0x0002, 0x0004, 0x0009, 0x000c, 0x0011, 0x0014, 
     43        0x0018, 0x0020, 0x0021, 0x0022, 0x0024, 0x0081, 
     44        0x0082, 0x0084, 0x0089, 0x008c, 0x0091, 0x0094, 
     45        0x0098, 0x00a0, 0x00a1, 0x00a2, 0x00a4, 0x0007, 
     46        0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 
     47        0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 
     48        0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 
     49        0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 0x0007, 
     50        0x0007, 0x0007, 
     51}; 
     52 
     53static const u16 b43_httab_0x27[] = { 
     54        0x0009, 0x000e, 0x0011, 0x0014, 0x0017, 0x001a, 
     55        0x001d, 0x0020, 0x0009, 0x000e, 0x0011, 0x0014, 
     56        0x0017, 0x001a, 0x001d, 0x0020, 0x0009, 0x000e, 
     57        0x0011, 0x0014, 0x0017, 0x001a, 0x001d, 0x0020, 
     58        0x0009, 0x000e, 0x0011, 0x0014, 0x0017, 0x001a, 
     59        0x001d, 0x0020, 
     60}; 
     61 
     62static const u16 b43_httab_0x26[] = { 
     63        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     64        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     65        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     66        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     67        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     68        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     69        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     70        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     71        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     72        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     73        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     74        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     75        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     76        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     77        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     78        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     79        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     80        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     81        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     82        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     83        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     84        0x0000, 0x0000, 
     85}; 
     86 
     87static const u32 b43_httab_0x25[] = { 
     88        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     89        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     90        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     91        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     92        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     93        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     94        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     95        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     96        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     97        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     98        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     99        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     100        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     101        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     102        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     103        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     104        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     105        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     106        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     107        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     108        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     109        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     110        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     111        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     112        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     113        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     114        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     115        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     116        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     117        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     118        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     119        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     120}; 
     121 
     122static const u32 b43_httab_0x2f[] = { 
     123        0x00035700, 0x0002cc9a, 0x00026666, 0x0001581f, 
     124        0x0001581f, 0x0001581f, 0x0001581f, 0x0001581f, 
     125        0x0001581f, 0x0001581f, 0x0001581f, 0x00035700, 
     126        0x0002cc9a, 0x00026666, 0x0001581f, 0x0001581f, 
     127        0x0001581f, 0x0001581f, 0x0001581f, 0x0001581f, 
     128        0x0001581f, 0x0001581f, 
     129}; 
     130 
     131static const u16 b43_httab_0x1a[] = { 
     132        0x0055, 0x0054, 0x0054, 0x0053, 0x0052, 0x0052, 
     133        0x0051, 0x0051, 0x0050, 0x004f, 0x004f, 0x004e, 
     134        0x004e, 0x004d, 0x004c, 0x004c, 0x004b, 0x004a, 
     135        0x0049, 0x0049, 0x0048, 0x0047, 0x0046, 0x0046, 
     136        0x0045, 0x0044, 0x0043, 0x0042, 0x0041, 0x0040, 
     137        0x0040, 0x003f, 0x003e, 0x003d, 0x003c, 0x003a, 
     138        0x0039, 0x0038, 0x0037, 0x0036, 0x0035, 0x0033, 
     139        0x0032, 0x0031, 0x002f, 0x002e, 0x002c, 0x002b, 
     140        0x0029, 0x0027, 0x0025, 0x0023, 0x0021, 0x001f, 
     141        0x001d, 0x001a, 0x0018, 0x0015, 0x0012, 0x000e, 
     142        0x000b, 0x0007, 0x0002, 0x00fd, 
     143}; 
     144 
     145static const u16 b43_httab_0x1b[] = { 
     146        0x0055, 0x0054, 0x0054, 0x0053, 0x0052, 0x0052, 
     147        0x0051, 0x0051, 0x0050, 0x004f, 0x004f, 0x004e, 
     148        0x004e, 0x004d, 0x004c, 0x004c, 0x004b, 0x004a, 
     149        0x0049, 0x0049, 0x0048, 0x0047, 0x0046, 0x0046, 
     150        0x0045, 0x0044, 0x0043, 0x0042, 0x0041, 0x0040, 
     151        0x0040, 0x003f, 0x003e, 0x003d, 0x003c, 0x003a, 
     152        0x0039, 0x0038, 0x0037, 0x0036, 0x0035, 0x0033, 
     153        0x0032, 0x0031, 0x002f, 0x002e, 0x002c, 0x002b, 
     154        0x0029, 0x0027, 0x0025, 0x0023, 0x0021, 0x001f, 
     155        0x001d, 0x001a, 0x0018, 0x0015, 0x0012, 0x000e, 
     156        0x000b, 0x0007, 0x0002, 0x00fd, 
     157}; 
     158 
     159static const u16 b43_httab_0x1c[] = { 
     160        0x0055, 0x0054, 0x0054, 0x0053, 0x0052, 0x0052, 
     161        0x0051, 0x0051, 0x0050, 0x004f, 0x004f, 0x004e, 
     162        0x004e, 0x004d, 0x004c, 0x004c, 0x004b, 0x004a, 
     163        0x0049, 0x0049, 0x0048, 0x0047, 0x0046, 0x0046, 
     164        0x0045, 0x0044, 0x0043, 0x0042, 0x0041, 0x0040, 
     165        0x0040, 0x003f, 0x003e, 0x003d, 0x003c, 0x003a, 
     166        0x0039, 0x0038, 0x0037, 0x0036, 0x0035, 0x0033, 
     167        0x0032, 0x0031, 0x002f, 0x002e, 0x002c, 0x002b, 
     168        0x0029, 0x0027, 0x0025, 0x0023, 0x0021, 0x001f, 
     169        0x001d, 0x001a, 0x0018, 0x0015, 0x0012, 0x000e, 
     170        0x000b, 0x0007, 0x0002, 0x00fd, 
     171}; 
     172 
     173static const u32 b43_httab_0x1a_0xc0[] = { 
     174        0x5bf70044, 0x5bf70042, 0x5bf70040, 0x5bf7003e, 
     175        0x5bf7003c, 0x5bf7003b, 0x5bf70039, 0x5bf70037, 
     176        0x5bf70036, 0x5bf70034, 0x5bf70033, 0x5bf70031, 
     177        0x5bf70030, 0x5ba70044, 0x5ba70042, 0x5ba70040, 
     178        0x5ba7003e, 0x5ba7003c, 0x5ba7003b, 0x5ba70039, 
     179        0x5ba70037, 0x5ba70036, 0x5ba70034, 0x5ba70033, 
     180        0x5b770044, 0x5b770042, 0x5b770040, 0x5b77003e, 
     181        0x5b77003c, 0x5b77003b, 0x5b770039, 0x5b770037, 
     182        0x5b770036, 0x5b770034, 0x5b770033, 0x5b770031, 
     183        0x5b770030, 0x5b77002f, 0x5b77002d, 0x5b77002c, 
     184        0x5b470044, 0x5b470042, 0x5b470040, 0x5b47003e, 
     185        0x5b47003c, 0x5b47003b, 0x5b470039, 0x5b470037, 
     186        0x5b470036, 0x5b470034, 0x5b470033, 0x5b470031, 
     187        0x5b470030, 0x5b47002f, 0x5b47002d, 0x5b47002c, 
     188        0x5b47002b, 0x5b47002a, 0x5b270044, 0x5b270042, 
     189        0x5b270040, 0x5b27003e, 0x5b27003c, 0x5b27003b, 
     190        0x5b270039, 0x5b270037, 0x5b270036, 0x5b270034, 
     191        0x5b270033, 0x5b270031, 0x5b270030, 0x5b27002f, 
     192        0x5b170044, 0x5b170042, 0x5b170040, 0x5b17003e, 
     193        0x5b17003c, 0x5b17003b, 0x5b170039, 0x5b170037, 
     194        0x5b170036, 0x5b170034, 0x5b170033, 0x5b170031, 
     195        0x5b170030, 0x5b17002f, 0x5b17002d, 0x5b17002c, 
     196        0x5b17002b, 0x5b17002a, 0x5b170028, 0x5b170027, 
     197        0x5b170026, 0x5b170025, 0x5b170024, 0x5b170023, 
     198        0x5b070044, 0x5b070042, 0x5b070040, 0x5b07003e, 
     199        0x5b07003c, 0x5b07003b, 0x5b070039, 0x5b070037, 
     200        0x5b070036, 0x5b070034, 0x5b070033, 0x5b070031, 
     201        0x5b070030, 0x5b07002f, 0x5b07002d, 0x5b07002c, 
     202        0x5b07002b, 0x5b07002a, 0x5b070028, 0x5b070027, 
     203        0x5b070026, 0x5b070025, 0x5b070024, 0x5b070023, 
     204        0x5b070022, 0x5b070021, 0x5b070020, 0x5b07001f, 
     205        0x5b07001e, 0x5b07001d, 0x5b07001d, 0x5b07001c, 
     206}; 
     207 
     208static const u32 b43_httab_0x1a_0x140[] = { 
     209        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     210        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     211        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     212        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     213        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     214        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     215        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     216        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     217        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     218        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     219        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     220        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     221        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     222        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     223        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     224        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     225        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     226        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     227        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     228        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     229        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     230        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     231        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     232        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     233        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     234        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     235        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     236        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     237        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     238        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     239        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     240        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     241}; 
     242 
     243static const u32 b43_httab_0x1b_0x140[] = { 
     244        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     245        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     246        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     247        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     248        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     249        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     250        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     251        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     252        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     253        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     254        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     255        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     256        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     257        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     258        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     259        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     260        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     261        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     262        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     263        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     264        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     265        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     266        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     267        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     268        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     269        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     270        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     271        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     272        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     273        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     274        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     275        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     276}; 
     277 
     278static const u32 b43_httab_0x1c_0x140[] = { 
     279        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     280        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     281        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     282        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     283        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     284        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     285        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     286        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     287        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     288        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     289        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     290        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     291        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     292        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     293        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     294        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     295        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     296        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     297        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     298        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     299        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     300        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     301        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     302        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     303        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     304        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     305        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     306        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     307        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     308        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     309        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     310        0x00000000, 0x00000000, 0x00000000, 0x00000000, 
     311}; 
     312 
     313static const u16 b43_httab_0x1a_0x1c0[] = { 
     314        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     315        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     316        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     317        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     318        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     319        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     320        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     321        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     322        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     323        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     324        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     325        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     326        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     327        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     328        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     329        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     330        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     331        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     332        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     333        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     334        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     335        0x0000, 0x0000, 
     336}; 
     337 
     338static const u16 b43_httab_0x1b_0x1c0[] = { 
     339        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     340        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     341        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     342        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     343        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     344        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     345        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     346        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     347        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     348        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     349        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     350        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     351        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     352        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     353        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     354        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     355        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     356        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     357        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     358        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     359        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     360        0x0000, 0x0000, 
     361}; 
     362 
     363static const u16 b43_httab_0x1c_0x1c0[] = { 
     364        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     365        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     366        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     367        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     368        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     369        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     370        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     371        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     372        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     373        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     374        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     375        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     376        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     377        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     378        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     379        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     380        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     381        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     382        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     383        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     384        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
     385        0x0000, 0x0000, 
     386}; 
     387 
     388static const u16 b43_httab_0x1a_0x240[] = { 
     389        0x0036, 0x0036, 0x0036, 0x0036, 0x0036, 0x0036, 
     390        0x0036, 0x0036, 0x0036, 0x0036, 0x0036, 0x0036, 
     391        0x0036, 0x002a, 0x002a, 0x002a, 0x002a, 0x002a, 
     392        0x002a, 0x002a, 0x002a, 0x002a, 0x002a, 0x002a, 
     393        0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 
     394        0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 
     395        0x001e, 0x001e, 0x001e, 0x001e, 0x000e, 0x000e, 
     396        0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 
     397        0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 
     398        0x000e, 0x000e, 0x000e, 0x000e, 0x01fc, 0x01fc, 
     399        0x01fc, 0x01fc, 0x01fc, 0x01fc, 0x01fc, 0x01fc, 
     400        0x01fc, 0x01fc, 0x01fc, 0x01fc, 0x01fc, 0x01fc, 
     401        0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 
     402        0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 
     403        0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 
     404        0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 
     405        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     406        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     407        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     408        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     409        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     410        0x01d6, 0x01d6, 
     411}; 
     412 
     413static const u16 b43_httab_0x1b_0x240[] = { 
     414        0x0036, 0x0036, 0x0036, 0x0036, 0x0036, 0x0036, 
     415        0x0036, 0x0036, 0x0036, 0x0036, 0x0036, 0x0036, 
     416        0x0036, 0x002a, 0x002a, 0x002a, 0x002a, 0x002a, 
     417        0x002a, 0x002a, 0x002a, 0x002a, 0x002a, 0x002a, 
     418        0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 
     419        0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 
     420        0x001e, 0x001e, 0x001e, 0x001e, 0x000e, 0x000e, 
     421        0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 
     422        0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 
     423        0x000e, 0x000e, 0x000e, 0x000e, 0x01fc, 0x01fc, 
     424        0x01fc, 0x01fc, 0x01fc, 0x01fc, 0x01fc, 0x01fc, 
     425        0x01fc, 0x01fc, 0x01fc, 0x01fc, 0x01fc, 0x01fc, 
     426        0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 
     427        0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 
     428        0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 
     429        0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 
     430        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     431        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     432        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     433        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     434        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     435        0x01d6, 0x01d6, 
     436}; 
     437 
     438static const u16 b43_httab_0x1c_0x240[] = { 
     439        0x0036, 0x0036, 0x0036, 0x0036, 0x0036, 0x0036, 
     440        0x0036, 0x0036, 0x0036, 0x0036, 0x0036, 0x0036, 
     441        0x0036, 0x002a, 0x002a, 0x002a, 0x002a, 0x002a, 
     442        0x002a, 0x002a, 0x002a, 0x002a, 0x002a, 0x002a, 
     443        0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 
     444        0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 0x001e, 
     445        0x001e, 0x001e, 0x001e, 0x001e, 0x000e, 0x000e, 
     446        0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 
     447        0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 0x000e, 
     448        0x000e, 0x000e, 0x000e, 0x000e, 0x01fc, 0x01fc, 
     449        0x01fc, 0x01fc, 0x01fc, 0x01fc, 0x01fc, 0x01fc, 
     450        0x01fc, 0x01fc, 0x01fc, 0x01fc, 0x01fc, 0x01fc, 
     451        0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 
     452        0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 
     453        0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 
     454        0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 0x01ee, 
     455        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     456        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     457        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     458        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     459        0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 0x01d6, 
     460        0x01d6, 0x01d6, 
     461}; 
     462 
     463static const u32 b43_httab_0x1f[] = { 
     464        0x00000000, 0x00000000, 0x00016023, 0x00006028, 
     465        0x00034036, 0x0003402e, 0x0007203c, 0x0006e037, 
     466        0x00070030, 0x0009401f, 0x0009a00f, 0x000b600d, 
     467        0x000c8007, 0x000ce007, 0x00101fff, 0x00121ff9, 
     468        0x0012e004, 0x0014dffc, 0x0016dff6, 0x0018dfe9, 
     469        0x001b3fe5, 0x001c5fd0, 0x001ddfc2, 0x001f1fb6, 
     470        0x00207fa4, 0x00219f8f, 0x0022ff7d, 0x00247f6c, 
     471        0x0024df5b, 0x00267f4b, 0x0027df3b, 0x0029bf3b, 
     472        0x002b5f2f, 0x002d3f2e, 0x002f5f2a, 0x002fff15, 
     473        0x00315f0b, 0x0032defa, 0x0033beeb, 0x0034fed9, 
     474        0x00353ec5, 0x00361eb0, 0x00363e9b, 0x0036be87, 
     475        0x0036be70, 0x0038fe67, 0x0044beb2, 0x00513ef3, 
     476        0x00595f11, 0x00669f3d, 0x0078dfdf, 0x00a143aa, 
     477        0x01642fff, 0x0162afff, 0x01620fff, 0x0160cfff, 
     478        0x015f0fff, 0x015dafff, 0x015bcfff, 0x015bcfff, 
     479        0x015b4fff, 0x015acfff, 0x01590fff, 0x0156cfff, 
     480}; 
     481 
     482static const u32 b43_httab_0x21[] = { 
     483        0x00000000, 0x00000000, 0x00016023, 0x00006028, 
     484        0x00034036, 0x0003402e, 0x0007203c, 0x0006e037, 
     485        0x00070030, 0x0009401f, 0x0009a00f, 0x000b600d, 
     486        0x000c8007, 0x000ce007, 0x00101fff, 0x00121ff9, 
     487        0x0012e004, 0x0014dffc, 0x0016dff6, 0x0018dfe9, 
     488        0x001b3fe5, 0x001c5fd0, 0x001ddfc2, 0x001f1fb6, 
     489        0x00207fa4, 0x00219f8f, 0x0022ff7d, 0x00247f6c, 
     490        0x0024df5b, 0x00267f4b, 0x0027df3b, 0x0029bf3b, 
     491        0x002b5f2f, 0x002d3f2e, 0x002f5f2a, 0x002fff15, 
     492        0x00315f0b, 0x0032defa, 0x0033beeb, 0x0034fed9, 
     493        0x00353ec5, 0x00361eb0, 0x00363e9b, 0x0036be87, 
     494        0x0036be70, 0x0038fe67, 0x0044beb2, 0x00513ef3, 
     495        0x00595f11, 0x00669f3d, 0x0078dfdf, 0x00a143aa, 
     496        0x01642fff, 0x0162afff, 0x01620fff, 0x0160cfff, 
     497        0x015f0fff, 0x015dafff, 0x015bcfff, 0x015bcfff, 
     498        0x015b4fff, 0x015acfff, 0x01590fff, 0x0156cfff, 
     499}; 
     500 
     501static const u32 b43_httab_0x23[] = { 
     502        0x00000000, 0x00000000, 0x00016023, 0x00006028, 
     503        0x00034036, 0x0003402e, 0x0007203c, 0x0006e037, 
     504        0x00070030, 0x0009401f, 0x0009a00f, 0x000b600d, 
     505        0x000c8007, 0x000ce007, 0x00101fff, 0x00121ff9, 
     506        0x0012e004, 0x0014dffc, 0x0016dff6, 0x0018dfe9, 
     507        0x001b3fe5, 0x001c5fd0, 0x001ddfc2, 0x001f1fb6, 
     508        0x00207fa4, 0x00219f8f, 0x0022ff7d, 0x00247f6c, 
     509        0x0024df5b, 0x00267f4b, 0x0027df3b, 0x0029bf3b, 
     510        0x002b5f2f, 0x002d3f2e, 0x002f5f2a, 0x002fff15, 
     511        0x00315f0b, 0x0032defa, 0x0033beeb, 0x0034fed9, 
     512        0x00353ec5, 0x00361eb0, 0x00363e9b, 0x0036be87, 
     513        0x0036be70, 0x0038fe67, 0x0044beb2, 0x00513ef3, 
     514        0x00595f11, 0x00669f3d, 0x0078dfdf, 0x00a143aa, 
     515        0x01642fff, 0x0162afff, 0x01620fff, 0x0160cfff, 
     516        0x015f0fff, 0x015dafff, 0x015bcfff, 0x015bcfff, 
     517        0x015b4fff, 0x015acfff, 0x01590fff, 0x0156cfff, 
     518}; 
     519 
     520static const u32 b43_httab_0x20[] = { 
     521        0x0b5e002d, 0x0ae2002f, 0x0a3b0032, 0x09a70035, 
     522        0x09220038, 0x08ab003b, 0x081f003f, 0x07a20043, 
     523        0x07340047, 0x06d2004b, 0x067a004f, 0x06170054, 
     524        0x05bf0059, 0x0571005e, 0x051e0064, 0x04d3006a, 
     525        0x04910070, 0x044c0077, 0x040f007e, 0x03d90085, 
     526        0x03a1008d, 0x036f0095, 0x033d009e, 0x030b00a8, 
     527        0x02e000b2, 0x02b900bc, 0x029200c7, 0x026d00d3, 
     528        0x024900e0, 0x022900ed, 0x020a00fb, 0x01ec010a, 
     529        0x01d20119, 0x01b7012a, 0x019e013c, 0x0188014e, 
     530        0x01720162, 0x015d0177, 0x0149018e, 0x013701a5, 
     531        0x012601be, 0x011501d8, 0x010601f4, 0x00f70212, 
     532        0x00e90231, 0x00dc0253, 0x00d00276, 0x00c4029b, 
     533        0x00b902c3, 0x00af02ed, 0x00a50319, 0x009c0348, 
     534        0x0093037a, 0x008b03af, 0x008303e6, 0x007c0422, 
     535        0x00750460, 0x006e04a3, 0x006804e9, 0x00620533, 
     536        0x005d0582, 0x005805d6, 0x0053062e, 0x004e068c, 
     537}; 
     538 
     539static const u32 b43_httab_0x22[] = { 
     540        0x0b5e002d, 0x0ae2002f, 0x0a3b0032, 0x09a70035, 
     541        0x09220038, 0x08ab003b, 0x081f003f, 0x07a20043, 
     542        0x07340047, 0x06d2004b, 0x067a004f, 0x06170054, 
     543        0x05bf0059, 0x0571005e, 0x051e0064, 0x04d3006a, 
     544        0x04910070, 0x044c0077, 0x040f007e, 0x03d90085, 
     545        0x03a1008d, 0x036f0095, 0x033d009e, 0x030b00a8, 
     546        0x02e000b2, 0x02b900bc, 0x029200c7, 0x026d00d3, 
     547        0x024900e0, 0x022900ed, 0x020a00fb, 0x01ec010a, 
     548        0x01d20119, 0x01b7012a, 0x019e013c, 0x0188014e, 
     549        0x01720162, 0x015d0177, 0x0149018e, 0x013701a5, 
     550        0x012601be, 0x011501d8, 0x010601f4, 0x00f70212, 
     551        0x00e90231, 0x00dc0253, 0x00d00276, 0x00c4029b, 
     552        0x00b902c3, 0x00af02ed, 0x00a50319, 0x009c0348, 
     553        0x0093037a, 0x008b03af, 0x008303e6, 0x007c0422, 
     554        0x00750460, 0x006e04a3, 0x006804e9, 0x00620533, 
     555        0x005d0582, 0x005805d6, 0x0053062e, 0x004e068c, 
     556}; 
     557 
     558static const u32 b43_httab_0x24[] = { 
     559        0x0b5e002d, 0x0ae2002f, 0x0a3b0032, 0x09a70035, 
     560        0x09220038, 0x08ab003b, 0x081f003f, 0x07a20043, 
     561        0x07340047, 0x06d2004b, 0x067a004f, 0x06170054, 
     562        0x05bf0059, 0x0571005e, 0x051e0064, 0x04d3006a, 
     563        0x04910070, 0x044c0077, 0x040f007e, 0x03d90085, 
     564        0x03a1008d, 0x036f0095, 0x033d009e, 0x030b00a8, 
     565        0x02e000b2, 0x02b900bc, 0x029200c7, 0x026d00d3, 
     566        0x024900e0, 0x022900ed, 0x020a00fb, 0x01ec010a, 
     567        0x01d20119, 0x01b7012a, 0x019e013c, 0x0188014e, 
     568        0x01720162, 0x015d0177, 0x0149018e, 0x013701a5, 
     569        0x012601be, 0x011501d8, 0x010601f4, 0x00f70212, 
     570        0x00e90231, 0x00dc0253, 0x00d00276, 0x00c4029b, 
     571        0x00b902c3, 0x00af02ed, 0x00a50319, 0x009c0348, 
     572        0x0093037a, 0x008b03af, 0x008303e6, 0x007c0422, 
     573        0x00750460, 0x006e04a3, 0x006804e9, 0x00620533, 
     574        0x005d0582, 0x005805d6, 0x0053062e, 0x004e068c, 
     575}; 
     576 
     577/************************************************** 
     578 * R/W ops. 
     579 **************************************************/ 
     580 
     581u32 b43_httab_read(struct b43_wldev *dev, u32 offset) 
     582{ 
     583        u32 type, value; 
     584 
     585        type = offset & B43_HTTAB_TYPEMASK; 
     586        offset &= ~B43_HTTAB_TYPEMASK; 
     587        B43_WARN_ON(offset > 0xFFFF); 
     588 
     589        switch (type) { 
     590        case B43_HTTAB_8BIT: 
     591                b43_phy_write(dev, B43_PHY_HT_TABLE_ADDR, offset); 
     592                value = b43_phy_read(dev, B43_PHY_HT_TABLE_DATALO) & 0xFF; 
     593                break; 
     594        case B43_HTTAB_16BIT: 
     595                b43_phy_write(dev, B43_PHY_HT_TABLE_ADDR, offset); 
     596                value = b43_phy_read(dev, B43_PHY_HT_TABLE_DATALO); 
     597                break; 
     598        case B43_HTTAB_32BIT: 
     599                b43_phy_write(dev, B43_PHY_HT_TABLE_ADDR, offset); 
     600                value = b43_phy_read(dev, B43_PHY_HT_TABLE_DATAHI); 
     601                value <<= 16; 
     602                value |= b43_phy_read(dev, B43_PHY_HT_TABLE_DATALO); 
     603                break; 
     604        default: 
     605                B43_WARN_ON(1); 
     606                value = 0; 
     607        } 
     608 
     609        return value; 
     610} 
     611 
     612void b43_httab_read_bulk(struct b43_wldev *dev, u32 offset, 
     613                         unsigned int nr_elements, void *_data) 
     614{ 
     615        u32 type; 
     616        u8 *data = _data; 
     617        unsigned int i; 
     618 
     619        type = offset & B43_HTTAB_TYPEMASK; 
     620        offset &= ~B43_HTTAB_TYPEMASK; 
     621        B43_WARN_ON(offset > 0xFFFF); 
     622 
     623        b43_phy_write(dev, B43_PHY_HT_TABLE_ADDR, offset); 
     624 
     625        for (i = 0; i < nr_elements; i++) { 
     626                switch (type) { 
     627                case B43_HTTAB_8BIT: 
     628                        *data = b43_phy_read(dev, B43_PHY_HT_TABLE_DATALO) & 0xFF; 
     629                        data++; 
     630                        break; 
     631                case B43_HTTAB_16BIT: 
     632                        *((u16 *)data) = b43_phy_read(dev, B43_PHY_HT_TABLE_DATALO); 
     633                        data += 2; 
     634                        break; 
     635                case B43_HTTAB_32BIT: 
     636                        *((u32 *)data) = b43_phy_read(dev, B43_PHY_HT_TABLE_DATAHI); 
     637                        *((u32 *)data) <<= 16; 
     638                        *((u32 *)data) |= b43_phy_read(dev, B43_PHY_HT_TABLE_DATALO); 
     639                        data += 4; 
     640                        break; 
     641                default: 
     642                        B43_WARN_ON(1); 
     643                } 
     644        } 
     645} 
     646 
     647void b43_httab_write(struct b43_wldev *dev, u32 offset, u32 value) 
     648{ 
     649        u32 type; 
     650 
     651        type = offset & B43_HTTAB_TYPEMASK; 
     652        offset &= 0xFFFF; 
     653 
     654        switch (type) { 
     655        case B43_HTTAB_8BIT: 
     656                B43_WARN_ON(value & ~0xFF); 
     657                b43_phy_write(dev, B43_PHY_HT_TABLE_ADDR, offset); 
     658                b43_phy_write(dev, B43_PHY_HT_TABLE_DATALO, value); 
     659                break; 
     660        case B43_HTTAB_16BIT: 
     661                B43_WARN_ON(value & ~0xFFFF); 
     662                b43_phy_write(dev, B43_PHY_HT_TABLE_ADDR, offset); 
     663                b43_phy_write(dev, B43_PHY_HT_TABLE_DATALO, value); 
     664                break; 
     665        case B43_HTTAB_32BIT: 
     666                b43_phy_write(dev, B43_PHY_HT_TABLE_ADDR, offset); 
     667                b43_phy_write(dev, B43_PHY_HT_TABLE_DATAHI, value >> 16); 
     668                b43_phy_write(dev, B43_PHY_HT_TABLE_DATALO, value & 0xFFFF); 
     669                break; 
     670        default: 
     671                B43_WARN_ON(1); 
     672        } 
     673 
     674        return; 
     675} 
     676 
     677void b43_httab_write_bulk(struct b43_wldev *dev, u32 offset, 
     678                          unsigned int nr_elements, const void *_data) 
     679{ 
     680        u32 type, value; 
     681        const u8 *data = _data; 
     682        unsigned int i; 
     683 
     684        type = offset & B43_HTTAB_TYPEMASK; 
     685        offset &= ~B43_HTTAB_TYPEMASK; 
     686        B43_WARN_ON(offset > 0xFFFF); 
     687 
     688        b43_phy_write(dev, B43_PHY_HT_TABLE_ADDR, offset); 
     689 
     690        for (i = 0; i < nr_elements; i++) { 
     691                switch (type) { 
     692                case B43_HTTAB_8BIT: 
     693                        value = *data; 
     694                        data++; 
     695                        B43_WARN_ON(value & ~0xFF); 
     696                        b43_phy_write(dev, B43_PHY_HT_TABLE_DATALO, value); 
     697                        break; 
     698                case B43_HTTAB_16BIT: 
     699                        value = *((u16 *)data); 
     700                        data += 2; 
     701                        B43_WARN_ON(value & ~0xFFFF); 
     702                        b43_phy_write(dev, B43_PHY_HT_TABLE_DATALO, value); 
     703                        break; 
     704                case B43_HTTAB_32BIT: 
     705                        value = *((u32 *)data); 
     706                        data += 4; 
     707                        b43_phy_write(dev, B43_PHY_HT_TABLE_DATAHI, value >> 16); 
     708                        b43_phy_write(dev, B43_PHY_HT_TABLE_DATALO, 
     709                                        value & 0xFFFF); 
     710                        break; 
     711                default: 
     712                        B43_WARN_ON(1); 
     713                } 
     714        } 
     715} 
     716 
     717/************************************************** 
     718 * Tables ops. 
     719 **************************************************/ 
     720 
     721#define httab_upload(dev, offset, data) do { \ 
     722                b43_httab_write_bulk(dev, offset, ARRAY_SIZE(data), data); \ 
     723        } while (0) 
     724void b43_phy_ht_tables_init(struct b43_wldev *dev) 
     725{ 
     726        httab_upload(dev, B43_HTTAB16(0x12, 0), b43_httab_0x12); 
     727        httab_upload(dev, B43_HTTAB16(0x27, 0), b43_httab_0x27); 
     728        httab_upload(dev, B43_HTTAB16(0x26, 0), b43_httab_0x26); 
     729        httab_upload(dev, B43_HTTAB32(0x25, 0), b43_httab_0x25); 
     730        httab_upload(dev, B43_HTTAB32(0x2f, 0), b43_httab_0x2f); 
     731        httab_upload(dev, B43_HTTAB16(0x1a, 0), b43_httab_0x1a); 
     732        httab_upload(dev, B43_HTTAB16(0x1b, 0), b43_httab_0x1b); 
     733        httab_upload(dev, B43_HTTAB16(0x1c, 0), b43_httab_0x1c); 
     734        httab_upload(dev, B43_HTTAB32(0x1a, 0x0c0), b43_httab_0x1a_0xc0); 
     735        httab_upload(dev, B43_HTTAB32(0x1a, 0x140), b43_httab_0x1a_0x140); 
     736        httab_upload(dev, B43_HTTAB32(0x1b, 0x140), b43_httab_0x1b_0x140); 
     737        httab_upload(dev, B43_HTTAB32(0x1c, 0x140), b43_httab_0x1c_0x140); 
     738        httab_upload(dev, B43_HTTAB16(0x1a, 0x1c0), b43_httab_0x1a_0x1c0); 
     739        httab_upload(dev, B43_HTTAB16(0x1b, 0x1c0), b43_httab_0x1b_0x1c0); 
     740        httab_upload(dev, B43_HTTAB16(0x1c, 0x1c0), b43_httab_0x1c_0x1c0); 
     741        httab_upload(dev, B43_HTTAB16(0x1a, 0x240), b43_httab_0x1a_0x240); 
     742        httab_upload(dev, B43_HTTAB16(0x1b, 0x240), b43_httab_0x1b_0x240); 
     743        httab_upload(dev, B43_HTTAB16(0x1c, 0x240), b43_httab_0x1c_0x240); 
     744        httab_upload(dev, B43_HTTAB32(0x1f, 0), b43_httab_0x1f); 
     745        httab_upload(dev, B43_HTTAB32(0x21, 0), b43_httab_0x21); 
     746        httab_upload(dev, B43_HTTAB32(0x23, 0), b43_httab_0x23); 
     747        httab_upload(dev, B43_HTTAB32(0x20, 0), b43_httab_0x20); 
     748        httab_upload(dev, B43_HTTAB32(0x22, 0), b43_httab_0x22); 
     749        httab_upload(dev, B43_HTTAB32(0x24, 0), b43_httab_0x24); 
     750} 
  • new file drivers/net/wireless/b43/tables_phy_ht.h

    - +  
     1#ifndef B43_TABLES_PHY_HT_H_ 
     2#define B43_TABLES_PHY_HT_H_ 
     3 
     4/* The HT-PHY tables. */ 
     5#define B43_HTTAB_TYPEMASK              0xF0000000 
     6#define B43_HTTAB_8BIT                  0x10000000 
     7#define B43_HTTAB_16BIT                 0x20000000 
     8#define B43_HTTAB_32BIT                 0x30000000 
     9#define B43_HTTAB8(table, offset)       (((table) << 10) | (offset) | B43_HTTAB_8BIT) 
     10#define B43_HTTAB16(table, offset)      (((table) << 10) | (offset) | B43_HTTAB_16BIT) 
     11#define B43_HTTAB32(table, offset)      (((table) << 10) | (offset) | B43_HTTAB_32BIT) 
     12 
     13u32 b43_httab_read(struct b43_wldev *dev, u32 offset); 
     14void b43_httab_read_bulk(struct b43_wldev *dev, u32 offset, 
     15                         unsigned int nr_elements, void *_data); 
     16void b43_httab_write(struct b43_wldev *dev, u32 offset, u32 value); 
     17void b43_httab_write_bulk(struct b43_wldev *dev, u32 offset, 
     18                          unsigned int nr_elements, const void *_data); 
     19 
     20void b43_phy_ht_tables_init(struct b43_wldev *dev); 
     21 
     22#endif /* B43_TABLES_PHY_HT_H_ */ 
  • new file drivers/net/wireless/b43/tables_phy_lcn.c

    - +  
     1/* 
     2 
     3  Broadcom B43 wireless driver 
     4  IEEE 802.11n LCN-PHY data tables 
     5 
     6  This program is free software; you can redistribute it and/or modify 
     7  it under the terms of the GNU General Public License as published by 
     8  the Free Software Foundation; either version 2 of the License, or 
     9  (at your option) any later version. 
     10 
     11  This program is distributed in the hope that it will be useful, 
     12  but WITHOUT ANY WARRANTY; without even the implied warranty of 
     13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     14  GNU General Public License for more details. 
     15 
     16  You should have received a copy of the GNU General Public License 
     17  along with this program; see the file COPYING.  If not, write to 
     18  the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor, 
     19  Boston, MA 02110-1301, USA. 
     20 
     21*/ 
     22 
     23#include "b43.h" 
     24#include "tables_phy_lcn.h" 
     25#include "phy_common.h" 
     26#include "phy_lcn.h" 
     27 
     28/************************************************** 
     29 * Tables ops. 
     30 **************************************************/ 
     31 
     32void b43_phy_lcn_tables_init(struct b43_wldev *dev) 
     33{ 
     34} 
  • new file drivers/net/wireless/b43/tables_phy_lcn.h

    - +  
     1#ifndef B43_TABLES_PHY_LCN_H_ 
     2#define B43_TABLES_PHY_LCN_H_ 
     3 
     4void b43_phy_lcn_tables_init(struct b43_wldev *dev); 
     5 
     6#endif /* B43_TABLES_PHY_LCN_H_ */ 
Note: See TracBrowser for help on using the repository browser.