staging: brcm80211: replace bcopy with memcpy
authorStanislav Fomichev <kernel@fomichev.me>
Mon, 14 Feb 2011 22:05:10 +0000 (01:05 +0300)
committerGreg Kroah-Hartman <gregkh@suse.de>
Fri, 18 Feb 2011 21:03:27 +0000 (13:03 -0800)
Use native linux memcpy instead of legacy bcopy

Signed-off-by: Stanislav Fomichev <kernel@fomichev.me>
Reviewed-by: Dan Carpenter <error27@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
23 files changed:
drivers/staging/brcm80211/brcmfmac/bcmsdh.c
drivers/staging/brcm80211/brcmfmac/bcmsdh_sdmmc.c
drivers/staging/brcm80211/brcmfmac/dhd_cdc.c
drivers/staging/brcm80211/brcmfmac/dhd_common.c
drivers/staging/brcm80211/brcmfmac/dhd_custom_gpio.c
drivers/staging/brcm80211/brcmfmac/dhd_linux.c
drivers/staging/brcm80211/brcmfmac/dhd_sdio.c
drivers/staging/brcm80211/brcmfmac/wl_iw.c
drivers/staging/brcm80211/brcmsmac/phy/wlc_phy_cmn.c
drivers/staging/brcm80211/brcmsmac/phy/wlc_phy_lcn.c
drivers/staging/brcm80211/brcmsmac/wl_mac80211.c
drivers/staging/brcm80211/brcmsmac/wlc_ampdu.c
drivers/staging/brcm80211/brcmsmac/wlc_bmac.c
drivers/staging/brcm80211/brcmsmac/wlc_mac80211.c
drivers/staging/brcm80211/brcmsmac/wlc_rate.c
drivers/staging/brcm80211/brcmsmac/wlc_stf.c
drivers/staging/brcm80211/include/osl.h
drivers/staging/brcm80211/util/bcmotp.c
drivers/staging/brcm80211/util/bcmsrom.c
drivers/staging/brcm80211/util/bcmutils.c
drivers/staging/brcm80211/util/hnddma.c
drivers/staging/brcm80211/util/nvram/nvram_ro.c
drivers/staging/brcm80211/util/siutils.c

index acf43a36508173a10f4d0d6c6b7d9b29ffd67c44..df9a139213a5219e836f3ec96f1b7e99205797c2 100644 (file)
@@ -324,7 +324,7 @@ int bcmsdh_cis_read(void *sdh, uint func, u8 * cis, uint length)
                        BCMSDH_ERROR(("%s: out of memory\n", __func__));
                        return BCME_NOMEM;
                }
-               bcopy(cis, tmp_buf, length);
+               memcpy(tmp_buf, cis, length);
                for (tmp_ptr = tmp_buf, ptr = cis; ptr < (cis + length - 4);
                     tmp_ptr++) {
                        ptr += sprintf((char *)ptr, "%.2x ", *tmp_ptr & 0xff);
index d399b5c76f94a0d10087281ac1eec3db452429a5..6cde62ac7dfc681461557dbae15d29ea8025633f 100644 (file)
@@ -441,7 +441,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
                val_size = sizeof(int);
 
        if (plen >= (int)sizeof(int_val))
-               bcopy(params, &int_val, sizeof(int_val));
+               memcpy(&int_val, params, sizeof(int_val));
 
        bool_val = (int_val != 0) ? true : false;
 
@@ -449,7 +449,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
        switch (actionid) {
        case IOV_GVAL(IOV_MSGLEVEL):
                int_val = (s32) sd_msglevel;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_MSGLEVEL):
@@ -458,7 +458,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
 
        case IOV_GVAL(IOV_BLOCKMODE):
                int_val = (s32) si->sd_blockmode;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_BLOCKMODE):
@@ -472,7 +472,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
                        break;
                }
                int_val = (s32) si->client_block_size[int_val];
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_BLOCKSIZE):
@@ -514,12 +514,12 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
 
        case IOV_GVAL(IOV_RXCHAIN):
                int_val = false;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_GVAL(IOV_DMA):
                int_val = (s32) si->sd_use_dma;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_DMA):
@@ -528,7 +528,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
 
        case IOV_GVAL(IOV_USEINTS):
                int_val = (s32) si->use_client_ints;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_USEINTS):
@@ -542,7 +542,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
 
        case IOV_GVAL(IOV_DIVISOR):
                int_val = (u32) sd_divisor;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_DIVISOR):
@@ -551,7 +551,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
 
        case IOV_GVAL(IOV_POWER):
                int_val = (u32) sd_power;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_POWER):
@@ -560,7 +560,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
 
        case IOV_GVAL(IOV_CLOCK):
                int_val = (u32) sd_clock;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_CLOCK):
@@ -569,7 +569,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
 
        case IOV_GVAL(IOV_SDMODE):
                int_val = (u32) sd_sdmode;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_SDMODE):
@@ -578,7 +578,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
 
        case IOV_GVAL(IOV_HISPEED):
                int_val = (u32) sd_hiok;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_HISPEED):
@@ -587,12 +587,12 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
 
        case IOV_GVAL(IOV_NUMINTS):
                int_val = (s32) si->intrcount;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_GVAL(IOV_NUMLOCALINTS):
                int_val = (s32) 0;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_GVAL(IOV_HOSTREG):
@@ -621,7 +621,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
                                int_val = 32;   /* sdioh_sdmmc_rreg(si,
                                                 sd_ptr->offset); */
 
-                       bcopy(&int_val, arg, sizeof(int_val));
+                       memcpy(arg, &int_val, sizeof(int_val));
                        break;
                }
 
@@ -657,7 +657,7 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name,
                        }
 
                        int_val = (int)data;
-                       bcopy(&int_val, arg, sizeof(int_val));
+                       memcpy(arg, &int_val, sizeof(int_val));
                        break;
                }
 
