madwifi: merge fixes from trunk
[openwrt/svn-archive/archive.git] / package / madwifi / patches / 421-channel_handling.patch
1 --- a/ath/if_ath.c
2 +++ b/ath/if_ath.c
3 @@ -148,7 +148,6 @@ static int ath_key_set(struct ieee80211v
4 static void ath_key_update_begin(struct ieee80211vap *);
5 static void ath_key_update_end(struct ieee80211vap *);
6 static void ath_mode_init(struct net_device *);
7 -static void ath_setslottime(struct ath_softc *);
8 static void ath_updateslot(struct net_device *);
9 static int ath_beaconq_setup(struct ath_softc *);
10 static int ath_beacon_alloc(struct ath_softc *, struct ieee80211_node *);
11 @@ -240,7 +239,7 @@ static void ath_setup_stationkey(struct
12 static void ath_setup_stationwepkey(struct ieee80211_node *);
13 static void ath_setup_keycacheslot(struct ath_softc *, struct ieee80211_node *);
14 static void ath_newassoc(struct ieee80211_node *, int);
15 -static int ath_getchannels(struct net_device *, u_int, HAL_BOOL, HAL_BOOL);
16 +static int ath_getchannels(struct net_device *);
17 static void ath_led_event(struct ath_softc *, int);
18 static void ath_update_txpow(struct ath_softc *);
19
20 @@ -265,7 +264,6 @@ static int ath_change_mtu(struct net_dev
21 static int ath_ioctl(struct net_device *, struct ifreq *, int);
22
23 static int ath_rate_setup(struct net_device *, u_int);
24 -static void ath_setup_subrates(struct net_device *);
25 #ifdef ATH_SUPERG_XR
26 static int ath_xr_rate_setup(struct net_device *);
27 static void ath_grppoll_txq_setup(struct ath_softc *, int, int);
28 @@ -387,8 +385,6 @@ static void ath_fetch_idle_time(struct a
29
30 /* calibrate every 30 secs in steady state but check every second at first. */
31 static int ath_calinterval = ATH_SHORT_CALINTERVAL;
32 -static int ath_countrycode = CTRY_DEFAULT; /* country code */
33 -static int ath_outdoor = AH_FALSE; /* enable outdoor use */
34 static int ath_xchanmode = AH_TRUE; /* enable extended channels */
35 static int ath_maxvaps = ATH_MAXVAPS_DEFAULT; /* set default maximum vaps */
36 static int bstuck_thresh = BSTUCK_THRESH; /* Stuck beacon count required for reset */
37 @@ -396,9 +392,7 @@ static char *autocreate = NULL;
38 static char *ratectl = DEF_RATE_CTL;
39 static int rfkill = 0;
40 static int tpc = 1;
41 -static int countrycode = -1;
42 static int maxvaps = -1;
43 -static int outdoor = -1;
44 static int xchanmode = -1;
45 #include "ath_wprobe.c"
46 static int beacon_cal = 1;
47 @@ -437,9 +431,7 @@ static struct notifier_block ath_event_b
48
49 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,52))
50 MODULE_PARM(beacon_cal, "i");
51 -MODULE_PARM(countrycode, "i");
52 MODULE_PARM(maxvaps, "i");
53 -MODULE_PARM(outdoor, "i");
54 MODULE_PARM(xchanmode, "i");
55 MODULE_PARM(rfkill, "i");
56 #ifdef ATH_CAP_TPC
57 @@ -451,9 +443,7 @@ MODULE_PARM(ratectl, "s");
58 #else
59 #include <linux/moduleparam.h>
60 module_param(beacon_cal, int, 0600);
61 -module_param(countrycode, int, 0600);
62 module_param(maxvaps, int, 0600);
63 -module_param(outdoor, int, 0600);
64 module_param(xchanmode, int, 0600);
65 module_param(rfkill, int, 0600);
66 #ifdef ATH_CAP_TPC
67 @@ -463,9 +453,7 @@ module_param(bstuck_thresh, int, 0600);
68 module_param(autocreate, charp, 0600);
69 module_param(ratectl, charp, 0600);
70 #endif
71 -MODULE_PARM_DESC(countrycode, "Override default country code");
72 MODULE_PARM_DESC(maxvaps, "Maximum VAPs");
73 -MODULE_PARM_DESC(outdoor, "Enable/disable outdoor use");
74 MODULE_PARM_DESC(xchanmode, "Enable/disable extended channel mode");
75 MODULE_PARM_DESC(rfkill, "Enable/disable RFKILL capability");
76 #ifdef ATH_CAP_TPC
77 @@ -531,6 +519,50 @@ MODULE_PARM_DESC(ieee80211_debug, "Load-
78 (bssid)[0] |= (((id) << 2) | 0x02); \
79 } while (0)
80
81 +static inline int ath_chan2mode(struct ieee80211_channel *c)
82 +{
83 + if (IEEE80211_IS_CHAN_HALF(c))
84 + return ATH_MODE_HALF;
85 + else if (IEEE80211_IS_CHAN_QUARTER(c))
86 + return ATH_MODE_QUARTER;
87 + else
88 + return ieee80211_chan2mode(c);
89 +}
90 +
91 +static inline int rate_hal2ieee(int dot11Rate, int f)
92 +{
93 + int flag = dot11Rate & ~(IEEE80211_RATE_VAL);
94 + dot11Rate &= IEEE80211_RATE_VAL;
95 +
96 + if (f == 4) { /* Quarter */
97 + if (dot11Rate == 4)
98 + return 18 | flag;
99 + }
100 + return (dot11Rate * f) | flag;
101 +}
102 +
103 +static inline int rate_factor(int mode)
104 +{
105 + int f;
106 +
107 + /*
108 + * NB: Fix up rates. HAL returns half or quarter dot11Rates,
109 + * while the stack deals with full rates only
110 + */
111 + switch(mode) {
112 + case ATH_MODE_HALF:
113 + f = 2;
114 + break;
115 + case ATH_MODE_QUARTER:
116 + f = 4;
117 + break;
118 + default:
119 + f = 1;
120 + break;
121 + }
122 + return f;
123 +}
124 +
125 /* Initialize ath_softc structure */
126
127 int
128 @@ -647,14 +679,6 @@ ath_attach(u_int16_t devid, struct net_d
129 for (i = 0; i < sc->sc_keymax; i++)
130 ath_hal_keyreset(ah, i);
131
132 - /*
133 - * Collect the channel list using the default country
134 - * code and including outdoor channels. The 802.11 layer
135 - * is responsible for filtering this list based on settings
136 - * like the phy mode.
137 - */
138 - if (countrycode != -1)
139 - ath_countrycode = countrycode;
140 if (maxvaps != -1) {
141 ath_maxvaps = maxvaps;
142 if (ath_maxvaps < ATH_MAXVAPS_MIN)
143 @@ -662,17 +686,14 @@ ath_attach(u_int16_t devid, struct net_d
144 else if (ath_maxvaps > ATH_MAXVAPS_MAX)
145 ath_maxvaps = ATH_MAXVAPS_MAX;
146 }
147 - if (outdoor != -1)
148 - ath_outdoor = outdoor;
149 if (xchanmode != -1)
150 ath_xchanmode = xchanmode;
151 - error = ath_getchannels(dev, ath_countrycode,
152 - ath_outdoor, ath_xchanmode);
153 + error = ath_getchannels(dev);
154 if (error != 0)
155 goto bad;
156
157 - ic->ic_country_code = ath_countrycode;
158 - ic->ic_country_outdoor = ath_outdoor;
159 + ic->ic_country_code = CTRY_DEFAULT;
160 + ic->ic_country_outdoor = 0;
161
162 IPRINTF(sc, "Switching rfkill capability %s\n",
163 rfkill ? "on" : "off");
164 @@ -686,9 +707,8 @@ ath_attach(u_int16_t devid, struct net_d
165 ath_rate_setup(dev, IEEE80211_MODE_11G);
166 ath_rate_setup(dev, IEEE80211_MODE_TURBO_A);
167 ath_rate_setup(dev, IEEE80211_MODE_TURBO_G);
168 -
169 - /* Setup for half/quarter rates */
170 - ath_setup_subrates(dev);
171 + ath_rate_setup(dev, ATH_MODE_HALF);
172 + ath_rate_setup(dev, ATH_MODE_QUARTER);
173
174 /* NB: setup here so ath_rate_update is happy */
175 ath_setcurmode(sc, IEEE80211_MODE_11A);
176 @@ -908,10 +928,6 @@ ath_attach(u_int16_t devid, struct net_d
177 IEEE80211_ATHC_COMP : 0);
178 #endif
179
180 -#ifdef ATH_SUPERG_DYNTURBO
181 - ic->ic_ath_cap |= (ath_hal_turboagsupported(ah, ath_countrycode) ?
182 - (IEEE80211_ATHC_TURBOP | IEEE80211_ATHC_AR) : 0);
183 -#endif
184 #ifdef ATH_SUPERG_XR
185 ic->ic_ath_cap |= (ath_hal_xrsupported(ah) ? IEEE80211_ATHC_XR : 0);
186 #endif
187 @@ -4470,17 +4486,17 @@ ath_mode_init(struct net_device *dev)
188 * Set the slot time based on the current setting.
189 */
190 static void
191 -ath_setslottime(struct ath_softc *sc)
192 +ath_settiming(struct ath_softc *sc)
193 {
194 - struct ieee80211com *ic = &sc->sc_ic;
195 struct ath_hal *ah = sc->sc_ah;
196 + u_int offset = getTimingOffset(sc);
197
198 - if (sc->sc_slottimeconf > 0) /* manual override */
199 - ath_hal_setslottime(ah, sc->sc_slottimeconf);
200 - else if (ic->ic_flags & IEEE80211_F_SHSLOT)
201 - ath_hal_setslottime(ah, HAL_SLOT_TIME_9);
202 - else
203 - ath_hal_setslottime(ah, HAL_SLOT_TIME_20);
204 + if (sc->sc_slottimeconf > 0)
205 + ath_hal_setslottime(ah, offset + sc->sc_slottimeconf);
206 + if (sc->sc_acktimeconf > 0)
207 + ath_hal_setacktimeout(ah, 2 * offset + sc->sc_acktimeconf);
208 + if (sc->sc_ctstimeconf > 0)
209 + ath_hal_setctstimeout(ah, 2 * offset + sc->sc_ctstimeconf);
210 sc->sc_updateslot = OK;
211 }
212
213 @@ -4502,7 +4518,7 @@ ath_updateslot(struct net_device *dev)
214 if (ic->ic_opmode == IEEE80211_M_HOSTAP)
215 sc->sc_updateslot = UPDATE;
216 else if (dev->flags & IFF_RUNNING)
217 - ath_setslottime(sc);
218 + ath_settiming(sc);
219 }
220
221 #ifdef ATH_SUPERG_DYNTURBO
222 @@ -5346,7 +5362,7 @@ ath_beacon_send(struct ath_softc *sc, in
223 sc->sc_updateslot = COMMIT; /* commit next beacon */
224 sc->sc_slotupdate = slot;
225 } else if ((sc->sc_updateslot == COMMIT) && (sc->sc_slotupdate == slot))
226 - ath_setslottime(sc); /* commit change to hardware */
227 + ath_settiming(sc); /* commit change to hardware */
228
229 if (bfaddr != 0) {
230 /*
231 @@ -7802,12 +7818,14 @@ ath_get_ivlen(struct ieee80211_key *k)
232 * Get transmit rate index using rate in Kbps
233 */
234 static __inline int
235 -ath_tx_findindex(const HAL_RATE_TABLE *rt, int rate)
236 +ath_tx_findindex(struct ath_softc *sc, const HAL_RATE_TABLE *rt, int rate)
237 {
238 unsigned int i, ndx = 0;
239 + int f;
240
241 + f = rate_factor(sc->sc_curmode);
242 for (i = 0; i < rt->rateCount; i++) {
243 - if (rt->info[i].rateKbps == rate) {
244 + if ((rt->info[i].rateKbps * f) == rate) {
245 ndx = i;
246 break;
247 }
248 @@ -8100,7 +8118,7 @@ ath_tx_start(struct net_device *dev, str
249 atype = HAL_PKT_TYPE_NORMAL; /* default */
250
251 if (ismcast) {
252 - rix = ath_tx_findindex(rt, vap->iv_mcast_rate);
253 + rix = ath_tx_findindex(sc, rt, vap->iv_mcast_rate);
254 txrate = rt->info[rix].rateCode;
255 if (shortPreamble)
256 txrate |= rt->info[rix].shortPreamble;
257 @@ -9067,7 +9085,7 @@ ath_chan_change(struct ath_softc *sc, st
258 struct net_device *dev = sc->sc_dev;
259 enum ieee80211_phymode mode;
260
261 - mode = ieee80211_chan2mode(chan);
262 + mode = ath_chan2mode(chan);
263
264 ath_rate_setup(dev, mode);
265 ath_setcurmode(sc, mode);
266 @@ -10124,8 +10142,7 @@ ath_newassoc(struct ieee80211_node *ni,
267 }
268
269 static int
270 -ath_getchannels(struct net_device *dev, u_int cc,
271 - HAL_BOOL outdoor, HAL_BOOL xchanmode)
272 +ath_getchannels(struct net_device *dev)
273 {
274 struct ath_softc *sc = dev->priv;
275 struct ieee80211com *ic = &sc->sc_ic;
276 @@ -10139,17 +10156,31 @@ ath_getchannels(struct net_device *dev,
277 EPRINTF(sc, "Insufficient memory for channel table!\n");
278 return -ENOMEM;
279 }
280 +
281 +restart:
282 if (!ath_hal_init_channels(ah, chans, IEEE80211_CHAN_MAX, &nchan,
283 ic->ic_regclassids, IEEE80211_REGCLASSIDS_MAX, &ic->ic_nregclass,
284 - cc, HAL_MODE_ALL, outdoor, xchanmode)) {
285 + ic->ic_country_code, HAL_MODE_ALL, ic->ic_country_outdoor, ath_xchanmode)) {
286 u_int32_t rd;
287
288 ath_hal_getregdomain(ah, &rd);
289 EPRINTF(sc, "Unable to collect channel list from HAL; "
290 - "regdomain likely %u country code %u\n", rd, cc);
291 + "regdomain likely %u country code %u\n", rd, ic->ic_country_code);
292 + if ((ic->ic_country_code != CTRY_DEFAULT) ||
293 + (ic->ic_country_outdoor != 0)) {
294 + EPRINTF(sc, "Reverting to defaults\n");
295 + ic->ic_country_code = CTRY_DEFAULT;
296 + ic->ic_country_outdoor = 0;
297 + goto restart;
298 + }
299 kfree(chans);
300 return -EINVAL;
301 }
302 +#ifdef ATH_SUPERG_DYNTURBO
303 + ic->ic_ath_cap &= ~(IEEE80211_ATHC_TURBOP | IEEE80211_ATHC_AR);
304 + ic->ic_ath_cap |= (ath_hal_turboagsupported(ah, ic->ic_country_code) ?
305 + (IEEE80211_ATHC_TURBOP | IEEE80211_ATHC_AR) : 0);
306 +#endif
307 /*
308 * Convert HAL channels to ieee80211 ones.
309 */
310 @@ -10395,7 +10426,7 @@ ath_xr_rate_setup(struct net_device *dev
311 struct ieee80211com *ic = &sc->sc_ic;
312 const HAL_RATE_TABLE *rt;
313 struct ieee80211_rateset *rs;
314 - unsigned int i, maxrates;
315 + unsigned int i, j, maxrates;
316 sc->sc_xr_rates = ath_hal_getratetable(ah, HAL_MODE_XR);
317 rt = sc->sc_xr_rates;
318 if (rt == NULL)
319 @@ -10408,57 +10439,16 @@ ath_xr_rate_setup(struct net_device *dev
320 } else
321 maxrates = rt->rateCount;
322 rs = &ic->ic_sup_xr_rates;
323 - for (i = 0; i < maxrates; i++)
324 - rs->rs_rates[i] = rt->info[i].dot11Rate;
325 - rs->rs_nrates = maxrates;
326 + for (j = 0, i = 0; i < maxrates; i++) {
327 + if (!rt->info[i].valid)
328 + continue;
329 + rs->rs_rates[j++] = rt->info[i].dot11Rate;
330 + }
331 + rs->rs_nrates = j;
332 return 1;
333 }
334 #endif
335
336 -/* Setup half/quarter rate table support */
337 -static void
338 -ath_setup_subrates(struct net_device *dev)
339 -{
340 - struct ath_softc *sc = dev->priv;
341 - struct ath_hal *ah = sc->sc_ah;
342 - struct ieee80211com *ic = &sc->sc_ic;
343 - const HAL_RATE_TABLE *rt;
344 - struct ieee80211_rateset *rs;
345 - unsigned int i, maxrates;
346 -
347 - sc->sc_half_rates = ath_hal_getratetable(ah, HAL_MODE_11A_HALF_RATE);
348 - rt = sc->sc_half_rates;
349 - if (rt != NULL) {
350 - if (rt->rateCount > IEEE80211_RATE_MAXSIZE) {
351 - DPRINTF(sc, ATH_DEBUG_ANY,
352 - "The rate table is too small (%u > %u)\n",
353 - rt->rateCount, IEEE80211_RATE_MAXSIZE);
354 - maxrates = IEEE80211_RATE_MAXSIZE;
355 - } else
356 - maxrates = rt->rateCount;
357 - rs = &ic->ic_sup_half_rates;
358 - for (i = 0; i < maxrates; i++)
359 - rs->rs_rates[i] = rt->info[i].dot11Rate;
360 - rs->rs_nrates = maxrates;
361 - }
362 -
363 - sc->sc_quarter_rates = ath_hal_getratetable(ah, HAL_MODE_11A_QUARTER_RATE);
364 - rt = sc->sc_quarter_rates;
365 - if (rt != NULL) {
366 - if (rt->rateCount > IEEE80211_RATE_MAXSIZE) {
367 - DPRINTF(sc, ATH_DEBUG_ANY,
368 - "The rate table is too small (%u > %u)\n",
369 - rt->rateCount, IEEE80211_RATE_MAXSIZE);
370 - maxrates = IEEE80211_RATE_MAXSIZE;
371 - } else
372 - maxrates = rt->rateCount;
373 - rs = &ic->ic_sup_quarter_rates;
374 - for (i = 0; i < maxrates; i++)
375 - rs->rs_rates[i] = rt->info[i].dot11Rate;
376 - rs->rs_nrates = maxrates;
377 - }
378 -}
379 -
380 static int
381 ath_rate_setup(struct net_device *dev, u_int mode)
382 {
383 @@ -10467,7 +10457,7 @@ ath_rate_setup(struct net_device *dev, u
384 struct ieee80211com *ic = &sc->sc_ic;
385 const HAL_RATE_TABLE *rt;
386 struct ieee80211_rateset *rs;
387 - unsigned int i, maxrates;
388 + unsigned int i, j, maxrates, f;
389
390 switch (mode) {
391 case IEEE80211_MODE_11A:
392 @@ -10485,6 +10475,12 @@ ath_rate_setup(struct net_device *dev, u
393 case IEEE80211_MODE_TURBO_G:
394 sc->sc_rates[mode] = ath_hal_getratetable(ah, HAL_MODE_108G);
395 break;
396 + case ATH_MODE_HALF:
397 + sc->sc_rates[mode] = ath_hal_getratetable(ah, HAL_MODE_11A_HALF_RATE);
398 + break;
399 + case ATH_MODE_QUARTER:
400 + sc->sc_rates[mode] = ath_hal_getratetable(ah, HAL_MODE_11A_QUARTER_RATE);
401 + break;
402 default:
403 DPRINTF(sc, ATH_DEBUG_ANY, "Invalid mode %u\n", mode);
404 return 0;
405 @@ -10499,10 +10495,16 @@ ath_rate_setup(struct net_device *dev, u
406 maxrates = IEEE80211_RATE_MAXSIZE;
407 } else
408 maxrates = rt->rateCount;
409 +
410 + /* NB: quarter/half rate channels hijack the 11A rateset */
411 + if (mode >= IEEE80211_MODE_MAX)
412 + return 1;
413 +
414 rs = &ic->ic_sup_rates[mode];
415 for (i = 0; i < maxrates; i++)
416 rs->rs_rates[i] = rt->info[i].dot11Rate;
417 rs->rs_nrates = maxrates;
418 +
419 return 1;
420 }
421
422 @@ -10531,13 +10533,18 @@ ath_setcurmode(struct ath_softc *sc, enu
423 { 0, 500, 130 },
424 };
425 const HAL_RATE_TABLE *rt;
426 - unsigned int i, j;
427 + unsigned int i, j, f;
428
429 + /*
430 + * NB: Fix up rixmap. HAL returns half or quarter dot11Rates,
431 + * while the stack deals with full rates only
432 + */
433 + f = rate_factor(mode);
434 memset(sc->sc_rixmap, 0xff, sizeof(sc->sc_rixmap));
435 rt = sc->sc_rates[mode];
436 KASSERT(rt != NULL, ("no h/w rate set for phy mode %u", mode));
437 for (i = 0; i < rt->rateCount; i++)
438 - sc->sc_rixmap[rt->info[i].dot11Rate & IEEE80211_RATE_VAL] = i;
439 + sc->sc_rixmap[rate_hal2ieee(rt->info[i].dot11Rate, f) & IEEE80211_RATE_VAL] = i;
440 memset(sc->sc_hwmap, 0, sizeof(sc->sc_hwmap));
441 for (i = 0; i < 32; i++) {
442 u_int8_t ix = rt->rateCodeToIndex[i];
443 @@ -10547,7 +10554,7 @@ ath_setcurmode(struct ath_softc *sc, enu
444 continue;
445 }
446 sc->sc_hwmap[i].ieeerate =
447 - rt->info[ix].dot11Rate & IEEE80211_RATE_VAL;
448 + rate_hal2ieee(rt->info[ix].dot11Rate, f) & IEEE80211_RATE_VAL;
449 if (rt->info[ix].shortPreamble ||
450 rt->info[ix].phy == IEEE80211_T_OFDM)
451 sc->sc_hwmap[i].flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
452 @@ -10948,9 +10955,106 @@ enum {
453 ATH_MAXVAPS = 26,
454 ATH_INTMIT = 27,
455 ATH_NOISE_IMMUNITY = 28,
456 - ATH_OFDM_WEAK_DET = 29
457 + ATH_OFDM_WEAK_DET = 29,
458 + ATH_CHANBW = 30,
459 + ATH_OUTDOOR = 31,
460 };
461
462 +/*
463 + * perform the channel related sysctl, reload the channel list
464 + * and try to stay on the current frequency
465 + */
466 +static int ath_sysctl_setchanparam(struct ath_softc *sc, unsigned long ctl, u_int val)
467 +{
468 + struct ieee80211com *ic = &sc->sc_ic;
469 + struct ath_hal *ah = sc->sc_ah;
470 + struct ieee80211_channel *c = NULL;
471 + struct ieee80211vap *vap;
472 + u_int16_t freq = 0;
473 + struct ifreq ifr;
474 +
475 + if (ic->ic_curchan != IEEE80211_CHAN_ANYC)
476 + freq = ic->ic_curchan->ic_freq;
477 +
478 + switch(ctl) {
479 + case ATH_COUNTRYCODE:
480 + ic->ic_country_code = val;
481 + break;
482 + case ATH_OUTDOOR:
483 + ic->ic_country_outdoor = val;
484 + break;
485 + case ATH_CHANBW:
486 + switch(val) {
487 + case 0:
488 + case 5:
489 + case 10:
490 + case 20:
491 + case 40:
492 + if (ath_hal_setcapability(ah, HAL_CAP_CHANBW, 1, val, NULL) == AH_TRUE) {
493 + sc->sc_chanbw = val;
494 + break;
495 + }
496 + default:
497 + return -EINVAL;
498 + }
499 + break;
500 + }
501 +
502 + if (ic->ic_curchan != IEEE80211_CHAN_ANYC)
503 + freq = ic->ic_curchan->ic_freq;
504 +
505 + /* clear out any old state */
506 + TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
507 + vap->iv_des_mode = IEEE80211_MODE_AUTO;
508 + vap->iv_des_chan = IEEE80211_CHAN_ANYC;
509 + }
510 + ieee80211_scan_flush(ic);
511 +
512 + IEEE80211_LOCK_IRQ(ic);
513 + ath_getchannels(sc->sc_dev);
514 + ieee80211_update_channels(ic, 0);
515 + if (freq)
516 + c = ieee80211_find_channel(ic, freq, IEEE80211_MODE_AUTO);
517 + if (!c)
518 + c = &ic->ic_channels[0];
519 + ic->ic_curchan = c;
520 + ic->ic_bsschan = c;
521 + ic->ic_curmode = IEEE80211_MODE_AUTO;
522 + IEEE80211_UNLOCK_IRQ(ic);
523 +
524 + if (!(sc->sc_dev->flags & IFF_RUNNING)) {
525 + ic->ic_bsschan = IEEE80211_CHAN_ANYC;
526 + return 0;
527 + }
528 +
529 +#ifndef ifr_media
530 +#define ifr_media ifr_ifru.ifru_ivalue
531 +#endif
532 + memset(&ifr, 0, sizeof(ifr));
533 + ifr.ifr_media = ic->ic_media.ifm_cur->ifm_media & ~IFM_MMASK;
534 + ifr.ifr_media |= IFM_MAKEMODE(IEEE80211_MODE_AUTO);
535 + ifmedia_ioctl(ic->ic_dev, &ifr, &ic->ic_media, SIOCSIFMEDIA);
536 +
537 + /* apply the channel to the hw */
538 + ath_set_channel(ic);
539 +
540 + TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
541 + struct net_device *dev = vap->iv_dev;
542 +
543 + /* reactivate all active vaps */
544 + vap->iv_state = IEEE80211_S_SCAN;
545 + if ((vap->iv_opmode == IEEE80211_M_HOSTAP) ||
546 + (vap->iv_opmode == IEEE80211_M_MONITOR) ||
547 + (vap->iv_opmode == IEEE80211_M_WDS))
548 + ieee80211_new_state(vap, IEEE80211_S_RUN, 0);
549 + else
550 + ieee80211_new_state(vap, IEEE80211_S_INIT, -1);
551 + }
552 +
553 + return 0;
554 +}
555 +
556 +
557 static int
558 ath_sysctl_set_intmit(struct ath_softc *sc, long ctl, u_int val)
559 {
560 @@ -11029,6 +11133,7 @@ static int
561 ATH_SYSCTL_DECL(ath_sysctl_halparam, ctl, write, filp, buffer, lenp, ppos)
562 {
563 struct ath_softc *sc = ctl->extra1;
564 + struct ieee80211com *ic = &sc->sc_ic;
565 struct ath_hal *ah = sc->sc_ah;
566 u_int val;
567 u_int tab_3_val[3];
568 @@ -11052,25 +11157,34 @@ ATH_SYSCTL_DECL(ath_sysctl_halparam, ctl
569 lenp, ppos);
570 if (ret == 0) {
571 switch ((long)ctl->extra2) {
572 + case ATH_REGDOMAIN:
573 + ath_hal_setregdomain(ah, val);
574 + break;
575 + case ATH_OUTDOOR:
576 + case ATH_COUNTRYCODE:
577 + case ATH_CHANBW:
578 + ret = ath_sysctl_setchanparam(sc, (long) ctl->extra2, val);
579 + break;
580 case ATH_SLOTTIME:
581 - if (val > 0) {
582 - if (!ath_hal_setslottime(ah, val))
583 - ret = -EINVAL;
584 - else
585 - sc->sc_slottimeconf = val;
586 - } else {
587 - /* disable manual override */
588 + if (val > 0)
589 + sc->sc_slottimeconf = val;
590 + else
591 sc->sc_slottimeconf = 0;
592 - ath_setslottime(sc);
593 - }
594 + ath_settiming(sc);
595 break;
596 case ATH_ACKTIMEOUT:
597 - if (!ath_hal_setacktimeout(ah, val))
598 - ret = -EINVAL;
599 + if (val > 0)
600 + sc->sc_acktimeconf = val;
601 + else
602 + sc->sc_acktimeconf = 0;
603 + ath_settiming(sc);
604 break;
605 case ATH_CTSTIMEOUT:
606 - if (!ath_hal_setctstimeout(ah, val))
607 - ret = -EINVAL;
608 + if (val > 0)
609 + sc->sc_ctstimeconf = val;
610 + else
611 + sc->sc_ctstimeconf = 0;
612 + ath_settiming(sc);
613 break;
614 case ATH_SOFTLED:
615 if (val != sc->sc_softled) {
616 @@ -11223,6 +11337,9 @@ ATH_SYSCTL_DECL(ath_sysctl_halparam, ctl
617 }
618 } else {
619 switch ((long)ctl->extra2) {
620 + case ATH_CHANBW:
621 + val = sc->sc_chanbw ?: 20;
622 + break;
623 case ATH_SLOTTIME:
624 val = ath_hal_getslottime(ah);
625 break;
626 @@ -11241,6 +11358,9 @@ ATH_SYSCTL_DECL(ath_sysctl_halparam, ctl
627 case ATH_COUNTRYCODE:
628 ath_hal_getcountrycode(ah, &val);
629 break;
630 + case ATH_OUTDOOR:
631 + val = ic->ic_country_outdoor;
632 + break;
633 case ATH_MAXVAPS:
634 val = ath_maxvaps;
635 break;
636 @@ -11354,11 +11474,17 @@ static const ctl_table ath_sysctl_templa
637 },
638 { .ctl_name = CTL_AUTO,
639 .procname = "countrycode",
640 - .mode = 0444,
641 + .mode = 0644,
642 .proc_handler = ath_sysctl_halparam,
643 .extra2 = (void *)ATH_COUNTRYCODE,
644 },
645 { .ctl_name = CTL_AUTO,
646 + .procname = "outdoor",
647 + .mode = 0644,
648 + .proc_handler = ath_sysctl_halparam,
649 + .extra2 = (void *)ATH_OUTDOOR,
650 + },
651 + { .ctl_name = CTL_AUTO,
652 .procname = "maxvaps",
653 .mode = 0444,
654 .proc_handler = ath_sysctl_halparam,
655 @@ -11366,7 +11492,7 @@ static const ctl_table ath_sysctl_templa
656 },
657 { .ctl_name = CTL_AUTO,
658 .procname = "regdomain",
659 - .mode = 0444,
660 + .mode = 0644,
661 .proc_handler = ath_sysctl_halparam,
662 .extra2 = (void *)ATH_REGDOMAIN,
663 },
664 @@ -11429,6 +11555,12 @@ static const ctl_table ath_sysctl_templa
665 .extra2 = (void *)ATH_ACKRATE,
666 },
667 { .ctl_name = CTL_AUTO,
668 + .procname = "channelbw",
669 + .mode = 0644,
670 + .proc_handler = ath_sysctl_halparam,
671 + .extra2 = (void *)ATH_CHANBW,
672 + },
673 + { .ctl_name = CTL_AUTO,
674 .procname = "rp",
675 .mode = 0200,
676 .proc_handler = ath_sysctl_halparam,
677 @@ -11669,13 +11801,6 @@ static ctl_table ath_static_sysctls[] =
678 },
679 #endif
680 { .ctl_name = CTL_AUTO,
681 - .procname = "countrycode",
682 - .mode = 0444,
683 - .data = &ath_countrycode,
684 - .maxlen = sizeof(ath_countrycode),
685 - .proc_handler = proc_dointvec
686 - },
687 - { .ctl_name = CTL_AUTO,
688 .procname = "maxvaps",
689 .mode = 0444,
690 .data = &ath_maxvaps,
691 @@ -11683,13 +11808,6 @@ static ctl_table ath_static_sysctls[] =
692 .proc_handler = proc_dointvec
693 },
694 { .ctl_name = CTL_AUTO,
695 - .procname = "outdoor",
696 - .mode = 0444,
697 - .data = &ath_outdoor,
698 - .maxlen = sizeof(ath_outdoor),
699 - .proc_handler = proc_dointvec
700 - },
701 - { .ctl_name = CTL_AUTO,
702 .procname = "xchanmode",
703 .mode = 0444,
704 .data = &ath_xchanmode,
705 --- a/ath/if_athvar.h
706 +++ b/ath/if_athvar.h
707 @@ -688,17 +688,18 @@ struct ath_softc {
708 int8_t sc_ofdm_weak_det; /* OFDM weak frames detection, -1 == auto */
709
710 /* rate tables */
711 - const HAL_RATE_TABLE *sc_rates[IEEE80211_MODE_MAX];
712 +#define ATH_MODE_HALF (IEEE80211_MODE_MAX)
713 +#define ATH_MODE_QUARTER (IEEE80211_MODE_MAX + 1)
714 + const HAL_RATE_TABLE *sc_rates[IEEE80211_MODE_MAX + 2];
715 const HAL_RATE_TABLE *sc_currates; /* current rate table */
716 const HAL_RATE_TABLE *sc_xr_rates; /* XR rate table */
717 - const HAL_RATE_TABLE *sc_half_rates; /* half rate table */
718 - const HAL_RATE_TABLE *sc_quarter_rates; /* quarter rate table */
719 HAL_OPMODE sc_opmode; /* current hal operating mode */
720 enum ieee80211_phymode sc_curmode; /* current phy mode */
721 u_int sc_poweroffset; /* hardware power offset */
722 u_int16_t sc_curtxpow; /* current tx power limit */
723 u_int16_t sc_curaid; /* current association id */
724 HAL_CHANNEL sc_curchan; /* current h/w channel */
725 + u_int8_t sc_chanbw; /* channel bandwidth */
726 u_int8_t sc_curbssid[IEEE80211_ADDR_LEN];
727 u_int8_t sc_rixmap[256]; /* IEEE to h/w rate table ix */
728 struct {
729 @@ -809,6 +810,8 @@ struct ath_softc {
730 u_int32_t sc_dturbo_bw_turbo; /* bandwidth threshold */
731 #endif
732 u_int sc_slottimeconf; /* manual override for slottime */
733 + u_int sc_acktimeconf; /* manual override for acktime */
734 + u_int sc_ctstimeconf; /* manual override for ctstime */
735
736 struct timer_list sc_dfs_excl_timer; /* mark expiration timer task */
737 struct timer_list sc_dfs_cac_timer; /* dfs wait timer */
738 @@ -827,6 +830,7 @@ struct ath_softc {
739 int sc_rp_num;
740 int sc_rp_min;
741 HAL_BOOL (*sc_rp_analyse)(struct ath_softc *sc);
742 + struct ATH_TQ_STRUCT sc_refresh_tq;
743 struct ATH_TQ_STRUCT sc_rp_tq;
744
745 int sc_rp_ignored; /* if set, we ignored all
746 @@ -942,6 +946,48 @@ int ar_device(int devid);
747 DEV_NAME(_v->iv_ic->ic_dev))
748
749 void ath_radar_detected(struct ath_softc *sc, const char* message);
750 +static inline u_int getTimingOffset(struct ath_softc *sc)
751 +{
752 + struct ieee80211com *ic = &sc->sc_ic;
753 + u_int usec = 9;
754 + if (IEEE80211_IS_CHAN_ANYG(ic->ic_curchan)) {
755 + usec = 20;
756 + if (ic->ic_flags & IEEE80211_F_SHSLOT)
757 + usec = 9;
758 + } else if (IEEE80211_IS_CHAN_A(ic->ic_curchan))
759 + usec = 9;
760 +
761 + if (IEEE80211_IS_CHAN_TURBO(ic->ic_curchan))
762 + usec = 6;
763 +
764 + if (IEEE80211_IS_CHAN_HALF(ic->ic_curchan))
765 + usec = 13;
766 + else if (IEEE80211_IS_CHAN_QUARTER(ic->ic_curchan))
767 + usec = 21;
768 + return usec;
769 +}
770 +
771 +static inline void ath_get_timings(struct ath_softc *sc, u_int *t_slot, u_int *t_sifs, u_int *t_difs)
772 +{
773 + struct ieee80211_channel *c = sc->sc_ic.ic_curchan;
774 +
775 + *t_slot = getTimingOffset(sc) + sc->sc_slottimeconf;
776 +
777 + if (IEEE80211_IS_CHAN_HALF(c)) {
778 + *t_sifs = 32;
779 + *t_difs = 56;
780 + } else if (IEEE80211_IS_CHAN_QUARTER(c)) {
781 + *t_sifs = 64;
782 + *t_difs = 112;
783 + } else if (IEEE80211_IS_CHAN_TURBO(c)) {
784 + *t_sifs = 8;
785 + *t_difs = 28;
786 + } else {
787 + *t_sifs = 16;
788 + *t_difs = 28;
789 + }
790 +}
791 +
792
793 struct ath_hw_detect {
794 const char *vendor_name;
795 --- a/tools/athctrl.c
796 +++ b/tools/athctrl.c
797 @@ -118,7 +118,7 @@ CMD(athctrl)(int argc, char *argv[])
798 }
799
800 if (distance >= 0) {
801 - int slottime = 9 + (distance / 300) + ((distance % 300) ? 1 : 0);
802 + int slottime = (distance / 300) + ((distance % 300) ? 1 : 0);
803 int acktimeout = slottime * 2 + 3;
804 int ctstimeout = slottime * 2 + 3;
805
806 --- a/net80211/ieee80211.c
807 +++ b/net80211/ieee80211.c
808 @@ -243,34 +243,17 @@ static const struct country_code_to_str
809 {CTRY_ZIMBABWE, "ZW"}
810 };
811
812 -int
813 -ieee80211_ifattach(struct ieee80211com *ic)
814 +void ieee80211_update_channels(struct ieee80211com *ic, int init)
815 {
816 - struct net_device *dev = ic->ic_dev;
817 struct ieee80211_channel *c;
818 + struct ieee80211vap *vap;
819 struct ifmediareq imr;
820 + int ext = 0;
821 int i;
822
823 - _MOD_INC_USE(THIS_MODULE, return -ENODEV);
824 -
825 - /*
826 - * Pick an initial operating mode until we have a vap
827 - * created to lock it down correctly. This is only
828 - * drivers have something defined for configuring the
829 - * hardware at startup.
830 - */
831 - ic->ic_opmode = IEEE80211_M_STA; /* everyone supports this */
832 -
833 - /*
834 - * Fill in 802.11 available channel set, mark
835 - * all available channels as active, and pick
836 - * a default channel if not already specified.
837 - */
838 - KASSERT(0 < ic->ic_nchans && ic->ic_nchans < IEEE80211_CHAN_MAX,
839 - ("invalid number of channels specified: %u", ic->ic_nchans));
840 memset(ic->ic_chan_avail, 0, sizeof(ic->ic_chan_avail));
841 - ic->ic_modecaps |= 1 << IEEE80211_MODE_AUTO;
842 ic->ic_max_txpower = IEEE80211_TXPOWER_MIN;
843 + ic->ic_modecaps = 1 << IEEE80211_MODE_AUTO;
844
845 for (i = 0; i < ic->ic_nchans; i++) {
846 c = &ic->ic_channels[i];
847 @@ -298,6 +281,8 @@ ieee80211_ifattach(struct ieee80211com *
848 ic->ic_modecaps |= 1 << IEEE80211_MODE_TURBO_A;
849 if (IEEE80211_IS_CHAN_108G(c))
850 ic->ic_modecaps |= 1 << IEEE80211_MODE_TURBO_G;
851 + if (IEEE80211_IS_CHAN_HALF(c) || IEEE80211_IS_CHAN_QUARTER(c))
852 + ext = 1;
853 }
854 /* Initialize candidate channels to all available */
855 memcpy(ic->ic_chan_active, ic->ic_chan_avail,
856 @@ -311,11 +296,59 @@ ieee80211_ifattach(struct ieee80211com *
857 * When 11g is supported, force the rate set to
858 * include basic rates suitable for a mixed b/g bss.
859 */
860 - if (ic->ic_modecaps & (1 << IEEE80211_MODE_11G))
861 + if ((ic->ic_modecaps & (1 << IEEE80211_MODE_11G)) && !ext)
862 ieee80211_set11gbasicrates(
863 &ic->ic_sup_rates[IEEE80211_MODE_11G],
864 IEEE80211_MODE_11G);
865
866 + if (init)
867 + return;
868 +
869 + ifmedia_removeall(&ic->ic_media);
870 + ieee80211_media_setup(ic, &ic->ic_media, ic->ic_caps, NULL, NULL);
871 + ieee80211com_media_status(ic->ic_dev, &imr);
872 + ifmedia_set(&ic->ic_media, imr.ifm_active);
873 +
874 + TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) {
875 + struct ieee80211vap *avp;
876 + TAILQ_FOREACH(avp, &vap->iv_wdslinks, iv_wdsnext) {
877 + (void) ieee80211_media_setup(ic, &vap->iv_media, vap->iv_caps, NULL, NULL);
878 + ieee80211_media_status(vap->iv_dev, &imr);
879 + ifmedia_set(&vap->iv_media, imr.ifm_active);
880 + }
881 + (void) ieee80211_media_setup(ic, &vap->iv_media, vap->iv_caps, NULL, NULL);
882 + ieee80211_media_status(vap->iv_dev, &imr);
883 + ifmedia_set(&vap->iv_media, imr.ifm_active);
884 + }
885 +}
886 +EXPORT_SYMBOL(ieee80211_update_channels);
887 +
888 +int
889 +ieee80211_ifattach(struct ieee80211com *ic)
890 +{
891 + struct net_device *dev = ic->ic_dev;
892 + struct ieee80211_channel *c;
893 + struct ifmediareq imr;
894 +
895 + _MOD_INC_USE(THIS_MODULE, return -ENODEV);
896 +
897 + /*
898 + * Pick an initial operating mode until we have a vap
899 + * created to lock it down correctly. This is only
900 + * drivers have something defined for configuring the
901 + * hardware at startup.
902 + */
903 + ic->ic_opmode = IEEE80211_M_STA; /* everyone supports this */
904 +
905 + /*
906 + * Fill in 802.11 available channel set, mark
907 + * all available channels as active, and pick
908 + * a default channel if not already specified.
909 + */
910 + KASSERT(0 < ic->ic_nchans && ic->ic_nchans < IEEE80211_CHAN_MAX,
911 + ("invalid number of channels specified: %u", ic->ic_nchans));
912 + ieee80211_update_channels(ic, 1);
913 +
914 /* Setup initial channel settings */
915 ic->ic_bsschan = IEEE80211_CHAN_ANYC;
916 /* Arbitrarily pick the first channel */
917 @@ -327,6 +360,7 @@ ieee80211_ifattach(struct ieee80211com *
918 /* Enable WME by default, if we're capable. */
919 if (ic->ic_caps & IEEE80211_C_WME)
920 ic->ic_flags |= IEEE80211_F_WME;
921 +
922 (void) ieee80211_setmode(ic, ic->ic_curmode);
923
924 /* Store default beacon interval, as nec. */
925 @@ -763,7 +797,8 @@ ieee80211_media_setup(struct ieee80211co
926 struct ieee80211_rateset allrates;
927
928 /* Fill in media characteristics. */
929 - ifmedia_init(media, 0, media_change, media_stat);
930 + if (media_change || media_stat)
931 + ifmedia_init(media, 0, media_change, media_stat);
932 maxrate = 0;
933 memset(&allrates, 0, sizeof(allrates));
934
935 @@ -793,7 +828,7 @@ ieee80211_media_setup(struct ieee80211co
936 ADD(media, IFM_AUTO, mopt | IFM_IEEE80211_WDS);
937 if (mode == IEEE80211_MODE_AUTO)
938 continue;
939 - rs = &ic->ic_sup_rates[mode];
940 + rs = &ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, mode)];
941
942 for (i = 0; i < rs->rs_nrates; i++) {
943 rate = rs->rs_rates[i];
944 @@ -1207,7 +1242,7 @@ ieee80211_announce(struct ieee80211com *
945 if ((ic->ic_modecaps & (1 << mode)) == 0)
946 continue;
947 if_printf(dev, "%s rates: ", ieee80211_phymode_name[mode]);
948 - rs = &ic->ic_sup_rates[mode];
949 + rs = &ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, mode)];
950 for (i = 0; i < rs->rs_nrates; i++) {
951 rate = rs->rs_rates[i];
952 mword = ieee80211_rate2media(ic, rate, mode);
953 @@ -1417,7 +1452,7 @@ ieee80211com_media_change(struct net_dev
954 * now so drivers have a consistent state.
955 */
956 KASSERT(vap->iv_bss != NULL, ("no bss node"));
957 - vap->iv_bss->ni_rates = ic->ic_sup_rates[newphymode];
958 + vap->iv_bss->ni_rates = ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, newphymode)];
959 }
960 error = -ENETRESET;
961 }
962 @@ -1435,7 +1470,7 @@ findrate(struct ieee80211com *ic, enum i
963 {
964 #define IEEERATE(_ic,_m,_i) \
965 ((_ic)->ic_sup_rates[_m].rs_rates[_i] & IEEE80211_RATE_VAL)
966 - int i, nrates = ic->ic_sup_rates[mode].rs_nrates;
967 + int i, nrates = ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, mode)].rs_nrates;
968 for (i = 0; i < nrates; i++)
969 if (IEEERATE(ic, mode, i) == rate)
970 return i;
971 @@ -1877,11 +1912,6 @@ ieee80211_build_countryie(struct ieee802
972 if (ieee80211_chan2mode(c) != curmode_noturbo)
973 continue;
974
975 - /* Skip half/quarter rate channels */
976 - if (IEEE80211_IS_CHAN_HALF(c) ||
977 - IEEE80211_IS_CHAN_QUARTER(c))
978 - continue;
979 -
980 if (*cur_runlen == 0) {
981 (*cur_runlen)++;
982 *cur_pow = c->ic_maxregpower;
983 @@ -1915,7 +1945,7 @@ void
984 ieee80211_build_sc_ie(struct ieee80211com *ic)
985 {
986 struct ieee80211_ie_sc *ie = &ic->ic_sc_ie;
987 - int i, j;
988 + int i, j, k;
989 struct ieee80211_channel *c;
990 u_int8_t prevchan;
991
992 --- a/net80211/ieee80211_var.h
993 +++ b/net80211/ieee80211_var.h
994 @@ -336,8 +336,6 @@ struct ieee80211com {
995 u_int8_t ic_nopened; /* VAPs been opened */
996 struct ieee80211_rateset ic_sup_rates[IEEE80211_MODE_MAX];
997 struct ieee80211_rateset ic_sup_xr_rates;
998 - struct ieee80211_rateset ic_sup_half_rates;
999 - struct ieee80211_rateset ic_sup_quarter_rates;
1000 u_int16_t ic_modecaps; /* set of mode capabilities */
1001 u_int16_t ic_curmode; /* current mode */
1002 u_int16_t ic_lintval; /* beacon interval */
1003 @@ -714,6 +712,7 @@ MALLOC_DECLARE(M_80211_VAP);
1004
1005 int ieee80211_ifattach(struct ieee80211com *);
1006 void ieee80211_ifdetach(struct ieee80211com *);
1007 +void ieee80211_update_channels(struct ieee80211com *ic, int);
1008 int ieee80211_vap_setup(struct ieee80211com *, struct net_device *,
1009 const char *, int, int, struct ieee80211vap *);
1010 int ieee80211_vap_attach(struct ieee80211vap *, ifm_change_cb_t, ifm_stat_cb_t);
1011 @@ -793,6 +792,23 @@ ieee80211_anyhdrspace(struct ieee80211co
1012 return size;
1013 }
1014
1015 +static __inline int
1016 +ieee80211_chan2ratemode(struct ieee80211_channel *c, int mode)
1017 +{
1018 + if (mode == -1)
1019 + mode = ieee80211_chan2mode(c);
1020 +
1021 + /*
1022 + * Use 11a rateset for half/quarter to restrict things
1023 + * to pure OFDM
1024 + */
1025 + if (IEEE80211_IS_CHAN_HALF(c) ||
1026 + IEEE80211_IS_CHAN_QUARTER(c))
1027 + return IEEE80211_MODE_11A;
1028 +
1029 + return mode;
1030 +}
1031 +
1032 /* Macros to print MAC address used in 802.11 headers */
1033
1034 #define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
1035 --- a/net80211/ieee80211_node.c
1036 +++ b/net80211/ieee80211_node.c
1037 @@ -287,7 +287,7 @@ ieee80211_node_set_chan(struct ieee80211
1038 ni->ni_rates = ic->ic_sup_xr_rates;
1039 else
1040 #endif
1041 - ni->ni_rates = ic->ic_sup_rates[ieee80211_chan2mode(chan)];
1042 + ni->ni_rates = ic->ic_sup_rates[ieee80211_chan2ratemode(chan, -1)];
1043 }
1044
1045 static __inline void
1046 @@ -387,6 +387,8 @@ ieee80211_create_ibss(struct ieee80211va
1047 ic->ic_bsschan = chan;
1048 ieee80211_node_set_chan(ic, ni);
1049 ic->ic_curmode = ieee80211_chan2mode(chan);
1050 + ni->ni_rates = ic->ic_sup_rates[ieee80211_chan2ratemode(chan, -1)];
1051 +
1052 spin_lock_irqsave(&channel_lock, flags);
1053 ieee80211_scan_set_bss_channel(ic, ic->ic_bsschan);
1054 spin_unlock_irqrestore(&channel_lock, flags);
1055 @@ -394,14 +396,8 @@ ieee80211_create_ibss(struct ieee80211va
1056 /* Update country ie information */
1057 ieee80211_build_countryie(ic);
1058
1059 - if (IEEE80211_IS_CHAN_HALF(chan)) {
1060 - ni->ni_rates = ic->ic_sup_half_rates;
1061 - } else if (IEEE80211_IS_CHAN_QUARTER(chan)) {
1062 - ni->ni_rates = ic->ic_sup_quarter_rates;
1063 - }
1064 -
1065 - if ((vap->iv_flags & IEEE80211_F_PUREG) &&
1066 - IEEE80211_IS_CHAN_ANYG(chan)) {
1067 + if ((ieee80211_chan2ratemode(chan, -1) != IEEE80211_MODE_11A) &&
1068 + IEEE80211_IS_CHAN_ANYG(chan) && (vap->iv_flags & IEEE80211_F_PUREG)) {
1069 ieee80211_setpuregbasicrates(&ni->ni_rates);
1070 }
1071
1072 --- a/net80211/ieee80211_scan_sta.c
1073 +++ b/net80211/ieee80211_scan_sta.c
1074 @@ -490,12 +490,7 @@ check_rate(struct ieee80211vap *vap, con
1075
1076 okrate = badrate = fixedrate = 0;
1077
1078 - if (IEEE80211_IS_CHAN_HALF(se->se_chan))
1079 - srs = &ic->ic_sup_half_rates;
1080 - else if (IEEE80211_IS_CHAN_QUARTER(se->se_chan))
1081 - srs = &ic->ic_sup_quarter_rates;
1082 - else
1083 - srs = &ic->ic_sup_rates[ieee80211_chan2mode(se->se_chan)];
1084 + srs = &ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, -1)];
1085 nrs = se->se_rates[1];
1086 rs = se->se_rates + 2;
1087 fixedrate = IEEE80211_FIXED_RATE_NONE;
1088 --- a/net80211/ieee80211_output.c
1089 +++ b/net80211/ieee80211_output.c
1090 @@ -1676,8 +1676,8 @@ ieee80211_send_probereq(struct ieee80211
1091
1092 frm = ieee80211_add_ssid(frm, ssid, ssidlen);
1093 mode = ieee80211_chan2mode(ic->ic_curchan);
1094 - frm = ieee80211_add_rates(frm, &ic->ic_sup_rates[mode]);
1095 - frm = ieee80211_add_xrates(frm, &ic->ic_sup_rates[mode]);
1096 + frm = ieee80211_add_rates(frm, &ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, mode)]);
1097 + frm = ieee80211_add_xrates(frm, &ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, mode)]);
1098
1099 if (optie != NULL) {
1100 memcpy(frm, optie, optielen);
1101 --- a/net80211/ieee80211_proto.c
1102 +++ b/net80211/ieee80211_proto.c
1103 @@ -404,7 +404,7 @@ ieee80211_fix_rate(struct ieee80211_node
1104
1105 error = 0;
1106 okrate = badrate = fixedrate = 0;
1107 - srs = &ic->ic_sup_rates[ieee80211_chan2mode(ni->ni_chan)];
1108 + srs = &ic->ic_sup_rates[ieee80211_chan2ratemode(ic->ic_curchan, -1)];
1109 nrs = &ni->ni_rates;
1110 fixedrate = IEEE80211_FIXED_RATE_NONE;
1111 for (i = 0; i < nrs->rs_nrates;) {
1112 @@ -1407,6 +1407,7 @@ ieee80211_new_state(struct ieee80211vap
1113 IEEE80211_VAPS_UNLOCK_IRQ(ic);
1114 return rc;
1115 }
1116 +EXPORT_SYMBOL(ieee80211_new_state);
1117
1118 static int
1119 __ieee80211_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
1120 --- a/ath_rate/minstrel/minstrel.c
1121 +++ b/ath_rate/minstrel/minstrel.c
1122 @@ -195,31 +195,7 @@ calc_usecs_unicast_packet(struct ath_sof
1123 return 0;
1124 }
1125
1126 - /* XXX: Getting MAC/PHY level timings should be fixed for turbo
1127 - * rates, and there is probably a way to get this from the
1128 - * HAL... */
1129 - switch (rt->info[rix].phy) {
1130 - case IEEE80211_T_OFDM:
1131 -#if 0
1132 - t_slot = 9;
1133 - t_sifs = 16;
1134 - t_difs = 28;
1135 - /* fall through */
1136 -#endif
1137 - case IEEE80211_T_TURBO:
1138 - t_slot = 9;
1139 - t_sifs = 8;
1140 - t_difs = 28;
1141 - break;
1142 - case IEEE80211_T_DS:
1143 - /* Fall through to default */
1144 - default:
1145 - /* pg. 205 ieee.802.11.pdf */
1146 - t_slot = 20;
1147 - t_difs = 50;
1148 - t_sifs = 10;
1149 - }
1150 -
1151 + ath_get_timings(sc, &t_slot, &t_sifs, &t_difs);
1152 if ((ic->ic_flags & IEEE80211_F_USEPROT) &&
1153 (rt->info[rix].phy == IEEE80211_T_OFDM)) {
1154 if (ic->ic_protmode == IEEE80211_PROT_RTSCTS)
1155 --- a/ath_rate/sample/sample.c
1156 +++ b/ath_rate/sample/sample.c
1157 @@ -172,26 +172,7 @@ calc_usecs_unicast_packet(struct ath_sof
1158 * rates, and there is probably a way to get this from the
1159 * hal...
1160 */
1161 - switch (rt->info[rix].phy) {
1162 - case IEEE80211_T_OFDM:
1163 - t_slot = 9;
1164 - t_sifs = 16;
1165 - t_difs = 28;
1166 - /* fall through */
1167 - case IEEE80211_T_TURBO:
1168 - t_slot = 9;
1169 - t_sifs = 8;
1170 - t_difs = 28;
1171 - break;
1172 - case IEEE80211_T_DS:
1173 - /* fall through to default */
1174 - default:
1175 - /* pg 205 ieee.802.11.pdf */
1176 - t_slot = 20;
1177 - t_difs = 50;
1178 - t_sifs = 10;
1179 - }
1180 -
1181 + ath_get_timings(sc, &t_slot, &t_sifs, &t_difs);
1182 rts = cts = 0;
1183
1184 if ((ic->ic_flags & IEEE80211_F_USEPROT) &&
1185 --- a/net80211/ieee80211_wireless.c
1186 +++ b/net80211/ieee80211_wireless.c
1187 @@ -2142,7 +2142,7 @@ ieee80211_ioctl_setmode(struct net_devic
1188
1189 vap->iv_des_mode = mode;
1190 if (IS_UP_AUTO(vap))
1191 - ieee80211_new_state(vap, IEEE80211_S_SCAN, 0);
1192 + ieee80211_init(vap->iv_dev, 0);
1193
1194 retv = 0;
1195 }
1196 @@ -4090,46 +4090,60 @@ ieee80211_ioctl_getchanlist(struct net_d
1197 return 0;
1198 }
1199
1200 +static int alreadyListed(struct ieee80211req_chaninfo *chans, u_int16_t mhz)
1201 +{
1202 + int i;
1203 + for (i = 0; i < chans->ic_nchans; i++) {
1204 + if (chans->ic_chans[i].ic_freq == mhz)
1205 + return 1;
1206 + }
1207 + return 0;
1208 +}
1209 +
1210 static int
1211 ieee80211_ioctl_getchaninfo(struct net_device *dev,
1212 - struct iw_request_info *info, void *w, char *extra)
1213 + struct iw_request_info *info, void *w, char *extra)
1214 {
1215 struct ieee80211vap *vap = dev->priv;
1216 struct ieee80211com *ic = vap->iv_ic;
1217 - struct ieee80211req_chaninfo chans;
1218 + struct ieee80211req_chaninfo *chans =
1219 + (struct ieee80211req_chaninfo *)extra;
1220 +
1221 u_int8_t reported[IEEE80211_CHAN_BYTES]; /* XXX stack usage? */
1222 int i;
1223
1224 - memset(&chans, 0, sizeof(chans));
1225 - memset(&reported, 0, sizeof(reported));
1226 + memset(chans, 0, sizeof(*chans));
1227 + memset(reported, 0, sizeof(reported));
1228 for (i = 0; i < ic->ic_nchans; i++) {
1229 const struct ieee80211_channel *c = &ic->ic_channels[i];
1230 const struct ieee80211_channel *c1 = c;
1231
1232 - if (isclr(reported, c->ic_ieee)) {
1233 + if (!alreadyListed(chans, c->ic_freq)) {
1234 setbit(reported, c->ic_ieee);
1235
1236 - /* pick turbo channel over non-turbo channel, and
1237 - * 11g channel over 11b channel */
1238 if (IEEE80211_IS_CHAN_A(c))
1239 - c1 = findchannel(ic, c->ic_ieee, IEEE80211_MODE_TURBO_A);
1240 + c1 = findchannel(ic, c->ic_freq,
1241 + IEEE80211_MODE_TURBO_A);
1242 if (IEEE80211_IS_CHAN_ANYG(c))
1243 - c1 = findchannel(ic, c->ic_ieee, IEEE80211_MODE_TURBO_G);
1244 + c1 = findchannel(ic, c->ic_freq,
1245 + IEEE80211_MODE_TURBO_G);
1246 else if (IEEE80211_IS_CHAN_B(c)) {
1247 - c1 = findchannel(ic, c->ic_ieee, IEEE80211_MODE_TURBO_G);
1248 + c1 = findchannel(ic, c->ic_freq,
1249 + IEEE80211_MODE_TURBO_G);
1250 if (!c1)
1251 - c1 = findchannel(ic, c->ic_ieee, IEEE80211_MODE_11G);
1252 + c1 = findchannel(ic, c->ic_freq,
1253 + IEEE80211_MODE_11G);
1254 }
1255
1256 if (c1)
1257 c = c1;
1258 - /* Copy the entire structure, whereas it used to just copy a few fields */
1259 - memcpy(&chans.ic_chans[chans.ic_nchans], c, sizeof(struct ieee80211_channel));
1260 - if (++chans.ic_nchans >= IEEE80211_CHAN_MAX)
1261 + chans->ic_chans[chans->ic_nchans].ic_ieee = c->ic_ieee;
1262 + chans->ic_chans[chans->ic_nchans].ic_freq = c->ic_freq;
1263 + chans->ic_chans[chans->ic_nchans].ic_flags = c->ic_flags;
1264 + if (++chans->ic_nchans >= IEEE80211_CHAN_MAX)
1265 break;
1266 }
1267 }
1268 - memcpy(extra, &chans, sizeof(struct ieee80211req_chaninfo));
1269 return 0;
1270 }
1271
1272 --- a/net80211/ieee80211_scan_ap.c
1273 +++ b/net80211/ieee80211_scan_ap.c
1274 @@ -512,12 +512,13 @@ pick_channel(struct ieee80211_scan_state
1275 int ss_last = ss->ss_last;
1276 struct ieee80211_channel *best;
1277 struct ap_state *as = ss->ss_priv;
1278 - struct channel chans[ss_last]; /* actually ss_last-1 is required */
1279 + struct channel *chans; /* actually ss_last-1 is required */
1280 struct channel *c = NULL;
1281 struct pc_params params = { vap, ss, flags };
1282 int benefit = 0;
1283 int sta_assoc = 0;
1284
1285 + chans = (struct channel *)kmalloc(ss_last*sizeof(struct channel),GFP_ATOMIC);
1286 for (i = 0; i < ss_last; i++) {
1287 chans[i].chan = ss->ss_chans[i];
1288 chans[i].orig = i;
1289 @@ -571,6 +572,7 @@ pick_channel(struct ieee80211_scan_state
1290 "%s: best: channel %u rssi %d\n",
1291 __func__, i, as->as_maxrssi[i]);
1292 }
1293 + kfree(chans);
1294 return best;
1295 }
1296
1297 @@ -609,6 +611,7 @@ ap_end(struct ieee80211_scan_state *ss,
1298 res = 1; /* Do NOT restart scan */
1299 } else {
1300 struct ieee80211_scan_entry se;
1301 + int i;
1302 /* XXX: notify all VAPs? */
1303 /* if this is a dynamic turbo frequency , start with normal
1304 * mode first */
1305 @@ -623,6 +626,11 @@ ap_end(struct ieee80211_scan_state *ss,
1306 return 0;
1307 }
1308 }
1309 + for (i = (bestchan - &ic->ic_channels[0])/sizeof(*bestchan) + 1; i < ic->ic_nchans; i++) {
1310 + if ((ic->ic_channels[i].ic_freq == bestchan->ic_freq) &&
1311 + IEEE80211_IS_CHAN_ANYG(&ic->ic_channels[i]))
1312 + bestchan = &ic->ic_channels[i];
1313 + }
1314 memset(&se, 0, sizeof(se));
1315 se.se_chan = bestchan;
1316
1317 --- a/tools/wlanconfig.c
1318 +++ b/tools/wlanconfig.c
1319 @@ -737,7 +737,7 @@ list_channels(const char *ifname, int al
1320 if (get80211priv(ifname, IEEE80211_IOCTL_GETCHANINFO, &chans, sizeof(chans)) < 0)
1321 errx(1, "unable to get channel information");
1322 if (!allchans) {
1323 - uint8_t active[32];
1324 + uint8_t active[IEEE80211_CHAN_BYTES];
1325
1326 if (get80211priv(ifname, IEEE80211_IOCTL_GETCHANLIST, &active, sizeof(active)) < 0)
1327 errx(1, "unable to get active channel list");
1328 --- a/net80211/ieee80211_scan.c
1329 +++ b/net80211/ieee80211_scan.c
1330 @@ -1044,6 +1044,7 @@ ieee80211_scan_assoc_fail(struct ieee802
1331 ss->ss_ops->scan_assoc_fail(ss, mac, reason);
1332 }
1333 }
1334 +EXPORT_SYMBOL(ieee80211_scan_flush);
1335
1336 /*
1337 * Iterate over the contents of the scan cache.
1338 --- a/ath/if_ath_hal_wrappers.h
1339 +++ b/ath/if_ath_hal_wrappers.h
1340 @@ -111,6 +111,11 @@ static inline HAL_BOOL ath_hal_getregdom
1341 return (ath_hal_getcapability(ah, HAL_CAP_REG_DMN, 0, destination) == HAL_OK);
1342 }
1343
1344 +static inline HAL_BOOL ath_hal_setregdomain(struct ath_hal *ah, u_int32_t v)
1345 +{
1346 + return (ath_hal_setcapability(ah, HAL_CAP_REG_DMN, 0, v, NULL));
1347 +}
1348 +
1349 static inline HAL_BOOL ath_hal_gettkipmic(struct ath_hal *ah)
1350 {
1351 return (ath_hal_getcapability(ah, HAL_CAP_TKIP_MIC, 1, NULL) == HAL_OK);