← Back to branch summary

~ubuntu-branches/ubuntu/natty/linux-backports-modules-2.6.38/natty-updates

« back to all changes in this revision

Viewing changes to updates/cw-2.6.39/drivers/net/wireless/libertas/if_usb.c

  • Committer: Bazaar Package Importer
  • Author(s): Tim Gardner, Tim Gardner
  • Date: 2011-06-08 10:44:09 UTC
  • Revision ID: james.westby@ubuntu.com-20110608104409-fnl8carkdo15bwsz
Tags: 2.6.38-10.6
[ Tim Gardner ]

Shorten compat-wireless package name to cw to accomodate
CDROM file name length restrictions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
updates/cw-2.6.39/drivers/net/wireless/libertas/if_usb.c
 
1
/**
 
2
  * This file contains functions used in USB interface module.
 
3
  */
 
4
#include <linux/delay.h>
 
5
#include <linux/moduleparam.h>
 
6
#include <linux/firmware.h>
 
7
#include <linux/netdevice.h>
 
8
#include <linux/slab.h>
 
9
#include <linux/usb.h>
 
10
 
 
11
#ifdef CONFIG_OLPC
 
12
#include <asm/olpc.h>
 
13
#endif
 
14
 
 
15
#define DRV_NAME "usb8xxx"
 
16
 
 
17
#include "host.h"
 
18
#include "decl.h"
 
19
#include "defs.h"
 
20
#include "dev.h"
 
21
#include "cmd.h"
 
22
#include "if_usb.h"
 
23
 
 
24
#define INSANEDEBUG     0
 
25
#define lbs_deb_usb2(...) do { if (INSANEDEBUG) lbs_deb_usbd(__VA_ARGS__); } while (0)
 
26
 
 
27
#define MESSAGE_HEADER_LEN      4
 
28
 
 
29
static char *lbs_fw_name = NULL;
 
30
module_param_named(fw_name, lbs_fw_name, charp, 0644);
 
31
 
 
32
MODULE_FIRMWARE("libertas/usb8388_v9.bin");
 
33
MODULE_FIRMWARE("libertas/usb8388_v5.bin");
 
34
MODULE_FIRMWARE("libertas/usb8388.bin");
 
35
MODULE_FIRMWARE("libertas/usb8682.bin");
 
36
MODULE_FIRMWARE("usb8388.bin");
 
37
 
 
38
enum {
 
39
        MODEL_UNKNOWN = 0x0,
 
40
        MODEL_8388 = 0x1,
 
41
        MODEL_8682 = 0x2
 
42
};
 
43
 
 
44
static struct usb_device_id if_usb_table[] = {
 
45
        /* Enter the device signature inside */
 
46
        { USB_DEVICE(0x1286, 0x2001), .driver_info = MODEL_8388 },
 
47
        { USB_DEVICE(0x05a3, 0x8388), .driver_info = MODEL_8388 },
 
48
        {}      /* Terminating entry */
 
49
};
 
50
 
 
51
MODULE_DEVICE_TABLE(usb, if_usb_table);
 
52
 
 
53
static void if_usb_receive(struct urb *urb);
 
54
static void if_usb_receive_fwload(struct urb *urb);
 
55
static int __if_usb_prog_firmware(struct if_usb_card *cardp,
 
56
                                        const char *fwname, int cmd);
 
57
static int if_usb_prog_firmware(struct if_usb_card *cardp,
 
58
                                        const char *fwname, int cmd);
 
59
static int if_usb_host_to_card(struct lbs_private *priv, uint8_t type,
 
60
                               uint8_t *payload, uint16_t nb);
 
61
static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload,
 
62
                        uint16_t nb);
 
63
static void if_usb_free(struct if_usb_card *cardp);
 
64
static int if_usb_submit_rx_urb(struct if_usb_card *cardp);
 
65
static int if_usb_reset_device(struct if_usb_card *cardp);
 
66
 
 
67
/* sysfs hooks */
 
68
 
 
69
/**
 
70
 *  Set function to write firmware to device's persistent memory
 
71
 */
 
72
static ssize_t if_usb_firmware_set(struct device *dev,
 
73
                struct device_attribute *attr, const char *buf, size_t count)
 
74
{
 
75
        struct lbs_private *priv = to_net_dev(dev)->ml_priv;
 
76
        struct if_usb_card *cardp = priv->card;
 
77
        int ret;
 
78
 
 
79
        BUG_ON(buf == NULL);
 
80
 
 
81
        ret = if_usb_prog_firmware(cardp, buf, BOOT_CMD_UPDATE_FW);
 
82
        if (ret == 0)
 
83
                return count;
 
84
 
 
85
        return ret;
 
86
}
 
87
 
 
88
/**
 
89
 * lbs_flash_fw attribute to be exported per ethX interface through sysfs
 
90
 * (/sys/class/net/ethX/lbs_flash_fw).  Use this like so to write firmware to
 
91
 * the device's persistent memory:
 
92
 * echo usb8388-5.126.0.p5.bin > /sys/class/net/ethX/lbs_flash_fw
 
93
 */
 
94
static DEVICE_ATTR(lbs_flash_fw, 0200, NULL, if_usb_firmware_set);
 
95
 
 
96
/**
 
97
 *  Set function to write firmware to device's persistent memory
 
98
 */
 
99
static ssize_t if_usb_boot2_set(struct device *dev,
 
100
                struct device_attribute *attr, const char *buf, size_t count)
 
101
{
 
102
        struct lbs_private *priv = to_net_dev(dev)->ml_priv;
 
103
        struct if_usb_card *cardp = priv->card;
 
104
        int ret;
 
105
 
 
106
        BUG_ON(buf == NULL);
 
107
 
 
108
        ret = if_usb_prog_firmware(cardp, buf, BOOT_CMD_UPDATE_BOOT2);
 
109
        if (ret == 0)
 
110
                return count;
 
111
 
 
112
        return ret;
 
113
}
 
114
 
 
115
/**
 
116
 * lbs_flash_boot2 attribute to be exported per ethX interface through sysfs
 
117
 * (/sys/class/net/ethX/lbs_flash_boot2).  Use this like so to write firmware
 
118
 * to the device's persistent memory:
 
119
 * echo usb8388-5.126.0.p5.bin > /sys/class/net/ethX/lbs_flash_boot2
 
120
 */
 
121
static DEVICE_ATTR(lbs_flash_boot2, 0200, NULL, if_usb_boot2_set);
 
122
 
 
123
/**
 
124
 *  @brief  call back function to handle the status of the URB
 
125
 *  @param urb          pointer to urb structure
 
126
 *  @return             N/A
 
127
 */
 
128
static void if_usb_write_bulk_callback(struct urb *urb)
 
