2 * Intel Wireless Multicomm 3200 WiFi driver
4 * Copyright (C) 2009 Intel Corporation. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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
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.
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.
33 * Intel Corporation <ilw@linux.intel.com>
34 * Samuel Ortiz <samuel.ortiz@intel.com>
35 * Zhu Yi <yi.zhu@intel.com>
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>
54 static struct iwm_conf def_iwm_conf
= {
56 .sdio_ior_timeout
= 5000,
57 .calib_map
= BIT(CALIB_CFG_DC_IDX
) |
58 BIT(CALIB_CFG_LO_IDX
) |
59 BIT(CALIB_CFG_TX_IQ_IDX
) |
60 BIT(CALIB_CFG_RX_IQ_IDX
) |
61 BIT(SHILOH_PHY_CALIBRATE_BASE_BAND_CMD
),
62 .expected_calib_map
= BIT(PHY_CALIBRATE_DC_CMD
) |
63 BIT(PHY_CALIBRATE_LO_CMD
) |
64 BIT(PHY_CALIBRATE_TX_IQ_CMD
) |
65 BIT(PHY_CALIBRATE_RX_IQ_CMD
) |
66 BIT(SHILOH_PHY_CALIBRATE_BASE_BAND_CMD
),
69 .reset_on_fatal_err
= 1,
71 .wimax_not_present
= 0,
73 .mode
= UMAC_MODE_BSS
,
75 /* UMAC configuration */
77 .frag_threshold
= IEEE80211_MAX_FRAG_THRESHOLD
,
78 .rts_threshold
= IEEE80211_MAX_RTS_THRESHOLD
,
83 .wireless_mode
= WIRELESS_MODE_11A
| WIRELESS_MODE_11G
|
85 .coexist_mode
= COEX_MODE_CM
,
88 .ibss_band
= UMAC_BAND_2GHZ
,
91 .mac_addr
= {0x00, 0x02, 0xb3, 0x01, 0x02, 0x03},
94 static int modparam_reset
;
95 module_param_named(reset
, modparam_reset
, bool, 0644);
96 MODULE_PARM_DESC(reset
, "reset on firmware errors (default 0 [not reset])");
98 int iwm_mode_to_nl80211_iftype(int mode
)
102 return NL80211_IFTYPE_STATION
;
104 return NL80211_IFTYPE_ADHOC
;
106 return NL80211_IFTYPE_UNSPECIFIED
;
112 static void iwm_statistics_request(struct work_struct
*work
)
114 struct iwm_priv
*iwm
=
115 container_of(work
, struct iwm_priv
, stats_request
.work
);
117 iwm_send_umac_stats_req(iwm
, 0);
120 static void iwm_disconnect_work(struct work_struct
*work
)
122 struct iwm_priv
*iwm
=
123 container_of(work
, struct iwm_priv
, disconnect
.work
);
125 if (iwm
->umac_profile_active
)
126 iwm_invalidate_mlme_profile(iwm
);
128 clear_bit(IWM_STATUS_ASSOCIATED
, &iwm
->status
);
129 iwm
->umac_profile_active
= 0;
130 memset(iwm
->bssid
, 0, ETH_ALEN
);
135 wake_up_interruptible(&iwm
->mlme_queue
);
137 cfg80211_disconnected(iwm_to_ndev(iwm
), 0, NULL
, 0, GFP_KERNEL
);
140 static void iwm_ct_kill_work(struct work_struct
*work
)
142 struct iwm_priv
*iwm
=
143 container_of(work
, struct iwm_priv
, ct_kill_delay
.work
);
144 struct wiphy
*wiphy
= iwm_to_wiphy(iwm
);
146 IWM_INFO(iwm
, "CT kill delay timeout\n");
148 wiphy_rfkill_set_hw_state(wiphy
, false);
151 static int __iwm_up(struct iwm_priv
*iwm
);
152 static int __iwm_down(struct iwm_priv
*iwm
);
154 static void iwm_reset_worker(struct work_struct
*work
)
156 struct iwm_priv
*iwm
;
157 struct iwm_umac_profile
*profile
= NULL
;
158 int uninitialized_var(ret
), retry
= 0;
160 iwm
= container_of(work
, struct iwm_priv
, reset_worker
);
163 * XXX: The iwm->mutex is introduced purely for this reset work,
164 * because the other users for iwm_up and iwm_down are only netdev
165 * ndo_open and ndo_stop which are already protected by rtnl.
166 * Please remove iwm->mutex together if iwm_reset_worker() is not
167 * required in the future.
169 if (!mutex_trylock(&iwm
->mutex
)) {
170 IWM_WARN(iwm
, "We are in the middle of interface bringing "
171 "UP/DOWN. Skip driver resetting.\n");
175 if (iwm
->umac_profile_active
) {
176 profile
= kmalloc(sizeof(struct iwm_umac_profile
), GFP_KERNEL
);
178 memcpy(profile
, iwm
->umac_profile
, sizeof(*profile
));
180 IWM_ERR(iwm
, "Couldn't alloc memory for profile\n");
185 while (retry
++ < 3) {
190 schedule_timeout_uninterruptible(10 * HZ
);
194 IWM_WARN(iwm
, "iwm_up() failed: %d\n", ret
);
201 IWM_DBG_MLME(iwm
, DBG
, "Resend UMAC profile\n");
202 memcpy(iwm
->umac_profile
, profile
, sizeof(*profile
));
203 iwm_send_mlme_profile(iwm
);
206 clear_bit(IWM_STATUS_RESETTING
, &iwm
->status
);
209 mutex_unlock(&iwm
->mutex
);
212 static void iwm_auth_retry_worker(struct work_struct
*work
)
214 struct iwm_priv
*iwm
;
217 iwm
= container_of(work
, struct iwm_priv
, auth_retry_worker
);
218 if (iwm
->umac_profile_active
) {
219 ret
= iwm_invalidate_mlme_profile(iwm
);
224 iwm
->umac_profile
->sec
.auth_type
= UMAC_AUTH_TYPE_LEGACY_PSK
;
226 ret
= iwm_send_mlme_profile(iwm
);
230 for (i
= 0; i
< IWM_NUM_KEYS
; i
++)
231 if (iwm
->keys
[i
].key_len
)
232 iwm_set_key(iwm
, 0, &iwm
->keys
[i
]);
234 iwm_set_tx_key(iwm
, iwm
->default_key
);
239 static void iwm_watchdog(unsigned long data
)
241 struct iwm_priv
*iwm
= (struct iwm_priv
*)data
;
243 IWM_WARN(iwm
, "Watchdog expired: UMAC stalls!\n");
249 int iwm_priv_init(struct iwm_priv
*iwm
)
255 INIT_LIST_HEAD(&iwm
->pending_notif
);
256 init_waitqueue_head(&iwm
->notif_queue
);
257 init_waitqueue_head(&iwm
->nonwifi_queue
);
258 init_waitqueue_head(&iwm
->wifi_ntfy_queue
);
259 init_waitqueue_head(&iwm
->mlme_queue
);
260 memcpy(&iwm
->conf
, &def_iwm_conf
, sizeof(struct iwm_conf
));
261 spin_lock_init(&iwm
->tx_credit
.lock
);
262 INIT_LIST_HEAD(&iwm
->wifi_pending_cmd
);
263 INIT_LIST_HEAD(&iwm
->nonwifi_pending_cmd
);
264 iwm
->wifi_seq_num
= UMAC_WIFI_SEQ_NUM_BASE
;
265 iwm
->nonwifi_seq_num
= UMAC_NONWIFI_SEQ_NUM_BASE
;
266 spin_lock_init(&iwm
->cmd_lock
);
268 INIT_DELAYED_WORK(&iwm
->stats_request
, iwm_statistics_request
);
269 INIT_DELAYED_WORK(&iwm
->disconnect
, iwm_disconnect_work
);
270 INIT_DELAYED_WORK(&iwm
->ct_kill_delay
, iwm_ct_kill_work
);
271 INIT_WORK(&iwm
->reset_worker
, iwm_reset_worker
);
272 INIT_WORK(&iwm
->auth_retry_worker
, iwm_auth_retry_worker
);
273 INIT_LIST_HEAD(&iwm
->bss_list
);
275 skb_queue_head_init(&iwm
->rx_list
);
276 INIT_LIST_HEAD(&iwm
->rx_tickets
);
277 for (i
= 0; i
< IWM_RX_ID_HASH
; i
++)
278 INIT_LIST_HEAD(&iwm
->rx_packets
[i
]);
280 INIT_WORK(&iwm
->rx_worker
, iwm_rx_worker
);
282 iwm
->rx_wq
= create_singlethread_workqueue(KBUILD_MODNAME
"_rx");
286 for (i
= 0; i
< IWM_TX_QUEUES
; i
++) {
287 INIT_WORK(&iwm
->txq
[i
].worker
, iwm_tx_worker
);
288 snprintf(name
, 32, KBUILD_MODNAME
"_tx_%d", i
);
290 iwm
->txq
[i
].wq
= create_singlethread_workqueue(name
);
294 skb_queue_head_init(&iwm
->txq
[i
].queue
);
297 for (i
= 0; i
< IWM_NUM_KEYS
; i
++)
298 memset(&iwm
->keys
[i
], 0, sizeof(struct iwm_key
));
300 iwm
->default_key
= -1;
302 init_timer(&iwm
->watchdog
);
303 iwm
->watchdog
.function
= iwm_watchdog
;
304 iwm
->watchdog
.data
= (unsigned long)iwm
;
305 mutex_init(&iwm
->mutex
);
307 iwm
->last_fw_err
= kzalloc(sizeof(struct iwm_fw_error_hdr
),
309 if (iwm
->last_fw_err
== NULL
)
315 void iwm_priv_deinit(struct iwm_priv
*iwm
)
319 for (i
= 0; i
< IWM_TX_QUEUES
; i
++)
320 destroy_workqueue(iwm
->txq
[i
].wq
);
322 destroy_workqueue(iwm
->rx_wq
);
323 kfree(iwm
->last_fw_err
);
327 * We reset all the structures, and we reset the UMAC.
328 * After calling this routine, you're expected to reload
331 void iwm_reset(struct iwm_priv
*iwm
)
333 struct iwm_notif
*notif
, *next
;
335 if (test_bit(IWM_STATUS_READY
, &iwm
->status
))
336 iwm_target_reset(iwm
);
338 if (test_bit(IWM_STATUS_RESETTING
, &iwm
->status
)) {
340 set_bit(IWM_STATUS_RESETTING
, &iwm
->status
);
345 list_for_each_entry_safe(notif
, next
, &iwm
->pending_notif
, pending
) {
346 list_del(¬if
->pending
);
353 flush_workqueue(iwm
->rx_wq
);
358 void iwm_resetting(struct iwm_priv
*iwm
)
360 set_bit(IWM_STATUS_RESETTING
, &iwm
->status
);
362 schedule_work(&iwm
->reset_worker
);
368 * We're faced with the following issue: Any host command can
369 * have an answer or not, and if there's an answer to expect,
370 * it can be treated synchronously or asynchronously.
371 * To work around the synchronous answer case, we implemented
372 * our notification mechanism.
373 * When a code path needs to wait for a command response
374 * synchronously, it calls notif_handle(), which waits for the
375 * right notification to show up, and then process it. Before
376 * starting to wait, it registered as a waiter for this specific
377 * answer (by toggling a bit in on of the handler_map), so that
378 * the rx code knows that it needs to send a notification to the
379 * waiting processes. It does so by calling iwm_notif_send(),
380 * which adds the notification to the pending notifications list,
381 * and then wakes the waiting processes up.
383 int iwm_notif_send(struct iwm_priv
*iwm
, struct iwm_wifi_cmd
*cmd
,
384 u8 cmd_id
, u8 source
, u8
*buf
, unsigned long buf_size
)
386 struct iwm_notif
*notif
;
388 notif
= kzalloc(sizeof(struct iwm_notif
), GFP_KERNEL
);
390 IWM_ERR(iwm
, "Couldn't alloc memory for notification\n");
394 INIT_LIST_HEAD(¬if
->pending
);
396 notif
->cmd_id
= cmd_id
;
398 notif
->buf
= kzalloc(buf_size
, GFP_KERNEL
);
400 IWM_ERR(iwm
, "Couldn't alloc notification buffer\n");
404 notif
->buf_size
= buf_size
;
405 memcpy(notif
->buf
, buf
, buf_size
);
406 list_add_tail(¬if
->pending
, &iwm
->pending_notif
);
408 wake_up_interruptible(&iwm
->notif_queue
);
413 static struct iwm_notif
*iwm_notif_find(struct iwm_priv
*iwm
, u32 cmd
,
416 struct iwm_notif
*notif
, *next
;
418 list_for_each_entry_safe(notif
, next
, &iwm
->pending_notif
, pending
) {
419 if ((notif
->cmd_id
== cmd
) && (notif
->src
== source
)) {
420 list_del(¬if
->pending
);
428 static struct iwm_notif
*iwm_notif_wait(struct iwm_priv
*iwm
, u32 cmd
,
429 u8 source
, long timeout
)
432 struct iwm_notif
*notif
;
433 unsigned long *map
= NULL
;
437 map
= &iwm
->lmac_handler_map
[0];
440 map
= &iwm
->umac_handler_map
[0];
443 map
= &iwm
->udma_handler_map
[0];
449 ret
= wait_event_interruptible_timeout(iwm
->notif_queue
,
450 ((notif
= iwm_notif_find(iwm
, cmd
, source
)) != NULL
),
460 int iwm_notif_handle(struct iwm_priv
*iwm
, u32 cmd
, u8 source
, long timeout
)
463 struct iwm_notif
*notif
;
465 notif
= iwm_notif_wait(iwm
, cmd
, source
, timeout
);
469 ret
= iwm_rx_handle_resp(iwm
, notif
->buf
, notif
->buf_size
, notif
->cmd
);
476 static int iwm_config_boot_params(struct iwm_priv
*iwm
)
478 struct iwm_udma_nonwifi_cmd target_cmd
;
481 /* check Wimax is off and config debug monitor */
482 if (iwm
->conf
.wimax_not_present
) {
484 u32 addr1
= 0x606BE258;
488 u32 addr2
= 0x606BE100;
491 u32 addr3
= 0x606BEC00;
494 target_cmd
.handle_by_hw
= 0;
497 target_cmd
.opcode
= UMAC_HDI_OUT_OPCODE_WRITE
;
498 target_cmd
.addr
= cpu_to_le32(addr1
);
499 target_cmd
.op1_sz
= cpu_to_le32(sizeof(u32
));
502 ret
= iwm_hal_send_target_cmd(iwm
, &target_cmd
, &data1
);
504 IWM_ERR(iwm
, "iwm_hal_send_target_cmd failed\n");
508 target_cmd
.opcode
= UMAC_HDI_OUT_OPCODE_READ_MODIFY_WRITE
;
509 target_cmd
.addr
= cpu_to_le32(addr2
);
510 target_cmd
.op1_sz
= cpu_to_le32(data2_set
);
511 target_cmd
.op2
= cpu_to_le32(data2_clr
);
513 ret
= iwm_hal_send_target_cmd(iwm
, &target_cmd
, &data1
);
515 IWM_ERR(iwm
, "iwm_hal_send_target_cmd failed\n");
519 target_cmd
.opcode
= UMAC_HDI_OUT_OPCODE_WRITE
;
520 target_cmd
.addr
= cpu_to_le32(addr3
);
521 target_cmd
.op1_sz
= cpu_to_le32(sizeof(u32
));
524 ret
= iwm_hal_send_target_cmd(iwm
, &target_cmd
, &data3
);
526 IWM_ERR(iwm
, "iwm_hal_send_target_cmd failed\n");
534 void iwm_init_default_profile(struct iwm_priv
*iwm
,
535 struct iwm_umac_profile
*profile
)
537 memset(profile
, 0, sizeof(struct iwm_umac_profile
));
539 profile
->sec
.auth_type
= UMAC_AUTH_TYPE_OPEN
;
540 profile
->sec
.flags
= UMAC_SEC_FLG_LEGACY_PROFILE
;
541 profile
->sec
.ucast_cipher
= UMAC_CIPHER_TYPE_NONE
;
542 profile
->sec
.mcast_cipher
= UMAC_CIPHER_TYPE_NONE
;
544 if (iwm
->conf
.enable_qos
)
545 profile
->flags
|= cpu_to_le16(UMAC_PROFILE_QOS_ALLOWED
);
547 profile
->wireless_mode
= iwm
->conf
.wireless_mode
;
548 profile
->mode
= cpu_to_le32(iwm
->conf
.mode
);
550 profile
->ibss
.atim
= 0;
551 profile
->ibss
.beacon_interval
= 100;
552 profile
->ibss
.join_only
= 0;
553 profile
->ibss
.band
= iwm
->conf
.ibss_band
;
554 profile
->ibss
.channel
= iwm
->conf
.ibss_channel
;
557 void iwm_link_on(struct iwm_priv
*iwm
)
559 netif_carrier_on(iwm_to_ndev(iwm
));
560 netif_tx_wake_all_queues(iwm_to_ndev(iwm
));
562 iwm_send_umac_stats_req(iwm
, 0);
565 void iwm_link_off(struct iwm_priv
*iwm
)
567 struct iw_statistics
*wstats
= &iwm
->wstats
;
570 netif_tx_stop_all_queues(iwm_to_ndev(iwm
));
571 netif_carrier_off(iwm_to_ndev(iwm
));
573 for (i
= 0; i
< IWM_TX_QUEUES
; i
++) {
574 skb_queue_purge(&iwm
->txq
[i
].queue
);
576 iwm
->txq
[i
].concat_count
= 0;
577 iwm
->txq
[i
].concat_ptr
= iwm
->txq
[i
].concat_buf
;
579 flush_workqueue(iwm
->txq
[i
].wq
);
584 cancel_delayed_work_sync(&iwm
->stats_request
);
585 memset(wstats
, 0, sizeof(struct iw_statistics
));
586 wstats
->qual
.updated
= IW_QUAL_ALL_INVALID
;
593 iwm
->resp_ie_len
= 0;
595 del_timer_sync(&iwm
->watchdog
);
598 static void iwm_bss_list_clean(struct iwm_priv
*iwm
)
600 struct iwm_bss_info
*bss
, *next
;
602 list_for_each_entry_safe(bss
, next
, &iwm
->bss_list
, node
) {
603 list_del(&bss
->node
);
609 static int iwm_channels_init(struct iwm_priv
*iwm
)
613 ret
= iwm_send_umac_channel_list(iwm
);
615 IWM_ERR(iwm
, "Send channel list failed\n");
619 ret
= iwm_notif_handle(iwm
, UMAC_CMD_OPCODE_GET_CHAN_INFO_LIST
,
620 IWM_SRC_UMAC
, WAIT_NOTIF_TIMEOUT
);
622 IWM_ERR(iwm
, "Didn't get a channel list notification\n");
629 static int __iwm_up(struct iwm_priv
*iwm
)
632 struct iwm_notif
*notif_reboot
, *notif_ack
= NULL
;
633 struct wiphy
*wiphy
= iwm_to_wiphy(iwm
);
636 ret
= iwm_bus_enable(iwm
);
638 IWM_ERR(iwm
, "Couldn't enable function\n");
642 iwm_rx_setup_handlers(iwm
);
644 /* Wait for initial BARKER_REBOOT from hardware */
645 notif_reboot
= iwm_notif_wait(iwm
, IWM_BARKER_REBOOT_NOTIFICATION
,
646 IWM_SRC_UDMA
, 2 * HZ
);
648 IWM_ERR(iwm
, "Wait for REBOOT_BARKER timeout\n");
652 /* We send the barker back */
653 ret
= iwm_bus_send_chunk(iwm
, notif_reboot
->buf
, 16);
655 IWM_ERR(iwm
, "REBOOT barker response failed\n");
660 kfree(notif_reboot
->buf
);
663 /* Wait for ACK_BARKER from hardware */
664 notif_ack
= iwm_notif_wait(iwm
, IWM_ACK_BARKER_NOTIFICATION
,
665 IWM_SRC_UDMA
, 2 * HZ
);
667 IWM_ERR(iwm
, "Wait for ACK_BARKER timeout\n");
671 kfree(notif_ack
->buf
);
674 /* We start to config static boot parameters */
675 ret
= iwm_config_boot_params(iwm
);
677 IWM_ERR(iwm
, "Config boot parameters failed\n");
681 ret
= iwm_read_mac(iwm
, iwm_to_ndev(iwm
)->dev_addr
);
683 IWM_ERR(iwm
, "MAC reading failed\n");
686 memcpy(iwm_to_ndev(iwm
)->perm_addr
, iwm_to_ndev(iwm
)->dev_addr
,
689 /* We can load the FWs */
690 ret
= iwm_load_fw(iwm
);
692 IWM_ERR(iwm
, "FW loading failed\n");
696 ret
= iwm_eeprom_fat_channels(iwm
);
698 IWM_ERR(iwm
, "Couldnt read HT channels EEPROM entries\n");
703 * Read our SKU capabilities.
704 * If it's valid, we AND the configured wireless mode with the
705 * device EEPROM value as the current profile wireless mode.
707 wireless_mode
= iwm_eeprom_wireless_mode(iwm
);
709 iwm
->conf
.wireless_mode
&= wireless_mode
;
710 if (iwm
->umac_profile
)
711 iwm
->umac_profile
->wireless_mode
=
712 iwm
->conf
.wireless_mode
;
714 IWM_ERR(iwm
, "Wrong SKU capabilities: 0x%x\n",
715 *((u16
*)iwm_eeprom_access(iwm
, IWM_EEPROM_SKU_CAP
)));
717 snprintf(wiphy
->fw_version
, sizeof(wiphy
->fw_version
), "L%s_U%s",
718 iwm
->lmac_version
, iwm
->umac_version
);
720 /* We configure the UMAC and enable the wifi module */
721 ret
= iwm_send_umac_config(iwm
,
722 cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_CORE_EN
) |
723 cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_LINK_EN
) |
724 cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_MLME_EN
));
726 IWM_ERR(iwm
, "UMAC config failed\n");
730 ret
= iwm_notif_handle(iwm
, UMAC_NOTIFY_OPCODE_WIFI_CORE_STATUS
,
731 IWM_SRC_UMAC
, WAIT_NOTIF_TIMEOUT
);
733 IWM_ERR(iwm
, "Didn't get a wifi core status notification\n");
737 if (iwm
->core_enabled
!= (UMAC_NTFY_WIFI_CORE_STATUS_LINK_EN
|
738 UMAC_NTFY_WIFI_CORE_STATUS_MLME_EN
)) {
739 IWM_DBG_BOOT(iwm
, DBG
, "Not all cores enabled:0x%x\n",
741 ret
= iwm_notif_handle(iwm
, UMAC_NOTIFY_OPCODE_WIFI_CORE_STATUS
,
742 IWM_SRC_UMAC
, WAIT_NOTIF_TIMEOUT
);
744 IWM_ERR(iwm
, "Didn't get a core status notification\n");
748 if (iwm
->core_enabled
!= (UMAC_NTFY_WIFI_CORE_STATUS_LINK_EN
|
749 UMAC_NTFY_WIFI_CORE_STATUS_MLME_EN
)) {
750 IWM_ERR(iwm
, "Not all cores enabled: 0x%x\n",
754 IWM_INFO(iwm
, "All cores enabled\n");
758 ret
= iwm_channels_init(iwm
);
760 IWM_ERR(iwm
, "Couldn't init channels\n");
764 /* Set the READY bit to indicate interface is brought up successfully */
765 set_bit(IWM_STATUS_READY
, &iwm
->status
);
770 iwm_eeprom_exit(iwm
);
773 ret
= iwm_bus_disable(iwm
);
775 IWM_ERR(iwm
, "Couldn't disable function\n");
780 int iwm_up(struct iwm_priv
*iwm
)
784 mutex_lock(&iwm
->mutex
);
786 mutex_unlock(&iwm
->mutex
);
791 static int __iwm_down(struct iwm_priv
*iwm
)
795 /* The interface is already down */
796 if (!test_bit(IWM_STATUS_READY
, &iwm
->status
))
799 if (iwm
->scan_request
) {
800 cfg80211_scan_done(iwm
->scan_request
, true);
801 iwm
->scan_request
= NULL
;
804 clear_bit(IWM_STATUS_READY
, &iwm
->status
);
806 iwm_eeprom_exit(iwm
);
807 iwm_bss_list_clean(iwm
);
808 iwm_init_default_profile(iwm
, iwm
->umac_profile
);
809 iwm
->umac_profile_active
= false;
810 iwm
->default_key
= -1;
811 iwm
->core_enabled
= 0;
813 ret
= iwm_bus_disable(iwm
);
815 IWM_ERR(iwm
, "Couldn't disable function\n");
822 int iwm_down(struct iwm_priv
*iwm
)
826 mutex_lock(&iwm
->mutex
);
827 ret
= __iwm_down(iwm
);
828 mutex_unlock(&iwm
->mutex
);