コード例 #1
0
ファイル: core.c プロジェクト: housansan/ucos
/*
 * 统计 task init
 * 被其他 task 调用
 * Q: 怎么统计任务
 * A: 当空闲任务 idle_ctr 越大时那么显然 cpu_usage 利用率越小
 * 这里关键以什么为基准? 来计算利用率. 
 */
void stat_init(void)
{
#if CRITICAL_METHOD == 3
	OS_CPU_SR cpu_sr = sigset_mask;
#endif
	
	// 延迟是为了与时钟节拍同步
	// 这是恰好时 task_stat 运行
	time_dly(2);

	ENTER_CRITICAL();

	idle_ctr = 0;

	EXIT_CRITICAL();

	time_dly(TICKS_PER_SEC);

	ENTER_CRITICAL();

	idle_ctr_max = idle_ctr;
	stat_rdy = TRUE;

	EXIT_CRITICAL();
}
コード例 #2
0
ファイル: tlb-r4k.c プロジェクト: 325116067/semc-qsd8x50
void local_flush_tlb_all(void)
{
	unsigned long flags;
	unsigned long old_ctx;
	int entry;

	ENTER_CRITICAL(flags);
	/* Save old context and create impossible VPN2 value */
	old_ctx = read_c0_entryhi();
	write_c0_entrylo0(0);
	write_c0_entrylo1(0);

	entry = read_c0_wired();

	/* Blast 'em all away. */
	while (entry < current_cpu_data.tlbsize) {
		/* Make sure all entries differ. */
		write_c0_entryhi(UNIQUE_ENTRYHI(entry));
		write_c0_index(entry);
		mtc0_tlbw_hazard();
		tlb_write_indexed();
		entry++;
	}
	tlbw_use_hazard();
	write_c0_entryhi(old_ctx);
	FLUSH_ITLB;
	EXIT_CRITICAL(flags);
}
コード例 #3
0
ファイル: ring_buffer.c プロジェクト: Magicoe/LPC820
int32_t RingBuf_Write(ring_buffer_t* pRB, const uint8_t* data, uint32_t dataBytes)
{
	uint32_t writeToEnd, bytesToCopy;
	INIT_CRITICAL();
	ENTER_CRITICAL();
	/* Calculate the maximum amount we can copy */
	writeToEnd = pRB->size - pRB->wNdx;
	bytesToCopy = MIN(dataBytes, pRB->size - pRB->cnt);
	
	if (bytesToCopy != 0)
	{
		/* Copy as much as we can until we fall off the end of the buffer */
		memcpy(&pRB->pBuf[pRB->wNdx], data, MIN(bytesToCopy, writeToEnd));

		/* Check if we have more to copy to the front of the buffer */
		if (writeToEnd < bytesToCopy)
		{
			memcpy(pRB->pBuf, data + writeToEnd, bytesToCopy - writeToEnd);
		}

		/* Update the wNdx */
		
		pRB->wNdx = (pRB->wNdx + bytesToCopy) % pRB->size;
		pRB->cnt += dataBytes;
	}
	LEAVE_CRITICAL();
	return bytesToCopy;
}
コード例 #4
0
ファイル: timer.c プロジェクト: ArcticSaturn/msp430_launchpad
/**
 * \brief Create and start a timer
 * \param[in] timeout_ms - the time timeout in ms
 * \param[in] periodic - non-zero for a periodic timer,  0 for single shot
 * \param[in] callback - timer callback function
 * \param[in] arg - callback function private data
 * \return non-negative integer - the timer handle - on success, -1 otherwise
 */
