1 #include "wilc_wfi_cfgoperations.h"
2 #include "wilc_wlan_if.h"
3 #include "wilc_wlan.h"
4
5 #include <linux/slab.h>
6 #include <linux/sched.h>
7 #include <linux/delay.h>
8 #include <linux/workqueue.h>
9 #include <linux/interrupt.h>
10 #include <linux/irq.h>
11 #include <linux/gpio.h>
12
13 #include <linux/kthread.h>
14 #include <linux/firmware.h>
15
16 #include <linux/init.h>
17 #include <linux/netdevice.h>
18 #include <linux/inetdevice.h>
19 #include <linux/etherdevice.h>
20 #include <linux/module.h>
21 #include <linux/kernel.h>
22 #include <linux/skbuff.h>
23 #include <linux/mutex.h>
24 #include <linux/completion.h>
25
26 static int dev_state_ev_handler(struct notifier_block *this,
27 unsigned long event, void *ptr);
28
29 static struct notifier_block g_dev_notifier = {
30 .notifier_call = dev_state_ev_handler
31 };
32
33 static int wlan_deinit_locks(struct net_device *dev);
34 static void wlan_deinitialize_threads(struct net_device *dev);
35
36 static void linux_wlan_tx_complete(void *priv, int status);
37 static int mac_init_fn(struct net_device *ndev);
38 static struct net_device_stats *mac_stats(struct net_device *dev);
39 static int mac_ioctl(struct net_device *ndev, struct ifreq *req, int cmd);
40 static int wilc_mac_open(struct net_device *ndev);
41 static int wilc_mac_close(struct net_device *ndev);
42 static void wilc_set_multicast_list(struct net_device *dev);
43
44 bool wilc_enable_ps = true;
45
46 static const struct net_device_ops wilc_netdev_ops = {
47 .ndo_init = mac_init_fn,
48 .ndo_open = wilc_mac_open,
49 .ndo_stop = wilc_mac_close,
50 .ndo_start_xmit = wilc_mac_xmit,
51 .ndo_do_ioctl = mac_ioctl,
52 .ndo_get_stats = mac_stats,
53 .ndo_set_rx_mode = wilc_set_multicast_list,
54
55 };
56
dev_state_ev_handler(struct notifier_block * this,unsigned long event,void * ptr)57 static int dev_state_ev_handler(struct notifier_block *this,
58 unsigned long event, void *ptr)
59 {
60 struct in_ifaddr *dev_iface = ptr;
61 struct wilc_priv *priv;
62 struct host_if_drv *hif_drv;
63 struct net_device *dev;
64 u8 *ip_addr_buf;
65 struct wilc_vif *vif;
66 u8 null_ip[4] = {0};
67 char wlan_dev_name[5] = "wlan0";
68
69 if (!dev_iface || !dev_iface->ifa_dev || !dev_iface->ifa_dev->dev)
70 return NOTIFY_DONE;
71
72 if (memcmp(dev_iface->ifa_label, "wlan0", 5) &&
73 memcmp(dev_iface->ifa_label, "p2p0", 4))
74 return NOTIFY_DONE;
75
76 dev = (struct net_device *)dev_iface->ifa_dev->dev;
77 if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
78 return NOTIFY_DONE;
79
80 priv = wiphy_priv(dev->ieee80211_ptr->wiphy);
81 if (!priv)
82 return NOTIFY_DONE;
83
84 hif_drv = (struct host_if_drv *)priv->hif_drv;
85 vif = netdev_priv(dev);
86 if (!vif || !hif_drv)
87 return NOTIFY_DONE;
88
89 switch (event) {
90 case NETDEV_UP:
91 if (vif->iftype == STATION_MODE || vif->iftype == CLIENT_MODE) {
92 hif_drv->IFC_UP = 1;
93 wilc_optaining_ip = false;
94 del_timer(&wilc_during_ip_timer);
95 }
96
97 if (wilc_enable_ps)
98 wilc_set_power_mgmt(vif, 1, 0);
99
100 netdev_dbg(dev, "[%s] Up IP\n", dev_iface->ifa_label);
101
102 ip_addr_buf = (char *)&dev_iface->ifa_address;
103 netdev_dbg(dev, "IP add=%d:%d:%d:%d\n",
104 ip_addr_buf[0], ip_addr_buf[1],
105 ip_addr_buf[2], ip_addr_buf[3]);
106 wilc_setup_ipaddress(vif, ip_addr_buf, vif->idx);
107
108 break;
109
110 case NETDEV_DOWN:
111 if (vif->iftype == STATION_MODE || vif->iftype == CLIENT_MODE) {
112 hif_drv->IFC_UP = 0;
113 wilc_optaining_ip = false;
114 }
115
116 if (memcmp(dev_iface->ifa_label, wlan_dev_name, 5) == 0)
117 wilc_set_power_mgmt(vif, 0, 0);
118
119 wilc_resolve_disconnect_aberration(vif);
120
121 netdev_dbg(dev, "[%s] Down IP\n", dev_iface->ifa_label);
122
123 ip_addr_buf = null_ip;
124 netdev_dbg(dev, "IP add=%d:%d:%d:%d\n",
125 ip_addr_buf[0], ip_addr_buf[1],
126 ip_addr_buf[2], ip_addr_buf[3]);
127
128 wilc_setup_ipaddress(vif, ip_addr_buf, vif->idx);
129
130 break;
131
132 default:
133 break;
134 }
135
136 return NOTIFY_DONE;
137 }
138
isr_uh_routine(int irq,void * user_data)139 static irqreturn_t isr_uh_routine(int irq, void *user_data)
140 {
141 struct wilc_vif *vif;
142 struct wilc *wilc;
143 struct net_device *dev = user_data;
144
145 vif = netdev_priv(dev);
146 wilc = vif->wilc;
147
148 if (wilc->close) {
149 netdev_err(dev, "Can't handle UH interrupt\n");
150 return IRQ_HANDLED;
151 }
152 return IRQ_WAKE_THREAD;
153 }
154
isr_bh_routine(int irq,void * userdata)155 static irqreturn_t isr_bh_routine(int irq, void *userdata)
156 {
157 struct wilc_vif *vif;
158 struct wilc *wilc;
159 struct net_device *dev = userdata;
160
161 vif = netdev_priv(userdata);
162 wilc = vif->wilc;
163
164 if (wilc->close) {
165 netdev_err(dev, "Can't handle BH interrupt\n");
166 return IRQ_HANDLED;
167 }
168
169 wilc_handle_isr(wilc);
170
171 return IRQ_HANDLED;
172 }
173
init_irq(struct net_device * dev)174 static int init_irq(struct net_device *dev)
175 {
176 int ret = 0;
177 struct wilc_vif *vif;
178 struct wilc *wl;
179
180 vif = netdev_priv(dev);
181 wl = vif->wilc;
182
183 if ((gpio_request(wl->gpio, "WILC_INTR") == 0) &&
184 (gpio_direction_input(wl->gpio) == 0)) {
185 wl->dev_irq_num = gpio_to_irq(wl->gpio);
186 } else {
187 ret = -1;
188 netdev_err(dev, "could not obtain gpio for WILC_INTR\n");
189 }
190
191 if (ret != -1 && request_threaded_irq(wl->dev_irq_num,
192 isr_uh_routine,
193 isr_bh_routine,
194 IRQF_TRIGGER_LOW | IRQF_ONESHOT,
195 "WILC_IRQ", dev) < 0) {
196 netdev_err(dev, "Failed to request IRQ GPIO: %d\n", wl->gpio);
197 gpio_free(wl->gpio);
198 ret = -1;
199 } else {
200 netdev_dbg(dev,
201 "IRQ request succeeded IRQ-NUM= %d on GPIO: %d\n",
202 wl->dev_irq_num, wl->gpio);
203 }
204
205 return ret;
206 }
207
deinit_irq(struct net_device * dev)208 static void deinit_irq(struct net_device *dev)
209 {
210 struct wilc_vif *vif;
211 struct wilc *wilc;
212
213 vif = netdev_priv(dev);
214 wilc = vif->wilc;
215
216 /* Deinitialize IRQ */
217 if (wilc->dev_irq_num) {
218 free_irq(wilc->dev_irq_num, wilc);
219 gpio_free(wilc->gpio);
220 }
221 }
222
wilc_mac_indicate(struct wilc * wilc,int flag)223 void wilc_mac_indicate(struct wilc *wilc, int flag)
224 {
225 int status;
226
227 if (flag == WILC_MAC_INDICATE_STATUS) {
228 wilc_wlan_cfg_get_val(WID_STATUS,
229 (unsigned char *)&status, 4);
230 if (wilc->mac_status == WILC_MAC_STATUS_INIT) {
231 wilc->mac_status = status;
232 complete(&wilc->sync_event);
233 } else {
234 wilc->mac_status = status;
235 }
236 }
237 }
238
get_if_handler(struct wilc * wilc,u8 * mac_header)239 static struct net_device *get_if_handler(struct wilc *wilc, u8 *mac_header)
240 {
241 u8 *bssid, *bssid1;
242 int i = 0;
243
244 bssid = mac_header + 10;
245 bssid1 = mac_header + 4;
246
247 for (i = 0; i < wilc->vif_num; i++) {
248 if (wilc->vif[i]->mode == STATION_MODE)
249 if (ether_addr_equal_unaligned(bssid,
250 wilc->vif[i]->bssid))
251 return wilc->vif[i]->ndev;
252 if (wilc->vif[i]->mode == AP_MODE)
253 if (ether_addr_equal_unaligned(bssid1,
254 wilc->vif[i]->bssid))
255 return wilc->vif[i]->ndev;
256 }
257
258 return NULL;
259 }
260
wilc_wlan_set_bssid(struct net_device * wilc_netdev,u8 * bssid,u8 mode)261 int wilc_wlan_set_bssid(struct net_device *wilc_netdev, u8 *bssid, u8 mode)
262 {
263 struct wilc_vif *vif = netdev_priv(wilc_netdev);
264
265 memcpy(vif->bssid, bssid, 6);
266 vif->mode = mode;
267
268 return 0;
269 }
270
wilc_wlan_get_num_conn_ifcs(struct wilc * wilc)271 int wilc_wlan_get_num_conn_ifcs(struct wilc *wilc)
272 {
273 u8 i = 0;
274 u8 null_bssid[6] = {0};
275 u8 ret_val = 0;
276
277 for (i = 0; i < wilc->vif_num; i++)
278 if (memcmp(wilc->vif[i]->bssid, null_bssid, 6))
279 ret_val++;
280
281 return ret_val;
282 }
283
linux_wlan_txq_task(void * vp)284 static int linux_wlan_txq_task(void *vp)
285 {
286 int ret;
287 u32 txq_count;
288 struct wilc_vif *vif;
289 struct wilc *wl;
290 struct net_device *dev = vp;
291
292 vif = netdev_priv(dev);
293 wl = vif->wilc;
294
295 complete(&wl->txq_thread_started);
296 while (1) {
297 wait_for_completion(&wl->txq_event);
298
299 if (wl->close) {
300 complete(&wl->txq_thread_started);
301
302 while (!kthread_should_stop())
303 schedule();
304 break;
305 }
306 do {
307 ret = wilc_wlan_handle_txq(dev, &txq_count);
308 if (txq_count < FLOW_CONTROL_LOWER_THRESHOLD) {
309 if (netif_queue_stopped(wl->vif[0]->ndev))
310 netif_wake_queue(wl->vif[0]->ndev);
311 if (netif_queue_stopped(wl->vif[1]->ndev))
312 netif_wake_queue(wl->vif[1]->ndev);
313 }
314 } while (ret == WILC_TX_ERR_NO_BUF && !wl->close);
315 }
316 return 0;
317 }
318
wilc_wlan_get_firmware(struct net_device * dev)319 int wilc_wlan_get_firmware(struct net_device *dev)
320 {
321 struct wilc_vif *vif;
322 struct wilc *wilc;
323 int chip_id, ret = 0;
324 const struct firmware *wilc_firmware;
325 char *firmware;
326
327 vif = netdev_priv(dev);
328 wilc = vif->wilc;
329
330 chip_id = wilc_get_chipid(wilc, false);
331
332 if (chip_id < 0x1003a0)
333 firmware = FIRMWARE_1002;
334 else
335 firmware = FIRMWARE_1003;
336
337 netdev_info(dev, "loading firmware %s\n", firmware);
338
339 if (!(&vif->ndev->dev))
340 goto _fail_;
341
342 if (request_firmware(&wilc_firmware, firmware, wilc->dev) != 0) {
343 netdev_err(dev, "%s - firmware not available\n", firmware);
344 ret = -1;
345 goto _fail_;
346 }
347 wilc->firmware = wilc_firmware;
348
349 _fail_:
350
351 return ret;
352 }
353
linux_wlan_start_firmware(struct net_device * dev)354 static int linux_wlan_start_firmware(struct net_device *dev)
355 {
356 struct wilc_vif *vif;
357 struct wilc *wilc;
358 int ret = 0;
359
360 vif = netdev_priv(dev);
361 wilc = vif->wilc;
362
363 ret = wilc_wlan_start(wilc);
364 if (ret < 0)
365 return ret;
366
367 if (!wait_for_completion_timeout(&wilc->sync_event,
368 msecs_to_jiffies(5000)))
369 return -ETIME;
370
371 return 0;
372 }
373
wilc1000_firmware_download(struct net_device * dev)374 static int wilc1000_firmware_download(struct net_device *dev)
375 {
376 struct wilc_vif *vif;
377 struct wilc *wilc;
378 int ret = 0;
379
380 vif = netdev_priv(dev);
381 wilc = vif->wilc;
382
383 if (!wilc->firmware) {
384 netdev_err(dev, "Firmware buffer is NULL\n");
385 return -ENOBUFS;
386 }
387
388 ret = wilc_wlan_firmware_download(wilc, wilc->firmware->data,
389 wilc->firmware->size);
390 if (ret < 0)
391 return ret;
392
393 release_firmware(wilc->firmware);
394 wilc->firmware = NULL;
395
396 netdev_dbg(dev, "Download Succeeded\n");
397
398 return 0;
399 }
400
linux_wlan_init_test_config(struct net_device * dev,struct wilc_vif * vif)401 static int linux_wlan_init_test_config(struct net_device *dev,
402 struct wilc_vif *vif)
403 {
404 unsigned char c_val[64];
405 struct wilc *wilc = vif->wilc;
406 struct wilc_priv *priv;
407 struct host_if_drv *hif_drv;
408
409 netdev_dbg(dev, "Start configuring Firmware\n");
410 priv = wiphy_priv(dev->ieee80211_ptr->wiphy);
411 hif_drv = (struct host_if_drv *)priv->hif_drv;
412 netdev_dbg(dev, "Host = %p\n", hif_drv);
413 wilc_get_chipid(wilc, false);
414
415 *(int *)c_val = 1;
416
417 if (!wilc_wlan_cfg_set(vif, 1, WID_SET_DRV_HANDLER, c_val, 4, 0, 0))
418 goto _fail_;
419
420 c_val[0] = 0;
421 if (!wilc_wlan_cfg_set(vif, 0, WID_PC_TEST_MODE, c_val, 1, 0, 0))
422 goto _fail_;
423
424 c_val[0] = INFRASTRUCTURE;
425 if (!wilc_wlan_cfg_set(vif, 0, WID_BSS_TYPE, c_val, 1, 0, 0))
426 goto _fail_;
427
428 c_val[0] = RATE_AUTO;
429 if (!wilc_wlan_cfg_set(vif, 0, WID_CURRENT_TX_RATE, c_val, 1, 0, 0))
430 goto _fail_;
431
432 c_val[0] = G_MIXED_11B_2_MODE;
433 if (!wilc_wlan_cfg_set(vif, 0, WID_11G_OPERATING_MODE, c_val, 1, 0,
434 0))
435 goto _fail_;
436
437 c_val[0] = 1;
438 if (!wilc_wlan_cfg_set(vif, 0, WID_CURRENT_CHANNEL, c_val, 1, 0, 0))
439 goto _fail_;
440
441 c_val[0] = G_SHORT_PREAMBLE;
442 if (!wilc_wlan_cfg_set(vif, 0, WID_PREAMBLE, c_val, 1, 0, 0))
443 goto _fail_;
444
445 c_val[0] = AUTO_PROT;
446 if (!wilc_wlan_cfg_set(vif, 0, WID_11N_PROT_MECH, c_val, 1, 0, 0))
447 goto _fail_;
448
449 c_val[0] = ACTIVE_SCAN;
450 if (!wilc_wlan_cfg_set(vif, 0, WID_SCAN_TYPE, c_val, 1, 0, 0))
451 goto _fail_;
452
453 c_val[0] = SITE_SURVEY_OFF;
454 if (!wilc_wlan_cfg_set(vif, 0, WID_SITE_SURVEY, c_val, 1, 0, 0))
455 goto _fail_;
456
457 *((int *)c_val) = 0xffff;
458 if (!wilc_wlan_cfg_set(vif, 0, WID_RTS_THRESHOLD, c_val, 2, 0, 0))
459 goto _fail_;
460
461 *((int *)c_val) = 2346;
462 if (!wilc_wlan_cfg_set(vif, 0, WID_FRAG_THRESHOLD, c_val, 2, 0, 0))
463 goto _fail_;
464
465 c_val[0] = 0;
466 if (!wilc_wlan_cfg_set(vif, 0, WID_BCAST_SSID, c_val, 1, 0, 0))
467 goto _fail_;
468
469 c_val[0] = 1;
470 if (!wilc_wlan_cfg_set(vif, 0, WID_QOS_ENABLE, c_val, 1, 0, 0))
471 goto _fail_;
472
473 c_val[0] = NO_POWERSAVE;
474 if (!wilc_wlan_cfg_set(vif, 0, WID_POWER_MANAGEMENT, c_val, 1, 0, 0))
475 goto _fail_;
476
477 c_val[0] = NO_SECURITY; /* NO_ENCRYPT, 0x79 */
478 if (!wilc_wlan_cfg_set(vif, 0, WID_11I_MODE, c_val, 1, 0, 0))
479 goto _fail_;
480
481 c_val[0] = OPEN_SYSTEM;
482 if (!wilc_wlan_cfg_set(vif, 0, WID_AUTH_TYPE, c_val, 1, 0, 0))
483 goto _fail_;
484
485 strcpy(c_val, "123456790abcdef1234567890");
486 if (!wilc_wlan_cfg_set(vif, 0, WID_WEP_KEY_VALUE, c_val,
487 (strlen(c_val) + 1), 0, 0))
488 goto _fail_;
489
490 strcpy(c_val, "12345678");
491 if (!wilc_wlan_cfg_set(vif, 0, WID_11I_PSK, c_val, (strlen(c_val)), 0,
492 0))
493 goto _fail_;
494
495 strcpy(c_val, "password");
496 if (!wilc_wlan_cfg_set(vif, 0, WID_1X_KEY, c_val, (strlen(c_val) + 1),
497 0, 0))
498 goto _fail_;
499
500 c_val[0] = 192;
501 c_val[1] = 168;
502 c_val[2] = 1;
503 c_val[3] = 112;
504 if (!wilc_wlan_cfg_set(vif, 0, WID_1X_SERV_ADDR, c_val, 4, 0, 0))
505 goto _fail_;
506
507 c_val[0] = 3;
508 if (!wilc_wlan_cfg_set(vif, 0, WID_LISTEN_INTERVAL, c_val, 1, 0, 0))
509 goto _fail_;
510
511 c_val[0] = 3;
512 if (!wilc_wlan_cfg_set(vif, 0, WID_DTIM_PERIOD, c_val, 1, 0, 0))
513 goto _fail_;
514
515 c_val[0] = NORMAL_ACK;
516 if (!wilc_wlan_cfg_set(vif, 0, WID_ACK_POLICY, c_val, 1, 0, 0))
517 goto _fail_;
518
519 c_val[0] = 0;
520 if (!wilc_wlan_cfg_set(vif, 0, WID_USER_CONTROL_ON_TX_POWER, c_val, 1,
521 0, 0))
522 goto _fail_;
523
524 c_val[0] = 48;
525 if (!wilc_wlan_cfg_set(vif, 0, WID_TX_POWER_LEVEL_11A, c_val, 1, 0,
526 0))
527 goto _fail_;
528
529 c_val[0] = 28;
530 if (!wilc_wlan_cfg_set(vif, 0, WID_TX_POWER_LEVEL_11B, c_val, 1, 0,
531 0))
532 goto _fail_;
533
534 *((int *)c_val) = 100;
535 if (!wilc_wlan_cfg_set(vif, 0, WID_BEACON_INTERVAL, c_val, 2, 0, 0))
536 goto _fail_;
537
538 c_val[0] = REKEY_DISABLE;
539 if (!wilc_wlan_cfg_set(vif, 0, WID_REKEY_POLICY, c_val, 1, 0, 0))
540 goto _fail_;
541
542 *((int *)c_val) = 84600;
543 if (!wilc_wlan_cfg_set(vif, 0, WID_REKEY_PERIOD, c_val, 4, 0, 0))
544 goto _fail_;
545
546 *((int *)c_val) = 500;
547 if (!wilc_wlan_cfg_set(vif, 0, WID_REKEY_PACKET_COUNT, c_val, 4, 0,
548 0))
549 goto _fail_;
550
551 c_val[0] = 1;
552 if (!wilc_wlan_cfg_set(vif, 0, WID_SHORT_SLOT_ALLOWED, c_val, 1, 0,
553 0))
554 goto _fail_;
555
556 c_val[0] = G_SELF_CTS_PROT;
557 if (!wilc_wlan_cfg_set(vif, 0, WID_11N_ERP_PROT_TYPE, c_val, 1, 0, 0))
558 goto _fail_;
559
560 c_val[0] = 1;
561 if (!wilc_wlan_cfg_set(vif, 0, WID_11N_ENABLE, c_val, 1, 0, 0))
562 goto _fail_;
563
564 c_val[0] = HT_MIXED_MODE;
565 if (!wilc_wlan_cfg_set(vif, 0, WID_11N_OPERATING_MODE, c_val, 1, 0,
566 0))
567 goto _fail_;
568
569 c_val[0] = 1;
570 if (!wilc_wlan_cfg_set(vif, 0, WID_11N_TXOP_PROT_DISABLE, c_val, 1, 0,
571 0))
572 goto _fail_;
573
574 c_val[0] = DETECT_PROTECT_REPORT;
575 if (!wilc_wlan_cfg_set(vif, 0, WID_11N_OBSS_NONHT_DETECTION, c_val, 1,
576 0, 0))
577 goto _fail_;
578
579 c_val[0] = RTS_CTS_NONHT_PROT;
580 if (!wilc_wlan_cfg_set(vif, 0, WID_11N_HT_PROT_TYPE, c_val, 1, 0, 0))
581 goto _fail_;
582
583 c_val[0] = 0;
584 if (!wilc_wlan_cfg_set(vif, 0, WID_11N_RIFS_PROT_ENABLE, c_val, 1, 0,
585 0))
586 goto _fail_;
587
588 c_val[0] = MIMO_MODE;
589 if (!wilc_wlan_cfg_set(vif, 0, WID_11N_SMPS_MODE, c_val, 1, 0, 0))
590 goto _fail_;
591
592 c_val[0] = 7;
593 if (!wilc_wlan_cfg_set(vif, 0, WID_11N_CURRENT_TX_MCS, c_val, 1, 0,
594 0))
595 goto _fail_;
596
597 c_val[0] = 1;
598 if (!wilc_wlan_cfg_set(vif, 0, WID_11N_IMMEDIATE_BA_ENABLED, c_val, 1,
599 1, 1))
600 goto _fail_;
601
602 return 0;
603
604 _fail_:
605 return -1;
606 }
607
wilc1000_wlan_deinit(struct net_device * dev)608 void wilc1000_wlan_deinit(struct net_device *dev)
609 {
610 struct wilc_vif *vif;
611 struct wilc *wl;
612
613 vif = netdev_priv(dev);
614 wl = vif->wilc;
615
616 if (!wl) {
617 netdev_err(dev, "wl is NULL\n");
618 return;
619 }
620
621 if (wl->initialized) {
622 netdev_info(dev, "Deinitializing wilc1000...\n");
623
624 if (!wl->dev_irq_num &&
625 wl->hif_func->disable_interrupt) {
626 mutex_lock(&wl->hif_cs);
627 wl->hif_func->disable_interrupt(wl);
628 mutex_unlock(&wl->hif_cs);
629 }
630 if (&wl->txq_event)
631 complete(&wl->txq_event);
632
633 wlan_deinitialize_threads(dev);
634 deinit_irq(dev);
635
636 wilc_wlan_stop(wl);
637 wilc_wlan_cleanup(dev);
638 wlan_deinit_locks(dev);
639
640 wl->initialized = false;
641
642 netdev_dbg(dev, "wilc1000 deinitialization Done\n");
643 } else {
644 netdev_dbg(dev, "wilc1000 is not initialized\n");
645 }
646 }
647
wlan_init_locks(struct net_device * dev)648 static int wlan_init_locks(struct net_device *dev)
649 {
650 struct wilc_vif *vif;
651 struct wilc *wl;
652
653 vif = netdev_priv(dev);
654 wl = vif->wilc;
655
656 mutex_init(&wl->hif_cs);
657 mutex_init(&wl->rxq_cs);
658
659 spin_lock_init(&wl->txq_spinlock);
660 mutex_init(&wl->txq_add_to_head_cs);
661
662 init_completion(&wl->txq_event);
663
664 init_completion(&wl->cfg_event);
665 init_completion(&wl->sync_event);
666 init_completion(&wl->txq_thread_started);
667
668 return 0;
669 }
670
wlan_deinit_locks(struct net_device * dev)671 static int wlan_deinit_locks(struct net_device *dev)
672 {
673 struct wilc_vif *vif;
674 struct wilc *wilc;
675
676 vif = netdev_priv(dev);
677 wilc = vif->wilc;
678
679 if (&wilc->hif_cs)
680 mutex_destroy(&wilc->hif_cs);
681
682 if (&wilc->rxq_cs)
683 mutex_destroy(&wilc->rxq_cs);
684
685 return 0;
686 }
687
wlan_initialize_threads(struct net_device * dev)688 static int wlan_initialize_threads(struct net_device *dev)
689 {
690 struct wilc_vif *vif;
691 struct wilc *wilc;
692
693 vif = netdev_priv(dev);
694 wilc = vif->wilc;
695
696 wilc->txq_thread = kthread_run(linux_wlan_txq_task, (void *)dev,
697 "K_TXQ_TASK");
698 if (IS_ERR(wilc->txq_thread)) {
699 netdev_err(dev, "couldn't create TXQ thread\n");
700 wilc->close = 0;
701 return PTR_ERR(wilc->txq_thread);
702 }
703 wait_for_completion(&wilc->txq_thread_started);
704
705 return 0;
706 }
707
wlan_deinitialize_threads(struct net_device * dev)708 static void wlan_deinitialize_threads(struct net_device *dev)
709 {
710 struct wilc_vif *vif;
711 struct wilc *wl;
712
713 vif = netdev_priv(dev);
714 wl = vif->wilc;
715
716 wl->close = 1;
717
718 if (&wl->txq_event)
719 complete(&wl->txq_event);
720
721 if (wl->txq_thread) {
722 kthread_stop(wl->txq_thread);
723 wl->txq_thread = NULL;
724 }
725 }
726
wilc1000_wlan_init(struct net_device * dev,struct wilc_vif * vif)727 int wilc1000_wlan_init(struct net_device *dev, struct wilc_vif *vif)
728 {
729 int ret = 0;
730 struct wilc *wl = vif->wilc;
731
732 if (!wl->initialized) {
733 wl->mac_status = WILC_MAC_STATUS_INIT;
734 wl->close = 0;
735
736 wlan_init_locks(dev);
737
738 ret = wilc_wlan_init(dev);
739 if (ret < 0) {
740 ret = -EIO;
741 goto _fail_locks_;
742 }
743
744 if (wl->gpio >= 0 && init_irq(dev)) {
745 ret = -EIO;
746 goto _fail_locks_;
747 }
748
749 ret = wlan_initialize_threads(dev);
750 if (ret < 0) {
751 ret = -EIO;
752 goto _fail_wilc_wlan_;
753 }
754
755 if (!wl->dev_irq_num &&
756 wl->hif_func->enable_interrupt &&
757 wl->hif_func->enable_interrupt(wl)) {
758 ret = -EIO;
759 goto _fail_irq_init_;
760 }
761
762 if (wilc_wlan_get_firmware(dev)) {
763 ret = -EIO;
764 goto _fail_irq_enable_;
765 }
766
767 ret = wilc1000_firmware_download(dev);
768 if (ret < 0) {
769 ret = -EIO;
770 goto _fail_irq_enable_;
771 }
772
773 ret = linux_wlan_start_firmware(dev);
774 if (ret < 0) {
775 ret = -EIO;
776 goto _fail_irq_enable_;
777 }
778
779 if (wilc_wlan_cfg_get(vif, 1, WID_FIRMWARE_VERSION, 1, 0)) {
780 int size;
781 char firmware_ver[20];
782
783 size = wilc_wlan_cfg_get_val(WID_FIRMWARE_VERSION,
784 firmware_ver,
785 sizeof(firmware_ver));
786 firmware_ver[size] = '\0';
787 netdev_dbg(dev, "Firmware Ver = %s\n", firmware_ver);
788 }
789 ret = linux_wlan_init_test_config(dev, vif);
790
791 if (ret < 0) {
792 netdev_err(dev, "Failed to configure firmware\n");
793 ret = -EIO;
794 goto _fail_fw_start_;
795 }
796
797 wl->initialized = true;
798 return 0;
799
800 _fail_fw_start_:
801 wilc_wlan_stop(wl);
802
803 _fail_irq_enable_:
804 if (!wl->dev_irq_num &&
805 wl->hif_func->disable_interrupt)
806 wl->hif_func->disable_interrupt(wl);
807 _fail_irq_init_:
808 if (wl->dev_irq_num)
809 deinit_irq(dev);
810
811 wlan_deinitialize_threads(dev);
812 _fail_wilc_wlan_:
813 wilc_wlan_cleanup(dev);
814 _fail_locks_:
815 wlan_deinit_locks(dev);
816 netdev_err(dev, "WLAN initialization FAILED\n");
817 } else {
818 netdev_dbg(dev, "wilc1000 already initialized\n");
819 }
820 return ret;
821 }
822
mac_init_fn(struct net_device * ndev)823 static int mac_init_fn(struct net_device *ndev)
824 {
825 netif_start_queue(ndev);
826 netif_stop_queue(ndev);
827
828 return 0;
829 }
830
wilc_mac_open(struct net_device * ndev)831 static int wilc_mac_open(struct net_device *ndev)
832 {
833 struct wilc_vif *vif;
834
835 unsigned char mac_add[ETH_ALEN] = {0};
836 int ret = 0;
837 int i = 0;
838 struct wilc *wl;
839
840 vif = netdev_priv(ndev);
841 wl = vif->wilc;
842
843 if (!wl || !wl->dev) {
844 netdev_err(ndev, "device not ready\n");
845 return -ENODEV;
846 }
847
848 netdev_dbg(ndev, "MAC OPEN[%p]\n", ndev);
849
850 ret = wilc_init_host_int(ndev);
851 if (ret < 0)
852 return ret;
853
854 ret = wilc1000_wlan_init(ndev, vif);
855 if (ret < 0) {
856 wilc_deinit_host_int(ndev);
857 return ret;
858 }
859
860 for (i = 0; i < wl->vif_num; i++) {
861 if (ndev == wl->vif[i]->ndev) {
862 wilc_set_wfi_drv_handler(vif, wilc_get_vif_idx(vif),
863 vif->iftype, vif->ifc_id);
864 wilc_set_operation_mode(vif, vif->iftype);
865 break;
866 }
867 }
868 wilc_get_mac_address(vif, mac_add);
869 netdev_dbg(ndev, "Mac address: %pM\n", mac_add);
870 memcpy(wl->vif[i]->src_addr, mac_add, ETH_ALEN);
871
872 memcpy(ndev->dev_addr, wl->vif[i]->src_addr, ETH_ALEN);
873
874 if (!is_valid_ether_addr(ndev->dev_addr)) {
875 netdev_err(ndev, "Wrong MAC address\n");
876 wilc_deinit_host_int(ndev);
877 wilc1000_wlan_deinit(ndev);
878 return -EINVAL;
879 }
880
881 wilc_mgmt_frame_register(vif->ndev->ieee80211_ptr->wiphy,
882 vif->ndev->ieee80211_ptr,
883 vif->frame_reg[0].type,
884 vif->frame_reg[0].reg);
885 wilc_mgmt_frame_register(vif->ndev->ieee80211_ptr->wiphy,
886 vif->ndev->ieee80211_ptr,
887 vif->frame_reg[1].type,
888 vif->frame_reg[1].reg);
889 netif_wake_queue(ndev);
890 wl->open_ifcs++;
891 vif->mac_opened = 1;
892 return 0;
893 }
894
mac_stats(struct net_device * dev)895 static struct net_device_stats *mac_stats(struct net_device *dev)
896 {
897 struct wilc_vif *vif = netdev_priv(dev);
898
899 return &vif->netstats;
900 }
901
wilc_set_multicast_list(struct net_device * dev)902 static void wilc_set_multicast_list(struct net_device *dev)
903 {
904 struct netdev_hw_addr *ha;
905 struct wilc_vif *vif;
906 int i = 0;
907
908 vif = netdev_priv(dev);
909
910 if (dev->flags & IFF_PROMISC)
911 return;
912
913 if ((dev->flags & IFF_ALLMULTI) ||
914 (dev->mc.count) > WILC_MULTICAST_TABLE_SIZE) {
915 wilc_setup_multicast_filter(vif, false, 0);
916 return;
917 }
918
919 if ((dev->mc.count) == 0) {
920 wilc_setup_multicast_filter(vif, true, 0);
921 return;
922 }
923
924 netdev_for_each_mc_addr(ha, dev) {
925 memcpy(wilc_multicast_mac_addr_list[i], ha->addr, ETH_ALEN);
926 netdev_dbg(dev, "Entry[%d]: %x:%x:%x:%x:%x:%x\n", i,
927 wilc_multicast_mac_addr_list[i][0],
928 wilc_multicast_mac_addr_list[i][1],
929 wilc_multicast_mac_addr_list[i][2],
930 wilc_multicast_mac_addr_list[i][3],
931 wilc_multicast_mac_addr_list[i][4],
932 wilc_multicast_mac_addr_list[i][5]);
933 i++;
934 }
935
936 wilc_setup_multicast_filter(vif, true, (dev->mc.count));
937 }
938
linux_wlan_tx_complete(void * priv,int status)939 static void linux_wlan_tx_complete(void *priv, int status)
940 {
941 struct tx_complete_data *pv_data = priv;
942
943 dev_kfree_skb(pv_data->skb);
944 kfree(pv_data);
945 }
946
wilc_mac_xmit(struct sk_buff * skb,struct net_device * ndev)947 int wilc_mac_xmit(struct sk_buff *skb, struct net_device *ndev)
948 {
949 struct wilc_vif *vif;
950 struct tx_complete_data *tx_data = NULL;
951 int queue_count;
952 char *udp_buf;
953 struct iphdr *ih;
954 struct ethhdr *eth_h;
955 struct wilc *wilc;
956
957 vif = netdev_priv(ndev);
958 wilc = vif->wilc;
959
960 if (skb->dev != ndev) {
961 netdev_err(ndev, "Packet not destined to this device\n");
962 return 0;
963 }
964
965 tx_data = kmalloc(sizeof(*tx_data), GFP_ATOMIC);
966 if (!tx_data) {
967 dev_kfree_skb(skb);
968 netif_wake_queue(ndev);
969 return 0;
970 }
971
972 tx_data->buff = skb->data;
973 tx_data->size = skb->len;
974 tx_data->skb = skb;
975
976 eth_h = (struct ethhdr *)(skb->data);
977 if (eth_h->h_proto == cpu_to_be16(0x8e88))
978 netdev_dbg(ndev, "EAPOL transmitted\n");
979
980 ih = (struct iphdr *)(skb->data + sizeof(struct ethhdr));
981
982 udp_buf = (char *)ih + sizeof(struct iphdr);
983 if ((udp_buf[1] == 68 && udp_buf[3] == 67) ||
984 (udp_buf[1] == 67 && udp_buf[3] == 68))
985 netdev_dbg(ndev, "DHCP Message transmitted, type:%x %x %x\n",
986 udp_buf[248], udp_buf[249], udp_buf[250]);
987
988 vif->netstats.tx_packets++;
989 vif->netstats.tx_bytes += tx_data->size;
990 tx_data->bssid = wilc->vif[vif->idx]->bssid;
991 queue_count = wilc_wlan_txq_add_net_pkt(ndev, (void *)tx_data,
992 tx_data->buff, tx_data->size,
993 linux_wlan_tx_complete);
994
995 if (queue_count > FLOW_CONTROL_UPPER_THRESHOLD) {
996 netif_stop_queue(wilc->vif[0]->ndev);
997 netif_stop_queue(wilc->vif[1]->ndev);
998 }
999
1000 return 0;
1001 }
1002
wilc_mac_close(struct net_device * ndev)1003 static int wilc_mac_close(struct net_device *ndev)
1004 {
1005 struct wilc_priv *priv;
1006 struct wilc_vif *vif;
1007 struct host_if_drv *hif_drv;
1008 struct wilc *wl;
1009
1010 vif = netdev_priv(ndev);
1011
1012 if (!vif || !vif->ndev || !vif->ndev->ieee80211_ptr ||
1013 !vif->ndev->ieee80211_ptr->wiphy)
1014 return 0;
1015
1016 priv = wiphy_priv(vif->ndev->ieee80211_ptr->wiphy);
1017 wl = vif->wilc;
1018
1019 if (!priv)
1020 return 0;
1021
1022 hif_drv = (struct host_if_drv *)priv->hif_drv;
1023
1024 netdev_dbg(ndev, "Mac close\n");
1025
1026 if (!wl)
1027 return 0;
1028
1029 if (!hif_drv)
1030 return 0;
1031
1032 if ((wl->open_ifcs) > 0)
1033 wl->open_ifcs--;
1034 else
1035 return 0;
1036
1037 if (vif->ndev) {
1038 netif_stop_queue(vif->ndev);
1039
1040 wilc_deinit_host_int(vif->ndev);
1041 }
1042
1043 if (wl->open_ifcs == 0) {
1044 netdev_dbg(ndev, "Deinitializing wilc1000\n");
1045 wl->close = 1;
1046 wilc1000_wlan_deinit(ndev);
1047 WILC_WFI_deinit_mon_interface();
1048 }
1049
1050 vif->mac_opened = 0;
1051
1052 return 0;
1053 }
1054
mac_ioctl(struct net_device * ndev,struct ifreq * req,int cmd)1055 static int mac_ioctl(struct net_device *ndev, struct ifreq *req, int cmd)
1056 {
1057 u8 *buff = NULL;
1058 s8 rssi;
1059 u32 size = 0;
1060 struct wilc_vif *vif;
1061 s32 ret = 0;
1062 struct wilc *wilc;
1063
1064 vif = netdev_priv(ndev);
1065 wilc = vif->wilc;
1066
1067 if (!wilc->initialized)
1068 return 0;
1069
1070 switch (cmd) {
1071 case SIOCSIWPRIV:
1072 {
1073 struct iwreq *wrq = (struct iwreq *)req;
1074
1075 size = wrq->u.data.length;
1076
1077 if (size && wrq->u.data.pointer) {
1078 buff = memdup_user(wrq->u.data.pointer,
1079 wrq->u.data.length);
1080 if (IS_ERR(buff))
1081 return PTR_ERR(buff);
1082
1083 if (strncasecmp(buff, "RSSI", size) == 0) {
1084 ret = wilc_get_rssi(vif, &rssi);
1085 netdev_info(ndev, "RSSI :%d\n", rssi);
1086
1087 rssi += 5;
1088
1089 snprintf(buff, size, "rssi %d", rssi);
1090
1091 if (copy_to_user(wrq->u.data.pointer, buff, size)) {
1092 netdev_err(ndev, "failed to copy\n");
1093 ret = -EFAULT;
1094 goto done;
1095 }
1096 }
1097 }
1098 }
1099 break;
1100
1101 default:
1102 {
1103 netdev_info(ndev, "Command - %d - has been received\n", cmd);
1104 ret = -EOPNOTSUPP;
1105 goto done;
1106 }
1107 }
1108
1109 done:
1110
1111 kfree(buff);
1112
1113 return ret;
1114 }
1115
wilc_frmw_to_linux(struct wilc * wilc,u8 * buff,u32 size,u32 pkt_offset)1116 void wilc_frmw_to_linux(struct wilc *wilc, u8 *buff, u32 size, u32 pkt_offset)
1117 {
1118 unsigned int frame_len = 0;
1119 int stats;
1120 unsigned char *buff_to_send = NULL;
1121 struct sk_buff *skb;
1122 struct net_device *wilc_netdev;
1123 struct wilc_vif *vif;
1124
1125 if (!wilc)
1126 return;
1127
1128 wilc_netdev = get_if_handler(wilc, buff);
1129 if (!wilc_netdev)
1130 return;
1131
1132 buff += pkt_offset;
1133 vif = netdev_priv(wilc_netdev);
1134
1135 if (size > 0) {
1136 frame_len = size;
1137 buff_to_send = buff;
1138
1139 skb = dev_alloc_skb(frame_len);
1140 if (!skb)
1141 return;
1142
1143 skb->dev = wilc_netdev;
1144
1145 skb_put_data(skb, buff_to_send, frame_len);
1146
1147 skb->protocol = eth_type_trans(skb, wilc_netdev);
1148 vif->netstats.rx_packets++;
1149 vif->netstats.rx_bytes += frame_len;
1150 skb->ip_summed = CHECKSUM_UNNECESSARY;
1151 stats = netif_rx(skb);
1152 netdev_dbg(wilc_netdev, "netif_rx ret value is: %d\n", stats);
1153 }
1154 }
1155
WILC_WFI_mgmt_rx(struct wilc * wilc,u8 * buff,u32 size)1156 void WILC_WFI_mgmt_rx(struct wilc *wilc, u8 *buff, u32 size)
1157 {
1158 int i = 0;
1159 struct wilc_vif *vif;
1160
1161 for (i = 0; i < wilc->vif_num; i++) {
1162 vif = netdev_priv(wilc->vif[i]->ndev);
1163 if (vif->monitor_flag) {
1164 WILC_WFI_monitor_rx(buff, size);
1165 return;
1166 }
1167 }
1168
1169 vif = netdev_priv(wilc->vif[1]->ndev);
1170 if ((buff[0] == vif->frame_reg[0].type && vif->frame_reg[0].reg) ||
1171 (buff[0] == vif->frame_reg[1].type && vif->frame_reg[1].reg))
1172 WILC_WFI_p2p_rx(wilc->vif[1]->ndev, buff, size);
1173 }
1174
wilc_netdev_cleanup(struct wilc * wilc)1175 void wilc_netdev_cleanup(struct wilc *wilc)
1176 {
1177 int i;
1178
1179 if (wilc && (wilc->vif[0]->ndev || wilc->vif[1]->ndev))
1180 unregister_inetaddr_notifier(&g_dev_notifier);
1181
1182 if (wilc && wilc->firmware) {
1183 release_firmware(wilc->firmware);
1184 wilc->firmware = NULL;
1185 }
1186
1187 if (wilc && (wilc->vif[0]->ndev || wilc->vif[1]->ndev)) {
1188 for (i = 0; i < NUM_CONCURRENT_IFC; i++)
1189 if (wilc->vif[i]->ndev)
1190 if (wilc->vif[i]->mac_opened)
1191 wilc_mac_close(wilc->vif[i]->ndev);
1192
1193 for (i = 0; i < NUM_CONCURRENT_IFC; i++) {
1194 unregister_netdev(wilc->vif[i]->ndev);
1195 wilc_free_wiphy(wilc->vif[i]->ndev);
1196 free_netdev(wilc->vif[i]->ndev);
1197 }
1198 }
1199
1200 kfree(wilc);
1201 }
1202 EXPORT_SYMBOL_GPL(wilc_netdev_cleanup);
1203
wilc_netdev_init(struct wilc ** wilc,struct device * dev,int io_type,int gpio,const struct wilc_hif_func * ops)1204 int wilc_netdev_init(struct wilc **wilc, struct device *dev, int io_type,
1205 int gpio, const struct wilc_hif_func *ops)
1206 {
1207 int i, ret;
1208 struct wilc_vif *vif;
1209 struct net_device *ndev;
1210 struct wilc *wl;
1211
1212 wl = kzalloc(sizeof(*wl), GFP_KERNEL);
1213 if (!wl)
1214 return -ENOMEM;
1215
1216 *wilc = wl;
1217 wl->io_type = io_type;
1218 wl->gpio = gpio;
1219 wl->hif_func = ops;
1220
1221 register_inetaddr_notifier(&g_dev_notifier);
1222
1223 for (i = 0; i < NUM_CONCURRENT_IFC; i++) {
1224 ndev = alloc_etherdev(sizeof(struct wilc_vif));
1225 if (!ndev)
1226 return -ENOMEM;
1227
1228 vif = netdev_priv(ndev);
1229 memset(vif, 0, sizeof(struct wilc_vif));
1230
1231 if (i == 0) {
1232 strcpy(ndev->name, "wlan%d");
1233 vif->ifc_id = 1;
1234 } else {
1235 strcpy(ndev->name, "p2p%d");
1236 vif->ifc_id = 0;
1237 }
1238 vif->wilc = *wilc;
1239 vif->ndev = ndev;
1240 wl->vif[i] = vif;
1241 wl->vif_num = i + 1;
1242 vif->idx = i;
1243
1244 ndev->netdev_ops = &wilc_netdev_ops;
1245
1246 {
1247 struct wireless_dev *wdev;
1248
1249 wdev = wilc_create_wiphy(ndev, dev);
1250
1251 if (dev)
1252 SET_NETDEV_DEV(ndev, dev);
1253
1254 if (!wdev) {
1255 netdev_err(ndev, "Can't register WILC Wiphy\n");
1256 return -1;
1257 }
1258
1259 vif->ndev->ieee80211_ptr = wdev;
1260 vif->ndev->ml_priv = vif;
1261 wdev->netdev = vif->ndev;
1262 vif->netstats.rx_packets = 0;
1263 vif->netstats.tx_packets = 0;
1264 vif->netstats.rx_bytes = 0;
1265 vif->netstats.tx_bytes = 0;
1266 }
1267
1268 ret = register_netdev(ndev);
1269 if (ret)
1270 return ret;
1271
1272 vif->iftype = STATION_MODE;
1273 vif->mac_opened = 0;
1274 }
1275
1276 return 0;
1277 }
1278 EXPORT_SYMBOL_GPL(wilc_netdev_init);
1279
1280 MODULE_LICENSE("GPL");
1281