129
{
 
130
        struct if_usb_card *cardp = (struct if_usb_card *) urb->context;
 
131
 
 
132
        /* handle the transmission complete validations */
 
133
 
 
134
        if (urb->status == 0) {
 
135
                struct lbs_private *priv = cardp->priv;
 
136
 
 
137
                lbs_deb_usb2(&urb->dev->dev, "URB status is successful\n");
 
138
                lbs_deb_usb2(&urb->dev->dev, "Actual length transmitted %d\n",
 
139
                             urb->actual_length);
 
140
 
 
141
                /* Boot commands such as UPDATE_FW and UPDATE_BOOT2 are not
 
142
                 * passed up to the lbs level.
 
143
                 */
 
144
                if (priv && priv->dnld_sent != DNLD_BOOTCMD_SENT)
 
145
                        lbs_host_to_card_done(priv);
 
146
        } else {
 
147
                /* print the failure status number for debug */
 
148
                lbs_pr_info("URB in failure status: %d\n", urb->status);
 
149
        }
 
150
}
 
151
 
 
152
/**
 
153
 *  @brief  free tx/rx urb, skb and rx buffer
 
154
 *  @param cardp        pointer if_usb_card
 
155
 *  @return             N/A
 
156
 */
 
157
static void if_usb_free(struct if_usb_card *cardp)
 
158
{
 
159
        lbs_deb_enter(LBS_DEB_USB);
 
160
 
 
161
        /* Unlink tx & rx urb */
 
162
        usb_kill_urb(cardp->tx_urb);
 
163
        usb_kill_urb(cardp->rx_urb);
 
164
 
 
165
        usb_free_urb(cardp->tx_urb);
 
166
        cardp->tx_urb = NULL;
 
167
 
 
168
        usb_free_urb(cardp->rx_urb);
 
169
        cardp->rx_urb = NULL;
 
170
 
 
171
        kfree(cardp->ep_out_buf);
 
172
        cardp->ep_out_buf = NULL;
 
173
 
 
174
        lbs_deb_leave(LBS_DEB_USB);
 
175
}
 
176
 
 
177
static void if_usb_setup_firmware(struct lbs_private *priv)
 
178
{
 
179
        struct if_usb_card *cardp = priv->card;
 
180
        struct cmd_ds_set_boot2_ver b2_cmd;
 
181
        struct cmd_ds_802_11_fw_wake_method wake_method;
 
182
 
 
183
        b2_cmd.hdr.size = cpu_to_le16(sizeof(b2_cmd));
 
184
        b2_cmd.action = 0;
 
185
        b2_cmd.version = cardp->boot2_version;
 
186
 
 
187
        if (lbs_cmd_with_response(priv, CMD_SET_BOOT2_VER, &b2_cmd))
 
188
                lbs_deb_usb("Setting boot2 version failed\n");
 
189
 
 
190
        priv->wol_gpio = 2; /* Wake via GPIO2... */
 
191
        priv->wol_gap = 20; /* ... after 20ms    */
 
192
        lbs_host_sleep_cfg(priv, EHS_WAKE_ON_UNICAST_DATA,
 
193
                        (struct wol_config *) NULL);
 
194
 
 
195
        wake_method.hdr.size = cpu_to_le16(sizeof(wake_method));
 
196
        wake_method.action = cpu_to_le16(CMD_ACT_GET);
 
197
        if (lbs_cmd_with_response(priv, CMD_802_11_FW_WAKE_METHOD, &wake_method)) {
 
198
                lbs_pr_info("Firmware does not seem to support PS mode\n");
 
199
                priv->fwcapinfo &= ~FW_CAPINFO_PS;
 
200
        } else {
 
201
                if (le16_to_cpu(wake_method.method) == CMD_WAKE_METHOD_COMMAND_INT) {
 
202
                        lbs_deb_usb("Firmware seems to support PS with wake-via-command\n");
 
203
                } else {
 
204
                        /* The versions which boot up this way don't seem to
 
205
                           work even if we set it to the command interrupt */
 
206
                        priv->fwcapinfo &= ~FW_CAPINFO_PS;
 
207
                        lbs_pr_info("Firmware doesn't wake via command interrupt; disabling PS mode\n");
 
208
                }
 
209
        }
 
210
}
 
211
 
 
212
static void if_usb_fw_timeo(unsigned long priv)
 
213
{
 
214
        struct if_usb_card *cardp = (void *)priv;
 
215
 
 
216
        if (cardp->fwdnldover) {
 
217
                lbs_deb_usb("Download complete, no event. Assuming success\n");
 
218
        } else {
 
219
                lbs_pr_err("Download timed out\n");
 
220
                cardp->surprise_removed = 1;
 
221
        }
 
222
        wake_up(&cardp->fw_wq);
 
223
}
 
224
 
 
225
#ifdef CONFIG_OLPC
 
226
static void if_usb_reset_olpc_card(struct lbs_private *priv)
 
227
{
 
228
        printk(KERN_CRIT "Resetting OLPC wireless via EC...\n");
 
229
        olpc_ec_cmd(0x25, NULL, 0, NULL, 0);
 
230
}
 
231
#endif
 
232
 
 
233
/**
 
234
 *  @brief sets the configuration values
 
235
 *  @param ifnum        interface number
 
236
 *  @param id           pointer to usb_device_id
 
237
 *  @return             0 on success, error code on failure
 
238
 */
 
239
static int if_usb_probe(struct usb_interface *intf,
 
240
                        const struct usb_device_id *id)
 
241
{
 
242
        struct usb_device *udev;
 
243
        struct usb_host_interface *iface_desc;
 
244
        struct usb_endpoint_descriptor *endpoint;
 
245
        struct lbs_private *priv;
 
246
        struct if_usb_card *cardp;
 
247
        int i;
 
248
 
 
249
        udev = interface_to_usbdev(intf);
 
250
 
 
251
        cardp = kzalloc(sizeof(struct if_usb_card), GFP_KERNEL);
 
252
        if (!cardp) {
 
253
                lbs_pr_err("Out of memory allocating private data.\n");
 
254
                goto error;
 
255
        }
 
256
 
 
257
        setup_timer(&cardp->fw_timeout, if_usb_fw_timeo, (unsigned long)cardp);
 
258
        init_waitqueue_head(&cardp->fw_wq);
 
259
 
 
260
        cardp->udev = udev;
 
261
        cardp->model = (uint32_t) id->driver_info;
 
262
        iface_desc = intf->cur_altsetting;
 
263
 
 
264
        lbs_deb_usbd(&udev->dev, "bcdUSB = 0x%X bDeviceClass = 0x%X"
 
265
                     " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
 
266
                     le16_to_cpu(udev->descriptor.bcdUSB),
 
267
                     udev->descriptor.bDeviceClass,
 
268
                     udev->descriptor.bDeviceSubClass,
 
269
                     udev->descriptor.bDeviceProtocol);
 
270
 
 
271
        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 
272
                endpoint = &iface_desc->endpoint[i].desc;
 
273
                if (usb_endpoint_is_bulk_in(endpoint)) {
 
274
                        cardp->ep_in_size = le16_to_cpu(endpoint->wMaxPacketSize);
 
275
                        cardp->ep_in = usb_endpoint_num(endpoint);
 
276
 
 
277
                        lbs_deb_usbd(&udev->dev, "in_endpoint = %d\n", cardp->ep_in);
 
278
                        lbs_deb_usbd(&udev->dev, "Bulk in size is %d\n", cardp->ep_in_size);
 
279
 
 
280
                } else if (usb_endpoint_is_bulk_out(endpoint)) {
 
281
                        cardp->ep_out_size = le16_to_cpu(endpoint->wMaxPacketSize);
 
282
                        cardp->ep_out = usb_endpoint_num(endpoint);
 
283
 
 
284
                        lbs_deb_usbd(&udev->dev, "out_endpoint = %d\n", cardp->ep_out);
 
285
                        lbs_deb_usbd(&udev->dev, "Bulk out size is %d\n", cardp->ep_out_size);
 
286
                }
 
287
        }
 
