staging: brcm80211: removed packet macros for accessing sk_buff fields
authorArend van Spriel <arend@broadcom.com>
Tue, 23 Nov 2010 13:06:24 +0000 (14:06 +0100)
committerGreg Kroah-Hartman <gregkh@suse.de>
Mon, 29 Nov 2010 19:37:01 +0000 (11:37 -0800)
With the packet storage type changed from void pointer to struct sk_buff
pointer there is no need for macros for accessing these fields through
casting. These can now be accessed directly.

Reviewed-by: Brett Rudley <brudley@broadcom.com>
Signed-off-by: Arend van Spriel <arend@broadcom.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
drivers/staging/brcm80211/brcmfmac/bcmsdh_sdmmc.c
drivers/staging/brcm80211/brcmfmac/dhd_cdc.c
drivers/staging/brcm80211/brcmfmac/dhd_linux.c
drivers/staging/brcm80211/brcmfmac/dhd_sdio.c
drivers/staging/brcm80211/include/linux_osl.h
drivers/staging/brcm80211/sys/wlc_ampdu.c
drivers/staging/brcm80211/sys/wlc_bmac.c
drivers/staging/brcm80211/sys/wlc_mac80211.c
drivers/staging/brcm80211/sys/wlc_pub.h
drivers/staging/brcm80211/util/bcmutils.c
drivers/staging/brcm80211/util/hnddma.c

index 3d3a428fa279e9cfec10160035254a02047e0725..aadfe69a8a0cd6f47f3a06cdcbe2a586985c010b 100644 (file)
@@ -944,8 +944,8 @@ sdioh_request_packet(sdioh_info_t *sd, uint fix_inc, uint write, uint func,
 
        /* Claim host controller */
        sdio_claim_host(gInstance->func[func]);
-       for (pnext = pkt; pnext; pnext = PKTNEXT(pnext)) {
-               uint pkt_len = PKTLEN(pnext);
+       for (pnext = pkt; pnext; pnext = pnext->next) {
+               uint pkt_len = pnext->len;
                pkt_len += 3;
                pkt_len &= 0xFFFFFFFC;
 
@@ -962,23 +962,23 @@ sdioh_request_packet(sdioh_info_t *sd, uint fix_inc, uint write, uint func,
                 * is supposed to give
                 * us something we can work with.
                 */
-               ASSERT(((u32) (PKTDATA(pkt)) & DMA_ALIGN_MASK) == 0);
+               ASSERT(((u32) (pkt->data) & DMA_ALIGN_MASK) == 0);
 
                if ((write) && (!fifo)) {
                        err_ret = sdio_memcpy_toio(gInstance->func[func], addr,
-                                                  ((u8 *) PKTDATA(pnext)),
+                                                  ((u8 *) (pnext->data)),
                                                   pkt_len);
                } else if (write) {
                        err_ret = sdio_memcpy_toio(gInstance->func[func], addr,
-                                                  ((u8 *) PKTDATA(pnext)),
+                                                  ((u8 *) (pnext->data)),
                                                   pkt_len);
                } else if (fifo) {
                        err_ret = sdio_readsb(gInstance->func[func],
-                                             ((u8 *) PKTDATA(pnext)),
+                                             ((u8 *) (pnext->data)),
                                              addr, pkt_len);
                } else {
                        err_ret = sdio_memcpy_fromio(gInstance->func[func],
-                                                    ((u8 *) PKTDATA(pnext)),
+                                                    ((u8 *) (pnext->data)),
                                                     addr, pkt_len);
                }
 
@@ -1048,41 +1048,41 @@ sdioh_request_buffer(sdioh_info_t *sd, uint pio_dma, uint fix_inc, uint write,
 
                /* For a write, copy the buffer data into the packet. */
                if (write)
-                       bcopy(buffer, PKTDATA(mypkt), buflen_u);
+                       bcopy(buffer, mypkt->data, buflen_u);
 
                Status =
                    sdioh_request_packet(sd, fix_inc, write, func, addr, mypkt);
 
                /* For a read, copy the packet data back to the buffer. */
                if (!write)
-                       bcopy(PKTDATA(mypkt), buffer, buflen_u);
+                       bcopy(mypkt->data, buffer, buflen_u);
 
                PKTFREE(sd->osh, mypkt, write ? true : false);
-       } else if (((u32) (PKTDATA(pkt)) & DMA_ALIGN_MASK) != 0) {
+       } else if (((u32) (pkt->data) & DMA_ALIGN_MASK) != 0) {
                /* Case 2: We have a packet, but it is unaligned. */
 
                /* In this case, we cannot have a chain. */
-               ASSERT(PKTNEXT(pkt) == NULL);
+               ASSERT(pkt->next == NULL);
 
                sd_data(("%s: Creating aligned %s Packet, len=%d\n",
-                        __func__, write ? "TX" : "RX", PKTLEN(pkt)));
-               mypkt = PKTGET(sd->osh, PKTLEN(pkt), write ? true : false);
+                        __func__, write ? "TX" : "RX", pkt->len));
+               mypkt = PKTGET(sd->osh, pkt->len, write ? true : false);
                if (!mypkt) {
                        sd_err(("%s: PKTGET failed: len %d\n",
-                               __func__, PKTLEN(pkt)));
+                               __func__, pkt->len));
                        return SDIOH_API_RC_FAIL;
                }
 
                /* For a write, copy the buffer data into the packet. */
                if (write)
-                       bcopy(PKTDATA(pkt), PKTDATA(mypkt), PKTLEN(pkt));
+                       bcopy(pkt->data, mypkt->data, pkt->len);
 
                Status =
                    sdioh_request_packet(sd, fix_inc, write, func, addr, mypkt);
 
                /* For a read, copy the packet data back to the buffer. */
                if (!write)
-                       bcopy(PKTDATA(mypkt), PKTDATA(pkt), PKTLEN(mypkt));
+                       bcopy(mypkt->data, pkt->data, mypkt->len);
 
                PKTFREE(sd->osh, mypkt, write ? true : false);
        } else {                /* case 3: We have a packet and
index c23d30b13147c965410f79ddaf586a39538dde99..2fa77cb53040fd3b33db136ff4e6d63b2e112f8e 100644 (file)
@@ -323,13 +323,13 @@ void dhd_prot_hdrpush(dhd_pub_t *dhd, int ifidx, struct sk_buff *pktbuf)
 
        skb_push(pktbuf, BDC_HEADER_LEN);
 
-       h = (struct bdc_header *)PKTDATA(pktbuf);
+       h = (struct bdc_header *)(pktbuf->data);
 
        h->flags = (BDC_PROTO_VER << BDC_FLAG_VER_SHIFT);
        if (PKTSUMNEEDED(pktbuf))
                h->flags |= BDC_FLAG_SUM_NEEDED;
 
-       h->priority = (PKTPRIO(pktbuf) & BDC_PRIORITY_MASK);
+       h->priority = (pktbuf->priority & BDC_PRIORITY_MASK);
        h->flags2 = 0;
        h->rssi = 0;
 #endif                         /* BDC */
@@ -341,13 +341,13 @@ bool dhd_proto_fcinfo(dhd_pub_t *dhd, struct sk_buff *pktbuf, u8 * fcbits)
 #ifdef BDC
        struct bdc_header *h;
 
-       if (PKTLEN(pktbuf) < BDC_HEADER_LEN) {
+       if (pktbuf->len < BDC_HEADER_LEN) {
                DHD_ERROR(("%s: rx data too short (%d < %d)\n",
-                          __func__, PKTLEN(pktbuf), BDC_HEADER_LEN));
+                          __func__, pktbuf->len, BDC_HEADER_LEN));
                return BCME_ERROR;
        }
 
