Root/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
24extern "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 */
119typedef 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 */
138typedef 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). */
147typedef 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 */
176typedef 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 */
183typedef 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 */
193typedef 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 */
210typedef 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 */
221typedef 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 */
258card_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 */
277CsrResult 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 */
287void 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 */
298void 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 */
325CsrResult 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 */
344CsrResult 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 */
356void 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 */
375CsrResult 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 */
399CsrResult 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 */
409enum 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 */
422enum 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 */
453CsrResult 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 */
474CsrResult 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 */
493CsrResult 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 */
509void 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 */
529void 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 */
543CsrResult unifi_card_hard_reset(card_t *card);
544
545
546CsrResult unifi_card_readn(card_t *card, u32 unifi_addr, void *pdata, u16 len);
547CsrResult unifi_card_read16(card_t *card, u32 unifi_addr, u16 *pdata);
548CsrResult unifi_card_write16(card_t *card, u32 unifi_addr, u16 data);
549
550
551enum 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
560CsrResult 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 */
578unifi_TrafficQueue
579unifi_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 */
593CSR_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 */
606void unifi_pause_xmit(void *ospriv, unifi_TrafficQueue queue);
607void 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 */
622CsrResult 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 */
643void 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 */
660CsrResult unifi_reque_ma_packet_request(void *ospriv, u32 host_tag,
661                                        u16 status,
662                                        bulk_data_desc_t *bulkDataDesc);
663
664#endif
665typedef 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
672void 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 */
702void* 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 */
720s32 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 */
732void 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 */
747void* 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 */
760void 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 */
787void 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 */
805void unifi_ta_indicate_sampling(void *ospriv, CsrWifiRouterCtrlTrafficStats *stats);
806void unifi_ta_indicate_l4stats(void *ospriv,
807                               u32 rxTcpThroughput,
808                               u32 txTcpThroughput,
809                               u32 rxUdpThroughput,
810                               u32 txUdpThroughput);
811#endif
812
813void 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 */
825void 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 */
834CsrResult unifi_init(card_t *card);
835CsrResult unifi_download(card_t *card, s32 led_mask);
836
837/*
838 * unifi_start_processors() ensures both on-chip processors are running
839 */
840CsrResult unifi_start_processors(card_t *card);
841
842CsrResult 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
850void 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 */
856void unifi_request_max_sdio_clock(card_t *card);
857
858
859/* Functions to lookup bulk data command names. */
860const char* lookup_bulkcmd_name(u16 id);
861
862/* Function to log HIP's global debug buffer */
863#ifdef CSR_WIFI_HIP_DEBUG_OFFLINE
864void unifi_debug_buf_dump(void);
865void unifi_debug_log_to_buf(const char *fmt, ...);
866void unifi_debug_hex_to_buf(const char *buff, u16 length);
867#endif
868
869/* Mini-coredump utility functions */
870CsrResult unifi_coredump_get_value(card_t *card, struct unifi_coredump_req *req);
871CsrResult unifi_coredump_capture(card_t *card, struct unifi_coredump_req *req);
872CsrResult unifi_coredump_request_at_next_reset(card_t *card, s8 enable);
873CsrResult unifi_coredump_init(card_t *card, u16 num_dump_buffers);
874void unifi_coredump_free(card_t *card);
875
876#ifdef __cplusplus
877}
878#endif
879
880#endif /* __CSR_WIFI_HIP_UNIFI_H__ */
881

Archive Download this file



interactive