// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2021 pureLiFi
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <linux/usb.h>
#include <linux/workqueue.h>
#include <linux/proc_fs.h>
#include <linux/fs.h>
#include <linux/string.h>
#include <linux/module.h>
#include <net/mac80211.h>
#include <linux/unaligned.h>
#include <linux/sysfs.h>

#include "mac.h"
#include "usb.h"
#include "chip.h"

static const struct usb_device_id usb_ids[] = {
        { USB_DEVICE(PURELIFI_X_VENDOR_ID_0, PURELIFI_X_PRODUCT_ID_0),
          .driver_info = DEVICE_LIFI_X },
        { USB_DEVICE(PURELIFI_XC_VENDOR_ID_0, PURELIFI_XC_PRODUCT_ID_0),
          .driver_info = DEVICE_LIFI_XC },
        { USB_DEVICE(PURELIFI_XL_VENDOR_ID_0, PURELIFI_XL_PRODUCT_ID_0),
          .driver_info = DEVICE_LIFI_XL },
        {}
};

void plfxlc_send_packet_from_data_queue(struct plfxlc_usb *usb)
{
        struct plfxlc_usb_tx *tx = &usb->tx;
        struct sk_buff *skb = NULL;
        unsigned long flags;
        u8 last_served_sidx;

        spin_lock_irqsave(&tx->lock, flags);
        last_served_sidx = usb->sidx;
        do {
                usb->sidx = (usb->sidx + 1) % MAX_STA_NUM;
                if (!(tx->station[usb->sidx].flag & STATION_CONNECTED_FLAG))
                        continue;
                if (!(tx->station[usb->sidx].flag & STATION_FIFO_FULL_FLAG))
                        skb = skb_peek(&tx->station[usb->sidx].data_list);
        } while ((usb->sidx != last_served_sidx) && (!skb));

        if (skb) {
                skb = skb_dequeue(&tx->station[usb->sidx].data_list);
                plfxlc_usb_wreq_async(usb, skb->data, skb->len, USB_REQ_DATA_TX,
                                      plfxlc_tx_urb_complete, skb);
                if (skb_queue_len(&tx->station[usb->sidx].data_list) <= 60)
                        ieee80211_wake_queues(plfxlc_usb_to_hw(usb));
        }
        spin_unlock_irqrestore(&tx->lock, flags);
}

static void handle_rx_packet(struct plfxlc_usb *usb, const u8 *buffer,
                             unsigned int length)
{
        plfxlc_mac_rx(plfxlc_usb_to_hw(usb), buffer, length);
}

static void rx_urb_complete(struct urb *urb)
{
        struct plfxlc_usb_tx *tx;
        struct plfxlc_usb *usb;
        unsigned int length;
        const u8 *buffer;
        u16 status;
        u8 sidx;
        int r;

        if (!urb) {
                pr_err("urb is NULL\n");
                return;
        }
        if (!urb->context) {
                pr_err("urb ctx is NULL\n");
                return;
        }
        usb = urb->context;

        if (usb->initialized != 1) {
                pr_err("usb is not initialized\n");
                return;
        }

        tx = &usb->tx;
        switch (urb->status) {
        case 0:
                break;
        case -ESHUTDOWN:
        case -EINVAL:
        case -ENODEV:
        case -ENOENT:
        case -ECONNRESET:
        case -EPIPE:
                dev_dbg(plfxlc_urb_dev(urb), "urb %p error %d\n", urb, urb->status);
                return;
        default:
                dev_dbg(plfxlc_urb_dev(urb), "urb %p error %d\n", urb, urb->status);
                if (tx->submitted_urbs++ < PURELIFI_URB_RETRY_MAX) {
                        dev_dbg(plfxlc_urb_dev(urb), "urb %p resubmit %d", urb,
                                tx->submitted_urbs++);
                        goto resubmit;
                } else {
                        dev_dbg(plfxlc_urb_dev(urb), "urb %p  max resubmits reached", urb);
                        tx->submitted_urbs = 0;
                        return;
                }
        }

        buffer = urb->transfer_buffer;
        length = le32_to_cpu(*(__le32 *)(buffer + sizeof(struct rx_status)))
                 + sizeof(u32);

        if (urb->actual_length != (PLF_MSG_STATUS_OFFSET + 1)) {
                if (usb->initialized && usb->link_up)
                        handle_rx_packet(usb, buffer, length);
                goto resubmit;
        }

        status = buffer[PLF_MSG_STATUS_OFFSET];

        switch (status) {
        case STATION_FIFO_ALMOST_FULL_NOT_MESSAGE:
                dev_dbg(&usb->intf->dev,
                        "FIFO full not packet receipt\n");
                tx->mac_fifo_full = 1;
                for (sidx = 0; sidx < MAX_STA_NUM; sidx++)
                        tx->station[sidx].flag |= STATION_FIFO_FULL_FLAG;
                break;
        case STATION_FIFO_ALMOST_FULL_MESSAGE:
                dev_dbg(&usb->intf->dev, "FIFO full packet receipt\n");

                for (sidx = 0; sidx < MAX_STA_NUM; sidx++)
                        tx->station[sidx].flag &= STATION_ACTIVE_FLAG;

                plfxlc_send_packet_from_data_queue(usb);
                break;
        case STATION_CONNECT_MESSAGE:
                usb->link_up = 1;
                dev_dbg(&usb->intf->dev, "ST_CONNECT_MSG packet receipt\n");
                break;
        case STATION_DISCONNECT_MESSAGE:
                usb->link_up = 0;
                dev_dbg(&usb->intf->dev, "ST_DISCONN_MSG packet receipt\n");
                break;
        default:
                dev_dbg(&usb->intf->dev, "Unknown packet receipt\n");
                break;
        }

resubmit:
        r = usb_submit_urb(urb, GFP_ATOMIC);
        if (r)
                dev_dbg(plfxlc_urb_dev(urb), "urb %p resubmit fail (%d)\n", urb, r);
}