-       h = (struct bdc_header *)PKTDATA(pktbuf);
+       h = (struct bdc_header *)(pktbuf->data);
 
        *fcbits = h->priority >> BDC_PRIORITY_FC_SHIFT;
        if ((h->flags2 & BDC_FLAG2_FC_FLAG) == BDC_FLAG2_FC_FLAG)
@@ -367,13 +367,13 @@ int dhd_prot_hdrpull(dhd_pub_t *dhd, int *ifidx, struct sk_buff *pktbuf)
 #ifdef BDC
        /* Pop BDC header used to convey priority for buses that don't */
 
-       if (PKTLEN(pktbuf) < BDC_HEADER_LEN) {
+       if (pktbuf->len < BDC_HEADER_LEN) {
                DHD_ERROR(("%s: rx data too short (%d < %d)\n", __func__,
-                          PKTLEN(pktbuf), BDC_HEADER_LEN));
+                          pktbuf->len, BDC_HEADER_LEN));
                return BCME_ERROR;
        }
 
-       h = (struct bdc_header *)PKTDATA(pktbuf);
+       h = (struct bdc_header *)(pktbuf->data);
 
        *ifidx = BDC_GET_IF_IDX(h);
        if (*ifidx >= DHD_MAX_IFS) {
@@ -396,7 +396,7 @@ int dhd_prot_hdrpull(dhd_pub_t *dhd, int *ifidx, struct sk_buff *pktbuf)
                PKTSETSUMGOOD(pktbuf, true);
        }
 
-       PKTSETPRIO(pktbuf, (h->priority & BDC_PRIORITY_MASK));
+       pktbuf->priority = h->priority & BDC_PRIORITY_MASK;
 
        skb_pull(pktbuf, BDC_HEADER_LEN);
 #endif                         /* BDC */
index ec887fb32faa2f075943095a3b4dd3bee6c87fe7..2a502f9ab66d41f9e76a276b9cb5da392dfc87b3 100644 (file)
@@ -1028,8 +1028,8 @@ int dhd_sendpkt(dhd_pub_t *dhdp, int ifidx, struct sk_buff *pktbuf)
                return -ENODEV;
 
        /* Update multicast statistic */
-       if (PKTLEN(pktbuf) >= ETHER_ADDR_LEN) {
-               u8 *pktdata = (u8 *) PKTDATA(pktbuf);
+       if (pktbuf->len >= ETHER_ADDR_LEN) {
+               u8 *pktdata = (u8 *) (pktbuf->data);
                struct ether_header *eh = (struct ether_header *)pktdata;
 
                if (ETHER_ISMULTI(eh->ether_dhost))
@@ -1151,8 +1151,8 @@ void dhd_rx_frame(dhd_pub_t *dhdp, int ifidx, struct sk_buff *pktbuf,
 
        for (i = 0; pktbuf && i < numpkt; i++, pktbuf = pnext) {
 
-               pnext = PKTNEXT(pktbuf);
-               PKTSETNEXT(pktbuf, NULL);
+               pnext = pktbuf->next;
+               pktbuf->next = NULL;
 
                skb = PKTTONATIVE(dhdp->osh, pktbuf);
 
@@ -1233,7 +1233,7 @@ void dhd_txcomplete(dhd_pub_t *dhdp, struct sk_buff *txp, bool success)
 
        dhd_prot_hdrpull(dhdp, &ifidx, txp);
 
-       eh = (struct ether_header *)PKTDATA(txp);
+       eh = (struct ether_header *)(txp->data);
        type = ntoh16(eh->ether_type);
 
        if (type == ETHER_TYPE_802_1X)
index 12bb7c602f1f637e06f30d53923e33bce61fa20b..1d06fb2998014915bdc15b349c1bd9e80fa3ca63 100644 (file)
@@ -357,16 +357,16 @@ extern void bcmsdh_enable_hw_oob_intr(void *sdh, bool enable);
 #if defined(OOB_INTR_ONLY) && defined(SDIO_ISR_THREAD)
 #error OOB_INTR_ONLY is NOT working with SDIO_ISR_THREAD
 #endif /* defined(OOB_INTR_ONLY) && defined(SDIO_ISR_THREAD) */
-#define PKTALIGN(osh, p, len, align)                                   \
+#define PKTALIGN(_osh, _p, _len, _align)                               \
        do {                                                            \
                uint datalign;                                          \
-               datalign = (unsigned long)PKTDATA((p));                 \
-               datalign = roundup(datalign, (align)) - datalign;       \
-               ASSERT(datalign < (align));                             \
-               ASSERT(PKTLEN((p)) >= ((len) + datalign));      \
+               datalign = (unsigned long)((_p)->data);                 \
+               datalign = roundup(datalign, (_align)) - datalign;      \
+               ASSERT(datalign < (_align));                            \
+               ASSERT((_p)->len >= ((_len) + datalign));               \
                if (datalign)                                           \
-                       skb_pull((p), datalign);                        \
-               __skb_trim((p), (len));                         \
+                       skb_pull((_p), datalign);                       \
+               __skb_trim((_p), (_len));                               \
        } while (0)
 
 /* Limit on rounding up frames */
@@ -927,7 +927,7 @@ static int dhdsdio_txpkt(dhd_bus_t *bus, struct sk_buff *pkt, uint chan,
                goto done;
        }
 
-       frame = (u8 *) PKTDATA(pkt);
+       frame = (u8 *) (pkt->data);
 
        /* Add alignment padding, allocate new packet if needed */
        pad = ((unsigned long)frame % DHD_SDALIGN);
@@ -936,37 +936,37 @@ static int dhdsdio_txpkt(dhd_bus_t *bus, struct sk_buff *pkt, uint chan,
                        DHD_INFO(("%s: insufficient headroom %d for %d pad\n",
                                  __func__, (int)PKTHEADROOM(pkt), pad));
                        bus->dhd->tx_realloc++;
-                       new = PKTGET(osh, (PKTLEN(pkt) + DHD_SDALIGN), true);
+                       new = PKTGET(osh, (pkt->len + DHD_SDALIGN), true);
                        if (!new) {
                                DHD_ERROR(("%s: couldn't allocate new %d-byte "
                                        "packet\n",
-                                       __func__, PKTLEN(pkt) + DHD_SDALIGN));
+                                       __func__, pkt->len + DHD_SDALIGN));
                                ret = BCME_NOMEM;
                                goto done;
                        }
 
-                       PKTALIGN(osh, new, PKTLEN(pkt), DHD_SDALIGN);
-                       bcopy(PKTDATA(pkt), PKTDATA(new), PKTLEN(pkt));
+                       PKTALIGN(osh, new, pkt->len, DHD_SDALIGN);
+                       bcopy(pkt->data, new->data, pkt->len);
                        if (free_pkt)
                                PKTFREE(osh, pkt, true);
                        /* free the pkt if canned one is not used */
                        free_pkt = true;
                        pkt = new;
-                       frame = (u8 *) PKTDATA(pkt);
+                       frame = (u8 *) (pkt->data);
                        ASSERT(((unsigned long)frame % DHD_SDALIGN) == 0);
                        pad = 0;
                } else {
                        skb_push(pkt, pad);
-                       frame = (u8 *) PKTDATA(pkt);
+                       frame = (u8 *) (pkt->data);
 
-                       ASSERT((pad + SDPCM_HDRLEN) <= (int)PKTLEN(pkt));
+                       ASSERT((pad + SDPCM_HDRLEN) <= (int)(pkt->len));
                        bzero(frame, pad + SDPCM_HDRLEN);
                }
        }
        ASSERT(pad < DHD_SDALIGN);
 
        /* Hardware tag: 2 byte len followed by 2 byte ~len check (all LE) */
-       len = (u16) PKTLEN(pkt);
+       len = (u16) (pkt->len);
        *(u16 *) frame = htol16(len);
        *(((u16 *) frame) + 1) = htol16(~len);
 
@@ -979,7 +979,7 @@ static int dhdsdio_txpkt(dhd_bus_t *bus, struct sk_buff *pkt, uint chan,
        htol32_ua_store(0, frame + SDPCM_FRAMETAG_LEN + sizeof(swheader));
 
 #ifdef DHD_DEBUG
-       tx_packets[PKTPRIO(pkt)]++;
+       tx_packets[pkt->priority]++;
        if (DHD_BYTES_ON() &&
            (((DHD_CTL_ON() && (chan == SDPCM_CONTROL_CHANNEL)) ||
              (DHD_DATA_ON() && (chan != SDPCM_CONTROL_CHANNEL))))) {
@@ -1075,14 +1075,14 @@ int dhd_bus_txdata(struct dhd_bus *bus, struct sk_buff *pkt)
        DHD_TRACE(("%s: Enter\n", __func__));
 
        osh = bus->dhd->osh;
-       datalen = PKTLEN(pkt);
+       datalen = pkt->len;
 
 #ifdef SDTEST
        /* Push the test header if doing loopback */
        if (bus->ext_loop) {
                u8 *data;
                skb_push(pkt, SDPCM_TEST_HDRLEN);
-               data = PKTDATA(pkt);
+               data = pkt->data;
                *data++ = SDPCM_TEST_ECHOREQ;
                *data++ = (u8) bus->loopid++;
                *data++ = (datalen >> 0);
@@ -1093,9 +1093,9 @@ int dhd_bus_txdata(struct dhd_bus *bus, struct sk_buff *pkt)
 
        /* Add space for the header */
        skb_push(pkt, SDPCM_HDRLEN);
-       ASSERT(IS_ALIGNED((unsigned long)PKTDATA(pkt), 2));
+       ASSERT(IS_ALIGNED((unsigned long)(pkt->data), 2));
 
-       prec = PRIO2PREC((PKTPRIO(pkt) & PRIOMASK));
+       prec = PRIO2PREC((pkt->priority & PRIOMASK));
 
        /* Check for existing queue, current flow-control,
                         pending event, or pending clock */
@@ -1191,7 +1191,7 @@ static uint dhdsdio_sendfromq(dhd_bus_t *bus, uint maxframes)
                        break;
                }
                dhd_os_sdunlock_txq(bus->dhd);
-               datalen = PKTLEN(pkt) - SDPCM_HDRLEN;
+               datalen = pkt->len - SDPCM_HDRLEN;
 
 #ifndef SDTEST
                ret = dhdsdio_txpkt(bus, pkt, SDPCM_DATA_CHANNEL, true);
@@ -3204,8 +3204,8 @@ static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
                dhd_os_sdlock_rxq(bus->dhd);
 
                pfirst = plast = pnext = NULL;
-               dlen = (u16) PKTLEN(bus->glomd);
-               dptr = PKTDATA(bus->glomd);
+               dlen = (u16) (bus->glomd->len);
+               dptr = bus->glomd->data;
                if (!dlen || (dlen & 1)) {
                        DHD_ERROR(("%s: bad glomd len(%d), ignore descriptor\n",
                        __func__, dlen));
@@ -3246,13 +3246,13 @@ static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
                                           __func__, num, sublen));
                                break;
                        }
-                       ASSERT(!PKTLINK(pnext));
+                       ASSERT(!(pnext->prev));
                        if (!pfirst) {
                                ASSERT(!plast);
                                pfirst = plast = pnext;
                        } else {
                                ASSERT(plast);
-                               PKTSETNEXT(plast, pnext);
+                               plast->next = pnext;
                                plast = pnext;
                        }
 
@@ -3295,10 +3295,10 @@ static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
                if (DHD_GLOM_ON()) {
                        DHD_GLOM(("%s: try superframe read, packet chain:\n",
                                __func__));
-                       for (pnext = bus->glom; pnext; pnext = PKTNEXT(pnext)) {
+                       for (pnext = bus->glom; pnext; pnext = pnext->next) {
                                DHD_GLOM(("    %p: %p len 0x%04x (%d)\n",
-                                         pnext, (u8 *) PKTDATA(pnext),
-                                         PKTLEN(pnext), PKTLEN(pnext)));
+                                         pnext, (u8 *) (pnext->data),
+                                         pnext->len, pnext->len));
                        }
                }
 
