drivers/staging/csr/csr_wifi_hip_unifi.h

   1 /*****************************************************************************
   2
   3             (c) Cambridge Silicon Radio Limited 2012
   4             All rights reserved and confidential information of CSR
   5
   6             Refer to LICENSE.txt included with this source for details
   7             on the license terms.
   8
   9 *****************************************************************************/
  10
  11 /*
  12  * ---------------------------------------------------------------------------
  13  *
  14  * FILE : csr_wifi_hip_unifi.h
  15  *
  16  * PURPOSE : Public API for the UniFi HIP core library.
  17  *
  18  * ---------------------------------------------------------------------------
  19  */
  20 #ifndef __CSR_WIFI_HIP_UNIFI_H__
  21 #define __CSR_WIFI_HIP_UNIFI_H__ 1
  22
  23 #ifdef __cplusplus
  24 extern "C" {
  25 #endif
  26
  27 #ifndef CSR_WIFI_HIP_TA_DISABLE
  28 #include "csr_wifi_router_ctrl_prim.h"
  29 #include "csr_wifi_router_prim.h"
  30 #else
  31 #include "csr_time.h"
  32 #endif
  33
  34 /* SDIO chip ID numbers */
  35
  36 /* Manufacturer id */
  37 #define SDIO_MANF_ID_CSR              0x032a
  38
  39 /* Device id */
  40 #define SDIO_CARD_ID_UNIFI_1          0x0001
  41 #define SDIO_CARD_ID_UNIFI_2          0x0002
  42 #define SDIO_CARD_ID_UNIFI_3          0x0007
  43 #define SDIO_CARD_ID_UNIFI_4          0x0008
  44
  45 /* Function number for WLAN */
  46 #define SDIO_WLAN_FUNC_ID_UNIFI_1          0x0001
  47 #define SDIO_WLAN_FUNC_ID_UNIFI_2          0x0001
  48 #define SDIO_WLAN_FUNC_ID_UNIFI_3          0x0001
  49 #define SDIO_WLAN_FUNC_ID_UNIFI_4          0x0002
  50
  51 /* Maximum SDIO bus clock supported. */
  52 #define UNIFI_SDIO_CLOCK_MAX_HZ    50000000  /* Hz */
  53
  54 /*
  55  * Initialisation SDIO bus clock.
  56  *
  57  * The initialisation clock speed should be used from when the chip has been
  58  * reset until the first MLME-reset has been received (i.e. during firmware
  59  * initialisation), unless UNIFI_SDIO_CLOCK_SAFE_HZ applies.
  60  */
  61 #define UNIFI_SDIO_CLOCK_INIT_HZ    12500000 /* Hz */
  62
  63 /*
  64  * Safe SDIO bus clock.
  65  *
  66  * The safe speed should be used when the chip is in deep sleep or
  67  * it's state is unknown (just after reset / power on).
  68  */
  69 #define UNIFI_SDIO_CLOCK_SAFE_HZ    1000000  /* Hz */
  70
  71 /* I/O default block size to use for UniFi. */
  72 #define UNIFI_IO_BLOCK_SIZE     64
  73
  74 #define UNIFI_WOL_OFF   0
  75 #define UNIFI_WOL_SDIO  1
  76 #define UNIFI_WOL_PIO   2
  77
  78 /* The number of Tx traffic queues */
  79 #define UNIFI_NO_OF_TX_QS              4
  80
  81 #define CSR_WIFI_HIP_RESERVED_HOST_TAG 0xFFFFFFFF
  82
  83 /*
  84  * The number of slots in the from-host queues.
  85  *
  86  * UNIFI_SOFT_TRAFFIC_Q_LENGTH is the number of slots in the traffic queues
  87  * and there will be UNIFI_NO_OF_TX_QS of them.
  88  * Traffic queues are used for data packets.
  89  *
  90  * UNIFI_SOFT_COMMAND_Q_LENGTH is the number of slots in the command queue.
  91  * The command queue is used for MLME management requests.
  92  *
  93  * Queues are ring buffers and so must always have 1 unused slot.
  94  */
  95 #define UNIFI_SOFT_TRAFFIC_Q_LENGTH (20 + 1)
  96 #define UNIFI_SOFT_COMMAND_Q_LENGTH (16 + 1)
  97
  98 #include "csr_framework_ext.h"  /* from the synergy porting folder */
  99 #include "csr_sdio.h"           /* from the synergy porting folder */
 100 #include "csr_macro.h"          /* from the synergy porting folder */
 101 #include "csr_formatted_io.h"   /* from the synergy gsp folder */
 102 #include "csr_wifi_result.h"
 103
 104 /* Utility MACROS. Note that UNIFI_MAC_ADDRESS_CMP returns TRUE on success */
 105 #define UNIFI_MAC_ADDRESS_COPY(dst, src) \
 106     do { (dst)[0] = (src)[0]; (dst)[1] = (src)[1]; \
 107          (dst)[2] = (src)[2]; (dst)[3] = (src)[3]; \
 108          (dst)[4] = (src)[4]; (dst)[5] = (src)[5]; \
 109     } while (0)
 110
 111 #define UNIFI_MAC_ADDRESS_CMP(addr1, addr2) \
 112     (((addr1)[0] == (addr2)[0]) && ((addr1)[1] == (addr2)[1]) && \
 113      ((addr1)[2] == (addr2)[2]) && ((addr1)[3] == (addr2)[3]) && \
 114      ((addr1)[4] == (addr2)[4]) && ((addr1)[5] == (addr2)[5]))
 115
 116 /* Traffic queue ordered according to priority
 117  * EAPOL/Uncontrolled port Queue should be the last
 118  */
 119 typedef enum
 120 {
 121     UNIFI_TRAFFIC_Q_BK = 0,
 122     UNIFI_TRAFFIC_Q_BE,
 123     UNIFI_TRAFFIC_Q_VI,
 124     UNIFI_TRAFFIC_Q_VO,
 125     UNIFI_TRAFFIC_Q_EAPOL,    /* Non existant in HIP */
 126     UNIFI_TRAFFIC_Q_MAX,      /* Non existant */
 127     UNIFI_TRAFFIC_Q_MLME      /* Non existant */
 128 } unifi_TrafficQueue;
 129
 130 /*
 131  * Structure describing a bulk data slot.
 132  * This structure is shared between the HIP core library and the OS
 133  * layer. See the definition of unifi_net_data_malloc() for more details.
 134  *
 135  * The data_length field is used to indicate empty/occupied state.
 136  * Needs to be defined before #include "unifi_os.h".
 137  */
 138 typedef struct _bulk_data_desc
 139 {
 140     const u8 *os_data_ptr;
 141     u32       data_length;
 142     const void     *os_net_buf_ptr;
 143     u32       net_buf_length;
 144 } bulk_data_desc_t;
 145
 146 /* Structure of an entry in the Symbol Look Up Table (SLUT). */
 147 typedef struct _symbol
 148 {
 149     u16 id;
 150     u32 obj;
 151 } symbol_t;
 152
 153 /*
 154  * Header files need to be included from the current directory,
 155  * the SME library, the synergy framework and the OS layer.
 156  * A thin OS layer needs to be implemented in the porting exercise.
 157  *
 158  * Note that unifi_os.h should be included only in unifi.h
 159  */
 160
 161 #include "unifi_os.h"
 162
 163 /*
 164  * Contains the HIP core definitions selected in the porting exercise, such as
 165  * UNIFI_PAD_BULK_DATA_TO_BLOCK_SIZE and UNIFI_PAD_SIGNALS_TO_BLOCK_SIZE.
 166  * Implemented in the OS layer, as part of the porting exersice.
 167  */
 168 #include "unifi_config.h"
 169
 170 #include "csr_wifi_hip_signals.h" /* from this dir */
 171
 172 /*
 173  * The card structure is an opaque pointer that is used to pass context
 174  * to the upper-edge API functions.
 175  */
 176 typedef struct card card_t;
 177
 178
 179 /*
 180  * This structure describes all of the bulk data that 'might' be
 181  * associated with a signal.
 182  */
 183 typedef struct _bulk_data_param
 184 {
 185     bulk_data_desc_t d[UNIFI_MAX_DATA_REFERENCES];
 186 } bulk_data_param_t;
 187
 188
 189 /*
 190  * This structure describes the chip and HIP core lib
 191  * information that exposed to the OS layer.
 192  */
 193 typedef struct _card_info
 194 {
 195     u16 chip_id;
 196     u16 chip_version;
 197     u32 fw_build;
 198     u16 fw_hip_version;
 199     u32 sdio_block_size;
 200 } card_info_t;
 201
 202
 203 /*
 204  * Mini-coredump definitions
 205  */
 206 /* Definition of XAP memory ranges used by the mini-coredump system.
 207  * Note that, these values are NOT the same as UNIFI_REGISTERS, etc
 208  * in unifihw.h which don't allow selection of register areas for each XAP.
 209  */
 210 typedef enum unifi_coredump_space
 211 {
 212     UNIFI_COREDUMP_MAC_REG,
 213     UNIFI_COREDUMP_PHY_REG,
 214     UNIFI_COREDUMP_SH_DMEM,
 215     UNIFI_COREDUMP_MAC_DMEM,
 216     UNIFI_COREDUMP_PHY_DMEM,
 217     UNIFI_COREDUMP_TRIGGER_MAGIC = 0xFEED
 218 } unifi_coredump_space_t;
 219
 220 /* Structure used to request a register value from a mini-coredump buffer */
 221 typedef struct unifi_coredump_req
 222 {
 223     /* From user */
 224     s32               index;       /* 0=newest, -1=oldest */
 225     unifi_coredump_space_t space;       /* memory space */
 226     u32              offset;      /* register offset in space */
 227     /* From driver */
 228     u32 drv_build;                /* Driver build id */
 229     u32 chip_ver;                 /* Chip version */
 230     u32 fw_ver;                   /* Firmware version */
 231     s32  requestor;                /* Requestor: 0=auto dump, 1=manual */
 232     CsrTime   timestamp;                /* time of capture by driver */
 233     u32 serial;                   /* capture serial number */
 234     s32  value;                    /* register value */
 235 } unifi_coredump_req_t;                 /* mini-coredumped reg value request */
 236
 237
 238 /**
 239  * @defgroup upperedge Upper edge API
 240  *
 241  * The following functions are implemented in the HIP core lib.
 242  */
 243
 244 /**
 245  *
 246  * Initialise the HIP core lib.
 247  * Note that the OS layer must initialise the SDIO glue layer and obtain
 248  * an SDIO function context, prior to this call.
 249  *
 250  * @param sdiopriv the SDIO function context.
 251  *
 252  * @param ospriv the OS layer context.
 253  *
 254  * @return \p card_t the HIP core lib API context.
 255  *
 256  * @ingroup upperedge
 257  */
 258 card_t* unifi_alloc_card(CsrSdioFunction *sdiopriv, void *ospriv);
 259
 260
 261 /**
 262  *
 263  * Initialise the UniFi chip.
 264  *
 265  * @param card the HIP core lib API context.
 266  *
 267  * @param led_mask the led mask to apply to UniFi.
 268  *
 269  * @return \b 0 if UniFi is initialized.
 270  *
 271  * @return \b -CSR_EIO if an I/O error occured while initializing UniFi
 272  *
 273  * @return \b -CSR_ENODEV if the card is no longer present.
 274  *
 275  * @ingroup upperedge
 276  */
 277 CsrResult unifi_init_card(card_t *card, s32 led_mask);
 278
 279 /**
 280  *
 281  * De-Initialise the HIP core lib.
 282  *
 283  * @param card the HIP core lib API context.
 284  *
 285  * @ingroup upperedge
 286  */
 287 void unifi_free_card(card_t *card);
 288
 289 /**
 290  *
 291  * Cancel all the signals pending in the HIP core lib.
 292  * Normally used during a system suspend when the power is retained on UniFi.
 293  *
 294  * @param card the HIP core lib API context.
 295  *
 296  * @ingroup upperedge
 297  */
 298 void unifi_cancel_pending_signals(card_t *card);
 299
 300 /**
 301  *
 302  * Send a signal to UniFi.
 303  * Normally it is called from unifi_sys_hip_req() and the OS layer
 304  * Tx data plane.
 305  *
 306  * Note that the bulkdata buffers ownership is passed to the HIP core lib.
 307  * These buffers must be allocated using unifi_net_data_malloc().
 308  *
 309  * @param card the HIP core lib API context.
 310  *
 311  * @param sigptr pointer to the signal.
 312  *
 313  * @param siglen size of the signal.
 314  *
 315  * @param bulkdata pointer to the bulk data associated with the signal.
 316  *
 317  * @return \b 0 signal is sent.
 318  *
 319  * @return \b -CSR_EIO if an error occured while sending the signal
 320  *
 321  * @return \b -CSR_ENODEV if the card is no longer present.
 322  *
 323  * @ingroup upperedge
 324  */
 325 CsrResult unifi_send_signal(card_t *card, const u8 *sigptr,
 326                             u32 siglen,
 327                             const bulk_data_param_t *bulkdata);
 328
 329 /**
 330  *
 331  * Check if the HIP core lib has resources to send a signal.
 332  * Normally there no need to use this function.
 333  *
 334  * @param card the HIP core lib API context.
 335  *
 336  * @param sigptr pointer to the signal.
 337  *
 338  * @return \b 0 if there are resources for the signal.
 339  *
 340  * @return \b -CSR_ENOSPC if there are not enough resources
 341  *
 342  * @ingroup upperedge
 343  */
 344 CsrResult unifi_send_resources_available(card_t *card, const u8 *sigptr);
 345
 346 /**
 347  *
 348  * Read the UniFi chip and the HIP core lib information.
 349  *
 350  * @param card the HIP core lib API context.
 351  *
 352  * @param card_info pointer to save the information.
 353  *
 354  * @ingroup upperedge
 355  */
 356 void unifi_card_info(card_t *card, card_info_t *card_info);
 357
 358 /**
 359  *
 360  * Print the UniFi I/O and Interrupt status.
 361  * Normally it is used for debug purposes only.
 362  *
 363  * @param card the HIP core lib API context.
 364
 365  * @param status buffer for the chip status
 366  *
 367  * @return \b 0 if the check was performed.
 368  *
 369  * @return \b -CSR_EIO if an error occured while checking the status.
 370  *
 371  * @return \b -CSR_ENODEV if the card is no longer present.
 372  *
 373  * @ingroup upperedge
 374  */
 375 CsrResult unifi_check_io_status(card_t *card, s32 *status);
 376
 377
 378 /**
 379  *
 380  * Run the HIP core lib Botton-Half.
 381  * Whenever the HIP core lib want this function to be called
 382  * by the OS layer, it calls unifi_run_bh().
 383  *
 384  * @param card the HIP core lib API context.
 385  *
 386  * @param remaining pointer to return the time (in msecs) that this function
 387  * should be re-scheduled. A return value of 0 means that no re-scheduling
 388  * is required. If unifi_bh() is called before the timeout expires,
 389  * the caller must pass in the remaining time.
 390  *
 391  * @return \b 0 if no error occured.
 392  *
 393  * @return \b -CSR_ENODEV if the card is no longer present.
 394  *
 395  * @return \b -CSR_E* if an error occured while running the bottom half.
 396  *
 397  * @ingroup upperedge
 398  */
 399 CsrResult unifi_bh(card_t *card, u32 *remaining);
 400
 401
 402 /**
 403  * UniFi Low Power Mode (Deep Sleep Signaling)
 404  *
 405  * unifi_low_power_mode defines the UniFi Deep Sleep Signaling status.
 406  * Use with unifi_configure_low_power_mode() to enable/disable
 407  * the Deep Sleep Signaling.
 408  */
 409 enum unifi_low_power_mode
 410 {
 411     UNIFI_LOW_POWER_DISABLED,
 412     UNIFI_LOW_POWER_ENABLED
 413 };
 414
 415 /**
 416  * Periodic Wake Host Mode
 417  *
 418  * unifi_periodic_wake_mode defines the Periodic Wake Host Mode.
 419  * It can only be set to UNIFI_PERIODIC_WAKE_HOST_ENABLED if
 420  * low_power_mode == UNIFI_LOW_POWER_ENABLED.
 421  */
 422 enum unifi_periodic_wake_mode
 423 {
 424     UNIFI_PERIODIC_WAKE_HOST_DISABLED,
 425     UNIFI_PERIODIC_WAKE_HOST_ENABLED
 426 };
 427
 428 /**
 429  *
 430  * Run the HIP core lib Botton-Half.
 431  * Whenever the HIP core lib want this function to be called
 432  * by the OS layer, it calls unifi_run_bh().
 433  *
 434  * Typically, the SME is responsible for configuring these parameters,
 435  * so unifi_sys_configure_power_mode_req() is usually implemented
 436  * as a direct call to unifi_configure_low_power_mode().
 437  *
 438  * Note: When polling mode is used instead of interrupts,
 439  * low_power_mode must never be set to UNIFI_LOW_POWER_ENABLED.
 440  *
 441  * @param card the HIP core lib API context.
 442  *
 443  * @param low_power_mode the Low Power Mode.
 444  *
 445  * @param periodic_wake_mode the Periodic Wake Mode.
 446  *
 447  * @return \b 0 if no error occured.
 448  *
 449  * @return \b -CSR_E* if the request failed.
 450  *
 451  * @ingroup upperedge
 452  */
 453 CsrResult unifi_configure_low_power_mode(card_t                       *card,
 454                                          enum unifi_low_power_mode     low_power_mode,
 455                                          enum unifi_periodic_wake_mode periodic_wake_mode);
 456
 457 /**
 458  *
 459  * Forces the UniFi chip to enter a Deep Sleep state.
 460  * This is normally called by the OS layer when the platform suspends.
 461  *
 462  * Note that if the UniFi Low Power Mode is disabled this call fails.
 463  *
 464  * @param card the HIP core lib API context.
 465  *
 466  * @return \b 0 if no error occured.
 467  *
 468  * @return \b -CSR_ENODEV if the card is no longer present.
 469  *
 470  * @return \b -CSR_E* if the request failed.
 471  *
 472  * @ingroup upperedge
 473  */
 474 CsrResult unifi_force_low_power_mode(card_t *card);
 475
 476 #ifndef CSR_WIFI_HIP_TA_DISABLE
 477 /**
 478  * Configure the Traffic Analysis sampling
 479  *
 480  * Enable or disable statistics gathering.
 481  * Enable or disable particular packet detection.
 482  *
 483  * @param card the HIP core context
 484  * @param config_type the item to configure
 485  * @param config pointer to struct containing config info
 486  *
 487  * @return \b 0 if configuration was successful
 488  *
 489  * @return \b -CSR_EINVAL if a parameter had an invalid value
 490  *
 491  * @ingroup upperedge
 492  */
 493 CsrResult unifi_ta_configure(card_t                               *card,
 494                              CsrWifiRouterCtrlTrafficConfigType    config_type,
 495                              const CsrWifiRouterCtrlTrafficConfig *config);
 496
 497 /**
 498  * Pass a packet for Traffic Analysis sampling
 499  *
 500  * @param card the HIP core context
 501  * @param direction the direction (Rx or Tx) of the frame.
 502  * @param data pointer to bulkdata struct containing the packet
 503  * @param saddr the source address of the packet
 504  * @param sta_macaddr the MAC address of the UniFi chip
 505  * @param timestamp the current time in msecs
 506  *
 507  * @ingroup upperedge
 508  */
 509 void unifi_ta_sample(card_t                            *card,
 510                      CsrWifiRouterCtrlProtocolDirection direction,
 511                      const bulk_data_desc_t            *data,
 512                      const u8                    *saddr,
 513                      const u8                    *sta_macaddr,
 514                      u32                          timestamp,
 515                      u16                          rate);
 516
 517 /**
 518  * Notify the HIP core lib for a detected Traffic Classification.
 519  * Typically, the SME is responsible for configuring these parameters,
 520  * so unifi_sys_traffic_classification_req() is usually implemented
 521  * as a direct call to unifi_ta_classification().
 522  *
 523  * @param card the HIP core context.
 524  * @param traffic_type the detected traffic type.
 525  * @param period The detected period of the traffic.
 526  *
 527  * @ingroup upperedge
 528  */
 529 void unifi_ta_classification(card_t                      *card,
 530                              CsrWifiRouterCtrlTrafficType traffic_type,
 531                              u16                    period);
 532
 533 #endif
 534 /**
 535  * Use software to hard reset the chip.
 536  * This is a subset of the unifi_init_card() functionality and should
 537  * only be used only to reset a paniced chip before a coredump is taken.
 538  *
 539  * @param card the HIP core context.
 540  *
 541  * @ingroup upperedge
 542  */
 543 CsrResult unifi_card_hard_reset(card_t *card);
 544
 545
 546 CsrResult unifi_card_readn(card_t *card, u32 unifi_addr, void *pdata, u16 len);
 547 CsrResult unifi_card_read16(card_t *card, u32 unifi_addr, u16 *pdata);
 548 CsrResult unifi_card_write16(card_t *card, u32 unifi_addr, u16 data);
 549
 550
 551 enum unifi_dbg_processors_select
 552 {
 553     UNIFI_PROC_MAC,
 554     UNIFI_PROC_PHY,
 555     UNIFI_PROC_BT,
 556     UNIFI_PROC_BOTH,
 557     UNIFI_PROC_INVALID
 558 };
 559
 560 CsrResult unifi_card_stop_processor(card_t *card, enum unifi_dbg_processors_select which);
 561
 562 /**
 563  * Call-outs from the HIP core lib to the OS layer.
 564  * The following functions need to be implemented during the porting exercise.
 565  */
 566
 567 /**
 568  * Selects appropriate queue according to priority
 569  * Helps maintain uniformity in queue selection between the HIP
 570  * and the OS layers.
 571  *
 572  * @param priority priority of the packet
 573  *
 574  * @return \b Traffic queue to which a packet of this priority belongs
 575  *
 576  * @ingroup upperedge
 577  */
 578 unifi_TrafficQueue
 579 unifi_frame_priority_to_queue(CSR_PRIORITY priority);
 580
 581 /**
 582  * Returns the priority corresponding to a particular Queue when that is used
 583  * when downgrading a packet to a lower AC.
 584  * Helps maintain uniformity in queue - priority mapping between the HIP
 585  * and the OS layers.
 586  *
 587  * @param queue
 588  *
 589  * @return \b Highest priority corresponding to this queue
 590  *
 591  * @ingroup upperedge
 592  */
 593 CSR_PRIORITY unifi_get_default_downgrade_priority(unifi_TrafficQueue queue);
 594
 595 /**
 596  *
 597  * Flow control callbacks.
 598  * unifi_pause_xmit() is called when the HIP core lib does not have any
 599  * resources to store data packets. The OS layer needs to pause
 600  * the Tx data plane until unifi_restart_xmit() is called.
 601  *
 602  * @param ospriv the OS layer context.
 603  *
 604  * @ingroup upperedge
 605  */
 606 void unifi_pause_xmit(void *ospriv, unifi_TrafficQueue queue);
 607 void unifi_restart_xmit(void *ospriv, unifi_TrafficQueue queue);
 608
 609 /**
 610  *
 611  * Request to run the Bottom-Half.
 612  * The HIP core lib calls this function to request that unifi_bh()
 613  * needs to be run by the OS layer. It can be called anytime, i.e.
 614  * when the unifi_bh() is running.
 615  * Since unifi_bh() is not re-entrant, usually unifi_run_bh() sets
 616  * an event to a thread that schedules a call to unifi_bh().
 617  *
 618  * @param ospriv the OS layer context.
 619  *
 620  * @ingroup upperedge
 621  */
 622 CsrResult unifi_run_bh(void *ospriv);
 623
 624 /**
 625  *
 626  * Delivers a signal received from UniFi to the OS layer.
 627  * Normally, the data signals should be delivered to the data plane
 628  * and all the rest to the SME (unifi_sys_hip_ind()).
 629  *
 630  * Note that the OS layer is responsible for freeing the bulkdata
 631  * buffers, using unifi_net_data_free().
 632  *
 633  * @param ospriv the OS layer context.
 634  *
 635  * @param sigptr pointer to the signal.
 636  *
 637  * @param siglen size of the signal.
 638  *
 639  * @param bulkdata pointer to the bulk data associated with the signal.
 640  *
 641  * @ingroup upperedge
 642  */
 643 void unifi_receive_event(void *ospriv,
 644                          u8 *sigdata, u32 siglen,
 645                          const bulk_data_param_t *bulkdata);
 646
 647 #ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
 648 /**
 649  *
 650  * Used to reque the failed ma packet request back to hal queues
 651  *
 652  * @param ospriv the OS layer context.
 653  *
 654  * @param host_tag host tag for the packet to requeue.
 655  *
 656  * @param bulkDataDesc pointer to the bulk data.
 657  *
 658  * @ingroup upperedge
 659  */
 660 CsrResult unifi_reque_ma_packet_request(void *ospriv, u32 host_tag,
 661                                         u16 status,
 662                                         bulk_data_desc_t *bulkDataDesc);
 663
 664 #endif
 665 typedef struct
 666 {
 667     u16 free_fh_sig_queue_slots[UNIFI_NO_OF_TX_QS];
 668     u16 free_fh_bulkdata_slots;
 669     u16 free_fh_fw_slots;
 670 } unifi_HipQosInfo;
 671
 672 void unifi_get_hip_qos_info(card_t *card, unifi_HipQosInfo *hipqosinfo);
 673
 674
 675 /**
 676  * Functions that read a portion of a firmware file.
 677  *
 678  * Note: If the UniFi chip runs the f/w from ROM, the HIP core may never
 679  * call these functions. Also, the HIP core may call these functions even if
 680  * a f/w file is not available. In this case, it is safe to fail the request.
 681  */
 682 #define UNIFI_FW_STA    1   /* Identify STA firmware file */
 683
 684 /**
 685  *
 686  * Ask the OS layer to initialise a read from a f/w file.
 687  *
 688  * @param ospriv the OS layer context.
 689  *
 690  * @param is_fw if 0 the request if for the loader file, if 1 the request
 691  * is for a f/w file.
 692  *
 693  * @param info a card_info_t structure containing versions information.
 694  * Note that some members of the structure may not be initialised.
 695  *
 696  * @return \p NULL if the file is not available, or a pointer which contains
 697  * OS specific information for the file (typically the contents of the file)
 698  * that the HIP core uses when calling unifi_fw_read() and unifi_fw_read_stop()
 699  *
 700  * @ingroup upperedge
 701  */
 702 void* unifi_fw_read_start(void *ospriv, s8 is_fw, const card_info_t *info);
 703
 704 /**
 705  *
 706  * Ask the OS layer to return a portion from a f/w file.
 707  *
 708  * @param ospriv the OS layer context.
 709  *
 710  * @param arg the OS pointer returned by unifi_fw_read_start().
 711  *
 712  * @param offset the offset in the f/w file to read the read from.
 713  *
 714  * @param buf the buffer to store the returned data.
 715  *
 716  * @param len the size in bytes of the requested read.
 717  *
 718  * @ingroup upperedge
 719  */
 720 s32 unifi_fw_read(void *ospriv, void *arg, u32 offset, void *buf, u32 len);
 721
 722 /**
 723  *
 724  * Ask the OS layer to finish reading from a f/w file.
 725  *
 726  * @param ospriv the OS layer context.
 727  *
 728  * @param dlpriv the OS pointer returned by unifi_fw_read_start().
 729  *
 730  * @ingroup upperedge
 731  */
 732 void unifi_fw_read_stop(void *ospriv, void *dlpriv);
 733
 734 /**
 735  *
 736  * Ask OS layer for a handle to a dynamically allocated firmware buffer
 737  * (primarily intended for production test images which may need conversion)
 738  *
 739  * @param ospriv the OS layer context.
 740  *
 741  * @param fwbuf pointer to dynamically allocated buffer
 742  *
 743  * @param len length of provided buffer in bytes
 744  *
 745  * @ingroup upperedge
 746  */
 747 void* unifi_fw_open_buffer(void *ospriv, void *fwbuf, u32 len);
 748
 749 /**
 750  *
 751  * Release a handle to a dynamically allocated firmware buffer
 752  * (primarily intended for production test images which may need conversion)
 753  *
 754  * @param ospriv the OS layer context.
 755  *
 756  * @param fwbuf pointer to dynamically allocated buffer
 757  *
 758  * @ingroup upperedge
 759  */
 760 void unifi_fw_close_buffer(void *ospriv, void *fwbuf);
 761
 762 #ifndef CSR_WIFI_HIP_TA_DISABLE
 763 /*
 764  * Driver must provide these.
 765  *
 766  * A simple implementation will just call
 767  * unifi_sys_traffic_protocol_ind() or unifi_sys_traffic_classification_ind()
 768  * respectively. See sme_csr_userspace/sme_userspace.c.
 769  */
 770 /**
 771  *
 772  * Indicates a detected packet of type packet_type.
 773  * Typically, this information is processed by the SME so
 774  * unifi_ta_indicate_protocol() needs to schedule a call to
 775  * unifi_sys_traffic_protocol_ind().
 776  *
 777  * @param ospriv the OS layer context.
 778  *
 779  * @param packet_type the detected packet type.
 780  *
 781  * @param direction the direction of the packet (Rx, Tx).
 782  *
 783  * @param src_addr the source address of the packet.
 784  *
 785  * @ingroup upperedge
 786  */
 787 void unifi_ta_indicate_protocol(void                              *ospriv,
 788                                 CsrWifiRouterCtrlTrafficPacketType packet_type,
 789                                 CsrWifiRouterCtrlProtocolDirection direction,
 790                                 const CsrWifiMacAddress           *src_addr);
 791
 792 /**
 793  *
 794  * Indicates statistics for the sample data over a period.
 795  * Typically, this information is processed by the SME so
 796  * unifi_ta_indicate_sampling() needs to schedule a call to
 797  * unifi_sys_traffic_sample_ind().
 798  *
 799  * @param ospriv the OS layer context.
 800  *
 801  * @param stats the pointer to the structure that contains the statistics.
 802  *
 803  * @ingroup upperedge
 804  */
 805 void unifi_ta_indicate_sampling(void *ospriv, CsrWifiRouterCtrlTrafficStats *stats);
 806 void unifi_ta_indicate_l4stats(void     *ospriv,
 807                                u32 rxTcpThroughput,
 808                                u32 txTcpThroughput,
 809                                u32 rxUdpThroughput,
 810                                u32 txUdpThroughput);
 811 #endif
 812
 813 void unifi_rx_queue_flush(void *ospriv);
 814
 815 /**
 816  * Call-out from the SDIO glue layer.
 817  *
 818  * The glue layer needs to call unifi_sdio_interrupt_handler() every time
 819  * an interrupts occurs.
 820  *
 821  * @param card the HIP core context.
 822  *
 823  * @ingroup bottomedge
 824  */
 825 void unifi_sdio_interrupt_handler(card_t *card);
 826
 827
 828 /* HELPER FUNCTIONS */
 829
 830 /*
 831  * unifi_init() and unifi_download() implement a subset of unifi_init_card functionality
 832  * that excludes HIP initialization.
 833  */
 834 CsrResult unifi_init(card_t *card);
 835 CsrResult unifi_download(card_t *card, s32 led_mask);
 836
 837 /*
 838  * unifi_start_processors() ensures both on-chip processors are running
 839  */
 840 CsrResult unifi_start_processors(card_t *card);
 841
 842 CsrResult unifi_capture_panic(card_t *card);
 843
 844 /*
 845  * Configure HIP interrupt processing mode
 846  */
 847 #define CSR_WIFI_INTMODE_DEFAULT        0
 848 #define CSR_WIFI_INTMODE_RUN_BH_ONCE    1       /* Run BH once per interrupt */
 849
 850 void unifi_set_interrupt_mode(card_t *card, u32 mode);
 851
 852 /*
 853  * unifi_request_max_clock() requests that max SDIO clock speed is set at the
 854  * next suitable opportunity.
 855  */
 856 void unifi_request_max_sdio_clock(card_t *card);
 857
 858
 859 /* Functions to lookup bulk data command names. */
 860 const char* lookup_bulkcmd_name(u16 id);
 861
 862 /* Function to log HIP's global debug buffer */
 863 #ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
 864 void unifi_debug_buf_dump(void);
 865 void unifi_debug_log_to_buf(const char *fmt, ...);
 866 void unifi_debug_hex_to_buf(const char *buff, u16 length);
 867 #endif
 868
 869 /* Mini-coredump utility functions */
 870 CsrResult unifi_coredump_get_value(card_t *card, struct unifi_coredump_req *req);
 871 CsrResult unifi_coredump_capture(card_t *card, struct unifi_coredump_req *req);
 872 CsrResult unifi_coredump_request_at_next_reset(card_t *card, s8 enable);
 873 CsrResult unifi_coredump_init(card_t *card, u16 num_dump_buffers);
 874 void unifi_coredump_free(card_t *card);
 875
 876 #ifdef __cplusplus
 877 }
 878 #endif
 879
 880 #endif /* __CSR_WIFI_HIP_UNIFI_H__ */