package/kernel/mac80211/patches/556-ath9k-define-all-EEPROM-fields-in-Little-Endian-form.patch

   1 From 7e1047f3cf8dcdb4825f3c785f7f708d07508096 Mon Sep 17 00:00:00 2001
   2 From: Martin Blumenstingl <martin.blumenstingl@googlemail.com>
   3 Date: Mon, 3 Oct 2016 00:29:13 +0200
   4 Subject: [v2 PATCH 7/7] ath9k: define all EEPROM fields in Little Endian format
   5
   6 The ar9300_eeprom logic is already using only 8-bit (endian neutral),
   7 __le16 and __le32 fields to state explicitly how the values should be
   8 interpreted.
   9 All other EEPROM implementations (4k, 9287 and def) were using u16 and
  10 u32 fields with additional logic to swap the values (read from the
  11 original EEPROM) so they match the current CPUs endianness.
  12
  13 The EEPROM format defaults to "all values are Little Endian", indicated
  14 by the absence of the AR5416_EEPMISC_BIG_ENDIAN in the u8 EEPMISC
  15 register. If we detect that the EEPROM indicates Big Endian mode
  16 (AR5416_EEPMISC_BIG_ENDIAN is set in the EEPMISC register) then we'll
  17 swap the values to convert them into Little Endian. This is done by
  18 activating the EEPMISC based logic in ath9k_hw_nvram_swap_data even if
  19 AH_NO_EEP_SWAP is set (this makes ath9k behave like the FreeBSD driver,
  20 which also does not have a flag to enable swapping based on the
  21 AR5416_EEPMISC_BIG_ENDIAN bit). Before this logic was only used to
  22 enable swapping when "current CPU endianness != EEPROM endianness".
  23
  24 After changing all relevant fields to __le16 and __le32 sparse was used
  25 to check that all code which reads any of these fields uses
  26 le{16,32}_to_cpu.
  27
  28 Signed-off-by: Martin Blumenstingl <martin.blumenstingl@googlemail.com>
  29 ---
  30  drivers/net/wireless/ath/ath9k/eeprom.c      |  27 ++-----
  31  drivers/net/wireless/ath/ath9k/eeprom.h      |  75 ++++++++++--------
  32  drivers/net/wireless/ath/ath9k/eeprom_4k.c   |  94 +++++++++-------------
  33  drivers/net/wireless/ath/ath9k/eeprom_9287.c |  98 ++++++++++-------------
  34  drivers/net/wireless/ath/ath9k/eeprom_def.c  | 114 ++++++++++++---------------
  35  5 files changed, 174 insertions(+), 234 deletions(-)
  36
  37 --- a/drivers/net/wireless/ath/ath9k/eeprom.c
  38 +++ b/drivers/net/wireless/ath/ath9k/eeprom.c
  39 @@ -155,17 +155,10 @@ bool ath9k_hw_nvram_read(struct ath_hw *
  40         return ret;
  41  }
  42
  43 -#ifdef __BIG_ENDIAN
  44 -#define EXPECTED_EEPMISC_ENDIAN AR5416_EEPMISC_BIG_ENDIAN
  45 -#else
  46 -#define EXPECTED_EEPMISC_ENDIAN 0
  47 -#endif
  48 -
  49  int ath9k_hw_nvram_swap_data(struct ath_hw *ah, bool *swap_needed, int size)
  50  {
  51         u16 magic;
  52         u16 *eepdata;
  53 -       u8 eepmisc;
  54         int i;
  55         bool needs_byteswap = false;
  56         struct ath_common *common = ath9k_hw_common(ah);
  57 @@ -203,25 +196,17 @@ int ath9k_hw_nvram_swap_data(struct ath_
  58                 }
  59         }
  60
  61 -       *swap_needed = false;
  62 -
  63 -       eepmisc = ah->eep_ops->get_eepmisc(ah);
  64 -       if ((eepmisc & AR5416_EEPMISC_BIG_ENDIAN) != EXPECTED_EEPMISC_ENDIAN) {
  65 -               if (ah->ah_flags & AH_NO_EEP_SWAP) {
  66 -                       ath_info(common,
  67 -                                "Ignoring endianness difference in eepmisc register.\n");
  68 -               } else {
  69 -                       *swap_needed = true;
  70 -                       ath_dbg(common, EEPROM,
  71 -                               "EEPROM needs swapping according to the eepmisc register.\n");
  72 -               }
  73 +       if (ah->eep_ops->get_eepmisc(ah) & AR5416_EEPMISC_BIG_ENDIAN) {
  74 +               *swap_needed = true;
  75 +               ath_dbg(common, EEPROM,
  76 +                       "Big Endian EEPROM detected according to EEPMISC register.\n");
  77 +       } else {
  78 +               *swap_needed = false;
  79         }
  80
  81         return 0;
  82  }
  83
  84 -#undef EXPECTED_EEPMISC_VAL
  85 -
  86  bool ath9k_hw_nvram_validate_checksum(struct ath_hw *ah, int size)
  87  {
  88         u32 i, sum = 0;
  89 --- a/drivers/net/wireless/ath/ath9k/eeprom.h
  90 +++ b/drivers/net/wireless/ath/ath9k/eeprom.h
  91 @@ -23,6 +23,17 @@
  92  #include <net/cfg80211.h>
  93  #include "ar9003_eeprom.h"
  94
  95 +/* helpers to swap EEPROM fields, which are stored as __le16 or __le32. Since
  96 + * we are 100% sure about it we __force these to u16/u32 for the swab calls to
  97 + * silence the sparse checks. These macros are used when we have a Big Endian
  98 + * EEPROM (according to AR5416_EEPMISC_BIG_ENDIAN) and need to convert the
  99 + * fields to __le16/__le32.
 100 + */
 101 +#define EEPROM_FIELD_SWAB16(field) \
 102 +       (field = (__force __le16)swab16((__force u16)field))
 103 +#define EEPROM_FIELD_SWAB32(field) \
 104 +       (field = (__force __le32)swab32((__force u32)field))
 105 +
 106  #ifdef __BIG_ENDIAN
 107  #define AR5416_EEPROM_MAGIC 0x5aa5
 108  #else
 109 @@ -270,19 +281,19 @@ enum ath9k_hal_freq_band {
 110  };
 111
 112  struct base_eep_header {
 113 -       u16 length;
 114 -       u16 checksum;
 115 -       u16 version;
 116 +       __le16 length;
 117 +       __le16 checksum;
 118 +       __le16 version;
 119         u8 opCapFlags;
 120         u8 eepMisc;
 121 -       u16 regDmn[2];
 122 +       __le16 regDmn[2];
 123         u8 macAddr[6];
 124         u8 rxMask;
 125         u8 txMask;
 126 -       u16 rfSilent;
 127 -       u16 blueToothOptions;
 128 -       u16 deviceCap;
 129 -       u32 binBuildNumber;
 130 +       __le16 rfSilent;
 131 +       __le16 blueToothOptions;
 132 +       __le16 deviceCap;
 133 +       __le32 binBuildNumber;
 134         u8 deviceType;
 135         u8 pwdclkind;
 136         u8 fastClk5g;
 137 @@ -300,33 +311,33 @@ struct base_eep_header {
 138  } __packed;
 139
 140  struct base_eep_header_4k {
 141 -       u16 length;
 142 -       u16 checksum;
 143 -       u16 version;
 144 +       __le16 length;
 145 +       __le16 checksum;
 146 +       __le16 version;
 147         u8 opCapFlags;
 148         u8 eepMisc;
 149 -       u16 regDmn[2];
 150 +       __le16 regDmn[2];
 151         u8 macAddr[6];
 152         u8 rxMask;
 153         u8 txMask;
 154 -       u16 rfSilent;
 155 -       u16 blueToothOptions;
 156 -       u16 deviceCap;
 157 -       u32 binBuildNumber;
 158 +       __le16 rfSilent;
 159 +       __le16 blueToothOptions;
 160 +       __le16 deviceCap;
 161 +       __le32 binBuildNumber;
 162         u8 deviceType;
 163         u8 txGainType;
 164  } __packed;
 165
 166
 167  struct spur_chan {
 168 -       u16 spurChan;
 169 +       __le16 spurChan;
 170         u8 spurRangeLow;
 171         u8 spurRangeHigh;
 172  } __packed;
 173
 174  struct modal_eep_header {
 175 -       u32 antCtrlChain[AR5416_MAX_CHAINS];
 176 -       u32 antCtrlCommon;
 177 +       __le32 antCtrlChain[AR5416_MAX_CHAINS];
 178 +       __le32 antCtrlCommon;
 179         u8 antennaGainCh[AR5416_MAX_CHAINS];
 180         u8 switchSettling;
 181         u8 txRxAttenCh[AR5416_MAX_CHAINS];
 182 @@ -361,7 +372,7 @@ struct modal_eep_header {
 183         u8 db_ch1;
 184         u8 lna_ctl;
 185         u8 miscBits;
 186 -       u16 xpaBiasLvlFreq[3];
 187 +       __le16 xpaBiasLvlFreq[3];
 188         u8 futureModal[6];
 189
 190         struct spur_chan spurChans[AR_EEPROM_MODAL_SPURS];
 191 @@ -375,8 +386,8 @@ struct calDataPerFreqOpLoop {
 192  } __packed;
 193
 194  struct modal_eep_4k_header {
 195 -       u32 antCtrlChain[AR5416_EEP4K_MAX_CHAINS];
 196 -       u32 antCtrlCommon;
 197 +       __le32 antCtrlChain[AR5416_EEP4K_MAX_CHAINS];
 198 +       __le32 antCtrlCommon;
 199         u8 antennaGainCh[AR5416_EEP4K_MAX_CHAINS];
 200         u8 switchSettling;
 201         u8 txRxAttenCh[AR5416_EEP4K_MAX_CHAINS];
 202 @@ -440,19 +451,19 @@ struct modal_eep_4k_header {
 203  } __packed;
 204
 205  struct base_eep_ar9287_header {
 206 -       u16 length;
 207 -       u16 checksum;
 208 -       u16 version;
 209 +       __le16 length;
 210 +       __le16 checksum;
 211 +       __le16 version;
 212         u8 opCapFlags;
 213         u8 eepMisc;
 214 -       u16 regDmn[2];
 215 +       __le16 regDmn[2];
 216         u8 macAddr[6];
 217         u8 rxMask;
 218         u8 txMask;
 219 -       u16 rfSilent;
 220 -       u16 blueToothOptions;
 221 -       u16 deviceCap;
 222 -       u32 binBuildNumber;
 223 +       __le16 rfSilent;
 224 +       __le16 blueToothOptions;
 225 +       __le16 deviceCap;
 226 +       __le32 binBuildNumber;
 227         u8 deviceType;
 228         u8 openLoopPwrCntl;
 229         int8_t pwrTableOffset;
 230 @@ -462,8 +473,8 @@ struct base_eep_ar9287_header {
 231  } __packed;
 232
 233  struct modal_eep_ar9287_header {
 234 -       u32 antCtrlChain[AR9287_MAX_CHAINS];
 235 -       u32 antCtrlCommon;
 236 +       __le32 antCtrlChain[AR9287_MAX_CHAINS];
 237 +       __le32 antCtrlCommon;
 238         int8_t antennaGainCh[AR9287_MAX_CHAINS];
 239         u8 switchSettling;
 240         u8 txRxAttenCh[AR9287_MAX_CHAINS];
 241 --- a/drivers/net/wireless/ath/ath9k/eeprom_4k.c
 242 +++ b/drivers/net/wireless/ath/ath9k/eeprom_4k.c
 243 @@ -20,7 +20,7 @@
 244
 245  static int ath9k_hw_4k_get_eeprom_ver(struct ath_hw *ah)
 246  {
 247 -       u16 version = ah->eeprom.map4k.baseEepHeader.version;
 248 +       u16 version = le16_to_cpu(ah->eeprom.map4k.baseEepHeader.version);
 249
 250         return (version & AR5416_EEP_VER_MAJOR_MASK) >>
 251                 AR5416_EEP_VER_MAJOR_SHIFT;
 252 @@ -28,7 +28,7 @@ static int ath9k_hw_4k_get_eeprom_ver(st
 253
 254  static int ath9k_hw_4k_get_eeprom_rev(struct ath_hw *ah)
 255  {
 256 -       u16 version = ah->eeprom.map4k.baseEepHeader.version;
 257 +       u16 version = le16_to_cpu(ah->eeprom.map4k.baseEepHeader.version);
 258
 259         return version & AR5416_EEP_VER_MINOR_MASK;
 260  }
 261 @@ -76,8 +76,8 @@ static bool ath9k_hw_4k_fill_eeprom(stru
 262  static u32 ath9k_dump_4k_modal_eeprom(char *buf, u32 len, u32 size,
 263                                       struct modal_eep_4k_header *modal_hdr)
 264  {
 265 -       PR_EEP("Chain0 Ant. Control", modal_hdr->antCtrlChain[0]);
 266 -       PR_EEP("Ant. Common Control", modal_hdr->antCtrlCommon);
 267 +       PR_EEP("Chain0 Ant. Control", le16_to_cpu(modal_hdr->antCtrlChain[0]));
 268 +       PR_EEP("Ant. Common Control", le32_to_cpu(modal_hdr->antCtrlCommon));
 269         PR_EEP("Chain0 Ant. Gain", modal_hdr->antennaGainCh[0]);
 270         PR_EEP("Switch Settle", modal_hdr->switchSettling);
 271         PR_EEP("Chain0 TxRxAtten", modal_hdr->txRxAttenCh[0]);
 272 @@ -132,6 +132,7 @@ static u32 ath9k_hw_4k_dump_eeprom(struc
 273  {
 274         struct ar5416_eeprom_4k *eep = &ah->eeprom.map4k;
 275         struct base_eep_header_4k *pBase = &eep->baseEepHeader;
 276 +       u32 binBuildNumber = le32_to_cpu(pBase->binBuildNumber);
 277
 278         if (!dump_base_hdr) {
 279                 len += scnprintf(buf + len, size - len,
 280 @@ -143,10 +144,10 @@ static u32 ath9k_hw_4k_dump_eeprom(struc
 281
 282         PR_EEP("Major Version", ath9k_hw_4k_get_eeprom_ver(ah));
 283         PR_EEP("Minor Version", ath9k_hw_4k_get_eeprom_rev(ah));
 284 -       PR_EEP("Checksum", pBase->checksum);
 285 -       PR_EEP("Length", pBase->length);
 286 -       PR_EEP("RegDomain1", pBase->regDmn[0]);
 287 -       PR_EEP("RegDomain2", pBase->regDmn[1]);
 288 +       PR_EEP("Checksum", le16_to_cpu(pBase->checksum));
 289 +       PR_EEP("Length", le16_to_cpu(pBase->length));
 290 +       PR_EEP("RegDomain1", le16_to_cpu(pBase->regDmn[0]));
 291 +       PR_EEP("RegDomain2", le16_to_cpu(pBase->regDmn[1]));
 292         PR_EEP("TX Mask", pBase->txMask);
 293         PR_EEP("RX Mask", pBase->rxMask);
 294         PR_EEP("Allow 5GHz", !!(pBase->opCapFlags & AR5416_OPFLAGS_11A));
 295 @@ -160,9 +161,9 @@ static u32 ath9k_hw_4k_dump_eeprom(struc
 296         PR_EEP("Disable 5Ghz HT40", !!(pBase->opCapFlags &
 297                                         AR5416_OPFLAGS_N_5G_HT40));
 298         PR_EEP("Big Endian", !!(pBase->eepMisc & AR5416_EEPMISC_BIG_ENDIAN));
 299 -       PR_EEP("Cal Bin Major Ver", (pBase->binBuildNumber >> 24) & 0xFF);
 300 -       PR_EEP("Cal Bin Minor Ver", (pBase->binBuildNumber >> 16) & 0xFF);
 301 -       PR_EEP("Cal Bin Build", (pBase->binBuildNumber >> 8) & 0xFF);
 302 +       PR_EEP("Cal Bin Major Ver", (binBuildNumber >> 24) & 0xFF);
 303 +       PR_EEP("Cal Bin Minor Ver", (binBuildNumber >> 16) & 0xFF);
 304 +       PR_EEP("Cal Bin Build", (binBuildNumber >> 8) & 0xFF);
 305         PR_EEP("TX Gain type", pBase->txGainType);
 306
 307         len += scnprintf(buf + len, size - len, "%20s : %pM\n", "MacAddress",
 308 @@ -194,54 +195,31 @@ static int ath9k_hw_4k_check_eeprom(stru
 309                 return err;
 310
 311         if (need_swap)
 312 -               el = swab16(eep->baseEepHeader.length);
 313 +               el = swab16((__force u16)eep->baseEepHeader.length);
 314         else
 315 -               el = eep->baseEepHeader.length;
 316 +               el = le16_to_cpu(eep->baseEepHeader.length);
 317
 318         el = min(el / sizeof(u16), SIZE_EEPROM_4K);
 319         if (!ath9k_hw_nvram_validate_checksum(ah, el))
 320                 return -EINVAL;
 321
 322         if (need_swap) {
 323 -               u32 integer;
 324 -               u16 word;
 325 -
 326 -               word = swab16(eep->baseEepHeader.length);
 327 -               eep->baseEepHeader.length = word;
 328 -
 329 -               word = swab16(eep->baseEepHeader.checksum);
 330 -               eep->baseEepHeader.checksum = word;
 331 -
 332 -               word = swab16(eep->baseEepHeader.version);
 333 -               eep->baseEepHeader.version = word;
 334 -
 335 -               word = swab16(eep->baseEepHeader.regDmn[0]);
 336 -               eep->baseEepHeader.regDmn[0] = word;
 337 -
 338 -               word = swab16(eep->baseEepHeader.regDmn[1]);
 339 -               eep->baseEepHeader.regDmn[1] = word;
 340 -
 341 -               word = swab16(eep->baseEepHeader.rfSilent);
 342 -               eep->baseEepHeader.rfSilent = word;
 343 -
 344 -               word = swab16(eep->baseEepHeader.blueToothOptions);
 345 -               eep->baseEepHeader.blueToothOptions = word;
 346 -
 347 -               word = swab16(eep->baseEepHeader.deviceCap);
 348 -               eep->baseEepHeader.deviceCap = word;
 349 -
 350 -               integer = swab32(eep->modalHeader.antCtrlCommon);
 351 -               eep->modalHeader.antCtrlCommon = integer;
 352 -
 353 -               for (i = 0; i < AR5416_EEP4K_MAX_CHAINS; i++) {
 354 -                       integer = swab32(eep->modalHeader.antCtrlChain[i]);
 355 -                       eep->modalHeader.antCtrlChain[i] = integer;
 356 -               }
 357 -
 358 -               for (i = 0; i < AR_EEPROM_MODAL_SPURS; i++) {
 359 -                       word = swab16(eep->modalHeader.spurChans[i].spurChan);
 360 -                       eep->modalHeader.spurChans[i].spurChan = word;
 361 -               }
 362 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.length);
 363 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.checksum);
 364 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.version);
 365 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.regDmn[0]);
 366 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.regDmn[1]);
 367 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.rfSilent);
 368 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.blueToothOptions);
 369 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.deviceCap);
 370 +               EEPROM_FIELD_SWAB32(eep->modalHeader.antCtrlCommon);
 371 +
 372 +               for (i = 0; i < AR5416_EEP4K_MAX_CHAINS; i++)
 373 +                       EEPROM_FIELD_SWAB32(eep->modalHeader.antCtrlChain[i]);
 374 +
 375 +               for (i = 0; i < AR_EEPROM_MODAL_SPURS; i++)
 376 +                       EEPROM_FIELD_SWAB16(
 377 +                               eep->modalHeader.spurChans[i].spurChan);
 378         }
 379
 380         if (!ath9k_hw_nvram_check_version(ah, AR5416_EEP_VER,
 381 @@ -270,13 +248,13 @@ static u32 ath9k_hw_4k_get_eeprom(struct
 382         case EEP_MAC_MSW:
 383                 return get_unaligned_be16(pBase->macAddr + 4);
 384         case EEP_REG_0:
 385 -               return pBase->regDmn[0];
 386 +               return le16_to_cpu(pBase->regDmn[0]);
 387         case EEP_OP_CAP:
 388 -               return pBase->deviceCap;
 389 +               return le16_to_cpu(pBase->deviceCap);
 390         case EEP_OP_MODE:
 391                 return pBase->opCapFlags;
 392         case EEP_RF_SILENT:
 393 -               return pBase->rfSilent;
 394 +               return le16_to_cpu(pBase->rfSilent);
 395         case EEP_OB_2:
 396                 return pModal->ob_0;
 397         case EEP_DB_2:
 398 @@ -724,7 +702,7 @@ static void ath9k_hw_4k_set_gain(struct
 399  {
 400         ENABLE_REG_RMW_BUFFER(ah);
 401         REG_RMW(ah, AR_PHY_SWITCH_CHAIN_0,
 402 -               pModal->antCtrlChain[0], 0);
 403 +               le32_to_cpu(pModal->antCtrlChain[0]), 0);
 404
 405         REG_RMW(ah, AR_PHY_TIMING_CTRL4(0),
 406                 SM(pModal->iqCalICh[0], AR_PHY_TIMING_CTRL4_IQCORR_Q_I_COFF) |
 407 @@ -790,7 +768,7 @@ static void ath9k_hw_4k_set_board_values
 408         pModal = &eep->modalHeader;
 409         txRxAttenLocal = 23;
 410
 411 -       REG_WRITE(ah, AR_PHY_SWITCH_COM, pModal->antCtrlCommon);
 412 +       REG_WRITE(ah, AR_PHY_SWITCH_COM, le32_to_cpu(pModal->antCtrlCommon));
 413
 414         /* Single chain for 4K EEPROM*/
 415         ath9k_hw_4k_set_gain(ah, pModal, eep, txRxAttenLocal);
 416 @@ -1054,7 +1032,7 @@ static void ath9k_hw_4k_set_board_values
 417
 418  static u16 ath9k_hw_4k_get_spur_channel(struct ath_hw *ah, u16 i, bool is2GHz)
 419  {
 420 -       return ah->eeprom.map4k.modalHeader.spurChans[i].spurChan;
 421 +       return le16_to_cpu(ah->eeprom.map4k.modalHeader.spurChans[i].spurChan);
 422  }
 423
 424  static u8 ath9k_hw_4k_get_eepmisc(struct ath_hw *ah)
 425 --- a/drivers/net/wireless/ath/ath9k/eeprom_9287.c
 426 +++ b/drivers/net/wireless/ath/ath9k/eeprom_9287.c
 427 @@ -22,7 +22,7 @@
 428
 429  static int ath9k_hw_ar9287_get_eeprom_ver(struct ath_hw *ah)
 430  {
 431 -       u16 version = ah->eeprom.map9287.baseEepHeader.version;
 432 +       u16 version = le16_to_cpu(ah->eeprom.map9287.baseEepHeader.version);
 433
 434         return (version & AR5416_EEP_VER_MAJOR_MASK) >>
 435                 AR5416_EEP_VER_MAJOR_SHIFT;
 436 @@ -30,7 +30,7 @@ static int ath9k_hw_ar9287_get_eeprom_ve
 437
 438  static int ath9k_hw_ar9287_get_eeprom_rev(struct ath_hw *ah)
 439  {
 440 -       u16 version = ah->eeprom.map9287.baseEepHeader.version;
 441 +       u16 version = le16_to_cpu(ah->eeprom.map9287.baseEepHeader.version);
 442
 443         return version & AR5416_EEP_VER_MINOR_MASK;
 444  }
 445 @@ -79,9 +79,9 @@ static bool ath9k_hw_ar9287_fill_eeprom(
 446  static u32 ar9287_dump_modal_eeprom(char *buf, u32 len, u32 size,
 447                                     struct modal_eep_ar9287_header *modal_hdr)
 448  {
 449 -       PR_EEP("Chain0 Ant. Control", modal_hdr->antCtrlChain[0]);
 450 -       PR_EEP("Chain1 Ant. Control", modal_hdr->antCtrlChain[1]);
 451 -       PR_EEP("Ant. Common Control", modal_hdr->antCtrlCommon);
 452 +       PR_EEP("Chain0 Ant. Control", le16_to_cpu(modal_hdr->antCtrlChain[0]));
 453 +       PR_EEP("Chain1 Ant. Control", le16_to_cpu(modal_hdr->antCtrlChain[1]));
 454 +       PR_EEP("Ant. Common Control", le32_to_cpu(modal_hdr->antCtrlCommon));
 455         PR_EEP("Chain0 Ant. Gain", modal_hdr->antennaGainCh[0]);
 456         PR_EEP("Chain1 Ant. Gain", modal_hdr->antennaGainCh[1]);
 457         PR_EEP("Switch Settle", modal_hdr->switchSettling);
 458 @@ -128,6 +128,7 @@ static u32 ath9k_hw_ar9287_dump_eeprom(s
 459  {
 460         struct ar9287_eeprom *eep = &ah->eeprom.map9287;
 461         struct base_eep_ar9287_header *pBase = &eep->baseEepHeader;
 462 +       u32 binBuildNumber = le32_to_cpu(pBase->binBuildNumber);
 463
 464         if (!dump_base_hdr) {
 465                 len += scnprintf(buf + len, size - len,
 466 @@ -139,10 +140,10 @@ static u32 ath9k_hw_ar9287_dump_eeprom(s
 467
 468         PR_EEP("Major Version", ath9k_hw_ar9287_get_eeprom_ver(ah));
 469         PR_EEP("Minor Version", ath9k_hw_ar9287_get_eeprom_rev(ah));
 470 -       PR_EEP("Checksum", pBase->checksum);
 471 -       PR_EEP("Length", pBase->length);
 472 -       PR_EEP("RegDomain1", pBase->regDmn[0]);
 473 -       PR_EEP("RegDomain2", pBase->regDmn[1]);
 474 +       PR_EEP("Checksum", le16_to_cpu(pBase->checksum));
 475 +       PR_EEP("Length", le16_to_cpu(pBase->length));
 476 +       PR_EEP("RegDomain1", le16_to_cpu(pBase->regDmn[0]));
 477 +       PR_EEP("RegDomain2", le16_to_cpu(pBase->regDmn[1]));
 478         PR_EEP("TX Mask", pBase->txMask);
 479         PR_EEP("RX Mask", pBase->rxMask);
 480         PR_EEP("Allow 5GHz", !!(pBase->opCapFlags & AR5416_OPFLAGS_11A));
 481 @@ -156,9 +157,9 @@ static u32 ath9k_hw_ar9287_dump_eeprom(s
 482         PR_EEP("Disable 5Ghz HT40", !!(pBase->opCapFlags &
 483                                         AR5416_OPFLAGS_N_5G_HT40));
 484         PR_EEP("Big Endian", !!(pBase->eepMisc & AR5416_EEPMISC_BIG_ENDIAN));
 485 -       PR_EEP("Cal Bin Major Ver", (pBase->binBuildNumber >> 24) & 0xFF);
 486 -       PR_EEP("Cal Bin Minor Ver", (pBase->binBuildNumber >> 16) & 0xFF);
 487 -       PR_EEP("Cal Bin Build", (pBase->binBuildNumber >> 8) & 0xFF);
 488 +       PR_EEP("Cal Bin Major Ver", (binBuildNumber >> 24) & 0xFF);
 489 +       PR_EEP("Cal Bin Minor Ver", (binBuildNumber >> 16) & 0xFF);
 490 +       PR_EEP("Cal Bin Build", (binBuildNumber >> 8) & 0xFF);
 491         PR_EEP("Power Table Offset", pBase->pwrTableOffset);
 492         PR_EEP("OpenLoop Power Ctrl", pBase->openLoopPwrCntl);
 493
 494 @@ -182,8 +183,7 @@ static u32 ath9k_hw_ar9287_dump_eeprom(s
 495
 496  static int ath9k_hw_ar9287_check_eeprom(struct ath_hw *ah)
 497  {
 498 -       u32 el, integer;
 499 -       u16 word;
 500 +       u32 el;
 501         int i, err;
 502         bool need_swap;
 503         struct ar9287_eeprom *eep = &ah->eeprom.map9287;
 504 @@ -193,51 +193,31 @@ static int ath9k_hw_ar9287_check_eeprom(
 505                 return err;
 506
 507         if (need_swap)
 508 -               el = swab16(eep->baseEepHeader.length);
 509 +               el = swab16((__force u16)eep->baseEepHeader.length);
 510         else
 511 -               el = eep->baseEepHeader.length;
 512 +               el = le16_to_cpu(eep->baseEepHeader.length);
 513
 514         el = min(el / sizeof(u16), SIZE_EEPROM_AR9287);
 515         if (!ath9k_hw_nvram_validate_checksum(ah, el))
 516                 return -EINVAL;
 517
 518         if (need_swap) {
 519 -               word = swab16(eep->baseEepHeader.length);
 520 -               eep->baseEepHeader.length = word;
 521 -
 522 -               word = swab16(eep->baseEepHeader.checksum);
 523 -               eep->baseEepHeader.checksum = word;
 524 -
 525 -               word = swab16(eep->baseEepHeader.version);
 526 -               eep->baseEepHeader.version = word;
 527 -
 528 -               word = swab16(eep->baseEepHeader.regDmn[0]);
 529 -               eep->baseEepHeader.regDmn[0] = word;
 530 -
 531 -               word = swab16(eep->baseEepHeader.regDmn[1]);
 532 -               eep->baseEepHeader.regDmn[1] = word;
 533 -
 534 -               word = swab16(eep->baseEepHeader.rfSilent);
 535 -               eep->baseEepHeader.rfSilent = word;
 536 -
 537 -               word = swab16(eep->baseEepHeader.blueToothOptions);
 538 -               eep->baseEepHeader.blueToothOptions = word;
 539 -
 540 -               word = swab16(eep->baseEepHeader.deviceCap);
 541 -               eep->baseEepHeader.deviceCap = word;
 542 -
 543 -               integer = swab32(eep->modalHeader.antCtrlCommon);
 544 -               eep->modalHeader.antCtrlCommon = integer;
 545 -
 546 -               for (i = 0; i < AR9287_MAX_CHAINS; i++) {
 547 -                       integer = swab32(eep->modalHeader.antCtrlChain[i]);
 548 -                       eep->modalHeader.antCtrlChain[i] = integer;
 549 -               }
 550 -
 551 -               for (i = 0; i < AR_EEPROM_MODAL_SPURS; i++) {
 552 -                       word = swab16(eep->modalHeader.spurChans[i].spurChan);
 553 -                       eep->modalHeader.spurChans[i].spurChan = word;
 554 -               }
 555 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.length);
 556 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.checksum);
 557 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.version);
 558 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.regDmn[0]);
 559 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.regDmn[1]);
 560 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.rfSilent);
 561 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.blueToothOptions);
 562 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.deviceCap);
 563 +               EEPROM_FIELD_SWAB32(eep->modalHeader.antCtrlCommon);
 564 +
 565 +               for (i = 0; i < AR9287_MAX_CHAINS; i++)
 566 +                       EEPROM_FIELD_SWAB32(eep->modalHeader.antCtrlChain[i]);
 567 +
 568 +               for (i = 0; i < AR_EEPROM_MODAL_SPURS; i++)
 569 +                       EEPROM_FIELD_SWAB16(
 570 +                               eep->modalHeader.spurChans[i].spurChan);
 571         }
 572
 573         if (!ath9k_hw_nvram_check_version(ah, AR9287_EEP_VER,
 574 @@ -267,13 +247,13 @@ static u32 ath9k_hw_ar9287_get_eeprom(st
 575         case EEP_MAC_MSW:
 576                 return get_unaligned_be16(pBase->macAddr + 4);
 577         case EEP_REG_0:
 578 -               return pBase->regDmn[0];
 579 +               return le16_to_cpu(pBase->regDmn[0]);
 580         case EEP_OP_CAP:
 581 -               return pBase->deviceCap;
 582 +               return le16_to_cpu(pBase->deviceCap);
 583         case EEP_OP_MODE:
 584                 return pBase->opCapFlags;
 585         case EEP_RF_SILENT:
 586 -               return pBase->rfSilent;
 587 +               return le16_to_cpu(pBase->rfSilent);
 588         case EEP_TX_MASK:
 589                 return pBase->txMask;
 590         case EEP_RX_MASK:
 591 @@ -878,13 +858,13 @@ static void ath9k_hw_ar9287_set_board_va
 592
 593         pModal = &eep->modalHeader;
 594
 595 -       REG_WRITE(ah, AR_PHY_SWITCH_COM, pModal->antCtrlCommon);
 596 +       REG_WRITE(ah, AR_PHY_SWITCH_COM, le32_to_cpu(pModal->antCtrlCommon));
 597
 598         for (i = 0; i < AR9287_MAX_CHAINS; i++) {
 599                 regChainOffset = i * 0x1000;
 600
 601                 REG_WRITE(ah, AR_PHY_SWITCH_CHAIN_0 + regChainOffset,
 602 -                         pModal->antCtrlChain[i]);
 603 +                         le32_to_cpu(pModal->antCtrlChain[i]));
 604
 605                 REG_WRITE(ah, AR_PHY_TIMING_CTRL4(0) + regChainOffset,
 606                           (REG_READ(ah, AR_PHY_TIMING_CTRL4(0) + regChainOffset)
 607 @@ -982,7 +962,9 @@ static void ath9k_hw_ar9287_set_board_va
 608  static u16 ath9k_hw_ar9287_get_spur_channel(struct ath_hw *ah,
 609                                             u16 i, bool is2GHz)
 610  {
 611 -       return ah->eeprom.map9287.modalHeader.spurChans[i].spurChan;
 612 +       __le16 spur_ch = ah->eeprom.map9287.modalHeader.spurChans[i].spurChan;
 613 +
 614 +       return le16_to_cpu(spur_ch);
 615  }
 616
 617  static u8 ath9k_hw_ar9287_get_eepmisc(struct ath_hw *ah)
 618 --- a/drivers/net/wireless/ath/ath9k/eeprom_def.c
 619 +++ b/drivers/net/wireless/ath/ath9k/eeprom_def.c
 620 @@ -79,7 +79,7 @@ static void ath9k_olc_get_pdadcs(struct
 621
 622  static int ath9k_hw_def_get_eeprom_ver(struct ath_hw *ah)
 623  {
 624 -       u16 version = ah->eeprom.def.baseEepHeader.version;
 625 +       u16 version = le16_to_cpu(ah->eeprom.def.baseEepHeader.version);
 626
 627         return (version & AR5416_EEP_VER_MAJOR_MASK) >>
 628                 AR5416_EEP_VER_MAJOR_SHIFT;
 629 @@ -87,7 +87,7 @@ static int ath9k_hw_def_get_eeprom_ver(s
 630
 631  static int ath9k_hw_def_get_eeprom_rev(struct ath_hw *ah)
 632  {
 633 -       u16 version = ah->eeprom.def.baseEepHeader.version;
 634 +       u16 version = le16_to_cpu(ah->eeprom.def.baseEepHeader.version);
 635
 636         return version & AR5416_EEP_VER_MINOR_MASK;
 637  }
 638 @@ -135,10 +135,10 @@ static bool ath9k_hw_def_fill_eeprom(str
 639  static u32 ath9k_def_dump_modal_eeprom(char *buf, u32 len, u32 size,
 640                                        struct modal_eep_header *modal_hdr)
 641  {
 642 -       PR_EEP("Chain0 Ant. Control", modal_hdr->antCtrlChain[0]);
 643 -       PR_EEP("Chain1 Ant. Control", modal_hdr->antCtrlChain[1]);
 644 -       PR_EEP("Chain2 Ant. Control", modal_hdr->antCtrlChain[2]);
 645 -       PR_EEP("Ant. Common Control", modal_hdr->antCtrlCommon);
 646 +       PR_EEP("Chain0 Ant. Control", le16_to_cpu(modal_hdr->antCtrlChain[0]));
 647 +       PR_EEP("Chain1 Ant. Control", le16_to_cpu(modal_hdr->antCtrlChain[1]));
 648 +       PR_EEP("Chain2 Ant. Control", le16_to_cpu(modal_hdr->antCtrlChain[2]));
 649 +       PR_EEP("Ant. Common Control", le32_to_cpu(modal_hdr->antCtrlCommon));
 650         PR_EEP("Chain0 Ant. Gain", modal_hdr->antennaGainCh[0]);
 651         PR_EEP("Chain1 Ant. Gain", modal_hdr->antennaGainCh[1]);
 652         PR_EEP("Chain2 Ant. Gain", modal_hdr->antennaGainCh[2]);
 653 @@ -194,9 +194,9 @@ static u32 ath9k_def_dump_modal_eeprom(c
 654         PR_EEP("Chain1 OutputBias", modal_hdr->ob_ch1);
 655         PR_EEP("Chain1 DriverBias", modal_hdr->db_ch1);
 656         PR_EEP("LNA Control", modal_hdr->lna_ctl);
 657 -       PR_EEP("XPA Bias Freq0", modal_hdr->xpaBiasLvlFreq[0]);
 658 -       PR_EEP("XPA Bias Freq1", modal_hdr->xpaBiasLvlFreq[1]);
 659 -       PR_EEP("XPA Bias Freq2", modal_hdr->xpaBiasLvlFreq[2]);
 660 +       PR_EEP("XPA Bias Freq0", le16_to_cpu(modal_hdr->xpaBiasLvlFreq[0]));
 661 +       PR_EEP("XPA Bias Freq1", le16_to_cpu(modal_hdr->xpaBiasLvlFreq[1]));
 662 +       PR_EEP("XPA Bias Freq2", le16_to_cpu(modal_hdr->xpaBiasLvlFreq[2]));
 663
 664         return len;
 665  }
 666 @@ -206,6 +206,7 @@ static u32 ath9k_hw_def_dump_eeprom(stru
 667  {
 668         struct ar5416_eeprom_def *eep = &ah->eeprom.def;
 669         struct base_eep_header *pBase = &eep->baseEepHeader;
 670 +       u32 binBuildNumber = le32_to_cpu(pBase->binBuildNumber);
 671
 672         if (!dump_base_hdr) {
 673                 len += scnprintf(buf + len, size - len,
 674 @@ -221,10 +222,10 @@ static u32 ath9k_hw_def_dump_eeprom(stru
 675
 676         PR_EEP("Major Version", ath9k_hw_def_get_eeprom_ver(ah));
 677         PR_EEP("Minor Version", ath9k_hw_def_get_eeprom_rev(ah));
 678 -       PR_EEP("Checksum", pBase->checksum);
 679 -       PR_EEP("Length", pBase->length);
 680 -       PR_EEP("RegDomain1", pBase->regDmn[0]);
 681 -       PR_EEP("RegDomain2", pBase->regDmn[1]);
 682 +       PR_EEP("Checksum", le16_to_cpu(pBase->checksum));
 683 +       PR_EEP("Length", le16_to_cpu(pBase->length));
 684 +       PR_EEP("RegDomain1", le16_to_cpu(pBase->regDmn[0]));
 685 +       PR_EEP("RegDomain2", le16_to_cpu(pBase->regDmn[1]));
 686         PR_EEP("TX Mask", pBase->txMask);
 687         PR_EEP("RX Mask", pBase->rxMask);
 688         PR_EEP("Allow 5GHz", !!(pBase->opCapFlags & AR5416_OPFLAGS_11A));
 689 @@ -238,9 +239,9 @@ static u32 ath9k_hw_def_dump_eeprom(stru
 690         PR_EEP("Disable 5Ghz HT40", !!(pBase->opCapFlags &
 691                                         AR5416_OPFLAGS_N_5G_HT40));
 692         PR_EEP("Big Endian", !!(pBase->eepMisc & AR5416_EEPMISC_BIG_ENDIAN));
 693 -       PR_EEP("Cal Bin Major Ver", (pBase->binBuildNumber >> 24) & 0xFF);
 694 -       PR_EEP("Cal Bin Minor Ver", (pBase->binBuildNumber >> 16) & 0xFF);
 695 -       PR_EEP("Cal Bin Build", (pBase->binBuildNumber >> 8) & 0xFF);
 696 +       PR_EEP("Cal Bin Major Ver", (binBuildNumber >> 24) & 0xFF);
 697 +       PR_EEP("Cal Bin Minor Ver", (binBuildNumber >> 16) & 0xFF);
 698 +       PR_EEP("Cal Bin Build", (binBuildNumber >> 8) & 0xFF);
 699         PR_EEP("OpenLoop Power Ctrl", pBase->openLoopPwrCntl);
 700
 701         len += scnprintf(buf + len, size - len, "%20s : %pM\n", "MacAddress",
 702 @@ -273,61 +274,40 @@ static int ath9k_hw_def_check_eeprom(str
 703                 return err;
 704
 705         if (need_swap)
 706 -               el = swab16(eep->baseEepHeader.length);
 707 +               el = swab16((__force u16)eep->baseEepHeader.length);
 708         else
 709 -               el = eep->baseEepHeader.length;
 710 +               el = le16_to_cpu(eep->baseEepHeader.length);
 711
 712         el = min(el / sizeof(u16), SIZE_EEPROM_DEF);
 713         if (!ath9k_hw_nvram_validate_checksum(ah, el))
 714                 return -EINVAL;
 715
 716         if (need_swap) {
 717 -               u32 integer, j;
 718 -               u16 word;
 719 +               u32 j;
 720
 721 -               word = swab16(eep->baseEepHeader.length);
 722 -               eep->baseEepHeader.length = word;
 723 -
 724 -               word = swab16(eep->baseEepHeader.checksum);
 725 -               eep->baseEepHeader.checksum = word;
 726 -
 727 -               word = swab16(eep->baseEepHeader.version);
 728 -               eep->baseEepHeader.version = word;
 729 -
 730 -               word = swab16(eep->baseEepHeader.regDmn[0]);
 731 -               eep->baseEepHeader.regDmn[0] = word;
 732 -
 733 -               word = swab16(eep->baseEepHeader.regDmn[1]);
 734 -               eep->baseEepHeader.regDmn[1] = word;
 735 -
 736 -               word = swab16(eep->baseEepHeader.rfSilent);
 737 -               eep->baseEepHeader.rfSilent = word;
 738 -
 739 -               word = swab16(eep->baseEepHeader.blueToothOptions);
 740 -               eep->baseEepHeader.blueToothOptions = word;
 741 -
 742 -               word = swab16(eep->baseEepHeader.deviceCap);
 743 -               eep->baseEepHeader.deviceCap = word;
 744 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.length);
 745 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.checksum);
 746 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.version);
 747 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.regDmn[0]);
 748 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.regDmn[1]);
 749 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.rfSilent);
 750 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.blueToothOptions);
 751 +               EEPROM_FIELD_SWAB16(eep->baseEepHeader.deviceCap);
 752
 753                 for (j = 0; j < ARRAY_SIZE(eep->modalHeader); j++) {
 754                         struct modal_eep_header *pModal =
 755                                 &eep->modalHeader[j];
 756 -                       integer = swab32(pModal->antCtrlCommon);
 757 -                       pModal->antCtrlCommon = integer;
 758 +                       EEPROM_FIELD_SWAB32(pModal->antCtrlCommon);
 759
 760 -                       for (i = 0; i < AR5416_MAX_CHAINS; i++) {
 761 -                               integer = swab32(pModal->antCtrlChain[i]);
 762 -                               pModal->antCtrlChain[i] = integer;
 763 -                       }
 764 -                       for (i = 0; i < 3; i++) {
 765 -                               word = swab16(pModal->xpaBiasLvlFreq[i]);
 766 -                               pModal->xpaBiasLvlFreq[i] = word;
 767 -                       }
 768 +                       for (i = 0; i < AR5416_MAX_CHAINS; i++)
 769 +                               EEPROM_FIELD_SWAB32(pModal->antCtrlChain[i]);
 770
 771 -                       for (i = 0; i < AR_EEPROM_MODAL_SPURS; i++) {
 772 -                               word = swab16(pModal->spurChans[i].spurChan);
 773 -                               pModal->spurChans[i].spurChan = word;
 774 -                       }
 775 +                       for (i = 0; i < 3; i++)
 776 +                               EEPROM_FIELD_SWAB16(pModal->xpaBiasLvlFreq[i]);
 777 +
 778 +                       for (i = 0; i < AR_EEPROM_MODAL_SPURS; i++)
 779 +                               EEPROM_FIELD_SWAB16(
 780 +                                       pModal->spurChans[i].spurChan);
 781                 }
 782         }
 783
 784 @@ -337,7 +317,7 @@ static int ath9k_hw_def_check_eeprom(str
 785
 786         /* Enable fixup for AR_AN_TOP2 if necessary */
 787         if ((ah->hw_version.devid == AR9280_DEVID_PCI) &&
 788 -           ((eep->baseEepHeader.version & 0xff) > 0x0a) &&
 789 +           ((le16_to_cpu(eep->baseEepHeader.version) & 0xff) > 0x0a) &&
 790             (eep->baseEepHeader.pwdclkind == 0))
 791                 ah->need_an_top2_fixup = true;
 792
 793 @@ -370,13 +350,13 @@ static u32 ath9k_hw_def_get_eeprom(struc
 794         case EEP_MAC_MSW:
 795                 return get_unaligned_be16(pBase->macAddr + 4);
 796         case EEP_REG_0:
 797 -               return pBase->regDmn[0];
 798 +               return le16_to_cpu(pBase->regDmn[0]);
 799         case EEP_OP_CAP:
 800 -               return pBase->deviceCap;
 801 +               return le16_to_cpu(pBase->deviceCap);
 802         case EEP_OP_MODE:
 803                 return pBase->opCapFlags;
 804         case EEP_RF_SILENT:
 805 -               return pBase->rfSilent;
 806 +               return le16_to_cpu(pBase->rfSilent);
 807         case EEP_OB_5:
 808                 return pModal[0].ob;
 809         case EEP_DB_5:
 810 @@ -490,11 +470,13 @@ static void ath9k_hw_def_set_board_value
 811         struct ar5416_eeprom_def *eep = &ah->eeprom.def;
 812         int i, regChainOffset;
 813         u8 txRxAttenLocal;
 814 +       u32 antCtrlCommon;
 815
 816         pModal = &(eep->modalHeader[IS_CHAN_2GHZ(chan)]);
 817         txRxAttenLocal = IS_CHAN_2GHZ(chan) ? 23 : 44;
 818 +       antCtrlCommon = le32_to_cpu(pModal->antCtrlCommon);
 819
 820 -       REG_WRITE(ah, AR_PHY_SWITCH_COM, pModal->antCtrlCommon & 0xffff);
 821 +       REG_WRITE(ah, AR_PHY_SWITCH_COM, antCtrlCommon & 0xffff);
 822
 823         for (i = 0; i < AR5416_MAX_CHAINS; i++) {
 824                 if (AR_SREV_9280(ah)) {
 825 @@ -508,7 +490,7 @@ static void ath9k_hw_def_set_board_value
 826                         regChainOffset = i * 0x1000;
 827
 828                 REG_WRITE(ah, AR_PHY_SWITCH_CHAIN_0 + regChainOffset,
 829 -                         pModal->antCtrlChain[i]);
 830 +                         le32_to_cpu(pModal->antCtrlChain[i]));
 831
 832                 REG_WRITE(ah, AR_PHY_TIMING_CTRL4(0) + regChainOffset,
 833                           (REG_READ(ah, AR_PHY_TIMING_CTRL4(0) + regChainOffset) &
 834 @@ -655,7 +637,7 @@ static void ath9k_hw_def_set_board_value
 835  static void ath9k_hw_def_set_addac(struct ath_hw *ah,
 836                                    struct ath9k_channel *chan)
 837  {
 838 -#define XPA_LVL_FREQ(cnt) (pModal->xpaBiasLvlFreq[cnt])
 839 +#define XPA_LVL_FREQ(cnt) (le16_to_cpu(pModal->xpaBiasLvlFreq[cnt]))
 840         struct modal_eep_header *pModal;
 841         struct ar5416_eeprom_def *eep = &ah->eeprom.def;
 842         u8 biaslevel;
 843 @@ -1315,7 +1297,9 @@ static void ath9k_hw_def_set_txpower(str
 844
 845  static u16 ath9k_hw_def_get_spur_channel(struct ath_hw *ah, u16 i, bool is2GHz)
 846  {
 847 -       return ah->eeprom.def.modalHeader[is2GHz].spurChans[i].spurChan;
 848 +       __le16 spch = ah->eeprom.def.modalHeader[is2GHz].spurChans[i].spurChan;
 849 +
 850 +       return le16_to_cpu(spch);
 851  }
 852
 853  static u8 ath9k_hw_def_get_eepmisc(struct ath_hw *ah)