| /* |
| * Copyright (c) 2018 The Fuchsia Authors. |
| * |
| * Permission to use, copy, modify, and/or distribute this software for any |
| * purpose with or without fee is hereby granted, provided that the above |
| * copyright notice and this permission notice appear in all copies. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
| * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
| * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| // This file contains what's needed to make Linux code compile (but not run) on Fuchsia. |
| // As the driver is ported, symbols will be removed from this file. When the driver is |
| // fully ported, this file will be empty and can be deleted. |
| // The symbols were defined by hand, based only on information from compiler errors and |
| // code in this driver. Do not expect defines/enums to have correct values, or struct fields to have |
| // correct types. Function prototypes are even less accurate. |
| |
| #ifndef GARNET_DRIVERS_WLAN_THIRD_PARTY_BROADCOM_BRCMFMAC_LINUXISMS_H_ |
| #define GARNET_DRIVERS_WLAN_THIRD_PARTY_BROADCOM_BRCMFMAC_LINUXISMS_H_ |
| |
| #include <ddk/debug.h> |
| #include <ddk/device.h> |
| #include <netinet/if_ether.h> |
| #include <pthread.h> |
| #include <stdarg.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <sys/types.h> |
| #include <wlan/protocol/info.h> |
| #include <zircon/assert.h> |
| #include <zircon/listnode.h> |
| #include <zircon/syscalls.h> |
| #include <zircon/types.h> |
| |
| typedef uint16_t __be16; |
| typedef uint32_t __be32; |
| typedef uint64_t __be64; |
| |
| // FROM Josh's linuxisms.h |
| |
| #define BIT(pos) (1UL << (pos)) |
| |
| #define DIV_ROUND_UP(n, m) (((n) + ((m)-1)) / (m)) |
| |
| #define GENMASK1(val) ((1UL << (val)) - 1) |
| #define GENMASK(start, end) ((GENMASK1((start) + 1) & ~GENMASK1(end))) |
| |
| #define WARN(cond, msg) \ |
| ({ bool ret_cond = cond; \ |
| if (ret_cond) { \ |
| zxlogf(WARN, "brcmfmac: unexpected condition %s warns %s at %s:%d\n", \ |
| #cond, msg, __FILE__, __LINE__); \ |
| } \ |
| ret_cond; \ |
| }) |
| |
| // TODO(cphoenix): Looks like these evaluate cond multiple times. And maybe should |
| // pass cond, not #cond, into WARN. |
| #define WARN_ON(cond) \ |
| ({ \ |
| if (cond) { WARN(#cond, "it's bad"); } \ |
| cond; \ |
| }) |
| |
| #define WARN_ON_ONCE(cond) \ |
| ({ \ |
| static bool warn_next = true; \ |
| if (cond && warn_next) { \ |
| WARN(#cond, "(future warnings suppressed)"); \ |
| warn_next = false; \ |
| } \ |
| cond; \ |
| }) |
| |
| #define iowrite32(value, addr) \ |
| do { \ |
| (*(volatile uint32_t*)(uintptr_t)(addr)) = (value); \ |
| } while (0) |
| |
| #define ioread32(addr) (*(volatile uint32_t*)(uintptr_t)(addr)) |
| |
| #define iowrite16(value, addr) \ |
| do { \ |
| (*(volatile uint16_t*)(uintptr_t)(addr)) = (value); \ |
| } while (0) |
| |
| #define ioread16(addr) (*(volatile uint16_t*)(uintptr_t)(addr)) |
| |
| #define iowrite8(value, addr) \ |
| do { \ |
| (*(volatile uint8_t*)(uintptr_t)(addr)) = (value); \ |
| } while (0) |
| |
| #define ioread8(addr) (*(volatile uint8_t*)(uintptr_t)(addr)) |
| |
| #define usleep(us) zx_nanosleep(zx_deadline_after(ZX_USEC(us))) |
| #define usleep_range(early, late) usleep(early) |
| #define msleep(ms) zx_nanosleep(zx_deadline_after(ZX_MSEC(ms))) |
| #define PAUSE zx_nanosleep(zx_deadline_after(ZX_MSEC(50))) |
| |
| #define min(a, b) (((a) < (b)) ? (a) : (b)) |
| #define min_t(t, a, b) (((t)(a) < (t)(b)) ? (t)(a) : (t)(b)) |
| |
| #define roundup(n, m) (((n) % (m) == 0) ? (n) : (n) + ((m) - ((n) % (m)))) |
| |
| #define LINUX_FUNC(name, paramtype, rettype) \ |
| static inline rettype name(paramtype foo, ...) { \ |
| /*zxlogf(ERROR, "brcmfmac: * * ERROR * * Called linux function %s\n", #name); */ \ |
| return (rettype)0; \ |
| } |
| #define LINUX_FUNCX(name) \ |
| static inline int name() { \ |
| /*zxlogf(ERROR, "brcmfmac: * * ERROR * * Called linux function %s\n", #name); */ \ |
| return 0; \ |
| } |
| |
| #define CHIPSET_ARM_CM3_CORE 0x82a |
| #define CHIPSET_INTERNAL_MEM_CORE 0x80e |
| #define CHIPSET_ARM_CR4_CORE 0x83e |
| #define CHIPSET_ARM_CA7_CORE 0x847 |
| #define CHIPSET_80211_CORE 0x812 |
| #define CHIPSET_PCIE2_CORE 0x83c |
| #define CHIPSET_SDIO_DEV_CORE 0x829 |
| #define CHIPSET_CHIPCOMMON_CORE 0x800 |
| #define CHIPSET_SYS_MEM_CORE 0x849 |
| #define CHIPSET_PMU_CORE 0x827 |
| |
| // clang-format off |
| #define LINUX_FUNCII(name) LINUX_FUNC(name, int, int) |
| #define LINUX_FUNCIV(name) LINUX_FUNC(name, int, void*) |
| #define LINUX_FUNCVV(name) LINUX_FUNC(name, void*, void*) |
| #define LINUX_FUNCVI(name) LINUX_FUNC(name, void*, int) |
| #define LINUX_FUNCVS(name) LINUX_FUNC(name, void*, zx_status_t) |
| #define LINUX_FUNCcVI(name) LINUX_FUNC(name, const void*, int) |
| #define LINUX_FUNCcVS(name) LINUX_FUNC(name, const void*, zx_status_t) |
| #define LINUX_FUNCcVV(name) LINUX_FUNC(name, const void*, void*) |
| #define LINUX_FUNCVU(name) LINUX_FUNC(name, void*, uint16_t) |
| #define LINUX_FUNCUU(name) LINUX_FUNC(name, uint32_t, uint32_t) |
| |
| LINUX_FUNCVI(netif_carrier_on) |
| LINUX_FUNCVI(netif_carrier_ok) |
| LINUX_FUNCVI(ether_addr_equal) // Trivial |
| LINUX_FUNCVI(is_valid_ether_addr) |
| LINUX_FUNCVI(eth_type_trans) |
| LINUX_FUNCII(BITS_TO_LONGS) |
| LINUX_FUNCII(gcd) |
| LINUX_FUNCX(get_random_int) |
| LINUX_FUNCII(round_up) |
| LINUX_FUNCVI(nla_put) // Add netlink attribute to netbuf |
| LINUX_FUNCVI(nla_put_u16) // Add u16 attribute to netbuf |
| LINUX_FUNCII(MBM_TO_DBM) |
| LINUX_FUNCX(prandom_u32) |
| |
| LINUX_FUNCVI(netdev_mc_count) // In core.c - Count of multicast addresses in netdev. |
| LINUX_FUNCX(rtnl_lock) // In core.c and p2p.c |
| LINUX_FUNCX(rtnl_unlock) // In core.c and p2p.c |
| LINUX_FUNCVV(bcm47xx_nvram_get_contents) // In firmware.c |
| LINUX_FUNCVI(bcm47xx_nvram_release_contents) // In firmware.c |
| |
| LINUX_FUNCVI(device_set_wakeup_enable) // USB only |
| LINUX_FUNCVI(usb_deregister) // USB only |
| LINUX_FUNCVI(driver_for_each_device) // In usb.c only |
| |
| // Last parameter of this returns an error code. Must be a zx_status_t (0 or negative). |
| #define SDIO_DEVICE(a,b) (a) |
| LINUX_FUNCVI(pm_runtime_allow) // SDIO only |
| LINUX_FUNCVI(pm_runtime_forbid) // SDIO only |
| // Leave enable/disable_irq_wake() NOPs for now. TODO(cphoenix): Use the ZX equivalent. |
| LINUX_FUNCII(enable_irq_wake) // SDIO only |
| LINUX_FUNCII(disable_irq_wake) // SDIO only |
| LINUX_FUNCVI(of_device_is_compatible) |
| LINUX_FUNCVI(of_property_read_u32) |
| LINUX_FUNCVI(of_find_property) |
| LINUX_FUNCVI(irq_of_parse_and_map) // OF only |
| LINUX_FUNCII(irqd_get_trigger_type) // OF only |
| LINUX_FUNCII(irq_get_irq_data) // OF only |
| |
| LINUX_FUNCVI(device_release_driver) |
| #define module_param_string(a, b, c, d) |
| #define module_exit(a) \ |
| void* __modexit() { return a; } |
| #define module_init(a) \ |
| void* __modinit() { return a; } |
| |
| LINUX_FUNCVI(netif_stop_queue) |
| LINUX_FUNCVI(cfg80211_classify8021d) |
| LINUX_FUNCVI(cfg80211_crit_proto_stopped) |
| LINUX_FUNCVV(cfg80211_vendor_cmd_alloc_reply_netbuf) |
| LINUX_FUNCVI(cfg80211_vendor_cmd_reply) |
| LINUX_FUNCVI(cfg80211_ready_on_channel) |
| LINUX_FUNCcVS(cfg80211_get_p2p_attr) // TODO(cphoenix): Can this return >0? If so, adjust usage. |
| LINUX_FUNCVI(cfg80211_remain_on_channel_expired) |
| LINUX_FUNCVI(cfg80211_unregister_wdev) |
| LINUX_FUNCVI(cfg80211_rx_mgmt) |
| LINUX_FUNCVI(cfg80211_mgmt_tx_status) |
| LINUX_FUNCVI(cfg80211_check_combinations) |
| LINUX_FUNCVI(cfg80211_roamed) |
| LINUX_FUNCVI(cfg80211_connect_done) |
| LINUX_FUNCVV(cfg80211_ibss_joined) |
| LINUX_FUNCVV(cfg80211_michael_mic_failure) |
| LINUX_FUNCII(ieee80211_channel_to_frequency) |
| LINUX_FUNCVV(ieee80211_get_channel) |
| LINUX_FUNCII(ieee80211_is_mgmt) |
| LINUX_FUNCII(ieee80211_is_action) |
| LINUX_FUNCII(ieee80211_is_probe_resp) |
| LINUX_FUNCVS(wiphy_register) |
| LINUX_FUNCVI(netif_rx) |
| LINUX_FUNCVI(netif_rx_ni) |
| LINUX_FUNCVI(netif_carrier_off) |
| |
| LINUX_FUNCVI(seq_printf) |
| LINUX_FUNCVS(seq_write) |
| LINUX_FUNCVI(seq_puts) |
| LINUX_FUNCVI(dev_coredumpv) |
| // I can't find this defined (or even declared) anywhere in the Linux codebase. |
| //LINUX_FUNCVI(trace_brcmf_bcdchdr) |
| |
| #define pci_write_config_dword(pdev, offset, value) \ |
| pci_config_write32(&pdev->pci_proto, offset, value) |
| #define pci_read_config_dword(pdev, offset, value) \ |
| pci_config_read32(&pdev->pci_proto, offset, value) |
| LINUX_FUNCcVI(pci_enable_msi) |
| LINUX_FUNCcVI(pci_disable_msi) |
| LINUX_FUNCII(free_irq) // PCI |
| LINUX_FUNCII(request_threaded_irq) // PCI only |
| LINUX_FUNCVV(dma_alloc_coherent) // PCI only |
| LINUX_FUNCVV(dma_free_coherent) // PCI only |
| LINUX_FUNCVI(memcpy_fromio) // PCI only |
| LINUX_FUNCVS(memcpy_toio) // PCI only |
| LINUX_FUNCVV(dma_zalloc_coherent) // PCI only |
| LINUX_FUNCVI(dma_map_single) // PCI only |
| LINUX_FUNCVI(dma_mapping_error) // PCI only |
| LINUX_FUNCVI(dma_unmap_single) // PCI only |
| |
| #define netdev_for_each_mc_addr(a, b) for (({brcmf_err("Calling netdev_for_each_mc_addr"); \ |
| a = (void*)0;});1;) |
| #define for_each_set_bit(a, b, c) for (({brcmf_err("Calling for_each_set_bit"); a = 0;});1;) |
| |
| #define DEBUG // Turns on struct members that debug.c needs |
| #define CONFIG_OF // Turns on functions that of.c needs |
| #define CONFIG_BRCMFMAC_PROTO_MSGBUF // turns on msgbuf.h |
| #define CONFIG_BRCMFMAC_PROTO_BCDC // Needed to see func defs in bcdc.h |
| |
| #define KBUILD_MODNAME "brcmfmac" |
| #define BRCMFMAC_PDATA_NAME ("pdata name") |
| |
| #define IEEE80211_MAX_SSID_LEN (32) |
| |
| enum { |
| IEEE80211_P2P_ATTR_DEVICE_INFO = 2, |
| IEEE80211_P2P_ATTR_DEVICE_ID = 3, |
| IEEE80211_STYPE_ACTION = 0, |
| IEEE80211_FCTL_STYPE = 0, |
| IEEE80211_P2P_ATTR_GROUP_ID = 0, |
| IEEE80211_STYPE_PROBE_REQ = 0, |
| IEEE80211_P2P_ATTR_LISTEN_CHANNEL = (57), |
| IFNAMSIZ = (16), |
| WLAN_PMKID_LEN = (16), |
| WLAN_MAX_KEY_LEN = (32), |
| IRQF_SHARED, // TODO(cphoenix) - Used only in PCI |
| IEEE80211_RATE_SHORT_PREAMBLE, |
| WLAN_EID_VENDOR_SPECIFIC, |
| WIPHY_PARAM_RETRY_SHORT, |
| WIPHY_PARAM_RTS_THRESHOLD, |
| WIPHY_PARAM_FRAG_THRESHOLD, |
| WIPHY_PARAM_RETRY_LONG, |
| WLAN_REASON_DEAUTH_LEAVING, |
| WLAN_REASON_UNSPECIFIED, |
| NL80211_WPA_VERSION_1, |
| NL80211_WPA_VERSION_2, |
| NL80211_AUTHTYPE_OPEN_SYSTEM, |
| NL80211_AUTHTYPE_SHARED_KEY, |
| WLAN_EID_TIM, |
| WLAN_EID_COUNTRY, |
| WLAN_EID_SSID, |
| NL80211_AUTHTYPE_AUTOMATIC, |
| WLAN_AKM_SUITE_PSK, |
| WLAN_AKM_SUITE_8021X, |
| WLAN_AKM_SUITE_8021X_SHA256, |
| WLAN_AKM_SUITE_PSK_SHA256, |
| NL80211_BSS_SELECT_ATTR_BAND_PREF = 0, |
| __NL80211_BSS_SELECT_ATTR_INVALID, |
| NL80211_BSS_SELECT_ATTR_RSSI_ADJUST, |
| NL80211_BSS_SELECT_ATTR_RSSI, |
| NL80211_STA_INFO_STA_FLAGS, |
| NL80211_STA_FLAG_WME = 0, |
| NL80211_STA_FLAG_ASSOCIATED, |
| NL80211_STA_FLAG_AUTHENTICATED, |
| NL80211_STA_FLAG_AUTHORIZED, |
| NL80211_STA_INFO_BSS_PARAM, |
| NL80211_STA_INFO_CONNECTED_TIME, |
| NL80211_STA_INFO_RX_BITRATE, |
| NL80211_STA_INFO_TX_BYTES, |
| NL80211_STA_INFO_RX_BYTES, |
| NL80211_STA_INFO_CHAIN_SIGNAL, |
| IEEE80211_HT_STBC_PARAM_DUAL_CTS_PROT, |
| BSS_PARAM_FLAGS_CTS_PROT, |
| BSS_PARAM_FLAGS_SHORT_PREAMBLE, |
| WLAN_CAPABILITY_SHORT_SLOT_TIME, |
| BSS_PARAM_FLAGS_SHORT_SLOT_TIME, |
| IEEE80211_CHAN_RADAR, |
| IEEE80211_CHAN_NO_IR, |
| IEEE80211_CHAN_NO_HT40, |
| IEEE80211_CHAN_NO_HT40PLUS, |
| IEEE80211_CHAN_DISABLED, |
| IEEE80211_CHAN_NO_HT40MINUS, |
| IEEE80211_CHAN_NO_80MHZ, |
| NL80211_STA_INFO_TX_BITRATE, |
| NL80211_STA_INFO_SIGNAL, |
| NL80211_STA_INFO_TX_PACKETS, |
| NL80211_STA_INFO_RX_DROP_MISC, |
| NL80211_STA_INFO_TX_FAILED, |
| NL80211_STA_INFO_RX_PACKETS, |
| WLAN_CAPABILITY_SHORT_PREAMBLE, |
| NL80211_STA_FLAG_TDLS_PEER, |
| NL80211_STA_INFO_INACTIVE_TIME, |
| CFG80211_BSS_FTYPE_UNKNOWN, |
| WLAN_CAPABILITY_IBSS, |
| UPDATE_ASSOC_IES, |
| IEEE80211_HT_CAP_SGI_40, |
| IEEE80211_HT_CAP_SUP_WIDTH_20_40, |
| IEEE80211_HT_CAP_DSSSCCK40, |
| IEEE80211_HT_MAX_AMPDU_64K, |
| IEEE80211_HT_MPDU_DENSITY_16, |
| IEEE80211_HT_MCS_TX_DEFINED, |
| IEEE80211_HT_CAP_SGI_20, |
| IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ, |
| IEEE80211_VHT_CAP_SHORT_GI_160, |
| IEEE80211_VHT_MCS_SUPPORT_0_9, |
| IEEE80211_VHT_CAP_SHORT_GI_80, |
| IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE, |
| IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE, |
| IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT = 0, |
| IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT, |
| IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE, |
| IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE, |
| IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB, |
| IEEE80211_STYPE_ASSOC_REQ, |
| IEEE80211_STYPE_REASSOC_REQ, |
| IEEE80211_STYPE_DISASSOC, |
| IEEE80211_STYPE_AUTH, |
| IEEE80211_STYPE_DEAUTH, |
| CFG80211_SIGNAL_TYPE_MBM, |
| WIPHY_FLAG_PS_ON_BY_DEFAULT, |
| WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL, |
| WIPHY_FLAG_SUPPORTS_TDLS, |
| WIPHY_FLAG_SUPPORTS_FW_ROAM, |
| WIPHY_FLAG_NETNS_OK, |
| WIPHY_FLAG_OFFCHAN_TX, |
| REGULATORY_CUSTOM_REG, |
| NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR, |
| IFF_ALLMULTI = 0, |
| NET_NETBUF_PAD, |
| IFF_PROMISC, |
| NETDEV_TX_OK, |
| NETIF_F_IP_CSUM, |
| CHECKSUM_PARTIAL, |
| CHECKSUM_UNNECESSARY, |
| BRCMF_H2D_TXFLOWRING_MAX_ITEM, |
| BRCMF_H2D_TXFLOWRING_ITEMSIZE, |
| NL80211_SCAN_FLAG_RANDOM_ADDR, |
| WLAN_AUTH_OPEN, |
| WIPHY_VENDOR_CMD_NEED_WDEV, |
| WIPHY_VENDOR_CMD_NEED_NETDEV, |
| BRCMF_SCAN_IE_LEN_MAX, |
| }; |
| |
| typedef enum { IRQ_WAKE_THREAD, IRQ_NONE, IRQ_HANDLED } irqreturn_t; |
| |
| enum ieee80211_vht_mcs_support { FOOVMS }; |
| |
| enum dma_data_direction { |
| DMA_TO_DEVICE, |
| DMA_FROM_DEVICE, |
| }; |
| |
| enum nl80211_tx_power_setting { |
| NL80211_TX_POWER_AUTOMATIC, |
| NL80211_TX_POWER_LIMITED, |
| NL80211_TX_POWER_FIXED, |
| |
| }; |
| |
| enum nl80211_key_type { |
| NL80211_KEYTYPE_GROUP, |
| NL80211_KEYTYPE_PAIRWISE, |
| }; |
| |
| enum nl80211_auth_type { FOONLAT }; |
| |
| enum nl80211_crit_proto_id { |
| NL80211_CRIT_PROTO_DHCP, |
| }; |
| |
| enum nl80211_tdls_operation { |
| NL80211_TDLS_DISCOVERY_REQ, |
| NL80211_TDLS_SETUP, |
| NL80211_TDLS_TEARDOWN, |
| }; |
| |
| enum nl80211_band { |
| NL80211_BAND_2GHZ, |
| NL80211_BAND_5GHZ, |
| NL80211_BAND_60GHZ, |
| }; |
| #define NL80211_BAND_COUNT (NL80211_BAND_60GHZ + 1) |
| |
| enum brcmf_bus_type { BRCMF_BUSTYPE_SDIO, BRCMF_BUSTYPE_USB, BRCMF_BUSTYPE_PCIE }; |
| |
| #define TP_PROTO(args...) args |
| #define MODULE_FIRMWARE(a) |
| #define MODULE_AUTHOR(a) |
| #define MODULE_DESCRIPTION(a) |
| #define MODULE_LICENSE(a) |
| #define module_param_named(a, b, c, d) |
| #define MODULE_PARM_DESC(a, b) |
| #define MODULE_SUPPORTED_DEVICE(a) |
| |
| #define __iomem // May want it later |
| #define IS_ENABLED(a) (a) // not in compiler.h |
| #define HZ (60) |
| |
| struct brcmfmac_pd_cc_entry { |
| uint8_t* iso3166; |
| uint32_t rev; |
| uint8_t* cc; |
| }; |
| |
| struct brcmfmac_pd_cc { |
| int table_size; |
| struct brcmfmac_pd_cc_entry* table; |
| }; |
| |
| struct net_device_ops { // Probably all return zx_status_t |
| void* ndo_open; |
| void* ndo_stop; |
| void* ndo_start_xmit; |
| void* ndo_set_mac_address; |
| void* ndo_set_rx_mode; |
| }; |
| |
| struct ethtool_ops { |
| void* get_drvinfo; |
| }; |
| |
| struct ieee80211_channel { |
| int hw_value; |
| uint32_t flags; |
| int center_freq; |
| int max_antenna_gain; |
| int max_power; |
| int band; |
| uint32_t orig_flags; |
| }; |
| |
| struct ieee80211_rate { |
| int bitrate; |
| uint32_t flags; |
| uint32_t hw_value; |
| }; |
| |
| struct ieee80211_supported_band { |
| int band; |
| struct ieee80211_rate* bitrates; |
| int n_bitrates; |
| struct ieee80211_channel* channels; |
| uint32_t n_channels; |
| struct { |
| int ht_supported; |
| uint16_t cap; |
| int ampdu_factor; |
| int ampdu_density; |
| struct { |
| uint8_t rx_mask[32]; // At most 32 bytes are set; it's never read in this driver. |
| uint32_t tx_params; |
| } mcs; |
| } ht_cap; |
| struct { |
| int vht_supported; |
| uint32_t cap; |
| struct { |
| uint16_t rx_mcs_map; |
| uint16_t tx_mcs_map; |
| } vht_mcs; |
| } vht_cap; |
| }; |
| |
| struct mac_address { |
| uint8_t addr[ETH_ALEN]; |
| }; |
| |
| struct regulatory_request { |
| char alpha2[44]; |
| int initiator; |
| }; |
| |
| struct wiphy { |
| int max_sched_scan_reqs; |
| int max_sched_scan_plan_interval; |
| int max_sched_scan_ie_len; |
| int max_match_sets; |
| int max_sched_scan_ssids; |
| uint32_t rts_threshold; |
| uint32_t frag_threshold; |
| uint32_t retry_long; |
| uint32_t retry_short; |
| uint32_t interface_modes; |
| struct ieee80211_supported_band* bands[NL80211_BAND_COUNT]; |
| int n_iface_combinations; |
| struct ieee80211_iface_combination* iface_combinations; |
| uint32_t max_scan_ssids; |
| uint32_t max_scan_ie_len; |
| uint32_t max_num_pmkids; |
| struct mac_address* addresses; |
| uint32_t n_addresses; |
| uint32_t signal_type; |
| const uint32_t* cipher_suites; |
| uint32_t n_cipher_suites; |
| uint32_t bss_select_support; |
| uint32_t flags; |
| const struct ieee80211_txrx_stypes* mgmt_stypes; |
| uint32_t max_remain_on_channel_duration; |
| uint32_t n_vendor_commands; |
| const struct wiphy_vendor_command* vendor_commands; |
| uint8_t perm_addr[ETH_ALEN]; |
| void (*reg_notifier)(struct wiphy*, struct regulatory_request*); |
| uint32_t regulatory_flags; |
| uint32_t features; |
| struct brcmf_cfg80211_info* cfg80211_info; |
| struct cfg80211_ops* ops; |
| struct brcmf_device* dev; |
| }; |
| |
| struct vif_params { |
| uint8_t macaddr[ETH_ALEN]; |
| }; |
| |
| struct wireless_dev { |
| struct net_device* netdev; |
| uint16_t iftype; |
| uint8_t address[ETH_ALEN]; |
| struct wiphy* wiphy; |
| struct brcmf_cfg80211_info* cfg80211_info; |
| }; |
| |
| // This stubs the use of struct sdio_func, which we only use for locking. |
| |
| struct sdio_func { |
| pthread_mutex_t lock; |
| }; |
| |
| void sdio_claim_host(struct sdio_func* func); |
| void sdio_release_host(struct sdio_func* func); |
| |
| struct cfg80211_ssid { |
| size_t ssid_len; |
| char* ssid; |
| }; |
| |
| struct ieee80211_mgmt { |
| int u; |
| uint8_t bssid[ETH_ALEN]; |
| uint8_t da[ETH_ALEN]; |
| uint8_t sa[ETH_ALEN]; |
| uint16_t frame_control; |
| }; |
| |
| struct notifier_block { |
| int foo; |
| }; |
| |
| struct in6_addr { |
| int foo; |
| }; |
| |
| struct seq_file { |
| void* private_data; |
| }; |
| |
| typedef uint64_t dma_addr_t; |
| |
| struct pci_device_id { |
| int a, b, c, d, e, f, g; |
| }; |
| |
| struct ieee80211_regdomain { |
| int n_reg_rules; |
| char* alpha2; |
| struct { |
| struct { |
| int start_freq_khz; |
| int end_freq_khz; |
| int max_bandwidth_khz; |
| } freq_range; |
| struct { |
| int max_antenna_gain; |
| int max_eirp; |
| } power_rule; |
| uint32_t flags; |
| uint32_t dfs_cac_ms; |
| } reg_rules[]; |
| }; |
| #define REG_RULE(...) \ |
| { .flags = 0 } // Fill up reg_rules |
| |
| struct cfg80211_match_set { |
| struct cfg80211_ssid ssid; |
| uint8_t bssid[ETH_ALEN]; |
| }; |
| |
| struct cfg80211_sched_scan_request { |
| int n_ssids; |
| int n_match_sets; |
| uint64_t reqid; |
| int flags; |
| uint8_t mac_addr[ETH_ALEN]; |
| struct cfg80211_ssid* ssids; |
| int n_channels; |
| struct ieee80211_channel* channels[555]; |
| struct { |
| int interval; |
| } * scan_plans; |
| uint8_t mac_addr_mask[ETH_ALEN]; |
| struct cfg80211_match_set match_sets[123]; |
| }; |
| |
| struct wiphy_vendor_command { |
| struct { |
| int vendor_id; |
| int subcmd; |
| } unknown_name; |
| uint32_t flags; |
| zx_status_t (*doit)(struct wiphy* wiphy, struct wireless_dev* wdev, const void* data, int len); |
| }; |
| |
| struct cfg80211_chan_def { |
| struct ieee80211_channel* chan; |
| int center_freq1; |
| int center_freq2; |
| int width; |
| }; |
| |
| struct iface_combination_params { |
| int num_different_channels; |
| int iftype_num[555]; |
| }; |
| |
| struct cfg80211_ibss_params { |
| char* ssid; |
| int privacy; |
| int beacon_interval; |
| int ssid_len; |
| uint8_t* bssid; |
| int channel_fixed; |
| struct cfg80211_chan_def chandef; |
| uint8_t* ie; |
| int ie_len; |
| int basic_rates; |
| }; |
| |
| struct key_params { |
| uint32_t key_len; |
| int cipher; |
| void* key; |
| }; |
| |
| struct nl80211_sta_flag_update { |
| int mask; |
| int set; |
| }; |
| |
| struct station_info { |
| unsigned long filled; |
| struct nl80211_sta_flag_update sta_flags; |
| struct { |
| uint32_t flags; |
| uint32_t dtim_period; |
| uint32_t beacon_interval; |
| } bss_param; |
| struct { |
| uint32_t legacy; |
| } txrate; |
| struct { |
| uint32_t legacy; |
| } rxrate; |
| uint32_t signal; |
| uint32_t rx_packets; |
| uint32_t rx_dropped_misc; |
| uint32_t tx_packets; |
| uint32_t tx_failed; |
| uint32_t inactive_time; |
| uint32_t connected_time; |
| uint32_t tx_bytes; |
| uint32_t rx_bytes; |
| uint32_t chain_signal_avg[555]; |
| uint32_t chain_signal[555]; |
| uint32_t chains; |
| void* assoc_req_ies; |
| uint32_t assoc_req_ies_len; |
| uint32_t generation; |
| }; |
| |
| struct cfg80211_wowlan { |
| int disconnect; |
| struct { |
| uint8_t* pattern; |
| uint32_t pattern_len; |
| uint8_t* mask; |
| uint32_t pkt_offset; |
| } * patterns; |
| uint32_t n_patterns; |
| int magic_pkt; |
| void* nd_config; |
| int gtk_rekey_failure; |
| }; |
| |
| struct cfg80211_wowlan_nd_match { |
| struct { |
| void* ssid; |
| uint32_t ssid_len; |
| } ssid; |
| int n_channels; |
| int* channels; |
| }; |
| |
| struct cfg80211_wowlan_nd_info { |
| int n_matches; |
| struct cfg80211_wowlan_nd_match* matches[555]; |
| int disconnect; |
| int* patterns; |
| int n_patterns; |
| }; |
| |
| struct cfg80211_pmksa { |
| uint8_t bssid[ETH_ALEN]; |
| uint8_t* pmkid; |
| }; |
| |
| struct cfg80211_beacon_data { |
| void* tail; |
| int tail_len; |
| void* head; |
| int head_len; |
| void* proberesp_ies; |
| int proberesp_ies_len; |
| }; |
| |
| struct cfg80211_ap_settings { |
| wlan_channel_t* chan; |
| int beacon_interval; |
| int dtim_period; |
| void* ssid; |
| size_t ssid_len; |
| int auth_type; |
| int inactivity_timeout; |
| struct cfg80211_beacon_data beacon; |
| int hidden_ssid; |
| }; |
| |
| struct station_del_parameters { |
| uint8_t* mac; |
| int reason_code; |
| }; |
| |
| struct station_parameters { |
| uint32_t sta_flags_mask; |
| uint32_t sta_flags_set; |
| }; |
| |
| struct cfg80211_mgmt_tx_params { |
| struct ieee80211_channel* chan; |
| uint8_t* buf; |
| size_t len; |
| }; |
| |
| struct cfg80211_pmk_conf { |
| void* pmk; |
| int pmk_len; |
| }; |
| |
| struct cfg80211_ops { // Most of these return zx_status_t |
| void* add_virtual_intf; |
| void* del_virtual_intf; |
| void* change_virtual_intf; |
| void* scan; |
| void* set_wiphy_params; |
| void* get_station; |
| void* dump_station; |
| void* set_tx_power; |
| void* get_tx_power; |
| void* add_key; |
| void* del_key; |
| void* get_key; |
| void* set_default_key; |
| void* set_default_mgmt_key; |
| void* set_power_mgmt; |
| void* connect; |
| void* disconnect; |
| void* suspend; |
| void* resume; |
| void* set_pmksa; |
| void* del_pmksa; |
| void* flush_pmksa; |
| void* start_ap; |
| void* stop_ap; |
| void* change_beacon; |
| void* del_station; |
| void* change_station; |
| void* sched_scan_start; |
| void* sched_scan_stop; |
| void* mgmt_frame_register; |
| void* mgmt_tx; |
| void* remain_on_channel; |
| void* cancel_remain_on_channel; |
| void* start_p2p_device; |
| void* stop_p2p_device; |
| void* crit_proto_start; |
| void* crit_proto_stop; |
| void* tdls_oper; |
| void* update_connect_params; |
| void* set_pmk; |
| void* del_pmk; |
| }; |
| |
| struct cfg80211_roam_info { |
| struct ieee80211_channel* channel; |
| uint8_t* bssid; |
| void* req_ie; |
| int req_ie_len; |
| void* resp_ie; |
| int resp_ie_len; |
| }; |
| |
| struct ieee80211_iface_combination { |
| int num_different_channels; |
| struct ieee80211_iface_limit* limits; |
| int max_interfaces; |
| int beacon_int_infra_match; |
| int n_limits; |
| }; |
| |
| struct ieee80211_txrx_stypes { |
| uint32_t tx; |
| uint32_t rx; |
| }; |
| |
| struct ieee80211_iface_limit { |
| int max; |
| int types; |
| }; |
| |
| struct netdev_hw_addr { |
| uint8_t addr[ETH_ALEN]; |
| }; |
| |
| struct ethtool_drvinfo { |
| void* driver; |
| void* version; |
| void* fw_version; |
| void* bus_info; |
| }; |
| |
| struct va_format { |
| va_list* va; |
| const char* fmt; |
| }; |
| |
| #endif // GARNET_DRIVERS_WLAN_THIRD_PARTY_BROADCOM_BRCMFMAC_LINUXISMS_H_ |