drivers/net/wireless/purelifi/plfxlc/usb.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2021 pureLiFi
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/init.h>
   8 #include <linux/device.h>
   9 #include <linux/errno.h>
  10 #include <linux/slab.h>
  11 #include <linux/skbuff.h>
  12 #include <linux/usb.h>
  13 #include <linux/workqueue.h>
  14 #include <linux/proc_fs.h>
  15 #include <linux/fs.h>
  16 #include <linux/string.h>
  17 #include <linux/module.h>
  18 #include <net/mac80211.h>
  19 #include <asm/unaligned.h>
  20 #include <linux/sysfs.h>
  21
  22 #include "mac.h"
  23 #include "usb.h"
  24 #include "chip.h"
  25
  26 static const struct usb_device_id usb_ids[] = {
  27         { USB_DEVICE(PURELIFI_X_VENDOR_ID_0, PURELIFI_X_PRODUCT_ID_0),
  28           .driver_info = DEVICE_LIFI_X },
  29         { USB_DEVICE(PURELIFI_XC_VENDOR_ID_0, PURELIFI_XC_PRODUCT_ID_0),
  30           .driver_info = DEVICE_LIFI_XC },
  31         { USB_DEVICE(PURELIFI_XL_VENDOR_ID_0, PURELIFI_XL_PRODUCT_ID_0),
  32           .driver_info = DEVICE_LIFI_XL },
  33         {}
  34 };
  35
  36 void plfxlc_send_packet_from_data_queue(struct plfxlc_usb *usb)
  37 {
  38         struct plfxlc_usb_tx *tx = &usb->tx;
  39         struct sk_buff *skb = NULL;
  40         unsigned long flags;
  41         u8 last_served_sidx;
  42
  43         spin_lock_irqsave(&tx->lock, flags);
  44         last_served_sidx = usb->sidx;
  45         do {
  46                 usb->sidx = (usb->sidx + 1) % MAX_STA_NUM;
  47                 if (!(tx->station[usb->sidx].flag & STATION_CONNECTED_FLAG))
  48                         continue;
  49                 if (!(tx->station[usb->sidx].flag & STATION_FIFO_FULL_FLAG))
  50                         skb = skb_peek(&tx->station[usb->sidx].data_list);
  51         } while ((usb->sidx != last_served_sidx) && (!skb));
  52
  53         if (skb) {
  54                 skb = skb_dequeue(&tx->station[usb->sidx].data_list);
  55                 plfxlc_usb_wreq_async(usb, skb->data, skb->len, USB_REQ_DATA_TX,
  56                                       plfxlc_tx_urb_complete, skb);
  57                 if (skb_queue_len(&tx->station[usb->sidx].data_list) <= 60)
  58                         ieee80211_wake_queues(plfxlc_usb_to_hw(usb));
  59         }
  60         spin_unlock_irqrestore(&tx->lock, flags);
  61 }
  62
  63 static void handle_rx_packet(struct plfxlc_usb *usb, const u8 *buffer,
  64                              unsigned int length)
  65 {
  66         plfxlc_mac_rx(plfxlc_usb_to_hw(usb), buffer, length);
  67 }
  68
  69 static void rx_urb_complete(struct urb *urb)
  70 {
  71         struct plfxlc_usb_tx *tx;
  72         struct plfxlc_usb *usb;
  73         unsigned int length;
  74         const u8 *buffer;
  75         u16 status;
  76         u8 sidx;
  77         int r;
  78
  79         if (!urb) {
  80                 pr_err("urb is NULL\n");
  81                 return;
  82         }
  83         if (!urb->context) {
  84                 pr_err("urb ctx is NULL\n");
  85                 return;
  86         }
  87         usb = urb->context;
  88
  89         if (usb->initialized != 1) {
  90                 pr_err("usb is not initialized\n");
  91                 return;
  92         }
  93
  94         tx = &usb->tx;
  95         switch (urb->status) {
  96         case 0:
  97                 break;
  98         case -ESHUTDOWN:
  99         case -EINVAL:
 100         case -ENODEV:
 101         case -ENOENT:
 102         case -ECONNRESET:
 103         case -EPIPE:
 104                 dev_dbg(plfxlc_urb_dev(urb), "urb %p error %d\n", urb, urb->status);
 105                 return;
 106         default:
 107                 dev_dbg(plfxlc_urb_dev(urb), "urb %p error %d\n", urb, urb->status);
 108                 if (tx->submitted_urbs++ < PURELIFI_URB_RETRY_MAX) {
 109                         dev_dbg(plfxlc_urb_dev(urb), "urb %p resubmit %d", urb,
 110                                 tx->submitted_urbs++);
 111                         goto resubmit;
 112                 } else {
 113                         dev_dbg(plfxlc_urb_dev(urb), "urb %p  max resubmits reached", urb);
 114                         tx->submitted_urbs = 0;
 115                         return;
 116                 }
 117         }
 118
 119         buffer = urb->transfer_buffer;
 120         length = le32_to_cpu(*(__le32 *)(buffer + sizeof(struct rx_status)))
 121                  + sizeof(u32);
 122
 123         if (urb->actual_length != (PLF_MSG_STATUS_OFFSET + 1)) {
 124                 if (usb->initialized && usb->link_up)
 125                         handle_rx_packet(usb, buffer, length);
 126                 goto resubmit;
 127         }
 128
 129         status = buffer[PLF_MSG_STATUS_OFFSET];
 130
 131         switch (status) {
 132         case STATION_FIFO_ALMOST_FULL_NOT_MESSAGE:
 133                 dev_dbg(&usb->intf->dev,
 134                         "FIFO full not packet receipt\n");
 135                 tx->mac_fifo_full = 1;
 136                 for (sidx = 0; sidx < MAX_STA_NUM; sidx++)
 137                         tx->station[sidx].flag |= STATION_FIFO_FULL_FLAG;
 138                 break;
 139         case STATION_FIFO_ALMOST_FULL_MESSAGE:
 140                 dev_dbg(&usb->intf->dev, "FIFO full packet receipt\n");
 141
 142                 for (sidx = 0; sidx < MAX_STA_NUM; sidx++)
 143                         tx->station[sidx].flag &= STATION_ACTIVE_FLAG;
 144
 145                 plfxlc_send_packet_from_data_queue(usb);
 146                 break;
 147         case STATION_CONNECT_MESSAGE:
 148                 usb->link_up = 1;
 149                 dev_dbg(&usb->intf->dev, "ST_CONNECT_MSG packet receipt\n");
 150                 break;
 151         case STATION_DISCONNECT_MESSAGE:
 152                 usb->link_up = 0;
 153                 dev_dbg(&usb->intf->dev, "ST_DISCONN_MSG packet receipt\n");
 154                 break;
 155         default:
 156                 dev_dbg(&usb->intf->dev, "Unknown packet receipt\n");
 157                 break;
 158         }
 159
 160 resubmit:
 161         r = usb_submit_urb(urb, GFP_ATOMIC);
 162         if (r)
 163                 dev_dbg(plfxlc_urb_dev(urb), "urb %p resubmit fail (%d)\n", urb, r);
 164 }
 165
 166 static struct urb *alloc_rx_urb(struct plfxlc_usb *usb)
 167 {
 168         struct usb_device *udev = plfxlc_usb_to_usbdev(usb);
 169         struct urb *urb;
 170         void *buffer;
 171
 172         urb = usb_alloc_urb(0, GFP_KERNEL);
 173         if (!urb)
 174                 return NULL;
 175
 176         buffer = usb_alloc_coherent(udev, USB_MAX_RX_SIZE, GFP_KERNEL,
 177                                     &urb->transfer_dma);
 178         if (!buffer) {
 179                 usb_free_urb(urb);
 180                 return NULL;
 181         }
 182
 183         usb_fill_bulk_urb(urb, udev, usb_rcvbulkpipe(udev, EP_DATA_IN),
 184                           buffer, USB_MAX_RX_SIZE,
 185                           rx_urb_complete, usb);
 186         urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 187
 188         return urb;
 189 }
 190
 191 static void free_rx_urb(struct urb *urb)
 192 {
 193         if (!urb)
 194                 return;
 195         usb_free_coherent(urb->dev, urb->transfer_buffer_length,
 196                           urb->transfer_buffer, urb->transfer_dma);
 197         usb_free_urb(urb);
 198 }
 199
 200 static int __lf_x_usb_enable_rx(struct plfxlc_usb *usb)
 201 {
 202         struct plfxlc_usb_rx *rx = &usb->rx;
 203         struct urb **urbs;
 204         int i, r;
 205
 206         r = -ENOMEM;
 207         urbs = kcalloc(RX_URBS_COUNT, sizeof(struct urb *), GFP_KERNEL);
 208         if (!urbs)
 209                 goto error;
 210
 211         for (i = 0; i < RX_URBS_COUNT; i++) {
 212                 urbs[i] = alloc_rx_urb(usb);
 213                 if (!urbs[i])
 214                         goto error;
 215         }
 216
 217         spin_lock_irq(&rx->lock);
 218
 219         dev_dbg(plfxlc_usb_dev(usb), "irq_disabled %d\n", irqs_disabled());
 220
 221         if (rx->urbs) {
 222                 spin_unlock_irq(&rx->lock);
 223                 r = 0;
 224                 goto error;
 225         }
 226         rx->urbs = urbs;
 227         rx->urbs_count = RX_URBS_COUNT;
 228         spin_unlock_irq(&rx->lock);
 229
 230         for (i = 0; i < RX_URBS_COUNT; i++) {
 231                 r = usb_submit_urb(urbs[i], GFP_KERNEL);
 232                 if (r)
 233                         goto error_submit;
 234         }
 235
 236         return 0;
 237
 238 error_submit:
 239         for (i = 0; i < RX_URBS_COUNT; i++)
 240                 usb_kill_urb(urbs[i]);
 241         spin_lock_irq(&rx->lock);
 242         rx->urbs = NULL;
 243         rx->urbs_count = 0;
 244         spin_unlock_irq(&rx->lock);
 245 error:
 246         if (urbs) {
 247                 for (i = 0; i < RX_URBS_COUNT; i++)
 248                         free_rx_urb(urbs[i]);
 249         }
 250         return r;
 251 }
 252
 253 int plfxlc_usb_enable_rx(struct plfxlc_usb *usb)
 254 {
 255         struct plfxlc_usb_rx *rx = &usb->rx;
 256         int r;
 257
 258         mutex_lock(&rx->setup_mutex);
 259         r = __lf_x_usb_enable_rx(usb);
 260         if (!r)
 261                 usb->rx_usb_enabled = 1;
 262
 263         mutex_unlock(&rx->setup_mutex);
 264
 265         return r;
 266 }
 267
 268 static void __lf_x_usb_disable_rx(struct plfxlc_usb *usb)
 269 {
 270         struct plfxlc_usb_rx *rx = &usb->rx;
 271         unsigned long flags;
 272         unsigned int count;
 273         struct urb **urbs;
 274         int i;
 275
 276         spin_lock_irqsave(&rx->lock, flags);
 277         urbs = rx->urbs;
 278         count = rx->urbs_count;
 279         spin_unlock_irqrestore(&rx->lock, flags);
 280
 281         if (!urbs)
 282                 return;
 283
 284         for (i = 0; i < count; i++) {
 285                 usb_kill_urb(urbs[i]);
 286                 free_rx_urb(urbs[i]);
 287         }
 288         kfree(urbs);
 289         rx->urbs = NULL;
 290         rx->urbs_count = 0;
 291 }
 292
 293 void plfxlc_usb_disable_rx(struct plfxlc_usb *usb)
 294 {
 295         struct plfxlc_usb_rx *rx = &usb->rx;
 296
 297         mutex_lock(&rx->setup_mutex);
 298         __lf_x_usb_disable_rx(usb);
 299         usb->rx_usb_enabled = 0;
 300         mutex_unlock(&rx->setup_mutex);
 301 }
 302
 303 void plfxlc_usb_disable_tx(struct plfxlc_usb *usb)
 304 {
 305         struct plfxlc_usb_tx *tx = &usb->tx;
 306         unsigned long flags;
 307
 308         clear_bit(PLF_BIT_ENABLED, &tx->enabled);
 309
 310         /* kill all submitted tx-urbs */
 311         usb_kill_anchored_urbs(&tx->submitted);
 312
 313         spin_lock_irqsave(&tx->lock, flags);
 314         WARN_ON(!skb_queue_empty(&tx->submitted_skbs));
 315         WARN_ON(tx->submitted_urbs != 0);
 316         tx->submitted_urbs = 0;
 317         spin_unlock_irqrestore(&tx->lock, flags);
 318
 319         /* The stopped state is ignored, relying on ieee80211_wake_queues()
 320          * in a potentionally following plfxlc_usb_enable_tx().
 321          */
 322 }
 323
 324 void plfxlc_usb_enable_tx(struct plfxlc_usb *usb)
 325 {
 326         struct plfxlc_usb_tx *tx = &usb->tx;
 327         unsigned long flags;
 328
 329         spin_lock_irqsave(&tx->lock, flags);
 330         set_bit(PLF_BIT_ENABLED, &tx->enabled);
 331         tx->submitted_urbs = 0;
 332         ieee80211_wake_queues(plfxlc_usb_to_hw(usb));
 333         tx->stopped = 0;
 334         spin_unlock_irqrestore(&tx->lock, flags);
 335 }
 336
 337 void plfxlc_tx_urb_complete(struct urb *urb)
 338 {
 339         struct ieee80211_tx_info *info;
 340         struct plfxlc_usb *usb;
 341         struct sk_buff *skb;
 342
 343         skb = urb->context;
 344         info = IEEE80211_SKB_CB(skb);
 345         /* grab 'usb' pointer before handing off the skb (since
 346          * it might be freed by plfxlc_mac_tx_to_dev or mac80211)
 347          */
 348         usb = &plfxlc_hw_mac(info->rate_driver_data[0])->chip.usb;
 349
 350         switch (urb->status) {
 351         case 0:
 352                 break;
 353         case -ESHUTDOWN:
 354         case -EINVAL:
 355         case -ENODEV:
 356         case -ENOENT:
 357         case -ECONNRESET:
 358         case -EPIPE:
 359                 dev_dbg(plfxlc_urb_dev(urb), "urb %p error %d\n", urb, urb->status);
 360                 break;
 361         default:
 362                 dev_dbg(plfxlc_urb_dev(urb), "urb %p error %d\n", urb, urb->status);
 363                 return;
 364         }
 365
 366         plfxlc_mac_tx_to_dev(skb, urb->status);
 367         plfxlc_send_packet_from_data_queue(usb);
 368         usb_free_urb(urb);
 369 }
 370
 371 static inline void init_usb_rx(struct plfxlc_usb *usb)
 372 {
 373         struct plfxlc_usb_rx *rx = &usb->rx;
 374
 375         spin_lock_init(&rx->lock);
 376         mutex_init(&rx->setup_mutex);
 377
 378         if (interface_to_usbdev(usb->intf)->speed == USB_SPEED_HIGH)
 379                 rx->usb_packet_size = 512;
 380         else
 381                 rx->usb_packet_size = 64;
 382
 383         if (rx->fragment_length != 0)
 384                 dev_dbg(plfxlc_usb_dev(usb), "fragment_length error\n");
 385 }
 386
 387 static inline void init_usb_tx(struct plfxlc_usb *usb)
 388 {
 389         struct plfxlc_usb_tx *tx = &usb->tx;
 390
 391         spin_lock_init(&tx->lock);
 392         clear_bit(PLF_BIT_ENABLED, &tx->enabled);
 393         tx->stopped = 0;
 394         skb_queue_head_init(&tx->submitted_skbs);
 395         init_usb_anchor(&tx->submitted);
 396 }
 397
 398 void plfxlc_usb_init(struct plfxlc_usb *usb, struct ieee80211_hw *hw,
 399                      struct usb_interface *intf)
 400 {
 401         memset(usb, 0, sizeof(*usb));
 402         usb->intf = usb_get_intf(intf);
 403         usb_set_intfdata(usb->intf, hw);
 404         init_usb_tx(usb);
 405         init_usb_rx(usb);
 406 }
 407
 408 void plfxlc_usb_release(struct plfxlc_usb *usb)
 409 {
 410         plfxlc_op_stop(plfxlc_usb_to_hw(usb));
 411         plfxlc_usb_disable_tx(usb);
 412         plfxlc_usb_disable_rx(usb);
 413         usb_set_intfdata(usb->intf, NULL);
 414         usb_put_intf(usb->intf);
 415 }
 416
 417 const char *plfxlc_speed(enum usb_device_speed speed)
 418 {
 419         switch (speed) {
 420         case USB_SPEED_LOW:
 421                 return "low";
 422         case USB_SPEED_FULL:
 423                 return "full";
 424         case USB_SPEED_HIGH:
 425                 return "high";
 426         default:
 427                 return "unknown";
 428         }
 429 }
 430
 431 int plfxlc_usb_init_hw(struct plfxlc_usb *usb)
 432 {
 433         int r;
 434
 435         r = usb_reset_configuration(plfxlc_usb_to_usbdev(usb));
 436         if (r) {
 437                 dev_err(plfxlc_usb_dev(usb), "cfg reset failed (%d)\n", r);
 438                 return r;
 439         }
 440         return 0;
 441 }
 442
 443 static void get_usb_req(struct usb_device *udev, void *buffer,
 444                         u32 buffer_len, enum plf_usb_req_enum usb_req_id,
 445                         struct plf_usb_req *usb_req)
 446 {
 447         __be32 payload_len_nw = cpu_to_be32(buffer_len + FCS_LEN);
 448         const u8 *buffer_src_p = buffer;
 449         u8 *buffer_dst = usb_req->buf;
 450         u32 temp_usb_len = 0;
 451
 452         usb_req->id = cpu_to_be32(usb_req_id);
 453         usb_req->len  = cpu_to_be32(0);
 454
 455         /* Copy buffer length into the transmitted buffer, as it is important
 456          * for the Rx MAC to know its exact length.
 457          */
 458         if (usb_req->id == cpu_to_be32(USB_REQ_BEACON_WR)) {
 459                 memcpy(buffer_dst, &payload_len_nw, sizeof(payload_len_nw));
 460                 buffer_dst += sizeof(payload_len_nw);
 461                 temp_usb_len += sizeof(payload_len_nw);
 462         }
 463
 464         memcpy(buffer_dst, buffer_src_p, buffer_len);
 465         buffer_dst += buffer_len;
 466         buffer_src_p += buffer_len;
 467         temp_usb_len +=  buffer_len;
 468
 469         /* Set the FCS_LEN (4) bytes as 0 for CRC checking. */
 470         memset(buffer_dst, 0, FCS_LEN);
 471         buffer_dst += FCS_LEN;
 472         temp_usb_len += FCS_LEN;
 473
 474         /* Round the packet to be transmitted to 4 bytes. */
 475         if (temp_usb_len % PURELIFI_BYTE_NUM_ALIGNMENT) {
 476                 memset(buffer_dst, 0, PURELIFI_BYTE_NUM_ALIGNMENT -
 477                        (temp_usb_len %
 478                         PURELIFI_BYTE_NUM_ALIGNMENT));
 479                 buffer_dst += PURELIFI_BYTE_NUM_ALIGNMENT -
 480                                 (temp_usb_len %
 481                                 PURELIFI_BYTE_NUM_ALIGNMENT);
 482                 temp_usb_len += PURELIFI_BYTE_NUM_ALIGNMENT -
 483                                 (temp_usb_len % PURELIFI_BYTE_NUM_ALIGNMENT);
 484         }
 485
 486         usb_req->len = cpu_to_be32(temp_usb_len);
 487 }
 488
 489 int plfxlc_usb_wreq_async(struct plfxlc_usb *usb, const u8 *buffer,
 490                           int buffer_len, enum plf_usb_req_enum usb_req_id,
 491                           usb_complete_t complete_fn,
 492                           void *context)
 493 {
 494         struct usb_device *udev = interface_to_usbdev(usb->ez_usb);
 495         struct urb *urb = usb_alloc_urb(0, GFP_ATOMIC);
 496         int r;
 497
 498         usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, EP_DATA_OUT),
 499                           (void *)buffer, buffer_len, complete_fn, context);
 500
 501         r = usb_submit_urb(urb, GFP_ATOMIC);
 502         if (r)
 503                 dev_err(&udev->dev, "Async write submit failed (%d)\n", r);
 504
 505         return r;
 506 }
 507
 508 int plfxlc_usb_wreq(struct usb_interface *ez_usb, void *buffer, int buffer_len,
 509                     enum plf_usb_req_enum usb_req_id)
 510 {
 511         struct usb_device *udev = interface_to_usbdev(ez_usb);
 512         unsigned char *dma_buffer = NULL;
 513         struct plf_usb_req usb_req;
 514         int usb_bulk_msg_len;
 515         int actual_length;
 516         int r;
 517
 518         get_usb_req(udev, buffer, buffer_len, usb_req_id, &usb_req);
 519         usb_bulk_msg_len = sizeof(__le32) + sizeof(__le32) +
 520                            be32_to_cpu(usb_req.len);
 521
 522         dma_buffer = kmemdup(&usb_req, usb_bulk_msg_len, GFP_KERNEL);
 523
 524         if (!dma_buffer) {
 525                 r = -ENOMEM;
 526                 goto error;
 527         }
 528
 529         r = usb_bulk_msg(udev,
 530                          usb_sndbulkpipe(udev, EP_DATA_OUT),
 531                          dma_buffer, usb_bulk_msg_len,
 532                          &actual_length, USB_BULK_MSG_TIMEOUT_MS);
 533         kfree(dma_buffer);
 534 error:
 535         if (r) {
 536                 r = -ENOMEM;
 537                 dev_err(&udev->dev, "usb_bulk_msg failed (%d)\n", r);
 538         }
 539
 540         return r;
 541 }
 542
 543 static void slif_data_plane_sap_timer_callb(struct timer_list *t)
 544 {
 545         struct plfxlc_usb *usb = from_timer(usb, t, tx.tx_retry_timer);
 546
 547         plfxlc_send_packet_from_data_queue(usb);
 548         timer_setup(&usb->tx.tx_retry_timer,
 549                     slif_data_plane_sap_timer_callb, 0);
 550         mod_timer(&usb->tx.tx_retry_timer, jiffies + TX_RETRY_BACKOFF_JIFF);
 551 }
 552
 553 static void sta_queue_cleanup_timer_callb(struct timer_list *t)
 554 {
 555         struct plfxlc_usb *usb = from_timer(usb, t, sta_queue_cleanup);
 556         struct plfxlc_usb_tx *tx = &usb->tx;
 557         int sidx;
 558
 559         for (sidx = 0; sidx < MAX_STA_NUM - 1; sidx++) {
 560                 if (!(tx->station[sidx].flag & STATION_CONNECTED_FLAG))
 561                         continue;
 562                 if (tx->station[sidx].flag & STATION_HEARTBEAT_FLAG) {
 563                         tx->station[sidx].flag ^= STATION_HEARTBEAT_FLAG;
 564                 } else {
 565                         memset(tx->station[sidx].mac, 0, ETH_ALEN);
 566                         tx->station[sidx].flag = 0;
 567                 }
 568         }
 569         timer_setup(&usb->sta_queue_cleanup,
 570                     sta_queue_cleanup_timer_callb, 0);
 571         mod_timer(&usb->sta_queue_cleanup, jiffies + STA_QUEUE_CLEANUP_JIFF);
 572 }
 573
 574 static int probe(struct usb_interface *intf,
 575                  const struct usb_device_id *id)
 576 {
 577         u8 serial_number[PURELIFI_SERIAL_LEN];
 578         struct ieee80211_hw *hw = NULL;
 579         struct plfxlc_usb_tx *tx;
 580         struct plfxlc_chip *chip;
 581         struct plfxlc_usb *usb;
 582         u8 hw_address[ETH_ALEN];
 583         unsigned int i;
 584         int r = 0;
 585
 586         hw = plfxlc_mac_alloc_hw(intf);
 587
 588         if (!hw) {
 589                 r = -ENOMEM;
 590                 goto error;
 591         }
 592
 593         chip = &plfxlc_hw_mac(hw)->chip;
 594         usb = &chip->usb;
 595         usb->ez_usb = intf;
 596         tx = &usb->tx;
 597
 598         r = plfxlc_upload_mac_and_serial(intf, hw_address, serial_number);
 599         if (r) {
 600                 dev_err(&intf->dev, "MAC and Serial upload failed (%d)\n", r);
 601                 goto error;
 602         }
 603
 604         chip->unit_type = STA;
 605         dev_err(&intf->dev, "Unit type is station");
 606
 607         r = plfxlc_mac_preinit_hw(hw, hw_address);
 608         if (r) {
 609                 dev_err(&intf->dev, "Init mac failed (%d)\n", r);
 610                 goto error;
 611         }
 612
 613         r = ieee80211_register_hw(hw);
 614         if (r) {
 615                 dev_err(&intf->dev, "Register device failed (%d)\n", r);
 616                 goto error;
 617         }
 618
 619         if ((le16_to_cpu(interface_to_usbdev(intf)->descriptor.idVendor) ==
 620                                 PURELIFI_XL_VENDOR_ID_0) &&
 621             (le16_to_cpu(interface_to_usbdev(intf)->descriptor.idProduct) ==
 622                                 PURELIFI_XL_PRODUCT_ID_0)) {
 623                 r = plfxlc_download_xl_firmware(intf);
 624         } else {
 625                 r = plfxlc_download_fpga(intf);
 626         }
 627         if (r != 0) {
 628                 dev_err(&intf->dev, "FPGA download failed (%d)\n", r);
 629                 goto error;
 630         }
 631
 632         tx->mac_fifo_full = 0;
 633         spin_lock_init(&tx->lock);
 634
 635         msleep(PLF_MSLEEP_TIME);
 636         r = plfxlc_usb_init_hw(usb);
 637         if (r < 0) {
 638                 dev_err(&intf->dev, "usb_init_hw failed (%d)\n", r);
 639                 goto error;
 640         }
 641
 642         msleep(PLF_MSLEEP_TIME);
 643         r = plfxlc_chip_switch_radio(chip, PLFXLC_RADIO_ON);
 644         if (r < 0) {
 645                 dev_dbg(&intf->dev, "chip_switch_radio_on failed (%d)\n", r);
 646                 goto error;
 647         }
 648
 649         msleep(PLF_MSLEEP_TIME);
 650         r = plfxlc_chip_set_rate(chip, 8);
 651         if (r < 0) {
 652                 dev_dbg(&intf->dev, "chip_set_rate failed (%d)\n", r);
 653                 goto error;
 654         }
 655
 656         msleep(PLF_MSLEEP_TIME);
 657         r = plfxlc_usb_wreq(usb->ez_usb,
 658                             hw_address, ETH_ALEN, USB_REQ_MAC_WR);
 659         if (r < 0) {
 660                 dev_dbg(&intf->dev, "MAC_WR failure (%d)\n", r);
 661                 goto error;
 662         }
 663
 664         plfxlc_chip_enable_rxtx(chip);
 665
 666         /* Initialise the data plane Tx queue */
 667         for (i = 0; i < MAX_STA_NUM; i++) {
 668                 skb_queue_head_init(&tx->station[i].data_list);
 669                 tx->station[i].flag = 0;
 670         }
 671
 672         tx->station[STA_BROADCAST_INDEX].flag |= STATION_CONNECTED_FLAG;
 673         for (i = 0; i < ETH_ALEN; i++)
 674                 tx->station[STA_BROADCAST_INDEX].mac[i] = 0xFF;
 675
 676         timer_setup(&tx->tx_retry_timer, slif_data_plane_sap_timer_callb, 0);
 677         tx->tx_retry_timer.expires = jiffies + TX_RETRY_BACKOFF_JIFF;
 678         add_timer(&tx->tx_retry_timer);
 679
 680         timer_setup(&usb->sta_queue_cleanup,
 681                     sta_queue_cleanup_timer_callb, 0);
 682         usb->sta_queue_cleanup.expires = jiffies + STA_QUEUE_CLEANUP_JIFF;
 683         add_timer(&usb->sta_queue_cleanup);
 684
 685         plfxlc_mac_init_hw(hw);
 686         usb->initialized = true;
 687         return 0;
 688 error:
 689         if (hw) {
 690                 plfxlc_mac_release(plfxlc_hw_mac(hw));
 691                 ieee80211_unregister_hw(hw);
 692                 ieee80211_free_hw(hw);
 693         }
 694         dev_err(&intf->dev, "pureLifi:Device error");
 695         return r;
 696 }
 697
 698 static void disconnect(struct usb_interface *intf)
 699 {
 700         struct ieee80211_hw *hw = plfxlc_intf_to_hw(intf);
 701         struct plfxlc_mac *mac;
 702         struct plfxlc_usb *usb;
 703
 704         /* Either something really bad happened, or
 705          * we're just dealing with a DEVICE_INSTALLER.
 706          */
 707         if (!hw)
 708                 return;
 709
 710         mac = plfxlc_hw_mac(hw);
 711         usb = &mac->chip.usb;
 712
 713         del_timer_sync(&usb->tx.tx_retry_timer);
 714         del_timer_sync(&usb->sta_queue_cleanup);
 715
 716         ieee80211_unregister_hw(hw);
 717
 718         plfxlc_chip_disable_rxtx(&mac->chip);
 719
 720         /* If the disconnect has been caused by a removal of the
 721          * driver module, the reset allows reloading of the driver. If the
 722          * reset will not be executed here, the upload of the firmware in the
 723          * probe function caused by the reloading of the driver will fail.
 724          */
 725         usb_reset_device(interface_to_usbdev(intf));
 726
 727         plfxlc_mac_release(mac);
 728         ieee80211_free_hw(hw);
 729 }
 730
 731 static void plfxlc_usb_resume(struct plfxlc_usb *usb)
 732 {
 733         struct plfxlc_mac *mac = plfxlc_usb_to_mac(usb);
 734         int r;
 735
 736         r = plfxlc_op_start(plfxlc_usb_to_hw(usb));
 737         if (r < 0) {
 738                 dev_warn(plfxlc_usb_dev(usb),
 739                          "Device resume failed (%d)\n", r);
 740
 741                 if (usb->was_running)
 742                         set_bit(PURELIFI_DEVICE_RUNNING, &mac->flags);
 743
 744                 usb_queue_reset_device(usb->intf);
 745                 return;
 746         }
 747
 748         if (mac->type != NL80211_IFTYPE_UNSPECIFIED) {
 749                 r = plfxlc_restore_settings(mac);
 750                 if (r < 0) {
 751                         dev_dbg(plfxlc_usb_dev(usb),
 752                                 "Restore failed (%d)\n", r);
 753                         return;
 754                 }
 755         }
 756 }
 757
 758 static void plfxlc_usb_stop(struct plfxlc_usb *usb)
 759 {
 760         plfxlc_op_stop(plfxlc_usb_to_hw(usb));
 761         plfxlc_usb_disable_tx(usb);
 762         plfxlc_usb_disable_rx(usb);
 763
 764         usb->initialized = false;
 765 }
 766
 767 static int pre_reset(struct usb_interface *intf)
 768 {
 769         struct ieee80211_hw *hw = usb_get_intfdata(intf);
 770         struct plfxlc_mac *mac;
 771         struct plfxlc_usb *usb;
 772
 773         if (!hw || intf->condition != USB_INTERFACE_BOUND)
 774                 return 0;
 775
 776         mac = plfxlc_hw_mac(hw);
 777         usb = &mac->chip.usb;
 778
 779         usb->was_running = test_bit(PURELIFI_DEVICE_RUNNING, &mac->flags);
 780
 781         plfxlc_usb_stop(usb);
 782
 783         return 0;
 784 }
 785
 786 static int post_reset(struct usb_interface *intf)
 787 {
 788         struct ieee80211_hw *hw = usb_get_intfdata(intf);
 789         struct plfxlc_mac *mac;
 790         struct plfxlc_usb *usb;
 791
 792         if (!hw || intf->condition != USB_INTERFACE_BOUND)
 793                 return 0;
 794
 795         mac = plfxlc_hw_mac(hw);
 796         usb = &mac->chip.usb;
 797
 798         if (usb->was_running)
 799                 plfxlc_usb_resume(usb);
 800
 801         return 0;
 802 }
 803
 804 #ifdef CONFIG_PM
 805
 806 static struct plfxlc_usb *get_plfxlc_usb(struct usb_interface *intf)
 807 {
 808         struct ieee80211_hw *hw = plfxlc_intf_to_hw(intf);
 809         struct plfxlc_mac *mac;
 810
 811         /* Either something really bad happened, or
 812          * we're just dealing with a DEVICE_INSTALLER.
 813          */
 814         if (!hw)
 815                 return NULL;
 816
 817         mac = plfxlc_hw_mac(hw);
 818         return &mac->chip.usb;
 819 }
 820
 821 static int suspend(struct usb_interface *interface,
 822                    pm_message_t message)
 823 {
 824         struct plfxlc_usb *pl = get_plfxlc_usb(interface);
 825         struct plfxlc_mac *mac = plfxlc_usb_to_mac(pl);
 826
 827         if (!pl)
 828                 return -ENODEV;
 829         if (pl->initialized == 0)
 830                 return 0;
 831         pl->was_running = test_bit(PURELIFI_DEVICE_RUNNING, &mac->flags);
 832         plfxlc_usb_stop(pl);
 833         return 0;
 834 }
 835
 836 static int resume(struct usb_interface *interface)
 837 {
 838         struct plfxlc_usb *pl = get_plfxlc_usb(interface);
 839
 840         if (!pl)
 841                 return -ENODEV;
 842         if (pl->was_running)
 843                 plfxlc_usb_resume(pl);
 844         return 0;
 845 }
 846
 847 #endif
 848
 849 static struct usb_driver driver = {
 850         .name = KBUILD_MODNAME,
 851         .id_table = usb_ids,
 852         .probe = probe,
 853         .disconnect = disconnect,
 854         .pre_reset = pre_reset,
 855         .post_reset = post_reset,
 856 #ifdef CONFIG_PM
 857         .suspend = suspend,
 858         .resume = resume,
 859 #endif
 860         .disable_hub_initiated_lpm = 1,
 861 };
 862
 863 static int __init usb_init(void)
 864 {
 865         int r;
 866
 867         r = usb_register(&driver);
 868         if (r) {
 869                 pr_err("%s usb_register() failed %d\n", driver.name, r);
 870                 return r;
 871         }
 872
 873         pr_debug("Driver initialized :%s\n", driver.name);
 874         return 0;
 875 }
 876
 877 static void __exit usb_exit(void)
 878 {
 879         usb_deregister(&driver);
 880         pr_debug("%s %s\n", driver.name, __func__);
 881 }
 882
 883 MODULE_LICENSE("GPL");
 884 MODULE_DESCRIPTION("USB driver for pureLiFi devices");
 885 MODULE_AUTHOR("pureLiFi");
 886 MODULE_VERSION("1.0");
 887 /*(DEBLOBBED)*/
 888 MODULE_DEVICE_TABLE(usb, usb_ids);
 889
 890 module_init(usb_init);
 891 module_exit(usb_exit);