tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

airo: last of endianness annotations

sanitize handling of ConfigRid

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

authored by

Al Viro and committed by
David S. Miller 3eb9b41f 329e2c00

+218 -226
+218 -226
drivers/net/wireless/airo.c
··· 520 520 } SsidRid; 521 521 522 522 typedef struct { 523 - u16 len; 524 - u16 modulation; 525 - #define MOD_DEFAULT 0 526 - #define MOD_CCK 1 527 - #define MOD_MOK 2 523 + __le16 len; 524 + __le16 modulation; 525 + #define MOD_DEFAULT cpu_to_le16(0) 526 + #define MOD_CCK cpu_to_le16(1) 527 + #define MOD_MOK cpu_to_le16(2) 528 528 } ModulationRid; 529 529 530 530 typedef struct { 531 - u16 len; /* sizeof(ConfigRid) */ 532 - u16 opmode; /* operating mode */ 533 - #define MODE_STA_IBSS 0 534 - #define MODE_STA_ESS 1 535 - #define MODE_AP 2 536 - #define MODE_AP_RPTR 3 537 - #define MODE_ETHERNET_HOST (0<<8) /* rx payloads converted */ 538 - #define MODE_LLC_HOST (1<<8) /* rx payloads left as is */ 539 - #define MODE_AIRONET_EXTEND (1<<9) /* enable Aironet extenstions */ 540 - #define MODE_AP_INTERFACE (1<<10) /* enable ap interface extensions */ 541 - #define MODE_ANTENNA_ALIGN (1<<11) /* enable antenna alignment */ 542 - #define MODE_ETHER_LLC (1<<12) /* enable ethernet LLC */ 543 - #define MODE_LEAF_NODE (1<<13) /* enable leaf node bridge */ 544 - #define MODE_CF_POLLABLE (1<<14) /* enable CF pollable */ 545 - #define MODE_MIC (1<<15) /* enable MIC */ 546 - u16 rmode; /* receive mode */ 547 - #define RXMODE_BC_MC_ADDR 0 548 - #define RXMODE_BC_ADDR 1 /* ignore multicasts */ 549 - #define RXMODE_ADDR 2 /* ignore multicast and broadcast */ 550 - #define RXMODE_RFMON 3 /* wireless monitor mode */ 551 - #define RXMODE_RFMON_ANYBSS 4 552 - #define RXMODE_LANMON 5 /* lan style monitor -- data packets only */ 553 - #define RXMODE_DISABLE_802_3_HEADER (1<<8) /* disables 802.3 header on rx */ 554 - #define RXMODE_NORMALIZED_RSSI (1<<9) /* return normalized RSSI */ 555 - u16 fragThresh; 556 - u16 rtsThres; 531 + __le16 len; /* sizeof(ConfigRid) */ 532 + __le16 opmode; /* operating mode */ 533 + #define MODE_STA_IBSS cpu_to_le16(0) 534 + #define MODE_STA_ESS cpu_to_le16(1) 535 + #define MODE_AP cpu_to_le16(2) 536 + #define MODE_AP_RPTR cpu_to_le16(3) 537 + #define MODE_CFG_MASK cpu_to_le16(0xff) 538 + #define MODE_ETHERNET_HOST cpu_to_le16(0<<8) /* rx payloads converted */ 539 + #define MODE_LLC_HOST cpu_to_le16(1<<8) /* rx payloads left as is */ 540 + #define MODE_AIRONET_EXTEND cpu_to_le16(1<<9) /* enable Aironet extenstions */ 541 + #define MODE_AP_INTERFACE cpu_to_le16(1<<10) /* enable ap interface extensions */ 542 + #define MODE_ANTENNA_ALIGN cpu_to_le16(1<<11) /* enable antenna alignment */ 543 + #define MODE_ETHER_LLC cpu_to_le16(1<<12) /* enable ethernet LLC */ 544 + #define MODE_LEAF_NODE cpu_to_le16(1<<13) /* enable leaf node bridge */ 545 + #define MODE_CF_POLLABLE cpu_to_le16(1<<14) /* enable CF pollable */ 546 + #define MODE_MIC cpu_to_le16(1<<15) /* enable MIC */ 547 + __le16 rmode; /* receive mode */ 548 + #define RXMODE_BC_MC_ADDR cpu_to_le16(0) 549 + #define RXMODE_BC_ADDR cpu_to_le16(1) /* ignore multicasts */ 550 + #define RXMODE_ADDR cpu_to_le16(2) /* ignore multicast and broadcast */ 551 + #define RXMODE_RFMON cpu_to_le16(3) /* wireless monitor mode */ 552 + #define RXMODE_RFMON_ANYBSS cpu_to_le16(4) 553 + #define RXMODE_LANMON cpu_to_le16(5) /* lan style monitor -- data packets only */ 554 + #define RXMODE_MASK cpu_to_le16(255) 555 + #define RXMODE_DISABLE_802_3_HEADER cpu_to_le16(1<<8) /* disables 802.3 header on rx */ 556 + #define RXMODE_FULL_MASK (RXMODE_MASK | RXMODE_DISABLE_802_3_HEADER) 557 + #define RXMODE_NORMALIZED_RSSI cpu_to_le16(1<<9) /* return normalized RSSI */ 558 + __le16 fragThresh; 559 + __le16 rtsThres; 557 560 u8 macAddr[ETH_ALEN]; 558 561 u8 rates[8]; 559 - u16 shortRetryLimit; 560 - u16 longRetryLimit; 561 - u16 txLifetime; /* in kusec */ 562 - u16 rxLifetime; /* in kusec */ 563 - u16 stationary; 564 - u16 ordering; 565 - u16 u16deviceType; /* for overriding device type */ 566 - u16 cfpRate; 567 - u16 cfpDuration; 568 - u16 _reserved1[3]; 562 + __le16 shortRetryLimit; 563 + __le16 longRetryLimit; 564 + __le16 txLifetime; /* in kusec */ 565 + __le16 rxLifetime; /* in kusec */ 566 + __le16 stationary; 567 + __le16 ordering; 568 + __le16 u16deviceType; /* for overriding device type */ 569 + __le16 cfpRate; 570 + __le16 cfpDuration; 571 + __le16 _reserved1[3]; 569 572 /*---------- Scanning/Associating ----------*/ 570 - u16 scanMode; 571 - #define SCANMODE_ACTIVE 0 572 - #define SCANMODE_PASSIVE 1 573 - #define SCANMODE_AIROSCAN 2 574 - u16 probeDelay; /* in kusec */ 575 - u16 probeEnergyTimeout; /* in kusec */ 576 - u16 probeResponseTimeout; 577 - u16 beaconListenTimeout; 578 - u16 joinNetTimeout; 579 - u16 authTimeout; 580 - u16 authType; 581 - #define AUTH_OPEN 0x1 582 - #define AUTH_ENCRYPT 0x101 583 - #define AUTH_SHAREDKEY 0x102 584 - #define AUTH_ALLOW_UNENCRYPTED 0x200 585 - u16 associationTimeout; 586 - u16 specifiedApTimeout; 587 - u16 offlineScanInterval; 588 - u16 offlineScanDuration; 589 - u16 linkLossDelay; 590 - u16 maxBeaconLostTime; 591 - u16 refreshInterval; 592 - #define DISABLE_REFRESH 0xFFFF 593 - u16 _reserved1a[1]; 573 + __le16 scanMode; 574 + #define SCANMODE_ACTIVE cpu_to_le16(0) 575 + #define SCANMODE_PASSIVE cpu_to_le16(1) 576 + #define SCANMODE_AIROSCAN cpu_to_le16(2) 577 + __le16 probeDelay; /* in kusec */ 578 + __le16 probeEnergyTimeout; /* in kusec */ 579 + __le16 probeResponseTimeout; 580 + __le16 beaconListenTimeout; 581 + __le16 joinNetTimeout; 582 + __le16 authTimeout; 583 + __le16 authType; 584 + #define AUTH_OPEN cpu_to_le16(0x1) 585 + #define AUTH_ENCRYPT cpu_to_le16(0x101) 586 + #define AUTH_SHAREDKEY cpu_to_le16(0x102) 587 + #define AUTH_ALLOW_UNENCRYPTED cpu_to_le16(0x200) 588 + __le16 associationTimeout; 589 + __le16 specifiedApTimeout; 590 + __le16 offlineScanInterval; 591 + __le16 offlineScanDuration; 592 + __le16 linkLossDelay; 593 + __le16 maxBeaconLostTime; 594 + __le16 refreshInterval; 595 + #define DISABLE_REFRESH cpu_to_le16(0xFFFF) 596 + __le16 _reserved1a[1]; 594 597 /*---------- Power save operation ----------*/ 595 - u16 powerSaveMode; 596 - #define POWERSAVE_CAM 0 597 - #define POWERSAVE_PSP 1 598 - #define POWERSAVE_PSPCAM 2 599 - u16 sleepForDtims; 600 - u16 listenInterval; 601 - u16 fastListenInterval; 602 - u16 listenDecay; 603 - u16 fastListenDelay; 604 - u16 _reserved2[2]; 598 + __le16 powerSaveMode; 599 + #define POWERSAVE_CAM cpu_to_le16(0) 600 + #define POWERSAVE_PSP cpu_to_le16(1) 601 + #define POWERSAVE_PSPCAM cpu_to_le16(2) 602 + __le16 sleepForDtims; 603 + __le16 listenInterval; 604 + __le16 fastListenInterval; 605 + __le16 listenDecay; 606 + __le16 fastListenDelay; 607 + __le16 _reserved2[2]; 605 608 /*---------- Ap/Ibss config items ----------*/ 606 - u16 beaconPeriod; 607 - u16 atimDuration; 608 - u16 hopPeriod; 609 - u16 channelSet; 610 - u16 channel; 611 - u16 dtimPeriod; 612 - u16 bridgeDistance; 613 - u16 radioID; 609 + __le16 beaconPeriod; 610 + __le16 atimDuration; 611 + __le16 hopPeriod; 612 + __le16 channelSet; 613 + __le16 channel; 614 + __le16 dtimPeriod; 615 + __le16 bridgeDistance; 616 + __le16 radioID; 614 617 /*---------- Radio configuration ----------*/ 615 - u16 radioType; 616 - #define RADIOTYPE_DEFAULT 0 617 - #define RADIOTYPE_802_11 1 618 - #define RADIOTYPE_LEGACY 2 618 + __le16 radioType; 619 + #define RADIOTYPE_DEFAULT cpu_to_le16(0) 620 + #define RADIOTYPE_802_11 cpu_to_le16(1) 621 + #define RADIOTYPE_LEGACY cpu_to_le16(2) 619 622 u8 rxDiversity; 620 623 u8 txDiversity; 621 - u16 txPower; 624 + __le16 txPower; 622 625 #define TXPOWER_DEFAULT 0 623 - u16 rssiThreshold; 626 + __le16 rssiThreshold; 624 627 #define RSSI_DEFAULT 0 625 - u16 modulation; 626 - #define PREAMBLE_AUTO 0 627 - #define PREAMBLE_LONG 1 628 - #define PREAMBLE_SHORT 2 629 - u16 preamble; 630 - u16 homeProduct; 631 - u16 radioSpecific; 628 + __le16 modulation; 629 + #define PREAMBLE_AUTO cpu_to_le16(0) 630 + #define PREAMBLE_LONG cpu_to_le16(1) 631 + #define PREAMBLE_SHORT cpu_to_le16(2) 632 + __le16 preamble; 633 + __le16 homeProduct; 634 + __le16 radioSpecific; 632 635 /*---------- Aironet Extensions ----------*/ 633 636 u8 nodeName[16]; 634 - u16 arlThreshold; 635 - u16 arlDecay; 636 - u16 arlDelay; 637 - u16 _reserved4[1]; 637 + __le16 arlThreshold; 638 + __le16 arlDecay; 639 + __le16 arlDelay; 640 + __le16 _reserved4[1]; 638 641 /*---------- Aironet Extensions ----------*/ 639 642 u8 magicAction; 640 643 #define MAGIC_ACTION_STSCHG 1 ··· 647 644 #define MAGIC_SWITCH_TO_PSP (0<<10) 648 645 #define MAGIC_STAY_IN_CAM (1<<10) 649 646 u8 magicControl; 650 - u16 autoWake; 647 + __le16 autoWake; 651 648 } ConfigRid; 652 649 653 650 typedef struct { ··· 1783 1780 return PC4500_writerid(ai, RID_SSID, pssidr, sizeof(*pssidr), lock); 1784 1781 } 1785 1782 1786 - static int readConfigRid(struct airo_info*ai, int lock) { 1783 + static int readConfigRid(struct airo_info *ai, int lock) 1784 + { 1787 1785 int rc; 1788 - u16 *s; 1789 1786 ConfigRid cfg; 1790 1787 1791 1788 if (ai->config.len) ··· 1795 1792 if (rc != SUCCESS) 1796 1793 return rc; 1797 1794 1798 - for(s = &cfg.len; s <= &cfg.rtsThres; s++) *s = le16_to_cpu(*s); 1799 - 1800 - for(s = &cfg.shortRetryLimit; s <= &cfg.radioType; s++) 1801 - *s = le16_to_cpu(*s); 1802 - 1803 - for(s = &cfg.txPower; s <= &cfg.radioSpecific; s++) 1804 - *s = le16_to_cpu(*s); 1805 - 1806 - for(s = &cfg.arlThreshold; s <= &cfg._reserved4[0]; s++) 1807 - *s = cpu_to_le16(*s); 1808 - 1809 - for(s = &cfg.autoWake; s <= &cfg.autoWake; s++) 1810 - *s = cpu_to_le16(*s); 1811 - 1812 1795 ai->config = cfg; 1813 1796 return SUCCESS; 1814 1797 } 1815 - static inline void checkThrottle(struct airo_info *ai) { 1798 + 1799 + static inline void checkThrottle(struct airo_info *ai) 1800 + { 1816 1801 int i; 1817 1802 /* Old hardware had a limit on encryption speed */ 1818 1803 if (ai->config.authType != AUTH_OPEN && maxencrypt) { ··· 1811 1820 } 1812 1821 } 1813 1822 } 1814 - static int writeConfigRid(struct airo_info*ai, int lock) { 1815 - u16 *s; 1823 + 1824 + static int writeConfigRid(struct airo_info *ai, int lock) 1825 + { 1816 1826 ConfigRid cfgr; 1817 1827 1818 1828 if (!test_bit (FLAG_COMMIT, &ai->flags)) ··· 1824 1832 checkThrottle(ai); 1825 1833 cfgr = ai->config; 1826 1834 1827 - if ((cfgr.opmode & 0xFF) == MODE_STA_IBSS) 1835 + if ((cfgr.opmode & MODE_CFG_MASK) == MODE_STA_IBSS) 1828 1836 set_bit(FLAG_ADHOC, &ai->flags); 1829 1837 else 1830 1838 clear_bit(FLAG_ADHOC, &ai->flags); 1831 - 1832 - for(s = &cfgr.len; s <= &cfgr.rtsThres; s++) *s = cpu_to_le16(*s); 1833 - 1834 - for(s = &cfgr.shortRetryLimit; s <= &cfgr.radioType; s++) 1835 - *s = cpu_to_le16(*s); 1836 - 1837 - for(s = &cfgr.txPower; s <= &cfgr.radioSpecific; s++) 1838 - *s = cpu_to_le16(*s); 1839 - 1840 - for(s = &cfgr.arlThreshold; s <= &cfgr._reserved4[0]; s++) 1841 - *s = cpu_to_le16(*s); 1842 - 1843 - for(s = &cfgr.autoWake; s <= &cfgr.autoWake; s++) 1844 - *s = cpu_to_le16(*s); 1845 1839 1846 1840 return PC4500_writerid( ai, RID_CONFIG, &cfgr, sizeof(cfgr), lock); 1847 1841 } ··· 4766 4788 struct iw_request_info *info, void *zwrq, 4767 4789 char *extra); 4768 4790 4769 - static void proc_config_on_close( struct inode *inode, struct file *file ) { 4791 + static inline int sniffing_mode(struct airo_info *ai) 4792 + { 4793 + return le16_to_cpu(ai->config.rmode & RXMODE_MASK) >= 4794 + le16_to_cpu(RXMODE_RFMON); 4795 + } 4796 + 4797 + static void proc_config_on_close(struct inode *inode, struct file *file) 4798 + { 4770 4799 struct proc_data *data = file->private_data; 4771 4800 struct proc_dir_entry *dp = PDE(inode); 4772 4801 struct net_device *dev = dp->data; ··· 4790 4805 /*** Mode processing */ 4791 4806 if ( !strncmp( line, "Mode: ", 6 ) ) { 4792 4807 line += 6; 4793 - if ((ai->config.rmode & 0xff) >= RXMODE_RFMON) 4794 - set_bit (FLAG_RESET, &ai->flags); 4795 - ai->config.rmode &= 0xfe00; 4808 + if (sniffing_mode(ai)) 4809 + set_bit (FLAG_RESET, &ai->flags); 4810 + ai->config.rmode &= ~RXMODE_FULL_MASK; 4796 4811 clear_bit (FLAG_802_11, &ai->flags); 4797 - ai->config.opmode &= 0xFF00; 4812 + ai->config.opmode &= ~MODE_CFG_MASK; 4798 4813 ai->config.scanMode = SCANMODE_ACTIVE; 4799 4814 if ( line[0] == 'a' ) { 4800 - ai->config.opmode |= 0; 4815 + ai->config.opmode |= MODE_STA_IBSS; 4801 4816 } else { 4802 - ai->config.opmode |= 1; 4817 + ai->config.opmode |= MODE_STA_ESS; 4803 4818 if ( line[0] == 'r' ) { 4804 4819 ai->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER; 4805 4820 ai->config.scanMode = SCANMODE_PASSIVE; ··· 4865 4880 line += 9; 4866 4881 v = get_dec_u16(line, &i, i+3); 4867 4882 if ( v != -1 ) { 4868 - ai->config.channelSet = (u16)v; 4883 + ai->config.channelSet = cpu_to_le16(v); 4869 4884 set_bit (FLAG_COMMIT, &ai->flags); 4870 4885 } 4871 4886 } else if ( !strncmp( line, "XmitPower: ", 11 ) ) { ··· 4873 4888 line += 11; 4874 4889 v = get_dec_u16(line, &i, i+3); 4875 4890 if ( v != -1 ) { 4876 - ai->config.txPower = (u16)v; 4891 + ai->config.txPower = cpu_to_le16(v); 4877 4892 set_bit (FLAG_COMMIT, &ai->flags); 4878 4893 } 4879 4894 } else if ( !strncmp( line, "WEP: ", 5 ) ) { 4880 4895 line += 5; 4881 4896 switch( line[0] ) { 4882 4897 case 's': 4883 - ai->config.authType = (u16)AUTH_SHAREDKEY; 4898 + ai->config.authType = AUTH_SHAREDKEY; 4884 4899 break; 4885 4900 case 'e': 4886 - ai->config.authType = (u16)AUTH_ENCRYPT; 4901 + ai->config.authType = AUTH_ENCRYPT; 4887 4902 break; 4888 4903 default: 4889 - ai->config.authType = (u16)AUTH_OPEN; 4904 + ai->config.authType = AUTH_OPEN; 4890 4905 break; 4891 4906 } 4892 4907 set_bit (FLAG_COMMIT, &ai->flags); ··· 4896 4911 line += 16; 4897 4912 v = get_dec_u16(line, &i, 3); 4898 4913 v = (v<0) ? 0 : ((v>255) ? 255 : v); 4899 - ai->config.longRetryLimit = (u16)v; 4914 + ai->config.longRetryLimit = cpu_to_le16(v); 4900 4915 set_bit (FLAG_COMMIT, &ai->flags); 4901 4916 } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) { 4902 4917 int v, i = 0; ··· 4904 4919 line += 17; 4905 4920 v = get_dec_u16(line, &i, 3); 4906 4921 v = (v<0) ? 0 : ((v>255) ? 255 : v); 4907 - ai->config.shortRetryLimit = (u16)v; 4922 + ai->config.shortRetryLimit = cpu_to_le16(v); 4908 4923 set_bit (FLAG_COMMIT, &ai->flags); 4909 4924 } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) { 4910 4925 int v, i = 0; ··· 4912 4927 line += 14; 4913 4928 v = get_dec_u16(line, &i, 4); 4914 4929 v = (v<0) ? 0 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v); 4915 - ai->config.rtsThres = (u16)v; 4930 + ai->config.rtsThres = cpu_to_le16(v); 4916 4931 set_bit (FLAG_COMMIT, &ai->flags); 4917 4932 } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) { 4918 4933 int v, i = 0; ··· 4920 4935 line += 16; 4921 4936 v = get_dec_u16(line, &i, 5); 4922 4937 v = (v<0) ? 0 : v; 4923 - ai->config.txLifetime = (u16)v; 4938 + ai->config.txLifetime = cpu_to_le16(v); 4924 4939 set_bit (FLAG_COMMIT, &ai->flags); 4925 4940 } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) { 4926 4941 int v, i = 0; ··· 4928 4943 line += 16; 4929 4944 v = get_dec_u16(line, &i, 5); 4930 4945 v = (v<0) ? 0 : v; 4931 - ai->config.rxLifetime = (u16)v; 4946 + ai->config.rxLifetime = cpu_to_le16(v); 4932 4947 set_bit (FLAG_COMMIT, &ai->flags); 4933 4948 } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) { 4934 4949 ai->config.txDiversity = ··· 4947 4962 v = get_dec_u16(line, &i, 4); 4948 4963 v = (v<256) ? 256 : ((v>AIRO_DEF_MTU) ? AIRO_DEF_MTU : v); 4949 4964 v = v & 0xfffe; /* Make sure its even */ 4950 - ai->config.fragThresh = (u16)v; 4965 + ai->config.fragThresh = cpu_to_le16(v); 4951 4966 set_bit (FLAG_COMMIT, &ai->flags); 4952 4967 } else if (!strncmp(line, "Modulation: ", 12)) { 4953 4968 line += 12; ··· 4974 4989 airo_config_commit(dev, NULL, NULL, NULL); 4975 4990 } 4976 4991 4977 - static char *get_rmode(u16 mode) { 4978 - switch(mode&0xff) { 4992 + static char *get_rmode(__le16 mode) 4993 + { 4994 + switch(mode & RXMODE_MASK) { 4979 4995 case RXMODE_RFMON: return "rfmon"; 4980 4996 case RXMODE_RFMON_ANYBSS: return "yna (any) bss rfmon"; 4981 4997 case RXMODE_LANMON: return "lanmon"; ··· 4984 4998 return "ESS"; 4985 4999 } 4986 5000 4987 - static int proc_config_open( struct inode *inode, struct file *file ) { 5001 + static int proc_config_open(struct inode *inode, struct file *file) 5002 + { 4988 5003 struct proc_data *data; 4989 5004 struct proc_dir_entry *dp = PDE(inode); 4990 5005 struct net_device *dev = dp->data; 4991 5006 struct airo_info *ai = dev->priv; 4992 5007 int i; 5008 + __le16 mode; 4993 5009 4994 5010 if ((file->private_data = kzalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL) 4995 5011 return -ENOMEM; ··· 5010 5022 5011 5023 readConfigRid(ai, 1); 5012 5024 5025 + mode = ai->config.opmode & MODE_CFG_MASK; 5013 5026 i = sprintf( data->rbuffer, 5014 5027 "Mode: %s\n" 5015 5028 "Radio: %s\n" ··· 5019 5030 "DataRates: %d %d %d %d %d %d %d %d\n" 5020 5031 "Channel: %d\n" 5021 5032 "XmitPower: %d\n", 5022 - (ai->config.opmode & 0xFF) == 0 ? "adhoc" : 5023 - (ai->config.opmode & 0xFF) == 1 ? get_rmode(ai->config.rmode): 5024 - (ai->config.opmode & 0xFF) == 2 ? "AP" : 5025 - (ai->config.opmode & 0xFF) == 3 ? "AP RPTR" : "Error", 5033 + mode == MODE_STA_IBSS ? "adhoc" : 5034 + mode == MODE_STA_ESS ? get_rmode(ai->config.rmode): 5035 + mode == MODE_AP ? "AP" : 5036 + mode == MODE_AP_RPTR ? "AP RPTR" : "Error", 5026 5037 test_bit(FLAG_RADIO_OFF, &ai->flags) ? "off" : "on", 5027 5038 ai->config.nodeName, 5028 - ai->config.powerSaveMode == 0 ? "CAM" : 5029 - ai->config.powerSaveMode == 1 ? "PSP" : 5030 - ai->config.powerSaveMode == 2 ? "PSPCAM" : "Error", 5039 + ai->config.powerSaveMode == POWERSAVE_CAM ? "CAM" : 5040 + ai->config.powerSaveMode == POWERSAVE_PSP ? "PSP" : 5041 + ai->config.powerSaveMode == POWERSAVE_PSPCAM ? "PSPCAM" : 5042 + "Error", 5031 5043 (int)ai->config.rates[0], 5032 5044 (int)ai->config.rates[1], 5033 5045 (int)ai->config.rates[2], ··· 5037 5047 (int)ai->config.rates[5], 5038 5048 (int)ai->config.rates[6], 5039 5049 (int)ai->config.rates[7], 5040 - (int)ai->config.channelSet, 5041 - (int)ai->config.txPower 5050 + le16_to_cpu(ai->config.channelSet), 5051 + le16_to_cpu(ai->config.txPower) 5042 5052 ); 5043 5053 sprintf( data->rbuffer + i, 5044 5054 "LongRetryLimit: %d\n" ··· 5052 5062 "WEP: %s\n" 5053 5063 "Modulation: %s\n" 5054 5064 "Preamble: %s\n", 5055 - (int)ai->config.longRetryLimit, 5056 - (int)ai->config.shortRetryLimit, 5057 - (int)ai->config.rtsThres, 5058 - (int)ai->config.txLifetime, 5059 - (int)ai->config.rxLifetime, 5065 + le16_to_cpu(ai->config.longRetryLimit), 5066 + le16_to_cpu(ai->config.shortRetryLimit), 5067 + le16_to_cpu(ai->config.rtsThres), 5068 + le16_to_cpu(ai->config.txLifetime), 5069 + le16_to_cpu(ai->config.rxLifetime), 5060 5070 ai->config.txDiversity == 1 ? "left" : 5061 5071 ai->config.txDiversity == 2 ? "right" : "both", 5062 5072 ai->config.rxDiversity == 1 ? "left" : 5063 5073 ai->config.rxDiversity == 2 ? "right" : "both", 5064 - (int)ai->config.fragThresh, 5074 + le16_to_cpu(ai->config.fragThresh), 5065 5075 ai->config.authType == AUTH_ENCRYPT ? "encrypt" : 5066 5076 ai->config.authType == AUTH_SHAREDKEY ? "shared" : "open", 5067 - ai->config.modulation == 0 ? "default" : 5077 + ai->config.modulation == MOD_DEFAULT ? "default" : 5068 5078 ai->config.modulation == MOD_CCK ? "cck" : 5069 5079 ai->config.modulation == MOD_MOK ? "mok" : "error", 5070 5080 ai->config.preamble == PREAMBLE_AUTO ? "auto" : ··· 5790 5800 } else { 5791 5801 readConfigRid(local, 1); 5792 5802 /* Yes ! We can set it !!! */ 5793 - local->config.channelSet = (u16) channel; 5803 + local->config.channelSet = cpu_to_le16(channel); 5794 5804 set_bit (FLAG_COMMIT, &local->flags); 5795 5805 } 5796 5806 } ··· 5811 5821 int ch; 5812 5822 5813 5823 readConfigRid(local, 1); 5814 - if ((local->config.opmode & 0xFF) == MODE_STA_ESS) 5815 - status_rid.channel = cpu_to_le16(local->config.channelSet); 5824 + if ((local->config.opmode & MODE_CFG_MASK) == MODE_STA_ESS) 5825 + status_rid.channel = local->config.channelSet; 5816 5826 else 5817 5827 readStatusRid(local, &status_rid, 1); 5818 5828 ··· 6112 6122 return -EINVAL; 6113 6123 } 6114 6124 readConfigRid(local, 1); 6115 - local->config.rtsThres = rthr; 6125 + local->config.rtsThres = cpu_to_le16(rthr); 6116 6126 set_bit (FLAG_COMMIT, &local->flags); 6117 6127 6118 6128 return -EINPROGRESS; /* Call commit handler */ ··· 6130 6140 struct airo_info *local = dev->priv; 6131 6141 6132 6142 readConfigRid(local, 1); 6133 - vwrq->value = local->config.rtsThres; 6143 + vwrq->value = le16_to_cpu(local->config.rtsThres); 6134 6144 vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU); 6135 6145 vwrq->fixed = 1; 6136 6146 ··· 6156 6166 } 6157 6167 fthr &= ~0x1; /* Get an even value - is it really needed ??? */ 6158 6168 readConfigRid(local, 1); 6159 - local->config.fragThresh = (u16)fthr; 6169 + local->config.fragThresh = cpu_to_le16(fthr); 6160 6170 set_bit (FLAG_COMMIT, &local->flags); 6161 6171 6162 6172 return -EINPROGRESS; /* Call commit handler */ ··· 6174 6184 struct airo_info *local = dev->priv; 6175 6185 6176 6186 readConfigRid(local, 1); 6177 - vwrq->value = local->config.fragThresh; 6187 + vwrq->value = le16_to_cpu(local->config.fragThresh); 6178 6188 vwrq->disabled = (vwrq->value >= AIRO_DEF_MTU); 6179 6189 vwrq->fixed = 1; 6180 6190 ··· 6194 6204 int reset = 0; 6195 6205 6196 6206 readConfigRid(local, 1); 6197 - if ((local->config.rmode & 0xff) >= RXMODE_RFMON) 6207 + if (sniffing_mode(local)) 6198 6208 reset = 1; 6199 6209 6200 6210 switch(*uwrq) { 6201 6211 case IW_MODE_ADHOC: 6202 - local->config.opmode &= 0xFF00; 6212 + local->config.opmode &= ~MODE_CFG_MASK; 6203 6213 local->config.opmode |= MODE_STA_IBSS; 6204 - local->config.rmode &= 0xfe00; 6214 + local->config.rmode &= ~RXMODE_FULL_MASK; 6205 6215 local->config.scanMode = SCANMODE_ACTIVE; 6206 6216 clear_bit (FLAG_802_11, &local->flags); 6207 6217 break; 6208 6218 case IW_MODE_INFRA: 6209 - local->config.opmode &= 0xFF00; 6219 + local->config.opmode &= ~MODE_CFG_MASK; 6210 6220 local->config.opmode |= MODE_STA_ESS; 6211 - local->config.rmode &= 0xfe00; 6221 + local->config.rmode &= ~RXMODE_FULL_MASK; 6212 6222 local->config.scanMode = SCANMODE_ACTIVE; 6213 6223 clear_bit (FLAG_802_11, &local->flags); 6214 6224 break; 6215 6225 case IW_MODE_MASTER: 6216 - local->config.opmode &= 0xFF00; 6226 + local->config.opmode &= ~MODE_CFG_MASK; 6217 6227 local->config.opmode |= MODE_AP; 6218 - local->config.rmode &= 0xfe00; 6228 + local->config.rmode &= ~RXMODE_FULL_MASK; 6219 6229 local->config.scanMode = SCANMODE_ACTIVE; 6220 6230 clear_bit (FLAG_802_11, &local->flags); 6221 6231 break; 6222 6232 case IW_MODE_REPEAT: 6223 - local->config.opmode &= 0xFF00; 6233 + local->config.opmode &= ~MODE_CFG_MASK; 6224 6234 local->config.opmode |= MODE_AP_RPTR; 6225 - local->config.rmode &= 0xfe00; 6235 + local->config.rmode &= ~RXMODE_FULL_MASK; 6226 6236 local->config.scanMode = SCANMODE_ACTIVE; 6227 6237 clear_bit (FLAG_802_11, &local->flags); 6228 6238 break; 6229 6239 case IW_MODE_MONITOR: 6230 - local->config.opmode &= 0xFF00; 6240 + local->config.opmode &= ~MODE_CFG_MASK; 6231 6241 local->config.opmode |= MODE_STA_ESS; 6232 - local->config.rmode &= 0xfe00; 6242 + local->config.rmode &= ~RXMODE_FULL_MASK; 6233 6243 local->config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER; 6234 6244 local->config.scanMode = SCANMODE_PASSIVE; 6235 6245 set_bit (FLAG_802_11, &local->flags); ··· 6257 6267 6258 6268 readConfigRid(local, 1); 6259 6269 /* If not managed, assume it's ad-hoc */ 6260 - switch (local->config.opmode & 0xFF) { 6270 + switch (local->config.opmode & MODE_CFG_MASK) { 6261 6271 case MODE_STA_ESS: 6262 6272 *uwrq = IW_MODE_INFRA; 6263 6273 break; ··· 6293 6303 struct airo_info *local = dev->priv; 6294 6304 CapabilityRid cap_rid; /* Card capability info */ 6295 6305 int perm = ( dwrq->flags & IW_ENCODE_TEMP ? 0 : 1 ); 6296 - u16 currentAuthType = local->config.authType; 6306 + __le16 currentAuthType = local->config.authType; 6297 6307 6298 6308 /* Is WEP supported ? */ 6299 6309 readCapabilityRid(local, &cap_rid, 1); ··· 6430 6440 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra; 6431 6441 CapabilityRid cap_rid; /* Card capability info */ 6432 6442 int perm = ( encoding->flags & IW_ENCODE_TEMP ? 0 : 1 ); 6433 - u16 currentAuthType = local->config.authType; 6443 + __le16 currentAuthType = local->config.authType; 6434 6444 int idx, key_len, alg = ext->alg, set_key = 1; 6435 6445 wep_key_t key; 6436 6446 ··· 6576 6586 { 6577 6587 struct airo_info *local = dev->priv; 6578 6588 struct iw_param *param = &wrqu->param; 6579 - u16 currentAuthType = local->config.authType; 6589 + __le16 currentAuthType = local->config.authType; 6580 6590 6581 6591 switch (param->flags & IW_AUTH_INDEX) { 6582 6592 case IW_AUTH_WPA_VERSION: ··· 6644 6654 { 6645 6655 struct airo_info *local = dev->priv; 6646 6656 struct iw_param *param = &wrqu->param; 6647 - u16 currentAuthType = local->config.authType; 6657 + __le16 currentAuthType = local->config.authType; 6648 6658 6649 6659 switch (param->flags & IW_AUTH_INDEX) { 6650 6660 case IW_AUTH_DROP_UNENCRYPTED: ··· 6695 6705 CapabilityRid cap_rid; /* Card capability info */ 6696 6706 int i; 6697 6707 int rc = -EINVAL; 6708 + __le16 v = cpu_to_le16(vwrq->value); 6698 6709 6699 6710 readCapabilityRid(local, &cap_rid, 1); 6700 6711 ··· 6709 6718 } 6710 6719 clear_bit (FLAG_RADIO_OFF, &local->flags); 6711 6720 for (i = 0; cap_rid.txPowerLevels[i] && (i < 8); i++) 6712 - if (vwrq->value == le16_to_cpu(cap_rid.txPowerLevels[i])) { 6721 + if (v == cap_rid.txPowerLevels[i]) { 6713 6722 readConfigRid(local, 1); 6714 - local->config.txPower = vwrq->value; 6723 + local->config.txPower = v; 6715 6724 set_bit (FLAG_COMMIT, &local->flags); 6716 6725 rc = -EINPROGRESS; /* Call commit handler */ 6717 6726 break; ··· 6731 6740 struct airo_info *local = dev->priv; 6732 6741 6733 6742 readConfigRid(local, 1); 6734 - vwrq->value = local->config.txPower; 6743 + vwrq->value = le16_to_cpu(local->config.txPower); 6735 6744 vwrq->fixed = 1; /* No power control */ 6736 6745 vwrq->disabled = test_bit(FLAG_RADIO_OFF, &local->flags); 6737 6746 vwrq->flags = IW_TXPOW_MWATT; ··· 6756 6765 } 6757 6766 readConfigRid(local, 1); 6758 6767 if(vwrq->flags & IW_RETRY_LIMIT) { 6768 + __le16 v = cpu_to_le16(vwrq->value); 6759 6769 if(vwrq->flags & IW_RETRY_LONG) 6760 - local->config.longRetryLimit = vwrq->value; 6770 + local->config.longRetryLimit = v; 6761 6771 else if (vwrq->flags & IW_RETRY_SHORT) 6762 - local->config.shortRetryLimit = vwrq->value; 6772 + local->config.shortRetryLimit = v; 6763 6773 else { 6764 6774 /* No modifier : set both */ 6765 - local->config.longRetryLimit = vwrq->value; 6766 - local->config.shortRetryLimit = vwrq->value; 6775 + local->config.longRetryLimit = v; 6776 + local->config.shortRetryLimit = v; 6767 6777 } 6768 6778 set_bit (FLAG_COMMIT, &local->flags); 6769 6779 rc = -EINPROGRESS; /* Call commit handler */ 6770 6780 } 6771 6781 if(vwrq->flags & IW_RETRY_LIFETIME) { 6772 - local->config.txLifetime = vwrq->value / 1024; 6782 + local->config.txLifetime = cpu_to_le16(vwrq->value / 1024); 6773 6783 set_bit (FLAG_COMMIT, &local->flags); 6774 6784 rc = -EINPROGRESS; /* Call commit handler */ 6775 6785 } ··· 6794 6802 /* Note : by default, display the min retry number */ 6795 6803 if((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) { 6796 6804 vwrq->flags = IW_RETRY_LIFETIME; 6797 - vwrq->value = (int)local->config.txLifetime * 1024; 6805 + vwrq->value = le16_to_cpu(local->config.txLifetime) * 1024; 6798 6806 } else if((vwrq->flags & IW_RETRY_LONG)) { 6799 6807 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_LONG; 6800 - vwrq->value = (int)local->config.longRetryLimit; 6808 + vwrq->value = le16_to_cpu(local->config.longRetryLimit); 6801 6809 } else { 6802 6810 vwrq->flags = IW_RETRY_LIMIT; 6803 - vwrq->value = (int)local->config.shortRetryLimit; 6804 - if((int)local->config.shortRetryLimit != (int)local->config.longRetryLimit) 6811 + vwrq->value = le16_to_cpu(local->config.shortRetryLimit); 6812 + if(local->config.shortRetryLimit != local->config.longRetryLimit) 6805 6813 vwrq->flags |= IW_RETRY_SHORT; 6806 6814 } 6807 6815 ··· 6946 6954 6947 6955 readConfigRid(local, 1); 6948 6956 if (vwrq->disabled) { 6949 - if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) { 6957 + if (sniffing_mode(local)) 6950 6958 return -EINVAL; 6951 - } 6952 6959 local->config.powerSaveMode = POWERSAVE_CAM; 6953 - local->config.rmode &= 0xFF00; 6960 + local->config.rmode &= ~RXMODE_MASK; 6954 6961 local->config.rmode |= RXMODE_BC_MC_ADDR; 6955 6962 set_bit (FLAG_COMMIT, &local->flags); 6956 6963 return -EINPROGRESS; /* Call commit handler */ 6957 6964 } 6958 6965 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) { 6959 - local->config.fastListenDelay = (vwrq->value + 500) / 1024; 6966 + local->config.fastListenDelay = cpu_to_le16((vwrq->value + 500) / 1024); 6960 6967 local->config.powerSaveMode = POWERSAVE_PSPCAM; 6961 6968 set_bit (FLAG_COMMIT, &local->flags); 6962 6969 } else if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_PERIOD) { 6963 - local->config.fastListenInterval = local->config.listenInterval = (vwrq->value + 500) / 1024; 6970 + local->config.fastListenInterval = 6971 + local->config.listenInterval = 6972 + cpu_to_le16((vwrq->value + 500) / 1024); 6964 6973 local->config.powerSaveMode = POWERSAVE_PSPCAM; 6965 6974 set_bit (FLAG_COMMIT, &local->flags); 6966 6975 } 6967 6976 switch (vwrq->flags & IW_POWER_MODE) { 6968 6977 case IW_POWER_UNICAST_R: 6969 - if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) { 6978 + if (sniffing_mode(local)) 6970 6979 return -EINVAL; 6971 - } 6972 - local->config.rmode &= 0xFF00; 6980 + local->config.rmode &= ~RXMODE_MASK; 6973 6981 local->config.rmode |= RXMODE_ADDR; 6974 6982 set_bit (FLAG_COMMIT, &local->flags); 6975 6983 break; 6976 6984 case IW_POWER_ALL_R: 6977 - if ((local->config.rmode & 0xFF) >= RXMODE_RFMON) { 6985 + if (sniffing_mode(local)) 6978 6986 return -EINVAL; 6979 - } 6980 - local->config.rmode &= 0xFF00; 6987 + local->config.rmode &= ~RXMODE_MASK; 6981 6988 local->config.rmode |= RXMODE_BC_MC_ADDR; 6982 6989 set_bit (FLAG_COMMIT, &local->flags); 6983 6990 case IW_POWER_ON: ··· 7000 7009 char *extra) 7001 7010 { 7002 7011 struct airo_info *local = dev->priv; 7003 - int mode; 7012 + __le16 mode; 7004 7013 7005 7014 readConfigRid(local, 1); 7006 7015 mode = local->config.powerSaveMode; 7007 7016 if ((vwrq->disabled = (mode == POWERSAVE_CAM))) 7008 7017 return 0; 7009 7018 if ((vwrq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) { 7010 - vwrq->value = (int)local->config.fastListenDelay * 1024; 7019 + vwrq->value = le16_to_cpu(local->config.fastListenDelay) * 1024; 7011 7020 vwrq->flags = IW_POWER_TIMEOUT; 7012 7021 } else { 7013 - vwrq->value = (int)local->config.fastListenInterval * 1024; 7022 + vwrq->value = le16_to_cpu(local->config.fastListenInterval) * 1024; 7014 7023 vwrq->flags = IW_POWER_PERIOD; 7015 7024 } 7016 - if ((local->config.rmode & 0xFF) == RXMODE_ADDR) 7025 + if ((local->config.rmode & RXMODE_MASK) == RXMODE_ADDR) 7017 7026 vwrq->flags |= IW_POWER_UNICAST_R; 7018 7027 else 7019 7028 vwrq->flags |= IW_POWER_ALL_R; ··· 7033 7042 struct airo_info *local = dev->priv; 7034 7043 7035 7044 readConfigRid(local, 1); 7036 - local->config.rssiThreshold = vwrq->disabled ? RSSI_DEFAULT : vwrq->value; 7045 + local->config.rssiThreshold = 7046 + cpu_to_le16(vwrq->disabled ? RSSI_DEFAULT : vwrq->value); 7037 7047 set_bit (FLAG_COMMIT, &local->flags); 7038 7048 7039 7049 return -EINPROGRESS; /* Call commit handler */ ··· 7052 7060 struct airo_info *local = dev->priv; 7053 7061 7054 7062 readConfigRid(local, 1); 7055 - vwrq->value = local->config.rssiThreshold; 7063 + vwrq->value = le16_to_cpu(local->config.rssiThreshold); 7056 7064 vwrq->disabled = (vwrq->value == 0); 7057 7065 vwrq->fixed = 1; 7058 7066 ··· 7853 7861 ConfigRid *cfg = (ConfigRid *)iobuf; 7854 7862 7855 7863 if (test_bit(FLAG_MIC_CAPABLE, &ai->flags)) 7856 - cfg->opmode |= cpu_to_le16(MODE_MIC); 7864 + cfg->opmode |= MODE_MIC; 7857 7865 7858 - if ((le16_to_cpu(cfg->opmode) & 0xFF) == MODE_STA_IBSS) 7866 + if ((cfg->opmode & MODE_CFG_MASK) == MODE_STA_IBSS) 7859 7867 set_bit (FLAG_ADHOC, &ai->flags); 7860 7868 else 7861 7869 clear_bit (FLAG_ADHOC, &ai->flags);