?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drivers/net/wireless: introduce missing kfree
[linux-2.6/mini2440.git] / drivers / net / wireless / iwmc3200wifi / commands.c
blobe2334d1235993812b35d1c2e39bc68fcb46d331f
1 /*
2 * Intel Wireless Multicomm 3200 WiFi driver
3 *
4 * Copyright (C) 2009 Intel Corporation. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
15 * distribution.
16 * * Neither the name of Intel Corporation nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 *
32 *
33 * Intel Corporation <ilw@linux.intel.com>
34 * Samuel Ortiz <samuel.ortiz@intel.com>
35 * Zhu Yi <yi.zhu@intel.com>
36 *
37 */
38
39 #include <linux/kernel.h>
40 #include <linux/wireless.h>
41 #include <linux/etherdevice.h>
42 #include <linux/ieee80211.h>
43
44 #include "iwm.h"
45 #include "bus.h"
46 #include "hal.h"
47 #include "umac.h"
48 #include "commands.h"
49 #include "debug.h"
50
51 static int iwm_send_lmac_ptrough_cmd(struct iwm_priv *iwm,
52 u8 lmac_cmd_id,
53 const void *lmac_payload,
54 u16 lmac_payload_size,
55 u8 resp)
56 {
57 struct iwm_udma_wifi_cmd udma_cmd = UDMA_LMAC_INIT;
58 struct iwm_umac_cmd umac_cmd;
59 struct iwm_lmac_cmd lmac_cmd;
60
61 lmac_cmd.id = lmac_cmd_id;
62
63 umac_cmd.id = UMAC_CMD_OPCODE_WIFI_PASS_THROUGH;
64 umac_cmd.resp = resp;
65
66 return iwm_hal_send_host_cmd(iwm, &udma_cmd, &umac_cmd, &lmac_cmd,
67 lmac_payload, lmac_payload_size);
68 }
69
70 int iwm_send_wifi_if_cmd(struct iwm_priv *iwm, void *payload, u16 payload_size,
71 bool resp)
72 {
73 struct iwm_udma_wifi_cmd udma_cmd = UDMA_UMAC_INIT;
74 struct iwm_umac_cmd umac_cmd;
75
76 umac_cmd.id = UMAC_CMD_OPCODE_WIFI_IF_WRAPPER;
77 umac_cmd.resp = resp;
78
79 return iwm_hal_send_umac_cmd(iwm, &udma_cmd, &umac_cmd,
80 payload, payload_size);
81 }
82
83 static struct coex_event iwm_sta_xor_prio_tbl[COEX_EVENTS_NUM] =
84 {
85 {4, 3, 0, COEX_UNASSOC_IDLE_FLAGS},
86 {4, 3, 0, COEX_UNASSOC_MANUAL_SCAN_FLAGS},
87 {4, 3, 0, COEX_UNASSOC_AUTO_SCAN_FLAGS},
88 {4, 3, 0, COEX_CALIBRATION_FLAGS},
89 {4, 3, 0, COEX_PERIODIC_CALIBRATION_FLAGS},
90 {4, 3, 0, COEX_CONNECTION_ESTAB_FLAGS},
91 {4, 3, 0, COEX_ASSOCIATED_IDLE_FLAGS},
92 {4, 3, 0, COEX_ASSOC_MANUAL_SCAN_FLAGS},
93 {4, 3, 0, COEX_ASSOC_AUTO_SCAN_FLAGS},
94 {4, 3, 0, COEX_ASSOC_ACTIVE_LEVEL_FLAGS},
95 {6, 3, 0, COEX_XOR_RF_ON_FLAGS},
96 {4, 3, 0, COEX_RF_OFF_FLAGS},
97 {6, 6, 0, COEX_STAND_ALONE_DEBUG_FLAGS},
98 {4, 3, 0, COEX_IPAN_ASSOC_LEVEL_FLAGS},
99 {4, 3, 0, COEX_RSRVD1_FLAGS},
100 {4, 3, 0, COEX_RSRVD2_FLAGS}
101 };
102
103 static struct coex_event iwm_sta_cm_prio_tbl[COEX_EVENTS_NUM] =
104 {
105 {1, 1, 0, COEX_UNASSOC_IDLE_FLAGS},
106 {4, 3, 0, COEX_UNASSOC_MANUAL_SCAN_FLAGS},
107 {3, 3, 0, COEX_UNASSOC_AUTO_SCAN_FLAGS},
108 {5, 5, 0, COEX_CALIBRATION_FLAGS},
109 {4, 4, 0, COEX_PERIODIC_CALIBRATION_FLAGS},
110 {5, 4, 0, COEX_CONNECTION_ESTAB_FLAGS},
111 {4, 4, 0, COEX_ASSOCIATED_IDLE_FLAGS},
112 {4, 4, 0, COEX_ASSOC_MANUAL_SCAN_FLAGS},
113 {4, 4, 0, COEX_ASSOC_AUTO_SCAN_FLAGS},
114 {4, 4, 0, COEX_ASSOC_ACTIVE_LEVEL_FLAGS},
115 {1, 1, 0, COEX_RF_ON_FLAGS},
116 {1, 1, 0, COEX_RF_OFF_FLAGS},
117 {6, 6, 0, COEX_STAND_ALONE_DEBUG_FLAGS},
118 {5, 4, 0, COEX_IPAN_ASSOC_LEVEL_FLAGS},
119 {1, 1, 0, COEX_RSRVD1_FLAGS},
120 {1, 1, 0, COEX_RSRVD2_FLAGS}
121 };
122
123 int iwm_send_prio_table(struct iwm_priv *iwm)
124 {
125 struct iwm_coex_prio_table_cmd coex_table_cmd;
126 u32 coex_enabled, mode_enabled;
127
128 memset(&coex_table_cmd, 0, sizeof(struct iwm_coex_prio_table_cmd));
129
130 coex_table_cmd.flags = COEX_FLAGS_STA_TABLE_VALID_MSK;
131
132 switch (iwm->conf.coexist_mode) {
133 case COEX_MODE_XOR:
134 case COEX_MODE_CM:
135 coex_enabled = 1;
136 break;
137 default:
138 coex_enabled = 0;
139 break;
140 }
141
142 switch (iwm->conf.mode) {
143 case UMAC_MODE_BSS:
144 case UMAC_MODE_IBSS:
145 mode_enabled = 1;
146 break;
147 default:
148 mode_enabled = 0;
149 break;
150 }
151
152 if (coex_enabled && mode_enabled) {
153 coex_table_cmd.flags |= COEX_FLAGS_COEX_ENABLE_MSK |
154 COEX_FLAGS_ASSOC_WAKEUP_UMASK_MSK |
155 COEX_FLAGS_UNASSOC_WAKEUP_UMASK_MSK;
156
157 switch (iwm->conf.coexist_mode) {
158 case COEX_MODE_XOR:
159 memcpy(coex_table_cmd.sta_prio, iwm_sta_xor_prio_tbl,
160 sizeof(iwm_sta_xor_prio_tbl));
161 break;
162 case COEX_MODE_CM:
163 memcpy(coex_table_cmd.sta_prio, iwm_sta_cm_prio_tbl,
164 sizeof(iwm_sta_cm_prio_tbl));
165 break;
166 default:
167 IWM_ERR(iwm, "Invalid coex_mode 0x%x\n",
168 iwm->conf.coexist_mode);
169 break;
170 }
171 } else
172 IWM_WARN(iwm, "coexistense disabled\n");
173
174 return iwm_send_lmac_ptrough_cmd(iwm, COEX_PRIORITY_TABLE_CMD,
175 &coex_table_cmd,
176 sizeof(struct iwm_coex_prio_table_cmd), 1);
177 }
178
179 int iwm_send_init_calib_cfg(struct iwm_priv *iwm, u8 calib_requested)
180 {
181 struct iwm_lmac_cal_cfg_cmd cal_cfg_cmd;
182
183 memset(&cal_cfg_cmd, 0, sizeof(struct iwm_lmac_cal_cfg_cmd));
184
185 cal_cfg_cmd.ucode_cfg.init.enable = cpu_to_le32(calib_requested);
186 cal_cfg_cmd.ucode_cfg.init.start = cpu_to_le32(calib_requested);
187 cal_cfg_cmd.ucode_cfg.init.send_res = cpu_to_le32(calib_requested);
188 cal_cfg_cmd.ucode_cfg.flags =
189 cpu_to_le32(CALIB_CFG_FLAG_SEND_COMPLETE_NTFY_AFTER_MSK);
190
191 return iwm_send_lmac_ptrough_cmd(iwm, CALIBRATION_CFG_CMD, &cal_cfg_cmd,
192 sizeof(struct iwm_lmac_cal_cfg_cmd), 1);
193 }
194
195 int iwm_send_periodic_calib_cfg(struct iwm_priv *iwm, u8 calib_requested)
196 {
197 struct iwm_lmac_cal_cfg_cmd cal_cfg_cmd;
198
199 memset(&cal_cfg_cmd, 0, sizeof(struct iwm_lmac_cal_cfg_cmd));
200
201 cal_cfg_cmd.ucode_cfg.periodic.enable = cpu_to_le32(calib_requested);
202 cal_cfg_cmd.ucode_cfg.periodic.start = cpu_to_le32(calib_requested);
203
204 return iwm_send_lmac_ptrough_cmd(iwm, CALIBRATION_CFG_CMD, &cal_cfg_cmd,
205 sizeof(struct iwm_lmac_cal_cfg_cmd), 0);
206 }
207
208 int iwm_store_rxiq_calib_result(struct iwm_priv *iwm)
209 {
210 struct iwm_calib_rxiq *rxiq;
211 u8 *eeprom_rxiq = iwm_eeprom_access(iwm, IWM_EEPROM_CALIB_RXIQ);
212 int grplen = sizeof(struct iwm_calib_rxiq_group);
213
214 rxiq = kzalloc(sizeof(struct iwm_calib_rxiq), GFP_KERNEL);
215 if (!rxiq) {
216 IWM_ERR(iwm, "Couldn't alloc memory for RX IQ\n");
217 return -ENOMEM;
218 }
219
220 eeprom_rxiq = iwm_eeprom_access(iwm, IWM_EEPROM_CALIB_RXIQ);
221 if (IS_ERR(eeprom_rxiq)) {
222 IWM_ERR(iwm, "Couldn't access EEPROM RX IQ entry\n");
223 kfree(rxiq);
224 return PTR_ERR(eeprom_rxiq);
225 }
226
227 iwm->calib_res[SHILOH_PHY_CALIBRATE_RX_IQ_CMD].buf = (u8 *)rxiq;
228 iwm->calib_res[SHILOH_PHY_CALIBRATE_RX_IQ_CMD].size = sizeof(*rxiq);
229
230 rxiq->hdr.opcode = SHILOH_PHY_CALIBRATE_RX_IQ_CMD;
231 rxiq->hdr.first_grp = 0;
232 rxiq->hdr.grp_num = 1;
233 rxiq->hdr.all_data_valid = 1;
234
235 memcpy(&rxiq->group[0], eeprom_rxiq, 4 * grplen);
236 memcpy(&rxiq->group[4], eeprom_rxiq + 6 * grplen, grplen);
237
238 return 0;
239 }
240
241 int iwm_send_calib_results(struct iwm_priv *iwm)
242 {
243 int i, ret = 0;
244
245 for (i = PHY_CALIBRATE_OPCODES_NUM; i < CALIBRATION_CMD_NUM; i++) {
246 if (test_bit(i - PHY_CALIBRATE_OPCODES_NUM,
247 &iwm->calib_done_map)) {
248 IWM_DBG_CMD(iwm, DBG,
249 "Send calibration %d result\n", i);
250 ret |= iwm_send_lmac_ptrough_cmd(iwm,
251 REPLY_PHY_CALIBRATION_CMD,
252 iwm->calib_res[i].buf,
253 iwm->calib_res[i].size, 0);
254
255 kfree(iwm->calib_res[i].buf);
256 iwm->calib_res[i].buf = NULL;
257 iwm->calib_res[i].size = 0;
258 }
259 }
260
261 return ret;
262 }
263
264 int iwm_send_umac_reset(struct iwm_priv *iwm, __le32 reset_flags, bool resp)
265 {
266 struct iwm_udma_wifi_cmd udma_cmd = UDMA_UMAC_INIT;
267 struct iwm_umac_cmd umac_cmd;
268 struct iwm_umac_cmd_reset reset;
269
270 reset.flags = reset_flags;
271
272 umac_cmd.id = UMAC_CMD_OPCODE_RESET;
273 umac_cmd.resp = resp;
274
275 return iwm_hal_send_umac_cmd(iwm, &udma_cmd, &umac_cmd, &reset,
276 sizeof(struct iwm_umac_cmd_reset));
277 }
278
279 int iwm_umac_set_config_fix(struct iwm_priv *iwm, u16 tbl, u16 key, u32 value)
280 {
281 struct iwm_udma_wifi_cmd udma_cmd = UDMA_UMAC_INIT;
282 struct iwm_umac_cmd umac_cmd;
283 struct iwm_umac_cmd_set_param_fix param;
284
285 if ((tbl != UMAC_PARAM_TBL_CFG_FIX) &&
286 (tbl != UMAC_PARAM_TBL_FA_CFG_FIX))
287 return -EINVAL;
288
289 umac_cmd.id = UMAC_CMD_OPCODE_SET_PARAM_FIX;
290 umac_cmd.resp = 0;
291
292 param.tbl = cpu_to_le16(tbl);
293 param.key = cpu_to_le16(key);
294 param.value = cpu_to_le32(value);
295
296 return iwm_hal_send_umac_cmd(iwm, &udma_cmd, &umac_cmd, &param,
297 sizeof(struct iwm_umac_cmd_set_param_fix));
298 }
299
300 int iwm_umac_set_config_var(struct iwm_priv *iwm, u16 key,
301 void *payload, u16 payload_size)
302 {
303 struct iwm_udma_wifi_cmd udma_cmd = UDMA_UMAC_INIT;
304 struct iwm_umac_cmd umac_cmd;
305 struct iwm_umac_cmd_set_param_var *param_hdr;
306 u8 *param;
307 int ret;
308
309 param = kzalloc(payload_size +
310 sizeof(struct iwm_umac_cmd_set_param_var), GFP_KERNEL);
311 if (!param) {
312 IWM_ERR(iwm, "Couldn't allocate param\n");
313 return -ENOMEM;
314 }
315
316 param_hdr = (struct iwm_umac_cmd_set_param_var *)param;
317
318 umac_cmd.id = UMAC_CMD_OPCODE_SET_PARAM_VAR;
319 umac_cmd.resp = 0;
320
321 param_hdr->tbl = cpu_to_le16(UMAC_PARAM_TBL_CFG_VAR);
322 param_hdr->key = cpu_to_le16(key);
323 param_hdr->len = cpu_to_le16(payload_size);
324 memcpy(param + sizeof(struct iwm_umac_cmd_set_param_var),
325 payload, payload_size);
326
327 ret = iwm_hal_send_umac_cmd(iwm, &udma_cmd, &umac_cmd, param,
328 sizeof(struct iwm_umac_cmd_set_param_var) +
329 payload_size);
330 kfree(param);
331
332 return ret;
333 }
334
335 int iwm_send_umac_config(struct iwm_priv *iwm,
336 __le32 reset_flags)
337 {
338 int ret;
339
340 /* Use UMAC default values */
341 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
342 CFG_POWER_INDEX, iwm->conf.power_index);
343 if (ret < 0)
344 return ret;
345
346 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_FA_CFG_FIX,
347 CFG_FRAG_THRESHOLD,
348 iwm->conf.frag_threshold);
349 if (ret < 0)
350 return ret;
351
352 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
353 CFG_RTS_THRESHOLD,
354 iwm->conf.rts_threshold);
355 if (ret < 0)
356 return ret;
357
358 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
359 CFG_CTS_TO_SELF, iwm->conf.cts_to_self);
360 if (ret < 0)
361 return ret;
362
363 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
364 CFG_COEX_MODE, iwm->conf.coexist_mode);
365 if (ret < 0)
366 return ret;
367
368 /*
369 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
370 CFG_ASSOCIATION_TIMEOUT,
371 iwm->conf.assoc_timeout);
372 if (ret < 0)
373 return ret;
374
375 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
376 CFG_ROAM_TIMEOUT,
377 iwm->conf.roam_timeout);
378 if (ret < 0)
379 return ret;
380
381 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
382 CFG_WIRELESS_MODE,
383 WIRELESS_MODE_11A | WIRELESS_MODE_11G);
384 if (ret < 0)
385 return ret;
386 */
387
388 ret = iwm_umac_set_config_var(iwm, CFG_NET_ADDR,
389 iwm_to_ndev(iwm)->dev_addr, ETH_ALEN);
390 if (ret < 0)
391 return ret;
392
393 /* UMAC PM static configurations */
394 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
395 CFG_PM_LEGACY_RX_TIMEOUT, 0x12C);
396 if (ret < 0)
397 return ret;
398
399 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
400 CFG_PM_LEGACY_TX_TIMEOUT, 0x15E);
401 if (ret < 0)
402 return ret;
403
404 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
405 CFG_PM_CTRL_FLAGS, 0x30001);
406 if (ret < 0)
407 return ret;
408
409 ret = iwm_umac_set_config_fix(iwm, UMAC_PARAM_TBL_CFG_FIX,
410 CFG_PM_KEEP_ALIVE_IN_BEACONS, 0x80);
411 if (ret < 0)
412 return ret;
413
414 /* reset UMAC */
415 ret = iwm_send_umac_reset(iwm, reset_flags, 1);
416 if (ret < 0)
417 return ret;
418
419 ret = iwm_notif_handle(iwm, UMAC_CMD_OPCODE_RESET, IWM_SRC_UMAC,
420 WAIT_NOTIF_TIMEOUT);
421 if (ret) {
422 IWM_ERR(iwm, "Wait for UMAC RESET timeout\n");
423 return ret;
424 }
425
426 return ret;
427 }
428
429 int iwm_send_packet(struct iwm_priv *iwm, struct sk_buff *skb, int pool_id)
430 {
431 struct iwm_udma_wifi_cmd udma_cmd;
432 struct iwm_umac_cmd umac_cmd;
433 struct iwm_tx_info *tx_info = skb_to_tx_info(skb);
434
435 udma_cmd.eop = 1; /* always set eop for non-concatenated Tx */
436 udma_cmd.credit_group = pool_id;
437 udma_cmd.ra_tid = tx_info->sta << 4 | tx_info->tid;
438 udma_cmd.lmac_offset = 0;
439
440 umac_cmd.id = REPLY_TX;
441 umac_cmd.color = tx_info->color;
442 umac_cmd.resp = 0;
443
444 return iwm_hal_send_umac_cmd(iwm, &udma_cmd, &umac_cmd,
445 skb->data, skb->len);
446 }
447
448 static int iwm_target_read(struct iwm_priv *iwm, __le32 address,
449 u8 *response, u32 resp_size)
450 {
451 struct iwm_udma_nonwifi_cmd target_cmd;
452 struct iwm_nonwifi_cmd *cmd;
453 u16 seq_num;
454 int ret = 0;
455
456 target_cmd.opcode = UMAC_HDI_OUT_OPCODE_READ;
457 target_cmd.addr = address;
458 target_cmd.op1_sz = cpu_to_le32(resp_size);
459 target_cmd.op2 = 0;
460 target_cmd.handle_by_hw = 0;
461 target_cmd.resp = 1;
462 target_cmd.eop = 1;
463
464 ret = iwm_hal_send_target_cmd(iwm, &target_cmd, NULL);
465 if (ret < 0)
466 IWM_ERR(iwm, "Couldn't send READ command\n");
467
468 /* When succeding, the send_target routine returns the seq number */
469 seq_num = ret;
470
471 ret = wait_event_interruptible_timeout(iwm->nonwifi_queue,
472 (cmd = iwm_get_pending_nonwifi_cmd(iwm, seq_num,
473 UMAC_HDI_OUT_OPCODE_READ)) != NULL,
474 2 * HZ);
475
476 if (!ret) {
477 IWM_ERR(iwm, "Didn't receive a target READ answer\n");
478 return ret;
479 }
480
481 memcpy(response, cmd->buf.hdr + sizeof(struct iwm_udma_in_hdr),
482 resp_size);
483
484 kfree(cmd);
485
486 return ret;
487 }
488
489 int iwm_read_mac(struct iwm_priv *iwm, u8 *mac)
490 {
491 int ret;
492 u8 mac_align[ALIGN(ETH_ALEN, 8)];
493
494 ret = iwm_target_read(iwm, cpu_to_le32(WICO_MAC_ADDRESS_ADDR),
495 mac_align, sizeof(mac_align));
496 if (ret < 0)
497 return ret;
498
499 if (is_valid_ether_addr(mac_align))
500 memcpy(mac, mac_align, ETH_ALEN);
501 else {
502 IWM_ERR(iwm, "Invalid EEPROM MAC\n");
503 memcpy(mac, iwm->conf.mac_addr, ETH_ALEN);
504 get_random_bytes(&mac[3], 3);
505 }
506
507 return 0;
508 }
509
510 int iwm_set_tx_key(struct iwm_priv *iwm, u8 key_idx)
511 {
512 struct iwm_umac_tx_key_id tx_key_id;
513
514 if (!iwm->default_key || !iwm->default_key->in_use)
515 return -EINVAL;
516
517 tx_key_id.hdr.oid = UMAC_WIFI_IF_CMD_GLOBAL_TX_KEY_ID;
518 tx_key_id.hdr.buf_size = cpu_to_le16(sizeof(struct iwm_umac_tx_key_id) -
519 sizeof(struct iwm_umac_wifi_if));
520
521 tx_key_id.key_idx = key_idx;
522
523 return iwm_send_wifi_if_cmd(iwm, &tx_key_id, sizeof(tx_key_id), 1);
524 }
525
526 static int iwm_check_profile(struct iwm_priv *iwm)
527 {
528 if (!iwm->umac_profile_active)
529 return -EAGAIN;
530
531 if (iwm->umac_profile->sec.ucast_cipher != UMAC_CIPHER_TYPE_WEP_40 &&
532 iwm->umac_profile->sec.ucast_cipher != UMAC_CIPHER_TYPE_WEP_104 &&
533 iwm->umac_profile->sec.ucast_cipher != UMAC_CIPHER_TYPE_TKIP &&
534 iwm->umac_profile->sec.ucast_cipher != UMAC_CIPHER_TYPE_CCMP) {
535 IWM_ERR(iwm, "Wrong unicast cipher: 0x%x\n",
536 iwm->umac_profile->sec.ucast_cipher);
537 return -EAGAIN;
538 }
539
540 if (iwm->umac_profile->sec.mcast_cipher != UMAC_CIPHER_TYPE_WEP_40 &&
541 iwm->umac_profile->sec.mcast_cipher != UMAC_CIPHER_TYPE_WEP_104 &&
542 iwm->umac_profile->sec.mcast_cipher != UMAC_CIPHER_TYPE_TKIP &&
543 iwm->umac_profile->sec.mcast_cipher != UMAC_CIPHER_TYPE_CCMP) {
544 IWM_ERR(iwm, "Wrong multicast cipher: 0x%x\n",
545 iwm->umac_profile->sec.mcast_cipher);
546 return -EAGAIN;
547 }
548
549 if ((iwm->umac_profile->sec.ucast_cipher == UMAC_CIPHER_TYPE_WEP_40 ||
550 iwm->umac_profile->sec.ucast_cipher == UMAC_CIPHER_TYPE_WEP_104) &&
551 (iwm->umac_profile->sec.ucast_cipher !=
552 iwm->umac_profile->sec.mcast_cipher)) {
553 IWM_ERR(iwm, "Unicast and multicast ciphers differ for WEP\n");
554 }
555
556 return 0;
557 }
558
559 int iwm_set_key(struct iwm_priv *iwm, bool remove, bool set_tx_key,
560 struct iwm_key *key)
561 {
562 int ret;
563 u8 cmd[64], *sta_addr, *key_data, key_len;
564 s8 key_idx;
565 u16 cmd_size = 0;
566 struct iwm_umac_key_hdr *key_hdr = &key->hdr;
567 struct iwm_umac_key_wep40 *wep40 = (struct iwm_umac_key_wep40 *)cmd;
568 struct iwm_umac_key_wep104 *wep104 = (struct iwm_umac_key_wep104 *)cmd;
569 struct iwm_umac_key_tkip *tkip = (struct iwm_umac_key_tkip *)cmd;
570 struct iwm_umac_key_ccmp *ccmp = (struct iwm_umac_key_ccmp *)cmd;
571
572 if (set_tx_key)
573 iwm->default_key = key;
574
575 /*
576 * We check if our current profile is valid.
577 * If not, we dont push the key, we just cache them,
578 * so that with the next siwsessid call, the keys
579 * will be actually pushed.
580 */
581 if (!remove) {
582 ret = iwm_check_profile(iwm);
583 if (ret < 0)
584 return ret;
585 }
586
587 sta_addr = key->hdr.mac;
588 key_data = key->key;
589 key_len = key->key_len;
590 key_idx = key->hdr.key_idx;
591
592 if (!remove) {
593 IWM_DBG_WEXT(iwm, DBG, "key_idx:%d set tx key:%d\n",
594 key_idx, set_tx_key);
595 IWM_DBG_WEXT(iwm, DBG, "key_len:%d\n", key_len);
596 IWM_DBG_WEXT(iwm, DBG, "MAC:%pM, idx:%d, multicast:%d\n",
597 key_hdr->mac, key_hdr->key_idx, key_hdr->multicast);
598
599 IWM_DBG_WEXT(iwm, DBG, "profile: mcast:0x%x, ucast:0x%x\n",
600 iwm->umac_profile->sec.mcast_cipher,
601 iwm->umac_profile->sec.ucast_cipher);
602 IWM_DBG_WEXT(iwm, DBG, "profile: auth_type:0x%x, flags:0x%x\n",
603 iwm->umac_profile->sec.auth_type,
604 iwm->umac_profile->sec.flags);
605
606 switch (key->alg) {
607 case UMAC_CIPHER_TYPE_WEP_40:
608 wep40->hdr.oid = UMAC_WIFI_IF_CMD_ADD_WEP40_KEY;
609 wep40->hdr.buf_size =
610 cpu_to_le16(sizeof(struct iwm_umac_key_wep40) -
611 sizeof(struct iwm_umac_wifi_if));
612
613 memcpy(&wep40->key_hdr, key_hdr,
614 sizeof(struct iwm_umac_key_hdr));
615 memcpy(wep40->key, key_data, key_len);
616 wep40->static_key = 1;
617
618 cmd_size = sizeof(struct iwm_umac_key_wep40);
619 break;
620
621 case UMAC_CIPHER_TYPE_WEP_104:
622 wep104->hdr.oid = UMAC_WIFI_IF_CMD_ADD_WEP104_KEY;
623 wep104->hdr.buf_size =
624 cpu_to_le16(sizeof(struct iwm_umac_key_wep104) -
625 sizeof(struct iwm_umac_wifi_if));
626
627 memcpy(&wep104->key_hdr, key_hdr,
628 sizeof(struct iwm_umac_key_hdr));
629 memcpy(wep104->key, key_data, key_len);
630 wep104->static_key = 1;
631
632 cmd_size = sizeof(struct iwm_umac_key_wep104);
633 break;
634
635 case UMAC_CIPHER_TYPE_CCMP:
636 key_hdr->key_idx++;
637 ccmp->hdr.oid = UMAC_WIFI_IF_CMD_ADD_CCMP_KEY;
638 ccmp->hdr.buf_size =
639 cpu_to_le16(sizeof(struct iwm_umac_key_ccmp) -
640 sizeof(struct iwm_umac_wifi_if));
641
642 memcpy(&ccmp->key_hdr, key_hdr,
643 sizeof(struct iwm_umac_key_hdr));
644
645 memcpy(ccmp->key, key_data, key_len);
646
647 if (key->flags & IW_ENCODE_EXT_RX_SEQ_VALID)
648 memcpy(ccmp->iv_count, key->rx_seq, 6);
649
650 cmd_size = sizeof(struct iwm_umac_key_ccmp);
651 break;
652
653 case UMAC_CIPHER_TYPE_TKIP:
654 key_hdr->key_idx++;
655 tkip->hdr.oid = UMAC_WIFI_IF_CMD_ADD_TKIP_KEY;
656 tkip->hdr.buf_size =
657 cpu_to_le16(sizeof(struct iwm_umac_key_tkip) -
658 sizeof(struct iwm_umac_wifi_if));
659
660 memcpy(&tkip->key_hdr, key_hdr,
661 sizeof(struct iwm_umac_key_hdr));
662
663 memcpy(tkip->tkip_key, key_data, IWM_TKIP_KEY_SIZE);
664 memcpy(tkip->mic_tx_key, key_data + IWM_TKIP_KEY_SIZE,
665 IWM_TKIP_MIC_SIZE);
666 memcpy(tkip->mic_rx_key,
667 key_data + IWM_TKIP_KEY_SIZE + IWM_TKIP_MIC_SIZE,
668 IWM_TKIP_MIC_SIZE);
669
670 if (key->flags & IW_ENCODE_EXT_RX_SEQ_VALID)
671 memcpy(ccmp->iv_count, key->rx_seq, 6);
672
673 cmd_size = sizeof(struct iwm_umac_key_tkip);
674 break;
675
676 default:
677 return -ENOTSUPP;
678 }
679
680 if ((key->alg == UMAC_CIPHER_TYPE_CCMP) ||
681 (key->alg == UMAC_CIPHER_TYPE_TKIP))
682 /*
683 * UGLY_UGLY_UGLY
684 * Copied HACK from the MWG driver.
685 * Without it, the key is set before the second
686 * EAPOL frame is sent, and the latter is thus
687 * encrypted.
688 */
689 schedule_timeout_interruptible(usecs_to_jiffies(300));
690
691 ret = iwm_send_wifi_if_cmd(iwm, cmd, cmd_size, 1);
692 if (ret < 0)
693 goto err;
694
695 /*
696 * We need a default key only if it is set and
697 * if we're doing WEP.
698 */
699 if (iwm->default_key == key &&
700 ((key->alg == UMAC_CIPHER_TYPE_WEP_40) ||
701 (key->alg == UMAC_CIPHER_TYPE_WEP_104))) {
702 ret = iwm_set_tx_key(iwm, key_idx);
703 if (ret < 0)
704 goto err;
705 }
706 } else {
707 struct iwm_umac_key_remove key_remove;
708
709 key_remove.hdr.oid = UMAC_WIFI_IF_CMD_REMOVE_KEY;
710 key_remove.hdr.buf_size =
711 cpu_to_le16(sizeof(struct iwm_umac_key_remove) -
712 sizeof(struct iwm_umac_wifi_if));
713 memcpy(&key_remove.key_hdr, key_hdr,
714 sizeof(struct iwm_umac_key_hdr));
715
716 ret = iwm_send_wifi_if_cmd(iwm, &key_remove,
717 sizeof(struct iwm_umac_key_remove),
718 1);
719 if (ret < 0)
720 return ret;
721
722 iwm->keys[key_idx].in_use = 0;
723 }
724
725 return 0;
726
727 err:
728 kfree(key);
729 return ret;
730 }
731
732
733 int iwm_send_mlme_profile(struct iwm_priv *iwm)
734 {
735 int ret, i;
736 struct iwm_umac_profile profile;
737
738 memcpy(&profile, iwm->umac_profile, sizeof(profile));
739
740 profile.hdr.oid = UMAC_WIFI_IF_CMD_SET_PROFILE;
741 profile.hdr.buf_size = cpu_to_le16(sizeof(struct iwm_umac_profile) -
742 sizeof(struct iwm_umac_wifi_if));
743
744 ret = iwm_send_wifi_if_cmd(iwm, &profile, sizeof(profile), 1);
745 if (ret < 0) {
746 IWM_ERR(iwm, "Send profile command failed\n");
747 return ret;
748 }
749
750 /* Wait for the profile to be active */
751 ret = wait_event_interruptible_timeout(iwm->mlme_queue,
752 iwm->umac_profile_active == 1,
753 3 * HZ);
754 if (!ret)
755 return -EBUSY;
756
757
758 for (i = 0; i < IWM_NUM_KEYS; i++)
759 if (iwm->keys[i].in_use) {
760 int default_key = 0;
761 struct iwm_key *key = &iwm->keys[i];
762
763 if (key == iwm->default_key)
764 default_key = 1;
765
766 /* Wait for the profile before sending the keys */
767 wait_event_interruptible_timeout(iwm->mlme_queue,
768 (test_bit(IWM_STATUS_ASSOCIATING, &iwm->status) ||
769 test_bit(IWM_STATUS_ASSOCIATED, &iwm->status)),
770 3 * HZ);
771
772 ret = iwm_set_key(iwm, 0, default_key, key);
773 if (ret < 0)
774 return ret;
775 }
776
777 return 0;
778 }
779
780 int iwm_invalidate_mlme_profile(struct iwm_priv *iwm)
781 {
782 int ret;
783 struct iwm_umac_invalidate_profile invalid;
784
785 invalid.hdr.oid = UMAC_WIFI_IF_CMD_INVALIDATE_PROFILE;
786 invalid.hdr.buf_size =
787 cpu_to_le16(sizeof(struct iwm_umac_invalidate_profile) -
788 sizeof(struct iwm_umac_wifi_if));
789
790 invalid.reason = WLAN_REASON_UNSPECIFIED;
791
792 ret = iwm_send_wifi_if_cmd(iwm, &invalid, sizeof(invalid), 1);
793 if (ret < 0)
794 return ret;
795
796 ret = wait_event_interruptible_timeout(iwm->mlme_queue,
797 (iwm->umac_profile_active == 0),
798 2 * HZ);
799 if (!ret)
800 return -EBUSY;
801
802 return 0;
803 }
804
805 int iwm_send_umac_stats_req(struct iwm_priv *iwm, u32 flags)
806 {
807 struct iwm_udma_wifi_cmd udma_cmd = UDMA_UMAC_INIT;
808 struct iwm_umac_cmd umac_cmd;
809 struct iwm_umac_cmd_stats_req stats_req;
810
811 stats_req.flags = cpu_to_le32(flags);
812
813 umac_cmd.id = UMAC_CMD_OPCODE_STATISTIC_REQUEST;
814 umac_cmd.resp = 0;
815
816 return iwm_hal_send_umac_cmd(iwm, &udma_cmd, &umac_cmd, &stats_req,
817 sizeof(struct iwm_umac_cmd_stats_req));
818 }
819
820 int iwm_send_umac_channel_list(struct iwm_priv *iwm)
821 {
822 struct iwm_udma_wifi_cmd udma_cmd = UDMA_UMAC_INIT;
823 struct iwm_umac_cmd umac_cmd;
824 struct iwm_umac_cmd_get_channel_list *ch_list;
825 int size = sizeof(struct iwm_umac_cmd_get_channel_list) +
826 sizeof(struct iwm_umac_channel_info) * 4;
827 int ret;
828
829 ch_list = kzalloc(size, GFP_KERNEL);
830 if (!ch_list) {
831 IWM_ERR(iwm, "Couldn't allocate channel list cmd\n");
832 return -ENOMEM;
833 }
834
835 ch_list->ch[0].band = UMAC_BAND_2GHZ;
836 ch_list->ch[0].type = UMAC_CHANNEL_WIDTH_20MHZ;
837 ch_list->ch[0].flags = UMAC_CHANNEL_FLAG_VALID;
838
839 ch_list->ch[1].band = UMAC_BAND_5GHZ;
840 ch_list->ch[1].type = UMAC_CHANNEL_WIDTH_20MHZ;
841 ch_list->ch[1].flags = UMAC_CHANNEL_FLAG_VALID;
842
843 ch_list->ch[2].band = UMAC_BAND_2GHZ;
844 ch_list->ch[2].type = UMAC_CHANNEL_WIDTH_20MHZ;
845 ch_list->ch[2].flags = UMAC_CHANNEL_FLAG_VALID | UMAC_CHANNEL_FLAG_IBSS;
846
847 ch_list->ch[3].band = UMAC_BAND_5GHZ;
848 ch_list->ch[3].type = UMAC_CHANNEL_WIDTH_20MHZ;
849 ch_list->ch[3].flags = UMAC_CHANNEL_FLAG_VALID | UMAC_CHANNEL_FLAG_IBSS;
850
851 ch_list->count = cpu_to_le16(4);
852
853 umac_cmd.id = UMAC_CMD_OPCODE_GET_CHAN_INFO_LIST;
854 umac_cmd.resp = 1;
855
856 ret = iwm_hal_send_umac_cmd(iwm, &udma_cmd, &umac_cmd, ch_list, size);
857
858 kfree(ch_list);
859
860 return ret;
861 }
862
863 int iwm_scan_ssids(struct iwm_priv *iwm, struct cfg80211_ssid *ssids,
864 int ssid_num)
865 {
866 struct iwm_umac_cmd_scan_request req;
867 int i, ret;
868
869 memset(&req, 0, sizeof(struct iwm_umac_cmd_scan_request));
870
871 req.hdr.oid = UMAC_WIFI_IF_CMD_SCAN_REQUEST;
872 req.hdr.buf_size = cpu_to_le16(sizeof(struct iwm_umac_cmd_scan_request)
873 - sizeof(struct iwm_umac_wifi_if));
874 req.type = UMAC_WIFI_IF_SCAN_TYPE_USER;
875 req.timeout = 2;
876 req.seq_num = iwm->scan_id;
877 req.ssid_num = min(ssid_num, UMAC_WIFI_IF_PROBE_OPTION_MAX);
878
879 for (i = 0; i < req.ssid_num; i++) {
880 memcpy(req.ssids[i].ssid, ssids[i].ssid, ssids[i].ssid_len);
881 req.ssids[i].ssid_len = ssids[i].ssid_len;
882 }
883
884 ret = iwm_send_wifi_if_cmd(iwm, &req, sizeof(req), 0);
885 if (ret < 0) {
886 IWM_ERR(iwm, "Couldn't send scan request\n");
887 return ret;
888 }
889
890 iwm->scan_id = iwm->scan_id++ % IWM_SCAN_ID_MAX;
891
892 return 0;
893 }
894
895 int iwm_scan_one_ssid(struct iwm_priv *iwm, u8 *ssid, int ssid_len)
896 {
897 struct cfg80211_ssid one_ssid;
898
899 if (test_and_set_bit(IWM_STATUS_SCANNING, &iwm->status))
900 return 0;
901
902 one_ssid.ssid_len = min(ssid_len, IEEE80211_MAX_SSID_LEN);
903 memcpy(&one_ssid.ssid, ssid, one_ssid.ssid_len);
904
905 return iwm_scan_ssids(iwm, &one_ssid, 1);
906 }
907
908 int iwm_target_reset(struct iwm_priv *iwm)
909 {
910 struct iwm_udma_nonwifi_cmd target_cmd;
911
912 target_cmd.opcode = UMAC_HDI_OUT_OPCODE_REBOOT;
913 target_cmd.addr = 0;
914 target_cmd.op1_sz = 0;
915 target_cmd.op2 = 0;
916 target_cmd.handle_by_hw = 0;
917 target_cmd.resp = 0;
918 target_cmd.eop = 1;
919
920 return iwm_hal_send_target_cmd(iwm, &target_cmd, NULL);
921 }
Support for the Chinese Samsung S3C2440 based development boards