drivers/staging/wlan-ng/hfa384x_usb.c

   1 /* src/prism2/driver/hfa384x_usb.c
   2 *
   3 * Functions that talk to the USB variantof the Intersil hfa384x MAC
   4 *
   5 * Copyright (C) 1999 AbsoluteValue Systems, Inc.  All Rights Reserved.
   6 * --------------------------------------------------------------------
   7 *
   8 * linux-wlan
   9 *
  10 *   The contents of this file are subject to the Mozilla Public
  11 *   License Version 1.1 (the "License"); you may not use this file
  12 *   except in compliance with the License. You may obtain a copy of
  13 *   the License at http://www.mozilla.org/MPL/
  14 *
  15 *   Software distributed under the License is distributed on an "AS
  16 *   IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  17 *   implied. See the License for the specific language governing
  18 *   rights and limitations under the License.
  19 *
  20 *   Alternatively, the contents of this file may be used under the
  21 *   terms of the GNU Public License version 2 (the "GPL"), in which
  22 *   case the provisions of the GPL are applicable instead of the
  23 *   above.  If you wish to allow the use of your version of this file
  24 *   only under the terms of the GPL and not to allow others to use
  25 *   your version of this file under the MPL, indicate your decision
  26 *   by deleting the provisions above and replace them with the notice
  27 *   and other provisions required by the GPL.  If you do not delete
  28 *   the provisions above, a recipient may use your version of this
  29 *   file under either the MPL or the GPL.
  30 *
  31 * --------------------------------------------------------------------
  32 *
  33 * Inquiries regarding the linux-wlan Open Source project can be
  34 * made directly to:
  35 *
  36 * AbsoluteValue Systems Inc.
  37 * info@linux-wlan.com
  38 * http://www.linux-wlan.com
  39 *
  40 * --------------------------------------------------------------------
  41 *
  42 * Portions of the development of this software were funded by
  43 * Intersil Corporation as part of PRISM(R) chipset product development.
  44 *
  45 * --------------------------------------------------------------------
  46 *
  47 * This file implements functions that correspond to the prism2/hfa384x
  48 * 802.11 MAC hardware and firmware host interface.
  49 *
  50 * The functions can be considered to represent several levels of
  51 * abstraction.  The lowest level functions are simply C-callable wrappers
  52 * around the register accesses.  The next higher level represents C-callable
  53 * prism2 API functions that match the Intersil documentation as closely
  54 * as is reasonable.  The next higher layer implements common sequences
  55 * of invokations of the API layer (e.g. write to bap, followed by cmd).
  56 *
  57 * Common sequences:
  58 * hfa384x_drvr_xxx      Highest level abstractions provided by the
  59 *                       hfa384x code.  They are driver defined wrappers
  60 *                       for common sequences.  These functions generally
  61 *                       use the services of the lower levels.
  62 *
  63 * hfa384x_drvr_xxxconfig  An example of the drvr level abstraction. These
  64 *                       functions are wrappers for the RID get/set
  65 *                       sequence. They  call copy_[to|from]_bap() and
  66 *                       cmd_access().   These functions operate on the
  67 *                       RIDs and buffers without validation.  The caller
  68 *                       is responsible for that.
  69 *
  70 * API wrapper functions:
  71 * hfa384x_cmd_xxx       functions that provide access to the f/w commands.
  72 *                       The function arguments correspond to each command
  73 *                       argument, even command arguments that get packed
  74 *                       into single registers.  These functions _just_
  75 *                       issue the command by setting the cmd/parm regs
  76 *                       & reading the status/resp regs.  Additional
  77 *                       activities required to fully use a command
  78 *                       (read/write from/to bap, get/set int status etc.)
  79 *                       are implemented separately.  Think of these as
  80 *                       C-callable prism2 commands.
  81 *
  82 * Lowest Layer Functions:
  83 * hfa384x_docmd_xxx     These functions implement the sequence required
  84 *                       to issue any prism2 command.  Primarily used by the
  85 *                       hfa384x_cmd_xxx functions.
  86 *
  87 * hfa384x_bap_xxx       BAP read/write access functions.
  88 *                       Note: we usually use BAP0 for non-interrupt context
  89 *                        and BAP1 for interrupt context.
  90 *
  91 * hfa384x_dl_xxx        download related functions.
  92 *
  93 * Driver State Issues:
  94 * Note that there are two pairs of functions that manage the
  95 * 'initialized' and 'running' states of the hw/MAC combo.  The four
  96 * functions are create(), destroy(), start(), and stop().  create()
  97 * sets up the data structures required to support the hfa384x_*
  98 * functions and destroy() cleans them up.  The start() function gets
  99 * the actual hardware running and enables the interrupts.  The stop()
 100 * function shuts the hardware down.  The sequence should be:
 101 * create()
 102 * start()
 103 *  .
 104 *  .  Do interesting things w/ the hardware
 105 *  .
 106 * stop()
 107 * destroy()
 108 *
 109 * Note that destroy() can be called without calling stop() first.
 110 * --------------------------------------------------------------------
 111 */
 112
 113 /*================================================================*/
 114 /* System Includes */
 115 #define WLAN_DBVAR      prism2_debug
 116
 117 #include <linux/version.h>
 118
 119 #include <linux/module.h>
 120 #include <linux/kernel.h>
 121 #include <linux/sched.h>
 122 #include <linux/types.h>
 123 #include <linux/slab.h>
 124 #include <linux/wireless.h>
 125 #include <linux/netdevice.h>
 126 #include <linux/timer.h>
 127 #include <asm/io.h>
 128 #include <linux/delay.h>
 129 #include <asm/byteorder.h>
 130 #include <asm/bitops.h>
 131 #include <linux/list.h>
 132 #include <linux/usb.h>
 133
 134 #include "wlan_compat.h"
 135
 136 #define SUBMIT_URB(u,f)  usb_submit_urb(u,f)
 137
 138 /*================================================================*/
 139 /* Project Includes */
 140
 141 #include "p80211types.h"
 142 #include "p80211hdr.h"
 143 #include "p80211mgmt.h"
 144 #include "p80211conv.h"
 145 #include "p80211msg.h"
 146 #include "p80211netdev.h"
 147 #include "p80211req.h"
 148 #include "p80211metadef.h"
 149 #include "p80211metastruct.h"
 150 #include "hfa384x.h"
 151 #include "prism2mgmt.h"
 152
 153 /*================================================================*/
 154 /* Local Constants */
 155
 156 enum cmd_mode
 157 {
 158   DOWAIT = 0,
 159   DOASYNC
 160 };
 161 typedef enum cmd_mode CMD_MODE;
 162
 163 #define THROTTLE_JIFFIES        (HZ/8)
 164
 165 /*================================================================*/
 166 /* Local Macros */
 167
 168 #define ROUNDUP64(a) (((a)+63)&~63)
 169
 170 /*================================================================*/
 171 /* Local Types */
 172
 173 /*================================================================*/
 174 /* Local Static Definitions */
 175 extern int prism2_debug;
 176
 177 /*================================================================*/
 178 /* Local Function Declarations */
 179
 180 #ifdef DEBUG_USB
 181 static void
 182 dbprint_urb(struct urb* urb);
 183 #endif
 184
 185 static void
 186 hfa384x_int_rxmonitor(
 187         wlandevice_t *wlandev,
 188         hfa384x_usb_rxfrm_t *rxfrm);
 189
 190 static void
 191 hfa384x_usb_defer(struct work_struct *data);
 192
 193 static int
 194 submit_rx_urb(hfa384x_t *hw, gfp_t flags);
 195
 196 static int
 197 submit_tx_urb(hfa384x_t *hw, struct urb *tx_urb, gfp_t flags);
 198
 199 /*---------------------------------------------------*/
 200 /* Callbacks */
 201 static void
 202 hfa384x_usbout_callback(struct urb *urb);
 203 static void
 204 hfa384x_ctlxout_callback(struct urb *urb);
 205 static void
 206 hfa384x_usbin_callback(struct urb *urb);
 207
 208 static void
 209 hfa384x_usbin_txcompl(wlandevice_t *wlandev, hfa384x_usbin_t *usbin);
 210
 211 static void
 212 hfa384x_usbin_rx(wlandevice_t *wlandev, struct sk_buff *skb);
 213
 214 static void
 215 hfa384x_usbin_info(wlandevice_t *wlandev, hfa384x_usbin_t *usbin);
 216
 217 static void
 218 hfa384x_usbout_tx(wlandevice_t *wlandev, hfa384x_usbout_t *usbout);
 219
 220 static void hfa384x_usbin_ctlx(hfa384x_t *hw, hfa384x_usbin_t *usbin,
 221                                int urb_status);
 222
 223 /*---------------------------------------------------*/
 224 /* Functions to support the prism2 usb command queue */
 225
 226 static void
 227 hfa384x_usbctlxq_run(hfa384x_t *hw);
 228
 229 static void
 230 hfa384x_usbctlx_reqtimerfn(unsigned long data);
 231
 232 static void
 233 hfa384x_usbctlx_resptimerfn(unsigned long data);
 234
 235 static void
 236 hfa384x_usb_throttlefn(unsigned long data);
 237
 238 static void
 239 hfa384x_usbctlx_completion_task(unsigned long data);
 240
 241 static void
 242 hfa384x_usbctlx_reaper_task(unsigned long data);
 243
 244 static int
 245 hfa384x_usbctlx_submit(hfa384x_t *hw, hfa384x_usbctlx_t *ctlx);
 246
 247 static void
 248 unlocked_usbctlx_complete(hfa384x_t *hw, hfa384x_usbctlx_t *ctlx);
 249
 250 struct usbctlx_completor
 251 {
 252         int (*complete)(struct usbctlx_completor*);
 253 };
 254 typedef struct usbctlx_completor usbctlx_completor_t;
 255
 256 static int
 257 hfa384x_usbctlx_complete_sync(hfa384x_t *hw,
 258                               hfa384x_usbctlx_t *ctlx,
 259                               usbctlx_completor_t *completor);
 260
 261 static int
 262 unlocked_usbctlx_cancel_async(hfa384x_t *hw, hfa384x_usbctlx_t *ctlx);
 263
 264 static void
 265 hfa384x_cb_status(hfa384x_t *hw, const hfa384x_usbctlx_t *ctlx);
 266
 267 static void
 268 hfa384x_cb_rrid(hfa384x_t *hw, const hfa384x_usbctlx_t *ctlx);
 269
 270 static int
 271 usbctlx_get_status(const hfa384x_usb_cmdresp_t *cmdresp,
 272                    hfa384x_cmdresult_t *result);
 273
 274 static void
 275 usbctlx_get_rridresult(const hfa384x_usb_rridresp_t *rridresp,
 276                        hfa384x_rridresult_t *result);
 277
 278 /*---------------------------------------------------*/
 279 /* Low level req/resp CTLX formatters and submitters */
 280 static int
 281 hfa384x_docmd(
 282         hfa384x_t *hw,
 283         CMD_MODE mode,
 284         hfa384x_metacmd_t *cmd,
 285         ctlx_cmdcb_t cmdcb,
 286         ctlx_usercb_t usercb,
 287         void    *usercb_data);
 288
 289 static int
 290 hfa384x_dorrid(
 291         hfa384x_t *hw,
 292         CMD_MODE mode,
 293         u16     rid,
 294         void    *riddata,
 295         unsigned int    riddatalen,
 296         ctlx_cmdcb_t cmdcb,
 297         ctlx_usercb_t usercb,
 298         void    *usercb_data);
 299
 300 static int
 301 hfa384x_dowrid(
 302         hfa384x_t *hw,
 303         CMD_MODE mode,
 304         u16     rid,
 305         void    *riddata,
 306         unsigned int    riddatalen,
 307         ctlx_cmdcb_t cmdcb,
 308         ctlx_usercb_t usercb,
 309         void    *usercb_data);
 310
 311 static int
 312 hfa384x_dormem(
 313         hfa384x_t *hw,
 314         CMD_MODE mode,
 315         u16     page,
 316         u16     offset,
 317         void    *data,
 318         unsigned int    len,
 319         ctlx_cmdcb_t cmdcb,
 320         ctlx_usercb_t usercb,
 321         void    *usercb_data);
 322
 323 static int
 324 hfa384x_dowmem(
 325         hfa384x_t *hw,
 326         CMD_MODE mode,
 327         u16     page,
 328         u16     offset,
 329         void    *data,
 330         unsigned int    len,
 331         ctlx_cmdcb_t cmdcb,
 332         ctlx_usercb_t usercb,
 333         void    *usercb_data);
 334
 335 static int
 336 hfa384x_isgood_pdrcode(u16 pdrcode);
 337
 338 /*================================================================*/
 339 /* Function Definitions */
 340 static inline const char* ctlxstr(CTLX_STATE s)
 341 {
 342         static const char* ctlx_str[] = {
 343                 "Initial state",
 344                 "Complete",
 345                 "Request failed",
 346                 "Request pending",
 347                 "Request packet submitted",
 348                 "Request packet completed",
 349                 "Response packet completed"
 350         };
 351
 352         return ctlx_str[s];
 353 };
 354
 355
 356 static inline hfa384x_usbctlx_t*
 357 get_active_ctlx(hfa384x_t *hw)
 358 {
 359         return list_entry(hw->ctlxq.active.next, hfa384x_usbctlx_t, list);
 360 }
 361
 362
 363 #ifdef DEBUG_USB
 364 void
 365 dbprint_urb(struct urb* urb)
 366 {
 367         WLAN_LOG_DEBUG(3,"urb->pipe=0x%08x\n", urb->pipe);
 368         WLAN_LOG_DEBUG(3,"urb->status=0x%08x\n", urb->status);
 369         WLAN_LOG_DEBUG(3,"urb->transfer_flags=0x%08x\n", urb->transfer_flags);
 370         WLAN_LOG_DEBUG(3,"urb->transfer_buffer=0x%08x\n", (unsigned int)urb->transfer_buffer);
 371         WLAN_LOG_DEBUG(3,"urb->transfer_buffer_length=0x%08x\n", urb->transfer_buffer_length);
 372         WLAN_LOG_DEBUG(3,"urb->actual_length=0x%08x\n", urb->actual_length);
 373         WLAN_LOG_DEBUG(3,"urb->bandwidth=0x%08x\n", urb->bandwidth);
 374         WLAN_LOG_DEBUG(3,"urb->setup_packet(ctl)=0x%08x\n", (unsigned int)urb->setup_packet);
 375         WLAN_LOG_DEBUG(3,"urb->start_frame(iso/irq)=0x%08x\n", urb->start_frame);
 376         WLAN_LOG_DEBUG(3,"urb->interval(irq)=0x%08x\n", urb->interval);
 377         WLAN_LOG_DEBUG(3,"urb->error_count(iso)=0x%08x\n", urb->error_count);
 378         WLAN_LOG_DEBUG(3,"urb->timeout=0x%08x\n", urb->timeout);
 379         WLAN_LOG_DEBUG(3,"urb->context=0x%08x\n", (unsigned int)urb->context);
 380         WLAN_LOG_DEBUG(3,"urb->complete=0x%08x\n", (unsigned int)urb->complete);
 381 }
 382 #endif
 383
 384
 385 /*----------------------------------------------------------------
 386 * submit_rx_urb
 387 *
 388 * Listen for input data on the BULK-IN pipe. If the pipe has
 389 * stalled then schedule it to be reset.
 390 *
 391 * Arguments:
 392 *       hw              device struct
 393 *       memflags        memory allocation flags
 394 *
 395 * Returns:
 396 *       error code from submission
 397 *
 398 * Call context:
 399 *       Any
 400 ----------------------------------------------------------------*/
 401 static int
 402 submit_rx_urb(hfa384x_t *hw, gfp_t memflags)
 403 {
 404         struct sk_buff *skb;
 405         int result;
 406
 407         DBFENTER;
 408
 409         skb = dev_alloc_skb(sizeof(hfa384x_usbin_t));
 410         if (skb == NULL) {
 411                 result = -ENOMEM;
 412                 goto done;
 413         }
 414
 415         /* Post the IN urb */
 416         usb_fill_bulk_urb(&hw->rx_urb, hw->usb,
 417                       hw->endp_in,
 418                       skb->data, sizeof(hfa384x_usbin_t),
 419                       hfa384x_usbin_callback, hw->wlandev);
 420
 421         hw->rx_urb_skb = skb;
 422
 423         result = -ENOLINK;
 424         if ( !hw->wlandev->hwremoved && !test_bit(WORK_RX_HALT, &hw->usb_flags)) {
 425                 result = SUBMIT_URB(&hw->rx_urb, memflags);
 426
 427                 /* Check whether we need to reset the RX pipe */
 428                 if (result == -EPIPE) {
 429                         WLAN_LOG_WARNING("%s rx pipe stalled: requesting reset\n",
 430                                          hw->wlandev->netdev->name);
 431                         if ( !test_and_set_bit(WORK_RX_HALT, &hw->usb_flags) )
 432                                 schedule_work(&hw->usb_work);
 433                 }
 434         }
 435
 436         /* Don't leak memory if anything should go wrong */
 437         if (result != 0) {
 438                 dev_kfree_skb(skb);
 439                 hw->rx_urb_skb = NULL;
 440         }
 441
 442  done:
 443
 444         DBFEXIT;
 445         return result;
 446 }
 447
 448 /*----------------------------------------------------------------
 449 * submit_tx_urb
 450 *
 451 * Prepares and submits the URB of transmitted data. If the
 452 * submission fails then it will schedule the output pipe to
 453 * be reset.
 454 *
 455 * Arguments:
 456 *       hw              device struct
 457 *       tx_urb          URB of data for tranmission
 458 *       memflags        memory allocation flags
 459 *
 460 * Returns:
 461 *       error code from submission
 462 *
 463 * Call context:
 464 *       Any
 465 ----------------------------------------------------------------*/
 466 static int
 467 submit_tx_urb(hfa384x_t *hw, struct urb *tx_urb, gfp_t memflags)
 468 {
 469         struct net_device *netdev = hw->wlandev->netdev;
 470         int result;
 471
 472         DBFENTER;
 473
 474         result = -ENOLINK;
 475         if ( netif_running(netdev) ) {
 476
 477                 if ( !hw->wlandev->hwremoved && !test_bit(WORK_TX_HALT, &hw->usb_flags) ) {
 478                         result = SUBMIT_URB(tx_urb, memflags);
 479
 480                         /* Test whether we need to reset the TX pipe */
 481                         if (result == -EPIPE) {
 482                                 WLAN_LOG_WARNING("%s tx pipe stalled: requesting reset\n",
 483                                                  netdev->name);
 484                                 set_bit(WORK_TX_HALT, &hw->usb_flags);
 485                                 schedule_work(&hw->usb_work);
 486                         } else if (result == 0) {
 487                                 netif_stop_queue(netdev);
 488                         }
 489                 }
 490         }
 491
 492         DBFEXIT;
 493
 494         return result;
 495 }
 496
 497 /*----------------------------------------------------------------
 498 * hfa394x_usb_defer
 499 *
 500 * There are some things that the USB stack cannot do while
 501 * in interrupt context, so we arrange this function to run
 502 * in process context.
 503 *
 504 * Arguments:
 505 *       hw      device structure
 506 *
 507 * Returns:
 508 *       nothing
 509 *
 510 * Call context:
 511 *       process (by design)
 512 ----------------------------------------------------------------*/
 513 static void
 514 hfa384x_usb_defer(struct work_struct *data)
 515 {
 516         hfa384x_t *hw = container_of(data, struct hfa384x, usb_work);
 517         struct net_device *netdev = hw->wlandev->netdev;
 518
 519         DBFENTER;
 520
 521         /* Don't bother trying to reset anything if the plug
 522          * has been pulled ...
 523          */
 524         if ( hw->wlandev->hwremoved ) {
 525                 DBFEXIT;
 526                 return;
 527         }
 528
 529         /* Reception has stopped: try to reset the input pipe */
 530         if (test_bit(WORK_RX_HALT, &hw->usb_flags)) {
 531                 int ret;
 532
 533                 usb_kill_urb(&hw->rx_urb);  /* Cannot be holding spinlock! */
 534
 535                 ret = usb_clear_halt(hw->usb, hw->endp_in);
 536                 if (ret != 0) {
 537                         printk(KERN_ERR
 538                                "Failed to clear rx pipe for %s: err=%d\n",
 539                                netdev->name, ret);
 540                 } else {
 541                         printk(KERN_INFO "%s rx pipe reset complete.\n",
 542                                          netdev->name);
 543                         clear_bit(WORK_RX_HALT, &hw->usb_flags);
 544                         set_bit(WORK_RX_RESUME, &hw->usb_flags);
 545                 }
 546         }
 547
 548         /* Resume receiving data back from the device. */
 549         if ( test_bit(WORK_RX_RESUME, &hw->usb_flags) ) {
 550                 int ret;
 551
 552                 ret = submit_rx_urb(hw, GFP_KERNEL);
 553                 if (ret != 0) {
 554                         printk(KERN_ERR
 555                                "Failed to resume %s rx pipe.\n", netdev->name);
 556                 } else {
 557                         clear_bit(WORK_RX_RESUME, &hw->usb_flags);
 558                 }
 559         }
 560
 561         /* Transmission has stopped: try to reset the output pipe */
 562         if (test_bit(WORK_TX_HALT, &hw->usb_flags)) {
 563                 int ret;
 564
 565                 usb_kill_urb(&hw->tx_urb);
 566                 ret = usb_clear_halt(hw->usb, hw->endp_out);
 567                 if (ret != 0) {
 568                         printk(KERN_ERR
 569                                "Failed to clear tx pipe for %s: err=%d\n",
 570                                netdev->name, ret);
 571                 } else {
 572                         printk(KERN_INFO "%s tx pipe reset complete.\n",
 573                                          netdev->name);
 574                         clear_bit(WORK_TX_HALT, &hw->usb_flags);
 575                         set_bit(WORK_TX_RESUME, &hw->usb_flags);
 576
 577                         /* Stopping the BULK-OUT pipe also blocked
 578                          * us from sending any more CTLX URBs, so
 579                          * we need to re-run our queue ...
 580                          */
 581                         hfa384x_usbctlxq_run(hw);
 582                 }
 583         }
 584
 585         /* Resume transmitting. */
 586         if ( test_and_clear_bit(WORK_TX_RESUME, &hw->usb_flags) ) {
 587                 netif_wake_queue(hw->wlandev->netdev);
 588         }
 589
 590         DBFEXIT;
 591 }
 592
 593
 594 /*----------------------------------------------------------------
 595 * hfa384x_create
 596 *
 597 * Sets up the hfa384x_t data structure for use.  Note this
 598 * does _not_ intialize the actual hardware, just the data structures
 599 * we use to keep track of its state.
 600 *
 601 * Arguments:
 602 *       hw              device structure
 603 *       irq             device irq number
 604 *       iobase          i/o base address for register access
 605 *       membase         memory base address for register access
 606 *
 607 * Returns:
 608 *       nothing
 609 *
 610 * Side effects:
 611 *
 612 * Call context:
 613 *       process
 614 ----------------------------------------------------------------*/
 615 void
 616 hfa384x_create( hfa384x_t *hw, struct usb_device *usb)
 617 {
 618         DBFENTER;
 619
 620         memset(hw, 0, sizeof(hfa384x_t));
 621         hw->usb = usb;
 622
 623         /* set up the endpoints */
 624         hw->endp_in = usb_rcvbulkpipe(usb, 1);
 625         hw->endp_out = usb_sndbulkpipe(usb, 2);
 626
 627         /* Set up the waitq */
 628         init_waitqueue_head(&hw->cmdq);
 629
 630         /* Initialize the command queue */
 631         spin_lock_init(&hw->ctlxq.lock);
 632         INIT_LIST_HEAD(&hw->ctlxq.pending);
 633         INIT_LIST_HEAD(&hw->ctlxq.active);
 634         INIT_LIST_HEAD(&hw->ctlxq.completing);
 635         INIT_LIST_HEAD(&hw->ctlxq.reapable);
 636
 637         /* Initialize the authentication queue */
 638         skb_queue_head_init(&hw->authq);
 639
 640         tasklet_init(&hw->reaper_bh,
 641                      hfa384x_usbctlx_reaper_task,
 642                      (unsigned long)hw);
 643         tasklet_init(&hw->completion_bh,
 644                      hfa384x_usbctlx_completion_task,
 645                      (unsigned long)hw);
 646         INIT_WORK(&hw->link_bh, prism2sta_processing_defer);
 647         INIT_WORK(&hw->usb_work, hfa384x_usb_defer);
 648
 649         init_timer(&hw->throttle);
 650         hw->throttle.function = hfa384x_usb_throttlefn;
 651         hw->throttle.data = (unsigned long)hw;
 652
 653         init_timer(&hw->resptimer);
 654         hw->resptimer.function = hfa384x_usbctlx_resptimerfn;
 655         hw->resptimer.data = (unsigned long)hw;
 656
 657         init_timer(&hw->reqtimer);
 658         hw->reqtimer.function = hfa384x_usbctlx_reqtimerfn;
 659         hw->reqtimer.data = (unsigned long)hw;
 660
 661         usb_init_urb(&hw->rx_urb);
 662         usb_init_urb(&hw->tx_urb);
 663         usb_init_urb(&hw->ctlx_urb);
 664
 665         hw->link_status = HFA384x_LINK_NOTCONNECTED;
 666         hw->state = HFA384x_STATE_INIT;
 667
 668         INIT_WORK(&hw->commsqual_bh, prism2sta_commsqual_defer);
 669         init_timer(&hw->commsqual_timer);
 670         hw->commsqual_timer.data = (unsigned long) hw;
 671         hw->commsqual_timer.function = prism2sta_commsqual_timer;
 672
 673         DBFEXIT;
 674 }
 675
 676
 677 /*----------------------------------------------------------------
 678 * hfa384x_destroy
 679 *
 680 * Partner to hfa384x_create().  This function cleans up the hw
 681 * structure so that it can be freed by the caller using a simple
 682 * kfree.  Currently, this function is just a placeholder.  If, at some
 683 * point in the future, an hw in the 'shutdown' state requires a 'deep'
 684 * kfree, this is where it should be done.  Note that if this function
 685 * is called on a _running_ hw structure, the drvr_stop() function is
 686 * called.
 687 *
 688 * Arguments:
 689 *       hw              device structure
 690 *
 691 * Returns:
 692 *       nothing, this function is not allowed to fail.
 693 *
 694 * Side effects:
 695 *
 696 * Call context:
 697 *       process
 698 ----------------------------------------------------------------*/
 699 void
 700 hfa384x_destroy( hfa384x_t *hw)
 701 {
 702         struct sk_buff *skb;
 703
 704         DBFENTER;
 705
 706         if ( hw->state == HFA384x_STATE_RUNNING ) {
 707                 hfa384x_drvr_stop(hw);
 708         }
 709         hw->state = HFA384x_STATE_PREINIT;
 710
 711         if (hw->scanresults) {
 712                 kfree(hw->scanresults);
 713                 hw->scanresults = NULL;
 714         }
 715
 716         /* Now to clean out the auth queue */
 717         while ( (skb = skb_dequeue(&hw->authq)) ) {
 718                 dev_kfree_skb(skb);
 719         }
 720
 721         DBFEXIT;
 722 }
 723
 724
 725 /*----------------------------------------------------------------
 726  */
 727 static hfa384x_usbctlx_t* usbctlx_alloc(void)
 728 {
 729         hfa384x_usbctlx_t *ctlx;
 730
 731         ctlx = kmalloc(sizeof(*ctlx), in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
 732         if (ctlx != NULL)
 733         {
 734                 memset(ctlx, 0, sizeof(*ctlx));
 735                 init_completion(&ctlx->done);
 736         }
 737
 738         return ctlx;
 739 }
 740
 741
 742 /*----------------------------------------------------------------
 743  *
 744 ----------------------------------------------------------------*/
 745 static int
 746 usbctlx_get_status(const hfa384x_usb_cmdresp_t *cmdresp,
 747                    hfa384x_cmdresult_t *result)
 748 {
 749         DBFENTER;
 750
 751         result->status = hfa384x2host_16(cmdresp->status);
 752         result->resp0 = hfa384x2host_16(cmdresp->resp0);
 753         result->resp1 = hfa384x2host_16(cmdresp->resp1);
 754         result->resp2 = hfa384x2host_16(cmdresp->resp2);
 755
 756         WLAN_LOG_DEBUG(4, "cmdresult:status=0x%04x "
 757                           "resp0=0x%04x resp1=0x%04x resp2=0x%04x\n",
 758                         result->status,
 759                         result->resp0,
 760                         result->resp1,
 761                         result->resp2);
 762
 763         DBFEXIT;
 764         return (result->status & HFA384x_STATUS_RESULT);
 765 }
 766
 767 static void
 768 usbctlx_get_rridresult(const hfa384x_usb_rridresp_t *rridresp,
 769                        hfa384x_rridresult_t *result)
 770 {
 771         DBFENTER;
 772
 773         result->rid = hfa384x2host_16(rridresp->rid);
 774         result->riddata = rridresp->data;
 775         result->riddata_len = ((hfa384x2host_16(rridresp->frmlen) - 1) * 2);
 776
 777         DBFEXIT;
 778 }
 779
 780
 781 /*----------------------------------------------------------------
 782 * Completor object:
 783 * This completor must be passed to hfa384x_usbctlx_complete_sync()
 784 * when processing a CTLX that returns a hfa384x_cmdresult_t structure.
 785 ----------------------------------------------------------------*/
 786 struct usbctlx_cmd_completor
 787 {
 788         usbctlx_completor_t     head;
 789
 790         const hfa384x_usb_cmdresp_t     *cmdresp;
 791         hfa384x_cmdresult_t     *result;
 792 };
 793 typedef struct usbctlx_cmd_completor usbctlx_cmd_completor_t;
 794
 795 static int usbctlx_cmd_completor_fn(usbctlx_completor_t *head)
 796 {
 797         usbctlx_cmd_completor_t *complete = (usbctlx_cmd_completor_t*)head;
 798         return usbctlx_get_status(complete->cmdresp, complete->result);
 799 }
 800
 801 static inline usbctlx_completor_t*
 802 init_cmd_completor(usbctlx_cmd_completor_t *completor,
 803                    const hfa384x_usb_cmdresp_t *cmdresp,
 804                    hfa384x_cmdresult_t *result)
 805 {
 806         completor->head.complete = usbctlx_cmd_completor_fn;
 807         completor->cmdresp = cmdresp;
 808         completor->result = result;
 809         return &(completor->head);
 810 }
 811
 812 /*----------------------------------------------------------------
 813 * Completor object:
 814 * This completor must be passed to hfa384x_usbctlx_complete_sync()
 815 * when processing a CTLX that reads a RID.
 816 ----------------------------------------------------------------*/
 817 struct usbctlx_rrid_completor
 818 {
 819         usbctlx_completor_t     head;
 820
 821         const hfa384x_usb_rridresp_t    *rridresp;
 822         void                    *riddata;
 823         unsigned int                    riddatalen;
 824 };
 825 typedef struct usbctlx_rrid_completor usbctlx_rrid_completor_t;
 826
 827 static int usbctlx_rrid_completor_fn(usbctlx_completor_t *head)
 828 {
 829         usbctlx_rrid_completor_t *complete = (usbctlx_rrid_completor_t*)head;
 830         hfa384x_rridresult_t rridresult;
 831
 832         usbctlx_get_rridresult(complete->rridresp, &rridresult);
 833
 834         /* Validate the length, note body len calculation in bytes */
 835         if ( rridresult.riddata_len != complete->riddatalen ) {
 836                 WLAN_LOG_WARNING(
 837                         "RID len mismatch, rid=0x%04x hlen=%d fwlen=%d\n",
 838                         rridresult.rid,
 839                         complete->riddatalen,
 840                         rridresult.riddata_len);
 841                 return -ENODATA;
 842         }
 843
 844         memcpy(complete->riddata,
 845                rridresult.riddata,
 846                complete->riddatalen);
 847         return 0;
 848 }
 849
 850 static inline usbctlx_completor_t*
 851 init_rrid_completor(usbctlx_rrid_completor_t *completor,
 852                     const hfa384x_usb_rridresp_t *rridresp,
 853                     void *riddata,
 854                     unsigned int riddatalen)
 855 {
 856         completor->head.complete = usbctlx_rrid_completor_fn;
 857         completor->rridresp = rridresp;
 858         completor->riddata = riddata;
 859         completor->riddatalen = riddatalen;
 860         return &(completor->head);
 861 }
 862
 863 /*----------------------------------------------------------------
 864 * Completor object:
 865 * Interprets the results of a synchronous RID-write
 866 ----------------------------------------------------------------*/
 867 typedef usbctlx_cmd_completor_t usbctlx_wrid_completor_t;
 868 #define init_wrid_completor  init_cmd_completor
 869
 870 /*----------------------------------------------------------------
 871 * Completor object:
 872 * Interprets the results of a synchronous memory-write
 873 ----------------------------------------------------------------*/
 874 typedef usbctlx_cmd_completor_t usbctlx_wmem_completor_t;
 875 #define init_wmem_completor  init_cmd_completor
 876
 877 /*----------------------------------------------------------------
 878 * Completor object:
 879 * Interprets the results of a synchronous memory-read
 880 ----------------------------------------------------------------*/
 881 struct usbctlx_rmem_completor
 882 {
 883         usbctlx_completor_t           head;
 884
 885         const hfa384x_usb_rmemresp_t  *rmemresp;
 886         void                          *data;
 887         unsigned int                          len;
 888 };
 889 typedef struct usbctlx_rmem_completor usbctlx_rmem_completor_t;
 890
 891 static int usbctlx_rmem_completor_fn(usbctlx_completor_t *head)
 892 {
 893         usbctlx_rmem_completor_t *complete = (usbctlx_rmem_completor_t*)head;
 894
 895         WLAN_LOG_DEBUG(4,"rmemresp:len=%d\n", complete->rmemresp->frmlen);
 896         memcpy(complete->data, complete->rmemresp->data, complete->len);
 897         return 0;
 898 }
 899
 900 static inline usbctlx_completor_t*
 901 init_rmem_completor(usbctlx_rmem_completor_t *completor,
 902                     hfa384x_usb_rmemresp_t *rmemresp,
 903                     void *data,
 904                     unsigned int len)
 905 {
 906         completor->head.complete = usbctlx_rmem_completor_fn;
 907         completor->rmemresp = rmemresp;
 908         completor->data = data;
 909         completor->len = len;
 910         return &(completor->head);
 911 }
 912
 913 /*----------------------------------------------------------------
 914 * hfa384x_cb_status
 915 *
 916 * Ctlx_complete handler for async CMD type control exchanges.
 917 * mark the hw struct as such.
 918 *
 919 * Note: If the handling is changed here, it should probably be
 920 *       changed in docmd as well.
 921 *
 922 * Arguments:
 923 *       hw              hw struct
 924 *       ctlx            completed CTLX
 925 *
 926 * Returns:
 927 *       nothing
 928 *
 929 * Side effects:
 930 *
 931 * Call context:
 932 *       interrupt
 933 ----------------------------------------------------------------*/
 934 static void
 935 hfa384x_cb_status(hfa384x_t *hw, const hfa384x_usbctlx_t *ctlx)
 936 {
 937         DBFENTER;
 938
 939         if ( ctlx->usercb != NULL ) {
 940                 hfa384x_cmdresult_t cmdresult;
 941
 942                 if (ctlx->state != CTLX_COMPLETE) {
 943                         memset(&cmdresult, 0, sizeof(cmdresult));
 944                         cmdresult.status = HFA384x_STATUS_RESULT_SET(HFA384x_CMD_ERR);
 945                 } else {
 946                         usbctlx_get_status(&ctlx->inbuf.cmdresp, &cmdresult);
 947                 }
 948
 949                 ctlx->usercb(hw, &cmdresult, ctlx->usercb_data);
 950         }
 951
 952         DBFEXIT;
 953 }
 954
 955
 956 /*----------------------------------------------------------------
 957 * hfa384x_cb_rrid
 958 *
 959 * CTLX completion handler for async RRID type control exchanges.
 960 *
 961 * Note: If the handling is changed here, it should probably be
 962 *       changed in dorrid as well.
 963 *
 964 * Arguments:
 965 *       hw              hw struct
 966 *       ctlx            completed CTLX
 967 *
 968 * Returns:
 969 *       nothing
 970 *
 971 * Side effects:
 972 *
 973 * Call context:
 974 *       interrupt
 975 ----------------------------------------------------------------*/
 976 static void
 977 hfa384x_cb_rrid(hfa384x_t *hw, const hfa384x_usbctlx_t *ctlx)
 978 {
 979         DBFENTER;
 980
 981         if ( ctlx->usercb != NULL ) {
 982                 hfa384x_rridresult_t rridresult;
 983
 984                 if (ctlx->state != CTLX_COMPLETE) {
 985                         memset(&rridresult, 0, sizeof(rridresult));
 986                         rridresult.rid = hfa384x2host_16(ctlx->outbuf.rridreq.rid);
 987                 } else {
 988                         usbctlx_get_rridresult(&ctlx->inbuf.rridresp, &rridresult);
 989                 }
 990
 991                 ctlx->usercb(hw, &rridresult, ctlx->usercb_data);
 992         }
 993
 994         DBFEXIT;
 995 }
 996
 997 static inline int
 998 hfa384x_docmd_wait(hfa384x_t *hw, hfa384x_metacmd_t *cmd)
 999 {
1000         return hfa384x_docmd(hw, DOWAIT, cmd, NULL, NULL, NULL);
1001 }
1002
1003 static inline int
1004 hfa384x_docmd_async(hfa384x_t *hw,
1005                     hfa384x_metacmd_t *cmd,
1006                     ctlx_cmdcb_t cmdcb,
1007                     ctlx_usercb_t usercb,
1008                     void *usercb_data)
1009 {
1010         return hfa384x_docmd(hw, DOASYNC, cmd,
1011                                 cmdcb, usercb, usercb_data);
1012 }
1013
1014 static inline int
1015 hfa384x_dorrid_wait(hfa384x_t *hw, u16 rid, void *riddata, unsigned int riddatalen)
1016 {
1017         return hfa384x_dorrid(hw, DOWAIT,
1018                               rid, riddata, riddatalen,
1019                               NULL, NULL, NULL);
1020 }
1021
1022 static inline int
1023 hfa384x_dorrid_async(hfa384x_t *hw,
1024                      u16 rid, void *riddata, unsigned int riddatalen,
1025                      ctlx_cmdcb_t cmdcb,
1026                      ctlx_usercb_t usercb,
1027                      void *usercb_data)
1028 {
1029         return hfa384x_dorrid(hw, DOASYNC,
1030                               rid, riddata, riddatalen,
1031                               cmdcb, usercb, usercb_data);
1032 }
1033
1034 static inline int
1035 hfa384x_dowrid_wait(hfa384x_t *hw, u16 rid, void *riddata, unsigned int riddatalen)
1036 {
1037         return hfa384x_dowrid(hw, DOWAIT,
1038                               rid, riddata, riddatalen,
1039                               NULL, NULL, NULL);
1040 }
1041
1042 static inline int
1043 hfa384x_dowrid_async(hfa384x_t *hw,
1044                      u16 rid, void *riddata, unsigned int riddatalen,
1045                      ctlx_cmdcb_t cmdcb,
1046                      ctlx_usercb_t usercb,
1047                      void *usercb_data)
1048 {
1049         return hfa384x_dowrid(hw, DOASYNC,
1050                               rid, riddata, riddatalen,
1051                               cmdcb, usercb, usercb_data);
1052 }
1053
1054 static inline int
1055 hfa384x_dormem_wait(hfa384x_t *hw,
1056                     u16 page, u16 offset, void *data, unsigned int len)
1057 {
1058         return hfa384x_dormem(hw, DOWAIT,
1059                               page, offset, data, len,
1060                               NULL, NULL, NULL);
1061 }
1062
1063 static inline int
1064 hfa384x_dormem_async(hfa384x_t *hw,
1065                      u16 page, u16 offset, void *data, unsigned int len,
1066                      ctlx_cmdcb_t cmdcb,
1067                      ctlx_usercb_t usercb,
1068                      void *usercb_data)
1069 {
1070         return hfa384x_dormem(hw, DOASYNC,
1071                               page, offset, data, len,
1072                               cmdcb, usercb, usercb_data);
1073 }
1074
1075 static inline int
1076 hfa384x_dowmem_wait(
1077         hfa384x_t *hw,
1078         u16  page,
1079         u16  offset,
1080         void    *data,
1081         unsigned int    len)
1082 {
1083         return hfa384x_dowmem(hw, DOWAIT,
1084                                   page, offset, data, len,
1085                                   NULL, NULL, NULL);
1086 }
1087
1088 static inline int
1089 hfa384x_dowmem_async(
1090         hfa384x_t *hw,
1091         u16  page,
1092         u16  offset,
1093         void    *data,
1094         unsigned int    len,
1095         ctlx_cmdcb_t cmdcb,
1096         ctlx_usercb_t usercb,
1097         void    *usercb_data)
1098 {
1099         return hfa384x_dowmem(hw, DOASYNC,
1100                                   page, offset, data, len,
1101                                   cmdcb, usercb, usercb_data);
1102 }
1103
1104 /*----------------------------------------------------------------
1105 * hfa384x_cmd_initialize
1106 *
1107 * Issues the initialize command and sets the hw->state based
1108 * on the result.
1109 *
1110 * Arguments:
1111 *       hw              device structure
1112 *
1113 * Returns:
1114 *       0               success
1115 *       >0              f/w reported error - f/w status code
1116 *       <0              driver reported error
1117 *
1118 * Side effects:
1119 *
1120 * Call context:
1121 *       process
1122 ----------------------------------------------------------------*/
1123 int
1124 hfa384x_cmd_initialize(hfa384x_t *hw)
1125 {
1126         int     result = 0;
1127         int     i;
1128         hfa384x_metacmd_t cmd;
1129
1130         DBFENTER;
1131
1132
1133         cmd.cmd = HFA384x_CMDCODE_INIT;
1134         cmd.parm0 = 0;
1135         cmd.parm1 = 0;
1136         cmd.parm2 = 0;
1137
1138         result = hfa384x_docmd_wait(hw, &cmd);
1139
1140
1141         WLAN_LOG_DEBUG(3,"cmdresp.init: "
1142                 "status=0x%04x, resp0=0x%04x, "
1143                 "resp1=0x%04x, resp2=0x%04x\n",
1144                 cmd.result.status,
1145                 cmd.result.resp0,
1146                 cmd.result.resp1,
1147                 cmd.result.resp2);
1148         if ( result == 0 ) {
1149                 for ( i = 0; i < HFA384x_NUMPORTS_MAX; i++) {
1150                         hw->port_enabled[i] = 0;
1151                 }
1152         }
1153
1154         hw->link_status = HFA384x_LINK_NOTCONNECTED;
1155
1156         DBFEXIT;
1157         return result;
1158 }
1159
1160
1161 /*----------------------------------------------------------------
1162 * hfa384x_cmd_disable
1163 *
1164 * Issues the disable command to stop communications on one of
1165 * the MACs 'ports'.
1166 *
1167 * Arguments:
1168 *       hw              device structure
1169 *       macport         MAC port number (host order)
1170 *
1171 * Returns:
1172 *       0               success
1173 *       >0              f/w reported failure - f/w status code
1174 *       <0              driver reported error (timeout|bad arg)
1175 *
1176 * Side effects:
1177 *
1178 * Call context:
1179 *       process
1180 ----------------------------------------------------------------*/
1181 int hfa384x_cmd_disable(hfa384x_t *hw, u16 macport)
1182 {
1183         int     result = 0;
1184         hfa384x_metacmd_t cmd;
1185
1186         DBFENTER;
1187
1188         cmd.cmd = HFA384x_CMD_CMDCODE_SET(HFA384x_CMDCODE_DISABLE) |
1189                   HFA384x_CMD_MACPORT_SET(macport);
1190         cmd.parm0 = 0;
1191         cmd.parm1 = 0;
1192         cmd.parm2 = 0;
1193
1194         result = hfa384x_docmd_wait(hw, &cmd);
1195
1196         DBFEXIT;
1197         return result;
1198 }
1199
1200
1201 /*----------------------------------------------------------------
1202 * hfa384x_cmd_enable
1203 *
1204 * Issues the enable command to enable communications on one of
1205 * the MACs 'ports'.
1206 *
1207 * Arguments:
1208 *       hw              device structure
1209 *       macport         MAC port number
1210 *
1211 * Returns:
1212 *       0               success
1213 *       >0              f/w reported failure - f/w status code
1214 *       <0              driver reported error (timeout|bad arg)
1215 *
1216 * Side effects:
1217 *
1218 * Call context:
1219 *       process
1220 ----------------------------------------------------------------*/
1221 int hfa384x_cmd_enable(hfa384x_t *hw, u16 macport)
1222 {
1223         int     result = 0;
1224         hfa384x_metacmd_t cmd;
1225
1226         DBFENTER;
1227
1228         cmd.cmd = HFA384x_CMD_CMDCODE_SET(HFA384x_CMDCODE_ENABLE) |
1229                   HFA384x_CMD_MACPORT_SET(macport);
1230         cmd.parm0 = 0;
1231         cmd.parm1 = 0;
1232         cmd.parm2 = 0;
1233
1234         result = hfa384x_docmd_wait(hw, &cmd);
1235
1236         DBFEXIT;
1237         return result;
1238 }
1239
1240 /*----------------------------------------------------------------
1241 * hfa384x_cmd_monitor
1242 *
1243 * Enables the 'monitor mode' of the MAC.  Here's the description of
1244 * monitor mode that I've received thus far:
1245 *
1246 *  "The "monitor mode" of operation is that the MAC passes all
1247 *  frames for which the PLCP checks are correct. All received
1248 *  MPDUs are passed to the host with MAC Port = 7, with a
1249 *  receive status of good, FCS error, or undecryptable. Passing
1250 *  certain MPDUs is a violation of the 802.11 standard, but useful
1251 *  for a debugging tool."  Normal communication is not possible
1252 *  while monitor mode is enabled.
1253 *
1254 * Arguments:
1255 *       hw              device structure
1256 *       enable          a code (0x0b|0x0f) that enables/disables
1257 *                       monitor mode. (host order)
1258 *
1259 * Returns:
1260 *       0               success
1261 *       >0              f/w reported failure - f/w status code
1262 *       <0              driver reported error (timeout|bad arg)
1263 *
1264 * Side effects:
1265 *
1266 * Call context:
1267 *       process
1268 ----------------------------------------------------------------*/
1269 int hfa384x_cmd_monitor(hfa384x_t *hw, u16 enable)
1270 {
1271         int     result = 0;
1272         hfa384x_metacmd_t cmd;
1273
1274         DBFENTER;
1275
1276         cmd.cmd = HFA384x_CMD_CMDCODE_SET(HFA384x_CMDCODE_MONITOR) |
1277                 HFA384x_CMD_AINFO_SET(enable);
1278         cmd.parm0 = 0;
1279         cmd.parm1 = 0;
1280         cmd.parm2 = 0;
1281
1282         result = hfa384x_docmd_wait(hw, &cmd);
1283
1284         DBFEXIT;
1285         return result;
1286 }
1287
1288
1289 /*----------------------------------------------------------------
1290 * hfa384x_cmd_download
1291 *
1292 * Sets the controls for the MAC controller code/data download
1293 * process.  The arguments set the mode and address associated
1294 * with a download.  Note that the aux registers should be enabled
1295 * prior to setting one of the download enable modes.
1296 *
1297 * Arguments:
1298 *       hw              device structure
1299 *       mode            0 - Disable programming and begin code exec
1300 *                       1 - Enable volatile mem programming
1301 *                       2 - Enable non-volatile mem programming
1302 *                       3 - Program non-volatile section from NV download
1303 *                           buffer.
1304 *                       (host order)
1305 *       lowaddr
1306 *       highaddr        For mode 1, sets the high & low order bits of
1307 *                       the "destination address".  This address will be
1308 *                       the execution start address when download is
1309 *                       subsequently disabled.
1310 *                       For mode 2, sets the high & low order bits of
1311 *                       the destination in NV ram.
1312 *                       For modes 0 & 3, should be zero. (host order)
1313 *                       NOTE: these are CMD format.
1314 *       codelen         Length of the data to write in mode 2,
1315 *                       zero otherwise. (host order)
1316 *
1317 * Returns:
1318 *       0               success
1319 *       >0              f/w reported failure - f/w status code
1320 *       <0              driver reported error (timeout|bad arg)
1321 *
1322 * Side effects:
1323 *
1324 * Call context:
1325 *       process
1326 ----------------------------------------------------------------*/
1327 int hfa384x_cmd_download(hfa384x_t *hw, u16 mode, u16 lowaddr,
1328                                 u16 highaddr, u16 codelen)
1329 {
1330         int     result = 0;
1331         hfa384x_metacmd_t cmd;
1332
1333         DBFENTER;
1334         WLAN_LOG_DEBUG(5,
1335                 "mode=%d, lowaddr=0x%04x, highaddr=0x%04x, codelen=%d\n",
1336                 mode, lowaddr, highaddr, codelen);
1337
1338         cmd.cmd = (HFA384x_CMD_CMDCODE_SET(HFA384x_CMDCODE_DOWNLD) |
1339                    HFA384x_CMD_PROGMODE_SET(mode));
1340
1341         cmd.parm0 = lowaddr;
1342         cmd.parm1 = highaddr;
1343         cmd.parm2 = codelen;
1344
1345         result = hfa384x_docmd_wait(hw, &cmd);
1346
1347         DBFEXIT;
1348         return result;
1349 }
1350
1351
1352 /*----------------------------------------------------------------
1353 * hfa384x_copy_from_aux
1354 *
1355 * Copies a collection of bytes from the controller memory.  The
1356 * Auxiliary port MUST be enabled prior to calling this function.
1357 * We _might_ be in a download state.
1358 *
1359 * Arguments:
1360 *       hw              device structure
1361 *       cardaddr        address in hfa384x data space to read
1362 *       auxctl          address space select
1363 *       buf             ptr to destination host buffer
1364 *       len             length of data to transfer (in bytes)
1365 *
1366 * Returns:
1367 *       nothing
1368 *
1369 * Side effects:
1370 *       buf contains the data copied
1371 *
1372 * Call context:
1373 *       process
1374 *       interrupt
1375 ----------------------------------------------------------------*/
1376 void
1377 hfa384x_copy_from_aux(
1378         hfa384x_t *hw, u32 cardaddr, u32 auxctl, void *buf, unsigned int len)
1379 {
1380         DBFENTER;
1381         WLAN_LOG_ERROR("not used in USB.\n");
1382         DBFEXIT;
1383 }
1384
1385
1386 /*----------------------------------------------------------------
1387 * hfa384x_copy_to_aux
1388 *
1389 * Copies a collection of bytes to the controller memory.  The
1390 * Auxiliary port MUST be enabled prior to calling this function.
1391 * We _might_ be in a download state.
1392 *
1393 * Arguments:
1394 *       hw              device structure
1395 *       cardaddr        address in hfa384x data space to read
1396 *       auxctl          address space select
1397 *       buf             ptr to destination host buffer
1398 *       len             length of data to transfer (in bytes)
1399 *
1400 * Returns:
1401 *       nothing
1402 *
1403 * Side effects:
1404 *       Controller memory now contains a copy of buf
1405 *
1406 * Call context:
1407 *       process
1408 *       interrupt
1409 ----------------------------------------------------------------*/
1410 void
1411 hfa384x_copy_to_aux(
1412         hfa384x_t *hw, u32 cardaddr, u32 auxctl, void *buf, unsigned int len)
1413 {
1414         DBFENTER;
1415         WLAN_LOG_ERROR("not used in USB.\n");
1416         DBFEXIT;
1417 }
1418
1419
1420 /*----------------------------------------------------------------
1421 * hfa384x_corereset
1422 *
1423 * Perform a reset of the hfa38xx MAC core.  We assume that the hw
1424 * structure is in its "created" state.  That is, it is initialized
1425 * with proper values.  Note that if a reset is done after the
1426 * device has been active for awhile, the caller might have to clean
1427 * up some leftover cruft in the hw structure.
1428 *
1429 * Arguments:
1430 *       hw              device structure
1431 *       holdtime        how long (in ms) to hold the reset
1432 *       settletime      how long (in ms) to wait after releasing
1433 *                       the reset
1434 *
1435 * Returns:
1436 *       nothing
1437 *
1438 * Side effects:
1439 *
1440 * Call context:
1441 *       process
1442 ----------------------------------------------------------------*/
1443 int hfa384x_corereset(hfa384x_t *hw, int holdtime, int settletime, int genesis)
1444 {
1445         int                     result = 0;
1446
1447         DBFENTER;
1448
1449         result=usb_reset_device(hw->usb);
1450         if(result<0) {
1451                 WLAN_LOG_ERROR("usb_reset_device() failed, result=%d.\n",result);
1452         }
1453
1454         DBFEXIT;
1455         return result;
1456 }
1457
1458
1459 /*----------------------------------------------------------------
1460 * hfa384x_usbctlx_complete_sync
1461 *
1462 * Waits for a synchronous CTLX object to complete,
1463 * and then handles the response.
1464 *
1465 * Arguments:
1466 *       hw              device structure
1467 *       ctlx            CTLX ptr
1468 *       completor       functor object to decide what to
1469 *                       do with the CTLX's result.
1470 *
1471 * Returns:
1472 *       0               Success
1473 *       -ERESTARTSYS    Interrupted by a signal
1474 *       -EIO            CTLX failed
1475 *       -ENODEV         Adapter was unplugged
1476 *       ???             Result from completor
1477 *
1478 * Side effects:
1479 *
1480 * Call context:
1481 *       process
1482 ----------------------------------------------------------------*/
1483 static int hfa384x_usbctlx_complete_sync(hfa384x_t *hw,
1484                                          hfa384x_usbctlx_t *ctlx,
1485                                          usbctlx_completor_t *completor)
1486 {
1487         unsigned long flags;
1488         int result;
1489
1490         DBFENTER;
1491
1492         result = wait_for_completion_interruptible(&ctlx->done);
1493
1494         spin_lock_irqsave(&hw->ctlxq.lock, flags);
1495
1496         /*
1497          * We can only handle the CTLX if the USB disconnect
1498          * function has not run yet ...
1499          */
1500         cleanup:
1501         if ( hw->wlandev->hwremoved )
1502         {
1503                 spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
1504                 result = -ENODEV;
1505         }
1506         else if ( result != 0 )
1507         {
1508                 int runqueue = 0;
1509
1510                 /*
1511                  * We were probably interrupted, so delete
1512                  * this CTLX asynchronously, kill the timers
1513                  * and the URB, and then start the next
1514                  * pending CTLX.
1515                  *
1516                  * NOTE: We can only delete the timers and
1517                  *       the URB if this CTLX is active.
1518                  */
1519                 if (ctlx == get_active_ctlx(hw))
1520                 {
1521                         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
1522
1523                         del_singleshot_timer_sync(&hw->reqtimer);
1524                         del_singleshot_timer_sync(&hw->resptimer);
1525                         hw->req_timer_done = 1;
1526                         hw->resp_timer_done = 1;
1527                         usb_kill_urb(&hw->ctlx_urb);
1528
1529                         spin_lock_irqsave(&hw->ctlxq.lock, flags);
1530
1531                         runqueue = 1;
1532
1533                         /*
1534                          * This scenario is so unlikely that I'm
1535                          * happy with a grubby "goto" solution ...
1536                          */
1537                         if ( hw->wlandev->hwremoved )
1538                                 goto cleanup;
1539                 }
1540
1541                 /*
1542                  * The completion task will send this CTLX
1543                  * to the reaper the next time it runs. We
1544                  * are no longer in a hurry.
1545                  */
1546                 ctlx->reapable = 1;
1547                 ctlx->state = CTLX_REQ_FAILED;
1548                 list_move_tail(&ctlx->list, &hw->ctlxq.completing);
1549
1550                 spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
1551
1552                 if (runqueue)
1553                         hfa384x_usbctlxq_run(hw);
1554         } else {
1555                 if (ctlx->state == CTLX_COMPLETE) {
1556                         result = completor->complete(completor);
1557                 } else {
1558                         WLAN_LOG_WARNING("CTLX[%d] error: state(%s)\n",
1559                                          hfa384x2host_16(ctlx->outbuf.type),
1560                                          ctlxstr(ctlx->state));
1561                         result = -EIO;
1562                 }
1563
1564                 list_del(&ctlx->list);
1565                 spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
1566                 kfree(ctlx);
1567         }
1568
1569         DBFEXIT;
1570         return result;
1571 }
1572
1573 /*----------------------------------------------------------------
1574 * hfa384x_docmd
1575 *
1576 * Constructs a command CTLX and submits it.
1577 *
1578 * NOTE: Any changes to the 'post-submit' code in this function
1579 *       need to be carried over to hfa384x_cbcmd() since the handling
1580 *       is virtually identical.
1581 *
1582 * Arguments:
1583 *       hw              device structure
1584 *       mode            DOWAIT or DOASYNC
1585 *       cmd             cmd structure.  Includes all arguments and result
1586 *                       data points.  All in host order. in host order
1587 *       cmdcb           command-specific callback
1588 *       usercb          user callback for async calls, NULL for DOWAIT calls
1589 *       usercb_data     user supplied data pointer for async calls, NULL
1590 *                       for DOASYNC calls
1591 *
1592 * Returns:
1593 *       0               success
1594 *       -EIO            CTLX failure
1595 *       -ERESTARTSYS    Awakened on signal
1596 *       >0              command indicated error, Status and Resp0-2 are
1597 *                       in hw structure.
1598 *
1599 * Side effects:
1600 *
1601 *
1602 * Call context:
1603 *       process
1604 ----------------------------------------------------------------*/
1605 static int
1606 hfa384x_docmd(
1607         hfa384x_t *hw,
1608         CMD_MODE mode,
1609         hfa384x_metacmd_t *cmd,
1610         ctlx_cmdcb_t    cmdcb,
1611         ctlx_usercb_t   usercb,
1612         void    *usercb_data)
1613 {
1614         int                     result;
1615         hfa384x_usbctlx_t       *ctlx;
1616
1617         DBFENTER;
1618         ctlx = usbctlx_alloc();
1619         if ( ctlx == NULL ) {
1620                 result = -ENOMEM;
1621                 goto done;
1622         }
1623
1624         /* Initialize the command */
1625         ctlx->outbuf.cmdreq.type =      host2hfa384x_16(HFA384x_USB_CMDREQ);
1626         ctlx->outbuf.cmdreq.cmd =       host2hfa384x_16(cmd->cmd);
1627         ctlx->outbuf.cmdreq.parm0 =     host2hfa384x_16(cmd->parm0);
1628         ctlx->outbuf.cmdreq.parm1 =     host2hfa384x_16(cmd->parm1);
1629         ctlx->outbuf.cmdreq.parm2 =     host2hfa384x_16(cmd->parm2);
1630
1631         ctlx->outbufsize = sizeof(ctlx->outbuf.cmdreq);
1632
1633         WLAN_LOG_DEBUG(4, "cmdreq: cmd=0x%04x "
1634                 "parm0=0x%04x parm1=0x%04x parm2=0x%04x\n",
1635                 cmd->cmd,
1636                 cmd->parm0,
1637                 cmd->parm1,
1638                 cmd->parm2);
1639
1640         ctlx->reapable = mode;
1641         ctlx->cmdcb = cmdcb;
1642         ctlx->usercb = usercb;
1643         ctlx->usercb_data = usercb_data;
1644
1645         result = hfa384x_usbctlx_submit(hw, ctlx);
1646         if (result != 0) {
1647                 kfree(ctlx);
1648         } else if (mode == DOWAIT) {
1649                 usbctlx_cmd_completor_t completor;
1650
1651                 result = hfa384x_usbctlx_complete_sync(
1652                              hw, ctlx, init_cmd_completor(&completor,
1653                                                           &ctlx->inbuf.cmdresp,
1654                                                           &cmd->result) );
1655         }
1656
1657 done:
1658         DBFEXIT;
1659         return result;
1660 }
1661
1662
1663 /*----------------------------------------------------------------
1664 * hfa384x_dorrid
1665 *
1666 * Constructs a read rid CTLX and issues it.
1667 *
1668 * NOTE: Any changes to the 'post-submit' code in this function
1669 *       need to be carried over to hfa384x_cbrrid() since the handling
1670 *       is virtually identical.
1671 *
1672 * Arguments:
1673 *       hw              device structure
1674 *       mode            DOWAIT or DOASYNC
1675 *       rid             Read RID number (host order)
1676 *       riddata         Caller supplied buffer that MAC formatted RID.data
1677 *                       record will be written to for DOWAIT calls. Should
1678 *                       be NULL for DOASYNC calls.
1679 *       riddatalen      Buffer length for DOWAIT calls. Zero for DOASYNC calls.
1680 *       cmdcb           command callback for async calls, NULL for DOWAIT calls
1681 *       usercb          user callback for async calls, NULL for DOWAIT calls
1682 *       usercb_data     user supplied data pointer for async calls, NULL
1683 *                       for DOWAIT calls
1684 *
1685 * Returns:
1686 *       0               success
1687 *       -EIO            CTLX failure
1688 *       -ERESTARTSYS    Awakened on signal
1689 *       -ENODATA        riddatalen != macdatalen
1690 *       >0              command indicated error, Status and Resp0-2 are
1691 *                       in hw structure.
1692 *
1693 * Side effects:
1694 *
1695 * Call context:
1696 *       interrupt (DOASYNC)
1697 *       process (DOWAIT or DOASYNC)
1698 ----------------------------------------------------------------*/
1699 static int
1700 hfa384x_dorrid(
1701         hfa384x_t *hw,
1702         CMD_MODE mode,
1703         u16     rid,
1704         void    *riddata,
1705         unsigned int    riddatalen,
1706         ctlx_cmdcb_t cmdcb,
1707         ctlx_usercb_t usercb,
1708         void    *usercb_data)
1709 {
1710         int                     result;
1711         hfa384x_usbctlx_t       *ctlx;
1712
1713         DBFENTER;
1714         ctlx = usbctlx_alloc();
1715         if ( ctlx == NULL ) {
1716                 result = -ENOMEM;
1717                 goto done;
1718         }
1719
1720         /* Initialize the command */
1721         ctlx->outbuf.rridreq.type =   host2hfa384x_16(HFA384x_USB_RRIDREQ);
1722         ctlx->outbuf.rridreq.frmlen =
1723                 host2hfa384x_16(sizeof(ctlx->outbuf.rridreq.rid));
1724         ctlx->outbuf.rridreq.rid =    host2hfa384x_16(rid);
1725
1726         ctlx->outbufsize = sizeof(ctlx->outbuf.rridreq);
1727
1728         ctlx->reapable = mode;
1729         ctlx->cmdcb = cmdcb;
1730         ctlx->usercb = usercb;
1731         ctlx->usercb_data = usercb_data;
1732
1733         /* Submit the CTLX */
1734         result = hfa384x_usbctlx_submit(hw, ctlx);
1735         if (result != 0) {
1736                 kfree(ctlx);
1737         } else if (mode == DOWAIT) {
1738                 usbctlx_rrid_completor_t completor;
1739
1740                 result = hfa384x_usbctlx_complete_sync(
1741                            hw, ctlx, init_rrid_completor(&completor,
1742                                                          &ctlx->inbuf.rridresp,
1743                                                          riddata,
1744                                                          riddatalen) );
1745         }
1746
1747 done:
1748         DBFEXIT;
1749         return result;
1750 }
1751
1752
1753 /*----------------------------------------------------------------
1754 * hfa384x_dowrid
1755 *
1756 * Constructs a write rid CTLX and issues it.
1757 *
1758 * NOTE: Any changes to the 'post-submit' code in this function
1759 *       need to be carried over to hfa384x_cbwrid() since the handling
1760 *       is virtually identical.
1761 *
1762 * Arguments:
1763 *       hw              device structure
1764 *       CMD_MODE        DOWAIT or DOASYNC
1765 *       rid             RID code
1766 *       riddata         Data portion of RID formatted for MAC
1767 *       riddatalen      Length of the data portion in bytes
1768 *       cmdcb           command callback for async calls, NULL for DOWAIT calls
1769 *       usercb          user callback for async calls, NULL for DOWAIT calls
1770 *       usercb_data     user supplied data pointer for async calls
1771 *
1772 * Returns:
1773 *       0               success
1774 *       -ETIMEDOUT      timed out waiting for register ready or
1775 *                       command completion
1776 *       >0              command indicated error, Status and Resp0-2 are
1777 *                       in hw structure.
1778 *
1779 * Side effects:
1780 *
1781 * Call context:
1782 *       interrupt (DOASYNC)
1783 *       process (DOWAIT or DOASYNC)
1784 ----------------------------------------------------------------*/
1785 static int
1786 hfa384x_dowrid(
1787         hfa384x_t *hw,
1788         CMD_MODE mode,
1789         u16     rid,
1790         void    *riddata,
1791         unsigned int    riddatalen,
1792         ctlx_cmdcb_t cmdcb,
1793         ctlx_usercb_t usercb,
1794         void    *usercb_data)
1795 {
1796         int                     result;
1797         hfa384x_usbctlx_t       *ctlx;
1798
1799         DBFENTER;
1800         ctlx = usbctlx_alloc();
1801         if ( ctlx == NULL ) {
1802                 result = -ENOMEM;
1803                 goto done;
1804         }
1805
1806         /* Initialize the command */
1807         ctlx->outbuf.wridreq.type =   host2hfa384x_16(HFA384x_USB_WRIDREQ);
1808         ctlx->outbuf.wridreq.frmlen = host2hfa384x_16(
1809                                         (sizeof(ctlx->outbuf.wridreq.rid) +
1810                                         riddatalen + 1) / 2);
1811         ctlx->outbuf.wridreq.rid =    host2hfa384x_16(rid);
1812         memcpy(ctlx->outbuf.wridreq.data, riddata, riddatalen);
1813
1814         ctlx->outbufsize = sizeof(ctlx->outbuf.wridreq.type) +
1815                            sizeof(ctlx->outbuf.wridreq.frmlen) +
1816                            sizeof(ctlx->outbuf.wridreq.rid) +
1817                            riddatalen;
1818
1819         ctlx->reapable = mode;
1820         ctlx->cmdcb = cmdcb;
1821         ctlx->usercb = usercb;
1822         ctlx->usercb_data = usercb_data;
1823
1824         /* Submit the CTLX */
1825         result = hfa384x_usbctlx_submit(hw, ctlx);
1826         if (result != 0) {
1827                 kfree(ctlx);
1828         } else if (mode == DOWAIT) {
1829                 usbctlx_wrid_completor_t completor;
1830                 hfa384x_cmdresult_t wridresult;
1831
1832                 result = hfa384x_usbctlx_complete_sync(
1833                                hw,
1834                                ctlx,
1835                                init_wrid_completor(&completor,
1836                                                    &ctlx->inbuf.wridresp,
1837                                                    &wridresult) );
1838         }
1839
1840 done:
1841         DBFEXIT;
1842         return result;
1843 }
1844
1845 /*----------------------------------------------------------------
1846 * hfa384x_dormem
1847 *
1848 * Constructs a readmem CTLX and issues it.
1849 *
1850 * NOTE: Any changes to the 'post-submit' code in this function
1851 *       need to be carried over to hfa384x_cbrmem() since the handling
1852 *       is virtually identical.
1853 *
1854 * Arguments:
1855 *       hw              device structure
1856 *       mode            DOWAIT or DOASYNC
1857 *       page            MAC address space page (CMD format)
1858 *       offset          MAC address space offset
1859 *       data            Ptr to data buffer to receive read
1860 *       len             Length of the data to read (max == 2048)
1861 *       cmdcb           command callback for async calls, NULL for DOWAIT calls
1862 *       usercb          user callback for async calls, NULL for DOWAIT calls
1863 *       usercb_data     user supplied data pointer for async calls
1864 *
1865 * Returns:
1866 *       0               success
1867 *       -ETIMEDOUT      timed out waiting for register ready or
1868 *                       command completion
1869 *       >0              command indicated error, Status and Resp0-2 are
1870 *                       in hw structure.
1871 *
1872 * Side effects:
1873 *
1874 * Call context:
1875 *       interrupt (DOASYNC)
1876 *       process (DOWAIT or DOASYNC)
1877 ----------------------------------------------------------------*/
1878 static int
1879 hfa384x_dormem(
1880         hfa384x_t *hw,
1881         CMD_MODE mode,
1882         u16     page,
1883         u16     offset,
1884         void    *data,
1885         unsigned int    len,
1886         ctlx_cmdcb_t cmdcb,
1887         ctlx_usercb_t usercb,
1888         void    *usercb_data)
1889 {
1890         int                     result;
1891         hfa384x_usbctlx_t       *ctlx;
1892
1893         DBFENTER;
1894         ctlx = usbctlx_alloc();
1895         if ( ctlx == NULL ) {
1896                 result = -ENOMEM;
1897                 goto done;
1898         }
1899
1900         /* Initialize the command */
1901         ctlx->outbuf.rmemreq.type =    host2hfa384x_16(HFA384x_USB_RMEMREQ);
1902         ctlx->outbuf.rmemreq.frmlen =  host2hfa384x_16(
1903                                         sizeof(ctlx->outbuf.rmemreq.offset) +
1904                                         sizeof(ctlx->outbuf.rmemreq.page) +
1905                                         len);
1906         ctlx->outbuf.rmemreq.offset =   host2hfa384x_16(offset);
1907         ctlx->outbuf.rmemreq.page =     host2hfa384x_16(page);
1908
1909         ctlx->outbufsize = sizeof(ctlx->outbuf.rmemreq);
1910
1911         WLAN_LOG_DEBUG(4,
1912                 "type=0x%04x frmlen=%d offset=0x%04x page=0x%04x\n",
1913                 ctlx->outbuf.rmemreq.type,
1914                 ctlx->outbuf.rmemreq.frmlen,
1915                 ctlx->outbuf.rmemreq.offset,
1916                 ctlx->outbuf.rmemreq.page);
1917
1918         WLAN_LOG_DEBUG(4,"pktsize=%zd\n",
1919                 ROUNDUP64(sizeof(ctlx->outbuf.rmemreq)));
1920
1921         ctlx->reapable = mode;
1922         ctlx->cmdcb = cmdcb;
1923         ctlx->usercb = usercb;
1924         ctlx->usercb_data = usercb_data;
1925
1926         result = hfa384x_usbctlx_submit(hw, ctlx);
1927         if (result != 0) {
1928                 kfree(ctlx);
1929         } else if ( mode == DOWAIT ) {
1930                 usbctlx_rmem_completor_t completor;
1931
1932                 result = hfa384x_usbctlx_complete_sync(
1933                            hw, ctlx, init_rmem_completor(&completor,
1934                                                          &ctlx->inbuf.rmemresp,
1935                                                          data,
1936                                                          len) );
1937         }
1938
1939 done:
1940         DBFEXIT;
1941         return result;
1942 }
1943
1944
1945
1946 /*----------------------------------------------------------------
1947 * hfa384x_dowmem
1948 *
1949 * Constructs a writemem CTLX and issues it.
1950 *
1951 * NOTE: Any changes to the 'post-submit' code in this function
1952 *       need to be carried over to hfa384x_cbwmem() since the handling
1953 *       is virtually identical.
1954 *
1955 * Arguments:
1956 *       hw              device structure
1957 *       mode            DOWAIT or DOASYNC
1958 *       page            MAC address space page (CMD format)
1959 *       offset          MAC address space offset
1960 *       data            Ptr to data buffer containing write data
1961 *       len             Length of the data to read (max == 2048)
1962 *       cmdcb           command callback for async calls, NULL for DOWAIT calls
1963 *       usercb          user callback for async calls, NULL for DOWAIT calls
1964 *       usercb_data     user supplied data pointer for async calls.
1965 *
1966 * Returns:
1967 *       0               success
1968 *       -ETIMEDOUT      timed out waiting for register ready or
1969 *                       command completion
1970 *       >0              command indicated error, Status and Resp0-2 are
1971 *                       in hw structure.
1972 *
1973 * Side effects:
1974 *
1975 * Call context:
1976 *       interrupt (DOWAIT)
1977 *       process (DOWAIT or DOASYNC)
1978 ----------------------------------------------------------------*/
1979 static int
1980 hfa384x_dowmem(
1981         hfa384x_t *hw,
1982         CMD_MODE mode,
1983         u16     page,
1984         u16     offset,
1985         void    *data,
1986         unsigned int    len,
1987         ctlx_cmdcb_t cmdcb,
1988         ctlx_usercb_t usercb,
1989         void    *usercb_data)
1990 {
1991         int                     result;
1992         hfa384x_usbctlx_t       *ctlx;
1993
1994         DBFENTER;
1995         WLAN_LOG_DEBUG(5, "page=0x%04x offset=0x%04x len=%d\n",
1996                 page,offset,len);
1997
1998         ctlx = usbctlx_alloc();
1999         if ( ctlx == NULL ) {
2000                 result = -ENOMEM;
2001                 goto done;
2002         }
2003
2004         /* Initialize the command */
2005         ctlx->outbuf.wmemreq.type =   host2hfa384x_16(HFA384x_USB_WMEMREQ);
2006         ctlx->outbuf.wmemreq.frmlen = host2hfa384x_16(
2007                                         sizeof(ctlx->outbuf.wmemreq.offset) +
2008                                         sizeof(ctlx->outbuf.wmemreq.page) +
2009                                         len);
2010         ctlx->outbuf.wmemreq.offset = host2hfa384x_16(offset);
2011         ctlx->outbuf.wmemreq.page =   host2hfa384x_16(page);
2012         memcpy(ctlx->outbuf.wmemreq.data, data, len);
2013
2014         ctlx->outbufsize = sizeof(ctlx->outbuf.wmemreq.type) +
2015                            sizeof(ctlx->outbuf.wmemreq.frmlen) +
2016                            sizeof(ctlx->outbuf.wmemreq.offset) +
2017                            sizeof(ctlx->outbuf.wmemreq.page) +
2018                            len;
2019
2020         ctlx->reapable = mode;
2021         ctlx->cmdcb = cmdcb;
2022         ctlx->usercb = usercb;
2023         ctlx->usercb_data = usercb_data;
2024
2025         result = hfa384x_usbctlx_submit(hw, ctlx);
2026         if (result != 0) {
2027                 kfree(ctlx);
2028         } else if ( mode == DOWAIT ) {
2029                 usbctlx_wmem_completor_t completor;
2030                 hfa384x_cmdresult_t wmemresult;
2031
2032                 result = hfa384x_usbctlx_complete_sync(
2033                                hw,
2034                                ctlx,
2035                                init_wmem_completor(&completor,
2036                                                    &ctlx->inbuf.wmemresp,
2037                                                    &wmemresult) );
2038         }
2039
2040 done:
2041         DBFEXIT;
2042         return result;
2043 }
2044
2045
2046 /*----------------------------------------------------------------
2047 * hfa384x_drvr_commtallies
2048 *
2049 * Send a commtallies inquiry to the MAC.  Note that this is an async
2050 * call that will result in an info frame arriving sometime later.
2051 *
2052 * Arguments:
2053 *       hw              device structure
2054 *
2055 * Returns:
2056 *       zero            success.
2057 *
2058 * Side effects:
2059 *
2060 * Call context:
2061 *       process
2062 ----------------------------------------------------------------*/
2063 int hfa384x_drvr_commtallies( hfa384x_t *hw )
2064 {
2065         hfa384x_metacmd_t cmd;
2066
2067         DBFENTER;
2068
2069         cmd.cmd = HFA384x_CMDCODE_INQ;
2070         cmd.parm0 = HFA384x_IT_COMMTALLIES;
2071         cmd.parm1 = 0;
2072         cmd.parm2 = 0;
2073
2074         hfa384x_docmd_async(hw, &cmd, NULL, NULL, NULL);
2075
2076         DBFEXIT;
2077         return 0;
2078 }
2079
2080
2081 /*----------------------------------------------------------------
2082 * hfa384x_drvr_disable
2083 *
2084 * Issues the disable command to stop communications on one of
2085 * the MACs 'ports'.  Only macport 0 is valid  for stations.
2086 * APs may also disable macports 1-6.  Only ports that have been
2087 * previously enabled may be disabled.
2088 *
2089 * Arguments:
2090 *       hw              device structure
2091 *       macport         MAC port number (host order)
2092 *
2093 * Returns:
2094 *       0               success
2095 *       >0              f/w reported failure - f/w status code
2096 *       <0              driver reported error (timeout|bad arg)
2097 *
2098 * Side effects:
2099 *
2100 * Call context:
2101 *       process
2102 ----------------------------------------------------------------*/
2103 int hfa384x_drvr_disable(hfa384x_t *hw, u16 macport)
2104 {
2105         int     result = 0;
2106
2107         DBFENTER;
2108         if ((!hw->isap && macport != 0) ||
2109             (hw->isap && !(macport <= HFA384x_PORTID_MAX)) ||
2110             !(hw->port_enabled[macport]) ){
2111                 result = -EINVAL;
2112         } else {
2113                 result = hfa384x_cmd_disable(hw, macport);
2114                 if ( result == 0 ) {
2115                         hw->port_enabled[macport] = 0;
2116                 }
2117         }
2118         DBFEXIT;
2119         return result;
2120 }
2121
2122
2123 /*----------------------------------------------------------------
2124 * hfa384x_drvr_enable
2125 *
2126 * Issues the enable command to enable communications on one of
2127 * the MACs 'ports'.  Only macport 0 is valid  for stations.
2128 * APs may also enable macports 1-6.  Only ports that are currently
2129 * disabled may be enabled.
2130 *
2131 * Arguments:
2132 *       hw              device structure
2133 *       macport         MAC port number
2134 *
2135 * Returns:
2136 *       0               success
2137 *       >0              f/w reported failure - f/w status code
2138 *       <0              driver reported error (timeout|bad arg)
2139 *
2140 * Side effects:
2141 *
2142 * Call context:
2143 *       process
2144 ----------------------------------------------------------------*/
2145 int hfa384x_drvr_enable(hfa384x_t *hw, u16 macport)
2146 {
2147         int     result = 0;
2148
2149         DBFENTER;
2150         if ((!hw->isap && macport != 0) ||
2151             (hw->isap && !(macport <= HFA384x_PORTID_MAX)) ||
2152             (hw->port_enabled[macport]) ){
2153                 result = -EINVAL;
2154         } else {
2155                 result = hfa384x_cmd_enable(hw, macport);
2156                 if ( result == 0 ) {
2157                         hw->port_enabled[macport] = 1;
2158                 }
2159         }
2160         DBFEXIT;
2161         return result;
2162 }
2163
2164
2165 /*----------------------------------------------------------------
2166 * hfa384x_drvr_flashdl_enable
2167 *
2168 * Begins the flash download state.  Checks to see that we're not
2169 * already in a download state and that a port isn't enabled.
2170 * Sets the download state and retrieves the flash download
2171 * buffer location, buffer size, and timeout length.
2172 *
2173 * Arguments:
2174 *       hw              device structure
2175 *
2176 * Returns:
2177 *       0               success
2178 *       >0              f/w reported error - f/w status code
2179 *       <0              driver reported error
2180 *
2181 * Side effects:
2182 *
2183 * Call context:
2184 *       process
2185 ----------------------------------------------------------------*/
2186 int hfa384x_drvr_flashdl_enable(hfa384x_t *hw)
2187 {
2188         int             result = 0;
2189         int             i;
2190
2191         DBFENTER;
2192         /* Check that a port isn't active */
2193         for ( i = 0; i < HFA384x_PORTID_MAX; i++) {
2194                 if ( hw->port_enabled[i] ) {
2195                         WLAN_LOG_DEBUG(1,"called when port enabled.\n");
2196                         return -EINVAL;
2197                 }
2198         }
2199
2200         /* Check that we're not already in a download state */
2201         if ( hw->dlstate != HFA384x_DLSTATE_DISABLED ) {
2202                 return -EINVAL;
2203         }
2204
2205         /* Retrieve the buffer loc&size and timeout */
2206         if ( (result = hfa384x_drvr_getconfig(hw, HFA384x_RID_DOWNLOADBUFFER,
2207                                 &(hw->bufinfo), sizeof(hw->bufinfo))) ) {
2208                 return result;
2209         }
2210         hw->bufinfo.page = hfa384x2host_16(hw->bufinfo.page);
2211         hw->bufinfo.offset = hfa384x2host_16(hw->bufinfo.offset);
2212         hw->bufinfo.len = hfa384x2host_16(hw->bufinfo.len);
2213         if ( (result = hfa384x_drvr_getconfig16(hw, HFA384x_RID_MAXLOADTIME,
2214                                 &(hw->dltimeout))) ) {
2215                 return result;
2216         }
2217         hw->dltimeout = hfa384x2host_16(hw->dltimeout);
2218
2219         WLAN_LOG_DEBUG(1,"flashdl_enable\n");
2220
2221         hw->dlstate = HFA384x_DLSTATE_FLASHENABLED;
2222         DBFEXIT;
2223         return result;
2224 }
2225
2226
2227 /*----------------------------------------------------------------
2228 * hfa384x_drvr_flashdl_disable
2229 *
2230 * Ends the flash download state.  Note that this will cause the MAC
2231 * firmware to restart.
2232 *
2233 * Arguments:
2234 *       hw              device structure
2235 *
2236 * Returns:
2237 *       0               success
2238 *       >0              f/w reported error - f/w status code
2239 *       <0              driver reported error
2240 *
2241 * Side effects:
2242 *
2243 * Call context:
2244 *       process
2245 ----------------------------------------------------------------*/
2246 int hfa384x_drvr_flashdl_disable(hfa384x_t *hw)
2247 {
2248         DBFENTER;
2249         /* Check that we're already in the download state */
2250         if ( hw->dlstate != HFA384x_DLSTATE_FLASHENABLED ) {
2251                 return -EINVAL;
2252         }
2253
2254         WLAN_LOG_DEBUG(1,"flashdl_enable\n");
2255
2256         /* There isn't much we can do at this point, so I don't */
2257         /*  bother  w/ the return value */
2258         hfa384x_cmd_download(hw, HFA384x_PROGMODE_DISABLE, 0, 0 , 0);
2259         hw->dlstate = HFA384x_DLSTATE_DISABLED;
2260
2261         DBFEXIT;
2262         return 0;
2263 }
2264
2265
2266 /*----------------------------------------------------------------
2267 * hfa384x_drvr_flashdl_write
2268 *
2269 * Performs a FLASH download of a chunk of data. First checks to see
2270 * that we're in the FLASH download state, then sets the download
2271 * mode, uses the aux functions to 1) copy the data to the flash
2272 * buffer, 2) sets the download 'write flash' mode, 3) readback and
2273 * compare.  Lather rinse, repeat as many times an necessary to get
2274 * all the given data into flash.
2275 * When all data has been written using this function (possibly
2276 * repeatedly), call drvr_flashdl_disable() to end the download state
2277 * and restart the MAC.
2278 *
2279 * Arguments:
2280 *       hw              device structure
2281 *       daddr           Card address to write to. (host order)
2282 *       buf             Ptr to data to write.
2283 *       len             Length of data (host order).
2284 *
2285 * Returns:
2286 *       0               success
2287 *       >0              f/w reported error - f/w status code
2288 *       <0              driver reported error
2289 *
2290 * Side effects:
2291 *
2292 * Call context:
2293 *       process
2294 ----------------------------------------------------------------*/
2295 int
2296 hfa384x_drvr_flashdl_write(
2297         hfa384x_t       *hw,
2298         u32             daddr,
2299         void            *buf,
2300         u32             len)
2301 {
2302         int             result = 0;
2303         u32             dlbufaddr;
2304         int             nburns;
2305         u32             burnlen;
2306         u32             burndaddr;
2307         u16             burnlo;
2308         u16             burnhi;
2309         int             nwrites;
2310         u8              *writebuf;
2311         u16             writepage;
2312         u16             writeoffset;
2313         u32             writelen;
2314         int             i;
2315         int             j;
2316
2317         DBFENTER;
2318         WLAN_LOG_DEBUG(5,"daddr=0x%08x len=%d\n", daddr, len);
2319
2320         /* Check that we're in the flash download state */
2321         if ( hw->dlstate != HFA384x_DLSTATE_FLASHENABLED ) {
2322                 return -EINVAL;
2323         }
2324
2325         WLAN_LOG_INFO("Download %d bytes to flash @0x%06x\n", len, daddr);
2326
2327         /* Convert to flat address for arithmetic */
2328         /* NOTE: dlbuffer RID stores the address in AUX format */
2329         dlbufaddr = HFA384x_ADDR_AUX_MKFLAT(
2330                         hw->bufinfo.page, hw->bufinfo.offset);
2331         WLAN_LOG_DEBUG(5,
2332                 "dlbuf.page=0x%04x dlbuf.offset=0x%04x dlbufaddr=0x%08x\n",
2333                 hw->bufinfo.page, hw->bufinfo.offset, dlbufaddr);
2334
2335 #if 0
2336 WLAN_LOG_WARNING("dlbuf@0x%06lx len=%d to=%d\n", dlbufaddr, hw->bufinfo.len, hw->dltimeout);
2337 #endif
2338         /* Calculations to determine how many fills of the dlbuffer to do
2339          * and how many USB wmemreq's to do for each fill.  At this point
2340          * in time, the dlbuffer size and the wmemreq size are the same.
2341          * Therefore, nwrites should always be 1.  The extra complexity
2342          * here is a hedge against future changes.
2343          */
2344
2345         /* Figure out how many times to do the flash programming */
2346         nburns = len / hw->bufinfo.len;
2347         nburns += (len % hw->bufinfo.len) ? 1 : 0;
2348
2349         /* For each flash program cycle, how many USB wmemreq's are needed? */
2350         nwrites = hw->bufinfo.len / HFA384x_USB_RWMEM_MAXLEN;
2351         nwrites += (hw->bufinfo.len % HFA384x_USB_RWMEM_MAXLEN) ? 1 : 0;
2352
2353         /* For each burn */
2354         for ( i = 0; i < nburns; i++) {
2355                 /* Get the dest address and len */
2356                 burnlen = (len - (hw->bufinfo.len * i)) > hw->bufinfo.len ?
2357                                 hw->bufinfo.len :
2358                                 (len - (hw->bufinfo.len * i));
2359                 burndaddr = daddr + (hw->bufinfo.len * i);
2360                 burnlo = HFA384x_ADDR_CMD_MKOFF(burndaddr);
2361                 burnhi = HFA384x_ADDR_CMD_MKPAGE(burndaddr);
2362
2363                 WLAN_LOG_INFO("Writing %d bytes to flash @0x%06x\n",
2364                         burnlen, burndaddr);
2365
2366                 /* Set the download mode */
2367                 result = hfa384x_cmd_download(hw, HFA384x_PROGMODE_NV,
2368                                 burnlo, burnhi, burnlen);
2369                 if ( result ) {
2370                         WLAN_LOG_ERROR("download(NV,lo=%x,hi=%x,len=%x) "
2371                                 "cmd failed, result=%d. Aborting d/l\n",
2372                                 burnlo, burnhi, burnlen, result);
2373                         goto exit_proc;
2374                 }
2375
2376                 /* copy the data to the flash download buffer */
2377                 for ( j=0; j < nwrites; j++) {
2378                         writebuf = buf +
2379                                 (i*hw->bufinfo.len) +
2380                                 (j*HFA384x_USB_RWMEM_MAXLEN);
2381
2382                         writepage = HFA384x_ADDR_CMD_MKPAGE(
2383                                         dlbufaddr +
2384                                         (j*HFA384x_USB_RWMEM_MAXLEN));
2385                         writeoffset = HFA384x_ADDR_CMD_MKOFF(
2386                                         dlbufaddr +
2387                                         (j*HFA384x_USB_RWMEM_MAXLEN));
2388
2389                         writelen = burnlen-(j*HFA384x_USB_RWMEM_MAXLEN);
2390                         writelen = writelen  > HFA384x_USB_RWMEM_MAXLEN ?
2391                                         HFA384x_USB_RWMEM_MAXLEN :
2392                                         writelen;
2393
2394                         result = hfa384x_dowmem_wait( hw,
2395                                         writepage,
2396                                         writeoffset,
2397                                         writebuf,
2398                                         writelen );
2399 #if 0
2400
2401 Comment out for debugging, assume the write was successful.
2402                         if (result) {
2403                                 WLAN_LOG_ERROR(
2404                                         "Write to dl buffer failed, "
2405                                         "result=0x%04x. Aborting.\n",
2406                                         result);
2407                                 goto exit_proc;
2408                         }
2409 #endif
2410
2411                 }
2412
2413                 /* set the download 'write flash' mode */
2414                 result = hfa384x_cmd_download(hw,
2415                                 HFA384x_PROGMODE_NVWRITE,
2416                                 0,0,0);
2417                 if ( result ) {
2418                         WLAN_LOG_ERROR(
2419                                 "download(NVWRITE,lo=%x,hi=%x,len=%x) "
2420                                 "cmd failed, result=%d. Aborting d/l\n",
2421                                 burnlo, burnhi, burnlen, result);
2422                         goto exit_proc;
2423                 }
2424
2425                 /* TODO: We really should do a readback and compare. */
2426         }
2427
2428 exit_proc:
2429
2430         /* Leave the firmware in the 'post-prog' mode.  flashdl_disable will */
2431         /*  actually disable programming mode.  Remember, that will cause the */
2432         /*  the firmware to effectively reset itself. */
2433
2434         DBFEXIT;
2435         return result;
2436 }
2437
2438
2439 /*----------------------------------------------------------------
2440 * hfa384x_drvr_getconfig
2441 *
2442 * Performs the sequence necessary to read a config/info item.
2443 *
2444 * Arguments:
2445 *       hw              device structure
2446 *       rid             config/info record id (host order)
2447 *       buf             host side record buffer.  Upon return it will
2448 *                       contain the body portion of the record (minus the
2449 *                       RID and len).
2450 *       len             buffer length (in bytes, should match record length)
2451 *
2452 * Returns:
2453 *       0               success
2454 *       >0              f/w reported error - f/w status code
2455 *       <0              driver reported error
2456 *       -ENODATA        length mismatch between argument and retrieved
2457 *                       record.
2458 *
2459 * Side effects:
2460 *
2461 * Call context:
2462 *       process
2463 ----------------------------------------------------------------*/
2464 int hfa384x_drvr_getconfig(hfa384x_t *hw, u16 rid, void *buf, u16 len)
2465 {
2466         int                     result;
2467         DBFENTER;
2468
2469         result = hfa384x_dorrid_wait(hw, rid, buf, len);
2470
2471         DBFEXIT;
2472         return result;
2473 }
2474
2475 /*----------------------------------------------------------------
2476  * hfa384x_drvr_getconfig_async
2477  *
2478  * Performs the sequence necessary to perform an async read of
2479  * of a config/info item.
2480  *
2481  * Arguments:
2482  *       hw              device structure
2483  *       rid             config/info record id (host order)
2484  *       buf             host side record buffer.  Upon return it will
2485  *                       contain the body portion of the record (minus the
2486  *                       RID and len).
2487  *       len             buffer length (in bytes, should match record length)
2488  *       cbfn            caller supplied callback, called when the command
2489  *                       is done (successful or not).
2490  *       cbfndata        pointer to some caller supplied data that will be
2491  *                       passed in as an argument to the cbfn.
2492  *
2493  * Returns:
2494  *       nothing         the cbfn gets a status argument identifying if
2495  *                       any errors occur.
2496  * Side effects:
2497  *       Queues an hfa384x_usbcmd_t for subsequent execution.
2498  *
2499  * Call context:
2500  *       Any
2501  ----------------------------------------------------------------*/
2502 int
2503 hfa384x_drvr_getconfig_async(
2504          hfa384x_t               *hw,
2505          u16                  rid,
2506          ctlx_usercb_t           usercb,
2507          void                    *usercb_data)
2508 {
2509          return hfa384x_dorrid_async(hw, rid, NULL, 0,
2510                                      hfa384x_cb_rrid, usercb, usercb_data);
2511 }
2512
2513 /*----------------------------------------------------------------
2514  * hfa384x_drvr_setconfig_async
2515  *
2516  * Performs the sequence necessary to write a config/info item.
2517  *
2518  * Arguments:
2519  *       hw              device structure
2520  *       rid             config/info record id (in host order)
2521  *       buf             host side record buffer
2522  *       len             buffer length (in bytes)
2523  *       usercb          completion callback
2524  *       usercb_data     completion callback argument
2525  *
2526  * Returns:
2527  *       0               success
2528  *       >0              f/w reported error - f/w status code
2529  *       <0              driver reported error
2530  *
2531  * Side effects:
2532  *
2533  * Call context:
2534  *       process
2535  ----------------------------------------------------------------*/
2536 int
2537 hfa384x_drvr_setconfig_async(
2538          hfa384x_t       *hw,
2539          u16          rid,
2540          void            *buf,
2541          u16          len,
2542          ctlx_usercb_t   usercb,
2543          void            *usercb_data)
2544 {
2545         return hfa384x_dowrid_async(hw, rid, buf, len,
2546                                     hfa384x_cb_status, usercb, usercb_data);
2547 }
2548
2549 /*----------------------------------------------------------------
2550 * hfa384x_drvr_handover
2551 *
2552 * Sends a handover notification to the MAC.
2553 *
2554 * Arguments:
2555 *       hw              device structure
2556 *       addr            address of station that's left
2557 *
2558 * Returns:
2559 *       zero            success.
2560 *       -ERESTARTSYS    received signal while waiting for semaphore.
2561 *       -EIO            failed to write to bap, or failed in cmd.
2562 *
2563 * Side effects:
2564 *
2565 * Call context:
2566 *       process
2567 ----------------------------------------------------------------*/
2568 int hfa384x_drvr_handover( hfa384x_t *hw, u8 *addr)
2569 {
2570         DBFENTER;
2571         WLAN_LOG_ERROR("Not currently supported in USB!\n");
2572         DBFEXIT;
2573         return -EIO;
2574 }
2575
2576 /*----------------------------------------------------------------
2577 * hfa384x_drvr_low_level
2578 *
2579 * Write test commands to the card.  Some test commands don't make
2580 * sense without prior set-up.  For example, continous TX isn't very
2581 * useful until you set the channel.  That functionality should be
2582 *
2583 * Side effects:
2584 *
2585 * Call context:
2586 *      process thread
2587 * -----------------------------------------------------------------*/
2588 int hfa384x_drvr_low_level(hfa384x_t *hw, hfa384x_metacmd_t *cmd)
2589 {
2590         int             result;
2591         DBFENTER;
2592
2593         /* Do i need a host2hfa... conversion ? */
2594
2595         result = hfa384x_docmd_wait(hw, cmd);
2596
2597         DBFEXIT;
2598         return result;
2599 }
2600
2601 /*----------------------------------------------------------------
2602 * hfa384x_drvr_ramdl_disable
2603 *
2604 * Ends the ram download state.
2605 *
2606 * Arguments:
2607 *       hw              device structure
2608 *
2609 * Returns:
2610 *       0               success
2611 *       >0              f/w reported error - f/w status code
2612 *       <0              driver reported error
2613 *
2614 * Side effects:
2615 *
2616 * Call context:
2617 *       process
2618 ----------------------------------------------------------------*/
2619 int
2620 hfa384x_drvr_ramdl_disable(hfa384x_t *hw)
2621 {
2622         DBFENTER;
2623         /* Check that we're already in the download state */
2624         if ( hw->dlstate != HFA384x_DLSTATE_RAMENABLED ) {
2625                 return -EINVAL;
2626         }
2627
2628         WLAN_LOG_DEBUG(3,"ramdl_disable()\n");
2629
2630         /* There isn't much we can do at this point, so I don't */
2631         /*  bother  w/ the return value */
2632         hfa384x_cmd_download(hw, HFA384x_PROGMODE_DISABLE, 0, 0 , 0);
2633         hw->dlstate = HFA384x_DLSTATE_DISABLED;
2634
2635         DBFEXIT;
2636         return 0;
2637 }
2638
2639
2640 /*----------------------------------------------------------------
2641 * hfa384x_drvr_ramdl_enable
2642 *
2643 * Begins the ram download state.  Checks to see that we're not
2644 * already in a download state and that a port isn't enabled.
2645 * Sets the download state and calls cmd_download with the
2646 * ENABLE_VOLATILE subcommand and the exeaddr argument.
2647 *
2648 * Arguments:
2649 *       hw              device structure
2650 *       exeaddr         the card execution address that will be
2651 *                       jumped to when ramdl_disable() is called
2652 *                       (host order).
2653 *
2654 * Returns:
2655 *       0               success
2656 *       >0              f/w reported error - f/w status code
2657 *       <0              driver reported error
2658 *
2659 * Side effects:
2660 *
2661 * Call context:
2662 *       process
2663 ----------------------------------------------------------------*/
2664 int
2665 hfa384x_drvr_ramdl_enable(hfa384x_t *hw, u32 exeaddr)
2666 {
2667         int             result = 0;
2668         u16             lowaddr;
2669         u16             hiaddr;
2670         int             i;
2671         DBFENTER;
2672         /* Check that a port isn't active */
2673         for ( i = 0; i < HFA384x_PORTID_MAX; i++) {
2674                 if ( hw->port_enabled[i] ) {
2675                         WLAN_LOG_ERROR(
2676                                 "Can't download with a macport enabled.\n");
2677                         return -EINVAL;
2678                 }
2679         }
2680
2681         /* Check that we're not already in a download state */
2682         if ( hw->dlstate != HFA384x_DLSTATE_DISABLED ) {
2683                 WLAN_LOG_ERROR(
2684                         "Download state not disabled.\n");
2685                 return -EINVAL;
2686         }
2687
2688         WLAN_LOG_DEBUG(3,"ramdl_enable, exeaddr=0x%08x\n", exeaddr);
2689
2690         /* Call the download(1,addr) function */
2691         lowaddr = HFA384x_ADDR_CMD_MKOFF(exeaddr);
2692         hiaddr =  HFA384x_ADDR_CMD_MKPAGE(exeaddr);
2693
2694         result = hfa384x_cmd_download(hw, HFA384x_PROGMODE_RAM,
2695                         lowaddr, hiaddr, 0);
2696
2697         if ( result == 0) {
2698                 /* Set the download state */
2699                 hw->dlstate = HFA384x_DLSTATE_RAMENABLED;
2700         } else {
2701                 WLAN_LOG_DEBUG(1,
2702                         "cmd_download(0x%04x, 0x%04x) failed, result=%d.\n",
2703                         lowaddr,
2704                         hiaddr,
2705                         result);
2706         }
2707
2708         DBFEXIT;
2709         return result;
2710 }
2711
2712
2713 /*----------------------------------------------------------------
2714 * hfa384x_drvr_ramdl_write
2715 *
2716 * Performs a RAM download of a chunk of data. First checks to see
2717 * that we're in the RAM download state, then uses the [read|write]mem USB
2718 * commands to 1) copy the data, 2) readback and compare.  The download
2719 * state is unaffected.  When all data has been written using
2720 * this function, call drvr_ramdl_disable() to end the download state
2721 * and restart the MAC.
2722 *
2723 * Arguments:
2724 *       hw              device structure
2725 *       daddr           Card address to write to. (host order)
2726 *       buf             Ptr to data to write.
2727 *       len             Length of data (host order).
2728 *
2729 * Returns:
2730 *       0               success
2731 *       >0              f/w reported error - f/w status code
2732 *       <0              driver reported error
2733 *
2734 * Side effects:
2735 *
2736 * Call context:
2737 *       process
2738 ----------------------------------------------------------------*/
2739 int
2740 hfa384x_drvr_ramdl_write(hfa384x_t *hw, u32 daddr, void* buf, u32 len)
2741 {
2742         int             result = 0;
2743         int             nwrites;
2744         u8              *data = buf;
2745         int             i;
2746         u32             curraddr;
2747         u16             currpage;
2748         u16             curroffset;
2749         u16             currlen;
2750         DBFENTER;
2751         /* Check that we're in the ram download state */
2752         if ( hw->dlstate != HFA384x_DLSTATE_RAMENABLED ) {
2753                 return -EINVAL;
2754         }
2755
2756         WLAN_LOG_INFO("Writing %d bytes to ram @0x%06x\n", len, daddr);
2757
2758         /* How many dowmem calls?  */
2759         nwrites = len / HFA384x_USB_RWMEM_MAXLEN;
2760         nwrites += len % HFA384x_USB_RWMEM_MAXLEN ? 1 : 0;
2761
2762         /* Do blocking wmem's */
2763         for(i=0; i < nwrites; i++) {
2764                 /* make address args */
2765                 curraddr = daddr + (i * HFA384x_USB_RWMEM_MAXLEN);
2766                 currpage = HFA384x_ADDR_CMD_MKPAGE(curraddr);
2767                 curroffset = HFA384x_ADDR_CMD_MKOFF(curraddr);
2768                 currlen = len - (i * HFA384x_USB_RWMEM_MAXLEN);
2769                 if ( currlen > HFA384x_USB_RWMEM_MAXLEN) {
2770                         currlen = HFA384x_USB_RWMEM_MAXLEN;
2771                 }
2772
2773                 /* Do blocking ctlx */
2774                 result = hfa384x_dowmem_wait( hw,
2775                                 currpage,
2776                                 curroffset,
2777                                 data + (i*HFA384x_USB_RWMEM_MAXLEN),
2778                                 currlen );
2779
2780                 if (result) break;
2781
2782                 /* TODO: We really should have a readback. */
2783         }
2784
2785         DBFEXIT;
2786         return result;
2787 }
2788
2789
2790 /*----------------------------------------------------------------
2791 * hfa384x_drvr_readpda
2792 *
2793 * Performs the sequence to read the PDA space.  Note there is no
2794 * drvr_writepda() function.  Writing a PDA is
2795 * generally implemented by a calling component via calls to
2796 * cmd_download and writing to the flash download buffer via the
2797 * aux regs.
2798 *
2799 * Arguments:
2800 *       hw              device structure
2801 *       buf             buffer to store PDA in
2802 *       len             buffer length
2803 *
2804 * Returns:
2805 *       0               success
2806 *       >0              f/w reported error - f/w status code
2807 *       <0              driver reported error
2808 *       -ETIMEOUT       timout waiting for the cmd regs to become
2809 *                       available, or waiting for the control reg
2810 *                       to indicate the Aux port is enabled.
2811 *       -ENODATA        the buffer does NOT contain a valid PDA.
2812 *                       Either the card PDA is bad, or the auxdata
2813 *                       reads are giving us garbage.
2814
2815 *
2816 * Side effects:
2817 *
2818 * Call context:
2819 *       process or non-card interrupt.
2820 ----------------------------------------------------------------*/
2821 int hfa384x_drvr_readpda(hfa384x_t *hw, void *buf, unsigned int len)
2822 {
2823         int             result = 0;
2824         u16             *pda = buf;
2825         int             pdaok = 0;
2826         int             morepdrs = 1;
2827         int             currpdr = 0;    /* word offset of the current pdr */
2828         size_t          i;
2829         u16             pdrlen;         /* pdr length in bytes, host order */
2830         u16             pdrcode;        /* pdr code, host order */
2831         u16             currpage;
2832         u16             curroffset;
2833         struct pdaloc {
2834                 u32     cardaddr;
2835                 u16     auxctl;
2836         } pdaloc[] =
2837         {
2838                 { HFA3842_PDA_BASE,             0},
2839                 { HFA3841_PDA_BASE,             0},
2840                 { HFA3841_PDA_BOGUS_BASE,       0}
2841         };
2842
2843         DBFENTER;
2844
2845         /* Read the pda from each known address.  */
2846         for ( i = 0; i < ARRAY_SIZE(pdaloc); i++) {
2847                 /* Make address */
2848                 currpage = HFA384x_ADDR_CMD_MKPAGE(pdaloc[i].cardaddr);
2849                 curroffset = HFA384x_ADDR_CMD_MKOFF(pdaloc[i].cardaddr);
2850
2851                 result = hfa384x_dormem_wait(hw,
2852                         currpage,
2853                         curroffset,
2854                         buf,
2855                         len);           /* units of bytes */
2856
2857                 if (result) {
2858                         WLAN_LOG_WARNING(
2859                                           "Read from index %zd failed, continuing\n",
2860                                 i );
2861                         continue;
2862                 }
2863
2864                 /* Test for garbage */
2865                 pdaok = 1;      /* initially assume good */
2866                 morepdrs = 1;
2867                 while ( pdaok && morepdrs ) {
2868                         pdrlen = hfa384x2host_16(pda[currpdr]) * 2;
2869                         pdrcode = hfa384x2host_16(pda[currpdr+1]);
2870                         /* Test the record length */
2871                         if ( pdrlen > HFA384x_PDR_LEN_MAX || pdrlen == 0) {
2872                                 WLAN_LOG_ERROR("pdrlen invalid=%d\n",
2873                                         pdrlen);
2874                                 pdaok = 0;
2875                                 break;
2876                         }
2877                         /* Test the code */
2878                         if ( !hfa384x_isgood_pdrcode(pdrcode) ) {
2879                                 WLAN_LOG_ERROR("pdrcode invalid=%d\n",
2880                                         pdrcode);
2881                                 pdaok = 0;
2882                                 break;
2883                         }
2884                         /* Test for completion */
2885                         if ( pdrcode == HFA384x_PDR_END_OF_PDA) {
2886                                 morepdrs = 0;
2887                         }
2888
2889                         /* Move to the next pdr (if necessary) */
2890                         if ( morepdrs ) {
2891                                 /* note the access to pda[], need words here */
2892                                 currpdr += hfa384x2host_16(pda[currpdr]) + 1;
2893                         }
2894                 }
2895                 if ( pdaok ) {
2896                         WLAN_LOG_INFO(
2897                                 "PDA Read from 0x%08x in %s space.\n",
2898                                 pdaloc[i].cardaddr,
2899                                 pdaloc[i].auxctl == 0 ? "EXTDS" :
2900                                 pdaloc[i].auxctl == 1 ? "NV" :
2901                                 pdaloc[i].auxctl == 2 ? "PHY" :
2902                                 pdaloc[i].auxctl == 3 ? "ICSRAM" :
2903                                 "<bogus auxctl>");
2904                         break;
2905                 }
2906         }
2907         result = pdaok ? 0 : -ENODATA;
2908
2909         if ( result ) {
2910                 WLAN_LOG_DEBUG(3,"Failure: pda is not okay\n");
2911         }
2912
2913         DBFEXIT;
2914         return result;
2915 }
2916
2917
2918 /*----------------------------------------------------------------
2919 * hfa384x_drvr_setconfig
2920 *
2921 * Performs the sequence necessary to write a config/info item.
2922 *
2923 * Arguments:
2924 *       hw              device structure
2925 *       rid             config/info record id (in host order)
2926 *       buf             host side record buffer
2927 *       len             buffer length (in bytes)
2928 *
2929 * Returns:
2930 *       0               success
2931 *       >0              f/w reported error - f/w status code
2932 *       <0              driver reported error
2933 *
2934 * Side effects:
2935 *
2936 * Call context:
2937 *       process
2938 ----------------------------------------------------------------*/
2939 int hfa384x_drvr_setconfig(hfa384x_t *hw, u16 rid, void *buf, u16 len)
2940 {
2941         return hfa384x_dowrid_wait(hw, rid, buf, len);
2942 }
2943
2944 /*----------------------------------------------------------------
2945 * hfa384x_drvr_start
2946 *
2947 * Issues the MAC initialize command, sets up some data structures,
2948 * and enables the interrupts.  After this function completes, the
2949 * low-level stuff should be ready for any/all commands.
2950 *
2951 * Arguments:
2952 *       hw              device structure
2953 * Returns:
2954 *       0               success
2955 *       >0              f/w reported error - f/w status code
2956 *       <0              driver reported error
2957 *
2958 * Side effects:
2959 *
2960 * Call context:
2961 *       process
2962 ----------------------------------------------------------------*/
2963
2964 int hfa384x_drvr_start(hfa384x_t *hw)
2965 {
2966         int             result, result1, result2;
2967         u16             status;
2968         DBFENTER;
2969
2970         might_sleep();
2971
2972         /* Clear endpoint stalls - but only do this if the endpoint
2973          * is showing a stall status. Some prism2 cards seem to behave
2974          * badly if a clear_halt is called when the endpoint is already
2975          * ok
2976          */
2977         result = usb_get_status(hw->usb, USB_RECIP_ENDPOINT, hw->endp_in, &status);
2978         if (result < 0) {
2979                 WLAN_LOG_ERROR(
2980                         "Cannot get bulk in endpoint status.\n");
2981                 goto done;
2982         }
2983         if ((status == 1) && usb_clear_halt(hw->usb, hw->endp_in)) {
2984                 WLAN_LOG_ERROR(
2985                         "Failed to reset bulk in endpoint.\n");
2986         }
2987
2988         result = usb_get_status(hw->usb, USB_RECIP_ENDPOINT, hw->endp_out, &status);
2989         if (result < 0) {
2990                 WLAN_LOG_ERROR(
2991                         "Cannot get bulk out endpoint status.\n");
2992                 goto done;
2993         }
2994         if ((status == 1) && usb_clear_halt(hw->usb, hw->endp_out)) {
2995                 WLAN_LOG_ERROR(
2996                         "Failed to reset bulk out endpoint.\n");
2997         }
2998
2999         /* Synchronous unlink, in case we're trying to restart the driver */
3000         usb_kill_urb(&hw->rx_urb);
3001
3002         /* Post the IN urb */
3003         result = submit_rx_urb(hw, GFP_KERNEL);
3004         if (result != 0) {
3005                 WLAN_LOG_ERROR(
3006                         "Fatal, failed to submit RX URB, result=%d\n",
3007                         result);
3008                 goto done;
3009         }
3010
3011         /* Call initialize twice, with a 1 second sleep in between.
3012          * This is a nasty work-around since many prism2 cards seem to
3013          * need time to settle after an init from cold. The second
3014          * call to initialize in theory is not necessary - but we call
3015          * it anyway as a double insurance policy:
3016          * 1) If the first init should fail, the second may well succeed
3017          *    and the card can still be used
3018          * 2) It helps ensures all is well with the card after the first
3019          *    init and settle time.
3020          */
3021         result1 = hfa384x_cmd_initialize(hw);
3022         msleep(1000);
3023         result = result2 = hfa384x_cmd_initialize(hw);
3024         if (result1 != 0) {
3025                 if (result2 != 0) {
3026                         WLAN_LOG_ERROR(
3027                                 "cmd_initialize() failed on two attempts, results %d and %d\n",
3028                                 result1, result2);
3029                         usb_kill_urb(&hw->rx_urb);
3030                         goto done;
3031                 } else {
3032                         WLAN_LOG_DEBUG(0, "First cmd_initialize() failed (result %d),\n",
3033                                 result1);
3034                         WLAN_LOG_DEBUG(0, "but second attempt succeeded. All should be ok\n");
3035                 }
3036         } else if (result2 != 0) {
3037                 WLAN_LOG_WARNING(
3038                         "First cmd_initialize() succeeded, but second attempt failed (result=%d)\n",
3039                         result2);
3040                 WLAN_LOG_WARNING("Most likely the card will be functional\n");
3041                         goto done;
3042         }
3043
3044         hw->state = HFA384x_STATE_RUNNING;
3045
3046 done:
3047         DBFEXIT;
3048         return result;
3049 }
3050
3051
3052 /*----------------------------------------------------------------
3053 * hfa384x_drvr_stop
3054 *
3055 * Shuts down the MAC to the point where it is safe to unload the
3056 * driver.  Any subsystem that may be holding a data or function
3057 * ptr into the driver must be cleared/deinitialized.
3058 *
3059 * Arguments:
3060 *       hw              device structure
3061 * Returns:
3062 *       0               success
3063 *       >0              f/w reported error - f/w status code
3064 *       <0              driver reported error
3065 *
3066 * Side effects:
3067 *
3068 * Call context:
3069 *       process
3070 ----------------------------------------------------------------*/
3071 int
3072 hfa384x_drvr_stop(hfa384x_t *hw)
3073 {
3074         int     result = 0;
3075         int     i;
3076         DBFENTER;
3077
3078         might_sleep();
3079
3080         /* There's no need for spinlocks here. The USB "disconnect"
3081          * function sets this "removed" flag and then calls us.
3082          */
3083         if ( !hw->wlandev->hwremoved ) {
3084                 /* Call initialize to leave the MAC in its 'reset' state */
3085                 hfa384x_cmd_initialize(hw);
3086
3087                 /* Cancel the rxurb */
3088                 usb_kill_urb(&hw->rx_urb);
3089         }
3090
3091         hw->link_status = HFA384x_LINK_NOTCONNECTED;
3092         hw->state = HFA384x_STATE_INIT;
3093
3094         del_timer_sync(&hw->commsqual_timer);
3095
3096         /* Clear all the port status */
3097         for ( i = 0; i < HFA384x_NUMPORTS_MAX; i++) {
3098                 hw->port_enabled[i] = 0;
3099         }
3100
3101         DBFEXIT;
3102         return result;
3103 }
3104
3105 /*----------------------------------------------------------------
3106 * hfa384x_drvr_txframe
3107 *
3108 * Takes a frame from prism2sta and queues it for transmission.
3109 *
3110 * Arguments:
3111 *       hw              device structure
3112 *       skb             packet buffer struct.  Contains an 802.11
3113 *                       data frame.
3114 *       p80211_hdr      points to the 802.11 header for the packet.
3115 * Returns:
3116 *       0               Success and more buffs available
3117 *       1               Success but no more buffs
3118 *       2               Allocation failure
3119 *       4               Buffer full or queue busy
3120 *
3121 * Side effects:
3122 *
3123 * Call context:
3124 *       interrupt
3125 ----------------------------------------------------------------*/
3126 int hfa384x_drvr_txframe(hfa384x_t *hw, struct sk_buff *skb, p80211_hdr_t *p80211_hdr, p80211_metawep_t *p80211_wep)
3127
3128 {
3129         int             usbpktlen = sizeof(hfa384x_tx_frame_t);
3130         int             result;
3131         int             ret;
3132         char            *ptr;
3133
3134         DBFENTER;
3135
3136         if (hw->tx_urb.status == -EINPROGRESS) {
3137                 WLAN_LOG_WARNING("TX URB already in use\n");
3138                 result = 3;
3139                 goto exit;
3140         }
3141
3142         /* Build Tx frame structure */
3143         /* Set up the control field */
3144         memset(&hw->txbuff.txfrm.desc, 0, sizeof(hw->txbuff.txfrm.desc));
3145
3146         /* Setup the usb type field */
3147         hw->txbuff.type = host2hfa384x_16(HFA384x_USB_TXFRM);
3148
3149         /* Set up the sw_support field to identify this frame */
3150         hw->txbuff.txfrm.desc.sw_support = 0x0123;
3151
3152 /* Tx complete and Tx exception disable per dleach.  Might be causing
3153  * buf depletion
3154  */
3155 //#define DOEXC  SLP -- doboth breaks horribly under load, doexc less so.
3156 #if defined(DOBOTH)
3157         hw->txbuff.txfrm.desc.tx_control =
3158                 HFA384x_TX_MACPORT_SET(0) | HFA384x_TX_STRUCTYPE_SET(1) |
3159                 HFA384x_TX_TXEX_SET(1) | HFA384x_TX_TXOK_SET(1);
3160 #elif defined(DOEXC)
3161         hw->txbuff.txfrm.desc.tx_control =
3162                 HFA384x_TX_MACPORT_SET(0) | HFA384x_TX_STRUCTYPE_SET(1) |
3163                 HFA384x_TX_TXEX_SET(1) | HFA384x_TX_TXOK_SET(0);
3164 #else
3165         hw->txbuff.txfrm.desc.tx_control =
3166                 HFA384x_TX_MACPORT_SET(0) | HFA384x_TX_STRUCTYPE_SET(1) |
3167                 HFA384x_TX_TXEX_SET(0) | HFA384x_TX_TXOK_SET(0);
3168 #endif
3169         hw->txbuff.txfrm.desc.tx_control =
3170                 host2hfa384x_16(hw->txbuff.txfrm.desc.tx_control);
3171
3172         /* copy the header over to the txdesc */
3173         memcpy(&(hw->txbuff.txfrm.desc.frame_control), p80211_hdr, sizeof(p80211_hdr_t));
3174
3175         /* if we're using host WEP, increase size by IV+ICV */
3176         if (p80211_wep->data) {
3177                 hw->txbuff.txfrm.desc.data_len = host2hfa384x_16(skb->len+8);
3178                 // hw->txbuff.txfrm.desc.tx_control |= HFA384x_TX_NOENCRYPT_SET(1);
3179                 usbpktlen+=8;
3180         } else {
3181                 hw->txbuff.txfrm.desc.data_len = host2hfa384x_16(skb->len);
3182         }
3183
3184         usbpktlen += skb->len;
3185
3186         /* copy over the WEP IV if we are using host WEP */
3187         ptr = hw->txbuff.txfrm.data;
3188         if (p80211_wep->data) {
3189                 memcpy(ptr, p80211_wep->iv, sizeof(p80211_wep->iv));
3190                 ptr+= sizeof(p80211_wep->iv);
3191                 memcpy(ptr, p80211_wep->data, skb->len);
3192         } else {
3193                 memcpy(ptr, skb->data, skb->len);
3194         }
3195         /* copy over the packet data */
3196         ptr+= skb->len;
3197
3198         /* copy over the WEP ICV if we are using host WEP */
3199         if (p80211_wep->data) {
3200                 memcpy(ptr, p80211_wep->icv, sizeof(p80211_wep->icv));
3201         }
3202
3203         /* Send the USB packet */
3204         usb_fill_bulk_urb( &(hw->tx_urb), hw->usb,
3205                        hw->endp_out,
3206                        &(hw->txbuff), ROUNDUP64(usbpktlen),
3207                        hfa384x_usbout_callback, hw->wlandev );
3208         hw->tx_urb.transfer_flags |= USB_QUEUE_BULK;
3209
3210         result = 1;
3211         ret = submit_tx_urb(hw, &hw->tx_urb, GFP_ATOMIC);
3212         if ( ret != 0 ) {
3213                 WLAN_LOG_ERROR(
3214                         "submit_tx_urb() failed, error=%d\n", ret);
3215                 result = 3;
3216         }
3217
3218  exit:
3219         DBFEXIT;
3220         return result;
3221 }
3222
3223 void hfa384x_tx_timeout(wlandevice_t *wlandev)
3224 {
3225         hfa384x_t       *hw = wlandev->priv;
3226         unsigned long flags;
3227
3228         DBFENTER;
3229
3230         spin_lock_irqsave(&hw->ctlxq.lock, flags);
3231
3232         if ( !hw->wlandev->hwremoved &&
3233              /* Note the bitwise OR, not the logical OR. */
3234              ( !test_and_set_bit(WORK_TX_HALT, &hw->usb_flags) |
3235                !test_and_set_bit(WORK_RX_HALT, &hw->usb_flags) ) )
3236         {
3237                 schedule_work(&hw->usb_work);
3238         }
3239
3240         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
3241
3242         DBFEXIT;
3243 }
3244
3245 /*----------------------------------------------------------------
3246 * hfa384x_usbctlx_reaper_task
3247 *
3248 * Tasklet to delete dead CTLX objects
3249 *
3250 * Arguments:
3251 *       data    ptr to a hfa384x_t
3252 *
3253 * Returns:
3254 *
3255 * Call context:
3256 *       Interrupt
3257 ----------------------------------------------------------------*/
3258 static void hfa384x_usbctlx_reaper_task(unsigned long data)
3259 {
3260         hfa384x_t       *hw = (hfa384x_t*)data;
3261         struct list_head *entry;
3262         struct list_head *temp;
3263         unsigned long   flags;
3264
3265         DBFENTER;
3266
3267         spin_lock_irqsave(&hw->ctlxq.lock, flags);
3268
3269         /* This list is guaranteed to be empty if someone
3270          * has unplugged the adapter.
3271          */
3272         list_for_each_safe(entry, temp, &hw->ctlxq.reapable) {
3273                 hfa384x_usbctlx_t       *ctlx;
3274
3275                 ctlx = list_entry(entry, hfa384x_usbctlx_t, list);
3276                 list_del(&ctlx->list);
3277                 kfree(ctlx);
3278         }
3279
3280         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
3281
3282         DBFEXIT;
3283 }
3284
3285 /*----------------------------------------------------------------
3286 * hfa384x_usbctlx_completion_task
3287 *
3288 * Tasklet to call completion handlers for returned CTLXs
3289 *
3290 * Arguments:
3291 *       data    ptr to hfa384x_t
3292 *
3293 * Returns:
3294 *       Nothing
3295 *
3296 * Call context:
3297 *       Interrupt
3298 ----------------------------------------------------------------*/
3299 static void hfa384x_usbctlx_completion_task(unsigned long data)
3300 {
3301         hfa384x_t *hw = (hfa384x_t*)data;
3302         struct list_head *entry;
3303         struct list_head *temp;
3304         unsigned long flags;
3305
3306         int reap = 0;
3307
3308         DBFENTER;
3309
3310         spin_lock_irqsave(&hw->ctlxq.lock, flags);
3311
3312         /* This list is guaranteed to be empty if someone
3313          * has unplugged the adapter ...
3314          */
3315         list_for_each_safe(entry, temp, &hw->ctlxq.completing) {
3316                 hfa384x_usbctlx_t *ctlx;
3317
3318                 ctlx = list_entry(entry, hfa384x_usbctlx_t, list);
3319
3320                 /* Call the completion function that this
3321                  * command was assigned, assuming it has one.
3322                  */
3323                 if ( ctlx->cmdcb != NULL ) {
3324                         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
3325                         ctlx->cmdcb(hw, ctlx);
3326                         spin_lock_irqsave(&hw->ctlxq.lock, flags);
3327
3328                         /* Make sure we don't try and complete
3329                          * this CTLX more than once!
3330                          */
3331                         ctlx->cmdcb = NULL;
3332
3333                         /* Did someone yank the adapter out
3334                          * while our list was (briefly) unlocked?
3335                          */
3336                         if ( hw->wlandev->hwremoved )
3337                         {
3338                                 reap = 0;
3339                                 break;
3340                         }
3341                 }
3342
3343                 /*
3344                  * "Reapable" CTLXs are ones which don't have any
3345                  * threads waiting for them to die. Hence they must
3346                  * be delivered to The Reaper!
3347                  */
3348                 if ( ctlx->reapable ) {
3349                         /* Move the CTLX off the "completing" list (hopefully)
3350                          * on to the "reapable" list where the reaper task
3351                          * can find it. And "reapable" means that this CTLX
3352                          * isn't sitting on a wait-queue somewhere.
3353                          */
3354                         list_move_tail(&ctlx->list, &hw->ctlxq.reapable);
3355                         reap = 1;
3356                 }
3357
3358                 complete(&ctlx->done);
3359         }
3360         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
3361
3362         if (reap)
3363                 tasklet_schedule(&hw->reaper_bh);
3364
3365         DBFEXIT;
3366 }
3367
3368 /*----------------------------------------------------------------
3369 * unlocked_usbctlx_cancel_async
3370 *
3371 * Mark the CTLX dead asynchronously, and ensure that the
3372 * next command on the queue is run afterwards.
3373 *
3374 * Arguments:
3375 *       hw      ptr to the hfa384x_t structure
3376 *       ctlx    ptr to a CTLX structure
3377 *
3378 * Returns:
3379 *       0       the CTLX's URB is inactive
3380 * -EINPROGRESS  the URB is currently being unlinked
3381 *
3382 * Call context:
3383 *       Either process or interrupt, but presumably interrupt
3384 ----------------------------------------------------------------*/
3385 static int unlocked_usbctlx_cancel_async(hfa384x_t *hw, hfa384x_usbctlx_t *ctlx)
3386 {
3387         int ret;
3388
3389         DBFENTER;
3390
3391         /*
3392          * Try to delete the URB containing our request packet.
3393          * If we succeed, then its completion handler will be
3394          * called with a status of -ECONNRESET.
3395          */
3396         hw->ctlx_urb.transfer_flags |= URB_ASYNC_UNLINK;
3397         ret = usb_unlink_urb(&hw->ctlx_urb);
3398
3399         if (ret != -EINPROGRESS) {
3400                 /*
3401                  * The OUT URB had either already completed
3402                  * or was still in the pending queue, so the
3403                  * URB's completion function will not be called.
3404                  * We will have to complete the CTLX ourselves.
3405                  */
3406                 ctlx->state = CTLX_REQ_FAILED;
3407                 unlocked_usbctlx_complete(hw, ctlx);
3408                 ret = 0;
3409         }
3410
3411         DBFEXIT;
3412
3413         return ret;
3414 }
3415
3416 /*----------------------------------------------------------------
3417 * unlocked_usbctlx_complete
3418 *
3419 * A CTLX has completed.  It may have been successful, it may not
3420 * have been. At this point, the CTLX should be quiescent.  The URBs
3421 * aren't active and the timers should have been stopped.
3422 *
3423 * The CTLX is migrated to the "completing" queue, and the completing
3424 * tasklet is scheduled.
3425 *
3426 * Arguments:
3427 *       hw              ptr to a hfa384x_t structure
3428 *       ctlx            ptr to a ctlx structure
3429 *
3430 * Returns:
3431 *       nothing
3432 *
3433 * Side effects:
3434 *
3435 * Call context:
3436 *       Either, assume interrupt
3437 ----------------------------------------------------------------*/
3438 static void unlocked_usbctlx_complete(hfa384x_t *hw, hfa384x_usbctlx_t *ctlx)
3439 {
3440         DBFENTER;
3441
3442         /* Timers have been stopped, and ctlx should be in
3443          * a terminal state. Retire it from the "active"
3444          * queue.
3445          */
3446         list_move_tail(&ctlx->list, &hw->ctlxq.completing);
3447         tasklet_schedule(&hw->completion_bh);
3448
3449         switch (ctlx->state) {
3450         case CTLX_COMPLETE:
3451         case CTLX_REQ_FAILED:
3452                 /* This are the correct terminating states. */
3453                 break;
3454
3455         default:
3456                 WLAN_LOG_ERROR("CTLX[%d] not in a terminating state(%s)\n",
3457                                hfa384x2host_16(ctlx->outbuf.type),
3458                                ctlxstr(ctlx->state));
3459                 break;
3460         } /* switch */
3461
3462         DBFEXIT;
3463 }
3464
3465 /*----------------------------------------------------------------
3466 * hfa384x_usbctlxq_run
3467 *
3468 * Checks to see if the head item is running.  If not, starts it.
3469 *
3470 * Arguments:
3471 *       hw      ptr to hfa384x_t
3472 *
3473 * Returns:
3474 *       nothing
3475 *
3476 * Side effects:
3477 *
3478 * Call context:
3479 *       any
3480 ----------------------------------------------------------------*/
3481 static void
3482 hfa384x_usbctlxq_run(hfa384x_t  *hw)
3483 {
3484         unsigned long           flags;
3485         DBFENTER;
3486
3487         /* acquire lock */
3488         spin_lock_irqsave(&hw->ctlxq.lock, flags);
3489
3490         /* Only one active CTLX at any one time, because there's no
3491          * other (reliable) way to match the response URB to the
3492          * correct CTLX.
3493          *
3494          * Don't touch any of these CTLXs if the hardware
3495          * has been removed or the USB subsystem is stalled.
3496          */
3497         if ( !list_empty(&hw->ctlxq.active) ||
3498              test_bit(WORK_TX_HALT, &hw->usb_flags) ||
3499              hw->wlandev->hwremoved )
3500                 goto unlock;
3501
3502         while ( !list_empty(&hw->ctlxq.pending) ) {
3503                 hfa384x_usbctlx_t       *head;
3504                 int                     result;
3505
3506                 /* This is the first pending command */
3507                 head = list_entry(hw->ctlxq.pending.next,
3508                                   hfa384x_usbctlx_t,
3509                                   list);
3510
3511                 /* We need to split this off to avoid a race condition */
3512                 list_move_tail(&head->list, &hw->ctlxq.active);
3513
3514                 /* Fill the out packet */
3515                 usb_fill_bulk_urb( &(hw->ctlx_urb), hw->usb,
3516                                    hw->endp_out,
3517                                    &(head->outbuf), ROUNDUP64(head->outbufsize),
3518                                    hfa384x_ctlxout_callback, hw);
3519                 hw->ctlx_urb.transfer_flags |= USB_QUEUE_BULK;
3520
3521                 /* Now submit the URB and update the CTLX's state
3522                  */
3523                 if ((result = SUBMIT_URB(&hw->ctlx_urb, GFP_ATOMIC)) == 0) {
3524                         /* This CTLX is now running on the active queue */
3525                         head->state = CTLX_REQ_SUBMITTED;
3526
3527                         /* Start the OUT wait timer */
3528                         hw->req_timer_done = 0;
3529                         hw->reqtimer.expires = jiffies + HZ;
3530                         add_timer(&hw->reqtimer);
3531
3532                         /* Start the IN wait timer */
3533                         hw->resp_timer_done = 0;
3534                         hw->resptimer.expires = jiffies + 2*HZ;
3535                         add_timer(&hw->resptimer);
3536
3537                         break;
3538                 }
3539
3540                 if (result == -EPIPE) {
3541                         /* The OUT pipe needs resetting, so put
3542                          * this CTLX back in the "pending" queue
3543                          * and schedule a reset ...
3544                          */
3545                         WLAN_LOG_WARNING("%s tx pipe stalled: requesting reset\n",
3546                                          hw->wlandev->netdev->name);
3547                         list_move(&head->list, &hw->ctlxq.pending);
3548                         set_bit(WORK_TX_HALT, &hw->usb_flags);
3549                         schedule_work(&hw->usb_work);
3550                         break;
3551                 }
3552
3553                 if (result == -ESHUTDOWN) {
3554                         WLAN_LOG_WARNING("%s urb shutdown!\n",
3555                                          hw->wlandev->netdev->name);
3556                         break;
3557                 }
3558
3559                 WLAN_LOG_ERROR("Failed to submit CTLX[%d]: error=%d\n",
3560                                hfa384x2host_16(head->outbuf.type), result);
3561                 unlocked_usbctlx_complete(hw, head);
3562         } /* while */
3563
3564         unlock:
3565         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
3566
3567         DBFEXIT;
3568 }
3569
3570
3571 /*----------------------------------------------------------------
3572 * hfa384x_usbin_callback
3573 *
3574 * Callback for URBs on the BULKIN endpoint.
3575 *
3576 * Arguments:
3577 *       urb             ptr to the completed urb
3578 *
3579 * Returns:
3580 *       nothing
3581 *
3582 * Side effects:
3583 *
3584 * Call context:
3585 *       interrupt
3586 ----------------------------------------------------------------*/
3587 static void hfa384x_usbin_callback(struct urb *urb)
3588 {
3589         wlandevice_t            *wlandev = urb->context;
3590         hfa384x_t               *hw;
3591         hfa384x_usbin_t         *usbin = (hfa384x_usbin_t *) urb->transfer_buffer;
3592         struct sk_buff          *skb = NULL;
3593         int                     result;
3594         int                     urb_status;
3595         u16                     type;
3596
3597         enum USBIN_ACTION {
3598                 HANDLE,
3599                 RESUBMIT,
3600                 ABORT
3601         } action;
3602
3603         DBFENTER;
3604
3605         if ( !wlandev ||
3606              !wlandev->netdev ||
3607              wlandev->hwremoved )
3608                 goto exit;
3609
3610         hw = wlandev->priv;
3611         if (!hw)
3612                 goto exit;
3613
3614         skb = hw->rx_urb_skb;
3615         if (!skb || (skb->data != urb->transfer_buffer)) {
3616                 BUG();
3617         }
3618         hw->rx_urb_skb = NULL;
3619
3620         /* Check for error conditions within the URB */
3621         switch (urb->status) {
3622         case 0:
3623                 action = HANDLE;
3624
3625                 /* Check for short packet */
3626                 if ( urb->actual_length == 0 ) {
3627                         ++(wlandev->linux_stats.rx_errors);
3628                         ++(wlandev->linux_stats.rx_length_errors);
3629                         action = RESUBMIT;
3630                 }
3631                 break;
3632
3633         case -EPIPE:
3634                 WLAN_LOG_WARNING("%s rx pipe stalled: requesting reset\n",
3635                                  wlandev->netdev->name);
3636                 if ( !test_and_set_bit(WORK_RX_HALT, &hw->usb_flags) )
3637                         schedule_work(&hw->usb_work);
3638                 ++(wlandev->linux_stats.rx_errors);
3639                 action = ABORT;
3640                 break;
3641
3642         case -EILSEQ:
3643         case -ETIMEDOUT:
3644         case -EPROTO:
3645                 if ( !test_and_set_bit(THROTTLE_RX, &hw->usb_flags) &&
3646                      !timer_pending(&hw->throttle) ) {
3647                         mod_timer(&hw->throttle, jiffies + THROTTLE_JIFFIES);
3648                 }
3649                 ++(wlandev->linux_stats.rx_errors);
3650                 action = ABORT;
3651                 break;
3652
3653         case -EOVERFLOW:
3654                 ++(wlandev->linux_stats.rx_over_errors);
3655                 action = RESUBMIT;
3656                 break;
3657
3658         case -ENODEV:
3659         case -ESHUTDOWN:
3660                 WLAN_LOG_DEBUG(3,"status=%d, device removed.\n", urb->status);
3661                 action = ABORT;
3662                 break;
3663
3664         case -ENOENT:
3665         case -ECONNRESET:
3666                 WLAN_LOG_DEBUG(3,"status=%d, urb explicitly unlinked.\n", urb->status);
3667                 action = ABORT;
3668                 break;
3669
3670         default:
3671                 WLAN_LOG_DEBUG(3,"urb status=%d, transfer flags=0x%x\n",
3672                                  urb->status, urb->transfer_flags);
3673                 ++(wlandev->linux_stats.rx_errors);
3674                 action = RESUBMIT;
3675                 break;
3676         }
3677
3678         urb_status = urb->status;
3679
3680         if (action != ABORT) {
3681                 /* Repost the RX URB */
3682                 result = submit_rx_urb(hw, GFP_ATOMIC);
3683
3684                 if (result != 0) {
3685                         WLAN_LOG_ERROR(
3686                                 "Fatal, failed to resubmit rx_urb. error=%d\n",
3687                                 result);
3688                 }
3689         }
3690
3691         /* Handle any USB-IN packet */
3692         /* Note: the check of the sw_support field, the type field doesn't
3693          *       have bit 12 set like the docs suggest.
3694          */
3695         type = hfa384x2host_16(usbin->type);
3696         if (HFA384x_USB_ISRXFRM(type)) {
3697                 if (action == HANDLE) {
3698                         if (usbin->txfrm.desc.sw_support == 0x0123) {
3699                                 hfa384x_usbin_txcompl(wlandev, usbin);
3700                         } else {
3701                                 skb_put(skb, sizeof(*usbin));
3702                                 hfa384x_usbin_rx(wlandev, skb);
3703                                 skb = NULL;
3704                         }
3705                 }
3706                 goto exit;
3707         }
3708         if (HFA384x_USB_ISTXFRM(type)) {
3709                 if (action == HANDLE)
3710                         hfa384x_usbin_txcompl(wlandev, usbin);
3711                 goto exit;
3712         }
3713         switch (type) {
3714         case HFA384x_USB_INFOFRM:
3715                 if (action == ABORT)
3716                         goto exit;
3717                 if (action == HANDLE)
3718                         hfa384x_usbin_info(wlandev, usbin);
3719                 break;
3720
3721         case HFA384x_USB_CMDRESP:
3722         case HFA384x_USB_WRIDRESP:
3723         case HFA384x_USB_RRIDRESP:
3724         case HFA384x_USB_WMEMRESP:
3725         case HFA384x_USB_RMEMRESP:
3726                 /* ALWAYS, ALWAYS, ALWAYS handle this CTLX!!!! */
3727                 hfa384x_usbin_ctlx(hw, usbin, urb_status);
3728                 break;
3729
3730         case HFA384x_USB_BUFAVAIL:
3731                 WLAN_LOG_DEBUG(3,"Received BUFAVAIL packet, frmlen=%d\n",
3732                         usbin->bufavail.frmlen);
3733                 break;
3734
3735         case HFA384x_USB_ERROR:
3736                 WLAN_LOG_DEBUG(3,"Received USB_ERROR packet, errortype=%d\n",
3737                         usbin->usberror.errortype);
3738                 break;
3739
3740         default:
3741                 WLAN_LOG_DEBUG(3,"Unrecognized USBIN packet, type=%x, status=%d\n",
3742                         usbin->type, urb_status);
3743                 break;
3744         } /* switch */
3745
3746 exit:
3747
3748         if (skb)
3749                 dev_kfree_skb(skb);
3750
3751         DBFEXIT;
3752 }
3753
3754
3755 /*----------------------------------------------------------------
3756 * hfa384x_usbin_ctlx
3757 *
3758 * We've received a URB containing a Prism2 "response" message.
3759 * This message needs to be matched up with a CTLX on the active
3760 * queue and our state updated accordingly.
3761 *
3762 * Arguments:
3763 *       hw              ptr to hfa384x_t
3764 *       usbin           ptr to USB IN packet
3765 *       urb_status      status of this Bulk-In URB
3766 *
3767 * Returns:
3768 *       nothing
3769 *
3770 * Side effects:
3771 *
3772 * Call context:
3773 *       interrupt
3774 ----------------------------------------------------------------*/
3775 static void hfa384x_usbin_ctlx(hfa384x_t *hw, hfa384x_usbin_t *usbin,
3776                                int urb_status)
3777 {
3778         hfa384x_usbctlx_t       *ctlx;
3779         int                     run_queue = 0;
3780         unsigned long           flags;
3781
3782         DBFENTER;
3783
3784 retry:
3785         spin_lock_irqsave(&hw->ctlxq.lock, flags);
3786
3787         /* There can be only one CTLX on the active queue
3788          * at any one time, and this is the CTLX that the
3789          * timers are waiting for.
3790          */
3791         if ( list_empty(&hw->ctlxq.active) ) {
3792                 goto unlock;
3793         }
3794
3795         /* Remove the "response timeout". It's possible that
3796          * we are already too late, and that the timeout is
3797          * already running. And that's just too bad for us,
3798          * because we could lose our CTLX from the active
3799          * queue here ...
3800          */
3801         if (del_timer(&hw->resptimer) == 0) {
3802                 if (hw->resp_timer_done == 0) {
3803                         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
3804                         goto retry;
3805                 }
3806         }
3807         else {
3808                 hw->resp_timer_done = 1;
3809         }
3810
3811         ctlx = get_active_ctlx(hw);
3812
3813         if (urb_status != 0) {
3814                 /*
3815                  * Bad CTLX, so get rid of it. But we only
3816                  * remove it from the active queue if we're no
3817                  * longer expecting the OUT URB to complete.
3818                  */
3819                 if (unlocked_usbctlx_cancel_async(hw, ctlx) == 0)
3820                         run_queue = 1;
3821         } else {
3822                 const u16 intype = (usbin->type&~host2hfa384x_16(0x8000));
3823
3824                 /*
3825                  * Check that our message is what we're expecting ...
3826                  */
3827                 if (ctlx->outbuf.type != intype) {
3828                         WLAN_LOG_WARNING("Expected IN[%d], received IN[%d] - ignored.\n",
3829                                          hfa384x2host_16(ctlx->outbuf.type),
3830                                          hfa384x2host_16(intype));
3831                         goto unlock;
3832                 }
3833
3834                 /* This URB has succeeded, so grab the data ... */
3835                 memcpy(&ctlx->inbuf, usbin, sizeof(ctlx->inbuf));
3836
3837                 switch (ctlx->state) {
3838                 case CTLX_REQ_SUBMITTED:
3839                         /*
3840                          * We have received our response URB before
3841                          * our request has been acknowledged. Odd,
3842                          * but our OUT URB is still alive...
3843                          */
3844                         WLAN_LOG_DEBUG(0, "Causality violation: please reboot Universe, or email linux-wlan-devel@lists.linux-wlan.com\n");
3845                         ctlx->state = CTLX_RESP_COMPLETE;
3846                         break;
3847
3848                 case CTLX_REQ_COMPLETE:
3849                         /*
3850                          * This is the usual path: our request
3851                          * has already been acknowledged, and
3852                          * now we have received the reply too.
3853                          */
3854                         ctlx->state = CTLX_COMPLETE;
3855                         unlocked_usbctlx_complete(hw, ctlx);
3856                         run_queue = 1;
3857                         break;
3858
3859                 default:
3860                         /*
3861                          * Throw this CTLX away ...
3862                          */
3863                         WLAN_LOG_ERROR("Matched IN URB, CTLX[%d] in invalid state(%s)."
3864                                        " Discarded.\n",
3865                                        hfa384x2host_16(ctlx->outbuf.type),
3866                                        ctlxstr(ctlx->state));
3867                         if (unlocked_usbctlx_cancel_async(hw, ctlx) == 0)
3868                                 run_queue = 1;
3869                         break;
3870                 } /* switch */
3871         }
3872
3873 unlock:
3874         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
3875
3876         if (run_queue)
3877                 hfa384x_usbctlxq_run(hw);
3878
3879         DBFEXIT;
3880 }
3881
3882
3883 /*----------------------------------------------------------------
3884 * hfa384x_usbin_txcompl
3885 *
3886 * At this point we have the results of a previous transmit.
3887 *
3888 * Arguments:
3889 *       wlandev         wlan device
3890 *       usbin           ptr to the usb transfer buffer
3891 *
3892 * Returns:
3893 *       nothing
3894 *
3895 * Side effects:
3896 *
3897 * Call context:
3898 *       interrupt
3899 ----------------------------------------------------------------*/
3900 static void hfa384x_usbin_txcompl(wlandevice_t *wlandev, hfa384x_usbin_t *usbin)
3901 {
3902         u16                     status;
3903         DBFENTER;
3904
3905         status = hfa384x2host_16(usbin->type); /* yeah I know it says type...*/
3906
3907         /* Was there an error? */
3908         if (HFA384x_TXSTATUS_ISERROR(status)) {
3909                 prism2sta_ev_txexc(wlandev, status);
3910         } else {
3911                 prism2sta_ev_tx(wlandev, status);
3912         }
3913         // prism2sta_ev_alloc(wlandev);
3914
3915         DBFEXIT;
3916 }
3917
3918
3919 /*----------------------------------------------------------------
3920 * hfa384x_usbin_rx
3921 *
3922 * At this point we have a successful received a rx frame packet.
3923 *
3924 * Arguments:
3925 *       wlandev         wlan device
3926 *       usbin           ptr to the usb transfer buffer
3927 *
3928 * Returns:
3929 *       nothing
3930 *
3931 * Side effects:
3932 *
3933 * Call context:
3934 *       interrupt
3935 ----------------------------------------------------------------*/
3936 static void hfa384x_usbin_rx(wlandevice_t *wlandev, struct sk_buff *skb)
3937 {
3938         hfa384x_usbin_t         *usbin = (hfa384x_usbin_t *) skb->data;
3939         hfa384x_t               *hw = wlandev->priv;
3940         int                     hdrlen;
3941         p80211_rxmeta_t         *rxmeta;
3942         u16                  data_len;
3943         u16                  fc;
3944
3945         DBFENTER;
3946
3947         /* Byte order convert once up front. */
3948         usbin->rxfrm.desc.status =
3949                 hfa384x2host_16(usbin->rxfrm.desc.status);
3950         usbin->rxfrm.desc.time =
3951                 hfa384x2host_32(usbin->rxfrm.desc.time);
3952
3953         /* Now handle frame based on port# */
3954         switch( HFA384x_RXSTATUS_MACPORT_GET(usbin->rxfrm.desc.status) )
3955         {
3956         case 0:
3957                 fc = ieee2host16(usbin->rxfrm.desc.frame_control);
3958
3959                 /* If exclude and we receive an unencrypted, drop it */
3960                 if ( (wlandev->hostwep & HOSTWEP_EXCLUDEUNENCRYPTED) &&
3961                      !WLAN_GET_FC_ISWEP(fc)){
3962                         goto done;
3963                 }
3964
3965                 data_len = hfa384x2host_16(usbin->rxfrm.desc.data_len);
3966
3967                 /* How much header data do we have? */
3968                 hdrlen = p80211_headerlen(fc);
3969
3970                 /* Pull off the descriptor */
3971                 skb_pull(skb, sizeof(hfa384x_rx_frame_t));
3972
3973                 /* Now shunt the header block up against the data block
3974                  * with an "overlapping" copy
3975                  */
3976                 memmove(skb_push(skb, hdrlen),
3977                         &usbin->rxfrm.desc.frame_control,
3978                         hdrlen);
3979
3980                 skb->dev = wlandev->netdev;
3981                 skb->dev->last_rx = jiffies;
3982
3983                 /* And set the frame length properly */
3984                 skb_trim(skb, data_len + hdrlen);
3985
3986                 /* The prism2 series does not return the CRC */
3987                 memset(skb_put(skb, WLAN_CRC_LEN), 0xff, WLAN_CRC_LEN);
3988
3989                 skb_reset_mac_header(skb);
3990
3991                 /* Attach the rxmeta, set some stuff */
3992                 p80211skb_rxmeta_attach(wlandev, skb);
3993                 rxmeta = P80211SKB_RXMETA(skb);
3994                 rxmeta->mactime = usbin->rxfrm.desc.time;
3995                 rxmeta->rxrate = usbin->rxfrm.desc.rate;
3996                 rxmeta->signal = usbin->rxfrm.desc.signal - hw->dbmadjust;
3997                 rxmeta->noise = usbin->rxfrm.desc.silence - hw->dbmadjust;
3998
3999                 prism2sta_ev_rx(wlandev, skb);
4000
4001                 break;
4002
4003         case 7:
4004                 if ( ! HFA384x_RXSTATUS_ISFCSERR(usbin->rxfrm.desc.status) ) {
4005                         /* Copy to wlansnif skb */
4006                         hfa384x_int_rxmonitor( wlandev, &usbin->rxfrm);
4007                         dev_kfree_skb(skb);
4008                 } else {
4009                         WLAN_LOG_DEBUG(3,"Received monitor frame: FCSerr set\n");
4010                 }
4011                 break;
4012
4013         default:
4014                 WLAN_LOG_WARNING("Received frame on unsupported port=%d\n",
4015                         HFA384x_RXSTATUS_MACPORT_GET(usbin->rxfrm.desc.status) );
4016                 goto done;
4017                 break;
4018         }
4019
4020 done:
4021         DBFEXIT;
4022         return;
4023 }
4024
4025 /*----------------------------------------------------------------
4026 * hfa384x_int_rxmonitor
4027 *
4028 * Helper function for int_rx.  Handles monitor frames.
4029 * Note that this function allocates space for the FCS and sets it
4030 * to 0xffffffff.  The hfa384x doesn't give us the FCS value but the
4031 * higher layers expect it.  0xffffffff is used as a flag to indicate
4032 * the FCS is bogus.
4033 *
4034 * Arguments:
4035 *       wlandev         wlan device structure
4036 *       rxfrm           rx descriptor read from card in int_rx
4037 *
4038 * Returns:
4039 *       nothing
4040 *
4041 * Side effects:
4042 *       Allocates an skb and passes it up via the PF_PACKET interface.
4043 * Call context:
4044 *       interrupt
4045 ----------------------------------------------------------------*/
4046 static void hfa384x_int_rxmonitor( wlandevice_t *wlandev, hfa384x_usb_rxfrm_t *rxfrm)
4047 {
4048         hfa384x_rx_frame_t              *rxdesc = &(rxfrm->desc);
4049         unsigned int                            hdrlen = 0;
4050         unsigned int                            datalen = 0;
4051         unsigned int                            skblen = 0;
4052         u8                              *datap;
4053         u16                             fc;
4054         struct sk_buff                  *skb;
4055         hfa384x_t                       *hw = wlandev->priv;
4056
4057
4058         DBFENTER;
4059         /* Don't forget the status, time, and data_len fields are in host order */
4060         /* Figure out how big the frame is */
4061         fc = ieee2host16(rxdesc->frame_control);
4062         hdrlen = p80211_headerlen(fc);
4063         datalen = hfa384x2host_16(rxdesc->data_len);
4064
4065         /* Allocate an ind message+framesize skb */
4066         skblen = sizeof(p80211_caphdr_t) +
4067                 hdrlen + datalen + WLAN_CRC_LEN;
4068
4069         /* sanity check the length */
4070         if ( skblen >
4071              (sizeof(p80211_caphdr_t) +
4072               WLAN_HDR_A4_LEN + WLAN_DATA_MAXLEN + WLAN_CRC_LEN) ) {
4073                 WLAN_LOG_DEBUG(1, "overlen frm: len=%zd\n",
4074                                skblen - sizeof(p80211_caphdr_t));
4075         }
4076
4077         if ( (skb = dev_alloc_skb(skblen)) == NULL ) {
4078                 WLAN_LOG_ERROR("alloc_skb failed trying to allocate %d bytes\n", skblen);
4079                 return;
4080         }
4081
4082         /* only prepend the prism header if in the right mode */
4083         if ((wlandev->netdev->type == ARPHRD_IEEE80211_PRISM) &&
4084             (hw->sniffhdr != 0)) {
4085                 p80211_caphdr_t         *caphdr;
4086                 /* The NEW header format! */
4087                 datap = skb_put(skb, sizeof(p80211_caphdr_t));
4088                 caphdr = (p80211_caphdr_t*) datap;
4089
4090                 caphdr->version =       htonl(P80211CAPTURE_VERSION);
4091                 caphdr->length =        htonl(sizeof(p80211_caphdr_t));
4092                 caphdr->mactime =       __cpu_to_be64(rxdesc->time) * 1000;
4093                 caphdr->hosttime =      __cpu_to_be64(jiffies);
4094                 caphdr->phytype =       htonl(4); /* dss_dot11_b */
4095                 caphdr->channel =       htonl(hw->sniff_channel);
4096                 caphdr->datarate =      htonl(rxdesc->rate);
4097                 caphdr->antenna =       htonl(0); /* unknown */
4098                 caphdr->priority =      htonl(0); /* unknown */
4099                 caphdr->ssi_type =      htonl(3); /* rssi_raw */
4100                 caphdr->ssi_signal =    htonl(rxdesc->signal);
4101                 caphdr->ssi_noise =     htonl(rxdesc->silence);
4102                 caphdr->preamble =      htonl(0); /* unknown */
4103                 caphdr->encoding =      htonl(1); /* cck */
4104         }
4105
4106         /* Copy the 802.11 header to the skb (ctl frames may be less than a full header) */
4107         datap = skb_put(skb, hdrlen);
4108         memcpy( datap, &(rxdesc->frame_control), hdrlen);
4109
4110         /* If any, copy the data from the card to the skb */
4111         if ( datalen > 0 )
4112         {
4113                 datap = skb_put(skb, datalen);
4114                 memcpy(datap, rxfrm->data, datalen);
4115
4116                 /* check for unencrypted stuff if WEP bit set. */
4117                 if (*(datap - hdrlen + 1) & 0x40) // wep set
4118                   if ((*(datap) == 0xaa) && (*(datap+1) == 0xaa))
4119                     *(datap - hdrlen + 1) &= 0xbf; // clear wep; it's the 802.2 header!
4120         }
4121
4122         if (hw->sniff_fcs) {
4123                 /* Set the FCS */
4124                 datap = skb_put(skb, WLAN_CRC_LEN);
4125                 memset( datap, 0xff, WLAN_CRC_LEN);
4126         }
4127
4128         /* pass it back up */
4129         prism2sta_ev_rx(wlandev, skb);
4130
4131         DBFEXIT;
4132         return;
4133 }
4134
4135
4136
4137 /*----------------------------------------------------------------
4138 * hfa384x_usbin_info
4139 *
4140 * At this point we have a successful received a Prism2 info frame.
4141 *
4142 * Arguments:
4143 *       wlandev         wlan device
4144 *       usbin           ptr to the usb transfer buffer
4145 *
4146 * Returns:
4147 *       nothing
4148 *
4149 * Side effects:
4150 *
4151 * Call context:
4152 *       interrupt
4153 ----------------------------------------------------------------*/
4154 static void hfa384x_usbin_info(wlandevice_t *wlandev, hfa384x_usbin_t *usbin)
4155 {
4156         DBFENTER;
4157
4158         usbin->infofrm.info.framelen = hfa384x2host_16(usbin->infofrm.info.framelen);
4159         prism2sta_ev_info(wlandev, &usbin->infofrm.info);
4160
4161         DBFEXIT;
4162 }
4163
4164
4165
4166 /*----------------------------------------------------------------
4167 * hfa384x_usbout_callback
4168 *
4169 * Callback for URBs on the BULKOUT endpoint.
4170 *
4171 * Arguments:
4172 *       urb             ptr to the completed urb
4173 *
4174 * Returns:
4175 *       nothing
4176 *
4177 * Side effects:
4178 *
4179 * Call context:
4180 *       interrupt
4181 ----------------------------------------------------------------*/
4182 static void hfa384x_usbout_callback(struct urb *urb)
4183 {
4184         wlandevice_t            *wlandev = urb->context;
4185         hfa384x_usbout_t        *usbout = urb->transfer_buffer;
4186         DBFENTER;
4187
4188 #ifdef DEBUG_USB
4189         dbprint_urb(urb);
4190 #endif
4191
4192         if ( wlandev &&
4193              wlandev->netdev ) {
4194
4195                 switch(urb->status) {
4196                 case 0:
4197                         hfa384x_usbout_tx(wlandev, usbout);
4198                         break;
4199
4200                 case -EPIPE:
4201                 {
4202                         hfa384x_t *hw = wlandev->priv;
4203                         WLAN_LOG_WARNING("%s tx pipe stalled: requesting reset\n",
4204                                          wlandev->netdev->name);
4205                         if ( !test_and_set_bit(WORK_TX_HALT, &hw->usb_flags) )
4206                                 schedule_work(&hw->usb_work);
4207                         ++(wlandev->linux_stats.tx_errors);
4208                         break;
4209                 }
4210
4211                 case -EPROTO:
4212                 case -ETIMEDOUT:
4213                 case -EILSEQ:
4214                 {
4215                         hfa384x_t *hw = wlandev->priv;
4216
4217                         if ( !test_and_set_bit(THROTTLE_TX, &hw->usb_flags)
4218                              && !timer_pending(&hw->throttle) ) {
4219                                 mod_timer(&hw->throttle,
4220                                           jiffies + THROTTLE_JIFFIES);
4221                         }
4222                         ++(wlandev->linux_stats.tx_errors);
4223                         netif_stop_queue(wlandev->netdev);
4224                         break;
4225                 }
4226
4227                 case -ENOENT:
4228                 case -ESHUTDOWN:
4229                         /* Ignorable errors */
4230                         break;
4231
4232                 default:
4233                         WLAN_LOG_INFO("unknown urb->status=%d\n", urb->status);
4234                         ++(wlandev->linux_stats.tx_errors);
4235                         break;
4236                 } /* switch */
4237         }
4238
4239         DBFEXIT;
4240 }
4241
4242
4243 /*----------------------------------------------------------------
4244 * hfa384x_ctlxout_callback
4245 *
4246 * Callback for control data on the BULKOUT endpoint.
4247 *
4248 * Arguments:
4249 *       urb             ptr to the completed urb
4250 *
4251 * Returns:
4252 * nothing
4253 *
4254 * Side effects:
4255 *
4256 * Call context:
4257 * interrupt
4258 ----------------------------------------------------------------*/
4259 static void hfa384x_ctlxout_callback(struct urb *urb)
4260 {
4261         hfa384x_t       *hw = urb->context;
4262         int             delete_resptimer = 0;
4263         int             timer_ok = 1;
4264         int             run_queue = 0;
4265         hfa384x_usbctlx_t       *ctlx;
4266         unsigned long   flags;
4267
4268         DBFENTER;
4269
4270         WLAN_LOG_DEBUG(3,"urb->status=%d\n", urb->status);
4271 #ifdef DEBUG_USB
4272         dbprint_urb(urb);
4273 #endif
4274         if ( (urb->status == -ESHUTDOWN) ||
4275              (urb->status == -ENODEV) ||
4276              (hw == NULL) )
4277                 goto done;
4278
4279 retry:
4280         spin_lock_irqsave(&hw->ctlxq.lock, flags);
4281
4282         /*
4283          * Only one CTLX at a time on the "active" list, and
4284          * none at all if we are unplugged. However, we can
4285          * rely on the disconnect function to clean everything
4286          * up if someone unplugged the adapter.
4287          */
4288         if ( list_empty(&hw->ctlxq.active) ) {
4289                 spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
4290                 goto done;
4291         }
4292
4293         /*
4294          * Having something on the "active" queue means
4295          * that we have timers to worry about ...
4296          */
4297         if (del_timer(&hw->reqtimer) == 0) {
4298                 if (hw->req_timer_done == 0) {
4299                         /*
4300                          * This timer was actually running while we
4301                          * were trying to delete it. Let it terminate
4302                          * gracefully instead.
4303                          */
4304                         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
4305                         goto retry;
4306                 }
4307         }
4308         else {
4309                 hw->req_timer_done = 1;
4310         }
4311
4312         ctlx = get_active_ctlx(hw);
4313
4314         if ( urb->status == 0 ) {
4315                 /* Request portion of a CTLX is successful */
4316                 switch ( ctlx->state ) {
4317                 case CTLX_REQ_SUBMITTED:
4318                         /* This OUT-ACK received before IN */
4319                         ctlx->state = CTLX_REQ_COMPLETE;
4320                         break;
4321
4322                 case CTLX_RESP_COMPLETE:
4323                         /* IN already received before this OUT-ACK,
4324                          * so this command must now be complete.
4325                          */
4326                         ctlx->state = CTLX_COMPLETE;
4327                         unlocked_usbctlx_complete(hw, ctlx);
4328                         run_queue = 1;
4329                         break;
4330
4331                 default:
4332                         /* This is NOT a valid CTLX "success" state! */
4333                         WLAN_LOG_ERROR(
4334                             "Illegal CTLX[%d] success state(%s, %d) in OUT URB\n",
4335                             hfa384x2host_16(ctlx->outbuf.type),
4336                             ctlxstr(ctlx->state), urb->status);
4337                         break;
4338                 } /* switch */
4339         } else {
4340                 /* If the pipe has stalled then we need to reset it */
4341                 if ( (urb->status == -EPIPE) &&
4342                       !test_and_set_bit(WORK_TX_HALT, &hw->usb_flags) ) {
4343                         WLAN_LOG_WARNING("%s tx pipe stalled: requesting reset\n",
4344                                          hw->wlandev->netdev->name);
4345                         schedule_work(&hw->usb_work);
4346                 }
4347
4348                 /* If someone cancels the OUT URB then its status
4349                  * should be either -ECONNRESET or -ENOENT.
4350                  */
4351                 ctlx->state = CTLX_REQ_FAILED;
4352                 unlocked_usbctlx_complete(hw, ctlx);
4353                 delete_resptimer = 1;
4354                 run_queue = 1;
4355         }
4356
4357  delresp:
4358         if (delete_resptimer) {
4359                 if ((timer_ok = del_timer(&hw->resptimer)) != 0) {
4360                         hw->resp_timer_done = 1;
4361                 }
4362         }
4363
4364         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
4365
4366         if ( !timer_ok && (hw->resp_timer_done == 0) ) {
4367                 spin_lock_irqsave(&hw->ctlxq.lock, flags);
4368                 goto delresp;
4369         }
4370
4371         if (run_queue)
4372                 hfa384x_usbctlxq_run(hw);
4373
4374  done:
4375         DBFEXIT;
4376 }
4377
4378
4379 /*----------------------------------------------------------------
4380 * hfa384x_usbctlx_reqtimerfn
4381 *
4382 * Timer response function for CTLX request timeouts.  If this
4383 * function is called, it means that the callback for the OUT
4384 * URB containing a Prism2.x XXX_Request was never called.
4385 *
4386 * Arguments:
4387 *       data            a ptr to the hfa384x_t
4388 *
4389 * Returns:
4390 *       nothing
4391 *
4392 * Side effects:
4393 *
4394 * Call context:
4395 *       interrupt
4396 ----------------------------------------------------------------*/
4397 static void
4398 hfa384x_usbctlx_reqtimerfn(unsigned long data)
4399 {
4400         hfa384x_t       *hw = (hfa384x_t*)data;
4401         unsigned long   flags;
4402         DBFENTER;
4403
4404         spin_lock_irqsave(&hw->ctlxq.lock, flags);
4405
4406         hw->req_timer_done = 1;
4407
4408         /* Removing the hardware automatically empties
4409          * the active list ...
4410          */
4411         if ( !list_empty(&hw->ctlxq.active) )
4412         {
4413                 /*
4414                  * We must ensure that our URB is removed from
4415                  * the system, if it hasn't already expired.
4416                  */
4417                 hw->ctlx_urb.transfer_flags |= URB_ASYNC_UNLINK;
4418                 if (usb_unlink_urb(&hw->ctlx_urb) == -EINPROGRESS)
4419                 {
4420                         hfa384x_usbctlx_t *ctlx = get_active_ctlx(hw);
4421
4422                         ctlx->state = CTLX_REQ_FAILED;
4423
4424                         /* This URB was active, but has now been
4425                          * cancelled. It will now have a status of
4426                          * -ECONNRESET in the callback function.
4427                          *
4428                          * We are cancelling this CTLX, so we're
4429                          * not going to need to wait for a response.
4430                          * The URB's callback function will check
4431                          * that this timer is truly dead.
4432                          */
4433                         if (del_timer(&hw->resptimer) != 0)
4434                                 hw->resp_timer_done = 1;
4435                 }
4436         }
4437
4438         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
4439
4440         DBFEXIT;
4441 }
4442
4443
4444 /*----------------------------------------------------------------
4445 * hfa384x_usbctlx_resptimerfn
4446 *
4447 * Timer response function for CTLX response timeouts.  If this
4448 * function is called, it means that the callback for the IN
4449 * URB containing a Prism2.x XXX_Response was never called.
4450 *
4451 * Arguments:
4452 *       data            a ptr to the hfa384x_t
4453 *
4454 * Returns:
4455 *       nothing
4456 *
4457 * Side effects:
4458 *
4459 * Call context:
4460 *       interrupt
4461 ----------------------------------------------------------------*/
4462 static void
4463 hfa384x_usbctlx_resptimerfn(unsigned long data)
4464 {
4465         hfa384x_t *hw = (hfa384x_t*)data;
4466         unsigned long   flags;
4467
4468         DBFENTER;
4469
4470         spin_lock_irqsave(&hw->ctlxq.lock, flags);
4471
4472         hw->resp_timer_done = 1;
4473
4474         /* The active list will be empty if the
4475          * adapter has been unplugged ...
4476          */
4477         if ( !list_empty(&hw->ctlxq.active) )
4478         {
4479                 hfa384x_usbctlx_t *ctlx = get_active_ctlx(hw);
4480
4481                 if ( unlocked_usbctlx_cancel_async(hw, ctlx) == 0 )
4482                 {
4483                         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
4484                         hfa384x_usbctlxq_run(hw);
4485                         goto done;
4486                 }
4487         }
4488
4489         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
4490
4491  done:
4492         DBFEXIT;
4493 }
4494
4495 /*----------------------------------------------------------------
4496 * hfa384x_usb_throttlefn
4497 *
4498 *
4499 * Arguments:
4500 *       data    ptr to hw
4501 *
4502 * Returns:
4503 *       Nothing
4504 *
4505 * Side effects:
4506 *
4507 * Call context:
4508 *       Interrupt
4509 ----------------------------------------------------------------*/
4510 static void
4511 hfa384x_usb_throttlefn(unsigned long data)
4512 {
4513         hfa384x_t *hw = (hfa384x_t*)data;
4514         unsigned long   flags;
4515
4516         DBFENTER;
4517
4518         spin_lock_irqsave(&hw->ctlxq.lock, flags);
4519
4520         /*
4521          * We need to check BOTH the RX and the TX throttle controls,
4522          * so we use the bitwise OR instead of the logical OR.
4523          */
4524         WLAN_LOG_DEBUG(3, "flags=0x%lx\n", hw->usb_flags);
4525         if ( !hw->wlandev->hwremoved &&
4526              (
4527                (test_and_clear_bit(THROTTLE_RX, &hw->usb_flags) &&
4528                !test_and_set_bit(WORK_RX_RESUME, &hw->usb_flags))
4529                |
4530                (test_and_clear_bit(THROTTLE_TX, &hw->usb_flags) &&
4531                 !test_and_set_bit(WORK_TX_RESUME, &hw->usb_flags))
4532              ) )
4533         {
4534                 schedule_work(&hw->usb_work);
4535         }
4536
4537         spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
4538
4539         DBFEXIT;
4540 }
4541
4542
4543 /*----------------------------------------------------------------
4544 * hfa384x_usbctlx_submit
4545 *
4546 * Called from the doxxx functions to submit a CTLX to the queue
4547 *
4548 * Arguments:
4549 *       hw              ptr to the hw struct
4550 *       ctlx            ctlx structure to enqueue
4551 *
4552 * Returns:
4553 *       -ENODEV if the adapter is unplugged
4554 *       0
4555 *
4556 * Side effects:
4557 *
4558 * Call context:
4559 *       process or interrupt
4560 ----------------------------------------------------------------*/
4561 static int
4562 hfa384x_usbctlx_submit(
4563         hfa384x_t               *hw,
4564         hfa384x_usbctlx_t       *ctlx)
4565 {
4566         unsigned long flags;
4567         int ret;
4568
4569         DBFENTER;
4570
4571         spin_lock_irqsave(&hw->ctlxq.lock, flags);
4572
4573         if (hw->wlandev->hwremoved) {
4574                 spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
4575                 ret = -ENODEV;
4576         } else {
4577                 ctlx->state = CTLX_PENDING;
4578                 list_add_tail(&ctlx->list, &hw->ctlxq.pending);
4579
4580                 spin_unlock_irqrestore(&hw->ctlxq.lock, flags);
4581                 hfa384x_usbctlxq_run(hw);
4582                 ret = 0;
4583         }
4584
4585         DBFEXIT;
4586         return ret;
4587 }
4588
4589
4590 /*----------------------------------------------------------------
4591 * hfa384x_usbout_tx
4592 *
4593 * At this point we have finished a send of a frame.  Mark the URB
4594 * as available and call ev_alloc to notify higher layers we're
4595 * ready for more.
4596 *
4597 * Arguments:
4598 *       wlandev         wlan device
4599 *       usbout          ptr to the usb transfer buffer
4600 *
4601 * Returns:
4602 *       nothing
4603 *
4604 * Side effects:
4605 *
4606 * Call context:
4607 *       interrupt
4608 ----------------------------------------------------------------*/
4609 static void hfa384x_usbout_tx(wlandevice_t *wlandev, hfa384x_usbout_t *usbout)
4610 {
4611         DBFENTER;
4612
4613         prism2sta_ev_alloc(wlandev);
4614
4615         DBFEXIT;
4616 }
4617
4618 /*----------------------------------------------------------------
4619 * hfa384x_isgood_pdrcore
4620 *
4621 * Quick check of PDR codes.
4622 *
4623 * Arguments:
4624 *       pdrcode         PDR code number (host order)
4625 *
4626 * Returns:
4627 *       zero            not good.
4628 *       one             is good.
4629 *
4630 * Side effects:
4631 *
4632 * Call context:
4633 ----------------------------------------------------------------*/
4634 static int
4635 hfa384x_isgood_pdrcode(u16 pdrcode)
4636 {
4637         switch(pdrcode) {
4638         case HFA384x_PDR_END_OF_PDA:
4639         case HFA384x_PDR_PCB_PARTNUM:
4640         case HFA384x_PDR_PDAVER:
4641         case HFA384x_PDR_NIC_SERIAL:
4642         case HFA384x_PDR_MKK_MEASUREMENTS:
4643         case HFA384x_PDR_NIC_RAMSIZE:
4644         case HFA384x_PDR_MFISUPRANGE:
4645         case HFA384x_PDR_CFISUPRANGE:
4646         case HFA384x_PDR_NICID:
4647         case HFA384x_PDR_MAC_ADDRESS:
4648         case HFA384x_PDR_REGDOMAIN:
4649         case HFA384x_PDR_ALLOWED_CHANNEL:
4650         case HFA384x_PDR_DEFAULT_CHANNEL:
4651         case HFA384x_PDR_TEMPTYPE:
4652         case HFA384x_PDR_IFR_SETTING:
4653         case HFA384x_PDR_RFR_SETTING:
4654         case HFA384x_PDR_HFA3861_BASELINE:
4655         case HFA384x_PDR_HFA3861_SHADOW:
4656         case HFA384x_PDR_HFA3861_IFRF:
4657         case HFA384x_PDR_HFA3861_CHCALSP:
4658         case HFA384x_PDR_HFA3861_CHCALI:
4659         case HFA384x_PDR_3842_NIC_CONFIG:
4660         case HFA384x_PDR_USB_ID:
4661         case HFA384x_PDR_PCI_ID:
4662         case HFA384x_PDR_PCI_IFCONF:
4663         case HFA384x_PDR_PCI_PMCONF:
4664         case HFA384x_PDR_RFENRGY:
4665         case HFA384x_PDR_HFA3861_MANF_TESTSP:
4666         case HFA384x_PDR_HFA3861_MANF_TESTI:
4667                 /* code is OK */
4668                 return 1;
4669                 break;
4670         default:
4671                 if ( pdrcode < 0x1000 ) {
4672                         /* code is OK, but we don't know exactly what it is */
4673                         WLAN_LOG_DEBUG(3,
4674                                 "Encountered unknown PDR#=0x%04x, "
4675                                 "assuming it's ok.\n",
4676                                 pdrcode);
4677                         return 1;
4678                 } else {
4679                         /* bad code */
4680                         WLAN_LOG_DEBUG(3,
4681                                 "Encountered unknown PDR#=0x%04x, "
4682                                 "(>=0x1000), assuming it's bad.\n",
4683                                 pdrcode);
4684                         return 0;
4685                 }
4686                 break;
4687         }
4688         return 0; /* avoid compiler warnings */
4689 }
4690