← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/net/wireless/zd1211rw/zd_usb.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/wireless/zd1211rw/zd_usb.c
60
60
        { USB_DEVICE(0x157e, 0x300a), .driver_info = DEVICE_ZD1211 },
61
61
        { USB_DEVICE(0x157e, 0x300b), .driver_info = DEVICE_ZD1211 },
62
62
        { USB_DEVICE(0x157e, 0x3204), .driver_info = DEVICE_ZD1211 },
 
63
        { USB_DEVICE(0x157e, 0x3207), .driver_info = DEVICE_ZD1211 },
63
64
        { USB_DEVICE(0x1740, 0x2000), .driver_info = DEVICE_ZD1211 },
64
65
        { USB_DEVICE(0x6891, 0xa727), .driver_info = DEVICE_ZD1211 },
65
66
        /* ZD1211B */
377
378
        int_num = le16_to_cpu(*(__le16 *)(urb->transfer_buffer+2));
378
379
        if (int_num == CR_INTERRUPT) {
379
380
                struct zd_mac *mac = zd_hw_mac(zd_usb_to_hw(urb->context));
 
381
                spin_lock(&mac->lock);
380
382
                memcpy(&mac->intr_buffer, urb->transfer_buffer,
381
383
                                USB_MAX_EP_INT_BUFFER);
 
384
                spin_unlock(&mac->lock);
382
385
                schedule_work(&mac->process_intr);
383
386
        } else if (intr->read_regs_enabled) {
384
387
                intr->read_regs.length = len = urb->actual_length;
409
412
        case -ENOENT:
410
413
        case -ECONNRESET:
411
414
        case -EPIPE:
412
 
                goto kfree;
 
415
                dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
 
416
                return;
413
417
        default:
 
418
                dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
414
419
                goto resubmit;
415
420
        }
416
421
 
441
446
resubmit:
442
447
        r = usb_submit_urb(urb, GFP_ATOMIC);
443
448
        if (r) {
444
 
                dev_dbg_f(urb_dev(urb), "resubmit urb %p\n", urb);
445
 
                goto kfree;
 
449
                dev_dbg_f(urb_dev(urb), "error: resubmit urb %p err code %d\n",
 
450
                          urb, r);
 
451
                /* TODO: add worker to reset intr->urb */
446
452
        }
447
453
        return;
448
 
kfree:
449
 
        kfree(urb->transfer_buffer);
450
454
}
451
455
 
