Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [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 | */ |
| 6 | |
Holger Schurig | a46c641 | 2007-05-25 11:32:07 -0400 | [diff] [blame] | 7 | #include <linux/moduleparam.h> |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 8 | #include <linux/delay.h> |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 9 | #include <linux/etherdevice.h> |
| 10 | #include <linux/netdevice.h> |
| 11 | #include <linux/if_arp.h> |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 12 | #include <linux/kthread.h> |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 13 | #include <linux/kfifo.h> |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 14 | #include <linux/stddef.h> |
Johannes Berg | 2c706002 | 2008-10-30 22:09:54 +0100 | [diff] [blame] | 15 | #include <linux/ieee80211.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame^] | 16 | #include <linux/slab.h> |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 17 | #include <net/iw_handler.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" |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 23 | #include "wext.h" |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 24 | #include "cfg.h" |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 25 | #include "debugfs.h" |
Holger Schurig | 245bf20 | 2008-04-02 16:27:42 +0200 | [diff] [blame] | 26 | #include "scan.h" |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 27 | #include "assoc.h" |
Dan Williams | 6e66f03 | 2007-12-11 12:42:16 -0500 | [diff] [blame] | 28 | #include "cmd.h" |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 29 | |
Dan Williams | 7856a54 | 2007-08-03 09:43:03 -0400 | [diff] [blame] | 30 | #define DRIVER_RELEASE_VERSION "323.p0" |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 31 | const char lbs_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION |
Dan Williams | 3ce4023 | 2007-05-10 23:03:07 -0400 | [diff] [blame] | 32 | #ifdef DEBUG |
| 33 | "-dbg" |
| 34 | #endif |
| 35 | ""; |
| 36 | |
Holger Schurig | a46c641 | 2007-05-25 11:32:07 -0400 | [diff] [blame] | 37 | |
| 38 | /* Module parameters */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 39 | unsigned int lbs_debug; |
| 40 | EXPORT_SYMBOL_GPL(lbs_debug); |
| 41 | module_param_named(libertas_debug, lbs_debug, int, 0644); |
Holger Schurig | a46c641 | 2007-05-25 11:32:07 -0400 | [diff] [blame] | 42 | |
| 43 | |
Holger Schurig | f539f2e | 2008-03-26 13:22:11 +0100 | [diff] [blame] | 44 | /* This global structure is used to send the confirm_sleep command as |
| 45 | * fast as possible down to the firmware. */ |
| 46 | struct cmd_confirm_sleep confirm_sleep; |
| 47 | |
| 48 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 49 | /** |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 50 | * the table to keep region code |
| 51 | */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 52 | u16 lbs_region_code_to_index[MRVDRV_MAX_REGION_CODE] = |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 53 | { 0x10, 0x20, 0x30, 0x31, 0x32, 0x40 }; |
| 54 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 55 | /** |
Dan Williams | 8c51276 | 2007-08-02 11:40:45 -0400 | [diff] [blame] | 56 | * FW rate table. FW refers to rates by their index in this table, not by the |
| 57 | * rate value itself. Values of 0x00 are |
| 58 | * reserved positions. |
| 59 | */ |
| 60 | static u8 fw_data_rates[MAX_RATES] = |
| 61 | { 0x02, 0x04, 0x0B, 0x16, 0x00, 0x0C, 0x12, |
| 62 | 0x18, 0x24, 0x30, 0x48, 0x60, 0x6C, 0x00 |
| 63 | }; |
| 64 | |
| 65 | /** |
| 66 | * @brief use index to get the data rate |
| 67 | * |
| 68 | * @param idx The index of data rate |
| 69 | * @return data rate or 0 |
| 70 | */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 71 | u32 lbs_fw_index_to_data_rate(u8 idx) |
Dan Williams | 8c51276 | 2007-08-02 11:40:45 -0400 | [diff] [blame] | 72 | { |
| 73 | if (idx >= sizeof(fw_data_rates)) |
| 74 | idx = 0; |
| 75 | return fw_data_rates[idx]; |
| 76 | } |
| 77 | |
| 78 | /** |
| 79 | * @brief use rate to get the index |
| 80 | * |
| 81 | * @param rate data rate |
| 82 | * @return index or 0 |
| 83 | */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 84 | u8 lbs_data_rate_to_fw_index(u32 rate) |
Dan Williams | 8c51276 | 2007-08-02 11:40:45 -0400 | [diff] [blame] | 85 | { |
| 86 | u8 i; |
| 87 | |
| 88 | if (!rate) |
| 89 | return 0; |
| 90 | |
| 91 | for (i = 0; i < sizeof(fw_data_rates); i++) { |
| 92 | if (rate == fw_data_rates[i]) |
| 93 | return i; |
| 94 | } |
| 95 | return 0; |
| 96 | } |
| 97 | |
Anna Neal | 6fb5325 | 2008-12-09 13:23:45 -0800 | [diff] [blame] | 98 | |
David Woodhouse | 2fd6cfe | 2007-12-11 17:44:10 -0500 | [diff] [blame] | 99 | static int lbs_add_rtap(struct lbs_private *priv); |
| 100 | static void lbs_remove_rtap(struct lbs_private *priv); |
David Woodhouse | 7e22627 | 2007-12-14 22:53:41 -0500 | [diff] [blame] | 101 | |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 102 | |
| 103 | /** |
| 104 | * Get function for sysfs attribute rtap |
| 105 | */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 106 | static ssize_t lbs_rtap_get(struct device *dev, |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 107 | struct device_attribute *attr, char * buf) |
| 108 | { |
Kiran Divekar | ab65f64 | 2009-02-19 19:32:39 -0500 | [diff] [blame] | 109 | struct lbs_private *priv = to_net_dev(dev)->ml_priv; |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 110 | return snprintf(buf, 5, "0x%X\n", priv->monitormode); |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 111 | } |
| 112 | |
| 113 | /** |
| 114 | * Set function for sysfs attribute rtap |
| 115 | */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 116 | static ssize_t lbs_rtap_set(struct device *dev, |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 117 | struct device_attribute *attr, const char * buf, size_t count) |
| 118 | { |
| 119 | int monitor_mode; |
Kiran Divekar | ab65f64 | 2009-02-19 19:32:39 -0500 | [diff] [blame] | 120 | struct lbs_private *priv = to_net_dev(dev)->ml_priv; |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 121 | |
| 122 | sscanf(buf, "%x", &monitor_mode); |
Holger Schurig | c2b310a | 2008-03-26 09:57:14 +0100 | [diff] [blame] | 123 | if (monitor_mode) { |
| 124 | if (priv->monitormode == monitor_mode) |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 125 | return strlen(buf); |
Holger Schurig | c2b310a | 2008-03-26 09:57:14 +0100 | [diff] [blame] | 126 | if (!priv->monitormode) { |
Holger Schurig | 602114a | 2009-12-02 15:26:01 +0100 | [diff] [blame] | 127 | if (priv->infra_open || lbs_mesh_open(priv)) |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 128 | return -EBUSY; |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 129 | if (priv->mode == IW_MODE_INFRA) |
Dan Williams | 191bb40 | 2008-08-21 17:46:18 -0400 | [diff] [blame] | 130 | lbs_cmd_80211_deauthenticate(priv, |
| 131 | priv->curbssparams.bssid, |
| 132 | WLAN_REASON_DEAUTH_LEAVING); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 133 | else if (priv->mode == IW_MODE_ADHOC) |
Dan Williams | f5fe1fd | 2008-08-21 21:46:59 -0400 | [diff] [blame] | 134 | lbs_adhoc_stop(priv); |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 135 | lbs_add_rtap(priv); |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 136 | } |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 137 | priv->monitormode = monitor_mode; |
Dan Williams | 3b72b01 | 2008-07-29 13:50:39 -0400 | [diff] [blame] | 138 | } else { |
Holger Schurig | c2b310a | 2008-03-26 09:57:14 +0100 | [diff] [blame] | 139 | if (!priv->monitormode) |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 140 | return strlen(buf); |
Holger Schurig | c2b310a | 2008-03-26 09:57:14 +0100 | [diff] [blame] | 141 | priv->monitormode = 0; |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 142 | lbs_remove_rtap(priv); |
David Woodhouse | f86a93e | 2007-12-08 19:46:19 +0000 | [diff] [blame] | 143 | |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 144 | if (priv->currenttxskb) { |
| 145 | dev_kfree_skb_any(priv->currenttxskb); |
| 146 | priv->currenttxskb = NULL; |
David Woodhouse | f86a93e | 2007-12-08 19:46:19 +0000 | [diff] [blame] | 147 | } |
| 148 | |
| 149 | /* Wake queues, command thread, etc. */ |
| 150 | lbs_host_to_card_done(priv); |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 151 | } |
| 152 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 153 | lbs_prepare_and_send_command(priv, |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 154 | CMD_802_11_MONITOR_MODE, CMD_ACT_SET, |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 155 | CMD_OPTION_WAITFORRSP, 0, &priv->monitormode); |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 156 | return strlen(buf); |
| 157 | } |
| 158 | |
| 159 | /** |
David Woodhouse | 23a397a | 2007-12-11 18:56:42 -0500 | [diff] [blame] | 160 | * lbs_rtap attribute to be exported per ethX interface |
| 161 | * through sysfs (/sys/class/net/ethX/lbs_rtap) |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 162 | */ |
David Woodhouse | 23a397a | 2007-12-11 18:56:42 -0500 | [diff] [blame] | 163 | static DEVICE_ATTR(lbs_rtap, 0644, lbs_rtap_get, lbs_rtap_set ); |
| 164 | |
| 165 | /** |
Holger Schurig | e0e42da | 2009-11-25 13:10:15 +0100 | [diff] [blame] | 166 | * @brief This function opens the ethX interface |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 167 | * |
| 168 | * @param dev A pointer to net_device structure |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 169 | * @return 0 or -EBUSY if monitor mode active |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 170 | */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 171 | static int lbs_dev_open(struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 172 | { |
Kiran Divekar | ab65f64 | 2009-02-19 19:32:39 -0500 | [diff] [blame] | 173 | struct lbs_private *priv = dev->ml_priv; |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 174 | int ret = 0; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 175 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 176 | lbs_deb_enter(LBS_DEB_NET); |
| 177 | |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 178 | spin_lock_irq(&priv->driver_lock); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 179 | |
Holger Schurig | c2b310a | 2008-03-26 09:57:14 +0100 | [diff] [blame] | 180 | if (priv->monitormode) { |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 181 | ret = -EBUSY; |
| 182 | goto out; |
Javier Cardona | 51d84f5 | 2007-05-25 12:06:56 -0400 | [diff] [blame] | 183 | } |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 184 | |
Holger Schurig | e0e42da | 2009-11-25 13:10:15 +0100 | [diff] [blame] | 185 | priv->infra_open = 1; |
David Woodhouse | 7e22627 | 2007-12-14 22:53:41 -0500 | [diff] [blame] | 186 | |
Holger Schurig | e0e42da | 2009-11-25 13:10:15 +0100 | [diff] [blame] | 187 | if (priv->connect_status == LBS_CONNECTED) |
| 188 | netif_carrier_on(dev); |
| 189 | else |
| 190 | netif_carrier_off(dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 191 | |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 192 | if (!priv->tx_pending_len) |
| 193 | netif_wake_queue(dev); |
| 194 | out: |
Brajesh Dave | 01d77d8 | 2007-11-20 17:44:14 -0500 | [diff] [blame] | 195 | |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 196 | spin_unlock_irq(&priv->driver_lock); |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 197 | lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 198 | return ret; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 199 | } |
| 200 | |
| 201 | /** |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 202 | * @brief This function closes the ethX interface |
| 203 | * |
| 204 | * @param dev A pointer to net_device structure |
| 205 | * @return 0 |
| 206 | */ |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 207 | static int lbs_eth_stop(struct net_device *dev) |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 208 | { |
Kiran Divekar | ab65f64 | 2009-02-19 19:32:39 -0500 | [diff] [blame] | 209 | struct lbs_private *priv = dev->ml_priv; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 210 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 211 | lbs_deb_enter(LBS_DEB_NET); |
| 212 | |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 213 | spin_lock_irq(&priv->driver_lock); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 214 | priv->infra_open = 0; |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 215 | netif_stop_queue(dev); |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 216 | spin_unlock_irq(&priv->driver_lock); |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 217 | |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 218 | schedule_work(&priv->mcast_work); |
| 219 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 220 | lbs_deb_leave(LBS_DEB_NET); |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 221 | return 0; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 222 | } |
| 223 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 224 | static void lbs_tx_timeout(struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 225 | { |
Kiran Divekar | ab65f64 | 2009-02-19 19:32:39 -0500 | [diff] [blame] | 226 | struct lbs_private *priv = dev->ml_priv; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 227 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 228 | lbs_deb_enter(LBS_DEB_TX); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 229 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 230 | lbs_pr_err("tx watch dog timeout\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 231 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 232 | dev->trans_start = jiffies; |
| 233 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 234 | if (priv->currenttxskb) |
| 235 | lbs_send_tx_feedback(priv, 0); |
| 236 | |
David Woodhouse | a63b22b | 2007-12-08 20:56:44 +0000 | [diff] [blame] | 237 | /* XX: Shouldn't we also call into the hw-specific driver |
| 238 | to kick it somehow? */ |
| 239 | lbs_host_to_card_done(priv); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 240 | |
David Woodhouse | 354eca9 | 2007-12-17 19:22:40 -0500 | [diff] [blame] | 241 | /* More often than not, this actually happens because the |
| 242 | firmware has crapped itself -- rather than just a very |
| 243 | busy medium. So send a harmless command, and if/when |
| 244 | _that_ times out, we'll kick it in the head. */ |
| 245 | lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0, |
| 246 | 0, 0, NULL); |
| 247 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 248 | lbs_deb_leave(LBS_DEB_TX); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 249 | } |
| 250 | |
David Woodhouse | e775ed7 | 2007-12-06 14:36:11 +0000 | [diff] [blame] | 251 | void lbs_host_to_card_done(struct lbs_private *priv) |
| 252 | { |
David Woodhouse | a63b22b | 2007-12-08 20:56:44 +0000 | [diff] [blame] | 253 | unsigned long flags; |
| 254 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 255 | lbs_deb_enter(LBS_DEB_THREAD); |
| 256 | |
David Woodhouse | a63b22b | 2007-12-08 20:56:44 +0000 | [diff] [blame] | 257 | spin_lock_irqsave(&priv->driver_lock, flags); |
David Woodhouse | e775ed7 | 2007-12-06 14:36:11 +0000 | [diff] [blame] | 258 | |
| 259 | priv->dnld_sent = DNLD_RES_RECEIVED; |
| 260 | |
| 261 | /* Wake main thread if commands are pending */ |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 262 | if (!priv->cur_cmd || priv->tx_pending_len > 0) { |
| 263 | if (!priv->wakeup_dev_required) |
| 264 | wake_up_interruptible(&priv->waitq); |
| 265 | } |
David Woodhouse | e775ed7 | 2007-12-06 14:36:11 +0000 | [diff] [blame] | 266 | |
David Woodhouse | a63b22b | 2007-12-08 20:56:44 +0000 | [diff] [blame] | 267 | spin_unlock_irqrestore(&priv->driver_lock, flags); |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 268 | lbs_deb_leave(LBS_DEB_THREAD); |
David Woodhouse | e775ed7 | 2007-12-06 14:36:11 +0000 | [diff] [blame] | 269 | } |
| 270 | EXPORT_SYMBOL_GPL(lbs_host_to_card_done); |
| 271 | |
Holger Schurig | e0e42da | 2009-11-25 13:10:15 +0100 | [diff] [blame] | 272 | int lbs_set_mac_address(struct net_device *dev, void *addr) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 273 | { |
| 274 | int ret = 0; |
Kiran Divekar | ab65f64 | 2009-02-19 19:32:39 -0500 | [diff] [blame] | 275 | struct lbs_private *priv = dev->ml_priv; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 276 | struct sockaddr *phwaddr = addr; |
Holger Schurig | 2af9f03 | 2008-03-26 09:58:32 +0100 | [diff] [blame] | 277 | struct cmd_ds_802_11_mac_address cmd; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 278 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 279 | lbs_deb_enter(LBS_DEB_NET); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 280 | |
Luis Carlos Cobo Rus | 0a0d08a | 2007-05-25 23:05:27 -0400 | [diff] [blame] | 281 | /* In case it was called from the mesh device */ |
Holger Schurig | 2af9f03 | 2008-03-26 09:58:32 +0100 | [diff] [blame] | 282 | dev = priv->dev; |
Luis Carlos Cobo Rus | 0a0d08a | 2007-05-25 23:05:27 -0400 | [diff] [blame] | 283 | |
Holger Schurig | 2af9f03 | 2008-03-26 09:58:32 +0100 | [diff] [blame] | 284 | cmd.hdr.size = cpu_to_le16(sizeof(cmd)); |
| 285 | cmd.action = cpu_to_le16(CMD_ACT_SET); |
| 286 | memcpy(cmd.macadd, phwaddr->sa_data, ETH_ALEN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 287 | |
Holger Schurig | 2af9f03 | 2008-03-26 09:58:32 +0100 | [diff] [blame] | 288 | ret = lbs_cmd_with_response(priv, CMD_802_11_MAC_ADDRESS, &cmd); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 289 | if (ret) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 290 | lbs_deb_net("set MAC address failed\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 291 | goto done; |
| 292 | } |
| 293 | |
Holger Schurig | 2af9f03 | 2008-03-26 09:58:32 +0100 | [diff] [blame] | 294 | memcpy(priv->current_addr, phwaddr->sa_data, ETH_ALEN); |
| 295 | memcpy(dev->dev_addr, phwaddr->sa_data, ETH_ALEN); |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 296 | if (priv->mesh_dev) |
Holger Schurig | 2af9f03 | 2008-03-26 09:58:32 +0100 | [diff] [blame] | 297 | memcpy(priv->mesh_dev->dev_addr, phwaddr->sa_data, ETH_ALEN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 298 | |
| 299 | done: |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 300 | lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 301 | return ret; |
| 302 | } |
| 303 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 304 | |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 305 | static inline int mac_in_list(unsigned char *list, int list_len, |
| 306 | unsigned char *mac) |
| 307 | { |
| 308 | while (list_len) { |
| 309 | if (!memcmp(list, mac, ETH_ALEN)) |
| 310 | return 1; |
| 311 | list += ETH_ALEN; |
| 312 | list_len--; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 313 | } |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 314 | return 0; |
| 315 | } |
| 316 | |
| 317 | |
| 318 | static int lbs_add_mcast_addrs(struct cmd_ds_mac_multicast_adr *cmd, |
| 319 | struct net_device *dev, int nr_addrs) |
| 320 | { |
| 321 | int i = nr_addrs; |
| 322 | struct dev_mc_list *mc_list; |
Jiri Pirko | 655ffee | 2010-02-27 07:35:45 +0000 | [diff] [blame] | 323 | int cnt; |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 324 | |
| 325 | if ((dev->flags & (IFF_UP|IFF_MULTICAST)) != (IFF_UP|IFF_MULTICAST)) |
| 326 | return nr_addrs; |
| 327 | |
David S. Miller | b9e4085 | 2008-07-15 00:15:08 -0700 | [diff] [blame] | 328 | netif_addr_lock_bh(dev); |
Jiri Pirko | 655ffee | 2010-02-27 07:35:45 +0000 | [diff] [blame] | 329 | cnt = netdev_mc_count(dev); |
| 330 | netdev_for_each_mc_addr(mc_list, dev) { |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 331 | if (mac_in_list(cmd->maclist, nr_addrs, mc_list->dmi_addr)) { |
Johannes Berg | e174961 | 2008-10-27 15:59:26 -0700 | [diff] [blame] | 332 | lbs_deb_net("mcast address %s:%pM skipped\n", dev->name, |
| 333 | mc_list->dmi_addr); |
Jiri Pirko | 655ffee | 2010-02-27 07:35:45 +0000 | [diff] [blame] | 334 | cnt--; |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 335 | continue; |
| 336 | } |
| 337 | |
| 338 | if (i == MRVDRV_MAX_MULTICAST_LIST_SIZE) |
| 339 | break; |
| 340 | memcpy(&cmd->maclist[6*i], mc_list->dmi_addr, ETH_ALEN); |
Johannes Berg | e174961 | 2008-10-27 15:59:26 -0700 | [diff] [blame] | 341 | lbs_deb_net("mcast address %s:%pM added to filter\n", dev->name, |
| 342 | mc_list->dmi_addr); |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 343 | i++; |
Jiri Pirko | 655ffee | 2010-02-27 07:35:45 +0000 | [diff] [blame] | 344 | cnt--; |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 345 | } |
David S. Miller | b9e4085 | 2008-07-15 00:15:08 -0700 | [diff] [blame] | 346 | netif_addr_unlock_bh(dev); |
Jiri Pirko | 655ffee | 2010-02-27 07:35:45 +0000 | [diff] [blame] | 347 | if (cnt) |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 348 | return -EOVERFLOW; |
| 349 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 350 | return i; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 351 | } |
| 352 | |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 353 | static void lbs_set_mcast_worker(struct work_struct *work) |
| 354 | { |
| 355 | struct lbs_private *priv = container_of(work, struct lbs_private, mcast_work); |
| 356 | struct cmd_ds_mac_multicast_adr mcast_cmd; |
| 357 | int dev_flags; |
| 358 | int nr_addrs; |
| 359 | int old_mac_control = priv->mac_control; |
| 360 | |
| 361 | lbs_deb_enter(LBS_DEB_NET); |
| 362 | |
| 363 | dev_flags = priv->dev->flags; |
| 364 | if (priv->mesh_dev) |
| 365 | dev_flags |= priv->mesh_dev->flags; |
| 366 | |
| 367 | if (dev_flags & IFF_PROMISC) { |
| 368 | priv->mac_control |= CMD_ACT_MAC_PROMISCUOUS_ENABLE; |
| 369 | priv->mac_control &= ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE | |
| 370 | CMD_ACT_MAC_MULTICAST_ENABLE); |
| 371 | goto out_set_mac_control; |
| 372 | } else if (dev_flags & IFF_ALLMULTI) { |
| 373 | do_allmulti: |
| 374 | priv->mac_control |= CMD_ACT_MAC_ALL_MULTICAST_ENABLE; |
| 375 | priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE | |
| 376 | CMD_ACT_MAC_MULTICAST_ENABLE); |
| 377 | goto out_set_mac_control; |
| 378 | } |
| 379 | |
| 380 | /* Once for priv->dev, again for priv->mesh_dev if it exists */ |
| 381 | nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->dev, 0); |
| 382 | if (nr_addrs >= 0 && priv->mesh_dev) |
| 383 | nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->mesh_dev, nr_addrs); |
| 384 | if (nr_addrs < 0) |
| 385 | goto do_allmulti; |
| 386 | |
| 387 | if (nr_addrs) { |
| 388 | int size = offsetof(struct cmd_ds_mac_multicast_adr, |
| 389 | maclist[6*nr_addrs]); |
| 390 | |
| 391 | mcast_cmd.action = cpu_to_le16(CMD_ACT_SET); |
| 392 | mcast_cmd.hdr.size = cpu_to_le16(size); |
| 393 | mcast_cmd.nr_of_adrs = cpu_to_le16(nr_addrs); |
| 394 | |
| 395 | lbs_cmd_async(priv, CMD_MAC_MULTICAST_ADR, &mcast_cmd.hdr, size); |
| 396 | |
| 397 | priv->mac_control |= CMD_ACT_MAC_MULTICAST_ENABLE; |
| 398 | } else |
| 399 | priv->mac_control &= ~CMD_ACT_MAC_MULTICAST_ENABLE; |
| 400 | |
| 401 | priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE | |
| 402 | CMD_ACT_MAC_ALL_MULTICAST_ENABLE); |
| 403 | out_set_mac_control: |
| 404 | if (priv->mac_control != old_mac_control) |
| 405 | lbs_set_mac_control(priv); |
| 406 | |
| 407 | lbs_deb_leave(LBS_DEB_NET); |
| 408 | } |
| 409 | |
Holger Schurig | e0e42da | 2009-11-25 13:10:15 +0100 | [diff] [blame] | 410 | void lbs_set_multicast_list(struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 411 | { |
Kiran Divekar | ab65f64 | 2009-02-19 19:32:39 -0500 | [diff] [blame] | 412 | struct lbs_private *priv = dev->ml_priv; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 413 | |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 414 | schedule_work(&priv->mcast_work); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 415 | } |
| 416 | |
| 417 | /** |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 418 | * @brief This function handles the major jobs in the LBS driver. |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 419 | * It handles all events generated by firmware, RX data received |
| 420 | * from firmware and TX data sent from kernel. |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 421 | * |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 422 | * @param data A pointer to lbs_thread structure |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 423 | * @return 0 |
| 424 | */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 425 | static int lbs_thread(void *data) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 426 | { |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 427 | struct net_device *dev = data; |
Kiran Divekar | ab65f64 | 2009-02-19 19:32:39 -0500 | [diff] [blame] | 428 | struct lbs_private *priv = dev->ml_priv; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 429 | wait_queue_t wait; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 430 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 431 | lbs_deb_enter(LBS_DEB_THREAD); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 432 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 433 | init_waitqueue_entry(&wait, current); |
| 434 | |
| 435 | for (;;) { |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 436 | int shouldsleep; |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 437 | u8 resp_idx; |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 438 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 439 | lbs_deb_thread("1: currenttxskb %p, dnld_sent %d\n", |
| 440 | priv->currenttxskb, priv->dnld_sent); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 441 | |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 442 | add_wait_queue(&priv->waitq, &wait); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 443 | set_current_state(TASK_INTERRUPTIBLE); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 444 | spin_lock_irq(&priv->driver_lock); |
David Woodhouse | 59f3e4b | 2007-12-08 17:42:59 +0000 | [diff] [blame] | 445 | |
David Woodhouse | d9f8870 | 2007-12-13 21:48:00 -0500 | [diff] [blame] | 446 | if (kthread_should_stop()) |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 447 | shouldsleep = 0; /* Bye */ |
David Woodhouse | d9f8870 | 2007-12-13 21:48:00 -0500 | [diff] [blame] | 448 | else if (priv->surpriseremoved) |
| 449 | shouldsleep = 1; /* We need to wait until we're _told_ to die */ |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 450 | else if (priv->psstate == PS_STATE_SLEEP) |
| 451 | shouldsleep = 1; /* Sleep mode. Nothing we can do till it wakes */ |
David Woodhouse | 2a34509 | 2007-12-15 19:33:43 -0500 | [diff] [blame] | 452 | else if (priv->cmd_timed_out) |
| 453 | shouldsleep = 0; /* Command timed out. Recover */ |
David Woodhouse | b15152a | 2007-12-11 11:55:37 -0500 | [diff] [blame] | 454 | else if (!priv->fw_ready) |
| 455 | shouldsleep = 1; /* Firmware not ready. We're waiting for it */ |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 456 | else if (priv->dnld_sent) |
| 457 | shouldsleep = 1; /* Something is en route to the device already */ |
David Woodhouse | 2eb188a | 2007-12-09 23:54:27 -0500 | [diff] [blame] | 458 | else if (priv->tx_pending_len > 0) |
| 459 | shouldsleep = 0; /* We've a packet to send */ |
Holger Schurig | ef707b8 | 2008-05-23 16:04:13 +0200 | [diff] [blame] | 460 | else if (priv->resp_len[priv->resp_idx]) |
| 461 | shouldsleep = 0; /* We have a command response */ |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 462 | else if (priv->cur_cmd) |
| 463 | shouldsleep = 1; /* Can't send a command; one already running */ |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 464 | else if (!list_empty(&priv->cmdpendingq) && |
| 465 | !(priv->wakeup_dev_required)) |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 466 | shouldsleep = 0; /* We have a command to send */ |
Stefani Seibold | e64c026 | 2009-12-21 14:37:28 -0800 | [diff] [blame] | 467 | else if (kfifo_len(&priv->event_fifo)) |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 468 | shouldsleep = 0; /* We have an event to process */ |
David Woodhouse | b8d40bc | 2007-12-09 23:44:43 -0500 | [diff] [blame] | 469 | else |
| 470 | shouldsleep = 1; /* No command */ |
| 471 | |
| 472 | if (shouldsleep) { |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 473 | lbs_deb_thread("sleeping, connect_status %d, " |
Holger Schurig | 5f505d9 | 2008-04-30 10:50:07 +0200 | [diff] [blame] | 474 | "psmode %d, psstate %d\n", |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 475 | priv->connect_status, |
| 476 | priv->psmode, priv->psstate); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 477 | spin_unlock_irq(&priv->driver_lock); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 478 | schedule(); |
| 479 | } else |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 480 | spin_unlock_irq(&priv->driver_lock); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 481 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 482 | lbs_deb_thread("2: currenttxskb %p, dnld_send %d\n", |
| 483 | priv->currenttxskb, priv->dnld_sent); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 484 | |
| 485 | set_current_state(TASK_RUNNING); |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 486 | remove_wait_queue(&priv->waitq, &wait); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 487 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 488 | lbs_deb_thread("3: currenttxskb %p, dnld_sent %d\n", |
| 489 | priv->currenttxskb, priv->dnld_sent); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 490 | |
David Woodhouse | d9f8870 | 2007-12-13 21:48:00 -0500 | [diff] [blame] | 491 | if (kthread_should_stop()) { |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 492 | lbs_deb_thread("break from main thread\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 493 | break; |
| 494 | } |
| 495 | |
David Woodhouse | d9f8870 | 2007-12-13 21:48:00 -0500 | [diff] [blame] | 496 | if (priv->surpriseremoved) { |
| 497 | lbs_deb_thread("adapter removed; waiting to die...\n"); |
| 498 | continue; |
| 499 | } |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 500 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 501 | lbs_deb_thread("4: currenttxskb %p, dnld_sent %d\n", |
| 502 | priv->currenttxskb, priv->dnld_sent); |
| 503 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 504 | /* Process any pending command response */ |
Holger Schurig | a01f545 | 2008-06-04 11:10:40 +0200 | [diff] [blame] | 505 | spin_lock_irq(&priv->driver_lock); |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 506 | resp_idx = priv->resp_idx; |
| 507 | if (priv->resp_len[resp_idx]) { |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 508 | spin_unlock_irq(&priv->driver_lock); |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 509 | lbs_process_command_response(priv, |
| 510 | priv->resp_buf[resp_idx], |
| 511 | priv->resp_len[resp_idx]); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 512 | spin_lock_irq(&priv->driver_lock); |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 513 | priv->resp_len[resp_idx] = 0; |
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 | spin_unlock_irq(&priv->driver_lock); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 516 | |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 517 | /* Process hardware events, e.g. card removed, link lost */ |
| 518 | spin_lock_irq(&priv->driver_lock); |
Stefani Seibold | e64c026 | 2009-12-21 14:37:28 -0800 | [diff] [blame] | 519 | while (kfifo_len(&priv->event_fifo)) { |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 520 | u32 event; |
Stefani Seibold | 7acd72e | 2009-12-21 14:37:28 -0800 | [diff] [blame] | 521 | |
Stefani Seibold | 9842c38 | 2009-12-21 14:37:29 -0800 | [diff] [blame] | 522 | if (kfifo_out(&priv->event_fifo, |
| 523 | (unsigned char *) &event, sizeof(event)) != |
| 524 | sizeof(event)) |
| 525 | break; |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 526 | spin_unlock_irq(&priv->driver_lock); |
| 527 | lbs_process_event(priv, event); |
| 528 | spin_lock_irq(&priv->driver_lock); |
| 529 | } |
| 530 | spin_unlock_irq(&priv->driver_lock); |
| 531 | |
| 532 | if (priv->wakeup_dev_required) { |
| 533 | lbs_deb_thread("Waking up device...\n"); |
| 534 | /* Wake up device */ |
| 535 | if (priv->exit_deep_sleep(priv)) |
| 536 | lbs_deb_thread("Wakeup device failed\n"); |
| 537 | continue; |
| 538 | } |
| 539 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 540 | /* command timeout stuff */ |
David Woodhouse | 2a34509 | 2007-12-15 19:33:43 -0500 | [diff] [blame] | 541 | if (priv->cmd_timed_out && priv->cur_cmd) { |
| 542 | struct cmd_ctrl_node *cmdnode = priv->cur_cmd; |
| 543 | |
Holger Schurig | 40e6fa8 | 2010-02-04 14:37:45 +0100 | [diff] [blame] | 544 | lbs_pr_info("Timeout submitting command 0x%04x\n", |
| 545 | le16_to_cpu(cmdnode->cmdbuf->command)); |
| 546 | lbs_complete_command(priv, cmdnode, -ETIMEDOUT); |
| 547 | if (priv->reset_card) |
| 548 | priv->reset_card(priv); |
David Woodhouse | 2a34509 | 2007-12-15 19:33:43 -0500 | [diff] [blame] | 549 | } |
| 550 | priv->cmd_timed_out = 0; |
| 551 | |
David Woodhouse | b15152a | 2007-12-11 11:55:37 -0500 | [diff] [blame] | 552 | if (!priv->fw_ready) |
| 553 | continue; |
| 554 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 555 | /* Check if we need to confirm Sleep Request received previously */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 556 | if (priv->psstate == PS_STATE_PRE_SLEEP && |
| 557 | !priv->dnld_sent && !priv->cur_cmd) { |
| 558 | if (priv->connect_status == LBS_CONNECTED) { |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 559 | lbs_deb_thread("pre-sleep, currenttxskb %p, " |
| 560 | "dnld_sent %d, cur_cmd %p\n", |
| 561 | priv->currenttxskb, priv->dnld_sent, |
| 562 | priv->cur_cmd); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 563 | |
Holger Schurig | d4ff0ef | 2008-03-19 14:25:18 +0100 | [diff] [blame] | 564 | lbs_ps_confirm_sleep(priv); |
David Woodhouse | 59f3e4b | 2007-12-08 17:42:59 +0000 | [diff] [blame] | 565 | } else { |
| 566 | /* workaround for firmware sending |
| 567 | * deauth/linkloss event immediately |
| 568 | * after sleep request; remove this |
| 569 | * after firmware fixes it |
| 570 | */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 571 | priv->psstate = PS_STATE_AWAKE; |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 572 | lbs_pr_alert("ignore PS_SleepConfirm in " |
| 573 | "non-connected state\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 574 | } |
| 575 | } |
| 576 | |
| 577 | /* The PS state is changed during processing of Sleep Request |
| 578 | * event above |
| 579 | */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 580 | if ((priv->psstate == PS_STATE_SLEEP) || |
| 581 | (priv->psstate == PS_STATE_PRE_SLEEP)) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 582 | continue; |
| 583 | |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 584 | if (priv->is_deep_sleep) |
| 585 | continue; |
| 586 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 587 | /* Execute the next command */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 588 | if (!priv->dnld_sent && !priv->cur_cmd) |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 589 | lbs_execute_next_command(priv); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 590 | |
| 591 | /* Wake-up command waiters which can't sleep in |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 592 | * lbs_prepare_and_send_command |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 593 | */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 594 | if (!list_empty(&priv->cmdpendingq)) |
| 595 | wake_up_all(&priv->cmd_pending); |
David Woodhouse | 2eb188a | 2007-12-09 23:54:27 -0500 | [diff] [blame] | 596 | |
| 597 | spin_lock_irq(&priv->driver_lock); |
| 598 | if (!priv->dnld_sent && priv->tx_pending_len > 0) { |
| 599 | int ret = priv->hw_host_to_card(priv, MVMS_DAT, |
| 600 | priv->tx_pending_buf, |
| 601 | priv->tx_pending_len); |
| 602 | if (ret) { |
| 603 | lbs_deb_tx("host_to_card failed %d\n", ret); |
| 604 | priv->dnld_sent = DNLD_RES_RECEIVED; |
| 605 | } |
| 606 | priv->tx_pending_len = 0; |
| 607 | if (!priv->currenttxskb) { |
| 608 | /* We can wake the queues immediately if we aren't |
| 609 | waiting for TX feedback */ |
| 610 | if (priv->connect_status == LBS_CONNECTED) |
| 611 | netif_wake_queue(priv->dev); |
| 612 | if (priv->mesh_dev && |
Holger Schurig | 602114a | 2009-12-02 15:26:01 +0100 | [diff] [blame] | 613 | lbs_mesh_connected(priv)) |
David Woodhouse | 2eb188a | 2007-12-09 23:54:27 -0500 | [diff] [blame] | 614 | netif_wake_queue(priv->mesh_dev); |
| 615 | } |
| 616 | } |
| 617 | spin_unlock_irq(&priv->driver_lock); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 618 | } |
| 619 | |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 620 | del_timer(&priv->command_timer); |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 621 | del_timer(&priv->auto_deepsleep_timer); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 622 | wake_up_all(&priv->cmd_pending); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 623 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 624 | lbs_deb_leave(LBS_DEB_THREAD); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 625 | return 0; |
| 626 | } |
| 627 | |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 628 | static int lbs_suspend_callback(struct lbs_private *priv, unsigned long dummy, |
| 629 | struct cmd_header *cmd) |
| 630 | { |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 631 | lbs_deb_enter(LBS_DEB_FW); |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 632 | |
| 633 | netif_device_detach(priv->dev); |
| 634 | if (priv->mesh_dev) |
| 635 | netif_device_detach(priv->mesh_dev); |
| 636 | |
| 637 | priv->fw_ready = 0; |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 638 | lbs_deb_leave(LBS_DEB_FW); |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 639 | return 0; |
| 640 | } |
| 641 | |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 642 | int lbs_suspend(struct lbs_private *priv) |
| 643 | { |
| 644 | struct cmd_header cmd; |
| 645 | int ret; |
| 646 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 647 | lbs_deb_enter(LBS_DEB_FW); |
| 648 | |
David Woodhouse | 506e902 | 2007-12-12 20:06:06 -0500 | [diff] [blame] | 649 | if (priv->wol_criteria == 0xffffffff) { |
| 650 | lbs_pr_info("Suspend attempt without configuring wake params!\n"); |
| 651 | return -EINVAL; |
| 652 | } |
| 653 | |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 654 | memset(&cmd, 0, sizeof(cmd)); |
David Woodhouse | 7e22627 | 2007-12-14 22:53:41 -0500 | [diff] [blame] | 655 | |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 656 | ret = __lbs_cmd(priv, CMD_802_11_HOST_SLEEP_ACTIVATE, &cmd, |
| 657 | sizeof(cmd), lbs_suspend_callback, 0); |
| 658 | if (ret) |
| 659 | lbs_pr_info("HOST_SLEEP_ACTIVATE failed: %d\n", ret); |
| 660 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 661 | lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 662 | return ret; |
| 663 | } |
| 664 | EXPORT_SYMBOL_GPL(lbs_suspend); |
| 665 | |
Holger Schurig | a63e5cb | 2008-04-30 10:50:39 +0200 | [diff] [blame] | 666 | void lbs_resume(struct lbs_private *priv) |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 667 | { |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 668 | lbs_deb_enter(LBS_DEB_FW); |
| 669 | |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 670 | priv->fw_ready = 1; |
| 671 | |
| 672 | /* Firmware doesn't seem to give us RX packets any more |
| 673 | until we send it some command. Might as well update */ |
| 674 | lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0, |
| 675 | 0, 0, NULL); |
| 676 | |
| 677 | netif_device_attach(priv->dev); |
| 678 | if (priv->mesh_dev) |
| 679 | netif_device_attach(priv->mesh_dev); |
| 680 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 681 | lbs_deb_leave(LBS_DEB_FW); |
David Woodhouse | ab25eca | 2007-12-12 17:38:56 -0500 | [diff] [blame] | 682 | } |
| 683 | EXPORT_SYMBOL_GPL(lbs_resume); |
| 684 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 685 | /** |
Colin McCabe | b483659 | 2009-01-02 19:00:22 -0800 | [diff] [blame] | 686 | * @brief This function gets the HW spec from the firmware and sets |
| 687 | * some basic parameters. |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 688 | * |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 689 | * @param priv A pointer to struct lbs_private structure |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 690 | * @return 0 or -1 |
| 691 | */ |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 692 | static int lbs_setup_firmware(struct lbs_private *priv) |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 693 | { |
| 694 | int ret = -1; |
Dan Williams | 87c8c72 | 2008-08-19 15:15:35 -0400 | [diff] [blame] | 695 | s16 curlevel = 0, minlevel = 0, maxlevel = 0; |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 696 | |
| 697 | lbs_deb_enter(LBS_DEB_FW); |
| 698 | |
Dan Williams | 87c8c72 | 2008-08-19 15:15:35 -0400 | [diff] [blame] | 699 | /* Read MAC address from firmware */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 700 | memset(priv->current_addr, 0xff, ETH_ALEN); |
Dan Williams | 6e66f03 | 2007-12-11 12:42:16 -0500 | [diff] [blame] | 701 | ret = lbs_update_hw_spec(priv); |
Holger Schurig | ef85ad5 | 2008-05-14 16:27:18 +0200 | [diff] [blame] | 702 | if (ret) |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 703 | goto done; |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 704 | |
Dan Williams | 87c8c72 | 2008-08-19 15:15:35 -0400 | [diff] [blame] | 705 | /* Read power levels if available */ |
| 706 | ret = lbs_get_tx_power(priv, &curlevel, &minlevel, &maxlevel); |
| 707 | if (ret == 0) { |
| 708 | priv->txpower_cur = curlevel; |
| 709 | priv->txpower_min = minlevel; |
| 710 | priv->txpower_max = maxlevel; |
| 711 | } |
| 712 | |
Holger Schurig | d9e9778 | 2008-03-12 16:06:43 +0100 | [diff] [blame] | 713 | lbs_set_mac_control(priv); |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 714 | done: |
| 715 | lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret); |
| 716 | return ret; |
| 717 | } |
| 718 | |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 719 | /** |
| 720 | * This function handles the timeout of command sending. |
| 721 | * It will re-send the same command again. |
| 722 | */ |
Holger Schurig | 40e6fa8 | 2010-02-04 14:37:45 +0100 | [diff] [blame] | 723 | static void lbs_cmd_timeout_handler(unsigned long data) |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 724 | { |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 725 | struct lbs_private *priv = (struct lbs_private *)data; |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 726 | unsigned long flags; |
| 727 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 728 | lbs_deb_enter(LBS_DEB_CMD); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 729 | spin_lock_irqsave(&priv->driver_lock, flags); |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 730 | |
Holger Schurig | 57962f0 | 2008-05-14 16:30:28 +0200 | [diff] [blame] | 731 | if (!priv->cur_cmd) |
David Woodhouse | 2a34509 | 2007-12-15 19:33:43 -0500 | [diff] [blame] | 732 | goto out; |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 733 | |
Holger Schurig | 57962f0 | 2008-05-14 16:30:28 +0200 | [diff] [blame] | 734 | lbs_pr_info("command 0x%04x timed out\n", |
| 735 | le16_to_cpu(priv->cur_cmd->cmdbuf->command)); |
David Woodhouse | 2a34509 | 2007-12-15 19:33:43 -0500 | [diff] [blame] | 736 | |
| 737 | priv->cmd_timed_out = 1; |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 738 | wake_up_interruptible(&priv->waitq); |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 739 | out: |
David Woodhouse | 2a34509 | 2007-12-15 19:33:43 -0500 | [diff] [blame] | 740 | spin_unlock_irqrestore(&priv->driver_lock, flags); |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 741 | lbs_deb_leave(LBS_DEB_CMD); |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 742 | } |
| 743 | |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 744 | /** |
| 745 | * This function put the device back to deep sleep mode when timer expires |
| 746 | * and no activity (command, event, data etc.) is detected. |
| 747 | */ |
| 748 | static void auto_deepsleep_timer_fn(unsigned long data) |
| 749 | { |
| 750 | struct lbs_private *priv = (struct lbs_private *)data; |
| 751 | int ret; |
| 752 | |
| 753 | lbs_deb_enter(LBS_DEB_CMD); |
| 754 | |
| 755 | if (priv->is_activity_detected) { |
| 756 | priv->is_activity_detected = 0; |
| 757 | } else { |
| 758 | if (priv->is_auto_deep_sleep_enabled && |
| 759 | (!priv->wakeup_dev_required) && |
| 760 | (priv->connect_status != LBS_CONNECTED)) { |
| 761 | lbs_deb_main("Entering auto deep sleep mode...\n"); |
| 762 | ret = lbs_prepare_and_send_command(priv, |
| 763 | CMD_802_11_DEEP_SLEEP, 0, |
| 764 | 0, 0, NULL); |
Amitkumar Karwar | c0bbd57 | 2009-10-08 19:38:45 -0700 | [diff] [blame] | 765 | if (ret) |
| 766 | lbs_pr_err("Enter Deep Sleep command failed\n"); |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 767 | } |
| 768 | } |
| 769 | mod_timer(&priv->auto_deepsleep_timer , jiffies + |
| 770 | (priv->auto_deep_sleep_timeout * HZ)/1000); |
| 771 | lbs_deb_leave(LBS_DEB_CMD); |
| 772 | } |
| 773 | |
| 774 | int lbs_enter_auto_deep_sleep(struct lbs_private *priv) |
| 775 | { |
| 776 | lbs_deb_enter(LBS_DEB_SDIO); |
| 777 | |
| 778 | priv->is_auto_deep_sleep_enabled = 1; |
| 779 | if (priv->is_deep_sleep) |
| 780 | priv->wakeup_dev_required = 1; |
| 781 | mod_timer(&priv->auto_deepsleep_timer , |
| 782 | jiffies + (priv->auto_deep_sleep_timeout * HZ)/1000); |
| 783 | |
| 784 | lbs_deb_leave(LBS_DEB_SDIO); |
| 785 | return 0; |
| 786 | } |
| 787 | |
| 788 | int lbs_exit_auto_deep_sleep(struct lbs_private *priv) |
| 789 | { |
| 790 | lbs_deb_enter(LBS_DEB_SDIO); |
| 791 | |
| 792 | priv->is_auto_deep_sleep_enabled = 0; |
| 793 | priv->auto_deep_sleep_timeout = 0; |
| 794 | del_timer(&priv->auto_deepsleep_timer); |
| 795 | |
| 796 | lbs_deb_leave(LBS_DEB_SDIO); |
| 797 | return 0; |
| 798 | } |
| 799 | |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 800 | static int lbs_init_adapter(struct lbs_private *priv) |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 801 | { |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 802 | size_t bufsize; |
| 803 | int i, ret = 0; |
| 804 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 805 | lbs_deb_enter(LBS_DEB_MAIN); |
| 806 | |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 807 | /* Allocate buffer to store the BSSID list */ |
| 808 | bufsize = MAX_NETWORK_COUNT * sizeof(struct bss_descriptor); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 809 | priv->networks = kzalloc(bufsize, GFP_KERNEL); |
| 810 | if (!priv->networks) { |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 811 | lbs_pr_err("Out of memory allocating beacons\n"); |
| 812 | ret = -1; |
| 813 | goto out; |
| 814 | } |
| 815 | |
| 816 | /* Initialize scan result lists */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 817 | INIT_LIST_HEAD(&priv->network_free_list); |
| 818 | INIT_LIST_HEAD(&priv->network_list); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 819 | for (i = 0; i < MAX_NETWORK_COUNT; i++) { |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 820 | list_add_tail(&priv->networks[i].list, |
| 821 | &priv->network_free_list); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 822 | } |
| 823 | |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 824 | memset(priv->current_addr, 0xff, ETH_ALEN); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 825 | |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 826 | priv->connect_status = LBS_DISCONNECTED; |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 827 | priv->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM; |
| 828 | priv->mode = IW_MODE_INFRA; |
Holger Schurig | c14951f | 2009-10-22 15:30:50 +0200 | [diff] [blame] | 829 | priv->channel = DEFAULT_AD_HOC_CHANNEL; |
Holger Schurig | d9e9778 | 2008-03-12 16:06:43 +0100 | [diff] [blame] | 830 | 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] | 831 | priv->radio_on = 1; |
Javier Cardona | 85319f9 | 2008-05-24 10:59:49 +0100 | [diff] [blame] | 832 | priv->enablehwauto = 1; |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 833 | priv->psmode = LBS802_11POWERMODECAM; |
| 834 | priv->psstate = PS_STATE_FULL_POWER; |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 835 | priv->is_deep_sleep = 0; |
| 836 | priv->is_auto_deep_sleep_enabled = 0; |
| 837 | priv->wakeup_dev_required = 0; |
| 838 | init_waitqueue_head(&priv->ds_awake_q); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 839 | |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 840 | mutex_init(&priv->lock); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 841 | |
Holger Schurig | 40e6fa8 | 2010-02-04 14:37:45 +0100 | [diff] [blame] | 842 | setup_timer(&priv->command_timer, lbs_cmd_timeout_handler, |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 843 | (unsigned long)priv); |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 844 | setup_timer(&priv->auto_deepsleep_timer, auto_deepsleep_timer_fn, |
| 845 | (unsigned long)priv); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 846 | |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 847 | INIT_LIST_HEAD(&priv->cmdfreeq); |
| 848 | INIT_LIST_HEAD(&priv->cmdpendingq); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 849 | |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 850 | spin_lock_init(&priv->driver_lock); |
| 851 | init_waitqueue_head(&priv->cmd_pending); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 852 | |
| 853 | /* Allocate the command buffers */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 854 | if (lbs_allocate_cmd_buffer(priv)) { |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 855 | lbs_pr_err("Out of memory allocating command buffers\n"); |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 856 | ret = -ENOMEM; |
| 857 | goto out; |
| 858 | } |
| 859 | priv->resp_idx = 0; |
| 860 | priv->resp_len[0] = priv->resp_len[1] = 0; |
| 861 | |
| 862 | /* Create the event FIFO */ |
Stefani Seibold | c1e13f2 | 2009-12-21 14:37:27 -0800 | [diff] [blame] | 863 | ret = kfifo_alloc(&priv->event_fifo, sizeof(u32) * 16, GFP_KERNEL); |
Stefani Seibold | 4546548 | 2009-12-21 14:37:26 -0800 | [diff] [blame] | 864 | if (ret) { |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 865 | lbs_pr_err("Out of memory allocating event FIFO buffer\n"); |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 866 | goto out; |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 867 | } |
| 868 | |
| 869 | out: |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 870 | lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); |
| 871 | |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 872 | return ret; |
| 873 | } |
| 874 | |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 875 | static void lbs_free_adapter(struct lbs_private *priv) |
Holger Schurig | ac558ca | 2007-08-02 11:49:06 -0400 | [diff] [blame] | 876 | { |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 877 | lbs_deb_enter(LBS_DEB_MAIN); |
| 878 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 879 | lbs_free_cmd_buffer(priv); |
Stefani Seibold | 4546548 | 2009-12-21 14:37:26 -0800 | [diff] [blame] | 880 | kfifo_free(&priv->event_fifo); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 881 | del_timer(&priv->command_timer); |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 882 | del_timer(&priv->auto_deepsleep_timer); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 883 | kfree(priv->networks); |
| 884 | priv->networks = NULL; |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 885 | |
| 886 | lbs_deb_leave(LBS_DEB_MAIN); |
Holger Schurig | ac558ca | 2007-08-02 11:49:06 -0400 | [diff] [blame] | 887 | } |
| 888 | |
Stephen Hemminger | f02abf1 | 2009-03-20 19:36:37 +0000 | [diff] [blame] | 889 | static const struct net_device_ops lbs_netdev_ops = { |
| 890 | .ndo_open = lbs_dev_open, |
| 891 | .ndo_stop = lbs_eth_stop, |
| 892 | .ndo_start_xmit = lbs_hard_start_xmit, |
| 893 | .ndo_set_mac_address = lbs_set_mac_address, |
| 894 | .ndo_tx_timeout = lbs_tx_timeout, |
| 895 | .ndo_set_multicast_list = lbs_set_multicast_list, |
| 896 | .ndo_change_mtu = eth_change_mtu, |
| 897 | .ndo_validate_addr = eth_validate_addr, |
| 898 | }; |
| 899 | |
Holger Schurig | 1df4e8f | 2007-08-02 11:45:12 -0400 | [diff] [blame] | 900 | /** |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 901 | * @brief This function adds the card. it will probe the |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 902 | * card, allocate the lbs_priv and initialize the device. |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 903 | * |
| 904 | * @param card A pointer to card |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 905 | * @return A pointer to struct lbs_private structure |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 906 | */ |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 907 | struct lbs_private *lbs_add_card(void *card, struct device *dmdev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 908 | { |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 909 | struct net_device *dev; |
| 910 | struct wireless_dev *wdev; |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 911 | struct lbs_private *priv = NULL; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 912 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 913 | lbs_deb_enter(LBS_DEB_MAIN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 914 | |
| 915 | /* Allocate an Ethernet device and register it */ |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 916 | wdev = lbs_cfg_alloc(dmdev); |
| 917 | if (IS_ERR(wdev)) { |
| 918 | lbs_pr_err("cfg80211 init failed\n"); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 919 | goto done; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 920 | } |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 921 | /* TODO? */ |
| 922 | wdev->iftype = NL80211_IFTYPE_STATION; |
| 923 | priv = wdev_priv(wdev); |
| 924 | priv->wdev = wdev; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 925 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 926 | if (lbs_init_adapter(priv)) { |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 927 | lbs_pr_err("failed to initialize adapter structure.\n"); |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 928 | goto err_wdev; |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 929 | } |
| 930 | |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 931 | //TODO? dev = alloc_netdev_mq(0, "wlan%d", ether_setup, IWM_TX_QUEUES); |
| 932 | dev = alloc_netdev(0, "wlan%d", ether_setup); |
| 933 | if (!dev) { |
| 934 | dev_err(dmdev, "no memory for network device instance\n"); |
| 935 | goto err_adapter; |
| 936 | } |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 937 | |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 938 | dev->ieee80211_ptr = wdev; |
| 939 | dev->ml_priv = priv; |
| 940 | SET_NETDEV_DEV(dev, dmdev); |
| 941 | wdev->netdev = dev; |
| 942 | priv->dev = dev; |
| 943 | |
Stephen Hemminger | f02abf1 | 2009-03-20 19:36:37 +0000 | [diff] [blame] | 944 | dev->netdev_ops = &lbs_netdev_ops; |
Holger Schurig | fb3dddf | 2007-05-25 11:58:22 -0400 | [diff] [blame] | 945 | dev->watchdog_timeo = 5 * HZ; |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 946 | dev->ethtool_ops = &lbs_ethtool_ops; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 947 | #ifdef WIRELESS_EXT |
Stephen Hemminger | f02abf1 | 2009-03-20 19:36:37 +0000 | [diff] [blame] | 948 | dev->wireless_handlers = &lbs_handler_def; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 949 | #endif |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 950 | dev->flags |= IFF_BROADCAST | IFF_MULTICAST; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 951 | |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 952 | |
| 953 | // TODO: kzalloc + iwm_init_default_profile(iwm, iwm->umac_profile); ?? |
| 954 | |
| 955 | |
| 956 | priv->card = card; |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 957 | priv->infra_open = 0; |
| 958 | |
Dan Williams | 7732ca4 | 2007-05-25 13:13:25 -0400 | [diff] [blame] | 959 | |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 960 | priv->rtap_net_dev = NULL; |
Daniel Mack | c00552c | 2009-08-11 16:09:34 +0200 | [diff] [blame] | 961 | strcpy(dev->name, "wlan%d"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 962 | |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 963 | lbs_deb_thread("Starting main thread...\n"); |
| 964 | init_waitqueue_head(&priv->waitq); |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 965 | priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main"); |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 966 | if (IS_ERR(priv->main_thread)) { |
| 967 | lbs_deb_thread("Error creating main thread.\n"); |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 968 | goto err_ndev; |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 969 | } |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 970 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 971 | priv->work_thread = create_singlethread_workqueue("lbs_worker"); |
| 972 | INIT_DELAYED_WORK(&priv->assoc_work, lbs_association_worker); |
| 973 | INIT_DELAYED_WORK(&priv->scan_work, lbs_scan_worker); |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 974 | INIT_WORK(&priv->mcast_work, lbs_set_mcast_worker); |
David Woodhouse | 23a397a | 2007-12-11 18:56:42 -0500 | [diff] [blame] | 975 | |
David Woodhouse | 506e902 | 2007-12-12 20:06:06 -0500 | [diff] [blame] | 976 | priv->wol_criteria = 0xffffffff; |
| 977 | priv->wol_gpio = 0xff; |
| 978 | |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 979 | goto done; |
| 980 | |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 981 | err_ndev: |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 982 | free_netdev(dev); |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 983 | |
| 984 | err_adapter: |
| 985 | lbs_free_adapter(priv); |
| 986 | |
| 987 | err_wdev: |
| 988 | lbs_cfg_free(priv); |
| 989 | |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 990 | priv = NULL; |
| 991 | |
| 992 | done: |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 993 | lbs_deb_leave_args(LBS_DEB_MAIN, "priv %p", priv); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 994 | return priv; |
| 995 | } |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 996 | EXPORT_SYMBOL_GPL(lbs_add_card); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 997 | |
| 998 | |
Holger Schurig | a63e5cb | 2008-04-30 10:50:39 +0200 | [diff] [blame] | 999 | void lbs_remove_card(struct lbs_private *priv) |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1000 | { |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1001 | struct net_device *dev = priv->dev; |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1002 | |
| 1003 | lbs_deb_enter(LBS_DEB_MAIN); |
| 1004 | |
David Woodhouse | 23a397a | 2007-12-11 18:56:42 -0500 | [diff] [blame] | 1005 | lbs_remove_mesh(priv); |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1006 | lbs_remove_rtap(priv); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1007 | |
| 1008 | dev = priv->dev; |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1009 | |
Holger Schurig | 652e3f2 | 2008-04-30 10:51:15 +0200 | [diff] [blame] | 1010 | cancel_delayed_work_sync(&priv->scan_work); |
| 1011 | cancel_delayed_work_sync(&priv->assoc_work); |
David Woodhouse | 75bf45a | 2008-05-20 13:32:45 +0100 | [diff] [blame] | 1012 | cancel_work_sync(&priv->mcast_work); |
Dan Williams | 71b35f3 | 2008-09-08 16:34:40 -0400 | [diff] [blame] | 1013 | |
| 1014 | /* worker thread destruction blocks on the in-flight command which |
| 1015 | * should have been cleared already in lbs_stop_card(). |
| 1016 | */ |
| 1017 | lbs_deb_main("destroying worker thread\n"); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1018 | destroy_workqueue(priv->work_thread); |
Dan Williams | 71b35f3 | 2008-09-08 16:34:40 -0400 | [diff] [blame] | 1019 | lbs_deb_main("done destroying worker thread\n"); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1020 | |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 1021 | if (priv->psmode == LBS802_11POWERMODEMAX_PSP) { |
| 1022 | priv->psmode = LBS802_11POWERMODECAM; |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1023 | lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1024 | } |
| 1025 | |
Holger Schurig | fea2b8e | 2009-10-22 15:30:56 +0200 | [diff] [blame] | 1026 | lbs_send_disconnect_notification(priv); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1027 | |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 1028 | if (priv->is_deep_sleep) { |
| 1029 | priv->is_deep_sleep = 0; |
| 1030 | wake_up_interruptible(&priv->ds_awake_q); |
| 1031 | } |
| 1032 | |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1033 | /* Stop the thread servicing the interrupts */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 1034 | priv->surpriseremoved = 1; |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1035 | kthread_stop(priv->main_thread); |
| 1036 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1037 | lbs_free_adapter(priv); |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 1038 | lbs_cfg_free(priv); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1039 | |
| 1040 | priv->dev = NULL; |
| 1041 | free_netdev(dev); |
| 1042 | |
| 1043 | lbs_deb_leave(LBS_DEB_MAIN); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1044 | } |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1045 | EXPORT_SYMBOL_GPL(lbs_remove_card); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1046 | |
| 1047 | |
Holger Schurig | cd74468 | 2009-12-02 15:25:59 +0100 | [diff] [blame] | 1048 | static int lbs_rtap_supported(struct lbs_private *priv) |
| 1049 | { |
| 1050 | if (MRVL_FW_MAJOR_REV(priv->fwrelease) == MRVL_FW_V5) |
| 1051 | return 1; |
| 1052 | |
| 1053 | /* newer firmware use a capability mask */ |
| 1054 | return ((MRVL_FW_MAJOR_REV(priv->fwrelease) >= MRVL_FW_V10) && |
| 1055 | (priv->fwcapinfo & MESH_CAPINFO_ENABLE_MASK)); |
| 1056 | } |
| 1057 | |
| 1058 | |
Holger Schurig | 69f9032 | 2007-11-23 15:43:44 +0100 | [diff] [blame] | 1059 | int lbs_start_card(struct lbs_private *priv) |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1060 | { |
| 1061 | struct net_device *dev = priv->dev; |
| 1062 | int ret = -1; |
| 1063 | |
| 1064 | lbs_deb_enter(LBS_DEB_MAIN); |
| 1065 | |
| 1066 | /* poke the firmware */ |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1067 | ret = lbs_setup_firmware(priv); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1068 | if (ret) |
| 1069 | goto done; |
| 1070 | |
Holger Schurig | ff9fc79 | 2009-10-06 16:31:54 +0200 | [diff] [blame] | 1071 | if (lbs_cfg_register(priv)) { |
| 1072 | lbs_pr_err("cannot register device\n"); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1073 | goto done; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1074 | } |
David Woodhouse | 020f3d0 | 2007-12-12 23:29:13 -0500 | [diff] [blame] | 1075 | |
David Woodhouse | 020f3d0 | 2007-12-12 23:29:13 -0500 | [diff] [blame] | 1076 | lbs_update_channel(priv); |
David Woodhouse | 020f3d0 | 2007-12-12 23:29:13 -0500 | [diff] [blame] | 1077 | |
Holger Schurig | cd74468 | 2009-12-02 15:25:59 +0100 | [diff] [blame] | 1078 | lbs_init_mesh(priv); |
| 1079 | |
Holger Schurig | e0e42da | 2009-11-25 13:10:15 +0100 | [diff] [blame] | 1080 | /* |
| 1081 | * While rtap isn't related to mesh, only mesh-enabled |
| 1082 | * firmware implements the rtap functionality via |
| 1083 | * CMD_802_11_MONITOR_MODE. |
Bing Zhao | 684d6b3 | 2009-03-25 09:51:16 -0700 | [diff] [blame] | 1084 | */ |
Holger Schurig | cd74468 | 2009-12-02 15:25:59 +0100 | [diff] [blame] | 1085 | if (lbs_rtap_supported(priv)) { |
Bing Zhao | 684d6b3 | 2009-03-25 09:51:16 -0700 | [diff] [blame] | 1086 | if (device_create_file(&dev->dev, &dev_attr_lbs_rtap)) |
| 1087 | lbs_pr_err("cannot register lbs_rtap attribute\n"); |
David Woodhouse | 020f3d0 | 2007-12-12 23:29:13 -0500 | [diff] [blame] | 1088 | } |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1089 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1090 | lbs_debugfs_init_one(priv, dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1091 | |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1092 | lbs_pr_info("%s: Marvell WLAN 802.11 adapter\n", dev->name); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1093 | |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1094 | ret = 0; |
| 1095 | |
Holger Schurig | 32a74b7 | 2007-05-25 12:04:31 -0400 | [diff] [blame] | 1096 | done: |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1097 | lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); |
Holger Schurig | 32a74b7 | 2007-05-25 12:04:31 -0400 | [diff] [blame] | 1098 | return ret; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1099 | } |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1100 | EXPORT_SYMBOL_GPL(lbs_start_card); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1101 | |
| 1102 | |
Holger Schurig | a63e5cb | 2008-04-30 10:50:39 +0200 | [diff] [blame] | 1103 | void lbs_stop_card(struct lbs_private *priv) |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1104 | { |
Julia Lawall | 43baa5b | 2009-01-09 10:23:10 +0000 | [diff] [blame] | 1105 | struct net_device *dev; |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1106 | struct cmd_ctrl_node *cmdnode; |
| 1107 | unsigned long flags; |
| 1108 | |
| 1109 | lbs_deb_enter(LBS_DEB_MAIN); |
| 1110 | |
Holger Schurig | 652e3f2 | 2008-04-30 10:51:15 +0200 | [diff] [blame] | 1111 | if (!priv) |
| 1112 | goto out; |
Julia Lawall | 43baa5b | 2009-01-09 10:23:10 +0000 | [diff] [blame] | 1113 | dev = priv->dev; |
Holger Schurig | 652e3f2 | 2008-04-30 10:51:15 +0200 | [diff] [blame] | 1114 | |
Julia Lawall | 43baa5b | 2009-01-09 10:23:10 +0000 | [diff] [blame] | 1115 | netif_stop_queue(dev); |
| 1116 | netif_carrier_off(dev); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1117 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1118 | lbs_debugfs_remove_one(priv); |
Holger Schurig | cd74468 | 2009-12-02 15:25:59 +0100 | [diff] [blame] | 1119 | lbs_deinit_mesh(priv); |
| 1120 | |
| 1121 | if (lbs_rtap_supported(priv)) |
Dan Williams | 3b72b01 | 2008-07-29 13:50:39 -0400 | [diff] [blame] | 1122 | device_remove_file(&dev->dev, &dev_attr_lbs_rtap); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1123 | |
Dan Williams | 71b35f3 | 2008-09-08 16:34:40 -0400 | [diff] [blame] | 1124 | /* Delete the timeout of the currently processing command */ |
Holger Schurig | 652e3f2 | 2008-04-30 10:51:15 +0200 | [diff] [blame] | 1125 | del_timer_sync(&priv->command_timer); |
Amitkumar Karwar | 4912545 | 2009-09-30 20:04:38 -0700 | [diff] [blame] | 1126 | del_timer_sync(&priv->auto_deepsleep_timer); |
Dan Williams | 71b35f3 | 2008-09-08 16:34:40 -0400 | [diff] [blame] | 1127 | |
| 1128 | /* Flush pending command nodes */ |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 1129 | spin_lock_irqsave(&priv->driver_lock, flags); |
Dan Williams | 71b35f3 | 2008-09-08 16:34:40 -0400 | [diff] [blame] | 1130 | lbs_deb_main("clearing pending commands\n"); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 1131 | list_for_each_entry(cmdnode, &priv->cmdpendingq, list) { |
David Woodhouse | ae125bf | 2007-12-15 04:22:52 -0500 | [diff] [blame] | 1132 | cmdnode->result = -ENOENT; |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1133 | cmdnode->cmdwaitqwoken = 1; |
| 1134 | wake_up_interruptible(&cmdnode->cmdwait_q); |
| 1135 | } |
Dan Williams | 71b35f3 | 2008-09-08 16:34:40 -0400 | [diff] [blame] | 1136 | |
| 1137 | /* Flush the command the card is currently processing */ |
| 1138 | if (priv->cur_cmd) { |
| 1139 | lbs_deb_main("clearing current command\n"); |
| 1140 | priv->cur_cmd->result = -ENOENT; |
| 1141 | priv->cur_cmd->cmdwaitqwoken = 1; |
| 1142 | wake_up_interruptible(&priv->cur_cmd->cmdwait_q); |
| 1143 | } |
| 1144 | lbs_deb_main("done clearing commands\n"); |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 1145 | spin_unlock_irqrestore(&priv->driver_lock, flags); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1146 | |
| 1147 | unregister_netdev(dev); |
| 1148 | |
Holger Schurig | 652e3f2 | 2008-04-30 10:51:15 +0200 | [diff] [blame] | 1149 | out: |
Holger Schurig | a63e5cb | 2008-04-30 10:50:39 +0200 | [diff] [blame] | 1150 | lbs_deb_leave(LBS_DEB_MAIN); |
Dan Williams | 954ee16 | 2007-08-20 11:43:25 -0400 | [diff] [blame] | 1151 | } |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1152 | EXPORT_SYMBOL_GPL(lbs_stop_card); |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1153 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1154 | |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 1155 | void lbs_queue_event(struct lbs_private *priv, u32 event) |
| 1156 | { |
| 1157 | unsigned long flags; |
| 1158 | |
| 1159 | lbs_deb_enter(LBS_DEB_THREAD); |
| 1160 | spin_lock_irqsave(&priv->driver_lock, flags); |
| 1161 | |
| 1162 | if (priv->psstate == PS_STATE_SLEEP) |
| 1163 | priv->psstate = PS_STATE_AWAKE; |
| 1164 | |
Stefani Seibold | 7acd72e | 2009-12-21 14:37:28 -0800 | [diff] [blame] | 1165 | kfifo_in(&priv->event_fifo, (unsigned char *) &event, sizeof(u32)); |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 1166 | |
| 1167 | wake_up_interruptible(&priv->waitq); |
| 1168 | |
| 1169 | spin_unlock_irqrestore(&priv->driver_lock, flags); |
| 1170 | lbs_deb_leave(LBS_DEB_THREAD); |
| 1171 | } |
| 1172 | EXPORT_SYMBOL_GPL(lbs_queue_event); |
| 1173 | |
| 1174 | void lbs_notify_command_response(struct lbs_private *priv, u8 resp_idx) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1175 | { |
Holger Schurig | ed37b51 | 2007-05-25 11:52:42 -0400 | [diff] [blame] | 1176 | lbs_deb_enter(LBS_DEB_THREAD); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1177 | |
David Woodhouse | 4f67949 | 2007-12-10 14:58:37 -0500 | [diff] [blame] | 1178 | if (priv->psstate == PS_STATE_SLEEP) |
David Woodhouse | aa21c00 | 2007-12-08 20:04:36 +0000 | [diff] [blame] | 1179 | priv->psstate = PS_STATE_AWAKE; |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 1180 | |
| 1181 | /* Swap buffers by flipping the response index */ |
| 1182 | BUG_ON(resp_idx > 1); |
| 1183 | priv->resp_idx = resp_idx; |
| 1184 | |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 1185 | wake_up_interruptible(&priv->waitq); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1186 | |
Holger Schurig | ed37b51 | 2007-05-25 11:52:42 -0400 | [diff] [blame] | 1187 | lbs_deb_leave(LBS_DEB_THREAD); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1188 | } |
Holger Schurig | 7919b89 | 2008-04-01 14:50:43 +0200 | [diff] [blame] | 1189 | EXPORT_SYMBOL_GPL(lbs_notify_command_response); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1190 | |
Andres Salomon | 4fb910f | 2007-11-20 17:43:45 -0500 | [diff] [blame] | 1191 | static int __init lbs_init_module(void) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1192 | { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1193 | lbs_deb_enter(LBS_DEB_MAIN); |
Holger Schurig | f539f2e | 2008-03-26 13:22:11 +0100 | [diff] [blame] | 1194 | memset(&confirm_sleep, 0, sizeof(confirm_sleep)); |
| 1195 | confirm_sleep.hdr.command = cpu_to_le16(CMD_802_11_PS_MODE); |
| 1196 | confirm_sleep.hdr.size = cpu_to_le16(sizeof(confirm_sleep)); |
| 1197 | confirm_sleep.action = cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED); |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1198 | lbs_debugfs_init(); |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1199 | lbs_deb_leave(LBS_DEB_MAIN); |
| 1200 | return 0; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1201 | } |
| 1202 | |
Andres Salomon | 4fb910f | 2007-11-20 17:43:45 -0500 | [diff] [blame] | 1203 | static void __exit lbs_exit_module(void) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1204 | { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1205 | lbs_deb_enter(LBS_DEB_MAIN); |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1206 | lbs_debugfs_remove(); |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1207 | lbs_deb_leave(LBS_DEB_MAIN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1208 | } |
| 1209 | |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1210 | /* |
| 1211 | * rtap interface support fuctions |
| 1212 | */ |
| 1213 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1214 | static int lbs_rtap_open(struct net_device *dev) |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1215 | { |
David Woodhouse | 8552855f | 2007-12-10 16:38:18 -0500 | [diff] [blame] | 1216 | /* Yes, _stop_ the queue. Because we don't support injection */ |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 1217 | lbs_deb_enter(LBS_DEB_MAIN); |
| 1218 | netif_carrier_off(dev); |
| 1219 | netif_stop_queue(dev); |
| 1220 | lbs_deb_leave(LBS_DEB_LEAVE); |
| 1221 | return 0; |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1222 | } |
| 1223 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1224 | static int lbs_rtap_stop(struct net_device *dev) |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1225 | { |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 1226 | lbs_deb_enter(LBS_DEB_MAIN); |
| 1227 | lbs_deb_leave(LBS_DEB_MAIN); |
| 1228 | return 0; |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1229 | } |
| 1230 | |
Stephen Hemminger | d0cf9c0 | 2009-08-31 19:50:57 +0000 | [diff] [blame] | 1231 | static netdev_tx_t lbs_rtap_hard_start_xmit(struct sk_buff *skb, |
| 1232 | struct net_device *dev) |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1233 | { |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 1234 | netif_stop_queue(dev); |
| 1235 | return NETDEV_TX_BUSY; |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1236 | } |
| 1237 | |
David Woodhouse | 2fd6cfe | 2007-12-11 17:44:10 -0500 | [diff] [blame] | 1238 | static void lbs_remove_rtap(struct lbs_private *priv) |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1239 | { |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 1240 | lbs_deb_enter(LBS_DEB_MAIN); |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1241 | if (priv->rtap_net_dev == NULL) |
Holger Schurig | 5f505d9 | 2008-04-30 10:50:07 +0200 | [diff] [blame] | 1242 | goto out; |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1243 | unregister_netdev(priv->rtap_net_dev); |
David Woodhouse | d9268fb | 2007-12-09 16:22:21 -0500 | [diff] [blame] | 1244 | free_netdev(priv->rtap_net_dev); |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1245 | priv->rtap_net_dev = NULL; |
Holger Schurig | 5f505d9 | 2008-04-30 10:50:07 +0200 | [diff] [blame] | 1246 | out: |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 1247 | lbs_deb_leave(LBS_DEB_MAIN); |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1248 | } |
| 1249 | |
Stephen Hemminger | f02abf1 | 2009-03-20 19:36:37 +0000 | [diff] [blame] | 1250 | static const struct net_device_ops rtap_netdev_ops = { |
| 1251 | .ndo_open = lbs_rtap_open, |
| 1252 | .ndo_stop = lbs_rtap_stop, |
| 1253 | .ndo_start_xmit = lbs_rtap_hard_start_xmit, |
| 1254 | }; |
| 1255 | |
David Woodhouse | 2fd6cfe | 2007-12-11 17:44:10 -0500 | [diff] [blame] | 1256 | static int lbs_add_rtap(struct lbs_private *priv) |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1257 | { |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 1258 | int ret = 0; |
David Woodhouse | d9268fb | 2007-12-09 16:22:21 -0500 | [diff] [blame] | 1259 | struct net_device *rtap_dev; |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1260 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 1261 | lbs_deb_enter(LBS_DEB_MAIN); |
| 1262 | if (priv->rtap_net_dev) { |
| 1263 | ret = -EPERM; |
| 1264 | goto out; |
| 1265 | } |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1266 | |
David Woodhouse | d9268fb | 2007-12-09 16:22:21 -0500 | [diff] [blame] | 1267 | rtap_dev = alloc_netdev(0, "rtap%d", ether_setup); |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 1268 | if (rtap_dev == NULL) { |
| 1269 | ret = -ENOMEM; |
| 1270 | goto out; |
| 1271 | } |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1272 | |
David Woodhouse | 121947c | 2007-12-09 19:54:11 -0500 | [diff] [blame] | 1273 | memcpy(rtap_dev->dev_addr, priv->current_addr, ETH_ALEN); |
David Woodhouse | d9268fb | 2007-12-09 16:22:21 -0500 | [diff] [blame] | 1274 | rtap_dev->type = ARPHRD_IEEE80211_RADIOTAP; |
Stephen Hemminger | f02abf1 | 2009-03-20 19:36:37 +0000 | [diff] [blame] | 1275 | rtap_dev->netdev_ops = &rtap_netdev_ops; |
Wang Chen | 4ceb7b6 | 2008-09-05 11:28:47 +0800 | [diff] [blame] | 1276 | rtap_dev->ml_priv = priv; |
Masakazu Mokuno | 229ce3a | 2008-05-14 14:16:50 +0900 | [diff] [blame] | 1277 | SET_NETDEV_DEV(rtap_dev, priv->dev->dev.parent); |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1278 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 1279 | ret = register_netdev(rtap_dev); |
| 1280 | if (ret) { |
David Woodhouse | d9268fb | 2007-12-09 16:22:21 -0500 | [diff] [blame] | 1281 | free_netdev(rtap_dev); |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 1282 | goto out; |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1283 | } |
David Woodhouse | d9268fb | 2007-12-09 16:22:21 -0500 | [diff] [blame] | 1284 | priv->rtap_net_dev = rtap_dev; |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1285 | |
Holger Schurig | 61d3002 | 2008-01-16 15:59:52 +0100 | [diff] [blame] | 1286 | out: |
| 1287 | lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); |
| 1288 | return ret; |
Luis Carlos Cobo | 965f8bbc | 2007-08-02 13:16:55 -0400 | [diff] [blame] | 1289 | } |
| 1290 | |
Holger Schurig | 1007832 | 2007-11-15 18:05:47 -0500 | [diff] [blame] | 1291 | module_init(lbs_init_module); |
| 1292 | module_exit(lbs_exit_module); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1293 | |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1294 | MODULE_DESCRIPTION("Libertas WLAN Driver Library"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1295 | MODULE_AUTHOR("Marvell International Ltd."); |
| 1296 | MODULE_LICENSE("GPL"); |