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