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