1
2
3
4
5
6#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7
8#include <linux/delay.h>
9#include <linux/module.h>
10#include <linux/firmware.h>
11#include <linux/netdevice.h>
12#include <linux/slab.h>
13#include <linux/usb.h>
14#include <linux/olpc-ec.h>
15
16#ifdef CONFIG_OLPC
17#include <asm/olpc.h>
18#endif
19
20#define DRV_NAME "usb8xxx"
21
22#include "host.h"
23#include "decl.h"
24#include "defs.h"
25#include "dev.h"
26#include "cmd.h"
27#include "if_usb.h"
28
29#define INSANEDEBUG 0
30#define lbs_deb_usb2(...) do { if (INSANEDEBUG) lbs_deb_usbd(__VA_ARGS__); } while (0)
31
32#define MESSAGE_HEADER_LEN 4
33
34MODULE_FIRMWARE("libertas/usb8388_v9.bin");
35MODULE_FIRMWARE("libertas/usb8388_v5.bin");
36MODULE_FIRMWARE("libertas/usb8388.bin");
37MODULE_FIRMWARE("libertas/usb8682.bin");
38MODULE_FIRMWARE("usb8388.bin");
39
40enum {
41 MODEL_UNKNOWN = 0x0,
42 MODEL_8388 = 0x1,
43 MODEL_8682 = 0x2
44};
45
46
47static const struct lbs_fw_table fw_table[] = {
48 { MODEL_8388, "libertas/usb8388_olpc.bin", NULL },
49 { MODEL_8388, "libertas/usb8388_v9.bin", NULL },
50 { MODEL_8388, "libertas/usb8388_v5.bin", NULL },
51 { MODEL_8388, "libertas/usb8388.bin", NULL },
52 { MODEL_8388, "usb8388.bin", NULL },
53 { MODEL_8682, "libertas/usb8682.bin", NULL },
54 { 0, NULL, NULL }
55};
56
57static const struct usb_device_id if_usb_table[] = {
58
59 { USB_DEVICE(0x1286, 0x2001), .driver_info = MODEL_8388 },
60 { USB_DEVICE(0x05a3, 0x8388), .driver_info = MODEL_8388 },
61 {}
62};
63
64MODULE_DEVICE_TABLE(usb, if_usb_table);
65
66static void if_usb_receive(struct urb *urb);
67static void if_usb_receive_fwload(struct urb *urb);
68static void if_usb_prog_firmware(struct lbs_private *priv, int ret,
69 const struct firmware *fw,
70 const struct firmware *unused);
71static int if_usb_host_to_card(struct lbs_private *priv, uint8_t type,
72 uint8_t *payload, uint16_t nb);
73static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload,
74 uint16_t nb);
75static void if_usb_free(struct if_usb_card *cardp);
76static int if_usb_submit_rx_urb(struct if_usb_card *cardp);
77static int if_usb_reset_device(struct if_usb_card *cardp);
78
79
80
81
82
83
84
85static void if_usb_write_bulk_callback(struct urb *urb)
86{
87 struct if_usb_card *cardp = (struct if_usb_card *) urb->context;
88
89
90
91 if (urb->status == 0) {
92 struct lbs_private *priv = cardp->priv;
93
94 lbs_deb_usb2(&urb->dev->dev, "URB status is successful\n");
95 lbs_deb_usb2(&urb->dev->dev, "Actual length transmitted %d\n",
96 urb->actual_length);
97
98
99
100
101 if (priv && priv->dnld_sent != DNLD_BOOTCMD_SENT)
102 lbs_host_to_card_done(priv);
103 } else {
104
105 pr_info("URB in failure status: %d\n", urb->status);
106 }
107}
108
109
110
111
112
113
114static void if_usb_free(struct if_usb_card *cardp)
115{
116
117 usb_kill_urb(cardp->tx_urb);
118 usb_kill_urb(cardp->rx_urb);
119
120 usb_free_urb(cardp->tx_urb);
121 cardp->tx_urb = NULL;
122
123 usb_free_urb(cardp->rx_urb);
124 cardp->rx_urb = NULL;
125
126 kfree(cardp->ep_out_buf);
127 cardp->ep_out_buf = NULL;
128}
129
130static void if_usb_setup_firmware(struct lbs_private *priv)
131{
132 struct if_usb_card *cardp = priv->card;
133 struct cmd_ds_set_boot2_ver b2_cmd;
134 struct cmd_ds_802_11_fw_wake_method wake_method;
135
136 b2_cmd.hdr.size = cpu_to_le16(sizeof(b2_cmd));
137 b2_cmd.action = 0;
138 b2_cmd.version = cardp->boot2_version;
139
140 if (lbs_cmd_with_response(priv, CMD_SET_BOOT2_VER, &b2_cmd))
141 lbs_deb_usb("Setting boot2 version failed\n");
142
143 priv->wol_gpio = 2;
144 priv->wol_gap = 20;
145 lbs_host_sleep_cfg(priv, EHS_WAKE_ON_UNICAST_DATA,
146 (struct wol_config *) NULL);
147
148 wake_method.hdr.size = cpu_to_le16(sizeof(wake_method));
149 wake_method.action = cpu_to_le16(CMD_ACT_GET);
150 if (lbs_cmd_with_response(priv, CMD_802_11_FW_WAKE_METHOD, &wake_method)) {
151 netdev_info(priv->dev, "Firmware does not seem to support PS mode\n");
152 priv->fwcapinfo &= ~FW_CAPINFO_PS;
153 } else {
154 if (le16_to_cpu(wake_method.method) == CMD_WAKE_METHOD_COMMAND_INT) {
155 lbs_deb_usb("Firmware seems to support PS with wake-via-command\n");
156 } else {
157
158
159 priv->fwcapinfo &= ~FW_CAPINFO_PS;
160 netdev_info(priv->dev,
161 "Firmware doesn't wake via command interrupt; disabling PS mode\n");
162 }
163 }
164}
165
166static void if_usb_fw_timeo(struct timer_list *t)
167{
168 struct if_usb_card *cardp = from_timer(cardp, t, fw_timeout);
169
170 if (cardp->fwdnldover) {
171 lbs_deb_usb("Download complete, no event. Assuming success\n");
172 } else {
173 pr_err("Download timed out\n");
174 cardp->surprise_removed = 1;
175 }
176 wake_up(&cardp->fw_wq);
177}
178
179#ifdef CONFIG_OLPC
180static void if_usb_reset_olpc_card(struct lbs_private *priv)
181{
182 printk(KERN_CRIT "Resetting OLPC wireless via EC...\n");
183 olpc_ec_cmd(0x25, NULL, 0, NULL, 0);
184}
185#endif
186
187
188
189
190
191
192
193static int if_usb_probe(struct usb_interface *intf,
194 const struct usb_device_id *id)
195{
196 struct usb_device *udev;
197 struct usb_host_interface *iface_desc;
198 struct usb_endpoint_descriptor *endpoint;
199 struct lbs_private *priv;
200 struct if_usb_card *cardp;
201 int r = -ENOMEM;
202 int i;
203
204 udev = interface_to_usbdev(intf);
205
206 cardp = kzalloc(sizeof(struct if_usb_card), GFP_KERNEL);
207 if (!cardp)
208 goto error;
209
210 timer_setup(&cardp->fw_timeout, if_usb_fw_timeo, 0);
211 init_waitqueue_head(&cardp->fw_wq);
212
213 cardp->udev = udev;
214 cardp->model = (uint32_t) id->driver_info;
215 iface_desc = intf->cur_altsetting;
216
217 lbs_deb_usbd(&udev->dev, "bcdUSB = 0x%X bDeviceClass = 0x%X"
218 " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
219 le16_to_cpu(udev->descriptor.bcdUSB),
220 udev->descriptor.bDeviceClass,
221 udev->descriptor.bDeviceSubClass,
222 udev->descriptor.bDeviceProtocol);
223
224 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
225 endpoint = &iface_desc->endpoint[i].desc;
226 if (usb_endpoint_is_bulk_in(endpoint)) {
227 cardp->ep_in_size = le16_to_cpu(endpoint->wMaxPacketSize);
228 cardp->ep_in = usb_endpoint_num(endpoint);
229
230 lbs_deb_usbd(&udev->dev, "in_endpoint = %d\n", cardp->ep_in);
231 lbs_deb_usbd(&udev->dev, "Bulk in size is %d\n", cardp->ep_in_size);
232
233 } else if (usb_endpoint_is_bulk_out(endpoint)) {
234 cardp->ep_out_size = le16_to_cpu(endpoint->wMaxPacketSize);
235 cardp->ep_out = usb_endpoint_num(endpoint);
236
237 lbs_deb_usbd(&udev->dev, "out_endpoint = %d\n", cardp->ep_out);
238 lbs_deb_usbd(&udev->dev, "Bulk out size is %d\n", cardp->ep_out_size);
239 }
240 }
241 if (!cardp->ep_out_size || !cardp->ep_in_size) {
242 lbs_deb_usbd(&udev->dev, "Endpoints not found\n");
243 goto dealloc;
244 }
245 if (!(cardp->rx_urb = usb_alloc_urb(0, GFP_KERNEL))) {
246 lbs_deb_usbd(&udev->dev, "Rx URB allocation failed\n");
247 goto dealloc;
248 }
249 if (!(cardp->tx_urb = usb_alloc_urb(0, GFP_KERNEL))) {
250 lbs_deb_usbd(&udev->dev, "Tx URB allocation failed\n");
251 goto dealloc;
252 }
253 cardp->ep_out_buf = kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE, GFP_KERNEL);
254 if (!cardp->ep_out_buf) {
255 lbs_deb_usbd(&udev->dev, "Could not allocate buffer\n");
256 goto dealloc;
257 }
258
259 priv = lbs_add_card(cardp, &intf->dev);
260 if (IS_ERR(priv)) {
261 r = PTR_ERR(priv);
262 goto err_add_card;
263 }
264
265 cardp->priv = priv;
266
267 priv->hw_host_to_card = if_usb_host_to_card;
268 priv->enter_deep_sleep = NULL;
269 priv->exit_deep_sleep = NULL;
270 priv->reset_deep_sleep_wakeup = NULL;
271 priv->is_polling = false;
272#ifdef CONFIG_OLPC
273 if (machine_is_olpc())
274 priv->reset_card = if_usb_reset_olpc_card;
275#endif
276
277 cardp->boot2_version = udev->descriptor.bcdDevice;
278
279 usb_get_dev(udev);
280 usb_set_intfdata(intf, cardp);
281
282 r = lbs_get_firmware_async(priv, &udev->dev, cardp->model,
283 fw_table, if_usb_prog_firmware);
284 if (r)
285 goto err_get_fw;
286
287 return 0;
288
289err_get_fw:
290 lbs_remove_card(priv);
291err_add_card:
292 if_usb_reset_device(cardp);
293dealloc:
294 if_usb_free(cardp);
295
296error:
297 return r;
298}
299
300
301
302
303
304
305static void if_usb_disconnect(struct usb_interface *intf)
306{
307 struct if_usb_card *cardp = usb_get_intfdata(intf);
308 struct lbs_private *priv = cardp->priv;
309
310 cardp->surprise_removed = 1;
311
312 if (priv) {
313 lbs_stop_card(priv);
314 lbs_remove_card(priv);
315 }
316
317
318 if_usb_free(cardp);
319
320 usb_set_intfdata(intf, NULL);
321 usb_put_dev(interface_to_usbdev(intf));
322}
323
324
325
326
327
328
329static int if_usb_send_fw_pkt(struct if_usb_card *cardp)
330{
331 struct fwdata *fwdata = cardp->ep_out_buf;
332 const uint8_t *firmware = cardp->fw->data;
333
334
335
336 if (!cardp->CRC_OK) {
337 cardp->totalbytes = cardp->fwlastblksent;
338 cardp->fwseqnum--;
339 }
340
341 lbs_deb_usb2(&cardp->udev->dev, "totalbytes = %d\n",
342 cardp->totalbytes);
343
344
345
346
347
348 memcpy(&fwdata->hdr, &firmware[cardp->totalbytes],
349 sizeof(struct fwheader));
350
351 cardp->fwlastblksent = cardp->totalbytes;
352 cardp->totalbytes += sizeof(struct fwheader);
353
354 memcpy(fwdata->data, &firmware[cardp->totalbytes],
355 le32_to_cpu(fwdata->hdr.datalength));
356
357 lbs_deb_usb2(&cardp->udev->dev, "Data length = %d\n",
358 le32_to_cpu(fwdata->hdr.datalength));
359
360 fwdata->seqnum = cpu_to_le32(++cardp->fwseqnum);
361 cardp->totalbytes += le32_to_cpu(fwdata->hdr.datalength);
362
363 usb_tx_block(cardp, cardp->ep_out_buf, sizeof(struct fwdata) +
364 le32_to_cpu(fwdata->hdr.datalength));
365
366 if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_DATA_TO_RECV)) {
367 lbs_deb_usb2(&cardp->udev->dev, "There are data to follow\n");
368 lbs_deb_usb2(&cardp->udev->dev, "seqnum = %d totalbytes = %d\n",
369 cardp->fwseqnum, cardp->totalbytes);
370 } else if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_LAST_BLOCK)) {
371 lbs_deb_usb2(&cardp->udev->dev, "Host has finished FW downloading\n");
372 lbs_deb_usb2(&cardp->udev->dev, "Downloading FW JUMP BLOCK\n");
373
374 cardp->fwfinalblk = 1;
375 }
376
377 lbs_deb_usb2(&cardp->udev->dev, "Firmware download done; size %d\n",
378 cardp->totalbytes);
379
380 return 0;
381}
382
383static int if_usb_reset_device(struct if_usb_card *cardp)
384{
385 struct cmd_header *cmd = cardp->ep_out_buf + 4;
386 int ret;
387
388 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
389
390 cmd->command = cpu_to_le16(CMD_802_11_RESET);
391 cmd->size = cpu_to_le16(sizeof(cmd));
392 cmd->result = cpu_to_le16(0);
393 cmd->seqnum = cpu_to_le16(0x5a5a);
394 usb_tx_block(cardp, cardp->ep_out_buf, 4 + sizeof(struct cmd_header));
395
396 msleep(100);
397 ret = usb_reset_device(cardp->udev);
398 msleep(100);
399
400#ifdef CONFIG_OLPC
401 if (ret && machine_is_olpc())
402 if_usb_reset_olpc_card(NULL);
403#endif
404
405 return ret;
406}
407
408
409
410
411
412
413
414
415static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload, uint16_t nb)
416{
417 int ret;
418
419
420 if (cardp->surprise_removed) {
421 lbs_deb_usbd(&cardp->udev->dev, "Device removed\n");
422 ret = -ENODEV;
423 goto tx_ret;
424 }
425
426 usb_fill_bulk_urb(cardp->tx_urb, cardp->udev,
427 usb_sndbulkpipe(cardp->udev,
428 cardp->ep_out),
429 payload, nb, if_usb_write_bulk_callback, cardp);
430
431 cardp->tx_urb->transfer_flags |= URB_ZERO_PACKET;
432
433 if ((ret = usb_submit_urb(cardp->tx_urb, GFP_ATOMIC))) {
434 lbs_deb_usbd(&cardp->udev->dev, "usb_submit_urb failed: %d\n", ret);
435 } else {
436 lbs_deb_usb2(&cardp->udev->dev, "usb_submit_urb success\n");
437 ret = 0;
438 }
439
440tx_ret:
441 return ret;
442}
443
444static int __if_usb_submit_rx_urb(struct if_usb_card *cardp,
445 void (*callbackfn)(struct urb *urb))
446{
447 struct sk_buff *skb;
448 int ret = -1;
449
450 if (!(skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE))) {
451 pr_err("No free skb\n");
452 goto rx_ret;
453 }
454
455 cardp->rx_skb = skb;
456
457
458 usb_fill_bulk_urb(cardp->rx_urb, cardp->udev,
459 usb_rcvbulkpipe(cardp->udev, cardp->ep_in),
460 skb->data + IPFIELD_ALIGN_OFFSET,
461 MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn,
462 cardp);
463
464 lbs_deb_usb2(&cardp->udev->dev, "Pointer for rx_urb %p\n", cardp->rx_urb);
465 if ((ret = usb_submit_urb(cardp->rx_urb, GFP_ATOMIC))) {
466 lbs_deb_usbd(&cardp->udev->dev, "Submit Rx URB failed: %d\n", ret);
467 kfree_skb(skb);
468 cardp->rx_skb = NULL;
469 ret = -1;
470 } else {
471 lbs_deb_usb2(&cardp->udev->dev, "Submit Rx URB success\n");
472 ret = 0;
473 }
474
475rx_ret:
476 return ret;
477}
478
479static int if_usb_submit_rx_urb_fwload(struct if_usb_card *cardp)
480{
481 return __if_usb_submit_rx_urb(cardp, &if_usb_receive_fwload);
482}
483
484static int if_usb_submit_rx_urb(struct if_usb_card *cardp)
485{
486 return __if_usb_submit_rx_urb(cardp, &if_usb_receive);
487}
488
489static void if_usb_receive_fwload(struct urb *urb)
490{
491 struct if_usb_card *cardp = urb->context;
492 struct sk_buff *skb = cardp->rx_skb;
493 struct fwsyncheader *syncfwheader;
494 struct bootcmdresp bootcmdresp;
495
496 if (urb->status) {
497 lbs_deb_usbd(&cardp->udev->dev,
498 "URB status is failed during fw load\n");
499 kfree_skb(skb);
500 return;
501 }
502
503 if (cardp->fwdnldover) {
504 __le32 *tmp = (__le32 *)(skb->data + IPFIELD_ALIGN_OFFSET);
505
506 if (tmp[0] == cpu_to_le32(CMD_TYPE_INDICATION) &&
507 tmp[1] == cpu_to_le32(MACREG_INT_CODE_FIRMWARE_READY)) {
508 pr_info("Firmware ready event received\n");
509 wake_up(&cardp->fw_wq);
510 } else {
511 lbs_deb_usb("Waiting for confirmation; got %x %x\n",
512 le32_to_cpu(tmp[0]), le32_to_cpu(tmp[1]));
513 if_usb_submit_rx_urb_fwload(cardp);
514 }
515 kfree_skb(skb);
516 return;
517 }
518 if (cardp->bootcmdresp <= 0) {
519 memcpy (&bootcmdresp, skb->data + IPFIELD_ALIGN_OFFSET,
520 sizeof(bootcmdresp));
521
522 if (le16_to_cpu(cardp->udev->descriptor.bcdDevice) < 0x3106) {
523 kfree_skb(skb);
524 if_usb_submit_rx_urb_fwload(cardp);
525 cardp->bootcmdresp = BOOT_CMD_RESP_OK;
526 lbs_deb_usbd(&cardp->udev->dev,
527 "Received valid boot command response\n");
528 return;
529 }
530 if (bootcmdresp.magic != cpu_to_le32(BOOT_CMD_MAGIC_NUMBER)) {
531 if (bootcmdresp.magic == cpu_to_le32(CMD_TYPE_REQUEST) ||
532 bootcmdresp.magic == cpu_to_le32(CMD_TYPE_DATA) ||
533 bootcmdresp.magic == cpu_to_le32(CMD_TYPE_INDICATION)) {
534 if (!cardp->bootcmdresp)
535 pr_info("Firmware already seems alive; resetting\n");
536 cardp->bootcmdresp = -1;
537 } else {
538 pr_info("boot cmd response wrong magic number (0x%x)\n",
539 le32_to_cpu(bootcmdresp.magic));
540 }
541 } else if ((bootcmdresp.cmd != BOOT_CMD_FW_BY_USB) &&
542 (bootcmdresp.cmd != BOOT_CMD_UPDATE_FW) &&
543 (bootcmdresp.cmd != BOOT_CMD_UPDATE_BOOT2)) {
544 pr_info("boot cmd response cmd_tag error (%d)\n",
545 bootcmdresp.cmd);
546 } else if (bootcmdresp.result != BOOT_CMD_RESP_OK) {
547 pr_info("boot cmd response result error (%d)\n",
548 bootcmdresp.result);
549 } else {
550 cardp->bootcmdresp = 1;
551 lbs_deb_usbd(&cardp->udev->dev,
552 "Received valid boot command response\n");
553 }
554 kfree_skb(skb);
555 if_usb_submit_rx_urb_fwload(cardp);
556 return;
557 }
558
559 syncfwheader = kmemdup(skb->data + IPFIELD_ALIGN_OFFSET,
560 sizeof(struct fwsyncheader), GFP_ATOMIC);
561 if (!syncfwheader) {
562 lbs_deb_usbd(&cardp->udev->dev, "Failure to allocate syncfwheader\n");
563 kfree_skb(skb);
564 return;
565 }
566
567 if (!syncfwheader->cmd) {
568 lbs_deb_usb2(&cardp->udev->dev, "FW received Blk with correct CRC\n");
569 lbs_deb_usb2(&cardp->udev->dev, "FW received Blk seqnum = %d\n",
570 le32_to_cpu(syncfwheader->seqnum));
571 cardp->CRC_OK = 1;
572 } else {
573 lbs_deb_usbd(&cardp->udev->dev, "FW received Blk with CRC error\n");
574 cardp->CRC_OK = 0;
575 }
576
577 kfree_skb(skb);
578
579
580 mod_timer(&cardp->fw_timeout, jiffies + (HZ*5));
581
582 if (cardp->fwfinalblk) {
583 cardp->fwdnldover = 1;
584 goto exit;
585 }
586
587 if_usb_send_fw_pkt(cardp);
588
589 exit:
590 if_usb_submit_rx_urb_fwload(cardp);
591
592 kfree(syncfwheader);
593}
594
595#define MRVDRV_MIN_PKT_LEN 30
596
597static inline void process_cmdtypedata(int recvlength, struct sk_buff *skb,
598 struct if_usb_card *cardp,
599 struct lbs_private *priv)
600{
601 if (recvlength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + MESSAGE_HEADER_LEN
602 || recvlength < MRVDRV_MIN_PKT_LEN) {
603 lbs_deb_usbd(&cardp->udev->dev, "Packet length is Invalid\n");
604 kfree_skb(skb);
605 return;
606 }
607
608 skb_reserve(skb, IPFIELD_ALIGN_OFFSET);
609 skb_put(skb, recvlength);
610 skb_pull(skb, MESSAGE_HEADER_LEN);
611
612 lbs_process_rxed_packet(priv, skb);
613}
614
615static inline void process_cmdrequest(int recvlength, uint8_t *recvbuff,
616 struct sk_buff *skb,
617 struct if_usb_card *cardp,
618 struct lbs_private *priv)
619{
620 unsigned long flags;
621 u8 i;
622
623 if (recvlength > LBS_CMD_BUFFER_SIZE) {
624 lbs_deb_usbd(&cardp->udev->dev,
625 "The receive buffer is too large\n");
626 kfree_skb(skb);
627 return;
628 }
629
630 spin_lock_irqsave(&priv->driver_lock, flags);
631
632 i = (priv->resp_idx == 0) ? 1 : 0;
633 BUG_ON(priv->resp_len[i]);
634 priv->resp_len[i] = (recvlength - MESSAGE_HEADER_LEN);
635 memcpy(priv->resp_buf[i], recvbuff + MESSAGE_HEADER_LEN,
636 priv->resp_len[i]);
637 kfree_skb(skb);
638 lbs_notify_command_response(priv, i);
639
640 spin_unlock_irqrestore(&priv->driver_lock, flags);
641
642 lbs_deb_usbd(&cardp->udev->dev,
643 "Wake up main thread to handle cmd response\n");
644}
645
646
647
648
649
650
651
652
653static void if_usb_receive(struct urb *urb)
654{
655 struct if_usb_card *cardp = urb->context;
656 struct sk_buff *skb = cardp->rx_skb;
657 struct lbs_private *priv = cardp->priv;
658 int recvlength = urb->actual_length;
659 uint8_t *recvbuff = NULL;
660 uint32_t recvtype = 0;
661 __le32 *pkt = (__le32 *)(skb->data + IPFIELD_ALIGN_OFFSET);
662 uint32_t event;
663
664 if (recvlength) {
665 if (urb->status) {
666 lbs_deb_usbd(&cardp->udev->dev, "RX URB failed: %d\n",
667 urb->status);
668 kfree_skb(skb);
669 goto setup_for_next;
670 }
671
672 recvbuff = skb->data + IPFIELD_ALIGN_OFFSET;
673 recvtype = le32_to_cpu(pkt[0]);
674 lbs_deb_usbd(&cardp->udev->dev,
675 "Recv length = 0x%x, Recv type = 0x%X\n",
676 recvlength, recvtype);
677 } else if (urb->status) {
678 kfree_skb(skb);
679 return;
680 }
681
682 switch (recvtype) {
683 case CMD_TYPE_DATA:
684 process_cmdtypedata(recvlength, skb, cardp, priv);
685 break;
686
687 case CMD_TYPE_REQUEST:
688 process_cmdrequest(recvlength, recvbuff, skb, cardp, priv);
689 break;
690
691 case CMD_TYPE_INDICATION:
692
693 event = le32_to_cpu(pkt[1]);
694 lbs_deb_usbd(&cardp->udev->dev, "**EVENT** 0x%X\n", event);
695 kfree_skb(skb);
696
697
698 if (event & 0xffff0000) {
699 u32 trycount = (event & 0xffff0000) >> 16;
700
701 lbs_send_tx_feedback(priv, trycount);
702 } else
703 lbs_queue_event(priv, event & 0xFF);
704 break;
705
706 default:
707 lbs_deb_usbd(&cardp->udev->dev, "Unknown command type 0x%X\n",
708 recvtype);
709 kfree_skb(skb);
710 break;
711 }
712
713setup_for_next:
714 if_usb_submit_rx_urb(cardp);
715}
716
717
718
719
720
721
722
723
724
725static int if_usb_host_to_card(struct lbs_private *priv, uint8_t type,
726 uint8_t *payload, uint16_t nb)
727{
728 struct if_usb_card *cardp = priv->card;
729
730 lbs_deb_usbd(&cardp->udev->dev,"*** type = %u\n", type);
731 lbs_deb_usbd(&cardp->udev->dev,"size after = %d\n", nb);
732
733 if (type == MVMS_CMD) {
734 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
735 priv->dnld_sent = DNLD_CMD_SENT;
736 } else {
737 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_DATA);
738 priv->dnld_sent = DNLD_DATA_SENT;
739 }
740
741 memcpy((cardp->ep_out_buf + MESSAGE_HEADER_LEN), payload, nb);
742
743 return usb_tx_block(cardp, cardp->ep_out_buf, nb + MESSAGE_HEADER_LEN);
744}
745
746
747
748
749
750
751
752
753static int if_usb_issue_boot_command(struct if_usb_card *cardp, int ivalue)
754{
755 struct bootcmd *bootcmd = cardp->ep_out_buf;
756
757
758 bootcmd->magic = cpu_to_le32(BOOT_CMD_MAGIC_NUMBER);
759 bootcmd->cmd = ivalue;
760 memset(bootcmd->pad, 0, sizeof(bootcmd->pad));
761
762
763 usb_tx_block(cardp, cardp->ep_out_buf, sizeof(*bootcmd));
764
765 return 0;
766}
767
768
769
770
771
772
773
774
775
776static int check_fwfile_format(const uint8_t *data, uint32_t totlen)
777{
778 uint32_t bincmd, exit;
779 uint32_t blksize, offset, len;
780 int ret;
781
782 ret = 1;
783 exit = len = 0;
784
785 do {
786 struct fwheader *fwh = (void *)data;
787
788 bincmd = le32_to_cpu(fwh->dnldcmd);
789 blksize = le32_to_cpu(fwh->datalength);
790 switch (bincmd) {
791 case FW_HAS_DATA_TO_RECV:
792 offset = sizeof(struct fwheader) + blksize;
793 data += offset;
794 len += offset;
795 if (len >= totlen)
796 exit = 1;
797 break;
798 case FW_HAS_LAST_BLOCK:
799 exit = 1;
800 ret = 0;
801 break;
802 default:
803 exit = 1;
804 break;
805 }
806 } while (!exit);
807
808 if (ret)
809 pr_err("firmware file format check FAIL\n");
810 else
811 lbs_deb_fw("firmware file format check PASS\n");
812
813 return ret;
814}
815
816static void if_usb_prog_firmware(struct lbs_private *priv, int ret,
817 const struct firmware *fw,
818 const struct firmware *unused)
819{
820 struct if_usb_card *cardp = priv->card;
821 int i = 0;
822 static int reset_count = 10;
823
824 if (ret) {
825 pr_err("failed to find firmware (%d)\n", ret);
826 goto done;
827 }
828
829 cardp->fw = fw;
830 if (check_fwfile_format(cardp->fw->data, cardp->fw->size)) {
831 ret = -EINVAL;
832 goto done;
833 }
834
835
836 usb_kill_urb(cardp->rx_urb);
837 usb_kill_urb(cardp->tx_urb);
838
839 cardp->fwlastblksent = 0;
840 cardp->fwdnldover = 0;
841 cardp->totalbytes = 0;
842 cardp->fwfinalblk = 0;
843 cardp->bootcmdresp = 0;
844
845restart:
846 if (if_usb_submit_rx_urb_fwload(cardp) < 0) {
847 lbs_deb_usbd(&cardp->udev->dev, "URB submission is failed\n");
848 ret = -EIO;
849 goto done;
850 }
851
852 cardp->bootcmdresp = 0;
853 do {
854 int j = 0;
855 i++;
856 if_usb_issue_boot_command(cardp, BOOT_CMD_FW_BY_USB);
857
858 do {
859 j++;
860 msleep_interruptible(100);
861 } while (cardp->bootcmdresp == 0 && j < 10);
862 } while (cardp->bootcmdresp == 0 && i < 5);
863
864 if (cardp->bootcmdresp == BOOT_CMD_RESP_NOT_SUPPORTED) {
865
866 ret = -EOPNOTSUPP;
867 usb_kill_urb(cardp->rx_urb);
868 usb_kill_urb(cardp->tx_urb);
869 if (if_usb_submit_rx_urb(cardp) < 0)
870 ret = -EIO;
871 goto done;
872 } else if (cardp->bootcmdresp <= 0) {
873 if (--reset_count >= 0) {
874 if_usb_reset_device(cardp);
875 goto restart;
876 }
877 ret = -EIO;
878 goto done;
879 }
880
881 i = 0;
882
883 cardp->totalbytes = 0;
884 cardp->fwlastblksent = 0;
885 cardp->CRC_OK = 1;
886 cardp->fwdnldover = 0;
887 cardp->fwseqnum = -1;
888 cardp->totalbytes = 0;
889 cardp->fwfinalblk = 0;
890
891
892 if_usb_send_fw_pkt(cardp);
893
894
895 wait_event_interruptible(cardp->fw_wq, cardp->surprise_removed || cardp->fwdnldover);
896
897 del_timer_sync(&cardp->fw_timeout);
898 usb_kill_urb(cardp->rx_urb);
899
900 if (!cardp->fwdnldover) {
901 pr_info("failed to load fw, resetting device!\n");
902 if (--reset_count >= 0) {
903 if_usb_reset_device(cardp);
904 goto restart;
905 }
906
907 pr_info("FW download failure, time = %d ms\n", i * 100);
908 ret = -EIO;
909 goto done;
910 }
911
912 cardp->priv->fw_ready = 1;
913 if_usb_submit_rx_urb(cardp);
914
915 if (lbs_start_card(priv))
916 goto done;
917
918 if_usb_setup_firmware(priv);
919
920
921
922
923 priv->wol_criteria = EHS_REMOVE_WAKEUP;
924 if (lbs_host_sleep_cfg(priv, priv->wol_criteria, NULL))
925 priv->ehs_remove_supported = false;
926
927 done:
928 cardp->fw = NULL;
929}
930
931
932#ifdef CONFIG_PM
933static int if_usb_suspend(struct usb_interface *intf, pm_message_t message)
934{
935 struct if_usb_card *cardp = usb_get_intfdata(intf);
936 struct lbs_private *priv = cardp->priv;
937 int ret;
938
939 if (priv->psstate != PS_STATE_FULL_POWER) {
940 ret = -1;
941 goto out;
942 }
943
944#ifdef CONFIG_OLPC
945 if (machine_is_olpc()) {
946 if (priv->wol_criteria == EHS_REMOVE_WAKEUP)
947 olpc_ec_wakeup_clear(EC_SCI_SRC_WLAN);
948 else
949 olpc_ec_wakeup_set(EC_SCI_SRC_WLAN);
950 }
951#endif
952
953 ret = lbs_suspend(priv);
954 if (ret)
955 goto out;
956
957
958 usb_kill_urb(cardp->tx_urb);
959 usb_kill_urb(cardp->rx_urb);
960
961 out:
962 return ret;
963}
964
965static int if_usb_resume(struct usb_interface *intf)
966{
967 struct if_usb_card *cardp = usb_get_intfdata(intf);
968 struct lbs_private *priv = cardp->priv;
969
970 if_usb_submit_rx_urb(cardp);
971
972 lbs_resume(priv);
973
974 return 0;
975}
976#else
977#define if_usb_suspend NULL
978#define if_usb_resume NULL
979#endif
980
981static struct usb_driver if_usb_driver = {
982 .name = DRV_NAME,
983 .probe = if_usb_probe,
984 .disconnect = if_usb_disconnect,
985 .id_table = if_usb_table,
986 .suspend = if_usb_suspend,
987 .resume = if_usb_resume,
988 .reset_resume = if_usb_resume,
989 .disable_hub_initiated_lpm = 1,
990};
991
992module_usb_driver(if_usb_driver);
993
994MODULE_DESCRIPTION("8388 USB WLAN Driver");
995MODULE_AUTHOR("Marvell International Ltd. and Red Hat, Inc.");
996MODULE_LICENSE("GPL");
997
