sys_arch.c

来自「uCOSII2.84在at91sam9263的移植」· C语言 代码 · 共 276 行

/*
 * Copyright (c) 2001, Swedish Institute of Computer Science.
 * All rights reserved. 
 *
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions 
 * are met: 
 * 1. Redistributions of source code must retain the above copyright 
 *    notice, this list of conditions and the following disclaimer. 
 * 2. Redistributions in binary form must reproduce the above copyright 
 *    notice, this list of conditions and the following disclaimer in the 
 *    documentation and/or other materials provided with the distribution. 
 * 3. Neither the name of the Institute nor the names of its contributors 
 *    may be used to endorse or promote products derived from this software 
 *    without specific prior written permission. 
 *
 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
 * SUCH DAMAGE. 
 *
 * This file is part of the lwIP TCP/IP stack.
 * 
 * Author: Adam Dunkels <[e-mail]>
 *
 * $Id: sys_arch.c,v 1.1.1.1 2003/02/19 02:42:23 skyeye Exp $
 */

#include "lwip/debug.h"

#include "lwip/def.h"
#include "lwip/sys.h"
#include "lwip/mem.h"

#include "arch/sys_arch.h" 


const void * const pvNullPointer;//=0xffffffff;


static OS_MEM *pQueueMem;

static char pcQueueMemoryPool[MAX_QUEUES * sizeof(TQ_DESCR) ];

struct sys_timeouts lwip_timeouts[LWIP_TASK_MAX];
struct sys_timeouts null_timeouts;



OS_STK LWIP_TASK_STK[LWIP_TASK_MAX][LWIP_STK_SIZE];
u8_t curr_prio_offset;

/*-----------------------------------------------------------------------------------*/
sys_mbox_t sys_mbox_new(int size)
{
    u8_t       ucErr;
    PQ_DESCR    pQDesc;
 
    
    pQDesc = OSMemGet( pQueueMem, &ucErr );
    if( ucErr == OS_NO_ERR ) {   
        pQDesc->pQ = OSQCreate( &(pQDesc->pvQEntries[0]), MAX_QUEUE_ENTRIES );       
        if( pQDesc->pQ != NULL ) {
		    LWIP_DEBUGF(LWIP_DBG_ON, ("sys_mbox_new: OK\r\n" ));
            return pQDesc;
        }
        else
		    LWIP_DEBUGF(LWIP_DBG_ON, ("sys_mbox_new: Err pQ\r\n" ));
  	}
    else
        LWIP_DEBUGF(LWIP_DBG_ON, ("sys_mbox_new: Err Que\r\n" ));
	return SYS_MBOX_NULL;
    
}    



/*-----------------------------------------------------------------------------------*/
void sys_mbox_free(sys_mbox_t mbox)


{
    u8_t     ucErr;
    
    //clear OSQ EVENT
    OSQFlush( mbox->pQ );
    //del OSQ EVENT
    (void)OSQDel( mbox->pQ, OS_DEL_NO_PEND, &ucErr);
    //put mem back to mem queue
    ucErr = OSMemPut( pQueueMem, mbox );
}






/*-----------------------------------------------------------------------------------*/
void sys_mbox_post(sys_mbox_t mbox, void *data)
{
    if( !data ) 
	data = (void*)&pvNullPointer;
    (void)OSQPost( mbox->pQ, data);
}


u32_t sys_arch_mbox_tryfetch(sys_mbox_t mbox, void **msg)
{
   return 0;
}


err_t sys_mbox_trypost(sys_mbox_t mbox, void *msg)
{
   return 0;
}

