Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Copyright (C) 2008, cozybit Inc.
0004  *  Copyright (C) 2003-2006, Marvell International Ltd.
0005  */
0006 #define DRV_NAME "lbtf_usb"
0007 
0008 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0009 
0010 #include "libertas_tf.h"
0011 #include "if_usb.h"
0012 
0013 #include <linux/delay.h>
0014 #include <linux/module.h>
0015 #include <linux/firmware.h>
0016 #include <linux/netdevice.h>
0017 #include <linux/slab.h>
0018 #include <linux/usb.h>
0019 
0020 #define INSANEDEBUG 0
0021 #define lbtf_deb_usb2(...) do { if (INSANEDEBUG) lbtf_deb_usbd(__VA_ARGS__); } while (0)
0022 
0023 #define MESSAGE_HEADER_LEN  4
0024 
0025 static char *lbtf_fw_name = "lbtf_usb.bin";
0026 module_param_named(fw_name, lbtf_fw_name, charp, 0644);
0027 
0028 MODULE_FIRMWARE("lbtf_usb.bin");
0029 
0030 static const struct usb_device_id if_usb_table[] = {
0031     /* Enter the device signature inside */
0032     { USB_DEVICE(0x1286, 0x2001) },
0033     { USB_DEVICE(0x05a3, 0x8388) },
0034     {}  /* Terminating entry */
0035 };
0036 
0037 MODULE_DEVICE_TABLE(usb, if_usb_table);
0038 
0039 static void if_usb_receive(struct urb *urb);
0040 static void if_usb_receive_fwload(struct urb *urb);
0041 static int if_usb_prog_firmware(struct lbtf_private *priv);
0042 static int if_usb_host_to_card(struct lbtf_private *priv, uint8_t type,
0043                    uint8_t *payload, uint16_t nb);
0044 static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload,
0045             uint16_t nb, u8 data);
0046 static void if_usb_free(struct if_usb_card *cardp);
0047 static int if_usb_submit_rx_urb(struct if_usb_card *cardp);
0048 static int if_usb_reset_device(struct lbtf_private *priv);
0049 
0050 /**
0051  *  if_usb_write_bulk_callback -  call back to handle URB status
0052  *
0053  *  @urb:       pointer to urb structure
0054  */
0055 static void if_usb_write_bulk_callback(struct urb *urb)
0056 {
0057     if (urb->status != 0) {
0058         /* print the failure status number for debug */
0059         pr_info("URB in failure status: %d\n", urb->status);
0060     } else {
0061         lbtf_deb_usb2(&urb->dev->dev, "URB status is successful\n");
0062         lbtf_deb_usb2(&urb->dev->dev, "Actual length transmitted %d\n",
0063                  urb->actual_length);
0064     }
0065 }
0066 
0067 /**
0068  *  if_usb_free - free tx/rx urb, skb and rx buffer
0069  *
0070  *  @cardp: pointer if_usb_card
0071  */
0072 static void if_usb_free(struct if_usb_card *cardp)
0073 {
0074     lbtf_deb_enter(LBTF_DEB_USB);
0075 
0076     /* Unlink tx & rx urb */
0077     usb_kill_urb(cardp->tx_urb);
0078     usb_kill_urb(cardp->rx_urb);
0079     usb_kill_urb(cardp->cmd_urb);
0080 
0081     usb_free_urb(cardp->tx_urb);
0082     cardp->tx_urb = NULL;
0083 
0084     usb_free_urb(cardp->rx_urb);
0085     cardp->rx_urb = NULL;
0086 
0087     usb_free_urb(cardp->cmd_urb);
0088     cardp->cmd_urb = NULL;
0089 
0090     kfree(cardp->ep_out_buf);
0091     cardp->ep_out_buf = NULL;
0092 
0093     lbtf_deb_leave(LBTF_DEB_USB);
0094 }
0095 
0096 static void if_usb_setup_firmware(struct lbtf_private *priv)
0097 {
0098     struct if_usb_card *cardp = priv->card;
0099     struct cmd_ds_set_boot2_ver b2_cmd;
0100 
0101     lbtf_deb_enter(LBTF_DEB_USB);
0102 
0103     if_usb_submit_rx_urb(cardp);
0104     b2_cmd.hdr.size = cpu_to_le16(sizeof(b2_cmd));
0105     b2_cmd.action = 0;
0106     b2_cmd.version = cardp->boot2_version;
0107 
0108     if (lbtf_cmd_with_response(priv, CMD_SET_BOOT2_VER, &b2_cmd))
0109         lbtf_deb_usb("Setting boot2 version failed\n");
0110 
0111     lbtf_deb_leave(LBTF_DEB_USB);
0112 }
0113 
0114 static void if_usb_fw_timeo(struct timer_list *t)
0115 {
0116     struct if_usb_card *cardp = from_timer(cardp, t, fw_timeout);
0117 
0118     lbtf_deb_enter(LBTF_DEB_USB);
0119     if (!cardp->fwdnldover) {
0120         /* Download timed out */
0121         cardp->priv->surpriseremoved = 1;
0122         pr_err("Download timed out\n");
0123     } else {
0124         lbtf_deb_usb("Download complete, no event. Assuming success\n");
0125     }
0126     wake_up(&cardp->fw_wq);
0127     lbtf_deb_leave(LBTF_DEB_USB);
0128 }
0129 
0130 static const struct lbtf_ops if_usb_ops = {
0131     .hw_host_to_card = if_usb_host_to_card,
0132     .hw_prog_firmware = if_usb_prog_firmware,
0133     .hw_reset_device = if_usb_reset_device,
0134 };
0135 
0136 /**
0137  *  if_usb_probe - sets the configuration values
0138  *
0139  *  @intf:  USB interface structure
0140  *  @id:    pointer to usb_device_id
0141  *
0142  *  Returns: 0 on success, error code on failure
0143  */
0144 static int if_usb_probe(struct usb_interface *intf,
0145             const struct usb_device_id *id)
0146 {
0147     struct usb_device *udev;
0148     struct usb_host_interface *iface_desc;
0149     struct usb_endpoint_descriptor *endpoint;
0150     struct lbtf_private *priv;
0151     struct if_usb_card *cardp;
0152     int i;
0153 
0154     lbtf_deb_enter(LBTF_DEB_USB);
0155     udev = interface_to_usbdev(intf);
0156 
0157     cardp = kzalloc(sizeof(struct if_usb_card), GFP_KERNEL);
0158     if (!cardp)
0159         goto error;
0160 
0161     timer_setup(&cardp->fw_timeout, if_usb_fw_timeo, 0);
0162     init_waitqueue_head(&cardp->fw_wq);
0163 
0164     cardp->udev = udev;
0165     iface_desc = intf->cur_altsetting;
0166 
0167     lbtf_deb_usbd(&udev->dev, "bcdUSB = 0x%X bDeviceClass = 0x%X"
0168              " bDeviceSubClass = 0x%X, bDeviceProtocol = 0x%X\n",
0169              le16_to_cpu(udev->descriptor.bcdUSB),
0170              udev->descriptor.bDeviceClass,
0171              udev->descriptor.bDeviceSubClass,
0172              udev->descriptor.bDeviceProtocol);
0173 
0174     for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
0175         endpoint = &iface_desc->endpoint[i].desc;
0176         if (usb_endpoint_is_bulk_in(endpoint)) {
0177             cardp->ep_in_size =
0178                 le16_to_cpu(endpoint->wMaxPacketSize);
0179             cardp->ep_in = usb_endpoint_num(endpoint);
0180 
0181             lbtf_deb_usbd(&udev->dev, "in_endpoint = %d\n",
0182                 cardp->ep_in);
0183             lbtf_deb_usbd(&udev->dev, "Bulk in size is %d\n",
0184                 cardp->ep_in_size);
0185         } else if (usb_endpoint_is_bulk_out(endpoint)) {
0186             cardp->ep_out_size =
0187                 le16_to_cpu(endpoint->wMaxPacketSize);
0188             cardp->ep_out = usb_endpoint_num(endpoint);
0189 
0190             lbtf_deb_usbd(&udev->dev, "out_endpoint = %d\n",
0191                 cardp->ep_out);
0192             lbtf_deb_usbd(&udev->dev, "Bulk out size is %d\n",
0193                 cardp->ep_out_size);
0194         }
0195     }
0196     if (!cardp->ep_out_size || !cardp->ep_in_size) {
0197         lbtf_deb_usbd(&udev->dev, "Endpoints not found\n");
0198         /* Endpoints not found */
0199         goto dealloc;
0200     }
0201 
0202     cardp->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
0203     if (!cardp->rx_urb)
0204         goto dealloc;
0205 
0206     cardp->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
0207     if (!cardp->tx_urb)
0208         goto dealloc;
0209 
0210     cardp->cmd_urb = usb_alloc_urb(0, GFP_KERNEL);
0211     if (!cardp->cmd_urb)
0212         goto dealloc;
0213 
0214     cardp->ep_out_buf = kmalloc(MRVDRV_ETH_TX_PACKET_BUFFER_SIZE,
0215                     GFP_KERNEL);
0216     if (!cardp->ep_out_buf) {
0217         lbtf_deb_usbd(&udev->dev, "Could not allocate buffer\n");
0218         goto dealloc;
0219     }
0220 
0221     cardp->boot2_version = udev->descriptor.bcdDevice;
0222     priv = lbtf_add_card(cardp, &udev->dev, &if_usb_ops);
0223     if (!priv)
0224         goto dealloc;
0225 
0226     usb_get_dev(udev);
0227     usb_set_intfdata(intf, cardp);
0228 
0229     return 0;
0230 
0231 dealloc:
0232     if_usb_free(cardp);
0233     kfree(cardp);
0234 error:
0235 lbtf_deb_leave(LBTF_DEB_MAIN);
0236     return -ENOMEM;
0237 }
0238 
0239 /**
0240  *  if_usb_disconnect -  free resource and cleanup
0241  *
0242  *  @intf:  USB interface structure
0243  */
0244 static void if_usb_disconnect(struct usb_interface *intf)
0245 {
0246     struct if_usb_card *cardp = usb_get_intfdata(intf);
0247     struct lbtf_private *priv = cardp->priv;
0248 
0249     lbtf_deb_enter(LBTF_DEB_MAIN);
0250 
0251     if (priv) {
0252         if_usb_reset_device(priv);
0253         lbtf_remove_card(priv);
0254     }
0255 
0256     /* Unlink and free urb */
0257     if_usb_free(cardp);
0258     kfree(cardp);
0259 
0260     usb_set_intfdata(intf, NULL);
0261     usb_put_dev(interface_to_usbdev(intf));
0262 
0263     lbtf_deb_leave(LBTF_DEB_MAIN);
0264 }
0265 
0266 /**
0267  *  if_usb_send_fw_pkt -  This function downloads the FW
0268  *
0269  *  @cardp: pointer if_usb_card
0270  *
0271  *  Returns: 0
0272  */
0273 static int if_usb_send_fw_pkt(struct if_usb_card *cardp)
0274 {
0275     struct fwdata *fwdata = cardp->ep_out_buf;
0276     u8 *firmware = (u8 *) cardp->fw->data;
0277 
0278     lbtf_deb_enter(LBTF_DEB_FW);
0279 
0280     /* If we got a CRC failure on the last block, back
0281        up and retry it */
0282     if (!cardp->CRC_OK) {
0283         cardp->totalbytes = cardp->fwlastblksent;
0284         cardp->fwseqnum--;
0285     }
0286 
0287     lbtf_deb_usb2(&cardp->udev->dev, "totalbytes = %d\n",
0288              cardp->totalbytes);
0289 
0290     /* struct fwdata (which we sent to the card) has an
0291        extra __le32 field in between the header and the data,
0292        which is not in the struct fwheader in the actual
0293        firmware binary. Insert the seqnum in the middle... */
0294     memcpy(&fwdata->hdr, &firmware[cardp->totalbytes],
0295            sizeof(struct fwheader));
0296 
0297     cardp->fwlastblksent = cardp->totalbytes;
0298     cardp->totalbytes += sizeof(struct fwheader);
0299 
0300     memcpy(fwdata->data, &firmware[cardp->totalbytes],
0301            le32_to_cpu(fwdata->hdr.datalength));
0302 
0303     lbtf_deb_usb2(&cardp->udev->dev, "Data length = %d\n",
0304              le32_to_cpu(fwdata->hdr.datalength));
0305 
0306     fwdata->seqnum = cpu_to_le32(++cardp->fwseqnum);
0307     cardp->totalbytes += le32_to_cpu(fwdata->hdr.datalength);
0308 
0309     usb_tx_block(cardp, cardp->ep_out_buf, sizeof(struct fwdata) +
0310              le32_to_cpu(fwdata->hdr.datalength), 0);
0311 
0312     if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_DATA_TO_RECV)) {
0313         lbtf_deb_usb2(&cardp->udev->dev, "There are data to follow\n");
0314         lbtf_deb_usb2(&cardp->udev->dev,
0315             "seqnum = %d totalbytes = %d\n",
0316             cardp->fwseqnum, cardp->totalbytes);
0317     } else if (fwdata->hdr.dnldcmd == cpu_to_le32(FW_HAS_LAST_BLOCK)) {
0318         lbtf_deb_usb2(&cardp->udev->dev,
0319             "Host has finished FW downloading\n");
0320         lbtf_deb_usb2(&cardp->udev->dev, "Downloading FW JUMP BLOCK\n");
0321 
0322         /* Host has finished FW downloading
0323          * Donwloading FW JUMP BLOCK
0324          */
0325         cardp->fwfinalblk = 1;
0326     }
0327 
0328     lbtf_deb_usb2(&cardp->udev->dev, "Firmware download done; size %d\n",
0329              cardp->totalbytes);
0330 
0331     lbtf_deb_leave(LBTF_DEB_FW);
0332     return 0;
0333 }
0334 
0335 static int if_usb_reset_device(struct lbtf_private *priv)
0336 {
0337     struct if_usb_card *cardp = priv->card;
0338     struct cmd_ds_802_11_reset *cmd = cardp->ep_out_buf + 4;
0339     int ret;
0340 
0341     lbtf_deb_enter(LBTF_DEB_USB);
0342 
0343     *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
0344 
0345     cmd->hdr.command = cpu_to_le16(CMD_802_11_RESET);
0346     cmd->hdr.size = cpu_to_le16(sizeof(struct cmd_ds_802_11_reset));
0347     cmd->hdr.result = cpu_to_le16(0);
0348     cmd->hdr.seqnum = cpu_to_le16(0x5a5a);
0349     cmd->action = cpu_to_le16(CMD_ACT_HALT);
0350     usb_tx_block(cardp, cardp->ep_out_buf,
0351              4 + sizeof(struct cmd_ds_802_11_reset), 0);
0352 
0353     msleep(100);
0354     ret = usb_reset_device(cardp->udev);
0355     msleep(100);
0356 
0357     lbtf_deb_leave_args(LBTF_DEB_USB, "ret %d", ret);
0358 
0359     return ret;
0360 }
0361 
0362 /**
0363  *  usb_tx_block - transfer data to the device
0364  *
0365  *  @cardp: pointer if_usb_card
0366  *  @payload:   pointer to payload data
0367  *  @nb:    data length
0368  *  @data:  non-zero for data, zero for commands
0369  *
0370  *  Returns: 0 on success, nonzero otherwise.
0371  */
0372 static int usb_tx_block(struct if_usb_card *cardp, uint8_t *payload,
0373             uint16_t nb, u8 data)
0374 {
0375     int ret = -1;
0376     struct urb *urb;
0377 
0378     lbtf_deb_enter(LBTF_DEB_USB);
0379     /* check if device is removed */
0380     if (cardp->priv->surpriseremoved) {
0381         lbtf_deb_usbd(&cardp->udev->dev, "Device removed\n");
0382         goto tx_ret;
0383     }
0384 
0385     if (data)
0386         urb = cardp->tx_urb;
0387     else
0388         urb = cardp->cmd_urb;
0389 
0390     usb_fill_bulk_urb(urb, cardp->udev,
0391               usb_sndbulkpipe(cardp->udev,
0392                       cardp->ep_out),
0393               payload, nb, if_usb_write_bulk_callback, cardp);
0394 
0395     urb->transfer_flags |= URB_ZERO_PACKET;
0396 
0397     if (usb_submit_urb(urb, GFP_ATOMIC)) {
0398         lbtf_deb_usbd(&cardp->udev->dev,
0399             "usb_submit_urb failed: %d\n", ret);
0400         goto tx_ret;
0401     }
0402 
0403     lbtf_deb_usb2(&cardp->udev->dev, "usb_submit_urb success\n");
0404 
0405     ret = 0;
0406 
0407 tx_ret:
0408     lbtf_deb_leave(LBTF_DEB_USB);
0409     return ret;
0410 }
0411 
0412 static int __if_usb_submit_rx_urb(struct if_usb_card *cardp,
0413                   void (*callbackfn)(struct urb *urb))
0414 {
0415     struct sk_buff *skb;
0416     int ret = -1;
0417 
0418     lbtf_deb_enter(LBTF_DEB_USB);
0419 
0420     skb = dev_alloc_skb(MRVDRV_ETH_RX_PACKET_BUFFER_SIZE);
0421     if (!skb) {
0422         pr_err("No free skb\n");
0423         lbtf_deb_leave(LBTF_DEB_USB);
0424         return -1;
0425     }
0426 
0427     cardp->rx_skb = skb;
0428 
0429     /* Fill the receive configuration URB and initialise the Rx call back */
0430     usb_fill_bulk_urb(cardp->rx_urb, cardp->udev,
0431               usb_rcvbulkpipe(cardp->udev, cardp->ep_in),
0432               skb_tail_pointer(skb),
0433               MRVDRV_ETH_RX_PACKET_BUFFER_SIZE, callbackfn, cardp);
0434 
0435     lbtf_deb_usb2(&cardp->udev->dev, "Pointer for rx_urb %p\n",
0436         cardp->rx_urb);
0437     ret = usb_submit_urb(cardp->rx_urb, GFP_ATOMIC);
0438     if (ret) {
0439         lbtf_deb_usbd(&cardp->udev->dev,
0440             "Submit Rx URB failed: %d\n", ret);
0441         kfree_skb(skb);
0442         cardp->rx_skb = NULL;
0443         lbtf_deb_leave(LBTF_DEB_USB);
0444         return -1;
0445     } else {
0446         lbtf_deb_usb2(&cardp->udev->dev, "Submit Rx URB success\n");
0447         lbtf_deb_leave(LBTF_DEB_USB);
0448         return 0;
0449     }
0450 }
0451 
0452 static int if_usb_submit_rx_urb_fwload(struct if_usb_card *cardp)
0453 {
0454     return __if_usb_submit_rx_urb(cardp, &if_usb_receive_fwload);
0455 }
0456 
0457 static int if_usb_submit_rx_urb(struct if_usb_card *cardp)
0458 {
0459     return __if_usb_submit_rx_urb(cardp, &if_usb_receive);
0460 }
0461 
0462 static void if_usb_receive_fwload(struct urb *urb)
0463 {
0464     struct if_usb_card *cardp = urb->context;
0465     struct sk_buff *skb = cardp->rx_skb;
0466     struct fwsyncheader *syncfwheader;
0467     struct bootcmdresp bcmdresp;
0468 
0469     lbtf_deb_enter(LBTF_DEB_USB);
0470     if (urb->status) {
0471         lbtf_deb_usbd(&cardp->udev->dev,
0472                  "URB status is failed during fw load\n");
0473         kfree_skb(skb);
0474         lbtf_deb_leave(LBTF_DEB_USB);
0475         return;
0476     }
0477 
0478     if (cardp->fwdnldover) {
0479         __le32 *tmp = (__le32 *)(skb->data);
0480 
0481         if (tmp[0] == cpu_to_le32(CMD_TYPE_INDICATION) &&
0482             tmp[1] == cpu_to_le32(MACREG_INT_CODE_FIRMWARE_READY)) {
0483             /* Firmware ready event received */
0484             pr_info("Firmware ready event received\n");
0485             wake_up(&cardp->fw_wq);
0486         } else {
0487             lbtf_deb_usb("Waiting for confirmation; got %x %x\n",
0488                     le32_to_cpu(tmp[0]), le32_to_cpu(tmp[1]));
0489             if_usb_submit_rx_urb_fwload(cardp);
0490         }
0491         kfree_skb(skb);
0492         lbtf_deb_leave(LBTF_DEB_USB);
0493         return;
0494     }
0495     if (cardp->bootcmdresp <= 0) {
0496         memcpy(&bcmdresp, skb->data, sizeof(bcmdresp));
0497 
0498         if (le16_to_cpu(cardp->udev->descriptor.bcdDevice) < 0x3106) {
0499             kfree_skb(skb);
0500             if_usb_submit_rx_urb_fwload(cardp);
0501             cardp->bootcmdresp = 1;
0502             /* Received valid boot command response */
0503             lbtf_deb_usbd(&cardp->udev->dev,
0504                      "Received valid boot command response\n");
0505             lbtf_deb_leave(LBTF_DEB_USB);
0506             return;
0507         }
0508         if (bcmdresp.magic != cpu_to_le32(BOOT_CMD_MAGIC_NUMBER)) {
0509             if (bcmdresp.magic == cpu_to_le32(CMD_TYPE_REQUEST) ||
0510                 bcmdresp.magic == cpu_to_le32(CMD_TYPE_DATA) ||
0511                 bcmdresp.magic == cpu_to_le32(CMD_TYPE_INDICATION)) {
0512                 if (!cardp->bootcmdresp)
0513                     pr_info("Firmware already seems alive; resetting\n");
0514                 cardp->bootcmdresp = -1;
0515             } else {
0516                 pr_info("boot cmd response wrong magic number (0x%x)\n",
0517                         le32_to_cpu(bcmdresp.magic));
0518             }
0519         } else if (bcmdresp.cmd != BOOT_CMD_FW_BY_USB) {
0520             pr_info("boot cmd response cmd_tag error (%d)\n",
0521                 bcmdresp.cmd);
0522         } else if (bcmdresp.result != BOOT_CMD_RESP_OK) {
0523             pr_info("boot cmd response result error (%d)\n",
0524                 bcmdresp.result);
0525         } else {
0526             cardp->bootcmdresp = 1;
0527             lbtf_deb_usbd(&cardp->udev->dev,
0528                 "Received valid boot command response\n");
0529         }
0530 
0531         kfree_skb(skb);
0532         if_usb_submit_rx_urb_fwload(cardp);
0533         lbtf_deb_leave(LBTF_DEB_USB);
0534         return;
0535     }
0536 
0537     syncfwheader = kmemdup(skb->data, sizeof(struct fwsyncheader),
0538                    GFP_ATOMIC);
0539     if (!syncfwheader) {
0540         lbtf_deb_usbd(&cardp->udev->dev,
0541             "Failure to allocate syncfwheader\n");
0542         kfree_skb(skb);
0543         lbtf_deb_leave(LBTF_DEB_USB);
0544         return;
0545     }
0546 
0547     if (!syncfwheader->cmd) {
0548         lbtf_deb_usb2(&cardp->udev->dev,
0549             "FW received Blk with correct CRC\n");
0550         lbtf_deb_usb2(&cardp->udev->dev,
0551             "FW received Blk seqnum = %d\n",
0552             le32_to_cpu(syncfwheader->seqnum));
0553         cardp->CRC_OK = 1;
0554     } else {
0555         lbtf_deb_usbd(&cardp->udev->dev,
0556             "FW received Blk with CRC error\n");
0557         cardp->CRC_OK = 0;
0558     }
0559 
0560     kfree_skb(skb);
0561 
0562     /* reschedule timer for 200ms hence */
0563     mod_timer(&cardp->fw_timeout, jiffies + (HZ/5));
0564 
0565     if (cardp->fwfinalblk) {
0566         cardp->fwdnldover = 1;
0567         goto exit;
0568     }
0569 
0570     if_usb_send_fw_pkt(cardp);
0571 
0572  exit:
0573     if_usb_submit_rx_urb_fwload(cardp);
0574 
0575     kfree(syncfwheader);
0576 
0577     lbtf_deb_leave(LBTF_DEB_USB);
0578 }
0579 
0580 #define MRVDRV_MIN_PKT_LEN  30
0581 
0582 static inline void process_cmdtypedata(int recvlength, struct sk_buff *skb,
0583                        struct if_usb_card *cardp,
0584                        struct lbtf_private *priv)
0585 {
0586     if (recvlength > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE + MESSAGE_HEADER_LEN
0587         || recvlength < MRVDRV_MIN_PKT_LEN) {
0588         lbtf_deb_usbd(&cardp->udev->dev, "Packet length is Invalid\n");
0589         kfree_skb(skb);
0590         return;
0591     }
0592 
0593     skb_put(skb, recvlength);
0594     skb_pull(skb, MESSAGE_HEADER_LEN);
0595     lbtf_rx(priv, skb);
0596 }
0597 
0598 static inline void process_cmdrequest(int recvlength, uint8_t *recvbuff,
0599                       struct sk_buff *skb,
0600                       struct if_usb_card *cardp,
0601                       struct lbtf_private *priv)
0602 {
0603     unsigned long flags;
0604 
0605     if (recvlength < MESSAGE_HEADER_LEN ||
0606         recvlength > LBS_CMD_BUFFER_SIZE) {
0607         lbtf_deb_usbd(&cardp->udev->dev,
0608                  "The receive buffer is invalid: %d\n", recvlength);
0609         kfree_skb(skb);
0610         return;
0611     }
0612 
0613     spin_lock_irqsave(&priv->driver_lock, flags);
0614     memcpy(priv->cmd_resp_buff, recvbuff + MESSAGE_HEADER_LEN,
0615            recvlength - MESSAGE_HEADER_LEN);
0616     kfree_skb(skb);
0617     lbtf_cmd_response_rx(priv);
0618     spin_unlock_irqrestore(&priv->driver_lock, flags);
0619 }
0620 
0621 /**
0622  *  if_usb_receive - read data received from the device.
0623  *
0624  *  @urb:       pointer to struct urb
0625  */
0626 static void if_usb_receive(struct urb *urb)
0627 {
0628     struct if_usb_card *cardp = urb->context;
0629     struct sk_buff *skb = cardp->rx_skb;
0630     struct lbtf_private *priv = cardp->priv;
0631     int recvlength = urb->actual_length;
0632     uint8_t *recvbuff = NULL;
0633     uint32_t recvtype = 0;
0634     __le32 *pkt = (__le32 *) skb->data;
0635 
0636     lbtf_deb_enter(LBTF_DEB_USB);
0637 
0638     if (recvlength) {
0639         if (urb->status) {
0640             lbtf_deb_usbd(&cardp->udev->dev, "RX URB failed: %d\n",
0641                      urb->status);
0642             kfree_skb(skb);
0643             goto setup_for_next;
0644         }
0645 
0646         recvbuff = skb->data;
0647         recvtype = le32_to_cpu(pkt[0]);
0648         lbtf_deb_usbd(&cardp->udev->dev,
0649                 "Recv length = 0x%x, Recv type = 0x%X\n",
0650                 recvlength, recvtype);
0651     } else if (urb->status) {
0652         kfree_skb(skb);
0653         lbtf_deb_leave(LBTF_DEB_USB);
0654         return;
0655     }
0656 
0657     switch (recvtype) {
0658     case CMD_TYPE_DATA:
0659         process_cmdtypedata(recvlength, skb, cardp, priv);
0660         break;
0661 
0662     case CMD_TYPE_REQUEST:
0663         process_cmdrequest(recvlength, recvbuff, skb, cardp, priv);
0664         break;
0665 
0666     case CMD_TYPE_INDICATION:
0667     {
0668         /* Event cause handling */
0669         u32 event_cause = le32_to_cpu(pkt[1]);
0670         lbtf_deb_usbd(&cardp->udev->dev, "**EVENT** 0x%X\n",
0671             event_cause);
0672 
0673         /* Icky undocumented magic special case */
0674         if (event_cause & 0xffff0000) {
0675             u16 tmp;
0676             u8 retrycnt;
0677             u8 failure;
0678 
0679             tmp = event_cause >> 16;
0680             retrycnt = tmp & 0x00ff;
0681             failure = (tmp & 0xff00) >> 8;
0682             lbtf_send_tx_feedback(priv, retrycnt, failure);
0683         } else if (event_cause == LBTF_EVENT_BCN_SENT)
0684             lbtf_bcn_sent(priv);
0685         else
0686             lbtf_deb_usbd(&cardp->udev->dev,
0687                    "Unsupported notification %d received\n",
0688                    event_cause);
0689         kfree_skb(skb);
0690         break;
0691     }
0692     default:
0693         lbtf_deb_usbd(&cardp->udev->dev,
0694             "libertastf: unknown command type 0x%X\n", recvtype);
0695         kfree_skb(skb);
0696         break;
0697     }
0698 
0699 setup_for_next:
0700     if_usb_submit_rx_urb(cardp);
0701     lbtf_deb_leave(LBTF_DEB_USB);
0702 }
0703 
0704 /**
0705  *  if_usb_host_to_card -  Download data to the device
0706  *
0707  *  @priv:      pointer to struct lbtf_private structure
0708  *  @type:      type of data
0709  *  @payload:       pointer to payload buffer
0710  *  @nb:        number of bytes
0711  *
0712  *  Returns: 0 on success, nonzero otherwise
0713  */
0714 static int if_usb_host_to_card(struct lbtf_private *priv, uint8_t type,
0715                    uint8_t *payload, uint16_t nb)
0716 {
0717     struct if_usb_card *cardp = priv->card;
0718     u8 data = 0;
0719 
0720     lbtf_deb_usbd(&cardp->udev->dev, "*** type = %u\n", type);
0721     lbtf_deb_usbd(&cardp->udev->dev, "size after = %d\n", nb);
0722 
0723     if (type == MVMS_CMD) {
0724         *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_REQUEST);
0725     } else {
0726         *(__le32 *)cardp->ep_out_buf = cpu_to_le32(CMD_TYPE_DATA);
0727         data = 1;
0728     }
0729 
0730     memcpy((cardp->ep_out_buf + MESSAGE_HEADER_LEN), payload, nb);
0731 
0732     return usb_tx_block(cardp, cardp->ep_out_buf, nb + MESSAGE_HEADER_LEN,
0733                 data);
0734 }
0735 
0736 /**
0737  *  if_usb_issue_boot_command - Issue boot command to Boot2.
0738  *
0739  *  @cardp: pointer if_usb_card
0740  *  @ivalue:   1 boots from FW by USB-Download, 2 boots from FW in EEPROM.
0741  *
0742  *  Returns: 0
0743  */
0744 static int if_usb_issue_boot_command(struct if_usb_card *cardp, int ivalue)
0745 {
0746     struct bootcmd *bootcmd = cardp->ep_out_buf;
0747 
0748     /* Prepare command */
0749     bootcmd->magic = cpu_to_le32(BOOT_CMD_MAGIC_NUMBER);
0750     bootcmd->cmd = ivalue;
0751     memset(bootcmd->pad, 0, sizeof(bootcmd->pad));
0752 
0753     /* Issue command */
0754     usb_tx_block(cardp, cardp->ep_out_buf, sizeof(*bootcmd), 0);
0755 
0756     return 0;
0757 }
0758 
0759 
0760 /**
0761  *  check_fwfile_format - Check the validity of Boot2/FW image.
0762  *
0763  *  @data:  pointer to image
0764  *  @totlen:    image length
0765  *
0766  *  Returns: 0 if the image is valid, nonzero otherwise.
0767  */
0768 static int check_fwfile_format(const u8 *data, u32 totlen)
0769 {
0770     u32 bincmd, exit;
0771     u32 blksize, offset, len;
0772     int ret;
0773 
0774     ret = 1;
0775     exit = len = 0;
0776 
0777     do {
0778         struct fwheader *fwh = (void *) data;
0779 
0780         bincmd = le32_to_cpu(fwh->dnldcmd);
0781         blksize = le32_to_cpu(fwh->datalength);
0782         switch (bincmd) {
0783         case FW_HAS_DATA_TO_RECV:
0784             offset = sizeof(struct fwheader) + blksize;
0785             data += offset;
0786             len += offset;
0787             if (len >= totlen)
0788                 exit = 1;
0789             break;
0790         case FW_HAS_LAST_BLOCK:
0791             exit = 1;
0792             ret = 0;
0793             break;
0794         default:
0795             exit = 1;
0796             break;
0797         }
0798     } while (!exit);
0799 
0800     if (ret)
0801         pr_err("firmware file format check FAIL\n");
0802     else
0803         lbtf_deb_fw("firmware file format check PASS\n");
0804 
0805     return ret;
0806 }
0807 
0808 
0809 static int if_usb_prog_firmware(struct lbtf_private *priv)
0810 {
0811     struct if_usb_card *cardp = priv->card;
0812     int i = 0;
0813     static int reset_count = 10;
0814     int ret = 0;
0815 
0816     lbtf_deb_enter(LBTF_DEB_USB);
0817 
0818     cardp->priv = priv;
0819 
0820     kernel_param_lock(THIS_MODULE);
0821     ret = request_firmware(&cardp->fw, lbtf_fw_name, &cardp->udev->dev);
0822     if (ret < 0) {
0823         pr_err("request_firmware() failed with %#x\n", ret);
0824         pr_err("firmware %s not found\n", lbtf_fw_name);
0825         kernel_param_unlock(THIS_MODULE);
0826         goto done;
0827     }
0828     kernel_param_unlock(THIS_MODULE);
0829 
0830     if (check_fwfile_format(cardp->fw->data, cardp->fw->size))
0831         goto release_fw;
0832 
0833 restart:
0834     if (if_usb_submit_rx_urb_fwload(cardp) < 0) {
0835         lbtf_deb_usbd(&cardp->udev->dev, "URB submission is failed\n");
0836         ret = -1;
0837         goto release_fw;
0838     }
0839 
0840     cardp->bootcmdresp = 0;
0841     do {
0842         int j = 0;
0843         i++;
0844         /* Issue Boot command = 1, Boot from Download-FW */
0845         if_usb_issue_boot_command(cardp, BOOT_CMD_FW_BY_USB);
0846         /* wait for command response */
0847         do {
0848             j++;
0849             msleep_interruptible(100);
0850         } while (cardp->bootcmdresp == 0 && j < 10);
0851     } while (cardp->bootcmdresp == 0 && i < 5);
0852 
0853     if (cardp->bootcmdresp <= 0) {
0854         if (--reset_count >= 0) {
0855             if_usb_reset_device(priv);
0856             goto restart;
0857         }
0858         return -1;
0859     }
0860 
0861     i = 0;
0862 
0863     cardp->totalbytes = 0;
0864     cardp->fwlastblksent = 0;
0865     cardp->CRC_OK = 1;
0866     cardp->fwdnldover = 0;
0867     cardp->fwseqnum = -1;
0868     cardp->totalbytes = 0;
0869     cardp->fwfinalblk = 0;
0870 
0871     /* Send the first firmware packet... */
0872     if_usb_send_fw_pkt(cardp);
0873 
0874     /* ... and wait for the process to complete */
0875     wait_event_interruptible(cardp->fw_wq, cardp->priv->surpriseremoved ||
0876                            cardp->fwdnldover);
0877 
0878     del_timer_sync(&cardp->fw_timeout);
0879     usb_kill_urb(cardp->rx_urb);
0880 
0881     if (!cardp->fwdnldover) {
0882         pr_info("failed to load fw, resetting device!\n");
0883         if (--reset_count >= 0) {
0884             if_usb_reset_device(priv);
0885             goto restart;
0886         }
0887 
0888         pr_info("FW download failure, time = %d ms\n", i * 100);
0889         ret = -1;
0890         goto release_fw;
0891     }
0892 
0893  release_fw:
0894     release_firmware(cardp->fw);
0895     cardp->fw = NULL;
0896 
0897     if_usb_setup_firmware(cardp->priv);
0898 
0899  done:
0900     lbtf_deb_leave_args(LBTF_DEB_USB, "ret %d", ret);
0901     return ret;
0902 }
0903 
0904 
0905 #define if_usb_suspend NULL
0906 #define if_usb_resume NULL
0907 
0908 static struct usb_driver if_usb_driver = {
0909     .name = DRV_NAME,
0910     .probe = if_usb_probe,
0911     .disconnect = if_usb_disconnect,
0912     .id_table = if_usb_table,
0913     .suspend = if_usb_suspend,
0914     .resume = if_usb_resume,
0915     .disable_hub_initiated_lpm = 1,
0916 };
0917 
0918 module_usb_driver(if_usb_driver);
0919 
0920 MODULE_DESCRIPTION("8388 USB WLAN Thinfirm Driver");
0921 MODULE_AUTHOR("Cozybit Inc.");
0922 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!