/* * Copyright (C) 2011-2014 MediaTek Inc. * * This program is free software: you can redistribute it and/or modify it under the terms of the * GNU General Public License version 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along with this program. * If not, see . */ /* ** Id: //Department/DaVinci/BRANCHES/MT6620_WIFI_DRIVER_V2_3/os/linux/gl_init.c#7 */ /*! \file gl_init.c \brief Main routines of Linux driver This file contains the main routines of Linux driver for MediaTek Inc. 802.11 Wireless LAN Adapters. */ /* ** Log: gl_init.c ** ** 09 03 2013 cp.wu ** add path for reassociation * * 07 17 2012 yuche.tsai * NULL * Fix compile error. * * 07 17 2012 yuche.tsai * NULL * Fix compile error for JB. * * 07 17 2012 yuche.tsai * NULL * Let netdev bring up. * * 07 17 2012 yuche.tsai * NULL * Compile no error before trial run. * * 06 13 2012 yuche.tsai * NULL * Update maintrunk driver. * Add support for driver compose assoc request frame. * * 05 25 2012 yuche.tsai * NULL * Fix reset KE issue. * * 05 11 2012 cp.wu * [WCXRP00001237] [MT6620 Wi-Fi][Driver] Show MAC address and MAC address source for ACS's convenience * show MAC address & source while initiliazation * * 03 02 2012 terry.wu * NULL * EXPORT_SYMBOL(rsnParseCheckForWFAInfoElem);. * * 03 02 2012 terry.wu * NULL * Snc CFG80211 modification for ICS migration from branch 2.2. * * 03 02 2012 terry.wu * NULL * Sync CFG80211 modification from branch 2,2. * * 03 02 2012 terry.wu * NULL * Enable CFG80211 Support. * * 12 22 2011 george.huang * [WCXRP00000905] [MT6628 Wi-Fi][FW] Code refinement for ROM/ RAM module dependency * using global variable instead of stack for setting wlanoidSetNetworkAddress(), due to buffer may be released before * TX thread handling * * 11 18 2011 yuche.tsai * NULL * CONFIG P2P support RSSI query, default turned off. * * 11 14 2011 yuche.tsai * [WCXRP00001107] [Volunteer Patch][Driver] Large Network Type index assert in FW issue. * Fix large network type index assert in FW issue. * * 11 14 2011 cm.chang * NULL * Fix compiling warning * * 11 11 2011 yuche.tsai * NULL * Fix work thread cancel issue. * * 11 10 2011 cp.wu * [WCXRP00001098] [MT6620 Wi-Fi][Driver] Replace printk by DBG LOG macros in linux porting layer * 1. eliminaite direct calls to printk in porting layer. * 2. replaced by DBGLOG, which would be XLOG on ALPS platforms. * * 10 06 2011 eddie.chen * [WCXRP00001027] [MT6628 Wi-Fi][Firmware/Driver] Tx fragmentation * Add rlmDomainGetChnlList symbol. * * 09 22 2011 cm.chang * NULL * Safer writng stype to avoid unitialized regitry structure * * 09 21 2011 cm.chang * [WCXRP00000969] [MT6620 Wi-Fi][Driver][FW] Channel list for 5G band based on country code * Avoid possible structure alignment problem * * 09 20 2011 chinglan.wang * [WCXRP00000989] [WiFi Direct] [Driver] Add a new io control API to start the formation for the sigma test. * . * * 09 08 2011 cm.chang * [WCXRP00000969] [MT6620 Wi-Fi][Driver][FW] Channel list for 5G band based on country code * Use new fields ucChannelListMap and ucChannelListIndex in NVRAM * * 08 31 2011 cm.chang * [WCXRP00000969] [MT6620 Wi-Fi][Driver][FW] Channel list for 5G band based on country code * . * * 08 11 2011 cp.wu * [WCXRP00000830] [MT6620 Wi-Fi][Firmware] Use MDRDY counter to detect empty channel for shortening scan time * expose scnQuerySparseChannel() for P2P-FSM. * * 08 11 2011 cp.wu * [WCXRP00000830] [MT6620 Wi-Fi][Firmware] Use MDRDY counter to detect empty channel for shortening scan time * sparse channel detection: * driver: collect sparse channel information with scan-done event * * 08 02 2011 yuche.tsai * [WCXRP00000896] [Volunteer Patch][WiFi Direct][Driver] GO with multiple client, TX deauth to a disconnecting * device issue. * Fix GO send deauth frame issue. * * 07 07 2011 wh.su * [WCXRP00000839] [MT6620 Wi-Fi][Driver] Add the dumpMemory8 and dumpMemory32 EXPORT_SYMBOL * Add the dumpMemory8 symbol export for debug mode. * * 07 06 2011 terry.wu * [WCXRP00000735] [MT6620 Wi-Fi][BoW][FW/Driver] Protect BoW connection establishment * Improve BoW connection establishment speed. * * 07 05 2011 yuche.tsai * [WCXRP00000821] [Volunteer Patch][WiFi Direct][Driver] WiFi Direct Connection Speed Issue * Export one symbol for enhancement. * * 06 13 2011 eddie.chen * [WCXRP00000779] [MT6620 Wi-Fi][DRV] Add tx rx statistics in linux and use netif_rx_ni * Add tx rx statistics and netif_rx_ni. * * 05 27 2011 cp.wu * [WCXRP00000749] [MT6620 Wi-Fi][Driver] Add band edge tx power control to Wi-Fi NVRAM * invoke CMD_ID_SET_EDGE_TXPWR_LIMIT when there is valid data exist in NVRAM content. * * 05 18 2011 cp.wu * [WCXRP00000734] [MT6620 Wi-Fi][Driver] Pass PHY_PARAM in NVRAM to firmware domain * pass PHY_PARAM in NVRAM from driver to firmware. * * 05 09 2011 jeffrey.chang * [WCXRP00000710] [MT6620 Wi-Fi] Support pattern filter update function on IP address change * support ARP filter through kernel notifier * * 05 03 2011 chinghwa.yu * [WCXRP00000065] Update BoW design and settings * Use kalMemAlloc to allocate event buffer for kalIndicateBOWEvent. * * 04 27 2011 george.huang * [WCXRP00000684] [MT6620 Wi-Fi][Driver] Support P2P setting ARP filter * Support P2P ARP filter setting on early suspend/ late resume * * 04 18 2011 terry.wu * [WCXRP00000660] [MT6620 Wi-Fi][Driver] Remove flag CFG_WIFI_DIRECT_MOVED * Remove flag CFG_WIFI_DIRECT_MOVED. * * 04 15 2011 chinghwa.yu * [WCXRP00000065] Update BoW design and settings * Add BOW short range mode. * * 04 14 2011 yuche.tsai * [WCXRP00000646] [Volunteer Patch][MT6620][FW/Driver] Sigma Test Modification for some test case. * Modify some driver connection flow or behavior to pass Sigma test more easier.. * * 04 12 2011 cm.chang * [WCXRP00000634] [MT6620 Wi-Fi][Driver][FW] 2nd BSS will not support 40MHz bandwidth for concurrency * . * * 04 11 2011 george.huang * [WCXRP00000621] [MT6620 Wi-Fi][Driver] Support P2P supplicant to set power mode * export wlan functions to p2p * * 04 08 2011 pat.lu * [WCXRP00000623] [MT6620 Wi-Fi][Driver] use ARCH define to distinguish PC Linux driver * Use CONFIG_X86 instead of PC_LINUX_DRIVER_USE option to have proper compile setting for PC Linux driver * * 04 08 2011 cp.wu * [WCXRP00000540] [MT5931][Driver] Add eHPI8/eHPI16 support to Linux Glue Layer * glBusFreeIrq() should use the same pvCookie as glBusSetIrq() or request_irq()/free_irq() won't work as a pair. * * 04 08 2011 eddie.chen * [WCXRP00000617] [MT6620 Wi-Fi][DRV/FW] Fix for sigma * Fix for sigma * * 04 06 2011 cp.wu * [WCXRP00000540] [MT5931][Driver] Add eHPI8/eHPI16 support to Linux Glue Layer * 1. do not check for pvData inside wlanNetCreate() due to it is NULL for eHPI port * 2. update perm_addr as well for MAC address * 3. not calling check_mem_region() anymore for eHPI * 4. correct MSC_CS macro for 0-based notation * * 03 29 2011 cp.wu * [WCXRP00000598] [MT6620 Wi-Fi][Driver] Implementation of interface for communicating with user space process for * RESET_START and RESET_END events * fix typo. * * 03 29 2011 cp.wu * [WCXRP00000598] [MT6620 Wi-Fi][Driver] Implementation of interface for communicating with user space process for * RESET_START and RESET_END events * implement kernel-to-userspace communication via generic netlink socket for whole-chip resetting mechanism * * 03 23 2011 cp.wu * [WCXRP00000540] [MT5931][Driver] Add eHPI8/eHPI16 support to Linux Glue Layer * apply multi-queue operation only for linux kernel > 2.6.26 * * 03 22 2011 pat.lu * [WCXRP00000592] [MT6620 Wi-Fi][Driver] Support PC Linux Environment Driver Build * Add a compiler option "PC_LINUX_DRIVER_USE" for building driver in PC Linux environment. * * 03 21 2011 cp.wu * [WCXRP00000540] [MT5931][Driver] Add eHPI8/eHPI16 support to Linux Glue Layer * portability for compatible with linux 2.6.12. * * 03 21 2011 cp.wu * [WCXRP00000540] [MT5931][Driver] Add eHPI8/eHPI16 support to Linux Glue Layer * improve portability for awareness of early version of linux kernel and wireless extension. * * 03 21 2011 cp.wu * [WCXRP00000540] [MT5931][Driver] Add eHPI8/eHPI16 support to Linux Glue Layer * portability improvement * * 03 18 2011 jeffrey.chang * [WCXRP00000512] [MT6620 Wi-Fi][Driver] modify the net device relative functions to support the H/W multiple queue * remove early suspend functions * * 03 17 2011 cp.wu * [WCXRP00000562] [MT6620 Wi-Fi][Driver] I/O buffer pre-allocation to avoid physically continuous memory shortage * after system running for a long period * reverse order to prevent probing racing. * * 03 16 2011 cp.wu * [WCXRP00000562] [MT6620 Wi-Fi][Driver] I/O buffer pre-allocation to avoid physically continuous memory shortage * after system running for a long period * 1. pre-allocate physical continuous buffer while module is being loaded * 2. use pre-allocated physical continuous buffer for TX/RX DMA transfer * * The windows part remained the same as before, but added similar APIs to hide the difference. * * 03 15 2011 jeffrey.chang * [WCXRP00000558] [MT6620 Wi-Fi][MT6620 Wi-Fi][Driver] refine the queue selection algorithm for WMM * refine the queue_select function * * 03 10 2011 cp.wu * [WCXRP00000532] [MT6620 Wi-Fi][Driver] Migrate NVRAM configuration procedures from MT6620 E2 to MT6620 E3 * deprecate configuration used by MT6620 E2 * * 03 10 2011 terry.wu * [WCXRP00000505] [MT6620 Wi-Fi][Driver/FW] WiFi Direct Integration * Remove unnecessary assert and message. * * 03 08 2011 terry.wu * [WCXRP00000505] [MT6620 Wi-Fi][Driver/FW] WiFi Direct Integration * Export nicQmUpdateWmmParms. * * 03 03 2011 jeffrey.chang * [WCXRP00000512] [MT6620 Wi-Fi][Driver] modify the net device relative functions to support the H/W multiple queue * support concurrent network * * 03 03 2011 jeffrey.chang * [WCXRP00000512] [MT6620 Wi-Fi][Driver] modify the net device relative functions to support the H/W multiple queue * modify net device relative functions to support multiple H/W queues * * 02 24 2011 george.huang * [WCXRP00000495] [MT6620 Wi-Fi][FW] Support pattern filter for unwanted ARP frames * Support ARP filter during suspended * * 02 21 2011 cp.wu * [WCXRP00000482] [MT6620 Wi-Fi][Driver] Simplify logic for checking NVRAM existence in driver domain * simplify logic for checking NVRAM existence only once. * * 02 17 2011 terry.wu * [WCXRP00000459] [MT6620 Wi-Fi][Driver] Fix deference null pointer problem in wlanRemove * Fix deference a null pointer problem in wlanRemove. * * 02 16 2011 jeffrey.chang * NULL * fix compilig error * * 02 16 2011 jeffrey.chang * NULL * Add query ipv4 and ipv6 address during early suspend and late resume * * 02 15 2011 jeffrey.chang * NULL * to support early suspend in android * * 02 11 2011 yuche.tsai * [WCXRP00000431] [Volunteer Patch][MT6620][Driver] Add MLME support for deauthentication under AP(Hot-Spot) mode. * Add one more export symbol. * * 02 10 2011 yuche.tsai * [WCXRP00000431] [Volunteer Patch][MT6620][Driver] Add MLME support for deauthentication under AP(Hot-Spot) mode. * Add RX deauthentication & disassociation process under Hot-Spot mode. * * 02 09 2011 terry.wu * [WCXRP00000383] [MT6620 Wi-Fi][Driver] Separate WiFi and P2P driver into two modules * Halt p2p module init and exit until TxThread finished p2p register and unregister. * * 02 08 2011 george.huang * [WCXRP00000422] [MT6620 Wi-Fi][Driver] support query power mode OID handler * Support querying power mode OID. * * 02 08 2011 yuche.tsai * [WCXRP00000421] [Volunteer Patch][MT6620][Driver] Fix incorrect SSID length Issue * Export Deactivation Network. * * 02 01 2011 jeffrey.chang * [WCXRP00000414] KAL Timer is not unregistered when driver not loaded * Unregister the KAL timer during driver unloading * * 01 26 2011 cm.chang * [WCXRP00000395] [MT6620 Wi-Fi][Driver][FW] Search STA_REC with additional net type index argument * Allocate system RAM if fixed message or mgmt buffer is not available * * 01 19 2011 cp.wu * [WCXRP00000371] [MT6620 Wi-Fi][Driver] make linux glue layer portable for Android 2.3.1 with Linux 2.6.35.7 * add compile option to check linux version 2.6.35 for different usage of system API to improve portability * * 01 12 2011 cp.wu * [WCXRP00000357] [MT6620 Wi-Fi][Driver][Bluetooth over Wi-Fi] add another net device interface for BT AMP * implementation of separate BT_OVER_WIFI data path. * * 01 10 2011 cp.wu * [WCXRP00000349] [MT6620 Wi-Fi][Driver] make kalIoctl() of linux port as a thread safe API to avoid potential issues * due to multiple access * use mutex to protect kalIoctl() for thread safe. * * 01 04 2011 cp.wu * [WCXRP00000338] [MT6620 Wi-Fi][Driver] Separate kalMemAlloc into kmalloc and vmalloc implementations to ease * physically continuous memory demands * separate kalMemAlloc() into virtually-continuous and physically-continuous type to ease slab system pressure * * 12 15 2010 cp.wu * [WCXRP00000265] [MT6620 Wi-Fi][Driver] Remove set_mac_address routine from legacy Wi-Fi Android driver * remove set MAC address. MAC address is always loaded from NVRAM instead. * * 12 10 2010 kevin.huang * [WCXRP00000128] [MT6620 Wi-Fi][Driver] Add proc support to Android Driver for debug and driver status check * Add Linux Proc Support * * 11 01 2010 yarco.yang * [WCXRP00000149] [MT6620 WI-Fi][Driver]Fine tune performance on MT6516 platform * Add GPIO debug function * * 11 01 2010 cp.wu * [WCXRP00000056] [MT6620 Wi-Fi][Driver] NVRAM implementation with Version Check[WCXRP00000150] [MT6620 Wi-Fi][Driver] * Add implementation for querying current TX rate from firmware auto rate module * 1) Query link speed (TX rate) from firmware directly with buffering mechanism to reduce overhead * 2) Remove CNM CH-RECOVER event handling * 3) cfg read/write API renamed with kal prefix for unified naming rules. * * 10 26 2010 cp.wu * [WCXRP00000056] [MT6620 Wi-Fi][Driver] NVRAM implementation with Version Check[WCXRP00000137] [MT6620 Wi-Fi] [FW] * Support NIC capability query command * 1) update NVRAM content template to ver 1.02 * 2) add compile option for querying NIC capability (default: off) * 3) modify AIS 5GHz support to run-time option, which could be turned on by registry or NVRAM setting * 4) correct auto-rate compiler error under linux (treat warning as error) * 5) simplify usage of NVRAM and REG_INFO_T * 6) add version checking between driver and firmware * * 10 21 2010 chinghwa.yu * [WCXRP00000065] Update BoW design and settings * . * * 10 19 2010 jeffrey.chang * [WCXRP00000120] [MT6620 Wi-Fi][Driver] Refine linux kernel module to the license of MTK propietary and enable MTK * HIF by default * Refine linux kernel module to the license of MTK and enable MTK HIF * * 10 18 2010 jeffrey.chang * [WCXRP00000106] [MT6620 Wi-Fi][Driver] Enable setting multicast callback in Android * . * * 10 18 2010 cp.wu * [WCXRP00000056] [MT6620 Wi-Fi][Driver] NVRAM implementation with Version Check[WCXRP00000086] [MT6620 Wi-Fi][Driver] * The mac address is all zero at android * complete implementation of Android NVRAM access * * 09 27 2010 chinghwa.yu * [WCXRP00000063] Update BCM CoEx design and settings[WCXRP00000065] Update BoW design and settings * Update BCM/BoW design and settings. * * 09 23 2010 cp.wu * [WCXRP00000051] [MT6620 Wi-Fi][Driver] WHQL test fail in MAC address changed item * use firmware reported mac address right after wlanAdapterStart() as permanent address * * 09 21 2010 kevin.huang * [WCXRP00000052] [MT6620 Wi-Fi][Driver] Eliminate Linux Compile Warning * Eliminate Linux Compile Warning * * 09 03 2010 kevin.huang * NULL * Refine #include sequence and solve recursive/nested #include issue * * 09 01 2010 wh.su * NULL * adding the wapi support for integration test. * * 08 18 2010 yarco.yang * NULL * 1. Fixed HW checksum offload function not work under Linux issue. * 2. Add debug message. * * 08 16 2010 yarco.yang * NULL * Support Linux x86 * * 08 02 2010 jeffrey.chang * NULL * 1) modify tx service thread to avoid busy looping * 2) add spin lock declartion for linux build * * 07 29 2010 jeffrey.chang * NULL * fix memory leak for module unloading * * 07 28 2010 jeffrey.chang * NULL * 1) remove unused spinlocks * 2) enable encyption ioctls * 3) fix scan ioctl which may cause supplicant to hang * * 07 23 2010 jeffrey.chang * * bug fix: allocate regInfo when disabling firmware download * * 07 23 2010 jeffrey.chang * * use glue layer api to decrease or increase counter atomically * * 07 22 2010 jeffrey.chang * * add new spinlock * * 07 19 2010 jeffrey.chang * * modify cmd/data path for new design * * 07 08 2010 cp.wu * * [WPD00003833] [MT6620 and MT5931] Driver migration - move to new repository. * * 06 06 2010 kevin.huang * [WPD00003832][MT6620 5931] Create driver base * [MT6620 5931] Create driver base * * 05 26 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * 1) Modify set mac address code * 2) remove power management macro * * 05 10 2010 cp.wu * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support * implement basic wi-fi direct framework * * 05 07 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * prevent supplicant accessing driver during resume * * 05 07 2010 cp.wu * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support * add basic framework for implementating P2P driver hook. * * 04 27 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * 1) fix firmware download bug * 2) remove query statistics for acelerating firmware download * * 04 27 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * follow Linux's firmware framework, and remove unused kal API * * 04 21 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * add for private ioctl support * * 04 19 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * Query statistics from firmware * * 04 19 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * modify tcp/ip checksum offload flags * * 04 16 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * fix tcp/ip checksum offload bug * * 04 13 2010 cp.wu * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support * add framework for BT-over-Wi-Fi support. * * * * * * * * * * * * * * * * * 1) prPendingCmdInfo is replaced by queue for multiple handler * * * * * * * * * * * * * * * * * capability * * * * * * * * * * * * * * * * * 2) command sequence number is now increased atomically * * * * * * * * * * * * * * * * * 3) private data could be hold and taken use for other purpose * * 04 09 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * fix spinlock usage * * 04 07 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * Set MAC address from firmware * * 04 07 2010 cp.wu * [WPD00001943]Create WiFi test driver framework on WinXP * rWlanInfo should be placed at adapter rather than glue due to most operations * * * * * * are done in adapter layer. * * 04 07 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * (1)improve none-glue code portability * * (2) disable set Multicast address during atomic context * * 04 06 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * adding debug module * * 03 31 2010 wh.su * [WPD00003816][MT6620 Wi-Fi] Adding the security support * modify the wapi related code for new driver's design. * * 03 30 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * emulate NDIS Pending OID facility * * 03 26 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * fix f/w download start and load address by using config.h * * 03 26 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * [WPD00003826] Initial import for Linux port * adding firmware download support * * 03 24 2010 jeffrey.chang * [WPD00003826]Initial import for Linux port * initial import for Linux port ** \main\maintrunk.MT5921\52 2009-10-27 22:49:59 GMT mtk01090 ** Fix compile error for Linux EHPI driver ** \main\maintrunk.MT5921\51 2009-10-20 17:38:22 GMT mtk01090 ** Refine driver unloading and clean up procedure. Block requests, stop main thread and clean up queued requests, ** and then stop hw. ** \main\maintrunk.MT5921\50 2009-10-08 10:33:11 GMT mtk01090 ** Avoid accessing private data of net_device directly. Replace with netdev_priv(). Add more checking for input ** parameters and pointers. ** \main\maintrunk.MT5921\49 2009-09-28 20:19:05 GMT mtk01090 ** Add private ioctl to carry OID structures. Restructure public/private ioctl interfaces to Linux kernel. ** \main\maintrunk.MT5921\48 2009-09-03 13:58:46 GMT mtk01088 ** remove non-used code ** \main\maintrunk.MT5921\47 2009-09-03 11:40:25 GMT mtk01088 ** adding the module parameter for wapi ** \main\maintrunk.MT5921\46 2009-08-18 22:56:41 GMT mtk01090 ** Add Linux SDIO (with mmc core) support. ** Add Linux 2.6.21, 2.6.25, 2.6.26. ** Fix compile warning in Linux. ** \main\maintrunk.MT5921\45 2009-07-06 20:53:00 GMT mtk01088 ** adding the code to check the wapi 1x frame ** \main\maintrunk.MT5921\44 2009-06-23 23:18:55 GMT mtk01090 ** Add build option BUILD_USE_EEPROM and compile option CFG_SUPPORT_EXT_CONFIG for NVRAM support ** \main\maintrunk.MT5921\43 2009-02-16 23:46:51 GMT mtk01461 ** Revise the order of increasing u4TxPendingFrameNum because of CFG_TX_RET_TX_CTRL_EARLY ** \main\maintrunk.MT5921\42 2009-01-22 13:11:59 GMT mtk01088 ** set the tid and 1x value at same packet reserved field ** \main\maintrunk.MT5921\41 2008-10-20 22:43:53 GMT mtk01104 ** Fix wrong variable name "prDev" in wlanStop() ** \main\maintrunk.MT5921\40 2008-10-16 15:37:10 GMT mtk01461 ** add handle WLAN_STATUS_SUCCESS in wlanHardStartXmit() for CFG_TX_RET_TX_CTRL_EARLY ** \main\maintrunk.MT5921\39 2008-09-25 15:56:21 GMT mtk01461 ** Update driver for Code review ** \main\maintrunk.MT5921\38 2008-09-05 17:25:07 GMT mtk01461 ** Update Driver for Code Review ** \main\maintrunk.MT5921\37 2008-09-02 10:57:06 GMT mtk01461 ** Update driver for code review ** \main\maintrunk.MT5921\36 2008-08-05 01:53:28 GMT mtk01461 ** Add support for linux statistics ** \main\maintrunk.MT5921\35 2008-08-04 16:52:58 GMT mtk01461 ** Fix ASSERT if removing module in BG_SSID_SCAN state ** \main\maintrunk.MT5921\34 2008-06-13 22:52:24 GMT mtk01461 ** Revise status code handling in wlanHardStartXmit() for WLAN_STATUS_SUCCESS ** \main\maintrunk.MT5921\33 2008-05-30 18:56:53 GMT mtk01461 ** Not use wlanoidSetCurrentAddrForLinux() ** \main\maintrunk.MT5921\32 2008-05-30 14:39:40 GMT mtk01461 ** Remove WMM Assoc Flag ** \main\maintrunk.MT5921\31 2008-05-23 10:26:40 GMT mtk01084 ** modify wlanISR interface ** \main\maintrunk.MT5921\30 2008-05-03 18:52:36 GMT mtk01461 ** Fix Unset Broadcast filter when setMulticast ** \main\maintrunk.MT5921\29 2008-05-03 15:17:26 GMT mtk01461 ** Move Query Media Status to GLUE ** \main\maintrunk.MT5921\28 2008-04-24 22:48:21 GMT mtk01461 ** Revise set multicast function by using windows oid style for LP own back ** \main\maintrunk.MT5921\27 2008-04-24 12:00:08 GMT mtk01461 ** Fix multicast setting in Linux and add comment ** \main\maintrunk.MT5921\26 2008-03-28 10:40:22 GMT mtk01461 ** Fix set mac address func in Linux ** \main\maintrunk.MT5921\25 2008-03-26 15:37:26 GMT mtk01461 ** Add set MAC Address ** \main\maintrunk.MT5921\24 2008-03-26 14:24:53 GMT mtk01461 ** For Linux, set net_device has feature with checksum offload by default ** \main\maintrunk.MT5921\23 2008-03-11 14:50:52 GMT mtk01461 ** Fix typo ** \main\maintrunk.MT5921\22 2008-02-29 15:35:20 GMT mtk01088 ** add 1x decide code for sw port control ** \main\maintrunk.MT5921\21 2008-02-21 15:01:54 GMT mtk01461 ** Rearrange the set off place of GLUE spin lock in HardStartXmit ** \main\maintrunk.MT5921\20 2008-02-12 23:26:50 GMT mtk01461 ** Add debug option - Packet Order for Linux and add debug level - Event ** \main\maintrunk.MT5921\19 2007-12-11 00:11:12 GMT mtk01461 ** Fix SPIN_LOCK protection ** \main\maintrunk.MT5921\18 2007-11-30 17:02:25 GMT mtk01425 ** 1. Set Rx multicast packets mode before setting the address list ** \main\maintrunk.MT5921\17 2007-11-26 19:44:24 GMT mtk01461 ** Add OS_TIMESTAMP to packet ** \main\maintrunk.MT5921\16 2007-11-21 15:47:20 GMT mtk01088 ** fixed the unload module issue ** \main\maintrunk.MT5921\15 2007-11-07 18:37:38 GMT mtk01461 ** Fix compile warnning ** \main\maintrunk.MT5921\14 2007-11-02 01:03:19 GMT mtk01461 ** Unify TX Path for Normal and IBSS Power Save + IBSS neighbor learning ** \main\maintrunk.MT5921\13 2007-10-30 10:42:33 GMT mtk01425 ** 1. Refine for multicast list ** \main\maintrunk.MT5921\12 2007-10-25 18:08:13 GMT mtk01461 ** Add VOIP SCAN Support & Refine Roaming ** Revision 1.4 2007/07/05 07:25:33 MTK01461 ** Add Linux initial code, modify doc, add 11BB, RF init code ** ** Revision 1.3 2007/06/27 02:18:50 MTK01461 ** Update SCAN_FSM, Initial(Can Load Module), Proc(Can do Reg R/W), TX API ** ** Revision 1.2 2007/06/25 06:16:24 MTK01461 ** Update illustrations, gl_init.c, gl_kal.c, gl_kal.h, gl_os.h and RX API ** */ /******************************************************************************* * C O M P I L E R F L A G S ******************************************************************************** */ /******************************************************************************* * E X T E R N A L R E F E R E N C E S ******************************************************************************** */ #include "gl_os.h" #include "debug.h" #include "wlan_lib.h" #include "gl_wext.h" #include "gl_cfg80211.h" #include "precomp.h" #if CFG_SUPPORT_AGPS_ASSIST #include "gl_kal.h" #endif #if defined(CONFIG_MTK_TC1_FEATURE) #include #endif #include "gl_vendor.h" #ifdef FW_CFG_SUPPORT #include "fwcfg.h" #endif /******************************************************************************* * C O N S T A N T S ******************************************************************************** */ /* #define MAX_IOREQ_NUM 10 */ BOOLEAN fgIsUnderSuspend = false; #if CFG_ENABLE_WIFI_DIRECT spinlock_t g_p2p_lock; int g_u4P2PEnding = 0; int g_u4P2POnOffing = 0; #endif /******************************************************************************* * D A T A T Y P E S ******************************************************************************** */ /* Tasklet mechanism is like buttom-half in Linux. We just want to * send a signal to OS for interrupt defer processing. All resources * are NOT allowed reentry, so txPacket, ISR-DPC and ioctl must avoid preempty. */ typedef struct _WLANDEV_INFO_T { struct net_device *prDev; } WLANDEV_INFO_T, *P_WLANDEV_INFO_T; /******************************************************************************* * P U B L I C D A T A ******************************************************************************** */ MODULE_AUTHOR(NIC_AUTHOR); MODULE_DESCRIPTION(NIC_DESC); MODULE_SUPPORTED_DEVICE(NIC_NAME); MODULE_LICENSE("GPL"); #define NIC_INF_NAME "wlan%d" /* interface name */ #if CFG_TC1_FEATURE #define NIC_INF_NAME_IN_AP_MODE "legacy%d" #endif /* support to change debug module info dynamically */ UINT_8 aucDebugModule[DBG_MODULE_NUM]; UINT_32 u4DebugModule = 0; /* 4 2007/06/26, mikewu, now we don't use this, we just fix the number of wlan device to 1 */ static WLANDEV_INFO_T arWlanDevInfo[CFG_MAX_WLAN_DEVICES] = { {0} }; static UINT_32 u4WlanDevNum; /* How many NICs coexist now */ /**20150205 added work queue for sched_scan to avoid cfg80211 stop schedule scan dead loack**/ struct delayed_work sched_workq; /******************************************************************************* * P R I V A T E D A T A ******************************************************************************** */ #if CFG_ENABLE_WIFI_DIRECT static SUB_MODULE_HANDLER rSubModHandler[SUB_MODULE_NUM] = { {NULL} }; #endif #define CHAN2G(_channel, _freq, _flags) \ { \ .band = IEEE80211_BAND_2GHZ, \ .center_freq = (_freq), \ .hw_value = (_channel), \ .flags = (_flags), \ .max_antenna_gain = 0, \ .max_power = 30, \ } static struct ieee80211_channel mtk_2ghz_channels[] = { CHAN2G(1, 2412, 0), CHAN2G(2, 2417, 0), CHAN2G(3, 2422, 0), CHAN2G(4, 2427, 0), CHAN2G(5, 2432, 0), CHAN2G(6, 2437, 0), CHAN2G(7, 2442, 0), CHAN2G(8, 2447, 0), CHAN2G(9, 2452, 0), CHAN2G(10, 2457, 0), CHAN2G(11, 2462, 0), CHAN2G(12, 2467, 0), CHAN2G(13, 2472, 0), CHAN2G(14, 2484, 0), }; #define CHAN5G(_channel, _flags) \ { \ .band = IEEE80211_BAND_5GHZ, \ .center_freq = 5000 + (5 * (_channel)), \ .hw_value = (_channel), \ .flags = (_flags), \ .max_antenna_gain = 0, \ .max_power = 30, \ } static struct ieee80211_channel mtk_5ghz_channels[] = { CHAN5G(34, 0), CHAN5G(36, 0), CHAN5G(38, 0), CHAN5G(40, 0), CHAN5G(42, 0), CHAN5G(44, 0), CHAN5G(46, 0), CHAN5G(48, 0), CHAN5G(52, 0), CHAN5G(56, 0), CHAN5G(60, 0), CHAN5G(64, 0), CHAN5G(100, 0), CHAN5G(104, 0), CHAN5G(108, 0), CHAN5G(112, 0), CHAN5G(116, 0), CHAN5G(120, 0), CHAN5G(124, 0), CHAN5G(128, 0), CHAN5G(132, 0), CHAN5G(136, 0), CHAN5G(140, 0), CHAN5G(149, 0), CHAN5G(153, 0), CHAN5G(157, 0), CHAN5G(161, 0), CHAN5G(165, 0), CHAN5G(169, 0), CHAN5G(173, 0), CHAN5G(184, 0), CHAN5G(188, 0), CHAN5G(192, 0), CHAN5G(196, 0), CHAN5G(200, 0), CHAN5G(204, 0), CHAN5G(208, 0), CHAN5G(212, 0), CHAN5G(216, 0), }; /* for cfg80211 - rate table */ static struct ieee80211_rate mtk_rates[] = { RATETAB_ENT(10, 0x1000, 0), RATETAB_ENT(20, 0x1001, 0), RATETAB_ENT(55, 0x1002, 0), RATETAB_ENT(110, 0x1003, 0), /* 802.11b */ RATETAB_ENT(60, 0x2000, 0), RATETAB_ENT(90, 0x2001, 0), RATETAB_ENT(120, 0x2002, 0), RATETAB_ENT(180, 0x2003, 0), RATETAB_ENT(240, 0x2004, 0), RATETAB_ENT(360, 0x2005, 0), RATETAB_ENT(480, 0x2006, 0), RATETAB_ENT(540, 0x2007, 0), /* 802.11a/g */ }; #define mtk_a_rates (mtk_rates + 4) #define mtk_a_rates_size (sizeof(mtk_rates) / sizeof(mtk_rates[0]) - 4) #define mtk_g_rates (mtk_rates + 0) #define mtk_g_rates_size (sizeof(mtk_rates) / sizeof(mtk_rates[0]) - 0) #define MT6620_MCS_INFO \ { \ .rx_mask = {0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0},\ .rx_highest = 0, \ .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \ } #define MT6620_HT_CAP \ { \ .ht_supported = true, \ .cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 \ | IEEE80211_HT_CAP_SM_PS \ | IEEE80211_HT_CAP_GRN_FLD \ | IEEE80211_HT_CAP_SGI_20 \ | IEEE80211_HT_CAP_SGI_40, \ .ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, \ .ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE, \ .mcs = MT6620_MCS_INFO, \ } /* public for both Legacy Wi-Fi / P2P access */ struct ieee80211_supported_band mtk_band_2ghz = { .band = IEEE80211_BAND_2GHZ, .channels = mtk_2ghz_channels, .n_channels = ARRAY_SIZE(mtk_2ghz_channels), .bitrates = mtk_g_rates, .n_bitrates = mtk_g_rates_size, .ht_cap = MT6620_HT_CAP, }; /* public for both Legacy Wi-Fi / P2P access */ struct ieee80211_supported_band mtk_band_5ghz = { .band = IEEE80211_BAND_5GHZ, .channels = mtk_5ghz_channels, .n_channels = ARRAY_SIZE(mtk_5ghz_channels), .bitrates = mtk_a_rates, .n_bitrates = mtk_a_rates_size, .ht_cap = MT6620_HT_CAP, }; static const UINT_32 mtk_cipher_suites[] = { /* keep WEP first, it may be removed below */ WLAN_CIPHER_SUITE_WEP40, WLAN_CIPHER_SUITE_WEP104, WLAN_CIPHER_SUITE_TKIP, WLAN_CIPHER_SUITE_CCMP, /* keep last -- depends on hw flags! */ WLAN_CIPHER_SUITE_AES_CMAC }; static struct cfg80211_ops mtk_wlan_ops = { .suspend = mtk_cfg80211_suspend, .resume = mtk_cfg80211_resume, .change_virtual_intf = mtk_cfg80211_change_iface, .add_key = mtk_cfg80211_add_key, .get_key = mtk_cfg80211_get_key, .del_key = mtk_cfg80211_del_key, .set_default_key = mtk_cfg80211_set_default_key, .set_default_mgmt_key = mtk_cfg80211_set_default_mgmt_key, .get_station = mtk_cfg80211_get_station, .change_station = mtk_cfg80211_change_station, .add_station = mtk_cfg80211_add_station, .del_station = mtk_cfg80211_del_station, .scan = mtk_cfg80211_scan, .connect = mtk_cfg80211_connect, .disconnect = mtk_cfg80211_disconnect, .join_ibss = mtk_cfg80211_join_ibss, .leave_ibss = mtk_cfg80211_leave_ibss, .set_power_mgmt = mtk_cfg80211_set_power_mgmt, .set_pmksa = mtk_cfg80211_set_pmksa, .del_pmksa = mtk_cfg80211_del_pmksa, .flush_pmksa = mtk_cfg80211_flush_pmksa, .assoc = mtk_cfg80211_assoc, /* Action Frame TX/RX */ .remain_on_channel = mtk_cfg80211_remain_on_channel, .cancel_remain_on_channel = mtk_cfg80211_cancel_remain_on_channel, .mgmt_tx = mtk_cfg80211_mgmt_tx, /* .mgmt_tx_cancel_wait = mtk_cfg80211_mgmt_tx_cancel_wait, */ .mgmt_frame_register = mtk_cfg80211_mgmt_frame_register, #ifdef CONFIG_NL80211_TESTMODE .testmode_cmd = mtk_cfg80211_testmode_cmd, #endif #if (CFG_SUPPORT_TDLS == 1) .tdls_mgmt = TdlsexCfg80211TdlsMgmt, .tdls_oper = TdlsexCfg80211TdlsOper, #endif /* CFG_SUPPORT_TDLS */ #if 1 /* Remove schedule_scan because we need more verification for NLO */ .sched_scan_start = mtk_cfg80211_sched_scan_start, .sched_scan_stop = mtk_cfg80211_sched_scan_stop, #endif }; static const struct wiphy_vendor_command mtk_wlan_vendor_ops[] = { { { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_SUBCMD_GET_CAPABILITIES}, .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV, .doit = mtk_cfg80211_vendor_get_gscan_capabilities}, { { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_SUBCMD_SET_CONFIG}, .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV, .doit = mtk_cfg80211_vendor_set_config}, { { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_SUBCMD_SET_SCAN_CONFIG}, .flags = WIPHY_VENDOR_CMD_NEED_WDEV, .doit = mtk_cfg80211_vendor_set_scan_config}, { { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_SUBCMD_ENABLE_GSCAN}, .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV, .doit = mtk_cfg80211_vendor_enable_scan}, { { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_SUBCMD_ENABLE_FULL_SCAN_RESULTS}, .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV, .doit = mtk_cfg80211_vendor_enable_full_scan_results}, { { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_SUBCMD_GET_SCAN_RESULTS}, .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV, .doit = mtk_cfg80211_vendor_get_scan_results}, { { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_SUBCMD_GET_CHANNEL_LIST}, .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV, .doit = mtk_cfg80211_vendor_get_channel_list}, { { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_SUBCMD_SET_SIGNIFICANT_CHANGE_CONFIG}, .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV, .doit = mtk_cfg80211_vendor_set_significant_change}, { { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_SUBCMD_SET_HOTLIST}, .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV, .doit = mtk_cfg80211_vendor_set_hotlist}, /*Link Layer Statistics */ { { .vendor_id = GOOGLE_OUI, .subcmd = LSTATS_SUBCMD_GET_INFO}, .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV, .doit = mtk_cfg80211_vendor_llstats_get_info}, { { .vendor_id = GOOGLE_OUI, .subcmd = RTT_SUBCMD_GETCAPABILITY}, .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_NETDEV, .doit = mtk_cfg80211_vendor_get_rtt_capabilities}, }; static const struct nl80211_vendor_cmd_info mtk_wlan_vendor_events[] = { { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_EVENT_SIGNIFICANT_CHANGE_RESULTS}, { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_EVENT_HOTLIST_RESULTS_FOUND}, { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_EVENT_SCAN_RESULTS_AVAILABLE}, { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_EVENT_FULL_SCAN_RESULTS}, { .vendor_id = GOOGLE_OUI, .subcmd = RTT_EVENT_COMPLETE}, { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_EVENT_COMPLETE_SCAN}, { .vendor_id = GOOGLE_OUI, .subcmd = GSCAN_EVENT_HOTLIST_RESULTS_LOST}, }; /* There isn't a lot of sense in it, but you can transmit anything you like */ static const struct ieee80211_txrx_stypes mtk_cfg80211_ais_default_mgmt_stypes[NUM_NL80211_IFTYPES] = { [NL80211_IFTYPE_ADHOC] = { .tx = 0xffff, .rx = BIT(IEEE80211_STYPE_ACTION >> 4) }, [NL80211_IFTYPE_STATION] = { .tx = 0xffff, .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | BIT(IEEE80211_STYPE_PROBE_REQ >> 4) }, [NL80211_IFTYPE_AP] = { .tx = 0xffff, .rx = BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | BIT(IEEE80211_STYPE_ACTION >> 4) }, [NL80211_IFTYPE_AP_VLAN] = { /* copy AP */ .tx = 0xffff, .rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) | BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) | BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | BIT(IEEE80211_STYPE_DISASSOC >> 4) | BIT(IEEE80211_STYPE_AUTH >> 4) | BIT(IEEE80211_STYPE_DEAUTH >> 4) | BIT(IEEE80211_STYPE_ACTION >> 4) }, [NL80211_IFTYPE_P2P_CLIENT] = { .tx = 0xffff, .rx = BIT(IEEE80211_STYPE_ACTION >> 4) | BIT(IEEE80211_STYPE_PROBE_REQ >> 4) }, [NL80211_IFTYPE_P2P_GO] = { .tx = 0xffff, .rx = BIT(IEEE80211_STYPE_PROBE_REQ >> 4) | BIT(IEEE80211_STYPE_ACTION >> 4) } }; /******************************************************************************* * M A C R O S ******************************************************************************** */ /******************************************************************************* * F U N C T I O N D E C L A R A T I O N S ******************************************************************************** */ /******************************************************************************* * F U N C T I O N S ******************************************************************************** */ /*----------------------------------------------------------------------------*/ /*! * \brief Override the implementation of select queue * * \param[in] dev Pointer to struct net_device * \param[in] skb Pointer to struct skb_buff * * \return (none) */ /*----------------------------------------------------------------------------*/ unsigned int _cfg80211_classify8021d(struct sk_buff *skb) { unsigned int dscp = 0; /* skb->priority values from 256->263 are magic values * directly indicate a specific 802.1d priority. This is * to allow 802.1d priority to be passed directly in from * tags */ if (skb->priority >= 256 && skb->priority <= 263) return skb->priority - 256; switch (skb->protocol) { case htons(ETH_P_IP): dscp = ip_hdr(skb)->tos & 0xfc; break; } return dscp >> 5; } static const UINT_16 au16Wlan1dToQueueIdx[8] = { 1, 0, 0, 1, 2, 2, 3, 3 }; static UINT_16 wlanSelectQueue(struct net_device *dev, struct sk_buff *skb, void *accel_priv, select_queue_fallback_t fallback) { skb->priority = _cfg80211_classify8021d(skb); return au16Wlan1dToQueueIdx[skb->priority]; } /*----------------------------------------------------------------------------*/ /*! * \brief Load NVRAM data and translate it into REG_INFO_T * * \param[in] prGlueInfo Pointer to struct GLUE_INFO_T * \param[out] prRegInfo Pointer to struct REG_INFO_T * * \return (none) */ /*----------------------------------------------------------------------------*/ static void glLoadNvram(IN P_GLUE_INFO_T prGlueInfo, OUT P_REG_INFO_T prRegInfo) { UINT_32 i, j; UINT_8 aucTmp[2]; PUINT_8 pucDest; ASSERT(prGlueInfo); ASSERT(prRegInfo); if ((!prGlueInfo) || (!prRegInfo)) return; if (kalCfgDataRead16(prGlueInfo, 0, (PUINT_16) aucTmp) == TRUE) { prGlueInfo->fgNvramAvailable = TRUE; /* load MAC Address */ #if !defined(CONFIG_MTK_TC1_FEATURE) for (i = 0; i < PARAM_MAC_ADDR_LEN; i += sizeof(UINT_16)) { kalCfgDataRead16(prGlueInfo, OFFSET_OF(WIFI_CFG_PARAM_STRUCT, aucMacAddress) + i, (PUINT_16) (((PUINT_8) prRegInfo->aucMacAddr) + i)); } #else TC1_FAC_NAME(FacReadWifiMacAddr) ((unsigned char *)prRegInfo->aucMacAddr); #endif /* load country code */ kalCfgDataRead16(prGlueInfo, OFFSET_OF(WIFI_CFG_PARAM_STRUCT, aucCountryCode[0]), (PUINT_16) aucTmp); /* cast to wide characters */ prRegInfo->au2CountryCode[0] = (UINT_16) aucTmp[0]; prRegInfo->au2CountryCode[1] = (UINT_16) aucTmp[1]; /* load default normal TX power */ for (i = 0; i < sizeof(TX_PWR_PARAM_T); i += sizeof(UINT_16)) { kalCfgDataRead16(prGlueInfo, OFFSET_OF(WIFI_CFG_PARAM_STRUCT, rTxPwr) + i, (PUINT_16) (((PUINT_8) &(prRegInfo->rTxPwr)) + i)); } /* load feature flags */ kalCfgDataRead16(prGlueInfo, OFFSET_OF(WIFI_CFG_PARAM_STRUCT, ucTxPwrValid), (PUINT_16) aucTmp); prRegInfo->ucTxPwrValid = aucTmp[0]; prRegInfo->ucSupport5GBand = aucTmp[1]; kalCfgDataRead16(prGlueInfo, OFFSET_OF(WIFI_CFG_PARAM_STRUCT, uc2G4BwFixed20M), (PUINT_16) aucTmp); prRegInfo->uc2G4BwFixed20M = aucTmp[0]; prRegInfo->uc5GBwFixed20M = aucTmp[1]; kalCfgDataRead16(prGlueInfo, OFFSET_OF(WIFI_CFG_PARAM_STRUCT, ucEnable5GBand), (PUINT_16) aucTmp); prRegInfo->ucEnable5GBand = aucTmp[0]; /* load EFUSE overriding part */ for (i = 0; i < sizeof(prRegInfo->aucEFUSE); i += sizeof(UINT_16)) { kalCfgDataRead16(prGlueInfo, OFFSET_OF(WIFI_CFG_PARAM_STRUCT, aucEFUSE) + i, (PUINT_16) (((PUINT_8) &(prRegInfo->aucEFUSE)) + i)); } /* load band edge tx power control */ kalCfgDataRead16(prGlueInfo, OFFSET_OF(WIFI_CFG_PARAM_STRUCT, fg2G4BandEdgePwrUsed), (PUINT_16) aucTmp); prRegInfo->fg2G4BandEdgePwrUsed = (BOOLEAN) aucTmp[0]; if (aucTmp[0]) { prRegInfo->cBandEdgeMaxPwrCCK = (INT_8) aucTmp[1]; kalCfgDataRead16(prGlueInfo, OFFSET_OF(WIFI_CFG_PARAM_STRUCT, cBandEdgeMaxPwrOFDM20), (PUINT_16) aucTmp); prRegInfo->cBandEdgeMaxPwrOFDM20 = (INT_8) aucTmp[0]; prRegInfo->cBandEdgeMaxPwrOFDM40 = (INT_8) aucTmp[1]; } /* load regulation subbands */ kalCfgDataRead16(prGlueInfo, OFFSET_OF(WIFI_CFG_PARAM_STRUCT, ucRegChannelListMap), (PUINT_16) aucTmp); prRegInfo->eRegChannelListMap = (ENUM_REG_CH_MAP_T) aucTmp[0]; prRegInfo->ucRegChannelListIndex = aucTmp[1]; if (prRegInfo->eRegChannelListMap == REG_CH_MAP_CUSTOMIZED) { for (i = 0; i < MAX_SUBBAND_NUM; i++) { pucDest = (PUINT_8) &prRegInfo->rDomainInfo.rSubBand[i]; for (j = 0; j < 6; j += sizeof(UINT_16)) { kalCfgDataRead16(prGlueInfo, OFFSET_OF(WIFI_CFG_PARAM_STRUCT, aucRegSubbandInfo) + (i * 6 + j), (PUINT_16) aucTmp); *pucDest++ = aucTmp[0]; *pucDest++ = aucTmp[1]; } } } /* load RSSI compensation */ kalCfgDataRead16(prGlueInfo, OFFSET_OF(WIFI_CFG_PARAM_STRUCT, uc2GRssiCompensation), (PUINT_16) aucTmp); prRegInfo->uc2GRssiCompensation = aucTmp[0]; prRegInfo->uc5GRssiCompensation = aucTmp[1]; kalCfgDataRead16(prGlueInfo, OFFSET_OF(WIFI_CFG_PARAM_STRUCT, fgRssiCompensationValidbit), (PUINT_16) aucTmp); prRegInfo->fgRssiCompensationValidbit = aucTmp[0]; prRegInfo->ucRxAntennanumber = aucTmp[1]; } else { prGlueInfo->fgNvramAvailable = FALSE; } } #if CFG_ENABLE_WIFI_DIRECT /*----------------------------------------------------------------------------*/ /*! * \brief called by txthread, run sub module init function * * \param[in] prGlueInfo Pointer to struct GLUE_INFO_T * * \return (none) */ /*----------------------------------------------------------------------------*/ VOID wlanSubModRunInit(P_GLUE_INFO_T prGlueInfo) { /*now, we only have p2p module */ if (rSubModHandler[P2P_MODULE].fgIsInited == FALSE) { rSubModHandler[P2P_MODULE].subModInit(prGlueInfo); rSubModHandler[P2P_MODULE].fgIsInited = TRUE; } } /*----------------------------------------------------------------------------*/ /*! * \brief called by txthread, run sub module exit function * * \param[in] prGlueInfo Pointer to struct GLUE_INFO_T * * \return (none) */ /*----------------------------------------------------------------------------*/ VOID wlanSubModRunExit(P_GLUE_INFO_T prGlueInfo) { /*now, we only have p2p module */ if (rSubModHandler[P2P_MODULE].fgIsInited == TRUE) { rSubModHandler[P2P_MODULE].subModExit(prGlueInfo); rSubModHandler[P2P_MODULE].fgIsInited = FALSE; } } /*----------------------------------------------------------------------------*/ /*! * \brief set sub module init flag, force TxThread to run sub modle init * * \param[in] prGlueInfo Pointer to struct GLUE_INFO_T * * \return (none) */ /*----------------------------------------------------------------------------*/ BOOLEAN wlanSubModInit(P_GLUE_INFO_T prGlueInfo) { /* 4 Mark HALT, notify main thread to finish current job */ prGlueInfo->ulFlag |= GLUE_FLAG_SUB_MOD_INIT; /* wake up main thread */ wake_up_interruptible(&prGlueInfo->waitq); /* wait main thread finish sub module INIT */ wait_for_completion_interruptible(&prGlueInfo->rSubModComp); #if 0 if (prGlueInfo->prAdapter->fgIsP2PRegistered) p2pNetRegister(prGlueInfo); #endif return TRUE; } /*----------------------------------------------------------------------------*/ /*! * \brief set sub module exit flag, force TxThread to run sub modle exit * * \param[in] prGlueInfo Pointer to struct GLUE_INFO_T * * \return (none) */ /*----------------------------------------------------------------------------*/ BOOLEAN wlanSubModExit(P_GLUE_INFO_T prGlueInfo) { #if 0 if (prGlueInfo->prAdapter->fgIsP2PRegistered) p2pNetUnregister(prGlueInfo); #endif /* 4 Mark HALT, notify main thread to finish current job */ prGlueInfo->ulFlag |= GLUE_FLAG_SUB_MOD_EXIT; /* wake up main thread */ wake_up_interruptible(&prGlueInfo->waitq); /* wait main thread finish sub module EXIT */ wait_for_completion_interruptible(&prGlueInfo->rSubModComp); return TRUE; } /*----------------------------------------------------------------------------*/ /*! * \brief set by sub module, indicate sub module is already inserted * * \param[in] rSubModInit, function pointer point to sub module init function * \param[in] rSubModExit, function pointer point to sub module exit function * \param[in] eSubModIdx, sub module index * * \return (none) */ /*----------------------------------------------------------------------------*/ VOID wlanSubModRegisterInitExit(SUB_MODULE_INIT rSubModInit, SUB_MODULE_EXIT rSubModExit, ENUM_SUB_MODULE_IDX_T eSubModIdx) { rSubModHandler[eSubModIdx].subModInit = rSubModInit; rSubModHandler[eSubModIdx].subModExit = rSubModExit; rSubModHandler[eSubModIdx].fgIsInited = FALSE; } #if 0 /*----------------------------------------------------------------------------*/ /*! * \brief check wlan is launched or not * * \param[in] (none) * * \return TRUE, wlan is already started * FALSE, wlan is not started yet */ /*----------------------------------------------------------------------------*/ BOOLEAN wlanIsLaunched(VOID) { struct net_device *prDev = NULL; P_GLUE_INFO_T prGlueInfo = NULL; /* 4 <0> Sanity check */ ASSERT(u4WlanDevNum <= CFG_MAX_WLAN_DEVICES); if (0 == u4WlanDevNum) return FALSE; prDev = arWlanDevInfo[u4WlanDevNum - 1].prDev; ASSERT(prDev); if (NULL == prDev) return FALSE; prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prDev)); ASSERT(prGlueInfo); if (NULL == prGlueInfo) return FALSE; return prGlueInfo->prAdapter->fgIsWlanLaunched; } #endif /*----------------------------------------------------------------------------*/ /*! * \brief Export wlan GLUE_INFO_T pointer to p2p module * * \param[in] prGlueInfo Pointer to struct GLUE_INFO_T * * \return TRUE: get GlueInfo pointer successfully * FALSE: wlan is not started yet */ /*---------------------------------------------------------------------------*/ BOOLEAN wlanExportGlueInfo(P_GLUE_INFO_T *prGlueInfoExpAddr) { struct net_device *prDev = NULL; P_GLUE_INFO_T prGlueInfo = NULL; if (0 == u4WlanDevNum) return FALSE; prDev = arWlanDevInfo[u4WlanDevNum - 1].prDev; if (NULL == prDev) return FALSE; prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prDev)); if (NULL == prGlueInfo) return FALSE; if (FALSE == prGlueInfo->prAdapter->fgIsWlanLaunched) return FALSE; *prGlueInfoExpAddr = prGlueInfo; return TRUE; } #endif /*----------------------------------------------------------------------------*/ /*! * \brief Release prDev from wlandev_array and free tasklet object related to it. * * \param[in] prDev Pointer to struct net_device * * \return (none) */ /*----------------------------------------------------------------------------*/ static void wlanClearDevIdx(struct net_device *prDev) { int i; ASSERT(prDev); for (i = 0; i < CFG_MAX_WLAN_DEVICES; i++) { if (arWlanDevInfo[i].prDev == prDev) { arWlanDevInfo[i].prDev = NULL; u4WlanDevNum--; } } } /* end of wlanClearDevIdx() */ /*----------------------------------------------------------------------------*/ /*! * \brief Allocate an unique interface index, net_device::ifindex member for this * wlan device. Store the net_device in wlandev_array, and initialize * tasklet object related to it. * * \param[in] prDev Pointer to struct net_device * * \retval >= 0 The device number. * \retval -1 Fail to get index. */ /*----------------------------------------------------------------------------*/ static int wlanGetDevIdx(struct net_device *prDev) { int i; ASSERT(prDev); for (i = 0; i < CFG_MAX_WLAN_DEVICES; i++) { if (arWlanDevInfo[i].prDev == (struct net_device *)NULL) { /* Reserve 2 bytes space to store one digit of * device number and NULL terminator. */ arWlanDevInfo[i].prDev = prDev; u4WlanDevNum++; return i; } } return -1; } /* end of wlanGetDevIdx() */ /*----------------------------------------------------------------------------*/ /*! * \brief A method of struct net_device, a primary SOCKET interface to configure * the interface lively. Handle an ioctl call on one of our devices. * Everything Linux ioctl specific is done here. Then we pass the contents * of the ifr->data to the request message handler. * * \param[in] prDev Linux kernel netdevice * * \param[in] prIFReq Our private ioctl request structure, typed for the generic * struct ifreq so we can use ptr to function * * \param[in] cmd Command ID * * \retval WLAN_STATUS_SUCCESS The IOCTL command is executed successfully. * \retval OTHER The execution of IOCTL command is failed. */ /*----------------------------------------------------------------------------*/ int wlanDoIOCTL(struct net_device *prDev, struct ifreq *prIFReq, int i4Cmd) { P_GLUE_INFO_T prGlueInfo = NULL; int ret = 0; /* Verify input parameters for the following functions */ ASSERT(prDev && prIFReq); if (!prDev || !prIFReq) { DBGLOG(INIT, WARN, "%s Invalid input data\n", __func__); return -EINVAL; } prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prDev)); ASSERT(prGlueInfo); if (!prGlueInfo) { DBGLOG(INIT, WARN, "%s No glue info\n", __func__); return -EFAULT; } if (prGlueInfo->u4ReadyFlag == 0) return -EINVAL; /* printk ("ioctl %x\n", i4Cmd); */ if (i4Cmd == SIOCGIWPRIV) { /* 0x8B0D, get private ioctl table */ ret = wext_get_priv(prDev, prIFReq); } else if ((i4Cmd >= SIOCIWFIRST) && (i4Cmd < SIOCIWFIRSTPRIV)) { /* 0x8B00 ~ 0x8BDF, wireless extension region */ ret = wext_support_ioctl(prDev, prIFReq, i4Cmd); } else if ((i4Cmd >= SIOCIWFIRSTPRIV) && (i4Cmd < SIOCIWLASTPRIV)) { /* 0x8BE0 ~ 0x8BFF, private ioctl region */ ret = priv_support_ioctl(prDev, prIFReq, i4Cmd); } else if (i4Cmd == SIOCDEVPRIVATE + 1) { ret = priv_support_driver_cmd(prDev, prIFReq, i4Cmd); } else { DBGLOG(INIT, WARN, "Unexpected ioctl command: 0x%04x\n", i4Cmd); /* return 0 for safe? */ } return ret; } /* end of wlanDoIOCTL() */ /*----------------------------------------------------------------------------*/ /*! * \brief This function is to set multicast list and set rx mode. * * \param[in] prDev Pointer to struct net_device * * \return (none) */ /*----------------------------------------------------------------------------*/ static struct delayed_work workq; static struct net_device *gPrDev; static BOOLEAN fgIsWorkMcStart = FALSE; static BOOLEAN fgIsWorkMcEverInit = FALSE; static struct wireless_dev *gprWdev; #ifdef CONFIG_PM static const struct wiphy_wowlan_support wlan_wowlan_support = { .flags = WIPHY_WOWLAN_DISCONNECT | WIPHY_WOWLAN_ANY, }; #endif static void createWirelessDevice(void) { struct wiphy *prWiphy = NULL; struct wireless_dev *prWdev = NULL; #if CFG_SUPPORT_PERSIST_NETDEV struct net_device *prNetDev = NULL; #endif /* <1.1> Create wireless_dev */ prWdev = kzalloc(sizeof(struct wireless_dev), GFP_KERNEL); if (!prWdev) { DBGLOG(INIT, ERROR, "Allocating memory to wireless_dev context failed\n"); return; } /* <1.2> Create wiphy */ prWiphy = wiphy_new(&mtk_wlan_ops, sizeof(GLUE_INFO_T)); if (!prWiphy) { DBGLOG(INIT, ERROR, "Allocating memory to wiphy device failed\n"); goto free_wdev; } /* <1.3> configure wireless_dev & wiphy */ prWdev->iftype = NL80211_IFTYPE_STATION; prWiphy->max_scan_ssids = 1; /* FIXME: for combo scan */ prWiphy->max_scan_ie_len = 512; prWiphy->max_sched_scan_ssids = CFG_SCAN_SSID_MAX_NUM; prWiphy->max_match_sets = CFG_SCAN_SSID_MATCH_MAX_NUM; prWiphy->max_sched_scan_ie_len = CFG_CFG80211_IE_BUF_LEN; prWiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC); prWiphy->bands[IEEE80211_BAND_2GHZ] = &mtk_band_2ghz; /* always assign 5Ghz bands here, if the chip is not support 5Ghz, bands[IEEE80211_BAND_5GHZ] will be assign to NULL */ prWiphy->bands[IEEE80211_BAND_5GHZ] = &mtk_band_5ghz; prWiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM; prWiphy->cipher_suites = (const u32 *)mtk_cipher_suites; prWiphy->n_cipher_suites = ARRAY_SIZE(mtk_cipher_suites); prWiphy->flags = WIPHY_FLAG_SUPPORTS_FW_ROAM | WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL | WIPHY_FLAG_SUPPORTS_SCHED_SCAN; prWiphy->regulatory_flags = REGULATORY_CUSTOM_REG; #if (CFG_SUPPORT_TDLS == 1) TDLSEX_WIPHY_FLAGS_INIT(prWiphy->flags); #endif /* CFG_SUPPORT_TDLS */ prWiphy->max_remain_on_channel_duration = 5000; prWiphy->mgmt_stypes = mtk_cfg80211_ais_default_mgmt_stypes; prWiphy->vendor_commands = mtk_wlan_vendor_ops; prWiphy->n_vendor_commands = sizeof(mtk_wlan_vendor_ops) / sizeof(struct wiphy_vendor_command); prWiphy->vendor_events = mtk_wlan_vendor_events; prWiphy->n_vendor_events = ARRAY_SIZE(mtk_wlan_vendor_events); /* <1.4> wowlan support */ #ifdef CONFIG_PM prWiphy->wowlan = &wlan_wowlan_support; #endif #ifdef CONFIG_CFG80211_WEXT /* <1.5> Use wireless extension to replace IOCTL */ prWiphy->wext = &wext_handler_def; #endif if (wiphy_register(prWiphy) < 0) { DBGLOG(INIT, ERROR, "wiphy_register error\n"); goto free_wiphy; } prWdev->wiphy = prWiphy; #if CFG_SUPPORT_PERSIST_NETDEV /* <2> allocate and register net_device */ #if CFG_TC1_FEATURE if (wlan_if_changed) prNetDev = alloc_netdev_mq(sizeof(P_GLUE_INFO_T), NIC_INF_NAME_IN_AP_MODE, NET_NAME_PREDICTABLE, ether_setup, CFG_MAX_TXQ_NUM); else #else prNetDev = alloc_netdev_mq(sizeof(P_GLUE_INFO_T), NIC_INF_NAME, NET_NAME_PREDICTABLE, ether_setup, CFG_MAX_TXQ_NUM); #endif if (!prNetDev) { DBGLOG(INIT, ERROR, "Allocating memory to net_device context failed\n"); goto unregister_wiphy; } *((P_GLUE_INFO_T *) netdev_priv(prNetDev)) = (P_GLUE_INFO_T) wiphy_priv(prWiphy); prNetDev->netdev_ops = &wlan_netdev_ops; #ifdef CONFIG_WIRELESS_EXT prNetDev->wireless_handlers = &wext_handler_def; #endif netif_carrier_off(prNetDev); netif_tx_stop_all_queues(prNetDev); /* <2.1> co-relate with wireless_dev bi-directionally */ prNetDev->ieee80211_ptr = prWdev; prWdev->netdev = prNetDev; #if CFG_TCP_IP_CHKSUM_OFFLOAD prNetDev->features = NETIF_F_HW_CSUM; #endif /* <2.2> co-relate net device & device tree */ SET_NETDEV_DEV(prNetDev, wiphy_dev(prWiphy)); /* <2.3> register net_device */ if (register_netdev(prWdev->netdev) < 0) { DBGLOG(INIT, ERROR, "wlanNetRegister: net_device context is not registered.\n"); goto unregister_wiphy; } #endif /* CFG_SUPPORT_PERSIST_NETDEV */ gprWdev = prWdev; DBGLOG(INIT, INFO, "create wireless device success\n"); return; #if CFG_SUPPORT_PERSIST_NETDEV unregister_wiphy: wiphy_unregister(prWiphy); #endif free_wiphy: wiphy_free(prWiphy); free_wdev: kfree(prWdev); } static void destroyWirelessDevice(void) { #if CFG_SUPPORT_PERSIST_NETDEV unregister_netdev(gprWdev->netdev); free_netdev(gprWdev->netdev); #endif wiphy_unregister(gprWdev->wiphy); wiphy_free(gprWdev->wiphy); kfree(gprWdev); gprWdev = NULL; } static void wlanSetMulticastList(struct net_device *prDev) { gPrDev = prDev; schedule_delayed_work(&workq, 0); } /* FIXME: Since we cannot sleep in the wlanSetMulticastList, we arrange * another workqueue for sleeping. We don't want to block * tx_thread, so we can't let tx_thread to do this */ static void wlanSetMulticastListWorkQueue(struct work_struct *work) { P_GLUE_INFO_T prGlueInfo = NULL; UINT_32 u4PacketFilter = 0; UINT_32 u4SetInfoLen; struct net_device *prDev = gPrDev; fgIsWorkMcStart = TRUE; DBGLOG(INIT, INFO, "wlanSetMulticastListWorkQueue start...\n"); if (kalHaltLock(KAL_HALT_LOCK_TIMEOUT_NORMAL_CASE)) return; if (kalIsHalted()) { fgIsWorkMcStart = FALSE; kalHaltUnlock(); return; } prGlueInfo = (NULL != prDev) ? *((P_GLUE_INFO_T *) netdev_priv(prDev)) : NULL; ASSERT(prDev); ASSERT(prGlueInfo); if (!prDev || !prGlueInfo) { DBGLOG(INIT, WARN, "abnormal dev or skb: prDev(0x%p), prGlueInfo(0x%p)\n", prDev, prGlueInfo); fgIsWorkMcStart = FALSE; kalHaltUnlock(); return; } if (prDev->flags & IFF_PROMISC) u4PacketFilter |= PARAM_PACKET_FILTER_PROMISCUOUS; if (prDev->flags & IFF_BROADCAST) u4PacketFilter |= PARAM_PACKET_FILTER_BROADCAST; if (prDev->flags & IFF_MULTICAST) { if ((prDev->flags & IFF_ALLMULTI) || (netdev_mc_count(prDev) > MAX_NUM_GROUP_ADDR)) { u4PacketFilter |= PARAM_PACKET_FILTER_ALL_MULTICAST; } else { u4PacketFilter |= PARAM_PACKET_FILTER_MULTICAST; } } kalHaltUnlock(); if (kalIoctl(prGlueInfo, wlanoidSetCurrentPacketFilter, &u4PacketFilter, sizeof(u4PacketFilter), FALSE, FALSE, TRUE, FALSE, &u4SetInfoLen) != WLAN_STATUS_SUCCESS) { fgIsWorkMcStart = FALSE; return; } if (u4PacketFilter & PARAM_PACKET_FILTER_MULTICAST) { /* Prepare multicast address list */ struct netdev_hw_addr *ha; PUINT_8 prMCAddrList = NULL; UINT_32 i = 0; if (kalHaltLock(KAL_HALT_LOCK_TIMEOUT_NORMAL_CASE)) return; if (kalIsHalted()) { fgIsWorkMcStart = FALSE; kalHaltUnlock(); /*DBGLOG(INIT, WARN, "wlanSetMulticastListWorkQueue g_u4HaltFlag=%d\n", g_u4HaltFlag);*/ return; } prMCAddrList = kalMemAlloc(MAX_NUM_GROUP_ADDR * ETH_ALEN, VIR_MEM_TYPE); netdev_for_each_mc_addr(ha, prDev) { if (i < MAX_NUM_GROUP_ADDR) { memcpy((prMCAddrList + i * ETH_ALEN), ha->addr, ETH_ALEN); i++; } } kalHaltUnlock(); kalIoctl(prGlueInfo, wlanoidSetMulticastList, prMCAddrList, (i * ETH_ALEN), FALSE, FALSE, TRUE, FALSE, &u4SetInfoLen); kalMemFree(prMCAddrList, VIR_MEM_TYPE, MAX_NUM_GROUP_ADDR * ETH_ALEN); } fgIsWorkMcStart = FALSE; DBGLOG(INIT, INFO, "wlanSetMulticastListWorkQueue end\n"); } /* end of wlanSetMulticastList() */ /*----------------------------------------------------------------------------*/ /*! * \brief To indicate scheduled scan has been stopped * * \param[in] * prGlueInfo * * \return * None */ /*----------------------------------------------------------------------------*/ VOID wlanSchedScanStoppedWorkQueue(struct work_struct *work) { P_GLUE_INFO_T prGlueInfo = NULL; struct net_device *prDev = gPrDev; prGlueInfo = (NULL != prDev) ? *((P_GLUE_INFO_T *) netdev_priv(prDev)) : NULL; if (!prGlueInfo) { DBGLOG(SCN, ERROR, "prGlueInfo == NULL unexpected\n"); return; } /* 2. indication to cfg80211 */ /* 20150205 change cfg80211_sched_scan_stopped to work queue due to sched_scan_mtx dead lock issue */ cfg80211_sched_scan_stopped(priv_to_wiphy(prGlueInfo)); DBGLOG(SCN, INFO, "cfg80211_sched_scan_stopped event send done\n"); } /* FIXME: Since we cannot sleep in the wlanSetMulticastList, we arrange * another workqueue for sleeping. We don't want to block * tx_thread, so we can't let tx_thread to do this */ void p2pSetMulticastListWorkQueueWrapper(P_GLUE_INFO_T prGlueInfo) { ASSERT(prGlueInfo); if (!prGlueInfo) { DBGLOG(INIT, WARN, "abnormal dev or skb: prGlueInfo(0x%p)\n", prGlueInfo); return; } #if CFG_ENABLE_WIFI_DIRECT if (prGlueInfo->prAdapter->fgIsP2PRegistered) mtk_p2p_wext_set_Multicastlist(prGlueInfo); #endif } /* end of p2pSetMulticastListWorkQueueWrapper() */ /*----------------------------------------------------------------------------*/ /*! * \brief This function is TX entry point of NET DEVICE. * * \param[in] prSkb Pointer of the sk_buff to be sent * \param[in] prDev Pointer to struct net_device * * \retval NETDEV_TX_OK - on success. * \retval NETDEV_TX_BUSY - on failure, packet will be discarded by upper layer. */ /*----------------------------------------------------------------------------*/ int wlanHardStartXmit(struct sk_buff *prSkb, struct net_device *prDev) { P_GLUE_INFO_T prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prDev)); P_QUE_ENTRY_T prQueueEntry = NULL; P_QUE_T prTxQueue = NULL; UINT_16 u2QueueIdx = 0; #if (CFG_SUPPORT_TDLS_DBG == 1) UINT16 u2Identifier = 0; #endif #if CFG_BOW_TEST UINT_32 i; #endif GLUE_SPIN_LOCK_DECLARATION(); ASSERT(prSkb); ASSERT(prDev); ASSERT(prGlueInfo); #if (CFG_SUPPORT_TDLS_DBG == 1) { UINT8 *pkt = prSkb->data; if ((*(pkt + 12) == 0x08) && (*(pkt + 13) == 0x00)) { /* ip */ u2Identifier = ((*(pkt + 18)) << 8) | (*(pkt + 19)); /* u2TdlsTxSeq[u4TdlsTxSeqId ++] = u2Identifier; */ DBGLOG(INIT, INFO, " %d\n", u2Identifier); } } #endif /* check if WiFi is halt */ if (prGlueInfo->ulFlag & GLUE_FLAG_HALT) { DBGLOG(INIT, INFO, "GLUE_FLAG_HALT skip tx\n"); dev_kfree_skb(prSkb); return NETDEV_TX_OK; } #if CFG_SUPPORT_HOTSPOT_2_0 if (prGlueInfo->fgIsDad) { /* kalPrint("[Passpoint R2] Due to ipv4_dad...TX is forbidden\n"); */ dev_kfree_skb(prSkb); return NETDEV_TX_OK; } if (prGlueInfo->fgIs6Dad) { /* kalPrint("[Passpoint R2] Due to ipv6_dad...TX is forbidden\n"); */ dev_kfree_skb(prSkb); return NETDEV_TX_OK; } #endif STATS_TX_TIME_ARRIVE(prSkb); prQueueEntry = (P_QUE_ENTRY_T) GLUE_GET_PKT_QUEUE_ENTRY(prSkb); prTxQueue = &prGlueInfo->rTxQueue; #if CFG_BOW_TEST DBGLOG(BOW, TRACE, "sk_buff->len: %d\n", prSkb->len); DBGLOG(BOW, TRACE, "sk_buff->data_len: %d\n", prSkb->data_len); DBGLOG(BOW, TRACE, "sk_buff->data:\n"); for (i = 0; i < prSkb->len; i++) { DBGLOG(BOW, TRACE, "%4x", prSkb->data[i]); if ((i + 1) % 16 == 0) DBGLOG(BOW, TRACE, "\n"); } DBGLOG(BOW, TRACE, "\n"); #endif if (wlanProcessSecurityFrame(prGlueInfo->prAdapter, (P_NATIVE_PACKET) prSkb) == FALSE) { /* non-1x packets */ #if CFG_DBG_GPIO_PINS { /* TX request from OS */ mtk_wcn_stp_debug_gpio_assert(IDX_TX_REQ, DBG_TIE_LOW); kalUdelay(1); mtk_wcn_stp_debug_gpio_assert(IDX_TX_REQ, DBG_TIE_HIGH); } #endif u2QueueIdx = skb_get_queue_mapping(prSkb); ASSERT(u2QueueIdx < CFG_MAX_TXQ_NUM); #if CFG_ENABLE_PKT_LIFETIME_PROFILE GLUE_SET_PKT_ARRIVAL_TIME(prSkb, kalGetTimeTick()); #endif GLUE_INC_REF_CNT(prGlueInfo->i4TxPendingFrameNum); if (u2QueueIdx < CFG_MAX_TXQ_NUM) GLUE_INC_REF_CNT(prGlueInfo->ai4TxPendingFrameNumPerQueue[NETWORK_TYPE_AIS_INDEX][u2QueueIdx]); GLUE_ACQUIRE_SPIN_LOCK(prGlueInfo, SPIN_LOCK_TX_QUE); QUEUE_INSERT_TAIL(prTxQueue, prQueueEntry); GLUE_RELEASE_SPIN_LOCK(prGlueInfo, SPIN_LOCK_TX_QUE); /* GLUE_INC_REF_CNT(prGlueInfo->i4TxPendingFrameNum); */ /* GLUE_INC_REF_CNT(prGlueInfo->ai4TxPendingFrameNumPerQueue[NETWORK_TYPE_AIS_INDEX][u2QueueIdx]); */ if (u2QueueIdx < CFG_MAX_TXQ_NUM) { if (prGlueInfo->ai4TxPendingFrameNumPerQueue[NETWORK_TYPE_AIS_INDEX][u2QueueIdx] >= CFG_TX_STOP_NETIF_PER_QUEUE_THRESHOLD) { netif_stop_subqueue(prDev, u2QueueIdx); #if (CONF_HIF_LOOPBACK_AUTO == 1) prGlueInfo->rHifInfo.HifLoopbkFlg |= 0x01; #endif /* CONF_HIF_LOOPBACK_AUTO */ } } } else { /* printk("is security frame\n"); */ GLUE_INC_REF_CNT(prGlueInfo->i4TxPendingSecurityFrameNum); } DBGLOG(TX, EVENT, "\n+++++ pending frame %d len = %d +++++\n", prGlueInfo->i4TxPendingFrameNum, prSkb->len); prGlueInfo->rNetDevStats.tx_bytes += prSkb->len; prGlueInfo->rNetDevStats.tx_packets++; if (netif_carrier_ok(prDev)) kalPerMonStart(prGlueInfo); /* set GLUE_FLAG_TXREQ_BIT */ /* pr->u4Flag |= GLUE_FLAG_TXREQ; */ /* wake_up_interruptible(&prGlueInfo->waitq); */ kalSetEvent(prGlueInfo); /* For Linux, we'll always return OK FLAG, because we'll free this skb by ourself */ return NETDEV_TX_OK; } /* end of wlanHardStartXmit() */ /*----------------------------------------------------------------------------*/ /*! * \brief A method of struct net_device, to get the network interface statistical * information. * * Whenever an application needs to get statistics for the interface, this method * is called. This happens, for example, when ifconfig or netstat -i is run. * * \param[in] prDev Pointer to struct net_device. * * \return net_device_stats buffer pointer. */ /*----------------------------------------------------------------------------*/ struct net_device_stats *wlanGetStats(IN struct net_device *prDev) { P_GLUE_INFO_T prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prDev)); #if 0 WLAN_STATUS rStatus; UINT_32 u4XmitError = 0; UINT_32 u4XmitOk = 0; UINT_32 u4RecvError = 0; UINT_32 u4RecvOk = 0; UINT_32 u4BufLen; ASSERT(prDev); /* @FIX ME: need a more clear way to do this */ rStatus = kalIoctl(prGlueInfo, wlanoidQueryXmitError, &u4XmitError, sizeof(UINT_32), TRUE, TRUE, TRUE, &u4BufLen); rStatus = kalIoctl(prGlueInfo, wlanoidQueryXmitOk, &u4XmitOk, sizeof(UINT_32), TRUE, TRUE, TRUE, &u4BufLen); rStatus = kalIoctl(prGlueInfo, wlanoidQueryRcvOk, &u4RecvOk, sizeof(UINT_32), TRUE, TRUE, TRUE, &u4BufLen); rStatus = kalIoctl(prGlueInfo, wlanoidQueryRcvError, &u4RecvError, sizeof(UINT_32), TRUE, TRUE, TRUE, &u4BufLen); prGlueInfo->rNetDevStats.rx_packets = u4RecvOk; prGlueInfo->rNetDevStats.tx_packets = u4XmitOk; prGlueInfo->rNetDevStats.tx_errors = u4XmitError; prGlueInfo->rNetDevStats.rx_errors = u4RecvError; /* prGlueInfo->rNetDevStats.rx_bytes = rCustomNetDevStats.u4RxBytes; */ /* prGlueInfo->rNetDevStats.tx_bytes = rCustomNetDevStats.u4TxBytes; */ /* prGlueInfo->rNetDevStats.rx_errors = rCustomNetDevStats.u4RxErrors; */ /* prGlueInfo->rNetDevStats.multicast = rCustomNetDevStats.u4Multicast; */ #endif /* prGlueInfo->rNetDevStats.rx_packets = 0; */ /* prGlueInfo->rNetDevStats.tx_packets = 0; */ prGlueInfo->rNetDevStats.tx_errors = 0; prGlueInfo->rNetDevStats.rx_errors = 0; /* prGlueInfo->rNetDevStats.rx_bytes = 0; */ /* prGlueInfo->rNetDevStats.tx_bytes = 0; */ prGlueInfo->rNetDevStats.rx_errors = 0; prGlueInfo->rNetDevStats.multicast = 0; return &prGlueInfo->rNetDevStats; } /* end of wlanGetStats() */ /*----------------------------------------------------------------------------*/ /*! * \brief A function for prDev->init * * \param[in] prDev Pointer to struct net_device. * * \retval 0 The execution of wlanInit succeeds. * \retval -ENXIO No such device. */ /*----------------------------------------------------------------------------*/ static int wlanInit(struct net_device *prDev) { P_GLUE_INFO_T prGlueInfo = NULL; if (fgIsWorkMcEverInit == FALSE) { if (!prDev) return -ENXIO; prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prDev)); INIT_DELAYED_WORK(&workq, wlanSetMulticastListWorkQueue); /* 20150205 work queue for sched_scan */ INIT_DELAYED_WORK(&sched_workq, wlanSchedScanStoppedWorkQueue); fgIsWorkMcEverInit = TRUE; } return 0; /* success */ } /* end of wlanInit() */ /*----------------------------------------------------------------------------*/ /*! * \brief A function for prDev->uninit * * \param[in] prDev Pointer to struct net_device. * * \return (none) */ /*----------------------------------------------------------------------------*/ static void wlanUninit(struct net_device *prDev) { } /* end of wlanUninit() */ /*----------------------------------------------------------------------------*/ /*! * \brief A function for prDev->open * * \param[in] prDev Pointer to struct net_device. * * \retval 0 The execution of wlanOpen succeeds. * \retval < 0 The execution of wlanOpen failed. */ /*----------------------------------------------------------------------------*/ static int wlanOpen(struct net_device *prDev) { ASSERT(prDev); netif_tx_start_all_queues(prDev); return 0; /* success */ } /* end of wlanOpen() */ /*----------------------------------------------------------------------------*/ /*! * \brief A function for prDev->stop * * \param[in] prDev Pointer to struct net_device. * * \retval 0 The execution of wlanStop succeeds. * \retval < 0 The execution of wlanStop failed. */ /*----------------------------------------------------------------------------*/ static int wlanStop(struct net_device *prDev) { P_GLUE_INFO_T prGlueInfo = NULL; struct cfg80211_scan_request *prScanRequest = NULL; GLUE_SPIN_LOCK_DECLARATION(); ASSERT(prDev); prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prDev)); /* CFG80211 down */ GLUE_ACQUIRE_SPIN_LOCK(prGlueInfo, SPIN_LOCK_NET_DEV); if (prGlueInfo->prScanRequest != NULL) { prScanRequest = prGlueInfo->prScanRequest; prGlueInfo->prScanRequest = NULL; } GLUE_RELEASE_SPIN_LOCK(prGlueInfo, SPIN_LOCK_NET_DEV); if (prScanRequest) cfg80211_scan_done(prScanRequest, TRUE); netif_tx_stop_all_queues(prDev); return 0; /* success */ } /* end of wlanStop() */ /*----------------------------------------------------------------------------*/ /*! * \brief Update Channel table for cfg80211 for Wi-Fi Direct based on current country code * * \param[in] prGlueInfo Pointer to glue info * * \return none */ /*----------------------------------------------------------------------------*/ VOID wlanUpdateChannelTable(P_GLUE_INFO_T prGlueInfo) { UINT_8 i, j; UINT_8 ucNumOfChannel; RF_CHANNEL_INFO_T aucChannelList[ARRAY_SIZE(mtk_2ghz_channels) + ARRAY_SIZE(mtk_5ghz_channels)]; /* 1. Disable all channel */ for (i = 0; i < ARRAY_SIZE(mtk_2ghz_channels); i++) { mtk_2ghz_channels[i].flags |= IEEE80211_CHAN_DISABLED; mtk_2ghz_channels[i].orig_flags |= IEEE80211_CHAN_DISABLED; } for (i = 0; i < ARRAY_SIZE(mtk_5ghz_channels); i++) { mtk_5ghz_channels[i].flags |= IEEE80211_CHAN_DISABLED; mtk_5ghz_channels[i].orig_flags |= IEEE80211_CHAN_DISABLED; } /* 2. Get current domain channel list */ rlmDomainGetChnlList(prGlueInfo->prAdapter, BAND_NULL, ARRAY_SIZE(mtk_2ghz_channels) + ARRAY_SIZE(mtk_5ghz_channels), &ucNumOfChannel, aucChannelList); /* 3. Enable specific channel based on domain channel list */ for (i = 0; i < ucNumOfChannel; i++) { switch (aucChannelList[i].eBand) { case BAND_2G4: for (j = 0; j < ARRAY_SIZE(mtk_2ghz_channels); j++) { if (mtk_2ghz_channels[j].hw_value == aucChannelList[i].ucChannelNum) { mtk_2ghz_channels[j].flags &= ~IEEE80211_CHAN_DISABLED; mtk_2ghz_channels[j].orig_flags &= ~IEEE80211_CHAN_DISABLED; break; } } break; case BAND_5G: for (j = 0; j < ARRAY_SIZE(mtk_5ghz_channels); j++) { if (mtk_5ghz_channels[j].hw_value == aucChannelList[i].ucChannelNum) { mtk_5ghz_channels[j].flags &= ~IEEE80211_CHAN_DISABLED; mtk_5ghz_channels[j].orig_flags &= ~IEEE80211_CHAN_DISABLED; break; } } break; default: break; } } } /*----------------------------------------------------------------------------*/ /*! * \brief Register the device to the kernel and return the index. * * \param[in] prDev Pointer to struct net_device. * * \retval 0 The execution of wlanNetRegister succeeds. * \retval < 0 The execution of wlanNetRegister failed. */ /*----------------------------------------------------------------------------*/ static INT_32 wlanNetRegister(struct wireless_dev *prWdev) { P_GLUE_INFO_T prGlueInfo; INT_32 i4DevIdx = -1; ASSERT(prWdev); do { if (!prWdev) break; prGlueInfo = (P_GLUE_INFO_T) wiphy_priv(prWdev->wiphy); i4DevIdx = wlanGetDevIdx(prWdev->netdev); if (i4DevIdx < 0) { DBGLOG(INIT, ERROR, "wlanNetRegister: net_device number exceeds.\n"); break; } /* adjust channel support status */ wlanUpdateChannelTable(prGlueInfo); #if !CFG_SUPPORT_PERSIST_NETDEV if (register_netdev(prWdev->netdev) < 0) { DBGLOG(INIT, ERROR, "wlanNetRegister: net_device context is not registered.\n"); wiphy_unregister(prWdev->wiphy); wlanClearDevIdx(prWdev->netdev); i4DevIdx = -1; } #endif if (i4DevIdx != -1) prGlueInfo->fgIsRegistered = TRUE; } while (FALSE); return i4DevIdx; /* success */ } /* end of wlanNetRegister() */ /*----------------------------------------------------------------------------*/ /*! * \brief Unregister the device from the kernel * * \param[in] prWdev Pointer to struct net_device. * * \return (none) */ /*----------------------------------------------------------------------------*/ static VOID wlanNetUnregister(struct wireless_dev *prWdev) { P_GLUE_INFO_T prGlueInfo; if (!prWdev) { DBGLOG(INIT, ERROR, "wlanNetUnregister: The device context is NULL\n"); return; } DBGLOG(INIT, TRACE, "unregister net_dev(0x%p)\n", prWdev->netdev); prGlueInfo = (P_GLUE_INFO_T) wiphy_priv(prWdev->wiphy); wlanClearDevIdx(prWdev->netdev); #if !CFG_SUPPORT_PERSIST_NETDEV unregister_netdev(prWdev->netdev); #endif prGlueInfo->fgIsRegistered = FALSE; DBGLOG(INIT, INFO, "unregister wireless_dev(0x%p), ifindex=%d\n", prWdev, prWdev->netdev->ifindex); } /* end of wlanNetUnregister() */ static const struct net_device_ops wlan_netdev_ops = { .ndo_open = wlanOpen, .ndo_stop = wlanStop, .ndo_set_rx_mode = wlanSetMulticastList, .ndo_get_stats = wlanGetStats, .ndo_do_ioctl = wlanDoIOCTL, .ndo_start_xmit = wlanHardStartXmit, .ndo_init = wlanInit, .ndo_uninit = wlanUninit, .ndo_select_queue = wlanSelectQueue, }; /*----------------------------------------------------------------------------*/ /*! * \brief A method for creating Linux NET4 struct net_device object and the * private data(prGlueInfo and prAdapter). Setup the IO address to the HIF. * Assign the function pointer to the net_device object * * \param[in] pvData Memory address for the device * * \retval Not null The wireless_dev object. * \retval NULL Fail to create wireless_dev object */ /*----------------------------------------------------------------------------*/ static struct lock_class_key rSpinKey[SPIN_LOCK_NUM]; static struct wireless_dev *wlanNetCreate(PVOID pvData) { P_GLUE_INFO_T prGlueInfo = NULL; struct wireless_dev *prWdev = gprWdev; UINT_32 i; struct device *prDev; if (!prWdev) { DBGLOG(INIT, ERROR, "Allocating memory to wireless_dev context failed\n"); return NULL; } /* 4 <1> co-relate wiphy & prDev */ #if MTK_WCN_HIF_SDIO mtk_wcn_hif_sdio_get_dev(*((MTK_WCN_HIF_SDIO_CLTCTX *) pvData), &prDev); #else /* prDev = &((struct sdio_func *) pvData)->dev; //samp */ prDev = pvData; /* samp */ #endif if (!prDev) DBGLOG(INIT, WARN, "unable to get struct dev for wlan\n"); /* don't set prDev as parent of wiphy->dev, because we have done device_add in driver init. if we set parent here, parent will be not able to know this child, and may occurs a KE in device_shutdown, to free wiphy->dev, because his parent has been freed. */ /*set_wiphy_dev(prWdev->wiphy, prDev);*/ #if !CFG_SUPPORT_PERSIST_NETDEV /* 4 <3> Initial Glue structure */ prGlueInfo = (P_GLUE_INFO_T) wiphy_priv(prWdev->wiphy); kalMemZero(prGlueInfo, sizeof(GLUE_INFO_T)); /* 4 <3.1> Create net device */ #if CFG_TC1_FEATURE if (wlan_if_changed) { prGlueInfo->prDevHandler = alloc_netdev_mq(sizeof(P_GLUE_INFO_T), NIC_INF_NAME_IN_AP_MODE, NET_NAME_PREDICTABLE, ether_setup, CFG_MAX_TXQ_NUM); } else { prGlueInfo->prDevHandler = alloc_netdev_mq(sizeof(P_GLUE_INFO_T), NIC_INF_NAME, NET_NAME_PREDICTABLE, ether_setup, CFG_MAX_TXQ_NUM); } #else prGlueInfo->prDevHandler = alloc_netdev_mq(sizeof(P_GLUE_INFO_T), NIC_INF_NAME, NET_NAME_PREDICTABLE, ether_setup, CFG_MAX_TXQ_NUM); #endif if (!prGlueInfo->prDevHandler) { DBGLOG(INIT, ERROR, "Allocating memory to net_device context failed\n"); return NULL; } DBGLOG(INIT, INFO, "net_device prDev(0x%p) allocated ifindex=%d\n", prGlueInfo->prDevHandler, prGlueInfo->prDevHandler->ifindex); /* 4 <3.1.1> initialize net device varaiables */ *((P_GLUE_INFO_T *) netdev_priv(prGlueInfo->prDevHandler)) = prGlueInfo; prGlueInfo->prDevHandler->netdev_ops = &wlan_netdev_ops; #ifdef CONFIG_WIRELESS_EXT prGlueInfo->prDevHandler->wireless_handlers = &wext_handler_def; #endif netif_carrier_off(prGlueInfo->prDevHandler); netif_tx_stop_all_queues(prGlueInfo->prDevHandler); /* 4 <3.1.2> co-relate with wiphy bi-directionally */ prGlueInfo->prDevHandler->ieee80211_ptr = prWdev; #if CFG_TCP_IP_CHKSUM_OFFLOAD prGlueInfo->prDevHandler->features = NETIF_F_HW_CSUM; #endif prWdev->netdev = prGlueInfo->prDevHandler; /* 4 <3.1.3> co-relate net device & prDev */ /*SET_NETDEV_DEV(prGlueInfo->prDevHandler, wiphy_dev(prWdev->wiphy));*/ SET_NETDEV_DEV(prGlueInfo->prDevHandler, prDev); #else /* CFG_SUPPORT_PERSIST_NETDEV */ prGlueInfo->prDevHandler = gprWdev->netdev; #endif /* CFG_SUPPORT_PERSIST_NETDEV */ /* 4 <3.2> initiali glue variables */ prGlueInfo->eParamMediaStateIndicated = PARAM_MEDIA_STATE_DISCONNECTED; prGlueInfo->ePowerState = ParamDeviceStateD0; prGlueInfo->fgIsMacAddrOverride = FALSE; prGlueInfo->fgIsRegistered = FALSE; prGlueInfo->prScanRequest = NULL; #if CFG_SUPPORT_HOTSPOT_2_0 /* Init DAD */ prGlueInfo->fgIsDad = FALSE; prGlueInfo->fgIs6Dad = FALSE; kalMemZero(prGlueInfo->aucDADipv4, 4); kalMemZero(prGlueInfo->aucDADipv6, 16); #endif init_completion(&prGlueInfo->rScanComp); init_completion(&prGlueInfo->rHaltComp); init_completion(&prGlueInfo->rPendComp); #if CFG_ENABLE_WIFI_DIRECT init_completion(&prGlueInfo->rSubModComp); #endif /* initialize timer for OID timeout checker */ kalOsTimerInitialize(prGlueInfo, kalTimeoutHandler); for (i = 0; i < SPIN_LOCK_NUM; i++) { spin_lock_init(&prGlueInfo->rSpinLock[i]); lockdep_set_class(&prGlueInfo->rSpinLock[i], &rSpinKey[i]); } /* initialize semaphore for ioctl */ sema_init(&prGlueInfo->ioctl_sem, 1); glSetHifInfo(prGlueInfo, (ULONG) pvData); /* 4 <8> Init Queues */ init_waitqueue_head(&prGlueInfo->waitq); QUEUE_INITIALIZE(&prGlueInfo->rCmdQueue); QUEUE_INITIALIZE(&prGlueInfo->rTxQueue); /* 4 <4> Create Adapter structure */ prGlueInfo->prAdapter = (P_ADAPTER_T) wlanAdapterCreate(prGlueInfo); if (!prGlueInfo->prAdapter) { DBGLOG(INIT, ERROR, "Allocating memory to adapter failed\n"); return NULL; } KAL_WAKE_LOCK_INIT(prAdapter, &prGlueInfo->rAhbIsrWakeLock, "WLAN AHB ISR"); #if CFG_SUPPORT_PERSIST_NETDEV dev_open(prGlueInfo->prDevHandler); netif_carrier_off(prGlueInfo->prDevHandler); netif_tx_stop_all_queues(prGlueInfo->prDevHandler); #endif return prWdev; } /* end of wlanNetCreate() */ /*----------------------------------------------------------------------------*/ /*! * \brief Destroying the struct net_device object and the private data. * * \param[in] prWdev Pointer to struct wireless_dev. * * \return (none) */ /*----------------------------------------------------------------------------*/ static VOID wlanNetDestroy(struct wireless_dev *prWdev) { P_GLUE_INFO_T prGlueInfo = NULL; ASSERT(prWdev); if (!prWdev) { DBGLOG(INIT, ERROR, "wlanNetDestroy: The device context is NULL\n"); return; } /* prGlueInfo is allocated with net_device */ prGlueInfo = (P_GLUE_INFO_T) wiphy_priv(prWdev->wiphy); ASSERT(prGlueInfo); /* destroy kal OS timer */ kalCancelTimer(prGlueInfo); glClearHifInfo(prGlueInfo); wlanAdapterDestroy(prGlueInfo->prAdapter); prGlueInfo->prAdapter = NULL; #if CFG_SUPPORT_PERSIST_NETDEV /* take the net_device to down state */ dev_close(prGlueInfo->prDevHandler); #else /* Free net_device and private data prGlueInfo, which are allocated by alloc_netdev(). */ free_netdev(prWdev->netdev); #endif } /* end of wlanNetDestroy() */ #ifndef CONFIG_X86 UINT_8 g_aucBufIpAddr[32] = { 0 }; static void wlanNotifyFwSuspend(P_GLUE_INFO_T prGlueInfo, BOOLEAN fgSuspend) { WLAN_STATUS rStatus = WLAN_STATUS_FAILURE; UINT_32 u4SetInfoLen; rStatus = kalIoctl(prGlueInfo, wlanoidNotifyFwSuspend, (PVOID)&fgSuspend, sizeof(fgSuspend), FALSE, FALSE, TRUE, FALSE, &u4SetInfoLen); if (rStatus != WLAN_STATUS_SUCCESS) DBGLOG(INIT, INFO, "wlanNotifyFwSuspend fail\n"); } void wlanHandleSystemSuspend(void) { WLAN_STATUS rStatus = WLAN_STATUS_FAILURE; struct net_device *prDev = NULL; P_GLUE_INFO_T prGlueInfo = NULL; UINT_8 ip[4] = { 0 }; UINT_32 u4NumIPv4 = 0; #ifdef CONFIG_IPV6 UINT_8 ip6[16] = { 0 }; /* FIX ME: avoid to allocate large memory in stack */ UINT_32 u4NumIPv6 = 0; #endif UINT_32 i; P_PARAM_NETWORK_ADDRESS_IP prParamIpAddr; #if CFG_SUPPORT_DROP_MC_PACKET UINT_32 u4PacketFilter = 0; UINT_32 u4SetInfoLen = 0; #endif /* <1> Sanity check and acquire the net_device */ ASSERT(u4WlanDevNum <= CFG_MAX_WLAN_DEVICES); if (u4WlanDevNum == 0) { DBGLOG(INIT, ERROR, "wlanEarlySuspend u4WlanDevNum==0 invalid!!\n"); return; } prDev = arWlanDevInfo[u4WlanDevNum - 1].prDev; fgIsUnderSuspend = true; prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prDev)); ASSERT(prGlueInfo); #if CFG_SUPPORT_DROP_MC_PACKET /* new filter should not include p2p mask */ #if CFG_ENABLE_WIFI_DIRECT_CFG_80211 u4PacketFilter = prGlueInfo->prAdapter->u4OsPacketFilter & (~PARAM_PACKET_FILTER_P2P_MASK); #endif if (kalIoctl(prGlueInfo, wlanoidSetCurrentPacketFilter, &u4PacketFilter, sizeof(u4PacketFilter), FALSE, FALSE, TRUE, FALSE, &u4SetInfoLen) != WLAN_STATUS_SUCCESS) { DBGLOG(INIT, ERROR, "set packet filter failed.\n"); } #endif if (!prDev || !(prDev->ip_ptr) || !((struct in_device *)(prDev->ip_ptr))->ifa_list || !(&(((struct in_device *)(prDev->ip_ptr))->ifa_list->ifa_local))) { goto notify_suspend; } kalMemCopy(ip, &(((struct in_device *)(prDev->ip_ptr))->ifa_list->ifa_local), sizeof(ip)); /* todo: traverse between list to find whole sets of IPv4 addresses */ if (!((ip[0] == 0) && (ip[1] == 0) && (ip[2] == 0) && (ip[3] == 0))) u4NumIPv4++; #ifdef CONFIG_IPV6 if (!prDev || !(prDev->ip6_ptr) || !((struct in_device *)(prDev->ip6_ptr))->ifa_list || !(&(((struct in_device *)(prDev->ip6_ptr))->ifa_list->ifa_local))) { goto notify_suspend; } kalMemCopy(ip6, &(((struct in_device *)(prDev->ip6_ptr))->ifa_list->ifa_local), sizeof(ip6)); DBGLOG(INIT, INFO, "ipv6 is %d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d\n", ip6[0], ip6[1], ip6[2], ip6[3], ip6[4], ip6[5], ip6[6], ip6[7], ip6[8], ip6[9], ip6[10], ip6[11], ip6[12], ip6[13], ip6[14], ip6[15] ); /* todo: traverse between list to find whole sets of IPv6 addresses */ if (!((ip6[0] == 0) && (ip6[1] == 0) && (ip6[2] == 0) && (ip6[3] == 0) && (ip6[4] == 0) && (ip6[5] == 0))) { /* Do nothing */ /* u4NumIPv6++; */ } #endif /* <7> set up the ARP filter */ { UINT_32 u4SetInfoLen = 0; UINT_32 u4Len = OFFSET_OF(PARAM_NETWORK_ADDRESS_LIST, arAddress); P_PARAM_NETWORK_ADDRESS_LIST prParamNetAddrList = (P_PARAM_NETWORK_ADDRESS_LIST) g_aucBufIpAddr; P_PARAM_NETWORK_ADDRESS prParamNetAddr = prParamNetAddrList->arAddress; kalMemZero(g_aucBufIpAddr, sizeof(g_aucBufIpAddr)); prParamNetAddrList->u4AddressCount = u4NumIPv4 + u4NumIPv6; prParamNetAddrList->u2AddressType = PARAM_PROTOCOL_ID_TCP_IP; for (i = 0; i < u4NumIPv4; i++) { prParamNetAddr->u2AddressLength = sizeof(PARAM_NETWORK_ADDRESS_IP); /* 4;; */ prParamNetAddr->u2AddressType = PARAM_PROTOCOL_ID_TCP_IP; prParamIpAddr = (P_PARAM_NETWORK_ADDRESS_IP) prParamNetAddr->aucAddress; kalMemCopy(&prParamIpAddr->in_addr, ip, sizeof(ip)); prParamNetAddr = (P_PARAM_NETWORK_ADDRESS) ((ULONG) prParamNetAddr + sizeof(PARAM_NETWORK_ADDRESS)); u4Len += OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress) + sizeof(PARAM_NETWORK_ADDRESS); } #ifdef CONFIG_IPV6 for (i = 0; i < u4NumIPv6; i++) { prParamNetAddr->u2AddressLength = 6; prParamNetAddr->u2AddressType = PARAM_PROTOCOL_ID_TCP_IP; kalMemCopy(prParamNetAddr->aucAddress, ip6, sizeof(ip6)); prParamNetAddr = (P_PARAM_NETWORK_ADDRESS) ((ULONG) prParamNetAddr + sizeof(ip6)); u4Len += OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress) + sizeof(ip6); } #endif ASSERT(u4Len <= sizeof(g_aucBufIpAddr)); rStatus = kalIoctl(prGlueInfo, wlanoidSetNetworkAddress, (PVOID) prParamNetAddrList, u4Len, FALSE, FALSE, TRUE, FALSE, &u4SetInfoLen); } notify_suspend: DBGLOG(INIT, INFO, "IP: %d.%d.%d.%d, rStatus: %u\n", ip[0], ip[1], ip[2], ip[3], rStatus); /* if (rStatus != WLAN_STATUS_SUCCESS) */ wlanNotifyFwSuspend(prGlueInfo, TRUE); } void wlanHandleSystemResume(void) { struct net_device *prDev = NULL; P_GLUE_INFO_T prGlueInfo = NULL; WLAN_STATUS rStatus = WLAN_STATUS_FAILURE; UINT_8 ip[4] = { 0 }; #ifdef CONFIG_IPV6 UINT_8 ip6[16] = { 0 }; /* FIX ME: avoid to allocate large memory in stack */ #endif EVENT_AIS_BSS_INFO_T rParam; UINT_32 u4BufLen = 0; #if CFG_SUPPORT_DROP_MC_PACKET UINT_32 u4PacketFilter = 0; UINT_32 u4SetInfoLen = 0; #endif /* <1> Sanity check and acquire the net_device */ ASSERT(u4WlanDevNum <= CFG_MAX_WLAN_DEVICES); if (u4WlanDevNum == 0) { DBGLOG(INIT, ERROR, "wlanLateResume u4WlanDevNum==0 invalid!!\n"); return; } prDev = arWlanDevInfo[u4WlanDevNum - 1].prDev; /* ASSERT(prDev); */ fgIsUnderSuspend = false; if (!prDev) { DBGLOG(INIT, INFO, "prDev == NULL!!!\n"); return; } /* <3> acquire the prGlueInfo */ prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prDev)); ASSERT(prGlueInfo); #if CFG_SUPPORT_DROP_MC_PACKET /* new filter should not include p2p mask */ #if CFG_ENABLE_WIFI_DIRECT_CFG_80211 u4PacketFilter = prGlueInfo->prAdapter->u4OsPacketFilter & (~PARAM_PACKET_FILTER_P2P_MASK); #endif if (kalIoctl(prGlueInfo, wlanoidSetCurrentPacketFilter, &u4PacketFilter, sizeof(u4PacketFilter), FALSE, FALSE, TRUE, FALSE, &u4SetInfoLen) != WLAN_STATUS_SUCCESS) { DBGLOG(INIT, ERROR, "set packet filter failed.\n"); } #endif /* We will receive the event in rx, we will check if the status is the same in driver and FW, if not the same, trigger disconnetion procedure. */ kalMemZero(&rParam, sizeof(EVENT_AIS_BSS_INFO_T)); rStatus = kalIoctl(prGlueInfo, wlanoidQueryBSSInfo, &rParam, sizeof(EVENT_AIS_BSS_INFO_T), TRUE, TRUE, TRUE, FALSE, &u4BufLen); if (rStatus != WLAN_STATUS_SUCCESS) { DBGLOG(INIT, ERROR, "Query BSSinfo fail 0x%x!!\n", rStatus); } /* <2> get the IPv4 address */ if (!(prDev->ip_ptr) || !((struct in_device *)(prDev->ip_ptr))->ifa_list || !(&(((struct in_device *)(prDev->ip_ptr))->ifa_list->ifa_local))) { goto notify_resume; } /* <4> copy the IPv4 address */ kalMemCopy(ip, &(((struct in_device *)(prDev->ip_ptr))->ifa_list->ifa_local), sizeof(ip)); #ifdef CONFIG_IPV6 /* <5> get the IPv6 address */ if (!prDev || !(prDev->ip6_ptr) || !((struct in_device *)(prDev->ip6_ptr))->ifa_list || !(&(((struct in_device *)(prDev->ip6_ptr))->ifa_list->ifa_local))) { goto notify_resume; } /* <6> copy the IPv6 address */ kalMemCopy(ip6, &(((struct in_device *)(prDev->ip6_ptr))->ifa_list->ifa_local), sizeof(ip6)); DBGLOG(INIT, INFO, "ipv6 is %d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d\n", ip6[0], ip6[1], ip6[2], ip6[3], ip6[4], ip6[5], ip6[6], ip6[7], ip6[8], ip6[9], ip6[10], ip6[11], ip6[12], ip6[13], ip6[14], ip6[15] ); #endif /* <7> clear the ARP filter */ { UINT_32 u4SetInfoLen = 0; /* UINT_8 aucBuf[32] = {0}; */ UINT_32 u4Len = sizeof(PARAM_NETWORK_ADDRESS_LIST); P_PARAM_NETWORK_ADDRESS_LIST prParamNetAddrList = (P_PARAM_NETWORK_ADDRESS_LIST) g_aucBufIpAddr; /* aucBuf; */ kalMemZero(g_aucBufIpAddr, sizeof(g_aucBufIpAddr)); prParamNetAddrList->u4AddressCount = 0; prParamNetAddrList->u2AddressType = PARAM_PROTOCOL_ID_TCP_IP; ASSERT(u4Len <= sizeof(g_aucBufIpAddr /*aucBuf */)); rStatus = kalIoctl(prGlueInfo, wlanoidSetNetworkAddress, (PVOID) prParamNetAddrList, u4Len, FALSE, FALSE, TRUE, FALSE, &u4SetInfoLen); } notify_resume: DBGLOG(INIT, INFO, "Query BSS result: %d %d %d, IP: %d.%d.%d.%d, rStatus: %u\n", rParam.eConnectionState, rParam.eCurrentOPMode, rParam.fgIsNetActive, ip[0], ip[1], ip[2], ip[3], rStatus); /* if (rStatus != WLAN_STATUS_SUCCESS) */ wlanNotifyFwSuspend(prGlueInfo, FALSE); } #endif /* ! CONFIG_X86 */ int set_p2p_mode_handler(struct net_device *netdev, PARAM_CUSTOM_P2P_SET_STRUCT_T p2pmode) { #if 0 P_GLUE_INFO_T prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(netdev)); PARAM_CUSTOM_P2P_SET_STRUCT_T rSetP2P; WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS; UINT_32 u4BufLen = 0; rSetP2P.u4Enable = p2pmode.u4Enable; rSetP2P.u4Mode = p2pmode.u4Mode; if (!rSetP2P.u4Enable) p2pNetUnregister(prGlueInfo, TRUE); rWlanStatus = kalIoctl(prGlueInfo, wlanoidSetP2pMode, (PVOID) &rSetP2P, sizeof(PARAM_CUSTOM_P2P_SET_STRUCT_T), FALSE, FALSE, TRUE, FALSE, &u4BufLen); DBGLOG(INIT, INFO, "ret = %d\n", rWlanStatus); if (rSetP2P.u4Enable) p2pNetRegister(prGlueInfo, TRUE); return 0; #else P_GLUE_INFO_T prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(netdev)); PARAM_CUSTOM_P2P_SET_STRUCT_T rSetP2P; WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS; BOOLEAN fgIsP2PEnding; UINT_32 u4BufLen = 0; GLUE_SPIN_LOCK_DECLARATION(); DBGLOG(INIT, INFO, "%u %u\n", (UINT_32) p2pmode.u4Enable, (UINT_32) p2pmode.u4Mode); /* avoid remove & p2p off command simultaneously */ GLUE_ACQUIRE_THE_SPIN_LOCK(&g_p2p_lock); fgIsP2PEnding = g_u4P2PEnding; g_u4P2POnOffing = 1; GLUE_RELEASE_THE_SPIN_LOCK(&g_p2p_lock); if (fgIsP2PEnding == 1) { /* skip the command if we are removing */ GLUE_ACQUIRE_THE_SPIN_LOCK(&g_p2p_lock); g_u4P2POnOffing = 0; GLUE_RELEASE_THE_SPIN_LOCK(&g_p2p_lock); return 0; } rSetP2P.u4Enable = p2pmode.u4Enable; rSetP2P.u4Mode = p2pmode.u4Mode; #if !CFG_SUPPORT_PERSIST_NETDEV if ((!rSetP2P.u4Enable) && (fgIsResetting == FALSE)) p2pNetUnregister(prGlueInfo, TRUE); #endif /* move out to caller to avoid kalIoctrl & suspend/resume deadlock problem ALPS00844864 */ /* Scenario: 1. System enters suspend/resume but not yet enter wlanearlysuspend() or wlanlateresume(); 2. System switches to do PRIV_CMD_P2P_MODE and execute kalIoctl() and get g_halt_sem then do glRegisterEarlySuspend() or glUnregisterEarlySuspend(); But system suspend/resume procedure is not yet finished so we suspend; 3. System switches back to do suspend/resume procedure and execute kalIoctl(). But driver does not yet release g_halt_sem so system suspend in wlanearlysuspend() or wlanlateresume(); ==> deadlock occurs. */ rWlanStatus = kalIoctl(prGlueInfo, wlanoidSetP2pMode, (PVOID) &rSetP2P,/* pu4IntBuf[0]is used as input SubCmd */ sizeof(PARAM_CUSTOM_P2P_SET_STRUCT_T), FALSE, FALSE, TRUE, FALSE, &u4BufLen); #if !CFG_SUPPORT_PERSIST_NETDEV /* Need to check fgIsP2PRegistered, in case of whole chip reset. * in this case, kalIOCTL return success always, * and prGlueInfo->prP2pInfo may be NULL */ if ((rSetP2P.u4Enable) && (prGlueInfo->prAdapter->fgIsP2PRegistered) && (fgIsResetting == FALSE)) p2pNetRegister(prGlueInfo, TRUE); #endif GLUE_ACQUIRE_THE_SPIN_LOCK(&g_p2p_lock); g_u4P2POnOffing = 0; GLUE_RELEASE_THE_SPIN_LOCK(&g_p2p_lock); return 0; #endif } static void set_dbg_level_handler(unsigned char dbg_lvl[DBG_MODULE_NUM]) { kalMemCopy(aucDebugModule, dbg_lvl, sizeof(aucDebugModule)); kalPrint("[wlan] change debug level"); } /*----------------------------------------------------------------------------*/ /*! * \brief Wlan probe function. This function probes and initializes the device. * * \param[in] pvData data passed by bus driver init function * _HIF_EHPI: NULL * _HIF_SDIO: sdio bus driver handle * * \retval 0 Success * \retval negative value Failed */ /*----------------------------------------------------------------------------*/ static INT_32 wlanProbe(PVOID pvData) { struct wireless_dev *prWdev = NULL; enum probe_fail_reason { BUS_INIT_FAIL, NET_CREATE_FAIL, BUS_SET_IRQ_FAIL, ADAPTER_START_FAIL, NET_REGISTER_FAIL, PROC_INIT_FAIL, FAIL_REASON_NUM } eFailReason; P_WLANDEV_INFO_T prWlandevInfo = NULL; INT_32 i4DevIdx = 0; P_GLUE_INFO_T prGlueInfo = NULL; P_ADAPTER_T prAdapter = NULL; INT_32 i4Status = 0; BOOLEAN bRet = FALSE; eFailReason = FAIL_REASON_NUM; do { /* 4 <1> Initialize the IO port of the interface */ /* GeorgeKuo: pData has different meaning for _HIF_XXX: * _HIF_EHPI: pointer to memory base variable, which will be * initialized by glBusInit(). * _HIF_SDIO: bus driver handle */ bRet = glBusInit(pvData); wlanDebugInit(); /* Cannot get IO address from interface */ if (FALSE == bRet) { DBGLOG(INIT, ERROR, KERN_ALERT "wlanProbe: glBusInit() fail\n"); i4Status = -EIO; eFailReason = BUS_INIT_FAIL; break; } /* 4 <2> Create network device, Adapter, KalInfo, prDevHandler(netdev) */ prWdev = wlanNetCreate(pvData); if (prWdev == NULL) { DBGLOG(INIT, ERROR, "wlanProbe: No memory for dev and its private\n"); i4Status = -ENOMEM; eFailReason = NET_CREATE_FAIL; break; } /* 4 <2.5> Set the ioaddr to HIF Info */ prGlueInfo = (P_GLUE_INFO_T) wiphy_priv(prWdev->wiphy); gPrDev = prGlueInfo->prDevHandler; /* 4 <4> Setup IRQ */ prWlandevInfo = &arWlanDevInfo[i4DevIdx]; i4Status = glBusSetIrq(prWdev->netdev, NULL, *((P_GLUE_INFO_T *) netdev_priv(prWdev->netdev))); if (i4Status != WLAN_STATUS_SUCCESS) { DBGLOG(INIT, ERROR, "wlanProbe: Set IRQ error\n"); eFailReason = BUS_SET_IRQ_FAIL; break; } prGlueInfo->i4DevIdx = i4DevIdx; prAdapter = prGlueInfo->prAdapter; prGlueInfo->u4ReadyFlag = 0; #if CFG_TCP_IP_CHKSUM_OFFLOAD prAdapter->u4CSUMFlags = (CSUM_OFFLOAD_EN_TX_TCP | CSUM_OFFLOAD_EN_TX_UDP | CSUM_OFFLOAD_EN_TX_IP); #endif #if CFG_SUPPORT_CFG_FILE #ifdef ENABLED_IN_ENGUSERDEBUG { PUINT_8 pucConfigBuf; UINT_32 u4ConfigReadLen; wlanCfgInit(prAdapter, NULL, 0, 0); pucConfigBuf = (PUINT_8) kalMemAlloc(WLAN_CFG_FILE_BUF_SIZE, VIR_MEM_TYPE); u4ConfigReadLen = 0; DBGLOG(INIT, LOUD, "CFG_FILE: Read File...\n"); if (pucConfigBuf) { kalMemZero(pucConfigBuf, WLAN_CFG_FILE_BUF_SIZE); if (kalReadToFile("/data/misc/wifi.cfg", pucConfigBuf, WLAN_CFG_FILE_BUF_SIZE, &u4ConfigReadLen) == 0) { DBGLOG(INIT, LOUD, "CFG_FILE: Read /data/misc/wifi.cfg\n"); } else if (kalReadToFile("/data/misc/wifi/wifi.cfg", pucConfigBuf, WLAN_CFG_FILE_BUF_SIZE, &u4ConfigReadLen) == 0) { DBGLOG(INIT, LOUD, "CFG_FILE: Read /data/misc/wifi/wifi.cfg\n"); } else if (kalReadToFile("/etc/firmware/wifi.cfg", pucConfigBuf, WLAN_CFG_FILE_BUF_SIZE, &u4ConfigReadLen) == 0) { DBGLOG(INIT, LOUD, "CFG_FILE: Read /etc/firmware/wifi.cfg\n"); } if (pucConfigBuf[0] != '\0' && u4ConfigReadLen > 0) wlanCfgInit(prAdapter, pucConfigBuf, u4ConfigReadLen, 0); kalMemFree(pucConfigBuf, VIR_MEM_TYPE, WLAN_CFG_FILE_BUF_SIZE); } /* pucConfigBuf */ } #endif #endif /* 4 <5> Start Device */ /* */ #if CFG_ENABLE_FW_DOWNLOAD DBGLOG(INIT, TRACE, "start to download firmware...\n"); /* before start adapter, we need to open and load firmware */ { UINT_32 u4FwSize = 0; PVOID prFwBuffer = NULL; P_REG_INFO_T prRegInfo = &prGlueInfo->rRegInfo; /* P_REG_INFO_T prRegInfo = (P_REG_INFO_T) kmalloc(sizeof(REG_INFO_T), GFP_KERNEL); */ kalMemSet(prRegInfo, 0, sizeof(REG_INFO_T)); prRegInfo->u4StartAddress = CFG_FW_START_ADDRESS; prRegInfo->u4LoadAddress = CFG_FW_LOAD_ADDRESS; /* Load NVRAM content to REG_INFO_T */ glLoadNvram(prGlueInfo, prRegInfo); #if CFG_SUPPORT_CFG_FILE #ifdef ENABLED_IN_ENGUSERDEBUG wlanCfgApply(prAdapter); #endif #endif /* kalMemCopy(&prGlueInfo->rRegInfo, prRegInfo, sizeof(REG_INFO_T)); */ prRegInfo->u4PowerMode = CFG_INIT_POWER_SAVE_PROF; prRegInfo->fgEnArpFilter = TRUE; if (kalFirmwareImageMapping(prGlueInfo, &prFwBuffer, &u4FwSize) == NULL) { i4Status = -EIO; DBGLOG(INIT, ERROR, "kalFirmwareImageMapping fail!\n"); goto bailout; } else { if (wlanAdapterStart(prAdapter, prRegInfo, prFwBuffer, u4FwSize) != WLAN_STATUS_SUCCESS) { i4Status = -EIO; } } kalFirmwareImageUnmapping(prGlueInfo, NULL, prFwBuffer); bailout: /* kfree(prRegInfo); */ DBGLOG(INIT, TRACE, "download firmware status = %d\n", i4Status); if (i4Status < 0) { GL_HIF_INFO_T *HifInfo; UINT_32 u4FwCnt; DBGLOG(INIT, WARN, "CONNSYS FW CPUINFO:\n"); HifInfo = &prAdapter->prGlueInfo->rHifInfo; for (u4FwCnt = 0; u4FwCnt < 16; u4FwCnt++) DBGLOG(INIT, WARN, "0x%08x ", MCU_REG_READL(HifInfo, CONN_MCU_CPUPCR)); /* CONSYS_REG_READ(CONSYS_CPUPCR_REG) */ /* dump HIF/DMA registers, if fgIsBusAccessFailed is FALSE, otherwise, */ /* dump HIF register may be hung */ if (!fgIsBusAccessFailed) HifRegDump(prGlueInfo->prAdapter); /* if (prGlueInfo->rHifInfo.DmaOps->DmaRegDump != NULL) */ /* prGlueInfo->rHifInfo.DmaOps->DmaRegDump(&prGlueInfo->rHifInfo); */ eFailReason = ADAPTER_START_FAIL; break; } } #else /* P_REG_INFO_T prRegInfo = (P_REG_INFO_T) kmalloc(sizeof(REG_INFO_T), GFP_KERNEL); */ kalMemSet(&prGlueInfo->rRegInfo, 0, sizeof(REG_INFO_T)); P_REG_INFO_T prRegInfo = &prGlueInfo->rRegInfo; /* Load NVRAM content to REG_INFO_T */ glLoadNvram(prGlueInfo, prRegInfo); prRegInfo->u4PowerMode = CFG_INIT_POWER_SAVE_PROF; if (wlanAdapterStart(prAdapter, prRegInfo, NULL, 0) != WLAN_STATUS_SUCCESS) { i4Status = -EIO; eFailReason = ADAPTER_START_FAIL; break; } #endif if (FALSE == prAdapter->fgEnable5GBand) prWdev->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL; else prWdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &mtk_band_5ghz; prGlueInfo->main_thread = kthread_run(tx_thread, prGlueInfo->prDevHandler, "tx_thread"); kalSetHalted(FALSE); #if CFG_SUPPORT_ROAMING_ENC /* adjust roaming threshold */ { WLAN_STATUS rStatus = WLAN_STATUS_FAILURE; CMD_ROAMING_INFO_T rRoamingInfo; UINT_32 u4SetInfoLen = 0; prAdapter->fgIsRoamingEncEnabled = TRUE; /* suggestion from Tsaiyuan.Hsu */ kalMemZero(&rRoamingInfo, sizeof(CMD_ROAMING_INFO_T)); rRoamingInfo.fgIsFastRoamingApplied = TRUE; DBGLOG(INIT, TRACE, "Enable roaming enhance function\n"); rStatus = kalIoctl(prGlueInfo, wlanoidSetRoamingInfo, &rRoamingInfo, sizeof(rRoamingInfo), TRUE, TRUE, TRUE, FALSE, &u4SetInfoLen); if (rStatus != WLAN_STATUS_SUCCESS) DBGLOG(INIT, ERROR, "set roaming advance info fail 0x%x\n", rStatus); } #endif /* CFG_SUPPORT_ROAMING_ENC */ #if (CFG_SUPPORT_TXR_ENC == 1) /* adjust tx rate switch threshold */ rlmTxRateEnhanceConfig(prGlueInfo->prAdapter); #endif /* CFG_SUPPORT_TXR_ENC */ /* set MAC address */ { WLAN_STATUS rStatus = WLAN_STATUS_FAILURE; struct sockaddr MacAddr; UINT_32 u4SetInfoLen = 0; kalMemZero(MacAddr.sa_data, sizeof(MacAddr.sa_data)); rStatus = kalIoctl(prGlueInfo, wlanoidQueryCurrentAddr, &MacAddr.sa_data, PARAM_MAC_ADDR_LEN, TRUE, TRUE, TRUE, FALSE, &u4SetInfoLen); if (rStatus != WLAN_STATUS_SUCCESS) { DBGLOG(INIT, WARN, "set MAC addr fail 0x%x\n", rStatus); prGlueInfo->u4ReadyFlag = 0; } else { ether_addr_copy(prGlueInfo->prDevHandler->dev_addr, (const u8 *)&(MacAddr.sa_data)); ether_addr_copy(prGlueInfo->prDevHandler->perm_addr, prGlueInfo->prDevHandler->dev_addr); /* card is ready */ prGlueInfo->u4ReadyFlag = 1; #if CFG_SHOW_MACADDR_SOURCE DBGLOG(INIT, INFO, "MAC address: %pM ", (&MacAddr.sa_data)); #endif } } #ifdef FW_CFG_SUPPORT { if (wlanFwArrayCfg(prAdapter) != WLAN_STATUS_FAILURE) DBGLOG(INIT, INFO, "FW Array Cfg done!"); } #ifdef ENABLED_IN_ENGUSERDEBUG { if (wlanFwFileCfg(prAdapter) != WLAN_STATUS_FAILURE) DBGLOG(INIT, INFO, "FW File Cfg done!"); } #endif #endif #if CFG_TCP_IP_CHKSUM_OFFLOAD /* set HW checksum offload */ { WLAN_STATUS rStatus = WLAN_STATUS_FAILURE; UINT_32 u4CSUMFlags = CSUM_OFFLOAD_EN_ALL; UINT_32 u4SetInfoLen = 0; rStatus = kalIoctl(prGlueInfo, wlanoidSetCSUMOffload, (PVOID) &u4CSUMFlags, sizeof(UINT_32), FALSE, FALSE, TRUE, FALSE, &u4SetInfoLen); if (rStatus != WLAN_STATUS_SUCCESS) DBGLOG(INIT, WARN, "set HW checksum offload fail 0x%x\n", rStatus); } #endif /* 4 <3> Register the card */ DBGLOG(INIT, TRACE, "wlanNetRegister...\n"); i4DevIdx = wlanNetRegister(prWdev); if (i4DevIdx < 0) { i4Status = -ENXIO; DBGLOG(INIT, ERROR, "wlanProbe: Cannot register the net_device context to the kernel\n"); eFailReason = NET_REGISTER_FAIL; break; } wlanRegisterNotifier(); /* 4 <6> Initialize /proc filesystem */ #ifdef WLAN_INCLUDE_PROC DBGLOG(INIT, TRACE, "init procfs...\n"); i4Status = procCreateFsEntry(prGlueInfo); if (i4Status < 0) { DBGLOG(INIT, ERROR, "wlanProbe: init procfs failed\n"); eFailReason = PROC_INIT_FAIL; break; } #endif /* WLAN_INCLUDE_PROC */ #ifdef FW_CFG_SUPPORT i4Status = cfgCreateProcEntry(prGlueInfo); if (i4Status < 0) { DBGLOG(INIT, ERROR, "fw cfg proc failed\n"); break; } #endif #if CFG_ENABLE_BT_OVER_WIFI prGlueInfo->rBowInfo.fgIsNetRegistered = FALSE; prGlueInfo->rBowInfo.fgIsRegistered = FALSE; glRegisterAmpc(prGlueInfo); #endif #if CFG_ENABLE_WIFI_DIRECT DBGLOG(INIT, TRACE, "wlanSubModInit...\n"); /* wlan is launched */ prGlueInfo->prAdapter->fgIsWlanLaunched = TRUE; /* if p2p module is inserted, notify tx_thread to init p2p network */ if (rSubModHandler[P2P_MODULE].subModInit) wlanSubModInit(prGlueInfo); /* register set_p2p_mode handler to mtk_wmt_wifi */ register_set_p2p_mode_handler(set_p2p_mode_handler); #endif #if CFG_SPM_WORKAROUND_FOR_HOTSPOT if (glIsChipNeedWakelock(prGlueInfo)) KAL_WAKE_LOCK_INIT(prGlueInfo->prAdapter, &prGlueInfo->prAdapter->rApWakeLock, "WLAN AP"); #endif } while (FALSE); if (i4Status != WLAN_STATUS_SUCCESS) { switch (eFailReason) { case PROC_INIT_FAIL: wlanNetUnregister(prWdev); set_bit(GLUE_FLAG_HALT_BIT, &prGlueInfo->ulFlag); /* wake up main thread */ wake_up_interruptible(&prGlueInfo->waitq); /* wait main thread stops */ wait_for_completion_interruptible(&prGlueInfo->rHaltComp); KAL_WAKE_LOCK_DESTROY(prAdapter, &prAdapter->rTxThreadWakeLock); wlanAdapterStop(prAdapter); glBusFreeIrq(prWdev->netdev, *((P_GLUE_INFO_T *) netdev_priv(prWdev->netdev))); KAL_WAKE_LOCK_DESTROY(prAdapter, &prGlueInfo->rAhbIsrWakeLock); wlanNetDestroy(prWdev); break; case NET_REGISTER_FAIL: set_bit(GLUE_FLAG_HALT_BIT, &prGlueInfo->ulFlag); /* wake up main thread */ wake_up_interruptible(&prGlueInfo->waitq); /* wait main thread stops */ wait_for_completion_interruptible(&prGlueInfo->rHaltComp); KAL_WAKE_LOCK_DESTROY(prAdapter, &prAdapter->rTxThreadWakeLock); wlanAdapterStop(prAdapter); glBusFreeIrq(prWdev->netdev, *((P_GLUE_INFO_T *) netdev_priv(prWdev->netdev))); KAL_WAKE_LOCK_DESTROY(prAdapter, &prGlueInfo->rAhbIsrWakeLock); wlanNetDestroy(prWdev); break; case ADAPTER_START_FAIL: glBusFreeIrq(prWdev->netdev, *((P_GLUE_INFO_T *) netdev_priv(prWdev->netdev))); KAL_WAKE_LOCK_DESTROY(prAdapter, &prGlueInfo->rAhbIsrWakeLock); wlanNetDestroy(prWdev); break; case BUS_SET_IRQ_FAIL: KAL_WAKE_LOCK_DESTROY(prAdapter, &prGlueInfo->rAhbIsrWakeLock); wlanNetDestroy(prWdev); break; case NET_CREATE_FAIL: break; case BUS_INIT_FAIL: break; default: break; } } #if CFG_ENABLE_WIFI_DIRECT { GLUE_SPIN_LOCK_DECLARATION(); GLUE_ACQUIRE_THE_SPIN_LOCK(&g_p2p_lock); g_u4P2PEnding = 0; GLUE_RELEASE_THE_SPIN_LOCK(&g_p2p_lock); } #endif #if CFG_SUPPORT_AGPS_ASSIST if (i4Status == WLAN_STATUS_SUCCESS) kalIndicateAgpsNotify(prAdapter, AGPS_EVENT_WLAN_ON, NULL, 0); #endif #if (CFG_SUPPORT_MET_PROFILING == 1) { int iMetInitRet = WLAN_STATUS_FAILURE; if (i4Status == WLAN_STATUS_SUCCESS) { DBGLOG(INIT, TRACE, "init MET procfs...\n"); iMetInitRet = kalMetInitProcfs(prGlueInfo); if (iMetInitRet < 0) DBGLOG(INIT, ERROR, "wlanProbe: init MET procfs failed\n"); } } #endif if (i4Status == WLAN_STATUS_SUCCESS) { /*Init performance monitor structure */ kalPerMonInit(prGlueInfo); /* probe ok */ DBGLOG(INIT, TRACE, "wlanProbe ok\n"); } else { /* we don't care the return value of mtk_wcn_set_connsys_power_off_flag, * because even this function returns * error, we can also call core dump but only core dump failed. */ if (g_IsNeedDoChipReset) mtk_wcn_set_connsys_power_off_flag(0); /* probe failed */ DBGLOG(INIT, ERROR, "wlanProbe failed\n"); } return i4Status; } /* end of wlanProbe() */ /*----------------------------------------------------------------------------*/ /*! * \brief A method to stop driver operation and release all resources. Following * this call, no frame should go up or down through this interface. * * \return (none) */ /*----------------------------------------------------------------------------*/ static VOID wlanRemove(VOID) { #define KAL_WLAN_REMOVE_TIMEOUT_MSEC 3000 struct net_device *prDev = NULL; P_WLANDEV_INFO_T prWlandevInfo = NULL; P_GLUE_INFO_T prGlueInfo = NULL; P_ADAPTER_T prAdapter = NULL; DBGLOG(INIT, LOUD, "Remove wlan!\n"); /* 4 <0> Sanity check */ ASSERT(u4WlanDevNum <= CFG_MAX_WLAN_DEVICES); if (0 == u4WlanDevNum) { DBGLOG(INIT, ERROR, "0 == u4WlanDevNum\n"); return; } /* unregister set_p2p_mode handler to mtk_wmt_wifi */ register_set_p2p_mode_handler(NULL); prDev = arWlanDevInfo[u4WlanDevNum - 1].prDev; prWlandevInfo = &arWlanDevInfo[u4WlanDevNum - 1]; ASSERT(prDev); if (NULL == prDev) { DBGLOG(INIT, ERROR, "NULL == prDev\n"); return; } prGlueInfo = *((P_GLUE_INFO_T *) netdev_priv(prDev)); ASSERT(prGlueInfo); if (NULL == prGlueInfo) { DBGLOG(INIT, ERROR, "NULL == prGlueInfo\n"); free_netdev(prDev); return; } kalPerMonDestroy(prGlueInfo); /* 4 <3> Remove /proc filesystem. */ #ifdef FW_CFG_SUPPORT cfgRemoveProcEntry(); #endif #ifdef WLAN_INCLUDE_PROC procRemoveProcfs(); #endif /* WLAN_INCLUDE_PROC */ #if CFG_ENABLE_WIFI_DIRECT /* avoid remove & p2p off command simultaneously */ { BOOLEAN fgIsP2POnOffing; GLUE_SPIN_LOCK_DECLARATION(); GLUE_ACQUIRE_THE_SPIN_LOCK(&g_p2p_lock); g_u4P2PEnding = 1; fgIsP2POnOffing = g_u4P2POnOffing; GLUE_RELEASE_THE_SPIN_LOCK(&g_p2p_lock); DBGLOG(INIT, TRACE, "waiting for fgIsP2POnOffing...\n"); /* History: cannot use down() here, sometimes we cannot come back here */ /* waiting for p2p off command finishes, we cannot skip the remove */ while (1) { if (fgIsP2POnOffing == 0) break; GLUE_ACQUIRE_THE_SPIN_LOCK(&g_p2p_lock); fgIsP2POnOffing = g_u4P2POnOffing; GLUE_RELEASE_THE_SPIN_LOCK(&g_p2p_lock); } } #endif #if CFG_ENABLE_BT_OVER_WIFI if (prGlueInfo->rBowInfo.fgIsNetRegistered) { bowNotifyAllLinkDisconnected(prGlueInfo->prAdapter); /* wait 300ms for BoW module to send deauth */ kalMsleep(300); } #endif /* 4 <1> Stopping handling interrupt and free IRQ */ DBGLOG(INIT, TRACE, "free IRQ...\n"); glBusFreeIrq(prDev, *((P_GLUE_INFO_T *) netdev_priv(prDev))); kalMemSet(&(prGlueInfo->prAdapter->rWlanInfo), 0, sizeof(WLAN_INFO_T)); kalSetHalted(TRUE); /* before flush_delayed_work() */ if (fgIsWorkMcStart == TRUE) { DBGLOG(INIT, TRACE, "flush_delayed_work...\n"); flush_delayed_work(&workq); /* flush_delayed_work_sync is deprecated */ } flush_delayed_work(&sched_workq); DBGLOG(INIT, INFO, "down g_halt_sem...\n"); kalHaltLock(KAL_WLAN_REMOVE_TIMEOUT_MSEC); #if CFG_SPM_WORKAROUND_FOR_HOTSPOT if (glIsChipNeedWakelock(prGlueInfo)) KAL_WAKE_LOCK_DESTROY(prGlueInfo->prAdapter, &prGlueInfo->prAdapter->rApWakeLock); #endif /* flush_delayed_work_sync(&workq); */ /* flush_delayed_work(&workq); */ /* flush_delayed_work_sync is deprecated */ /* 4 <2> Mark HALT, notify main thread to stop, and clean up queued requests */ /* prGlueInfo->u4Flag |= GLUE_FLAG_HALT; */ set_bit(GLUE_FLAG_HALT_BIT, &prGlueInfo->ulFlag); DBGLOG(INIT, TRACE, "waiting for tx_thread stop...\n"); /* wake up main thread */ wake_up_interruptible(&prGlueInfo->waitq); DBGLOG(INIT, TRACE, "wait_for_completion_interruptible\n"); /* wait main thread stops */ wait_for_completion_interruptible(&prGlueInfo->rHaltComp); DBGLOG(INIT, TRACE, "mtk_sdiod stopped\n"); KAL_WAKE_LOCK_DESTROY(prGlueInfo->prAdapter, &prGlueInfo->prAdapter->rTxThreadWakeLock); KAL_WAKE_LOCK_DESTROY(prGlueInfo->prAdapter, &prGlueInfo->rAhbIsrWakeLock); /* prGlueInfo->rHifInfo.main_thread = NULL; */ prGlueInfo->main_thread = NULL; #if CFG_ENABLE_BT_OVER_WIFI if (prGlueInfo->rBowInfo.fgIsRegistered) glUnregisterAmpc(prGlueInfo); #endif #if (CFG_SUPPORT_MET_PROFILING == 1) kalMetRemoveProcfs(); #endif /* Force to do DMA reset */ DBGLOG(INIT, TRACE, "glResetHif\n"); glResetHif(prGlueInfo); /* 4 <4> wlanAdapterStop */ prAdapter = prGlueInfo->prAdapter; #if CFG_SUPPORT_AGPS_ASSIST kalIndicateAgpsNotify(prAdapter, AGPS_EVENT_WLAN_OFF, NULL, 0); #endif wlanAdapterStop(prAdapter); DBGLOG(INIT, TRACE, "Number of Stalled Packets = %d\n", prGlueInfo->i4TxPendingFrameNum); #if CFG_ENABLE_WIFI_DIRECT prGlueInfo->prAdapter->fgIsWlanLaunched = FALSE; if (prGlueInfo->prAdapter->fgIsP2PRegistered) { DBGLOG(INIT, TRACE, "p2pNetUnregister...\n"); #if !CFG_SUPPORT_PERSIST_NETDEV p2pNetUnregister(prGlueInfo, FALSE); #endif DBGLOG(INIT, INFO, "p2pRemove...\n"); p2pRemove(prGlueInfo); } #endif /* 4 <5> Release the Bus */ glBusRelease(prDev); kalHaltUnlock(); wlanDebugUninit(); /* 4 <6> Unregister the card */ wlanNetUnregister(prDev->ieee80211_ptr); /* 4 <7> Destroy the device */ wlanNetDestroy(prDev->ieee80211_ptr); prDev = NULL; DBGLOG(INIT, LOUD, "wlanUnregisterNotifier...\n"); wlanUnregisterNotifier(); DBGLOG(INIT, INFO, "wlanRemove ok\n"); } /* end of wlanRemove() */ /*----------------------------------------------------------------------------*/ /*! * \brief Driver entry point when the driver is configured as a Linux Module, and * is called once at module load time, by the user-level modutils * application: insmod or modprobe. * * \retval 0 Success */ /*----------------------------------------------------------------------------*/ /* 1 Module Entry Point */ static int initWlan(void) { int ret = 0, i; #if DBG for (i = 0; i < DBG_MODULE_NUM; i++) aucDebugModule[i] = DBG_CLASS_MASK; /* enable all */ #else /* Initial debug level is D1 */ for (i = 0; i < DBG_MODULE_NUM; i++) aucDebugModule[i] = DBG_CLASS_ERROR | DBG_CLASS_WARN | DBG_CLASS_INFO | DBG_CLASS_STATE; #endif /* DBG */ DBGLOG(INIT, INFO, "initWlan\n"); spin_lock_init(&g_p2p_lock); /* memory pre-allocation */ kalInitIOBuffer(); procInitFs(); createWirelessDevice(); if (gprWdev) glP2pCreateWirelessDevice((P_GLUE_INFO_T) wiphy_priv(gprWdev->wiphy)); ret = ((glRegisterBus(wlanProbe, wlanRemove) == WLAN_STATUS_SUCCESS) ? 0 : -EIO); if (ret == -EIO) { kalUninitIOBuffer(); return ret; } #if (CFG_CHIP_RESET_SUPPORT) glResetInit(); #endif /* register set_dbg_level handler to mtk_wmt_wifi */ register_set_dbg_level_handler(set_dbg_level_handler); /* Register framebuffer notifier client*/ kalFbNotifierReg((P_GLUE_INFO_T) wiphy_priv(gprWdev->wiphy)); /* Set the initial DEBUG CLASS of each module */ return ret; } /* end of initWlan() */ /*----------------------------------------------------------------------------*/ /*! * \brief Driver exit point when the driver as a Linux Module is removed. Called * at module unload time, by the user level modutils application: rmmod. * This is our last chance to clean up after ourselves. * * \return (none) */ /*----------------------------------------------------------------------------*/ /* 1 Module Leave Point */ static VOID exitWlan(void) { DBGLOG(INIT, INFO, "exitWlan\n"); /* Unregister framebuffer notifier client*/ kalFbNotifierUnReg(); /* unregister set_dbg_level handler to mtk_wmt_wifi */ register_set_dbg_level_handler(NULL); #if CFG_CHIP_RESET_SUPPORT glResetUninit(); #endif destroyWirelessDevice(); glP2pDestroyWirelessDevice(); glUnregisterBus(wlanRemove); /* free pre-allocated memory */ kalUninitIOBuffer(); DBGLOG(INIT, INFO, "exitWlan\n"); procUninitProcFs(); } /* end of exitWlan() */ #ifdef MTK_WCN_BUILT_IN_DRIVER int mtk_wcn_wlan_gen2_init(void) { return initWlan(); } EXPORT_SYMBOL(mtk_wcn_wlan_gen2_init); void mtk_wcn_wlan_gen2_exit(void) { return exitWlan(); } EXPORT_SYMBOL(mtk_wcn_wlan_gen2_exit); #else module_init(initWlan); module_exit(exitWlan); #endif