linux/drivers/staging/rtl8723bs/core/rtw_xmit.c

// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
 *
 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
 *
 ******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>

static u8 P802_1H_OUI[P80211_OUI_LEN] =;
static u8 RFC1042_OUI[P80211_OUI_LEN] =;

static void _init_txservq(struct tx_servq *ptxservq)
{}

void _rtw_init_sta_xmit_priv(struct sta_xmit_priv *psta_xmitpriv)
{}

s32 _rtw_init_xmit_priv(struct xmit_priv *pxmitpriv, struct adapter *padapter)
{}

void _rtw_free_xmit_priv(struct xmit_priv *pxmitpriv)
{}

u8 query_ra_short_GI(struct sta_info *psta)
{}

static void update_attrib_vcs_info(struct adapter *padapter, struct xmit_frame *pxmitframe)
{}

static void update_attrib_phy_info(struct adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta)
{}

static s32 update_attrib_sec_info(struct adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta)
{}

u8 qos_acm(u8 acm_mask, u8 priority)
{}

static void set_qos(struct pkt_file *ppktfile, struct pkt_attrib *pattrib)
{}

static s32 update_attrib(struct adapter *padapter, struct sk_buff *pkt, struct pkt_attrib *pattrib)
{}

static s32 xmitframe_addmic(struct adapter *padapter, struct xmit_frame *pxmitframe)
{}

static s32 xmitframe_swencrypt(struct adapter *padapter, struct xmit_frame *pxmitframe)
{}

s32 rtw_make_wlanhdr(struct adapter *padapter, u8 *hdr, struct pkt_attrib *pattrib)
{}

s32 rtw_txframes_pending(struct adapter *padapter)
{}

/*
 * Calculate wlan 802.11 packet MAX size from pkt_attrib
 * This function doesn't consider fragment case
 */
u32 rtw_calculate_wlan_pkt_size_by_attribue(struct pkt_attrib *pattrib)
{}

/*
 * This sub-routine will perform all the following:
 * 1. remove 802.3 header.
 * 2. create wlan_header, based on the info in pxmitframe
 * 3. append sta's iv/ext-iv
 * 4. append LLC
 * 5. move frag chunk from pframe to pxmitframe->mem
 * 6. apply sw-encrypt, if necessary.
 */
s32 rtw_xmitframe_coalesce(struct adapter *padapter, struct sk_buff *pkt, struct xmit_frame *pxmitframe)
{}

/* broadcast or multicast management pkt use BIP, unicast management pkt use CCMP encryption */
s32 rtw_mgmt_xmitframe_coalesce(struct adapter *padapter, struct sk_buff *pkt, struct xmit_frame *pxmitframe)
{}

/* Logical Link Control(LLC) SubNetwork Attachment Point(SNAP) header
 * IEEE LLC/SNAP header contains 8 octets
 * First 3 octets comprise the LLC portion
 * SNAP portion, 5 octets, is divided into two fields:
 *Organizationally Unique Identifier(OUI), 3 octets,
 *type, defined by that organization, 2 octets.
 */
s32 rtw_put_snap(u8 *data, u16 h_proto)
{}

void rtw_update_protection(struct adapter *padapter, u8 *ie, uint ie_len)
{}

void rtw_count_tx_stats(struct adapter *padapter, struct xmit_frame *pxmitframe, int sz)
{}

static struct xmit_buf *__rtw_alloc_cmd_xmitbuf(struct xmit_priv *pxmitpriv,
		enum cmdbuf_type buf_type)
{}

struct xmit_frame *__rtw_alloc_cmdxmitframe(struct xmit_priv *pxmitpriv,
		enum cmdbuf_type buf_type)
{}

struct xmit_buf *rtw_alloc_xmitbuf_ext(struct xmit_priv *pxmitpriv)
{}

