?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libertas: convert KEY_MATERIAL to a direct command
[linux-2.6/kvm.git] / drivers / net / wireless / libertas / cmdresp.c
blobb96fe58ec495e4e668e09ce3f2c611950f237ed9
1 /**
2 * This file contains the handling of command
3 * responses as well as events generated by firmware.
4 */
5 #include <linux/delay.h>
6 #include <linux/if_arp.h>
7 #include <linux/netdevice.h>
8
9 #include <net/iw_handler.h>
10
11 #include "host.h"
12 #include "decl.h"
13 #include "defs.h"
14 #include "dev.h"
15 #include "join.h"
16 #include "wext.h"
17
18 /**
19 * @brief This function handles disconnect event. it
20 * reports disconnect to upper layer, clean tx/rx packets,
21 * reset link state etc.
22 *
23 * @param priv A pointer to struct lbs_private structure
24 * @return n/a
25 */
26 void lbs_mac_event_disconnected(struct lbs_private *priv)
27 {
28 union iwreq_data wrqu;
29
30 if (priv->connect_status != LBS_CONNECTED)
31 return;
32
33 lbs_deb_enter(LBS_DEB_ASSOC);
34
35 memset(wrqu.ap_addr.sa_data, 0x00, ETH_ALEN);
36 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
37
38 /*
39 * Cisco AP sends EAP failure and de-auth in less than 0.5 ms.
40 * It causes problem in the Supplicant
41 */
42
43 msleep_interruptible(1000);
44 wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
45
46 /* report disconnect to upper layer */
47 netif_stop_queue(priv->dev);
48 netif_carrier_off(priv->dev);
49
50 /* Free Tx and Rx packets */
51 kfree_skb(priv->currenttxskb);
52 priv->currenttxskb = NULL;
53 priv->tx_pending_len = 0;
54
55 /* reset SNR/NF/RSSI values */
56 memset(priv->SNR, 0x00, sizeof(priv->SNR));
57 memset(priv->NF, 0x00, sizeof(priv->NF));
58 memset(priv->RSSI, 0x00, sizeof(priv->RSSI));
59 memset(priv->rawSNR, 0x00, sizeof(priv->rawSNR));
60 memset(priv->rawNF, 0x00, sizeof(priv->rawNF));
61 priv->nextSNRNF = 0;
62 priv->numSNRNF = 0;
63 priv->connect_status = LBS_DISCONNECTED;
64
65 /* Clear out associated SSID and BSSID since connection is
66 * no longer valid.
67 */
68 memset(&priv->curbssparams.bssid, 0, ETH_ALEN);
69 memset(&priv->curbssparams.ssid, 0, IW_ESSID_MAX_SIZE);
70 priv->curbssparams.ssid_len = 0;
71
72 if (priv->psstate != PS_STATE_FULL_POWER) {
73 /* make firmware to exit PS mode */
74 lbs_deb_cmd("disconnected, so exit PS mode\n");
75 lbs_ps_wakeup(priv, 0);
76 }
77 lbs_deb_leave(LBS_DEB_ASSOC);
78 }
79
80 /**
81 * @brief This function handles MIC failure event.
82 *
83 * @param priv A pointer to struct lbs_private structure
84 * @para event the event id
85 * @return n/a
86 */
87 static void handle_mic_failureevent(struct lbs_private *priv, u32 event)
88 {
89 char buf[50];
90
91 lbs_deb_enter(LBS_DEB_CMD);
92 memset(buf, 0, sizeof(buf));
93
94 sprintf(buf, "%s", "MLME-MICHAELMICFAILURE.indication ");
95
96 if (event == MACREG_INT_CODE_MIC_ERR_UNICAST) {
97 strcat(buf, "unicast ");
98 } else {
99 strcat(buf, "multicast ");
100 }
101
102 lbs_send_iwevcustom_event(priv, buf);
103 lbs_deb_leave(LBS_DEB_CMD);
104 }
105
106 static int lbs_ret_reg_access(struct lbs_private *priv,
107 u16 type, struct cmd_ds_command *resp)
108 {
109 int ret = 0;
110
111 lbs_deb_enter(LBS_DEB_CMD);
112
113 switch (type) {
114 case CMD_RET(CMD_MAC_REG_ACCESS):
115 {
116 struct cmd_ds_mac_reg_access *reg = &resp->params.macreg;
117
118 priv->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
119 priv->offsetvalue.value = le32_to_cpu(reg->value);
120 break;
121 }
122
123 case CMD_RET(CMD_BBP_REG_ACCESS):
124 {
125 struct cmd_ds_bbp_reg_access *reg = &resp->params.bbpreg;
126
127 priv->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
128 priv->offsetvalue.value = reg->value;
129 break;
130 }
131
132 case CMD_RET(CMD_RF_REG_ACCESS):
133 {
134 struct cmd_ds_rf_reg_access *reg = &resp->params.rfreg;
135
136 priv->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
137 priv->offsetvalue.value = reg->value;
138 break;
139 }
140
141 default:
142 ret = -1;
143 }
144
145 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
146 return ret;
147 }
148
149 static int lbs_ret_802_11_stat(struct lbs_private *priv,
150 struct cmd_ds_command *resp)
151 {
152 lbs_deb_enter(LBS_DEB_CMD);
153 /* currently priv->wlan802_11Stat is unused
154
155 struct cmd_ds_802_11_get_stat *p11Stat = &resp->params.gstat;
156
157 // TODO Convert it to Big endian befor copy
158 memcpy(&priv->wlan802_11Stat,
159 p11Stat, sizeof(struct cmd_ds_802_11_get_stat));
160 */
161 lbs_deb_leave(LBS_DEB_CMD);
162 return 0;
163 }
164
165 static int lbs_ret_802_11_snmp_mib(struct lbs_private *priv,
166 struct cmd_ds_command *resp)
167 {
168 struct cmd_ds_802_11_snmp_mib *smib = &resp->params.smib;
169 u16 oid = le16_to_cpu(smib->oid);
170 u16 querytype = le16_to_cpu(smib->querytype);
171
172 lbs_deb_enter(LBS_DEB_CMD);
173
174 lbs_deb_cmd("SNMP_RESP: oid 0x%x, querytype 0x%x\n", oid,
175 querytype);
176 lbs_deb_cmd("SNMP_RESP: Buf size %d\n", le16_to_cpu(smib->bufsize));
177
178 if (querytype == CMD_ACT_GET) {
179 switch (oid) {
180 case FRAGTHRESH_I:
181 priv->fragthsd =
182 le16_to_cpu(*((__le16 *)(smib->value)));
183 lbs_deb_cmd("SNMP_RESP: frag threshold %u\n",
184 priv->fragthsd);
185 break;
186 case RTSTHRESH_I:
187 priv->rtsthsd =
188 le16_to_cpu(*((__le16 *)(smib->value)));
189 lbs_deb_cmd("SNMP_RESP: rts threshold %u\n",
190 priv->rtsthsd);
191 break;
192 case SHORT_RETRYLIM_I:
193 priv->txretrycount =
194 le16_to_cpu(*((__le16 *)(smib->value)));
195 lbs_deb_cmd("SNMP_RESP: tx retry count %u\n",
196 priv->rtsthsd);
197 break;
198 default:
199 break;
200 }
201 }
202
203 lbs_deb_enter(LBS_DEB_CMD);
204 return 0;
205 }
206
207 static int lbs_ret_802_11_mac_address(struct lbs_private *priv,
208 struct cmd_ds_command *resp)
209 {
210 struct cmd_ds_802_11_mac_address *macadd = &resp->params.macadd;
211
212 lbs_deb_enter(LBS_DEB_CMD);
213
214 memcpy(priv->current_addr, macadd->macadd, ETH_ALEN);
215
216 lbs_deb_enter(LBS_DEB_CMD);
217 return 0;
218 }
219
220 static int lbs_ret_802_11_rf_tx_power(struct lbs_private *priv,
221 struct cmd_ds_command *resp)
222 {
223 struct cmd_ds_802_11_rf_tx_power *rtp = &resp->params.txp;
224
225 lbs_deb_enter(LBS_DEB_CMD);
226
227 priv->txpowerlevel = le16_to_cpu(rtp->currentlevel);
228
229 lbs_deb_cmd("TX power currently %d\n", priv->txpowerlevel);
230
231 lbs_deb_leave(LBS_DEB_CMD);
232 return 0;
233 }
234
235 static int lbs_ret_802_11_rate_adapt_rateset(struct lbs_private *priv,
236 struct cmd_ds_command *resp)
237 {
238 struct cmd_ds_802_11_rate_adapt_rateset *rates = &resp->params.rateset;
239
240 lbs_deb_enter(LBS_DEB_CMD);
241
242 if (rates->action == CMD_ACT_GET) {
243 priv->enablehwauto = le16_to_cpu(rates->enablehwauto);
244 priv->ratebitmap = le16_to_cpu(rates->bitmap);
245 }
246
247 lbs_deb_leave(LBS_DEB_CMD);
248 return 0;
249 }
250
251 static int lbs_ret_802_11_rssi(struct lbs_private *priv,
252 struct cmd_ds_command *resp)
253 {
254 struct cmd_ds_802_11_rssi_rsp *rssirsp = &resp->params.rssirsp;
255
256 lbs_deb_enter(LBS_DEB_CMD);
257
258 /* store the non average value */
259 priv->SNR[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->SNR);
260 priv->NF[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->noisefloor);
261
262 priv->SNR[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgSNR);
263 priv->NF[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgnoisefloor);
264
265 priv->RSSI[TYPE_BEACON][TYPE_NOAVG] =
266 CAL_RSSI(priv->SNR[TYPE_BEACON][TYPE_NOAVG],
267 priv->NF[TYPE_BEACON][TYPE_NOAVG]);
268
269 priv->RSSI[TYPE_BEACON][TYPE_AVG] =
270 CAL_RSSI(priv->SNR[TYPE_BEACON][TYPE_AVG] / AVG_SCALE,
271 priv->NF[TYPE_BEACON][TYPE_AVG] / AVG_SCALE);
272
273 lbs_deb_cmd("RSSI: beacon %d, avg %d\n",
274 priv->RSSI[TYPE_BEACON][TYPE_NOAVG],
275 priv->RSSI[TYPE_BEACON][TYPE_AVG]);
276
277 lbs_deb_leave(LBS_DEB_CMD);
278 return 0;
279 }
280
281 static int lbs_ret_802_11_eeprom_access(struct lbs_private *priv,
282 struct cmd_ds_command *resp)
283 {
284 struct lbs_ioctl_regrdwr *pbuf;
285 pbuf = (struct lbs_ioctl_regrdwr *) priv->prdeeprom;
286
287 lbs_deb_enter_args(LBS_DEB_CMD, "len %d",
288 le16_to_cpu(resp->params.rdeeprom.bytecount));
289 if (pbuf->NOB < le16_to_cpu(resp->params.rdeeprom.bytecount)) {
290 pbuf->NOB = 0;
291 lbs_deb_cmd("EEPROM read length too big\n");
292 return -1;
293 }
294 pbuf->NOB = le16_to_cpu(resp->params.rdeeprom.bytecount);
295 if (pbuf->NOB > 0) {
296
297 memcpy(&pbuf->value, (u8 *) & resp->params.rdeeprom.value,
298 le16_to_cpu(resp->params.rdeeprom.bytecount));
299 lbs_deb_hex(LBS_DEB_CMD, "EEPROM", (char *)&pbuf->value,
300 le16_to_cpu(resp->params.rdeeprom.bytecount));
301 }
302 lbs_deb_leave(LBS_DEB_CMD);
303 return 0;
304 }
305
306 static int lbs_ret_get_log(struct lbs_private *priv,
307 struct cmd_ds_command *resp)
308 {
309 struct cmd_ds_802_11_get_log *logmessage = &resp->params.glog;
310
311 lbs_deb_enter(LBS_DEB_CMD);
312
313 /* Stored little-endian */
314 memcpy(&priv->logmsg, logmessage, sizeof(struct cmd_ds_802_11_get_log));
315
316 lbs_deb_leave(LBS_DEB_CMD);
317 return 0;
318 }
319
320 static int lbs_ret_802_11_bcn_ctrl(struct lbs_private * priv,
321 struct cmd_ds_command *resp)
322 {
323 struct cmd_ds_802_11_beacon_control *bcn_ctrl =
324 &resp->params.bcn_ctrl;
325
326 lbs_deb_enter(LBS_DEB_CMD);
327
328 if (bcn_ctrl->action == CMD_ACT_GET) {
329 priv->beacon_enable = (u8) le16_to_cpu(bcn_ctrl->beacon_enable);
330 priv->beacon_period = le16_to_cpu(bcn_ctrl->beacon_period);
331 }
332
333 lbs_deb_enter(LBS_DEB_CMD);
334 return 0;
335 }
336
337 static inline int handle_cmd_response(struct lbs_private *priv,
338 unsigned long dummy,
339 struct cmd_header *cmd_response)
340 {
341 struct cmd_ds_command *resp = (struct cmd_ds_command *) cmd_response;
342 int ret = 0;
343 unsigned long flags;
344 uint16_t respcmd = le16_to_cpu(resp->command);
345
346 lbs_deb_enter(LBS_DEB_HOST);
347
348 switch (respcmd) {
349 case CMD_RET(CMD_MAC_REG_ACCESS):
350 case CMD_RET(CMD_BBP_REG_ACCESS):
351 case CMD_RET(CMD_RF_REG_ACCESS):
352 ret = lbs_ret_reg_access(priv, respcmd, resp);
353 break;
354
355 case CMD_RET(CMD_802_11_SCAN):
356 ret = lbs_ret_80211_scan(priv, resp);
357 break;
358
359 case CMD_RET(CMD_802_11_GET_LOG):
360 ret = lbs_ret_get_log(priv, resp);
361 break;
362
363 case CMD_RET_802_11_ASSOCIATE:
364 case CMD_RET(CMD_802_11_ASSOCIATE):
365 case CMD_RET(CMD_802_11_REASSOCIATE):
366 ret = lbs_ret_80211_associate(priv, resp);
367 break;
368
369 case CMD_RET(CMD_802_11_DISASSOCIATE):
370 case CMD_RET(CMD_802_11_DEAUTHENTICATE):
371 ret = lbs_ret_80211_disassociate(priv, resp);
372 break;
373
374 case CMD_RET(CMD_802_11_AD_HOC_START):
375 case CMD_RET(CMD_802_11_AD_HOC_JOIN):
376 ret = lbs_ret_80211_ad_hoc_start(priv, resp);
377 break;
378
379 case CMD_RET(CMD_802_11_GET_STAT):
380 ret = lbs_ret_802_11_stat(priv, resp);
381 break;
382
383 case CMD_RET(CMD_802_11_SNMP_MIB):
384 ret = lbs_ret_802_11_snmp_mib(priv, resp);
385 break;
386
387 case CMD_RET(CMD_802_11_RF_TX_POWER):
388 ret = lbs_ret_802_11_rf_tx_power(priv, resp);
389 break;
390
391 case CMD_RET(CMD_802_11_SET_AFC):
392 case CMD_RET(CMD_802_11_GET_AFC):
393 spin_lock_irqsave(&priv->driver_lock, flags);
394 memmove((void *)priv->cur_cmd->callback_arg, &resp->params.afc,
395 sizeof(struct cmd_ds_802_11_afc));
396 spin_unlock_irqrestore(&priv->driver_lock, flags);
397
398 break;
399
400 case CMD_RET(CMD_MAC_MULTICAST_ADR):
401 case CMD_RET(CMD_MAC_CONTROL):
402 case CMD_RET(CMD_802_11_RESET):
403 case CMD_RET(CMD_802_11_AUTHENTICATE):
404 case CMD_RET(CMD_802_11_BEACON_STOP):
405 break;
406
407 case CMD_RET(CMD_802_11_RATE_ADAPT_RATESET):
408 ret = lbs_ret_802_11_rate_adapt_rateset(priv, resp);
409 break;
410
411 case CMD_RET(CMD_802_11_RSSI):
412 ret = lbs_ret_802_11_rssi(priv, resp);
413 break;
414
415 case CMD_RET(CMD_802_11_MAC_ADDRESS):
416 ret = lbs_ret_802_11_mac_address(priv, resp);
417 break;
418
419 case CMD_RET(CMD_802_11_AD_HOC_STOP):
420 ret = lbs_ret_80211_ad_hoc_stop(priv, resp);
421 break;
422
423 case CMD_RET(CMD_802_11_EEPROM_ACCESS):
424 ret = lbs_ret_802_11_eeprom_access(priv, resp);
425 break;
426
427 case CMD_RET(CMD_802_11D_DOMAIN_INFO):
428 ret = lbs_ret_802_11d_domain_info(priv, resp);
429 break;
430
431 case CMD_RET(CMD_802_11_TPC_CFG):
432 spin_lock_irqsave(&priv->driver_lock, flags);
433 memmove((void *)priv->cur_cmd->callback_arg, &resp->params.tpccfg,
434 sizeof(struct cmd_ds_802_11_tpc_cfg));
435 spin_unlock_irqrestore(&priv->driver_lock, flags);
436 break;
437 case CMD_RET(CMD_802_11_LED_GPIO_CTRL):
438 spin_lock_irqsave(&priv->driver_lock, flags);
439 memmove((void *)priv->cur_cmd->callback_arg, &resp->params.ledgpio,
440 sizeof(struct cmd_ds_802_11_led_ctrl));
441 spin_unlock_irqrestore(&priv->driver_lock, flags);
442 break;
443
444 case CMD_RET(CMD_802_11_PWR_CFG):
445 spin_lock_irqsave(&priv->driver_lock, flags);
446 memmove((void *)priv->cur_cmd->callback_arg, &resp->params.pwrcfg,
447 sizeof(struct cmd_ds_802_11_pwr_cfg));
448 spin_unlock_irqrestore(&priv->driver_lock, flags);
449
450 break;
451
452 case CMD_RET(CMD_GET_TSF):
453 spin_lock_irqsave(&priv->driver_lock, flags);
454 memcpy((void *)priv->cur_cmd->callback_arg,
455 &resp->params.gettsf.tsfvalue, sizeof(u64));
456 spin_unlock_irqrestore(&priv->driver_lock, flags);
457 break;
458 case CMD_RET(CMD_BT_ACCESS):
459 spin_lock_irqsave(&priv->driver_lock, flags);
460 if (priv->cur_cmd->callback_arg)
461 memcpy((void *)priv->cur_cmd->callback_arg,
462 &resp->params.bt.addr1, 2 * ETH_ALEN);
463 spin_unlock_irqrestore(&priv->driver_lock, flags);
464 break;
465 case CMD_RET(CMD_FWT_ACCESS):
466 spin_lock_irqsave(&priv->driver_lock, flags);
467 if (priv->cur_cmd->callback_arg)
468 memcpy((void *)priv->cur_cmd->callback_arg, &resp->params.fwt,
469 sizeof(resp->params.fwt));
470 spin_unlock_irqrestore(&priv->driver_lock, flags);
471 break;
472 case CMD_RET(CMD_802_11_BEACON_CTRL):
473 ret = lbs_ret_802_11_bcn_ctrl(priv, resp);
474 break;
475
476 default:
477 lbs_deb_host("CMD_RESP: unknown cmd response 0x%04x\n",
478 le16_to_cpu(resp->command));
479 break;
480 }
481 lbs_deb_leave(LBS_DEB_HOST);
482 return ret;
483 }
484
485 int lbs_process_rx_command(struct lbs_private *priv)
486 {
487 uint16_t respcmd, curcmd;
488 struct cmd_header *resp;
489 int ret = 0;
490 unsigned long flags;
491 uint16_t result;
492
493 lbs_deb_enter(LBS_DEB_HOST);
494
495 mutex_lock(&priv->lock);
496 spin_lock_irqsave(&priv->driver_lock, flags);
497
498 if (!priv->cur_cmd) {
499 lbs_deb_host("CMD_RESP: cur_cmd is NULL\n");
500 ret = -1;
501 spin_unlock_irqrestore(&priv->driver_lock, flags);
502 goto done;
503 }
504
505 resp = (void *)priv->upld_buf;
506 curcmd = le16_to_cpu(priv->cur_cmd->cmdbuf->command);
507 respcmd = le16_to_cpu(resp->command);
508 result = le16_to_cpu(resp->result);
509
510 lbs_deb_cmd("CMD_RESP: response 0x%04x, seq %d, size %d, jiffies %lu\n",
511 respcmd, le16_to_cpu(resp->seqnum), priv->upld_len, jiffies);
512 lbs_deb_hex(LBS_DEB_CMD, "CMD_RESP", (void *) resp, priv->upld_len);
513
514 if (resp->seqnum != priv->cur_cmd->cmdbuf->seqnum) {
515 lbs_pr_info("Received CMD_RESP with invalid sequence %d (expected %d)\n",
516 le16_to_cpu(resp->seqnum), le16_to_cpu(priv->cur_cmd->cmdbuf->seqnum));
517 spin_unlock_irqrestore(&priv->driver_lock, flags);
518 ret = -1;
519 goto done;
520 }
521 if (respcmd != CMD_RET(curcmd) &&
522 respcmd != CMD_802_11_ASSOCIATE && curcmd != CMD_RET_802_11_ASSOCIATE) {
523 lbs_pr_info("Invalid CMD_RESP %x to command %x!\n", respcmd, curcmd);
524 spin_unlock_irqrestore(&priv->driver_lock, flags);
525 ret = -1;
526 goto done;
527 }
528
529 if (resp->result == cpu_to_le16(0x0004)) {
530 /* 0x0004 means -EAGAIN. Drop the response, let it time out
531 and be resubmitted */
532 lbs_pr_info("Firmware returns DEFER to command %x. Will let it time out...\n",
533 le16_to_cpu(resp->command));
534 spin_unlock_irqrestore(&priv->driver_lock, flags);
535 ret = -1;
536 goto done;
537 }
538
539 /* Now we got response from FW, cancel the command timer */
540 del_timer(&priv->command_timer);
541 priv->cmd_timed_out = 0;
542 if (priv->nr_retries) {
543 lbs_pr_info("Received result %x to command %x after %d retries\n",
544 result, curcmd, priv->nr_retries);
545 priv->nr_retries = 0;
546 }
547
548 /* Store the response code to cur_cmd_retcode. */
549 priv->cur_cmd_retcode = result;
550
551 if (respcmd == CMD_RET(CMD_802_11_PS_MODE)) {
552 struct cmd_ds_802_11_ps_mode *psmode = (void *) &resp[1];
553 u16 action = le16_to_cpu(psmode->action);
554
555 lbs_deb_host(
556 "CMD_RESP: PS_MODE cmd reply result 0x%x, action 0x%x\n",
557 result, action);
558
559 if (result) {
560 lbs_deb_host("CMD_RESP: PS command failed with 0x%x\n",
561 result);
562 /*
563 * We should not re-try enter-ps command in
564 * ad-hoc mode. It takes place in
565 * lbs_execute_next_command().
566 */
567 if (priv->mode == IW_MODE_ADHOC &&
568 action == CMD_SUBCMD_ENTER_PS)
569 priv->psmode = LBS802_11POWERMODECAM;
570 } else if (action == CMD_SUBCMD_ENTER_PS) {
571 priv->needtowakeup = 0;
572 priv->psstate = PS_STATE_AWAKE;
573
574 lbs_deb_host("CMD_RESP: ENTER_PS command response\n");
575 if (priv->connect_status != LBS_CONNECTED) {
576 /*
577 * When Deauth Event received before Enter_PS command
578 * response, We need to wake up the firmware.
579 */
580 lbs_deb_host(
581 "disconnected, invoking lbs_ps_wakeup\n");
582
583 spin_unlock_irqrestore(&priv->driver_lock, flags);
584 mutex_unlock(&priv->lock);
585 lbs_ps_wakeup(priv, 0);
586 mutex_lock(&priv->lock);
587 spin_lock_irqsave(&priv->driver_lock, flags);
588 }
589 } else if (action == CMD_SUBCMD_EXIT_PS) {
590 priv->needtowakeup = 0;
591 priv->psstate = PS_STATE_FULL_POWER;
592 lbs_deb_host("CMD_RESP: EXIT_PS command response\n");
593 } else {
594 lbs_deb_host("CMD_RESP: PS action 0x%X\n", action);
595 }
596
597 lbs_complete_command(priv, priv->cur_cmd, result);
598 spin_unlock_irqrestore(&priv->driver_lock, flags);
599
600 ret = 0;
601 goto done;
602 }
603
604 /* If the command is not successful, cleanup and return failure */
605 if ((result != 0 || !(respcmd & 0x8000))) {
606 lbs_deb_host("CMD_RESP: error 0x%04x in command reply 0x%04x\n",
607 result, respcmd);
608 /*
609 * Handling errors here
610 */
611 switch (respcmd) {
612 case CMD_RET(CMD_GET_HW_SPEC):
613 case CMD_RET(CMD_802_11_RESET):
614 lbs_deb_host("CMD_RESP: reset failed\n");
615 break;
616
617 }
618 lbs_complete_command(priv, priv->cur_cmd, result);
619 spin_unlock_irqrestore(&priv->driver_lock, flags);
620
621 ret = -1;
622 goto done;
623 }
624
625 spin_unlock_irqrestore(&priv->driver_lock, flags);
626
627 if (priv->cur_cmd && priv->cur_cmd->callback) {
628 ret = priv->cur_cmd->callback(priv, priv->cur_cmd->callback_arg,
629 resp);
630 } else
631 ret = handle_cmd_response(priv, 0, resp);
632
633 spin_lock_irqsave(&priv->driver_lock, flags);
634
635 if (priv->cur_cmd) {
636 /* Clean up and Put current command back to cmdfreeq */
637 lbs_complete_command(priv, priv->cur_cmd, result);
638 }
639 spin_unlock_irqrestore(&priv->driver_lock, flags);
640
641 done:
642 mutex_unlock(&priv->lock);
643 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
644 return ret;
645 }
646
647 static int lbs_send_confirmwake(struct lbs_private *priv)
648 {
649 struct cmd_header *cmd = &priv->lbs_ps_confirm_wake;
650 int ret = 0;
651
652 lbs_deb_enter(LBS_DEB_HOST);
653
654 cmd->command = cpu_to_le16(CMD_802_11_WAKEUP_CONFIRM);
655 cmd->size = cpu_to_le16(sizeof(*cmd));
656 cmd->seqnum = cpu_to_le16(++priv->seqnum);
657 cmd->result = 0;
658
659 lbs_deb_host("SEND_WAKEC_CMD: before download\n");
660
661 lbs_deb_hex(LBS_DEB_HOST, "wake confirm command", (void *)cmd, sizeof(*cmd));
662
663 ret = priv->hw_host_to_card(priv, MVMS_CMD, (void *)cmd, sizeof(*cmd));
664 if (ret)
665 lbs_pr_alert("SEND_WAKEC_CMD: Host to Card failed for Confirm Wake\n");
666
667 lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
668 return ret;
669 }
670
671 int lbs_process_event(struct lbs_private *priv)
672 {
673 int ret = 0;
674 u32 eventcause;
675
676 lbs_deb_enter(LBS_DEB_CMD);
677
678 spin_lock_irq(&priv->driver_lock);
679 eventcause = priv->eventcause >> SBI_EVENT_CAUSE_SHIFT;
680 spin_unlock_irq(&priv->driver_lock);
681
682 lbs_deb_cmd("event cause %d\n", eventcause);
683
684 switch (eventcause) {
685 case MACREG_INT_CODE_LINK_SENSED:
686 lbs_deb_cmd("EVENT: MACREG_INT_CODE_LINK_SENSED\n");
687 break;
688
689 case MACREG_INT_CODE_DEAUTHENTICATED:
690 lbs_deb_cmd("EVENT: deauthenticated\n");
691 lbs_mac_event_disconnected(priv);
692 break;
693
694 case MACREG_INT_CODE_DISASSOCIATED:
695 lbs_deb_cmd("EVENT: disassociated\n");
696 lbs_mac_event_disconnected(priv);
697 break;
698
699 case MACREG_INT_CODE_LINK_LOST_NO_SCAN:
700 lbs_deb_cmd("EVENT: link lost\n");
701 lbs_mac_event_disconnected(priv);
702 break;
703
704 case MACREG_INT_CODE_PS_SLEEP:
705 lbs_deb_cmd("EVENT: sleep\n");
706
707 /* handle unexpected PS SLEEP event */
708 if (priv->psstate == PS_STATE_FULL_POWER) {
709 lbs_deb_cmd(
710 "EVENT: in FULL POWER mode, ignoreing PS_SLEEP\n");
711 break;
712 }
713 priv->psstate = PS_STATE_PRE_SLEEP;
714
715 lbs_ps_confirm_sleep(priv, (u16) priv->psmode);
716
717 break;
718
719 case MACREG_INT_CODE_HOST_AWAKE:
720 lbs_deb_cmd("EVENT: HOST_AWAKE\n");
721 lbs_send_confirmwake(priv);
722 break;
723
724 case MACREG_INT_CODE_PS_AWAKE:
725 lbs_deb_cmd("EVENT: awake\n");
726 /* handle unexpected PS AWAKE event */
727 if (priv->psstate == PS_STATE_FULL_POWER) {
728 lbs_deb_cmd(
729 "EVENT: In FULL POWER mode - ignore PS AWAKE\n");
730 break;
731 }
732
733 priv->psstate = PS_STATE_AWAKE;
734
735 if (priv->needtowakeup) {
736 /*
737 * wait for the command processing to finish
738 * before resuming sending
739 * priv->needtowakeup will be set to FALSE
740 * in lbs_ps_wakeup()
741 */
742 lbs_deb_cmd("waking up ...\n");
743 lbs_ps_wakeup(priv, 0);
744 }
745 break;
746
747 case MACREG_INT_CODE_MIC_ERR_UNICAST:
748 lbs_deb_cmd("EVENT: UNICAST MIC ERROR\n");
749 handle_mic_failureevent(priv, MACREG_INT_CODE_MIC_ERR_UNICAST);
750 break;
751
752 case MACREG_INT_CODE_MIC_ERR_MULTICAST:
753 lbs_deb_cmd("EVENT: MULTICAST MIC ERROR\n");
754 handle_mic_failureevent(priv, MACREG_INT_CODE_MIC_ERR_MULTICAST);
755 break;
756 case MACREG_INT_CODE_MIB_CHANGED:
757 case MACREG_INT_CODE_INIT_DONE:
758 break;
759
760 case MACREG_INT_CODE_ADHOC_BCN_LOST:
761 lbs_deb_cmd("EVENT: ADHOC beacon lost\n");
762 break;
763
764 case MACREG_INT_CODE_RSSI_LOW:
765 lbs_pr_alert("EVENT: rssi low\n");
766 break;
767 case MACREG_INT_CODE_SNR_LOW:
768 lbs_pr_alert("EVENT: snr low\n");
769 break;
770 case MACREG_INT_CODE_MAX_FAIL:
771 lbs_pr_alert("EVENT: max fail\n");
772 break;
773 case MACREG_INT_CODE_RSSI_HIGH:
774 lbs_pr_alert("EVENT: rssi high\n");
775 break;
776 case MACREG_INT_CODE_SNR_HIGH:
777 lbs_pr_alert("EVENT: snr high\n");
778 break;
779
780 case MACREG_INT_CODE_MESH_AUTO_STARTED:
781 /* Ignore spurious autostart events if autostart is disabled */
782 if (!priv->mesh_autostart_enabled) {
783 lbs_pr_info("EVENT: MESH_AUTO_STARTED (ignoring)\n");
784 break;
785 }
786 lbs_pr_info("EVENT: MESH_AUTO_STARTED\n");
787 priv->mesh_connect_status = LBS_CONNECTED;
788 if (priv->mesh_open) {
789 netif_carrier_on(priv->mesh_dev);
790 if (!priv->tx_pending_len)
791 netif_wake_queue(priv->mesh_dev);
792 }
793 priv->mode = IW_MODE_ADHOC;
794 schedule_work(&priv->sync_channel);
795 break;
796
797 default:
798 lbs_pr_alert("EVENT: unknown event id %d\n", eventcause);
799 break;
800 }
801
802 spin_lock_irq(&priv->driver_lock);
803 priv->eventcause = 0;
804 spin_unlock_irq(&priv->driver_lock);
805
806 lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
807 return ret;
808 }
kernel-based virtual machine