← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/staging/ft1000/ft1000-usb/ft1000_usb.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/ft1000/ft1000-usb/ft1000_usb.c
 
1
/*=====================================================
 
2
 * CopyRight (C) 2007 Qualcomm Inc. All Rights Reserved.
 
3
 *
 
4
 *
 
5
 * This file is part of Express Card USB Driver
 
6
 *
 
7
 * $Id:
 
8
 *====================================================
 
9
 */
 
10
#include <linux/init.h>
 
11
#include <linux/kernel.h>
 
12
#include <linux/module.h>
 
13
#include <linux/usb.h>
 
14
#include <linux/netdevice.h>
 
15
#include <linux/etherdevice.h>
 
16
#include <linux/firmware.h>
 
17
#include "ft1000_usb.h"
 
18
 
 
19
#include <linux/kthread.h>
 
20
 
 
21
MODULE_DESCRIPTION("FT1000 EXPRESS CARD DRIVER");
 
22
MODULE_LICENSE("Dual MPL/GPL");
 
23
MODULE_SUPPORTED_DEVICE("QFT FT1000 Express Cards");
 
24
 
 
25
void *pFileStart;
 
26
size_t FileLength;
 
27
 
 
28
#define VENDOR_ID 0x1291        /* Qualcomm vendor id */
 
29
#define PRODUCT_ID 0x11         /* fake product id */
 
30
 
 
31
/* table of devices that work with this driver */
 
32
static struct usb_device_id id_table[] = {
 
33
        {USB_DEVICE(VENDOR_ID, PRODUCT_ID)},
 
34
        {},
 
35
};
 
36
 
 
37
MODULE_DEVICE_TABLE(usb, id_table);
 
38
 
 
39
static bool gPollingfailed = FALSE;
 
40
int ft1000_poll_thread(void *arg)
 
41
{
 
42
        int ret = STATUS_SUCCESS;
 
43
 
 
44
        while (!kthread_should_stop()) {
 
45
                msleep(10);
 
46
                if (!gPollingfailed) {
 
47
                        ret = ft1000_poll(arg);
 
48
                        if (ret != STATUS_SUCCESS) {
 
49
                                DEBUG("ft1000_poll_thread: polling failed\n");
 
50
                                gPollingfailed = TRUE;
 
51
                        }
 
52
                }
 
53
        }
 
54
        return STATUS_SUCCESS;
 
55
}
 
56
 
 
57
static int ft1000_probe(struct usb_interface *interface,
 
58
                        const struct usb_device_id *id)
 