static struct urb *alloc_rx_urb(struct plfxlc_usb *usb)
{
        struct usb_device *udev = plfxlc_usb_to_usbdev(usb);
        struct urb *urb;
        void *buffer;

        urb = usb_alloc_urb(0, GFP_KERNEL);
        if (!urb)
                return NULL;

        buffer = usb_alloc_coherent(udev, USB_MAX_RX_SIZE, GFP_KERNEL,
                                    &urb->transfer_dma);
        if (!buffer) {
                usb_free_urb(urb);
                return NULL;
        }

        usb_fill_bulk_urb(urb, udev, usb_rcvbulkpipe(udev, EP_DATA_IN),
                          buffer, USB_MAX_RX_SIZE,
                          rx_urb_complete, usb);
        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

        return urb;
}

static void free_rx_urb(struct urb *urb)
{
        if (!urb)
                return;
        usb_free_coherent(urb->dev, urb->transfer_buffer_length,
                          urb->transfer_buffer, urb->transfer_dma);
        usb_free_urb(urb);
}

static int __lf_x_usb_enable_rx(struct plfxlc_usb *usb)
{
        struct plfxlc_usb_rx *rx = &usb->rx;
        struct urb **urbs;
        int i, r;

        r = -ENOMEM;
        urbs = kzalloc_objs(struct urb *, RX_URBS_COUNT);
        if (!urbs)
                goto error;

        for (i = 0; i < RX_URBS_COUNT; i++) {
                urbs[i] = alloc_rx_urb(usb);
                if (!urbs[i])
                        goto error;
        }

        spin_lock_irq(&rx->lock);

        dev_dbg(plfxlc_usb_dev(usb), "irq_disabled %d\n", irqs_disabled());

        if (rx->urbs) {
                spin_unlock_irq(&rx->lock);
                r = 0;
                goto error;
        }
        rx->urbs = urbs;
        rx->urbs_count = RX_URBS_COUNT;
        spin_unlock_irq(&rx->lock);

        for (i = 0; i < RX_URBS_COUNT; i++) {
                r = usb_submit_urb(urbs[i], GFP_KERNEL);
                if (r)
                        goto error_submit;
        }

        return 0;

error_submit:
        for (i = 0; i < RX_URBS_COUNT; i++)
                usb_kill_urb(urbs[i]);
        spin_lock_irq(&rx->lock);
        rx->urbs = NULL;
        rx->urbs_count = 0;
        spin_unlock_irq(&rx->lock);
error:
        if (urbs) {
                for (i = 0; i < RX_URBS_COUNT; i++)
                        free_rx_urb(urbs[i]);
        }
        kfree(urbs);
        return r;
}

