Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 1 | /* |
| 2 | * This file contains the major functions in WLAN |
| 3 | * driver. It includes init, exit, open, close and main |
| 4 | * thread etc.. |
| 5 | */ |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 6 | |
Joe Perches | 0e4e06a | 2011-05-02 16:49:14 -0700 | [diff] [blame] | 7 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 8 | |
Paul Gortmaker | ac5c24e9 | 2011-08-30 14:18:44 -0400 | [diff] [blame] | 9 | #include <linux/module.h> |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 10 | #include <linux/delay.h> |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 11 | #include <linux/etherdevice.h> |
Alexey Dobriyan | a6b7a40 | 2011-06-06 10:43:46 +0000 | [diff] [blame] | 12 | #include <linux/hardirq.h> |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 13 | #include <linux/netdevice.h> |
| 14 | #include <linux/if_arp.h> |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 15 | #include <linux/kthread.h> |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 16 | #include <linux/kfifo.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 17 | #include <linux/slab.h> |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 18 | #include <net/cfg80211.h> |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 19 | |
| 20 | #include "host.h" |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 21 | #include "decl.h" |
| 22 | #include "dev.h" |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 23 | #include "cfg.h" |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 24 | #include "debugfs.h" |
Dan Williams | 6e66f03 | 2007-12-11 12:42:16 -0500 | [diff] [blame] | 25 | #include "cmd.h" |
Daniel Drake | 49fee69 | 2011-07-21 20:43:17 +0100 | [diff] [blame] | 26 | #include "mesh.h" |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 27 | |
Dan Williams | 7856a54 | 2007-08-03 09:43:03 -0400 | [diff] [blame] | 28 | #define DRIVER_RELEASE_VERSION "323.p0" |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 29 | const char lbs_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION |
Dan Williams | 3ce4023 | 2007-05-10 23:03:07 -0400 | [diff] [blame] | 30 | #ifdef DEBUG |
| 31 | "-dbg" |
| 32 | #endif |
| 33 | ""; |
| 34 | |
Holger Schurig | a46c641 | 2007-05-25 11:32:07 -0400 | [diff] [blame] | 35 | |
| 36 | /* Module parameters */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 37 | unsigned int lbs_debug; |
| 38 | EXPORT_SYMBOL_GPL(lbs_debug); |
| 39 | module_param_named(libertas_debug, lbs_debug, int, 0644); |
Holger Schurig | a46c641 | 2007-05-25 11:32:07 -0400 | [diff] [blame] | 40 | |
Sascha Silbe | 6bdbdbf4 | 2011-05-11 14:52:34 +0200 | [diff] [blame] | 41 | unsigned int lbs_disablemesh; |
| 42 | EXPORT_SYMBOL_GPL(lbs_disablemesh); |
| 43 | module_param_named(libertas_disablemesh, lbs_disablemesh, int, 0644); |
| 44 | |
Holger Schurig | a46c641 | 2007-05-25 11:32:07 -0400 | [diff] [blame] | 45 | |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 46 | /* |
| 47 | * This global structure is used to send the confirm_sleep command as |
| 48 | * fast as possible down to the firmware. |
| 49 | */ |
Holger Schurig | f539f2e | 2008-03-26 13:22:11 +0100 | [diff] [blame] | 50 | struct cmd_confirm_sleep confirm_sleep; |
| 51 | |
| 52 | |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 53 | /* |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 54 | * the table to keep region code |
| 55 | */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 56 | u16 lbs_region_code_to_index[MRVDRV_MAX_REGION_CODE] = |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 57 | { 0x10, 0x20, 0x30, 0x31, 0x32, 0x40 }; |
| 58 | |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 59 | /* |
Dan Williams | 8c51276 | 2007-08-02 11:40:45 -0400 | [diff] [blame] | 60 | * FW rate table. FW refers to rates by their index in this table, not by the |
| 61 | * rate value itself. Values of 0x00 are |
| 62 | * reserved positions. |
| 63 | */ |
| 64 | static u8 fw_data_rates[MAX_RATES] = |
| 65 | { 0x02, 0x04, 0x0B, 0x16, 0x00, 0x0C, 0x12, |
| 66 | 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C, 0x00 |
| 67 | }; |
| 68 | |
| 69 | /** |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 70 | * lbs_fw_index_to_data_rate - use index to get the data rate |
Dan Williams | 8c51276 | 2007-08-02 11:40:45 -0400 | [diff] [blame] | 71 | * |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 72 | * @idx: The index of data rate |
| 73 | * returns: data rate or 0 |
Dan Williams | 8c51276 | 2007-08-02 11:40:45 -0400 | [diff] [blame] | 74 | */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 75 | u32 lbs_fw_index_to_data_rate(u8 idx) |
Dan Williams | 8c51276 | 2007-08-02 11:40:45 -0400 | [diff] [blame] | 76 | { |
| 77 | if (idx >= sizeof(fw_data_rates)) |
| 78 | idx = 0; |
| 79 | return fw_data_rates[idx]; |
| 80 | } |
| 81 | |
| 82 | /** |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 83 | * lbs_data_rate_to_fw_index - use rate to get the index |
Dan Williams | 8c51276 | 2007-08-02 11:40:45 -0400 | [diff] [blame] | 84 | * |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 85 | * @rate: data rate |
| 86 | * returns: index or 0 |
Dan Williams | 8c51276 | 2007-08-02 11:40:45 -0400 | [diff] [blame] | 87 | */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 88 | u8 lbs_data_rate_to_fw_index(u32 rate) |
Dan Williams | 8c51276 | 2007-08-02 11:40:45 -0400 | [diff] [blame] | 89 | { |
| 90 | u8 i; |
| 91 | |
| 92 | if (!rate) |
| 93 | return 0; |
| 94 | |
| 95 | for (i = 0; i < sizeof(fw_data_rates); i++) { |
| 96 | if (rate == fw_data_rates[i]) |
| 97 | return i; |
| 98 | } |
| 99 | return 0; |
| 100 | } |
| 101 | |
Daniel Drake | 5c1381a | 2011-10-14 12:05:26 +0100 | [diff] [blame] | 102 | int lbs_set_iface_type(struct lbs_private *priv, enum nl80211_iftype type) |
| 103 | { |
| 104 | int ret = 0; |
| 105 | |
| 106 | switch (type) { |
| 107 | case NL80211_IFTYPE_MONITOR: |
| 108 | ret = lbs_set_monitor_mode(priv, 1); |
| 109 | break; |
| 110 | case NL80211_IFTYPE_STATION: |
| 111 | if (priv->wdev->iftype == NL80211_IFTYPE_MONITOR) |
| 112 | ret = lbs_set_monitor_mode(priv, 0); |
| 113 | if (!ret) |
| 114 | ret = lbs_set_snmp_mib(priv, SNMP_MIB_OID_BSS_TYPE, 1); |
| 115 | break; |
| 116 | case NL80211_IFTYPE_ADHOC: |
| 117 | if (priv->wdev->iftype == NL80211_IFTYPE_MONITOR) |
| 118 | ret = lbs_set_monitor_mode(priv, 0); |
| 119 | if (!ret) |
| 120 | ret = lbs_set_snmp_mib(priv, SNMP_MIB_OID_BSS_TYPE, 2); |
| 121 | break; |
| 122 | default: |
| 123 | ret = -ENOTSUPP; |
| 124 | } |
| 125 | return ret; |
| 126 | } |
| 127 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 128 | int lbs_start_iface(struct lbs_private *priv) |
| 129 | { |
| 130 | struct cmd_ds_802_11_mac_address cmd; |
| 131 | int ret; |
| 132 | |
| 133 | if (priv->power_restore) { |
| 134 | ret = priv->power_restore(priv); |
| 135 | if (ret) |
| 136 | return ret; |
| 137 | } |
| 138 | |
| 139 | cmd.hdr.size = cpu_to_le16(sizeof(cmd)); |
| 140 | cmd.action = cpu_to_le16(CMD_ACT_SET); |
| 141 | memcpy(cmd.macadd, priv->current_addr, ETH_ALEN); |
| 142 | |
| 143 | ret = lbs_cmd_with_response(priv, CMD_802_11_MAC_ADDRESS, &cmd); |
| 144 | if (ret) { |
| 145 | lbs_deb_net("set MAC address failed\n"); |
| 146 | goto err; |
| 147 | } |
| 148 | |
Daniel Drake | 5c1381a | 2011-10-14 12:05:26 +0100 | [diff] [blame] | 149 | ret = lbs_set_iface_type(priv, priv->wdev->iftype); |
| 150 | if (ret) { |
| 151 | lbs_deb_net("set iface type failed\n"); |
| 152 | goto err; |
| 153 | } |
| 154 | |
Daniel Drake | 20d2ebe | 2012-07-15 23:44:58 +0100 | [diff] [blame] | 155 | ret = lbs_set_11d_domain_info(priv); |
| 156 | if (ret) { |
| 157 | lbs_deb_net("set 11d domain info failed\n"); |
| 158 | goto err; |
| 159 | } |
| 160 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 161 | lbs_update_channel(priv); |
| 162 | |
| 163 | priv->iface_running = true; |
| 164 | return 0; |
| 165 | |
| 166 | err: |
| 167 | if (priv->power_save) |
| 168 | priv->power_save(priv); |
| 169 | return ret; |
| 170 | } |
Anna Neal | 6fb5325 | 2008-12-09 13:23:45 -0800 | [diff] [blame] | 171 | |
David Woodhouse | 23a397a | 2007-12-11 18:56:42 -0500 | [diff] [blame] | 172 | /** |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 173 | * lbs_dev_open - open the ethX interface |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 174 | * |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 175 | * @dev: A pointer to &net_device structure |
| 176 | * returns: 0 or -EBUSY if monitor mode active |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 177 | */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 178 | static int lbs_dev_open(struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 179 | { |
Kiran Divekar | ab65f64 | 2009-02-19 19:32:39 -0500 | [diff] [blame] | 180 | struct lbs_private *priv = dev->ml_priv; |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 181 | int ret = 0; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 182 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 183 | lbs_deb_enter(LBS_DEB_NET); |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 184 | if (!priv->iface_running) { |
| 185 | ret = lbs_start_iface(priv); |
| 186 | if (ret) |
| 187 | goto out; |
| 188 | } |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 189 | |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 190 | spin_lock_irq(&priv->driver_lock); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 191 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 192 | netif_carrier_off(dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 193 | |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 194 | if (!priv->tx_pending_len) |
| 195 | netif_wake_queue(dev); |
Brajesh Dave | 01d77d8 | 2007-11-20 17:44:14 -0500 | [diff] [blame] | 196 | |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 197 | spin_unlock_irq(&priv->driver_lock); |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 198 | |
| 199 | out: |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 200 | lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 201 | return ret; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 202 | } |
| 203 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 204 | static bool lbs_command_queue_empty(struct lbs_private *priv) |
| 205 | { |
| 206 | unsigned long flags; |
| 207 | bool ret; |
| 208 | spin_lock_irqsave(&priv->driver_lock, flags); |
| 209 | ret = priv->cur_cmd == NULL && list_empty(&priv->cmdpendingq); |
| 210 | spin_unlock_irqrestore(&priv->driver_lock, flags); |
| 211 | return ret; |
| 212 | } |
| 213 | |
| 214 | int lbs_stop_iface(struct lbs_private *priv) |
| 215 | { |
| 216 | unsigned long flags; |
| 217 | int ret = 0; |
| 218 | |
| 219 | lbs_deb_enter(LBS_DEB_MAIN); |
| 220 | |
| 221 | spin_lock_irqsave(&priv->driver_lock, flags); |
| 222 | priv->iface_running = false; |
| 223 | kfree_skb(priv->currenttxskb); |
| 224 | priv->currenttxskb = NULL; |
| 225 | priv->tx_pending_len = 0; |
| 226 | spin_unlock_irqrestore(&priv->driver_lock, flags); |
| 227 | |
| 228 | cancel_work_sync(&priv->mcast_work); |
Daniel Drake | 8f641d9 | 2011-10-03 11:33:02 +0100 | [diff] [blame] | 229 | del_timer_sync(&priv->tx_lockup_timer); |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 230 | |
| 231 | /* Disable command processing, and wait for all commands to complete */ |
| 232 | lbs_deb_main("waiting for commands to complete\n"); |
| 233 | wait_event(priv->waitq, lbs_command_queue_empty(priv)); |
| 234 | lbs_deb_main("all commands completed\n"); |
| 235 | |
| 236 | if (priv->power_save) |
| 237 | ret = priv->power_save(priv); |
| 238 | |
| 239 | lbs_deb_leave(LBS_DEB_MAIN); |
| 240 | return ret; |
| 241 | } |
| 242 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 243 | /** |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 244 | * lbs_eth_stop - close the ethX interface |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 245 | * |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 246 | * @dev: A pointer to &net_device structure |
| 247 | * returns: 0 |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 248 | */ |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 249 | static int lbs_eth_stop(struct net_device *dev) |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 250 | { |
Kiran Divekar | ab65f64 | 2009-02-19 19:32:39 -0500 | [diff] [blame] | 251 | struct lbs_private *priv = dev->ml_priv; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 252 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 253 | lbs_deb_enter(LBS_DEB_NET); |
| 254 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 255 | if (priv->connect_status == LBS_CONNECTED) |
| 256 | lbs_disconnect(priv, WLAN_REASON_DEAUTH_LEAVING); |
| 257 | |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 258 | spin_lock_irq(&priv->driver_lock); |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 259 | netif_stop_queue(dev); |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 260 | spin_unlock_irq(&priv->driver_lock); |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 261 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 262 | lbs_update_mcast(priv); |
Daniel Drake | 2e30168 | 2010-11-04 21:21:52 +0000 | [diff] [blame] | 263 | cancel_delayed_work_sync(&priv->scan_work); |
Andres Salomon | 3209e06 | 2011-10-26 10:19:26 -0700 | [diff] [blame] | 264 | if (priv->scan_req) |
| 265 | lbs_scan_done(priv); |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 266 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 267 | netif_carrier_off(priv->dev); |
| 268 | |
| 269 | if (!lbs_iface_active(priv)) |
| 270 | lbs_stop_iface(priv); |
| 271 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 272 | lbs_deb_leave(LBS_DEB_NET); |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 273 | return 0; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 274 | } |
| 275 | |
David Woodhouse | e775ed7 | 2007-12-06 14:36:11 +0000 | [diff] [blame] | 276 | void lbs_host_to_card_done(struct lbs_private *priv) |
| 277 | { |
David Woodhouse | a63b22b | 2007-12-08 20:56:44 +0000 | [diff] [blame] | 278 | unsigned long flags; |
| 279 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 280 | lbs_deb_enter(LBS_DEB_THREAD); |
| 281 | |
David Woodhouse | a63b22b | 2007-12-08 20:56:44 +0000 | [diff] [blame] | 282 | spin_lock_irqsave(&priv->driver_lock, flags); |
Daniel Drake | 8f641d9 | 2011-10-03 11:33:02 +0100 | [diff] [blame] | 283 | del_timer(&priv->tx_lockup_timer); |
David Woodhouse | e775ed7 | 2007-12-06 14:36:11 +0000 | [diff] [blame] | 284 | |
| 285 | priv->dnld_sent = DNLD_RES_RECEIVED; |
| 286 | |
| 287 | /* Wake main thread if commands are pending */ |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 288 | if (!priv->cur_cmd || priv->tx_pending_len > 0) { |
| 289 | if (!priv->wakeup_dev_required) |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 290 | wake_up(&priv->waitq); |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 291 | } |
David Woodhouse | e775ed7 | 2007-12-06 14:36:11 +0000 | [diff] [blame] | 292 | |
David Woodhouse | a63b22b | 2007-12-08 20:56:44 +0000 | [diff] [blame] | 293 | spin_unlock_irqrestore(&priv->driver_lock, flags); |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 294 | lbs_deb_leave(LBS_DEB_THREAD); |
David Woodhouse | e775ed7 | 2007-12-06 14:36:11 +0000 | [diff] [blame] | 295 | } |
| 296 | EXPORT_SYMBOL_GPL(lbs_host_to_card_done); |
| 297 | |
Holger Schurig | e0e42da | 2009-11-25 13:10:15 +0100 | [diff] [blame] | 298 | int lbs_set_mac_address(struct net_device *dev, void *addr) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 299 | { |
| 300 | int ret = 0; |
Kiran Divekar | ab65f64 | 2009-02-19 19:32:39 -0500 | [diff] [blame] | 301 | struct lbs_private *priv = dev->ml_priv; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 302 | struct sockaddr *phwaddr = addr; |
| 303 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 304 | lbs_deb_enter(LBS_DEB_NET); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 305 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 306 | /* |
| 307 | * Can only set MAC address when all interfaces are down, to be written |
| 308 | * to the hardware when one of them is brought up. |
| 309 | */ |
| 310 | if (lbs_iface_active(priv)) |
| 311 | return -EBUSY; |
| 312 | |
Luis Carlos Cobo Rus | 0a0d08a | 2007-05-25 23:05:27 -0400 | [diff] [blame] | 313 | /* In case it was called from the mesh device */ |
Holger Schurig | 2af9f03 | 2008-03-26 09:58:32 +0100 | [diff] [blame] | 314 | dev = priv->dev; |
Luis Carlos Cobo Rus | 0a0d08a | 2007-05-25 23:05:27 -0400 | [diff] [blame] | 315 | |
Holger Schurig | 2af9f03 | 2008-03-26 09:58:32 +0100 | [diff] [blame] | 316 | memcpy(priv->current_addr, phwaddr->sa_data, ETH_ALEN); |
| 317 | memcpy(dev->dev_addr, phwaddr->sa_data, ETH_ALEN); |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 318 | if (priv->mesh_dev) |
Holger Schurig | 2af9f03 | 2008-03-26 09:58:32 +0100 | [diff] [blame] | 319 | memcpy(priv->mesh_dev->dev_addr, phwaddr->sa_data, ETH_ALEN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 320 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 321 | lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 322 | return ret; |
| 323 | } |
| 324 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 325 | |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 326 | static inline int mac_in_list(unsigned char *list, int list_len, |
| 327 | unsigned char *mac) |
| 328 | { |
| 329 | while (list_len) { |
| 330 | if (!memcmp(list, mac, ETH_ALEN)) |
| 331 | return 1; |
| 332 | list += ETH_ALEN; |
| 333 | list_len--; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 334 | } |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 335 | return 0; |
| 336 | } |
| 337 | |
| 338 | |
| 339 | static int lbs_add_mcast_addrs(struct cmd_ds_mac_multicast_adr *cmd, |
| 340 | struct net_device *dev, int nr_addrs) |
| 341 | { |
| 342 | int i = nr_addrs; |
Jiri Pirko | 22bedad3 | 2010-04-01 21:22:57 +0000 | [diff] [blame] | 343 | struct netdev_hw_addr *ha; |
Jiri Pirko | 655ffee | 2010-02-27 07:35:45 +0000 | [diff] [blame] | 344 | int cnt; |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 345 | |
| 346 | if ((dev->flags & (IFF_UP|IFF_MULTICAST)) != (IFF_UP|IFF_MULTICAST)) |
| 347 | return nr_addrs; |
| 348 | |
David S. Miller | b9e4085 | 2008-07-15 00:15:08 -0700 | [diff] [blame] | 349 | netif_addr_lock_bh(dev); |
Jiri Pirko | 655ffee | 2010-02-27 07:35:45 +0000 | [diff] [blame] | 350 | cnt = netdev_mc_count(dev); |
Jiri Pirko | 22bedad3 | 2010-04-01 21:22:57 +0000 | [diff] [blame] | 351 | netdev_for_each_mc_addr(ha, dev) { |
| 352 | if (mac_in_list(cmd->maclist, nr_addrs, ha->addr)) { |
Johannes Berg | e174961 | 2008-10-27 15:59:26 -0700 | [diff] [blame] | 353 | lbs_deb_net("mcast address %s:%pM skipped\n", dev->name, |
Jiri Pirko | 22bedad3 | 2010-04-01 21:22:57 +0000 | [diff] [blame] | 354 | ha->addr); |
Jiri Pirko | 655ffee | 2010-02-27 07:35:45 +0000 | [diff] [blame] | 355 | cnt--; |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 356 | continue; |
| 357 | } |
| 358 | |
| 359 | if (i == MRVDRV_MAX_MULTICAST_LIST_SIZE) |
| 360 | break; |
Jiri Pirko | 22bedad3 | 2010-04-01 21:22:57 +0000 | [diff] [blame] | 361 | memcpy(&cmd->maclist[6*i], ha->addr, ETH_ALEN); |
Johannes Berg | e174961 | 2008-10-27 15:59:26 -0700 | [diff] [blame] | 362 | lbs_deb_net("mcast address %s:%pM added to filter\n", dev->name, |
Jiri Pirko | 22bedad3 | 2010-04-01 21:22:57 +0000 | [diff] [blame] | 363 | ha->addr); |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 364 | i++; |
Jiri Pirko | 655ffee | 2010-02-27 07:35:45 +0000 | [diff] [blame] | 365 | cnt--; |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 366 | } |
David S. Miller | b9e4085 | 2008-07-15 00:15:08 -0700 | [diff] [blame] | 367 | netif_addr_unlock_bh(dev); |
Jiri Pirko | 655ffee | 2010-02-27 07:35:45 +0000 | [diff] [blame] | 368 | if (cnt) |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 369 | return -EOVERFLOW; |
| 370 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 371 | return i; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 372 | } |
| 373 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 374 | void lbs_update_mcast(struct lbs_private *priv) |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 375 | { |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 376 | struct cmd_ds_mac_multicast_adr mcast_cmd; |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 377 | int dev_flags = 0; |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 378 | int nr_addrs; |
| 379 | int old_mac_control = priv->mac_control; |
| 380 | |
| 381 | lbs_deb_enter(LBS_DEB_NET); |
| 382 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 383 | if (netif_running(priv->dev)) |
| 384 | dev_flags |= priv->dev->flags; |
| 385 | if (priv->mesh_dev && netif_running(priv->mesh_dev)) |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 386 | dev_flags |= priv->mesh_dev->flags; |
| 387 | |
| 388 | if (dev_flags & IFF_PROMISC) { |
| 389 | priv->mac_control |= CMD_ACT_MAC_PROMISCUOUS_ENABLE; |
| 390 | priv->mac_control &= ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE | |
| 391 | CMD_ACT_MAC_MULTICAST_ENABLE); |
| 392 | goto out_set_mac_control; |
| 393 | } else if (dev_flags & IFF_ALLMULTI) { |
| 394 | do_allmulti: |
| 395 | priv->mac_control |= CMD_ACT_MAC_ALL_MULTICAST_ENABLE; |
| 396 | priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE | |
| 397 | CMD_ACT_MAC_MULTICAST_ENABLE); |
| 398 | goto out_set_mac_control; |
| 399 | } |
| 400 | |
| 401 | /* Once for priv->dev, again for priv->mesh_dev if it exists */ |
| 402 | nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->dev, 0); |
| 403 | if (nr_addrs >= 0 && priv->mesh_dev) |
| 404 | nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->mesh_dev, nr_addrs); |
| 405 | if (nr_addrs < 0) |
| 406 | goto do_allmulti; |
| 407 | |
| 408 | if (nr_addrs) { |
| 409 | int size = offsetof(struct cmd_ds_mac_multicast_adr, |
| 410 | maclist[6*nr_addrs]); |
| 411 | |
| 412 | mcast_cmd.action = cpu_to_le16(CMD_ACT_SET); |
| 413 | mcast_cmd.hdr.size = cpu_to_le16(size); |
| 414 | mcast_cmd.nr_of_adrs = cpu_to_le16(nr_addrs); |
| 415 | |
| 416 | lbs_cmd_async(priv, CMD_MAC_MULTICAST_ADR, &mcast_cmd.hdr, size); |
| 417 | |
| 418 | priv->mac_control |= CMD_ACT_MAC_MULTICAST_ENABLE; |
| 419 | } else |
| 420 | priv->mac_control &= ~CMD_ACT_MAC_MULTICAST_ENABLE; |
| 421 | |
| 422 | priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE | |
| 423 | CMD_ACT_MAC_ALL_MULTICAST_ENABLE); |
| 424 | out_set_mac_control: |
| 425 | if (priv->mac_control != old_mac_control) |
| 426 | lbs_set_mac_control(priv); |
| 427 | |
| 428 | lbs_deb_leave(LBS_DEB_NET); |
| 429 | } |
| 430 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 431 | static void lbs_set_mcast_worker(struct work_struct *work) |
| 432 | { |
| 433 | struct lbs_private *priv = container_of(work, struct lbs_private, mcast_work); |
| 434 | lbs_update_mcast(priv); |
| 435 | } |
| 436 | |
Holger Schurig | e0e42da | 2009-11-25 13:10:15 +0100 | [diff] [blame] | 437 | void lbs_set_multicast_list(struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 438 | { |
Kiran Divekar | ab65f64 | 2009-02-19 19:32:39 -0500 | [diff] [blame] | 439 | struct lbs_private *priv = dev->ml_priv; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 440 | |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 441 | schedule_work(&priv->mcast_work); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 442 | } |
| 443 | |
| 444 | /** |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 445 | * lbs_thread - handles the major jobs in the LBS driver. |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 446 | * It handles all events generated by firmware, RX data received |
| 447 | * from firmware and TX data sent from kernel. |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 448 | * |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 449 | * @data: A pointer to &lbs_thread structure |
| 450 | * returns: 0 |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 451 | */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 452 | static int lbs_thread(void *data) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 453 | { |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 454 | struct net_device *dev = data; |
Kiran Divekar | ab65f64 | 2009-02-19 19:32:39 -0500 | [diff] [blame] | 455 | struct lbs_private *priv = dev->ml_priv; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 456 | wait_queue_t wait; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 457 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 458 | lbs_deb_enter(LBS_DEB_THREAD); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 459 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 460 | init_waitqueue_entry(&wait, current); |
| 461 | |
| 462 | for (;;) { |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 463 | int shouldsleep; |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 464 | u8 resp_idx; |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 465 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 466 | lbs_deb_thread("1: currenttxskb %p, dnld_sent %d\n", |
| 467 | priv->currenttxskb, priv->dnld_sent); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 468 | |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 469 | add_wait_queue(&priv->waitq, &wait); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 470 | set_current_state(TASK_INTERRUPTIBLE); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 471 | spin_lock_irq(&priv->driver_lock); |
David Woodhouse | 59f3e4b | 2007-12-08 17:42:59 +0000 | [diff] [blame] | 472 | |
David Woodhouse | d9f8870 | 2007-12-13 21:48:00 -0500 | [diff] [blame] | 473 | if (kthread_should_stop()) |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 474 | shouldsleep = 0; /* Bye */ |
David Woodhouse | d9f8870 | 2007-12-13 21:48:00 -0500 | [diff] [blame] | 475 | else if (priv->surpriseremoved) |
| 476 | shouldsleep = 1; /* We need to wait until we're _told_ to die */ |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 477 | else if (priv->psstate == PS_STATE_SLEEP) |
| 478 | shouldsleep = 1; /* Sleep mode. Nothing we can do till it wakes */ |
David Woodhouse | 2a34509 | 2007-12-15 19:33:43 -0500 | [diff] [blame] | 479 | else if (priv->cmd_timed_out) |
| 480 | shouldsleep = 0; /* Command timed out. Recover */ |
David Woodhouse | b15152a | 2007-12-11 11:55:37 -0500 | [diff] [blame] | 481 | else if (!priv->fw_ready) |
| 482 | shouldsleep = 1; /* Firmware not ready. We're waiting for it */ |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 483 | else if (priv->dnld_sent) |
| 484 | shouldsleep = 1; /* Something is en route to the device already */ |
David Woodhouse | 2eb188a | 2007-12-09 23:54:27 -0500 | [diff] [blame] | 485 | else if (priv->tx_pending_len > 0) |
| 486 | shouldsleep = 0; /* We've a packet to send */ |
Holger Schurig | ef707b8 | 2008-05-23 16:04:13 +0200 | [diff] [blame] | 487 | else if (priv->resp_len[priv->resp_idx]) |
| 488 | shouldsleep = 0; /* We have a command response */ |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 489 | else if (priv->cur_cmd) |
| 490 | shouldsleep = 1; /* Can't send a command; one already running */ |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 491 | else if (!list_empty(&priv->cmdpendingq) && |
| 492 | !(priv->wakeup_dev_required)) |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 493 | shouldsleep = 0; /* We have a command to send */ |
Stefani Seibold | e64c026 | 2009-12-21 14:37:28 -0800 | [diff] [blame] | 494 | else if (kfifo_len(&priv->event_fifo)) |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 495 | shouldsleep = 0; /* We have an event to process */ |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 496 | else |
| 497 | shouldsleep = 1; /* No command */ |
| 498 | |
| 499 | if (shouldsleep) { |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 500 | lbs_deb_thread("sleeping, connect_status %d, " |
Holger Schurig | 5f505d9 | 2008-04-30 10:50:07 +0200 | [diff] [blame] | 501 | "psmode %d, psstate %d\n", |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 502 | priv->connect_status, |
| 503 | priv->psmode, priv->psstate); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 504 | spin_unlock_irq(&priv->driver_lock); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 505 | schedule(); |
| 506 | } else |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 507 | spin_unlock_irq(&priv->driver_lock); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 508 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 509 | lbs_deb_thread("2: currenttxskb %p, dnld_send %d\n", |
| 510 | priv->currenttxskb, priv->dnld_sent); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 511 | |
| 512 | set_current_state(TASK_RUNNING); |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 513 | remove_wait_queue(&priv->waitq, &wait); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 514 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 515 | lbs_deb_thread("3: currenttxskb %p, dnld_sent %d\n", |
| 516 | priv->currenttxskb, priv->dnld_sent); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 517 | |
David Woodhouse | d9f8870 | 2007-12-13 21:48:00 -0500 | [diff] [blame] | 518 | if (kthread_should_stop()) { |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 519 | lbs_deb_thread("break from main thread\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 520 | break; |
| 521 | } |
| 522 | |
David Woodhouse | d9f8870 | 2007-12-13 21:48:00 -0500 | [diff] [blame] | 523 | if (priv->surpriseremoved) { |
| 524 | lbs_deb_thread("adapter removed; waiting to die...\n"); |
| 525 | continue; |
| 526 | } |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 527 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 528 | lbs_deb_thread("4: currenttxskb %p, dnld_sent %d\n", |
| 529 | priv->currenttxskb, priv->dnld_sent); |
| 530 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 531 | /* Process any pending command response */ |
Holger Schurig | a01f545 | 2008-06-04 11:10:40 +0200 | [diff] [blame] | 532 | spin_lock_irq(&priv->driver_lock); |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 533 | resp_idx = priv->resp_idx; |
| 534 | if (priv->resp_len[resp_idx]) { |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 535 | spin_unlock_irq(&priv->driver_lock); |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 536 | lbs_process_command_response(priv, |
| 537 | priv->resp_buf[resp_idx], |
| 538 | priv->resp_len[resp_idx]); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 539 | spin_lock_irq(&priv->driver_lock); |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 540 | priv->resp_len[resp_idx] = 0; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 541 | } |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 542 | spin_unlock_irq(&priv->driver_lock); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 543 | |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 544 | /* Process hardware events, e.g. card removed, link lost */ |
| 545 | spin_lock_irq(&priv->driver_lock); |
Stefani Seibold | e64c026 | 2009-12-21 14:37:28 -0800 | [diff] [blame] | 546 | while (kfifo_len(&priv->event_fifo)) { |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 547 | u32 event; |
Stefani Seibold | 7acd72e | 2009-12-21 14:37:28 -0800 | [diff] [blame] | 548 | |
Stefani Seibold | 9842c38 | 2009-12-21 14:37:29 -0800 | [diff] [blame] | 549 | if (kfifo_out(&priv->event_fifo, |
| 550 | (unsigned char *) &event, sizeof(event)) != |
| 551 | sizeof(event)) |
| 552 | break; |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 553 | spin_unlock_irq(&priv->driver_lock); |
| 554 | lbs_process_event(priv, event); |
| 555 | spin_lock_irq(&priv->driver_lock); |
| 556 | } |
| 557 | spin_unlock_irq(&priv->driver_lock); |
| 558 | |
| 559 | if (priv->wakeup_dev_required) { |
| 560 | lbs_deb_thread("Waking up device...\n"); |
| 561 | /* Wake up device */ |
| 562 | if (priv->exit_deep_sleep(priv)) |
| 563 | lbs_deb_thread("Wakeup device failed\n"); |
| 564 | continue; |
| 565 | } |
| 566 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 567 | /* command timeout stuff */ |
David Woodhouse | 2a34509 | 2007-12-15 19:33:43 -0500 | [diff] [blame] | 568 | if (priv->cmd_timed_out && priv->cur_cmd) { |
| 569 | struct cmd_ctrl_node *cmdnode = priv->cur_cmd; |
| 570 | |
Joe Perches | f3a57fd | 2011-05-02 16:49:15 -0700 | [diff] [blame] | 571 | netdev_info(dev, "Timeout submitting command 0x%04x\n", |
| 572 | le16_to_cpu(cmdnode->cmdbuf->command)); |
Holger Schurig | 40e6fa8 | 2010-02-04 14:37:45 +0100 | [diff] [blame] | 573 | lbs_complete_command(priv, cmdnode, -ETIMEDOUT); |
Daniel Drake | 9d5d496 | 2012-07-30 22:58:04 +0100 | [diff] [blame] | 574 | |
| 575 | /* Reset card, but only when it isn't in the process |
| 576 | * of being shutdown anyway. */ |
| 577 | if (!dev->dismantle && priv->reset_card) |
Holger Schurig | 40e6fa8 | 2010-02-04 14:37:45 +0100 | [diff] [blame] | 578 | priv->reset_card(priv); |
David Woodhouse | 2a34509 | 2007-12-15 19:33:43 -0500 | [diff] [blame] | 579 | } |
| 580 | priv->cmd_timed_out = 0; |
| 581 | |
David Woodhouse | b15152a | 2007-12-11 11:55:37 -0500 | [diff] [blame] | 582 | if (!priv->fw_ready) |
| 583 | continue; |
| 584 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 585 | /* Check if we need to confirm Sleep Request received previously */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 586 | if (priv->psstate == PS_STATE_PRE_SLEEP && |
| 587 | !priv->dnld_sent && !priv->cur_cmd) { |
| 588 | if (priv->connect_status == LBS_CONNECTED) { |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 589 | lbs_deb_thread("pre-sleep, currenttxskb %p, " |
| 590 | "dnld_sent %d, cur_cmd %p\n", |
| 591 | priv->currenttxskb, priv->dnld_sent, |
| 592 | priv->cur_cmd); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 593 | |
Holger Schurig | d4ff0ef | 2008-03-19 14:25:18 +0100 | [diff] [blame] | 594 | lbs_ps_confirm_sleep(priv); |
David Woodhouse | 59f3e4b | 2007-12-08 17:42:59 +0000 | [diff] [blame] | 595 | } else { |
| 596 | /* workaround for firmware sending |
| 597 | * deauth/linkloss event immediately |
| 598 | * after sleep request; remove this |
| 599 | * after firmware fixes it |
| 600 | */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 601 | priv->psstate = PS_STATE_AWAKE; |
Joe Perches | f3a57fd | 2011-05-02 16:49:15 -0700 | [diff] [blame] | 602 | netdev_alert(dev, |
| 603 | "ignore PS_SleepConfirm in non-connected state\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 604 | } |
| 605 | } |
| 606 | |
| 607 | /* The PS state is changed during processing of Sleep Request |
| 608 | * event above |
| 609 | */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 610 | if ((priv->psstate == PS_STATE_SLEEP) || |
| 611 | (priv->psstate == PS_STATE_PRE_SLEEP)) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 612 | continue; |
| 613 | |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 614 | if (priv->is_deep_sleep) |
| 615 | continue; |
| 616 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 617 | /* Execute the next command */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 618 | if (!priv->dnld_sent && !priv->cur_cmd) |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 619 | lbs_execute_next_command(priv); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 620 | |
David Woodhouse | 2eb188a | 2007-12-09 23:54:27 -0500 | [diff] [blame] | 621 | spin_lock_irq(&priv->driver_lock); |
| 622 | if (!priv->dnld_sent && priv->tx_pending_len > 0) { |
| 623 | int ret = priv->hw_host_to_card(priv, MVMS_DAT, |
| 624 | priv->tx_pending_buf, |
| 625 | priv->tx_pending_len); |
| 626 | if (ret) { |
| 627 | lbs_deb_tx("host_to_card failed %d\n", ret); |
| 628 | priv->dnld_sent = DNLD_RES_RECEIVED; |
Daniel Drake | 8f641d9 | 2011-10-03 11:33:02 +0100 | [diff] [blame] | 629 | } else { |
| 630 | mod_timer(&priv->tx_lockup_timer, |
| 631 | jiffies + (HZ * 5)); |
David Woodhouse | 2eb188a | 2007-12-09 23:54:27 -0500 | [diff] [blame] | 632 | } |
| 633 | priv->tx_pending_len = 0; |
| 634 | if (!priv->currenttxskb) { |
| 635 | /* We can wake the queues immediately if we aren't |
| 636 | waiting for TX feedback */ |
| 637 | if (priv->connect_status == LBS_CONNECTED) |
| 638 | netif_wake_queue(priv->dev); |
| 639 | if (priv->mesh_dev && |
Daniel Drake | d931998 | 2011-07-20 17:53:56 +0100 | [diff] [blame] | 640 | netif_running(priv->mesh_dev)) |
David Woodhouse | 2eb188a | 2007-12-09 23:54:27 -0500 | [diff] [blame] | 641 | netif_wake_queue(priv->mesh_dev); |
| 642 | } |
| 643 | } |
| 644 | spin_unlock_irq(&priv->driver_lock); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 645 | } |
| 646 | |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 647 | del_timer(&priv->command_timer); |
Daniel Drake | 8f641d9 | 2011-10-03 11:33:02 +0100 | [diff] [blame] | 648 | del_timer(&priv->tx_lockup_timer); |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 649 | del_timer(&priv->auto_deepsleep_timer); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 650 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 651 | lbs_deb_leave(LBS_DEB_THREAD); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 652 | return 0; |
| 653 | } |
| 654 | |
Vasily Khoruzhick | 75abde4 | 2011-01-21 22:44:49 +0200 | [diff] [blame] | 655 | /** |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 656 | * lbs_setup_firmware - gets the HW spec from the firmware and sets |
| 657 | * some basic parameters |
Vasily Khoruzhick | 75abde4 | 2011-01-21 22:44:49 +0200 | [diff] [blame] | 658 | * |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 659 | * @priv: A pointer to &struct lbs_private structure |
| 660 | * returns: 0 or -1 |
Vasily Khoruzhick | 75abde4 | 2011-01-21 22:44:49 +0200 | [diff] [blame] | 661 | */ |
| 662 | static int lbs_setup_firmware(struct lbs_private *priv) |
| 663 | { |
| 664 | int ret = -1; |
| 665 | s16 curlevel = 0, minlevel = 0, maxlevel = 0; |
| 666 | |
| 667 | lbs_deb_enter(LBS_DEB_FW); |
| 668 | |
| 669 | /* Read MAC address from firmware */ |
Joe Perches | 93803b3 | 2015-03-02 19:54:49 -0800 | [diff] [blame] | 670 | eth_broadcast_addr(priv->current_addr); |
Vasily Khoruzhick | 75abde4 | 2011-01-21 22:44:49 +0200 | [diff] [blame] | 671 | ret = lbs_update_hw_spec(priv); |
| 672 | if (ret) |
| 673 | goto done; |
| 674 | |
| 675 | /* Read power levels if available */ |
| 676 | ret = lbs_get_tx_power(priv, &curlevel, &minlevel, &maxlevel); |
| 677 | if (ret == 0) { |
| 678 | priv->txpower_cur = curlevel; |
| 679 | priv->txpower_min = minlevel; |
| 680 | priv->txpower_max = maxlevel; |
| 681 | } |
| 682 | |
| 683 | /* Send cmd to FW to enable 11D function */ |
| 684 | ret = lbs_set_snmp_mib(priv, SNMP_MIB_OID_11D_ENABLE, 1); |
Daniel Drake | 871fc09 | 2012-09-11 11:38:11 -0400 | [diff] [blame] | 685 | if (ret) |
| 686 | goto done; |
Vasily Khoruzhick | 75abde4 | 2011-01-21 22:44:49 +0200 | [diff] [blame] | 687 | |
Daniel Drake | 871fc09 | 2012-09-11 11:38:11 -0400 | [diff] [blame] | 688 | ret = lbs_set_mac_control_sync(priv); |
Vasily Khoruzhick | 75abde4 | 2011-01-21 22:44:49 +0200 | [diff] [blame] | 689 | done: |
| 690 | lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); |
| 691 | return ret; |
| 692 | } |
| 693 | |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 694 | int lbs_suspend(struct lbs_private *priv) |
| 695 | { |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 696 | int ret; |
| 697 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 698 | lbs_deb_enter(LBS_DEB_FW); |
| 699 | |
Amitkumar Karwar | 66fceb6 | 2010-05-19 03:24:38 -0700 | [diff] [blame] | 700 | if (priv->is_deep_sleep) { |
| 701 | ret = lbs_set_deep_sleep(priv, 0); |
| 702 | if (ret) { |
Joe Perches | f3a57fd | 2011-05-02 16:49:15 -0700 | [diff] [blame] | 703 | netdev_err(priv->dev, |
| 704 | "deep sleep cancellation failed: %d\n", ret); |
Amitkumar Karwar | 66fceb6 | 2010-05-19 03:24:38 -0700 | [diff] [blame] | 705 | return ret; |
| 706 | } |
| 707 | priv->deep_sleep_required = 1; |
David Woodhouse | 506e902 | 2007-12-12 20:06:06 -0500 | [diff] [blame] | 708 | } |
| 709 | |
Amitkumar Karwar | 1311843 | 2010-07-08 06:43:48 +0530 | [diff] [blame] | 710 | ret = lbs_set_host_sleep(priv, 1); |
David Woodhouse | 7e22627 | 2007-12-14 22:53:41 -0500 | [diff] [blame] | 711 | |
Amitkumar Karwar | 66fceb6 | 2010-05-19 03:24:38 -0700 | [diff] [blame] | 712 | netif_device_detach(priv->dev); |
| 713 | if (priv->mesh_dev) |
| 714 | netif_device_detach(priv->mesh_dev); |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 715 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 716 | lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 717 | return ret; |
| 718 | } |
| 719 | EXPORT_SYMBOL_GPL(lbs_suspend); |
| 720 | |
Amitkumar Karwar | 66fceb6 | 2010-05-19 03:24:38 -0700 | [diff] [blame] | 721 | int lbs_resume(struct lbs_private *priv) |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 722 | { |
Amitkumar Karwar | 66fceb6 | 2010-05-19 03:24:38 -0700 | [diff] [blame] | 723 | int ret; |
Amitkumar Karwar | 66fceb6 | 2010-05-19 03:24:38 -0700 | [diff] [blame] | 724 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 725 | lbs_deb_enter(LBS_DEB_FW); |
| 726 | |
Amitkumar Karwar | 1311843 | 2010-07-08 06:43:48 +0530 | [diff] [blame] | 727 | ret = lbs_set_host_sleep(priv, 0); |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 728 | |
| 729 | netif_device_attach(priv->dev); |
| 730 | if (priv->mesh_dev) |
| 731 | netif_device_attach(priv->mesh_dev); |
| 732 | |
Amitkumar Karwar | 66fceb6 | 2010-05-19 03:24:38 -0700 | [diff] [blame] | 733 | if (priv->deep_sleep_required) { |
| 734 | priv->deep_sleep_required = 0; |
| 735 | ret = lbs_set_deep_sleep(priv, 1); |
| 736 | if (ret) |
Joe Perches | f3a57fd | 2011-05-02 16:49:15 -0700 | [diff] [blame] | 737 | netdev_err(priv->dev, |
| 738 | "deep sleep activation failed: %d\n", ret); |
Amitkumar Karwar | 66fceb6 | 2010-05-19 03:24:38 -0700 | [diff] [blame] | 739 | } |
| 740 | |
Vasily Khoruzhick | 75abde4 | 2011-01-21 22:44:49 +0200 | [diff] [blame] | 741 | if (priv->setup_fw_on_resume) |
| 742 | ret = lbs_setup_firmware(priv); |
| 743 | |
Amitkumar Karwar | 66fceb6 | 2010-05-19 03:24:38 -0700 | [diff] [blame] | 744 | lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); |
| 745 | return ret; |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 746 | } |
| 747 | EXPORT_SYMBOL_GPL(lbs_resume); |
| 748 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 749 | /** |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 750 | * lbs_cmd_timeout_handler - handles the timeout of command sending. |
| 751 | * It will re-send the same command again. |
| 752 | * |
| 753 | * @data: &struct lbs_private pointer |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 754 | */ |
Holger Schurig | 40e6fa8 | 2010-02-04 14:37:45 +0100 | [diff] [blame] | 755 | static void lbs_cmd_timeout_handler(unsigned long data) |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 756 | { |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 757 | struct lbs_private *priv = (struct lbs_private *)data; |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 758 | unsigned long flags; |
| 759 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 760 | lbs_deb_enter(LBS_DEB_CMD); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 761 | spin_lock_irqsave(&priv->driver_lock, flags); |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 762 | |
Holger Schurig | 57962f0 | 2008-05-14 16:30:28 +0200 | [diff] [blame] | 763 | if (!priv->cur_cmd) |
David Woodhouse | 2a34509 | 2007-12-15 19:33:43 -0500 | [diff] [blame] | 764 | goto out; |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 765 | |
Joe Perches | f3a57fd | 2011-05-02 16:49:15 -0700 | [diff] [blame] | 766 | netdev_info(priv->dev, "command 0x%04x timed out\n", |
| 767 | le16_to_cpu(priv->cur_cmd->cmdbuf->command)); |
David Woodhouse | 2a34509 | 2007-12-15 19:33:43 -0500 | [diff] [blame] | 768 | |
| 769 | priv->cmd_timed_out = 1; |
Daniel Drake | df90d84 | 2011-07-09 15:41:25 +0100 | [diff] [blame] | 770 | |
| 771 | /* |
| 772 | * If the device didn't even acknowledge the command, reset the state |
| 773 | * so that we don't block all future commands due to this one timeout. |
| 774 | */ |
| 775 | if (priv->dnld_sent == DNLD_CMD_SENT) |
| 776 | priv->dnld_sent = DNLD_RES_RECEIVED; |
| 777 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 778 | wake_up(&priv->waitq); |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 779 | out: |
David Woodhouse | 2a34509 | 2007-12-15 19:33:43 -0500 | [diff] [blame] | 780 | spin_unlock_irqrestore(&priv->driver_lock, flags); |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 781 | lbs_deb_leave(LBS_DEB_CMD); |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 782 | } |
| 783 | |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 784 | /** |
Daniel Drake | 8f641d9 | 2011-10-03 11:33:02 +0100 | [diff] [blame] | 785 | * lbs_tx_lockup_handler - handles the timeout of the passing of TX frames |
| 786 | * to the hardware. This is known to frequently happen with SD8686 when |
| 787 | * waking up after a Wake-on-WLAN-triggered resume. |
| 788 | * |
| 789 | * @data: &struct lbs_private pointer |
| 790 | */ |
| 791 | static void lbs_tx_lockup_handler(unsigned long data) |
| 792 | { |
| 793 | struct lbs_private *priv = (struct lbs_private *)data; |
| 794 | unsigned long flags; |
| 795 | |
| 796 | lbs_deb_enter(LBS_DEB_TX); |
| 797 | spin_lock_irqsave(&priv->driver_lock, flags); |
| 798 | |
| 799 | netdev_info(priv->dev, "TX lockup detected\n"); |
| 800 | if (priv->reset_card) |
| 801 | priv->reset_card(priv); |
| 802 | |
| 803 | priv->dnld_sent = DNLD_RES_RECEIVED; |
| 804 | wake_up_interruptible(&priv->waitq); |
| 805 | |
| 806 | spin_unlock_irqrestore(&priv->driver_lock, flags); |
| 807 | lbs_deb_leave(LBS_DEB_TX); |
| 808 | } |
| 809 | |
| 810 | /** |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 811 | * auto_deepsleep_timer_fn - put the device back to deep sleep mode when |
| 812 | * timer expires and no activity (command, event, data etc.) is detected. |
| 813 | * @data: &struct lbs_private pointer |
| 814 | * returns: N/A |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 815 | */ |
| 816 | static void auto_deepsleep_timer_fn(unsigned long data) |
| 817 | { |
| 818 | struct lbs_private *priv = (struct lbs_private *)data; |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 819 | |
| 820 | lbs_deb_enter(LBS_DEB_CMD); |
| 821 | |
| 822 | if (priv->is_activity_detected) { |
| 823 | priv->is_activity_detected = 0; |
| 824 | } else { |
| 825 | if (priv->is_auto_deep_sleep_enabled && |
Dan Williams | 53800f5 | 2010-07-27 13:15:01 -0700 | [diff] [blame] | 826 | (!priv->wakeup_dev_required) && |
| 827 | (priv->connect_status != LBS_CONNECTED)) { |
| 828 | struct cmd_header cmd; |
| 829 | |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 830 | lbs_deb_main("Entering auto deep sleep mode...\n"); |
Dan Williams | 53800f5 | 2010-07-27 13:15:01 -0700 | [diff] [blame] | 831 | memset(&cmd, 0, sizeof(cmd)); |
| 832 | cmd.size = cpu_to_le16(sizeof(cmd)); |
| 833 | lbs_cmd_async(priv, CMD_802_11_DEEP_SLEEP, &cmd, |
| 834 | sizeof(cmd)); |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 835 | } |
| 836 | } |
| 837 | mod_timer(&priv->auto_deepsleep_timer , jiffies + |
| 838 | (priv->auto_deep_sleep_timeout * HZ)/1000); |
| 839 | lbs_deb_leave(LBS_DEB_CMD); |
| 840 | } |
| 841 | |
| 842 | int lbs_enter_auto_deep_sleep(struct lbs_private *priv) |
| 843 | { |
| 844 | lbs_deb_enter(LBS_DEB_SDIO); |
| 845 | |
| 846 | priv->is_auto_deep_sleep_enabled = 1; |
| 847 | if (priv->is_deep_sleep) |
| 848 | priv->wakeup_dev_required = 1; |
| 849 | mod_timer(&priv->auto_deepsleep_timer , |
| 850 | jiffies + (priv->auto_deep_sleep_timeout * HZ)/1000); |
| 851 | |
| 852 | lbs_deb_leave(LBS_DEB_SDIO); |
| 853 | return 0; |
| 854 | } |
| 855 | |
| 856 | int lbs_exit_auto_deep_sleep(struct lbs_private *priv) |
| 857 | { |
| 858 | lbs_deb_enter(LBS_DEB_SDIO); |
| 859 | |
| 860 | priv->is_auto_deep_sleep_enabled = 0; |
| 861 | priv->auto_deep_sleep_timeout = 0; |
| 862 | del_timer(&priv->auto_deepsleep_timer); |
| 863 | |
| 864 | lbs_deb_leave(LBS_DEB_SDIO); |
| 865 | return 0; |
| 866 | } |
| 867 | |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 868 | static int lbs_init_adapter(struct lbs_private *priv) |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 869 | { |
Kiran Divekar | e86dc1c | 2010-06-14 22:01:26 +0530 | [diff] [blame] | 870 | int ret; |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 871 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 872 | lbs_deb_enter(LBS_DEB_MAIN); |
| 873 | |
Joe Perches | 93803b3 | 2015-03-02 19:54:49 -0800 | [diff] [blame] | 874 | eth_broadcast_addr(priv->current_addr); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 875 | |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 876 | priv->connect_status = LBS_DISCONNECTED; |
Holger Schurig | c14951f | 2009-10-22 15:30:50 +0200 | [diff] [blame] | 877 | priv->channel = DEFAULT_AD_HOC_CHANNEL; |
Holger Schurig | d9e9778 | 2008-03-12 16:06:43 +0100 | [diff] [blame] | 878 | priv->mac_control = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON; |
Dan Williams | d5db2df | 2008-08-21 17:51:07 -0400 | [diff] [blame] | 879 | priv->radio_on = 1; |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 880 | priv->psmode = LBS802_11POWERMODECAM; |
| 881 | priv->psstate = PS_STATE_FULL_POWER; |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 882 | priv->is_deep_sleep = 0; |
| 883 | priv->is_auto_deep_sleep_enabled = 0; |
Amitkumar Karwar | 66fceb6 | 2010-05-19 03:24:38 -0700 | [diff] [blame] | 884 | priv->deep_sleep_required = 0; |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 885 | priv->wakeup_dev_required = 0; |
| 886 | init_waitqueue_head(&priv->ds_awake_q); |
Dan Williams | cc02681 | 2010-08-04 00:43:47 -0500 | [diff] [blame] | 887 | init_waitqueue_head(&priv->scan_q); |
Amitkumar Karwar | 921ca03 | 2010-02-25 17:16:36 -0800 | [diff] [blame] | 888 | priv->authtype_auto = 1; |
Amitkumar Karwar | 66fceb6 | 2010-05-19 03:24:38 -0700 | [diff] [blame] | 889 | priv->is_host_sleep_configured = 0; |
| 890 | priv->is_host_sleep_activated = 0; |
| 891 | init_waitqueue_head(&priv->host_sleep_q); |
Daniel Drake | 534111c | 2012-04-16 23:53:26 +0100 | [diff] [blame] | 892 | init_waitqueue_head(&priv->fw_waitq); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 893 | mutex_init(&priv->lock); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 894 | |
Holger Schurig | 40e6fa8 | 2010-02-04 14:37:45 +0100 | [diff] [blame] | 895 | setup_timer(&priv->command_timer, lbs_cmd_timeout_handler, |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 896 | (unsigned long)priv); |
Daniel Drake | 8f641d9 | 2011-10-03 11:33:02 +0100 | [diff] [blame] | 897 | setup_timer(&priv->tx_lockup_timer, lbs_tx_lockup_handler, |
| 898 | (unsigned long)priv); |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 899 | setup_timer(&priv->auto_deepsleep_timer, auto_deepsleep_timer_fn, |
| 900 | (unsigned long)priv); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 901 | |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 902 | INIT_LIST_HEAD(&priv->cmdfreeq); |
| 903 | INIT_LIST_HEAD(&priv->cmdpendingq); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 904 | |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 905 | spin_lock_init(&priv->driver_lock); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 906 | |
| 907 | /* Allocate the command buffers */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 908 | if (lbs_allocate_cmd_buffer(priv)) { |
Joe Perches | 0e4e06a | 2011-05-02 16:49:14 -0700 | [diff] [blame] | 909 | pr_err("Out of memory allocating command buffers\n"); |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 910 | ret = -ENOMEM; |
| 911 | goto out; |
| 912 | } |
| 913 | priv->resp_idx = 0; |
| 914 | priv->resp_len[0] = priv->resp_len[1] = 0; |
| 915 | |
| 916 | /* Create the event FIFO */ |
Stefani Seibold | c1e13f2 | 2009-12-21 14:37:27 -0800 | [diff] [blame] | 917 | ret = kfifo_alloc(&priv->event_fifo, sizeof(u32) * 16, GFP_KERNEL); |
Stefani Seibold | 4546548 | 2009-12-21 14:37:26 -0800 | [diff] [blame] | 918 | if (ret) { |
Joe Perches | 0e4e06a | 2011-05-02 16:49:14 -0700 | [diff] [blame] | 919 | pr_err("Out of memory allocating event FIFO buffer\n"); |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 920 | goto out; |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 921 | } |
| 922 | |
| 923 | out: |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 924 | lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); |
| 925 | |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 926 | return ret; |
| 927 | } |
| 928 | |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 929 | static void lbs_free_adapter(struct lbs_private *priv) |
Holger Schurig | ac558ca | 2007-08-02 11:49:06 -0400 | [diff] [blame] | 930 | { |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 931 | lbs_deb_enter(LBS_DEB_MAIN); |
| 932 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 933 | lbs_free_cmd_buffer(priv); |
Stefani Seibold | 4546548 | 2009-12-21 14:37:26 -0800 | [diff] [blame] | 934 | kfifo_free(&priv->event_fifo); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 935 | del_timer(&priv->command_timer); |
Daniel Drake | 8f641d9 | 2011-10-03 11:33:02 +0100 | [diff] [blame] | 936 | del_timer(&priv->tx_lockup_timer); |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 937 | del_timer(&priv->auto_deepsleep_timer); |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 938 | |
| 939 | lbs_deb_leave(LBS_DEB_MAIN); |
Holger Schurig | ac558ca | 2007-08-02 11:49:06 -0400 | [diff] [blame] | 940 | } |
| 941 | |
Stephen Hemminger | f02abf1 | 2009-03-20 19:36:37 +0000 | [diff] [blame] | 942 | static const struct net_device_ops lbs_netdev_ops = { |
| 943 | .ndo_open = lbs_dev_open, |
| 944 | .ndo_stop = lbs_eth_stop, |
| 945 | .ndo_start_xmit = lbs_hard_start_xmit, |
| 946 | .ndo_set_mac_address = lbs_set_mac_address, |
Jiri Pirko | afc4b13 | 2011-08-16 06:29:01 +0000 | [diff] [blame] | 947 | .ndo_set_rx_mode = lbs_set_multicast_list, |
Stephen Hemminger | f02abf1 | 2009-03-20 19:36:37 +0000 | [diff] [blame] | 948 | .ndo_change_mtu = eth_change_mtu, |
| 949 | .ndo_validate_addr = eth_validate_addr, |
| 950 | }; |
| 951 | |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 952 | /** |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 953 | * lbs_add_card - adds the card. It will probe the |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 954 | * card, allocate the lbs_priv and initialize the device. |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 955 | * |
Randy Dunlap | 8973a6e | 2011-04-26 15:25:29 -0700 | [diff] [blame] | 956 | * @card: A pointer to card |
| 957 | * @dmdev: A pointer to &struct device |
| 958 | * returns: A pointer to &struct lbs_private structure |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 959 | */ |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 960 | struct lbs_private *lbs_add_card(void *card, struct device *dmdev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 961 | { |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 962 | struct net_device *dev; |
| 963 | struct wireless_dev *wdev; |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 964 | struct lbs_private *priv = NULL; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 965 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 966 | lbs_deb_enter(LBS_DEB_MAIN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 967 | |
| 968 | /* Allocate an Ethernet device and register it */ |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 969 | wdev = lbs_cfg_alloc(dmdev); |
| 970 | if (IS_ERR(wdev)) { |
Joe Perches | 0e4e06a | 2011-05-02 16:49:14 -0700 | [diff] [blame] | 971 | pr_err("cfg80211 init failed\n"); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 972 | goto done; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 973 | } |
Kiran Divekar | e86dc1c | 2010-06-14 22:01:26 +0530 | [diff] [blame] | 974 | |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 975 | wdev->iftype = NL80211_IFTYPE_STATION; |
| 976 | priv = wdev_priv(wdev); |
| 977 | priv->wdev = wdev; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 978 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 979 | if (lbs_init_adapter(priv)) { |
Joe Perches | 0e4e06a | 2011-05-02 16:49:14 -0700 | [diff] [blame] | 980 | pr_err("failed to initialize adapter structure\n"); |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 981 | goto err_wdev; |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 982 | } |
| 983 | |
Tom Gundersen | c835a67 | 2014-07-14 16:37:24 +0200 | [diff] [blame] | 984 | dev = alloc_netdev(0, "wlan%d", NET_NAME_UNKNOWN, ether_setup); |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 985 | if (!dev) { |
| 986 | dev_err(dmdev, "no memory for network device instance\n"); |
| 987 | goto err_adapter; |
| 988 | } |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 989 | |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 990 | dev->ieee80211_ptr = wdev; |
| 991 | dev->ml_priv = priv; |
| 992 | SET_NETDEV_DEV(dev, dmdev); |
| 993 | wdev->netdev = dev; |
| 994 | priv->dev = dev; |
| 995 | |
Stephen Hemminger | f02abf1 | 2009-03-20 19:36:37 +0000 | [diff] [blame] | 996 | dev->netdev_ops = &lbs_netdev_ops; |
Holger Schurig | fb3dddf | 2007-05-25 11:58:22 -0400 | [diff] [blame] | 997 | dev->watchdog_timeo = 5 * HZ; |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 998 | dev->ethtool_ops = &lbs_ethtool_ops; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 999 | dev->flags |= IFF_BROADCAST | IFF_MULTICAST; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1000 | |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 1001 | priv->card = card; |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 1002 | |
Daniel Mack | c00552c | 2009-08-11 16:09:34 +0200 | [diff] [blame] | 1003 | strcpy(dev->name, "wlan%d"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1004 | |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 1005 | lbs_deb_thread("Starting main thread...\n"); |
| 1006 | init_waitqueue_head(&priv->waitq); |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1007 | priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main"); |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 1008 | if (IS_ERR(priv->main_thread)) { |
| 1009 | lbs_deb_thread("Error creating main thread.\n"); |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 1010 | goto err_ndev; |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 1011 | } |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1012 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1013 | priv->work_thread = create_singlethread_workqueue("lbs_worker"); |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 1014 | INIT_WORK(&priv->mcast_work, lbs_set_mcast_worker); |
David Woodhouse | 23a397a | 2007-12-11 18:56:42 -0500 | [diff] [blame] | 1015 | |
Deepak Saxena | ae63a33 | 2010-10-31 13:40:33 +0000 | [diff] [blame] | 1016 | priv->wol_criteria = EHS_REMOVE_WAKEUP; |
David Woodhouse | 506e902 | 2007-12-12 20:06:06 -0500 | [diff] [blame] | 1017 | priv->wol_gpio = 0xff; |
Amitkumar Karwar | 66fceb6 | 2010-05-19 03:24:38 -0700 | [diff] [blame] | 1018 | priv->wol_gap = 20; |
Deepak Saxena | ae63a33 | 2010-10-31 13:40:33 +0000 | [diff] [blame] | 1019 | priv->ehs_remove_supported = true; |
David Woodhouse | 506e902 | 2007-12-12 20:06:06 -0500 | [diff] [blame] | 1020 | |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1021 | goto done; |
| 1022 | |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 1023 | err_ndev: |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1024 | free_netdev(dev); |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 1025 | |
| 1026 | err_adapter: |
| 1027 | lbs_free_adapter(priv); |
| 1028 | |
| 1029 | err_wdev: |
| 1030 | lbs_cfg_free(priv); |
| 1031 | |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1032 | priv = NULL; |
| 1033 | |
| 1034 | done: |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 1035 | lbs_deb_leave_args(LBS_DEB_MAIN, "priv %p", priv); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1036 | return priv; |
| 1037 | } |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1038 | EXPORT_SYMBOL_GPL(lbs_add_card); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1039 | |
| 1040 | |
Holger Schurig | a63e5cb | 2008-04-30 10:50:39 +0200 | [diff] [blame] | 1041 | void lbs_remove_card(struct lbs_private *priv) |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1042 | { |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1043 | struct net_device *dev = priv->dev; |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1044 | |
| 1045 | lbs_deb_enter(LBS_DEB_MAIN); |
| 1046 | |
David Woodhouse | 23a397a | 2007-12-11 18:56:42 -0500 | [diff] [blame] | 1047 | lbs_remove_mesh(priv); |
Daniel Drake | 0beecac8 | 2012-04-16 23:53:02 +0100 | [diff] [blame] | 1048 | |
| 1049 | if (priv->wiphy_registered) |
| 1050 | lbs_scan_deinit(priv); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1051 | |
Daniel Drake | 534111c | 2012-04-16 23:53:26 +0100 | [diff] [blame] | 1052 | lbs_wait_for_firmware_load(priv); |
| 1053 | |
Dan Williams | 71b35f3 | 2008-09-08 16:34:40 -0400 | [diff] [blame] | 1054 | /* worker thread destruction blocks on the in-flight command which |
| 1055 | * should have been cleared already in lbs_stop_card(). |
| 1056 | */ |
| 1057 | lbs_deb_main("destroying worker thread\n"); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1058 | destroy_workqueue(priv->work_thread); |
Dan Williams | 71b35f3 | 2008-09-08 16:34:40 -0400 | [diff] [blame] | 1059 | lbs_deb_main("done destroying worker thread\n"); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1060 | |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 1061 | if (priv->psmode == LBS802_11POWERMODEMAX_PSP) { |
| 1062 | priv->psmode = LBS802_11POWERMODECAM; |
Dan Williams | 0bb6408 | 2010-07-27 13:08:08 -0700 | [diff] [blame] | 1063 | lbs_set_ps_mode(priv, PS_MODE_ACTION_EXIT_PS, true); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1064 | } |
| 1065 | |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 1066 | if (priv->is_deep_sleep) { |
| 1067 | priv->is_deep_sleep = 0; |
| 1068 | wake_up_interruptible(&priv->ds_awake_q); |
| 1069 | } |
| 1070 | |
Amitkumar Karwar | 66fceb6 | 2010-05-19 03:24:38 -0700 | [diff] [blame] | 1071 | priv->is_host_sleep_configured = 0; |
| 1072 | priv->is_host_sleep_activated = 0; |
| 1073 | wake_up_interruptible(&priv->host_sleep_q); |
| 1074 | |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1075 | /* Stop the thread servicing the interrupts */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 1076 | priv->surpriseremoved = 1; |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1077 | kthread_stop(priv->main_thread); |
| 1078 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1079 | lbs_free_adapter(priv); |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 1080 | lbs_cfg_free(priv); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1081 | free_netdev(dev); |
| 1082 | |
| 1083 | lbs_deb_leave(LBS_DEB_MAIN); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1084 | } |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1085 | EXPORT_SYMBOL_GPL(lbs_remove_card); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1086 | |
| 1087 | |
Kiran Divekar | e86dc1c | 2010-06-14 22:01:26 +0530 | [diff] [blame] | 1088 | int lbs_rtap_supported(struct lbs_private *priv) |
Holger Schurig | cd74468 | 2009-12-02 15:25:59 +0100 | [diff] [blame] | 1089 | { |
| 1090 | if (MRVL_FW_MAJOR_REV(priv->fwrelease) == MRVL_FW_V5) |
| 1091 | return 1; |
| 1092 | |
| 1093 | /* newer firmware use a capability mask */ |
| 1094 | return ((MRVL_FW_MAJOR_REV(priv->fwrelease) >= MRVL_FW_V10) && |
| 1095 | (priv->fwcapinfo & MESH_CAPINFO_ENABLE_MASK)); |
| 1096 | } |
| 1097 | |
| 1098 | |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 1099 | int lbs_start_card(struct lbs_private *priv) |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1100 | { |
| 1101 | struct net_device *dev = priv->dev; |
| 1102 | int ret = -1; |
| 1103 | |
| 1104 | lbs_deb_enter(LBS_DEB_MAIN); |
| 1105 | |
| 1106 | /* poke the firmware */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1107 | ret = lbs_setup_firmware(priv); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1108 | if (ret) |
| 1109 | goto done; |
| 1110 | |
Daniel Drake | 49fee69 | 2011-07-21 20:43:17 +0100 | [diff] [blame] | 1111 | if (!lbs_disablemesh) |
| 1112 | lbs_init_mesh(priv); |
| 1113 | else |
| 1114 | pr_info("%s: mesh disabled\n", dev->name); |
| 1115 | |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 1116 | if (lbs_cfg_register(priv)) { |
Joe Perches | 0e4e06a | 2011-05-02 16:49:14 -0700 | [diff] [blame] | 1117 | pr_err("cannot register device\n"); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1118 | goto done; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1119 | } |
David Woodhouse | 020f3d0 | 2007-12-12 23:29:13 -0500 | [diff] [blame] | 1120 | |
Daniel Drake | 49fee69 | 2011-07-21 20:43:17 +0100 | [diff] [blame] | 1121 | if (lbs_mesh_activated(priv)) |
| 1122 | lbs_start_mesh(priv); |
Holger Schurig | cd74468 | 2009-12-02 15:25:59 +0100 | [diff] [blame] | 1123 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1124 | lbs_debugfs_init_one(priv, dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1125 | |
Joe Perches | f3a57fd | 2011-05-02 16:49:15 -0700 | [diff] [blame] | 1126 | netdev_info(dev, "Marvell WLAN 802.11 adapter\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1127 | |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1128 | ret = 0; |
| 1129 | |
Holger Schurig | 32a74b7 | 2007-05-25 12:04:31 -0400 | [diff] [blame] | 1130 | done: |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1131 | lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); |
Holger Schurig | 32a74b7 | 2007-05-25 12:04:31 -0400 | [diff] [blame] | 1132 | return ret; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1133 | } |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1134 | EXPORT_SYMBOL_GPL(lbs_start_card); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1135 | |
| 1136 | |
Holger Schurig | a63e5cb | 2008-04-30 10:50:39 +0200 | [diff] [blame] | 1137 | void lbs_stop_card(struct lbs_private *priv) |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1138 | { |
Julia Lawall | 43baa5b | 2009-01-09 10:23:10 +0000 | [diff] [blame] | 1139 | struct net_device *dev; |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1140 | |
| 1141 | lbs_deb_enter(LBS_DEB_MAIN); |
| 1142 | |
Holger Schurig | 652e3f2 | 2008-04-30 10:51:15 +0200 | [diff] [blame] | 1143 | if (!priv) |
| 1144 | goto out; |
Julia Lawall | 43baa5b | 2009-01-09 10:23:10 +0000 | [diff] [blame] | 1145 | dev = priv->dev; |
Holger Schurig | 652e3f2 | 2008-04-30 10:51:15 +0200 | [diff] [blame] | 1146 | |
Daniel Drake | 0beecac8 | 2012-04-16 23:53:02 +0100 | [diff] [blame] | 1147 | /* If the netdev isn't registered, it means that lbs_start_card() was |
| 1148 | * never called so we have nothing to do here. */ |
| 1149 | if (dev->reg_state != NETREG_REGISTERED) |
| 1150 | goto out; |
| 1151 | |
Julia Lawall | 43baa5b | 2009-01-09 10:23:10 +0000 | [diff] [blame] | 1152 | netif_stop_queue(dev); |
| 1153 | netif_carrier_off(dev); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1154 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1155 | lbs_debugfs_remove_one(priv); |
Holger Schurig | cd74468 | 2009-12-02 15:25:59 +0100 | [diff] [blame] | 1156 | lbs_deinit_mesh(priv); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1157 | unregister_netdev(dev); |
| 1158 | |
Holger Schurig | 652e3f2 | 2008-04-30 10:51:15 +0200 | [diff] [blame] | 1159 | out: |
Holger Schurig | a63e5cb | 2008-04-30 10:50:39 +0200 | [diff] [blame] | 1160 | lbs_deb_leave(LBS_DEB_MAIN); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1161 | } |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1162 | EXPORT_SYMBOL_GPL(lbs_stop_card); |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1163 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1164 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 1165 | void lbs_queue_event(struct lbs_private *priv, u32 event) |
| 1166 | { |
| 1167 | unsigned long flags; |
| 1168 | |
| 1169 | lbs_deb_enter(LBS_DEB_THREAD); |
| 1170 | spin_lock_irqsave(&priv->driver_lock, flags); |
| 1171 | |
| 1172 | if (priv->psstate == PS_STATE_SLEEP) |
| 1173 | priv->psstate = PS_STATE_AWAKE; |
| 1174 | |
Stefani Seibold | 7acd72e | 2009-12-21 14:37:28 -0800 | [diff] [blame] | 1175 | kfifo_in(&priv->event_fifo, (unsigned char *) &event, sizeof(u32)); |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 1176 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 1177 | wake_up(&priv->waitq); |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 1178 | |
| 1179 | spin_unlock_irqrestore(&priv->driver_lock, flags); |
| 1180 | lbs_deb_leave(LBS_DEB_THREAD); |
| 1181 | } |
| 1182 | EXPORT_SYMBOL_GPL(lbs_queue_event); |
| 1183 | |
| 1184 | void lbs_notify_command_response(struct lbs_private *priv, u8 resp_idx) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1185 | { |
Holger Schurig | ed37b51 | 2007-05-25 11:52:42 -0400 | [diff] [blame] | 1186 | lbs_deb_enter(LBS_DEB_THREAD); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1187 | |
David Woodhouse | 4f67949 | 2007-12-10 14:58:37 -0500 | [diff] [blame] | 1188 | if (priv->psstate == PS_STATE_SLEEP) |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 1189 | priv->psstate = PS_STATE_AWAKE; |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 1190 | |
| 1191 | /* Swap buffers by flipping the response index */ |
| 1192 | BUG_ON(resp_idx > 1); |
| 1193 | priv->resp_idx = resp_idx; |
| 1194 | |
Daniel Drake | d2e7b34 | 2011-08-01 16:43:13 +0100 | [diff] [blame] | 1195 | wake_up(&priv->waitq); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1196 | |
Holger Schurig | ed37b51 | 2007-05-25 11:52:42 -0400 | [diff] [blame] | 1197 | lbs_deb_leave(LBS_DEB_THREAD); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1198 | } |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 1199 | EXPORT_SYMBOL_GPL(lbs_notify_command_response); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1200 | |
Andres Salomon | 4fb910f | 2007-11-20 17:43:45 -0500 | [diff] [blame] | 1201 | static int __init lbs_init_module(void) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1202 | { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1203 | lbs_deb_enter(LBS_DEB_MAIN); |
Holger Schurig | f539f2e | 2008-03-26 13:22:11 +0100 | [diff] [blame] | 1204 | memset(&confirm_sleep, 0, sizeof(confirm_sleep)); |
| 1205 | confirm_sleep.hdr.command = cpu_to_le16(CMD_802_11_PS_MODE); |
| 1206 | confirm_sleep.hdr.size = cpu_to_le16(sizeof(confirm_sleep)); |
Dan Williams | 0bb6408 | 2010-07-27 13:08:08 -0700 | [diff] [blame] | 1207 | confirm_sleep.action = cpu_to_le16(PS_MODE_ACTION_SLEEP_CONFIRMED); |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1208 | lbs_debugfs_init(); |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1209 | lbs_deb_leave(LBS_DEB_MAIN); |
| 1210 | return 0; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1211 | } |
| 1212 | |
Andres Salomon | 4fb910f | 2007-11-20 17:43:45 -0500 | [diff] [blame] | 1213 | static void __exit lbs_exit_module(void) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1214 | { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1215 | lbs_deb_enter(LBS_DEB_MAIN); |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1216 | lbs_debugfs_remove(); |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1217 | lbs_deb_leave(LBS_DEB_MAIN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1218 | } |
| 1219 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1220 | module_init(lbs_init_module); |
| 1221 | module_exit(lbs_exit_module); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1222 | |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1223 | MODULE_DESCRIPTION("Libertas WLAN Driver Library"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1224 | MODULE_AUTHOR("Marvell International Ltd."); |
| 1225 | MODULE_LICENSE("GPL"); |