@@ -3314,7 +3314,7 @@ static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
                                                      bcmsdh_cur_sbwad
                                                      (bus->sdh), SDIO_FUNC_2,
                                                      F2SYNC,
-                                                     (u8 *) PKTDATA(pfirst),
+                                                     (u8 *) pfirst->data,
                                                      dlen, pfirst, NULL, NULL);
                } else if (bus->dataptr) {
                        errcode = dhd_bcmsdh_recv_buf(bus,
@@ -3360,13 +3360,13 @@ static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
                }
 #ifdef DHD_DEBUG
                if (DHD_GLOM_ON()) {
-                       prhex("SUPERFRAME", PKTDATA(pfirst),
-                             min_t(int, PKTLEN(pfirst), 48));
+                       prhex("SUPERFRAME", pfirst->data,
+                             min_t(int, pfirst->len, 48));
                }
 #endif
 
                /* Validate the superframe header */
-               dptr = (u8 *) PKTDATA(pfirst);
+               dptr = (u8 *) (pfirst->data);
                sublen = ltoh16_ua(dptr);
                check = ltoh16_ua(dptr + sizeof(u16));
 
@@ -3404,11 +3404,11 @@ static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
                                   __func__));
                        errcode = -1;
                } else if ((doff < SDPCM_HDRLEN) ||
-                          (doff > (PKTLEN(pfirst) - SDPCM_HDRLEN))) {
+                          (doff > (pfirst->len - SDPCM_HDRLEN))) {
                        DHD_ERROR(("%s (superframe): Bad data offset %d: HW %d "
                                "pkt %d min %d\n",
                                __func__, doff, sublen,
-                               PKTLEN(pfirst), SDPCM_HDRLEN));
+                               pfirst->len, SDPCM_HDRLEN));
                        errcode = -1;
                }
 
@@ -3434,9 +3434,9 @@ static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
 
                /* Validate all the subframe headers */
                for (num = 0, pnext = pfirst; pnext && !errcode;
-                    num++, pnext = PKTNEXT(pnext)) {
-                       dptr = (u8 *) PKTDATA(pnext);
-                       dlen = (u16) PKTLEN(pnext);
+                    num++, pnext = pnext->next) {
+                       dptr = (u8 *) (pnext->data);
+                       dlen = (u16) (pnext->len);
                        sublen = ltoh16_ua(dptr);
                        check = ltoh16_ua(dptr + sizeof(u16));
                        chan = SDPCM_PACKET_CHANNEL(&dptr[SDPCM_FRAMETAG_LEN]);
@@ -3496,10 +3496,10 @@ static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
 
                dhd_os_sdlock_rxq(bus->dhd);
                for (num = 0; pfirst; rxseq++, pfirst = pnext) {
-                       pnext = PKTNEXT(pfirst);
-                       PKTSETNEXT(pfirst, NULL);
+                       pnext = pfirst->next;
+                       pfirst->next = NULL;
 
-                       dptr = (u8 *) PKTDATA(pfirst);
+                       dptr = (u8 *) (pfirst->data);
                        sublen = ltoh16_ua(dptr);
                        chan = SDPCM_PACKET_CHANNEL(&dptr[SDPCM_FRAMETAG_LEN]);
                        seq = SDPCM_PACKET_SEQUENCE(&dptr[SDPCM_FRAMETAG_LEN]);
@@ -3507,8 +3507,8 @@ static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
 
                        DHD_GLOM(("%s: Get subframe %d, %p(%p/%d), sublen %d "
                                "chan %d seq %d\n",
-                               __func__, num, pfirst, PKTDATA(pfirst),
-                               PKTLEN(pfirst), sublen, chan, seq));
+                               __func__, num, pfirst, pfirst->data,
+                               pfirst->len, sublen, chan, seq));
 
                        ASSERT((chan == SDPCM_DATA_CHANNEL)
                               || (chan == SDPCM_EVENT_CHANNEL));
