← 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/compat-wireless-2.6.37/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/compat-wireless-2.6.37/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
 
        return 0;
349
 
 
350
 
err_start_card:
351
 
        lbs_remove_card(priv);
352
 
err_prog_firmware:
353
 
        if_usb_reset_device(cardp);
354
 
dealloc:
355
 
        if_usb_free(cardp);
356
 
 
357
 
error:
358
 
        return -ENOMEM;
359
 
}
360
 
 
361
 
/**
362
 
 *  @brief free resource and cleanup
363
 
 *  @param intf         USB interface structure
364
 
 *  @return             N/A
365
 
 */
366
 
static void if_usb_disconnect(struct usb_interface *intf)
367
 
{
368
 
        struct if_usb_card *cardp = usb_get_intfdata(intf);
369
 
        struct lbs_private *priv = (struct lbs_private *) cardp->priv;
370
 
 
371
 
        lbs_deb_enter(LBS_DEB_MAIN);
372
 
 
373
 
        device_remove_file(&priv->dev->dev, &dev_attr_lbs_flash_boot2);
374
 
        device_remove_file(&priv->dev->dev, &dev_attr_lbs_flash_fw);
375
 
 
376
 
        cardp->surprise_removed = 1;
377
 
 
378
 
        if (priv) {
379
 
                priv->surpriseremoved = 1;
380
 
                lbs_stop_card(priv);
381
 
                lbs_remove_card(priv);
382
 
        }
383
 
 
384
 
        /* Unlink and free urb */
385
 
        if_usb_free(cardp);
386
 
 
387
 
        usb_set_intfdata(intf, NULL);
388
 
        usb_put_dev(interface_to_usbdev(intf));
389
 
 
390
 
        lbs_deb_leave(LBS_DEB_MAIN);
391
 
}
392
 
 
393
 
/**
394
 
 *  @brief  This function download FW
395
 
 *  @param priv         pointer to struct lbs_private
396
 
 *  @return             0
397
 
 */
398
 
static int if_usb_send_fw_pkt(struct if_usb_card *cardp)
399
 
{
400
 
        struct fwdata *fwdata = cardp->ep_out_buf;
401
 
        const uint8_t *firmware = cardp->fw->data;
402
 
 
403
 
        /* If we got a CRC failure on the last block, back
404
 
           up and retry it */
405
 
        if (!cardp->CRC_OK) {
406
 
                cardp->totalbytes = cardp->fwlastblksent;
407
 
                cardp->fwseqnum--;
408
 
        }
409
 
 
410
 
        lbs_deb_usb2(&cardp->udev->dev, "totalbytes = %d\n",
411
 
                     cardp->totalbytes);
412
 
 
413
 
        /* struct fwdata (which we sent to the card) has an
414
 
           extra __le32 field in between the header and the data,
415
 
           which is not in the struct fwheader in the actual
416
 
           firmware binary. Insert the seqnum in the middle... */
417
 
        memcpy(&fwdata->hdr, &firmware[cardp->totalbytes],
418
 
               sizeof(struct fwheader));
419
 
 
420
 
        cardp->fwlastblksent = cardp->totalbytes;
421
 
        cardp->totalbytes += sizeof(struct fwheader);
422
 
 
423
 
        memcpy(fwdata->data, &firmware[cardp->totalbytes],
424
 
               le32_to_cpu(fwdata->hdr.datalength));
425
 
 
426
 
        lbs_deb_usb2(&cardp->udev->dev, "Data length = %d\n",
427
 
                     le32_to_cpu(fwdata->hdr.datalength));
428
 
 
429
 
        fwdata->seqnum = cpu_to_le32(++cardp->fwseqnum);
430
 
        cardp->totalbytes += le32_to_cpu(fwdata->hdr.datalength);
431
 
 
432
 
        usb_tx_block(cardp, cardp->ep_out_buf, sizeof(struct fwdata) +
433
 
                     le32_to_cpu(fwdata->hdr.datalength));
434
 
 
435
 
        if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_DATA_TO_RECV)) {
436
 
                lbs_deb_usb2(&cardp->udev->dev, "There are data to follow\n");
437
 
                lbs_deb_usb2(&cardp->udev->dev, "seqnum = %d totalbytes = %d\n",
438
 
                             cardp->fwseqnum, cardp->totalbytes);
439
 
        } else if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_LAST_BLOCK)) {
440
 
                lbs_deb_usb2(&cardp->udev->dev, "Host has finished FW downloading\n");
441
 
                lbs_deb_usb2(&cardp->udev->dev, "Donwloading FW JUMP BLOCK\n");
442
 
 
443
 
                cardp->fwfinalblk = 1;
444
 
        }
