int main() { int i; /* The clock frequency of systick may be changed by user's application. Please change the value of SYSTICK_CLOCK according to real situration */ #define TT_SYSTICK_CLOCK 22118400 /* Initialize TinyThread */ tt_init(TT_SYSTICK_CLOCK); /* Open LED GPIO for testing */ DrvGPIO_Open(LED_GPIO_GREEN_GRP, LED_GPIO_GREEN_BIT, E_IO_OUTPUT); DrvGPIO_Open(LED_GPIO_RED_GRP, LED_GPIO_RED_BIT, E_IO_OUTPUT); DrvGPIO_Open(LED_GPIO_ISP_GRP, LED_GPIO_ISP_BIT, E_IO_OUTPUT); DrvGPIO_Open(LED_GPIO_ICE_GRP, LED_GPIO_ICE_BIT, E_IO_OUTPUT); /* Create and run thread */ arg[0].gpio_group = LED_GPIO_RED_GRP; arg[1].gpio_group = LED_GPIO_ISP_GRP; arg[2].gpio_group = LED_GPIO_ICE_GRP; arg[0].gpio_bit = LED_GPIO_RED_BIT; arg[1].gpio_bit = LED_GPIO_ISP_BIT; arg[2].gpio_bit = LED_GPIO_ICE_BIT; for (i = 0; i < THREAD_NUM; ++i) { tt_sem_init (&join_sem[i], 0); arg[i].join_sem = &join_sem[i]; thread[i] = tt_thread_create("thread", /* thread Name */ 0, /* thread priority */ stack[i], /* stack pointer */ sizeof(stack[i]), /* stack size */ thread_entry, /* thread entry function */ (void *)&arg[i] /* argument for thread entry function */ ); } /* Join threads. * TinyThread does not support build-in tt_thread_join() * since it is easy to emulate by a semaphore. */ for (i = 0; i < THREAD_NUM; ++i) tt_sem_down (&join_sem[i]); /* Set LED to indicate that run to here */ DrvGPIO_SetBit(LED_GPIO_RED_GRP, LED_GPIO_RED_BIT); /* OFF */ DrvGPIO_SetBit(LED_GPIO_ISP_GRP, LED_GPIO_ISP_BIT); /* OFF */ DrvGPIO_SetBit(LED_GPIO_ISP_GRP, LED_GPIO_ISP_BIT); /* OFF */ DrvGPIO_ClrBit(LED_GPIO_GREEN_GRP, LED_GPIO_GREEN_BIT); /* ON */ while(1); }
char* tth(const char* filename, char **tthl, size_t *tthl_len) { char *tth = NULL; size_t numbytes; unsigned char root[24]; unsigned char *cur; TT_CONTEXT tt; unsigned char buf[1 + 256 * BLOCKSIZE]; struct stat sb; unsigned level; size_t leaf_blocksize; int fd = open(filename, O_RDONLY); if ((fd == -1) || ( fstat(fd, &sb) == -1)) { return NULL; } level = calc_block_level(sb.st_size, max_block_count); leaf_blocksize = 1 << (level+10); *tthl_len = 0; *tthl = NULL; tt_init(&tt, *tthl, level); tt.leaf = buf; buf[0] = '\0'; while ( (numbytes = read(fd, &buf[1], sizeof(buf) - 1) ) > 0) { tt.index = BLOCKSIZE; for (cur = &buf[1]; cur + BLOCKSIZE <= &buf[numbytes + 1]; cur += BLOCKSIZE) { tt.leaf = cur - 1; tt.leaf[0] = '\0'; tt_block(&tt); } tt.index = numbytes - (cur - &buf[1]); tt.leaf = cur - 1; tt.leaf[0] = '\0'; } close(fd); tt_digest(&tt, root); tth = base32_encode(root, sizeof(root)); return tth; }
int main() { int i; THREAD_ARG_T arg[THREAD_NUM]; MY_SEM_T sem; /* The clock frequency of systick may be changed by user's application. Please change the value of SYSTICK_CLOCK according to real situration */ #define TT_SYSTICK_CLOCK 22118400 /* Initialize TinyThread */ tt_init(TT_SYSTICK_CLOCK); /* Open LED GPIO for testing */ DrvGPIO_Open(LED_GPIO_GREEN_GRP, LED_GPIO_GREEN_BIT, E_IO_OUTPUT); DrvGPIO_Open(LED_GPIO_RED_GRP, LED_GPIO_RED_BIT, E_IO_OUTPUT); DrvGPIO_Open(LED_GPIO_ISP_GRP, LED_GPIO_ISP_BIT, E_IO_OUTPUT); DrvGPIO_Open(LED_GPIO_ICE_GRP, LED_GPIO_ICE_BIT, E_IO_OUTPUT); /* Set semaphore value to 3, so that always 3 threads' LED is blinking */ my_sem_init (&sem, 3); /* Create and run thread */ arg[0].gpio_group = LED_GPIO_RED_GRP; arg[1].gpio_group = LED_GPIO_ISP_GRP; arg[2].gpio_group = LED_GPIO_ICE_GRP; arg[3].gpio_group = LED_GPIO_GREEN_GRP; arg[0].gpio_bit = LED_GPIO_RED_BIT; arg[1].gpio_bit = LED_GPIO_ISP_BIT; arg[2].gpio_bit = LED_GPIO_ICE_BIT; arg[3].gpio_bit = LED_GPIO_GREEN_BIT; for (i = 0; i < THREAD_NUM; ++i) { arg[i].sem = &sem; thread[i] = tt_thread_create("thread", /* thread Name */ 0, /* thread priority */ stack[i], /* stack pointer */ sizeof(stack[i]), /* stack size */ thread_entry, /* thread entry function */ (void *)&arg[i] /* argument for thread entry function */ ); } tt_thread_exit (); return 0; }
int main() { int i; /* The clock frequency of systick may be changed by user's application. Please change the value of SYSTICK_CLOCK according to real situration */ #define TT_SYSTICK_CLOCK 22118400 /* Initialize TinyThread */ tt_init(TT_SYSTICK_CLOCK); /* Open LED GPIO for testing */ _GPIO_SET_PIN_MODE(LED0_GPIO_GRP, LED0_GPIO_BIT, GPIO_PMD_OUTPUT); _GPIO_SET_PIN_MODE(LED1_GPIO_GRP, LED1_GPIO_BIT, GPIO_PMD_OUTPUT); _GPIO_SET_PIN_MODE(LED2_GPIO_GRP, LED2_GPIO_BIT, GPIO_PMD_OUTPUT); _GPIO_SET_PIN_MODE(LED3_GPIO_GRP, LED3_GPIO_BIT, GPIO_PMD_OUTPUT); /* Test threads lock by value[] the element in value should be the same, if not, there must be an error */ tt_rmutex_init(&mutex); for(i = 0; i < THREAD_NUM; ++i) value[i] = 0; arg[0].gpio_group = LED0_GPIO_GRP; arg[1].gpio_group = LED1_GPIO_GRP; arg[2].gpio_group = LED2_GPIO_GRP; arg[0].gpio_bit = LED0_GPIO_BIT; arg[1].gpio_bit = LED1_GPIO_BIT; arg[2].gpio_bit = LED2_GPIO_BIT; for(i = THREAD_NUM; i-- != 0; ) { arg[i].value = value; arg[i].mutex = &mutex; thread[i] = tt_thread_create("th", 0, stack[i], sizeof(stack[i]), thread_entry, (void *)&arg[i]); } tt_sleep(1024); while(1); return 0; }
static G_GNUC_COLD void tt_check_digest(const char * const expected, const void *data, size_t size) { char digest[TTH_BASE32_SIZE + 1]; struct tth hash; TTH_CONTEXT ctx; tt_init(&ctx, size); tt_update(&ctx, data, size); tt_digest(&ctx, &hash); ZERO(&digest); base32_encode(digest, sizeof digest, hash.data, sizeof hash.data); digest[G_N_ELEMENTS(digest) - 1] = '\0'; if (0 != strcmp(expected, digest)) { g_warning("tt_check_digest:\nExpected: \"%s\"\nGot: \"%s\"", expected, digest); g_error("Tigertree implementation is defective."); } }
int main() { /* The clock frequency of systick may be changed by user's application. Please change the value of SYSTICK_CLOCK according to real situration */ uint32_t SysGet_HCLKFreq(void); #define TT_SYSTICK_CLOCK SysGet_HCLKFreq() /* Initialize TinyThread */ tt_init(TT_SYSTICK_CLOCK); /* Initialize flag and event queue for timer interrupt */ g_is_irq_detected = 0; tt_wq_init(&g_wait_queue); /* Initialize timer */ init_timer(); while(1) { int rt; /* Check flag and then wait interrupt */ tt_disable_irq(); while(!g_is_irq_detected) { /* tt_wq_wait_event and tt_wq_wait_event_timeout will enable irq internally */ rt = tt_wq_wait_event_timeout(&g_wait_queue, 300); if(rt != 0) break; } g_is_irq_detected = 0; tt_enable_irq(); if(rt == 0) printf("Interrupt detected!\n"); else printf("Waiting timeout detected!\n"); } }
int sysInit (void) { /* <0> Save threads debug entry. */ #ifndef ECOS { extern UCHAR ASM_THREADS_DUMP_FUN[]; //A buffer in wb_init.s UINT32 uThreadDebugFun_Addr = (UINT32) &tt_dump_threads; memcpy (ASM_THREADS_DUMP_FUN, &uThreadDebugFun_Addr, sizeof (UINT32)); } #endif /* <1> Enable flash. */ sysFlushCache (I_D_CACHE); sysDisableCache (); sysEnableCache (CACHE_WRITE_BACK); /* <2> Disable almost all of the engines for safety. */ outpw (REG_CLKCON, inpw (REG_CLKCON) | CPUCLK_EN | APBCLK_EN | HCLK2_EN); outpw (REG_CLKSEL, SYSTEM_CLK_FROM_XTAL); outpw (REG_APLLCON, PLL_OUT_OFF); outpw (REG_UPLLCON, PLL_OUT_OFF); /* <3> Initialize UART. */ /* { WB_UART_T uart; TURN_ON_UART_CLOCK; uart.uiFreq = OPT_XIN_CLOCK; uart.uiBaudrate = 57600; uart.uiDataBits = WB_DATA_BITS_8; uart.uiStopBits = WB_STOP_BITS_1; uart.uiParity = WB_PARITY_NONE; uart.uiRxTriggerLevel = LEVEL_1_BYTE; sysInitializeUART(&uart); printf ("UART ok\n"); } */ /* <4> Set PLL. */ // SDRAM MCLK automatically on/off outpw(REG_SDICON, inpw(REG_SDICON) & 0xBFFFFFFF); // Force MPEG4 transfer length as 8 bytes outpw(REG_BBLENG1, (inpw(REG_BBLENG1) & 0xFFFFFFF8) | 0x2); // CLKDIV0 // Bit 1~0 : APB = HCLK1/? -------------------------+ // Bit15~8 : VPOST = PLL/? -----------------------+ | // Bit19~16: USB = PLL/? ---------------------+ | | // Bit23~20: Audio = PLL/? --------------------+| | | // Bit27~24: Sensor = PLL/? -------------------+|| | | // Bit31~28: System = PLL/? ------------------+||| | | // |||| | | // ||||++ | // outpw(REG_CLKDIV0, inpw(REG_CLKDIV0)&0x0fc|0x01322302); //(ok for 108) #ifndef ECOS outpw(REG_CLKDIV0, inpw(REG_CLKDIV0)&0x0fc|0x25362401); //(ok for 336(112)) #else //outpw(REG_CLKDIV0, inpw(REG_CLKDIV0)&0xf00000fc|0x05362401); //can't modify system clock outpw(REG_CLKDIV0, inpw(REG_CLKDIV0)&0x0fc|0x25362401); //(ok for 336(112)) #endif // outpw(REG_CLKDIV0, inpw(REG_CLKDIV0)&0x0fc|0x03331802); //(ok for 144) //Adjust SDRAM printf("setting apll to 0x%x, upll to 0x%x\n", pllEvalPLLCON (OPT_XIN_CLOCK, OPT_APLL_OUT_CLOCK), pllEvalPLLCON (OPT_XIN_CLOCK, OPT_UPLL_OUT_CLOCK)); outpw(REG_APLLCON, pllEvalPLLCON (OPT_XIN_CLOCK, OPT_APLL_OUT_CLOCK)); outpw(REG_UPLLCON, pllEvalPLLCON (OPT_XIN_CLOCK, OPT_UPLL_OUT_CLOCK)); // +-------- Bit31~28 : HCLK (from system) // |+------- Bit27~24 : CPU (from HCLK) // ||+------ Bit23~20 : HCLK1 (from HCLK, must less or equal to HCLK and CPU) // |||+----- Bit19~16 : HCLK2 (from HCLK) // ||||+---- Bit15~12 : MPEG4, JPEG (from HCLK2) // |||||+--- Bit11~8 : 2D, VPE (from HCLK2) // ||||||+-- Bit 7~6 : DSP (from HCLK2) // |||||||+- Bit 5~0 : Reserved. // outpw(REG_CLKDIV1, 0x00105045); //(ok for 108) outpw(REG_CLKDIV1, 0x00105045); //(ok for 112) // outpw(REG_CLKDIV1, 0x00110005); #ifndef ECOS //don't need to modify system clock source outpw(REG_CLKSEL, SYSTEM_CLK_FROM_UPLL); #endif printf("before system clock\n"); outpw(REG_CLKSEL, SYSTEM_CLK_FROM_UPLL); printf("system clock ok\n"); /* <5> Initialize TinyThread to support multi-thread. */ #ifndef ECOS tt_init (OPT_XIN_CLOCK, OPT_UPLL_OUT_CLOCK); #else //tt_init (OPT_XIN_CLOCK, OPT_UPLL_OUT_CLOCK); printf("reg_tcr0=0x%x reg_ticr0=0x%x\n", inpw(REG_TCR0), inpw(REG_TICR0)); printf("reg_tcr1=0x%x reg_ticr1=0x%x\n", inpw(REG_TCR1), inpw(REG_TICR1)); #endif /* <6> Set other engine clocks. */ /* Set vpost clock: Why I can NOT call it after HIC is transferred. */ outpw (REG_CLKSEL, inpw (REG_CLKSEL) | VIDEO_CLK_FROM_UPLL); tt_msleep (30); TURN_ON_VPOST_CLOCK; tt_msleep (30); /* Set audio clock. */ outpw (REG_CLKSEL, inpw (REG_CLKSEL) | AUDIO_CLK_FROM_APLL); tt_msleep (30); TURN_ON_AUDIO_CLOCK; tt_msleep (30); /* Set sensor clock. */ outpw (REG_CLKSEL, inpw (REG_CLKSEL) | SENSOR_CLK_FROM_UPLL); //tt_msleep (30); //TURN_ON_DSP_CLOCK; //tt_msleep (30); //TURN_ON_CAP_CLOCK; /* Set MP4 clock. */ //TURN_ON_MPEG4_CLOCK; //tt_msleep (30); /* Set VPE and 2D clock. */ TURN_ON_VPE_CLOCK; tt_msleep (30); TURN_ON_GFX_CLOCK; tt_msleep (30); /* Set USB clock */ #if 0 writew(REG_SYS_CFG, readw(REG_SYS_CFG)&0xffffffbf); outpw (REG_CLKSEL, inpw (REG_CLKSEL) | USB_CLK_FROM_UPLL); tt_msleep (30); TURN_ON_USB_CLOCK; outpw(REG_GPIO_PE,inpw(REG_GPIO_PE)|0x00000200);//GPIO9,disable pull-up or pull-down #endif return 0; }
/* Initialize the cache for read results, using at most the given * number of bytes of memory. If the memory isn't sufficient to * allocate a single node or if the allocation fails, the caching is * disabled. */ void reading_cache_init(int bytes) { tt_init(&ttable, bytes); }
static void verify_tth_reset(filesize_t size) { if G_LIKELY(verify_tth.context != NULL) tt_init(verify_tth.context, size); }
static void verify_tth_reset(filesize_t size) { tt_init(verify_tth.context, size); }