@@ -1048,14 +1048,14 @@ 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, mypkt->data, buflen_u);
+                       memcpy(mypkt->data, buffer, 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(mypkt->data, buffer, buflen_u);
+                       memcpy(buffer, mypkt->data, buflen_u);
 
                pkt_buf_free_skb(sd->osh, mypkt, write ? true : false);
        } else if (((u32) (pkt->data) & DMA_ALIGN_MASK) != 0) {
@@ -1075,14 +1075,14 @@ 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(pkt->data, mypkt->data, pkt->len);
+                       memcpy(mypkt->data, pkt->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(mypkt->data, pkt->data, mypkt->len);
+                       memcpy(pkt->data, mypkt->data, mypkt->len);
 
                pkt_buf_free_skb(sd->osh, mypkt, write ? true : false);
        } else {                /* case 3: We have a packet and
index 09461e6f7c8181df426c88571e967cabb14aedfd..ed204d535942927845d678fb494ef30178004b4e 100644 (file)
@@ -286,7 +286,7 @@ dhd_prot_ioctl(dhd_pub_t *dhd, int ifidx, wl_ioctl_t *ioc, void *buf, int len)
 
                slen = strlen("wme_dp") + 1;
                if (len >= (int)(slen + sizeof(int)))
-                       bcopy(((char *)buf + slen), &val, sizeof(int));
+                       memcpy(&val, (char *)buf + slen, sizeof(int));
                dhd->wme_dp = (u8) ltoh32(val);
        }
 
index ad4a00871d851bfc42184f877d328aa56e09592b..b2a6fb247ef9b388a1c1740a97f7fc57102f66dc 100644 (file)
@@ -214,7 +214,7 @@ dhd_doiovar(dhd_pub_t *dhd_pub, const bcm_iovar_t *vi, u32 actionid,
                goto exit;
 
        if (plen >= (int)sizeof(int_val))
-               bcopy(params, &int_val, sizeof(int_val));
+               memcpy(&int_val, params, sizeof(int_val));
 
        switch (actionid) {
        case IOV_GVAL(IOV_VERSION):
@@ -224,7 +224,7 @@ dhd_doiovar(dhd_pub_t *dhd_pub, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_MSGLEVEL):
                int_val = (s32) dhd_msg_level;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_MSGLEVEL):
@@ -239,12 +239,12 @@ dhd_doiovar(dhd_pub_t *dhd_pub, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_BCMERROR):
                int_val = (s32) dhd_pub->bcmerror;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_GVAL(IOV_WDTICK):
                int_val = (s32) dhd_watchdog_ms;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_WDTICK):
@@ -262,7 +262,7 @@ dhd_doiovar(dhd_pub_t *dhd_pub, const bcm_iovar_t *vi, u32 actionid,
 #ifdef DHD_DEBUG
        case IOV_GVAL(IOV_DCONSOLE_POLL):
                int_val = (s32) dhd_console_ms;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_DCONSOLE_POLL):
@@ -290,7 +290,7 @@ dhd_doiovar(dhd_pub_t *dhd_pub, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_IOCTLTIMEOUT):{
                        int_val = (s32) dhd_os_get_ioctl_resp_timeout();
-                       bcopy(&int_val, arg, sizeof(int_val));
+                       memcpy(arg, &int_val, sizeof(int_val));
                        break;
                }
 
@@ -1498,7 +1498,7 @@ int dhd_iscan_delete_bss(void *dhdp, void *addr, iscan_buf_t *iscan_skip)
                                                                (bi->length));
 /*
                        if(bi && bi_new) {
-                               bcopy(bi, bi_new, results->buflen -
+                               memcpy(bi_new, bi, results->buflen -
                                dtoh32(bi_new->length));
                                results->buflen -= dtoh32(bi_new->length);
                        }
@@ -1522,7 +1522,7 @@ int dhd_iscan_delete_bss(void *dhdp, void *addr, iscan_buf_t *iscan_skip)
                                                            (wl_bss_info_t *)((unsigned long)bi +
                                                                 dtoh32
                                                                 (bi->length));
-                                                       bcopy(bi, bi_new,
+                                                       memcpy(bi_new, bi,
                                                              dtoh32
                                                              (bi->length));
                                                        bi_new =
index 2cd80114d3857d353685152710a07ab3a9ab06f2..1a7a93981bffc961ed10954ac92d46369955068c 100644 (file)
@@ -149,9 +149,8 @@ int dhd_custom_get_mac_address(unsigned char *buf)
 #ifdef EXAMPLE_GET_MAC
        /* EXAMPLE code */
        {
-               u8 ea_example[ETH_ALEN] = {
-                       {0x00, 0x11, 0x22, 0x33, 0x44, 0xFF} };
-               bcopy((char *)ea_example, buf, ETH_ALEN);
+               u8 ea_example[ETH_ALEN] = {0x00, 0x11, 0x22, 0x33, 0x44, 0xFF};
+               memcpy(buf, ea_example, ETH_ALEN);
        }
 #endif                         /* EXAMPLE_GET_MAC */
 
index 2426a616807e507bd7967166a3bc120ca47f9d94..fef08b60f6f0f60b2cd241cff032807d4ca29c1b 100644 (file)
@@ -2167,7 +2167,7 @@ int dhd_bus_start(dhd_pub_t *dhdp)
        bcm_mkiovar("event_msgs", dhdp->eventmask, WL_EVENTING_MASK_LEN, iovbuf,
                    sizeof(iovbuf));
        dhdcdc_query_ioctl(dhdp, 0, WLC_GET_VAR, iovbuf, sizeof(iovbuf));
-       bcopy(iovbuf, dhdp->eventmask, WL_EVENTING_MASK_LEN);
+       memcpy(dhdp->eventmask, iovbuf, WL_EVENTING_MASK_LEN);
 
        setbit(dhdp->eventmask, WLC_E_SET_SSID);
        setbit(dhdp->eventmask, WLC_E_PRUNE);
index 159c45928e74b1503c7e1b091c052458bf40ecb6..916c5557f7b4144aeff5acd755b8dc082ee295be 100644 (file)
@@ -945,7 +945,7 @@ static int dhdsdio_txpkt(dhd_bus_t *bus, struct sk_buff *pkt, uint chan,
                        }
 
                        PKTALIGN(osh, new, pkt->len, DHD_SDALIGN);
-                       bcopy(pkt->data, new->data, pkt->len);
+                       memcpy(new->data, pkt->data, pkt->len);
                        if (free_pkt)
                                pkt_buf_free_skb(osh, pkt, true);
                        /* free the pkt if canned one is not used */
@@ -1395,7 +1395,7 @@ int dhd_bus_rxctl(struct dhd_bus *bus, unsigned char *msg, uint msglen)
 
        dhd_os_sdlock(bus->dhd);
        rxlen = bus->rxlen;
-       bcopy(bus->rxctl, msg, min(msglen, rxlen));
+       memcpy(msg, bus->rxctl, min(msglen, rxlen));
        bus->rxlen = 0;
        dhd_os_sdunlock(bus->dhd);
 
@@ -1658,7 +1658,7 @@ static int dhdsdio_pktgen_get(dhd_bus_t *bus, u8 *arg)
        pktgen.mode = bus->pktgen_mode;
        pktgen.stop = bus->pktgen_stop;
 
-       bcopy(&pktgen, arg, sizeof(pktgen));
+       memcpy(arg, &pktgen, sizeof(pktgen));
 
        return 0;
 }
@@ -1668,7 +1668,7 @@ static int dhdsdio_pktgen_set(dhd_bus_t *bus, u8 *arg)
        dhd_pktgen_t pktgen;
        uint oldcnt, oldmode;
 
-       bcopy(arg, &pktgen, sizeof(pktgen));
+       memcpy(&pktgen, arg, sizeof(pktgen));
        if (pktgen.version != DHD_PKTGEN_VERSION)
                return BCME_BADARG;
 
@@ -2094,7 +2094,7 @@ int dhdsdio_downloadvars(dhd_bus_t *bus, void *arg, int len)
 
        /* Copy the passed variables, which should include the
                 terminating double-null */
-       bcopy(arg, bus->vars, bus->varsz);
+       memcpy(bus->vars, arg, bus->varsz);
 err:
        return bcmerror;
 }
@@ -2117,7 +2117,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
                goto exit;
 
        if (plen >= (int)sizeof(int_val))
-               bcopy(params, &int_val, sizeof(int_val));
+               memcpy(&int_val, params, sizeof(int_val));
 
        bool_val = (int_val != 0) ? true : false;
 
@@ -2137,7 +2137,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
                        bcmerror = dhdsdio_bussleep(bus, bool_val);
                } else {
                        int_val = (s32) bus->sleeping;
-                       bcopy(&int_val, arg, val_size);
+                       memcpy(arg, &int_val, val_size);
                }
                goto exit;
        }
@@ -2151,7 +2151,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
        switch (actionid) {
        case IOV_GVAL(IOV_INTR):
                int_val = (s32) bus->intr;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_INTR):
@@ -2172,7 +2172,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_POLLRATE):
                int_val = (s32) bus->pollrate;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_POLLRATE):
@@ -2182,7 +2182,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_IDLETIME):
                int_val = bus->idletime;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_IDLETIME):
@@ -2194,7 +2194,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_IDLECLOCK):
                int_val = (s32) bus->idleclock;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_IDLECLOCK):
@@ -2203,7 +2203,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_SD1IDLE):
                int_val = (s32) sd1idle;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_SD1IDLE):
@@ -2222,8 +2222,8 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
                        ASSERT(plen >= 2 * sizeof(int));
 
                        address = (u32) int_val;
