• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2012 Broadcom Corporation
3  *
4  * Permission to use, copy, modify, and/or distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 #include <linux/slab.h>
17 #include <linux/netdevice.h>
18 #include <linux/etherdevice.h>
19 #include <linux/rtnetlink.h>
20 #include <net/cfg80211.h>
21 
22 #include <brcmu_wifi.h>
23 #include <brcmu_utils.h>
24 #include <defs.h>
25 #include "core.h"
26 #include "debug.h"
27 #include "fwil.h"
28 #include "fwil_types.h"
29 #include "p2p.h"
30 #include "cfg80211.h"
31 
32 /* parameters used for p2p escan */
33 #define P2PAPI_SCAN_NPROBES 1
34 #define P2PAPI_SCAN_DWELL_TIME_MS 80
35 #define P2PAPI_SCAN_SOCIAL_DWELL_TIME_MS 40
36 #define P2PAPI_SCAN_HOME_TIME_MS 60
37 #define P2PAPI_SCAN_NPROBS_TIME_MS 30
38 #define P2PAPI_SCAN_AF_SEARCH_DWELL_TIME_MS 100
39 #define WL_SCAN_CONNECT_DWELL_TIME_MS 200
40 #define WL_SCAN_JOIN_PROBE_INTERVAL_MS 20
41 
42 #define BRCMF_P2P_WILDCARD_SSID		"DIRECT-"
43 #define BRCMF_P2P_WILDCARD_SSID_LEN	(sizeof(BRCMF_P2P_WILDCARD_SSID) - 1)
44 
45 #define SOCIAL_CHAN_1		1
46 #define SOCIAL_CHAN_2		6
47 #define SOCIAL_CHAN_3		11
48 #define IS_P2P_SOCIAL_CHANNEL(channel) ((channel == SOCIAL_CHAN_1) || \
49 					 (channel == SOCIAL_CHAN_2) || \
50 					 (channel == SOCIAL_CHAN_3))
51 #define BRCMF_P2P_TEMP_CHAN	SOCIAL_CHAN_3
52 #define SOCIAL_CHAN_CNT		3
53 #define AF_PEER_SEARCH_CNT	2
54 
55 #define BRCMF_SCB_TIMEOUT_VALUE	20
56 
57 #define P2P_VER			9	/* P2P version: 9=WiFi P2P v1.0 */
58 #define P2P_PUB_AF_CATEGORY	0x04
59 #define P2P_PUB_AF_ACTION	0x09
60 #define P2P_AF_CATEGORY		0x7f
61 #define P2P_OUI			"\x50\x6F\x9A"	/* P2P OUI */
62 #define P2P_OUI_LEN		3		/* P2P OUI length */
63 
64 /* Action Frame Constants */
65 #define DOT11_ACTION_HDR_LEN	2	/* action frame category + action */
66 #define DOT11_ACTION_CAT_OFF	0	/* category offset */
67 #define DOT11_ACTION_ACT_OFF	1	/* action offset */
68 
69 #define P2P_AF_DWELL_TIME		200
70 #define P2P_AF_MIN_DWELL_TIME		100
71 #define P2P_AF_MED_DWELL_TIME		400
72 #define P2P_AF_LONG_DWELL_TIME		1000
73 #define P2P_AF_TX_MAX_RETRY		1
74 #define P2P_AF_MAX_WAIT_TIME		msecs_to_jiffies(2000)
75 #define P2P_INVALID_CHANNEL		-1
76 #define P2P_CHANNEL_SYNC_RETRY		5
77 #define P2P_AF_FRM_SCAN_MAX_WAIT	msecs_to_jiffies(450)
78 #define P2P_DEFAULT_SLEEP_TIME_VSDB	200
79 
80 /* WiFi P2P Public Action Frame OUI Subtypes */
81 #define P2P_PAF_GON_REQ		0	/* Group Owner Negotiation Req */
82 #define P2P_PAF_GON_RSP		1	/* Group Owner Negotiation Rsp */
83 #define P2P_PAF_GON_CONF	2	/* Group Owner Negotiation Confirm */
84 #define P2P_PAF_INVITE_REQ	3	/* P2P Invitation Request */
85 #define P2P_PAF_INVITE_RSP	4	/* P2P Invitation Response */
86 #define P2P_PAF_DEVDIS_REQ	5	/* Device Discoverability Request */
87 #define P2P_PAF_DEVDIS_RSP	6	/* Device Discoverability Response */
88 #define P2P_PAF_PROVDIS_REQ	7	/* Provision Discovery Request */
89 #define P2P_PAF_PROVDIS_RSP	8	/* Provision Discovery Response */
90 #define P2P_PAF_SUBTYPE_INVALID	255	/* Invalid Subtype */
91 
92 /* WiFi P2P Action Frame OUI Subtypes */
93 #define P2P_AF_NOTICE_OF_ABSENCE	0	/* Notice of Absence */
94 #define P2P_AF_PRESENCE_REQ		1	/* P2P Presence Request */
95 #define P2P_AF_PRESENCE_RSP		2	/* P2P Presence Response */
96 #define P2P_AF_GO_DISC_REQ		3	/* GO Discoverability Request */
97 
98 /* P2P Service Discovery related */
99 #define P2PSD_ACTION_CATEGORY		0x04	/* Public action frame */
100 #define P2PSD_ACTION_ID_GAS_IREQ	0x0a	/* GAS Initial Request AF */
101 #define P2PSD_ACTION_ID_GAS_IRESP	0x0b	/* GAS Initial Response AF */
102 #define P2PSD_ACTION_ID_GAS_CREQ	0x0c	/* GAS Comback Request AF */
103 #define P2PSD_ACTION_ID_GAS_CRESP	0x0d	/* GAS Comback Response AF */
104 
105 #define BRCMF_P2P_DISABLE_TIMEOUT	msecs_to_jiffies(500)
106 /**
107  * struct brcmf_p2p_disc_st_le - set discovery state in firmware.
108  *
109  * @state: requested discovery state (see enum brcmf_p2p_disc_state).
110  * @chspec: channel parameter for %WL_P2P_DISC_ST_LISTEN state.
111  * @dwell: dwell time in ms for %WL_P2P_DISC_ST_LISTEN state.
112  */
113 struct brcmf_p2p_disc_st_le {
114 	u8 state;
115 	__le16 chspec;
116 	__le16 dwell;
117 };
118 
119 /**
120  * enum brcmf_p2p_disc_state - P2P discovery state values
121  *
122  * @WL_P2P_DISC_ST_SCAN: P2P discovery with wildcard SSID and P2P IE.
123  * @WL_P2P_DISC_ST_LISTEN: P2P discovery off-channel for specified time.
124  * @WL_P2P_DISC_ST_SEARCH: P2P discovery with P2P wildcard SSID and P2P IE.
125  */
126 enum brcmf_p2p_disc_state {
127 	WL_P2P_DISC_ST_SCAN,
128 	WL_P2P_DISC_ST_LISTEN,
129 	WL_P2P_DISC_ST_SEARCH
130 };
131 
132 /**
133  * struct brcmf_p2p_scan_le - P2P specific scan request.
134  *
135  * @type: type of scan method requested (values: 'E' or 'S').
136  * @reserved: reserved (ignored).
137  * @eparams: parameters used for type 'E'.
138  * @sparams: parameters used for type 'S'.
139  */
140 struct brcmf_p2p_scan_le {
141 	u8 type;
142 	u8 reserved[3];
143 	union {
144 		struct brcmf_escan_params_le eparams;
145 		struct brcmf_scan_params_le sparams;
146 	};
147 };
148 
149 /**
150  * struct brcmf_p2p_pub_act_frame - WiFi P2P Public Action Frame
151  *
152  * @category: P2P_PUB_AF_CATEGORY
153  * @action: P2P_PUB_AF_ACTION
154  * @oui[3]: P2P_OUI
155  * @oui_type: OUI type - P2P_VER
156  * @subtype: OUI subtype - P2P_TYPE_*
157  * @dialog_token: nonzero, identifies req/rsp transaction
158  * @elts[1]: Variable length information elements.
159  */
160 struct brcmf_p2p_pub_act_frame {
161 	u8	category;
162 	u8	action;
163 	u8	oui[3];
164 	u8	oui_type;
165 	u8	subtype;
166 	u8	dialog_token;
167 	u8	elts[1];
168 };
169 
170 /**
171  * struct brcmf_p2p_action_frame - WiFi P2P Action Frame
172  *
173  * @category: P2P_AF_CATEGORY
174  * @OUI[3]: OUI - P2P_OUI
175  * @type: OUI Type - P2P_VER
176  * @subtype: OUI Subtype - P2P_AF_*
177  * @dialog_token: nonzero, identifies req/resp tranaction
178  * @elts[1]: Variable length information elements.
179  */
180 struct brcmf_p2p_action_frame {
181 	u8	category;
182 	u8	oui[3];
183 	u8	type;
184 	u8	subtype;
185 	u8	dialog_token;
186 	u8	elts[1];
187 };
188 
189 /**
190  * struct brcmf_p2psd_gas_pub_act_frame - Wi-Fi GAS Public Action Frame
191  *
192  * @category: 0x04 Public Action Frame
193  * @action: 0x6c Advertisement Protocol
194  * @dialog_token: nonzero, identifies req/rsp transaction
195  * @query_data[1]: Query Data. SD gas ireq SD gas iresp
196  */
197 struct brcmf_p2psd_gas_pub_act_frame {
198 	u8	category;
199 	u8	action;
200 	u8	dialog_token;
201 	u8	query_data[1];
202 };
203 
204 /**
205  * struct brcmf_config_af_params - Action Frame Parameters for tx.
206  *
207  * @mpc_onoff: To make sure to send successfully action frame, we have to
208  *             turn off mpc  0: off, 1: on,  (-1): do nothing
209  * @search_channel: 1: search peer's channel to send af
210  * extra_listen: keep the dwell time to get af response frame.
211  */
212 struct brcmf_config_af_params {
213 	s32 mpc_onoff;
214 	bool search_channel;
215 	bool extra_listen;
216 };
217 
218 /**
219  * brcmf_p2p_is_pub_action() - true if p2p public type frame.
220  *
221  * @frame: action frame data.
222  * @frame_len: length of action frame data.
223  *
224  * Determine if action frame is p2p public action type
225  */
brcmf_p2p_is_pub_action(void * frame,u32 frame_len)226 static bool brcmf_p2p_is_pub_action(void *frame, u32 frame_len)
227 {
228 	struct brcmf_p2p_pub_act_frame *pact_frm;
229 
230 	if (frame == NULL)
231 		return false;
232 
233 	pact_frm = (struct brcmf_p2p_pub_act_frame *)frame;
234 	if (frame_len < sizeof(struct brcmf_p2p_pub_act_frame) - 1)
235 		return false;
236 
237 	if (pact_frm->category == P2P_PUB_AF_CATEGORY &&
238 	    pact_frm->action == P2P_PUB_AF_ACTION &&
239 	    pact_frm->oui_type == P2P_VER &&
240 	    memcmp(pact_frm->oui, P2P_OUI, P2P_OUI_LEN) == 0)
241 		return true;
242 
243 	return false;
244 }
245 
246 /**
247  * brcmf_p2p_is_p2p_action() - true if p2p action type frame.
248  *
249  * @frame: action frame data.
250  * @frame_len: length of action frame data.
251  *
252  * Determine if action frame is p2p action type
253  */
brcmf_p2p_is_p2p_action(void * frame,u32 frame_len)254 static bool brcmf_p2p_is_p2p_action(void *frame, u32 frame_len)
255 {
256 	struct brcmf_p2p_action_frame *act_frm;
257 
258 	if (frame == NULL)
259 		return false;
260 
261 	act_frm = (struct brcmf_p2p_action_frame *)frame;
262 	if (frame_len < sizeof(struct brcmf_p2p_action_frame) - 1)
263 		return false;
264 
265 	if (act_frm->category == P2P_AF_CATEGORY &&
266 	    act_frm->type  == P2P_VER &&
267 	    memcmp(act_frm->oui, P2P_OUI, P2P_OUI_LEN) == 0)
268 		return true;
269 
270 	return false;
271 }
272 
273 /**
274  * brcmf_p2p_is_gas_action() - true if p2p gas action type frame.
275  *
276  * @frame: action frame data.
277  * @frame_len: length of action frame data.
278  *
279  * Determine if action frame is p2p gas action type
280  */
brcmf_p2p_is_gas_action(void * frame,u32 frame_len)281 static bool brcmf_p2p_is_gas_action(void *frame, u32 frame_len)
282 {
283 	struct brcmf_p2psd_gas_pub_act_frame *sd_act_frm;
284 
285 	if (frame == NULL)
286 		return false;
287 
288 	sd_act_frm = (struct brcmf_p2psd_gas_pub_act_frame *)frame;
289 	if (frame_len < sizeof(struct brcmf_p2psd_gas_pub_act_frame) - 1)
290 		return false;
291 
292 	if (sd_act_frm->category != P2PSD_ACTION_CATEGORY)
293 		return false;
294 
295 	if (sd_act_frm->action == P2PSD_ACTION_ID_GAS_IREQ ||
296 	    sd_act_frm->action == P2PSD_ACTION_ID_GAS_IRESP ||
297 	    sd_act_frm->action == P2PSD_ACTION_ID_GAS_CREQ ||
298 	    sd_act_frm->action == P2PSD_ACTION_ID_GAS_CRESP)
299 		return true;
300 
301 	return false;
302 }
303 
304 /**
305  * brcmf_p2p_print_actframe() - debug print routine.
306  *
307  * @tx: Received or to be transmitted
308  * @frame: action frame data.
309  * @frame_len: length of action frame data.
310  *
311  * Print information about the p2p action frame
312  */
313 
314 #ifdef DEBUG
315 
brcmf_p2p_print_actframe(bool tx,void * frame,u32 frame_len)316 static void brcmf_p2p_print_actframe(bool tx, void *frame, u32 frame_len)
317 {
318 	struct brcmf_p2p_pub_act_frame *pact_frm;
319 	struct brcmf_p2p_action_frame *act_frm;
320 	struct brcmf_p2psd_gas_pub_act_frame *sd_act_frm;
321 
322 	if (!frame || frame_len <= 2)
323 		return;
324 
325 	if (brcmf_p2p_is_pub_action(frame, frame_len)) {
326 		pact_frm = (struct brcmf_p2p_pub_act_frame *)frame;
327 		switch (pact_frm->subtype) {
328 		case P2P_PAF_GON_REQ:
329 			brcmf_dbg(TRACE, "%s P2P Group Owner Negotiation Req Frame\n",
330 				  (tx) ? "TX" : "RX");
331 			break;
332 		case P2P_PAF_GON_RSP:
333 			brcmf_dbg(TRACE, "%s P2P Group Owner Negotiation Rsp Frame\n",
334 				  (tx) ? "TX" : "RX");
335 			break;
336 		case P2P_PAF_GON_CONF:
337 			brcmf_dbg(TRACE, "%s P2P Group Owner Negotiation Confirm Frame\n",
338 				  (tx) ? "TX" : "RX");
339 			break;
340 		case P2P_PAF_INVITE_REQ:
341 			brcmf_dbg(TRACE, "%s P2P Invitation Request  Frame\n",
342 				  (tx) ? "TX" : "RX");
343 			break;
344 		case P2P_PAF_INVITE_RSP:
345 			brcmf_dbg(TRACE, "%s P2P Invitation Response Frame\n",
346 				  (tx) ? "TX" : "RX");
347 			break;
348 		case P2P_PAF_DEVDIS_REQ:
349 			brcmf_dbg(TRACE, "%s P2P Device Discoverability Request Frame\n",
350 				  (tx) ? "TX" : "RX");
351 			break;
352 		case P2P_PAF_DEVDIS_RSP:
353 			brcmf_dbg(TRACE, "%s P2P Device Discoverability Response Frame\n",
354 				  (tx) ? "TX" : "RX");
355 			break;
356 		case P2P_PAF_PROVDIS_REQ:
357 			brcmf_dbg(TRACE, "%s P2P Provision Discovery Request Frame\n",
358 				  (tx) ? "TX" : "RX");
359 			break;
360 		case P2P_PAF_PROVDIS_RSP:
361 			brcmf_dbg(TRACE, "%s P2P Provision Discovery Response Frame\n",
362 				  (tx) ? "TX" : "RX");
363 			break;
364 		default:
365 			brcmf_dbg(TRACE, "%s Unknown P2P Public Action Frame\n",
366 				  (tx) ? "TX" : "RX");
367 			break;
368 		}
369 	} else if (brcmf_p2p_is_p2p_action(frame, frame_len)) {
370 		act_frm = (struct brcmf_p2p_action_frame *)frame;
371 		switch (act_frm->subtype) {
372 		case P2P_AF_NOTICE_OF_ABSENCE:
373 			brcmf_dbg(TRACE, "%s P2P Notice of Absence Frame\n",
374 				  (tx) ? "TX" : "RX");
375 			break;
376 		case P2P_AF_PRESENCE_REQ:
377 			brcmf_dbg(TRACE, "%s P2P Presence Request Frame\n",
378 				  (tx) ? "TX" : "RX");
379 			break;
380 		case P2P_AF_PRESENCE_RSP:
381 			brcmf_dbg(TRACE, "%s P2P Presence Response Frame\n",
382 				  (tx) ? "TX" : "RX");
383 			break;
384 		case P2P_AF_GO_DISC_REQ:
385 			brcmf_dbg(TRACE, "%s P2P Discoverability Request Frame\n",
386 				  (tx) ? "TX" : "RX");
387 			break;
388 		default:
389 			brcmf_dbg(TRACE, "%s Unknown P2P Action Frame\n",
390 				  (tx) ? "TX" : "RX");
391 		}
392 
393 	} else if (brcmf_p2p_is_gas_action(frame, frame_len)) {
394 		sd_act_frm = (struct brcmf_p2psd_gas_pub_act_frame *)frame;
395 		switch (sd_act_frm->action) {
396 		case P2PSD_ACTION_ID_GAS_IREQ:
397 			brcmf_dbg(TRACE, "%s P2P GAS Initial Request\n",
398 				  (tx) ? "TX" : "RX");
399 			break;
400 		case P2PSD_ACTION_ID_GAS_IRESP:
401 			brcmf_dbg(TRACE, "%s P2P GAS Initial Response\n",
402 				  (tx) ? "TX" : "RX");
403 			break;
404 		case P2PSD_ACTION_ID_GAS_CREQ:
405 			brcmf_dbg(TRACE, "%s P2P GAS Comback Request\n",
406 				  (tx) ? "TX" : "RX");
407 			break;
408 		case P2PSD_ACTION_ID_GAS_CRESP:
409 			brcmf_dbg(TRACE, "%s P2P GAS Comback Response\n",
410 				  (tx) ? "TX" : "RX");
411 			break;
412 		default:
413 			brcmf_dbg(TRACE, "%s Unknown P2P GAS Frame\n",
414 				  (tx) ? "TX" : "RX");
415 			break;
416 		}
417 	}
418 }
419 
420 #else
421 
brcmf_p2p_print_actframe(bool tx,void * frame,u32 frame_len)422 static void brcmf_p2p_print_actframe(bool tx, void *frame, u32 frame_len)
423 {
424 }
425 
426 #endif
427 
428 
429 /**
430  * brcmf_p2p_set_firmware() - prepare firmware for peer-to-peer operation.
431  *
432  * @ifp: ifp to use for iovars (primary).
433  * @p2p_mac: mac address to configure for p2p_da_override
434  */
brcmf_p2p_set_firmware(struct brcmf_if * ifp,u8 * p2p_mac)435 static int brcmf_p2p_set_firmware(struct brcmf_if *ifp, u8 *p2p_mac)
436 {
437 	s32 ret = 0;
438 
439 	brcmf_fil_cmd_int_set(ifp, BRCMF_C_DOWN, 1);
440 	brcmf_fil_iovar_int_set(ifp, "apsta", 1);
441 	brcmf_fil_cmd_int_set(ifp, BRCMF_C_UP, 1);
442 
443 	/* In case of COB type, firmware has default mac address
444 	 * After Initializing firmware, we have to set current mac address to
445 	 * firmware for P2P device address. This must be done with discovery
446 	 * disabled.
447 	 */
448 	brcmf_fil_iovar_int_set(ifp, "p2p_disc", 0);
449 
450 	ret = brcmf_fil_iovar_data_set(ifp, "p2p_da_override", p2p_mac,
451 				       ETH_ALEN);
452 	if (ret)
453 		brcmf_err("failed to update device address ret %d\n", ret);
454 
455 	return ret;
456 }
457 
458 /**
459  * brcmf_p2p_generate_bss_mac() - derive mac addresses for P2P.
460  *
461  * @p2p: P2P specific data.
462  * @dev_addr: optional device address.
463  *
464  * P2P needs mac addresses for P2P device and interface. If no device
465  * address it specified, these are derived from a random ethernet
466  * address.
467  */
brcmf_p2p_generate_bss_mac(struct brcmf_p2p_info * p2p,u8 * dev_addr)468 static void brcmf_p2p_generate_bss_mac(struct brcmf_p2p_info *p2p, u8 *dev_addr)
469 {
470 	bool random_addr = false;
471 
472 	if (!dev_addr || is_zero_ether_addr(dev_addr))
473 		random_addr = true;
474 
475 	/* Generate the P2P Device Address obtaining a random ethernet
476 	 * address with the locally administered bit set.
477 	 */
478 	if (random_addr)
479 		eth_random_addr(p2p->dev_addr);
480 	else
481 		memcpy(p2p->dev_addr, dev_addr, ETH_ALEN);
482 
483 	/* Generate the P2P Interface Address.  If the discovery and connection
484 	 * BSSCFGs need to simultaneously co-exist, then this address must be
485 	 * different from the P2P Device Address, but also locally administered.
486 	 */
487 	memcpy(p2p->int_addr, p2p->dev_addr, ETH_ALEN);
488 	p2p->int_addr[0] |= 0x02;
489 	p2p->int_addr[4] ^= 0x80;
490 }
491 
492 /**
493  * brcmf_p2p_scan_is_p2p_request() - is cfg80211 scan request a P2P scan.
494  *
495  * @request: the scan request as received from cfg80211.
496  *
497  * returns true if one of the ssids in the request matches the
498  * P2P wildcard ssid; otherwise returns false.
499  */
brcmf_p2p_scan_is_p2p_request(struct cfg80211_scan_request * request)500 static bool brcmf_p2p_scan_is_p2p_request(struct cfg80211_scan_request *request)
501 {
502 	struct cfg80211_ssid *ssids = request->ssids;
503 	int i;
504 
505 	for (i = 0; i < request->n_ssids; i++) {
506 		if (ssids[i].ssid_len != BRCMF_P2P_WILDCARD_SSID_LEN)
507 			continue;
508 
509 		brcmf_dbg(INFO, "comparing ssid \"%s\"", ssids[i].ssid);
510 		if (!memcmp(BRCMF_P2P_WILDCARD_SSID, ssids[i].ssid,
511 			    BRCMF_P2P_WILDCARD_SSID_LEN))
512 			return true;
513 	}
514 	return false;
515 }
516 
517 /**
518  * brcmf_p2p_set_discover_state - set discover state in firmware.
519  *
520  * @ifp: low-level interface object.
521  * @state: discover state to set.
522  * @chanspec: channel parameters (for state @WL_P2P_DISC_ST_LISTEN only).
523  * @listen_ms: duration to listen (for state @WL_P2P_DISC_ST_LISTEN only).
524  */
brcmf_p2p_set_discover_state(struct brcmf_if * ifp,u8 state,u16 chanspec,u16 listen_ms)525 static s32 brcmf_p2p_set_discover_state(struct brcmf_if *ifp, u8 state,
526 					u16 chanspec, u16 listen_ms)
527 {
528 	struct brcmf_p2p_disc_st_le discover_state;
529 	s32 ret = 0;
530 	brcmf_dbg(TRACE, "enter\n");
531 
532 	discover_state.state = state;
533 	discover_state.chspec = cpu_to_le16(chanspec);
534 	discover_state.dwell = cpu_to_le16(listen_ms);
535 	ret = brcmf_fil_bsscfg_data_set(ifp, "p2p_state", &discover_state,
536 					sizeof(discover_state));
537 	return ret;
538 }
539 
540 /**
541  * brcmf_p2p_deinit_discovery() - disable P2P device discovery.
542  *
543  * @p2p: P2P specific data.
544  *
545  * Resets the discovery state and disables it in firmware.
546  */
brcmf_p2p_deinit_discovery(struct brcmf_p2p_info * p2p)547 static s32 brcmf_p2p_deinit_discovery(struct brcmf_p2p_info *p2p)
548 {
549 	struct brcmf_cfg80211_vif *vif;
550 
551 	brcmf_dbg(TRACE, "enter\n");
552 
553 	/* Set the discovery state to SCAN */
554 	vif = p2p->bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
555 	(void)brcmf_p2p_set_discover_state(vif->ifp, WL_P2P_DISC_ST_SCAN, 0, 0);
556 
557 	/* Disable P2P discovery in the firmware */
558 	vif = p2p->bss_idx[P2PAPI_BSSCFG_PRIMARY].vif;
559 	(void)brcmf_fil_iovar_int_set(vif->ifp, "p2p_disc", 0);
560 
561 	return 0;
562 }
563 
564 /**
565  * brcmf_p2p_enable_discovery() - initialize and configure discovery.
566  *
567  * @p2p: P2P specific data.
568  *
569  * Initializes the discovery device and configure the virtual interface.
570  */
brcmf_p2p_enable_discovery(struct brcmf_p2p_info * p2p)571 static int brcmf_p2p_enable_discovery(struct brcmf_p2p_info *p2p)
572 {
573 	struct brcmf_cfg80211_vif *vif;
574 	s32 ret = 0;
575 
576 	brcmf_dbg(TRACE, "enter\n");
577 	vif = p2p->bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
578 	if (!vif) {
579 		brcmf_err("P2P config device not available\n");
580 		ret = -EPERM;
581 		goto exit;
582 	}
583 
584 	if (test_bit(BRCMF_P2P_STATUS_ENABLED, &p2p->status)) {
585 		brcmf_dbg(INFO, "P2P config device already configured\n");
586 		goto exit;
587 	}
588 
589 	/* Re-initialize P2P Discovery in the firmware */
590 	vif = p2p->bss_idx[P2PAPI_BSSCFG_PRIMARY].vif;
591 	ret = brcmf_fil_iovar_int_set(vif->ifp, "p2p_disc", 1);
592 	if (ret < 0) {
593 		brcmf_err("set p2p_disc error\n");
594 		goto exit;
595 	}
596 	vif = p2p->bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
597 	ret = brcmf_p2p_set_discover_state(vif->ifp, WL_P2P_DISC_ST_SCAN, 0, 0);
598 	if (ret < 0) {
599 		brcmf_err("unable to set WL_P2P_DISC_ST_SCAN\n");
600 		goto exit;
601 	}
602 
603 	/*
604 	 * Set wsec to any non-zero value in the discovery bsscfg
605 	 * to ensure our P2P probe responses have the privacy bit
606 	 * set in the 802.11 WPA IE. Some peer devices may not
607 	 * initiate WPS with us if this bit is not set.
608 	 */
609 	ret = brcmf_fil_bsscfg_int_set(vif->ifp, "wsec", AES_ENABLED);
610 	if (ret < 0) {
611 		brcmf_err("wsec error %d\n", ret);
612 		goto exit;
613 	}
614 
615 	set_bit(BRCMF_P2P_STATUS_ENABLED, &p2p->status);
616 exit:
617 	return ret;
618 }
619 
620 /**
621  * brcmf_p2p_escan() - initiate a P2P scan.
622  *
623  * @p2p: P2P specific data.
624  * @num_chans: number of channels to scan.
625  * @chanspecs: channel parameters for @num_chans channels.
626  * @search_state: P2P discover state to use.
627  * @bss_type: type of P2P bss.
628  */
brcmf_p2p_escan(struct brcmf_p2p_info * p2p,u32 num_chans,u16 chanspecs[],s32 search_state,enum p2p_bss_type bss_type)629 static s32 brcmf_p2p_escan(struct brcmf_p2p_info *p2p, u32 num_chans,
630 			   u16 chanspecs[], s32 search_state,
631 			   enum p2p_bss_type bss_type)
632 {
633 	s32 ret = 0;
634 	s32 memsize = offsetof(struct brcmf_p2p_scan_le,
635 			       eparams.params_le.channel_list);
636 	s32 nprobes;
637 	s32 active;
638 	u32 i;
639 	u8 *memblk;
640 	struct brcmf_cfg80211_vif *vif;
641 	struct brcmf_p2p_scan_le *p2p_params;
642 	struct brcmf_scan_params_le *sparams;
643 
644 	memsize += num_chans * sizeof(__le16);
645 	memblk = kzalloc(memsize, GFP_KERNEL);
646 	if (!memblk)
647 		return -ENOMEM;
648 
649 	vif = p2p->bss_idx[bss_type].vif;
650 	if (vif == NULL) {
651 		brcmf_err("no vif for bss type %d\n", bss_type);
652 		ret = -EINVAL;
653 		goto exit;
654 	}
655 	p2p_params = (struct brcmf_p2p_scan_le *)memblk;
656 	sparams = &p2p_params->eparams.params_le;
657 
658 	switch (search_state) {
659 	case WL_P2P_DISC_ST_SEARCH:
660 		/*
661 		 * If we in SEARCH STATE, we don't need to set SSID explictly
662 		 * because dongle use P2P WILDCARD internally by default, use
663 		 * null ssid, which it is already due to kzalloc.
664 		 */
665 		break;
666 	case WL_P2P_DISC_ST_SCAN:
667 		/*
668 		 * wpa_supplicant has p2p_find command with type social or
669 		 * progressive. For progressive, we need to set the ssid to
670 		 * P2P WILDCARD because we just do broadcast scan unless
671 		 * setting SSID.
672 		 */
673 		sparams->ssid_le.SSID_len =
674 				cpu_to_le32(BRCMF_P2P_WILDCARD_SSID_LEN);
675 		memcpy(sparams->ssid_le.SSID, BRCMF_P2P_WILDCARD_SSID,
676 		       BRCMF_P2P_WILDCARD_SSID_LEN);
677 		break;
678 	default:
679 		brcmf_err(" invalid search state %d\n", search_state);
680 		ret = -EINVAL;
681 		goto exit;
682 	}
683 
684 	brcmf_p2p_set_discover_state(vif->ifp, search_state, 0, 0);
685 
686 	/*
687 	 * set p2p scan parameters.
688 	 */
689 	p2p_params->type = 'E';
690 
691 	/* determine the scan engine parameters */
692 	sparams->bss_type = DOT11_BSSTYPE_ANY;
693 	if (p2p->cfg->active_scan)
694 		sparams->scan_type = 0;
695 	else
696 		sparams->scan_type = 1;
697 
698 	eth_broadcast_addr(sparams->bssid);
699 	sparams->home_time = cpu_to_le32(P2PAPI_SCAN_HOME_TIME_MS);
700 
701 	/*
702 	 * SOCIAL_CHAN_CNT + 1 takes care of the Progressive scan
703 	 * supported by the supplicant.
704 	 */
705 	if (num_chans == SOCIAL_CHAN_CNT || num_chans == (SOCIAL_CHAN_CNT + 1))
706 		active = P2PAPI_SCAN_SOCIAL_DWELL_TIME_MS;
707 	else if (num_chans == AF_PEER_SEARCH_CNT)
708 		active = P2PAPI_SCAN_AF_SEARCH_DWELL_TIME_MS;
709 	else if (brcmf_get_vif_state_any(p2p->cfg, BRCMF_VIF_STATUS_CONNECTED))
710 		active = -1;
711 	else
712 		active = P2PAPI_SCAN_DWELL_TIME_MS;
713 
714 	/* Override scan params to find a peer for a connection */
715 	if (num_chans == 1) {
716 		active = WL_SCAN_CONNECT_DWELL_TIME_MS;
717 		/* WAR to sync with presence period of VSDB GO.
718 		 * send probe request more frequently
719 		 */
720 		nprobes = active / WL_SCAN_JOIN_PROBE_INTERVAL_MS;
721 	} else {
722 		nprobes = active / P2PAPI_SCAN_NPROBS_TIME_MS;
723 	}
724 
725 	if (nprobes <= 0)
726 		nprobes = 1;
727 
728 	brcmf_dbg(INFO, "nprobes # %d, active_time %d\n", nprobes, active);
729 	sparams->active_time = cpu_to_le32(active);
730 	sparams->nprobes = cpu_to_le32(nprobes);
731 	sparams->passive_time = cpu_to_le32(-1);
732 	sparams->channel_num = cpu_to_le32(num_chans &
733 					   BRCMF_SCAN_PARAMS_COUNT_MASK);
734 	for (i = 0; i < num_chans; i++)
735 		sparams->channel_list[i] = cpu_to_le16(chanspecs[i]);
736 
737 	/* set the escan specific parameters */
738 	p2p_params->eparams.version = cpu_to_le32(BRCMF_ESCAN_REQ_VERSION);
739 	p2p_params->eparams.action =  cpu_to_le16(WL_ESCAN_ACTION_START);
740 	p2p_params->eparams.sync_id = cpu_to_le16(0x1234);
741 	/* perform p2p scan on primary device */
742 	ret = brcmf_fil_bsscfg_data_set(vif->ifp, "p2p_scan", memblk, memsize);
743 	if (!ret)
744 		set_bit(BRCMF_SCAN_STATUS_BUSY, &p2p->cfg->scan_status);
745 exit:
746 	kfree(memblk);
747 	return ret;
748 }
749 
750 /**
751  * brcmf_p2p_run_escan() - escan callback for peer-to-peer.
752  *
753  * @cfg: driver private data for cfg80211 interface.
754  * @ndev: net device for which scan is requested.
755  * @request: scan request from cfg80211.
756  * @action: scan action.
757  *
758  * Determines the P2P discovery state based to scan request parameters and
759  * validates the channels in the request.
760  */
brcmf_p2p_run_escan(struct brcmf_cfg80211_info * cfg,struct brcmf_if * ifp,struct cfg80211_scan_request * request)761 static s32 brcmf_p2p_run_escan(struct brcmf_cfg80211_info *cfg,
762 			       struct brcmf_if *ifp,
763 			       struct cfg80211_scan_request *request)
764 {
765 	struct brcmf_p2p_info *p2p = &cfg->p2p;
766 	s32 err = 0;
767 	s32 search_state = WL_P2P_DISC_ST_SCAN;
768 	struct brcmf_cfg80211_vif *vif;
769 	struct net_device *dev = NULL;
770 	int i, num_nodfs = 0;
771 	u16 *chanspecs;
772 
773 	brcmf_dbg(TRACE, "enter\n");
774 
775 	if (!request) {
776 		err = -EINVAL;
777 		goto exit;
778 	}
779 
780 	if (request->n_channels) {
781 		chanspecs = kcalloc(request->n_channels, sizeof(*chanspecs),
782 				    GFP_KERNEL);
783 		if (!chanspecs) {
784 			err = -ENOMEM;
785 			goto exit;
786 		}
787 		vif = p2p->bss_idx[P2PAPI_BSSCFG_CONNECTION].vif;
788 		if (vif)
789 			dev = vif->wdev.netdev;
790 		if (request->n_channels == 3 &&
791 		    request->channels[0]->hw_value == SOCIAL_CHAN_1 &&
792 		    request->channels[1]->hw_value == SOCIAL_CHAN_2 &&
793 		    request->channels[2]->hw_value == SOCIAL_CHAN_3) {
794 			/* SOCIAL CHANNELS 1, 6, 11 */
795 			search_state = WL_P2P_DISC_ST_SEARCH;
796 			brcmf_dbg(INFO, "P2P SEARCH PHASE START\n");
797 		} else if (dev != NULL &&
798 			   vif->wdev.iftype == NL80211_IFTYPE_P2P_GO) {
799 			/* If you are already a GO, then do SEARCH only */
800 			brcmf_dbg(INFO, "Already a GO. Do SEARCH Only\n");
801 			search_state = WL_P2P_DISC_ST_SEARCH;
802 		} else {
803 			brcmf_dbg(INFO, "P2P SCAN STATE START\n");
804 		}
805 
806 		/*
807 		 * no P2P scanning on passive or DFS channels.
808 		 */
809 		for (i = 0; i < request->n_channels; i++) {
810 			struct ieee80211_channel *chan = request->channels[i];
811 
812 			if (chan->flags & (IEEE80211_CHAN_RADAR |
813 					   IEEE80211_CHAN_NO_IR))
814 				continue;
815 
816 			chanspecs[i] = channel_to_chanspec(&p2p->cfg->d11inf,
817 							   chan);
818 			brcmf_dbg(INFO, "%d: chan=%d, channel spec=%x\n",
819 				  num_nodfs, chan->hw_value, chanspecs[i]);
820 			num_nodfs++;
821 		}
822 		err = brcmf_p2p_escan(p2p, num_nodfs, chanspecs, search_state,
823 				      P2PAPI_BSSCFG_DEVICE);
824 		kfree(chanspecs);
825 	}
826 exit:
827 	if (err)
828 		brcmf_err("error (%d)\n", err);
829 	return err;
830 }
831 
832 
833 /**
834  * brcmf_p2p_find_listen_channel() - find listen channel in ie string.
835  *
836  * @ie: string of information elements.
837  * @ie_len: length of string.
838  *
839  * Scan ie for p2p ie and look for attribute 6 channel. If available determine
840  * channel and return it.
841  */
brcmf_p2p_find_listen_channel(const u8 * ie,u32 ie_len)842 static s32 brcmf_p2p_find_listen_channel(const u8 *ie, u32 ie_len)
843 {
844 	u8 channel_ie[5];
845 	s32 listen_channel;
846 	s32 err;
847 
848 	err = cfg80211_get_p2p_attr(ie, ie_len,
849 				    IEEE80211_P2P_ATTR_LISTEN_CHANNEL,
850 				    channel_ie, sizeof(channel_ie));
851 	if (err < 0)
852 		return err;
853 
854 	/* listen channel subel length format:     */
855 	/* 3(country) + 1(op. class) + 1(chan num) */
856 	listen_channel = (s32)channel_ie[3 + 1];
857 
858 	if (listen_channel == SOCIAL_CHAN_1 ||
859 	    listen_channel == SOCIAL_CHAN_2 ||
860 	    listen_channel == SOCIAL_CHAN_3) {
861 		brcmf_dbg(INFO, "Found my Listen Channel %d\n", listen_channel);
862 		return listen_channel;
863 	}
864 
865 	return -EPERM;
866 }
867 
868 
869 /**
870  * brcmf_p2p_scan_prep() - prepare scan based on request.
871  *
872  * @wiphy: wiphy device.
873  * @request: scan request from cfg80211.
874  * @vif: vif on which scan request is to be executed.
875  *
876  * Prepare the scan appropriately for type of scan requested. Overrides the
877  * escan .run() callback for peer-to-peer scanning.
878  */
brcmf_p2p_scan_prep(struct wiphy * wiphy,struct cfg80211_scan_request * request,struct brcmf_cfg80211_vif * vif)879 int brcmf_p2p_scan_prep(struct wiphy *wiphy,
880 			struct cfg80211_scan_request *request,
881 			struct brcmf_cfg80211_vif *vif)
882 {
883 	struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
884 	struct brcmf_p2p_info *p2p = &cfg->p2p;
885 	int err = 0;
886 
887 	if (brcmf_p2p_scan_is_p2p_request(request)) {
888 		/* find my listen channel */
889 		err = brcmf_p2p_find_listen_channel(request->ie,
890 						    request->ie_len);
891 		if (err < 0)
892 			return err;
893 
894 		p2p->afx_hdl.my_listen_chan = err;
895 
896 		clear_bit(BRCMF_P2P_STATUS_GO_NEG_PHASE, &p2p->status);
897 		brcmf_dbg(INFO, "P2P: GO_NEG_PHASE status cleared\n");
898 
899 		err = brcmf_p2p_enable_discovery(p2p);
900 		if (err)
901 			return err;
902 
903 		vif = p2p->bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
904 
905 		/* override .run_escan() callback. */
906 		cfg->escan_info.run = brcmf_p2p_run_escan;
907 	}
908 	err = brcmf_vif_set_mgmt_ie(vif, BRCMF_VNDR_IE_PRBREQ_FLAG,
909 				    request->ie, request->ie_len);
910 	return err;
911 }
912 
913 
914 /**
915  * brcmf_p2p_discover_listen() - set firmware to discover listen state.
916  *
917  * @p2p: p2p device.
918  * @channel: channel nr for discover listen.
919  * @duration: time in ms to stay on channel.
920  *
921  */
922 static s32
brcmf_p2p_discover_listen(struct brcmf_p2p_info * p2p,u16 channel,u32 duration)923 brcmf_p2p_discover_listen(struct brcmf_p2p_info *p2p, u16 channel, u32 duration)
924 {
925 	struct brcmf_cfg80211_vif *vif;
926 	struct brcmu_chan ch;
927 	s32 err = 0;
928 
929 	vif = p2p->bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
930 	if (!vif) {
931 		brcmf_err("Discovery is not set, so we have nothing to do\n");
932 		err = -EPERM;
933 		goto exit;
934 	}
935 
936 	if (test_bit(BRCMF_P2P_STATUS_DISCOVER_LISTEN, &p2p->status)) {
937 		brcmf_err("Previous LISTEN is not completed yet\n");
938 		/* WAR: prevent cookie mismatch in wpa_supplicant return OK */
939 		goto exit;
940 	}
941 
942 	ch.chnum = channel;
943 	ch.bw = BRCMU_CHAN_BW_20;
944 	p2p->cfg->d11inf.encchspec(&ch);
945 	err = brcmf_p2p_set_discover_state(vif->ifp, WL_P2P_DISC_ST_LISTEN,
946 					   ch.chspec, (u16)duration);
947 	if (!err) {
948 		set_bit(BRCMF_P2P_STATUS_DISCOVER_LISTEN, &p2p->status);
949 		p2p->remain_on_channel_cookie++;
950 	}
951 exit:
952 	return err;
953 }
954 
955 
956 /**
957  * brcmf_p2p_remain_on_channel() - put device on channel and stay there.
958  *
959  * @wiphy: wiphy device.
960  * @channel: channel to stay on.
961  * @duration: time in ms to remain on channel.
962  *
963  */
brcmf_p2p_remain_on_channel(struct wiphy * wiphy,struct wireless_dev * wdev,struct ieee80211_channel * channel,unsigned int duration,u64 * cookie)964 int brcmf_p2p_remain_on_channel(struct wiphy *wiphy, struct wireless_dev *wdev,
965 				struct ieee80211_channel *channel,
966 				unsigned int duration, u64 *cookie)
967 {
968 	struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
969 	struct brcmf_p2p_info *p2p = &cfg->p2p;
970 	s32 err;
971 	u16 channel_nr;
972 
973 	channel_nr = ieee80211_frequency_to_channel(channel->center_freq);
974 	brcmf_dbg(TRACE, "Enter, channel: %d, duration ms (%d)\n", channel_nr,
975 		  duration);
976 
977 	err = brcmf_p2p_enable_discovery(p2p);
978 	if (err)
979 		goto exit;
980 	err = brcmf_p2p_discover_listen(p2p, channel_nr, duration);
981 	if (err)
982 		goto exit;
983 
984 	memcpy(&p2p->remain_on_channel, channel, sizeof(*channel));
985 	*cookie = p2p->remain_on_channel_cookie;
986 	cfg80211_ready_on_channel(wdev, *cookie, channel, duration, GFP_KERNEL);
987 
988 exit:
989 	return err;
990 }
991 
992 
993 /**
994  * brcmf_p2p_notify_listen_complete() - p2p listen has completed.
995  *
996  * @ifp: interfac control.
997  * @e: event message. Not used, to make it usable for fweh event dispatcher.
998  * @data: payload of message. Not used.
999  *
1000  */
brcmf_p2p_notify_listen_complete(struct brcmf_if * ifp,const struct brcmf_event_msg * e,void * data)1001 int brcmf_p2p_notify_listen_complete(struct brcmf_if *ifp,
1002 				     const struct brcmf_event_msg *e,
1003 				     void *data)
1004 {
1005 	struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
1006 	struct brcmf_p2p_info *p2p = &cfg->p2p;
1007 
1008 	brcmf_dbg(TRACE, "Enter\n");
1009 	if (test_and_clear_bit(BRCMF_P2P_STATUS_DISCOVER_LISTEN,
1010 			       &p2p->status)) {
1011 		if (test_and_clear_bit(BRCMF_P2P_STATUS_WAITING_NEXT_AF_LISTEN,
1012 				       &p2p->status)) {
1013 			clear_bit(BRCMF_P2P_STATUS_WAITING_NEXT_ACT_FRAME,
1014 				  &p2p->status);
1015 			brcmf_dbg(INFO, "Listen DONE, wake up wait_next_af\n");
1016 			complete(&p2p->wait_next_af);
1017 		}
1018 
1019 		cfg80211_remain_on_channel_expired(&ifp->vif->wdev,
1020 						   p2p->remain_on_channel_cookie,
1021 						   &p2p->remain_on_channel,
1022 						   GFP_KERNEL);
1023 	}
1024 	return 0;
1025 }
1026 
1027 
1028 /**
1029  * brcmf_p2p_cancel_remain_on_channel() - cancel p2p listen state.
1030  *
1031  * @ifp: interfac control.
1032  *
1033  */
brcmf_p2p_cancel_remain_on_channel(struct brcmf_if * ifp)1034 void brcmf_p2p_cancel_remain_on_channel(struct brcmf_if *ifp)
1035 {
1036 	if (!ifp)
1037 		return;
1038 	brcmf_p2p_set_discover_state(ifp, WL_P2P_DISC_ST_SCAN, 0, 0);
1039 	brcmf_p2p_notify_listen_complete(ifp, NULL, NULL);
1040 }
1041 
1042 
1043 /**
1044  * brcmf_p2p_act_frm_search() - search function for action frame.
1045  *
1046  * @p2p: p2p device.
1047  * channel: channel on which action frame is to be trasmitted.
1048  *
1049  * search function to reach at common channel to send action frame. When
1050  * channel is 0 then all social channels will be used to send af
1051  */
brcmf_p2p_act_frm_search(struct brcmf_p2p_info * p2p,u16 channel)1052 static s32 brcmf_p2p_act_frm_search(struct brcmf_p2p_info *p2p, u16 channel)
1053 {
1054 	s32 err;
1055 	u32 channel_cnt;
1056 	u16 *default_chan_list;
1057 	u32 i;
1058 	struct brcmu_chan ch;
1059 
1060 	brcmf_dbg(TRACE, "Enter\n");
1061 
1062 	if (channel)
1063 		channel_cnt = AF_PEER_SEARCH_CNT;
1064 	else
1065 		channel_cnt = SOCIAL_CHAN_CNT;
1066 	default_chan_list = kzalloc(channel_cnt * sizeof(*default_chan_list),
1067 				    GFP_KERNEL);
1068 	if (default_chan_list == NULL) {
1069 		brcmf_err("channel list allocation failed\n");
1070 		err = -ENOMEM;
1071 		goto exit;
1072 	}
1073 	ch.bw = BRCMU_CHAN_BW_20;
1074 	if (channel) {
1075 		ch.chnum = channel;
1076 		p2p->cfg->d11inf.encchspec(&ch);
1077 		/* insert same channel to the chan_list */
1078 		for (i = 0; i < channel_cnt; i++)
1079 			default_chan_list[i] = ch.chspec;
1080 	} else {
1081 		ch.chnum = SOCIAL_CHAN_1;
1082 		p2p->cfg->d11inf.encchspec(&ch);
1083 		default_chan_list[0] = ch.chspec;
1084 		ch.chnum = SOCIAL_CHAN_2;
1085 		p2p->cfg->d11inf.encchspec(&ch);
1086 		default_chan_list[1] = ch.chspec;
1087 		ch.chnum = SOCIAL_CHAN_3;
1088 		p2p->cfg->d11inf.encchspec(&ch);
1089 		default_chan_list[2] = ch.chspec;
1090 	}
1091 	err = brcmf_p2p_escan(p2p, channel_cnt, default_chan_list,
1092 			      WL_P2P_DISC_ST_SEARCH, P2PAPI_BSSCFG_DEVICE);
1093 	kfree(default_chan_list);
1094 exit:
1095 	return err;
1096 }
1097 
1098 
1099 /**
1100  * brcmf_p2p_afx_handler() - afx worker thread.
1101  *
1102  * @work:
1103  *
1104  */
brcmf_p2p_afx_handler(struct work_struct * work)1105 static void brcmf_p2p_afx_handler(struct work_struct *work)
1106 {
1107 	struct afx_hdl *afx_hdl = container_of(work, struct afx_hdl, afx_work);
1108 	struct brcmf_p2p_info *p2p = container_of(afx_hdl,
1109 						  struct brcmf_p2p_info,
1110 						  afx_hdl);
1111 	s32 err;
1112 
1113 	if (!afx_hdl->is_active)
1114 		return;
1115 
1116 	if (afx_hdl->is_listen && afx_hdl->my_listen_chan)
1117 		/* 100ms ~ 300ms */
1118 		err = brcmf_p2p_discover_listen(p2p, afx_hdl->my_listen_chan,
1119 						100 * (1 + prandom_u32() % 3));
1120 	else
1121 		err = brcmf_p2p_act_frm_search(p2p, afx_hdl->peer_listen_chan);
1122 
1123 	if (err) {
1124 		brcmf_err("ERROR occurred! value is (%d)\n", err);
1125 		if (test_bit(BRCMF_P2P_STATUS_FINDING_COMMON_CHANNEL,
1126 			     &p2p->status))
1127 			complete(&afx_hdl->act_frm_scan);
1128 	}
1129 }
1130 
1131 
1132 /**
1133  * brcmf_p2p_af_searching_channel() - search channel.
1134  *
1135  * @p2p: p2p device info struct.
1136  *
1137  */
brcmf_p2p_af_searching_channel(struct brcmf_p2p_info * p2p)1138 static s32 brcmf_p2p_af_searching_channel(struct brcmf_p2p_info *p2p)
1139 {
1140 	struct afx_hdl *afx_hdl = &p2p->afx_hdl;
1141 	struct brcmf_cfg80211_vif *pri_vif;
1142 	s32 retry;
1143 
1144 	brcmf_dbg(TRACE, "Enter\n");
1145 
1146 	pri_vif = p2p->bss_idx[P2PAPI_BSSCFG_PRIMARY].vif;
1147 
1148 	reinit_completion(&afx_hdl->act_frm_scan);
1149 	set_bit(BRCMF_P2P_STATUS_FINDING_COMMON_CHANNEL, &p2p->status);
1150 	afx_hdl->is_active = true;
1151 	afx_hdl->peer_chan = P2P_INVALID_CHANNEL;
1152 
1153 	/* Loop to wait until we find a peer's channel or the
1154 	 * pending action frame tx is cancelled.
1155 	 */
1156 	retry = 0;
1157 	while ((retry < P2P_CHANNEL_SYNC_RETRY) &&
1158 	       (afx_hdl->peer_chan == P2P_INVALID_CHANNEL)) {
1159 		afx_hdl->is_listen = false;
1160 		brcmf_dbg(TRACE, "Scheduling action frame for sending.. (%d)\n",
1161 			  retry);
1162 		/* search peer on peer's listen channel */
1163 		schedule_work(&afx_hdl->afx_work);
1164 		wait_for_completion_timeout(&afx_hdl->act_frm_scan,
1165 					    P2P_AF_FRM_SCAN_MAX_WAIT);
1166 		if ((afx_hdl->peer_chan != P2P_INVALID_CHANNEL) ||
1167 		    (!test_bit(BRCMF_P2P_STATUS_FINDING_COMMON_CHANNEL,
1168 			       &p2p->status)))
1169 			break;
1170 
1171 		if (afx_hdl->my_listen_chan) {
1172 			brcmf_dbg(TRACE, "Scheduling listen peer, channel=%d\n",
1173 				  afx_hdl->my_listen_chan);
1174 			/* listen on my listen channel */
1175 			afx_hdl->is_listen = true;
1176 			schedule_work(&afx_hdl->afx_work);
1177 			wait_for_completion_timeout(&afx_hdl->act_frm_scan,
1178 						    P2P_AF_FRM_SCAN_MAX_WAIT);
1179 		}
1180 		if ((afx_hdl->peer_chan != P2P_INVALID_CHANNEL) ||
1181 		    (!test_bit(BRCMF_P2P_STATUS_FINDING_COMMON_CHANNEL,
1182 			       &p2p->status)))
1183 			break;
1184 		retry++;
1185 
1186 		/* if sta is connected or connecting, sleep for a while before
1187 		 * retry af tx or finding a peer
1188 		 */
1189 		if (test_bit(BRCMF_VIF_STATUS_CONNECTED, &pri_vif->sme_state) ||
1190 		    test_bit(BRCMF_VIF_STATUS_CONNECTING, &pri_vif->sme_state))
1191 			msleep(P2P_DEFAULT_SLEEP_TIME_VSDB);
1192 	}
1193 
1194 	brcmf_dbg(TRACE, "Completed search/listen peer_chan=%d\n",
1195 		  afx_hdl->peer_chan);
1196 	afx_hdl->is_active = false;
1197 
1198 	clear_bit(BRCMF_P2P_STATUS_FINDING_COMMON_CHANNEL, &p2p->status);
1199 
1200 	return afx_hdl->peer_chan;
1201 }
1202 
1203 
1204 /**
1205  * brcmf_p2p_scan_finding_common_channel() - was escan used for finding channel
1206  *
1207  * @cfg: common configuration struct.
1208  * @bi: bss info struct, result from scan.
1209  *
1210  */
brcmf_p2p_scan_finding_common_channel(struct brcmf_cfg80211_info * cfg,struct brcmf_bss_info_le * bi)1211 bool brcmf_p2p_scan_finding_common_channel(struct brcmf_cfg80211_info *cfg,
1212 					   struct brcmf_bss_info_le *bi)
1213 
1214 {
1215 	struct brcmf_p2p_info *p2p = &cfg->p2p;
1216 	struct afx_hdl *afx_hdl = &p2p->afx_hdl;
1217 	struct brcmu_chan ch;
1218 	u8 *ie;
1219 	s32 err;
1220 	u8 p2p_dev_addr[ETH_ALEN];
1221 
1222 	if (!test_bit(BRCMF_P2P_STATUS_FINDING_COMMON_CHANNEL, &p2p->status))
1223 		return false;
1224 
1225 	if (bi == NULL) {
1226 		brcmf_dbg(TRACE, "ACTION FRAME SCAN Done\n");
1227 		if (afx_hdl->peer_chan == P2P_INVALID_CHANNEL)
1228 			complete(&afx_hdl->act_frm_scan);
1229 		return true;
1230 	}
1231 
1232 	ie = ((u8 *)bi) + le16_to_cpu(bi->ie_offset);
1233 	memset(p2p_dev_addr, 0, sizeof(p2p_dev_addr));
1234 	err = cfg80211_get_p2p_attr(ie, le32_to_cpu(bi->ie_length),
1235 				    IEEE80211_P2P_ATTR_DEVICE_INFO,
1236 				    p2p_dev_addr, sizeof(p2p_dev_addr));
1237 	if (err < 0)
1238 		err = cfg80211_get_p2p_attr(ie, le32_to_cpu(bi->ie_length),
1239 					    IEEE80211_P2P_ATTR_DEVICE_ID,
1240 					    p2p_dev_addr, sizeof(p2p_dev_addr));
1241 	if ((err >= 0) &&
1242 	    (ether_addr_equal(p2p_dev_addr, afx_hdl->tx_dst_addr))) {
1243 		if (!bi->ctl_ch) {
1244 			ch.chspec = le16_to_cpu(bi->chanspec);
1245 			cfg->d11inf.decchspec(&ch);
1246 			bi->ctl_ch = ch.control_ch_num;
1247 		}
1248 		afx_hdl->peer_chan = bi->ctl_ch;
1249 		brcmf_dbg(TRACE, "ACTION FRAME SCAN : Peer %pM found, channel : %d\n",
1250 			  afx_hdl->tx_dst_addr, afx_hdl->peer_chan);
1251 		complete(&afx_hdl->act_frm_scan);
1252 	}
1253 	return true;
1254 }
1255 
1256 /**
1257  * brcmf_p2p_stop_wait_next_action_frame() - finish scan if af tx complete.
1258  *
1259  * @cfg: common configuration struct.
1260  *
1261  */
1262 static void
brcmf_p2p_stop_wait_next_action_frame(struct brcmf_cfg80211_info * cfg)1263 brcmf_p2p_stop_wait_next_action_frame(struct brcmf_cfg80211_info *cfg)
1264 {
1265 	struct brcmf_p2p_info *p2p = &cfg->p2p;
1266 	struct brcmf_if *ifp = p2p->bss_idx[P2PAPI_BSSCFG_PRIMARY].vif->ifp;
1267 
1268 	if (test_bit(BRCMF_P2P_STATUS_SENDING_ACT_FRAME, &p2p->status) &&
1269 	    (test_bit(BRCMF_P2P_STATUS_ACTION_TX_COMPLETED, &p2p->status) ||
1270 	     test_bit(BRCMF_P2P_STATUS_ACTION_TX_NOACK, &p2p->status))) {
1271 		brcmf_dbg(TRACE, "*** Wake UP ** abort actframe iovar\n");
1272 		/* if channel is not zero, "actfame" uses off channel scan.
1273 		 * So abort scan for off channel completion.
1274 		 */
1275 		if (p2p->af_sent_channel)
1276 			brcmf_notify_escan_complete(cfg, ifp, true, true);
1277 	} else if (test_bit(BRCMF_P2P_STATUS_WAITING_NEXT_AF_LISTEN,
1278 			    &p2p->status)) {
1279 		brcmf_dbg(TRACE, "*** Wake UP ** abort listen for next af frame\n");
1280 		/* So abort scan to cancel listen */
1281 		brcmf_notify_escan_complete(cfg, ifp, true, true);
1282 	}
1283 }
1284 
1285 
1286 /**
1287  * brcmf_p2p_gon_req_collision() - Check if go negotiaton collission
1288  *
1289  * @p2p: p2p device info struct.
1290  *
1291  * return true if recevied action frame is to be dropped.
1292  */
1293 static bool
brcmf_p2p_gon_req_collision(struct brcmf_p2p_info * p2p,u8 * mac)1294 brcmf_p2p_gon_req_collision(struct brcmf_p2p_info *p2p, u8 *mac)
1295 {
1296 	struct brcmf_cfg80211_info *cfg = p2p->cfg;
1297 	struct brcmf_if *ifp;
1298 
1299 	brcmf_dbg(TRACE, "Enter\n");
1300 
1301 	if (!test_bit(BRCMF_P2P_STATUS_WAITING_NEXT_ACT_FRAME, &p2p->status) ||
1302 	    !p2p->gon_req_action)
1303 		return false;
1304 
1305 	brcmf_dbg(TRACE, "GO Negotiation Request COLLISION !!!\n");
1306 	/* if sa(peer) addr is less than da(my) addr, then this device
1307 	 * process peer's gon request and block to send gon req.
1308 	 * if not (sa addr > da addr),
1309 	 * this device will process gon request and drop gon req of peer.
1310 	 */
1311 	ifp = p2p->bss_idx[P2PAPI_BSSCFG_DEVICE].vif->ifp;
1312 	if (memcmp(mac, ifp->mac_addr, ETH_ALEN) < 0) {
1313 		brcmf_dbg(INFO, "Block transmit gon req !!!\n");
1314 		p2p->block_gon_req_tx = true;
1315 		/* if we are finding a common channel for sending af,
1316 		 * do not scan more to block to send current gon req
1317 		 */
1318 		if (test_and_clear_bit(BRCMF_P2P_STATUS_FINDING_COMMON_CHANNEL,
1319 				       &p2p->status))
1320 			complete(&p2p->afx_hdl.act_frm_scan);
1321 		if (test_and_clear_bit(BRCMF_P2P_STATUS_WAITING_NEXT_ACT_FRAME,
1322 				       &p2p->status))
1323 			brcmf_p2p_stop_wait_next_action_frame(cfg);
1324 		return false;
1325 	}
1326 
1327 	/* drop gon request of peer to process gon request by this device. */
1328 	brcmf_dbg(INFO, "Drop received gon req !!!\n");
1329 
1330 	return true;
1331 }
1332 
1333 
1334 /**
1335  * brcmf_p2p_notify_action_frame_rx() - received action frame.
1336  *
1337  * @ifp: interfac control.
1338  * @e: event message. Not used, to make it usable for fweh event dispatcher.
1339  * @data: payload of message, containing action frame data.
1340  *
1341  */
brcmf_p2p_notify_action_frame_rx(struct brcmf_if * ifp,const struct brcmf_event_msg * e,void * data)1342 int brcmf_p2p_notify_action_frame_rx(struct brcmf_if *ifp,
1343 				     const struct brcmf_event_msg *e,
1344 				     void *data)
1345 {
1346 	struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
1347 	struct brcmf_p2p_info *p2p = &cfg->p2p;
1348 	struct afx_hdl *afx_hdl = &p2p->afx_hdl;
1349 	struct wireless_dev *wdev;
1350 	u32 mgmt_frame_len = e->datalen - sizeof(struct brcmf_rx_mgmt_data);
1351 	struct brcmf_rx_mgmt_data *rxframe = (struct brcmf_rx_mgmt_data *)data;
1352 	u8 *frame = (u8 *)(rxframe + 1);
1353 	struct brcmf_p2p_pub_act_frame *act_frm;
1354 	struct brcmf_p2psd_gas_pub_act_frame *sd_act_frm;
1355 	struct brcmu_chan ch;
1356 	struct ieee80211_mgmt *mgmt_frame;
1357 	s32 freq;
1358 	u16 mgmt_type;
1359 	u8 action;
1360 
1361 	if (e->datalen < sizeof(*rxframe)) {
1362 		brcmf_dbg(SCAN, "Event data to small. Ignore\n");
1363 		return 0;
1364 	}
1365 
1366 	ch.chspec = be16_to_cpu(rxframe->chanspec);
1367 	cfg->d11inf.decchspec(&ch);
1368 	/* Check if wpa_supplicant has registered for this frame */
1369 	brcmf_dbg(INFO, "ifp->vif->mgmt_rx_reg %04x\n", ifp->vif->mgmt_rx_reg);
1370 	mgmt_type = (IEEE80211_STYPE_ACTION & IEEE80211_FCTL_STYPE) >> 4;
1371 	if ((ifp->vif->mgmt_rx_reg & BIT(mgmt_type)) == 0)
1372 		return 0;
1373 
1374 	brcmf_p2p_print_actframe(false, frame, mgmt_frame_len);
1375 
1376 	action = P2P_PAF_SUBTYPE_INVALID;
1377 	if (brcmf_p2p_is_pub_action(frame, mgmt_frame_len)) {
1378 		act_frm = (struct brcmf_p2p_pub_act_frame *)frame;
1379 		action = act_frm->subtype;
1380 		if ((action == P2P_PAF_GON_REQ) &&
1381 		    (brcmf_p2p_gon_req_collision(p2p, (u8 *)e->addr))) {
1382 			if (test_bit(BRCMF_P2P_STATUS_FINDING_COMMON_CHANNEL,
1383 				     &p2p->status) &&
1384 			    (ether_addr_equal(afx_hdl->tx_dst_addr, e->addr))) {
1385 				afx_hdl->peer_chan = ch.control_ch_num;
1386 				brcmf_dbg(INFO, "GON request: Peer found, channel=%d\n",
1387 					  afx_hdl->peer_chan);
1388 				complete(&afx_hdl->act_frm_scan);
1389 			}
1390 			return 0;
1391 		}
1392 		/* After complete GO Negotiation, roll back to mpc mode */
1393 		if ((action == P2P_PAF_GON_CONF) ||
1394 		    (action == P2P_PAF_PROVDIS_RSP))
1395 			brcmf_set_mpc(ifp, 1);
1396 		if (action == P2P_PAF_GON_CONF) {
1397 			brcmf_dbg(TRACE, "P2P: GO_NEG_PHASE status cleared\n");
1398 			clear_bit(BRCMF_P2P_STATUS_GO_NEG_PHASE, &p2p->status);
1399 		}
1400 	} else if (brcmf_p2p_is_gas_action(frame, mgmt_frame_len)) {
1401 		sd_act_frm = (struct brcmf_p2psd_gas_pub_act_frame *)frame;
1402 		action = sd_act_frm->action;
1403 	}
1404 
1405 	if (test_bit(BRCMF_P2P_STATUS_WAITING_NEXT_ACT_FRAME, &p2p->status) &&
1406 	    (p2p->next_af_subtype == action)) {
1407 		brcmf_dbg(TRACE, "We got a right next frame! (%d)\n", action);
1408 		clear_bit(BRCMF_P2P_STATUS_WAITING_NEXT_ACT_FRAME,
1409 			  &p2p->status);
1410 		/* Stop waiting for next AF. */
1411 		brcmf_p2p_stop_wait_next_action_frame(cfg);
1412 	}
1413 
1414 	mgmt_frame = kzalloc(offsetof(struct ieee80211_mgmt, u) +
1415 			     mgmt_frame_len, GFP_KERNEL);
1416 	if (!mgmt_frame) {
1417 		brcmf_err("No memory available for action frame\n");
1418 		return -ENOMEM;
1419 	}
1420 	memcpy(mgmt_frame->da, ifp->mac_addr, ETH_ALEN);
1421 	brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSSID, mgmt_frame->bssid,
1422 			       ETH_ALEN);
1423 	memcpy(mgmt_frame->sa, e->addr, ETH_ALEN);
1424 	mgmt_frame->frame_control = cpu_to_le16(IEEE80211_STYPE_ACTION);
1425 	memcpy(&mgmt_frame->u, frame, mgmt_frame_len);
1426 	mgmt_frame_len += offsetof(struct ieee80211_mgmt, u);
1427 
1428 	freq = ieee80211_channel_to_frequency(ch.control_ch_num,
1429 					      ch.band == BRCMU_CHAN_BAND_2G ?
1430 					      NL80211_BAND_2GHZ :
1431 					      NL80211_BAND_5GHZ);
1432 
1433 	wdev = &ifp->vif->wdev;
1434 	cfg80211_rx_mgmt(wdev, freq, 0, (u8 *)mgmt_frame, mgmt_frame_len, 0);
1435 
1436 	kfree(mgmt_frame);
1437 	return 0;
1438 }
1439 
1440 
1441 /**
1442  * brcmf_p2p_notify_action_tx_complete() - transmit action frame complete
1443  *
1444  * @ifp: interfac control.
1445  * @e: event message. Not used, to make it usable for fweh event dispatcher.
1446  * @data: not used.
1447  *
1448  */
brcmf_p2p_notify_action_tx_complete(struct brcmf_if * ifp,const struct brcmf_event_msg * e,void * data)1449 int brcmf_p2p_notify_action_tx_complete(struct brcmf_if *ifp,
1450 					const struct brcmf_event_msg *e,
1451 					void *data)
1452 {
1453 	struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
1454 	struct brcmf_p2p_info *p2p = &cfg->p2p;
1455 
1456 	brcmf_dbg(INFO, "Enter: event %s, status=%d\n",
1457 		  e->event_code == BRCMF_E_ACTION_FRAME_OFF_CHAN_COMPLETE ?
1458 		  "ACTION_FRAME_OFF_CHAN_COMPLETE" : "ACTION_FRAME_COMPLETE",
1459 		  e->status);
1460 
1461 	if (!test_bit(BRCMF_P2P_STATUS_SENDING_ACT_FRAME, &p2p->status))
1462 		return 0;
1463 
1464 	if (e->event_code == BRCMF_E_ACTION_FRAME_COMPLETE) {
1465 		if (e->status == BRCMF_E_STATUS_SUCCESS) {
1466 			set_bit(BRCMF_P2P_STATUS_ACTION_TX_COMPLETED,
1467 				&p2p->status);
1468 			if (!p2p->wait_for_offchan_complete)
1469 				complete(&p2p->send_af_done);
1470 		} else {
1471 			set_bit(BRCMF_P2P_STATUS_ACTION_TX_NOACK, &p2p->status);
1472 			/* If there is no ack, we don't need to wait for
1473 			 * WLC_E_ACTION_FRAME_OFFCHAN_COMPLETE event
1474 			 */
1475 			brcmf_p2p_stop_wait_next_action_frame(cfg);
1476 		}
1477 
1478 	} else {
1479 		complete(&p2p->send_af_done);
1480 	}
1481 	return 0;
1482 }
1483 
1484 
1485 /**
1486  * brcmf_p2p_tx_action_frame() - send action frame over fil.
1487  *
1488  * @p2p: p2p info struct for vif.
1489  * @af_params: action frame data/info.
1490  *
1491  * Send an action frame immediately without doing channel synchronization.
1492  *
1493  * This function waits for a completion event before returning.
1494  * The WLC_E_ACTION_FRAME_COMPLETE event will be received when the action
1495  * frame is transmitted.
1496  */
brcmf_p2p_tx_action_frame(struct brcmf_p2p_info * p2p,struct brcmf_fil_af_params_le * af_params)1497 static s32 brcmf_p2p_tx_action_frame(struct brcmf_p2p_info *p2p,
1498 				     struct brcmf_fil_af_params_le *af_params)
1499 {
1500 	struct brcmf_cfg80211_vif *vif;
1501 	s32 err = 0;
1502 	s32 timeout = 0;
1503 
1504 	brcmf_dbg(TRACE, "Enter\n");
1505 
1506 	reinit_completion(&p2p->send_af_done);
1507 	clear_bit(BRCMF_P2P_STATUS_ACTION_TX_COMPLETED, &p2p->status);
1508 	clear_bit(BRCMF_P2P_STATUS_ACTION_TX_NOACK, &p2p->status);
1509 
1510 	vif = p2p->bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
1511 	err = brcmf_fil_bsscfg_data_set(vif->ifp, "actframe", af_params,
1512 					sizeof(*af_params));
1513 	if (err) {
1514 		brcmf_err(" sending action frame has failed\n");
1515 		goto exit;
1516 	}
1517 
1518 	p2p->af_sent_channel = le32_to_cpu(af_params->channel);
1519 	p2p->af_tx_sent_jiffies = jiffies;
1520 
1521 	if (test_bit(BRCMF_P2P_STATUS_DISCOVER_LISTEN, &p2p->status) &&
1522 	    p2p->af_sent_channel ==
1523 	    ieee80211_frequency_to_channel(p2p->remain_on_channel.center_freq))
1524 		p2p->wait_for_offchan_complete = false;
1525 	else
1526 		p2p->wait_for_offchan_complete = true;
1527 
1528 	brcmf_dbg(TRACE, "Waiting for %s tx completion event\n",
1529 		  (p2p->wait_for_offchan_complete) ?
1530 		   "off-channel" : "on-channel");
1531 
1532 	timeout = wait_for_completion_timeout(&p2p->send_af_done,
1533 					      P2P_AF_MAX_WAIT_TIME);
1534 
1535 	if (test_bit(BRCMF_P2P_STATUS_ACTION_TX_COMPLETED, &p2p->status)) {
1536 		brcmf_dbg(TRACE, "TX action frame operation is success\n");
1537 	} else {
1538 		err = -EIO;
1539 		brcmf_dbg(TRACE, "TX action frame operation has failed\n");
1540 	}
1541 	/* clear status bit for action tx */
1542 	clear_bit(BRCMF_P2P_STATUS_ACTION_TX_COMPLETED, &p2p->status);
1543 	clear_bit(BRCMF_P2P_STATUS_ACTION_TX_NOACK, &p2p->status);
1544 
1545 exit:
1546 	return err;
1547 }
1548 
1549 
1550 /**
1551  * brcmf_p2p_pub_af_tx() - public action frame tx routine.
1552  *
1553  * @cfg: driver private data for cfg80211 interface.
1554  * @af_params: action frame data/info.
1555  * @config_af_params: configuration data for action frame.
1556  *
1557  * routine which transmits ation frame public type.
1558  */
brcmf_p2p_pub_af_tx(struct brcmf_cfg80211_info * cfg,struct brcmf_fil_af_params_le * af_params,struct brcmf_config_af_params * config_af_params)1559 static s32 brcmf_p2p_pub_af_tx(struct brcmf_cfg80211_info *cfg,
1560 			       struct brcmf_fil_af_params_le *af_params,
1561 			       struct brcmf_config_af_params *config_af_params)
1562 {
1563 	struct brcmf_p2p_info *p2p = &cfg->p2p;
1564 	struct brcmf_fil_action_frame_le *action_frame;
1565 	struct brcmf_p2p_pub_act_frame *act_frm;
1566 	s32 err = 0;
1567 	u16 ie_len;
1568 
1569 	action_frame = &af_params->action_frame;
1570 	act_frm = (struct brcmf_p2p_pub_act_frame *)(action_frame->data);
1571 
1572 	config_af_params->extra_listen = true;
1573 
1574 	switch (act_frm->subtype) {
1575 	case P2P_PAF_GON_REQ:
1576 		brcmf_dbg(TRACE, "P2P: GO_NEG_PHASE status set\n");
1577 		set_bit(BRCMF_P2P_STATUS_GO_NEG_PHASE, &p2p->status);
1578 		config_af_params->mpc_onoff = 0;
1579 		config_af_params->search_channel = true;
1580 		p2p->next_af_subtype = act_frm->subtype + 1;
1581 		p2p->gon_req_action = true;
1582 		/* increase dwell time to wait for RESP frame */
1583 		af_params->dwell_time = cpu_to_le32(P2P_AF_MED_DWELL_TIME);
1584 		break;
1585 	case P2P_PAF_GON_RSP:
1586 		p2p->next_af_subtype = act_frm->subtype + 1;
1587 		/* increase dwell time to wait for CONF frame */
1588 		af_params->dwell_time = cpu_to_le32(P2P_AF_MED_DWELL_TIME);
1589 		break;
1590 	case P2P_PAF_GON_CONF:
1591 		/* If we reached till GO Neg confirmation reset the filter */
1592 		brcmf_dbg(TRACE, "P2P: GO_NEG_PHASE status cleared\n");
1593 		clear_bit(BRCMF_P2P_STATUS_GO_NEG_PHASE, &p2p->status);
1594 		/* turn on mpc again if go nego is done */
1595 		config_af_params->mpc_onoff = 1;
1596 		/* minimize dwell time */
1597 		af_params->dwell_time = cpu_to_le32(P2P_AF_MIN_DWELL_TIME);
1598 		config_af_params->extra_listen = false;
1599 		break;
1600 	case P2P_PAF_INVITE_REQ:
1601 		config_af_params->search_channel = true;
1602 		p2p->next_af_subtype = act_frm->subtype + 1;
1603 		/* increase dwell time */
1604 		af_params->dwell_time = cpu_to_le32(P2P_AF_MED_DWELL_TIME);
1605 		break;
1606 	case P2P_PAF_INVITE_RSP:
1607 		/* minimize dwell time */
1608 		af_params->dwell_time = cpu_to_le32(P2P_AF_MIN_DWELL_TIME);
1609 		config_af_params->extra_listen = false;
1610 		break;
1611 	case P2P_PAF_DEVDIS_REQ:
1612 		config_af_params->search_channel = true;
1613 		p2p->next_af_subtype = act_frm->subtype + 1;
1614 		/* maximize dwell time to wait for RESP frame */
1615 		af_params->dwell_time = cpu_to_le32(P2P_AF_LONG_DWELL_TIME);
1616 		break;
1617 	case P2P_PAF_DEVDIS_RSP:
1618 		/* minimize dwell time */
1619 		af_params->dwell_time = cpu_to_le32(P2P_AF_MIN_DWELL_TIME);
1620 		config_af_params->extra_listen = false;
1621 		break;
1622 	case P2P_PAF_PROVDIS_REQ:
1623 		ie_len = le16_to_cpu(action_frame->len) -
1624 			 offsetof(struct brcmf_p2p_pub_act_frame, elts);
1625 		if (cfg80211_get_p2p_attr(&act_frm->elts[0], ie_len,
1626 					  IEEE80211_P2P_ATTR_GROUP_ID,
1627 					  NULL, 0) < 0)
1628 			config_af_params->search_channel = true;
1629 		config_af_params->mpc_onoff = 0;
1630 		p2p->next_af_subtype = act_frm->subtype + 1;
1631 		/* increase dwell time to wait for RESP frame */
1632 		af_params->dwell_time = cpu_to_le32(P2P_AF_MED_DWELL_TIME);
1633 		break;
1634 	case P2P_PAF_PROVDIS_RSP:
1635 		/* wpa_supplicant send go nego req right after prov disc */
1636 		p2p->next_af_subtype = P2P_PAF_GON_REQ;
1637 		/* increase dwell time to MED level */
1638 		af_params->dwell_time = cpu_to_le32(P2P_AF_MED_DWELL_TIME);
1639 		config_af_params->extra_listen = false;
1640 		break;
1641 	default:
1642 		brcmf_err("Unknown p2p pub act frame subtype: %d\n",
1643 			  act_frm->subtype);
1644 		err = -EINVAL;
1645 	}
1646 	return err;
1647 }
1648 
1649 /**
1650  * brcmf_p2p_send_action_frame() - send action frame .
1651  *
1652  * @cfg: driver private data for cfg80211 interface.
1653  * @ndev: net device to transmit on.
1654  * @af_params: configuration data for action frame.
1655  */
brcmf_p2p_send_action_frame(struct brcmf_cfg80211_info * cfg,struct net_device * ndev,struct brcmf_fil_af_params_le * af_params)1656 bool brcmf_p2p_send_action_frame(struct brcmf_cfg80211_info *cfg,
1657 				 struct net_device *ndev,
1658 				 struct brcmf_fil_af_params_le *af_params)
1659 {
1660 	struct brcmf_p2p_info *p2p = &cfg->p2p;
1661 	struct brcmf_if *ifp = netdev_priv(ndev);
1662 	struct brcmf_fil_action_frame_le *action_frame;
1663 	struct brcmf_config_af_params config_af_params;
1664 	struct afx_hdl *afx_hdl = &p2p->afx_hdl;
1665 	u16 action_frame_len;
1666 	bool ack = false;
1667 	u8 category;
1668 	u8 action;
1669 	s32 tx_retry;
1670 	s32 extra_listen_time;
1671 	uint delta_ms;
1672 
1673 	action_frame = &af_params->action_frame;
1674 	action_frame_len = le16_to_cpu(action_frame->len);
1675 
1676 	brcmf_p2p_print_actframe(true, action_frame->data, action_frame_len);
1677 
1678 	/* Add the default dwell time. Dwell time to stay off-channel */
1679 	/* to wait for a response action frame after transmitting an  */
1680 	/* GO Negotiation action frame                                */
1681 	af_params->dwell_time = cpu_to_le32(P2P_AF_DWELL_TIME);
1682 
1683 	category = action_frame->data[DOT11_ACTION_CAT_OFF];
1684 	action = action_frame->data[DOT11_ACTION_ACT_OFF];
1685 
1686 	/* initialize variables */
1687 	p2p->next_af_subtype = P2P_PAF_SUBTYPE_INVALID;
1688 	p2p->gon_req_action = false;
1689 
1690 	/* config parameters */
1691 	config_af_params.mpc_onoff = -1;
1692 	config_af_params.search_channel = false;
1693 	config_af_params.extra_listen = false;
1694 
1695 	if (brcmf_p2p_is_pub_action(action_frame->data, action_frame_len)) {
1696 		/* p2p public action frame process */
1697 		if (brcmf_p2p_pub_af_tx(cfg, af_params, &config_af_params)) {
1698 			/* Just send unknown subtype frame with */
1699 			/* default parameters.                  */
1700 			brcmf_err("P2P Public action frame, unknown subtype.\n");
1701 		}
1702 	} else if (brcmf_p2p_is_gas_action(action_frame->data,
1703 					   action_frame_len)) {
1704 		/* service discovery process */
1705 		if (action == P2PSD_ACTION_ID_GAS_IREQ ||
1706 		    action == P2PSD_ACTION_ID_GAS_CREQ) {
1707 			/* configure service discovery query frame */
1708 			config_af_params.search_channel = true;
1709 
1710 			/* save next af suptype to cancel */
1711 			/* remaining dwell time           */
1712 			p2p->next_af_subtype = action + 1;
1713 
1714 			af_params->dwell_time =
1715 				cpu_to_le32(P2P_AF_MED_DWELL_TIME);
1716 		} else if (action == P2PSD_ACTION_ID_GAS_IRESP ||
1717 			   action == P2PSD_ACTION_ID_GAS_CRESP) {
1718 			/* configure service discovery response frame */
1719 			af_params->dwell_time =
1720 				cpu_to_le32(P2P_AF_MIN_DWELL_TIME);
1721 		} else {
1722 			brcmf_err("Unknown action type: %d\n", action);
1723 			goto exit;
1724 		}
1725 	} else if (brcmf_p2p_is_p2p_action(action_frame->data,
1726 					   action_frame_len)) {
1727 		/* do not configure anything. it will be */
1728 		/* sent with a default configuration     */
1729 	} else {
1730 		brcmf_err("Unknown Frame: category 0x%x, action 0x%x\n",
1731 			  category, action);
1732 		return false;
1733 	}
1734 
1735 	/* if connecting on primary iface, sleep for a while before sending
1736 	 * af tx for VSDB
1737 	 */
1738 	if (test_bit(BRCMF_VIF_STATUS_CONNECTING,
1739 		     &p2p->bss_idx[P2PAPI_BSSCFG_PRIMARY].vif->sme_state))
1740 		msleep(50);
1741 
1742 	/* if scan is ongoing, abort current scan. */
1743 	if (test_bit(BRCMF_SCAN_STATUS_BUSY, &cfg->scan_status))
1744 		brcmf_abort_scanning(cfg);
1745 
1746 	memcpy(afx_hdl->tx_dst_addr, action_frame->da, ETH_ALEN);
1747 
1748 	/* To make sure to send successfully action frame, turn off mpc */
1749 	if (config_af_params.mpc_onoff == 0)
1750 		brcmf_set_mpc(ifp, 0);
1751 
1752 	/* set status and destination address before sending af */
1753 	if (p2p->next_af_subtype != P2P_PAF_SUBTYPE_INVALID) {
1754 		/* set status to cancel the remained dwell time in rx process */
1755 		set_bit(BRCMF_P2P_STATUS_WAITING_NEXT_ACT_FRAME, &p2p->status);
1756 	}
1757 
1758 	p2p->af_sent_channel = 0;
1759 	set_bit(BRCMF_P2P_STATUS_SENDING_ACT_FRAME, &p2p->status);
1760 	/* validate channel and p2p ies */
1761 	if (config_af_params.search_channel &&
1762 	    IS_P2P_SOCIAL_CHANNEL(le32_to_cpu(af_params->channel)) &&
1763 	    p2p->bss_idx[P2PAPI_BSSCFG_DEVICE].vif->saved_ie.probe_req_ie_len) {
1764 		afx_hdl = &p2p->afx_hdl;
1765 		afx_hdl->peer_listen_chan = le32_to_cpu(af_params->channel);
1766 
1767 		if (brcmf_p2p_af_searching_channel(p2p) ==
1768 							P2P_INVALID_CHANNEL) {
1769 			brcmf_err("Couldn't find peer's channel.\n");
1770 			goto exit;
1771 		}
1772 
1773 		/* Abort scan even for VSDB scenarios. Scan gets aborted in
1774 		 * firmware but after the check of piggyback algorithm. To take
1775 		 * care of current piggback algo, lets abort the scan here
1776 		 * itself.
1777 		 */
1778 		brcmf_notify_escan_complete(cfg, ifp, true, true);
1779 
1780 		/* update channel */
1781 		af_params->channel = cpu_to_le32(afx_hdl->peer_chan);
1782 	}
1783 
1784 	tx_retry = 0;
1785 	while (!p2p->block_gon_req_tx &&
1786 	       (ack == false) && (tx_retry < P2P_AF_TX_MAX_RETRY)) {
1787 		ack = !brcmf_p2p_tx_action_frame(p2p, af_params);
1788 		tx_retry++;
1789 	}
1790 	if (ack == false) {
1791 		brcmf_err("Failed to send Action Frame(retry %d)\n", tx_retry);
1792 		clear_bit(BRCMF_P2P_STATUS_GO_NEG_PHASE, &p2p->status);
1793 	}
1794 
1795 exit:
1796 	clear_bit(BRCMF_P2P_STATUS_SENDING_ACT_FRAME, &p2p->status);
1797 
1798 	/* WAR: sometimes dongle does not keep the dwell time of 'actframe'.
1799 	 * if we coundn't get the next action response frame and dongle does
1800 	 * not keep the dwell time, go to listen state again to get next action
1801 	 * response frame.
1802 	 */
1803 	if (ack && config_af_params.extra_listen && !p2p->block_gon_req_tx &&
1804 	    test_bit(BRCMF_P2P_STATUS_WAITING_NEXT_ACT_FRAME, &p2p->status) &&
1805 	    p2p->af_sent_channel == afx_hdl->my_listen_chan) {
1806 		delta_ms = jiffies_to_msecs(jiffies - p2p->af_tx_sent_jiffies);
1807 		if (le32_to_cpu(af_params->dwell_time) > delta_ms)
1808 			extra_listen_time = le32_to_cpu(af_params->dwell_time) -
1809 					    delta_ms;
1810 		else
1811 			extra_listen_time = 0;
1812 		if (extra_listen_time > 50) {
1813 			set_bit(BRCMF_P2P_STATUS_WAITING_NEXT_AF_LISTEN,
1814 				&p2p->status);
1815 			brcmf_dbg(INFO, "Wait more time! actual af time:%d, calculated extra listen:%d\n",
1816 				  le32_to_cpu(af_params->dwell_time),
1817 				  extra_listen_time);
1818 			extra_listen_time += 100;
1819 			if (!brcmf_p2p_discover_listen(p2p,
1820 						       p2p->af_sent_channel,
1821 						       extra_listen_time)) {
1822 				unsigned long duration;
1823 
1824 				extra_listen_time += 100;
1825 				duration = msecs_to_jiffies(extra_listen_time);
1826 				wait_for_completion_timeout(&p2p->wait_next_af,
1827 							    duration);
1828 			}
1829 			clear_bit(BRCMF_P2P_STATUS_WAITING_NEXT_AF_LISTEN,
1830 				  &p2p->status);
1831 		}
1832 	}
1833 
1834 	if (p2p->block_gon_req_tx) {
1835 		/* if ack is true, supplicant will wait more time(100ms).
1836 		 * so we will return it as a success to get more time .
1837 		 */
1838 		p2p->block_gon_req_tx = false;
1839 		ack = true;
1840 	}
1841 
1842 	clear_bit(BRCMF_P2P_STATUS_WAITING_NEXT_ACT_FRAME, &p2p->status);
1843 	/* if all done, turn mpc on again */
1844 	if (config_af_params.mpc_onoff == 1)
1845 		brcmf_set_mpc(ifp, 1);
1846 
1847 	return ack;
1848 }
1849 
1850 /**
1851  * brcmf_p2p_notify_rx_mgmt_p2p_probereq() - Event handler for p2p probe req.
1852  *
1853  * @ifp: interface pointer for which event was received.
1854  * @e: even message.
1855  * @data: payload of event message (probe request).
1856  */
brcmf_p2p_notify_rx_mgmt_p2p_probereq(struct brcmf_if * ifp,const struct brcmf_event_msg * e,void * data)1857 s32 brcmf_p2p_notify_rx_mgmt_p2p_probereq(struct brcmf_if *ifp,
1858 					  const struct brcmf_event_msg *e,
1859 					  void *data)
1860 {
1861 	struct brcmf_cfg80211_info *cfg = ifp->drvr->config;
1862 	struct brcmf_p2p_info *p2p = &cfg->p2p;
1863 	struct afx_hdl *afx_hdl = &p2p->afx_hdl;
1864 	struct brcmf_cfg80211_vif *vif = ifp->vif;
1865 	struct brcmf_rx_mgmt_data *rxframe = (struct brcmf_rx_mgmt_data *)data;
1866 	u16 chanspec = be16_to_cpu(rxframe->chanspec);
1867 	struct brcmu_chan ch;
1868 	u8 *mgmt_frame;
1869 	u32 mgmt_frame_len;
1870 	s32 freq;
1871 	u16 mgmt_type;
1872 
1873 	brcmf_dbg(INFO, "Enter: event %d reason %d\n", e->event_code,
1874 		  e->reason);
1875 
1876 	if (e->datalen < sizeof(*rxframe)) {
1877 		brcmf_dbg(SCAN, "Event data to small. Ignore\n");
1878 		return 0;
1879 	}
1880 
1881 	ch.chspec = be16_to_cpu(rxframe->chanspec);
1882 	cfg->d11inf.decchspec(&ch);
1883 
1884 	if (test_bit(BRCMF_P2P_STATUS_FINDING_COMMON_CHANNEL, &p2p->status) &&
1885 	    (ether_addr_equal(afx_hdl->tx_dst_addr, e->addr))) {
1886 		afx_hdl->peer_chan = ch.control_ch_num;
1887 		brcmf_dbg(INFO, "PROBE REQUEST: Peer found, channel=%d\n",
1888 			  afx_hdl->peer_chan);
1889 		complete(&afx_hdl->act_frm_scan);
1890 	}
1891 
1892 	/* Firmware sends us two proberesponses for each idx one. At the */
1893 	/* moment anything but bsscfgidx 0 is passed up to supplicant    */
1894 	if (e->bsscfgidx == 0)
1895 		return 0;
1896 
1897 	/* Filter any P2P probe reqs arriving during the GO-NEG Phase */
1898 	if (test_bit(BRCMF_P2P_STATUS_GO_NEG_PHASE, &p2p->status)) {
1899 		brcmf_dbg(INFO, "Filtering P2P probe_req in GO-NEG phase\n");
1900 		return 0;
1901 	}
1902 
1903 	/* Check if wpa_supplicant has registered for this frame */
1904 	brcmf_dbg(INFO, "vif->mgmt_rx_reg %04x\n", vif->mgmt_rx_reg);
1905 	mgmt_type = (IEEE80211_STYPE_PROBE_REQ & IEEE80211_FCTL_STYPE) >> 4;
1906 	if ((vif->mgmt_rx_reg & BIT(mgmt_type)) == 0)
1907 		return 0;
1908 
1909 	mgmt_frame = (u8 *)(rxframe + 1);
1910 	mgmt_frame_len = e->datalen - sizeof(*rxframe);
1911 	freq = ieee80211_channel_to_frequency(ch.control_ch_num,
1912 					      ch.band == BRCMU_CHAN_BAND_2G ?
1913 					      NL80211_BAND_2GHZ :
1914 					      NL80211_BAND_5GHZ);
1915 
1916 	cfg80211_rx_mgmt(&vif->wdev, freq, 0, mgmt_frame, mgmt_frame_len, 0);
1917 
1918 	brcmf_dbg(INFO, "mgmt_frame_len (%d) , e->datalen (%d), chanspec (%04x), freq (%d)\n",
1919 		  mgmt_frame_len, e->datalen, chanspec, freq);
1920 
1921 	return 0;
1922 }
1923 
1924 
1925 /**
1926  * brcmf_p2p_get_current_chanspec() - Get current operation channel.
1927  *
1928  * @p2p: P2P specific data.
1929  * @chanspec: chanspec to be returned.
1930  */
brcmf_p2p_get_current_chanspec(struct brcmf_p2p_info * p2p,u16 * chanspec)1931 static void brcmf_p2p_get_current_chanspec(struct brcmf_p2p_info *p2p,
1932 					   u16 *chanspec)
1933 {
1934 	struct brcmf_if *ifp;
1935 	u8 mac_addr[ETH_ALEN];
1936 	struct brcmu_chan ch;
1937 	struct brcmf_bss_info_le *bi;
1938 	u8 *buf;
1939 
1940 	ifp = p2p->bss_idx[P2PAPI_BSSCFG_PRIMARY].vif->ifp;
1941 
1942 	if (brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSSID, mac_addr,
1943 				   ETH_ALEN) == 0) {
1944 		buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
1945 		if (buf != NULL) {
1946 			*(__le32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
1947 			if (brcmf_fil_cmd_data_get(ifp, BRCMF_C_GET_BSS_INFO,
1948 						   buf, WL_BSS_INFO_MAX) == 0) {
1949 				bi = (struct brcmf_bss_info_le *)(buf + 4);
1950 				*chanspec = le16_to_cpu(bi->chanspec);
1951 				kfree(buf);
1952 				return;
1953 			}
1954 			kfree(buf);
1955 		}
1956 	}
1957 	/* Use default channel for P2P */
1958 	ch.chnum = BRCMF_P2P_TEMP_CHAN;
1959 	ch.bw = BRCMU_CHAN_BW_20;
1960 	p2p->cfg->d11inf.encchspec(&ch);
1961 	*chanspec = ch.chspec;
1962 }
1963 
1964 /**
1965  * Change a P2P Role.
1966  * Parameters:
1967  * @mac: MAC address of the BSS to change a role
1968  * Returns 0 if success.
1969  */
brcmf_p2p_ifchange(struct brcmf_cfg80211_info * cfg,enum brcmf_fil_p2p_if_types if_type)1970 int brcmf_p2p_ifchange(struct brcmf_cfg80211_info *cfg,
1971 		       enum brcmf_fil_p2p_if_types if_type)
1972 {
1973 	struct brcmf_p2p_info *p2p = &cfg->p2p;
1974 	struct brcmf_cfg80211_vif *vif;
1975 	struct brcmf_fil_p2p_if_le if_request;
1976 	s32 err;
1977 	u16 chanspec;
1978 
1979 	brcmf_dbg(TRACE, "Enter\n");
1980 
1981 	vif = p2p->bss_idx[P2PAPI_BSSCFG_PRIMARY].vif;
1982 	if (!vif) {
1983 		brcmf_err("vif for P2PAPI_BSSCFG_PRIMARY does not exist\n");
1984 		return -EPERM;
1985 	}
1986 	brcmf_notify_escan_complete(cfg, vif->ifp, true, true);
1987 	vif = p2p->bss_idx[P2PAPI_BSSCFG_CONNECTION].vif;
1988 	if (!vif) {
1989 		brcmf_err("vif for P2PAPI_BSSCFG_CONNECTION does not exist\n");
1990 		return -EPERM;
1991 	}
1992 	brcmf_set_mpc(vif->ifp, 0);
1993 
1994 	/* In concurrency case, STA may be already associated in a particular */
1995 	/* channel. so retrieve the current channel of primary interface and  */
1996 	/* then start the virtual interface on that.                          */
1997 	brcmf_p2p_get_current_chanspec(p2p, &chanspec);
1998 
1999 	if_request.type = cpu_to_le16((u16)if_type);
2000 	if_request.chspec = cpu_to_le16(chanspec);
2001 	memcpy(if_request.addr, p2p->int_addr, sizeof(if_request.addr));
2002 
2003 	brcmf_cfg80211_arm_vif_event(cfg, vif);
2004 	err = brcmf_fil_iovar_data_set(vif->ifp, "p2p_ifupd", &if_request,
2005 				       sizeof(if_request));
2006 	if (err) {
2007 		brcmf_err("p2p_ifupd FAILED, err=%d\n", err);
2008 		brcmf_cfg80211_arm_vif_event(cfg, NULL);
2009 		return err;
2010 	}
2011 	err = brcmf_cfg80211_wait_vif_event(cfg, BRCMF_E_IF_CHANGE,
2012 					    BRCMF_VIF_EVENT_TIMEOUT);
2013 	brcmf_cfg80211_arm_vif_event(cfg, NULL);
2014 	if (!err)  {
2015 		brcmf_err("No BRCMF_E_IF_CHANGE event received\n");
2016 		return -EIO;
2017 	}
2018 
2019 	err = brcmf_fil_cmd_int_set(vif->ifp, BRCMF_C_SET_SCB_TIMEOUT,
2020 				    BRCMF_SCB_TIMEOUT_VALUE);
2021 
2022 	return err;
2023 }
2024 
brcmf_p2p_request_p2p_if(struct brcmf_p2p_info * p2p,struct brcmf_if * ifp,u8 ea[ETH_ALEN],enum brcmf_fil_p2p_if_types iftype)2025 static int brcmf_p2p_request_p2p_if(struct brcmf_p2p_info *p2p,
2026 				    struct brcmf_if *ifp, u8 ea[ETH_ALEN],
2027 				    enum brcmf_fil_p2p_if_types iftype)
2028 {
2029 	struct brcmf_fil_p2p_if_le if_request;
2030 	int err;
2031 	u16 chanspec;
2032 
2033 	/* we need a default channel */
2034 	brcmf_p2p_get_current_chanspec(p2p, &chanspec);
2035 
2036 	/* fill the firmware request */
2037 	memcpy(if_request.addr, ea, ETH_ALEN);
2038 	if_request.type = cpu_to_le16((u16)iftype);
2039 	if_request.chspec = cpu_to_le16(chanspec);
2040 
2041 	err = brcmf_fil_iovar_data_set(ifp, "p2p_ifadd", &if_request,
2042 				       sizeof(if_request));
2043 
2044 	return err;
2045 }
2046 
brcmf_p2p_disable_p2p_if(struct brcmf_cfg80211_vif * vif)2047 static int brcmf_p2p_disable_p2p_if(struct brcmf_cfg80211_vif *vif)
2048 {
2049 	struct brcmf_cfg80211_info *cfg = wdev_to_cfg(&vif->wdev);
2050 	struct net_device *pri_ndev = cfg_to_ndev(cfg);
2051 	struct brcmf_if *ifp = netdev_priv(pri_ndev);
2052 	u8 *addr = vif->wdev.netdev->dev_addr;
2053 
2054 	return brcmf_fil_iovar_data_set(ifp, "p2p_ifdis", addr, ETH_ALEN);
2055 }
2056 
brcmf_p2p_release_p2p_if(struct brcmf_cfg80211_vif * vif)2057 static int brcmf_p2p_release_p2p_if(struct brcmf_cfg80211_vif *vif)
2058 {
2059 	struct brcmf_cfg80211_info *cfg = wdev_to_cfg(&vif->wdev);
2060 	struct net_device *pri_ndev = cfg_to_ndev(cfg);
2061 	struct brcmf_if *ifp = netdev_priv(pri_ndev);
2062 	u8 *addr = vif->wdev.netdev->dev_addr;
2063 
2064 	return brcmf_fil_iovar_data_set(ifp, "p2p_ifdel", addr, ETH_ALEN);
2065 }
2066 
2067 /**
2068  * brcmf_p2p_create_p2pdev() - create a P2P_DEVICE virtual interface.
2069  *
2070  * @p2p: P2P specific data.
2071  * @wiphy: wiphy device of new interface.
2072  * @addr: mac address for this new interface.
2073  */
brcmf_p2p_create_p2pdev(struct brcmf_p2p_info * p2p,struct wiphy * wiphy,u8 * addr)2074 static struct wireless_dev *brcmf_p2p_create_p2pdev(struct brcmf_p2p_info *p2p,
2075 						    struct wiphy *wiphy,
2076 						    u8 *addr)
2077 {
2078 	struct brcmf_cfg80211_vif *p2p_vif;
2079 	struct brcmf_if *p2p_ifp;
2080 	struct brcmf_if *pri_ifp;
2081 	int err;
2082 	u32 bsscfgidx;
2083 
2084 	if (p2p->bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
2085 		return ERR_PTR(-ENOSPC);
2086 
2087 	p2p_vif = brcmf_alloc_vif(p2p->cfg, NL80211_IFTYPE_P2P_DEVICE);
2088 	if (IS_ERR(p2p_vif)) {
2089 		brcmf_err("could not create discovery vif\n");
2090 		return (struct wireless_dev *)p2p_vif;
2091 	}
2092 
2093 	pri_ifp = p2p->bss_idx[P2PAPI_BSSCFG_PRIMARY].vif->ifp;
2094 	brcmf_p2p_generate_bss_mac(p2p, addr);
2095 	brcmf_p2p_set_firmware(pri_ifp, p2p->dev_addr);
2096 
2097 	brcmf_cfg80211_arm_vif_event(p2p->cfg, p2p_vif);
2098 	brcmf_fweh_p2pdev_setup(pri_ifp, true);
2099 
2100 	/* Initialize P2P Discovery in the firmware */
2101 	err = brcmf_fil_iovar_int_set(pri_ifp, "p2p_disc", 1);
2102 	if (err < 0) {
2103 		brcmf_err("set p2p_disc error\n");
2104 		brcmf_fweh_p2pdev_setup(pri_ifp, false);
2105 		brcmf_cfg80211_arm_vif_event(p2p->cfg, NULL);
2106 		goto fail;
2107 	}
2108 
2109 	/* wait for firmware event */
2110 	err = brcmf_cfg80211_wait_vif_event(p2p->cfg, BRCMF_E_IF_ADD,
2111 					    BRCMF_VIF_EVENT_TIMEOUT);
2112 	brcmf_cfg80211_arm_vif_event(p2p->cfg, NULL);
2113 	brcmf_fweh_p2pdev_setup(pri_ifp, false);
2114 	if (!err) {
2115 		brcmf_err("timeout occurred\n");
2116 		err = -EIO;
2117 		goto fail;
2118 	}
2119 
2120 	/* discovery interface created */
2121 	p2p_ifp = p2p_vif->ifp;
2122 	p2p->bss_idx[P2PAPI_BSSCFG_DEVICE].vif = p2p_vif;
2123 	memcpy(p2p_ifp->mac_addr, p2p->dev_addr, ETH_ALEN);
2124 	memcpy(&p2p_vif->wdev.address, p2p->dev_addr, sizeof(p2p->dev_addr));
2125 
2126 	/* verify bsscfg index for P2P discovery */
2127 	err = brcmf_fil_iovar_int_get(pri_ifp, "p2p_dev", &bsscfgidx);
2128 	if (err < 0) {
2129 		brcmf_err("retrieving discover bsscfg index failed\n");
2130 		goto fail;
2131 	}
2132 
2133 	WARN_ON(p2p_ifp->bsscfgidx != bsscfgidx);
2134 
2135 	init_completion(&p2p->send_af_done);
2136 	INIT_WORK(&p2p->afx_hdl.afx_work, brcmf_p2p_afx_handler);
2137 	init_completion(&p2p->afx_hdl.act_frm_scan);
2138 	init_completion(&p2p->wait_next_af);
2139 
2140 	return &p2p_vif->wdev;
2141 
2142 fail:
2143 	brcmf_free_vif(p2p_vif);
2144 	return ERR_PTR(err);
2145 }
2146 
2147 /**
2148  * brcmf_p2p_add_vif() - create a new P2P virtual interface.
2149  *
2150  * @wiphy: wiphy device of new interface.
2151  * @name: name of the new interface.
2152  * @name_assign_type: origin of the interface name
2153  * @type: nl80211 interface type.
2154  * @params: contains mac address for P2P device.
2155  */
brcmf_p2p_add_vif(struct wiphy * wiphy,const char * name,unsigned char name_assign_type,enum nl80211_iftype type,struct vif_params * params)2156 struct wireless_dev *brcmf_p2p_add_vif(struct wiphy *wiphy, const char *name,
2157 				       unsigned char name_assign_type,
2158 				       enum nl80211_iftype type,
2159 				       struct vif_params *params)
2160 {
2161 	struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2162 	struct brcmf_if *ifp = netdev_priv(cfg_to_ndev(cfg));
2163 	struct brcmf_cfg80211_vif *vif;
2164 	enum brcmf_fil_p2p_if_types iftype;
2165 	int err;
2166 
2167 	if (brcmf_cfg80211_vif_event_armed(cfg))
2168 		return ERR_PTR(-EBUSY);
2169 
2170 	brcmf_dbg(INFO, "adding vif \"%s\" (type=%d)\n", name, type);
2171 
2172 	switch (type) {
2173 	case NL80211_IFTYPE_P2P_CLIENT:
2174 		iftype = BRCMF_FIL_P2P_IF_CLIENT;
2175 		break;
2176 	case NL80211_IFTYPE_P2P_GO:
2177 		iftype = BRCMF_FIL_P2P_IF_GO;
2178 		break;
2179 	case NL80211_IFTYPE_P2P_DEVICE:
2180 		return brcmf_p2p_create_p2pdev(&cfg->p2p, wiphy,
2181 					       params->macaddr);
2182 	default:
2183 		return ERR_PTR(-EOPNOTSUPP);
2184 	}
2185 
2186 	vif = brcmf_alloc_vif(cfg, type);
2187 	if (IS_ERR(vif))
2188 		return (struct wireless_dev *)vif;
2189 	brcmf_cfg80211_arm_vif_event(cfg, vif);
2190 
2191 	err = brcmf_p2p_request_p2p_if(&cfg->p2p, ifp, cfg->p2p.int_addr,
2192 				       iftype);
2193 	if (err) {
2194 		brcmf_cfg80211_arm_vif_event(cfg, NULL);
2195 		goto fail;
2196 	}
2197 
2198 	/* wait for firmware event */
2199 	err = brcmf_cfg80211_wait_vif_event(cfg, BRCMF_E_IF_ADD,
2200 					    BRCMF_VIF_EVENT_TIMEOUT);
2201 	brcmf_cfg80211_arm_vif_event(cfg, NULL);
2202 	if (!err) {
2203 		brcmf_err("timeout occurred\n");
2204 		err = -EIO;
2205 		goto fail;
2206 	}
2207 
2208 	/* interface created in firmware */
2209 	ifp = vif->ifp;
2210 	if (!ifp) {
2211 		brcmf_err("no if pointer provided\n");
2212 		err = -ENOENT;
2213 		goto fail;
2214 	}
2215 
2216 	strncpy(ifp->ndev->name, name, sizeof(ifp->ndev->name) - 1);
2217 	ifp->ndev->name_assign_type = name_assign_type;
2218 	err = brcmf_net_attach(ifp, true);
2219 	if (err) {
2220 		brcmf_err("Registering netdevice failed\n");
2221 		free_netdev(ifp->ndev);
2222 		goto fail;
2223 	}
2224 
2225 	cfg->p2p.bss_idx[P2PAPI_BSSCFG_CONNECTION].vif = vif;
2226 	/* Disable firmware roaming for P2P interface  */
2227 	brcmf_fil_iovar_int_set(ifp, "roam_off", 1);
2228 	if (iftype == BRCMF_FIL_P2P_IF_GO) {
2229 		/* set station timeout for p2p */
2230 		brcmf_fil_cmd_int_set(ifp, BRCMF_C_SET_SCB_TIMEOUT,
2231 				      BRCMF_SCB_TIMEOUT_VALUE);
2232 	}
2233 	return &ifp->vif->wdev;
2234 
2235 fail:
2236 	brcmf_free_vif(vif);
2237 	return ERR_PTR(err);
2238 }
2239 
2240 /**
2241  * brcmf_p2p_del_vif() - delete a P2P virtual interface.
2242  *
2243  * @wiphy: wiphy device of interface.
2244  * @wdev: wireless device of interface.
2245  */
brcmf_p2p_del_vif(struct wiphy * wiphy,struct wireless_dev * wdev)2246 int brcmf_p2p_del_vif(struct wiphy *wiphy, struct wireless_dev *wdev)
2247 {
2248 	struct brcmf_cfg80211_info *cfg = wiphy_priv(wiphy);
2249 	struct brcmf_p2p_info *p2p = &cfg->p2p;
2250 	struct brcmf_cfg80211_vif *vif;
2251 	enum nl80211_iftype iftype;
2252 	bool wait_for_disable = false;
2253 	int err;
2254 
2255 	brcmf_dbg(TRACE, "delete P2P vif\n");
2256 	vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
2257 
2258 	iftype = vif->wdev.iftype;
2259 	brcmf_cfg80211_arm_vif_event(cfg, vif);
2260 	switch (iftype) {
2261 	case NL80211_IFTYPE_P2P_CLIENT:
2262 		if (test_bit(BRCMF_VIF_STATUS_DISCONNECTING, &vif->sme_state))
2263 			wait_for_disable = true;
2264 		break;
2265 
2266 	case NL80211_IFTYPE_P2P_GO:
2267 		if (!brcmf_p2p_disable_p2p_if(vif))
2268 			wait_for_disable = true;
2269 		break;
2270 
2271 	case NL80211_IFTYPE_P2P_DEVICE:
2272 		if (!p2p->bss_idx[P2PAPI_BSSCFG_DEVICE].vif)
2273 			return 0;
2274 		brcmf_p2p_cancel_remain_on_channel(vif->ifp);
2275 		brcmf_p2p_deinit_discovery(p2p);
2276 		break;
2277 
2278 	default:
2279 		return -ENOTSUPP;
2280 	}
2281 
2282 	clear_bit(BRCMF_P2P_STATUS_GO_NEG_PHASE, &p2p->status);
2283 	brcmf_dbg(INFO, "P2P: GO_NEG_PHASE status cleared\n");
2284 
2285 	if (wait_for_disable)
2286 		wait_for_completion_timeout(&cfg->vif_disabled,
2287 					    BRCMF_P2P_DISABLE_TIMEOUT);
2288 
2289 	err = 0;
2290 	if (iftype != NL80211_IFTYPE_P2P_DEVICE) {
2291 		brcmf_vif_clear_mgmt_ies(vif);
2292 		err = brcmf_p2p_release_p2p_if(vif);
2293 	}
2294 	if (!err) {
2295 		/* wait for firmware event */
2296 		err = brcmf_cfg80211_wait_vif_event(cfg, BRCMF_E_IF_DEL,
2297 						    BRCMF_VIF_EVENT_TIMEOUT);
2298 		if (!err)
2299 			err = -EIO;
2300 		else
2301 			err = 0;
2302 	}
2303 	brcmf_remove_interface(vif->ifp, true);
2304 
2305 	brcmf_cfg80211_arm_vif_event(cfg, NULL);
2306 	if (iftype != NL80211_IFTYPE_P2P_DEVICE)
2307 		p2p->bss_idx[P2PAPI_BSSCFG_CONNECTION].vif = NULL;
2308 
2309 	return err;
2310 }
2311 
brcmf_p2p_ifp_removed(struct brcmf_if * ifp,bool rtnl_locked)2312 void brcmf_p2p_ifp_removed(struct brcmf_if *ifp, bool rtnl_locked)
2313 {
2314 	struct brcmf_cfg80211_info *cfg;
2315 	struct brcmf_cfg80211_vif *vif;
2316 
2317 	brcmf_dbg(INFO, "P2P: device interface removed\n");
2318 	vif = ifp->vif;
2319 	cfg = wdev_to_cfg(&vif->wdev);
2320 	cfg->p2p.bss_idx[P2PAPI_BSSCFG_DEVICE].vif = NULL;
2321 	if (!rtnl_locked)
2322 		rtnl_lock();
2323 	cfg80211_unregister_wdev(&vif->wdev);
2324 	if (!rtnl_locked)
2325 		rtnl_unlock();
2326 	brcmf_free_vif(vif);
2327 }
2328 
brcmf_p2p_start_device(struct wiphy * wiphy,struct wireless_dev * wdev)2329 int brcmf_p2p_start_device(struct wiphy *wiphy, struct wireless_dev *wdev)
2330 {
2331 	struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2332 	struct brcmf_p2p_info *p2p = &cfg->p2p;
2333 	struct brcmf_cfg80211_vif *vif;
2334 	int err;
2335 
2336 	vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
2337 	mutex_lock(&cfg->usr_sync);
2338 	err = brcmf_p2p_enable_discovery(p2p);
2339 	if (!err)
2340 		set_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state);
2341 	mutex_unlock(&cfg->usr_sync);
2342 	return err;
2343 }
2344 
brcmf_p2p_stop_device(struct wiphy * wiphy,struct wireless_dev * wdev)2345 void brcmf_p2p_stop_device(struct wiphy *wiphy, struct wireless_dev *wdev)
2346 {
2347 	struct brcmf_cfg80211_info *cfg = wiphy_to_cfg(wiphy);
2348 	struct brcmf_p2p_info *p2p = &cfg->p2p;
2349 	struct brcmf_cfg80211_vif *vif;
2350 
2351 	vif = container_of(wdev, struct brcmf_cfg80211_vif, wdev);
2352 	/* This call can be result of the unregister_wdev call. In that case
2353 	 * we dont want to do anything anymore. Just return. The config vif
2354 	 * will have been cleared at this point.
2355 	 */
2356 	if (p2p->bss_idx[P2PAPI_BSSCFG_DEVICE].vif == vif) {
2357 		mutex_lock(&cfg->usr_sync);
2358 		/* Set the discovery state to SCAN */
2359 		(void)brcmf_p2p_set_discover_state(vif->ifp,
2360 						   WL_P2P_DISC_ST_SCAN, 0, 0);
2361 		brcmf_abort_scanning(cfg);
2362 		clear_bit(BRCMF_VIF_STATUS_READY, &vif->sme_state);
2363 		mutex_unlock(&cfg->usr_sync);
2364 	}
2365 }
2366 
2367 /**
2368  * brcmf_p2p_attach() - attach for P2P.
2369  *
2370  * @cfg: driver private data for cfg80211 interface.
2371  * @p2pdev_forced: create p2p device interface at attach.
2372  */
brcmf_p2p_attach(struct brcmf_cfg80211_info * cfg,bool p2pdev_forced)2373 s32 brcmf_p2p_attach(struct brcmf_cfg80211_info *cfg, bool p2pdev_forced)
2374 {
2375 	struct brcmf_p2p_info *p2p;
2376 	struct brcmf_if *pri_ifp;
2377 	s32 err = 0;
2378 	void *err_ptr;
2379 
2380 	p2p = &cfg->p2p;
2381 	p2p->cfg = cfg;
2382 
2383 	pri_ifp = brcmf_get_ifp(cfg->pub, 0);
2384 	p2p->bss_idx[P2PAPI_BSSCFG_PRIMARY].vif = pri_ifp->vif;
2385 
2386 	if (p2pdev_forced) {
2387 		err_ptr = brcmf_p2p_create_p2pdev(p2p, NULL, NULL);
2388 		if (IS_ERR(err_ptr)) {
2389 			brcmf_err("P2P device creation failed.\n");
2390 			err = PTR_ERR(err_ptr);
2391 		}
2392 	} else {
2393 		p2p->p2pdev_dynamically = true;
2394 	}
2395 	return err;
2396 }
2397 
2398 /**
2399  * brcmf_p2p_detach() - detach P2P.
2400  *
2401  * @p2p: P2P specific data.
2402  */
brcmf_p2p_detach(struct brcmf_p2p_info * p2p)2403 void brcmf_p2p_detach(struct brcmf_p2p_info *p2p)
2404 {
2405 	struct brcmf_cfg80211_vif *vif;
2406 
2407 	vif = p2p->bss_idx[P2PAPI_BSSCFG_DEVICE].vif;
2408 	if (vif != NULL) {
2409 		brcmf_p2p_cancel_remain_on_channel(vif->ifp);
2410 		brcmf_p2p_deinit_discovery(p2p);
2411 		brcmf_remove_interface(vif->ifp, false);
2412 	}
2413 	/* just set it all to zero */
2414 	memset(p2p, 0, sizeof(*p2p));
2415 }
2416 
2417