452
456
static inline int int_urb_interval(struct usb_device *udev)
477
481
int zd_usb_enable_int(struct zd_usb *usb)
478
482
{
479
483
        int r;
480
 
        struct usb_device *udev;
 
484
        struct usb_device *udev = zd_usb_to_usbdev(usb);
481
485
        struct zd_usb_interrupt *intr = &usb->intr;
482
 
        void *transfer_buffer = NULL;
483
486
        struct urb *urb;
484
487
 
485
488
        dev_dbg_f(zd_usb_dev(usb), "\n");
500
503
        intr->urb = urb;
501
504
        spin_unlock_irq(&intr->lock);
502
505
 
503
 
        /* TODO: make it a DMA buffer */
504
506
        r = -ENOMEM;
505
 
        transfer_buffer = kmalloc(USB_MAX_EP_INT_BUFFER, GFP_KERNEL);
506
 
        if (!transfer_buffer) {
 
507
        intr->buffer = usb_alloc_coherent(udev, USB_MAX_EP_INT_BUFFER,
 
508
                                          GFP_KERNEL, &intr->buffer_dma);
 
509
        if (!intr->buffer) {
507
510
                dev_dbg_f(zd_usb_dev(usb),
508
511
                        "couldn't allocate transfer_buffer\n");
509
512
                goto error_set_urb_null;
510
513
        }
511
514
 
512
 
        udev = zd_usb_to_usbdev(usb);
513
515
        usb_fill_int_urb(urb, udev, usb_rcvintpipe(udev, EP_INT_IN),
514
 
                         transfer_buffer, USB_MAX_EP_INT_BUFFER,
 
516
                         intr->buffer, USB_MAX_EP_INT_BUFFER,
515
517
                         int_urb_complete, usb,
516
518
                         intr->interval);
 
519
        urb->transfer_dma = intr->buffer_dma;
 
520
        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
517
521
 
518
522
        dev_dbg_f(zd_usb_dev(usb), "submit urb %p\n", intr->urb);
519
523
        r = usb_submit_urb(urb, GFP_KERNEL);
525
529
 
526
530
        return 0;
527
531
error:
528
 
        kfree(transfer_buffer);
 
532
        usb_free_coherent(udev, USB_MAX_EP_INT_BUFFER,
 
533
                          intr->buffer, intr->buffer_dma);
529
534
error_set_urb_null:
530
535
        spin_lock_irq(&intr->lock);
531
536
        intr->urb = NULL;
539
544
void zd_usb_disable_int(struct zd_usb *usb)
540
545
{
541
546
        unsigned long flags;
 
547
        struct usb_device *udev = zd_usb_to_usbdev(usb);
542
548
        struct zd_usb_interrupt *intr = &usb->intr;
543
549
        struct urb *urb;
 
550
        void *buffer;
 
551
        dma_addr_t buffer_dma;
544
552
 
545
553
        spin_lock_irqsave(&intr->lock, flags);
546
554
        urb = intr->urb;
549
557
                return;
550
558
        }
551
559
        intr->urb = NULL;
 
560
        buffer = intr->buffer;
 
561
        buffer_dma = intr->buffer_dma;
 
562
        intr->buffer = NULL;
552
563
        spin_unlock_irqrestore(&intr->lock, flags);
553
564
 
554
565
        usb_kill_urb(urb);
555
566
        dev_dbg_f(zd_usb_dev(usb), "urb %p killed\n", urb);
556
567
        usb_free_urb(urb);
 
568
 
 
569
        if (buffer)
 
570
                usb_free_coherent(udev, USB_MAX_EP_INT_BUFFER,
 
571
                                  buffer, buffer_dma);
557
572
}
558
573
 
559
574
static void handle_rx_packet(struct zd_usb *usb, const u8 *buffer,
601
616
 
602
617
static void rx_urb_complete(struct urb *urb)
603
618
{
 
619
        int r;
604
620
        struct zd_usb *usb;
605
621
        struct zd_usb_rx *rx;
606
622
        const u8 *buffer;
615
631
        case -ENOENT:
616
632
        case -ECONNRESET:
617
633
        case -EPIPE:
 
634
                dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
618
635
                return;
619
636
        default:
620
637
                dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
626
643
        usb = urb->context;
627
644
        rx = &usb->rx;
628
645
 
 
646
        tasklet_schedule(&rx->reset_timer_tasklet);
 
647
 
629
648
        if (length%rx->usb_packet_size > rx->usb_packet_size-4) {
630
649
                /* If there is an old first fragment, we don't care. */
631
650
                dev_dbg_f(urb_dev(urb), "*** first fragment ***\n");
654
673
        }
655
674
 
656
675
resubmit:
657
 
        usb_submit_urb(urb, GFP_ATOMIC);
 
676
        r = usb_submit_urb(urb, GFP_ATOMIC);
 
677
        if (r)
 
678
                dev_dbg_f(urb_dev(urb), "urb %p resubmit error %d\n", urb, r);
658
679
}
659
680
 
660
681
static struct urb *alloc_rx_urb(struct zd_usb *usb)
690
711
        usb_free_urb(urb);
691
712
}
692
713
 
693
 
int zd_usb_enable_rx(struct zd_usb *usb)
 
714
static int __zd_usb_enable_rx(struct zd_usb *usb)
694
715
{
695
716
        int i, r;
696
717
        struct zd_usb_rx *rx = &usb->rx;
742
763
        return r;
743
764
}
744
765
 
745
 
void zd_usb_disable_rx(struct zd_usb *usb)
 
766
int zd_usb_enable_rx(struct zd_usb *usb)
 
767
{
 
768
        int r;
 
769
        struct zd_usb_rx *rx = &usb->rx;
 
770
 
 
771
        mutex_lock(&rx->setup_mutex);
 
772
        r = __zd_usb_enable_rx(usb);
 
773
        mutex_unlock(&rx->setup_mutex);
 
774
 
 
775
        zd_usb_reset_rx_idle_timer(usb);
 
776
 
 
777
        return r;
 
778
}
 
779
 
 
780
static void __zd_usb_disable_rx(struct zd_usb *usb)
746
781
{
747
782
        int i;
748
783
        unsigned long flags;
769
804
        spin_unlock_irqrestore(&rx->lock, flags);
770
805
}
771
806
 
 
807
void zd_usb_disable_rx(struct zd_usb *usb)
 
808
{
 
809
        struct zd_usb_rx *rx = &usb->rx;
 
810
 
 
811
        mutex_lock(&rx->setup_mutex);
 
812
        __zd_usb_disable_rx(usb);
 
813
        mutex_unlock(&rx->setup_mutex);
 
814
 
 
815
        tasklet_kill(&rx->reset_timer_tasklet);
 
816
        cancel_delayed_work_sync(&rx->idle_work);
 
817
}
 
818
 
 
819
static void zd_usb_reset_rx(struct zd_usb *usb)
 
820
{
 
821
        bool do_reset;
 
822
        struct zd_usb_rx *rx = &usb->rx;
 
823
        unsigned long flags;
 
824
 
 
825
        mutex_lock(&rx->setup_mutex);
 
826
 
 
827
        spin_lock_irqsave(&rx->lock, flags);
 
828
        do_reset = rx->urbs != NULL;
 
829
        spin_unlock_irqrestore(&rx->lock, flags);
 
830
 
 
831
        if (do_reset) {
 
832
                __zd_usb_disable_rx(usb);
 
833
                __zd_usb_enable_rx(usb);
 
834
        }
 
835
 
 
836
        mutex_unlock(&rx->setup_mutex);
 
837
 
 
838
        if (do_reset)
 
839
                zd_usb_reset_rx_idle_timer(usb);
 
840
}
 
841
 
772
842
/**
773
843
 * zd_usb_disable_tx - disable transmission
774
844
 * @usb: the zd1211rw-private USB structure
779
849
{
780
850
        struct zd_usb_tx *tx = &usb->tx;
781
851
        unsigned long flags;
782
 
        struct list_head *pos, *n;
 
852
 
 
853
        atomic_set(&tx->enabled, 0);
 
854
 
 
855
        /* kill all submitted tx-urbs */
 
856
        usb_kill_anchored_urbs(&tx->submitted);
783
857
 
784
858
        spin_lock_irqsave(&tx->lock, flags);
785
 
        list_for_each_safe(pos, n, &tx->free_urb_list) {
786
 
                list_del(pos);
787
 
                usb_free_urb(list_entry(pos, struct urb, urb_list));
788
 
        }
789
 
        tx->enabled = 0;
 
859
        WARN_ON(!skb_queue_empty(&tx->submitted_skbs));
 
860
        WARN_ON(tx->submitted_urbs != 0);
790
861
        tx->submitted_urbs = 0;
 
862
        spin_unlock_irqrestore(&tx->lock, flags);
 
863
 
791
864
        /* The stopped state is ignored, relying on ieee80211_wake_queues()
792
865
         * in a potentionally following zd_usb_enable_tx().
793
866
         */
794
 
        spin_unlock_irqrestore(&tx->lock, flags);
795
867
}
796
868
 
