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-12 
12:51:28.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,61 @@
        struct ieee80211_channel *channels)
 {
        int                             counter = 0;
+       u16                             eeprom = 0;
+       u32 vals[] = {
+               0x000c1fda, 0x000c1fee, 0x000c2002, 0x000c2016,
+               0x000c202a, 0x000c203e, 0x000c2052, 0x000c2066,
+               0x000c207a, 0x000c208e, 0x000c20a2, 0x000c20b6,
+               0x000c20ca, 0x000c20fa
+       };
 
        /*
-        * 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].val = cpu_to_le32(vals[counter]);
+               channels[counter].antenna_max = 0xff;
        }
 
-       /*
-        * Channel 14 initialization.
-        */
        channels[13].chan = 14;
        channels[13].freq = 2484;
-       channels[13].val = cpu_to_le32(0x000c20fa);
-       channels[13].flag = IEEE80211_CHAN_W_SCAN |
-               IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_IBSS;
+       channels[13].flag = IEEE80211_CHAN_W_IBSS
+               | IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_SCAN;
+       channels[13].val = cpu_to_le32(vals[13]);
+       channels[13].antenna_max = 0xff;
+
+       /*
+        * 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-12 
12:51:37.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,132 +1922,142 @@
        struct ieee80211_channel *channels)
 {
        int                             counter = 0;
-       int                             channel = 0;
+       u16                             eeprom = 0;
+       u32                             rf2_base = 0;
+       struct {
+               unsigned int chip;
+               u32 val[3];
+       } rf[] = {
+               { RF2522,       { 0x00002050, 0x00000101, 0x00000000 } },
+               { RF2523,       { 0x00022010, 0x000e0111, 0x00000a1b } },
+               { RF2524,       { 0x00032020, 0x00000101, 0x00000a1b } },
+               { RF2525,       { 0x00022020, 0x00060111, 0x00000a1b } },
+               { RF2525E,      { 0x00022020, 0x00060111, 0x00000a0b } },
+               { RF5222,       { 0x00000000, 0x00000101, 0x00000000 } }
+       };
 
        /*
-        * 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].val = cpu_to_le32(0x000c20fa);
-               channels[13].flag = IEEE80211_CHAN_W_SCAN |
-                       IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_IBSS;
+       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)){
+               u32 vals[] = {
+                       0x000c1fda, 0x000c1fee, 0x000c2002, 0x000c2016,
+                       0x000c202a, 0x000c203e, 0x000c2052, 0x000c2066,
+                       0x000c207a, 0x000c208e, 0x000c20a2, 0x000c20b6,
+                       0x000c20ca, 0x000c20fa
+               };
+
+               for (counter = 0; counter < ARRAY_SIZE(vals); counter++)
+                       channels[counter].val = cpu_to_le32(vals[counter]);
        }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;
-               }
+               u32 vals[] = {
+                       0x00000c9e, 0x00000ca2, 0x00000ca6, 0x00000caa,
+                       0x00000cae, 0x00000cb2, 0x00000cb6, 0x00000cba,
+                       0x00000cbe, 0x00000d02, 0x00000d06, 0x00000d0a,
+                       0x00000d0e, 0x00000d1a
+               };
 
-               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;
-               }
+               for (counter = 0; counter < ARRAY_SIZE(vals); counter++)
+                       channels[counter].val =
+                               cpu_to_le32(vals[counter] | rf2_base);
+       }else if(rt2x00_rf(&rt2x00pci->chip, RF2525E)
+       || rt2x00_rf(&rt2x00pci->chip, RF5222)){
+               u32 vals[] = {
+                       0x00001136, 0x0000113a, 0x0000113e, 0x00001182,
+                       0x00001186, 0x0000118a, 0x0000118e, 0x00001192,
+                       0x00001196, 0x0000119a, 0x0000119e, 0x000011a2,
+                       0x000011a6, 0x000011ae
+               };
 
-               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;
+               for (counter = 0; counter < ARRAY_SIZE(vals); counter++)
+                       channels[counter].val =
+                               cpu_to_le32(vals[counter] | rf2_base);
                }
+       if(rt2x00_rf(&rt2x00pci->chip, RF5222)){
+               u32 vals[] = {
+                       0x00018896, 0x0001889a, 0x0001889e, 0x000188a2,
+                       0x000188a6, 0x000188aa, 0x000188ae, 0x000188b2,
+                       0x00008802, 0x00008806, 0x0000880a, 0x0000880e,
+                       0x00008812, 0x00008816, 0x0000881a, 0x0000881e,
+                       0x00008822, 0x00008826, 0x0000882a, 0x000090a6,
+                       0x000090ae, 0x000090b6, 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++;
+               struct ieee80211_channel *chan = channels + 14;
+       
+               for (counter = 0; counter < ARRAY_SIZE(vals); counter++)
+                       (chan++)->val = cpu_to_le32(vals[counter]);
                }
 
-               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++;
+       /*
+        * 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 > 0x20)
+                       channels[(counter * 2)].power_level = 0x18;
+
+               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.
+        */
+       for (counter = 0; counter < ARRAY_SIZE(rf); counter++) {
+               if (rt2x00_rf(&rt2x00pci->chip, rf[counter].chip)) {
+                       rt2x00pci->rf1 = cpu_to_le32(rf[counter].val[0]);
+                       rt2x00pci->rf3 = cpu_to_le32(rf[counter].val[1]);
+                       rt2x00pci->rf4 = cpu_to_le32(rf[counter].val[2]);
                }
        }
 }
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-12 
12:51:43.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,137 +1618,140 @@
        struct ieee80211_channel *channels)
 {
        int                             counter = 0;
-       int                             channel = 0;
+       u16                             eeprom = 0;
+       u32                             rf2_base = 0;
+       struct {
+               unsigned int chip;
+               u32 val[3];
+       } rf[] = {
+               { RF2522,       { 0x00002050, 0x00000101, 0x00000000 } },
+               { RF2523,       { 0x00022010, 0x000e0111, 0x00000a1b } },
+               { RF2524,       { 0x00032020, 0x00000101, 0x00000a1b } },
+               { RF2525,       { 0x00022020, 0x00060111, 0x00000a1b } },
+               { RF2525E,      { 0x00022020, 0x00060111, 0x00000000 } },
+               { RF5222,       { 0x00000000, 0x00000101, 0x00000000 } }
+       };
 
        /*
-        * 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].val = cpu_to_le32(0x000c20fa);
-               channels[13].flag = IEEE80211_CHAN_W_SCAN |
-                       IEEE80211_CHAN_W_ACTIVE_SCAN | IEEE80211_CHAN_W_IBSS;
+       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)){
+               u32 vals[] = {
+                       0x000c1fda, 0x000c1fee, 0x000c2002, 0x000c2016,
+                       0x000c202a, 0x000c203e, 0x000c2052, 0x000c2066,
+                       0x000c207a, 0x000c208e, 0x000c20a2, 0x000c20b6,
+                       0x000c20ca, 0x000c20fa
+               };
+
+               for (counter = 0; counter < ARRAY_SIZE(vals); counter++)
+                       channels[counter].val = cpu_to_le32(vals[counter]);
        }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;
-               }
+               u32 vals[] = {
+                       0x00000c9e, 0x00000ca2, 0x00000ca6, 0x00000caa,
+                       0x00000cae, 0x00000cb2, 0x00000cb6, 0x00000cba,
+                       0x00000cbe, 0x00000d02, 0x00000d06, 0x00000d0a,
+                       0x00000d0e, 0x00000d1a
+               };
 
-               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(&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 */
+               for (counter = 0; counter < ARRAY_SIZE(vals); counter++)
                                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;
+                               cpu_to_le32(vals[counter] | rf2_base);
+       }else if(rt2x00_rf(&rt2x00usb->chip, RF2525E)){
+               u32 vals[] = {
+                       0x0000089a, 0x0000089e, 0x0000089e, 0x000008a2,
+                       0x000008a2, 0x000008a6, 0x000008a6, 0x000008aa,
+                       0x000008aa, 0x000008ae, 0x000008ae, 0x000008b2,
+                       0x000008b2, 0x000008b6
+               };
+
+               for (counter = 0; counter < ARRAY_SIZE(vals); counter++)
+                       channels[counter].val = cpu_to_le32(vals[counter]);
+       }else if(rt2x00_rf(&rt2x00usb->chip, RF5222)){
+               u32 vals[] = {
+                       0x00001136, 0x0000113a, 0x0000113e, 0x00001182,
+                       0x00001186, 0x0000118a, 0x0000118e, 0x00001192,
+                       0x00001196, 0x0000119a, 0x0000119e, 0x000011a2,
+                       0x000011a6, 0x000011ae, 0x0001889a, 0x0001889a,
+                       0x0001889e, 0x000188a2, 0x000188a6, 0x000188aa,
+                       0x000188ae, 0x000188b2, 0x00008802, 0x00008806,
+                       0x0000880a, 0x0000880e, 0x00008812, 0x00008816,
+                       0x0000881a, 0x0000881e, 0x00008822, 0x00008826,
+                       0x0000882a, 0x000090a6, 0x000090ae, 0x000090b6,
+                       0x000090be
+               };
+
+               for (counter = 0; counter < ARRAY_SIZE(vals); counter++)
+                       channels[counter].val = cpu_to_le32(vals[counter]);
                }
 
                /*
-                * 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.
+        */
+       for (counter = 0; counter < ARRAY_SIZE(rf); counter++) {
+               if (rt2x00_rf(&rt2x00usb->chip, rf[counter].chip)) {
+                       rt2x00usb->rf1 = cpu_to_le32(rf[counter].val[0]);
+                       rt2x00usb->rf3 = cpu_to_le32(rf[counter].val[1]);
+                       rt2x00usb->rf4 = cpu_to_le32(rf[counter].val[2]);
                }
        }
 }

Attachment: pgphQlgGBUJZm.pgp
Description: PGP signature

Reply via email to