445
 
 
446
 
        lbs_deb_usb2(&cardp->udev->dev, "Firmware download done; size %d\n",
447
 
                     cardp->totalbytes);
448
 
 
449
 
        return 0;
450
 
}
451
 
 
452
 
static int if_usb_reset_device(struct if_usb_card *cardp)
453
 
{
454
 
        struct cmd_header *cmd = cardp->ep_out_buf + 4;
455
 
        int ret;
456
 
 
457
 
        lbs_deb_enter(LBS_DEB_USB);
458
 
 
459
 
        *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
460
 
 
461
 
        cmd->command = cpu_to_le16(CMD_802_11_RESET);
462
 
        cmd->size = cpu_to_le16(sizeof(cmd));
463
 
        cmd->result = cpu_to_le16(0);
464
 
        cmd->seqnum = cpu_to_le16(0x5a5a);
465
 
        usb_tx_block(cardp, cardp->ep_out_buf, 4 + sizeof(struct cmd_header));
466
 
 
467
 
        msleep(100);
468
 
        ret = usb_reset_device(cardp->udev);
469
 
        msleep(100);
470
 
 
471
 
#ifdef CONFIG_OLPC
472
 
        if (ret && machine_is_olpc())
473
 
                if_usb_reset_olpc_card(NULL);
474
 
#endif
475
 
 
476
 
        lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret);
477
 
 
478
 
        return ret;
479
 
}
480
 
 
481
 
/**
482
 
 *  @brief This function transfer the data to the device.
483
 
 *  @param priv         pointer to struct lbs_private
484
 
 *  @param payload      pointer to payload data
485
 
 *  @param nb           data length
486
 
 *  @return             0 or -1
487
 
 */
488
 
static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload, uint16_t nb)
489
 
{
490
 
        int ret;
491
 
 
492
 
        /* check if device is removed */
493
 
        if (cardp->surprise_removed) {
494
 
                lbs_deb_usbd(&cardp->udev->dev, "Device removed\n");
495
 
                ret = -ENODEV;
496
 
                goto tx_ret;
497
 
        }
498
 
 
499
 
        usb_fill_bulk_urb(cardp->tx_urb, cardp->udev,
500
 
                          usb_sndbulkpipe(cardp->udev,
501
 
                                          cardp->ep_out),
502
 
                          payload, nb, if_usb_write_bulk_callback, cardp);
503
 
 
504
 
        cardp->tx_urb->transfer_flags |= URB_ZERO_PACKET;
505
 
 
506
 
        if ((ret = usb_submit_urb(cardp->tx_urb, GFP_ATOMIC))) {
507
 
                lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb failed: %d\n", ret);
508
 
        } else {
509
 
                lbs_deb_usb2(&cardp->udev->dev, "usb_submit_urb success\n");
510
 
                ret = 0;
511
 
        }
512
 
 
513
 
tx_ret:
514
 
        return ret;
515
 
}
516
 
 
517
 
static int __if_usb_submit_rx_urb(struct if_usb_card *cardp,
518
 
                                  void (*callbackfn)(struct urb *urb))
519
 
{
520
 
        struct sk_buff *skb;
521
 
        int ret = -1;
522
 
 
523
 
        if (!(skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE))) {
524
 
                lbs_pr_err("No free skb\n");
525
 
                goto rx_ret;
526
 
        }
527
 
 
528
 
        cardp->rx_skb = skb;
529
 
 
530
 
        /* Fill the receive configuration URB and initialise the Rx call back */
531
 
        usb_fill_bulk_urb(cardp->rx_urb, cardp->udev,
532
 
                          usb_rcvbulkpipe(cardp->udev, cardp->ep_in),
533
 
                          skb->data + IPFIELD_ALIGN_OFFSET,
534
 
                          MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn,
535
 
                          cardp);
536
 
 
537
 
        cardp->rx_urb->transfer_flags |= URB_ZERO_PACKET;
538
 
 
539
 
        lbs_deb_usb2(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb);
540
 
        if ((ret = usb_submit_urb(cardp->rx_urb, GFP_ATOMIC))) {
541
 
                lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB failed: %d\n", ret);
542
 
                kfree_skb(skb);
543
 
                cardp->rx_skb = NULL;
544
 
                ret = -1;
545
 
        } else {
546
 
                lbs_deb_usb2(&cardp->udev->dev, "Submit Rx URB success\n");
547
 
                ret = 0;
548
 
        }
549
 
 
550
 
rx_ret:
551
 
        return ret;
552
 
}
553
 
 
554
 
static int if_usb_submit_rx_urb_fwload(struct if_usb_card *cardp)
555
 
