1 // SPDX-License-Identifier: GPL-2.0-only
2 /******************************************************************************
4 * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
6 * Portions of this file are derived from the ipw3945 project, as well
7 * as portions of the ieee80211 subsystem header files.
10 * Intel Linux Wireless <ilw@linux.intel.com>
11 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
13 *****************************************************************************/
15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/pci.h>
21 #include <linux/slab.h>
22 #include <linux/dma-mapping.h>
23 #include <linux/delay.h>
24 #include <linux/sched.h>
25 #include <linux/skbuff.h>
26 #include <linux/netdevice.h>
27 #include <linux/firmware.h>
28 #include <linux/etherdevice.h>
29 #include <linux/if_arp.h>
31 #include <net/ieee80211_radiotap.h>
32 #include <net/mac80211.h>
34 #include <asm/div64.h>
36 #define DRV_NAME "iwl3945"
41 #include "iwl-spectrum.h"
44 * module name, copyright, version, etc.
47 #define DRV_DESCRIPTION \
48 "Intel(R) PRO/Wireless 3945ABG/BG Network Connection driver for Linux"
50 #ifdef CONFIG_IWLEGACY_DEBUG
57 * add "s" to indicate spectrum measurement included.
58 * we add it here to be consistent with previous releases in which
59 * this was configurable.
61 #define DRV_VERSION IWLWIFI_VERSION VD "s"
62 #define DRV_COPYRIGHT "Copyright(c) 2003-2011 Intel Corporation"
63 #define DRV_AUTHOR "<ilw@linux.intel.com>"
65 MODULE_DESCRIPTION(DRV_DESCRIPTION);
66 MODULE_VERSION(DRV_VERSION);
67 MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
68 MODULE_LICENSE("GPL");
70 /* module parameters */
71 struct il_mod_params il3945_mod_params = {
75 /* the rest are 0 by default */
79 * il3945_get_antenna_flags - Get antenna flags for RXON command
80 * @il: eeprom and antenna fields are used to determine antenna flags
82 * il->eeprom39 is used to determine if antenna AUX/MAIN are reversed
83 * il3945_mod_params.antenna specifies the antenna diversity mode:
85 * IL_ANTENNA_DIVERSITY - NIC selects best antenna by itself
86 * IL_ANTENNA_MAIN - Force MAIN antenna
87 * IL_ANTENNA_AUX - Force AUX antenna
90 il3945_get_antenna_flags(const struct il_priv *il)
92 struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
94 switch (il3945_mod_params.antenna) {
95 case IL_ANTENNA_DIVERSITY:
99 if (eeprom->antenna_switch_type)
100 return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_B_MSK;
101 return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_A_MSK;
104 if (eeprom->antenna_switch_type)
105 return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_A_MSK;
106 return RXON_FLG_DIS_DIV_MSK | RXON_FLG_ANT_B_MSK;
109 /* bad antenna selector value */
110 IL_ERR("Bad antenna selector value (0x%x)\n",
111 il3945_mod_params.antenna);
113 return 0; /* "diversity" is default if error */
117 il3945_set_ccmp_dynamic_key_info(struct il_priv *il,
118 struct ieee80211_key_conf *keyconf, u8 sta_id)
121 __le16 key_flags = 0;
124 key_flags |= (STA_KEY_FLG_CCMP | STA_KEY_FLG_MAP_KEY_MSK);
125 key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
127 if (sta_id == il->hw_params.bcast_id)
128 key_flags |= STA_KEY_MULTICAST_MSK;
130 keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
131 keyconf->hw_key_idx = keyconf->keyidx;
132 key_flags &= ~STA_KEY_FLG_INVALID;
134 spin_lock_irqsave(&il->sta_lock, flags);
135 il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
136 il->stations[sta_id].keyinfo.keylen = keyconf->keylen;
137 memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
139 memcpy(il->stations[sta_id].sta.key.key, keyconf->key, keyconf->keylen);
141 if ((il->stations[sta_id].sta.key.
142 key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
143 il->stations[sta_id].sta.key.key_offset =
144 il_get_free_ucode_key_idx(il);
145 /* else, we are overriding an existing key => no need to allocated room
148 WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
149 "no space for a new key");
151 il->stations[sta_id].sta.key.key_flags = key_flags;
152 il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
153 il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
155 D_INFO("hwcrypto: modify ucode station key info\n");
157 ret = il_send_add_sta(il, &il->stations[sta_id].sta, CMD_ASYNC);
159 spin_unlock_irqrestore(&il->sta_lock, flags);
165 il3945_set_tkip_dynamic_key_info(struct il_priv *il,
166 struct ieee80211_key_conf *keyconf, u8 sta_id)
172 il3945_set_wep_dynamic_key_info(struct il_priv *il,
173 struct ieee80211_key_conf *keyconf, u8 sta_id)
179 il3945_clear_sta_key_info(struct il_priv *il, u8 sta_id)
182 struct il_addsta_cmd sta_cmd;
184 spin_lock_irqsave(&il->sta_lock, flags);
185 memset(&il->stations[sta_id].keyinfo, 0, sizeof(struct il_hw_key));
186 memset(&il->stations[sta_id].sta.key, 0, sizeof(struct il4965_keyinfo));
187 il->stations[sta_id].sta.key.key_flags = STA_KEY_FLG_NO_ENC;
188 il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
189 il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
190 memcpy(&sta_cmd, &il->stations[sta_id].sta,
191 sizeof(struct il_addsta_cmd));
192 spin_unlock_irqrestore(&il->sta_lock, flags);
194 D_INFO("hwcrypto: clear ucode station key info\n");
195 return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
199 il3945_set_dynamic_key(struct il_priv *il, struct ieee80211_key_conf *keyconf,
204 keyconf->hw_key_idx = HW_KEY_DYNAMIC;
206 switch (keyconf->cipher) {
207 case WLAN_CIPHER_SUITE_CCMP:
208 ret = il3945_set_ccmp_dynamic_key_info(il, keyconf, sta_id);
210 case WLAN_CIPHER_SUITE_TKIP:
211 ret = il3945_set_tkip_dynamic_key_info(il, keyconf, sta_id);
213 case WLAN_CIPHER_SUITE_WEP40:
214 case WLAN_CIPHER_SUITE_WEP104:
215 ret = il3945_set_wep_dynamic_key_info(il, keyconf, sta_id);
218 IL_ERR("Unknown alg: %s alg=%x\n", __func__, keyconf->cipher);
222 D_WEP("Set dynamic key: alg=%x len=%d idx=%d sta=%d ret=%d\n",
223 keyconf->cipher, keyconf->keylen, keyconf->keyidx, sta_id, ret);
229 il3945_remove_static_key(struct il_priv *il)
231 int ret = -EOPNOTSUPP;
237 il3945_set_static_key(struct il_priv *il, struct ieee80211_key_conf *key)
239 if (key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
240 key->cipher == WLAN_CIPHER_SUITE_WEP104)
243 IL_ERR("Static key invalid: cipher %x\n", key->cipher);
248 il3945_clear_free_frames(struct il_priv *il)
250 struct list_head *element;
252 D_INFO("%d frames on pre-allocated heap on clear.\n", il->frames_count);
254 while (!list_empty(&il->free_frames)) {
255 element = il->free_frames.next;
257 kfree(list_entry(element, struct il3945_frame, list));
261 if (il->frames_count) {
262 IL_WARN("%d frames still in use. Did we lose one?\n",
264 il->frames_count = 0;
268 static struct il3945_frame *
269 il3945_get_free_frame(struct il_priv *il)
271 struct il3945_frame *frame;
272 struct list_head *element;
273 if (list_empty(&il->free_frames)) {
274 frame = kzalloc(sizeof(*frame), GFP_KERNEL);
276 IL_ERR("Could not allocate frame!\n");
284 element = il->free_frames.next;
286 return list_entry(element, struct il3945_frame, list);
290 il3945_free_frame(struct il_priv *il, struct il3945_frame *frame)
292 memset(frame, 0, sizeof(*frame));
293 list_add(&frame->list, &il->free_frames);
297 il3945_fill_beacon_frame(struct il_priv *il, struct ieee80211_hdr *hdr,
301 if (!il_is_associated(il) || !il->beacon_skb)
304 if (il->beacon_skb->len > left)
307 memcpy(hdr, il->beacon_skb->data, il->beacon_skb->len);
309 return il->beacon_skb->len;
313 il3945_send_beacon_cmd(struct il_priv *il)
315 struct il3945_frame *frame;
316 unsigned int frame_size;
320 frame = il3945_get_free_frame(il);
323 IL_ERR("Could not obtain free frame buffer for beacon "
328 rate = il_get_lowest_plcp(il);
330 frame_size = il3945_hw_get_beacon_cmd(il, frame, rate);
332 rc = il_send_cmd_pdu(il, C_TX_BEACON, frame_size, &frame->u.cmd[0]);
334 il3945_free_frame(il, frame);
340 il3945_unset_hw_params(struct il_priv *il)
342 if (il->_3945.shared_virt)
343 dma_free_coherent(&il->pci_dev->dev,
344 sizeof(struct il3945_shared),
345 il->_3945.shared_virt, il->_3945.shared_phys);
349 il3945_build_tx_cmd_hwcrypto(struct il_priv *il, struct ieee80211_tx_info *info,
350 struct il_device_cmd *cmd,
351 struct sk_buff *skb_frag, int sta_id)
353 struct il3945_tx_cmd *tx_cmd = (struct il3945_tx_cmd *)cmd->cmd.payload;
354 struct il_hw_key *keyinfo = &il->stations[sta_id].keyinfo;
358 switch (keyinfo->cipher) {
359 case WLAN_CIPHER_SUITE_CCMP:
360 tx_cmd->sec_ctl = TX_CMD_SEC_CCM;
361 memcpy(tx_cmd->key, keyinfo->key, keyinfo->keylen);
362 D_TX("tx_cmd with AES hwcrypto\n");
365 case WLAN_CIPHER_SUITE_TKIP:
368 case WLAN_CIPHER_SUITE_WEP104:
369 tx_cmd->sec_ctl |= TX_CMD_SEC_KEY128;
371 case WLAN_CIPHER_SUITE_WEP40:
373 TX_CMD_SEC_WEP | (info->control.hw_key->
374 hw_key_idx & TX_CMD_SEC_MSK) <<
377 memcpy(&tx_cmd->key[3], keyinfo->key, keyinfo->keylen);
379 D_TX("Configuring packet for WEP encryption " "with key %d\n",
380 info->control.hw_key->hw_key_idx);
384 IL_ERR("Unknown encode cipher %x\n", keyinfo->cipher);
390 * handle build C_TX command notification.
393 il3945_build_tx_cmd_basic(struct il_priv *il, struct il_device_cmd *cmd,
394 struct ieee80211_tx_info *info,
395 struct ieee80211_hdr *hdr, u8 std_id)
397 struct il3945_tx_cmd *tx_cmd = (struct il3945_tx_cmd *)cmd->cmd.payload;
398 __le32 tx_flags = tx_cmd->tx_flags;
399 __le16 fc = hdr->frame_control;
401 tx_cmd->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
402 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
403 tx_flags |= TX_CMD_FLG_ACK_MSK;
404 if (ieee80211_is_mgmt(fc))
405 tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
406 if (ieee80211_is_probe_resp(fc) &&
407 !(le16_to_cpu(hdr->seq_ctrl) & 0xf))
408 tx_flags |= TX_CMD_FLG_TSF_MSK;
410 tx_flags &= (~TX_CMD_FLG_ACK_MSK);
411 tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
414 tx_cmd->sta_id = std_id;
415 if (ieee80211_has_morefrags(fc))
416 tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;
418 if (ieee80211_is_data_qos(fc)) {
419 u8 *qc = ieee80211_get_qos_ctl(hdr);
420 tx_cmd->tid_tspec = qc[0] & 0xf;
421 tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
423 tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
426 il_tx_cmd_protection(il, info, fc, &tx_flags);
428 tx_flags &= ~(TX_CMD_FLG_ANT_SEL_MSK);
429 if (ieee80211_is_mgmt(fc)) {
430 if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
431 tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(3);
433 tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(2);
435 tx_cmd->timeout.pm_frame_timeout = 0;
438 tx_cmd->driver_txop = 0;
439 tx_cmd->tx_flags = tx_flags;
440 tx_cmd->next_frame_len = 0;
444 * start C_TX command process
447 il3945_tx_skb(struct il_priv *il,
448 struct ieee80211_sta *sta,
451 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
452 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
453 struct il3945_tx_cmd *tx_cmd;
454 struct il_tx_queue *txq = NULL;
455 struct il_queue *q = NULL;
456 struct il_device_cmd *out_cmd;
457 struct il_cmd_meta *out_meta;
458 dma_addr_t phys_addr;
459 dma_addr_t txcmd_phys;
460 int txq_id = skb_get_queue_mapping(skb);
461 u16 len, idx, hdr_len;
462 u16 firstlen, secondlen;
466 u8 wait_write_ptr = 0;
469 spin_lock_irqsave(&il->lock, flags);
470 if (il_is_rfkill(il)) {
471 D_DROP("Dropping - RF KILL\n");
475 if ((ieee80211_get_tx_rate(il->hw, info)->hw_value & 0xFF) ==
477 IL_ERR("ERROR: No TX rate available.\n");
481 fc = hdr->frame_control;
483 #ifdef CONFIG_IWLEGACY_DEBUG
484 if (ieee80211_is_auth(fc))
485 D_TX("Sending AUTH frame\n");
486 else if (ieee80211_is_assoc_req(fc))
487 D_TX("Sending ASSOC frame\n");
488 else if (ieee80211_is_reassoc_req(fc))
489 D_TX("Sending REASSOC frame\n");
492 spin_unlock_irqrestore(&il->lock, flags);
494 hdr_len = ieee80211_hdrlen(fc);
496 /* Find idx into station table for destination station */
497 sta_id = il_sta_id_or_broadcast(il, sta);
498 if (sta_id == IL_INVALID_STATION) {
499 D_DROP("Dropping - INVALID STATION: %pM\n", hdr->addr1);
503 D_RATE("station Id %d\n", sta_id);
505 if (ieee80211_is_data_qos(fc)) {
506 u8 *qc = ieee80211_get_qos_ctl(hdr);
507 tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
508 if (unlikely(tid >= MAX_TID_COUNT))
512 /* Descriptor for chosen Tx queue */
513 txq = &il->txq[txq_id];
516 if ((il_queue_space(q) < q->high_mark))
519 spin_lock_irqsave(&il->lock, flags);
521 idx = il_get_cmd_idx(q, q->write_ptr, 0);
523 txq->skbs[q->write_ptr] = skb;
525 /* Init first empty entry in queue's array of Tx/cmd buffers */
526 out_cmd = txq->cmd[idx];
527 out_meta = &txq->meta[idx];
528 tx_cmd = (struct il3945_tx_cmd *)out_cmd->cmd.payload;
529 memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
530 memset(tx_cmd, 0, sizeof(*tx_cmd));
533 * Set up the Tx-command (not MAC!) header.
534 * Store the chosen Tx queue and TFD idx within the sequence field;
535 * after Tx, uCode's Tx response will return this value so driver can
536 * locate the frame within the tx queue and do post-tx processing.
538 out_cmd->hdr.cmd = C_TX;
539 out_cmd->hdr.sequence =
541 (QUEUE_TO_SEQ(txq_id) | IDX_TO_SEQ(q->write_ptr)));
543 /* Copy MAC header from skb into command buffer */
544 memcpy(tx_cmd->hdr, hdr, hdr_len);
546 if (info->control.hw_key)
547 il3945_build_tx_cmd_hwcrypto(il, info, out_cmd, skb, sta_id);
549 /* TODO need this for burst mode later on */
550 il3945_build_tx_cmd_basic(il, out_cmd, info, hdr, sta_id);
552 il3945_hw_build_tx_cmd_rate(il, out_cmd, info, hdr, sta_id);
554 /* Total # bytes to be transmitted */
555 tx_cmd->len = cpu_to_le16((u16) skb->len);
557 tx_cmd->tx_flags &= ~TX_CMD_FLG_ANT_A_MSK;
558 tx_cmd->tx_flags &= ~TX_CMD_FLG_ANT_B_MSK;
561 * Use the first empty entry in this queue's command buffer array
562 * to contain the Tx command and MAC header concatenated together
563 * (payload data will be in another buffer).
564 * Size of this varies, due to varying MAC header length.
565 * If end is not dword aligned, we'll have 2 extra bytes at the end
566 * of the MAC header (device reads on dword boundaries).
567 * We'll tell device about this padding later.
570 sizeof(struct il3945_tx_cmd) + sizeof(struct il_cmd_header) +
572 firstlen = (len + 3) & ~3;
574 /* Physical address of this Tx command's header (not MAC header!),
575 * within command buffer array. */
577 pci_map_single(il->pci_dev, &out_cmd->hdr, firstlen,
579 if (unlikely(pci_dma_mapping_error(il->pci_dev, txcmd_phys)))
582 /* Set up TFD's 2nd entry to point directly to remainder of skb,
583 * if any (802.11 null frames have no payload). */
584 secondlen = skb->len - hdr_len;
587 pci_map_single(il->pci_dev, skb->data + hdr_len, secondlen,
589 if (unlikely(pci_dma_mapping_error(il->pci_dev, phys_addr)))
593 /* Add buffer containing Tx command and MAC(!) header to TFD's
595 il->ops->txq_attach_buf_to_tfd(il, txq, txcmd_phys, firstlen, 1, 0);
596 dma_unmap_addr_set(out_meta, mapping, txcmd_phys);
597 dma_unmap_len_set(out_meta, len, firstlen);
599 il->ops->txq_attach_buf_to_tfd(il, txq, phys_addr, secondlen, 0,
602 if (!ieee80211_has_morefrags(hdr->frame_control)) {
603 txq->need_update = 1;
606 txq->need_update = 0;
609 il_update_stats(il, true, fc, skb->len);
611 D_TX("sequence nr = 0X%x\n", le16_to_cpu(out_cmd->hdr.sequence));
612 D_TX("tx_flags = 0X%x\n", le32_to_cpu(tx_cmd->tx_flags));
613 il_print_hex_dump(il, IL_DL_TX, tx_cmd, sizeof(*tx_cmd));
614 il_print_hex_dump(il, IL_DL_TX, (u8 *) tx_cmd->hdr,
615 ieee80211_hdrlen(fc));
617 /* Tell device the write idx *just past* this latest filled TFD */
618 q->write_ptr = il_queue_inc_wrap(q->write_ptr, q->n_bd);
619 il_txq_update_write_ptr(il, txq);
620 spin_unlock_irqrestore(&il->lock, flags);
622 if (il_queue_space(q) < q->high_mark && il->mac80211_registered) {
623 if (wait_write_ptr) {
624 spin_lock_irqsave(&il->lock, flags);
625 txq->need_update = 1;
626 il_txq_update_write_ptr(il, txq);
627 spin_unlock_irqrestore(&il->lock, flags);
630 il_stop_queue(il, txq);
636 spin_unlock_irqrestore(&il->lock, flags);
642 il3945_get_measurement(struct il_priv *il,
643 struct ieee80211_measurement_params *params, u8 type)
645 struct il_spectrum_cmd spectrum;
646 struct il_rx_pkt *pkt;
647 struct il_host_cmd cmd = {
648 .id = C_SPECTRUM_MEASUREMENT,
649 .data = (void *)&spectrum,
650 .flags = CMD_WANT_SKB,
652 u32 add_time = le64_to_cpu(params->start_time);
654 int spectrum_resp_status;
655 int duration = le16_to_cpu(params->duration);
657 if (il_is_associated(il))
659 il_usecs_to_beacons(il,
660 le64_to_cpu(params->start_time) -
662 le16_to_cpu(il->timing.beacon_interval));
664 memset(&spectrum, 0, sizeof(spectrum));
666 spectrum.channel_count = cpu_to_le16(1);
668 RXON_FLG_TSF2HOST_MSK | RXON_FLG_ANT_A_MSK | RXON_FLG_DIS_DIV_MSK;
669 spectrum.filter_flags = MEASUREMENT_FILTER_FLAG;
670 cmd.len = sizeof(spectrum);
671 spectrum.len = cpu_to_le16(cmd.len - sizeof(spectrum.len));
673 if (il_is_associated(il))
674 spectrum.start_time =
675 il_add_beacon_time(il, il->_3945.last_beacon_time, add_time,
676 le16_to_cpu(il->timing.beacon_interval));
678 spectrum.start_time = 0;
680 spectrum.channels[0].duration = cpu_to_le32(duration * TIME_UNIT);
681 spectrum.channels[0].channel = params->channel;
682 spectrum.channels[0].type = type;
683 if (il->active.flags & RXON_FLG_BAND_24G_MSK)
685 RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK |
686 RXON_FLG_TGG_PROTECT_MSK;
688 rc = il_send_cmd_sync(il, &cmd);
692 pkt = (struct il_rx_pkt *)cmd.reply_page;
693 if (pkt->hdr.flags & IL_CMD_FAILED_MSK) {
694 IL_ERR("Bad return from N_RX_ON_ASSOC command\n");
698 spectrum_resp_status = le16_to_cpu(pkt->u.spectrum.status);
699 switch (spectrum_resp_status) {
700 case 0: /* Command will be handled */
701 if (pkt->u.spectrum.id != 0xff) {
702 D_INFO("Replaced existing measurement: %d\n",
704 il->measurement_status &= ~MEASUREMENT_READY;
706 il->measurement_status |= MEASUREMENT_ACTIVE;
710 case 1: /* Command will not be handled */
715 il_free_pages(il, cmd.reply_page);
721 il3945_hdl_alive(struct il_priv *il, struct il_rx_buf *rxb)
723 struct il_rx_pkt *pkt = rxb_addr(rxb);
724 struct il_alive_resp *palive;
725 struct delayed_work *pwork;
727 palive = &pkt->u.alive_frame;
729 D_INFO("Alive ucode status 0x%08X revision " "0x%01X 0x%01X\n",
730 palive->is_valid, palive->ver_type, palive->ver_subtype);
732 if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
733 D_INFO("Initialization Alive received.\n");
734 memcpy(&il->card_alive_init, &pkt->u.alive_frame,
735 sizeof(struct il_alive_resp));
736 pwork = &il->init_alive_start;
738 D_INFO("Runtime Alive received.\n");
739 memcpy(&il->card_alive, &pkt->u.alive_frame,
740 sizeof(struct il_alive_resp));
741 pwork = &il->alive_start;
742 il3945_disable_events(il);
745 /* We delay the ALIVE response by 5ms to
746 * give the HW RF Kill time to activate... */
747 if (palive->is_valid == UCODE_VALID_OK)
748 queue_delayed_work(il->workqueue, pwork, msecs_to_jiffies(5));
750 IL_WARN("uCode did not respond OK.\n");
754 il3945_hdl_add_sta(struct il_priv *il, struct il_rx_buf *rxb)
756 #ifdef CONFIG_IWLEGACY_DEBUG
757 struct il_rx_pkt *pkt = rxb_addr(rxb);
760 D_RX("Received C_ADD_STA: 0x%02X\n", pkt->u.status);
764 il3945_hdl_beacon(struct il_priv *il, struct il_rx_buf *rxb)
766 struct il_rx_pkt *pkt = rxb_addr(rxb);
767 struct il3945_beacon_notif *beacon = &(pkt->u.beacon_status);
768 #ifdef CONFIG_IWLEGACY_DEBUG
769 u8 rate = beacon->beacon_notify_hdr.rate;
771 D_RX("beacon status %x retries %d iss %d " "tsf %d %d rate %d\n",
772 le32_to_cpu(beacon->beacon_notify_hdr.status) & TX_STATUS_MSK,
773 beacon->beacon_notify_hdr.failure_frame,
774 le32_to_cpu(beacon->ibss_mgr_status),
775 le32_to_cpu(beacon->high_tsf), le32_to_cpu(beacon->low_tsf), rate);
778 il->ibss_manager = le32_to_cpu(beacon->ibss_mgr_status);
782 /* Handle notification from uCode that card's power state is changing
783 * due to software, hardware, or critical temperature RFKILL */
785 il3945_hdl_card_state(struct il_priv *il, struct il_rx_buf *rxb)
787 struct il_rx_pkt *pkt = rxb_addr(rxb);
788 u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
789 unsigned long status = il->status;
791 IL_WARN("Card state received: HW:%s SW:%s\n",
792 (flags & HW_CARD_DISABLED) ? "Kill" : "On",
793 (flags & SW_CARD_DISABLED) ? "Kill" : "On");
795 _il_wr(il, CSR_UCODE_DRV_GP1_SET, CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
797 if (flags & HW_CARD_DISABLED)
798 set_bit(S_RFKILL, &il->status);
800 clear_bit(S_RFKILL, &il->status);
804 if ((test_bit(S_RFKILL, &status) !=
805 test_bit(S_RFKILL, &il->status)))
806 wiphy_rfkill_set_hw_state(il->hw->wiphy,
807 test_bit(S_RFKILL, &il->status));
809 wake_up(&il->wait_command_queue);
813 * il3945_setup_handlers - Initialize Rx handler callbacks
815 * Setup the RX handlers for each of the reply types sent from the uCode
818 * This function chains into the hardware specific files for them to setup
819 * any hardware specific handlers as well.
822 il3945_setup_handlers(struct il_priv *il)
824 il->handlers[N_ALIVE] = il3945_hdl_alive;
825 il->handlers[C_ADD_STA] = il3945_hdl_add_sta;
826 il->handlers[N_ERROR] = il_hdl_error;
827 il->handlers[N_CHANNEL_SWITCH] = il_hdl_csa;
828 il->handlers[N_SPECTRUM_MEASUREMENT] = il_hdl_spectrum_measurement;
829 il->handlers[N_PM_SLEEP] = il_hdl_pm_sleep;
830 il->handlers[N_PM_DEBUG_STATS] = il_hdl_pm_debug_stats;
831 il->handlers[N_BEACON] = il3945_hdl_beacon;
834 * The same handler is used for both the REPLY to a discrete
835 * stats request from the host as well as for the periodic
836 * stats notifications (after received beacons) from the uCode.
838 il->handlers[C_STATS] = il3945_hdl_c_stats;
839 il->handlers[N_STATS] = il3945_hdl_stats;
841 il_setup_rx_scan_handlers(il);
842 il->handlers[N_CARD_STATE] = il3945_hdl_card_state;
844 /* Set up hardware specific Rx handlers */
845 il3945_hw_handler_setup(il);
848 /************************** RX-FUNCTIONS ****************************/
850 * Rx theory of operation
852 * The host allocates 32 DMA target addresses and passes the host address
853 * to the firmware at register IL_RFDS_TBL_LOWER + N * RFD_SIZE where N is
857 * The host/firmware share two idx registers for managing the Rx buffers.
859 * The READ idx maps to the first position that the firmware may be writing
860 * to -- the driver can read up to (but not including) this position and get
862 * The READ idx is managed by the firmware once the card is enabled.
864 * The WRITE idx maps to the last position the driver has read from -- the
865 * position preceding WRITE is the last slot the firmware can place a packet.
867 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
870 * During initialization, the host sets up the READ queue position to the first
871 * IDX position, and WRITE to the last (READ - 1 wrapped)
873 * When the firmware places a packet in a buffer, it will advance the READ idx
874 * and fire the RX interrupt. The driver can then query the READ idx and
875 * process as many packets as possible, moving the WRITE idx forward as it
876 * resets the Rx queue buffers with new memory.
878 * The management in the driver is as follows:
879 * + A list of pre-allocated SKBs is stored in iwl->rxq->rx_free. When
880 * iwl->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
881 * to replenish the iwl->rxq->rx_free.
882 * + In il3945_rx_replenish (scheduled) if 'processed' != 'read' then the
883 * iwl->rxq is replenished and the READ IDX is updated (updating the
884 * 'processed' and 'read' driver idxes as well)
885 * + A received packet is processed and handed to the kernel network stack,
886 * detached from the iwl->rxq. The driver 'processed' idx is updated.
887 * + The Host/Firmware iwl->rxq is replenished at tasklet time from the rx_free
888 * list. If there are no allocated buffers in iwl->rxq->rx_free, the READ
889 * IDX is not incremented and iwl->status(RX_STALLED) is set. If there
890 * were enough free buffers and RX_STALLED is set it is cleared.
895 * il3945_rx_replenish() Replenishes rx_free list from rx_used, and calls
896 * il3945_rx_queue_restock
897 * il3945_rx_queue_restock() Moves available buffers from rx_free into Rx
898 * queue, updates firmware pointers, and updates
899 * the WRITE idx. If insufficient rx_free buffers
900 * are available, schedules il3945_rx_replenish
902 * -- enable interrupts --
903 * ISR - il3945_rx() Detach il_rx_bufs from pool up to the
904 * READ IDX, detaching the SKB from the pool.
905 * Moves the packet buffer from queue to rx_used.
906 * Calls il3945_rx_queue_restock to refill any empty
913 * il3945_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
916 il3945_dma_addr2rbd_ptr(struct il_priv *il, dma_addr_t dma_addr)
918 return cpu_to_le32((u32) dma_addr);
922 * il3945_rx_queue_restock - refill RX queue from pre-allocated pool
924 * If there are slots in the RX queue that need to be restocked,
925 * and we have free pre-allocated buffers, fill the ranks as much
926 * as we can, pulling from rx_free.
928 * This moves the 'write' idx forward to catch up with 'processed', and
929 * also updates the memory address in the firmware to reference the new
933 il3945_rx_queue_restock(struct il_priv *il)
935 struct il_rx_queue *rxq = &il->rxq;
936 struct list_head *element;
937 struct il_rx_buf *rxb;
940 spin_lock_irqsave(&rxq->lock, flags);
941 while (il_rx_queue_space(rxq) > 0 && rxq->free_count) {
942 /* Get next free Rx buffer, remove from free list */
943 element = rxq->rx_free.next;
944 rxb = list_entry(element, struct il_rx_buf, list);
947 /* Point to Rx buffer via next RBD in circular buffer */
948 rxq->bd[rxq->write] =
949 il3945_dma_addr2rbd_ptr(il, rxb->page_dma);
950 rxq->queue[rxq->write] = rxb;
951 rxq->write = (rxq->write + 1) & RX_QUEUE_MASK;
954 spin_unlock_irqrestore(&rxq->lock, flags);
955 /* If the pre-allocated buffer pool is dropping low, schedule to
957 if (rxq->free_count <= RX_LOW_WATERMARK)
958 queue_work(il->workqueue, &il->rx_replenish);
960 /* If we've added more space for the firmware to place data, tell it.
961 * Increment device's write pointer in multiples of 8. */
962 if (rxq->write_actual != (rxq->write & ~0x7) ||
963 abs(rxq->write - rxq->read) > 7) {
964 spin_lock_irqsave(&rxq->lock, flags);
965 rxq->need_update = 1;
966 spin_unlock_irqrestore(&rxq->lock, flags);
967 il_rx_queue_update_write_ptr(il, rxq);
972 * il3945_rx_replenish - Move all used packet from rx_used to rx_free
974 * When moving to rx_free an SKB is allocated for the slot.
976 * Also restock the Rx queue via il3945_rx_queue_restock.
977 * This is called as a scheduled work item (except for during initialization)
980 il3945_rx_allocate(struct il_priv *il, gfp_t priority)
982 struct il_rx_queue *rxq = &il->rxq;
983 struct list_head *element;
984 struct il_rx_buf *rxb;
988 gfp_t gfp_mask = priority;
991 spin_lock_irqsave(&rxq->lock, flags);
992 if (list_empty(&rxq->rx_used)) {
993 spin_unlock_irqrestore(&rxq->lock, flags);
996 spin_unlock_irqrestore(&rxq->lock, flags);
998 if (rxq->free_count > RX_LOW_WATERMARK)
999 gfp_mask |= __GFP_NOWARN;
1001 if (il->hw_params.rx_page_order > 0)
1002 gfp_mask |= __GFP_COMP;
1004 /* Alloc a new receive buffer */
1005 page = alloc_pages(gfp_mask, il->hw_params.rx_page_order);
1007 if (net_ratelimit())
1008 D_INFO("Failed to allocate SKB buffer.\n");
1009 if (rxq->free_count <= RX_LOW_WATERMARK &&
1011 IL_ERR("Failed to allocate SKB buffer with %0x."
1012 "Only %u free buffers remaining.\n",
1013 priority, rxq->free_count);
1014 /* We don't reschedule replenish work here -- we will
1015 * call the restock method and if it still needs
1016 * more buffers it will schedule replenish */
1020 /* Get physical address of RB/SKB */
1022 pci_map_page(il->pci_dev, page, 0,
1023 PAGE_SIZE << il->hw_params.rx_page_order,
1024 PCI_DMA_FROMDEVICE);
1026 if (unlikely(pci_dma_mapping_error(il->pci_dev, page_dma))) {
1027 __free_pages(page, il->hw_params.rx_page_order);
1031 spin_lock_irqsave(&rxq->lock, flags);
1033 if (list_empty(&rxq->rx_used)) {
1034 spin_unlock_irqrestore(&rxq->lock, flags);
1035 pci_unmap_page(il->pci_dev, page_dma,
1036 PAGE_SIZE << il->hw_params.rx_page_order,
1037 PCI_DMA_FROMDEVICE);
1038 __free_pages(page, il->hw_params.rx_page_order);
1042 element = rxq->rx_used.next;
1043 rxb = list_entry(element, struct il_rx_buf, list);
1047 rxb->page_dma = page_dma;
1048 list_add_tail(&rxb->list, &rxq->rx_free);
1050 il->alloc_rxb_page++;
1052 spin_unlock_irqrestore(&rxq->lock, flags);
1057 il3945_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq)
1059 unsigned long flags;
1061 spin_lock_irqsave(&rxq->lock, flags);
1062 INIT_LIST_HEAD(&rxq->rx_free);
1063 INIT_LIST_HEAD(&rxq->rx_used);
1064 /* Fill the rx_used queue with _all_ of the Rx buffers */
1065 for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
1066 /* In the reset function, these buffers may have been allocated
1067 * to an SKB, so we need to unmap and free potential storage */
1068 if (rxq->pool[i].page != NULL) {
1069 pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
1070 PAGE_SIZE << il->hw_params.rx_page_order,
1071 PCI_DMA_FROMDEVICE);
1072 __il_free_pages(il, rxq->pool[i].page);
1073 rxq->pool[i].page = NULL;
1075 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
1078 /* Set us so that we have processed and used all buffers, but have
1079 * not restocked the Rx queue with fresh buffers */
1080 rxq->read = rxq->write = 0;
1081 rxq->write_actual = 0;
1082 rxq->free_count = 0;
1083 spin_unlock_irqrestore(&rxq->lock, flags);
1087 il3945_rx_replenish(void *data)
1089 struct il_priv *il = data;
1090 unsigned long flags;
1092 il3945_rx_allocate(il, GFP_KERNEL);
1094 spin_lock_irqsave(&il->lock, flags);
1095 il3945_rx_queue_restock(il);
1096 spin_unlock_irqrestore(&il->lock, flags);
1100 il3945_rx_replenish_now(struct il_priv *il)
1102 il3945_rx_allocate(il, GFP_ATOMIC);
1104 il3945_rx_queue_restock(il);
1107 /* Assumes that the skb field of the buffers in 'pool' is kept accurate.
1108 * If an SKB has been detached, the POOL needs to have its SKB set to NULL
1109 * This free routine walks the list of POOL entries and if SKB is set to
1110 * non NULL it is unmapped and freed
1113 il3945_rx_queue_free(struct il_priv *il, struct il_rx_queue *rxq)
1116 for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
1117 if (rxq->pool[i].page != NULL) {
1118 pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
1119 PAGE_SIZE << il->hw_params.rx_page_order,
1120 PCI_DMA_FROMDEVICE);
1121 __il_free_pages(il, rxq->pool[i].page);
1122 rxq->pool[i].page = NULL;
1126 dma_free_coherent(&il->pci_dev->dev, 4 * RX_QUEUE_SIZE, rxq->bd,
1128 dma_free_coherent(&il->pci_dev->dev, sizeof(struct il_rb_status),
1129 rxq->rb_stts, rxq->rb_stts_dma);
1131 rxq->rb_stts = NULL;
1134 /* Convert linear signal-to-noise ratio into dB */
1135 static u8 ratio2dB[100] = {
1136 /* 0 1 2 3 4 5 6 7 8 9 */
1137 0, 0, 6, 10, 12, 14, 16, 17, 18, 19, /* 00 - 09 */
1138 20, 21, 22, 22, 23, 23, 24, 25, 26, 26, /* 10 - 19 */
1139 26, 26, 26, 27, 27, 28, 28, 28, 29, 29, /* 20 - 29 */
1140 29, 30, 30, 30, 31, 31, 31, 31, 32, 32, /* 30 - 39 */
1141 32, 32, 32, 33, 33, 33, 33, 33, 34, 34, /* 40 - 49 */
1142 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, /* 50 - 59 */
1143 36, 36, 36, 36, 36, 36, 36, 37, 37, 37, /* 60 - 69 */
1144 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, /* 70 - 79 */
1145 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, /* 80 - 89 */
1146 39, 39, 39, 39, 39, 40, 40, 40, 40, 40 /* 90 - 99 */
1149 /* Calculates a relative dB value from a ratio of linear
1150 * (i.e. not dB) signal levels.
1151 * Conversion assumes that levels are voltages (20*log), not powers (10*log). */
1153 il3945_calc_db_from_ratio(int sig_ratio)
1155 /* 1000:1 or higher just report as 60 dB */
1156 if (sig_ratio >= 1000)
1159 /* 100:1 or higher, divide by 10 and use table,
1160 * add 20 dB to make up for divide by 10 */
1161 if (sig_ratio >= 100)
1162 return 20 + (int)ratio2dB[sig_ratio / 10];
1164 /* We shouldn't see this */
1168 /* Use table for ratios 1:1 - 99:1 */
1169 return (int)ratio2dB[sig_ratio];
1173 * il3945_rx_handle - Main entry function for receiving responses from uCode
1175 * Uses the il->handlers callback function array to invoke
1176 * the appropriate handlers, including command responses,
1177 * frame-received notifications, and other notifications.
1180 il3945_rx_handle(struct il_priv *il)
1182 struct il_rx_buf *rxb;
1183 struct il_rx_pkt *pkt;
1184 struct il_rx_queue *rxq = &il->rxq;
1187 unsigned long flags;
1190 int total_empty = 0;
1192 /* uCode's read idx (stored in shared DRAM) indicates the last Rx
1193 * buffer that the driver may process (last buffer filled by ucode). */
1194 r = le16_to_cpu(rxq->rb_stts->closed_rb_num) & 0x0FFF;
1197 /* calculate total frames need to be restock after handling RX */
1198 total_empty = r - rxq->write_actual;
1199 if (total_empty < 0)
1200 total_empty += RX_QUEUE_SIZE;
1202 if (total_empty > (RX_QUEUE_SIZE / 2))
1204 /* Rx interrupt, but nothing sent from uCode */
1206 D_RX("r = %d, i = %d\n", r, i);
1211 rxb = rxq->queue[i];
1213 /* If an RXB doesn't have a Rx queue slot associated with it,
1214 * then a bug has been introduced in the queue refilling
1215 * routines -- catch it here */
1216 BUG_ON(rxb == NULL);
1218 rxq->queue[i] = NULL;
1220 pci_unmap_page(il->pci_dev, rxb->page_dma,
1221 PAGE_SIZE << il->hw_params.rx_page_order,
1222 PCI_DMA_FROMDEVICE);
1223 pkt = rxb_addr(rxb);
1225 len = le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK;
1226 len += sizeof(u32); /* account for status word */
1228 reclaim = il_need_reclaim(il, pkt);
1230 /* Based on type of command response or notification,
1231 * handle those that need handling via function in
1232 * handlers table. See il3945_setup_handlers() */
1233 if (il->handlers[pkt->hdr.cmd]) {
1234 D_RX("r = %d, i = %d, %s, 0x%02x\n", r, i,
1235 il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
1236 il->isr_stats.handlers[pkt->hdr.cmd]++;
1237 il->handlers[pkt->hdr.cmd] (il, rxb);
1239 /* No handling needed */
1240 D_RX("r %d i %d No handler needed for %s, 0x%02x\n", r,
1241 i, il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
1245 * XXX: After here, we should always check rxb->page
1246 * against NULL before touching it or its virtual
1247 * memory (pkt). Because some handler might have
1248 * already taken or freed the pages.
1252 /* Invoke any callbacks, transfer the buffer to caller,
1253 * and fire off the (possibly) blocking il_send_cmd()
1254 * as we reclaim the driver command queue */
1256 il_tx_cmd_complete(il, rxb);
1258 IL_WARN("Claim null rxb?\n");
1261 /* Reuse the page if possible. For notification packets and
1262 * SKBs that fail to Rx correctly, add them back into the
1263 * rx_free list for reuse later. */
1264 spin_lock_irqsave(&rxq->lock, flags);
1265 if (rxb->page != NULL) {
1267 pci_map_page(il->pci_dev, rxb->page, 0,
1268 PAGE_SIZE << il->hw_params.
1269 rx_page_order, PCI_DMA_FROMDEVICE);
1270 if (unlikely(pci_dma_mapping_error(il->pci_dev,
1272 __il_free_pages(il, rxb->page);
1274 list_add_tail(&rxb->list, &rxq->rx_used);
1276 list_add_tail(&rxb->list, &rxq->rx_free);
1280 list_add_tail(&rxb->list, &rxq->rx_used);
1282 spin_unlock_irqrestore(&rxq->lock, flags);
1284 i = (i + 1) & RX_QUEUE_MASK;
1285 /* If there are a lot of unused frames,
1286 * restock the Rx queue so ucode won't assert. */
1291 il3945_rx_replenish_now(il);
1297 /* Backtrack one entry */
1300 il3945_rx_replenish_now(il);
1302 il3945_rx_queue_restock(il);
1305 /* call this function to flush any scheduled tasklet */
1307 il3945_synchronize_irq(struct il_priv *il)
1309 /* wait to make sure we flush pending tasklet */
1310 synchronize_irq(il->pci_dev->irq);
1311 tasklet_kill(&il->irq_tasklet);
1315 il3945_desc_lookup(int i)
1323 return "BAD_CHECKSUM";
1325 return "NMI_INTERRUPT";
1329 return "FATAL_ERROR";
1335 #define ERROR_START_OFFSET (1 * sizeof(u32))
1336 #define ERROR_ELEM_SIZE (7 * sizeof(u32))
1339 il3945_dump_nic_error_log(struct il_priv *il)
1342 u32 desc, time, count, base, data1;
1343 u32 blink1, blink2, ilink1, ilink2;
1345 base = le32_to_cpu(il->card_alive.error_event_table_ptr);
1347 if (!il3945_hw_valid_rtc_data_addr(base)) {
1348 IL_ERR("Not valid error log pointer 0x%08X\n", base);
1352 count = il_read_targ_mem(il, base);
1354 if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
1355 IL_ERR("Start IWL Error Log Dump:\n");
1356 IL_ERR("Status: 0x%08lX, count: %d\n", il->status, count);
1359 IL_ERR("Desc Time asrtPC blink2 "
1360 "ilink1 nmiPC Line\n");
1361 for (i = ERROR_START_OFFSET;
1362 i < (count * ERROR_ELEM_SIZE) + ERROR_START_OFFSET;
1363 i += ERROR_ELEM_SIZE) {
1364 desc = il_read_targ_mem(il, base + i);
1365 time = il_read_targ_mem(il, base + i + 1 * sizeof(u32));
1366 blink1 = il_read_targ_mem(il, base + i + 2 * sizeof(u32));
1367 blink2 = il_read_targ_mem(il, base + i + 3 * sizeof(u32));
1368 ilink1 = il_read_targ_mem(il, base + i + 4 * sizeof(u32));
1369 ilink2 = il_read_targ_mem(il, base + i + 5 * sizeof(u32));
1370 data1 = il_read_targ_mem(il, base + i + 6 * sizeof(u32));
1372 IL_ERR("%-13s (0x%X) %010u 0x%05X 0x%05X 0x%05X 0x%05X %u\n\n",
1373 il3945_desc_lookup(desc), desc, time, blink1, blink2,
1374 ilink1, ilink2, data1);
1379 il3945_irq_tasklet(unsigned long data)
1381 struct il_priv *il = (struct il_priv *)data;
1382 u32 inta, handled = 0;
1384 unsigned long flags;
1385 #ifdef CONFIG_IWLEGACY_DEBUG
1389 spin_lock_irqsave(&il->lock, flags);
1391 /* Ack/clear/reset pending uCode interrupts.
1392 * Note: Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
1393 * and will clear only when CSR_FH_INT_STATUS gets cleared. */
1394 inta = _il_rd(il, CSR_INT);
1395 _il_wr(il, CSR_INT, inta);
1397 /* Ack/clear/reset pending flow-handler (DMA) interrupts.
1398 * Any new interrupts that happen after this, either while we're
1399 * in this tasklet, or later, will show up in next ISR/tasklet. */
1400 inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
1401 _il_wr(il, CSR_FH_INT_STATUS, inta_fh);
1403 #ifdef CONFIG_IWLEGACY_DEBUG
1404 if (il_get_debug_level(il) & IL_DL_ISR) {
1405 /* just for debug */
1406 inta_mask = _il_rd(il, CSR_INT_MASK);
1407 D_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n", inta,
1408 inta_mask, inta_fh);
1412 spin_unlock_irqrestore(&il->lock, flags);
1414 /* Since CSR_INT and CSR_FH_INT_STATUS reads and clears are not
1415 * atomic, make sure that inta covers all the interrupts that
1416 * we've discovered, even if FH interrupt came in just after
1417 * reading CSR_INT. */
1418 if (inta_fh & CSR39_FH_INT_RX_MASK)
1419 inta |= CSR_INT_BIT_FH_RX;
1420 if (inta_fh & CSR39_FH_INT_TX_MASK)
1421 inta |= CSR_INT_BIT_FH_TX;
1423 /* Now service all interrupt bits discovered above. */
1424 if (inta & CSR_INT_BIT_HW_ERR) {
1425 IL_ERR("Hardware error detected. Restarting.\n");
1427 /* Tell the device to stop sending interrupts */
1428 il_disable_interrupts(il);
1431 il_irq_handle_error(il);
1433 handled |= CSR_INT_BIT_HW_ERR;
1437 #ifdef CONFIG_IWLEGACY_DEBUG
1438 if (il_get_debug_level(il) & (IL_DL_ISR)) {
1439 /* NIC fires this, but we don't use it, redundant with WAKEUP */
1440 if (inta & CSR_INT_BIT_SCD) {
1441 D_ISR("Scheduler finished to transmit "
1442 "the frame/frames.\n");
1443 il->isr_stats.sch++;
1446 /* Alive notification via Rx interrupt will do the real work */
1447 if (inta & CSR_INT_BIT_ALIVE) {
1448 D_ISR("Alive interrupt\n");
1449 il->isr_stats.alive++;
1453 /* Safely ignore these bits for debug checks below */
1454 inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
1456 /* Error detected by uCode */
1457 if (inta & CSR_INT_BIT_SW_ERR) {
1458 IL_ERR("Microcode SW error detected. " "Restarting 0x%X.\n",
1461 il_irq_handle_error(il);
1462 handled |= CSR_INT_BIT_SW_ERR;
1465 /* uCode wakes up after power-down sleep */
1466 if (inta & CSR_INT_BIT_WAKEUP) {
1467 D_ISR("Wakeup interrupt\n");
1468 il_rx_queue_update_write_ptr(il, &il->rxq);
1470 spin_lock_irqsave(&il->lock, flags);
1471 il_txq_update_write_ptr(il, &il->txq[0]);
1472 il_txq_update_write_ptr(il, &il->txq[1]);
1473 il_txq_update_write_ptr(il, &il->txq[2]);
1474 il_txq_update_write_ptr(il, &il->txq[3]);
1475 il_txq_update_write_ptr(il, &il->txq[4]);
1476 spin_unlock_irqrestore(&il->lock, flags);
1478 il->isr_stats.wakeup++;
1479 handled |= CSR_INT_BIT_WAKEUP;
1482 /* All uCode command responses, including Tx command responses,
1483 * Rx "responses" (frame-received notification), and other
1484 * notifications from uCode come through here*/
1485 if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX)) {
1486 il3945_rx_handle(il);
1488 handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
1491 if (inta & CSR_INT_BIT_FH_TX) {
1492 D_ISR("Tx interrupt\n");
1495 _il_wr(il, CSR_FH_INT_STATUS, (1 << 6));
1496 il_wr(il, FH39_TCSR_CREDIT(FH39_SRVC_CHNL), 0x0);
1497 handled |= CSR_INT_BIT_FH_TX;
1500 if (inta & ~handled) {
1501 IL_ERR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
1502 il->isr_stats.unhandled++;
1505 if (inta & ~il->inta_mask) {
1506 IL_WARN("Disabled INTA bits 0x%08x were pending\n",
1507 inta & ~il->inta_mask);
1508 IL_WARN(" with inta_fh = 0x%08x\n", inta_fh);
1511 /* Re-enable all interrupts */
1512 /* only Re-enable if disabled by irq */
1513 if (test_bit(S_INT_ENABLED, &il->status))
1514 il_enable_interrupts(il);
1516 #ifdef CONFIG_IWLEGACY_DEBUG
1517 if (il_get_debug_level(il) & (IL_DL_ISR)) {
1518 inta = _il_rd(il, CSR_INT);
1519 inta_mask = _il_rd(il, CSR_INT_MASK);
1520 inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
1521 D_ISR("End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
1522 "flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
1528 il3945_get_channels_for_scan(struct il_priv *il, enum nl80211_band band,
1529 u8 is_active, u8 n_probes,
1530 struct il3945_scan_channel *scan_ch,
1531 struct ieee80211_vif *vif)
1533 struct ieee80211_channel *chan;
1534 const struct ieee80211_supported_band *sband;
1535 const struct il_channel_info *ch_info;
1536 u16 passive_dwell = 0;
1537 u16 active_dwell = 0;
1540 sband = il_get_hw_mode(il, band);
1544 active_dwell = il_get_active_dwell_time(il, band, n_probes);
1545 passive_dwell = il_get_passive_dwell_time(il, band, vif);
1547 if (passive_dwell <= active_dwell)
1548 passive_dwell = active_dwell + 1;
1550 for (i = 0, added = 0; i < il->scan_request->n_channels; i++) {
1551 chan = il->scan_request->channels[i];
1553 if (chan->band != band)
1556 scan_ch->channel = chan->hw_value;
1558 ch_info = il_get_channel_info(il, band, scan_ch->channel);
1559 if (!il_is_channel_valid(ch_info)) {
1560 D_SCAN("Channel %d is INVALID for this band.\n",
1565 scan_ch->active_dwell = cpu_to_le16(active_dwell);
1566 scan_ch->passive_dwell = cpu_to_le16(passive_dwell);
1567 /* If passive , set up for auto-switch
1568 * and use long active_dwell time.
1570 if (!is_active || il_is_channel_passive(ch_info) ||
1571 (chan->flags & IEEE80211_CHAN_NO_IR)) {
1572 scan_ch->type = 0; /* passive */
1573 if (IL_UCODE_API(il->ucode_ver) == 1)
1574 scan_ch->active_dwell =
1575 cpu_to_le16(passive_dwell - 1);
1577 scan_ch->type = 1; /* active */
1580 /* Set direct probe bits. These may be used both for active
1581 * scan channels (probes gets sent right away),
1582 * or for passive channels (probes get se sent only after
1583 * hearing clear Rx packet).*/
1584 if (IL_UCODE_API(il->ucode_ver) >= 2) {
1586 scan_ch->type |= IL39_SCAN_PROBE_MASK(n_probes);
1588 /* uCode v1 does not allow setting direct probe bits on
1589 * passive channel. */
1590 if ((scan_ch->type & 1) && n_probes)
1591 scan_ch->type |= IL39_SCAN_PROBE_MASK(n_probes);
1594 /* Set txpower levels to defaults */
1595 scan_ch->tpc.dsp_atten = 110;
1596 /* scan_pwr_info->tpc.dsp_atten; */
1598 /*scan_pwr_info->tpc.tx_gain; */
1599 if (band == NL80211_BAND_5GHZ)
1600 scan_ch->tpc.tx_gain = ((1 << 5) | (3 << 3)) | 3;
1602 scan_ch->tpc.tx_gain = ((1 << 5) | (5 << 3));
1603 /* NOTE: if we were doing 6Mb OFDM for scans we'd use
1605 * scan_ch->tpc.tx_gain = ((1 << 5) | (2 << 3)) | 3;
1609 D_SCAN("Scanning %d [%s %d]\n", scan_ch->channel,
1610 (scan_ch->type & 1) ? "ACTIVE" : "PASSIVE",
1611 (scan_ch->type & 1) ? active_dwell : passive_dwell);
1617 D_SCAN("total channels to scan %d\n", added);
1622 il3945_init_hw_rates(struct il_priv *il, struct ieee80211_rate *rates)
1626 for (i = 0; i < RATE_COUNT_LEGACY; i++) {
1627 rates[i].bitrate = il3945_rates[i].ieee * 5;
1628 rates[i].hw_value = i; /* Rate scaling will work on idxes */
1629 rates[i].hw_value_short = i;
1631 if (i > IL39_LAST_OFDM_RATE || i < IL_FIRST_OFDM_RATE) {
1633 * If CCK != 1M then set short preamble rate flag.
1636 (il3945_rates[i].plcp ==
1637 10) ? 0 : IEEE80211_RATE_SHORT_PREAMBLE;
1642 /******************************************************************************
1644 * uCode download functions
1646 ******************************************************************************/
1649 il3945_dealloc_ucode_pci(struct il_priv *il)
1651 il_free_fw_desc(il->pci_dev, &il->ucode_code);
1652 il_free_fw_desc(il->pci_dev, &il->ucode_data);
1653 il_free_fw_desc(il->pci_dev, &il->ucode_data_backup);
1654 il_free_fw_desc(il->pci_dev, &il->ucode_init);
1655 il_free_fw_desc(il->pci_dev, &il->ucode_init_data);
1656 il_free_fw_desc(il->pci_dev, &il->ucode_boot);
1660 * il3945_verify_inst_full - verify runtime uCode image in card vs. host,
1661 * looking at all data.
1664 il3945_verify_inst_full(struct il_priv *il, __le32 * image, u32 len)
1671 D_INFO("ucode inst image size is %u\n", len);
1673 il_wr(il, HBUS_TARG_MEM_RADDR, IL39_RTC_INST_LOWER_BOUND);
1676 for (; len > 0; len -= sizeof(u32), image++) {
1677 /* read data comes through single port, auto-incr addr */
1678 /* NOTE: Use the debugless read so we don't flood kernel log
1679 * if IL_DL_IO is set */
1680 val = _il_rd(il, HBUS_TARG_MEM_RDAT);
1681 if (val != le32_to_cpu(*image)) {
1682 IL_ERR("uCode INST section is invalid at "
1683 "offset 0x%x, is 0x%x, s/b 0x%x\n",
1684 save_len - len, val, le32_to_cpu(*image));
1693 D_INFO("ucode image in INSTRUCTION memory is good\n");
1699 * il3945_verify_inst_sparse - verify runtime uCode image in card vs. host,
1700 * using sample data 100 bytes apart. If these sample points are good,
1701 * it's a pretty good bet that everything between them is good, too.
1704 il3945_verify_inst_sparse(struct il_priv *il, __le32 * image, u32 len)
1711 D_INFO("ucode inst image size is %u\n", len);
1713 for (i = 0; i < len; i += 100, image += 100 / sizeof(u32)) {
1714 /* read data comes through single port, auto-incr addr */
1715 /* NOTE: Use the debugless read so we don't flood kernel log
1716 * if IL_DL_IO is set */
1717 il_wr(il, HBUS_TARG_MEM_RADDR, i + IL39_RTC_INST_LOWER_BOUND);
1718 val = _il_rd(il, HBUS_TARG_MEM_RDAT);
1719 if (val != le32_to_cpu(*image)) {
1720 #if 0 /* Enable this if you want to see details */
1721 IL_ERR("uCode INST section is invalid at "
1722 "offset 0x%x, is 0x%x, s/b 0x%x\n", i, val,
1736 * il3945_verify_ucode - determine which instruction image is in SRAM,
1737 * and verify its contents
1740 il3945_verify_ucode(struct il_priv *il)
1747 image = (__le32 *) il->ucode_boot.v_addr;
1748 len = il->ucode_boot.len;
1749 rc = il3945_verify_inst_sparse(il, image, len);
1751 D_INFO("Bootstrap uCode is good in inst SRAM\n");
1755 /* Try initialize */
1756 image = (__le32 *) il->ucode_init.v_addr;
1757 len = il->ucode_init.len;
1758 rc = il3945_verify_inst_sparse(il, image, len);
1760 D_INFO("Initialize uCode is good in inst SRAM\n");
1764 /* Try runtime/protocol */
1765 image = (__le32 *) il->ucode_code.v_addr;
1766 len = il->ucode_code.len;
1767 rc = il3945_verify_inst_sparse(il, image, len);
1769 D_INFO("Runtime uCode is good in inst SRAM\n");
1773 IL_ERR("NO VALID UCODE IMAGE IN INSTRUCTION SRAM!!\n");
1775 /* Since nothing seems to match, show first several data entries in
1776 * instruction SRAM, so maybe visual inspection will give a clue.
1777 * Selection of bootstrap image (vs. other images) is arbitrary. */
1778 image = (__le32 *) il->ucode_boot.v_addr;
1779 len = il->ucode_boot.len;
1780 rc = il3945_verify_inst_full(il, image, len);
1786 il3945_nic_start(struct il_priv *il)
1788 /* Remove all resets to allow NIC to operate */
1789 _il_wr(il, CSR_RESET, 0);
1792 #define IL3945_UCODE_GET(item) \
1793 static u32 il3945_ucode_get_##item(const struct il_ucode_header *ucode)\
1795 return le32_to_cpu(ucode->v1.item); \
1799 il3945_ucode_get_header_size(u32 api_ver)
1805 il3945_ucode_get_data(const struct il_ucode_header *ucode)
1807 return (u8 *) ucode->v1.data;
1810 IL3945_UCODE_GET(inst_size);
1811 IL3945_UCODE_GET(data_size);
1812 IL3945_UCODE_GET(init_size);
1813 IL3945_UCODE_GET(init_data_size);
1814 IL3945_UCODE_GET(boot_size);
1817 * il3945_read_ucode - Read uCode images from disk file.
1819 * Copy into buffers for card to fetch via bus-mastering
1822 il3945_read_ucode(struct il_priv *il)
1824 const struct il_ucode_header *ucode;
1825 int ret = -EINVAL, idx;
1826 const struct firmware *ucode_raw;
1827 /* firmware file name contains uCode/driver compatibility version */
1828 const char *name_pre = il->cfg->fw_name_pre;
1829 const unsigned int api_max = il->cfg->ucode_api_max;
1830 const unsigned int api_min = il->cfg->ucode_api_min;
1834 u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
1836 /* Ask kernel firmware_class module to get the boot firmware off disk.
1837 * reject_firmware() is synchronous, file is in memory on return. */
1838 for (idx = api_max; idx >= api_min; idx--) {
1839 sprintf(buf, "/*(DEBLOBBED)*/");
1840 ret = reject_firmware(&ucode_raw, buf, &il->pci_dev->dev);
1842 IL_ERR("%s firmware file req failed: %d\n", buf, ret);
1849 IL_ERR("Loaded firmware %s, "
1850 "which is deprecated. "
1851 " Please use API v%u instead.\n", buf,
1853 D_INFO("Got firmware '%s' file "
1854 "(%zd bytes) from disk\n", buf, ucode_raw->size);
1862 /* Make sure that we got at least our header! */
1863 if (ucode_raw->size < il3945_ucode_get_header_size(1)) {
1864 IL_ERR("File size way too small!\n");
1869 /* Data from ucode file: header followed by uCode images */
1870 ucode = (struct il_ucode_header *)ucode_raw->data;
1872 il->ucode_ver = le32_to_cpu(ucode->ver);
1873 api_ver = IL_UCODE_API(il->ucode_ver);
1874 inst_size = il3945_ucode_get_inst_size(ucode);
1875 data_size = il3945_ucode_get_data_size(ucode);
1876 init_size = il3945_ucode_get_init_size(ucode);
1877 init_data_size = il3945_ucode_get_init_data_size(ucode);
1878 boot_size = il3945_ucode_get_boot_size(ucode);
1879 src = il3945_ucode_get_data(ucode);
1881 /* api_ver should match the api version forming part of the
1882 * firmware filename ... but we don't check for that and only rely
1883 * on the API version read from firmware header from here on forward */
1885 if (api_ver < api_min || api_ver > api_max) {
1886 IL_ERR("Driver unable to support your firmware API. "
1887 "Driver supports v%u, firmware is v%u.\n", api_max,
1893 if (api_ver != api_max)
1894 IL_ERR("Firmware has old API version. Expected %u, "
1895 "got %u. New firmware can be obtained "
1896 "from http://www.intellinuxwireless.org.\n", api_max,
1899 IL_INFO("loaded firmware version %u.%u.%u.%u\n",
1900 IL_UCODE_MAJOR(il->ucode_ver), IL_UCODE_MINOR(il->ucode_ver),
1901 IL_UCODE_API(il->ucode_ver), IL_UCODE_SERIAL(il->ucode_ver));
1903 snprintf(il->hw->wiphy->fw_version, sizeof(il->hw->wiphy->fw_version),
1904 "%u.%u.%u.%u", IL_UCODE_MAJOR(il->ucode_ver),
1905 IL_UCODE_MINOR(il->ucode_ver), IL_UCODE_API(il->ucode_ver),
1906 IL_UCODE_SERIAL(il->ucode_ver));
1908 D_INFO("f/w package hdr ucode version raw = 0x%x\n", il->ucode_ver);
1909 D_INFO("f/w package hdr runtime inst size = %u\n", inst_size);
1910 D_INFO("f/w package hdr runtime data size = %u\n", data_size);
1911 D_INFO("f/w package hdr init inst size = %u\n", init_size);
1912 D_INFO("f/w package hdr init data size = %u\n", init_data_size);
1913 D_INFO("f/w package hdr boot inst size = %u\n", boot_size);
1915 /* Verify size of file vs. image size info in file's header */
1916 if (ucode_raw->size !=
1917 il3945_ucode_get_header_size(api_ver) + inst_size + data_size +
1918 init_size + init_data_size + boot_size) {
1920 D_INFO("uCode file size %zd does not match expected size\n",
1926 /* Verify that uCode images will fit in card's SRAM */
1927 if (inst_size > IL39_MAX_INST_SIZE) {
1928 D_INFO("uCode instr len %d too large to fit in\n", inst_size);
1933 if (data_size > IL39_MAX_DATA_SIZE) {
1934 D_INFO("uCode data len %d too large to fit in\n", data_size);
1938 if (init_size > IL39_MAX_INST_SIZE) {
1939 D_INFO("uCode init instr len %d too large to fit in\n",
1944 if (init_data_size > IL39_MAX_DATA_SIZE) {
1945 D_INFO("uCode init data len %d too large to fit in\n",
1950 if (boot_size > IL39_MAX_BSM_SIZE) {
1951 D_INFO("uCode boot instr len %d too large to fit in\n",
1957 /* Allocate ucode buffers for card's bus-master loading ... */
1959 /* Runtime instructions and 2 copies of data:
1960 * 1) unmodified from disk
1961 * 2) backup cache for save/restore during power-downs */
1962 il->ucode_code.len = inst_size;
1963 il_alloc_fw_desc(il->pci_dev, &il->ucode_code);
1965 il->ucode_data.len = data_size;
1966 il_alloc_fw_desc(il->pci_dev, &il->ucode_data);
1968 il->ucode_data_backup.len = data_size;
1969 il_alloc_fw_desc(il->pci_dev, &il->ucode_data_backup);
1971 if (!il->ucode_code.v_addr || !il->ucode_data.v_addr ||
1972 !il->ucode_data_backup.v_addr)
1975 /* Initialization instructions and data */
1976 if (init_size && init_data_size) {
1977 il->ucode_init.len = init_size;
1978 il_alloc_fw_desc(il->pci_dev, &il->ucode_init);
1980 il->ucode_init_data.len = init_data_size;
1981 il_alloc_fw_desc(il->pci_dev, &il->ucode_init_data);
1983 if (!il->ucode_init.v_addr || !il->ucode_init_data.v_addr)
1987 /* Bootstrap (instructions only, no data) */
1989 il->ucode_boot.len = boot_size;
1990 il_alloc_fw_desc(il->pci_dev, &il->ucode_boot);
1992 if (!il->ucode_boot.v_addr)
1996 /* Copy images into buffers for card's bus-master reads ... */
1998 /* Runtime instructions (first block of data in file) */
2000 D_INFO("Copying (but not loading) uCode instr len %zd\n", len);
2001 memcpy(il->ucode_code.v_addr, src, len);
2004 D_INFO("uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
2005 il->ucode_code.v_addr, (u32) il->ucode_code.p_addr);
2007 /* Runtime data (2nd block)
2008 * NOTE: Copy into backup buffer will be done in il3945_up() */
2010 D_INFO("Copying (but not loading) uCode data len %zd\n", len);
2011 memcpy(il->ucode_data.v_addr, src, len);
2012 memcpy(il->ucode_data_backup.v_addr, src, len);
2015 /* Initialization instructions (3rd block) */
2018 D_INFO("Copying (but not loading) init instr len %zd\n", len);
2019 memcpy(il->ucode_init.v_addr, src, len);
2023 /* Initialization data (4th block) */
2024 if (init_data_size) {
2025 len = init_data_size;
2026 D_INFO("Copying (but not loading) init data len %zd\n", len);
2027 memcpy(il->ucode_init_data.v_addr, src, len);
2031 /* Bootstrap instructions (5th block) */
2033 D_INFO("Copying (but not loading) boot instr len %zd\n", len);
2034 memcpy(il->ucode_boot.v_addr, src, len);
2036 /* We have our copies now, allow OS release its copies */
2037 release_firmware(ucode_raw);
2041 IL_ERR("failed to allocate pci memory\n");
2043 il3945_dealloc_ucode_pci(il);
2046 release_firmware(ucode_raw);
2053 * il3945_set_ucode_ptrs - Set uCode address location
2055 * Tell initialization uCode where to find runtime uCode.
2057 * BSM registers initially contain pointers to initialization uCode.
2058 * We need to replace them to load runtime uCode inst and data,
2059 * and to save runtime data when powering down.
2062 il3945_set_ucode_ptrs(struct il_priv *il)
2067 /* bits 31:0 for 3945 */
2068 pinst = il->ucode_code.p_addr;
2069 pdata = il->ucode_data_backup.p_addr;
2071 /* Tell bootstrap uCode where to find image to load */
2072 il_wr_prph(il, BSM_DRAM_INST_PTR_REG, pinst);
2073 il_wr_prph(il, BSM_DRAM_DATA_PTR_REG, pdata);
2074 il_wr_prph(il, BSM_DRAM_DATA_BYTECOUNT_REG, il->ucode_data.len);
2076 /* Inst byte count must be last to set up, bit 31 signals uCode
2077 * that all new ptr/size info is in place */
2078 il_wr_prph(il, BSM_DRAM_INST_BYTECOUNT_REG,
2079 il->ucode_code.len | BSM_DRAM_INST_LOAD);
2081 D_INFO("Runtime uCode pointers are set.\n");
2087 * il3945_init_alive_start - Called after N_ALIVE notification received
2089 * Called after N_ALIVE notification received from "initialize" uCode.
2091 * Tell "initialize" uCode to go ahead and load the runtime uCode.
2094 il3945_init_alive_start(struct il_priv *il)
2096 /* Check alive response for "valid" sign from uCode */
2097 if (il->card_alive_init.is_valid != UCODE_VALID_OK) {
2098 /* We had an error bringing up the hardware, so take it
2099 * all the way back down so we can try again */
2100 D_INFO("Initialize Alive failed.\n");
2104 /* Bootstrap uCode has loaded initialize uCode ... verify inst image.
2105 * This is a paranoid check, because we would not have gotten the
2106 * "initialize" alive if code weren't properly loaded. */
2107 if (il3945_verify_ucode(il)) {
2108 /* Runtime instruction load was bad;
2109 * take it all the way back down so we can try again */
2110 D_INFO("Bad \"initialize\" uCode load.\n");
2114 /* Send pointers to protocol/runtime uCode image ... init code will
2115 * load and launch runtime uCode, which will send us another "Alive"
2117 D_INFO("Initialization Alive received.\n");
2118 if (il3945_set_ucode_ptrs(il)) {
2119 /* Runtime instruction load won't happen;
2120 * take it all the way back down so we can try again */
2121 D_INFO("Couldn't set up uCode pointers.\n");
2127 queue_work(il->workqueue, &il->restart);
2131 * il3945_alive_start - called after N_ALIVE notification received
2132 * from protocol/runtime uCode (initialization uCode's
2133 * Alive gets handled by il3945_init_alive_start()).
2136 il3945_alive_start(struct il_priv *il)
2138 int thermal_spin = 0;
2141 D_INFO("Runtime Alive received.\n");
2143 if (il->card_alive.is_valid != UCODE_VALID_OK) {
2144 /* We had an error bringing up the hardware, so take it
2145 * all the way back down so we can try again */
2146 D_INFO("Alive failed.\n");
2150 /* Initialize uCode has loaded Runtime uCode ... verify inst image.
2151 * This is a paranoid check, because we would not have gotten the
2152 * "runtime" alive if code weren't properly loaded. */
2153 if (il3945_verify_ucode(il)) {
2154 /* Runtime instruction load was bad;
2155 * take it all the way back down so we can try again */
2156 D_INFO("Bad runtime uCode load.\n");
2160 rfkill = il_rd_prph(il, APMG_RFKILL_REG);
2161 D_INFO("RFKILL status: 0x%x\n", rfkill);
2164 clear_bit(S_RFKILL, &il->status);
2165 /* if RFKILL is not on, then wait for thermal
2166 * sensor in adapter to kick in */
2167 while (il3945_hw_get_temperature(il) == 0) {
2173 D_INFO("Thermal calibration took %dus\n",
2176 set_bit(S_RFKILL, &il->status);
2178 /* After the ALIVE response, we can send commands to 3945 uCode */
2179 set_bit(S_ALIVE, &il->status);
2181 /* Enable watchdog to monitor the driver tx queues */
2182 il_setup_watchdog(il);
2184 if (il_is_rfkill(il))
2187 ieee80211_wake_queues(il->hw);
2189 il->active_rate = RATES_MASK_3945;
2191 il_power_update_mode(il, true);
2193 if (il_is_associated(il)) {
2194 struct il3945_rxon_cmd *active_rxon =
2195 (struct il3945_rxon_cmd *)(&il->active);
2197 il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
2198 active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
2200 /* Initialize our rx_config data */
2201 il_connection_init_rx_config(il);
2204 /* Configure Bluetooth device coexistence support */
2205 il_send_bt_config(il);
2207 set_bit(S_READY, &il->status);
2209 /* Configure the adapter for unassociated operation */
2210 il3945_commit_rxon(il);
2212 il3945_reg_txpower_periodic(il);
2214 D_INFO("ALIVE processing complete.\n");
2215 wake_up(&il->wait_command_queue);
2220 queue_work(il->workqueue, &il->restart);
2223 static void il3945_cancel_deferred_work(struct il_priv *il);
2226 __il3945_down(struct il_priv *il)
2228 unsigned long flags;
2231 D_INFO(DRV_NAME " is going down\n");
2233 il_scan_cancel_timeout(il, 200);
2235 exit_pending = test_and_set_bit(S_EXIT_PENDING, &il->status);
2237 /* Stop TX queues watchdog. We need to have S_EXIT_PENDING bit set
2238 * to prevent rearm timer */
2239 del_timer_sync(&il->watchdog);
2241 /* Station information will now be cleared in device */
2242 il_clear_ucode_stations(il);
2243 il_dealloc_bcast_stations(il);
2244 il_clear_driver_stations(il);
2246 /* Unblock any waiting calls */
2247 wake_up_all(&il->wait_command_queue);
2249 /* Wipe out the EXIT_PENDING status bit if we are not actually
2250 * exiting the module */
2252 clear_bit(S_EXIT_PENDING, &il->status);
2254 /* stop and reset the on-board processor */
2255 _il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
2257 /* tell the device to stop sending interrupts */
2258 spin_lock_irqsave(&il->lock, flags);
2259 il_disable_interrupts(il);
2260 spin_unlock_irqrestore(&il->lock, flags);
2261 il3945_synchronize_irq(il);
2263 if (il->mac80211_registered)
2264 ieee80211_stop_queues(il->hw);
2266 /* If we have not previously called il3945_init() then
2267 * clear all bits but the RF Kill bits and return */
2268 if (!il_is_init(il)) {
2270 test_bit(S_RFKILL, &il->status) << S_RFKILL |
2271 test_bit(S_GEO_CONFIGURED, &il->status) << S_GEO_CONFIGURED |
2272 test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
2276 /* ...otherwise clear out all the status bits but the RF Kill
2277 * bit and continue taking the NIC down. */
2279 test_bit(S_RFKILL, &il->status) << S_RFKILL |
2280 test_bit(S_GEO_CONFIGURED, &il->status) << S_GEO_CONFIGURED |
2281 test_bit(S_FW_ERROR, &il->status) << S_FW_ERROR |
2282 test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
2285 * We disabled and synchronized interrupt, and priv->mutex is taken, so
2286 * here is the only thread which will program device registers, but
2287 * still have lockdep assertions, so we are taking reg_lock.
2289 spin_lock_irq(&il->reg_lock);
2290 /* FIXME: il_grab_nic_access if rfkill is off ? */
2292 il3945_hw_txq_ctx_stop(il);
2293 il3945_hw_rxq_stop(il);
2294 /* Power-down device's busmaster DMA clocks */
2295 _il_wr_prph(il, APMG_CLK_DIS_REG, APMG_CLK_VAL_DMA_CLK_RQT);
2297 /* Stop the device, and put it in low power state */
2300 spin_unlock_irq(&il->reg_lock);
2302 il3945_hw_txq_ctx_free(il);
2304 memset(&il->card_alive, 0, sizeof(struct il_alive_resp));
2307 dev_kfree_skb(il->beacon_skb);
2308 il->beacon_skb = NULL;
2310 /* clear out any free frames */
2311 il3945_clear_free_frames(il);
2315 il3945_down(struct il_priv *il)
2317 mutex_lock(&il->mutex);
2319 mutex_unlock(&il->mutex);
2321 il3945_cancel_deferred_work(il);
2324 #define MAX_HW_RESTARTS 5
2327 il3945_alloc_bcast_station(struct il_priv *il)
2329 unsigned long flags;
2332 spin_lock_irqsave(&il->sta_lock, flags);
2333 sta_id = il_prep_station(il, il_bcast_addr, false, NULL);
2334 if (sta_id == IL_INVALID_STATION) {
2335 IL_ERR("Unable to prepare broadcast station\n");
2336 spin_unlock_irqrestore(&il->sta_lock, flags);
2341 il->stations[sta_id].used |= IL_STA_DRIVER_ACTIVE;
2342 il->stations[sta_id].used |= IL_STA_BCAST;
2343 spin_unlock_irqrestore(&il->sta_lock, flags);
2349 __il3945_up(struct il_priv *il)
2353 rc = il3945_alloc_bcast_station(il);
2357 if (test_bit(S_EXIT_PENDING, &il->status)) {
2358 IL_WARN("Exit pending; will not bring the NIC up\n");
2362 if (!il->ucode_data_backup.v_addr || !il->ucode_data.v_addr) {
2363 IL_ERR("ucode not available for device bring up\n");
2367 /* If platform's RF_KILL switch is NOT set to KILL */
2368 if (_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
2369 clear_bit(S_RFKILL, &il->status);
2371 set_bit(S_RFKILL, &il->status);
2375 _il_wr(il, CSR_INT, 0xFFFFFFFF);
2377 rc = il3945_hw_nic_init(il);
2379 IL_ERR("Unable to int nic\n");
2383 /* make sure rfkill handshake bits are cleared */
2384 _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
2385 _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
2387 /* clear (again), then enable host interrupts */
2388 _il_wr(il, CSR_INT, 0xFFFFFFFF);
2389 il_enable_interrupts(il);
2391 /* really make sure rfkill handshake bits are cleared */
2392 _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
2393 _il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
2395 /* Copy original ucode data image from disk into backup cache.
2396 * This will be used to initialize the on-board processor's
2397 * data SRAM for a clean start when the runtime program first loads. */
2398 memcpy(il->ucode_data_backup.v_addr, il->ucode_data.v_addr,
2399 il->ucode_data.len);
2401 /* We return success when we resume from suspend and rf_kill is on. */
2402 if (test_bit(S_RFKILL, &il->status))
2405 for (i = 0; i < MAX_HW_RESTARTS; i++) {
2407 /* load bootstrap state machine,
2408 * load bootstrap program into processor's memory,
2409 * prepare to load the "initialize" uCode */
2410 rc = il->ops->load_ucode(il);
2413 IL_ERR("Unable to set up bootstrap uCode: %d\n", rc);
2417 /* start card; "initialize" will load runtime ucode */
2418 il3945_nic_start(il);
2420 D_INFO(DRV_NAME " is coming up\n");
2425 set_bit(S_EXIT_PENDING, &il->status);
2427 clear_bit(S_EXIT_PENDING, &il->status);
2429 /* tried to restart and config the device for as long as our
2430 * patience could withstand */
2431 IL_ERR("Unable to initialize device after %d attempts.\n", i);
2435 /*****************************************************************************
2437 * Workqueue callbacks
2439 *****************************************************************************/
2442 il3945_bg_init_alive_start(struct work_struct *data)
2444 struct il_priv *il =
2445 container_of(data, struct il_priv, init_alive_start.work);
2447 mutex_lock(&il->mutex);
2448 if (test_bit(S_EXIT_PENDING, &il->status))
2451 il3945_init_alive_start(il);
2453 mutex_unlock(&il->mutex);
2457 il3945_bg_alive_start(struct work_struct *data)
2459 struct il_priv *il =
2460 container_of(data, struct il_priv, alive_start.work);
2462 mutex_lock(&il->mutex);
2463 if (test_bit(S_EXIT_PENDING, &il->status) || il->txq == NULL)
2466 il3945_alive_start(il);
2468 mutex_unlock(&il->mutex);
2472 * 3945 cannot interrupt driver when hardware rf kill switch toggles;
2473 * driver must poll CSR_GP_CNTRL_REG register for change. This register
2474 * *is* readable even when device has been SW_RESET into low power mode
2475 * (e.g. during RF KILL).
2478 il3945_rfkill_poll(struct work_struct *data)
2480 struct il_priv *il =
2481 container_of(data, struct il_priv, _3945.rfkill_poll.work);
2482 bool old_rfkill = test_bit(S_RFKILL, &il->status);
2484 !(_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW);
2486 if (new_rfkill != old_rfkill) {
2488 set_bit(S_RFKILL, &il->status);
2490 clear_bit(S_RFKILL, &il->status);
2492 wiphy_rfkill_set_hw_state(il->hw->wiphy, new_rfkill);
2494 D_RF_KILL("RF_KILL bit toggled to %s.\n",
2495 new_rfkill ? "disable radio" : "enable radio");
2498 /* Keep this running, even if radio now enabled. This will be
2499 * cancelled in mac_start() if system decides to start again */
2500 queue_delayed_work(il->workqueue, &il->_3945.rfkill_poll,
2501 round_jiffies_relative(2 * HZ));
2506 il3945_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
2508 struct il_host_cmd cmd = {
2510 .len = sizeof(struct il3945_scan_cmd),
2511 .flags = CMD_SIZE_HUGE,
2513 struct il3945_scan_cmd *scan;
2515 enum nl80211_band band;
2516 bool is_active = false;
2520 lockdep_assert_held(&il->mutex);
2522 if (!il->scan_cmd) {
2524 kmalloc(sizeof(struct il3945_scan_cmd) + IL_MAX_SCAN_SIZE,
2526 if (!il->scan_cmd) {
2527 D_SCAN("Fail to allocate scan memory\n");
2531 scan = il->scan_cmd;
2532 memset(scan, 0, sizeof(struct il3945_scan_cmd) + IL_MAX_SCAN_SIZE);
2534 scan->quiet_plcp_th = IL_PLCP_QUIET_THRESH;
2535 scan->quiet_time = IL_ACTIVE_QUIET_TIME;
2537 if (il_is_associated(il)) {
2540 u32 suspend_time = 100;
2541 u32 scan_suspend_time = 100;
2543 D_INFO("Scanning while associated...\n");
2545 interval = vif->bss_conf.beacon_int;
2547 scan->suspend_time = 0;
2548 scan->max_out_time = cpu_to_le32(200 * 1024);
2550 interval = suspend_time;
2552 * suspend time format:
2553 * 0-19: beacon interval in usec (time before exec.)
2555 * 24-31: number of beacons (suspend between channels)
2558 extra = (suspend_time / interval) << 24;
2560 0xFF0FFFFF & (extra | ((suspend_time % interval) * 1024));
2562 scan->suspend_time = cpu_to_le32(scan_suspend_time);
2563 D_SCAN("suspend_time 0x%X beacon interval %d\n",
2564 scan_suspend_time, interval);
2567 if (il->scan_request->n_ssids) {
2569 D_SCAN("Kicking off active scan\n");
2570 for (i = 0; i < il->scan_request->n_ssids; i++) {
2571 /* always does wildcard anyway */
2572 if (!il->scan_request->ssids[i].ssid_len)
2574 scan->direct_scan[p].id = WLAN_EID_SSID;
2575 scan->direct_scan[p].len =
2576 il->scan_request->ssids[i].ssid_len;
2577 memcpy(scan->direct_scan[p].ssid,
2578 il->scan_request->ssids[i].ssid,
2579 il->scan_request->ssids[i].ssid_len);
2585 D_SCAN("Kicking off passive scan.\n");
2587 /* We don't build a direct scan probe request; the uCode will do
2588 * that based on the direct_mask added to each channel entry */
2589 scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK;
2590 scan->tx_cmd.sta_id = il->hw_params.bcast_id;
2591 scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
2593 /* flags + rate selection */
2595 switch (il->scan_band) {
2596 case NL80211_BAND_2GHZ:
2597 scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK;
2598 scan->tx_cmd.rate = RATE_1M_PLCP;
2599 band = NL80211_BAND_2GHZ;
2601 case NL80211_BAND_5GHZ:
2602 scan->tx_cmd.rate = RATE_6M_PLCP;
2603 band = NL80211_BAND_5GHZ;
2606 IL_WARN("Invalid scan band\n");
2611 * If active scaning is requested but a certain channel is marked
2612 * passive, we can do active scanning if we detect transmissions. For
2613 * passive only scanning disable switching to active on any channel.
2616 is_active ? IL_GOOD_CRC_TH_DEFAULT : IL_GOOD_CRC_TH_NEVER;
2619 il_fill_probe_req(il, (struct ieee80211_mgmt *)scan->data,
2620 vif->addr, il->scan_request->ie,
2621 il->scan_request->ie_len,
2622 IL_MAX_SCAN_SIZE - sizeof(*scan));
2623 scan->tx_cmd.len = cpu_to_le16(len);
2625 /* select Rx antennas */
2626 scan->flags |= il3945_get_antenna_flags(il);
2628 scan->channel_count =
2629 il3945_get_channels_for_scan(il, band, is_active, n_probes,
2630 (void *)&scan->data[len], vif);
2631 if (scan->channel_count == 0) {
2632 D_SCAN("channel count %d\n", scan->channel_count);
2637 le16_to_cpu(scan->tx_cmd.len) +
2638 scan->channel_count * sizeof(struct il3945_scan_channel);
2640 scan->len = cpu_to_le16(cmd.len);
2642 set_bit(S_SCAN_HW, &il->status);
2643 ret = il_send_cmd_sync(il, &cmd);
2645 clear_bit(S_SCAN_HW, &il->status);
2650 il3945_post_scan(struct il_priv *il)
2653 * Since setting the RXON may have been deferred while
2654 * performing the scan, fire one off if needed
2656 if (memcmp(&il->staging, &il->active, sizeof(il->staging)))
2657 il3945_commit_rxon(il);
2661 il3945_bg_restart(struct work_struct *data)
2663 struct il_priv *il = container_of(data, struct il_priv, restart);
2665 if (test_bit(S_EXIT_PENDING, &il->status))
2668 if (test_and_clear_bit(S_FW_ERROR, &il->status)) {
2669 mutex_lock(&il->mutex);
2671 mutex_unlock(&il->mutex);
2673 ieee80211_restart_hw(il->hw);
2677 mutex_lock(&il->mutex);
2678 if (test_bit(S_EXIT_PENDING, &il->status)) {
2679 mutex_unlock(&il->mutex);
2684 mutex_unlock(&il->mutex);
2689 il3945_bg_rx_replenish(struct work_struct *data)
2691 struct il_priv *il = container_of(data, struct il_priv, rx_replenish);
2693 mutex_lock(&il->mutex);
2694 if (test_bit(S_EXIT_PENDING, &il->status))
2697 il3945_rx_replenish(il);
2699 mutex_unlock(&il->mutex);
2703 il3945_post_associate(struct il_priv *il)
2707 if (!il->vif || !il->is_open)
2710 D_ASSOC("Associated as %d to: %pM\n", il->vif->bss_conf.aid,
2711 il->active.bssid_addr);
2713 if (test_bit(S_EXIT_PENDING, &il->status))
2716 il_scan_cancel_timeout(il, 200);
2718 il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
2719 il3945_commit_rxon(il);
2721 rc = il_send_rxon_timing(il);
2723 IL_WARN("C_RXON_TIMING failed - " "Attempting to continue.\n");
2725 il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
2727 il->staging.assoc_id = cpu_to_le16(il->vif->bss_conf.aid);
2729 D_ASSOC("assoc id %d beacon interval %d\n", il->vif->bss_conf.aid,
2730 il->vif->bss_conf.beacon_int);
2732 if (il->vif->bss_conf.use_short_preamble)
2733 il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
2735 il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
2737 if (il->staging.flags & RXON_FLG_BAND_24G_MSK) {
2738 if (il->vif->bss_conf.use_short_slot)
2739 il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
2741 il->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
2744 il3945_commit_rxon(il);
2746 switch (il->vif->type) {
2747 case NL80211_IFTYPE_STATION:
2748 il3945_rate_scale_init(il->hw, IL_AP_ID);
2750 case NL80211_IFTYPE_ADHOC:
2751 il3945_send_beacon_cmd(il);
2754 IL_ERR("%s Should not be called in %d mode\n", __func__,
2760 /*****************************************************************************
2762 * mac80211 entry point functions
2764 *****************************************************************************/
2766 #define UCODE_READY_TIMEOUT (2 * HZ)
2769 il3945_mac_start(struct ieee80211_hw *hw)
2771 struct il_priv *il = hw->priv;
2774 /* we should be verifying the device is ready to be opened */
2775 mutex_lock(&il->mutex);
2776 D_MAC80211("enter\n");
2778 /* fetch ucode file from disk, alloc and copy to bus-master buffers ...
2779 * ucode filename and max sizes are card-specific. */
2781 if (!il->ucode_code.len) {
2782 ret = il3945_read_ucode(il);
2784 IL_ERR("Could not read microcode: %d\n", ret);
2785 mutex_unlock(&il->mutex);
2786 goto out_release_irq;
2790 ret = __il3945_up(il);
2792 mutex_unlock(&il->mutex);
2795 goto out_release_irq;
2797 D_INFO("Start UP work.\n");
2799 /* Wait for START_ALIVE from ucode. Otherwise callbacks from
2800 * mac80211 will not be run successfully. */
2801 ret = wait_event_timeout(il->wait_command_queue,
2802 test_bit(S_READY, &il->status),
2803 UCODE_READY_TIMEOUT);
2805 if (!test_bit(S_READY, &il->status)) {
2806 IL_ERR("Wait for START_ALIVE timeout after %dms.\n",
2807 jiffies_to_msecs(UCODE_READY_TIMEOUT));
2809 goto out_release_irq;
2813 /* ucode is running and will send rfkill notifications,
2814 * no need to poll the killswitch state anymore */
2815 cancel_delayed_work(&il->_3945.rfkill_poll);
2818 D_MAC80211("leave\n");
2823 D_MAC80211("leave - failed\n");
2828 il3945_mac_stop(struct ieee80211_hw *hw)
2830 struct il_priv *il = hw->priv;
2832 D_MAC80211("enter\n");
2835 D_MAC80211("leave - skip\n");
2843 flush_workqueue(il->workqueue);
2845 /* start polling the killswitch state again */
2846 queue_delayed_work(il->workqueue, &il->_3945.rfkill_poll,
2847 round_jiffies_relative(2 * HZ));
2849 D_MAC80211("leave\n");
2853 il3945_mac_tx(struct ieee80211_hw *hw,
2854 struct ieee80211_tx_control *control,
2855 struct sk_buff *skb)
2857 struct il_priv *il = hw->priv;
2859 D_MAC80211("enter\n");
2861 D_TX("dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
2862 ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
2864 if (il3945_tx_skb(il, control->sta, skb))
2865 dev_kfree_skb_any(skb);
2867 D_MAC80211("leave\n");
2871 il3945_config_ap(struct il_priv *il)
2873 struct ieee80211_vif *vif = il->vif;
2876 if (test_bit(S_EXIT_PENDING, &il->status))
2879 /* The following should be done only at AP bring up */
2880 if (!(il_is_associated(il))) {
2882 /* RXON - unassoc (to set timing command) */
2883 il->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
2884 il3945_commit_rxon(il);
2887 rc = il_send_rxon_timing(il);
2889 IL_WARN("C_RXON_TIMING failed - "
2890 "Attempting to continue.\n");
2892 il->staging.assoc_id = 0;
2894 if (vif->bss_conf.use_short_preamble)
2895 il->staging.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
2897 il->staging.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
2899 if (il->staging.flags & RXON_FLG_BAND_24G_MSK) {
2900 if (vif->bss_conf.use_short_slot)
2901 il->staging.flags |= RXON_FLG_SHORT_SLOT_MSK;
2903 il->staging.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
2905 /* restore RXON assoc */
2906 il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
2907 il3945_commit_rxon(il);
2909 il3945_send_beacon_cmd(il);
2913 il3945_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2914 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
2915 struct ieee80211_key_conf *key)
2917 struct il_priv *il = hw->priv;
2919 u8 sta_id = IL_INVALID_STATION;
2922 D_MAC80211("enter\n");
2924 if (il3945_mod_params.sw_crypto) {
2925 D_MAC80211("leave - hwcrypto disabled\n");
2930 * To support IBSS RSN, don't program group keys in IBSS, the
2931 * hardware will then not attempt to decrypt the frames.
2933 if (vif->type == NL80211_IFTYPE_ADHOC &&
2934 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
2935 D_MAC80211("leave - IBSS RSN\n");
2939 static_key = !il_is_associated(il);
2942 sta_id = il_sta_id_or_broadcast(il, sta);
2943 if (sta_id == IL_INVALID_STATION) {
2944 D_MAC80211("leave - station not found\n");
2949 mutex_lock(&il->mutex);
2950 il_scan_cancel_timeout(il, 100);
2955 ret = il3945_set_static_key(il, key);
2957 ret = il3945_set_dynamic_key(il, key, sta_id);
2958 D_MAC80211("enable hwcrypto key\n");
2962 ret = il3945_remove_static_key(il);
2964 ret = il3945_clear_sta_key_info(il, sta_id);
2965 D_MAC80211("disable hwcrypto key\n");
2971 D_MAC80211("leave ret %d\n", ret);
2972 mutex_unlock(&il->mutex);
2978 il3945_mac_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2979 struct ieee80211_sta *sta)
2981 struct il_priv *il = hw->priv;
2982 struct il3945_sta_priv *sta_priv = (void *)sta->drv_priv;
2984 bool is_ap = vif->type == NL80211_IFTYPE_STATION;
2987 mutex_lock(&il->mutex);
2988 D_INFO("station %pM\n", sta->addr);
2989 sta_priv->common.sta_id = IL_INVALID_STATION;
2991 ret = il_add_station_common(il, sta->addr, is_ap, sta, &sta_id);
2993 IL_ERR("Unable to add station %pM (%d)\n", sta->addr, ret);
2994 /* Should we return success if return code is EEXIST ? */
2995 mutex_unlock(&il->mutex);
2999 sta_priv->common.sta_id = sta_id;
3001 /* Initialize rate scaling */
3002 D_INFO("Initializing rate scaling for station %pM\n", sta->addr);
3003 il3945_rs_rate_init(il, sta, sta_id);
3004 mutex_unlock(&il->mutex);
3010 il3945_configure_filter(struct ieee80211_hw *hw, unsigned int changed_flags,
3011 unsigned int *total_flags, u64 multicast)
3013 struct il_priv *il = hw->priv;
3014 __le32 filter_or = 0, filter_nand = 0;
3016 #define CHK(test, flag) do { \
3017 if (*total_flags & (test)) \
3018 filter_or |= (flag); \
3020 filter_nand |= (flag); \
3023 D_MAC80211("Enter: changed: 0x%x, total: 0x%x\n", changed_flags,
3026 CHK(FIF_OTHER_BSS, RXON_FILTER_PROMISC_MSK);
3027 CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK);
3028 CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
3032 mutex_lock(&il->mutex);
3034 il->staging.filter_flags &= ~filter_nand;
3035 il->staging.filter_flags |= filter_or;
3038 * Not committing directly because hardware can perform a scan,
3039 * but even if hw is ready, committing here breaks for some reason,
3040 * we'll eventually commit the filter flags change anyway.
3043 mutex_unlock(&il->mutex);
3046 * Receiving all multicast frames is always enabled by the
3047 * default flags setup in il_connection_init_rx_config()
3048 * since we currently do not support programming multicast
3049 * filters into the device.
3052 FIF_OTHER_BSS | FIF_ALLMULTI |
3053 FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
3056 /*****************************************************************************
3060 *****************************************************************************/
3062 #ifdef CONFIG_IWLEGACY_DEBUG
3065 * The following adds a new attribute to the sysfs representation
3066 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/iwl/)
3067 * used for controlling the debug level.
3069 * See the level definitions in iwl for details.
3071 * The debug_level being managed using sysfs below is a per device debug
3072 * level that is used instead of the global debug level if it (the per
3073 * device debug level) is set.
3076 il3945_show_debug_level(struct device *d, struct device_attribute *attr,
3079 struct il_priv *il = dev_get_drvdata(d);
3080 return sprintf(buf, "0x%08X\n", il_get_debug_level(il));
3084 il3945_store_debug_level(struct device *d, struct device_attribute *attr,
3085 const char *buf, size_t count)
3087 struct il_priv *il = dev_get_drvdata(d);
3091 ret = kstrtoul(buf, 0, &val);
3093 IL_INFO("%s is not in hex or decimal form.\n", buf);
3095 il->debug_level = val;
3097 return strnlen(buf, count);
3100 static DEVICE_ATTR(debug_level, 0644, il3945_show_debug_level,
3101 il3945_store_debug_level);
3103 #endif /* CONFIG_IWLEGACY_DEBUG */
3106 il3945_show_temperature(struct device *d, struct device_attribute *attr,
3109 struct il_priv *il = dev_get_drvdata(d);
3111 if (!il_is_alive(il))
3114 return sprintf(buf, "%d\n", il3945_hw_get_temperature(il));
3117 static DEVICE_ATTR(temperature, 0444, il3945_show_temperature, NULL);
3120 il3945_show_tx_power(struct device *d, struct device_attribute *attr, char *buf)
3122 struct il_priv *il = dev_get_drvdata(d);
3123 return sprintf(buf, "%d\n", il->tx_power_user_lmt);
3127 il3945_store_tx_power(struct device *d, struct device_attribute *attr,
3128 const char *buf, size_t count)
3130 struct il_priv *il = dev_get_drvdata(d);
3131 char *p = (char *)buf;
3134 val = simple_strtoul(p, &p, 10);
3136 IL_INFO(": %s is not in decimal form.\n", buf);
3138 il3945_hw_reg_set_txpower(il, val);
3143 static DEVICE_ATTR(tx_power, 0644, il3945_show_tx_power, il3945_store_tx_power);
3146 il3945_show_flags(struct device *d, struct device_attribute *attr, char *buf)
3148 struct il_priv *il = dev_get_drvdata(d);
3150 return sprintf(buf, "0x%04X\n", il->active.flags);
3154 il3945_store_flags(struct device *d, struct device_attribute *attr,
3155 const char *buf, size_t count)
3157 struct il_priv *il = dev_get_drvdata(d);
3158 u32 flags = simple_strtoul(buf, NULL, 0);
3160 mutex_lock(&il->mutex);
3161 if (le32_to_cpu(il->staging.flags) != flags) {
3162 /* Cancel any currently running scans... */
3163 if (il_scan_cancel_timeout(il, 100))
3164 IL_WARN("Could not cancel scan.\n");
3166 D_INFO("Committing rxon.flags = 0x%04X\n", flags);
3167 il->staging.flags = cpu_to_le32(flags);
3168 il3945_commit_rxon(il);
3171 mutex_unlock(&il->mutex);
3176 static DEVICE_ATTR(flags, 0644, il3945_show_flags, il3945_store_flags);
3179 il3945_show_filter_flags(struct device *d, struct device_attribute *attr,
3182 struct il_priv *il = dev_get_drvdata(d);
3184 return sprintf(buf, "0x%04X\n", le32_to_cpu(il->active.filter_flags));
3188 il3945_store_filter_flags(struct device *d, struct device_attribute *attr,
3189 const char *buf, size_t count)
3191 struct il_priv *il = dev_get_drvdata(d);
3192 u32 filter_flags = simple_strtoul(buf, NULL, 0);
3194 mutex_lock(&il->mutex);
3195 if (le32_to_cpu(il->staging.filter_flags) != filter_flags) {
3196 /* Cancel any currently running scans... */
3197 if (il_scan_cancel_timeout(il, 100))
3198 IL_WARN("Could not cancel scan.\n");
3200 D_INFO("Committing rxon.filter_flags = " "0x%04X\n",
3202 il->staging.filter_flags = cpu_to_le32(filter_flags);
3203 il3945_commit_rxon(il);
3206 mutex_unlock(&il->mutex);
3211 static DEVICE_ATTR(filter_flags, 0644, il3945_show_filter_flags,
3212 il3945_store_filter_flags);
3215 il3945_show_measurement(struct device *d, struct device_attribute *attr,
3218 struct il_priv *il = dev_get_drvdata(d);
3219 struct il_spectrum_notification measure_report;
3220 u32 size = sizeof(measure_report), len = 0, ofs = 0;
3221 u8 *data = (u8 *) &measure_report;
3222 unsigned long flags;
3224 spin_lock_irqsave(&il->lock, flags);
3225 if (!(il->measurement_status & MEASUREMENT_READY)) {
3226 spin_unlock_irqrestore(&il->lock, flags);
3229 memcpy(&measure_report, &il->measure_report, size);
3230 il->measurement_status = 0;
3231 spin_unlock_irqrestore(&il->lock, flags);
3233 while (size && PAGE_SIZE - len) {
3234 hex_dump_to_buffer(data + ofs, size, 16, 1, buf + len,
3235 PAGE_SIZE - len, true);
3237 if (PAGE_SIZE - len)
3241 size -= min(size, 16U);
3248 il3945_store_measurement(struct device *d, struct device_attribute *attr,
3249 const char *buf, size_t count)
3251 struct il_priv *il = dev_get_drvdata(d);
3252 struct ieee80211_measurement_params params = {
3253 .channel = le16_to_cpu(il->active.channel),
3254 .start_time = cpu_to_le64(il->_3945.last_tsf),
3255 .duration = cpu_to_le16(1),
3257 u8 type = IL_MEASURE_BASIC;
3263 strlcpy(buffer, buf, sizeof(buffer));
3264 channel = simple_strtoul(p, NULL, 0);
3266 params.channel = channel;
3269 while (*p && *p != ' ')
3272 type = simple_strtoul(p + 1, NULL, 0);
3275 D_INFO("Invoking measurement of type %d on " "channel %d (for '%s')\n",
3276 type, params.channel, buf);
3277 il3945_get_measurement(il, ¶ms, type);
3282 static DEVICE_ATTR(measurement, 0600, il3945_show_measurement,
3283 il3945_store_measurement);
3286 il3945_store_retry_rate(struct device *d, struct device_attribute *attr,
3287 const char *buf, size_t count)
3289 struct il_priv *il = dev_get_drvdata(d);
3291 il->retry_rate = simple_strtoul(buf, NULL, 0);
3292 if (il->retry_rate <= 0)
3299 il3945_show_retry_rate(struct device *d, struct device_attribute *attr,
3302 struct il_priv *il = dev_get_drvdata(d);
3303 return sprintf(buf, "%d", il->retry_rate);
3306 static DEVICE_ATTR(retry_rate, 0600, il3945_show_retry_rate,
3307 il3945_store_retry_rate);
3310 il3945_show_channels(struct device *d, struct device_attribute *attr, char *buf)
3312 /* all this shit doesn't belong into sysfs anyway */
3316 static DEVICE_ATTR(channels, 0400, il3945_show_channels, NULL);
3319 il3945_show_antenna(struct device *d, struct device_attribute *attr, char *buf)
3321 struct il_priv *il = dev_get_drvdata(d);
3323 if (!il_is_alive(il))
3326 return sprintf(buf, "%d\n", il3945_mod_params.antenna);
3330 il3945_store_antenna(struct device *d, struct device_attribute *attr,
3331 const char *buf, size_t count)
3333 struct il_priv *il __maybe_unused = dev_get_drvdata(d);
3339 if (sscanf(buf, "%1i", &ant) != 1) {
3340 D_INFO("not in hex or decimal form.\n");
3344 if (ant >= 0 && ant <= 2) {
3345 D_INFO("Setting antenna select to %d.\n", ant);
3346 il3945_mod_params.antenna = (enum il3945_antenna)ant;
3348 D_INFO("Bad antenna select value %d.\n", ant);
3353 static DEVICE_ATTR(antenna, 0644, il3945_show_antenna, il3945_store_antenna);
3356 il3945_show_status(struct device *d, struct device_attribute *attr, char *buf)
3358 struct il_priv *il = dev_get_drvdata(d);
3359 if (!il_is_alive(il))
3361 return sprintf(buf, "0x%08x\n", (int)il->status);
3364 static DEVICE_ATTR(status, 0444, il3945_show_status, NULL);
3367 il3945_dump_error_log(struct device *d, struct device_attribute *attr,
3368 const char *buf, size_t count)
3370 struct il_priv *il = dev_get_drvdata(d);
3371 char *p = (char *)buf;
3374 il3945_dump_nic_error_log(il);
3376 return strnlen(buf, count);
3379 static DEVICE_ATTR(dump_errors, 0200, NULL, il3945_dump_error_log);
3381 /*****************************************************************************
3383 * driver setup and tear down
3385 *****************************************************************************/
3388 il3945_setup_deferred_work(struct il_priv *il)
3390 il->workqueue = create_singlethread_workqueue(DRV_NAME);
3392 init_waitqueue_head(&il->wait_command_queue);
3394 INIT_WORK(&il->restart, il3945_bg_restart);
3395 INIT_WORK(&il->rx_replenish, il3945_bg_rx_replenish);
3396 INIT_DELAYED_WORK(&il->init_alive_start, il3945_bg_init_alive_start);
3397 INIT_DELAYED_WORK(&il->alive_start, il3945_bg_alive_start);
3398 INIT_DELAYED_WORK(&il->_3945.rfkill_poll, il3945_rfkill_poll);
3400 il_setup_scan_deferred_work(il);
3402 il3945_hw_setup_deferred_work(il);
3404 timer_setup(&il->watchdog, il_bg_watchdog, 0);
3406 tasklet_init(&il->irq_tasklet,
3412 il3945_cancel_deferred_work(struct il_priv *il)
3414 il3945_hw_cancel_deferred_work(il);
3416 cancel_delayed_work_sync(&il->init_alive_start);
3417 cancel_delayed_work(&il->alive_start);
3419 il_cancel_scan_deferred_work(il);
3422 static struct attribute *il3945_sysfs_entries[] = {
3423 &dev_attr_antenna.attr,
3424 &dev_attr_channels.attr,
3425 &dev_attr_dump_errors.attr,
3426 &dev_attr_flags.attr,
3427 &dev_attr_filter_flags.attr,
3428 &dev_attr_measurement.attr,
3429 &dev_attr_retry_rate.attr,
3430 &dev_attr_status.attr,
3431 &dev_attr_temperature.attr,
3432 &dev_attr_tx_power.attr,
3433 #ifdef CONFIG_IWLEGACY_DEBUG
3434 &dev_attr_debug_level.attr,
3439 static const struct attribute_group il3945_attribute_group = {
3440 .name = NULL, /* put in device directory */
3441 .attrs = il3945_sysfs_entries,
3444 static struct ieee80211_ops il3945_mac_ops __ro_after_init = {
3445 .tx = il3945_mac_tx,
3446 .start = il3945_mac_start,
3447 .stop = il3945_mac_stop,
3448 .add_interface = il_mac_add_interface,
3449 .remove_interface = il_mac_remove_interface,
3450 .change_interface = il_mac_change_interface,
3451 .config = il_mac_config,
3452 .configure_filter = il3945_configure_filter,
3453 .set_key = il3945_mac_set_key,
3454 .conf_tx = il_mac_conf_tx,
3455 .reset_tsf = il_mac_reset_tsf,
3456 .bss_info_changed = il_mac_bss_info_changed,
3457 .hw_scan = il_mac_hw_scan,
3458 .sta_add = il3945_mac_sta_add,
3459 .sta_remove = il_mac_sta_remove,
3460 .tx_last_beacon = il_mac_tx_last_beacon,
3461 .flush = il_mac_flush,
3465 il3945_init_drv(struct il_priv *il)
3468 struct il3945_eeprom *eeprom = (struct il3945_eeprom *)il->eeprom;
3471 il->beacon_skb = NULL;
3473 spin_lock_init(&il->sta_lock);
3474 spin_lock_init(&il->hcmd_lock);
3476 INIT_LIST_HEAD(&il->free_frames);
3478 mutex_init(&il->mutex);
3480 il->ieee_channels = NULL;
3481 il->ieee_rates = NULL;
3482 il->band = NL80211_BAND_2GHZ;
3484 il->iw_mode = NL80211_IFTYPE_STATION;
3485 il->missed_beacon_threshold = IL_MISSED_BEACON_THRESHOLD_DEF;
3487 /* initialize force reset */
3488 il->force_reset.reset_duration = IL_DELAY_NEXT_FORCE_FW_RELOAD;
3490 if (eeprom->version < EEPROM_3945_EEPROM_VERSION) {
3491 IL_WARN("Unsupported EEPROM version: 0x%04X\n",
3496 ret = il_init_channel_map(il);
3498 IL_ERR("initializing regulatory failed: %d\n", ret);
3502 /* Set up txpower settings in driver for all channels */
3503 if (il3945_txpower_set_from_eeprom(il)) {
3505 goto err_free_channel_map;
3508 ret = il_init_geos(il);
3510 IL_ERR("initializing geos failed: %d\n", ret);
3511 goto err_free_channel_map;
3513 il3945_init_hw_rates(il, il->ieee_rates);
3517 err_free_channel_map:
3518 il_free_channel_map(il);
3523 #define IL3945_MAX_PROBE_REQUEST 200
3526 il3945_setup_mac(struct il_priv *il)
3529 struct ieee80211_hw *hw = il->hw;
3531 hw->rate_control_algorithm = "iwl-3945-rs";
3532 hw->sta_data_size = sizeof(struct il3945_sta_priv);
3533 hw->vif_data_size = sizeof(struct il_vif_priv);
3535 /* Tell mac80211 our characteristics */
3536 ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
3537 ieee80211_hw_set(hw, SUPPORTS_PS);
3538 ieee80211_hw_set(hw, SIGNAL_DBM);
3539 ieee80211_hw_set(hw, SPECTRUM_MGMT);
3541 hw->wiphy->interface_modes =
3542 BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
3544 hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
3545 hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG |
3546 REGULATORY_DISABLE_BEACON_HINTS;
3548 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
3550 hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX_3945;
3551 /* we create the 802.11 header and a zero-length SSID element */
3552 hw->wiphy->max_scan_ie_len = IL3945_MAX_PROBE_REQUEST - 24 - 2;
3554 /* Default value; 4 EDCA QOS priorities */
3557 if (il->bands[NL80211_BAND_2GHZ].n_channels)
3558 il->hw->wiphy->bands[NL80211_BAND_2GHZ] =
3559 &il->bands[NL80211_BAND_2GHZ];
3561 if (il->bands[NL80211_BAND_5GHZ].n_channels)
3562 il->hw->wiphy->bands[NL80211_BAND_5GHZ] =
3563 &il->bands[NL80211_BAND_5GHZ];
3567 wiphy_ext_feature_set(il->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
3569 ret = ieee80211_register_hw(il->hw);
3571 IL_ERR("Failed to register hw (error %d)\n", ret);
3574 il->mac80211_registered = 1;
3580 il3945_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
3584 struct ieee80211_hw *hw;
3585 struct il_cfg *cfg = (struct il_cfg *)(ent->driver_data);
3586 struct il3945_eeprom *eeprom;
3587 unsigned long flags;
3589 /***********************
3590 * 1. Allocating HW data
3591 * ********************/
3593 hw = ieee80211_alloc_hw(sizeof(struct il_priv), &il3945_mac_ops);
3600 SET_IEEE80211_DEV(hw, &pdev->dev);
3602 il->cmd_queue = IL39_CMD_QUEUE_NUM;
3604 D_INFO("*** LOAD DRIVER ***\n");
3606 il->ops = &il3945_ops;
3607 #ifdef CONFIG_IWLEGACY_DEBUGFS
3608 il->debugfs_ops = &il3945_debugfs_ops;
3611 il->inta_mask = CSR_INI_SET_MASK;
3613 /***************************
3614 * 2. Initializing PCI bus
3615 * *************************/
3616 pci_disable_link_state(pdev,
3617 PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1 |
3618 PCIE_LINK_STATE_CLKPM);
3620 if (pci_enable_device(pdev)) {
3622 goto out_ieee80211_free_hw;
3625 pci_set_master(pdev);
3627 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
3629 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
3631 IL_WARN("No suitable DMA available.\n");
3632 goto out_pci_disable_device;
3635 pci_set_drvdata(pdev, il);
3636 err = pci_request_regions(pdev, DRV_NAME);
3638 goto out_pci_disable_device;
3640 /***********************
3641 * 3. Read REV Register
3642 * ********************/
3643 il->hw_base = pci_ioremap_bar(pdev, 0);
3646 goto out_pci_release_regions;
3649 D_INFO("pci_resource_len = 0x%08llx\n",
3650 (unsigned long long)pci_resource_len(pdev, 0));
3651 D_INFO("pci_resource_base = %p\n", il->hw_base);
3653 /* We disable the RETRY_TIMEOUT register (0x41) to keep
3654 * PCI Tx retries from interfering with C3 CPU state */
3655 pci_write_config_byte(pdev, 0x41, 0x00);
3657 /* these spin locks will be used in apm_init and EEPROM access
3658 * we should init now
3660 spin_lock_init(&il->reg_lock);
3661 spin_lock_init(&il->lock);
3664 * stop and reset the on-board processor just in case it is in a
3665 * strange state ... like being left stranded by a primary kernel
3666 * and this is now the kdump kernel trying to start up
3668 _il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
3670 /***********************
3672 * ********************/
3674 /* Read the EEPROM */
3675 err = il_eeprom_init(il);
3677 IL_ERR("Unable to init EEPROM\n");
3680 /* MAC Address location in EEPROM same for 3945/4965 */
3681 eeprom = (struct il3945_eeprom *)il->eeprom;
3682 D_INFO("MAC address: %pM\n", eeprom->mac_address);
3683 SET_IEEE80211_PERM_ADDR(il->hw, eeprom->mac_address);
3685 /***********************
3686 * 5. Setup HW Constants
3687 * ********************/
3688 /* Device-specific setup */
3689 err = il3945_hw_set_hw_params(il);
3691 IL_ERR("failed to set hw settings\n");
3692 goto out_eeprom_free;
3695 /***********************
3697 * ********************/
3699 err = il3945_init_drv(il);
3701 IL_ERR("initializing driver failed\n");
3702 goto out_unset_hw_params;
3705 IL_INFO("Detected Intel Wireless WiFi Link %s\n", il->cfg->name);
3707 /***********************
3709 * ********************/
3711 spin_lock_irqsave(&il->lock, flags);
3712 il_disable_interrupts(il);
3713 spin_unlock_irqrestore(&il->lock, flags);
3715 pci_enable_msi(il->pci_dev);
3717 err = request_irq(il->pci_dev->irq, il_isr, IRQF_SHARED, DRV_NAME, il);
3719 IL_ERR("Error allocating IRQ %d\n", il->pci_dev->irq);
3720 goto out_disable_msi;
3723 err = sysfs_create_group(&pdev->dev.kobj, &il3945_attribute_group);
3725 IL_ERR("failed to create sysfs device attributes\n");
3726 goto out_release_irq;
3729 il_set_rxon_channel(il, &il->bands[NL80211_BAND_2GHZ].channels[5]);
3730 il3945_setup_deferred_work(il);
3731 il3945_setup_handlers(il);
3732 il_power_initialize(il);
3734 /*********************************
3735 * 8. Setup and Register mac80211
3736 * *******************************/
3738 il_enable_interrupts(il);
3740 err = il3945_setup_mac(il);
3742 goto out_remove_sysfs;
3744 il_dbgfs_register(il, DRV_NAME);
3746 /* Start monitoring the killswitch */
3747 queue_delayed_work(il->workqueue, &il->_3945.rfkill_poll, 2 * HZ);
3752 destroy_workqueue(il->workqueue);
3753 il->workqueue = NULL;
3754 sysfs_remove_group(&pdev->dev.kobj, &il3945_attribute_group);
3756 free_irq(il->pci_dev->irq, il);
3758 pci_disable_msi(il->pci_dev);
3760 il_free_channel_map(il);
3761 out_unset_hw_params:
3762 il3945_unset_hw_params(il);
3766 iounmap(il->hw_base);
3767 out_pci_release_regions:
3768 pci_release_regions(pdev);
3769 out_pci_disable_device:
3770 pci_disable_device(pdev);
3771 out_ieee80211_free_hw:
3772 ieee80211_free_hw(il->hw);
3778 il3945_pci_remove(struct pci_dev *pdev)
3780 struct il_priv *il = pci_get_drvdata(pdev);
3781 unsigned long flags;
3786 D_INFO("*** UNLOAD DRIVER ***\n");
3788 il_dbgfs_unregister(il);
3790 set_bit(S_EXIT_PENDING, &il->status);
3794 if (il->mac80211_registered) {
3795 ieee80211_unregister_hw(il->hw);
3796 il->mac80211_registered = 0;
3802 * Make sure device is reset to low power before unloading driver.
3803 * This may be redundant with il_down(), but there are paths to
3804 * run il_down() without calling apm_ops.stop(), and there are
3805 * paths to avoid running il_down() at all before leaving driver.
3806 * This (inexpensive) call *makes sure* device is reset.
3810 /* make sure we flush any pending irq or
3811 * tasklet for the driver
3813 spin_lock_irqsave(&il->lock, flags);
3814 il_disable_interrupts(il);
3815 spin_unlock_irqrestore(&il->lock, flags);
3817 il3945_synchronize_irq(il);
3819 sysfs_remove_group(&pdev->dev.kobj, &il3945_attribute_group);
3821 cancel_delayed_work_sync(&il->_3945.rfkill_poll);
3823 il3945_dealloc_ucode_pci(il);
3826 il3945_rx_queue_free(il, &il->rxq);
3827 il3945_hw_txq_ctx_free(il);
3829 il3945_unset_hw_params(il);
3831 /*netif_stop_queue(dev); */
3832 flush_workqueue(il->workqueue);
3834 /* ieee80211_unregister_hw calls il3945_mac_stop, which flushes
3835 * il->workqueue... so we can't take down the workqueue
3837 destroy_workqueue(il->workqueue);
3838 il->workqueue = NULL;
3840 free_irq(pdev->irq, il);
3841 pci_disable_msi(pdev);
3843 iounmap(il->hw_base);
3844 pci_release_regions(pdev);
3845 pci_disable_device(pdev);
3847 il_free_channel_map(il);
3849 kfree(il->scan_cmd);
3851 dev_kfree_skb(il->beacon_skb);
3853 ieee80211_free_hw(il->hw);
3856 /*****************************************************************************
3858 * driver and module entry point
3860 *****************************************************************************/
3862 static struct pci_driver il3945_driver = {
3864 .id_table = il3945_hw_card_ids,
3865 .probe = il3945_pci_probe,
3866 .remove = il3945_pci_remove,
3867 .driver.pm = IL_LEGACY_PM_OPS,
3875 pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
3876 pr_info(DRV_COPYRIGHT "\n");
3879 * Disabling hardware scan means that mac80211 will perform scans
3880 * "the hard way", rather than using device's scan.
3882 if (il3945_mod_params.disable_hw_scan) {
3883 pr_info("hw_scan is disabled\n");
3884 il3945_mac_ops.hw_scan = NULL;
3887 ret = il3945_rate_control_register();
3889 pr_err("Unable to register rate control algorithm: %d\n", ret);
3893 ret = pci_register_driver(&il3945_driver);
3895 pr_err("Unable to initialize PCI module\n");
3896 goto error_register;
3902 il3945_rate_control_unregister();
3909 pci_unregister_driver(&il3945_driver);
3910 il3945_rate_control_unregister();
3915 module_param_named(antenna, il3945_mod_params.antenna, int, 0444);
3916 MODULE_PARM_DESC(antenna, "select antenna (1=Main, 2=Aux, default 0 [both])");
3917 module_param_named(swcrypto, il3945_mod_params.sw_crypto, int, 0444);
3918 MODULE_PARM_DESC(swcrypto, "using software crypto (default 1 [software])");
3919 module_param_named(disable_hw_scan, il3945_mod_params.disable_hw_scan, int,
3921 MODULE_PARM_DESC(disable_hw_scan, "disable hardware scanning (default 1)");
3922 #ifdef CONFIG_IWLEGACY_DEBUG
3923 module_param_named(debug, il_debug_level, uint, 0644);
3924 MODULE_PARM_DESC(debug, "debug output mask");
3926 module_param_named(fw_restart, il3945_mod_params.restart_fw, int, 0444);
3927 MODULE_PARM_DESC(fw_restart, "restart firmware in case of error");
3929 module_exit(il3945_exit);
3930 module_init(il3945_init);