-                       bcopy((char *)params + sizeof(int_val), &int_val,
-                             sizeof(int_val));
+                       memcpy(&int_val, (char *)params + sizeof(int_val),
+                              sizeof(int_val));
                        size = (uint) int_val;
 
                        /* Do some validation */
@@ -2266,12 +2266,12 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_MEMSIZE):
                int_val = (s32) bus->ramsize;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_GVAL(IOV_SDIOD_DRIVE):
                int_val = (s32) dhd_sdiod_drive_strength;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_SDIOD_DRIVE):
@@ -2290,7 +2290,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_READAHEAD):
                int_val = (s32) dhd_readahead;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_READAHEAD):
@@ -2301,7 +2301,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_SDRXCHAIN):
                int_val = (s32) bus->use_rxchain;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_SDRXCHAIN):
@@ -2312,7 +2312,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
                break;
        case IOV_GVAL(IOV_ALIGNCTL):
                int_val = (s32) dhd_alignctl;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_ALIGNCTL):
@@ -2321,13 +2321,13 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_SDALIGN):
                int_val = DHD_SDALIGN;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
 #ifdef DHD_DEBUG
        case IOV_GVAL(IOV_VARS):
                if (bus->varsz < (uint) len)
-                       bcopy(bus->vars, arg, bus->varsz);
+                       memcpy(arg, bus->vars, bus->varsz);
                else
                        bcmerror = BCME_BUFTOOSHORT;
                break;
@@ -2346,7 +2346,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
                        int_val = (s32) bcmsdh_reg_read(bus->sdh, addr, size);
                        if (bcmsdh_regfail(bus->sdh))
                                bcmerror = BCME_SDIO_ERROR;
-                       bcopy(&int_val, arg, sizeof(s32));
+                       memcpy(arg, &int_val, sizeof(s32));
                        break;
                }
 
@@ -2372,14 +2372,14 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
                        sdreg_t sdreg;
                        u32 addr, size;
 
-                       bcopy(params, &sdreg, sizeof(sdreg));
+                       memcpy(&sdreg, params, sizeof(sdreg));
 
                        addr = SI_ENUM_BASE + sdreg.offset;
                        size = sdreg.func;
                        int_val = (s32) bcmsdh_reg_read(bus->sdh, addr, size);
                        if (bcmsdh_regfail(bus->sdh))
                                bcmerror = BCME_SDIO_ERROR;
-                       bcopy(&int_val, arg, sizeof(s32));
+                       memcpy(arg, &int_val, sizeof(s32));
                        break;
                }
 
@@ -2388,7 +2388,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
                        sdreg_t sdreg;
                        u32 addr, size;
 
-                       bcopy(params, &sdreg, sizeof(sdreg));
+                       memcpy(&sdreg, params, sizeof(sdreg));
 
                        addr = SI_ENUM_BASE + sdreg.offset;
                        size = sdreg.func;
@@ -2419,7 +2419,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_FORCEEVEN):
                int_val = (s32) forcealign;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_FORCEEVEN):
@@ -2428,7 +2428,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_TXBOUND):
                int_val = (s32) dhd_txbound;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_TXBOUND):
@@ -2437,7 +2437,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_RXBOUND):
                int_val = (s32) dhd_rxbound;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_RXBOUND):
@@ -2446,7 +2446,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 
        case IOV_GVAL(IOV_TXMINMAX):
                int_val = (s32) dhd_txminmax;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_TXMINMAX):
@@ -2457,7 +2457,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 #ifdef SDTEST
        case IOV_GVAL(IOV_EXTLOOP):
                int_val = (s32) bus->ext_loop;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
                break;
 
        case IOV_SVAL(IOV_EXTLOOP):
@@ -2491,7 +2491,7 @@ dhdsdio_doiovar(dhd_bus_t *bus, const bcm_iovar_t *vi, u32 actionid,
 
                /* Get its status */
                int_val = (bool) bus->dhd->dongle_reset;
-               bcopy(&int_val, arg, val_size);
+               memcpy(arg, &int_val, val_size);
 
                break;
 
@@ -2536,7 +2536,7 @@ static int dhdsdio_write_vars(dhd_bus_t *bus)
                        return BCME_NOMEM;
 
                memset(vbuffer, 0, varsize);
-               bcopy(bus->vars, vbuffer, bus->varsz);
+               memcpy(vbuffer, bus->vars, bus->varsz);
 
                /* Write the vars list */
                bcmerror =
@@ -3099,13 +3099,13 @@ dhdsdio_read_control(dhd_bus_t *bus, u8 *hdr, uint len, uint doff)
        ASSERT(bus->rxctl >= bus->rxbuf);
 
        /* Copy the already-read portion over */
-       bcopy(hdr, bus->rxctl, firstread);
+       memcpy(bus->rxctl, hdr, firstread);
        if (len <= firstread)
                goto gotpkt;
 
        /* Copy the full data pkt in gSPI case and process ioctl. */
        if (bus->bus == SPI_BUS) {
-               bcopy(hdr, bus->rxctl, len);
+               memcpy(bus->rxctl, hdr, len);
                goto gotpkt;
        }
 
@@ -3769,7 +3769,7 @@ static uint dhdsdio_readframes(dhd_bus_t *bus, uint maxframes, bool *finished)
                        dhd_os_sdunlock_rxq(bus->dhd);
 
                        /* Now check the header */
-                       bcopy(rxbuf, bus->rxhdr, SDPCM_HDRLEN);
+                       memcpy(bus->rxhdr, rxbuf, SDPCM_HDRLEN);
 
                        /* Extract hardware header fields */
                        len = ltoh16_ua(bus->rxhdr);
@@ -4135,7 +4135,7 @@ static uint dhdsdio_readframes(dhd_bus_t *bus, uint maxframes, bool *finished)
 
                /* Copy the already-read portion */
                skb_push(pkt, firstread);
-               bcopy(bus->rxhdr, pkt->data, firstread);
+               memcpy(pkt->data, bus->rxhdr, firstread);
 
 #ifdef DHD_DEBUG
                if (DHD_BYTES_ON() && DHD_DATA_ON())
index 6841b3ad81136fdf800065ceb074dc8b6d205f38..50cd22979d29115aeb004fe385a045d326c56a23 100644 (file)
@@ -289,7 +289,7 @@ dev_wlc_bufvar_get(struct net_device *dev, char *name, char *buf, int buflen)
            dev_wlc_ioctl(dev, WLC_GET_VAR, (void *)ioctlbuf,
                          MAX_WLIW_IOCTL_LEN);
        if (!error)
-               bcopy(ioctlbuf, buf, buflen);
+               memcpy(buf, ioctlbuf, buflen);
 
        return error;
 }
@@ -841,7 +841,7 @@ wl_iw_mlme(struct net_device *dev,
        }
 
        scbval.val = mlme->reason_code;