int plfxlc_usb_enable_rx(struct plfxlc_usb *usb)
{
        struct plfxlc_usb_rx *rx = &usb->rx;
        int r;

        mutex_lock(&rx->setup_mutex);
        r = __lf_x_usb_enable_rx(usb);
        if (!r)
                usb->rx_usb_enabled = 1;

        mutex_unlock(&rx->setup_mutex);

        return r;
}

static void __lf_x_usb_disable_rx(struct plfxlc_usb *usb)
{
        struct plfxlc_usb_rx *rx = &usb->rx;
        unsigned long flags;
        unsigned int count;
        struct urb **urbs;
        int i;

        spin_lock_irqsave(&rx->lock, flags);
        urbs = rx->urbs;
        count = rx->urbs_count;
        spin_unlock_irqrestore(&rx->lock, flags);

        if (!urbs)
                return;

        for (i = 0; i < count; i++) {
                usb_kill_urb(urbs[i]);
                free_rx_urb(urbs[i]);
        }
        kfree(urbs);
        rx->urbs = NULL;
        rx->urbs_count = 0;
}

void plfxlc_usb_disable_rx(struct plfxlc_usb *usb)
{
        struct plfxlc_usb_rx *rx = &usb->rx;

        mutex_lock(&rx->setup_mutex);
        __lf_x_usb_disable_rx(usb);
        usb->rx_usb_enabled = 0;
        mutex_unlock(&rx->setup_mutex);
}

void plfxlc_usb_disable_tx(struct plfxlc_usb *usb)
{
        struct plfxlc_usb_tx *tx = &usb->tx;
        unsigned long flags;

        clear_bit(PLF_BIT_ENABLED, &tx->enabled);

        /* kill all submitted tx-urbs */
        usb_kill_anchored_urbs(&tx->submitted);

        spin_lock_irqsave(&tx->lock, flags);
        WARN_ON(!skb_queue_empty(&tx->submitted_skbs));
        WARN_ON(tx->submitted_urbs != 0);
        tx->submitted_urbs = 0;
        spin_unlock_irqrestore(&tx->lock, flags);

        /* The stopped state is ignored, relying on ieee80211_wake_queues()
         * in a potentionally following plfxlc_usb_enable_tx().
         */
}

void plfxlc_usb_enable_tx(struct plfxlc_usb *usb)
{
        struct plfxlc_usb_tx *tx = &usb->tx;
        unsigned long flags;

        spin_lock_irqsave(&tx->lock, flags);
        set_bit(PLF_BIT_ENABLED, &tx->enabled);
        tx->submitted_urbs = 0;
        ieee80211_wake_queues(plfxlc_usb_to_hw(usb));
        tx->stopped = 0;
        spin_unlock_irqrestore(&tx->lock, flags);
}

void plfxlc_tx_urb_complete(struct urb *urb)
{
        struct ieee80211_tx_info *info;
        struct plfxlc_usb *usb;
        struct sk_buff *skb;

        skb = urb->context;
        info = IEEE80211_SKB_CB(skb);
        /* grab 'usb' pointer before handing off the skb (since
         * it might be freed by plfxlc_mac_tx_to_dev or mac80211)
         */
        usb = &plfxlc_hw_mac(info->rate_driver_data[0])->chip.usb;

        switch (urb->status) {
        case 0:
                break;
        case -ESHUTDOWN:
        case -EINVAL:
        case -ENODEV:
        case -ENOENT:
        case -ECONNRESET:
        case -EPIPE:
                dev_dbg(plfxlc_urb_dev(urb), "urb %p error %d\n", urb, urb->status);
                break;
        default:
                dev_dbg(plfxlc_urb_dev(urb), "urb %p error %d\n", urb, urb->status);
                return;
        }

        plfxlc_mac_tx_to_dev(skb, urb->status);
        plfxlc_send_packet_from_data_queue(usb);
        usb_free_urb(urb);
}

static inline void init_usb_rx(struct plfxlc_usb *usb)
{
        struct plfxlc_usb_rx *rx = &usb->rx;

        spin_lock_init(&rx->lock);
        mutex_init(&rx->setup_mutex);

        if (interface_to_usbdev(usb->intf)->speed == USB_SPEED_HIGH)
                rx->usb_packet_size = 512;
        else
                rx->usb_packet_size = 64;

        if (rx->fragment_length != 0)
                dev_dbg(plfxlc_usb_dev(usb), "fragment_length error\n");
}