288
        if (!cardp->ep_out_size || !cardp->ep_in_size) {
 
289
                lbs_deb_usbd(&udev->dev, "Endpoints not found\n");
 
290
                goto dealloc;
 
291
        }
 
292
        if (!(cardp->rx_urb = usb_alloc_urb(0, GFP_KERNEL))) {
 
293
                lbs_deb_usbd(&udev->dev, "Rx URB allocation failed\n");
 
294
                goto dealloc;
 
295
        }
 
296
        if (!(cardp->tx_urb = usb_alloc_urb(0, GFP_KERNEL))) {
 
297
                lbs_deb_usbd(&udev->dev, "Tx URB allocation failed\n");
 
298
                goto dealloc;
 
299
        }
 
300
        cardp->ep_out_buf = kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE, GFP_KERNEL);
 
301
        if (!cardp->ep_out_buf) {
 
302
                lbs_deb_usbd(&udev->dev, "Could not allocate buffer\n");
 
303
                goto dealloc;
 
304
        }
 
305
 
 
306
        /* Upload firmware */
 
307
        kparam_block_sysfs_write(fw_name);
 
308
        if (__if_usb_prog_firmware(cardp, lbs_fw_name, BOOT_CMD_FW_BY_USB)) {
 
309
                kparam_unblock_sysfs_write(fw_name);
 
310
                lbs_deb_usbd(&udev->dev, "FW upload failed\n");
 
311
                goto err_prog_firmware;
 
312
        }
 
313
        kparam_unblock_sysfs_write(fw_name);
 
314
 
 
315
        if (!(priv = lbs_add_card(cardp, &udev->dev)))
 
316
                goto err_prog_firmware;
 
317
 
 
318
        cardp->priv = priv;
 
319
        cardp->priv->fw_ready = 1;
 
320
 
 
321
        priv->hw_host_to_card = if_usb_host_to_card;
 
322
        priv->enter_deep_sleep = NULL;
 
323
        priv->exit_deep_sleep = NULL;
 
324
        priv->reset_deep_sleep_wakeup = NULL;
 
325
#ifdef CONFIG_OLPC
 
326
        if (machine_is_olpc())
 
327
                priv->reset_card = if_usb_reset_olpc_card;
 
328
#endif
 
329
 
 
330
        cardp->boot2_version = udev->descriptor.bcdDevice;
 
331
 
 
332
        if_usb_submit_rx_urb(cardp);
 
333
 
 
334
        if (lbs_start_card(priv))
 
335
                goto err_start_card;
 
336
 
 
337
        if_usb_setup_firmware(priv);
 
338
 
 
339
        usb_get_dev(udev);
 
340
        usb_set_intfdata(intf, cardp);
 
341
 
 
342
        if (device_create_file(&priv->dev->dev, &dev_attr_lbs_flash_fw))
 
343
                lbs_pr_err("cannot register lbs_flash_fw attribute\n");
 
344
 
 
345
        if (device_create_file(&priv->dev->dev, &dev_attr_lbs_flash_boot2))
 
346
                lbs_pr_err("cannot register lbs_flash_boot2 attribute\n");
 
347
 
 
348
        /*
 
349
         * EHS_REMOVE_WAKEUP is not supported on all versions of the firmware.
 
350
         */
 
351
        priv->wol_criteria = EHS_REMOVE_WAKEUP;
 
352
        if (lbs_host_sleep_cfg(priv, priv->wol_criteria, NULL))
 
353
                priv->ehs_remove_supported = false;
 
354
 
 
355
        return 0;
 
356
 
 
357
err_start_card:
 
358
        lbs_remove_card(priv);
 
359
err_prog_firmware:
 
360
        if_usb_reset_device(cardp);
 
361
dealloc:
 
362
        if_usb_free(cardp);
 
363
 
 
364
error:
 
365
        return -ENOMEM;
 
366
}
 
367
 
 
368
/**
 
369
 *  @brief free resource and cleanup
 
370
 *  @param intf         USB interface structure
 
371
 *  @return             N/A
 
372
 */
 
373
static void if_usb_disconnect(struct usb_interface *intf)
 
374
{
 
375
        struct if_usb_card *cardp = usb_get_intfdata(intf);
 
376
        struct lbs_private *priv = (struct lbs_private *) cardp->priv;
 
377
 
 
378
        lbs_deb_enter(LBS_DEB_MAIN);
 
379
 
 
380
        device_remove_file(&priv->dev->dev, &dev_attr_lbs_flash_boot2);
 
381
        device_remove_file(&priv->dev->dev, &dev_attr_lbs_flash_fw);
 
382
 
 
383
        cardp->surprise_removed = 1;
 
384
 
 
385
        if (priv) {
 
386
                priv->surpriseremoved = 1;
 
387
                lbs_stop_card(priv);
 
388
                lbs_remove_card(priv);
 
389
        }
 
390
 
 
391
        /* Unlink and free urb */
 
392
        if_usb_free(cardp);
 
393
 
 
394
        usb_set_intfdata(intf, NULL);
 
395
        usb_put_dev(interface_to_usbdev(intf));
 
396
 
 
397
        lbs_deb_leave(LBS_DEB_MAIN);
 
398
}
 
399
 
 
400
/**
 
401
 *  @brief  This function download FW
 
402
 *  @param priv         pointer to struct lbs_private
 
403
 *  @return             0
 
404
 */
 
405
static int if_usb_send_fw_pkt(struct if_usb_card *cardp)
 
