1 /*****************************************************************************
3 (c) Cambridge Silicon Radio Limited 2012
4 All rights reserved and confidential information of CSR
6 Refer to LICENSE.txt included with this source for details
9 *****************************************************************************/
12 * ---------------------------------------------------------------------------
14 * FILE : csr_wifi_hip_unifi.h
16 * PURPOSE : Public API for the UniFi HIP core library.
18 * ---------------------------------------------------------------------------
20 #ifndef __CSR_WIFI_HIP_UNIFI_H__
21 #define __CSR_WIFI_HIP_UNIFI_H__ 1
27 #ifndef CSR_WIFI_HIP_TA_DISABLE
28 #include "csr_wifi_router_ctrl_prim.h"
29 #include "csr_wifi_router_prim.h"
34 /* SDIO chip ID numbers */
37 #define SDIO_MANF_ID_CSR 0x032a
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
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
51 /* Maximum SDIO bus clock supported. */
52 #define UNIFI_SDIO_CLOCK_MAX_HZ 50000000 /* Hz */
55 * Initialisation SDIO bus clock.
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.
61 #define UNIFI_SDIO_CLOCK_INIT_HZ 12500000 /* Hz */
64 * Safe SDIO bus clock.
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).
69 #define UNIFI_SDIO_CLOCK_SAFE_HZ 1000000 /* Hz */
71 /* I/O default block size to use for UniFi. */
72 #define UNIFI_IO_BLOCK_SIZE 64
74 #define UNIFI_WOL_OFF 0
75 #define UNIFI_WOL_SDIO 1
76 #define UNIFI_WOL_PIO 2
78 /* The number of Tx traffic queues */
79 #define UNIFI_NO_OF_TX_QS 4
81 #define CSR_WIFI_HIP_RESERVED_HOST_TAG 0xFFFFFFFF
84 * The number of slots in the from-host queues.
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.
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.
93 * Queues are ring buffers and so must always have 1 unused slot.
95 #define UNIFI_SOFT_TRAFFIC_Q_LENGTH (20 + 1)
96 #define UNIFI_SOFT_COMMAND_Q_LENGTH (16 + 1)
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_wifi_result.h"
103 /* Utility MACROS. Note that UNIFI_MAC_ADDRESS_CMP returns TRUE on success */
104 #define UNIFI_MAC_ADDRESS_COPY(dst, src) \
105 do { (dst)[0] = (src)[0]; (dst)[1] = (src)[1]; \
106 (dst)[2] = (src)[2]; (dst)[3] = (src)[3]; \
107 (dst)[4] = (src)[4]; (dst)[5] = (src)[5]; \
110 #define UNIFI_MAC_ADDRESS_CMP(addr1, addr2) \
111 (((addr1)[0] == (addr2)[0]) && ((addr1)[1] == (addr2)[1]) && \
112 ((addr1)[2] == (addr2)[2]) && ((addr1)[3] == (addr2)[3]) && \
113 ((addr1)[4] == (addr2)[4]) && ((addr1)[5] == (addr2)[5]))
115 /* Traffic queue ordered according to priority
116 * EAPOL/Uncontrolled port Queue should be the last
120 UNIFI_TRAFFIC_Q_BK = 0,
124 UNIFI_TRAFFIC_Q_EAPOL, /* Non existant in HIP */
125 UNIFI_TRAFFIC_Q_MAX, /* Non existant */
126 UNIFI_TRAFFIC_Q_MLME /* Non existant */
127 } unifi_TrafficQueue;
130 * Structure describing a bulk data slot.
131 * This structure is shared between the HIP core library and the OS
132 * layer. See the definition of unifi_net_data_malloc() for more details.
134 * The data_length field is used to indicate empty/occupied state.
135 * Needs to be defined before #include "unifi_os.h".
137 typedef struct _bulk_data_desc
139 const u8 *os_data_ptr;
141 const void *os_net_buf_ptr;
145 /* Structure of an entry in the Symbol Look Up Table (SLUT). */
146 typedef struct _symbol
153 * Header files need to be included from the current directory,
154 * the SME library, the synergy framework and the OS layer.
155 * A thin OS layer needs to be implemented in the porting exercise.
157 * Note that unifi_os.h should be included only in unifi.h
160 #include "unifi_os.h"
163 * Contains the HIP core definitions selected in the porting exercise, such as
164 * UNIFI_PAD_BULK_DATA_TO_BLOCK_SIZE and UNIFI_PAD_SIGNALS_TO_BLOCK_SIZE.
165 * Implemented in the OS layer, as part of the porting exersice.
167 #include "unifi_config.h"
169 #include "csr_wifi_hip_signals.h" /* from this dir */
172 * The card structure is an opaque pointer that is used to pass context
173 * to the upper-edge API functions.
175 typedef struct card card_t;
179 * This structure describes all of the bulk data that 'might' be
180 * associated with a signal.
182 typedef struct _bulk_data_param
184 bulk_data_desc_t d[UNIFI_MAX_DATA_REFERENCES];
189 * This structure describes the chip and HIP core lib
190 * information that exposed to the OS layer.
192 typedef struct _card_info
203 * Mini-coredump definitions
205 /* Definition of XAP memory ranges used by the mini-coredump system.
206 * Note that, these values are NOT the same as UNIFI_REGISTERS, etc
207 * in unifihw.h which don't allow selection of register areas for each XAP.
209 typedef enum unifi_coredump_space
211 UNIFI_COREDUMP_MAC_REG,
212 UNIFI_COREDUMP_PHY_REG,
213 UNIFI_COREDUMP_SH_DMEM,
214 UNIFI_COREDUMP_MAC_DMEM,
215 UNIFI_COREDUMP_PHY_DMEM,
216 UNIFI_COREDUMP_TRIGGER_MAGIC = 0xFEED
217 } unifi_coredump_space_t;
219 /* Structure used to request a register value from a mini-coredump buffer */
220 typedef struct unifi_coredump_req
223 s32 index; /* 0=newest, -1=oldest */
224 unifi_coredump_space_t space; /* memory space */
225 u32 offset; /* register offset in space */
227 u32 drv_build; /* Driver build id */
228 u32 chip_ver; /* Chip version */
229 u32 fw_ver; /* Firmware version */
230 s32 requestor; /* Requestor: 0=auto dump, 1=manual */
231 CsrTime timestamp; /* time of capture by driver */
232 u32 serial; /* capture serial number */
233 s32 value; /* register value */
234 } unifi_coredump_req_t; /* mini-coredumped reg value request */
238 * @defgroup upperedge Upper edge API
240 * The following functions are implemented in the HIP core lib.
245 * Initialise the HIP core lib.
246 * Note that the OS layer must initialise the SDIO glue layer and obtain
247 * an SDIO function context, prior to this call.
249 * @param sdiopriv the SDIO function context.
251 * @param ospriv the OS layer context.
253 * @return \p card_t the HIP core lib API context.
257 card_t* unifi_alloc_card(CsrSdioFunction *sdiopriv, void *ospriv);
262 * Initialise the UniFi chip.
264 * @param card the HIP core lib API context.
266 * @param led_mask the led mask to apply to UniFi.
268 * @return \b 0 if UniFi is initialized.
270 * @return \b -CSR_EIO if an I/O error occured while initializing UniFi
272 * @return \b -CSR_ENODEV if the card is no longer present.
276 CsrResult unifi_init_card(card_t *card, s32 led_mask);
280 * De-Initialise the HIP core lib.
282 * @param card the HIP core lib API context.
286 void unifi_free_card(card_t *card);
290 * Cancel all the signals pending in the HIP core lib.
291 * Normally used during a system suspend when the power is retained on UniFi.
293 * @param card the HIP core lib API context.
297 void unifi_cancel_pending_signals(card_t *card);
301 * Send a signal to UniFi.
302 * Normally it is called from unifi_sys_hip_req() and the OS layer
305 * Note that the bulkdata buffers ownership is passed to the HIP core lib.
306 * These buffers must be allocated using unifi_net_data_malloc().
308 * @param card the HIP core lib API context.
310 * @param sigptr pointer to the signal.
312 * @param siglen size of the signal.
314 * @param bulkdata pointer to the bulk data associated with the signal.
316 * @return \b 0 signal is sent.
318 * @return \b -CSR_EIO if an error occured while sending the signal
320 * @return \b -CSR_ENODEV if the card is no longer present.
324 CsrResult unifi_send_signal(card_t *card, const u8 *sigptr,
326 const bulk_data_param_t *bulkdata);
330 * Check if the HIP core lib has resources to send a signal.
331 * Normally there no need to use this function.
333 * @param card the HIP core lib API context.
335 * @param sigptr pointer to the signal.
337 * @return \b 0 if there are resources for the signal.
339 * @return \b -CSR_ENOSPC if there are not enough resources
343 CsrResult unifi_send_resources_available(card_t *card, const u8 *sigptr);
347 * Read the UniFi chip and the HIP core lib information.
349 * @param card the HIP core lib API context.
351 * @param card_info pointer to save the information.
355 void unifi_card_info(card_t *card, card_info_t *card_info);
359 * Print the UniFi I/O and Interrupt status.
360 * Normally it is used for debug purposes only.
362 * @param card the HIP core lib API context.
364 * @param status buffer for the chip status
366 * @return \b 0 if the check was performed.
368 * @return \b -CSR_EIO if an error occured while checking the status.
370 * @return \b -CSR_ENODEV if the card is no longer present.
374 CsrResult unifi_check_io_status(card_t *card, s32 *status);
379 * Run the HIP core lib Botton-Half.
380 * Whenever the HIP core lib want this function to be called
381 * by the OS layer, it calls unifi_run_bh().
383 * @param card the HIP core lib API context.
385 * @param remaining pointer to return the time (in msecs) that this function
386 * should be re-scheduled. A return value of 0 means that no re-scheduling
387 * is required. If unifi_bh() is called before the timeout expires,
388 * the caller must pass in the remaining time.
390 * @return \b 0 if no error occured.
392 * @return \b -CSR_ENODEV if the card is no longer present.
394 * @return \b -CSR_E* if an error occured while running the bottom half.
398 CsrResult unifi_bh(card_t *card, u32 *remaining);
402 * UniFi Low Power Mode (Deep Sleep Signaling)
404 * unifi_low_power_mode defines the UniFi Deep Sleep Signaling status.
405 * Use with unifi_configure_low_power_mode() to enable/disable
406 * the Deep Sleep Signaling.
408 enum unifi_low_power_mode
410 UNIFI_LOW_POWER_DISABLED,
411 UNIFI_LOW_POWER_ENABLED
415 * Periodic Wake Host Mode
417 * unifi_periodic_wake_mode defines the Periodic Wake Host Mode.
418 * It can only be set to UNIFI_PERIODIC_WAKE_HOST_ENABLED if
419 * low_power_mode == UNIFI_LOW_POWER_ENABLED.
421 enum unifi_periodic_wake_mode
423 UNIFI_PERIODIC_WAKE_HOST_DISABLED,
424 UNIFI_PERIODIC_WAKE_HOST_ENABLED
429 * Run the HIP core lib Botton-Half.
430 * Whenever the HIP core lib want this function to be called
431 * by the OS layer, it calls unifi_run_bh().
433 * Typically, the SME is responsible for configuring these parameters,
434 * so unifi_sys_configure_power_mode_req() is usually implemented
435 * as a direct call to unifi_configure_low_power_mode().
437 * Note: When polling mode is used instead of interrupts,
438 * low_power_mode must never be set to UNIFI_LOW_POWER_ENABLED.
440 * @param card the HIP core lib API context.
442 * @param low_power_mode the Low Power Mode.
444 * @param periodic_wake_mode the Periodic Wake Mode.
446 * @return \b 0 if no error occured.
448 * @return \b -CSR_E* if the request failed.
452 CsrResult unifi_configure_low_power_mode(card_t *card,
453 enum unifi_low_power_mode low_power_mode,
454 enum unifi_periodic_wake_mode periodic_wake_mode);
458 * Forces the UniFi chip to enter a Deep Sleep state.
459 * This is normally called by the OS layer when the platform suspends.
461 * Note that if the UniFi Low Power Mode is disabled this call fails.
463 * @param card the HIP core lib API context.
465 * @return \b 0 if no error occured.
467 * @return \b -CSR_ENODEV if the card is no longer present.
469 * @return \b -CSR_E* if the request failed.
473 CsrResult unifi_force_low_power_mode(card_t *card);
475 #ifndef CSR_WIFI_HIP_TA_DISABLE
477 * Configure the Traffic Analysis sampling
479 * Enable or disable statistics gathering.
480 * Enable or disable particular packet detection.
482 * @param card the HIP core context
483 * @param config_type the item to configure
484 * @param config pointer to struct containing config info
486 * @return \b 0 if configuration was successful
488 * @return \b -CSR_EINVAL if a parameter had an invalid value
492 CsrResult unifi_ta_configure(card_t *card,
493 CsrWifiRouterCtrlTrafficConfigType config_type,
494 const CsrWifiRouterCtrlTrafficConfig *config);
497 * Pass a packet for Traffic Analysis sampling
499 * @param card the HIP core context
500 * @param direction the direction (Rx or Tx) of the frame.
501 * @param data pointer to bulkdata struct containing the packet
502 * @param saddr the source address of the packet
503 * @param sta_macaddr the MAC address of the UniFi chip
504 * @param timestamp the current time in msecs
508 void unifi_ta_sample(card_t *card,
509 CsrWifiRouterCtrlProtocolDirection direction,
510 const bulk_data_desc_t *data,
512 const u8 *sta_macaddr,
517 * Notify the HIP core lib for a detected Traffic Classification.
518 * Typically, the SME is responsible for configuring these parameters,
519 * so unifi_sys_traffic_classification_req() is usually implemented
520 * as a direct call to unifi_ta_classification().
522 * @param card the HIP core context.
523 * @param traffic_type the detected traffic type.
524 * @param period The detected period of the traffic.
528 void unifi_ta_classification(card_t *card,
529 CsrWifiRouterCtrlTrafficType traffic_type,
534 * Use software to hard reset the chip.
535 * This is a subset of the unifi_init_card() functionality and should
536 * only be used only to reset a paniced chip before a coredump is taken.
538 * @param card the HIP core context.
542 CsrResult unifi_card_hard_reset(card_t *card);
545 CsrResult unifi_card_readn(card_t *card, u32 unifi_addr, void *pdata, u16 len);
546 CsrResult unifi_card_read16(card_t *card, u32 unifi_addr, u16 *pdata);
547 CsrResult unifi_card_write16(card_t *card, u32 unifi_addr, u16 data);
550 enum unifi_dbg_processors_select
559 CsrResult unifi_card_stop_processor(card_t *card, enum unifi_dbg_processors_select which);
562 * Call-outs from the HIP core lib to the OS layer.
563 * The following functions need to be implemented during the porting exercise.
567 * Selects appropriate queue according to priority
568 * Helps maintain uniformity in queue selection between the HIP
571 * @param priority priority of the packet
573 * @return \b Traffic queue to which a packet of this priority belongs
578 unifi_frame_priority_to_queue(CSR_PRIORITY priority);
581 * Returns the priority corresponding to a particular Queue when that is used
582 * when downgrading a packet to a lower AC.
583 * Helps maintain uniformity in queue - priority mapping between the HIP
588 * @return \b Highest priority corresponding to this queue
592 CSR_PRIORITY unifi_get_default_downgrade_priority(unifi_TrafficQueue queue);
596 * Flow control callbacks.
597 * unifi_pause_xmit() is called when the HIP core lib does not have any
598 * resources to store data packets. The OS layer needs to pause
599 * the Tx data plane until unifi_restart_xmit() is called.
601 * @param ospriv the OS layer context.
605 void unifi_pause_xmit(void *ospriv, unifi_TrafficQueue queue);
606 void unifi_restart_xmit(void *ospriv, unifi_TrafficQueue queue);
610 * Request to run the Bottom-Half.
611 * The HIP core lib calls this function to request that unifi_bh()
612 * needs to be run by the OS layer. It can be called anytime, i.e.
613 * when the unifi_bh() is running.
614 * Since unifi_bh() is not re-entrant, usually unifi_run_bh() sets
615 * an event to a thread that schedules a call to unifi_bh().
617 * @param ospriv the OS layer context.
621 CsrResult unifi_run_bh(void *ospriv);
625 * Delivers a signal received from UniFi to the OS layer.
626 * Normally, the data signals should be delivered to the data plane
627 * and all the rest to the SME (unifi_sys_hip_ind()).
629 * Note that the OS layer is responsible for freeing the bulkdata
630 * buffers, using unifi_net_data_free().
632 * @param ospriv the OS layer context.
634 * @param sigptr pointer to the signal.
636 * @param siglen size of the signal.
638 * @param bulkdata pointer to the bulk data associated with the signal.
642 void unifi_receive_event(void *ospriv,
643 u8 *sigdata, u32 siglen,
644 const bulk_data_param_t *bulkdata);
646 #ifdef CSR_WIFI_REQUEUE_PACKET_TO_HAL
649 * Used to reque the failed ma packet request back to hal queues
651 * @param ospriv the OS layer context.
653 * @param host_tag host tag for the packet to requeue.
655 * @param bulkDataDesc pointer to the bulk data.
659 CsrResult unifi_reque_ma_packet_request(void *ospriv, u32 host_tag,
661 bulk_data_desc_t *bulkDataDesc);
666 u16 free_fh_sig_queue_slots[UNIFI_NO_OF_TX_QS];
667 u16 free_fh_bulkdata_slots;
668 u16 free_fh_fw_slots;
671 void unifi_get_hip_qos_info(card_t *card, unifi_HipQosInfo *hipqosinfo);
675 * Functions that read a portion of a firmware file.
677 * Note: If the UniFi chip runs the f/w from ROM, the HIP core may never
678 * call these functions. Also, the HIP core may call these functions even if
679 * a f/w file is not available. In this case, it is safe to fail the request.
681 #define UNIFI_FW_STA 1 /* Identify STA firmware file */
685 * Ask the OS layer to initialise a read from a f/w file.
687 * @param ospriv the OS layer context.
689 * @param is_fw if 0 the request if for the loader file, if 1 the request
692 * @param info a card_info_t structure containing versions information.
693 * Note that some members of the structure may not be initialised.
695 * @return \p NULL if the file is not available, or a pointer which contains
696 * OS specific information for the file (typically the contents of the file)
697 * that the HIP core uses when calling unifi_fw_read() and unifi_fw_read_stop()
701 void* unifi_fw_read_start(void *ospriv, s8 is_fw, const card_info_t *info);
705 * Ask the OS layer to return a portion from a f/w file.
707 * @param ospriv the OS layer context.
709 * @param arg the OS pointer returned by unifi_fw_read_start().
711 * @param offset the offset in the f/w file to read the read from.
713 * @param buf the buffer to store the returned data.
715 * @param len the size in bytes of the requested read.
719 s32 unifi_fw_read(void *ospriv, void *arg, u32 offset, void *buf, u32 len);
723 * Ask the OS layer to finish reading from a f/w file.
725 * @param ospriv the OS layer context.
727 * @param dlpriv the OS pointer returned by unifi_fw_read_start().
731 void unifi_fw_read_stop(void *ospriv, void *dlpriv);
735 * Ask OS layer for a handle to a dynamically allocated firmware buffer
736 * (primarily intended for production test images which may need conversion)
738 * @param ospriv the OS layer context.
740 * @param fwbuf pointer to dynamically allocated buffer
742 * @param len length of provided buffer in bytes
746 void* unifi_fw_open_buffer(void *ospriv, void *fwbuf, u32 len);
750 * Release a handle to a dynamically allocated firmware buffer
751 * (primarily intended for production test images which may need conversion)
753 * @param ospriv the OS layer context.
755 * @param fwbuf pointer to dynamically allocated buffer
759 void unifi_fw_close_buffer(void *ospriv, void *fwbuf);
761 #ifndef CSR_WIFI_HIP_TA_DISABLE
763 * Driver must provide these.
765 * A simple implementation will just call
766 * unifi_sys_traffic_protocol_ind() or unifi_sys_traffic_classification_ind()
767 * respectively. See sme_csr_userspace/sme_userspace.c.
771 * Indicates a detected packet of type packet_type.
772 * Typically, this information is processed by the SME so
773 * unifi_ta_indicate_protocol() needs to schedule a call to
774 * unifi_sys_traffic_protocol_ind().
776 * @param ospriv the OS layer context.
778 * @param packet_type the detected packet type.
780 * @param direction the direction of the packet (Rx, Tx).
782 * @param src_addr the source address of the packet.
786 void unifi_ta_indicate_protocol(void *ospriv,
787 CsrWifiRouterCtrlTrafficPacketType packet_type,
788 CsrWifiRouterCtrlProtocolDirection direction,
789 const CsrWifiMacAddress *src_addr);
793 * Indicates statistics for the sample data over a period.
794 * Typically, this information is processed by the SME so
795 * unifi_ta_indicate_sampling() needs to schedule a call to
796 * unifi_sys_traffic_sample_ind().
798 * @param ospriv the OS layer context.
800 * @param stats the pointer to the structure that contains the statistics.
804 void unifi_ta_indicate_sampling(void *ospriv, CsrWifiRouterCtrlTrafficStats *stats);
805 void unifi_ta_indicate_l4stats(void *ospriv,
809 u32 txUdpThroughput);
812 void unifi_rx_queue_flush(void *ospriv);
815 * Call-out from the SDIO glue layer.
817 * The glue layer needs to call unifi_sdio_interrupt_handler() every time
818 * an interrupts occurs.
820 * @param card the HIP core context.
822 * @ingroup bottomedge
824 void unifi_sdio_interrupt_handler(card_t *card);
827 /* HELPER FUNCTIONS */
830 * unifi_init() and unifi_download() implement a subset of unifi_init_card functionality
831 * that excludes HIP initialization.
833 CsrResult unifi_init(card_t *card);
834 CsrResult unifi_download(card_t *card, s32 led_mask);
837 * unifi_start_processors() ensures both on-chip processors are running
839 CsrResult unifi_start_processors(card_t *card);
841 CsrResult unifi_capture_panic(card_t *card);
844 * Configure HIP interrupt processing mode
846 #define CSR_WIFI_INTMODE_DEFAULT 0
847 #define CSR_WIFI_INTMODE_RUN_BH_ONCE 1 /* Run BH once per interrupt */
849 void unifi_set_interrupt_mode(card_t *card, u32 mode);
852 * unifi_request_max_clock() requests that max SDIO clock speed is set at the
853 * next suitable opportunity.
855 void unifi_request_max_sdio_clock(card_t *card);
858 /* Functions to lookup bulk data command names. */
859 const char* lookup_bulkcmd_name(u16 id);
861 /* Function to log HIP's global debug buffer */
862 #ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
863 void unifi_debug_buf_dump(void);
864 void unifi_debug_log_to_buf(const char *fmt, ...);
865 void unifi_debug_hex_to_buf(const char *buff, u16 length);
868 /* Mini-coredump utility functions */
869 CsrResult unifi_coredump_get_value(card_t *card, struct unifi_coredump_req *req);
870 CsrResult unifi_coredump_capture(card_t *card, struct unifi_coredump_req *req);
871 CsrResult unifi_coredump_request_at_next_reset(card_t *card, s8 enable);
872 CsrResult unifi_coredump_init(card_t *card, u16 num_dump_buffers);
873 void unifi_coredump_free(card_t *card);
879 #endif /* __CSR_WIFI_HIP_UNIFI_H__ */