Jouni Malinen | ff1d276 | 2005-05-12 22:54:16 -0400 | [diff] [blame] | 1 | /* Host AP driver Info Frame processing (part of hostap.o module) */ |
| 2 | |
Adrian Bunk | 5fad5a2 | 2006-01-14 03:09:34 +0100 | [diff] [blame] | 3 | #include "hostap_wlan.h" |
| 4 | #include "hostap.h" |
| 5 | #include "hostap_ap.h" |
Jouni Malinen | ff1d276 | 2005-05-12 22:54:16 -0400 | [diff] [blame] | 6 | |
| 7 | /* Called only as a tasklet (software IRQ) */ |
| 8 | static void prism2_info_commtallies16(local_info_t *local, unsigned char *buf, |
| 9 | int left) |
| 10 | { |
| 11 | struct hfa384x_comm_tallies *tallies; |
| 12 | |
| 13 | if (left < sizeof(struct hfa384x_comm_tallies)) { |
| 14 | printk(KERN_DEBUG "%s: too short (len=%d) commtallies " |
| 15 | "info frame\n", local->dev->name, left); |
| 16 | return; |
| 17 | } |
| 18 | |
| 19 | tallies = (struct hfa384x_comm_tallies *) buf; |
| 20 | #define ADD_COMM_TALLIES(name) \ |
| 21 | local->comm_tallies.name += le16_to_cpu(tallies->name) |
| 22 | ADD_COMM_TALLIES(tx_unicast_frames); |
| 23 | ADD_COMM_TALLIES(tx_multicast_frames); |
| 24 | ADD_COMM_TALLIES(tx_fragments); |
| 25 | ADD_COMM_TALLIES(tx_unicast_octets); |
| 26 | ADD_COMM_TALLIES(tx_multicast_octets); |
| 27 | ADD_COMM_TALLIES(tx_deferred_transmissions); |
| 28 | ADD_COMM_TALLIES(tx_single_retry_frames); |
| 29 | ADD_COMM_TALLIES(tx_multiple_retry_frames); |
| 30 | ADD_COMM_TALLIES(tx_retry_limit_exceeded); |
| 31 | ADD_COMM_TALLIES(tx_discards); |
| 32 | ADD_COMM_TALLIES(rx_unicast_frames); |
| 33 | ADD_COMM_TALLIES(rx_multicast_frames); |
| 34 | ADD_COMM_TALLIES(rx_fragments); |
| 35 | ADD_COMM_TALLIES(rx_unicast_octets); |
| 36 | ADD_COMM_TALLIES(rx_multicast_octets); |
| 37 | ADD_COMM_TALLIES(rx_fcs_errors); |
| 38 | ADD_COMM_TALLIES(rx_discards_no_buffer); |
| 39 | ADD_COMM_TALLIES(tx_discards_wrong_sa); |
| 40 | ADD_COMM_TALLIES(rx_discards_wep_undecryptable); |
| 41 | ADD_COMM_TALLIES(rx_message_in_msg_fragments); |
| 42 | ADD_COMM_TALLIES(rx_message_in_bad_msg_fragments); |
| 43 | #undef ADD_COMM_TALLIES |
| 44 | } |
| 45 | |
| 46 | |
| 47 | /* Called only as a tasklet (software IRQ) */ |
| 48 | static void prism2_info_commtallies32(local_info_t *local, unsigned char *buf, |
| 49 | int left) |
| 50 | { |
| 51 | struct hfa384x_comm_tallies32 *tallies; |
| 52 | |
| 53 | if (left < sizeof(struct hfa384x_comm_tallies32)) { |
| 54 | printk(KERN_DEBUG "%s: too short (len=%d) commtallies32 " |
| 55 | "info frame\n", local->dev->name, left); |
| 56 | return; |
| 57 | } |
| 58 | |
| 59 | tallies = (struct hfa384x_comm_tallies32 *) buf; |
| 60 | #define ADD_COMM_TALLIES(name) \ |
| 61 | local->comm_tallies.name += le32_to_cpu(tallies->name) |
| 62 | ADD_COMM_TALLIES(tx_unicast_frames); |
| 63 | ADD_COMM_TALLIES(tx_multicast_frames); |
| 64 | ADD_COMM_TALLIES(tx_fragments); |
| 65 | ADD_COMM_TALLIES(tx_unicast_octets); |
| 66 | ADD_COMM_TALLIES(tx_multicast_octets); |
| 67 | ADD_COMM_TALLIES(tx_deferred_transmissions); |
| 68 | ADD_COMM_TALLIES(tx_single_retry_frames); |
| 69 | ADD_COMM_TALLIES(tx_multiple_retry_frames); |
| 70 | ADD_COMM_TALLIES(tx_retry_limit_exceeded); |
| 71 | ADD_COMM_TALLIES(tx_discards); |
| 72 | ADD_COMM_TALLIES(rx_unicast_frames); |
| 73 | ADD_COMM_TALLIES(rx_multicast_frames); |
| 74 | ADD_COMM_TALLIES(rx_fragments); |
| 75 | ADD_COMM_TALLIES(rx_unicast_octets); |
| 76 | ADD_COMM_TALLIES(rx_multicast_octets); |
| 77 | ADD_COMM_TALLIES(rx_fcs_errors); |
| 78 | ADD_COMM_TALLIES(rx_discards_no_buffer); |
| 79 | ADD_COMM_TALLIES(tx_discards_wrong_sa); |
| 80 | ADD_COMM_TALLIES(rx_discards_wep_undecryptable); |
| 81 | ADD_COMM_TALLIES(rx_message_in_msg_fragments); |
| 82 | ADD_COMM_TALLIES(rx_message_in_bad_msg_fragments); |
| 83 | #undef ADD_COMM_TALLIES |
| 84 | } |
| 85 | |
| 86 | |
| 87 | /* Called only as a tasklet (software IRQ) */ |
| 88 | static void prism2_info_commtallies(local_info_t *local, unsigned char *buf, |
| 89 | int left) |
| 90 | { |
| 91 | if (local->tallies32) |
| 92 | prism2_info_commtallies32(local, buf, left); |
| 93 | else |
| 94 | prism2_info_commtallies16(local, buf, left); |
| 95 | } |
| 96 | |
| 97 | |
| 98 | #ifndef PRISM2_NO_STATION_MODES |
| 99 | #ifndef PRISM2_NO_DEBUG |
| 100 | static const char* hfa384x_linkstatus_str(u16 linkstatus) |
| 101 | { |
| 102 | switch (linkstatus) { |
| 103 | case HFA384X_LINKSTATUS_CONNECTED: |
| 104 | return "Connected"; |
| 105 | case HFA384X_LINKSTATUS_DISCONNECTED: |
| 106 | return "Disconnected"; |
| 107 | case HFA384X_LINKSTATUS_AP_CHANGE: |
| 108 | return "Access point change"; |
| 109 | case HFA384X_LINKSTATUS_AP_OUT_OF_RANGE: |
| 110 | return "Access point out of range"; |
| 111 | case HFA384X_LINKSTATUS_AP_IN_RANGE: |
| 112 | return "Access point in range"; |
| 113 | case HFA384X_LINKSTATUS_ASSOC_FAILED: |
| 114 | return "Association failed"; |
| 115 | default: |
| 116 | return "Unknown"; |
| 117 | } |
| 118 | } |
| 119 | #endif /* PRISM2_NO_DEBUG */ |
| 120 | |
| 121 | |
| 122 | /* Called only as a tasklet (software IRQ) */ |
| 123 | static void prism2_info_linkstatus(local_info_t *local, unsigned char *buf, |
| 124 | int left) |
| 125 | { |
| 126 | u16 val; |
| 127 | int non_sta_mode; |
| 128 | |
| 129 | /* Alloc new JoinRequests to occur since LinkStatus for the previous |
| 130 | * has been received */ |
| 131 | local->last_join_time = 0; |
| 132 | |
| 133 | if (left != 2) { |
| 134 | printk(KERN_DEBUG "%s: invalid linkstatus info frame " |
| 135 | "length %d\n", local->dev->name, left); |
| 136 | return; |
| 137 | } |
| 138 | |
| 139 | non_sta_mode = local->iw_mode == IW_MODE_MASTER || |
| 140 | local->iw_mode == IW_MODE_REPEAT || |
| 141 | local->iw_mode == IW_MODE_MONITOR; |
| 142 | |
| 143 | val = buf[0] | (buf[1] << 8); |
| 144 | if (!non_sta_mode || val != HFA384X_LINKSTATUS_DISCONNECTED) { |
| 145 | PDEBUG(DEBUG_EXTRA, "%s: LinkStatus=%d (%s)\n", |
| 146 | local->dev->name, val, hfa384x_linkstatus_str(val)); |
| 147 | } |
| 148 | |
| 149 | if (non_sta_mode) { |
| 150 | netif_carrier_on(local->dev); |
| 151 | netif_carrier_on(local->ddev); |
| 152 | return; |
| 153 | } |
| 154 | |
| 155 | /* Get current BSSID later in scheduled task */ |
| 156 | set_bit(PRISM2_INFO_PENDING_LINKSTATUS, &local->pending_info); |
| 157 | local->prev_link_status = val; |
| 158 | schedule_work(&local->info_queue); |
| 159 | } |
| 160 | |
| 161 | |
| 162 | static void prism2_host_roaming(local_info_t *local) |
| 163 | { |
| 164 | struct hfa384x_join_request req; |
| 165 | struct net_device *dev = local->dev; |
Jouni Malinen | 2e4fd06 | 2005-07-30 12:50:02 -0700 | [diff] [blame] | 166 | struct hfa384x_hostscan_result *selected, *entry; |
Jouni Malinen | ff1d276 | 2005-05-12 22:54:16 -0400 | [diff] [blame] | 167 | int i; |
| 168 | unsigned long flags; |
| 169 | |
| 170 | if (local->last_join_time && |
| 171 | time_before(jiffies, local->last_join_time + 10 * HZ)) { |
| 172 | PDEBUG(DEBUG_EXTRA, "%s: last join request has not yet been " |
| 173 | "completed - waiting for it before issuing new one\n", |
| 174 | dev->name); |
| 175 | return; |
| 176 | } |
| 177 | |
| 178 | /* ScanResults are sorted: first ESS results in decreasing signal |
| 179 | * quality then IBSS results in similar order. |
| 180 | * Trivial roaming policy: just select the first entry. |
| 181 | * This could probably be improved by adding hysteresis to limit |
| 182 | * number of handoffs, etc. |
| 183 | * |
| 184 | * Could do periodic RID_SCANREQUEST or Inquire F101 to get new |
| 185 | * ScanResults */ |
| 186 | spin_lock_irqsave(&local->lock, flags); |
| 187 | if (local->last_scan_results == NULL || |
| 188 | local->last_scan_results_count == 0) { |
| 189 | spin_unlock_irqrestore(&local->lock, flags); |
| 190 | PDEBUG(DEBUG_EXTRA, "%s: no scan results for host roaming\n", |
| 191 | dev->name); |
| 192 | return; |
| 193 | } |
| 194 | |
| 195 | selected = &local->last_scan_results[0]; |
| 196 | |
| 197 | if (local->preferred_ap[0] || local->preferred_ap[1] || |
| 198 | local->preferred_ap[2] || local->preferred_ap[3] || |
| 199 | local->preferred_ap[4] || local->preferred_ap[5]) { |
| 200 | /* Try to find preferred AP */ |
| 201 | PDEBUG(DEBUG_EXTRA, "%s: Preferred AP BSSID " MACSTR "\n", |
| 202 | dev->name, MAC2STR(local->preferred_ap)); |
| 203 | for (i = 0; i < local->last_scan_results_count; i++) { |
| 204 | entry = &local->last_scan_results[i]; |
| 205 | if (memcmp(local->preferred_ap, entry->bssid, 6) == 0) |
| 206 | { |
| 207 | PDEBUG(DEBUG_EXTRA, "%s: using preferred AP " |
| 208 | "selection\n", dev->name); |
| 209 | selected = entry; |
| 210 | break; |
| 211 | } |
| 212 | } |
| 213 | } |
| 214 | |
| 215 | memcpy(req.bssid, selected->bssid, 6); |
| 216 | req.channel = selected->chid; |
| 217 | spin_unlock_irqrestore(&local->lock, flags); |
| 218 | |
| 219 | PDEBUG(DEBUG_EXTRA, "%s: JoinRequest: BSSID=" MACSTR " channel=%d\n", |
| 220 | dev->name, MAC2STR(req.bssid), le16_to_cpu(req.channel)); |
| 221 | if (local->func->set_rid(dev, HFA384X_RID_JOINREQUEST, &req, |
| 222 | sizeof(req))) { |
| 223 | printk(KERN_DEBUG "%s: JoinRequest failed\n", dev->name); |
| 224 | } |
| 225 | local->last_join_time = jiffies; |
| 226 | } |
| 227 | |
| 228 | |
| 229 | static void hostap_report_scan_complete(local_info_t *local) |
| 230 | { |
| 231 | union iwreq_data wrqu; |
| 232 | |
| 233 | /* Inform user space about new scan results (just empty event, |
| 234 | * SIOCGIWSCAN can be used to fetch data */ |
| 235 | wrqu.data.length = 0; |
| 236 | wrqu.data.flags = 0; |
| 237 | wireless_send_event(local->dev, SIOCGIWSCAN, &wrqu, NULL); |
| 238 | |
| 239 | /* Allow SIOCGIWSCAN handling to occur since we have received |
| 240 | * scanning result */ |
| 241 | local->scan_timestamp = 0; |
| 242 | } |
| 243 | |
| 244 | |
| 245 | /* Called only as a tasklet (software IRQ) */ |
| 246 | static void prism2_info_scanresults(local_info_t *local, unsigned char *buf, |
| 247 | int left) |
| 248 | { |
| 249 | u16 *pos; |
Jouni Malinen | 2e4fd06 | 2005-07-30 12:50:02 -0700 | [diff] [blame] | 250 | int new_count, i; |
Jouni Malinen | ff1d276 | 2005-05-12 22:54:16 -0400 | [diff] [blame] | 251 | unsigned long flags; |
Jouni Malinen | 2e4fd06 | 2005-07-30 12:50:02 -0700 | [diff] [blame] | 252 | struct hfa384x_scan_result *res; |
| 253 | struct hfa384x_hostscan_result *results, *prev; |
Jouni Malinen | ff1d276 | 2005-05-12 22:54:16 -0400 | [diff] [blame] | 254 | |
| 255 | if (left < 4) { |
| 256 | printk(KERN_DEBUG "%s: invalid scanresult info frame " |
| 257 | "length %d\n", local->dev->name, left); |
| 258 | return; |
| 259 | } |
| 260 | |
| 261 | pos = (u16 *) buf; |
| 262 | pos++; |
| 263 | pos++; |
| 264 | left -= 4; |
| 265 | |
| 266 | new_count = left / sizeof(struct hfa384x_scan_result); |
Jouni Malinen | 2e4fd06 | 2005-07-30 12:50:02 -0700 | [diff] [blame] | 267 | results = kmalloc(new_count * sizeof(struct hfa384x_hostscan_result), |
Jouni Malinen | ff1d276 | 2005-05-12 22:54:16 -0400 | [diff] [blame] | 268 | GFP_ATOMIC); |
| 269 | if (results == NULL) |
| 270 | return; |
Jouni Malinen | 2e4fd06 | 2005-07-30 12:50:02 -0700 | [diff] [blame] | 271 | |
| 272 | /* Convert to hostscan result format. */ |
| 273 | res = (struct hfa384x_scan_result *) pos; |
| 274 | for (i = 0; i < new_count; i++) { |
| 275 | memcpy(&results[i], &res[i], |
| 276 | sizeof(struct hfa384x_scan_result)); |
| 277 | results[i].atim = 0; |
| 278 | } |
Jouni Malinen | ff1d276 | 2005-05-12 22:54:16 -0400 | [diff] [blame] | 279 | |
| 280 | spin_lock_irqsave(&local->lock, flags); |
| 281 | local->last_scan_type = PRISM2_SCAN; |
| 282 | prev = local->last_scan_results; |
| 283 | local->last_scan_results = results; |
| 284 | local->last_scan_results_count = new_count; |
| 285 | spin_unlock_irqrestore(&local->lock, flags); |
| 286 | kfree(prev); |
| 287 | |
| 288 | hostap_report_scan_complete(local); |
| 289 | |
| 290 | /* Perform rest of ScanResults handling later in scheduled task */ |
| 291 | set_bit(PRISM2_INFO_PENDING_SCANRESULTS, &local->pending_info); |
| 292 | schedule_work(&local->info_queue); |
| 293 | } |
| 294 | |
| 295 | |
| 296 | /* Called only as a tasklet (software IRQ) */ |
| 297 | static void prism2_info_hostscanresults(local_info_t *local, |
| 298 | unsigned char *buf, int left) |
| 299 | { |
| 300 | int i, result_size, copy_len, new_count; |
| 301 | struct hfa384x_hostscan_result *results, *prev; |
| 302 | unsigned long flags; |
| 303 | u16 *pos; |
| 304 | u8 *ptr; |
| 305 | |
| 306 | wake_up_interruptible(&local->hostscan_wq); |
| 307 | |
| 308 | if (left < 4) { |
| 309 | printk(KERN_DEBUG "%s: invalid hostscanresult info frame " |
| 310 | "length %d\n", local->dev->name, left); |
| 311 | return; |
| 312 | } |
| 313 | |
| 314 | pos = (u16 *) buf; |
| 315 | copy_len = result_size = le16_to_cpu(*pos); |
| 316 | if (result_size == 0) { |
| 317 | printk(KERN_DEBUG "%s: invalid result_size (0) in " |
| 318 | "hostscanresults\n", local->dev->name); |
| 319 | return; |
| 320 | } |
| 321 | if (copy_len > sizeof(struct hfa384x_hostscan_result)) |
| 322 | copy_len = sizeof(struct hfa384x_hostscan_result); |
| 323 | |
| 324 | pos++; |
| 325 | pos++; |
| 326 | left -= 4; |
| 327 | ptr = (u8 *) pos; |
| 328 | |
| 329 | new_count = left / result_size; |
| 330 | results = kmalloc(new_count * sizeof(struct hfa384x_hostscan_result), |
| 331 | GFP_ATOMIC); |
| 332 | if (results == NULL) |
| 333 | return; |
| 334 | memset(results, 0, new_count * sizeof(struct hfa384x_hostscan_result)); |
| 335 | |
| 336 | for (i = 0; i < new_count; i++) { |
| 337 | memcpy(&results[i], ptr, copy_len); |
| 338 | ptr += result_size; |
| 339 | left -= result_size; |
| 340 | } |
| 341 | |
| 342 | if (left) { |
| 343 | printk(KERN_DEBUG "%s: short HostScan result entry (%d/%d)\n", |
| 344 | local->dev->name, left, result_size); |
| 345 | } |
| 346 | |
| 347 | spin_lock_irqsave(&local->lock, flags); |
| 348 | local->last_scan_type = PRISM2_HOSTSCAN; |
Jouni Malinen | 2e4fd06 | 2005-07-30 12:50:02 -0700 | [diff] [blame] | 349 | prev = local->last_scan_results; |
| 350 | local->last_scan_results = results; |
| 351 | local->last_scan_results_count = new_count; |
Jouni Malinen | ff1d276 | 2005-05-12 22:54:16 -0400 | [diff] [blame] | 352 | spin_unlock_irqrestore(&local->lock, flags); |
| 353 | kfree(prev); |
| 354 | |
| 355 | hostap_report_scan_complete(local); |
| 356 | } |
| 357 | #endif /* PRISM2_NO_STATION_MODES */ |
| 358 | |
| 359 | |
| 360 | /* Called only as a tasklet (software IRQ) */ |
| 361 | void hostap_info_process(local_info_t *local, struct sk_buff *skb) |
| 362 | { |
| 363 | struct hfa384x_info_frame *info; |
| 364 | unsigned char *buf; |
| 365 | int left; |
| 366 | #ifndef PRISM2_NO_DEBUG |
| 367 | int i; |
| 368 | #endif /* PRISM2_NO_DEBUG */ |
| 369 | |
| 370 | info = (struct hfa384x_info_frame *) skb->data; |
| 371 | buf = skb->data + sizeof(*info); |
| 372 | left = skb->len - sizeof(*info); |
| 373 | |
| 374 | switch (info->type) { |
| 375 | case HFA384X_INFO_COMMTALLIES: |
| 376 | prism2_info_commtallies(local, buf, left); |
| 377 | break; |
| 378 | |
| 379 | #ifndef PRISM2_NO_STATION_MODES |
| 380 | case HFA384X_INFO_LINKSTATUS: |
| 381 | prism2_info_linkstatus(local, buf, left); |
| 382 | break; |
| 383 | |
| 384 | case HFA384X_INFO_SCANRESULTS: |
| 385 | prism2_info_scanresults(local, buf, left); |
| 386 | break; |
| 387 | |
| 388 | case HFA384X_INFO_HOSTSCANRESULTS: |
| 389 | prism2_info_hostscanresults(local, buf, left); |
| 390 | break; |
| 391 | #endif /* PRISM2_NO_STATION_MODES */ |
| 392 | |
| 393 | #ifndef PRISM2_NO_DEBUG |
| 394 | default: |
| 395 | PDEBUG(DEBUG_EXTRA, "%s: INFO - len=%d type=0x%04x\n", |
| 396 | local->dev->name, info->len, info->type); |
| 397 | PDEBUG(DEBUG_EXTRA, "Unknown info frame:"); |
| 398 | for (i = 0; i < (left < 100 ? left : 100); i++) |
| 399 | PDEBUG2(DEBUG_EXTRA, " %02x", buf[i]); |
| 400 | PDEBUG2(DEBUG_EXTRA, "\n"); |
| 401 | break; |
| 402 | #endif /* PRISM2_NO_DEBUG */ |
| 403 | } |
| 404 | } |
| 405 | |
| 406 | |
| 407 | #ifndef PRISM2_NO_STATION_MODES |
| 408 | static void handle_info_queue_linkstatus(local_info_t *local) |
| 409 | { |
| 410 | int val = local->prev_link_status; |
| 411 | int connected; |
| 412 | union iwreq_data wrqu; |
| 413 | |
| 414 | connected = |
| 415 | val == HFA384X_LINKSTATUS_CONNECTED || |
| 416 | val == HFA384X_LINKSTATUS_AP_CHANGE || |
| 417 | val == HFA384X_LINKSTATUS_AP_IN_RANGE; |
| 418 | |
| 419 | if (local->func->get_rid(local->dev, HFA384X_RID_CURRENTBSSID, |
| 420 | local->bssid, ETH_ALEN, 1) < 0) { |
| 421 | printk(KERN_DEBUG "%s: could not read CURRENTBSSID after " |
| 422 | "LinkStatus event\n", local->dev->name); |
| 423 | } else { |
| 424 | PDEBUG(DEBUG_EXTRA, "%s: LinkStatus: BSSID=" MACSTR "\n", |
| 425 | local->dev->name, |
| 426 | MAC2STR((unsigned char *) local->bssid)); |
| 427 | if (local->wds_type & HOSTAP_WDS_AP_CLIENT) |
| 428 | hostap_add_sta(local->ap, local->bssid); |
| 429 | } |
| 430 | |
| 431 | /* Get BSSID if we have a valid AP address */ |
| 432 | if (connected) { |
| 433 | netif_carrier_on(local->dev); |
| 434 | netif_carrier_on(local->ddev); |
| 435 | memcpy(wrqu.ap_addr.sa_data, local->bssid, ETH_ALEN); |
| 436 | } else { |
| 437 | netif_carrier_off(local->dev); |
| 438 | netif_carrier_off(local->ddev); |
| 439 | memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN); |
| 440 | } |
| 441 | wrqu.ap_addr.sa_family = ARPHRD_ETHER; |
| 442 | |
| 443 | /* |
| 444 | * Filter out sequential disconnect events in order not to cause a |
| 445 | * flood of SIOCGIWAP events that have a race condition with EAPOL |
| 446 | * frames and can confuse wpa_supplicant about the current association |
| 447 | * status. |
| 448 | */ |
| 449 | if (connected || local->prev_linkstatus_connected) |
| 450 | wireless_send_event(local->dev, SIOCGIWAP, &wrqu, NULL); |
| 451 | local->prev_linkstatus_connected = connected; |
| 452 | } |
| 453 | |
| 454 | |
| 455 | static void handle_info_queue_scanresults(local_info_t *local) |
| 456 | { |
| 457 | if (local->host_roaming == 1 && local->iw_mode == IW_MODE_INFRA) |
| 458 | prism2_host_roaming(local); |
Jouni Malinen | 0c629a6 | 2005-07-30 12:50:03 -0700 | [diff] [blame] | 459 | |
| 460 | if (local->host_roaming == 2 && local->iw_mode == IW_MODE_INFRA && |
| 461 | memcmp(local->preferred_ap, "\x00\x00\x00\x00\x00\x00", |
| 462 | ETH_ALEN) != 0) { |
| 463 | /* |
| 464 | * Firmware seems to be getting into odd state in host_roaming |
| 465 | * mode 2 when hostscan is used without join command, so try |
| 466 | * to fix this by re-joining the current AP. This does not |
| 467 | * actually trigger a new association if the current AP is |
| 468 | * still in the scan results. |
| 469 | */ |
| 470 | prism2_host_roaming(local); |
| 471 | } |
Jouni Malinen | ff1d276 | 2005-05-12 22:54:16 -0400 | [diff] [blame] | 472 | } |
| 473 | |
| 474 | |
| 475 | /* Called only as scheduled task after receiving info frames (used to avoid |
| 476 | * pending too much time in HW IRQ handler). */ |
| 477 | static void handle_info_queue(void *data) |
| 478 | { |
| 479 | local_info_t *local = (local_info_t *) data; |
| 480 | |
| 481 | if (test_and_clear_bit(PRISM2_INFO_PENDING_LINKSTATUS, |
| 482 | &local->pending_info)) |
| 483 | handle_info_queue_linkstatus(local); |
| 484 | |
| 485 | if (test_and_clear_bit(PRISM2_INFO_PENDING_SCANRESULTS, |
| 486 | &local->pending_info)) |
| 487 | handle_info_queue_scanresults(local); |
| 488 | } |
| 489 | #endif /* PRISM2_NO_STATION_MODES */ |
| 490 | |
| 491 | |
| 492 | void hostap_info_init(local_info_t *local) |
| 493 | { |
| 494 | skb_queue_head_init(&local->info_list); |
| 495 | #ifndef PRISM2_NO_STATION_MODES |
| 496 | INIT_WORK(&local->info_queue, handle_info_queue, local); |
| 497 | #endif /* PRISM2_NO_STATION_MODES */ |
| 498 | } |
| 499 | |
| 500 | |
| 501 | EXPORT_SYMBOL(hostap_info_init); |
| 502 | EXPORT_SYMBOL(hostap_info_process); |