406
{
 
407
        struct fwdata *fwdata = cardp->ep_out_buf;
 
408
        const uint8_t *firmware = cardp->fw->data;
 
409
 
 
410
        /* If we got a CRC failure on the last block, back
 
411
           up and retry it */
 
412
        if (!cardp->CRC_OK) {
 
413
                cardp->totalbytes = cardp->fwlastblksent;
 
414
                cardp->fwseqnum--;
 
415
        }
 
416
 
 
417
        lbs_deb_usb2(&cardp->udev->dev, "totalbytes = %d\n",
 
418
                     cardp->totalbytes);
 
419
 
 
420
        /* struct fwdata (which we sent to the card) has an
 
421
           extra __le32 field in between the header and the data,
 
422
           which is not in the struct fwheader in the actual
 
423
           firmware binary. Insert the seqnum in the middle... */
 
424
        memcpy(&fwdata->hdr, &firmware[cardp->totalbytes],
 
425
               sizeof(struct fwheader));
 
426
 
 
427
        cardp->fwlastblksent = cardp->totalbytes;
 
428
        cardp->totalbytes += sizeof(struct fwheader);
 
429
 
 
430
        memcpy(fwdata->data, &firmware[cardp->totalbytes],
 
431
               le32_to_cpu(fwdata->hdr.datalength));
 
432
 
 
433
        lbs_deb_usb2(&cardp->udev->dev, "Data length = %d\n",
 
434
                     le32_to_cpu(fwdata->hdr.datalength));
 
435
 
 
436
        fwdata->seqnum = cpu_to_le32(++cardp->fwseqnum);
 
437
        cardp->totalbytes += le32_to_cpu(fwdata->hdr.datalength);
 
438
 
 
439
        usb_tx_block(cardp, cardp->ep_out_buf, sizeof(struct fwdata) +
 
440
                     le32_to_cpu(fwdata->hdr.datalength));
 
441
 
 
442
        if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_DATA_TO_RECV)) {
 
443
                lbs_deb_usb2(&cardp->udev->dev, "There are data to follow\n");
 
444
                lbs_deb_usb2(&cardp->udev->dev, "seqnum = %d totalbytes = %d\n",
 
445
                             cardp->fwseqnum, cardp->totalbytes);
 
446
        } else if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_LAST_BLOCK)) {
 
447
                lbs_deb_usb2(&cardp->udev->dev, "Host has finished FW downloading\n");
 
448
                lbs_deb_usb2(&cardp->udev->dev, "Donwloading FW JUMP BLOCK\n");
 
449
 
 
450
                cardp->fwfinalblk = 1;
 
451
        }
 
452
 
 
453
        lbs_deb_usb2(&cardp->udev->dev, "Firmware download done; size %d\n",
 
454
                     cardp->totalbytes);
 
455
 
 
456
        return 0;
 
457
}
 
458
 
 
459
static int if_usb_reset_device(struct if_usb_card *cardp)
 
460
{
 
461
        struct cmd_header *cmd = cardp->ep_out_buf + 4;
 
462
        int ret;
 
463
 
 
464
        lbs_deb_enter(LBS_DEB_USB);
 
465
 
 
466
        *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
 
467
 
 
468
        cmd->command = cpu_to_le16(CMD_802_11_RESET);
 
469
        cmd->size = cpu_to_le16(sizeof(cmd));
 
470
        cmd->result = cpu_to_le16(0);
 
471
        cmd->seqnum = cpu_to_le16(0x5a5a);
 
472
        usb_tx_block(cardp, cardp->ep_out_buf, 4 + sizeof(struct cmd_header));
 
473
 
 
474
        msleep(100);
 
475
        ret = usb_reset_device(cardp->udev);
 
476
        msleep(100);
 
477
 
 
478
#ifdef CONFIG_OLPC
 
479
        if (ret && machine_is_olpc())
 
480
                if_usb_reset_olpc_card(NULL);
 
481
#endif
 
482
 
 
483
        lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret);
 
484
 
 
485
        return ret;
 
486
}
 
487
 
 
488
/**
 
489
 *  @brief This function transfer the data to the device.
 
490
 *  @param priv         pointer to struct lbs_private
 
491
 *  @param payload      pointer to payload data
 
492
 *  @param nb           data length
 
493
 *  @return             0 or -1
 
494
 */
 
495
static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload, uint16_t nb)
 
496
{
 
497
        int ret;
 
498
 
 
499
        /* check if device is removed */
 
500
        if (cardp->surprise_removed) {
 
501
                lbs_deb_usbd(&cardp->udev->dev, "Device removed\n");
 
502
                ret = -ENODEV;
 
503
                goto tx_ret;
 
504
        }
 
505
 
 
506
        usb_fill_bulk_urb(cardp->tx_urb, cardp->udev,
 
507
                          usb_sndbulkpipe(cardp->udev,
 
508
                                          cardp->ep_out),
 
509
                          payload, nb, if_usb_write_bulk_callback, cardp);
 
510
 
 
511
        cardp->tx_urb->transfer_flags |= URB_ZERO_PACKET;
 
512
 
 
513
        if ((ret = usb_submit_urb(cardp->tx_urb, GFP_ATOMIC))) {
 
514
                lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb failed: %d\n", ret);
 
515
        } else {
 
516
                lbs_deb_usb2(&cardp->udev->dev, "usb_submit_urb success\n");
 
517
                ret = 0;
 
518
        }
 
519
 
 
520
tx_ret:
 
521
        return ret;
 
522
}
 
523
 
 
524
static int __if_usb_submit_rx_urb(struct if_usb_card *cardp,
 
525
                                  void (*callbackfn)(struct urb *urb))
 
526
{
 
527
        struct sk_buff *skb;
 
528
        int ret = -1;
 
529
 
 
530
        if (!(skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE))) {
 
531
                lbs_pr_err("No free skb\n");
 
532
                goto rx_ret;
 
533
        }
 
534
 
 
535
        cardp->rx_skb = skb;
 
536
 
 
537
        /* Fill the receive configuration URB and initialise the Rx call back */
 
538
        usb_fill_bulk_urb(cardp->rx_urb, cardp->udev,
 
539
                          usb_rcvbulkpipe(cardp->udev, cardp->ep_in),
 
540
                          skb->data + IPFIELD_ALIGN_OFFSET,
 
541
                          MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn,
 
542
                          cardp);
 
543
 
 
544
        cardp->rx_urb->transfer_flags |= URB_ZERO_PACKET;
 
545
 
 
546
        lbs_deb_usb2(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb);
 
547
        if ((ret = usb_submit_urb(cardp->rx_urb, GFP_ATOMIC))) {
 
548
                lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB failed: %d\n", ret);
 
549
                kfree_skb(skb);
 
550
                cardp->rx_skb = NULL;
 
551
                ret = -1;
 
552
        } else {
 
553
                lbs_deb_usb2(&cardp->udev->dev, "Submit Rx URB success\n");
 
554
                ret = 0;
 
555
        }
 
556
 
 
557
rx_ret:
 
558
        return ret;
 
559
}
 
560
 
 
561
static int if_usb_submit_rx_urb_fwload(struct if_usb_card *cardp)
 
562
{
 
563
        return __if_usb_submit_rx_urb(cardp, &if_usb_receive_fwload);
 
564
}
 
