← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to drivers/net/wireless/rt2x00/rt2800pci.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno
  • Date: 2011-06-07 12:14:05 UTC
  • mfrom: (43.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20110607121405-i3h1rd7nrnd2b73h
Tags: 2.6.39-2
http://bugs.debian.org/627492
http://bugs.debian.org/596626
http://bugs.debian.org/628932
http://bugs.debian.org/628191
http://bugs.debian.org/627837
http://bugs.debian.org/622997
http://bugs.debian.org/622745
http://bugs.debian.org/619827
http://bugs.debian.org/629401
[ Ben Hutchings ]
* [x86] Enable BACKLIGHT_APPLE, replacing BACKLIGHT_MBP_NVIDIA
  (Closes: #627492)
* cgroups: Disable memory resource controller by default. Allow it
  to be enabled using kernel parameter 'cgroup_enable=memory'.
* rt2800usb: Enable support for more USB devices including
  Linksys WUSB600N (Closes: #596626) (this change was accidentally
  omitted from 2.6.39-1)
* [x86] Remove Celeron from list of processors supporting PAE. Most
  'Celeron M' models do not.
* Update debconf template translations:
  - Swedish (Martin Bagge) (Closes: #628932)
  - French (David Prévot) (Closes: #628191)
* aufs: Update for 2.6.39 (Closes: #627837)
* Add stable 2.6.39.1, including:
  - ext4: dont set PageUptodate in ext4_end_bio()
  - pata_cmd64x: fix boot crash on parisc (Closes: #622997, #622745)
  - ext3: Fix fs corruption when make_indexed_dir() fails
  - netfilter: nf_ct_sip: validate Content-Length in TCP SIP messages
  - sctp: fix race between sctp_bind_addr_free() and
    sctp_bind_addr_conflict()
  - sctp: fix memory leak of the ASCONF queue when free asoc
  - md/bitmap: fix saving of events_cleared and other state
  - cdc_acm: Fix oops when Droids MuIn LCD is connected
  - cx88: Fix conversion from BKL to fine-grained locks (Closes: #619827)
  - keys: Set cred->user_ns in key_replace_session_keyring (CVE-2011-2184)
  - tmpfs: fix race between truncate and writepage
  - nfs41: Correct offset for LAYOUTCOMMIT
  - xen/mmu: fix a race window causing leave_mm BUG()
  - ext4: fix possible use-after-free in ext4_remove_li_request()
  For the complete list of changes, see:
   http://www.kernel.org/pub/linux/kernel/v2.6/ChangeLog-2.6.39.1
* Bump ABI to 2
* netfilter: Enable IP_SET, IP_SET_BITMAP_IP, IP_SET_BITMAP_IPMAC,
  IP_SET_BITMAP_PORT, IP_SET_HASH_IP, IP_SET_HASH_IPPORT,
  IP_SET_HASH_IPPORTIP, IP_SET_HASH_IPPORTNET, IP_SET_HASH_NET,
  IP_SET_HASH_NETPORT, IP_SET_LIST_SET, NETFILTER_XT_SET as modules
  (Closes: #629401)

[ Aurelien Jarno ]
* [mipsel/loongson-2f] Disable_SCSI_LPFC to workaround GCC ICE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/wireless/rt2x00/rt2800pci.c
200
200
                rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg);
201
201
                break;
202
202
        case QID_BEACON:
 
203
                /*
 
204
                 * Allow beacon tasklets to be scheduled for periodic
 
205
                 * beacon updates.
 
206
                 */
 
207
                tasklet_enable(&rt2x00dev->tbtt_tasklet);
 
208
                tasklet_enable(&rt2x00dev->pretbtt_tasklet);
 
209
 
203
210
                rt2800_register_read(rt2x00dev, BCN_TIME_CFG, &reg);
204
211
                rt2x00_set_field32(&reg, BCN_TIME_CFG_TSF_TICKING, 1);
205
212
                rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 1);
206
213
                rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 1);
207
214
                rt2800_register_write(rt2x00dev, BCN_TIME_CFG, reg);
 
215
 
 
216
                rt2800_register_read(rt2x00dev, INT_TIMER_EN, &reg);
 
217
                rt2x00_set_field32(&reg, INT_TIMER_EN_PRE_TBTT_TIMER, 1);
 
218
                rt2800_register_write(rt2x00dev, INT_TIMER_EN, reg);
208
219
                break;
209
220
        default:
210
221
                break;
250
261
                rt2x00_set_field32(&reg, BCN_TIME_CFG_TBTT_ENABLE, 0);
251
262
                rt2x00_set_field32(&reg, BCN_TIME_CFG_BEACON_GEN, 0);
252
263
                rt2800_register_write(rt2x00dev, BCN_TIME_CFG, reg);
 
264
 
 
265
                rt2800_register_read(rt2x00dev, INT_TIMER_EN, &reg);
 
266
                rt2x00_set_field32(&reg, INT_TIMER_EN_PRE_TBTT_TIMER, 0);
 
267
                rt2800_register_write(rt2x00dev, INT_TIMER_EN, reg);
 
268
 
 
269
                /*
 
270
                 * Wait for tbtt tasklets to finish.
 
271
                 */
 
272
                tasklet_disable(&rt2x00dev->tbtt_tasklet);
 
273
                tasklet_disable(&rt2x00dev->pretbtt_tasklet);
253
274
                break;
254
275
        default:
255
276
                break;
397
418
static void rt2800pci_toggle_irq(struct rt2x00_dev *rt2x00dev,
398
419
                                 enum dev_state state)
399
420
{
400
 
        int mask = (state == STATE_RADIO_IRQ_ON) ||
401
 
                   (state == STATE_RADIO_IRQ_ON_ISR);
 
421
        int mask = (state == STATE_RADIO_IRQ_ON);
402
422
        u32 reg;
 
423
        unsigned long flags;
403
424
 
404
425
        /*
405
426
         * When interrupts are being enabled, the interrupt registers
408
429
        if (state == STATE_RADIO_IRQ_ON) {
409
430
                rt2800_register_read(rt2x00dev, INT_SOURCE_CSR, &reg);
410
431
                rt2800_register_write(rt2x00dev, INT_SOURCE_CSR, reg);
 
432
 
 
433
                /*
 
434
                 * Enable tasklets. The beacon related tasklets are
 
435
                 * enabled when the beacon queue is started.
 
436
                 */
 
437
                tasklet_enable(&rt2x00dev->txstatus_tasklet);
 
438
                tasklet_enable(&rt2x00dev->rxdone_tasklet);
 
439
                tasklet_enable(&rt2x00dev->autowake_tasklet);
411
440
        }
412
441
 
 
442
        spin_lock_irqsave(&rt2x00dev->irqmask_lock, flags);
413
443
        rt2800_register_read(rt2x00dev, INT_MASK_CSR, &reg);
414
444
        rt2x00_set_field32(&reg, INT_MASK_CSR_RXDELAYINT, 0);
415
445
        rt2x00_set_field32(&reg, INT_MASK_CSR_TXDELAYINT, 0);
430
460
        rt2x00_set_field32(&reg, INT_MASK_CSR_RX_COHERENT, 0);
431
461
        rt2x00_set_field32(&reg, INT_MASK_CSR_TX_COHERENT, 0);
432
462
        rt2800_register_write(rt2x00dev, INT_MASK_CSR, reg);
 
463
        spin_unlock_irqrestore(&rt2x00dev->irqmask_lock, flags);
 
464
 
 
465
        if (state == STATE_RADIO_IRQ_OFF) {
 
466
                /*
 
467
                 * Ensure that all tasklets are finished before
 
468
                 * disabling the interrupts.
 
469
                 */
 
470
                tasklet_disable(&rt2x00dev->txstatus_tasklet);
 
471
                tasklet_disable(&rt2x00dev->rxdone_tasklet);
 
472
                tasklet_disable(&rt2x00dev->autowake_tasklet);
 
473
        }
433
474
}
434
475
 
435
476
static int rt2800pci_init_registers(struct rt2x00_dev *rt2x00dev)
452
493
        rt2800_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00000e1f);
453
494
        rt2800_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00000e00);
454
495
 
 
496
        if (rt2x00_rt(rt2x00dev, RT5390)) {
 
497
                rt2800_register_read(rt2x00dev, AUX_CTRL, &reg);
 
498
                rt2x00_set_field32(&reg, AUX_CTRL_FORCE_PCIE_CLK, 1);
 
499
                rt2x00_set_field32(&reg, AUX_CTRL_WAKE_PCIE_EN, 1);
 
500
                rt2800_register_write(rt2x00dev, AUX_CTRL, reg);
 
501
        }
 
502
 
455
503
        rt2800_register_write(rt2x00dev, PWR_PIN_CFG, 0x00000003);
456
504
 
457
505
        rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, &reg);
475
523
 
476
524
static void rt2800pci_disable_radio(struct rt2x00_dev *rt2x00dev)
477
525
{
478
 
        u32 reg;
479
 
 
480
 
        rt2800_disable_radio(rt2x00dev);
481
 
 
482
 
        rt2800_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00001280);
483
 
 
484
 
        rt2800_register_read(rt2x00dev, WPDMA_RST_IDX, &reg);
485
 
        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX0, 1);