{
556
 
        return __if_usb_submit_rx_urb(cardp, &if_usb_receive_fwload);
557
 
}
558
 
 
559
 
static int if_usb_submit_rx_urb(struct if_usb_card *cardp)
560
 
{
561
 
        return __if_usb_submit_rx_urb(cardp, &if_usb_receive);
562
 
}
563
 
 
564
 
static void if_usb_receive_fwload(struct urb *urb)
565
 
{
566
 
        struct if_usb_card *cardp = urb->context;
567
 
        struct sk_buff *skb = cardp->rx_skb;
568
 
        struct fwsyncheader *syncfwheader;
569
 
        struct bootcmdresp bootcmdresp;
570
 
 
571
 
        if (urb->status) {
572
 
                lbs_deb_usbd(&cardp->udev->dev,
573
 
                             "URB status is failed during fw load\n");
574
 
                kfree_skb(skb);
575
 
                return;
576
 
        }
577
 
 
578
 
        if (cardp->fwdnldover) {
579
 
                __le32 *tmp = (__le32 *)(skb->data + IPFIELD_ALIGN_OFFSET);
580
 
 
581
 
                if (tmp[0] == cpu_to_le32(CMD_TYPE_INDICATION) &&
582
 
                    tmp[1] == cpu_to_le32(MACREG_INT_CODE_FIRMWARE_READY)) {
583
 
                        lbs_pr_info("Firmware ready event received\n");
584
 
                        wake_up(&cardp->fw_wq);
585
 
                } else {
586
 
                        lbs_deb_usb("Waiting for confirmation; got %x %x\n",
587
 
                                    le32_to_cpu(tmp[0]), le32_to_cpu(tmp[1]));
588
 
                        if_usb_submit_rx_urb_fwload(cardp);
589
 
                }
590
 
                kfree_skb(skb);
591
 
                return;
592
 
        }
593
 
        if (cardp->bootcmdresp <= 0) {
594
 
                memcpy (&bootcmdresp, skb->data + IPFIELD_ALIGN_OFFSET,
595
 
                        sizeof(bootcmdresp));
596
 
 
597
 
                if (le16_to_cpu(cardp->udev->descriptor.bcdDevice) < 0x3106) {
598
 
                        kfree_skb(skb);
599
 
                        if_usb_submit_rx_urb_fwload(cardp);
600
 
                        cardp->bootcmdresp = BOOT_CMD_RESP_OK;
601
 
                        lbs_deb_usbd(&cardp->udev->dev,
602
 
                                     "Received valid boot command response\n");
603
 
                        return;
604
 
                }
605
 
                if (bootcmdresp.magic != cpu_to_le32(BOOT_CMD_MAGIC_NUMBER)) {
606
 
                        if (bootcmdresp.magic == cpu_to_le32(CMD_TYPE_REQUEST) ||
607
 
                            bootcmdresp.magic == cpu_to_le32(CMD_TYPE_DATA) ||
608
 
                            bootcmdresp.magic == cpu_to_le32(CMD_TYPE_INDICATION)) {
609
 
                                if (!cardp->bootcmdresp)
610
 
                                        lbs_pr_info("Firmware already seems alive; resetting\n");
611
 
                                cardp->bootcmdresp = -1;
612
 
                        } else {
613
 
                                lbs_pr_info("boot cmd response wrong magic number (0x%x)\n",
614
 
                                            le32_to_cpu(bootcmdresp.magic));
615
 
                        }
616
 
                } else if ((bootcmdresp.cmd != BOOT_CMD_FW_BY_USB) &&
617
 
                           (bootcmdresp.cmd != BOOT_CMD_UPDATE_FW) &&
618
 
                           (bootcmdresp.cmd != BOOT_CMD_UPDATE_BOOT2)) {
619
 
                        lbs_pr_info("boot cmd response cmd_tag error (%d)\n",
620
 
                                    bootcmdresp.cmd);
621
 
                } else if (bootcmdresp.result != BOOT_CMD_RESP_OK) {
622
 
                        lbs_pr_info("boot cmd response result error (%d)\n",
623
 
                                    bootcmdresp.result);
624
 
                } else {
625
 
                        cardp->bootcmdresp = 1;
626
 
                        lbs_deb_usbd(&cardp->udev->dev,
627
 
                                     "Received valid boot command response\n");
628
 
                }
629
 
                kfree_skb(skb);
630
 
                if_usb_submit_rx_urb_fwload(cardp);
631
 
                return;
632
 
        }
633
 
 
634
 
        syncfwheader = kmemdup(skb->data + IPFIELD_ALIGN_OFFSET,
635
 
                               sizeof(struct fwsyncheader), GFP_ATOMIC);
636
 
        if (!syncfwheader) {
637
 
                lbs_deb_usbd(&cardp->udev->dev, "Failure to allocate syncfwheader\n");
638
 
                kfree_skb(skb);
639
 
                return;
640
 
        }
641
 
 
642
 
        if (!syncfwheader->cmd) {
643
 
                lbs_deb_usb2(&cardp->udev->dev, "FW received Blk with correct CRC\n");
644
 
                lbs_deb_usb2(&cardp->udev->dev, "FW received Blk seqnum = %d\n",
645
 
                             le32_to_cpu(syncfwheader->seqnum));
646
 
                cardp->CRC_OK = 1;
647
 
        } else {
648
 
                lbs_deb_usbd(&cardp->udev->dev, "FW received Blk with CRC error\n");
649
 
                cardp->CRC_OK = 0;
650
 
        }
651
 
 
652
 
        kfree_skb(skb);
653
 
 
654
 
        /* Give device 5s to either write firmware to its RAM or eeprom */
655
 
        mod_timer(&cardp->fw_timeout, jiffies + (HZ*5));
656
 
 
657
 
        if (cardp->fwfinalblk) {
658
 
                cardp->fwdnldover = 1;
659
 
                goto exit;
660
 
        }
661
 
 
662
 
        if_usb_send_fw_pkt(cardp);
663
 
 
664
 
 exit:
665
 
        if_usb_submit_rx_urb_fwload(cardp);
666
 
 
667
 
        kfree(syncfwheader);
668
 
}
669
 
 
670
 