565
 
 
566
static int if_usb_submit_rx_urb(struct if_usb_card *cardp)
 
567
{
 
568
        return __if_usb_submit_rx_urb(cardp, &if_usb_receive);
 
569
}
 
570
 
 
571
static void if_usb_receive_fwload(struct urb *urb)
 
572
{
 
573
        struct if_usb_card *cardp = urb->context;
 
574
        struct sk_buff *skb = cardp->rx_skb;
 
575
        struct fwsyncheader *syncfwheader;
 
576
        struct bootcmdresp bootcmdresp;
 
577
 
 
578
        if (urb->status) {
 
579
                lbs_deb_usbd(&cardp->udev->dev,
 
580
                             "URB status is failed during fw load\n");
 
581
                kfree_skb(skb);
 
582
                return;
 
583
        }
 
584
 
 
585
        if (cardp->fwdnldover) {
 
586
                __le32 *tmp = (__le32 *)(skb->data + IPFIELD_ALIGN_OFFSET);
 
587
 
 
588
                if (tmp[0] == cpu_to_le32(CMD_TYPE_INDICATION) &&
 
589
                    tmp[1] == cpu_to_le32(MACREG_INT_CODE_FIRMWARE_READY)) {
 
590
                        lbs_pr_info("Firmware ready event received\n");
 
591
                        wake_up(&cardp->fw_wq);
 
592
                } else {
 
593
                        lbs_deb_usb("Waiting for confirmation; got %x %x\n",
 
594
                                    le32_to_cpu(tmp[0]), le32_to_cpu(tmp[1]));
 
595
                        if_usb_submit_rx_urb_fwload(cardp);
 
596
                }
 
597
                kfree_skb(skb);
 
598
                return;
 
599
        }
 
600
        if (cardp->bootcmdresp <= 0) {
 
601
                memcpy (&bootcmdresp, skb->data + IPFIELD_ALIGN_OFFSET,
 
602
                        sizeof(bootcmdresp));
 
603
 
 
604
                if (le16_to_cpu(cardp->udev->descriptor.bcdDevice) < 0x3106) {
 
605
                        kfree_skb(skb);
 
606
                        if_usb_submit_rx_urb_fwload(cardp);
 
607
                        cardp->bootcmdresp = BOOT_CMD_RESP_OK;
 
608
                        lbs_deb_usbd(&cardp->udev->dev,
 
609
                                     "Received valid boot command response\n");
 
610
                        return;
 
611
                }
 
612
                if (bootcmdresp.magic != cpu_to_le32(BOOT_CMD_MAGIC_NUMBER)) {
 
613
                        if (bootcmdresp.magic == cpu_to_le32(CMD_TYPE_REQUEST) ||
 
614
                            bootcmdresp.magic == cpu_to_le32(CMD_TYPE_DATA) ||
 
615
                            bootcmdresp.magic == cpu_to_le32(CMD_TYPE_INDICATION)) {
 
616
                                if (!cardp->bootcmdresp)
 
617
                                        lbs_pr_info("Firmware already seems alive; resetting\n");
 
618
                                cardp->bootcmdresp = -1;
 
619
                        } else {
 
620
                                lbs_pr_info("boot cmd response wrong magic number (0x%x)\n",
 
621
                                            le32_to_cpu(bootcmdresp.magic));
 
622
                        }
 
623
                } else if ((bootcmdresp.cmd != BOOT_CMD_FW_BY_USB) &&
 
624
                           (bootcmdresp.cmd != BOOT_CMD_UPDATE_FW) &&
 
625
                           (bootcmdresp.cmd != BOOT_CMD_UPDATE_BOOT2)) {
 
626
                        lbs_pr_info("boot cmd response cmd_tag error (%d)\n",
 
627
                                    bootcmdresp.cmd);
 
628
                } else if (bootcmdresp.result != BOOT_CMD_RESP_OK) {
 
629
                        lbs_pr_info("boot cmd response result error (%d)\n",
 
630
                                    bootcmdresp.result);
 
631
                } else {
 
632
                        cardp->bootcmdresp = 1;
 
633
                        lbs_deb_usbd(&cardp->udev->dev,
 
634
                                     "Received valid boot command response\n");
 
635
                }
 
636
                kfree_skb(skb);
 
637
                if_usb_submit_rx_urb_fwload(cardp);
 
638
                return;
 
639
        }
 
640
 
 
641
        syncfwheader = kmemdup(skb->data + IPFIELD_ALIGN_OFFSET,
 
642
                               sizeof(struct fwsyncheader), GFP_ATOMIC);
 
643
        if (!syncfwheader) {
 
644
                lbs_deb_usbd(&cardp->udev->dev, "Failure to allocate syncfwheader\n");
 
645
                kfree_skb(skb);
 
646
                return;
 
647
        }
 
648
 
 
649
        if (!syncfwheader->cmd) {
 
650
                lbs_deb_usb2(&cardp->udev->dev, "FW received Blk with correct CRC\n");
 
651
                lbs_deb_usb2(&cardp->udev->dev, "FW received Blk seqnum = %d\n",
 
652
                             le32_to_cpu(syncfwheader->seqnum));
 
653
                cardp->CRC_OK = 1;
 
654
        } else {
 
655
                lbs_deb_usbd(&cardp->udev->dev, "FW received Blk with CRC error\n");
 
656
                cardp->CRC_OK = 0;
 
657
        }
 
658
 
 
659
        kfree_skb(skb);
 
660
 
 
661
        /* Give device 5s to either write firmware to its RAM or eeprom */
 
662
        mod_timer(&cardp->fw_timeout, jiffies + (HZ*5));
 
663
 
 
664
        if (cardp->fwfinalblk) {
 
665
                cardp->fwdnldover = 1;
 
666
                goto exit;
 
667
        }
 
668
 
 
669
        if_usb_send_fw_pkt(cardp);
 
670
 
 
671
 exit:
 
672
        if_usb_submit_rx_urb_fwload(cardp);
 
673
 
 
674
        kfree(syncfwheader);
 
675
}
 
676
 
 
677
#define MRVDRV_MIN_PKT_LEN      30
 
678
 
 
679
static inline void process_cmdtypedata(int recvlength, struct sk_buff *skb,
 
680
                                       struct if_usb_card *cardp,
 
681
                                       struct lbs_private *priv)
 
682
{
 
683
        if (recvlength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + MESSAGE_HEADER_LEN
 
684
            || recvlength < MRVDRV_MIN_PKT_LEN) {
 
685
                lbs_deb_usbd(&cardp->udev->dev, "Packet length is Invalid\n");
 
686
                kfree_skb(skb);
 
687
                return;
 
688
        }
 
689
 
 
690
        skb_reserve(skb, IPFIELD_ALIGN_OFFSET);
 
691
        skb_put(skb, recvlength);
 
692
        skb_pull(skb, MESSAGE_HEADER_LEN);
 
693
 
 
694
        lbs_process_rxed_packet(priv, skb);
 
695
}
 
