xref: /linux/drivers/net/wireless/microchip/wilc1000/netdev.c (revision 6a143a7cf94730f57544ea14a987dc025364dbb8)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2012 - 2018 Microchip Technology Inc., and its subsidiaries.
4  * All rights reserved.
5  */
6 
7 #include <linux/irq.h>
8 #include <linux/kthread.h>
9 #include <linux/firmware.h>
10 #include <linux/netdevice.h>
11 #include <linux/inetdevice.h>
12 
13 #include "cfg80211.h"
14 #include "wlan_cfg.h"
15 
16 #define WILC_MULTICAST_TABLE_SIZE	8
17 
18 /* latest API version supported */
19 #define WILC1000_API_VER		1
20 
21 #define WILC1000_FW_PREFIX		"atmel/wilc1000_wifi_firmware-"
22 #define __WILC1000_FW(api)		WILC1000_FW_PREFIX #api ".bin"
23 #define WILC1000_FW(api)		__WILC1000_FW(api)
24 
25 static irqreturn_t isr_uh_routine(int irq, void *user_data)
26 {
27 	struct net_device *dev = user_data;
28 	struct wilc_vif *vif = netdev_priv(dev);
29 	struct wilc *wilc = vif->wilc;
30 
31 	if (wilc->close) {
32 		netdev_err(dev, "Can't handle UH interrupt\n");
33 		return IRQ_HANDLED;
34 	}
35 	return IRQ_WAKE_THREAD;
36 }
37 
38 static irqreturn_t isr_bh_routine(int irq, void *userdata)
39 {
40 	struct net_device *dev = userdata;
41 	struct wilc_vif *vif = netdev_priv(userdata);
42 	struct wilc *wilc = vif->wilc;
43 
44 	if (wilc->close) {
45 		netdev_err(dev, "Can't handle BH interrupt\n");
46 		return IRQ_HANDLED;
47 	}
48 
49 	wilc_handle_isr(wilc);
50 
51 	return IRQ_HANDLED;
52 }
53 
54 static int init_irq(struct net_device *dev)
55 {
56 	struct wilc_vif *vif = netdev_priv(dev);
57 	struct wilc *wl = vif->wilc;
58 	int ret;
59 
60 	ret = request_threaded_irq(wl->dev_irq_num, isr_uh_routine,
61 				   isr_bh_routine,
62 				   IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
63 				   "WILC_IRQ", dev);
64 	if (ret) {
65 		netdev_err(dev, "Failed to request IRQ [%d]\n", ret);
66 		return ret;
67 	}
68 	netdev_dbg(dev, "IRQ request succeeded IRQ-NUM= %d\n", wl->dev_irq_num);
69 
70 	return 0;
71 }
72 
73 static void deinit_irq(struct net_device *dev)
74 {
75 	struct wilc_vif *vif = netdev_priv(dev);
76 	struct wilc *wilc = vif->wilc;
77 
78 	/* Deinitialize IRQ */
79 	if (wilc->dev_irq_num)
80 		free_irq(wilc->dev_irq_num, wilc);
81 }
82 
83 void wilc_mac_indicate(struct wilc *wilc)
84 {
85 	s8 status;
86 
87 	wilc_wlan_cfg_get_val(wilc, WID_STATUS, &status, 1);
88 	if (wilc->mac_status == WILC_MAC_STATUS_INIT) {
89 		wilc->mac_status = status;
90 		complete(&wilc->sync_event);
91 	} else {
92 		wilc->mac_status = status;
93 	}
94 }
95 
96 static struct net_device *get_if_handler(struct wilc *wilc, u8 *mac_header)
97 {
98 	struct net_device *ndev = NULL;
99 	struct wilc_vif *vif;
100 	struct ieee80211_hdr *h = (struct ieee80211_hdr *)mac_header;
101 
102 	list_for_each_entry_rcu(vif, &wilc->vif_list, list) {
103 		if (vif->mode == WILC_STATION_MODE)
104 			if (ether_addr_equal_unaligned(h->addr2, vif->bssid)) {
105 				ndev = vif->ndev;
106 				goto out;
107 			}
108 		if (vif->mode == WILC_AP_MODE)
109 			if (ether_addr_equal_unaligned(h->addr1, vif->bssid)) {
110 				ndev = vif->ndev;
111 				goto out;
112 			}
113 	}
114 out:
115 	return ndev;
116 }
117 
118 void wilc_wlan_set_bssid(struct net_device *wilc_netdev, u8 *bssid, u8 mode)
119 {
120 	struct wilc_vif *vif = netdev_priv(wilc_netdev);
121 
122 	if (bssid)
123 		ether_addr_copy(vif->bssid, bssid);
124 	else
125 		eth_zero_addr(vif->bssid);
126 
127 	vif->mode = mode;
128 }
129 
130 int wilc_wlan_get_num_conn_ifcs(struct wilc *wilc)
131 {
132 	int srcu_idx;
133 	u8 ret_val = 0;
134 	struct wilc_vif *vif;
135 
136 	srcu_idx = srcu_read_lock(&wilc->srcu);
137 	list_for_each_entry_rcu(vif, &wilc->vif_list, list) {
138 		if (!is_zero_ether_addr(vif->bssid))
139 			ret_val++;
140 	}
141 	srcu_read_unlock(&wilc->srcu, srcu_idx);
142 	return ret_val;
143 }
144 
145 static int wilc_txq_task(void *vp)
146 {
147 	int ret;
148 	u32 txq_count;
149 	struct wilc *wl = vp;
150 
151 	complete(&wl->txq_thread_started);
152 	while (1) {
153 		wait_for_completion(&wl->txq_event);
154 
155 		if (wl->close) {
156 			complete(&wl->txq_thread_started);
157 
158 			while (!kthread_should_stop())
159 				schedule();
160 			break;
161 		}
162 		do {
163 			ret = wilc_wlan_handle_txq(wl, &txq_count);
164 			if (txq_count < FLOW_CONTROL_LOWER_THRESHOLD) {
165 				int srcu_idx;
166 				struct wilc_vif *ifc;
167 
168 				srcu_idx = srcu_read_lock(&wl->srcu);
169 				list_for_each_entry_rcu(ifc, &wl->vif_list,
170 							list) {
171 					if (ifc->mac_opened && ifc->ndev)
172 						netif_wake_queue(ifc->ndev);
173 				}
174 				srcu_read_unlock(&wl->srcu, srcu_idx);
175 			}
176 		} while (ret == WILC_VMM_ENTRY_FULL_RETRY && !wl->close);
177 	}
178 	return 0;
179 }
180 
181 static int wilc_wlan_get_firmware(struct net_device *dev)
182 {
183 	struct wilc_vif *vif = netdev_priv(dev);
184 	struct wilc *wilc = vif->wilc;
185 	int chip_id;
186 	const struct firmware *wilc_fw;
187 	int ret;
188 
189 	chip_id = wilc_get_chipid(wilc, false);
190 
191 	netdev_info(dev, "ChipID [%x] loading firmware [%s]\n", chip_id,
192 		    WILC1000_FW(WILC1000_API_VER));
193 
194 	ret = request_firmware(&wilc_fw, WILC1000_FW(WILC1000_API_VER),
195 			       wilc->dev);
196 	if (ret != 0) {
197 		netdev_err(dev, "%s - firmware not available\n",
198 			   WILC1000_FW(WILC1000_API_VER));
199 		return -EINVAL;
200 	}
201 	wilc->firmware = wilc_fw;
202 
203 	return 0;
204 }
205 
206 static int wilc_start_firmware(struct net_device *dev)
207 {
208 	struct wilc_vif *vif = netdev_priv(dev);
209 	struct wilc *wilc = vif->wilc;
210 	int ret = 0;
211 
212 	ret = wilc_wlan_start(wilc);
213 	if (ret)
214 		return ret;
215 
216 	if (!wait_for_completion_timeout(&wilc->sync_event,
217 					 msecs_to_jiffies(5000)))
218 		return -ETIME;
219 
220 	return 0;
221 }
222 
223 static int wilc1000_firmware_download(struct net_device *dev)
224 {
225 	struct wilc_vif *vif = netdev_priv(dev);
226 	struct wilc *wilc = vif->wilc;
227 	int ret = 0;
228 
229 	if (!wilc->firmware) {
230 		netdev_err(dev, "Firmware buffer is NULL\n");
231 		return -ENOBUFS;
232 	}
233 
234 	ret = wilc_wlan_firmware_download(wilc, wilc->firmware->data,
235 					  wilc->firmware->size);
236 	if (ret)
237 		return ret;
238 
239 	release_firmware(wilc->firmware);
240 	wilc->firmware = NULL;
241 
242 	netdev_dbg(dev, "Download Succeeded\n");
243 
244 	return 0;
245 }
246 
247 static int wilc_init_fw_config(struct net_device *dev, struct wilc_vif *vif)
248 {
249 	struct wilc_priv *priv = &vif->priv;
250 	struct host_if_drv *hif_drv;
251 	u8 b;
252 	u16 hw;
253 	u32 w;
254 
255 	netdev_dbg(dev, "Start configuring Firmware\n");
256 	hif_drv = (struct host_if_drv *)priv->hif_drv;
257 	netdev_dbg(dev, "Host = %p\n", hif_drv);
258 
259 	w = vif->iftype;
260 	cpu_to_le32s(&w);
261 	if (!wilc_wlan_cfg_set(vif, 1, WID_SET_OPERATION_MODE, (u8 *)&w, 4,
262 			       0, 0))
263 		goto fail;
264 
265 	b = WILC_FW_BSS_TYPE_INFRA;
266 	if (!wilc_wlan_cfg_set(vif, 0, WID_BSS_TYPE, &b, 1, 0, 0))
267 		goto fail;
268 
269 	b = WILC_FW_TX_RATE_AUTO;
270 	if (!wilc_wlan_cfg_set(vif, 0, WID_CURRENT_TX_RATE, &b, 1, 0, 0))
271 		goto fail;
272 
273 	b = WILC_FW_OPER_MODE_G_MIXED_11B_2;
274 	if (!wilc_wlan_cfg_set(vif, 0, WID_11G_OPERATING_MODE, &b, 1, 0, 0))
275 		goto fail;
276 
277 	b = WILC_FW_PREAMBLE_SHORT;
278 	if (!wilc_wlan_cfg_set(vif, 0, WID_PREAMBLE, &b, 1, 0, 0))
279 		goto fail;
280 
281 	b = WILC_FW_11N_PROT_AUTO;
282 	if (!wilc_wlan_cfg_set(vif, 0, WID_11N_PROT_MECH, &b, 1, 0, 0))
283 		goto fail;
284 
285 	b = WILC_FW_ACTIVE_SCAN;
286 	if (!wilc_wlan_cfg_set(vif, 0, WID_SCAN_TYPE, &b, 1, 0, 0))
287 		goto fail;
288 
289 	b = WILC_FW_SITE_SURVEY_OFF;
290 	if (!wilc_wlan_cfg_set(vif, 0, WID_SITE_SURVEY, &b, 1, 0, 0))
291 		goto fail;
292 
293 	hw = 0xffff;
294 	cpu_to_le16s(&hw);
295 	if (!wilc_wlan_cfg_set(vif, 0, WID_RTS_THRESHOLD, (u8 *)&hw, 2, 0, 0))
296 		goto fail;
297 
298 	hw = 2346;
299 	cpu_to_le16s(&hw);
300 	if (!wilc_wlan_cfg_set(vif, 0, WID_FRAG_THRESHOLD, (u8 *)&hw, 2, 0, 0))
301 		goto fail;
302 
303 	b = 0;
304 	if (!wilc_wlan_cfg_set(vif, 0, WID_BCAST_SSID, &b, 1, 0, 0))
305 		goto fail;
306 
307 	b = 1;
308 	if (!wilc_wlan_cfg_set(vif, 0, WID_QOS_ENABLE, &b, 1, 0, 0))
309 		goto fail;
310 
311 	b = WILC_FW_NO_POWERSAVE;
312 	if (!wilc_wlan_cfg_set(vif, 0, WID_POWER_MANAGEMENT, &b, 1, 0, 0))
313 		goto fail;
314 
315 	b = WILC_FW_SEC_NO;
316 	if (!wilc_wlan_cfg_set(vif, 0, WID_11I_MODE, &b, 1, 0, 0))
317 		goto fail;
318 
319 	b = WILC_FW_AUTH_OPEN_SYSTEM;
320 	if (!wilc_wlan_cfg_set(vif, 0, WID_AUTH_TYPE, &b, 1, 0, 0))
321 		goto fail;
322 
323 	b = 3;
324 	if (!wilc_wlan_cfg_set(vif, 0, WID_LISTEN_INTERVAL, &b, 1, 0, 0))
325 		goto fail;
326 
327 	b = 3;
328 	if (!wilc_wlan_cfg_set(vif, 0, WID_DTIM_PERIOD, &b, 1, 0, 0))
329 		goto fail;
330 
331 	b = WILC_FW_ACK_POLICY_NORMAL;
332 	if (!wilc_wlan_cfg_set(vif, 0, WID_ACK_POLICY, &b, 1, 0, 0))
333 		goto fail;
334 
335 	b = 0;
336 	if (!wilc_wlan_cfg_set(vif, 0, WID_USER_CONTROL_ON_TX_POWER, &b, 1,
337 			       0, 0))
338 		goto fail;
339 
340 	b = 48;
341 	if (!wilc_wlan_cfg_set(vif, 0, WID_TX_POWER_LEVEL_11A, &b, 1, 0, 0))
342 		goto fail;
343 
344 	b = 28;
345 	if (!wilc_wlan_cfg_set(vif, 0, WID_TX_POWER_LEVEL_11B, &b, 1, 0, 0))
346 		goto fail;
347 
348 	hw = 100;
349 	cpu_to_le16s(&hw);
350 	if (!wilc_wlan_cfg_set(vif, 0, WID_BEACON_INTERVAL, (u8 *)&hw, 2, 0, 0))
351 		goto fail;
352 
353 	b = WILC_FW_REKEY_POLICY_DISABLE;
354 	if (!wilc_wlan_cfg_set(vif, 0, WID_REKEY_POLICY, &b, 1, 0, 0))
355 		goto fail;
356 
357 	w = 84600;
358 	cpu_to_le32s(&w);
359 	if (!wilc_wlan_cfg_set(vif, 0, WID_REKEY_PERIOD, (u8 *)&w, 4, 0, 0))
360 		goto fail;
361 
362 	w = 500;
363 	cpu_to_le32s(&w);
364 	if (!wilc_wlan_cfg_set(vif, 0, WID_REKEY_PACKET_COUNT, (u8 *)&w, 4, 0,
365 			       0))
366 		goto fail;
367 
368 	b = 1;
369 	if (!wilc_wlan_cfg_set(vif, 0, WID_SHORT_SLOT_ALLOWED, &b, 1, 0,
370 			       0))
371 		goto fail;
372 
373 	b = WILC_FW_ERP_PROT_SELF_CTS;
374 	if (!wilc_wlan_cfg_set(vif, 0, WID_11N_ERP_PROT_TYPE, &b, 1, 0, 0))
375 		goto fail;
376 
377 	b = 1;
378 	if (!wilc_wlan_cfg_set(vif, 0, WID_11N_ENABLE, &b, 1, 0, 0))
379 		goto fail;
380 
381 	b = WILC_FW_11N_OP_MODE_HT_MIXED;
382 	if (!wilc_wlan_cfg_set(vif, 0, WID_11N_OPERATING_MODE, &b, 1, 0, 0))
383 		goto fail;
384 
385 	b = 1;
386 	if (!wilc_wlan_cfg_set(vif, 0, WID_11N_TXOP_PROT_DISABLE, &b, 1, 0, 0))
387 		goto fail;
388 
389 	b = WILC_FW_OBBS_NONHT_DETECT_PROTECT_REPORT;
390 	if (!wilc_wlan_cfg_set(vif, 0, WID_11N_OBSS_NONHT_DETECTION, &b, 1,
391 			       0, 0))
392 		goto fail;
393 
394 	b = WILC_FW_HT_PROT_RTS_CTS_NONHT;
395 	if (!wilc_wlan_cfg_set(vif, 0, WID_11N_HT_PROT_TYPE, &b, 1, 0, 0))
396 		goto fail;
397 
398 	b = 0;
399 	if (!wilc_wlan_cfg_set(vif, 0, WID_11N_RIFS_PROT_ENABLE, &b, 1, 0,
400 			       0))
401 		goto fail;
402 
403 	b = 7;
404 	if (!wilc_wlan_cfg_set(vif, 0, WID_11N_CURRENT_TX_MCS, &b, 1, 0, 0))
405 		goto fail;
406 
407 	b = 1;
408 	if (!wilc_wlan_cfg_set(vif, 0, WID_11N_IMMEDIATE_BA_ENABLED, &b, 1,
409 			       1, 1))
410 		goto fail;
411 
412 	return 0;
413 
414 fail:
415 	return -EINVAL;
416 }
417 
418 static void wlan_deinitialize_threads(struct net_device *dev)
419 {
420 	struct wilc_vif *vif = netdev_priv(dev);
421 	struct wilc *wl = vif->wilc;
422 
423 	wl->close = 1;
424 
425 	complete(&wl->txq_event);
426 
427 	if (wl->txq_thread) {
428 		kthread_stop(wl->txq_thread);
429 		wl->txq_thread = NULL;
430 	}
431 }
432 
433 static void wilc_wlan_deinitialize(struct net_device *dev)
434 {
435 	struct wilc_vif *vif = netdev_priv(dev);
436 	struct wilc *wl = vif->wilc;
437 
438 	if (!wl) {
439 		netdev_err(dev, "wl is NULL\n");
440 		return;
441 	}
442 
443 	if (wl->initialized) {
444 		netdev_info(dev, "Deinitializing wilc1000...\n");
445 
446 		if (!wl->dev_irq_num &&
447 		    wl->hif_func->disable_interrupt) {
448 			mutex_lock(&wl->hif_cs);
449 			wl->hif_func->disable_interrupt(wl);
450 			mutex_unlock(&wl->hif_cs);
451 		}
452 		complete(&wl->txq_event);
453 
454 		wlan_deinitialize_threads(dev);
455 		deinit_irq(dev);
456 
457 		wilc_wlan_stop(wl, vif);
458 		wilc_wlan_cleanup(dev);
459 
460 		wl->initialized = false;
461 
462 		netdev_dbg(dev, "wilc1000 deinitialization Done\n");
463 	} else {
464 		netdev_dbg(dev, "wilc1000 is not initialized\n");
465 	}
466 }
467 
468 static int wlan_initialize_threads(struct net_device *dev)
469 {
470 	struct wilc_vif *vif = netdev_priv(dev);
471 	struct wilc *wilc = vif->wilc;
472 
473 	wilc->txq_thread = kthread_run(wilc_txq_task, (void *)wilc,
474 				       "K_TXQ_TASK");
475 	if (IS_ERR(wilc->txq_thread)) {
476 		netdev_err(dev, "couldn't create TXQ thread\n");
477 		wilc->close = 0;
478 		return PTR_ERR(wilc->txq_thread);
479 	}
480 	wait_for_completion(&wilc->txq_thread_started);
481 
482 	return 0;
483 }
484 
485 static int wilc_wlan_initialize(struct net_device *dev, struct wilc_vif *vif)
486 {
487 	int ret = 0;
488 	struct wilc *wl = vif->wilc;
489 
490 	if (!wl->initialized) {
491 		wl->mac_status = WILC_MAC_STATUS_INIT;
492 		wl->close = 0;
493 
494 		ret = wilc_wlan_init(dev);
495 		if (ret)
496 			return ret;
497 
498 		ret = wlan_initialize_threads(dev);
499 		if (ret)
500 			goto fail_wilc_wlan;
501 
502 		if (wl->dev_irq_num && init_irq(dev)) {
503 			ret = -EIO;
504 			goto fail_threads;
505 		}
506 
507 		if (!wl->dev_irq_num &&
508 		    wl->hif_func->enable_interrupt &&
509 		    wl->hif_func->enable_interrupt(wl)) {
510 			ret = -EIO;
511 			goto fail_irq_init;
512 		}
513 
514 		ret = wilc_wlan_get_firmware(dev);
515 		if (ret)
516 			goto fail_irq_enable;
517 
518 		ret = wilc1000_firmware_download(dev);
519 		if (ret)
520 			goto fail_irq_enable;
521 
522 		ret = wilc_start_firmware(dev);
523 		if (ret)
524 			goto fail_irq_enable;
525 
526 		if (wilc_wlan_cfg_get(vif, 1, WID_FIRMWARE_VERSION, 1, 0)) {
527 			int size;
528 			char firmware_ver[20];
529 
530 			size = wilc_wlan_cfg_get_val(wl, WID_FIRMWARE_VERSION,
531 						     firmware_ver,
532 						     sizeof(firmware_ver));
533 			firmware_ver[size] = '\0';
534 			netdev_dbg(dev, "Firmware Ver = %s\n", firmware_ver);
535 		}
536 
537 		ret = wilc_init_fw_config(dev, vif);
538 		if (ret) {
539 			netdev_err(dev, "Failed to configure firmware\n");
540 			goto fail_fw_start;
541 		}
542 		wl->initialized = true;
543 		return 0;
544 
545 fail_fw_start:
546 		wilc_wlan_stop(wl, vif);
547 
548 fail_irq_enable:
549 		if (!wl->dev_irq_num &&
550 		    wl->hif_func->disable_interrupt)
551 			wl->hif_func->disable_interrupt(wl);
552 fail_irq_init:
553 		if (wl->dev_irq_num)
554 			deinit_irq(dev);
555 fail_threads:
556 		wlan_deinitialize_threads(dev);
557 fail_wilc_wlan:
558 		wilc_wlan_cleanup(dev);
559 		netdev_err(dev, "WLAN initialization FAILED\n");
560 	} else {
561 		netdev_dbg(dev, "wilc1000 already initialized\n");
562 	}
563 	return ret;
564 }
565 
566 static int mac_init_fn(struct net_device *ndev)
567 {
568 	netif_start_queue(ndev);
569 	netif_stop_queue(ndev);
570 
571 	return 0;
572 }
573 
574 static int wilc_mac_open(struct net_device *ndev)
575 {
576 	struct wilc_vif *vif = netdev_priv(ndev);
577 	struct wilc *wl = vif->wilc;
578 	unsigned char mac_add[ETH_ALEN] = {0};
579 	int ret = 0;
580 	struct mgmt_frame_regs mgmt_regs = {};
581 
582 	if (!wl || !wl->dev) {
583 		netdev_err(ndev, "device not ready\n");
584 		return -ENODEV;
585 	}
586 
587 	netdev_dbg(ndev, "MAC OPEN[%p]\n", ndev);
588 
589 	ret = wilc_init_host_int(ndev);
590 	if (ret)
591 		return ret;
592 
593 	ret = wilc_wlan_initialize(ndev, vif);
594 	if (ret) {
595 		wilc_deinit_host_int(ndev);
596 		return ret;
597 	}
598 
599 	wilc_set_operation_mode(vif, wilc_get_vif_idx(vif), vif->iftype,
600 				vif->idx);
601 	wilc_get_mac_address(vif, mac_add);
602 	netdev_dbg(ndev, "Mac address: %pM\n", mac_add);
603 	ether_addr_copy(ndev->dev_addr, mac_add);
604 
605 	if (!is_valid_ether_addr(ndev->dev_addr)) {
606 		netdev_err(ndev, "Wrong MAC address\n");
607 		wilc_deinit_host_int(ndev);
608 		wilc_wlan_deinitialize(ndev);
609 		return -EINVAL;
610 	}
611 
612 	mgmt_regs.interface_stypes = vif->mgmt_reg_stypes;
613 	/* so we detect a change */
614 	vif->mgmt_reg_stypes = 0;
615 	wilc_update_mgmt_frame_registrations(vif->ndev->ieee80211_ptr->wiphy,
616 					     vif->ndev->ieee80211_ptr,
617 					     &mgmt_regs);
618 	netif_wake_queue(ndev);
619 	wl->open_ifcs++;
620 	vif->mac_opened = 1;
621 	return 0;
622 }
623 
624 static struct net_device_stats *mac_stats(struct net_device *dev)
625 {
626 	struct wilc_vif *vif = netdev_priv(dev);
627 
628 	return &vif->netstats;
629 }
630 
631 static int wilc_set_mac_addr(struct net_device *dev, void *p)
632 {
633 	int result;
634 	struct wilc_vif *vif = netdev_priv(dev);
635 	struct wilc *wilc = vif->wilc;
636 	struct sockaddr *addr = (struct sockaddr *)p;
637 	unsigned char mac_addr[ETH_ALEN];
638 	struct wilc_vif *tmp_vif;
639 	int srcu_idx;
640 
641 	if (!is_valid_ether_addr(addr->sa_data))
642 		return -EINVAL;
643 
644 	srcu_idx = srcu_read_lock(&wilc->srcu);
645 	list_for_each_entry_rcu(tmp_vif, &wilc->vif_list, list) {
646 		wilc_get_mac_address(tmp_vif, mac_addr);
647 		if (ether_addr_equal(addr->sa_data, mac_addr)) {
648 			if (vif != tmp_vif) {
649 				srcu_read_unlock(&wilc->srcu, srcu_idx);
650 				return -EINVAL;
651 			}
652 			srcu_read_unlock(&wilc->srcu, srcu_idx);
653 			return 0;
654 		}
655 	}
656 	srcu_read_unlock(&wilc->srcu, srcu_idx);
657 
658 	result = wilc_set_mac_address(vif, (u8 *)addr->sa_data);
659 	if (result)
660 		return result;
661 
662 	ether_addr_copy(vif->bssid, addr->sa_data);
663 	ether_addr_copy(vif->ndev->dev_addr, addr->sa_data);
664 
665 	return result;
666 }
667 
668 static void wilc_set_multicast_list(struct net_device *dev)
669 {
670 	struct netdev_hw_addr *ha;
671 	struct wilc_vif *vif = netdev_priv(dev);
672 	int i;
673 	u8 *mc_list;
674 	u8 *cur_mc;
675 
676 	if (dev->flags & IFF_PROMISC)
677 		return;
678 
679 	if (dev->flags & IFF_ALLMULTI ||
680 	    dev->mc.count > WILC_MULTICAST_TABLE_SIZE) {
681 		wilc_setup_multicast_filter(vif, 0, 0, NULL);
682 		return;
683 	}
684 
685 	if (dev->mc.count == 0) {
686 		wilc_setup_multicast_filter(vif, 1, 0, NULL);
687 		return;
688 	}
689 
690 	mc_list = kmalloc_array(dev->mc.count, ETH_ALEN, GFP_ATOMIC);
691 	if (!mc_list)
692 		return;
693 
694 	cur_mc = mc_list;
695 	i = 0;
696 	netdev_for_each_mc_addr(ha, dev) {
697 		memcpy(cur_mc, ha->addr, ETH_ALEN);
698 		netdev_dbg(dev, "Entry[%d]: %pM\n", i, cur_mc);
699 		i++;
700 		cur_mc += ETH_ALEN;
701 	}
702 
703 	if (wilc_setup_multicast_filter(vif, 1, dev->mc.count, mc_list))
704 		kfree(mc_list);
705 }
706 
707 static void wilc_tx_complete(void *priv, int status)
708 {
709 	struct tx_complete_data *pv_data = priv;
710 
711 	dev_kfree_skb(pv_data->skb);
712 	kfree(pv_data);
713 }
714 
715 netdev_tx_t wilc_mac_xmit(struct sk_buff *skb, struct net_device *ndev)
716 {
717 	struct wilc_vif *vif = netdev_priv(ndev);
718 	struct wilc *wilc = vif->wilc;
719 	struct tx_complete_data *tx_data = NULL;
720 	int queue_count;
721 
722 	if (skb->dev != ndev) {
723 		netdev_err(ndev, "Packet not destined to this device\n");
724 		return NETDEV_TX_OK;
725 	}
726 
727 	tx_data = kmalloc(sizeof(*tx_data), GFP_ATOMIC);
728 	if (!tx_data) {
729 		dev_kfree_skb(skb);
730 		netif_wake_queue(ndev);
731 		return NETDEV_TX_OK;
732 	}
733 
734 	tx_data->buff = skb->data;
735 	tx_data->size = skb->len;
736 	tx_data->skb  = skb;
737 
738 	vif->netstats.tx_packets++;
739 	vif->netstats.tx_bytes += tx_data->size;
740 	queue_count = wilc_wlan_txq_add_net_pkt(ndev, tx_data,
741 						tx_data->buff, tx_data->size,
742 						wilc_tx_complete);
743 
744 	if (queue_count > FLOW_CONTROL_UPPER_THRESHOLD) {
745 		int srcu_idx;
746 		struct wilc_vif *vif;
747 
748 		srcu_idx = srcu_read_lock(&wilc->srcu);
749 		list_for_each_entry_rcu(vif, &wilc->vif_list, list) {
750 			if (vif->mac_opened)
751 				netif_stop_queue(vif->ndev);
752 		}
753 		srcu_read_unlock(&wilc->srcu, srcu_idx);
754 	}
755 
756 	return NETDEV_TX_OK;
757 }
758 
759 static int wilc_mac_close(struct net_device *ndev)
760 {
761 	struct wilc_vif *vif = netdev_priv(ndev);
762 	struct wilc *wl = vif->wilc;
763 
764 	netdev_dbg(ndev, "Mac close\n");
765 
766 	if (wl->open_ifcs > 0)
767 		wl->open_ifcs--;
768 	else
769 		return 0;
770 
771 	if (vif->ndev) {
772 		netif_stop_queue(vif->ndev);
773 
774 		wilc_deinit_host_int(vif->ndev);
775 	}
776 
777 	if (wl->open_ifcs == 0) {
778 		netdev_dbg(ndev, "Deinitializing wilc1000\n");
779 		wl->close = 1;
780 		wilc_wlan_deinitialize(ndev);
781 	}
782 
783 	vif->mac_opened = 0;
784 
785 	return 0;
786 }
787 
788 void wilc_frmw_to_host(struct wilc *wilc, u8 *buff, u32 size,
789 		       u32 pkt_offset)
790 {
791 	unsigned int frame_len = 0;
792 	int stats;
793 	unsigned char *buff_to_send = NULL;
794 	struct sk_buff *skb;
795 	struct net_device *wilc_netdev;
796 	struct wilc_vif *vif;
797 
798 	if (!wilc)
799 		return;
800 
801 	wilc_netdev = get_if_handler(wilc, buff);
802 	if (!wilc_netdev)
803 		return;
804 
805 	buff += pkt_offset;
806 	vif = netdev_priv(wilc_netdev);
807 
808 	if (size > 0) {
809 		frame_len = size;
810 		buff_to_send = buff;
811 
812 		skb = dev_alloc_skb(frame_len);
813 		if (!skb)
814 			return;
815 
816 		skb->dev = wilc_netdev;
817 
818 		skb_put_data(skb, buff_to_send, frame_len);
819 
820 		skb->protocol = eth_type_trans(skb, wilc_netdev);
821 		vif->netstats.rx_packets++;
822 		vif->netstats.rx_bytes += frame_len;
823 		skb->ip_summed = CHECKSUM_UNNECESSARY;
824 		stats = netif_rx(skb);
825 		netdev_dbg(wilc_netdev, "netif_rx ret value is: %d\n", stats);
826 	}
827 }
828 
829 void wilc_wfi_mgmt_rx(struct wilc *wilc, u8 *buff, u32 size)
830 {
831 	int srcu_idx;
832 	struct wilc_vif *vif;
833 
834 	srcu_idx = srcu_read_lock(&wilc->srcu);
835 	list_for_each_entry_rcu(vif, &wilc->vif_list, list) {
836 		u16 type = le16_to_cpup((__le16 *)buff);
837 		u32 type_bit = BIT(type >> 4);
838 
839 		if (vif->priv.p2p_listen_state &&
840 		    vif->mgmt_reg_stypes & type_bit)
841 			wilc_wfi_p2p_rx(vif, buff, size);
842 
843 		if (vif->monitor_flag)
844 			wilc_wfi_monitor_rx(wilc->monitor_dev, buff, size);
845 	}
846 	srcu_read_unlock(&wilc->srcu, srcu_idx);
847 }
848 
849 static const struct net_device_ops wilc_netdev_ops = {
850 	.ndo_init = mac_init_fn,
851 	.ndo_open = wilc_mac_open,
852 	.ndo_stop = wilc_mac_close,
853 	.ndo_set_mac_address = wilc_set_mac_addr,
854 	.ndo_start_xmit = wilc_mac_xmit,
855 	.ndo_get_stats = mac_stats,
856 	.ndo_set_rx_mode  = wilc_set_multicast_list,
857 };
858 
859 void wilc_netdev_cleanup(struct wilc *wilc)
860 {
861 	struct wilc_vif *vif;
862 	int srcu_idx, ifc_cnt = 0;
863 
864 	if (!wilc)
865 		return;
866 
867 	if (wilc->firmware) {
868 		release_firmware(wilc->firmware);
869 		wilc->firmware = NULL;
870 	}
871 
872 	srcu_idx = srcu_read_lock(&wilc->srcu);
873 	list_for_each_entry_rcu(vif, &wilc->vif_list, list) {
874 		if (vif->ndev)
875 			unregister_netdev(vif->ndev);
876 	}
877 	srcu_read_unlock(&wilc->srcu, srcu_idx);
878 
879 	wilc_wfi_deinit_mon_interface(wilc, false);
880 	flush_workqueue(wilc->hif_workqueue);
881 	destroy_workqueue(wilc->hif_workqueue);
882 
883 	while (ifc_cnt < WILC_NUM_CONCURRENT_IFC) {
884 		mutex_lock(&wilc->vif_mutex);
885 		if (wilc->vif_num <= 0) {
886 			mutex_unlock(&wilc->vif_mutex);
887 			break;
888 		}
889 		vif = wilc_get_wl_to_vif(wilc);
890 		if (!IS_ERR(vif))
891 			list_del_rcu(&vif->list);
892 
893 		wilc->vif_num--;
894 		mutex_unlock(&wilc->vif_mutex);
895 		synchronize_srcu(&wilc->srcu);
896 		ifc_cnt++;
897 	}
898 
899 	wilc_wlan_cfg_deinit(wilc);
900 	wlan_deinit_locks(wilc);
901 	kfree(wilc->bus_data);
902 	wiphy_unregister(wilc->wiphy);
903 	wiphy_free(wilc->wiphy);
904 }
905 EXPORT_SYMBOL_GPL(wilc_netdev_cleanup);
906 
907 static u8 wilc_get_available_idx(struct wilc *wl)
908 {
909 	int idx = 0;
910 	struct wilc_vif *vif;
911 	int srcu_idx;
912 
913 	srcu_idx = srcu_read_lock(&wl->srcu);
914 	list_for_each_entry_rcu(vif, &wl->vif_list, list) {
915 		if (vif->idx == 0)
916 			idx = 1;
917 		else
918 			idx = 0;
919 	}
920 	srcu_read_unlock(&wl->srcu, srcu_idx);
921 	return idx;
922 }
923 
924 struct wilc_vif *wilc_netdev_ifc_init(struct wilc *wl, const char *name,
925 				      int vif_type, enum nl80211_iftype type,
926 				      bool rtnl_locked)
927 {
928 	struct net_device *ndev;
929 	struct wilc_vif *vif;
930 	int ret;
931 
932 	ndev = alloc_etherdev(sizeof(*vif));
933 	if (!ndev)
934 		return ERR_PTR(-ENOMEM);
935 
936 	vif = netdev_priv(ndev);
937 	ndev->ieee80211_ptr = &vif->priv.wdev;
938 	strcpy(ndev->name, name);
939 	vif->wilc = wl;
940 	vif->ndev = ndev;
941 	ndev->ml_priv = vif;
942 
943 	ndev->netdev_ops = &wilc_netdev_ops;
944 
945 	SET_NETDEV_DEV(ndev, wiphy_dev(wl->wiphy));
946 
947 	vif->priv.wdev.wiphy = wl->wiphy;
948 	vif->priv.wdev.netdev = ndev;
949 	vif->priv.wdev.iftype = type;
950 	vif->priv.dev = ndev;
951 
952 	if (rtnl_locked)
953 		ret = cfg80211_register_netdevice(ndev);
954 	else
955 		ret = register_netdev(ndev);
956 
957 	if (ret) {
958 		free_netdev(ndev);
959 		return ERR_PTR(-EFAULT);
960 	}
961 
962 	ndev->needs_free_netdev = true;
963 	vif->iftype = vif_type;
964 	vif->idx = wilc_get_available_idx(wl);
965 	vif->mac_opened = 0;
966 	mutex_lock(&wl->vif_mutex);
967 	list_add_tail_rcu(&vif->list, &wl->vif_list);
968 	wl->vif_num += 1;
969 	mutex_unlock(&wl->vif_mutex);
970 	synchronize_srcu(&wl->srcu);
971 
972 	return vif;
973 }
974 
975 MODULE_LICENSE("GPL");
976 MODULE_FIRMWARE(WILC1000_FW(WILC1000_API_VER));
977