#define MRVDRV_MIN_PKT_LEN      30
671
 
 
672
 
static inline void process_cmdtypedata(int recvlength, struct sk_buff *skb,
673
 
                                       struct if_usb_card *cardp,
674
 
                                       struct lbs_private *priv)
675
 
{
676
 
        if (recvlength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + MESSAGE_HEADER_LEN
677
 
            || recvlength < MRVDRV_MIN_PKT_LEN) {
678
 
                lbs_deb_usbd(&cardp->udev->dev, "Packet length is Invalid\n");
679
 
                kfree_skb(skb);
680
 
                return;
681
 
        }
682
 
 
683
 
        skb_reserve(skb, IPFIELD_ALIGN_OFFSET);
684
 
        skb_put(skb, recvlength);
685
 
        skb_pull(skb, MESSAGE_HEADER_LEN);
686
 
 
687
 
        lbs_process_rxed_packet(priv, skb);
688
 
}
689
 
 
690
 
static inline void process_cmdrequest(int recvlength, uint8_t *recvbuff,
691
 
                                      struct sk_buff *skb,
692
 
                                      struct if_usb_card *cardp,
693
 
                                      struct lbs_private *priv)
694
 
{
695
 
        u8 i;
696
 
 
697
 
        if (recvlength > LBS_CMD_BUFFER_SIZE) {
698
 
                lbs_deb_usbd(&cardp->udev->dev,
699
 
                             "The receive buffer is too large\n");
700
 
                kfree_skb(skb);
701
 
                return;
702
 
        }
703
 
 
704
 
        BUG_ON(!in_interrupt());
705
 
 
706
 
        spin_lock(&priv->driver_lock);
707
 
 
708
 
        i = (priv->resp_idx == 0) ? 1 : 0;
709
 
        BUG_ON(priv->resp_len[i]);
710
 
        priv->resp_len[i] = (recvlength - MESSAGE_HEADER_LEN);
711
 
        memcpy(priv->resp_buf[i], recvbuff + MESSAGE_HEADER_LEN,
712
 
                priv->resp_len[i]);
713
 
        kfree_skb(skb);
714
 
        lbs_notify_command_response(priv, i);
715
 
 
716
 
        spin_unlock(&priv->driver_lock);
717
 
 
718
 
        lbs_deb_usbd(&cardp->udev->dev,
719
 
                    "Wake up main thread to handle cmd response\n");
720
 
}
721
 
 
722
 
/**
723
 
 *  @brief This function reads of the packet into the upload buff,
724
 
 *  wake up the main thread and initialise the Rx callack.
725
 
 *
726
 
 *  @param urb          pointer to struct urb
727
 
 *  @return             N/A
728
 
 */
729
 
static void if_usb_receive(struct urb *urb)
730
 