797
869
/**
807
879
        struct zd_usb_tx *tx = &usb->tx;
808
880
 
809
881
        spin_lock_irqsave(&tx->lock, flags);
810
 
        tx->enabled = 1;
 
882
        atomic_set(&tx->enabled, 1);
811
883
        tx->submitted_urbs = 0;
812
884
        ieee80211_wake_queues(zd_usb_to_hw(usb));
813
885
        tx->stopped = 0;
814
886
        spin_unlock_irqrestore(&tx->lock, flags);
815
887
}
816
888
 
817
 
/**
818
 
 * alloc_tx_urb - provides an tx URB
819
 
 * @usb: a &struct zd_usb pointer
820
 
 *
821
 
 * Allocates a new URB. If possible takes the urb from the free list in
822
 
 * usb->tx.
823
 
 */
824
 
static struct urb *alloc_tx_urb(struct zd_usb *usb)
825
 
{
826
 
        struct zd_usb_tx *tx = &usb->tx;
827
 
        unsigned long flags;
828
 
        struct list_head *entry;
829
 
        struct urb *urb;
830
 
 
831
 
        spin_lock_irqsave(&tx->lock, flags);
832
 
        if (list_empty(&tx->free_urb_list)) {
833
 
                urb = usb_alloc_urb(0, GFP_ATOMIC);
834
 
                goto out;
835
 
        }
836
 
        entry = tx->free_urb_list.next;
837
 
        list_del(entry);
838
 
        urb = list_entry(entry, struct urb, urb_list);
839
 
out:
840
 
        spin_unlock_irqrestore(&tx->lock, flags);
841
 
        return urb;
842
 
}
843
 
 
844
 
/**
845
 
 * free_tx_urb - frees a used tx URB
846
 
 * @usb: a &struct zd_usb pointer
847
 
 * @urb: URB to be freed
848
 
 *
849
 
 * Frees the transmission URB, which means to put it on the free URB
850
 
 * list.
851
 
 */
852
 
static void free_tx_urb(struct zd_usb *usb, struct urb *urb)
853
 
{
854
 
        struct zd_usb_tx *tx = &usb->tx;
855
 
        unsigned long flags;
856
 
 
857
 
        spin_lock_irqsave(&tx->lock, flags);
858
 
        if (!tx->enabled) {
859
 
                usb_free_urb(urb);
860
 
                goto out;
861
 
        }
862
 
        list_add(&urb->urb_list, &tx->free_urb_list);
863
 
out:
864
 
        spin_unlock_irqrestore(&tx->lock, flags);
865
 
}
866
 
 
867
889
static void tx_dec_submitted_urbs(struct zd_usb *usb)
868
890
{
869
891
        struct zd_usb_tx *tx = &usb->tx;
905
927
        struct sk_buff *skb;
906
928
        struct ieee80211_tx_info *info;
907
929
        struct zd_usb *usb;
 
930
        struct zd_usb_tx *tx;
908
931
 
909
 
        switch (urb->status) {
910
 
        case 0:
911
 
                break;
912
 
        case -ESHUTDOWN:
913
 
        case -EINVAL:
914
 
        case -ENODEV:
915
 
        case -ENOENT:
916
 
        case -ECONNRESET:
917
 
        case -EPIPE:
918
 
                dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
919
 
                break;
920
 
        default:
921
 
                dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
922
 
                goto resubmit;
923
 
        }
924
 
free_urb:
925
932
        skb = (struct sk_buff *)urb->context;
 
933
        info = IEEE80211_SKB_CB(skb);
926
934
        /*
927
935
         * grab 'usb' pointer before handing off the skb (since
928
936
         * it might be freed by zd_mac_tx_to_dev or mac80211)
929
937
         */
930
 
        info = IEEE80211_SKB_CB(skb);
931
938
        usb = &zd_hw_mac(info->rate_driver_data[0])->chip.usb;
 
939
        tx = &usb->tx;
 
940
 
 
941
        switch (urb->status) {
 
942
        case 0:
 
943
                break;
 
944
        case -ESHUTDOWN:
 
945
        case -EINVAL:
 
946
        case -ENODEV:
 
947
        case -ENOENT:
 
948
        case -ECONNRESET:
 
949
        case -EPIPE:
 
950
                dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
 
951
                break;
 
952
        default:
 
953
                dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
 
954
                goto resubmit;
 
955
        }
 
956
free_urb:
 
957
        skb_unlink(skb, &usb->tx.submitted_skbs);
932
958
        zd_mac_tx_to_dev(skb, urb->status);
933
 
        free_tx_urb(usb, urb);
 
959
        usb_free_urb(urb);
934
960
        tx_dec_submitted_urbs(usb);
935
961
        return;
936
962
resubmit:
 
963
        usb_anchor_urb(urb, &tx->submitted);
937
964
        r = usb_submit_urb(urb, GFP_ATOMIC);
938
965
        if (r) {
 
966
                usb_unanchor_urb(urb);
939
967
                dev_dbg_f(urb_dev(urb), "error resubmit urb %p %d\n", urb, r);
940
968
                goto free_urb;
941
969
        }
956
984
int zd_usb_tx(struct zd_usb *usb, struct sk_buff *skb)
957
985
{
958
986
        int r;
 
987
        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
959
988
        struct usb_device *udev = zd_usb_to_usbdev(usb);
960
989
        struct urb *urb;
961
 
 
962
 
        urb = alloc_tx_urb(usb);
 
990
        struct zd_usb_tx *tx = &usb->tx;
 
991
 
 
992
        if (!atomic_read(&tx->enabled)) {
 
993
                r = -ENOENT;
 
994
                goto out;
 
995
        }
 
996
 
 
997
        urb = usb_alloc_urb(0, GFP_ATOMIC);
963
998
        if (!urb) {
964
999
                r = -ENOMEM;
965
1000
                goto out;
968
1003
        usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, EP_DATA_OUT),
969
1004
                          skb->data, skb->len, tx_urb_complete, skb);
970
1005
 
 
1006
        info->rate_driver_data[1] = (void *)jiffies;
 
1007
        skb_queue_tail(&tx->submitted_skbs, skb);
 
1008
        usb_anchor_urb(urb, &tx->submitted);
 
1009
 
971
1010
        r = usb_submit_urb(urb, GFP_ATOMIC);
972
 
        if (r)
 
1011
        if (r) {
 
1012
                dev_dbg_f(zd_usb_dev(usb), "error submit urb %p %d\n", urb, r);
 
1013
                usb_unanchor_urb(urb);
 
1014
                skb_unlink(skb, &tx->submitted_skbs);
973
1015
                goto error;
 
1016
        }
974
1017
        tx_inc_submitted_urbs(usb);
975
1018
        return 0;
976
1019
error:
977
 
        free_tx_urb(usb, urb);
 
1020
        usb_free_urb(urb);
978
1021
out:
979
1022
        return r;
980
1023
}
981
1024
 
 
1025
static bool zd_tx_timeout(struct zd_usb *usb)
 
