net: remove interrupt.h inclusion from netdevice.h
[linux-3.10.git] / drivers / net / wireless / libertas / cmdresp.c
index 9c18227..2ffe5a1 100644 (file)
@@ -1,7 +1,9 @@
-/**
-  * This file contains the handling of command
-  * responses as well as events generated by firmware.
-  */
+/*
+ * This file contains the handling of command
+ * responses as well as events generated by firmware.
+ */
+
+#include <linux/hardirq.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/sched.h>
 #include "cmd.h"
 
 /**
- *  @brief This function handles disconnect event. it
- *  reports disconnect to upper layer, clean tx/rx packets,
- *  reset link state etc.
+ * lbs_mac_event_disconnected - handles disconnect event. It
+ * reports disconnect to upper layer, clean tx/rx packets,
+ * reset link state etc.
+ *
+ * @priv:      A pointer to struct lbs_private structure
  *
- *  @param priv    A pointer to struct lbs_private structure
- *  @return       n/a
+ * returns:    n/a
  */
 void lbs_mac_event_disconnected(struct lbs_private *priv)
 {
@@ -31,7 +34,9 @@ void lbs_mac_event_disconnected(struct lbs_private *priv)
         * It causes problem in the Supplicant
         */
        msleep_interruptible(1000);
-       lbs_send_disconnect_notification(priv);
+
+       if (priv->wdev->iftype == NL80211_IFTYPE_STATION)
+               lbs_send_disconnect_notification(priv);
 
        /* report disconnect to upper layer */
        netif_stop_queue(priv->dev);
@@ -47,121 +52,11 @@ void lbs_mac_event_disconnected(struct lbs_private *priv)
        if (priv->psstate != PS_STATE_FULL_POWER) {
                /* make firmware to exit PS mode */
                lbs_deb_cmd("disconnected, so exit PS mode\n");
-               lbs_ps_wakeup(priv, 0);
+               lbs_set_ps_mode(priv, PS_MODE_ACTION_EXIT_PS, false);
        }
        lbs_deb_leave(LBS_DEB_ASSOC);
 }
 