{
731
 
        struct if_usb_card *cardp = urb->context;
732
 
        struct sk_buff *skb = cardp->rx_skb;
733
 
        struct lbs_private *priv = cardp->priv;
734
 
        int recvlength = urb->actual_length;
735
 
        uint8_t *recvbuff = NULL;
736
 
        uint32_t recvtype = 0;
737
 
        __le32 *pkt = (__le32 *)(skb->data + IPFIELD_ALIGN_OFFSET);
738
 
        uint32_t event;
739
 
 
740
 
        lbs_deb_enter(LBS_DEB_USB);
741
 
 
742
 
        if (recvlength) {
743
 
                if (urb->status) {
744
 
                        lbs_deb_usbd(&cardp->udev->dev, "RX URB failed: %d\n",
745
 
                                     urb->status);
746
 
                        kfree_skb(skb);
747
 
                        goto setup_for_next;
748
 
                }
749
 
 
750
 
                recvbuff = skb->data + IPFIELD_ALIGN_OFFSET;
751
 
                recvtype = le32_to_cpu(pkt[0]);
752
 
                lbs_deb_usbd(&cardp->udev->dev,
753
 
                            "Recv length = 0x%x, Recv type = 0x%X\n",
754
 
                            recvlength, recvtype);
755
 
        } else if (urb->status) {
756
 
                kfree_skb(skb);
757
 
                goto rx_exit;
758
 
        }
759
 
 
760
 
        switch (recvtype) {
761
 
        case CMD_TYPE_DATA:
762
 
                process_cmdtypedata(recvlength, skb, cardp, priv);
763
 
                break;
764
 
 
765
 
        case CMD_TYPE_REQUEST:
766
 
                process_cmdrequest(recvlength, recvbuff, skb, cardp, priv);
767
 
                break;
768
 
 
769
 
        case CMD_TYPE_INDICATION:
770
 
                /* Event handling */
771
 
                event = le32_to_cpu(pkt[1]);
772
 
                lbs_deb_usbd(&cardp->udev->dev, "**EVENT** 0x%X\n", event);
773
 
                kfree_skb(skb);
774
 
 
775
 
                /* Icky undocumented magic special case */
776
 
                if (event & 0xffff0000) {
777
 
                        u32 trycount = (event & 0xffff0000) >> 16;
778
 
 
779
 
                        lbs_send_tx_feedback(priv, trycount);
780
 
                } else
781
 
                        lbs_queue_event(priv, event & 0xFF);
782
 
                break;
783
 
 
784
 
        default:
785
 
                lbs_deb_usbd(&cardp->udev->dev, "Unknown command type 0x%X\n",
786
 
                             recvtype);
787
 
                kfree_skb(skb);
788
 
                break;
789
 
        }
790
 
 
791
 
setup_for_next:
792
 
        if_usb_submit_rx_urb(cardp);
793
 
rx_exit:
794
 
        lbs_deb_leave(LBS_DEB_USB);
795
 
}
796
 
 
797
 
/**
798
 
 *  @brief This function downloads data to FW
799
 
 *  @param priv         pointer to struct lbs_private structure
800
 
 *  @param type         type of data
801
 
 *  @param buf          pointer to data buffer
802
 
 *  @param len          number of bytes
803
 
 *  @return             0 or -1
804
 
 */
805
 
static int if_usb_host_to_card(struct lbs_private *priv, uint8_t type,
806
 
                               uint8_t *payload, uint16_t nb)
807
 
{
808
 
        struct if_usb_card *cardp = priv->card;
809
 
 
810
 
        lbs_deb_usbd(&cardp->udev->dev,"*** type = %u\n", type);
811
 
        lbs_deb_usbd(&cardp->udev->dev,"size after = %d\n", nb);
812
 
 
813
 
        if (type == MVMS_CMD) {
814
 
                *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
815
 
                priv->dnld_sent = DNLD_CMD_SENT;
816
 
        } else {
817
 
                *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_DATA);
818
 
                priv->dnld_sent = DNLD_DATA_SENT;
819
 
        }
820
 
 
821
 
        memcpy((cardp->ep_out_buf + MESSAGE_HEADER_LEN), payload, nb);
822
 
 
823
 
        return usb_tx_block(cardp, cardp->ep_out_buf, nb + MESSAGE_HEADER_LEN);
824
 
}
825
 
 
826
 
/**
827
 
 *  @brief This function issues Boot command to the Boot2 code
828
 
 *  @param ivalue   1:Boot from FW by USB-Download
829
 
 *                  2:Boot from FW in EEPROM
830
 
 *  @return             0
831
 
 */
832
 
static int if_usb_issue_boot_command(struct if_usb_card *cardp, int ivalue)
833
 
{
834
 
        struct bootcmd *bootcmd = cardp->ep_out_buf;
835
 
 
836
 
        /* Prepare command */
837
 
        bootcmd->magic = cpu_to_le32(BOOT_CMD_MAGIC_NUMBER);
838
 
        bootcmd->cmd = ivalue;
839
 
        memset(bootcmd->pad, 0, sizeof(bootcmd->pad));
840
 
 
841
 
        /* Issue command */
842
 
        usb_tx_block(cardp, cardp->ep_out_buf, sizeof(*bootcmd));
843
 
 
844
 
        return 0;
845
 
}
846
 
 
847
 
 
848
 
