Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 67ad48bc authored by Roland Vossen's avatar Roland Vossen Committed by Greg Kroah-Hartman
Browse files

staging: brcm80211: cleaned up prefix for utility functions 



Code cleanup. 'bcm' replaced by 'brcmu_', which is shorthand for
'Broadcom Utilities' (the 'brcmutil.ko' library module).

Signed-off-by: default avatarRoland Vossen <rvossen@broadcom.com>
Reviewed-by: default avatarArend van Spriel <arend@broadcom.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 3918ec2b

drivers/staging/brcm80211/brcmfmac/bcmsdh_sdmmc.c

+10 −10
Original line number Diff line number Diff line
@@ -352,7 +352,7 @@ enum { 
	IOV_RXCHAIN

};



const bcm_iovar_t sdioh_iovars[] = {

const struct brcmu_iovar sdioh_iovars[] = {

	{"sd_msglevel", IOV_MSGLEVEL, 0, IOVT_UINT32, 0},

	{"sd_blocksize", IOV_BLOCKSIZE, 0, IOVT_UINT32, 0},/* ((fn << 16) |

								 size) */
@@ -369,7 +369,7 @@ int 
sdioh_iovar_op(sdioh_info_t *si, const char *name,

	       void *params, int plen, void *arg, int len, bool set)

{

	const bcm_iovar_t *vi = NULL;

	const struct brcmu_iovar *vi = NULL;

	int bcmerror = 0;

	int val_size;

	s32 int_val = 0;
@@ -386,13 +386,13 @@ sdioh_iovar_op(sdioh_info_t *si, const char *name, 
	sd_trace(("%s: Enter (%s %s)\n", __func__, (set ? "set" : "get"),

		  name));



	vi = bcm_iovar_lookup(sdioh_iovars, name);

	vi = brcmu_iovar_lookup(sdioh_iovars, name);

	if (vi == NULL) {

		bcmerror = -ENOTSUPP;

		goto exit;

	}



	bcmerror = bcm_iovar_lencheck(vi, arg, len, set);

	bcmerror = brcmu_iovar_lencheck(vi, arg, len, set);

	if (bcmerror != 0)

		goto exit;
@@ -888,9 +888,9 @@ sdioh_request_buffer(sdioh_info_t *sd, uint pio_dma, uint fix_inc, uint write, 
	if (pkt == NULL) {

		sd_data(("%s: Creating new %s Packet, len=%d\n",

			 __func__, write ? "TX" : "RX", buflen_u));

		mypkt = bcm_pkt_buf_get_skb(buflen_u);

		mypkt = brcmu_pkt_buf_get_skb(buflen_u);

		if (!mypkt) {

			sd_err(("%s: bcm_pkt_buf_get_skb failed: len %d\n",

			sd_err(("%s: brcmu_pkt_buf_get_skb failed: len %d\n",

				__func__, buflen_u));

			return SDIOH_API_RC_FAIL;

		}
@@ -906,7 +906,7 @@ sdioh_request_buffer(sdioh_info_t *sd, uint pio_dma, uint fix_inc, uint write, 
		if (!write)

			memcpy(buffer, mypkt->data, buflen_u);



		bcm_pkt_buf_free_skb(mypkt);

		brcmu_pkt_buf_free_skb(mypkt);

	} else if (((u32) (pkt->data) & DMA_ALIGN_MASK) != 0) {

		/* Case 2: We have a packet, but it is unaligned. */
@@ -915,9 +915,9 @@ sdioh_request_buffer(sdioh_info_t *sd, uint pio_dma, uint fix_inc, uint write, 


		sd_data(("%s: Creating aligned %s Packet, len=%d\n",

			 __func__, write ? "TX" : "RX", pkt->len));

		mypkt = bcm_pkt_buf_get_skb(pkt->len);

		mypkt = brcmu_pkt_buf_get_skb(pkt->len);

		if (!mypkt) {

			sd_err(("%s: bcm_pkt_buf_get_skb failed: len %d\n",

			sd_err(("%s: brcmu_pkt_buf_get_skb failed: len %d\n",

				__func__, pkt->len));

			return SDIOH_API_RC_FAIL;

		}
@@ -933,7 +933,7 @@ sdioh_request_buffer(sdioh_info_t *sd, uint pio_dma, uint fix_inc, uint write, 
		if (!write)

			memcpy(pkt->data, mypkt->data, mypkt->len);



		bcm_pkt_buf_free_skb(mypkt);

		brcmu_pkt_buf_free_skb(mypkt);

	} else {		/* case 3: We have a packet and

				 it is aligned. */

		sd_data(("%s: Aligned %s Packet, direct DMA\n",

drivers/staging/brcm80211/brcmfmac/dhd_bus.h

+1 −1
Original line number Diff line number Diff line
@@ -63,7 +63,7 @@ extern int dhd_bus_iovar_op(dhd_pub_t *dhdp, const char *name, 
			    bool set);



/* Add bus dump output to a buffer */

extern void dhd_bus_dump(dhd_pub_t *dhdp, struct bcmstrbuf *strbuf);

extern void dhd_bus_dump(dhd_pub_t *dhdp, struct brcmu_strbuf *strbuf);



/* Clear any bus counters */

extern void dhd_bus_clearcounts(dhd_pub_t *dhdp);

drivers/staging/brcm80211/brcmfmac/dhd_cdc.c

+2 −2
Original line number Diff line number Diff line
@@ -366,9 +366,9 @@ dhd_prot_iovar_op(dhd_pub_t *dhdp, const char *name, 
	return -ENOTSUPP;

}



void dhd_prot_dump(dhd_pub_t *dhdp, struct bcmstrbuf *strbuf)

void dhd_prot_dump(dhd_pub_t *dhdp, struct brcmu_strbuf *strbuf)

{

	bcm_bprintf(strbuf, "Protocol CDC: reqid %d\n", dhdp->prot->reqid);

	brcmu_bprintf(strbuf, "Protocol CDC: reqid %d\n", dhdp->prot->reqid);

}



void dhd_prot_hdrpush(dhd_pub_t *dhd, int ifidx, struct sk_buff *pktbuf)

drivers/staging/brcm80211/brcmfmac/dhd_common.c

+57 −55
Original line number Diff line number Diff line
@@ -89,7 +89,7 @@ enum { 
	IOV_LAST

};



const bcm_iovar_t dhd_iovars[] = {

const struct brcmu_iovar dhd_iovars[] = {

	{"version", IOV_VERSION, 0, IOVT_BUFFER, sizeof(dhd_version)}

	,

#ifdef DHD_DEBUG
@@ -160,54 +160,54 @@ void dhd_common_init(void) 


static int dhd_dump(dhd_pub_t *dhdp, char *buf, int buflen)

{

	struct bcmstrbuf b;

	struct bcmstrbuf *strbuf = &b;

	struct brcmu_strbuf b;

	struct brcmu_strbuf *strbuf = &b;



	bcm_binit(strbuf, buf, buflen);

	brcmu_binit(strbuf, buf, buflen);



	/* Base DHD info */

	bcm_bprintf(strbuf, "%s\n", dhd_version);

	bcm_bprintf(strbuf, "\n");

	bcm_bprintf(strbuf, "pub.up %d pub.txoff %d pub.busstate %d\n",

	brcmu_bprintf(strbuf, "%s\n", dhd_version);

	brcmu_bprintf(strbuf, "\n");

	brcmu_bprintf(strbuf, "pub.up %d pub.txoff %d pub.busstate %d\n",

		    dhdp->up, dhdp->txoff, dhdp->busstate);

	bcm_bprintf(strbuf, "pub.hdrlen %d pub.maxctl %d pub.rxsz %d\n",

	brcmu_bprintf(strbuf, "pub.hdrlen %d pub.maxctl %d pub.rxsz %d\n",

		    dhdp->hdrlen, dhdp->maxctl, dhdp->rxsz);

	bcm_bprintf(strbuf, "pub.iswl %d pub.drv_version %ld pub.mac %pM\n",

	brcmu_bprintf(strbuf, "pub.iswl %d pub.drv_version %ld pub.mac %pM\n",

		    dhdp->iswl, dhdp->drv_version, &dhdp->mac);

	bcm_bprintf(strbuf, "pub.bcmerror %d tickcnt %d\n", dhdp->bcmerror,

	brcmu_bprintf(strbuf, "pub.bcmerror %d tickcnt %d\n", dhdp->bcmerror,

		    dhdp->tickcnt);



	bcm_bprintf(strbuf, "dongle stats:\n");

	bcm_bprintf(strbuf,

	brcmu_bprintf(strbuf, "dongle stats:\n");

	brcmu_bprintf(strbuf,

		    "tx_packets %ld tx_bytes %ld tx_errors %ld tx_dropped %ld\n",

		    dhdp->dstats.tx_packets, dhdp->dstats.tx_bytes,

		    dhdp->dstats.tx_errors, dhdp->dstats.tx_dropped);

	bcm_bprintf(strbuf,

	brcmu_bprintf(strbuf,

		    "rx_packets %ld rx_bytes %ld rx_errors %ld rx_dropped %ld\n",

		    dhdp->dstats.rx_packets, dhdp->dstats.rx_bytes,

		    dhdp->dstats.rx_errors, dhdp->dstats.rx_dropped);

	bcm_bprintf(strbuf, "multicast %ld\n", dhdp->dstats.multicast);

	brcmu_bprintf(strbuf, "multicast %ld\n", dhdp->dstats.multicast);



	bcm_bprintf(strbuf, "bus stats:\n");

	bcm_bprintf(strbuf, "tx_packets %ld tx_multicast %ld tx_errors %ld\n",

	brcmu_bprintf(strbuf, "bus stats:\n");

	brcmu_bprintf(strbuf, "tx_packets %ld tx_multicast %ld tx_errors %ld\n",

		    dhdp->tx_packets, dhdp->tx_multicast, dhdp->tx_errors);

	bcm_bprintf(strbuf, "tx_ctlpkts %ld tx_ctlerrs %ld\n",

	brcmu_bprintf(strbuf, "tx_ctlpkts %ld tx_ctlerrs %ld\n",

		    dhdp->tx_ctlpkts, dhdp->tx_ctlerrs);

	bcm_bprintf(strbuf, "rx_packets %ld rx_multicast %ld rx_errors %ld\n",

	brcmu_bprintf(strbuf, "rx_packets %ld rx_multicast %ld rx_errors %ld\n",

		    dhdp->rx_packets, dhdp->rx_multicast, dhdp->rx_errors);

	bcm_bprintf(strbuf,

	brcmu_bprintf(strbuf,

		    "rx_ctlpkts %ld rx_ctlerrs %ld rx_dropped %ld rx_flushed %ld\n",

		    dhdp->rx_ctlpkts, dhdp->rx_ctlerrs, dhdp->rx_dropped,

		    dhdp->rx_flushed);

	bcm_bprintf(strbuf,

	brcmu_bprintf(strbuf,

		    "rx_readahead_cnt %ld tx_realloc %ld fc_packets %ld\n",

		    dhdp->rx_readahead_cnt, dhdp->tx_realloc, dhdp->fc_packets);

	bcm_bprintf(strbuf, "wd_dpc_sched %ld\n", dhdp->wd_dpc_sched);

	bcm_bprintf(strbuf, "\n");

	brcmu_bprintf(strbuf, "wd_dpc_sched %ld\n", dhdp->wd_dpc_sched);

	brcmu_bprintf(strbuf, "\n");



	/* Add any prot info */

	dhd_prot_dump(dhdp, strbuf);

	bcm_bprintf(strbuf, "\n");

	brcmu_bprintf(strbuf, "\n");



	/* Add any bus info */

	dhd_bus_dump(dhdp, strbuf);
@@ -216,7 +216,7 @@ static int dhd_dump(dhd_pub_t *dhdp, char *buf, int buflen) 
}



static int

dhd_doiovar(dhd_pub_t *dhd_pub, const bcm_iovar_t *vi, u32 actionid,

dhd_doiovar(dhd_pub_t *dhd_pub, const struct brcmu_iovar *vi, u32 actionid,

	    const char *name, void *params, int plen, void *arg, int len,

	    int val_size)

{
@@ -225,7 +225,7 @@ dhd_doiovar(dhd_pub_t *dhd_pub, const bcm_iovar_t *vi, u32 actionid, 


	DHD_TRACE(("%s: Enter\n", __func__));



	bcmerror = bcm_iovar_lencheck(vi, arg, len, IOV_ISSET(actionid));

	bcmerror = brcmu_iovar_lencheck(vi, arg, len, IOV_ISSET(actionid));

	if (bcmerror != 0)

		goto exit;
@@ -339,7 +339,7 @@ bool dhd_prec_enq(dhd_pub_t *dhdp, struct pktq *q, struct sk_buff *pkt, 
	 * exceeding total queue length

	 */

	if (!pktq_pfull(q, prec) && !pktq_full(q)) {

		bcm_pktq_penq(q, prec, pkt);

		brcmu_pktq_penq(q, prec, pkt);

		return true;

	}
@@ -347,7 +347,7 @@ bool dhd_prec_enq(dhd_pub_t *dhdp, struct pktq *q, struct sk_buff *pkt, 
	if (pktq_pfull(q, prec))

		eprec = prec;

	else if (pktq_full(q)) {

		p = bcm_pktq_peek_tail(q, &eprec);

		p = brcmu_pktq_peek_tail(q, &eprec);

		ASSERT(p);

		if (eprec > prec)

			return false;
@@ -361,21 +361,21 @@ bool dhd_prec_enq(dhd_pub_t *dhdp, struct pktq *q, struct sk_buff *pkt, 
		if (eprec == prec && !discard_oldest)

			return false;	/* refuse newer (incoming) packet */

		/* Evict packet according to discard policy */

		p = discard_oldest ? bcm_pktq_pdeq(q, eprec) :

			bcm_pktq_pdeq_tail(q, eprec);

		p = discard_oldest ? brcmu_pktq_pdeq(q, eprec) :

			brcmu_pktq_pdeq_tail(q, eprec);

		if (p == NULL) {

			DHD_ERROR(("%s: bcm_pktq_penq() failed, oldest %d.",

			DHD_ERROR(("%s: brcmu_pktq_penq() failed, oldest %d.",

				   __func__, discard_oldest));

			ASSERT(p);

		}



		bcm_pkt_buf_free_skb(p);

		brcmu_pkt_buf_free_skb(p);

	}



	/* Enqueue */

	p = bcm_pktq_penq(q, prec, pkt);

	p = brcmu_pktq_penq(q, prec, pkt);

	if (p == NULL) {

		DHD_ERROR(("%s: bcm_pktq_penq() failed.", __func__));

		DHD_ERROR(("%s: brcmu_pktq_penq() failed.", __func__));

		ASSERT(p);

	}
@@ -388,7 +388,7 @@ dhd_iovar_op(dhd_pub_t *dhd_pub, const char *name, 
{

	int bcmerror = 0;

	int val_size;

	const bcm_iovar_t *vi = NULL;

	const struct brcmu_iovar *vi = NULL;

	u32 actionid;



	DHD_TRACE(("%s: Enter\n", __func__));
@@ -402,7 +402,7 @@ dhd_iovar_op(dhd_pub_t *dhd_pub, const char *name, 
	/* Set does NOT take qualifiers */

	ASSERT(!set || (!params && !plen));



	vi = bcm_iovar_lookup(dhd_iovars, name);

	vi = brcmu_iovar_lookup(dhd_iovars, name);

	if (vi == NULL) {

		bcmerror = -ENOTSUPP;

		goto exit;
@@ -1013,7 +1013,7 @@ dhd_pktfilter_offload_enable(dhd_pub_t *dhd, char *arg, int enable, 
			   __func__, arg));



	/* Contorl the master mode */

	bcm_mkiovar("pkt_filter_mode", (char *)&master_mode, 4, buf,

	brcmu_mkiovar("pkt_filter_mode", (char *)&master_mode, 4, buf,

		    sizeof(buf));

	rc = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, buf, sizeof(buf));

	rc = rc >= 0 ? 0 : rc;
@@ -1167,7 +1167,7 @@ void dhd_arp_offload_set(dhd_pub_t *dhd, int arp_mode) 
	char iovbuf[32];

	int retcode;



	bcm_mkiovar("arp_ol", (char *)&arp_mode, 4, iovbuf, sizeof(iovbuf));

	brcmu_mkiovar("arp_ol", (char *)&arp_mode, 4, iovbuf, sizeof(iovbuf));

	retcode = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));

	retcode = retcode >= 0 ? 0 : retcode;

	if (retcode)
@@ -1183,7 +1183,7 @@ void dhd_arp_offload_enable(dhd_pub_t *dhd, int arp_enable) 
	char iovbuf[32];

	int retcode;



	bcm_mkiovar("arpoe", (char *)&arp_enable, 4, iovbuf, sizeof(iovbuf));

	brcmu_mkiovar("arpoe", (char *)&arp_enable, 4, iovbuf, sizeof(iovbuf));

	retcode = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));

	retcode = retcode >= 0 ? 0 : retcode;

	if (retcode)
@@ -1222,7 +1222,7 @@ int dhd_preinit_ioctls(dhd_pub_t *dhd) 
	 */

	ret = dhd_custom_get_mac_address(ea_addr);

	if (!ret) {

		bcm_mkiovar("cur_etheraddr", (void *)ea_addr, ETH_ALEN,

		brcmu_mkiovar("cur_etheraddr", (void *)ea_addr, ETH_ALEN,

			    buf, sizeof(buf));

		ret = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, buf, sizeof(buf));

		if (ret < 0) {
@@ -1247,7 +1247,7 @@ int dhd_preinit_ioctls(dhd_pub_t *dhd) 
	/* query for 'ver' to get version info from firmware */

	memset(buf, 0, sizeof(buf));

	ptr = buf;

	bcm_mkiovar("ver", 0, 0, buf, sizeof(buf));

	brcmu_mkiovar("ver", 0, 0, buf, sizeof(buf));

	dhdcdc_query_ioctl(dhd, 0, WLC_GET_VAR, buf, sizeof(buf));

	strsep(&ptr, "\n");

	/* Print fw version info */
@@ -1258,23 +1258,23 @@ int dhd_preinit_ioctls(dhd_pub_t *dhd) 
			 sizeof(power_mode));



	/* Match Host and Dongle rx alignment */

	bcm_mkiovar("bus:txglomalign", (char *)&dongle_align, 4, iovbuf,

	brcmu_mkiovar("bus:txglomalign", (char *)&dongle_align, 4, iovbuf,

		    sizeof(iovbuf));

	dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));



	/* disable glom option per default */

	bcm_mkiovar("bus:txglom", (char *)&glom, 4, iovbuf, sizeof(iovbuf));

	brcmu_mkiovar("bus:txglom", (char *)&glom, 4, iovbuf, sizeof(iovbuf));

	dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));



	/* Setup timeout if Beacons are lost and roam is off to report

		 link down */

	bcm_mkiovar("bcn_timeout", (char *)&bcn_timeout, 4, iovbuf,

	brcmu_mkiovar("bcn_timeout", (char *)&bcn_timeout, 4, iovbuf,

		    sizeof(iovbuf));

	dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));



	/* Enable/Disable build-in roaming to allowed ext supplicant to take

		 of romaing */

	bcm_mkiovar("roam_off", (char *)&dhd_roam, 4, iovbuf, sizeof(iovbuf));

	brcmu_mkiovar("roam_off", (char *)&dhd_roam, 4, iovbuf, sizeof(iovbuf));

	dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));



	/* Force STA UP */
@@ -1282,8 +1282,8 @@ int dhd_preinit_ioctls(dhd_pub_t *dhd) 
		dhdcdc_set_ioctl(dhd, 0, WLC_UP, (char *)&up, sizeof(up));



	/* Setup event_msgs */

	bcm_mkiovar("event_msgs", dhd->eventmask, WL_EVENTING_MASK_LEN, iovbuf,

		    sizeof(iovbuf));

	brcmu_mkiovar("event_msgs", dhd->eventmask, WL_EVENTING_MASK_LEN,

		      iovbuf, sizeof(iovbuf));

	dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));



	dhdcdc_set_ioctl(dhd, 0, WLC_SET_SCAN_CHANNEL_TIME,
@@ -1647,7 +1647,7 @@ int dhd_iscan_request(void *dhdp, u16 action) 
	params.action = action;

	params.scan_duration = 0;



	bcm_mkiovar("iscan", (char *)&params, sizeof(wl_iscan_params_t), buf,

	brcmu_mkiovar("iscan", (char *)&params, sizeof(wl_iscan_params_t), buf,

		    WLC_IOCTL_SMLEN);

	rc = dhd_wl_ioctl(dhdp, WLC_SET_VAR, buf, WLC_IOCTL_SMLEN);
@@ -1683,7 +1683,8 @@ static int dhd_iscan_get_partial_result(void *dhdp, uint *scan_count) 


	memset(&list, 0, sizeof(list));

	list.results.buflen = WLC_IW_ISCAN_MAXLEN;

	bcm_mkiovar("iscanresults", (char *)&list, WL_ISCAN_RESULTS_FIXED_SIZE,

	brcmu_mkiovar("iscanresults", (char *)&list,

		      WL_ISCAN_RESULTS_FIXED_SIZE,

		      iscan_cur->iscan_buf, WLC_IW_ISCAN_MAXLEN);

	rc = dhd_wl_ioctl(dhdp, WLC_GET_VAR, iscan_cur->iscan_buf,

			  WLC_IW_ISCAN_MAXLEN);
@@ -1714,12 +1715,13 @@ int dhd_pno_clean(dhd_pub_t *dhd) 
	int ret;



	/* Disable pfn */

	iov_len =

	    bcm_mkiovar("pfn", (char *)&pfn_enabled, 4, iovbuf, sizeof(iovbuf));

	iov_len = brcmu_mkiovar("pfn", (char *)&pfn_enabled, 4, iovbuf,

				sizeof(iovbuf));

	ret = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));

	if (ret >= 0) {

		/* clear pfn */

		iov_len = bcm_mkiovar("pfnclear", 0, 0, iovbuf, sizeof(iovbuf));

		iov_len = brcmu_mkiovar("pfnclear", 0, 0, iovbuf,

					sizeof(iovbuf));

		if (iov_len) {

			ret = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf,

					iov_len);
@@ -1748,7 +1750,7 @@ int dhd_pno_enable(dhd_pub_t *dhd, int pfn_enabled) 
	}



	/* Enable/disable PNO */

	ret = bcm_mkiovar("pfn", (char *)&pfn_enabled, 4, iovbuf,

	ret = brcmu_mkiovar("pfn", (char *)&pfn_enabled, 4, iovbuf,

			sizeof(iovbuf));

	if (ret > 0) {

		ret = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf,
@@ -1821,7 +1823,7 @@ dhd_pno_set(dhd_pub_t *dhd, wlc_ssid_t *ssids_local, int nssid, unsigned char sc 
	if (scan_fr != 0)

		pfn_param.scan_freq = scan_fr;



	bcm_mkiovar("pfn_set", (char *)&pfn_param, sizeof(pfn_param), iovbuf,

	brcmu_mkiovar("pfn_set", (char *)&pfn_param, sizeof(pfn_param), iovbuf,

		    sizeof(iovbuf));

	dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
@@ -1838,7 +1840,7 @@ dhd_pno_set(dhd_pub_t *dhd, wlc_ssid_t *ssids_local, int nssid, unsigned char sc 
		       ssids_local[i].SSID_len);

		pfn_element.ssid.SSID_len = ssids_local[i].SSID_len;



		err = bcm_mkiovar("pfn_add", (char *)&pfn_element,

		err = brcmu_mkiovar("pfn_add", (char *)&pfn_element,

				sizeof(pfn_element), iovbuf, sizeof(iovbuf));

		if (err > 0) {

			err = dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf,

drivers/staging/brcm80211/brcmfmac/dhd_linux.c

+9 −9
Original line number Diff line number Diff line
@@ -485,7 +485,7 @@ static int dhd_set_suspend(int value, dhd_pub_t *dhd) 
				bcn_li_dtim = 3;

			else

				bcn_li_dtim = dhd->dtim_skip;

			bcm_mkiovar("bcn_li_dtim", (char *)&bcn_li_dtim,

			brcmu_mkiovar("bcn_li_dtim", (char *)&bcn_li_dtim,

				    4, iovbuf, sizeof(iovbuf));

			dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf,

					 sizeof(iovbuf));
@@ -493,7 +493,7 @@ static int dhd_set_suspend(int value, dhd_pub_t *dhd) 
			/* Disable build-in roaming to allowed \

			 * supplicant to take of romaing

			 */

			bcm_mkiovar("roam_off", (char *)&roamvar, 4,

			brcmu_mkiovar("roam_off", (char *)&roamvar, 4,

				    iovbuf, sizeof(iovbuf));

			dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf,

					 sizeof(iovbuf));
@@ -513,14 +513,14 @@ static int dhd_set_suspend(int value, dhd_pub_t *dhd) 
			dhd_set_packet_filter(0, dhd);



			/* restore pre-suspend setting for dtim_skip */

			bcm_mkiovar("bcn_li_dtim", (char *)&dhd->dtim_skip,

			brcmu_mkiovar("bcn_li_dtim", (char *)&dhd->dtim_skip,

				    4, iovbuf, sizeof(iovbuf));



			dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf,

					 sizeof(iovbuf));

#ifdef CUSTOMER_HW2

			roamvar = 0;

			bcm_mkiovar("roam_off", (char *)&roamvar, 4, iovbuf,

			brcmu_mkiovar("roam_off", (char *)&roamvar, 4, iovbuf,

				    sizeof(iovbuf));

			dhdcdc_set_ioctl(dhd, 0, WLC_SET_VAR, iovbuf,

					 sizeof(iovbuf));
@@ -750,7 +750,7 @@ static void _dhd_set_multicast_list(dhd_info_t *dhd, int ifidx) 
	}

	allmulti = cpu_to_le32(allmulti);



	if (!bcm_mkiovar

	if (!brcmu_mkiovar

	    ("allmulti", (void *)&allmulti, sizeof(allmulti), buf, buflen)) {

		DHD_ERROR(("%s: mkiovar failed for allmulti, datalen %d "

			"buflen %u\n", dhd_ifname(&dhd->pub, ifidx),
@@ -802,7 +802,7 @@ _dhd_set_mac_address(dhd_info_t *dhd, int ifidx, u8 *addr) 
	int ret;



	DHD_TRACE(("%s enter\n", __func__));

	if (!bcm_mkiovar

	if (!brcmu_mkiovar

	    ("cur_etheraddr", (char *)addr, ETH_ALEN, buf, 32)) {

		DHD_ERROR(("%s: mkiovar failed for cur_etheraddr\n",

			   dhd_ifname(&dhd->pub, ifidx)));
@@ -2091,8 +2091,8 @@ int dhd_bus_start(dhd_pub_t *dhdp) 
		return -ENODEV;

	}

#ifdef EMBEDDED_PLATFORM

	bcm_mkiovar("event_msgs", dhdp->eventmask, WL_EVENTING_MASK_LEN, iovbuf,

		    sizeof(iovbuf));

	brcmu_mkiovar("event_msgs", dhdp->eventmask, WL_EVENTING_MASK_LEN,

		      iovbuf, sizeof(iovbuf));

	dhdcdc_query_ioctl(dhdp, 0, WLC_GET_VAR, iovbuf, sizeof(iovbuf));

	memcpy(dhdp->eventmask, iovbuf, WL_EVENTING_MASK_LEN);
@@ -2142,7 +2142,7 @@ dhd_iovar(dhd_pub_t *pub, int ifidx, char *name, char *cmd_buf, uint cmd_len, 
	wl_ioctl_t ioc;

	int ret;



	len = bcm_mkiovar(name, cmd_buf, cmd_len, buf, len);

	len = brcmu_mkiovar(name, cmd_buf, cmd_len, buf, len);



	memset(&ioc, 0, sizeof(ioc));