s32 rtw_free_xmitbuf_ext(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
{}

struct xmit_buf *rtw_alloc_xmitbuf(struct xmit_priv *pxmitpriv)
{}

s32 rtw_free_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
{}

static void rtw_init_xmitframe(struct xmit_frame *pxframe)
{}

/*
 * Calling context:
 * 1. OS_TXENTRY
 * 2. RXENTRY (rx_thread or RX_ISR/RX_CallBack)
 *
 * If we turn on USE_RXTHREAD, then, no need for critical section.
 * Otherwise, we must use _enter/_exit critical to protect free_xmit_queue...
 *
 * Must be very, very cautious...
 */
struct xmit_frame *rtw_alloc_xmitframe(struct xmit_priv *pxmitpriv)/* _queue *pfree_xmit_queue) */
{}

struct xmit_frame *rtw_alloc_xmitframe_ext(struct xmit_priv *pxmitpriv)
{}

struct xmit_frame *rtw_alloc_xmitframe_once(struct xmit_priv *pxmitpriv)
{}

s32 rtw_free_xmitframe(struct xmit_priv *pxmitpriv, struct xmit_frame *pxmitframe)
{}

void rtw_free_xmitframe_queue(struct xmit_priv *pxmitpriv, struct __queue *pframequeue)
{}

s32 rtw_xmitframe_enqueue(struct adapter *padapter, struct xmit_frame *pxmitframe)
{}

struct tx_servq *rtw_get_sta_pending(struct adapter *padapter, struct sta_info *psta, signed int up, u8 *ac)
{}

/*
 * Will enqueue pxmitframe to the proper queue,
 * and indicate it to xx_pending list.....
 */
s32 rtw_xmit_classifier(struct adapter *padapter, struct xmit_frame *pxmitframe)
{}

s32 rtw_alloc_hwxmits(struct adapter *padapter)
{}

void rtw_free_hwxmits(struct adapter *padapter)
{}

void rtw_init_hwxmits(struct hw_xmit *phwxmit, signed int entry)
{}

u32 rtw_get_ff_hwaddr(struct xmit_frame *pxmitframe)
{}

static void do_queue_select(struct adapter	*padapter, struct pkt_attrib *pattrib)
{}

/*
 * The main transmit(tx) entry
 *
 * Return
 *1	enqueue
 *0	success, hardware will handle this xmit frame(packet)
 *<0	fail
 */
s32 rtw_xmit(struct adapter *padapter, struct sk_buff **ppkt)
{}

#define RTW_HIQ_FILTER_ALLOW_ALL
#define RTW_HIQ_FILTER_ALLOW_SPECIAL
#define RTW_HIQ_FILTER_DENY_ALL

inline bool xmitframe_hiq_filter(struct xmit_frame *xmitframe)
{}

signed int xmitframe_enqueue_for_sleeping_sta(struct adapter *padapter, struct xmit_frame *pxmitframe)
{}

static void dequeue_xmitframes_to_sleeping_queue(struct adapter *padapter, struct sta_info *psta, struct __queue *pframequeue)
{}

void stop_sta_xmit(struct adapter *padapter, struct sta_info *psta)
{}

void wakeup_sta_to_xmit(struct adapter *padapter, struct sta_info *psta)
{}

void xmit_delivery_enabled_frames(struct adapter *padapter, struct sta_info *psta)
{}

void enqueue_pending_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
{}

void enqueue_pending_xmitbuf_to_head(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
{}

struct xmit_buf *dequeue_pending_xmitbuf(struct xmit_priv *pxmitpriv)
{}

struct xmit_buf *dequeue_pending_xmitbuf_under_survey(struct xmit_priv *pxmitpriv)
{}

signed int check_pending_xmitbuf(struct xmit_priv *pxmitpriv)
{}

int rtw_xmit_thread(void *context)
{}

void rtw_sctx_init(struct submit_ctx *sctx, int timeout_ms)
{}

int rtw_sctx_wait(struct submit_ctx *sctx)
{}

void rtw_sctx_done_err(struct submit_ctx **sctx, int status)
{}

void rtw_sctx_done(struct submit_ctx **sctx)
{}

int rtw_ack_tx_wait(struct xmit_priv *pxmitpriv, u32 timeout_ms)
{}

void rtw_ack_tx_done(struct xmit_priv *pxmitpriv, int status)
{}