Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/net/wireless/libertas/if_usb.c

  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 {
 40         MODEL_UNKNOWN = 0x0,
 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 
 77 /**
 78  * if_usb_write_bulk_callback - callback function to handle the status
 79  * of the URB
 80  * @urb:        pointer to &urb structure
 81  * returns:     N/A
 82  */
 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 
107 /**
108  * if_usb_free - free tx/rx urb, skb and rx buffer
109  * @cardp:      pointer to &if_usb_card
110  * returns:     N/A
111  */
112 static void if_usb_free(struct if_usb_card *cardp)
113 {
114         lbs_deb_enter(LBS_DEB_USB);
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 
129         lbs_deb_leave(LBS_DEB_USB);
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    */
147         lbs_host_sleep_cfg(priv, EHS_WAKE_ON_UNICAST_DATA,
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 
189 /**
190  * if_usb_probe - sets the configuration values
191  * @intf:       &usb_interface pointer
192  * @id: pointer to usb_device_id
193  * returns:     0 on success, error code on failure
194  */
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;
200         struct usb_endpoint_descriptor *endpoint;
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         }
255         cardp->ep_out_buf = kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE, GFP_KERNEL);
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;
269         priv->reset_deep_sleep_wakeup = 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 
298 /**
299  * if_usb_disconnect - free resource and cleanup
300  * @intf:       USB interface structure
301  * returns:     N/A
302  */
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 
308         lbs_deb_enter(LBS_DEB_MAIN);
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 
323         lbs_deb_leave(LBS_DEB_MAIN);
324 }
325 
326 /**
327  * if_usb_send_fw_pkt - download FW
328  * @cardp:      pointer to &struct if_usb_card
329  * returns:     0
330  */
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 
390         lbs_deb_enter(LBS_DEB_USB);
391 
392         *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
393 
394         cmd->command = cpu_to_le16(CMD_802_11_RESET);
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 
414 /**
415  *  usb_tx_block - transfer the data to the device
416  *  @cardp:     pointer to &struct if_usb_card
417  *  @payload:   pointer to payload data
418  *  @nb:        data length
419  *  returns:    0 for success or negative error code
420  */
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,
467                           MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn,
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) &&
515                     tmp[1] == cpu_to_le32(MACREG_INT_CODE_FIRMWARE_READY)) {
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) {
527                 memcpy (&bootcmdresp, skb->data + IPFIELD_ALIGN_OFFSET,
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                 }
538                 if (bootcmdresp.magic != cpu_to_le32(BOOT_CMD_MAGIC_NUMBER)) {
539                         if (bootcmdresp.magic == cpu_to_le32(CMD_TYPE_REQUEST) ||
540                             bootcmdresp.magic == cpu_to_le32(CMD_TYPE_DATA) ||
541                             bootcmdresp.magic == cpu_to_le32(CMD_TYPE_INDICATION)) {
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",
547                                             le32_to_cpu(bootcmdresp.magic));
548                         }
549                 } else if ((bootcmdresp.cmd != BOOT_CMD_FW_BY_USB) &&
550                            (bootcmdresp.cmd != BOOT_CMD_UPDATE_FW) &&
551                            (bootcmdresp.cmd != BOOT_CMD_UPDATE_BOOT2)) {
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",
556                                 bootcmdresp.result);
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 {
609         if (recvlength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + MESSAGE_HEADER_LEN
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);
618         skb_pull(skb, MESSAGE_HEADER_LEN);
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);
647         lbs_notify_command_response(priv, i);
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 
655 /**
656  *  if_usb_receive - read the packet into the upload buffer,
657  *  wake up the main thread and initialise the Rx callack
658  *
659  *  @urb:       pointer to &struct urb
660  *  returns:    N/A
661  */
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 
673         lbs_deb_enter(LBS_DEB_USB);
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:
727         lbs_deb_leave(LBS_DEB_USB);
728 }
729 
730 /**
731  *  if_usb_host_to_card - downloads data to FW
732  *  @priv:      pointer to &struct lbs_private structure
733  *  @type:      type of data
734  *  @payload:   pointer to data buffer
735  *  @nb:        number of bytes
736  *  returns:    0 for success or negative error code
737  */
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) {
747                 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
748                 priv->dnld_sent = DNLD_CMD_SENT;
749         } else {
750                 *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_DATA);
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 
759 /**
760  *  if_usb_issue_boot_command - issues Boot command to the Boot2 code
761  *  @cardp:     pointer to &if_usb_card
762  *  @ivalue:    1:Boot from FW by USB-Download
763  *              2:Boot from FW in EEPROM
764  *  returns:    0 for success or negative error code
765  */
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 */
771         bootcmd->magic = cpu_to_le32(BOOT_CMD_MAGIC_NUMBER);
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 
782 /**
783  *  check_fwfile_format - check the validity of Boot2/FW image
784  *
785  *  @data:      pointer to image
786  *  @totlen:    image length
787  *  returns:     0 (good) or 1 (failure)
788  */
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 
837         lbs_deb_enter(LBS_DEB_USB);
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 done;
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 done;
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++;
875                         msleep_interruptible(100);
876                 } while (cardp->bootcmdresp == 0 && j < 10);
877         } while (cardp->bootcmdresp == 0 && i < 5);
878 
879         if (cardp->bootcmdresp == BOOT_CMD_RESP_NOT_SUPPORTED) {
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 done;
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 done;
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 done;
925         }
926 
927         cardp->priv->fw_ready = 1;
928         if_usb_submit_rx_urb(cardp);
929 
930         if (lbs_start_card(priv))
931                 goto done;
932 
933         if_usb_setup_firmware(priv);
934 
935         /*
936          * EHS_REMOVE_WAKEUP is not supported on all versions of the firmware.
937          */
938         priv->wol_criteria = EHS_REMOVE_WAKEUP;
939         if (lbs_host_sleep_cfg(priv, priv->wol_criteria, NULL))
940                 priv->ehs_remove_supported = false;
941 
942  done:
943         cardp->fw = NULL;
944         lbs_deb_leave(LBS_DEB_USB);
945 }
946 
947 
948 #ifdef CONFIG_PM
949 static int if_usb_suspend(struct usb_interface *intf, pm_message_t message)
950 {
951         struct if_usb_card *cardp = usb_get_intfdata(intf);
952         struct lbs_private *priv = cardp->priv;
953         int ret;
954 
955         lbs_deb_enter(LBS_DEB_USB);
956 
957         if (priv->psstate != PS_STATE_FULL_POWER) {
958                 ret = -1;
959                 goto out;
960         }
961 
962 #ifdef CONFIG_OLPC
963         if (machine_is_olpc()) {
964                 if (priv->wol_criteria == EHS_REMOVE_WAKEUP)
965                         olpc_ec_wakeup_clear(EC_SCI_SRC_WLAN);
966                 else
967                         olpc_ec_wakeup_set(EC_SCI_SRC_WLAN);
968         }
969 #endif
970 
971         ret = lbs_suspend(priv);
972         if (ret)
973                 goto out;
974 
975         /* Unlink tx & rx urb */
976         usb_kill_urb(cardp->tx_urb);
977         usb_kill_urb(cardp->rx_urb);
978 
979  out:
980         lbs_deb_leave(LBS_DEB_USB);
981         return ret;
982 }
983 
984 static int if_usb_resume(struct usb_interface *intf)
985 {
986         struct if_usb_card *cardp = usb_get_intfdata(intf);
987         struct lbs_private *priv = cardp->priv;
988 
989         lbs_deb_enter(LBS_DEB_USB);
990 
991         if_usb_submit_rx_urb(cardp);
992 
993         lbs_resume(priv);
994 
995         lbs_deb_leave(LBS_DEB_USB);
996         return 0;
997 }
998 #else
999 #define if_usb_suspend NULL
1000 #define if_usb_resume NULL
1001 #endif
1002 
1003 static struct usb_driver if_usb_driver = {
1004         .name = DRV_NAME,
1005         .probe = if_usb_probe,
1006         .disconnect = if_usb_disconnect,
1007         .id_table = if_usb_table,
1008         .suspend = if_usb_suspend,
1009         .resume = if_usb_resume,
1010         .reset_resume = if_usb_resume,
1011         .disable_hub_initiated_lpm = 1,
1012 };
1013 
1014 module_usb_driver(if_usb_driver);
1015 
1016 MODULE_DESCRIPTION("8388 USB WLAN Driver");
1017 MODULE_AUTHOR("Marvell International Ltd. and Red Hat, Inc.");
1018 MODULE_LICENSE("GPL");
1019 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us