err.no Git - linux-2.6/blob - drivers/net/wireless/rt2x00/rt2x00dev.c

   1 /*
   2         Copyright (C) 2004 - 2007 rt2x00 SourceForge Project
   3         <http://rt2x00.serialmonkey.com>
   4
   5         This program is free software; you can redistribute it and/or modify
   6         it under the terms of the GNU General Public License as published by
   7         the Free Software Foundation; either version 2 of the License, or
   8         (at your option) any later version.
   9
  10         This program is distributed in the hope that it will be useful,
  11         but WITHOUT ANY WARRANTY; without even the implied warranty of
  12         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13         GNU General Public License for more details.
  14
  15         You should have received a copy of the GNU General Public License
  16         along with this program; if not, write to the
  17         Free Software Foundation, Inc.,
  18         59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 /*
  22         Module: rt2x00lib
  23         Abstract: rt2x00 generic device routines.
  24  */
  25
  26 #include <linux/kernel.h>
  27 #include <linux/module.h>
  28
  29 #include "rt2x00.h"
  30 #include "rt2x00lib.h"
  31 #include "rt2x00dump.h"
  32
  33 /*
  34  * Ring handler.
  35  */
  36 struct data_ring *rt2x00lib_get_ring(struct rt2x00_dev *rt2x00dev,
  37                                      const unsigned int queue)
  38 {
  39         int beacon = test_bit(DRIVER_REQUIRE_BEACON_RING, &rt2x00dev->flags);
  40
  41         /*
  42          * Check if we are requesting a reqular TX ring,
  43          * or if we are requesting a Beacon or Atim ring.
  44          * For Atim rings, we should check if it is supported.
  45          */
  46         if (queue < rt2x00dev->hw->queues && rt2x00dev->tx)
  47                 return &rt2x00dev->tx[queue];
  48
  49         if (!rt2x00dev->bcn || !beacon)
  50                 return NULL;
  51
  52         if (queue == IEEE80211_TX_QUEUE_BEACON)
  53                 return &rt2x00dev->bcn[0];
  54         else if (queue == IEEE80211_TX_QUEUE_AFTER_BEACON)
  55                 return &rt2x00dev->bcn[1];
  56
  57         return NULL;
  58 }
  59 EXPORT_SYMBOL_GPL(rt2x00lib_get_ring);
  60
  61 /*
  62  * Link tuning handlers
  63  */
  64 void rt2x00lib_reset_link_tuner(struct rt2x00_dev *rt2x00dev)
  65 {
  66         if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
  67                 return;
  68
  69         /*
  70          * Reset link information.
  71          * Both the currently active vgc level as well as
  72          * the link tuner counter should be reset. Resetting
  73          * the counter is important for devices where the
  74          * device should only perform link tuning during the
  75          * first minute after being enabled.
  76          */
  77         rt2x00dev->link.count = 0;
  78         rt2x00dev->link.vgc_level = 0;
  79
  80         /*
  81          * Reset the link tuner.
  82          */
  83         rt2x00dev->ops->lib->reset_tuner(rt2x00dev);
  84 }
  85
  86 static void rt2x00lib_start_link_tuner(struct rt2x00_dev *rt2x00dev)
  87 {
  88         /*
  89          * Clear all (possibly) pre-existing quality statistics.
  90          */
  91         memset(&rt2x00dev->link.qual, 0, sizeof(rt2x00dev->link.qual));
  92
  93         /*
  94          * The RX and TX percentage should start at 50%
  95          * this will assure we will get at least get some
  96          * decent value when the link tuner starts.
  97          * The value will be dropped and overwritten with
  98          * the correct (measured )value anyway during the
  99          * first run of the link tuner.
 100          */
 101         rt2x00dev->link.qual.rx_percentage = 50;
 102         rt2x00dev->link.qual.tx_percentage = 50;
 103
 104         rt2x00lib_reset_link_tuner(rt2x00dev);
 105
 106         queue_delayed_work(rt2x00dev->hw->workqueue,
 107                            &rt2x00dev->link.work, LINK_TUNE_INTERVAL);
 108 }
 109
 110 static void rt2x00lib_stop_link_tuner(struct rt2x00_dev *rt2x00dev)
 111 {
 112         cancel_delayed_work_sync(&rt2x00dev->link.work);
 113 }
 114
 115 /*
 116  * Ring initialization
 117  */
 118 static void rt2x00lib_init_rxrings(struct rt2x00_dev *rt2x00dev)
 119 {
 120         struct data_ring *ring = rt2x00dev->rx;
 121         unsigned int i;
 122
 123         if (!rt2x00dev->ops->lib->init_rxentry)
 124                 return;
 125
 126         if (ring->data_addr)
 127                 memset(ring->data_addr, 0, rt2x00_get_ring_size(ring));
 128
 129         for (i = 0; i < ring->stats.limit; i++)
 130                 rt2x00dev->ops->lib->init_rxentry(rt2x00dev, &ring->entry[i]);
 131
 132         rt2x00_ring_index_clear(ring);
 133 }
 134
 135 static void rt2x00lib_init_txrings(struct rt2x00_dev *rt2x00dev)
 136 {
 137         struct data_ring *ring;
 138         unsigned int i;
 139
 140         if (!rt2x00dev->ops->lib->init_txentry)
 141                 return;
 142
 143         txringall_for_each(rt2x00dev, ring) {
 144                 if (ring->data_addr)
 145                         memset(ring->data_addr, 0, rt2x00_get_ring_size(ring));
 146
 147                 for (i = 0; i < ring->stats.limit; i++)
 148                         rt2x00dev->ops->lib->init_txentry(rt2x00dev,
 149                                                           &ring->entry[i]);
 150
 151                 rt2x00_ring_index_clear(ring);
 152         }
 153 }
 154
 155 /*
 156  * Radio control handlers.
 157  */
 158 int rt2x00lib_enable_radio(struct rt2x00_dev *rt2x00dev)
 159 {
 160         int status;
 161
 162         /*
 163          * Don't enable the radio twice.
 164          * And check if the hardware button has been disabled.
 165          */
 166         if (test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) ||
 167             test_bit(DEVICE_DISABLED_RADIO_HW, &rt2x00dev->flags))
 168                 return 0;
 169
 170         /*
 171          * Initialize all data rings.
 172          */
 173         rt2x00lib_init_rxrings(rt2x00dev);
 174         rt2x00lib_init_txrings(rt2x00dev);
 175
 176         /*
 177          * Enable radio.
 178          */
 179         status = rt2x00dev->ops->lib->set_device_state(rt2x00dev,
 180                                                        STATE_RADIO_ON);
 181         if (status)
 182                 return status;
 183
 184         __set_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags);
 185
 186         /*
 187          * Enable RX.
 188          */
 189         rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_ON);
 190
 191         /*
 192          * Start the TX queues.
 193          */
 194         ieee80211_start_queues(rt2x00dev->hw);
 195
 196         return 0;
 197 }
 198
 199 void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
 200 {
 201         if (!__test_and_clear_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
 202                 return;
 203
 204         /*
 205          * Stop all scheduled work.
 206          */
 207         if (work_pending(&rt2x00dev->beacon_work))
 208                 cancel_work_sync(&rt2x00dev->beacon_work);
 209         if (work_pending(&rt2x00dev->filter_work))
 210                 cancel_work_sync(&rt2x00dev->filter_work);
 211         if (work_pending(&rt2x00dev->config_work))
 212                 cancel_work_sync(&rt2x00dev->config_work);
 213
 214         /*
 215          * Stop the TX queues.
 216          */
 217         ieee80211_stop_queues(rt2x00dev->hw);
 218
 219         /*
 220          * Disable RX.
 221          */
 222         rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_OFF);
 223
 224         /*
 225          * Disable radio.
 226          */
 227         rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF);
 228 }
 229
 230 void rt2x00lib_toggle_rx(struct rt2x00_dev *rt2x00dev, enum dev_state state)
 231 {
 232         /*
 233          * When we are disabling the RX, we should also stop the link tuner.
 234          */
 235         if (state == STATE_RADIO_RX_OFF)
 236                 rt2x00lib_stop_link_tuner(rt2x00dev);
 237
 238         rt2x00dev->ops->lib->set_device_state(rt2x00dev, state);
 239
 240         /*
 241          * When we are enabling the RX, we should also start the link tuner.
 242          */
 243         if (state == STATE_RADIO_RX_ON &&
 244             is_interface_present(&rt2x00dev->interface))
 245                 rt2x00lib_start_link_tuner(rt2x00dev);
 246 }
 247
 248 static void rt2x00lib_evaluate_antenna_sample(struct rt2x00_dev *rt2x00dev)
 249 {
 250         enum antenna rx = rt2x00dev->link.ant.active.rx;
 251         enum antenna tx = rt2x00dev->link.ant.active.tx;
 252         int sample_a =
 253             rt2x00_get_link_ant_rssi_history(&rt2x00dev->link, ANTENNA_A);
 254         int sample_b =
 255             rt2x00_get_link_ant_rssi_history(&rt2x00dev->link, ANTENNA_B);
 256
 257         /*
 258          * We are done sampling. Now we should evaluate the results.
 259          */
 260         rt2x00dev->link.ant.flags &= ~ANTENNA_MODE_SAMPLE;
 261
 262         /*
 263          * During the last period we have sampled the RSSI
 264          * from both antenna's. It now is time to determine
 265          * which antenna demonstrated the best performance.
 266          * When we are already on the antenna with the best
 267          * performance, then there really is nothing for us
 268          * left to do.
 269          */
 270         if (sample_a == sample_b)
 271                 return;
 272
 273         if (rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY)
 274                 rx = (sample_a > sample_b) ? ANTENNA_A : ANTENNA_B;
 275
 276         if (rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)
 277                 tx = (sample_a > sample_b) ? ANTENNA_A : ANTENNA_B;
 278
 279         rt2x00lib_config_antenna(rt2x00dev, rx, tx);
 280 }
 281
 282 static void rt2x00lib_evaluate_antenna_eval(struct rt2x00_dev *rt2x00dev)
 283 {
 284         enum antenna rx = rt2x00dev->link.ant.active.rx;
 285         enum antenna tx = rt2x00dev->link.ant.active.tx;
 286         int rssi_curr = rt2x00_get_link_ant_rssi(&rt2x00dev->link);
 287         int rssi_old = rt2x00_update_ant_rssi(&rt2x00dev->link, rssi_curr);
 288
 289         /*
 290          * Legacy driver indicates that we should swap antenna's
 291          * when the difference in RSSI is greater that 5. This
 292          * also should be done when the RSSI was actually better
 293          * then the previous sample.
 294          * When the difference exceeds the threshold we should
 295          * sample the rssi from the other antenna to make a valid
 296          * comparison between the 2 antennas.
 297          */
 298         if (abs(rssi_curr - rssi_old) < 5)
 299                 return;
 300
 301         rt2x00dev->link.ant.flags |= ANTENNA_MODE_SAMPLE;
 302
 303         if (rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY)
 304                 rx = (rx == ANTENNA_A) ? ANTENNA_B : ANTENNA_A;
 305
 306         if (rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)
 307                 tx = (tx == ANTENNA_A) ? ANTENNA_B : ANTENNA_A;
 308
 309         rt2x00lib_config_antenna(rt2x00dev, rx, tx);
 310 }
 311
 312 static void rt2x00lib_evaluate_antenna(struct rt2x00_dev *rt2x00dev)
 313 {
 314         /*
 315          * Determine if software diversity is enabled for
 316          * either the TX or RX antenna (or both).
 317          * Always perform this check since within the link
 318          * tuner interval the configuration might have changed.
 319          */
 320         rt2x00dev->link.ant.flags &= ~ANTENNA_RX_DIVERSITY;
 321         rt2x00dev->link.ant.flags &= ~ANTENNA_TX_DIVERSITY;
 322
 323         if (rt2x00dev->hw->conf.antenna_sel_rx == 0 &&
 324             rt2x00dev->default_ant.rx == ANTENNA_SW_DIVERSITY)
 325                 rt2x00dev->link.ant.flags |= ANTENNA_RX_DIVERSITY;
 326         if (rt2x00dev->hw->conf.antenna_sel_tx == 0 &&
 327             rt2x00dev->default_ant.tx == ANTENNA_SW_DIVERSITY)
 328                 rt2x00dev->link.ant.flags |= ANTENNA_TX_DIVERSITY;
 329
 330         if (!(rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY) &&
 331             !(rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)) {
 332                 rt2x00dev->link.ant.flags = 0;
 333                 return;
 334         }
 335
 336         /*
 337          * If we have only sampled the data over the last period
 338          * we should now harvest the data. Otherwise just evaluate
 339          * the data. The latter should only be performed once
 340          * every 2 seconds.
 341          */
 342         if (rt2x00dev->link.ant.flags & ANTENNA_MODE_SAMPLE)
 343                 rt2x00lib_evaluate_antenna_sample(rt2x00dev);
 344         else if (rt2x00dev->link.count & 1)
 345                 rt2x00lib_evaluate_antenna_eval(rt2x00dev);
 346 }
 347
 348 static void rt2x00lib_update_link_stats(struct link *link, int rssi)
 349 {
 350         int avg_rssi = rssi;
 351
 352         /*
 353          * Update global RSSI
 354          */
 355         if (link->qual.avg_rssi)
 356                 avg_rssi = MOVING_AVERAGE(link->qual.avg_rssi, rssi, 8);
 357         link->qual.avg_rssi = avg_rssi;
 358
 359         /*
 360          * Update antenna RSSI
 361          */
 362         if (link->ant.rssi_ant)
 363                 rssi = MOVING_AVERAGE(link->ant.rssi_ant, rssi, 8);
 364         link->ant.rssi_ant = rssi;
 365 }
 366
 367 static void rt2x00lib_precalculate_link_signal(struct link_qual *qual)
 368 {
 369         if (qual->rx_failed || qual->rx_success)
 370                 qual->rx_percentage =
 371                     (qual->rx_success * 100) /
 372                     (qual->rx_failed + qual->rx_success);
 373         else
 374                 qual->rx_percentage = 50;
 375
 376         if (qual->tx_failed || qual->tx_success)
 377                 qual->tx_percentage =
 378                     (qual->tx_success * 100) /
 379                     (qual->tx_failed + qual->tx_success);
 380         else
 381                 qual->tx_percentage = 50;
 382
 383         qual->rx_success = 0;
 384         qual->rx_failed = 0;
 385         qual->tx_success = 0;
 386         qual->tx_failed = 0;
 387 }
 388
 389 static int rt2x00lib_calculate_link_signal(struct rt2x00_dev *rt2x00dev,
 390                                            int rssi)
 391 {
 392         int rssi_percentage = 0;
 393         int signal;
 394
 395         /*
 396          * We need a positive value for the RSSI.
 397          */
 398         if (rssi < 0)
 399                 rssi += rt2x00dev->rssi_offset;
 400
 401         /*
 402          * Calculate the different percentages,
 403          * which will be used for the signal.
 404          */
 405         if (rt2x00dev->rssi_offset)
 406                 rssi_percentage = (rssi * 100) / rt2x00dev->rssi_offset;
 407
 408         /*
 409          * Add the individual percentages and use the WEIGHT
 410          * defines to calculate the current link signal.
 411          */
 412         signal = ((WEIGHT_RSSI * rssi_percentage) +
 413                   (WEIGHT_TX * rt2x00dev->link.qual.tx_percentage) +
 414                   (WEIGHT_RX * rt2x00dev->link.qual.rx_percentage)) / 100;
 415
 416         return (signal > 100) ? 100 : signal;
 417 }
 418
 419 static void rt2x00lib_link_tuner(struct work_struct *work)
 420 {
 421         struct rt2x00_dev *rt2x00dev =
 422             container_of(work, struct rt2x00_dev, link.work.work);
 423
 424         /*
 425          * When the radio is shutting down we should
 426          * immediately cease all link tuning.
 427          */
 428         if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
 429                 return;
 430
 431         /*
 432          * Update statistics.
 433          */
 434         rt2x00dev->ops->lib->link_stats(rt2x00dev, &rt2x00dev->link.qual);
 435         rt2x00dev->low_level_stats.dot11FCSErrorCount +=
 436             rt2x00dev->link.qual.rx_failed;
 437
 438         /*
 439          * Only perform the link tuning when Link tuning
 440          * has been enabled (This could have been disabled from the EEPROM).
 441          */
 442         if (!test_bit(CONFIG_DISABLE_LINK_TUNING, &rt2x00dev->flags))
 443                 rt2x00dev->ops->lib->link_tuner(rt2x00dev);
 444
 445         /*
 446          * Precalculate a portion of the link signal which is
 447          * in based on the tx/rx success/failure counters.
 448          */
 449         rt2x00lib_precalculate_link_signal(&rt2x00dev->link.qual);
 450
 451         /*
 452          * Evaluate antenna setup, make this the last step since this could
 453          * possibly reset some statistics.
 454          */
 455         rt2x00lib_evaluate_antenna(rt2x00dev);
 456
 457         /*
 458          * Increase tuner counter, and reschedule the next link tuner run.
 459          */
 460         rt2x00dev->link.count++;
 461         queue_delayed_work(rt2x00dev->hw->workqueue, &rt2x00dev->link.work,
 462                            LINK_TUNE_INTERVAL);
 463 }
 464
 465 static void rt2x00lib_packetfilter_scheduled(struct work_struct *work)
 466 {
 467         struct rt2x00_dev *rt2x00dev =
 468             container_of(work, struct rt2x00_dev, filter_work);
 469         unsigned int filter = rt2x00dev->packet_filter;
 470
 471         /*
 472          * Since we had stored the filter inside interface.filter,
 473          * we should now clear that field. Otherwise the driver will
 474          * assume nothing has changed (*total_flags will be compared
 475          * to interface.filter to determine if any action is required).
 476          */
 477         rt2x00dev->packet_filter = 0;
 478
 479         rt2x00dev->ops->hw->configure_filter(rt2x00dev->hw,
 480                                              filter, &filter, 0, NULL);
 481 }
 482
 483 static void rt2x00lib_configuration_scheduled(struct work_struct *work)
 484 {
 485         struct rt2x00_dev *rt2x00dev =
 486             container_of(work, struct rt2x00_dev, config_work);
 487         struct ieee80211_bss_conf bss_conf;
 488
 489         bss_conf.use_short_preamble =
 490                 test_bit(CONFIG_SHORT_PREAMBLE, &rt2x00dev->flags);
 491
 492         /*
 493          * FIXME: shouldn't invoke it this way because all other contents
 494          *        of bss_conf is invalid.
 495          */
 496         rt2x00mac_bss_info_changed(rt2x00dev->hw, rt2x00dev->interface.id,
 497                                    &bss_conf, BSS_CHANGED_ERP_PREAMBLE);
 498 }
 499
 500 /*
 501  * Interrupt context handlers.
 502  */
 503 static void rt2x00lib_beacondone_scheduled(struct work_struct *work)
 504 {
 505         struct rt2x00_dev *rt2x00dev =
 506             container_of(work, struct rt2x00_dev, beacon_work);
 507         struct data_ring *ring =
 508             rt2x00lib_get_ring(rt2x00dev, IEEE80211_TX_QUEUE_BEACON);
 509         struct data_entry *entry = rt2x00_get_data_entry(ring);
 510         struct sk_buff *skb;
 511
 512         skb = ieee80211_beacon_get(rt2x00dev->hw,
 513                                    rt2x00dev->interface.id,
 514                                    &entry->tx_status.control);
 515         if (!skb)
 516                 return;
 517
 518         rt2x00dev->ops->hw->beacon_update(rt2x00dev->hw, skb,
 519                                           &entry->tx_status.control);
 520
 521         dev_kfree_skb(skb);
 522 }
 523
 524 void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
 525 {
 526         if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
 527                 return;
 528
 529         queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->beacon_work);
 530 }
 531 EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);
 532
 533 void rt2x00lib_txdone(struct data_entry *entry,
 534                       const int status, const int retry)
 535 {
 536         struct rt2x00_dev *rt2x00dev = entry->ring->rt2x00dev;
 537         struct ieee80211_tx_status *tx_status = &entry->tx_status;
 538         struct ieee80211_low_level_stats *stats = &rt2x00dev->low_level_stats;
 539         int success = !!(status == TX_SUCCESS || status == TX_SUCCESS_RETRY);
 540         int fail = !!(status == TX_FAIL_RETRY || status == TX_FAIL_INVALID ||
 541                       status == TX_FAIL_OTHER);
 542
 543         /*
 544          * Update TX statistics.
 545          */
 546         tx_status->flags = 0;
 547         tx_status->ack_signal = 0;
 548         tx_status->excessive_retries = (status == TX_FAIL_RETRY);
 549         tx_status->retry_count = retry;
 550         rt2x00dev->link.qual.tx_success += success;
 551         rt2x00dev->link.qual.tx_failed += retry + fail;
 552
 553         if (!(tx_status->control.flags & IEEE80211_TXCTL_NO_ACK)) {
 554                 if (success)
 555                         tx_status->flags |= IEEE80211_TX_STATUS_ACK;
 556                 else
 557                         stats->dot11ACKFailureCount++;
 558         }
 559
 560         tx_status->queue_length = entry->ring->stats.limit;
 561         tx_status->queue_number = tx_status->control.queue;
 562
 563         if (tx_status->control.flags & IEEE80211_TXCTL_USE_RTS_CTS) {
 564                 if (success)
 565                         stats->dot11RTSSuccessCount++;
 566                 else
 567                         stats->dot11RTSFailureCount++;
 568         }
 569
 570         /*
 571          * Send the tx_status to mac80211 & debugfs.
 572          * mac80211 will clean up the skb structure.
 573          */
 574         get_skb_desc(entry->skb)->frame_type = DUMP_FRAME_TXDONE;
 575         rt2x00debug_dump_frame(rt2x00dev, entry->skb);
 576         ieee80211_tx_status_irqsafe(rt2x00dev->hw, entry->skb, tx_status);
 577         entry->skb = NULL;
 578 }
 579 EXPORT_SYMBOL_GPL(rt2x00lib_txdone);
 580
 581 void rt2x00lib_rxdone(struct data_entry *entry, struct sk_buff *skb,
 582                       struct rxdata_entry_desc *desc)
 583 {
 584         struct rt2x00_dev *rt2x00dev = entry->ring->rt2x00dev;
 585         struct ieee80211_rx_status *rx_status = &rt2x00dev->rx_status;
 586         struct ieee80211_hw_mode *mode;
 587         struct ieee80211_rate *rate;
 588         struct ieee80211_hdr *hdr;
 589         unsigned int i;
 590         int val = 0;
 591         u16 fc;
 592
 593         /*
 594          * Update RX statistics.
 595          */
 596         mode = &rt2x00dev->hwmodes[rt2x00dev->curr_hwmode];
 597         for (i = 0; i < mode->num_rates; i++) {
 598                 rate = &mode->rates[i];
 599
 600                 /*
 601                  * When frame was received with an OFDM bitrate,
 602                  * the signal is the PLCP value. If it was received with
 603                  * a CCK bitrate the signal is the rate in 0.5kbit/s.
 604                  */
 605                 if (!desc->ofdm)
 606                         val = DEVICE_GET_RATE_FIELD(rate->val, RATE);
 607                 else
 608                         val = DEVICE_GET_RATE_FIELD(rate->val, PLCP);
 609
 610                 if (val == desc->signal) {
 611                         val = rate->val;
 612                         break;
 613                 }
 614         }
 615
 616         /*
 617          * Only update link status if this is a beacon frame carrying our bssid.
 618          */
 619         hdr = (struct ieee80211_hdr*)skb->data;
 620         fc = le16_to_cpu(hdr->frame_control);
 621         if (is_beacon(fc) && desc->my_bss)
 622                 rt2x00lib_update_link_stats(&rt2x00dev->link, desc->rssi);
 623
 624         rt2x00dev->link.qual.rx_success++;
 625
 626         rx_status->rate = val;
 627         rx_status->signal =
 628             rt2x00lib_calculate_link_signal(rt2x00dev, desc->rssi);
 629         rx_status->ssi = desc->rssi;
 630         rx_status->flag = desc->flags;
 631         rx_status->antenna = rt2x00dev->link.ant.active.rx;
 632
 633         /*
 634          * Send frame to mac80211 & debugfs
 635          */
 636         get_skb_desc(skb)->frame_type = DUMP_FRAME_RXDONE;
 637         rt2x00debug_dump_frame(rt2x00dev, skb);
 638         ieee80211_rx_irqsafe(rt2x00dev->hw, skb, rx_status);
 639 }
 640 EXPORT_SYMBOL_GPL(rt2x00lib_rxdone);
 641
 642 /*
 643  * TX descriptor initializer
 644  */
 645 void rt2x00lib_write_tx_desc(struct rt2x00_dev *rt2x00dev,
 646                              struct sk_buff *skb,
 647                              struct ieee80211_tx_control *control)
 648 {
 649         struct txdata_entry_desc desc;
 650         struct skb_desc *skbdesc = get_skb_desc(skb);
 651         struct ieee80211_hdr *ieee80211hdr = skbdesc->data;
 652         int tx_rate;
 653         int bitrate;
 654         int length;
 655         int duration;
 656         int residual;
 657         u16 frame_control;
 658         u16 seq_ctrl;
 659
 660         memset(&desc, 0, sizeof(desc));
 661
 662         desc.cw_min = skbdesc->ring->tx_params.cw_min;
 663         desc.cw_max = skbdesc->ring->tx_params.cw_max;
 664         desc.aifs = skbdesc->ring->tx_params.aifs;
 665
 666         /*
 667          * Identify queue
 668          */
 669         if (control->queue < rt2x00dev->hw->queues)
 670                 desc.queue = control->queue;
 671         else if (control->queue == IEEE80211_TX_QUEUE_BEACON ||
 672                  control->queue == IEEE80211_TX_QUEUE_AFTER_BEACON)
 673                 desc.queue = QUEUE_MGMT;
 674         else
 675                 desc.queue = QUEUE_OTHER;
 676
 677         /*
 678          * Read required fields from ieee80211 header.
 679          */
 680         frame_control = le16_to_cpu(ieee80211hdr->frame_control);
 681         seq_ctrl = le16_to_cpu(ieee80211hdr->seq_ctrl);
 682
 683         tx_rate = control->tx_rate;
 684
 685         /*
 686          * Check whether this frame is to be acked
 687          */
 688         if (!(control->flags & IEEE80211_TXCTL_NO_ACK))
 689                 __set_bit(ENTRY_TXD_ACK, &desc.flags);
 690
 691         /*
 692          * Check if this is a RTS/CTS frame
 693          */
 694         if (is_rts_frame(frame_control) || is_cts_frame(frame_control)) {
 695                 __set_bit(ENTRY_TXD_BURST, &desc.flags);
 696                 if (is_rts_frame(frame_control)) {
 697                         __set_bit(ENTRY_TXD_RTS_FRAME, &desc.flags);
 698                         __set_bit(ENTRY_TXD_ACK, &desc.flags);
 699                 } else
 700                         __clear_bit(ENTRY_TXD_ACK, &desc.flags);
 701                 if (control->rts_cts_rate)
 702                         tx_rate = control->rts_cts_rate;
 703         }
 704
 705         /*
 706          * Check for OFDM
 707          */
 708         if (DEVICE_GET_RATE_FIELD(tx_rate, RATEMASK) & DEV_OFDM_RATEMASK)
 709                 __set_bit(ENTRY_TXD_OFDM_RATE, &desc.flags);
 710
 711         /*
 712          * Check if more fragments are pending
 713          */
 714         if (ieee80211_get_morefrag(ieee80211hdr)) {
 715                 __set_bit(ENTRY_TXD_BURST, &desc.flags);
 716                 __set_bit(ENTRY_TXD_MORE_FRAG, &desc.flags);
 717         }
 718
 719         /*
 720          * Beacons and probe responses require the tsf timestamp
 721          * to be inserted into the frame.
 722          */
 723         if (control->queue == IEEE80211_TX_QUEUE_BEACON ||
 724             is_probe_resp(frame_control))
 725                 __set_bit(ENTRY_TXD_REQ_TIMESTAMP, &desc.flags);
 726
 727         /*
 728          * Determine with what IFS priority this frame should be send.
 729          * Set ifs to IFS_SIFS when the this is not the first fragment,
 730          * or this fragment came after RTS/CTS.
 731          */
 732         if ((seq_ctrl & IEEE80211_SCTL_FRAG) > 0 ||
 733             test_bit(ENTRY_TXD_RTS_FRAME, &desc.flags))
 734                 desc.ifs = IFS_SIFS;
 735         else
 736                 desc.ifs = IFS_BACKOFF;
 737
 738         /*
 739          * PLCP setup
 740          * Length calculation depends on OFDM/CCK rate.
 741          */
 742         desc.signal = DEVICE_GET_RATE_FIELD(tx_rate, PLCP);
 743         desc.service = 0x04;
 744
 745         length = skbdesc->data_len + FCS_LEN;
 746         if (test_bit(ENTRY_TXD_OFDM_RATE, &desc.flags)) {
 747                 desc.length_high = (length >> 6) & 0x3f;
 748                 desc.length_low = length & 0x3f;
 749         } else {
 750                 bitrate = DEVICE_GET_RATE_FIELD(tx_rate, RATE);
 751
 752                 /*
 753                  * Convert length to microseconds.
 754                  */
 755                 residual = get_duration_res(length, bitrate);
 756                 duration = get_duration(length, bitrate);
 757
 758                 if (residual != 0) {
 759                         duration++;
 760
 761                         /*
 762                          * Check if we need to set the Length Extension
 763                          */
 764                         if (bitrate == 110 && residual <= 30)
 765                                 desc.service |= 0x80;
 766                 }
 767
 768                 desc.length_high = (duration >> 8) & 0xff;
 769                 desc.length_low = duration & 0xff;
 770
 771                 /*
 772                  * When preamble is enabled we should set the
 773                  * preamble bit for the signal.
 774                  */
 775                 if (DEVICE_GET_RATE_FIELD(tx_rate, PREAMBLE))
 776                         desc.signal |= 0x08;
 777         }
 778
 779         rt2x00dev->ops->lib->write_tx_desc(rt2x00dev, skb, &desc, control);
 780
 781         /*
 782          * Update ring entry.
 783          */
 784         skbdesc->entry->skb = skb;
 785         memcpy(&skbdesc->entry->tx_status.control, control, sizeof(*control));
 786
 787         /*
 788          * The frame has been completely initialized and ready
 789          * for sending to the device. The caller will push the
 790          * frame to the device, but we are going to push the
 791          * frame to debugfs here.
 792          */
 793         skbdesc->frame_type = DUMP_FRAME_TX;
 794         rt2x00debug_dump_frame(rt2x00dev, skb);
 795 }
 796 EXPORT_SYMBOL_GPL(rt2x00lib_write_tx_desc);
 797
 798 /*
 799  * Driver initialization handlers.
 800  */
 801 static void rt2x00lib_channel(struct ieee80211_channel *entry,
 802                               const int channel, const int tx_power,
 803                               const int value)
 804 {
 805         entry->chan = channel;
 806         if (channel <= 14)
 807                 entry->freq = 2407 + (5 * channel);
 808         else
 809                 entry->freq = 5000 + (5 * channel);
 810         entry->val = value;
 811         entry->flag =
 812             IEEE80211_CHAN_W_IBSS |
 813             IEEE80211_CHAN_W_ACTIVE_SCAN |
 814             IEEE80211_CHAN_W_SCAN;
 815         entry->power_level = tx_power;
 816         entry->antenna_max = 0xff;
 817 }
 818
 819 static void rt2x00lib_rate(struct ieee80211_rate *entry,
 820                            const int rate, const int mask,
 821                            const int plcp, const int flags)
 822 {
 823         entry->rate = rate;
 824         entry->val =
 825             DEVICE_SET_RATE_FIELD(rate, RATE) |
 826             DEVICE_SET_RATE_FIELD(mask, RATEMASK) |
 827             DEVICE_SET_RATE_FIELD(plcp, PLCP);
 828         entry->flags = flags;
 829         entry->val2 = entry->val;
 830         if (entry->flags & IEEE80211_RATE_PREAMBLE2)
 831                 entry->val2 |= DEVICE_SET_RATE_FIELD(1, PREAMBLE);
 832         entry->min_rssi_ack = 0;
 833         entry->min_rssi_ack_delta = 0;
 834 }
 835
 836 static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
 837                                     struct hw_mode_spec *spec)
 838 {
 839         struct ieee80211_hw *hw = rt2x00dev->hw;
 840         struct ieee80211_hw_mode *hwmodes;
 841         struct ieee80211_channel *channels;
 842         struct ieee80211_rate *rates;
 843         unsigned int i;
 844         unsigned char tx_power;
 845
 846         hwmodes = kzalloc(sizeof(*hwmodes) * spec->num_modes, GFP_KERNEL);
 847         if (!hwmodes)
 848                 goto exit;
 849
 850         channels = kzalloc(sizeof(*channels) * spec->num_channels, GFP_KERNEL);
 851         if (!channels)
 852                 goto exit_free_modes;
 853
 854         rates = kzalloc(sizeof(*rates) * spec->num_rates, GFP_KERNEL);
 855         if (!rates)
 856                 goto exit_free_channels;
 857
 858         /*
 859          * Initialize Rate list.
 860          */
 861         rt2x00lib_rate(&rates[0], 10, DEV_RATEMASK_1MB,
 862                        0x00, IEEE80211_RATE_CCK);
 863         rt2x00lib_rate(&rates[1], 20, DEV_RATEMASK_2MB,
 864                        0x01, IEEE80211_RATE_CCK_2);
 865         rt2x00lib_rate(&rates[2], 55, DEV_RATEMASK_5_5MB,
 866                        0x02, IEEE80211_RATE_CCK_2);
 867         rt2x00lib_rate(&rates[3], 110, DEV_RATEMASK_11MB,
 868                        0x03, IEEE80211_RATE_CCK_2);
 869
 870         if (spec->num_rates > 4) {
 871                 rt2x00lib_rate(&rates[4], 60, DEV_RATEMASK_6MB,
 872                                0x0b, IEEE80211_RATE_OFDM);
 873                 rt2x00lib_rate(&rates[5], 90, DEV_RATEMASK_9MB,
 874                                0x0f, IEEE80211_RATE_OFDM);
 875                 rt2x00lib_rate(&rates[6], 120, DEV_RATEMASK_12MB,
 876                                0x0a, IEEE80211_RATE_OFDM);
 877                 rt2x00lib_rate(&rates[7], 180, DEV_RATEMASK_18MB,
 878                                0x0e, IEEE80211_RATE_OFDM);
 879                 rt2x00lib_rate(&rates[8], 240, DEV_RATEMASK_24MB,
 880                                0x09, IEEE80211_RATE_OFDM);
 881                 rt2x00lib_rate(&rates[9], 360, DEV_RATEMASK_36MB,
 882                                0x0d, IEEE80211_RATE_OFDM);
 883                 rt2x00lib_rate(&rates[10], 480, DEV_RATEMASK_48MB,
 884                                0x08, IEEE80211_RATE_OFDM);
 885                 rt2x00lib_rate(&rates[11], 540, DEV_RATEMASK_54MB,
 886                                0x0c, IEEE80211_RATE_OFDM);
 887         }
 888
 889         /*
 890          * Initialize Channel list.
 891          */
 892         for (i = 0; i < spec->num_channels; i++) {
 893                 if (spec->channels[i].channel <= 14)
 894                         tx_power = spec->tx_power_bg[i];
 895                 else if (spec->tx_power_a)
 896                         tx_power = spec->tx_power_a[i];
 897                 else
 898                         tx_power = spec->tx_power_default;
 899
 900                 rt2x00lib_channel(&channels[i],
 901                                   spec->channels[i].channel, tx_power, i);
 902         }
 903
 904         /*
 905          * Intitialize 802.11b
 906          * Rates: CCK.
 907          * Channels: OFDM.
 908          */
 909         if (spec->num_modes > HWMODE_B) {
 910                 hwmodes[HWMODE_B].mode = MODE_IEEE80211B;
 911                 hwmodes[HWMODE_B].num_channels = 14;
 912                 hwmodes[HWMODE_B].num_rates = 4;
 913                 hwmodes[HWMODE_B].channels = channels;
 914                 hwmodes[HWMODE_B].rates = rates;
 915         }
 916
 917         /*
 918          * Intitialize 802.11g
 919          * Rates: CCK, OFDM.
 920          * Channels: OFDM.
 921          */
 922         if (spec->num_modes > HWMODE_G) {
 923                 hwmodes[HWMODE_G].mode = MODE_IEEE80211G;
 924                 hwmodes[HWMODE_G].num_channels = 14;
 925                 hwmodes[HWMODE_G].num_rates = spec->num_rates;
 926                 hwmodes[HWMODE_G].channels = channels;
 927                 hwmodes[HWMODE_G].rates = rates;
 928         }
 929
 930         /*
 931          * Intitialize 802.11a
 932          * Rates: OFDM.
 933          * Channels: OFDM, UNII, HiperLAN2.
 934          */
 935         if (spec->num_modes > HWMODE_A) {
 936                 hwmodes[HWMODE_A].mode = MODE_IEEE80211A;
 937                 hwmodes[HWMODE_A].num_channels = spec->num_channels - 14;
 938                 hwmodes[HWMODE_A].num_rates = spec->num_rates - 4;
 939                 hwmodes[HWMODE_A].channels = &channels[14];
 940                 hwmodes[HWMODE_A].rates = &rates[4];
 941         }
 942
 943         if (spec->num_modes > HWMODE_G &&
 944             ieee80211_register_hwmode(hw, &hwmodes[HWMODE_G]))
 945                 goto exit_free_rates;
 946
 947         if (spec->num_modes > HWMODE_B &&
 948             ieee80211_register_hwmode(hw, &hwmodes[HWMODE_B]))
 949                 goto exit_free_rates;
 950
 951         if (spec->num_modes > HWMODE_A &&
 952             ieee80211_register_hwmode(hw, &hwmodes[HWMODE_A]))
 953                 goto exit_free_rates;
 954
 955         rt2x00dev->hwmodes = hwmodes;
 956
 957         return 0;
 958
 959 exit_free_rates:
 960         kfree(rates);
 961
 962 exit_free_channels:
 963         kfree(channels);
 964
 965 exit_free_modes:
 966         kfree(hwmodes);
 967
 968 exit:
 969         ERROR(rt2x00dev, "Allocation ieee80211 modes failed.\n");
 970         return -ENOMEM;
 971 }
 972
 973 static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
 974 {
 975         if (test_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags))
 976                 ieee80211_unregister_hw(rt2x00dev->hw);
 977
 978         if (likely(rt2x00dev->hwmodes)) {
 979                 kfree(rt2x00dev->hwmodes->channels);
 980                 kfree(rt2x00dev->hwmodes->rates);
 981                 kfree(rt2x00dev->hwmodes);
 982                 rt2x00dev->hwmodes = NULL;
 983         }
 984 }
 985
 986 static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
 987 {
 988         struct hw_mode_spec *spec = &rt2x00dev->spec;
 989         int status;
 990
 991         /*
 992          * Initialize HW modes.
 993          */
 994         status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
 995         if (status)
 996                 return status;
 997
 998         /*
 999          * Register HW.
1000          */
1001         status = ieee80211_register_hw(rt2x00dev->hw);
1002         if (status) {
1003                 rt2x00lib_remove_hw(rt2x00dev);
1004                 return status;
1005         }
1006
1007         __set_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags);
1008
1009         return 0;
1010 }
1011
1012 /*
1013  * Initialization/uninitialization handlers.
1014  */
1015 static int rt2x00lib_alloc_entries(struct data_ring *ring,
1016                                    const u16 max_entries, const u16 data_size,
1017                                    const u16 desc_size)
1018 {
1019         struct data_entry *entry;
1020         unsigned int i;
1021
1022         ring->stats.limit = max_entries;
1023         ring->data_size = data_size;
1024         ring->desc_size = desc_size;
1025
1026         /*
1027          * Allocate all ring entries.
1028          */
1029         entry = kzalloc(ring->stats.limit * sizeof(*entry), GFP_KERNEL);
1030         if (!entry)
1031                 return -ENOMEM;
1032
1033         for (i = 0; i < ring->stats.limit; i++) {
1034                 entry[i].flags = 0;
1035                 entry[i].ring = ring;
1036                 entry[i].skb = NULL;
1037                 entry[i].entry_idx = i;
1038         }
1039
1040         ring->entry = entry;
1041
1042         return 0;
1043 }
1044
1045 static int rt2x00lib_alloc_ring_entries(struct rt2x00_dev *rt2x00dev)
1046 {
1047         struct data_ring *ring;
1048
1049         /*
1050          * Allocate the RX ring.
1051          */
1052         if (rt2x00lib_alloc_entries(rt2x00dev->rx, RX_ENTRIES, DATA_FRAME_SIZE,
1053                                     rt2x00dev->ops->rxd_size))
1054                 return -ENOMEM;
1055
1056         /*
1057          * First allocate the TX rings.
1058          */
1059         txring_for_each(rt2x00dev, ring) {
1060                 if (rt2x00lib_alloc_entries(ring, TX_ENTRIES, DATA_FRAME_SIZE,
1061                                             rt2x00dev->ops->txd_size))
1062                         return -ENOMEM;
1063         }
1064
1065         if (!test_bit(DRIVER_REQUIRE_BEACON_RING, &rt2x00dev->flags))
1066                 return 0;
1067
1068         /*
1069          * Allocate the BEACON ring.
1070          */
1071         if (rt2x00lib_alloc_entries(&rt2x00dev->bcn[0], BEACON_ENTRIES,
1072                                     MGMT_FRAME_SIZE, rt2x00dev->ops->txd_size))
1073                 return -ENOMEM;
1074
1075         /*
1076          * Allocate the Atim ring.
1077          */
1078         if (rt2x00lib_alloc_entries(&rt2x00dev->bcn[1], ATIM_ENTRIES,
1079                                     DATA_FRAME_SIZE, rt2x00dev->ops->txd_size))
1080                 return -ENOMEM;
1081
1082         return 0;
1083 }
1084
1085 static void rt2x00lib_free_ring_entries(struct rt2x00_dev *rt2x00dev)
1086 {
1087         struct data_ring *ring;
1088
1089         ring_for_each(rt2x00dev, ring) {
1090                 kfree(ring->entry);
1091                 ring->entry = NULL;
1092         }
1093 }
1094
1095 static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
1096 {
1097         if (!__test_and_clear_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
1098                 return;
1099
1100         /*
1101          * Unregister extra components.
1102          */
1103         rt2x00rfkill_unregister(rt2x00dev);
1104
1105         /*
1106          * Allow the HW to uninitialize.
1107          */
1108         rt2x00dev->ops->lib->uninitialize(rt2x00dev);
1109
1110         /*
1111          * Free allocated ring entries.
1112          */
1113         rt2x00lib_free_ring_entries(rt2x00dev);
1114 }
1115
1116 static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
1117 {
1118         int status;
1119
1120         if (test_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
1121                 return 0;
1122
1123         /*
1124          * Allocate all ring entries.
1125          */
1126         status = rt2x00lib_alloc_ring_entries(rt2x00dev);
1127         if (status) {
1128                 ERROR(rt2x00dev, "Ring entries allocation failed.\n");
1129                 return status;
1130         }
1131
1132         /*
1133          * Initialize the device.
1134          */
1135         status = rt2x00dev->ops->lib->initialize(rt2x00dev);
1136         if (status)
1137                 goto exit;
1138
1139         __set_bit(DEVICE_INITIALIZED, &rt2x00dev->flags);
1140
1141         /*
1142          * Register the extra components.
1143          */
1144         rt2x00rfkill_register(rt2x00dev);
1145
1146         return 0;
1147
1148 exit:
1149         rt2x00lib_free_ring_entries(rt2x00dev);
1150
1151         return status;
1152 }
1153
1154 int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
1155 {
1156         int retval;
1157
1158         if (test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1159                 return 0;
1160
1161         /*
1162          * If this is the first interface which is added,
1163          * we should load the firmware now.
1164          */
1165         if (test_bit(DRIVER_REQUIRE_FIRMWARE, &rt2x00dev->flags)) {
1166                 retval = rt2x00lib_load_firmware(rt2x00dev);
1167                 if (retval)
1168                         return retval;
1169         }
1170
1171         /*
1172          * Initialize the device.
1173          */
1174         retval = rt2x00lib_initialize(rt2x00dev);
1175         if (retval)
1176                 return retval;
1177
1178         /*
1179          * Enable radio.
1180          */
1181         retval = rt2x00lib_enable_radio(rt2x00dev);
1182         if (retval) {
1183                 rt2x00lib_uninitialize(rt2x00dev);
1184                 return retval;
1185         }
1186
1187         __set_bit(DEVICE_STARTED, &rt2x00dev->flags);
1188
1189         return 0;
1190 }
1191
1192 void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
1193 {
1194         if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1195                 return;
1196
1197         /*
1198          * Perhaps we can add something smarter here,
1199          * but for now just disabling the radio should do.
1200          */
1201         rt2x00lib_disable_radio(rt2x00dev);
1202
1203         __clear_bit(DEVICE_STARTED, &rt2x00dev->flags);
1204 }
1205
1206 /*
1207  * driver allocation handlers.
1208  */
1209 static int rt2x00lib_alloc_rings(struct rt2x00_dev *rt2x00dev)
1210 {
1211         struct data_ring *ring;
1212         unsigned int index;
1213
1214         /*
1215          * We need the following rings:
1216          * RX: 1
1217          * TX: hw->queues
1218          * Beacon: 1 (if required)
1219          * Atim: 1 (if required)
1220          */
1221         rt2x00dev->data_rings = 1 + rt2x00dev->hw->queues +
1222             (2 * test_bit(DRIVER_REQUIRE_BEACON_RING, &rt2x00dev->flags));
1223
1224         ring = kzalloc(rt2x00dev->data_rings * sizeof(*ring), GFP_KERNEL);
1225         if (!ring) {
1226                 ERROR(rt2x00dev, "Ring allocation failed.\n");
1227                 return -ENOMEM;
1228         }
1229
1230         /*
1231          * Initialize pointers
1232          */
1233         rt2x00dev->rx = ring;
1234         rt2x00dev->tx = &rt2x00dev->rx[1];
1235         if (test_bit(DRIVER_REQUIRE_BEACON_RING, &rt2x00dev->flags))
1236                 rt2x00dev->bcn = &rt2x00dev->tx[rt2x00dev->hw->queues];
1237
1238         /*
1239          * Initialize ring parameters.
1240          * RX: queue_idx = 0
1241          * TX: queue_idx = IEEE80211_TX_QUEUE_DATA0 + index
1242          * TX: cw_min: 2^5 = 32.
1243          * TX: cw_max: 2^10 = 1024.
1244          */
1245         rt2x00dev->rx->rt2x00dev = rt2x00dev;
1246         rt2x00dev->rx->queue_idx = 0;
1247
1248         index = IEEE80211_TX_QUEUE_DATA0;
1249         txring_for_each(rt2x00dev, ring) {
1250                 ring->rt2x00dev = rt2x00dev;
1251                 ring->queue_idx = index++;
1252                 ring->tx_params.aifs = 2;
1253                 ring->tx_params.cw_min = 5;
1254                 ring->tx_params.cw_max = 10;
1255         }
1256
1257         return 0;
1258 }
1259
1260 static void rt2x00lib_free_rings(struct rt2x00_dev *rt2x00dev)
1261 {
1262         kfree(rt2x00dev->rx);
1263         rt2x00dev->rx = NULL;
1264         rt2x00dev->tx = NULL;
1265         rt2x00dev->bcn = NULL;
1266 }
1267
1268 int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
1269 {
1270         int retval = -ENOMEM;
1271
1272         /*
1273          * Let the driver probe the device to detect the capabilities.
1274          */
1275         retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
1276         if (retval) {
1277                 ERROR(rt2x00dev, "Failed to allocate device.\n");
1278                 goto exit;
1279         }
1280
1281         /*
1282          * Initialize configuration work.
1283          */
1284         INIT_WORK(&rt2x00dev->beacon_work, rt2x00lib_beacondone_scheduled);
1285         INIT_WORK(&rt2x00dev->filter_work, rt2x00lib_packetfilter_scheduled);
1286         INIT_WORK(&rt2x00dev->config_work, rt2x00lib_configuration_scheduled);
1287         INIT_DELAYED_WORK(&rt2x00dev->link.work, rt2x00lib_link_tuner);
1288
1289         /*
1290          * Reset current working type.
1291          */
1292         rt2x00dev->interface.type = IEEE80211_IF_TYPE_INVALID;
1293
1294         /*
1295          * Allocate ring array.
1296          */
1297         retval = rt2x00lib_alloc_rings(rt2x00dev);
1298         if (retval)
1299                 goto exit;
1300
1301         /*
1302          * Initialize ieee80211 structure.
1303          */
1304         retval = rt2x00lib_probe_hw(rt2x00dev);
1305         if (retval) {
1306                 ERROR(rt2x00dev, "Failed to initialize hw.\n");
1307                 goto exit;
1308         }
1309
1310         /*
1311          * Register extra components.
1312          */
1313         rt2x00rfkill_allocate(rt2x00dev);
1314         rt2x00debug_register(rt2x00dev);
1315
1316         __set_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1317
1318         return 0;
1319
1320 exit:
1321         rt2x00lib_remove_dev(rt2x00dev);
1322
1323         return retval;
1324 }
1325 EXPORT_SYMBOL_GPL(rt2x00lib_probe_dev);
1326
1327 void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
1328 {
1329         __clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1330
1331         /*
1332          * Disable radio.
1333          */
1334         rt2x00lib_disable_radio(rt2x00dev);
1335
1336         /*
1337          * Uninitialize device.
1338          */
1339         rt2x00lib_uninitialize(rt2x00dev);
1340
1341         /*
1342          * Free extra components
1343          */
1344         rt2x00debug_deregister(rt2x00dev);
1345         rt2x00rfkill_free(rt2x00dev);
1346
1347         /*
1348          * Free ieee80211_hw memory.
1349          */
1350         rt2x00lib_remove_hw(rt2x00dev);
1351
1352         /*
1353          * Free firmware image.
1354          */
1355         rt2x00lib_free_firmware(rt2x00dev);
1356
1357         /*
1358          * Free ring structures.
1359          */
1360         rt2x00lib_free_rings(rt2x00dev);
1361 }
1362 EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev);
1363
1364 /*
1365  * Device state handlers
1366  */
1367 #ifdef CONFIG_PM
1368 int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state)
1369 {
1370         int retval;
1371
1372         NOTICE(rt2x00dev, "Going to sleep.\n");
1373         __clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1374
1375         /*
1376          * Only continue if mac80211 has open interfaces.
1377          */
1378         if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1379                 goto exit;
1380         __set_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags);
1381
1382         /*
1383          * Disable radio.
1384          */
1385         rt2x00lib_stop(rt2x00dev);
1386         rt2x00lib_uninitialize(rt2x00dev);
1387
1388         /*
1389          * Suspend/disable extra components.
1390          */
1391         rt2x00rfkill_suspend(rt2x00dev);
1392         rt2x00debug_deregister(rt2x00dev);
1393
1394 exit:
1395         /*
1396          * Set device mode to sleep for power management,
1397          * on some hardware this call seems to consistently fail.
1398          * From the specifications it is hard to tell why it fails,
1399          * and if this is a "bad thing".
1400          * Overall it is safe to just ignore the failure and
1401          * continue suspending. The only downside is that the
1402          * device will not be in optimal power save mode, but with
1403          * the radio and the other components already disabled the
1404          * device is as good as disabled.
1405          */
1406         retval = rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP);
1407         if (retval)
1408                 WARNING(rt2x00dev, "Device failed to enter sleep state, "
1409                         "continue suspending.\n");
1410
1411         return 0;
1412 }
1413 EXPORT_SYMBOL_GPL(rt2x00lib_suspend);
1414
1415 int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
1416 {
1417         struct interface *intf = &rt2x00dev->interface;
1418         int retval;
1419
1420         NOTICE(rt2x00dev, "Waking up.\n");
1421
1422         /*
1423          * Restore/enable extra components.
1424          */
1425         rt2x00debug_register(rt2x00dev);
1426         rt2x00rfkill_resume(rt2x00dev);
1427
1428         /*
1429          * Only continue if mac80211 had open interfaces.
1430          */
1431         if (!__test_and_clear_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags))
1432                 return 0;
1433
1434         /*
1435          * Reinitialize device and all active interfaces.
1436          */
1437         retval = rt2x00lib_start(rt2x00dev);
1438         if (retval)
1439                 goto exit;
1440
1441         /*
1442          * Reconfigure device.
1443          */
1444         rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf, 1);
1445         if (!rt2x00dev->hw->conf.radio_enabled)
1446                 rt2x00lib_disable_radio(rt2x00dev);
1447
1448         rt2x00lib_config_mac_addr(rt2x00dev, intf->mac);
1449         rt2x00lib_config_bssid(rt2x00dev, intf->bssid);
1450         rt2x00lib_config_type(rt2x00dev, intf->type);
1451
1452         /*
1453          * We are ready again to receive requests from mac80211.
1454          */
1455         __set_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1456
1457         /*
1458          * It is possible that during that mac80211 has attempted
1459          * to send frames while we were suspending or resuming.
1460          * In that case we have disabled the TX queue and should
1461          * now enable it again
1462          */
1463         ieee80211_start_queues(rt2x00dev->hw);
1464
1465         /*
1466          * When in Master or Ad-hoc mode,
1467          * restart Beacon transmitting by faking a beacondone event.
1468          */
1469         if (intf->type == IEEE80211_IF_TYPE_AP ||
1470             intf->type == IEEE80211_IF_TYPE_IBSS)
1471                 rt2x00lib_beacondone(rt2x00dev);
1472
1473         return 0;
1474
1475 exit:
1476         rt2x00lib_disable_radio(rt2x00dev);
1477         rt2x00lib_uninitialize(rt2x00dev);
1478         rt2x00debug_deregister(rt2x00dev);
1479
1480         return retval;
1481 }
1482 EXPORT_SYMBOL_GPL(rt2x00lib_resume);
1483 #endif /* CONFIG_PM */
1484
1485 /*
1486  * rt2x00lib module information.
1487  */
1488 MODULE_AUTHOR(DRV_PROJECT);
1489 MODULE_VERSION(DRV_VERSION);
1490 MODULE_DESCRIPTION("rt2x00 library");
1491 MODULE_LICENSE("GPL");