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