/*---------------------------------------------------------------------------*/
int putchar (int c)
{
int bl = '\r' ;
if (tx_init == YES)
{
/* Get a spot on the tx buffer */
if (sem_get (tx_buf_sem, WAIT_FOREVER) != GOOD)
return EOF ;
/* First take the buffer semaphore */
if (sem_get (putchar_sem, WAIT_FOREVER) != GOOD)
return EOF ;
/* Copy character into buffer */
tx_buf [tx_p++ % BUF_SIZE] = (u8) c ;
/* Give back the buffer semaphore */
sem_give (putchar_sem) ;
/* Now wake up the stdout task */
sem_give (tx_task_sem) ;
} else {
/* The stdout is still not inited. Used the Debug out */
dbg_putchar (c) ;
/* Follow a new line char with a begin line char */
if (c == '\n')
dbg_putchar (bl) ;
}
return c ;
} /* End of function putchar() */
void sig_init(void)
{
p1 = sem_get(SEMKEY1);
p2 = sem_get(SEMKEY2);
p3 = sem_get(SEMKEY3);
#ifdef NONBLOCK
V(p3);
#endif
int shm_id;
shm_id = shmget(key,sbuf_size*sizeof(char),NULL);
shm = shmat(shm_id,NULL,NULL);
if(shm == -1)
{
printf("Create share memory error");
}
#ifdef DEBUG
printf("initl file\n");
printf("share memory address is %p\n", shm);
#endif
#if 0
int i;
for(i=1;i<1024;i++)
{
sc_init(6);
insert_sc_arg(0, i, 0,0);
dispatch_sc();
}
#endif
gettimeofday(&start, NULL);
seminit=1;
}
int main(void)
{
int freie_ressourcen;
/* Anlegen des Semaphors */
sem_anfordid = sem_create(SEM_READKEY);
/* Setzen des Sempahors auf 1 */
sem_set(sem_anfordid, 1);
/* Beginn Serverschleife */
while(1) {
/* Abfragen wieviel Ressourcen frei sind, falls 0 Schleife verlassen */
freie_ressourcen = sem_get(sem_anfordid);
if (freie_ressourcen == 0)
break;
/* eine Sekunde warten */
sleep(1);
/* Ende Serverschleife */
}
/* Semaphor entfernen */
sem_rm(sem_anfordid);
printf("Server terminiert.\n");
exit(0);
}
/**
* Remove and return the first task from the queue (FIFO).
* This blocks until there is something in the queue.
* @returns the first task from the queue or an empty task on error (eg. shutdown in progress)
*/
task_t take_task() {
task_t t = {0, 0};
lock_get(tasks->lock);
while (tasks->start == tasks->end) {
lock_release(tasks->lock);
if (*shutdownx) {
sem_release(tasks->empty);
return t;
}
sem_get(tasks->empty);
if (*shutdownx) {
sem_release(tasks->empty);
return t;
}
lock_get(tasks->lock);
}
t = tasks->queue[tasks->start];
tasks->queue[tasks->start].msg = 0;
tasks->start = (tasks->start + 1) % tasks->max;
if (sem_release(tasks->full) < 0)
LM_WARN("Error releasing tasks->full semaphore > %s!\n", strerror(errno));
lock_release(tasks->lock);
//int num_tasks = tasks->end - tasks->start;
//LM_ERR("Taken task from task queue. Queue length [%i]", num_tasks);
return t;
}
reginfo_event_t* pop_reginfo_event()
{
reginfo_event_t *ev;
// Make sure, it's initialized:
init_reginfo_event_list();
lock_get(reginfo_event_list->lock);
while (reginfo_event_list->head == 0) {
lock_release(reginfo_event_list->lock);
sem_get(reginfo_event_list->empty);
lock_get(reginfo_event_list->lock);
}
ev = reginfo_event_list->head;
reginfo_event_list->head = ev->next;
if (ev == reginfo_event_list->tail) { //list now empty
reginfo_event_list->tail = 0;
}
ev->next = 0; //make sure whoever gets this cant access our list
reginfo_event_list->size--;
lock_release(reginfo_event_list->lock);
return ev;
}
int SerialGetData( void* pData,unsigned int len,int timeout )
{
data_length = len;
if(rxIndex <data_length)
{
return -1;
if(sem_get(wait_data,10*1000) == 0)
{
memcpy(pData,rxQueue,len);
memcpy(rxQueue,&rxQueue[len],rxIndex-len);
// memset(&rxQueue[rxIndex-data_length],0,rxIndex-len);
rxQueueFree+=len;
rxIndex-=len;
return len;
}
}
else
{
memcpy(pData,rxQueue,len);
memcpy(rxQueue,&rxQueue[len],rxIndex-len);
// memset(&rxQueue[rxIndex-data_length],0,rxIndex-len);
rxQueueFree+=len;
rxIndex-=len;
return len;
}
return -1;
}
/**
* Remove and return the first task from the queue (FIFO).
* This blocks until there is something in the queue.
* @returns the first task from the queue or an empty task on error (eg. shutdown in progress)
*/
task_t take_task()
{
task_t t={0,0};
// LOG(L_CRIT,"-1-\n");
lock_get(tasks->lock);
// LOG(L_CRIT,"-2-\n");
while(tasks->start == tasks->end){
// LOG(L_CRIT,"-3-\n");
lock_release(tasks->lock);
// LOG(L_CRIT,"-4-\n");
if (*shutdownx) {
sem_release(tasks->empty);
return t;
}
// LOG(L_ERR,"-");
sem_get(tasks->empty);
// LOG(L_CRIT,"-5-\n");
if (*shutdownx) {
sem_release(tasks->empty);
return t;
}
lock_get(tasks->lock);
// LOG(L_CRIT,"-6-\n");
}
// LOG(L_CRIT,"-7-\n");
t = tasks->queue[tasks->start];
tasks->queue[tasks->start].msg = 0;
tasks->start = (tasks->start+1) % tasks->max;
if (sem_release(tasks->full)<0)
LOG(L_WARN,"WARN:take_task(): Error releasing tasks->full semaphore > %s!\n",strerror(errno));
lock_release(tasks->lock);
return t;
}
/**
* Adds a message as a task to the task queue.
* This blocks if the task queue is full, until there is space.
* @param p - the peer that the message was received from
* @param msg - the message
* @returns 1 on success, 0 on failure (eg. shutdown in progress)
*/
int put_task(peer *p,AAAMessage *msg)
{
lock_get(tasks->lock);
while ((tasks->end+1)%tasks->max == tasks->start){
lock_release(tasks->lock);
if (*shutdownx) {
sem_release(tasks->full);
return 0;
}
sem_get(tasks->full);
if (*shutdownx) {
sem_release(tasks->full);
return 0;
}
lock_get(tasks->lock);
}
tasks->queue[tasks->end].p = p;
tasks->queue[tasks->end].msg = msg;
tasks->end = (tasks->end+1) % tasks->max;
if (sem_release(tasks->empty)<0)
LOG(L_WARN,"WARN:put_task(): Error releasing tasks->empty semaphore > %s!\n",strerror(errno));
lock_release(tasks->lock);
return 1;
}
void task2(void *arg)
{
os_printf("task2 start....\n");
for (;;) {
#if msg_queue_test
memset(buffer, 0, 10);
msg_get(&my_queue, buffer);
os_printf("queue 0 read = %s\n", buffer);
memset(buffer, 0, 10);
msg_get(&my_queue1, buffer);
os_printf("queue 1 read = %s\n", buffer);
memset(buffer, 0, 10);
msg_get(&my_queue2, buffer);
os_printf("queue 2 read = %s\n", buffer);
#endif
#if sem_test
sem_get(&sem);
os_printf("task2 sem.count = %d\n", sem.count );
#endif
#if mutex_test
os_printf("task2 running\n" );
mutex_get(&mutex);
os_printf("task2 priority: %d\n", new_task->prio );
mutex_put(&mutex);
#endif
os_delay(100);
};
}
/**
* Music player callback to get the current song path.
*/
static const char *get_current_song_path(void *arg_p)
{
struct song_t *song_p;
sem_get(&sem, NULL);
song_p = hash_map_get(&song_map, current_song);
sem_put(&sem, 1);
return (song_p->name);
}
/***************************************************************************
GfxSetFGColor
***************************************************************************/
void GfxSetFGColor(u_int32 Color)
{
sem_get(GXA_Sem_Id, KAL_WAIT_FOREVER);
mCheckFifo(1)
mLoadReg(GXA_FG_COLOR_REG, Color)
sem_put(GXA_Sem_Id);
}
CNXT_SMC_STATUS cnxt_smc_term ( void )
{
u_int32 i;
IS_DRIVER_INITED(SMC, pDriverInst->bInit);
if (sem_get(pDriverInst->DriverSem, KAL_WAIT_FOREVER) != RC_OK)
{
return CNXT_SMC_INTERNAL_ERROR;
}
/* Mark the driver as not initialized */
pDriverInst->bInit = FALSE;
/* notify all clients of termination of the driver */
for ( i = 0 ; i < CNXT_SMC_NUM_UNITS ; i ++ )
{
cnxt_smc_notify_unit_clients(CNXT_SMC_EVENT_TERM, i);
if ( Card[i].ResetJob.SyncSem )
{
sem_delete ( Card[i].ResetJob.SyncSem );
Card[i].ResetJob.SyncSem = 0;
}
if ( Card[i].PowerdownJob.SyncSem )
{
sem_delete ( Card[i].PowerdownJob.SyncSem );
Card[i].PowerdownJob.SyncSem = 0;
}
}
/* destroy RW job semaphores */
for ( i = 0 ; i < CNXT_SMC_MAX_PENDING_RW ; i ++ )
{
if ( RwJobs[i].SyncSem )
{
sem_delete ( RwJobs[i].SyncSem );
}
}
/* Destroy semaphore */
if (pDriverInst->DriverSem)
{
sem_delete(pDriverInst->DriverSem);
pDriverInst->DriverSem = 0;
}
return CNXT_SMC_OK;
} /* end cnxt_smc_term() */
/*---------------------------------------------------------------------------*/
int getchar (void)
{
int val ;
/* What if multiple tasks call getchar <-- DO */
if (sem_get (rx_sem, WAIT_FOREVER) == GOOD)
{
val = rx_buf [rx_c++ % BUF_SIZE] ;
return val ;
}
return EOF ;
} /* End of Function getchar () */
/**
* Send a AAAMessage synchronously.
* This blocks until a response is received or a transactional time-out happens.
* @param message - the request to be sent
* @param peer_id - FQDN of the peer to send
* @returns 1 on success, 0 on failure
* \todo remove peer_id and add Realm routing
* \todo replace the busy-waiting lock in here with one that does not consume CPU
*/
AAAMessage* AAASendRecvMessageToPeer(AAAMessage *message, str *peer_id)
{
peer *p;
gen_sem_t *sem;
cdp_trans_t *t;
AAAMessage *ans;
p = get_peer_by_fqdn(peer_id);
if (!p) {
LOG(L_ERR,"ERROR:AAASendRecvMessageToPeer(): Peer unknown %.*s\n",peer_id->len,peer_id->s);
goto error;
}
if (p->state!=I_Open && p->state!=R_Open){
LOG(L_ERR,"ERROR:AAASendRecvMessageToPeer(): Peer not connected to %.*s\n",peer_id->len,peer_id->s);
goto error;
}
if (is_req(message)){
sem_new(sem,0);
t = cdp_add_trans(message,sendrecv_cb,(void*)sem,config->transaction_timeout,0);
// if (!peer_send_msg(p,message)) {
if (!sm_process(p,Send_Message,message,0,0)){
sem_free(sem);
goto error;
}
/* block until callback is executed */
while(sem_get(sem)<0){
if (shutdownx&&(*shutdownx)) goto error;
LOG(L_WARN,"WARN:AAASendRecvMessageToPeer(): interrupted by signal or something > %s\n",strerror(errno));
}
sem_free(sem);
ans = t->ans;
cdp_free_trans(t);
return ans;
} else {
LOG(L_ERR,"ERROR:AAASendRecvMessageToPeer(): can't add wait for answer to answer.\n");
goto error;
}
error:
out_of_memory:
AAAFreeMessage(&message);
return 0;
}
/**
* Adds a message as a task to the task queue.
* This blocks if the task queue is full, until there is space.
* @param p - the peer that the message was received from
* @param msg - the message
* @returns 1 on success, 0 on failure (eg. shutdown in progress)
*/
int put_task(peer *p, AAAMessage *msg) {
struct timeval start, stop;
long elapsed_useconds=0, elapsed_seconds=0, elapsed_millis=0;
lock_get(tasks->lock);
gettimeofday(&start, NULL);
while ((tasks->end + 1) % tasks->max == tasks->start) {
lock_release(tasks->lock);
if (*shutdownx) {
sem_release(tasks->full);
return 0;
}
sem_get(tasks->full);
if (*shutdownx) {
sem_release(tasks->full);
return 0;
}
lock_get(tasks->lock);
}
gettimeofday(&stop, NULL);
elapsed_useconds = stop.tv_usec - start.tv_usec;
elapsed_seconds = stop.tv_sec - start.tv_sec;
elapsed_useconds = elapsed_seconds*1000000 + elapsed_useconds;
elapsed_millis = elapsed_useconds/1000;
if (elapsed_millis > workerq_latency_threshold) {
LM_ERR("took too long to put task into task queue > %d - [%ld]\n", workerq_latency_threshold, elapsed_millis);
}
tasks->queue[tasks->end].p = p;
tasks->queue[tasks->end].msg = msg;
tasks->end = (tasks->end + 1) % tasks->max;
if (sem_release(tasks->empty) < 0)
LM_WARN("Error releasing tasks->empty semaphore > %s!\n", strerror(errno));
lock_release(tasks->lock);
//int num_tasks = tasks->end - tasks->start;
//LM_ERR("Added task to task queue. Queue length [%i]", num_tasks);
return 1;
}
static int next()
{
music_player_song_stop(&music_player);
/* Increment current song. */
sem_get(&sem, NULL);
current_song++;
if (hash_map_get(&song_map, current_song) == NULL) {
current_song = FIRST_SONG_NUMBER;
}
sem_put(&sem, 1);
return (music_player_song_play(&music_player));
}
static int prev()
{
music_player_song_stop(&music_player);
/* Increment current song. */
sem_get(&sem, NULL);
if (current_song == FIRST_SONG_NUMBER) {
current_song = last_song_number;
} else {
current_song--;
}
sem_put(&sem, 1);
return (music_player_song_play(&music_player));
}
cdp_cb_event_t* pop_cdp_cb_event() {
cdp_cb_event_t *ev;
lock_get(cdp_event_list->lock);
while (cdp_event_list->head == 0) {
lock_release(cdp_event_list->lock);
sem_get(cdp_event_list->empty);
lock_get(cdp_event_list->lock);
}
ev = cdp_event_list->head;
cdp_event_list->head = ev->next;
if (ev == cdp_event_list->tail) { //list now empty
cdp_event_list->tail = 0;
}
ev->next = 0; //make sure whoever gets this cant access our list
lock_release(cdp_event_list->lock);
return ev;
}
/**
* Music player callback to get the next song path.
*/
static const char *get_next_song_path(void *arg_p)
{
struct song_t *song_p;
sem_get(&sem, NULL);
/* Increment current song. */
if (repeat == 0) {
current_song++;
}
song_p = hash_map_get(&song_map, current_song);
sem_put(&sem, 1);
if (song_p != NULL) {
return (song_p->name);
} else {
current_song = FIRST_SONG_NUMBER;
return (NULL);
}
}
/*---------------------------------------------------------------------------*/
void stdout_task (void)
{
u8 c, bl = '\r' ;
/* When stdout_task() is first run, make sure to take putchar() */
/* out of the debug state. */
tx_init = YES ;
/* Get into a forever loop and handle all tx's */
for (;;)
{
/* Wait to be woken up by putchar() */
if (sem_get (tx_task_sem, WAIT_FOREVER) != GOOD)
{
/* <-- DO */
}
/* Send out all the data */
while (tx_p != tx_c)
{
c = tx_buf [tx_c++ % BUF_SIZE] ;
/* Send data to the receiver module */
if (stdio_link.tx_func != NULL)
{
stdio_link.tx_func (0, 1, &c) ;
/* Follow a new line char with a begin line char */
if (c == '\n')
stdio_link.tx_func (0, 1, &bl) ;
}
/* Free the buffer spot */
sem_give (tx_buf_sem) ;
}
}
} /* End of function stdout_task () */
CNXT_SMC_STATUS cnxt_smc_close ( CNXT_SMC_HANDLE Handle )
{
CNXT_SMC_INST *pInst = (CNXT_SMC_INST*)Handle;
CNXT_SMC_UNIT_INST *pUnitInst;
IS_DRIVER_INITED(SMC,pDriverInst->bInit);
IS_VALID_HANDLE(SMC, pInst, &(pDriverInst->pUnitInst[pInst->uUnitNumber].pFirstInst));
if (sem_get(pDriverInst->DriverSem, KAL_WAIT_FOREVER) != RC_OK)
{
return CNXT_SMC_INTERNAL_ERROR;
}
/*
* Put Driver Specific code here.
*/
pUnitInst = &(pDriverInst->pUnitInst[pInst->uUnitNumber]);
/* release the resource of the instance */
if (REMOVE_HANDLE(&(pUnitInst->pFirstInst), pInst) == FALSE)
{
sem_put(pDriverInst->DriverSem); /* must be last line of routine! */
return CNXT_SMC_INTERNAL_ERROR;
}
DESTROY_HANDLE(&(pDriverInst->pInstList), pInst);
/* set the unit to be shared if no instance opened for the unit */
if ( pUnitInst->pFirstInst == NULL )
{
pUnitInst->bExclusive = FALSE;
}
sem_put(pDriverInst->DriverSem); /* must be last line of routine! */
return CNXT_SMC_OK;
} /* end cnxt_smc_close() */
CNXT_SMC_STATUS cnxt_smc_reset ( CNXT_SMC_CONFIG *pCfg )
{
u_int32 i;
IS_DRIVER_INITED(SMC, pDriverInst->bInit);
if (sem_get(pDriverInst->DriverSem, KAL_WAIT_FOREVER) != RC_OK)
{
return CNXT_SMC_INTERNAL_ERROR;
}
/* Mark the driver as not initialized */
pDriverInst->bInit = FALSE;
/* notify all clients of reset of the driver */
for ( i = 0 ; i < CNXT_SMC_NUM_UNITS ; i ++ )
{
cnxt_smc_notify_unit_clients(CNXT_SMC_EVENT_RESET, i);
}
/* initialize internal data */
if ( cnxt_smc_internal_data_init() == FALSE )
{
sem_put(pDriverInst->DriverSem);
return CNXT_SMC_RESOURCE_ERROR;
}
/*
* Put Driver Specific code here.
*/
pDriverInst->bInit = TRUE;
sem_put(pDriverInst->DriverSem); /* must be last line of routine! */
return CNXT_SMC_OK;
} /* end cnxt_smc_reset() */
int cmd_play(int argc,
const char *argv[],
void *out_p,
void *in_p)
{
long song_number;
struct song_t *song_p;
if (argc > 2) {
std_fprintf(out_p, FSTR("Usage: %s [<song number>]\r\n"), argv[0]);
return (-EINVAL);
}
if (argc == 2) {
if (std_strtol(argv[1], &song_number) != 0) {
return (-EINVAL);
}
/* Find the song in the hash map. */
song_p = hash_map_get(&song_map, song_number);
if (song_p == NULL) {
return (-EINVAL);
}
/* Stop the current song and set the new current song. */
music_player_song_stop(&music_player);
sem_get(&sem, NULL);
current_song = song_number;
sem_put(&sem, 1);
}
/* Play the song or resume it if it's paused. */
return (music_player_song_play(&music_player));
}
CNXT_SMC_STATUS cnxt_smc_powerdown_card ( CNXT_SMC_HANDLE Handle,
bool bAsync,
void *Tag )
{
CNXT_SMC_INST *pInst = (CNXT_SMC_INST*)Handle;
SMC_RW_JOB_DESCRIPTOR *pRwJob;
u_int32 uUnit;
bool bKs;
IS_DRIVER_INITED(SMC,pDriverInst->bInit);
IS_VALID_HANDLE(SMC, pInst, &(pDriverInst->pUnitInst[pInst->uUnitNumber].pFirstInst));
/*
* Put Driver Specific code here.
*/
uUnit = pInst->uUnitNumber;
/* check if there is resetting/power down pending */
bKs = critical_section_begin ();
if ( Card[uUnit].ResetJob.pInst )
{
critical_section_end ( bKs );
return CNXT_SMC_NOT_AVAILABLE;
}
if ( Card[uUnit].PowerdownJob.pInst )
{
critical_section_end ( bKs );
return CNXT_SMC_OK;
}
Card[uUnit].PowerdownJob.pInst = pInst;
critical_section_end ( bKs );
/* clear all pending RW jobs */
bKs = critical_section_begin ();
while ( Card[uUnit].pRwJob )
{
pRwJob = Card[uUnit].pRwJob;
Card[uUnit].pRwJob = pRwJob->pNext;
smc_term_rw_job ( pRwJob, CNXT_SMC_TIMEOUT );
}
critical_section_end ( bKs );
if ( Card[uUnit].State == SMC_NOT_INSERT )
{
Card[uUnit].PowerdownJob.pInst = NULL;
return CNXT_SMC_NOT_AVAILABLE;
}
/* save bAsync & Tag */
Card[uUnit].PowerdownJob.bAsync = bAsync;
Card[uUnit].PowerdownJob.Tag = Tag;
/* check if the card is up */
if ( CNXT_GET ( SMC_ICC_STAT_REG_ADDR ( BANK_FROM_SLOT_ID ( uUnit ) ),
SMC_ICC_STAT_CARDPOWER_MASK ) == 0 )
{
/* card is down, clear power down job */
Card[uUnit].PowerdownJob.pInst = NULL;
}
else
{
/* initiate deactivate */
*(LPREG)( SMC_ICC_CTRL_REG_ADDR ( BANK_FROM_SLOT_ID ( uUnit ) ) )
= SMC_ICC_CTRL_DEACTIVATECARD_MASK;
}
if ( Card[uUnit].PowerdownJob.bAsync == FALSE )
{
if ( sem_get ( Card[uUnit].PowerdownJob.SyncSem,
Card[uUnit].Config.uTimeout ) != RC_OK )
{
return CNXT_SMC_TIMEOUT;
}
}
return CNXT_SMC_OK;
} /* end cnxt_smc_reset_card */
CNXT_SMC_STATUS cnxt_smc_reset_card ( CNXT_SMC_HANDLE Handle,
bool bAsync,
void *Tag )
{
CNXT_SMC_INST *pInst = (CNXT_SMC_INST*)Handle;
SMC_RW_JOB_DESCRIPTOR *pRwJob;
u_int32 uUnit, uBank;
bool bKs;
IS_DRIVER_INITED(SMC,pDriverInst->bInit);
IS_VALID_HANDLE(SMC, pInst, &(pDriverInst->pUnitInst[pInst->uUnitNumber].pFirstInst));
/*
* Put Driver Specific code here.
*/
uUnit = pInst->uUnitNumber;
/* check if there is another resetting pending */
bKs = critical_section_begin ();
if ( Card[uUnit].ResetJob.pInst )
{
critical_section_end ( bKs );
return CNXT_SMC_OK;
}
Card[uUnit].ResetJob.pInst = pInst;
critical_section_end ( bKs );
/* clear other pending transactions */
bKs = critical_section_begin ();
if ( Card[uUnit].PowerdownJob.pInst )
{
if ( ( Card[uUnit].PowerdownJob.bAsync ) &&
( (Card[uUnit].PowerdownJob.pInst)->pNotifyFn ) )
{
(Card[uUnit].PowerdownJob.pInst)->pNotifyFn (
(CNXT_SMC_HANDLE)Card[uUnit].PowerdownJob.pInst,
(Card[uUnit].PowerdownJob.pInst)->pUserData,
CNXT_SMC_EVENT_CARD_POWER_DOWN_TIMEOUT,
NULL,
Card[uUnit].PowerdownJob.Tag );
}
Card[uUnit].PowerdownJob.pInst = NULL;
}
critical_section_end ( bKs );
/* clear all pending RW jobs */
while ( Card[uUnit].pRwJob )
{
bKs = critical_section_begin ();
pRwJob = Card[uUnit].pRwJob;
Card[uUnit].pRwJob = pRwJob->pNext;
critical_section_end ( bKs );
smc_term_rw_job ( pRwJob, CNXT_SMC_TIMEOUT );
}
/* save bAsync & Tag */
Card[uUnit].ResetJob.bAsync = bAsync;
Card[uUnit].ResetJob.Tag = Tag;
uBank = BANK_FROM_SLOT_ID ( uUnit );
/* initialize card descriptor */
smc_descriptor_init ( &Card[uUnit], uUnit );
/* check if there is card in the slot */
if ( Card[uUnit].State == SMC_NOT_INSERT )
{
Card[uUnit].ResetJob.pInst = NULL;
return CNXT_SMC_NOT_AVAILABLE;
}
/* initialize card HW */
smc_hw_init ( &Card[uUnit], uUnit );
/* set receive mode to receive ATR */
CNXT_SET_VAL ( SMC_TERM_CTRL_REG_ADDR ( uBank ),
SMC_TERM_CTRL_MODE_MASK,
SMC_MODE_RX );
/* Enable Rx Interrupt */
CNXT_SET_VAL ( SMC_INT_MASK_REG_ADDR ( uBank ),
SMC_INT_RXREAD_MASK,
SMC_ENABLE );
/* initiate reset */
if (CNXT_GET (SMC_ICC_STAT_REG_ADDR (uBank), SMC_ICC_STAT_CARDPOWER_MASK))
{
/* do a warm reset */
*(LPREG)(SMC_ICC_CTRL_REG_ADDR (uBank)) = SMC_ICC_CTRL_WARMRESET_MASK;
}
else
{
/* do a cold reset */
*(LPREG)(SMC_ICC_CTRL_REG_ADDR (uBank)) = ( SMC_ICC_CTRL_ACTIVATECARD_MASK |
SMC_ICC_CTRL_DEACTIVATECARD_MASK );
}
if ( Card[uUnit].ResetJob.bAsync == FALSE )
{
if ( sem_get ( Card[uUnit].ResetJob.SyncSem,
Card[uUnit].Config.uTimeout ) != RC_OK )
{
return CNXT_SMC_TIMEOUT;
}
}
return CNXT_SMC_OK;
} /* end cnxt_smc_reset_card */
CNXT_SMC_STATUS cnxt_smc_open ( CNXT_SMC_HANDLE *pHandle,
CNXT_SMC_CAPS *pCaps,
CNXT_SMC_PFNNOTIFY pNotifyFn,
void *pUserData )
{
CNXT_SMC_INST *pInst;
CNXT_SMC_UNIT_INST *pUnitInst;
u_int32 uUnit;
IS_DRIVER_INITED(SMC,pDriverInst->bInit);
IS_NOT_NULL_POINTER(SMC, pHandle);
IS_NOT_NULL_POINTER(SMC, pCaps);
if (sem_get(pDriverInst->DriverSem, KAL_WAIT_FOREVER) != RC_OK)
{
return CNXT_SMC_INTERNAL_ERROR;
}
/* figure out unit number based on info in pCaps */
uUnit = cnxt_smc_unit_num(pCaps);
if (uUnit >= CNXT_SMC_NUM_UNITS)
{
return CNXT_SMC_BAD_UNIT;
}
/* check bExclusive */
pUnitInst = &(pDriverInst->pUnitInst[uUnit]);
if ((pUnitInst->pFirstInst != NULL) &&
(pUnitInst->bExclusive || pCaps->bExclusive))
{
sem_put(pDriverInst->DriverSem); /* must be last line of routine! */
return CNXT_SMC_NOT_AVAILABLE;
}
/*
* There is a possibility that the pCaps needs to be checked further.
* Add that here.
*/
/* create an instance */
if ( !CREATE_HANDLE(&(pDriverInst->pInstList), &pInst) )
{
*pHandle = NULL;
sem_put(pDriverInst->DriverSem); /* must be last line of routine! */
return CNXT_SMC_RESOURCE_ERROR;
}
/* add the instance into the list */
pInst->uUnitNumber = uUnit;
if (ADD_HANDLE (&(pUnitInst->pFirstInst), pInst) == FALSE)
{
DESTROY_HANDLE(&(pDriverInst->pInstList), pInst);
sem_put(pDriverInst->DriverSem); /* must be last line of routine! */
return CNXT_SMC_INTERNAL_ERROR;
}
pInst->Preface.pSelf = (CNXT_HANDLE_PREFACE*)pInst;
pInst->pNotifyFn = pNotifyFn; /* Use this fcn to notify appl of events */
pInst->pUserData = pUserData; /* Store data the inst needs */
/*
* Put Driver Specific code here.
*/
/* set driver bExclusive field */
pUnitInst->bExclusive = pCaps->bExclusive;
*pHandle = (CNXT_SMC_HANDLE)pInst;
sem_put(pDriverInst->DriverSem); /* must be last line of routine! */
return CNXT_SMC_OK;
} /* end cnxt_smc_open() */
CNXT_SMC_STATUS cnxt_smc_init ( CNXT_SMC_CONFIG *pCfg )
{
static bool ReEntry = FALSE;
bool bKs;
u_int32 i;
/*
* Need to ensure that this routine only called once, so
* start crit section, test the semaphore for existence.
* If not exist, then create.
* get out of the critical section, and see if the semaphore
* exists. If it doesn't, then return an error.
* Now get the semaphore. If this fails then
* someone else grapped the semaphore, or there is a bigger
* system resource problem
*/
while (1)
{
bKs = critical_section_begin();
if ( ReEntry == FALSE )
{
ReEntry = TRUE;
critical_section_end(bKs);
break;
}
critical_section_end(bKs);
task_time_sleep(5);
}
if (pDriverInst->DriverSem == 0)
{
pDriverInst->DriverSem = sem_create(1, NULL);
}
if (pDriverInst->DriverSem == 0)
{
ReEntry = FALSE;
return CNXT_SMC_RESOURCE_ERROR;
}
if (sem_get(pDriverInst->DriverSem, KAL_WAIT_FOREVER) != RC_OK)
{
ReEntry = FALSE;
return CNXT_SMC_INTERNAL_ERROR;
}
if (pDriverInst->bInit == TRUE)
{
sem_put(pDriverInst->DriverSem);
ReEntry = FALSE;
return CNXT_SMC_ALREADY_INIT;
}
/* initialize internal data */
if ( cnxt_smc_internal_data_init() == FALSE )
{
sem_put(pDriverInst->DriverSem);
ReEntry = FALSE;
return CNXT_SMC_RESOURCE_ERROR;
}
/* connect internal data to the driver instance structure */
pDriverInst->pInstList = InstArray;
pDriverInst->pUnitInst = UnitInst;
/*
* Put Driver Specific code here.
*/
/* enable smart card access */
smc_access_enable ();
for ( i = 0 ; i < CNXT_SMC_NUM_UNITS ; i ++ )
{
/* create semaphore for synchronous implementations of asynchronous op */
if ( Card[i].ResetJob.SyncSem == 0 )
{
Card[i].ResetJob.SyncSem = sem_create ( 0, NULL );
if ( Card[i].ResetJob.SyncSem == 0 )
{
sem_put(pDriverInst->DriverSem);
ReEntry = FALSE;
return CNXT_SMC_RESOURCE_ERROR;
}
}
if ( Card[i].PowerdownJob.SyncSem == 0 )
{
Card[i].PowerdownJob.SyncSem = sem_create ( 0, NULL );
if ( Card[i].PowerdownJob.SyncSem == 0 )
{
sem_put(pDriverInst->DriverSem);
ReEntry = FALSE;
return CNXT_SMC_RESOURCE_ERROR;
}
}
/* intialize card HW */
smc_hw_init ( (pDriverInst->pUnitInst[i]).pCard, i );
/* Hook Interrupts */
if ( int_register_isr ( ( ( i == 0 ) ? INT_VENDOR_SLOT_0 : INT_VENDOR_SLOT_1 ),
(PFNISR)cnxt_smc_isr, FALSE, FALSE,
&previous_isr[i] ) != RC_OK )
{
return CNXT_SMC_INTERNAL_ERROR;
}
/* enable interrupts */
if ( int_enable ( ( i == 0 ) ? INT_VENDOR_SLOT_0 : INT_VENDOR_SLOT_1 ) != RC_OK )
{
return CNXT_SMC_INTERNAL_ERROR;
}
}
pDriverInst->bInit = TRUE;
sem_put(pDriverInst->DriverSem); /* must be last line of routine! */
ReEntry = FALSE;
return CNXT_SMC_OK;
} /* end cnxt_smc_init() */
CNXT_SMC_STATUS cnxt_smc_read_write ( CNXT_SMC_HANDLE Handle,
bool bAsync,
void *pOutBuf,
u_int32 uOutLength,
void *pInBuf,
u_int32 *pInLength,
void *Tag )
{
CNXT_SMC_INST *pInst = (CNXT_SMC_INST*)Handle;
u_int32 uUnit;
SMC_RW_JOB_DESCRIPTOR *pRwJob, *pJobNode;
bool bKs;
CNXT_SMC_STATUS RetCode = CNXT_SMC_OK;
IS_DRIVER_INITED(SMC,pDriverInst->bInit);
IS_VALID_HANDLE(SMC, pInst, &(pDriverInst->pUnitInst[pInst->uUnitNumber].pFirstInst));
if ( ( ( pOutBuf == NULL ) || ( uOutLength == 0 ) ) &&
( ( pInBuf == NULL ) || ( pInLength == NULL ) || ( *pInLength == 0 ) ) )
{
return CNXT_SMC_BAD_PARAMETER;
}
uUnit = pInst->uUnitNumber;
/* check the state of the card */
if ( Card[uUnit].State != SMC_ATR_PARSED )
{
return CNXT_SMC_NOT_AVAILABLE;
}
/* set up Rw job */
bKs = critical_section_begin ();
if ( ( pRwJob = cnxt_smc_new_rw_job () ) == NULL )
{
critical_section_end(bKs);
return CNXT_SMC_RESOURCE_ERROR;
}
critical_section_end(bKs);
#ifdef TFCAS
CNXT_SET_VAL ( SMC_CHTIME_REG_ADDR ( uUnit ), SMC_TIME_CYCLES_MASK, 9600 );
CNXT_SET_VAL ( SMC_BLKTIME_REG_ADDR ( uUnit ), SMC_TIME_CYCLES_MASK, 9600 );
#endif
pRwJob->pInst = pInst;
pRwJob->bAsync = bAsync;
pRwJob->pTxPtr = pOutBuf;
pRwJob->uBytesToTx = uOutLength;
pRwJob->pRxPtr = pInBuf;
pRwJob->pBytesRecved = pInLength;
pRwJob->pRxBufEnd = (u_int8*)pInBuf + *pInLength;
pRwJob->Tag = Tag;
pRwJob->pNext = NULL;
*(pRwJob->pBytesRecved) = 0;
/* add the job to the execution list */
bKs = critical_section_begin ();
if ( Card[uUnit].pRwJob )
{
pJobNode = Card[uUnit].pRwJob;
while ( pJobNode->pNext )
{
pJobNode = pJobNode->pNext;
}
pJobNode->pNext = pRwJob;
}
else
{
Card[uUnit].pRwJob = pRwJob;
smc_start_rw_job ( pRwJob );
}
critical_section_end ( bKs );
if ( ( bAsync == FALSE ) && pRwJob->SyncSem )
{
if ( sem_get ( pRwJob->SyncSem, KAL_WAIT_FOREVER ) == RC_OK )
{
/* rw job finished */
RetCode = pRwJob->Status;
bKs = critical_section_begin ();
cnxt_smc_free_rw_job ( pRwJob );
critical_section_end ( bKs );
}
else
{
RetCode = CNXT_SMC_INTERNAL_ERROR;
}
}
#ifdef TFCAS
CNXT_SET_VAL ( SMC_CHTIME_REG_ADDR ( uUnit ), SMC_TIME_CYCLES_MASK, 9600 );
CNXT_SET_VAL ( SMC_BLKTIME_REG_ADDR ( uUnit ), SMC_TIME_CYCLES_MASK, 9600 );
#endif
return RetCode;
}
int main(int argc, char *argv[])
{
char buffer[512], prog_name[512], sTemp[256];
int nret, i, share_size, count;
int shm_id;
int shm_need_init;
int bRet;
/*检测程序启动参数是否正确*/
if (CheckParam(argc, argv) == -1)
{
return 0;
}
strcpy(buffer, argv[0]);
split_str(buffer, prog_name, "/", 1, 1, 1, 1);
/*检测程序是否已经在后台运行*/
if (strcmp(argv[1], "start") != 0)
{
if ( !if_program_running(prog_name) )
{
WriteLog(0, 0, OUT_SCREEN, "系统尚未启动");
return 0;
}
}
WriteLog(0, 0, OUT_SCREEN, "读取配置文件 ... ");
if (GetInitInfo(argv[0]) == -1)
{
return 0;
}
/*WriteLog(0, 0, OUT_SCREEN, "OK !");*/
if (strcmp(G_ini.cur_version, CURRENT_SERVER_VERSION) != 0)
{
WriteLog(0, 0, OUT_SCREEN, "程序版本错误，禁止运行!");
return 0;
}
G_shm = NULL;
G_ctrl_data = NULL;
G_trans_buffer = NULL;
WriteLog(0, 0, OUT_SCREEN, "读取共享内存 ... ");
shm_need_init = 0;
if (strcmp(argv[1], "start") == 0 && argc == 2)
{
if (atoi(sTemp) > 1)
{
WriteLog(0, 0, OUT_SCREEN, "系统已经执行完成该命令");
return 0;
}
share_size = G_ini.proc_num * ((int)sizeof(struct SHM_CONF)) + (int)sizeof(struct SHM_HEAD);
shm_id = shmget((key_t)G_ini.shm_key, (size_t)share_size, IPC_CREAT | IPC_EXCL | 0777);
shm_need_init = 1;
bRet = sem_requ(G_ini.sem_key, 1, 1);
}
else
{
shm_id = shmget((key_t)G_ini.shm_key, 0, 0777);
bRet = sem_get(G_ini.sem_key, 1);
}
if (shm_id < 0)
{
/*EEXIST 17 File exists*/
WriteLog(0, 0, OUT_SCREEN, " shmget error(%d):%s", errno, strerror(errno));
FreeShm(shm_id);
return 0;
}
if (bRet == SEM_ERROR)
{
WriteLog(0, 0, OUT_SCREEN, " semget error:%s", gs_sem_err);
FreeShm(shm_id);
return 0;
}
G_shm = (char *)shmat(shm_id, 0, 0);
if (G_shm == (void *)-1)
{
WriteLog(0, 0, OUT_SCREEN, " shmat error(%d):%s", errno, strerror(errno));
FreeShm(shm_id);
return 0;
}
if (shm_need_init == 1)
{
/*共享内存初试化*/
InitShm();
}
else
{
if (ShmConfCheck() == -1)
{
WriteLog(0, 0, OUT_SCREEN, "INI文件在启动之后被修改过,禁止执行当前指令!");
if (shm_need_init == 1)
{
FreeShm(shm_id);
}
return 0;
}
}
/*WriteLog(0, 0, OUT_SCREEN, "OK !");*/
if (strcmp(argv[1], "stop") == 0 || strcmp(argv[1], "query") == 0 || strcmp(argv[1], "refresh") == 0)
{
strcpy(buffer, argv[0]);
split_str(buffer, prog_name, "/", 1, 1, 1, 1);
if (strcmp(argv[1], "query") == 0)
{
QueryClient(prog_name);
}
if (strcmp(argv[1], "refresh") == 0)
{
if (argc != 3)
{
RefreshParam(prog_name, 0);
}
else
{
RefreshParam(prog_name, atoi(argv[2]));
}
}
if (strcmp(argv[1], "stop") == 0)
{
WriteLog(0, 0, OUT_SCREEN, "server stop ...");
if (argc != 3)
{
StopClient(prog_name, 0);
}
else
{
StopClient(prog_name, atoi(argv[2]));
}
}
if (strcmp(argv[1], "refresh") != 0)
{
if (GetRunCount() == 0)
{
/*WriteLog(0, 0, OUT_SCREEN, "释放资源 ...");*/
FreeShm(shm_id);
}
}
return 0;
}
/****************************************************************************************/
count = 0;
for (i = 0 ; i < G_ini.port_num ; i++)
{
if (argc != 2)
{
if (atoi(argv[2]) != G_ini.port_list[i].lsnr_port)
{
continue;
}
}
WriteLog(0, 0, OUT_SCREEN, "\n启动:%s接口,port=[%d]", G_ini.port_list[i].name, G_ini.port_list[i].lsnr_port);
nret = StartPort(G_ini.port_list[i].lsnr_port, G_ini.port_list[i].lsnr_num, G_ini.port_list[i].lsnr_len, G_ini.port_list[i].is_reuse_addr);
FreeResource();
if (nret < 0)
{
continue;
}
count++;
}
if (count == 0)
{
WriteLog(0, 0, OUT_SCREEN, "系统启动失败,释放系统资源!");
FreeShm(shm_id);
}
else
{
WriteLog(0, 0, OUT_SCREEN, "系统启动指令执行完成!");
sleep(2);
if (GetRunCount() == 0)
{
WriteLog(0, 0, OUT_SCREEN, "进程启动失败");
FreeShm(shm_id);
}
}
return 0;
}