1026
{
 
1027
        struct zd_usb_tx *tx = &usb->tx;
 
1028
        struct sk_buff_head *q = &tx->submitted_skbs;
 
1029
        struct sk_buff *skb, *skbnext;
 
1030
        struct ieee80211_tx_info *info;
 
1031
        unsigned long flags, trans_start;
 
1032
        bool have_timedout = false;
 
1033
 
 
1034
        spin_lock_irqsave(&q->lock, flags);
 
1035
        skb_queue_walk_safe(q, skb, skbnext) {
 
1036
                info = IEEE80211_SKB_CB(skb);
 
1037
                trans_start = (unsigned long)info->rate_driver_data[1];
 
1038
 
 
1039
                if (time_is_before_jiffies(trans_start + ZD_TX_TIMEOUT)) {
 
1040
                        have_timedout = true;
 
1041
                        break;
 
1042
                }
 
1043
        }
 
1044
        spin_unlock_irqrestore(&q->lock, flags);
 
1045
 
 
1046
        return have_timedout;
 
1047
}
 
1048
 
 
1049
static void zd_tx_watchdog_handler(struct work_struct *work)
 
1050
{
 
1051
        struct zd_usb *usb =
 
1052
                container_of(work, struct zd_usb, tx.watchdog_work.work);
 
1053
        struct zd_usb_tx *tx = &usb->tx;
 
1054
 
 
1055
        if (!atomic_read(&tx->enabled) || !tx->watchdog_enabled)
 
1056
                goto out;
 
1057
        if (!zd_tx_timeout(usb))
 
1058
                goto out;
 
1059
 
 
1060
        /* TX halted, try reset */
 
1061
        dev_warn(zd_usb_dev(usb), "TX-stall detected, reseting device...");
 
1062
 
 
1063
        usb_queue_reset_device(usb->intf);
 
1064
 
 
1065
        /* reset will stop this worker, don't rearm */
 
1066
        return;
 
1067
out:
 
1068
        queue_delayed_work(zd_workqueue, &tx->watchdog_work,
 
1069
                           ZD_TX_WATCHDOG_INTERVAL);
 
1070
}
 
1071
 
 
1072
void zd_tx_watchdog_enable(struct zd_usb *usb)
 
1073
{
 
1074
        struct zd_usb_tx *tx = &usb->tx;
 
1075
 
 
1076
        if (!tx->watchdog_enabled) {
 
1077
                dev_dbg_f(zd_usb_dev(usb), "\n");
 
1078
                queue_delayed_work(zd_workqueue, &tx->watchdog_work,
 
1079
                                   ZD_TX_WATCHDOG_INTERVAL);
 
1080
                tx->watchdog_enabled = 1;
 
1081
        }
 
1082
}
 
1083
 
 
1084
void zd_tx_watchdog_disable(struct zd_usb *usb)
 
1085
{
 
1086
        struct zd_usb_tx *tx = &usb->tx;
 
1087
 
 
1088
        if (tx->watchdog_enabled) {
 
1089
                dev_dbg_f(zd_usb_dev(usb), "\n");
 
1090
                tx->watchdog_enabled = 0;
 
1091
                cancel_delayed_work_sync(&tx->watchdog_work);
 
1092
        }
 
1093
}
 
1094
 
 
1095
static void zd_rx_idle_timer_handler(struct work_struct *work)
 
1096
{
 
1097
        struct zd_usb *usb =
 
1098
                container_of(work, struct zd_usb, rx.idle_work.work);
 
1099
        struct zd_mac *mac = zd_usb_to_mac(usb);
 
1100
 
 
1101
        if (!test_bit(ZD_DEVICE_RUNNING, &mac->flags))
 
1102
                return;
 
1103
 
 
1104
        dev_dbg_f(zd_usb_dev(usb), "\n");
 
1105
 
 
1106
        /* 30 seconds since last rx, reset rx */
 
1107
        zd_usb_reset_rx(usb);
 
1108
}
 
1109
 
 
1110
static void zd_usb_reset_rx_idle_timer_tasklet(unsigned long param)
 
1111
{
 
1112
        struct zd_usb *usb = (struct zd_usb *)param;
 
1113
 
 
1114
        zd_usb_reset_rx_idle_timer(usb);
 
1115
}
 
1116
 
 
1117
void zd_usb_reset_rx_idle_timer(struct zd_usb *usb)
 
1118
{
 
1119
        struct zd_usb_rx *rx = &usb->rx;
 
1120
 
 
1121
        cancel_delayed_work(&rx->idle_work);
 
1122
        queue_delayed_work(zd_workqueue, &rx->idle_work, ZD_RX_IDLE_INTERVAL);
 
1123
}
 
1124
 
