drivers/net/wireless/brcm80211/brcmsmac/dma.c

   1 /*
   2  * Copyright (c) 2010 Broadcom Corporation
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16 #include <linux/slab.h>
  17 #include <linux/skbuff.h>
  18 #include <linux/delay.h>
  19 #include <linux/pci.h>
  20
  21 #include <brcmu_utils.h>
  22 #include <aiutils.h>
  23 #include "types.h"
  24 #include "dma.h"
  25
  26 /*
  27  * DMA hardware requires each descriptor ring to be 8kB aligned, and fit within
  28  * a contiguous 8kB physical address.
  29  */
  30 #define D64RINGALIGN_BITS       13
  31 #define D64MAXRINGSZ            (1 << D64RINGALIGN_BITS)
  32 #define D64RINGALIGN            (1 << D64RINGALIGN_BITS)
  33
  34 #define D64MAXDD        (D64MAXRINGSZ / sizeof(struct dma64desc))
  35
  36 /* transmit channel control */
  37 #define D64_XC_XE               0x00000001      /* transmit enable */
  38 #define D64_XC_SE               0x00000002      /* transmit suspend request */
  39 #define D64_XC_LE               0x00000004      /* loopback enable */
  40 #define D64_XC_FL               0x00000010      /* flush request */
  41 #define D64_XC_PD               0x00000800      /* parity check disable */
  42 #define D64_XC_AE               0x00030000      /* address extension bits */
  43 #define D64_XC_AE_SHIFT         16
  44
  45 /* transmit descriptor table pointer */
  46 #define D64_XP_LD_MASK          0x00000fff      /* last valid descriptor */
  47
  48 /* transmit channel status */
  49 #define D64_XS0_CD_MASK         0x00001fff      /* current descriptor pointer */
  50 #define D64_XS0_XS_MASK         0xf0000000      /* transmit state */
  51 #define D64_XS0_XS_SHIFT                28
  52 #define D64_XS0_XS_DISABLED     0x00000000      /* disabled */
  53 #define D64_XS0_XS_ACTIVE       0x10000000      /* active */
  54 #define D64_XS0_XS_IDLE         0x20000000      /* idle wait */
  55 #define D64_XS0_XS_STOPPED      0x30000000      /* stopped */
  56 #define D64_XS0_XS_SUSP         0x40000000      /* suspend pending */
  57
  58 #define D64_XS1_AD_MASK         0x00001fff      /* active descriptor */
  59 #define D64_XS1_XE_MASK         0xf0000000      /* transmit errors */
  60 #define D64_XS1_XE_SHIFT                28
  61 #define D64_XS1_XE_NOERR        0x00000000      /* no error */
  62 #define D64_XS1_XE_DPE          0x10000000      /* descriptor protocol error */
  63 #define D64_XS1_XE_DFU          0x20000000      /* data fifo underrun */
  64 #define D64_XS1_XE_DTE          0x30000000      /* data transfer error */
  65 #define D64_XS1_XE_DESRE        0x40000000      /* descriptor read error */
  66 #define D64_XS1_XE_COREE        0x50000000      /* core error */
  67
  68 /* receive channel control */
  69 /* receive enable */
  70 #define D64_RC_RE               0x00000001
  71 /* receive frame offset */
  72 #define D64_RC_RO_MASK          0x000000fe
  73 #define D64_RC_RO_SHIFT         1
  74 /* direct fifo receive (pio) mode */
  75 #define D64_RC_FM               0x00000100
  76 /* separate rx header descriptor enable */
  77 #define D64_RC_SH               0x00000200
  78 /* overflow continue */
  79 #define D64_RC_OC               0x00000400
  80 /* parity check disable */
  81 #define D64_RC_PD               0x00000800
  82 /* address extension bits */
  83 #define D64_RC_AE               0x00030000
  84 #define D64_RC_AE_SHIFT         16
  85
  86 /* flags for dma controller */
  87 /* partity enable */
  88 #define DMA_CTRL_PEN            (1 << 0)
  89 /* rx overflow continue */
  90 #define DMA_CTRL_ROC            (1 << 1)
  91 /* allow rx scatter to multiple descriptors */
  92 #define DMA_CTRL_RXMULTI        (1 << 2)
  93 /* Unframed Rx/Tx data */
  94 #define DMA_CTRL_UNFRAMED       (1 << 3)
  95
  96 /* receive descriptor table pointer */
  97 #define D64_RP_LD_MASK          0x00000fff      /* last valid descriptor */
  98
  99 /* receive channel status */
 100 #define D64_RS0_CD_MASK         0x00001fff      /* current descriptor pointer */
 101 #define D64_RS0_RS_MASK         0xf0000000      /* receive state */
 102 #define D64_RS0_RS_SHIFT                28
 103 #define D64_RS0_RS_DISABLED     0x00000000      /* disabled */
 104 #define D64_RS0_RS_ACTIVE       0x10000000      /* active */
 105 #define D64_RS0_RS_IDLE         0x20000000      /* idle wait */
 106 #define D64_RS0_RS_STOPPED      0x30000000      /* stopped */
 107 #define D64_RS0_RS_SUSP         0x40000000      /* suspend pending */
 108
 109 #define D64_RS1_AD_MASK         0x0001ffff      /* active descriptor */
 110 #define D64_RS1_RE_MASK         0xf0000000      /* receive errors */
 111 #define D64_RS1_RE_SHIFT                28
 112 #define D64_RS1_RE_NOERR        0x00000000      /* no error */
 113 #define D64_RS1_RE_DPO          0x10000000      /* descriptor protocol error */
 114 #define D64_RS1_RE_DFU          0x20000000      /* data fifo overflow */
 115 #define D64_RS1_RE_DTE          0x30000000      /* data transfer error */
 116 #define D64_RS1_RE_DESRE        0x40000000      /* descriptor read error */
 117 #define D64_RS1_RE_COREE        0x50000000      /* core error */
 118
 119 /* fifoaddr */
 120 #define D64_FA_OFF_MASK         0xffff  /* offset */
 121 #define D64_FA_SEL_MASK         0xf0000 /* select */
 122 #define D64_FA_SEL_SHIFT        16
 123 #define D64_FA_SEL_XDD          0x00000 /* transmit dma data */
 124 #define D64_FA_SEL_XDP          0x10000 /* transmit dma pointers */
 125 #define D64_FA_SEL_RDD          0x40000 /* receive dma data */
 126 #define D64_FA_SEL_RDP          0x50000 /* receive dma pointers */
 127 #define D64_FA_SEL_XFD          0x80000 /* transmit fifo data */
 128 #define D64_FA_SEL_XFP          0x90000 /* transmit fifo pointers */
 129 #define D64_FA_SEL_RFD          0xc0000 /* receive fifo data */
 130 #define D64_FA_SEL_RFP          0xd0000 /* receive fifo pointers */
 131 #define D64_FA_SEL_RSD          0xe0000 /* receive frame status data */
 132 #define D64_FA_SEL_RSP          0xf0000 /* receive frame status pointers */
 133
 134 /* descriptor control flags 1 */
 135 #define D64_CTRL_COREFLAGS      0x0ff00000      /* core specific flags */
 136 #define D64_CTRL1_EOT           ((u32)1 << 28)  /* end of descriptor table */
 137 #define D64_CTRL1_IOC           ((u32)1 << 29)  /* interrupt on completion */
 138 #define D64_CTRL1_EOF           ((u32)1 << 30)  /* end of frame */
 139 #define D64_CTRL1_SOF           ((u32)1 << 31)  /* start of frame */
 140
 141 /* descriptor control flags 2 */
 142 /* buffer byte count. real data len must <= 16KB */
 143 #define D64_CTRL2_BC_MASK       0x00007fff
 144 /* address extension bits */
 145 #define D64_CTRL2_AE            0x00030000
 146 #define D64_CTRL2_AE_SHIFT      16
 147 /* parity bit */
 148 #define D64_CTRL2_PARITY        0x00040000
 149
 150 /* control flags in the range [27:20] are core-specific and not defined here */
 151 #define D64_CTRL_CORE_MASK      0x0ff00000
 152
 153 #define D64_RX_FRM_STS_LEN      0x0000ffff      /* frame length mask */
 154 #define D64_RX_FRM_STS_OVFL     0x00800000      /* RxOverFlow */
 155 #define D64_RX_FRM_STS_DSCRCNT  0x0f000000  /* no. of descriptors used - 1 */
 156 #define D64_RX_FRM_STS_DATATYPE 0xf0000000      /* core-dependent data type */
 157
 158 /*
 159  * packet headroom necessary to accommodate the largest header
 160  * in the system, (i.e TXOFF). By doing, we avoid the need to
 161  * allocate an extra buffer for the header when bridging to WL.
 162  * There is a compile time check in wlc.c which ensure that this
 163  * value is at least as big as TXOFF. This value is used in
 164  * dma_rxfill().
 165  */
 166
 167 #define BCMEXTRAHDROOM 172
 168
 169 /* debug/trace */
 170 #ifdef BCMDBG
 171 #define DMA_ERROR(args) \
 172         do { \
 173                 if (!(*di->msg_level & 1)) \
 174                         ; \
 175                 else \
 176                         printk args; \
 177         } while (0)
 178 #define DMA_TRACE(args) \
 179         do { \
 180                 if (!(*di->msg_level & 2)) \
 181                         ; \
 182                 else \
 183                         printk args; \
 184         } while (0)
 185 #else
 186 #define DMA_ERROR(args)
 187 #define DMA_TRACE(args)
 188 #endif                          /* BCMDBG */
 189
 190 #define DMA_NONE(args)
 191
 192 #define MAXNAMEL        8       /* 8 char names */
 193
 194 /* macros to convert between byte offsets and indexes */
 195 #define B2I(bytes, type)        ((bytes) / sizeof(type))
 196 #define I2B(index, type)        ((index) * sizeof(type))
 197
 198 #define PCI32ADDR_HIGH          0xc0000000      /* address[31:30] */
 199 #define PCI32ADDR_HIGH_SHIFT    30      /* address[31:30] */
 200
 201 #define PCI64ADDR_HIGH          0x80000000      /* address[63] */
 202 #define PCI64ADDR_HIGH_SHIFT    31      /* address[63] */
 203
 204 /*
 205  * DMA Descriptor
 206  * Descriptors are only read by the hardware, never written back.
 207  */
 208 struct dma64desc {
 209         __le32 ctrl1;   /* misc control bits & bufcount */
 210         __le32 ctrl2;   /* buffer count and address extension */
 211         __le32 addrlow; /* memory address of the date buffer, bits 31:0 */
 212         __le32 addrhigh; /* memory address of the date buffer, bits 63:32 */
 213 };
 214
 215 /* dma engine software state */
 216 struct dma_info {
 217         struct dma_pub dma; /* exported structure */
 218         uint *msg_level;        /* message level pointer */
 219         char name[MAXNAMEL];    /* callers name for diag msgs */
 220
 221         struct pci_dev *pbus;           /* bus handle */
 222
 223         bool dma64;     /* this dma engine is operating in 64-bit mode */
 224         bool addrext;   /* this dma engine supports DmaExtendedAddrChanges */
 225
 226         /* 64-bit dma tx engine registers */
 227         struct dma64regs __iomem *d64txregs;
 228         /* 64-bit dma rx engine registers */
 229         struct dma64regs __iomem *d64rxregs;
 230         /* pointer to dma64 tx descriptor ring */
 231         struct dma64desc *txd64;
 232         /* pointer to dma64 rx descriptor ring */
 233         struct dma64desc *rxd64;
 234
 235         u16 dmadesc_align;      /* alignment requirement for dma descriptors */
 236
 237         u16 ntxd;               /* # tx descriptors tunable */
 238         u16 txin;               /* index of next descriptor to reclaim */
 239         u16 txout;              /* index of next descriptor to post */
 240         /* pointer to parallel array of pointers to packets */
 241         struct sk_buff **txp;
 242         /* Aligned physical address of descriptor ring */
 243         dma_addr_t txdpa;
 244         /* Original physical address of descriptor ring */
 245         dma_addr_t txdpaorig;
 246         u16 txdalign;   /* #bytes added to alloc'd mem to align txd */
 247         u32 txdalloc;   /* #bytes allocated for the ring */
 248         u32 xmtptrbase; /* When using unaligned descriptors, the ptr register
 249                          * is not just an index, it needs all 13 bits to be
 250                          * an offset from the addr register.
 251                          */
 252
 253         u16 nrxd;       /* # rx descriptors tunable */
 254         u16 rxin;       /* index of next descriptor to reclaim */
 255         u16 rxout;      /* index of next descriptor to post */
 256         /* pointer to parallel array of pointers to packets */
 257         struct sk_buff **rxp;
 258         /* Aligned physical address of descriptor ring */
 259         dma_addr_t rxdpa;
 260         /* Original physical address of descriptor ring */
 261         dma_addr_t rxdpaorig;
 262         u16 rxdalign;   /* #bytes added to alloc'd mem to align rxd */
 263         u32 rxdalloc;   /* #bytes allocated for the ring */
 264         u32 rcvptrbase; /* Base for ptr reg when using unaligned descriptors */
 265
 266         /* tunables */
 267         unsigned int rxbufsize; /* rx buffer size in bytes, not including
 268                                  * the extra headroom
 269                                  */
 270         uint rxextrahdrroom;    /* extra rx headroom, reverseved to assist upper
 271                                  * stack, e.g. some rx pkt buffers will be
 272                                  * bridged to tx side without byte copying.
 273                                  * The extra headroom needs to be large enough
 274                                  * to fit txheader needs. Some dongle driver may
 275                                  * not need it.
 276                                  */
 277         uint nrxpost;           /* # rx buffers to keep posted */
 278         unsigned int rxoffset;  /* rxcontrol offset */
 279         /* add to get dma address of descriptor ring, low 32 bits */
 280         uint ddoffsetlow;
 281         /*   high 32 bits */
 282         uint ddoffsethigh;
 283         /* add to get dma address of data buffer, low 32 bits */
 284         uint dataoffsetlow;
 285         /*   high 32 bits */
 286         uint dataoffsethigh;
 287         /* descriptor base need to be aligned or not */
 288         bool aligndesc_4k;
 289 };
 290
 291 /*
 292  * default dma message level (if input msg_level
 293  * pointer is null in dma_attach())
 294  */
 295 static uint dma_msg_level;
 296
 297 /* Check for odd number of 1's */
 298 static u32 parity32(__le32 data)
 299 {
 300         /* no swap needed for counting 1's */
 301         u32 par_data = *(u32 *)&data;
 302
 303         par_data ^= par_data >> 16;
 304         par_data ^= par_data >> 8;
 305         par_data ^= par_data >> 4;
 306         par_data ^= par_data >> 2;
 307         par_data ^= par_data >> 1;
 308
 309         return par_data & 1;
 310 }
 311
 312 static bool dma64_dd_parity(struct dma64desc *dd)
 313 {
 314         return parity32(dd->addrlow ^ dd->addrhigh ^ dd->ctrl1 ^ dd->ctrl2);
 315 }
 316
 317 /* descriptor bumping functions */
 318
 319 static uint xxd(uint x, uint n)
 320 {
 321         return x & (n - 1); /* faster than %, but n must be power of 2 */
 322 }
 323
 324 static uint txd(struct dma_info *di, uint x)
 325 {
 326         return xxd(x, di->ntxd);
 327 }
 328
 329 static uint rxd(struct dma_info *di, uint x)
 330 {
 331         return xxd(x, di->nrxd);
 332 }
 333
 334 static uint nexttxd(struct dma_info *di, uint i)
 335 {
 336         return txd(di, i + 1);
 337 }
 338
 339 static uint prevtxd(struct dma_info *di, uint i)
 340 {
 341         return txd(di, i - 1);
 342 }
 343
 344 static uint nextrxd(struct dma_info *di, uint i)
 345 {
 346         return txd(di, i + 1);
 347 }
 348
 349 static uint ntxdactive(struct dma_info *di, uint h, uint t)
 350 {
 351         return txd(di, t-h);
 352 }
 353
 354 static uint nrxdactive(struct dma_info *di, uint h, uint t)
 355 {
 356         return rxd(di, t-h);
 357 }
 358
 359 static uint _dma_ctrlflags(struct dma_info *di, uint mask, uint flags)
 360 {
 361         uint dmactrlflags;
 362
 363         if (di == NULL) {
 364                 DMA_ERROR(("_dma_ctrlflags: NULL dma handle\n"));
 365                 return 0;
 366         }
 367
 368         dmactrlflags = di->dma.dmactrlflags;
 369         dmactrlflags &= ~mask;
 370         dmactrlflags |= flags;
 371
 372         /* If trying to enable parity, check if parity is actually supported */
 373         if (dmactrlflags & DMA_CTRL_PEN) {
 374                 u32 control;
 375
 376                 control = R_REG(&di->d64txregs->control);
 377                 W_REG(&di->d64txregs->control,
 378                       control | D64_XC_PD);
 379                 if (R_REG(&di->d64txregs->control) & D64_XC_PD)
 380                         /* We *can* disable it so it is supported,
 381                          * restore control register
 382                          */
 383                         W_REG(&di->d64txregs->control,
 384                         control);
 385                 else
 386                         /* Not supported, don't allow it to be enabled */
 387                         dmactrlflags &= ~DMA_CTRL_PEN;
 388         }
 389
 390         di->dma.dmactrlflags = dmactrlflags;
 391
 392         return dmactrlflags;
 393 }
 394
 395 static bool _dma64_addrext(struct dma64regs __iomem *dma64regs)
 396 {
 397         u32 w;
 398         OR_REG(&dma64regs->control, D64_XC_AE);
 399         w = R_REG(&dma64regs->control);
 400         AND_REG(&dma64regs->control, ~D64_XC_AE);
 401         return (w & D64_XC_AE) == D64_XC_AE;
 402 }
 403
 404 /*
 405  * return true if this dma engine supports DmaExtendedAddrChanges,
 406  * otherwise false
 407  */
 408 static bool _dma_isaddrext(struct dma_info *di)
 409 {
 410         /* DMA64 supports full 32- or 64-bit operation. AE is always valid */
 411
 412         /* not all tx or rx channel are available */
 413         if (di->d64txregs != NULL) {
 414                 if (!_dma64_addrext(di->d64txregs))
 415                         DMA_ERROR(("%s: _dma_isaddrext: DMA64 tx doesn't have "
 416                                    "AE set\n", di->name));
 417                 return true;
 418         } else if (di->d64rxregs != NULL) {
 419                 if (!_dma64_addrext(di->d64rxregs))
 420                         DMA_ERROR(("%s: _dma_isaddrext: DMA64 rx doesn't have "
 421                                    "AE set\n", di->name));
 422                 return true;
 423         }
 424
 425         return false;
 426 }
 427
 428 static bool _dma_descriptor_align(struct dma_info *di)
 429 {
 430         u32 addrl;
 431
 432         /* Check to see if the descriptors need to be aligned on 4K/8K or not */
 433         if (di->d64txregs != NULL) {
 434                 W_REG(&di->d64txregs->addrlow, 0xff0);
 435                 addrl = R_REG(&di->d64txregs->addrlow);
 436                 if (addrl != 0)
 437                         return false;
 438         } else if (di->d64rxregs != NULL) {
 439                 W_REG(&di->d64rxregs->addrlow, 0xff0);
 440                 addrl = R_REG(&di->d64rxregs->addrlow);
 441                 if (addrl != 0)
 442                         return false;
 443         }
 444         return true;
 445 }
 446
 447 /*
 448  * Descriptor table must start at the DMA hardware dictated alignment, so
 449  * allocated memory must be large enough to support this requirement.
 450  */
 451 static void *dma_alloc_consistent(struct pci_dev *pdev, uint size,
 452                                   u16 align_bits, uint *alloced,
 453                                   dma_addr_t *pap)
 454 {
 455         if (align_bits) {
 456                 u16 align = (1 << align_bits);
 457                 if (!IS_ALIGNED(PAGE_SIZE, align))
 458                         size += align;
 459                 *alloced = size;
 460         }
 461         return pci_alloc_consistent(pdev, size, pap);
 462 }
 463
 464 static
 465 u8 dma_align_sizetobits(uint size)
 466 {
 467         u8 bitpos = 0;
 468         while (size >>= 1)
 469                 bitpos++;
 470         return bitpos;
 471 }
 472
 473 /* This function ensures that the DMA descriptor ring will not get allocated
 474  * across Page boundary. If the allocation is done across the page boundary
 475  * at the first time, then it is freed and the allocation is done at
 476  * descriptor ring size aligned location. This will ensure that the ring will
 477  * not cross page boundary
 478  */
 479 static void *dma_ringalloc(struct dma_info *di, u32 boundary, uint size,
 480                            u16 *alignbits, uint *alloced,
 481                            dma_addr_t *descpa)
 482 {
 483         void *va;
 484         u32 desc_strtaddr;
 485         u32 alignbytes = 1 << *alignbits;
 486
 487         va = dma_alloc_consistent(di->pbus, size, *alignbits, alloced, descpa);
 488
 489         if (NULL == va)
 490                 return NULL;
 491
 492         desc_strtaddr = (u32) roundup((unsigned long)va, alignbytes);
 493         if (((desc_strtaddr + size - 1) & boundary) != (desc_strtaddr
 494                                                         & boundary)) {
 495                 *alignbits = dma_align_sizetobits(size);
 496                 pci_free_consistent(di->pbus, size, va, *descpa);
 497                 va = dma_alloc_consistent(di->pbus, size, *alignbits,
 498                         alloced, descpa);
 499         }
 500         return va;
 501 }
 502
 503 static bool dma64_alloc(struct dma_info *di, uint direction)
 504 {
 505         u16 size;
 506         uint ddlen;
 507         void *va;
 508         uint alloced = 0;
 509         u16 align;
 510         u16 align_bits;
 511
 512         ddlen = sizeof(struct dma64desc);
 513
 514         size = (direction == DMA_TX) ? (di->ntxd * ddlen) : (di->nrxd * ddlen);
 515         align_bits = di->dmadesc_align;
 516         align = (1 << align_bits);
 517
 518         if (direction == DMA_TX) {
 519                 va = dma_ringalloc(di, D64RINGALIGN, size, &align_bits,
 520                         &alloced, &di->txdpaorig);
 521                 if (va == NULL) {
 522                         DMA_ERROR(("%s: dma64_alloc: DMA_ALLOC_CONSISTENT(ntxd)"
 523                                    " failed\n", di->name));
 524                         return false;
 525                 }
 526                 align = (1 << align_bits);
 527                 di->txd64 = (struct dma64desc *)
 528                                         roundup((unsigned long)va, align);
 529                 di->txdalign = (uint) ((s8 *)di->txd64 - (s8 *) va);
 530                 di->txdpa = di->txdpaorig + di->txdalign;
 531                 di->txdalloc = alloced;
 532         } else {
 533                 va = dma_ringalloc(di, D64RINGALIGN, size, &align_bits,
 534                         &alloced, &di->rxdpaorig);
 535                 if (va == NULL) {
 536                         DMA_ERROR(("%s: dma64_alloc: DMA_ALLOC_CONSISTENT(nrxd)"
 537                                    " failed\n", di->name));
 538                         return false;
 539                 }
 540                 align = (1 << align_bits);
 541                 di->rxd64 = (struct dma64desc *)
 542                                         roundup((unsigned long)va, align);
 543                 di->rxdalign = (uint) ((s8 *)di->rxd64 - (s8 *) va);
 544                 di->rxdpa = di->rxdpaorig + di->rxdalign;
 545                 di->rxdalloc = alloced;
 546         }
 547
 548         return true;
 549 }
 550
 551 static bool _dma_alloc(struct dma_info *di, uint direction)
 552 {
 553         return dma64_alloc(di, direction);
 554 }
 555
 556 struct dma_pub *dma_attach(char *name, struct si_pub *sih,
 557                      void __iomem *dmaregstx, void __iomem *dmaregsrx,
 558                      uint ntxd, uint nrxd,
 559                      uint rxbufsize, int rxextheadroom,
 560                      uint nrxpost, uint rxoffset, uint *msg_level)
 561 {
 562         struct dma_info *di;
 563         uint size;
 564
 565         /* allocate private info structure */
 566         di = kzalloc(sizeof(struct dma_info), GFP_ATOMIC);
 567         if (di == NULL)
 568                 return NULL;
 569
 570         di->msg_level = msg_level ? msg_level : &dma_msg_level;
 571
 572
 573         di->dma64 = ((ai_core_sflags(sih, 0, 0) & SISF_DMA64) == SISF_DMA64);
 574
 575         /* init dma reg pointer */
 576         di->d64txregs = (struct dma64regs __iomem *) dmaregstx;
 577         di->d64rxregs = (struct dma64regs __iomem *) dmaregsrx;
 578
 579         /*
 580          * Default flags (which can be changed by the driver calling
 581          * dma_ctrlflags before enable): For backwards compatibility
 582          * both Rx Overflow Continue and Parity are DISABLED.
 583          */
 584         _dma_ctrlflags(di, DMA_CTRL_ROC | DMA_CTRL_PEN, 0);
 585
 586         DMA_TRACE(("%s: dma_attach: %s flags 0x%x ntxd %d nrxd %d "
 587                    "rxbufsize %d rxextheadroom %d nrxpost %d rxoffset %d "
 588                    "dmaregstx %p dmaregsrx %p\n", name, "DMA64",
 589                    di->dma.dmactrlflags, ntxd, nrxd, rxbufsize,
 590                    rxextheadroom, nrxpost, rxoffset, dmaregstx, dmaregsrx));
 591
 592         /* make a private copy of our callers name */
 593         strncpy(di->name, name, MAXNAMEL);
 594         di->name[MAXNAMEL - 1] = '\0';
 595
 596         di->pbus = ((struct si_info *)sih)->pbus;
 597
 598         /* save tunables */
 599         di->ntxd = (u16) ntxd;
 600         di->nrxd = (u16) nrxd;
 601
 602         /* the actual dma size doesn't include the extra headroom */
 603         di->rxextrahdrroom =
 604             (rxextheadroom == -1) ? BCMEXTRAHDROOM : rxextheadroom;
 605         if (rxbufsize > BCMEXTRAHDROOM)
 606                 di->rxbufsize = (u16) (rxbufsize - di->rxextrahdrroom);
 607         else
 608                 di->rxbufsize = (u16) rxbufsize;
 609
 610         di->nrxpost = (u16) nrxpost;
 611         di->rxoffset = (u8) rxoffset;
 612
 613         /*
 614          * figure out the DMA physical address offset for dd and data
 615          *     PCI/PCIE: they map silicon backplace address to zero
 616          *     based memory, need offset
 617          *     Other bus: use zero SI_BUS BIGENDIAN kludge: use sdram
 618          *     swapped region for data buffer, not descriptor
 619          */
 620         di->ddoffsetlow = 0;
 621         di->dataoffsetlow = 0;
 622         /* add offset for pcie with DMA64 bus */
 623         di->ddoffsetlow = 0;
 624         di->ddoffsethigh = SI_PCIE_DMA_H32;
 625         di->dataoffsetlow = di->ddoffsetlow;
 626         di->dataoffsethigh = di->ddoffsethigh;
 627         /* WAR64450 : DMACtl.Addr ext fields are not supported in SDIOD core. */
 628         if ((ai_coreid(sih) == SDIOD_CORE_ID)
 629             && ((ai_corerev(sih) > 0) && (ai_corerev(sih) <= 2)))
 630                 di->addrext = 0;
 631         else if ((ai_coreid(sih) == I2S_CORE_ID) &&
 632                  ((ai_corerev(sih) == 0) || (ai_corerev(sih) == 1)))
 633                 di->addrext = 0;
 634         else
 635                 di->addrext = _dma_isaddrext(di);
 636
 637         /* does the descriptor need to be aligned and if yes, on 4K/8K or not */
 638         di->aligndesc_4k = _dma_descriptor_align(di);
 639         if (di->aligndesc_4k) {
 640                 di->dmadesc_align = D64RINGALIGN_BITS;
 641                 if ((ntxd < D64MAXDD / 2) && (nrxd < D64MAXDD / 2))
 642                         /* for smaller dd table, HW relax alignment reqmnt */
 643                         di->dmadesc_align = D64RINGALIGN_BITS - 1;
 644         } else {
 645                 di->dmadesc_align = 4;  /* 16 byte alignment */
 646         }
 647
 648         DMA_NONE(("DMA descriptor align_needed %d, align %d\n",
 649                   di->aligndesc_4k, di->dmadesc_align));
 650
 651         /* allocate tx packet pointer vector */
 652         if (ntxd) {
 653                 size = ntxd * sizeof(void *);
 654                 di->txp = kzalloc(size, GFP_ATOMIC);
 655                 if (di->txp == NULL)
 656                         goto fail;
 657         }
 658
 659         /* allocate rx packet pointer vector */
 660         if (nrxd) {
 661                 size = nrxd * sizeof(void *);
 662                 di->rxp = kzalloc(size, GFP_ATOMIC);
 663                 if (di->rxp == NULL)
 664                         goto fail;
 665         }
 666
 667         /*
 668          * allocate transmit descriptor ring, only need ntxd descriptors
 669          * but it must be aligned
 670          */
 671         if (ntxd) {
 672                 if (!_dma_alloc(di, DMA_TX))
 673                         goto fail;
 674         }
 675
 676         /*
 677          * allocate receive descriptor ring, only need nrxd descriptors
 678          * but it must be aligned
 679          */
 680         if (nrxd) {
 681                 if (!_dma_alloc(di, DMA_RX))
 682                         goto fail;
 683         }
 684
 685         if ((di->ddoffsetlow != 0) && !di->addrext) {
 686                 if (di->txdpa > SI_PCI_DMA_SZ) {
 687                         DMA_ERROR(("%s: dma_attach: txdpa 0x%x: addrext not "
 688                                    "supported\n", di->name, (u32)di->txdpa));
 689                         goto fail;
 690                 }
 691                 if (di->rxdpa > SI_PCI_DMA_SZ) {
 692                         DMA_ERROR(("%s: dma_attach: rxdpa 0x%x: addrext not "
 693                                    "supported\n", di->name, (u32)di->rxdpa));
 694                         goto fail;
 695                 }
 696         }
 697
 698         DMA_TRACE(("ddoffsetlow 0x%x ddoffsethigh 0x%x dataoffsetlow 0x%x "
 699                    "dataoffsethigh " "0x%x addrext %d\n", di->ddoffsetlow,
 700                    di->ddoffsethigh, di->dataoffsetlow, di->dataoffsethigh,
 701                    di->addrext));
 702
 703         return (struct dma_pub *) di;
 704
 705  fail:
 706         dma_detach((struct dma_pub *)di);
 707         return NULL;
 708 }
 709
 710 static inline void
 711 dma64_dd_upd(struct dma_info *di, struct dma64desc *ddring,
 712              dma_addr_t pa, uint outidx, u32 *flags, u32 bufcount)
 713 {
 714         u32 ctrl2 = bufcount & D64_CTRL2_BC_MASK;
 715
 716         /* PCI bus with big(>1G) physical address, use address extension */
 717         if ((di->dataoffsetlow == 0) || !(pa & PCI32ADDR_HIGH)) {
 718                 ddring[outidx].addrlow = cpu_to_le32(pa + di->dataoffsetlow);
 719                 ddring[outidx].addrhigh = cpu_to_le32(di->dataoffsethigh);
 720                 ddring[outidx].ctrl1 = cpu_to_le32(*flags);
 721                 ddring[outidx].ctrl2 = cpu_to_le32(ctrl2);
 722         } else {
 723                 /* address extension for 32-bit PCI */
 724                 u32 ae;
 725
 726                 ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
 727                 pa &= ~PCI32ADDR_HIGH;
 728
 729                 ctrl2 |= (ae << D64_CTRL2_AE_SHIFT) & D64_CTRL2_AE;
 730                 ddring[outidx].addrlow = cpu_to_le32(pa + di->dataoffsetlow);
 731                 ddring[outidx].addrhigh = cpu_to_le32(di->dataoffsethigh);
 732                 ddring[outidx].ctrl1 = cpu_to_le32(*flags);
 733                 ddring[outidx].ctrl2 = cpu_to_le32(ctrl2);
 734         }
 735         if (di->dma.dmactrlflags & DMA_CTRL_PEN) {
 736                 if (dma64_dd_parity(&ddring[outidx]))
 737                         ddring[outidx].ctrl2 =
 738                              cpu_to_le32(ctrl2 | D64_CTRL2_PARITY);
 739         }
 740 }
 741
 742 /* !! may be called with core in reset */
 743 void dma_detach(struct dma_pub *pub)
 744 {
 745         struct dma_info *di = (struct dma_info *)pub;
 746
 747         DMA_TRACE(("%s: dma_detach\n", di->name));
 748
 749         /* free dma descriptor rings */
 750         if (di->txd64)
 751                 pci_free_consistent(di->pbus, di->txdalloc,
 752                                     ((s8 *)di->txd64 - di->txdalign),
 753                                     (di->txdpaorig));
 754         if (di->rxd64)
 755                 pci_free_consistent(di->pbus, di->rxdalloc,
 756                                     ((s8 *)di->rxd64 - di->rxdalign),
 757                                     (di->rxdpaorig));
 758
 759         /* free packet pointer vectors */
 760         kfree(di->txp);
 761         kfree(di->rxp);
 762
 763         /* free our private info structure */
 764         kfree(di);
 765
 766 }
 767
 768 /* initialize descriptor table base address */
 769 static void
 770 _dma_ddtable_init(struct dma_info *di, uint direction, dma_addr_t pa)
 771 {
 772         if (!di->aligndesc_4k) {
 773                 if (direction == DMA_TX)
 774                         di->xmtptrbase = pa;
 775                 else
 776                         di->rcvptrbase = pa;
 777         }
 778
 779         if ((di->ddoffsetlow == 0)
 780             || !(pa & PCI32ADDR_HIGH)) {
 781                 if (direction == DMA_TX) {
 782                         W_REG(&di->d64txregs->addrlow, pa + di->ddoffsetlow);
 783                         W_REG(&di->d64txregs->addrhigh, di->ddoffsethigh);
 784                 } else {
 785                         W_REG(&di->d64rxregs->addrlow, pa + di->ddoffsetlow);
 786                         W_REG(&di->d64rxregs->addrhigh, di->ddoffsethigh);
 787                 }
 788         } else {
 789                 /* DMA64 32bits address extension */
 790                 u32 ae;
 791
 792                 /* shift the high bit(s) from pa to ae */
 793                 ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
 794                 pa &= ~PCI32ADDR_HIGH;
 795
 796                 if (direction == DMA_TX) {
 797                         W_REG(&di->d64txregs->addrlow, pa + di->ddoffsetlow);
 798                         W_REG(&di->d64txregs->addrhigh, di->ddoffsethigh);
 799                         SET_REG(&di->d64txregs->control,
 800                                 D64_XC_AE, (ae << D64_XC_AE_SHIFT));
 801                 } else {
 802                         W_REG(&di->d64rxregs->addrlow, pa + di->ddoffsetlow);
 803                         W_REG(&di->d64rxregs->addrhigh, di->ddoffsethigh);
 804                         SET_REG(&di->d64rxregs->control,
 805                                 D64_RC_AE, (ae << D64_RC_AE_SHIFT));
 806                 }
 807         }
 808 }
 809
 810 static void _dma_rxenable(struct dma_info *di)
 811 {
 812         uint dmactrlflags = di->dma.dmactrlflags;
 813         u32 control;
 814
 815         DMA_TRACE(("%s: dma_rxenable\n", di->name));
 816
 817         control =
 818             (R_REG(&di->d64rxregs->control) & D64_RC_AE) |
 819             D64_RC_RE;
 820
 821         if ((dmactrlflags & DMA_CTRL_PEN) == 0)
 822                 control |= D64_RC_PD;
 823
 824         if (dmactrlflags & DMA_CTRL_ROC)
 825                 control |= D64_RC_OC;
 826
 827         W_REG(&di->d64rxregs->control,
 828                 ((di->rxoffset << D64_RC_RO_SHIFT) | control));
 829 }
 830
 831 void dma_rxinit(struct dma_pub *pub)
 832 {
 833         struct dma_info *di = (struct dma_info *)pub;
 834
 835         DMA_TRACE(("%s: dma_rxinit\n", di->name));
 836
 837         if (di->nrxd == 0)
 838                 return;
 839
 840         di->rxin = di->rxout = 0;
 841
 842         /* clear rx descriptor ring */
 843         memset(di->rxd64, '\0', di->nrxd * sizeof(struct dma64desc));
 844
 845         /* DMA engine with out alignment requirement requires table to be inited
 846          * before enabling the engine
 847          */
 848         if (!di->aligndesc_4k)
 849                 _dma_ddtable_init(di, DMA_RX, di->rxdpa);
 850
 851         _dma_rxenable(di);
 852
 853         if (di->aligndesc_4k)
 854                 _dma_ddtable_init(di, DMA_RX, di->rxdpa);
 855 }
 856
 857 static struct sk_buff *dma64_getnextrxp(struct dma_info *di, bool forceall)
 858 {
 859         uint i, curr;
 860         struct sk_buff *rxp;
 861         dma_addr_t pa;
 862
 863         i = di->rxin;
 864
 865         /* return if no packets posted */
 866         if (i == di->rxout)
 867                 return NULL;
 868
 869         curr =
 870             B2I(((R_REG(&di->d64rxregs->status0) & D64_RS0_CD_MASK) -
 871                  di->rcvptrbase) & D64_RS0_CD_MASK, struct dma64desc);
 872
 873         /* ignore curr if forceall */
 874         if (!forceall && (i == curr))
 875                 return NULL;
 876
 877         /* get the packet pointer that corresponds to the rx descriptor */
 878         rxp = di->rxp[i];
 879         di->rxp[i] = NULL;
 880
 881         pa = le32_to_cpu(di->rxd64[i].addrlow) - di->dataoffsetlow;
 882
 883         /* clear this packet from the descriptor ring */
 884         pci_unmap_single(di->pbus, pa, di->rxbufsize, PCI_DMA_FROMDEVICE);
 885
 886         di->rxd64[i].addrlow = cpu_to_le32(0xdeadbeef);
 887         di->rxd64[i].addrhigh = cpu_to_le32(0xdeadbeef);
 888
 889         di->rxin = nextrxd(di, i);
 890
 891         return rxp;
 892 }
 893
 894 static struct sk_buff *_dma_getnextrxp(struct dma_info *di, bool forceall)
 895 {
 896         if (di->nrxd == 0)
 897                 return NULL;
 898
 899         return dma64_getnextrxp(di, forceall);
 900 }
 901
 902 /*
 903  * !! rx entry routine
 904  * returns a pointer to the next frame received, or NULL if there are no more
 905  *   if DMA_CTRL_RXMULTI is defined, DMA scattering(multiple buffers) is
 906  *   supported with pkts chain
 907  *   otherwise, it's treated as giant pkt and will be tossed.
 908  *   The DMA scattering starts with normal DMA header, followed by first
 909  *   buffer data. After it reaches the max size of buffer, the data continues
 910  *   in next DMA descriptor buffer WITHOUT DMA header
 911  */
 912 struct sk_buff *dma_rx(struct dma_pub *pub)
 913 {
 914         struct dma_info *di = (struct dma_info *)pub;
 915         struct sk_buff *p, *head, *tail;
 916         uint len;
 917         uint pkt_len;
 918         int resid = 0;
 919
 920  next_frame:
 921         head = _dma_getnextrxp(di, false);
 922         if (head == NULL)
 923                 return NULL;
 924
 925         len = le16_to_cpu(*(__le16 *) (head->data));
 926         DMA_TRACE(("%s: dma_rx len %d\n", di->name, len));
 927         dma_spin_for_len(len, head);
 928
 929         /* set actual length */
 930         pkt_len = min((di->rxoffset + len), di->rxbufsize);
 931         __skb_trim(head, pkt_len);
 932         resid = len - (di->rxbufsize - di->rxoffset);
 933
 934         /* check for single or multi-buffer rx */
 935         if (resid > 0) {
 936                 tail = head;
 937                 while ((resid > 0) && (p = _dma_getnextrxp(di, false))) {
 938                         tail->next = p;
 939                         pkt_len = min_t(uint, resid, di->rxbufsize);
 940                         __skb_trim(p, pkt_len);
 941
 942                         tail = p;
 943                         resid -= di->rxbufsize;
 944                 }
 945
 946 #ifdef BCMDBG
 947                 if (resid > 0) {
 948                         uint cur;
 949                         cur =
 950                             B2I(((R_REG(&di->d64rxregs->status0) &
 951                                   D64_RS0_CD_MASK) -
 952                                  di->rcvptrbase) & D64_RS0_CD_MASK,
 953                                 struct dma64desc);
 954                         DMA_ERROR(("dma_rx, rxin %d rxout %d, hw_curr %d\n",
 955                                    di->rxin, di->rxout, cur));
 956                 }
 957 #endif                          /* BCMDBG */
 958
 959                 if ((di->dma.dmactrlflags & DMA_CTRL_RXMULTI) == 0) {
 960                         DMA_ERROR(("%s: dma_rx: bad frame length (%d)\n",
 961                                    di->name, len));
 962                         brcmu_pkt_buf_free_skb(head);
 963                         di->dma.rxgiants++;
 964                         goto next_frame;
 965                 }
 966         }
 967
 968         return head;
 969 }
 970
 971 static bool dma64_rxidle(struct dma_info *di)
 972 {
 973         DMA_TRACE(("%s: dma_rxidle\n", di->name));
 974
 975         if (di->nrxd == 0)
 976                 return true;
 977
 978         return ((R_REG(&di->d64rxregs->status0) & D64_RS0_CD_MASK) ==
 979                 (R_REG(&di->d64rxregs->ptr) & D64_RS0_CD_MASK));
 980 }
 981
 982 /*
 983  * post receive buffers
 984  *  return false is refill failed completely and ring is empty this will stall
 985  *  the rx dma and user might want to call rxfill again asap. This unlikely
 986  *  happens on memory-rich NIC, but often on memory-constrained dongle
 987  */
 988 bool dma_rxfill(struct dma_pub *pub)
 989 {
 990         struct dma_info *di = (struct dma_info *)pub;
 991         struct sk_buff *p;
 992         u16 rxin, rxout;
 993         u32 flags = 0;
 994         uint n;
 995         uint i;
 996         dma_addr_t pa;
 997         uint extra_offset = 0;
 998         bool ring_empty;
 999
1000         ring_empty = false;
1001
1002         /*
1003          * Determine how many receive buffers we're lacking
1004          * from the full complement, allocate, initialize,
1005          * and post them, then update the chip rx lastdscr.
1006          */
1007
1008         rxin = di->rxin;
1009         rxout = di->rxout;
1010
1011         n = di->nrxpost - nrxdactive(di, rxin, rxout);
1012
1013         DMA_TRACE(("%s: dma_rxfill: post %d\n", di->name, n));
1014
1015         if (di->rxbufsize > BCMEXTRAHDROOM)
1016                 extra_offset = di->rxextrahdrroom;
1017
1018         for (i = 0; i < n; i++) {
1019                 /*
1020                  * the di->rxbufsize doesn't include the extra headroom,
1021                  * we need to add it to the size to be allocated
1022                  */
1023                 p = brcmu_pkt_buf_get_skb(di->rxbufsize + extra_offset);
1024
1025                 if (p == NULL) {
1026                         DMA_ERROR(("%s: dma_rxfill: out of rxbufs\n",
1027                                    di->name));
1028                         if (i == 0 && dma64_rxidle(di)) {
1029                                 DMA_ERROR(("%s: rxfill64: ring is empty !\n",
1030                                            di->name));
1031                                 ring_empty = true;
1032                         }
1033                         di->dma.rxnobuf++;
1034                         break;
1035                 }
1036                 /* reserve an extra headroom, if applicable */
1037                 if (extra_offset)
1038                         skb_pull(p, extra_offset);
1039
1040                 /* Do a cached write instead of uncached write since DMA_MAP
1041                  * will flush the cache.
1042                  */
1043                 *(u32 *) (p->data) = 0;
1044
1045                 pa = pci_map_single(di->pbus, p->data,
1046                         di->rxbufsize, PCI_DMA_FROMDEVICE);
1047
1048                 /* save the free packet pointer */
1049                 di->rxp[rxout] = p;
1050
1051                 /* reset flags for each descriptor */
1052                 flags = 0;
1053                 if (rxout == (di->nrxd - 1))
1054                         flags = D64_CTRL1_EOT;
1055
1056                 dma64_dd_upd(di, di->rxd64, pa, rxout, &flags,
1057                              di->rxbufsize);
1058                 rxout = nextrxd(di, rxout);
1059         }
1060
1061         di->rxout = rxout;
1062
1063         /* update the chip lastdscr pointer */
1064         W_REG(&di->d64rxregs->ptr,
1065               di->rcvptrbase + I2B(rxout, struct dma64desc));
1066
1067         return ring_empty;
1068 }
1069
1070 void dma_rxreclaim(struct dma_pub *pub)
1071 {
1072         struct dma_info *di = (struct dma_info *)pub;
1073         struct sk_buff *p;
1074
1075         DMA_TRACE(("%s: dma_rxreclaim\n", di->name));
1076
1077         while ((p = _dma_getnextrxp(di, true)))
1078                 brcmu_pkt_buf_free_skb(p);
1079 }
1080
1081 void dma_counterreset(struct dma_pub *pub)
1082 {
1083         /* reset all software counters */
1084         pub->rxgiants = 0;
1085         pub->rxnobuf = 0;
1086         pub->txnobuf = 0;
1087 }
1088
1089 /* get the address of the var in order to change later */
1090 unsigned long dma_getvar(struct dma_pub *pub, const char *name)
1091 {
1092         struct dma_info *di = (struct dma_info *)pub;
1093
1094         if (!strcmp(name, "&txavail"))
1095                 return (unsigned long)&(di->dma.txavail);
1096         return 0;
1097 }
1098
1099 /* 64-bit DMA functions */
1100
1101 void dma_txinit(struct dma_pub *pub)
1102 {
1103         struct dma_info *di = (struct dma_info *)pub;
1104         u32 control = D64_XC_XE;
1105
1106         DMA_TRACE(("%s: dma_txinit\n", di->name));
1107
1108         if (di->ntxd == 0)
1109                 return;
1110
1111         di->txin = di->txout = 0;
1112         di->dma.txavail = di->ntxd - 1;
1113
1114         /* clear tx descriptor ring */
1115         memset(di->txd64, '\0', (di->ntxd * sizeof(struct dma64desc)));
1116
1117         /* DMA engine with out alignment requirement requires table to be inited
1118          * before enabling the engine
1119          */
1120         if (!di->aligndesc_4k)
1121                 _dma_ddtable_init(di, DMA_TX, di->txdpa);
1122
1123         if ((di->dma.dmactrlflags & DMA_CTRL_PEN) == 0)
1124                 control |= D64_XC_PD;
1125         OR_REG(&di->d64txregs->control, control);
1126
1127         /* DMA engine with alignment requirement requires table to be inited
1128          * before enabling the engine
1129          */
1130         if (di->aligndesc_4k)
1131                 _dma_ddtable_init(di, DMA_TX, di->txdpa);
1132 }
1133
1134 void dma_txsuspend(struct dma_pub *pub)
1135 {
1136         struct dma_info *di = (struct dma_info *)pub;
1137
1138         DMA_TRACE(("%s: dma_txsuspend\n", di->name));
1139
1140         if (di->ntxd == 0)
1141                 return;
1142
1143         OR_REG(&di->d64txregs->control, D64_XC_SE);
1144 }
1145
1146 void dma_txresume(struct dma_pub *pub)
1147 {
1148         struct dma_info *di = (struct dma_info *)pub;
1149
1150         DMA_TRACE(("%s: dma_txresume\n", di->name));
1151
1152         if (di->ntxd == 0)
1153                 return;
1154
1155         AND_REG(&di->d64txregs->control, ~D64_XC_SE);
1156 }
1157
1158 bool dma_txsuspended(struct dma_pub *pub)
1159 {
1160         struct dma_info *di = (struct dma_info *)pub;
1161
1162         return (di->ntxd == 0) ||
1163             ((R_REG(&di->d64txregs->control) & D64_XC_SE) ==
1164              D64_XC_SE);
1165 }
1166
1167 void dma_txreclaim(struct dma_pub *pub, enum txd_range range)
1168 {
1169         struct dma_info *di = (struct dma_info *)pub;
1170         struct sk_buff *p;
1171
1172         DMA_TRACE(("%s: dma_txreclaim %s\n", di->name,
1173                    (range == DMA_RANGE_ALL) ? "all" :
1174                    ((range ==
1175                      DMA_RANGE_TRANSMITTED) ? "transmitted" :
1176                     "transferred")));
1177
1178         if (di->txin == di->txout)
1179                 return;
1180
1181         while ((p = dma_getnexttxp(pub, range))) {
1182                 /* For unframed data, we don't have any packets to free */
1183                 if (!(di->dma.dmactrlflags & DMA_CTRL_UNFRAMED))
1184                         brcmu_pkt_buf_free_skb(p);
1185         }
1186 }
1187
1188 bool dma_txreset(struct dma_pub *pub)
1189 {
1190         struct dma_info *di = (struct dma_info *)pub;
1191         u32 status;
1192
1193         if (di->ntxd == 0)
1194                 return true;
1195
1196         /* suspend tx DMA first */
1197         W_REG(&di->d64txregs->control, D64_XC_SE);
1198         SPINWAIT(((status =
1199                    (R_REG(&di->d64txregs->status0) & D64_XS0_XS_MASK))
1200                   != D64_XS0_XS_DISABLED) && (status != D64_XS0_XS_IDLE)
1201                  && (status != D64_XS0_XS_STOPPED), 10000);
1202
1203         W_REG(&di->d64txregs->control, 0);
1204         SPINWAIT(((status =
1205                    (R_REG(&di->d64txregs->status0) & D64_XS0_XS_MASK))
1206                   != D64_XS0_XS_DISABLED), 10000);
1207
1208         /* wait for the last transaction to complete */
1209         udelay(300);
1210
1211         return status == D64_XS0_XS_DISABLED;
1212 }
1213
1214 bool dma_rxreset(struct dma_pub *pub)
1215 {
1216         struct dma_info *di = (struct dma_info *)pub;
1217         u32 status;
1218
1219         if (di->nrxd == 0)
1220                 return true;
1221
1222         W_REG(&di->d64rxregs->control, 0);
1223         SPINWAIT(((status =
1224                    (R_REG(&di->d64rxregs->status0) & D64_RS0_RS_MASK))
1225                   != D64_RS0_RS_DISABLED), 10000);
1226
1227         return status == D64_RS0_RS_DISABLED;
1228 }
1229
1230 /*
1231  * !! tx entry routine
1232  * WARNING: call must check the return value for error.
1233  *   the error(toss frames) could be fatal and cause many subsequent hard
1234  *   to debug problems
1235  */
1236 int dma_txfast(struct dma_pub *pub, struct sk_buff *p0, bool commit)
1237 {
1238         struct dma_info *di = (struct dma_info *)pub;
1239         struct sk_buff *p, *next;
1240         unsigned char *data;
1241         uint len;
1242         u16 txout;
1243         u32 flags = 0;
1244         dma_addr_t pa;
1245
1246         DMA_TRACE(("%s: dma_txfast\n", di->name));
1247
1248         txout = di->txout;
1249
1250         /*
1251          * Walk the chain of packet buffers
1252          * allocating and initializing transmit descriptor entries.
1253          */
1254         for (p = p0; p; p = next) {
1255                 data = p->data;
1256                 len = p->len;
1257                 next = p->next;
1258
1259                 /* return nonzero if out of tx descriptors */
1260                 if (nexttxd(di, txout) == di->txin)
1261                         goto outoftxd;
1262
1263                 if (len == 0)
1264                         continue;
1265
1266                 /* get physical address of buffer start */
1267                 pa = pci_map_single(di->pbus, data, len, PCI_DMA_TODEVICE);
1268
1269                 flags = 0;
1270                 if (p == p0)
1271                         flags |= D64_CTRL1_SOF;
1272
1273                 /* With a DMA segment list, Descriptor table is filled
1274                  * using the segment list instead of looping over
1275                  * buffers in multi-chain DMA. Therefore, EOF for SGLIST
1276                  * is when end of segment list is reached.
1277                  */
1278                 if (next == NULL)
1279                         flags |= (D64_CTRL1_IOC | D64_CTRL1_EOF);
1280                 if (txout == (di->ntxd - 1))
1281                         flags |= D64_CTRL1_EOT;
1282
1283                 dma64_dd_upd(di, di->txd64, pa, txout, &flags, len);
1284
1285                 txout = nexttxd(di, txout);
1286         }
1287
1288         /* if last txd eof not set, fix it */
1289         if (!(flags & D64_CTRL1_EOF))
1290                 di->txd64[prevtxd(di, txout)].ctrl1 =
1291                      cpu_to_le32(flags | D64_CTRL1_IOC | D64_CTRL1_EOF);
1292
1293         /* save the packet */
1294         di->txp[prevtxd(di, txout)] = p0;
1295
1296         /* bump the tx descriptor index */
1297         di->txout = txout;
1298
1299         /* kick the chip */
1300         if (commit)
1301                 W_REG(&di->d64txregs->ptr,
1302                       di->xmtptrbase + I2B(txout, struct dma64desc));
1303
1304         /* tx flow control */
1305         di->dma.txavail = di->ntxd - ntxdactive(di, di->txin, di->txout) - 1;
1306
1307         return 0;
1308
1309  outoftxd:
1310         DMA_ERROR(("%s: dma_txfast: out of txds !!!\n", di->name));
1311         brcmu_pkt_buf_free_skb(p0);
1312         di->dma.txavail = 0;
1313         di->dma.txnobuf++;
1314         return -1;
1315 }
1316
1317 /*
1318  * Reclaim next completed txd (txds if using chained buffers) in the range
1319  * specified and return associated packet.
1320  * If range is DMA_RANGE_TRANSMITTED, reclaim descriptors that have be
1321  * transmitted as noted by the hardware "CurrDescr" pointer.
1322  * If range is DMA_RANGE_TRANSFERED, reclaim descriptors that have be
1323  * transferred by the DMA as noted by the hardware "ActiveDescr" pointer.
1324  * If range is DMA_RANGE_ALL, reclaim all txd(s) posted to the ring and
1325  * return associated packet regardless of the value of hardware pointers.
1326  */
1327 struct sk_buff *dma_getnexttxp(struct dma_pub *pub, enum txd_range range)
1328 {
1329         struct dma_info *di = (struct dma_info *)pub;
1330         u16 start, end, i;
1331         u16 active_desc;
1332         struct sk_buff *txp;
1333
1334         DMA_TRACE(("%s: dma_getnexttxp %s\n", di->name,
1335                    (range == DMA_RANGE_ALL) ? "all" :
1336                    ((range ==
1337                      DMA_RANGE_TRANSMITTED) ? "transmitted" :
1338                     "transferred")));
1339
1340         if (di->ntxd == 0)
1341                 return NULL;
1342
1343         txp = NULL;
1344
1345         start = di->txin;
1346         if (range == DMA_RANGE_ALL)
1347                 end = di->txout;
1348         else {
1349                 struct dma64regs __iomem *dregs = di->d64txregs;
1350
1351                 end = (u16) (B2I(((R_REG(&dregs->status0) &
1352                                  D64_XS0_CD_MASK) -
1353                                  di->xmtptrbase) & D64_XS0_CD_MASK,
1354                                  struct dma64desc));
1355
1356                 if (range == DMA_RANGE_TRANSFERED) {
1357                         active_desc =
1358                             (u16) (R_REG(&dregs->status1) &
1359                                       D64_XS1_AD_MASK);
1360                         active_desc =
1361                             (active_desc - di->xmtptrbase) & D64_XS0_CD_MASK;
1362                         active_desc = B2I(active_desc, struct dma64desc);
1363                         if (end != active_desc)
1364                                 end = prevtxd(di, active_desc);
1365                 }
1366         }
1367
1368         if ((start == 0) && (end > di->txout))
1369                 goto bogus;
1370
1371         for (i = start; i != end && !txp; i = nexttxd(di, i)) {
1372                 dma_addr_t pa;
1373                 uint size;
1374
1375                 pa = le32_to_cpu(di->txd64[i].addrlow) - di->dataoffsetlow;
1376
1377                 size =
1378                     (le32_to_cpu(di->txd64[i].ctrl2) &
1379                      D64_CTRL2_BC_MASK);
1380
1381                 di->txd64[i].addrlow = cpu_to_le32(0xdeadbeef);
1382                 di->txd64[i].addrhigh = cpu_to_le32(0xdeadbeef);
1383
1384                 txp = di->txp[i];
1385                 di->txp[i] = NULL;
1386
1387                 pci_unmap_single(di->pbus, pa, size, PCI_DMA_TODEVICE);
1388         }
1389
1390         di->txin = i;
1391
1392         /* tx flow control */
1393         di->dma.txavail = di->ntxd - ntxdactive(di, di->txin, di->txout) - 1;
1394
1395         return txp;
1396
1397  bogus:
1398         DMA_NONE(("dma_getnexttxp: bogus curr: start %d end %d txout %d "
1399                   "force %d\n", start, end, di->txout, forceall));
1400         return NULL;
1401 }
1402
1403 /*
1404  * Mac80211 initiated actions sometimes require packets in the DMA queue to be
1405  * modified. The modified portion of the packet is not under control of the DMA
1406  * engine. This function calls a caller-supplied function for each packet in
1407  * the caller specified dma chain.
1408  */
1409 void dma_walk_packets(struct dma_pub *dmah, void (*callback_fnc)
1410                       (void *pkt, void *arg_a), void *arg_a)
1411 {
1412         struct dma_info *di = (struct dma_info *) dmah;
1413         uint i =   di->txin;
1414         uint end = di->txout;
1415         struct sk_buff *skb;
1416         struct ieee80211_tx_info *tx_info;
1417
1418         while (i != end) {
1419                 skb = (struct sk_buff *)di->txp[i];
1420                 if (skb != NULL) {
1421                         tx_info = (struct ieee80211_tx_info *)skb->cb;
1422                         (callback_fnc)(tx_info, arg_a);
1423                 }
1424                 i = nexttxd(di, i);
1425         }
1426 }