int timer_create(uint16_t timeout_ms, int periodic, void (*callback)(void *), void *arg)
{
    int handle = -1;
    size_t i;

    /* Find a free timer */
    for (i = 0; i < MAX_TIMERS; i++) {
        if (_timer[i].callback == NULL) {
            break;
        }
    }

    /* Make sure a valid timer is found */
    if (i < MAX_TIMERS) {
        SR_ALLOC();
        ENTER_CRITICAL();

        /* Set up the timer */
        if (periodic != 0) {
            _timer[i].periodic = (timeout_ms < 100) ? 1 : (timeout_ms / TIMER_RESOLUTION_MS);
        } else {
            _timer[i].periodic = 0;
        }

        _timer[i].callback = callback;
        _timer[i].arg = arg;
        _timer[i].expiry = _timer_tick + _timer[i].periodic; 

        EXIT_CRITICAL();
        handle = i;
    } 

    return handle;
}
コード例 #5
0
ファイル: schedule.c プロジェクト: nis/EMP
void _clear_sem(INT16U sem)
/*****************************************************************************
*   Function : See module specification (.h-file).
*****************************************************************************/
{
    ENTER_CRITICAL();
    semaphores &= (~sem);
    EXIT_CRITICAL();
}
コード例 #6
0
ファイル: schedule.c プロジェクト: nis/EMP
void _signal_sem(INT16U sem)
/*****************************************************************************
*   Function : See module specification (.h-file).
*****************************************************************************/
{
    ENTER_CRITICAL();
    semaphores |= sem;
    EXIT_CRITICAL();
}
コード例 #7
0
ファイル: watchdog_process.c プロジェクト: MeloQi/ReadCardSub
/**************************************************************************************
** 函数名称 :watchdog_process()
** 函数功能 :定时喂狗
** 入口参数 :无
** 出口参数 :
**************************************************************************************/
void watchdog_process(void)
{
	if(dog_cnt > DOG_TIME){
		dog_cnt = 0;
		ENTER_CRITICAL();					//喂狗
		watchdog_weigou();
		EXIT_CRITICAL();
	}
}
コード例 #8
0
ファイル: spi.c プロジェクト: espressif/ESP8266_RTOS_SDK
esp_err_t spi_set_mode(spi_host_t host, spi_mode_t *mode)
{
    SPI_CHECK(host < SPI_NUM_MAX, "host num error", ESP_ERR_INVALID_ARG);
    SPI_CHECK(spi_object[host], "spi has not been initialized yet", ESP_FAIL);
    SPI_CHECK(mode, "parameter pointer is empty", ESP_ERR_INVALID_ARG);

    spi_object[host]->mode = *mode;
    ENTER_CRITICAL();
    // Disable flash operation mode
    SPI[host]->user.flash_mode = false;

    if (SPI_MASTER_MODE == *mode) {
        // Set to Master mode
        SPI[host]->pin.slave_mode = false;
        SPI[host]->slave.slave_mode = false;
        // Master uses the entire hardware buffer to improve transmission speed
        SPI[host]->user.usr_mosi_highpart = false;
        SPI[host]->user.usr_miso_highpart = false;
        SPI[host]->user.usr_mosi = true;
        // Create hardware cs in advance
        SPI[host]->user.cs_setup = true;
        // Hysteresis to keep hardware cs
        SPI[host]->user.cs_hold = true;
        SPI[host]->user.duplex = true;
        SPI[host]->user.ck_i_edge = true;
        SPI[host]->ctrl2.mosi_delay_num = 0;
        SPI[host]->ctrl2.miso_delay_num = 1;
    } else {
        // Set to Slave mode
        SPI[host]->pin.slave_mode = true;
        SPI[host]->slave.slave_mode = true;
        SPI[host]->user.usr_miso_highpart = true;
        // MOSI signals are delayed by APB_CLK(80MHz) mosi_delay_num cycles
        SPI[host]->ctrl2.mosi_delay_num = 2;
        SPI[host]->ctrl2.miso_delay_num = 0;
        SPI[host]->slave.wr_rd_sta_en = 1;
        SPI[host]->slave1.status_bitlen = 31;
        SPI[host]->slave1.status_readback = 0;
        // Put the slave's miso on the highpart, so you can only send 256bits
        // In Slave mode miso, mosi length is the same
        SPI[host]->slave1.buf_bitlen = 255;
        SPI[host]->cmd.usr = 1;
    }

    SPI[host]->user.fwrite_dual = false;
    SPI[host]->user.fwrite_quad = false;
    SPI[host]->user.fwrite_dio  = false;
    SPI[host]->user.fwrite_qio  = false;
    SPI[host]->ctrl.fread_dual  = false;
    SPI[host]->ctrl.fread_quad  = false;
    SPI[host]->ctrl.fread_dio   = false;
    SPI[host]->ctrl.fread_qio   = false;
    SPI[host]->ctrl.fastrd_mode = true;
    EXIT_CRITICAL();

    return ESP_OK;
}
コード例 #9
0
ファイル: ring_buffer.c プロジェクト: Magicoe/LPC820
int32_t RingBuf_Free(ring_buffer_t* pRB, uint32_t bytesToFree)
{
	INIT_CRITICAL();
	ENTER_CRITICAL();
	pRB->rNdx = (pRB->rNdx + bytesToFree) % pRB->size;
	pRB->cnt -= bytesToFree;
	LEAVE_CRITICAL();
	return bytesToFree;
}
コード例 #10
0
ファイル: systick.c プロジェクト: Exchizz/Projekt-2014
INT8U systick_get(void)
{
	INT8U	return_value = 0;
	
	ENTER_CRITICAL();
	return_value = tick;
	EXIT_CRITICAL();

	return return_value;
}
コード例 #11
0
ファイル: spi.c プロジェクト: espressif/ESP8266_RTOS_SDK
esp_err_t spi_set_clk_div(spi_host_t host, spi_clk_div_t *clk_div)
{
    SPI_CHECK(host < SPI_NUM_MAX, "host num error", ESP_ERR_INVALID_ARG);
    SPI_CHECK(spi_object[host], "spi has not been initialized yet", ESP_FAIL);
    SPI_CHECK(clk_div, "parameter pointer is empty", ESP_ERR_INVALID_ARG);

    ENTER_CRITICAL();

    if (SPI_MASTER_MODE == spi_object[host]->mode) {
        if (SPI_80MHz_DIV == *clk_div) {
            switch (host) {
                case CSPI_HOST: {
                    SET_PERI_REG_MASK(PERIPHS_IO_MUX_CONF_U, SPI0_CLK_EQU_SYS_CLK);
                }
                break;

                case HSPI_HOST: {
                    SET_PERI_REG_MASK(PERIPHS_IO_MUX_CONF_U, SPI1_CLK_EQU_SYS_CLK);
                }
                break;
            }

            SPI[host]->clock.clk_equ_sysclk = true;
        } else {
            // Configure the IO_MUX clock (required, otherwise the clock output will be confusing)
            switch (host) {
                case CSPI_HOST: {
                    CLEAR_PERI_REG_MASK(PERIPHS_IO_MUX_CONF_U, SPI0_CLK_EQU_SYS_CLK);
                }
                break;

                case HSPI_HOST: {
                    CLEAR_PERI_REG_MASK(PERIPHS_IO_MUX_CONF_U, SPI1_CLK_EQU_SYS_CLK);
                }
                break;
            }

            // FRE(SCLK) = clk_equ_sysclk ? 80MHz : APB_CLK(80MHz) / clkdiv_pre / clkcnt
            SPI[host]->clock.clk_equ_sysclk = false;
            SPI[host]->clock.clkdiv_pre = 0;
            SPI[host]->clock.clkcnt_n = *clk_div - 1;
            // In the master mode clkcnt_h = floor((clkcnt_n+1)/2-1). In the slave mode it must be 0
            SPI[host]->clock.clkcnt_h = *clk_div / 2 - 1;
            // In the master mode clkcnt_l = clkcnt_n. In the slave mode it must be 0
            SPI[host]->clock.clkcnt_l = *clk_div - 1;
        }
    } else {
        // Slave mode must be set to 0
        SPI[host]->clock.val = 0;
    }

    EXIT_CRITICAL();

    return ESP_OK;
}
コード例 #12
0
ファイル: imgproc.c プロジェクト: 12019/mtktest
/*
* FUNCTION
*	   IMGPROC_Open
*
* DESCRIPTION
*   	Set owner of the IMGPROC. While one owner open the IMGPROC, no one
*	is allowed to use IMGPROC untile the owern close it.
*
* CALLS
*
* PARAMETERS
*
* RETURNS
*	   None
*
* GLOBALS AFFECTED
*     imgproc_dcb.owner
*/
kal_int32 API IMGPROC_Open(MMDI_SCENERIO_ID owner)
{
#if (defined(DRV_IDP_6219_SERIES))
	ENTER_CRITICAL();
	ASSERT(imgproc_dcb.owner == SCENARIO_UNKNOW_ID);
	imgproc_dcb.owner = owner;
	EXIT_CRITICAL();
   DRVPDN_Disable(DRVPDN_CON3,DRVPDN_CON3_IMGPROC,PDN_IMGPROC);
#endif
	return NO_ERROR;
}
コード例 #13
0
ファイル: usart.c プロジェクト: feixingzhe9/bestfu-dev-cube
/*******************************************************************************
函 数 名:	USART1_IRQHandler
功能说明:	串口中断处理
参	  数:	无
返 回 值:	无
*******************************************************************************/
void USART2_IRQHandler(void)
{
    if(USART2->SR&(1<<5))//接收到数据
    {
        CPU_SR_ALLOC();
        ENTER_CRITICAL();
        fifo_putc(&phy_rcvUsartfifo, USART2->DR);
        EXIT_CRITICAL();
    }
    USART2->SR &=~(1<<5);
}
コード例 #14
0
ファイル: time.c プロジェクト: housansan/ucos
/*
 * ticks
 */
