target/linux/generic/patches-2.6.35/975-ssb_update.patch

   1 --- a/drivers/net/b44.c
   2 +++ b/drivers/net/b44.c
   3 @@ -135,7 +135,6 @@ static void b44_init_rings(struct b44 *)
   4
   5  static void b44_init_hw(struct b44 *, int);
   6
   7 -static int dma_desc_align_mask;
   8  static int dma_desc_sync_size;
   9  static int instance;
  10
  11 @@ -150,9 +149,8 @@ static inline void b44_sync_dma_desc_for
  12                                                 unsigned long offset,
  13                                                 enum dma_data_direction dir)
  14  {
  15 -       ssb_dma_sync_single_range_for_device(sdev, dma_base,
  16 -                                            offset & dma_desc_align_mask,
  17 -                                            dma_desc_sync_size, dir);
  18 +       dma_sync_single_for_device(sdev->dma_dev, dma_base + offset,
  19 +                                  dma_desc_sync_size, dir);
  20  }
  21
  22  static inline void b44_sync_dma_desc_for_cpu(struct ssb_device *sdev,
  23 @@ -160,9 +158,8 @@ static inline void b44_sync_dma_desc_for
  24                                              unsigned long offset,
  25                                              enum dma_data_direction dir)
  26  {
  27 -       ssb_dma_sync_single_range_for_cpu(sdev, dma_base,
  28 -                                         offset & dma_desc_align_mask,
  29 -                                         dma_desc_sync_size, dir);
  30 +       dma_sync_single_for_cpu(sdev->dma_dev, dma_base + offset,
  31 +                               dma_desc_sync_size, dir);
  32  }
  33
  34  static inline unsigned long br32(const struct b44 *bp, unsigned long reg)
  35 @@ -608,10 +605,10 @@ static void b44_tx(struct b44 *bp)
  36
  37                 BUG_ON(skb == NULL);
  38
  39 -               ssb_dma_unmap_single(bp->sdev,
  40 -                                    rp->mapping,
  41 -                                    skb->len,
  42 -                                    DMA_TO_DEVICE);
  43 +               dma_unmap_single(bp->sdev->dma_dev,
  44 +                                rp->mapping,
  45 +                                skb->len,
  46 +                                DMA_TO_DEVICE);
  47                 rp->skb = NULL;
  48                 dev_kfree_skb_irq(skb);
  49         }
  50 @@ -648,29 +645,29 @@ static int b44_alloc_rx_skb(struct b44 *
  51         if (skb == NULL)
  52                 return -ENOMEM;
  53
  54 -       mapping = ssb_dma_map_single(bp->sdev, skb->data,
  55 -                                    RX_PKT_BUF_SZ,
  56 -                                    DMA_FROM_DEVICE);
  57 +       mapping = dma_map_single(bp->sdev->dma_dev, skb->data,
  58 +                                RX_PKT_BUF_SZ,
  59 +                                DMA_FROM_DEVICE);
  60
  61         /* Hardware bug work-around, the chip is unable to do PCI DMA
  62            to/from anything above 1GB :-( */
  63 -       if (ssb_dma_mapping_error(bp->sdev, mapping) ||
  64 +       if (dma_mapping_error(bp->sdev->dma_dev, mapping) ||
  65                 mapping + RX_PKT_BUF_SZ > DMA_BIT_MASK(30)) {
  66                 /* Sigh... */
  67 -               if (!ssb_dma_mapping_error(bp->sdev, mapping))
  68 -                       ssb_dma_unmap_single(bp->sdev, mapping,
  69 +               if (!dma_mapping_error(bp->sdev->dma_dev, mapping))
  70 +                       dma_unmap_single(bp->sdev->dma_dev, mapping,
  71                                              RX_PKT_BUF_SZ, DMA_FROM_DEVICE);
  72                 dev_kfree_skb_any(skb);
  73                 skb = __netdev_alloc_skb(bp->dev, RX_PKT_BUF_SZ, GFP_ATOMIC|GFP_DMA);
  74                 if (skb == NULL)
  75                         return -ENOMEM;
  76 -               mapping = ssb_dma_map_single(bp->sdev, skb->data,
  77 -                                            RX_PKT_BUF_SZ,
  78 -                                            DMA_FROM_DEVICE);
  79 -               if (ssb_dma_mapping_error(bp->sdev, mapping) ||
  80 -                       mapping + RX_PKT_BUF_SZ > DMA_BIT_MASK(30)) {
  81 -                       if (!ssb_dma_mapping_error(bp->sdev, mapping))
  82 -                               ssb_dma_unmap_single(bp->sdev, mapping, RX_PKT_BUF_SZ,DMA_FROM_DEVICE);
  83 +               mapping = dma_map_single(bp->sdev->dma_dev, skb->data,
  84 +                                        RX_PKT_BUF_SZ,
  85 +                                        DMA_FROM_DEVICE);
  86 +               if (dma_mapping_error(bp->sdev->dma_dev, mapping) ||
  87 +                   mapping + RX_PKT_BUF_SZ > DMA_BIT_MASK(30)) {
  88 +                       if (!dma_mapping_error(bp->sdev->dma_dev, mapping))
  89 +                               dma_unmap_single(bp->sdev->dma_dev, mapping, RX_PKT_BUF_SZ,DMA_FROM_DEVICE);
  90                         dev_kfree_skb_any(skb);
  91                         return -ENOMEM;
  92                 }
  93 @@ -745,9 +742,9 @@ static void b44_recycle_rx(struct b44 *b
  94                                              dest_idx * sizeof(*dest_desc),
  95                                              DMA_BIDIRECTIONAL);
  96
  97 -       ssb_dma_sync_single_for_device(bp->sdev, dest_map->mapping,
  98 -                                      RX_PKT_BUF_SZ,
  99 -                                      DMA_FROM_DEVICE);
 100 +       dma_sync_single_for_device(bp->sdev->dma_dev, dest_map->mapping,
 101 +                                  RX_PKT_BUF_SZ,
 102 +                                  DMA_FROM_DEVICE);
 103  }
 104
 105  static int b44_rx(struct b44 *bp, int budget)
 106 @@ -767,9 +764,9 @@ static int b44_rx(struct b44 *bp, int bu
 107                 struct rx_header *rh;
 108                 u16 len;
 109
 110 -               ssb_dma_sync_single_for_cpu(bp->sdev, map,
 111 -                                           RX_PKT_BUF_SZ,
 112 -                                           DMA_FROM_DEVICE);
 113 +               dma_sync_single_for_cpu(bp->sdev->dma_dev, map,
 114 +                                       RX_PKT_BUF_SZ,
 115 +                                       DMA_FROM_DEVICE);
 116                 rh = (struct rx_header *) skb->data;
 117                 len = le16_to_cpu(rh->len);
 118                 if ((len > (RX_PKT_BUF_SZ - RX_PKT_OFFSET)) ||
 119 @@ -801,8 +798,8 @@ static int b44_rx(struct b44 *bp, int bu
 120                         skb_size = b44_alloc_rx_skb(bp, cons, bp->rx_prod);
 121                         if (skb_size < 0)
 122                                 goto drop_it;
 123 -                       ssb_dma_unmap_single(bp->sdev, map,
 124 -                                            skb_size, DMA_FROM_DEVICE);
 125 +                       dma_unmap_single(bp->sdev->dma_dev, map,
 126 +                                        skb_size, DMA_FROM_DEVICE);
 127                         /* Leave out rx_header */
 128                         skb_put(skb, len + RX_PKT_OFFSET);
 129                         skb_pull(skb, RX_PKT_OFFSET);
 130 @@ -954,24 +951,24 @@ static netdev_tx_t b44_start_xmit(struct
 131                 goto err_out;
 132         }
 133
 134 -       mapping = ssb_dma_map_single(bp->sdev, skb->data, len, DMA_TO_DEVICE);
 135 -       if (ssb_dma_mapping_error(bp->sdev, mapping) || mapping + len > DMA_BIT_MASK(30)) {
 136 +       mapping = dma_map_single(bp->sdev->dma_dev, skb->data, len, DMA_TO_DEVICE);
 137 +       if (dma_mapping_error(bp->sdev->dma_dev, mapping) || mapping + len > DMA_BIT_MASK(30)) {
 138                 struct sk_buff *bounce_skb;
 139
 140                 /* Chip can't handle DMA to/from >1GB, use bounce buffer */
 141 -               if (!ssb_dma_mapping_error(bp->sdev, mapping))
 142 -                       ssb_dma_unmap_single(bp->sdev, mapping, len,
 143 +               if (!dma_mapping_error(bp->sdev->dma_dev, mapping))
 144 +                       dma_unmap_single(bp->sdev->dma_dev, mapping, len,
 145                                              DMA_TO_DEVICE);
 146
 147                 bounce_skb = __netdev_alloc_skb(dev, len, GFP_ATOMIC | GFP_DMA);
 148                 if (!bounce_skb)
 149                         goto err_out;
 150
 151 -               mapping = ssb_dma_map_single(bp->sdev, bounce_skb->data,
 152 -                                            len, DMA_TO_DEVICE);
 153 -               if (ssb_dma_mapping_error(bp->sdev, mapping) || mapping + len > DMA_BIT_MASK(30)) {
 154 -                       if (!ssb_dma_mapping_error(bp->sdev, mapping))
 155 -                               ssb_dma_unmap_single(bp->sdev, mapping,
 156 +               mapping = dma_map_single(bp->sdev->dma_dev, bounce_skb->data,
 157 +                                        len, DMA_TO_DEVICE);
 158 +               if (dma_mapping_error(bp->sdev->dma_dev, mapping) || mapping + len > DMA_BIT_MASK(30)) {
 159 +                       if (!dma_mapping_error(bp->sdev->dma_dev, mapping))
 160 +                               dma_unmap_single(bp->sdev->dma_dev, mapping,
 161                                                      len, DMA_TO_DEVICE);
 162                         dev_kfree_skb_any(bounce_skb);
 163                         goto err_out;
 164 @@ -1068,8 +1065,8 @@ static void b44_free_rings(struct b44 *b
 165
 166                 if (rp->skb == NULL)
 167                         continue;
 168 -               ssb_dma_unmap_single(bp->sdev, rp->mapping, RX_PKT_BUF_SZ,
 169 -                                    DMA_FROM_DEVICE);
 170 +               dma_unmap_single(bp->sdev->dma_dev, rp->mapping, RX_PKT_BUF_SZ,
 171 +                                DMA_FROM_DEVICE);
 172                 dev_kfree_skb_any(rp->skb);
 173                 rp->skb = NULL;
 174         }
 175 @@ -1080,8 +1077,8 @@ static void b44_free_rings(struct b44 *b
 176
 177                 if (rp->skb == NULL)
 178                         continue;
 179 -               ssb_dma_unmap_single(bp->sdev, rp->mapping, rp->skb->len,
 180 -                                    DMA_TO_DEVICE);
 181 +               dma_unmap_single(bp->sdev->dma_dev, rp->mapping, rp->skb->len,
 182 +                                DMA_TO_DEVICE);
 183                 dev_kfree_skb_any(rp->skb);
 184                 rp->skb = NULL;
 185         }
 186 @@ -1103,14 +1100,12 @@ static void b44_init_rings(struct b44 *b
 187         memset(bp->tx_ring, 0, B44_TX_RING_BYTES);
 188
 189         if (bp->flags & B44_FLAG_RX_RING_HACK)
 190 -               ssb_dma_sync_single_for_device(bp->sdev, bp->rx_ring_dma,
 191 -                                              DMA_TABLE_BYTES,
 192 -                                              DMA_BIDIRECTIONAL);
 193 +               dma_sync_single_for_device(bp->sdev->dma_dev, bp->rx_ring_dma,
 194 +                                          DMA_TABLE_BYTES, DMA_BIDIRECTIONAL);
 195
 196         if (bp->flags & B44_FLAG_TX_RING_HACK)
 197 -               ssb_dma_sync_single_for_device(bp->sdev, bp->tx_ring_dma,
 198 -                                              DMA_TABLE_BYTES,
 199 -                                              DMA_TO_DEVICE);
 200 +               dma_sync_single_for_device(bp->sdev->dma_dev, bp->tx_ring_dma,
 201 +                                          DMA_TABLE_BYTES, DMA_TO_DEVICE);
 202
 203         for (i = 0; i < bp->rx_pending; i++) {
 204                 if (b44_alloc_rx_skb(bp, -1, i) < 0)
 205 @@ -1130,27 +1125,23 @@ static void b44_free_consistent(struct b
 206         bp->tx_buffers = NULL;
 207         if (bp->rx_ring) {
 208                 if (bp->flags & B44_FLAG_RX_RING_HACK) {
 209 -                       ssb_dma_unmap_single(bp->sdev, bp->rx_ring_dma,
 210 -                                            DMA_TABLE_BYTES,
 211 -                                            DMA_BIDIRECTIONAL);
 212 +                       dma_unmap_single(bp->sdev->dma_dev, bp->rx_ring_dma,
 213 +                                        DMA_TABLE_BYTES, DMA_BIDIRECTIONAL);
 214                         kfree(bp->rx_ring);
 215                 } else
 216 -                       ssb_dma_free_consistent(bp->sdev, DMA_TABLE_BYTES,
 217 -                                               bp->rx_ring, bp->rx_ring_dma,
 218 -                                               GFP_KERNEL);
 219 +                       dma_free_coherent(bp->sdev->dma_dev, DMA_TABLE_BYTES,
 220 +                                         bp->rx_ring, bp->rx_ring_dma);
 221                 bp->rx_ring = NULL;
 222                 bp->flags &= ~B44_FLAG_RX_RING_HACK;
 223         }
 224         if (bp->tx_ring) {
 225                 if (bp->flags & B44_FLAG_TX_RING_HACK) {
 226 -                       ssb_dma_unmap_single(bp->sdev, bp->tx_ring_dma,
 227 -                                            DMA_TABLE_BYTES,
 228 -                                            DMA_TO_DEVICE);
 229 +                       dma_unmap_single(bp->sdev->dma_dev, bp->tx_ring_dma,
 230 +                                        DMA_TABLE_BYTES, DMA_TO_DEVICE);
 231                         kfree(bp->tx_ring);
 232                 } else
 233 -                       ssb_dma_free_consistent(bp->sdev, DMA_TABLE_BYTES,
 234 -                                               bp->tx_ring, bp->tx_ring_dma,
 235 -                                               GFP_KERNEL);
 236 +                       dma_free_coherent(bp->sdev->dma_dev, DMA_TABLE_BYTES,
 237 +                                         bp->tx_ring, bp->tx_ring_dma);
 238                 bp->tx_ring = NULL;
 239                 bp->flags &= ~B44_FLAG_TX_RING_HACK;
 240         }
 241 @@ -1175,7 +1166,8 @@ static int b44_alloc_consistent(struct b
 242                 goto out_err;
 243
 244         size = DMA_TABLE_BYTES;
 245 -       bp->rx_ring = ssb_dma_alloc_consistent(bp->sdev, size, &bp->rx_ring_dma, gfp);
 246 +       bp->rx_ring = dma_alloc_coherent(bp->sdev->dma_dev, size,
 247 +                                        &bp->rx_ring_dma, gfp);
 248         if (!bp->rx_ring) {
 249                 /* Allocation may have failed due to pci_alloc_consistent
 250                    insisting on use of GFP_DMA, which is more restrictive
 251 @@ -1187,11 +1179,11 @@ static int b44_alloc_consistent(struct b
 252                 if (!rx_ring)
 253                         goto out_err;
 254
 255 -               rx_ring_dma = ssb_dma_map_single(bp->sdev, rx_ring,
 256 -                                                DMA_TABLE_BYTES,
 257 -                                                DMA_BIDIRECTIONAL);
 258 +               rx_ring_dma = dma_map_single(bp->sdev->dma_dev, rx_ring,
 259 +                                            DMA_TABLE_BYTES,
 260 +                                            DMA_BIDIRECTIONAL);
 261
 262 -               if (ssb_dma_mapping_error(bp->sdev, rx_ring_dma) ||
 263 +               if (dma_mapping_error(bp->sdev->dma_dev, rx_ring_dma) ||
 264                         rx_ring_dma + size > DMA_BIT_MASK(30)) {
 265                         kfree(rx_ring);
 266                         goto out_err;
 267 @@ -1202,7 +1194,8 @@ static int b44_alloc_consistent(struct b
 268                 bp->flags |= B44_FLAG_RX_RING_HACK;
 269         }
 270
 271 -       bp->tx_ring = ssb_dma_alloc_consistent(bp->sdev, size, &bp->tx_ring_dma, gfp);
 272 +       bp->tx_ring = dma_alloc_coherent(bp->sdev->dma_dev, size,
 273 +                                        &bp->tx_ring_dma, gfp);
 274         if (!bp->tx_ring) {
 275                 /* Allocation may have failed due to ssb_dma_alloc_consistent
 276                    insisting on use of GFP_DMA, which is more restrictive
 277 @@ -1214,11 +1207,11 @@ static int b44_alloc_consistent(struct b
 278                 if (!tx_ring)
 279                         goto out_err;
 280
 281 -               tx_ring_dma = ssb_dma_map_single(bp->sdev, tx_ring,
 282 -                                           DMA_TABLE_BYTES,
 283 -                                           DMA_TO_DEVICE);
 284 +               tx_ring_dma = dma_map_single(bp->sdev->dma_dev, tx_ring,
 285 +                                            DMA_TABLE_BYTES,
 286 +                                            DMA_TO_DEVICE);
 287
 288 -               if (ssb_dma_mapping_error(bp->sdev, tx_ring_dma) ||
 289 +               if (dma_mapping_error(bp->sdev->dma_dev, tx_ring_dma) ||
 290                         tx_ring_dma + size > DMA_BIT_MASK(30)) {
 291                         kfree(tx_ring);
 292                         goto out_err;
 293 @@ -2174,12 +2167,14 @@ static int __devinit b44_init_one(struct
 294                         "Failed to powerup the bus\n");
 295                 goto err_out_free_dev;
 296         }
 297 -       err = ssb_dma_set_mask(sdev, DMA_BIT_MASK(30));
 298 -       if (err) {
 299 +
 300 +       if (dma_set_mask(sdev->dma_dev, DMA_BIT_MASK(30)) ||
 301 +           dma_set_coherent_mask(sdev->dma_dev, DMA_BIT_MASK(30))) {
 302                 dev_err(sdev->dev,
 303                         "Required 30BIT DMA mask unsupported by the system\n");
 304                 goto err_out_powerdown;
 305         }
 306 +
 307         err = b44_get_invariants(bp);
 308         if (err) {
 309                 dev_err(sdev->dev,
 310 @@ -2344,7 +2339,6 @@ static int __init b44_init(void)
 311         int err;
 312
 313         /* Setup paramaters for syncing RX/TX DMA descriptors */
 314 -       dma_desc_align_mask = ~(dma_desc_align_size - 1);
 315         dma_desc_sync_size = max_t(unsigned int, dma_desc_align_size, sizeof(struct dma_desc));
 316
 317         err = b44_pci_init();
 318 --- a/drivers/ssb/driver_chipcommon.c
 319 +++ b/drivers/ssb/driver_chipcommon.c
 320 @@ -209,6 +209,24 @@ static void chipco_powercontrol_init(str
 321         }
 322  }
 323
 324 +/* http://bcm-v4.sipsolutions.net/802.11/PmuFastPwrupDelay */
 325 +static u16 pmu_fast_powerup_delay(struct ssb_chipcommon *cc)
 326 +{
 327 +       struct ssb_bus *bus = cc->dev->bus;
 328 +
 329 +       switch (bus->chip_id) {
 330 +       case 0x4312:
 331 +       case 0x4322:
 332 +       case 0x4328:
 333 +               return 7000;
 334 +       case 0x4325:
 335 +               /* TODO: */
 336 +       default:
 337 +               return 15000;
 338 +       }
 339 +}
 340 +
 341 +/* http://bcm-v4.sipsolutions.net/802.11/ClkctlFastPwrupDelay */
 342  static void calc_fast_powerup_delay(struct ssb_chipcommon *cc)
 343  {
 344         struct ssb_bus *bus = cc->dev->bus;
 345 @@ -218,6 +236,12 @@ static void calc_fast_powerup_delay(stru
 346
 347         if (bus->bustype != SSB_BUSTYPE_PCI)
 348                 return;
 349 +
 350 +       if (cc->capabilities & SSB_CHIPCO_CAP_PMU) {
 351 +               cc->fast_pwrup_delay = pmu_fast_powerup_delay(cc);
 352 +               return;
 353 +       }
 354 +
 355         if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL))
 356                 return;
 357
 358 --- a/drivers/ssb/driver_chipcommon_pmu.c
 359 +++ b/drivers/ssb/driver_chipcommon_pmu.c
 360 @@ -502,9 +502,9 @@ static void ssb_pmu_resources_init(struc
 361                 chipco_write32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, max_msk);
 362  }
 363
 364 +/* http://bcm-v4.sipsolutions.net/802.11/SSB/PmuInit */
 365  void ssb_pmu_init(struct ssb_chipcommon *cc)
 366  {
 367 -       struct ssb_bus *bus = cc->dev->bus;
 368         u32 pmucap;
 369
 370         if (!(cc->capabilities & SSB_CHIPCO_CAP_PMU))
 371 @@ -516,15 +516,12 @@ void ssb_pmu_init(struct ssb_chipcommon
 372         ssb_dprintk(KERN_DEBUG PFX "Found rev %u PMU (capabilities 0x%08X)\n",
 373                     cc->pmu.rev, pmucap);
 374
 375 -       if (cc->pmu.rev >= 1) {
 376 -               if ((bus->chip_id == 0x4325) && (bus->chip_rev < 2)) {
 377 -                       chipco_mask32(cc, SSB_CHIPCO_PMU_CTL,
 378 -                                     ~SSB_CHIPCO_PMU_CTL_NOILPONW);
 379 -               } else {
 380 -                       chipco_set32(cc, SSB_CHIPCO_PMU_CTL,
 381 -                                    SSB_CHIPCO_PMU_CTL_NOILPONW);
 382 -               }
 383 -       }
 384 +       if (cc->pmu.rev == 1)
 385 +               chipco_mask32(cc, SSB_CHIPCO_PMU_CTL,
 386 +                             ~SSB_CHIPCO_PMU_CTL_NOILPONW);
 387 +       else
 388 +               chipco_set32(cc, SSB_CHIPCO_PMU_CTL,
 389 +                            SSB_CHIPCO_PMU_CTL_NOILPONW);
 390         ssb_pmu_pll_init(cc);
 391         ssb_pmu_resources_init(cc);
 392  }
 393 --- a/drivers/ssb/main.c
 394 +++ b/drivers/ssb/main.c
 395 @@ -385,6 +385,35 @@ static int ssb_device_uevent(struct devi
 396                              ssb_dev->id.revision);
 397  }
 398
 399 +#define ssb_config_attr(attrib, field, format_string) \
 400 +static ssize_t \
 401 +attrib##_show(struct device *dev, struct device_attribute *attr, char *buf) \
 402 +{ \
 403 +       return sprintf(buf, format_string, dev_to_ssb_dev(dev)->field); \
 404 +}
 405 +
 406 +ssb_config_attr(core_num, core_index, "%u\n")
 407 +ssb_config_attr(coreid, id.coreid, "0x%04x\n")
 408 +ssb_config_attr(vendor, id.vendor, "0x%04x\n")
 409 +ssb_config_attr(revision, id.revision, "%u\n")
 410 +ssb_config_attr(irq, irq, "%u\n")
 411 +static ssize_t
 412 +name_show(struct device *dev, struct device_attribute *attr, char *buf)
 413 +{
 414 +       return sprintf(buf, "%s\n",
 415 +                      ssb_core_name(dev_to_ssb_dev(dev)->id.coreid));
 416 +}
 417 +
 418 +static struct device_attribute ssb_device_attrs[] = {
 419 +       __ATTR_RO(name),
 420 +       __ATTR_RO(core_num),
 421 +       __ATTR_RO(coreid),
 422 +       __ATTR_RO(vendor),
 423 +       __ATTR_RO(revision),
 424 +       __ATTR_RO(irq),
 425 +       __ATTR_NULL,
 426 +};
 427 +
 428  static struct bus_type ssb_bustype = {
 429         .name           = "ssb",
 430         .match          = ssb_bus_match,
 431 @@ -394,6 +423,7 @@ static struct bus_type ssb_bustype = {
 432         .suspend        = ssb_device_suspend,
 433         .resume         = ssb_device_resume,
 434         .uevent         = ssb_device_uevent,
 435 +       .dev_attrs      = ssb_device_attrs,
 436  };
 437
 438  static void ssb_buses_lock(void)
 439 @@ -486,6 +516,7 @@ static int ssb_devices_register(struct s
 440  #ifdef CONFIG_SSB_PCIHOST
 441                         sdev->irq = bus->host_pci->irq;
 442                         dev->parent = &bus->host_pci->dev;
 443 +                       sdev->dma_dev = dev->parent;
 444  #endif
 445                         break;
 446                 case SSB_BUSTYPE_PCMCIA:
 447 @@ -501,6 +532,7 @@ static int ssb_devices_register(struct s
 448                         break;
 449                 case SSB_BUSTYPE_SSB:
 450                         dev->dma_mask = &dev->coherent_dma_mask;
 451 +                       sdev->dma_dev = dev;
 452                         break;
 453                 }
 454
 455 @@ -1162,10 +1194,10 @@ void ssb_device_enable(struct ssb_device
 456  }
 457  EXPORT_SYMBOL(ssb_device_enable);
 458
 459 -/* Wait for a bit in a register to get set or unset.
 460 +/* Wait for bitmask in a register to get set or cleared.
 461   * timeout is in units of ten-microseconds */
 462 -static int ssb_wait_bit(struct ssb_device *dev, u16 reg, u32 bitmask,
 463 -                       int timeout, int set)
 464 +static int ssb_wait_bits(struct ssb_device *dev, u16 reg, u32 bitmask,
 465 +                        int timeout, int set)
 466  {
 467         int i;
 468         u32 val;
 469 @@ -1173,7 +1205,7 @@ static int ssb_wait_bit(struct ssb_devic
 470         for (i = 0; i < timeout; i++) {
 471                 val = ssb_read32(dev, reg);
 472                 if (set) {
 473 -                       if (val & bitmask)
 474 +                       if ((val & bitmask) == bitmask)
 475                                 return 0;
 476                 } else {
 477                         if (!(val & bitmask))
 478 @@ -1190,20 +1222,38 @@ static int ssb_wait_bit(struct ssb_devic
 479
 480  void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags)
 481  {
 482 -       u32 reject;
 483 +       u32 reject, val;
 484
 485         if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_RESET)
 486                 return;
 487
 488         reject = ssb_tmslow_reject_bitmask(dev);
 489 -       ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK);
 490 -       ssb_wait_bit(dev, SSB_TMSLOW, reject, 1000, 1);
 491 -       ssb_wait_bit(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0);
 492 -       ssb_write32(dev, SSB_TMSLOW,
 493 -                   SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK |
 494 -                   reject | SSB_TMSLOW_RESET |
 495 -                   core_specific_flags);
 496 -       ssb_flush_tmslow(dev);
 497 +
 498 +       if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_CLOCK) {
 499 +               ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK);
 500 +               ssb_wait_bits(dev, SSB_TMSLOW, reject, 1000, 1);
 501 +               ssb_wait_bits(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0);
 502 +
 503 +               if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) {
 504 +                       val = ssb_read32(dev, SSB_IMSTATE);
 505 +                       val |= SSB_IMSTATE_REJECT;
 506 +                       ssb_write32(dev, SSB_IMSTATE, val);
 507 +                       ssb_wait_bits(dev, SSB_IMSTATE, SSB_IMSTATE_BUSY, 1000,
 508 +                                     0);
 509 +               }
 510 +
 511 +               ssb_write32(dev, SSB_TMSLOW,
 512 +                       SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK |
 513 +                       reject | SSB_TMSLOW_RESET |
 514 +                       core_specific_flags);
 515 +               ssb_flush_tmslow(dev);
 516 +
 517 +               if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) {
 518 +                       val = ssb_read32(dev, SSB_IMSTATE);
 519 +                       val &= ~SSB_IMSTATE_REJECT;
 520 +                       ssb_write32(dev, SSB_IMSTATE, val);
 521 +               }
 522 +       }
 523
 524         ssb_write32(dev, SSB_TMSLOW,
 525                     reject | SSB_TMSLOW_RESET |
 526 @@ -1226,80 +1276,6 @@ u32 ssb_dma_translation(struct ssb_devic
 527  }
 528  EXPORT_SYMBOL(ssb_dma_translation);
 529
 530 -int ssb_dma_set_mask(struct ssb_device *dev, u64 mask)
 531 -{
 532 -#ifdef CONFIG_SSB_PCIHOST
 533 -       int err;
 534 -#endif
 535 -
 536 -       switch (dev->bus->bustype) {
 537 -       case SSB_BUSTYPE_PCI:
 538 -#ifdef CONFIG_SSB_PCIHOST
 539 -               err = pci_set_dma_mask(dev->bus->host_pci, mask);
 540 -               if (err)
 541 -                       return err;
 542 -               err = pci_set_consistent_dma_mask(dev->bus->host_pci, mask);
 543 -               return err;
 544 -#endif
 545 -       case SSB_BUSTYPE_SSB:
 546 -               return dma_set_mask(dev->dev, mask);
 547 -       default:
 548 -               __ssb_dma_not_implemented(dev);
 549 -       }
 550 -       return -ENOSYS;
 551 -}
 552 -EXPORT_SYMBOL(ssb_dma_set_mask);
 553 -
 554 -void * ssb_dma_alloc_consistent(struct ssb_device *dev, size_t size,
 555 -                               dma_addr_t *dma_handle, gfp_t gfp_flags)
 556 -{
 557 -       switch (dev->bus->bustype) {
 558 -       case SSB_BUSTYPE_PCI:
 559 -#ifdef CONFIG_SSB_PCIHOST
 560 -               if (gfp_flags & GFP_DMA) {
 561 -                       /* Workaround: The PCI API does not support passing
 562 -                        * a GFP flag. */
 563 -                       return dma_alloc_coherent(&dev->bus->host_pci->dev,
 564 -                                                 size, dma_handle, gfp_flags);
 565 -               }
 566 -               return pci_alloc_consistent(dev->bus->host_pci, size, dma_handle);
 567 -#endif
 568 -       case SSB_BUSTYPE_SSB:
 569 -               return dma_alloc_coherent(dev->dev, size, dma_handle, gfp_flags);
 570 -       default:
 571 -               __ssb_dma_not_implemented(dev);
 572 -       }
 573 -       return NULL;
 574 -}
 575 -EXPORT_SYMBOL(ssb_dma_alloc_consistent);
 576 -
 577 -void ssb_dma_free_consistent(struct ssb_device *dev, size_t size,
 578 -                            void *vaddr, dma_addr_t dma_handle,
 579 -                            gfp_t gfp_flags)
 580 -{
 581 -       switch (dev->bus->bustype) {
 582 -       case SSB_BUSTYPE_PCI:
 583 -#ifdef CONFIG_SSB_PCIHOST
 584 -               if (gfp_flags & GFP_DMA) {
 585 -                       /* Workaround: The PCI API does not support passing
 586 -                        * a GFP flag. */
 587 -                       dma_free_coherent(&dev->bus->host_pci->dev,
 588 -                                         size, vaddr, dma_handle);
 589 -                       return;
 590 -               }
 591 -               pci_free_consistent(dev->bus->host_pci, size,
 592 -                                   vaddr, dma_handle);
 593 -               return;
 594 -#endif
 595 -       case SSB_BUSTYPE_SSB:
 596 -               dma_free_coherent(dev->dev, size, vaddr, dma_handle);
 597 -               return;
 598 -       default:
 599 -               __ssb_dma_not_implemented(dev);
 600 -       }
 601 -}
 602 -EXPORT_SYMBOL(ssb_dma_free_consistent);
 603 -
 604  int ssb_bus_may_powerdown(struct ssb_bus *bus)
 605  {
 606         struct ssb_chipcommon *cc;
 607 --- a/drivers/ssb/pci.c
 608 +++ b/drivers/ssb/pci.c
 609 @@ -406,6 +406,46 @@ static void sprom_extract_r123(struct ss
 610         out->antenna_gain.ghz5.a3 = gain;
 611  }
 612
 613 +/* Revs 4 5 and 8 have partially shared layout */
 614 +static void sprom_extract_r458(struct ssb_sprom *out, const u16 *in)
 615 +{
 616 +       SPEX(txpid2g[0], SSB_SPROM4_TXPID2G01,
 617 +            SSB_SPROM4_TXPID2G0, SSB_SPROM4_TXPID2G0_SHIFT);
 618 +       SPEX(txpid2g[1], SSB_SPROM4_TXPID2G01,
 619 +            SSB_SPROM4_TXPID2G1, SSB_SPROM4_TXPID2G1_SHIFT);
 620 +       SPEX(txpid2g[2], SSB_SPROM4_TXPID2G23,
 621 +            SSB_SPROM4_TXPID2G2, SSB_SPROM4_TXPID2G2_SHIFT);
 622 +       SPEX(txpid2g[3], SSB_SPROM4_TXPID2G23,
 623 +            SSB_SPROM4_TXPID2G3, SSB_SPROM4_TXPID2G3_SHIFT);
 624 +
 625 +       SPEX(txpid5gl[0], SSB_SPROM4_TXPID5GL01,
 626 +            SSB_SPROM4_TXPID5GL0, SSB_SPROM4_TXPID5GL0_SHIFT);
 627 +       SPEX(txpid5gl[1], SSB_SPROM4_TXPID5GL01,
 628 +            SSB_SPROM4_TXPID5GL1, SSB_SPROM4_TXPID5GL1_SHIFT);
 629 +       SPEX(txpid5gl[2], SSB_SPROM4_TXPID5GL23,
 630 +            SSB_SPROM4_TXPID5GL2, SSB_SPROM4_TXPID5GL2_SHIFT);
 631 +       SPEX(txpid5gl[3], SSB_SPROM4_TXPID5GL23,
 632 +            SSB_SPROM4_TXPID5GL3, SSB_SPROM4_TXPID5GL3_SHIFT);
 633 +
 634 +       SPEX(txpid5g[0], SSB_SPROM4_TXPID5G01,
 635 +            SSB_SPROM4_TXPID5G0, SSB_SPROM4_TXPID5G0_SHIFT);
 636 +       SPEX(txpid5g[1], SSB_SPROM4_TXPID5G01,
 637 +            SSB_SPROM4_TXPID5G1, SSB_SPROM4_TXPID5G1_SHIFT);
 638 +       SPEX(txpid5g[2], SSB_SPROM4_TXPID5G23,
 639 +            SSB_SPROM4_TXPID5G2, SSB_SPROM4_TXPID5G2_SHIFT);
 640 +       SPEX(txpid5g[3], SSB_SPROM4_TXPID5G23,
 641 +            SSB_SPROM4_TXPID5G3, SSB_SPROM4_TXPID5G3_SHIFT);
 642 +
 643 +       SPEX(txpid5gh[0], SSB_SPROM4_TXPID5GH01,
 644 +            SSB_SPROM4_TXPID5GH0, SSB_SPROM4_TXPID5GH0_SHIFT);
 645 +       SPEX(txpid5gh[1], SSB_SPROM4_TXPID5GH01,
 646 +            SSB_SPROM4_TXPID5GH1, SSB_SPROM4_TXPID5GH1_SHIFT);
 647 +       SPEX(txpid5gh[2], SSB_SPROM4_TXPID5GH23,
 648 +            SSB_SPROM4_TXPID5GH2, SSB_SPROM4_TXPID5GH2_SHIFT);
 649 +       SPEX(txpid5gh[3], SSB_SPROM4_TXPID5GH23,
 650 +            SSB_SPROM4_TXPID5GH3, SSB_SPROM4_TXPID5GH3_SHIFT);
 651 +}
 652 +
 653  static void sprom_extract_r45(struct ssb_sprom *out, const u16 *in)
 654  {
 655         int i;
 656 @@ -428,10 +468,14 @@ static void sprom_extract_r45(struct ssb
 657                 SPEX(country_code, SSB_SPROM4_CCODE, 0xFFFF, 0);
 658                 SPEX(boardflags_lo, SSB_SPROM4_BFLLO, 0xFFFF, 0);
 659                 SPEX(boardflags_hi, SSB_SPROM4_BFLHI, 0xFFFF, 0);
 660 +               SPEX(boardflags2_lo, SSB_SPROM4_BFL2LO, 0xFFFF, 0);
 661 +               SPEX(boardflags2_hi, SSB_SPROM4_BFL2HI, 0xFFFF, 0);
 662         } else {
 663                 SPEX(country_code, SSB_SPROM5_CCODE, 0xFFFF, 0);
 664                 SPEX(boardflags_lo, SSB_SPROM5_BFLLO, 0xFFFF, 0);
 665                 SPEX(boardflags_hi, SSB_SPROM5_BFLHI, 0xFFFF, 0);
 666 +               SPEX(boardflags2_lo, SSB_SPROM5_BFL2LO, 0xFFFF, 0);
 667 +               SPEX(boardflags2_hi, SSB_SPROM5_BFL2HI, 0xFFFF, 0);
 668         }
 669         SPEX(ant_available_a, SSB_SPROM4_ANTAVAIL, SSB_SPROM4_ANTAVAIL_A,
 670              SSB_SPROM4_ANTAVAIL_A_SHIFT);
 671 @@ -471,6 +515,8 @@ static void sprom_extract_r45(struct ssb
 672         memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24,
 673                sizeof(out->antenna_gain.ghz5));
 674
 675 +       sprom_extract_r458(out, in);
 676 +
 677         /* TODO - get remaining rev 4 stuff needed */
 678  }
 679
 680 @@ -561,6 +607,8 @@ static void sprom_extract_r8(struct ssb_
 681         memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24,
 682                sizeof(out->antenna_gain.ghz5));
 683
 684 +       sprom_extract_r458(out, in);
 685 +
 686         /* TODO - get remaining rev 8 stuff needed */
 687  }
 688
 689 @@ -573,37 +621,34 @@ static int sprom_extract(struct ssb_bus
 690         ssb_dprintk(KERN_DEBUG PFX "SPROM revision %d detected.\n", out->revision);
 691         memset(out->et0mac, 0xFF, 6);           /* preset et0 and et1 mac */
 692         memset(out->et1mac, 0xFF, 6);
 693 +
 694         if ((bus->chip_id & 0xFF00) == 0x4400) {
 695                 /* Workaround: The BCM44XX chip has a stupid revision
 696                  * number stored in the SPROM.
 697                  * Always extract r1. */
 698                 out->revision = 1;
 699 +               ssb_dprintk(KERN_DEBUG PFX "SPROM treated as revision %d\n", out->revision);
 700 +       }
 701 +
 702 +       switch (out->revision) {
 703 +       case 1:
 704 +       case 2:
 705 +       case 3:
 706                 sprom_extract_r123(out, in);
 707 -       } else if (bus->chip_id == 0x4321) {
 708 -               /* the BCM4328 has a chipid == 0x4321 and a rev 4 SPROM */
 709 -               out->revision = 4;
 710 +               break;
 711 +       case 4:
 712 +       case 5:
 713                 sprom_extract_r45(out, in);
 714 -       } else {
 715 -               switch (out->revision) {
 716 -               case 1:
 717 -               case 2:
 718 -               case 3:
 719 -                       sprom_extract_r123(out, in);
 720 -                       break;
 721 -               case 4:
 722 -               case 5:
 723 -                       sprom_extract_r45(out, in);
 724 -                       break;
 725 -               case 8:
 726 -                       sprom_extract_r8(out, in);
 727 -                       break;
 728 -               default:
 729 -                       ssb_printk(KERN_WARNING PFX "Unsupported SPROM"
 730 -                                  "  revision %d detected. Will extract"
 731 -                                  " v1\n", out->revision);
 732 -                       out->revision = 1;
 733 -                       sprom_extract_r123(out, in);
 734 -               }
 735 +               break;
 736 +       case 8:
 737 +               sprom_extract_r8(out, in);
 738 +               break;
 739 +       default:
 740 +               ssb_printk(KERN_WARNING PFX "Unsupported SPROM"
 741 +                          " revision %d detected. Will extract"
 742 +                          " v1\n", out->revision);
 743 +               out->revision = 1;
 744 +               sprom_extract_r123(out, in);
 745         }
 746
 747         if (out->boardflags_lo == 0xFFFF)
 748 @@ -618,7 +663,7 @@ static int ssb_pci_sprom_get(struct ssb_
 749                              struct ssb_sprom *sprom)
 750  {
 751         const struct ssb_sprom *fallback;
 752 -       int err = -ENOMEM;
 753 +       int err;
 754         u16 *buf;
 755
 756         if (!ssb_is_sprom_available(bus)) {
 757 @@ -645,7 +690,7 @@ static int ssb_pci_sprom_get(struct ssb_
 758
 759         buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL);
 760         if (!buf)
 761 -               goto out;
 762 +               return -ENOMEM;
 763         bus->sprom_size = SSB_SPROMSIZE_WORDS_R123;
 764         sprom_do_read(bus, buf);
 765         err = sprom_check_crc(buf, bus->sprom_size);
 766 @@ -655,7 +700,7 @@ static int ssb_pci_sprom_get(struct ssb_
 767                 buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16),
 768                               GFP_KERNEL);
 769                 if (!buf)
 770 -                       goto out;
 771 +                       return -ENOMEM;
 772                 bus->sprom_size = SSB_SPROMSIZE_WORDS_R4;
 773                 sprom_do_read(bus, buf);
 774                 err = sprom_check_crc(buf, bus->sprom_size);
 775 @@ -677,7 +722,6 @@ static int ssb_pci_sprom_get(struct ssb_
 776
 777  out_free:
 778         kfree(buf);
 779 -out:
 780         return err;
 781  }
 782
 783 --- a/drivers/ssb/pcihost_wrapper.c
 784 +++ b/drivers/ssb/pcihost_wrapper.c
 785 @@ -59,6 +59,7 @@ static int ssb_pcihost_probe(struct pci_
 786         struct ssb_bus *ssb;
 787         int err = -ENOMEM;
 788         const char *name;
 789 +       u32 val;
 790
 791         ssb = kzalloc(sizeof(*ssb), GFP_KERNEL);
 792         if (!ssb)
 793 @@ -74,6 +75,12 @@ static int ssb_pcihost_probe(struct pci_
 794                 goto err_pci_disable;
 795         pci_set_master(dev);
 796
 797 +       /* Disable the RETRY_TIMEOUT register (0x41) to keep
 798 +        * PCI Tx retries from interfering with C3 CPU state */
 799 +       pci_read_config_dword(dev, 0x40, &val);
 800 +       if ((val & 0x0000ff00) != 0)
 801 +               pci_write_config_dword(dev, 0x40, val & 0xffff00ff);
 802 +
 803         err = ssb_bus_pcibus_register(ssb, dev);
 804         if (err)
 805                 goto err_pci_release_regions;
 806 --- a/drivers/ssb/pcmcia.c
 807 +++ b/drivers/ssb/pcmcia.c
 808 @@ -745,7 +745,7 @@ int ssb_pcmcia_get_invariants(struct ssb
 809
 810         /* Fetch the vendor specific tuples. */
 811         res = pcmcia_loop_tuple(bus->host_pcmcia, SSB_PCMCIA_CIS,
 812 -                               ssb_pcmcia_do_get_invariants, sprom);
 813 +                               ssb_pcmcia_do_get_invariants, iv);
 814         if ((res == 0) || (res == -ENOSPC))
 815                 return 0;
 816
 817 --- a/drivers/ssb/scan.c
 818 +++ b/drivers/ssb/scan.c
 819 @@ -407,10 +407,10 @@ int ssb_bus_scan(struct ssb_bus *bus,
 820                                 /* Ignore PCI cores on PCI-E cards.
 821                                  * Ignore PCI-E cores on PCI cards. */
 822                                 if (dev->id.coreid == SSB_DEV_PCI) {
 823 -                                       if (bus->host_pci->is_pcie)
 824 +                                       if (pci_is_pcie(bus->host_pci))
 825                                                 continue;
 826                                 } else {
 827 -                                       if (!bus->host_pci->is_pcie)
 828 +                                       if (!pci_is_pcie(bus->host_pci))
 829                                                 continue;
 830                                 }
 831                         }
 832 @@ -422,6 +422,16 @@ int ssb_bus_scan(struct ssb_bus *bus,
 833                         bus->pcicore.dev = dev;
 834  #endif /* CONFIG_SSB_DRIVER_PCICORE */
 835                         break;
 836 +               case SSB_DEV_ETHERNET:
 837 +                       if (bus->bustype == SSB_BUSTYPE_PCI) {
 838 +                               if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM &&
 839 +                                   (bus->host_pci->device & 0xFF00) == 0x4300) {
 840 +                                       /* This is a dangling ethernet core on a
 841 +                                        * wireless device. Ignore it. */
 842 +                                       continue;
 843 +                               }
 844 +                       }
 845 +                       break;
 846                 default:
 847                         break;
 848                 }
 849 --- a/include/linux/ssb/ssb.h
 850 +++ b/include/linux/ssb/ssb.h
 851 @@ -55,6 +55,10 @@ struct ssb_sprom {
 852         u8 tri5gl;              /* 5.2GHz TX isolation */
 853         u8 tri5g;               /* 5.3GHz TX isolation */
 854         u8 tri5gh;              /* 5.8GHz TX isolation */
 855 +       u8 txpid2g[4];          /* 2GHz TX power index */
 856 +       u8 txpid5gl[4];         /* 4.9 - 5.1GHz TX power index */
 857 +       u8 txpid5g[4];          /* 5.1 - 5.5GHz TX power index */
 858 +       u8 txpid5gh[4];         /* 5.5 - ...GHz TX power index */
 859         u8 rxpo2g;              /* 2GHz RX power offset */
 860         u8 rxpo5g;              /* 5GHz RX power offset */
 861         u8 rssisav2g;           /* 2GHz RSSI params */
 862 @@ -167,7 +171,7 @@ struct ssb_device {
 863          * is an optimization. */
 864         const struct ssb_bus_ops *ops;
 865
 866 -       struct device *dev;
 867 +       struct device *dev, *dma_dev;
 868
 869         struct ssb_bus *bus;
 870         struct ssb_device_id id;
 871 @@ -470,14 +474,6 @@ extern u32 ssb_dma_translation(struct ss
 872  #define SSB_DMA_TRANSLATION_MASK       0xC0000000
 873  #define SSB_DMA_TRANSLATION_SHIFT      30
 874
 875 -extern int ssb_dma_set_mask(struct ssb_device *dev, u64 mask);
 876 -
 877 -extern void * ssb_dma_alloc_consistent(struct ssb_device *dev, size_t size,
 878 -                                      dma_addr_t *dma_handle, gfp_t gfp_flags);
 879 -extern void ssb_dma_free_consistent(struct ssb_device *dev, size_t size,
 880 -                                   void *vaddr, dma_addr_t dma_handle,
 881 -                                   gfp_t gfp_flags);
 882 -
 883  static inline void __cold __ssb_dma_not_implemented(struct ssb_device *dev)
 884  {
 885  #ifdef CONFIG_SSB_DEBUG
 886 @@ -486,155 +482,6 @@ static inline void __cold __ssb_dma_not_
 887  #endif /* DEBUG */
 888  }
 889
 890 -static inline int ssb_dma_mapping_error(struct ssb_device *dev, dma_addr_t addr)
 891 -{
 892 -       switch (dev->bus->bustype) {
 893 -       case SSB_BUSTYPE_PCI:
 894 -#ifdef CONFIG_SSB_PCIHOST
 895 -               return pci_dma_mapping_error(dev->bus->host_pci, addr);
 896 -#endif
 897 -               break;
 898 -       case SSB_BUSTYPE_SSB:
 899 -               return dma_mapping_error(dev->dev, addr);
 900 -       default:
 901 -               break;
 902 -       }
 903 -       __ssb_dma_not_implemented(dev);
 904 -       return -ENOSYS;
 905 -}
 906 -
 907 -static inline dma_addr_t ssb_dma_map_single(struct ssb_device *dev, void *p,
 908 -                                           size_t size, enum dma_data_direction dir)
 909 -{
 910 -       switch (dev->bus->bustype) {
 911 -       case SSB_BUSTYPE_PCI:
 912 -#ifdef CONFIG_SSB_PCIHOST
 913 -               return pci_map_single(dev->bus->host_pci, p, size, dir);
 914 -#endif
 915 -               break;
 916 -       case SSB_BUSTYPE_SSB:
 917 -               return dma_map_single(dev->dev, p, size, dir);
 918 -       default:
 919 -               break;
 920 -       }
 921 -       __ssb_dma_not_implemented(dev);
 922 -       return 0;
 923 -}
 924 -
 925 -static inline void ssb_dma_unmap_single(struct ssb_device *dev, dma_addr_t dma_addr,
 926 -                                       size_t size, enum dma_data_direction dir)
 927 -{
 928 -       switch (dev->bus->bustype) {
 929 -       case SSB_BUSTYPE_PCI:
 930 -#ifdef CONFIG_SSB_PCIHOST
 931 -               pci_unmap_single(dev->bus->host_pci, dma_addr, size, dir);
 932 -               return;
 933 -#endif
 934 -               break;
 935 -       case SSB_BUSTYPE_SSB:
 936 -               dma_unmap_single(dev->dev, dma_addr, size, dir);
 937 -               return;
 938 -       default:
 939 -               break;
 940 -       }
 941 -       __ssb_dma_not_implemented(dev);
 942 -}
 943 -
 944 -static inline void ssb_dma_sync_single_for_cpu(struct ssb_device *dev,
 945 -                                              dma_addr_t dma_addr,
 946 -                                              size_t size,
 947 -                                              enum dma_data_direction dir)
 948 -{
 949 -       switch (dev->bus->bustype) {
 950 -       case SSB_BUSTYPE_PCI:
 951 -#ifdef CONFIG_SSB_PCIHOST
 952 -               pci_dma_sync_single_for_cpu(dev->bus->host_pci, dma_addr,
 953 -                                           size, dir);
 954 -               return;
 955 -#endif
 956 -               break;
 957 -       case SSB_BUSTYPE_SSB:
 958 -               dma_sync_single_for_cpu(dev->dev, dma_addr, size, dir);
 959 -               return;
 960 -       default:
 961 -               break;
 962 -       }
 963 -       __ssb_dma_not_implemented(dev);
 964 -}
 965 -
 966 -static inline void ssb_dma_sync_single_for_device(struct ssb_device *dev,
 967 -                                                 dma_addr_t dma_addr,
 968 -                                                 size_t size,
 969 -                                                 enum dma_data_direction dir)
 970 -{
 971 -       switch (dev->bus->bustype) {
 972 -       case SSB_BUSTYPE_PCI:
 973 -#ifdef CONFIG_SSB_PCIHOST
 974 -               pci_dma_sync_single_for_device(dev->bus->host_pci, dma_addr,
 975 -                                              size, dir);
 976 -               return;
 977 -#endif
 978 -               break;
 979 -       case SSB_BUSTYPE_SSB:
 980 -               dma_sync_single_for_device(dev->dev, dma_addr, size, dir);
 981 -               return;
 982 -       default:
 983 -               break;
 984 -       }
 985 -       __ssb_dma_not_implemented(dev);
 986 -}
 987 -
 988 -static inline void ssb_dma_sync_single_range_for_cpu(struct ssb_device *dev,
 989 -                                                    dma_addr_t dma_addr,
 990 -                                                    unsigned long offset,
 991 -                                                    size_t size,
 992 -                                                    enum dma_data_direction dir)
 993 -{
 994 -       switch (dev->bus->bustype) {
 995 -       case SSB_BUSTYPE_PCI:
 996 -#ifdef CONFIG_SSB_PCIHOST
 997 -               /* Just sync everything. That's all the PCI API can do. */
 998 -               pci_dma_sync_single_for_cpu(dev->bus->host_pci, dma_addr,
 999 -                                           offset + size, dir);
1000 -               return;
1001 -#endif
1002 -               break;
1003 -       case SSB_BUSTYPE_SSB:
1004 -               dma_sync_single_range_for_cpu(dev->dev, dma_addr, offset,
1005 -                                             size, dir);
1006 -               return;
1007 -       default:
1008 -               break;
1009 -       }
1010 -       __ssb_dma_not_implemented(dev);
1011 -}
1012 -
1013 -static inline void ssb_dma_sync_single_range_for_device(struct ssb_device *dev,
1014 -                                                       dma_addr_t dma_addr,
1015 -                                                       unsigned long offset,
1016 -                                                       size_t size,
1017 -                                                       enum dma_data_direction dir)
1018 -{
1019 -       switch (dev->bus->bustype) {
1020 -       case SSB_BUSTYPE_PCI:
1021 -#ifdef CONFIG_SSB_PCIHOST
1022 -               /* Just sync everything. That's all the PCI API can do. */
1023 -               pci_dma_sync_single_for_device(dev->bus->host_pci, dma_addr,
1024 -                                              offset + size, dir);
1025 -               return;
1026 -#endif
1027 -               break;
1028 -       case SSB_BUSTYPE_SSB:
1029 -               dma_sync_single_range_for_device(dev->dev, dma_addr, offset,
1030 -                                                size, dir);
1031 -               return;
1032 -       default:
1033 -               break;
1034 -       }
1035 -       __ssb_dma_not_implemented(dev);
1036 -}
1037 -
1038 -
1039  #ifdef CONFIG_SSB_PCIHOST
1040  /* PCI-host wrapper driver */
1041  extern int ssb_pcihost_register(struct pci_driver *driver);
1042 --- a/include/linux/ssb/ssb_driver_gige.h
1043 +++ b/include/linux/ssb/ssb_driver_gige.h
1044 @@ -96,16 +96,21 @@ static inline bool ssb_gige_must_flush_p
1045         return 0;
1046  }
1047
1048 -extern char * nvram_get(const char *name);
1049 +#ifdef CONFIG_BCM47XX
1050 +#include <asm/mach-bcm47xx/nvram.h>
1051  /* Get the device MAC address */
1052  static inline void ssb_gige_get_macaddr(struct pci_dev *pdev, u8 *macaddr)
1053  {
1054 -#ifdef CONFIG_BCM47XX
1055 -       char *res = nvram_get("et0macaddr");
1056 -       if (res)
1057 -               memcpy(macaddr, res, 6);
1058 -#endif
1059 +       char buf[20];
1060 +       if (nvram_getenv("et0macaddr", buf, sizeof(buf)) < 0)
1061 +               return;
1062 +       nvram_parse_macaddr(buf, macaddr);
1063  }
1064 +#else
1065 +static inline void ssb_gige_get_macaddr(struct pci_dev *pdev, u8 *macaddr)
1066 +{
1067 +}
1068 +#endif
1069
1070  extern int ssb_gige_pcibios_plat_dev_init(struct ssb_device *sdev,
1071                                           struct pci_dev *pdev);
1072 --- a/include/linux/ssb/ssb_regs.h
1073 +++ b/include/linux/ssb/ssb_regs.h
1074 @@ -85,6 +85,8 @@
1075  #define  SSB_IMSTATE_AP_RSV    0x00000030 /* Reserved */
1076  #define  SSB_IMSTATE_IBE       0x00020000 /* In Band Error */
1077  #define  SSB_IMSTATE_TO                0x00040000 /* Timeout */
1078 +#define  SSB_IMSTATE_BUSY      0x01800000 /* Busy (Backplane rev >= 2.3 only) */
1079 +#define  SSB_IMSTATE_REJECT    0x02000000 /* Reject (Backplane rev >= 2.3 only) */
1080  #define SSB_INTVEC             0x0F94     /* SB Interrupt Mask */
1081  #define  SSB_INTVEC_PCI                0x00000001 /* Enable interrupts for PCI */
1082  #define  SSB_INTVEC_ENET0      0x00000002 /* Enable interrupts for enet 0 */
1083 @@ -267,6 +269,8 @@
1084  /* SPROM Revision 4 */
1085  #define SSB_SPROM4_BFLLO               0x0044  /* Boardflags (low 16 bits) */
1086  #define SSB_SPROM4_BFLHI               0x0046  /* Board Flags Hi */
1087 +#define SSB_SPROM4_BFL2LO              0x0048  /* Board flags 2 (low 16 bits) */
1088 +#define SSB_SPROM4_BFL2HI              0x004A  /* Board flags 2 Hi */
1089  #define SSB_SPROM4_IL0MAC              0x004C  /* 6 byte MAC address for a/b/g/n */
1090  #define SSB_SPROM4_CCODE               0x0052  /* Country Code (2 bytes) */
1091  #define SSB_SPROM4_GPIOA               0x0056  /* Gen. Purpose IO # 0 and 1 */
1092 @@ -298,6 +302,46 @@
1093  #define  SSB_SPROM4_AGAIN2_SHIFT       0
1094  #define  SSB_SPROM4_AGAIN3             0xFF00  /* Antenna 3 */
1095  #define  SSB_SPROM4_AGAIN3_SHIFT       8
1096 +#define SSB_SPROM4_TXPID2G01           0x0062  /* TX Power Index 2GHz */
1097 +#define  SSB_SPROM4_TXPID2G0           0x00FF
1098 +#define  SSB_SPROM4_TXPID2G0_SHIFT     0
1099 +#define  SSB_SPROM4_TXPID2G1           0xFF00
1100 +#define  SSB_SPROM4_TXPID2G1_SHIFT     8
1101 +#define SSB_SPROM4_TXPID2G23           0x0064  /* TX Power Index 2GHz */
1102 +#define  SSB_SPROM4_TXPID2G2           0x00FF
1103 +#define  SSB_SPROM4_TXPID2G2_SHIFT     0
1104 +#define  SSB_SPROM4_TXPID2G3           0xFF00
1105 +#define  SSB_SPROM4_TXPID2G3_SHIFT     8
1106 +#define SSB_SPROM4_TXPID5G01           0x0066  /* TX Power Index 5GHz middle subband */
1107 +#define  SSB_SPROM4_TXPID5G0           0x00FF
1108 +#define  SSB_SPROM4_TXPID5G0_SHIFT     0
1109 +#define  SSB_SPROM4_TXPID5G1           0xFF00
1110 +#define  SSB_SPROM4_TXPID5G1_SHIFT     8
1111 +#define SSB_SPROM4_TXPID5G23           0x0068  /* TX Power Index 5GHz middle subband */
1112 +#define  SSB_SPROM4_TXPID5G2           0x00FF
1113 +#define  SSB_SPROM4_TXPID5G2_SHIFT     0
1114 +#define  SSB_SPROM4_TXPID5G3           0xFF00
1115 +#define  SSB_SPROM4_TXPID5G3_SHIFT     8
1116 +#define SSB_SPROM4_TXPID5GL01          0x006A  /* TX Power Index 5GHz low subband */
1117 +#define  SSB_SPROM4_TXPID5GL0          0x00FF
1118 +#define  SSB_SPROM4_TXPID5GL0_SHIFT    0
1119 +#define  SSB_SPROM4_TXPID5GL1          0xFF00
1120 +#define  SSB_SPROM4_TXPID5GL1_SHIFT    8
1121 +#define SSB_SPROM4_TXPID5GL23          0x006C  /* TX Power Index 5GHz low subband */
1122 +#define  SSB_SPROM4_TXPID5GL2          0x00FF
1123 +#define  SSB_SPROM4_TXPID5GL2_SHIFT    0
1124 +#define  SSB_SPROM4_TXPID5GL3          0xFF00
1125 +#define  SSB_SPROM4_TXPID5GL3_SHIFT    8
1126 +#define SSB_SPROM4_TXPID5GH01          0x006E  /* TX Power Index 5GHz high subband */
1127 +#define  SSB_SPROM4_TXPID5GH0          0x00FF
1128 +#define  SSB_SPROM4_TXPID5GH0_SHIFT    0
1129 +#define  SSB_SPROM4_TXPID5GH1          0xFF00
1130 +#define  SSB_SPROM4_TXPID5GH1_SHIFT    8
1131 +#define SSB_SPROM4_TXPID5GH23          0x0070  /* TX Power Index 5GHz high subband */
1132 +#define  SSB_SPROM4_TXPID5GH2          0x00FF
1133 +#define  SSB_SPROM4_TXPID5GH2_SHIFT    0
1134 +#define  SSB_SPROM4_TXPID5GH3          0xFF00
1135 +#define  SSB_SPROM4_TXPID5GH3_SHIFT    8
1136  #define SSB_SPROM4_MAXP_BG             0x0080  /* Max Power BG in path 1 */
1137  #define  SSB_SPROM4_MAXP_BG_MASK       0x00FF  /* Mask for Max Power BG */
1138  #define  SSB_SPROM4_ITSSI_BG           0xFF00  /* Mask for path 1 itssi_bg */
1139 @@ -317,6 +361,8 @@
1140  #define SSB_SPROM5_CCODE               0x0044  /* Country Code (2 bytes) */
1141  #define SSB_SPROM5_BFLLO               0x004A  /* Boardflags (low 16 bits) */
1142  #define SSB_SPROM5_BFLHI               0x004C  /* Board Flags Hi */
1143 +#define SSB_SPROM5_BFL2LO              0x004E  /* Board flags 2 (low 16 bits) */
1144 +#define SSB_SPROM5_BFL2HI              0x0050  /* Board flags 2 Hi */
1145  #define SSB_SPROM5_IL0MAC              0x0052  /* 6 byte MAC address for a/b/g/n */
1146  #define SSB_SPROM5_GPIOA               0x0076  /* Gen. Purpose IO # 0 and 1 */
1147  #define  SSB_SPROM5_GPIOA_P0           0x00FF  /* Pin 0 */