Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 1 | /****************************************************************************** |
| 2 | * |
| 3 | * GPL LICENSE SUMMARY |
| 4 | * |
Reinette Chatre | 01f8162 | 2009-01-08 10:20:02 -0800 | [diff] [blame] | 5 | * Copyright(c) 2008 - 2009 Intel Corporation. All rights reserved. |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 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: |
Winkler, Tomas | 759ef89 | 2008-12-09 11:28:58 -0800 | [diff] [blame] | 25 | * Intel Linux Wireless <ilw@linux.intel.com> |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 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> |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 31 | #include <net/mac80211.h> |
| 32 | |
Tomas Winkler | 3e0d4cb | 2008-04-24 11:55:38 -0700 | [diff] [blame] | 33 | #include "iwl-dev.h" /* FIXME: remove */ |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 34 | #include "iwl-debug.h" |
| 35 | #include "iwl-eeprom.h" |
| 36 | #include "iwl-core.h" |
| 37 | |
| 38 | |
Abhijeet Kolekar | c305606 | 2008-11-12 13:14:08 -0800 | [diff] [blame] | 39 | #define IWL_CMD(x) case x: return #x |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 40 | |
| 41 | const char *get_cmd_string(u8 cmd) |
| 42 | { |
| 43 | switch (cmd) { |
| 44 | IWL_CMD(REPLY_ALIVE); |
| 45 | IWL_CMD(REPLY_ERROR); |
| 46 | IWL_CMD(REPLY_RXON); |
| 47 | IWL_CMD(REPLY_RXON_ASSOC); |
| 48 | IWL_CMD(REPLY_QOS_PARAM); |
| 49 | IWL_CMD(REPLY_RXON_TIMING); |
| 50 | IWL_CMD(REPLY_ADD_STA); |
| 51 | IWL_CMD(REPLY_REMOVE_STA); |
| 52 | IWL_CMD(REPLY_REMOVE_ALL_STA); |
Emmanuel Grumbach | 0a0bed1 | 2008-04-14 21:16:05 -0700 | [diff] [blame] | 53 | IWL_CMD(REPLY_WEPKEY); |
Samuel Ortiz | d732129 | 2009-01-08 10:20:00 -0800 | [diff] [blame] | 54 | IWL_CMD(REPLY_3945_RX); |
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) { |
Winkler, Tomas | 15b1687 | 2008-12-19 10:37:33 +0800 | [diff] [blame] | 112 | IWL_ERR(priv, "Error: Response NULL in %s.\n", |
Emmanuel Grumbach | 0472f88 | 2008-03-25 16:33:40 -0700 | [diff] [blame] | 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) { |
Winkler, Tomas | 15b1687 | 2008-12-19 10:37:33 +0800 | [diff] [blame] | 119 | IWL_ERR(priv, "Bad return from %s (0x%08X)\n", |
Emmanuel Grumbach | 0472f88 | 2008-03-25 16:33:40 -0700 | [diff] [blame] | 120 | get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags); |
| 121 | return 1; |
| 122 | } |
| 123 | |
Esti Kummer | ded2ae7 | 2008-08-04 16:00:45 +0800 | [diff] [blame] | 124 | #ifdef CONFIG_IWLWIFI_DEBUG |
| 125 | switch (cmd->hdr.cmd) { |
| 126 | case REPLY_TX_LINK_QUALITY_CMD: |
| 127 | case SENSITIVITY_CMD: |
Tomas Winkler | e162344 | 2009-01-27 14:27:56 -0800 | [diff] [blame] | 128 | IWL_DEBUG_HC_DUMP(priv, "back from %s (0x%08X)\n", |
Esti Kummer | ded2ae7 | 2008-08-04 16:00:45 +0800 | [diff] [blame] | 129 | get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags); |
| 130 | break; |
| 131 | default: |
Tomas Winkler | e162344 | 2009-01-27 14:27:56 -0800 | [diff] [blame] | 132 | IWL_DEBUG_HC(priv, "back from %s (0x%08X)\n", |
Esti Kummer | ded2ae7 | 2008-08-04 16:00:45 +0800 | [diff] [blame] | 133 | get_cmd_string(cmd->hdr.cmd), pkt->hdr.flags); |
| 134 | } |
| 135 | #endif |
Emmanuel Grumbach | 0472f88 | 2008-03-25 16:33:40 -0700 | [diff] [blame] | 136 | |
| 137 | /* Let iwl_tx_complete free the response skb */ |
| 138 | return 1; |
| 139 | } |
| 140 | |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 141 | static int iwl_send_cmd_async(struct iwl_priv *priv, struct iwl_host_cmd *cmd) |
| 142 | { |
| 143 | int ret; |
| 144 | |
| 145 | BUG_ON(!(cmd->meta.flags & CMD_ASYNC)); |
| 146 | |
| 147 | /* An asynchronous command can not expect an SKB to be set. */ |
| 148 | BUG_ON(cmd->meta.flags & CMD_WANT_SKB); |
| 149 | |
Emmanuel Grumbach | 0472f88 | 2008-03-25 16:33:40 -0700 | [diff] [blame] | 150 | /* Assign a generic callback if one is not provided */ |
| 151 | if (!cmd->meta.u.callback) |
| 152 | cmd->meta.u.callback = iwl_generic_cmd_callback; |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 153 | |
| 154 | if (test_bit(STATUS_EXIT_PENDING, &priv->status)) |
| 155 | return -EBUSY; |
| 156 | |
Tomas Winkler | fd4abac | 2008-05-15 13:54:07 +0800 | [diff] [blame] | 157 | ret = iwl_enqueue_hcmd(priv, cmd); |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 158 | if (ret < 0) { |
Winkler, Tomas | 15b1687 | 2008-12-19 10:37:33 +0800 | [diff] [blame] | 159 | IWL_ERR(priv, "Error sending %s: enqueue_hcmd failed: %d\n", |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 160 | get_cmd_string(cmd->id), ret); |
| 161 | return ret; |
| 162 | } |
| 163 | return 0; |
| 164 | } |
| 165 | |
| 166 | int iwl_send_cmd_sync(struct iwl_priv *priv, struct iwl_host_cmd *cmd) |
| 167 | { |
| 168 | int cmd_idx; |
| 169 | int ret; |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 170 | |
| 171 | BUG_ON(cmd->meta.flags & CMD_ASYNC); |
| 172 | |
| 173 | /* A synchronous command can not have a callback set. */ |
| 174 | BUG_ON(cmd->meta.u.callback != NULL); |
| 175 | |
Tomas Winkler | e547297 | 2008-03-28 16:21:12 -0700 | [diff] [blame] | 176 | if (test_and_set_bit(STATUS_HCMD_SYNC_ACTIVE, &priv->status)) { |
Winkler, Tomas | 15b1687 | 2008-12-19 10:37:33 +0800 | [diff] [blame] | 177 | IWL_ERR(priv, |
| 178 | "Error sending %s: Already sending a host command\n", |
| 179 | get_cmd_string(cmd->id)); |
Tomas Winkler | e547297 | 2008-03-28 16:21:12 -0700 | [diff] [blame] | 180 | ret = -EBUSY; |
| 181 | goto out; |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 182 | } |
| 183 | |
| 184 | set_bit(STATUS_HCMD_ACTIVE, &priv->status); |
| 185 | |
| 186 | if (cmd->meta.flags & CMD_WANT_SKB) |
| 187 | cmd->meta.source = &cmd->meta; |
| 188 | |
Tomas Winkler | fd4abac | 2008-05-15 13:54:07 +0800 | [diff] [blame] | 189 | cmd_idx = iwl_enqueue_hcmd(priv, cmd); |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 190 | if (cmd_idx < 0) { |
| 191 | ret = cmd_idx; |
Winkler, Tomas | 15b1687 | 2008-12-19 10:37:33 +0800 | [diff] [blame] | 192 | IWL_ERR(priv, "Error sending %s: enqueue_hcmd failed: %d\n", |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 193 | get_cmd_string(cmd->id), ret); |
| 194 | goto out; |
| 195 | } |
| 196 | |
| 197 | ret = wait_event_interruptible_timeout(priv->wait_command_queue, |
| 198 | !test_bit(STATUS_HCMD_ACTIVE, &priv->status), |
| 199 | HOST_COMPLETE_TIMEOUT); |
| 200 | if (!ret) { |
| 201 | if (test_bit(STATUS_HCMD_ACTIVE, &priv->status)) { |
Winkler, Tomas | 15b1687 | 2008-12-19 10:37:33 +0800 | [diff] [blame] | 202 | IWL_ERR(priv, |
| 203 | "Error sending %s: time out after %dms.\n", |
| 204 | get_cmd_string(cmd->id), |
| 205 | jiffies_to_msecs(HOST_COMPLETE_TIMEOUT)); |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 206 | |
| 207 | clear_bit(STATUS_HCMD_ACTIVE, &priv->status); |
| 208 | ret = -ETIMEDOUT; |
| 209 | goto cancel; |
| 210 | } |
| 211 | } |
| 212 | |
| 213 | if (test_bit(STATUS_RF_KILL_HW, &priv->status)) { |
Tomas Winkler | e162344 | 2009-01-27 14:27:56 -0800 | [diff] [blame] | 214 | IWL_DEBUG_INFO(priv, "Command %s aborted: RF KILL Switch\n", |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 215 | get_cmd_string(cmd->id)); |
| 216 | ret = -ECANCELED; |
| 217 | goto fail; |
| 218 | } |
| 219 | if (test_bit(STATUS_FW_ERROR, &priv->status)) { |
Tomas Winkler | e162344 | 2009-01-27 14:27:56 -0800 | [diff] [blame] | 220 | IWL_DEBUG_INFO(priv, "Command %s failed: FW Error\n", |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 221 | get_cmd_string(cmd->id)); |
| 222 | ret = -EIO; |
| 223 | goto fail; |
| 224 | } |
| 225 | if ((cmd->meta.flags & CMD_WANT_SKB) && !cmd->meta.u.skb) { |
Winkler, Tomas | 15b1687 | 2008-12-19 10:37:33 +0800 | [diff] [blame] | 226 | IWL_ERR(priv, "Error: Response NULL in '%s'\n", |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 227 | get_cmd_string(cmd->id)); |
| 228 | ret = -EIO; |
Zhu Yi | 73e1a65 | 2009-01-08 10:19:58 -0800 | [diff] [blame] | 229 | goto cancel; |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 230 | } |
| 231 | |
| 232 | ret = 0; |
| 233 | goto out; |
| 234 | |
| 235 | cancel: |
| 236 | if (cmd->meta.flags & CMD_WANT_SKB) { |
| 237 | struct iwl_cmd *qcmd; |
| 238 | |
| 239 | /* Cancel the CMD_WANT_SKB flag for the cmd in the |
| 240 | * TX cmd queue. Otherwise in case the cmd comes |
| 241 | * in later, it will possibly set an invalid |
| 242 | * address (cmd->meta.source). */ |
Gregory Greenman | da99c4b | 2008-08-04 16:00:40 +0800 | [diff] [blame] | 243 | qcmd = priv->txq[IWL_CMD_QUEUE_NUM].cmd[cmd_idx]; |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 244 | qcmd->meta.flags &= ~CMD_WANT_SKB; |
| 245 | } |
| 246 | fail: |
| 247 | if (cmd->meta.u.skb) { |
| 248 | dev_kfree_skb_any(cmd->meta.u.skb); |
| 249 | cmd->meta.u.skb = NULL; |
| 250 | } |
| 251 | out: |
Tomas Winkler | e547297 | 2008-03-28 16:21:12 -0700 | [diff] [blame] | 252 | clear_bit(STATUS_HCMD_SYNC_ACTIVE, &priv->status); |
Tomas Winkler | 857485c | 2008-03-21 13:53:44 -0700 | [diff] [blame] | 253 | return ret; |
| 254 | } |
| 255 | EXPORT_SYMBOL(iwl_send_cmd_sync); |
| 256 | |
| 257 | int iwl_send_cmd(struct iwl_priv *priv, struct iwl_host_cmd *cmd) |
| 258 | { |
| 259 | if (cmd->meta.flags & CMD_ASYNC) |
| 260 | return iwl_send_cmd_async(priv, cmd); |
| 261 | |
| 262 | return iwl_send_cmd_sync(priv, cmd); |
| 263 | } |
| 264 | EXPORT_SYMBOL(iwl_send_cmd); |
| 265 | |
| 266 | int iwl_send_cmd_pdu(struct iwl_priv *priv, u8 id, u16 len, const void *data) |
| 267 | { |
| 268 | struct iwl_host_cmd cmd = { |
| 269 | .id = id, |
| 270 | .len = len, |
| 271 | .data = data, |
| 272 | }; |
| 273 | |
| 274 | return iwl_send_cmd_sync(priv, &cmd); |
| 275 | } |
| 276 | EXPORT_SYMBOL(iwl_send_cmd_pdu); |
| 277 | |
| 278 | int iwl_send_cmd_pdu_async(struct iwl_priv *priv, |
| 279 | u8 id, u16 len, const void *data, |
| 280 | int (*callback)(struct iwl_priv *priv, |
| 281 | struct iwl_cmd *cmd, |
| 282 | struct sk_buff *skb)) |
| 283 | { |
| 284 | struct iwl_host_cmd cmd = { |
| 285 | .id = id, |
| 286 | .len = len, |
| 287 | .data = data, |
| 288 | }; |
| 289 | |
| 290 | cmd.meta.flags |= CMD_ASYNC; |
| 291 | cmd.meta.u.callback = callback; |
| 292 | |
| 293 | return iwl_send_cmd_async(priv, &cmd); |
| 294 | } |
| 295 | EXPORT_SYMBOL(iwl_send_cmd_pdu_async); |