#include "common.h"
+int
+_il_poll_bit(struct il_priv *il, u32 addr, u32 bits, u32 mask, int timeout)
+{
+ const int interval = 10; /* microseconds */
+ int t = 0;
+
+ do {
+ if ((_il_rd(il, addr) & mask) == (bits & mask))
+ return t;
+ udelay(interval);
+ t += interval;
+ } while (t < timeout);
+
+ return -ETIMEDOUT;
+}
+EXPORT_SYMBOL(_il_poll_bit);
+
+void
+il_set_bit(struct il_priv *p, u32 r, u32 m)
+{
+ unsigned long reg_flags;
+
+ spin_lock_irqsave(&p->reg_lock, reg_flags);
+ _il_set_bit(p, r, m);
+ spin_unlock_irqrestore(&p->reg_lock, reg_flags);
+}
+EXPORT_SYMBOL(il_set_bit);
+
+void
+il_clear_bit(struct il_priv *p, u32 r, u32 m)
+{
+ unsigned long reg_flags;
+
+ spin_lock_irqsave(&p->reg_lock, reg_flags);
+ _il_clear_bit(p, r, m);
+ spin_unlock_irqrestore(&p->reg_lock, reg_flags);
+}
+EXPORT_SYMBOL(il_clear_bit);
+
+int
+_il_grab_nic_access(struct il_priv *il)
+{
+ int ret;
+ u32 val;
+
+ /* this bit wakes up the NIC */
+ _il_set_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
+
+ /*
+ * These bits say the device is running, and should keep running for
+ * at least a short while (at least as long as MAC_ACCESS_REQ stays 1),
+ * but they do not indicate that embedded SRAM is restored yet;
+ * 3945 and 4965 have volatile SRAM, and must save/restore contents
+ * to/from host DRAM when sleeping/waking for power-saving.
+ * Each direction takes approximately 1/4 millisecond; with this
+ * overhead, it's a good idea to grab and hold MAC_ACCESS_REQUEST if a
+ * series of register accesses are expected (e.g. reading Event Log),
+ * to keep device from sleeping.
+ *
+ * CSR_UCODE_DRV_GP1 register bit MAC_SLEEP == 0 indicates that
+ * SRAM is okay/restored. We don't check that here because this call
+ * is just for hardware register access; but GP1 MAC_SLEEP check is a
+ * good idea before accessing 3945/4965 SRAM (e.g. reading Event Log).
+ *
+ */
+ ret =
+ _il_poll_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN,
+ (CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY |
+ CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP), 15000);
+ if (ret < 0) {
+ val = _il_rd(il, CSR_GP_CNTRL);
+ IL_ERR("MAC is in deep sleep!. CSR_GP_CNTRL = 0x%08X\n", val);
+ _il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_FORCE_NMI);
+ return -EIO;
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(_il_grab_nic_access);
+
+int
+il_poll_bit(struct il_priv *il, u32 addr, u32 mask, int timeout)
+{
+ const int interval = 10; /* microseconds */
+ int t = 0;
+
+ do {
+ if ((il_rd(il, addr) & mask) == mask)
+ return t;
+ udelay(interval);
+ t += interval;
+ } while (t < timeout);
+
+ return -ETIMEDOUT;
+}
+EXPORT_SYMBOL(il_poll_bit);
+
+u32
+il_rd_prph(struct il_priv *il, u32 reg)
+{
+ unsigned long reg_flags;
+ u32 val;
+
+ spin_lock_irqsave(&il->reg_lock, reg_flags);
+ _il_grab_nic_access(il);
+ val = _il_rd_prph(il, reg);
+ _il_release_nic_access(il);
+ spin_unlock_irqrestore(&il->reg_lock, reg_flags);
+ return val;
+}
+EXPORT_SYMBOL(il_rd_prph);
+
+void
+il_wr_prph(struct il_priv *il, u32 addr, u32 val)
+{
+ unsigned long reg_flags;
+
+ spin_lock_irqsave(&il->reg_lock, reg_flags);
+ if (!_il_grab_nic_access(il)) {
+ _il_wr_prph(il, addr, val);
+ _il_release_nic_access(il);
+ }
+ spin_unlock_irqrestore(&il->reg_lock, reg_flags);
+}
+EXPORT_SYMBOL(il_wr_prph);
+
+u32
+il_read_targ_mem(struct il_priv *il, u32 addr)
+{
+ unsigned long reg_flags;
+ u32 value;
+
+ spin_lock_irqsave(&il->reg_lock, reg_flags);
+ _il_grab_nic_access(il);
+
+ _il_wr(il, HBUS_TARG_MEM_RADDR, addr);
+ rmb();
+ value = _il_rd(il, HBUS_TARG_MEM_RDAT);
+
+ _il_release_nic_access(il);
+ spin_unlock_irqrestore(&il->reg_lock, reg_flags);
+ return value;
+}
+EXPORT_SYMBOL(il_read_targ_mem);
+
+void
+il_write_targ_mem(struct il_priv *il, u32 addr, u32 val)
+{
+ unsigned long reg_flags;
+
+ spin_lock_irqsave(&il->reg_lock, reg_flags);
+ if (!_il_grab_nic_access(il)) {
+ _il_wr(il, HBUS_TARG_MEM_WADDR, addr);
+ wmb();
+ _il_wr(il, HBUS_TARG_MEM_WDAT, val);
+ _il_release_nic_access(il);
+ }
+ spin_unlock_irqrestore(&il->reg_lock, reg_flags);
+}
+EXPORT_SYMBOL(il_write_targ_mem);
+
const char *
il_get_cmd_string(u8 cmd)
{
}
}
-
EXPORT_SYMBOL(il_get_cmd_string);
#define HOST_COMPLETE_TIMEOUT (HZ / 2)
out:
return ret;
}
-
EXPORT_SYMBOL(il_send_cmd_sync);
int
return il_send_cmd_sync(il, cmd);
}
-
EXPORT_SYMBOL(il_send_cmd);
int
return il_send_cmd_sync(il, &cmd);
}
-
EXPORT_SYMBOL(il_send_cmd_pdu);
int
il_send_cmd_pdu_async(struct il_priv *il, u8 id, u16 len, const void *data,
- void (*callback) (struct il_priv * il,
- struct il_device_cmd * cmd,
- struct il_rx_pkt * pkt))
+ void (*callback) (struct il_priv *il,
+ struct il_device_cmd *cmd,
+ struct il_rx_pkt *pkt))
{
struct il_host_cmd cmd = {
.id = id,
return il_send_cmd_async(il, &cmd);
}
-
EXPORT_SYMBOL(il_send_cmd_pdu_async);
/* default: IL_LED_BLINK(0) using blinking idx table */
* <=0 SOLID ON
*/
static const struct ieee80211_tpt_blink il_blink[] = {
- {.throughput = 0,.blink_time = 334},
- {.throughput = 1 * 1024 - 1,.blink_time = 260},
- {.throughput = 5 * 1024 - 1,.blink_time = 220},
- {.throughput = 10 * 1024 - 1,.blink_time = 190},
- {.throughput = 20 * 1024 - 1,.blink_time = 170},
- {.throughput = 50 * 1024 - 1,.blink_time = 150},
- {.throughput = 70 * 1024 - 1,.blink_time = 130},
- {.throughput = 100 * 1024 - 1,.blink_time = 110},
- {.throughput = 200 * 1024 - 1,.blink_time = 80},
- {.throughput = 300 * 1024 - 1,.blink_time = 50},
+ {.throughput = 0, .blink_time = 334},
+ {.throughput = 1 * 1024 - 1, .blink_time = 260},
+ {.throughput = 5 * 1024 - 1, .blink_time = 220},
+ {.throughput = 10 * 1024 - 1, .blink_time = 190},
+ {.throughput = 20 * 1024 - 1, .blink_time = 170},
+ {.throughput = 50 * 1024 - 1, .blink_time = 150},
+ {.throughput = 70 * 1024 - 1, .blink_time = 130},
+ {.throughput = 100 * 1024 - 1, .blink_time = 110},
+ {.throughput = 200 * 1024 - 1, .blink_time = 80},
+ {.throughput = 300 * 1024 - 1, .blink_time = 50},
};
/*
il->led_registered = true;
}
-
EXPORT_SYMBOL(il_leds_init);
void
led_classdev_unregister(&il->led);
kfree(il->led.name);
}
-
EXPORT_SYMBOL(il_leds_exit);
/************************** EEPROM BANDS ****************************
BUG_ON(offset >= il->cfg->base_params->eeprom_size);
return &il->eeprom[offset];
}
-
EXPORT_SYMBOL(il_eeprom_query_addr);
u16
-il_eeprom_query16(const struct il_priv * il, size_t offset)
+il_eeprom_query16(const struct il_priv *il, size_t offset)
{
if (!il->eeprom)
return 0;
return (u16) il->eeprom[offset] | ((u16) il->eeprom[offset + 1] << 8);
}
-
EXPORT_SYMBOL(il_eeprom_query16);
/**
alloc_err:
return ret;
}
-
EXPORT_SYMBOL(il_eeprom_init);
void
kfree(il->eeprom);
il->eeprom = NULL;
}
-
EXPORT_SYMBOL(il_eeprom_free);
static void
il_init_band_reference(const struct il_priv *il, int eep_band,
int *eeprom_ch_count,
const struct il_eeprom_channel **eeprom_ch_info,
- const u8 ** eeprom_ch_idx)
+ const u8 **eeprom_ch_idx)
{
u32 offset =
il->cfg->ops->lib->eeprom_ops.regulatory_bands[eep_band - 1];
return 0;
}
-
EXPORT_SYMBOL(il_init_channel_map);
/*
kfree(il->channel_info);
il->channel_count = 0;
}
-
EXPORT_SYMBOL(il_free_channel_map);
/**
return NULL;
}
-
EXPORT_SYMBOL(il_get_channel_info);
/*
il_power_sleep_cam_cmd(il, &cmd);
return il_power_set_mode(il, &cmd, force);
}
-
EXPORT_SYMBOL(il_power_update_mode);
/* initialize to default */
queue_work(il->workqueue, &il->abort_scan);
return 0;
}
-
EXPORT_SYMBOL(il_scan_cancel);
/**
return test_bit(S_SCAN_HW, &il->status);
}
-
EXPORT_SYMBOL(il_scan_cancel_timeout);
/* Service response to C_SCAN (0x80) */
il->handlers[N_SCAN_RESULTS] = il_hdl_scan_results;
il->handlers[N_SCAN_COMPLETE] = il_hdl_scan_complete;
}
-
EXPORT_SYMBOL(il_setup_rx_scan_handlers);
inline u16
return IL_ACTIVE_DWELL_TIME_24 +
IL_ACTIVE_DWELL_FACTOR_24GHZ * (n_probes + 1);
}
-
EXPORT_SYMBOL(il_get_active_dwell_time);
u16
-il_get_passive_dwell_time(struct il_priv * il, enum ieee80211_band band,
- struct ieee80211_vif * vif)
+il_get_passive_dwell_time(struct il_priv *il, enum ieee80211_band band,
+ struct ieee80211_vif *vif)
{
struct il_rxon_context *ctx = &il->ctx;
u16 value;
return passive;
}
-
EXPORT_SYMBOL(il_get_passive_dwell_time);
void
if (!il->scan_tx_ant[IEEE80211_BAND_2GHZ])
il->scan_tx_ant[IEEE80211_BAND_2GHZ] = ant_idx;
}
-
EXPORT_SYMBOL(il_init_scan_params);
static int
return ret;
}
-
EXPORT_SYMBOL(il_mac_hw_scan);
static void
u16
il_fill_probe_req(struct il_priv *il, struct ieee80211_mgmt *frame,
- const u8 * ta, const u8 * ies, int ie_len, int left)
+ const u8 *ta, const u8 *ies, int ie_len, int left)
{
int len = 0;
u8 *pos = NULL;
return (u16) len;
}
-
EXPORT_SYMBOL(il_fill_probe_req);
static void
INIT_WORK(&il->abort_scan, il_bg_abort_scan);
INIT_DELAYED_WORK(&il->scan_check, il_bg_scan_check);
}
-
EXPORT_SYMBOL(il_setup_scan_deferred_work);
void
mutex_unlock(&il->mutex);
}
}
-
EXPORT_SYMBOL(il_cancel_scan_deferred_work);
/* il->sta_lock must be held */
return ret;
}
-
EXPORT_SYMBOL(il_send_add_sta);
static void
mimo_ps_mode = (sta_ht_inf->cap & IEEE80211_HT_CAP_SM_PS) >> 2;
D_ASSOC("spatial multiplexing power save mode: %s\n",
- (mimo_ps_mode ==
- WLAN_HT_CAP_SM_PS_STATIC) ? "static" : (mimo_ps_mode ==
- WLAN_HT_CAP_SM_PS_DYNAMIC)
- ? "dynamic" : "disabled");
+ (mimo_ps_mode == WLAN_HT_CAP_SM_PS_STATIC) ? "static" :
+ (mimo_ps_mode == WLAN_HT_CAP_SM_PS_DYNAMIC) ? "dynamic" :
+ "disabled");
sta_flags = il->stations[idx].sta.station_flags;
* should be called with sta_lock held
*/
u8
-il_prep_station(struct il_priv * il, struct il_rxon_context * ctx,
- const u8 * addr, bool is_ap, struct ieee80211_sta * sta)
+il_prep_station(struct il_priv *il, struct il_rxon_context *ctx,
+ const u8 *addr, bool is_ap, struct ieee80211_sta *sta)
{
struct il_station_entry *station;
int i;
return sta_id;
}
-
EXPORT_SYMBOL_GPL(il_prep_station);
#define STA_WAIT_TIMEOUT (HZ/2)
*/
int
il_add_station_common(struct il_priv *il, struct il_rxon_context *ctx,
- const u8 * addr, bool is_ap, struct ieee80211_sta *sta,
- u8 * sta_id_r)
+ const u8 *addr, bool is_ap, struct ieee80211_sta *sta,
+ u8 *sta_id_r)
{
unsigned long flags_spin;
int ret = 0;
*sta_id_r = sta_id;
return ret;
}
-
EXPORT_SYMBOL(il_add_station_common);
/**
spin_unlock_irqrestore(&il->sta_lock, flags);
return -EINVAL;
}
-
EXPORT_SYMBOL_GPL(il_remove_station);
/**
if (!cleared)
D_INFO("No active stations found to be cleared\n");
}
-
EXPORT_SYMBOL(il_clear_ucode_stations);
/**
else
D_INFO("Restoring all known stations" " .... complete.\n");
}
-
EXPORT_SYMBOL(il_restore_stations);
int
return WEP_INVALID_OFFSET;
}
-
EXPORT_SYMBOL(il_get_free_ucode_key_idx);
void
}
spin_unlock_irqrestore(&il->sta_lock, flags);
}
-
EXPORT_SYMBOL_GPL(il_dealloc_bcast_stations);
#ifdef CONFIG_IWLEGACY_DEBUG
}
return ret;
}
-
EXPORT_SYMBOL(il_send_lq_cmd);
int
mutex_unlock(&il->mutex);
return ret;
}
-
EXPORT_SYMBOL(il_mac_sta_remove);
/************************** RX-FUNCTIONS ****************************/
s = 0;
return s;
}
-
EXPORT_SYMBOL(il_rx_queue_space);
/**
exit_unlock:
spin_unlock_irqrestore(&q->lock, flags);
}
-
EXPORT_SYMBOL(il_rx_queue_update_write_ptr);
int
err_bd:
return -ENOMEM;
}
-
EXPORT_SYMBOL(il_rx_queue_alloc);
void
memcpy(&il->measure_report, report, sizeof(*report));
il->measurement_status |= MEASUREMENT_READY;
}
-
EXPORT_SYMBOL(il_hdl_spectrum_measurement);
/*
}
return 0;
}
-
EXPORT_SYMBOL(il_set_decrypted_flag);
/**
_il_wr(il, HBUS_TARG_WRPTR, txq->q.write_ptr | (txq_id << 8));
txq->need_update = 0;
}
-
EXPORT_SYMBOL(il_txq_update_write_ptr);
/**
q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd);
}
}
-
EXPORT_SYMBOL(il_tx_queue_unmap);
/**
/* 0-fill queue descriptor structure */
memset(txq, 0, sizeof(*txq));
}
-
EXPORT_SYMBOL(il_tx_queue_free);
/**
txq->meta[i].flags = 0;
}
}
-
EXPORT_SYMBOL(il_cmd_queue_unmap);
/**
/* 0-fill queue descriptor structure */
memset(txq, 0, sizeof(*txq));
}
-
EXPORT_SYMBOL(il_cmd_queue_free);
/*************** DMA-QUEUE-GENERAL-FUNCTIONS *****
s = 0;
return s;
}
-
EXPORT_SYMBOL(il_queue_space);
/* Driver ilate data, only for Tx (not command) queues,
* not shared with device. */
if (id != il->cmd_queue) {
- txq->txb =
- kzalloc(sizeof(txq->txb[0]) * TFD_QUEUE_SIZE_MAX,
- GFP_KERNEL);
+ txq->txb = kcalloc(TFD_QUEUE_SIZE_MAX, sizeof(txq->txb[0]),
+ GFP_KERNEL);
if (!txq->txb) {
IL_ERR("kmalloc for auxiliary BD "
"structures failed\n");
return -ENOMEM;
}
-
EXPORT_SYMBOL(il_tx_queue_init);
void
/* Tell device where to find queue */
il->cfg->ops->lib->txq_init(il, txq);
}
-
EXPORT_SYMBOL(il_tx_queue_reset);
/*************** HOST COMMAND QUEUE FUNCTIONS *****/
EXPORT_SYMBOL(il_debug_level);
const u8 il_bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
-
EXPORT_SYMBOL(il_bcast_addr);
/* This function both allocates and initializes hw and il. */
out:
return hw;
}
-
EXPORT_SYMBOL(il_alloc_all);
#define MAX_BIT_RATE_40_MHZ 150 /* Mbps */
return 0;
}
-
EXPORT_SYMBOL(il_init_geos);
/*
kfree(il->ieee_rates);
clear_bit(S_GEO_CONFIGURED, &il->status);
}
-
EXPORT_SYMBOL(il_free_geos);
static bool
}
bool
-il_is_ht40_tx_allowed(struct il_priv * il, struct il_rxon_context * ctx,
- struct ieee80211_sta_ht_cap * ht_cap)
+il_is_ht40_tx_allowed(struct il_priv *il, struct il_rxon_context *ctx,
+ struct ieee80211_sta_ht_cap *ht_cap)
{
if (!ctx->ht.enabled || !ctx->ht.is_40mhz)
return false;
le16_to_cpu(ctx->staging.channel),
ctx->ht.extension_chan_offset);
}
-
EXPORT_SYMBOL(il_is_ht40_tx_allowed);
static u16
return il_send_cmd_pdu(il, ctx->rxon_timing_cmd, sizeof(ctx->timing),
&ctx->timing);
}
-
EXPORT_SYMBOL(il_send_rxon_timing);
void
rxon->filter_flags |= RXON_FILTER_DIS_DECRYPT_MSK;
}
-
EXPORT_SYMBOL(il_set_rxon_hwcrypto);
/* validate RXON structure is valid */
}
return 0;
}
-
EXPORT_SYMBOL(il_check_rxon_cmd);
/**
return 0;
}
-
EXPORT_SYMBOL(il_full_rxon_required);
u8
-il_get_lowest_plcp(struct il_priv * il, struct il_rxon_context * ctx)
+il_get_lowest_plcp(struct il_priv *il, struct il_rxon_context *ctx)
{
/*
* Assign the lowest rate -- should really get this from
else
return RATE_6M_PLCP;
}
-
EXPORT_SYMBOL(il_get_lowest_plcp);
static void
{
_il_set_rxon_ht(il, ht_conf, &il->ctx);
}
-
EXPORT_SYMBOL(il_set_rxon_ht);
/* Return valid, unused, channel for a passive scan to reset the RF */
return channel;
}
-
EXPORT_SYMBOL(il_get_single_channel_number);
/**
return 0;
}
-
EXPORT_SYMBOL(il_set_rxon_channel);
void
ctx->staging.flags &= ~RXON_FLG_CCK_MSK;
}
}
-
EXPORT_SYMBOL(il_set_flags_for_band);
/*
ctx->staging.ofdm_ht_single_stream_basic_rates = 0xff;
ctx->staging.ofdm_ht_dual_stream_basic_rates = 0xff;
}
-
EXPORT_SYMBOL(il_connection_init_rx_config);
void
il->ctx.staging.ofdm_basic_rates =
(IL_OFDM_BASIC_RATES_MASK >> IL_FIRST_OFDM_RATE) & 0xFF;
}
-
EXPORT_SYMBOL(il_set_rate);
void
if (test_and_clear_bit(S_CHANNEL_SWITCH_PENDING, &il->status))
ieee80211_chswitch_done(ctx->vif, is_success);
}
-
EXPORT_SYMBOL(il_chswitch_done);
void
il_chswitch_done(il, false);
}
}
-
EXPORT_SYMBOL(il_hdl_csa);
#ifdef CONFIG_IWLEGACY_DEBUG
D_RADIO("u8[6] bssid_addr: %pM\n", rxon->bssid_addr);
D_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
}
-
EXPORT_SYMBOL(il_print_rx_config_cmd);
#endif
/**
queue_work(il->workqueue, &il->restart);
}
}
-
EXPORT_SYMBOL(il_irq_handle_error);
static int
*/
il_clear_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
}
-
EXPORT_SYMBOL(il_apm_stop);
/*
out:
return ret;
}
-
EXPORT_SYMBOL(il_apm_init);
int
}
return ret;
}
-
EXPORT_SYMBOL(il_set_tx_power);
void
struct il_rx_pkt *pkt = rxb_addr(rxb);
struct il_sleep_notification *sleep = &(pkt->u.sleep_notif);
D_RX("sleep mode: %d, src: %d\n",
- sleep->pm_sleep_mode, sleep->pm_wakeup_src);
+ sleep->pm_sleep_mode, sleep->pm_wakeup_src);
#endif
}
EXPORT_SYMBOL(il_hdl_pm_sleep);
D_MAC80211("leave\n");
return 0;
}
-
EXPORT_SYMBOL(il_mac_conf_tx);
int
return il->ibss_manager == IL_IBSS_MANAGER;
}
-
EXPORT_SYMBOL_GPL(il_mac_tx_last_beacon);
static int
D_MAC80211("leave\n");
return err;
}
-
EXPORT_SYMBOL(il_mac_add_interface);
static void
D_MAC80211("leave\n");
}
-
EXPORT_SYMBOL(il_mac_remove_interface);
int
}
return 0;
}
-
EXPORT_SYMBOL(il_alloc_txq_mem);
void
kfree(il->txq);
il->txq = NULL;
}
-
EXPORT_SYMBOL(il_txq_mem);
#ifdef CONFIG_IWLEGACY_DEBUGFS
il_reset_traffic_log(il);
return 0;
}
-
EXPORT_SYMBOL(il_alloc_traffic_mem);
void
kfree(il->rx_traffic);
il->rx_traffic = NULL;
}
-
EXPORT_SYMBOL(il_free_traffic_mem);
void
(il->tx_traffic_idx + 1) % IL_TRAFFIC_ENTRIES;
}
}
-
EXPORT_SYMBOL(il_dbg_log_tx_data_frame);
void
(il->rx_traffic_idx + 1) % IL_TRAFFIC_ENTRIES;
}
}
-
EXPORT_SYMBOL(il_dbg_log_rx_data_frame);
const char *
stats->data_bytes += len;
}
}
-
EXPORT_SYMBOL(il_update_stats);
#endif
mutex_unlock(&il->mutex);
return err;
}
-
EXPORT_SYMBOL(il_mac_change_interface);
/*
mod_timer(&il->watchdog,
jiffies + msecs_to_jiffies(IL_WD_TICK(timeout)));
}
-
EXPORT_SYMBOL(il_bg_watchdog);
void
else
del_timer(&il->watchdog);
}
-
EXPORT_SYMBOL(il_setup_watchdog);
/*
return (quot << il->hw_params.beacon_time_tsf_bits) + rem;
}
-
EXPORT_SYMBOL(il_usecs_to_beacons);
/* base is usually what we get from ucode with each received frame,
* the same as HW timer counter counting down
*/
__le32
-il_add_beacon_time(struct il_priv * il, u32 base, u32 addon,
+il_add_beacon_time(struct il_priv *il, u32 base, u32 addon,
u32 beacon_interval)
{
u32 base_low = base & il_beacon_time_mask_low(il,
return cpu_to_le32(res);
}
-
EXPORT_SYMBOL(il_add_beacon_time);
#ifdef CONFIG_PM
return 0;
}
-
EXPORT_SYMBOL(il_pci_suspend);
int
return 0;
}
-
EXPORT_SYMBOL(il_pci_resume);
const struct dev_pm_ops il_pm_ops = {
.poweroff = il_pci_suspend,
.restore = il_pci_resume,
};
-
EXPORT_SYMBOL(il_pm_ops);
#endif /* CONFIG_PM */
D_MAC80211("leave\n");
}
-
EXPORT_SYMBOL(il_mac_reset_tsf);
static void
D_MAC80211("leave\n");
}
-
EXPORT_SYMBOL(il_mac_bss_info_changed);
irqreturn_t
spin_unlock_irqrestore(&il->lock, flags);
return IRQ_NONE;
}
-
EXPORT_SYMBOL(il_isr);
/*
*/
void
il_tx_cmd_protection(struct il_priv *il, struct ieee80211_tx_info *info,
- __le16 fc, __le32 * tx_flags)
+ __le16 fc, __le32 *tx_flags)
{
if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) {
*tx_flags |= TX_CMD_FLG_RTS_MSK;
*tx_flags |= TX_CMD_FLG_FULL_TXOP_PROT_MSK;
}
}
-
EXPORT_SYMBOL(il_tx_cmd_protection);
projects / cascardo / linux.git / blobdiff