S: Maintained
F: drivers/net/typhoon*
- 3W-9XXX SATA-RAID CONTROLLER DRIVER
- M: Adam Radford <linuxraid@amcc.com>
+ 3WARE SAS/SATA-RAID SCSI DRIVERS (3W-XXXX, 3W-9XXX, 3W-SAS)
+ M: Adam Radford <linuxraid@lsi.com>
L: linux-scsi@vger.kernel.org
- W: http://www.amcc.com
+ W: http://www.lsi.com
S: Supported
- F: drivers/scsi/3w-9xxx*
-
- 3W-XXXX ATA-RAID CONTROLLER DRIVER
- M: Adam Radford <linuxraid@amcc.com>
- L: linux-scsi@vger.kernel.org
- W: http://www.amcc.com
- S: Supported
- F: drivers/scsi/3w-xxxx*
+ F: drivers/scsi/3w-*
53C700 AND 53C700-66 SCSI DRIVER
M: "James E.J. Bottomley" <James.Bottomley@HansenPartnership.com>
L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
W: http://www.mcuos.com
S: Maintained
+ F: arch/arm/mach-w90x900/
+ F: arch/arm/mach-nuc93x/
+ F: drivers/input/keyboard/w90p910_keypad.c
+ F: drivers/input/touchscreen/w90p910_ts.c
+ F: drivers/watchdog/nuc900_wdt.c
+ F: drivers/net/arm/w90p910_ether.c
+ F: drivers/mtd/nand/w90p910_nand.c
+ F: drivers/rtc/rtc-nuc900.c
+ F: drivers/spi/spi_nuc900.c
+ F: drivers/usb/host/ehci-w90x900.c
+ F: drivers/video/nuc900fb.c
+ F: drivers/sound/soc/nuc900/
ARM/U300 MACHINE SUPPORT
M: Linus Walleij <linus.walleij@stericsson.com>
S: Supported
F: drivers/infiniband/hw/cxgb4/
+ CXGB4VF ETHERNET DRIVER (CXGB4VF)
+ M: Casey Leedom <leedom@chelsio.com>
+ L: netdev@vger.kernel.org
+ W: http://www.chelsio.com
+ S: Supported
+ F: drivers/net/cxgb4vf/
+
CYBERPRO FB DRIVER
M: Russell King <linux@arm.linux.org.uk>
L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
S: Maintained
F: drivers/input/
+ INTEL IDLE DRIVER
+ M: Len Brown <lenb@kernel.org>
+ L: linux-pm@lists.linux-foundation.org
+ T: git git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux-idle-2.6.git
+ S: Supported
+ F: drivers/idle/intel_idle.c
+
INTEL FRAMEBUFFER DRIVER (excluding 810 and 815)
M: Maik Broemme <mbroemme@plusserver.de>
L: linux-fbdev@vger.kernel.org
F: include/keys/
F: security/keys/
- KGDB
+ KGDB / KDB /debug_core
M: Jason Wessel <jason.wessel@windriver.com>
+ W: http://kgdb.wiki.kernel.org/
L: kgdb-bugreport@lists.sourceforge.net
S: Maintained
F: Documentation/DocBook/kgdb.tmpl
F: drivers/misc/kgdbts.c
F: drivers/serial/kgdboc.c
+ F: include/linux/kdb.h
F: include/linux/kgdb.h
- F: kernel/kgdb.c
+ F: kernel/debug/
KMEMCHECK
M: Vegard Nossum <vegardno@ifi.uio.no>
S: Maintained
F: net/sched/sch_netem.c
- NETERION (S2IO) 10GbE DRIVER (xframe/vxge)
- M: Ramkrishna Vepa <ram.vepa@neterion.com>
- M: Rastapur Santosh <santosh.rastapur@neterion.com>
- M: Sivakumar Subramani <sivakumar.subramani@neterion.com>
- M: Sreenivasa Honnur <sreenivasa.honnur@neterion.com>
+ NETERION 10GbE DRIVERS (s2io/vxge)
+ M: Ramkrishna Vepa <ramkrishna.vepa@exar.com>
+ M: Sivakumar Subramani <sivakumar.subramani@exar.com>
+ M: Sreenivasa Honnur <sreenivasa.honnur@exar.com>
+ M: Jon Mason <jon.mason@exar.com>
L: netdev@vger.kernel.org
W: http://trac.neterion.com/cgi-bin/trac.cgi/wiki/Linux?Anonymous
W: http://trac.neterion.com/cgi-bin/trac.cgi/wiki/X3100Linux?Anonymous
S: Supported
F: Documentation/networking/s2io.txt
F: drivers/net/s2io*
+ F: Documentation/networking/vxge.txt
+ F: drivers/net/vxge/
NETFILTER/IPTABLES/IPCHAINS
P: Rusty Russell
M: "Luis R. Rodriguez" <mcgrof@gmail.com>
L: linux-wireless@vger.kernel.org
W: http://prism54.org
-S: Maintained
+S: Obsolete
F: drivers/net/wireless/prism54/
PROMISE DC4030 CACHING DISK CONTROLLER DRIVER
F: Documentation/scsi/LICENSE.qla2xxx
F: drivers/scsi/qla2xxx/
+ QLOGIC QLA4XXX iSCSI DRIVER
+ M: Ravi Anand <ravi.anand@qlogic.com>
+ M: Vikas Chaudhary <vikas.chaudhary@qlogic.com>
+ M: iscsi-driver@qlogic.com
+ L: linux-scsi@vger.kernel.org
+ S: Supported
+ F: drivers/scsi/qla4xxx/
+
QLOGIC QLA3XXX NETWORK DRIVER
M: Ron Mercer <ron.mercer@qlogic.com>
M: linux-driver@qlogic.com
F: drivers/rapidio/
RAYLINK/WEBGEAR 802.11 WIRELESS LAN DRIVER
-M: Corey Thomas <coreythomas@charter.net>
L: linux-wireless@vger.kernel.org
-S: Maintained
+S: Orphan
F: drivers/net/wireless/ray*
RCUTORTURE MODULE
F: Documentation/rfkill.txt
F: net/rfkill/
+ RICOH SMARTMEDIA/XD DRIVER
+ M: Maxim Levitsky <maximlevitsky@gmail.com>
+ S: Maintained
+ F: drivers/mtd/nand/r822.c
+ F: drivers/mtd/nand/r822.h
+
RISCOM8 DRIVER
S: Orphan
F: Documentation/serial/riscom8.txt
S: Supported
F: arch/s390/
F: drivers/s390/
+ F: fs/partitions/ibm.c
+ F: Documentation/s390/
+ F: Documentation/DocBook/s390*
S390 NETWORK DRIVERS
M: Ursula Braun <ursula.braun@de.ibm.com>
S: Maintained
F: drivers/mmc/host/sdhci-s3c.c
+ SECURE DIGITAL HOST CONTROLLER INTERFACE (SDHCI) ST SPEAR DRIVER
+ M: Viresh Kumar <viresh.kumar@st.com>
+ L: linux-mmc@vger.kernel.org
+ S: Maintained
+ F: drivers/mmc/host/sdhci-spear.c
+
SECURITY SUBSYSTEM
M: James Morris <jmorris@namei.org>
L: linux-security-module@vger.kernel.org (suggested Cc:)
F: drivers/media/video/zc0301/
USB ZD1201 DRIVER
-M: Jeroen Vreeken <pe1rxq@amsat.org>
-L: linux-usb@vger.kernel.org
+L: linux-wireless@vger.kernel.org
W: http://linux-lc100020.sourceforge.net
-S: Maintained
+S: Orphan
F: drivers/net/wireless/zd1201.*
USB ZR364XX DRIVER
F: drivers/watchdog/
F: include/linux/watchdog.h
-WAVELAN NETWORK DRIVER & WIRELESS EXTENSIONS
-M: Jean Tourrilhes <jt@hpl.hp.com>
-L: linux-wireless@vger.kernel.org
-W: http://www.hpl.hp.com/personal/Jean_Tourrilhes/Linux/
-S: Maintained
-F: Documentation/networking/wavelan.txt
-F: drivers/staging/wavelan/
-
WD7000 SCSI DRIVER
M: Miroslav Zagorac <zaga@fly.cc.fer.hr>
L: linux-scsi@vger.kernel.org
u8 mac[ETH_ALEN];
__le16 klen;
u8 key[16];
- } __attribute__ ((packed));
+ } __packed;
/* These structures are from the Aironet's PC4500 Developers Manual */
typedef struct Ssid Ssid;
struct Ssid {
__le16 len;
u8 ssid[32];
- } __attribute__ ((packed));
+ } __packed;
typedef struct SsidRid SsidRid;
struct SsidRid {
__le16 len;
Ssid ssids[3];
- } __attribute__ ((packed));
+ } __packed;
typedef struct ModulationRid ModulationRid;
struct ModulationRid {
#define MOD_DEFAULT cpu_to_le16(0)
#define MOD_CCK cpu_to_le16(1)
#define MOD_MOK cpu_to_le16(2)
- } __attribute__ ((packed));
+ } __packed;
typedef struct ConfigRid ConfigRid;
struct ConfigRid {
#define MAGIC_STAY_IN_CAM (1<<10)
u8 magicControl;
__le16 autoWake;
- } __attribute__ ((packed));
+ } __packed;
typedef struct StatusRid StatusRid;
struct StatusRid {
#define STAT_LEAPFAILED 91
#define STAT_LEAPTIMEDOUT 92
#define STAT_LEAPCOMPLETE 93
- } __attribute__ ((packed));
+ } __packed;
typedef struct StatsRid StatsRid;
struct StatsRid {
__le16 len;
__le16 spacer;
__le32 vals[100];
- } __attribute__ ((packed));
+ } __packed;
typedef struct APListRid APListRid;
struct APListRid {
__le16 len;
u8 ap[4][ETH_ALEN];
- } __attribute__ ((packed));
+ } __packed;
typedef struct CapabilityRid CapabilityRid;
struct CapabilityRid {
__le16 bootBlockVer;
__le16 requiredHard;
__le16 extSoftCap;
- } __attribute__ ((packed));
+ } __packed;
/* Only present on firmware >= 5.30.17 */
typedef struct BSSListRidExtra BSSListRidExtra;
__le16 unknown[4];
u8 fixed[12]; /* WLAN management frame */
u8 iep[624];
- } __attribute__ ((packed));
+ } __packed;
typedef struct BSSListRid BSSListRid;
struct BSSListRid {
/* Only present on firmware >= 5.30.17 */
BSSListRidExtra extra;
- } __attribute__ ((packed));
+ } __packed;
typedef struct {
BSSListRid bss;
struct tdsRssiEntry {
u8 rssipct;
u8 rssidBm;
- } __attribute__ ((packed));
+ } __packed;
typedef struct tdsRssiRid tdsRssiRid;
struct tdsRssiRid {
u16 len;
tdsRssiEntry x[256];
- } __attribute__ ((packed));
+ } __packed;
typedef struct MICRid MICRid;
struct MICRid {
u8 multicast[16];
__le16 unicastValid;
u8 unicast[16];
- } __attribute__ ((packed));
+ } __packed;
typedef struct MICBuffer MICBuffer;
struct MICBuffer {
} u;
__be32 mic;
__be32 seq;
- } __attribute__ ((packed));
+ } __packed;
typedef struct {
u8 da[ETH_ALEN];
u8 rate;
u8 freq;
__le16 tmp[4];
- } __attribute__ ((packed));
+ } __packed;
typedef struct {
unsigned int ctl: 15;
release_region( dev->base_addr, 64 );
err_out_nets:
airo_networks_free(ai);
- del_airo_dev(ai);
err_out_free:
+ del_airo_dev(ai);
free_netdev(dev);
return NULL;
}
loff_t *offset )
{
loff_t pos = *offset;
- struct proc_data *priv = (struct proc_data*)file->private_data;
+ struct proc_data *priv = file->private_data;
if (!priv->wbuffer)
return -EINVAL;
if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
return -ENOMEM;
- data = (struct proc_data *)file->private_data;
+ data = file->private_data;
if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
kfree (file->private_data);
return -ENOMEM;
if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
return -ENOMEM;
- data = (struct proc_data *)file->private_data;
+ data = file->private_data;
if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
kfree (file->private_data);
return -ENOMEM;
if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
return -ENOMEM;
- data = (struct proc_data *)file->private_data;
+ data = file->private_data;
if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
kfree (file->private_data);
return -ENOMEM;
static void proc_SSID_on_close(struct inode *inode, struct file *file)
{
- struct proc_data *data = (struct proc_data *)file->private_data;
+ struct proc_data *data = file->private_data;
struct proc_dir_entry *dp = PDE(inode);
struct net_device *dev = dp->data;
struct airo_info *ai = dev->ml_priv;
enable_MAC(ai, 1);
}
- static inline u8 hexVal(char c) {
- if (c>='0' && c<='9') return c -= '0';
- if (c>='a' && c<='f') return c -= 'a'-10;
- if (c>='A' && c<='F') return c -= 'A'-10;
- return 0;
- }
-
static void proc_APList_on_close( struct inode *inode, struct file *file ) {
- struct proc_data *data = (struct proc_data *)file->private_data;
+ struct proc_data *data = file->private_data;
struct proc_dir_entry *dp = PDE(inode);
struct net_device *dev = dp->data;
struct airo_info *ai = dev->ml_priv;
switch(j%3) {
case 0:
APList_rid.ap[i][j/3]=
- hexVal(data->wbuffer[j+i*6*3])<<4;
+ hex_to_bin(data->wbuffer[j+i*6*3])<<4;
break;
case 1:
APList_rid.ap[i][j/3]|=
- hexVal(data->wbuffer[j+i*6*3]);
+ hex_to_bin(data->wbuffer[j+i*6*3]);
break;
}
}
memset(key, 0, sizeof(key));
- data = (struct proc_data *)file->private_data;
+ data = file->private_data;
if ( !data->writelen ) return;
if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
switch(i%3) {
case 0:
- key[i/3] = hexVal(data->wbuffer[i+j])<<4;
+ key[i/3] = hex_to_bin(data->wbuffer[i+j])<<4;
break;
case 1:
- key[i/3] |= hexVal(data->wbuffer[i+j]);
+ key[i/3] |= hex_to_bin(data->wbuffer[i+j]);
break;
}
}
if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
return -ENOMEM;
memset(&wkr, 0, sizeof(wkr));
- data = (struct proc_data *)file->private_data;
+ data = file->private_data;
if ((data->rbuffer = kzalloc( 180, GFP_KERNEL )) == NULL) {
kfree (file->private_data);
return -ENOMEM;
if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
return -ENOMEM;
- data = (struct proc_data *)file->private_data;
+ data = file->private_data;
if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
kfree (file->private_data);
return -ENOMEM;
if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
return -ENOMEM;
- data = (struct proc_data *)file->private_data;
+ data = file->private_data;
if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
kfree (file->private_data);
return -ENOMEM;
if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
return -ENOMEM;
- data = (struct proc_data *)file->private_data;
+ data = file->private_data;
if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
kfree (file->private_data);
return -ENOMEM;
#define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2100 Network Driver"
#define DRV_COPYRIGHT "Copyright(c) 2003-2006 Intel Corporation"
-struct pm_qos_request_list *ipw2100_pm_qos_req;
+static struct pm_qos_request_list *ipw2100_pm_qos_req;
/* Debugging stuff */
#ifdef CONFIG_IPW2100_DEBUG
u8 auth_mode;
u8 replay_counters_number;
u8 unicast_using_group;
- } __attribute__ ((packed));
+ } __packed;
static int ipw2100_set_security_information(struct ipw2100_priv *priv,
int auth_mode,
short mode;
unsigned int fw_size;
unsigned int uc_size;
- } __attribute__ ((packed));
+ } __packed;
static int ipw2100_mod_firmware_load(struct ipw2100_fw *fw)
{
u8 ctrl; /* always 0x03 */
u8 oui[P80211_OUI_LEN]; /* organizational universal id */
- } __attribute__ ((packed));
+ } __packed;
#define SNAP_SIZE sizeof(struct libipw_snap_hdr)
u8 keys[WEP_KEYS][SCM_KEY_LEN];
u8 level;
u16 flags;
- } __attribute__ ((packed));
+ } __packed;
/*
__le16 duration_id;
u8 addr1[ETH_ALEN];
u8 payload[0];
- } __attribute__ ((packed));
+ } __packed;
struct libipw_hdr_2addr {
__le16 frame_ctl;
u8 addr1[ETH_ALEN];
u8 addr2[ETH_ALEN];
u8 payload[0];
- } __attribute__ ((packed));
+ } __packed;
struct libipw_hdr_3addr {
__le16 frame_ctl;
u8 addr3[ETH_ALEN];
__le16 seq_ctl;
u8 payload[0];
- } __attribute__ ((packed));
+ } __packed;
struct libipw_hdr_4addr {
__le16 frame_ctl;
__le16 seq_ctl;
u8 addr4[ETH_ALEN];
u8 payload[0];
- } __attribute__ ((packed));
+ } __packed;
struct libipw_hdr_3addrqos {
__le16 frame_ctl;
__le16 seq_ctl;
u8 payload[0];
__le16 qos_ctl;
- } __attribute__ ((packed));
+ } __packed;
struct libipw_info_element {
u8 id;
u8 len;
u8 data[0];
- } __attribute__ ((packed));
+ } __packed;
/*
* These are the data types that can make up management packets
u16 listen_interval;
struct {
u16 association_id:14, reserved:2;
- } __attribute__ ((packed));
+ } __packed;
u32 time_stamp[2];
u16 reason;
u16 status;
__le16 status;
/* challenge */
struct libipw_info_element info_element[0];
- } __attribute__ ((packed));
+ } __packed;
struct libipw_channel_switch {
u8 id;
u8 mode;
u8 channel;
u8 count;
- } __attribute__ ((packed));
+ } __packed;
struct libipw_action {
struct libipw_hdr_3addr header;
struct libipw_channel_switch channel_switch;
} format;
- } __attribute__ ((packed));
+ } __packed;
struct libipw_disassoc {
struct libipw_hdr_3addr header;
__le16 reason;
- } __attribute__ ((packed));
+ } __packed;
/* Alias deauth for disassoc */
#define libipw_deauth libipw_disassoc
struct libipw_hdr_3addr header;
/* SSID, supported rates */
struct libipw_info_element info_element[0];
- } __attribute__ ((packed));
+ } __packed;
struct libipw_probe_response {
struct libipw_hdr_3addr header;
/* SSID, supported rates, FH params, DS params,
* CF params, IBSS params, TIM (if beacon), RSN */
struct libipw_info_element info_element[0];
- } __attribute__ ((packed));
+ } __packed;
/* Alias beacon for probe_response */
#define libipw_beacon libipw_probe_response
__le16 listen_interval;
/* SSID, supported rates, RSN */
struct libipw_info_element info_element[0];
- } __attribute__ ((packed));
+ } __packed;
struct libipw_reassoc_request {
struct libipw_hdr_3addr header;
__le16 listen_interval;
u8 current_ap[ETH_ALEN];
struct libipw_info_element info_element[0];
- } __attribute__ ((packed));
+ } __packed;
struct libipw_assoc_response {
struct libipw_hdr_3addr header;
__le16 aid;
/* supported rates */
struct libipw_info_element info_element[0];
- } __attribute__ ((packed));
+ } __packed;
struct libipw_txb {
u8 nr_frags;
u8 qui_subtype;
u8 version;
u8 ac_info;
- } __attribute__ ((packed));
+ } __packed;
struct libipw_qos_ac_parameter {
u8 aci_aifsn;
u8 ecw_min_max;
__le16 tx_op_limit;
- } __attribute__ ((packed));
+ } __packed;
struct libipw_qos_parameter_info {
struct libipw_qos_information_element info_element;
u8 reserved;
struct libipw_qos_ac_parameter ac_params_record[QOS_QUEUE_NUM];
- } __attribute__ ((packed));
+ } __packed;
struct libipw_qos_parameters {
__le16 cw_min[QOS_QUEUE_NUM];
u8 aifs[QOS_QUEUE_NUM];
u8 flag[QOS_QUEUE_NUM];
__le16 tx_op_limit[QOS_QUEUE_NUM];
- } __attribute__ ((packed));
+ } __packed;
struct libipw_qos_data {
struct libipw_qos_parameters parameters;
struct libipw_tim_parameters {
u8 tim_count;
u8 tim_period;
- } __attribute__ ((packed));
+ } __packed;
/*******************************************************/
__le64 start_time;
__le16 duration;
u8 map;
- } __attribute__ ((packed));
+ } __packed;
enum { /* libipw_measurement_request.mode */
/* Bit 0 is reserved */
u8 channel;
__le64 start_time;
__le16 duration;
- } __attribute__ ((packed));
+ } __packed;
struct libipw_measurement_request {
struct libipw_info_element ie;
u8 mode;
u8 type;
struct libipw_measurement_params params[0];
- } __attribute__ ((packed));
+ } __packed;
struct libipw_measurement_report {
struct libipw_info_element ie;
union {
struct libipw_basic_report basic[0];
} u;
- } __attribute__ ((packed));
+ } __packed;
struct libipw_tpc_report {
u8 transmit_power;
u8 link_margin;
- } __attribute__ ((packed));
+ } __packed;
struct libipw_channel_map {
u8 channel;
u8 map;
- } __attribute__ ((packed));
+ } __packed;
struct libipw_ibss_dfs {
struct libipw_info_element ie;
u8 mode;
u8 channel;
u8 count;
- } __attribute__ ((packed));
+ } __packed;
struct libipw_quiet {
u8 count;
u8 period;
u8 duration;
u8 offset;
- } __attribute__ ((packed));
+ } __packed;
struct libipw_network {
/* These entries are used to identify a unique network */
int host_strip_iv_icv;
int host_open_frag;
- int host_build_iv;
int ieee802_1x; /* is IEEE 802.1X used */
/* WPA data */
/* command or response/notification data follows immediately */
u8 data[0];
- } __attribute__ ((packed));
+ } __packed;
/**
struct iwl3945_tx_power {
u8 tx_gain; /* gain for analog radio */
u8 dsp_atten; /* gain for DSP */
- } __attribute__ ((packed));
+ } __packed;
/**
* struct iwl3945_power_per_rate
u8 rate; /* plcp */
struct iwl3945_tx_power tpc;
u8 reserved;
- } __attribute__ ((packed));
+ } __packed;
/**
* iwlagn rate_n_flags bit fields
*/
struct tx_power_dual_stream {
__le32 dw;
- } __attribute__ ((packed));
+ } __packed;
/**
* struct iwl4965_tx_power_db
*/
struct iwl4965_tx_power_db {
struct tx_power_dual_stream power_tbl[POWER_TABLE_NUM_ENTRIES];
- } __attribute__ ((packed));
+ } __packed;
/**
* Command REPLY_TX_POWER_DBM_CMD = 0x98
u8 flags;
s8 srv_chan_lmt; /*in half-dBm (e.g. 30 = 15 dBm) */
u8 reserved;
- } __attribute__ ((packed));
+ } __packed;
/**
* Command TX_ANT_CONFIGURATION_CMD = 0x98
*/
struct iwl_tx_ant_config_cmd {
__le32 valid;
- } __attribute__ ((packed));
+ } __packed;
/******************************************************************************
* (0a)
__le32 therm_r4[2]; /* signed */
__le32 tx_atten[5][2]; /* signed MIMO gain comp, 5 freq groups,
* 2 Tx chains */
- } __attribute__ ((packed));
+ } __packed;
/**
__le32 error_event_table_ptr; /* SRAM address for error log */
__le32 timestamp;
__le32 is_valid;
- } __attribute__ ((packed));
+ } __packed;
/*
* REPLY_ERROR = 0x2 (response only, not a command)
__le16 bad_cmd_seq_num;
__le32 error_info;
__le64 timestamp;
- } __attribute__ ((packed));
+ } __packed;
/******************************************************************************
* (1)
__le32 filter_flags;
__le16 channel;
__le16 reserved5;
- } __attribute__ ((packed));
+ } __packed;
struct iwl4965_rxon_cmd {
u8 node_addr[6];
__le16 channel;
u8 ofdm_ht_single_stream_basic_rates;
u8 ofdm_ht_dual_stream_basic_rates;
- } __attribute__ ((packed));
+ } __packed;
/* 5000 HW just extend this command */
struct iwl_rxon_cmd {
u8 reserved5;
__le16 acquisition_data;
__le16 reserved6;
- } __attribute__ ((packed));
+ } __packed;
/*
* REPLY_RXON_ASSOC = 0x11 (command, has simple generic response)
u8 ofdm_basic_rates;
u8 cck_basic_rates;
__le16 reserved;
- } __attribute__ ((packed));
+ } __packed;
struct iwl4965_rxon_assoc_cmd {
__le32 flags;
u8 ofdm_ht_dual_stream_basic_rates;
__le16 rx_chain_select_flags;
__le16 reserved;
- } __attribute__ ((packed));
+ } __packed;
struct iwl5000_rxon_assoc_cmd {
__le32 flags;
__le16 rx_chain_select_flags;
__le16 acquisition_data;
__le32 reserved3;
- } __attribute__ ((packed));
+ } __packed;
#define IWL_CONN_MAX_LISTEN_INTERVAL 10
#define IWL_MAX_UCODE_BEACON_INTERVAL 4 /* 4096 */
__le32 beacon_init_val;
__le16 listen_interval;
__le16 reserved;
- } __attribute__ ((packed));
+ } __packed;
/*
* REPLY_CHANNEL_SWITCH = 0x72 (command, has simple generic response)
__le32 rxon_filter_flags;
__le32 switch_time;
struct iwl3945_power_per_rate power[IWL_MAX_RATES];
- } __attribute__ ((packed));
+ } __packed;
struct iwl4965_channel_switch_cmd {
u8 band;
__le32 rxon_filter_flags;
__le32 switch_time;
struct iwl4965_tx_power_db tx_power;
- } __attribute__ ((packed));
+ } __packed;
/**
* struct iwl5000_channel_switch_cmd
__le32 rxon_filter_flags;
__le32 switch_time;
__le32 reserved[2][IWL_PWR_NUM_HT_OFDM_ENTRIES + IWL_PWR_CCK_ENTRIES];
- } __attribute__ ((packed));
+ } __packed;
/**
* struct iwl6000_channel_switch_cmd
__le32 rxon_filter_flags;
__le32 switch_time;
__le32 reserved[3][IWL_PWR_NUM_HT_OFDM_ENTRIES + IWL_PWR_CCK_ENTRIES];
- } __attribute__ ((packed));
+ } __packed;
/*
* CHANNEL_SWITCH_NOTIFICATION = 0x73 (notification only, not a command)
__le16 band;
__le16 channel;
__le32 status; /* 0 - OK, 1 - fail */
- } __attribute__ ((packed));
+ } __packed;
/******************************************************************************
* (2)
u8 aifsn;
u8 reserved1;
__le16 edca_txop;
- } __attribute__ ((packed));
+ } __packed;
/* QoS flags defines */
#define QOS_PARAM_FLG_UPDATE_EDCA_MSK cpu_to_le32(0x01)
struct iwl_qosparam_cmd {
__le32 qos_flags;
struct iwl_ac_qos ac[AC_NUM];
- } __attribute__ ((packed));
+ } __packed;
/******************************************************************************
* (3)
#define IWL_STATION_COUNT 32 /* MAX(3945,4965)*/
#define IWL_INVALID_STATION 255
-#define STA_FLG_TX_RATE_MSK cpu_to_le32(1 << 2);
-#define STA_FLG_PWR_SAVE_MSK cpu_to_le32(1 << 8);
+#define STA_FLG_TX_RATE_MSK cpu_to_le32(1 << 2)
+#define STA_FLG_PWR_SAVE_MSK cpu_to_le32(1 << 8)
#define STA_FLG_RTS_MIMO_PROT_MSK cpu_to_le32(1 << 17)
#define STA_FLG_AGG_MPDU_8US_MSK cpu_to_le32(1 << 18)
#define STA_FLG_MAX_AGG_SIZE_POS (19)
u8 key_offset;
u8 reserved2;
u8 key[16]; /* 16-byte unicast decryption key */
- } __attribute__ ((packed));
+ } __packed;
/* 5000 */
struct iwl_keyinfo {
__le64 tx_secur_seq_cnt;
__le64 hw_tkip_mic_rx_key;
__le64 hw_tkip_mic_tx_key;
- } __attribute__ ((packed));
+ } __packed;
/**
* struct sta_id_modify
u8 sta_id;
u8 modify_mask;
__le16 reserved2;
- } __attribute__ ((packed));
+ } __packed;
/*
* REPLY_ADD_STA = 0x18 (command)
/* Starting Sequence Number for added block-ack support.
* Set modify_mask bit STA_MODIFY_ADDBA_TID_MSK to use this field. */
__le16 add_immediate_ba_ssn;
- } __attribute__ ((packed));
+ } __packed;
struct iwl4965_addsta_cmd {
u8 mode; /* 1: modify existing, 0: add new station */
__le16 sleep_tx_count;
__le16 reserved2;
- } __attribute__ ((packed));
+ } __packed;
/* 5000 */
struct iwl_addsta_cmd {
__le16 sleep_tx_count;
__le16 reserved2;
- } __attribute__ ((packed));
+ } __packed;
#define ADD_STA_SUCCESS_MSK 0x1
*/
struct iwl_add_sta_resp {
u8 status; /* ADD_STA_* */
- } __attribute__ ((packed));
+ } __packed;
#define REM_STA_SUCCESS_MSK 0x1
/*
*/
struct iwl_rem_sta_resp {
u8 status;
- } __attribute__ ((packed));
+ } __packed;
/*
* REPLY_REM_STA = 0x19 (command)
u8 reserved[3];
u8 addr[ETH_ALEN]; /* MAC addr of the first station */
u8 reserved2[2];
- } __attribute__ ((packed));
+ } __packed;
#define IWL_TX_FIFO_BK_MSK cpu_to_le32(BIT(0))
#define IWL_TX_FIFO_BE_MSK cpu_to_le32(BIT(1))
__le32 fifo_control;
__le16 flush_control;
__le16 reserved;
-} __attribute__ ((packed));
+} __packed;
/*
* REPLY_WEP_KEY = 0x20
u8 key_size;
u8 reserved2[3];
u8 key[16];
- } __attribute__ ((packed));
+ } __packed;
struct iwl_wep_cmd {
u8 num_keys;
u8 flags;
u8 reserved;
struct iwl_wep_key key[0];
- } __attribute__ ((packed));
+ } __packed;
#define WEP_KEY_WEP_TYPE 1
#define WEP_KEYS_MAX 4
__le16 sig_avg;
__le16 noise_diff;
u8 payload[0];
- } __attribute__ ((packed));
+ } __packed;
struct iwl3945_rx_frame_hdr {
__le16 channel;
u8 rate;
__le16 len;
u8 payload[0];
- } __attribute__ ((packed));
+ } __packed;
struct iwl3945_rx_frame_end {
__le32 status;
__le64 timestamp;
__le32 beacon_timestamp;
- } __attribute__ ((packed));
+ } __packed;
/*
* REPLY_3945_RX = 0x1b (response only, not a command)
struct iwl3945_rx_frame_stats stats;
struct iwl3945_rx_frame_hdr hdr;
struct iwl3945_rx_frame_end end;
- } __attribute__ ((packed));
+ } __packed;
#define IWL39_RX_FRAME_SIZE (4 + sizeof(struct iwl3945_rx_frame))
__le16 agc_info; /* agc code 0:6, agc dB 7:13, reserved 14:15 */
u8 rssi_info[6]; /* we use even entries, 0/2/4 for A/B/C rssi */
u8 pad[0];
- } __attribute__ ((packed));
+ } __packed;
#define IWL50_RX_RES_PHY_CNT 8
struct iwl5000_non_cfg_phy {
__le32 non_cfg_phy[IWL50_RX_RES_PHY_CNT]; /* up to 8 phy entries */
- } __attribute__ ((packed));
+ } __packed;
/*
__le32 rate_n_flags; /* RATE_MCS_* */
__le16 byte_count; /* frame's byte-count */
__le16 reserved3;
- } __attribute__ ((packed));
+ } __packed;
struct iwl_rx_mpdu_res_start {
__le16 byte_count;
__le16 reserved;
- } __attribute__ ((packed));
+ } __packed;
/******************************************************************************
*/
u8 payload[0];
struct ieee80211_hdr hdr[0];
- } __attribute__ ((packed));
+ } __packed;
/*
* REPLY_TX = 0x1c (response)
u8 rate;
__le32 wireless_media_time;
__le32 status; /* TX status */
- } __attribute__ ((packed));
+ } __packed;
/*
u8 try_cnt; /* Tx attempts */
u8 bt_kill_cnt; /* Tx attempts blocked by Bluetooth device */
__le16 reserved;
- } __attribute__ ((packed));
+ } __packed;
struct iwl_tx_cmd {
/*
*/
u8 payload[0];
struct ieee80211_hdr hdr[0];
- } __attribute__ ((packed));
+ } __packed;
/* TX command response is sent after *3945* transmission attempts.
*
struct agg_tx_status {
__le16 status;
__le16 sequence;
- } __attribute__ ((packed));
+ } __packed;
struct iwl4965_tx_resp {
u8 frame_count; /* 1 no aggregation, >1 aggregation */
__le32 status;
struct agg_tx_status agg_status[0]; /* for each agg frame */
} u;
- } __attribute__ ((packed));
+ } __packed;
/*
* definitions for initial rate index field
*/
struct agg_tx_status status; /* TX status (in aggregation -
* status of 1st frame) */
- } __attribute__ ((packed));
+ } __packed;
/*
* REPLY_COMPRESSED_BA = 0xc5 (response only, not a command)
*
__le64 bitmap;
__le16 scd_flow;
__le16 scd_ssn;
- } __attribute__ ((packed));
+ } __packed;
/*
* REPLY_TX_PWR_TABLE_CMD = 0x97 (command, has simple generic response)
u8 reserved;
__le16 channel;
struct iwl3945_power_per_rate power[IWL_MAX_RATES];
- } __attribute__ ((packed));
+ } __packed;
struct iwl4965_txpowertable_cmd {
u8 band; /* 0: 5 GHz, 1: 2.4 GHz */
u8 reserved;
__le16 channel;
struct iwl4965_tx_power_db tx_power;
- } __attribute__ ((packed));
+ } __packed;
/**
__le16 rate_n_flags;
u8 try_cnt;
u8 next_rate_index;
- } __attribute__ ((packed));
+ } __packed;
struct iwl3945_rate_scaling_cmd {
u8 table_id;
u8 reserved[3];
struct iwl3945_rate_scaling_info table[IWL_MAX_RATES];
- } __attribute__ ((packed));
+ } __packed;
/*RS_NEW_API: only TLC_RTS remains and moved to bit 0 */
* TX FIFOs above 3 use same value (typically 0) as TX FIFO 3.
*/
u8 start_rate_index[LINK_QUAL_AC_NUM];
- } __attribute__ ((packed));
+ } __packed;
#define LINK_QUAL_AGG_TIME_LIMIT_DEF (4000) /* 4 milliseconds */
#define LINK_QUAL_AGG_TIME_LIMIT_MAX (65535)
u8 agg_frame_cnt_limit;
__le32 reserved;
- } __attribute__ ((packed));
+ } __packed;
/*
* REPLY_TX_LINK_QUALITY_CMD = 0x4e (command, has simple generic response)
__le32 rate_n_flags; /* RATE_MCS_*, IWL_RATE_* */
} rs_table[LINK_QUAL_MAX_RETRY_NUM];
__le32 reserved2;
- } __attribute__ ((packed));
+ } __packed;
/*
* BT configuration enable flags:
u8 reserved;
__le32 kill_ack_mask;
__le32 kill_cts_mask;
- } __attribute__ ((packed));
+ } __packed;
/******************************************************************************
* (6)
u8 channel; /* channel to measure */
u8 type; /* see enum iwl_measure_type */
__le16 reserved;
- } __attribute__ ((packed));
+ } __packed;
/*
* REPLY_SPECTRUM_MEASUREMENT_CMD = 0x74 (command)
__le16 channel_count; /* minimum 1, maximum 10 */
__le16 reserved3;
struct iwl_measure_channel channels[10];
- } __attribute__ ((packed));
+ } __packed;
/*
* REPLY_SPECTRUM_MEASUREMENT_CMD = 0x74 (response)
__le16 status; /* 0 - command will be handled
* 1 - cannot handle (conflicts with another
* measurement) */
- } __attribute__ ((packed));
+ } __packed;
enum iwl_measurement_state {
IWL_MEASUREMENT_START = 0,
struct iwl_measurement_histogram {
__le32 ofdm[NUM_ELEMENTS_IN_HISTOGRAM]; /* in 0.8usec counts */
__le32 cck[NUM_ELEMENTS_IN_HISTOGRAM]; /* in 1usec counts */
- } __attribute__ ((packed));
+ } __packed;
/* clear channel availability counters */
struct iwl_measurement_cca_counters {
__le32 ofdm;
__le32 cck;
- } __attribute__ ((packed));
+ } __packed;
enum iwl_measure_type {
IWL_MEASURE_BASIC = (1 << 0),
struct iwl_measurement_histogram histogram;
__le32 stop_time; /* lower 32-bits of TSF */
__le32 status; /* see iwl_measurement_status */
- } __attribute__ ((packed));
+ } __packed;
/******************************************************************************
* (7)
__le32 rx_data_timeout;
__le32 tx_data_timeout;
__le32 sleep_interval[IWL_POWER_VEC_SIZE];
- } __attribute__ ((packed));
+ } __packed;
struct iwl_powertable_cmd {
__le16 flags;
__le32 tx_data_timeout;
__le32 sleep_interval[IWL_POWER_VEC_SIZE];
__le32 keep_alive_beacons;
- } __attribute__ ((packed));
+ } __packed;
/*
* PM_SLEEP_NOTIFICATION = 0x7A (notification only, not a command)
__le32 sleep_time;
__le32 tsf_low;
__le32 bcon_timer;
- } __attribute__ ((packed));
+ } __packed;
/* Sleep states. 3945 and 4965 identical. */
enum {
#define CARD_STATE_CMD_HALT 0x02 /* Power down permanently */
struct iwl_card_state_cmd {
__le32 status; /* CARD_STATE_CMD_* request new power state */
- } __attribute__ ((packed));
+ } __packed;
/*
* CARD_STATE_NOTIFICATION = 0xa1 (notification only, not a command)
*/
struct iwl_card_state_notif {
__le32 flags;
- } __attribute__ ((packed));
+ } __packed;
#define HW_CARD_DISABLED 0x01
#define SW_CARD_DISABLED 0x02
__le32 reserved;
__le32 critical_temperature_M;
__le32 critical_temperature_R;
- } __attribute__ ((packed));
+ } __packed;
/* 1000, and 6x00 */
struct iwl_ct_kill_throttling_config {
__le32 critical_temperature_exit;
__le32 reserved;
__le32 critical_temperature_enter;
- } __attribute__ ((packed));
+ } __packed;
/******************************************************************************
* (8)
struct iwl3945_tx_power tpc;
__le16 active_dwell; /* in 1024-uSec TU (time units), typ 5-50 */
__le16 passive_dwell; /* in 1024-uSec TU (time units), typ 20-500 */
- } __attribute__ ((packed));
+ } __packed;
/* set number of direct probes u8 type */
#define IWL39_SCAN_PROBE_MASK(n) ((BIT(n) | (BIT(n) - BIT(1))))
u8 dsp_atten; /* gain for DSP */
__le16 active_dwell; /* in 1024-uSec TU (time units), typ 5-50 */
__le16 passive_dwell; /* in 1024-uSec TU (time units), typ 20-500 */
- } __attribute__ ((packed));
+ } __packed;
/* set number of direct probes __le32 type */
#define IWL_SCAN_PROBE_MASK(n) cpu_to_le32((BIT(n) | (BIT(n) - BIT(1))))
u8 id;
u8 len;
u8 ssid[32];
- } __attribute__ ((packed));
+ } __packed;
#define PROBE_OPTION_MAX_3945 4
#define PROBE_OPTION_MAX 20
* before requesting another scan.
*/
u8 data[0];
- } __attribute__ ((packed));
+ } __packed;
struct iwl_scan_cmd {
__le16 len;
* before requesting another scan.
*/
u8 data[0];
- } __attribute__ ((packed));
+ } __packed;
/* Can abort will notify by complete notification with abort status. */
#define CAN_ABORT_STATUS cpu_to_le32(0x1)
*/
struct iwl_scanreq_notification {
__le32 status; /* 1: okay, 2: cannot fulfill request */
- } __attribute__ ((packed));
+ } __packed;
/*
* SCAN_START_NOTIFICATION = 0x82 (notification only, not a command)
u8 band;
u8 reserved[2];
__le32 status;
- } __attribute__ ((packed));
+ } __packed;
#define SCAN_OWNER_STATUS 0x1;
#define MEASURE_OWNER_STATUS 0x2;
__le32 tsf_low;
__le32 tsf_high;
__le32 statistics[NUMBER_OF_STATISTICS];
- } __attribute__ ((packed));
+ } __packed;
/*
* SCAN_COMPLETE_NOTIFICATION = 0x84 (notification only, not a command)
u8 last_channel;
__le32 tsf_low;
__le32 tsf_high;
- } __attribute__ ((packed));
+ } __packed;
/******************************************************************************
__le32 low_tsf;
__le32 high_tsf;
__le32 ibss_mgr_status;
- } __attribute__ ((packed));
+ } __packed;
struct iwl4965_beacon_notif {
struct iwl4965_tx_resp beacon_notify_hdr;
__le32 low_tsf;
__le32 high_tsf;
__le32 ibss_mgr_status;
- } __attribute__ ((packed));
+ } __packed;
/*
* REPLY_TX_BEACON = 0x91 (command, has simple generic response)
u8 tim_size;
u8 reserved1;
struct ieee80211_hdr frame[0]; /* beacon frame */
- } __attribute__ ((packed));
+ } __packed;
struct iwl_tx_beacon_cmd {
struct iwl_tx_cmd tx;
u8 tim_size;
u8 reserved1;
struct ieee80211_hdr frame[0]; /* beacon frame */
- } __attribute__ ((packed));
+ } __packed;
/******************************************************************************
* (10)
__le32 b[SUP_RATE_11B_MAX_NUM_CHANNELS];
__le32 g[SUP_RATE_11G_MAX_NUM_CHANNELS];
} failed;
- } __attribute__ ((packed));
+ } __packed;
/* statistics command response */
__le32 rxe_frame_limit_overrun;
__le32 sent_ack_cnt;
__le32 sent_cts_cnt;
- } __attribute__ ((packed));
+ } __packed;
struct iwl39_statistics_rx_non_phy {
__le32 bogus_cts; /* CTS received when not expecting CTS */
* filtering process */
__le32 non_channel_beacons; /* beacons with our bss id but not on
* our serving channel */
- } __attribute__ ((packed));
+ } __packed;
struct iwl39_statistics_rx {
struct iwl39_statistics_rx_phy ofdm;
struct iwl39_statistics_rx_phy cck;
struct iwl39_statistics_rx_non_phy general;
- } __attribute__ ((packed));
+ } __packed;
struct iwl39_statistics_tx {
__le32 preamble_cnt;
__le32 ack_timeout;
__le32 expected_ack_cnt;
__le32 actual_ack_cnt;
- } __attribute__ ((packed));
+ } __packed;
struct statistics_dbg {
__le32 burst_check;
__le32 burst_count;
- __le32 reserved[4];
+ __le32 wait_for_silence_timeout_cnt;
+ __le32 reserved[3];
- } __attribute__ ((packed));
+ } __packed;
struct iwl39_statistics_div {
__le32 tx_on_a;
__le32 tx_on_b;
__le32 exec_time;
__le32 probe_time;
- } __attribute__ ((packed));
+ } __packed;
struct iwl39_statistics_general {
__le32 temperature;
__le32 slots_idle;
__le32 ttl_timestamp;
struct iwl39_statistics_div div;
- } __attribute__ ((packed));
+ } __packed;
struct statistics_rx_phy {
__le32 ina_cnt;
__le32 mh_format_err;
__le32 re_acq_main_rssi_sum;
__le32 reserved3;
- } __attribute__ ((packed));
+ } __packed;
struct statistics_rx_ht_phy {
__le32 plcp_err;
__le32 agg_mpdu_cnt;
__le32 agg_cnt;
__le32 unsupport_mcs;
- } __attribute__ ((packed));
+ } __packed;
#define INTERFERENCE_DATA_AVAILABLE cpu_to_le32(1)
__le32 beacon_energy_a;
__le32 beacon_energy_b;
__le32 beacon_energy_c;
- } __attribute__ ((packed));
+ } __packed;
+struct statistics_rx_non_phy_bt {
+ struct statistics_rx_non_phy common;
+ /* additional stats for bt */
+ __le32 num_bt_kills;
+ __le32 reserved[2];
+} __packed;
+
struct statistics_rx {
struct statistics_rx_phy ofdm;
struct statistics_rx_phy cck;
struct statistics_rx_non_phy general;
struct statistics_rx_ht_phy ofdm_ht;
- } __attribute__ ((packed));
+ } __packed;
+struct statistics_rx_bt {
+ struct statistics_rx_phy ofdm;
+ struct statistics_rx_phy cck;
+ struct statistics_rx_non_phy_bt general;
+ struct statistics_rx_ht_phy ofdm_ht;
+} __packed;
+
/**
* struct statistics_tx_power - current tx power
*
u8 ant_b;
u8 ant_c;
u8 reserved;
- } __attribute__ ((packed));
+ } __packed;
struct statistics_tx_non_phy_agg {
__le32 ba_timeout;
__le32 underrun;
__le32 bt_prio_kill;
__le32 rx_ba_rsp_cnt;
- } __attribute__ ((packed));
+ } __packed;
struct statistics_tx {
__le32 preamble_cnt;
*/
struct statistics_tx_power tx_power;
__le32 reserved1;
- } __attribute__ ((packed));
+ } __packed;
struct statistics_div {
__le32 probe_time;
__le32 reserved1;
__le32 reserved2;
- } __attribute__ ((packed));
+ } __packed;
-struct statistics_general {
+struct statistics_general_common {
__le32 temperature; /* radio temperature */
__le32 temperature_m; /* for 5000 and up, this is radio voltage */
struct statistics_dbg dbg;
* in order to get out of bad PHY status
*/
__le32 num_of_sos_states;
+} __packed;
+
+struct statistics_bt_activity {
+ /* Tx statistics */
+ __le32 hi_priority_tx_req_cnt;
+ __le32 hi_priority_tx_denied_cnt;
+ __le32 lo_priority_tx_req_cnt;
+ __le32 lo_priority_tx_denied_cnt;
+ /* Rx statistics */
+ __le32 hi_priority_rx_req_cnt;
+ __le32 hi_priority_rx_denied_cnt;
+ __le32 lo_priority_rx_req_cnt;
+ __le32 lo_priority_rx_denied_cnt;
+} __packed;
+
+struct statistics_general {
+ struct statistics_general_common common;
+ __le32 reserved2;
+ __le32 reserved3;
+} __packed;
+
+struct statistics_general_bt {
+ struct statistics_general_common common;
+ struct statistics_bt_activity activity;
__le32 reserved2;
__le32 reserved3;
- } __attribute__ ((packed));
+ } __packed;
#define UCODE_STATISTICS_CLEAR_MSK (0x1 << 0)
#define UCODE_STATISTICS_FREQUENCY_MSK (0x1 << 1)
#define IWL_STATS_CONF_DISABLE_NOTIF cpu_to_le32(0x2)/* see above */
struct iwl_statistics_cmd {
__le32 configuration_flags; /* IWL_STATS_CONF_* */
- } __attribute__ ((packed));
+ } __packed;
/*
* STATISTICS_NOTIFICATION = 0x9d (notification only, not a command)
struct iwl39_statistics_rx rx;
struct iwl39_statistics_tx tx;
struct iwl39_statistics_general general;
- } __attribute__ ((packed));
+ } __packed;
struct iwl_notif_statistics {
__le32 flag;
struct statistics_rx rx;
struct statistics_tx tx;
struct statistics_general general;
- } __attribute__ ((packed));
+ } __packed;
+struct iwl_bt_notif_statistics {
+ __le32 flag;
+ struct statistics_rx_bt rx;
+ struct statistics_tx tx;
+ struct statistics_general_bt general;
+} __packed;
/*
* MISSED_BEACONS_NOTIFICATION = 0xa2 (notification only, not a command)
__le32 total_missed_becons;
__le32 num_expected_beacons;
__le32 num_recvd_beacons;
- } __attribute__ ((packed));
+ } __packed;
/******************************************************************************
struct iwl_sensitivity_cmd {
__le16 control; /* always use "1" */
__le16 table[HD_TABLE_SIZE]; /* use HD_* as index */
- } __attribute__ ((packed));
+ } __packed;
/*
*
struct iwl_enhance_sensitivity_cmd {
__le16 control; /* always use "1" */
__le16 enhance_table[ENHANCE_HD_TABLE_SIZE]; /* use HD_* as index */
-} __attribute__ ((packed));
+} __packed;
/**
IWL_PHY_CALIBRATE_CRYSTAL_FRQ_CMD = 15,
IWL_PHY_CALIBRATE_BASE_BAND_CMD = 16,
IWL_PHY_CALIBRATE_TX_IQ_PERD_CMD = 17,
- IWL_PHY_CALIBRATE_CHAIN_NOISE_RESET_CMD = 18,
- IWL_PHY_CALIBRATE_CHAIN_NOISE_GAIN_CMD = 19,
+ IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE = 18,
};
+#define IWL_MAX_PHY_CALIBRATE_TBL_SIZE (253)
#define IWL_CALIB_INIT_CFG_ALL cpu_to_le32(0xffffffff)
__le32 send_res;
__le32 apply_res;
__le32 reserved;
- } __attribute__ ((packed));
+ } __packed;
struct iwl_calib_cfg_status_s {
struct iwl_calib_cfg_elmnt_s once;
struct iwl_calib_cfg_elmnt_s perd;
__le32 flags;
- } __attribute__ ((packed));
+ } __packed;
struct iwl_calib_cfg_cmd {
struct iwl_calib_cfg_status_s ucd_calib_cfg;
struct iwl_calib_cfg_status_s drv_calib_cfg;
__le32 reserved1;
- } __attribute__ ((packed));
+ } __packed;
struct iwl_calib_hdr {
u8 op_code;
u8 first_group;
u8 groups_num;
u8 data_valid;
- } __attribute__ ((packed));
+ } __packed;
struct iwl_calib_cmd {
struct iwl_calib_hdr hdr;
u8 data[0];
- } __attribute__ ((packed));
+ } __packed;
/* IWL_PHY_CALIBRATE_DIFF_GAIN_CMD (7) */
struct iwl_calib_diff_gain_cmd {
s8 diff_gain_b;
s8 diff_gain_c;
u8 reserved1;
- } __attribute__ ((packed));
+ } __packed;
struct iwl_calib_xtal_freq_cmd {
struct iwl_calib_hdr hdr;
u8 cap_pin1;
u8 cap_pin2;
u8 pad[2];
- } __attribute__ ((packed));
+ } __packed;
/* IWL_PHY_CALIBRATE_CHAIN_NOISE_RESET_CMD */
struct iwl_calib_chain_noise_reset_cmd {
u8 delta_gain_1;
u8 delta_gain_2;
u8 pad[2];
- } __attribute__ ((packed));
+ } __packed;
/******************************************************************************
* (12)
u8 on; /* # intervals on while blinking;
* "0", regardless of "off", turns LED off */
u8 reserved;
- } __attribute__ ((packed));
+ } __packed;
/*
* station priority table entries
u8 win_medium_prio;
u8 reserved;
u8 flags;
- } __attribute__ ((packed));
+ } __packed;
/* COEX flag masks */
u8 flags;
u8 reserved[3];
struct iwl_wimax_coex_event_entry sta_prio[COEX_NUM_OF_EVENTS];
- } __attribute__ ((packed));
+ } __packed;
/*
* Coexistence MEDIUM NOTIFICATION
struct iwl_coex_medium_notification {
__le32 status;
__le32 events;
- } __attribute__ ((packed));
+ } __packed;
/*
* Coexistence EVENT Command
u8 flags;
u8 event;
__le16 reserved;
- } __attribute__ ((packed));
+ } __packed;
struct iwl_coex_event_resp {
__le32 status;
- } __attribute__ ((packed));
+ } __packed;
/******************************************************************************
struct iwl_sleep_notification sleep_notif;
struct iwl_spectrum_resp spectrum;
struct iwl_notif_statistics stats;
+ struct iwl_bt_notif_statistics stats_bt;
struct iwl_compressed_ba_resp compressed_ba;
struct iwl_missed_beacon_notif missed_beacon;
struct iwl_coex_medium_notification coex_medium_notif;
__le32 status;
u8 raw[0];
} u;
- } __attribute__ ((packed));
+ } __packed;
int iwl_agn_check_rxon_cmd(struct iwl_priv *priv);
* space more than this */
int high_mark; /* high watermark, stop queue if free
* space less than this */
- } __attribute__ ((packed));
+ } __packed;
/* One for each TFD */
struct iwl_tx_info {
struct iwl_tx_cmd tx;
struct iwl6000_channel_switch_cmd chswitch;
u8 payload[DEF_CMD_PAYLOAD_SIZE];
- } __attribute__ ((packed)) cmd;
- } __attribute__ ((packed));
+ } __packed cmd;
+ } __packed;
#define TFD_MAX_PAYLOAD_SIZE (sizeof(struct iwl_device_cmd))
IWL_UCODE_TLV_INIT_EVTLOG_SIZE = 12,
IWL_UCODE_TLV_INIT_ERRLOG_PTR = 13,
IWL_UCODE_TLV_ENHANCE_SENS_TBL = 14,
+ IWL_UCODE_TLV_PHY_CALIBRATION_SIZE = 15,
};
struct iwl_ucode_tlv {
__le16 alternative; /* see comment */
__le32 length; /* not including type/length fields */
u8 data[0];
- } __attribute__ ((packed));
+ } __packed;
#define IWL_TLV_UCODE_MAGIC 0x0a4c5749
u32 hw_wa_rev;
u8 rev_id;
+ /* EEPROM MAC addresses */
+ struct mac_address addresses[2];
+
/* uCode images, save to reload in case of failure */
int fw_index; /* firmware we're trying to load */
u32 ucode_ver; /* version of ucode, copy of
u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
+ /*
+ * chain noise reset and gain commands are the
+ * two extra calibration commands follows the standard
+ * phy calibration commands
+ */
+ u8 phy_calib_chain_noise_reset_cmd;
+ u8 phy_calib_chain_noise_gain_cmd;
+
struct iwl_notif_statistics statistics;
+ struct iwl_bt_notif_statistics statistics_bt;
#ifdef CONFIG_IWLWIFI_DEBUGFS
struct iwl_notif_statistics accum_statistics;
struct iwl_notif_statistics delta_statistics;
struct iwl_notif_statistics max_delta;
+ struct iwl_bt_notif_statistics accum_statistics_bt;
+ struct iwl_bt_notif_statistics delta_statistics_bt;
+ struct iwl_bt_notif_statistics max_delta_bt;
#endif
} _agn;
#endif
struct iwl_eeprom_channel {
u8 flags; /* EEPROM_CHANNEL_* flags copied from EEPROM */
s8 max_power_avg; /* max power (dBm) on this chnl, limit 31 */
- } __attribute__ ((packed));
+ } __packed;
/**
* iwl_eeprom_enhanced_txpwr structure
s8 reserved;
s8 mimo2_max;
s8 mimo3_max;
- } __attribute__ ((packed));
+ } __packed;
/* 3945 Specific */
#define EEPROM_3945_EEPROM_VERSION (0x2f)
u8 gain_idx; /* Index into gain table */
u8 actual_pow; /* Measured RF output power, half-dBm */
s8 pa_det; /* Power amp detector level (not used) */
- } __attribute__ ((packed));
+ } __packed;
/*
struct iwl_eeprom_calib_measure
measurements[EEPROM_TX_POWER_TX_CHAINS]
[EEPROM_TX_POWER_MEASUREMENTS];
- } __attribute__ ((packed));
+ } __packed;
/*
* txpower subband info.
u8 ch_to; /* channel number of highest channel in subband */
struct iwl_eeprom_calib_ch_info ch1;
struct iwl_eeprom_calib_ch_info ch2;
- } __attribute__ ((packed));
+ } __packed;
/*
__le16 voltage; /* signed */
struct iwl_eeprom_calib_subband_info
band_info[EEPROM_TX_POWER_BANDS];
- } __attribute__ ((packed));
+ } __packed;
#define ADDRESS_MSK 0x0000FFFF
#define EEPROM_WOWLAN_MODE (2*0x47) /* 2 bytes */
#define EEPROM_RADIO_CONFIG (2*0x48) /* 2 bytes */
#define EEPROM_3945_M_VERSION (2*0x4A) /* 1 bytes */
+#define EEPROM_NUM_MAC_ADDRESS (2*0x4C) /* 2 bytes */
/* The following masks are to be applied on EEPROM_RADIO_CONFIG */
#define EEPROM_RF_CFG_TYPE_MSK(x) (x & 0x3) /* bits 0-1 */
u8 pktdelay_2ms;
/* reserved */
u8 reserved1;
- } __attribute__ ((packed));
+ } __packed;
/* RxPD Descriptor */
struct rxpd {
u8 bss_type;
/* BSS number */
u8 bss_num;
- } __attribute__ ((packed)) bss;
- } __attribute__ ((packed)) u;
+ } __packed bss;
+ } __packed u;
/* SNR */
u8 snr;
/* Pkt Priority */
u8 priority;
u8 reserved[3];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_header {
__le16 command;
__le16 size;
__le16 seqnum;
__le16 result;
- } __attribute__ ((packed));
+ } __packed;
/* Generic structure to hold all key types. */
struct enc_key {
struct lbs_offset_value {
u32 offset;
u32 value;
- } __attribute__ ((packed));
+ } __packed;
#define MRVDRV_MAX_TRIPLET_802_11D 83
u8 countrycode[COUNTRY_CODE_LEN];
struct ieee80211_country_ie_triplet triplet[1];
-} __attribute__ ((packed));
+} __packed;
struct cmd_ds_802_11d_domain_info {
__le16 action;
struct mrvl_ie_domain_param_set domain;
-} __attribute__ ((packed));
+} __packed;
struct lbs_802_11d_domain_reg {
/** Country code*/
/** No. of triplet*/
u8 no_triplet;
struct ieee80211_country_ie_triplet triplet[MRVDRV_MAX_TRIPLET_802_11D];
-} __attribute__ ((packed));
+} __packed;
/*
* Define data structure for CMD_GET_HW_SPEC
/*FW/HW capability */
__le32 fwcapinfo;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_subscribe_event {
struct cmd_header hdr;
* bump this up a bit.
*/
uint8_t tlv[128];
- } __attribute__ ((packed));
+ } __packed;
/*
* This scan handle Country Information IE(802.11d compliant)
uint8_t bsstype;
uint8_t bssid[ETH_ALEN];
uint8_t tlvbuffer[0];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_scan_rsp {
struct cmd_header hdr;
__le16 bssdescriptsize;
uint8_t nr_sets;
uint8_t bssdesc_and_tlvbuffer[0];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_get_log {
struct cmd_header hdr;
__le32 fcserror;
__le32 txframe;
__le32 wepundecryptable;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_mac_control {
struct cmd_header hdr;
__le16 action;
u16 reserved;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_mac_multicast_adr {
struct cmd_header hdr;
__le16 action;
__le16 nr_of_adrs;
u8 maclist[ETH_ALEN * MRVDRV_MAX_MULTICAST_LIST_SIZE];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_authenticate {
struct cmd_header hdr;
u8 bssid[ETH_ALEN];
u8 authtype;
u8 reserved[10];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_deauthenticate {
struct cmd_header hdr;
u8 macaddr[ETH_ALEN];
__le16 reasoncode;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_associate {
struct cmd_header hdr;
__le16 bcnperiod;
u8 dtimperiod;
u8 iebuf[512]; /* Enough for required and most optional IEs */
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_associate_response {
struct cmd_header hdr;
__le16 statuscode;
__le16 aid;
u8 iebuf[512];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_set_wep {
struct cmd_header hdr;
/* 40, 128bit or TXWEP */
uint8_t keytype[4];
uint8_t keymaterial[4][16];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_snmp_mib {
struct cmd_header hdr;
__le16 oid;
__le16 bufsize;
u8 value[128];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_mac_reg_access {
__le16 action;
__le16 offset;
__le32 value;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_bbp_reg_access {
__le16 action;
__le16 offset;
u8 value;
u8 reserved[3];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_rf_reg_access {
__le16 action;
__le16 offset;
u8 value;
u8 reserved[3];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_radio_control {
struct cmd_header hdr;
__le16 action;
__le16 control;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_beacon_control {
__le16 action;
__le16 beacon_enable;
__le16 beacon_period;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_sleep_params {
struct cmd_header hdr;
/* reserved field, should be set to zero */
__le16 reserved;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_rf_channel {
struct cmd_header hdr;
__le16 rftype; /* unused */
__le16 reserved; /* unused */
u8 channellist[32]; /* unused */
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_rssi {
/* weighting factor */
__le16 reserved_0;
__le16 reserved_1;
__le16 reserved_2;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_rssi_rsp {
__le16 SNR;
__le16 noisefloor;
__le16 avgSNR;
__le16 avgnoisefloor;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_mac_address {
struct cmd_header hdr;
__le16 action;
u8 macadd[ETH_ALEN];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_rf_tx_power {
struct cmd_header hdr;
__le16 curlevel;
s8 maxlevel;
s8 minlevel;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_monitor_mode {
__le16 action;
__le16 mode;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_set_boot2_ver {
struct cmd_header hdr;
__le16 action;
__le16 version;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_fw_wake_method {
struct cmd_header hdr;
__le16 action;
__le16 method;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_ps_mode {
__le16 action;
__le16 multipledtim;
__le16 reserved;
__le16 locallisteninterval;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_confirm_sleep {
struct cmd_header hdr;
__le16 multipledtim;
__le16 reserved;
__le16 locallisteninterval;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_data_rate {
struct cmd_header hdr;
__le16 action;
__le16 reserved;
u8 rates[MAX_RATES];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_rate_adapt_rateset {
struct cmd_header hdr;
__le16 action;
__le16 enablehwauto;
__le16 bitmap;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_ad_hoc_start {
struct cmd_header hdr;
__le16 capability;
u8 rates[MAX_RATES];
u8 tlv_memory_size_pad[100];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_ad_hoc_result {
struct cmd_header hdr;
u8 pad[3];
u8 bssid[ETH_ALEN];
- } __attribute__ ((packed));
+ } __packed;
struct adhoc_bssdesc {
u8 bssid[ETH_ALEN];
* Adhoc join command and will cause a binary layout mismatch with
* the firmware
*/
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_ad_hoc_join {
struct cmd_header hdr;
struct adhoc_bssdesc bss;
__le16 failtimeout; /* Reserved on v9 and later */
__le16 probedelay; /* Reserved on v9 and later */
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_ad_hoc_stop {
struct cmd_header hdr;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_enable_rsn {
struct cmd_header hdr;
__le16 action;
__le16 enable;
- } __attribute__ ((packed));
+ } __packed;
struct MrvlIEtype_keyParamSet {
/* type ID */
/* key material of size keylen */
u8 key[32];
- } __attribute__ ((packed));
+ } __packed;
#define MAX_WOL_RULES 16
__le16 reserve;
__be32 sig_mask;
__be32 signature;
- } __attribute__ ((packed));
+ } __packed;
struct wol_config {
uint8_t action;
uint8_t no_rules_in_cmd;
uint8_t result;
struct host_wol_rule rule[MAX_WOL_RULES];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_host_sleep {
struct cmd_header hdr;
uint8_t gpio;
uint16_t gap;
struct wol_config wol_conf;
- } __attribute__ ((packed));
+ } __packed;
__le16 action;
struct MrvlIEtype_keyParamSet keyParamSet[2];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_eeprom_access {
struct cmd_header hdr;
/* firmware says it returns a maximum of 20 bytes */
#define LBS_EEPROM_READ_LEN 20
u8 value[LBS_EEPROM_READ_LEN];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_tpc_cfg {
struct cmd_header hdr;
int8_t P1;
int8_t P2;
uint8_t usesnr;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_pa_cfg {
int8_t P0;
int8_t P1;
int8_t P2;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_led_ctrl {
__le16 action;
__le16 numled;
u8 data[256];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_802_11_afc {
__le16 afc_auto;
__le16 carrier_offset; /* signed */
};
};
- } __attribute__ ((packed));
+ } __packed;
struct cmd_tx_rate_query {
__le16 txrate;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_get_tsf {
__le64 tsfvalue;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_bt_access {
__le16 action;
__le32 id;
u8 addr1[ETH_ALEN];
u8 addr2[ETH_ALEN];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_fwt_access {
__le16 action;
__le32 snr;
__le32 references;
u8 prec[ETH_ALEN];
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_mesh_config {
struct cmd_header hdr;
__le16 type;
__le16 length;
u8 data[128]; /* last position reserved */
- } __attribute__ ((packed));
+ } __packed;
struct cmd_ds_mesh_access {
struct cmd_header hdr;
__le16 action;
__le32 data[32]; /* last position reserved */
- } __attribute__ ((packed));
+ } __packed;
/* Number of stats counters returned by the firmware */
#define MESH_STATS_NUM 8
struct cmd_ds_fwt_access fwt;
struct cmd_ds_802_11_beacon_control bcn_ctrl;
} params;
- } __attribute__ ((packed));
+ } __packed;
#endif
#define MWL8K_CMD_SET_NEW_STN 0x1111 /* per-vif */
#define MWL8K_CMD_UPDATE_STADB 0x1123
-static const char *mwl8k_cmd_name(u16 cmd, char *buf, int bufsize)
+static const char *mwl8k_cmd_name(__le16 cmd, char *buf, int bufsize)
{
+ u16 command = le16_to_cpu(cmd);
+
#define MWL8K_CMDNAME(x) case MWL8K_CMD_##x: do {\
snprintf(buf, bufsize, "%s", #x);\
return buf;\
} while (0)
- switch (cmd & ~0x8000) {
+ switch (command & ~0x8000) {
MWL8K_CMDNAME(CODE_DNLD);
MWL8K_CMDNAME(GET_HW_SPEC);
MWL8K_CMDNAME(SET_HW_SPEC);
__u8 macid;
__le16 result;
char payload[0];
- } __attribute__((packed));
+ } __packed;
/*
* Firmware loading.
__le16 fwlen;
struct ieee80211_hdr wh;
char data[0];
- } __attribute__((packed));
+ } __packed;
/* Routines to add/remove DMA header from skb. */
static inline void mwl8k_remove_dma_header(struct sk_buff *skb, __le16 qos)
__u8 rx_status;
__u8 channel;
__u8 rx_ctrl;
- } __attribute__((packed));
+ } __packed;
#define MWL8K_8366_AP_RATE_INFO_MCS_FORMAT 0x80
#define MWL8K_8366_AP_RATE_INFO_40MHZ 0x40
__u8 rx_ctrl;
__u8 rx_status;
__u8 pad2[2];
- } __attribute__((packed));
+ } __packed;
#define MWL8K_STA_RATE_INFO_SHORTPRE 0x8000
#define MWL8K_STA_RATE_INFO_ANTSELECT(x) (((x) >> 11) & 0x3)
__le16 rate_info;
__u8 peer_id;
__u8 tx_frag_cnt;
- } __attribute__((packed));
+ } __packed;
#define MWL8K_TX_DESCS 128
unsigned long timeout = 0;
u8 buf[32];
- cmd->result = 0xffff;
+ cmd->result = (__force __le16) 0xffff;
dma_size = le16_to_cpu(cmd->length);
dma_addr = pci_map_single(priv->pdev, cmd, dma_size,
PCI_DMA_BIDIRECTIONAL);
__le32 caps2;
__le32 num_tx_desc_per_queue;
__le32 total_rxd;
- } __attribute__((packed));
+ } __packed;
#define MWL8K_CAP_MAX_AMSDU 0x20000000
#define MWL8K_CAP_GREENFIELD 0x08000000
__le32 wcbbase1;
__le32 wcbbase2;
__le32 wcbbase3;
- } __attribute__((packed));
+ } __packed;
static int mwl8k_cmd_get_hw_spec_ap(struct ieee80211_hw *hw)
{
priv->sta_macids_supported = 0x00000000;
off = le32_to_cpu(cmd->wcbbase0) & 0xffff;
- iowrite32(cpu_to_le32(priv->txq[0].txd_dma), priv->sram + off);
+ iowrite32(priv->txq[0].txd_dma, priv->sram + off);
off = le32_to_cpu(cmd->rxwrptr) & 0xffff;
- iowrite32(cpu_to_le32(priv->rxq[0].rxd_dma), priv->sram + off);
+ iowrite32(priv->rxq[0].rxd_dma, priv->sram + off);
off = le32_to_cpu(cmd->rxrdptr) & 0xffff;
- iowrite32(cpu_to_le32(priv->rxq[0].rxd_dma), priv->sram + off);
+ iowrite32(priv->rxq[0].rxd_dma, priv->sram + off);
off = le32_to_cpu(cmd->wcbbase1) & 0xffff;
- iowrite32(cpu_to_le32(priv->txq[1].txd_dma), priv->sram + off);
+ iowrite32(priv->txq[1].txd_dma, priv->sram + off);
off = le32_to_cpu(cmd->wcbbase2) & 0xffff;
- iowrite32(cpu_to_le32(priv->txq[2].txd_dma), priv->sram + off);
+ iowrite32(priv->txq[2].txd_dma, priv->sram + off);
off = le32_to_cpu(cmd->wcbbase3) & 0xffff;
- iowrite32(cpu_to_le32(priv->txq[3].txd_dma), priv->sram + off);
+ iowrite32(priv->txq[3].txd_dma, priv->sram + off);
}
kfree(cmd);
__le32 flags;
__le32 num_tx_desc_per_queue;
__le32 total_rxd;
- } __attribute__((packed));
+ } __packed;
#define MWL8K_SET_HW_SPEC_FLAG_HOST_DECR_MGMT 0x00000080
#define MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_PROBERESP 0x00000020
struct mwl8k_cmd_get_stat {
struct mwl8k_cmd_pkt header;
__le32 stats[64];
- } __attribute__((packed));
+ } __packed;
#define MWL8K_STAT_ACK_FAILURE 9
#define MWL8K_STAT_RTS_FAILURE 12
__le16 action;
__le16 control;
__le16 radio_on;
- } __attribute__((packed));
+ } __packed;
static int
mwl8k_cmd_radio_control(struct ieee80211_hw *hw, bool enable, bool force)
__le16 current_level;
__le16 reserved;
__le16 power_level_list[MWL8K_TX_POWER_LEVEL_TOTAL];
- } __attribute__((packed));
+ } __packed;
static int mwl8k_cmd_rf_tx_power(struct ieee80211_hw *hw, int dBm)
{
struct mwl8k_cmd_pkt header;
__le16 antenna;
__le16 mode;
- } __attribute__((packed));
+ } __packed;
#define MWL8K_RF_ANTENNA_RX 1
#define MWL8K_RF_ANTENNA_TX 2
*/
struct mwl8k_cmd_set_pre_scan {
struct mwl8k_cmd_pkt header;
- } __attribute__((packed));
+ } __packed;
static int mwl8k_cmd_set_pre_scan(struct ieee80211_hw *hw)
{
struct mwl8k_cmd_pkt header;
__le32 isibss;
__u8 bssid[ETH_ALEN];
- } __attribute__((packed));
+ } __packed;
static int
mwl8k_cmd_set_post_scan(struct ieee80211_hw *hw, const __u8 *mac)
__le16 action;
__u8 current_channel;
__le32 channel_flags;
- } __attribute__((packed));
+ } __packed;
static int mwl8k_cmd_set_rf_channel(struct ieee80211_hw *hw,
struct ieee80211_conf *conf)
__u8 bssid[ETH_ALEN];
__le16 protection_mode;
__u8 supp_rates[14];
- } __attribute__((packed));
+ } __packed;
static void legacy_rate_mask_to_array(u8 *rates, u32 mask)
{
/* Bitmap for supported MCS codes. */
__u8 mcs_set[16];
__u8 reserved[16];
- } __attribute__((packed));
+ } __packed;
static int
mwl8k_cmd_set_rate(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
struct mwl8k_cmd_pkt header;
__le32 sleep_interval; /* Number of beacon periods to sleep */
__u8 beacon_data[MWL8K_FJ_BEACON_MAXLEN];
- } __attribute__((packed));
+ } __packed;
static int mwl8k_cmd_finalize_join(struct ieee80211_hw *hw, void *frame,
int framelen, int dtim)
struct mwl8k_cmd_pkt header;
__le16 action;
__le16 threshold;
- } __attribute__((packed));
+ } __packed;
static int
mwl8k_cmd_set_rts_threshold(struct ieee80211_hw *hw, int rts_thresh)
struct mwl8k_cmd_pkt header;
__le16 action;
__u8 short_slot;
- } __attribute__((packed));
+ } __packed;
static int mwl8k_cmd_set_slot(struct ieee80211_hw *hw, bool short_slot_time)
{
__u8 txq;
} sta;
};
- } __attribute__((packed));
+ } __packed;
#define MWL8K_SET_EDCA_CW 0x01
#define MWL8K_SET_EDCA_TXOP 0x02
struct mwl8k_cmd_set_wmm_mode {
struct mwl8k_cmd_pkt header;
__le16 action;
- } __attribute__((packed));
+ } __packed;
static int mwl8k_cmd_set_wmm_mode(struct ieee80211_hw *hw, bool enable)
{
__le32 action;
__u8 rx_antenna_map;
__u8 tx_antenna_map;
- } __attribute__((packed));
+ } __packed;
static int mwl8k_cmd_mimo_config(struct ieee80211_hw *hw, __u8 rx, __u8 tx)
{
__le32 rate_type;
__le32 reserved1;
__le32 reserved2;
- } __attribute__((packed));
+ } __packed;
#define MWL8K_USE_AUTO_RATE 0x0002
#define MWL8K_UCAST_RATE 0
u8 multicast_rate;
u8 multicast_rate_type;
u8 management_rate;
- } __attribute__((packed));
+ } __packed;
static int
mwl8k_cmd_use_fixed_rate_ap(struct ieee80211_hw *hw, int mcast, int mgmt)
struct mwl8k_cmd_enable_sniffer {
struct mwl8k_cmd_pkt header;
__le32 action;
- } __attribute__((packed));
+ } __packed;
static int mwl8k_cmd_enable_sniffer(struct ieee80211_hw *hw, bool enable)
{
} mbss;
__u8 mac_addr[ETH_ALEN];
};
- } __attribute__((packed));
+ } __packed;
#define MWL8K_MAC_TYPE_PRIMARY_CLIENT 0
#define MWL8K_MAC_TYPE_SECONDARY_CLIENT 1
struct mwl8k_cmd_pkt header;
__le16 action;
__le16 mode;
- } __attribute__((packed));
+ } __packed;
static int mwl8k_cmd_set_rateadapt_mode(struct ieee80211_hw *hw, __u16 mode)
{
struct mwl8k_cmd_bss_start {
struct mwl8k_cmd_pkt header;
__le32 enable;
- } __attribute__((packed));
+ } __packed;
static int mwl8k_cmd_bss_start(struct ieee80211_hw *hw,
struct ieee80211_vif *vif, int enable)
__u8 add_qos_info;
__u8 is_qos_sta;
__le32 fw_sta_ptr;
- } __attribute__((packed));
+ } __packed;
#define MWL8K_STA_ACTION_ADD 0
#define MWL8K_STA_ACTION_REMOVE 2
__le16 control1;
__le16 control2;
__le16 control3;
- } __attribute__((packed));
+ } __packed;
struct peer_capability_info {
/* Peer type - AP vs. STA. */
__u8 pad2;
__u8 station_id;
__le16 amsdu_enabled;
- } __attribute__((packed));
+ } __packed;
struct mwl8k_cmd_update_stadb {
struct mwl8k_cmd_pkt header;
/* Peer info - valid during add/update. */
struct peer_capability_info peer_info;
- } __attribute__((packed));
+ } __packed;
#define MWL8K_STA_DB_MODIFY_ENTRY 1
#define MWL8K_STA_DB_DEL_ENTRY 2
p->peer_type = MWL8K_PEER_TYPE_ACCESSPOINT;
p->basic_caps = cpu_to_le16(vif->bss_conf.assoc_capability);
p->ht_support = sta->ht_cap.ht_supported;
- p->ht_caps = sta->ht_cap.cap;
+ p->ht_caps = cpu_to_le16(sta->ht_cap.cap);
p->extended_ht_caps = (sta->ht_cap.ampdu_factor & 3) |
((sta->ht_cap.ampdu_density & 7) << 2);
if (hw->conf.channel->band == IEEE80211_BAND_2GHZ)
/* SNAP */
u8 oui[3];
__be16 ethertype;
- } __attribute__ ((packed));
+ } __packed;
struct ez_usb_fw {
u16 size;
__le16 hermes_len;
__le16 hermes_rid;
u8 data[0];
- } __attribute__ ((packed));
+ } __packed;
/* Table of devices that work or may work with this driver */
static struct usb_device_id ezusb_table[] = {
ezusb_ctx_complete(list_entry(item,
struct request_context, list));
- if (upriv->read_urb->status == -EINPROGRESS)
+ if (upriv->read_urb && upriv->read_urb->status == -EINPROGRESS)
printk(KERN_ERR PFX "Some URB in progress\n");
mutex_unlock(&upriv->mtx);
- kfree(upriv->read_urb->transfer_buffer);
- if (upriv->bap_buf != NULL)
- kfree(upriv->bap_buf);
- if (upriv->read_urb != NULL)
+ if (upriv->read_urb) {
+ kfree(upriv->read_urb->transfer_buffer);
usb_free_urb(upriv->read_urb);
+ }
+ kfree(upriv->bap_buf);
if (upriv->dev) {
struct orinoco_private *priv = ndev_priv(upriv->dev);
orinoco_if_del(priv);
u8 reserved_22[4];
__le16 TALLY_CNT;
u8 TALLY_SEL;
- } __attribute__((packed));
+ } __packed;
struct rtl818x_rf_ops {
char *name;
void (*stop)(struct ieee80211_hw *);
void (*set_chan)(struct ieee80211_hw *, struct ieee80211_conf *);
void (*conf_erp)(struct ieee80211_hw *, struct ieee80211_bss_conf *);
+ u8 (*calc_rssi)(u8 agc, u8 sq);
};
/**
u16 status;
/* payload */
u8 data[0];
- } __attribute__ ((packed));
+ } __packed;
struct wl1251_command {
struct wl1251_cmd_header header;
#define WL1251_SCAN_NUM_PROBES 3
struct wl1251_scan_parameters {
- u32 rx_config_options;
- u32 rx_filter_options;
+ __le32 rx_config_options;
+ __le32 rx_filter_options;
/*
* Scan options:
* bit 2: voice mode, 0 for normal scan.
* bit 3: scan priority, 1 for high priority.
*/
- u16 scan_options;
+ __le16 scan_options;
/* Number of channels to scan */
u8 num_channels;
u8 num_probe_requests;
/* Rate and modulation for probe requests */
- u16 tx_rate;
+ __le16 tx_rate;
u8 tid_trigger;
u8 ssid_len;
u8 ssid[32];
- } __attribute__ ((packed));
+ } __packed;
struct wl1251_scan_ch_parameters {
- u32 min_duration; /* in TU */
- u32 max_duration; /* in TU */
+ __le32 min_duration; /* in TU */
+ __le32 max_duration; /* in TU */
u32 bssid_lsb;
u16 bssid_msb;
u8 tx_power_att;
u8 channel;
u8 pad[3];
- } __attribute__ ((packed));
+ } __packed;
/* SCAN parameters */
#define SCAN_MAX_NUM_OF_CHANNELS 16
struct wl1251_scan_parameters params;
struct wl1251_scan_ch_parameters channels[SCAN_MAX_NUM_OF_CHANNELS];
- } __attribute__ ((packed));
+ } __packed;
enum {
BSS_TYPE_IBSS = 0,
u8 tx_mgt_frame_rate; /* OBSOLETE */
u8 tx_mgt_frame_mod; /* OBSOLETE */
u8 reserved;
- } __attribute__ ((packed));
+ } __packed;
struct cmd_enabledisable_path {
struct wl1251_cmd_header header;
u8 channel;
u8 padding[3];
- } __attribute__ ((packed));
+ } __packed;
#define WL1251_MAX_TEMPLATE_SIZE 300
__le16 size;
u8 data[0];
- } __attribute__ ((packed));
+ } __packed;
#define TIM_ELE_ID 5
#define PARTIAL_VBM_MAX 251
u8 dtim_period;
u8 bitmap_ctrl;
u8 pvb_field[PARTIAL_VBM_MAX]; /* Partial Virtual Bitmap */
- } __attribute__ ((packed));
+ } __packed;
/* Virtual Bit Map update */
struct wl1251_cmd_vbm_update {
__le16 len;
u8 padding[2];
struct wl1251_tim tim;
- } __attribute__ ((packed));
+ } __packed;
enum wl1251_cmd_ps_mode {
STATION_ACTIVE_MODE,
u8 hang_over_period;
u16 null_data_rate;
u8 pad[2];
- } __attribute__ ((packed));
+ } __packed;
struct wl1251_cmd_trigger_scan_to {
struct wl1251_cmd_header header;
u8 key[MAX_KEY_SIZE];
u16 ac_seq_num16[NUM_ACCESS_CATEGORIES_COPY];
u32 ac_seq_num32[NUM_ACCESS_CATEGORIES_COPY];
- } __attribute__ ((packed));
+ } __packed;
#endif /* __WL1251_CMD_H__ */
unsigned xfer_pad:1;
unsigned reserved:7;
- } __attribute__ ((packed));
+ } __packed;
struct tx_double_buffer_desc {
/* Length of payload, including headers. */
- u16 length;
+ __le16 length;
/*
* A bit mask that specifies the initial rate to be used
* 0x0800 - 48Mbits
* 0x1000 - 54Mbits
*/
- u16 rate;
+ __le16 rate;
/* Time in us that a packet can spend in the target */
- u32 expiry_time;
+ __le32 expiry_time;
/* index of the TX queue used for this packet */
u8 xmit_queue;
* The FW should cut the packet into fragments
* of this size.
*/
- u16 frag_threshold;
+ __le16 frag_threshold;
/* Numbers of HW queue blocks to be allocated */
u8 num_mem_blocks;
u8 reserved;
- } __attribute__ ((packed));
+ } __packed;
enum {
TX_SUCCESS = 0,
/* See done_1 */
u8 done_2;
- } __attribute__ ((packed));
+ } __packed;
static inline int wl1251_tx_get_queue(int queue)
{
char priv[0] __attribute__((__aligned__(NETDEV_ALIGN)));
};
- #ifdef CONFIG_NET_NS
static inline struct net *wiphy_net(struct wiphy *wiphy)
{
- return wiphy->_net;
+ return read_pnet(&wiphy->_net);
}
static inline void wiphy_net_set(struct wiphy *wiphy, struct net *net)
{
- wiphy->_net = net;
+ write_pnet(&wiphy->_net, net);
}
- #else
- static inline struct net *wiphy_net(struct wiphy *wiphy)
- {
- return &init_net;
- }
-
- static inline void wiphy_net_set(struct wiphy *wiphy, struct net *net)
- {
- }
- #endif
/**
* wiphy_priv - return priv from wiphy
struct iw_request_info *info,
struct sockaddr *ap_addr, char *extra);
+int cfg80211_wext_siwpmksa(struct net_device *dev,
+ struct iw_request_info *info,
+ struct iw_point *data, char *extra);
+
/*
* callbacks for asynchronous cfg80211 methods, notification
* functions and BSS handling helpers
struct net_device *dev,
u8 key_idx)
{
- struct ieee80211_sub_if_data *sdata;
-
- rcu_read_lock();
+ struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
- sdata = IEEE80211_DEV_TO_SUB_IF(dev);
ieee80211_set_default_mgmt_key(sdata, key_idx);
- rcu_read_unlock();
-
return 0;
}
u8 ssap; /* 0 */
u8 control;
u8 xid_info[3];
- } __attribute__ ((packed));
+ } __packed;
static void ieee80211_send_layer2_update(struct sta_info *sta)
{
return -EINVAL;
}
- /* enable WMM or activate new settings */
- local->hw.conf.flags |= IEEE80211_CONF_QOS;
- drv_config(local, IEEE80211_CONF_CHANGE_QOS);
-
return 0;
}
int last_cqm_event_signal;
};
-enum ieee80211_ibss_request {
- IEEE80211_IBSS_REQ_RUN = 0,
-};
-
struct ieee80211_if_ibss {
struct timer_list timer;
- unsigned long request;
+ struct mutex mtx;
+
unsigned long last_scan_completed;
u32 basic_rates;
u8 padding_for_rate;
__le16 tx_flags;
u8 data_retries;
- } __attribute__ ((packed));
+ } __packed;
/* HT */
projects / ~andy / linux / commitdiff