1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2021 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 *****************************************************************************/
15 #define _OS_INTFS_C_
16
17 #include <drv_types.h>
18
19 MODULE_LICENSE("GPL");
20 MODULE_DESCRIPTION("Realtek Wireless Lan Driver");
21 MODULE_AUTHOR("Realtek Semiconductor Corp.");
22 MODULE_VERSION(DRIVERVERSION);
23
24
25 int netdev_open(struct net_device *pnetdev);
26 static int netdev_close(struct net_device *pnetdev);
27
28
29 /**
30 * rtw_net_set_mac_address
31 * This callback function is used for the Media Access Control address
32 * of each net_device needs to be changed.
33 *
34 * Arguments:
35 * @pnetdev: net_device pointer.
36 * @addr: new MAC address.
37 *
38 * Return:
39 * ret = 0: Permit to change net_device's MAC address.
40 * ret = -1 (Default): Operation not permitted.
41 *
42 * Auther: Arvin Liu
43 * Date: 2015/05/29
44 */
rtw_net_set_mac_address(struct net_device * pnetdev,void * addr)45 static int rtw_net_set_mac_address(struct net_device *pnetdev, void *addr)
46 {
47 _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
48 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
49 struct sockaddr *sa = (struct sockaddr *)addr;
50 int ret = -1;
51
52 /* only the net_device is in down state to permit modifying mac addr */
53 if ((pnetdev->flags & IFF_UP) == _TRUE) {
54 RTW_INFO(FUNC_ADPT_FMT": The net_device's is not in down state\n"
55 , FUNC_ADPT_ARG(padapter));
56
57 return ret;
58 }
59
60 /* if the net_device is linked, it's not permit to modify mac addr */
61 if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING) ||
62 check_fwstate(pmlmepriv, WIFI_ASOC_STATE) ||
63 check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY)) {
64 RTW_INFO(FUNC_ADPT_FMT": The net_device's is not idle currently\n"
65 , FUNC_ADPT_ARG(padapter));
66
67 return ret;
68 }
69
70 /* check whether the input mac address is valid to permit modifying mac addr */
71 if (rtw_check_invalid_mac_address(sa->sa_data, _FALSE) == _TRUE) {
72 RTW_INFO(FUNC_ADPT_FMT": Invalid Mac Addr for "MAC_FMT"\n"
73 , FUNC_ADPT_ARG(padapter), MAC_ARG(sa->sa_data));
74
75 return ret;
76 }
77
78 _rtw_memcpy(adapter_mac_addr(padapter), sa->sa_data, ETH_ALEN); /* set mac addr to adapter */
79 _rtw_memcpy(pnetdev->dev_addr, sa->sa_data, ETH_ALEN); /* set mac addr to net_device */
80
81 /* Since the net_device is in down state, there is no wrole at this moment.
82 * The new mac address will be set to hw when changing the net_device to up state.
83 */
84
85 RTW_INFO(FUNC_ADPT_FMT": Set Mac Addr to "MAC_FMT" Successfully\n"
86 , FUNC_ADPT_ARG(padapter), MAC_ARG(sa->sa_data));
87
88 ret = 0;
89
90 return ret;
91 }
92
rtw_net_get_stats(struct net_device * pnetdev)93 static struct net_device_stats *rtw_net_get_stats(struct net_device *pnetdev)
94 {
95 _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
96 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
97 struct recv_info *precvinfo = &(padapter->recvinfo);
98
99 padapter->stats.tx_packets = pxmitpriv->tx_pkts;/* pxmitpriv->tx_pkts++; */
100 padapter->stats.rx_packets = precvinfo->rx_pkts;/* precvinfo->rx_pkts++; */
101 padapter->stats.tx_dropped = pxmitpriv->tx_drop;
102 padapter->stats.rx_dropped = precvinfo->rx_drop;
103 padapter->stats.tx_bytes = pxmitpriv->tx_bytes;
104 padapter->stats.rx_bytes = precvinfo->rx_bytes;
105
106 return &padapter->stats;
107 }
108
109 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
110 /*
111 * AC to queue mapping
112 *
113 * AC_VO -> queue 0
114 * AC_VI -> queue 1
115 * AC_BE -> queue 2
116 * AC_BK -> queue 3
117 */
118 static const u16 rtw_1d_to_queue[8] = { 2, 3, 3, 2, 1, 1, 0, 0 };
119
120 /* Given a data frame determine the 802.1p/1d tag to use. */
rtw_classify8021d(struct sk_buff * skb)121 unsigned int rtw_classify8021d(struct sk_buff *skb)
122 {
123 unsigned int dscp;
124
125 /* skb->priority values from 256->263 are magic values to
126 * directly indicate a specific 802.1d priority. This is used
127 * to allow 802.1d priority to be passed directly in from VLAN
128 * tags, etc.
129 */
130 if (skb->priority >= 256 && skb->priority <= 263)
131 return skb->priority - 256;
132
133 switch (skb->protocol) {
134 case htons(ETH_P_IP):
135 dscp = ip_hdr(skb)->tos & 0xfc;
136 break;
137 default:
138 return 0;
139 }
140
141 return dscp >> 5;
142 }
143
144
rtw_select_queue(struct net_device * dev,struct sk_buff * skb,struct net_device * sb_dev,select_queue_fallback_t fallback)145 static u16 rtw_select_queue(struct net_device *dev, struct sk_buff *skb
146 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 13, 0)
147 #if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0)
148 , struct net_device *sb_dev
149 #else
150 , void *accel_priv
151 #endif
152 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)) && (LINUX_VERSION_CODE < KERNEL_VERSION(5, 2, 0))
153 , select_queue_fallback_t fallback
154 #endif
155 #endif
156 )
157 {
158 _adapter *padapter = rtw_netdev_priv(dev);
159 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
160
161 skb->priority = rtw_classify8021d(skb);
162
163 if (pmlmepriv->acm_mask != 0)
164 skb->priority = qos_acm(pmlmepriv->acm_mask, skb->priority);
165
166 return rtw_1d_to_queue[skb->priority];
167 }
168 #endif /* (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35)) */
169
rtw_os_recv_select_queue(u8 * msdu,enum rtw_rx_llc_hdl llc_hdl)170 u16 rtw_os_recv_select_queue(u8 *msdu, enum rtw_rx_llc_hdl llc_hdl)
171 {
172 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
173 u32 priority = 0;
174
175 if (llc_hdl == RTW_RX_LLC_REMOVE) {
176 u16 eth_type = RTW_GET_BE16(msdu + SNAP_SIZE);
177
178 if (eth_type == ETH_P_IP) {
179 struct iphdr *iphdr = (struct iphdr *)(msdu + SNAP_SIZE + 2);
180 unsigned int dscp = iphdr->tos & 0xfc;
181
182 priority = dscp >> 5;
183 }
184 }
185
186 return rtw_1d_to_queue[priority];
187 #else
188 return 0;
189 #endif
190 }
191
is_rtw_ndev(struct net_device * ndev)192 static u8 is_rtw_ndev(struct net_device *ndev)
193 {
194 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29))
195 return ndev->netdev_ops
196 && ndev->netdev_ops->ndo_do_ioctl
197 && ndev->netdev_ops->ndo_do_ioctl == rtw_ioctl;
198 #else
199 return ndev->do_ioctl
200 && ndev->do_ioctl == rtw_ioctl;
201 #endif
202 }
203
204
205 #define _netdev_status_msg(_ndev, state, sts_str) \
206 RTW_INFO(FUNC_NDEV_FMT" state:%lu - %s\n", FUNC_NDEV_ARG(_ndev), state, sts_str);
207
rtw_ndev_notifier_call(struct notifier_block * nb,unsigned long state,void * ptr)208 static int rtw_ndev_notifier_call(struct notifier_block *nb, unsigned long state, void *ptr)
209 {
210 struct net_device *ndev;
211
212 if (ptr == NULL)
213 return NOTIFY_DONE;
214
215 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 11, 0))
216 ndev = netdev_notifier_info_to_dev(ptr);
217 #else
218 ndev = ptr;
219 #endif
220
221 if (ndev == NULL)
222 return NOTIFY_DONE;
223
224 if (!is_rtw_ndev(ndev))
225 return NOTIFY_DONE;
226
227 switch (state) {
228 case NETDEV_CHANGE:
229 _netdev_status_msg(ndev, state, "netdev change");
230 break;
231 case NETDEV_GOING_DOWN:
232 _netdev_status_msg(ndev, state, "netdev going down");
233 break;
234 case NETDEV_DOWN:
235 _netdev_status_msg(ndev, state, "netdev down");
236 break;
237 case NETDEV_UP:
238 _netdev_status_msg(ndev, state, "netdev up");
239 break;
240 case NETDEV_REBOOT:
241 _netdev_status_msg(ndev, state, "netdev reboot");
242 break;
243 case NETDEV_CHANGENAME:
244 rtw_adapter_proc_replace(ndev);
245 _netdev_status_msg(ndev, state, "netdev chang ename");
246 break;
247 case NETDEV_PRE_UP :
248 {
249 _adapter *adapter = rtw_netdev_priv(ndev);
250
251 rtw_pwr_wakeup(adapter);
252 }
253 _netdev_status_msg(ndev, state, "netdev pre up");
254 break;
255 case NETDEV_JOIN:
256 _netdev_status_msg(ndev, state, "netdev join");
257 break;
258 default:
259 _netdev_status_msg(ndev, state, " ");
260 break;
261 }
262
263 return NOTIFY_DONE;
264 }
265
266 static struct notifier_block rtw_ndev_notifier = {
267 .notifier_call = rtw_ndev_notifier_call,
268 };
269
rtw_ndev_notifier_register(void)270 int rtw_ndev_notifier_register(void)
271 {
272 return register_netdevice_notifier(&rtw_ndev_notifier);
273 }
274
rtw_ndev_notifier_unregister(void)275 void rtw_ndev_notifier_unregister(void)
276 {
277 unregister_netdevice_notifier(&rtw_ndev_notifier);
278 }
279
rtw_ndev_init(struct net_device * dev)280 int rtw_ndev_init(struct net_device *dev)
281 {
282 _adapter *adapter = rtw_netdev_priv(dev);
283
284 RTW_PRINT(FUNC_ADPT_FMT" if%d mac_addr="MAC_FMT"\n"
285 , FUNC_ADPT_ARG(adapter), (adapter->iface_id + 1), MAC_ARG(dev->dev_addr));
286 strncpy(adapter->old_ifname, dev->name, IFNAMSIZ);
287 adapter->old_ifname[IFNAMSIZ - 1] = '\0';
288 #ifdef CONFIG_ARCH_CORTINA
289 dev->priv_flags = IFF_DOMAIN_WLAN;
290 #endif
291 rtw_adapter_proc_init(dev);
292
293 #ifdef CONFIG_RTW_NAPI
294 netif_napi_add(dev, &adapter->napi, rtw_recv_napi_poll, RTL_NAPI_WEIGHT);
295 #endif /* CONFIG_RTW_NAPI */
296
297 return 0;
298 }
299
rtw_ndev_uninit(struct net_device * dev)300 void rtw_ndev_uninit(struct net_device *dev)
301 {
302 _adapter *adapter = rtw_netdev_priv(dev);
303
304 RTW_PRINT(FUNC_ADPT_FMT" if%d\n"
305 , FUNC_ADPT_ARG(adapter), (adapter->iface_id + 1));
306 rtw_adapter_proc_deinit(dev);
307
308 #ifdef CONFIG_RTW_NAPI
309 if(adapter->napi_state == NAPI_ENABLE) {
310 napi_disable(&adapter->napi);
311 adapter->napi_state = NAPI_DISABLE;
312 }
313 netif_napi_del(&adapter->napi);
314 #endif /* CONFIG_RTW_NAPI */
315 }
316
317 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29))
318 static const struct net_device_ops rtw_netdev_ops = {
319 .ndo_init = rtw_ndev_init,
320 .ndo_uninit = rtw_ndev_uninit,
321 .ndo_open = netdev_open,
322 .ndo_stop = netdev_close,
323 .ndo_start_xmit = rtw_xmit_entry,
324 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
325 .ndo_select_queue = rtw_select_queue,
326 #endif
327 .ndo_set_mac_address = rtw_net_set_mac_address,
328 .ndo_get_stats = rtw_net_get_stats,
329 .ndo_do_ioctl = rtw_ioctl,
330 };
331 #endif
332
rtw_init_netdev_name(struct net_device * pnetdev,const char * ifname)333 int rtw_init_netdev_name(struct net_device *pnetdev, const char *ifname)
334 {
335 if (dev_alloc_name(pnetdev, ifname) < 0)
336 RTW_ERR("dev_alloc_name, fail!\n");
337
338 rtw_netif_carrier_off(pnetdev);
339 /* rtw_netif_stop_queue(pnetdev); */
340
341 return 0;
342 }
343
rtw_hook_if_ops(struct net_device * ndev)344 void rtw_hook_if_ops(struct net_device *ndev)
345 {
346 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29))
347 ndev->netdev_ops = &rtw_netdev_ops;
348 #else
349 ndev->init = rtw_ndev_init;
350 ndev->uninit = rtw_ndev_uninit;
351 ndev->open = netdev_open;
352 ndev->stop = netdev_close;
353 ndev->hard_start_xmit = rtw_xmit_entry;
354 ndev->set_mac_address = rtw_net_set_mac_address;
355 ndev->get_stats = rtw_net_get_stats;
356 ndev->do_ioctl = rtw_ioctl;
357 #endif
358 }
359
360 #ifdef CONFIG_CONCURRENT_MODE
361 static void rtw_hook_vir_if_ops(struct net_device *ndev);
362 #endif
rtw_init_netdev(_adapter * old_padapter)363 struct net_device *rtw_init_netdev(_adapter *old_padapter)
364 {
365 _adapter *padapter;
366 struct net_device *pnetdev;
367
368 if (old_padapter != NULL) {
369 rtw_os_ndev_free(old_padapter);
370 pnetdev = rtw_alloc_etherdev_with_old_priv(sizeof(_adapter), (void *)old_padapter);
371 } else
372 pnetdev = rtw_alloc_etherdev(sizeof(_adapter));
373
374 if (!pnetdev)
375 return NULL;
376
377 padapter = rtw_netdev_priv(pnetdev);
378 padapter->pnetdev = pnetdev;
379
380 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
381 SET_MODULE_OWNER(pnetdev);
382 #endif
383
384 rtw_hook_if_ops(pnetdev);
385 #ifdef CONFIG_CONCURRENT_MODE
386 if (!is_primary_adapter(padapter))
387 rtw_hook_vir_if_ops(pnetdev);
388 #endif /* CONFIG_CONCURRENT_MODE */
389
390
391 #ifdef CONFIG_TCP_CSUM_OFFLOAD_TX
392 pnetdev->features |= (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
393 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 39)
394 pnetdev->hw_features |= (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
395 #endif
396 #endif
397
398 #ifdef CONFIG_RTW_NETIF_SG
399 pnetdev->features |= NETIF_F_SG;
400 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 39)
401 pnetdev->hw_features |= NETIF_F_SG;
402 #endif
403 #endif
404
405 if ((pnetdev->features & NETIF_F_SG) && (pnetdev->features & NETIF_F_IP_CSUM)) {
406 pnetdev->features |= (NETIF_F_TSO | NETIF_F_GSO);
407 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 39)
408 pnetdev->hw_features |= (NETIF_F_TSO | NETIF_F_GSO);
409 #endif
410 }
411 /* pnetdev->tx_timeout = NULL; */
412 pnetdev->watchdog_timeo = HZ * 3; /* 3 second timeout */
413
414 #ifdef CONFIG_WIRELESS_EXT
415 pnetdev->wireless_handlers = (struct iw_handler_def *)&rtw_handlers_def;
416 #endif
417
418 #ifdef WIRELESS_SPY
419 /* priv->wireless_data.spy_data = &priv->spy_data; */
420 /* pnetdev->wireless_data = &priv->wireless_data; */
421 #endif
422
423 #ifdef CONFIG_TX_AMSDU_SW_MODE
424 pnetdev->needed_headroom += 8; /* +8 for rfc1042 header */
425 pnetdev->needed_headroom += 4; /* +4 for padding */
426 #endif
427
428 return pnetdev;
429 }
430 #ifdef CONFIG_PCI_HCI
431 #include <rtw_trx_pci.h>
432 #endif
rtw_os_ndev_alloc(_adapter * adapter)433 int rtw_os_ndev_alloc(_adapter *adapter)
434 {
435 int ret = _FAIL;
436 struct net_device *ndev = NULL;
437
438 ndev = rtw_init_netdev(adapter);
439 if (ndev == NULL) {
440 rtw_warn_on(1);
441 goto exit;
442 }
443 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
444 SET_NETDEV_DEV(ndev, dvobj_to_dev(adapter_to_dvobj(adapter)));
445 #endif
446
447 #ifdef CONFIG_PCI_HCI
448 if (is_pci_support_dma64(adapter_to_dvobj(adapter)))
449 ndev->features |= NETIF_F_HIGHDMA;
450 ndev->irq = dvobj_to_pci(adapter_to_dvobj(adapter))->irq;
451 #endif
452
453 #if defined(CONFIG_IOCTL_CFG80211)
454 if (rtw_cfg80211_ndev_res_alloc(adapter) != _SUCCESS) {
455 rtw_warn_on(1);
456 } else
457 #endif
458 ret = _SUCCESS;
459
460 if (ret != _SUCCESS && ndev)
461 rtw_free_netdev(ndev);
462 exit:
463 return ret;
464 }
465
rtw_os_ndev_free(_adapter * adapter)466 void rtw_os_ndev_free(_adapter *adapter)
467 {
468 #if defined(CONFIG_IOCTL_CFG80211)
469 rtw_cfg80211_ndev_res_free(adapter);
470 #endif
471
472 /* free the old_pnetdev */
473 if (adapter->rereg_nd_name_priv.old_pnetdev) {
474 rtw_free_netdev(adapter->rereg_nd_name_priv.old_pnetdev);
475 adapter->rereg_nd_name_priv.old_pnetdev = NULL;
476 }
477
478 if (adapter->pnetdev) {
479 rtw_free_netdev(adapter->pnetdev);
480 adapter->pnetdev = NULL;
481 }
482 }
483
484 /* For ethtool +++ */
485 #ifdef CONFIG_IOCTL_CFG80211
486 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 8))
rtw_ethtool_get_drvinfo(struct net_device * dev,struct ethtool_drvinfo * info)487 static void rtw_ethtool_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
488 {
489 struct wireless_dev *wdev = NULL;
490 _adapter *padapter = NULL;
491
492 wdev = dev->ieee80211_ptr;
493 if (wdev) {
494 strlcpy(info->driver, wiphy_dev(wdev->wiphy)->driver->name,
495 sizeof(info->driver));
496 } else {
497 strlcpy(info->driver, "N/A", sizeof(info->driver));
498 }
499
500 strlcpy(info->version, DRIVERVERSION, sizeof(info->version));
501
502 padapter = (_adapter *)rtw_netdev_priv(dev);
503
504
505 /*GEORGIA_TODO_FIXIT*/
506 #if 0
507 HAL_DATA_TYPE *hal_data = NULL;
508 if (padapter) {
509 hal_data = GET_PHL_COM(padapter);
510 }
511 if (hal_data) {
512 scnprintf(info->fw_version, sizeof(info->fw_version), "%d.%d",
513 hal_data->firmware_version, hal_data->firmware_sub_version);
514 } else
515 #endif
516 {
517 strlcpy(info->fw_version, "N/A", sizeof(info->fw_version));
518 }
519
520 strlcpy(info->bus_info, dev_name(wiphy_dev(wdev->wiphy)),
521 sizeof(info->bus_info));
522 }
523
524 static const char rtw_ethtool_gstrings_sta_stats[][ETH_GSTRING_LEN] = {
525 "rx_packets", "rx_bytes", "rx_dropped",
526 "tx_packets", "tx_bytes", "tx_dropped",
527 };
528
529 #define RTW_ETHTOOL_STATS_LEN ARRAY_SIZE(rtw_ethtool_gstrings_sta_stats)
530
rtw_ethtool_get_sset_count(struct net_device * dev,int sset)531 static int rtw_ethtool_get_sset_count(struct net_device *dev, int sset)
532 {
533 int rv = 0;
534
535 if (sset == ETH_SS_STATS)
536 rv += RTW_ETHTOOL_STATS_LEN;
537
538 if (rv == 0)
539 return -EOPNOTSUPP;
540
541 return rv;
542 }
543
rtw_ethtool_get_strings(struct net_device * dev,u32 sset,u8 * data)544 static void rtw_ethtool_get_strings(struct net_device *dev, u32 sset, u8 *data)
545 {
546 int sz_sta_stats = 0;
547
548 if (sset == ETH_SS_STATS) {
549 sz_sta_stats = sizeof(rtw_ethtool_gstrings_sta_stats);
550 _rtw_memcpy(data, rtw_ethtool_gstrings_sta_stats, sz_sta_stats);
551 }
552 }
553
rtw_ethtool_get_stats(struct net_device * dev,struct ethtool_stats * stats,u64 * data)554 static void rtw_ethtool_get_stats(struct net_device *dev,
555 struct ethtool_stats *stats,
556 u64 *data)
557 {
558 int i = 0;
559 _adapter *padapter = NULL;
560 struct xmit_priv *pxmitpriv = NULL;
561 struct recv_info *precvinfo = NULL;
562
563 memset(data, 0, sizeof(u64) * RTW_ETHTOOL_STATS_LEN);
564
565 padapter = (_adapter *)rtw_netdev_priv(dev);
566 if (padapter) {
567 pxmitpriv = &(padapter->xmitpriv);
568 precvinfo = &(padapter->recvinfo);
569
570 data[i++] = precvinfo->rx_pkts;
571 data[i++] = precvinfo->rx_bytes;
572 data[i++] = precvinfo->rx_drop;
573
574 data[i++] = pxmitpriv->tx_pkts;
575 data[i++] = pxmitpriv->tx_bytes;
576 data[i++] = pxmitpriv->tx_drop;
577 } else {
578 data[i++] = 0;
579 data[i++] = 0;
580 data[i++] = 0;
581
582 data[i++] = 0;
583 data[i++] = 0;
584 data[i++] = 0;
585 }
586 }
587
588 static const struct ethtool_ops rtw_ethtool_ops = {
589 .get_drvinfo = rtw_ethtool_get_drvinfo,
590 .get_link = ethtool_op_get_link,
591 .get_strings = rtw_ethtool_get_strings,
592 .get_ethtool_stats = rtw_ethtool_get_stats,
593 .get_sset_count = rtw_ethtool_get_sset_count,
594 };
595 #endif // LINUX_VERSION_CODE >= 3.7.8
596 #endif /* CONFIG_IOCTL_CFG80211 */
597 /* For ethtool --- */
598
rtw_os_ndev_register(_adapter * adapter,const char * name)599 int rtw_os_ndev_register(_adapter *adapter, const char *name)
600 {
601 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
602 int ret = _SUCCESS;
603 struct net_device *ndev = adapter->pnetdev;
604 u8 rtnl_lock_needed = rtw_rtnl_lock_needed(dvobj);
605
606 #if defined(CONFIG_IOCTL_CFG80211)
607 if (rtw_cfg80211_ndev_res_register(adapter) != _SUCCESS) {
608 rtw_warn_on(1);
609 ret = _FAIL;
610 goto exit;
611 }
612
613 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 8))
614 netdev_set_default_ethtool_ops(ndev, &rtw_ethtool_ops);
615 #endif /* LINUX_VERSION_CODE >= 3.7.8 */
616 #endif
617 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 19, 0)) && defined(CONFIG_PCI_HCI)
618 ndev->gro_flush_timeout = 100000;
619 #endif
620 /* alloc netdev name */
621 rtw_init_netdev_name(ndev, name);
622
623 _rtw_memcpy(ndev->dev_addr, adapter_mac_addr(adapter), ETH_ALEN);
624
625 /* Tell the network stack we exist */
626
627 if (rtnl_lock_needed)
628 ret = (register_netdev(ndev) == 0) ? _SUCCESS : _FAIL;
629 else
630 ret = (register_netdevice(ndev) == 0) ? _SUCCESS : _FAIL;
631
632 if (ret == _SUCCESS)
633 adapter->registered = 1;
634 else
635 RTW_INFO(FUNC_NDEV_FMT" if%d Failed!\n", FUNC_NDEV_ARG(ndev), (adapter->iface_id + 1));
636
637 #if defined(CONFIG_IOCTL_CFG80211)
638 if (ret != _SUCCESS) {
639 rtw_cfg80211_ndev_res_unregister(adapter);
640 }
641 #endif
642
643 #if defined(CONFIG_IOCTL_CFG80211)
644 exit:
645 #endif
646
647 return ret;
648 }
649
rtw_os_ndev_unregister(_adapter * adapter)650 void rtw_os_ndev_unregister(_adapter *adapter)
651 {
652 struct net_device *netdev = NULL;
653
654 if (adapter == NULL || adapter->registered == 0)
655 return;
656
657 adapter->ndev_unregistering = 1;
658
659 netdev = adapter->pnetdev;
660
661 #if defined(CONFIG_IOCTL_CFG80211)
662 rtw_cfg80211_ndev_res_unregister(adapter);
663 #endif
664
665 if (netdev) {
666 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
667 u8 rtnl_lock_needed = rtw_rtnl_lock_needed(dvobj);
668
669 if (rtnl_lock_needed)
670 unregister_netdev(netdev);
671 else
672 unregister_netdevice(netdev);
673 }
674
675 adapter->registered = 0;
676 adapter->ndev_unregistering = 0;
677 }
678
679 /**
680 * rtw_os_ndev_init - Allocate and register OS layer net device and relating structures for @adapter
681 * @adapter: the adapter on which this function applies
682 * @name: the requesting net device name
683 *
684 * Returns:
685 * _SUCCESS or _FAIL
686 */
rtw_os_ndev_init(_adapter * adapter,const char * name)687 int rtw_os_ndev_init(_adapter *adapter, const char *name)
688 {
689 int ret = _FAIL;
690
691 if (rtw_os_ndev_alloc(adapter) != _SUCCESS)
692 goto exit;
693
694 if (rtw_os_ndev_register(adapter, name) != _SUCCESS)
695 goto os_ndev_free;
696
697 ret = _SUCCESS;
698
699 os_ndev_free:
700 if (ret != _SUCCESS)
701 rtw_os_ndev_free(adapter);
702 exit:
703 return ret;
704 }
705
706 /**
707 * rtw_os_ndev_deinit - Unregister and free OS layer net device and relating structures for @adapter
708 * @adapter: the adapter on which this function applies
709 */
rtw_os_ndev_deinit(_adapter * adapter)710 void rtw_os_ndev_deinit(_adapter *adapter)
711 {
712 rtw_os_ndev_unregister(adapter);
713 rtw_os_ndev_free(adapter);
714 }
715
rtw_os_ndevs_alloc(struct dvobj_priv * dvobj)716 int rtw_os_ndevs_alloc(struct dvobj_priv *dvobj)
717 {
718 int i, status = _SUCCESS;
719 _adapter *adapter;
720
721 #if defined(CONFIG_IOCTL_CFG80211)
722 if (rtw_cfg80211_dev_res_alloc(dvobj) != _SUCCESS) {
723 rtw_warn_on(1);
724 return _FAIL;
725 }
726 #endif
727
728 for (i = 0; i < dvobj->iface_nums; i++) {
729
730 if (i >= CONFIG_IFACE_NUMBER) {
731 RTW_ERR("%s %d >= CONFIG_IFACE_NUMBER(%d)\n", __func__, i, CONFIG_IFACE_NUMBER);
732 rtw_warn_on(1);
733 continue;
734 }
735
736 adapter = dvobj->padapters[i];
737 if (adapter && !adapter->pnetdev) {
738
739 #ifdef CONFIG_RTW_DYNAMIC_NDEV
740 if (!is_primary_adapter(adapter) &&
741 (i >= CONFIG_RTW_STATIC_NDEV_NUM))
742 break;
743 #endif
744
745 status = rtw_os_ndev_alloc(adapter);
746 if (status != _SUCCESS) {
747 rtw_warn_on(1);
748 break;
749 }
750 }
751 }
752
753 if (status != _SUCCESS) {
754 for (; i >= 0; i--) {
755 adapter = dvobj->padapters[i];
756 if (adapter && adapter->pnetdev)
757 rtw_os_ndev_free(adapter);
758 }
759 }
760
761 #if defined(CONFIG_IOCTL_CFG80211)
762 if (status != _SUCCESS)
763 rtw_cfg80211_dev_res_free(dvobj);
764 #endif
765
766 return status;
767 }
768
rtw_os_ndevs_free(struct dvobj_priv * dvobj)769 void rtw_os_ndevs_free(struct dvobj_priv *dvobj)
770 {
771 int i;
772 _adapter *adapter = NULL;
773
774 for (i = 0; i < dvobj->iface_nums; i++) {
775
776 if (i >= CONFIG_IFACE_NUMBER) {
777 RTW_ERR("%s %d >= CONFIG_IFACE_NUMBER(%d)\n", __func__, i, CONFIG_IFACE_NUMBER);
778 rtw_warn_on(1);
779 continue;
780 }
781
782 adapter = dvobj->padapters[i];
783
784 if (adapter == NULL)
785 continue;
786
787 rtw_os_ndev_free(adapter);
788 }
789
790 #if defined(CONFIG_IOCTL_CFG80211)
791 rtw_cfg80211_dev_res_free(dvobj);
792 #endif
793 }
794
795 #if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
796 u32 rtw_start_drv_threads(_adapter *padapter)
797 {
798 u32 _status = _SUCCESS;
799
800 RTW_INFO(FUNC_ADPT_FMT" enter\n", FUNC_ADPT_ARG(padapter));
801
802 #ifdef CONFIG_XMIT_THREAD_MODE
803 #if defined(CONFIG_SDIO_HCI)
804 if (is_primary_adapter(padapter))
805 #endif
806 {
807 if (padapter->xmitThread == NULL) {
808 RTW_INFO(FUNC_ADPT_FMT " start RTW_XMIT_THREAD\n", FUNC_ADPT_ARG(padapter));
809 padapter->xmitThread = rtw_thread_start(rtw_xmit_thread, padapter, "RTW_XMIT_THREAD");
810 if (padapter->xmitThread == NULL)
811 _status = _FAIL;
812 }
813 }
814 #endif /* #ifdef CONFIG_XMIT_THREAD_MODE */
815
816 #ifdef CONFIG_RECV_THREAD_MODE
817 if (is_primary_adapter(padapter)) {
818 if (padapter->recvThread == NULL) {
819 RTW_INFO(FUNC_ADPT_FMT " start RTW_RECV_THREAD\n", FUNC_ADPT_ARG(padapter));
820 padapter->recvThread = rtw_thread_start(rtw_recv_thread, padapter, "RTW_RECV_THREAD");
821 if (padapter->recvThread == NULL)
822 _status = _FAIL;
823 }
824 }
825 #endif
826
827 if (is_primary_adapter(padapter)) {
828 if (padapter->cmdThread == NULL) {
829 RTW_INFO(FUNC_ADPT_FMT " start RTW_CMD_THREAD\n", FUNC_ADPT_ARG(padapter));
830 padapter->cmdThread = rtw_thread_start(rtw_cmd_thread, padapter, "RTW_CMD_THREAD");
831 if (padapter->cmdThread == NULL)
832 _status = _FAIL;
833 else
834 _rtw_down_sema(&padapter->cmdpriv.start_cmdthread_sema); /* wait for cmd_thread to run */
835 }
836 }
837
838 _status = rtw_intf_start_xmit_frame_thread(padapter);
839 return _status;
840
841 }
842
843 void rtw_stop_drv_threads(_adapter *padapter)
844 {
845 RTW_INFO(FUNC_ADPT_FMT" enter\n", FUNC_ADPT_ARG(padapter));
846 if (is_primary_adapter(padapter))
847 rtw_stop_cmd_thread(padapter);
848
849 #ifdef CONFIG_XMIT_THREAD_MODE
850 /* Below is to termindate tx_thread... */
851 #if defined(CONFIG_SDIO_HCI)
852 /* Only wake-up primary adapter */
853 if (is_primary_adapter(padapter))
854 #endif /*SDIO_HCI */
855 {
856 if (padapter->xmitThread) {
857 _rtw_up_sema(&padapter->xmitpriv.xmit_sema);
858 rtw_thread_stop(padapter->xmitThread);
859 padapter->xmitThread = NULL;
860 }
861 }
862 #endif
863
864 #ifdef CONFIG_RECV_THREAD_MODE
865 if (is_primary_adapter(padapter) && padapter->recvThread) {
866 /* Below is to termindate rx_thread... */
867 _rtw_up_sema(&padapter->recvpriv.recv_sema);
868 rtw_thread_stop(padapter->recvThread);
869 padapter->recvThread = NULL;
870 }
871 #endif
872
873 /*rtw_hal_stop_thread(padapter);*/
874 rtw_intf_cancel_xmit_frame_thread(padapter);
875
876 }
877 #endif
878
rtw_init_default_value(_adapter * padapter)879 u8 rtw_init_default_value(_adapter *padapter)
880 {
881 u8 ret = _SUCCESS;
882 struct registry_priv *pregistrypriv = &padapter->registrypriv;
883 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
884 struct security_priv *psecuritypriv = &padapter->securitypriv;
885
886 /* xmit_priv */
887 pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense;
888 pxmitpriv->vcs = pregistrypriv->vcs_type;
889 pxmitpriv->vcs_type = pregistrypriv->vcs_type;
890 /* pxmitpriv->rts_thresh = pregistrypriv->rts_thresh; */
891 pxmitpriv->frag_len = pregistrypriv->frag_thresh;
892
893 /* security_priv */
894 /* rtw_get_encrypt_decrypt_from_registrypriv(padapter); */
895 psecuritypriv->binstallGrpkey = _FAIL;
896 #ifdef CONFIG_GTK_OL
897 psecuritypriv->binstallKCK_KEK = _FAIL;
898 #endif /* CONFIG_GTK_OL */
899 psecuritypriv->sw_encrypt = pregistrypriv->software_encrypt;
900 psecuritypriv->sw_decrypt = pregistrypriv->software_decrypt;
901
902 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
903 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
904
905 psecuritypriv->dot11PrivacyKeyIndex = 0;
906
907 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
908 psecuritypriv->dot118021XGrpKeyid = 1;
909
910 psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
911 psecuritypriv->ndisencryptstatus = Ndis802_11WEPDisabled;
912 #ifdef CONFIG_CONCURRENT_MODE
913 psecuritypriv->dot118021x_bmc_cam_id = INVALID_SEC_MAC_CAM_ID;
914 #endif
915
916 /* pwrctrl_priv */
917
918 /* registry_priv */
919 rtw_init_registrypriv_dev_network(padapter);
920 rtw_update_registrypriv_dev_network(padapter);
921
922 pregistrypriv->wireless_mode &= rtw_hw_get_wireless_mode(adapter_to_dvobj(padapter));
923 pregistrypriv->band_type &= rtw_hw_get_band_type(adapter_to_dvobj(padapter));
924 /*init fw_psmode_iface_id*/
925 adapter_to_pwrctl(padapter)->fw_psmode_iface_id = 0xff;
926
927
928 /* misc. */
929 padapter->bLinkInfoDump = 0;
930 padapter->bNotifyChannelChange = _FALSE;
931 #ifdef CONFIG_P2P
932 padapter->bShowGetP2PState = 1;
933 #endif
934
935 /* for debug purpose */
936 padapter->fix_rate = NO_FIX_RATE;
937 padapter->data_fb = 0;
938 padapter->fix_bw = NO_FIX_BW;
939 padapter->power_offset = 0;
940 padapter->rsvd_page_offset = 0;
941 padapter->rsvd_page_num = 0;
942 #ifdef CONFIG_AP_MODE
943 padapter->bmc_tx_rate = pregistrypriv->bmc_tx_rate;
944 #if CONFIG_RTW_AP_DATA_BMC_TO_UC
945 padapter->b2u_flags_ap_src = pregistrypriv->ap_src_b2u_flags;
946 padapter->b2u_flags_ap_fwd = pregistrypriv->ap_fwd_b2u_flags;
947 #endif
948 #endif
949 padapter->driver_tx_bw_mode = pregistrypriv->tx_bw_mode;
950
951 padapter->driver_ampdu_spacing = 0xFF;
952 padapter->driver_rx_ampdu_factor = 0xFF;
953 padapter->driver_rx_ampdu_spacing = 0xFF;
954 padapter->fix_rx_ampdu_accept = RX_AMPDU_ACCEPT_INVALID;
955 padapter->fix_rx_ampdu_size = RX_AMPDU_SIZE_INVALID;
956 #ifdef CONFIG_TX_AMSDU
957 padapter->tx_amsdu = 2;
958 padapter->tx_amsdu_rate = 10;
959 #endif
960 if (pregistrypriv->adaptivity_idle_probability == 1) {
961 #ifdef CONFIG_TX_AMSDU
962 padapter->tx_amsdu = 0;
963 padapter->tx_amsdu_rate = 0;
964 #endif
965 padapter->dis_turboedca = 1;
966 }
967
968 padapter->driver_tx_max_agg_num = 0xFF;
969 #ifdef DBG_RX_COUNTER_DUMP
970 padapter->dump_rx_cnt_mode = 0;
971 padapter->drv_rx_cnt_ok = 0;
972 padapter->drv_rx_cnt_crcerror = 0;
973 padapter->drv_rx_cnt_drop = 0;
974 #endif
975 #ifdef CONFIG_RTW_NAPI
976 padapter->napi_state = NAPI_DISABLE;
977 #endif
978
979 #ifdef CONFIG_RTW_TOKEN_BASED_XMIT
980 ATOMIC_SET(&padapter->tbtx_tx_pause, _FALSE);
981 ATOMIC_SET(&padapter->tbtx_remove_tx_pause, _FALSE);
982 padapter->tbtx_capability = _TRUE;
983 #endif
984
985 #ifdef CONFIG_CORE_TXSC
986 txsc_init(padapter);
987 #endif
988
989 return ret;
990 }
991
992 #ifdef CONFIG_DRV_FAKE_AP
993 extern void rtw_fakeap_work(struct work_struct *work);
994 extern void rtw_fakeap_bcn_timer_hdl(void*);
995 #endif /* CONFIG_DRV_FAKE_AP */
996
devobj_init(void)997 struct dvobj_priv *devobj_init(void)
998 {
999 struct dvobj_priv *pdvobj = NULL;
1000 struct rf_ctl_t *rfctl;
1001
1002 pdvobj = (struct dvobj_priv *)rtw_zmalloc(sizeof(*pdvobj));
1003 if (pdvobj == NULL)
1004 return NULL;
1005
1006 rfctl = dvobj_to_rfctl(pdvobj);
1007
1008 _rtw_mutex_init(&pdvobj->hw_init_mutex);
1009 _rtw_mutex_init(&pdvobj->setch_mutex);
1010 _rtw_mutex_init(&pdvobj->setbw_mutex);
1011 _rtw_mutex_init(&pdvobj->rf_read_reg_mutex);
1012 _rtw_mutex_init(&pdvobj->ioctrl_mutex);
1013
1014 #ifdef CONFIG_RTW_CUSTOMER_STR
1015 _rtw_mutex_init(&pdvobj->customer_str_mutex);
1016 _rtw_memset(pdvobj->customer_str, 0xFF, RTW_CUSTOMER_STR_LEN);
1017 #endif
1018
1019 pdvobj->processing_dev_remove = _FALSE;
1020
1021 ATOMIC_SET(&pdvobj->disable_func, 0);
1022 /* move to phl */
1023 /* rtw_macid_ctl_init(&pdvobj->macid_ctl); */
1024
1025 _rtw_spinlock_init(&pdvobj->cam_ctl.lock);
1026 _rtw_mutex_init(&pdvobj->cam_ctl.sec_cam_access_mutex);
1027 #if defined(RTK_129X_PLATFORM) && defined(CONFIG_PCI_HCI)
1028 _rtw_spinlock_init(&pdvobj->io_reg_lock);
1029 #endif
1030
1031 #if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
1032 rtw_init_timer(&(pdvobj->dynamic_chk_timer), rtw_dynamic_check_timer_handlder, pdvobj);
1033 #endif
1034
1035 #ifdef CONFIG_RTW_NAPI_DYNAMIC
1036 pdvobj->en_napi_dynamic = 0;
1037 #endif /* CONFIG_RTW_NAPI_DYNAMIC */
1038
1039 _rtw_mutex_init(&rfctl->offch_mutex);
1040
1041 pdvobj->scan_deny = _FALSE;
1042 rtw_load_dvobj_registry(pdvobj);
1043
1044 #ifdef CONFIG_DRV_FAKE_AP
1045 skb_queue_head_init(&pdvobj->fakeap.rxq);
1046 _init_workitem(&pdvobj->fakeap.work, rtw_fakeap_work, pdvobj);
1047 _init_timer(&pdvobj->fakeap.bcn_timer, rtw_fakeap_bcn_timer_hdl, pdvobj);
1048 #endif /* CONFIG_DRV_FAKE_AP */
1049
1050 /* wpas type default from w1.fi */
1051 pdvobj->wpas_type = RTW_WPAS_W1FI;
1052
1053 return pdvobj;
1054
1055 }
1056
devobj_deinit(struct dvobj_priv * pdvobj)1057 void devobj_deinit(struct dvobj_priv *pdvobj)
1058 {
1059 if (!pdvobj)
1060 return;
1061
1062 /* TODO: use rtw_os_ndevs_deinit instead at the first stage of driver's dev deinit function */
1063 #if defined(CONFIG_IOCTL_CFG80211)
1064 rtw_cfg80211_dev_res_free(pdvobj);
1065 #endif
1066
1067 _rtw_mutex_free(&pdvobj->hw_init_mutex);
1068
1069 #ifdef CONFIG_RTW_CUSTOMER_STR
1070 _rtw_mutex_free(&pdvobj->customer_str_mutex);
1071 #endif
1072
1073 _rtw_mutex_free(&pdvobj->setch_mutex);
1074 _rtw_mutex_free(&pdvobj->setbw_mutex);
1075 _rtw_mutex_free(&pdvobj->rf_read_reg_mutex);
1076 _rtw_mutex_free(&pdvobj->ioctrl_mutex);
1077 /* move to phl */
1078 /* rtw_macid_ctl_deinit(&pdvobj->macid_ctl); */
1079
1080 _rtw_spinlock_free(&pdvobj->cam_ctl.lock);
1081 _rtw_mutex_free(&pdvobj->cam_ctl.sec_cam_access_mutex);
1082
1083 #if defined(RTK_129X_PLATFORM) && defined(CONFIG_PCI_HCI)
1084 _rtw_spinlock_free(&pdvobj->io_reg_lock);
1085 #endif
1086
1087 rtw_mfree((u8 *)pdvobj, sizeof(*pdvobj));
1088 }
1089
rtw_rtnl_lock_needed(struct dvobj_priv * dvobj)1090 inline u8 rtw_rtnl_lock_needed(struct dvobj_priv *dvobj)
1091 {
1092 if (dvobj->rtnl_lock_holder && dvobj->rtnl_lock_holder == current)
1093 return 0;
1094 return 1;
1095 }
1096
1097 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 26))
rtnl_is_locked(void)1098 static inline int rtnl_is_locked(void)
1099 {
1100 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 17))
1101 if (unlikely(rtnl_trylock())) {
1102 rtnl_unlock();
1103 #else
1104 if (unlikely(down_trylock(&rtnl_sem) == 0)) {
1105 up(&rtnl_sem);
1106 #endif
1107 return 0;
1108 }
1109 return 1;
1110 }
1111 #endif
1112
1113 inline void rtw_set_rtnl_lock_holder(struct dvobj_priv *dvobj, _thread_hdl_ thd_hdl)
1114 {
1115 rtw_warn_on(!rtnl_is_locked());
1116
1117 if (!thd_hdl || rtnl_is_locked())
1118 dvobj->rtnl_lock_holder = thd_hdl;
1119
1120 if (dvobj->rtnl_lock_holder && 0)
1121 RTW_INFO("rtnl_lock_holder: %s:%d\n", current->comm, current->pid);
1122 }
1123
1124 u8 rtw_reset_drv_sw(_adapter *padapter)
1125 {
1126 u8 ret8 = _SUCCESS;
1127 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1128 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
1129
1130 /* hal_priv */
1131 rtw_hw_cap_init(adapter_to_dvobj(padapter));
1132
1133 RTW_ENABLE_FUNC(adapter_to_dvobj(padapter), DF_RX_BIT);
1134 RTW_ENABLE_FUNC(adapter_to_dvobj(padapter), DF_TX_BIT);
1135
1136 padapter->bLinkInfoDump = 0;
1137
1138 padapter->xmitpriv.tx_pkts = 0;
1139 padapter->recvinfo.rx_pkts = 0;
1140
1141 pmlmepriv->LinkDetectInfo.bBusyTraffic = _FALSE;
1142
1143 /* pmlmepriv->LinkDetectInfo.TrafficBusyState = _FALSE; */
1144 pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0;
1145 pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0;
1146
1147 _clr_fwstate_(pmlmepriv, WIFI_UNDER_SURVEY | WIFI_UNDER_LINKING);
1148
1149 #ifdef DBG_CONFIG_ERROR_DETECT
1150 if (is_primary_adapter(padapter))
1151 rtw_hal_sreset_reset_value(padapter);
1152 #endif
1153 pwrctrlpriv->pwr_state_check_cnts = 0;
1154
1155 /* mlmeextpriv */
1156 mlmeext_set_scan_state(&padapter->mlmeextpriv, SCAN_DISABLE);
1157
1158 #ifdef CONFIG_SIGNAL_STAT_PROCESS
1159 rtw_set_signal_stat_timer(&padapter->recvinfo);
1160 #endif
1161 return ret8;
1162 }
1163
1164 static int devobj_set_phl_regulation_capability(struct dvobj_priv *dvobj)
1165 {
1166 struct registry_priv *regsty = dvobj_to_regsty(dvobj);
1167 bool band_2g = _FALSE;
1168 #if CONFIG_IEEE80211_BAND_5GHZ
1169 bool band_5g = _FALSE;
1170 #endif
1171 #if CONFIG_IEEE80211_BAND_6GHZ
1172 bool band_6g = _FALSE;
1173 #endif
1174 enum rtw_regulation_capability phl_regd_cap = 0;
1175 int ret = _FAIL;
1176
1177 if (is_supported_24g(regsty->band_type) && rtw_hw_chk_band_cap(dvobj, BAND_CAP_2G))
1178 band_2g = _TRUE;
1179
1180 #if CONFIG_IEEE80211_BAND_5GHZ
1181 if (is_supported_5g(regsty->band_type) && rtw_hw_chk_band_cap(dvobj, BAND_CAP_5G))
1182 band_5g = _TRUE;
1183 #endif
1184
1185 #if CONFIG_IEEE80211_BAND_6GHZ
1186 if (is_supported_6g(regsty->band_type) && rtw_hw_chk_band_cap(dvobj, BAND_CAP_6G))
1187 band_6g = _TRUE;
1188 #endif
1189
1190 if (band_2g == _FALSE
1191 #if CONFIG_IEEE80211_BAND_5GHZ
1192 && band_5g == _FALSE
1193 #endif
1194 #if CONFIG_IEEE80211_BAND_6GHZ
1195 && band_6g == _FALSE
1196 #endif
1197 ) {
1198 RTW_WARN("HW band_cap has no intersection with SW wireless_mode setting\n");
1199 goto exit;
1200 }
1201
1202 if (band_2g)
1203 phl_regd_cap |= CAPABILITY_2GHZ;
1204 #if CONFIG_IEEE80211_BAND_5GHZ
1205 if (band_5g)
1206 phl_regd_cap |= CAPABILITY_5GHZ;
1207 #endif
1208 #if CONFIG_IEEE80211_BAND_6GHZ
1209 if (band_6g)
1210 phl_regd_cap |= CAPABILITY_6GHZ;
1211 #endif
1212 #if CONFIG_DFS
1213 phl_regd_cap |= CAPABILITY_DFS;
1214 #endif
1215
1216 if (rtw_phl_regulation_set_capability(GET_PHL_INFO(dvobj), phl_regd_cap) != true) {
1217 RTW_WARN("rtw_phl_regulation_set_capability() != true\n");
1218 goto exit;
1219 }
1220
1221 ret = _SUCCESS;
1222
1223 exit:
1224 return ret;
1225 }
1226
1227 static void devobj_decide_init_chplan(struct dvobj_priv *dvobj)
1228 {
1229 struct rf_ctl_t *rfctl = dvobj_to_rfctl(dvobj);
1230 struct dev_cap_t *dev_cap = &GET_PHL_COM(dvobj)->dev_cap;
1231 const char *alpha2 = NULL; /* TODO */
1232 u8 chplan = dev_cap->domain;
1233 u8 chplan_6g = RTW_CHPLAN_6G_NULL; /* TODO */
1234 bool disable_sw_chplan = _FALSE; /* TODO */
1235
1236 if (alpha2)
1237 RTW_INFO("%s alpha2:{%d,%d}\n", __func__, alpha2[0], alpha2[1]);
1238 RTW_INFO("%s chplan:0x%02x\n", __func__, chplan);
1239 RTW_INFO("%s chplan_6g:0x%02x\n", __func__, chplan_6g);
1240 RTW_INFO("%s disable_sw_chplan:%d\n", __func__, disable_sw_chplan);
1241
1242 /*
1243 * treat {0xFF, 0xFF} as unspecified
1244 */
1245 if (alpha2 && strncmp(alpha2, "\xFF\xFF", 2) == 0)
1246 alpha2 = NULL;
1247
1248 #ifdef CONFIG_FORCE_SW_CHANNEL_PLAN
1249 disable_sw_chplan = _FALSE;
1250 #endif
1251
1252 rtw_rfctl_decide_init_chplan(rfctl, alpha2, chplan, chplan_6g, disable_sw_chplan);
1253 }
1254
1255 u8 devobj_data_init(struct dvobj_priv *dvobj)
1256 {
1257 u8 ret = _FAIL;
1258
1259 dev_set_drv_stopped(dvobj);/*init*/
1260 dev_clr_hw_start(dvobj); /* init */
1261
1262 /*init data of dvobj*/
1263 if (devobj_set_phl_regulation_capability(dvobj) != _SUCCESS)
1264 goto exit;
1265
1266 devobj_decide_init_chplan(dvobj);
1267
1268 if (rtw_rfctl_init(dvobj) == _FAIL)
1269 goto exit;
1270
1271 rtw_edcca_mode_update(dvobj);
1272 rtw_update_phl_edcca_mode(dvobj_get_primary_adapter(dvobj));
1273 rtw_rfctl_chplan_init(dvobj);
1274 rtw_hw_cap_init(dvobj);
1275
1276 RTW_ENABLE_FUNC(dvobj, DF_RX_BIT);
1277 RTW_ENABLE_FUNC(dvobj, DF_TX_BIT);
1278
1279 ret = _SUCCESS;
1280
1281 exit:
1282 return ret;
1283 }
1284
1285
1286 void devobj_data_deinit(struct dvobj_priv *dvobj)
1287 {
1288 }
1289
1290 u8 devobj_trx_resource_init(struct dvobj_priv *dvobj)
1291 {
1292 u8 ret = _SUCCESS;
1293
1294 #ifdef CONFIG_USB_HCI
1295 ret = rtw_init_lite_xmit_resource(dvobj);
1296 if (ret == _FAIL)
1297 goto exit;
1298 ret = rtw_init_lite_recv_resource(dvobj);
1299 if (ret == _FAIL)
1300 goto exit;
1301 #endif
1302 ret = rtw_init_recv_priv(dvobj);
1303 if (ret == _FAIL) {
1304 RTW_ERR("%s rtw_init_recv_priv failed\n", __func__);
1305 goto exit;
1306 }
1307
1308 ret = rtw_init_cmd_priv(dvobj);
1309 if (ret == _FAIL) {
1310 RTW_ERR("%s rtw_init_cmd_priv failed\n", __func__);
1311 goto exit;
1312 }
1313 exit:
1314 return ret;
1315 }
1316
1317
1318 void devobj_trx_resource_deinit(struct dvobj_priv *dvobj)
1319 {
1320 #ifdef CONFIG_USB_HCI
1321 rtw_free_lite_xmit_resource(dvobj);
1322 rtw_free_lite_recv_resource(dvobj);
1323 #endif
1324 rtw_free_recv_priv(dvobj);
1325 rtw_free_cmd_priv(dvobj);
1326 }
1327
1328
1329 u8 rtw_init_drv_sw(_adapter *padapter)
1330 {
1331 u8 ret8 = _SUCCESS;
1332
1333 #ifdef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
1334 struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(padapter);
1335 #endif
1336
1337 ret8 = rtw_init_default_value(padapter);/*load registrypriv value*/
1338
1339 if (rtw_init_mlme_priv(padapter) == _FAIL) {
1340 ret8 = _FAIL;
1341 goto exit;
1342 }
1343
1344 #ifdef CONFIG_P2P
1345 init_wifidirect_info(padapter, P2P_ROLE_DISABLE);
1346 reset_global_wifidirect_info(padapter);
1347 #ifdef CONFIG_WFD
1348 if (rtw_init_wifi_display_info(padapter) == _FAIL)
1349 RTW_ERR("Can't init init_wifi_display_info\n");
1350 #endif
1351 #endif /* CONFIG_P2P */
1352
1353 if (init_mlme_ext_priv(padapter) == _FAIL) {
1354 ret8 = _FAIL;
1355 goto exit;
1356 }
1357
1358 #ifdef CONFIG_TDLS
1359 if (rtw_init_tdls_info(padapter) == _FAIL) {
1360 RTW_INFO("Can't rtw_init_tdls_info\n");
1361 ret8 = _FAIL;
1362 goto exit;
1363 }
1364 #endif /* CONFIG_TDLS */
1365
1366 #ifdef CONFIG_RTW_MESH
1367 rtw_mesh_cfg_init(padapter);
1368 #endif
1369
1370 if (_rtw_init_xmit_priv(&padapter->xmitpriv, padapter) == _FAIL) {
1371 RTW_INFO("Can't _rtw_init_xmit_priv\n");
1372 ret8 = _FAIL;
1373 goto exit;
1374 }
1375 if (rtw_init_recv_info(padapter) == _FAIL) {
1376 RTW_INFO("Can't rtw_init_recv_info\n");
1377 ret8 = _FAIL;
1378 goto exit;
1379 }
1380
1381 /* add for CONFIG_IEEE80211W, none 11w also can use */
1382 _rtw_spinlock_init(&padapter->security_key_mutex);
1383
1384 /* We don't need to memset padapter->XXX to zero, because adapter is allocated by rtw_zvmalloc(). */
1385 /* _rtw_memset((unsigned char *)&padapter->securitypriv, 0, sizeof (struct security_priv)); */
1386
1387 if (_rtw_init_sta_priv(&padapter->stapriv) == _FAIL) {
1388 RTW_INFO("Can't _rtw_init_sta_priv\n");
1389 ret8 = _FAIL;
1390 goto exit;
1391 }
1392
1393 padapter->setband = WIFI_FREQUENCY_BAND_AUTO;
1394 padapter->fix_rate = NO_FIX_RATE;
1395 padapter->power_offset = 0;
1396 padapter->rsvd_page_offset = 0;
1397 padapter->rsvd_page_num = 0;
1398
1399 padapter->data_fb = 0;
1400 padapter->fix_rx_ampdu_accept = RX_AMPDU_ACCEPT_INVALID;
1401 padapter->fix_rx_ampdu_size = RX_AMPDU_SIZE_INVALID;
1402 #ifdef DBG_RX_COUNTER_DUMP
1403 padapter->dump_rx_cnt_mode = 0;
1404 padapter->drv_rx_cnt_ok = 0;
1405 padapter->drv_rx_cnt_crcerror = 0;
1406 padapter->drv_rx_cnt_drop = 0;
1407 #endif
1408
1409 rtw_init_pwrctrl_priv(padapter);
1410 #ifdef CONFIG_WOWLAN
1411 rtw_init_wow(padapter);
1412 #endif /* CONFIG_WOWLAN */
1413
1414 /* _rtw_memset((u8 *)&padapter->qospriv, 0, sizeof (struct qos_priv)); */ /* move to mlme_priv */
1415
1416 #ifdef CONFIG_WAPI_SUPPORT
1417 padapter->WapiSupport = true; /* set true temp, will revise according to Efuse or Registry value later. */
1418 rtw_wapi_init(padapter);
1419 #endif
1420
1421 #ifdef CONFIG_BR_EXT
1422 _rtw_spinlock_init(&padapter->br_ext_lock);
1423 #endif /* CONFIG_BR_EXT */
1424
1425 #ifdef CONFIG_RTW_80211K
1426 rtw_init_rm(padapter);
1427 #endif
1428
1429 #ifdef CONFIG_RTW_CFGVENDOR_RANDOM_MAC_OUI
1430 _rtw_memset(pwdev_priv->pno_mac_addr, 0xFF, ETH_ALEN);
1431 #endif
1432
1433 #ifdef CONFIG_STA_CMD_DISPR
1434 rtw_connect_req_init(padapter);
1435 rtw_disconnect_req_init(padapter);
1436 #endif /* CONFIG_STA_CMD_DISPR */
1437
1438 exit:
1439
1440 return ret8;
1441
1442 }
1443
1444 #ifdef CONFIG_WOWLAN
1445 void rtw_cancel_dynamic_chk_timer(_adapter *padapter)
1446 {
1447 #if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
1448 _cancel_timer_ex(&adapter_to_dvobj(padapter)->dynamic_chk_timer);
1449 #endif
1450 }
1451 #endif
1452
1453 void rtw_cancel_all_timer(_adapter *padapter)
1454 {
1455
1456 /*_cancel_timer_ex(&padapter->mlmepriv.assoc_timer);*/
1457 cancel_assoc_timer(&padapter->mlmepriv);
1458
1459 _cancel_timer_ex(&padapter->mlmepriv.scan_to_timer);
1460
1461 #ifdef CONFIG_DFS_MASTER
1462 _cancel_timer_ex(&adapter_to_rfctl(padapter)->radar_detect_timer);
1463 #endif
1464
1465 #if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
1466 _cancel_timer_ex(&adapter_to_dvobj(padapter)->dynamic_chk_timer);
1467 #endif
1468
1469 #ifdef CONFIG_RTW_SW_LED
1470 /* cancel sw led timer */
1471 rtw_hal_sw_led_deinit(padapter);
1472 #endif
1473 #ifdef CONFIG_POWER_SAVING
1474 _cancel_timer_ex(&(adapter_to_pwrctl(padapter)->pwr_state_check_timer));
1475 #endif
1476
1477 #ifdef CONFIG_TX_AMSDU
1478 _cancel_timer_ex(&padapter->xmitpriv.amsdu_bk_timer);
1479 _cancel_timer_ex(&padapter->xmitpriv.amsdu_be_timer);
1480 _cancel_timer_ex(&padapter->xmitpriv.amsdu_vo_timer);
1481 _cancel_timer_ex(&padapter->xmitpriv.amsdu_vi_timer);
1482 #endif
1483
1484 #ifdef CONFIG_SET_SCAN_DENY_TIMER
1485 _cancel_timer_ex(&padapter->mlmepriv.set_scan_deny_timer);
1486 rtw_clear_scan_deny(padapter);
1487 #endif
1488 #ifdef CONFIG_SIGNAL_STAT_PROCESS
1489 _cancel_timer_ex(&padapter->recvinfo.signal_stat_timer);
1490 #endif
1491 #ifdef CONFIG_LPS_RPWM_TIMER
1492 _cancel_timer_ex(&(adapter_to_pwrctl(padapter)->pwr_rpwm_timer));
1493 #endif /* CONFIG_LPS_RPWM_TIMER */
1494
1495 #ifdef CONFIG_RTW_TOKEN_BASED_XMIT
1496 _cancel_timer_ex(&padapter->mlmeextpriv.tbtx_xmit_timer);
1497 _cancel_timer_ex(&padapter->mlmeextpriv.tbtx_token_dispatch_timer);
1498 #endif
1499
1500 #ifdef CONFIG_PLATFORM_FS_MX61
1501 msleep(50);
1502 #endif
1503 }
1504
1505 u8 rtw_free_drv_sw(_adapter *padapter)
1506 {
1507
1508 #ifdef CONFIG_WAPI_SUPPORT
1509 rtw_wapi_free(padapter);
1510 #endif
1511
1512 /* we can call rtw_p2p_enable here, but: */
1513 /* 1. rtw_p2p_enable may have IO operation */
1514 /* 2. rtw_p2p_enable is bundled with wext interface */
1515 #ifdef CONFIG_P2P
1516 {
1517 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
1518 if (!rtw_p2p_chk_role(pwdinfo, P2P_ROLE_DISABLE)) {
1519 rtw_p2p_set_role(pwdinfo, P2P_ROLE_DISABLE);
1520 }
1521 }
1522 #endif
1523 /* add for CONFIG_IEEE80211W, none 11w also can use */
1524 _rtw_spinlock_free(&padapter->security_key_mutex);
1525
1526 #ifdef CONFIG_BR_EXT
1527 _rtw_spinlock_free(&padapter->br_ext_lock);
1528 #endif /* CONFIG_BR_EXT */
1529
1530 free_mlme_ext_priv(&padapter->mlmeextpriv);
1531
1532 #ifdef CONFIG_TDLS
1533 /* rtw_free_tdls_info(&padapter->tdlsinfo); */
1534 #endif /* CONFIG_TDLS */
1535
1536 #ifdef CONFIG_RTW_80211K
1537 rtw_free_rm_priv(padapter);
1538 #endif
1539
1540 rtw_free_mlme_priv(&padapter->mlmepriv);
1541 #ifdef CONFIG_STA_CMD_DISPR
1542 rtw_connect_req_free(padapter);
1543 rtw_disconnect_req_free(padapter);
1544 #endif /* CONFIG_STA_CMD_DISPR */
1545
1546 if (is_primary_adapter(padapter))
1547 rtw_rfctl_deinit(adapter_to_dvobj(padapter));
1548
1549 /* free_io_queue(padapter); */
1550
1551 _rtw_free_xmit_priv(&padapter->xmitpriv);
1552
1553 _rtw_free_sta_priv(&padapter->stapriv); /* will free bcmc_stainfo here */
1554
1555 rtw_free_pwrctrl_priv(padapter);
1556 #ifdef CONFIG_WOWLAN
1557 rtw_free_wow(padapter);
1558 #endif /* CONFIG_WOWLAN */
1559
1560 /* rtw_mfree((void *)padapter, sizeof (padapter)); */
1561
1562 return _SUCCESS;
1563
1564 }
1565 void rtw_drv_stop_prim_iface(_adapter *adapter)
1566 {
1567 struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
1568 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(adapter);
1569 struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
1570 struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
1571
1572 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
1573 rtw_disassoc_cmd(adapter, 0, RTW_CMDF_DIRECTLY|RTW_CMDF_WAIT_ACK);
1574
1575 #ifdef CONFIG_AP_MODE
1576 if (MLME_IS_AP(adapter) || MLME_IS_MESH(adapter)) {
1577 free_mlme_ap_info(adapter);
1578 #ifdef CONFIG_HOSTAPD_MLME
1579 hostapd_mode_unload(adapter);
1580 #endif
1581 }
1582 #endif
1583
1584 RTW_INFO("==> "FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(adapter));
1585
1586 if (adapter->netif_up == _TRUE) {
1587 #ifdef CONFIG_XMIT_ACK
1588 if (adapter->xmitpriv.ack_tx)
1589 rtw_ack_tx_done(&adapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
1590 #endif
1591 rtw_hw_iface_deinit(adapter);
1592 if (!pwrctl->bInSuspend)
1593 adapter->netif_up = _FALSE;
1594 }
1595 #if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
1596 rtw_stop_drv_threads(adapter);
1597
1598 if (ATOMIC_READ(&(pcmdpriv->cmdthd_running)) == _TRUE) {
1599 RTW_ERR("cmd_thread not stop !!\n");
1600 rtw_warn_on(1);
1601 }
1602 #endif
1603
1604 /* check the status of IPS */
1605 if (rtw_hal_check_ips_status(adapter) == _TRUE || pwrctl->rf_pwrstate == rf_off) { /* check HW status and SW state */
1606 RTW_PRINT("%s: driver in IPS-FWLPS\n", __func__);
1607 pdbgpriv->dbg_dev_unload_inIPS_cnt++;
1608 } else
1609 RTW_PRINT("%s: driver not in IPS\n", __func__);
1610
1611 rtw_cancel_all_timer(adapter);
1612 RTW_INFO("<== "FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(adapter));
1613
1614 }
1615
1616 #ifdef CONFIG_CONCURRENT_MODE
1617 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29))
1618 static const struct net_device_ops rtw_netdev_vir_if_ops = {
1619 .ndo_init = rtw_ndev_init,
1620 .ndo_uninit = rtw_ndev_uninit,
1621 .ndo_open = netdev_open,
1622 .ndo_stop = netdev_close,
1623 .ndo_start_xmit = rtw_xmit_entry,
1624 .ndo_set_mac_address = rtw_net_set_mac_address,
1625 .ndo_get_stats = rtw_net_get_stats,
1626 .ndo_do_ioctl = rtw_ioctl,
1627 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
1628 .ndo_select_queue = rtw_select_queue,
1629 #endif
1630 };
1631 #endif
1632
1633 static void rtw_hook_vir_if_ops(struct net_device *ndev)
1634 {
1635 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29))
1636 ndev->netdev_ops = &rtw_netdev_vir_if_ops;
1637 #else
1638 ndev->init = rtw_ndev_init;
1639 ndev->uninit = rtw_ndev_uninit;
1640 ndev->open = netdev_open;
1641 ndev->stop = netdev_close;
1642
1643 ndev->set_mac_address = rtw_net_set_mac_address;
1644 #endif
1645 }
1646 static _adapter *rtw_drv_add_vir_if(struct dvobj_priv *dvobj)
1647 {
1648 int res = _FAIL;
1649 _adapter *padapter = NULL;
1650 _adapter *primary_padapter = dvobj_get_primary_adapter(dvobj);
1651 u8 mac[ETH_ALEN];
1652 #ifdef CONFIG_MI_UNIQUE_MACADDR_BIT
1653 u32 mi_unique_macaddr_bit = 0;
1654 bool is_uniq_macaddr = _FALSE;
1655 u8 i;
1656 #endif
1657
1658 /****** init adapter ******/
1659 padapter = (_adapter *)rtw_zvmalloc(sizeof(*padapter));
1660 if (padapter == NULL)
1661 goto exit;
1662
1663 _rtw_memcpy(padapter, primary_padapter, sizeof(_adapter));
1664 #ifdef CONFIG_STA_CMD_DISPR
1665 /* Reset not proper variables value which copied from primary adapter */
1666 /* Check rtw_connect_req_init() & rtw_disconnect_req_init() */
1667 padapter->connect_state = CONNECT_ST_NOT_READY;
1668 #endif
1669
1670 if (rtw_load_registry(padapter) != _SUCCESS)
1671 goto free_adapter;
1672
1673 padapter->netif_up = _FALSE;
1674 padapter->dir_dev = NULL;
1675 padapter->dir_odm = NULL;
1676
1677 /*set adapter_type/iface type*/
1678 padapter->isprimary = _FALSE;
1679 padapter->adapter_type = VIRTUAL_ADAPTER;
1680
1681 padapter->hw_port = HW_PORT1;
1682
1683 /****** hook vir if into dvobj ******/
1684 padapter->iface_id = dvobj->iface_nums;
1685 dvobj->padapters[dvobj->iface_nums++] = padapter;
1686
1687 /*init drv data*/
1688 if (rtw_init_drv_sw(padapter) != _SUCCESS)
1689 goto free_drv_sw;
1690
1691
1692 /*get mac address from primary_padapter*/
1693 _rtw_memcpy(mac, adapter_mac_addr(primary_padapter), ETH_ALEN);
1694
1695 #ifdef CONFIG_MI_UNIQUE_MACADDR_BIT
1696 mi_unique_macaddr_bit = BIT(CONFIG_MI_UNIQUE_MACADDR_BIT) >> 24;
1697 /* Find out CONFIG_MI_UNIQUE_MACADDR_BIT in which nic specific byte */
1698 for(i = 3; i < 6; i++) {
1699 if(((mi_unique_macaddr_bit >> 8) == 0) &&
1700 ((mac[i] & (u8)mi_unique_macaddr_bit) == 0)) {
1701 is_uniq_macaddr = _TRUE;
1702
1703 RTW_INFO("%s() "MAC_FMT" : BIT%u is zero\n",
1704 __func__, MAC_ARG(mac), CONFIG_MI_UNIQUE_MACADDR_BIT);
1705 break;
1706 }
1707 mi_unique_macaddr_bit >>= 8;
1708 }
1709
1710 if(is_uniq_macaddr) {
1711 /* IFACE_ID1/IFACE_ID3 : set locally administered bit */
1712 if(padapter->iface_id & BIT(0))
1713 mac[0] |= BIT(1);
1714 /* IFACE_ID2/IFACE_ID3 : set bit(CONFIG_MI_UNIQUE_MACADDR_BIT) */
1715 if(padapter->iface_id >> 1)
1716 mac[i] |= (u8)mi_unique_macaddr_bit;
1717 } else
1718 #endif
1719 {
1720 /*
1721 * If the BIT1 is 0, the address is universally administered.
1722 * If it is 1, the address is locally administered
1723 */
1724 mac[0] |= BIT(1);
1725 if (padapter->iface_id > IFACE_ID1)
1726 mac[0] ^= ((padapter->iface_id) << 2);
1727 }
1728
1729 _rtw_memcpy(adapter_mac_addr(padapter), mac, ETH_ALEN);
1730
1731 RTW_INFO("%s if%d mac_addr : "MAC_FMT"\n", __func__, padapter->iface_id + 1, MAC_ARG(adapter_mac_addr(padapter)));
1732
1733 rtw_led_set_ctl_en_mask_virtual(padapter);
1734 rtw_led_set_iface_en(padapter, 1);
1735
1736 res = _SUCCESS;
1737
1738 free_drv_sw:
1739 if (res != _SUCCESS && padapter)
1740 rtw_free_drv_sw(padapter);
1741 free_adapter:
1742 if (res != _SUCCESS && padapter) {
1743 rtw_vmfree((u8 *)padapter, sizeof(*padapter));
1744 padapter = NULL;
1745 }
1746 exit:
1747 return padapter;
1748 }
1749 u8 rtw_drv_add_vir_ifaces(struct dvobj_priv *dvobj)
1750 {
1751 u8 i;
1752 u8 rst = _FAIL;
1753
1754 if (dvobj->virtual_iface_num > (CONFIG_IFACE_NUMBER - 1))
1755 dvobj->virtual_iface_num = (CONFIG_IFACE_NUMBER - 1);
1756
1757 for (i = 0; i < dvobj->virtual_iface_num; i++) {
1758 if (rtw_drv_add_vir_if(dvobj) == NULL) {
1759 RTW_ERR("rtw_drv_add_vir_if failed! (%d)\n", i);
1760 goto _exit;
1761 }
1762 }
1763 rst = _SUCCESS;
1764 _exit:
1765 return rst;
1766 }
1767
1768 static void rtw_drv_stop_vir_if(_adapter *padapter)
1769 {
1770 struct net_device *pnetdev = NULL;
1771 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1772 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
1773
1774 if (padapter == NULL)
1775 return;
1776 RTW_INFO(FUNC_ADPT_FMT" enter\n", FUNC_ADPT_ARG(padapter));
1777
1778 pnetdev = padapter->pnetdev;
1779
1780 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE)
1781 rtw_disassoc_cmd(padapter, 0, RTW_CMDF_DIRECTLY|RTW_CMDF_WAIT_ACK);
1782
1783 #ifdef CONFIG_AP_MODE
1784 if (MLME_IS_AP(padapter) || MLME_IS_MESH(padapter)) {
1785 free_mlme_ap_info(padapter);
1786 #ifdef CONFIG_HOSTAPD_MLME
1787 hostapd_mode_unload(padapter);
1788 #endif
1789 }
1790 #endif
1791
1792 if (padapter->netif_up == _TRUE) {
1793 #ifdef CONFIG_XMIT_ACK
1794 if (padapter->xmitpriv.ack_tx)
1795 rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
1796 #endif
1797 rtw_hw_iface_deinit(padapter);
1798 if (!pwrctl->bInSuspend)
1799 padapter->netif_up = _FALSE;
1800 }
1801 #if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
1802 rtw_stop_drv_threads(padapter);
1803 #endif
1804 /* cancel timer after thread stop */
1805 rtw_cancel_all_timer(padapter);
1806 }
1807 void rtw_drv_stop_vir_ifaces(struct dvobj_priv *dvobj)
1808 {
1809 int i;
1810
1811 for (i = VIF_START_ID; i < dvobj->iface_nums; i++)
1812 rtw_drv_stop_vir_if(dvobj->padapters[i]);
1813 }
1814
1815 static void rtw_drv_free_vir_if(_adapter *padapter)
1816 {
1817 if (padapter == NULL)
1818 return;
1819
1820 RTW_INFO(FUNC_ADPT_FMT"\n", FUNC_ADPT_ARG(padapter));
1821 rtw_free_drv_sw(padapter);
1822
1823 /* TODO: use rtw_os_ndevs_deinit instead at the first stage of driver's dev deinit function */
1824 rtw_os_ndev_free(padapter);
1825
1826 rtw_vmfree((u8 *)padapter, sizeof(_adapter));
1827 }
1828 void rtw_drv_free_vir_ifaces(struct dvobj_priv *dvobj)
1829 {
1830 int i;
1831
1832 for (i = VIF_START_ID; i < dvobj->iface_nums; i++)
1833 rtw_drv_free_vir_if(dvobj->padapters[i]);
1834 }
1835
1836
1837 #endif /*end of CONFIG_CONCURRENT_MODE*/
1838
1839 /* IPv4, IPv6 IP addr notifier */
1840 static int rtw_inetaddr_notifier_call(struct notifier_block *nb,
1841 unsigned long action, void *data)
1842 {
1843 struct in_ifaddr *ifa = (struct in_ifaddr *)data;
1844 struct net_device *ndev;
1845 struct mlme_ext_priv *pmlmeext = NULL;
1846 struct mlme_ext_info *pmlmeinfo = NULL;
1847 _adapter *adapter = NULL;
1848
1849 if (!ifa || !ifa->ifa_dev || !ifa->ifa_dev->dev)
1850 return NOTIFY_DONE;
1851
1852 ndev = ifa->ifa_dev->dev;
1853
1854 if (!is_rtw_ndev(ndev))
1855 return NOTIFY_DONE;
1856
1857 adapter = (_adapter *)rtw_netdev_priv(ifa->ifa_dev->dev);
1858
1859 if (adapter == NULL)
1860 return NOTIFY_DONE;
1861
1862 pmlmeext = &adapter->mlmeextpriv;
1863 pmlmeinfo = &pmlmeext->mlmext_info;
1864
1865 switch (action) {
1866 case NETDEV_UP:
1867 _rtw_memcpy(pmlmeinfo->ip_addr, &ifa->ifa_address,
1868 RTW_IP_ADDR_LEN);
1869 RTW_DBG("%s[%s]: up IP: %pI4\n", __func__,
1870 ifa->ifa_label, pmlmeinfo->ip_addr);
1871 break;
1872 case NETDEV_DOWN:
1873 _rtw_memset(pmlmeinfo->ip_addr, 0, RTW_IP_ADDR_LEN);
1874 RTW_DBG("%s[%s]: down IP: %pI4\n", __func__,
1875 ifa->ifa_label, pmlmeinfo->ip_addr);
1876 break;
1877 default:
1878 RTW_DBG("%s: default action\n", __func__);
1879 break;
1880 }
1881 return NOTIFY_DONE;
1882 }
1883
1884 #ifdef CONFIG_IPV6
1885 static int rtw_inet6addr_notifier_call(struct notifier_block *nb,
1886 unsigned long action, void *data)
1887 {
1888 struct inet6_ifaddr *inet6_ifa = data;
1889 struct net_device *ndev;
1890 struct pwrctrl_priv *pwrctl = NULL;
1891 struct mlme_ext_priv *pmlmeext = NULL;
1892 struct mlme_ext_info *pmlmeinfo = NULL;
1893 _adapter *adapter = NULL;
1894
1895 if (!inet6_ifa || !inet6_ifa->idev || !inet6_ifa->idev->dev)
1896 return NOTIFY_DONE;
1897
1898 ndev = inet6_ifa->idev->dev;
1899
1900 if (!is_rtw_ndev(ndev))
1901 return NOTIFY_DONE;
1902
1903 adapter = (_adapter *)rtw_netdev_priv(inet6_ifa->idev->dev);
1904
1905 if (adapter == NULL)
1906 return NOTIFY_DONE;
1907
1908 pmlmeext = &adapter->mlmeextpriv;
1909 pmlmeinfo = &pmlmeext->mlmext_info;
1910 pwrctl = adapter_to_pwrctl(adapter);
1911
1912 pmlmeext = &adapter->mlmeextpriv;
1913 pmlmeinfo = &pmlmeext->mlmext_info;
1914
1915 switch (action) {
1916 case NETDEV_UP:
1917 #ifdef CONFIG_WOWLAN
1918 pwrctl->wowlan_ns_offload_en = _TRUE;
1919 #endif
1920 _rtw_memcpy(pmlmeinfo->ip6_addr, &inet6_ifa->addr,
1921 RTW_IPv6_ADDR_LEN);
1922 RTW_DBG("%s: up IPv6 addrs: %pI6\n", __func__,
1923 pmlmeinfo->ip6_addr);
1924 break;
1925 case NETDEV_DOWN:
1926 #ifdef CONFIG_WOWLAN
1927 pwrctl->wowlan_ns_offload_en = _FALSE;
1928 #endif
1929 _rtw_memset(pmlmeinfo->ip6_addr, 0, RTW_IPv6_ADDR_LEN);
1930 RTW_DBG("%s: down IPv6 addrs: %pI6\n", __func__,
1931 pmlmeinfo->ip6_addr);
1932 break;
1933 default:
1934 RTW_DBG("%s: default action\n", __func__);
1935 break;
1936 }
1937 return NOTIFY_DONE;
1938 }
1939 #endif
1940
1941 static struct notifier_block rtw_inetaddr_notifier = {
1942 .notifier_call = rtw_inetaddr_notifier_call
1943 };
1944
1945 #ifdef CONFIG_IPV6
1946 static struct notifier_block rtw_inet6addr_notifier = {
1947 .notifier_call = rtw_inet6addr_notifier_call
1948 };
1949 #endif
1950
1951 void rtw_inetaddr_notifier_register(void)
1952 {
1953 RTW_INFO("%s\n", __func__);
1954 register_inetaddr_notifier(&rtw_inetaddr_notifier);
1955 #ifdef CONFIG_IPV6
1956 register_inet6addr_notifier(&rtw_inet6addr_notifier);
1957 #endif
1958 }
1959
1960 void rtw_inetaddr_notifier_unregister(void)
1961 {
1962 RTW_INFO("%s\n", __func__);
1963 unregister_inetaddr_notifier(&rtw_inetaddr_notifier);
1964 #ifdef CONFIG_IPV6
1965 unregister_inet6addr_notifier(&rtw_inet6addr_notifier);
1966 #endif
1967 }
1968
1969 int rtw_os_ndevs_register(struct dvobj_priv *dvobj)
1970 {
1971 int i, status = _SUCCESS;
1972 struct registry_priv *regsty = dvobj_to_regsty(dvobj);
1973 _adapter *adapter;
1974
1975 #if defined(CONFIG_IOCTL_CFG80211)
1976 if (rtw_cfg80211_dev_res_register(dvobj) != _SUCCESS) {
1977 rtw_warn_on(1);
1978 return _FAIL;
1979 }
1980 #endif
1981
1982 for (i = 0; i < dvobj->iface_nums; i++) {
1983
1984 if (i >= CONFIG_IFACE_NUMBER) {
1985 RTW_ERR("%s %d >= CONFIG_IFACE_NUMBER(%d)\n", __func__, i, CONFIG_IFACE_NUMBER);
1986 rtw_warn_on(1);
1987 continue;
1988 }
1989
1990 adapter = dvobj->padapters[i];
1991 if (adapter) {
1992 char *name;
1993
1994 #ifdef CONFIG_RTW_DYNAMIC_NDEV
1995 if (!is_primary_adapter(adapter) &&
1996 (i >= CONFIG_RTW_STATIC_NDEV_NUM))
1997 break;
1998 #endif
1999
2000 if (adapter->iface_id == IFACE_ID0)
2001 name = regsty->ifname;
2002 else if (adapter->iface_id == IFACE_ID1)
2003 name = regsty->if2name;
2004 else
2005 name = "wlan%d";
2006
2007 status = rtw_os_ndev_register(adapter, name);
2008
2009 if (status != _SUCCESS) {
2010 rtw_warn_on(1);
2011 break;
2012 }
2013 }
2014 }
2015
2016 if (status != _SUCCESS) {
2017 for (; i >= 0; i--) {
2018 adapter = dvobj->padapters[i];
2019 if (adapter)
2020 rtw_os_ndev_unregister(adapter);
2021 }
2022 }
2023
2024 #if defined(CONFIG_IOCTL_CFG80211)
2025 if (status != _SUCCESS)
2026 rtw_cfg80211_dev_res_unregister(dvobj);
2027 #endif
2028 return status;
2029 }
2030
2031 void rtw_os_ndevs_unregister(struct dvobj_priv *dvobj)
2032 {
2033 int i;
2034 _adapter *adapter = NULL;
2035
2036 for (i = 0; i < dvobj->iface_nums; i++) {
2037 adapter = dvobj->padapters[i];
2038
2039 if (adapter == NULL)
2040 continue;
2041
2042 rtw_os_ndev_unregister(adapter);
2043 }
2044
2045 #if defined(CONFIG_IOCTL_CFG80211)
2046 rtw_cfg80211_dev_res_unregister(dvobj);
2047 #endif
2048 }
2049
2050 /**
2051 * rtw_os_ndevs_init - Allocate and register OS layer net devices and relating structures for @dvobj
2052 * @dvobj: the dvobj on which this function applies
2053 *
2054 * Returns:
2055 * _SUCCESS or _FAIL
2056 */
2057 int rtw_os_ndevs_init(struct dvobj_priv *dvobj)
2058 {
2059 int ret = _FAIL;
2060
2061 if (rtw_os_ndevs_alloc(dvobj) != _SUCCESS)
2062 goto exit;
2063
2064 if (rtw_os_ndevs_register(dvobj) != _SUCCESS)
2065 goto os_ndevs_free;
2066
2067 ret = _SUCCESS;
2068
2069 os_ndevs_free:
2070 if (ret != _SUCCESS)
2071 rtw_os_ndevs_free(dvobj);
2072 exit:
2073 return ret;
2074 }
2075
2076 /**
2077 * rtw_os_ndevs_deinit - Unregister and free OS layer net devices and relating structures for @dvobj
2078 * @dvobj: the dvobj on which this function applies
2079 */
2080 void rtw_os_ndevs_deinit(struct dvobj_priv *dvobj)
2081 {
2082 rtw_os_ndevs_unregister(dvobj);
2083 rtw_os_ndevs_free(dvobj);
2084 }
2085
2086 #ifdef CONFIG_BR_EXT
2087 void netdev_br_init(struct net_device *netdev)
2088 {
2089 _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
2090
2091 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2092 rcu_read_lock();
2093 #endif
2094
2095 /* if(check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_ADHOC_STATE) == _TRUE) */
2096 {
2097 /* struct net_bridge *br = netdev->br_port->br; */ /* ->dev->dev_addr; */
2098 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 35))
2099 if (netdev->br_port)
2100 #else
2101 if (rcu_dereference(adapter->pnetdev->rx_handler_data))
2102 #endif
2103 {
2104 struct net_device *br_netdev;
2105
2106 br_netdev = rtw_get_bridge_ndev_by_name(CONFIG_BR_EXT_BRNAME);
2107 if (br_netdev) {
2108 _rtw_memcpy(adapter->br_mac, br_netdev->dev_addr, ETH_ALEN);
2109 dev_put(br_netdev);
2110 RTW_INFO(FUNC_NDEV_FMT" bind bridge dev "NDEV_FMT"("MAC_FMT")\n"
2111 , FUNC_NDEV_ARG(netdev), NDEV_ARG(br_netdev), MAC_ARG(br_netdev->dev_addr));
2112 } else {
2113 RTW_INFO(FUNC_NDEV_FMT" can't get bridge dev by name \"%s\"\n"
2114 , FUNC_NDEV_ARG(netdev), CONFIG_BR_EXT_BRNAME);
2115 }
2116 }
2117
2118 adapter->ethBrExtInfo.addPPPoETag = 1;
2119 }
2120
2121 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 35))
2122 rcu_read_unlock();
2123 #endif
2124 }
2125 #endif /* CONFIG_BR_EXT */
2126
2127 #if 0
2128 /*FPGA_test*/
2129 static int _drv_enable_trx(struct dvobj_priv *d)
2130 {
2131 struct _ADAPTER *adapter;
2132 u32 status;
2133
2134
2135 adapter = dvobj_get_primary_adapter(d);
2136 if (adapter->netif_up == _FALSE) {
2137 status = rtw_mi_start_drv_threads(adapter);
2138
2139 if (status == _FAIL) {
2140 RTW_ERR("%s: Start threads Failed!\n", __FUNCTION__);
2141 return -1;
2142 }
2143 }
2144
2145
2146 return 0;
2147 }
2148 #endif
2149
2150 static int _netdev_open(struct net_device *pnetdev)
2151 {
2152 uint status;
2153 _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2154 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
2155
2156
2157 RTW_INFO(FUNC_NDEV_FMT" start\n", FUNC_NDEV_ARG(pnetdev));
2158
2159 #ifdef DIRTY_FOR_WORK
2160 if(pnetdev->priv_flags & IFF_DONT_BRIDGE)
2161 {
2162 RTW_INFO("Unable to be bridged !! Unlock for this iface !!\n");
2163 pnetdev->priv_flags &= ~(IFF_DONT_BRIDGE);
2164 }
2165 #endif
2166
2167 if (!dev_is_hw_start(dvobj)) {
2168 dev_clr_surprise_removed(dvobj);
2169 dev_clr_drv_stopped(dvobj);
2170 RTW_ENABLE_FUNC(dvobj, DF_RX_BIT);
2171 RTW_ENABLE_FUNC(dvobj, DF_TX_BIT);
2172 status = rtw_hw_start(dvobj);
2173 if (status == _FAIL)
2174 goto netdev_open_error;
2175 rtw_led_control(padapter, LED_CTL_NO_LINK);
2176
2177 #if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
2178 if (0){
2179 _set_timer(&dvobj->dynamic_chk_timer, 2000);
2180 }
2181 #endif
2182 #if 0 /*CONFIG_CORE_THREAD*/
2183 _drv_enable_trx(dvobj);/*FPGA_test*/
2184 #endif
2185 }
2186
2187 #ifdef CONFIG_RTW_NAPI
2188 if(padapter->napi_state == NAPI_DISABLE) {
2189 napi_enable(&padapter->napi);
2190 padapter->napi_state = NAPI_ENABLE;
2191 }
2192 #endif
2193
2194 if (padapter->netif_up == _FALSE) {
2195 if (rtw_hw_iface_init(padapter) == _FAIL) {
2196 rtw_warn_on(1);
2197 goto netdev_open_error;
2198 }
2199
2200 /* rtw_netif_carrier_on(pnetdev); */ /* call this func when rtw_joinbss_event_callback return success */
2201 rtw_netif_wake_queue(pnetdev);
2202
2203 #ifdef CONFIG_BR_EXT
2204 if (is_primary_adapter(padapter))
2205 netdev_br_init(pnetdev);
2206 #endif /* CONFIG_BR_EXT */
2207
2208 padapter->netif_up = _TRUE;
2209 }
2210
2211 RTW_INFO(FUNC_NDEV_FMT" Success (netif_up=%d)\n", FUNC_NDEV_ARG(pnetdev), padapter->netif_up);
2212 return 0;
2213
2214 netdev_open_error:
2215 padapter->netif_up = _FALSE;
2216
2217 #ifdef CONFIG_RTW_NAPI
2218 if(padapter->napi_state == NAPI_ENABLE) {
2219 napi_disable(&padapter->napi);
2220 padapter->napi_state = NAPI_DISABLE;
2221 }
2222 #endif
2223
2224 rtw_netif_carrier_off(pnetdev);
2225 rtw_netif_stop_queue(pnetdev);
2226
2227 RTW_ERR(FUNC_NDEV_FMT" Failed!! (netif_up=%d)\n", FUNC_NDEV_ARG(pnetdev), padapter->netif_up);
2228
2229 return -1;
2230
2231 }
2232
2233 int netdev_open(struct net_device *pnetdev)
2234 {
2235 int ret = _FALSE;
2236 _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2237 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
2238
2239 if (pwrctrlpriv->bInSuspend == _TRUE) {
2240 RTW_INFO(" [WARN] "ADPT_FMT" %s failed, bInSuspend=%d\n", ADPT_ARG(padapter), __func__, pwrctrlpriv->bInSuspend);
2241 return 0;
2242 }
2243
2244 RTW_INFO(FUNC_NDEV_FMT" , netif_up=%d\n", FUNC_NDEV_ARG(pnetdev), padapter->netif_up);
2245 /*rtw_dump_stack();*/
2246 _rtw_mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->hw_init_mutex));
2247 ret = _netdev_open(pnetdev);
2248 _rtw_mutex_unlock(&(adapter_to_dvobj(padapter)->hw_init_mutex));
2249
2250
2251 #ifdef CONFIG_AUTO_AP_MODE
2252 if (padapter->iface_id == IFACE_ID2)
2253 rtw_start_auto_ap(padapter);
2254 #endif
2255
2256 return ret;
2257 }
2258
2259 #ifdef CONFIG_IPS
2260 int ips_netdrv_open(_adapter *padapter)
2261 {
2262 int status = _SUCCESS;
2263 /* struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter); */
2264 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
2265
2266
2267 RTW_INFO("===> %s.........\n", __FUNCTION__);
2268
2269
2270 dev_clr_drv_stopped(dvobj);
2271 /* padapter->netif_up = _TRUE; */
2272 if (!rtw_hw_is_init_completed(dvobj)) {
2273 status = rtw_hw_start(dvobj);
2274 if (status == _FAIL) {
2275 goto netdev_open_error;
2276 }
2277 rtw_mi_hal_iface_init(padapter);
2278 }
2279 #if 0
2280 rtw_mi_set_mac_addr(padapter);
2281 #endif
2282
2283 #if 0 /*ndef CONFIG_IPS_CHECK_IN_WD*/
2284 rtw_set_pwr_state_check_timer(adapter_to_pwrctl(padapter));
2285 #endif
2286 #if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
2287 _set_timer(&dvobj->dynamic_chk_timer, 2000);
2288 #endif
2289 return _SUCCESS;
2290
2291 netdev_open_error:
2292 /* padapter->bup = _FALSE; */
2293 RTW_INFO("-ips_netdrv_open - drv_open failure, netif_up=%d\n", padapter->netif_up);
2294
2295 return _FAIL;
2296 }
2297
2298 int rtw_ips_pwr_up(_adapter *padapter)
2299 {
2300 int result;
2301 #if defined(CONFIG_SWLPS_IN_IPS) || defined(CONFIG_FWLPS_IN_IPS)
2302 #ifdef DBG_CONFIG_ERROR_DETECT
2303 HAL_DATA_TYPE *pHalData = GET_PHL_COM(adapter_to_dvobj(padapter));
2304 struct sreset_priv *psrtpriv = &pHalData->srestpriv;
2305 #endif/* #ifdef DBG_CONFIG_ERROR_DETECT */
2306 #endif /* defined(CONFIG_SWLPS_IN_IPS) || defined(CONFIG_FWLPS_IN_IPS) */
2307 systime start_time = rtw_get_current_time();
2308 RTW_INFO("===> rtw_ips_pwr_up..............\n");
2309
2310 #if defined(CONFIG_SWLPS_IN_IPS) || defined(CONFIG_FWLPS_IN_IPS)
2311 #ifdef DBG_CONFIG_ERROR_DETECT
2312 if (psrtpriv->silent_reset_inprogress == _TRUE)
2313 #endif/* #ifdef DBG_CONFIG_ERROR_DETECT */
2314 #endif /* defined(CONFIG_SWLPS_IN_IPS) || defined(CONFIG_FWLPS_IN_IPS) */
2315 rtw_reset_drv_sw(padapter);
2316
2317 result = ips_netdrv_open(padapter);
2318
2319 rtw_led_control(padapter, LED_CTL_NO_LINK);
2320
2321 RTW_INFO("<=== rtw_ips_pwr_up.............. in %dms\n", rtw_get_passing_time_ms(start_time));
2322 return result;
2323
2324 }
2325
2326 void rtw_ips_pwr_down(_adapter *padapter)
2327 {
2328 systime start_time = rtw_get_current_time();
2329 RTW_INFO("===> rtw_ips_pwr_down...................\n");
2330
2331
2332 rtw_ips_dev_unload(padapter);
2333 RTW_INFO("<=== rtw_ips_pwr_down..................... in %dms\n", rtw_get_passing_time_ms(start_time));
2334 }
2335 #endif
2336 void rtw_ips_dev_unload(_adapter *padapter)
2337 {
2338 #if defined(CONFIG_SWLPS_IN_IPS) || defined(CONFIG_FWLPS_IN_IPS)
2339 #ifdef DBG_CONFIG_ERROR_DETECT
2340 HAL_DATA_TYPE *pHalData = GET_PHL_COM(adapter_to_dvobj(padapter));
2341 struct sreset_priv *psrtpriv = &pHalData->srestpriv;
2342 #endif/* #ifdef DBG_CONFIG_ERROR_DETECT */
2343 #endif /* defined(CONFIG_SWLPS_IN_IPS) || defined(CONFIG_FWLPS_IN_IPS) */
2344 RTW_INFO("====> %s...\n", __FUNCTION__);
2345
2346
2347 #if defined(CONFIG_SWLPS_IN_IPS) || defined(CONFIG_FWLPS_IN_IPS)
2348 #ifdef DBG_CONFIG_ERROR_DETECT
2349 if (psrtpriv->silent_reset_inprogress == _TRUE)
2350 #endif /* #ifdef DBG_CONFIG_ERROR_DETECT */
2351 #endif /* defined(CONFIG_SWLPS_IN_IPS) || defined(CONFIG_FWLPS_IN_IPS) */
2352 {
2353 rtw_hal_set_hwreg(padapter, HW_VAR_FIFO_CLEARN_UP, 0);
2354 }
2355
2356 if (!dev_is_surprise_removed(adapter_to_dvobj(padapter)) &&
2357 rtw_hw_is_init_completed(adapter_to_dvobj(padapter)))
2358 rtw_hw_stop(adapter_to_dvobj(padapter));
2359
2360 }
2361
2362 int _pm_netdev_open(_adapter *padapter)
2363 {
2364 uint status;
2365 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
2366 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
2367 struct net_device *pnetdev = padapter->pnetdev;
2368
2369 RTW_INFO(FUNC_NDEV_FMT" start\n", FUNC_NDEV_ARG(pnetdev));
2370
2371 if (!rtw_hw_is_init_completed(dvobj)) { // ips
2372 dev_clr_surprise_removed(dvobj);
2373 dev_clr_drv_stopped(dvobj);
2374 status = rtw_hw_start(dvobj);
2375 if (status == _FAIL)
2376 goto netdev_open_error;
2377 rtw_led_control(padapter, LED_CTL_NO_LINK);
2378 #if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
2379 _set_timer(&dvobj->dynamic_chk_timer, 2000);
2380 #endif
2381
2382 #if 0 /*ndef CONFIG_IPS_CHECK_IN_WD*/
2383 rtw_set_pwr_state_check_timer(pwrctrlpriv);
2384 #endif /*CONFIG_IPS_CHECK_IN_WD*/
2385 }
2386
2387 /*if (padapter->netif_up == _FALSE) */
2388 {
2389 rtw_hw_iface_init(padapter);
2390
2391 padapter->netif_up = _TRUE;
2392 }
2393
2394 RTW_INFO(FUNC_NDEV_FMT" Success (netif_up=%d)\n", FUNC_NDEV_ARG(pnetdev), padapter->netif_up);
2395 return 0;
2396
2397 netdev_open_error:
2398 padapter->netif_up = _FALSE;
2399
2400 rtw_netif_carrier_off(pnetdev);
2401 rtw_netif_stop_queue(pnetdev);
2402
2403 RTW_ERR(FUNC_NDEV_FMT" Failed!! (netif_up=%d)\n", FUNC_NDEV_ARG(pnetdev), padapter->netif_up);
2404
2405 return -1;
2406
2407 }
2408 int _mi_pm_netdev_open(struct net_device *pnetdev)
2409 {
2410 int i;
2411 int status = 0;
2412 _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2413 _adapter *iface;
2414 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
2415
2416 for (i = 0; i < dvobj->iface_nums; i++) {
2417 iface = dvobj->padapters[i];
2418 if (iface->netif_up) {
2419 status = _pm_netdev_open(iface);
2420 if (status == -1) {
2421 RTW_ERR("%s failled\n", __func__);
2422 break;
2423 }
2424 }
2425 }
2426
2427 return status;
2428 }
2429
2430 int pm_netdev_open(struct net_device *pnetdev, u8 bnormal)
2431 {
2432 int status = 0;
2433
2434 _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2435
2436 if (_TRUE == bnormal) {
2437 _rtw_mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->hw_init_mutex));
2438 status = _mi_pm_netdev_open(pnetdev);
2439
2440 _rtw_mutex_unlock(&(adapter_to_dvobj(padapter)->hw_init_mutex));
2441 }
2442 #ifdef CONFIG_IPS
2443 else
2444 status = (_SUCCESS == ips_netdrv_open(padapter)) ? (0) : (-1);
2445 #endif
2446
2447 return status;
2448 }
2449
2450 static int netdev_close(struct net_device *pnetdev)
2451 {
2452 _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
2453 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
2454 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2455 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2456 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
2457 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
2458
2459 RTW_INFO(FUNC_NDEV_FMT" , netif_up=%d\n", FUNC_NDEV_ARG(pnetdev), padapter->netif_up);
2460
2461 pmlmepriv->LinkDetectInfo.bBusyTraffic = _FALSE;
2462
2463 rtw_scan_abort(padapter, 0); /* stop scanning process before wifi is going to down */
2464 #ifdef CONFIG_IOCTL_CFG80211
2465 rtw_cfg80211_wait_scan_req_empty(padapter, 200);
2466 /* padapter->rtw_wdev->iftype = NL80211_IFTYPE_MONITOR; */ /* set this at the end */
2467 #endif /* CONFIG_IOCTL_CFG80211 */
2468
2469 if (pwrctl->rf_pwrstate == rf_on) {
2470 RTW_INFO("netif_up=%d, hw_init_completed=%s\n",
2471 padapter->netif_up,
2472 rtw_hw_is_init_completed(dvobj) ? "_TRUE" : "_FALSE");
2473
2474 /* s1. */
2475 if (pnetdev)
2476 rtw_netif_stop_queue(pnetdev);
2477
2478 /* s2. */
2479 LeaveAllPowerSaveMode(padapter);
2480 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE)) {
2481 rtw_disassoc_cmd(padapter, 500, RTW_CMDF_WAIT_ACK);
2482 /* s2-2*/
2483 if (1
2484 #ifdef CONFIG_STA_CMD_DISPR
2485 && (MLME_IS_STA(padapter) == _FALSE)
2486 #endif /* CONFIG_STA_CMD_DISPR */
2487 )
2488 rtw_free_assoc_resources_cmd(padapter, _TRUE, RTW_CMDF_WAIT_ACK);
2489 /* s2-3. indicate disconnect to os */
2490 rtw_indicate_disconnect(padapter, 0, _FALSE);
2491 /* s2-4. */
2492 rtw_free_network_queue(padapter, _TRUE);
2493
2494 pmlmeinfo->disconnect_occurred_time = rtw_systime_to_ms(rtw_get_current_time());
2495 pmlmeinfo->disconnect_code = DISCONNECTION_BY_SYSTEM_DUE_TO_NET_DEVICE_DOWN;
2496 pmlmeinfo->wifi_reason_code = WLAN_REASON_DEAUTH_LEAVING;
2497 }
2498
2499 #ifdef CONFIG_STA_CMD_DISPR
2500 rtw_connect_abort_wait(padapter);
2501 rtw_disconnect_abort_wait(padapter);
2502 #endif /* CONFIG_STA_CMD_DISPR */
2503 }
2504
2505 #ifdef CONFIG_BR_EXT
2506 /* if (OPMODE & (WIFI_STATION_STATE | WIFI_ADHOC_STATE)) */
2507 {
2508 /* void nat25_db_cleanup(_adapter *priv); */
2509 nat25_db_cleanup(padapter);
2510 }
2511 #endif /* CONFIG_BR_EXT */
2512
2513 #ifdef CONFIG_P2P
2514 if (!rtw_p2p_chk_role(&padapter->wdinfo, P2P_ROLE_DISABLE))
2515 rtw_p2p_enable(padapter, P2P_ROLE_DISABLE);
2516 #endif /* CONFIG_P2P */
2517
2518 #ifdef CONFIG_WAPI_SUPPORT
2519 rtw_wapi_disable_tx(padapter);
2520 #endif
2521
2522 #ifdef CONFIG_RTW_NAPI
2523 if (padapter->napi_state == NAPI_ENABLE) {
2524 napi_disable(&padapter->napi);
2525 padapter->napi_state = NAPI_DISABLE;
2526 }
2527 #endif /* CONFIG_RTW_NAPI */
2528
2529 rtw_hw_iface_deinit(padapter);
2530 padapter->netif_up = _FALSE;
2531
2532 RTW_INFO("-871x_drv - drv_close, netif_up=%d\n", padapter->netif_up);
2533
2534 return 0;
2535
2536 }
2537
2538 int pm_netdev_close(struct net_device *pnetdev, u8 bnormal)
2539 {
2540 int status = 0;
2541
2542 status = netdev_close(pnetdev);
2543
2544 return status;
2545 }
2546
2547 void rtw_ndev_destructor(struct net_device *ndev)
2548 {
2549 RTW_INFO(FUNC_NDEV_FMT"\n", FUNC_NDEV_ARG(ndev));
2550
2551 #ifdef CONFIG_IOCTL_CFG80211
2552 if (ndev->ieee80211_ptr)
2553 rtw_mfree((u8 *)ndev->ieee80211_ptr, sizeof(struct wireless_dev));
2554 #endif
2555 free_netdev(ndev);
2556 }
2557
2558 #ifdef CONFIG_ARP_KEEP_ALIVE
2559 struct route_info {
2560 struct in_addr dst_addr;
2561 struct in_addr src_addr;
2562 struct in_addr gateway;
2563 unsigned int dev_index;
2564 };
2565
2566 static void parse_routes(struct nlmsghdr *nl_hdr, struct route_info *rt_info)
2567 {
2568 struct rtmsg *rt_msg;
2569 struct rtattr *rt_attr;
2570 int rt_len;
2571
2572 rt_msg = (struct rtmsg *) NLMSG_DATA(nl_hdr);
2573 if ((rt_msg->rtm_family != AF_INET) || (rt_msg->rtm_table != RT_TABLE_MAIN))
2574 return;
2575
2576 rt_attr = (struct rtattr *) RTM_RTA(rt_msg);
2577 rt_len = RTM_PAYLOAD(nl_hdr);
2578
2579 for (; RTA_OK(rt_attr, rt_len); rt_attr = RTA_NEXT(rt_attr, rt_len)) {
2580 switch (rt_attr->rta_type) {
2581 case RTA_OIF:
2582 rt_info->dev_index = *(int *) RTA_DATA(rt_attr);
2583 break;
2584 case RTA_GATEWAY:
2585 rt_info->gateway.s_addr = *(u_int *) RTA_DATA(rt_attr);
2586 break;
2587 case RTA_PREFSRC:
2588 rt_info->src_addr.s_addr = *(u_int *) RTA_DATA(rt_attr);
2589 break;
2590 case RTA_DST:
2591 rt_info->dst_addr.s_addr = *(u_int *) RTA_DATA(rt_attr);
2592 break;
2593 }
2594 }
2595 }
2596
2597 static int route_dump(u32 *gw_addr , int *gw_index)
2598 {
2599 int err = 0;
2600 struct socket *sock;
2601 struct {
2602 struct nlmsghdr nlh;
2603 struct rtgenmsg g;
2604 } req;
2605 struct msghdr msg;
2606 struct iovec iov;
2607 struct sockaddr_nl nladdr;
2608 mm_segment_t oldfs;
2609 char *pg;
2610 int size = 0;
2611
2612 err = sock_create(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE, &sock);
2613 if (err) {
2614 printk(": Could not create a datagram socket, error = %d\n", -ENXIO);
2615 return err;
2616 }
2617
2618 memset(&nladdr, 0, sizeof(nladdr));
2619 nladdr.nl_family = AF_NETLINK;
2620
2621 req.nlh.nlmsg_len = sizeof(req);
2622 req.nlh.nlmsg_type = RTM_GETROUTE;
2623 req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
2624 req.nlh.nlmsg_pid = 0;
2625 req.g.rtgen_family = AF_INET;
2626
2627 iov.iov_base = &req;
2628 iov.iov_len = sizeof(req);
2629
2630 msg.msg_name = &nladdr;
2631 msg.msg_namelen = sizeof(nladdr);
2632 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 19, 0))
2633 /* referece:sock_xmit in kernel code
2634 * WRITE for sock_sendmsg, READ for sock_recvmsg
2635 * third parameter for msg_iovlen
2636 * last parameter for iov_len
2637 */
2638 iov_iter_init(&msg.msg_iter, WRITE, &iov, 1, sizeof(req));
2639 #else
2640 msg.msg_iov = &iov;
2641 msg.msg_iovlen = 1;
2642 #endif
2643 msg.msg_control = NULL;
2644 msg.msg_controllen = 0;
2645 msg.msg_flags = MSG_DONTWAIT;
2646
2647 oldfs = get_fs();
2648 set_fs(KERNEL_DS);
2649 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0))
2650 err = sock_sendmsg(sock, &msg);
2651 #else
2652 err = sock_sendmsg(sock, &msg, sizeof(req));
2653 #endif
2654 set_fs(oldfs);
2655
2656 if (err < 0)
2657 goto out_sock;
2658
2659 pg = (char *) __get_free_page(GFP_KERNEL);
2660 if (pg == NULL) {
2661 err = -ENOMEM;
2662 goto out_sock;
2663 }
2664
2665 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
2666 restart:
2667 #endif
2668
2669 for (;;) {
2670 struct nlmsghdr *h;
2671
2672 iov.iov_base = pg;
2673 iov.iov_len = PAGE_SIZE;
2674
2675 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 19, 0))
2676 iov_iter_init(&msg.msg_iter, READ, &iov, 1, PAGE_SIZE);
2677 #endif
2678
2679 oldfs = get_fs();
2680 set_fs(KERNEL_DS);
2681 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 7, 0))
2682 err = sock_recvmsg(sock, &msg, MSG_DONTWAIT);
2683 #else
2684 err = sock_recvmsg(sock, &msg, PAGE_SIZE, MSG_DONTWAIT);
2685 #endif
2686 set_fs(oldfs);
2687
2688 if (err < 0)
2689 goto out_sock_pg;
2690
2691 if (msg.msg_flags & MSG_TRUNC) {
2692 err = -ENOBUFS;
2693 goto out_sock_pg;
2694 }
2695
2696 h = (struct nlmsghdr *) pg;
2697
2698 while (NLMSG_OK(h, err)) {
2699 struct route_info rt_info;
2700 if (h->nlmsg_type == NLMSG_DONE) {
2701 err = 0;
2702 goto done;
2703 }
2704
2705 if (h->nlmsg_type == NLMSG_ERROR) {
2706 struct nlmsgerr *errm = (struct nlmsgerr *) NLMSG_DATA(h);
2707 err = errm->error;
2708 printk("NLMSG error: %d\n", errm->error);
2709 goto done;
2710 }
2711
2712 if (h->nlmsg_type == RTM_GETROUTE)
2713 printk("RTM_GETROUTE: NLMSG: %d\n", h->nlmsg_type);
2714 if (h->nlmsg_type != RTM_NEWROUTE) {
2715 printk("NLMSG: %d\n", h->nlmsg_type);
2716 err = -EINVAL;
2717 goto done;
2718 }
2719
2720 memset(&rt_info, 0, sizeof(struct route_info));
2721 parse_routes(h, &rt_info);
2722 if (!rt_info.dst_addr.s_addr && rt_info.gateway.s_addr && rt_info.dev_index) {
2723 *gw_addr = rt_info.gateway.s_addr;
2724 *gw_index = rt_info.dev_index;
2725
2726 }
2727 h = NLMSG_NEXT(h, err);
2728 }
2729
2730 if (err) {
2731 printk("!!!Remnant of size %d %d %d\n", err, h->nlmsg_len, h->nlmsg_type);
2732 err = -EINVAL;
2733 break;
2734 }
2735 }
2736
2737 done:
2738 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
2739 if (!err && req.g.rtgen_family == AF_INET) {
2740 req.g.rtgen_family = AF_INET6;
2741
2742 iov.iov_base = &req;
2743 iov.iov_len = sizeof(req);
2744
2745 msg.msg_name = &nladdr;
2746 msg.msg_namelen = sizeof(nladdr);
2747 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 19, 0))
2748 iov_iter_init(&msg.msg_iter, WRITE, &iov, 1, sizeof(req));
2749 #else
2750 msg.msg_iov = &iov;
2751 msg.msg_iovlen = 1;
2752 #endif
2753 msg.msg_control = NULL;
2754 msg.msg_controllen = 0;
2755 msg.msg_flags = MSG_DONTWAIT;
2756
2757 oldfs = get_fs();
2758 set_fs(KERNEL_DS);
2759 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 1, 0))
2760 err = sock_sendmsg(sock, &msg);
2761 #else
2762 err = sock_sendmsg(sock, &msg, sizeof(req));
2763 #endif
2764 set_fs(oldfs);
2765
2766 if (err > 0)
2767 goto restart;
2768 }
2769 #endif
2770
2771 out_sock_pg:
2772 free_page((unsigned long) pg);
2773
2774 out_sock:
2775 sock_release(sock);
2776 return err;
2777 }
2778
2779 static int arp_query(unsigned char *haddr, u32 paddr,
2780 struct net_device *dev)
2781 {
2782 struct neighbour *neighbor_entry;
2783 int ret = 0;
2784
2785 neighbor_entry = neigh_lookup(&arp_tbl, &paddr, dev);
2786
2787 if (neighbor_entry != NULL) {
2788 neighbor_entry->used = jiffies;
2789 if (neighbor_entry->nud_state & NUD_VALID) {
2790 _rtw_memcpy(haddr, neighbor_entry->ha, dev->addr_len);
2791 ret = 1;
2792 }
2793 neigh_release(neighbor_entry);
2794 }
2795 return ret;
2796 }
2797
2798 static int get_defaultgw(u32 *ip_addr , char mac[])
2799 {
2800 int gw_index = 0; /* oif device index */
2801 struct net_device *gw_dev = NULL; /* oif device */
2802
2803 route_dump(ip_addr, &gw_index);
2804
2805 if (!(*ip_addr) || !gw_index) {
2806 /* RTW_INFO("No default GW\n"); */
2807 return -1;
2808 }
2809
2810 gw_dev = dev_get_by_index(&init_net, gw_index);
2811
2812 if (gw_dev == NULL) {
2813 /* RTW_INFO("get Oif Device Fail\n"); */
2814 return -1;
2815 }
2816
2817 if (!arp_query(mac, *ip_addr, gw_dev)) {
2818 /* RTW_INFO( "arp query failed\n"); */
2819 dev_put(gw_dev);
2820 return -1;
2821
2822 }
2823 dev_put(gw_dev);
2824
2825 return 0;
2826 }
2827
2828 int rtw_gw_addr_query(_adapter *padapter)
2829 {
2830 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2831 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
2832 u32 gw_addr = 0; /* default gw address */
2833 unsigned char gw_mac[32] = {0}; /* default gw mac */
2834 int i;
2835 int res;
2836
2837 res = get_defaultgw(&gw_addr, gw_mac);
2838 if (!res) {
2839 pmlmepriv->gw_ip[0] = gw_addr & 0xff;
2840 pmlmepriv->gw_ip[1] = (gw_addr & 0xff00) >> 8;
2841 pmlmepriv->gw_ip[2] = (gw_addr & 0xff0000) >> 16;
2842 pmlmepriv->gw_ip[3] = (gw_addr & 0xff000000) >> 24;
2843 _rtw_memcpy(pmlmepriv->gw_mac_addr, gw_mac, ETH_ALEN);
2844 RTW_INFO("%s Gateway Mac:\t" MAC_FMT "\n", __FUNCTION__, MAC_ARG(pmlmepriv->gw_mac_addr));
2845 RTW_INFO("%s Gateway IP:\t" IP_FMT "\n", __FUNCTION__, IP_ARG(pmlmepriv->gw_ip));
2846 } else
2847 RTW_INFO("Get Gateway IP/MAC fail!\n");
2848
2849 return res;
2850 }
2851 #endif
2852
2853 int rtw_suspend_free_assoc_resource(_adapter *padapter)
2854 {
2855 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2856 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
2857 struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
2858 #ifdef CONFIG_P2P
2859 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
2860 #endif /* CONFIG_P2P */
2861
2862 RTW_INFO("==> "FUNC_ADPT_FMT" entry....\n", FUNC_ADPT_ARG(padapter));
2863
2864 if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) {
2865 if (MLME_IS_STA(padapter) &&
2866 #ifdef CONFIG_P2P
2867 !rtw_p2p_chk_role(pwdinfo, P2P_ROLE_CLIENT) &&
2868 !rtw_p2p_chk_role(pwdinfo, P2P_ROLE_GO) &&
2869 #endif /* CONFIG_P2P */
2870 check_fwstate(pmlmepriv, WIFI_ASOC_STATE)) {
2871 RTW_INFO("%s %s(" MAC_FMT "), length:%d assoc_ssid.length:%d\n", __FUNCTION__,
2872 pmlmepriv->cur_network.network.Ssid.Ssid,
2873 MAC_ARG(pmlmepriv->cur_network.network.MacAddress),
2874 pmlmepriv->cur_network.network.Ssid.SsidLength,
2875 pmlmepriv->assoc_ssid.SsidLength);
2876 rtw_set_to_roam(padapter, 1);
2877 }
2878 }
2879
2880 if (MLME_IS_STA(padapter) && check_fwstate(pmlmepriv, WIFI_ASOC_STATE))
2881 rtw_disassoc_cmd(padapter, 0, RTW_CMDF_DIRECTLY|RTW_CMDF_WAIT_ACK);
2882 #ifdef CONFIG_AP_MODE
2883 else if (MLME_IS_AP(padapter) || MLME_IS_MESH(padapter))
2884 rtw_sta_flush(padapter, _TRUE);
2885 #endif
2886
2887 if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == _TRUE) {
2888 /* s2-2. */
2889 if (1
2890 #ifdef CONFIG_STA_CMD_DISPR
2891 && (MLME_IS_STA(padapter) == _FALSE)
2892 #endif /* CONFIG_STA_CMD_DISPR */
2893 )
2894 rtw_free_assoc_resources(padapter, _TRUE);
2895
2896 /* s2-3. indicate disconnect to os */
2897 if (MLME_IS_STA(padapter)) {
2898 rtw_indicate_disconnect(padapter, 0, _FALSE);
2899 pmlmeinfo->disconnect_occurred_time = rtw_systime_to_ms(rtw_get_current_time());
2900 pmlmeinfo->disconnect_code = DISCONNECTION_BY_SYSTEM_DUE_TO_SYSTEM_IN_SUSPEND;
2901 pmlmeinfo->wifi_reason_code = WLAN_REASON_DEAUTH_LEAVING;
2902 }
2903 }
2904 /* s2-4. */
2905 rtw_free_network_queue(padapter, _TRUE);
2906
2907 if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY)) {
2908 RTW_PRINT("%s: fw_under_survey\n", __func__);
2909 rtw_indicate_scan_done(padapter, 1);
2910 clr_fwstate(pmlmepriv, WIFI_UNDER_SURVEY);
2911 }
2912
2913 if (check_fwstate(pmlmepriv, WIFI_UNDER_LINKING) == _TRUE) {
2914 RTW_PRINT("%s: fw_under_linking\n", __FUNCTION__);
2915 rtw_indicate_disconnect(padapter, 0, _FALSE);
2916 pmlmeinfo->disconnect_occurred_time = rtw_systime_to_ms(rtw_get_current_time());
2917 pmlmeinfo->disconnect_code = DISCONNECTION_BY_SYSTEM_DUE_TO_SYSTEM_IN_SUSPEND;
2918 pmlmeinfo->wifi_reason_code = WLAN_REASON_DEAUTH_LEAVING;
2919 }
2920
2921 RTW_INFO("<== "FUNC_ADPT_FMT" exit....\n", FUNC_ADPT_ARG(padapter));
2922 return _SUCCESS;
2923 }
2924
2925 #ifdef CONFIG_WOWLAN
2926 int rtw_suspend_wow(_adapter *padapter)
2927 {
2928 u8 ch, bw, offset;
2929 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2930 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
2931 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
2932 int ret = _SUCCESS;
2933
2934 RTW_INFO("==> "FUNC_ADPT_FMT" entry....\n", FUNC_ADPT_ARG(padapter));
2935
2936
2937 RTW_INFO("wowlan_mode: %d\n", pwrpriv->wowlan_mode);
2938 RTW_INFO("wowlan_pno_enable: %d\n", pwrpriv->wowlan_pno_enable);
2939 #ifdef CONFIG_P2P_WOWLAN
2940 RTW_INFO("wowlan_p2p_enable: %d\n", pwrpriv->wowlan_p2p_enable);
2941 #endif
2942
2943 if (pwrpriv->wowlan_mode == _TRUE) {
2944 #ifdef CONFIG_CMD_GENERAL
2945 rtw_phl_watchdog_stop(dvobj->phl);
2946 #endif
2947 rtw_mi_netif_stop_queue(padapter);
2948 #ifdef CONFIG_CONCURRENT_MODE
2949 rtw_mi_buddy_netif_carrier_off(padapter);
2950 #endif
2951
2952 rtw_hw_wow(padapter, _TRUE);
2953
2954 if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) {
2955 if (MLME_IS_STA(padapter)
2956 && check_fwstate(pmlmepriv, WIFI_ASOC_STATE)) {
2957 RTW_INFO("%s %s(" MAC_FMT "), length:%d assoc_ssid.length:%d\n", __FUNCTION__,
2958 pmlmepriv->cur_network.network.Ssid.Ssid,
2959 MAC_ARG(pmlmepriv->cur_network.network.MacAddress),
2960 pmlmepriv->cur_network.network.Ssid.SsidLength,
2961 pmlmepriv->assoc_ssid.SsidLength);
2962
2963 rtw_set_to_roam(padapter, 0);
2964 }
2965 }
2966
2967 RTW_PRINT("%s: wowmode suspending\n", __func__);
2968
2969 if (check_fwstate(pmlmepriv, WIFI_UNDER_SURVEY) == _TRUE) {
2970 RTW_PRINT("%s: fw_under_survey\n", __func__);
2971 rtw_indicate_scan_done(padapter, 1);
2972 clr_fwstate(pmlmepriv, WIFI_UNDER_SURVEY);
2973 }
2974
2975 #ifdef CONFIG_SDIO_HCI
2976 #if !(CONFIG_RTW_SDIO_KEEP_IRQ)
2977 rtw_sdio_free_irq(dvobj);
2978 #endif
2979 #endif/*CONFIG_SDIO_HCI*/
2980
2981 #ifdef CONFIG_CONCURRENT_MODE
2982 rtw_mi_buddy_suspend_free_assoc_resource(padapter);
2983 #endif
2984 } else
2985 RTW_PRINT("%s: ### ERROR ### wowlan_mode=%d\n", __FUNCTION__, pwrpriv->wowlan_mode);
2986 RTW_INFO("<== "FUNC_ADPT_FMT" exit....\n", FUNC_ADPT_ARG(padapter));
2987 return ret;
2988 }
2989 #endif /* #ifdef CONFIG_WOWLAN */
2990
2991 #ifdef CONFIG_AP_WOWLAN
2992 int rtw_suspend_ap_wow(_adapter *padapter)
2993 {
2994 u8 ch, bw, offset;
2995 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
2996 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2997 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
2998 int ret = _SUCCESS;
2999
3000 RTW_INFO("==> "FUNC_ADPT_FMT" entry....\n", FUNC_ADPT_ARG(padapter));
3001
3002 pwrpriv->wowlan_ap_mode = _TRUE;
3003
3004 RTW_INFO("wowlan_ap_mode: %d\n", pwrpriv->wowlan_ap_mode);
3005
3006 rtw_mi_netif_stop_queue(padapter);
3007
3008 /* 0. Power off LED */
3009 rtw_led_control(padapter, LED_CTL_POWER_OFF);
3010
3011 /* 1. stop thread */
3012 dev_set_drv_stopped(dvobj); /*for stop thread*/
3013 #if 0
3014 rtw_mi_stop_drv_threads(padapter);
3015 #endif
3016 dev_clr_drv_stopped(dvobj); /*for 32k command*/
3017
3018 #ifdef CONFIG_SDIO_HCI
3019 /* 2.2 free irq */
3020 #if !(CONFIG_RTW_SDIO_KEEP_IRQ)
3021 rtw_sdio_free_irq(dvobj);
3022 #endif
3023 #endif/*CONFIG_SDIO_HCI*/
3024
3025 rtw_wow_lps_level_decide(padapter, _TRUE);
3026 RTW_PRINT("%s: wowmode suspending\n", __func__);
3027 #if 1
3028 if (rtw_mi_check_status(padapter, MI_LINKED)) {
3029 ch = rtw_mi_get_union_chan(padapter);
3030 bw = rtw_mi_get_union_bw(padapter);
3031 offset = rtw_mi_get_union_offset(padapter);
3032 RTW_INFO("back to linked/linking union - ch:%u, bw:%u, offset:%u\n", ch, bw, offset);
3033 set_channel_bwmode(padapter, ch, offset, bw, _FALSE);
3034 }
3035 #else
3036 if (rtw_mi_get_ch_setting_union(padapter, &ch, &bw, &offset) != 0) {
3037 RTW_INFO("back to linked/linking union - ch:%u, bw:%u, offset:%u\n", ch, bw, offset);
3038 set_channel_bwmode(padapter, ch, offset, bw, _FALSE);
3039 rtw_mi_update_union_chan_inf(padapter, ch, offset, bw);
3040 }
3041 #endif
3042
3043 /*FOR ONE AP - TODO :Multi-AP*/
3044 {
3045 int i;
3046 _adapter *iface;
3047 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
3048
3049 for (i = 0; i < dvobj->iface_nums; i++) {
3050 iface = dvobj->padapters[i];
3051 if ((iface) && rtw_is_adapter_up(iface)) {
3052 if (check_fwstate(&iface->mlmepriv, WIFI_AP_STATE | WIFI_MESH_STATE) == _FALSE)
3053 rtw_suspend_free_assoc_resource(iface);
3054 }
3055 }
3056
3057 }
3058
3059 #ifdef CONFIG_LPS
3060 if(pwrpriv->wowlan_power_mgmt != PM_PS_MODE_ACTIVE) {
3061 rtw_set_ps_mode(padapter, pwrpriv->wowlan_power_mgmt, 0, 0, "AP-WOWLAN");
3062 }
3063 #endif
3064
3065 RTW_INFO("<== "FUNC_ADPT_FMT" exit....\n", FUNC_ADPT_ARG(padapter));
3066 return ret;
3067 }
3068 #endif /* #ifdef CONFIG_AP_WOWLAN */
3069
3070
3071 int rtw_suspend_normal(_adapter *padapter)
3072 {
3073 int ret = _SUCCESS;
3074
3075 RTW_INFO("==> "FUNC_ADPT_FMT" entry....\n", FUNC_ADPT_ARG(padapter));
3076
3077 rtw_mi_netif_caroff_qstop(padapter);
3078
3079 rtw_mi_suspend_free_assoc_resource(padapter);
3080
3081 rtw_led_control(padapter, LED_CTL_POWER_OFF);
3082
3083 if ((rtw_hal_check_ips_status(padapter) == _TRUE)
3084 || (adapter_to_pwrctl(padapter)->rf_pwrstate == rf_off))
3085 RTW_PRINT("%s: ### ERROR #### driver in IPS ####ERROR###!!!\n", __FUNCTION__);
3086
3087 dev_set_drv_stopped(adapter_to_dvobj(padapter)); /*for stop thread*/
3088 #if 0 /*#ifdef CONFIG_CORE_CMD_THREAD*/
3089 rtw_stop_cmd_thread(padapter);
3090 #endif
3091 #ifdef CONFIG_CONCURRENT_MODE
3092 rtw_drv_stop_vir_ifaces(adapter_to_dvobj(padapter));
3093 #endif
3094 rtw_drv_stop_prim_iface(padapter);
3095
3096 if (rtw_hw_is_init_completed(adapter_to_dvobj(padapter)))
3097 rtw_hw_stop(adapter_to_dvobj(padapter));
3098 dev_set_surprise_removed(adapter_to_dvobj(padapter));
3099
3100 #ifdef CONFIG_SDIO_HCI
3101 rtw_sdio_deinit(adapter_to_dvobj(padapter));
3102
3103 #if !(CONFIG_RTW_SDIO_KEEP_IRQ)
3104 rtw_sdio_free_irq(adapter_to_dvobj(padapter));
3105 #endif
3106 #endif /*CONFIG_SDIO_HCI*/
3107
3108 RTW_INFO("<== "FUNC_ADPT_FMT" exit....\n", FUNC_ADPT_ARG(padapter));
3109 return ret;
3110 }
3111
3112 int rtw_suspend_common(_adapter *padapter)
3113 {
3114 struct dvobj_priv *dvobj = padapter->dvobj;
3115 struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
3116 struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
3117 #ifdef CONFIG_WOWLAN
3118 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3119 struct registry_priv *registry_par = &padapter->registrypriv;
3120 #endif
3121
3122 int ret = 0;
3123 systime start_time = rtw_get_current_time();
3124
3125 RTW_PRINT(" suspend start\n");
3126 RTW_INFO("==> %s (%s:%d)\n", __FUNCTION__, current->comm, current->pid);
3127
3128 pdbgpriv->dbg_suspend_cnt++;
3129
3130 pwrpriv->bInSuspend = _TRUE;
3131
3132 if ( RTW_CANNOT_RUN(dvobj)) {
3133 RTW_INFO("%s bDriverStopped=%s bSurpriseRemoved = %s\n", __func__
3134 , dev_is_drv_stopped(adapter_to_dvobj(padapter)) ? "True" : "False"
3135 , dev_is_surprise_removed(adapter_to_dvobj(padapter)) ? "True" : "False");
3136 pdbgpriv->dbg_suspend_error_cnt++;
3137 goto exit;
3138 }
3139
3140 rtw_mi_scan_abort(padapter, _TRUE);
3141 rtw_ps_deny(padapter, PS_DENY_SUSPEND);
3142
3143 rtw_mi_cancel_all_timer(padapter);
3144 LeaveAllPowerSaveModeDirect(padapter);
3145
3146 rtw_ps_deny_cancel(padapter, PS_DENY_SUSPEND);
3147
3148 if (rtw_mi_check_status(padapter, MI_AP_MODE) == _FALSE) {
3149 #ifdef CONFIG_WOWLAN
3150 if (WOWLAN_IS_STA_MIX_MODE(padapter))
3151 pwrpriv->wowlan_mode = _TRUE;
3152 else if ( registry_par->wowlan_enable && check_fwstate(pmlmepriv, WIFI_ASOC_STATE))
3153 pwrpriv->wowlan_mode = _TRUE;
3154 else if (pwrpriv->wowlan_pno_enable == _TRUE)
3155 pwrpriv->wowlan_mode |= pwrpriv->wowlan_pno_enable;
3156
3157 #ifdef CONFIG_P2P_WOWLAN
3158 if (rtw_p2p_chk_role(&padapter->wdinfo, P2P_ROLE_CLIENT) ||
3159 rtw_p2p_chk_role(&padapter->wdinfo, P2P_ROLE_GO))
3160 pwrpriv->wowlan_p2p_mode = _TRUE;
3161 if (_TRUE == pwrpriv->wowlan_p2p_mode)
3162 pwrpriv->wowlan_mode |= pwrpriv->wowlan_p2p_mode;
3163 #endif /* CONFIG_P2P_WOWLAN */
3164
3165 if (pwrpriv->wowlan_mode == _TRUE)
3166 rtw_suspend_wow(padapter);
3167 else
3168 #endif /* CONFIG_WOWLAN */
3169 rtw_suspend_normal(padapter);
3170 } else if (rtw_mi_check_status(padapter, MI_AP_MODE)) {
3171 #ifdef CONFIG_AP_WOWLAN
3172 rtw_suspend_ap_wow(padapter);
3173 #else
3174 rtw_suspend_normal(padapter);
3175 #endif /*CONFIG_AP_WOWLAN*/
3176 }
3177
3178
3179 RTW_PRINT("rtw suspend success in %d ms\n",
3180 rtw_get_passing_time_ms(start_time));
3181
3182 exit:
3183 RTW_INFO("<=== %s return %d.............. in %dms\n", __FUNCTION__
3184 , ret, rtw_get_passing_time_ms(start_time));
3185
3186 return ret;
3187 }
3188
3189 #ifdef CONFIG_WOWLAN
3190 int rtw_resume_process_wow(_adapter *padapter)
3191 {
3192 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
3193 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
3194 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
3195 struct dvobj_priv *dvobj = padapter->dvobj;
3196 struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
3197 struct registry_priv *registry_par = &padapter->registrypriv;
3198 int ret = _SUCCESS;
3199
3200 RTW_INFO("==> "FUNC_ADPT_FMT" entry....\n", FUNC_ADPT_ARG(padapter));
3201
3202 if (padapter) {
3203 pwrpriv = adapter_to_pwrctl(padapter);
3204 } else {
3205 pdbgpriv->dbg_resume_error_cnt++;
3206 ret = -1;
3207 goto exit;
3208 }
3209
3210 if (RTW_CANNOT_RUN(dvobj)) {
3211 RTW_INFO("%s pdapter %p bDriverStopped %s bSurpriseRemoved %s\n"
3212 , __func__, padapter
3213 , dev_is_drv_stopped(dvobj) ? "True" : "False"
3214 , dev_is_surprise_removed(dvobj) ? "True" : "False");
3215 goto exit;
3216 }
3217
3218 pwrpriv->wowlan_in_resume = _TRUE;
3219
3220 if (pwrpriv->wowlan_mode == _TRUE) {
3221 pwrpriv->bFwCurrentInPSMode = _FALSE;
3222
3223 #ifdef CONFIG_SDIO_HCI
3224 #if !(CONFIG_RTW_SDIO_KEEP_IRQ)
3225 if (rtw_sdio_alloc_irq(dvobj) != _SUCCESS) {
3226 ret = -1;
3227 goto exit;
3228 }
3229 #endif
3230 #endif/*CONFIG_SDIO_HCI*/
3231
3232 #ifdef CONFIG_CONCURRENT_MODE
3233 rtw_mi_buddy_reset_drv_sw(padapter);
3234 #endif
3235 rtw_hw_wow(padapter, _FALSE);
3236
3237 dev_clr_drv_stopped(dvobj);
3238 RTW_INFO("%s: wowmode resuming, DriverStopped:%s\n", __func__, dev_is_drv_stopped(dvobj) ? "True" : "False");
3239
3240 #if 0
3241 rtw_mi_start_drv_threads(padapter);
3242 #endif
3243
3244 #ifdef CONFIG_CONCURRENT_MODE
3245 rtw_mi_buddy_netif_carrier_on(padapter);
3246 #endif
3247
3248 /* start netif queue */
3249 rtw_mi_netif_wake_queue(padapter);
3250
3251 } else
3252
3253 RTW_PRINT("%s: ### ERROR ### wowlan_mode=%d\n", __FUNCTION__, pwrpriv->wowlan_mode);
3254
3255 if (padapter->pid[1] != 0) {
3256 RTW_INFO("pid[1]:%d\n", padapter->pid[1]);
3257 rtw_signal_process(padapter->pid[1], SIGUSR2);
3258 }
3259 #if 0 /* WOW_ToDo */
3260 if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) {
3261 if (pwrpriv->wowlan_wake_reason == FW_DECISION_DISCONNECT ||
3262 pwrpriv->wowlan_wake_reason == RX_DISASSOC||
3263 pwrpriv->wowlan_wake_reason == RX_DEAUTH) {
3264
3265 RTW_INFO("%s: disconnect reason: %02x\n", __func__,
3266 pwrpriv->wowlan_wake_reason);
3267
3268 rtw_sta_media_status_rpt(padapter,
3269 rtw_get_stainfo(&padapter->stapriv,
3270 get_bssid(&padapter->mlmepriv)), 0);
3271 if (MLME_IS_ASOC(padapter) == _TRUE)
3272 rtw_free_assoc_resources(padapter, _TRUE);
3273 rtw_indicate_disconnect(padapter, 0, _FALSE);
3274 pmlmeinfo->state = WIFI_FW_NULL_STATE;
3275
3276 pmlmeinfo->disconnect_occurred_time = rtw_systime_to_ms(rtw_get_current_time());
3277 if (pwrpriv->wowlan_wake_reason == FW_DECISION_DISCONNECT)
3278 pmlmeinfo->disconnect_code = DISCONNECTION_BY_FW_DUE_TO_FW_DECISION_IN_WOW_RESUME;
3279 else if (pwrpriv->wowlan_wake_reason == RX_DISASSOC)
3280 pmlmeinfo->disconnect_code = DISCONNECTION_BY_AP_DUE_TO_RECEIVE_DISASSOC_IN_WOW_RESUME;
3281 else if (pwrpriv->wowlan_wake_reason == RX_DEAUTH)
3282 pmlmeinfo->disconnect_code = DISCONNECTION_BY_AP_DUE_TO_RECEIVE_DEAUTH_IN_WOW_RESUME;
3283
3284 pmlmeinfo->wifi_reason_code = WLAN_REASON_UNSPECIFIED;
3285
3286 } else {
3287 RTW_INFO("%s: do roaming\n", __func__);
3288 rtw_roaming(padapter, NULL);
3289 }
3290 }
3291 #endif
3292 if (pwrpriv->wowlan_mode == _TRUE) {
3293 #ifdef CONFIG_CMD_GENERAL
3294 rtw_phl_watchdog_start(dvobj->phl);
3295 #endif
3296 #if 0 /*ndef CONFIG_IPS_CHECK_IN_WD*/
3297 rtw_set_pwr_state_check_timer(pwrpriv);
3298 #endif
3299 } else
3300 RTW_PRINT("do not reset timer\n");
3301
3302 pwrpriv->wowlan_mode = _FALSE;
3303
3304 /* Power On LED */
3305 #ifdef CONFIG_RTW_SW_LED
3306
3307 if (pwrpriv->wowlan_wake_reason == RX_DISASSOC||
3308 pwrpriv->wowlan_wake_reason == RX_DEAUTH||
3309 pwrpriv->wowlan_wake_reason == FW_DECISION_DISCONNECT)
3310 rtw_led_control(padapter, LED_CTL_NO_LINK);
3311 else
3312 rtw_led_control(padapter, LED_CTL_LINK);
3313 #endif
3314 /* clean driver side wake up reason. */
3315 pwrpriv->wowlan_last_wake_reason = pwrpriv->wowlan_wake_reason;
3316 pwrpriv->wowlan_wake_reason = 0;
3317
3318 exit:
3319 RTW_INFO("<== "FUNC_ADPT_FMT" exit....\n", FUNC_ADPT_ARG(padapter));
3320 return ret;
3321 }
3322 #endif /* #ifdef CONFIG_WOWLAN */
3323
3324 #ifdef CONFIG_AP_WOWLAN
3325 int rtw_resume_process_ap_wow(_adapter *padapter)
3326 {
3327 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
3328 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
3329 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
3330 struct debug_priv *pdbgpriv = &dvobj->drv_dbg;
3331 struct sta_info *psta = NULL;
3332 int ret = _SUCCESS;
3333 u8 ch, bw, offset;
3334
3335 RTW_INFO("==> "FUNC_ADPT_FMT" entry....\n", FUNC_ADPT_ARG(padapter));
3336
3337 if (padapter) {
3338 pwrpriv = adapter_to_pwrctl(padapter);
3339 } else {
3340 pdbgpriv->dbg_resume_error_cnt++;
3341 ret = -1;
3342 goto exit;
3343 }
3344
3345
3346 #ifdef CONFIG_LPS
3347 if(pwrpriv->wowlan_power_mgmt != PM_PS_MODE_ACTIVE) {
3348 rtw_set_ps_mode(padapter, PM_PS_MODE_ACTIVE, 0, 0, "AP-WOWLAN");
3349 rtw_wow_lps_level_decide(padapter, _FALSE);
3350 }
3351 #endif /* CONFIG_LPS */
3352
3353 pwrpriv->bFwCurrentInPSMode = _FALSE;
3354 #if 0 /*GEORGIA_TODO_REMOVE_IT_FOR_PHL_ARCH*/
3355
3356 rtw_hal_disable_interrupt(GET_PHL_COM(dvobj));
3357
3358 rtw_hal_clear_interrupt(padapter);
3359 #endif
3360
3361 #ifdef CONFIG_SDIO_HCI
3362 #if !(CONFIG_RTW_SDIO_KEEP_IRQ)
3363 if (rtw_sdio_alloc_irq(dvobj) != _SUCCESS) {
3364 ret = -1;
3365 goto exit;
3366 }
3367 #endif
3368 #endif/*CONFIG_SDIO_HCI*/
3369
3370 pwrpriv->wowlan_ap_mode = _FALSE;
3371
3372 dev_clr_drv_stopped(dvobj);
3373 RTW_INFO("%s: wowmode resuming, DriverStopped:%s\n", __func__, dev_is_drv_stopped(dvobj) ? "True" : "False");
3374
3375 #if 0
3376 rtw_mi_start_drv_threads(padapter);
3377 #endif
3378
3379 #if 1
3380 if (rtw_mi_check_status(padapter, MI_LINKED)) {
3381 ch = rtw_mi_get_union_chan(padapter);
3382 bw = rtw_mi_get_union_bw(padapter);
3383 offset = rtw_mi_get_union_offset(padapter);
3384 RTW_INFO(FUNC_ADPT_FMT" back to linked/linking union - ch:%u, bw:%u, offset:%u\n", FUNC_ADPT_ARG(padapter), ch, bw, offset);
3385 set_channel_bwmode(padapter, ch, offset, bw, _FALSE);
3386 }
3387 #else
3388 if (rtw_mi_get_ch_setting_union(padapter, &ch, &bw, &offset) != 0) {
3389 RTW_INFO(FUNC_ADPT_FMT" back to linked/linking union - ch:%u, bw:%u, offset:%u\n", FUNC_ADPT_ARG(padapter), ch, bw, offset);
3390 set_channel_bwmode(padapter, ch, offset, bw, _FALSE);
3391 rtw_mi_update_union_chan_inf(padapter, ch, offset, bw);
3392 }
3393 #endif
3394
3395 /*FOR ONE AP - TODO :Multi-AP*/
3396 {
3397 int i;
3398 _adapter *iface;
3399
3400 for (i = 0; i < dvobj->iface_nums; i++) {
3401 iface = dvobj->padapters[i];
3402 if ((iface) && rtw_is_adapter_up(iface)) {
3403 if (check_fwstate(&iface->mlmepriv, WIFI_AP_STATE | WIFI_MESH_STATE | WIFI_ASOC_STATE))
3404 rtw_reset_drv_sw(iface);
3405 }
3406 }
3407
3408 }
3409
3410 /* start netif queue */
3411 rtw_mi_netif_wake_queue(padapter);
3412
3413 if (padapter->pid[1] != 0) {
3414 RTW_INFO("pid[1]:%d\n", padapter->pid[1]);
3415 rtw_signal_process(padapter->pid[1], SIGUSR2);
3416 }
3417
3418 #ifdef CONFIG_RESUME_IN_WORKQUEUE
3419 /* rtw_unlock_suspend(); */
3420 #endif /* CONFIG_RESUME_IN_WORKQUEUE */
3421
3422 #if 0 /*#ifdef CONFIG_CORE_DM_CHK_TIMER*/
3423 _set_timer(&dvobj->dynamic_chk_timer, 2000);
3424 #endif
3425 #if 0 /*ndef CONFIG_IPS_CHECK_IN_WD*/
3426 rtw_set_pwr_state_check_timer(pwrpriv);
3427 #endif
3428 /* clean driver side wake up reason. */
3429 pwrpriv->wowlan_wake_reason = 0;
3430
3431 /* Power On LED */
3432 #ifdef CONFIG_RTW_SW_LED
3433
3434 rtw_led_control(padapter, LED_CTL_LINK);
3435 #endif
3436 exit:
3437 RTW_INFO("<== "FUNC_ADPT_FMT" exit....\n", FUNC_ADPT_ARG(padapter));
3438 return ret;
3439 }
3440 #endif /* #ifdef CONFIG_APWOWLAN */
3441
3442 void rtw_mi_resume_process_normal(_adapter *padapter)
3443 {
3444 int i;
3445 _adapter *iface;
3446 struct mlme_priv *pmlmepriv;
3447 struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
3448
3449 for (i = 0; i < dvobj->iface_nums; i++) {
3450 iface = dvobj->padapters[i];
3451 if ((iface) && rtw_is_adapter_up(iface)) {
3452 pmlmepriv = &iface->mlmepriv;
3453
3454 if (MLME_IS_STA(padapter)) {
3455 RTW_INFO(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_STATION_STATE\n", FUNC_ADPT_ARG(iface), get_fwstate(pmlmepriv));
3456
3457 if (rtw_chk_roam_flags(iface, RTW_ROAM_ON_RESUME))
3458 rtw_roaming(iface, NULL);
3459
3460 } else if (MLME_IS_AP(iface) || MLME_IS_MESH(iface)) {
3461 RTW_INFO(FUNC_ADPT_FMT" %s\n", FUNC_ADPT_ARG(iface), MLME_IS_AP(iface) ? "AP" : "MESH");
3462 rtw_ap_restore_network(iface);
3463 } else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE))
3464 RTW_INFO(FUNC_ADPT_FMT" fwstate:0x%08x - WIFI_ADHOC_STATE\n", FUNC_ADPT_ARG(iface), get_fwstate(pmlmepriv));
3465 else
3466 RTW_INFO(FUNC_ADPT_FMT" fwstate:0x%08x - ???\n", FUNC_ADPT_ARG(iface), get_fwstate(pmlmepriv));
3467 }
3468 }
3469 }
3470
3471 int rtw_resume_process_normal(_adapter *padapter)
3472 {
3473 struct net_device *pnetdev;
3474 struct pwrctrl_priv *pwrpriv;
3475 struct dvobj_priv *dvobj;
3476 struct debug_priv *pdbgpriv;
3477
3478 int ret = _SUCCESS;
3479
3480 if (!padapter) {
3481 ret = -1;
3482 goto exit;
3483 }
3484
3485 pnetdev = padapter->pnetdev;
3486 pwrpriv = adapter_to_pwrctl(padapter);
3487 dvobj = padapter->dvobj;
3488 pdbgpriv = &dvobj->drv_dbg;
3489
3490 RTW_INFO("==> "FUNC_ADPT_FMT" entry....\n", FUNC_ADPT_ARG(padapter));
3491
3492 #ifdef CONFIG_SDIO_HCI
3493 /* interface init */
3494 if (rtw_sdio_init(dvobj) != _SUCCESS) {
3495 ret = -1;
3496 goto exit;
3497 }
3498 #endif/*CONFIG_SDIO_HCI*/
3499
3500 dev_clr_surprise_removed(dvobj);
3501 #if 0 /*GEORGIA_TODO_REMOVE_IT_FOR_PHL_ARCH*/
3502 rtw_hal_disable_interrupt(GET_PHL_COM(dvobj));
3503 #endif
3504 #ifdef CONFIG_SDIO_HCI
3505 #if !(CONFIG_RTW_SDIO_KEEP_IRQ)
3506 if (rtw_sdio_alloc_irq(dvobj) != _SUCCESS) {
3507 ret = -1;
3508 goto exit;
3509 }
3510 #endif
3511 #endif/*CONFIG_SDIO_HCI*/
3512
3513 rtw_mi_reset_drv_sw(padapter);
3514
3515 pwrpriv->bkeepfwalive = _FALSE;
3516
3517 RTW_INFO("bkeepfwalive(%x)\n", pwrpriv->bkeepfwalive);
3518 if (pm_netdev_open(pnetdev, _TRUE) != 0) {
3519 ret = -1;
3520 pdbgpriv->dbg_resume_error_cnt++;
3521 goto exit;
3522 }
3523
3524 rtw_mi_netif_caron_qstart(padapter);
3525
3526 if (padapter->pid[1] != 0) {
3527 RTW_INFO("pid[1]:%d\n", padapter->pid[1]);
3528 rtw_signal_process(padapter->pid[1], SIGUSR2);
3529 }
3530
3531 rtw_mi_resume_process_normal(padapter);
3532
3533 #ifdef CONFIG_RESUME_IN_WORKQUEUE
3534 /* rtw_unlock_suspend(); */
3535 #endif /* CONFIG_RESUME_IN_WORKQUEUE */
3536 RTW_INFO("<== "FUNC_ADPT_FMT" exit....\n", FUNC_ADPT_ARG(padapter));
3537
3538 exit:
3539 return ret;
3540 }
3541
3542 int rtw_resume_common(_adapter *padapter)
3543 {
3544 int ret = 0;
3545 systime start_time = rtw_get_current_time();
3546 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
3547
3548 if (pwrpriv == NULL)
3549 return 0;
3550
3551 if (pwrpriv->bInSuspend == _FALSE)
3552 return 0;
3553
3554 RTW_PRINT("resume start\n");
3555 RTW_INFO("==> %s (%s:%d)\n", __FUNCTION__, current->comm, current->pid);
3556
3557 if (rtw_mi_check_status(padapter, MI_AP_MODE) == _FALSE) {
3558 #ifdef CONFIG_WOWLAN
3559 if (pwrpriv->wowlan_mode == _TRUE)
3560 rtw_resume_process_wow(padapter);
3561 else
3562 #endif
3563 rtw_resume_process_normal(padapter);
3564
3565 } else if (rtw_mi_check_status(padapter, MI_AP_MODE)) {
3566 #ifdef CONFIG_AP_WOWLAN
3567 rtw_resume_process_ap_wow(padapter);
3568 #else
3569 rtw_resume_process_normal(padapter);
3570 #endif /* CONFIG_AP_WOWLAN */
3571 }
3572
3573
3574 pwrpriv->bInSuspend = _FALSE;
3575 pwrpriv->wowlan_in_resume = _FALSE;
3576
3577 RTW_PRINT("%s:%d in %d ms\n", __FUNCTION__ , ret,
3578 rtw_get_passing_time_ms(start_time));
3579
3580
3581 return ret;
3582 }
3583
3584 #ifdef CONFIG_GPIO_API
3585 u8 rtw_get_gpio(struct net_device *netdev, u8 gpio_num)
3586 {
3587 _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
3588 return rtw_hal_get_gpio(adapter, gpio_num);
3589 }
3590 EXPORT_SYMBOL(rtw_get_gpio);
3591
3592 int rtw_set_gpio_output_value(struct net_device *netdev, u8 gpio_num, bool isHigh)
3593 {
3594 u8 direction = 0;
3595 u8 res = -1;
3596 _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
3597 return rtw_hal_set_gpio_output_value(adapter, gpio_num, isHigh);
3598 }
3599 EXPORT_SYMBOL(rtw_set_gpio_output_value);
3600
3601 int rtw_config_gpio(struct net_device *netdev, u8 gpio_num, bool isOutput)
3602 {
3603 _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
3604 return rtw_hal_config_gpio(adapter, gpio_num, isOutput);
3605 }
3606 EXPORT_SYMBOL(rtw_config_gpio);
3607 int rtw_register_gpio_interrupt(struct net_device *netdev, int gpio_num, void(*callback)(u8 level))
3608 {
3609 _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
3610 return rtw_hal_register_gpio_interrupt(adapter, gpio_num, callback);
3611 }
3612 EXPORT_SYMBOL(rtw_register_gpio_interrupt);
3613
3614 int rtw_disable_gpio_interrupt(struct net_device *netdev, int gpio_num)
3615 {
3616 _adapter *adapter = (_adapter *)rtw_netdev_priv(netdev);
3617 return rtw_hal_disable_gpio_interrupt(adapter, gpio_num);
3618 }
3619 EXPORT_SYMBOL(rtw_disable_gpio_interrupt);
3620
3621 #endif /* #ifdef CONFIG_GPIO_API */
3622
3623 #ifdef CONFIG_APPEND_VENDOR_IE_ENABLE
3624
3625 int rtw_vendor_ie_get_api(struct net_device *dev, int ie_num, char *extra,
3626 u16 extra_len)
3627 {
3628 int ret = 0;
3629
3630 ret = rtw_vendor_ie_get_raw_data(dev, ie_num, extra, extra_len);
3631 return ret;
3632 }
3633 EXPORT_SYMBOL(rtw_vendor_ie_get_api);
3634
3635 int rtw_vendor_ie_set_api(struct net_device *dev, char *extra)
3636 {
3637 return rtw_vendor_ie_set(dev, NULL, NULL, extra);
3638 }
3639 EXPORT_SYMBOL(rtw_vendor_ie_set_api);
3640
3641 #endif
3642