@@ -3527,10 +3527,10 @@ static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
                        __skb_trim(pfirst, sublen);
                        skb_pull(pfirst, doff);
 
-                       if (PKTLEN(pfirst) == 0) {
+                       if (pfirst->len == 0) {
                                PKTFREE(bus->dhd->osh, pfirst, false);
                                if (plast) {
-                                       PKTSETNEXT(plast, pnext);
+                                       plast->next = pnext;
                                } else {
                                        ASSERT(save_pfirst == pfirst);
                                        save_pfirst = pnext;
@@ -3543,7 +3543,7 @@ static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
                                bus->dhd->rx_errors++;
                                PKTFREE(osh, pfirst, false);
                                if (plast) {
-                                       PKTSETNEXT(plast, pnext);
+                                       plast->next = pnext;
                                } else {
                                        ASSERT(save_pfirst == pfirst);
                                        save_pfirst = pnext;
@@ -3553,7 +3553,7 @@ static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
 
                        /* this packet will go up, link back into
                                 chain and count it */
-                       PKTSETNEXT(pfirst, pnext);
+                       pfirst->next = pnext;
                        plast = pfirst;
                        num++;
 
@@ -3561,11 +3561,11 @@ static u8 dhdsdio_rxglom(dhd_bus_t *bus, u8 rxseq)
                        if (DHD_GLOM_ON()) {
                                DHD_GLOM(("%s subframe %d to stack, %p(%p/%d) "
                                "nxt/lnk %p/%p\n",
-                               __func__, num, pfirst, PKTDATA(pfirst),
-                               PKTLEN(pfirst), PKTNEXT(pfirst),
-                               PKTLINK(pfirst)));
-                               prhex("", (u8 *) PKTDATA(pfirst),
-                                     min_t(int, PKTLEN(pfirst), 32));
+                               __func__, num, pfirst, pfirst->data,
+                               pfirst->len, pfirst->next,
+                               pfirst->prev));
+                               prhex("", (u8 *) pfirst->data,
+                                     min_t(int, pfirst->len, 32));
                        }
 #endif                         /* DHD_DEBUG */
                }
@@ -3737,9 +3737,9 @@ static uint dhdsdio_readframes(dhd_bus_t *bus, uint maxframes, bool *finished)
                                if (bus->bus == SPI_BUS)
                                        bus->usebufpool = true;
 
-                               ASSERT(!PKTLINK(pkt));
+                               ASSERT(!(pkt->prev));
                                PKTALIGN(osh, pkt, rdlen, DHD_SDALIGN);
-                               rxbuf = (u8 *) PKTDATA(pkt);
+                               rxbuf = (u8 *) (pkt->data);
                                /* Read the entire frame */
                                sdret =
                                    dhd_bcmsdh_recv_buf(bus,
@@ -4103,17 +4103,17 @@ static uint dhdsdio_readframes(dhd_bus_t *bus, uint maxframes, bool *finished)
                }
                dhd_os_sdunlock_rxq(bus->dhd);
 
-               ASSERT(!PKTLINK(pkt));
+               ASSERT(!(pkt->prev));
 
                /* Leave room for what we already read, and align remainder */
-               ASSERT(firstread < (PKTLEN(pkt)));
+               ASSERT(firstread < pkt->len);
                skb_pull(pkt, firstread);
                PKTALIGN(osh, pkt, rdlen, DHD_SDALIGN);
 
                /* Read the remaining frame data */
                sdret =
                    dhd_bcmsdh_recv_buf(bus, bcmsdh_cur_sbwad(sdh), SDIO_FUNC_2,
-                                       F2SYNC, ((u8 *) PKTDATA(pkt)), rdlen,
+                                       F2SYNC, ((u8 *) (pkt->data)), rdlen,
                                        pkt, NULL, NULL);
                bus->f2rxdata++;
                ASSERT(sdret != BCME_PENDING);
@@ -4136,11 +4136,11 @@ static uint dhdsdio_readframes(dhd_bus_t *bus, uint maxframes, bool *finished)
 
                /* Copy the already-read portion */
                skb_push(pkt, firstread);
-               bcopy(bus->rxhdr, PKTDATA(pkt), firstread);
+               bcopy(bus->rxhdr, pkt->data, firstread);
 
 #ifdef DHD_DEBUG
                if (DHD_BYTES_ON() && DHD_DATA_ON())
-                       prhex("Rx Data", PKTDATA(pkt), len);
+                       prhex("Rx Data", pkt->data, len);
 #endif
 
 deliver:
@@ -4151,7 +4151,7 @@ deliver:
                                        __func__, len));
 #ifdef DHD_DEBUG
                                if (DHD_GLOM_ON()) {
-                                       prhex("Glom Data", PKTDATA(pkt), len);
+                                       prhex("Glom Data", pkt->data, len);
                                }
 #endif
                                __skb_trim(pkt, len);
@@ -4178,7 +4178,7 @@ deliver:
                }
 #endif                         /* SDTEST */
 
-               if (PKTLEN(pkt) == 0) {
+               if (pkt->len == 0) {
                        dhd_os_sdlock_rxq(bus->dhd);
                        PKTFREE(bus->dhd->osh, pkt, false);
                        dhd_os_sdunlock_rxq(bus->dhd);
@@ -4672,7 +4672,7 @@ static void dhdsdio_pktgen(dhd_bus_t *bus)
                }
                PKTALIGN(osh, pkt, (len + SDPCM_HDRLEN + SDPCM_TEST_HDRLEN),
                         DHD_SDALIGN);
-               data = (u8 *) PKTDATA(pkt) + SDPCM_HDRLEN;
+               data = (u8 *) (pkt->data) + SDPCM_HDRLEN;
 
                /* Write test header cmd and extra based on mode */
                switch (bus->pktgen_mode) {
@@ -4711,9 +4711,9 @@ static void dhdsdio_pktgen(dhd_bus_t *bus)
 
 #ifdef DHD_DEBUG
                if (DHD_BYTES_ON() && DHD_DATA_ON()) {
-                       data = (u8 *) PKTDATA(pkt) + SDPCM_HDRLEN;
+                       data = (u8 *) (pkt->data) + SDPCM_HDRLEN;
                        prhex("dhdsdio_pktgen: Tx Data", data,
-                             PKTLEN(pkt) - SDPCM_HDRLEN);
+                             pkt->len - SDPCM_HDRLEN);
                }
 #endif
 
@@ -4750,7 +4750,7 @@ static void dhdsdio_sdtest_set(dhd_bus_t *bus, bool start)
                return;
        }
        PKTALIGN(osh, pkt, (SDPCM_HDRLEN + SDPCM_TEST_HDRLEN), DHD_SDALIGN);
-       data = (u8 *) PKTDATA(pkt) + SDPCM_HDRLEN;
+       data = (u8 *) (pkt->data) + SDPCM_HDRLEN;
 
        /* Fill in the test header */
        *data++ = SDPCM_TEST_SEND;
@@ -4775,7 +4775,7 @@ static void dhdsdio_testrcv(dhd_bus_t *bus, struct sk_buff *pkt, uint seq)
        u16 offset;
 
        /* Check for min length */
-       pktlen = PKTLEN(pkt);
+       pktlen = pkt->len;
        if (pktlen < SDPCM_TEST_HDRLEN) {
                DHD_ERROR(("dhdsdio_restrcv: toss runt frame, pktlen %d\n",
                           pktlen));
@@ -4784,7 +4784,7 @@ static void dhdsdio_testrcv(dhd_bus_t *bus, struct sk_buff *pkt, uint seq)
        }
 
        /* Extract header fields */