/**
849
 
 *  @brief This function checks the validity of Boot2/FW image.
850
 
 *
851
 
 *  @param data              pointer to image
852
 
 *         len               image length
853
 
 *  @return     0 or -1
854
 
 */
855
 
static int check_fwfile_format(const uint8_t *data, uint32_t totlen)
856
 
{
857
 
        uint32_t bincmd, exit;
858
 
        uint32_t blksize, offset, len;
859
 
        int ret;
860
 
 
861
 
        ret = 1;
862
 
        exit = len = 0;
863
 
 
864
 
        do {
865
 
                struct fwheader *fwh = (void *)data;
866
 
 
867
 
                bincmd = le32_to_cpu(fwh->dnldcmd);
868
 
                blksize = le32_to_cpu(fwh->datalength);
869
 
                switch (bincmd) {
870
 
                case FW_HAS_DATA_TO_RECV:
871
 
                        offset = sizeof(struct fwheader) + blksize;
872
 
                        data += offset;
873
 
                        len += offset;
874
 
                        if (len >= totlen)
875
 
                                exit = 1;
876
 
                        break;
877
 
                case FW_HAS_LAST_BLOCK:
878
 
                        exit = 1;
879
 
                        ret = 0;
880
 
                        break;
881
 
                default:
882
 
                        exit = 1;
883
 
                        break;
884
 
                }
885
 
        } while (!exit);
886
 
 
887
 
        if (ret)
888
 
                lbs_pr_err("firmware file format check FAIL\n");
889
 
        else
890
 
                lbs_deb_fw("firmware file format check PASS\n");
891
 
 
892
 
        return ret;
893
 
}
894
 
 
895
 
 
896
 
/**
897
 
*  @brief This function programs the firmware subject to cmd
898
 
*
899
 
*  @param cardp             the if_usb_card descriptor
900
 
*         fwname            firmware or boot2 image file name
901
 
*         cmd               either BOOT_CMD_FW_BY_USB, BOOT_CMD_UPDATE_FW,
902
 
*                           or BOOT_CMD_UPDATE_BOOT2.
903
 
*  @return     0 or error code
904
 
*/
905
 
static int if_usb_prog_firmware(struct if_usb_card *cardp,
906
 
                                const char *fwname, int cmd)
907
 
{
908
 
        struct lbs_private *priv = cardp->priv;
909
 
        unsigned long flags, caps;
910
 
        int ret;
911
 
 
912
 
        caps = priv->fwcapinfo;
913
 
        if (((cmd == BOOT_CMD_UPDATE_FW) && !(caps & FW_CAPINFO_FIRMWARE_UPGRADE)) ||
914
 
            ((cmd == BOOT_CMD_UPDATE_BOOT2) && !(caps & FW_CAPINFO_BOOT2_UPGRADE)))
915
 
                return -EOPNOTSUPP;
916
 
 
917
 
        /* Ensure main thread is idle. */
918
 
        spin_lock_irqsave(&priv->driver_lock, flags);
919
 
        while (priv->cur_cmd != NULL || priv->dnld_sent != DNLD_RES_RECEIVED) {
920
 
                spin_unlock_irqrestore(&priv->driver_lock, flags);
921
 
                if (wait_event_interruptible(priv->waitq,
922
 
                                (priv->cur_cmd == NULL &&
923
 
                                priv->dnld_sent == DNLD_RES_RECEIVED))) {
924
 
                        return -ERESTARTSYS;
925
 
                }
926
 
                spin_lock_irqsave(&priv->driver_lock, flags);
927
 
        }
928
 
        priv->dnld_sent = DNLD_BOOTCMD_SENT;
929
 
        spin_unlock_irqrestore(&priv->driver_lock, flags);
930
 
 
931
 
        ret = __if_usb_prog_firmware(cardp, fwname, cmd);
932
 
 
933
 
        spin_lock_irqsave(&priv->driver_lock, flags);
934
 
        priv->dnld_sent = DNLD_RES_RECEIVED;
935
 
        spin_unlock_irqrestore(&priv->driver_lock, flags);
936
 
 
937
 
        wake_up_interruptible(&priv->waitq);
938
 
 
939
 
        return ret;
940
 
}
941
 
 
942
 
/* table of firmware file names */
943
 
