projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / wireless / iwmc3200wifi / main.c
CommitLineData
bb9f8692
ZY		 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/netdevice.h>
d43c36dc 41#include <linux/sched.h>
bb9f8692
ZY		 42#include <linux/ieee80211.h>
43#include <linux/wireless.h>
5a0e3ad6 44#include <linux/slab.h>
bb9f8692
ZY		 45
46#include "iwm.h"
47#include "debug.h"
48#include "bus.h"
49#include "umac.h"
50#include "commands.h"
51#include "hal.h"
52#include "fw.h"
53#include "rx.h"
54
55static struct iwm_conf def_iwm_conf = {
56
57 .sdio_ior_timeout = 5000,
d04bd628
SO		 58 .calib_map = BIT(CALIB_CFG_DC_IDX) |
59 BIT(CALIB_CFG_LO_IDX) |
60 BIT(CALIB_CFG_TX_IQ_IDX) |
61 BIT(CALIB_CFG_RX_IQ_IDX) |
62 BIT(SHILOH_PHY_CALIBRATE_BASE_BAND_CMD),
63 .expected_calib_map = BIT(PHY_CALIBRATE_DC_CMD) |
bb9f8692
ZY		 64 BIT(PHY_CALIBRATE_LO_CMD) |
65 BIT(PHY_CALIBRATE_TX_IQ_CMD) |
66 BIT(PHY_CALIBRATE_RX_IQ_CMD) |
67 BIT(SHILOH_PHY_CALIBRATE_BASE_BAND_CMD),
e85498b2
SO		 68 .ct_kill_entry = 110,
69 .ct_kill_exit = 110,
bb9f8692
ZY		 70 .reset_on_fatal_err = 1,
71 .auto_connect = 1,
bb9f8692
ZY		 72 .enable_qos = 1,
73 .mode = UMAC_MODE_BSS,
74
75 /* UMAC configuration */
76 .power_index = 0,
77 .frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD,
78 .rts_threshold = IEEE80211_MAX_RTS_THRESHOLD,
79 .cts_to_self = 0,
80
81 .assoc_timeout = 2,
82 .roam_timeout = 10,
0bed08de
SO		 83 .wireless_mode = WIRELESS_MODE_11A | WIRELESS_MODE_11G |
84 WIRELESS_MODE_11N,
bb9f8692
ZY		 85
86 /* IBSS */
87 .ibss_band = UMAC_BAND_2GHZ,
88 .ibss_channel = 1,
89
90 .mac_addr = {0x00, 0x02, 0xb3, 0x01, 0x02, 0x03},
91};
92
93static int modparam_reset;
94module_param_named(reset, modparam_reset, bool, 0644);
95MODULE_PARM_DESC(reset, "reset on firmware errors (default 0 [not reset])");
96
159bcfeb
SO		 97static int modparam_wimax_enable = 1;
98module_param_named(wimax_enable, modparam_wimax_enable, bool, 0644);
99MODULE_PARM_DESC(wimax_enable, "Enable wimax core (default 1 [wimax enabled])");
100
bb9f8692
ZY		 101int iwm_mode_to_nl80211_iftype(int mode)
102{
103 switch (mode) {
104 case UMAC_MODE_BSS:
105 return NL80211_IFTYPE_STATION;
106 case UMAC_MODE_IBSS:
107 return NL80211_IFTYPE_ADHOC;
108 default:
109 return NL80211_IFTYPE_UNSPECIFIED;
110 }
111
112 return 0;
113}
114
115static void iwm_statistics_request(struct work_struct *work)
116{
117 struct iwm_priv *iwm =
118 container_of(work, struct iwm_priv, stats_request.work);
119
120 iwm_send_umac_stats_req(iwm, 0);
121}
122
c7436273
ZY		 123static void iwm_disconnect_work(struct work_struct *work)
124{
125 struct iwm_priv *iwm =
126 container_of(work, struct iwm_priv, disconnect.work);
127
128 if (iwm->umac_profile_active)
129 iwm_invalidate_mlme_profile(iwm);
130
131 clear_bit(IWM_STATUS_ASSOCIATED, &iwm->status);
132 iwm->umac_profile_active = 0;
133 memset(iwm->bssid, 0, ETH_ALEN);
134 iwm->channel = 0;
135
136 iwm_link_off(iwm);
137
138 wake_up_interruptible(&iwm->mlme_queue);
139
140 cfg80211_disconnected(iwm_to_ndev(iwm), 0, NULL, 0, GFP_KERNEL);
141}
142
e85498b2
SO		 143static void iwm_ct_kill_work(struct work_struct *work)
144{
145 struct iwm_priv *iwm =
146 container_of(work, struct iwm_priv, ct_kill_delay.work);
147 struct wiphy *wiphy = iwm_to_wiphy(iwm);
148
149 IWM_INFO(iwm, "CT kill delay timeout\n");
150
151 wiphy_rfkill_set_hw_state(wiphy, false);
152}
153
31452420
ZY		 154static int __iwm_up(struct iwm_priv *iwm);
155static int __iwm_down(struct iwm_priv *iwm);
68810c5d 156
bb9f8692
ZY		 157static void iwm_reset_worker(struct work_struct *work)
158{
159 struct iwm_priv *iwm;
160 struct iwm_umac_profile *profile = NULL;
161 int uninitialized_var(ret), retry = 0;
162
163 iwm = container_of(work, struct iwm_priv, reset_worker);
164
68810c5d
ZY		 165 /*
166 * XXX: The iwm->mutex is introduced purely for this reset work,
167 * because the other users for iwm_up and iwm_down are only netdev
168 * ndo_open and ndo_stop which are already protected by rtnl.
169 * Please remove iwm->mutex together if iwm_reset_worker() is not
170 * required in the future.
171 */
172 if (!mutex_trylock(&iwm->mutex)) {
173 IWM_WARN(iwm, "We are in the middle of interface bringing "
174 "UP/DOWN. Skip driver resetting.\n");
175 return;
176 }
177
bb9f8692
ZY		 178 if (iwm->umac_profile_active) {
179 profile = kmalloc(sizeof(struct iwm_umac_profile), GFP_KERNEL);
180 if (profile)
181 memcpy(profile, iwm->umac_profile, sizeof(*profile));
182 else
183 IWM_ERR(iwm, "Couldn't alloc memory for profile\n");
184 }
185
68810c5d 186 __iwm_down(iwm);
bb9f8692
ZY		 187
188 while (retry++ < 3) {
68810c5d 189 ret = __iwm_up(iwm);
bb9f8692
ZY		 190 if (!ret)
191 break;
192
193 schedule_timeout_uninterruptible(10 * HZ);
194 }
195
196 if (ret) {
197 IWM_WARN(iwm, "iwm_up() failed: %d\n", ret);
198
199 kfree(profile);
68810c5d 200 goto out;
bb9f8692
ZY		 201 }
202
203 if (profile) {
204 IWM_DBG_MLME(iwm, DBG, "Resend UMAC profile\n");
205 memcpy(iwm->umac_profile, profile, sizeof(*profile));
206 iwm_send_mlme_profile(iwm);
207 kfree(profile);
d210176e
SO		 208 } else
209 clear_bit(IWM_STATUS_RESETTING, &iwm->status);
68810c5d
ZY		 210
211 out:
212 mutex_unlock(&iwm->mutex);
bb9f8692
ZY		 213}
214
9829e1b5
SO		 215static void iwm_auth_retry_worker(struct work_struct *work)
216{
217 struct iwm_priv *iwm;
218 int i, ret;
219
220 iwm = container_of(work, struct iwm_priv, auth_retry_worker);
221 if (iwm->umac_profile_active) {
222 ret = iwm_invalidate_mlme_profile(iwm);
223 if (ret < 0)
224 return;
225 }
226
227 iwm->umac_profile->sec.auth_type = UMAC_AUTH_TYPE_LEGACY_PSK;
228
229 ret = iwm_send_mlme_profile(iwm);
230 if (ret < 0)
231 return;
232
233 for (i = 0; i < IWM_NUM_KEYS; i++)
234 if (iwm->keys[i].key_len)
235 iwm_set_key(iwm, 0, &iwm->keys[i]);
236
237 iwm_set_tx_key(iwm, iwm->default_key);
238}
239
240
241
bb9f8692
ZY		 242static void iwm_watchdog(unsigned long data)
243{
244 struct iwm_priv *iwm = (struct iwm_priv *)data;
245
246 IWM_WARN(iwm, "Watchdog expired: UMAC stalls!\n");
247
248 if (modparam_reset)
d210176e 249 iwm_resetting(iwm);
bb9f8692
ZY		 250}
251
252int iwm_priv_init(struct iwm_priv *iwm)
253{
a7af530d 254 int i, j;
bb9f8692
ZY		 255 char name[32];
256
257 iwm->status = 0;
258 INIT_LIST_HEAD(&iwm->pending_notif);
259 init_waitqueue_head(&iwm->notif_queue);
260 init_waitqueue_head(&iwm->nonwifi_queue);
a70742f1 261 init_waitqueue_head(&iwm->wifi_ntfy_queue);
bb9f8692
ZY		 262 init_waitqueue_head(&iwm->mlme_queue);
263 memcpy(&iwm->conf, &def_iwm_conf, sizeof(struct iwm_conf));
264 spin_lock_init(&iwm->tx_credit.lock);
265 INIT_LIST_HEAD(&iwm->wifi_pending_cmd);
266 INIT_LIST_HEAD(&iwm->nonwifi_pending_cmd);
267 iwm->wifi_seq_num = UMAC_WIFI_SEQ_NUM_BASE;
268 iwm->nonwifi_seq_num = UMAC_NONWIFI_SEQ_NUM_BASE;
269 spin_lock_init(&iwm->cmd_lock);
270 iwm->scan_id = 1;
271 INIT_DELAYED_WORK(&iwm->stats_request, iwm_statistics_request);
c7436273 272 INIT_DELAYED_WORK(&iwm->disconnect, iwm_disconnect_work);
e85498b2 273 INIT_DELAYED_WORK(&iwm->ct_kill_delay, iwm_ct_kill_work);
bb9f8692 274 INIT_WORK(&iwm->reset_worker, iwm_reset_worker);
9829e1b5 275 INIT_WORK(&iwm->auth_retry_worker, iwm_auth_retry_worker);
bb9f8692
ZY		 276 INIT_LIST_HEAD(&iwm->bss_list);
277
278 skb_queue_head_init(&iwm->rx_list);
279 INIT_LIST_HEAD(&iwm->rx_tickets);
280 for (i = 0; i < IWM_RX_ID_HASH; i++)
281 INIT_LIST_HEAD(&iwm->rx_packets[i]);
282
283 INIT_WORK(&iwm->rx_worker, iwm_rx_worker);
284
285 iwm->rx_wq = create_singlethread_workqueue(KBUILD_MODNAME "_rx");
286 if (!iwm->rx_wq)
287 return -EAGAIN;
288
289 for (i = 0; i < IWM_TX_QUEUES; i++) {
290 INIT_WORK(&iwm->txq[i].worker, iwm_tx_worker);
291 snprintf(name, 32, KBUILD_MODNAME "_tx_%d", i);
292 iwm->txq[i].id = i;
293 iwm->txq[i].wq = create_singlethread_workqueue(name);
294 if (!iwm->txq[i].wq)
295 return -EAGAIN;
296
297 skb_queue_head_init(&iwm->txq[i].queue);
a7af530d
SO		 298 skb_queue_head_init(&iwm->txq[i].stopped_queue);
299 spin_lock_init(&iwm->txq[i].lock);
bb9f8692
ZY		 300 }
301
302 for (i = 0; i < IWM_NUM_KEYS; i++)
303 memset(&iwm->keys[i], 0, sizeof(struct iwm_key));
304
13e0fe70 305 iwm->default_key = -1;
bb9f8692 306
a7af530d
SO		 307 for (i = 0; i < IWM_STA_TABLE_NUM; i++)
308 for (j = 0; j < IWM_UMAC_TID_NR; j++) {
309 mutex_init(&iwm->sta_table[i].tid_info[j].mutex);
310 iwm->sta_table[i].tid_info[j].stopped = false;
311 }
312
bb9f8692
ZY		 313 init_timer(&iwm->watchdog);
314 iwm->watchdog.function = iwm_watchdog;
315 iwm->watchdog.data = (unsigned long)iwm;
68810c5d 316 mutex_init(&iwm->mutex);
bb9f8692 317
04e715cd
SO		 318 iwm->last_fw_err = kzalloc(sizeof(struct iwm_fw_error_hdr),
319 GFP_KERNEL);
320 if (iwm->last_fw_err == NULL)
321 return -ENOMEM;
322
bb9f8692
ZY		 323 return 0;
324}
325
8d96e796
ZY		 326void iwm_priv_deinit(struct iwm_priv *iwm)
327{
328 int i;
329
330 for (i = 0; i < IWM_TX_QUEUES; i++)
331 destroy_workqueue(iwm->txq[i].wq);
332
333 destroy_workqueue(iwm->rx_wq);
04e715cd 334 kfree(iwm->last_fw_err);
8d96e796
ZY		 335}
336
bb9f8692
ZY		 337/*
338 * We reset all the structures, and we reset the UMAC.
339 * After calling this routine, you're expected to reload
340 * the firmware.
341 */
342void iwm_reset(struct iwm_priv *iwm)
343{
344 struct iwm_notif *notif, *next;
345
346 if (test_bit(IWM_STATUS_READY, &iwm->status))
347 iwm_target_reset(iwm);
348
d210176e
SO		 349 if (test_bit(IWM_STATUS_RESETTING, &iwm->status)) {
350 iwm->status = 0;
351 set_bit(IWM_STATUS_RESETTING, &iwm->status);
352 } else
353 iwm->status = 0;
bb9f8692
ZY		 354 iwm->scan_id = 1;
355
356 list_for_each_entry_safe(notif, next, &iwm->pending_notif, pending) {
357 list_del(&notif->pending);
358 kfree(notif->buf);
359 kfree(notif);
360 }
361
362 iwm_cmd_flush(iwm);
363
364 flush_workqueue(iwm->rx_wq);
365
366 iwm_link_off(iwm);
367}
368
d210176e
SO		 369void iwm_resetting(struct iwm_priv *iwm)
370{
371 set_bit(IWM_STATUS_RESETTING, &iwm->status);
372
373 schedule_work(&iwm->reset_worker);
374}
375
bb9f8692
ZY		 376/*
377 * Notification code:
378 *
379 * We're faced with the following issue: Any host command can
380 * have an answer or not, and if there's an answer to expect,
381 * it can be treated synchronously or asynchronously.
382 * To work around the synchronous answer case, we implemented
383 * our notification mechanism.
384 * When a code path needs to wait for a command response
385 * synchronously, it calls notif_handle(), which waits for the
386 * right notification to show up, and then process it. Before
387 * starting to wait, it registered as a waiter for this specific
388 * answer (by toggling a bit in on of the handler_map), so that
389 * the rx code knows that it needs to send a notification to the
390 * waiting processes. It does so by calling iwm_notif_send(),
391 * which adds the notification to the pending notifications list,
392 * and then wakes the waiting processes up.
393 */
394int iwm_notif_send(struct iwm_priv *iwm, struct iwm_wifi_cmd *cmd,
395 u8 cmd_id, u8 source, u8 *buf, unsigned long buf_size)
396{
397 struct iwm_notif *notif;
398
399 notif = kzalloc(sizeof(struct iwm_notif), GFP_KERNEL);
400 if (!notif) {
401 IWM_ERR(iwm, "Couldn't alloc memory for notification\n");
402 return -ENOMEM;
403 }
404
405 INIT_LIST_HEAD(&notif->pending);
406 notif->cmd = cmd;
407 notif->cmd_id = cmd_id;
408 notif->src = source;
409 notif->buf = kzalloc(buf_size, GFP_KERNEL);
410 if (!notif->buf) {
411 IWM_ERR(iwm, "Couldn't alloc notification buffer\n");
412 kfree(notif);
413 return -ENOMEM;
414 }
415 notif->buf_size = buf_size;
416 memcpy(notif->buf, buf, buf_size);
417 list_add_tail(&notif->pending, &iwm->pending_notif);
418
419 wake_up_interruptible(&iwm->notif_queue);
420
421 return 0;
422}
423
424static struct iwm_notif *iwm_notif_find(struct iwm_priv *iwm, u32 cmd,
425 u8 source)
426{
427 struct iwm_notif *notif, *next;
428
429 list_for_each_entry_safe(notif, next, &iwm->pending_notif, pending) {
430 if ((notif->cmd_id == cmd) && (notif->src == source)) {
431 list_del(&notif->pending);
432 return notif;
433 }
434 }
435
436 return NULL;
437}
438
439static struct iwm_notif *iwm_notif_wait(struct iwm_priv *iwm, u32 cmd,
440 u8 source, long timeout)
441{
442 int ret;
443 struct iwm_notif *notif;
444 unsigned long *map = NULL;
445
446 switch (source) {
447 case IWM_SRC_LMAC:
448 map = &iwm->lmac_handler_map[0];
449 break;
450 case IWM_SRC_UMAC:
451 map = &iwm->umac_handler_map[0];
452 break;
453 case IWM_SRC_UDMA:
454 map = &iwm->udma_handler_map[0];
455 break;
456 }
457
458 set_bit(cmd, map);
459
460 ret = wait_event_interruptible_timeout(iwm->notif_queue,
461 ((notif = iwm_notif_find(iwm, cmd, source)) != NULL),
462 timeout);
463 clear_bit(cmd, map);
464
465 if (!ret)
466 return NULL;
467
468 return notif;
469}
470
471int iwm_notif_handle(struct iwm_priv *iwm, u32 cmd, u8 source, long timeout)
472{
473 int ret;
474 struct iwm_notif *notif;
475
476 notif = iwm_notif_wait(iwm, cmd, source, timeout);
477 if (!notif)
478 return -ETIME;
479
480 ret = iwm_rx_handle_resp(iwm, notif->buf, notif->buf_size, notif->cmd);
481 kfree(notif->buf);
482 kfree(notif);
483
484 return ret;
485}
486
487static int iwm_config_boot_params(struct iwm_priv *iwm)
488{
489 struct iwm_udma_nonwifi_cmd target_cmd;
490 int ret;
491
492 /* check Wimax is off and config debug monitor */
159bcfeb 493 if (!modparam_wimax_enable) {
bb9f8692
ZY		 494 u32 data1 = 0x1f;
495 u32 addr1 = 0x606BE258;
496
497 u32 data2_set = 0x0;
498 u32 data2_clr = 0x1;
499 u32 addr2 = 0x606BE100;
500
501 u32 data3 = 0x1;
502 u32 addr3 = 0x606BEC00;
503
504 target_cmd.resp = 0;
505 target_cmd.handle_by_hw = 0;
506 target_cmd.eop = 1;
507
508 target_cmd.opcode = UMAC_HDI_OUT_OPCODE_WRITE;
509 target_cmd.addr = cpu_to_le32(addr1);
510 target_cmd.op1_sz = cpu_to_le32(sizeof(u32));
511 target_cmd.op2 = 0;
512
513 ret = iwm_hal_send_target_cmd(iwm, &target_cmd, &data1);
514 if (ret < 0) {
515 IWM_ERR(iwm, "iwm_hal_send_target_cmd failed\n");
516 return ret;
517 }
518
519 target_cmd.opcode = UMAC_HDI_OUT_OPCODE_READ_MODIFY_WRITE;
520 target_cmd.addr = cpu_to_le32(addr2);
521 target_cmd.op1_sz = cpu_to_le32(data2_set);
522 target_cmd.op2 = cpu_to_le32(data2_clr);
523
524 ret = iwm_hal_send_target_cmd(iwm, &target_cmd, &data1);
525 if (ret < 0) {
526 IWM_ERR(iwm, "iwm_hal_send_target_cmd failed\n");
527 return ret;
528 }
529
530 target_cmd.opcode = UMAC_HDI_OUT_OPCODE_WRITE;
531 target_cmd.addr = cpu_to_le32(addr3);
532 target_cmd.op1_sz = cpu_to_le32(sizeof(u32));
533 target_cmd.op2 = 0;
534
535 ret = iwm_hal_send_target_cmd(iwm, &target_cmd, &data3);
536 if (ret < 0) {
537 IWM_ERR(iwm, "iwm_hal_send_target_cmd failed\n");
538 return ret;
539 }
540 }
541
542 return 0;
543}
544
545void iwm_init_default_profile(struct iwm_priv *iwm,
546 struct iwm_umac_profile *profile)
547{
548 memset(profile, 0, sizeof(struct iwm_umac_profile));
549
550 profile->sec.auth_type = UMAC_AUTH_TYPE_OPEN;
551 profile->sec.flags = UMAC_SEC_FLG_LEGACY_PROFILE;
552 profile->sec.ucast_cipher = UMAC_CIPHER_TYPE_NONE;
553 profile->sec.mcast_cipher = UMAC_CIPHER_TYPE_NONE;
554
555 if (iwm->conf.enable_qos)
556 profile->flags |= cpu_to_le16(UMAC_PROFILE_QOS_ALLOWED);
557
558 profile->wireless_mode = iwm->conf.wireless_mode;
559 profile->mode = cpu_to_le32(iwm->conf.mode);
560
561 profile->ibss.atim = 0;
562 profile->ibss.beacon_interval = 100;
563 profile->ibss.join_only = 0;
564 profile->ibss.band = iwm->conf.ibss_band;
565 profile->ibss.channel = iwm->conf.ibss_channel;
566}
567
568void iwm_link_on(struct iwm_priv *iwm)
569{
570 netif_carrier_on(iwm_to_ndev(iwm));
571 netif_tx_wake_all_queues(iwm_to_ndev(iwm));
572
573 iwm_send_umac_stats_req(iwm, 0);
574}
575
576void iwm_link_off(struct iwm_priv *iwm)
577{
578 struct iw_statistics *wstats = &iwm->wstats;
579 int i;
580
581 netif_tx_stop_all_queues(iwm_to_ndev(iwm));
582 netif_carrier_off(iwm_to_ndev(iwm));
583
584 for (i = 0; i < IWM_TX_QUEUES; i++) {
585 skb_queue_purge(&iwm->txq[i].queue);
a7af530d 586 skb_queue_purge(&iwm->txq[i].stopped_queue);
bb9f8692
ZY		 587
588 iwm->txq[i].concat_count = 0;
589 iwm->txq[i].concat_ptr = iwm->txq[i].concat_buf;
590
591 flush_workqueue(iwm->txq[i].wq);
592 }
593
594 iwm_rx_free(iwm);
595
68810c5d 596 cancel_delayed_work_sync(&iwm->stats_request);
bb9f8692
ZY		 597 memset(wstats, 0, sizeof(struct iw_statistics));
598 wstats->qual.updated = IW_QUAL_ALL_INVALID;
599
b68518fc
ZY		 600 kfree(iwm->req_ie);
601 iwm->req_ie = NULL;
602 iwm->req_ie_len = 0;
603 kfree(iwm->resp_ie);
604 iwm->resp_ie = NULL;
605 iwm->resp_ie_len = 0;
606
bb9f8692
ZY		 607 del_timer_sync(&iwm->watchdog);
608}
609
610static void iwm_bss_list_clean(struct iwm_priv *iwm)
611{
612 struct iwm_bss_info *bss, *next;
613
614 list_for_each_entry_safe(bss, next, &iwm->bss_list, node) {
615 list_del(&bss->node);
616 kfree(bss->bss);
617 kfree(bss);
618 }
619}
620
621static int iwm_channels_init(struct iwm_priv *iwm)
622{
623 int ret;
624
bb9f8692
ZY		 625 ret = iwm_send_umac_channel_list(iwm);
626 if (ret) {
627 IWM_ERR(iwm, "Send channel list failed\n");
628 return ret;
629 }
630
631 ret = iwm_notif_handle(iwm, UMAC_CMD_OPCODE_GET_CHAN_INFO_LIST,
632 IWM_SRC_UMAC, WAIT_NOTIF_TIMEOUT);
633 if (ret) {
634 IWM_ERR(iwm, "Didn't get a channel list notification\n");
635 return ret;
636 }
637
638 return 0;
639}
640
31452420 641static int __iwm_up(struct iwm_priv *iwm)
bb9f8692
ZY		 642{
643 int ret;
644 struct iwm_notif *notif_reboot, *notif_ack = NULL;
5dc53163 645 struct wiphy *wiphy = iwm_to_wiphy(iwm);
0bed08de 646 u32 wireless_mode;
bb9f8692
ZY		 647
648 ret = iwm_bus_enable(iwm);
649 if (ret) {
650 IWM_ERR(iwm, "Couldn't enable function\n");
651 return ret;
652 }
653
654 iwm_rx_setup_handlers(iwm);
655
656 /* Wait for initial BARKER_REBOOT from hardware */
657 notif_reboot = iwm_notif_wait(iwm, IWM_BARKER_REBOOT_NOTIFICATION,
658 IWM_SRC_UDMA, 2 * HZ);
659 if (!notif_reboot) {
660 IWM_ERR(iwm, "Wait for REBOOT_BARKER timeout\n");
661 goto err_disable;
662 }
663
664 /* We send the barker back */
665 ret = iwm_bus_send_chunk(iwm, notif_reboot->buf, 16);
666 if (ret) {
667 IWM_ERR(iwm, "REBOOT barker response failed\n");
668 kfree(notif_reboot);
669 goto err_disable;
670 }
671
672 kfree(notif_reboot->buf);
673 kfree(notif_reboot);
674
675 /* Wait for ACK_BARKER from hardware */
676 notif_ack = iwm_notif_wait(iwm, IWM_ACK_BARKER_NOTIFICATION,
677 IWM_SRC_UDMA, 2 * HZ);
678 if (!notif_ack) {
679 IWM_ERR(iwm, "Wait for ACK_BARKER timeout\n");
680 goto err_disable;
681 }
682
683 kfree(notif_ack->buf);
684 kfree(notif_ack);
685
686 /* We start to config static boot parameters */
687 ret = iwm_config_boot_params(iwm);
688 if (ret) {
689 IWM_ERR(iwm, "Config boot parameters failed\n");
690 goto err_disable;
691 }
692
693 ret = iwm_read_mac(iwm, iwm_to_ndev(iwm)->dev_addr);
694 if (ret) {
695 IWM_ERR(iwm, "MAC reading failed\n");
696 goto err_disable;
697 }
5b367378
JL		 698 memcpy(iwm_to_ndev(iwm)->perm_addr, iwm_to_ndev(iwm)->dev_addr,
699 ETH_ALEN);
bb9f8692
ZY		 700
701 /* We can load the FWs */
702 ret = iwm_load_fw(iwm);
703 if (ret) {
704 IWM_ERR(iwm, "FW loading failed\n");
705 goto err_disable;
706 }
707
902b6667
SO		 708 ret = iwm_eeprom_fat_channels(iwm);
709 if (ret) {
710 IWM_ERR(iwm, "Couldnt read HT channels EEPROM entries\n");
711 goto err_fw;
712 }
713
0bed08de
SO		 714 /*
715 * Read our SKU capabilities.
2351178c
ZY		 716 * If it's valid, we AND the configured wireless mode with the
717 * device EEPROM value as the current profile wireless mode.
0bed08de
SO		 718 */
719 wireless_mode = iwm_eeprom_wireless_mode(iwm);
720 if (wireless_mode) {
2351178c 721 iwm->conf.wireless_mode &= wireless_mode;
0bed08de
SO		 722 if (iwm->umac_profile)
723 iwm->umac_profile->wireless_mode =
724 iwm->conf.wireless_mode;
725 } else
726 IWM_ERR(iwm, "Wrong SKU capabilities: 0x%x\n",
727 *((u16 *)iwm_eeprom_access(iwm, IWM_EEPROM_SKU_CAP)));
728
5dc53163
SO		 729 snprintf(wiphy->fw_version, sizeof(wiphy->fw_version), "L%s_U%s",
730 iwm->lmac_version, iwm->umac_version);
731
bb9f8692
ZY		 732 /* We configure the UMAC and enable the wifi module */
733 ret = iwm_send_umac_config(iwm,
734 cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_CORE_EN) |
735 cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_LINK_EN) |
736 cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_MLME_EN));
737 if (ret) {
738 IWM_ERR(iwm, "UMAC config failed\n");
739 goto err_fw;
740 }
741
742 ret = iwm_notif_handle(iwm, UMAC_NOTIFY_OPCODE_WIFI_CORE_STATUS,
743 IWM_SRC_UMAC, WAIT_NOTIF_TIMEOUT);
744 if (ret) {
745 IWM_ERR(iwm, "Didn't get a wifi core status notification\n");
746 goto err_fw;
747 }
748
749 if (iwm->core_enabled != (UMAC_NTFY_WIFI_CORE_STATUS_LINK_EN |
750 UMAC_NTFY_WIFI_CORE_STATUS_MLME_EN)) {
751 IWM_DBG_BOOT(iwm, DBG, "Not all cores enabled:0x%x\n",
752 iwm->core_enabled);
753 ret = iwm_notif_handle(iwm, UMAC_NOTIFY_OPCODE_WIFI_CORE_STATUS,
754 IWM_SRC_UMAC, WAIT_NOTIF_TIMEOUT);
755 if (ret) {
756 IWM_ERR(iwm, "Didn't get a core status notification\n");
757 goto err_fw;
758 }
759
760 if (iwm->core_enabled != (UMAC_NTFY_WIFI_CORE_STATUS_LINK_EN |
761 UMAC_NTFY_WIFI_CORE_STATUS_MLME_EN)) {
762 IWM_ERR(iwm, "Not all cores enabled: 0x%x\n",
763 iwm->core_enabled);
764 goto err_fw;
765 } else {
766 IWM_INFO(iwm, "All cores enabled\n");
767 }
768 }
769
bb9f8692
ZY		 770 ret = iwm_channels_init(iwm);
771 if (ret < 0) {
772 IWM_ERR(iwm, "Couldn't init channels\n");
35497164 773 goto err_fw;
bb9f8692
ZY		 774 }
775
776 /* Set the READY bit to indicate interface is brought up successfully */
777 set_bit(IWM_STATUS_READY, &iwm->status);
778
779 return 0;
780
bb9f8692
ZY		 781 err_fw:
782 iwm_eeprom_exit(iwm);
783
784 err_disable:
785 ret = iwm_bus_disable(iwm);
786 if (ret < 0)
787 IWM_ERR(iwm, "Couldn't disable function\n");
788
789 return -EIO;
790}
791
68810c5d
ZY		 792int iwm_up(struct iwm_priv *iwm)
793{
794 int ret;
795
796 mutex_lock(&iwm->mutex);
797 ret = __iwm_up(iwm);
798 mutex_unlock(&iwm->mutex);
799
800 return ret;
801}
802
31452420 803static int __iwm_down(struct iwm_priv *iwm)
bb9f8692
ZY		 804{
805 int ret;
806
807 /* The interface is already down */
808 if (!test_bit(IWM_STATUS_READY, &iwm->status))
809 return 0;
810
811 if (iwm->scan_request) {
812 cfg80211_scan_done(iwm->scan_request, true);
813 iwm->scan_request = NULL;
814 }
815
816 clear_bit(IWM_STATUS_READY, &iwm->status);
817
818 iwm_eeprom_exit(iwm);
bb9f8692 819 iwm_bss_list_clean(iwm);
35497164
SO		 820 iwm_init_default_profile(iwm, iwm->umac_profile);
821 iwm->umac_profile_active = false;
13e0fe70 822 iwm->default_key = -1;
bb9f8692
ZY		 823 iwm->core_enabled = 0;
824
825 ret = iwm_bus_disable(iwm);
826 if (ret < 0) {
827 IWM_ERR(iwm, "Couldn't disable function\n");
828 return ret;
829 }
830
831 return 0;
832}
68810c5d
ZY		 833
834int iwm_down(struct iwm_priv *iwm)
835{
836 int ret;
837
838 mutex_lock(&iwm->mutex);
839 ret = __iwm_down(iwm);
840 mutex_unlock(&iwm->mutex);
841
842 return ret;
843}
kernel source for telekom puls (alcatel/mediatek)