-       data = PKTDATA(pkt);
+       data = pkt->data;
        cmd = *data++;
        extra = *data++;
        len = *data++;
@@ -4807,7 +4807,7 @@ static void dhdsdio_testrcv(dhd_bus_t *bus, struct sk_buff *pkt, uint seq)
        case SDPCM_TEST_ECHOREQ:
                /* Rx->Tx turnaround ok (even on NDIS w/current
                         implementation) */
-               *(u8 *) (PKTDATA(pkt)) = SDPCM_TEST_ECHORSP;
+               *(u8 *) (pkt->data) = SDPCM_TEST_ECHORSP;
                if (dhdsdio_txpkt(bus, pkt, SDPCM_TEST_CHANNEL, true) == 0) {
                        bus->pktgen_sent++;
                } else {
index 010182fa1a9220033cd2388490bac49e0962db77..4e446606b5c10efe2042480b1e78f880481646f8 100644 (file)
@@ -246,15 +246,10 @@ extern void osl_dma_unmap(struct osl_info *osh, uint pa, uint size,
 #define        BZERO_SM(r, len)        memset((r), '\0', (len))
 
 /* packet primitives */
-#define        PKTGET(osh, len, send)          osl_pktget((osh), (len))
-#define        PKTFREE(osh, skb, send)         osl_pktfree((osh), (skb), (send))
-#define        PKTDATA(skb)            (((struct sk_buff *)(skb))->data)
-#define        PKTLEN(skb)             (((struct sk_buff *)(skb))->len)
-#define PKTHEADROOM(skb)               (PKTDATA(skb)-(((struct sk_buff *)(skb))->head))
-#define PKTTAILROOM(skb) ((((struct sk_buff *)(skb))->end)-(((struct sk_buff *)(skb))->tail))
-#define        PKTNEXT(skb)            (((struct sk_buff *)(skb))->next)
-#define        PKTSETNEXT(skb, x)      \
-       (((struct sk_buff *)(skb))->next = (struct sk_buff *)(x))
+#define        PKTGET(osh, len, send)  osl_pktget((osh), (len))
+#define        PKTFREE(osh, skb, send) osl_pktfree((osh), (skb), (send))
+#define PKTHEADROOM(skb)       ((skb)->data - (skb)->head)
+#define PKTTAILROOM(skb)       ((skb)->end - (skb)->tail)
 #define PKTALLOCED(osh)                (((struct osl_pubinfo *)(osh))->pktalloced)
 extern void *osl_pktget(struct osl_info *osh, uint len);
 extern void osl_pktfree(struct osl_info *osh, void *skb, bool send);
@@ -293,14 +288,9 @@ osl_pkt_tonative(struct osl_pubinfo *osh, void *pkt)
 #define        PKTSKIPCT(osh, skb)
 #endif /* BRCM_FULLMAC */
 
-#define        PKTLINK(skb)                    (((struct sk_buff *)(skb))->prev)
-#define        PKTSETLINK(skb, x)              (((struct sk_buff *)(skb))->prev = (struct sk_buff*)(x))
-#define        PKTPRIO(skb)                    (((struct sk_buff *)(skb))->priority)
-#define        PKTSETPRIO(skb, x)              (((struct sk_buff *)(skb))->priority = (x))
 #define PKTSUMNEEDED(skb)              (((struct sk_buff *)(skb))->ip_summed == CHECKSUM_PARTIAL)
 #define PKTSETSUMGOOD(skb, x)          (((struct sk_buff *)(skb))->ip_summed = \
                                                ((x) ? CHECKSUM_UNNECESSARY : CHECKSUM_NONE))
 /* PKTSETSUMNEEDED and PKTSUMGOOD are not possible because skb->ip_summed is overloaded */
-#define PKTSHARED(skb)                  (((struct sk_buff *)(skb))->cloned)
 
 #endif                         /* _linux_osl_h_ */
index f2acda77d47b73bf7118890cbfc39a378eaa047c..c5ab4a459471beca74c9101900cb00e9cd701549 100644 (file)
@@ -153,7 +153,7 @@ static inline u16 pkt_txh_seqnum(wlc_info_t *wlc, struct sk_buff *p)
 {
        d11txh_t *txh;
        struct dot11_header *h;
-       txh = (d11txh_t *) PKTDATA(p);
+       txh = (d11txh_t *) p->data;
        h = (struct dot11_header *)((u8 *) (txh + 1) + D11_PHY_HDR_LEN);
        return ltoh16(h->seq) >> SEQNUM_SHIFT;
 }
@@ -475,7 +475,7 @@ wlc_ampdu_agg(ampdu_info_t *ampdu, struct scb *scb, struct sk_buff *p,
 {
        scb_ampdu_t *scb_ampdu;
        scb_ampdu_tid_ini_t *ini;
-       u8 tid = (u8) PKTPRIO(p);
+       u8 tid = (u8) (p->priority);
 
        scb_ampdu = SCB_AMPDU_CUBBY(ampdu, scb);
 
@@ -529,7 +529,7 @@ wlc_sendampdu(ampdu_info_t *ampdu, wlc_txq_info_t *qi, struct sk_buff **pdu,
 
        ASSERT(p);
 
-       tid = (u8) PKTPRIO(p);
+       tid = (u8) (p->priority);
        ASSERT(tid < AMPDU_MAX_SCB_TID);
 
        f = ampdu->fifo_tb + prio2fifo[tid];
@@ -589,7 +589,7 @@ wlc_sendampdu(ampdu_info_t *ampdu, wlc_txq_info_t *qi, struct sk_buff **pdu,
 
                /* pkt is good to be aggregated */
                ASSERT(tx_info->flags & IEEE80211_TX_CTL_AMPDU);
-               txh = (d11txh_t *) PKTDATA(p);
+               txh = (d11txh_t *) p->data;
                plcp = (u8 *) (txh + 1);
                h = (struct dot11_header *)(plcp + D11_PHY_HDR_LEN);
                seq = ltoh16(h->seq) >> SEQNUM_SHIFT;
@@ -744,7 +744,7 @@ wlc_sendampdu(ampdu_info_t *ampdu, wlc_txq_info_t *qi, struct sk_buff **pdu,
 
                if (p) {
                        if ((tx_info->flags & IEEE80211_TX_CTL_AMPDU) &&
-                           ((u8) PKTPRIO(p) == tid)) {
+                           ((u8) (p->priority) == tid)) {
 
                                plen =
                                    pkttotlen(osh, p) + AMPDU_MAX_MPDU_OVERHEAD;
@@ -778,7 +778,7 @@ wlc_sendampdu(ampdu_info_t *ampdu, wlc_txq_info_t *qi, struct sk_buff **pdu,
                WLCNTADD(ampdu->cnt->txmpdu, count);
 
                /* patch up the last txh */
-               txh = (d11txh_t *) PKTDATA(pkt[count - 1]);
+               txh = (d11txh_t *) pkt[count - 1]->data;
                mcl = ltoh16(txh->MacTxControlLow);
                mcl &= ~TXC_AMPDU_MASK;
                mcl |= (TXC_AMPDU_LAST << TXC_AMPDU_SHIFT);
@@ -796,7 +796,7 @@ wlc_sendampdu(ampdu_info_t *ampdu, wlc_txq_info_t *qi, struct sk_buff **pdu,
                ampdu_len -= roundup(len, 4) - len;
 
                /* patch up the first txh & plcp */
-               txh = (d11txh_t *) PKTDATA(pkt[0]);
+               txh = (d11txh_t *) pkt[0]->data;
                plcp = (u8 *) (txh + 1);
 
                WLC_SET_MIMO_PLCP_LEN(plcp, ampdu_len);
@@ -901,7 +901,7 @@ wlc_ampdu_dotxstatus(ampdu_info_t *ampdu, struct scb *scb, struct sk_buff *p,
        ASSERT(txs->status & TX_STATUS_AMPDU);
        scb_ampdu = SCB_AMPDU_CUBBY(ampdu, scb);
        ASSERT(scb_ampdu);
-       ini = SCB_AMPDU_INI(scb_ampdu, PKTPRIO(p));
+       ini = SCB_AMPDU_INI(scb_ampdu, p->priority);
        ASSERT(ini->scb == scb);
 
        /* BMAC_NOTE: For the split driver, second level txstatus comes later
@@ -985,7 +985,7 @@ wlc_ampdu_dotxstatus_complete(ampdu_info_t *ampdu, struct scb *scb,
        scb_ampdu = SCB_AMPDU_CUBBY(ampdu, scb);
        ASSERT(scb_ampdu);
 
-       tid = (u8) PKTPRIO(p);
+       tid = (u8) (p->priority);
 
        ini = SCB_AMPDU_INI(scb_ampdu, tid);
        retry_limit = ampdu->retry_limit_tid[tid];
@@ -1065,7 +1065,7 @@ wlc_ampdu_dotxstatus_complete(ampdu_info_t *ampdu, struct scb *scb,
 #ifdef BCMDBG
                        if (WL_ERROR_ON()) {
                                prpkt("txpkt (AMPDU)", wlc->osh, p);
-                               wlc_print_txdesc((d11txh_t *) PKTDATA(p));
+                               wlc_print_txdesc((d11txh_t *) p->data);
                                wlc_print_txstatus(txs);
                        }
 #endif                         /* BCMDBG */
@@ -1076,7 +1076,7 @@ wlc_ampdu_dotxstatus_complete(ampdu_info_t *ampdu, struct scb *scb,
        while (p) {
                tx_info = IEEE80211_SKB_CB(p);
                ASSERT(tx_info->flags & IEEE80211_TX_CTL_AMPDU);
-               txh = (d11txh_t *) PKTDATA(p);
+               txh = (d11txh_t *) p->data;
                mcl = ltoh16(txh->MacTxControlLow);
                plcp = (u8 *) (txh + 1);
                h = (struct dot11_header *)(plcp + D11_PHY_HDR_LEN);
index 2a2ad494746d64c1686db7825172319b16d77ffe..264389f788f1bb5ce0607dcdef5eb14336f251a7 100644 (file)
@@ -285,7 +285,7 @@ wlc_bmac_recv(wlc_hw_info_t *wlc_hw, uint fifo, bool bound)
                if (!tail)
                        head = tail = p;
                else {
-                       PKTSETLINK(tail, p);
+                       tail->prev = p;
                        tail = p;
                }
 
@@ -302,11 +302,11 @@ wlc_bmac_recv(wlc_hw_info_t *wlc_hw, uint fifo, bool bound)
 
        /* process each frame */
        while ((p = head) != NULL) {
-               head = PKTLINK(head);
-               PKTSETLINK(p, NULL);
+               head = head->prev;
+               p->prev = NULL;
 
                /* record the tsf_l in wlc_rxd11hdr */
-               wlc_rxhdr = (wlc_d11rxhdr_t *) PKTDATA(p);
+               wlc_rxhdr = (wlc_d11rxhdr_t *) p->data;
                wlc_rxhdr->tsf_l = htol32(tsf_l);
 
                /* compute the RSSI from d11rxhdr and record it in wlc_rxd11hr */
@@ -3327,7 +3327,7 @@ static bool wlc_bmac_txstatus_corerev4(wlc_hw_info_t *wlc_hw)
 
        while (!fatal && (status_p = dma_rx(wlc_hw->di[RX_TXSTATUS_FIFO]))) {
 
-               txs = (tx_status_t *) PKTDATA(status_p);
+               txs = (tx_status_t *) status_p->data;
                /* MAC uses little endian only */
                ltoh16_buf((void *)txs, sizeof(tx_status_t));
 
index d99fcb524d54f473d4361a1b482b924c8fc9bf28..52e4d95a5cb15a142db3a5daaf8aa13ddd93641e 100644 (file)
@@ -5042,9 +5042,9 @@ wlc_prec_enq_head(wlc_info_t *wlc, struct pktq *q, struct sk_buff *pkt,
                /* Increment wme stats */
                if (WME_ENAB(wlc->pub)) {
                        WLCNTINCR(wlc->pub->_wme_cnt->
-                                 tx_failed[WME_PRIO2AC(PKTPRIO(p))].packets);
+                                 tx_failed[WME_PRIO2AC(p->priority)].packets);
                        WLCNTADD(wlc->pub->_wme_cnt->
-                                tx_failed[WME_PRIO2AC(PKTPRIO(p))].bytes,
+                                tx_failed[WME_PRIO2AC(p->priority)].bytes,
                                 pkttotlen(wlc->osh, p));
                }
 
@@ -5071,7 +5071,7 @@ void BCMFASTPATH wlc_txq_enq(void *ctx, struct scb *scb, struct sk_buff *sdu,
        struct pktq *q = &qi->q;
        int prio;
 
-       prio = PKTPRIO(sdu);
+       prio = sdu->priority;
 
        ASSERT(pktq_max(q) >= wlc->pub->tunables->datahiwat);
 
@@ -5111,7 +5111,7 @@ wlc_sendpkt_mac80211(wlc_info_t *wlc, struct sk_buff *sdu,
        uint fifo;
        void *pkt;
        struct scb *scb = &global_scb;
-       struct dot11_header *d11_header = (struct dot11_header *)PKTDATA(sdu);
+       struct dot11_header *d11_header = (struct dot11_header *)(sdu->data);
        u16 type, fc;
 
        ASSERT(sdu);
@@ -5120,13 +5120,13 @@ wlc_sendpkt_mac80211(wlc_info_t *wlc, struct sk_buff *sdu,
        type = FC_TYPE(fc);
 
        /* 802.11 standard requires management traffic to go at highest priority */
-       prio = (type == FC_TYPE_DATA ? PKTPRIO(sdu) : MAXPRIO);
+       prio = (type == FC_TYPE_DATA ? sdu->priority : MAXPRIO);
        fifo = prio2fifo[prio];
 
        ASSERT((uint) PKTHEADROOM(sdu) >= TXOFF);
-       ASSERT(!PKTSHARED(sdu));
-       ASSERT(!PKTNEXT(sdu));
-       ASSERT(!PKTLINK(sdu));
+       ASSERT(!(sdu->cloned));
+       ASSERT(!(sdu->next));
+       ASSERT(!(sdu->prev));
        ASSERT(fifo < NFIFO);
 
        pkt = sdu;
@@ -5236,7 +5236,7 @@ wlc_txfifo(wlc_info_t *wlc, uint fifo, struct sk_buff *p, bool commit,
        d11txh_t *txh;
 
        ASSERT(fifo < NFIFO);
-       txh = (d11txh_t *) PKTDATA(p);
+       txh = (d11txh_t *) (p->data);
 
        /* When a BC/MC frame is being committed to the BCMC fifo via DMA (NOT PIO), update
         * ucode or BSS info as appropriate.
@@ -5690,7 +5690,7 @@ wlc_d11hdrs_mac80211(wlc_info_t *wlc, struct ieee80211_hw *hw,
        osh = wlc->osh;
 
        /* locate 802.11 MAC header */
-       h = (struct dot11_header *)PKTDATA(p);
+       h = (struct dot11_header *)(p->data);
        fc = ltoh16(h->fc);
        type = FC_TYPE(fc);
 
@@ -5731,12 +5731,12 @@ wlc_d11hdrs_mac80211(wlc_info_t *wlc, struct ieee80211_hw *hw,
                } else {
                        /* Increment the counter for first fragment */
                        if (tx_info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT) {
-                               SCB_SEQNUM(scb, PKTPRIO(p))++;
+                               SCB_SEQNUM(scb, p->priority)++;
                        }
 
                        /* extract fragment number from frame first */
                        seq = ltoh16(seq) & FRAGNUM_MASK;
-                       seq |= (SCB_SEQNUM(scb, PKTPRIO(p)) << SEQNUM_SHIFT);
+                       seq |= (SCB_SEQNUM(scb, p->priority) << SEQNUM_SHIFT);
                        h->seq = htol16(seq);
 
                        frameid = ((seq << TXFID_SEQ_SHIFT) & TXFID_SEQ_MASK) |
@@ -6559,7 +6559,7 @@ wlc_dotxstatus(wlc_info_t *wlc, tx_status_t *txs, u32 frm_tx2)
        if (p == NULL)
                goto fatal;
 
-       txh = (d11txh_t *) PKTDATA(p);
+       txh = (d11txh_t *) (p->data);
        mcl = ltoh16(txh->MacTxControlLow);
 
        if (txs->phyerr) {
@@ -6649,8 +6649,8 @@ wlc_dotxstatus(wlc_info_t *wlc, tx_status_t *txs, u32 frm_tx2)
        wlc_txfifo_complete(wlc, queue, 1);
 
        if (lastframe) {
-               PKTSETNEXT(p, NULL);
-               PKTSETLINK(p, NULL);
+               p->next = NULL;
+               p->prev = NULL;
                wlc->txretried = 0;
                /* remove PLCP & Broadcom tx descriptor header */
                skb_pull(p, D11_PHY_HDR_LEN);
@@ -6825,7 +6825,7 @@ prep_mac80211_status(wlc_info_t *wlc, d11rxhdr_t *rxh, struct sk_buff *p,
        /* qual */
        rx_status->antenna = (rxh->PhyRxStatus_0 & PRXS0_RXANT_UPSUBBAND) ? 1 : 0;      /* ant */
 
-       plcp = PKTDATA(p);
+       plcp = p->data;
 
        rspec = wlc_compute_rspec(rxh, plcp);
        if (IS_MCS(rspec)) {
@@ -6920,12 +6920,12 @@ wlc_recvctl(wlc_info_t *wlc, struct osl_info *osh, d11rxhdr_t *rxh,
        prep_mac80211_status(wlc, rxh, p, &rx_status);
 
        /* mac header+body length, exclude CRC and plcp header */
-       len_mpdu = PKTLEN(p) - D11_PHY_HDR_LEN - DOT11_FCS_LEN;
+       len_mpdu = p->len - D11_PHY_HDR_LEN - DOT11_FCS_LEN;
        skb_pull(p, D11_PHY_HDR_LEN);
        __skb_trim(p, len_mpdu);
 
-       ASSERT(!PKTNEXT(p));
-       ASSERT(!PKTLINK(p));
+       ASSERT(!(p->next));
+       ASSERT(!(p->prev));
 
        ASSERT(IS_ALIGNED((unsigned long)skb->data, 2));
 
@@ -6980,7 +6980,7 @@ void BCMFASTPATH wlc_recv(wlc_info_t *wlc, struct sk_buff *p)
        osh = wlc->osh;
 
        /* frame starts with rxhdr */
-       rxh = (d11rxhdr_t *) PKTDATA(p);
+       rxh = (d11rxhdr_t *) (p->data);
 
        /* strip off rxhdr */
        skb_pull(p, wlc->hwrxoff);
@@ -6990,17 +6990,17 @@ void BCMFASTPATH wlc_recv(wlc_info_t *wlc, struct sk_buff *p)
 
        /* MAC inserts 2 pad bytes for a4 headers or QoS or A-MSDU subframes */
        if (rxh->RxStatus1 & RXS_PBPRES) {
-               if (PKTLEN(p) < 2) {
+               if (p->len < 2) {
                        WLCNTINCR(wlc->pub->_cnt->rxrunt);
                        WL_ERROR(("wl%d: wlc_recv: rcvd runt of len %d\n",
-                                 wlc->pub->unit, PKTLEN(p)));
+                                 wlc->pub->unit, p->len));
                        goto toss;
                }
                skb_pull(p, 2);
        }
 
-       h = (struct dot11_header *)(PKTDATA(p) + D11_PHY_HDR_LEN);
-       len = PKTLEN(p);
+       h = (struct dot11_header *)(p->data + D11_PHY_HDR_LEN);
+       len = p->len;
 
        if (rxh->RxStatus1 & RXS_FCSERR) {
                if (wlc->pub->mac80211_state & MAC80211_PROMISC_BCNS) {
@@ -7804,7 +7804,7 @@ int wlc_prep_pdu(wlc_info_t *wlc, struct sk_buff *pdu, uint *fifop)
        osh = wlc->osh;
 
        ASSERT(pdu);
-       txh = (d11txh_t *) PKTDATA(pdu);
+       txh = (d11txh_t *) (pdu->data);
        ASSERT(txh);
        h = (struct dot11_header *)((u8 *) (txh + 1) + D11_PHY_HDR_LEN);
        ASSERT(h);
index b3ad4c0233ab7062d8626419309051c1bf5d88fe..ea796cb40b7ae34cfcd7153bf98052723001d1d4 100644 (file)
@@ -440,7 +440,7 @@ struct wlc_if;
 
 #define        WLC_PREC_COUNT          16      /* Max precedence level implemented */
 
-/* pri is PKTPRIO encoded in the packet. This maps the Packet priority to
+/* pri is priority encoded in the packet. This maps the Packet priority to
  * enqueue precedence as defined in wlc_prec_map
  */
 extern const u8 wlc_prio2prec_map[];
index 701ea0170933ef38711c64f2e327fc69db14a285..49c1f74dda830a32855b4876f226ca884107e319 100644 (file)
@@ -39,19 +39,19 @@ uint pktfrombuf(struct osl_info *osh, struct sk_buff *p, uint offset, int len,
        uint n, ret = 0;
 
        /* skip 'offset' bytes */
-       for (; p && offset; p = PKTNEXT(p)) {
-               if (offset < (uint) PKTLEN(p))
+       for (; p && offset; p = p->next) {
+               if (offset < (uint) (p->len))
                        break;
-               offset -= PKTLEN(p);
+               offset -= p->len;
        }
 
        if (!p)
                return 0;
 
        /* copy the data */
-       for (; p && len; p = PKTNEXT(p)) {
-               n = min((uint) PKTLEN(p) - offset, (uint) len);
-               bcopy(buf, PKTDATA(p) + offset, n);
+       for (; p && len; p = p->next) {
+               n = min((uint) (p->len) - offset, (uint) len);
+               bcopy(buf, p->data + offset, n);
                buf += n;
                len -= n;
                ret += n;
@@ -66,8 +66,8 @@ uint BCMFASTPATH pkttotlen(struct osl_info *osh, struct sk_buff *p)
        uint total;
 
        total = 0;
-       for (; p; p = PKTNEXT(p))
-               total += PKTLEN(p);
+       for (; p; p = p->next)
+               total += p->len;
        return total;
 }
 
@@ -81,7 +81,7 @@ struct sk_buff *BCMFASTPATH pktq_penq(struct pktq *pq, int prec,
        struct pktq_prec *q;
 
        ASSERT(prec >= 0 && prec < pq->num_prec);
-       ASSERT(PKTLINK(p) == NULL);     /* queueing chains not allowed */
+       ASSERT(p->prev == NULL);        /* queueing chains not allowed */
 
        ASSERT(!pktq_full(pq));
        ASSERT(!pktq_pfull(pq, prec));
@@ -89,7 +89,7 @@ struct sk_buff *BCMFASTPATH pktq_penq(struct pktq *pq, int prec,
        q = &pq->q[prec];
 
        if (q->head)
-               PKTSETLINK(q->tail, p);
+               q->tail->prev = p;
        else
                q->head = p;
 
@@ -110,7 +110,7 @@ struct sk_buff *BCMFASTPATH pktq_penq_head(struct pktq *pq, int prec,
        struct pktq_prec *q;
 
        ASSERT(prec >= 0 && prec < pq->num_prec);
-       ASSERT(PKTLINK(p) == NULL);     /* queueing chains not allowed */
+       ASSERT(p->prev == NULL);        /* queueing chains not allowed */
 
        ASSERT(!pktq_full(pq));
        ASSERT(!pktq_pfull(pq, prec));
@@ -120,7 +120,7 @@ struct sk_buff *BCMFASTPATH pktq_penq_head(struct pktq *pq, int prec,
        if (q->head == NULL)
                q->tail = p;
 
-       PKTSETLINK(p, q->head);
+       p->prev = q->head;
        q->head = p;
        q->len++;
 
@@ -145,7 +145,7 @@ struct sk_buff *BCMFASTPATH pktq_pdeq(struct pktq *pq, int prec)
        if (p == NULL)
                return NULL;
 
-       q->head = PKTLINK(p);
+       q->head = p->prev;
        if (q->head == NULL)
                q->tail = NULL;
 
@@ -153,7 +153,7 @@ struct sk_buff *BCMFASTPATH pktq_pdeq(struct pktq *pq, int prec)
 
        pq->len--;
 
-       PKTSETLINK(p, NULL);
+       p->prev = NULL;
 
        return p;
 }
@@ -171,11 +171,11 @@ struct sk_buff *BCMFASTPATH pktq_pdeq_tail(struct pktq *pq, int prec)
        if (p == NULL)
                return NULL;
 
-       for (prev = NULL; p != q->tail; p = PKTLINK(p))
+       for (prev = NULL; p != q->tail; p = p->prev)
                prev = p;
 
        if (prev)
-               PKTSETLINK(prev, NULL);
+               prev->prev = NULL;
        else
                q->head = NULL;
 
@@ -196,8 +196,8 @@ void pktq_pflush(struct osl_info *osh, struct pktq *pq, int prec, bool dir)
        q = &pq->q[prec];
        p = q->head;
        while (p) {
-               q->head = PKTLINK(p);
-               PKTSETLINK(p, NULL);
+               q->head = p->prev;
+               p->prev = NULL;
                PKTFREE(osh, p, dir);
                q->len--;
                pq->len--;
@@ -228,17 +228,17 @@ pktq_pflush(struct osl_info *osh, struct pktq *pq, int prec, bool dir,
                if (fn == NULL || (*fn) (p, arg)) {
                        bool head = (p == q->head);
                        if (head)
-                               q->head = PKTLINK(p);
+                               q->head = p->prev;
                        else
-                               PKTSETLINK(prev, PKTLINK(p));
-                       PKTSETLINK(p, NULL);
+                               prev->prev = p->prev;
+                       p->prev = NULL;
                        PKTFREE(osh, p, dir);
                        q->len--;
                        pq->len--;
-                       p = (head ? q->head : PKTLINK(prev));
+                       p = (head ? q->head : prev->prev);
                } else {
                        prev = p;
-                       p = PKTLINK(p);
+                       p = p->prev;
                }
        }
 
@@ -331,7 +331,7 @@ struct sk_buff *BCMFASTPATH pktq_mdeq(struct pktq *pq, uint prec_bmp,
        if (p == NULL)
                return NULL;
 
-       q->head = PKTLINK(p);
+       q->head = p->prev;
        if (q->head == NULL)
                q->tail = NULL;
 
@@ -342,7 +342,7 @@ struct sk_buff *BCMFASTPATH pktq_mdeq(struct pktq *pq, uint prec_bmp,
 
        pq->len--;
 
-       PKTSETLINK(p, NULL);
+       p->prev = NULL;
 
        return p;
 }
@@ -417,8 +417,8 @@ void prpkt(const char *msg, struct osl_info *osh, struct sk_buff *p0)
        if (msg && (msg[0] != '\0'))
                printf("%s:\n", msg);
 
-       for (p = p0; p; p = PKTNEXT(p))
-               prhex(NULL, PKTDATA(p), PKTLEN(p));
+       for (p = p0; p; p = p->next)
+               prhex(NULL, p->data, p->len);
 }
 #endif                         /* defined(BCMDBG) */
 
index 33d2c9a5a97c4dc04f816d5fe18d10dc0035e62d..c9dddcdb10995fa5f95190c2882234723c4df4f2 100644 (file)
@@ -989,15 +989,15 @@ static void *BCMFASTPATH _dma_rx(dma_info_t *di)
        if (head == NULL)
                return NULL;
 
-       len = ltoh16(*(u16 *) (PKTDATA(head)));
+       len = ltoh16(*(u16 *) (head->data));
        DMA_TRACE(("%s: dma_rx len %d\n", di->name, len));
 
 #if defined(__mips__)
        if (!len) {
-               while (!(len = *(u16 *) OSL_UNCACHED(PKTDATA(head))))
+               while (!(len = *(u16 *) OSL_UNCACHED(head->data)))
                        udelay(1);
 
-               *(u16 *) PKTDATA(head) = htol16((u16) len);
+               *(u16 *) (head->data) = htol16((u16) len);
        }
 #endif                         /* defined(__mips__) */
 
@@ -1010,7 +1010,7 @@ static void *BCMFASTPATH _dma_rx(dma_info_t *di)
        if (resid > 0) {
                tail = head;
                while ((resid > 0) && (p = _dma_getnextrxp(di, false))) {
-                       PKTSETNEXT(tail, p);
+                       tail->next = p;
                        pkt_len = min(resid, (int)di->rxbufsize);
                        __skb_trim(p, pkt_len);
 
@@ -1115,12 +1115,12 @@ static bool BCMFASTPATH _dma_rxfill(dma_info_t *di)
                /* Do a cached write instead of uncached write since DMA_MAP
                 * will flush the cache.
                 */
-               *(u32 *) (PKTDATA(p)) = 0;
+               *(u32 *) (p->data) = 0;
 
                if (DMASGLIST_ENAB)
                        bzero(&di->rxp_dmah[rxout], sizeof(hnddma_seg_map_t));
 
-               pa = DMA_MAP(di->osh, PKTDATA(p),
+               pa = DMA_MAP(di->osh, p->data,
                             di->rxbufsize, DMA_RX, p, &di->rxp_dmah[rxout]);
 
                ASSERT(IS_ALIGNED(PHYSADDRLO(pa), 4));
@@ -1673,12 +1673,12 @@ static int dma32_txfast(dma_info_t *di, struct sk_buff *p0, bool commit)
                uint nsegs, j;
                hnddma_seg_map_t *map;
 
-               data = PKTDATA(p);
-               len = PKTLEN(p);
+               data = p->data;
+               len = p->len;
 #ifdef BCM_DMAPAD
                len += PKTDMAPAD(di->osh, p);
 #endif
-               next = PKTNEXT(p);
+               next = p->next;
 
                /* return nonzero if out of tx descriptors */
                if (NEXTTXD(txout) == di->txin)
@@ -2323,12 +2323,12 @@ static int BCMFASTPATH dma64_txfast(dma_info_t *di, struct sk_buff *p0,
                uint nsegs, j;
                hnddma_seg_map_t *map;
 
-               data = PKTDATA(p);
-               len = PKTLEN(p);
+               data = p->data;
+               len = p->len;
 #ifdef BCM_DMAPAD
                len += PKTDMAPAD(di->osh, p);
 #endif                         /* BCM_DMAPAD */
-               next = PKTNEXT(p);
+               next = p->next;
 
                /* return nonzero if out of tx descriptors */
                if (NEXTTXD(txout) == di->txin)