static const struct {
944
 
        u32 model;
945
 
        const char *fwname;
946
 
} fw_table[] = {
947
 
        { MODEL_8388, "libertas/usb8388_v9.bin" },
948
 
        { MODEL_8388, "libertas/usb8388_v5.bin" },
949
 
        { MODEL_8388, "libertas/usb8388.bin" },
950
 
        { MODEL_8388, "usb8388.bin" },
951
 
        { MODEL_8682, "libertas/usb8682.bin" }
952
 
};
953
 
 
954
 
static int get_fw(struct if_usb_card *cardp, const char *fwname)
955
 
{
956
 
        int i;
957
 
 
958
 
        /* Try user-specified firmware first */
959
 
        if (fwname)
960
 
                return request_firmware(&cardp->fw, fwname, &cardp->udev->dev);
961
 
 
962
 
        /* Otherwise search for firmware to use */
963
 
        for (i = 0; i < ARRAY_SIZE(fw_table); i++) {
964
 
                if (fw_table[i].model != cardp->model)
965
 
                        continue;
966
 
                if (request_firmware(&cardp->fw, fw_table[i].fwname,
967
 
                                        &cardp->udev->dev) == 0)
968
 
                        return 0;
969
 
        }
970
 
 
971
 
        return -ENOENT;
972
 
}
973
 
 
974
 
static int __if_usb_prog_firmware(struct if_usb_card *cardp,
975
 
                                        const char *fwname, int cmd)
976
 
{
977
 
        int i = 0;
978
 
        static int reset_count = 10;
979
 
        int ret = 0;
980
 
 
981
 
        lbs_deb_enter(LBS_DEB_USB);
982
 
 
983
 
        ret = get_fw(cardp, fwname);
984
 
        if (ret) {
985
 
                lbs_pr_err("failed to find firmware (%d)\n", ret);
986
 
                goto done;
987
 
        }
988
 
 
989
 
        if (check_fwfile_format(cardp->fw->data, cardp->fw->size)) {
990
 
                ret = -EINVAL;
991
 
                goto release_fw;
992
 
        }
993
 
 
994
 
        /* Cancel any pending usb business */
995
 
        usb_kill_urb(cardp->rx_urb);
996
 
        usb_kill_urb(cardp->tx_urb);
997
 
 
998
 
        cardp->fwlastblksent = 0;
999
 
        cardp->fwdnldover = 0;
1000
 
        cardp->totalbytes = 0;
1001
 
        cardp->fwfinalblk = 0;
1002
 
        cardp->bootcmdresp = 0;
1003
 
 
1004
 
restart:
1005
 
        if (if_usb_submit_rx_urb_fwload(cardp) < 0) {
1006
 
                lbs_deb_usbd(&cardp->udev->dev, "URB submission is failed\n");
1007
 
                ret = -EIO;
1008
 
                goto release_fw;
1009
 
        }
1010
 
 
1011
 
        cardp->bootcmdresp = 0;
1012
 
        do {
1013
 
                int j = 0;
1014
 
                i++;
1015
 
                if_usb_issue_boot_command(cardp, cmd);
1016
 
                /* wait for command response */
1017
 
                do {
1018
 
                        j++;
1019
 
                        msleep_interruptible(100);
1020
 
                } while (cardp->bootcmdresp == 0 && j < 10);
1021
 
        } while (cardp->bootcmdresp == 0 && i < 5);
1022
 
 
1023
 
        if (cardp->bootcmdresp == BOOT_CMD_RESP_NOT_SUPPORTED) {
1024
 
                /* Return to normal operation */
1025
 
                ret = -EOPNOTSUPP;
1026
 
                usb_kill_urb(cardp->rx_urb);
1027
 
                usb_kill_urb(cardp->tx_urb);
1028
 
                if (if_usb_submit_rx_urb(cardp) < 0)
1029
 
                        ret = -EIO;
1030
 
                goto release_fw;
1031
 
        } else if (cardp->bootcmdresp <= 0) {
1032
 
                if (--reset_count >= 0) {
1033
 
                        if_usb_reset_device(cardp);
1034
 
                        goto restart;
1035
 
                }
1036
 
                ret = -EIO;
1037
 
                goto release_fw;
1038
 
        }
1039
 
 
1040
 
        i = 0;
1041
 
 
1042
 
        cardp->totalbytes = 0;
1043
 
        cardp->fwlastblksent = 0;
1044
 
        cardp->CRC_OK = 1;
1045
 
        cardp->fwdnldover = 0;
1046
 
        cardp->fwseqnum = -1;
1047
 
        cardp->totalbytes = 0;
1048
 
        cardp->fwfinalblk = 0;
1049
 
 
1050
 
        /* Send the first firmware packet... */
1051
 
        if_usb_send_fw_pkt(cardp);
1052
 
 
1053
 
        /* ... and wait for the process to complete */
1054
 
        wait_event_interruptible(cardp->fw_wq, cardp->surprise_removed || cardp->fwdnldover);
1055
 
 
1056
 
        del_timer_sync(&cardp->fw_timeout);
1057
 
        usb_kill_urb(cardp->rx_urb);
1058
 
 
1059
 
        if (!cardp->fwdnldover) {
1060
 
                lbs_pr_info("failed to load fw, resetting device!\n");
1061
 
                if (--reset_count >= 0) {
1062
 
                        if_usb_reset_device(cardp);
1063
 
                        goto restart;
1064
 
                }
1065
 
 
1066
 
                lbs_pr_info("FW download failure, time = %d ms\n", i * 100);
1067
 
                ret = -EIO;
1068
 
                goto release_fw;
1069
 
        }
1070
 
 
1071
 
 release_fw:
1072
 
        release_firmware(cardp->fw);
1073
 
        cardp->fw = NULL;
1074
 
 
1075
 
 done:
1076
 
        lbs_deb_leave_args(LBS_DEB_USB, "ret %d", ret);
1077
 
        return ret;
1078
 
}
1079
 
 
1080
 
 
1081
 
