Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 1 | /****************************************************************************** |
| 2 | * |
| 3 | * GPL LICENSE SUMMARY |
| 4 | * |
| 5 | * Copyright(c) 2008 Intel Corporation. All rights reserved. |
| 6 | * |
| 7 | * This program is free software; you can redistribute it and/or modify |
| 8 | * it under the terms of version 2 of the GNU General Public License as |
| 9 | * published by the Free Software Foundation. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, but |
| 12 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 14 | * General Public License for more details. |
| 15 | * |
| 16 | * You should have received a copy of the GNU General Public License |
| 17 | * along with this program; if not, write to the Free Software |
| 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, |
| 19 | * USA |
| 20 | * |
| 21 | * The full GNU General Public License is included in this distribution |
| 22 | * in the file called LICENSE.GPL. |
| 23 | * |
| 24 | * Contact Information: |
| 25 | * Tomas Winkler <tomas.winkler@intel.com> |
| 26 | * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 |
| 27 | *****************************************************************************/ |
| 28 | |
| 29 | #include <linux/kernel.h> |
| 30 | #include <linux/module.h> |
| 31 | #include <linux/version.h> |
| 32 | #include <net/mac80211.h> |
| 33 | |
Tomas Winkler | 3e0d4cb | 2008-04-24 11:55:38 -0700 | [diff] [blame] | 34 | #include "iwl-dev.h" /* FIXME: remove */ |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 35 | #include "iwl-debug.h" |
| 36 | #include "iwl-eeprom.h" |
| 37 | #include "iwl-core.h" |
| 38 | |
| 39 | |
| 40 | #define IWL_CMD(x) case x : return #x |
| 41 | |
| 42 | const char *get_cmd_string(u8 cmd) |
| 43 | { |
| 44 | switch (cmd) { |
| 45 | IWL_CMD(REPLY_ALIVE); |
| 46 | IWL_CMD(REPLY_ERROR); |
| 47 | IWL_CMD(REPLY_RXON); |
| 48 | IWL_CMD(REPLY_RXON_ASSOC); |
| 49 | IWL_CMD(REPLY_QOS_PARAM); |
| 50 | IWL_CMD(REPLY_RXON_TIMING); |
| 51 | IWL_CMD(REPLY_ADD_STA); |
| 52 | IWL_CMD(REPLY_REMOVE_STA); |
| 53 | IWL_CMD(REPLY_REMOVE_ALL_STA); |
Emmanuel Grumbach | 0a0bed1 | 2008-04-14 21:16:05 -0700 | [diff] [blame] | 54 | IWL_CMD(REPLY_WEPKEY); |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 55 | IWL_CMD(REPLY_TX); |
| 56 | IWL_CMD(REPLY_RATE_SCALE); |
| 57 | IWL_CMD(REPLY_LEDS_CMD); |
| 58 | IWL_CMD(REPLY_TX_LINK_QUALITY_CMD); |
Tomas Winkler | 7c616cb | 2008-05-29 16:35:05 +0800 | [diff] [blame] | 59 | IWL_CMD(COEX_PRIORITY_TABLE_CMD); |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 60 | IWL_CMD(RADAR_NOTIFICATION); |
| 61 | IWL_CMD(REPLY_QUIET_CMD); |
| 62 | IWL_CMD(REPLY_CHANNEL_SWITCH); |
| 63 | IWL_CMD(CHANNEL_SWITCH_NOTIFICATION); |
| 64 | IWL_CMD(REPLY_SPECTRUM_MEASUREMENT_CMD); |
| 65 | IWL_CMD(SPECTRUM_MEASURE_NOTIFICATION); |
| 66 | IWL_CMD(POWER_TABLE_CMD); |
| 67 | IWL_CMD(PM_SLEEP_NOTIFICATION); |
| 68 | IWL_CMD(PM_DEBUG_STATISTIC_NOTIFIC); |
| 69 | IWL_CMD(REPLY_SCAN_CMD); |
| 70 | IWL_CMD(REPLY_SCAN_ABORT_CMD); |
| 71 | IWL_CMD(SCAN_START_NOTIFICATION); |
| 72 | IWL_CMD(SCAN_RESULTS_NOTIFICATION); |
| 73 | IWL_CMD(SCAN_COMPLETE_NOTIFICATION); |
| 74 | IWL_CMD(BEACON_NOTIFICATION); |
| 75 | IWL_CMD(REPLY_TX_BEACON); |
| 76 | IWL_CMD(WHO_IS_AWAKE_NOTIFICATION); |
| 77 | IWL_CMD(QUIET_NOTIFICATION); |
| 78 | IWL_CMD(REPLY_TX_PWR_TABLE_CMD); |
| 79 | IWL_CMD(MEASURE_ABORT_NOTIFICATION); |
| 80 | IWL_CMD(REPLY_BT_CONFIG); |
| 81 | IWL_CMD(REPLY_STATISTICS_CMD); |
| 82 | IWL_CMD(STATISTICS_NOTIFICATION); |
| 83 | IWL_CMD(REPLY_CARD_STATE_CMD); |
| 84 | IWL_CMD(CARD_STATE_NOTIFICATION); |
| 85 | IWL_CMD(MISSED_BEACONS_NOTIFICATION); |
| 86 | IWL_CMD(REPLY_CT_KILL_CONFIG_CMD); |
| 87 | IWL_CMD(SENSITIVITY_CMD); |
| 88 | IWL_CMD(REPLY_PHY_CALIBRATION_CMD); |
| 89 | IWL_CMD(REPLY_RX_PHY_CMD); |
| 90 | IWL_CMD(REPLY_RX_MPDU_CMD); |
| 91 | IWL_CMD(REPLY_RX); |
| 92 | IWL_CMD(REPLY_COMPRESSED_BA); |
Tomas Winkler | 7c616cb | 2008-05-29 16:35:05 +0800 | [diff] [blame] | 93 | IWL_CMD(CALIBRATION_CFG_CMD); |
| 94 | IWL_CMD(CALIBRATION_RES_NOTIFICATION); |
| 95 | IWL_CMD(CALIBRATION_COMPLETE_NOTIFICATION); |
Emmanuel Grumbach | ebbbdc3 | 2008-06-30 17:23:05 +0800 | [diff] [blame] | 96 | IWL_CMD(REPLY_TX_POWER_DBM_CMD); |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 97 | default: |
| 98 | return "UNKNOWN"; |
| 99 | |
| 100 | } |
| 101 | } |
| 102 | EXPORT_SYMBOL(get_cmd_string); |
| 103 | |
| 104 | #define HOST_COMPLETE_TIMEOUT (HZ / 2) |
| 105 | |
Emmanuel Grumbach | 0472f88 | 2008-03-25 16:33:40 -0700 | [diff] [blame] | 106 | static int iwl_generic_cmd_callback(struct iwl_priv *priv, |
| 107 | struct iwl_cmd *cmd, struct sk_buff *skb) |
| 108 | { |
Tomas Winkler | db11d63 | 2008-05-05 10:22:33 +0800 | [diff] [blame] | 109 | struct iwl_rx_packet *pkt = NULL; |
Emmanuel Grumbach | 0472f88 | 2008-03-25 16:33:40 -0700 | [diff] [blame] | 110 | |
| 111 | if (!skb) { |
| 112 | IWL_ERROR("Error: Response NULL in %s.\n", |
| 113 | get_cmd_string(cmd->hdr.cmd)); |
| 114 | return 1; |
| 115 | } |
| 116 | |
Tomas Winkler | db11d63 | 2008-05-05 10:22:33 +0800 | [diff] [blame] | 117 | pkt = (struct iwl_rx_packet *)skb->data; |
Emmanuel Grumbach | 0472f88 | 2008-03-25 16:33:40 -0700 | [diff] [blame] | 118 | if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) { |
| 119 | IWL_ERROR("Bad return from %s (0x%08X)\n", |
| 120 | get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags); |
| 121 | return 1; |
| 122 | } |
| 123 | |
| 124 | IWL_DEBUG_HC("back from %s (0x%08X)\n", |
| 125 | get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags); |
| 126 | |
| 127 | /* Let iwl_tx_complete free the response skb */ |
| 128 | return 1; |
| 129 | } |
| 130 | |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 131 | static int iwl_send_cmd_async(struct iwl_priv *priv, struct iwl_host_cmd *cmd) |
| 132 | { |
| 133 | int ret; |
| 134 | |
| 135 | BUG_ON(!(cmd->meta.flags & CMD_ASYNC)); |
| 136 | |
| 137 | /* An asynchronous command can not expect an SKB to be set. */ |
| 138 | BUG_ON(cmd->meta.flags & CMD_WANT_SKB); |
| 139 | |
Emmanuel Grumbach | 0472f88 | 2008-03-25 16:33:40 -0700 | [diff] [blame] | 140 | /* Assign a generic callback if one is not provided */ |
| 141 | if (!cmd->meta.u.callback) |
| 142 | cmd->meta.u.callback = iwl_generic_cmd_callback; |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 143 | |
| 144 | if (test_bit(STATUS_EXIT_PENDING, &priv->status)) |
| 145 | return -EBUSY; |
| 146 | |
Tomas Winkler | fd4abac | 2008-05-15 13:54:07 +0800 | [diff] [blame] | 147 | ret = iwl_enqueue_hcmd(priv, cmd); |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 148 | if (ret < 0) { |
| 149 | IWL_ERROR("Error sending %s: enqueue_hcmd failed: %d\n", |
| 150 | get_cmd_string(cmd->id), ret); |
| 151 | return ret; |
| 152 | } |
| 153 | return 0; |
| 154 | } |
| 155 | |
| 156 | int iwl_send_cmd_sync(struct iwl_priv *priv, struct iwl_host_cmd *cmd) |
| 157 | { |
| 158 | int cmd_idx; |
| 159 | int ret; |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 160 | |
| 161 | BUG_ON(cmd->meta.flags & CMD_ASYNC); |
| 162 | |
| 163 | /* A synchronous command can not have a callback set. */ |
| 164 | BUG_ON(cmd->meta.u.callback != NULL); |
| 165 | |
Tomas Winkler | e547297 | 2008-03-28 16:21:12 -0700 | [diff] [blame] | 166 | if (test_and_set_bit(STATUS_HCMD_SYNC_ACTIVE, &priv->status)) { |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 167 | IWL_ERROR("Error sending %s: Already sending a host command\n", |
| 168 | get_cmd_string(cmd->id)); |
Tomas Winkler | e547297 | 2008-03-28 16:21:12 -0700 | [diff] [blame] | 169 | ret = -EBUSY; |
| 170 | goto out; |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 171 | } |
| 172 | |
| 173 | set_bit(STATUS_HCMD_ACTIVE, &priv->status); |
| 174 | |
| 175 | if (cmd->meta.flags & CMD_WANT_SKB) |
| 176 | cmd->meta.source = &cmd->meta; |
| 177 | |
Tomas Winkler | fd4abac | 2008-05-15 13:54:07 +0800 | [diff] [blame] | 178 | cmd_idx = iwl_enqueue_hcmd(priv, cmd); |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 179 | if (cmd_idx < 0) { |
| 180 | ret = cmd_idx; |
| 181 | IWL_ERROR("Error sending %s: enqueue_hcmd failed: %d\n", |
| 182 | get_cmd_string(cmd->id), ret); |
| 183 | goto out; |
| 184 | } |
| 185 | |
| 186 | ret = wait_event_interruptible_timeout(priv->wait_command_queue, |
| 187 | !test_bit(STATUS_HCMD_ACTIVE, &priv->status), |
| 188 | HOST_COMPLETE_TIMEOUT); |
| 189 | if (!ret) { |
| 190 | if (test_bit(STATUS_HCMD_ACTIVE, &priv->status)) { |
| 191 | IWL_ERROR("Error sending %s: time out after %dms.\n", |
| 192 | get_cmd_string(cmd->id), |
| 193 | jiffies_to_msecs(HOST_COMPLETE_TIMEOUT)); |
| 194 | |
| 195 | clear_bit(STATUS_HCMD_ACTIVE, &priv->status); |
| 196 | ret = -ETIMEDOUT; |
| 197 | goto cancel; |
| 198 | } |
| 199 | } |
| 200 | |
| 201 | if (test_bit(STATUS_RF_KILL_HW, &priv->status)) { |
| 202 | IWL_DEBUG_INFO("Command %s aborted: RF KILL Switch\n", |
| 203 | get_cmd_string(cmd->id)); |
| 204 | ret = -ECANCELED; |
| 205 | goto fail; |
| 206 | } |
| 207 | if (test_bit(STATUS_FW_ERROR, &priv->status)) { |
| 208 | IWL_DEBUG_INFO("Command %s failed: FW Error\n", |
| 209 | get_cmd_string(cmd->id)); |
| 210 | ret = -EIO; |
| 211 | goto fail; |
| 212 | } |
| 213 | if ((cmd->meta.flags & CMD_WANT_SKB) && !cmd->meta.u.skb) { |
| 214 | IWL_ERROR("Error: Response NULL in '%s'\n", |
| 215 | get_cmd_string(cmd->id)); |
| 216 | ret = -EIO; |
| 217 | goto out; |
| 218 | } |
| 219 | |
| 220 | ret = 0; |
| 221 | goto out; |
| 222 | |
| 223 | cancel: |
| 224 | if (cmd->meta.flags & CMD_WANT_SKB) { |
| 225 | struct iwl_cmd *qcmd; |
| 226 | |
| 227 | /* Cancel the CMD_WANT_SKB flag for the cmd in the |
| 228 | * TX cmd queue. Otherwise in case the cmd comes |
| 229 | * in later, it will possibly set an invalid |
| 230 | * address (cmd->meta.source). */ |
| 231 | qcmd = &priv->txq[IWL_CMD_QUEUE_NUM].cmd[cmd_idx]; |
| 232 | qcmd->meta.flags &= ~CMD_WANT_SKB; |
| 233 | } |
| 234 | fail: |
| 235 | if (cmd->meta.u.skb) { |
| 236 | dev_kfree_skb_any(cmd->meta.u.skb); |
| 237 | cmd->meta.u.skb = NULL; |
| 238 | } |
| 239 | out: |
Tomas Winkler | e547297 | 2008-03-28 16:21:12 -0700 | [diff] [blame] | 240 | clear_bit(STATUS_HCMD_SYNC_ACTIVE, &priv->status); |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 241 | return ret; |
| 242 | } |
| 243 | EXPORT_SYMBOL(iwl_send_cmd_sync); |
| 244 | |
| 245 | int iwl_send_cmd(struct iwl_priv *priv, struct iwl_host_cmd *cmd) |
| 246 | { |
| 247 | if (cmd->meta.flags & CMD_ASYNC) |
| 248 | return iwl_send_cmd_async(priv, cmd); |
| 249 | |
| 250 | return iwl_send_cmd_sync(priv, cmd); |
| 251 | } |
| 252 | EXPORT_SYMBOL(iwl_send_cmd); |
| 253 | |
| 254 | int iwl_send_cmd_pdu(struct iwl_priv *priv, u8 id, u16 len, const void *data) |
| 255 | { |
| 256 | struct iwl_host_cmd cmd = { |
| 257 | .id = id, |
| 258 | .len = len, |
| 259 | .data = data, |
| 260 | }; |
| 261 | |
| 262 | return iwl_send_cmd_sync(priv, &cmd); |
| 263 | } |
| 264 | EXPORT_SYMBOL(iwl_send_cmd_pdu); |
| 265 | |
| 266 | int iwl_send_cmd_pdu_async(struct iwl_priv *priv, |
| 267 | u8 id, u16 len, const void *data, |
| 268 | int (*callback)(struct iwl_priv *priv, |
| 269 | struct iwl_cmd *cmd, |
| 270 | struct sk_buff *skb)) |
| 271 | { |
| 272 | struct iwl_host_cmd cmd = { |
| 273 | .id = id, |
| 274 | .len = len, |
| 275 | .data = data, |
| 276 | }; |
| 277 | |
| 278 | cmd.meta.flags |= CMD_ASYNC; |
| 279 | cmd.meta.u.callback = callback; |
| 280 | |
| 281 | return iwl_send_cmd_async(priv, &cmd); |
| 282 | } |
| 283 | EXPORT_SYMBOL(iwl_send_cmd_pdu_async); |