static inline void init_usb_tx(struct plfxlc_usb *usb)
{
        struct plfxlc_usb_tx *tx = &usb->tx;

        spin_lock_init(&tx->lock);
        clear_bit(PLF_BIT_ENABLED, &tx->enabled);
        tx->stopped = 0;
        skb_queue_head_init(&tx->submitted_skbs);
        init_usb_anchor(&tx->submitted);
}

void plfxlc_usb_init(struct plfxlc_usb *usb, struct ieee80211_hw *hw,
                     struct usb_interface *intf)
{
        memset(usb, 0, sizeof(*usb));
        usb->intf = usb_get_intf(intf);
        usb_set_intfdata(usb->intf, hw);
        init_usb_tx(usb);
        init_usb_rx(usb);
}

void plfxlc_usb_release(struct plfxlc_usb *usb)
{
        plfxlc_op_stop(plfxlc_usb_to_hw(usb), false);
        plfxlc_usb_disable_tx(usb);
        plfxlc_usb_disable_rx(usb);
        usb_set_intfdata(usb->intf, NULL);
        usb_put_intf(usb->intf);
}

const char *plfxlc_speed(enum usb_device_speed speed)
{
        switch (speed) {
        case USB_SPEED_LOW:
                return "low";
        case USB_SPEED_FULL:
                return "full";
        case USB_SPEED_HIGH:
                return "high";
        default:
                return "unknown";
        }
}

int plfxlc_usb_init_hw(struct plfxlc_usb *usb)
{
        int r;

        r = usb_reset_configuration(plfxlc_usb_to_usbdev(usb));
        if (r) {
                dev_err(plfxlc_usb_dev(usb), "cfg reset failed (%d)\n", r);
                return r;
        }
        return 0;
}

static void get_usb_req(struct usb_device *udev, void *buffer,
                        u32 buffer_len, enum plf_usb_req_enum usb_req_id,
                        struct plf_usb_req *usb_req)
{
        __be32 payload_len_nw = cpu_to_be32(buffer_len + FCS_LEN);
        const u8 *buffer_src_p = buffer;
        u8 *buffer_dst = usb_req->buf;
        u32 temp_usb_len = 0;

        usb_req->id = cpu_to_be32(usb_req_id);
        usb_req->len  = cpu_to_be32(0);

        /* Copy buffer length into the transmitted buffer, as it is important
         * for the Rx MAC to know its exact length.
         */
        if (usb_req->id == cpu_to_be32(USB_REQ_BEACON_WR)) {
                memcpy(buffer_dst, &payload_len_nw, sizeof(payload_len_nw));
                buffer_dst += sizeof(payload_len_nw);
                temp_usb_len += sizeof(payload_len_nw);
        }

        memcpy(buffer_dst, buffer_src_p, buffer_len);
        buffer_dst += buffer_len;
        buffer_src_p += buffer_len;
        temp_usb_len +=  buffer_len;

        /* Set the FCS_LEN (4) bytes as 0 for CRC checking. */
        memset(buffer_dst, 0, FCS_LEN);
        buffer_dst += FCS_LEN;
        temp_usb_len += FCS_LEN;

        /* Round the packet to be transmitted to 4 bytes. */
        if (temp_usb_len % PURELIFI_BYTE_NUM_ALIGNMENT) {
                memset(buffer_dst, 0, PURELIFI_BYTE_NUM_ALIGNMENT -
                       (temp_usb_len %
                        PURELIFI_BYTE_NUM_ALIGNMENT));
                buffer_dst += PURELIFI_BYTE_NUM_ALIGNMENT -
                                (temp_usb_len %
                                PURELIFI_BYTE_NUM_ALIGNMENT);
                temp_usb_len += PURELIFI_BYTE_NUM_ALIGNMENT -
                                (temp_usb_len % PURELIFI_BYTE_NUM_ALIGNMENT);
        }

        usb_req->len = cpu_to_be32(temp_usb_len);
}

int plfxlc_usb_wreq_async(struct plfxlc_usb *usb, const u8 *buffer,
                          int buffer_len, enum plf_usb_req_enum usb_req_id,
                          usb_complete_t complete_fn,
                          void *context)
{
        struct usb_device *udev = interface_to_usbdev(usb->ez_usb);
        struct urb *urb;
        int r;

        urb = usb_alloc_urb(0, GFP_ATOMIC);
        if (!urb)
                return -ENOMEM;
        usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, EP_DATA_OUT),
                          (void *)buffer, buffer_len, complete_fn, context);

        r = usb_submit_urb(urb, GFP_ATOMIC);
        if (r) {
                usb_free_urb(urb);
                dev_err(&udev->dev, "Async write submit failed (%d)\n", r);
        }

        return r;
}