#ifdef CONFIG_PM
1082
 
static int if_usb_suspend(struct usb_interface *intf, pm_message_t message)
1083
 
{
1084
 
        struct if_usb_card *cardp = usb_get_intfdata(intf);
1085
 
        struct lbs_private *priv = cardp->priv;
1086
 
        int ret;
1087
 
 
1088
 
        lbs_deb_enter(LBS_DEB_USB);
1089
 
 
1090
 
        if (priv->psstate != PS_STATE_FULL_POWER)
1091
 
                return -1;
1092
 
 
1093
 
        if (priv->wol_criteria == EHS_REMOVE_WAKEUP) {
1094
 
                lbs_pr_info("Suspend attempt without "
1095
 
                                                "configuring wake params!\n");
1096
 
                return -ENOSYS;
1097
 
        }
1098
 
 
1099
 
        ret = lbs_suspend(priv);
1100
 
        if (ret)
1101
 
                goto out;
1102
 
 
1103
 
        /* Unlink tx & rx urb */
1104
 
        usb_kill_urb(cardp->tx_urb);
1105
 
        usb_kill_urb(cardp->rx_urb);
1106
 
 
1107
 
 out:
1108
 
        lbs_deb_leave(LBS_DEB_USB);
1109
 
        return ret;
1110
 
}
1111
 
 
1112
 
static int if_usb_resume(struct usb_interface *intf)
1113
 
{
1114
 
        struct if_usb_card *cardp = usb_get_intfdata(intf);
1115
 
        struct lbs_private *priv = cardp->priv;
1116
 
 
1117
 
        lbs_deb_enter(LBS_DEB_USB);
1118
 
 
1119
 
        if_usb_submit_rx_urb(cardp);
1120
 
 
1121
 
        lbs_resume(priv);
1122
 
 
1123
 
        lbs_deb_leave(LBS_DEB_USB);
1124
 
        return 0;
1125
 
}
1126
 
#else
1127
 
#define if_usb_suspend NULL
1128
 
#define if_usb_resume NULL
1129
 
#endif
1130
 
 
1131
 
static struct usb_driver if_usb_driver = {
1132
 
        .name = DRV_NAME,
1133
 
        .probe = if_usb_probe,
1134
 
        .disconnect = if_usb_disconnect,
1135
 
        .id_table = if_usb_table,
1136
 
        .suspend = if_usb_suspend,
1137
 
        .resume = if_usb_resume,
1138
 
        .reset_resume = if_usb_resume,
1139
 
};
1140
 
 
1141
 
static int __init if_usb_init_module(void)
1142
 
{
1143
 
        int ret = 0;
1144
 
 
1145
 
        lbs_deb_enter(LBS_DEB_MAIN);
1146
 
 
1147
 
        ret = usb_register(&if_usb_driver);
1148
 
 
1149
 
        lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1150
 
        return ret;
1151
 
}
1152
 
 
1153
 
static void __exit if_usb_exit_module(void)
1154
 
{
1155
 
        lbs_deb_enter(LBS_DEB_MAIN);
1156
 
 
1157
 
        usb_deregister(&if_usb_driver);
1158
 
 
1159
 
        lbs_deb_leave(LBS_DEB_MAIN);
1160
 
}
1161
 
 
1162
 
module_init(if_usb_init_module);
1163
 
module_exit(if_usb_exit_module);
1164
 
 
1165
 
MODULE_DESCRIPTION("8388 USB WLAN Driver");
1166
 
MODULE_AUTHOR("Marvell International Ltd. and Red Hat, Inc.");
1167
 
MODULE_LICENSE("GPL");