Cleanup channel initialization and remove device specific
value magic calculations. Just deliver a plain list of values.
Read the EEPROM for default TXpower values for each channel.

Signed-off-by Ivo van Doorn <[EMAIL PROTECTED]>

diff -U 3 -H -w -E -d -r -N -- 
wireless-2.6/drivers/net/wireless/rt2x00/rt2400pci.c 
wireless-2.6-rt2x00/drivers/net/wireless/rt2x00/rt2400pci.c
--- wireless-2.6/drivers/net/wireless/rt2x00/rt2400pci.c        2006-02-09 
20:35:21.000000000 +0100
+++ wireless-2.6-rt2x00/drivers/net/wireless/rt2x00/rt2400pci.c 2006-02-11 
22:56:08.000000000 +0100
@@ -399,14 +402,8 @@
 rt2400pci_config_channel(struct rt2x00_pci *rt2x00pci,
        int rf2, int channel, int freq)
 {
-       u32                     rf1 = 0;
-       u32                     rf3 = 0;
-
-       rf1 = cpu_to_le32(0x00022058);
-       if(rt2x00_rf(&rt2x00pci->chip, RF2420))
-               rf3 = cpu_to_le32(0x00000111);
-       else
-               rf3 = cpu_to_le32(0x00000101);
+       u32                     rf1 = rt2x00pci->rf1;
+       u32                     rf3 = rt2x00pci->rf3;
 
        INFO("Switching channel. RF1: 0x%08x, RF2: 0x%08x, RF3: 0x%08x.\n",
                rf1, rf2, rf3);
@@ -1893,30 +1867,71 @@
        struct ieee80211_channel *channels)
 {
        int                             counter = 0;
+       u16                             eeprom = 0;
 
        /*
-        * Put the initialization of channels 1-13 in a loop,
-        * channel 14 needs to be initialized seperately.
+        * Channel initialization.
+        * First we set the basic variables.
         */
        for(counter = 0; counter < 13; counter++){
                channels[counter].chan = counter + 1;
-               channels[counter].freq =
-                       2407 + ((counter + 1) * 5);
-               channels[counter].val =
-                       cpu_to_le32(0x000c1fda + (counter * 0x14));
-               channels[counter].flag =
-                       IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_SCAN
-                       | IEEE80211_CHAN_W_IBSS;
+               channels[counter].freq = 2407 + ((counter + 1) * 5);
+               channels[counter].flag = IEEE80211_CHAN_W_IBSS
+                       | IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_SCAN;
+               channels[counter].antenna_max = 0xff;
        }
 
-       /*
-        * Channel 14 initialization.
-        */
        channels[13].chan = 14;
        channels[13].freq = 2484;
+       channels[13].flag = IEEE80211_CHAN_W_IBSS
+               | IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_SCAN;
+       channels[13].antenna_max = 0xff;
+
+       /*
+        * Set device specific value.
+        */
+       channels[0].val = cpu_to_le32(0x000c1fda);
+       channels[1].val = cpu_to_le32(0x000c1fee);
+       channels[2].val = cpu_to_le32(0x000c2002);
+       channels[3].val = cpu_to_le32(0x000c2016);
+       channels[4].val = cpu_to_le32(0x000c202a);
+       channels[5].val = cpu_to_le32(0x000c203e);
+       channels[6].val = cpu_to_le32(0x000c2052);
+       channels[7].val = cpu_to_le32(0x000c2066);
+       channels[8].val = cpu_to_le32(0x000c207a);
+       channels[9].val = cpu_to_le32(0x000c208e);
+       channels[10].val = cpu_to_le32(0x000c20a2);
+       channels[11].val = cpu_to_le32(0x000c20b6);
+       channels[12].val = cpu_to_le32(0x000c20ca);
        channels[13].val = cpu_to_le32(0x000c20fa);
-       channels[13].flag = IEEE80211_CHAN_W_SCAN |
-               IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_IBSS;
+
+       /*
+        * Set TX power, each EEPROM TXpower entry
+        * contains the TXpower value for 2 channels.
+        */
+       for(counter = 0; counter < EEPROM_TXPOWER_SIZE; counter++){
+               rt2x00_eeprom_read(rt2x00pci,
+                       EEPROM_TXPOWER_START + counter, &eeprom);
+
+               channels[(counter * 2)].power_level =
+                       rt2x00_get_field16(eeprom, EEPROM_TXPOWER_1);
+               if(channels[(counter * 2)].power_level > 0x7f)
+                       channels[(counter * 2)].power_level = 0x27;
+
+               channels[(counter * 2) + 1].power_level =
+                       rt2x00_get_field16(eeprom, EEPROM_TXPOWER_2);
+               if(channels[(counter * 2) + 1].power_level > 0x7f)
+                       channels[(counter * 2) + 1].power_level = 0x27;
+       }
+
+       /*
+        * Set device specific, but channel independent RF values.
+        */
+       rt2x00pci->rf1 = cpu_to_le32(0x00022058);
+       if(rt2x00_rf(&rt2x00pci->chip, RF2420))
+               rt2x00pci->rf3 = cpu_to_le32(0x00000111);
+       else
+               rt2x00pci->rf3 = cpu_to_le32(0x00000101);
 }
 
 static void