void time_set(u32 ticks)
{
#if CRITICAL_METHOD == 3
	OS_CPU_SR cpu_sr = sigset_mask;
#endif

	ENTER_CRITICAL();

	jiffies = ticks;

	EXIT_CRITICAL();
}
コード例 #15
0
ファイル: eventbuffer.cpp プロジェクト: speakman/qlc
bool EventBuffer::put(Event* event)
{
  ENTER_CRITICAL();

  m_tailPos = (m_tailPos + 1) % EVENT_BUFFER_SIZE;

  EXIT_CRITICAL();

  if (m_tailPos == m_headPos)
    {
      return false;
    }

  ENTER_CRITICAL();

  m_buffer[m_tailPos] = event;

  EXIT_CRITICAL();
  
  return true;
}
コード例 #16
0
void local_flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
	unsigned long end)
{
	struct mm_struct *mm = vma->vm_mm;
	int cpu = smp_processor_id();

	if (cpu_context(cpu, mm) != 0) {
		unsigned long size, flags;
		unsigned long config6_flags;

		ENTER_CRITICAL(flags);
		disable_pgwalker(config6_flags);
		size = (end - start + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
		size = (size + 1) >> 1;
		if (size <= current_cpu_data.tlbsize/2) {
			int oldpid = read_c0_entryhi();
			int newpid = cpu_asid(cpu, mm);

			start &= (PAGE_MASK << 1);
			end += ((PAGE_SIZE << 1) - 1);
			end &= (PAGE_MASK << 1);
			while (start < end) {
				int idx;

				write_c0_entryhi(start | newpid);
				start += (PAGE_SIZE << 1);
				mtc0_tlbw_hazard();
				tlb_probe();
				tlb_probe_hazard();
				idx = read_c0_index();
				write_c0_entrylo0(0);
				write_c0_entrylo1(0);
				if (idx < 0)
					continue;
				/* Make sure all entries differ. */
#ifndef CONFIG_NLM_VMIPS
				write_c0_entryhi(UNIQUE_ENTRYHI(idx));
#else
				__write_64bit_c0_register($10, 0, (UNIQUE_VMIPS_ENTRYHI(idx)));
#endif
				mtc0_tlbw_hazard();
				tlb_write_indexed();
			}
			tlbw_use_hazard();
			write_c0_entryhi(oldpid);
		} else {
			drop_mmu_context(mm, cpu);
		}
		FLUSH_ITLB;
		enable_pgwalker(config6_flags);
		EXIT_CRITICAL(flags);
	}
コード例 #17
0
ファイル: schedule.c プロジェクト: tschristensen/EMB
uint8_t _test_sem(uint16_t sem)
/*****************************************************************************
*   Function : See module specification (.h-file).
*****************************************************************************/
{
	uint8_t return_value = 0;
	
	ENTER_CRITICAL();
	return_value = ((semaphores & sem) != 0);
	EXIT_CRITICAL();

	return return_value;
}
コード例 #18
0
ファイル: schedule.c プロジェクト: nis/EMP
INT8U _test_sem(INT16U sem)
/*****************************************************************************
*   Function : See module specification (.h-file).
*****************************************************************************/
{
    INT8U return_value = 0;

    ENTER_CRITICAL();
    return_value = ((semaphores & sem) != 0);
    EXIT_CRITICAL();

    return return_value;
}
コード例 #19
0
ファイル: core.c プロジェクト: housansan/ucos
static void task_stat(void)
{
#if CRITICAL_METHOD == 3
	OS_CPU_SR cpu_sr = sigset_mask;
#endif
	
	s32 run;
	s8 usage;

	while(FALSE == stat_rdy) 
	{
		time_dly(2 * TICKS_PER_SEC);
	}

	while(1) 
	{
		ENTER_CRITICAL();

		//idle_ctr_run = idle_ctr;
		run = idle_ctr;
		idle_ctr = 0;

		EXIT_CRITICAL();

		//printf("idle_ctr_max: %d\n", idle_ctr_max);

		if (idle_ctr_max > 0)
		{
			usage = (s8)(100 - 100 * run / idle_ctr_max);
			//printf("usage: %d, run: %d\n", usage, run);
			if (usage > 100)
			{
				cpu_usage = 100;
			}
			else if (usage < 0)
			{
				cpu_usage = 0;
			}
			else 
			{
				cpu_usage = usage;
			}
		}
		else 
		{
			cpu_usage = 0;
		}

		time_dly(TICKS_PER_SEC);
	}
}
コード例 #20
0
ファイル: spi.c プロジェクト: espressif/ESP8266_RTOS_SDK
static esp_err_t spi_slave_trans(spi_host_t host, spi_trans_t trans)
{
    SPI_CHECK(trans.bits.cmd >= 3 && trans.bits.cmd <= 16, "spi cmd must be longer than 3 bits and shorter than 16 bits", ESP_ERR_INVALID_ARG);
    SPI_CHECK(trans.bits.addr >= 1 && trans.bits.addr <= 32, "spi addr must be longer than 1 bits and shorter than 32 bits", ESP_ERR_INVALID_ARG);
    SPI_CHECK(trans.bits.miso <= 256, "spi miso must be shorter than 256 bits", ESP_ERR_INVALID_ARG);
    SPI_CHECK(trans.bits.mosi <= 256, "spi mosi must be shorter than 256 bits", ESP_ERR_INVALID_ARG);

    int x, y;
    ENTER_CRITICAL();
    // Set cmd length and receive cmd
    SPI[host]->user2.usr_command_bitlen = trans.bits.cmd - 1;

    if (trans.cmd) {
        *trans.cmd = SPI[host]->user2.usr_command_value;
    }

    // Set addr length and transfer addr
    SPI[host]->slave1.wr_addr_bitlen = trans.bits.addr - 1;
    SPI[host]->slave1.rd_addr_bitlen = trans.bits.addr - 1;

    if (trans.addr) {
        *trans.addr = SPI[host]->addr;
    }

    // Set the length of the miso and transfer the miso
    if (trans.bits.miso && trans.miso) {
        for (x = 0; x < trans.bits.miso; x += 32) {
            y = x / 32;
            SPI[host]->data_buf[y + 8] = trans.miso[y];
        }
    }

    // Call the event callback function to send a transfer start event
    if (spi_object[host]->event_cb) {
        spi_object[host]->event_cb(SPI_TRANS_START_EVENT, NULL);
    }

    // Receive mosi data
    if (trans.bits.mosi && trans.mosi) {
        for (x = 0; x < trans.bits.mosi; x += 32) {
            y = x / 32;
            trans.mosi[y] = SPI[host]->data_buf[y];
        }
    }

    EXIT_CRITICAL();

    return ESP_OK;
}
コード例 #21
0
ファイル: ring_buffer.c プロジェクト: Magicoe/LPC820
int32_t RingBuf_Write1Byte(ring_buffer_t* pRB, const uint8_t *pcData)
{
	uint32_t ret = 0;
	INIT_CRITICAL();
	ENTER_CRITICAL();
	if (pRB->cnt < pRB->size)
	{
		pRB->pBuf[pRB->wNdx] = pcData[0];
		pRB->wNdx = (pRB->wNdx + 1) % pRB->size;
		pRB->cnt++;
		ret = 1;
	}
	LEAVE_CRITICAL();
	return ret;
}
コード例 #22
0
ファイル: platform_EABox.c プロジェクト: ilxj/STM32_SPI
int check_Restore_function(void)
{	
	ENTER_CRITICAL();
	if(Restorechecking)
	{
		if(MS_TIMER - RESET_Button_pressed_start_time > RESET_BUTTON_PRESSED_TIME_DEFAULT){
			Restorechecking = 0;
			EXIT_CRITICAL();
			return 1;
		}
	}
	EXIT_CRITICAL();
	return 0;

}
コード例 #23
0
ファイル: platform_EABox.c プロジェクト: ilxj/STM32_SPI
int check_WPS_function(void)
{
	ENTER_CRITICAL();
	if(WPSchecking)
	{
		if(MS_TIMER - WPS_Button_pressed_start_time > WPS_BUTTON_PRESSED_TIME_WPS){
			WPSchecking = 0;
			EXIT_CRITICAL();
			return 1;
		}
	}
	EXIT_CRITICAL();
	return 0;

}
コード例 #24
0
ファイル: ring_buffer.c プロジェクト: Magicoe/LPC820
int32_t RingBuf_Read1Byte(ring_buffer_t* pRB, uint8_t *pData)
{
	uint32_t ret = 0;
	INIT_CRITICAL();
	ENTER_CRITICAL();
	if (pRB->cnt != 0)
	{
		pData[0] = pRB->pBuf[pRB->rNdx];
		pRB->rNdx = (pRB->rNdx + 1) % pRB->size;
		pRB->cnt--;
		ret = 1;
	}
	LEAVE_CRITICAL();
	return ret;
}
コード例 #25
0
ファイル: spi.c プロジェクト: espressif/ESP8266_RTOS_SDK
esp_err_t spi_slave_set_status(spi_host_t host, uint32_t *status)
{
    SPI_CHECK(host < SPI_NUM_MAX, "host num error", ESP_ERR_INVALID_ARG);
    SPI_CHECK(spi_object[host], "spi has not been initialized yet", ESP_FAIL);
    SPI_CHECK(SPI_SLAVE_MODE == spi_object[host]->mode, "this function must used by spi slave mode", ESP_FAIL);
    SPI_CHECK(status, "parameter pointer is empty", ESP_ERR_INVALID_ARG);

    ENTER_CRITICAL();

    SPI[host]->rd_status.val = *status;

    EXIT_CRITICAL();

    return ESP_OK;
}
コード例 #26
0
ファイル: time.c プロジェクト: housansan/ucos
u32 time_get(void)
{
#if CRITICAL_METHOD == 3
	OS_CPU_SR cpu_sr = sigset_mask;
#endif

	u32 ticks;

	ENTER_CRITICAL();

	ticks = jiffies;

	EXIT_CRITICAL();

	return (ticks);
}
コード例 #27
0
ファイル: tlb-r4k.c プロジェクト: daeiron/LG_G3_Kernel
void local_flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
                           unsigned long end)
{
    struct mm_struct *mm = vma->vm_mm;
    int cpu = smp_processor_id();

    if (cpu_context(cpu, mm) != 0) {
        unsigned long size, flags;
        int huge = is_vm_hugetlb_page(vma);

        ENTER_CRITICAL(flags);
        if (huge) {
            start = round_down(start, HPAGE_SIZE);
            end = round_up(end, HPAGE_SIZE);
            size = (end - start) >> HPAGE_SHIFT;
        } else {
コード例 #28
0
ファイル: time.c プロジェクト: housansan/ucos
/*
 * 取消 延时
 * 同时也会取消因 semaphore or event 等设置的延时
 */
u8 time_dly_resume(u8 prio)
{
#if CRITICAL_METHOD == 3
	OS_CPU_SR cpu_sr = sigset_mask;
#endif

	struct tcb *ptcb;
	u8 err = NO_ERR;

	err = general_check_prio(prio);
	if (NO_ERR != err)
	{
		goto fail;
	}

	ENTER_CRITICAL();

	ptcb = tcb_prio_tbl[prio];

	// check
	
	ptcb->delay = 0;
	// 如果有 semaphore event flag 挂起
	if (TASK_STAT_RDY != (ptcb->stat & TASK_STAT_PEND_ANY))
	{
		ptcb->stat &= ~TASK_STAT_PEND_ANY;
		ptcb->pend_to = TRUE;
	}
	else 
	{
		ptcb->pend_to = FALSE;
	}

	if (TASK_STAT_RDY == (ptcb->stat & TASK_STAT_SUSPEND))
	{
		tcb_enter_rdy(prio);
		EXIT_CRITICAL();
		schedule();
	}
	else 
	{
		EXIT_CRITICAL();
	}

fail:
	return err;
}
コード例 #29
0
ファイル: tlb-r4k.c プロジェクト: Voskrese/mipsonqemu
void local_flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
	unsigned long end)
{
	struct mm_struct *mm = vma->vm_mm;
	int cpu = smp_processor_id();

	if (cpu_context(cpu, mm) != 0) {
		unsigned long flags;
		int size;

		ENTER_CRITICAL(flags);
		size = (end - start + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
		size = (size + 1) >> 1;
		local_irq_save(flags);
		if (size <= current_cpu_data.tlbsize/2) {
			int oldpid = read_c0_entryhi();
			int newpid = cpu_asid(cpu, mm);

			start &= (PAGE_MASK << 1);
			end += ((PAGE_SIZE << 1) - 1);
			end &= (PAGE_MASK << 1);
			while (start < end) {
				int idx;

				write_c0_entryhi(start | newpid);
				start += (PAGE_SIZE << 1);
				mtc0_tlbw_hazard();
				tlb_probe();
				tlb_probe_hazard();
				idx = read_c0_index();
				write_c0_entrylo0(0);
				write_c0_entrylo1(0);
				if (idx < 0)
					continue;
				/* Make sure all entries differ. */
				write_c0_entryhi(UNIQUE_ENTRYHI(idx));
				mtc0_tlbw_hazard();
				tlb_write_indexed();
			}
			tlbw_use_hazard();
			write_c0_entryhi(oldpid);
		} else {
			drop_mmu_context(mm, cpu);
		}
		EXIT_CRITICAL(flags);
	}
コード例 #30
0
ファイル: timer.c プロジェクト: ArcticSaturn/msp430_launchpad
/**
 * \brief Delete a timer
 * \param[in] handle - the timer handle to delete
 * \return 0 if the handle is valid, -1 otherwise
 */
int timer_delete(int handle)
{
    int status = -1;

    if (handle < MAX_TIMERS) {
        SR_ALLOC();
        ENTER_CRITICAL();

        /* Clear the callback to delete the timer */
        _timer[handle].callback = NULL;

        EXIT_CRITICAL();
        status = 0;
    }

    return status;
}