int plfxlc_usb_wreq(struct usb_interface *ez_usb, void *buffer, int buffer_len,
                    enum plf_usb_req_enum usb_req_id)
{
        struct usb_device *udev = interface_to_usbdev(ez_usb);
        unsigned char *dma_buffer = NULL;
        struct plf_usb_req usb_req;
        int usb_bulk_msg_len;
        int actual_length;
        int r;

        get_usb_req(udev, buffer, buffer_len, usb_req_id, &usb_req);
        usb_bulk_msg_len = sizeof(__le32) + sizeof(__le32) +
                           be32_to_cpu(usb_req.len);

        dma_buffer = kmemdup(&usb_req, usb_bulk_msg_len, GFP_KERNEL);

        if (!dma_buffer) {
                r = -ENOMEM;
                goto error;
        }

        r = usb_bulk_msg(udev,
                         usb_sndbulkpipe(udev, EP_DATA_OUT),
                         dma_buffer, usb_bulk_msg_len,
                         &actual_length, USB_BULK_MSG_TIMEOUT_MS);
        kfree(dma_buffer);
error:
        if (r) {
                r = -ENOMEM;
                dev_err(&udev->dev, "usb_bulk_msg failed (%d)\n", r);
        }

        return r;
}

static void slif_data_plane_sap_timer_callb(struct timer_list *t)
{
        struct plfxlc_usb *usb = timer_container_of(usb, t, tx.tx_retry_timer);

        plfxlc_send_packet_from_data_queue(usb);
        timer_setup(&usb->tx.tx_retry_timer,
                    slif_data_plane_sap_timer_callb, 0);
        mod_timer(&usb->tx.tx_retry_timer, jiffies + TX_RETRY_BACKOFF_JIFF);
}

static void sta_queue_cleanup_timer_callb(struct timer_list *t)
{
        struct plfxlc_usb *usb = timer_container_of(usb, t, sta_queue_cleanup);
        struct plfxlc_usb_tx *tx = &usb->tx;
        int sidx;

        for (sidx = 0; sidx < MAX_STA_NUM - 1; sidx++) {
                if (!(tx->station[sidx].flag & STATION_CONNECTED_FLAG))
                        continue;
                if (tx->station[sidx].flag & STATION_HEARTBEAT_FLAG) {
                        tx->station[sidx].flag ^= STATION_HEARTBEAT_FLAG;
                } else {
                        eth_zero_addr(tx->station[sidx].mac);
                        tx->station[sidx].flag = 0;
                }
        }
        timer_setup(&usb->sta_queue_cleanup,
                    sta_queue_cleanup_timer_callb, 0);
        mod_timer(&usb->sta_queue_cleanup, jiffies + STA_QUEUE_CLEANUP_JIFF);
}