982
1125
static inline void init_usb_interrupt(struct zd_usb *usb)
983
1126
{
984
1127
        struct zd_usb_interrupt *intr = &usb->intr;
992
1135
static inline void init_usb_rx(struct zd_usb *usb)
993
1136
{
994
1137
        struct zd_usb_rx *rx = &usb->rx;
 
1138
 
995
1139
        spin_lock_init(&rx->lock);
 
1140
        mutex_init(&rx->setup_mutex);
996
1141
        if (interface_to_usbdev(usb->intf)->speed == USB_SPEED_HIGH) {
997
1142
                rx->usb_packet_size = 512;
998
1143
        } else {
999
1144
                rx->usb_packet_size = 64;
1000
1145
        }
1001
1146
        ZD_ASSERT(rx->fragment_length == 0);
 
1147
        INIT_DELAYED_WORK(&rx->idle_work, zd_rx_idle_timer_handler);
 
1148
        rx->reset_timer_tasklet.func = zd_usb_reset_rx_idle_timer_tasklet;
 
1149
        rx->reset_timer_tasklet.data = (unsigned long)usb;
1002
1150
}
1003
1151
 
1004
1152
static inline void init_usb_tx(struct zd_usb *usb)
1005
1153
{
1006
1154
        struct zd_usb_tx *tx = &usb->tx;
 
1155
 
1007
1156
        spin_lock_init(&tx->lock);
1008
 
        tx->enabled = 0;
 
1157
        atomic_set(&tx->enabled, 0);
1009
1158
        tx->stopped = 0;
1010
 
        INIT_LIST_HEAD(&tx->free_urb_list);
 
1159
        skb_queue_head_init(&tx->submitted_skbs);
 
1160
        init_usb_anchor(&tx->submitted);
1011
1161
        tx->submitted_urbs = 0;
 
1162
        tx->watchdog_enabled = 0;
 
1163
        INIT_DELAYED_WORK(&tx->watchdog_work, zd_tx_watchdog_handler);
1012
1164
}
1013
1165
 
1014
1166
void zd_usb_init(struct zd_usb *usb, struct ieee80211_hw *hw,
1017
1169
        memset(usb, 0, sizeof(*usb));
1018
1170
        usb->intf = usb_get_intf(intf);
1019
1171
        usb_set_intfdata(usb->intf, hw);
 
1172
        init_usb_anchor(&usb->submitted_cmds);
1020
1173
        init_usb_interrupt(usb);
1021
1174
        init_usb_tx(usb);
1022
1175
        init_usb_rx(usb);
1240
1393
        ieee80211_unregister_hw(hw);
1241
1394
 
1242
1395
        /* Just in case something has gone wrong! */
 
1396
        zd_usb_disable_tx(usb);
1243
1397
        zd_usb_disable_rx(usb);
1244
1398
        zd_usb_disable_int(usb);
1245
1399
 
1255
1409
        dev_dbg(&intf->dev, "disconnected\n");
1256
1410
}
1257
1411
 
 
1412
static void zd_usb_resume(struct zd_usb *usb)
 
1413
{
 
1414
        struct zd_mac *mac = zd_usb_to_mac(usb);
 
1415
        int r;
 
1416
 
 
1417
        dev_dbg_f(zd_usb_dev(usb), "\n");
 
1418
 
 
1419
        r = zd_op_start(zd_usb_to_hw(usb));
 
1420
        if (r < 0) {
 
1421
                dev_warn(zd_usb_dev(usb), "Device resume failed "
 
1422
                         "with error code %d. Retrying...\n", r);
 
1423
                if (usb->was_running)
 
1424
                        set_bit(ZD_DEVICE_RUNNING, &mac->flags);
 
1425
                usb_queue_reset_device(usb->intf);
 
1426
                return;
 
1427
        }
 
1428
 
 
1429
        if (mac->type != NL80211_IFTYPE_UNSPECIFIED) {
 
1430
                r = zd_restore_settings(mac);
 
1431
                if (r < 0) {
 
1432
                        dev_dbg(zd_usb_dev(usb),
 
1433
                                "failed to restore settings, %d\n", r);
 
1434
                        return;
 
1435
                }
 
1436
        }
 
1437
}
 
1438
 
 
1439
static void zd_usb_stop(struct zd_usb *usb)
 
1440
{
 
1441
        dev_dbg_f(zd_usb_dev(usb), "\n");
 
1442
 
 
1443
        zd_op_stop(zd_usb_to_hw(usb));
 
1444
 
 
1445
        zd_usb_disable_tx(usb);
 
1446
        zd_usb_disable_rx(usb);
 
1447
        zd_usb_disable_int(usb);
 
1448
 
 
1449
        usb->initialized = 0;
 
1450
}
 
1451
 
 
1452
static int pre_reset(struct usb_interface *intf)
 
1453
{
 
1454
        struct ieee80211_hw *hw = usb_get_intfdata(intf);
 
1455
        struct zd_mac *mac;
 
1456
        struct zd_usb *usb;
 
1457
 
 
1458
        if (!hw || intf->condition != USB_INTERFACE_BOUND)
 
1459
                return 0;
 
1460
 
 
1461
        mac = zd_hw_mac(hw);
 
1462
        usb = &mac->chip.usb;
 
1463
 
 
1464
        usb->was_running = test_bit(ZD_DEVICE_RUNNING, &mac->flags);
 
1465
 
 
1466
        zd_usb_stop(usb);
 
1467
 
 
1468
        mutex_lock(&mac->chip.mutex);
 
1469
        return 0;
 
1470
}
 
1471
 
 
1472
static int post_reset(struct usb_interface *intf)
 
1473
{
 
1474
        struct ieee80211_hw *hw = usb_get_intfdata(intf);
 
1475
        struct zd_mac *mac;
 
1476
        struct zd_usb *usb;
 
1477
 
 
1478
        if (!hw || intf->condition != USB_INTERFACE_BOUND)
 
1479
                return 0;
 
1480
 
 
1481
        mac = zd_hw_mac(hw);
 
1482
        usb = &mac->chip.usb;
 
1483
 
 
1484
        mutex_unlock(&mac->chip.mutex);
 
1485
 
 
1486
        if (usb->was_running)
 
1487
                zd_usb_resume(usb);
 
1488
        return 0;
 
1489
}
 
1490
 
1258
1491
static struct usb_driver driver = {
1259
1492
        .name           = KBUILD_MODNAME,
1260
1493
        .id_table       = usb_ids,
1261
1494
        .probe          = probe,
1262
1495
        .disconnect     = disconnect,
 
1496
        .pre_reset      = pre_reset,
 
1497
        .post_reset     = post_reset,
1263
1498
};
1264
1499
 
1265
1500
struct workqueue_struct *zd_workqueue;
1298
1533
module_init(usb_init);
1299
1534
module_exit(usb_exit);
1300
1535
 
 
1536
static int zd_ep_regs_out_msg(struct usb_device *udev, void *data, int len,
 
1537
                              int *actual_length, int timeout)
 
1538
{
 
1539
        /* In USB 2.0 mode EP_REGS_OUT endpoint is interrupt type. However in
 
1540
         * USB 1.1 mode endpoint is bulk. Select correct type URB by endpoint
 
1541
         * descriptor.
 
1542
         */
 
1543
        struct usb_host_endpoint *ep;
 
1544
        unsigned int pipe;
 
1545
 
 
1546
        pipe = usb_sndintpipe(udev, EP_REGS_OUT);
 
1547
        ep = usb_pipe_endpoint(udev, pipe);
 
1548
        if (!ep)
 
1549
                return -EINVAL;
 
1550
 
 
1551
        if (usb_endpoint_xfer_int(&ep->desc)) {
 
1552
                return usb_interrupt_msg(udev, pipe, data, len,
 
1553
                                         actual_length, timeout);
 
1554
        } else {
 
1555
                pipe = usb_sndbulkpipe(udev, EP_REGS_OUT);
 
1556
                return usb_bulk_msg(udev, pipe, data, len, actual_length,
 
1557
                                    timeout);
 
1558
        }
 
1559
}
 
1560
 
1301
1561
static int usb_int_regs_length(unsigned int count)
1302
1562
{
1303
1563
        return sizeof(struct usb_int_regs) + count * sizeof(struct reg_data);
1393
1653
                return -EWOULDBLOCK;
1394
1654
        }
1395
1655
        if (!usb_int_enabled(usb)) {
1396
 
                 dev_dbg_f(zd_usb_dev(usb),
 
1656
                dev_dbg_f(zd_usb_dev(usb),
1397
1657
                          "error: usb interrupt not enabled\n");
1398
1658
                return -EWOULDBLOCK;
1399
1659
        }
1400
1660
 
 
1661
        ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
 
1662
        BUILD_BUG_ON(sizeof(struct usb_req_read_regs) + USB_MAX_IOREAD16_COUNT *
 
1663
                     sizeof(__le16) > sizeof(usb->req_buf));
 
1664
        BUG_ON(sizeof(struct usb_req_read_regs) + count * sizeof(__le16) >
 
1665
               sizeof(usb->req_buf));
 
1666
 
1401
1667
        req_len = sizeof(struct usb_req_read_regs) + count * sizeof(__le16);
1402
 
        req = kmalloc(req_len, GFP_KERNEL);
1403
 
        if (!req)
1404
 
                return -ENOMEM;
 
1668
        req = (void *)usb->req_buf;
 
1669
 
1405
1670
        req->id = cpu_to_le16(USB_REQ_READ_REGS);
1406
1671
        for (i = 0; i < count; i++)
1407
1672
                req->addr[i] = cpu_to_le16((u16)addresses[i]);
1408
1673
 
1409
1674
        udev = zd_usb_to_usbdev(usb);
1410
1675
        prepare_read_regs_int(usb);
1411
 
        r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, EP_REGS_OUT),
1412
 
                         req, req_len, &actual_req_len, 1000 /* ms */);
 
