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
,
84 .coexist_mode
= COEX_MODE_CM
,
87 .ibss_band
= UMAC_BAND_2GHZ
,
90 .mac_addr
= {0x00, 0x02, 0xb3, 0x01, 0x02, 0x03},
93 static int modparam_reset
;
94 module_param_named(reset
, modparam_reset
, bool, 0644);
95 MODULE_PARM_DESC(reset
, "reset on firmware errors (default 0 [not reset])");
97 int iwm_mode_to_nl80211_iftype(int mode
)
101 return NL80211_IFTYPE_STATION
;
103 return NL80211_IFTYPE_ADHOC
;
105 return NL80211_IFTYPE_UNSPECIFIED
;
111 static void iwm_statistics_request(struct work_struct
*work
)
113 struct iwm_priv
*iwm
=
114 container_of(work
, struct iwm_priv
, stats_request
.work
);
116 iwm_send_umac_stats_req(iwm
, 0);
119 static void iwm_disconnect_work(struct work_struct
*work
)
121 struct iwm_priv
*iwm
=
122 container_of(work
, struct iwm_priv
, disconnect
.work
);
124 if (iwm
->umac_profile_active
)
125 iwm_invalidate_mlme_profile(iwm
);
127 clear_bit(IWM_STATUS_ASSOCIATED
, &iwm
->status
);
128 iwm
->umac_profile_active
= 0;
129 memset(iwm
->bssid
, 0, ETH_ALEN
);
134 wake_up_interruptible(&iwm
->mlme_queue
);
136 cfg80211_disconnected(iwm_to_ndev(iwm
), 0, NULL
, 0, GFP_KERNEL
);
139 static void iwm_ct_kill_work(struct work_struct
*work
)
141 struct iwm_priv
*iwm
=
142 container_of(work
, struct iwm_priv
, ct_kill_delay
.work
);
143 struct wiphy
*wiphy
= iwm_to_wiphy(iwm
);
145 IWM_INFO(iwm
, "CT kill delay timeout\n");
147 wiphy_rfkill_set_hw_state(wiphy
, false);
150 static int __iwm_up(struct iwm_priv
*iwm
);
151 static int __iwm_down(struct iwm_priv
*iwm
);
153 static void iwm_reset_worker(struct work_struct
*work
)
155 struct iwm_priv
*iwm
;
156 struct iwm_umac_profile
*profile
= NULL
;
157 int uninitialized_var(ret
), retry
= 0;
159 iwm
= container_of(work
, struct iwm_priv
, reset_worker
);
162 * XXX: The iwm->mutex is introduced purely for this reset work,
163 * because the other users for iwm_up and iwm_down are only netdev
164 * ndo_open and ndo_stop which are already protected by rtnl.
165 * Please remove iwm->mutex together if iwm_reset_worker() is not
166 * required in the future.
168 if (!mutex_trylock(&iwm
->mutex
)) {
169 IWM_WARN(iwm
, "We are in the middle of interface bringing "
170 "UP/DOWN. Skip driver resetting.\n");
174 if (iwm
->umac_profile_active
) {
175 profile
= kmalloc(sizeof(struct iwm_umac_profile
), GFP_KERNEL
);
177 memcpy(profile
, iwm
->umac_profile
, sizeof(*profile
));
179 IWM_ERR(iwm
, "Couldn't alloc memory for profile\n");
184 while (retry
++ < 3) {
189 schedule_timeout_uninterruptible(10 * HZ
);
193 IWM_WARN(iwm
, "iwm_up() failed: %d\n", ret
);
200 IWM_DBG_MLME(iwm
, DBG
, "Resend UMAC profile\n");
201 memcpy(iwm
->umac_profile
, profile
, sizeof(*profile
));
202 iwm_send_mlme_profile(iwm
);
205 clear_bit(IWM_STATUS_RESETTING
, &iwm
->status
);
208 mutex_unlock(&iwm
->mutex
);
211 static void iwm_auth_retry_worker(struct work_struct
*work
)
213 struct iwm_priv
*iwm
;
216 iwm
= container_of(work
, struct iwm_priv
, auth_retry_worker
);
217 if (iwm
->umac_profile_active
) {
218 ret
= iwm_invalidate_mlme_profile(iwm
);
223 iwm
->umac_profile
->sec
.auth_type
= UMAC_AUTH_TYPE_LEGACY_PSK
;
225 ret
= iwm_send_mlme_profile(iwm
);
229 for (i
= 0; i
< IWM_NUM_KEYS
; i
++)
230 if (iwm
->keys
[i
].key_len
)
231 iwm_set_key(iwm
, 0, &iwm
->keys
[i
]);
233 iwm_set_tx_key(iwm
, iwm
->default_key
);
238 static void iwm_watchdog(unsigned long data
)
240 struct iwm_priv
*iwm
= (struct iwm_priv
*)data
;
242 IWM_WARN(iwm
, "Watchdog expired: UMAC stalls!\n");
248 int iwm_priv_init(struct iwm_priv
*iwm
)
254 INIT_LIST_HEAD(&iwm
->pending_notif
);
255 init_waitqueue_head(&iwm
->notif_queue
);
256 init_waitqueue_head(&iwm
->nonwifi_queue
);
257 init_waitqueue_head(&iwm
->wifi_ntfy_queue
);
258 init_waitqueue_head(&iwm
->mlme_queue
);
259 memcpy(&iwm
->conf
, &def_iwm_conf
, sizeof(struct iwm_conf
));
260 spin_lock_init(&iwm
->tx_credit
.lock
);
261 INIT_LIST_HEAD(&iwm
->wifi_pending_cmd
);
262 INIT_LIST_HEAD(&iwm
->nonwifi_pending_cmd
);
263 iwm
->wifi_seq_num
= UMAC_WIFI_SEQ_NUM_BASE
;
264 iwm
->nonwifi_seq_num
= UMAC_NONWIFI_SEQ_NUM_BASE
;
265 spin_lock_init(&iwm
->cmd_lock
);
267 INIT_DELAYED_WORK(&iwm
->stats_request
, iwm_statistics_request
);
268 INIT_DELAYED_WORK(&iwm
->disconnect
, iwm_disconnect_work
);
269 INIT_DELAYED_WORK(&iwm
->ct_kill_delay
, iwm_ct_kill_work
);
270 INIT_WORK(&iwm
->reset_worker
, iwm_reset_worker
);
271 INIT_WORK(&iwm
->auth_retry_worker
, iwm_auth_retry_worker
);
272 INIT_LIST_HEAD(&iwm
->bss_list
);
274 skb_queue_head_init(&iwm
->rx_list
);
275 INIT_LIST_HEAD(&iwm
->rx_tickets
);
276 for (i
= 0; i
< IWM_RX_ID_HASH
; i
++)
277 INIT_LIST_HEAD(&iwm
->rx_packets
[i
]);
279 INIT_WORK(&iwm
->rx_worker
, iwm_rx_worker
);
281 iwm
->rx_wq
= create_singlethread_workqueue(KBUILD_MODNAME
"_rx");
285 for (i
= 0; i
< IWM_TX_QUEUES
; i
++) {
286 INIT_WORK(&iwm
->txq
[i
].worker
, iwm_tx_worker
);
287 snprintf(name
, 32, KBUILD_MODNAME
"_tx_%d", i
);
289 iwm
->txq
[i
].wq
= create_singlethread_workqueue(name
);
293 skb_queue_head_init(&iwm
->txq
[i
].queue
);
296 for (i
= 0; i
< IWM_NUM_KEYS
; i
++)
297 memset(&iwm
->keys
[i
], 0, sizeof(struct iwm_key
));
299 iwm
->default_key
= -1;
301 init_timer(&iwm
->watchdog
);
302 iwm
->watchdog
.function
= iwm_watchdog
;
303 iwm
->watchdog
.data
= (unsigned long)iwm
;
304 mutex_init(&iwm
->mutex
);
306 iwm
->last_fw_err
= kzalloc(sizeof(struct iwm_fw_error_hdr
),
308 if (iwm
->last_fw_err
== NULL
)
314 void iwm_priv_deinit(struct iwm_priv
*iwm
)
318 for (i
= 0; i
< IWM_TX_QUEUES
; i
++)
319 destroy_workqueue(iwm
->txq
[i
].wq
);
321 destroy_workqueue(iwm
->rx_wq
);
322 kfree(iwm
->last_fw_err
);
326 * We reset all the structures, and we reset the UMAC.
327 * After calling this routine, you're expected to reload
330 void iwm_reset(struct iwm_priv
*iwm
)
332 struct iwm_notif
*notif
, *next
;
334 if (test_bit(IWM_STATUS_READY
, &iwm
->status
))
335 iwm_target_reset(iwm
);
337 if (test_bit(IWM_STATUS_RESETTING
, &iwm
->status
)) {
339 set_bit(IWM_STATUS_RESETTING
, &iwm
->status
);
344 list_for_each_entry_safe(notif
, next
, &iwm
->pending_notif
, pending
) {
345 list_del(¬if
->pending
);
352 flush_workqueue(iwm
->rx_wq
);
357 void iwm_resetting(struct iwm_priv
*iwm
)
359 set_bit(IWM_STATUS_RESETTING
, &iwm
->status
);
361 schedule_work(&iwm
->reset_worker
);
367 * We're faced with the following issue: Any host command can
368 * have an answer or not, and if there's an answer to expect,
369 * it can be treated synchronously or asynchronously.
370 * To work around the synchronous answer case, we implemented
371 * our notification mechanism.
372 * When a code path needs to wait for a command response
373 * synchronously, it calls notif_handle(), which waits for the
374 * right notification to show up, and then process it. Before
375 * starting to wait, it registered as a waiter for this specific
376 * answer (by toggling a bit in on of the handler_map), so that
377 * the rx code knows that it needs to send a notification to the
378 * waiting processes. It does so by calling iwm_notif_send(),
379 * which adds the notification to the pending notifications list,
380 * and then wakes the waiting processes up.
382 int iwm_notif_send(struct iwm_priv
*iwm
, struct iwm_wifi_cmd
*cmd
,
383 u8 cmd_id
, u8 source
, u8
*buf
, unsigned long buf_size
)
385 struct iwm_notif
*notif
;
387 notif
= kzalloc(sizeof(struct iwm_notif
), GFP_KERNEL
);
389 IWM_ERR(iwm
, "Couldn't alloc memory for notification\n");
393 INIT_LIST_HEAD(¬if
->pending
);
395 notif
->cmd_id
= cmd_id
;
397 notif
->buf
= kzalloc(buf_size
, GFP_KERNEL
);
399 IWM_ERR(iwm
, "Couldn't alloc notification buffer\n");
403 notif
->buf_size
= buf_size
;
404 memcpy(notif
->buf
, buf
, buf_size
);
405 list_add_tail(¬if
->pending
, &iwm
->pending_notif
);
407 wake_up_interruptible(&iwm
->notif_queue
);
412 static struct iwm_notif
*iwm_notif_find(struct iwm_priv
*iwm
, u32 cmd
,
415 struct iwm_notif
*notif
, *next
;
417 list_for_each_entry_safe(notif
, next
, &iwm
->pending_notif
, pending
) {
418 if ((notif
->cmd_id
== cmd
) && (notif
->src
== source
)) {
419 list_del(¬if
->pending
);
427 static struct iwm_notif
*iwm_notif_wait(struct iwm_priv
*iwm
, u32 cmd
,
428 u8 source
, long timeout
)
431 struct iwm_notif
*notif
;
432 unsigned long *map
= NULL
;
436 map
= &iwm
->lmac_handler_map
[0];
439 map
= &iwm
->umac_handler_map
[0];
442 map
= &iwm
->udma_handler_map
[0];
448 ret
= wait_event_interruptible_timeout(iwm
->notif_queue
,
449 ((notif
= iwm_notif_find(iwm
, cmd
, source
)) != NULL
),
459 int iwm_notif_handle(struct iwm_priv
*iwm
, u32 cmd
, u8 source
, long timeout
)
462 struct iwm_notif
*notif
;
464 notif
= iwm_notif_wait(iwm
, cmd
, source
, timeout
);
468 ret
= iwm_rx_handle_resp(iwm
, notif
->buf
, notif
->buf_size
, notif
->cmd
);
475 static int iwm_config_boot_params(struct iwm_priv
*iwm
)
477 struct iwm_udma_nonwifi_cmd target_cmd
;
480 /* check Wimax is off and config debug monitor */
481 if (iwm
->conf
.wimax_not_present
) {
483 u32 addr1
= 0x606BE258;
487 u32 addr2
= 0x606BE100;
490 u32 addr3
= 0x606BEC00;
493 target_cmd
.handle_by_hw
= 0;
496 target_cmd
.opcode
= UMAC_HDI_OUT_OPCODE_WRITE
;
497 target_cmd
.addr
= cpu_to_le32(addr1
);
498 target_cmd
.op1_sz
= cpu_to_le32(sizeof(u32
));
501 ret
= iwm_hal_send_target_cmd(iwm
, &target_cmd
, &data1
);
503 IWM_ERR(iwm
, "iwm_hal_send_target_cmd failed\n");
507 target_cmd
.opcode
= UMAC_HDI_OUT_OPCODE_READ_MODIFY_WRITE
;
508 target_cmd
.addr
= cpu_to_le32(addr2
);
509 target_cmd
.op1_sz
= cpu_to_le32(data2_set
);
510 target_cmd
.op2
= cpu_to_le32(data2_clr
);
512 ret
= iwm_hal_send_target_cmd(iwm
, &target_cmd
, &data1
);
514 IWM_ERR(iwm
, "iwm_hal_send_target_cmd failed\n");
518 target_cmd
.opcode
= UMAC_HDI_OUT_OPCODE_WRITE
;
519 target_cmd
.addr
= cpu_to_le32(addr3
);
520 target_cmd
.op1_sz
= cpu_to_le32(sizeof(u32
));
523 ret
= iwm_hal_send_target_cmd(iwm
, &target_cmd
, &data3
);
525 IWM_ERR(iwm
, "iwm_hal_send_target_cmd failed\n");
533 void iwm_init_default_profile(struct iwm_priv
*iwm
,
534 struct iwm_umac_profile
*profile
)
536 memset(profile
, 0, sizeof(struct iwm_umac_profile
));
538 profile
->sec
.auth_type
= UMAC_AUTH_TYPE_OPEN
;
539 profile
->sec
.flags
= UMAC_SEC_FLG_LEGACY_PROFILE
;
540 profile
->sec
.ucast_cipher
= UMAC_CIPHER_TYPE_NONE
;
541 profile
->sec
.mcast_cipher
= UMAC_CIPHER_TYPE_NONE
;
543 if (iwm
->conf
.enable_qos
)
544 profile
->flags
|= cpu_to_le16(UMAC_PROFILE_QOS_ALLOWED
);
546 profile
->wireless_mode
= iwm
->conf
.wireless_mode
;
547 profile
->mode
= cpu_to_le32(iwm
->conf
.mode
);
549 profile
->ibss
.atim
= 0;
550 profile
->ibss
.beacon_interval
= 100;
551 profile
->ibss
.join_only
= 0;
552 profile
->ibss
.band
= iwm
->conf
.ibss_band
;
553 profile
->ibss
.channel
= iwm
->conf
.ibss_channel
;
556 void iwm_link_on(struct iwm_priv
*iwm
)
558 netif_carrier_on(iwm_to_ndev(iwm
));
559 netif_tx_wake_all_queues(iwm_to_ndev(iwm
));
561 iwm_send_umac_stats_req(iwm
, 0);
564 void iwm_link_off(struct iwm_priv
*iwm
)
566 struct iw_statistics
*wstats
= &iwm
->wstats
;
569 netif_tx_stop_all_queues(iwm_to_ndev(iwm
));
570 netif_carrier_off(iwm_to_ndev(iwm
));
572 for (i
= 0; i
< IWM_TX_QUEUES
; i
++) {
573 skb_queue_purge(&iwm
->txq
[i
].queue
);
575 iwm
->txq
[i
].concat_count
= 0;
576 iwm
->txq
[i
].concat_ptr
= iwm
->txq
[i
].concat_buf
;
578 flush_workqueue(iwm
->txq
[i
].wq
);
583 cancel_delayed_work_sync(&iwm
->stats_request
);
584 memset(wstats
, 0, sizeof(struct iw_statistics
));
585 wstats
->qual
.updated
= IW_QUAL_ALL_INVALID
;
592 iwm
->resp_ie_len
= 0;
594 del_timer_sync(&iwm
->watchdog
);
597 static void iwm_bss_list_clean(struct iwm_priv
*iwm
)
599 struct iwm_bss_info
*bss
, *next
;
601 list_for_each_entry_safe(bss
, next
, &iwm
->bss_list
, node
) {
602 list_del(&bss
->node
);
608 static int iwm_channels_init(struct iwm_priv
*iwm
)
612 ret
= iwm_send_umac_channel_list(iwm
);
614 IWM_ERR(iwm
, "Send channel list failed\n");
618 ret
= iwm_notif_handle(iwm
, UMAC_CMD_OPCODE_GET_CHAN_INFO_LIST
,
619 IWM_SRC_UMAC
, WAIT_NOTIF_TIMEOUT
);
621 IWM_ERR(iwm
, "Didn't get a channel list notification\n");
628 static int __iwm_up(struct iwm_priv
*iwm
)
631 struct iwm_notif
*notif_reboot
, *notif_ack
= NULL
;
632 struct wiphy
*wiphy
= iwm_to_wiphy(iwm
);
634 ret
= iwm_bus_enable(iwm
);
636 IWM_ERR(iwm
, "Couldn't enable function\n");
640 iwm_rx_setup_handlers(iwm
);
642 /* Wait for initial BARKER_REBOOT from hardware */
643 notif_reboot
= iwm_notif_wait(iwm
, IWM_BARKER_REBOOT_NOTIFICATION
,
644 IWM_SRC_UDMA
, 2 * HZ
);
646 IWM_ERR(iwm
, "Wait for REBOOT_BARKER timeout\n");
650 /* We send the barker back */
651 ret
= iwm_bus_send_chunk(iwm
, notif_reboot
->buf
, 16);
653 IWM_ERR(iwm
, "REBOOT barker response failed\n");
658 kfree(notif_reboot
->buf
);
661 /* Wait for ACK_BARKER from hardware */
662 notif_ack
= iwm_notif_wait(iwm
, IWM_ACK_BARKER_NOTIFICATION
,
663 IWM_SRC_UDMA
, 2 * HZ
);
665 IWM_ERR(iwm
, "Wait for ACK_BARKER timeout\n");
669 kfree(notif_ack
->buf
);
672 /* We start to config static boot parameters */
673 ret
= iwm_config_boot_params(iwm
);
675 IWM_ERR(iwm
, "Config boot parameters failed\n");
679 ret
= iwm_read_mac(iwm
, iwm_to_ndev(iwm
)->dev_addr
);
681 IWM_ERR(iwm
, "MAC reading failed\n");
684 memcpy(iwm_to_ndev(iwm
)->perm_addr
, iwm_to_ndev(iwm
)->dev_addr
,
687 /* We can load the FWs */
688 ret
= iwm_load_fw(iwm
);
690 IWM_ERR(iwm
, "FW loading failed\n");
694 snprintf(wiphy
->fw_version
, sizeof(wiphy
->fw_version
), "L%s_U%s",
695 iwm
->lmac_version
, iwm
->umac_version
);
697 /* We configure the UMAC and enable the wifi module */
698 ret
= iwm_send_umac_config(iwm
,
699 cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_CORE_EN
) |
700 cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_LINK_EN
) |
701 cpu_to_le32(UMAC_RST_CTRL_FLG_WIFI_MLME_EN
));
703 IWM_ERR(iwm
, "UMAC config failed\n");
707 ret
= iwm_notif_handle(iwm
, UMAC_NOTIFY_OPCODE_WIFI_CORE_STATUS
,
708 IWM_SRC_UMAC
, WAIT_NOTIF_TIMEOUT
);
710 IWM_ERR(iwm
, "Didn't get a wifi core status notification\n");
714 if (iwm
->core_enabled
!= (UMAC_NTFY_WIFI_CORE_STATUS_LINK_EN
|
715 UMAC_NTFY_WIFI_CORE_STATUS_MLME_EN
)) {
716 IWM_DBG_BOOT(iwm
, DBG
, "Not all cores enabled:0x%x\n",
718 ret
= iwm_notif_handle(iwm
, UMAC_NOTIFY_OPCODE_WIFI_CORE_STATUS
,
719 IWM_SRC_UMAC
, WAIT_NOTIF_TIMEOUT
);
721 IWM_ERR(iwm
, "Didn't get a core status notification\n");
725 if (iwm
->core_enabled
!= (UMAC_NTFY_WIFI_CORE_STATUS_LINK_EN
|
726 UMAC_NTFY_WIFI_CORE_STATUS_MLME_EN
)) {
727 IWM_ERR(iwm
, "Not all cores enabled: 0x%x\n",
731 IWM_INFO(iwm
, "All cores enabled\n");
735 ret
= iwm_channels_init(iwm
);
737 IWM_ERR(iwm
, "Couldn't init channels\n");
741 /* Set the READY bit to indicate interface is brought up successfully */
742 set_bit(IWM_STATUS_READY
, &iwm
->status
);
747 iwm_eeprom_exit(iwm
);
750 ret
= iwm_bus_disable(iwm
);
752 IWM_ERR(iwm
, "Couldn't disable function\n");
757 int iwm_up(struct iwm_priv
*iwm
)
761 mutex_lock(&iwm
->mutex
);
763 mutex_unlock(&iwm
->mutex
);
768 static int __iwm_down(struct iwm_priv
*iwm
)
772 /* The interface is already down */
773 if (!test_bit(IWM_STATUS_READY
, &iwm
->status
))
776 if (iwm
->scan_request
) {
777 cfg80211_scan_done(iwm
->scan_request
, true);
778 iwm
->scan_request
= NULL
;
781 clear_bit(IWM_STATUS_READY
, &iwm
->status
);
783 iwm_eeprom_exit(iwm
);
784 iwm_bss_list_clean(iwm
);
785 iwm_init_default_profile(iwm
, iwm
->umac_profile
);
786 iwm
->umac_profile_active
= false;
787 iwm
->default_key
= -1;
788 iwm
->core_enabled
= 0;
790 ret
= iwm_bus_disable(iwm
);
792 IWM_ERR(iwm
, "Couldn't disable function\n");
799 int iwm_down(struct iwm_priv
*iwm
)
803 mutex_lock(&iwm
->mutex
);
804 ret
= __iwm_down(iwm
);
805 mutex_unlock(&iwm
->mutex
);