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