696
 
 
697
static inline void process_cmdrequest(int recvlength, uint8_t *recvbuff,
 
698
                                      struct sk_buff *skb,
 
699
                                      struct if_usb_card *cardp,
 
700
                                      struct lbs_private *priv)
 
701
{
 
702
        u8 i;
 
703
 
 
704
        if (recvlength > LBS_CMD_BUFFER_SIZE) {
 
705
                lbs_deb_usbd(&cardp->udev->dev,
 
706
                             "The receive buffer is too large\n");
 
707
                kfree_skb(skb);
 
708
                return;
 
709
        }
 
710
 
 
711
        BUG_ON(!in_interrupt());
 
712
 
 
713
        spin_lock(&priv->driver_lock);
 
714
 
 
715
        i = (priv->resp_idx == 0) ? 1 : 0;
 
716
        BUG_ON(priv->resp_len[i]);
 
717
        priv->resp_len[i] = (recvlength - MESSAGE_HEADER_LEN);
 
718
        memcpy(priv->resp_buf[i], recvbuff + MESSAGE_HEADER_LEN,
 
719
                priv->resp_len[i]);
 
720
        kfree_skb(skb);
 
721
        lbs_notify_command_response(priv, i);
 
722
 
 
723
        spin_unlock(&priv->driver_lock);
 
724
 
 
725
        lbs_deb_usbd(&cardp->udev->dev,
 
726
                    "Wake up main thread to handle cmd response\n");
 
727
}
 
728
 
 
729
/**
 
730
 *  @brief This function reads of the packet into the upload buff,
 
731
 *  wake up the main thread and initialise the Rx callack.
 
732
 *
 
733
 *  @param urb          pointer to struct urb
 
734
 *  @return             N/A
 
735
 */
 
736
static void if_usb_receive(struct urb *urb)
 
737
{
 
738
        struct if_usb_card *cardp = urb->context;
 
739
        struct sk_buff *skb = cardp->rx_skb;
 
740
        struct lbs_private *priv = cardp->priv;
 
741
        int recvlength = urb->actual_length;
 
742
        uint8_t *recvbuff = NULL;
 
743
        uint32_t recvtype = 0;
 
744
        __le32 *pkt = (__le32 *)(skb->data + IPFIELD_ALIGN_OFFSET);
 
745
        uint32_t event;
 
746
 
 
747
        lbs_deb_enter(LBS_DEB_USB);
 
748
 
 
749
        if (recvlength) {
 
750
                if (urb->status) {
 
751
                        lbs_deb_usbd(&cardp->udev->dev, "RX URB failed: %d\n",
 
752
                                     urb->status);
 
753
                        kfree_skb(skb);
 
754
                        goto setup_for_next;
 
755
                }
 
756
 
 
757
                recvbuff = skb->data + IPFIELD_ALIGN_OFFSET;
 
758
                recvtype = le32_to_cpu(pkt[0]);
 
759
                lbs_deb_usbd(&cardp->udev->dev,
 
760
                            "Recv length = 0x%x, Recv type = 0x%X\n",
 
761
                            recvlength, recvtype);
 
762
        } else if (urb->status) {
 
763
                kfree_skb(skb);
 
764
                goto rx_exit;
 
765
        }
 
766
 
 
767
        switch (recvtype) {
 
768
        case CMD_TYPE_DATA:
 
769
                process_cmdtypedata(recvlength, skb, cardp, priv);
 
770
                break;
 
771
 
 
772
        case CMD_TYPE_REQUEST:
 
773
                process_cmdrequest(recvlength, recvbuff, skb, cardp, priv);
 
774
                break;
 
775
 
 
776
        case CMD_TYPE_INDICATION:
 
777
                /* Event handling */
 
778
                event = le32_to_cpu(pkt[1]);
 
779
                lbs_deb_usbd(&cardp->udev->dev, "**EVENT** 0x%X\n", event);
 
780
                kfree_skb(skb);
 
781
 
 
782
                /* Icky undocumented magic special case */
 
783
                if (event & 0xffff0000) {
 
784
                        u32 trycount = (event & 0xffff0000) >> 16;
 
785
 
 
786
                        lbs_send_tx_feedback(priv, trycount);
 
787
                } else
 
788
                        lbs_queue_event(priv, event & 0xFF);
 
789
                break;
 
790
 
 
791
        default:
 
792
                lbs_deb_usbd(&cardp->udev->dev, "Unknown command type 0x%X\n",
 
793
                             recvtype);
 
794
                kfree_skb(skb);
 
795
                break;
 
796
        }
 
797
 
 
798
setup_for_next:
 
799
        if_usb_submit_rx_urb(cardp);
 
800
rx_exit:
 
801
        lbs_deb_leave(LBS_DEB_USB);
 
802
}
 
803
 
 
804
/**
 
805
 *  @brief This function downloads data to FW
 
806
 *  @param priv         pointer to struct lbs_private structure
 
807
 *  @param type         type of data
 
808
 *  @param buf          pointer to data buffer
 
809
 *  @param len          number of bytes
 
810
 *  @return             0 or -1
 
811
 */
 
812
static int if_usb_host_to_card(struct lbs_private *priv, uint8_t type,
 
813
                               uint8_t *payload, uint16_t nb)
 
814
{
 
815
        struct if_usb_card *cardp = priv->card;
 
816
 
 
817
        lbs_deb_usbd(&cardp->udev->dev,"*** type = %u\n", type);
 
818
        lbs_deb_usbd(&cardp->udev->dev,"size after = %d\n", nb);
 
819
 
 
820
        if (type == MVMS_CMD) {
 
821
                *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
 
822
                priv->dnld_sent = DNLD_CMD_SENT;
 
823
        } else {
 
824
                *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_DATA);
 
825
                priv->dnld_sent = DNLD_DATA_SENT;
 
826
        }
 
827
 
 
828
        memcpy((cardp->ep_out_buf + MESSAGE_HEADER_LEN), payload, nb);
 
829
 
 
830
        return usb_tx_block(cardp, cardp->ep_out_buf, nb + MESSAGE_HEADER_LEN);
 
831
}
 
832
 
 
833
/**
 
834
 *  @brief This function issues Boot command to the Boot2 code
 
835
 *  @param ivalue   1:Boot from FW by USB-Download
 
836
 *                  2:Boot from FW in EEPROM
 
837
 *  @return             0
 
838
 */
 
839
static int if_usb_issue_boot_command(struct if_usb_card *cardp, int ivalue)
 