1676
        r = zd_ep_regs_out_msg(udev, req, req_len, &actual_req_len, 50 /*ms*/);
1413
1677
        if (r) {
1414
1678
                dev_dbg_f(zd_usb_dev(usb),
1415
 
                        "error in usb_bulk_msg(). Error number %d\n", r);
 
1679
                        "error in zd_ep_regs_out_msg(). Error number %d\n", r);
1416
1680
                goto error;
1417
1681
        }
1418
1682
        if (req_len != actual_req_len) {
1419
 
                dev_dbg_f(zd_usb_dev(usb), "error in usb_bulk_msg()\n"
 
1683
                dev_dbg_f(zd_usb_dev(usb), "error in zd_ep_regs_out_msg()\n"
1420
1684
                        " req_len %d != actual_req_len %d\n",
1421
1685
                        req_len, actual_req_len);
1422
1686
                r = -EIO;
1424
1688
        }
1425
1689
 
1426
1690
        timeout = wait_for_completion_timeout(&usb->intr.read_regs.completion,
1427
 
                                              msecs_to_jiffies(1000));
 
1691
                                              msecs_to_jiffies(50));
1428
1692
        if (!timeout) {
1429
1693
                disable_read_regs_int(usb);
1430
1694
                dev_dbg_f(zd_usb_dev(usb), "read timed out\n");
1434
1698
 
1435
1699
        r = get_results(usb, values, req, count);
1436
1700
error:
1437
 
        kfree(req);
1438
 
        return r;
1439
 
}
1440
 
 
1441
 
int zd_usb_iowrite16v(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
1442
 
                      unsigned int count)
 
1701
        return r;
 
1702
}
 
1703
 
 
1704
static void iowrite16v_urb_complete(struct urb *urb)
 