486
 
        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX1, 1);
487
 
        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX2, 1);
488
 
        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX3, 1);
489
 
        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX4, 1);
490
 
        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DTX_IDX5, 1);
491
 
        rt2x00_set_field32(&reg, WPDMA_RST_IDX_DRX_IDX0, 1);
492
 
        rt2800_register_write(rt2x00dev, WPDMA_RST_IDX, reg);
493
 
 
494
 
        rt2800_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00000e1f);
495
 
        rt2800_register_write(rt2x00dev, PBF_SYS_CTRL, 0x00000e00);
 
526
        if (rt2x00_is_soc(rt2x00dev)) {
 
527
                rt2800_disable_radio(rt2x00dev);
 
528
                rt2800_register_write(rt2x00dev, PWR_PIN_CFG, 0);
 
529
                rt2800_register_write(rt2x00dev, TX_PIN_CFG, 0);
 
530
        }
496
531
}
497
532
 
498
533
static int rt2800pci_set_state(struct rt2x00_dev *rt2x00dev,
499
534
                               enum dev_state state)
500
535
{
501
 
        /*
502
 
         * Always put the device to sleep (even when we intend to wakeup!)
503
 
         * if the device is booting and wasn't asleep it will return
504
 
         * failure when attempting to wakeup.
505
 
         */
506
 
        rt2800_mcu_request(rt2x00dev, MCU_SLEEP, 0xff, 0xff, 2);
507
 
 
508
536
        if (state == STATE_AWAKE) {
509
 
                rt2800_mcu_request(rt2x00dev, MCU_WAKEUP, TOKEN_WAKUP, 0, 0);
 
537
                rt2800_mcu_request(rt2x00dev, MCU_WAKEUP, TOKEN_WAKUP, 0, 0x02);
510
538
                rt2800pci_mcu_status(rt2x00dev, TOKEN_WAKUP);
 
539
        } else if (state == STATE_SLEEP) {
 
540
                rt2800_register_write(rt2x00dev, H2M_MAILBOX_STATUS, 0xffffffff);
 
541
                rt2800_register_write(rt2x00dev, H2M_MAILBOX_CID, 0xffffffff);
 
542
                rt2800_mcu_request(rt2x00dev, MCU_SLEEP, 0x01, 0xff, 0x01);
511
543
        }
512
544
 
513
545
        return 0;
538
570
                rt2800pci_set_state(rt2x00dev, STATE_SLEEP);
539
571
                break;
540
572
        case STATE_RADIO_IRQ_ON:
541
 
        case STATE_RADIO_IRQ_ON_ISR:
542
573
        case STATE_RADIO_IRQ_OFF:
543
 
        case STATE_RADIO_IRQ_OFF_ISR:
544
574
                rt2800pci_toggle_irq(rt2x00dev, state);
545
575
                break;
546
576
        case STATE_DEEP_SLEEP:
696
726
 
697
727
        while (kfifo_get(&rt2x00dev->txstatus_fifo, &status)) {
698
728
                qid = rt2x00_get_field32(status, TX_STA_FIFO_PID_QUEUE);
699
 
                if (qid >= QID_RX) {
 
729
                if (unlikely(qid >= QID_RX)) {
700
730
                        /*
701
731
                         * Unknown queue, this shouldn't happen. Just drop
702
732
                         * this tx status.
706
736
                        break;
707
737
                }
708
738
 
709
 
                queue = rt2x00queue_get_queue(rt2x00dev, qid);
 
739
                queue = rt2x00queue_get_tx_queue(rt2x00dev, qid);
710
740
                if (unlikely(queue == NULL)) {
711
741
                        /*
712
742
                         * The queue is NULL, this shouldn't happen. Stop
717
747
                        break;
718
748
                }
719
749
 
720
 
                if (rt2x00queue_empty(queue)) {
 
750
                if (unlikely(rt2x00queue_empty(queue))) {
721
751
                        /*
722
752
                         * The queue is empty. Stop processing here
723
753
                         * and drop the tx status.
732
762
        }
733
763
}
734
764
 
 
765
static void rt2800pci_enable_interrupt(struct rt2x00_dev *rt2x00dev,
 
766
                                       struct rt2x00_field32 irq_field)
 
767
{
 
768
        u32 reg;
 
769
 
 
770
        /*
 
771
         * Enable a single interrupt. The interrupt mask register
 
772
         * access needs locking.
 
773
         */
 
774
        spin_lock_irq(&rt2x00dev->irqmask_lock);
 
775
        rt2800_register_read(rt2x00dev, INT_MASK_CSR, &reg);
 
776
        rt2x00_set_field32(&reg, irq_field, 1);
 
777
        rt2800_register_write(rt2x00dev, INT_MASK_CSR, reg);
 
778
        spin_unlock_irq(&rt2x00dev->irqmask_lock);
 
779
}
 
780
 
735
781
static void rt2800pci_txstatus_tasklet(unsigned long data)
736
782
{
737
783
        rt2800pci_txdone((struct rt2x00_dev *)data);
738
 
}
739
 
 
740
 
static irqreturn_t rt2800pci_interrupt_thread(int irq, void *dev_instance)
741
 
{
742
 
        struct rt2x00_dev *rt2x00dev = dev_instance;
743
 
        u32 reg = rt2x00dev->irqvalue[0];
744
 
 
745
 
        /*
746
 
         * 1 - Pre TBTT interrupt.
747
 
         */
748
 
        if (rt2x00_get_field32(reg, INT_SOURCE_CSR_PRE_TBTT))
749
 
                rt2x00lib_pretbtt(rt2x00dev);
750
 
 
751
 
        /*
752
 
         * 2 - Beacondone interrupt.
753
 
         */
754
 
        if (rt2x00_get_field32(reg, INT_SOURCE_CSR_TBTT))
755
 
                rt2x00lib_beacondone(rt2x00dev);
756
 
 
757
 
        /*
758
 
         * 3 - Rx ring done interrupt.
759
 
         */
760
 
        if (rt2x00_get_field32(reg, INT_SOURCE_CSR_RX_DONE))
761
 
                rt2x00pci_rxdone(rt2x00dev);
762
 
 
763
 
        /*
764
 
         * 4 - Auto wakeup interrupt.
765
 
         */
766
 
        if (rt2x00_get_field32(reg, INT_SOURCE_CSR_AUTO_WAKEUP))
767
 
                rt2800pci_wakeup(rt2x00dev);
768
 
 
769
 
        /* Enable interrupts again. */
770
 
        rt2x00dev->ops->lib->set_device_state(rt2x00dev,
771
 
                                              STATE_RADIO_IRQ_ON_ISR);
772
 
 
773
 
        return IRQ_HANDLED;
 
784
 
 
785
        /*
 
786
         * No need to enable the tx status interrupt here as we always
 
787
         * leave it enabled to minimize the possibility of a tx status
 
788
         * register overflow. See comment in interrupt handler.
 
789
         */
 
790
}
 
791
 
 
792
static void rt2800pci_pretbtt_tasklet(unsigned long data)
 
793
{
 
794
        struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;
 
795
        rt2x00lib_pretbtt(rt2x00dev);
 
796
        rt2800pci_enable_interrupt(rt2x00dev, INT_MASK_CSR_PRE_TBTT);
 
797
}
 
798
 
 
799
static void rt2800pci_tbtt_tasklet(unsigned long data)
 
800
{
 
801
        struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;
 
802
        rt2x00lib_beacondone(rt2x00dev);
 
803
        rt2800pci_enable_interrupt(rt2x00dev, INT_MASK_CSR_TBTT);
 
804
}
 
805
 
 
806
static void rt2800pci_rxdone_tasklet(unsigned long data)
 
807
{
 
808
        struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;
 
809
        rt2x00pci_rxdone(rt2x00dev);
 
810
        rt2800pci_enable_interrupt(rt2x00dev, INT_MASK_CSR_RX_DONE);
 
811
}
 
812
 
 
813
static void rt2800pci_autowake_tasklet(unsigned long data)
 
814
{
 
815
        struct rt2x00_dev *rt2x00dev = (struct rt2x00_dev *)data;
 
816
        rt2800pci_wakeup(rt2x00dev);
 
817
        rt2800pci_enable_interrupt(rt2x00dev, INT_MASK_CSR_AUTO_WAKEUP);
774
818
}
775
819
 
776
820
static void rt2800pci_txstatus_interrupt(struct rt2x00_dev *rt2x00dev)
791
835
         *
792
836
         * Furthermore we don't disable the TX_FIFO_STATUS
793
837
         * interrupt here but leave it enabled so that the TX_STA_FIFO
794
 
         * can also be read while the interrupt thread gets executed.
 
838
         * can also be read while the tx status tasklet gets executed.
795
839
         *
796
840
         * Since we have only one producer and one consumer we don't
797
841
         * need to lock the kfifo.
816
860
static irqreturn_t rt2800pci_interrupt(int irq, void *dev_instance)
817
861
{
818
862
        struct rt2x00_dev *rt2x00dev = dev_instance;
819
 
        u32 reg;
820
 
        irqreturn_t ret = IRQ_HANDLED;
 
863
        u32 reg, mask;
821
864
 
822
865
        /* Read status and ACK all interrupts */
823
866
        rt2800_register_read(rt2x00dev, INT_SOURCE_CSR, &reg);
829
872
        if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
830
873
                return IRQ_HANDLED;
831
874
 
832
 
        if (rt2x00_get_field32(reg, INT_SOURCE_CSR_TX_FIFO_STATUS))
 
875
        /*
 
876
         * Since INT_MASK_CSR and INT_SOURCE_CSR use the same bits
 
877
         * for interrupts and interrupt masks we can just use the value of
 
878
         * INT_SOURCE_CSR to create the interrupt mask.
 
879
         */
 
880
        mask = ~reg;
 
881
 
 
882
        if (rt2x00_get_field32(reg, INT_SOURCE_CSR_TX_FIFO_STATUS)) {
833
883
                rt2800pci_txstatus_interrupt(rt2x00dev);
834
 
 
835
 
        if (rt2x00_get_field32(reg, INT_SOURCE_CSR_PRE_TBTT) ||
836
 
            rt2x00_get_field32(reg, INT_SOURCE_CSR_TBTT) ||
837
 
            rt2x00_get_field32(reg, INT_SOURCE_CSR_RX_DONE) ||
838
 
            rt2x00_get_field32(reg, INT_SOURCE_CSR_AUTO_WAKEUP)) {
839
 
                /*
840
 
                 * All other interrupts are handled in the interrupt thread.
841
 
                 * Store irqvalue for use in the interrupt thread.
842
 
                 */
843
 
                rt2x00dev->irqvalue[0] = reg;
844
 
 
845
 
                /*
846
 
                 * Disable interrupts, will be enabled again in the
847
 
                 * interrupt thread.
848
 
                */
849
 
                rt2x00dev->ops->lib->set_device_state(rt2x00dev,
850
 
                                                      STATE_RADIO_IRQ_OFF_ISR);
851
 
 
852
 
                /*
853
 
                 * Leave the TX_FIFO_STATUS interrupt enabled to not lose any
854
 
                 * tx status reports.
855
 
                 */
856
 
                rt2800_register_read(rt2x00dev, INT_MASK_CSR, &reg);
857
 
                rt2x00_set_field32(&reg, INT_MASK_CSR_TX_FIFO_STATUS, 1);
858
 
                rt2800_register_write(rt2x00dev, INT_MASK_CSR, reg);
859
 
 
860
 
                ret = IRQ_WAKE_THREAD;
 
884
                /*
 
885
                 * Never disable the TX_FIFO_STATUS interrupt.
 
886
                 */
 
887
                rt2x00_set_field32(&mask, INT_MASK_CSR_TX_FIFO_STATUS, 1);
861
888
        }
862
889
 
863
 
        return ret;
 
890
        if (rt2x00_get_field32(reg, INT_SOURCE_CSR_PRE_TBTT))
 
891
                tasklet_hi_schedule(&rt2x00dev->pretbtt_tasklet);
 
892
 
 
893
        if (rt2x00_get_field32(reg, INT_SOURCE_CSR_TBTT))
 
894
                tasklet_hi_schedule(&rt2x00dev->tbtt_tasklet);
 
895
 
 
896
        if (rt2x00_get_field32(reg, INT_SOURCE_CSR_RX_DONE))
 
897
                tasklet_schedule(&rt2x00dev->rxdone_tasklet);
 
898
 
 
899
        if (rt2x00_get_field32(reg, INT_SOURCE_CSR_AUTO_WAKEUP))
 
900
                tasklet_schedule(&rt2x00dev->autowake_tasklet);
 
901
 
 
902
        /*
 
903
         * Disable all interrupts for which a tasklet was scheduled right now,
 
904
         * the tasklet will reenable the appropriate interrupts.
 
905
         */
 
906
        spin_lock(&rt2x00dev->irqmask_lock);
 
907
        rt2800_register_read(rt2x00dev, INT_MASK_CSR, &reg);
 
908
        reg &= mask;
 
909
        rt2800_register_write(rt2x00dev, INT_MASK_CSR, reg);
 
910
        spin_unlock(&rt2x00dev->irqmask_lock);
 
911
 
 
912
        return IRQ_HANDLED;
864
913
}
865
914
 
866
915
/*
928
977
        if (!modparam_nohwcrypt)
929
978
                __set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags);
930
979
        __set_bit(DRIVER_SUPPORT_LINK_TUNING, &rt2x00dev->flags);
 
980
        __set_bit(DRIVER_REQUIRE_HT_TX_DESC, &rt2x00dev->flags);
931
981
 
932
982
        /*
933
983
         * Set the rssi offset.
975
1025
 
976
1026
static const struct rt2x00lib_ops rt2800pci_rt2x00_ops = {
977
1027
        .irq_handler            = rt2800pci_interrupt,
978
 
        .irq_handler_thread     = rt2800pci_interrupt_thread,
979
 
        .txstatus_tasklet       = rt2800pci_txstatus_tasklet,
 
1028
        .txstatus_tasklet       = rt2800pci_txstatus_tasklet,
 
1029
        .pretbtt_tasklet        = rt2800pci_pretbtt_tasklet,
 
1030
        .tbtt_tasklet           = rt2800pci_tbtt_tasklet,
 
1031
        .rxdone_tasklet         = rt2800pci_rxdone_tasklet,
 
1032
        .autowake_tasklet       = rt2800pci_autowake_tasklet,
980
1033
        .probe_hw               = rt2800pci_probe_hw,
981
1034
        .get_firmware_name      = rt2800pci_get_firmware_name,
982
1035
        .check_firmware         = rt2800_check_firmware,
996
1049
        .write_tx_desc          = rt2800pci_write_tx_desc,
997
1050
        .write_tx_data          = rt2800_write_tx_data,
998
1051
        .write_beacon           = rt2800_write_beacon,
 
1052
        .clear_beacon           = rt2800_clear_beacon,
999
1053
        .fill_rxdone            = rt2800pci_fill_rxdone,
1000
1054
        .config_shared_key      = rt2800_config_shared_key,
1001
1055
        .config_pairwise_key    = rt2800_config_pairwise_key,
1079
1133
        { PCI_DEVICE(0x1814, 0x3592), PCI_DEVICE_DATA(&rt2800pci_ops) },
1080
1134
        { PCI_DEVICE(0x1814, 0x3593), PCI_DEVICE_DATA(&rt2800pci_ops) },
1081
1135
#endif
 
1136
#ifdef CONFIG_RT2800PCI_RT53XX
 
1137
        { PCI_DEVICE(0x1814, 0x5390), PCI_DEVICE_DATA(&rt2800pci_ops) },
 
1138
#endif
1082
1139
        { 0, }
1083
1140
};
1084
1141
#endif /* CONFIG_PCI */