59
{
 
60
        struct usb_host_interface *iface_desc;
 
61
        struct usb_endpoint_descriptor *endpoint;
 
62
        struct usb_device *dev;
 
63
        unsigned numaltsetting;
 
64
        int i, ret = 0, size;
 
65
 
 
66
        struct ft1000_device *ft1000dev;
 
67
        struct ft1000_info *pft1000info = NULL;
 
68
        const struct firmware *dsp_fw;
 
69
 
 
70
        ft1000dev = kmalloc(sizeof(struct ft1000_device), GFP_KERNEL);
 
71
 
 
72
        if (!ft1000dev) {
 
73
                printk(KERN_ERR "out of memory allocating device structure\n");
 
74
                return 0;
 
75
        }
 
76
 
 
77
        memset(ft1000dev, 0, sizeof(*ft1000dev));
 
78
 
 
79
        dev = interface_to_usbdev(interface);
 
80
        DEBUG("ft1000_probe: usb device descriptor info:\n");
 
81
        DEBUG("ft1000_probe: number of configuration is %d\n",
 
82
              dev->descriptor.bNumConfigurations);
 
83
 
 
84
        ft1000dev->dev = dev;
 
85
        ft1000dev->status = 0;
 
86
        ft1000dev->net = NULL;
 
87
        ft1000dev->tx_urb = usb_alloc_urb(0, GFP_ATOMIC);
 
88
        ft1000dev->rx_urb = usb_alloc_urb(0, GFP_ATOMIC);
 
89
 
 
90
        DEBUG("ft1000_probe is called\n");
 
91
        numaltsetting = interface->num_altsetting;
 
92
        DEBUG("ft1000_probe: number of alt settings is :%d\n", numaltsetting);
 
93
        iface_desc = interface->cur_altsetting;
 
94
        DEBUG("ft1000_probe: number of endpoints is %d\n",
 
95
              iface_desc->desc.bNumEndpoints);
 
96
        DEBUG("ft1000_probe: descriptor type is %d\n",
 
97
              iface_desc->desc.bDescriptorType);
 
98
        DEBUG("ft1000_probe: interface number is %d\n",
 
99
              iface_desc->desc.bInterfaceNumber);
 
100
        DEBUG("ft1000_probe: alternatesetting is %d\n",
 
101
              iface_desc->desc.bAlternateSetting);
 
102
        DEBUG("ft1000_probe: interface class is %d\n",
 
103
              iface_desc->desc.bInterfaceClass);
 
104
        DEBUG("ft1000_probe: control endpoint info:\n");
 
105
        DEBUG("ft1000_probe: descriptor0 type -- %d\n",
 
106
              iface_desc->endpoint[0].desc.bmAttributes);
 
107
        DEBUG("ft1000_probe: descriptor1 type -- %d\n",
 
108
              iface_desc->endpoint[1].desc.bmAttributes);
 
109
        DEBUG("ft1000_probe: descriptor2 type -- %d\n",
 
110
              iface_desc->endpoint[2].desc.bmAttributes);
 
111
 
 
112
        for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
 
113
                endpoint =
 
114
                    (struct usb_endpoint_descriptor *)&iface_desc->
 
115
                    endpoint[i].desc;
 
116
                DEBUG("endpoint %d\n", i);
 
117
                DEBUG("bEndpointAddress=%x, bmAttributes=%x\n",
 
118
                      endpoint->bEndpointAddress, endpoint->bmAttributes);
 
119
                if ((endpoint->bEndpointAddress & USB_DIR_IN)
 
120
                    && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
 
121
                        USB_ENDPOINT_XFER_BULK)) {
 
122
                        ft1000dev->bulk_in_endpointAddr =
 
123
                            endpoint->bEndpointAddress;
 
124
                        DEBUG("ft1000_probe: in: %d\n",
 
125
                              endpoint->bEndpointAddress);
 
126
                }
 
127
 
 
128
                if (!(endpoint->bEndpointAddress & USB_DIR_IN)
 
129
                    && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
 
130
                        USB_ENDPOINT_XFER_BULK)) {
 
131
                        ft1000dev->bulk_out_endpointAddr =
 
132
                            endpoint->bEndpointAddress;
 
133
                        DEBUG("ft1000_probe: out: %d\n",
 
134
                              endpoint->bEndpointAddress);
 
135
                }
 
136
        }
 
137
 
 
138
        DEBUG("bulk_in=%d, bulk_out=%d\n", ft1000dev->bulk_in_endpointAddr,
 
139
              ft1000dev->bulk_out_endpointAddr);
 
140
 
 
141
        ret = request_firmware(&dsp_fw, "ft3000.img", &dev->dev);
 
142
        if (ret < 0) {
 
143
                printk(KERN_ERR "Error request_firmware().\n");
 
144
                goto err_fw;
 
145
        }
 
146
 
 
147
        size = max_t(uint, dsp_fw->size, 4096);
 
148
        pFileStart = kmalloc(size, GFP_KERNEL);
 
149
 
 
150
        if (!pFileStart) {
 
151
                release_firmware(dsp_fw);
 
152
                ret = -ENOMEM;
 
153
                goto err_fw;
 
154
        }
 
155
 
 
156
        memcpy(pFileStart, dsp_fw->data, dsp_fw->size);
 
157
        FileLength = dsp_fw->size;
 
158
        release_firmware(dsp_fw);
 
159
 
 
160
        DEBUG("ft1000_probe: start downloading dsp image...\n");
 
161
 
 
162
        ret = init_ft1000_netdev(ft1000dev);
 
163
        if (ret)
 
164
                goto err_load;
 
165
 
 
166
        pft1000info = netdev_priv(ft1000dev->net);
 
167
 
 
168
        DEBUG("In probe: pft1000info=%p\n", pft1000info);
 
169
        ret = dsp_reload(ft1000dev);
 
170
        if (ret) {
 
171
                printk(KERN_ERR "Problem with DSP image loading\n");
 
172
                goto err_load;
 
173
        }
 
174
 
 
175
        gPollingfailed = FALSE;
 
176
        pft1000info->pPollThread =
 