diff -U 3 -H -w -E -d -r -N -- 
wireless-2.6/drivers/net/wireless/rt2x00/rt2500pci.c 
wireless-2.6-rt2x00/drivers/net/wireless/rt2x00/rt2500pci.c
--- wireless-2.6/drivers/net/wireless/rt2x00/rt2500pci.c        2006-02-09 
20:35:21.000000000 +0100
+++ wireless-2.6-rt2x00/drivers/net/wireless/rt2x00/rt2500pci.c 2006-02-11 
22:56:28.000000000 +0100
@@ -401,54 +404,34 @@
 rt2500pci_config_channel(struct rt2x00_pci *rt2x00pci,
        int rf2, int channel, int freq, int txpower)
 {
-       u32                     rf1 = 0;
-       u32                     rf3 = 0;
-       u32                     rf4 = 0;
+       u32                     rf1 = rt2x00pci->rf1;
+       u32                     rf3 = rt2x00pci->rf3;
+       u32                     rf4 = rt2x00pci->rf4;
 
        txpower = (txpower < 19) ? 19 : txpower;
        txpower = (txpower > 31) ? 31 : txpower;
 
-       if(rt2x00_rf(&rt2x00pci->chip, RF2522)){
-               rf1 = cpu_to_le32(0x00002050);
-               rf3 = cpu_to_le32(0x00000101);
-               rf4 = 0;
-       }else if(rt2x00_rf(&rt2x00pci->chip, RF2523)){
-               rf1 = cpu_to_le32(0x00022010);
-               rf3 = cpu_to_le32(0x000e0111);
-               rf4 = cpu_to_le32(0x00000a1b);
-       }else if(rt2x00_rf(&rt2x00pci->chip, RF2524)){
-               rf1 = cpu_to_le32(0x00032020);
-               rf3 = cpu_to_le32(0x00000101);
-               rf4 = cpu_to_le32(0x00000a1b);
-       }else if(rt2x00_rf(&rt2x00pci->chip, RF2525)){
-               rf1 = cpu_to_le32(0x00022020);
-               rf3 = cpu_to_le32(0x00060111);
-               rf4 = cpu_to_le32(0x00000a1b);
-       }else if(rt2x00_rf(&rt2x00pci->chip, RF2525E)){
+       if(rt2x00_rf(&rt2x00pci->chip, RF2525E) && channel == 14)
+               rf4 |= 0x00000010;
+
+       if(rt2x00_rf(&rt2x00pci->chip, RF5222)){
+               if(channel < 14){
                rf1 = cpu_to_le32(0x00022020);
-               rf3 = cpu_to_le32(0x00060111);
-               if(channel != 14)
                        rf4 = cpu_to_le32(0x00000a0b);
-               else
-                       rf4 = cpu_to_le32(0x00000a1b);
-       }else if(rt2x00_rf(&rt2x00pci->chip, RF5222)){
-               rf3 = cpu_to_le32(0x00000101);
-               if(channel < 14
-               || channel > 149)
-                       rf1 = cpu_to_le32(0x00022020);
-               else
+               }else if(channel == 14){
                        rf1 = cpu_to_le32(0x00022010);
-               if(channel < 14)
-                       rf4 = cpu_to_le32(0x00000a0b);
-               else if(channel == 14)
                        rf4 = cpu_to_le32(0x00000a1b);
-               else if(channel < 64)
+               }else if(channel < 64){
+                       rf1 = cpu_to_le32(0x00022010);
                        rf4 = cpu_to_le32(0x00000a1f);
-               else if(channel < 140)
+               }else if(channel < 140){
+                       rf1 = cpu_to_le32(0x00022010);
                        rf4 = cpu_to_le32(0x00000a0f);
-               else if(channel < 161)
+               }else if(channel < 161){
+                       rf1 = cpu_to_le32(0x00022020);
                        rf4 = cpu_to_le32(0x00000a07);
        }
+       }
 
        INFO("Switching channel. RF1: 0x%08x, RF2: 0x%08x, RF3: 0x%08x, "
                "RF4: 0x%08x.\n", rf1, rf2, rf3, rf4);
@@ -1962,133 +1922,175 @@
        struct ieee80211_channel *channels)
 {
        int                             counter = 0;
-       int                             channel = 0;
+       u16                             eeprom = 0;
+       u32                             rf2_base = 0;
 
        /*
-        * We can put the initialization of channels 1-13
-        * in a loop, channel 14 needs to be initialized
-        * seperately.
+        * Channel initialization.
+        * First we set the basic variables.
         */
-       if(rt2x00_rf(&rt2x00pci->chip, RF2522)){
                for(counter = 0; counter < 13; counter++){
                        channels[counter].chan = counter + 1;
-                       channels[counter].freq = 2407
-                               + ((counter + 1) * 5);
-                       channels[counter].val = cpu_to_le32(0x000c1fda
-                               + (counter * 0x14));
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
+               channels[counter].freq = 2407 + ((counter + 1) * 5);
+               channels[counter].flag = IEEE80211_CHAN_W_IBSS
+                       | IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_SCAN;
+               channels[counter].antenna_max = 0xff;
                }
 
                channels[13].chan = 14;
                channels[13].freq = 2484;
+       channels[13].flag = IEEE80211_CHAN_W_IBSS
+               | IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_SCAN;
+       channels[13].antenna_max = 0xff;
+
+       if(rt2x00_rf(&rt2x00pci->chip, RF5222)){
+               for(counter = 14; counter < 37; counter++){
+                       if(counter < 22)
+                               channels[counter].chan = 36;
+                       else if(counter < 33)
+                               channels[counter].chan = 100;
+                       else
+                               channels[counter].chan = 149;
+                       channels[counter].chan += ((counter - 14) * 4);
+                       channels[counter].freq = ((counter - 13) + 1000) * 5;
+                       channels[counter].flag = IEEE80211_CHAN_W_IBSS
+                               | IEEE80211_CHAN_W_ACTIVE_SCAN
+                               | IEEE80211_CHAN_W_SCAN;
+                       channels[counter].power_level = 0x18;
+                       channels[counter].antenna_max = 0xff;
+               }
+       }
+
+       /*
+        * Set device specific value.
+        */
+       if(rt2x00_rf(&rt2x00pci->chip, RF2525)
+       || rt2x00_rf(&rt2x00pci->chip, RF2525E))
+               rf2_base = 0x00080000;
+
+       if(rt2x00_rf(&rt2x00pci->chip, RF2522)){
+               channels[0].val = cpu_to_le32(0x000c1fda);
+               channels[1].val = cpu_to_le32(0x000c1fee);
+               channels[2].val = cpu_to_le32(0x000c2002);
+               channels[3].val = cpu_to_le32(0x000c2016);
+               channels[4].val = cpu_to_le32(0x000c202a);
+               channels[5].val = cpu_to_le32(0x000c203e);
+               channels[6].val = cpu_to_le32(0x000c2052);
+               channels[7].val = cpu_to_le32(0x000c2066);
+               channels[8].val = cpu_to_le32(0x000c207a);
+               channels[9].val = cpu_to_le32(0x000c208e);
+               channels[10].val = cpu_to_le32(0x000c20a2);
+               channels[11].val = cpu_to_le32(0x000c20b6);
+               channels[12].val = cpu_to_le32(0x000c20ca);
                channels[13].val = cpu_to_le32(0x000c20fa);
-               channels[13].flag = IEEE80211_CHAN_W_SCAN |
-                       IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_IBSS;
        }else if(rt2x00_rf(&rt2x00pci->chip, RF2523)
        || rt2x00_rf(&rt2x00pci->chip, RF2524)
        || rt2x00_rf(&rt2x00pci->chip, RF2525)){
-               for(counter = 0; counter < 13; counter++){
-                       channels[counter].chan = counter + 1;
-                       channels[counter].freq = 2407
-                               + ((counter + 1) * 5);
-                       channels[counter].val = cpu_to_le32(0x00000c9e
-                               + (counter * 0x04));
-                       if(channels[counter].val & 0x00000040)
-                               channels[counter].val += 0x00000040;
-                       if(rt2x00_rf(&rt2x00pci->chip, RF2525))
-                               channels[counter].val += 0x00080000;
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
+               channels[0].val = cpu_to_le32(0x00000c9e | rf2_base);
+               channels[1].val = cpu_to_le32(0x00000ca2 | rf2_base);
+               channels[2].val = cpu_to_le32(0x00000ca6 | rf2_base);
+               channels[3].val = cpu_to_le32(0x00000caa | rf2_base);
+               channels[4].val = cpu_to_le32(0x00000cae | rf2_base);
+               channels[5].val = cpu_to_le32(0x00000cb2 | rf2_base);
+               channels[6].val = cpu_to_le32(0x00000cb6 | rf2_base);
+               channels[7].val = cpu_to_le32(0x00000cba | rf2_base);
+               channels[8].val = cpu_to_le32(0x00000cbe | rf2_base);
+               channels[9].val = cpu_to_le32(0x00000d02 | rf2_base);
+               channels[10].val = cpu_to_le32(0x00000d06 | rf2_base);
+               channels[11].val = cpu_to_le32(0x00000d0a | rf2_base);
+               channels[12].val = cpu_to_le32(0x00000d0e | rf2_base);
+               channels[13].val = cpu_to_le32(0x00000d1a | rf2_base);
+       }else if(rt2x00_rf(&rt2x00pci->chip, RF2525E)
+       || rt2x00_rf(&rt2x00pci->chip, RF5222)){
+               channels[0].val = cpu_to_le32(0x00001136 | rf2_base);
+               channels[1].val = cpu_to_le32(0x0000113a | rf2_base);
+               channels[2].val = cpu_to_le32(0x0000113e | rf2_base);
+               channels[3].val = cpu_to_le32(0x00001182 | rf2_base);
+               channels[4].val = cpu_to_le32(0x00001186 | rf2_base);
+               channels[5].val = cpu_to_le32(0x0000118a | rf2_base);
+               channels[6].val = cpu_to_le32(0x0000118e | rf2_base);
+               channels[7].val = cpu_to_le32(0x00001192 | rf2_base);
+               channels[8].val = cpu_to_le32(0x00001196 | rf2_base);
+               channels[9].val = cpu_to_le32(0x0000119a | rf2_base);
+               channels[10].val = cpu_to_le32(0x0000119e | rf2_base);
+               channels[11].val = cpu_to_le32(0x000011a2 | rf2_base);
+               channels[12].val = cpu_to_le32(0x000011a6 | rf2_base);
+               channels[13].val = cpu_to_le32(0x000011ae | rf2_base);
                }
+       if(rt2x00_rf(&rt2x00pci->chip, RF5222)){
+               channels[14].val = cpu_to_le32(0x00018896);
+               channels[15].val = cpu_to_le32(0x0001889a);
+               channels[16].val = cpu_to_le32(0x0001889e);
+               channels[17].val = cpu_to_le32(0x000188a2);
+               channels[18].val = cpu_to_le32(0x000188a6);
+               channels[19].val = cpu_to_le32(0x000188aa);
+               channels[20].val = cpu_to_le32(0x000188ae);
+               channels[21].val = cpu_to_le32(0x000188b2);
 
-               channels[13].chan = 14;
-               channels[13].freq = 2484;
-               channels[13].val = cpu_to_le32(0x00000d1a);
-               channels[13].flag = IEEE80211_CHAN_W_SCAN |
-                       IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_IBSS;
-       }else if(rt2x00_rf(&rt2x00pci->chip, RF2525E)){
-               for(counter = 0; counter < 13; counter++){
-                       channels[counter].chan = counter + 1;
-                       channels[counter].freq = 2407
-                               + ((counter + 1) * 5);
-                       channels[counter].val = cpu_to_le32(0x00081136
-                               + (counter * 0x04));
-                       if(channels[counter].val & 0x00000040)
-                               channels[counter].val += 0x00000040;
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
-               }
+               channels[22].val = cpu_to_le32(0x00008802);
+               channels[23].val = cpu_to_le32(0x00008806);
+               channels[24].val = cpu_to_le32(0x0000880a);
+               channels[25].val = cpu_to_le32(0x0000880e);
+               channels[26].val = cpu_to_le32(0x00008812);
+               channels[27].val = cpu_to_le32(0x00008816);
+               channels[28].val = cpu_to_le32(0x0000881a);
+               channels[29].val = cpu_to_le32(0x0000881e);
+               channels[30].val = cpu_to_le32(0x00008822);
+               channels[31].val = cpu_to_le32(0x00008826);
+               channels[32].val = cpu_to_le32(0x0000882a);
 
-               channels[13].chan = 14;
-               channels[13].freq = 2484;
-               channels[13].val = cpu_to_le32(0x000811ae);
-               channels[13].flag = IEEE80211_CHAN_W_SCAN |
-                       IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_IBSS;
-       }else if(rt2x00_rf(&rt2x00pci->chip, RF5222)){
-               for(counter = 0; counter < 13; counter++){
-                       channels[counter].chan = counter + 1;
-                       channels[counter].freq = 2407
-                               + ((counter + 1) * 5);
-                       channels[counter].val = cpu_to_le32(0x00001136
-                               + (counter * 0x04));
-                       if(channels[counter].val & 0x00000040)
-                               channels[counter].val += 0x00000040;
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
+               channels[33].val = cpu_to_le32(0x000090a6);
+               channels[34].val = cpu_to_le32(0x000090ae);
+               channels[35].val = cpu_to_le32(0x000090b6);
+               channels[36].val = cpu_to_le32(0x000090be);
                }
 
-               channels[13].chan = 14;
-               channels[13].freq = 2484;
-               channels[13].val = cpu_to_le32(0x000811ae);
-               channels[13].flag = IEEE80211_CHAN_W_SCAN |
-                       IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_IBSS;
-               for(channel = 36; channel <= 64; channel += 4){
-                       channels[counter].chan = counter + 1;
-                       channels[counter].freq =
-                               ((counter + 1) + 1000) * 5;
-                       channels[counter].val = cpu_to_le32(0x00018896
-                               + (counter * 0x04));
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
-                       counter++;
-               }
+       /*
+        * Set TX power, each EEPROM TXpower entry
+        * contains the TXpower value for 2 channels.
+        */
+       for(counter = 0; counter < EEPROM_TXPOWER_SIZE; counter++){
+               rt2x00_eeprom_read(rt2x00pci,
+                       EEPROM_TXPOWER_START + counter, &eeprom);
 
-               for(channel = 100; channel <= 140; channel += 4){
-                       channels[counter].chan = counter + 1;
-                       channels[counter].freq =
-                               ((counter + 1) + 1000) * 5;
-                       channels[counter].val = cpu_to_le32(0x00008802
-                               + (counter * 0x04));
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
-                       counter++;
-               }
+               channels[(counter * 2)].power_level =
+                       rt2x00_get_field16(eeprom, EEPROM_TXPOWER_1);
+               if(channels[(counter * 2)].power_level > 0x20)
+                       channels[(counter * 2)].power_level = 0x18;
 
-               for(channel = 149; channel <= 161; channel += 4){
-                       channels[counter].chan = counter + 1;
-                       channels[counter].freq =
-                               ((counter + 1) + 1000) * 5;
-                       channels[counter].val = cpu_to_le32(0x000090a6
-                               + (counter * 0x08));
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
-                       counter++;
+               channels[(counter * 2) + 1].power_level =
+                       rt2x00_get_field16(eeprom, EEPROM_TXPOWER_2);
+               if(channels[(counter * 2) + 1].power_level > 0x20)
+                       channels[(counter * 2) + 1].power_level = 0x18;
                }
+
+       /*
+        * Set device specific, but channel independent RF values.
+        */
+       if(rt2x00_rf(&rt2x00pci->chip, RF2522)){
+               rt2x00pci->rf1 = cpu_to_le32(0x00002050);
+               rt2x00pci->rf3 = cpu_to_le32(0x00000101);
+               rt2x00pci->rf4 = 0;
+       }else if(rt2x00_rf(&rt2x00pci->chip, RF2523)){
+               rt2x00pci->rf1 = cpu_to_le32(0x00022010);
+               rt2x00pci->rf3 = cpu_to_le32(0x000e0111);
+               rt2x00pci->rf4 = cpu_to_le32(0x00000a1b);
+       }else if(rt2x00_rf(&rt2x00pci->chip, RF2524)){
+               rt2x00pci->rf1 = cpu_to_le32(0x00032020);
+               rt2x00pci->rf3 = cpu_to_le32(0x00000101);
+               rt2x00pci->rf4 = cpu_to_le32(0x00000a1b);
+       }else if(rt2x00_rf(&rt2x00pci->chip, RF2525)){
+               rt2x00pci->rf1 = cpu_to_le32(0x00022020);
+               rt2x00pci->rf3 = cpu_to_le32(0x00060111);
+               rt2x00pci->rf4 = cpu_to_le32(0x00000a1b);
+       }else if(rt2x00_rf(&rt2x00pci->chip, RF2525E)){
+               rt2x00pci->rf1 = cpu_to_le32(0x00022020);
+               rt2x00pci->rf3 = cpu_to_le32(0x00060111);
+               rt2x00pci->rf4 = cpu_to_le32(0x00000a0b);
+       }else if(rt2x00_rf(&rt2x00pci->chip, RF5222)){
+               rt2x00pci->rf1 = 0;
+               rt2x00pci->rf3 = cpu_to_le32(0x00000101);
+               rt2x00pci->rf4 = 0;
        }
 }
 
diff -U 3 -H -w -E -d -r -N -- 
wireless-2.6/drivers/net/wireless/rt2x00/rt2500usb.c 
wireless-2.6-rt2x00/drivers/net/wireless/rt2x00/rt2500usb.c
--- wireless-2.6/drivers/net/wireless/rt2x00/rt2500usb.c        2006-02-09 
20:35:21.000000000 +0100
+++ wireless-2.6-rt2x00/drivers/net/wireless/rt2x00/rt2500usb.c 2006-02-11 
22:56:01.000000000 +0100
@@ -284,61 +287,45 @@
 rt2500usb_config_channel(struct rt2x00_usb *rt2x00usb,
        int rf2, int channel, int freq, int txpower)
 {
-       u32                     rf1 = 0;
-       u32                     rf3 = 0;
-       u32                     rf4 = 0;
+       u32                     rf1 = rt2x00usb->rf1;
+       u32                     rf3 = rt2x00usb->rf3;
+       u32                     rf4 = rt2x00usb->rf4;
 
        txpower = (txpower < 19) ? 19 : txpower;
        txpower = (txpower > 31) ? 31 : txpower;
 
-       if(rt2x00_rf(&rt2x00usb->chip, RF2522)){
-               rf1 = 0x00002050;
-               rf3 = 0x00000101;
-               rf4 = 0;
-       }else if(rt2x00_rf(&rt2x00usb->chip, RF2523)){
-               rf1 = 0x00022010;
-               rf3 = 0x000e0111;
-               rf4 = 0x00000a1b;
-               if(channel == 14)
-                       rf4 &= ~0x00000018;
-       }else if(rt2x00_rf(&rt2x00usb->chip, RF2524)){
-               rf1 = 0x00032020;
-               rf3 = 0x00000101;
-               rf4 = 0x00000a1b;
-               if(channel == 14)
-                       rf4 &= ~0x00000018;
-       }else if(rt2x00_rf(&rt2x00usb->chip, RF2525)){
-               rf1 = 0x00022020;
-               rf3 = 0x00060111;
-               rf4 = 0x00000a1b;
-               if(channel == 14)
+       if((rt2x00_rf(&rt2x00usb->chip, RF2523)
+       || rt2x00_rf(&rt2x00usb->chip, RF2524)
+       || rt2x00_rf(&rt2x00usb->chip, RF2525))
+       && channel == 14)
                        rf4 &= ~0x00000018;
-       }else if(rt2x00_rf(&rt2x00usb->chip, RF2525E)){
-               rf1 = 0x00022020;
-               rf3 = 0x00060111;
+
+       if(rt2x00_rf(&rt2x00usb->chip, RF2525E)){
                if(channel & 0x01)
                        rf4 = 0x00000e1b;
                else
                        rf4 = 0x00000e07;
                if(channel == 14)
                        rf4 = 0x00000e23;
-       }else if(rt2x00_rf(&rt2x00usb->chip, RF5222)){
-               rf3 = 0x00000101;
-               if(channel < 14
-               || channel > 149)
-                       rf1 = 0x00022020;
-               else
-                       rf1 = 0x00022010;
-               if(channel < 14)
-                       rf4 = 0x00000a0b;
-               else if(channel == 14)
-                       rf4 = 0x00000a1b;
-               else if(channel < 64)
-                       rf4 = 0x00000a1f;
-               else if(channel < 140)
-                       rf4 = 0x00000a0f;
-               else if(channel < 161)
-                       rf4 = 0x00000a07;
+       }
+
+       if(rt2x00_rf(&rt2x00usb->chip, RF5222)){
+               if(channel < 14){
+                       rf1 = cpu_to_le32(0x00022020);
+                       rf4 = cpu_to_le32(0x00000a0b);
+               }else if(channel == 14){
+                       rf1 = cpu_to_le32(0x00022010);
+                       rf4 = cpu_to_le32(0x00000a1b);
+               }else if(channel < 64){
+                       rf1 = cpu_to_le32(0x00022010);
+                       rf4 = cpu_to_le32(0x00000a1f);
+               }else if(channel < 140){
+                       rf1 = cpu_to_le32(0x00022010);
+                       rf4 = cpu_to_le32(0x00000a0f);
+               }else if(channel < 161){
+                       rf1 = cpu_to_le32(0x00022020);
+                       rf4 = cpu_to_le32(0x00000a07);
+               }
        }
 
        INFO("Switching channel. RF1: 0x%08x, RF2: 0x%08x, RF3: 0x%08x, "
@@ -1651,138 +1618,187 @@
        struct ieee80211_channel *channels)
 {
        int                             counter = 0;
-       int                             channel = 0;
+       u16                             eeprom = 0;
+       u32                             rf2_base = 0;
 
        /*
-        * We can put the initialization of channels 1-13
-        * in a loop, channel 14 needs to be initialized
-        * seperately.
+        * Channel initialization.
+        * First we set the basic variables.
         */
-       if(rt2x00_rf(&rt2x00usb->chip, RF2522)){
                for(counter = 0; counter < 13; counter++){
                        channels[counter].chan = counter + 1;
-                       channels[counter].freq = 2407
-                               + ((counter + 1) * 5);
-                       channels[counter].val = cpu_to_le32(0x000c1fda
-                               + (counter * 0x14));
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
+               channels[counter].freq = 2407 + ((counter + 1) * 5);
+               channels[counter].flag = IEEE80211_CHAN_W_IBSS
+                       | IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_SCAN;
+               channels[counter].antenna_max = 0xff;
                }
 
                channels[13].chan = 14;
                channels[13].freq = 2484;
+       channels[13].flag = IEEE80211_CHAN_W_IBSS
+               | IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_SCAN;
+       channels[13].antenna_max = 0xff;
+
+       if(rt2x00_rf(&rt2x00usb->chip, RF5222)){
+               for(counter = 14; counter < 37; counter++){
+                       if(counter < 22)
+                               channels[counter].chan = 36;
+                       else if(counter < 33)
+                               channels[counter].chan = 100;
+                       else
+                               channels[counter].chan = 149;
+                       channels[counter].chan += ((counter - 14) * 4);
+                       channels[counter].freq = ((counter - 13) + 1000) * 5;
+                       channels[counter].flag = IEEE80211_CHAN_W_IBSS
+                               | IEEE80211_CHAN_W_ACTIVE_SCAN
+                               | IEEE80211_CHAN_W_SCAN;
+                       channels[counter].power_level = 0x18;
+                       channels[counter].antenna_max = 0xff;
+               }
+       }
+
+       /*
+        * Set device specific value.
+        */
+       if(rt2x00_rf(&rt2x00usb->chip, RF2525))
+               rf2_base = 0x00080000;
+
+       if(rt2x00_rf(&rt2x00usb->chip, RF2522)){
+               channels[0].val = cpu_to_le32(0x000c1fda);
+               channels[1].val = cpu_to_le32(0x000c1fee);
+               channels[2].val = cpu_to_le32(0x000c2002);
+               channels[3].val = cpu_to_le32(0x000c2016);
+               channels[4].val = cpu_to_le32(0x000c202a);
+               channels[5].val = cpu_to_le32(0x000c203e);
+               channels[6].val = cpu_to_le32(0x000c2052);
+               channels[7].val = cpu_to_le32(0x000c2066);
+               channels[8].val = cpu_to_le32(0x000c207a);
+               channels[9].val = cpu_to_le32(0x000c208e);
+               channels[10].val = cpu_to_le32(0x000c20a2);
+               channels[11].val = cpu_to_le32(0x000c20b6);
+               channels[12].val = cpu_to_le32(0x000c20ca);
                channels[13].val = cpu_to_le32(0x000c20fa);
-               channels[13].flag = IEEE80211_CHAN_W_SCAN |
-                       IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_IBSS;
        }else if(rt2x00_rf(&rt2x00usb->chip, RF2523)
        || rt2x00_rf(&rt2x00usb->chip, RF2524)
        || rt2x00_rf(&rt2x00usb->chip, RF2525)){
-               for(counter = 0; counter < 13; counter++){
-                       channels[counter].chan = counter + 1;
-                       channels[counter].freq = 2407
-                               + ((counter + 1) * 5);
-                       channels[counter].val = cpu_to_le32(0x00000c9e
-                               + (counter * 0x04));
-                       if(channels[counter].val & 0x00000040)
-                               channels[counter].val += 0x00000040;
-                       if(rt2x00_rf(&rt2x00usb->chip, RF2525))
-                               channels[counter].val += 0x00080000;
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
-               }
-
-               channels[13].chan = 14;
-               channels[13].freq = 2484;
-               channels[13].val = cpu_to_le32(0x00000d1a);
-               channels[13].flag = IEEE80211_CHAN_W_SCAN |
-                       IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_IBSS;
+               channels[0].val = cpu_to_le32(0x00000c9e | rf2_base);
+               channels[1].val = cpu_to_le32(0x00000ca2 | rf2_base);
+               channels[2].val = cpu_to_le32(0x00000ca6 | rf2_base);
+               channels[3].val = cpu_to_le32(0x00000caa | rf2_base);
+               channels[4].val = cpu_to_le32(0x00000cae | rf2_base);
+               channels[5].val = cpu_to_le32(0x00000cb2 | rf2_base);
+               channels[6].val = cpu_to_le32(0x00000cb6 | rf2_base);
+               channels[7].val = cpu_to_le32(0x00000cba | rf2_base);
+               channels[8].val = cpu_to_le32(0x00000cbe | rf2_base);
+               channels[9].val = cpu_to_le32(0x00000d02 | rf2_base);
+               channels[10].val = cpu_to_le32(0x00000d06 | rf2_base);
+               channels[11].val = cpu_to_le32(0x00000d0a | rf2_base);
+               channels[12].val = cpu_to_le32(0x00000d0e | rf2_base);
+               channels[13].val = cpu_to_le32(0x00000d1a | rf2_base);
        }else if(rt2x00_rf(&rt2x00usb->chip, RF2525E)){
-               for(counter = 0; counter < 14; counter++){
-                       channels[counter].chan = counter + 1;
-                       channels[counter].freq = 2407
-                               + ((counter + 1) * 5);
-                       if(counter & 0x01) /* Odd number. */
-                               channels[counter].val =
-                                       cpu_to_le32(0x0000089a
-                                       + ((counter + 1) * 0x02));
-                       else /* Even number */
-                               channels[counter].val =
-                                       cpu_to_le32(0x0000089a
-                                       + (counter * 0x02));
-                       if(channels[counter].val & 0x00000040)
-                               channels[counter].val += 0x00000040;
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
+               channels[0].val = cpu_to_le32(0x0000089a);
+               channels[1].val = cpu_to_le32(0x0000089e);
+               channels[2].val = cpu_to_le32(0x0000089e);
+               channels[3].val = cpu_to_le32(0x000008a2);
+               channels[4].val = cpu_to_le32(0x000008a2);
+               channels[5].val = cpu_to_le32(0x000008a6);
+               channels[6].val = cpu_to_le32(0x000008a6);
+               channels[7].val = cpu_to_le32(0x000008aa);
+               channels[8].val = cpu_to_le32(0x000008aa);
+               channels[9].val = cpu_to_le32(0x000008ae);
+               channels[10].val = cpu_to_le32(0x000008ae);
+               channels[11].val = cpu_to_le32(0x000008b2);
+               channels[12].val = cpu_to_le32(0x000008b2);
+               channels[13].val = cpu_to_le32(0x000008b6);
+       }else if(rt2x00_rf(&rt2x00usb->chip, RF5222)){
+               channels[0].val = cpu_to_le32(0x00001136);
+               channels[1].val = cpu_to_le32(0x0000113a);
+               channels[2].val = cpu_to_le32(0x0000113e);
+               channels[3].val = cpu_to_le32(0x00001182);
+               channels[4].val = cpu_to_le32(0x00001186);
+               channels[5].val = cpu_to_le32(0x0000118a);
+               channels[6].val = cpu_to_le32(0x0000118e);
+               channels[7].val = cpu_to_le32(0x00001192);
+               channels[8].val = cpu_to_le32(0x00001196);
+               channels[9].val = cpu_to_le32(0x0000119a);
+               channels[10].val = cpu_to_le32(0x0000119e);
+               channels[11].val = cpu_to_le32(0x000011a2);
+               channels[12].val = cpu_to_le32(0x000011a6);
+               channels[13].val = cpu_to_le32(0x000011ae);
+
+               channels[14].val = cpu_to_le32(0x00018896);
+               channels[15].val = cpu_to_le32(0x0001889a);
+               channels[16].val = cpu_to_le32(0x0001889e);
+               channels[17].val = cpu_to_le32(0x000188a2);
+               channels[18].val = cpu_to_le32(0x000188a6);
+               channels[19].val = cpu_to_le32(0x000188aa);
+               channels[20].val = cpu_to_le32(0x000188ae);
+               channels[21].val = cpu_to_le32(0x000188b2);
+
+               channels[22].val = cpu_to_le32(0x00008802);
+               channels[23].val = cpu_to_le32(0x00008806);
+               channels[24].val = cpu_to_le32(0x0000880a);
+               channels[25].val = cpu_to_le32(0x0000880e);
+               channels[26].val = cpu_to_le32(0x00008812);
+               channels[27].val = cpu_to_le32(0x00008816);
+               channels[28].val = cpu_to_le32(0x0000881a);
+               channels[29].val = cpu_to_le32(0x0000881e);
+               channels[30].val = cpu_to_le32(0x00008822);
+               channels[31].val = cpu_to_le32(0x00008826);
+               channels[32].val = cpu_to_le32(0x0000882a);
+
+               channels[33].val = cpu_to_le32(0x000090a6);
+               channels[34].val = cpu_to_le32(0x000090ae);
+               channels[35].val = cpu_to_le32(0x000090b6);
+               channels[36].val = cpu_to_le32(0x000090be);
                }
 
                /*
-                * Only fix frequency number for channel 14.
+        * Set TX power, each EEPROM TXpower entry
+        * contains the TXpower value for 2 channels.
                 */
-               channels[13].freq = 2484;
-       }else if(rt2x00_rf(&rt2x00usb->chip, RF5222)){
-               for(counter = 0; counter < 13; counter++){
-                       channels[counter].chan = counter + 1;
-                       channels[counter].freq = 2407
-                               + ((counter + 1) * 5);
-                       channels[counter].val = cpu_to_le32(0x00001136
-                               + (counter * 0x04));
-                       if(channels[counter].val & 0x00000040)
-                               channels[counter].val += 0x00000040;
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
-               }
+       for(counter = 0; counter < EEPROM_TXPOWER_SIZE; counter++){
+               rt2x00_eeprom_read(rt2x00usb,
+                       EEPROM_TXPOWER_START + counter, &eeprom, 2);
 
-               channels[13].chan = 14;
-               channels[13].freq = 2484;
-               channels[13].val = cpu_to_le32(0x000811ae);
-               channels[13].flag = IEEE80211_CHAN_W_SCAN |
-                       IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_IBSS;
-               for(channel = 36; channel <= 64; channel += 4){
-                       channels[counter].chan = counter + 1;
-                       channels[counter].freq =
-                               ((counter + 1) + 1000) * 5;
-                       channels[counter].val = cpu_to_le32(0x00018896
-                               + (counter * 0x04));
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
-                       counter++;
-               }
+               channels[(counter * 2)].power_level =
+                       rt2x00_get_field16(eeprom, EEPROM_TXPOWER_1);
+               if(channels[(counter * 2)].power_level > 0x20)
+                       channels[(counter * 2)].power_level = 0x18;
 
-               for(channel = 100; channel <= 140; channel += 4){
-                       channels[counter].chan = counter + 1;
-                       channels[counter].freq =
-                               ((counter + 1) + 1000) * 5;
-                       channels[counter].val = cpu_to_le32(0x00008802
-                               + (counter * 0x04));
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
-                       counter++;
+               channels[(counter * 2) + 1].power_level =
+                       rt2x00_get_field16(eeprom, EEPROM_TXPOWER_2);
+               if(channels[(counter * 2) + 1].power_level > 0x20)
+                       channels[(counter * 2) + 1].power_level = 0x18;
                }
 
-               for(channel = 149; channel <= 161; channel += 4){
-                       channels[counter].chan = counter + 1;
-                       channels[counter].freq =
-                               ((counter + 1) + 1000) * 5;
-                       channels[counter].val = cpu_to_le32(0x000090a6
-                               + (counter * 0x08));
-                       channels[counter].flag =
-                               IEEE80211_CHAN_W_ACTIVE_SCAN
-                               | IEEE80211_CHAN_W_SCAN
-                               | IEEE80211_CHAN_W_IBSS;
-                       counter++;
-               }
+       /*
+        * Set device specific, but channel independent RF values.
+        */
+       if(rt2x00_rf(&rt2x00usb->chip, RF2522)){
+               rt2x00usb->rf1 = cpu_to_le32(0x00002050);
+               rt2x00usb->rf3 = cpu_to_le32(0x00000101);
+               rt2x00usb->rf4 = 0;
+       }else if(rt2x00_rf(&rt2x00usb->chip, RF2523)){
+               rt2x00usb->rf1 = cpu_to_le32(0x00022010);
+               rt2x00usb->rf3 = cpu_to_le32(0x000e0111);
+               rt2x00usb->rf4 = cpu_to_le32(0x00000a1b);
+       }else if(rt2x00_rf(&rt2x00usb->chip, RF2524)){
+               rt2x00usb->rf1 = cpu_to_le32(0x00032020);
+               rt2x00usb->rf3 = cpu_to_le32(0x00000101);
+               rt2x00usb->rf4 = cpu_to_le32(0x00000a1b);
+       }else if(rt2x00_rf(&rt2x00usb->chip, RF2525)){
+               rt2x00usb->rf1 = cpu_to_le32(0x00022020);
+               rt2x00usb->rf3 = cpu_to_le32(0x00060111);
+               rt2x00usb->rf4 = cpu_to_le32(0x00000a1b);
+       }else if(rt2x00_rf(&rt2x00usb->chip, RF2525E)){
+               rt2x00usb->rf1 = cpu_to_le32(0x00022020);
+               rt2x00usb->rf3 = cpu_to_le32(0x00060111);
+               rt2x00usb->rf4 = 0;
+       }else if(rt2x00_rf(&rt2x00usb->chip, RF5222)){
+               rt2x00usb->rf1 = 0;
+               rt2x00usb->rf3 = cpu_to_le32(0x00000101);
+               rt2x00usb->rf4 = 0;
        }
 }
 

Attachment: pgpOYCOH333fy.pgp
Description: PGP signature

Reply via email to