1705
{
 
1706
        struct zd_usb *usb = urb->context;
 
1707
 
 
1708
        if (urb->status && !usb->cmd_error)
 
1709
                usb->cmd_error = urb->status;
 
1710
 
 
1711
        if (!usb->cmd_error &&
 
1712
                        urb->actual_length != urb->transfer_buffer_length)
 
1713
                usb->cmd_error = -EIO;
 
1714
}
 
1715
 
 
1716
static int zd_submit_waiting_urb(struct zd_usb *usb, bool last)
 
1717
{
 
1718
        int r = 0;
 
1719
        struct urb *urb = usb->urb_async_waiting;
 
1720
 
 
1721
        if (!urb)
 
1722
                return 0;
 
1723
 
 
1724
        usb->urb_async_waiting = NULL;
 
1725
 
 
1726
        if (!last)
 
1727
                urb->transfer_flags |= URB_NO_INTERRUPT;
 
1728
 
 
1729
        usb_anchor_urb(urb, &usb->submitted_cmds);
 
1730
        r = usb_submit_urb(urb, GFP_KERNEL);
 
1731
        if (r) {
 
1732
                usb_unanchor_urb(urb);
 
1733
                dev_dbg_f(zd_usb_dev(usb),
 
1734
                        "error in usb_submit_urb(). Error number %d\n", r);
 
1735
                goto error;
 
1736
        }
 
1737
 
 
1738
        /* fall-through with r == 0 */
 
1739
error:
 
1740
        usb_free_urb(urb);
 
1741
        return r;
 
1742
}
 
1743
 
 
1744
void zd_usb_iowrite16v_async_start(struct zd_usb *usb)
 
1745
{
 
1746
        ZD_ASSERT(usb_anchor_empty(&usb->submitted_cmds));
 
1747
        ZD_ASSERT(usb->urb_async_waiting == NULL);
 
1748
        ZD_ASSERT(!usb->in_async);
 
1749
 
 
1750
        ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
 
1751
 
 
1752
        usb->in_async = 1;
 
1753
        usb->cmd_error = 0;
 
1754
        usb->urb_async_waiting = NULL;
 
1755
}
 
1756
 
 
1757
int zd_usb_iowrite16v_async_end(struct zd_usb *usb, unsigned int timeout)
 
1758
{
 
1759
        int r;
 
1760
 
 
1761
        ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
 
1762
        ZD_ASSERT(usb->in_async);
 
1763
 
 
1764
        /* Submit last iowrite16v URB */
 
1765
        r = zd_submit_waiting_urb(usb, true);
 
1766
        if (r) {
 
1767
                dev_dbg_f(zd_usb_dev(usb),
 
1768
                        "error in zd_submit_waiting_usb(). "
 
1769
                        "Error number %d\n", r);
 
1770
 
 
1771
                usb_kill_anchored_urbs(&usb->submitted_cmds);
 
1772
                goto error;
 
1773
        }
 
1774
 
 
1775
        if (timeout)
 
1776
                timeout = usb_wait_anchor_empty_timeout(&usb->submitted_cmds,
 
1777
                                                        timeout);
 
1778
        if (!timeout) {
 
1779
                usb_kill_anchored_urbs(&usb->submitted_cmds);
 
1780
                if (usb->cmd_error == -ENOENT) {
 
1781
                        dev_dbg_f(zd_usb_dev(usb), "timed out");
 
1782
                        r = -ETIMEDOUT;
 
1783
                        goto error;
 
1784
                }
 
1785
        }
 
1786
 
 
1787
        r = usb->cmd_error;
 
1788
error:
 
1789
        usb->in_async = 0;
 
1790
        return r;
 
1791
}
 
1792
 
 
1793
int zd_usb_iowrite16v_async(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
 
1794
                            unsigned int count)
1443
1795
{
1444
1796
        int r;
1445
1797
        struct usb_device *udev;
1446
1798
        struct usb_req_write_regs *req = NULL;
1447
 
        int i, req_len, actual_req_len;
 
1799
        int i, req_len;
 
1800
        struct urb *urb;
 
1801
        struct usb_host_endpoint *ep;
 
1802
 
 
1803
        ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
 
1804
        ZD_ASSERT(usb->in_async);
1448
1805
 
1449
1806
        if (count == 0)
1450
1807
                return 0;
1460
1817
                return -EWOULDBLOCK;
1461
1818
        }
1462
1819
 
 
1820
        udev = zd_usb_to_usbdev(usb);
 
1821
 
 
1822
        ep = usb_pipe_endpoint(udev, usb_sndintpipe(udev, EP_REGS_OUT));
 
1823
        if (!ep)
 
1824
                return -ENOENT;
 
1825
 
 
1826
        urb = usb_alloc_urb(0, GFP_KERNEL);
 
1827
        if (!urb)
 
1828
                return -ENOMEM;
 
1829
 
1463
1830
        req_len = sizeof(struct usb_req_write_regs) +
1464
1831
                  count * sizeof(struct reg_data);
1465
1832
        req = kmalloc(req_len, GFP_KERNEL);
1466
 
        if (!req)
1467
 
                return -ENOMEM;
 
1833
        if (!req) {
 
1834
                r = -ENOMEM;
 
1835
                goto error;
 
1836
        }
1468
1837
 
1469
1838
        req->id = cpu_to_le16(USB_REQ_WRITE_REGS);
1470
1839
        for (i = 0; i < count; i++) {
1473
1842
                rw->value = cpu_to_le16(ioreqs[i].value);
1474
1843
        }
1475
1844
 
1476
 
        udev = zd_usb_to_usbdev(usb);
1477
 
        r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, EP_REGS_OUT),
1478
 
                         req, req_len, &actual_req_len, 1000 /* ms */);
 
