Attachment #173185 for bug #211519




{
	struct ieee80211com *ic = &sc->sc_ic;
	struct ieee80211_channel *c;
	uint32_t ssid_mask;
	uint8_t nchan;
	int i, j;

	/* NB: all SSIDs for all channels. */
	ssid_mask = 0;
	for (i = 0; i < n_ssids; i++)
		ssid_mask |= 1 << (i + 1);
	ssid_mask = htole32(ssid_mask);

	for (nchan = j = 0;
	    j < ic->ic_nchans && nchan < sc->sc_capa_n_scan_channels; j++) {
		c = &ic->ic_channels[j];

		chan->iter_count = htole16(1);
		chan->iter_interval = htole32(0);
		chan->flags = htole32(IWM_UNIFIED_SCAN_CHANNEL_PARTIAL);
		chan->flags |= ssid_mask;
		if (n_ssids != 0)
			chan->flags |= htole32(1 << 1); /* select SSID 0 */
#endif
		chan++;
		nchan++;
	}

{
	struct ieee80211com *ic = &sc->sc_ic;
	struct ieee80211_channel *c;
	uint32_t ssid_mask;
	uint8_t nchan;
	int i, j;

	/* NB: all SSIDs for all channels. */
	ssid_mask = 0;
	for (i = 0; i < n_ssids; i++)
		ssid_mask |= 1 << i;
	ssid_mask = htole32(ssid_mask);

	for (nchan = j = 0;
	    j < ic->ic_nchans && nchan < sc->sc_capa_n_scan_channels; j++) {
		c = &ic->ic_channels[j];

		chan->iter_count = 1;
		chan->iter_interval = htole16(0);
		chan->flags = htole32(0);
		chan->flags |= ssid_mask;
		if (n_ssids != 0)
			chan->flags = htole32(1 << 0); /* select SSID 0 */
#endif
		chan++;
		nchan++;
	}

	struct ieee80211_rateset *rs;
	size_t remain = sizeof(preq->buf);
	uint8_t *frm, *pos;
	int ssid_len = 0;
	const uint8_t *ssid = NULL;

	memset(preq, 0, sizeof(*preq));

	/* Ensure enough space for header and SSID IE. */
	if (remain < sizeof(*wh) + 2)
		return ENOBUFS;

	/*

	*(uint16_t *)&wh->i_seq[0] = 0; /* filled by HW */

	frm = (uint8_t *)(wh + 1);
	frm = ieee80211_add_ssid(frm, NULL, 0);

	/* Tell the firmware where the MAC header is. */
	preq->mac_header.offset = 0;

		.data = { NULL, },
		.flags = IWM_CMD_SYNC,
	};
	struct ieee80211_scan_state *ss = sc->sc_ic.ic_scan;
	struct iwm_scan_req_umac *req;
	struct iwm_scan_req_umac_tail *tail;
	size_t req_len;
	uint8_t i, nssid;
	const uint8_t *ssid = NULL;
	int ret;

	req_len = sizeof(struct iwm_scan_req_umac) +

	req->scan_priority = htole32(IWM_SCAN_PRIORITY_HIGH);
	req->ooc_priority = htole32(IWM_SCAN_PRIORITY_HIGH);

	nssid = MIN(ss->ss_nssid, IWM_PROBE_OPTION_MAX);
	req->n_channels = iwm_mvm_umac_scan_fill_channels(sc,
	    (struct iwm_scan_channel_cfg_umac *)req->data, nssid);

	req->general_flags = htole32(IWM_UMAC_SCAN_GEN_FLAGS_PASS_ALL |
	    IWM_UMAC_SCAN_GEN_FLAGS_ITER_COMPLETE |

			sc->sc_capa_n_scan_channels);

	/* Check if we're doing an active directed scan. */
	for (i = 0; i < nssid; i++) {
		tail->direct_scan[i].id = IEEE80211_ELEMID_SSID;
		tail->direct_scan[i].len = MIN(ss->ss_ssid[i].len,
		    IEEE80211_NWID_LEN);
		memcpy(tail->direct_scan[i].ssid, ss->ss_ssid[i].ssid,
		    tail->direct_scan[i].len);
		/* XXX debug */
	}
	if (nssid != 0) {
		req->general_flags |=
		    htole32(IWM_UMAC_SCAN_GEN_FLAGS_PRE_CONNECT);
	} else
		req->general_flags |= htole32(IWM_UMAC_SCAN_GEN_FLAGS_PASSIVE);
	}

	if (isset(sc->sc_enabled_capa,
	    IWM_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT))

		.data = { NULL, },
		.flags = IWM_CMD_SYNC,
	};
	struct ieee80211_scan_state *ss = sc->sc_ic.ic_scan;
	struct iwm_scan_req_lmac *req;
	size_t req_len;
	uint8_t i, nssid;
	int ret;
	int ssid_len = 0;
	const uint8_t *ssid = NULL;

	IWM_DPRINTF(sc, IWM_DEBUG_SCAN,
	    "Handling ieee80211 scan request\n");

	req->scan_flags = htole32(IWM_MVM_LMAC_SCAN_FLAG_PASS_ALL |
	    IWM_MVM_LMAC_SCAN_FLAG_ITER_COMPLETE |
	    IWM_MVM_LMAC_SCAN_FLAG_EXTENDED_DWELL);
	if (ssid_len == 0)
		req->scan_flags |= htole32(IWM_MVM_LMAC_SCAN_FLAG_PASSIVE);
	else
		req->scan_flags |=
		    htole32(IWM_MVM_LMAC_SCAN_FLAG_PRE_CONNECTION);
	if (isset(sc->sc_enabled_capa,
	    IWM_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT))
		req->scan_flags |= htole32(IWM_MVM_LMAC_SCAN_FLAGS_RRM_ENABLED);

	req->tx_cmd[1].sta_id = sc->sc_aux_sta.sta_id;

	/* Check if we're doing an active directed scan. */
	nssid = MIN(ss->ss_nssid, IWM_PROBE_OPTION_MAX);
	for (i = 0; i < nssid; i++) {
		req->direct_scan[i].id = IEEE80211_ELEMID_SSID;
		req->direct_scan[i].len = MIN(ss->ss_ssid[i].len,
		    IEEE80211_NWID_LEN);
		memcpy(req->direct_scan[i].ssid, ss->ss_ssid[i].ssid,
		    req->direct_scan[i].len);
		/* XXX debug */
	}
	if (nssid != 0) {
		req->scan_flags |=
		    htole32(IWM_MVM_LMAC_SCAN_FLAG_PRE_CONNECTION);
	} else
		req->scan_flags |= htole32(IWM_MVM_LMAC_SCAN_FLAG_PASSIVE);

	req->n_channels = iwm_mvm_lmac_scan_fill_channels(sc,
	    (struct iwm_scan_channel_cfg_lmac *)req->data, nssid);
	    ssid_len != 0);

	ret = iwm_mvm_fill_probe_req(sc,
			    (struct iwm_scan_probe_req *)(req->data +

Return to bug 211519

Lines 266-274 Link Here

(-)sys/dev/iwm/if_iwm_scan.c (-36 / +50 lines)
266	{	266	{
267	struct ieee80211com *ic = &sc->sc_ic;	267	struct ieee80211com *ic = &sc->sc_ic;
268	struct ieee80211_channel *c;	268	struct ieee80211_channel *c;
		269	uint32_t ssid_mask;
269	uint8_t nchan;	270	uint8_t nchan;
270	int j;	271	int i, j;
271		272
		273	/* NB: all SSIDs for all channels. */
		274	ssid_mask = 0;
		275	for (i = 0; i < n_ssids; i++)
		276	ssid_mask \|= 1 << (i + 1);
		277	ssid_mask = htole32(ssid_mask);
		278
272	for (nchan = j = 0;	279	for (nchan = j = 0;
273	j < ic->ic_nchans && nchan < sc->sc_capa_n_scan_channels; j++) {	280	j < ic->ic_nchans && nchan < sc->sc_capa_n_scan_channels; j++) {
274	c = &ic->ic_channels[j];	281	c = &ic->ic_channels[j];
Lines 292-301 Link Here
292	chan->iter_count = htole16(1);	299	chan->iter_count = htole16(1);
293	chan->iter_interval = htole32(0);	300	chan->iter_interval = htole32(0);
294	chan->flags = htole32(IWM_UNIFIED_SCAN_CHANNEL_PARTIAL);	301	chan->flags = htole32(IWM_UNIFIED_SCAN_CHANNEL_PARTIAL);
295	#if 0 /* makes scanning while associated less useful */	302	chan->flags \|= ssid_mask;
296	if (n_ssids != 0)
297	chan->flags \|= htole32(1 << 1); /* select SSID 0 */
298	#endif
299	chan++;	303	chan++;
300	nchan++;	304	nchan++;
301	}	305	}
Lines 309-317 Link Here
309	{	313	{
310	struct ieee80211com *ic = &sc->sc_ic;	314	struct ieee80211com *ic = &sc->sc_ic;
311	struct ieee80211_channel *c;	315	struct ieee80211_channel *c;
		316	uint32_t ssid_mask;
312	uint8_t nchan;	317	uint8_t nchan;
313	int j;	318	int i, j;
314		319
		320	/* NB: all SSIDs for all channels. */
		321	ssid_mask = 0;
		322	for (i = 0; i < n_ssids; i++)
		323	ssid_mask \|= 1 << i;
		324	ssid_mask = htole32(ssid_mask);
		325
315	for (nchan = j = 0;	326	for (nchan = j = 0;
316	j < ic->ic_nchans && nchan < sc->sc_capa_n_scan_channels; j++) {	327	j < ic->ic_nchans && nchan < sc->sc_capa_n_scan_channels; j++) {
317	c = &ic->ic_channels[j];	328	c = &ic->ic_channels[j];
Lines 335-344 Link Here
335	chan->iter_count = 1;	346	chan->iter_count = 1;
336	chan->iter_interval = htole16(0);	347	chan->iter_interval = htole16(0);
337	chan->flags = htole32(0);	348	chan->flags = htole32(0);
338	#if 0 /* makes scanning while associated less useful */	349	chan->flags \|= ssid_mask;
339	if (n_ssids != 0)
340	chan->flags = htole32(1 << 0); /* select SSID 0 */
341	#endif
342	chan++;	350	chan++;
343	nchan++;	351	nchan++;
344	}	352	}
Lines 355-367 Link Here
355	struct ieee80211_rateset *rs;	363	struct ieee80211_rateset *rs;
356	size_t remain = sizeof(preq->buf);	364	size_t remain = sizeof(preq->buf);
357	uint8_t frm, pos;	365	uint8_t frm, pos;
358	int ssid_len = 0;
359	const uint8_t *ssid = NULL;
360		366
361	memset(preq, 0, sizeof(*preq));	367	memset(preq, 0, sizeof(*preq));
362		368
363	/* Ensure enough space for header and SSID IE. */	369	/* Ensure enough space for header and SSID IE. */
364	if (remain < sizeof(*wh) + 2 + ssid_len)	370	if (remain < sizeof(*wh) + 2)
365	return ENOBUFS;	371	return ENOBUFS;
366		372
367	/*	373	/*
Lines 378-384 Link Here
378	(uint16_t )&wh->i_seq[0] = 0; /* filled by HW */	384	(uint16_t )&wh->i_seq[0] = 0; /* filled by HW */
379		385
380	frm = (uint8_t *)(wh + 1);	386	frm = (uint8_t *)(wh + 1);
381	frm = ieee80211_add_ssid(frm, ssid, ssid_len);	387	frm = ieee80211_add_ssid(frm, NULL, 0);
382		388
383	/* Tell the firmware where the MAC header is. */	389	/* Tell the firmware where the MAC header is. */
384	preq->mac_header.offset = 0;	390	preq->mac_header.offset = 0;
Lines 544-554 Link Here
544	.data = { NULL, },	550	.data = { NULL, },
545	.flags = IWM_CMD_SYNC,	551	.flags = IWM_CMD_SYNC,
546	};	552	};
		553	struct ieee80211_scan_state *ss = sc->sc_ic.ic_scan;
547	struct iwm_scan_req_umac *req;	554	struct iwm_scan_req_umac *req;
548	struct iwm_scan_req_umac_tail *tail;	555	struct iwm_scan_req_umac_tail *tail;
549	size_t req_len;	556	size_t req_len;
550	int ssid_len = 0;	557	uint8_t i, nssid;
551	const uint8_t *ssid = NULL;
552	int ret;	558	int ret;
553		559
554	req_len = sizeof(struct iwm_scan_req_umac) +	560	req_len = sizeof(struct iwm_scan_req_umac) +
Lines 577-584 Link Here
577	req->scan_priority = htole32(IWM_SCAN_PRIORITY_HIGH);	583	req->scan_priority = htole32(IWM_SCAN_PRIORITY_HIGH);
578	req->ooc_priority = htole32(IWM_SCAN_PRIORITY_HIGH);	584	req->ooc_priority = htole32(IWM_SCAN_PRIORITY_HIGH);
579		585
		586	nssid = MIN(ss->ss_nssid, IWM_PROBE_OPTION_MAX);
580	req->n_channels = iwm_mvm_umac_scan_fill_channels(sc,	587	req->n_channels = iwm_mvm_umac_scan_fill_channels(sc,
581	(struct iwm_scan_channel_cfg_umac *)req->data, ssid_len != 0);	588	(struct iwm_scan_channel_cfg_umac *)req->data, nssid);
582		589
583	req->general_flags = htole32(IWM_UMAC_SCAN_GEN_FLAGS_PASS_ALL \|	590	req->general_flags = htole32(IWM_UMAC_SCAN_GEN_FLAGS_PASS_ALL \|
584	IWM_UMAC_SCAN_GEN_FLAGS_ITER_COMPLETE \|	591	IWM_UMAC_SCAN_GEN_FLAGS_ITER_COMPLETE \|
Lines 589-603 Link Here
589	sc->sc_capa_n_scan_channels);	596	sc->sc_capa_n_scan_channels);
590		597
591	/* Check if we're doing an active directed scan. */	598	/* Check if we're doing an active directed scan. */
592	if (ssid_len != 0) {	599	for (i = 0; i < nssid; i++) {
593	tail->direct_scan[0].id = IEEE80211_ELEMID_SSID;	600	tail->direct_scan[i].id = IEEE80211_ELEMID_SSID;
594	tail->direct_scan[0].len = ssid_len;	601	tail->direct_scan[i].len = MIN(ss->ss_ssid[i].len,
595	memcpy(tail->direct_scan[0].ssid, ssid, ssid_len);	602	IEEE80211_NWID_LEN);
		603	memcpy(tail->direct_scan[i].ssid, ss->ss_ssid[i].ssid,
		604	tail->direct_scan[i].len);
		605	/* XXX debug */
		606	}
		607	if (nssid != 0) {
596	req->general_flags \|=	608	req->general_flags \|=
597	htole32(IWM_UMAC_SCAN_GEN_FLAGS_PRE_CONNECT);	609	htole32(IWM_UMAC_SCAN_GEN_FLAGS_PRE_CONNECT);
598	} else {	610	} else
599	req->general_flags \|= htole32(IWM_UMAC_SCAN_GEN_FLAGS_PASSIVE);	611	req->general_flags \|= htole32(IWM_UMAC_SCAN_GEN_FLAGS_PASSIVE);
600	}
601		612
602	if (isset(sc->sc_enabled_capa,	613	if (isset(sc->sc_enabled_capa,
603	IWM_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT))	614	IWM_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT))
Lines 631-641 Link Here
631	.data = { NULL, },	642	.data = { NULL, },
632	.flags = IWM_CMD_SYNC,	643	.flags = IWM_CMD_SYNC,
633	};	644	};
		645	struct ieee80211_scan_state *ss = sc->sc_ic.ic_scan;
634	struct iwm_scan_req_lmac *req;	646	struct iwm_scan_req_lmac *req;
635	size_t req_len;	647	size_t req_len;
		648	uint8_t i, nssid;
636	int ret;	649	int ret;
637	int ssid_len = 0;
638	const uint8_t *ssid = NULL;
639		650
640	IWM_DPRINTF(sc, IWM_DEBUG_SCAN,	651	IWM_DPRINTF(sc, IWM_DEBUG_SCAN,
641	"Handling ieee80211 scan request\n");	652	"Handling ieee80211 scan request\n");
Lines 668-678 Link Here
668	req->scan_flags = htole32(IWM_MVM_LMAC_SCAN_FLAG_PASS_ALL \|	679	req->scan_flags = htole32(IWM_MVM_LMAC_SCAN_FLAG_PASS_ALL \|
669	IWM_MVM_LMAC_SCAN_FLAG_ITER_COMPLETE \|	680	IWM_MVM_LMAC_SCAN_FLAG_ITER_COMPLETE \|
670	IWM_MVM_LMAC_SCAN_FLAG_EXTENDED_DWELL);	681	IWM_MVM_LMAC_SCAN_FLAG_EXTENDED_DWELL);
671	if (ssid_len == 0)
672	req->scan_flags \|= htole32(IWM_MVM_LMAC_SCAN_FLAG_PASSIVE);
673	else
674	req->scan_flags \|=
675	htole32(IWM_MVM_LMAC_SCAN_FLAG_PRE_CONNECTION);
676	if (isset(sc->sc_enabled_capa,	682	if (isset(sc->sc_enabled_capa,
677	IWM_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT))	683	IWM_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT))
678	req->scan_flags \|= htole32(IWM_MVM_LMAC_SCAN_FLAGS_RRM_ENABLED);	684	req->scan_flags \|= htole32(IWM_MVM_LMAC_SCAN_FLAGS_RRM_ENABLED);
Lines 698-712 Link Here
698	req->tx_cmd[1].sta_id = sc->sc_aux_sta.sta_id;	704	req->tx_cmd[1].sta_id = sc->sc_aux_sta.sta_id;
699		705
700	/* Check if we're doing an active directed scan. */	706	/* Check if we're doing an active directed scan. */
701	if (ssid_len != 0) {	707	nssid = MIN(ss->ss_nssid, IWM_PROBE_OPTION_MAX);
702	req->direct_scan[0].id = IEEE80211_ELEMID_SSID;	708	for (i = 0; i < nssid; i++) {
703	req->direct_scan[0].len = ssid_len;	709	req->direct_scan[i].id = IEEE80211_ELEMID_SSID;
704	memcpy(req->direct_scan[0].ssid, ssid, ssid_len);	710	req->direct_scan[i].len = MIN(ss->ss_ssid[i].len,
		711	IEEE80211_NWID_LEN);
		712	memcpy(req->direct_scan[i].ssid, ss->ss_ssid[i].ssid,
		713	req->direct_scan[i].len);
		714	/* XXX debug */
705	}	715	}
		716	if (nssid != 0) {
		717	req->scan_flags \|=
		718	htole32(IWM_MVM_LMAC_SCAN_FLAG_PRE_CONNECTION);
		719	} else
		720	req->scan_flags \|= htole32(IWM_MVM_LMAC_SCAN_FLAG_PASSIVE);
706		721
707	req->n_channels = iwm_mvm_lmac_scan_fill_channels(sc,	722	req->n_channels = iwm_mvm_lmac_scan_fill_channels(sc,
708	(struct iwm_scan_channel_cfg_lmac *)req->data,	723	(struct iwm_scan_channel_cfg_lmac *)req->data, nssid);
709	ssid_len != 0);
710		724
711	ret = iwm_mvm_fill_probe_req(sc,	725	ret = iwm_mvm_fill_probe_req(sc,
712	(struct iwm_scan_probe_req *)(req->data +	726	(struct iwm_scan_probe_req *)(req->data +