/** * @brief This function allocates buffer for the members of adapter * structure like command buffer and BSSID list. * * @param pmadapter A pointer to mlan_adapter structure * * @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE */ static mlan_status wlan_allocate_adapter(pmlan_adapter pmadapter) { mlan_status ret = MLAN_STATUS_SUCCESS; #ifdef STA_SUPPORT t_u32 buf_size; BSSDescriptor_t *ptemp_scan_table = MNULL; #endif ENTER(); #ifdef STA_SUPPORT /* Allocate buffer to store the BSSID list */ buf_size = sizeof(BSSDescriptor_t) * MRVDRV_MAX_BSSID_LIST; ret = pmadapter->callbacks.moal_malloc(pmadapter->pmoal_handle, buf_size, MLAN_MEM_DEF, (t_u8 **) & ptemp_scan_table); if (ret != MLAN_STATUS_SUCCESS || !ptemp_scan_table) { PRINTM(MERROR, "Failed to allocate scan table\n"); LEAVE(); return MLAN_STATUS_FAILURE; } pmadapter->pscan_table = ptemp_scan_table; #endif /* Allocate command buffer */ ret = wlan_alloc_cmd_buffer(pmadapter); if (ret != MLAN_STATUS_SUCCESS) { PRINTM(MERROR, "Failed to allocate command buffer\n"); LEAVE(); return MLAN_STATUS_FAILURE; } ret = pmadapter->callbacks.moal_malloc(pmadapter->pmoal_handle, MAX_MP_REGS + HEADER_ALIGNMENT, MLAN_MEM_DEF | MLAN_MEM_DMA, (t_u8 **) & pmadapter->mp_regs_buf); if (ret != MLAN_STATUS_SUCCESS || !pmadapter->mp_regs_buf) { PRINTM(MERROR, "Failed to allocate mp_regs_buf\n"); LEAVE(); return MLAN_STATUS_FAILURE; } pmadapter->mp_regs = (t_u8 *) ALIGN_ADDR(pmadapter->mp_regs_buf, HEADER_ALIGNMENT); #if defined(SDIO_MULTI_PORT_TX_AGGR) || defined(SDIO_MULTI_PORT_RX_AGGR) ret = wlan_alloc_sdio_mpa_buffers(pmadapter, SDIO_MP_TX_AGGR_DEF_BUF_SIZE, SDIO_MP_RX_AGGR_DEF_BUF_SIZE); if (ret != MLAN_STATUS_SUCCESS) { PRINTM(MERROR, "Failed to allocate sdio mp-a buffers\n"); LEAVE(); return MLAN_STATUS_FAILURE; } #endif pmadapter->psleep_cfm = wlan_alloc_mlan_buffer(pmadapter, sizeof(opt_sleep_confirm_buffer), 0, MTRUE); LEAVE(); return MLAN_STATUS_SUCCESS; }
static void isc_httpd_senddone(isc_task_t *task, isc_event_t *ev) { isc_httpd_t *httpd = ev->ev_arg; isc_region_t r; isc_socketevent_t *sev = (isc_socketevent_t *)ev; ENTER("senddone"); INSIST(ISC_HTTPD_ISSEND(httpd)); /* * First, unlink our header buffer from the socket's bufflist. This * is sort of an evil hack, since we know our buffer will be there, * and we know it's address, so we can just remove it directly. */ NOTICE("senddone unlinked header"); ISC_LIST_UNLINK(sev->bufferlist, &httpd->headerbuffer, link); /* * We will always want to clean up our receive buffer, even if we * got an error on send or we are shutting down. * * We will pass in the buffer only if there is data in it. If * there is no data, we will pass in a NULL. */ if (httpd->freecb != NULL) { isc_buffer_t *b = NULL; if (isc_buffer_length(&httpd->bodybuffer) > 0) { b = &httpd->bodybuffer; httpd->freecb(b, httpd->freecb_arg); } NOTICE("senddone free callback performed"); } if (ISC_LINK_LINKED(&httpd->bodybuffer, link)) { ISC_LIST_UNLINK(sev->bufferlist, &httpd->bodybuffer, link); NOTICE("senddone body buffer unlinked"); } if (sev->result != ISC_R_SUCCESS) { destroy_client(&httpd); goto out; } if ((httpd->flags & HTTPD_CLOSE) != 0) { destroy_client(&httpd); goto out; } ISC_HTTPD_SETRECV(httpd); NOTICE("senddone restarting recv on socket"); reset_client(httpd); r.base = (unsigned char *)httpd->recvbuf; r.length = HTTP_RECVLEN - 1; /* check return code? */ (void)isc_socket_recv(httpd->sock, &r, 1, task, isc_httpd_recvdone, httpd); out: isc_event_free(&ev); EXIT("senddone"); }
ESPEAK_API void espeak_CompileDictionary(const char *path, FILE *log, int flags) {//============================================================================= ENTER("espeak_CompileDictionary"); CompileDictionary(path, dictionary_name, log, NULL, flags); } // end of espeak_CompileDirectory
/** * @brief The main process * * @param pmlan_adapter A pointer to mlan_adapter structure * * @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE */ mlan_status mlan_main_process(IN t_void * pmlan_adapter) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_adapter *pmadapter = (mlan_adapter *) pmlan_adapter; pmlan_callbacks pcb; ENTER(); MASSERT(pmlan_adapter); pcb = &pmadapter->callbacks; pcb->moal_spin_lock(pmadapter->pmoal_handle, pmadapter->pmain_proc_lock); /* Check if already processing */ if (pmadapter->mlan_processing) { pmadapter->more_task_flag = MTRUE; pcb->moal_spin_unlock(pmadapter->pmoal_handle, pmadapter->pmain_proc_lock); goto exit_main_proc; } else pmadapter->mlan_processing = MTRUE; process_start: do { pmadapter->more_task_flag = MFALSE; pcb->moal_spin_unlock(pmadapter->pmoal_handle, pmadapter->pmain_proc_lock); /* Is MLAN shutting down or not ready? */ if ((pmadapter->hw_status == WlanHardwareStatusClosing) || (pmadapter->hw_status == WlanHardwareStatusNotReady)) break; if (util_scalar_read (pmadapter->pmoal_handle, &pmadapter->rx_pkts_queued, pmadapter->callbacks.moal_spin_lock, pmadapter->callbacks.moal_spin_unlock) > HIGH_RX_PENDING) { PRINTM(MEVENT, "Pause\n"); pmadapter->delay_task_flag = MTRUE; if (!pmadapter->mlan_rx_processing) wlan_recv_event(wlan_get_priv (pmadapter, MLAN_BSS_ROLE_ANY), MLAN_EVENT_ID_DRV_DEFER_RX_WORK, MNULL); break; } /* Handle pending SDIO interrupts if any */ if (pmadapter->sdio_ireg) { if (pmadapter->hs_activated == MTRUE) wlan_process_hs_config(pmadapter); wlan_process_int_status(pmadapter); if (pmadapter->data_received && pmadapter->rx_work_flag) wlan_recv_event(wlan_get_priv (pmadapter, MLAN_BSS_ROLE_ANY), MLAN_EVENT_ID_DRV_DEFER_RX_WORK, MNULL); } /* Need to wake up the card ? */ if ((pmadapter->ps_state == PS_STATE_SLEEP) && (pmadapter->pm_wakeup_card_req && !pmadapter->pm_wakeup_fw_try) && (util_peek_list (pmadapter->pmoal_handle, &pmadapter->cmd_pending_q, pcb->moal_spin_lock, pcb->moal_spin_unlock) || !wlan_bypass_tx_list_empty(pmadapter) || !wlan_wmm_lists_empty(pmadapter) )) { wlan_pm_wakeup_card(pmadapter); pmadapter->pm_wakeup_fw_try = MTRUE; pcb->moal_spin_lock(pmadapter->pmoal_handle, pmadapter->pmain_proc_lock); continue; } if (IS_CARD_RX_RCVD(pmadapter)) { pmadapter->data_received = MFALSE; if (pmadapter->hs_activated == MTRUE) { pmadapter->is_hs_configured = MFALSE; wlan_host_sleep_activated_event(wlan_get_priv (pmadapter, MLAN_BSS_ROLE_ANY), MFALSE); } pmadapter->pm_wakeup_fw_try = MFALSE; if (pmadapter->ps_state == PS_STATE_SLEEP) pmadapter->ps_state = PS_STATE_AWAKE; } else { /* We have tried to wakeup the card already */ if (pmadapter->pm_wakeup_fw_try) break; if (pmadapter->ps_state != PS_STATE_AWAKE || (pmadapter->tx_lock_flag == MTRUE)) break; if (pmadapter->data_sent || wlan_is_tdls_link_chan_switching(pmadapter-> tdls_status) || (wlan_bypass_tx_list_empty(pmadapter) && wlan_wmm_lists_empty(pmadapter)) || wlan_11h_radar_detected_tx_blocked(pmadapter) ) { if (pmadapter->cmd_sent || pmadapter->curr_cmd || !wlan_is_send_cmd_allowed(pmadapter-> tdls_status) || (!util_peek_list (pmadapter->pmoal_handle, &pmadapter->cmd_pending_q, pcb->moal_spin_lock, pcb->moal_spin_unlock))) { break; } } } /* Check for Cmd Resp */ if (pmadapter->cmd_resp_received) { pmadapter->cmd_resp_received = MFALSE; wlan_process_cmdresp(pmadapter); /* call moal back when init_fw is done */ if (pmadapter->hw_status == WlanHardwareStatusInitdone) { pmadapter->hw_status = WlanHardwareStatusReady; wlan_init_fw_complete(pmadapter); } } /* Check for event */ if (pmadapter->event_received) { pmadapter->event_received = MFALSE; wlan_process_event(pmadapter); } /* Check if we need to confirm Sleep Request received previously */ if (pmadapter->ps_state == PS_STATE_PRE_SLEEP) if (!pmadapter->cmd_sent && !pmadapter->curr_cmd) wlan_check_ps_cond(pmadapter); /* * The ps_state may have been changed during processing of * Sleep Request event. */ if ((pmadapter->ps_state == PS_STATE_SLEEP) || (pmadapter->ps_state == PS_STATE_PRE_SLEEP) || (pmadapter->ps_state == PS_STATE_SLEEP_CFM) || (pmadapter->tx_lock_flag == MTRUE) ) { pcb->moal_spin_lock(pmadapter->pmoal_handle, pmadapter->pmain_proc_lock); continue; } if (!pmadapter->cmd_sent && !pmadapter->curr_cmd && wlan_is_send_cmd_allowed(pmadapter->tdls_status) ) { if (wlan_exec_next_cmd(pmadapter) == MLAN_STATUS_FAILURE) { ret = MLAN_STATUS_FAILURE; break; } } if (!pmadapter->data_sent && !wlan_11h_radar_detected_tx_blocked(pmadapter) && !wlan_is_tdls_link_chan_switching(pmadapter->tdls_status) && !wlan_bypass_tx_list_empty(pmadapter)) { PRINTM(MINFO, "mlan_send_pkt(): deq(bybass_txq)\n"); wlan_process_bypass_tx(pmadapter); if (pmadapter->hs_activated == MTRUE) { pmadapter->is_hs_configured = MFALSE; wlan_host_sleep_activated_event(wlan_get_priv (pmadapter, MLAN_BSS_ROLE_ANY), MFALSE); } } if (!pmadapter->data_sent && !wlan_wmm_lists_empty(pmadapter) && !wlan_11h_radar_detected_tx_blocked(pmadapter) && !wlan_is_tdls_link_chan_switching(pmadapter->tdls_status) ) { wlan_wmm_process_tx(pmadapter); if (pmadapter->hs_activated == MTRUE) { pmadapter->is_hs_configured = MFALSE; wlan_host_sleep_activated_event(wlan_get_priv (pmadapter, MLAN_BSS_ROLE_ANY), MFALSE); } } #ifdef STA_SUPPORT if (pmadapter->delay_null_pkt && !pmadapter->cmd_sent && !pmadapter->curr_cmd && !IS_COMMAND_PENDING(pmadapter) && wlan_bypass_tx_list_empty(pmadapter) && wlan_wmm_lists_empty(pmadapter)) { if (wlan_send_null_packet (wlan_get_priv(pmadapter, MLAN_BSS_ROLE_STA), MRVDRV_TxPD_POWER_MGMT_NULL_PACKET | MRVDRV_TxPD_POWER_MGMT_LAST_PACKET) == MLAN_STATUS_SUCCESS) { pmadapter->delay_null_pkt = MFALSE; } break; } #endif pcb->moal_spin_lock(pmadapter->pmoal_handle, pmadapter->pmain_proc_lock); } while (MTRUE); pcb->moal_spin_lock(pmadapter->pmoal_handle, pmadapter->pmain_proc_lock); if (pmadapter->more_task_flag == MTRUE) goto process_start; pmadapter->mlan_processing = MFALSE; pcb->moal_spin_unlock(pmadapter->pmoal_handle, pmadapter->pmain_proc_lock); exit_main_proc: if (pmadapter->hw_status == WlanHardwareStatusClosing) mlan_shutdown_fw(pmadapter); LEAVE(); return ret; }
static void isc_httpd_accept(isc_task_t *task, isc_event_t *ev) { isc_result_t result; isc_httpdmgr_t *httpdmgr = ev->ev_arg; isc_httpd_t *httpd; isc_region_t r; isc_socket_newconnev_t *nev = (isc_socket_newconnev_t *)ev; isc_sockaddr_t peeraddr; ENTER("accept"); LOCK(&httpdmgr->lock); if (MSHUTTINGDOWN(httpdmgr)) { NOTICE("accept shutting down, goto out"); goto out; } if (nev->result == ISC_R_CANCELED) { NOTICE("accept canceled, goto out"); goto out; } if (nev->result != ISC_R_SUCCESS) { /* XXXMLG log failure */ NOTICE("accept returned failure, goto requeue"); goto requeue; } (void)isc_socket_getpeername(nev->newsocket, &peeraddr); if (httpdmgr->client_ok != NULL && !(httpdmgr->client_ok)(&peeraddr, httpdmgr->cb_arg)) { isc_socket_detach(&nev->newsocket); goto requeue; } httpd = isc_mem_get(httpdmgr->mctx, sizeof(isc_httpd_t)); if (httpd == NULL) { /* XXXMLG log failure */ NOTICE("accept failed to allocate memory, goto requeue"); isc_socket_detach(&nev->newsocket); goto requeue; } httpd->mgr = httpdmgr; ISC_LINK_INIT(httpd, link); ISC_LIST_APPEND(httpdmgr->running, httpd, link); ISC_HTTPD_SETRECV(httpd); httpd->sock = nev->newsocket; isc_socket_setname(httpd->sock, "httpd", NULL); httpd->flags = 0; /* * Initialize the buffer for our headers. */ httpd->headerdata = isc_mem_get(httpdmgr->mctx, HTTP_SENDGROW); if (httpd->headerdata == NULL) { isc_mem_put(httpdmgr->mctx, httpd, sizeof(isc_httpd_t)); isc_socket_detach(&nev->newsocket); goto requeue; } httpd->headerlen = HTTP_SENDGROW; isc_buffer_init(&httpd->headerbuffer, httpd->headerdata, httpd->headerlen); ISC_LIST_INIT(httpd->bufflist); isc_buffer_initnull(&httpd->bodybuffer); reset_client(httpd); r.base = (unsigned char *)httpd->recvbuf; r.length = HTTP_RECVLEN - 1; result = isc_socket_recv(httpd->sock, &r, 1, task, isc_httpd_recvdone, httpd); /* FIXME!!! */ POST(result); NOTICE("accept queued recv on socket"); requeue: result = isc_socket_accept(httpdmgr->sock, task, isc_httpd_accept, httpdmgr); if (result != ISC_R_SUCCESS) { /* XXXMLG what to do? Log failure... */ NOTICE("accept could not reaccept due to failure"); } out: UNLOCK(&httpdmgr->lock); httpdmgr_destroy(httpdmgr); isc_event_free(&ev); EXIT("accept"); }
/** * @brief This function initializes the adapter structure * and set default value to the member of adapter. * * @param priv A pointer to wlan_private structure * @return n/a */ void wlan_init_adapter(wlan_private * priv) { wlan_adapter *Adapter = priv->adapter; int i; ENTER(); Adapter->ScanProbes = 0; Adapter->bcn_avg_factor = DEFAULT_BCN_AVG_FACTOR; Adapter->data_avg_factor = DEFAULT_DATA_AVG_FACTOR; /* ATIM params */ Adapter->AtimWindow = 0; Adapter->ATIMEnabled = FALSE; Adapter->MediaConnectStatus = WlanMediaStateDisconnected; memset(Adapter->CurrentAddr, 0xff, ETH_ALEN); /* Status variables */ Adapter->HardwareStatus = WlanHardwareStatusInitializing; /* scan type */ Adapter->ScanType = HostCmd_SCAN_TYPE_ACTIVE; /* scan mode */ Adapter->ScanMode = HostCmd_BSS_TYPE_ANY; /* Enable auto auth */ Adapter->AuthType = AUTHTYPE_ALLOW_BOTH; /* scan time */ Adapter->SpecificScanTime = MRVDRV_SPECIFIC_SCAN_CHAN_TIME; Adapter->ActiveScanTime = MRVDRV_ACTIVE_SCAN_CHAN_TIME; Adapter->PassiveScanTime = MRVDRV_PASSIVE_SCAN_CHAN_TIME; /* 802.11 specific */ Adapter->SecInfo.WEPStatus = Wlan802_11WEPDisabled; for (i = 0; i < sizeof(Adapter->WepKey) / sizeof(Adapter->WepKey[0]); i++) memset(&Adapter->WepKey[i], 0, sizeof(MRVL_WEP_KEY)); Adapter->CurrentWepKeyIndex = 0; Adapter->SecInfo.AuthenticationMode = Wlan802_11AuthModeOpen; Adapter->SecInfo.EncryptionMode = CIPHER_NONE; Adapter->AdhocAESEnabled = FALSE; Adapter->AdhocState = ADHOC_IDLE; Adapter->InfrastructureMode = Wlan802_11Infrastructure; Adapter->NumInScanTable = 0; Adapter->pAttemptedBSSDesc = NULL; #ifdef REASSOCIATION OS_INIT_SEMAPHORE(&Adapter->ReassocSem); #endif Adapter->pBeaconBufEnd = Adapter->beaconBuffer; Adapter->HisRegCpy |= HIS_TxDnLdRdy; memset(&Adapter->CurBssParams, 0, sizeof(Adapter->CurBssParams)); /* PnP and power profile */ Adapter->SurpriseRemoved = FALSE; Adapter->CurrentPacketFilter = HostCmd_ACT_MAC_RX_ON | HostCmd_ACT_MAC_TX_ON | HostCmd_ACT_MAC_ETHERNETII_ENABLE; Adapter->RadioOn = RADIO_ON; #ifdef REASSOCIATION #if (WIRELESS_EXT >= 18) Adapter->Reassoc_on = FALSE; #else Adapter->Reassoc_on = TRUE; #endif #endif /* REASSOCIATION */ Adapter->HWRateDropMode = HW_TABLE_RATE_DROP; Adapter->Is_DataRate_Auto = TRUE; Adapter->BeaconPeriod = MRVDRV_BEACON_INTERVAL; Adapter->AdhocChannel = DEFAULT_AD_HOC_CHANNEL; Adapter->AdhocAutoSel = TRUE; Adapter->PSMode = Wlan802_11PowerModeCAM; Adapter->MultipleDtim = MRVDRV_DEFAULT_MULTIPLE_DTIM; Adapter->ListenInterval = MRVDRV_DEFAULT_LISTEN_INTERVAL; Adapter->PSState = PS_STATE_FULL_POWER; Adapter->NeedToWakeup = FALSE; Adapter->LocalListenInterval = 0; /* default value in firmware will be used */ Adapter->IsDeepSleep = FALSE; Adapter->IsAutoDeepSleepEnabled = FALSE; Adapter->IsEnhancedPSEnabled = FALSE; Adapter->bWakeupDevRequired = FALSE; Adapter->WakeupTries = 0; Adapter->bHostSleepConfigured = FALSE; Adapter->HSCfg.conditions = HOST_SLEEP_CFG_CANCEL; Adapter->HSCfg.gpio = 0; Adapter->HSCfg.gap = 0; Adapter->DataRate = 0; /* Initially indicate the rate as auto */ Adapter->adhoc_grate_enabled = TRUE; Adapter->IntCounter = Adapter->IntCounterSaved = 0; Adapter->gen_null_pkg = TRUE; /* Enable NULL Pkg generation */ Adapter->BCNMissTimeOut = DEFAULT_BCN_MISS_TIMEOUT; init_waitqueue_head(&Adapter->HS_wait_q); init_waitqueue_head(&Adapter->ds_awake_q); spin_lock_init(&Adapter->CurrentTxLock); spin_lock_init(&Adapter->driver_lock); Adapter->PktTxCtrl = 0; /* Initialize 802.11d */ wlan_init_11d(priv); LEAVE(); return; }
/** * @brief This function registers MOAL to MLAN module. * * @param pmdevice A pointer to a mlan_device structure * allocated in MOAL * @param ppmlan_adapter A pointer to a t_void pointer to store * mlan_adapter structure pointer as the context * * @return MLAN_STATUS_SUCCESS * The registration succeeded. * MLAN_STATUS_FAILURE * The registration failed. * * mlan_status mlan_register ( * IN pmlan_device pmdevice, * OUT t_void **ppmlan_adapter * ); * * Comments * MOAL constructs mlan_device data structure to pass moal_handle and * mlan_callback table to MLAN. MLAN returns mlan_adapter pointer to * the ppmlan_adapter buffer provided by MOAL. * Headers: * declared in mlan_decl.h * See Also * mlan_unregister */ mlan_status mlan_register(IN pmlan_device pmdevice, OUT t_void ** ppmlan_adapter) { mlan_status ret = MLAN_STATUS_SUCCESS; pmlan_adapter pmadapter = MNULL; pmlan_callbacks pcb = MNULL; t_u8 i = 0; t_u32 j = 0; MASSERT(pmdevice); MASSERT(ppmlan_adapter); MASSERT(pmdevice->callbacks.moal_print); #ifdef DEBUG_LEVEL1 print_callback = pmdevice->callbacks.moal_print; get_sys_time_callback = pmdevice->callbacks.moal_get_system_time; #endif assert_callback = pmdevice->callbacks.moal_assert; ENTER(); MASSERT(pmdevice->callbacks.moal_malloc); MASSERT(pmdevice->callbacks.moal_memset); MASSERT(pmdevice->callbacks.moal_memmove); /* Allocate memory for adapter structure */ if (pmdevice->callbacks.moal_vmalloc && pmdevice->callbacks.moal_vfree) ret = pmdevice->callbacks.moal_vmalloc(pmdevice->pmoal_handle, sizeof(mlan_adapter), (t_u8 **) & pmadapter); else ret = pmdevice->callbacks.moal_malloc(pmdevice->pmoal_handle, sizeof(mlan_adapter), MLAN_MEM_DEF, (t_u8 **) & pmadapter); if ((ret != MLAN_STATUS_SUCCESS) || !pmadapter) { ret = MLAN_STATUS_FAILURE; goto exit_register; } pmdevice->callbacks.moal_memset(pmdevice->pmoal_handle, pmadapter, 0, sizeof(mlan_adapter)); pcb = &pmadapter->callbacks; /* Save callback functions */ pmdevice->callbacks.moal_memmove(pmadapter->pmoal_handle, pcb, &pmdevice->callbacks, sizeof(mlan_callbacks)); /* Assertion for all callback functions */ MASSERT(pcb->moal_init_fw_complete); MASSERT(pcb->moal_shutdown_fw_complete); MASSERT(pcb->moal_send_packet_complete); MASSERT(pcb->moal_recv_packet); MASSERT(pcb->moal_recv_event); MASSERT(pcb->moal_ioctl_complete); MASSERT(pcb->moal_write_reg); MASSERT(pcb->moal_read_reg); MASSERT(pcb->moal_alloc_mlan_buffer); MASSERT(pcb->moal_free_mlan_buffer); MASSERT(pcb->moal_write_data_sync); MASSERT(pcb->moal_read_data_sync); MASSERT(pcb->moal_mfree); MASSERT(pcb->moal_memcpy); MASSERT(pcb->moal_memcmp); MASSERT(pcb->moal_get_system_time); MASSERT(pcb->moal_init_timer); MASSERT(pcb->moal_free_timer); MASSERT(pcb->moal_start_timer); MASSERT(pcb->moal_stop_timer); MASSERT(pcb->moal_init_lock); MASSERT(pcb->moal_free_lock); MASSERT(pcb->moal_spin_lock); MASSERT(pcb->moal_spin_unlock); MASSERT(pcb->moal_tcp_ack_tx_ind); /* Save pmoal_handle */ pmadapter->pmoal_handle = pmdevice->pmoal_handle; if ((pmdevice->int_mode == INT_MODE_GPIO) && (pmdevice->gpio_pin == 0)) { PRINTM(MERROR, "SDIO_GPIO_INT_CONFIG: Invalid GPIO Pin\n"); ret = MLAN_STATUS_FAILURE; goto error; } pmadapter->init_para.int_mode = pmdevice->int_mode; pmadapter->init_para.gpio_pin = pmdevice->gpio_pin; pmadapter->card_type = pmdevice->card_type; ret = wlan_get_sdio_device(pmadapter); if (MLAN_STATUS_SUCCESS != ret) { ret = MLAN_STATUS_FAILURE; goto error; } /* card specific probing has been deferred until now .. */ ret = wlan_sdio_probe(pmadapter); if (MLAN_STATUS_SUCCESS != ret) { ret = MLAN_STATUS_FAILURE; goto error; } #ifdef DEBUG_LEVEL1 mlan_drvdbg = pmdevice->drvdbg; #endif #ifdef MFG_CMD_SUPPORT pmadapter->init_para.mfg_mode = pmdevice->mfg_mode; #endif #if defined(SDIO_MULTI_PORT_TX_AGGR) || defined(SDIO_MULTI_PORT_RX_AGGR) pmadapter->max_segs = pmdevice->max_segs; pmadapter->max_seg_size = pmdevice->max_seg_size; #endif #ifdef SDIO_MULTI_PORT_TX_AGGR pmadapter->init_para.mpa_tx_cfg = pmdevice->mpa_tx_cfg; #endif #ifdef SDIO_MULTI_PORT_RX_AGGR pmadapter->init_para.mpa_rx_cfg = pmdevice->mpa_rx_cfg; #endif pmadapter->init_para.auto_ds = pmdevice->auto_ds; pmadapter->init_para.ps_mode = pmdevice->ps_mode; if (pmdevice->max_tx_buf == MLAN_TX_DATA_BUF_SIZE_2K || pmdevice->max_tx_buf == MLAN_TX_DATA_BUF_SIZE_4K || pmdevice->max_tx_buf == MLAN_TX_DATA_BUF_SIZE_12K || pmdevice->max_tx_buf == MLAN_TX_DATA_BUF_SIZE_8K) pmadapter->init_para.max_tx_buf = pmdevice->max_tx_buf; #ifdef STA_SUPPORT pmadapter->init_para.cfg_11d = pmdevice->cfg_11d; #else pmadapter->init_para.cfg_11d = 0; #endif pmadapter->init_para.dfs_master_radar_det_en = DFS_MASTER_RADAR_DETECT_EN; pmadapter->init_para.dfs_slave_radar_det_en = DFS_SLAVE_RADAR_DETECT_EN; if (IS_SD8777(pmadapter->card_type) || IS_SD8787(pmadapter->card_type)) pmadapter->init_para.fw_crc_check = pmdevice->fw_crc_check; pmadapter->init_para.dev_cap_mask = pmdevice->dev_cap_mask; pmadapter->rx_work_flag = pmdevice->rx_work; pmadapter->priv_num = 0; for (i = 0; i < MLAN_MAX_BSS_NUM; i++) { pmadapter->priv[i] = MNULL; if (pmdevice->bss_attr[i].active == MTRUE) { /* For valid bss_attr, allocate memory for private structure */ if (pcb->moal_vmalloc && pcb->moal_vfree) ret = pcb->moal_vmalloc(pmadapter->pmoal_handle, sizeof(mlan_private), (t_u8 **) & pmadapter-> priv[i]); else ret = pcb->moal_malloc(pmadapter->pmoal_handle, sizeof(mlan_private), MLAN_MEM_DEF, (t_u8 **) & pmadapter-> priv[i]); if (ret != MLAN_STATUS_SUCCESS || !pmadapter->priv[i]) { ret = MLAN_STATUS_FAILURE; goto error; } pmadapter->priv_num++; memset(pmadapter, pmadapter->priv[i], 0, sizeof(mlan_private)); pmadapter->priv[i]->adapter = pmadapter; /* Save bss_type, frame_type & bss_priority */ pmadapter->priv[i]->bss_type = (t_u8) pmdevice->bss_attr[i].bss_type; pmadapter->priv[i]->frame_type = (t_u8) pmdevice->bss_attr[i].frame_type; pmadapter->priv[i]->bss_priority = (t_u8) pmdevice->bss_attr[i].bss_priority; if (pmdevice->bss_attr[i].bss_type == MLAN_BSS_TYPE_STA) pmadapter->priv[i]->bss_role = MLAN_BSS_ROLE_STA; else if (pmdevice->bss_attr[i].bss_type == MLAN_BSS_TYPE_UAP) pmadapter->priv[i]->bss_role = MLAN_BSS_ROLE_UAP; #ifdef WIFI_DIRECT_SUPPORT else if (pmdevice->bss_attr[i].bss_type == MLAN_BSS_TYPE_WIFIDIRECT) { pmadapter->priv[i]->bss_role = MLAN_BSS_ROLE_STA; if (pmdevice->bss_attr[i].bss_virtual) pmadapter->priv[i]->bss_virtual = MTRUE; } #endif /* Save bss_index and bss_num */ pmadapter->priv[i]->bss_index = i; pmadapter->priv[i]->bss_num = (t_u8) pmdevice->bss_attr[i].bss_num; /* init function table */ for (j = 0; mlan_ops[j]; j++) { if (mlan_ops[j]->bss_role == GET_BSS_ROLE(pmadapter->priv[i])) { memcpy(pmadapter, &pmadapter->priv[i]->ops, mlan_ops[j], sizeof(mlan_operations)); } } } } /* Initialize lock variables */ if (wlan_init_lock_list(pmadapter) != MLAN_STATUS_SUCCESS) { ret = MLAN_STATUS_FAILURE; goto error; } /* Allocate memory for member of adapter structure */ if (wlan_allocate_adapter(pmadapter)) { ret = MLAN_STATUS_FAILURE; goto error; } /* Initialize timers */ if (wlan_init_timer(pmadapter) != MLAN_STATUS_SUCCESS) { ret = MLAN_STATUS_FAILURE; goto error; } /* Return pointer of mlan_adapter to MOAL */ *ppmlan_adapter = pmadapter; goto exit_register; error: PRINTM(MINFO, "Leave mlan_register with error\n"); /* Free timers */ wlan_free_timer(pmadapter); /* Free adapter structure */ wlan_free_adapter(pmadapter); /* Free lock variables */ wlan_free_lock_list(pmadapter); for (i = 0; i < MLAN_MAX_BSS_NUM; i++) { if (pmadapter->priv[i]) { if (pcb->moal_vmalloc && pcb->moal_vfree) pcb->moal_vfree(pmadapter->pmoal_handle, (t_u8 *) pmadapter->priv[i]); else pcb->moal_mfree(pmadapter->pmoal_handle, (t_u8 *) pmadapter->priv[i]); } } if (pcb->moal_vmalloc && pcb->moal_vfree) pcb->moal_vfree(pmadapter->pmoal_handle, (t_u8 *) pmadapter); else pcb->moal_mfree(pmadapter->pmoal_handle, (t_u8 *) pmadapter); exit_register: LEAVE(); return ret; }
void w55fa93_adc_close(void) { ENTER(); DrvADC_Close(); }
/*----- set sample Frequency -----*/ VOID adcSetRecordSampleRate(INT nSamplingRate) { ENTER(); _tADC.nRecSamplingRate = nSamplingRate; }
/** * @brief This function initializes firmware * * @param pmadapter A pointer to mlan_adapter * * @return MLAN_STATUS_SUCCESS or error code */ mlan_status wlan_init_fw(IN pmlan_adapter pmadapter) { mlan_status ret = MLAN_STATUS_SUCCESS; pmlan_private priv = MNULL; t_u8 i = 0; t_u8 first_sta = MTRUE; ENTER(); /* Allocate memory for member of adapter structure */ ret = wlan_allocate_adapter(pmadapter); if (ret) { ret = MLAN_STATUS_FAILURE; goto done; } /* Initialize adapter structure */ wlan_init_adapter(pmadapter); for (i = 0; i < MLAN_MAX_BSS_NUM; i++) { if (pmadapter->priv[i]) { priv = pmadapter->priv[i]; /* Initialize private structure */ wlan_init_priv(priv); if ((ret = wlan_add_bsspriotbl(pmadapter, i))) { ret = MLAN_STATUS_FAILURE; goto done; } } } #ifdef MFG_CMD_SUPPORT if (pmadapter->mfg_mode != MTRUE) { #endif for (i = 0; i < MLAN_MAX_BSS_NUM; i++) { if (pmadapter->priv[i]) { ret = pmadapter->priv[i]->ops.init_cmd(pmadapter->priv[i], first_sta); if (ret == MLAN_STATUS_FAILURE) goto done; first_sta = MFALSE; } } #ifdef MFG_CMD_SUPPORT } #endif if (util_peek_list(pmadapter->pmoal_handle, &pmadapter->cmd_pending_q, pmadapter->callbacks.moal_spin_lock, pmadapter->callbacks.moal_spin_unlock)) { /* Send the first command in queue and return */ if (mlan_main_process(pmadapter) == MLAN_STATUS_FAILURE) ret = MLAN_STATUS_FAILURE; else ret = MLAN_STATUS_PENDING; } else { pmadapter->hw_status = WlanHardwareStatusReady; } done: LEAVE(); return ret; }
/** * @brief This function initializes the private structure * and sets default values to the members of mlan_private. * * @param priv A pointer to mlan_private structure * * @return N/A */ t_void wlan_init_priv(pmlan_private priv) { #ifdef STA_SUPPORT t_u32 i; #else t_u32 i; #endif pmlan_adapter pmadapter = priv->adapter; ENTER(); priv->media_connected = MFALSE; memset(pmadapter, priv->curr_addr, 0xff, MLAN_MAC_ADDR_LENGTH); #ifdef STA_SUPPORT priv->pkt_tx_ctrl = 0; priv->bss_mode = MLAN_BSS_MODE_INFRA; priv->data_rate = 0; /* Initially indicate the rate as auto */ priv->is_data_rate_auto = MTRUE; priv->bcn_avg_factor = DEFAULT_BCN_AVG_FACTOR; priv->data_avg_factor = DEFAULT_DATA_AVG_FACTOR; priv->sec_info.wep_status = Wlan802_11WEPDisabled; priv->sec_info.authentication_mode = MLAN_AUTH_MODE_AUTO; priv->sec_info.encryption_mode = MLAN_ENCRYPTION_MODE_NONE; for (i = 0; i < sizeof(priv->wep_key) / sizeof(priv->wep_key[0]); i++) memset(pmadapter, &priv->wep_key[i], 0, sizeof(mrvl_wep_key_t)); priv->wep_key_curr_index = 0; priv->ewpa_query = MFALSE; priv->adhoc_aes_enabled = MFALSE; priv->curr_pkt_filter = HostCmd_ACT_MAC_RX_ON | HostCmd_ACT_MAC_TX_ON | HostCmd_ACT_MAC_ETHERNETII_ENABLE; priv->beacon_period = MLAN_BEACON_INTERVAL; priv->pattempted_bss_desc = MNULL; memset(pmadapter, &priv->curr_bss_params, 0, sizeof(priv->curr_bss_params)); priv->listen_interval = MLAN_DEFAULT_LISTEN_INTERVAL; memset(pmadapter, &priv->prev_ssid, 0, sizeof(priv->prev_ssid)); memset(pmadapter, &priv->prev_bssid, 0, sizeof(priv->prev_bssid)); memset(pmadapter, &priv->assoc_rsp_buf, 0, sizeof(priv->assoc_rsp_buf)); priv->assoc_rsp_size = 0; priv->adhoc_auto_sel = MTRUE; priv->adhoc_channel = DEFAULT_AD_HOC_CHANNEL; priv->atim_window = 0; priv->adhoc_state = ADHOC_IDLE; priv->tx_power_level = 0; priv->max_tx_power_level = 0; priv->min_tx_power_level = 0; priv->tx_rate = 0; priv->rxpd_htinfo = 0; priv->rxpd_rate = 0; priv->rate_bitmap = 0; priv->data_rssi_last = 0; priv->data_rssi_avg = 0; priv->data_nf_avg = 0; priv->data_nf_last = 0; priv->bcn_rssi_last = 0; priv->bcn_rssi_avg = 0; priv->bcn_nf_avg = 0; priv->bcn_nf_last = 0; memset(pmadapter, &priv->wpa_ie, 0, sizeof(priv->wpa_ie)); memset(pmadapter, &priv->aes_key, 0, sizeof(priv->aes_key)); priv->wpa_ie_len = 0; priv->wpa_is_gtk_set = MFALSE; memset(pmadapter, &priv->wps, 0, sizeof(priv->wps)); memset(pmadapter, &priv->gen_ie_buf, 0, sizeof(priv->gen_ie_buf)); priv->gen_ie_buf_len = 0; memset(pmadapter, priv->vs_ie, 0, sizeof(priv->vs_ie)); #endif /* STA_SUPPORT */ priv->wmm_required = MTRUE; priv->wmm_enabled = MFALSE; priv->wmm_qosinfo = 0; #ifdef STA_SUPPORT priv->pcurr_bcn_buf = MNULL; priv->curr_bcn_size = 0; #endif /* STA_SUPPORT */ for (i = 0; i < MAX_NUM_TID; i++) priv->addba_reject[i] = ADDBA_RSP_STATUS_ACCEPT; priv->port_ctrl_mode = MFALSE; priv->port_open = MFALSE; priv->scan_block = MFALSE; LEAVE(); return; }
/** * @brief This function releases the lock variables * * @param pmadapter A pointer to a mlan_adapter structure * * @return None * */ t_void wlan_free_lock_list(IN pmlan_adapter pmadapter) { pmlan_private priv = MNULL; pmlan_callbacks pcb = &pmadapter->callbacks; t_s32 i = 0; t_s32 j = 0; ENTER(); if (pmadapter->pmlan_lock) pcb->moal_free_lock(pmadapter->pmoal_handle, pmadapter->pmlan_lock); if (pmadapter->pint_lock) pcb->moal_free_lock(pmadapter->pmoal_handle, pmadapter->pint_lock); if (pmadapter->pmain_proc_lock) pcb->moal_free_lock(pmadapter->pmoal_handle, pmadapter->pmain_proc_lock); if (pmadapter->pmlan_cmd_lock) pcb->moal_free_lock(pmadapter->pmoal_handle, pmadapter->pmlan_cmd_lock); for (i = 0; i < MLAN_MAX_BSS_NUM; i++) { if (pmadapter->priv[i]) { priv = pmadapter->priv[i]; if (priv->rx_pkt_lock) pcb->moal_free_lock(pmadapter->pmoal_handle, priv->rx_pkt_lock); if (priv->wmm.ra_list_spinlock) pcb->moal_free_lock(pmadapter->pmoal_handle, priv->wmm.ra_list_spinlock); #ifdef STA_SUPPORT if (priv->curr_bcn_buf_lock) pcb->moal_free_lock(pmadapter->pmoal_handle, priv->curr_bcn_buf_lock); #endif } } /* Free lists */ util_free_list_head((t_void *) pmadapter->pmoal_handle, &pmadapter->bypass_txq, pmadapter->callbacks.moal_free_lock); util_free_list_head((t_void *) pmadapter->pmoal_handle, &pmadapter->cmd_free_q, pmadapter->callbacks.moal_free_lock); util_free_list_head((t_void *) pmadapter->pmoal_handle, &pmadapter->cmd_pending_q, pmadapter->callbacks.moal_free_lock); util_free_list_head((t_void *) pmadapter->pmoal_handle, &pmadapter->scan_pending_q, pmadapter->callbacks.moal_free_lock); for (i = 0; i < MLAN_MAX_BSS_NUM; i++) util_free_list_head((t_void *) pmadapter->pmoal_handle, &pmadapter->bssprio_tbl[i].bssprio_head, pcb->moal_free_lock); for (i = 0; i < MLAN_MAX_BSS_NUM; i++) { if (pmadapter->priv[i]) { priv = pmadapter->priv[i]; #ifdef UAP_SUPPORT util_free_list_head((t_void *) pmadapter->pmoal_handle, &priv->sta_list, priv->adapter->callbacks.moal_free_lock); #endif /* UAP_SUPPORT */ for (j = 0; j < MAX_NUM_TID; ++j) util_free_list_head((t_void *) priv->adapter->pmoal_handle, &priv->wmm.tid_tbl_ptr[j].ra_list, priv->adapter->callbacks.moal_free_lock); util_free_list_head((t_void *) priv->adapter->pmoal_handle, &priv->tx_ba_stream_tbl_ptr, priv->adapter->callbacks.moal_free_lock); util_free_list_head((t_void *) priv->adapter->pmoal_handle, &priv->rx_reorder_tbl_ptr, priv->adapter->callbacks.moal_free_lock); util_scalar_free((t_void *) priv->adapter->pmoal_handle, &priv->wmm.tx_pkts_queued, priv->adapter->callbacks.moal_free_lock); util_scalar_free((t_void *) priv->adapter->pmoal_handle, &priv->wmm.highest_queued_prio, priv->adapter->callbacks.moal_free_lock); } } LEAVE(); return; }
/** * @brief This function intializes the lock variables and * the list heads. * * @param pmadapter A pointer to a mlan_adapter structure * * @return MLAN_STATUS_SUCCESS -- on success, * otherwise MLAN_STATUS_FAILURE * */ mlan_status wlan_init_lock_list(IN pmlan_adapter pmadapter) { mlan_status ret = MLAN_STATUS_SUCCESS; pmlan_private priv = MNULL; pmlan_callbacks pcb = &pmadapter->callbacks; t_s32 i = 0; t_u32 j = 0; ENTER(); if (pcb->moal_init_lock(pmadapter->pmoal_handle, &pmadapter->pmlan_lock) != MLAN_STATUS_SUCCESS) { ret = MLAN_STATUS_FAILURE; goto error; } if (pcb->moal_init_lock(pmadapter->pmoal_handle, &pmadapter->pint_lock) != MLAN_STATUS_SUCCESS) { ret = MLAN_STATUS_FAILURE; goto error; } if (pcb-> moal_init_lock(pmadapter->pmoal_handle, &pmadapter->pmain_proc_lock) != MLAN_STATUS_SUCCESS) { ret = MLAN_STATUS_FAILURE; goto error; } if (pcb->moal_init_lock(pmadapter->pmoal_handle, &pmadapter->pmlan_cmd_lock) != MLAN_STATUS_SUCCESS) { ret = MLAN_STATUS_FAILURE; goto error; } for (i = 0; i < MLAN_MAX_BSS_NUM; i++) { if (pmadapter->priv[i]) { priv = pmadapter->priv[i]; if (pcb->moal_init_lock(pmadapter->pmoal_handle, &priv->rx_pkt_lock) != MLAN_STATUS_SUCCESS) { ret = MLAN_STATUS_FAILURE; goto error; } if (pcb-> moal_init_lock(pmadapter->pmoal_handle, &priv->wmm.ra_list_spinlock) != MLAN_STATUS_SUCCESS) { ret = MLAN_STATUS_FAILURE; goto error; } #ifdef STA_SUPPORT if (pcb-> moal_init_lock(pmadapter->pmoal_handle, &priv->curr_bcn_buf_lock) != MLAN_STATUS_SUCCESS) { ret = MLAN_STATUS_FAILURE; goto error; } #endif } } /* Initialize bypass_txq */ util_init_list_head((t_void *) pmadapter->pmoal_handle, &pmadapter->bypass_txq, MTRUE, pmadapter->callbacks.moal_init_lock); /* Initialize cmd_free_q */ util_init_list_head((t_void *) pmadapter->pmoal_handle, &pmadapter->cmd_free_q, MTRUE, pmadapter->callbacks.moal_init_lock); /* Initialize cmd_pending_q */ util_init_list_head((t_void *) pmadapter->pmoal_handle, &pmadapter->cmd_pending_q, MTRUE, pmadapter->callbacks.moal_init_lock); /* Initialize scan_pending_q */ util_init_list_head((t_void *) pmadapter->pmoal_handle, &pmadapter->scan_pending_q, MTRUE, pmadapter->callbacks.moal_init_lock); for (i = 0; i < MLAN_MAX_BSS_NUM; ++i) { util_init_list_head((t_void *) pmadapter->pmoal_handle, &pmadapter->bssprio_tbl[i].bssprio_head, MTRUE, pmadapter->callbacks.moal_init_lock); pmadapter->bssprio_tbl[i].bssprio_cur = MNULL; } for (i = 0; i < MLAN_MAX_BSS_NUM; i++) { if (pmadapter->priv[i]) { priv = pmadapter->priv[i]; for (j = 0; j < MAX_NUM_TID; ++j) { util_init_list_head((t_void *) pmadapter->pmoal_handle, &priv->wmm.tid_tbl_ptr[j].ra_list, MTRUE, priv->adapter->callbacks.moal_init_lock); } util_init_list_head((t_void *) pmadapter->pmoal_handle, &priv->tx_ba_stream_tbl_ptr, MTRUE, pmadapter->callbacks.moal_init_lock); util_init_list_head((t_void *) pmadapter->pmoal_handle, &priv->rx_reorder_tbl_ptr, MTRUE, pmadapter->callbacks.moal_init_lock); util_scalar_init((t_void *) pmadapter->pmoal_handle, &priv->wmm.tx_pkts_queued, 0, priv->wmm.ra_list_spinlock, pmadapter->callbacks.moal_init_lock); util_scalar_init((t_void *) pmadapter->pmoal_handle, &priv->wmm.highest_queued_prio, HIGH_PRIO_TID, priv->wmm.ra_list_spinlock, pmadapter->callbacks.moal_init_lock); #ifdef UAP_SUPPORT util_init_list_head((t_void *) pmadapter->pmoal_handle, &priv->sta_list, MTRUE, pmadapter->callbacks.moal_init_lock); #endif /* UAP_SUPPORT */ } } error: LEAVE(); return ret; }
/** * @brief This function initializes the adapter structure * and sets default values to the members of adapter. * * @param pmadapter A pointer to mlan_adapter structure * * @return N/A */ t_void wlan_init_adapter(pmlan_adapter pmadapter) { int i; opt_sleep_confirm_buffer *sleep_cfm_buf = MNULL; ENTER(); sleep_cfm_buf = (opt_sleep_confirm_buffer *) (pmadapter->psleep_cfm->pbuf + pmadapter->psleep_cfm-> data_offset); #ifdef MFG_CMD_SUPPORT if (pmadapter->init_para.mfg_mode == MLAN_INIT_PARA_DISABLED) { pmadapter->mfg_mode = MFALSE; } else { pmadapter->mfg_mode = pmadapter->init_para.mfg_mode; } #endif pmadapter->int_mode = pmadapter->init_para.int_mode; pmadapter->gpio_pin = pmadapter->init_para.gpio_pin; pmadapter->cmd_sent = MFALSE; pmadapter->data_sent = MTRUE; pmadapter->mp_rd_bitmap = 0; pmadapter->mp_wr_bitmap = 0; pmadapter->curr_rd_port = 1; pmadapter->curr_wr_port = 1; for (i = 0; i < MAX_NUM_TID; i++) { pmadapter->tx_eligibility[i] = 1; } pmadapter->mp_data_port_mask = DATA_PORT_MASK; #ifdef SDIO_MULTI_PORT_TX_AGGR pmadapter->mpa_tx.buf_len = 0; pmadapter->mpa_tx.pkt_cnt = 0; pmadapter->mpa_tx.start_port = 0; if (!pmadapter->init_para.mpa_tx_cfg) { pmadapter->mpa_tx.enabled = 0; } else if (pmadapter->init_para.mpa_tx_cfg == MLAN_INIT_PARA_DISABLED) { pmadapter->mpa_tx.enabled = 0; } else { pmadapter->mpa_tx.enabled = 1; } pmadapter->mpa_tx.pkt_aggr_limit = SDIO_MP_AGGR_DEF_PKT_LIMIT; #endif /* SDIO_MULTI_PORT_TX_AGGR */ #ifdef SDIO_MULTI_PORT_RX_AGGR pmadapter->mpa_rx.buf_len = 0; pmadapter->mpa_rx.pkt_cnt = 0; pmadapter->mpa_rx.start_port = 0; if (!pmadapter->init_para.mpa_rx_cfg) { pmadapter->mpa_rx.enabled = 0; } else if (pmadapter->init_para.mpa_rx_cfg == MLAN_INIT_PARA_DISABLED) { pmadapter->mpa_rx.enabled = 0; } else { pmadapter->mpa_rx.enabled = 1; } pmadapter->mpa_rx.pkt_aggr_limit = SDIO_MP_AGGR_DEF_PKT_LIMIT; #endif /* SDIO_MULTI_PORT_RX_AGGR */ pmadapter->cmd_resp_received = MFALSE; pmadapter->event_received = MFALSE; pmadapter->data_received = MFALSE; pmadapter->cmd_timer_is_set = MFALSE; /* PnP and power profile */ pmadapter->surprise_removed = MFALSE; /* Status variables */ pmadapter->hw_status = WlanHardwareStatusInitializing; if (!pmadapter->init_para.ps_mode) { pmadapter->ps_mode = DEFAULT_PS_MODE; } else if (pmadapter->init_para.ps_mode == MLAN_INIT_PARA_DISABLED) { pmadapter->ps_mode = Wlan802_11PowerModeCAM; } else { pmadapter->ps_mode = Wlan802_11PowerModePSP; } pmadapter->ps_state = PS_STATE_AWAKE; pmadapter->need_to_wakeup = MFALSE; #ifdef STA_SUPPORT /* Scan type */ pmadapter->scan_type = MLAN_SCAN_TYPE_ACTIVE; /* Scan mode */ pmadapter->scan_mode = HostCmd_BSS_MODE_ANY; /* Scan time */ pmadapter->specific_scan_time = MRVDRV_SPECIFIC_SCAN_CHAN_TIME; pmadapter->active_scan_time = MRVDRV_ACTIVE_SCAN_CHAN_TIME; pmadapter->passive_scan_time = MRVDRV_PASSIVE_SCAN_CHAN_TIME; pmadapter->num_in_scan_table = 0; memset(pmadapter, pmadapter->pscan_table, 0, (sizeof(BSSDescriptor_t) * MRVDRV_MAX_BSSID_LIST)); pmadapter->scan_probes = DEFAULT_PROBES; memset(pmadapter, pmadapter->bcn_buf, 0, sizeof(pmadapter->bcn_buf)); pmadapter->pbcn_buf_end = pmadapter->bcn_buf; pmadapter->radio_on = RADIO_ON; pmadapter->multiple_dtim = MRVDRV_DEFAULT_MULTIPLE_DTIM; pmadapter->local_listen_interval = 0; /* default value in firmware will be used */ #endif /* STA_SUPPORT */ pmadapter->is_deep_sleep = MFALSE; if (!pmadapter->init_para.auto_ds) { pmadapter->init_auto_ds = DEFAULT_AUTO_DS_MODE; } else if (pmadapter->init_para.auto_ds == MLAN_INIT_PARA_DISABLED) { pmadapter->init_auto_ds = MFALSE; } else { pmadapter->init_auto_ds = MTRUE; } pmadapter->delay_null_pkt = MFALSE; pmadapter->delay_to_ps = DELAY_TO_PS_DEFAULT; pmadapter->enhanced_ps_mode = PS_MODE_AUTO; pmadapter->gen_null_pkt = MFALSE; /* Disable NULL Pkt generation-default */ pmadapter->pps_uapsd_mode = MFALSE; /* Disable pps/uapsd mode -default */ pmadapter->pm_wakeup_card_req = MFALSE; pmadapter->pm_wakeup_fw_try = MFALSE; if (!pmadapter->init_para.max_tx_buf) pmadapter->max_tx_buf_size = MLAN_TX_DATA_BUF_SIZE_2K; else pmadapter->max_tx_buf_size = (t_u16) pmadapter->init_para.max_tx_buf; pmadapter->tx_buf_size = MLAN_TX_DATA_BUF_SIZE_2K; pmadapter->curr_tx_buf_size = MLAN_TX_DATA_BUF_SIZE_2K; pmadapter->is_hs_configured = MFALSE; pmadapter->hs_cfg.conditions = HOST_SLEEP_DEF_COND; pmadapter->hs_cfg.gpio = HOST_SLEEP_DEF_GPIO; pmadapter->hs_cfg.gap = HOST_SLEEP_DEF_GAP; pmadapter->hs_activated = MFALSE; memset(pmadapter, pmadapter->event_body, 0, sizeof(pmadapter->event_body)); pmadapter->hw_dot_11n_dev_cap = 0; pmadapter->hw_dev_mcs_support = 0; pmadapter->usr_dot_11n_dev_cap = 0; pmadapter->usr_dev_mcs_support = 0; #ifdef STA_SUPPORT pmadapter->chan_offset = 0; pmadapter->adhoc_11n_enabled = MFALSE; #endif /* STA_SUPPORT */ #ifdef STA_SUPPORT /* Initialize 802.11d */ wlan_11d_init(pmadapter); #endif /* STA_SUPPORT */ #ifdef STA_SUPPORT wlan_11h_init(pmadapter); #endif wlan_wmm_init(pmadapter); if (pmadapter->psleep_cfm) { pmadapter->psleep_cfm->buf_type = MLAN_BUF_TYPE_CMD; pmadapter->psleep_cfm->data_len = sizeof(OPT_Confirm_Sleep); memset(pmadapter, &sleep_cfm_buf->ps_cfm_sleep, 0, sizeof(OPT_Confirm_Sleep)); sleep_cfm_buf->ps_cfm_sleep.command = wlan_cpu_to_le16(HostCmd_CMD_802_11_PS_MODE_ENH); sleep_cfm_buf->ps_cfm_sleep.size = wlan_cpu_to_le16(sizeof(OPT_Confirm_Sleep)); sleep_cfm_buf->ps_cfm_sleep.result = 0; sleep_cfm_buf->ps_cfm_sleep.action = wlan_cpu_to_le16(SLEEP_CONFIRM); sleep_cfm_buf->ps_cfm_sleep.sleep_cfm.resp_ctrl = wlan_cpu_to_le16(RESP_NEEDED); } memset(pmadapter, &pmadapter->sleep_params, 0, sizeof(pmadapter->sleep_params)); memset(pmadapter, &pmadapter->sleep_period, 0, sizeof(pmadapter->sleep_period)); pmadapter->tx_lock_flag = MFALSE; pmadapter->null_pkt_interval = 0; pmadapter->fw_bands = 0; pmadapter->config_bands = 0; pmadapter->adhoc_start_band = 0; pmadapter->pscan_channels = MNULL; pmadapter->fw_release_number = 0; pmadapter->fw_cap_info = 0; memset(pmadapter, &pmadapter->upld_buf, 0, sizeof(pmadapter->upld_buf)); pmadapter->upld_len = 0; pmadapter->event_cause = 0; pmadapter->pmlan_buffer_event = MNULL; memset(pmadapter, &pmadapter->region_channel, 0, sizeof(pmadapter->region_channel)); pmadapter->region_code = 0; pmadapter->bcn_miss_time_out = DEFAULT_BCN_MISS_TIMEOUT; pmadapter->adhoc_awake_period = 0; #ifdef STA_SUPPORT memset(pmadapter, &pmadapter->arp_filter, 0, sizeof(pmadapter->arp_filter)); pmadapter->arp_filter_size = 0; #endif /* STA_SUPPORT */ LEAVE(); return; }
/** * @brief Proc write function * * @param f File pointer * @param buf Pointer to data buffer * @param cnt Data number to write * @param data Data to write * * @return Number of data or MLAN_STATUS_FAILURE */ static int woal_debug_write(struct file *f, const char *buf, unsigned long cnt, void *data) { int r, i; char *pdata; char *p; char *p0; char *p1; char *p2; struct debug_data *d = ((struct debug_data_priv *) data)->items; moal_private *priv = ((struct debug_data_priv *) data)->priv; #ifdef DEBUG_LEVEL1 t_u32 last_drvdbg = drvdbg; #endif ENTER(); if (MODULE_GET == 0) { LEAVE(); return MLAN_STATUS_FAILURE; } pdata = (char *) kmalloc(cnt, GFP_KERNEL); if (pdata == NULL) { MODULE_PUT; LEAVE(); return 0; } if (copy_from_user(pdata, buf, cnt)) { PRINTM(MERROR, "Copy from user failed\n"); kfree(pdata); MODULE_PUT; LEAVE(); return 0; } if (woal_get_debug_info(priv, MOAL_PROC_WAIT, &info)) { kfree(pdata); MODULE_PUT; LEAVE(); return 0; } p0 = pdata; for (i = 0; i < ((struct debug_data_priv *) data)->num_of_items; i++) { do { p = strstr(p0, d[i].name); if (p == NULL) break; p1 = strchr(p, '\n'); if (p1 == NULL) break; p0 = p1++; p2 = strchr(p, '='); if (!p2) break; p2++; r = woal_string_to_number(p2); if (d[i].size == 1) *((t_u8 *) d[i].addr) = (t_u8) r; else if (d[i].size == 2) *((t_u16 *) d[i].addr) = (t_u16) r; else if (d[i].size == 4) *((t_ptr *) d[i].addr) = (t_ptr) r; break; } while (MTRUE); } kfree(pdata); #ifdef DEBUG_LEVEL1 if (last_drvdbg != drvdbg) { woal_set_drvdbg(priv, drvdbg); } #endif /* Set debug information */ if (woal_set_debug_info(priv, MOAL_PROC_WAIT, &info)) { MODULE_PUT; LEAVE(); return 0; } MODULE_PUT; LEAVE(); return cnt; }
VOID adcSetRecordCallBackFunction(AU_CB_FUN_T fnCallBack) { ENTER(); _tADC.fnRecCallBack = fnCallBack; }
/** * @brief Create debug proc file * * @param priv A pointer to a moal_private structure * * @return N/A */ void woal_debug_entry(moal_private * priv) { struct proc_dir_entry *r; int i; int handle_items; ENTER(); if (priv->proc_entry == NULL) { LEAVE(); return; } #ifdef STA_SUPPORT if (GET_BSS_ROLE(priv) == MLAN_BSS_ROLE_STA) { priv->items_priv.items = (struct debug_data *) kmalloc(sizeof(items), GFP_KERNEL); if (!priv->items_priv.items) { PRINTM(MERROR, "Failed to allocate memory for debug data\n"); LEAVE(); return; } memcpy(priv->items_priv.items, items, sizeof(items)); priv->items_priv.num_of_items = sizeof(items) / sizeof(items[0]); } #endif #ifdef UAP_SUPPORT if (GET_BSS_ROLE(priv) == MLAN_BSS_ROLE_UAP) { priv->items_priv.items = (struct debug_data *) kmalloc(sizeof(uap_items), GFP_KERNEL); if (!priv->items_priv.items) { PRINTM(MERROR, "Failed to allocate memory for debug data\n"); LEAVE(); return; } memcpy(priv->items_priv.items, uap_items, sizeof(uap_items)); priv->items_priv.num_of_items = sizeof(uap_items) / sizeof(uap_items[0]); } #endif priv->items_priv.priv = priv; handle_items = 8; #ifdef SDIO_MMC_DEBUG handle_items += 2; #endif #if defined(SDIO_SUSPEND_RESUME) handle_items += 2; #endif for (i = 1; i <= handle_items; i++) priv->items_priv.items[priv->items_priv.num_of_items - i].addr += (t_ptr) (priv->phandle); /* Create proc entry */ r = create_proc_entry("debug", 0644, priv->proc_entry); if (r == NULL) { LEAVE(); return; } r->data = &priv->items_priv; r->read_proc = woal_debug_read; r->write_proc = woal_debug_write; #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30) r->owner = THIS_MODULE; #endif LEAVE(); }
void w55fa93_adc_recording_setup(void) { UINT32 u32Reg; UINT32 eMode = eDRVADC_RECORD_MODE_1; ENTER(); #if 1 DrvADC_Open(eDRVADC_RECORD, //Record mode eDRVSYS_APLL, //Source clock come from UPLL 8); //Deafult 8K sample rate. DrvADC_SetGainControl(eDRVADC_PRE_P14, eDRVADC_POST_P34P5); // DrvADC_SetGainControl(eDRVADC_PRE_P14, eDRVADC_POST_P34P5); //eDRVADC_POST_P0); DrvADC_SetAutoGainTiming(4, //Period 4, //Attack 4, //Recovery 4); //Hold DrvADC_SetAutoGainControl(TRUE, //11, //Output target -12db //15, //Output target -6db //13, //Output target -9db 12, //Output target -10.5db eDRVADC_BAND_P0P5, eDRVADC_BAND_N0P5); DrvADC_SetOffsetCancellation(FALSE, //BOOL bIsMuteEnable, FALSE, //BOOL bIsOffsetCalibration, FALSE, //BOOL bIsHardwareMode, 0x10); //UINT32 u32Offset DrvADC_SetOffsetCancellationEx(1, //255 sample 512); //Delay sample count DrvADC_SetNoiseGate(FALSE, eDRVADC_NG_N48); #else DrvADC_Open(eDRVADC_RECORD, //Record mode eDRVSYS_APLL, //Source clock come from UPLL 8); //Deafult 8K sample rate. DrvADC_SetGainControl(eDRVADC_PRE_P14, eDRVADC_POST_P0); DrvADC_SetClampingAGC(eDRVADC_MAX_P17P25, eDRVADC_MIN_N12); DrvADC_SetAutoGainTiming(4, //Period 4, //Attack 4, //Recovery sync 4); //Hold DrvADC_SetOffsetCancellation(FALSE, //BOOL bIsMuteEnable, FALSE, //BOOL bIsOffsetCalibration, FALSE, //BOOL bIsHardwareMode, 0x1A); //UINT32 u32Offset DrvADC_SetOffsetCancellationEx(1, //255 sample 256); //Delay sample count DrvADC_SetNoiseGate(FALSE, eDRVADC_NG_N36); DrvADC_SetAutoGainControl(TRUE, 12, //Output target -10.5db //11, //Output target -12db eDRVADC_BAND_P0P5, eDRVADC_BAND_N0P5); #endif outp32(REG_AUDIO_CON, inp32(REG_AUDIO_CON) & ~AUDIO_INT_MODE & ~AUDIO_INT_EN); // one sample if finish outp32(REG_AGCP1,inp32(REG_AGCP1) | 0x80000000); // Enabe EDMA for ADC }
/** * @brief This function initializes firmware * * @param priv A pointer to wlan_private structure * @return WLAN_STATUS_SUCCESS or WLAN_STATUS_FAILURE */ int wlan_init_fw(wlan_private * priv) { int ret = WLAN_STATUS_SUCCESS; wlan_adapter *Adapter = priv->adapter; ENTER(); sbi_disable_host_int(priv); /* Check if firmware is already running */ if (sbi_check_fw_status(priv, 1) == WLAN_STATUS_SUCCESS) { PRINTM(MSG, "WLAN FW already running! Skip FW download\n"); } else { if ((ret = request_firmware(&priv->fw_helper, helper_name, priv->hotplug_device)) < 0) { PRINTM(FATAL, "request_firmware() failed (helper), error code = %#x\n", ret); goto done; } /* Download the helper */ ret = sbi_prog_helper(priv); if (ret) { PRINTM(INFO, "Bootloader in invalid state! Helper download failed!\n"); ret = WLAN_STATUS_FAILURE; goto done; } if ((ret = request_firmware(&priv->firmware, fw_name, priv->hotplug_device)) < 0) { PRINTM(FATAL, "request_firmware() failed, error code = %#x\n", ret); goto done; } /* Download the main firmware via the helper firmware */ if (sbi_prog_fw_w_helper(priv)) { PRINTM(INFO, "Wlan FW download failed!\n"); ret = WLAN_STATUS_FAILURE; goto done; } /* Check if the firmware is downloaded successfully or not */ if (sbi_check_fw_status(priv, MAX_FIRMWARE_POLL_TRIES) == WLAN_STATUS_FAILURE) { PRINTM(FATAL, "FW failed to be active in time!\n"); ret = WLAN_STATUS_FAILURE; goto done; } PRINTM(MSG, "WLAN FW is active\n"); } #define RF_REG_OFFSET 0x07 #define RF_REG_VALUE 0xc8 sbi_enable_host_int(priv); #ifdef MFG_CMD_SUPPORT if (mfgmode == 0) { #endif ret = wlan_prepare_cmd(priv, HostCmd_CMD_FUNC_INIT, 0, HostCmd_OPTION_WAITFORRSP | HostCmd_OPTION_TIMEOUT, 0, NULL); /* * Read MAC address from HW */ memset(Adapter->CurrentAddr, 0xff, ETH_ALEN); ret = wlan_prepare_cmd(priv, HostCmd_CMD_GET_HW_SPEC, 0, HostCmd_OPTION_WAITFORRSP | HostCmd_OPTION_TIMEOUT, 0, NULL); if (ret) { ret = WLAN_STATUS_FAILURE; goto done; } ret = wlan_prepare_cmd(priv, HostCmd_CMD_MAC_CONTROL, 0, HostCmd_OPTION_WAITFORRSP | HostCmd_OPTION_TIMEOUT, 0, &Adapter->CurrentPacketFilter); if (ret) { ret = WLAN_STATUS_FAILURE; goto done; } ret = wlan_prepare_cmd(priv, HostCmd_CMD_802_11_RATE_ADAPT_RATESET, HostCmd_ACT_GEN_GET, HostCmd_OPTION_WAITFORRSP | HostCmd_OPTION_TIMEOUT, 0, NULL); if (ret) { ret = WLAN_STATUS_FAILURE; goto done; } priv->adapter->DataRate = 0; ret = wlan_prepare_cmd(priv, HostCmd_CMD_802_11_RF_TX_POWER, HostCmd_ACT_GEN_GET, HostCmd_OPTION_WAITFORRSP | HostCmd_OPTION_TIMEOUT, 0, NULL); if (ret) { ret = WLAN_STATUS_FAILURE; goto done; } #ifdef MFG_CMD_SUPPORT } #endif Adapter->HardwareStatus = WlanHardwareStatusReady; ret = WLAN_STATUS_SUCCESS; done: if (priv->fw_helper) release_firmware(priv->fw_helper); if (priv->firmware) release_firmware(priv->firmware); if (ret != WLAN_STATUS_SUCCESS) { Adapter->HardwareStatus = WlanHardwareStatusNotReady; ret = WLAN_STATUS_FAILURE; } LEAVE(); return ret; }
void rx_addrnew(UNUSED struct RexxHost *host, struct RexxParams *params, enum RexxAction action, UNUSED struct RexxMsg *rexxmsg) { struct args *args = params->args; struct results *results = params->results; struct optional *optional = params->optional; ENTER(); switch(action) { case RXIF_INIT: { params->args = AllocVecPooled(G->SharedMemPool, sizeof(*args)); params->results = AllocVecPooled(G->SharedMemPool, sizeof(*results)); params->optional = AllocVecPooled(G->SharedMemPool, sizeof(*optional)); if(params->optional == NULL) params->rc = RETURN_ERROR; } break; case RXIF_ACTION: { enum ABookNodeType type; if(args->type != NULL) { if(tolower(*args->type) == 'g') type = ABNT_GROUP; else if(tolower(*args->type) == 'l') type = ABNT_LIST; else type = ABNT_USER; } else type = ABNT_USER; InitABookNode(&optional->abn, type); if(args->alias != NULL) strlcpy(optional->abn.Alias, args->alias, sizeof(optional->abn.Alias)); if(args->name != NULL) strlcpy(optional->abn.RealName, args->name, sizeof(optional->abn.RealName)); if(args->email != NULL) strlcpy(optional->abn.Address, args->email, sizeof(optional->abn.Address)); if(IsStrEmpty(optional->abn.Alias) == TRUE) { if(optional->abn.type == ABNT_USER) SetDefaultAlias(&optional->abn); else params->rc = RETURN_ERROR; } if(params->rc == 0) { struct ABookNode *abn; FixAlias(&G->abook, &optional->abn, NULL); results->alias = optional->abn.Alias; if((abn = CreateABookNode(optional->abn.type)) != NULL) { struct ABookNode *group; struct ABookNode *afterThis; memcpy(abn, &optional->abn, sizeof(*abn)); if(G->ABookWinObject != NULL) { group = (struct ABookNode *)xget(G->ABookWinObject, MUIA_AddressBookWindow_ActiveGroup); afterThis = (struct ABookNode *)xget(G->ABookWinObject, MUIA_AddressBookWindow_ActiveEntry); } else { group = &G->abook.rootGroup; afterThis = NULL; } AddABookNode(group, abn, afterThis); G->abook.arexxABN = abn; G->abook.modified = TRUE; // update an existing address book window as well if(G->ABookWinObject != NULL) DoMethod(G->ABookWinObject, MUIM_AddressBookWindow_RebuildTree); set(G->ABookWinObject, MUIA_AddressBookWindow_Modified, TRUE); AppendToLogfile(LF_VERBOSE, 71, tr(MSG_LOG_NewAddress), optional->abn.Alias); } else params->rc = RETURN_ERROR; } } break; case RXIF_FREE: { if(args != NULL) FreeVecPooled(G->SharedMemPool, args); if(results != NULL) FreeVecPooled(G->SharedMemPool, results); if(optional != NULL) FreeVecPooled(G->SharedMemPool, optional); } break; } LEAVE(); }
/** * @brief This function downloads the firmware * * @param pmlan_adapter A pointer to a t_void pointer to store * mlan_adapter structure pointer * @param pmfw A pointer to firmware image * * @return MLAN_STATUS_SUCCESS * The firmware download succeeded. * MLAN_STATUS_FAILURE * The firmware download failed. */ mlan_status mlan_dnld_fw(IN t_void * pmlan_adapter, IN pmlan_fw_image pmfw) { mlan_status ret = MLAN_STATUS_SUCCESS; mlan_adapter *pmadapter = (mlan_adapter *) pmlan_adapter; t_u32 poll_num = 1; t_u32 winner = 0; ENTER(); MASSERT(pmlan_adapter); /* Card specific probing */ ret = wlan_sdio_probe(pmadapter); if (ret == MLAN_STATUS_FAILURE) { PRINTM(MERROR, "WLAN SDIO probe failed\n", ret); LEAVE(); return ret; } /* Check if firmware is already running */ ret = wlan_check_fw_status(pmadapter, poll_num); if (ret == MLAN_STATUS_SUCCESS) { PRINTM(MMSG, "WLAN FW already running! Skip FW download\n"); goto done; } poll_num = MAX_FIRMWARE_POLL_TRIES; /* Check if other interface is downloading */ ret = wlan_check_winner_status(pmadapter, &winner); if (ret == MLAN_STATUS_FAILURE) { PRINTM(MFATAL, "WLAN read winner status failed!\n"); goto done; } if (winner) { PRINTM(MMSG, "WLAN is not the winner (0x%x). Skip FW download\n", winner); poll_num = MAX_MULTI_INTERFACE_POLL_TRIES; goto poll_fw; } if (pmfw) { /* Download helper/firmware */ ret = wlan_dnld_fw(pmadapter, pmfw); if (ret != MLAN_STATUS_SUCCESS) { PRINTM(MERROR, "wlan_dnld_fw fail ret=0x%x\n", ret); LEAVE(); return ret; } } poll_fw: /* Check if the firmware is downloaded successfully or not */ ret = wlan_check_fw_status(pmadapter, poll_num); if (ret != MLAN_STATUS_SUCCESS) { PRINTM(MFATAL, "FW failed to be active in time!\n"); ret = MLAN_STATUS_FAILURE; LEAVE(); return ret; } done: /* re-enable host interrupt for mlan after fw dnld is successful */ wlan_enable_host_int(pmadapter); LEAVE(); return ret; }
/** * @brief ioctl function for wireless IOCTLs * * @param dev A pointer to net_device structure * @param req A pointer to ifreq structure * @param cmd Command * * @return 0 --success, otherwise fail */ int woal_uap_do_priv_ioctl(struct net_device *dev, struct ifreq *req, int cmd) { moal_private *priv = (moal_private *) netdev_priv(dev); struct iwreq *wrq = (struct iwreq *) req; int ret = 0; ENTER(); switch (cmd) { case WOAL_UAP_SETNONE_GETNONE: switch (wrq->u.data.flags) { case WOAL_UAP_START: break; case WOAL_UAP_STOP: ret = woal_uap_bss_ctrl(priv, MOAL_IOCTL_WAIT, UAP_BSS_STOP); break; case WOAL_AP_BSS_START: ret = woal_uap_bss_ctrl(priv, MOAL_IOCTL_WAIT, UAP_BSS_START); break; case WOAL_AP_BSS_STOP: ret = woal_uap_bss_ctrl(priv, MOAL_IOCTL_WAIT, UAP_BSS_STOP); break; default: ret = -EINVAL; break; } break; case WOAL_UAP_SETONEINT_GETWORDCHAR: switch (wrq->u.data.flags) { case WOAL_UAP_VERSION: ret = woal_get_driver_version(priv, req); break; case WOAL_UAP_VEREXT: ret = woal_get_driver_verext(priv, req); break; default: ret = -EOPNOTSUPP; break; } break; case WOAL_UAP_SET_GET_256_CHAR: switch (wrq->u.data.flags) { case WOAL_WL_FW_RELOAD: break; case WOAL_AP_SET_CFG: ret = woal_uap_set_ap_cfg(priv, wrq); break; default: ret = -EINVAL; break; } break; #if defined(WFD_SUPPORT) #if defined(STA_SUPPORT) && defined(UAP_SUPPORT) case WOAL_UAP_SETONEINT_GETONEINT: switch (wrq->u.data.flags) { case WOAL_UAP_SET_GET_BSS_ROLE: ret = woal_set_get_bss_role(priv, wrq); break; default: ret = -EINVAL; break; } break; #endif #endif case WOAL_UAP_HOST_CMD: ret = woal_host_command(priv, wrq); break; case WOAL_UAP_FROYO_START: break; case WOAL_UAP_FROYO_STOP: ret = woal_uap_bss_ctrl(priv, MOAL_IOCTL_WAIT, UAP_BSS_STOP); break; case WOAL_UAP_FROYO_AP_BSS_START: ret = woal_uap_bss_ctrl(priv, MOAL_IOCTL_WAIT, UAP_BSS_START); break; case WOAL_UAP_FROYO_AP_BSS_STOP: ret = woal_uap_bss_ctrl(priv, MOAL_IOCTL_WAIT, UAP_BSS_STOP); break; case WOAL_UAP_FROYO_WL_FW_RELOAD: break; case WOAL_UAP_FROYO_AP_SET_CFG: ret = woal_uap_set_ap_cfg(priv, wrq); break; default: ret = -EINVAL; break; } LEAVE(); return ret; }
static isc_result_t process_request(isc_httpd_t *httpd, int length) { char *s; char *p; int delim; ENTER("request"); httpd->recvlen += length; httpd->recvbuf[httpd->recvlen] = 0; httpd->headers = NULL; /* * If we don't find a blank line in our buffer, return that we need * more data. */ s = strstr(httpd->recvbuf, "\r\n\r\n"); delim = 1; if (s == NULL) { s = strstr(httpd->recvbuf, "\n\n"); delim = 2; } if (s == NULL) return (ISC_R_NOTFOUND); /* * Determine if this is a POST or GET method. Any other values will * cause an error to be returned. */ if (strncmp(httpd->recvbuf, "GET ", 4) == 0) { httpd->method = ISC_HTTPD_METHODGET; p = httpd->recvbuf + 4; } else if (strncmp(httpd->recvbuf, "POST ", 5) == 0) { httpd->method = ISC_HTTPD_METHODPOST; p = httpd->recvbuf + 5; } else { return (ISC_R_RANGE); } /* * From now on, p is the start of our buffer. */ /* * Extract the URL. */ s = p; while (LENGTHOK(s) && BUFLENOK(s) && (*s != '\n' && *s != '\r' && *s != '\0' && *s != ' ')) s++; if (!LENGTHOK(s)) return (ISC_R_NOTFOUND); if (!BUFLENOK(s)) return (ISC_R_NOMEMORY); *s = 0; /* * Make the URL relative. */ if ((strncmp(p, "http:/", 6) == 0) || (strncmp(p, "https:/", 7) == 0)) { /* Skip first / */ while (*p != '/' && *p != 0) p++; if (*p == 0) return (ISC_R_RANGE); p++; /* Skip second / */ while (*p != '/' && *p != 0) p++; if (*p == 0) return (ISC_R_RANGE); p++; /* Find third / */ while (*p != '/' && *p != 0) p++; if (*p == 0) { p--; *p = '/'; } } httpd->url = p; p = s + delim; s = p; /* * Now, see if there is a ? mark in the URL. If so, this is * part of the query string, and we will split it from the URL. */ httpd->querystring = strchr(httpd->url, '?'); if (httpd->querystring != NULL) { *(httpd->querystring) = 0; httpd->querystring++; } /* * Extract the HTTP/1.X protocol. We will bounce on anything but * HTTP/1.1 for now. */ while (LENGTHOK(s) && BUFLENOK(s) && (*s != '\n' && *s != '\r' && *s != '\0')) s++; if (!LENGTHOK(s)) return (ISC_R_NOTFOUND); if (!BUFLENOK(s)) return (ISC_R_NOMEMORY); *s = 0; if ((strncmp(p, "HTTP/1.0", 8) != 0) && (strncmp(p, "HTTP/1.1", 8) != 0)) return (ISC_R_RANGE); httpd->protocol = p; p = s + 1; s = p; httpd->headers = s; if (strstr(s, "Connection: close") != NULL) httpd->flags |= HTTPD_CLOSE; if (strstr(s, "Host: ") != NULL) httpd->flags |= HTTPD_FOUNDHOST; /* * Standards compliance hooks here. */ if (strcmp(httpd->protocol, "HTTP/1.1") == 0 && ((httpd->flags & HTTPD_FOUNDHOST) == 0)) return (ISC_R_RANGE); EXIT("request"); return (ISC_R_SUCCESS); }
/** * @brief Parse AP configuration from ASCII string * * @param ap_cfg A pointer to mlan_uap_bss_param structure * @param buf A pointer to user data * * @return 0 --success, otherwise fail */ static int woal_uap_ap_cfg_parse_data(mlan_uap_bss_param * ap_cfg, t_s8 * buf) { int ret = 0, atoi_ret; int set_sec = 0, set_key = 0, set_chan = 0; int set_preamble = 0, set_scb = 0, set_ssid = 0; t_s8 *begin = buf, *value = NULL, *opt = NULL; ENTER(); while (begin) { value = woal_strsep(&begin, ',', '/'); opt = woal_strsep(&value, '=', '/'); if (opt && !strncmp(opt, "END", strlen("END"))) { if (!ap_cfg->ssid.ssid_len) { PRINTM(MERROR, "Minimum option required is SSID\n"); ret = -EINVAL; goto done; } PRINTM(MINFO, "Parsing terminated by string END\n"); break; } if (!opt || !value || !value[0]) { PRINTM(MERROR, "Invalid option\n"); ret = -EINVAL; goto done; } else if (!strncmp(opt, "ASCII_CMD", strlen("ASCII_CMD"))) { if (strncmp(value, "AP_CFG", strlen("AP_CFG"))) { PRINTM(MERROR, "ASCII_CMD: %s not matched with AP_CFG\n", value); ret = -EFAULT; goto done; } value = woal_strsep(&begin, ',', '/'); opt = woal_strsep(&value, '=', '/'); if (!opt || !value || !value[0]) { PRINTM(MERROR, "Minimum option required is SSID\n"); ret = -EINVAL; goto done; } else if (!strncmp(opt, "SSID", strlen("SSID"))) { if (set_ssid) { PRINTM(MWARN, "Skipping SSID, found again!\n"); continue; } if (strlen(value) > MLAN_MAX_SSID_LENGTH) { PRINTM(MERROR, "SSID length exceeds max length\n"); ret = -EFAULT; goto done; } ap_cfg->ssid.ssid_len = strlen(value); strncpy((char *) ap_cfg->ssid.ssid, value, strlen(value)); PRINTM(MINFO, "ssid=%s, len=%d\n", ap_cfg->ssid.ssid, (int) ap_cfg->ssid.ssid_len); set_ssid = 1; } else { PRINTM(MERROR, "AP_CFG: Invalid option %s, " "expect SSID\n", opt); ret = -EINVAL; goto done; } } else if (!strncmp(opt, "SEC", strlen("SEC"))) { if (set_sec) { PRINTM(MWARN, "Skipping SEC, found again!\n"); continue; } if (!strnicmp(value, "open", strlen("open"))) { ap_cfg->auth_mode = MLAN_AUTH_MODE_OPEN; if (set_key) ap_cfg->wpa_cfg.length = 0; ap_cfg->key_mgmt = KEY_MGMT_NONE; ap_cfg->protocol = PROTOCOL_NO_SECURITY; } else if (!strnicmp(value, "wpa2-psk", strlen("wpa2-psk"))) { ap_cfg->auth_mode = MLAN_AUTH_MODE_OPEN; ap_cfg->protocol = PROTOCOL_WPA2; ap_cfg->key_mgmt = KEY_MGMT_PSK; ap_cfg->wpa_cfg.pairwise_cipher_wpa = CIPHER_AES_CCMP; ap_cfg->wpa_cfg.pairwise_cipher_wpa2 = CIPHER_AES_CCMP; ap_cfg->wpa_cfg.group_cipher = CIPHER_AES_CCMP; } else { PRINTM(MERROR, "AP_CFG: Invalid value=%s for %s\n", value, opt); ret = -EFAULT; goto done; } set_sec = 1; } else if (!strncmp(opt, "KEY", strlen("KEY"))) { if (set_key) { PRINTM(MWARN, "Skipping KEY, found again!\n"); continue; } if (set_sec && ap_cfg->protocol != PROTOCOL_WPA2) { PRINTM(MWARN, "Warning! No KEY for open mode\n"); set_key = 1; continue; } if (strlen(value) < MLAN_MIN_PASSPHRASE_LENGTH || strlen(value) > MLAN_PMK_HEXSTR_LENGTH) { PRINTM(MERROR, "Invalid PSK/PMK length\n"); ret = -EINVAL; goto done; } ap_cfg->wpa_cfg.length = strlen(value); memcpy(ap_cfg->wpa_cfg.passphrase, value, strlen(value)); set_key = 1; } else if (!strncmp(opt, "CHANNEL", strlen("CHANNEL"))) { if (set_chan) { PRINTM(MWARN, "Skipping CHANNEL, found again!\n"); continue; } if (woal_atoi(&atoi_ret, value)) { ret = -EINVAL; goto done; } if (atoi_ret < 1 || atoi_ret > MLAN_MAX_CHANNEL) { PRINTM(MERROR, "AP_CFG: Channel must be between 1 and %d" "(both included)\n", MLAN_MAX_CHANNEL); ret = -EINVAL; goto done; } ap_cfg->channel = atoi_ret; set_chan = 1; } else if (!strncmp(opt, "PREAMBLE", strlen("PREAMBLE"))) { if (set_preamble) { PRINTM(MWARN, "Skipping PREAMBLE, found again!\n"); continue; } if (woal_atoi(&atoi_ret, value)) { ret = -EINVAL; goto done; } /* This is a READ only value from FW, so we can not set this and pass it successfully */ set_preamble = 1; } else if (!strncmp(opt, "MAX_SCB", strlen("MAX_SCB"))) { if (set_scb) { PRINTM(MWARN, "Skipping MAX_SCB, found again!\n"); continue; } if (woal_atoi(&atoi_ret, value)) { ret = -EINVAL; goto done; } if (atoi_ret < 1 || atoi_ret > MAX_STA_COUNT) { PRINTM(MERROR, "AP_CFG: MAX_SCB must be between 1 to %d " "(both included)\n", MAX_STA_COUNT); ret = -EINVAL; goto done; } ap_cfg->max_sta_count = (t_u16) atoi_ret; set_scb = 1; } else { PRINTM(MERROR, "Invalid option %s\n", opt); ret = -EINVAL; goto done; } } done: LEAVE(); return ret; }
static void isc_httpd_recvdone(isc_task_t *task, isc_event_t *ev) { isc_region_t r; isc_result_t result; isc_httpd_t *httpd = ev->ev_arg; isc_socketevent_t *sev = (isc_socketevent_t *)ev; isc_httpdurl_t *url; isc_time_t now; char datebuf[32]; /* Only need 30, but safety first */ ENTER("recv"); INSIST(ISC_HTTPD_ISRECV(httpd)); if (sev->result != ISC_R_SUCCESS) { NOTICE("recv destroying client"); destroy_client(&httpd); goto out; } result = process_request(httpd, sev->n); if (result == ISC_R_NOTFOUND) { if (httpd->recvlen >= HTTP_RECVLEN - 1) { destroy_client(&httpd); goto out; } r.base = (unsigned char *)httpd->recvbuf + httpd->recvlen; r.length = HTTP_RECVLEN - httpd->recvlen - 1; /* check return code? */ (void)isc_socket_recv(httpd->sock, &r, 1, task, isc_httpd_recvdone, httpd); goto out; } else if (result != ISC_R_SUCCESS) { destroy_client(&httpd); goto out; } ISC_HTTPD_SETSEND(httpd); /* * XXXMLG Call function here. Provide an add-header function * which will append the common headers to a response we generate. */ isc_buffer_initnull(&httpd->bodybuffer); isc_time_now(&now); isc_time_formathttptimestamp(&now, datebuf, sizeof(datebuf)); url = ISC_LIST_HEAD(httpd->mgr->urls); while (url != NULL) { if (strcmp(httpd->url, url->url) == 0) break; url = ISC_LIST_NEXT(url, link); } if (url == NULL) result = httpd->mgr->render_404(httpd->url, NULL, httpd->querystring, NULL, NULL, &httpd->retcode, &httpd->retmsg, &httpd->mimetype, &httpd->bodybuffer, &httpd->freecb, &httpd->freecb_arg); else result = url->action(httpd->url, url, httpd->querystring, httpd->headers, url->action_arg, &httpd->retcode, &httpd->retmsg, &httpd->mimetype, &httpd->bodybuffer, &httpd->freecb, &httpd->freecb_arg); if (result != ISC_R_SUCCESS) { result = httpd->mgr->render_500(httpd->url, url, httpd->querystring, NULL, NULL, &httpd->retcode, &httpd->retmsg, &httpd->mimetype, &httpd->bodybuffer, &httpd->freecb, &httpd->freecb_arg); RUNTIME_CHECK(result == ISC_R_SUCCESS); } isc_httpd_response(httpd); isc_httpd_addheader(httpd, "Content-Type", httpd->mimetype); isc_httpd_addheader(httpd, "Date", datebuf); isc_httpd_addheader(httpd, "Expires", datebuf); if (url != NULL && url->isstatic) { char loadbuf[32]; isc_time_formathttptimestamp(&url->loadtime, loadbuf, sizeof(loadbuf)); isc_httpd_addheader(httpd, "Last-Modified", loadbuf); isc_httpd_addheader(httpd, "Cache-Control: public", NULL); } else { isc_httpd_addheader(httpd, "Last-Modified", datebuf); isc_httpd_addheader(httpd, "Pragma: no-cache", NULL); isc_httpd_addheader(httpd, "Cache-Control: no-cache", NULL); } isc_httpd_addheader(httpd, "Server: libisc", NULL); isc_httpd_addheaderuint(httpd, "Content-Length", isc_buffer_usedlength(&httpd->bodybuffer)); isc_httpd_endheaders(httpd); /* done */ ISC_LIST_APPEND(httpd->bufflist, &httpd->headerbuffer, link); /* * Link the data buffer into our send queue, should we have any data * rendered into it. If no data is present, we won't do anything * with the buffer. */ if (isc_buffer_length(&httpd->bodybuffer) > 0) ISC_LIST_APPEND(httpd->bufflist, &httpd->bodybuffer, link); /* check return code? */ (void)isc_socket_sendv(httpd->sock, &httpd->bufflist, task, isc_httpd_senddone, httpd); out: isc_event_free(&ev); EXIT("recv"); }
static int handle_subscription_request(struct Upnp_Subscription_Request *sr_event) { struct service *srv; int i; int eventVarCount = 0, eventVarIdx = 0; const char **eventvar_names = NULL; char **eventvar_values = NULL; int rc; int result = -1; ENTER(); srv = find_service(upnp_device, sr_event->ServiceId); if (srv == NULL) { debug_printf(MSG_ERROR, "%s: Unknown service '%s'\n", __FUNCTION__, sr_event->ServiceId); goto out; } ithread_mutex_lock(&(upnp_device->device_mutex)); /* generate list of eventable variables */ for(i=0; i<srv->variable_count; i++) { struct var_meta *metaEntry; metaEntry = &(srv->variable_meta[i]); if (metaEntry->sendevents == SENDEVENT_YES) { eventVarCount++; } } eventvar_names = malloc((eventVarCount+1) * sizeof(const char *)); if (NULL == eventvar_names) { debug_printf(MSG_ERROR, "eventvar_names malloc fail, eventVarCount:%d\n", eventVarCount); return 1; } eventvar_values = malloc((eventVarCount+1) * sizeof(const char *)); if (NULL == eventvar_values) { debug_printf(MSG_ERROR, "eventvar_values malloc fail, eventVarCount:%d\n", eventVarCount); free(eventvar_names); return 1; } //printf("%d evented variables\n", eventVarCount); for(i=0; i<srv->variable_count; i++) { struct var_meta *metaEntry; metaEntry = &(srv->variable_meta[i]); if (metaEntry->sendevents == SENDEVENT_YES) { eventvar_names[eventVarIdx] = srv->variable_names[i]; eventvar_values[eventVarIdx] = xmlescape(srv->variable_values[i], 0); //printf("Evented: '%s' == '%s'\n", // eventvar_names[eventVarIdx], // eventvar_values[eventVarIdx]); eventVarIdx++; } } eventvar_names[eventVarIdx] = NULL; eventvar_values[eventVarIdx] = NULL; rc = UpnpAcceptSubscription(device_handle, sr_event->UDN, sr_event->ServiceId, (const char **)eventvar_names, (const char **)eventvar_values, eventVarCount, sr_event->Sid); if (rc == UPNP_E_SUCCESS) { result = 0; } ithread_mutex_unlock(&(upnp_device->device_mutex)); for(i=0; i<eventVarCount; i++) { free(eventvar_values[i]); } free(eventvar_names); free(eventvar_values); out: LEAVE(); return result; }
/** * @brief This function checks the conditions and sends packet to device * * @param priv A pointer to mlan_private structure * @param pmbuf A pointer to the mlan_buffer for process * @param tx_param A pointer to mlan_tx_param structure * * @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --success, otherwise failure */ mlan_status wlan_process_tx(pmlan_private priv, pmlan_buffer pmbuf, mlan_tx_param * tx_param) { mlan_status ret = MLAN_STATUS_SUCCESS; pmlan_adapter pmadapter = priv->adapter; t_u8 *head_ptr = MNULL; #ifdef DEBUG_LEVEL1 t_u32 sec = 0, usec = 0; #endif #ifdef STA_SUPPORT TxPD *plocal_tx_pd = MNULL; #endif ENTER(); head_ptr = (t_u8 *) priv->ops.process_txpd(priv, pmbuf); if (!head_ptr) { pmbuf->status_code = MLAN_ERROR_PKT_INVALID; ret = MLAN_STATUS_FAILURE; goto done; } #ifdef STA_SUPPORT if (GET_BSS_ROLE(priv) == MLAN_BSS_ROLE_STA) plocal_tx_pd = (TxPD *) (head_ptr + INTF_HEADER_LEN); #endif ret = wlan_sdio_host_to_card(pmadapter, MLAN_TYPE_DATA, pmbuf, tx_param); done: switch (ret) { case MLAN_STATUS_RESOURCE: #ifdef STA_SUPPORT if ((GET_BSS_ROLE(priv) == MLAN_BSS_ROLE_STA) && pmadapter->pps_uapsd_mode && (pmadapter->tx_lock_flag == MTRUE)) { pmadapter->tx_lock_flag = MFALSE; plocal_tx_pd->flags = 0; } #endif PRINTM(MINFO, "MLAN_STATUS_RESOURCE is returned\n"); break; case MLAN_STATUS_FAILURE: pmadapter->data_sent = MFALSE; PRINTM(MERROR, "Error: host_to_card failed: 0x%X\n", ret); pmadapter->dbg.num_tx_host_to_card_failure++; pmbuf->status_code = MLAN_ERROR_DATA_TX_FAIL; wlan_write_data_complete(pmadapter, pmbuf, ret); break; case MLAN_STATUS_PENDING: pmadapter->data_sent = MFALSE; DBG_HEXDUMP(MDAT_D, "Tx", head_ptr + INTF_HEADER_LEN, MIN(pmbuf->data_len + sizeof(TxPD), MAX_DATA_DUMP_LEN)); break; case MLAN_STATUS_SUCCESS: DBG_HEXDUMP(MDAT_D, "Tx", head_ptr + INTF_HEADER_LEN, MIN(pmbuf->data_len + sizeof(TxPD), MAX_DATA_DUMP_LEN)); wlan_write_data_complete(pmadapter, pmbuf, ret); break; default: break; } if ((ret == MLAN_STATUS_SUCCESS) || (ret == MLAN_STATUS_PENDING)) { PRINTM_GET_SYS_TIME(MDATA, &sec, &usec); PRINTM_NETINTF(MDATA, priv); PRINTM(MDATA, "%lu.%06lu : Data => FW\n", sec, usec); } LEAVE(); return ret; }
/** * @brief Proc read function * * @param page Pointer to buffer * @param s Read data starting position * @param off Offset * @param cnt Counter * @param eof End of file flag * @param data Output data * * @return Number of output data or MLAN_STATUS_FAILURE */ static int woal_debug_read(char *page, char **s, off_t off, int cnt, int *eof, void *data) { int val = 0; unsigned int i; char *p = page; struct debug_data *d = ((struct debug_data_priv *) data)->items; moal_private *priv = ((struct debug_data_priv *) data)->priv; ENTER(); if (MODULE_GET == 0) { LEAVE(); return MLAN_STATUS_FAILURE; } /* Get debug information */ if (woal_get_debug_info(priv, MOAL_PROC_WAIT, &info)) { *eof = 1; goto exit; } for (i = 0; i < (unsigned int) ((struct debug_data_priv *) data)->num_of_items; i++) { if (d[i].size == 1) val = *((t_u8 *) d[i].addr); else if (d[i].size == 2) val = *((t_u16 *) d[i].addr); else if (d[i].size == 4) val = *((t_ptr *) d[i].addr); else { unsigned int j; p += sprintf(p, "%s=", d[i].name); for (j = 0; j < d[i].size; j += 2) { val = *(t_u16 *) (d[i].addr + j); p += sprintf(p, "0x%x ", val); } p += sprintf(p, "\n"); continue; } if (strstr(d[i].name, "id") || strstr(d[i].name, "bitmap") ) p += sprintf(p, "%s=0x%x\n", d[i].name, val); else p += sprintf(p, "%s=%d\n", d[i].name, val); } #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,29) for (i = 0; i < 4; i++) p += sprintf(p, "wmm_tx_pending[%d]:%d\n", i, atomic_read(&priv->wmm_tx_pending[i])); #endif if (info.tx_tbl_num) { p += sprintf(p, "Tx BA stream table:\n"); for (i = 0; i < info.tx_tbl_num; i++) { p += sprintf(p, "tid = %d, ra = %02x:%02x:%02x:%02x:%02x:%02x amsdu=%d\n", (int) info.tx_tbl[i].tid, info.tx_tbl[i].ra[0], info.tx_tbl[i].ra[1], info.tx_tbl[i].ra[2], info.tx_tbl[i].ra[3], info.tx_tbl[i].ra[4], info.tx_tbl[i].ra[5], (int) info.tx_tbl[i].amsdu); } } if (info.rx_tbl_num) { p += sprintf(p, "Rx reorder table:\n"); for (i = 0; i < info.rx_tbl_num; i++) { unsigned int j; p += sprintf(p, "tid = %d, ta = %02x:%02x:%02x:%02x:%02x:%02x, start_win = %d, " "win_size = %d, amsdu=%d\n", (int) info.rx_tbl[i].tid, info.rx_tbl[i].ta[0], info.rx_tbl[i].ta[1], info.rx_tbl[i].ta[2], info.rx_tbl[i].ta[3], info.rx_tbl[i].ta[4], info.rx_tbl[i].ta[5], (int) info.rx_tbl[i].start_win, (int) info.rx_tbl[i].win_size, (int) info.rx_tbl[i].amsdu); p += sprintf(p, "buffer: "); for (j = 0; j < info.rx_tbl[i].win_size; j++) { if (info.rx_tbl[i].buffer[j] == MTRUE) p += sprintf(p, "1 "); else p += sprintf(p, "0 "); } p += sprintf(p, "\n"); } } exit: MODULE_PUT; LEAVE(); return p - page; }
static espeak_ERROR Synthesize(unsigned int unique_identifier, const void *text, int flags) {//======================================================================================== // Fill the buffer with output sound int length; int finished = 0; int count_buffers = 0; #ifdef USE_ASYNC uint32_t a_write_pos=0; #endif #ifdef DEBUG_ENABLED ENTER("Synthesize"); if (text) { SHOW("Synthesize > uid=%d, flags=%d, >>>text=%s<<<\n", unique_identifier, flags, text); } #endif if((outbuf==NULL) || (event_list==NULL)) return(EE_INTERNAL_ERROR); // espeak_Initialize() has not been called option_multibyte = flags & 7; option_ssml = flags & espeakSSML; option_phoneme_input = flags & espeakPHONEMES; option_endpause = flags & espeakENDPAUSE; count_samples = 0; #ifdef USE_ASYNC if(my_mode == AUDIO_OUTPUT_PLAYBACK) { a_write_pos = wave_get_write_position(my_audio); } #endif if(translator == NULL) { SetVoiceByName("default"); } SpeakNextClause(NULL,text,0); if(my_mode == AUDIO_OUTPUT_SYNCH_PLAYBACK) { for(;;) { #ifdef PLATFORM_WINDOWS Sleep(300); // 0.3s #else #ifdef USE_NANOSLEEP struct timespec period; struct timespec remaining; period.tv_sec = 0; period.tv_nsec = 300000000; // 0.3 sec nanosleep(&period,&remaining); #else sleep(1); #endif #endif if(SynthOnTimer() != 0) break; } return(EE_OK); } for(;;) { #ifdef DEBUG_ENABLED SHOW("Synthesize > %s\n","for (next)"); #endif out_ptr = outbuf; out_end = &outbuf[outbuf_size]; event_list_ix = 0; WavegenFill(0); length = (out_ptr - outbuf)/2; count_samples += length; event_list[event_list_ix].type = espeakEVENT_LIST_TERMINATED; // indicates end of event list event_list[event_list_ix].unique_identifier = my_unique_identifier; event_list[event_list_ix].user_data = my_user_data; count_buffers++; if (my_mode==AUDIO_OUTPUT_PLAYBACK) { #ifdef USE_ASYNC finished = create_events((short *)outbuf, length, event_list, a_write_pos); if(finished < 0) return EE_INTERNAL_ERROR; length = 0; // the wave data are played once. #endif } else { finished = synth_callback((short *)outbuf, length, event_list); } if(finished) { SpeakNextClause(NULL,0,2); // stop break; } if(Generate(phoneme_list,&n_phoneme_list,1)==0) { if(WcmdqUsed() == 0) { // don't process the next clause until the previous clause has finished generating speech. // This ensures that <audio> tag (which causes end-of-clause) is at a sound buffer boundary event_list[0].type = espeakEVENT_LIST_TERMINATED; event_list[0].unique_identifier = my_unique_identifier; event_list[0].user_data = my_user_data; if(SpeakNextClause(NULL,NULL,1)==0) { #ifdef USE_ASYNC if (my_mode==AUDIO_OUTPUT_PLAYBACK) { if(dispatch_audio(NULL, 0, NULL) < 0) // TBD: test case return err = EE_INTERNAL_ERROR; } else { synth_callback(NULL, 0, event_list); // NULL buffer ptr indicates end of data } #else synth_callback(NULL, 0, event_list); // NULL buffer ptr indicates end of data #endif break; } } } } return(EE_OK); } // end of Synthesize
int define_Computed_field_type_sin(struct Parse_state *state, void *field_modify_void,void *computed_field_trigonometry_package_void) /******************************************************************************* LAST MODIFIED : 24 August 2006 DESCRIPTION : Converts <field> into type COMPUTED_FIELD_SIN (if it is not already) and allows its contents to be modified. ==============================================================================*/ { int return_code; struct Computed_field **source_fields; Computed_field_modify_data *field_modify; struct Option_table *option_table; struct Set_Computed_field_array_data set_source_field_array_data; struct Set_Computed_field_conditional_data set_source_field_data; ENTER(define_Computed_field_type_sin); USE_PARAMETER(computed_field_trigonometry_package_void); if (state&&(field_modify=(Computed_field_modify_data *)field_modify_void)) { return_code=1; /* get valid parameters for projection field */ source_fields = (struct Computed_field **)NULL; if (ALLOCATE(source_fields, struct Computed_field *, 1)) { source_fields[0] = (struct Computed_field *)NULL; if ((NULL != field_modify->get_field()) && (computed_field_sin_type_string == Computed_field_get_type_string(field_modify->get_field()))) { return_code=Computed_field_get_type_sin(field_modify->get_field(), source_fields); } if (return_code) { /* must access objects for set functions */ if (source_fields[0]) { ACCESS(Computed_field)(source_fields[0]); } option_table = CREATE(Option_table)(); /* fields */ set_source_field_data.computed_field_manager= field_modify->get_field_manager(); set_source_field_data.conditional_function= Computed_field_has_numerical_components; set_source_field_data.conditional_function_user_data=(void *)NULL; set_source_field_array_data.number_of_fields=1; set_source_field_array_data.conditional_data= &set_source_field_data; Option_table_add_entry(option_table,"field",source_fields, &set_source_field_array_data,set_Computed_field_array); return_code=Option_table_multi_parse(option_table,state); /* no errors,not asking for help */ if (return_code) { return_code = field_modify->update_field_and_deaccess( Computed_field_create_sin(field_modify->get_field_module(), source_fields[0])); } if (!return_code) { if ((!state->current_token)|| (strcmp(PARSER_HELP_STRING,state->current_token)&& strcmp(PARSER_RECURSIVE_HELP_STRING,state->current_token))) { /* error */ display_message(ERROR_MESSAGE, "define_Computed_field_type_sin. Failed"); } } if (source_fields[0]) { DEACCESS(Computed_field)(&source_fields[0]); } DESTROY(Option_table)(&option_table); } DEALLOCATE(source_fields); } else {