840
{
 
841
        struct bootcmd *bootcmd = cardp->ep_out_buf;
 
842
 
 
843
        /* Prepare command */
 
844
        bootcmd->magic = cpu_to_le32(BOOT_CMD_MAGIC_NUMBER);
 
845
        bootcmd->cmd = ivalue;
 
846
        memset(bootcmd->pad, 0, sizeof(bootcmd->pad));
 
847
 
 
848
        /* Issue command */
 
849
        usb_tx_block(cardp, cardp->ep_out_buf, sizeof(*bootcmd));
 
850
 
 
851
        return 0;
 
852
}
 
853
 
 
854
 
 
855
/**
 
856
 *  @brief This function checks the validity of Boot2/FW image.
 
857
 *
 
858
 *  @param data              pointer to image
 
859
 *         len               image length
 
860
 *  @return     0 or -1
 
861
 */
 
862
static int check_fwfile_format(const uint8_t *data, uint32_t totlen)
 
863
{
 
864
        uint32_t bincmd, exit;
 
865
        uint32_t blksize, offset, len;
 
866
        int ret;
 
867
 
 
868
        ret = 1;
 
869
        exit = len = 0;
 
870
 
 
871
        do {
 
872
                struct fwheader *fwh = (void *)data;
 
873
 
 
874
                bincmd = le32_to_cpu(fwh->dnldcmd);
 
875
                blksize = le32_to_cpu(fwh->datalength);
 
876
                switch (bincmd) {
 
877
                case FW_HAS_DATA_TO_RECV:
 
878
                        offset = sizeof(struct fwheader) + blksize;
 
879
                        data += offset;
 
880
                        len += offset;
 
881
                        if (len >= totlen)
 
882
                                exit = 1;
 
883
                        break;
 
884
                case FW_HAS_LAST_BLOCK:
 
885
                        exit = 1;
 
886
                        ret = 0;
 
887
                        break;
 
888
                default:
 
889
                        exit = 1;
 
890
                        break;
 
891
                }
 
892
        } while (!exit);
 
893
 
 
894
        if (ret)
 
895
                lbs_pr_err("firmware file format check FAIL\n");
 
896
        else
 
897
                lbs_deb_fw("firmware file format check PASS\n");
 
898
 
 
899
        return ret;
 
900
}
 
901
 
 
902
 
 
903
/**
 
904
*  @brief This function programs the firmware subject to cmd
 
905
*
 
906
*  @param cardp             the if_usb_card descriptor
 
907
*         fwname            firmware or boot2 image file name
 
908
*         cmd               either BOOT_CMD_FW_BY_USB, BOOT_CMD_UPDATE_FW,
 
909
*                           or BOOT_CMD_UPDATE_BOOT2.
 
910
*  @return     0 or error code
 
911
*/
 
912
static int if_usb_prog_firmware(struct if_usb_card *cardp,
 
913
                                const char *fwname, int cmd)
 
914
{
 
915
        struct lbs_private *priv = cardp->priv;
 
916
        unsigned long flags, caps;
 
917
        int ret;
 
918
 
 
919
        caps = priv->fwcapinfo;
 
920
        if (((cmd == BOOT_CMD_UPDATE_FW) && !(caps & FW_CAPINFO_FIRMWARE_UPGRADE)) ||
 
921
            ((cmd == BOOT_CMD_UPDATE_BOOT2) && !(caps & FW_CAPINFO_BOOT2_UPGRADE)))
 
922
                return -EOPNOTSUPP;
 
923
 
 
924
        /* Ensure main thread is idle. */
 
925
        spin_lock_irqsave(&priv->driver_lock, flags);
 
926
        while (priv->cur_cmd != NULL || priv->dnld_sent != DNLD_RES_RECEIVED) {
 
927
                spin_unlock_irqrestore(&priv->driver_lock, flags);
 
928
                if (wait_event_interruptible(priv->waitq,
 
929
                                (priv->cur_cmd == NULL &&
 
930
                                priv->dnld_sent == DNLD_RES_RECEIVED))) {
 
931
                        return -ERESTARTSYS;
 
932
                }
 
933
                spin_lock_irqsave(&priv->driver_lock, flags);
 
934
        }
 
935
        priv->dnld_sent = DNLD_BOOTCMD_SENT;
 
936
        spin_unlock_irqrestore(&priv->driver_lock, flags);
 
937
 
 
938
        ret = __if_usb_prog_firmware(cardp, fwname, cmd);
 
939
 
 
940
        spin_lock_irqsave(&priv->driver_lock, flags);
 
941
        priv->dnld_sent = DNLD_RES_RECEIVED;
 
942
        spin_unlock_irqrestore(&priv->driver_lock, flags);
 
943
 
 
944
        wake_up_interruptible(&priv->waitq);
 
945
 
 
946
        return ret;
 
947
}
 
948
 
 
949
/* table of firmware file names */
 
950
static const struct {
 
951
        u32 model;
 
952
        const char *fwname;
 
953
} fw_table[] = {
 
954
        { MODEL_8388, "libertas/usb8388_v9.bin" },
 
955
        { MODEL_8388, "libertas/usb8388_v5.bin" },
 
956
        { MODEL_8388, "libertas/usb8388.bin" },
 
957
        { MODEL_8388, "usb8388.bin" },
 
958
        { MODEL_8682, "libertas/usb8682.bin" }
 
959
};
 
960
 
 
961
static int get_fw(struct if_usb_card *cardp, const char *fwname)
 
962
{
 
963
        int i;
 
964
 
 
965
        /* Try user-specified firmware first */
 
966
        if (fwname)
 
967
                return request_firmware(&cardp->fw, fwname, &cardp->udev->dev);
 
968
 
 
969
        /* Otherwise search for firmware to use */
 
970
        for (i = 0; i < ARRAY_SIZE(fw_table); i++) {
 
971
                if (fw_table[i].model != cardp->model)
 
972
                        continue;
 
973
                if (request_firmware(&cardp->fw, fw_table[i].fwname,
 
974
                                        &cardp->udev->dev) == 0)
 
975
                        return 0;
 
976
        }
 
977
 
 
978
        return -ENOENT;
 
979
}
 
980
 
 
981
static int __if_usb_prog_firmware(struct if_usb_card *cardp,
 
982
                                        const char *fwname, int cmd)
 
