card_t *card;
u32 i;
- func_enter();
-
card = kzalloc(sizeof(card_t), GFP_KERNEL);
if (card == NULL)
{
CsrResult r;
- func_enter();
if (card == NULL)
{
CsrResult r;
CsrResult csrResult;
- func_enter();
-
if (card == NULL)
{
func_exit_r(CSR_WIFI_HIP_RESULT_INVALID_VALUE);
CsrResult r;
void *dlpriv;
- func_enter();
-
if (card == NULL)
{
func_exit_r(CSR_WIFI_HIP_RESULT_INVALID_VALUE);
CsrResult r;
CsrResult csrResult;
- func_enter();
-
r = card_hw_init(card);
if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
{
s16 search_4slut_again;
CsrResult csrResult;
- func_enter();
-
/*
* The device revision from the TPLMID_MANF and TPLMID_CARD fields
* of the CIS are available as
u8 io_enable;
CsrResult csrResult;
- func_enter();
-
r = CSR_RESULT_SUCCESS;
for (i = 0; i < MAILBOX2_ATTEMPTS; i++)
{
u8 io_enable;
CsrResult csrResult;
- func_enter();
-
if (card->chip_id <= SDIO_CARD_ID_UNIFI_2)
{
unifi_error(card->ospriv,
u16 mbox0, mbox1;
CsrResult r;
- func_enter();
-
/*
* Wait for UniFi to initialise its data structures by polling
* the SHARED_MAILBOX1 register.
*/
CsrResult unifi_capture_panic(card_t *card)
{
- func_enter();
/* The firmware must have previously initialised to read the panic addresses
* from the SLUT
s32 i;
CsrResult r, sr;
- func_enter();
-
/* A chip version of zero means that the version never got succesfully read
* during reset. In this case give up because it will not be possible to
* verify the chip version.
CsrResult r;
u16 p_code, p_arg;
- func_enter();
-
/* The firmware must have previously initialised to read the panic addresses
* from the SLUT
*/
s16 n, i, k, r;
sdio_config_data_t *cfg_data;
- func_enter();
-
/* Reset any state carried forward from a previous life */
card->fh_command_queue.q_rd_ptr = 0;
card->fh_command_queue.q_wr_ptr = 0;
*/
static void card_free_memory_resources(card_t *card)
{
- func_enter();
unifi_trace(card->ospriv, UDBG1, "Freeing card memory resources.\n");
{
s16 i;
- func_enter();
-
unifi_trace(card->ospriv, UDBG1, "Initialising internal signal queues.\n");
/* Reset any state carried forward from a previous life */
card->fh_command_queue.q_rd_ptr = 0;
void unifi_cancel_pending_signals(card_t *card)
{
s16 i, n, r;
- func_enter();
unifi_trace(card->ospriv, UDBG1, "Canceling pending signals.\n");
*/
void unifi_free_card(card_t *card)
{
- func_enter();
#ifdef CSR_PRE_ALLOC_NET_DATA
prealloc_netdata_free(card);
#endif
CsrResult r;
u8 i;
- func_enter();
-
/* Allocate the buffers we need, only once. */
if (card->memory_resources_allocated == 1)
{
{
u8 i;
- func_enter();
-
unifi_trace(card->ospriv, UDBG5, "Packets Txed %d %d %d %d\n",
card->dynamic_slot_data.packets_txed[0],
card->dynamic_slot_data.packets_txed[1],
q_t *sigq;
u16 num_data_slots = card->config_data.num_fromhost_data_slots - UNIFI_RESERVED_COMMAND_SLOTS;
- func_enter();
-
/* Calculate the pending queue length */
sigq = &card->fh_traffic_queue[queue];
q_len = CSR_WIFI_HIP_Q_SLOTS_USED(sigq);
u8 queue = card->from_host_data[slot].queue;
const void *os_data_ptr = card->from_host_data[slot].bd.os_data_ptr;
- func_enter();
-
if (card->from_host_data[slot].bd.data_length == 0)
{
unifi_warning(card->ospriv,
{
u16 i, n = 0;
- func_enter();
-
/* First two slots reserved for MLME */
for (i = 0; i < card->config_data.num_fromhost_data_slots; i++)
{
static CsrResult unifi_identify_hw(card_t *card)
{
- func_enter();
card->chip_id = card->sdio_if->sdioId.cardId;
card->function = card->sdio_if->sdioId.sdioFunction;
CsrResult csrResult;
enum unifi_host_state old_state = card->host_state;
- func_enter();
-
r = unifi_identify_hw(card);
if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
{
CsrResult r;
u16 ver;
- func_enter();
-
gbl_chip_version = ChipHelper_GBL_CHIP_VERSION(card->helper);
/* Try to read the chip version from register. */
u16 new_block_size = UNIFI_IO_BLOCK_SIZE;
CsrResult csrResult;
- func_enter();
-
/* Errors returned by unifi_prepare_hw() are not critical at this point */
r = unifi_prepare_hw(card);
if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
CsrResult r;
CsrResult csrResult;
- func_enter();
-
/*
* This resets only function 1, so should be used in
* preference to the method below (CSR_FUNC_EN)
{
CsrResult r;
- func_enter();
-
/*
* Prepare UniFi for h/w reset
*/
const struct chip_helper_reset_values *init_data;
u32 chunks;
- func_enter();
-
/* Clear cache of page registers */
card->proc_select = (u32)(-1);
card->dmem_page = (u32)(-1);
{
CsrResult r;
- func_enter();
-
if (card->chip_id > SDIO_CARD_ID_UNIFI_2)
{
r = sdio_write_f0(card, SDIO_CSR_FROM_HOST_SCRATCH0,
bulk_data_desc_t *bulkdata = csptr->bulkdata;
s16 h, nslots;
- func_enter();
-
/* Count the number of slots required */
for (i = 0; i < UNIFI_MAX_DATA_REFERENCES; i++)
{
xbv1_t *fwinfo;
CsrResult r;
- func_enter();
-
fwinfo = kmalloc(sizeof(xbv1_t), GFP_KERNEL);
if (fwinfo == NULL)
{
xbv1_t *fwinfo;
CsrResult r;
- func_enter();
-
unifi_info(card->ospriv, "unifi_dl_patch %p %08x\n", dlpriv, boot_ctrl);
fwinfo = kmalloc(sizeof(xbv1_t), GFP_KERNEL);
{
CsrResult r;
- func_enter();
-
if (enable)
{
unifi_trace(card->ospriv, UDBG2, "Mini-coredump requested after reset\n");
{
CsrResult r = CSR_RESULT_SUCCESS;
- func_enter();
-
if (card == NULL)
{
r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
static u16 dump_seq_no = 1;
u32 time_of_capture;
- func_enter();
-
if (card->dump_next_write == NULL)
{
r = CSR_RESULT_SUCCESS;
s32 i = 0;
coredump_buffer *find_dump = NULL;
- func_enter();
-
if (req == NULL || card == NULL)
{
r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
{
CsrResult r;
- func_enter();
-
if (zonebuf == NULL || def == NULL)
{
r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
CsrResult r = CSR_RESULT_SUCCESS;
s32 i;
- func_enter();
-
/* Walk the table of coredump zone definitions and read them from the chip */
for (i = 0;
(i < HIP_CDUMP_NUM_ZONES) && (r == 0);
CsrResult r;
u32 sdio_addr;
- func_enter();
-
if (dump_buf == NULL)
{
r = CSR_WIFI_HIP_RESULT_INVALID_VALUE;
u32 i = 0;
#endif
- func_enter();
-
card->request_coredump_on_reset = 0;
card->dump_next_write = NULL;
card->dump_cur_read = NULL;
s16 i = 0;
s16 j;
- func_enter();
unifi_trace(ospriv, UDBG2, "Core dump de-configured\n");
if (card->dump_buf == NULL)
unifi_priv_t *priv;
ul_client_t *udi_cli;
- func_enter();
-
devno = MINOR(inode->i_rdev) >> 1;
/*
int devno;
unifi_priv_t *priv;
- func_enter();
-
priv = uf_find_instance(udi_cli->instance);
if (!priv) {
unifi_error(priv, "unifi_close: instance for device not found\n");
struct list_head *l;
int msglen;
- func_enter();
-
priv = uf_find_instance(pcli->instance);
if (!priv) {
unifi_error(priv, "invalid priv\n");
int bytecount;
CsrResult csrResult;
- func_enter();
-
/*
* The signal is the first thing in buf, the signal id is the
* first 16 bits of the signal.
bulk_data_param_t bulkdata;
CsrResult csrResult;
- func_enter();
-
priv = uf_find_instance(pcli->instance);
if (!priv) {
unifi_error(priv, "invalid priv\n");
unsigned int mask = 0;
int ready;
- func_enter();
-
ready = !list_empty(&pcli->udi_log);
poll_wait(filp, &pcli->udi_wq, wait);
unsigned long n_1000;
#endif
- func_enter();
-
/* Just a sanity check */
if ((signal == NULL) || (signal_len <= 0)) {
return;
udi_msg_t *msgptr;
u8 *p;
- func_enter();
-
/* Just a sanity check */
if ((buffer == NULL) || (length <= 0)) {
return -EINVAL;
unifi_priv_t *priv = (unifi_priv_t*)ospriv;
CSR_UNUSED(info);
- func_enter();
-
if (is_fw == UNIFI_FW_STA) {
/* F/w may have been released after a previous successful download. */
if (priv->fw_sta.dl_data == NULL) {
{
unifi_priv_t *priv = (unifi_priv_t*)ospriv;
struct dlpriv *dl_struct = (struct dlpriv *)dlpriv;
- func_enter();
if (dl_struct != NULL) {
if (dl_struct->dl_data != NULL) {
unifi_fw_open_buffer(void *ospriv, void *fwbuf, u32 len)
{
unifi_priv_t *priv = (unifi_priv_t*)ospriv;
- func_enter();
if (fwbuf == NULL) {
func_exit();
static CsrResult signal_buffer_init(unifi_priv_t * priv, int size)
{
int i;
- func_enter();
priv->rxSignalBuffer.writePointer =
priv->rxSignalBuffer.readPointer = 0;
int r = -1;
CsrResult csrResult;
- func_enter();
-
if ((bus_id < 0) || (bus_id >= MAX_UNIFI_DEVS)) {
unifi_error(priv, "register_unifi_sdio: invalid device %d\n",
bus_id);
static void
ask_unifi_sdio_cleanup(unifi_priv_t *priv)
{
- func_enter();
/*
* Now clear the flag that says the old instance is in use.
int i;
static const CsrWifiMacAddress broadcast_address = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}};
- func_enter();
-
/* Remove the device nodes */
uf_destroy_device_nodes(priv);
{
int r;
- func_enter();
-
if (sig->SignalPrimitiveHeader.SignalId == 0) {
unifi_error(priv, "unifi_mlme_blocking_request: Invalid Signal Id (0x%x)\n",
sig->SignalPrimitiveHeader.SignalId);
struct unifi_rx_radiotap_header *unifi_rt;
int signal, noise, snr;
- func_enter();
-
if (ind_data_len <= 0) {
unifi_error(priv, "Invalid length in CSR_MA_SNIFFDATA_INDICATION.\n");
return;
} *avs;
int signal, noise, snr;
- func_enter();
-
if (ind_data_len <= 0) {
unifi_error(priv, "Invalid length in CSR_MA_SNIFFDATA_INDICATION.\n");
return;
struct net_device *dev = priv->netdev;
struct sk_buff *skb = (struct sk_buff*)bulkdata->d[0].os_net_buf_ptr;
- func_enter();
-
if (bulkdata->d[0].data_length == 0) {
unifi_warning(priv, "rx: MA-SNIFFDATA indication with zero bulk data\n");
func_exit();
int i;
unsigned long flags;
- func_enter();
-
unifi_trace(priv, UDBG1, "uf_free_netdevice\n");
if (!priv) {
netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
unifi_priv_t *priv = interfacePriv->privPtr;
- func_enter();
-
/* If we haven't finished UniFi initialisation, we can't start */
if (priv->init_progress != UNIFI_INIT_COMPLETED) {
unifi_warning(priv, "%s: unifi not ready, failing net_open\n", __FUNCTION__);
netInterface_priv_t *interfacePriv = (netInterface_priv_t*)netdev_priv(dev);
unifi_priv_t *priv = interfacePriv->privPtr;
- func_enter();
-
/* Stop sniffing if in Monitor mode */
if (priv->wext_conf.mode == IW_MODE_MONITOR) {
if (priv->card) {
}
}
}
-#else
- func_enter();
#endif
netif_tx_stop_all_queues(dev);
{
CSR_PRIORITY priority = CSR_CONTENTION;
- func_enter();
priority = (CSR_PRIORITY) (skb->priority >> 5);
if (priority == CSR_QOS_UP0) { /* 0 */
u8 interfaceMode = interfacePriv->interfaceMode;
- func_enter();
-
/* Priority Mapping for all the Modes */
switch(interfaceMode)
{
int proto;
CSR_PRIORITY priority;
- func_enter();
-
memcpy(&ehdr, skb->data, ETH_HLEN);
proto = ntohs(ehdr.h_proto);
CSR_PRIORITY priority;
CsrWifiRouterCtrlPortAction port_action;
- func_enter();
-
unifi_trace(priv, UDBG5, "unifi_net_xmit: skb = %x\n", skb);
memcpy(&ehdr, skb->data, ETH_HLEN);
unifi_priv_t *priv = ospriv;
int i; /* used as a loop counter */
- func_enter();
unifi_trace(priv, UDBG2, "Stopping queue %d\n", queue);
for(i=0;i<CSR_WIFI_NUM_INTERFACES;i++)
unifi_priv_t *priv = ospriv;
int i=0; /* used as a loop counter */
- func_enter();
unifi_trace(priv, UDBG2, "Waking queue %d\n", queue);
for(i=0;i<CSR_WIFI_NUM_INTERFACES;i++)
netInterface_priv_t *interfacePriv;
struct ethhdr ehdr;
- func_enter();
-
interfaceTag = (pkt_ind->VirtualInterfaceIdentifier & 0xff);
interfacePriv = priv->interfacePriv[interfaceTag];
const CSR_MA_PACKET_CONFIRM *pkt_cfm = &signal->u.MaPacketConfirm;
netInterface_priv_t *interfacePriv;
- func_enter();
interfaceTag = (pkt_cfm->VirtualInterfaceIdentifier & 0xff);
interfacePriv = priv->interfacePriv[interfaceTag];
#endif
- func_enter();
-
interfaceTag = (pkt_ind->VirtualInterfaceIdentifier & 0xff);
interfacePriv = priv->interfacePriv[interfaceTag];
int id, r;
bulk_data_param_t bulkdata;
- func_enter();
-
/* Just a sanity check */
if (sig_packed == NULL) {
return;
CSR_PRIORITY UserPriority;
CSR_SEQUENCE_NUMBER sn;
- func_enter();
-
interfaceTag = (pkt_err_ind->VirtualInterfaceIdentifier & 0xff);
struct sdio_func *func = (struct sdio_func *)function->priv;
int err;
- func_enter();
-
/* Enable UniFi function 1 (the 802.11 part). */
_sdio_claim_host(func);
err = sdio_enable_func(func);
struct sdio_func *func = (struct sdio_func *)function->priv;
int err;
- func_enter();
-
/* Disable UniFi function 1 (the 802.11 part). */
_sdio_claim_host(func);
err = sdio_disable_func(func);
int instance;
CsrSdioFunction *sdio_ctx;
- func_enter();
-
/* First of all claim the SDIO driver */
sdio_claim_host(func);
return;
}
- func_enter();
-
unifi_info(NULL, "UniFi card removed\n");
/* Clean up the SDIO function driver */
static int
uf_glue_sdio_suspend(struct device *dev)
{
- func_enter();
-
unifi_trace(NULL, UDBG1, "uf_glue_sdio_suspend");
func_exit();
static int
uf_glue_sdio_resume(struct device *dev)
{
- func_enter();
-
unifi_trace(NULL, UDBG1, "uf_glue_sdio_resume");
#ifdef ANDROID_BUILD
int
uf_sme_init(unifi_priv_t *priv)
{
- func_enter();
-
sema_init(&priv->mlme_blocking_mutex, 1);
#ifdef CSR_SUPPORT_WEXT
uf_sme_deinit(unifi_priv_t *priv)
{
- func_enter();
-
/* Free memory allocated for the scan table */
/* unifi_clear_scan_table(priv); */
CSR_SIGNAL signal;
ul_client_t *client = pcli;
- func_enter();
-
if (client == NULL) {
unifi_error(NULL, "sme_native_log_event: client has exited\n");
return;
unifi_priv_t *priv = uf_find_instance(pcli->instance);
int id, r;
- func_enter();
-
/* Just a sanity check */
if ((sig_packed == NULL) || (sig_len <= 0)) {
return;
{
int r = 0;
- func_enter();
-
#ifdef CSR_SUPPORT_WEXT
/* The reset clears any 802.11 association. */
priv->wext_conf.flag_associated = 0;
0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xc0, 0xa8, 0x00, 0x02};
- func_enter();
-
csrResult = unifi_net_data_malloc(priv, &bulkdata.d[0], sizeof(arp_req));
if (csrResult != CSR_RESULT_SUCCESS)
{
struct list_head send_cfm_list;
u8 j;
- func_enter();
-
if(!staInfo) {
return;
}
u8 enable;
netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
unifi_priv_t *priv = interfacePriv->privPtr;
- func_enter();
unifi_trace(priv, UDBG1, "iwprivsconfwapi\n" );
unifiio_wapi_key_t inKey;
netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
unifi_priv_t *priv = interfacePriv->privPtr;
- func_enter();
unifi_trace(priv, UDBG1, "iwprivswpikey\n" );
unifi_priv_t *priv = interfacePriv->privPtr;
struct iw_freq *freq = (struct iw_freq *)wrqu;
- func_enter();
unifi_trace(priv, UDBG2, "unifi_siwfreq\n");
if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
int err = 0;
CsrWifiSmeConnectionInfo connectionInfo;
- func_enter();
unifi_trace(priv, UDBG2, "unifi_giwfreq\n");
CHECK_INITED(priv);
netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
unifi_priv_t *priv = interfacePriv->privPtr;
- func_enter();
unifi_trace(priv, UDBG2, "unifi_siwmode\n");
if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
unifi_priv_t *priv = interfacePriv->privPtr;
CsrWifiSmeConnectionConfig connectionConfig;
- func_enter();
unifi_trace(priv, UDBG2, "unifi_giwmode\n");
CHECK_INITED(priv);
unifi_priv_t *priv = interfacePriv->privPtr;
int err = 0;
- func_enter();
-
CHECK_INITED(priv);
if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
int r = 0;
u8 *bssid;
- func_enter();
-
CHECK_INITED(priv);
unifi_trace(priv, UDBG2, "unifi_giwap\n");
struct iw_scan_req *req = (struct iw_scan_req *) extra;
#endif
- func_enter();
-
CHECK_INITED(priv);
if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
int len;
int err = 0;
- func_enter();
CHECK_INITED(priv);
if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
CsrWifiSmeConnectionInfo connectionInfo;
int r = 0;
- func_enter();
unifi_trace(priv, UDBG2, "unifi_giwessid\n");
CHECK_INITED(priv);
CsrWifiSmeMibConfig mibConfig;
int r;
- func_enter();
-
CHECK_INITED(priv);
unifi_trace(priv, UDBG2, "unifi_siwrate\n");
CsrWifiSmeMibConfig mibConfig;
CsrWifiSmeConnectionStats connectionStats;
- func_enter();
unifi_trace(priv, UDBG2, "unifi_giwrate\n");
CHECK_INITED(priv);
int privacy = -1;
CsrWifiSmeKey sme_key;
- func_enter();
unifi_trace(priv, UDBG2, "unifi_siwencode\n");
CHECK_INITED(priv);
netInterface_priv_t *interfacePriv = (netInterface_priv_t *)netdev_priv(dev);
unifi_priv_t *priv = interfacePriv->privPtr;
struct iw_mlme *mlme = (struct iw_mlme *)extra;
- func_enter();
unifi_trace(priv, UDBG2, "unifi_siwmlme\n");
CHECK_INITED(priv);
unifi_priv_t *priv = interfacePriv->privPtr;
int len;
- func_enter();
unifi_trace(priv, UDBG2, "unifi_siwgenie\n");
if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
unifi_priv_t *priv = interfacePriv->privPtr;
int len;
- func_enter();
unifi_trace(priv, UDBG2, "unifi_giwgenie\n");
if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
unifi_priv_t *priv = interfacePriv->privPtr;
CsrWifiSmeAuthModeMask new_auth;
- func_enter();
unifi_trace(priv, UDBG2, "unifi_siwauth\n");
if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
CsrWifiSmeKey sme_key;
CsrWifiSmeKeyType key_type;
- func_enter();
-
CHECK_INITED(priv);
if(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP ||
s16 signal_id;
u8 pktIndToSme = FALSE, freeBulkData = FALSE;
- func_enter();
-
unifi_trace(priv, UDBG5, "unifi_process_receive_event: "
"%04x %04x %04x %04x %04x %04x %04x %04x (%d)\n",
CSR_GET_UINT16_FROM_LITTLE_ENDIAN((sigdata) + sizeof(s16)*0) & 0xFFFF,
{
unifi_priv_t *priv = (unifi_priv_t*)ospriv;
- func_enter();
unifi_trace(priv, UDBG4, "rx_wq_handler: RdPtr = %d WritePtr = %d\n",
priv->rxSignalBuffer.readPointer,priv->rxSignalBuffer.writePointer);
if(priv != NULL) {
u8 writePointer;
int i;
rx_buff_struct_t * rx_buff;
- func_enter();
unifi_trace(priv, UDBG5, "unifi_receive_event: "
"%04x %04x %04x %04x %04x %04x %04x %04x (%d)\n",
* etc.
*/
-#define func_enter() \
- do { \
- if (unifi_debug >= 5) { \
- printk("unifi: => %s\n", __FUNCTION__); \
- } \
- } while (0)
#define func_exit() \
do { \
if (unifi_debug >= 5) { \
#else
/* Stubs */
-#define func_enter()
#define func_exit()
#define func_exit_r(_rc)
netInterface_priv_t *interfacePriv = priv->interfacePriv[interfaceTag];
u32 hostTag = 0xffffffff;
- func_enter();
if(!isRouterBufferEnabled(priv,UNIFI_TRAFFIC_Q_VO)) {
while((interfacePriv->dtimActive)&& (buffered_pkt=dequeue_tx_data_pdu(priv,&interfacePriv->genericMulticastOrBroadCastMgtFrames))) {
buffered_pkt->transmissionControl |= (TRANSMISSION_CONTROL_TRIGGER_MASK);
CSR_RESULT_CODE resultCode = CSR_RC_SUCCESS;
netInterface_priv_t *interfacePriv;
- func_enter();
unifi_trace(priv, UDBG3,
"uf_process_ma_vif_availibility_ind: Process signal 0x%.4X\n",
*((u16*)sigdata));
u8 moreData = FALSE;
s8 r =0;
- func_enter();
-
unifi_trace(priv,UDBG2,"uf_send_buffered_data_from_ac :\n");
while(!isRouterBufferEnabled(priv,queue) &&
if(!((interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_AP) ||
(interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_P2PGO)))
return;
- func_enter();
queue = (q<=3)?q:0;
CSR_RATE transmitRate = 0;
- func_enter();
/* Send a Null Frame to Peer,
* 32= size of mac header */
csrResult = unifi_net_data_malloc(priv, &bulkdata.d[0], MAC_HEADER_SIZE + QOS_CONTROL_HEADER_SIZE);
CSR_MA_PACKET_REQUEST *req = &signal.u.MaPacketRequest;
unsigned long lock_flags;
- func_enter();
/* Send a Null Frame to Peer, size = 24 for MAC header */
csrResult = unifi_net_data_malloc(priv, &bulkdata.d[0], MAC_HEADER_SIZE);
struct list_head *placeHolder;
unsigned long lock_flags;
- func_enter();
-
spin_lock_irqsave(&priv->tx_q_lock,lock_flags);
/* Search through the list and if confirmation required for any frames,
int r;
unsigned long lock_flags;
- func_enter();
while(!isRouterBufferEnabled(priv,3) &&
((buffered_pkt=dequeue_tx_data_pdu(priv,&interfacePriv->genericMgtFrames))!=NULL)) {
buffered_pkt->transmissionControl &=
struct list_head *placeHolder;
tx_buffered_packets_t *tx_q_item;
- func_enter();
if (interfacePriv->noOfbroadcastPktQueued) {
/* Update the EOSP to the HEAD of b/c list
CsrResult result = CSR_RESULT_SUCCESS;
int r;
- func_enter();
/* Just a sanity check */
if ((signal == NULL) || (signal_len <= 0)) {
func_exit();
CsrWifiMacAddress peer;
unsigned long flags;
- func_enter();
-
/* The peer address was stored in the signal */
spin_lock_irqsave(&priv->m4_lock, flags);
memcpy(peer.a, req->Ra.x, sizeof(peer.a));
if (interfacePriv->interfaceMode == CSR_WIFI_ROUTER_CTRL_MODE_STA) {
- func_enter();
-
pktBulkDataLength = interfacePriv->wapi_unicast_bulk_data.data_length;
if (pktBulkDataLength > 0) {
projects / users / hch / block.git / commitdiff