1845
        /* In USB 2.0 mode endpoint is interrupt type. However in USB 1.1 mode
 
1846
         * endpoint is bulk. Select correct type URB by endpoint descriptor.
 
1847
         */
 
1848
        if (usb_endpoint_xfer_int(&ep->desc))
 
1849
                usb_fill_int_urb(urb, udev, usb_sndintpipe(udev, EP_REGS_OUT),
 
1850
                                 req, req_len, iowrite16v_urb_complete, usb,
 
1851
                                 ep->desc.bInterval);
 
1852
        else
 
1853
                usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, EP_REGS_OUT),
 
1854
                                  req, req_len, iowrite16v_urb_complete, usb);
 
1855
 
 
1856
        urb->transfer_flags |= URB_FREE_BUFFER;
 
1857
 
 
1858
        /* Submit previous URB */
 
1859
        r = zd_submit_waiting_urb(usb, false);
1479
1860
        if (r) {
1480
1861
                dev_dbg_f(zd_usb_dev(usb),
1481
 
                        "error in usb_bulk_msg(). Error number %d\n", r);
1482
 
                goto error;
1483
 
        }
1484
 
        if (req_len != actual_req_len) {
1485
 
                dev_dbg_f(zd_usb_dev(usb),
1486
 
                        "error in usb_bulk_msg()"
1487
 
                        " req_len %d != actual_req_len %d\n",
1488
 
                        req_len, actual_req_len);
1489
 
                r = -EIO;
 
1862
                        "error in zd_submit_waiting_usb(). "
 
1863
                        "Error number %d\n", r);
1490
1864
                goto error;
1491
1865
        }
1492
1866
 
1493
 
        /* FALL-THROUGH with r == 0 */
 
1867
        /* Delay submit so that URB_NO_INTERRUPT flag can be set for all URBs
 
1868
         * of currect batch except for very last.
 
1869
         */
 
1870
        usb->urb_async_waiting = urb;
 
1871
        return 0;
1494
1872
error:
1495
 
        kfree(req);
 
1873
        usb_free_urb(urb);
1496
1874
        return r;
1497
1875
}
1498
1876
 
 
1877
int zd_usb_iowrite16v(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
 
1878
                        unsigned int count)
 
1879
{
 
1880
        int r;
 
1881
 
 
1882
        zd_usb_iowrite16v_async_start(usb);
 
1883
        r = zd_usb_iowrite16v_async(usb, ioreqs, count);
 
1884
        if (r) {
 
1885
                zd_usb_iowrite16v_async_end(usb, 0);
 
1886
                return r;
 
1887
        }
 
1888
        return zd_usb_iowrite16v_async_end(usb, 50 /* ms */);
 
1889
}
 
1890
 
1499
1891
int zd_usb_rfwrite(struct zd_usb *usb, u32 value, u8 bits)
1500
1892
{
1501
1893
        int r;
1533
1925
 
1534
1926
        dev_dbg_f(zd_usb_dev(usb), "value %#09x bits %d\n", value, bits);
1535
1927
 
1536
 
        r = zd_usb_ioread16(usb, &bit_value_template, CR203);
 
1928
        r = zd_usb_ioread16(usb, &bit_value_template, ZD_CR203);
1537
1929
        if (r) {
1538
1930
                dev_dbg_f(zd_usb_dev(usb),
1539
 
                        "error %d: Couldn't read CR203\n", r);
1540
 
                goto out;
 
1931
                        "error %d: Couldn't read ZD_CR203\n", r);
 
1932
                return r;
1541
1933
        }
1542
1934
        bit_value_template &= ~(RF_IF_LE|RF_CLK|RF_DATA);
1543
1935
 
 
1936
        ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
 
1937
        BUILD_BUG_ON(sizeof(struct usb_req_rfwrite) +
 
1938
                     USB_MAX_RFWRITE_BIT_COUNT * sizeof(__le16) >
 
1939
                     sizeof(usb->req_buf));
 
1940
        BUG_ON(sizeof(struct usb_req_rfwrite) + bits * sizeof(__le16) >
 
1941
               sizeof(usb->req_buf));
 
1942
 
1544
1943
        req_len = sizeof(struct usb_req_rfwrite) + bits * sizeof(__le16);
1545
 
        req = kmalloc(req_len, GFP_KERNEL);
1546
 
        if (!req)
1547
 
                return -ENOMEM;
 
1944
        req = (void *)usb->req_buf;
1548
1945
 
1549
1946
        req->id = cpu_to_le16(USB_REQ_WRITE_RF);
1550
1947
        /* 1: 3683a, but not used in ZYDAS driver */
1559
1956
        }
1560
1957
 
1561
1958
        udev = zd_usb_to_usbdev(usb);
1562
 
        r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, EP_REGS_OUT),
1563
 
                         req, req_len, &actual_req_len, 1000 /* ms */);
 
1959
        r = zd_ep_regs_out_msg(udev, req, req_len, &actual_req_len, 50 /*ms*/);
1564
1960
        if (r) {
1565
1961
                dev_dbg_f(zd_usb_dev(usb),
1566
 
                        "error in usb_bulk_msg(). Error number %d\n", r);
 
1962
                        "error in zd_ep_regs_out_msg(). Error number %d\n", r);
1567
1963
                goto out;
1568
1964
        }
1569
1965
        if (req_len != actual_req_len) {
1570
 
                dev_dbg_f(zd_usb_dev(usb), "error in usb_bulk_msg()"
 
1966
                dev_dbg_f(zd_usb_dev(usb), "error in zd_ep_regs_out_msg()"
1571
1967
                        " req_len %d != actual_req_len %d\n",
1572
1968
                        req_len, actual_req_len);
1573
1969
                r = -EIO;
1576
1972
 
1577
1973
        /* FALL-THROUGH with r == 0 */
1578
1974
out:
1579
 
        kfree(req);
1580
1975
        return r;
1581
1976
}