diff options
Diffstat (limited to 'drivers/staging/brcm80211/brcmfmac/dhd.h')
| -rw-r--r-- | drivers/staging/brcm80211/brcmfmac/dhd.h | 468 |
1 files changed, 468 insertions, 0 deletions
diff --git a/drivers/staging/brcm80211/brcmfmac/dhd.h b/drivers/staging/brcm80211/brcmfmac/dhd.h new file mode 100644 index 0000000..57d06b2 --- /dev/null +++ b/drivers/staging/brcm80211/brcmfmac/dhd.h @@ -0,0 +1,468 @@ +/* + * Copyright (c) 2010 Broadcom Corporation + * + * 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. + */ + +/**************** + * Common types * + */ + +#ifndef _dhd_h_ +#define _dhd_h_ + +#include <linux/sched.h> +#include <linux/init.h> +#include <linux/kernel.h> +#include <linux/slab.h> +#include <linux/skbuff.h> +#include <linux/netdevice.h> +#include <linux/etherdevice.h> +#include <linux/random.h> +#include <linux/spinlock.h> +#include <linux/ethtool.h> +#include <asm/uaccess.h> +#include <asm/unaligned.h> +#if defined(CONFIG_HAS_WAKELOCK) +#include <linux/wakelock.h> +#endif /* defined (CONFIG_HAS_WAKELOCK) */ +/* The kernel threading is sdio-specific */ + +#include <wlioctl.h> + +/* Forward decls */ +struct dhd_bus; +struct dhd_prot; +struct dhd_info; + +/* The level of bus communication with the dongle */ +enum dhd_bus_state { + DHD_BUS_DOWN, /* Not ready for frame transfers */ + DHD_BUS_LOAD, /* Download access only (CPU reset) */ + DHD_BUS_DATA /* Ready for frame transfers */ +}; + +enum dhd_bus_wake_state { + WAKE_LOCK_OFF, + WAKE_LOCK_PRIV, + WAKE_LOCK_DPC, + WAKE_LOCK_IOCTL, + WAKE_LOCK_DOWNLOAD, + WAKE_LOCK_TMOUT, + WAKE_LOCK_WATCHDOG, + WAKE_LOCK_LINK_DOWN_TMOUT, + WAKE_LOCK_PNO_FIND_TMOUT, + WAKE_LOCK_SOFTAP_SET, + WAKE_LOCK_SOFTAP_STOP, + WAKE_LOCK_SOFTAP_START, + WAKE_LOCK_MAX +}; +enum dhd_prealloc_index { + DHD_PREALLOC_PROT = 0, + DHD_PREALLOC_RXBUF, + DHD_PREALLOC_DATABUF, + DHD_PREALLOC_OSL_BUF +}; + +/* Common structure for module and instance linkage */ +typedef struct dhd_pub { + /* Linkage ponters */ + osl_t *osh; /* OSL handle */ + struct dhd_bus *bus; /* Bus module handle */ + struct dhd_prot *prot; /* Protocol module handle */ + struct dhd_info *info; /* Info module handle */ + + /* Internal dhd items */ + bool up; /* Driver up/down (to OS) */ + bool txoff; /* Transmit flow-controlled */ + bool dongle_reset; /* true = DEVRESET put dongle into reset */ + enum dhd_bus_state busstate; + uint hdrlen; /* Total DHD header length (proto + bus) */ + uint maxctl; /* Max size rxctl request from proto to bus */ + uint rxsz; /* Rx buffer size bus module should use */ + u8 wme_dp; /* wme discard priority */ + + /* Dongle media info */ + bool iswl; /* Dongle-resident driver is wl */ + unsigned long drv_version; /* Version of dongle-resident driver */ + struct ether_addr mac; /* MAC address obtained from dongle */ + dngl_stats_t dstats; /* Stats for dongle-based data */ + + /* Additional stats for the bus level */ + unsigned long tx_packets; /* Data packets sent to dongle */ + unsigned long tx_multicast; /* Multicast data packets sent to dongle */ + unsigned long tx_errors; /* Errors in sending data to dongle */ + unsigned long tx_ctlpkts; /* Control packets sent to dongle */ + unsigned long tx_ctlerrs; /* Errors sending control frames to dongle */ + unsigned long rx_packets; /* Packets sent up the network interface */ + unsigned long rx_multicast; /* Multicast packets sent up the network + interface */ + unsigned long rx_errors; /* Errors processing rx data packets */ + unsigned long rx_ctlpkts; /* Control frames processed from dongle */ + unsigned long rx_ctlerrs; /* Errors in processing rx control frames */ + unsigned long rx_dropped; /* Packets dropped locally (no memory) */ + unsigned long rx_flushed; /* Packets flushed due to + unscheduled sendup thread */ + unsigned long wd_dpc_sched; /* Number of times dhd dpc scheduled by + watchdog timer */ + + unsigned long rx_readahead_cnt; /* Number of packets where header read-ahead + was used. */ + unsigned long tx_realloc; /* Number of tx packets we had to realloc for + headroom */ + unsigned long fc_packets; /* Number of flow control pkts recvd */ + + /* Last error return */ + int bcmerror; + uint tickcnt; + + /* Last error from dongle */ + int dongle_error; + + /* Suspend disable flag flag */ + int suspend_disable_flag; /* "1" to disable all extra powersaving + during suspend */ + int in_suspend; /* flag set to 1 when early suspend called */ +#ifdef PNO_SUPPORT + int pno_enable; /* pno status : "1" is pno enable */ +#endif /* PNO_SUPPORT */ + int dtim_skip; /* dtim skip , default 0 means wake each dtim */ + + /* Pkt filter defination */ + char *pktfilter[100]; + int pktfilter_count; + + u8 country_code[WLC_CNTRY_BUF_SZ]; + char eventmask[WL_EVENTING_MASK_LEN]; + +#if defined(CONFIG_HAS_WAKELOCK) + struct wake_lock wakelock[WAKE_LOCK_MAX]; +#endif /* defined (CONFIG_HAS_WAKELOCK) */ +} dhd_pub_t; + +#if defined(CONFIG_PM_SLEEP) + +#define DHD_PM_RESUME_WAIT_INIT(a) DECLARE_WAIT_QUEUE_HEAD(a); +#define _DHD_PM_RESUME_WAIT(a, b) do {\ + int retry = 0; \ + while (dhd_mmc_suspend && retry++ != b) { \ + wait_event_timeout(a, false, HZ/100); \ + } \ + } while (0) +#define DHD_PM_RESUME_WAIT(a) _DHD_PM_RESUME_WAIT(a, 30) +#define DHD_PM_RESUME_WAIT_FOREVER(a) _DHD_PM_RESUME_WAIT(a, ~0) +#define DHD_PM_RESUME_RETURN_ERROR(a) \ + do { if (dhd_mmc_suspend) return a; } while (0) +#define DHD_PM_RESUME_RETURN do { if (dhd_mmc_suspend) return; } while (0) + +#define DHD_SPINWAIT_SLEEP_INIT(a) DECLARE_WAIT_QUEUE_HEAD(a); +#define SPINWAIT_SLEEP(a, exp, us) do { \ + uint countdown = (us) + 9999; \ + while ((exp) && (countdown >= 10000)) { \ + wait_event_timeout(a, false, HZ/100); \ + countdown -= 10000; \ + } \ + } while (0) + +#else + +#define DHD_PM_RESUME_WAIT_INIT(a) +#define DHD_PM_RESUME_WAIT(a) +#define DHD_PM_RESUME_WAIT_FOREVER(a) +#define DHD_PM_RESUME_RETURN_ERROR(a) +#define DHD_PM_RESUME_RETURN + +#define DHD_SPINWAIT_SLEEP_INIT(a) +#define SPINWAIT_SLEEP(a, exp, us) do { \ + uint countdown = (us) + 9; \ + while ((exp) && (countdown >= 10)) { \ + udelay(10); \ + countdown -= 10; \ + } \ + } while (0) + +#endif /* defined(CONFIG_PM_SLEEP) */ +#define DHD_IF_VIF 0x01 /* Virtual IF (Hidden from user) */ + +static inline void MUTEX_LOCK_INIT(dhd_pub_t *dhdp) +{ +} + +static inline void MUTEX_LOCK(dhd_pub_t *dhdp) +{ +} + +static inline void MUTEX_UNLOCK(dhd_pub_t *dhdp) +{ +} + +static inline void MUTEX_LOCK_SOFTAP_SET_INIT(dhd_pub_t *dhdp) +{ +} + +static inline void MUTEX_LOCK_SOFTAP_SET(dhd_pub_t *dhdp) +{ +} + +static inline void MUTEX_UNLOCK_SOFTAP_SET(dhd_pub_t *dhdp) +{ +} + +static inline void MUTEX_LOCK_WL_SCAN_SET_INIT(void) +{ +} + +static inline void MUTEX_LOCK_WL_SCAN_SET(void) +{ +} + +static inline void MUTEX_UNLOCK_WL_SCAN_SET(void) +{ +} + +static inline void WAKE_LOCK_INIT(dhd_pub_t *dhdp, int index, char *y) +{ +#if defined(CONFIG_HAS_WAKELOCK) + wake_lock_init(&dhdp->wakelock[index], WAKE_LOCK_SUSPEND, y); +#endif /* defined (CONFIG_HAS_WAKELOCK) */ +} + +static inline void WAKE_LOCK(dhd_pub_t *dhdp, int index) +{ +#if defined(CONFIG_HAS_WAKELOCK) + wake_lock(&dhdp->wakelock[index]); +#endif /* defined (CONFIG_HAS_WAKELOCK) */ +} + +static inline void WAKE_UNLOCK(dhd_pub_t *dhdp, int index) +{ +#if defined(CONFIG_HAS_WAKELOCK) + wake_unlock(&dhdp->wakelock[index]); +#endif /* defined (CONFIG_HAS_WAKELOCK) */ +} + +static inline void WAKE_LOCK_TIMEOUT(dhd_pub_t *dhdp, int index, long time) +{ +#if defined(CONFIG_HAS_WAKELOCK) + wake_lock_timeout(&dhdp->wakelock[index], time); +#endif /* defined (CONFIG_HAS_WAKELOCK) */ +} + +static inline void WAKE_LOCK_DESTROY(dhd_pub_t *dhdp, int index) +{ +#if defined(CONFIG_HAS_WAKELOCK) + wake_lock_destroy(&dhdp->wakelock[index]); +#endif /* defined (CONFIG_HAS_WAKELOCK) */ +} + +typedef struct dhd_if_event { + u8 ifidx; + u8 action; + u8 flags; + u8 bssidx; +} dhd_if_event_t; + +/* + * Exported from dhd OS modules (dhd_linux/dhd_ndis) + */ + +/* To allow osl_attach/detach calls from os-independent modules */ +osl_t *dhd_osl_attach(void *pdev, uint bustype); +void dhd_osl_detach(osl_t *osh); + +/* Indication from bus module regarding presence/insertion of dongle. + * Return dhd_pub_t pointer, used as handle to OS module in later calls. + * Returned structure should have bus and prot pointers filled in. + * bus_hdrlen specifies required headroom for bus module header. + */ +extern dhd_pub_t *dhd_attach(osl_t *osh, struct dhd_bus *bus, uint bus_hdrlen); +extern int dhd_net_attach(dhd_pub_t *dhdp, int idx); + +/* Indication from bus module regarding removal/absence of dongle */ +extern void dhd_detach(dhd_pub_t *dhdp); + +/* Indication from bus module to change flow-control state */ +extern void dhd_txflowcontrol(dhd_pub_t *dhdp, int ifidx, bool on); + +extern bool dhd_prec_enq(dhd_pub_t *dhdp, struct pktq *q, void *pkt, int prec); + +/* Receive frame for delivery to OS. Callee disposes of rxp. */ +extern void dhd_rx_frame(dhd_pub_t *dhdp, int ifidx, void *rxp, int numpkt); + +/* Return pointer to interface name */ +extern char *dhd_ifname(dhd_pub_t *dhdp, int idx); + +/* Request scheduling of the bus dpc */ +extern void dhd_sched_dpc(dhd_pub_t *dhdp); + +/* Notify tx completion */ +extern void dhd_txcomplete(dhd_pub_t *dhdp, void *txp, bool success); + +/* Query ioctl */ +extern int dhdcdc_query_ioctl(dhd_pub_t *dhd, int ifidx, uint cmd, void *buf, + uint len); + +/* OS independent layer functions */ +extern int dhd_os_proto_block(dhd_pub_t *pub); +extern int dhd_os_proto_unblock(dhd_pub_t *pub); +extern int dhd_os_ioctl_resp_wait(dhd_pub_t *pub, uint *condition, + bool *pending); +extern int dhd_os_ioctl_resp_wake(dhd_pub_t *pub); +extern unsigned int dhd_os_get_ioctl_resp_timeout(void); +extern void dhd_os_set_ioctl_resp_timeout(unsigned int timeout_msec); +extern void *dhd_os_open_image(char *filename); +extern int dhd_os_get_image_block(char *buf, int len, void *image); +extern void dhd_os_close_image(void *image); +extern void dhd_os_wd_timer(void *bus, uint wdtick); +extern void dhd_os_sdlock(dhd_pub_t *pub); +extern void dhd_os_sdunlock(dhd_pub_t *pub); +extern void dhd_os_sdlock_txq(dhd_pub_t *pub); +extern void dhd_os_sdunlock_txq(dhd_pub_t *pub); +extern void dhd_os_sdlock_rxq(dhd_pub_t *pub); +extern void dhd_os_sdunlock_rxq(dhd_pub_t *pub); +extern void dhd_os_sdlock_sndup_rxq(dhd_pub_t *pub); +extern void dhd_customer_gpio_wlan_ctrl(int onoff); +extern int dhd_custom_get_mac_address(unsigned char *buf); +extern void dhd_os_sdunlock_sndup_rxq(dhd_pub_t *pub); +extern void dhd_os_sdlock_eventq(dhd_pub_t *pub); +extern void dhd_os_sdunlock_eventq(dhd_pub_t *pub); +#ifdef DHD_DEBUG +extern int write_to_file(dhd_pub_t *dhd, u8 *buf, int size); +#endif /* DHD_DEBUG */ +#if defined(OOB_INTR_ONLY) +extern int dhd_customer_oob_irq_map(unsigned long *irq_flags_ptr); +#endif /* defined(OOB_INTR_ONLY) */ +extern void dhd_os_sdtxlock(dhd_pub_t *pub); +extern void dhd_os_sdtxunlock(dhd_pub_t *pub); + +int setScheduler(struct task_struct *p, int policy, struct sched_param *param); + +typedef struct { + u32 limit; /* Expiration time (usec) */ + u32 increment; /* Current expiration increment (usec) */ + u32 elapsed; /* Current elapsed time (usec) */ + u32 tick; /* O/S tick time (usec) */ +} dhd_timeout_t; + +extern void dhd_timeout_start(dhd_timeout_t *tmo, uint usec); +extern int dhd_timeout_expired(dhd_timeout_t *tmo); + +extern int dhd_ifname2idx(struct dhd_info *dhd, char *name); +extern u8 *dhd_bssidx2bssid(dhd_pub_t *dhd, int idx); +extern int wl_host_event(struct dhd_info *dhd, int *idx, void *pktdata, + wl_event_msg_t *, void **data_ptr); +extern void wl_event_to_host_order(wl_event_msg_t *evt); + +extern void dhd_common_init(void); + +extern int dhd_add_if(struct dhd_info *dhd, int ifidx, void *handle, + char *name, u8 *mac_addr, u32 flags, u8 bssidx); +extern void dhd_del_if(struct dhd_info *dhd, int ifidx); + +extern void dhd_vif_add(struct dhd_info *dhd, int ifidx, char *name); +extern void dhd_vif_del(struct dhd_info *dhd, int ifidx); + +extern void dhd_event(struct dhd_info *dhd, char *evpkt, int evlen, int ifidx); +extern void dhd_vif_sendup(struct dhd_info *dhd, int ifidx, unsigned char * cp, + int len); + +/* Send packet to dongle via data channel */ +extern int dhd_sendpkt(dhd_pub_t *dhdp, int ifidx, void *pkt); + +/* Send event to host */ +extern void dhd_sendup_event(dhd_pub_t *dhdp, wl_event_msg_t *event, + void *data); +extern int dhd_bus_devreset(dhd_pub_t *dhdp, u8 flag); +extern uint dhd_bus_status(dhd_pub_t *dhdp); +extern int dhd_bus_start(dhd_pub_t *dhdp); + +extern void print_buf(void *pbuf, int len, int bytes_per_line); + +typedef enum cust_gpio_modes { + WLAN_RESET_ON, + WLAN_RESET_OFF, + WLAN_POWER_ON, + WLAN_POWER_OFF +} cust_gpio_modes_t; +/* + * Insmod parameters for debug/test + */ + +/* Watchdog timer interval */ +extern uint dhd_watchdog_ms; + +#if defined(DHD_DEBUG) +/* Console output poll interval */ +extern uint dhd_console_ms; +#endif /* defined(DHD_DEBUG) */ + +/* Use interrupts */ +extern uint dhd_intr; + +/* Use polling */ +extern uint dhd_poll; + +/* ARP offload agent mode */ +extern uint dhd_arp_mode; + +/* ARP offload enable */ +extern uint dhd_arp_enable; + +/* Pkt filte enable control */ +extern uint dhd_pkt_filter_enable; + +/* Pkt filter init setup */ +extern uint dhd_pkt_filter_init; + +/* Pkt filter mode control */ +extern uint dhd_master_mode; + +/* Roaming mode control */ +extern uint dhd_roam; + +/* Roaming mode control */ +extern uint dhd_radio_up; + +/* Initial idletime ticks (may be -1 for immediate idle, 0 for no idle) */ +extern int dhd_idletime; +#define DHD_IDLETIME_TICKS 1 + +/* SDIO Drive Strength */ +extern uint dhd_sdiod_drive_strength; + +/* Override to force tx queueing all the time */ +extern uint dhd_force_tx_queueing; + +#ifdef SDTEST +/* Echo packet generator (SDIO), pkts/s */ +extern uint dhd_pktgen; + +/* Echo packet len (0 => sawtooth, max 1800) */ +extern uint dhd_pktgen_len; +#define MAX_PKTGEN_LEN 1800 +#endif + +/* optionally set by a module_param_string() */ +#define MOD_PARAM_PATHLEN 2048 +extern char fw_path[MOD_PARAM_PATHLEN]; +extern char nv_path[MOD_PARAM_PATHLEN]; + +/* For supporting multiple interfaces */ +#define DHD_MAX_IFS 16 +#define DHD_DEL_IF -0xe +#define DHD_BAD_IF -0xf + +extern void dhd_wait_for_event(dhd_pub_t *dhd, bool * lockvar); +extern void dhd_wait_event_wakeup(dhd_pub_t *dhd); + +#endif /* _dhd_h_ */ |
