int can_mbox_init(can_iface_ctx_t *iface_ctx) {
int i;
mbox_t *m, *mbox;
mbox = iface_ctx->mbox;
for (i = 0; i < MBOX_NUM; i++) {
m = &mbox[i];
m->state = MBOX_FREE;
m->csp_can_socket = &iface_ctx->csp_can_socket;
m->mbox_pool_sem = &iface_ctx->mbox_pool_sem;
/* Init signal semaphore */
if (csp_bin_sem_create(&(m->signal_sem)) != CSP_SEMAPHORE_OK) {
csp_log_error("sem create");
return -1;
} else {
/* Take signal semaphore so the thread waits for tx data */
csp_bin_sem_wait(&(m->signal_sem), CSP_MAX_DELAY);
}
/* Create mailbox */
if(csp_thread_create(mbox_tx_thread, (signed char *)"mbox_tx", 1024, (void *)m, 3, &m->thread) != CSP_ERR_NONE) { //TODO: Adjust priority
csp_log_error("thread creation");
return -1;
}
}
/* Init mailbox pool semaphore */
csp_bin_sem_create(&iface_ctx->mbox_pool_sem);
return 0;
}
/** pbuf_init
* Initialize packet buffer.
* @return 0 on success, -1 on error.
*/
static int pbuf_init(void) {
/* Initialize packet buffers */
int i;
pbuf_element_t *buf;
for (i = 0; i < PBUF_ELEMENTS; i++) {
buf = &pbuf[i];
buf->rx_count = 0;
buf->tx_count = 0;
buf->cfpid = 0;
buf->packet = NULL;
buf->state = BUF_FREE;
buf->last_used = 0;
buf->remain = 0;
/* Create tx semaphore if blocking mode is enabled */
if (csp_bin_sem_create(&buf->tx_sem) != CSP_SEMAPHORE_OK) {
csp_log_error("Failed to allocate TX semaphore\r\n");
return CSP_ERR_NOMEM;
}
}
/* Initialize global lock */
if (CSP_INIT_CRITICAL(pbuf_sem) != CSP_ERR_NONE) {
csp_log_error("No more memory for packet buffer semaphore\r\n");
return CSP_ERR_NOMEM;
}
return CSP_ERR_NONE;
}
int csp_conn_init(void) {
/* Initialize source port */
srand(csp_get_ms());
sport = (rand() % (CSP_ID_PORT_MAX - CSP_MAX_BIND_PORT)) + (CSP_MAX_BIND_PORT + 1);
if (csp_bin_sem_create(&sport_lock) != CSP_SEMAPHORE_OK) {
csp_log_error("No more memory for sport semaphore\r\n");
return CSP_ERR_NOMEM;
}
int i, prio;
for (i = 0; i < CSP_CONN_MAX; i++) {
for (prio = 0; prio < CSP_RX_QUEUES; prio++)
arr_conn[i].rx_queue[prio] = csp_queue_create(CSP_RX_QUEUE_LENGTH, sizeof(csp_packet_t *));
#ifdef CSP_USE_QOS
arr_conn[i].rx_event = csp_queue_create(CSP_CONN_QUEUE_LENGTH, sizeof(int));
#endif
arr_conn[i].state = CONN_CLOSED;
if (csp_mutex_create(&arr_conn[i].lock) != CSP_MUTEX_OK) {
csp_log_error("Failed to create connection lock\r\n");
return CSP_ERR_NOMEM;
}
#ifdef CSP_USE_RDP
if (csp_rdp_allocate(&arr_conn[i]) != CSP_ERR_NONE) {
csp_log_error("Failed to create queues for RDP in csp_conn_init\r\n");
return CSP_ERR_NOMEM;
}
#endif
}
if (csp_bin_sem_create(&conn_lock) != CSP_SEMAPHORE_OK) {
csp_log_error("No more memory for conn semaphore\r\n");
return CSP_ERR_NOMEM;
}
return CSP_ERR_NONE;
}
/* Identification number */
static int id_init(void) {
/* Init ID field to random number */
srand((int)csp_get_ms());
cfp_id = rand() & ((1 << CFP_ID_SIZE) - 1);
if (csp_bin_sem_create(&id_sem) == CSP_SEMAPHORE_OK) {
return CSP_ERR_NONE;
} else {
csp_log_error("Could not initialize CFP id semaphore\r\n");
return CSP_ERR_NOMEM;
}
}
int csp_buffer_init(int buf_count, int buf_size) {
#ifndef CSP_BUFFER_STATIC
/* Remember size */
count = buf_count;
size = buf_size;
/* Allocate main memory */
csp_buffer_p = csp_malloc(count * size);
if (csp_buffer_p == NULL)
return CSP_ERR_NOMEM;
/* Allocate housekeeping memory */
csp_buffer_list = (csp_buffer_state_t *) csp_malloc(count * sizeof(csp_buffer_state_t));
if (csp_buffer_list == NULL) {
csp_free(csp_buffer_p);
return CSP_ERR_NOMEM;
}
#endif
#if defined(CSP_POSIX) || defined(CSP_WINDOWS)
/* Initialize critical lock */
if (csp_bin_sem_create(&csp_critical_lock) != CSP_SEMAPHORE_OK) {
csp_debug(CSP_ERROR, "No more memory for buffer semaphore\r\n");
if (csp_buffer_list)
csp_free(csp_buffer_list);
if (csp_buffer_p)
csp_free(csp_buffer_p);
return CSP_ERR_NOMEM;
}
#endif
/* Clear housekeeping memory = all free mem */
memset(csp_buffer_list, 0, count * sizeof(csp_buffer_state_t));
return CSP_ERR_NONE;
}
