← Back to branch summary

~ubuntu-branches/ubuntu/quantal/linux-linaro-mx51/quantal

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): John Rigby, John Rigby
  • Date: 2011-09-26 10:44:23 UTC
  • Revision ID: package-import@ubuntu.com-20110926104423-3o58a3c1bj7x00rs
Tags: 3.0.0-1007.9
https://launchpad.net/bugs/826021
[ John Rigby ]

Enable crypto modules and remove crypto-modules from
exclude-module files
LP: #826021

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/wireless/zd1211rw/zd_usb.c
1533
1533
module_init(usb_init);
1534
1534
module_exit(usb_exit);
1535
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
 
1536
1561
static int usb_int_regs_length(unsigned int count)
1537
1562
{
1538
1563
        return sizeof(struct usb_int_regs) + count * sizeof(struct reg_data);
1648
1673
 
1649
1674
        udev = zd_usb_to_usbdev(usb);
1650
1675
        prepare_read_regs_int(usb);
1651
 
        r = usb_interrupt_msg(udev, usb_sndintpipe(udev, EP_REGS_OUT),
1652
 
                              req, req_len, &actual_req_len, 50 /* ms */);
 
1676
        r = zd_ep_regs_out_msg(udev, req, req_len, &actual_req_len, 50 /*ms*/);
1653
1677
        if (r) {
1654
1678
                dev_dbg_f(zd_usb_dev(usb),
1655
 
                        "error in usb_interrupt_msg(). Error number %d\n", r);
 
1679
                        "error in zd_ep_regs_out_msg(). Error number %d\n", r);
1656
1680
                goto error;
1657
1681
        }
1658
1682
        if (req_len != actual_req_len) {
1659
 
                dev_dbg_f(zd_usb_dev(usb), "error in usb_interrupt_msg()\n"
 
1683
                dev_dbg_f(zd_usb_dev(usb), "error in zd_ep_regs_out_msg()\n"
1660
1684
                        " req_len %d != actual_req_len %d\n",
1661
1685
                        req_len, actual_req_len);
1662
1686
                r = -EIO;
1818
1842
                rw->value = cpu_to_le16(ioreqs[i].value);
1819
1843
        }
1820
1844
 
1821
 
        usb_fill_int_urb(urb, udev, usb_sndintpipe(udev, EP_REGS_OUT),
1822
 
                         req, req_len, iowrite16v_urb_complete, usb,
1823
 
                         ep->desc.bInterval);
 
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
 
1824
1856
        urb->transfer_flags |= URB_FREE_BUFFER;
1825
1857
 
1826
1858
        /* Submit previous URB */
1893
1925
 
1894
1926
        dev_dbg_f(zd_usb_dev(usb), "value %#09x bits %d\n", value, bits);
1895
1927
 
1896
 
        r = zd_usb_ioread16(usb, &bit_value_template, CR203);
 
1928
        r = zd_usb_ioread16(usb, &bit_value_template, ZD_CR203);
1897
1929
        if (r) {
1898
1930
                dev_dbg_f(zd_usb_dev(usb),
1899
 
                        "error %d: Couldn't read CR203\n", r);
 
1931
                        "error %d: Couldn't read ZD_CR203\n", r);
1900
1932
                return r;
1901
1933
        }
1902
1934
        bit_value_template &= ~(RF_IF_LE|RF_CLK|RF_DATA);
1924
1956
        }
1925
1957
 
1926
1958
        udev = zd_usb_to_usbdev(usb);
1927
 
        r = usb_interrupt_msg(udev, usb_sndintpipe(udev, EP_REGS_OUT),
1928
 
                              req, req_len, &actual_req_len, 50 /* ms */);
 
1959
        r = zd_ep_regs_out_msg(udev, req, req_len, &actual_req_len, 50 /*ms*/);
1929
1960
        if (r) {
1930
1961
                dev_dbg_f(zd_usb_dev(usb),
1931
 
                        "error in usb_interrupt_msg(). Error number %d\n", r);
 
1962
                        "error in zd_ep_regs_out_msg(). Error number %d\n", r);
1932
1963
                goto out;
1933
1964
        }
1934
1965
        if (req_len != actual_req_len) {
1935
 
                dev_dbg_f(zd_usb_dev(usb), "error in usb_interrupt_msg()"
 
1966
                dev_dbg_f(zd_usb_dev(usb), "error in zd_ep_regs_out_msg()"
1936
1967
                        " req_len %d != actual_req_len %d\n",
1937
1968
                        req_len, actual_req_len);
1938
1969
                r = -EIO;