177
            kthread_run(ft1000_poll_thread, ft1000dev, "ft1000_poll");
 
178
 
 
179
        if (IS_ERR(pft1000info->pPollThread)) {
 
180
                ret = PTR_ERR(pft1000info->pPollThread);
 
181
                goto err_load;
 
182
        }
 
183
 
 
184
        msleep(500);
 
185
 
 
186
        while (!pft1000info->CardReady) {
 
187
                if (gPollingfailed) {
 
188
                        ret = -EIO;
 
189
                        goto err_thread;
 
190
                }
 
191
                msleep(100);
 
192
                DEBUG("ft1000_probe::Waiting for Card Ready\n");
 
193
        }
 
194
 
 
195
        DEBUG("ft1000_probe::Card Ready!!!! Registering network device\n");
 
196
 
 
197
        ret = reg_ft1000_netdev(ft1000dev, interface);
 
198
        if (ret)
 
199
                goto err_thread;
 
200
 
 
201
        ret = ft1000_init_proc(ft1000dev->net);
 
202
        if (ret)
 
203
                goto err_proc;
 
204
 
 
205
        pft1000info->NetDevRegDone = 1;
 
206
 
 
207
        return 0;
 
208
 
 
209
err_proc:
 
210
        unregister_netdev(ft1000dev->net);
 
211
        free_netdev(ft1000dev->net);
 
212
err_thread:
 
213
        kthread_stop(pft1000info->pPollThread);
 
214
err_load:
 
215
        kfree(pFileStart);
 
216
err_fw:
 
217
        kfree(ft1000dev);
 
218
        return ret;
 
219
}
 
220
 
 
221
static void ft1000_disconnect(struct usb_interface *interface)
 
222
{
 
223
        struct ft1000_info *pft1000info;
 
224
 
 
225
        DEBUG("ft1000_disconnect is called\n");
 
226
 
 
227
        pft1000info = (struct ft1000_info *) usb_get_intfdata(interface);
 
228
        DEBUG("In disconnect pft1000info=%p\n", pft1000info);
 
229
 
 
230
        if (pft1000info) {
 
231
                ft1000_cleanup_proc(pft1000info);
 
232
                if (pft1000info->pPollThread)
 
233
                        kthread_stop(pft1000info->pPollThread);
 
234
 
 
235
                DEBUG("ft1000_disconnect: threads are terminated\n");
 
236
 
 
237
                if (pft1000info->pFt1000Dev->net) {
 
238
                        DEBUG("ft1000_disconnect: destroy char driver\n");
 
239
                        ft1000_destroy_dev(pft1000info->pFt1000Dev->net);
 
240
                        unregister_netdev(pft1000info->pFt1000Dev->net);
 
241
                        DEBUG
 
242
                            ("ft1000_disconnect: network device unregisterd\n");
 
243
                        free_netdev(pft1000info->pFt1000Dev->net);
 
244
 
 
245
                }
 
246
 
 
247
                usb_free_urb(pft1000info->pFt1000Dev->rx_urb);
 
248
                usb_free_urb(pft1000info->pFt1000Dev->tx_urb);
 
249
 
 
250
                DEBUG("ft1000_disconnect: urb freed\n");
 
251
 
 
252
                kfree(pft1000info->pFt1000Dev);
 
253
        }
 
254
        kfree(pFileStart);
 
255
 
 
256
        return;
 
257
}
 
258
 
 
259
static struct usb_driver ft1000_usb_driver = {
 
260
        .name = "ft1000usb",
 
261
        .probe = ft1000_probe,
 
262
        .disconnect = ft1000_disconnect,
 
263
        .id_table = id_table,
 
264
};
 
265
 
 
266
static int __init usb_ft1000_init(void)
 
267
{
 
268
        int ret = 0;
 
269
 
 
270
        DEBUG("Initialize and register the driver\n");
 
271
 
 
272
        ret = usb_register(&ft1000_usb_driver);
 
273
        if (ret)
 
274
                err("usb_register failed. Error number %d", ret);
 
275
 
 
276
        return ret;
 
277
}
 
278
 
 
279
static void __exit usb_ft1000_exit(void)
 
280
{
 
281
        DEBUG("Deregister the driver\n");
 
282
        usb_deregister(&ft1000_usb_driver);
 
283
}
 
284
 
 
285
module_init(usb_ft1000_init);
 
286
module_exit(usb_ft1000_exit);