int main(void)
{
//使用CCM内存
kernel_init(0x10000000,0x10000);
kthread_create(init,0,0);
kernel_start();
}
void cmd_boot_linux(void){
//1.从nand flash 0x600000读取内核到内存0x20008000，读取大小0xC00000
//特殊情况：板子的nand flash有坏块
//nand_page_read(test_buf,0);
uart0_puts("\nloading kernel...");
unsigned int *ptr = (unsigned int *)0x20008000;
unsigned int page = 0x600000/NF_PAGE_SIZE;
int i ;
for(i = 0;i < 6000;i++){
uart0_putc('.');
uart0_puts("^_^");
nand_page_read(ptr,page);
ptr += NF_PAGE_SIZE/4;//偏移NF_PAGE_SIZE
page++;//加1页
}
uart0_puts("\nrun linux ...");
//2.调用0x20008000处的程序(函数指针)
func_t kernel_start;
kernel_start = (func_t)0x20008000;
kernel_start(0,2456,0);
//第一个参数0，内核已经不使用了
//第二个参数，当编译内核时为开发板指定的一个号，
//内核启动时会判断引导程序传给内核的参数和编译内核时指定的值是否一样；
//如果一样内核继续执行，如果不一样，内核停止执行；
//第三个参数，引导程序和内核传递参数 的 内存地址；内核根据给定地址找参数；该内存地址是引导和内核共享的内存；
//给0是因为Image是使用默认参数的，不需要引导程序传递；
//uart0_puts("\nkernel run end");
}
static int setupEMBXAndOS()
{
EMBX_FACTORY hFact;
EMBX_TRANSPORT hTrans;
EMBX_PORT masterPort;
int status = 0;
/*
* Start OS21
*/
kernel_initialize(NULL);
kernel_start();
kernel_timeslice(OS21_TRUE);
if(init_mailboxes() < 0) {
printf("Failed to initialize mailboxes\n");
status = 1;
goto exit;
}
if(init_comms(&hFact,&hTrans,&masterPort) < 0) {
printf("Failed to initialize embx comms\n");
status = 1;
}
exit:
return status;
}
int main(void)
{
lib_low_level_init();
lib_os_init();
create_thread(main_thread, main_thread_stack, sizeof(main_thread_stack), PRIORITY_MAX);
kernel_start();
return 0;
}
int
main (void)
{
// Configire LEDS
pio_config_set (LED0_PIO, PIO_OUTPUT_HIGH);
pio_config_set (LED1_PIO, PIO_OUTPUT_HIGH);
pio_config_set (LED2_PIO, PIO_OUTPUT_HIGH);
pio_config_set (LED3_PIO, PIO_OUTPUT_HIGH);
i2c_slave1 = i2c_slave_init (&i2c_bus_cfg, &i2c_slave1_cfg); // Initialise as I2C slave
extint1 = extint_init (&extint1_cfg); // Initialise I2C Interrupt
// Initialise comms_data
uint8_t cd_photo_ready = 0;
uint8_t cd_fault = 0;
comms_data[CD_PHOTO_READY-ARRAY_OFFSET] = &cd_photo_ready;
comms_data[CD_PHOTO_NEXT_LINE-ARRAY_OFFSET] = image;
comms_data[CD_FAULT-ARRAY_OFFSET] = &cd_fault;
extint_enable (extint1); // Enable I2C Interrupt
tcm8230_init (&cfg); // Initialise Camera
kernel_init (); // Initialise Kernel
// Register Tasks for kernel
kernel_taskRegister (command_task, COMMAND_TASK, &comms_data, 200);
kernel_taskRegister (capture_task, CAPTURE_TASK, 0, 500);
kernel_taskRegister (photo_ready_flash_task, PHOTO_READY_FLASH_TASK, 0, 200);
// Block any currently uneeded task
kernelTaskBlocked (CAPTURE_TASK);
kernelTaskBlocked (PHOTO_READY_FLASH_TASK);
// Finally start the kernel, no code beyone here will be run
kernel_start ();
return 0;
}
int main(int argc, char **argv)
{
stm_display_plane_t *pPlane;
stm_display_buffer_t buffer_setup;
char *fbuffer;
void *fbufferphys;
interrupt_t *vsync_interrupt=0;
interrupt_t *hdmi_interrupt=0;
int err;
int seconds;
int clip;
int rgb;
int dvi;
stm_plane_id_t planeid;
osclock_t lasttime;
kernel_initialize(NULL);
kernel_start();
kernel_timeslice(OS21_TRUE);
framerate_sem = semaphore_create_fifo(0);
frameupdate_sem = semaphore_create_fifo(0);
hotplug_sem = semaphore_create_fifo(0);
task_create(displayupdate_task_fn, 0, OS21_DEF_MIN_STACK_SIZE, MAX_USER_PRIORITY, "displayupdate", 0);
pDev = stm_display_get_device(0);
if(!pDev)
{
printf("Unable to create device instance\n");
return 1;
}
if(argc<2)
usage();
argc--;
argv++;
seconds = 60;
rgb = 0;
dvi = 0;
clip = 0;
while(argc>0)
{
switch(**argv)
{
case 'C':
{
printf("Clipping video signal selected\n");
clip = 1;
break;
}
case 'd':
{
printf("Setting DVI mode on HDMI output\n");
dvi = 1;
break;
}
case 'h':
{
int refresh;
argc--;
argv++;
if(argc <= 0)
{
fprintf(stderr,"Missing HD vertical refresh frequency\n");
usage();
}
refresh = atoi(*argv);
switch(refresh)
{
case 50:
printf("Setting 1280x720-50\n");
MODE = STVTG_TIMING_MODE_720P50000_74250;
STANDARD = STM_OUTPUT_STD_SMPTE296M;
framerate = 50;
break;
case 59:
printf("Setting 1280x720-59\n");
MODE = STVTG_TIMING_MODE_720P59940_74176;
STANDARD = STM_OUTPUT_STD_SMPTE296M;
framerate = 60;
break;
case 60:
printf("Setting 1280x720-60\n");
MODE = STVTG_TIMING_MODE_720P60000_74250;
STANDARD = STM_OUTPUT_STD_SMPTE296M;
framerate = 60;
break;
default:
fprintf(stderr,"Unsupported HD vertical refresh frequency\n");
usage();
}
break;
}
case 'r':
{
printf("Setting Component RGB Outputs\n");
rgb = 1;
break;
}
case 'p':
{
int refresh;
argc--;
argv++;
if(argc <= 0)
{
fprintf(stderr,"Missing 1080p vertical refresh frequency\n");
usage();
}
refresh = atoi(*argv);
switch(refresh)
{
case 23:
printf("Setting 1920x1080-23\n");
MODE = STVTG_TIMING_MODE_1080P23976_74176;
STANDARD = STM_OUTPUT_STD_SMPTE274M;
framerate = 24;
break;
case 24:
printf("Setting 1920x1080-24\n");
MODE = STVTG_TIMING_MODE_1080P24000_74250;
STANDARD = STM_OUTPUT_STD_SMPTE274M;
framerate = 24;
break;
case 25:
printf("Setting 1920x1080-25\n");
MODE = STVTG_TIMING_MODE_1080P25000_74250;
STANDARD = STM_OUTPUT_STD_SMPTE274M;
framerate = 25;
break;
case 29:
printf("Setting 1920x1080-29\n");
MODE = STVTG_TIMING_MODE_1080P29970_74176;
STANDARD = STM_OUTPUT_STD_SMPTE274M;
framerate = 30;
break;
case 30:
printf("Setting 1920x1080-30\n");
MODE = STVTG_TIMING_MODE_1080P30000_74250;
STANDARD = STM_OUTPUT_STD_SMPTE274M;
framerate = 30;
break;
case 50:
printf("Setting 1920x1080-50\n");
MODE = STVTG_TIMING_MODE_1080P50000_148500;
STANDARD = STM_OUTPUT_STD_SMPTE274M;
framerate = 50;
break;
case 59:
printf("Setting 1920x1080-59\n");
MODE = STVTG_TIMING_MODE_1080P59940_148352;
STANDARD = STM_OUTPUT_STD_SMPTE274M;
framerate = 60;
break;
case 60:
printf("Setting 1920x1080-60\n");
MODE = STVTG_TIMING_MODE_1080P60000_148500;
STANDARD = STM_OUTPUT_STD_SMPTE274M;
framerate = 60;
break;
default:
fprintf(stderr,"Unsupported HD vertical refresh frequency\n");
usage();
}
break;
}
case 's':
{
int refresh;
argc--;
argv++;
if(argc <= 0)
{
fprintf(stderr,"Missing SD vertical refresh frequency\n");
usage();
}
refresh = atoi(*argv);
switch(refresh)
{
case 50:
printf("Setting 720x576-50\n");
MODE = STVTG_TIMING_MODE_576P50000_27000;
STANDARD = STM_OUTPUT_STD_SMPTE293M;
framerate = 50;
break;
case 59:
printf("Setting 720x480-59\n");
MODE = STVTG_TIMING_MODE_480P59940_27000;
STANDARD = STM_OUTPUT_STD_SMPTE293M;
framerate = 60;
break;
case 60:
printf("Setting 720x480-60\n");
MODE = STVTG_TIMING_MODE_480P60000_27027;
STANDARD = STM_OUTPUT_STD_SMPTE293M;
framerate = 60;
break;
default:
fprintf(stderr,"Unsupported SD vertical refresh frequency\n");
usage();
}
break;
}
case 't':
{
argc--;
argv++;
if(argc <= 0)
{
fprintf(stderr,"Missing seconds\n");
usage();
}
seconds = atoi(*argv);
if(seconds<0)
usage();
break;
}
case 'v':
{
int refresh;
argc--;
argv++;
if(argc <= 0)
{
fprintf(stderr,"Missing vertical refresh frequency\n");
usage();
}
refresh = atoi(*argv);
switch(refresh)
{
case 59:
printf("Setting 640x480-59\n");
MODE = STVTG_TIMING_MODE_480P59940_25180;
STANDARD = STM_OUTPUT_STD_VESA;
framerate = 60;
break;
case 60:
printf("Setting 640x480-60\n");
MODE = STVTG_TIMING_MODE_480P60000_25200;
STANDARD = STM_OUTPUT_STD_VESA;
framerate = 60;
break;
default:
fprintf(stderr,"Unsupported vertical refresh frequency\n");
usage();
}
break;
}
default:
fprintf(stderr,"Unknown option '%s'\n",*argv);
usage();
}
argc--;
argv++;
}
planeid = OUTPUT_GDP1;
vsync_interrupt = get_main_vtg_interrupt();
setup_soc();
if(!vsync_interrupt)
{
printf("Cannot find VSYNC interrupt handler\n");
return 1;
}
err = interrupt_install(vsync_interrupt, vsync_isr, pDev);
err += interrupt_enable(vsync_interrupt);
if(err>0)
{
printf("Unable to install and enable VSYNC interrupt\n");
return 1;
}
fbuffer = (char *)malloc(FBSIZE);
if(!fbuffer)
{
printf("Unable to allocate framebuffer\n");
return 1;
}
memset(fbuffer, 0x00, FBSIZE);
create_test_pattern(fbuffer, FBWIDTH, FBHEIGHT, FBSTRIDE);
cache_purge_data(fbuffer, FBSIZE);
pOutput = stm_display_get_output(pDev, 0);
if(!pOutput)
{
printf("Unable to get output\n");
return 1;
}
setup_analogue_voltages(pOutput);
stm_display_output_set_control(pOutput, STM_CTRL_SIGNAL_RANGE, clip?STM_SIGNAL_VIDEO_RANGE:STM_SIGNAL_FILTER_SAV_EAV);
pDVO = get_dvo_output(pDev);
{
pHDMI = get_hdmi_output(pDev);
if(pHDMI)
{
/*
* Now we have a HDMI output pointer to handle hotplug interrupts,
* we can enable the interrupt handlers.
*/
hdmi_interrupt = get_hdmi_interrupt();
if(hdmi_interrupt)
{
err = interrupt_install(hdmi_interrupt, hdmi_isr, pHDMI);
err += interrupt_enable(hdmi_interrupt);
}
if(err>0)
{
printf("Unable to install and enable hdmi interrupts\n");
return 1;
}
stm_display_output_set_control(pHDMI, STM_CTRL_SIGNAL_RANGE, clip?STM_SIGNAL_VIDEO_RANGE:STM_SIGNAL_FILTER_SAV_EAV);
}
else
{
printf("Hmmm, no HDMI output available\n");
}
}
pModeLine = stm_display_output_get_display_mode(pOutput, MODE);
if(!pModeLine)
{
printf("Unable to use requested display mode\n");
return 1;
}
pPlane = stm_display_get_plane(pDev, planeid);
if(!pPlane)
{
printf("Unable to get graphics plane\n");
return 1;
}
if(stm_display_plane_connect_to_output(pPlane, pOutput)<0)
{
printf("Unable to display plane on output\n");
return 1;
}
if(stm_display_plane_lock(pPlane)<0)
{
printf("Unable to lock plane's buffer queue\n");
return 1;
}
memset(&buffer_setup, 0, sizeof(buffer_setup));
vmem_virt_to_phys(fbuffer, &fbufferphys);
buffer_setup.src.ulVideoBufferAddr = (ULONG)fbufferphys;
buffer_setup.src.ulVideoBufferSize = FBSIZE;
buffer_setup.src.ulStride = FBSTRIDE;
buffer_setup.src.ulPixelDepth = FBDEPTH;
buffer_setup.src.ulColorFmt = FBPIXFMT;
buffer_setup.src.Rect.width = FBWIDTH;
buffer_setup.src.Rect.height = FBHEIGHT;
buffer_setup.dst.Rect.width = FBWIDTH;
buffer_setup.dst.Rect.height = FBHEIGHT;
buffer_setup.info.ulFlags = STM_PLANE_PRESENTATION_PERSISTENT;
printf("Clock is running at %ld ticks per second\n",(long)time_ticks_per_sec());
ULONG format=0;
format = rgb?STM_VIDEO_OUT_RGB:STM_VIDEO_OUT_YUV;
stm_display_output_set_control(pOutput, STM_CTRL_VIDEO_OUT_SELECT, format);
if(pHDMI)
{
ULONG format = 0;
format |= rgb?STM_VIDEO_OUT_RGB:STM_VIDEO_OUT_YUV;
format |= dvi?STM_VIDEO_OUT_DVI:STM_VIDEO_OUT_HDMI;
stm_display_output_set_control(pHDMI, STM_CTRL_VIDEO_OUT_SELECT, format);
}
if(stm_display_output_start(pOutput, pModeLine, STANDARD)<0)
{
printf("Unable to start display\n");
return 1;
}
if(pDVO)
{
printf("Info: Attempting to start DVO\n");
if(stm_display_output_start(pDVO, pModeLine, STANDARD)<0)
{
printf("Info: Unable to start DVO\n");
}
}
lasttime = time_now(); // VTG Start time (approx)
if(stm_display_plane_queue_buffer(pPlane, &buffer_setup)<0)
{
printf("Unable to queue framebuffer for display on graphics plane\n");
return 1;
}
task_create(hotplug_task_fn, 0, OS21_DEF_MIN_STACK_SIZE, MIN_USER_PRIORITY, "hotplug", 0);
if(seconds == 0)
{
task_delay(time_ticks_per_sec()*5);
task_priority_set(NULL,MIN_USER_PRIORITY);
silent_hotplug = 1;
err = get_yesno();
}
else
{
while(seconds>0)
{
osclock_t now,delta;
semaphore_wait(framerate_sem);
now = time_now();
delta = time_minus(now,lasttime);
printf("%d frames took %ld ticks.\n",framerate, (long)delta);
lasttime = now;
seconds--;
}
err = 0;
}
stm_display_plane_flush(pPlane);
stm_display_plane_disconnect_from_output(pPlane, pOutput);
stm_display_output_stop(pOutput);
interrupt_disable(vsync_interrupt);
interrupt_disable(hdmi_interrupt);
stm_display_plane_release(pPlane);
if(pDVO)
stm_display_output_release(pDVO);
if(pHDMI)
stm_display_output_release(pHDMI);
stm_display_output_release(pOutput);
stm_display_release_device(pDev);
return err;
}
int main(void (*sr_read)(unsigned int start_sector,
char *buffer, int num_sectors),
void (*ser_puts)(const char *buffer))
{
char *dst = (char *)LINUX_LOADADDR;
const struct mbr_part *part;
unsigned found = 0;
unsigned int i;
BUILD_BUG_ON(sizeof(struct mbr_part) != 16);
BUILD_BUG_ON(sizeof(struct mbr) != SECT_SIZE);
if (mbr->sig != MBR_SIG) {
ser_puts("S");
die();
}
for (i = 0; i < NUM_PE; i++) {
part = &mbr->pe[i];
/* First partition is Linux */
if (part->type != PART_TYPE_OTHER_DATA) {
ser_puts("P");
continue;
}
ser_puts("L");
sr_read(part->lba, dst, part->num_sects);
ser_puts(".\r\n");
found = 1;
break;
}
if (!found) {
dbg_str("N");
die();
}
/* Prepare ATAGS */
atags->hdr.tag = ATAG_CORE;
atags->hdr.size = atag_size(atag_core);
atags->u.core.flags = 1;
atags->u.core.pagesize = 4096;
atags->u.core.rootdev = 0;
atags = atag_next(atags);
#if (SDRAM_SIZE_MB > 32)
#error "Need to add additional ATAG_MEM for second bank!"
#endif
atags->hdr.tag = ATAG_MEM;
atags->hdr.size = atag_size(atag_mem);
atags->u.mem.start = 0;
atags->u.mem.size = 8 << 20;
atags = atag_next(atags);
atags->hdr.tag = ATAG_MEM;
atags->hdr.size = atag_size(atag_mem);
atags->u.mem.start = 0x1000000;
atags->u.mem.size = 8 << 20;
atags = atag_next(atags);
atags->hdr.tag = ATAG_MEM;
atags->hdr.size = atag_size(atag_mem);
atags->u.mem.start = 0x4000000;
atags->u.mem.size = 8 << 20;
atags = atag_next(atags);
atags->hdr.tag = ATAG_MEM;
atags->hdr.size = atag_size(atag_mem);
atags->u.mem.start = 0x5000000;
atags->u.mem.size = 8 << 20;
atags = atag_next(atags);
atags->hdr.tag = ATAG_NONE;
atags->hdr.size = 0;
/* Start kernel, bye! */
ser_puts("G\r\n");
void (*kernel_start)(int, int, uint32_t) = (void *)LINUX_LOADADDR;
kernel_start(0, TS72XX_MACH_NUM, ATAGS_OFFSET);
return 0;
}
int
main ()
{
pio_config_set (LED_GREEN_PIO, PIO_OUTPUT_HIGH);
pio_config_set (LED_ORANGE_PIO, PIO_OUTPUT_HIGH);
pio_config_set (LED_RED_PIO, PIO_OUTPUT_HIGH);
pio_config_set (LED_BLUE_PIO, PIO_OUTPUT_HIGH);
/* Initialise i2c */
i2c_motor = i2c_master_init (&i2c_bus_cfg, &i2c_motor_cfg);
i2c_camera = i2c_master_init (&i2c_bus_cfg, &i2c_camera_cfg);
/* Initialise bluetooth */
bluetooth_t btconn = bluetooth_init(115200);
kernel_init ();
kernel_taskRegister (bluetooth_comms_task, BLUETOOTH_COMMS_TASK, btconn, 10);
kernel_taskRegister (action_commands_task, ACTION_COMMANDS_TASK, btconn, 100);
kernel_start ();
return 0;
}