/*-----------------------------------------------------------------------------------*/
u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **data, u32_t timeout)
{
    u8_t     ucErr;
    u32_t ucos_timeout;

    //in lwip ,timeout is  millisecond 
    //in ucosII ,timeout is timer  tick! 
    //chang timeout from millisecond to ucos tick
    ucos_timeout = 0;
    if(timeout != 0){
    ucos_timeout = timeout * (OS_TICKS_PER_SEC/1000);
    if(ucos_timeout < 1)
  	  ucos_timeout = 1;
    else if(ucos_timeout > 65535)
  	  ucos_timeout = 65535;
    }  
    
    //it is very important!!!! 
    //sometimes lwip calls sys_mbox_fetch(mbox,NULL)
    //it is dangrous to return (void *) to NULL ! (from OSQPend())
    if(data != NULL){
      *data = OSQPend( mbox->pQ, (u16_t)ucos_timeout, &ucErr );        
    }else{
      //just discard return value if data==NULL
      OSQPend(mbox->pQ,(u16_t)ucos_timeout,&ucErr);
    }
    
    if( ucErr == OS_TIMEOUT ) {
         timeout = SYS_ARCH_TIMEOUT;
    } else {
      if(*data == (void*)&pvNullPointer ) 
	  *data = NULL;
      timeout = 1;
    }
    return timeout;
}





/*-----------------------------------------------------------------------------------*/
sys_sem_t sys_sem_new(u8_t count)
{
    sys_sem_t pSem;
    pSem = OSSemCreate((u16_t)count );
    return pSem;
}





/*-----------------------------------------------------------------------------------*/
void sys_sem_signal(sys_sem_t sem)
{
    u8_t     ucErr;
    ucErr = OSSemPost((OS_EVENT *)sem );
}

u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout)
{
    u8_t err;
    u32_t ucos_timeout;


    //in lwip ,timeout is  millisecond in ucosII ,timeout is timer  tick! 
    //chang timeout from millisecond to ucos tick
    ucos_timeout = 0;
    if(timeout != 0){
         ucos_timeout = (timeout * OS_TICKS_PER_SEC)/1000;
     if(ucos_timeout < 1)
         ucos_timeout = 1;
     else if(ucos_timeout > 65535) 
         ucos_timeout = 65535;
     }
  	
     OSSemPend ((OS_EVENT *)sem,(u16_t)ucos_timeout, (u8_t *)&err);

     if(err == OS_TIMEOUT)
        return SYS_ARCH_TIMEOUT;
     else
     	return 1;
}

/*-----------------------------------------------------------------------------------*/

void sys_sem_free(sys_sem_t sem)
{
    u8_t     ucErr;
    (void)OSSemDel((OS_EVENT *)sem, OS_DEL_NO_PEND, &ucErr );
}

/*----------------------------------------------------------------------*/
struct sys_timeouts * sys_arch_timeouts(void)
{
    u8_t curr_prio;
    s16_t err,offset;
    OS_TCB curr_task_pcb;
    
    null_timeouts.next = NULL;
    //get current task prio
    err = OSTaskQuery(OS_PRIO_SELF,&curr_task_pcb);
    curr_prio = curr_task_pcb.OSTCBPrio;
  
    offset = curr_prio - LWIP_START_PRIO;
    //not called by a lwip task ,return timeouts->NULL
    if(offset < 0 || offset >= LWIP_TASK_MAX)
    {
      return &null_timeouts;
    }

    return &lwip_timeouts[offset];
}
/*------------------------------------------------------------------------*/


sys_thread_t sys_thread_new(char *name, void (* thread)(void *arg), void *arg, int stacksize, int prio)
{

  if(curr_prio_offset < LWIP_TASK_MAX){
  
    OSTaskCreate(thread, (void *)arg, &LWIP_TASK_STK[curr_prio_offset][LWIP_STK_SIZE-1],LWIP_START_PRIO+curr_prio_offset );
    curr_prio_offset++; 
  } else {
    // PRINT(" lwip task prio out of range ! error! ");
  }
  return LWIP_START_PRIO+curr_prio_offset;
}




/*-----------------------------------------------------------------------------------*/
void sys_init(void)
{
    u8_t i;
    //this func is called first in lwip task!
    u8_t   ucErr;
    //init mem used by sys_mbox_t
    //use ucosII functions pQueueMem = OSMemCreate( (void*)pcQueueMemoryPool, MAX_QUEUES, sizeof(TQ_DESCR), &ucErr );
    //init lwip task prio offset
    curr_prio_offset = 0;
    //init lwip_timeouts for every lwip task
    for(i=0;i<LWIP_TASK_MAX;i++){
    	lwip_timeouts[i].next = NULL;
    }
}
/*-----------------------------------------------------------------------------------*/