void user_process_init(void){
//unsigned char err=0;
UINT32 *stkA, *stkB;
process_control_block_t *ret;
stkA=(unsigned long *)os_mem_alloc(PROC_STACK_SIZE);
stkB=(unsigned long *)os_mem_alloc(PROC_STACK_SIZE);
process_create(procIdA, 1, ret, user_process_a, stkA);
process_create(procIdB, 2, ret, user_process_b, stkB);
//current=idle->next;
}
int tls_session_init(tls_handle_t *h, int sockfd,
const tls_init_config_t *cfg)
{
int status;
tls_session_t *s;
tls_d("Session init");
ASSERT(h != NULL);
ASSERT(sockfd >= 0);
ASSERT(cfg != NULL);
s = os_mem_alloc(sizeof(tls_session_t));
if (!s) {
tls_e("No memory for tls session");
return -WM_E_NOMEM;
}
memset(s, 0x00, sizeof(tls_session_t));
if (cfg->flags & TLS_SERVER_MODE)
status = _tls_session_init_server(s, cfg);
else
status = _tls_session_init_client(s, sockfd, cfg);
if (status != WM_SUCCESS) {
os_mem_free(s);
return status;
}
*h = (tls_handle_t) s;
return WM_SUCCESS;
}
void sem_debug_add(const xSemaphoreHandle handle, const char *name,
bool is_semaphore)
{
int temp, i;
if (sem_mutex) {
temp = os_mutex_get(&sem_mutex, OS_WAIT_FOREVER);
if (temp == -WM_FAIL) {
wmprintf("[sem-dbg] Failed to get sem-mutex\r\n");
return;
}
}
for (i = 0; i < MAX_SEM_INFO_BUF; i++) {
if (semdbg[i].x_queue == 0) {
if (name && strlen(name)) {
semdbg[i].q_name =
os_mem_alloc(strlen(name)+1);
if (semdbg[i].q_name == NULL)
break;
strcpy(semdbg[i].q_name, name);
}
semdbg[i].x_queue = handle;
semdbg[i].is_semaphore = is_semaphore;
semcnt++;
break;
}
}
if (sem_mutex)
os_mutex_put(&sem_mutex);
return;
}
int tls_derive_key(tls_session_t *s, size_t len)
{
struct tls_keys keys;
unsigned char *rnd, *out;
if (SSL_get_keys(s->ssl, &keys.master_key, &keys.master_key_len,
&keys.server_random, &keys.server_random_len,
&keys.client_random, &keys.client_random_len) ==
SSL_SUCCESS) {
out = os_mem_alloc(len);
if (out == NULL) {
tls_e("No memory for tls_derive_key");
goto fail;
}
if (keys.master_key == NULL || keys.server_random ==NULL ||
keys.client_random == NULL)
goto fail;
rnd = os_mem_alloc(keys.client_random_len + keys.server_random_len);
if (rnd == NULL) {
tls_e("No memory for rnd:: %d", keys.client_random_len + keys.server_random_len);
goto fail;
}
memcpy(rnd, keys.client_random, keys.client_random_len);
memcpy(rnd + keys.client_random_len, keys.server_random,
keys.server_random_len);
mrvl_tls_prf(keys.master_key, keys.master_key_len,
"client EAP encryption", rnd, keys.client_random_len + keys.server_random_len, out, len);
memcpy(s->key_data, out, TLS_KEY_LEN);
os_mem_free(rnd);
os_mem_free(out);
return WM_SUCCESS;
}
fail:
tls_e("EAP-TLS: Failed to derive key");
return -WM_FAIL;
}
void timer_list_init(void){
timerList = (os_timer_t *)os_mem_alloc((UINT8)sizeof(os_timer_t));
if(!timerList){
UARTprintf("Error:create timer list failed!\n");
}
timerList->next = timerList;
timerList->prev = timerList;
}
static void *cyassl_mem_malloc(size_t size)
{
void *buffer = os_mem_alloc(size);
if (!buffer) {
tls_e("failed to allocate mem for CyaSSL");
return NULL;
}
return buffer;
}
static int rx_buf_init(sspdev_data_t *ssp_data_p)
{
ssp_data_p->rx_ringbuf.rd_idx = 0;
ssp_data_p->rx_ringbuf.wr_idx = 0;
ssp_data_p->rx_ringbuf.buf_p = os_mem_alloc
(GET_RX_BUF_SIZE(ssp_data_p));
if (!ssp_data_p->rx_ringbuf.buf_p)
return -WM_FAIL;
return WM_SUCCESS;
}
void *wifi_malloc_eventbuf(int size)
{
void *ptr = os_mem_alloc(size);
if (ptr) {
w_mem_d("[evtbuf] Alloc: A: %p S: %d",
ptr, size);
} else {
w_mem_e("[evtbuf] Alloc: S: %d FAILED", size);
}
return ptr;
}
static void os_dump_seminfo()
{
int i = 0, temp;
const unsigned int *px_queue = NULL;
unsigned int *list;
char *pc_write_buffer = os_mem_alloc(MAX_WAITER_BUF);
if (pc_write_buffer == NULL)
return;
if (sem_mutex) {
temp = os_mutex_get(&sem_mutex, OS_WAIT_FOREVER);
if (temp == -WM_FAIL) {
wmprintf("[sem-dbg] Failed to get sem-mutex\r\n");
os_mem_free(pc_write_buffer);
return;
}
}
if (semcnt > 0) {
wmprintf("%-32s%-8s%-50s%s", "Name", "Count", "Waiters",
"Type\r\n");
}
for (i = 0; i < MAX_SEM_INFO_BUF; i++) {
if (semdbg[i].x_queue == 0)
continue;
if (semdbg[i].q_name && isascii(semdbg[i].q_name[0])) {
wmprintf("%-32s", semdbg[i].q_name);
} else {
wmprintf("%-32s", "-");
}
px_queue = semdbg[i].x_queue;
wmprintf("%-8d",
os_semaphore_getcount(&semdbg[i].x_queue));
vGetWaiterListFromHandle(px_queue, &list);
vGetTaskNamesInList((signed char *) pc_write_buffer,
MAX_WAITER_BUF - 1,
(const unsigned int *)list);
pc_write_buffer[MAX_WAITER_BUF - 1] = '\0';
wmprintf("%-50s ", pc_write_buffer);
(semdbg[i].is_semaphore == 0) ?
wmprintf("q") :
wmprintf("s");
wmprintf("\r\n");
}
if (sem_mutex)
os_mutex_put(&sem_mutex);
os_mem_free(pc_write_buffer);
}
void *wps_mem_malloc(size_t size)
{
void *buffer_ptr = 0;
if (size == 0)
return NULL;
buffer_ptr = os_mem_alloc(size);
if (!buffer_ptr) {
WPS_LOG("Failed to allocate mem: Size: %d", size);
return NULL;
}
return buffer_ptr;
}
/*---------------------------------------------------------------------*/
__task void task3(void){
void *pointer;
pointer = os_mem_alloc(box_mem);
if (pointer == NULL)
printf("Not enough memory\n");
else
printf("malloc'd(): %d \n", pointer);
os_dly_wait(50);
if(os_mem_free(box_mem, pointer) == OS_R_OK){
printf("dealloc'd(): OS_R_OK \n");
}else{
printf("dealloc'd(): OS_R_NOK \n");
}
os_dly_wait(50);
os_tsk_delete_self();
}
mlan_status wrapper_moal_malloc(IN t_void *pmoal_handle, IN t_u32 size,
IN t_u32 flag, OUT t_u8 **ppbuf)
{
*ppbuf = os_mem_alloc(size);
#ifdef DEBUG_11N_ALLOC
#endif /* DEBUG_11N_ALLOC */
if (*ppbuf) {
w_mem_d("[mlan]: Alloc: A: %p S: %d", *ppbuf, size);
return MLAN_STATUS_SUCCESS;
} else {
w_mem_e("[mlan] Alloc: S: %d FAILED", size);
/*
* fixme: check if MLAN_STATUS_SUCCESS is to be returned in
* spite of the status failure.
*/
return MLAN_STATUS_FAILURE;
}
}
/*
* We only save the params to be used later when BSS is (re-)started.
*/
int wifi_uap_set_domain_params(wifi_domain_param_t *dp)
{
if (!dp)
return -WM_E_INVAL;
if (wm_wifi.dp)
wuap_w("Overwriting previous configuration");
/*
* We have domain information from caller. Allocate tlv, fill it
* up and store as pointer in global wifi structure. It will be
* used later by the uap start code.
*/
int sz = sizeof(MrvlIEtypes_DomainParamSet_t) +
(sizeof(IEEEtypes_SubbandSet_t) * dp->no_of_sub_band);
MrvlIEtypes_DomainParamSet_t *n_dp = os_mem_alloc(sz);
if (!n_dp)
return -WM_E_NOMEM;
n_dp->header.type = TLV_TYPE_DOMAIN;
n_dp->header.len = sizeof(MrvlIEtypes_DomainParamSet_t) -
4 + (dp->no_of_sub_band *
sizeof(IEEEtypes_SubbandSet_t));
memcpy(n_dp->country_code, dp->country_code, COUNTRY_CODE_LEN);
wifi_sub_band_set_t *is = dp->sub_band;
IEEEtypes_SubbandSet_t *s = n_dp->sub_band;
int i;
for (i = 0; i < dp->no_of_sub_band; i++) {
s[i].first_chan = is[i].first_chan;
s[i].no_of_chan = is[i].no_of_chan;
s[i].max_tx_pwr = is[i].max_tx_pwr;
}
/* Store for use later */
wuap_d("Saved domain info for later use");
wm_wifi.dp = n_dp;
return 0;
}
/*
* Write all data in the adapter's battery-backed cache to
* storage.
*/
int pqisrc_flush_cache( pqisrc_softstate_t *softs,
enum pqisrc_flush_cache_event_type event_type)
{
int rval = PQI_STATUS_SUCCESS;
pqisrc_raid_req_t request;
pqisrc_bmic_flush_cache_t *flush_buff = NULL;
DBG_FUNC("IN\n");
if (pqisrc_ctrl_offline(softs))
return PQI_STATUS_FAILURE;
flush_buff = os_mem_alloc(softs, sizeof(pqisrc_bmic_flush_cache_t));
if (!flush_buff) {
DBG_ERR("Failed to allocate memory for flush cache params\n");
rval = PQI_STATUS_FAILURE;
return rval;
}
flush_buff->halt_event = event_type;
memset(&request, 0, sizeof(request));
rval = pqisrc_build_send_raid_request(softs, &request, flush_buff,
sizeof(*flush_buff), SA_CACHE_FLUSH, 0,
(uint8_t *)RAID_CTLR_LUNID, NULL);
if (rval) {
DBG_ERR("error in build send raid req ret=%d\n", rval);
}
if (flush_buff)
os_mem_free(softs, (void *)flush_buff,
sizeof(pqisrc_bmic_flush_cache_t));
DBG_FUNC("OUT\n");
return rval;
}
/* This task configures Evrythng client and connects to the Evrythng cloud */
static void evrythng_task()
{
psm_handle_t handle;
int rc;
if ((rc = psm_open(&handle, "evrythng")) != 0)
{
wmprintf("psm_open failed with: %d (Is the module name registered?)\n\r", rc);
goto exit;
}
char api_key[128];
if (psm_get(&handle, "api_key", api_key, 128) == 0)
{
wmprintf("api_key: %s\n\r", api_key);
}
else
{
wmprintf("api_key doesn't exist\n\r");
goto exit;
}
char thng_id_buf[64];
if (psm_get(&handle, "thng_id", thng_id_buf, 64) == 0)
{
if (thng_id != NULL)
{
os_mem_free(thng_id);
}
thng_id = (char*)os_mem_alloc((strlen(thng_id_buf)+1)*sizeof(char));
strcpy(thng_id, thng_id_buf);
wmprintf("thng_id: %s\n\r", thng_id);
}
else
{
wmprintf("thng_id doesn't exist\n\r");
goto exit;
}
char url_buf[64];
if (psm_get(&handle, "url", url_buf, 64) == 0)
{
wmprintf("Evrythng URL: %s\n\r", url_buf);
}
else
{
wmprintf("Evrythng URL doesn't exist\n\r");
goto exit;
}
psm_close(&handle);
EvrythngInitHandle(&evt_handle);
EvrythngSetUrl(evt_handle, url_buf);
EvrythngSetKey(evt_handle, api_key);
EvrythngSetLogCallback(evt_handle, log_callback);
EvrythngSetConnectionCallbacks(evt_handle, on_connection_lost, on_connection_restored);
while (EvrythngConnect(evt_handle) != EVRYTHNG_SUCCESS)
{
wmprintf("Retry\n\r");
os_thread_sleep(os_msec_to_ticks(5000));
}
wmprintf("Connected\n\r");
os_semaphore_create_counting(&button1_sem, "button1_sem", 1000, 0);
os_semaphore_create_counting(&button2_sem, "button1_sem", 1000, 0);
EvrythngSubThngAction(evt_handle, thng_id, "_led1", 0, action_led_callback);
EvrythngSubThngAction(evt_handle, thng_id, "_led2", 0, action_led_callback);
os_thread_create(&button1_thread, "button1_task", button_task, (void*)button_1, &button_stack, OS_PRIO_3);
os_thread_create(&button2_thread, "button2_task", button_task, (void*)button_2, &button_stack, OS_PRIO_3);
exit:
os_thread_self_complete(0);
}
/*
* Get the PQI configuration table parameters.
* Currently using for heart-beat counter scratch-pad register.
*/
int pqisrc_process_config_table(pqisrc_softstate_t *softs)
{
int ret = PQI_STATUS_FAILURE;
uint32_t config_table_size;
uint32_t section_off;
uint8_t *config_table_abs_addr;
struct pqi_conf_table *conf_table;
struct pqi_conf_table_section_header *section_hdr;
config_table_size = softs->pqi_cap.conf_tab_sz;
if (config_table_size < sizeof(*conf_table) ||
config_table_size > PQI_CONF_TABLE_MAX_LEN) {
DBG_ERR("Invalid PQI conf table length of %u\n",
config_table_size);
return ret;
}
conf_table = os_mem_alloc(softs, config_table_size);
if (!conf_table) {
DBG_ERR("Failed to allocate memory for PQI conf table\n");
return ret;
}
config_table_abs_addr = (uint8_t *)(softs->pci_mem_base_vaddr +
softs->pqi_cap.conf_tab_off);
PCI_MEM_GET_BUF(softs, config_table_abs_addr,
softs->pqi_cap.conf_tab_off,
(uint8_t*)conf_table, config_table_size);
if (memcmp(conf_table->sign, PQI_CONF_TABLE_SIGNATURE,
sizeof(conf_table->sign)) != 0) {
DBG_ERR("Invalid PQI config signature\n");
goto out;
}
section_off = LE_32(conf_table->first_section_off);
while (section_off) {
if (section_off+ sizeof(*section_hdr) >= config_table_size) {
DBG_ERR("PQI config table section offset (%u) beyond \
end of config table (config table length: %u)\n",
section_off, config_table_size);
break;
}
section_hdr = (struct pqi_conf_table_section_header *)((uint8_t *)conf_table + section_off);
switch (LE_16(section_hdr->section_id)) {
case PQI_CONF_TABLE_SECTION_GENERAL_INFO:
case PQI_CONF_TABLE_SECTION_FIRMWARE_FEATURES:
case PQI_CONF_TABLE_SECTION_FIRMWARE_ERRATA:
case PQI_CONF_TABLE_SECTION_DEBUG:
break;
case PQI_CONF_TABLE_SECTION_HEARTBEAT:
softs->heartbeat_counter_off = softs->pqi_cap.conf_tab_off +
section_off +
offsetof(struct pqi_conf_table_heartbeat,
heartbeat_counter);
softs->heartbeat_counter_abs_addr = (uint64_t *)(softs->pci_mem_base_vaddr +
softs->heartbeat_counter_off);
ret = PQI_STATUS_SUCCESS;
break;
default:
DBG_ERR("unrecognized PQI config table section ID: 0x%x\n",
LE_16(section_hdr->section_id));
break;
}
section_off = LE_16(section_hdr->next_section_off);
}
/*
* Request the adapter to get PQI capabilities supported.
*/
static int pqisrc_report_pqi_capability(pqisrc_softstate_t *softs)
{
int ret = PQI_STATUS_SUCCESS;
DBG_FUNC("IN\n");
gen_adm_req_iu_t admin_req;
gen_adm_resp_iu_t admin_resp;
dma_mem_t pqi_cap_dma_buf;
pqi_dev_cap_t *capability = NULL;
pqi_iu_layer_desc_t *iu_layer_desc = NULL;
/* Allocate Non DMA memory */
capability = os_mem_alloc(softs, sizeof(*capability));
if (!capability) {
DBG_ERR("Failed to allocate memory for capability\n");
ret = PQI_STATUS_FAILURE;
goto err_out;
}
memset(&admin_req, 0, sizeof(admin_req));
memset(&admin_resp, 0, sizeof(admin_resp));
memset(&pqi_cap_dma_buf, 0, sizeof(struct dma_mem));
pqi_cap_dma_buf.tag = "pqi_cap_buf";
pqi_cap_dma_buf.size = REPORT_PQI_DEV_CAP_DATA_BUF_SIZE;
pqi_cap_dma_buf.align = PQISRC_DEFAULT_DMA_ALIGN;
ret = os_dma_mem_alloc(softs, &pqi_cap_dma_buf);
if (ret) {
DBG_ERR("Failed to allocate capability DMA buffer : %d\n", ret);
goto err_dma_alloc;
}
admin_req.fn_code = PQI_FUNCTION_REPORT_DEV_CAP;
admin_req.req_type.general_func.buf_size = pqi_cap_dma_buf.size;
admin_req.req_type.general_func.sg_desc.length = pqi_cap_dma_buf.size;
admin_req.req_type.general_func.sg_desc.addr = pqi_cap_dma_buf.dma_addr;
admin_req.req_type.general_func.sg_desc.type = SGL_DESCRIPTOR_CODE_DATA_BLOCK;
ret = pqisrc_submit_admin_req(softs, &admin_req, &admin_resp);
if( PQI_STATUS_SUCCESS == ret) {
memcpy(capability,
pqi_cap_dma_buf.virt_addr,
pqi_cap_dma_buf.size);
} else {
DBG_ERR("Failed to send admin req report pqi device capability\n");
goto err_admin_req;
}
softs->pqi_dev_cap.max_iqs = capability->max_iqs;
softs->pqi_dev_cap.max_iq_elements = capability->max_iq_elements;
softs->pqi_dev_cap.max_iq_elem_len = capability->max_iq_elem_len;
softs->pqi_dev_cap.min_iq_elem_len = capability->min_iq_elem_len;
softs->pqi_dev_cap.max_oqs = capability->max_oqs;
softs->pqi_dev_cap.max_oq_elements = capability->max_oq_elements;
softs->pqi_dev_cap.max_oq_elem_len = capability->max_oq_elem_len;
softs->pqi_dev_cap.intr_coales_time_granularity = capability->intr_coales_time_granularity;
iu_layer_desc = &capability->iu_layer_desc[PQI_PROTOCOL_SOP];
softs->max_ib_iu_length_per_fw = iu_layer_desc->max_ib_iu_len;
softs->ib_spanning_supported = iu_layer_desc->ib_spanning_supported;
softs->ob_spanning_supported = iu_layer_desc->ob_spanning_supported;
DBG_INIT("softs->pqi_dev_cap.max_iqs: %d\n", softs->pqi_dev_cap.max_iqs);
DBG_INIT("softs->pqi_dev_cap.max_iq_elements: %d\n", softs->pqi_dev_cap.max_iq_elements);
DBG_INIT("softs->pqi_dev_cap.max_iq_elem_len: %d\n", softs->pqi_dev_cap.max_iq_elem_len);
DBG_INIT("softs->pqi_dev_cap.min_iq_elem_len: %d\n", softs->pqi_dev_cap.min_iq_elem_len);
DBG_INIT("softs->pqi_dev_cap.max_oqs: %d\n", softs->pqi_dev_cap.max_oqs);
DBG_INIT("softs->pqi_dev_cap.max_oq_elements: %d\n", softs->pqi_dev_cap.max_oq_elements);
DBG_INIT("softs->pqi_dev_cap.max_oq_elem_len: %d\n", softs->pqi_dev_cap.max_oq_elem_len);
DBG_INIT("softs->pqi_dev_cap.intr_coales_time_granularity: %d\n", softs->pqi_dev_cap.intr_coales_time_granularity);
DBG_INIT("softs->max_ib_iu_length_per_fw: %d\n", softs->max_ib_iu_length_per_fw);
DBG_INIT("softs->ib_spanning_supported: %d\n", softs->ib_spanning_supported);
DBG_INIT("softs->ob_spanning_supported: %d\n", softs->ob_spanning_supported);
os_mem_free(softs, (void *)capability,
REPORT_PQI_DEV_CAP_DATA_BUF_SIZE);
os_dma_mem_free(softs, &pqi_cap_dma_buf);
DBG_FUNC("OUT\n");
return ret;
err_admin_req:
os_dma_mem_free(softs, &pqi_cap_dma_buf);
err_dma_alloc:
if (capability)
os_mem_free(softs, (void *)capability,
REPORT_PQI_DEV_CAP_DATA_BUF_SIZE);
err_out:
DBG_FUNC("failed OUT\n");
return PQI_STATUS_FAILURE;
}
/*
* Allocate memory for rcb and SG descriptors.
*/
static int pqisrc_allocate_rcb(pqisrc_softstate_t *softs)
{
int ret = PQI_STATUS_SUCCESS;
int i = 0;
uint32_t num_req = 0;
uint32_t sg_buf_size = 0;
uint64_t alloc_size = 0;
rcb_t *rcb = NULL;
rcb_t *prcb = NULL;
DBG_FUNC("IN\n");
/* Set maximum outstanding requests */
/* The valid tag values are from 1, 2, ..., softs->max_outstanding_io
* The rcb will be accessed by using the tag as index
* * As 0 tag index is not used, we need to allocate one extra.
*/
softs->max_outstanding_io = softs->pqi_cap.max_outstanding_io;
num_req = softs->max_outstanding_io + 1;
DBG_INIT("Max Outstanding IO reset to %d\n", num_req);
alloc_size = num_req * sizeof(rcb_t);
/* Allocate Non DMA memory */
rcb = os_mem_alloc(softs, alloc_size);
if (!rcb) {
DBG_ERR("Failed to allocate memory for rcb\n");
ret = PQI_STATUS_FAILURE;
goto err_out;
}
softs->rcb = rcb;
/* Allocate sg dma memory for sg chain */
sg_buf_size = softs->pqi_cap.max_sg_elem *
sizeof(sgt_t);
prcb = &softs->rcb[1];
/* Initialize rcb */
for(i=1; i < num_req; i++) {
char tag[15];
sprintf(tag, "sg_dma_buf%d", i);
softs->sg_dma_desc[i].tag = tag;
softs->sg_dma_desc[i].size = sg_buf_size;
softs->sg_dma_desc[i].align = PQISRC_DEFAULT_DMA_ALIGN;
ret = os_dma_mem_alloc(softs, &softs->sg_dma_desc[i]);
if (ret) {
DBG_ERR("Failed to Allocate sg desc %d\n", ret);
ret = PQI_STATUS_FAILURE;
goto error;
}
prcb->sg_chain_virt = (sgt_t *)(softs->sg_dma_desc[i].virt_addr);
prcb->sg_chain_dma = (dma_addr_t)(softs->sg_dma_desc[i].dma_addr);
prcb ++;
}
DBG_FUNC("OUT\n");
return ret;
error:
pqisrc_free_rcb(softs, i);
err_out:
DBG_FUNC("failed OUT\n");
return ret;
}
int httpd_handle_file(httpd_request_t *req_p, struct fs *fs)
{
const char *anchor = "/";
char tmp[HTTPD_MAX_URI_LENGTH+1];
const char *encoding = NULL;
char *msg_in, *ptr, *type = NULL;
int err, msg_in_len = HTTPD_MAX_MESSAGE - 1, conn = req_p->sock;
int ret;
msg_in = os_mem_alloc(HTTPD_MAX_MESSAGE + 2);
if (!msg_in) {
httpd_e("Failed to allocate memory for file handling");
/* Check what needs to be returned */
return -WM_FAIL;
}
memset(msg_in, 0, HTTPD_MAX_MESSAGE + 2);
SYS_FILE_DECL;
if (!fs) {
/* The filesystem wasn't mounted properly */
httpd_send_hdr_from_str(conn, http_header_404,
CONTENT_TYPE_PLAIN, encoding,
NO_CACHE_HEADERS, UNUSED_PARAM);
httpd_send_default_headers(conn,
req_p->wsgi->hdr_fields);
httpd_send_crlf(conn);
httpd_send(conn, FILE_NOT_FOUND, sizeof(FILE_NOT_FOUND));
ret = WM_SUCCESS;
goto out;
}
struct ftfs_super *f_super = fs_to_ftfs_sb(fs);
/* Ensure that the anchor is the first part of the filename */
ptr = strstr(req_p->filename, anchor);
if (ptr == NULL ||
ptr != req_p->filename) {
httpd_d("No anchor in filename\r\n");
ret = httpd_send_error(conn, HTTP_500);
goto out;
}
/* Zap the anchor from the filename */
ptr = req_p->filename + strlen(anchor);
err = 0;
/* anchors are only across directory boundaries */
if (*ptr != '/')
req_p->filename[err++] = '/';
while (*ptr && (*ptr != '?')) {
req_p->filename[err] = *ptr;
ptr++;
err++;
}
req_p->filename[err] = '\0';
/* "/" implies a request for index.html */
if (strncmp(req_p->filename, "/", 2) == 0) {
strncpy(req_p->filename, http_index_html,
sizeof(http_index_html));
}
/* Find if .gz version exists for file, if it is then serve that */
type = strrchr(req_p->filename, ISO_period);
if (type) {
strncpy(tmp, req_p->filename, sizeof(tmp));
strncat(tmp, ".gz", 3);
httpd_d("Look for gz file if it exists: %s\r\n", tmp);
if (htsys_file_open(fs, tmp, sys_filep) == WM_SUCCESS) {
/* Gzipped version exists, serve that */
httpd_d("Serve gzipped file\r\n");
strncpy(req_p->filename, tmp, HTTPD_MAX_URI_LENGTH + 1);
encoding = ".gz";
htsys_close(fs, sys_filep);
}
}
ret = httpd_parse_hdr_tags(req_p, conn, msg_in, msg_in_len);
if (ret < 0) {
httpd_d("Parsing headers failed \r\n");
ret = httpd_send_error(conn, HTTP_500);
goto out;
}
/* It is not a WSGI, check to see if the file exists */
if (htsys_file_open(fs, req_p->filename, sys_filep) == -WM_FAIL) {
httpd_w("file not found: %s\r\n", req_p->filename);
ret = httpd_send_hdr_from_str(conn, http_header_404,
type, encoding, NO_CACHE_HEADERS,
UNUSED_PARAM);
httpd_send_default_headers(conn,
req_p->wsgi->hdr_fields);
httpd_send_crlf(conn);
if (ret != WM_SUCCESS)
goto out;
ret = htsys_file_open(fs, http_404_html, sys_filep);
if (ret == WM_SUCCESS) {
ret = httpd_send_file(fs, conn, sys_filep);
goto out;
} else
httpd_w("No local 404 file. Sending empty 404"
" response.\r\n");
} else {
/* Ok, the file exists, is it a script html or just html */
g_wm_stats.wm_hd_file++;
if (req_p->if_none_match &&
(f_super->fs_crc32 == req_p->etag_val)) {
/* We do not need the file handle now */
htsys_close(fs, sys_filep);
/* Send Not Modified header */
/* Send header prologue */
ret = httpd_send(conn, http_header_304_prologue,
strlen(http_header_304_prologue));
if (ret != WM_SUCCESS)
goto out;
httpd_send_header(conn, "Server", "Marvell-WM");
httpd_send_header(conn, "Connection", "Close");
/* Send ETag */
int len;
const char *h = httpd_get_etag_hdr(req_p->etag_val,
&len);
ret = httpd_send(conn, h, len);
if (ret != WM_SUCCESS)
goto out;
/* Close the header */
ret = httpd_send_crlf(conn);
goto out;
} else {
ret = httpd_send_hdr_from_str(conn, http_header_200,
type, encoding,
SEND_CACHE_HEADERS,
f_super->fs_crc32);
httpd_send_default_headers(conn,
req_p->wsgi->hdr_fields);
httpd_send_crlf(conn);
if (ret != WM_SUCCESS)
goto out;
ptr = strchr(req_p->filename, ISO_period);
if (ptr != NULL && strncmp(ptr, http_shtml,
sizeof(http_shtml)
- 1) == 0) {
httpd_d("Handling script: %s", req_p->filename);
ret = handle_script(fs, req_p, conn,
sys_filep, msg_in);
htsys_close(fs, sys_filep);
if (ret != WM_SUCCESS) {
httpd_d("Script failed\r\n");
goto out;
}
} else {
ret = httpd_send_file(fs, conn, sys_filep);
if (ret != WM_SUCCESS)
goto out;
}
}
}
ret = httpd_send_last_chunk(conn);
out:
os_mem_free(msg_in);
return ret;
}
/**
* mu3d_hal_alloc_qmu_mem - allocate gpd and bd memory for all ep
*
*/
void mu3d_hal_alloc_qmu_mem(void)
{
DEV_UINT32 i, size;
TGPD *ptr, *io_ptr;
TBD *bptr, *io_bptr;
for (i = 1; i <= MAX_QMU_EP; i++) {
/* Allocate Tx GPD */
size = sizeof(TGPD);
size *= MAX_GPD_NUM;
ptr = (TGPD *) os_mem_alloc(size);
os_memset(ptr, 0, size);
io_ptr = (TGPD *) dma_map_single(NULL, ptr, size, DMA_TO_DEVICE);
/* io_ptr = (TGPD*)os_ioremap(os_virt_to_phys(ptr),size); */
/* io_ptr = (TGPD*)(os_virt_to_phys(ptr)); */
/* init_gpd_list(USB_RX,i,ptr,io_ptr,MAX_GPD_NUM); */
init_gpd_list(USB_RX, i, ptr, io_ptr, MAX_GPD_NUM);
Rx_gpd_end[i] = ptr;
os_printk(K_DEBUG, "ALLOC RX GPD End [%d] Virtual Mem=%p, DMA addr=%p\n", i,
Rx_gpd_end[i], io_ptr);
/* os_memset(Rx_gpd_end[i], 0 , sizeof(TGPD)); */
TGPD_CLR_FLAGS_HWO(Rx_gpd_end[i]);
Rx_gpd_head[i] = Rx_gpd_last[i] = Rx_gpd_end[i];
os_printk(K_DEBUG, "RQSAR[%d]=%p\n", i,
(void *)mu3d_hal_gpd_virt_to_phys(Rx_gpd_end[i], USB_RX, i));
/* Allocate Rx GPD */
size = sizeof(TGPD);
size += AT_GPD_EXT_LEN;
size *= MAX_GPD_NUM;
ptr = (TGPD *) os_mem_alloc(size);
os_memset(ptr, 0, size);
io_ptr = (TGPD *) dma_map_single(NULL, ptr, size, DMA_TO_DEVICE);
/* io_ptr = (TGPD*)os_ioremap(os_virt_to_phys(ptr),size); */
init_gpd_list(USB_TX, i, ptr, io_ptr, MAX_GPD_NUM);
Tx_gpd_end[i] = ptr;
os_printk(K_DEBUG, "ALLOC TX GPD End [%d] Virtual Mem=%p, DMA addr=%p\n", i,
Tx_gpd_end[i], io_ptr);
/* os_memset(Tx_gpd_end[i], 0 , sizeof(TGPD)+AT_GPD_EXT_LEN); */
TGPD_CLR_FLAGS_HWO(Tx_gpd_end[i]);
Tx_gpd_head[i] = Tx_gpd_last[i] = Tx_gpd_end[i];
os_printk(K_DEBUG, "TQSAR[%d]=%p\n", i,
(void *)mu3d_hal_gpd_virt_to_phys(Tx_gpd_end[i], USB_TX, i));
/* Allocate Tx BD */
size = (sizeof(TBD));
size *= MAX_BD_NUM;
bptr = (TBD *) os_mem_alloc(size);
os_memset(bptr, 0, size);
io_bptr = (TBD *) dma_map_single(NULL, bptr, size, DMA_TO_DEVICE);
/* io_bptr = (TBD*)os_ioremap(os_virt_to_phys(bptr),size); */
init_bd_list(USB_RX, i, bptr, io_bptr, MAX_BD_NUM);
/* Allocate Rx BD */
size = (sizeof(TBD));
size += AT_BD_EXT_LEN;
size *= MAX_BD_NUM;
bptr = (TBD *) os_mem_alloc(size);
os_memset(bptr, 0, size);
io_bptr = (TBD *) dma_map_single(NULL, bptr, size, DMA_TO_DEVICE);
/* io_bptr = (TBD*)os_ioremap(os_virt_to_phys(bptr),size); */
init_bd_list(USB_TX, i, bptr, io_bptr, MAX_BD_NUM);
}
}
