package/mac80211/patches/424-mac80211-make-retry-limits-available.patch

   1 ---
   2  drivers/net/wireless/ath9k/main.c       |    1
   3  drivers/net/wireless/b43/main.c         |   67 +++++++++++++-----------------
   4  drivers/net/wireless/b43legacy/main.c   |   70 ++++++++++++++------------------
   5  drivers/net/wireless/rt2x00/rt2400pci.c |    2
   6  drivers/net/wireless/rt2x00/rt2500pci.c |    2
   7  drivers/net/wireless/rt2x00/rt2x00.h    |    3 +
   8  drivers/net/wireless/rt2x00/rt2x00mac.c |    9 ++++
   9  drivers/net/wireless/rt2x00/rt61pci.c   |    2
  10  drivers/net/wireless/rt2x00/rt73usb.c   |    2
  11  include/net/mac80211.h                  |   14 ++++--
  12  net/mac80211/debugfs.c                  |    4 -
  13  net/mac80211/ieee80211_i.h              |    2
  14  net/mac80211/main.c                     |    4 -
  15  net/mac80211/tx.c                       |    4 -
  16  net/mac80211/wext.c                     |   28 +++++-------
  17  15 files changed, 106 insertions(+), 108 deletions(-)
  18
  19 --- everything.orig/include/net/mac80211.h      2008-10-10 23:27:46.000000000 +0200
  20 +++ everything/include/net/mac80211.h   2008-10-10 23:31:21.000000000 +0200
  21 @@ -473,6 +473,7 @@ static inline int __deprecated __IEEE802
  22   * @IEEE80211_CONF_CHANGE_PS: the PS flag changed
  23   * @IEEE80211_CONF_CHANGE_POWER: the TX power changed
  24   * @IEEE80211_CONF_CHANGE_CHANNEL: the channel changed
  25 + * @IEEE80211_CONF_CHANGE_RETRY_LIMITS: retry limits changed
  26   */
  27  enum ieee80211_conf_changed {
  28         IEEE80211_CONF_CHANGE_RADIO_ENABLED     = BIT(0),
  29 @@ -482,6 +483,7 @@ enum ieee80211_conf_changed {
  30         IEEE80211_CONF_CHANGE_PS                = BIT(4),
  31         IEEE80211_CONF_CHANGE_POWER             = BIT(5),
  32         IEEE80211_CONF_CHANGE_CHANNEL           = BIT(6),
  33 +       IEEE80211_CONF_CHANGE_RETRY_LIMITS      = BIT(7),
  34  };
  35
  36  /**
  37 @@ -497,6 +499,12 @@ enum ieee80211_conf_changed {
  38   * @ht_cap: describes current self configuration of 802.11n HT capabilities
  39   * @ht_bss_conf: describes current BSS configuration of 802.11n HT parameters
  40   * @channel: the channel to tune to
  41 + * @long_frame_max_tx_count: Maximum number of transmissions for a "long" frame
  42 + *     (a frame not RTS protected), called "dot11LongRetryLimit" in 802.11,
  43 + *     but actually means the number of transmissions not the number of retries
  44 + * @short_frame_max_tx_count: Maximum number of transmissions for a "short" frame,
  45 + *     called "dot11ShortRetryLimit" in 802.11, but actually means the number
  46 + *     of transmissions not the number of retries
  47   */
  48  struct ieee80211_conf {
  49         int beacon_int;
  50 @@ -506,6 +514,8 @@ struct ieee80211_conf {
  51         u16 listen_interval;
  52         bool radio_enabled;
  53
  54 +       u8 long_frame_max_tx_count, short_frame_max_tx_count;
  55 +
  56         struct ieee80211_channel *channel;
  57
  58         struct ieee80211_sta_ht_cap ht_cap;
  59 @@ -1192,8 +1202,6 @@ enum ieee80211_ampdu_mlme_action {
  60   *     the device does fragmentation by itself; if this method is assigned then
  61   *     the stack will not do fragmentation.
  62   *
  63 - * @set_retry_limit: Configuration of retry limits (if device needs it)
  64 - *
  65   * @sta_notify: Notifies low level driver about addition or removal
  66   *     of assocaited station or AP.
  67   *
  68 @@ -1263,8 +1271,6 @@ struct ieee80211_ops {
  69                              u32 *iv32, u16 *iv16);
  70         int (*set_rts_threshold)(struct ieee80211_hw *hw, u32 value);
  71         int (*set_frag_threshold)(struct ieee80211_hw *hw, u32 value);
  72 -       int (*set_retry_limit)(struct ieee80211_hw *hw,
  73 -                              u32 short_retry, u32 long_retr);
  74         void (*sta_notify)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
  75                         enum sta_notify_cmd, struct ieee80211_sta *sta);
  76         int (*conf_tx)(struct ieee80211_hw *hw, u16 queue,
  77 --- everything.orig/net/mac80211/ieee80211_i.h  2008-10-10 23:27:46.000000000 +0200
  78 +++ everything/net/mac80211/ieee80211_i.h       2008-10-10 23:31:22.000000000 +0200
  79 @@ -632,8 +632,6 @@ struct ieee80211_local {
  80
  81         int rts_threshold;
  82         int fragmentation_threshold;
  83 -       int short_retry_limit; /* dot11ShortRetryLimit */
  84 -       int long_retry_limit; /* dot11LongRetryLimit */
  85
  86         struct crypto_blkcipher *wep_tx_tfm;
  87         struct crypto_blkcipher *wep_rx_tfm;
  88 --- everything.orig/net/mac80211/main.c 2008-10-10 23:27:46.000000000 +0200
  89 +++ everything/net/mac80211/main.c      2008-10-10 23:31:22.000000000 +0200
  90 @@ -673,8 +673,8 @@ struct ieee80211_hw *ieee80211_alloc_hw(
  91
  92         local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
  93         local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
  94 -       local->short_retry_limit = 7;
  95 -       local->long_retry_limit = 4;
  96 +       local->hw.conf.long_frame_max_tx_count = 4;
  97 +       local->hw.conf.short_frame_max_tx_count = 7;
  98         local->hw.conf.radio_enabled = true;
  99
 100         INIT_LIST_HEAD(&local->interfaces);
 101 --- everything.orig/net/mac80211/wext.c 2008-10-10 23:27:46.000000000 +0200
 102 +++ everything/net/mac80211/wext.c      2008-10-10 23:31:22.000000000 +0200
 103 @@ -802,21 +802,16 @@ static int ieee80211_ioctl_siwretry(stru
 104             (retry->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT)
 105                 return -EINVAL;
 106
 107 -       if (retry->flags & IW_RETRY_MAX)
 108 -               local->long_retry_limit = retry->value;
 109 -       else if (retry->flags & IW_RETRY_MIN)
 110 -               local->short_retry_limit = retry->value;
 111 -       else {
 112 -               local->long_retry_limit = retry->value;
 113 -               local->short_retry_limit = retry->value;
 114 +       if (retry->flags & IW_RETRY_MAX) {
 115 +               local->hw.conf.long_frame_max_tx_count = retry->value;
 116 +       } else if (retry->flags & IW_RETRY_MIN) {
 117 +               local->hw.conf.short_frame_max_tx_count = retry->value;
 118 +       } else {
 119 +               local->hw.conf.long_frame_max_tx_count = retry->value;
 120 +               local->hw.conf.short_frame_max_tx_count = retry->value;
 121         }
 122
 123 -       if (local->ops->set_retry_limit) {
 124 -               return local->ops->set_retry_limit(
 125 -                       local_to_hw(local),
 126 -                       local->short_retry_limit,
 127 -                       local->long_retry_limit);
 128 -       }
 129 +       ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS);
 130
 131         return 0;
 132  }
 133 @@ -833,14 +828,15 @@ static int ieee80211_ioctl_giwretry(stru
 134                 /* first return min value, iwconfig will ask max value
 135                  * later if needed */
 136                 retry->flags |= IW_RETRY_LIMIT;
 137 -               retry->value = local->short_retry_limit;
 138 -               if (local->long_retry_limit != local->short_retry_limit)
 139 +               retry->value = local->hw.conf.short_frame_max_tx_count;
 140 +               if (local->hw.conf.long_frame_max_tx_count !=
 141 +                   local->hw.conf.short_frame_max_tx_count)
 142                         retry->flags |= IW_RETRY_MIN;
 143                 return 0;
 144         }
 145         if (retry->flags & IW_RETRY_MAX) {
 146                 retry->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
 147 -               retry->value = local->long_retry_limit;
 148 +               retry->value = local->hw.conf.long_frame_max_tx_count;
 149         }
 150
 151         return 0;
 152 --- everything.orig/drivers/net/wireless/ath9k/main.c   2008-10-10 23:27:47.000000000 +0200
 153 +++ everything/drivers/net/wireless/ath9k/main.c        2008-10-10 23:31:23.000000000 +0200
 154 @@ -1657,7 +1657,6 @@ static struct ieee80211_ops ath9k_ops =
 155         .get_tkip_seq       = NULL,
 156         .set_rts_threshold  = NULL,
 157         .set_frag_threshold = NULL,
 158 -       .set_retry_limit    = NULL,
 159         .get_tsf            = ath9k_get_tsf,
 160         .reset_tsf          = ath9k_reset_tsf,
 161         .tx_last_beacon     = NULL,
 162 --- everything.orig/drivers/net/wireless/b43/main.c     2008-10-10 23:27:47.000000000 +0200
 163 +++ everything/drivers/net/wireless/b43/main.c  2008-10-10 23:31:23.000000000 +0200
 164 @@ -3320,6 +3320,22 @@ init_failure:
 165         return err;
 166  }
 167
 168 +/* Write the short and long frame retry limit values. */
 169 +static void b43_set_retry_limits(struct b43_wldev *dev,
 170 +                                unsigned int short_retry,
 171 +                                unsigned int long_retry)
 172 +{
 173 +       /* The retry limit is a 4-bit counter. Enforce this to avoid overflowing
 174 +        * the chip-internal counter. */
 175 +       short_retry = min(short_retry, (unsigned int)0xF);
 176 +       long_retry = min(long_retry, (unsigned int)0xF);
 177 +
 178 +       b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_SRLIMIT,
 179 +                       short_retry);
 180 +       b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_LRLIMIT,
 181 +                       long_retry);
 182 +}
 183 +
 184  static int b43_op_config(struct ieee80211_hw *hw, u32 changed)
 185  {
 186         struct b43_wl *wl = hw_to_b43_wl(hw);
 187 @@ -3333,6 +3349,20 @@ static int b43_op_config(struct ieee8021
 188
 189         mutex_lock(&wl->mutex);
 190
 191 +       if (changed & IEEE80211_CONF_CHANGE_RETRY_LIMITS) {
 192 +               dev = wl->current_dev;
 193 +               if (unlikely(!dev || (b43_status(dev) < B43_STAT_INITIALIZED))) {
 194 +                       err = -ENODEV;
 195 +                       goto out_unlock_mutex;
 196 +               }
 197 +               b43_set_retry_limits(dev, conf->short_frame_max_tx_count,
 198 +                                         conf->long_frame_max_tx_count);
 199 +               changed &= ~IEEE80211_CONF_CHANGE_RETRY_LIMITS;
 200 +       }
 201 +
 202 +       if (!changed)
 203 +               goto out_unlock_mutex;
 204 +
 205         /* Switch the band (if necessary). This might change the active core. */
 206         err = b43_switch_band(wl, conf->channel);
 207         if (err)
 208 @@ -3860,22 +3890,6 @@ static void b43_imcfglo_timeouts_workaro
 209  #endif /* CONFIG_SSB_DRIVER_PCICORE */
 210  }
 211
 212 -/* Write the short and long frame retry limit values. */
 213 -static void b43_set_retry_limits(struct b43_wldev *dev,
 214 -                                unsigned int short_retry,
 215 -                                unsigned int long_retry)
 216 -{
 217 -       /* The retry limit is a 4-bit counter. Enforce this to avoid overflowing
 218 -        * the chip-internal counter. */
 219 -       short_retry = min(short_retry, (unsigned int)0xF);
 220 -       long_retry = min(long_retry, (unsigned int)0xF);
 221 -
 222 -       b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_SRLIMIT,
 223 -                       short_retry);
 224 -       b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_LRLIMIT,
 225 -                       long_retry);
 226 -}
 227 -
 228  static void b43_set_synth_pu_delay(struct b43_wldev *dev, bool idle)
 229  {
 230         u16 pu_delay;
 231 @@ -4196,26 +4210,6 @@ static void b43_op_stop(struct ieee80211
 232         cancel_work_sync(&(wl->txpower_adjust_work));
 233  }
 234
 235 -static int b43_op_set_retry_limit(struct ieee80211_hw *hw,
 236 -                                 u32 short_retry_limit, u32 long_retry_limit)
 237 -{
 238 -       struct b43_wl *wl = hw_to_b43_wl(hw);
 239 -       struct b43_wldev *dev;
 240 -       int err = 0;
 241 -
 242 -       mutex_lock(&wl->mutex);
 243 -       dev = wl->current_dev;
 244 -       if (unlikely(!dev || (b43_status(dev) < B43_STAT_INITIALIZED))) {
 245 -               err = -ENODEV;
 246 -               goto out_unlock;
 247 -       }
 248 -       b43_set_retry_limits(dev, short_retry_limit, long_retry_limit);
 249 -out_unlock:
 250 -       mutex_unlock(&wl->mutex);
 251 -
 252 -       return err;
 253 -}
 254 -
 255  static int b43_op_beacon_set_tim(struct ieee80211_hw *hw,
 256                                  struct ieee80211_sta *sta, bool set)
 257  {
 258 @@ -4252,7 +4246,6 @@ static const struct ieee80211_ops b43_hw
 259         .get_tx_stats           = b43_op_get_tx_stats,
 260         .start                  = b43_op_start,
 261         .stop                   = b43_op_stop,
 262 -       .set_retry_limit        = b43_op_set_retry_limit,
 263         .set_tim                = b43_op_beacon_set_tim,
 264         .sta_notify             = b43_op_sta_notify,
 265  };
 266 --- everything.orig/drivers/net/wireless/b43legacy/main.c       2008-10-10 23:27:47.000000000 +0200
 267 +++ everything/drivers/net/wireless/b43legacy/main.c    2008-10-10 23:31:23.000000000 +0200
 268 @@ -2556,6 +2556,20 @@ init_failure:
 269         return err;
 270  }
 271
 272 +/* Write the short and long frame retry limit values. */
 273 +static void b43legacy_set_retry_limits(struct b43legacy_wldev *dev,
 274 +                                      unsigned int short_retry,
 275 +                                      unsigned int long_retry)
 276 +{
 277 +       /* The retry limit is a 4-bit counter. Enforce this to avoid overflowing
 278 +        * the chip-internal counter. */
 279 +       short_retry = min(short_retry, (unsigned int)0xF);
 280 +       long_retry = min(long_retry, (unsigned int)0xF);
 281 +
 282 +       b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS, 0x0006, short_retry);
 283 +       b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS, 0x0007, long_retry);
 284 +}
 285 +
 286  static int b43legacy_op_dev_config(struct ieee80211_hw *hw,
 287                                    u32 changed)
 288  {
 289 @@ -2570,10 +2584,27 @@ static int b43legacy_op_dev_config(struc
 290         int err = 0;
 291         u32 savedirqs;
 292
 293 +       mutex_lock(&wl->mutex);
 294 +       dev = wl->current_dev;
 295 +
 296 +       if (changed & IEEE80211_CONF_CHANGE_RETRY_LIMITS) {
 297 +               if (unlikely(!dev ||
 298 +                            (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED))) {
 299 +                       err = -ENODEV;
 300 +                       goto out_unlock_mutex;
 301 +               }
 302 +               b43legacy_set_retry_limits(dev,
 303 +                                          conf->short_frame_max_tx_count,
 304 +                                          conf->long_frame_max_tx_count);
 305 +               changed &= ~IEEE80211_CONF_CHANGE_RETRY_LIMITS;
 306 +       }
 307 +
 308 +       if (!changed)
 309 +               goto out_unlock_mutex;
 310 +
 311         antenna_tx = B43legacy_ANTENNA_DEFAULT;
 312         antenna_rx = B43legacy_ANTENNA_DEFAULT;
 313
 314 -       mutex_lock(&wl->mutex);
 315         dev = wl->current_dev;
 316         phy = &dev->phy;
 317
 318 @@ -2989,20 +3020,6 @@ static void b43legacy_imcfglo_timeouts_w
 319  #endif /* CONFIG_SSB_DRIVER_PCICORE */
 320  }
 321
 322 -/* Write the short and long frame retry limit values. */
 323 -static void b43legacy_set_retry_limits(struct b43legacy_wldev *dev,
 324 -                                      unsigned int short_retry,
 325 -                                      unsigned int long_retry)
 326 -{
 327 -       /* The retry limit is a 4-bit counter. Enforce this to avoid overflowing
 328 -        * the chip-internal counter. */
 329 -       short_retry = min(short_retry, (unsigned int)0xF);
 330 -       long_retry = min(long_retry, (unsigned int)0xF);
 331 -
 332 -       b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS, 0x0006, short_retry);
 333 -       b43legacy_shm_write16(dev, B43legacy_SHM_WIRELESS, 0x0007, long_retry);
 334 -}
 335 -
 336  static void b43legacy_set_synth_pu_delay(struct b43legacy_wldev *dev,
 337                                           bool idle) {
 338         u16 pu_delay = 1050;
 339 @@ -3367,28 +3384,6 @@ static void b43legacy_op_stop(struct iee
 340         mutex_unlock(&wl->mutex);
 341  }
 342
 343 -static int b43legacy_op_set_retry_limit(struct ieee80211_hw *hw,
 344 -                                       u32 short_retry_limit,
 345 -                                       u32 long_retry_limit)
 346 -{
 347 -       struct b43legacy_wl *wl = hw_to_b43legacy_wl(hw);
 348 -       struct b43legacy_wldev *dev;
 349 -       int err = 0;
 350 -
 351 -       mutex_lock(&wl->mutex);
 352 -       dev = wl->current_dev;
 353 -       if (unlikely(!dev ||
 354 -                    (b43legacy_status(dev) < B43legacy_STAT_INITIALIZED))) {
 355 -               err = -ENODEV;
 356 -               goto out_unlock;
 357 -       }
 358 -       b43legacy_set_retry_limits(dev, short_retry_limit, long_retry_limit);
 359 -out_unlock:
 360 -       mutex_unlock(&wl->mutex);
 361 -
 362 -       return err;
 363 -}
 364 -
 365  static int b43legacy_op_beacon_set_tim(struct ieee80211_hw *hw,
 366                                        struct ieee80211_sta *sta, bool set)
 367  {
 368 @@ -3414,7 +3409,6 @@ static const struct ieee80211_ops b43leg
 369         .get_tx_stats           = b43legacy_op_get_tx_stats,
 370         .start                  = b43legacy_op_start,
 371         .stop                   = b43legacy_op_stop,
 372 -       .set_retry_limit        = b43legacy_op_set_retry_limit,
 373         .set_tim                = b43legacy_op_beacon_set_tim,
 374  };
 375
 376 --- everything.orig/drivers/net/wireless/rt2x00/rt2400pci.c     2008-10-10 23:27:46.000000000 +0200
 377 +++ everything/drivers/net/wireless/rt2x00/rt2400pci.c  2008-10-10 23:27:48.000000000 +0200
 378 @@ -1576,7 +1576,6 @@ static const struct ieee80211_ops rt2400
 379         .config_interface       = rt2x00mac_config_interface,
 380         .configure_filter       = rt2x00mac_configure_filter,
 381         .get_stats              = rt2x00mac_get_stats,
 382 -       .set_retry_limit        = rt2400pci_set_retry_limit,
 383         .bss_info_changed       = rt2x00mac_bss_info_changed,
 384         .conf_tx                = rt2400pci_conf_tx,
 385         .get_tx_stats           = rt2x00mac_get_tx_stats,
 386 @@ -1605,6 +1604,7 @@ static const struct rt2x00lib_ops rt2400
 387         .config_intf            = rt2400pci_config_intf,
 388         .config_erp             = rt2400pci_config_erp,
 389         .config                 = rt2400pci_config,
 390 +       .set_retry_limit        = rt2400pci_set_retry_limit,
 391  };
 392
 393  static const struct data_queue_desc rt2400pci_queue_rx = {
 394 --- everything.orig/drivers/net/wireless/rt2x00/rt2x00.h        2008-10-10 23:27:47.000000000 +0200
 395 +++ everything/drivers/net/wireless/rt2x00/rt2x00.h     2008-10-10 23:27:48.000000000 +0200
 396 @@ -599,6 +599,9 @@ struct rt2x00lib_ops {
 397  #define CONFIG_UPDATE_SLOT_TIME        ( 1 << 5 )
 398  #define CONFIG_UPDATE_BEACON_INT       ( 1 << 6 )
 399  #define CONFIG_UPDATE_ALL              0xffff
 400 +
 401 +       int (*set_retry_limit) (struct ieee80211_hw *hw,
 402 +                               u32 short_limit, u32 long_limit);
 403  };
 404
 405  /*
 406 --- everything.orig/drivers/net/wireless/rt2x00/rt2500pci.c     2008-10-10 23:27:46.000000000 +0200
 407 +++ everything/drivers/net/wireless/rt2x00/rt2500pci.c  2008-10-10 23:27:48.000000000 +0200
 408 @@ -1877,7 +1877,6 @@ static const struct ieee80211_ops rt2500
 409         .config_interface       = rt2x00mac_config_interface,
 410         .configure_filter       = rt2x00mac_configure_filter,
 411         .get_stats              = rt2x00mac_get_stats,
 412 -       .set_retry_limit        = rt2500pci_set_retry_limit,
 413         .bss_info_changed       = rt2x00mac_bss_info_changed,
 414         .conf_tx                = rt2x00mac_conf_tx,
 415         .get_tx_stats           = rt2x00mac_get_tx_stats,
 416 @@ -1906,6 +1905,7 @@ static const struct rt2x00lib_ops rt2500
 417         .config_intf            = rt2500pci_config_intf,
 418         .config_erp             = rt2500pci_config_erp,
 419         .config                 = rt2500pci_config,
 420 +       .set_retry_limit        = rt2500pci_set_retry_limit,
 421  };
 422
 423  static const struct data_queue_desc rt2500pci_queue_rx = {
 424 --- everything.orig/drivers/net/wireless/rt2x00/rt61pci.c       2008-10-10 23:27:47.000000000 +0200
 425 +++ everything/drivers/net/wireless/rt2x00/rt61pci.c    2008-10-10 23:27:48.000000000 +0200
 426 @@ -2726,7 +2726,6 @@ static const struct ieee80211_ops rt61pc
 427         .configure_filter       = rt2x00mac_configure_filter,
 428         .set_key                = rt2x00mac_set_key,
 429         .get_stats              = rt2x00mac_get_stats,
 430 -       .set_retry_limit        = rt61pci_set_retry_limit,
 431         .bss_info_changed       = rt2x00mac_bss_info_changed,
 432         .conf_tx                = rt61pci_conf_tx,
 433         .get_tx_stats           = rt2x00mac_get_tx_stats,
 434 @@ -2759,6 +2758,7 @@ static const struct rt2x00lib_ops rt61pc
 435         .config_intf            = rt61pci_config_intf,
 436         .config_erp             = rt61pci_config_erp,
 437         .config                 = rt61pci_config,
 438 +       .set_retry_limit        = rt61pci_set_retry_limit,
 439  };
 440
 441  static const struct data_queue_desc rt61pci_queue_rx = {
 442 --- everything.orig/drivers/net/wireless/rt2x00/rt73usb.c       2008-10-10 23:27:47.000000000 +0200
 443 +++ everything/drivers/net/wireless/rt2x00/rt73usb.c    2008-10-10 23:27:48.000000000 +0200
 444 @@ -2317,7 +2317,6 @@ static const struct ieee80211_ops rt73us
 445         .configure_filter       = rt2x00mac_configure_filter,
 446         .set_key                = rt2x00mac_set_key,
 447         .get_stats              = rt2x00mac_get_stats,
 448 -       .set_retry_limit        = rt73usb_set_retry_limit,
 449         .bss_info_changed       = rt2x00mac_bss_info_changed,
 450         .conf_tx                = rt73usb_conf_tx,
 451         .get_tx_stats           = rt2x00mac_get_tx_stats,
 452 @@ -2349,6 +2348,7 @@ static const struct rt2x00lib_ops rt73us
 453         .config_intf            = rt73usb_config_intf,
 454         .config_erp             = rt73usb_config_erp,
 455         .config                 = rt73usb_config,
 456 +       .set_retry_limit        = rt73usb_set_retry_limit,
 457  };
 458
 459  static const struct data_queue_desc rt73usb_queue_rx = {
 460 --- everything.orig/drivers/net/wireless/rt2x00/rt2x00mac.c     2008-10-10 23:27:46.000000000 +0200
 461 +++ everything/drivers/net/wireless/rt2x00/rt2x00mac.c  2008-10-10 23:31:23.000000000 +0200
 462 @@ -349,6 +349,15 @@ int rt2x00mac_config(struct ieee80211_hw
 463         if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
 464                 return 0;
 465
 466 +       if (changed & IEEE80211_CONF_CHANGE_RETRY_LIMITS) {
 467 +               rt2x00dev->ops->lib->set_retry_limit(hw,
 468 +                       conf->short_frame_max_tx_count,
 469 +                       conf->long_frame_max_tx_count);
 470 +       }
 471 +       changed &= ~IEEE80211_CONF_CHANGE_RETRY_LIMITS;
 472 +       if (!changed)
 473 +               return 0;
 474 +
 475         /*
 476          * Only change device state when the radio is enabled. It does not
 477          * matter what parameters we have configured when the radio is disabled
 478 --- everything.orig/net/mac80211/debugfs.c      2008-10-10 23:27:46.000000000 +0200
 479 +++ everything/net/mac80211/debugfs.c   2008-10-10 23:27:48.000000000 +0200
 480 @@ -52,9 +52,9 @@ DEBUGFS_READONLY_FILE(rts_threshold, 20,
 481  DEBUGFS_READONLY_FILE(fragmentation_threshold, 20, "%d",
 482                       local->fragmentation_threshold);
 483  DEBUGFS_READONLY_FILE(short_retry_limit, 20, "%d",
 484 -                     local->short_retry_limit);
 485 +                     local->hw.conf.short_frame_max_tx_count);
 486  DEBUGFS_READONLY_FILE(long_retry_limit, 20, "%d",
 487 -                     local->long_retry_limit);
 488 +                     local->hw.conf.long_frame_max_tx_count);
 489  DEBUGFS_READONLY_FILE(total_ps_buffered, 20, "%d",
 490                       local->total_ps_buffered);
 491  DEBUGFS_READONLY_FILE(wep_iv, 20, "%#06x",
 492 --- everything.orig/net/mac80211/tx.c   2008-10-10 23:27:46.000000000 +0200
 493 +++ everything/net/mac80211/tx.c        2008-10-10 23:31:22.000000000 +0200
 494 @@ -507,10 +507,10 @@ ieee80211_tx_h_misc(struct ieee80211_tx_
 495                                 info->flags |=
 496                                         IEEE80211_TX_CTL_LONG_RETRY_LIMIT;
 497                                 info->control.retry_limit =
 498 -                                       tx->local->long_retry_limit;
 499 +                                       tx->local->hw.conf.long_frame_max_tx_count - 1;
 500                         } else {
 501                                 info->control.retry_limit =
 502 -                                       tx->local->short_retry_limit;
 503 +                                       tx->local->hw.conf.short_frame_max_tx_count - 1;
 504                         }
 505                 } else {
 506                         info->control.retry_limit = 1;