int recvlength = urb->actual_length;
        u8 *recvbuff = NULL;
-       u32 recvtype;
+       u32 recvtype = 0;
 
        lbs_deb_enter(LBS_DEB_USB);
 
        if (recvlength) {
+               __le32 tmp;
+
                if (urb->status) {
                        lbs_deb_usbd(&cardp->udev->dev,
                                    "URB status is failed\n");
                }
 
                recvbuff = skb->data + IPFIELD_ALIGN_OFFSET;
-               memcpy(&recvtype, recvbuff, sizeof(u32));
-               lbs_deb_usbd(&cardp->udev->dev,
-                           "Recv length = 0x%x\n", recvlength);
+               memcpy(&tmp, recvbuff, sizeof(u32));
+               recvtype = le32_to_cpu(tmp);
                lbs_deb_usbd(&cardp->udev->dev,
-                           "Receive type = 0x%X\n", recvtype);
-               recvtype = le32_to_cpu(recvtype);
-               lbs_deb_usbd(&cardp->udev->dev,
-                           "Receive type after = 0x%X\n", recvtype);
+                           "Recv length = 0x%x, Recv type = 0x%X\n",
+                           recvlength, recvtype);
        } else if (urb->status)
                goto rx_exit;
 
-
        switch (recvtype) {
        case CMD_TYPE_DATA:
                process_cmdtypedata(recvlength, skb, cardp, priv);
                spin_unlock(&priv->adapter->driver_lock);
                goto rx_exit;
        default:
+               lbs_deb_usbd(&cardp->udev->dev, "Unknown command type 0x%X\n",
+                            recvtype);
                kfree_skb(skb);
                break;
        }
  */
 static int if_usb_host_to_card(wlan_private * priv, u8 type, u8 * payload, u16 nb)
 {
-       int ret = -1;
-       u32 tmp;
        struct usb_card_rec *cardp = (struct usb_card_rec *)priv->card;
 
        lbs_deb_usbd(&cardp->udev->dev,"*** type = %u\n", type);
        lbs_deb_usbd(&cardp->udev->dev,"size after = %d\n", nb);
 
        if (type == MVMS_CMD) {
-               tmp = cpu_to_le32(CMD_TYPE_REQUEST);
+               __le32 tmp = cpu_to_le32(CMD_TYPE_REQUEST);
                priv->dnld_sent = DNLD_CMD_SENT;
                memcpy(cardp->bulk_out_buffer, (u8 *) & tmp,
                       MESSAGE_HEADER_LEN);
 
        } else {
-               tmp = cpu_to_le32(CMD_TYPE_DATA);
+               __le32 tmp = cpu_to_le32(CMD_TYPE_DATA);
                priv->dnld_sent = DNLD_DATA_SENT;
                memcpy(cardp->bulk_out_buffer, (u8 *) & tmp,
                       MESSAGE_HEADER_LEN);
 
        memcpy((cardp->bulk_out_buffer + MESSAGE_HEADER_LEN), payload, nb);
 
-       ret =
-           usb_tx_block(priv, cardp->bulk_out_buffer, nb + MESSAGE_HEADER_LEN);
-
-       return ret;
+       return usb_tx_block(priv, cardp->bulk_out_buffer,
+                           nb + MESSAGE_HEADER_LEN);
 }
 
 /* called with adapter->driver_lock held */
 
        /* Quality by TX errors */
        priv->wstats.discard.retries = priv->stats.tx_errors;
 
-       tx_retries = le16_to_cpu(adapter->logmsg.retry);
+       tx_retries = le32_to_cpu(adapter->logmsg.retry);
 
        if (tx_retries > 75)
                tx_qual = (90 - tx_retries) * POOR / 15;
                    (PERFECT - VERY_GOOD) / 50 + VERY_GOOD;
        quality = min(quality, tx_qual);
 
-       priv->wstats.discard.code = le16_to_cpu(adapter->logmsg.wepundecryptable);
-       priv->wstats.discard.fragment = le16_to_cpu(adapter->logmsg.rxfrag);
+       priv->wstats.discard.code = le32_to_cpu(adapter->logmsg.wepundecryptable);
+       priv->wstats.discard.fragment = le32_to_cpu(adapter->logmsg.rxfrag);
        priv->wstats.discard.retries = tx_retries;
-       priv->wstats.discard.misc = le16_to_cpu(adapter->logmsg.ackfailure);
+       priv->wstats.discard.misc = le32_to_cpu(adapter->logmsg.ackfailure);
 
        /* Calculate quality */
        priv->wstats.qual.qual = min_t(u8, quality, 100);