-       bcopy(&mlme->addr.sa_data, &scbval.ea, ETH_ALEN);
+       memcpy(&scbval.ea, &mlme->addr.sa_data, ETH_ALEN);
 
        if (mlme->cmd == IW_MLME_DISASSOC) {
                scbval.val = htod32(scbval.val);
@@ -1078,7 +1078,7 @@ static void wl_iw_set_event_mask(struct net_device *dev)
        char iovbuf[WL_EVENTING_MASK_LEN + 12];
 
        dev_iw_iovar_getbuf(dev, "event_msgs", "", 0, iovbuf, sizeof(iovbuf));
-       bcopy(iovbuf, eventmask, WL_EVENTING_MASK_LEN);
+       memcpy(eventmask, iovbuf, WL_EVENTING_MASK_LEN);
        setbit(eventmask, WLC_E_SCAN_COMPLETE);
        dev_iw_iovar_setbuf(dev, "event_msgs", eventmask, WL_EVENTING_MASK_LEN,
                            iovbuf, sizeof(iovbuf));
@@ -2555,8 +2555,7 @@ wl_iw_set_encodeext(struct net_device *dev,
        key.len = iwe->key_len;
 
        if (!is_multicast_ether_addr(iwe->addr.sa_data))
-               bcopy((void *)&iwe->addr.sa_data, (char *)&key.ea,
-                     ETH_ALEN);
+               memcpy(&key.ea, &iwe->addr.sa_data, ETH_ALEN);
 
        if (key.len == 0) {
                if (iwe->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
@@ -2581,13 +2580,13 @@ wl_iw_set_encodeext(struct net_device *dev,
                        key.flags = WL_PRIMARY_KEY;
                }
 
-               bcopy((void *)iwe->key, key.data, iwe->key_len);
+               memcpy(key.data, iwe->key, iwe->key_len);
 
                if (iwe->alg == IW_ENCODE_ALG_TKIP) {
                        u8 keybuf[8];
-                       bcopy(&key.data[24], keybuf, sizeof(keybuf));
-                       bcopy(&key.data[16], &key.data[24], sizeof(keybuf));
-                       bcopy(keybuf, &key.data[16], sizeof(keybuf));
+                       memcpy(keybuf, &key.data[24], sizeof(keybuf));
+                       memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
+                       memcpy(&key.data[16], keybuf, sizeof(keybuf));
                }
 
                if (iwe->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
@@ -2661,10 +2660,12 @@ wl_iw_set_pmksa(struct net_device *dev,
                        uint j;
                        pmkidptr = &pmkid;
 
-                       bcopy(&iwpmksa->bssid.sa_data[0],
-                             &pmkidptr->pmkid[0].BSSID, ETH_ALEN);
-                       bcopy(&iwpmksa->pmkid[0], &pmkidptr->pmkid[0].PMKID,
-                             WLAN_PMKID_LEN);
+                       memcpy(&pmkidptr->pmkid[0].BSSID,
+                              &iwpmksa->bssid.sa_data[0],
+                              ETH_ALEN);
+                       memcpy(&pmkidptr->pmkid[0].PMKID,
+                              &iwpmksa->pmkid[0],
+                              WLAN_PMKID_LEN);
 
                        WL_WSEC("wl_iw_set_pmksa:IW_PMKSA_REMOVE:PMKID: "
                                "%pM = ", &pmkidptr->pmkid[0].BSSID);
@@ -2683,12 +2684,12 @@ wl_iw_set_pmksa(struct net_device *dev,
                    && (i < pmkid_list.pmkids.npmkid)) {
                        memset(&pmkid_list.pmkids.pmkid[i], 0, sizeof(pmkid_t));
                        for (; i < (pmkid_list.pmkids.npmkid - 1); i++) {
-                               bcopy(&pmkid_list.pmkids.pmkid[i + 1].BSSID,
-                                     &pmkid_list.pmkids.pmkid[i].BSSID,
-                                     ETH_ALEN);
-                               bcopy(&pmkid_list.pmkids.pmkid[i + 1].PMKID,
-                                     &pmkid_list.pmkids.pmkid[i].PMKID,
-                                     WLAN_PMKID_LEN);
+                               memcpy(&pmkid_list.pmkids.pmkid[i].BSSID,
+                                      &pmkid_list.pmkids.pmkid[i + 1].BSSID,
+                                      ETH_ALEN);
+                               memcpy(&pmkid_list.pmkids.pmkid[i].PMKID,
+                                      &pmkid_list.pmkids.pmkid[i + 1].PMKID,
+                                      WLAN_PMKID_LEN);
                        }
                        pmkid_list.pmkids.npmkid--;
                } else
@@ -2702,12 +2703,12 @@ wl_iw_set_pmksa(struct net_device *dev,
                             &pmkid_list.pmkids.pmkid[i].BSSID, ETH_ALEN))
                                break;
                if (i < MAXPMKID) {
-                       bcopy(&iwpmksa->bssid.sa_data[0],
-                             &pmkid_list.pmkids.pmkid[i].BSSID,
-                             ETH_ALEN);
-                       bcopy(&iwpmksa->pmkid[0],
-                             &pmkid_list.pmkids.pmkid[i].PMKID,
-                             WLAN_PMKID_LEN);
+                       memcpy(&pmkid_list.pmkids.pmkid[i].BSSID,
+                              &iwpmksa->bssid.sa_data[0],
+                              ETH_ALEN);
+                       memcpy(&pmkid_list.pmkids.pmkid[i].PMKID,
+                              &iwpmksa->pmkid[0],
+                              WLAN_PMKID_LEN);
                        if (i == pmkid_list.pmkids.npmkid)
                                pmkid_list.pmkids.npmkid++;
                } else
@@ -3491,9 +3492,9 @@ void wl_iw_event(struct net_device *dev, wl_event_msg_t *e, void *data)
                                        if (pmkidcand->preauth)
                                                iwpmkidcand->flags |=
                                                    IW_PMKID_CAND_PREAUTH;
-                                       bcopy(&pmkidcand->BSSID,
-                                             &iwpmkidcand->bssid.sa_data,
-                                             ETH_ALEN);
+                                       memcpy(&iwpmkidcand->bssid.sa_data,
+                                              &pmkidcand->BSSID,
+                                              ETH_ALEN);
 #ifndef SANDGATE2G
                                        wireless_send_event(dev, cmd, &wrqu,
                                                            extra);
index 3bed37cb59b89e72e0949279ab45651ac7bf6f44..0760d97b3ba193ca5bbdadc1af33158a0fb0f522 100644 (file)
@@ -779,7 +779,7 @@ wlc_phy_t *wlc_phy_attach(shared_phy_t *sh, void *regs, int bandtype, char *vars
 
        pi->vars = (char *)&pi->vars;
 
-       bcopy(&pi->pubpi, &pi->pubpi_ro, sizeof(wlc_phy_t));
+       memcpy(&pi->pubpi_ro, &pi->pubpi, sizeof(wlc_phy_t));
 
        return &pi->pubpi_ro;
 
@@ -1619,40 +1619,36 @@ void wlc_phy_txpower_target_set(wlc_phy_t *ppi, struct txpwr_limits *txpwr)
        bool mac_enabled = false;
        phy_info_t *pi = (phy_info_t *) ppi;
 
-       bcopy(&txpwr->cck[0], &pi->tx_user_target[TXP_FIRST_CCK],
-             WLC_NUM_RATES_CCK);
-
-       bcopy(&txpwr->ofdm[0], &pi->tx_user_target[TXP_FIRST_OFDM],
-             WLC_NUM_RATES_OFDM);
-       bcopy(&txpwr->ofdm_cdd[0], &pi->tx_user_target[TXP_FIRST_OFDM_20_CDD],
-             WLC_NUM_RATES_OFDM);
-
-       bcopy(&txpwr->ofdm_40_siso[0],
-             &pi->tx_user_target[TXP_FIRST_OFDM_40_SISO], WLC_NUM_RATES_OFDM);
-       bcopy(&txpwr->ofdm_40_cdd[0],
-             &pi->tx_user_target[TXP_FIRST_OFDM_40_CDD], WLC_NUM_RATES_OFDM);
-
-       bcopy(&txpwr->mcs_20_siso[0],
-             &pi->tx_user_target[TXP_FIRST_MCS_20_SISO],
-             WLC_NUM_RATES_MCS_1_STREAM);
-       bcopy(&txpwr->mcs_20_cdd[0], &pi->tx_user_target[TXP_FIRST_MCS_20_CDD],
-             WLC_NUM_RATES_MCS_1_STREAM);
-       bcopy(&txpwr->mcs_20_stbc[0],
-             &pi->tx_user_target[TXP_FIRST_MCS_20_STBC],
-             WLC_NUM_RATES_MCS_1_STREAM);
-       bcopy(&txpwr->mcs_20_mimo[0], &pi->tx_user_target[TXP_FIRST_MCS_20_SDM],
-             WLC_NUM_RATES_MCS_2_STREAM);
-
-       bcopy(&txpwr->mcs_40_siso[0],
-             &pi->tx_user_target[TXP_FIRST_MCS_40_SISO],
-             WLC_NUM_RATES_MCS_1_STREAM);
-       bcopy(&txpwr->mcs_40_cdd[0], &pi->tx_user_target[TXP_FIRST_MCS_40_CDD],
-             WLC_NUM_RATES_MCS_1_STREAM);
-       bcopy(&txpwr->mcs_40_stbc[0],
-             &pi->tx_user_target[TXP_FIRST_MCS_40_STBC],
-             WLC_NUM_RATES_MCS_1_STREAM);
-       bcopy(&txpwr->mcs_40_mimo[0], &pi->tx_user_target[TXP_FIRST_MCS_40_SDM],
-             WLC_NUM_RATES_MCS_2_STREAM);
+       memcpy(&pi->tx_user_target[TXP_FIRST_CCK],
+              &txpwr->cck[0], WLC_NUM_RATES_CCK);
+
+       memcpy(&pi->tx_user_target[TXP_FIRST_OFDM],
+              &txpwr->ofdm[0], WLC_NUM_RATES_OFDM);
+       memcpy(&pi->tx_user_target[TXP_FIRST_OFDM_20_CDD],
+              &txpwr->ofdm_cdd[0], WLC_NUM_RATES_OFDM);
+
+       memcpy(&pi->tx_user_target[TXP_FIRST_OFDM_40_SISO],
+              &txpwr->ofdm_40_siso[0], WLC_NUM_RATES_OFDM);
+       memcpy(&pi->tx_user_target[TXP_FIRST_OFDM_40_CDD],
+              &txpwr->ofdm_40_cdd[0], WLC_NUM_RATES_OFDM);
+
+       memcpy(&pi->tx_user_target[TXP_FIRST_MCS_20_SISO],
+              &txpwr->mcs_20_siso[0], WLC_NUM_RATES_MCS_1_STREAM);
+       memcpy(&pi->tx_user_target[TXP_FIRST_MCS_20_CDD],
+              &txpwr->mcs_20_cdd[0], WLC_NUM_RATES_MCS_1_STREAM);
+       memcpy(&pi->tx_user_target[TXP_FIRST_MCS_20_STBC],
+              &txpwr->mcs_20_stbc[0], WLC_NUM_RATES_MCS_1_STREAM);
+       memcpy(&pi->tx_user_target[TXP_FIRST_MCS_20_SDM],
+              &txpwr->mcs_20_mimo[0], WLC_NUM_RATES_MCS_2_STREAM);
+
+       memcpy(&pi->tx_user_target[TXP_FIRST_MCS_40_SISO],
+              &txpwr->mcs_40_siso[0], WLC_NUM_RATES_MCS_1_STREAM);
+       memcpy(&pi->tx_user_target[TXP_FIRST_MCS_40_CDD],
+              &txpwr->mcs_40_cdd[0], WLC_NUM_RATES_MCS_1_STREAM);
+       memcpy(&pi->tx_user_target[TXP_FIRST_MCS_40_STBC],
+              &txpwr->mcs_40_stbc[0], WLC_NUM_RATES_MCS_1_STREAM);
+       memcpy(&pi->tx_user_target[TXP_FIRST_MCS_40_SDM],
+              &txpwr->mcs_40_mimo[0], WLC_NUM_RATES_MCS_2_STREAM);
 
        if (R_REG(pi->sh->osh, &pi->regs->maccontrol) & MCTL_EN_MAC)
                mac_enabled = true;
index 3ac2b49d9a9de9c452cff98e821a7af2fc58b85e..3fbbbb46a3603ecef486225f45318538fcc553c2 100644 (file)
@@ -1965,8 +1965,9 @@ wlc_lcnphy_tx_iqlo_cal(phy_info_t *pi,
                            tbl_iqcal_gainparams_lcnphy[band_idx][j][2];
                        cal_gains.pad_gain =
                            tbl_iqcal_gainparams_lcnphy[band_idx][j][3];
-                       bcopy(&tbl_iqcal_gainparams_lcnphy[band_idx][j][3],
-                             ncorr_override, sizeof(ncorr_override));
+                       memcpy(ncorr_override,
+                              &tbl_iqcal_gainparams_lcnphy[band_idx][j][3],
+                              sizeof(ncorr_override));
                        break;
                }
        }
index 07871679daaf71c4995bcd435bf114a78f0438e3..18f1ccfa0d4f9df1f6c3171b1c6cd3d30b1cf572 100644 (file)
@@ -799,7 +799,7 @@ static struct wl_info *wl_attach(u16 vendor, u16 device, unsigned long regs,
                goto fail;
        }
 
-       bcopy(&wl->pub->cur_etheraddr, perm, ETH_ALEN);
+       memcpy(perm, &wl->pub->cur_etheraddr, ETH_ALEN);
        ASSERT(is_valid_ether_addr(perm));
        SET_IEEE80211_PERM_ADDR(hw, perm);
 
@@ -1754,7 +1754,7 @@ int wl_ucode_init_buf(struct wl_info *wl, void **pbuf, u32 idx)
                                                 hdr->len);
                                        goto fail;
                                }
-                               bcopy(pdata, *pbuf, hdr->len);
+                               memcpy(*pbuf, pdata, hdr->len);
                                return 0;
                        }
                }
index f344e383d5c9951a7dfefcacf8fb0050a2dea07b..ca27e826e14fb68a49f60ab304f89a4d8fe17190 100644 (file)
@@ -1324,7 +1324,7 @@ void wlc_ampdu_macaddr_upd(struct wlc_info *wlc)
 
        /* driver needs to write the ta in the template; ta is at offset 16 */
        memset(template, 0, sizeof(template));
-       bcopy((char *)wlc->pub->cur_etheraddr, template, ETH_ALEN);
+       memcpy(template, wlc->pub->cur_etheraddr, ETH_ALEN);
        wlc_write_template_ram(wlc, (T_BA_TPL_BASE + 16), (T_RAM_ACCESS_SZ * 2),
                               template);
 }
