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> |
| 9 | #include <linux/freezer.h> |
| 10 | #include <linux/etherdevice.h> |
| 11 | #include <linux/netdevice.h> |
| 12 | #include <linux/if_arp.h> |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 13 | #include <linux/kthread.h> |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 14 | |
| 15 | #include <net/iw_handler.h> |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 16 | #include <net/ieee80211.h> |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 17 | |
| 18 | #include "host.h" |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 19 | #include "decl.h" |
| 20 | #include "dev.h" |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 21 | #include "wext.h" |
| 22 | #include "debugfs.h" |
| 23 | #include "assoc.h" |
| 24 | |
Dan Williams | 125dcab | 2007-08-02 11:34:47 -0400 | [diff] [blame] | 25 | #define DRIVER_RELEASE_VERSION "322.p1" |
Dan Williams | 3ce4023 | 2007-05-10 23:03:07 -0400 | [diff] [blame] | 26 | const char libertas_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION |
| 27 | #ifdef DEBUG |
| 28 | "-dbg" |
| 29 | #endif |
| 30 | ""; |
| 31 | |
Holger Schurig | a46c641 | 2007-05-25 11:32:07 -0400 | [diff] [blame] | 32 | |
| 33 | /* Module parameters */ |
| 34 | unsigned int libertas_debug = 0; |
| 35 | module_param(libertas_debug, int, 0644); |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 36 | EXPORT_SYMBOL_GPL(libertas_debug); |
Holger Schurig | a46c641 | 2007-05-25 11:32:07 -0400 | [diff] [blame] | 37 | |
| 38 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 39 | #define WLAN_TX_PWR_DEFAULT 20 /*100mW */ |
| 40 | #define WLAN_TX_PWR_US_DEFAULT 20 /*100mW */ |
| 41 | #define WLAN_TX_PWR_JP_DEFAULT 16 /*50mW */ |
| 42 | #define WLAN_TX_PWR_FR_DEFAULT 20 /*100mW */ |
| 43 | #define WLAN_TX_PWR_EMEA_DEFAULT 20 /*100mW */ |
| 44 | |
| 45 | /* Format { channel, frequency (MHz), maxtxpower } */ |
| 46 | /* band: 'B/G', region: USA FCC/Canada IC */ |
| 47 | static struct chan_freq_power channel_freq_power_US_BG[] = { |
| 48 | {1, 2412, WLAN_TX_PWR_US_DEFAULT}, |
| 49 | {2, 2417, WLAN_TX_PWR_US_DEFAULT}, |
| 50 | {3, 2422, WLAN_TX_PWR_US_DEFAULT}, |
| 51 | {4, 2427, WLAN_TX_PWR_US_DEFAULT}, |
| 52 | {5, 2432, WLAN_TX_PWR_US_DEFAULT}, |
| 53 | {6, 2437, WLAN_TX_PWR_US_DEFAULT}, |
| 54 | {7, 2442, WLAN_TX_PWR_US_DEFAULT}, |
| 55 | {8, 2447, WLAN_TX_PWR_US_DEFAULT}, |
| 56 | {9, 2452, WLAN_TX_PWR_US_DEFAULT}, |
| 57 | {10, 2457, WLAN_TX_PWR_US_DEFAULT}, |
| 58 | {11, 2462, WLAN_TX_PWR_US_DEFAULT} |
| 59 | }; |
| 60 | |
| 61 | /* band: 'B/G', region: Europe ETSI */ |
| 62 | static struct chan_freq_power channel_freq_power_EU_BG[] = { |
| 63 | {1, 2412, WLAN_TX_PWR_EMEA_DEFAULT}, |
| 64 | {2, 2417, WLAN_TX_PWR_EMEA_DEFAULT}, |
| 65 | {3, 2422, WLAN_TX_PWR_EMEA_DEFAULT}, |
| 66 | {4, 2427, WLAN_TX_PWR_EMEA_DEFAULT}, |
| 67 | {5, 2432, WLAN_TX_PWR_EMEA_DEFAULT}, |
| 68 | {6, 2437, WLAN_TX_PWR_EMEA_DEFAULT}, |
| 69 | {7, 2442, WLAN_TX_PWR_EMEA_DEFAULT}, |
| 70 | {8, 2447, WLAN_TX_PWR_EMEA_DEFAULT}, |
| 71 | {9, 2452, WLAN_TX_PWR_EMEA_DEFAULT}, |
| 72 | {10, 2457, WLAN_TX_PWR_EMEA_DEFAULT}, |
| 73 | {11, 2462, WLAN_TX_PWR_EMEA_DEFAULT}, |
| 74 | {12, 2467, WLAN_TX_PWR_EMEA_DEFAULT}, |
| 75 | {13, 2472, WLAN_TX_PWR_EMEA_DEFAULT} |
| 76 | }; |
| 77 | |
| 78 | /* band: 'B/G', region: Spain */ |
| 79 | static struct chan_freq_power channel_freq_power_SPN_BG[] = { |
| 80 | {10, 2457, WLAN_TX_PWR_DEFAULT}, |
| 81 | {11, 2462, WLAN_TX_PWR_DEFAULT} |
| 82 | }; |
| 83 | |
| 84 | /* band: 'B/G', region: France */ |
| 85 | static struct chan_freq_power channel_freq_power_FR_BG[] = { |
| 86 | {10, 2457, WLAN_TX_PWR_FR_DEFAULT}, |
| 87 | {11, 2462, WLAN_TX_PWR_FR_DEFAULT}, |
| 88 | {12, 2467, WLAN_TX_PWR_FR_DEFAULT}, |
| 89 | {13, 2472, WLAN_TX_PWR_FR_DEFAULT} |
| 90 | }; |
| 91 | |
| 92 | /* band: 'B/G', region: Japan */ |
| 93 | static struct chan_freq_power channel_freq_power_JPN_BG[] = { |
| 94 | {1, 2412, WLAN_TX_PWR_JP_DEFAULT}, |
| 95 | {2, 2417, WLAN_TX_PWR_JP_DEFAULT}, |
| 96 | {3, 2422, WLAN_TX_PWR_JP_DEFAULT}, |
| 97 | {4, 2427, WLAN_TX_PWR_JP_DEFAULT}, |
| 98 | {5, 2432, WLAN_TX_PWR_JP_DEFAULT}, |
| 99 | {6, 2437, WLAN_TX_PWR_JP_DEFAULT}, |
| 100 | {7, 2442, WLAN_TX_PWR_JP_DEFAULT}, |
| 101 | {8, 2447, WLAN_TX_PWR_JP_DEFAULT}, |
| 102 | {9, 2452, WLAN_TX_PWR_JP_DEFAULT}, |
| 103 | {10, 2457, WLAN_TX_PWR_JP_DEFAULT}, |
| 104 | {11, 2462, WLAN_TX_PWR_JP_DEFAULT}, |
| 105 | {12, 2467, WLAN_TX_PWR_JP_DEFAULT}, |
| 106 | {13, 2472, WLAN_TX_PWR_JP_DEFAULT}, |
| 107 | {14, 2484, WLAN_TX_PWR_JP_DEFAULT} |
| 108 | }; |
| 109 | |
| 110 | /** |
| 111 | * the structure for channel, frequency and power |
| 112 | */ |
| 113 | struct region_cfp_table { |
| 114 | u8 region; |
| 115 | struct chan_freq_power *cfp_BG; |
| 116 | int cfp_no_BG; |
| 117 | }; |
| 118 | |
| 119 | /** |
| 120 | * the structure for the mapping between region and CFP |
| 121 | */ |
| 122 | static struct region_cfp_table region_cfp_table[] = { |
| 123 | {0x10, /*US FCC */ |
| 124 | channel_freq_power_US_BG, |
| 125 | sizeof(channel_freq_power_US_BG) / sizeof(struct chan_freq_power), |
| 126 | } |
| 127 | , |
| 128 | {0x20, /*CANADA IC */ |
| 129 | channel_freq_power_US_BG, |
| 130 | sizeof(channel_freq_power_US_BG) / sizeof(struct chan_freq_power), |
| 131 | } |
| 132 | , |
| 133 | {0x30, /*EU*/ channel_freq_power_EU_BG, |
| 134 | sizeof(channel_freq_power_EU_BG) / sizeof(struct chan_freq_power), |
| 135 | } |
| 136 | , |
| 137 | {0x31, /*SPAIN*/ channel_freq_power_SPN_BG, |
| 138 | sizeof(channel_freq_power_SPN_BG) / sizeof(struct chan_freq_power), |
| 139 | } |
| 140 | , |
| 141 | {0x32, /*FRANCE*/ channel_freq_power_FR_BG, |
| 142 | sizeof(channel_freq_power_FR_BG) / sizeof(struct chan_freq_power), |
| 143 | } |
| 144 | , |
| 145 | {0x40, /*JAPAN*/ channel_freq_power_JPN_BG, |
| 146 | sizeof(channel_freq_power_JPN_BG) / sizeof(struct chan_freq_power), |
| 147 | } |
| 148 | , |
| 149 | /*Add new region here */ |
| 150 | }; |
| 151 | |
| 152 | /** |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 153 | * the rates supported |
| 154 | */ |
| 155 | u8 libertas_supported_rates[G_SUPPORTED_RATES] = |
| 156 | { 0x82, 0x84, 0x8b, 0x96, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6c, |
| 157 | 0 }; |
| 158 | |
| 159 | /** |
| 160 | * the rates supported for ad-hoc G mode |
| 161 | */ |
| 162 | u8 libertas_adhoc_rates_g[G_SUPPORTED_RATES] = |
| 163 | { 0x82, 0x84, 0x8b, 0x96, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6c, |
| 164 | 0 }; |
| 165 | |
| 166 | /** |
| 167 | * the rates supported for ad-hoc B mode |
| 168 | */ |
| 169 | u8 libertas_adhoc_rates_b[4] = { 0x82, 0x84, 0x8b, 0x96 }; |
| 170 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 171 | /** |
| 172 | * the table to keep region code |
| 173 | */ |
| 174 | u16 libertas_region_code_to_index[MRVDRV_MAX_REGION_CODE] = |
| 175 | { 0x10, 0x20, 0x30, 0x31, 0x32, 0x40 }; |
| 176 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 177 | /** |
| 178 | * Attributes exported through sysfs |
| 179 | */ |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 180 | |
| 181 | /** |
Luis Carlos | 82fde74 | 2007-06-07 16:40:59 -0400 | [diff] [blame] | 182 | * @brief Get function for sysfs attribute anycast_mask |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 183 | */ |
Luis Carlos | 82fde74 | 2007-06-07 16:40:59 -0400 | [diff] [blame] | 184 | static ssize_t libertas_anycast_get(struct device * dev, |
Dan Williams | b59bb61 | 2007-06-18 11:50:43 -0400 | [diff] [blame] | 185 | struct device_attribute *attr, char * buf) |
| 186 | { |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 187 | struct cmd_ds_mesh_access mesh_access; |
| 188 | |
| 189 | memset(&mesh_access, 0, sizeof(mesh_access)); |
| 190 | libertas_prepare_and_send_command(to_net_dev(dev)->priv, |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 191 | CMD_MESH_ACCESS, |
| 192 | CMD_ACT_MESH_GET_ANYCAST, |
| 193 | CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 194 | |
Luis Carlos | 82fde74 | 2007-06-07 16:40:59 -0400 | [diff] [blame] | 195 | return snprintf(buf, 12, "0x%X\n", le32_to_cpu(mesh_access.data[0])); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 196 | } |
| 197 | |
| 198 | /** |
Luis Carlos | 82fde74 | 2007-06-07 16:40:59 -0400 | [diff] [blame] | 199 | * @brief Set function for sysfs attribute anycast_mask |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 200 | */ |
Luis Carlos | 82fde74 | 2007-06-07 16:40:59 -0400 | [diff] [blame] | 201 | static ssize_t libertas_anycast_set(struct device * dev, |
Dan Williams | b59bb61 | 2007-06-18 11:50:43 -0400 | [diff] [blame] | 202 | struct device_attribute *attr, const char * buf, size_t count) |
| 203 | { |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 204 | struct cmd_ds_mesh_access mesh_access; |
David Woodhouse | 981f187 | 2007-05-25 23:36:54 -0400 | [diff] [blame] | 205 | uint32_t datum; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 206 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 207 | memset(&mesh_access, 0, sizeof(mesh_access)); |
Luis Carlos | 82fde74 | 2007-06-07 16:40:59 -0400 | [diff] [blame] | 208 | sscanf(buf, "%x", &datum); |
David Woodhouse | 981f187 | 2007-05-25 23:36:54 -0400 | [diff] [blame] | 209 | mesh_access.data[0] = cpu_to_le32(datum); |
| 210 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 211 | libertas_prepare_and_send_command((to_net_dev(dev))->priv, |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 212 | CMD_MESH_ACCESS, |
| 213 | CMD_ACT_MESH_SET_ANYCAST, |
| 214 | CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 215 | return strlen(buf); |
| 216 | } |
| 217 | |
| 218 | /** |
Luis Carlos | 82fde74 | 2007-06-07 16:40:59 -0400 | [diff] [blame] | 219 | * anycast_mask attribute to be exported per mshX interface |
| 220 | * through sysfs (/sys/class/net/mshX/anycast_mask) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 221 | */ |
Luis Carlos | 82fde74 | 2007-06-07 16:40:59 -0400 | [diff] [blame] | 222 | static DEVICE_ATTR(anycast_mask, 0644, libertas_anycast_get, libertas_anycast_set); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 223 | |
| 224 | /** |
| 225 | * @brief Check if the device can be open and wait if necessary. |
| 226 | * |
| 227 | * @param dev A pointer to net_device structure |
| 228 | * @return 0 |
| 229 | * |
| 230 | * For USB adapter, on some systems the device open handler will be |
| 231 | * called before FW ready. Use the following flag check and wait |
| 232 | * function to work around the issue. |
| 233 | * |
| 234 | */ |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 235 | static int pre_open_check(struct net_device *dev) |
| 236 | { |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 237 | wlan_private *priv = (wlan_private *) dev->priv; |
| 238 | wlan_adapter *adapter = priv->adapter; |
| 239 | int i = 0; |
| 240 | |
| 241 | while (!adapter->fw_ready && i < 20) { |
| 242 | i++; |
| 243 | msleep_interruptible(100); |
| 244 | } |
| 245 | if (!adapter->fw_ready) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 246 | lbs_pr_err("firmware not ready\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 247 | return -1; |
| 248 | } |
| 249 | |
| 250 | return 0; |
| 251 | } |
| 252 | |
| 253 | /** |
| 254 | * @brief This function opens the device |
| 255 | * |
| 256 | * @param dev A pointer to net_device structure |
| 257 | * @return 0 |
| 258 | */ |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 259 | static int libertas_dev_open(struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 260 | { |
| 261 | wlan_private *priv = (wlan_private *) dev->priv; |
| 262 | wlan_adapter *adapter = priv->adapter; |
| 263 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 264 | lbs_deb_enter(LBS_DEB_NET); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 265 | |
| 266 | priv->open = 1; |
| 267 | |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 268 | if (adapter->connect_status == LIBERTAS_CONNECTED) { |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 269 | netif_carrier_on(priv->dev); |
Javier Cardona | 51d84f5 | 2007-05-25 12:06:56 -0400 | [diff] [blame] | 270 | netif_carrier_on(priv->mesh_dev); |
| 271 | } else { |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 272 | netif_carrier_off(priv->dev); |
Javier Cardona | 51d84f5 | 2007-05-25 12:06:56 -0400 | [diff] [blame] | 273 | netif_carrier_off(priv->mesh_dev); |
| 274 | } |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 275 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 276 | lbs_deb_leave(LBS_DEB_NET); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 277 | return 0; |
| 278 | } |
| 279 | /** |
| 280 | * @brief This function opens the mshX interface |
| 281 | * |
| 282 | * @param dev A pointer to net_device structure |
| 283 | * @return 0 |
| 284 | */ |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 285 | static int libertas_mesh_open(struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 286 | { |
| 287 | wlan_private *priv = (wlan_private *) dev->priv ; |
| 288 | |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 289 | if (pre_open_check(dev) == -1) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 290 | return -1; |
| 291 | priv->mesh_open = 1 ; |
Javier Cardona | 51d84f5 | 2007-05-25 12:06:56 -0400 | [diff] [blame] | 292 | netif_wake_queue(priv->mesh_dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 293 | if (priv->infra_open == 0) |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 294 | return libertas_dev_open(priv->dev) ; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 295 | return 0; |
| 296 | } |
| 297 | |
| 298 | /** |
| 299 | * @brief This function opens the ethX interface |
| 300 | * |
| 301 | * @param dev A pointer to net_device structure |
| 302 | * @return 0 |
| 303 | */ |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 304 | static int libertas_open(struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 305 | { |
| 306 | wlan_private *priv = (wlan_private *) dev->priv ; |
| 307 | |
| 308 | if(pre_open_check(dev) == -1) |
| 309 | return -1; |
| 310 | priv->infra_open = 1 ; |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 311 | netif_wake_queue(priv->dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 312 | if (priv->open == 0) |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 313 | return libertas_dev_open(priv->dev) ; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 314 | return 0; |
| 315 | } |
| 316 | |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 317 | static int libertas_dev_close(struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 318 | { |
| 319 | wlan_private *priv = dev->priv; |
| 320 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 321 | lbs_deb_enter(LBS_DEB_NET); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 322 | |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 323 | netif_carrier_off(priv->dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 324 | priv->open = 0; |
| 325 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 326 | lbs_deb_leave(LBS_DEB_NET); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 327 | return 0; |
| 328 | } |
| 329 | |
| 330 | /** |
| 331 | * @brief This function closes the mshX interface |
| 332 | * |
| 333 | * @param dev A pointer to net_device structure |
| 334 | * @return 0 |
| 335 | */ |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 336 | static int libertas_mesh_close(struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 337 | { |
| 338 | wlan_private *priv = (wlan_private *) (dev->priv); |
| 339 | |
| 340 | priv->mesh_open = 0; |
| 341 | netif_stop_queue(priv->mesh_dev); |
| 342 | if (priv->infra_open == 0) |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 343 | return libertas_dev_close(dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 344 | else |
| 345 | return 0; |
| 346 | } |
| 347 | |
| 348 | /** |
| 349 | * @brief This function closes the ethX interface |
| 350 | * |
| 351 | * @param dev A pointer to net_device structure |
| 352 | * @return 0 |
| 353 | */ |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 354 | static int libertas_close(struct net_device *dev) |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 355 | { |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 356 | wlan_private *priv = (wlan_private *) dev->priv; |
| 357 | |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 358 | netif_stop_queue(dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 359 | priv->infra_open = 0; |
| 360 | if (priv->mesh_open == 0) |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 361 | return libertas_dev_close(dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 362 | else |
| 363 | return 0; |
| 364 | } |
| 365 | |
| 366 | |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 367 | static int libertas_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 368 | { |
| 369 | int ret = 0; |
| 370 | wlan_private *priv = dev->priv; |
| 371 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 372 | lbs_deb_enter(LBS_DEB_NET); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 373 | |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 374 | if (priv->dnld_sent || priv->adapter->TxLockFlag) { |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 375 | priv->stats.tx_dropped++; |
| 376 | goto done; |
| 377 | } |
| 378 | |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 379 | netif_stop_queue(priv->dev); |
Javier Cardona | 51d84f5 | 2007-05-25 12:06:56 -0400 | [diff] [blame] | 380 | netif_stop_queue(priv->mesh_dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 381 | |
| 382 | if (libertas_process_tx(priv, skb) == 0) |
| 383 | dev->trans_start = jiffies; |
| 384 | done: |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 385 | lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 386 | return ret; |
| 387 | } |
| 388 | |
| 389 | /** |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 390 | * @brief Mark mesh packets and handover them to libertas_hard_start_xmit |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 391 | * |
| 392 | */ |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 393 | static int libertas_mesh_pre_start_xmit(struct sk_buff *skb, |
| 394 | struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 395 | { |
| 396 | wlan_private *priv = dev->priv; |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 397 | int ret; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 398 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 399 | lbs_deb_enter(LBS_DEB_MESH); |
| 400 | |
| 401 | SET_MESH_FRAME(skb); |
| 402 | |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 403 | ret = libertas_hard_start_xmit(skb, priv->dev); |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 404 | lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret); |
| 405 | return ret; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 406 | } |
| 407 | |
| 408 | /** |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 409 | * @brief Mark non-mesh packets and handover them to libertas_hard_start_xmit |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 410 | * |
| 411 | */ |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 412 | static int libertas_pre_start_xmit(struct sk_buff *skb, struct net_device *dev) |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 413 | { |
| 414 | int ret; |
| 415 | |
| 416 | lbs_deb_enter(LBS_DEB_NET); |
| 417 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 418 | UNSET_MESH_FRAME(skb); |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 419 | |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 420 | ret = libertas_hard_start_xmit(skb, dev); |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 421 | lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); |
| 422 | return ret; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 423 | } |
| 424 | |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 425 | static void libertas_tx_timeout(struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 426 | { |
| 427 | wlan_private *priv = (wlan_private *) dev->priv; |
| 428 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 429 | lbs_deb_enter(LBS_DEB_TX); |
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_pr_err("tx watch dog timeout\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 432 | |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 433 | priv->dnld_sent = DNLD_RES_RECEIVED; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 434 | dev->trans_start = jiffies; |
| 435 | |
| 436 | if (priv->adapter->currenttxskb) { |
| 437 | if (priv->adapter->radiomode == WLAN_RADIOMODE_RADIOTAP) { |
| 438 | /* If we are here, we have not received feedback from |
| 439 | the previous packet. Assume TX_FAIL and move on. */ |
| 440 | priv->adapter->eventcause = 0x01000000; |
| 441 | libertas_send_tx_feedback(priv); |
| 442 | } else |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 443 | wake_up_interruptible(&priv->waitq); |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 444 | } else if (priv->adapter->connect_status == LIBERTAS_CONNECTED) { |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 445 | netif_wake_queue(priv->dev); |
Javier Cardona | 51d84f5 | 2007-05-25 12:06:56 -0400 | [diff] [blame] | 446 | netif_wake_queue(priv->mesh_dev); |
| 447 | } |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 448 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 449 | lbs_deb_leave(LBS_DEB_TX); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 450 | } |
| 451 | |
| 452 | /** |
| 453 | * @brief This function returns the network statistics |
| 454 | * |
| 455 | * @param dev A pointer to wlan_private structure |
| 456 | * @return A pointer to net_device_stats structure |
| 457 | */ |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 458 | static struct net_device_stats *libertas_get_stats(struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 459 | { |
| 460 | wlan_private *priv = (wlan_private *) dev->priv; |
| 461 | |
| 462 | return &priv->stats; |
| 463 | } |
| 464 | |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 465 | static int libertas_set_mac_address(struct net_device *dev, void *addr) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 466 | { |
| 467 | int ret = 0; |
| 468 | wlan_private *priv = (wlan_private *) dev->priv; |
| 469 | wlan_adapter *adapter = priv->adapter; |
| 470 | struct sockaddr *phwaddr = addr; |
| 471 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 472 | lbs_deb_enter(LBS_DEB_NET); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 473 | |
Luis Carlos Cobo Rus | 0a0d08a | 2007-05-25 23:05:27 -0400 | [diff] [blame] | 474 | /* In case it was called from the mesh device */ |
| 475 | dev = priv->dev ; |
| 476 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 477 | memset(adapter->current_addr, 0, ETH_ALEN); |
| 478 | |
| 479 | /* dev->dev_addr is 8 bytes */ |
| 480 | lbs_dbg_hex("dev->dev_addr:", dev->dev_addr, ETH_ALEN); |
| 481 | |
| 482 | lbs_dbg_hex("addr:", phwaddr->sa_data, ETH_ALEN); |
| 483 | memcpy(adapter->current_addr, phwaddr->sa_data, ETH_ALEN); |
| 484 | |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 485 | ret = libertas_prepare_and_send_command(priv, CMD_802_11_MAC_ADDRESS, |
| 486 | CMD_ACT_SET, |
| 487 | CMD_OPTION_WAITFORRSP, 0, NULL); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 488 | |
| 489 | if (ret) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 490 | lbs_deb_net("set MAC address failed\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 491 | ret = -1; |
| 492 | goto done; |
| 493 | } |
| 494 | |
| 495 | lbs_dbg_hex("adapter->macaddr:", adapter->current_addr, ETH_ALEN); |
| 496 | memcpy(dev->dev_addr, adapter->current_addr, ETH_ALEN); |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 497 | if (priv->mesh_dev) |
| 498 | memcpy(priv->mesh_dev->dev_addr, adapter->current_addr, ETH_ALEN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 499 | |
| 500 | done: |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 501 | lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 502 | return ret; |
| 503 | } |
| 504 | |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 505 | static int libertas_copy_multicast_address(wlan_adapter * adapter, |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 506 | struct net_device *dev) |
| 507 | { |
| 508 | int i = 0; |
| 509 | struct dev_mc_list *mcptr = dev->mc_list; |
| 510 | |
| 511 | for (i = 0; i < dev->mc_count; i++) { |
| 512 | memcpy(&adapter->multicastlist[i], mcptr->dmi_addr, ETH_ALEN); |
| 513 | mcptr = mcptr->next; |
| 514 | } |
| 515 | |
| 516 | return i; |
| 517 | |
| 518 | } |
| 519 | |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 520 | static void libertas_set_multicast_list(struct net_device *dev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 521 | { |
| 522 | wlan_private *priv = dev->priv; |
| 523 | wlan_adapter *adapter = priv->adapter; |
| 524 | int oldpacketfilter; |
| 525 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 526 | lbs_deb_enter(LBS_DEB_NET); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 527 | |
| 528 | oldpacketfilter = adapter->currentpacketfilter; |
| 529 | |
| 530 | if (dev->flags & IFF_PROMISC) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 531 | lbs_deb_net("enable promiscuous mode\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 532 | adapter->currentpacketfilter |= |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 533 | CMD_ACT_MAC_PROMISCUOUS_ENABLE; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 534 | adapter->currentpacketfilter &= |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 535 | ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE | |
| 536 | CMD_ACT_MAC_MULTICAST_ENABLE); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 537 | } else { |
| 538 | /* Multicast */ |
| 539 | adapter->currentpacketfilter &= |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 540 | ~CMD_ACT_MAC_PROMISCUOUS_ENABLE; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 541 | |
| 542 | if (dev->flags & IFF_ALLMULTI || dev->mc_count > |
| 543 | MRVDRV_MAX_MULTICAST_LIST_SIZE) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 544 | lbs_deb_net( "enabling all multicast\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 545 | adapter->currentpacketfilter |= |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 546 | CMD_ACT_MAC_ALL_MULTICAST_ENABLE; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 547 | adapter->currentpacketfilter &= |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 548 | ~CMD_ACT_MAC_MULTICAST_ENABLE; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 549 | } else { |
| 550 | adapter->currentpacketfilter &= |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 551 | ~CMD_ACT_MAC_ALL_MULTICAST_ENABLE; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 552 | |
| 553 | if (!dev->mc_count) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 554 | lbs_deb_net("no multicast addresses, " |
| 555 | "disabling multicast\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 556 | adapter->currentpacketfilter &= |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 557 | ~CMD_ACT_MAC_MULTICAST_ENABLE; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 558 | } else { |
| 559 | int i; |
| 560 | |
| 561 | adapter->currentpacketfilter |= |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 562 | CMD_ACT_MAC_MULTICAST_ENABLE; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 563 | |
| 564 | adapter->nr_of_multicastmacaddr = |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 565 | libertas_copy_multicast_address(adapter, dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 566 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 567 | lbs_deb_net("multicast addresses: %d\n", |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 568 | dev->mc_count); |
| 569 | |
| 570 | for (i = 0; i < dev->mc_count; i++) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 571 | lbs_deb_net("Multicast address %d:" |
| 572 | MAC_FMT "\n", i, |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 573 | adapter->multicastlist[i][0], |
| 574 | adapter->multicastlist[i][1], |
| 575 | adapter->multicastlist[i][2], |
| 576 | adapter->multicastlist[i][3], |
| 577 | adapter->multicastlist[i][4], |
| 578 | adapter->multicastlist[i][5]); |
| 579 | } |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 580 | /* send multicast addresses to firmware */ |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 581 | libertas_prepare_and_send_command(priv, |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 582 | CMD_MAC_MULTICAST_ADR, |
| 583 | CMD_ACT_SET, 0, 0, |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 584 | NULL); |
| 585 | } |
| 586 | } |
| 587 | } |
| 588 | |
| 589 | if (adapter->currentpacketfilter != oldpacketfilter) { |
| 590 | libertas_set_mac_packet_filter(priv); |
| 591 | } |
| 592 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 593 | lbs_deb_leave(LBS_DEB_NET); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 594 | } |
| 595 | |
| 596 | /** |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 597 | * @brief This function handles the major jobs in the WLAN driver. |
| 598 | * It handles all events generated by firmware, RX data received |
| 599 | * from firmware and TX data sent from kernel. |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 600 | * |
| 601 | * @param data A pointer to wlan_thread structure |
| 602 | * @return 0 |
| 603 | */ |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 604 | static int libertas_thread(void *data) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 605 | { |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 606 | struct net_device *dev = data; |
| 607 | wlan_private *priv = dev->priv; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 608 | wlan_adapter *adapter = priv->adapter; |
| 609 | wait_queue_t wait; |
| 610 | u8 ireg = 0; |
| 611 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 612 | lbs_deb_enter(LBS_DEB_THREAD); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 613 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 614 | init_waitqueue_entry(&wait, current); |
| 615 | |
| 616 | for (;;) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 617 | lbs_deb_thread( "main-thread 111: intcounter=%d " |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 618 | "currenttxskb=%p dnld_sent=%d\n", |
| 619 | adapter->intcounter, |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 620 | adapter->currenttxskb, priv->dnld_sent); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 621 | |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 622 | add_wait_queue(&priv->waitq, &wait); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 623 | set_current_state(TASK_INTERRUPTIBLE); |
| 624 | spin_lock_irq(&adapter->driver_lock); |
| 625 | if ((adapter->psstate == PS_STATE_SLEEP) || |
| 626 | (!adapter->intcounter |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 627 | && (priv->dnld_sent || adapter->cur_cmd || |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 628 | list_empty(&adapter->cmdpendingq)))) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 629 | lbs_deb_thread( |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 630 | "main-thread sleeping... Conn=%d IntC=%d PS_mode=%d PS_State=%d\n", |
| 631 | adapter->connect_status, adapter->intcounter, |
| 632 | adapter->psmode, adapter->psstate); |
| 633 | spin_unlock_irq(&adapter->driver_lock); |
| 634 | schedule(); |
| 635 | } else |
| 636 | spin_unlock_irq(&adapter->driver_lock); |
| 637 | |
| 638 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 639 | lbs_deb_thread( |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 640 | "main-thread 222 (waking up): intcounter=%d currenttxskb=%p " |
| 641 | "dnld_sent=%d\n", adapter->intcounter, |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 642 | adapter->currenttxskb, priv->dnld_sent); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 643 | |
| 644 | set_current_state(TASK_RUNNING); |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 645 | remove_wait_queue(&priv->waitq, &wait); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 646 | try_to_freeze(); |
| 647 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 648 | lbs_deb_thread("main-thread 333: intcounter=%d currenttxskb=%p " |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 649 | "dnld_sent=%d\n", |
| 650 | adapter->intcounter, |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 651 | adapter->currenttxskb, priv->dnld_sent); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 652 | |
| 653 | if (kthread_should_stop() |
| 654 | || adapter->surpriseremoved) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 655 | lbs_deb_thread( |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 656 | "main-thread: break from main thread: surpriseremoved=0x%x\n", |
| 657 | adapter->surpriseremoved); |
| 658 | break; |
| 659 | } |
| 660 | |
| 661 | |
| 662 | spin_lock_irq(&adapter->driver_lock); |
| 663 | if (adapter->intcounter) { |
| 664 | u8 int_status; |
| 665 | adapter->intcounter = 0; |
Holger Schurig | 208fdd2 | 2007-05-25 12:17:06 -0400 | [diff] [blame] | 666 | int_status = priv->hw_get_int_status(priv, &ireg); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 667 | |
| 668 | if (int_status) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 669 | lbs_deb_thread( |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 670 | "main-thread: reading HOST_INT_STATUS_REG failed\n"); |
| 671 | spin_unlock_irq(&adapter->driver_lock); |
| 672 | continue; |
| 673 | } |
| 674 | adapter->hisregcpy |= ireg; |
| 675 | } |
| 676 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 677 | lbs_deb_thread("main-thread 444: intcounter=%d currenttxskb=%p " |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 678 | "dnld_sent=%d\n", |
| 679 | adapter->intcounter, |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 680 | adapter->currenttxskb, priv->dnld_sent); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 681 | |
| 682 | /* command response? */ |
| 683 | if (adapter->hisregcpy & his_cmdupldrdy) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 684 | lbs_deb_thread("main-thread: cmd response ready\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 685 | |
| 686 | adapter->hisregcpy &= ~his_cmdupldrdy; |
| 687 | spin_unlock_irq(&adapter->driver_lock); |
| 688 | libertas_process_rx_command(priv); |
| 689 | spin_lock_irq(&adapter->driver_lock); |
| 690 | } |
| 691 | |
| 692 | /* Any Card Event */ |
| 693 | if (adapter->hisregcpy & his_cardevent) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 694 | lbs_deb_thread("main-thread: Card Event Activity\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 695 | |
| 696 | adapter->hisregcpy &= ~his_cardevent; |
| 697 | |
Holger Schurig | 208fdd2 | 2007-05-25 12:17:06 -0400 | [diff] [blame] | 698 | if (priv->hw_read_event_cause(priv)) { |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 699 | lbs_pr_alert( |
Holger Schurig | 208fdd2 | 2007-05-25 12:17:06 -0400 | [diff] [blame] | 700 | "main-thread: hw_read_event_cause failed\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 701 | spin_unlock_irq(&adapter->driver_lock); |
| 702 | continue; |
| 703 | } |
| 704 | spin_unlock_irq(&adapter->driver_lock); |
| 705 | libertas_process_event(priv); |
| 706 | } else |
| 707 | spin_unlock_irq(&adapter->driver_lock); |
| 708 | |
| 709 | /* Check if we need to confirm Sleep Request received previously */ |
| 710 | if (adapter->psstate == PS_STATE_PRE_SLEEP) { |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 711 | if (!priv->dnld_sent && !adapter->cur_cmd) { |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 712 | if (adapter->connect_status == |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 713 | LIBERTAS_CONNECTED) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 714 | lbs_deb_thread( |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 715 | "main_thread: PRE_SLEEP--intcounter=%d currenttxskb=%p " |
| 716 | "dnld_sent=%d cur_cmd=%p, confirm now\n", |
| 717 | adapter->intcounter, |
| 718 | adapter->currenttxskb, |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 719 | priv->dnld_sent, |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 720 | adapter->cur_cmd); |
| 721 | |
| 722 | libertas_ps_confirm_sleep(priv, |
| 723 | (u16) adapter->psmode); |
| 724 | } else { |
| 725 | /* workaround for firmware sending |
| 726 | * deauth/linkloss event immediately |
| 727 | * after sleep request, remove this |
| 728 | * after firmware fixes it |
| 729 | */ |
| 730 | adapter->psstate = PS_STATE_AWAKE; |
| 731 | lbs_pr_alert( |
| 732 | "main-thread: ignore PS_SleepConfirm in non-connected state\n"); |
| 733 | } |
| 734 | } |
| 735 | } |
| 736 | |
| 737 | /* The PS state is changed during processing of Sleep Request |
| 738 | * event above |
| 739 | */ |
| 740 | if ((priv->adapter->psstate == PS_STATE_SLEEP) || |
| 741 | (priv->adapter->psstate == PS_STATE_PRE_SLEEP)) |
| 742 | continue; |
| 743 | |
| 744 | /* Execute the next command */ |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 745 | if (!priv->dnld_sent && !priv->adapter->cur_cmd) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 746 | libertas_execute_next_command(priv); |
| 747 | |
| 748 | /* Wake-up command waiters which can't sleep in |
| 749 | * libertas_prepare_and_send_command |
| 750 | */ |
| 751 | if (!adapter->nr_cmd_pending) |
| 752 | wake_up_all(&adapter->cmd_pending); |
| 753 | |
| 754 | libertas_tx_runqueue(priv); |
| 755 | } |
| 756 | |
| 757 | del_timer(&adapter->command_timer); |
| 758 | adapter->nr_cmd_pending = 0; |
| 759 | wake_up_all(&adapter->cmd_pending); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 760 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 761 | lbs_deb_leave(LBS_DEB_THREAD); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 762 | return 0; |
| 763 | } |
| 764 | |
| 765 | /** |
| 766 | * @brief This function adds the card. it will probe the |
| 767 | * card, allocate the wlan_priv and initialize the device. |
| 768 | * |
| 769 | * @param card A pointer to card |
| 770 | * @return A pointer to wlan_private structure |
| 771 | */ |
Dan Williams | 7732ca4 | 2007-05-25 13:13:25 -0400 | [diff] [blame] | 772 | wlan_private *libertas_add_card(void *card, struct device *dmdev) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 773 | { |
| 774 | struct net_device *dev = NULL; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 775 | wlan_private *priv = NULL; |
| 776 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 777 | lbs_deb_enter(LBS_DEB_NET); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 778 | |
| 779 | /* Allocate an Ethernet device and register it */ |
| 780 | if (!(dev = alloc_etherdev(sizeof(wlan_private)))) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 781 | lbs_pr_err("init ethX device failed\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 782 | return NULL; |
| 783 | } |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 784 | priv = dev->priv; |
| 785 | |
| 786 | /* allocate buffer for wlan_adapter */ |
Holger Schurig | fb3dddf | 2007-05-25 11:58:22 -0400 | [diff] [blame] | 787 | if (!(priv->adapter = kzalloc(sizeof(wlan_adapter), GFP_KERNEL))) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 788 | lbs_pr_err("allocate buffer for wlan_adapter failed\n"); |
Holger Schurig | fb3dddf | 2007-05-25 11:58:22 -0400 | [diff] [blame] | 789 | goto err_kzalloc; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 790 | } |
| 791 | |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 792 | priv->dev = dev; |
| 793 | priv->card = card; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 794 | priv->mesh_open = 0; |
| 795 | priv->infra_open = 0; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 796 | |
| 797 | SET_MODULE_OWNER(dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 798 | |
| 799 | /* Setup the OS Interface to our functions */ |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 800 | dev->open = libertas_open; |
| 801 | dev->hard_start_xmit = libertas_pre_start_xmit; |
| 802 | dev->stop = libertas_close; |
| 803 | dev->set_mac_address = libertas_set_mac_address; |
| 804 | dev->tx_timeout = libertas_tx_timeout; |
| 805 | dev->get_stats = libertas_get_stats; |
Holger Schurig | fb3dddf | 2007-05-25 11:58:22 -0400 | [diff] [blame] | 806 | dev->watchdog_timeo = 5 * HZ; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 807 | dev->ethtool_ops = &libertas_ethtool_ops; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 808 | #ifdef WIRELESS_EXT |
| 809 | dev->wireless_handlers = (struct iw_handler_def *)&libertas_handler_def; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 810 | #endif |
| 811 | #define NETIF_F_DYNALLOC 16 |
| 812 | dev->features |= NETIF_F_DYNALLOC; |
| 813 | dev->flags |= IFF_BROADCAST | IFF_MULTICAST; |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 814 | dev->set_multicast_list = libertas_set_multicast_list; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 815 | |
Dan Williams | 7732ca4 | 2007-05-25 13:13:25 -0400 | [diff] [blame] | 816 | SET_NETDEV_DEV(dev, dmdev); |
| 817 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 818 | INIT_LIST_HEAD(&priv->adapter->cmdfreeq); |
| 819 | INIT_LIST_HEAD(&priv->adapter->cmdpendingq); |
| 820 | |
| 821 | spin_lock_init(&priv->adapter->driver_lock); |
| 822 | init_waitqueue_head(&priv->adapter->cmd_pending); |
| 823 | priv->adapter->nr_cmd_pending = 0; |
Holger Schurig | 32a74b7 | 2007-05-25 12:04:31 -0400 | [diff] [blame] | 824 | goto done; |
| 825 | |
| 826 | err_kzalloc: |
| 827 | free_netdev(dev); |
Marcelo Tosatti | 6a81215 | 2007-05-25 12:09:13 -0400 | [diff] [blame] | 828 | priv = NULL; |
Holger Schurig | 32a74b7 | 2007-05-25 12:04:31 -0400 | [diff] [blame] | 829 | done: |
| 830 | lbs_deb_leave_args(LBS_DEB_NET, "priv %p", priv); |
| 831 | return priv; |
| 832 | } |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 833 | EXPORT_SYMBOL_GPL(libertas_add_card); |
Holger Schurig | 32a74b7 | 2007-05-25 12:04:31 -0400 | [diff] [blame] | 834 | |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 835 | int libertas_activate_card(wlan_private *priv, char *fw_name) |
Holger Schurig | 32a74b7 | 2007-05-25 12:04:31 -0400 | [diff] [blame] | 836 | { |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 837 | struct net_device *dev = priv->dev; |
Holger Schurig | 32a74b7 | 2007-05-25 12:04:31 -0400 | [diff] [blame] | 838 | int ret = -1; |
| 839 | |
| 840 | lbs_deb_enter(LBS_DEB_MAIN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 841 | |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 842 | lbs_deb_thread("Starting main thread...\n"); |
| 843 | init_waitqueue_head(&priv->waitq); |
| 844 | priv->main_thread = kthread_run(libertas_thread, dev, "libertas_main"); |
| 845 | if (IS_ERR(priv->main_thread)) { |
| 846 | lbs_deb_thread("Error creating main thread.\n"); |
| 847 | goto done; |
| 848 | } |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 849 | |
| 850 | priv->assoc_thread = |
| 851 | create_singlethread_workqueue("libertas_assoc"); |
Holger Schurig | eb3ce63 | 2007-05-24 23:41:15 -0400 | [diff] [blame] | 852 | INIT_DELAYED_WORK(&priv->assoc_work, libertas_association_worker); |
Luis Carlos Cobo Rus | b8bedef | 2007-05-30 12:14:34 -0400 | [diff] [blame] | 853 | INIT_WORK(&priv->sync_channel, libertas_sync_channel); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 854 | |
| 855 | /* |
| 856 | * Register the device. Fillup the private data structure with |
| 857 | * relevant information from the card and request for the required |
| 858 | * IRQ. |
| 859 | */ |
Holger Schurig | 208fdd2 | 2007-05-25 12:17:06 -0400 | [diff] [blame] | 860 | if (priv->hw_register_dev(priv) < 0) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 861 | lbs_pr_err("failed to register WLAN device\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 862 | goto err_registerdev; |
| 863 | } |
| 864 | |
| 865 | /* init FW and HW */ |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 866 | if (fw_name && libertas_init_fw(priv, fw_name)) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 867 | lbs_pr_err("firmware init failed\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 868 | goto err_registerdev; |
| 869 | } |
| 870 | |
| 871 | if (register_netdev(dev)) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 872 | lbs_pr_err("cannot register ethX device\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 873 | goto err_init_fw; |
| 874 | } |
| 875 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 876 | lbs_pr_info("%s: Marvell WLAN 802.11 adapter\n", dev->name); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 877 | |
| 878 | libertas_debugfs_init_one(priv, dev); |
| 879 | |
Holger Schurig | 32a74b7 | 2007-05-25 12:04:31 -0400 | [diff] [blame] | 880 | ret = 0; |
| 881 | goto done; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 882 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 883 | err_init_fw: |
Holger Schurig | 208fdd2 | 2007-05-25 12:17:06 -0400 | [diff] [blame] | 884 | priv->hw_unregister_dev(priv); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 885 | err_registerdev: |
| 886 | destroy_workqueue(priv->assoc_thread); |
| 887 | /* Stop the thread servicing the interrupts */ |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 888 | wake_up_interruptible(&priv->waitq); |
| 889 | kthread_stop(priv->main_thread); |
Holger Schurig | 32a74b7 | 2007-05-25 12:04:31 -0400 | [diff] [blame] | 890 | done: |
| 891 | lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret); |
| 892 | return ret; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 893 | } |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 894 | EXPORT_SYMBOL_GPL(libertas_activate_card); |
| 895 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 896 | |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 897 | /** |
| 898 | * @brief This function adds mshX interface |
| 899 | * |
| 900 | * @param priv A pointer to the wlan_private structure |
| 901 | * @return 0 if successful, -X otherwise |
| 902 | */ |
Dan Williams | 7732ca4 | 2007-05-25 13:13:25 -0400 | [diff] [blame] | 903 | int libertas_add_mesh(wlan_private *priv, struct device *dev) |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 904 | { |
| 905 | struct net_device *mesh_dev = NULL; |
| 906 | int ret = 0; |
| 907 | |
| 908 | lbs_deb_enter(LBS_DEB_MESH); |
| 909 | |
| 910 | /* Allocate a virtual mesh device */ |
| 911 | if (!(mesh_dev = alloc_netdev(0, "msh%d", ether_setup))) { |
| 912 | lbs_deb_mesh("init mshX device failed\n"); |
| 913 | ret = -ENOMEM; |
| 914 | goto done; |
| 915 | } |
| 916 | mesh_dev->priv = priv; |
| 917 | priv->mesh_dev = mesh_dev; |
| 918 | |
| 919 | SET_MODULE_OWNER(mesh_dev); |
| 920 | |
Dan Williams | e524147 | 2007-08-02 11:39:19 -0400 | [diff] [blame^] | 921 | mesh_dev->open = libertas_mesh_open; |
| 922 | mesh_dev->hard_start_xmit = libertas_mesh_pre_start_xmit; |
| 923 | mesh_dev->stop = libertas_mesh_close; |
| 924 | mesh_dev->get_stats = libertas_get_stats; |
| 925 | mesh_dev->set_mac_address = libertas_set_mac_address; |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 926 | mesh_dev->ethtool_ops = &libertas_ethtool_ops; |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 927 | memcpy(mesh_dev->dev_addr, priv->dev->dev_addr, |
| 928 | sizeof(priv->dev->dev_addr)); |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 929 | |
Dan Williams | 7732ca4 | 2007-05-25 13:13:25 -0400 | [diff] [blame] | 930 | SET_NETDEV_DEV(priv->mesh_dev, dev); |
| 931 | |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 932 | #ifdef WIRELESS_EXT |
Luis Carlos Cobo Rus | f5e05b6 | 2007-05-25 23:08:34 -0400 | [diff] [blame] | 933 | mesh_dev->wireless_handlers = (struct iw_handler_def *)&mesh_handler_def; |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 934 | #endif |
| 935 | #define NETIF_F_DYNALLOC 16 |
| 936 | |
| 937 | /* Register virtual mesh interface */ |
| 938 | ret = register_netdev(mesh_dev); |
| 939 | if (ret) { |
| 940 | lbs_pr_err("cannot register mshX virtual interface\n"); |
| 941 | goto err_free; |
| 942 | } |
| 943 | |
Luis Carlos | 82fde74 | 2007-06-07 16:40:59 -0400 | [diff] [blame] | 944 | ret = device_create_file(&(mesh_dev->dev), &dev_attr_anycast_mask); |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 945 | if (ret) |
| 946 | goto err_unregister; |
| 947 | |
| 948 | /* Everything successful */ |
| 949 | ret = 0; |
| 950 | goto done; |
| 951 | |
| 952 | |
| 953 | err_unregister: |
| 954 | unregister_netdev(mesh_dev); |
| 955 | |
| 956 | err_free: |
| 957 | free_netdev(mesh_dev); |
| 958 | |
| 959 | done: |
| 960 | lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret); |
| 961 | return ret; |
| 962 | } |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 963 | EXPORT_SYMBOL_GPL(libertas_add_mesh); |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 964 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 965 | static void wake_pending_cmdnodes(wlan_private *priv) |
| 966 | { |
| 967 | struct cmd_ctrl_node *cmdnode; |
| 968 | unsigned long flags; |
| 969 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 970 | lbs_deb_enter(LBS_DEB_CMD); |
| 971 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 972 | spin_lock_irqsave(&priv->adapter->driver_lock, flags); |
| 973 | list_for_each_entry(cmdnode, &priv->adapter->cmdpendingq, list) { |
| 974 | cmdnode->cmdwaitqwoken = 1; |
| 975 | wake_up_interruptible(&cmdnode->cmdwait_q); |
| 976 | } |
| 977 | spin_unlock_irqrestore(&priv->adapter->driver_lock, flags); |
| 978 | } |
| 979 | |
| 980 | |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 981 | int libertas_remove_card(wlan_private *priv) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 982 | { |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 983 | wlan_adapter *adapter; |
| 984 | struct net_device *dev; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 985 | union iwreq_data wrqu; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 986 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 987 | lbs_deb_enter(LBS_DEB_NET); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 988 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 989 | if (!priv) |
| 990 | goto out; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 991 | |
| 992 | adapter = priv->adapter; |
| 993 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 994 | if (!adapter) |
| 995 | goto out; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 996 | |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 997 | dev = priv->dev; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 998 | |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 999 | netif_stop_queue(priv->dev); |
| 1000 | netif_carrier_off(priv->dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1001 | |
| 1002 | wake_pending_cmdnodes(priv); |
| 1003 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1004 | unregister_netdev(dev); |
| 1005 | |
| 1006 | cancel_delayed_work(&priv->assoc_work); |
| 1007 | destroy_workqueue(priv->assoc_thread); |
| 1008 | |
Dan Williams | 0aef64d | 2007-08-02 11:31:18 -0400 | [diff] [blame] | 1009 | if (adapter->psmode == WLAN802_11POWERMODEMAX_PSP) { |
| 1010 | adapter->psmode = WLAN802_11POWERMODECAM; |
| 1011 | libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1012 | } |
| 1013 | |
| 1014 | memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN); |
| 1015 | wrqu.ap_addr.sa_family = ARPHRD_ETHER; |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 1016 | wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1017 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1018 | adapter->surpriseremoved = 1; |
| 1019 | |
| 1020 | /* Stop the thread servicing the interrupts */ |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 1021 | kthread_stop(priv->main_thread); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1022 | |
| 1023 | libertas_debugfs_remove_one(priv); |
| 1024 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1025 | lbs_deb_net("free adapter\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1026 | libertas_free_adapter(priv); |
| 1027 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1028 | lbs_deb_net("unregister finish\n"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1029 | |
Holger Schurig | 634b8f4 | 2007-05-25 13:05:16 -0400 | [diff] [blame] | 1030 | priv->dev = NULL; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1031 | free_netdev(dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1032 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1033 | out: |
| 1034 | lbs_deb_leave(LBS_DEB_NET); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1035 | return 0; |
| 1036 | } |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1037 | EXPORT_SYMBOL_GPL(libertas_remove_card); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1038 | |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1039 | |
| 1040 | void libertas_remove_mesh(wlan_private *priv) |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 1041 | { |
| 1042 | struct net_device *mesh_dev; |
| 1043 | |
| 1044 | lbs_deb_enter(LBS_DEB_NET); |
| 1045 | |
| 1046 | if (!priv) |
| 1047 | goto out; |
| 1048 | |
| 1049 | mesh_dev = priv->mesh_dev; |
| 1050 | |
| 1051 | netif_stop_queue(mesh_dev); |
Javier Cardona | 51d84f5 | 2007-05-25 12:06:56 -0400 | [diff] [blame] | 1052 | netif_carrier_off(priv->mesh_dev); |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 1053 | |
Luis Carlos | 82fde74 | 2007-06-07 16:40:59 -0400 | [diff] [blame] | 1054 | device_remove_file(&(mesh_dev->dev), &dev_attr_anycast_mask); |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 1055 | unregister_netdev(mesh_dev); |
| 1056 | |
| 1057 | priv->mesh_dev = NULL ; |
| 1058 | free_netdev(mesh_dev); |
| 1059 | |
| 1060 | out: |
| 1061 | lbs_deb_leave(LBS_DEB_NET); |
| 1062 | } |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1063 | EXPORT_SYMBOL_GPL(libertas_remove_mesh); |
Holger Schurig | 78523da | 2007-05-25 11:49:19 -0400 | [diff] [blame] | 1064 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1065 | /** |
| 1066 | * @brief This function finds the CFP in |
| 1067 | * region_cfp_table based on region and band parameter. |
| 1068 | * |
| 1069 | * @param region The region code |
| 1070 | * @param band The band |
| 1071 | * @param cfp_no A pointer to CFP number |
| 1072 | * @return A pointer to CFP |
| 1073 | */ |
| 1074 | struct chan_freq_power *libertas_get_region_cfp_table(u8 region, u8 band, int *cfp_no) |
| 1075 | { |
| 1076 | int i, end; |
| 1077 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1078 | lbs_deb_enter(LBS_DEB_MAIN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1079 | |
| 1080 | end = sizeof(region_cfp_table)/sizeof(struct region_cfp_table); |
| 1081 | |
| 1082 | for (i = 0; i < end ; i++) { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1083 | lbs_deb_main("region_cfp_table[i].region=%d\n", |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1084 | region_cfp_table[i].region); |
| 1085 | if (region_cfp_table[i].region == region) { |
| 1086 | *cfp_no = region_cfp_table[i].cfp_no_BG; |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1087 | lbs_deb_leave(LBS_DEB_MAIN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1088 | return region_cfp_table[i].cfp_BG; |
| 1089 | } |
| 1090 | } |
| 1091 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1092 | lbs_deb_leave_args(LBS_DEB_MAIN, "ret NULL"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1093 | return NULL; |
| 1094 | } |
| 1095 | |
| 1096 | int libertas_set_regiontable(wlan_private * priv, u8 region, u8 band) |
| 1097 | { |
| 1098 | wlan_adapter *adapter = priv->adapter; |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1099 | int ret = 0; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1100 | int i = 0; |
| 1101 | |
| 1102 | struct chan_freq_power *cfp; |
| 1103 | int cfp_no; |
| 1104 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1105 | lbs_deb_enter(LBS_DEB_MAIN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1106 | |
| 1107 | memset(adapter->region_channel, 0, sizeof(adapter->region_channel)); |
| 1108 | |
| 1109 | { |
| 1110 | cfp = libertas_get_region_cfp_table(region, band, &cfp_no); |
| 1111 | if (cfp != NULL) { |
| 1112 | adapter->region_channel[i].nrcfp = cfp_no; |
| 1113 | adapter->region_channel[i].CFP = cfp; |
| 1114 | } else { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1115 | lbs_deb_main("wrong region code %#x in band B/G\n", |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1116 | region); |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1117 | ret = -1; |
| 1118 | goto out; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1119 | } |
| 1120 | adapter->region_channel[i].valid = 1; |
| 1121 | adapter->region_channel[i].region = region; |
| 1122 | adapter->region_channel[i].band = band; |
| 1123 | i++; |
| 1124 | } |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1125 | out: |
| 1126 | lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); |
| 1127 | return ret; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1128 | } |
| 1129 | |
| 1130 | /** |
| 1131 | * @brief This function handles the interrupt. it will change PS |
| 1132 | * state if applicable. it will wake up main_thread to handle |
| 1133 | * the interrupt event as well. |
| 1134 | * |
| 1135 | * @param dev A pointer to net_device structure |
| 1136 | * @return n/a |
| 1137 | */ |
| 1138 | void libertas_interrupt(struct net_device *dev) |
| 1139 | { |
| 1140 | wlan_private *priv = dev->priv; |
| 1141 | |
Holger Schurig | ed37b51 | 2007-05-25 11:52:42 -0400 | [diff] [blame] | 1142 | lbs_deb_enter(LBS_DEB_THREAD); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1143 | |
Holger Schurig | ed37b51 | 2007-05-25 11:52:42 -0400 | [diff] [blame] | 1144 | lbs_deb_thread("libertas_interrupt: intcounter=%d\n", |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1145 | priv->adapter->intcounter); |
| 1146 | |
| 1147 | priv->adapter->intcounter++; |
| 1148 | |
| 1149 | if (priv->adapter->psstate == PS_STATE_SLEEP) { |
| 1150 | priv->adapter->psstate = PS_STATE_AWAKE; |
| 1151 | netif_wake_queue(dev); |
Javier Cardona | 51d84f5 | 2007-05-25 12:06:56 -0400 | [diff] [blame] | 1152 | netif_wake_queue(priv->mesh_dev); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1153 | } |
| 1154 | |
Dan Williams | fe33615 | 2007-08-02 11:32:25 -0400 | [diff] [blame] | 1155 | wake_up_interruptible(&priv->waitq); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1156 | |
Holger Schurig | ed37b51 | 2007-05-25 11:52:42 -0400 | [diff] [blame] | 1157 | lbs_deb_leave(LBS_DEB_THREAD); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1158 | } |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1159 | EXPORT_SYMBOL_GPL(libertas_interrupt); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1160 | |
Dan Williams | eedc2a3 | 2007-08-02 11:36:22 -0400 | [diff] [blame] | 1161 | int libertas_reset_device(wlan_private *priv) |
| 1162 | { |
| 1163 | int ret; |
| 1164 | |
| 1165 | lbs_deb_enter(LBS_DEB_MAIN); |
| 1166 | ret = libertas_prepare_and_send_command(priv, CMD_802_11_RESET, |
| 1167 | CMD_ACT_HALT, 0, 0, NULL); |
| 1168 | msleep_interruptible(10); |
| 1169 | |
| 1170 | lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret); |
| 1171 | return ret; |
| 1172 | } |
| 1173 | EXPORT_SYMBOL_GPL(libertas_reset_device); |
| 1174 | |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1175 | static int libertas_init_module(void) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1176 | { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1177 | lbs_deb_enter(LBS_DEB_MAIN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1178 | libertas_debugfs_init(); |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1179 | lbs_deb_leave(LBS_DEB_MAIN); |
| 1180 | return 0; |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1181 | } |
| 1182 | |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1183 | static void libertas_exit_module(void) |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1184 | { |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1185 | lbs_deb_enter(LBS_DEB_MAIN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1186 | |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1187 | libertas_debugfs_remove(); |
| 1188 | |
Holger Schurig | 9012b28 | 2007-05-25 11:27:16 -0400 | [diff] [blame] | 1189 | lbs_deb_leave(LBS_DEB_MAIN); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1190 | } |
| 1191 | |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1192 | module_init(libertas_init_module); |
| 1193 | module_exit(libertas_exit_module); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1194 | |
Holger Schurig | 084708b | 2007-05-25 12:37:58 -0400 | [diff] [blame] | 1195 | MODULE_DESCRIPTION("Libertas WLAN Driver Library"); |
Marcelo Tosatti | 876c9d3 | 2007-02-10 12:25:27 -0200 | [diff] [blame] | 1196 | MODULE_AUTHOR("Marvell International Ltd."); |
| 1197 | MODULE_LICENSE("GPL"); |