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