ipw2200 trivial annotations

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

diff --git a/drivers/net/wireless/ipw2200.c b/drivers/net/wireless/ipw2200.c
index 7c45ba53f379bdf8c937b839e423a7fc24e881d9..7ac57f1fc18b637564e52e657cb91e91e9df9001 100644 (file)
--- a/drivers/net/wireless/ipw2200.c
+++ b/drivers/net/wireless/ipw2200.c
@@ -2403,14 +2403,13 @@ static int ipw_set_random_seed(struct ipw_priv *priv)
 
 static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
 {
+       __le32 v = cpu_to_le32(phy_off);
        if (!priv) {
                IPW_ERROR("Invalid args\n");
                return -1;
        }
 
-       phy_off = cpu_to_le32(phy_off);
-       return ipw_send_cmd_pdu(priv, IPW_CMD_CARD_DISABLE, sizeof(phy_off),
-                               &phy_off);
+       return ipw_send_cmd_pdu(priv, IPW_CMD_CARD_DISABLE, sizeof(v), &v);
 }
 
 static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
@@ -2499,7 +2498,7 @@ static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
 
 static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
 {
-       u32 param;
+       __le32 param;
 
        if (!priv) {
                IPW_ERROR("Invalid args\n");
@@ -2510,17 +2509,16 @@ static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
         * level */
        switch (mode) {
        case IPW_POWER_BATTERY:
-               param = IPW_POWER_INDEX_3;
+               param = cpu_to_le32(IPW_POWER_INDEX_3);
                break;
        case IPW_POWER_AC:
-               param = IPW_POWER_MODE_CAM;
+               param = cpu_to_le32(IPW_POWER_MODE_CAM);
                break;
        default:
-               param = mode;
+               param = cpu_to_le32(mode);
                break;
        }
 
-       param = cpu_to_le32(param);
        return ipw_send_cmd_pdu(priv, IPW_CMD_POWER_MODE, sizeof(param),
                                &param);
 }
@@ -2654,13 +2652,13 @@ static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
 static void ipw_eeprom_init_sram(struct ipw_priv *priv)
 {
        int i;
-       u16 *eeprom = (u16 *) priv->eeprom;
+       __le16 *eeprom = (__le16 *) priv->eeprom;
 
        IPW_DEBUG_TRACE(">>\n");
 
        /* read entire contents of eeprom into private buffer */
        for (i = 0; i < 128; i++)
-               eeprom[i] = le16_to_cpu(eeprom_read_u16(priv, (u8) i));
+               eeprom[i] = cpu_to_le16(eeprom_read_u16(priv, (u8) i));
 
        /*
           If the data looks correct, then copy it to our private
@@ -3040,17 +3038,17 @@ static void ipw_arc_release(struct ipw_priv *priv)
 }
 
 struct fw_chunk {
-       u32 address;
-       u32 length;
+       __le32 address;
+       __le32 length;
 };
 
 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
 {
        int rc = 0, i, addr;
        u8 cr = 0;
-       u16 *image;
+       __le16 *image;
 
-       image = (u16 *) data;
+       image = (__le16 *) data;
 
        IPW_DEBUG_TRACE(">> \n");
 
@@ -3097,7 +3095,7 @@ static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
        /* load new ipw uCode */
        for (i = 0; i < len / 2; i++)
                ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
-                               cpu_to_le16(image[i]));
+                               le16_to_cpu(image[i]));
 
        /* enable DINO */
        ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