static int probe(struct usb_interface *intf,
                 const struct usb_device_id *id)
{
        u8 serial_number[PURELIFI_SERIAL_LEN];
        struct ieee80211_hw *hw = NULL;
        struct plfxlc_usb_tx *tx;
        struct plfxlc_chip *chip;
        struct plfxlc_usb *usb;
        u8 hw_address[ETH_ALEN];
        unsigned int i;
        int r = 0;

        hw = plfxlc_mac_alloc_hw(intf);

        if (!hw) {
                r = -ENOMEM;
                goto error;
        }

        chip = &plfxlc_hw_mac(hw)->chip;
        usb = &chip->usb;
        usb->ez_usb = intf;
        tx = &usb->tx;

        r = plfxlc_upload_mac_and_serial(intf, hw_address, serial_number);
        if (r) {
                dev_err(&intf->dev, "MAC and Serial upload failed (%d)\n", r);
                goto error_free_hw;
        }

        chip->unit_type = STA;
        dev_err(&intf->dev, "Unit type is station");

        r = plfxlc_mac_preinit_hw(hw, hw_address);
        if (r) {
                dev_err(&intf->dev, "Init mac failed (%d)\n", r);
                goto error_free_hw;
        }

        r = ieee80211_register_hw(hw);
        if (r) {
                dev_err(&intf->dev, "Register device failed (%d)\n", r);
                goto error_free_hw;
        }

        if ((le16_to_cpu(interface_to_usbdev(intf)->descriptor.idVendor) ==
                                PURELIFI_XL_VENDOR_ID_0) &&
            (le16_to_cpu(interface_to_usbdev(intf)->descriptor.idProduct) ==
                                PURELIFI_XL_PRODUCT_ID_0)) {
                r = plfxlc_download_xl_firmware(intf);
        } else {
                r = plfxlc_download_fpga(intf);
        }
        if (r != 0) {
                dev_err(&intf->dev, "FPGA download failed (%d)\n", r);
                goto error_unreg_hw;
        }

        tx->mac_fifo_full = 0;
        spin_lock_init(&tx->lock);

        msleep(PLF_MSLEEP_TIME);
        r = plfxlc_usb_init_hw(usb);
        if (r < 0) {
                dev_err(&intf->dev, "usb_init_hw failed (%d)\n", r);
                goto error_unreg_hw;
        }

        msleep(PLF_MSLEEP_TIME);
        r = plfxlc_chip_switch_radio(chip, PLFXLC_RADIO_ON);
        if (r < 0) {
                dev_dbg(&intf->dev, "chip_switch_radio_on failed (%d)\n", r);
                goto error_unreg_hw;
        }

        msleep(PLF_MSLEEP_TIME);
        r = plfxlc_chip_set_rate(chip, 8);
        if (r < 0) {
                dev_dbg(&intf->dev, "chip_set_rate failed (%d)\n", r);
                goto error_unreg_hw;
        }

        msleep(PLF_MSLEEP_TIME);
        r = plfxlc_usb_wreq(usb->ez_usb,
                            hw_address, ETH_ALEN, USB_REQ_MAC_WR);
        if (r < 0) {
                dev_dbg(&intf->dev, "MAC_WR failure (%d)\n", r);
                goto error_unreg_hw;
        }

        plfxlc_chip_enable_rxtx(chip);

        /* Initialise the data plane Tx queue */
        for (i = 0; i < MAX_STA_NUM; i++) {
                skb_queue_head_init(&tx->station[i].data_list);
                tx->station[i].flag = 0;
        }

        tx->station[STA_BROADCAST_INDEX].flag |= STATION_CONNECTED_FLAG;
        for (i = 0; i < ETH_ALEN; i++)
                tx->station[STA_BROADCAST_INDEX].mac[i] = 0xFF;

        timer_setup(&tx->tx_retry_timer, slif_data_plane_sap_timer_callb, 0);
        tx->tx_retry_timer.expires = jiffies + TX_RETRY_BACKOFF_JIFF;
        add_timer(&tx->tx_retry_timer);

        timer_setup(&usb->sta_queue_cleanup,
                    sta_queue_cleanup_timer_callb, 0);
        usb->sta_queue_cleanup.expires = jiffies + STA_QUEUE_CLEANUP_JIFF;
        add_timer(&usb->sta_queue_cleanup);

        plfxlc_mac_init_hw(hw);
        usb->initialized = true;
        return 0;

error_unreg_hw:
        ieee80211_unregister_hw(hw);
error_free_hw:
        plfxlc_mac_release_hw(hw);
error:
        dev_err(&intf->dev, "pureLifi:Device error");
        return r;
}

static void disconnect(struct usb_interface *intf)
{
        struct ieee80211_hw *hw = plfxlc_intf_to_hw(intf);
        struct plfxlc_mac *mac;
        struct plfxlc_usb *usb;

        /* Either something really bad happened, or
         * we're just dealing with a DEVICE_INSTALLER.
         */
        if (!hw)
                return;

        mac = plfxlc_hw_mac(hw);
        usb = &mac->chip.usb;

        timer_delete_sync(&usb->tx.tx_retry_timer);
        timer_delete_sync(&usb->sta_queue_cleanup);

        ieee80211_unregister_hw(hw);

        plfxlc_chip_disable_rxtx(&mac->chip);

        /* If the disconnect has been caused by a removal of the
         * driver module, the reset allows reloading of the driver. If the
         * reset will not be executed here, the upload of the firmware in the
         * probe function caused by the reloading of the driver will fail.
         */
        usb_reset_device(interface_to_usbdev(intf));

        plfxlc_mac_release_hw(hw);
}

