← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to drivers/net/wireless/brcm80211/brcmsmac/dma.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
}