kernel-bcm43xx-2.6.20_combined.patch

   1
   2 Index: linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx_dma.c
   3 ===================================================================
   4 --- linux-2.6.orig/drivers/net/wireless/bcm43xx/bcm43xx_dma.c
   5 +++ linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx_dma.c
   6 @@ -145,16 +145,14 @@ dma_addr_t map_descbuffer(struct bcm43xx
   7                           int tx)
   8  {
   9         dma_addr_t dmaaddr;
  10 +       int direction = PCI_DMA_FROMDEVICE;
  11
  12 -       if (tx) {
  13 -               dmaaddr = dma_map_single(&ring->bcm->pci_dev->dev,
  14 -                                        buf, len,
  15 -                                        DMA_TO_DEVICE);
  16 -       } else {
  17 -               dmaaddr = dma_map_single(&ring->bcm->pci_dev->dev,
  18 +       if (tx)
  19 +               direction = PCI_DMA_TODEVICE;
  20 +
  21 +       dmaaddr = pci_map_single(ring->bcm->pci_dev,
  22                                          buf, len,
  23 -                                        DMA_FROM_DEVICE);
  24 -       }
  25 +                                        direction);
  26
  27         return dmaaddr;
  28  }
  29 @@ -166,13 +164,13 @@ void unmap_descbuffer(struct bcm43xx_dma
  30                       int tx)
  31  {
  32         if (tx) {
  33 -               dma_unmap_single(&ring->bcm->pci_dev->dev,
  34 +               pci_unmap_single(ring->bcm->pci_dev,
  35                                  addr, len,
  36 -                                DMA_TO_DEVICE);
  37 +                                PCI_DMA_TODEVICE);
  38         } else {
  39 -               dma_unmap_single(&ring->bcm->pci_dev->dev,
  40 +               pci_unmap_single(ring->bcm->pci_dev,
  41                                  addr, len,
  42 -                                DMA_FROM_DEVICE);
  43 +                                PCI_DMA_FROMDEVICE);
  44         }
  45  }
  46
  47 @@ -183,8 +181,8 @@ void sync_descbuffer_for_cpu(struct bcm4
  48  {
  49         assert(!ring->tx);
  50
  51 -       dma_sync_single_for_cpu(&ring->bcm->pci_dev->dev,
  52 -                               addr, len, DMA_FROM_DEVICE);
  53 +       pci_dma_sync_single_for_cpu(ring->bcm->pci_dev,
  54 +                                   addr, len, PCI_DMA_FROMDEVICE);
  55  }
  56
  57  static inline
  58 @@ -194,8 +192,8 @@ void sync_descbuffer_for_device(struct b
  59  {
  60         assert(!ring->tx);
  61
  62 -       dma_sync_single_for_device(&ring->bcm->pci_dev->dev,
  63 -                                  addr, len, DMA_FROM_DEVICE);
  64 +       pci_dma_sync_single_for_cpu(ring->bcm->pci_dev,
  65 +                                   addr, len, PCI_DMA_TODEVICE);
  66  }
  67
  68  /* Unmap and free a descriptor buffer. */
  69 @@ -214,17 +212,53 @@ void free_descriptor_buffer(struct bcm43
  70
  71  static int alloc_ringmemory(struct bcm43xx_dmaring *ring)
  72  {
  73 -       struct device *dev = &(ring->bcm->pci_dev->dev);
  74 -
  75 -       ring->descbase = dma_alloc_coherent(dev, BCM43xx_DMA_RINGMEMSIZE,
  76 -                                           &(ring->dmabase), GFP_KERNEL);
  77 +       ring->descbase = pci_alloc_consistent(ring->bcm->pci_dev, BCM43xx_DMA_RINGMEMSIZE,
  78 +                                           &(ring->dmabase));
  79         if (!ring->descbase) {
  80 -               printk(KERN_ERR PFX "DMA ringmemory allocation failed\n");
  81 -               return -ENOMEM;
  82 +               /* Allocation may have failed due to pci_alloc_consistent
  83 +                  insisting on use of GFP_DMA, which is more restrictive
  84 +                  than necessary...  */
  85 +               struct dma_desc *rx_ring;
  86 +               dma_addr_t rx_ring_dma;
  87 +
  88 +               rx_ring = kzalloc(BCM43xx_DMA_RINGMEMSIZE, GFP_KERNEL);
  89 +               if (!rx_ring)
  90 +                       goto out_err;
  91 +
  92 +               rx_ring_dma = pci_map_single(ring->bcm->pci_dev, rx_ring,
  93 +                                            BCM43xx_DMA_RINGMEMSIZE,
  94 +                                            PCI_DMA_BIDIRECTIONAL);
  95 +
  96 +               if (pci_dma_mapping_error(rx_ring_dma) ||
  97 +                   rx_ring_dma + BCM43xx_DMA_RINGMEMSIZE > ring->bcm->dma_mask) {
  98 +                       /* Sigh... */
  99 +                       if (!pci_dma_mapping_error(rx_ring_dma))
 100 +                               pci_unmap_single(ring->bcm->pci_dev,
 101 +                                                rx_ring_dma, BCM43xx_DMA_RINGMEMSIZE,
 102 +                                                PCI_DMA_BIDIRECTIONAL);
 103 +                       rx_ring_dma = pci_map_single(ring->bcm->pci_dev,
 104 +                                                rx_ring, BCM43xx_DMA_RINGMEMSIZE,
 105 +                                                PCI_DMA_BIDIRECTIONAL);
 106 +                       if (pci_dma_mapping_error(rx_ring_dma) ||
 107 +                           rx_ring_dma + BCM43xx_DMA_RINGMEMSIZE > ring->bcm->dma_mask) {
 108 +                               assert(0);
 109 +                               if (!pci_dma_mapping_error(rx_ring_dma))
 110 +                                       pci_unmap_single(ring->bcm->pci_dev,
 111 +                                                        rx_ring_dma, BCM43xx_DMA_RINGMEMSIZE,
 112 +                                                        PCI_DMA_BIDIRECTIONAL);
 113 +                               goto out_err;
 114 +                       }
 115 +                }
 116 +
 117 +                ring->descbase = rx_ring;
 118 +                ring->dmabase = rx_ring_dma;
 119         }
 120         memset(ring->descbase, 0, BCM43xx_DMA_RINGMEMSIZE);
 121
 122         return 0;
 123 +out_err:
 124 +       printk(KERN_ERR PFX "DMA ringmemory allocation failed\n");
 125 +       return -ENOMEM;
 126  }
 127
 128  static void free_ringmemory(struct bcm43xx_dmaring *ring)
 129 @@ -407,6 +441,29 @@ static int setup_rx_descbuffer(struct bc
 130         if (unlikely(!skb))
 131                 return -ENOMEM;
 132         dmaaddr = map_descbuffer(ring, skb->data, ring->rx_buffersize, 0);
 133 +       /* This hardware bug work-around adapted from the b44 driver.
 134 +          The chip may be unable to do PCI DMA to/from anything above 1GB */
 135 +       if (pci_dma_mapping_error(dmaaddr) ||
 136 +           dmaaddr + ring->rx_buffersize > ring->bcm->dma_mask) {
 137 +               /* This one has 30-bit addressing... */
 138 +               if (!pci_dma_mapping_error(dmaaddr))
 139 +                       pci_unmap_single(ring->bcm->pci_dev,
 140 +                                        dmaaddr, ring->rx_buffersize,
 141 +                                        PCI_DMA_FROMDEVICE);
 142 +               dev_kfree_skb_any(skb);
 143 +               skb = __dev_alloc_skb(ring->rx_buffersize,GFP_DMA);
 144 +               if (skb == NULL)
 145 +                       return -ENOMEM;
 146 +               dmaaddr = pci_map_single(ring->bcm->pci_dev,
 147 +                                        skb->data, ring->rx_buffersize,
 148 +                                        PCI_DMA_FROMDEVICE);
 149 +               if (pci_dma_mapping_error(dmaaddr) ||
 150 +                   dmaaddr + ring->rx_buffersize > ring->bcm->dma_mask) {
 151 +                       assert(0);
 152 +                       dev_kfree_skb_any(skb);
 153 +                       return -ENOMEM;
 154 +               }
 155 +       }
 156         meta->skb = skb;
 157         meta->dmaaddr = dmaaddr;
 158         skb->dev = ring->bcm->net_dev;
 159 @@ -636,8 +693,10 @@ struct bcm43xx_dmaring * bcm43xx_setup_d
 160         err = dmacontroller_setup(ring);
 161         if (err)
 162                 goto err_free_ringmemory;
 163 +       return ring;
 164
 165  out:
 166 +       printk(KERN_ERR PFX "Error in bcm43xx_setup_dmaring\n");
 167         return ring;
 168
 169  err_free_ringmemory:
 170 @@ -705,30 +764,16 @@ int bcm43xx_dma_init(struct bcm43xx_priv
 171         struct bcm43xx_dmaring *ring;
 172         int err = -ENOMEM;
 173         int dma64 = 0;
 174 -       u64 mask = bcm43xx_get_supported_dma_mask(bcm);
 175 -       int nobits;
 176
 177 -       if (mask == DMA_64BIT_MASK) {
 178 +       bcm->dma_mask = bcm43xx_get_supported_dma_mask(bcm);
 179 +       if (bcm->dma_mask == DMA_64BIT_MASK)
 180                 dma64 = 1;
 181 -               nobits = 64;
 182 -       } else if (mask == DMA_32BIT_MASK)
 183 -               nobits = 32;
 184 -       else
 185 -               nobits = 30;
 186 -       err = pci_set_dma_mask(bcm->pci_dev, mask);
 187 -       err |= pci_set_consistent_dma_mask(bcm->pci_dev, mask);
 188 -       if (err) {
 189 -#ifdef CONFIG_BCM43XX_PIO
 190 -               printk(KERN_WARNING PFX "DMA not supported on this device."
 191 -                                       " Falling back to PIO.\n");
 192 -               bcm->__using_pio = 1;
 193 -               return -ENOSYS;
 194 -#else
 195 -               printk(KERN_ERR PFX "FATAL: DMA not supported and PIO not configured. "
 196 -                                   "Please recompile the driver with PIO support.\n");
 197 -               return -ENODEV;
 198 -#endif /* CONFIG_BCM43XX_PIO */
 199 -       }
 200 +       err = pci_set_dma_mask(bcm->pci_dev, bcm->dma_mask);
 201 +       if (err)
 202 +               goto no_dma;
 203 +       err = pci_set_consistent_dma_mask(bcm->pci_dev, bcm->dma_mask);
 204 +       if (err)
 205 +               goto no_dma;
 206
 207         /* setup TX DMA channels. */
 208         ring = bcm43xx_setup_dmaring(bcm, 0, 1, dma64);
 209 @@ -774,9 +819,12 @@ int bcm43xx_dma_init(struct bcm43xx_priv
 210                 dma->rx_ring3 = ring;
 211         }
 212
 213 -       dprintk(KERN_INFO PFX "%d-bit DMA initialized\n", nobits);
 214 +       dprintk(KERN_INFO PFX "%d-bit DMA initialized\n",
 215 +               (bcm->dma_mask == DMA_64BIT_MASK) ? 64 :
 216 +               (bcm->dma_mask == DMA_32BIT_MASK) ? 32 : 30);
 217         err = 0;
 218  out:
 219 +       if(err)BUG();
 220         return err;
 221
 222  err_destroy_rx0:
 223 @@ -800,7 +848,18 @@ err_destroy_tx1:
 224  err_destroy_tx0:
 225         bcm43xx_destroy_dmaring(dma->tx_ring0);
 226         dma->tx_ring0 = NULL;
 227 -       goto out;
 228 +no_dma:
 229 +#ifdef CONFIG_BCM43XX_PIO
 230 +       printk(KERN_WARNING PFX "DMA not supported on this device."
 231 +                               " Falling back to PIO.\n");
 232 +       bcm->__using_pio = 1;
 233 +       BUG();
 234 +       return -ENOSYS;
 235 +#else
 236 +       printk(KERN_ERR PFX "FATAL: DMA not supported and PIO not configured. "
 237 +                           "Please recompile the driver with PIO support.\n");
 238 +       return -ENODEV;
 239 +#endif /* CONFIG_BCM43XX_PIO */
 240  }
 241
 242  /* Generate a cookie for the TX header. */
 243 @@ -905,6 +964,7 @@ static void dma_tx_fragment(struct bcm43
 244         struct bcm43xx_dmadesc_generic *desc;
 245         struct bcm43xx_dmadesc_meta *meta;
 246         dma_addr_t dmaaddr;
 247 +       struct sk_buff *bounce_skb;
 248
 249         assert(skb_shinfo(skb)->nr_frags == 0);
 250
 251 @@ -924,9 +984,28 @@ static void dma_tx_fragment(struct bcm43
 252                                skb->len - sizeof(struct bcm43xx_txhdr),
 253                                (cur_frag == 0),
 254                                generate_cookie(ring, slot));
 255 +       dmaaddr = map_descbuffer(ring, skb->data, skb->len, 1);
 256 +       if (dma_mapping_error(dmaaddr) || dmaaddr + skb->len > ring->bcm->dma_mask) {
 257 +               /* chip cannot handle DMA to/from > 1GB, use bounce buffer (copied from b44 driver) */
 258 +               if (!dma_mapping_error(dmaaddr))
 259 +                       unmap_descbuffer(ring, dmaaddr, skb->len, 1);
 260 +               bounce_skb = __dev_alloc_skb(skb->len, GFP_ATOMIC|GFP_DMA);
 261 +               if (!bounce_skb)
 262 +                       return;
 263 +               dmaaddr = map_descbuffer(ring, bounce_skb->data, bounce_skb->len, 1);
 264 +               if (dma_mapping_error(dmaaddr) || dmaaddr + skb->len > ring->bcm->dma_mask) {
 265 +                       if (!dma_mapping_error(dmaaddr))
 266 +                               unmap_descbuffer(ring, dmaaddr, skb->len, 1);
 267 +                       dev_kfree_skb_any(bounce_skb);
 268 +                       assert(0);
 269 +                       return;
 270 +               }
 271 +               memcpy(skb_put(bounce_skb, skb->len), skb->data, skb->len);
 272 +               dev_kfree_skb_any(skb);
 273 +               skb = bounce_skb;
 274 +       }
 275
 276         meta->skb = skb;
 277 -       dmaaddr = map_descbuffer(ring, skb->data, skb->len, 1);
 278         meta->dmaaddr = dmaaddr;
 279
 280         fill_descriptor(ring, desc, dmaaddr,
 281 Index: linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx.h
 282 ===================================================================
 283 --- linux-2.6.orig/drivers/net/wireless/bcm43xx/bcm43xx.h
 284 +++ linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx.h
 285 @@ -21,7 +21,7 @@
 286  #define PFX                            KBUILD_MODNAME ": "
 287
 288  #define BCM43xx_SWITCH_CORE_MAX_RETRIES        50
 289 -#define BCM43xx_IRQWAIT_MAX_RETRIES    50
 290 +#define BCM43xx_IRQWAIT_MAX_RETRIES    100
 291
 292  #define BCM43xx_IO_SIZE                        8192
 293
 294 @@ -352,6 +352,10 @@
 295  #define BCM43xx_UCODEFLAG_UNKPACTRL    0x0040
 296  #define BCM43xx_UCODEFLAG_JAPAN                0x0080
 297
 298 +/* Hardware Radio Enable masks */
 299 +#define BCM43xx_MMIO_RADIO_HWENABLED_HI_MASK (1 << 16)
 300 +#define BCM43xx_MMIO_RADIO_HWENABLED_LO_MASK (1 << 4)
 301 +
 302  /* Generic-Interrupt reasons. */
 303  #define BCM43xx_IRQ_READY              (1 << 0)
 304  #define BCM43xx_IRQ_BEACON             (1 << 1)
 305 @@ -758,7 +762,8 @@ struct bcm43xx_private {
 306             bad_frames_preempt:1,       /* Use "Bad Frames Preemption" (default off) */
 307             reg124_set_0x4:1,           /* Some variable to keep track of IRQ stuff. */
 308             short_preamble:1,           /* TRUE, if short preamble is enabled. */
 309 -           firmware_norelease:1;       /* Do not release the firmware. Used on suspend. */
 310 +           firmware_norelease:1,       /* Do not release the firmware. Used on suspend. */
 311 +           radio_hw_enable:1;          /* TRUE if radio is hardware enabled */
 312
 313         struct bcm43xx_stats stats;
 314
 315 @@ -766,6 +771,7 @@ struct bcm43xx_private {
 316          * This is currently always BCM43xx_BUSTYPE_PCI
 317          */
 318         u8 bustype;
 319 +       u64 dma_mask;
 320
 321         u16 board_vendor;
 322         u16 board_type;
 323 Index: linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx_main.c
 324 ===================================================================
 325 --- linux-2.6.orig/drivers/net/wireless/bcm43xx/bcm43xx_main.c
 326 +++ linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx_main.c
 327 @@ -2441,6 +2441,9 @@ static int bcm43xx_chip_init(struct bcm4
 328         if (err)
 329                 goto err_gpio_cleanup;
 330         bcm43xx_radio_turn_on(bcm);
 331 +       bcm->radio_hw_enable = bcm43xx_is_hw_radio_enabled(bcm);
 332 +       dprintk(KERN_INFO PFX "Radio %s by hardware\n",
 333 +               (bcm->radio_hw_enable == 0) ? "disabled" : "enabled");
 334
 335         bcm43xx_write16(bcm, 0x03E6, 0x0000);
 336         err = bcm43xx_phy_init(bcm);
 337 @@ -3175,9 +3178,24 @@ static void bcm43xx_periodic_every30sec(
 338
 339  static void bcm43xx_periodic_every15sec(struct bcm43xx_private *bcm)
 340  {
 341 +       bcm43xx_phy_xmitpower(bcm); //FIXME: unless scanning?
 342 +       //TODO for APHY (temperature?)
 343 +}
 344 +
 345 +static void bcm43xx_periodic_every1sec(struct bcm43xx_private *bcm)
 346 +{
 347         struct bcm43xx_phyinfo *phy = bcm43xx_current_phy(bcm);
 348         struct bcm43xx_radioinfo *radio = bcm43xx_current_radio(bcm);
 349 +       int radio_hw_enable;
 350
 351 +       /* check if radio hardware enabled status changed */
 352 +       radio_hw_enable = bcm43xx_is_hw_radio_enabled(bcm);
 353 +       if (unlikely(bcm->radio_hw_enable != radio_hw_enable)) {
 354 +               bcm->radio_hw_enable = radio_hw_enable;
 355 +               dprintk(KERN_INFO PFX "Radio hardware status changed to %s\n",
 356 +                      (radio_hw_enable == 0) ? "disabled" : "enabled");
 357 +               bcm43xx_leds_update(bcm, 0);
 358 +       }
 359         if (phy->type == BCM43xx_PHYTYPE_G) {
 360                 //TODO: update_aci_moving_average
 361                 if (radio->aci_enable && radio->aci_wlan_automatic) {
 362 @@ -3201,21 +3219,21 @@ static void bcm43xx_periodic_every15sec(
 363                         //TODO: implement rev1 workaround
 364                 }
 365         }
 366 -       bcm43xx_phy_xmitpower(bcm); //FIXME: unless scanning?
 367 -       //TODO for APHY (temperature?)
 368  }
 369
 370  static void do_periodic_work(struct bcm43xx_private *bcm)
 371  {
 372 -       if (bcm->periodic_state % 8 == 0)
 373 +       if (bcm->periodic_state % 120 == 0)
 374                 bcm43xx_periodic_every120sec(bcm);
 375 -       if (bcm->periodic_state % 4 == 0)
 376 +       if (bcm->periodic_state % 60 == 0)
 377                 bcm43xx_periodic_every60sec(bcm);
 378 -       if (bcm->periodic_state % 2 == 0)
 379 +       if (bcm->periodic_state % 30 == 0)
 380                 bcm43xx_periodic_every30sec(bcm);
 381 -       bcm43xx_periodic_every15sec(bcm);
 382 +       if (bcm->periodic_state % 15 == 0)
 383 +               bcm43xx_periodic_every15sec(bcm);
 384 +       bcm43xx_periodic_every1sec(bcm);
 385
 386 -       schedule_delayed_work(&bcm->periodic_work, HZ * 15);
 387 +       schedule_delayed_work(&bcm->periodic_work, HZ);
 388  }
 389
 390  static void bcm43xx_periodic_work_handler(struct work_struct *work)
 391 @@ -3228,7 +3246,7 @@ static void bcm43xx_periodic_work_handle
 392         unsigned long orig_trans_start = 0;
 393
 394         mutex_lock(&bcm->mutex);
 395 -       if (unlikely(bcm->periodic_state % 4 == 0)) {
 396 +       if (unlikely(bcm->periodic_state % 60 == 0)) {
 397                 /* Periodic work will take a long time, so we want it to
 398                  * be preemtible.
 399                  */
 400 @@ -3260,7 +3278,7 @@ static void bcm43xx_periodic_work_handle
 401
 402         do_periodic_work(bcm);
 403
 404 -       if (unlikely(bcm->periodic_state % 4 == 0)) {
 405 +       if (unlikely(bcm->periodic_state % 60 == 0)) {
 406                 spin_lock_irqsave(&bcm->irq_lock, flags);
 407                 tasklet_enable(&bcm->isr_tasklet);
 408                 bcm43xx_interrupt_enable(bcm, savedirqs);
 409 Index: linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx_radio.h
 410 ===================================================================
 411 --- linux-2.6.orig/drivers/net/wireless/bcm43xx/bcm43xx_radio.h
 412 +++ linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx_radio.h
 413 @@ -65,6 +65,22 @@ void bcm43xx_radio_init2060(struct bcm43
 414  void bcm43xx_radio_turn_on(struct bcm43xx_private *bcm);
 415  void bcm43xx_radio_turn_off(struct bcm43xx_private *bcm);
 416
 417 +static inline
 418 +int bcm43xx_is_hw_radio_enabled(struct bcm43xx_private *bcm)
 419 +{
 420 +       /* function to return state of hardware enable of radio
 421 +        * returns 0 if radio disabled, 1 if radio enabled
 422 +        */
 423 +       if (likely(bcm->current_core->rev >= 3))
 424 +               return ((bcm43xx_read32(bcm, BCM43xx_MMIO_RADIO_HWENABLED_HI)
 425 +                                       & BCM43xx_MMIO_RADIO_HWENABLED_HI_MASK)
 426 +                                       == 0) ? 1 : 0;
 427 +       else
 428 +               return ((bcm43xx_read16(bcm, BCM43xx_MMIO_RADIO_HWENABLED_LO)
 429 +                                       & BCM43xx_MMIO_RADIO_HWENABLED_LO_MASK)
 430 +                                       == 0) ? 0 : 1;
 431 +}
 432 +
 433  int bcm43xx_radio_selectchannel(struct bcm43xx_private *bcm, u8 channel,
 434                                 int synthetic_pu_workaround);
 435
 436 Index: linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx_leds.c
 437 ===================================================================
 438 --- linux-2.6.orig/drivers/net/wireless/bcm43xx/bcm43xx_leds.c
 439 +++ linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx_leds.c
 440 @@ -26,6 +26,7 @@
 441  */
 442
 443  #include "bcm43xx_leds.h"
 444 +#include "bcm43xx_radio.h"
 445  #include "bcm43xx.h"
 446
 447  #include <asm/bitops.h>
 448 @@ -108,6 +109,7 @@ static void bcm43xx_led_init_hardcoded(s
 449         switch (led_index) {
 450         case 0:
 451                 led->behaviour = BCM43xx_LED_ACTIVITY;
 452 +               led->activelow = 1;
 453                 if (bcm->board_vendor == PCI_VENDOR_ID_COMPAQ)
 454                         led->behaviour = BCM43xx_LED_RADIO_ALL;
 455                 break;
 456 @@ -199,20 +201,21 @@ void bcm43xx_leds_update(struct bcm43xx_
 457                         turn_on = activity;
 458                         break;
 459                 case BCM43xx_LED_RADIO_ALL:
 460 -                       turn_on = radio->enabled;
 461 +                       turn_on = radio->enabled && bcm43xx_is_hw_radio_enabled(bcm);
 462                         break;
 463                 case BCM43xx_LED_RADIO_A:
 464                 case BCM43xx_LED_BCM4303_2:
 465 -                       turn_on = (radio->enabled && phy->type == BCM43xx_PHYTYPE_A);
 466 +                       turn_on = (radio->enabled && bcm43xx_is_hw_radio_enabled(bcm) &&
 467 +                                  phy->type == BCM43xx_PHYTYPE_A);
 468                         break;
 469                 case BCM43xx_LED_RADIO_B:
 470                 case BCM43xx_LED_BCM4303_1:
 471 -                       turn_on = (radio->enabled &&
 472 +                       turn_on = (radio->enabled && bcm43xx_is_hw_radio_enabled(bcm) &&
 473                                    (phy->type == BCM43xx_PHYTYPE_B ||
 474                                     phy->type == BCM43xx_PHYTYPE_G));
 475                         break;
 476                 case BCM43xx_LED_MODE_BG:
 477 -                       if (phy->type == BCM43xx_PHYTYPE_G &&
 478 +                       if (phy->type == BCM43xx_PHYTYPE_G && bcm43xx_is_hw_radio_enabled(bcm) &&
 479                             1/*FIXME: using G rates.*/)
 480                                 turn_on = 1;
 481                         break;
 482 Index: linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx_radio.c
 483 ===================================================================
 484 --- linux-2.6.orig/drivers/net/wireless/bcm43xx/bcm43xx_radio.c
 485 +++ linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx_radio.c
 486 @@ -1981,6 +1981,7 @@ void bcm43xx_radio_turn_on(struct bcm43x
 487         }
 488         radio->enabled = 1;
 489         dprintk(KERN_INFO PFX "Radio turned on\n");
 490 +       bcm43xx_leds_update(bcm, 0);
 491  }
 492
 493  void bcm43xx_radio_turn_off(struct bcm43xx_private *bcm)
 494 @@ -2001,6 +2002,7 @@ void bcm43xx_radio_turn_off(struct bcm43
 495                 bcm43xx_phy_write(bcm, 0x0015, 0xAA00);
 496         radio->enabled = 0;
 497         dprintk(KERN_INFO PFX "Radio turned off\n");
 498 +       bcm43xx_leds_update(bcm, 0);
 499  }
 500
 501  void bcm43xx_radio_clear_tssi(struct bcm43xx_private *bcm)
 502 Index: linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx_wx.c
 503 ===================================================================
 504 --- linux-2.6.orig/drivers/net/wireless/bcm43xx/bcm43xx_wx.c
 505 +++ linux-2.6/drivers/net/wireless/bcm43xx/bcm43xx_wx.c
 506 @@ -261,22 +261,22 @@ static int bcm43xx_wx_get_rangeparams(st
 507         if (phy->type == BCM43xx_PHYTYPE_A ||
 508             phy->type == BCM43xx_PHYTYPE_G) {
 509                 range->num_bitrates = 8;
 510 -               range->bitrate[i++] = IEEE80211_OFDM_RATE_6MB;
 511 -               range->bitrate[i++] = IEEE80211_OFDM_RATE_9MB;
 512 -               range->bitrate[i++] = IEEE80211_OFDM_RATE_12MB;
 513 -               range->bitrate[i++] = IEEE80211_OFDM_RATE_18MB;
 514 -               range->bitrate[i++] = IEEE80211_OFDM_RATE_24MB;
 515 -               range->bitrate[i++] = IEEE80211_OFDM_RATE_36MB;
 516 -               range->bitrate[i++] = IEEE80211_OFDM_RATE_48MB;
 517 -               range->bitrate[i++] = IEEE80211_OFDM_RATE_54MB;
 518 +               range->bitrate[i++] = IEEE80211_OFDM_RATE_6MB * 500000;
 519 +               range->bitrate[i++] = IEEE80211_OFDM_RATE_9MB * 500000;
 520 +               range->bitrate[i++] = IEEE80211_OFDM_RATE_12MB * 500000;
 521 +               range->bitrate[i++] = IEEE80211_OFDM_RATE_18MB * 500000;
 522 +               range->bitrate[i++] = IEEE80211_OFDM_RATE_24MB * 500000;
 523 +               range->bitrate[i++] = IEEE80211_OFDM_RATE_36MB * 500000;
 524 +               range->bitrate[i++] = IEEE80211_OFDM_RATE_48MB * 500000;
 525 +               range->bitrate[i++] = IEEE80211_OFDM_RATE_54MB * 500000;
 526         }
 527         if (phy->type == BCM43xx_PHYTYPE_B ||
 528             phy->type == BCM43xx_PHYTYPE_G) {
 529                 range->num_bitrates += 4;
 530 -               range->bitrate[i++] = IEEE80211_CCK_RATE_1MB;
 531 -               range->bitrate[i++] = IEEE80211_CCK_RATE_2MB;
 532 -               range->bitrate[i++] = IEEE80211_CCK_RATE_5MB;
 533 -               range->bitrate[i++] = IEEE80211_CCK_RATE_11MB;
 534 +               range->bitrate[i++] = IEEE80211_CCK_RATE_1MB * 500000;
 535 +               range->bitrate[i++] = IEEE80211_CCK_RATE_2MB * 500000;
 536 +               range->bitrate[i++] = IEEE80211_CCK_RATE_5MB * 500000;
 537 +               range->bitrate[i++] = IEEE80211_CCK_RATE_11MB * 500000;
 538         }
 539
 540         geo = ieee80211_get_geo(bcm->ieee);
 541 @@ -286,7 +286,7 @@ static int bcm43xx_wx_get_rangeparams(st
 542                 if (j == IW_MAX_FREQUENCIES)
 543                         break;
 544                 range->freq[j].i = j + 1;
 545 -               range->freq[j].m = geo->a[i].freq;//FIXME?
 546 +               range->freq[j].m = geo->a[i].freq * 100000;
 547                 range->freq[j].e = 1;
 548                 j++;
 549         }
 550 @@ -294,7 +294,7 @@ static int bcm43xx_wx_get_rangeparams(st
 551                 if (j == IW_MAX_FREQUENCIES)
 552                         break;
 553                 range->freq[j].i = j + 1;
 554 -               range->freq[j].m = geo->bg[i].freq;//FIXME?
 555 +               range->freq[j].m = geo->bg[i].freq * 100000;
 556                 range->freq[j].e = 1;
 557                 j++;
 558         }