-static int lbs_ret_reg_access(struct lbs_private *priv,
-                              u16 type, struct cmd_ds_command *resp)
-{
-       int ret = 0;
-
-       lbs_deb_enter(LBS_DEB_CMD);
-
-       switch (type) {
-       case CMD_RET(CMD_MAC_REG_ACCESS):
-               {
-                       struct cmd_ds_mac_reg_access *reg = &resp->params.macreg;
-
-                       priv->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
-                       priv->offsetvalue.value = le32_to_cpu(reg->value);
-                       break;
-               }
-
-       case CMD_RET(CMD_BBP_REG_ACCESS):
-               {
-                       struct cmd_ds_bbp_reg_access *reg = &resp->params.bbpreg;
-
-                       priv->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
-                       priv->offsetvalue.value = reg->value;
-                       break;
-               }
-
-       case CMD_RET(CMD_RF_REG_ACCESS):
-               {
-                       struct cmd_ds_rf_reg_access *reg = &resp->params.rfreg;
-
-                       priv->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
-                       priv->offsetvalue.value = reg->value;
-                       break;
-               }
-
-       default:
-               ret = -1;
-       }
-
-       lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
-       return ret;
-}
-
-static inline int handle_cmd_response(struct lbs_private *priv,
-                                     struct cmd_header *cmd_response)
-{
-       struct cmd_ds_command *resp = (struct cmd_ds_command *) cmd_response;
-       int ret = 0;
-       unsigned long flags;
-       uint16_t respcmd = le16_to_cpu(resp->command);
-
-       lbs_deb_enter(LBS_DEB_HOST);
-
-       switch (respcmd) {
-       case CMD_RET(CMD_MAC_REG_ACCESS):
-       case CMD_RET(CMD_BBP_REG_ACCESS):
-       case CMD_RET(CMD_RF_REG_ACCESS):
-               ret = lbs_ret_reg_access(priv, respcmd, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_SET_AFC):
-       case CMD_RET(CMD_802_11_GET_AFC):
-               spin_lock_irqsave(&priv->driver_lock, flags);
-               memmove((void *)priv->cur_cmd->callback_arg, &resp->params.afc,
-                       sizeof(struct cmd_ds_802_11_afc));
-               spin_unlock_irqrestore(&priv->driver_lock, flags);
-
-               break;
-
-       case CMD_RET(CMD_802_11_BEACON_STOP):
-               break;
-
-       case CMD_RET(CMD_802_11_RSSI):
-               ret = lbs_ret_802_11_rssi(priv, resp);
-               break;
-
-       case CMD_RET(CMD_802_11_TPC_CFG):
-               spin_lock_irqsave(&priv->driver_lock, flags);
-               memmove((void *)priv->cur_cmd->callback_arg, &resp->params.tpccfg,
-                       sizeof(struct cmd_ds_802_11_tpc_cfg));
-               spin_unlock_irqrestore(&priv->driver_lock, flags);
-               break;
-
-       case CMD_RET(CMD_BT_ACCESS):
-               spin_lock_irqsave(&priv->driver_lock, flags);
-               if (priv->cur_cmd->callback_arg)
-                       memcpy((void *)priv->cur_cmd->callback_arg,
-                              &resp->params.bt.addr1, 2 * ETH_ALEN);
-               spin_unlock_irqrestore(&priv->driver_lock, flags);
-               break;
-       case CMD_RET(CMD_FWT_ACCESS):
-               spin_lock_irqsave(&priv->driver_lock, flags);
-               if (priv->cur_cmd->callback_arg)
-                       memcpy((void *)priv->cur_cmd->callback_arg, &resp->params.fwt,
-                              sizeof(resp->params.fwt));
-               spin_unlock_irqrestore(&priv->driver_lock, flags);
-               break;
-       case CMD_RET(CMD_802_11_BEACON_CTRL):
-               ret = lbs_ret_802_11_bcn_ctrl(priv, resp);
-               break;
-
-       default:
-               lbs_pr_err("CMD_RESP: unknown cmd response 0x%04x\n",
-                          le16_to_cpu(resp->command));
-               break;
-       }
-       lbs_deb_leave(LBS_DEB_HOST);
-       return ret;
-}
-
 int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
 {
        uint16_t respcmd, curcmd;
@@ -192,15 +87,18 @@ int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
        lbs_deb_hex(LBS_DEB_CMD, "CMD_RESP", (void *) resp, len);
 
        if (resp->seqnum != priv->cur_cmd->cmdbuf->seqnum) {
-               lbs_pr_info("Received CMD_RESP with invalid sequence %d (expected %d)\n",
-                           le16_to_cpu(resp->seqnum), le16_to_cpu(priv->cur_cmd->cmdbuf->seqnum));
+               netdev_info(priv->dev,
+                           "Received CMD_RESP with invalid sequence %d (expected %d)\n",
+                           le16_to_cpu(resp->seqnum),
+                           le16_to_cpu(priv->cur_cmd->cmdbuf->seqnum));
                spin_unlock_irqrestore(&priv->driver_lock, flags);
                ret = -1;
                goto done;
        }
        if (respcmd != CMD_RET(curcmd) &&
            respcmd != CMD_RET_802_11_ASSOCIATE && curcmd != CMD_802_11_ASSOCIATE) {
-               lbs_pr_info("Invalid CMD_RESP %x to command %x!\n", respcmd, curcmd);
+               netdev_info(priv->dev, "Invalid CMD_RESP %x to command %x!\n",
+                           respcmd, curcmd);
                spin_unlock_irqrestore(&priv->driver_lock, flags);
                ret = -1;
                goto done;
@@ -209,7 +107,8 @@ int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
        if (resp->result == cpu_to_le16(0x0004)) {
                /* 0x0004 means -EAGAIN. Drop the response, let it time out
                   and be resubmitted */
-               lbs_pr_info("Firmware returns DEFER to command %x. Will let it time out...\n",
+               netdev_info(priv->dev,
+                           "Firmware returns DEFER to command %x. Will let it time out...\n",
                            le16_to_cpu(resp->command));
                spin_unlock_irqrestore(&priv->driver_lock, flags);
                ret = -1;
@@ -220,9 +119,6 @@ int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
        del_timer(&priv->command_timer);
        priv->cmd_timed_out = 0;
 
-       /* Store the response code to cur_cmd_retcode. */
-       priv->cur_cmd_retcode = result;
-
        if (respcmd == CMD_RET(CMD_802_11_PS_MODE)) {
                struct cmd_ds_802_11_ps_mode *psmode = (void *) &resp[1];
                u16 action = le16_to_cpu(psmode->action);
@@ -240,9 +136,9 @@ int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
                         * lbs_execute_next_command().
                         */
                        if (priv->wdev->iftype == NL80211_IFTYPE_MONITOR &&
-                           action == CMD_SUBCMD_ENTER_PS)
+                           action == PS_MODE_ACTION_ENTER_PS)
                                priv->psmode = LBS802_11POWERMODECAM;
-               } else if (action == CMD_SUBCMD_ENTER_PS) {
+               } else if (action == PS_MODE_ACTION_ENTER_PS) {
                        priv->needtowakeup = 0;
                        priv->psstate = PS_STATE_AWAKE;
 
@@ -257,11 +153,12 @@ int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
 
                                spin_unlock_irqrestore(&priv->driver_lock, flags);
                                mutex_unlock(&priv->lock);
-                               lbs_ps_wakeup(priv, 0);
+                               lbs_set_ps_mode(priv, PS_MODE_ACTION_EXIT_PS,
+                                               false);
                                mutex_lock(&priv->lock);
                                spin_lock_irqsave(&priv->driver_lock, flags);
                        }
-               } else if (action == CMD_SUBCMD_EXIT_PS) {
+               } else if (action == PS_MODE_ACTION_EXIT_PS) {
                        priv->needtowakeup = 0;
                        priv->psstate = PS_STATE_FULL_POWER;
                        lbs_deb_host("CMD_RESP: EXIT_PS command response\n");
@@ -302,8 +199,7 @@ int lbs_process_command_response(struct lbs_private *priv, u8 *data, u32 len)
        if (priv->cur_cmd && priv->cur_cmd->callback) {
                ret = priv->cur_cmd->callback(priv, priv->cur_cmd->callback_arg,
                                resp);
-       } else
-               ret = handle_cmd_response(priv, resp);
+       }
 
        spin_lock_irqsave(&priv->driver_lock, flags);
 
@@ -400,7 +296,7 @@ int lbs_process_event(struct lbs_private *priv, u32 event)
                         * in lbs_ps_wakeup()
                         */
                        lbs_deb_cmd("waking up ...\n");
-                       lbs_ps_wakeup(priv, 0);
+                       lbs_set_ps_mode(priv, PS_MODE_ACTION_EXIT_PS, false);
                }
                break;
 
@@ -424,28 +320,28 @@ int lbs_process_event(struct lbs_private *priv, u32 event)
                lbs_deb_cmd("EVENT: ADHOC beacon lost\n");
                break;
        case MACREG_INT_CODE_RSSI_LOW:
-               lbs_pr_alert("EVENT: rssi low\n");
+               netdev_alert(priv->dev, "EVENT: rssi low\n");
                break;
        case MACREG_INT_CODE_SNR_LOW:
-               lbs_pr_alert("EVENT: snr low\n");
+               netdev_alert(priv->dev, "EVENT: snr low\n");
                break;
        case MACREG_INT_CODE_MAX_FAIL:
-               lbs_pr_alert("EVENT: max fail\n");
+               netdev_alert(priv->dev, "EVENT: max fail\n");
                break;
        case MACREG_INT_CODE_RSSI_HIGH:
-               lbs_pr_alert("EVENT: rssi high\n");
+               netdev_alert(priv->dev, "EVENT: rssi high\n");
                break;
        case MACREG_INT_CODE_SNR_HIGH:
-               lbs_pr_alert("EVENT: snr high\n");
+               netdev_alert(priv->dev, "EVENT: snr high\n");
                break;
 
        case MACREG_INT_CODE_MESH_AUTO_STARTED:
                /* Ignore spurious autostart events */
-               lbs_pr_info("EVENT: MESH_AUTO_STARTED (ignoring)\n");
+               netdev_info(priv->dev, "EVENT: MESH_AUTO_STARTED (ignoring)\n");
                break;
 
        default:
-               lbs_pr_alert("EVENT: unknown event id %d\n", event);
+               netdev_alert(priv->dev, "EVENT: unknown event id %d\n", event);
                break;
        }