drivers/staging/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         u32 ctrl1;      /* misc control bits & bufcount */
 210         u32 ctrl2;      /* buffer count and address extension */
 211         u32 addrlow;    /* memory address of the date buffer, bits 31:0 */
 212         u32 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 *d64txregs;
 228         /* 64-bit dma rx engine registers */
 229         struct dma64regs *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(u32 data)
 299 {
 300         data ^= data >> 16;
 301         data ^= data >> 8;
 302         data ^= data >> 4;
 303         data ^= data >> 2;
 304         data ^= data >> 1;
 305
 306         return data & 1;
 307 }
 308
 309 static bool dma64_dd_parity(struct dma64desc *dd)
 310 {
 311         return parity32(dd->addrlow ^ dd->addrhigh ^ dd->ctrl1 ^ dd->ctrl2);
 312 }
 313
 314 /* descriptor bumping functions */
 315
 316 static uint xxd(uint x, uint n)
 317 {
 318         return x & (n - 1); /* faster than %, but n must be power of 2 */
 319 }
 320
 321 static uint txd(struct dma_info *di, uint x)
 322 {
 323         return xxd(x, di->ntxd);
 324 }
 325
 326 static uint rxd(struct dma_info *di, uint x)
 327 {
 328         return xxd(x, di->nrxd);
 329 }
 330
 331 static uint nexttxd(struct dma_info *di, uint i)
 332 {
 333         return txd(di, i + 1);
 334 }
 335
 336 static uint prevtxd(struct dma_info *di, uint i)
 337 {
 338         return txd(di, i - 1);
 339 }
 340
 341 static uint nextrxd(struct dma_info *di, uint i)
 342 {
 343         return txd(di, i + 1);
 344 }
 345
 346 static uint ntxdactive(struct dma_info *di, uint h, uint t)
 347 {
 348         return txd(di, t-h);
 349 }
 350
 351 static uint nrxdactive(struct dma_info *di, uint h, uint t)
 352 {
 353         return rxd(di, t-h);
 354 }
 355
 356 static uint _dma_ctrlflags(struct dma_info *di, uint mask, uint flags)
 357 {
 358         uint dmactrlflags = di->dma.dmactrlflags;
 359
 360         if (di == NULL) {
 361                 DMA_ERROR(("%s: _dma_ctrlflags: NULL dma handle\n", di->name));
 362                 return 0;
 363         }
 364
 365         dmactrlflags &= ~mask;
 366         dmactrlflags |= flags;
 367
 368         /* If trying to enable parity, check if parity is actually supported */
 369         if (dmactrlflags & DMA_CTRL_PEN) {
 370                 u32 control;
 371
 372                 control = R_REG(&di->d64txregs->control);
 373                 W_REG(&di->d64txregs->control,
 374                       control | D64_XC_PD);
 375                 if (R_REG(&di->d64txregs->control) & D64_XC_PD)
 376                         /* We *can* disable it so it is supported,
 377                          * restore control register
 378                          */
 379                         W_REG(&di->d64txregs->control,
 380                         control);
 381                 else
 382                         /* Not supported, don't allow it to be enabled */
 383                         dmactrlflags &= ~DMA_CTRL_PEN;
 384         }
 385
 386         di->dma.dmactrlflags = dmactrlflags;
 387
 388         return dmactrlflags;
 389 }
 390
 391 static bool _dma64_addrext(struct dma64regs *dma64regs)
 392 {
 393         u32 w;
 394         OR_REG(&dma64regs->control, D64_XC_AE);
 395         w = R_REG(&dma64regs->control);
 396         AND_REG(&dma64regs->control, ~D64_XC_AE);
 397         return (w & D64_XC_AE) == D64_XC_AE;
 398 }
 399
 400 /*
 401  * return true if this dma engine supports DmaExtendedAddrChanges,
 402  * otherwise false
 403  */
 404 static bool _dma_isaddrext(struct dma_info *di)
 405 {
 406         /* DMA64 supports full 32- or 64-bit operation. AE is always valid */
 407
 408         /* not all tx or rx channel are available */
 409         if (di->d64txregs != NULL) {
 410                 if (!_dma64_addrext(di->d64txregs))
 411                         DMA_ERROR(("%s: _dma_isaddrext: DMA64 tx doesn't have "
 412                                    "AE set\n", di->name));
 413                 return true;
 414         } else if (di->d64rxregs != NULL) {
 415                 if (!_dma64_addrext(di->d64rxregs))
 416                         DMA_ERROR(("%s: _dma_isaddrext: DMA64 rx doesn't have "
 417                                    "AE set\n", di->name));
 418                 return true;
 419         }
 420
 421         return false;
 422 }
 423
 424 static bool _dma_descriptor_align(struct dma_info *di)
 425 {
 426         u32 addrl;
 427
 428         /* Check to see if the descriptors need to be aligned on 4K/8K or not */
 429         if (di->d64txregs != NULL) {
 430                 W_REG(&di->d64txregs->addrlow, 0xff0);
 431                 addrl = R_REG(&di->d64txregs->addrlow);
 432                 if (addrl != 0)
 433                         return false;
 434         } else if (di->d64rxregs != NULL) {
 435                 W_REG(&di->d64rxregs->addrlow, 0xff0);
 436                 addrl = R_REG(&di->d64rxregs->addrlow);
 437                 if (addrl != 0)
 438                         return false;
 439         }
 440         return true;
 441 }
 442
 443 /*
 444  * Descriptor table must start at the DMA hardware dictated alignment, so
 445  * allocated memory must be large enough to support this requirement.
 446  */
 447 static void *dma_alloc_consistent(struct pci_dev *pdev, uint size,
 448                                   u16 align_bits, uint *alloced,
 449                                   dma_addr_t *pap)
 450 {
 451         if (align_bits) {
 452                 u16 align = (1 << align_bits);
 453                 if (!IS_ALIGNED(PAGE_SIZE, align))
 454                         size += align;
 455                 *alloced = size;
 456         }
 457         return pci_alloc_consistent(pdev, size, pap);
 458 }
 459
 460 static
 461 u8 dma_align_sizetobits(uint size)
 462 {
 463         u8 bitpos = 0;
 464         while (size >>= 1)
 465                 bitpos++;
 466         return bitpos;
 467 }
 468
 469 /* This function ensures that the DMA descriptor ring will not get allocated
 470  * across Page boundary. If the allocation is done across the page boundary
 471  * at the first time, then it is freed and the allocation is done at
 472  * descriptor ring size aligned location. This will ensure that the ring will
 473  * not cross page boundary
 474  */
 475 static void *dma_ringalloc(struct dma_info *di, u32 boundary, uint size,
 476                            u16 *alignbits, uint *alloced,
 477                            dma_addr_t *descpa)
 478 {
 479         void *va;
 480         u32 desc_strtaddr;
 481         u32 alignbytes = 1 << *alignbits;
 482
 483         va = dma_alloc_consistent(di->pbus, size, *alignbits, alloced, descpa);
 484
 485         if (NULL == va)
 486                 return NULL;
 487
 488         desc_strtaddr = (u32) roundup((unsigned long)va, alignbytes);
 489         if (((desc_strtaddr + size - 1) & boundary) != (desc_strtaddr
 490                                                         & boundary)) {
 491                 *alignbits = dma_align_sizetobits(size);
 492                 pci_free_consistent(di->pbus, size, va, *descpa);
 493                 va = dma_alloc_consistent(di->pbus, size, *alignbits,
 494                         alloced, descpa);
 495         }
 496         return va;
 497 }
 498
 499 static bool dma64_alloc(struct dma_info *di, uint direction)
 500 {
 501         u16 size;
 502         uint ddlen;
 503         void *va;
 504         uint alloced = 0;
 505         u16 align;
 506         u16 align_bits;
 507
 508         ddlen = sizeof(struct dma64desc);
 509
 510         size = (direction == DMA_TX) ? (di->ntxd * ddlen) : (di->nrxd * ddlen);
 511         align_bits = di->dmadesc_align;
 512         align = (1 << align_bits);
 513
 514         if (direction == DMA_TX) {
 515                 va = dma_ringalloc(di, D64RINGALIGN, size, &align_bits,
 516                         &alloced, &di->txdpaorig);
 517                 if (va == NULL) {
 518                         DMA_ERROR(("%s: dma64_alloc: DMA_ALLOC_CONSISTENT(ntxd)"
 519                                    " failed\n", di->name));
 520                         return false;
 521                 }
 522                 align = (1 << align_bits);
 523                 di->txd64 = (struct dma64desc *)
 524                                         roundup((unsigned long)va, align);
 525                 di->txdalign = (uint) ((s8 *)di->txd64 - (s8 *) va);
 526                 di->txdpa = di->txdpaorig + di->txdalign;
 527                 di->txdalloc = alloced;
 528         } else {
 529                 va = dma_ringalloc(di, D64RINGALIGN, size, &align_bits,
 530                         &alloced, &di->rxdpaorig);
 531                 if (va == NULL) {
 532                         DMA_ERROR(("%s: dma64_alloc: DMA_ALLOC_CONSISTENT(nrxd)"
 533                                    " failed\n", di->name));
 534                         return false;
 535                 }
 536                 align = (1 << align_bits);
 537                 di->rxd64 = (struct dma64desc *)
 538                                         roundup((unsigned long)va, align);
 539                 di->rxdalign = (uint) ((s8 *)di->rxd64 - (s8 *) va);
 540                 di->rxdpa = di->rxdpaorig + di->rxdalign;
 541                 di->rxdalloc = alloced;
 542         }
 543
 544         return true;
 545 }
 546
 547 static bool _dma_alloc(struct dma_info *di, uint direction)
 548 {
 549         return dma64_alloc(di, direction);
 550 }
 551
 552 struct dma_pub *dma_attach(char *name, struct si_pub *sih,
 553                      void *dmaregstx, void *dmaregsrx, uint ntxd,
 554                      uint nrxd, uint rxbufsize, int rxextheadroom,
 555                      uint nrxpost, uint rxoffset, uint *msg_level)
 556 {
 557         struct dma_info *di;
 558         uint size;
 559
 560         /* allocate private info structure */
 561         di = kzalloc(sizeof(struct dma_info), GFP_ATOMIC);
 562         if (di == NULL) {
 563 #ifdef BCMDBG
 564                 printk(KERN_ERR "dma_attach: out of memory\n");
 565 #endif
 566                 return NULL;
 567         }
 568
 569         di->msg_level = msg_level ? msg_level : &dma_msg_level;
 570
 571
 572         di->dma64 = ((ai_core_sflags(sih, 0, 0) & SISF_DMA64) == SISF_DMA64);
 573
 574         /* init dma reg pointer */
 575         di->d64txregs = (struct dma64regs *) dmaregstx;
 576         di->d64rxregs = (struct dma64regs *) dmaregsrx;
 577
 578         /*
 579          * Default flags (which can be changed by the driver calling
 580          * dma_ctrlflags before enable): For backwards compatibility
 581          * both Rx Overflow Continue and Parity are DISABLED.
 582          */
 583         _dma_ctrlflags(di, DMA_CTRL_ROC | DMA_CTRL_PEN, 0);
 584
 585         DMA_TRACE(("%s: dma_attach: %s flags 0x%x ntxd %d nrxd %d "
 586                    "rxbufsize %d rxextheadroom %d nrxpost %d rxoffset %d "
 587                    "dmaregstx %p dmaregsrx %p\n", name, "DMA64",
 588                    di->dma.dmactrlflags, ntxd, nrxd, rxbufsize,
 589                    rxextheadroom, nrxpost, rxoffset, dmaregstx, dmaregsrx));
 590
 591         /* make a private copy of our callers name */
 592         strncpy(di->name, name, MAXNAMEL);
 593         di->name[MAXNAMEL - 1] = '\0';
 594
 595         di->pbus = ((struct si_info *)sih)->pbus;
 596
 597         /* save tunables */
 598         di->ntxd = (u16) ntxd;
 599         di->nrxd = (u16) nrxd;
 600
 601         /* the actual dma size doesn't include the extra headroom */
 602         di->rxextrahdrroom =
 603             (rxextheadroom == -1) ? BCMEXTRAHDROOM : rxextheadroom;
 604         if (rxbufsize > BCMEXTRAHDROOM)
 605                 di->rxbufsize = (u16) (rxbufsize - di->rxextrahdrroom);
 606         else
 607                 di->rxbufsize = (u16) rxbufsize;
 608
 609         di->nrxpost = (u16) nrxpost;
 610         di->rxoffset = (u8) rxoffset;
 611
 612         /*
 613          * figure out the DMA physical address offset for dd and data
 614          *     PCI/PCIE: they map silicon backplace address to zero
 615          *     based memory, need offset
 616          *     Other bus: use zero SI_BUS BIGENDIAN kludge: use sdram
 617          *     swapped region for data buffer, not descriptor
 618          */
 619         di->ddoffsetlow = 0;
 620         di->dataoffsetlow = 0;
 621         /* add offset for pcie with DMA64 bus */
 622         di->ddoffsetlow = 0;
 623         di->ddoffsethigh = SI_PCIE_DMA_H32;
 624         di->dataoffsetlow = di->ddoffsetlow;
 625         di->dataoffsethigh = di->ddoffsethigh;
 626         /* WAR64450 : DMACtl.Addr ext fields are not supported in SDIOD core. */
 627         if ((ai_coreid(sih) == SDIOD_CORE_ID)
 628             && ((ai_corerev(sih) > 0) && (ai_corerev(sih) <= 2)))
 629                 di->addrext = 0;
 630         else if ((ai_coreid(sih) == I2S_CORE_ID) &&
 631                  ((ai_corerev(sih) == 0) || (ai_corerev(sih) == 1)))
 632                 di->addrext = 0;
 633         else
 634                 di->addrext = _dma_isaddrext(di);
 635
 636         /* does the descriptor need to be aligned and if yes, on 4K/8K or not */
 637         di->aligndesc_4k = _dma_descriptor_align(di);
 638         if (di->aligndesc_4k) {
 639                 di->dmadesc_align = D64RINGALIGN_BITS;
 640                 if ((ntxd < D64MAXDD / 2) && (nrxd < D64MAXDD / 2))
 641                         /* for smaller dd table, HW relax alignment reqmnt */
 642                         di->dmadesc_align = D64RINGALIGN_BITS - 1;
 643         } else {
 644                 di->dmadesc_align = 4;  /* 16 byte alignment */
 645         }
 646
 647         DMA_NONE(("DMA descriptor align_needed %d, align %d\n",
 648                   di->aligndesc_4k, di->dmadesc_align));
 649
 650         /* allocate tx packet pointer vector */
 651         if (ntxd) {
 652                 size = ntxd * sizeof(void *);
 653                 di->txp = kzalloc(size, GFP_ATOMIC);
 654                 if (di->txp == NULL) {
 655                         DMA_ERROR(("%s: dma_attach: out of tx memory\n",
 656                                    di->name));
 657                         goto fail;
 658                 }
 659         }
 660
 661         /* allocate rx packet pointer vector */
 662         if (nrxd) {
 663                 size = nrxd * sizeof(void *);
 664                 di->rxp = kzalloc(size, GFP_ATOMIC);
 665                 if (di->rxp == NULL) {
 666                         DMA_ERROR(("%s: dma_attach: out of rx memory\n",
 667                                    di->name));
 668                         goto fail;
 669                 }
 670         }
 671
 672         /*
 673          * allocate transmit descriptor ring, only need ntxd descriptors
 674          * but it must be aligned
 675          */
 676         if (ntxd) {
 677                 if (!_dma_alloc(di, DMA_TX))
 678                         goto fail;
 679         }
 680
 681         /*
 682          * allocate receive descriptor ring, only need nrxd descriptors
 683          * but it must be aligned
 684          */
 685         if (nrxd) {
 686                 if (!_dma_alloc(di, DMA_RX))
 687                         goto fail;
 688         }
 689
 690         if ((di->ddoffsetlow != 0) && !di->addrext) {
 691                 if (di->txdpa > SI_PCI_DMA_SZ) {
 692                         DMA_ERROR(("%s: dma_attach: txdpa 0x%x: addrext not "
 693                                    "supported\n", di->name, (u32)di->txdpa));
 694                         goto fail;
 695                 }
 696                 if (di->rxdpa > SI_PCI_DMA_SZ) {
 697                         DMA_ERROR(("%s: dma_attach: rxdpa 0x%x: addrext not "
 698                                    "supported\n", di->name, (u32)di->rxdpa));
 699                         goto fail;
 700                 }
 701         }
 702
 703         DMA_TRACE(("ddoffsetlow 0x%x ddoffsethigh 0x%x dataoffsetlow 0x%x "
 704                    "dataoffsethigh " "0x%x addrext %d\n", di->ddoffsetlow,
 705                    di->ddoffsethigh, di->dataoffsetlow, di->dataoffsethigh,
 706                    di->addrext));
 707
 708         return (struct dma_pub *) di;
 709
 710  fail:
 711         dma_detach((struct dma_pub *)di);
 712         return NULL;
 713 }
 714
 715 static inline void
 716 dma64_dd_upd(struct dma_info *di, struct dma64desc *ddring,
 717              dma_addr_t pa, uint outidx, u32 *flags, u32 bufcount)
 718 {
 719         u32 ctrl2 = bufcount & D64_CTRL2_BC_MASK;
 720
 721         /* PCI bus with big(>1G) physical address, use address extension */
 722         if ((di->dataoffsetlow == 0) || !(pa & PCI32ADDR_HIGH)) {
 723                 ddring[outidx].addrlow = cpu_to_le32(pa + di->dataoffsetlow);
 724                 ddring[outidx].addrhigh = cpu_to_le32(di->dataoffsethigh);
 725                 ddring[outidx].ctrl1 = cpu_to_le32(*flags);
 726                 ddring[outidx].ctrl2 = cpu_to_le32(ctrl2);
 727         } else {
 728                 /* address extension for 32-bit PCI */
 729                 u32 ae;
 730
 731                 ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
 732                 pa &= ~PCI32ADDR_HIGH;
 733
 734                 ctrl2 |= (ae << D64_CTRL2_AE_SHIFT) & D64_CTRL2_AE;
 735                 ddring[outidx].addrlow = cpu_to_le32(pa + di->dataoffsetlow);
 736                 ddring[outidx].addrhigh = cpu_to_le32(di->dataoffsethigh);
 737                 ddring[outidx].ctrl1 = cpu_to_le32(*flags);
 738                 ddring[outidx].ctrl2 = cpu_to_le32(ctrl2);
 739         }
 740         if (di->dma.dmactrlflags & DMA_CTRL_PEN) {
 741                 if (dma64_dd_parity(&ddring[outidx]))
 742                         ddring[outidx].ctrl2 =
 743                              cpu_to_le32(ctrl2 | D64_CTRL2_PARITY);
 744         }
 745 }
 746
 747 /* !! may be called with core in reset */
 748 void dma_detach(struct dma_pub *pub)
 749 {
 750         struct dma_info *di = (struct dma_info *)pub;
 751
 752         DMA_TRACE(("%s: dma_detach\n", di->name));
 753
 754         /* free dma descriptor rings */
 755         if (di->txd64)
 756                 pci_free_consistent(di->pbus, di->txdalloc,
 757                                     ((s8 *)di->txd64 - di->txdalign),
 758                                     (di->txdpaorig));
 759         if (di->rxd64)
 760                 pci_free_consistent(di->pbus, di->rxdalloc,
 761                                     ((s8 *)di->rxd64 - di->rxdalign),
 762                                     (di->rxdpaorig));
 763
 764         /* free packet pointer vectors */
 765         kfree(di->txp);
 766         kfree(di->rxp);
 767
 768         /* free our private info structure */
 769         kfree(di);
 770
 771 }
 772
 773 /* initialize descriptor table base address */
 774 static void
 775 _dma_ddtable_init(struct dma_info *di, uint direction, dma_addr_t pa)
 776 {
 777         if (!di->aligndesc_4k) {
 778                 if (direction == DMA_TX)
 779                         di->xmtptrbase = pa;
 780                 else
 781                         di->rcvptrbase = pa;
 782         }
 783
 784         if ((di->ddoffsetlow == 0)
 785             || !(pa & PCI32ADDR_HIGH)) {
 786                 if (direction == DMA_TX) {
 787                         W_REG(&di->d64txregs->addrlow, pa + di->ddoffsetlow);
 788                         W_REG(&di->d64txregs->addrhigh, di->ddoffsethigh);
 789                 } else {
 790                         W_REG(&di->d64rxregs->addrlow, pa + di->ddoffsetlow);
 791                         W_REG(&di->d64rxregs->addrhigh, di->ddoffsethigh);
 792                 }
 793         } else {
 794                 /* DMA64 32bits address extension */
 795                 u32 ae;
 796
 797                 /* shift the high bit(s) from pa to ae */
 798                 ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
 799                 pa &= ~PCI32ADDR_HIGH;
 800
 801                 if (direction == DMA_TX) {
 802                         W_REG(&di->d64txregs->addrlow, pa + di->ddoffsetlow);
 803                         W_REG(&di->d64txregs->addrhigh, di->ddoffsethigh);
 804                         SET_REG(&di->d64txregs->control,
 805                                 D64_XC_AE, (ae << D64_XC_AE_SHIFT));
 806                 } else {
 807                         W_REG(&di->d64rxregs->addrlow, pa + di->ddoffsetlow);
 808                         W_REG(&di->d64rxregs->addrhigh, di->ddoffsethigh);
 809                         SET_REG(&di->d64rxregs->control,
 810                                 D64_RC_AE, (ae << D64_RC_AE_SHIFT));
 811                 }
 812         }
 813 }
 814
 815 static void _dma_rxenable(struct dma_info *di)
 816 {
 817         uint dmactrlflags = di->dma.dmactrlflags;
 818         u32 control;
 819
 820         DMA_TRACE(("%s: dma_rxenable\n", di->name));
 821
 822         control =
 823             (R_REG(&di->d64rxregs->control) & D64_RC_AE) |
 824             D64_RC_RE;
 825
 826         if ((dmactrlflags & DMA_CTRL_PEN) == 0)
 827                 control |= D64_RC_PD;
 828
 829         if (dmactrlflags & DMA_CTRL_ROC)
 830                 control |= D64_RC_OC;
 831
 832         W_REG(&di->d64rxregs->control,
 833                 ((di->rxoffset << D64_RC_RO_SHIFT) | control));
 834 }
 835
 836 void dma_rxinit(struct dma_pub *pub)
 837 {
 838         struct dma_info *di = (struct dma_info *)pub;
 839
 840         DMA_TRACE(("%s: dma_rxinit\n", di->name));
 841
 842         if (di->nrxd == 0)
 843                 return;
 844
 845         di->rxin = di->rxout = 0;
 846
 847         /* clear rx descriptor ring */
 848         memset(di->rxd64, '\0', di->nrxd * sizeof(struct dma64desc));
 849
 850         /* DMA engine with out alignment requirement requires table to be inited
 851          * before enabling the engine
 852          */
 853         if (!di->aligndesc_4k)
 854                 _dma_ddtable_init(di, DMA_RX, di->rxdpa);
 855
 856         _dma_rxenable(di);
 857
 858         if (di->aligndesc_4k)
 859                 _dma_ddtable_init(di, DMA_RX, di->rxdpa);
 860 }
 861
 862 static struct sk_buff *dma64_getnextrxp(struct dma_info *di, bool forceall)
 863 {
 864         uint i, curr;
 865         struct sk_buff *rxp;
 866         dma_addr_t pa;
 867
 868         i = di->rxin;
 869
 870         /* return if no packets posted */
 871         if (i == di->rxout)
 872                 return NULL;
 873
 874         curr =
 875             B2I(((R_REG(&di->d64rxregs->status0) & D64_RS0_CD_MASK) -
 876                  di->rcvptrbase) & D64_RS0_CD_MASK, struct dma64desc);
 877
 878         /* ignore curr if forceall */
 879         if (!forceall && (i == curr))
 880                 return NULL;
 881
 882         /* get the packet pointer that corresponds to the rx descriptor */
 883         rxp = di->rxp[i];
 884         di->rxp[i] = NULL;
 885
 886         pa = cpu_to_le32(di->rxd64[i].addrlow) - di->dataoffsetlow;
 887
 888         /* clear this packet from the descriptor ring */
 889         pci_unmap_single(di->pbus, pa, di->rxbufsize, PCI_DMA_FROMDEVICE);
 890
 891         di->rxd64[i].addrlow = 0xdeadbeef;
 892         di->rxd64[i].addrhigh = 0xdeadbeef;
 893
 894         di->rxin = nextrxd(di, i);
 895
 896         return rxp;
 897 }
 898
 899 static struct sk_buff *_dma_getnextrxp(struct dma_info *di, bool forceall)
 900 {
 901         if (di->nrxd == 0)
 902                 return NULL;
 903
 904         return dma64_getnextrxp(di, forceall);
 905 }
 906
 907 /*
 908  * !! rx entry routine
 909  * returns a pointer to the next frame received, or NULL if there are no more
 910  *   if DMA_CTRL_RXMULTI is defined, DMA scattering(multiple buffers) is
 911  *   supported with pkts chain
 912  *   otherwise, it's treated as giant pkt and will be tossed.
 913  *   The DMA scattering starts with normal DMA header, followed by first
 914  *   buffer data. After it reaches the max size of buffer, the data continues
 915  *   in next DMA descriptor buffer WITHOUT DMA header
 916  */
 917 struct sk_buff *dma_rx(struct dma_pub *pub)
 918 {
 919         struct dma_info *di = (struct dma_info *)pub;
 920         struct sk_buff *p, *head, *tail;
 921         uint len;
 922         uint pkt_len;
 923         int resid = 0;
 924
 925  next_frame:
 926         head = _dma_getnextrxp(di, false);
 927         if (head == NULL)
 928                 return NULL;
 929
 930         len = le16_to_cpu(*(u16 *) (head->data));
 931         DMA_TRACE(("%s: dma_rx len %d\n", di->name, len));
 932         dma_spin_for_len(len, head);
 933
 934         /* set actual length */
 935         pkt_len = min((di->rxoffset + len), di->rxbufsize);
 936         __skb_trim(head, pkt_len);
 937         resid = len - (di->rxbufsize - di->rxoffset);
 938
 939         /* check for single or multi-buffer rx */
 940         if (resid > 0) {
 941                 tail = head;
 942                 while ((resid > 0) && (p = _dma_getnextrxp(di, false))) {
 943                         tail->next = p;
 944                         pkt_len = min_t(uint, resid, di->rxbufsize);
 945                         __skb_trim(p, pkt_len);
 946
 947                         tail = p;
 948                         resid -= di->rxbufsize;
 949                 }
 950
 951 #ifdef BCMDBG
 952                 if (resid > 0) {
 953                         uint cur;
 954                         cur =
 955                             B2I(((R_REG(&di->d64rxregs->status0) &
 956                                   D64_RS0_CD_MASK) -
 957                                  di->rcvptrbase) & D64_RS0_CD_MASK,
 958                                 struct dma64desc);
 959                         DMA_ERROR(("dma_rx, rxin %d rxout %d, hw_curr %d\n",
 960                                    di->rxin, di->rxout, cur));
 961                 }
 962 #endif                          /* BCMDBG */
 963
 964                 if ((di->dma.dmactrlflags & DMA_CTRL_RXMULTI) == 0) {
 965                         DMA_ERROR(("%s: dma_rx: bad frame length (%d)\n",
 966                                    di->name, len));
 967                         brcmu_pkt_buf_free_skb(head);
 968                         di->dma.rxgiants++;
 969                         goto next_frame;
 970                 }
 971         }
 972
 973         return head;
 974 }
 975
 976 static bool dma64_rxidle(struct dma_info *di)
 977 {
 978         DMA_TRACE(("%s: dma_rxidle\n", di->name));
 979
 980         if (di->nrxd == 0)
 981                 return true;
 982
 983         return ((R_REG(&di->d64rxregs->status0) & D64_RS0_CD_MASK) ==
 984                 (R_REG(&di->d64rxregs->ptr) & D64_RS0_CD_MASK));
 985 }
 986
 987 /*
 988  * post receive buffers
 989  *  return false is refill failed completely and ring is empty this will stall
 990  *  the rx dma and user might want to call rxfill again asap. This unlikely
 991  *  happens on memory-rich NIC, but often on memory-constrained dongle
 992  */
 993 bool dma_rxfill(struct dma_pub *pub)
 994 {
 995         struct dma_info *di = (struct dma_info *)pub;
 996         struct sk_buff *p;
 997         u16 rxin, rxout;
 998         u32 flags = 0;
 999         uint n;
1000         uint i;
1001         dma_addr_t pa;
1002         uint extra_offset = 0;
1003         bool ring_empty;
1004
1005         ring_empty = false;
1006
1007         /*
1008          * Determine how many receive buffers we're lacking
1009          * from the full complement, allocate, initialize,
1010          * and post them, then update the chip rx lastdscr.
1011          */
1012
1013         rxin = di->rxin;
1014         rxout = di->rxout;
1015
1016         n = di->nrxpost - nrxdactive(di, rxin, rxout);
1017
1018         DMA_TRACE(("%s: dma_rxfill: post %d\n", di->name, n));
1019
1020         if (di->rxbufsize > BCMEXTRAHDROOM)
1021                 extra_offset = di->rxextrahdrroom;
1022
1023         for (i = 0; i < n; i++) {
1024                 /*
1025                  * the di->rxbufsize doesn't include the extra headroom,
1026                  * we need to add it to the size to be allocated
1027                  */
1028                 p = brcmu_pkt_buf_get_skb(di->rxbufsize + extra_offset);
1029
1030                 if (p == NULL) {
1031                         DMA_ERROR(("%s: dma_rxfill: out of rxbufs\n",
1032                                    di->name));
1033                         if (i == 0 && dma64_rxidle(di)) {
1034                                 DMA_ERROR(("%s: rxfill64: ring is empty !\n",
1035                                            di->name));
1036                                 ring_empty = true;
1037                         }
1038                         di->dma.rxnobuf++;
1039                         break;
1040                 }
1041                 /* reserve an extra headroom, if applicable */
1042                 if (extra_offset)
1043                         skb_pull(p, extra_offset);
1044
1045                 /* Do a cached write instead of uncached write since DMA_MAP
1046                  * will flush the cache.
1047                  */
1048                 *(u32 *) (p->data) = 0;
1049
1050                 pa = pci_map_single(di->pbus, p->data,
1051                         di->rxbufsize, PCI_DMA_FROMDEVICE);
1052
1053                 /* save the free packet pointer */
1054                 di->rxp[rxout] = p;
1055
1056                 /* reset flags for each descriptor */
1057                 flags = 0;
1058                 if (rxout == (di->nrxd - 1))
1059                         flags = D64_CTRL1_EOT;
1060
1061                 dma64_dd_upd(di, di->rxd64, pa, rxout, &flags,
1062                              di->rxbufsize);
1063                 rxout = nextrxd(di, rxout);
1064         }
1065
1066         di->rxout = rxout;
1067
1068         /* update the chip lastdscr pointer */
1069         W_REG(&di->d64rxregs->ptr,
1070               di->rcvptrbase + I2B(rxout, struct dma64desc));
1071
1072         return ring_empty;
1073 }
1074
1075 void dma_rxreclaim(struct dma_pub *pub)
1076 {
1077         struct dma_info *di = (struct dma_info *)pub;
1078         struct sk_buff *p;
1079
1080         DMA_TRACE(("%s: dma_rxreclaim\n", di->name));
1081
1082         while ((p = _dma_getnextrxp(di, true)))
1083                 brcmu_pkt_buf_free_skb(p);
1084 }
1085
1086 void dma_counterreset(struct dma_pub *pub)
1087 {
1088         /* reset all software counters */
1089         pub->rxgiants = 0;
1090         pub->rxnobuf = 0;
1091         pub->txnobuf = 0;
1092 }
1093
1094 /* get the address of the var in order to change later */
1095 unsigned long dma_getvar(struct dma_pub *pub, const char *name)
1096 {
1097         struct dma_info *di = (struct dma_info *)pub;
1098
1099         if (!strcmp(name, "&txavail"))
1100                 return (unsigned long)&(di->dma.txavail);
1101         return 0;
1102 }
1103
1104 /* 64-bit DMA functions */
1105
1106 void dma_txinit(struct dma_pub *pub)
1107 {
1108         struct dma_info *di = (struct dma_info *)pub;
1109         u32 control = D64_XC_XE;
1110
1111         DMA_TRACE(("%s: dma_txinit\n", di->name));
1112
1113         if (di->ntxd == 0)
1114                 return;
1115
1116         di->txin = di->txout = 0;
1117         di->dma.txavail = di->ntxd - 1;
1118
1119         /* clear tx descriptor ring */
1120         memset(di->txd64, '\0', (di->ntxd * sizeof(struct dma64desc)));
1121
1122         /* DMA engine with out alignment requirement requires table to be inited
1123          * before enabling the engine
1124          */
1125         if (!di->aligndesc_4k)
1126                 _dma_ddtable_init(di, DMA_TX, di->txdpa);
1127
1128         if ((di->dma.dmactrlflags & DMA_CTRL_PEN) == 0)
1129                 control |= D64_XC_PD;
1130         OR_REG(&di->d64txregs->control, control);
1131
1132         /* DMA engine with alignment requirement requires table to be inited
1133          * before enabling the engine
1134          */
1135         if (di->aligndesc_4k)
1136                 _dma_ddtable_init(di, DMA_TX, di->txdpa);
1137 }
1138
1139 void dma_txsuspend(struct dma_pub *pub)
1140 {
1141         struct dma_info *di = (struct dma_info *)pub;
1142
1143         DMA_TRACE(("%s: dma_txsuspend\n", di->name));
1144
1145         if (di->ntxd == 0)
1146                 return;
1147
1148         OR_REG(&di->d64txregs->control, D64_XC_SE);
1149 }
1150
1151 void dma_txresume(struct dma_pub *pub)
1152 {
1153         struct dma_info *di = (struct dma_info *)pub;
1154
1155         DMA_TRACE(("%s: dma_txresume\n", di->name));
1156
1157         if (di->ntxd == 0)
1158                 return;
1159
1160         AND_REG(&di->d64txregs->control, ~D64_XC_SE);
1161 }
1162
1163 bool dma_txsuspended(struct dma_pub *pub)
1164 {
1165         struct dma_info *di = (struct dma_info *)pub;
1166
1167         return (di->ntxd == 0) ||
1168             ((R_REG(&di->d64txregs->control) & D64_XC_SE) ==
1169              D64_XC_SE);
1170 }
1171
1172 void dma_txreclaim(struct dma_pub *pub, enum txd_range range)
1173 {
1174         struct dma_info *di = (struct dma_info *)pub;
1175         struct sk_buff *p;
1176
1177         DMA_TRACE(("%s: dma_txreclaim %s\n", di->name,
1178                    (range == DMA_RANGE_ALL) ? "all" :
1179                    ((range ==
1180                      DMA_RANGE_TRANSMITTED) ? "transmitted" :
1181                     "transferred")));
1182
1183         if (di->txin == di->txout)
1184                 return;
1185
1186         while ((p = dma_getnexttxp(pub, range))) {
1187                 /* For unframed data, we don't have any packets to free */
1188                 if (!(di->dma.dmactrlflags & DMA_CTRL_UNFRAMED))
1189                         brcmu_pkt_buf_free_skb(p);
1190         }
1191 }
1192
1193 bool dma_txreset(struct dma_pub *pub)
1194 {
1195         struct dma_info *di = (struct dma_info *)pub;
1196         u32 status;
1197
1198         if (di->ntxd == 0)
1199                 return true;
1200
1201         /* suspend tx DMA first */
1202         W_REG(&di->d64txregs->control, D64_XC_SE);
1203         SPINWAIT(((status =
1204                    (R_REG(&di->d64txregs->status0) & D64_XS0_XS_MASK))
1205                   != D64_XS0_XS_DISABLED) && (status != D64_XS0_XS_IDLE)
1206                  && (status != D64_XS0_XS_STOPPED), 10000);
1207
1208         W_REG(&di->d64txregs->control, 0);
1209         SPINWAIT(((status =
1210                    (R_REG(&di->d64txregs->status0) & D64_XS0_XS_MASK))
1211                   != D64_XS0_XS_DISABLED), 10000);
1212
1213         /* wait for the last transaction to complete */
1214         udelay(300);
1215
1216         return status == D64_XS0_XS_DISABLED;
1217 }
1218
1219 bool dma_rxreset(struct dma_pub *pub)
1220 {
1221         struct dma_info *di = (struct dma_info *)pub;
1222         u32 status;
1223
1224         if (di->nrxd == 0)
1225                 return true;
1226
1227         W_REG(&di->d64rxregs->control, 0);
1228         SPINWAIT(((status =
1229                    (R_REG(&di->d64rxregs->status0) & D64_RS0_RS_MASK))
1230                   != D64_RS0_RS_DISABLED), 10000);
1231
1232         return status == D64_RS0_RS_DISABLED;
1233 }
1234
1235 /*
1236  * !! tx entry routine
1237  * WARNING: call must check the return value for error.
1238  *   the error(toss frames) could be fatal and cause many subsequent hard
1239  *   to debug problems
1240  */
1241 int dma_txfast(struct dma_pub *pub, struct sk_buff *p0, bool commit)
1242 {
1243         struct dma_info *di = (struct dma_info *)pub;
1244         struct sk_buff *p, *next;
1245         unsigned char *data;
1246         uint len;
1247         u16 txout;
1248         u32 flags = 0;
1249         dma_addr_t pa;
1250
1251         DMA_TRACE(("%s: dma_txfast\n", di->name));
1252
1253         txout = di->txout;
1254
1255         /*
1256          * Walk the chain of packet buffers
1257          * allocating and initializing transmit descriptor entries.
1258          */
1259         for (p = p0; p; p = next) {
1260                 data = p->data;
1261                 len = p->len;
1262                 next = p->next;
1263
1264                 /* return nonzero if out of tx descriptors */
1265                 if (nexttxd(di, txout) == di->txin)
1266                         goto outoftxd;
1267
1268                 if (len == 0)
1269                         continue;
1270
1271                 /* get physical address of buffer start */
1272                 pa = pci_map_single(di->pbus, data, len, PCI_DMA_TODEVICE);
1273
1274                 flags = 0;
1275                 if (p == p0)
1276                         flags |= D64_CTRL1_SOF;
1277
1278                 /* With a DMA segment list, Descriptor table is filled
1279                  * using the segment list instead of looping over
1280                  * buffers in multi-chain DMA. Therefore, EOF for SGLIST
1281                  * is when end of segment list is reached.
1282                  */
1283                 if (next == NULL)
1284                         flags |= (D64_CTRL1_IOC | D64_CTRL1_EOF);
1285                 if (txout == (di->ntxd - 1))
1286                         flags |= D64_CTRL1_EOT;
1287
1288                 dma64_dd_upd(di, di->txd64, pa, txout, &flags, len);
1289
1290                 txout = nexttxd(di, txout);
1291         }
1292
1293         /* if last txd eof not set, fix it */
1294         if (!(flags & D64_CTRL1_EOF))
1295                 di->txd64[prevtxd(di, txout)].ctrl1 =
1296                      cpu_to_le32(flags | D64_CTRL1_IOC | D64_CTRL1_EOF);
1297
1298         /* save the packet */
1299         di->txp[prevtxd(di, txout)] = p0;
1300
1301         /* bump the tx descriptor index */
1302         di->txout = txout;
1303
1304         /* kick the chip */
1305         if (commit)
1306                 W_REG(&di->d64txregs->ptr,
1307                       di->xmtptrbase + I2B(txout, struct dma64desc));
1308
1309         /* tx flow control */
1310         di->dma.txavail = di->ntxd - ntxdactive(di, di->txin, di->txout) - 1;
1311
1312         return 0;
1313
1314  outoftxd:
1315         DMA_ERROR(("%s: dma_txfast: out of txds !!!\n", di->name));
1316         brcmu_pkt_buf_free_skb(p0);
1317         di->dma.txavail = 0;
1318         di->dma.txnobuf++;
1319         return -1;
1320 }
1321
1322 /*
1323  * Reclaim next completed txd (txds if using chained buffers) in the range
1324  * specified and return associated packet.
1325  * If range is DMA_RANGE_TRANSMITTED, reclaim descriptors that have be
1326  * transmitted as noted by the hardware "CurrDescr" pointer.
1327  * If range is DMA_RANGE_TRANSFERED, reclaim descriptors that have be
1328  * transferred by the DMA as noted by the hardware "ActiveDescr" pointer.
1329  * If range is DMA_RANGE_ALL, reclaim all txd(s) posted to the ring and
1330  * return associated packet regardless of the value of hardware pointers.
1331  */
1332 struct sk_buff *dma_getnexttxp(struct dma_pub *pub, enum txd_range range)
1333 {
1334         struct dma_info *di = (struct dma_info *)pub;
1335         u16 start, end, i;
1336         u16 active_desc;
1337         struct sk_buff *txp;
1338
1339         DMA_TRACE(("%s: dma_getnexttxp %s\n", di->name,
1340                    (range == DMA_RANGE_ALL) ? "all" :
1341                    ((range ==
1342                      DMA_RANGE_TRANSMITTED) ? "transmitted" :
1343                     "transferred")));
1344
1345         if (di->ntxd == 0)
1346                 return NULL;
1347
1348         txp = NULL;
1349
1350         start = di->txin;
1351         if (range == DMA_RANGE_ALL)
1352                 end = di->txout;
1353         else {
1354                 struct dma64regs *dregs = di->d64txregs;
1355
1356                 end = (u16) (B2I(((R_REG(&dregs->status0) &
1357                                  D64_XS0_CD_MASK) -
1358                                  di->xmtptrbase) & D64_XS0_CD_MASK,
1359                                  struct dma64desc));
1360
1361                 if (range == DMA_RANGE_TRANSFERED) {
1362                         active_desc =
1363                             (u16) (R_REG(&dregs->status1) &
1364                                       D64_XS1_AD_MASK);
1365                         active_desc =
1366                             (active_desc - di->xmtptrbase) & D64_XS0_CD_MASK;
1367                         active_desc = B2I(active_desc, struct dma64desc);
1368                         if (end != active_desc)
1369                                 end = prevtxd(di, active_desc);
1370                 }
1371         }
1372
1373         if ((start == 0) && (end > di->txout))
1374                 goto bogus;
1375
1376         for (i = start; i != end && !txp; i = nexttxd(di, i)) {
1377                 dma_addr_t pa;
1378                 uint size;
1379
1380                 pa = cpu_to_le32(di->txd64[i].addrlow) - di->dataoffsetlow;
1381
1382                 size =
1383                     (cpu_to_le32(di->txd64[i].ctrl2) &
1384                      D64_CTRL2_BC_MASK);
1385
1386                 di->txd64[i].addrlow = 0xdeadbeef;
1387                 di->txd64[i].addrhigh = 0xdeadbeef;
1388
1389                 txp = di->txp[i];
1390                 di->txp[i] = NULL;
1391
1392                 pci_unmap_single(di->pbus, pa, size, PCI_DMA_TODEVICE);
1393         }
1394
1395         di->txin = i;
1396
1397         /* tx flow control */
1398         di->dma.txavail = di->ntxd - ntxdactive(di, di->txin, di->txout) - 1;
1399
1400         return txp;
1401
1402  bogus:
1403         DMA_NONE(("dma_getnexttxp: bogus curr: start %d end %d txout %d "
1404                   "force %d\n", start, end, di->txout, forceall));
1405         return NULL;
1406 }
1407
1408 /*
1409  * Mac80211 initiated actions sometimes require packets in the DMA queue to be
1410  * modified. The modified portion of the packet is not under control of the DMA
1411  * engine. This function calls a caller-supplied function for each packet in
1412  * the caller specified dma chain.
1413  */
1414 void dma_walk_packets(struct dma_pub *dmah, void (*callback_fnc)
1415                       (void *pkt, void *arg_a), void *arg_a)
1416 {
1417         struct dma_info *di = (struct dma_info *) dmah;
1418         uint i =   di->txin;
1419         uint end = di->txout;
1420         struct sk_buff *skb;
1421         struct ieee80211_tx_info *tx_info;
1422
1423         while (i != end) {
1424                 skb = (struct sk_buff *)di->txp[i];
1425                 if (skb != NULL) {
1426                         tx_info = (struct ieee80211_tx_info *)skb->cb;
1427                         (callback_fnc)(tx_info, arg_a);
1428                 }
1429                 i = nexttxd(di, i);
1430         }
1431 }