983
{
 
984
        int i = 0;
 
985
        static int reset_count = 10;
 
986
        int ret = 0;
 
987
 
 
988
        lbs_deb_enter(LBS_DEB_USB);
 
989
 
 
990
        ret = get_fw(cardp, fwname);
 
991
        if (ret) {
 
992
                lbs_pr_err("failed to find firmware (%d)\n", ret);
 
993
                goto done;
 
994
        }
 
995
 
 
996
        if (check_fwfile_format(cardp->fw->data, cardp->fw->size)) {
 
997
                ret = -EINVAL;
 
998
                goto release_fw;
 
999
        }
 
1000
 
 
1001
        /* Cancel any pending usb business */
 
1002
        usb_kill_urb(cardp->rx_urb);
 
1003
        usb_kill_urb(cardp->tx_urb);
 
1004
 
 
1005
        cardp->fwlastblksent = 0;
 
1006
        cardp->fwdnldover = 0;
 
1007
        cardp->totalbytes = 0;
 
1008
        cardp->fwfinalblk = 0;
 
1009
        cardp->bootcmdresp = 0;
 
1010
 
 
1011
restart:
 
1012
        if (if_usb_submit_rx_urb_fwload(cardp) < 0) {
 
1013
                lbs_deb_usbd(&cardp->udev->dev, "URB submission is failed\n");
 
1014
                ret = -EIO;
 
1015
                goto release_fw;
 
1016
        }
 
1017
 
 
1018
        cardp->bootcmdresp = 0;
 
1019
        do {
 
1020
                int j = 0;
 
1021
                i++;
 
1022
                if_usb_issue_boot_command(cardp, cmd);
 
1023
                /* wait for command response */
 
1024
                do {
 
1025
                        j++;
 
1026
                        msleep_interruptible(100);
 
1027
                } while (cardp->bootcmdresp == 0 && j < 10);
 
1028
        } while (cardp->bootcmdresp == 0 && i < 5);
 
1029
 
 
1030
        if (cardp->bootcmdresp == BOOT_CMD_RESP_NOT_SUPPORTED) {
 
1031
                /* Return to normal operation */
 
1032
                ret = -EOPNOTSUPP;
 
1033
                usb_kill_urb(cardp->rx_urb);
 
1034
                usb_kill_urb(cardp->tx_urb);
 
1035
                if (if_usb_submit_rx_urb(cardp) < 0)
 
1036
                        ret = -EIO;
 
1037
                goto release_fw;
 
1038
        } else if (cardp->bootcmdresp <= 0) {
 
1039
                if (--reset_count >= 0) {
 
1040
                        if_usb_reset_device(cardp);
 
1041
                        goto restart;
 
1042
                }
 
1043
                ret = -EIO;
 
1044
                goto release_fw;
 
1045
        }
 
1046
 
 
1047
        i = 0;
 
1048
 
 
1049
        cardp->totalbytes = 0;
 
1050
        cardp->fwlastblksent = 0;
 
1051
        cardp->CRC_OK = 1;
 
1052
        cardp->fwdnldover = 0;
 
1053
        cardp->fwseqnum = -1;
 
1054
        cardp->totalbytes = 0;
 
1055
        cardp->fwfinalblk = 0;
 
1056
 
 
1057
        /* Send the first firmware packet... */
 
1058
        if_usb_send_fw_pkt(cardp);
 
1059
 
 
1060
        /* ... and wait for the process to complete */
 
1061
        wait_event_interruptible(cardp->fw_wq, cardp->surprise_removed || cardp->fwdnldover);
 
1062
 
 
1063
        del_timer_sync(&cardp->fw_timeout);
 
1064
        usb_kill_urb(cardp->rx_urb);
 
1065
 
 
1066
        if (!cardp->fwdnldover) {
 
1067
                lbs_pr_info("failed to load fw, resetting device!\n");
 
1068
                if (--reset_count >= 0) {
 
1069
                        if_usb_reset_device(cardp);
 
1070
                        goto restart;
 
1071
                }
 
1072
 
 
1073
                lbs_pr_info("FW download failure, time = %d ms\n", i * 100);
 
1074
                ret = -EIO;
 
1075
                goto release_fw;
 
1076
        }
 
1077
 
 
1078
 release_fw:
 
1079
        release_firmware(cardp->fw);
 
1080
        cardp->fw = NULL;
 
1081
 
 
1082
 done:
 
1083
        lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret);
 
1084
        return ret;
 
1085
}
 
1086
 
 
1087
 
 
1088
#ifdef CONFIG_PM
 
1089
static int if_usb_suspend(struct usb_interface *intf, pm_message_t message)
 
1090
{
 
1091
        struct if_usb_card *cardp = usb_get_intfdata(intf);
 
1092
        struct lbs_private *priv = cardp->priv;
 
1093
        int ret;
 
1094
 
 
1095
        lbs_deb_enter(LBS_DEB_USB);
 
1096
 
 
1097
        if (priv->psstate != PS_STATE_FULL_POWER)
 
1098
                return -1;
 
1099
 
 
1100
        ret = lbs_suspend(priv);
 
1101
        if (ret)
 
1102
                goto out;
 
1103
 
 
1104
        /* Unlink tx & rx urb */
 
1105
        usb_kill_urb(cardp->tx_urb);
 
1106
        usb_kill_urb(cardp->rx_urb);
 
1107
 
 
1108
 out:
 
1109
        lbs_deb_leave(LBS_DEB_USB);
 
1110
        return ret;
 
1111
}
 
1112
 
 
1113
static int if_usb_resume(struct usb_interface *intf)
 
1114
{
 
1115
        struct if_usb_card *cardp = usb_get_intfdata(intf);
 
1116
        struct lbs_private *priv = cardp->priv;
 
1117
 
 
1118
        lbs_deb_enter(LBS_DEB_USB);
 
1119
 
 
1120
        if_usb_submit_rx_urb(cardp);
 
1121
 
 
1122
        lbs_resume(priv);
 
1123
 
 
1124
        lbs_deb_leave(LBS_DEB_USB);
 
1125
        return 0;
 
1126
}
 
1127
#else
 
1128
#define if_usb_suspend NULL
 
1129
#define if_usb_resume NULL
 
1130
#endif
 
1131
 
 
1132
static struct usb_driver if_usb_driver = {
 
1133
        .name = DRV_NAME,
 
1134
        .probe = if_usb_probe,
 
1135
        .disconnect = if_usb_disconnect,
 
1136
        .id_table = if_usb_table,
 
1137
        .suspend = if_usb_suspend,
 
1138
        .resume = if_usb_resume,
 
1139
        .reset_resume = if_usb_resume,
 
1140
};
 
1141
 
 
1142
static int __init if_usb_init_module(void)
 
1143
{
 
1144
        int ret = 0;
 
1145
 
 
1146
        lbs_deb_enter(LBS_DEB_MAIN);
 
1147
 
 
1148
        ret = usb_register(&if_usb_driver);
 
1149
 
 
1150
        lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
 
1151
        return ret;
 
1152
}
 
1153
 
 
1154
static void __exit if_usb_exit_module(void)
 
1155
{
 
1156
        lbs_deb_enter(LBS_DEB_MAIN);
 
1157
 
 
1158
        usb_deregister(&if_usb_driver);
 
1159
 
 
1160
        lbs_deb_leave(LBS_DEB_MAIN);
 
1161
}
 
1162
 
 
1163
module_init(if_usb_init_module);
 
1164
module_exit(if_usb_exit_module);
 
1165
 
 
1166
MODULE_DESCRIPTION("8388 USB WLAN Driver");
 
1167
MODULE_AUTHOR("Marvell International Ltd. and Red Hat, Inc.");
 
1168
MODULE_LICENSE("GPL");