static void plfxlc_usb_resume(struct plfxlc_usb *usb)
{
        struct plfxlc_mac *mac = plfxlc_usb_to_mac(usb);
        int r;

        r = plfxlc_op_start(plfxlc_usb_to_hw(usb));
        if (r < 0) {
                dev_warn(plfxlc_usb_dev(usb),
                         "Device resume failed (%d)\n", r);

                if (usb->was_running)
                        set_bit(PURELIFI_DEVICE_RUNNING, &mac->flags);

                usb_queue_reset_device(usb->intf);
                return;
        }

        if (mac->type != NL80211_IFTYPE_UNSPECIFIED) {
                r = plfxlc_restore_settings(mac);
                if (r < 0) {
                        dev_dbg(plfxlc_usb_dev(usb),
                                "Restore failed (%d)\n", r);
                        return;
                }
        }
}

static void plfxlc_usb_stop(struct plfxlc_usb *usb)
{
        plfxlc_op_stop(plfxlc_usb_to_hw(usb), false);
        plfxlc_usb_disable_tx(usb);
        plfxlc_usb_disable_rx(usb);

        usb->initialized = false;
}

static int pre_reset(struct usb_interface *intf)
{
        struct ieee80211_hw *hw = usb_get_intfdata(intf);
        struct plfxlc_mac *mac;
        struct plfxlc_usb *usb;

        if (!hw || intf->condition != USB_INTERFACE_BOUND)
                return 0;

        mac = plfxlc_hw_mac(hw);
        usb = &mac->chip.usb;

        usb->was_running = test_bit(PURELIFI_DEVICE_RUNNING, &mac->flags);

        plfxlc_usb_stop(usb);

        return 0;
}

static int post_reset(struct usb_interface *intf)
{
        struct ieee80211_hw *hw = usb_get_intfdata(intf);
        struct plfxlc_mac *mac;
        struct plfxlc_usb *usb;

        if (!hw || intf->condition != USB_INTERFACE_BOUND)
                return 0;

        mac = plfxlc_hw_mac(hw);
        usb = &mac->chip.usb;

        if (usb->was_running)
                plfxlc_usb_resume(usb);

        return 0;
}

#ifdef CONFIG_PM

static struct plfxlc_usb *get_plfxlc_usb(struct usb_interface *intf)
{
        struct ieee80211_hw *hw = plfxlc_intf_to_hw(intf);
        struct plfxlc_mac *mac;

        /* Either something really bad happened, or
         * we're just dealing with a DEVICE_INSTALLER.
         */
        if (!hw)
                return NULL;

        mac = plfxlc_hw_mac(hw);
        return &mac->chip.usb;
}

static int suspend(struct usb_interface *interface,
                   pm_message_t message)
{
        struct plfxlc_usb *pl = get_plfxlc_usb(interface);
        struct plfxlc_mac *mac = plfxlc_usb_to_mac(pl);

        if (!pl)
                return -ENODEV;
        if (pl->initialized == 0)
                return 0;
        pl->was_running = test_bit(PURELIFI_DEVICE_RUNNING, &mac->flags);
        plfxlc_usb_stop(pl);
        return 0;
}

static int resume(struct usb_interface *interface)
{
        struct plfxlc_usb *pl = get_plfxlc_usb(interface);

        if (!pl)
                return -ENODEV;
        if (pl->was_running)
                plfxlc_usb_resume(pl);
        return 0;
}

#endif

static struct usb_driver driver = {
        .name = KBUILD_MODNAME,
        .id_table = usb_ids,
        .probe = probe,
        .disconnect = disconnect,
        .pre_reset = pre_reset,
        .post_reset = post_reset,
#ifdef CONFIG_PM
        .suspend = suspend,
        .resume = resume,
#endif
        .disable_hub_initiated_lpm = 1,
};

static int __init usb_init(void)
{
        int r;

        r = usb_register(&driver);
        if (r) {
                pr_err("%s usb_register() failed %d\n", driver.name, r);
                return r;
        }

        pr_debug("Driver initialized :%s\n", driver.name);
        return 0;
}

static void __exit usb_exit(void)
{
        usb_deregister(&driver);
        pr_debug("%s %s\n", driver.name, __func__);
}

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("USB driver for pureLiFi devices");
MODULE_AUTHOR("pureLiFi");
MODULE_VERSION("1.0");
MODULE_FIRMWARE("plfxlc/lifi-x.bin");
MODULE_DEVICE_TABLE(usb, usb_ids);

module_init(usb_init);
module_exit(usb_exit);