void uart1_init( void ) {
uart_periph_init(&uart1);
uart1.reg_addr = UART1_BASE;
#ifdef USE_UART1_RX_ONLY
// only use the RX1 P0.9 pin, no TX
PINSEL0 = (PINSEL0 & ~U1_PINMASK_RX) | U1_PINSEL_RX;
#else
// set port pins for UART1
PINSEL0 = (PINSEL0 & ~U1_PINMASK) | U1_PINSEL;
#endif
uart_disable_interrupts(&uart1);
uart_set_baudrate(&uart1, UART1_BAUD);
// initialize the interrupt vector
VICIntSelect &= ~VIC_BIT(VIC_UART1); // UART1 selected as IRQ
VICIntEnable = VIC_BIT(VIC_UART1); // UART1 interrupt enabled
_VIC_CNTL(UART1_VIC_SLOT) = VIC_ENABLE | VIC_UART1;
_VIC_ADDR(UART1_VIC_SLOT) = (uint32_t)uart1_ISR; // address of the ISR
// enable receiver interrupts
uart_enable_interrupts(&uart1);
}
void usbuart_init(void)
{
UART_PIN_SETUP();
periph_clock_enable(USBUART_CLK);
__asm__("nop"); __asm__("nop"); __asm__("nop");
uart_disable(USBUART);
/* Setup UART parameters. */
uart_clock_from_sysclk(USBUART);
uart_set_baudrate(USBUART, 38400);
uart_set_databits(USBUART, 8);
uart_set_stopbits(USBUART, 1);
uart_set_parity(USBUART, UART_PARITY_NONE);
// Enable FIFO
uart_enable_fifo(USBUART);
// Set FIFO interrupt trigger levels to 1/8 full for RX buffer and
// 7/8 empty (1/8 full) for TX buffer
uart_set_fifo_trigger_levels(USBUART, UART_FIFO_RX_TRIG_1_8, UART_FIFO_TX_TRIG_7_8);
uart_clear_interrupt_flag(USBUART, UART_INT_RX | UART_INT_RT);
/* Enable interrupts */
uart_enable_interrupts(UART0, UART_INT_RX| UART_INT_RT);
/* Finally enable the USART. */
uart_enable(USBUART);
//nvic_set_priority(USBUSART_IRQ, IRQ_PRI_USBUSART);
nvic_enable_irq(USBUART_IRQ);
}
void uart0_init( void ) {
uart_periph_init(&uart0);
uart0.reg_addr = UART0_BASE;
#ifdef USE_UART0_RX_ONLY
// only use the RX0 P0.1 pin, no TX
PINSEL0 = (PINSEL0 & ~U0_PINMASK_RX) | U0_PINSEL_RX;
#else
// set port pins for UART0
PINSEL0 = (PINSEL0 & ~U0_PINMASK) | U0_PINSEL;
#endif
// initialize uart parameters
uart_disable_interrupts(&uart0);
uart_set_baudrate(&uart0, UART0_BAUD);
// initialize the interrupt vector
VICIntSelect &= ~VIC_BIT(VIC_UART0); // UART0 selected as IRQ
VICIntEnable = VIC_BIT(VIC_UART0); // UART0 interrupt enabled
_VIC_CNTL(UART0_VIC_SLOT) = VIC_ENABLE | VIC_UART0;
_VIC_ADDR(UART0_VIC_SLOT) = (uint32_t)uart0_ISR; // address of the ISR
uart_enable_interrupts(&uart0);
}
/// Set interrupts to a previous state
int chip_uart_int_set(void* device, int state)
{
int rc = chip_uart_int_enabled(device);
if ( state )
uart_enable_interrupts(device);
else
uart_disable_interrupts(device);
return rc;
}
int main(void) {
float v; // Current battery voltage
adc_init(); // time to init?
led_init();
mosfet_init();
uart_init(); // time to init?
uart_enable_interrupts();
// setup
charger_start(); // Charging by default
while (1) {
v = map(adc_read(0), ADC_MIN, ADC_MAX, V_MIN, V_MAX);
if (charging) {
if (v > V_FLT) {
// Stop charging
charger_stop();
}
} else {
if (v <= V_FLT - HYST) {
// Start charging
charger_start();
}
}
if (uart_char_available()) {
unsigned char cmd;
char buf[6];
cmd = uart_getchar();
switch (cmd) {
case 'v':
voltage_to_str(buf, v);
printf("voltage: %s ", buf);
printf(charging ? "(charging)\n" : "(not charging)\n");
break;
}
}
}
return 0;
}
void traceswo_init(void)
{
periph_clock_enable(RCC_GPIOD);
periph_clock_enable(TRACEUART_CLK);
__asm__("nop"); __asm__("nop"); __asm__("nop");
gpio_mode_setup(SWO_PORT, GPIO_MODE_INPUT, GPIO_PUPD_NONE, SWO_PIN);
gpio_set_af(SWO_PORT, 1, SWO_PIN); /* U2RX */
uart_disable(TRACEUART);
/* Setup UART parameters. */
uart_clock_from_sysclk(TRACEUART);
uart_set_baudrate(TRACEUART, 800000);
uart_set_databits(TRACEUART, 8);
uart_set_stopbits(TRACEUART, 1);
uart_set_parity(TRACEUART, UART_PARITY_NONE);
// Enable FIFO
uart_enable_fifo(TRACEUART);
// Set FIFO interrupt trigger levels to 4/8 full for RX buffer and
// 7/8 empty (1/8 full) for TX buffer
uart_set_fifo_trigger_levels(TRACEUART, UART_FIFO_RX_TRIG_1_2, UART_FIFO_TX_TRIG_7_8);
uart_clear_interrupt_flag(TRACEUART, UART_INT_RX | UART_INT_RT);
/* Enable interrupts */
uart_enable_interrupts(TRACEUART, UART_INT_RX | UART_INT_RT);
/* Finally enable the USART. */
uart_enable(TRACEUART);
nvic_set_priority(TRACEUART_IRQ, 0);
nvic_enable_irq(TRACEUART_IRQ);
/* Un-stall USB endpoint */
usbd_ep_stall_set(usbdev, 0x85, 0);
gpio_mode_setup(GPIOD, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO3);
}
void kernel_main(uint32_t r0, uint32_t r1, uint32_t *atags,
uint32_t memory_kernel) {
unsigned int memory_total;
int init_process,idle_process;
struct atag_info_t atag_info;
uint32_t framebuffer_width=800,framebuffer_height=600;
(void) r0; /* Ignore boot method */
/* Initialize Software Structures */
processes_init();
/* Detect Hardware */
atags_detect(atags,&atag_info);
hardware_type=atag_info.hardware_type;
/* Initialize Hardware */
/* Serial console is most important so do that first */
uart_init();
/* Enable Interrupts */
enable_interrupts();
/************************/
/* Boot message! */
/************************/
printk("\r\nBooting VMWos...\r\n");
/**************************/
/* Device Drivers */
/**************************/
/* Set up ACT LED */
led_init();
/* Set up timer */
timer_init();
/* Set up keyboard */
ps2_keyboard_init();
/* Enable the Framebuffer */
if (atag_info.framebuffer_x!=0) {
framebuffer_width=atag_info.framebuffer_x;
}
if (atag_info.framebuffer_y!=0) {
framebuffer_height=atag_info.framebuffer_y;
}
framebuffer_init(framebuffer_width,framebuffer_height,24);
framebuffer_console_init();
/* Delay to allow time for serial port to settle */
/* So we can actually see the output on the terminal */
delay(0x3f0000);
printk("\r\nWaiting for serial port to be ready (press any key)\r\n");
uart_getc();
uart_enable_interrupts();
/* Clear screen */
printk("\n\r\033[2J\n\r\n\r");
/* Print boot message */
printk("\033[0;41m \033[42m \033[44m \033[42m \033[44m \033[0m VMW OS\r\n");
printk(" \033[0;41m \033[42m \033[44m \033[42m \033[44m \033[0m Version 0.%d\r\n\r\n",VERSION);
/* Print hardware version */
printk("Hardware version: %x ",r1);
if (r1==0xc42) printk("(Raspberry Pi)");
else printk("(Unknown Hardware)");
printk("\r\n");
printk("Detected Model ");
switch(hardware_type) {
case RPI_MODEL_A: printk("A"); break;
case RPI_MODEL_APLUS: printk("A+"); break;
case RPI_MODEL_B: printk("B"); break;
case RPI_MODEL_BPLUS: printk("B+"); break;
case RPI_MODEL_B2: printk("B2"); break;
case RPI_COMPUTE_NODE: printk("Compute Node"); break;
default: printk("Unknown %x",hardware_type); break;
}
printk("\r\n");
/* Print ATAGS */
atags_dump(atags);
printk("\r\n");
/* Get amount of RAM from ATAGs */
memory_total=atag_info.ramsize;
/* Init memory subsystem */
memory_init(memory_total,memory_kernel);
/* Init the MMU */
printk("Initializing MMU and caches\r\n");
//enable_mmu(0, memory_total);
//l1_data_cache_clear();
//l1_data_cache_enable();
l1_instruction_cache_enable();
/* Memory Benchmark */
#if 1
{
int i;
uint32_t before,after;
before=ticks_since_boot();
for(i=0;i<16;i++) {
memset(benchmark,0,BENCH_SIZE);
}
after=ticks_since_boot();
printk("MEMSPEED: %d MB took %d ticks %dkB/s\r\n",
16, (after-before),
div32(16*1024,(((after-before)*1000)/64)));
}
#endif
/* Load the idle thread */
idle_process=load_process("idle",PROCESS_FROM_RAM,
(char *)&idle_task,8,4096);
init_process=load_process("shell",PROCESS_FROM_DISK,
NULL,0,8192);
load_process("printa",PROCESS_FROM_DISK,
NULL,0,8192);
load_process("printb",PROCESS_FROM_DISK,
NULL,0,8192);
/* Enter our "init" process*/
printk("\r\nEntering userspace by starting process %d!\r\n",
init_process);
process[idle_process].ready=1;
process[init_process].ready=1;
userspace_started=1;
/* run init and restore stack as we won't return */
run_process(init_process,0x8000);
/* we should never get here */
while(1) {
/* Loop Forever */
/* Should probably execute a wfi instruction */
}
}
void uart_periph_set_baudrate(struct uart_periph* p, uint32_t baud, bool_t hw_flow_control __attribute__ ((unused))) {
uart_disable_interrupts(p);
uart_set_baudrate(p, baud);
uart_enable_interrupts(p);
}
void uart_periph_set_baudrate(struct uart_periph* p, uint32_t baud) {
uart_disable_interrupts(p);
uart_set_baudrate(p, baud);
uart_enable_interrupts(p);
}
void kernel_main(uint32_t r0, uint32_t r1, uint32_t *atags,
uint32_t memory_kernel) {
unsigned int memory_total;
int init_process,idle_process;
struct atag_info_t atag_info;
uint32_t framebuffer_width=800,framebuffer_height=600;
uint32_t temperature;
(void) r0; /* Ignore boot method */
/* Initialize Software Structures */
processes_init();
/* Detect Hardware */
atags_detect(atags,&atag_info);
hardware_type=atag_info.hardware_type;
/* Initialize Hardware */
/* Serial console is most important so do that first */
uart_init();
/* Enable HW random number generator */
bcm2835_rng_init();
/* Enable Interrupts */
enable_interrupts();
/************************/
/* Boot message! */
/************************/
printk("\nBooting VMWos...\n");
/**************************/
/* Device Drivers */
/**************************/
/* Set up ACT LED */
led_init();
/* Set up timer */
timer_init();
/* Set up keyboard */
ps2_keyboard_init();
/* Enable the Framebuffer */
if (atag_info.framebuffer_x!=0) {
framebuffer_width=atag_info.framebuffer_x;
}
if (atag_info.framebuffer_y!=0) {
framebuffer_height=atag_info.framebuffer_y;
}
framebuffer_init(framebuffer_width,framebuffer_height,24);
framebuffer_console_init();
/* Delay to allow time for serial port to settle */
/* So we can actually see the output on the terminal */
delay(0x3f0000);
printk("\nWaiting for serial port to be ready (press any key)\n");
uart_getc();
uart_enable_interrupts();
/* Clear screen */
printk("\n\033[2J\n\n");
/* Print boot message */
printk("\033[0;41m \033[42m \033[44m \033[42m \033[44m \033[0m VMW OS\n");
printk(" \033[0;41m \033[42m \033[44m \033[42m \033[44m \033[0m Version 0.%d\n\n",VERSION);
/* Print hardware version */
printk("Hardware version: %x ",r1);
if (r1==0xc42) printk("(Raspberry Pi)");
else printk("(Unknown Hardware)");
printk("\n");
printk("Detected Model ");
switch(hardware_type) {
case RPI_MODEL_A: printk("A"); break;
case RPI_MODEL_APLUS: printk("A+"); break;
case RPI_MODEL_B: printk("B"); break;
case RPI_MODEL_BPLUS: printk("B+"); break;
case RPI_MODEL_B2: printk("B2"); break;
case RPI_COMPUTE_NODE: printk("Compute Node"); break;
default: printk("Unknown %x",hardware_type); break;
}
printk("\n");
/* Check temperature */
temperature=thermal_read();
printk("CPU Temperature: %dC, %dF\n",
temperature/1000,
((temperature*9)/5000)+32);
/* Print ATAGS */
atags_dump(atags);
printk("\n");
/* Get amount of RAM from ATAGs */
memory_total=atag_info.ramsize;
/* Init memory subsystem */
memory_init(memory_total,memory_kernel);
/* Start HW Perf Counters */
arm1176_init_pmu();
#if 0
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
// printk("Heisenbug!\n");
#endif
/* Setup Memory Hierarchy */
#if 1
memset_benchmark(memory_total);
#else
/* Enable L1 i-cache */
printk("Enabling L1 icache\n");
enable_l1_dcache();
/* Enable branch predictor */
printk("Enabling branch predictor\n");
/* Enable L1 d-cache */
printk("Enabling MMU with 1:1 Virt/Phys page mapping\n");
enable_mmu(0,memory_total);
printk("Enabling L1 dcache\n");
enable_l1_dcache();
#endif
/* Init the file descriptor table */
fd_table_init();
/* Initialize the ramdisk */
ramdisk_init(initrd_image,sizeof(initrd_image));
/* Mount the ramdisk */
mount("/dev/ramdisk","/","romfs",0,NULL);
/* Load the idle thread */
idle_process=load_process("idle",PROCESS_FROM_RAM,
(char *)&idle_task,8,4096);
init_process=load_process("shell",PROCESS_FROM_DISK,
NULL,0,8192);
load_process("printa",PROCESS_FROM_DISK,
NULL,0,8192);
load_process("printb",PROCESS_FROM_DISK,
NULL,0,8192);
/* Enter our "init" process*/
printk("\nEntering userspace by starting process %d!\n",
init_process);
process[idle_process].ready=1;
process[init_process].ready=1;
userspace_started=1;
/* run init and restore stack as we won't return */
run_process(init_process,0x8000);
/* we should never get here */
while(1) {
/* Loop Forever */
/* Should probably execute a wfi instruction */
}
}
