int wl1251_boot_run_firmware(struct wl1251 *wl)
 {
        int loop, ret;
-       u32 chip_id, interrupt;
+       u32 chip_id, acx_intr;
 
        wl1251_boot_set_ecpu_ctrl(wl, ECPU_CONTROL_HALT);
 
        loop = 0;
        while (loop++ < INIT_LOOP) {
                udelay(INIT_LOOP_DELAY);
-               interrupt = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
+               acx_intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
 
-               if (interrupt == 0xffffffff) {
+               if (acx_intr == 0xffffffff) {
                        wl1251_error("error reading hardware complete "
                                     "init indication");
                        return -EIO;
                }
                /* check that ACX_INTR_INIT_COMPLETE is enabled */
-               else if (interrupt & WL1251_ACX_INTR_INIT_COMPLETE) {
+               else if (acx_intr & WL1251_ACX_INTR_INIT_COMPLETE) {
                        wl1251_reg_write32(wl, ACX_REG_INTERRUPT_ACK,
                                           WL1251_ACX_INTR_INIT_COMPLETE);
                        break;
 
 #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;
 } __attribute__ ((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;
 
 
        frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
        tx_hdr->frag_threshold = cpu_to_le16(frag_threshold);
 
-       payload_len = tx_hdr->length + MAX_MSDU_SECURITY_LENGTH;
+       payload_len = le16_to_cpu(tx_hdr->length) + MAX_MSDU_SECURITY_LENGTH;
 
        if (payload_len > frag_threshold) {
                mem_blocks_per_frag =
        if (control->control.hw_key &&
            control->control.hw_key->alg == ALG_TKIP) {
                int hdrlen;
-               u16 fc;
+               __le16 fc;
+               u16 length;
                u8 *pos;
 
-               fc = *(u16 *)(skb->data + sizeof(*tx_hdr));
-               tx_hdr->length += WL1251_TKIP_IV_SPACE;
+               fc = *(__le16 *)(skb->data + sizeof(*tx_hdr));
+               length = le16_to_cpu(tx_hdr->length) + WL1251_TKIP_IV_SPACE;
+               tx_hdr->length = cpu_to_le16(length);
 
                hdrlen = ieee80211_hdrlen(fc);
 
 
 
 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;