diff options
Diffstat (limited to 'drivers/net/wireless/libertas/main.c')
| -rw-r--r-- | drivers/net/wireless/libertas/main.c | 1438 |
1 files changed, 704 insertions, 734 deletions
diff --git a/drivers/net/wireless/libertas/main.c b/drivers/net/wireless/libertas/main.c index 1823b48a8ba..84fb49ca0fa 100644 --- a/drivers/net/wireless/libertas/main.c +++ b/drivers/net/wireless/libertas/main.c @@ -6,7 +6,6 @@ #include <linux/moduleparam.h> #include <linux/delay.h> -#include <linux/freezer.h> #include <linux/etherdevice.h> #include <linux/netdevice.h> #include <linux/if_arp.h> @@ -22,9 +21,10 @@ #include "debugfs.h" #include "assoc.h" #include "join.h" +#include "cmd.h" #define DRIVER_RELEASE_VERSION "323.p0" -const char libertas_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION +const char lbs_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION #ifdef DEBUG "-dbg" #endif @@ -32,80 +32,80 @@ const char libertas_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION /* Module parameters */ -unsigned int libertas_debug = 0; -module_param(libertas_debug, int, 0644); -EXPORT_SYMBOL_GPL(libertas_debug); +unsigned int lbs_debug; +EXPORT_SYMBOL_GPL(lbs_debug); +module_param_named(libertas_debug, lbs_debug, int, 0644); -#define WLAN_TX_PWR_DEFAULT 20 /*100mW */ -#define WLAN_TX_PWR_US_DEFAULT 20 /*100mW */ -#define WLAN_TX_PWR_JP_DEFAULT 16 /*50mW */ -#define WLAN_TX_PWR_FR_DEFAULT 20 /*100mW */ -#define WLAN_TX_PWR_EMEA_DEFAULT 20 /*100mW */ +#define LBS_TX_PWR_DEFAULT 20 /*100mW */ +#define LBS_TX_PWR_US_DEFAULT 20 /*100mW */ +#define LBS_TX_PWR_JP_DEFAULT 16 /*50mW */ +#define LBS_TX_PWR_FR_DEFAULT 20 /*100mW */ +#define LBS_TX_PWR_EMEA_DEFAULT 20 /*100mW */ /* Format { channel, frequency (MHz), maxtxpower } */ /* band: 'B/G', region: USA FCC/Canada IC */ static struct chan_freq_power channel_freq_power_US_BG[] = { - {1, 2412, WLAN_TX_PWR_US_DEFAULT}, - {2, 2417, WLAN_TX_PWR_US_DEFAULT}, - {3, 2422, WLAN_TX_PWR_US_DEFAULT}, - {4, 2427, WLAN_TX_PWR_US_DEFAULT}, - {5, 2432, WLAN_TX_PWR_US_DEFAULT}, - {6, 2437, WLAN_TX_PWR_US_DEFAULT}, - {7, 2442, WLAN_TX_PWR_US_DEFAULT}, - {8, 2447, WLAN_TX_PWR_US_DEFAULT}, - {9, 2452, WLAN_TX_PWR_US_DEFAULT}, - {10, 2457, WLAN_TX_PWR_US_DEFAULT}, - {11, 2462, WLAN_TX_PWR_US_DEFAULT} + {1, 2412, LBS_TX_PWR_US_DEFAULT}, + {2, 2417, LBS_TX_PWR_US_DEFAULT}, + {3, 2422, LBS_TX_PWR_US_DEFAULT}, + {4, 2427, LBS_TX_PWR_US_DEFAULT}, + {5, 2432, LBS_TX_PWR_US_DEFAULT}, + {6, 2437, LBS_TX_PWR_US_DEFAULT}, + {7, 2442, LBS_TX_PWR_US_DEFAULT}, + {8, 2447, LBS_TX_PWR_US_DEFAULT}, + {9, 2452, LBS_TX_PWR_US_DEFAULT}, + {10, 2457, LBS_TX_PWR_US_DEFAULT}, + {11, 2462, LBS_TX_PWR_US_DEFAULT} }; /* band: 'B/G', region: Europe ETSI */ static struct chan_freq_power channel_freq_power_EU_BG[] = { - {1, 2412, WLAN_TX_PWR_EMEA_DEFAULT}, - {2, 2417, WLAN_TX_PWR_EMEA_DEFAULT}, - {3, 2422, WLAN_TX_PWR_EMEA_DEFAULT}, - {4, 2427, WLAN_TX_PWR_EMEA_DEFAULT}, - {5, 2432, WLAN_TX_PWR_EMEA_DEFAULT}, - {6, 2437, WLAN_TX_PWR_EMEA_DEFAULT}, - {7, 2442, WLAN_TX_PWR_EMEA_DEFAULT}, - {8, 2447, WLAN_TX_PWR_EMEA_DEFAULT}, - {9, 2452, WLAN_TX_PWR_EMEA_DEFAULT}, - {10, 2457, WLAN_TX_PWR_EMEA_DEFAULT}, - {11, 2462, WLAN_TX_PWR_EMEA_DEFAULT}, - {12, 2467, WLAN_TX_PWR_EMEA_DEFAULT}, - {13, 2472, WLAN_TX_PWR_EMEA_DEFAULT} + {1, 2412, LBS_TX_PWR_EMEA_DEFAULT}, + {2, 2417, LBS_TX_PWR_EMEA_DEFAULT}, + {3, 2422, LBS_TX_PWR_EMEA_DEFAULT}, + {4, 2427, LBS_TX_PWR_EMEA_DEFAULT}, + {5, 2432, LBS_TX_PWR_EMEA_DEFAULT}, + {6, 2437, LBS_TX_PWR_EMEA_DEFAULT}, + {7, 2442, LBS_TX_PWR_EMEA_DEFAULT}, + {8, 2447, LBS_TX_PWR_EMEA_DEFAULT}, + {9, 2452, LBS_TX_PWR_EMEA_DEFAULT}, + {10, 2457, LBS_TX_PWR_EMEA_DEFAULT}, + {11, 2462, LBS_TX_PWR_EMEA_DEFAULT}, + {12, 2467, LBS_TX_PWR_EMEA_DEFAULT}, + {13, 2472, LBS_TX_PWR_EMEA_DEFAULT} }; /* band: 'B/G', region: Spain */ static struct chan_freq_power channel_freq_power_SPN_BG[] = { - {10, 2457, WLAN_TX_PWR_DEFAULT}, - {11, 2462, WLAN_TX_PWR_DEFAULT} + {10, 2457, LBS_TX_PWR_DEFAULT}, + {11, 2462, LBS_TX_PWR_DEFAULT} }; /* band: 'B/G', region: France */ static struct chan_freq_power channel_freq_power_FR_BG[] = { - {10, 2457, WLAN_TX_PWR_FR_DEFAULT}, - {11, 2462, WLAN_TX_PWR_FR_DEFAULT}, - {12, 2467, WLAN_TX_PWR_FR_DEFAULT}, - {13, 2472, WLAN_TX_PWR_FR_DEFAULT} + {10, 2457, LBS_TX_PWR_FR_DEFAULT}, + {11, 2462, LBS_TX_PWR_FR_DEFAULT}, + {12, 2467, LBS_TX_PWR_FR_DEFAULT}, + {13, 2472, LBS_TX_PWR_FR_DEFAULT} }; /* band: 'B/G', region: Japan */ static struct chan_freq_power channel_freq_power_JPN_BG[] = { - {1, 2412, WLAN_TX_PWR_JP_DEFAULT}, - {2, 2417, WLAN_TX_PWR_JP_DEFAULT}, - {3, 2422, WLAN_TX_PWR_JP_DEFAULT}, - {4, 2427, WLAN_TX_PWR_JP_DEFAULT}, - {5, 2432, WLAN_TX_PWR_JP_DEFAULT}, - {6, 2437, WLAN_TX_PWR_JP_DEFAULT}, - {7, 2442, WLAN_TX_PWR_JP_DEFAULT}, - {8, 2447, WLAN_TX_PWR_JP_DEFAULT}, - {9, 2452, WLAN_TX_PWR_JP_DEFAULT}, - {10, 2457, WLAN_TX_PWR_JP_DEFAULT}, - {11, 2462, WLAN_TX_PWR_JP_DEFAULT}, - {12, 2467, WLAN_TX_PWR_JP_DEFAULT}, - {13, 2472, WLAN_TX_PWR_JP_DEFAULT}, - {14, 2484, WLAN_TX_PWR_JP_DEFAULT} + {1, 2412, LBS_TX_PWR_JP_DEFAULT}, + {2, 2417, LBS_TX_PWR_JP_DEFAULT}, + {3, 2422, LBS_TX_PWR_JP_DEFAULT}, + {4, 2427, LBS_TX_PWR_JP_DEFAULT}, + {5, 2432, LBS_TX_PWR_JP_DEFAULT}, + {6, 2437, LBS_TX_PWR_JP_DEFAULT}, + {7, 2442, LBS_TX_PWR_JP_DEFAULT}, + {8, 2447, LBS_TX_PWR_JP_DEFAULT}, + {9, 2452, LBS_TX_PWR_JP_DEFAULT}, + {10, 2457, LBS_TX_PWR_JP_DEFAULT}, + {11, 2462, LBS_TX_PWR_JP_DEFAULT}, + {12, 2467, LBS_TX_PWR_JP_DEFAULT}, + {13, 2472, LBS_TX_PWR_JP_DEFAULT}, + {14, 2484, LBS_TX_PWR_JP_DEFAULT} }; /** @@ -153,13 +153,13 @@ static struct region_cfp_table region_cfp_table[] = { /** * the table to keep region code */ -u16 libertas_region_code_to_index[MRVDRV_MAX_REGION_CODE] = +u16 lbs_region_code_to_index[MRVDRV_MAX_REGION_CODE] = { 0x10, 0x20, 0x30, 0x31, 0x32, 0x40 }; /** * 802.11b/g supported bitrates (in 500Kb/s units) */ -u8 libertas_bg_rates[MAX_RATES] = +u8 lbs_bg_rates[MAX_RATES] = { 0x02, 0x04, 0x0b, 0x16, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6c, 0x00, 0x00 }; @@ -179,7 +179,7 @@ static u8 fw_data_rates[MAX_RATES] = * @param idx The index of data rate * @return data rate or 0 */ -u32 libertas_fw_index_to_data_rate(u8 idx) +u32 lbs_fw_index_to_data_rate(u8 idx) { if (idx >= sizeof(fw_data_rates)) idx = 0; @@ -192,7 +192,7 @@ u32 libertas_fw_index_to_data_rate(u8 idx) * @param rate data rate * @return index or 0 */ -u8 libertas_data_rate_to_fw_index(u32 rate) +u8 lbs_data_rate_to_fw_index(u32 rate) { u8 i; @@ -213,16 +213,18 @@ u8 libertas_data_rate_to_fw_index(u32 rate) /** * @brief Get function for sysfs attribute anycast_mask */ -static ssize_t libertas_anycast_get(struct device * dev, +static ssize_t lbs_anycast_get(struct device *dev, struct device_attribute *attr, char * buf) { + struct lbs_private *priv = to_net_dev(dev)->priv; struct cmd_ds_mesh_access mesh_access; + int ret; memset(&mesh_access, 0, sizeof(mesh_access)); - libertas_prepare_and_send_command(to_net_dev(dev)->priv, - CMD_MESH_ACCESS, - CMD_ACT_MESH_GET_ANYCAST, - CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); + + ret = lbs_mesh_access(priv, CMD_ACT_MESH_GET_ANYCAST, &mesh_access); + if (ret) + return ret; return snprintf(buf, 12, "0x%X\n", le32_to_cpu(mesh_access.data[0])); } @@ -230,244 +232,191 @@ static ssize_t libertas_anycast_get(struct device * dev, /** * @brief Set function for sysfs attribute anycast_mask */ -static ssize_t libertas_anycast_set(struct device * dev, +static ssize_t lbs_anycast_set(struct device *dev, struct device_attribute *attr, const char * buf, size_t count) { + struct lbs_private *priv = to_net_dev(dev)->priv; struct cmd_ds_mesh_access mesh_access; uint32_t datum; + int ret; memset(&mesh_access, 0, sizeof(mesh_access)); sscanf(buf, "%x", &datum); mesh_access.data[0] = cpu_to_le32(datum); - libertas_prepare_and_send_command((to_net_dev(dev))->priv, - CMD_MESH_ACCESS, - CMD_ACT_MESH_SET_ANYCAST, - CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); + ret = lbs_mesh_access(priv, CMD_ACT_MESH_SET_ANYCAST, &mesh_access); + if (ret) + return ret; + return strlen(buf); } -int libertas_add_rtap(wlan_private *priv); -void libertas_remove_rtap(wlan_private *priv); +static int lbs_add_rtap(struct lbs_private *priv); +static void lbs_remove_rtap(struct lbs_private *priv); +static int lbs_add_mesh(struct lbs_private *priv); +static void lbs_remove_mesh(struct lbs_private *priv); + /** * Get function for sysfs attribute rtap */ -static ssize_t libertas_rtap_get(struct device * dev, +static ssize_t lbs_rtap_get(struct device *dev, struct device_attribute *attr, char * buf) { - wlan_private *priv = (wlan_private *) (to_net_dev(dev))->priv; - wlan_adapter *adapter = priv->adapter; - return snprintf(buf, 5, "0x%X\n", adapter->monitormode); + struct lbs_private *priv = to_net_dev(dev)->priv; + return snprintf(buf, 5, "0x%X\n", priv->monitormode); } /** * Set function for sysfs attribute rtap */ -static ssize_t libertas_rtap_set(struct device * dev, +static ssize_t lbs_rtap_set(struct device *dev, struct device_attribute *attr, const char * buf, size_t count) { int monitor_mode; - wlan_private *priv = (wlan_private *) (to_net_dev(dev))->priv; - wlan_adapter *adapter = priv->adapter; + struct lbs_private *priv = to_net_dev(dev)->priv; sscanf(buf, "%x", &monitor_mode); - if (monitor_mode != WLAN_MONITOR_OFF) { - if(adapter->monitormode == monitor_mode) + if (monitor_mode != LBS_MONITOR_OFF) { + if(priv->monitormode == monitor_mode) return strlen(buf); - if (adapter->monitormode == WLAN_MONITOR_OFF) { - if (adapter->mode == IW_MODE_INFRA) - libertas_send_deauthentication(priv); - else if (adapter->mode == IW_MODE_ADHOC) - libertas_stop_adhoc_network(priv); - libertas_add_rtap(priv); + if (priv->monitormode == LBS_MONITOR_OFF) { + if (priv->infra_open || priv->mesh_open) + return -EBUSY; + if (priv->mode == IW_MODE_INFRA) + lbs_send_deauthentication(priv); + else if (priv->mode == IW_MODE_ADHOC) + lbs_stop_adhoc_network(priv); + lbs_add_rtap(priv); } - adapter->monitormode = monitor_mode; + priv->monitormode = monitor_mode; } else { - if(adapter->monitormode == WLAN_MONITOR_OFF) + if (priv->monitormode == LBS_MONITOR_OFF) return strlen(buf); - adapter->monitormode = WLAN_MONITOR_OFF; - libertas_remove_rtap(priv); - netif_wake_queue(priv->dev); - netif_wake_queue(priv->mesh_dev); + priv->monitormode = LBS_MONITOR_OFF; + lbs_remove_rtap(priv); + + if (priv->currenttxskb) { + dev_kfree_skb_any(priv->currenttxskb); + priv->currenttxskb = NULL; + } + + /* Wake queues, command thread, etc. */ + lbs_host_to_card_done(priv); } - libertas_prepare_and_send_command(priv, + lbs_prepare_and_send_command(priv, CMD_802_11_MONITOR_MODE, CMD_ACT_SET, - CMD_OPTION_WAITFORRSP, 0, &adapter->monitormode); + CMD_OPTION_WAITFORRSP, 0, &priv->monitormode); return strlen(buf); } /** - * libertas_rtap attribute to be exported per mshX interface - * through sysfs (/sys/class/net/mshX/libertas-rtap) + * lbs_rtap attribute to be exported per ethX interface + * through sysfs (/sys/class/net/ethX/lbs_rtap) */ -static DEVICE_ATTR(libertas_rtap, 0644, libertas_rtap_get, - libertas_rtap_set ); +static DEVICE_ATTR(lbs_rtap, 0644, lbs_rtap_get, lbs_rtap_set ); /** - * anycast_mask attribute to be exported per mshX interface - * through sysfs (/sys/class/net/mshX/anycast_mask) + * Get function for sysfs attribute mesh */ -static DEVICE_ATTR(anycast_mask, 0644, libertas_anycast_get, libertas_anycast_set); - -static ssize_t libertas_autostart_enabled_get(struct device * dev, +static ssize_t lbs_mesh_get(struct device *dev, struct device_attribute *attr, char * buf) { - struct cmd_ds_mesh_access mesh_access; - - memset(&mesh_access, 0, sizeof(mesh_access)); - libertas_prepare_and_send_command(to_net_dev(dev)->priv, - CMD_MESH_ACCESS, - CMD_ACT_MESH_GET_AUTOSTART_ENABLED, - CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); - - return sprintf(buf, "%d\n", le32_to_cpu(mesh_access.data[0])); + struct lbs_private *priv = to_net_dev(dev)->priv; + return snprintf(buf, 5, "0x%X\n", !!priv->mesh_dev); } -static ssize_t libertas_autostart_enabled_set(struct device * dev, +/** + * Set function for sysfs attribute mesh + */ +static ssize_t lbs_mesh_set(struct device *dev, struct device_attribute *attr, const char * buf, size_t count) { - struct cmd_ds_mesh_access mesh_access; - uint32_t datum; - wlan_private * priv = (to_net_dev(dev))->priv; + struct lbs_private *priv = to_net_dev(dev)->priv; + int enable; int ret; - memset(&mesh_access, 0, sizeof(mesh_access)); - sscanf(buf, "%d", &datum); - mesh_access.data[0] = cpu_to_le32(datum); + sscanf(buf, "%x", &enable); + enable = !!enable; + if (enable == !!priv->mesh_dev) + return count; + + ret = lbs_mesh_config(priv, enable, priv->curbssparams.channel); + if (ret) + return ret; - ret = libertas_prepare_and_send_command(priv, - CMD_MESH_ACCESS, - CMD_ACT_MESH_SET_AUTOSTART_ENABLED, - CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); - if (ret == 0) - priv->mesh_autostart_enabled = datum ? 1 : 0; + if (enable) + lbs_add_mesh(priv); + else + lbs_remove_mesh(priv); - return strlen(buf); + return count; } -static DEVICE_ATTR(autostart_enabled, 0644, - libertas_autostart_enabled_get, libertas_autostart_enabled_set); +/** + * lbs_mesh attribute to be exported per ethX interface + * through sysfs (/sys/class/net/ethX/lbs_mesh) + */ +static DEVICE_ATTR(lbs_mesh, 0644, lbs_mesh_get, lbs_mesh_set); -static struct attribute *libertas_mesh_sysfs_entries[] = { +/** + * anycast_mask attribute to be exported per mshX interface + * through sysfs (/sys/class/net/mshX/anycast_mask) + */ +static DEVICE_ATTR(anycast_mask, 0644, lbs_anycast_get, lbs_anycast_set); + +static struct attribute *lbs_mesh_sysfs_entries[] = { &dev_attr_anycast_mask.attr, - &dev_attr_autostart_enabled.attr, NULL, }; -static struct attribute_group libertas_mesh_attr_group = { - .attrs = libertas_mesh_sysfs_entries, +static struct attribute_group lbs_mesh_attr_group = { + .attrs = lbs_mesh_sysfs_entries, }; /** - * @brief Check if the device can be open and wait if necessary. - * - * @param dev A pointer to net_device structure - * @return 0 - * - * For USB adapter, on some systems the device open handler will be - * called before FW ready. Use the following flag check and wait - * function to work around the issue. - * - */ -static int pre_open_check(struct net_device *dev) -{ - wlan_private *priv = (wlan_private *) dev->priv; - wlan_adapter *adapter = priv->adapter; - int i = 0; - - while (!adapter->fw_ready && i < 20) { - i++; - msleep_interruptible(100); - } - if (!adapter->fw_ready) { - lbs_pr_err("firmware not ready\n"); - return -1; - } - - return 0; -} - -/** - * @brief This function opens the device + * @brief This function opens the ethX or mshX interface * * @param dev A pointer to net_device structure - * @return 0 + * @return 0 or -EBUSY if monitor mode active */ -static int libertas_dev_open(struct net_device *dev) +static int lbs_dev_open(struct net_device *dev) { - wlan_private *priv = (wlan_private *) dev->priv; - wlan_adapter *adapter = priv->adapter; + struct lbs_private *priv = (struct lbs_private *) dev->priv ; + int ret = 0; lbs_deb_enter(LBS_DEB_NET); - priv->open = 1; + spin_lock_irq(&priv->driver_lock); - if (adapter->connect_status == LIBERTAS_CONNECTED) { - netif_carrier_on(priv->dev); - if (priv->mesh_dev) - netif_carrier_on(priv->mesh_dev); - } else { - netif_carrier_off(priv->dev); - if (priv->mesh_dev) - netif_carrier_off(priv->mesh_dev); + if (priv->monitormode != LBS_MONITOR_OFF) { + ret = -EBUSY; + goto out; } - lbs_deb_leave(LBS_DEB_NET); - return 0; -} -/** - * @brief This function opens the mshX interface - * - * @param dev A pointer to net_device structure - * @return 0 - */ -static int libertas_mesh_open(struct net_device *dev) -{ - wlan_private *priv = (wlan_private *) dev->priv ; - - if (pre_open_check(dev) == -1) - return -1; - priv->mesh_open = 1 ; - netif_wake_queue(priv->mesh_dev); - if (priv->infra_open == 0) - return libertas_dev_open(priv->dev) ; - return 0; -} - -/** - * @brief This function opens the ethX interface - * - * @param dev A pointer to net_device structure - * @return 0 - */ -static int libertas_open(struct net_device *dev) -{ - wlan_private *priv = (wlan_private *) dev->priv ; - - if(pre_open_check(dev) == -1) - return -1; - priv->infra_open = 1 ; - netif_wake_queue(priv->dev); - if (priv->open == 0) - return libertas_dev_open(priv->dev) ; - return 0; -} - -static int libertas_dev_close(struct net_device *dev) -{ - wlan_private *priv = dev->priv; + if (dev == priv->mesh_dev) { + priv->mesh_open = 1; + priv->mesh_connect_status = LBS_CONNECTED; + netif_carrier_on(dev); + } else { + priv->infra_open = 1; - lbs_deb_enter(LBS_DEB_NET); + if (priv->connect_status == LBS_CONNECTED) + netif_carrier_on(dev); + else + netif_carrier_off(dev); + } - netif_carrier_off(priv->dev); - priv->open = 0; + if (!priv->tx_pending_len) + netif_wake_queue(dev); + out: - lbs_deb_leave(LBS_DEB_NET); - return 0; + spin_unlock_irq(&priv->driver_lock); + lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); + return ret; } /** @@ -476,16 +425,23 @@ static int libertas_dev_close(struct net_device *dev) * @param dev A pointer to net_device structure * @return 0 */ -static int libertas_mesh_close(struct net_device *dev) +static int lbs_mesh_stop(struct net_device *dev) { - wlan_private *priv = (wlan_private *) (dev->priv); + struct lbs_private *priv = (struct lbs_private *) (dev->priv); + + lbs_deb_enter(LBS_DEB_MESH); + spin_lock_irq(&priv->driver_lock); priv->mesh_open = 0; - netif_stop_queue(priv->mesh_dev); - if (priv->infra_open == 0) - return libertas_dev_close(dev); - else - return 0; + priv->mesh_connect_status = LBS_DISCONNECTED; + + netif_stop_queue(dev); + netif_carrier_off(dev); + + spin_unlock_irq(&priv->driver_lock); + + lbs_deb_leave(LBS_DEB_MESH); + return 0; } /** @@ -494,134 +450,86 @@ static int libertas_mesh_close(struct net_device *dev) * @param dev A pointer to net_device structure * @return 0 */ -static int libertas_close(struct net_device *dev) -{ - wlan_private *priv = (wlan_private *) dev->priv; - - netif_stop_queue(dev); - priv->infra_open = 0; - if (priv->mesh_open == 0) - return libertas_dev_close(dev); - else - return 0; -} - - -static int libertas_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) +static int lbs_eth_stop(struct net_device *dev) { - int ret = 0; - wlan_private *priv = dev->priv; + struct lbs_private *priv = (struct lbs_private *) dev->priv; lbs_deb_enter(LBS_DEB_NET); - if (priv->dnld_sent || priv->adapter->TxLockFlag) { - priv->stats.tx_dropped++; - goto done; - } - - netif_stop_queue(priv->dev); - if (priv->mesh_dev) - netif_stop_queue(priv->mesh_dev); + spin_lock_irq(&priv->driver_lock); + priv->infra_open = 0; + netif_stop_queue(dev); + spin_unlock_irq(&priv->driver_lock); - if (libertas_process_tx(priv, skb) == 0) - dev->trans_start = jiffies; -done: - lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); - return ret; + lbs_deb_leave(LBS_DEB_NET); + return 0; } -/** - * @brief Mark mesh packets and handover them to libertas_hard_start_xmit - * - */ -static int libertas_mesh_pre_start_xmit(struct sk_buff *skb, - struct net_device *dev) +static void lbs_tx_timeout(struct net_device *dev) { - wlan_private *priv = dev->priv; - int ret; - - lbs_deb_enter(LBS_DEB_MESH); - if(priv->adapter->monitormode != WLAN_MONITOR_OFF) { - netif_stop_queue(dev); - return -EOPNOTSUPP; - } - - SET_MESH_FRAME(skb); + struct lbs_private *priv = (struct lbs_private *) dev->priv; - ret = libertas_hard_start_xmit(skb, priv->dev); - lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret); - return ret; -} + lbs_deb_enter(LBS_DEB_TX); -/** - * @brief Mark non-mesh packets and handover them to libertas_hard_start_xmit - * - */ -static int libertas_pre_start_xmit(struct sk_buff *skb, struct net_device *dev) -{ - wlan_private *priv = dev->priv; - int ret; + lbs_pr_err("tx watch dog timeout\n"); - lbs_deb_enter(LBS_DEB_NET); + dev->trans_start = jiffies; - if(priv->adapter->monitormode != WLAN_MONITOR_OFF) { - netif_stop_queue(dev); - return -EOPNOTSUPP; + if (priv->currenttxskb) { + priv->eventcause = 0x01000000; + lbs_send_tx_feedback(priv); } + /* XX: Shouldn't we also call into the hw-specific driver + to kick it somehow? */ + lbs_host_to_card_done(priv); - UNSET_MESH_FRAME(skb); + /* More often than not, this actually happens because the + firmware has crapped itself -- rather than just a very + busy medium. So send a harmless command, and if/when + _that_ times out, we'll kick it in the head. */ + lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0, + 0, 0, NULL); - ret = libertas_hard_start_xmit(skb, dev); - lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); - return ret; + lbs_deb_leave(LBS_DEB_TX); } -static void libertas_tx_timeout(struct net_device *dev) +void lbs_host_to_card_done(struct lbs_private *priv) { - wlan_private *priv = (wlan_private *) dev->priv; + unsigned long flags; - lbs_deb_enter(LBS_DEB_TX); + lbs_deb_enter(LBS_DEB_THREAD); - lbs_pr_err("tx watch dog timeout\n"); + spin_lock_irqsave(&priv->driver_lock, flags); priv->dnld_sent = DNLD_RES_RECEIVED; - dev->trans_start = jiffies; - if (priv->adapter->currenttxskb) { - if (priv->adapter->monitormode != WLAN_MONITOR_OFF) { - /* If we are here, we have not received feedback from - the previous packet. Assume TX_FAIL and move on. */ - priv->adapter->eventcause = 0x01000000; - libertas_send_tx_feedback(priv); - } else - wake_up_interruptible(&priv->waitq); - } else if (priv->adapter->connect_status == LIBERTAS_CONNECTED) { - netif_wake_queue(priv->dev); - if (priv->mesh_dev) - netif_wake_queue(priv->mesh_dev); - } + /* Wake main thread if commands are pending */ + if (!priv->cur_cmd || priv->tx_pending_len > 0) + wake_up_interruptible(&priv->waitq); - lbs_deb_leave(LBS_DEB_TX); + spin_unlock_irqrestore(&priv->driver_lock, flags); + lbs_deb_leave(LBS_DEB_THREAD); } +EXPORT_SYMBOL_GPL(lbs_host_to_card_done); /** * @brief This function returns the network statistics * - * @param dev A pointer to wlan_private structure + * @param dev A pointer to struct lbs_private structure * @return A pointer to net_device_stats structure */ -static struct net_device_stats *libertas_get_stats(struct net_device *dev) +static struct net_device_stats *lbs_get_stats(struct net_device *dev) { - wlan_private *priv = (wlan_private *) dev->priv; + struct lbs_private *priv = (struct lbs_private *) dev->priv; + lbs_deb_enter(LBS_DEB_NET); return &priv->stats; } -static int libertas_set_mac_address(struct net_device *dev, void *addr) +static int lbs_set_mac_address(struct net_device *dev, void *addr) { int ret = 0; - wlan_private *priv = (wlan_private *) dev->priv; - wlan_adapter *adapter = priv->adapter; + struct lbs_private *priv = (struct lbs_private *) dev->priv; struct sockaddr *phwaddr = addr; lbs_deb_enter(LBS_DEB_NET); @@ -629,15 +537,15 @@ static int libertas_set_mac_address(struct net_device *dev, void *addr) /* In case it was called from the mesh device */ dev = priv->dev ; - memset(adapter->current_addr, 0, ETH_ALEN); + memset(priv->current_addr, 0, ETH_ALEN); /* dev->dev_addr is 8 bytes */ lbs_deb_hex(LBS_DEB_NET, "dev->dev_addr", dev->dev_addr, ETH_ALEN); lbs_deb_hex(LBS_DEB_NET, "addr", phwaddr->sa_data, ETH_ALEN); - memcpy(adapter->current_addr, phwaddr->sa_data, ETH_ALEN); + memcpy(priv->current_addr, phwaddr->sa_data, ETH_ALEN); - ret = libertas_prepare_and_send_command(priv, CMD_802_11_MAC_ADDRESS, + ret = lbs_prepare_and_send_command(priv, CMD_802_11_MAC_ADDRESS, CMD_ACT_SET, CMD_OPTION_WAITFORRSP, 0, NULL); @@ -647,89 +555,86 @@ static int libertas_set_mac_address(struct net_device *dev, void *addr) goto done; } - lbs_deb_hex(LBS_DEB_NET, "adapter->macaddr", adapter->current_addr, ETH_ALEN); - memcpy(dev->dev_addr, adapter->current_addr, ETH_ALEN); + lbs_deb_hex(LBS_DEB_NET, "priv->macaddr", priv->current_addr, ETH_ALEN); + memcpy(dev->dev_addr, priv->current_addr, ETH_ALEN); if (priv->mesh_dev) - memcpy(priv->mesh_dev->dev_addr, adapter->current_addr, ETH_ALEN); + memcpy(priv->mesh_dev->dev_addr, priv->current_addr, ETH_ALEN); done: lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); return ret; } -static int libertas_copy_multicast_address(wlan_adapter * adapter, +static int lbs_copy_multicast_address(struct lbs_private *priv, struct net_device *dev) { int i = 0; struct dev_mc_list *mcptr = dev->mc_list; for (i = 0; i < dev->mc_count; i++) { - memcpy(&adapter->multicastlist[i], mcptr->dmi_addr, ETH_ALEN); + memcpy(&priv->multicastlist[i], mcptr->dmi_addr, ETH_ALEN); mcptr = mcptr->next; } - return i; - } -static void libertas_set_multicast_list(struct net_device *dev) +static void lbs_set_multicast_list(struct net_device *dev) { - wlan_private *priv = dev->priv; - wlan_adapter *adapter = priv->adapter; + struct lbs_private *priv = dev->priv; int oldpacketfilter; DECLARE_MAC_BUF(mac); lbs_deb_enter(LBS_DEB_NET); - oldpacketfilter = adapter->currentpacketfilter; + oldpacketfilter = priv->currentpacketfilter; if (dev->flags & IFF_PROMISC) { lbs_deb_net("enable promiscuous mode\n"); - adapter->currentpacketfilter |= + priv->currentpacketfilter |= CMD_ACT_MAC_PROMISCUOUS_ENABLE; - adapter->currentpacketfilter &= + priv->currentpacketfilter &= ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE | CMD_ACT_MAC_MULTICAST_ENABLE); } else { /* Multicast */ - adapter->currentpacketfilter &= + priv->currentpacketfilter &= ~CMD_ACT_MAC_PROMISCUOUS_ENABLE; if (dev->flags & IFF_ALLMULTI || dev->mc_count > MRVDRV_MAX_MULTICAST_LIST_SIZE) { lbs_deb_net( "enabling all multicast\n"); - adapter->currentpacketfilter |= + priv->currentpacketfilter |= CMD_ACT_MAC_ALL_MULTICAST_ENABLE; - adapter->currentpacketfilter &= + priv->currentpacketfilter &= ~CMD_ACT_MAC_MULTICAST_ENABLE; } else { - adapter->currentpacketfilter &= + priv->currentpacketfilter &= ~CMD_ACT_MAC_ALL_MULTICAST_ENABLE; if (!dev->mc_count) { lbs_deb_net("no multicast addresses, " "disabling multicast\n"); - adapter->currentpacketfilter &= + priv->currentpacketfilter &= ~CMD_ACT_MAC_MULTICAST_ENABLE; } else { int i; - adapter->currentpacketfilter |= + priv->currentpacketfilter |= CMD_ACT_MAC_MULTICAST_ENABLE; - adapter->nr_of_multicastmacaddr = - libertas_copy_multicast_address(adapter, dev); + priv->nr_of_multicastmacaddr = + lbs_copy_multicast_address(priv, dev); lbs_deb_net("multicast addresses: %d\n", dev->mc_count); for (i = 0; i < dev->mc_count; i++) { - lbs_deb_net("Multicast address %d:%s\n", + lbs_deb_net("Multicast address %d: %s\n", i, print_mac(mac, - adapter->multicastlist[i])); + priv->multicastlist[i])); } /* send multicast addresses to firmware */ - libertas_prepare_and_send_command(priv, + lbs_prepare_and_send_command(priv, CMD_MAC_MULTICAST_ADR, CMD_ACT_SET, 0, 0, NULL); @@ -737,26 +642,25 @@ static void libertas_set_multicast_list(struct net_device *dev) } } - if (adapter->currentpacketfilter != oldpacketfilter) { - libertas_set_mac_packet_filter(priv); + if (priv->currentpacketfilter != oldpacketfilter) { + lbs_set_mac_packet_filter(priv); } lbs_deb_leave(LBS_DEB_NET); } /** - * @brief This function handles the major jobs in the WLAN driver. + * @brief This function handles the major jobs in the LBS driver. * It handles all events generated by firmware, RX data received * from firmware and TX data sent from kernel. * - * @param data A pointer to wlan_thread structure + * @param data A pointer to lbs_thread structure * @return 0 */ -static int libertas_thread(void *data) +static int lbs_thread(void *data) { struct net_device *dev = data; - wlan_private *priv = dev->priv; - wlan_adapter *adapter = priv->adapter; + struct lbs_private *priv = dev->priv; wait_queue_t wait; u8 ireg = 0; @@ -764,215 +668,291 @@ static int libertas_thread(void *data) init_waitqueue_entry(&wait, current); - set_freezable(); for (;;) { - lbs_deb_thread( "main-thread 111: intcounter=%d " - "currenttxskb=%p dnld_sent=%d\n", - adapter->intcounter, - adapter->currenttxskb, priv->dnld_sent); + int shouldsleep; + + lbs_deb_thread( "main-thread 111: intcounter=%d currenttxskb=%p dnld_sent=%d\n", + priv->intcounter, priv->currenttxskb, priv->dnld_sent); add_wait_queue(&priv->waitq, &wait); set_current_state(TASK_INTERRUPTIBLE); - spin_lock_irq(&adapter->driver_lock); - if ((adapter->psstate == PS_STATE_SLEEP) || - (!adapter->intcounter - && (priv->dnld_sent || adapter->cur_cmd || - list_empty(&adapter->cmdpendingq)))) { - lbs_deb_thread( - "main-thread sleeping... Conn=%d IntC=%d PS_mode=%d PS_State=%d\n", - adapter->connect_status, adapter->intcounter, - adapter->psmode, adapter->psstate); - spin_unlock_irq(&adapter->driver_lock); + spin_lock_irq(&priv->driver_lock); + + if (kthread_should_stop()) + shouldsleep = 0; /* Bye */ + else if (priv->surpriseremoved) + shouldsleep = 1; /* We need to wait until we're _told_ to die */ + else if (priv->psstate == PS_STATE_SLEEP) + shouldsleep = 1; /* Sleep mode. Nothing we can do till it wakes */ + else if (priv->intcounter) + shouldsleep = 0; /* Interrupt pending. Deal with it now */ + else if (priv->cmd_timed_out) + shouldsleep = 0; /* Command timed out. Recover */ + else if (!priv->fw_ready) + shouldsleep = 1; /* Firmware not ready. We're waiting for it */ + else if (priv->dnld_sent) + shouldsleep = 1; /* Something is en route to the device already */ + else if (priv->tx_pending_len > 0) + shouldsleep = 0; /* We've a packet to send */ + else if (priv->cur_cmd) + shouldsleep = 1; /* Can't send a command; one already running */ + else if (!list_empty(&priv->cmdpendingq)) + shouldsleep = 0; /* We have a command to send */ + else + shouldsleep = 1; /* No command */ + + if (shouldsleep) { + lbs_deb_thread("main-thread sleeping... Conn=%d IntC=%d PS_mode=%d PS_State=%d\n", + priv->connect_status, priv->intcounter, + priv->psmode, priv->psstate); + spin_unlock_irq(&priv->driver_lock); schedule(); } else - spin_unlock_irq(&adapter->driver_lock); + spin_unlock_irq(&priv->driver_lock); - lbs_deb_thread( - "main-thread 222 (waking up): intcounter=%d currenttxskb=%p " - "dnld_sent=%d\n", adapter->intcounter, - adapter->currenttxskb, priv->dnld_sent); + lbs_deb_thread("main-thread 222 (waking up): intcounter=%d currenttxskb=%p dnld_sent=%d\n", + priv->intcounter, priv->currenttxskb, priv->dnld_sent); set_current_state(TASK_RUNNING); remove_wait_queue(&priv->waitq, &wait); - try_to_freeze(); - - lbs_deb_thread("main-thread 333: intcounter=%d currenttxskb=%p " - "dnld_sent=%d\n", - adapter->intcounter, - adapter->currenttxskb, priv->dnld_sent); - - if (kthread_should_stop() - || adapter->surpriseremoved) { - lbs_deb_thread( - "main-thread: break from main thread: surpriseremoved=0x%x\n", - adapter->surpriseremoved); + + lbs_deb_thread("main-thread 333: intcounter=%d currenttxskb=%p dnld_sent=%d\n", + priv->intcounter, priv->currenttxskb, priv->dnld_sent); + + if (kthread_should_stop()) { + lbs_deb_thread("main-thread: break from main thread\n"); break; } + if (priv->surpriseremoved) { + lbs_deb_thread("adapter removed; waiting to die...\n"); + continue; + } + + spin_lock_irq(&priv->driver_lock); - spin_lock_irq(&adapter->driver_lock); - if (adapter->intcounter) { + if (priv->intcounter) { u8 int_status; - adapter->intcounter = 0; + + priv->intcounter = 0; int_status = priv->hw_get_int_status(priv, &ireg); if (int_status) { - lbs_deb_thread( - "main-thread: reading HOST_INT_STATUS_REG failed\n"); - spin_unlock_irq(&adapter->driver_lock); + lbs_deb_thread("main-thread: reading HOST_INT_STATUS_REG failed\n"); + spin_unlock_irq(&priv->driver_lock); continue; } - adapter->hisregcpy |= ireg; + priv->hisregcpy |= ireg; } - lbs_deb_thread("main-thread 444: intcounter=%d currenttxskb=%p " - "dnld_sent=%d\n", - adapter->intcounter, - adapter->currenttxskb, priv->dnld_sent); + lbs_deb_thread("main-thread 444: intcounter=%d currenttxskb=%p dnld_sent=%d\n", + priv->intcounter, priv->currenttxskb, priv->dnld_sent); /* command response? */ - if (adapter->hisregcpy & MRVDRV_CMD_UPLD_RDY) { + if (priv->hisregcpy & MRVDRV_CMD_UPLD_RDY) { lbs_deb_thread("main-thread: cmd response ready\n"); - adapter->hisregcpy &= ~MRVDRV_CMD_UPLD_RDY; - spin_unlock_irq(&adapter->driver_lock); - libertas_process_rx_command(priv); - spin_lock_irq(&adapter->driver_lock); + priv->hisregcpy &= ~MRVDRV_CMD_UPLD_RDY; + spin_unlock_irq(&priv->driver_lock); + lbs_process_rx_command(priv); + spin_lock_irq(&priv->driver_lock); } + if (priv->cmd_timed_out && priv->cur_cmd) { + struct cmd_ctrl_node *cmdnode = priv->cur_cmd; + + if (++priv->nr_retries > 10) { + lbs_pr_info("Excessive timeouts submitting command %x\n", + le16_to_cpu(cmdnode->cmdbuf->command)); + lbs_complete_command(priv, cmdnode, -ETIMEDOUT); + priv->nr_retries = 0; + } else { + priv->cur_cmd = NULL; + lbs_pr_info("requeueing command %x due to timeout (#%d)\n", + le16_to_cpu(cmdnode->cmdbuf->command), priv->nr_retries); + + /* Stick it back at the _top_ of the pending queue + for immediate resubmission */ + list_add(&cmdnode->list, &priv->cmdpendingq); + } + } + priv->cmd_timed_out = 0; + /* Any Card Event */ - if (adapter->hisregcpy & MRVDRV_CARDEVENT) { + if (priv->hisregcpy & MRVDRV_CARDEVENT) { lbs_deb_thread("main-thread: Card Event Activity\n"); - adapter->hisregcpy &= ~MRVDRV_CARDEVENT; + priv->hisregcpy &= ~MRVDRV_CARDEVENT; if (priv->hw_read_event_cause(priv)) { - lbs_pr_alert( - "main-thread: hw_read_event_cause failed\n"); - spin_unlock_irq(&adapter->driver_lock); + lbs_pr_alert("main-thread: hw_read_event_cause failed\n"); + spin_unlock_irq(&priv->driver_lock); continue; } - spin_unlock_irq(&adapter->driver_lock); - libertas_process_event(priv); + spin_unlock_irq(&priv->driver_lock); + lbs_process_event(priv); } else - spin_unlock_irq(&adapter->driver_lock); + spin_unlock_irq(&priv->driver_lock); + + if (!priv->fw_ready) + continue; /* Check if we need to confirm Sleep Request received previously */ - if (adapter->psstate == PS_STATE_PRE_SLEEP) { - if (!priv->dnld_sent && !adapter->cur_cmd) { - if (adapter->connect_status == - LIBERTAS_CONNECTED) { - lbs_deb_thread( - "main_thread: PRE_SLEEP--intcounter=%d currenttxskb=%p " - "dnld_sent=%d cur_cmd=%p, confirm now\n", - adapter->intcounter, - adapter->currenttxskb, - priv->dnld_sent, - adapter->cur_cmd); - - libertas_ps_confirm_sleep(priv, - (u16) adapter->psmode); - } else { - /* workaround for firmware sending - * deauth/linkloss event immediately - * after sleep request, remove this - * after firmware fixes it - */ - adapter->psstate = PS_STATE_AWAKE; - lbs_pr_alert( - "main-thread: ignore PS_SleepConfirm in non-connected state\n"); - } + if (priv->psstate == PS_STATE_PRE_SLEEP && + !priv->dnld_sent && !priv->cur_cmd) { + if (priv->connect_status == LBS_CONNECTED) { + lbs_deb_thread("main_thread: PRE_SLEEP--intcounter=%d currenttxskb=%p dnld_sent=%d cur_cmd=%p, confirm now\n", + priv->intcounter, priv->currenttxskb, priv->dnld_sent, priv->cur_cmd); + + lbs_ps_confirm_sleep(priv, (u16) priv->psmode); + } else { + /* workaround for firmware sending + * deauth/linkloss event immediately + * after sleep request; remove this + * after firmware fixes it + */ + priv->psstate = PS_STATE_AWAKE; + lbs_pr_alert("main-thread: ignore PS_SleepConfirm in non-connected state\n"); } } /* The PS state is changed during processing of Sleep Request * event above */ - if ((priv->adapter->psstate == PS_STATE_SLEEP) || - (priv->adapter->psstate == PS_STATE_PRE_SLEEP)) + if ((priv->psstate == PS_STATE_SLEEP) || + (priv->psstate == PS_STATE_PRE_SLEEP)) continue; /* Execute the next command */ - if (!priv->dnld_sent && !priv->adapter->cur_cmd) - libertas_execute_next_command(priv); + if (!priv->dnld_sent && !priv->cur_cmd) + lbs_execute_next_command(priv); /* Wake-up command waiters which can't sleep in - * libertas_prepare_and_send_command + * lbs_prepare_and_send_command */ - if (!adapter->nr_cmd_pending) - wake_up_all(&adapter->cmd_pending); - - libertas_tx_runqueue(priv); + if (!list_empty(&priv->cmdpendingq)) + wake_up_all(&priv->cmd_pending); + + spin_lock_irq(&priv->driver_lock); + if (!priv->dnld_sent && priv->tx_pending_len > 0) { + int ret = priv->hw_host_to_card(priv, MVMS_DAT, + priv->tx_pending_buf, + priv->tx_pending_len); + if (ret) { + lbs_deb_tx("host_to_card failed %d\n", ret); + priv->dnld_sent = DNLD_RES_RECEIVED; + } + priv->tx_pending_len = 0; + if (!priv->currenttxskb) { + /* We can wake the queues immediately if we aren't + waiting for TX feedback */ + if (priv->connect_status == LBS_CONNECTED) + netif_wake_queue(priv->dev); + if (priv->mesh_dev && + priv->mesh_connect_status == LBS_CONNECTED) + netif_wake_queue(priv->mesh_dev); + } + } + spin_unlock_irq(&priv->driver_lock); } - del_timer(&adapter->command_timer); - adapter->nr_cmd_pending = 0; - wake_up_all(&adapter->cmd_pending); + del_timer(&priv->command_timer); + wake_up_all(&priv->cmd_pending); lbs_deb_leave(LBS_DEB_THREAD); return 0; } +static int lbs_suspend_callback(struct lbs_private *priv, unsigned long dummy, + struct cmd_header *cmd) +{ + lbs_deb_enter(LBS_DEB_FW); + + netif_device_detach(priv->dev); + if (priv->mesh_dev) + netif_device_detach(priv->mesh_dev); + + priv->fw_ready = 0; + lbs_deb_leave(LBS_DEB_FW); + return 0; +} + +int lbs_suspend(struct lbs_private *priv) +{ + struct cmd_header cmd; + int ret; + + lbs_deb_enter(LBS_DEB_FW); + + if (priv->wol_criteria == 0xffffffff) { + lbs_pr_info("Suspend attempt without configuring wake params!\n"); + return -EINVAL; + } + + memset(&cmd, 0, sizeof(cmd)); + + ret = __lbs_cmd(priv, CMD_802_11_HOST_SLEEP_ACTIVATE, &cmd, + sizeof(cmd), lbs_suspend_callback, 0); + if (ret) + lbs_pr_info("HOST_SLEEP_ACTIVATE failed: %d\n", ret); + + lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); + return ret; +} +EXPORT_SYMBOL_GPL(lbs_suspend); + +int lbs_resume(struct lbs_private *priv) +{ + lbs_deb_enter(LBS_DEB_FW); + + priv->fw_ready = 1; + + /* Firmware doesn't seem to give us RX packets any more + until we send it some command. Might as well update */ + lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0, + 0, 0, NULL); + + netif_device_attach(priv->dev); + if (priv->mesh_dev) + netif_device_attach(priv->mesh_dev); + + lbs_deb_leave(LBS_DEB_FW); + return 0; +} +EXPORT_SYMBOL_GPL(lbs_resume); + /** * @brief This function downloads firmware image, gets * HW spec from firmware and set basic parameters to * firmware. * - * @param priv A pointer to wlan_private structure + * @param priv A pointer to struct lbs_private structure * @return 0 or -1 */ -static int wlan_setup_firmware(wlan_private * priv) +static int lbs_setup_firmware(struct lbs_private *priv) { int ret = -1; - wlan_adapter *adapter = priv->adapter; - struct cmd_ds_mesh_access mesh_access; lbs_deb_enter(LBS_DEB_FW); /* * Read MAC address from HW */ - memset(adapter->current_addr, 0xff, ETH_ALEN); - - ret = libertas_prepare_and_send_command(priv, CMD_GET_HW_SPEC, - 0, CMD_OPTION_WAITFORRSP, 0, NULL); - + memset(priv->current_addr, 0xff, ETH_ALEN); + ret = lbs_update_hw_spec(priv); if (ret) { ret = -1; goto done; } - libertas_set_mac_packet_filter(priv); - - /* Get the supported Data rates */ - ret = libertas_prepare_and_send_command(priv, CMD_802_11_DATA_RATE, - CMD_ACT_GET_TX_RATE, - CMD_OPTION_WAITFORRSP, 0, NULL); + lbs_set_mac_packet_filter(priv); - if (ret) { + ret = lbs_get_data_rate(priv); + if (ret < 0) { ret = -1; goto done; } - /* Disable mesh autostart */ - if (priv->mesh_dev) { - memset(&mesh_access, 0, sizeof(mesh_access)); - mesh_access.data[0] = cpu_to_le32(0); - ret = libertas_prepare_and_send_command(priv, - CMD_MESH_ACCESS, - CMD_ACT_MESH_SET_AUTOSTART_ENABLED, - CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); - if (ret) { - ret = -1; - goto done; - } - priv->mesh_autostart_enabled = 0; - } - - /* Set the boot2 version in firmware */ - ret = libertas_prepare_and_send_command(priv, CMD_SET_BOOT2_VER, - 0, CMD_OPTION_WAITFORRSP, 0, NULL); - ret = 0; done: lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); @@ -985,164 +965,130 @@ done: */ static void command_timer_fn(unsigned long data) { - wlan_private *priv = (wlan_private *)data; - wlan_adapter *adapter = priv->adapter; - struct cmd_ctrl_node *ptempnode; - struct cmd_ds_command *cmd; + struct lbs_private *priv = (struct lbs_private *)data; unsigned long flags; - ptempnode = adapter->cur_cmd; - if (ptempnode == NULL) { - lbs_deb_fw("ptempnode empty\n"); - return; - } + lbs_deb_enter(LBS_DEB_CMD); + spin_lock_irqsave(&priv->driver_lock, flags); - cmd = (struct cmd_ds_command *)ptempnode->bufvirtualaddr; - if (!cmd) { - lbs_deb_fw("cmd is NULL\n"); - return; + if (!priv->cur_cmd) { + lbs_pr_info("Command timer expired; no pending command\n"); + goto out; } - lbs_deb_fw("command_timer_fn fired, cmd %x\n", cmd->command); - - if (!adapter->fw_ready) - return; - - spin_lock_irqsave(&adapter->driver_lock, flags); - adapter->cur_cmd = NULL; - spin_unlock_irqrestore(&adapter->driver_lock, flags); - - lbs_deb_fw("re-sending same command because of timeout\n"); - libertas_queue_cmd(adapter, ptempnode, 0); + lbs_pr_info("Command %x timed out\n", le16_to_cpu(priv->cur_cmd->cmdbuf->command)); + priv->cmd_timed_out = 1; wake_up_interruptible(&priv->waitq); - - return; +out: + spin_unlock_irqrestore(&priv->driver_lock, flags); + lbs_deb_leave(LBS_DEB_CMD); } -static int libertas_init_adapter(wlan_private * priv) +static int lbs_init_adapter(struct lbs_private *priv) { - wlan_adapter *adapter = priv->adapter; size_t bufsize; int i, ret = 0; + lbs_deb_enter(LBS_DEB_MAIN); + /* Allocate buffer to store the BSSID list */ bufsize = MAX_NETWORK_COUNT * sizeof(struct bss_descriptor); - adapter->networks = kzalloc(bufsize, GFP_KERNEL); - if (!adapter->networks) { + priv->networks = kzalloc(bufsize, GFP_KERNEL); + if (!priv->networks) { lbs_pr_err("Out of memory allocating beacons\n"); ret = -1; goto out; } /* Initialize scan result lists */ - INIT_LIST_HEAD(&adapter->network_free_list); - INIT_LIST_HEAD(&adapter->network_list); + INIT_LIST_HEAD(&priv->network_free_list); + INIT_LIST_HEAD(&priv->network_list); for (i = 0; i < MAX_NETWORK_COUNT; i++) { - list_add_tail(&adapter->networks[i].list, - &adapter->network_free_list); + list_add_tail(&priv->networks[i].list, + &priv->network_free_list); } - adapter->libertas_ps_confirm_sleep.seqnum = cpu_to_le16(++adapter->seqnum); - adapter->libertas_ps_confirm_sleep.command = + priv->lbs_ps_confirm_sleep.seqnum = cpu_to_le16(++priv->seqnum); + priv->lbs_ps_confirm_sleep.command = cpu_to_le16(CMD_802_11_PS_MODE); - adapter->libertas_ps_confirm_sleep.size = + priv->lbs_ps_confirm_sleep.size = cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep)); - adapter->libertas_ps_confirm_sleep.action = + priv->lbs_ps_confirm_sleep.action = cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED); - memset(adapter->current_addr, 0xff, ETH_ALEN); - - adapter->connect_status = LIBERTAS_DISCONNECTED; - adapter->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM; - adapter->mode = IW_MODE_INFRA; - adapter->curbssparams.channel = DEFAULT_AD_HOC_CHANNEL; - adapter->currentpacketfilter = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON; - adapter->radioon = RADIO_ON; - adapter->auto_rate = 1; - adapter->capability = WLAN_CAPABILITY_SHORT_PREAMBLE; - adapter->psmode = WLAN802_11POWERMODECAM; - adapter->psstate = PS_STATE_FULL_POWER; + memset(priv->current_addr, 0xff, ETH_ALEN); - mutex_init(&adapter->lock); + priv->connect_status = LBS_DISCONNECTED; + priv->mesh_connect_status = LBS_DISCONNECTED; + priv->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM; + priv->mode = IW_MODE_INFRA; + priv->curbssparams.channel = DEFAULT_AD_HOC_CHANNEL; + priv->currentpacketfilter = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON; + priv->radioon = RADIO_ON; + priv->auto_rate = 1; + priv->capability = WLAN_CAPABILITY_SHORT_PREAMBLE; + priv->psmode = LBS802_11POWERMODECAM; + priv->psstate = PS_STATE_FULL_POWER; - memset(&adapter->tx_queue_ps, 0, NR_TX_QUEUE*sizeof(struct sk_buff*)); - adapter->tx_queue_idx = 0; - spin_lock_init(&adapter->txqueue_lock); + mutex_init(&priv->lock); - setup_timer(&adapter->command_timer, command_timer_fn, - (unsigned long)priv); + setup_timer(&priv->command_timer, command_timer_fn, + (unsigned long)priv); - INIT_LIST_HEAD(&adapter->cmdfreeq); - INIT_LIST_HEAD(&adapter->cmdpendingq); + INIT_LIST_HEAD(&priv->cmdfreeq); + INIT_LIST_HEAD(&priv->cmdpendingq); - spin_lock_init(&adapter->driver_lock); - init_waitqueue_head(&adapter->cmd_pending); - adapter->nr_cmd_pending = 0; + spin_lock_init(&priv->driver_lock); + init_waitqueue_head(&priv->cmd_pending); /* Allocate the command buffers */ - if (libertas_allocate_cmd_buffer(priv)) { + if (lbs_allocate_cmd_buffer(priv)) { lbs_pr_err("Out of memory allocating command buffers\n"); ret = -1; } out: + lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); + return ret; } -static void libertas_free_adapter(wlan_private * priv) +static void lbs_free_adapter(struct lbs_private *priv) { - wlan_adapter *adapter = priv->adapter; - - if (!adapter) { - lbs_deb_fw("why double free adapter?\n"); - return; - } - - lbs_deb_fw("free command buffer\n"); - libertas_free_cmd_buffer(priv); - - lbs_deb_fw("free command_timer\n"); - del_timer(&adapter->command_timer); + lbs_deb_enter(LBS_DEB_MAIN); - lbs_deb_fw("free scan results table\n"); - kfree(adapter->networks); - adapter->networks = NULL; + lbs_free_cmd_buffer(priv); + del_timer(&priv->command_timer); + kfree(priv->networks); + priv->networks = NULL; - /* Free the adapter object itself */ - lbs_deb_fw("free adapter\n"); - kfree(adapter); - priv->adapter = NULL; + lbs_deb_leave(LBS_DEB_MAIN); } /** * @brief This function adds the card. it will probe the - * card, allocate the wlan_priv and initialize the device. + * card, allocate the lbs_priv and initialize the device. * * @param card A pointer to card - * @return A pointer to wlan_private structure + * @return A pointer to struct lbs_private structure */ -wlan_private *libertas_add_card(void *card, struct device *dmdev) +struct lbs_private *lbs_add_card(void *card, struct device *dmdev) { struct net_device *dev = NULL; - wlan_private *priv = NULL; + struct lbs_private *priv = NULL; - lbs_deb_enter(LBS_DEB_NET); + lbs_deb_enter(LBS_DEB_MAIN); /* Allocate an Ethernet device and register it */ - if (!(dev = alloc_etherdev(sizeof(wlan_private)))) { + dev = alloc_etherdev(sizeof(struct lbs_private)); + if (!dev) { lbs_pr_err("init ethX device failed\n"); goto done; } priv = dev->priv; - /* allocate buffer for wlan_adapter */ - if (!(priv->adapter = kzalloc(sizeof(wlan_adapter), GFP_KERNEL))) { - lbs_pr_err("allocate buffer for wlan_adapter failed\n"); - goto err_kzalloc; - } - - if (libertas_init_adapter(priv)) { + if (lbs_init_adapter(priv)) { lbs_pr_err("failed to initialize adapter structure.\n"); goto err_init_adapter; } @@ -1151,81 +1097,78 @@ wlan_private *libertas_add_card(void *card, struct device *dmdev) priv->card = card; priv->mesh_open = 0; priv->infra_open = 0; - priv->hotplug_device = dmdev; /* Setup the OS Interface to our functions */ - dev->open = libertas_open; - dev->hard_start_xmit = libertas_pre_start_xmit; - dev->stop = libertas_close; - dev->set_mac_address = libertas_set_mac_address; - dev->tx_timeout = libertas_tx_timeout; - dev->get_stats = libertas_get_stats; + dev->open = lbs_dev_open; + dev->hard_start_xmit = lbs_hard_start_xmit; + dev->stop = lbs_eth_stop; + dev->set_mac_address = lbs_set_mac_address; + dev->tx_timeout = lbs_tx_timeout; + dev->get_stats = lbs_get_stats; dev->watchdog_timeo = 5 * HZ; - dev->ethtool_ops = &libertas_ethtool_ops; + dev->ethtool_ops = &lbs_ethtool_ops; #ifdef WIRELESS_EXT - dev->wireless_handlers = (struct iw_handler_def *)&libertas_handler_def; + dev->wireless_handlers = (struct iw_handler_def *)&lbs_handler_def; #endif dev->flags |= IFF_BROADCAST | IFF_MULTICAST; - dev->set_multicast_list = libertas_set_multicast_list; + dev->set_multicast_list = lbs_set_multicast_list; SET_NETDEV_DEV(dev, dmdev); priv->rtap_net_dev = NULL; - if (device_create_file(dmdev, &dev_attr_libertas_rtap)) - goto err_init_adapter; lbs_deb_thread("Starting main thread...\n"); init_waitqueue_head(&priv->waitq); - priv->main_thread = kthread_run(libertas_thread, dev, "libertas_main"); + priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main"); if (IS_ERR(priv->main_thread)) { lbs_deb_thread("Error creating main thread.\n"); - goto err_kthread_run; + goto err_init_adapter; } - priv->work_thread = create_singlethread_workqueue("libertas_worker"); - INIT_DELAYED_WORK(&priv->assoc_work, libertas_association_worker); - INIT_DELAYED_WORK(&priv->scan_work, libertas_scan_worker); - INIT_WORK(&priv->sync_channel, libertas_sync_channel); + priv->work_thread = create_singlethread_workqueue("lbs_worker"); + INIT_DELAYED_WORK(&priv->assoc_work, lbs_association_worker); + INIT_DELAYED_WORK(&priv->scan_work, lbs_scan_worker); + INIT_WORK(&priv->sync_channel, lbs_sync_channel); - goto done; + sprintf(priv->mesh_ssid, "mesh"); + priv->mesh_ssid_len = 4; -err_kthread_run: - device_remove_file(dmdev, &dev_attr_libertas_rtap); + priv->wol_criteria = 0xffffffff; + priv->wol_gpio = 0xff; -err_init_adapter: - libertas_free_adapter(priv); + goto done; -err_kzalloc: +err_init_adapter: + lbs_free_adapter(priv); free_netdev(dev); priv = NULL; done: - lbs_deb_leave_args(LBS_DEB_NET, "priv %p", priv); + lbs_deb_leave_args(LBS_DEB_MAIN, "priv %p", priv); return priv; } -EXPORT_SYMBOL_GPL(libertas_add_card); +EXPORT_SYMBOL_GPL(lbs_add_card); -int libertas_remove_card(wlan_private *priv) +int lbs_remove_card(struct lbs_private *priv) { - wlan_adapter *adapter = priv->adapter; struct net_device *dev = priv->dev; union iwreq_data wrqu; lbs_deb_enter(LBS_DEB_MAIN); - libertas_remove_rtap(priv); + lbs_remove_mesh(priv); + lbs_remove_rtap(priv); dev = priv->dev; - device_remove_file(priv->hotplug_device, &dev_attr_libertas_rtap); cancel_delayed_work(&priv->scan_work); cancel_delayed_work(&priv->assoc_work); destroy_workqueue(priv->work_thread); - if (adapter->psmode == WLAN802_11POWERMODEMAX_PSP) { - adapter->psmode = WLAN802_11POWERMODECAM; - libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP); + if (priv->psmode == LBS802_11POWERMODEMAX_PSP) { + priv->psmode = LBS802_11POWERMODECAM; + lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP); } memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN); @@ -1233,10 +1176,10 @@ int libertas_remove_card(wlan_private *priv) wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL); /* Stop the thread servicing the interrupts */ - adapter->surpriseremoved = 1; + priv->surpriseremoved = 1; kthread_stop(priv->main_thread); - libertas_free_adapter(priv); + lbs_free_adapter(priv); priv->dev = NULL; free_netdev(dev); @@ -1244,10 +1187,10 @@ int libertas_remove_card(wlan_private *priv) lbs_deb_leave(LBS_DEB_MAIN); return 0; } -EXPORT_SYMBOL_GPL(libertas_remove_card); +EXPORT_SYMBOL_GPL(lbs_remove_card); -int libertas_start_card(wlan_private *priv) +int lbs_start_card(struct lbs_private *priv) { struct net_device *dev = priv->dev; int ret = -1; @@ -1255,19 +1198,52 @@ int libertas_start_card(wlan_private *priv) lbs_deb_enter(LBS_DEB_MAIN); /* poke the firmware */ - ret = wlan_setup_firmware(priv); + ret = lbs_setup_firmware(priv); if (ret) goto done; /* init 802.11d */ - libertas_init_11d(priv); + lbs_init_11d(priv); if (register_netdev(dev)) { lbs_pr_err("cannot register ethX device\n"); goto done; } + if (device_create_file(&dev->dev, &dev_attr_lbs_rtap)) + lbs_pr_err("cannot register lbs_rtap attribute\n"); + + lbs_update_channel(priv); + + /* 5.0.16p0 is known to NOT support any mesh */ + if (priv->fwrelease > 0x05001000) { + /* Enable mesh, if supported, and work out which TLV it uses. + 0x100 + 291 is an unofficial value used in 5.110.20.pXX + 0x100 + 37 is the official value used in 5.110.21.pXX + but we check them in that order because 20.pXX doesn't + give an error -- it just silently fails. */ + + /* 5.110.20.pXX firmware will fail the command if the channel + doesn't match the existing channel. But only if the TLV + is correct. If the channel is wrong, _BOTH_ versions will + give an error to 0x100+291, and allow 0x100+37 to succeed. + It's just that 5.110.20.pXX will not have done anything + useful */ + + priv->mesh_tlv = 0x100 + 291; + if (lbs_mesh_config(priv, 1, priv->curbssparams.channel)) { + priv->mesh_tlv = 0x100 + 37; + if (lbs_mesh_config(priv, 1, priv->curbssparams.channel)) + priv->mesh_tlv = 0; + } + if (priv->mesh_tlv) { + lbs_add_mesh(priv); - libertas_debugfs_init_one(priv, dev); + if (device_create_file(&dev->dev, &dev_attr_lbs_mesh)) + lbs_pr_err("cannot register lbs_mesh attribute\n"); + } + } + + lbs_debugfs_init_one(priv, dev); lbs_pr_info("%s: Marvell WLAN 802.11 adapter\n", dev->name); @@ -1277,10 +1253,10 @@ done: lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); return ret; } -EXPORT_SYMBOL_GPL(libertas_start_card); +EXPORT_SYMBOL_GPL(lbs_start_card); -int libertas_stop_card(wlan_private *priv) +int lbs_stop_card(struct lbs_private *priv) { struct net_device *dev = priv->dev; int ret = -1; @@ -1292,31 +1268,35 @@ int libertas_stop_card(wlan_private *priv) netif_stop_queue(priv->dev); netif_carrier_off(priv->dev); - libertas_debugfs_remove_one(priv); + lbs_debugfs_remove_one(priv); + device_remove_file(&dev->dev, &dev_attr_lbs_rtap); + if (priv->mesh_tlv) + device_remove_file(&dev->dev, &dev_attr_lbs_mesh); /* Flush pending command nodes */ - spin_lock_irqsave(&priv->adapter->driver_lock, flags); - list_for_each_entry(cmdnode, &priv->adapter->cmdpendingq, list) { + spin_lock_irqsave(&priv->driver_lock, flags); + list_for_each_entry(cmdnode, &priv->cmdpendingq, list) { + cmdnode->result = -ENOENT; cmdnode->cmdwaitqwoken = 1; wake_up_interruptible(&cmdnode->cmdwait_q); } - spin_unlock_irqrestore(&priv->adapter->driver_lock, flags); + spin_unlock_irqrestore(&priv->driver_lock, flags); unregister_netdev(dev); lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); return ret; } -EXPORT_SYMBOL_GPL(libertas_stop_card); +EXPORT_SYMBOL_GPL(lbs_stop_card); /** * @brief This function adds mshX interface * - * @param priv A pointer to the wlan_private structure + * @param priv A pointer to the struct lbs_private structure * @return 0 if successful, -X otherwise */ -int libertas_add_mesh(wlan_private *priv, struct device *dev) +static int lbs_add_mesh(struct lbs_private *priv) { struct net_device *mesh_dev = NULL; int ret = 0; @@ -1332,16 +1312,16 @@ int libertas_add_mesh(wlan_private *priv, struct device *dev) mesh_dev->priv = priv; priv->mesh_dev = mesh_dev; - mesh_dev->open = libertas_mesh_open; - mesh_dev->hard_start_xmit = libertas_mesh_pre_start_xmit; - mesh_dev->stop = libertas_mesh_close; - mesh_dev->get_stats = libertas_get_stats; - mesh_dev->set_mac_address = libertas_set_mac_address; - mesh_dev->ethtool_ops = &libertas_ethtool_ops; + mesh_dev->open = lbs_dev_open; + mesh_dev->hard_start_xmit = lbs_hard_start_xmit; + mesh_dev->stop = lbs_mesh_stop; + mesh_dev->get_stats = lbs_get_stats; + mesh_dev->set_mac_address = lbs_set_mac_address; + mesh_dev->ethtool_ops = &lbs_ethtool_ops; memcpy(mesh_dev->dev_addr, priv->dev->dev_addr, sizeof(priv->dev->dev_addr)); - SET_NETDEV_DEV(priv->mesh_dev, dev); + SET_NETDEV_DEV(priv->mesh_dev, priv->dev->dev.parent); #ifdef WIRELESS_EXT mesh_dev->wireless_handlers = (struct iw_handler_def *)&mesh_handler_def; @@ -1353,7 +1333,7 @@ int libertas_add_mesh(wlan_private *priv, struct device *dev) goto err_free; } - ret = sysfs_create_group(&(mesh_dev->dev.kobj), &libertas_mesh_attr_group); + ret = sysfs_create_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group); if (ret) goto err_unregister; @@ -1371,33 +1351,28 @@ done: lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret); return ret; } -EXPORT_SYMBOL_GPL(libertas_add_mesh); +EXPORT_SYMBOL_GPL(lbs_add_mesh); -void libertas_remove_mesh(wlan_private *priv) +static void lbs_remove_mesh(struct lbs_private *priv) { struct net_device *mesh_dev; - lbs_deb_enter(LBS_DEB_MAIN); - - if (!priv) - goto out; mesh_dev = priv->mesh_dev; + if (!mesh_dev) + return; + lbs_deb_enter(LBS_DEB_MESH); netif_stop_queue(mesh_dev); netif_carrier_off(priv->mesh_dev); - - sysfs_remove_group(&(mesh_dev->dev.kobj), &libertas_mesh_attr_group); + sysfs_remove_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group); unregister_netdev(mesh_dev); - - priv->mesh_dev = NULL ; + priv->mesh_dev = NULL; free_netdev(mesh_dev); - -out: - lbs_deb_leave(LBS_DEB_MAIN); + lbs_deb_leave(LBS_DEB_MESH); } -EXPORT_SYMBOL_GPL(libertas_remove_mesh); +EXPORT_SYMBOL_GPL(lbs_remove_mesh); /** * @brief This function finds the CFP in @@ -1408,7 +1383,7 @@ EXPORT_SYMBOL_GPL(libertas_remove_mesh); * @param cfp_no A pointer to CFP number * @return A pointer to CFP */ -struct chan_freq_power *libertas_get_region_cfp_table(u8 region, u8 band, int *cfp_no) +struct chan_freq_power *lbs_get_region_cfp_table(u8 region, u8 band, int *cfp_no) { int i, end; @@ -1430,9 +1405,8 @@ struct chan_freq_power *libertas_get_region_cfp_table(u8 region, u8 band, int *c return NULL; } -int libertas_set_regiontable(wlan_private * priv, u8 region, u8 band) +int lbs_set_regiontable(struct lbs_private *priv, u8 region, u8 band) { - wlan_adapter *adapter = priv->adapter; int ret = 0; int i = 0; @@ -1441,24 +1415,22 @@ int libertas_set_regiontable(wlan_private * priv, u8 region, u8 band) lbs_deb_enter(LBS_DEB_MAIN); - memset(adapter->region_channel, 0, sizeof(adapter->region_channel)); + memset(priv->region_channel, 0, sizeof(priv->region_channel)); - { - cfp = libertas_get_region_cfp_table(region, band, &cfp_no); - if (cfp != NULL) { - adapter->region_channel[i].nrcfp = cfp_no; - adapter->region_channel[i].CFP = cfp; - } else { - lbs_deb_main("wrong region code %#x in band B/G\n", - region); - ret = -1; - goto out; - } - adapter->region_channel[i].valid = 1; - adapter->region_channel[i].region = region; - adapter->region_channel[i].band = band; - i++; + cfp = lbs_get_region_cfp_table(region, band, &cfp_no); + if (cfp != NULL) { + priv->region_channel[i].nrcfp = cfp_no; + priv->region_channel[i].CFP = cfp; + } else { + lbs_deb_main("wrong region code %#x in band B/G\n", + region); + ret = -1; + goto out; } + priv->region_channel[i].valid = 1; + priv->region_channel[i].region = region; + priv->region_channel[i].band = band; + i++; out: lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); return ret; @@ -1472,58 +1444,46 @@ out: * @param dev A pointer to net_device structure * @return n/a */ -void libertas_interrupt(struct net_device *dev) +void lbs_interrupt(struct lbs_private *priv) { - wlan_private *priv = dev->priv; - lbs_deb_enter(LBS_DEB_THREAD); - lbs_deb_thread("libertas_interrupt: intcounter=%d\n", - priv->adapter->intcounter); - - priv->adapter->intcounter++; - - if (priv->adapter->psstate == PS_STATE_SLEEP) { - priv->adapter->psstate = PS_STATE_AWAKE; - netif_wake_queue(dev); - if (priv->mesh_dev) - netif_wake_queue(priv->mesh_dev); - } - + lbs_deb_thread("lbs_interrupt: intcounter=%d\n", priv->intcounter); + priv->intcounter++; + if (priv->psstate == PS_STATE_SLEEP) + priv->psstate = PS_STATE_AWAKE; wake_up_interruptible(&priv->waitq); lbs_deb_leave(LBS_DEB_THREAD); } -EXPORT_SYMBOL_GPL(libertas_interrupt); +EXPORT_SYMBOL_GPL(lbs_interrupt); -int libertas_reset_device(wlan_private *priv) +int lbs_reset_device(struct lbs_private *priv) { int ret; lbs_deb_enter(LBS_DEB_MAIN); - ret = libertas_prepare_and_send_command(priv, CMD_802_11_RESET, + ret = lbs_prepare_and_send_command(priv, CMD_802_11_RESET, CMD_ACT_HALT, 0, 0, NULL); msleep_interruptible(10); lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); return ret; } -EXPORT_SYMBOL_GPL(libertas_reset_device); +EXPORT_SYMBOL_GPL(lbs_reset_device); -static int libertas_init_module(void) +static int __init lbs_init_module(void) { lbs_deb_enter(LBS_DEB_MAIN); - libertas_debugfs_init(); + lbs_debugfs_init(); lbs_deb_leave(LBS_DEB_MAIN); return 0; } -static void libertas_exit_module(void) +static void __exit lbs_exit_module(void) { lbs_deb_enter(LBS_DEB_MAIN); - - libertas_debugfs_remove(); - + lbs_debugfs_remove(); lbs_deb_leave(LBS_DEB_MAIN); } @@ -1531,79 +1491,89 @@ static void libertas_exit_module(void) * rtap interface support fuctions */ -static int libertas_rtap_open(struct net_device *dev) +static int lbs_rtap_open(struct net_device *dev) { - netif_carrier_off(dev); - netif_stop_queue(dev); - return 0; + /* Yes, _stop_ the queue. Because we don't support injection */ + lbs_deb_enter(LBS_DEB_MAIN); + netif_carrier_off(dev); + netif_stop_queue(dev); + lbs_deb_leave(LBS_DEB_LEAVE); + return 0; } -static int libertas_rtap_stop(struct net_device *dev) +static int lbs_rtap_stop(struct net_device *dev) { - return 0; + lbs_deb_enter(LBS_DEB_MAIN); + lbs_deb_leave(LBS_DEB_MAIN); + return 0; } -static int libertas_rtap_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) +static int lbs_rtap_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) { - netif_stop_queue(dev); - return -EOPNOTSUPP; + netif_stop_queue(dev); + return NETDEV_TX_BUSY; } -static struct net_device_stats *libertas_rtap_get_stats(struct net_device *dev) +static struct net_device_stats *lbs_rtap_get_stats(struct net_device *dev) { - wlan_private *priv = dev->priv; - return &priv->ieee->stats; + struct lbs_private *priv = dev->priv; + lbs_deb_enter(LBS_DEB_NET); + return &priv->stats; } -void libertas_remove_rtap(wlan_private *priv) +static void lbs_remove_rtap(struct lbs_private *priv) { + lbs_deb_enter(LBS_DEB_MAIN); if (priv->rtap_net_dev == NULL) return; unregister_netdev(priv->rtap_net_dev); - free_ieee80211(priv->rtap_net_dev); + free_netdev(priv->rtap_net_dev); priv->rtap_net_dev = NULL; + lbs_deb_leave(LBS_DEB_MAIN); } -int libertas_add_rtap(wlan_private *priv) +static int lbs_add_rtap(struct lbs_private *priv) { - int rc = 0; - - if (priv->rtap_net_dev) - return -EPERM; - - priv->rtap_net_dev = alloc_ieee80211(0); - if (priv->rtap_net_dev == NULL) - return -ENOMEM; - - - priv->ieee = netdev_priv(priv->rtap_net_dev); + int ret = 0; + struct net_device *rtap_dev; - strcpy(priv->rtap_net_dev->name, "rtap%d"); + lbs_deb_enter(LBS_DEB_MAIN); + if (priv->rtap_net_dev) { + ret = -EPERM; + goto out; + } - priv->rtap_net_dev->type = ARPHRD_IEEE80211_RADIOTAP; - priv->rtap_net_dev->open = libertas_rtap_open; - priv->rtap_net_dev->stop = libertas_rtap_stop; - priv->rtap_net_dev->get_stats = libertas_rtap_get_stats; - priv->rtap_net_dev->hard_start_xmit = libertas_rtap_hard_start_xmit; - priv->rtap_net_dev->set_multicast_list = libertas_set_multicast_list; - priv->rtap_net_dev->priv = priv; + rtap_dev = alloc_netdev(0, "rtap%d", ether_setup); + if (rtap_dev == NULL) { + ret = -ENOMEM; + goto out; + } - priv->ieee->iw_mode = IW_MODE_MONITOR; + memcpy(rtap_dev->dev_addr, priv->current_addr, ETH_ALEN); + rtap_dev->type = ARPHRD_IEEE80211_RADIOTAP; + rtap_dev->open = lbs_rtap_open; + rtap_dev->stop = lbs_rtap_stop; + rtap_dev->get_stats = lbs_rtap_get_stats; + rtap_dev->hard_start_xmit = lbs_rtap_hard_start_xmit; + rtap_dev->set_multicast_list = lbs_set_multicast_list; + rtap_dev->priv = priv; - rc = register_netdev(priv->rtap_net_dev); - if (rc) { - free_ieee80211(priv->rtap_net_dev); - priv->rtap_net_dev = NULL; - return rc; + ret = register_netdev(rtap_dev); + if (ret) { + free_netdev(rtap_dev); + goto out; } + priv->rtap_net_dev = rtap_dev; - return 0; +out: + lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); + return ret; } -module_init(libertas_init_module); -module_exit(libertas_exit_module); +module_init(lbs_init_module); +module_exit(lbs_exit_module); MODULE_DESCRIPTION("Libertas WLAN Driver Library"); MODULE_AUTHOR("Marvell International Ltd."); |