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 static int ft1000_poll_thread(void *arg)
  41 {
  42         int ret;
  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_usb *ft1000dev;
  67         struct ft1000_info *pft1000info = NULL;
  68         const struct firmware *dsp_fw;
  69
  70         ft1000dev = kzalloc(sizeof(struct ft1000_usb), GFP_KERNEL);
  71         if (!ft1000dev)
  72                 return -ENOMEM;
  73
  74         dev = interface_to_usbdev(interface);
  75         DEBUG("ft1000_probe: usb device descriptor info:\n");
  76         DEBUG("ft1000_probe: number of configuration is %d\n",
  77               dev->descriptor.bNumConfigurations);
  78
  79         ft1000dev->dev = dev;
  80         ft1000dev->status = 0;
  81         ft1000dev->net = NULL;
  82         ft1000dev->tx_urb = usb_alloc_urb(0, GFP_ATOMIC);
  83         ft1000dev->rx_urb = usb_alloc_urb(0, GFP_ATOMIC);
  84
  85         DEBUG("ft1000_probe is called\n");
  86         numaltsetting = interface->num_altsetting;
  87         DEBUG("ft1000_probe: number of alt settings is :%d\n", numaltsetting);
  88         iface_desc = interface->cur_altsetting;
  89         DEBUG("ft1000_probe: number of endpoints is %d\n",
  90               iface_desc->desc.bNumEndpoints);
  91         DEBUG("ft1000_probe: descriptor type is %d\n",
  92               iface_desc->desc.bDescriptorType);
  93         DEBUG("ft1000_probe: interface number is %d\n",
  94               iface_desc->desc.bInterfaceNumber);
  95         DEBUG("ft1000_probe: alternatesetting is %d\n",
  96               iface_desc->desc.bAlternateSetting);
  97         DEBUG("ft1000_probe: interface class is %d\n",
  98               iface_desc->desc.bInterfaceClass);
  99         DEBUG("ft1000_probe: control endpoint info:\n");
 100         DEBUG("ft1000_probe: descriptor0 type -- %d\n",
 101               iface_desc->endpoint[0].desc.bmAttributes);
 102         DEBUG("ft1000_probe: descriptor1 type -- %d\n",
 103               iface_desc->endpoint[1].desc.bmAttributes);
 104         DEBUG("ft1000_probe: descriptor2 type -- %d\n",
 105               iface_desc->endpoint[2].desc.bmAttributes);
 106
 107         for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
 108                 endpoint =
 109                     (struct usb_endpoint_descriptor *)&iface_desc->
 110                     endpoint[i].desc;
 111                 DEBUG("endpoint %d\n", i);
 112                 DEBUG("bEndpointAddress=%x, bmAttributes=%x\n",
 113                       endpoint->bEndpointAddress, endpoint->bmAttributes);
 114                 if ((endpoint->bEndpointAddress & USB_DIR_IN)
 115                     && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
 116                         USB_ENDPOINT_XFER_BULK)) {
 117                         ft1000dev->bulk_in_endpointAddr =
 118                             endpoint->bEndpointAddress;
 119                         DEBUG("ft1000_probe: in: %d\n",
 120                               endpoint->bEndpointAddress);
 121                 }
 122
 123                 if (!(endpoint->bEndpointAddress & USB_DIR_IN)
 124                     && ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
 125                         USB_ENDPOINT_XFER_BULK)) {
 126                         ft1000dev->bulk_out_endpointAddr =
 127                             endpoint->bEndpointAddress;
 128                         DEBUG("ft1000_probe: out: %d\n",
 129                               endpoint->bEndpointAddress);
 130                 }
 131         }
 132
 133         DEBUG("bulk_in=%d, bulk_out=%d\n", ft1000dev->bulk_in_endpointAddr,
 134               ft1000dev->bulk_out_endpointAddr);
 135
 136         ret = request_firmware(&dsp_fw, "ft3000.img", &dev->dev);
 137         if (ret < 0) {
 138                 pr_err("Error request_firmware().\n");
 139                 goto err_fw;
 140         }
 141
 142         size = max_t(uint, dsp_fw->size, 4096);
 143         pFileStart = kmalloc(size, GFP_KERNEL);
 144
 145         if (!pFileStart) {
 146                 release_firmware(dsp_fw);
 147                 ret = -ENOMEM;
 148                 goto err_fw;
 149         }
 150
 151         memcpy(pFileStart, dsp_fw->data, dsp_fw->size);
 152         FileLength = dsp_fw->size;
 153         release_firmware(dsp_fw);
 154
 155         DEBUG("ft1000_probe: start downloading dsp image...\n");
 156
 157         ret = init_ft1000_netdev(ft1000dev);
 158         if (ret)
 159                 goto err_load;
 160
 161         pft1000info = netdev_priv(ft1000dev->net);
 162
 163         DEBUG("In probe: pft1000info=%p\n", pft1000info);
 164         ret = dsp_reload(ft1000dev);
 165         if (ret) {
 166                 pr_err("Problem with DSP image loading\n");
 167                 goto err_load;
 168         }
 169
 170         gPollingfailed = FALSE;
 171         ft1000dev->pPollThread =
 172             kthread_run(ft1000_poll_thread, ft1000dev, "ft1000_poll");
 173
 174         if (IS_ERR(ft1000dev->pPollThread)) {
 175                 ret = PTR_ERR(ft1000dev->pPollThread);
 176                 goto err_load;
 177         }
 178
 179         msleep(500);
 180
 181         while (!pft1000info->CardReady) {
 182                 if (gPollingfailed) {
 183                         ret = -EIO;
 184                         goto err_thread;
 185                 }
 186                 msleep(100);
 187                 DEBUG("ft1000_probe::Waiting for Card Ready\n");
 188         }
 189
 190         DEBUG("ft1000_probe::Card Ready!!!! Registering network device\n");
 191
 192         ret = reg_ft1000_netdev(ft1000dev, interface);
 193         if (ret)
 194                 goto err_thread;
 195
 196         ret = ft1000_init_proc(ft1000dev->net);
 197         if (ret)
 198                 goto err_proc;
 199
 200         ft1000dev->NetDevRegDone = 1;
 201
 202         return 0;
 203
 204 err_proc:
 205         unregister_netdev(ft1000dev->net);
 206         free_netdev(ft1000dev->net);
 207 err_thread:
 208         kthread_stop(ft1000dev->pPollThread);
 209 err_load:
 210         kfree(pFileStart);
 211 err_fw:
 212         kfree(ft1000dev);
 213         return ret;
 214 }
 215
 216 static void ft1000_disconnect(struct usb_interface *interface)
 217 {
 218         struct ft1000_info *pft1000info;
 219         struct ft1000_usb *ft1000dev;
 220
 221         DEBUG("ft1000_disconnect is called\n");
 222
 223         pft1000info = (struct ft1000_info *) usb_get_intfdata(interface);
 224         DEBUG("In disconnect pft1000info=%p\n", pft1000info);
 225
 226         if (pft1000info) {
 227                 ft1000dev = pft1000info->priv;
 228                 ft1000_cleanup_proc(pft1000info);
 229                 if (ft1000dev->pPollThread)
 230                         kthread_stop(ft1000dev->pPollThread);
 231
 232                 DEBUG("ft1000_disconnect: threads are terminated\n");
 233
 234                 if (ft1000dev->net) {
 235                         DEBUG("ft1000_disconnect: destroy char driver\n");
 236                         ft1000_destroy_dev(ft1000dev->net);
 237                         unregister_netdev(ft1000dev->net);
 238                         DEBUG
 239                             ("ft1000_disconnect: network device unregistered\n");
 240                         free_netdev(ft1000dev->net);
 241
 242                 }
 243
 244                 usb_free_urb(ft1000dev->rx_urb);
 245                 usb_free_urb(ft1000dev->tx_urb);
 246
 247                 DEBUG("ft1000_disconnect: urb freed\n");
 248
 249                 kfree(ft1000dev);
 250         }
 251         kfree(pFileStart);
 252
 253         return;
 254 }
 255
 256 static struct usb_driver ft1000_usb_driver = {
 257         .name = "ft1000usb",
 258         .probe = ft1000_probe,
 259         .disconnect = ft1000_disconnect,
 260         .id_table = id_table,
 261 };
 262
 263 module_usb_driver(ft1000_usb_driver);