* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
-#include <typedefs.h>
-#include <linuxver.h>
+#include <linux/kernel.h>
+#include <linux/if_arp.h>
#include <osl.h>
#include <bcmutils.h>
#include <bcmendian.h>
#include <proto/ethernet.h>
-#include <linux/if_arp.h>
#include <asm/uaccess.h>
#include <dngl_stats.h>
#include <dhdioctl.h>
#include <wlioctl.h>
-#include <proto/ethernet.h>
-#include <dngl_stats.h>
-#include <dhd.h>
-
-#include <linux/kernel.h>
+#include <linux/kthread.h>
#include <linux/netdevice.h>
#include <linux/sched.h>
#include <linux/etherdevice.h>
static struct sdio_func *cfg80211_sdio_func;
static struct wl_dev *wl_cfg80211_dev;
-uint32 wl_dbg_level = WL_DBG_ERR | WL_DBG_INFO;
+u32 wl_dbg_level = WL_DBG_ERR | WL_DBG_INFO;
-#define WL_4329_FW_FILE "brcm/bcm4329-fullmac-4-218-248-5.bin"
-#define WL_4329_NVRAM_FILE "brcm/bcm4329-fullmac-4-218-248-5.txt"
+#define WL_4329_FW_FILE "brcm/bcm4329-fullmac-4.bin"
+#define WL_4329_NVRAM_FILE "brcm/bcm4329-fullmac-4.txt"
/*
** cfg80211_ops api/callback list
*/
-static int32 wl_cfg80211_change_iface(struct wiphy *wiphy,
+static s32 wl_cfg80211_change_iface(struct wiphy *wiphy,
struct net_device *ndev,
- enum nl80211_iftype type, uint32 *flags,
+ enum nl80211_iftype type, u32 *flags,
struct vif_params *params);
-static int32 __wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
+static s32 __wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
struct cfg80211_scan_request *request,
struct cfg80211_ssid *this_ssid);
-static int32 wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
+static s32 wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
struct cfg80211_scan_request *request);
-static int32 wl_cfg80211_set_wiphy_params(struct wiphy *wiphy, uint32 changed);
-static int32 wl_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
+static s32 wl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed);
+static s32 wl_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_ibss_params *params);
-static int32 wl_cfg80211_leave_ibss(struct wiphy *wiphy,
+static s32 wl_cfg80211_leave_ibss(struct wiphy *wiphy,
struct net_device *dev);
-static int32 wl_cfg80211_get_station(struct wiphy *wiphy,
+static s32 wl_cfg80211_get_station(struct wiphy *wiphy,
struct net_device *dev, u8 *mac,
struct station_info *sinfo);
-static int32 wl_cfg80211_set_power_mgmt(struct wiphy *wiphy,
+static s32 wl_cfg80211_set_power_mgmt(struct wiphy *wiphy,
struct net_device *dev, bool enabled,
- int32 timeout);
-static int32 wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
+ s32 timeout);
+static s32 wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
struct net_device *dev,
const u8 *addr,
const struct cfg80211_bitrate_mask
*mask);
static int wl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_connect_params *sme);
-static int32 wl_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
- uint16 reason_code);
-static int32 wl_cfg80211_set_tx_power(struct wiphy *wiphy,
+static s32 wl_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
+ u16 reason_code);
+static s32 wl_cfg80211_set_tx_power(struct wiphy *wiphy,
enum nl80211_tx_power_setting type,
- int32 dbm);
-static int32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, int32 *dbm);
-static int32 wl_cfg80211_config_default_key(struct wiphy *wiphy,
+ s32 dbm);
+static s32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm);
+static s32 wl_cfg80211_config_default_key(struct wiphy *wiphy,
struct net_device *dev,
u8 key_idx);
-static int32 wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
- u8 key_idx, const u8 *mac_addr,
+static s32 wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
+ u8 key_idx, bool pairwise, const u8 *mac_addr,
struct key_params *params);
-static int32 wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
- u8 key_idx, const u8 *mac_addr);
-static int32 wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
- u8 key_idx, const u8 *mac_addr,
+static s32 wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
+ u8 key_idx, bool pairwise, const u8 *mac_addr);
+static s32 wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
+ u8 key_idx, bool pairwise, const u8 *mac_addr,
void *cookie, void (*callback) (void *cookie,
struct
key_params *
params));
-static int32 wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
+static s32 wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
struct net_device *dev,
u8 key_idx);
-static int32 wl_cfg80211_resume(struct wiphy *wiphy);
-static int32 wl_cfg80211_suspend(struct wiphy *wiphy);
-static int32 wl_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
+static s32 wl_cfg80211_resume(struct wiphy *wiphy);
+static s32 wl_cfg80211_suspend(struct wiphy *wiphy);
+static s32 wl_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_pmksa *pmksa);
-static int32 wl_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
+static s32 wl_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_pmksa *pmksa);
-static int32 wl_cfg80211_flush_pmksa(struct wiphy *wiphy,
+static s32 wl_cfg80211_flush_pmksa(struct wiphy *wiphy,
struct net_device *dev);
/*
** event & event Q handlers for cfg80211 interfaces
*/
-static int32 wl_create_event_handler(struct wl_priv *wl);
+static s32 wl_create_event_handler(struct wl_priv *wl);
static void wl_destroy_event_handler(struct wl_priv *wl);
-static int32 wl_event_handler(void *data);
+static s32 wl_event_handler(void *data);
static void wl_init_eq(struct wl_priv *wl);
static void wl_flush_eq(struct wl_priv *wl);
static void wl_lock_eq(struct wl_priv *wl);
static void wl_init_eq_lock(struct wl_priv *wl);
static void wl_init_eloop_handler(struct wl_event_loop *el);
static struct wl_event_q *wl_deq_event(struct wl_priv *wl);
-static int32 wl_enq_event(struct wl_priv *wl, uint32 type,
+static s32 wl_enq_event(struct wl_priv *wl, u32 type,
const wl_event_msg_t *msg, void *data);
static void wl_put_event(struct wl_event_q *e);
static void wl_wakeup_event(struct wl_priv *wl);
-static int32 wl_notify_connect_status(struct wl_priv *wl,
+static s32 wl_notify_connect_status(struct wl_priv *wl,
struct net_device *ndev,
const wl_event_msg_t *e, void *data);
-static int32 wl_notify_roaming_status(struct wl_priv *wl,
+static s32 wl_notify_roaming_status(struct wl_priv *wl,
struct net_device *ndev,
const wl_event_msg_t *e, void *data);
-static int32 wl_notify_scan_status(struct wl_priv *wl, struct net_device *ndev,
+static s32 wl_notify_scan_status(struct wl_priv *wl, struct net_device *ndev,
const wl_event_msg_t *e, void *data);
-static int32 wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
- const wl_event_msg_t *e, void *data);
-static int32 wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
+static s32 wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
+ const wl_event_msg_t *e, void *data,
+ bool completed);
+static s32 wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
const wl_event_msg_t *e, void *data);
-static int32 wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
+static s32 wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
const wl_event_msg_t *e, void *data);
/*
/*
** ioctl utilites
*/
-static int32 wl_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
- int32 buf_len);
-static __used int32 wl_dev_bufvar_set(struct net_device *dev, s8 *name,
- s8 *buf, int32 len);
-static int32 wl_dev_intvar_set(struct net_device *dev, s8 *name, int32 val);
-static int32 wl_dev_intvar_get(struct net_device *dev, s8 *name,
- int32 *retval);
-static int32 wl_dev_ioctl(struct net_device *dev, uint32 cmd, void *arg,
- uint32 len);
+static s32 wl_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
+ s32 buf_len);
+static __used s32 wl_dev_bufvar_set(struct net_device *dev, s8 *name,
+ s8 *buf, s32 len);
+static s32 wl_dev_intvar_set(struct net_device *dev, s8 *name, s32 val);
+static s32 wl_dev_intvar_get(struct net_device *dev, s8 *name,
+ s32 *retval);
+static s32 wl_dev_ioctl(struct net_device *dev, u32 cmd, void *arg,
+ u32 len);
/*
** cfg80211 set_wiphy_params utilities
*/
-static int32 wl_set_frag(struct net_device *dev, uint32 frag_threshold);
-static int32 wl_set_rts(struct net_device *dev, uint32 frag_threshold);
-static int32 wl_set_retry(struct net_device *dev, uint32 retry, bool l);
+static s32 wl_set_frag(struct net_device *dev, u32 frag_threshold);
+static s32 wl_set_rts(struct net_device *dev, u32 frag_threshold);
+static s32 wl_set_retry(struct net_device *dev, u32 retry, bool l);
/*
** wl profile utilities
*/
-static int32 wl_update_prof(struct wl_priv *wl, const wl_event_msg_t *e,
- void *data, int32 item);
-static void *wl_read_prof(struct wl_priv *wl, int32 item);
+static s32 wl_update_prof(struct wl_priv *wl, const wl_event_msg_t *e,
+ void *data, s32 item);
+static void *wl_read_prof(struct wl_priv *wl, s32 item);
static void wl_init_prof(struct wl_profile *prof);
/*
** cfg80211 connect utilites
*/
-static int32 wl_set_wpa_version(struct net_device *dev,
+static s32 wl_set_wpa_version(struct net_device *dev,
struct cfg80211_connect_params *sme);
-static int32 wl_set_auth_type(struct net_device *dev,
+static s32 wl_set_auth_type(struct net_device *dev,
struct cfg80211_connect_params *sme);
-static int32 wl_set_set_cipher(struct net_device *dev,
+static s32 wl_set_set_cipher(struct net_device *dev,
struct cfg80211_connect_params *sme);
-static int32 wl_set_key_mgmt(struct net_device *dev,
+static s32 wl_set_key_mgmt(struct net_device *dev,
struct cfg80211_connect_params *sme);
-static int32 wl_set_set_sharedkey(struct net_device *dev,
+static s32 wl_set_set_sharedkey(struct net_device *dev,
struct cfg80211_connect_params *sme);
-static int32 wl_get_assoc_ies(struct wl_priv *wl);
+static s32 wl_get_assoc_ies(struct wl_priv *wl);
+static void wl_ch_to_chanspec(int ch,
+ struct wl_join_params *join_params, size_t *join_params_size);
/*
** information element utilities
*/
static void wl_rst_ie(struct wl_priv *wl);
-static int32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v);
-static int32 wl_mrg_ie(struct wl_priv *wl, u8 *ie_stream, uint16 ie_size);
-static int32 wl_cp_ie(struct wl_priv *wl, u8 *dst, uint16 dst_size);
-static uint32 wl_get_ielen(struct wl_priv *wl);
+static __used s32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v);
+static s32 wl_mrg_ie(struct wl_priv *wl, u8 *ie_stream, u16 ie_size);
+static s32 wl_cp_ie(struct wl_priv *wl, u8 *dst, u16 dst_size);
+static u32 wl_get_ielen(struct wl_priv *wl);
-static int32 wl_mode_to_nl80211_iftype(int32 mode);
+static s32 wl_mode_to_nl80211_iftype(s32 mode);
-static struct wireless_dev *wl_alloc_wdev(int32 sizeof_iface,
+static struct wireless_dev *wl_alloc_wdev(s32 sizeof_iface,
struct device *dev);
static void wl_free_wdev(struct wl_priv *wl);
-static int32 wl_inform_bss(struct wl_priv *wl);
-static int32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi);
-static int32 wl_update_bss_info(struct wl_priv *wl);
+static s32 wl_inform_bss(struct wl_priv *wl);
+static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi);
+static s32 wl_update_bss_info(struct wl_priv *wl);
-static int32 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
+static s32 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
u8 key_idx, const u8 *mac_addr,
struct key_params *params);
/*
** wl_priv memory init/deinit utilities
*/
-static int32 wl_init_priv_mem(struct wl_priv *wl);
+static s32 wl_init_priv_mem(struct wl_priv *wl);
static void wl_deinit_priv_mem(struct wl_priv *wl);
-static void wl_delay(uint32 ms);
+static void wl_delay(u32 ms);
/*
** store/restore cfg80211 instance data
*/
static bool wl_is_linkdown(struct wl_priv *wl, const wl_event_msg_t *e);
static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e);
+static bool wl_is_nonetwork(struct wl_priv *wl, const wl_event_msg_t *e);
static void wl_link_up(struct wl_priv *wl);
static void wl_link_down(struct wl_priv *wl);
-static int32 wl_dongle_mode(struct net_device *ndev, int32 iftype);
-static int32 __wl_cfg80211_up(struct wl_priv *wl);
-static int32 __wl_cfg80211_down(struct wl_priv *wl);
-static int32 wl_dongle_probecap(struct wl_priv *wl);
+static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype);
+static s32 __wl_cfg80211_up(struct wl_priv *wl);
+static s32 __wl_cfg80211_down(struct wl_priv *wl);
+static s32 wl_dongle_probecap(struct wl_priv *wl);
static void wl_init_conf(struct wl_conf *conf);
/*
** dongle configuration utilities
*/
#ifndef EMBEDDED_PLATFORM
-static int32 wl_dongle_mode(struct net_device *ndev, int32 iftype);
-static int32 wl_dongle_country(struct net_device *ndev, u8 ccode);
-static int32 wl_dongle_up(struct net_device *ndev, uint32 up);
-static int32 wl_dongle_power(struct net_device *ndev, uint32 power_mode);
-static int32 wl_dongle_glom(struct net_device *ndev, uint32 glom,
- uint32 dongle_align);
-static int32 wl_dongle_roam(struct net_device *ndev, uint32 roamvar,
- uint32 bcn_timeout);
-static int32 wl_dongle_eventmsg(struct net_device *ndev);
-static int32 wl_dongle_scantime(struct net_device *ndev, int32 scan_assoc_time,
- int32 scan_unassoc_time);
-static int32 wl_dongle_offload(struct net_device *ndev, int32 arpoe,
- int32 arp_ol);
-static int32 wl_pattern_atoh(s8 *src, s8 *dst);
-static int32 wl_dongle_filter(struct net_device *ndev, uint32 filter_mode);
-static int32 wl_update_wiphybands(struct wl_priv *wl);
+static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype);
+static s32 wl_dongle_country(struct net_device *ndev, u8 ccode);
+static s32 wl_dongle_up(struct net_device *ndev, u32 up);
+static s32 wl_dongle_power(struct net_device *ndev, u32 power_mode);
+static s32 wl_dongle_glom(struct net_device *ndev, u32 glom,
+ u32 dongle_align);
+static s32 wl_dongle_roam(struct net_device *ndev, u32 roamvar,
+ u32 bcn_timeout);
+static s32 wl_dongle_eventmsg(struct net_device *ndev);
+static s32 wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
+ s32 scan_unassoc_time);
+static s32 wl_dongle_offload(struct net_device *ndev, s32 arpoe,
+ s32 arp_ol);
+static s32 wl_pattern_atoh(s8 *src, s8 *dst);
+static s32 wl_dongle_filter(struct net_device *ndev, u32 filter_mode);
+static s32 wl_update_wiphybands(struct wl_priv *wl);
#endif /* !EMBEDDED_PLATFORM */
-static int32 wl_config_dongle(struct wl_priv *wl, bool need_lock);
+static s32 wl_config_dongle(struct wl_priv *wl, bool need_lock);
/*
** iscan handler
*/
static void wl_iscan_timer(unsigned long data);
static void wl_term_iscan(struct wl_priv *wl);
-static int32 wl_init_iscan(struct wl_priv *wl);
-static int32 wl_iscan_thread(void *data);
-static int32 wl_dev_iovar_setbuf(struct net_device *dev, s8 *iovar,
- void *param, int32 paramlen, void *bufptr,
- int32 buflen);
-static int32 wl_dev_iovar_getbuf(struct net_device *dev, s8 *iovar,
- void *param, int32 paramlen, void *bufptr,
- int32 buflen);
-static int32 wl_run_iscan(struct wl_iscan_ctrl *iscan, struct wlc_ssid *ssid,
- uint16 action);
-static int32 wl_do_iscan(struct wl_priv *wl);
-static int32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan);
-static int32 wl_invoke_iscan(struct wl_priv *wl);
-static int32 wl_get_iscan_results(struct wl_iscan_ctrl *iscan, uint32 *status,
+static s32 wl_init_iscan(struct wl_priv *wl);
+static s32 wl_iscan_thread(void *data);
+static s32 wl_dev_iovar_setbuf(struct net_device *dev, s8 *iovar,
+ void *param, s32 paramlen, void *bufptr,
+ s32 buflen);
+static s32 wl_dev_iovar_getbuf(struct net_device *dev, s8 *iovar,
+ void *param, s32 paramlen, void *bufptr,
+ s32 buflen);
+static s32 wl_run_iscan(struct wl_iscan_ctrl *iscan, struct wlc_ssid *ssid,
+ u16 action);
+static s32 wl_do_iscan(struct wl_priv *wl);
+static s32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan);
+static s32 wl_invoke_iscan(struct wl_priv *wl);
+static s32 wl_get_iscan_results(struct wl_iscan_ctrl *iscan, u32 *status,
struct wl_scan_results **bss_list);
static void wl_notify_iscan_complete(struct wl_iscan_ctrl *iscan, bool aborted);
static void wl_init_iscan_eloop(struct wl_iscan_eloop *el);
-static int32 wl_iscan_done(struct wl_priv *wl);
-static int32 wl_iscan_pending(struct wl_priv *wl);
-static int32 wl_iscan_inprogress(struct wl_priv *wl);
-static int32 wl_iscan_aborted(struct wl_priv *wl);
+static s32 wl_iscan_done(struct wl_priv *wl);
+static s32 wl_iscan_pending(struct wl_priv *wl);
+static s32 wl_iscan_inprogress(struct wl_priv *wl);
+static s32 wl_iscan_aborted(struct wl_priv *wl);
/*
** fw/nvram downloading handler
/*
* find most significant bit set
*/
-static __used uint32 wl_find_msb(uint16 bit16);
+static __used u32 wl_find_msb(u16 bit16);
/*
* update pmklist to dongle
*/
-static __used int32 wl_update_pmklist(struct net_device *dev,
- struct wl_pmk_list *pmk_list, int32 err);
+static __used s32 wl_update_pmklist(struct net_device *dev,
+ struct wl_pmk_list *pmk_list, s32 err);
+
+static void wl_set_mpc(struct net_device *ndev, int mpc);
+
+/*
+* debufs support
+*/
+static int wl_debugfs_add_netdev_params(struct wl_priv *wl);
+static void wl_debugfs_remove_netdev(struct wl_priv *wl);
#define WL_PRIV_GET() \
({ \
.n_bitrates = wl_a_rates_size,
};
-static const uint32 __wl_cipher_suites[] = {
+static const u32 __wl_cipher_suites[] = {
WLAN_CIPHER_SUITE_WEP40,
WLAN_CIPHER_SUITE_WEP104,
WLAN_CIPHER_SUITE_TKIP,
key->iv_initialized = dtoh32(key->iv_initialized);
}
-static int32
-wl_dev_ioctl(struct net_device *dev, uint32 cmd, void *arg, uint32 len)
+static s32
+wl_dev_ioctl(struct net_device *dev, u32 cmd, void *arg, u32 len)
{
struct ifreq ifr;
struct wl_ioctl ioc;
mm_segment_t fs;
- int32 err = 0;
+ s32 err = 0;
memset(&ioc, 0, sizeof(ioc));
ioc.cmd = cmd;
return err;
}
-static int32
+static s32
wl_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
- enum nl80211_iftype type, uint32 *flags,
+ enum nl80211_iftype type, u32 *flags,
struct vif_params *params)
{
struct wl_priv *wl = wiphy_to_wl(wiphy);
struct wireless_dev *wdev;
- int32 infra = 0;
- int32 ap = 0;
- int32 err = 0;
+ s32 infra = 0;
+ s32 ap = 0;
+ s32 err = 0;
CHECK_SYS_UP();
switch (type) {
wdev = ndev->ieee80211_ptr;
wdev->iftype = type;
WL_DBG(("%s : ap (%d), infra (%d)\n", ndev->name, ap, infra));
- if (unlikely
- ((err = wl_dev_ioctl(ndev, WLC_SET_INFRA, &infra, sizeof(infra))))
- ||
- unlikely((err = wl_dev_ioctl(ndev, WLC_SET_AP, &ap, sizeof(ap))))) {
- WL_ERR(("Error (%d)\n", err));
+ err = wl_dev_ioctl(ndev, WLC_SET_INFRA, &infra, sizeof(infra));
+ if (unlikely(err)) {
+ WL_ERR(("WLC_SET_INFRA error (%d)\n", err));
return err;
}
+ err = wl_dev_ioctl(ndev, WLC_SET_AP, &ap, sizeof(ap));
+ if (unlikely(err)) {
+ WL_ERR(("WLC_SET_AP error (%d)\n", err));
+ return err;
+ }
+
/* -EINPROGRESS: Call commit handler */
return -EINPROGRESS;
}
}
-static int32
+static s32
wl_dev_iovar_setbuf(struct net_device *dev, s8 * iovar, void *param,
- int32 paramlen, void *bufptr, int32 buflen)
+ s32 paramlen, void *bufptr, s32 buflen)
{
- int32 iolen;
+ s32 iolen;
iolen = bcm_mkiovar(iovar, param, paramlen, bufptr, buflen);
BUG_ON(unlikely(!iolen));
return wl_dev_ioctl(dev, WLC_SET_VAR, bufptr, iolen);
}
-static int32
+static s32
wl_dev_iovar_getbuf(struct net_device *dev, s8 * iovar, void *param,
- int32 paramlen, void *bufptr, int32 buflen)
+ s32 paramlen, void *bufptr, s32 buflen)
{
- int32 iolen;
+ s32 iolen;
iolen = bcm_mkiovar(iovar, param, paramlen, bufptr, buflen);
BUG_ON(unlikely(!iolen));
return wl_dev_ioctl(dev, WLC_GET_VAR, bufptr, buflen);
}
-static int32
-wl_run_iscan(struct wl_iscan_ctrl *iscan, struct wlc_ssid *ssid, uint16 action)
+static s32
+wl_run_iscan(struct wl_iscan_ctrl *iscan, struct wlc_ssid *ssid, u16 action)
{
- int32 params_size =
- (WL_SCAN_PARAMS_FIXED_SIZE + OFFSETOF(wl_iscan_params_t, params));
+ s32 params_size =
+ (WL_SCAN_PARAMS_FIXED_SIZE + offsetof(wl_iscan_params_t, params));
struct wl_iscan_params *params;
- int32 err = 0;
+ s32 err = 0;
if (ssid && ssid->SSID_len)
params_size += sizeof(struct wlc_ssid);
- params = (struct wl_iscan_params *)kzalloc(params_size, GFP_KERNEL);
+ params = kzalloc(params_size, GFP_KERNEL);
if (unlikely(!params))
return -ENOMEM;
memset(params, 0, params_size);
params->action = htod16(action);
params->scan_duration = htod16(0);
- /* params_size += OFFSETOF(wl_iscan_params_t, params); */
- if (unlikely
- ((err =
- wl_dev_iovar_setbuf(iscan->dev, "iscan", params, params_size,
- iscan->ioctl_buf, WLC_IOCTL_SMLEN)))) {
+ /* params_size += offsetof(wl_iscan_params_t, params); */
+ err = wl_dev_iovar_setbuf(iscan->dev, "iscan", params, params_size,
+ iscan->ioctl_buf, WLC_IOCTL_SMLEN);
+ if (unlikely(err)) {
if (err == -EBUSY) {
WL_INFO(("system busy : iscan canceled\n"));
} else {
return err;
}
-static int32 wl_do_iscan(struct wl_priv *wl)
+static s32 wl_do_iscan(struct wl_priv *wl)
{
struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
+ struct net_device *ndev = wl_to_ndev(wl);
struct wlc_ssid ssid;
- int32 err = 0;
+ s32 passive_scan;
+ s32 err = 0;
/* Broadcast scan by default */
memset(&ssid, 0, sizeof(ssid));
iscan->state = WL_ISCAN_STATE_SCANING;
- if (wl->active_scan) {
- int32 passive_scan = 0;
- /* make it active scan */
- if (unlikely
- ((err =
- wl_dev_ioctl(wl_to_ndev(wl), WLC_SET_PASSIVE_SCAN,
- &passive_scan, sizeof(passive_scan))))) {
- WL_DBG(("error (%d)\n", err));
- return err;
- }
+ passive_scan = wl->active_scan ? 0 : 1;
+ err = wl_dev_ioctl(wl_to_ndev(wl), WLC_SET_PASSIVE_SCAN,
+ &passive_scan, sizeof(passive_scan));
+ if (unlikely(err)) {
+ WL_DBG(("error (%d)\n", err));
+ return err;
}
- wl->iscan_kickstart = TRUE;
+ wl_set_mpc(ndev, 0);
+ wl->iscan_kickstart = true;
wl_run_iscan(iscan, &ssid, WL_SCAN_ACTION_START);
mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
iscan->timer_on = 1;
return err;
}
-static int32
+static s32
__wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
struct cfg80211_scan_request *request,
struct cfg80211_ssid *this_ssid)
struct wl_priv *wl = ndev_to_wl(ndev);
struct cfg80211_ssid *ssids;
struct wl_scan_req *sr = wl_to_sr(wl);
+ s32 passive_scan;
bool iscan_req;
bool spec_scan;
- int32 err = 0;
+ s32 err = 0;
if (unlikely(test_bit(WL_STATUS_SCANNING, &wl->status))) {
WL_ERR(("Scanning already : status (%d)\n", (int)wl->status));
return -EAGAIN;
}
- iscan_req = FALSE;
- spec_scan = FALSE;
+ iscan_req = false;
+ spec_scan = false;
if (request) { /* scan bss */
ssids = request->ssids;
if (wl->iscan_on && (!ssids || !ssids->ssid_len)) { /* for
* we do not iscan for
* specific scan request
*/
- iscan_req = TRUE;
+ iscan_req = true;
}
} else { /* scan in ibss */
/* we don't do iscan in ibss */
wl->scan_request = request;
set_bit(WL_STATUS_SCANNING, &wl->status);
if (iscan_req) {
- if (likely(!(err = wl_do_iscan(wl))))
+ err = wl_do_iscan(wl);
+ if (likely(!err))
return err;
else
goto scan_out;
ssids->ssid, ssids->ssid_len));
memset(&sr->ssid, 0, sizeof(sr->ssid));
sr->ssid.SSID_len =
- MIN(sizeof(sr->ssid.SSID), ssids->ssid_len);
+ min_t(u8, sizeof(sr->ssid.SSID), ssids->ssid_len);
if (sr->ssid.SSID_len) {
memcpy(sr->ssid.SSID, ssids->ssid, sr->ssid.SSID_len);
sr->ssid.SSID_len = htod32(sr->ssid.SSID_len);
WL_DBG(("Specific scan ssid=\"%s\" len=%d\n",
sr->ssid.SSID, sr->ssid.SSID_len));
- spec_scan = TRUE;
+ spec_scan = true;
} else {
WL_DBG(("Broadcast scan\n"));
}
WL_DBG(("sr->ssid.SSID_len (%d)\n", sr->ssid.SSID_len));
- if (wl->active_scan) {
- int32 pssive_scan = 0;
- /* make it active scan */
- if (unlikely
- ((err =
- wl_dev_ioctl(ndev, WLC_SET_PASSIVE_SCAN,
- &pssive_scan,
- sizeof(pssive_scan))))) {
- WL_ERR(("WLC_SET_PASSIVE_SCAN error (%d)\n",
- err));
- goto scan_out;
- }
+ passive_scan = wl->active_scan ? 0 : 1;
+ err = wl_dev_ioctl(ndev, WLC_SET_PASSIVE_SCAN,
+ &passive_scan, sizeof(passive_scan));
+ if (unlikely(err)) {
+ WL_ERR(("WLC_SET_PASSIVE_SCAN error (%d)\n", err));
+ goto scan_out;
}
- if ((err =
- wl_dev_ioctl(ndev, WLC_SCAN, &sr->ssid,
- sizeof(sr->ssid)))) {
+ wl_set_mpc(ndev, 0);
+ err = wl_dev_ioctl(ndev, WLC_SCAN, &sr->ssid,
+ sizeof(sr->ssid));
+ if (err) {
if (err == -EBUSY) {
WL_INFO(("system busy : scan for \"%s\" "
"canceled\n", sr->ssid.SSID));
} else {
WL_ERR(("WLC_SCAN error (%d)\n", err));
}
+ wl_set_mpc(ndev, 1);
goto scan_out;
}
}
return err;
}
-static int32
+static s32
wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
struct cfg80211_scan_request *request)
{
- int32 err = 0;
+ s32 err = 0;
CHECK_SYS_UP();
- if (unlikely((err = __wl_cfg80211_scan(wiphy, ndev, request, NULL)))) {
+ err = __wl_cfg80211_scan(wiphy, ndev, request, NULL);
+ if (unlikely(err)) {
WL_DBG(("scan error (%d)\n", err));
return err;
}
return err;
}
-static int32 wl_dev_intvar_set(struct net_device *dev, s8 *name, int32 val)
+static s32 wl_dev_intvar_set(struct net_device *dev, s8 *name, s32 val)
{
s8 buf[WLC_IOCTL_SMLEN];
- uint32 len;
- int32 err = 0;
+ u32 len;
+ s32 err = 0;
val = htod32(val);
len = bcm_mkiovar(name, (char *)(&val), sizeof(val), buf, sizeof(buf));
BUG_ON(unlikely(!len));
- if (unlikely((err = wl_dev_ioctl(dev, WLC_SET_VAR, buf, len)))) {
+ err = wl_dev_ioctl(dev, WLC_SET_VAR, buf, len);
+ if (unlikely(err)) {
WL_ERR(("error (%d)\n", err));
}
return err;
}
-static int32
-wl_dev_intvar_get(struct net_device *dev, s8 *name, int32 *retval)
+static s32
+wl_dev_intvar_get(struct net_device *dev, s8 *name, s32 *retval)
{
union {
s8 buf[WLC_IOCTL_SMLEN];
- int32 val;
+ s32 val;
} var;
- uint32 len;
- uint32 data_null;
- int32 err = 0;
+ u32 len;
+ u32 data_null;
+ s32 err = 0;
len =
bcm_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
sizeof(var.buf));
BUG_ON(unlikely(!len));
- if (unlikely((err = wl_dev_ioctl(dev, WLC_GET_VAR, &var, len)))) {
+ err = wl_dev_ioctl(dev, WLC_GET_VAR, &var, len);
+ if (unlikely(err)) {
WL_ERR(("error (%d)\n", err));
}
*retval = dtoh32(var.val);
return err;
}
-static int32 wl_set_rts(struct net_device *dev, uint32 rts_threshold)
+static s32 wl_set_rts(struct net_device *dev, u32 rts_threshold)
{
- int32 err = 0;
+ s32 err = 0;
- if (unlikely
- ((err = wl_dev_intvar_set(dev, "rtsthresh", rts_threshold)))) {
+ err = wl_dev_intvar_set(dev, "rtsthresh", rts_threshold);
+ if (unlikely(err)) {
WL_ERR(("Error (%d)\n", err));
return err;
}
return err;
}
-static int32 wl_set_frag(struct net_device *dev, uint32 frag_threshold)
+static s32 wl_set_frag(struct net_device *dev, u32 frag_threshold)
{
- int32 err = 0;
+ s32 err = 0;
- if (unlikely
- ((err = wl_dev_intvar_set(dev, "fragthresh", frag_threshold)))) {
+ err = wl_dev_intvar_set(dev, "fragthresh", frag_threshold);
+ if (unlikely(err)) {
WL_ERR(("Error (%d)\n", err));
return err;
}
return err;
}
-static int32 wl_set_retry(struct net_device *dev, uint32 retry, bool l)
+static s32 wl_set_retry(struct net_device *dev, u32 retry, bool l)
{
- int32 err = 0;
- uint32 cmd = (l ? WLC_SET_LRL : WLC_SET_SRL);
+ s32 err = 0;
+ u32 cmd = (l ? WLC_SET_LRL : WLC_SET_SRL);
retry = htod32(retry);
- if (unlikely((err = wl_dev_ioctl(dev, cmd, &retry, sizeof(retry))))) {
+ err = wl_dev_ioctl(dev, cmd, &retry, sizeof(retry));
+ if (unlikely(err)) {
WL_ERR(("cmd (%d) , error (%d)\n", cmd, err));
return err;
}
return err;
}
-static int32 wl_cfg80211_set_wiphy_params(struct wiphy *wiphy, uint32 changed)
+static s32 wl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
{
struct wl_priv *wl = wiphy_to_wl(wiphy);
struct net_device *ndev = wl_to_ndev(wl);
- int32 err = 0;
+ s32 err = 0;
CHECK_SYS_UP();
if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
(wl->conf->rts_threshold != wiphy->rts_threshold)) {
wl->conf->rts_threshold = wiphy->rts_threshold;
- if (!(err = wl_set_rts(ndev, wl->conf->rts_threshold)))
+ err = wl_set_rts(ndev, wl->conf->rts_threshold);
+ if (!err)
return err;
}
if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
(wl->conf->frag_threshold != wiphy->frag_threshold)) {
wl->conf->frag_threshold = wiphy->frag_threshold;
- if (!(err = wl_set_frag(ndev, wl->conf->frag_threshold)))
+ err = wl_set_frag(ndev, wl->conf->frag_threshold);
+ if (!err)
return err;
}
if (changed & WIPHY_PARAM_RETRY_LONG
&& (wl->conf->retry_long != wiphy->retry_long)) {
wl->conf->retry_long = wiphy->retry_long;
- if (!(err = wl_set_retry(ndev, wl->conf->retry_long, TRUE)))
+ err = wl_set_retry(ndev, wl->conf->retry_long, true);
+ if (!err)
return err;
}
if (changed & WIPHY_PARAM_RETRY_SHORT
&& (wl->conf->retry_short != wiphy->retry_short)) {
wl->conf->retry_short = wiphy->retry_short;
- if (!(err = wl_set_retry(ndev, wl->conf->retry_short, FALSE))) {
+ err = wl_set_retry(ndev, wl->conf->retry_short, false);
+ if (!err) {
return err;
}
}
return err;
}
-static int32
+static s32
wl_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_ibss_params *params)
{
struct ieee80211_channel *chan;
struct wl_join_params join_params;
struct cfg80211_ssid ssid;
- int32 scan_retry = 0;
- int32 err = 0;
+ s32 scan_retry = 0;
+ s32 err = 0;
CHECK_SYS_UP();
if (params->bssid) {
params->ssid, params->ssid_len);
}
if (bss) {
- wl->ibss_starter = FALSE;
+ wl->ibss_starter = false;
WL_DBG(("Found IBSS\n"));
} else {
- wl->ibss_starter = TRUE;
+ wl->ibss_starter = true;
}
- if ((chan = params->channel))
+ chan = params->channel;
+ if (chan)
wl->channel = ieee80211_frequency_to_channel(chan->center_freq);
/*
** Join with specific BSSID and cached SSID
else
memset(&join_params.params.bssid, 0, ETHER_ADDR_LEN);
- if (unlikely
- ((err =
- wl_dev_ioctl(dev, WLC_SET_SSID, &join_params,
- sizeof(join_params))))) {
+ err = wl_dev_ioctl(dev, WLC_SET_SSID, &join_params,
+ sizeof(join_params));
+ if (unlikely(err)) {
WL_ERR(("Error (%d)\n", err));
return err;
}
return err;
}
-static int32 wl_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
+static s32 wl_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
{
struct wl_priv *wl = wiphy_to_wl(wiphy);
- int32 err = 0;
+ s32 err = 0;
CHECK_SYS_UP();
wl_link_down(wl);
return err;
}
-static int32
+static s32
wl_set_wpa_version(struct net_device *dev, struct cfg80211_connect_params *sme)
{
struct wl_priv *wl = ndev_to_wl(dev);
struct wl_security *sec;
- int32 val = 0;
- int32 err = 0;
+ s32 val = 0;
+ s32 err = 0;
if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
else
val = WPA_AUTH_DISABLED;
WL_DBG(("setting wpa_auth to 0x%0x\n", val));
- if (unlikely((err = wl_dev_intvar_set(dev, "wpa_auth", val)))) {
+ err = wl_dev_intvar_set(dev, "wpa_auth", val);
+ if (unlikely(err)) {
WL_ERR(("set wpa_auth failed (%d)\n", err));
return err;
}
return err;
}
-static int32
+static s32
wl_set_auth_type(struct net_device *dev, struct cfg80211_connect_params *sme)
{
struct wl_priv *wl = ndev_to_wl(dev);
struct wl_security *sec;
- int32 val = 0;
- int32 err = 0;
+ s32 val = 0;
+ s32 err = 0;
switch (sme->auth_type) {
case NL80211_AUTHTYPE_OPEN_SYSTEM:
break;
}
- if (unlikely((err = wl_dev_intvar_set(dev, "auth", val)))) {
+ err = wl_dev_intvar_set(dev, "auth", val);
+ if (unlikely(err)) {
WL_ERR(("set auth failed (%d)\n", err));
return err;
}
return err;
}
-static int32
+static s32
wl_set_set_cipher(struct net_device *dev, struct cfg80211_connect_params *sme)
{
struct wl_priv *wl = ndev_to_wl(dev);
struct wl_security *sec;
- int32 pval = 0;
- int32 gval = 0;
- int32 err = 0;
+ s32 pval = 0;
+ s32 gval = 0;
+ s32 err = 0;
if (sme->crypto.n_ciphers_pairwise) {
switch (sme->crypto.ciphers_pairwise[0]) {
}
WL_DBG(("pval (%d) gval (%d)\n", pval, gval));
- if (unlikely((err = wl_dev_intvar_set(dev, "wsec", pval | gval)))) {
+ err = wl_dev_intvar_set(dev, "wsec", pval | gval);
+ if (unlikely(err)) {
WL_ERR(("error (%d)\n", err));
return err;
}
return err;
}
-static int32
+static s32
wl_set_key_mgmt(struct net_device *dev, struct cfg80211_connect_params *sme)
{
struct wl_priv *wl = ndev_to_wl(dev);
struct wl_security *sec;
- int32 val = 0;
- int32 err = 0;
+ s32 val = 0;
+ s32 err = 0;
if (sme->crypto.n_akm_suites) {
- if (unlikely((err = wl_dev_intvar_get(dev, "wpa_auth", &val)))) {
+ err = wl_dev_intvar_get(dev, "wpa_auth", &val);
+ if (unlikely(err)) {
WL_ERR(("could not get wpa_auth (%d)\n", err));
return err;
}
}
WL_DBG(("setting wpa_auth to %d\n", val));
- if (unlikely((err = wl_dev_intvar_set(dev, "wpa_auth", val)))) {
+ err = wl_dev_intvar_set(dev, "wpa_auth", val);
+ if (unlikely(err)) {
WL_ERR(("could not set wpa_auth (%d)\n", err));
return err;
}
return err;
}
-static int32
+static s32
wl_set_set_sharedkey(struct net_device *dev,
struct cfg80211_connect_params *sme)
{
struct wl_priv *wl = ndev_to_wl(dev);
struct wl_security *sec;
struct wl_wsec_key key;
- int32 val;
- int32 err = 0;
+ s32 val;
+ s32 err = 0;
WL_DBG(("key len (%d)\n", sme->key_len));
if (sme->key_len) {
&& (sec->cipher_pairwise & (WLAN_CIPHER_SUITE_WEP40 |
WLAN_CIPHER_SUITE_WEP104))) {
memset(&key, 0, sizeof(key));
- key.len = (uint32) sme->key_len;
- key.index = (uint32) sme->key_idx;
+ key.len = (u32) sme->key_len;
+ key.index = (u32) sme->key_idx;
if (unlikely(key.len > sizeof(key.data))) {
WL_ERR(("Too long key length (%u)\n", key.len));
return -EINVAL;
key.len, key.index, key.algo));
WL_DBG(("key \"%s\"\n", key.data));
swap_key_from_BE(&key);
- if (unlikely
- ((err =
- wl_dev_ioctl(dev, WLC_SET_KEY, &key,
- sizeof(key))))) {
+ err = wl_dev_ioctl(dev, WLC_SET_KEY, &key,
+ sizeof(key));
+ if (unlikely(err)) {
WL_ERR(("WLC_SET_KEY error (%d)\n", err));
return err;
}
if (sec->auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM) {
WL_DBG(("set auth_type to shared key\n"));
val = 1; /* shared key */
- if (unlikely
- ((err =
- wl_dev_intvar_set(dev, "auth", val)))) {
+ err = wl_dev_intvar_set(dev, "auth", val);
+ if (unlikely(err)) {
WL_ERR(("set auth failed (%d)\n", err));
return err;
}
return err;
}
-static int32
+static s32
wl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_connect_params *sme)
{
struct wl_priv *wl = wiphy_to_wl(wiphy);
struct ieee80211_channel *chan = sme->channel;
- struct wlc_ssid ssid;
- int32 err = 0;
+ struct wl_join_params join_params;
+ size_t join_params_size;
+
+ s32 err = 0;
CHECK_SYS_UP();
if (unlikely(!sme->ssid)) {
WL_DBG(("channel (%d), center_req (%d)\n", wl->channel,
chan->center_freq));
}
- WL_DBG(("ie (%p), ie_len (%d)\n", sme->ie, sme->ie_len));
- if (unlikely((err = wl_set_wpa_version(dev, sme))))
+ WL_DBG(("ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len));
+ err = wl_set_wpa_version(dev, sme);
+ if (unlikely(err))
return err;
- if (unlikely((err = wl_set_auth_type(dev, sme))))
+ err = wl_set_auth_type(dev, sme);
+ if (unlikely(err))
return err;
- if (unlikely((err = wl_set_set_cipher(dev, sme))))
+ err = wl_set_set_cipher(dev, sme);
+ if (unlikely(err))
return err;
- if (unlikely((err = wl_set_key_mgmt(dev, sme))))
+ err = wl_set_key_mgmt(dev, sme);
+ if (unlikely(err))
return err;
- if (unlikely((err = wl_set_set_sharedkey(dev, sme))))
+ err = wl_set_set_sharedkey(dev, sme);
+ if (unlikely(err))
return err;
wl_update_prof(wl, NULL, sme->bssid, WL_PROF_BSSID);
** Join with specific BSSID and cached SSID
** If SSID is zero join based on BSSID only
*/
- memset(&ssid, 0, sizeof(ssid));
- ssid.SSID_len = MIN(sizeof(ssid.SSID), sme->ssid_len);
- memcpy(ssid.SSID, sme->ssid, ssid.SSID_len);
- ssid.SSID_len = htod32(ssid.SSID_len);
- wl_update_prof(wl, NULL, &ssid, WL_PROF_SSID);
- if (ssid.SSID_len < IEEE80211_MAX_SSID_LEN) {
- WL_DBG(("ssid \"%s\", len (%d)\n", ssid.SSID, ssid.SSID_len));
+ memset(&join_params, 0, sizeof(join_params));
+ join_params_size = sizeof(join_params.ssid);
+
+ join_params.ssid.SSID_len = min(sizeof(join_params.ssid.SSID), sme->ssid_len);
+ memcpy(&join_params.ssid.SSID, sme->ssid, join_params.ssid.SSID_len);
+ join_params.ssid.SSID_len = htod32(join_params.ssid.SSID_len);
+ wl_update_prof(wl, NULL, &join_params.ssid, WL_PROF_SSID);
+ memcpy(&join_params.params.bssid, ðer_bcast, ETHER_ADDR_LEN);
+
+ wl_ch_to_chanspec(wl->channel, &join_params, &join_params_size);
+ WL_DBG(("join_param_size %d\n", join_params_size));
+
+ if (join_params.ssid.SSID_len < IEEE80211_MAX_SSID_LEN) {
+ WL_DBG(("ssid \"%s\", len (%d)\n", join_params.ssid.SSID,
+ join_params.ssid.SSID_len));
}
- if (unlikely
- ((err = wl_dev_ioctl(dev, WLC_SET_SSID, &ssid, sizeof(ssid))))) {
+ err = wl_dev_ioctl(dev, WLC_SET_SSID, &join_params, join_params_size);
+ if (unlikely(err)) {
WL_ERR(("error (%d)\n", err));
return err;
}
return err;
}
-static int32
+static s32
wl_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
- uint16 reason_code)
+ u16 reason_code)
{
struct wl_priv *wl = wiphy_to_wl(wiphy);
scb_val_t scbval;
- bool act = FALSE;
- int32 err = 0;
+ bool act = false;
+ s32 err = 0;
WL_DBG(("Reason %d\n", reason_code));
CHECK_SYS_UP();
- if (likely((act = *(bool *) wl_read_prof(wl, WL_PROF_ACT)))) {
+ act = *(bool *) wl_read_prof(wl, WL_PROF_ACT);
+ if (likely(act)) {
scbval.val = reason_code;
memcpy(&scbval.ea, &wl->bssid, ETHER_ADDR_LEN);
scbval.val = htod32(scbval.val);
- if (unlikely((err = wl_dev_ioctl(dev, WLC_DISASSOC, &scbval,
- sizeof(scb_val_t))))) {
+ err = wl_dev_ioctl(dev, WLC_DISASSOC, &scbval,
+ sizeof(scb_val_t));
+ if (unlikely(err)) {
WL_ERR(("error (%d)\n", err));
return err;
}
return err;
}
-static int32
+static s32
wl_cfg80211_set_tx_power(struct wiphy *wiphy,
- enum nl80211_tx_power_setting type, int32 dbm)
+ enum nl80211_tx_power_setting type, s32 dbm)
{
struct wl_priv *wl = wiphy_to_wl(wiphy);
struct net_device *ndev = wl_to_ndev(wl);
- uint16 txpwrmw;
- int32 err = 0;
- int32 disable = 0;
+ u16 txpwrmw;
+ s32 err = 0;
+ s32 disable = 0;
CHECK_SYS_UP();
switch (type) {
/* Make sure radio is off or on as far as software is concerned */
disable = WL_RADIO_SW_DISABLE << 16;
disable = htod32(disable);
- if (unlikely
- ((err =
- wl_dev_ioctl(ndev, WLC_SET_RADIO, &disable, sizeof(disable))))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_RADIO, &disable, sizeof(disable));
+ if (unlikely(err)) {
WL_ERR(("WLC_SET_RADIO error (%d)\n", err));
return err;
}
if (dbm > 0xffff)
txpwrmw = 0xffff;
else
- txpwrmw = (uint16) dbm;
- if (unlikely((err = wl_dev_intvar_set(ndev, "qtxpower",
- (int32) (bcm_mw_to_qdbm
- (txpwrmw)))))) {
+ txpwrmw = (u16) dbm;
+ err = wl_dev_intvar_set(ndev, "qtxpower",
+ (s32) (bcm_mw_to_qdbm(txpwrmw)));
+ if (unlikely(err)) {
WL_ERR(("qtxpower error (%d)\n", err));
return err;
}
return err;
}
-static int32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, int32 *dbm)
+static s32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm)
{
struct wl_priv *wl = wiphy_to_wl(wiphy);
struct net_device *ndev = wl_to_ndev(wl);
- int32 txpwrdbm;
+ s32 txpwrdbm;
u8 result;
- int32 err = 0;
+ s32 err = 0;
CHECK_SYS_UP();
- if (unlikely((err = wl_dev_intvar_get(ndev, "qtxpower", &txpwrdbm)))) {
+ err = wl_dev_intvar_get(ndev, "qtxpower", &txpwrdbm);
+ if (unlikely(err)) {
WL_ERR(("error (%d)\n", err));
return err;
}
result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
- *dbm = (int32) bcm_qdbm_to_mw(result);
+ *dbm = (s32) bcm_qdbm_to_mw(result);
return err;
}
-static int32
+static s32
wl_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *dev,
u8 key_idx)
{
- uint32 index;
- int32 wsec;
- int32 err = 0;
+ u32 index;
+ s32 wsec;
+ s32 err = 0;
WL_DBG(("key index (%d)\n", key_idx));
CHECK_SYS_UP();
- if (unlikely
- (err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec)))) {
+ err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
+ if (unlikely(err)) {
WL_ERR(("WLC_GET_WSEC error (%d)\n", err));
return err;
}
wsec = dtoh32(wsec);
if (wsec & WEP_ENABLED) {
/* Just select a new current key */
- index = (uint32) key_idx;
+ index = (u32) key_idx;
index = htod32(index);
- if (unlikely((err = wl_dev_ioctl(dev, WLC_SET_KEY_PRIMARY,
- &index, sizeof(index))))) {
+ err = wl_dev_ioctl(dev, WLC_SET_KEY_PRIMARY, &index,
+ sizeof(index));
+ if (unlikely(err)) {
WL_ERR(("error (%d)\n", err));
}
}
return err;
}
-static int32
+static s32
wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
u8 key_idx, const u8 *mac_addr, struct key_params *params)
{
struct wl_wsec_key key;
- int32 err = 0;
+ s32 err = 0;
memset(&key, 0, sizeof(key));
- key.index = (uint32) key_idx;
+ key.index = (u32) key_idx;
/* Instead of bcast for ea address for default wep keys,
driver needs it to be Null */
if (!ETHER_ISMULTI(mac_addr))
memcpy((char *)&key.ea, (void *)mac_addr, ETHER_ADDR_LEN);
- key.len = (uint32) params->key_len;
+ key.len = (u32) params->key_len;
/* check for key index change */
if (key.len == 0) {
/* key delete */
swap_key_from_BE(&key);
- if (unlikely
- ((err =
- wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key))))) {
+ err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
+ if (unlikely(err)) {
WL_ERR(("key delete error (%d)\n", err));
return err;
}
key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
(ivptr[3] << 8) | ivptr[2];
key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
- key.iv_initialized = TRUE;
+ key.iv_initialized = true;
}
switch (params->cipher) {
swap_key_from_BE(&key);
dhd_wait_pend8021x(dev);
- if (unlikely
- ((err =
- wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key))))) {
+ err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
+ if (unlikely(err)) {
WL_ERR(("WLC_SET_KEY error (%d)\n", err));
return err;
}
return err;
}
-static int32
+static s32
wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
- u8 key_idx, const u8 *mac_addr,
+ u8 key_idx, bool pairwise, const u8 *mac_addr,
struct key_params *params)
{
struct wl_wsec_key key;
- int32 val;
- int32 wsec;
- int32 err = 0;
+ s32 val;
+ s32 wsec;
+ s32 err = 0;
WL_DBG(("key index (%d)\n", key_idx));
CHECK_SYS_UP();
return wl_add_keyext(wiphy, dev, key_idx, mac_addr, params);
memset(&key, 0, sizeof(key));
- key.len = (uint32) params->key_len;
- key.index = (uint32) key_idx;
+ key.len = (u32) params->key_len;
+ key.index = (u32) key_idx;
if (unlikely(key.len > sizeof(key.data))) {
WL_ERR(("Too long key length (%u)\n", key.len));
/* Set the new key/index */
swap_key_from_BE(&key);
- if (unlikely((err = wl_dev_ioctl(dev, WLC_SET_KEY,
- &key, sizeof(key))))) {
+ err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
+ if (unlikely(err)) {
WL_ERR(("WLC_SET_KEY error (%d)\n", err));
return err;
}
val = WEP_ENABLED;
- if (unlikely((err = wl_dev_intvar_get(dev, "wsec", &wsec)))) {
+ err = wl_dev_intvar_get(dev, "wsec", &wsec);
+ if (unlikely(err)) {
WL_ERR(("get wsec error (%d)\n", err));
return err;
}
wsec &= ~(WEP_ENABLED);
wsec |= val;
- if (unlikely((err = wl_dev_intvar_set(dev, "wsec", wsec)))) {
+ err = wl_dev_intvar_set(dev, "wsec", wsec);
+ if (unlikely(err)) {
WL_ERR(("set wsec error (%d)\n", err));
return err;
}
val = 1; /* assume shared key. otherwise 0 */
val = htod32(val);
- if (unlikely
- ((err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val))))) {
+ err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
+ if (unlikely(err)) {
WL_ERR(("WLC_SET_AUTH error (%d)\n", err));
return err;
}
return err;
}
-static int32
+static s32
wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
- u8 key_idx, const u8 *mac_addr)
+ u8 key_idx, bool pairwise, const u8 *mac_addr)
{
struct wl_wsec_key key;
- int32 err = 0;
- int32 val;
- int32 wsec;
+ s32 err = 0;
+ s32 val;
+ s32 wsec;
CHECK_SYS_UP();
memset(&key, 0, sizeof(key));
- key.index = (uint32) key_idx;
+ key.index = (u32) key_idx;
key.flags = WL_PRIMARY_KEY;
key.algo = CRYPTO_ALGO_OFF;
WL_DBG(("key index (%d)\n", key_idx));
/* Set the new key/index */
swap_key_from_BE(&key);
- if (unlikely((err = wl_dev_ioctl(dev, WLC_SET_KEY,
- &key, sizeof(key))))) {
+ err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
+ if (unlikely(err)) {
if (err == -EINVAL) {
if (key.index >= DOT11_MAX_DEFAULT_KEYS) {
/* we ignore this key index in this case */
}
val = 0;
- if (unlikely((err = wl_dev_intvar_get(dev, "wsec", &wsec)))) {
+ err = wl_dev_intvar_get(dev, "wsec", &wsec);
+ if (unlikely(err)) {
WL_ERR(("get wsec error (%d)\n", err));
return err;
}
wsec &= ~(WEP_ENABLED);
wsec |= val;
- if (unlikely((err = wl_dev_intvar_set(dev, "wsec", wsec)))) {
+ err = wl_dev_intvar_set(dev, "wsec", wsec);
+ if (unlikely(err)) {
WL_ERR(("set wsec error (%d)\n", err));
return err;
}
val = 0; /* assume open key. otherwise 1 */
val = htod32(val);
- if (unlikely
- ((err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val))))) {
+ err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
+ if (unlikely(err)) {
WL_ERR(("WLC_SET_AUTH error (%d)\n", err));
return err;
}
return err;
}
-static int32
+static s32
wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
- u8 key_idx, const u8 *mac_addr, void *cookie,
+ u8 key_idx, bool pairwise, const u8 *mac_addr, void *cookie,
void (*callback) (void *cookie, struct key_params * params))
{
struct key_params params;
struct wl_wsec_key key;
struct wl_priv *wl = wiphy_to_wl(wiphy);
struct wl_security *sec;
- int32 wsec;
- int32 err = 0;
+ s32 wsec;
+ s32 err = 0;
WL_DBG(("key index (%d)\n", key_idx));
CHECK_SYS_UP();
key.index = key_idx;
swap_key_to_BE(&key);
memset(¶ms, 0, sizeof(params));
- params.key_len = (u8) MIN(DOT11_MAX_KEY_SIZE, key.len);
+ params.key_len = (u8) min_t(u8, DOT11_MAX_KEY_SIZE, key.len);
memcpy(params.key, key.data, params.key_len);
- if (unlikely
- (err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec)))) {
+ err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
+ if (unlikely(err)) {
WL_ERR(("WLC_GET_WSEC error (%d)\n", err));
return err;
}
return err;
}
-static int32
+static s32
wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
struct net_device *dev, u8 key_idx)
{
return -EOPNOTSUPP;
}
-static int32
+static s32
wl_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
u8 *mac, struct station_info *sinfo)
{
struct wl_priv *wl = wiphy_to_wl(wiphy);
scb_val_t scb_val;
int rssi;
- int32 rate;
- int32 err = 0;
+ s32 rate;
+ s32 err = 0;
CHECK_SYS_UP();
if (unlikely
}
/* Report the current tx rate */
- if ((err = wl_dev_ioctl(dev, WLC_GET_RATE, &rate, sizeof(rate)))) {
+ err = wl_dev_ioctl(dev, WLC_GET_RATE, &rate, sizeof(rate));
+ if (err) {
WL_ERR(("Could not get rate (%d)\n", err));
} else {
rate = dtoh32(rate);
if (test_bit(WL_STATUS_CONNECTED, &wl->status)) {
scb_val.val = 0;
- if (unlikely
- (err =
- wl_dev_ioctl(dev, WLC_GET_RSSI, &scb_val,
- sizeof(scb_val_t)))) {
+ err = wl_dev_ioctl(dev, WLC_GET_RSSI, &scb_val,
+ sizeof(scb_val_t));
+ if (unlikely(err)) {
WL_ERR(("Could not get rssi (%d)\n", err));
return err;
}
return err;
}
-static int32
+static s32
wl_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
- bool enabled, int32 timeout)
+ bool enabled, s32 timeout)
{
- int32 pm;
- int32 err = 0;
+ s32 pm;
+ s32 err = 0;
CHECK_SYS_UP();
pm = enabled ? PM_FAST : PM_OFF;
pm = htod32(pm);
WL_DBG(("power save %s\n", (pm ? "enabled" : "disabled")));
- if (unlikely((err = wl_dev_ioctl(dev, WLC_SET_PM, &pm, sizeof(pm))))) {
+ err = wl_dev_ioctl(dev, WLC_SET_PM, &pm, sizeof(pm));
+ if (unlikely(err)) {
if (err == -ENODEV)
WL_DBG(("net_device is not ready yet\n"));
else
return err;
}
-static __used uint32 wl_find_msb(uint16 bit16)
+static __used u32 wl_find_msb(u16 bit16)
{
- uint32 ret = 0;
+ u32 ret = 0;
if (bit16 & 0xff00) {
ret += 8;
return ret;
}
-static int32
+static s32
wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *dev,
const u8 *addr,
const struct cfg80211_bitrate_mask *mask)
{
struct wl_rateset rateset;
- int32 rate;
- int32 val;
- int32 err_bg;
- int32 err_a;
- uint32 legacy;
- int32 err = 0;
+ s32 rate;
+ s32 val;
+ s32 err_bg;
+ s32 err_a;
+ u32 legacy;
+ s32 err = 0;
CHECK_SYS_UP();
/* addr param is always NULL. ignore it */
/* Get current rateset */
- if (unlikely((err = wl_dev_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
- sizeof(rateset))))) {
+ err = wl_dev_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
+ sizeof(rateset));
+ if (unlikely(err)) {
WL_ERR(("could not get current rateset (%d)\n", err));
return err;
}
rateset.count = dtoh32(rateset.count);
- if (!(legacy = wl_find_msb(mask->control[IEEE80211_BAND_2GHZ].legacy)))
+ legacy = wl_find_msb(mask->control[IEEE80211_BAND_2GHZ].legacy);
+ if (!legacy)
legacy = wl_find_msb(mask->control[IEEE80211_BAND_5GHZ].legacy);
val = wl_g_rates[legacy - 1].bitrate * 100000;
return err;
}
-static int32 wl_cfg80211_resume(struct wiphy *wiphy)
+static s32 wl_cfg80211_resume(struct wiphy *wiphy)
{
- int32 err = 0;
+ s32 err = 0;
CHECK_SYS_UP();
wl_invoke_iscan(wiphy_to_wl(wiphy));
return err;
}
-static int32 wl_cfg80211_suspend(struct wiphy *wiphy)
+static s32 wl_cfg80211_suspend(struct wiphy *wiphy)
{
struct wl_priv *wl = wiphy_to_wl(wiphy);
- int32 err = 0;
+ struct net_device *ndev = wl_to_ndev(wl);
+ s32 err = 0;
CHECK_SYS_UP();
set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
wl_term_iscan(wl);
if (wl->scan_request) {
- cfg80211_scan_done(wl->scan_request, TRUE); /* TRUE means
+ cfg80211_scan_done(wl->scan_request, true); /* true means
abort */
+ wl_set_mpc(ndev, 1);
wl->scan_request = NULL;
}
clear_bit(WL_STATUS_SCANNING, &wl->status);
return err;
}
-static __used int32
+static __used s32
wl_update_pmklist(struct net_device *dev, struct wl_pmk_list *pmk_list,
- int32 err)
+ s32 err)
{
- s8 eabuf[ETHER_ADDR_STR_LEN];
int i, j;
- memset(eabuf, 0, ETHER_ADDR_STR_LEN);
-
WL_DBG(("No of elements %d\n", pmk_list->pmkids.npmkid));
for (i = 0; i < pmk_list->pmkids.npmkid; i++) {
- WL_DBG(("PMKID[%d]: %s =\n", i,
- bcm_ether_ntoa(&pmk_list->pmkids.pmkid[i].BSSID,
- eabuf)));
+ WL_DBG(("PMKID[%d]: %pM =\n", i,
+ &pmk_list->pmkids.pmkid[i].BSSID));
for (j = 0; j < WPA2_PMKID_LEN; j++) {
WL_DBG(("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]));
}
return err;
}
-static int32
+static s32
wl_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_pmksa *pmksa)
{
struct wl_priv *wl = wiphy_to_wl(wiphy);
- s8 eabuf[ETHER_ADDR_STR_LEN];
- int32 err = 0;
+ s32 err = 0;
int i;
CHECK_SYS_UP();
- memset(eabuf, 0, ETHER_ADDR_STR_LEN);
for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
if (!memcmp(pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
ETHER_ADDR_LEN))
} else {
err = -EINVAL;
}
- WL_DBG(("set_pmksa,IW_PMKSA_ADD - PMKID: %s =\n",
- bcm_ether_ntoa(&wl->pmk_list->pmkids.
- pmkid[wl->pmk_list->pmkids.npmkid].BSSID,
- eabuf)));
+ WL_DBG(("set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
+ &wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].BSSID));
for (i = 0; i < WPA2_PMKID_LEN; i++) {
WL_DBG(("%02x\n",
wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].
return err;
}
-static int32
+static s32
wl_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_pmksa *pmksa)
{
struct wl_priv *wl = wiphy_to_wl(wiphy);
- s8 eabuf[ETHER_ADDR_STR_LEN];
struct _pmkid_list pmkid;
- int32 err = 0;
+ s32 err = 0;
int i;
CHECK_SYS_UP();
- memset(eabuf, 0, ETHER_ADDR_STR_LEN);
memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETHER_ADDR_LEN);
memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WPA2_PMKID_LEN);
- WL_DBG(("del_pmksa,IW_PMKSA_REMOVE - PMKID: %s =\n",
- bcm_ether_ntoa(&pmkid.pmkid[0].BSSID, eabuf)));
+ WL_DBG(("del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
+ &pmkid.pmkid[0].BSSID));
for (i = 0; i < WPA2_PMKID_LEN; i++) {
WL_DBG(("%02x\n", pmkid.pmkid[0].PMKID[i]));
}
}
-static int32
+static s32
wl_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *dev)
{
struct wl_priv *wl = wiphy_to_wl(wiphy);
- int32 err = 0;
+ s32 err = 0;
CHECK_SYS_UP();
memset(wl->pmk_list, 0, sizeof(*wl->pmk_list));
.flush_pmksa = wl_cfg80211_flush_pmksa
};
-static int32 wl_mode_to_nl80211_iftype(int32 mode)
+static s32 wl_mode_to_nl80211_iftype(s32 mode)
{
- int32 err = 0;
+ s32 err = 0;
switch (mode) {
case WL_MODE_BSS:
return err;
}
-static struct wireless_dev *wl_alloc_wdev(int32 sizeof_iface,
+static struct wireless_dev *wl_alloc_wdev(s32 sizeof_iface,
struct device *dev)
{
struct wireless_dev *wdev;
- int32 err = 0;
+ s32 err = 0;
wdev = kzalloc(sizeof(*wdev), GFP_KERNEL);
if (unlikely(!wdev)) {
#else
wdev->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
#endif /* !WL_POWERSAVE_DISABLED */
- if (unlikely(((err = wiphy_register(wdev->wiphy)) < 0))) {
+ err = wiphy_register(wdev->wiphy);
+ if (unlikely(err < 0)) {
WL_ERR(("Couldn not register wiphy device (%d)\n", err));
goto wiphy_register_out;
}
wl_to_wdev(wl) = NULL;
}
-static int32 wl_inform_bss(struct wl_priv *wl)
+static s32 wl_inform_bss(struct wl_priv *wl)
{
struct wl_scan_results *bss_list;
struct wl_bss_info *bi = NULL; /* must be initialized */
- int32 err = 0;
+ s32 err = 0;
int i;
bss_list = wl->bss_list;
WL_DBG(("scanned AP count (%d)\n", bss_list->count));
bi = next_bss(bss_list, bi);
for_each_bss(bss_list, bi, i) {
- if (unlikely(err = wl_inform_single_bss(wl, bi)))
+ err = wl_inform_single_bss(wl, bi);
+ if (unlikely(err))
break;
}
return err;
}
-static int32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi)
+static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi)
{
struct wiphy *wiphy = wl_to_wiphy(wl);
struct ieee80211_mgmt *mgmt;
struct ieee80211_supported_band *band;
struct wl_cfg80211_bss_info *notif_bss_info;
struct wl_scan_req *sr = wl_to_sr(wl);
- uint32 signal;
- uint32 freq;
- int32 err = 0;
+ struct beacon_proberesp *beacon_proberesp;
+ s32 mgmt_type;
+ u32 signal;
+ u32 freq;
+ s32 err = 0;
if (unlikely(dtoh32(bi->length) > WL_BSS_INFO_MAX)) {
WL_DBG(("Beacon is larger than buffer. Discarding\n"));
return -ENOMEM;
}
mgmt = (struct ieee80211_mgmt *)notif_bss_info->frame_buf;
- notif_bss_info->channel = CHSPEC_CHANNEL(bi->chanspec);
+ notif_bss_info->channel =
+ bi->ctl_ch ? bi->ctl_ch : CHSPEC_CHANNEL(bi->chanspec);
+
if (notif_bss_info->channel <= CH_MAX_2G_CHANNEL)
band = wiphy->bands[IEEE80211_BAND_2GHZ];
else
band = wiphy->bands[IEEE80211_BAND_5GHZ];
notif_bss_info->rssi = bi->RSSI;
memcpy(mgmt->bssid, &bi->BSSID, ETHER_ADDR_LEN);
+ mgmt_type = wl->active_scan ?
+ IEEE80211_STYPE_PROBE_RESP : IEEE80211_STYPE_BEACON;
if (!memcmp(bi->SSID, sr->ssid.SSID, bi->SSID_len)) {
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
- IEEE80211_STYPE_PROBE_RESP);
- }
- mgmt->u.probe_resp.timestamp = 0;
- mgmt->u.probe_resp.beacon_int = cpu_to_le16(bi->beacon_period);
- mgmt->u.probe_resp.capab_info = cpu_to_le16(bi->capability);
+ mgmt_type);
+ }
+ beacon_proberesp = wl->active_scan ?
+ (struct beacon_proberesp *)&mgmt->u.probe_resp :
+ (struct beacon_proberesp *)&mgmt->u.beacon;
+ beacon_proberesp->timestamp = 0;
+ beacon_proberesp->beacon_int = cpu_to_le16(bi->beacon_period);
+ beacon_proberesp->capab_info = cpu_to_le16(bi->capability);
wl_rst_ie(wl);
- wl_add_ie(wl, WLAN_EID_SSID, bi->SSID_len, bi->SSID);
- wl_add_ie(wl, WLAN_EID_SUPP_RATES, bi->rateset.count,
- bi->rateset.rates);
+ /*
+ * wl_add_ie is not necessary because it can only add duplicated
+ * SSID, rate information to frame_buf
+ */
+ /*
+ * wl_add_ie(wl, WLAN_EID_SSID, bi->SSID_len, bi->SSID);
+ * wl_add_ie(wl, WLAN_EID_SUPP_RATES, bi->rateset.count,
+ * bi->rateset.rates);
+ */
wl_mrg_ie(wl, ((u8 *) bi) + bi->ie_offset, bi->ie_length);
- wl_cp_ie(wl, mgmt->u.probe_resp.variable, WL_BSS_INFO_MAX -
+ wl_cp_ie(wl, beacon_proberesp->variable, WL_BSS_INFO_MAX -
offsetof(struct wl_cfg80211_bss_info, frame_buf));
notif_bss_info->frame_len =
offsetof(struct ieee80211_mgmt,
- u.probe_resp.variable) + wl_get_ielen(wl);
+ u.beacon.variable) + wl_get_ielen(wl);
freq = ieee80211_channel_to_frequency(notif_bss_info->channel);
channel = ieee80211_get_channel(wiphy, freq);
- WL_DBG(("SSID : \"%s\", rssi (%d), capability : 0x04%x\n", bi->SSID,
- notif_bss_info->rssi, mgmt->u.probe_resp.capab_info));
+ WL_DBG(("SSID : \"%s\", rssi %d, channel %d, capability : 0x04%x, bssid %pM\n",
+ bi->SSID,
+ notif_bss_info->rssi, notif_bss_info->channel,
+ mgmt->u.beacon.capab_info, &bi->BSSID));
signal = notif_bss_info->rssi * 100;
if (unlikely(!cfg80211_inform_bss_frame(wiphy, channel, mgmt,
static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e)
{
- uint32 event = ntoh32(e->event_type);
- uint16 flags = ntoh16(e->flags);
+ u32 event = ntoh32(e->event_type);
+ u16 flags = ntoh16(e->flags);
- if (event == WLC_E_JOIN || event == WLC_E_ASSOC_IND
- || event == WLC_E_REASSOC_IND) {
- return TRUE;
- } else if (event == WLC_E_LINK) {
+ if (event == WLC_E_LINK) {
if (flags & WLC_EVENT_MSG_LINK) {
if (wl_is_ibssmode(wl)) {
if (wl_is_ibssstarter(wl)) {
}
} else {
-
+ return true;
}
}
}
- return FALSE;
+ return false;
}
static bool wl_is_linkdown(struct wl_priv *wl, const wl_event_msg_t *e)
{
- uint32 event = ntoh32(e->event_type);
- uint16 flags = ntoh16(e->flags);
+ u32 event = ntoh32(e->event_type);
+ u16 flags = ntoh16(e->flags);
if (event == WLC_E_DEAUTH_IND || event == WLC_E_DISASSOC_IND) {
- return TRUE;
+ return true;
} else if (event == WLC_E_LINK) {
if (!(flags & WLC_EVENT_MSG_LINK))
- return TRUE;
+ return true;
+ }
+
+ return false;
+}
+
+static bool wl_is_nonetwork(struct wl_priv *wl, const wl_event_msg_t *e)
+{
+ u32 event = ntoh32(e->event_type);
+ u32 status = ntoh32(e->status);
+
+ if (event == WLC_E_SET_SSID || event == WLC_E_LINK) {
+ if (status == WLC_E_STATUS_NO_NETWORKS)
+ return true;
}
- return FALSE;
+ return false;
}
-static int32
+static s32
wl_notify_connect_status(struct wl_priv *wl, struct net_device *ndev,
const wl_event_msg_t *e, void *data)
{
bool act;
- int32 err = 0;
+ s32 err = 0;
if (wl_is_linkup(wl, e)) {
wl_link_up(wl);
GFP_KERNEL);
WL_DBG(("joined in IBSS network\n"));
} else {
- wl_bss_connect_done(wl, ndev, e, data);
+ wl_bss_connect_done(wl, ndev, e, data, true);
WL_DBG(("joined in BSS network \"%s\"\n",
((struct wlc_ssid *)
wl_read_prof(wl, WL_PROF_SSID))->SSID));
}
- act = TRUE;
+ act = true;
wl_update_prof(wl, e, &act, WL_PROF_ACT);
} else if (wl_is_linkdown(wl, e)) {
cfg80211_disconnected(ndev, 0, NULL, 0, GFP_KERNEL);
clear_bit(WL_STATUS_CONNECTED, &wl->status);
wl_link_down(wl);
wl_init_prof(wl->profile);
+ } else if (wl_is_nonetwork(wl, e)) {
+ wl_bss_connect_done(wl, ndev, e, data, false);
}
return err;
}
-static int32
+static s32
wl_notify_roaming_status(struct wl_priv *wl, struct net_device *ndev,
const wl_event_msg_t *e, void *data)
{
bool act;
- int32 err = 0;
+ s32 err = 0;
wl_bss_roaming_done(wl, ndev, e, data);
- act = TRUE;
+ act = true;
wl_update_prof(wl, e, &act, WL_PROF_ACT);
return err;
}
-static __used int32
-wl_dev_bufvar_set(struct net_device *dev, s8 *name, s8 *buf, int32 len)
+static __used s32
+wl_dev_bufvar_set(struct net_device *dev, s8 *name, s8 *buf, s32 len)
{
struct wl_priv *wl = ndev_to_wl(dev);
- uint32 buflen;
+ u32 buflen;
buflen = bcm_mkiovar(name, buf, len, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
BUG_ON(unlikely(!buflen));
return wl_dev_ioctl(dev, WLC_SET_VAR, wl->ioctl_buf, buflen);
}
-static int32
+static s32
wl_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
- int32 buf_len)
+ s32 buf_len)
{
struct wl_priv *wl = ndev_to_wl(dev);
- uint32 len;
- int32 err = 0;
+ u32 len;
+ s32 err = 0;
len = bcm_mkiovar(name, NULL, 0, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
BUG_ON(unlikely(!len));
- if (unlikely
- ((err =
- wl_dev_ioctl(dev, WLC_GET_VAR, (void *)wl->ioctl_buf,
- WL_IOCTL_LEN_MAX)))) {
+ err = wl_dev_ioctl(dev, WLC_GET_VAR, (void *)wl->ioctl_buf,
+ WL_IOCTL_LEN_MAX);
+ if (unlikely(err)) {
WL_ERR(("error (%d)\n", err));
return err;
}
return err;
}
-static int32 wl_get_assoc_ies(struct wl_priv *wl)
+static s32 wl_get_assoc_ies(struct wl_priv *wl)
{
struct net_device *ndev = wl_to_ndev(wl);
struct wl_assoc_ielen *assoc_info;
struct wl_connect_info *conn_info = wl_to_conn(wl);
- uint32 req_len;
- uint32 resp_len;
- int32 err = 0;
+ u32 req_len;
+ u32 resp_len;
+ s32 err = 0;
- if (unlikely(err = wl_dev_bufvar_get(ndev, "assoc_info", wl->extra_buf,
- WL_ASSOC_INFO_MAX))) {
+ err = wl_dev_bufvar_get(ndev, "assoc_info", wl->extra_buf,
+ WL_ASSOC_INFO_MAX);
+ if (unlikely(err)) {
WL_ERR(("could not get assoc info (%d)\n", err));
return err;
}
req_len = assoc_info->req_len;
resp_len = assoc_info->resp_len;
if (req_len) {
- if (unlikely
- (err =
- wl_dev_bufvar_get(ndev, "assoc_req_ies", wl->extra_buf,
- WL_ASSOC_INFO_MAX))) {
+ err = wl_dev_bufvar_get(ndev, "assoc_req_ies", wl->extra_buf,
+ WL_ASSOC_INFO_MAX);
+ if (unlikely(err)) {
WL_ERR(("could not get assoc req (%d)\n", err));
return err;
}
conn_info->req_ie = NULL;
}
if (resp_len) {
- if (unlikely
- (err =
- wl_dev_bufvar_get(ndev, "assoc_resp_ies", wl->extra_buf,
- WL_ASSOC_INFO_MAX))) {
+ err = wl_dev_bufvar_get(ndev, "assoc_resp_ies", wl->extra_buf,
+ WL_ASSOC_INFO_MAX);
+ if (unlikely(err)) {
WL_ERR(("could not get assoc resp (%d)\n", err));
return err;
}
return err;
}
-static int32 wl_update_bss_info(struct wl_priv *wl)
+static void wl_ch_to_chanspec(int ch, struct wl_join_params *join_params,
+ size_t *join_params_size)
+{
+ chanspec_t chanspec = 0;
+
+ if (ch != 0) {
+ join_params->params.chanspec_num = 1;
+ join_params->params.chanspec_list[0] = ch;
+
+ if (join_params->params.chanspec_list[0])
+ chanspec |= WL_CHANSPEC_BAND_2G;
+ else
+ chanspec |= WL_CHANSPEC_BAND_5G;
+
+ chanspec |= WL_CHANSPEC_BW_20;
+ chanspec |= WL_CHANSPEC_CTL_SB_NONE;
+
+ *join_params_size += WL_ASSOC_PARAMS_FIXED_SIZE +
+ join_params->params.chanspec_num * sizeof(chanspec_t);
+
+ join_params->params.chanspec_list[0] &= WL_CHANSPEC_CHAN_MASK;
+ join_params->params.chanspec_list[0] |= chanspec;
+ join_params->params.chanspec_list[0] =
+ htodchanspec(join_params->params.chanspec_list[0]);
+
+ join_params->params.chanspec_num =
+ htod32(join_params->params.chanspec_num);
+
+ WL_DBG(("join_params->params.chanspec_list[0]= %#X, channel %d, chanspec %#X\n",
+ join_params->params.chanspec_list[0], ch, chanspec));
+ }
+}
+
+static s32 wl_update_bss_info(struct wl_priv *wl)
{
struct cfg80211_bss *bss;
struct wl_bss_info *bi;
struct wlc_ssid *ssid;
- int32 err = 0;
+ struct bcm_tlv *tim;
+ u16 beacon_interval;
+ u8 dtim_period;
+ size_t ie_len;
+ u8 *ie;
+ s32 err = 0;
if (wl_is_ibssmode(wl))
return err;
rtnl_lock();
if (unlikely(!bss)) {
WL_DBG(("Could not find the AP\n"));
- *(uint32 *) wl->extra_buf = htod32(WL_EXTRA_BUF_MAX);
- if (unlikely
- (err =
- wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_BSS_INFO,
- wl->extra_buf, WL_EXTRA_BUF_MAX))) {
+ *(u32 *) wl->extra_buf = htod32(WL_EXTRA_BUF_MAX);
+ err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_BSS_INFO,
+ wl->extra_buf, WL_EXTRA_BUF_MAX);
+ if (unlikely(err)) {
WL_ERR(("Could not get bss info %d\n", err));
goto update_bss_info_out;
}
err = -EIO;
goto update_bss_info_out;
}
- if (unlikely((err = wl_inform_single_bss(wl, bi))))
+ err = wl_inform_single_bss(wl, bi);
+ if (unlikely(err))
goto update_bss_info_out;
+
+ ie = ((u8 *)bi) + bi->ie_offset;
+ ie_len = bi->ie_length;
+ beacon_interval = cpu_to_le16(bi->beacon_period);
} else {
- WL_DBG(("Found the AP in the list - "
- "BSSID %02x:%02x:%02x:%02x:%02x:%02x\n",
- bss->bssid[0], bss->bssid[1], bss->bssid[2],
- bss->bssid[3], bss->bssid[4], bss->bssid[5]));
+ WL_DBG(("Found the AP in the list - BSSID %pM\n", bss->bssid));
+ ie = bss->information_elements;
+ ie_len = bss->len_information_elements;
+ beacon_interval = bss->beacon_interval;
cfg80211_put_bss(bss);
}
+ tim = bcm_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
+ if (tim) {
+ dtim_period = tim->data[1];
+ } else {
+ /*
+ * active scan was done so we could not get dtim
+ * information out of probe response.
+ * so we speficially query dtim information to dongle.
+ */
+ err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_DTIMPRD,
+ &dtim_period, sizeof(dtim_period));
+ if (unlikely(err)) {
+ WL_ERR(("WLC_GET_DTIMPRD error (%d)\n", err));
+ goto update_bss_info_out;
+ }
+ }
+
+ wl_update_prof(wl, NULL, &beacon_interval, WL_PROF_BEACONINT);
+ wl_update_prof(wl, NULL, &dtim_period, WL_PROF_DTIMPERIOD);
+
update_bss_info_out:
rtnl_unlock();
return err;
}
-static int32
+static s32
wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
const wl_event_msg_t *e, void *data)
{
struct wl_connect_info *conn_info = wl_to_conn(wl);
- int32 err = 0;
+ s32 err = 0;
wl_get_assoc_ies(wl);
memcpy(&wl->bssid, &e->addr, ETHER_ADDR_LEN);
return err;
}
-static int32
+static s32
wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
- const wl_event_msg_t *e, void *data)
+ const wl_event_msg_t *e, void *data, bool completed)
{
struct wl_connect_info *conn_info = wl_to_conn(wl);
- int32 err = 0;
+ s32 err = 0;
wl_get_assoc_ies(wl);
memcpy(&wl->bssid, &e->addr, ETHER_ADDR_LEN);
conn_info->req_ie_len,
conn_info->resp_ie,
conn_info->resp_ie_len,
- WLAN_STATUS_SUCCESS, GFP_KERNEL);
- WL_DBG(("Report connect result\n"));
+ completed ? WLAN_STATUS_SUCCESS : WLAN_STATUS_AUTH_TIMEOUT,
+ GFP_KERNEL);
+ WL_DBG(("Report connect result - connection %s\n",
+ completed ? "succeeded" : "failed"));
} else {
cfg80211_roamed(ndev,
(u8 *)&wl->bssid,
return err;
}
-static int32
+static s32
wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
const wl_event_msg_t *e, void *data)
{
- uint16 flags = ntoh16(e->flags);
+ u16 flags = ntoh16(e->flags);
enum nl80211_key_type key_type;
rtnl_lock();
return 0;
}
-static int32
+static s32
wl_notify_scan_status(struct wl_priv *wl, struct net_device *ndev,
const wl_event_msg_t *e, void *data)
{
struct channel_info channel_inform;
struct wl_scan_results *bss_list;
- uint32 len = WL_SCAN_BUF_MAX;
- int32 err = 0;
+ u32 len = WL_SCAN_BUF_MAX;
+ s32 err = 0;
if (wl->iscan_on && wl->iscan_kickstart)
return wl_wakeup_iscan(wl_to_iscan(wl));
if (unlikely(!wl->scan_request)) {
}
rtnl_lock();
- if (unlikely((err = wl_dev_ioctl(ndev, WLC_GET_CHANNEL, &channel_inform,
- sizeof(channel_inform))))) {
+ err = wl_dev_ioctl(ndev, WLC_GET_CHANNEL, &channel_inform,
+ sizeof(channel_inform));
+ if (unlikely(err)) {
WL_ERR(("scan busy (%d)\n", err));
goto scan_done_out;
}
bss_list = wl->bss_list;
memset(bss_list, 0, len);
bss_list->buflen = htod32(len);
- if (unlikely
- ((err = wl_dev_ioctl(ndev, WLC_SCAN_RESULTS, bss_list, len)))) {
+ err = wl_dev_ioctl(ndev, WLC_SCAN_RESULTS, bss_list, len);
+ if (unlikely(err)) {
WL_ERR(("%s Scan_results error (%d)\n", ndev->name, err));
err = -EINVAL;
goto scan_done_out;
bss_list->version = dtoh32(bss_list->version);
bss_list->count = dtoh32(bss_list->count);
- if ((err = wl_inform_bss(wl)))
+ err = wl_inform_bss(wl);
+ if (err)
goto scan_done_out;
scan_done_out:
if (wl->scan_request) {
- cfg80211_scan_done(wl->scan_request, FALSE);
+ cfg80211_scan_done(wl->scan_request, false);
+ wl_set_mpc(ndev, 1);
wl->scan_request = NULL;
}
rtnl_unlock();
static void wl_init_conf(struct wl_conf *conf)
{
- conf->mode = (uint32)-1;
- conf->frag_threshold = (uint32)-1;
- conf->rts_threshold = (uint32)-1;
- conf->retry_short = (uint32)-1;
- conf->retry_long = (uint32)-1;
+ conf->mode = (u32)-1;
+ conf->frag_threshold = (u32)-1;
+ conf->rts_threshold = (u32)-1;
+ conf->retry_short = (u32)-1;
+ conf->retry_long = (u32)-1;
conf->tx_power = -1;
}
el->handler[WLC_E_REASSOC_IND] = wl_notify_connect_status;
el->handler[WLC_E_ROAM] = wl_notify_roaming_status;
el->handler[WLC_E_MIC_ERROR] = wl_notify_mic_status;
+ el->handler[WLC_E_SET_SSID] = wl_notify_connect_status;
}
-static int32 wl_init_priv_mem(struct wl_priv *wl)
+static s32 wl_init_priv_mem(struct wl_priv *wl)
{
- wl->scan_results = (void *)kzalloc(WL_SCAN_BUF_MAX, GFP_KERNEL);
+ wl->scan_results = kzalloc(WL_SCAN_BUF_MAX, GFP_KERNEL);
if (unlikely(!wl->scan_results)) {
WL_ERR(("Scan results alloc failed\n"));
goto init_priv_mem_out;
}
- wl->conf = (void *)kzalloc(sizeof(*wl->conf), GFP_KERNEL);
+ wl->conf = kzalloc(sizeof(*wl->conf), GFP_KERNEL);
if (unlikely(!wl->conf)) {
WL_ERR(("wl_conf alloc failed\n"));
goto init_priv_mem_out;
}
- wl->profile = (void *)kzalloc(sizeof(*wl->profile), GFP_KERNEL);
+ wl->profile = kzalloc(sizeof(*wl->profile), GFP_KERNEL);
if (unlikely(!wl->profile)) {
WL_ERR(("wl_profile alloc failed\n"));
goto init_priv_mem_out;
}
- wl->bss_info = (void *)kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
+ wl->bss_info = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
if (unlikely(!wl->bss_info)) {
WL_ERR(("Bss information alloc failed\n"));
goto init_priv_mem_out;
}
- wl->scan_req_int =
- (void *)kzalloc(sizeof(*wl->scan_req_int), GFP_KERNEL);
+ wl->scan_req_int = kzalloc(sizeof(*wl->scan_req_int), GFP_KERNEL);
if (unlikely(!wl->scan_req_int)) {
WL_ERR(("Scan req alloc failed\n"));
goto init_priv_mem_out;
}
- wl->ioctl_buf = (void *)kzalloc(WL_IOCTL_LEN_MAX, GFP_KERNEL);
+ wl->ioctl_buf = kzalloc(WL_IOCTL_LEN_MAX, GFP_KERNEL);
if (unlikely(!wl->ioctl_buf)) {
WL_ERR(("Ioctl buf alloc failed\n"));
goto init_priv_mem_out;
}
- wl->extra_buf = (void *)kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
+ wl->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
if (unlikely(!wl->extra_buf)) {
WL_ERR(("Extra buf alloc failed\n"));
goto init_priv_mem_out;
}
- wl->iscan = (void *)kzalloc(sizeof(*wl->iscan), GFP_KERNEL);
+ wl->iscan = kzalloc(sizeof(*wl->iscan), GFP_KERNEL);
if (unlikely(!wl->iscan)) {
WL_ERR(("Iscan buf alloc failed\n"));
goto init_priv_mem_out;
}
- wl->fw = (void *)kzalloc(sizeof(*wl->fw), GFP_KERNEL);
+ wl->fw = kzalloc(sizeof(*wl->fw), GFP_KERNEL);
if (unlikely(!wl->fw)) {
WL_ERR(("fw object alloc failed\n"));
goto init_priv_mem_out;
}
- wl->pmk_list = (void *)kzalloc(sizeof(*wl->pmk_list), GFP_KERNEL);
+ wl->pmk_list = kzalloc(sizeof(*wl->pmk_list), GFP_KERNEL);
if (unlikely(!wl->pmk_list)) {
WL_ERR(("pmk list alloc failed\n"));
goto init_priv_mem_out;
wl->pmk_list = NULL;
}
-static int32 wl_create_event_handler(struct wl_priv *wl)
+static s32 wl_create_event_handler(struct wl_priv *wl)
{
sema_init(&wl->event_sync, 0);
- init_completion(&wl->event_exit);
- if (unlikely
- (((wl->event_pid = kernel_thread(wl_event_handler, wl, 0)) < 0))) {
+ wl->event_tsk = kthread_run(wl_event_handler, wl, "wl_event_handler");
+ if (IS_ERR(wl->event_tsk)) {
+ wl->event_tsk = NULL;
WL_ERR(("failed to create event thread\n"));
return -ENOMEM;
}
- WL_DBG(("pid %d\n", wl->event_pid));
return 0;
}
static void wl_destroy_event_handler(struct wl_priv *wl)
{
- if (wl->event_pid >= 0) {
- KILL_PROC(wl->event_pid, SIGTERM);
- wait_for_completion(&wl->event_exit);
+ if (wl->event_tsk) {
+ send_sig(SIGTERM, wl->event_tsk, 1);
+ kthread_stop(wl->event_tsk);
+ wl->event_tsk = NULL;
}
}
{
struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
- if (wl->iscan_on && iscan->pid >= 0) {
+ if (wl->iscan_on && iscan->tsk) {
iscan->state = WL_ISCAN_STATE_IDLE;
- KILL_PROC(iscan->pid, SIGTERM);
- wait_for_completion(&iscan->exited);
- iscan->pid = -1;
+ send_sig(SIGTERM, iscan->tsk, 1);
+ kthread_stop(iscan->tsk);
+ iscan->tsk = NULL;
}
}
static void wl_notify_iscan_complete(struct wl_iscan_ctrl *iscan, bool aborted)
{
struct wl_priv *wl = iscan_to_wl(iscan);
+ struct net_device *ndev = wl_to_ndev(wl);
if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
WL_ERR(("Scan complete while device not scanning\n"));
}
if (likely(wl->scan_request)) {
cfg80211_scan_done(wl->scan_request, aborted);
+ wl_set_mpc(ndev, 1);
wl->scan_request = NULL;
}
- wl->iscan_kickstart = FALSE;
+ wl->iscan_kickstart = false;
}
-static int32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan)
+static s32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan)
{
if (likely(iscan->state != WL_ISCAN_STATE_IDLE)) {
WL_DBG(("wake up iscan\n"));
return -EIO;
}
-static int32
-wl_get_iscan_results(struct wl_iscan_ctrl *iscan, uint32 *status,
+static s32
+wl_get_iscan_results(struct wl_iscan_ctrl *iscan, u32 *status,
struct wl_scan_results **bss_list)
{
struct wl_iscan_results list;
struct wl_scan_results *results;
struct wl_iscan_results *list_buf;
- int32 err = 0;
+ s32 err = 0;
memset(iscan->scan_buf, 0, WL_ISCAN_BUF_MAX);
list_buf = (struct wl_iscan_results *)iscan->scan_buf;
memset(&list, 0, sizeof(list));
list.results.buflen = htod32(WL_ISCAN_BUF_MAX);
- if (unlikely((err = wl_dev_iovar_getbuf(iscan->dev,
- "iscanresults",
- &list,
- WL_ISCAN_RESULTS_FIXED_SIZE,
- iscan->scan_buf,
- WL_ISCAN_BUF_MAX)))) {
+ err = wl_dev_iovar_getbuf(iscan->dev, "iscanresults", &list,
+ WL_ISCAN_RESULTS_FIXED_SIZE, iscan->scan_buf,
+ WL_ISCAN_BUF_MAX);
+ if (unlikely(err)) {
WL_ERR(("error (%d)\n", err));
return err;
}
return err;
}
-static int32 wl_iscan_done(struct wl_priv *wl)
+static s32 wl_iscan_done(struct wl_priv *wl)
{
struct wl_iscan_ctrl *iscan = wl->iscan;
- int32 err = 0;
+ s32 err = 0;
iscan->state = WL_ISCAN_STATE_IDLE;
rtnl_lock();
wl_inform_bss(wl);
- wl_notify_iscan_complete(iscan, FALSE);
+ wl_notify_iscan_complete(iscan, false);
rtnl_unlock();
return err;
}
-static int32 wl_iscan_pending(struct wl_priv *wl)
+static s32 wl_iscan_pending(struct wl_priv *wl)
{
struct wl_iscan_ctrl *iscan = wl->iscan;
- int32 err = 0;
+ s32 err = 0;
/* Reschedule the timer */
mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
return err;
}
-static int32 wl_iscan_inprogress(struct wl_priv *wl)
+static s32 wl_iscan_inprogress(struct wl_priv *wl)
{
struct wl_iscan_ctrl *iscan = wl->iscan;
- int32 err = 0;
+ s32 err = 0;
rtnl_lock();
wl_inform_bss(wl);
return err;
}
-static int32 wl_iscan_aborted(struct wl_priv *wl)
+static s32 wl_iscan_aborted(struct wl_priv *wl)
{
struct wl_iscan_ctrl *iscan = wl->iscan;
- int32 err = 0;
+ s32 err = 0;
iscan->state = WL_ISCAN_STATE_IDLE;
rtnl_lock();
- wl_notify_iscan_complete(iscan, TRUE);
+ wl_notify_iscan_complete(iscan, true);
rtnl_unlock();
return err;
}
-static int32 wl_iscan_thread(void *data)
+static s32 wl_iscan_thread(void *data)
{
struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
struct wl_iscan_ctrl *iscan = (struct wl_iscan_ctrl *)data;
struct wl_priv *wl = iscan_to_wl(iscan);
struct wl_iscan_eloop *el = &iscan->el;
- uint32 status;
+ u32 status;
int err = 0;
sched_setscheduler(current, SCHED_FIFO, ¶m);
+ allow_signal(SIGTERM);
status = WL_SCAN_RESULTS_PARTIAL;
while (likely(!down_interruptible(&iscan->sync))) {
+ if (kthread_should_stop())
+ break;
if (iscan->timer_on) {
del_timer_sync(&iscan->timer);
iscan->timer_on = 0;
}
rtnl_lock();
- if (unlikely
- ((err =
- wl_get_iscan_results(iscan, &status, &wl->bss_list)))) {
+ err = wl_get_iscan_results(iscan, &status, &wl->bss_list);
+ if (unlikely(err)) {
status = WL_SCAN_RESULTS_ABORTED;
WL_ERR(("Abort iscan\n"));
}
del_timer_sync(&iscan->timer);
iscan->timer_on = 0;
}
- complete_and_exit(&iscan->exited, 0);
+ WL_DBG(("%s was terminated\n", __func__));
return 0;
}
}
}
-static int32 wl_invoke_iscan(struct wl_priv *wl)
+static s32 wl_invoke_iscan(struct wl_priv *wl)
{
struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
int err = 0;
- if (wl->iscan_on && iscan->pid < 0) {
+ if (wl->iscan_on && !iscan->tsk) {
iscan->state = WL_ISCAN_STATE_IDLE;
sema_init(&iscan->sync, 0);
- init_completion(&iscan->exited);
- iscan->pid = kernel_thread(wl_iscan_thread, iscan, 0);
- if (unlikely(iscan->pid < 0)) {
+ iscan->tsk = kthread_run(wl_iscan_thread, iscan, "wl_iscan");
+ if (IS_ERR(iscan->tsk)) {
WL_ERR(("Could not create iscan thread\n"));
+ iscan->tsk = NULL;
return -ENOMEM;
}
}
el->handler[WL_SCAN_RESULTS_NO_MEM] = wl_iscan_aborted;
}
-static int32 wl_init_iscan(struct wl_priv *wl)
+static s32 wl_init_iscan(struct wl_priv *wl)
{
struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
int err = 0;
iscan->timer.data = (unsigned long) iscan;
iscan->timer.function = wl_iscan_timer;
sema_init(&iscan->sync, 0);
- init_completion(&iscan->exited);
- iscan->pid = kernel_thread(wl_iscan_thread, iscan, 0);
- if (unlikely(iscan->pid < 0)) {
+ iscan->tsk = kthread_run(wl_iscan_thread, iscan, "wl_iscan");
+ if (IS_ERR(iscan->tsk)) {
WL_ERR(("Could not create iscan thread\n"));
+ iscan->tsk = NULL;
return -ENOMEM;
}
iscan->data = wl;
0 means nothing was loaded yet */
}
-static int32 wl_init_priv(struct wl_priv *wl)
+static s32 wl_init_priv(struct wl_priv *wl)
{
struct wiphy *wiphy = wl_to_wiphy(wl);
- int32 err = 0;
+ s32 err = 0;
wl->scan_request = NULL;
wl->pwr_save = !!(wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT);
-#ifndef WL_ISCAN_DISABLED
- wl->iscan_on = TRUE; /* iscan on & off switch.
+ wl->iscan_on = true; /* iscan on & off switch.
we enable iscan per default */
-#else
- wl->iscan_on = FALSE;
-#endif /* WL_ISCAN_DISABLED */
-#ifndef WL_ROAM_DISABLED
- wl->roam_on = TRUE; /* roam on & off switch.
+ wl->roam_on = false; /* roam on & off switch.
we enable roam per default */
-#else
- wl->roam_on = FALSE;
-#endif /* WL_ROAM_DISABLED */
- wl->iscan_kickstart = FALSE;
- wl->active_scan = TRUE; /* we do active scan for
+ wl->iscan_kickstart = false;
+ wl->active_scan = true; /* we do active scan for
specific scan per default */
- wl->dongle_up = FALSE; /* dongle is not up yet */
+ wl->dongle_up = false; /* dongle is not up yet */
wl_init_eq(wl);
- if (unlikely((err = wl_init_priv_mem(wl))))
+ err = wl_init_priv_mem(wl);
+ if (unlikely(err))
return err;
if (unlikely(wl_create_event_handler(wl)))
return -ENOMEM;
wl_init_eloop_handler(&wl->el);
mutex_init(&wl->usr_sync);
- if (unlikely((err = wl_init_iscan(wl))))
+ err = wl_init_iscan(wl);
+ if (unlikely(err))
return err;
wl_init_fw(wl->fw);
wl_init_conf(wl->conf);
static void wl_deinit_priv(struct wl_priv *wl)
{
wl_destroy_event_handler(wl);
- wl->dongle_up = FALSE; /* dongle down */
+ wl->dongle_up = false; /* dongle down */
wl_flush_eq(wl);
wl_link_down(wl);
wl_term_iscan(wl);
wl_deinit_priv_mem(wl);
}
-int32 wl_cfg80211_attach(struct net_device *ndev, void *data)
+s32 wl_cfg80211_attach(struct net_device *ndev, void *data)
{
struct wireless_dev *wdev;
struct wl_priv *wl;
struct wl_iface *ci;
- int32 err = 0;
+ s32 err = 0;
if (unlikely(!ndev)) {
WL_ERR(("ndev is invaild\n"));
ndev->ieee80211_ptr = wdev;
SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));
wdev->netdev = ndev;
- if (unlikely((err = wl_init_priv(wl)))) {
+ err = wl_init_priv(wl);
+ if (unlikely(err)) {
WL_ERR(("Failed to init iwm_priv (%d)\n", err));
goto cfg80211_attach_out;
}
up(&wl->event_sync);
}
-static int32 wl_event_handler(void *data)
+static s32 wl_event_handler(void *data)
{
struct wl_priv *wl = (struct wl_priv *)data;
struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
struct wl_event_q *e;
sched_setscheduler(current, SCHED_FIFO, ¶m);
+ allow_signal(SIGTERM);
while (likely(!down_interruptible(&wl->event_sync))) {
- if (unlikely(!(e = wl_deq_event(wl)))) {
+ if (kthread_should_stop())
+ break;
+ e = wl_deq_event(wl);
+ if (unlikely(!e)) {
WL_ERR(("eqeue empty..\n"));
BUG();
}
}
wl_put_event(e);
}
- complete_and_exit(&wl->event_exit, 0);
+ WL_DBG(("%s was terminated\n", __func__));
+ return 0;
}
void
wl_cfg80211_event(struct net_device *ndev, const wl_event_msg_t * e, void *data)
{
- uint32 event_type = ntoh32(e->event_type);
+ u32 event_type = ntoh32(e->event_type);
struct wl_priv *wl = ndev_to_wl(ndev);
#if (WL_DBG_LEVEL > 0)
s8 *estr = (event_type <= sizeof(wl_dbg_estr) / WL_DBG_ESTR_MAX - 1) ?
** push event to tail of the queue
*/
-static int32
-wl_enq_event(struct wl_priv *wl, uint32 event, const wl_event_msg_t *msg,
+static s32
+wl_enq_event(struct wl_priv *wl, u32 event, const wl_event_msg_t *msg,
void *data)
{
struct wl_event_q *e;
- int32 err = 0;
+ s32 err = 0;
- if (unlikely(!(e = kzalloc(sizeof(struct wl_event_q), GFP_KERNEL)))) {
+ e = kzalloc(sizeof(struct wl_event_q), GFP_KERNEL);
+ if (unlikely(!e)) {
WL_ERR(("event alloc failed\n"));
return -ENOMEM;
}
return cfg80211_sdio_func;
}
-static int32 wl_dongle_mode(struct net_device *ndev, int32 iftype)
+static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype)
{
- int32 infra = 0;
- int32 ap = 0;
- int32 err = 0;
+ s32 infra = 0;
+ s32 ap = 0;
+ s32 err = 0;
switch (iftype) {
case NL80211_IFTYPE_MONITOR:
infra = htod32(infra);
ap = htod32(ap);
WL_DBG(("%s ap (%d), infra (%d)\n", ndev->name, ap, infra));
- if (unlikely
- (err = wl_dev_ioctl(ndev, WLC_SET_INFRA, &infra, sizeof(infra)))
- || unlikely
- (err = wl_dev_ioctl(ndev, WLC_SET_AP, &ap, sizeof(ap)))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_INFRA, &infra, sizeof(infra));
+ if (unlikely(err)) {
WL_ERR(("WLC_SET_INFRA error (%d)\n", err));
return err;
}
+ err = wl_dev_ioctl(ndev, WLC_SET_AP, &ap, sizeof(ap));
+ if (unlikely(err)) {
+ WL_ERR(("WLC_SET_AP error (%d)\n", err));
+ return err;
+ }
return -EINPROGRESS;
}
#ifndef EMBEDDED_PLATFORM
-static int32 wl_dongle_country(struct net_device *ndev, u8 ccode)
+static s32 wl_dongle_country(struct net_device *ndev, u8 ccode)
{
- int32 err = 0;
+ s32 err = 0;
return err;
}
-static int32 wl_dongle_up(struct net_device *ndev, uint32 up)
+static s32 wl_dongle_up(struct net_device *ndev, u32 up)
{
- int32 err = 0;
+ s32 err = 0;
- if (unlikely(err = wl_dev_ioctl(ndev, WLC_UP, &up, sizeof(up)))) {
+ err = wl_dev_ioctl(ndev, WLC_UP, &up, sizeof(up));
+ if (unlikely(err)) {
WL_ERR(("WLC_UP error (%d)\n", err));
}
return err;
}
-static int32 wl_dongle_power(struct net_device *ndev, uint32 power_mode)
+static s32 wl_dongle_power(struct net_device *ndev, u32 power_mode)
{
- int32 err = 0;
+ s32 err = 0;
- if (unlikely
- (err =
- wl_dev_ioctl(ndev, WLC_SET_PM, &power_mode, sizeof(power_mode)))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_PM, &power_mode, sizeof(power_mode));
+ if (unlikely(err)) {
WL_ERR(("WLC_SET_PM error (%d)\n", err));
}
return err;
}
-static int32
-wl_dongle_glom(struct net_device *ndev, uint32 glom, uint32 dongle_align)
+static s32
+wl_dongle_glom(struct net_device *ndev, u32 glom, u32 dongle_align)
{
s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
'\0' + bitvec */
- int32 err = 0;
+ s32 err = 0;
/* Match Host and Dongle rx alignment */
bcm_mkiovar("bus:txglomalign", (char *)&dongle_align, 4, iovbuf,
sizeof(iovbuf));
- if (unlikely
- (err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf)))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
+ if (unlikely(err)) {
WL_ERR(("txglomalign error (%d)\n", err));
goto dongle_glom_out;
}
/* disable glom option per default */
bcm_mkiovar("bus:txglom", (char *)&glom, 4, iovbuf, sizeof(iovbuf));
- if (unlikely
- (err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf)))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
+ if (unlikely(err)) {
WL_ERR(("txglom error (%d)\n", err));
goto dongle_glom_out;
}
return err;
}
-static int32
-wl_dongle_roam(struct net_device *ndev, uint32 roamvar, uint32 bcn_timeout)
+static s32
+wl_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout)
{
s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
'\0' + bitvec */
- int32 err = 0;
+ s32 err = 0;
/* Setup timeout if Beacons are lost and roam is
off to report link down */
if (roamvar) {
bcm_mkiovar("bcn_timeout", (char *)&bcn_timeout, 4, iovbuf,
sizeof(iovbuf));
- if (unlikely
- (err =
- wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf)))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
+ if (unlikely(err)) {
WL_ERR(("bcn_timeout error (%d)\n", err));
goto dongle_rom_out;
}
/* Enable/Disable built-in roaming to allow supplicant
to take care of roaming */
bcm_mkiovar("roam_off", (char *)&roamvar, 4, iovbuf, sizeof(iovbuf));
- if (unlikely
- (err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf)))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
+ if (unlikely(err)) {
WL_ERR(("roam_off error (%d)\n", err));
goto dongle_rom_out;
}
return err;
}
-static int32 wl_dongle_eventmsg(struct net_device *ndev)
+static s32 wl_dongle_eventmsg(struct net_device *ndev)
{
s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
'\0' + bitvec */
s8 eventmask[WL_EVENTING_MASK_LEN];
- int32 err = 0;
+ s32 err = 0;
/* Setup event_msgs */
bcm_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
sizeof(iovbuf));
- if (unlikely
- (err = wl_dev_ioctl(ndev, WLC_GET_VAR, iovbuf, sizeof(iovbuf)))) {
+ err = wl_dev_ioctl(ndev, WLC_GET_VAR, iovbuf, sizeof(iovbuf));
+ if (unlikely(err)) {
WL_ERR(("Get event_msgs error (%d)\n", err));
goto dongle_eventmsg_out;
}
bcm_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
sizeof(iovbuf));
- if (unlikely
- (err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf)))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
+ if (unlikely(err)) {
WL_ERR(("Set event_msgs error (%d)\n", err));
goto dongle_eventmsg_out;
}
return err;
}
-static int32
-wl_dongle_scantime(struct net_device *ndev, int32 scan_assoc_time,
- int32 scan_unassoc_time)
+static s32
+wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
+ s32 scan_unassoc_time)
{
- int32 err = 0;
+ s32 err = 0;
- if ((err =
- wl_dev_ioctl(ndev, WLC_SET_SCAN_CHANNEL_TIME, &scan_assoc_time,
- sizeof(scan_assoc_time)))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_SCAN_CHANNEL_TIME, &scan_assoc_time,
+ sizeof(scan_assoc_time));
+ if (err) {
if (err == -EOPNOTSUPP) {
WL_INFO(("Scan assoc time is not supported\n"));
} else {
}
goto dongle_scantime_out;
}
- if ((err =
- wl_dev_ioctl(ndev, WLC_SET_SCAN_UNASSOC_TIME, &scan_unassoc_time,
- sizeof(scan_unassoc_time)))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_SCAN_UNASSOC_TIME, &scan_unassoc_time,
+ sizeof(scan_unassoc_time));
+ if (err) {
if (err == -EOPNOTSUPP) {
WL_INFO(("Scan unassoc time is not supported\n"));
} else {
return err;
}
-static int32
-wl_dongle_offload(struct net_device *ndev, int32 arpoe, int32 arp_ol)
+static s32
+wl_dongle_offload(struct net_device *ndev, s32 arpoe, s32 arp_ol)
{
s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
'\0' + bitvec */
- int32 err = 0;
+ s32 err = 0;
/* Set ARP offload */
bcm_mkiovar("arpoe", (char *)&arpoe, 4, iovbuf, sizeof(iovbuf));
- if ((err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf)))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
+ if (err) {
if (err == -EOPNOTSUPP)
WL_INFO(("arpoe is not supported\n"));
else
goto dongle_offload_out;
}
bcm_mkiovar("arp_ol", (char *)&arp_ol, 4, iovbuf, sizeof(iovbuf));
- if ((err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf)))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
+ if (err) {
if (err == -EOPNOTSUPP)
WL_INFO(("arp_ol is not supported\n"));
else
return err;
}
-static int32 wl_pattern_atoh(s8 *src, s8 *dst)
+static s32 wl_pattern_atoh(s8 *src, s8 *dst)
{
-#define strtoul(nptr, endptr, base) bcm_strtoul((nptr), (endptr), (base))
int i;
if (strncmp(src, "0x", 2) != 0 && strncmp(src, "0X", 2) != 0) {
WL_ERR(("Mask invalid format. Needs to start with 0x\n"));
char num[3];
strncpy(num, src, 2);
num[2] = '\0';
- dst[i] = (u8) strtoul(num, NULL, 16);
+ dst[i] = (u8) simple_strtoul(num, NULL, 16);
src += 2;
}
return i;
}
-static int32 wl_dongle_filter(struct net_device *ndev, uint32 filter_mode)
+static s32 wl_dongle_filter(struct net_device *ndev, u32 filter_mode)
{
s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
'\0' + bitvec */
const s8 *str;
struct wl_pkt_filter pkt_filter;
struct wl_pkt_filter *pkt_filterp;
- int32 buf_len;
- int32 str_len;
- uint32 mask_size;
- uint32 pattern_size;
+ s32 buf_len;
+ s32 str_len;
+ u32 mask_size;
+ u32 pattern_size;
s8 buf[256];
- int32 err = 0;
+ s32 err = 0;
/* add a default packet filter pattern */
str = "pkt_filter_add";
memcpy((char *)pkt_filterp, &pkt_filter,
WL_PKT_FILTER_FIXED_LEN + WL_PKT_FILTER_PATTERN_FIXED_LEN);
- if ((err = wl_dev_ioctl(ndev, WLC_SET_VAR, buf, buf_len))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_VAR, buf, buf_len);
+ if (err) {
if (err == -EOPNOTSUPP) {
WL_INFO(("filter not supported\n"));
} else {
/* set mode to allow pattern */
bcm_mkiovar("pkt_filter_mode", (char *)&filter_mode, 4, iovbuf,
sizeof(iovbuf));
- if ((err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf)))) {
+ err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
+ if (err) {
if (err == -EOPNOTSUPP) {
WL_INFO(("filter_mode not supported\n"));
} else {
}
#endif /* !EMBEDDED_PLATFORM */
-int32 wl_config_dongle(struct wl_priv *wl, bool need_lock)
+s32 wl_config_dongle(struct wl_priv *wl, bool need_lock)
{
#ifndef DHD_SDALIGN
#define DHD_SDALIGN 32
#endif
struct net_device *ndev;
struct wireless_dev *wdev;
- int32 err = 0;
+ s32 err = 0;
if (wl->dongle_up)
return err;
rtnl_lock();
#ifndef EMBEDDED_PLATFORM
- if (unlikely((err = wl_dongle_up(ndev, 0))))
+ err = wl_dongle_up(ndev, 0);
+ if (unlikely(err))
goto default_conf_out;
- if (unlikely((err = wl_dongle_country(ndev, 0))))
+ err = wl_dongle_country(ndev, 0);
+ if (unlikely(err))
goto default_conf_out;
- if (unlikely((err = wl_dongle_power(ndev, PM_FAST))))
+ err = wl_dongle_power(ndev, PM_FAST);
+ if (unlikely(err))
goto default_conf_out;
- if (unlikely((err = wl_dongle_glom(ndev, 0, DHD_SDALIGN))))
+ err = wl_dongle_glom(ndev, 0, DHD_SDALIGN);
+ if (unlikely(err))
goto default_conf_out;
- if (unlikely((err = wl_dongle_roam(ndev, (wl->roam_on ? 0 : 1), 3))))
+ err = wl_dongle_roam(ndev, (wl->roam_on ? 0 : 1), 3);
+ if (unlikely(err))
goto default_conf_out;
- if (unlikely((err = wl_dongle_eventmsg(ndev))))
+ err = wl_dongle_eventmsg(ndev);
+ if (unlikely(err))
goto default_conf_out;
wl_dongle_scantime(ndev, 40, 80);
err = wl_dongle_mode(ndev, wdev->iftype);
if (unlikely(err && err != -EINPROGRESS))
goto default_conf_out;
- if (unlikely((err = wl_dongle_probecap(wl))))
+ err = wl_dongle_probecap(wl);
+ if (unlikely(err))
goto default_conf_out;
/* -EINPROGRESS: Call commit handler */
if (need_lock)
rtnl_unlock();
- wl->dongle_up = TRUE;
+ wl->dongle_up = true;
return err;
}
-static int32 wl_update_wiphybands(struct wl_priv *wl)
+static s32 wl_update_wiphybands(struct wl_priv *wl)
{
struct wiphy *wiphy;
- int32 phy_list;
+ s32 phy_list;
s8 phy;
- int32 err = 0;
+ s32 err = 0;
- if (unlikely
- (err =
- wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_PHYLIST, &phy_list,
- sizeof(phy_list)))) {
+ err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_PHYLIST, &phy_list,
+ sizeof(phy_list));
+ if (unlikely(err)) {
WL_ERR(("error (%d)\n", err));
return err;
}
return err;
}
-static int32 __wl_cfg80211_up(struct wl_priv *wl)
+static s32 __wl_cfg80211_up(struct wl_priv *wl)
{
- int32 err = 0;
+ s32 err = 0;
+
+ wl_debugfs_add_netdev_params(wl);
- if (unlikely(err = wl_config_dongle(wl, FALSE)))
+ err = wl_config_dongle(wl, false);
+ if (unlikely(err))
return err;
wl_invoke_iscan(wl);
return err;
}
-static int32 __wl_cfg80211_down(struct wl_priv *wl)
+static s32 __wl_cfg80211_down(struct wl_priv *wl)
{
- int32 err = 0;
+ s32 err = 0;
/* Check if cfg80211 interface is already down */
if (!test_bit(WL_STATUS_READY, &wl->status))
set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
wl_term_iscan(wl);
if (wl->scan_request) {
- cfg80211_scan_done(wl->scan_request, TRUE); /* TRUE
+ cfg80211_scan_done(wl->scan_request, true); /* true
means abort */
+ /* wl_set_mpc(wl_to_ndev(wl), 1); */ /* BUG
+ * this operation cannot help
+ * but here because sdio
+ * is already down through
+ * rmmod process.
+ * Need to figure out how to
+ * address this issue
+ */
wl->scan_request = NULL;
}
clear_bit(WL_STATUS_READY, &wl->status);
clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
clear_bit(WL_STATUS_CONNECTED, &wl->status);
+ wl_debugfs_remove_netdev(wl);
+
return err;
}
-int32 wl_cfg80211_up(void)
+s32 wl_cfg80211_up(void)
{
struct wl_priv *wl;
- int32 err = 0;
+ s32 err = 0;
wl = WL_PRIV_GET();
mutex_lock(&wl->usr_sync);
return err;
}
-int32 wl_cfg80211_down(void)
+s32 wl_cfg80211_down(void)
{
struct wl_priv *wl;
- int32 err = 0;
+ s32 err = 0;
wl = WL_PRIV_GET();
mutex_lock(&wl->usr_sync);
return err;
}
-static int32 wl_dongle_probecap(struct wl_priv *wl)
+static s32 wl_dongle_probecap(struct wl_priv *wl)
{
- int32 err = 0;
+ s32 err = 0;
- if (unlikely((err = wl_update_wiphybands(wl))))
+ err = wl_update_wiphybands(wl);
+ if (unlikely(err))
return err;
return err;
}
-static void *wl_read_prof(struct wl_priv *wl, int32 item)
+static void *wl_read_prof(struct wl_priv *wl, s32 item)
{
switch (item) {
case WL_PROF_SEC:
return NULL;
}
-static int32
+static s32
wl_update_prof(struct wl_priv *wl, const wl_event_msg_t *e, void *data,
- int32 item)
+ s32 item)
{
- int32 err = 0;
+ s32 err = 0;
struct wlc_ssid *ssid;
switch (item) {
memcpy(&wl->profile->sec, data, sizeof(wl->profile->sec));
break;
case WL_PROF_ACT:
- wl->profile->active = *(bool *) data;
+ wl->profile->active = *(bool *)data;
+ break;
+ case WL_PROF_BEACONINT:
+ wl->profile->beacon_interval = *(u16 *)data;
+ break;
+ case WL_PROF_DTIMPERIOD:
+ wl->profile->dtim_period = *(u8 *)data;
break;
default:
WL_ERR(("unsupported item (%d)\n", item));
return err;
}
-void wl_cfg80211_dbg_level(uint32 level)
+void wl_cfg80211_dbg_level(u32 level)
{
- wl_dbg_level = level;
+ /*
+ * prohibit to change debug level
+ * by insmod parameter.
+ * eventually debug level will be configured
+ * in compile time by using CONFIG_XXX
+ */
+ /* wl_dbg_level = level; */
}
static bool wl_is_ibssmode(struct wl_priv *wl)
ie->offset = 0;
}
-static int32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v)
+static __used s32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v)
{
struct wl_ie *ie = wl_to_ie(wl);
- int32 err = 0;
+ s32 err = 0;
if (unlikely(ie->offset + l + 2 > WL_TLV_INFO_MAX)) {
WL_ERR(("ei crosses buffer boundary\n"));
return err;
}
-static int32 wl_mrg_ie(struct wl_priv *wl, u8 *ie_stream, uint16 ie_size)
+static s32 wl_mrg_ie(struct wl_priv *wl, u8 *ie_stream, u16 ie_size)
{
struct wl_ie *ie = wl_to_ie(wl);
- int32 err = 0;
+ s32 err = 0;
if (unlikely(ie->offset + ie_size > WL_TLV_INFO_MAX)) {
WL_ERR(("ei_stream crosses buffer boundary\n"));
return err;
}
-static int32 wl_cp_ie(struct wl_priv *wl, u8 *dst, uint16 dst_size)
+static s32 wl_cp_ie(struct wl_priv *wl, u8 *dst, u16 dst_size)
{
struct wl_ie *ie = wl_to_ie(wl);
- int32 err = 0;
+ s32 err = 0;
if (unlikely(ie->offset > dst_size)) {
WL_ERR(("dst_size is not enough\n"));
return err;
}
-static uint32 wl_get_ielen(struct wl_priv *wl)
+static u32 wl_get_ielen(struct wl_priv *wl)
{
struct wl_ie *ie = wl_to_ie(wl);
static void wl_link_up(struct wl_priv *wl)
{
- wl->link_up = TRUE;
+ wl->link_up = true;
}
static void wl_link_down(struct wl_priv *wl)
{
struct wl_connect_info *conn_info = wl_to_conn(wl);
- wl->link_up = FALSE;
+ wl->link_up = false;
kfree(conn_info->req_ie);
conn_info->req_ie = NULL;
conn_info->req_ie_len = 0;
spin_lock_init(&wl->eq_lock);
}
-static void wl_delay(uint32 ms)
+static void wl_delay(u32 ms)
{
if (ms < 1000 / HZ) {
cond_resched();
return dev->driver_data;
}
-int32 wl_cfg80211_read_fw(s8 *buf, uint32 size)
+s32 wl_cfg80211_read_fw(s8 *buf, u32 size)
{
const struct firmware *fw_entry;
struct wl_priv *wl;
{
struct wl_priv *wl;
const struct firmware *fw_entry = NULL;
- int32 err = 0;
+ s32 err = 0;
WL_DBG(("file name : \"%s\"\n", file_name));
wl = WL_PRIV_GET();
if (!test_bit(WL_FW_LOADING_DONE, &wl->fw->status)) {
- if (unlikely
- (err =
- request_firmware(&wl->fw->fw_entry, file_name,
- &wl_cfg80211_get_sdio_func()->dev))) {
+ err = request_firmware(&wl->fw->fw_entry, file_name,
+ &wl_cfg80211_get_sdio_func()->dev);
+ if (unlikely(err)) {
WL_ERR(("Could not download fw (%d)\n", err));
goto req_fw_out;
}
set_bit(WL_FW_LOADING_DONE, &wl->fw->status);
fw_entry = wl->fw->fw_entry;
if (fw_entry) {
- WL_DBG(("fw size (%d), data (%p)\n", fw_entry->size,
+ WL_DBG(("fw size (%zd), data (%p)\n", fw_entry->size,
fw_entry->data));
}
} else if (!test_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status)) {
- if (unlikely
- (err =
- request_firmware(&wl->fw->fw_entry, file_name,
- &wl_cfg80211_get_sdio_func()->dev))) {
+ err = request_firmware(&wl->fw->fw_entry, file_name,
+ &wl_cfg80211_get_sdio_func()->dev);
+ if (unlikely(err)) {
WL_ERR(("Could not download nvram (%d)\n", err));
goto req_fw_out;
}
set_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status);
fw_entry = wl->fw->fw_entry;
if (fw_entry) {
- WL_DBG(("nvram size (%d), data (%p)\n", fw_entry->size,
+ WL_DBG(("nvram size (%zd), data (%p)\n", fw_entry->size,
fw_entry->data));
}
} else {
strcpy(wl->fw->nvram_name, WL_4329_NVRAM_FILE);
return wl->fw->nvram_name;
}
+
+static void wl_set_mpc(struct net_device *ndev, int mpc)
+{
+ s32 err = 0;
+
+ err = wl_dev_intvar_set(ndev, "mpc", mpc);
+ if (unlikely(err)) {
+ WL_ERR(("fail to set mpc\n"));
+ return;
+ }
+ WL_DBG(("MPC : %d\n", mpc));
+}
+
+static int wl_debugfs_add_netdev_params(struct wl_priv *wl)
+{
+ char buf[10+IFNAMSIZ];
+ struct dentry *fd;
+ s32 err = 0;
+
+ sprintf(buf, "netdev:%s", wl_to_ndev(wl)->name);
+ wl->debugfsdir = debugfs_create_dir(buf, wl_to_wiphy(wl)->debugfsdir);
+
+ fd = debugfs_create_u16("beacon_int", S_IRUGO, wl->debugfsdir,
+ (u16 *)&wl->profile->beacon_interval);
+ if (!fd) {
+ err = -ENOMEM;
+ goto err_out;
+ }
+
+ fd = debugfs_create_u8("dtim_period", S_IRUGO, wl->debugfsdir,
+ (u8 *)&wl->profile->dtim_period);
+ if (!fd) {
+ err = -ENOMEM;
+ goto err_out;
+ }
+
+err_out:
+ return err;
+}
+
+static void wl_debugfs_remove_netdev(struct wl_priv *wl)
+{
+ debugfs_remove_recursive(wl->debugfsdir);
+ wl->debugfsdir = NULL;
+}
projects / mv-sheeva.git / blobdiff