@@ -3116,11 +3114,11 @@ static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
 
        if (cr & DINO_RXFIFO_DATA) {
                /* alive_command_responce size is NOT multiple of 4 */
-               u32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
+               __le32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
 
                for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
                        response_buffer[i] =
-                           le32_to_cpu(ipw_read_reg32(priv,
+                           cpu_to_le32(ipw_read_reg32(priv,
                                                       IPW_BASEBAND_RX_FIFO_READ));
                memcpy(&priv->dino_alive, response_buffer,
                       sizeof(priv->dino_alive));
@@ -4396,9 +4394,10 @@ static void ipw_rx_notification(struct ipw_priv *priv,
                                       struct ipw_rx_notification *notif)
 {
        DECLARE_MAC_BUF(mac);
+       u16 size = le16_to_cpu(notif->size);
        notif->size = le16_to_cpu(notif->size);
 
-       IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
+       IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, size);
 
        switch (notif->subtype) {
        case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
@@ -4453,20 +4452,17 @@ static void ipw_rx_notification(struct ipw_priv *priv,
                                                if ((sizeof
                                                     (struct
                                                      ieee80211_assoc_response)
-                                                    <= notif->size)
-                                                   && (notif->size <= 2314)) {
+                                                    <= size)
+                                                   && (size <= 2314)) {
                                                        struct
                                                        ieee80211_rx_stats
                                                            stats = {
-                                                               .len =
-                                                                   notif->
-                                                                   size - 1,
+                                                               .len = size - 1,
                                                        };
 
                                                        IPW_DEBUG_QOS
                                                            ("QoS Associate "
-                                                            "size %d\n",
-                                                            notif->size);
+                                                            "size %d\n", size);
                                                        ieee80211_rx_mgt(priv->
                                                                         ieee,
                                                                         (struct
@@ -4671,20 +4667,20 @@ static void ipw_rx_notification(struct ipw_priv *priv,
                        struct notif_channel_result *x =
                            &notif->u.channel_result;
 
-                       if (notif->size == sizeof(*x)) {
+                       if (size == sizeof(*x)) {
                                IPW_DEBUG_SCAN("Scan result for channel %d\n",
                                               x->channel_num);
                        } else {
                                IPW_DEBUG_SCAN("Scan result of wrong size %d "
                                               "(should be %zd)\n",
-                                              notif->size, sizeof(*x));
+                                              size, sizeof(*x));
                        }
                        break;
                }
 
        case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
                        struct notif_scan_complete *x = &notif->u.scan_complete;
-                       if (notif->size == sizeof(*x)) {
+                       if (size == sizeof(*x)) {
                                IPW_DEBUG_SCAN
                                    ("Scan completed: type %d, %d channels, "
                                     "%d status\n", x->scan_type,
@@ -4692,7 +4688,7 @@ static void ipw_rx_notification(struct ipw_priv *priv,
                        } else {
                                IPW_ERROR("Scan completed of wrong size %d "
                                          "(should be %zd)\n",
-                                         notif->size, sizeof(*x));
+                                         size, sizeof(*x));
                        }
 
                        priv->status &=
@@ -4758,13 +4754,13 @@ static void ipw_rx_notification(struct ipw_priv *priv,
        case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
                        struct notif_frag_length *x = &notif->u.frag_len;
 
-                       if (notif->size == sizeof(*x))
+                       if (size == sizeof(*x))
                                IPW_ERROR("Frag length: %d\n",
                                          le16_to_cpu(x->frag_length));
                        else
                                IPW_ERROR("Frag length of wrong size %d "
                                          "(should be %zd)\n",
-                                         notif->size, sizeof(*x));
+                                         size, sizeof(*x));
                        break;
                }
 
@@ -4772,7 +4768,7 @@ static void ipw_rx_notification(struct ipw_priv *priv,
                        struct notif_link_deterioration *x =
                            &notif->u.link_deterioration;
 
-                       if (notif->size == sizeof(*x)) {
+                       if (size == sizeof(*x)) {
                                IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
                                        "link deterioration: type %d, cnt %d\n",
                                        x->silence_notification_type,
@@ -4782,7 +4778,7 @@ static void ipw_rx_notification(struct ipw_priv *priv,
                        } else {
                                IPW_ERROR("Link Deterioration of wrong size %d "
                                          "(should be %zd)\n",
-                                         notif->size, sizeof(*x));
+                                         size, sizeof(*x));
                        }
                        break;
                }
@@ -4798,10 +4794,10 @@ static void ipw_rx_notification(struct ipw_priv *priv,
 
        case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
                        struct notif_beacon_state *x = &notif->u.beacon_state;
-                       if (notif->size != sizeof(*x)) {
+                       if (size != sizeof(*x)) {
                                IPW_ERROR
                                    ("Beacon state of wrong size %d (should "
-                                    "be %zd)\n", notif->size, sizeof(*x));
+                                    "be %zd)\n", size, sizeof(*x));
                                break;
                        }
 
@@ -4816,7 +4812,7 @@ static void ipw_rx_notification(struct ipw_priv *priv,
 
        case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
                        struct notif_tgi_tx_key *x = &notif->u.tgi_tx_key;
-                       if (notif->size == sizeof(*x)) {
+                       if (size == sizeof(*x)) {
                                IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
                                          "0x%02x station %d\n",
                                          x->key_state, x->security_type,
@@ -4826,14 +4822,14 @@ static void ipw_rx_notification(struct ipw_priv *priv,
 
                        IPW_ERROR
                            ("TGi Tx Key of wrong size %d (should be %zd)\n",
-                            notif->size, sizeof(*x));
+                            size, sizeof(*x));
                        break;
                }
 
        case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
                        struct notif_calibration *x = &notif->u.calibration;
 
-                       if (notif->size == sizeof(*x)) {
+                       if (size == sizeof(*x)) {
                                memcpy(&priv->calib, x, sizeof(*x));
                                IPW_DEBUG_INFO("TODO: Calibration\n");
                                break;
@@ -4841,12 +4837,12 @@ static void ipw_rx_notification(struct ipw_priv *priv,
 
                        IPW_ERROR
                            ("Calibration of wrong size %d (should be %zd)\n",
-                            notif->size, sizeof(*x));
+                            size, sizeof(*x));
                        break;
                }
 
        case HOST_NOTIFICATION_NOISE_STATS:{
-                       if (notif->size == sizeof(u32)) {
+                       if (size == sizeof(u32)) {
                                priv->exp_avg_noise =
                                    exponential_average(priv->exp_avg_noise,
                                    (u8) (le32_to_cpu(notif->u.noise.value) & 0xff),
@@ -4856,14 +4852,14 @@ static void ipw_rx_notification(struct ipw_priv *priv,
 
                        IPW_ERROR
                            ("Noise stat is wrong size %d (should be %zd)\n",
-                            notif->size, sizeof(u32));
+                            size, sizeof(u32));
                        break;
                }
 
        default:
                IPW_DEBUG_NOTIF("Unknown notification: "
                                "subtype=%d,flags=0x%2x,size=%d\n",
-                               notif->subtype, notif->flags, notif->size);
+                               notif->subtype, notif->flags, size);
        }
 }
 
@@ -6767,7 +6763,7 @@ static int ipw_wx_set_mlme(struct net_device *dev,
 {
        struct ipw_priv *priv = ieee80211_priv(dev);
        struct iw_mlme *mlme = (struct iw_mlme *)extra;
-       u16 reason;
+       __le16 reason;
 
        reason = cpu_to_le16(mlme->reason_code);
 
@@ -10438,18 +10434,18 @@ static void ipw_handle_promiscuous_tx(struct ipw_priv *priv,
                rt_hdr->it_present = 0; /* after all, it's just an idea */
                rt_hdr->it_present |=  cpu_to_le32(1 << IEEE80211_RADIOTAP_CHANNEL);
 
-               *(u16*)skb_put(dst, sizeof(u16)) = cpu_to_le16(
+               *(__le16*)skb_put(dst, sizeof(u16)) = cpu_to_le16(
                        ieee80211chan2mhz(priv->channel));
                if (priv->channel > 14)         /* 802.11a */
-                       *(u16*)skb_put(dst, sizeof(u16)) =
+                       *(__le16*)skb_put(dst, sizeof(u16)) =
                                cpu_to_le16(IEEE80211_CHAN_OFDM |
                                             IEEE80211_CHAN_5GHZ);
                else if (priv->ieee->mode == IEEE_B) /* 802.11b */
-                       *(u16*)skb_put(dst, sizeof(u16)) =
+                       *(__le16*)skb_put(dst, sizeof(u16)) =
                                cpu_to_le16(IEEE80211_CHAN_CCK |
                                             IEEE80211_CHAN_2GHZ);
                else            /* 802.11g */
-                       *(u16*)skb_put(dst, sizeof(u16)) =
+                       *(__le16*)skb_put(dst, sizeof(u16)) =
                                cpu_to_le16(IEEE80211_CHAN_OFDM |
                                 IEEE80211_CHAN_2GHZ);
 

diff --git a/drivers/net/wireless/ipw2200.h b/drivers/net/wireless/ipw2200.h
index b8e815a42be8a2811358439d05bdbcce56d029cc..fae57a9f8be494647d19e42c5a612bb651de2c50 100644 (file)
--- a/drivers/net/wireless/ipw2200.h
+++ b/drivers/net/wireless/ipw2200.h
@@ -388,18 +388,18 @@ struct clx2_queue {
 } __attribute__ ((packed));
 
 struct machdr32 {
-       u16 frame_ctl;
+       __le16 frame_ctl;
        u16 duration;           // watch out for endians!
        u8 addr1[MACADRR_BYTE_LEN];
        u8 addr2[MACADRR_BYTE_LEN];
        u8 addr3[MACADRR_BYTE_LEN];
        u16 seq_ctrl;           // more endians!
        u8 addr4[MACADRR_BYTE_LEN];
-       u16 qos_ctrl;
+       __le16 qos_ctrl;
 } __attribute__ ((packed));
 
 struct machdr30 {
-       u16 frame_ctl;
+       __le16 frame_ctl;
        u16 duration;           // watch out for endians!
        u8 addr1[MACADRR_BYTE_LEN];
        u8 addr2[MACADRR_BYTE_LEN];
@@ -409,17 +409,17 @@ struct machdr30 {
 } __attribute__ ((packed));
 
 struct machdr26 {
-       u16 frame_ctl;
+       __le16 frame_ctl;
        u16 duration;           // watch out for endians!
        u8 addr1[MACADRR_BYTE_LEN];
        u8 addr2[MACADRR_BYTE_LEN];
        u8 addr3[MACADRR_BYTE_LEN];
        u16 seq_ctrl;           // more endians!
-       u16 qos_ctrl;
+       __le16 qos_ctrl;
 } __attribute__ ((packed));
 
 struct machdr24 {
-       u16 frame_ctl;
+       __le16 frame_ctl;
        u16 duration;           // watch out for endians!
        u8 addr1[MACADRR_BYTE_LEN];
        u8 addr2[MACADRR_BYTE_LEN];
@@ -466,15 +466,15 @@ struct tfd_command {
 
 struct tfd_data {
        /* Header */
-       u32 work_area_ptr;
+       __le32 work_area_ptr;
        u8 station_number;      /* 0 for BSS */
        u8 reserved1;
-       u16 reserved2;
+       __le16 reserved2;
 
        /* Tx Parameters */
        u8 cmd_id;
        u8 seq_num;
-       u16 len;
+       __le16 len;
        u8 priority;
        u8 tx_flags;
        u8 tx_flags_ext;
@@ -482,11 +482,11 @@ struct tfd_data {
        u8 wepkey[DCT_WEP_KEY_FIELD_LENGTH];
        u8 rate;
        u8 antenna;
-       u16 next_packet_duration;
-       u16 next_frag_len;
-       u16 back_off_counter;   //////txop;
+       __le16 next_packet_duration;
+       __le16 next_frag_len;
+       __le16 back_off_counter;        //////txop;
        u8 retrylimit;
-       u16 cwcurrent;
+       __le16 cwcurrent;
        u8 reserved3;
 
        /* 802.11 MAC Header */
@@ -498,9 +498,9 @@ struct tfd_data {
        } tfd;
 
        /* Payload DMA info */
-       u32 num_chunks;
-       u32 chunk_ptr[NUM_TFD_CHUNKS];
-       u16 chunk_len[NUM_TFD_CHUNKS];
+       __le32 num_chunks;
+       __le32 chunk_ptr[NUM_TFD_CHUNKS];
+       __le16 chunk_len[NUM_TFD_CHUNKS];
 } __attribute__ ((packed));
 
 struct txrx_control_flags {
@@ -547,14 +547,14 @@ struct clx2_tx_queue {
 // Used for passing to driver number of successes and failures per rate
 struct rate_histogram {
        union {
-               u32 a[SUP_RATE_11A_MAX_NUM_CHANNELS];
-               u32 b[SUP_RATE_11B_MAX_NUM_CHANNELS];
-               u32 g[SUP_RATE_11G_MAX_NUM_CHANNELS];
+               __le32 a[SUP_RATE_11A_MAX_NUM_CHANNELS];
+               __le32 b[SUP_RATE_11B_MAX_NUM_CHANNELS];
+               __le32 g[SUP_RATE_11G_MAX_NUM_CHANNELS];
        } success;
        union {
-               u32 a[SUP_RATE_11A_MAX_NUM_CHANNELS];
-               u32 b[SUP_RATE_11B_MAX_NUM_CHANNELS];
-               u32 g[SUP_RATE_11G_MAX_NUM_CHANNELS];
+               __le32 a[SUP_RATE_11A_MAX_NUM_CHANNELS];
+               __le32 b[SUP_RATE_11B_MAX_NUM_CHANNELS];
+               __le32 g[SUP_RATE_11G_MAX_NUM_CHANNELS];
        } failed;
 } __attribute__ ((packed));
 
@@ -602,13 +602,13 @@ struct notif_scan_complete {
 } __attribute__ ((packed));
 
 struct notif_frag_length {
-       u16 frag_length;
-       u16 reserved;
+       __le16 frag_length;
+       __le16 reserved;
 } __attribute__ ((packed));
 
 struct notif_beacon_state {
-       u32 state;
-       u32 number;
+       __le32 state;
+       __le32 number;
 } __attribute__ ((packed));
 
 struct notif_tgi_tx_key {
@@ -627,7 +627,7 @@ struct notif_link_deterioration {
        u8 modulation;
        struct rate_histogram histogram;
        u8 silence_notification_type;   /* SILENCE_OVER/UNDER_THRESH */
-       u16 silence_count;
+       __le16 silence_count;
 } __attribute__ ((packed));
 
 struct notif_association {
@@ -645,14 +645,14 @@ struct notif_calibration {
 } __attribute__ ((packed));
 
 struct notif_noise {
-       u32 value;
+       __le32 value;
 } __attribute__ ((packed));
 
 struct ipw_rx_notification {
        u8 reserved[8];
        u8 subtype;
        u8 flags;
-       u16 size;
+       __le16 size;
        union {
                struct notif_association assoc;
                struct notif_authenticate auth;
@@ -669,7 +669,7 @@ struct ipw_rx_notification {
 } __attribute__ ((packed));
 
 struct ipw_rx_frame {
-       u32 reserved1;
+       __le32 reserved1;
        u8 parent_tsf[4];       // fw_use[0] is boolean for OUR_TSF_IS_GREATER
        u8 received_channel;    // The channel that this frame was received on.
        // Note that for .11b this does not have to be
@@ -680,14 +680,14 @@ struct ipw_rx_frame {
        u8 rssi;
        u8 agc;
        u8 rssi_dbm;
-       u16 signal;
-       u16 noise;
+       __le16 signal;
+       __le16 noise;
        u8 antennaAndPhy;
        u8 control;             // control bit should be on in bg
        u8 rtscts_rate;         // rate of rts or cts (in rts cts sequence rate
        // is identical)
        u8 rtscts_seen;         // 0x1 RTS seen ; 0x2 CTS seen
-       u16 length;
+       __le16 length;
        u8 data[0];
 } __attribute__ ((packed));
 
@@ -827,14 +827,14 @@ struct ipw_tgi_tx_key {
        u8 station_index;
        u8 flags;
        u8 key[16];
-       u32 tx_counter[2];
+       __le32 tx_counter[2];
 } __attribute__ ((packed));
 
 #define IPW_SCAN_CHANNELS 54
 
 struct ipw_scan_request {
        u8 scan_type;
-       u16 dwell_time;
+       __le16 dwell_time;
        u8 channels_list[IPW_SCAN_CHANNELS];
        u8 channels_reserved[3];
 } __attribute__ ((packed));
@@ -849,11 +849,11 @@ enum {
 };
 
 struct ipw_scan_request_ext {
-       u32 full_scan_index;
+       __le32 full_scan_index;
        u8 channels_list[IPW_SCAN_CHANNELS];
        u8 scan_type[IPW_SCAN_CHANNELS / 2];
        u8 reserved;
-       u16 dwell_time[IPW_SCAN_TYPES];
+       __le16 dwell_time[IPW_SCAN_TYPES];
 } __attribute__ ((packed));
 
 static inline u8 ipw_get_scan_type(struct ipw_scan_request_ext *scan, u8 index)
@@ -906,13 +906,13 @@ struct ipw_supported_rates {
 } __attribute__ ((packed));
 
 struct ipw_rts_threshold {
-       u16 rts_threshold;
-       u16 reserved;
+       __le16 rts_threshold;
+       __le16 reserved;
 } __attribute__ ((packed));
 
 struct ipw_frag_threshold {
-       u16 frag_threshold;
-       u16 reserved;
+       __le16 frag_threshold;
+       __le16 reserved;
 } __attribute__ ((packed));
 
 struct ipw_retry_limit {
@@ -931,7 +931,7 @@ struct ipw_dino_config {
 struct ipw_aironet_info {
        u8 id;
        u8 length;
-       u16 reserved;
+       __le16 reserved;
 } __attribute__ ((packed));
 
 struct ipw_rx_key {
@@ -977,12 +977,12 @@ struct ipw_tx_power {
 struct ipw_rsn_capabilities {
        u8 id;
        u8 length;
-       u16 version;
+       __le16 version;
 } __attribute__ ((packed));
 
 struct ipw_sensitivity_calib {
-       u16 beacon_rssi_raw;
-       u16 reserved;
+       __le16 beacon_rssi_raw;
+       __le16 reserved;
 } __attribute__ ((packed));
 
 /**
@@ -1156,8 +1156,8 @@ struct ipw_rt_hdr {
        u64 rt_tsf;      /* TSF */
        u8 rt_flags;    /* radiotap packet flags */
        u8 rt_rate;     /* rate in 500kb/s */
-       u16 rt_channel; /* channel in mhz */
-       u16 rt_chbitmask;       /* channel bitfield */
+       __le16 rt_channel;      /* channel in mhz */
+       __le16 rt_chbitmask;    /* channel bitfield */
        s8 rt_dbmsignal;        /* signal in dbM, kluged to signed */
        s8 rt_dbmnoise;
        u8 rt_antenna;  /* antenna number */