index c21977929ff87f9c716f3c2ea36e4d17022e02d1..ac068cdc578b32dda8f41e0062d2a02edf00f028 100644 (file)
@@ -1275,7 +1275,7 @@ void wlc_bmac_wait_for_wake(struct wlc_hw_info *wlc_hw)
 
 void wlc_bmac_hw_etheraddr(struct wlc_hw_info *wlc_hw, u8 *ea)
 {
-       bcopy(wlc_hw->etheraddr, ea, ETH_ALEN);
+       memcpy(ea, wlc_hw->etheraddr, ETH_ALEN);
 }
 
 int wlc_bmac_bandtype(struct wlc_hw_info *wlc_hw)
@@ -1698,7 +1698,7 @@ wlc_bmac_write_template_ram(struct wlc_hw_info *wlc_hw, int offset, int len,
        be_bit = (R_REG(osh, &regs->maccontrol) & MCTL_BIGEND) != 0;
 
        while (len > 0) {
-               bcopy((u8 *) buf, &word, sizeof(u32));
+               memcpy(&word, buf, sizeof(u32));
 
                if (be_bit)
                        word = hton32(word);
index 5b2b93f2b2e5a21c46814df9e2b54592810cf31c..cb1a8026262d16fdf58f769623d2d5daf0755956 100644 (file)
@@ -1005,7 +1005,7 @@ static int wlc_get_current_txpwr(struct wlc_info *wlc, void *pwr, uint len)
         * or convert to a tx_power_legacy_t struct
         */
        if (!old_power) {
-               bcopy(&power, pwr, sizeof(tx_power_t));
+               memcpy(pwr, &power, sizeof(tx_power_t));
        } else {
                int band_idx = CHSPEC_IS2G(power.chanspec) ? 0 : 1;
 
@@ -1855,8 +1855,7 @@ void *wlc_attach(void *wl, u16 vendor, u16 device, uint unit, bool piomode,
 
        wlc_bmac_hw_etheraddr(wlc->hw, wlc->perm_etheraddr);
 
-       bcopy((char *)&wlc->perm_etheraddr, (char *)&pub->cur_etheraddr,
-             ETH_ALEN);
+       memcpy(&pub->cur_etheraddr, &wlc->perm_etheraddr, ETH_ALEN);
 
        for (j = 0; j < NBANDS(wlc); j++) {
                /* Use band 1 for single band 11a */
@@ -2916,8 +2915,8 @@ int wlc_set_gmode(struct wlc_info *wlc, u8 gmode, bool config)
 
        /* Set default bss rateset */
        wlc->default_bss->rateset.count = rs.count;
-       bcopy((char *)rs.rates, (char *)wlc->default_bss->rateset.rates,
-             sizeof(wlc->default_bss->rateset.rates));
+       memcpy(wlc->default_bss->rateset.rates, rs.rates, 
+              sizeof(wlc->default_bss->rateset.rates));
 
        return ret;
 }
@@ -3010,7 +3009,7 @@ static int wlc_set_rateset(struct wlc_info *wlc, wlc_rateset_t *rs_arg)
        wlc_rateset_t rs, new;
        uint bandunit;
 
-       bcopy((char *)rs_arg, (char *)&rs, sizeof(wlc_rateset_t));
+       memcpy(&rs, rs_arg, sizeof(wlc_rateset_t));
 
        /* check for bad count value */
        if ((rs.count == 0) || (rs.count > WLC_NUMRATES))
@@ -3018,7 +3017,7 @@ static int wlc_set_rateset(struct wlc_info *wlc, wlc_rateset_t *rs_arg)
 
        /* try the current band */
        bandunit = wlc->band->bandunit;
-       bcopy((char *)&rs, (char *)&new, sizeof(wlc_rateset_t));
+       memcpy(&new, &rs, sizeof(wlc_rateset_t));
        if (wlc_rate_hwrs_filter_sort_validate
            (&new, &wlc->bandstate[bandunit]->hw_rateset, true,
             wlc->stf->txstreams))
@@ -3027,7 +3026,7 @@ static int wlc_set_rateset(struct wlc_info *wlc, wlc_rateset_t *rs_arg)
        /* try the other band */
        if (IS_MBAND_UNLOCKED(wlc)) {
                bandunit = OTHERBANDUNIT(wlc);
-               bcopy((char *)&rs, (char *)&new, sizeof(wlc_rateset_t));
+               memcpy(&new, &rs, sizeof(wlc_rateset_t));
                if (wlc_rate_hwrs_filter_sort_validate(&new,
                                                       &wlc->
                                                       bandstate[bandunit]->
@@ -3040,10 +3039,9 @@ static int wlc_set_rateset(struct wlc_info *wlc, wlc_rateset_t *rs_arg)
 
  good:
        /* apply new rateset */
-       bcopy((char *)&new, (char *)&wlc->default_bss->rateset,
-             sizeof(wlc_rateset_t));
-       bcopy((char *)&new, (char *)&wlc->bandstate[bandunit]->defrateset,
-             sizeof(wlc_rateset_t));
+       memcpy(&wlc->default_bss->rateset, &new, sizeof(wlc_rateset_t));
+       memcpy(&wlc->bandstate[bandunit]->defrateset, &new,
+              sizeof(wlc_rateset_t));
        return 0;
 }
 
@@ -3123,7 +3121,7 @@ _wlc_ioctl(struct wlc_info *wlc, int cmd, void *arg, int len,
 
        /* This will prevent the misaligned access */
        if (pval && (u32) len >= sizeof(val))
-               bcopy(pval, &val, sizeof(val));
+               memcpy(&val, pval, sizeof(val));
        else
                val = 0;
 
@@ -3612,18 +3610,17 @@ _wlc_ioctl(struct wlc_info *wlc, int cmd, void *arg, int len,
                        if (src_key) {
                                key.index = src_key->id;
                                key.len = src_key->len;
-                               bcopy(src_key->data, key.data, key.len);
+                               memcpy(key.data, src_key->data, key.len);
                                key.algo = src_key->algo;
                                if (WSEC_SOFTKEY(wlc, src_key, bsscfg))
                                        key.flags |= WL_SOFT_KEY;
                                if (src_key->flags & WSEC_PRIMARY_KEY)
                                        key.flags |= WL_PRIMARY_KEY;
 
-                               bcopy(src_key->ea, key.ea,
-                                     ETH_ALEN);
+                               memcpy(key.ea, src_key->ea, ETH_ALEN);
                        }
 
-                       bcopy((char *)&key, arg, sizeof(key));
+                       memcpy(arg, &key, sizeof(key));
                } else
                        bcmerror = BCME_BADKEYIDX;
                break;
@@ -3674,7 +3671,7 @@ _wlc_ioctl(struct wlc_info *wlc, int cmd, void *arg, int len,
                                seq[6] = 0;
                                seq[7] = 0;
 
-                               bcopy((char *)seq, arg, sizeof(seq));
+                               memcpy(arg, seq, sizeof(seq));
                        } else {
                                bcmerror = BCME_BADKEYIDX;
                        }
@@ -3697,7 +3694,7 @@ _wlc_ioctl(struct wlc_info *wlc, int cmd, void *arg, int len,
 
                        /* Copy only legacy rateset section */
                        ret_rs->count = rs->count;
-                       bcopy(&rs->rates, &ret_rs->rates, rs->count);
+                       memcpy(&ret_rs->rates, &rs->rates, rs->count);
                        break;
                }
 
@@ -3715,7 +3712,7 @@ _wlc_ioctl(struct wlc_info *wlc, int cmd, void *arg, int len,
 
                        /* Copy only legacy rateset section */
                        ret_rs->count = rs.count;
-                       bcopy(&rs.rates, &ret_rs->rates, rs.count);
+                       memcpy(&ret_rs->rates, &rs.rates, rs.count);
                        break;
                }
 
@@ -3737,16 +3734,18 @@ _wlc_ioctl(struct wlc_info *wlc, int cmd, void *arg, int len,
 
                        /* Copy only legacy rateset section */
                        rs.count = in_rs->count;
-                       bcopy(&in_rs->rates, &rs.rates, rs.count);
+                       memcpy(&rs.rates, &in_rs->rates, rs.count);
 
                        /* merge rateset coming in with the current mcsset */
                        if (N_ENAB(wlc->pub)) {
                                if (bsscfg->associated)
-                                       bcopy(&current_bss->rateset.mcs[0],
-                                             rs.mcs, MCSSET_LEN);
+                                       memcpy(rs.mcs,
+                                              &current_bss->rateset.mcs[0],
+                                              MCSSET_LEN);
                                else
-                                       bcopy(&wlc->default_bss->rateset.mcs[0],
-                                             rs.mcs, MCSSET_LEN);
+                                       memcpy(rs.mcs,
+                                              &wlc->default_bss->rateset.mcs[0],
+                                              MCSSET_LEN);
                        }
 
                        bcmerror = wlc_set_rateset(wlc, &rs);
@@ -4048,7 +4047,7 @@ _wlc_ioctl(struct wlc_info *wlc, int cmd, void *arg, int len,
                                bcmerror = BCME_BUFTOOSHORT;
                                break;
                        }
-                       bcopy((char *)arg, (char *)&rs, sizeof(wlc_rateset_t));
+                       memcpy(&rs, arg, sizeof(wlc_rateset_t));
 
                        /* check for bad count value */
                        if (rs.count > WLC_NUMRATES) {
@@ -4084,7 +4083,7 @@ _wlc_ioctl(struct wlc_info *wlc, int cmd, void *arg, int len,
                        }
 
                        /* apply new rateset to the override */
-                       bcopy((char *)&new, (char *)&wlc->sup_rates_override,
+                       memcpy(&wlc->sup_rates_override, &new,
                              sizeof(wlc_rateset_t));
 
                        /* update bcn and probe resp if needed */
@@ -4108,8 +4107,7 @@ _wlc_ioctl(struct wlc_info *wlc, int cmd, void *arg, int len,
                        bcmerror = BCME_BUFTOOSHORT;
                        break;
                }
-               bcopy((char *)&wlc->sup_rates_override, (char *)arg,
-                     sizeof(wlc_rateset_t));
+               memcpy(arg, &wlc->sup_rates_override, sizeof(wlc_rateset_t));
 
                break;
 
@@ -4518,7 +4516,7 @@ wlc_iovar_check(struct wlc_pub *pub, const bcm_iovar_t *vi, void *arg, int len,
                case IOVT_UINT8:
                case IOVT_UINT16:
                case IOVT_UINT32:
-                       bcopy(arg, &int_val, sizeof(int));
+                       memcpy(&int_val, arg, sizeof(int));
                        err = wlc_iovar_rangecheck(wlc, int_val, vi);
                        break;
                }
@@ -4562,11 +4560,12 @@ wlc_doiovar(void *hdl, const bcm_iovar_t *vi, u32 actionid,
 
        /* convenience int and bool vals for first 8 bytes of buffer */
        if (p_len >= (int)sizeof(int_val))
-               bcopy(params, &int_val, sizeof(int_val));
+               memcpy(&int_val, params, sizeof(int_val));
 
        if (p_len >= (int)sizeof(int_val) * 2)
-               bcopy((void *)((unsigned long)params + sizeof(int_val)), &int_val2,
-                     sizeof(int_val));
+               memcpy(&int_val2,
+                      (void *)((unsigned long)params + sizeof(int_val)),
+                      sizeof(int_val));
 
        /* convenience int ptr for 4-byte gets (requires int aligned arg) */
        ret_int_ptr = (s32 *) arg;
@@ -6061,8 +6060,8 @@ wlc_d11hdrs_mac80211(struct wlc_info *wlc, struct ieee80211_hw *hw,
        /* (3) PLCP: determine PLCP header and MAC duration, fill d11txh_t */
        wlc_compute_plcp(wlc, rspec[0], phylen, plcp);
        wlc_compute_plcp(wlc, rspec[1], phylen, plcp_fallback);
-       bcopy(plcp_fallback, (char *)&txh->FragPLCPFallback,
-             sizeof(txh->FragPLCPFallback));
+       memcpy(&txh->FragPLCPFallback,
+              plcp_fallback, sizeof(txh->FragPLCPFallback));
 
        /* Length field now put in CCK FBR CRC field */
        if (IS_CCK(rspec[1])) {
@@ -6135,14 +6134,13 @@ wlc_d11hdrs_mac80211(struct wlc_info *wlc, struct ieee80211_hw *hw,
        }
 
        /* MacFrameControl */
-       bcopy((char *)&h->frame_control, (char *)&txh->MacFrameControl,
-           sizeof(u16));
+       memcpy(&txh->MacFrameControl, &h->frame_control, sizeof(u16));
        txh->TxFesTimeNormal = htol16(0);
 
        txh->TxFesTimeFallback = htol16(0);
 
        /* TxFrameRA */
-       bcopy((char *)&h->addr1, (char *)&txh->TxFrameRA, ETH_ALEN);
+       memcpy(&txh->TxFrameRA, &h->addr1, ETH_ALEN);
 
        /* TxFrameID */
        txh->TxFrameID = htol16(frameid);
@@ -6207,8 +6205,8 @@ wlc_d11hdrs_mac80211(struct wlc_info *wlc, struct ieee80211_hw *hw,
                /* fallback rate version of RTS PLCP header */
                wlc_compute_plcp(wlc, rts_rspec[1], rts_phylen,
                                 rts_plcp_fallback);
-               bcopy(rts_plcp_fallback, (char *)&txh->RTSPLCPFallback,
-                     sizeof(txh->RTSPLCPFallback));
+               memcpy(&txh->RTSPLCPFallback, rts_plcp_fallback,
+                      sizeof(txh->RTSPLCPFallback));
 
                /* RTS frame fields... */
                rts = (struct ieee80211_rts *)&txh->rts_frame;
@@ -6226,11 +6224,10 @@ wlc_d11hdrs_mac80211(struct wlc_info *wlc, struct ieee80211_hw *hw,
 
                if (use_cts) {
                        rts->frame_control = htol16(FC_CTS);
-                       bcopy((char *)&h->addr2, (char *)&rts->ra, ETH_ALEN);
+                       memcpy(&rts->ra, &h->addr2, ETH_ALEN);
                } else {
                        rts->frame_control = htol16((u16) FC_RTS);
-                       bcopy((char *)&h->addr1, (char *)&rts->ra,
-                             2 * ETH_ALEN);
+                       memcpy(&rts->ra, &h->addr1, 2 * ETH_ALEN);
                }
 
                /* mainrate
@@ -7726,10 +7723,9 @@ wlc_bcn_prb_template(struct wlc_info *wlc, uint type, ratespec_t bcn_rspec,
        /* DUR is 0 for multicast bcn, or filled in by MAC for prb resp */
        /* A1 filled in by MAC for prb resp, broadcast for bcn */
        if (type == FC_BEACON)
-               bcopy((const char *)&ether_bcast, (char *)&h->da,
-                     ETH_ALEN);
-       bcopy((char *)&cfg->cur_etheraddr, (char *)&h->sa, ETH_ALEN);
-       bcopy((char *)&cfg->BSSID, (char *)&h->bssid, ETH_ALEN);
+               memcpy(&h->da, &ether_bcast, ETH_ALEN);
+       memcpy(&h->sa, &cfg->cur_etheraddr, ETH_ALEN);
+       memcpy(&h->bssid, &cfg->BSSID, ETH_ALEN);
 
        /* SEQ filled in by MAC */
 
@@ -7820,7 +7816,7 @@ void wlc_shm_ssid_upd(struct wlc_info *wlc, wlc_bsscfg_t *cfg)
 
        /* padding the ssid with zero and copy it into shm */
        memset(ssidbuf, 0, IEEE80211_MAX_SSID_LEN);
-       bcopy(ssidptr, ssidbuf, cfg->SSID_len);
+       memcpy(ssidbuf, ssidptr, cfg->SSID_len);
 
        wlc_copyto_shm(wlc, base, ssidbuf, IEEE80211_MAX_SSID_LEN);
 
index ab7d0bed3c0a10c5f9fddeda7bba85903f76f885..6904f8b19092cf1fa48046ec2470075a4d5afd7e 100644 (file)
@@ -382,7 +382,7 @@ ratespec_t BCMFASTPATH wlc_compute_rspec(d11rxhdr_t *rxh, u8 *plcp)
 /* copy rateset src to dst as-is (no masking or sorting) */
 void wlc_rateset_copy(const wlc_rateset_t *src, wlc_rateset_t *dst)
 {
-       bcopy(src, dst, sizeof(wlc_rateset_t));
+       memcpy(dst, src, sizeof(wlc_rateset_t));
 }
 
 /*
@@ -417,7 +417,7 @@ wlc_rateset_filter(wlc_rateset_t *src, wlc_rateset_t *dst, bool basic_only,
        dst->htphy_membership = src->htphy_membership;
 
        if (mcsallow && rates != WLC_RATES_CCK)
-               bcopy(&src->mcs[0], &dst->mcs[0], MCSSET_LEN);
+               memcpy(&dst->mcs[0], &src->mcs[0], MCSSET_LEN);
        else
                wlc_rateset_mcs_clear(dst);
 }
@@ -487,7 +487,7 @@ void wlc_rateset_mcs_clear(wlc_rateset_t *rateset)
 
 void wlc_rateset_mcs_build(wlc_rateset_t *rateset, u8 txstreams)
 {
-       bcopy(&cck_ofdm_mimo_rates.mcs[0], &rateset->mcs[0], MCSSET_LEN);
+       memcpy(&rateset->mcs[0], &cck_ofdm_mimo_rates.mcs[0], MCSSET_LEN);
        wlc_rateset_mcs_upd(rateset, txstreams);
 }
 
index a1a1767f1d3af6ce57578c61e0621ff5cae98b3c..8b7620f2b8809d6f8859a7509826bc64c46be6fd 100644 (file)
@@ -489,7 +489,7 @@ void wlc_stf_phy_chain_calc(struct wlc_info *wlc)
        wlc->stf->rxstreams = (u8) WLC_BITSCNT(wlc->stf->hw_rxchain);
 
        /* initialize the txcore table */
-       bcopy(txcore_default, wlc->stf->txcore, sizeof(wlc->stf->txcore));
+       memcpy(wlc->stf->txcore, txcore_default, sizeof(wlc->stf->txcore));
 
        /* default spatial_policy */
        wlc->stf->spatial_policy = MIN_SPATIAL_EXPANSION;
index 919b12af0c81fdc2f10e3e15ca58acb4d7654f88..17fc274ef240524ee8471f726d2e0cb0bc2bab86 100644 (file)
@@ -110,8 +110,6 @@ extern void osl_dma_unmap(struct osl_info *osh, uint pa, uint size,
 #include <linux/kernel.h>      /* for vsn/printf's */
 #include <linux/string.h>      /* for mem*, str* */
 #endif
-/* bcopy's: Linux kernel doesn't provide these (anymore) */
-#define        bcopy(src, dst, len)    memcpy((dst), (src), (len))
 
 /* register access macros */
 #ifndef IL_BIGENDIAN
@@ -204,8 +202,6 @@ extern void osl_dma_unmap(struct osl_info *osh, uint pa, uint size,
        } while (0)
 #endif                         /* IL_BIGENDIAN */
 
-#define        bcopy(src, dst, len)    memcpy((dst), (src), (len))
-
 /* packet primitives */
 extern struct sk_buff *pkt_buf_get_skb(struct osl_info *osh, uint len);
 extern void pkt_buf_free_skb(struct osl_info *osh, struct sk_buff *skb, bool send);
index d820e7b9e970913e1af13e109cd880c8ca8b1c5f..6fa04ed9350198908b9aee1de3a611836ee231a1 100644 (file)
@@ -818,7 +818,7 @@ static int hndotp_nvread(void *oh, char *data, uint *len)
                        if (offset + dsz >= *len) {
                                goto out;
                        }
-                       bcopy((char *)&rawotp[i + 2], &data[offset], dsz);
+                       memcpy(&data[offset], &rawotp[i + 2], dsz);
                        offset += dsz;
                        /* Remove extra null characters at the end */
                        while (offset > 1 &&
index 622cd309c6a70fc2ddce73402d76dfc55de7ced6..b26877c460234632479b1c467ec5bf73c2e6d7f8 100644 (file)
@@ -1336,8 +1336,8 @@ int srom_parsecis(struct osl_info *osh, u8 *pcis[], uint ciscnt, char **vars,
                                                u8 srev = cis[i + 1 + 70];
                                                ASSERT(srev == 3);
                                                /* make tuple value 16-bit aligned and parse it */
-                                               bcopy(&cis[i + 1], srom,
-                                                     sizeof(srom));
+                                               memcpy(srom, &cis[i + 1],
+                                                      sizeof(srom));
                                                _initvars_srom_pci(srev, srom,
                                                                   SROM3_SWRGN_OFF,
                                                                   &b);
@@ -1518,7 +1518,7 @@ static int otp_read_pci(struct osl_info *osh, si_t *sih, u16 *buf, uint bufsz)
 
        err = otp_read_region(sih, OTP_HW_RGN, (u16 *) otp, &sz);
 
-       bcopy(otp, buf, bufsz);
+       memcpy(buf, otp, bufsz);
 
        if (otp)
                kfree(otp);
@@ -1562,7 +1562,7 @@ static int initvars_table(struct osl_info *osh, char *start, char *end,
                ASSERT(vp != NULL);
                if (!vp)
                        return BCME_NOMEM;
-               bcopy(start, vp, c);
+               memcpy(vp, start, c);
                *vars = vp;
                *count = c;
        } else {
index 35c1b6d6b50efa393fba20fdafce579b9465a7c4..707fd0da3d36f6e519f446be1ceaf086a0fc72a1 100644 (file)
@@ -50,7 +50,7 @@ uint pktfrombuf(struct osl_info *osh, struct sk_buff *p, uint offset, int len,
        /* copy the data */
        for (; p && len; p = p->next) {
                n = min((uint) (p->len) - offset, (uint) len);
-               bcopy(buf, p->data + offset, n);
+               memcpy(p->data + offset, buf, n);
                buf += n;
                len -= n;
                ret += n;
index 47dceb30244737896e35f21fd232cdeb722aa1f7..3f1d63ee7c481ce8515e658a62e829872e37b3e5 100644 (file)
@@ -1758,8 +1758,8 @@ static void dma64_txrotate(dma_info_t *di)
 
                /* Move the map */
                if (DMASGLIST_ENAB) {
-                       bcopy(&di->txp_dmah[old], &di->txp_dmah[new],
-                             sizeof(hnddma_seg_map_t));
+                       memcpy(&di->txp_dmah[new], &di->txp_dmah[old],
+                              sizeof(hnddma_seg_map_t));
                        memset(&di->txp_dmah[old], 0, sizeof(hnddma_seg_map_t));
                }
 
index e4d41ee78e2ab959772de1d10ec03f8542a2d6b9..b2e6c0df137ea28aac0d347b0ad08ffbac490035 100644 (file)
@@ -70,7 +70,7 @@ static void get_flash_nvram(si_t *sih, struct nvram_header *nvh)
        new->next = vars;
        vars = new;
 
-       bcopy((char *)(&nvh[1]), new->vars, nvs);
+       memcpy(new->vars, &nvh[1], nvs);
 
        NVR_MSG(("%s: flash nvram @ %p, copied %d bytes to %p\n", __func__,
                 nvh, nvs, new->vars));
@@ -195,7 +195,7 @@ int nvram_getall(char *buf, int count)
                        len = strlen(from) + 1;
                        if (resid < (acc + len))
                                return BCME_BUFTOOSHORT;
-                       bcopy(from, to, len);
+                       memcpy(to, from, len);
                        acc += len;
                        from += len;
                        to += len;
index b0e7695097e80c6c44ec6a1f747bebadcb33dcc2..5631d5b55c22139494b2e3a636e2e2f7e4a5e790 100644 (file)
@@ -697,7 +697,7 @@ void si_detach(si_t *sih)
        uint idx;
 
        struct si_pub *si_local = NULL;
-       bcopy(&sih, &si_local, sizeof(si_t **));
+       memcpy(&si_local, &sih, sizeof(si_t **));
 
        sii = SI_INFO(sih);