Category: Uncategorized

WFI and timer change

Leave a comment

Before implementing context switch, I wanted to improve interrupt handling and better timer.
I was using busy loop to check messages from interrupt. First, I used WFI ARM instruction to wait (sleep) until interrupted.

startup.s:
.global _wfi
_wfi:
  wfi
  bx lr

hoge.c:
while (true) {
  _disable_IRQ();
  _wfi();
  if (StatusFifo8(&fifoTimer) == 0) {
    _enable_IRQ();
  } else {
    unsigned char data = GetFifo8(&fifoTimer);
    _enable_IRQ();
...

And I used FIFO8 used in Haribote OS (32bit tiny OS for x86).

Then quickly wrote dirty timer handling which supports up to MAX_TIMER (currently 512). It’s not using a list but an array and not efficient -> TODO.

#define MAX_TIMER 512
typedef struct _TIMER {
  unsigned int timeout;
  unsigned char data;
} TIMER;

typedef struct _TIMERCTL {
  unsigned int counter, next;
  unsigned int length;  // number of used timers
  FIFO8 *fifo;
  TIMER timer[MAX_TIMER];
} TIMERCTL;

extern TIMERCTL timerctl;

void InitTimer(FIFO8 *fifo);
TIMER *SetTimer(TIMER *timer, unsigned int timeout, unsigned char data);

One more improvement. I bought a USB power cable with a switch! I don’t need to plug-in/out to reboot my code anymore 🙂

Today’s code -> https://github.com/sokoide/rpi-baremetal -> 007_wfi.

USB power cable with switch.
usbcable

3 timers whose intervals are 100ms, 500ms and 1s each.
timer2

Frames per second

Leave a comment

Changed to display FPS using yesterday’s timer interrupt.
When I tested, it was 120 FPS @ 640×480, 16-17 FPS @ 1920 x 1080 just to fill whole display with a solid color.
Then I added FillRect() and it decreased to 95 FPS @ 640×480 with 3 rectangles.

It’ll be a bit better if I add 8×8 between 32×32 and 1×1, but I didn’t do that today. Even with that, it looks this pixel by pixel draw is too slow if I add more objects. Perhaps I should do block-copy of tiles and sprites.

void FillRect(int x, int y, int width, int height, char color) {
  // left ... draw pixel by pixel
  int x1 = x;
  int x2 = ((x + 31) / 32) * 32;
  if (x1 != x2) {
    char *p8 = (char *)fbRequest.fbBaseAddress;
    p8 += y * kWidth + x1;
    for (int yy = y; yy < y + height; yy++) {
      for (int xx = x1; xx < x2; xx++) {
        *p8++ = color;
      }
      p8 += kWidth - (x2 - x1);
    }
  }

  // center draw 32 pixels at once
  int x3 = ((x + width) / 32) * 32;
  if (x2 != x3) {
    uint32_t *p = (uint32_t *)fbRequest.fbBaseAddress;
    p += (y * kWidth + x2) / 4;
    for (int yy = y; yy < y + height; yy++) {
      for (int xx = x2; xx < x3; xx += 4 * 8) {
        int32_t c = color << 24 | color << 16 | color << 8 | color;
        *p++ = c;
        *p++ = c;
        *p++ = c;
        *p++ = c;
        *p++ = c;
        *p++ = c;
        *p++ = c;
        *p++ = c;
      }
      p += (kWidth - (x3 - x2)) / 4;
    }
  }

  // right ... draw pixel by pixel
  int x4 = x + width;
  if (x3 != x4) {
    char *p8 = (char *)fbRequest.fbBaseAddress;
    p8 += y * kWidth + x3;
    for (int yy = y; yy < y + height; yy++) {
      for (int xx = x3; xx < x4; xx++) {
        *p8++ = color;
      }
      p8 += kWidth - (x4 - x3);
    }
  }
}

Today's code: https://github.com/sokoide/rpi-baremetal -> 006_fps.

fps

Print string

Leave a comment

I drew a string using hankaku.bin 8×16 font provided by the X86 OS book.
First, I converted the 4096 byte bin file into elf format.

hankaku.o: hankaku.bin                                                                                     
  $(OBJCOPY) -I binary -O elf32-littlearm -B arm $< $@

when you convert that way, you can refer to the address in .data section by _hankaku_bin_obj_start as below.

void printstr(int x, int y, char *str, char color) {
  size_t len = strlen(str);
  for (int i = 0; i < len; i++) {
    char c = str[i];
    myputchar(x + i * 8, y, c, color);
  }
}

void myputchar(int x, int y, char c, char color) {
  char *hankaku = (char *)&_binary_hankaku_bin_start;
  char *base = (char *)fbRequest.fbBaseAddress;
  char *p;
  char d;

  for (int i = 0; i < 16; i++) {
    p = base + (y + i) * kWidth + x;
    d = hankaku[c * 16 + i];
...

And it's displayed by this!

  printstr(10, 0, "HOG", 7);
  printstr(10 + 8 * 3, 0, "E", 1);

Today's code: https://github.com/sokoide/rpi-baremetal -> 005_character.

hoge

Timer interrupt

Leave a comment

Implemented timer. First, it needs interrupt vector table at address 0x00000000.
The following (not optimized my first) arm code “_init_vector_table” copies _initialize_vector_start to _initialize_vector_end to 0x00000000.

First, I tried to copy that in C, but uint32_t* vector_table; *vector_table=… was not compiled as I expected by cross gcc 4.9 perhaps because 0 is NULL in C and *NULL is illegal.

.global  _initialize_vector_start
_initialize_vector_start:
        ldr     pc, _vec_Reset
        ldr     pc, _vec_Undef
        ldr     pc, _vec_SWI
        ldr     pc, _vec_PrefAbort
        ldr     pc, _vec_DataAbort
        ldr     pc, _vec_Reserved
        ldr     pc, _vec_IRQ
        ldr     pc, _vec_FIQ
_vec_Reset:             .word   _start
_vec_Undef:             .word   _hangup
_vec_SWI:               .word   _hangup
_vec_PrefAbort: .word   _hangup
_vec_DataAbort: .word   _hangup
_vec_Reserved:  .word   _hangup
_vec_IRQ:               .word   _IRQ_iterrupt
_vec_FIQ:               .word   _hangup
        .global  _initialize_vector_end
_initialize_vector_end:
# dummy instruction to keep initialize_vector_end label
        mov r0,r0

.global _init_vector_table
_init_vector_table:
  ldr r0, =0x0
  ldr r1, =_initialize_vector_start
  ldr r3, =_initialize_vector_end
  cmp r1, r3
  bxeq lr
  _init_vector_table_loop:
  ldr r2, [r1]
  str r2, [r0]
  add r1, #4
  add r0, #4
  cmp r1, r3
  bne _init_vector_table_loop
  bx lr

Then, _IRQ_iterrupt calls C function IRQ_handler.

_IRQ_iterrupt:
	stmfd	r13!, {r0-r12,lr}
	bl	IRQ_handler
	ldmfd	r13!, {r0-r12,lr}
	subs	pc,lr, #4

IRQ_handler sets g_interrupt flag.

volatile static bool g_interrupt = false;

// called by _IRQ_interrupt in startup.s
void IRQ_handler(void) {
  // disable IRQ
  _disable_IRQ();

  if (*INTERRUPT_IRQ_BASIC_PENDING & 0x01 != 0) {
    // Timer interrupt handler
    g_interrupt = true;
    // clear interrupt flag
    *TIMER_IRQ_CLR = 0;
  }

  // enable IRQ
  _enable_IRQ();
}

Then dirty main loop is checking the flag. I’ll change it to wait for interrupt like another x86 OS is doing.

  while (true) {
    _disable_IRQ();
    if (true == g_interrupt) {
      g_interrupt = false;
      _enable_IRQ();
      redraw();
    } else {
      _enable_IRQ();
    }
  }

Today’s code: https://github.com/sokoide/rpi-baremetal -> 004_timer_interrupt.

Draw pixels

Leave a comment

Got VRAM frame buffer address from Video Core via MailBox protocol and drew 1920×1080 pixels. I found it’s very slow ~3-5 fps.
Then I changed it to 640×480 which made it faster but not 60fps.
I’ll need to initialize interrupts & use timer and add fonts to show FPS tomorrrow.

Buffer address specified by MailBox’s property-tag protocol should be 16 byte aligned since the least 4 bits are used to specify tag (7 for ARM to VC, 8 for VC to ARM) like this.

struct FramebufferRequest {
  uint32_t size;
  uint32_t bufferRequestResponseCode;

  // Set_Physical_Display
  uint32_t tag_setPd;
  uint32_t size_setPd;
  uint32_t rr_setPd;
  uint32_t width_setPd;
  uint32_t height_setPd;
...
} fbRequest __attribute__((aligned(16)));

Today’s code: https://github.com/sokoide/rpi-baremetal -> 003_screen.

vga

Implementing syscalls for libc

Leave a comment

If you try to use C-library functions such as malloc() or printf(), link fails with these since they depends on these system calls.

/home/sokoide/cross/rpi/arm-unknown-eabi/arm-unknown-eabi/lib//libc.a(lib_a-sbrkr.o): In function `_sbrk_r':
sbrkr.c:(.text+0x18): undefined reference to `_sbrk'
/home/sokoide/cross/rpi/arm-unknown-eabi/arm-unknown-eabi/lib//libc.a(lib_a-writer.o): In function `_write_r':
writer.c:(.text+0x20): undefined reference to `_write'
/home/sokoide/cross/rpi/arm-unknown-eabi/arm-unknown-eabi/lib//libc.a(lib_a-closer.o): In function `_close_r':
closer.c:(.text+0x18): undefined reference to `_close'
/home/sokoide/cross/rpi/arm-unknown-eabi/arm-unknown-eabi/lib//libc.a(lib_a-fstatr.o): In function `_fstat_r':
fstatr.c:(.text+0x1c): undefined reference to `_fstat'
/home/sokoide/cross/rpi/arm-unknown-eabi/arm-unknown-eabi/lib//libc.a(lib_a-isattyr.o): In function `_isatty_r':
isattyr.c:(.text+0x18): undefined reference to `_isatty'
/home/sokoide/cross/rpi/arm-unknown-eabi/arm-unknown-eabi/lib//libc.a(lib_a-lseekr.o): In function `_lseek_r':
lseekr.c:(.text+0x20): undefined reference to `_lseek'
/home/sokoide/cross/rpi/arm-unknown-eabi/arm-unknown-eabi/lib//libc.a(lib_a-readr.o): In function `_read_r':
readr.c:(.text+0x20): undefined reference to `_read'

We can’t use OS’s syscalls obviously since there is no OS. The book suggested to implement it by reffering to ~/cross/src/ct-ng_rpi/.build/src/newlib-1.20.0/newlib/libc/sys/arm/syscalls.c.

I implemented a stub and wrote _write as below. Since there is no stdout yet, I only copied it in memory and confirmed it in gdb + arm sim.

_write in syscalls.c:

int _write(int file, char *ptr, int len) {
  // TODO:
  for (int i = 0; i < len; i++) {
    _write_memory(ptr[i]);
  }
  return len;
}

_writememory in startup.s: only to confirm it's called with a right character

_write_memory:
  bx  lr

confirmation: tried to confirm with arm sim on gdb, and got this. It looks it's not implemented in arm sim.

(gdb) target sim
Connected to the simulator.
(gdb) load hoge.elf
Loading section .text, size 0x8cf0 vma 0x8000
Loading section .rodata, size 0xa48 vma 0x10cf0
Loading section .rodata.str1.4, size 0xc vma 0x11738
Loading section .rodata.str1.1, size 0x4b vma 0x11744
Loading section .ARM.exidx, size 0x8 vma 0x11790
Start address 0x8000
Transfer rate: 310456 bits in <1 sec.
(gdb) file hoge.elf
Reading symbols from hoge.elf...done.
(gdb) b _write_memory
Breakpoint 1 at 0x8020
(gdb) start
Temporary breakpoint 2 at 0x808c
Starting program: /media/psf/Dropbox/workspace/arm/rpi-baremetal/002/hoge.elf 

Temporary breakpoint 2, 0x0000808c in main ()
(gdb) c
Continuing.
Unhandled v6 thumb insn: 4601
[Inferior 1 (process 42000) exited with code 0215]

Uploaded above at https://github.com/sokoide/rpi-baremetal -> 002_libcstub.

First RPi2 bare metal code

Leave a comment

First bare metal code for Raspberry Pi2 hardware uploaded at https://github.com/sokoide/rpi-baremetal/tree/master/001_led.
Used http://www.valvers.com/open-software/raspberry-pi/step02-bare-metal-programming-in-c-pt2/ for GPIO port definition for RPi2 and http://tatsu-zine.com/books/raspi-bm for section def & boot startup code.

When the hardware starts up, it halts CPU and starts GPU which loads bootloader from ROM which loads bootcode.bin which reads config.txt. Start.elf loads the boot image file written in config.txt at 0x00008000 and runs it.
When you build it, you’ll get hoge.img which is loaded and executed by start.elf during boot and see a blinking green LED at fast, regular, slow, regular, fast… paces.

Here is my first bare metal code which is only 480 bytes.

hoge.lds:

OUTPUT_ARCH(arm)
ENTRY(_start)
SECTIONS
{
	. = 0x8000;

	.text : { *(.text*) }
	. = ALIGN(4);

	__rodata_start = .;
	.rodata : { *(.data*) }
	. = ALIGN(4);
	__rodata_end = .;

	__data_start = . ;
	.data : { *(.data*) }
	. = ALIGN(4);
	__data_end = . ;

	__bss_start = . ;
	.bss : { *(.bss*) }
	. = ALIGN(4);
	__bss_end = . ;
}

startup.s: in supervisor mode (d3), using 1MB stack at 0x06400000 although I don’t need that much.

@ startup
  .global _start
  .align

_start:
  ldr r0, =0x000000d3
  msr cpsr, r0
  ldr sp, =0x06400000
  bl main
  b .

hoge.c:

#include "lib/rpi.h"
#define kFastInterval 200000
#define kRegularInterval 500000
#define kSlowInterval 1000000

volatile unsigned int* gpio = (unsigned int*)GPIO_BASE;
volatile unsigned int tim;

void wait(unsigned int interval);

void wait(unsigned int interval) {
  for (tim = 0; tim < interval; tim++)
    ;
}

void led_on() {
  /* Set the LED GPIO pin high ( Turn OK LED off for original Pi, and on
     for plus models )*/
  gpio[LED_GPSET] = (1 << LED_GPIO_BIT);
}

void led_off() {
  /* Set the LED GPIO pin low ( Turn OK LED on for original Pi, and off
     for plus models )*/
  gpio[LED_GPCLR] = (1 << LED_GPIO_BIT);
}

int main(int argc, char const* argv[]) {
  rpiInit();

  gpio[LED_GPFSEL] |= (1 << LED_GPFBIT);

  unsigned int intervals[] = {kFastInterval, kRegularInterval, kSlowInterval,
                              kRegularInterval};
  while (1) {
    for (int i = 0; i < sizeof(intervals) / sizeof(intervals[0]); i++) {
      unsigned int interval = intervals[i];
      {
        for (int j = 0; j < 3; j++) {
          wait(interval);
          led_on();
          wait(interval);
          led_off();
        }
      }
    }
  }

  return 0;
}

Self and cross development environment for Raspberry Pi2

Leave a comment

I bought Rapberry Pi2 and set up self and cross development environment.

1. Self dev env on Raspberry pi
Installed gcc/g++ 4. Used pre-installed gdb ver 7.4 for ARM.

src: main.s

/* main.s */
/* data section */
.data
.balign 4
myvar1:
  .word 3

.balign 4
myvar2:
  .word 4

.balign 4
myvar3:
  .word 0

/* text section */
.text
.balign 4
.global main
.func   main

main:
  ldr r1, addr_of_myvar1
  ldr r1, [r1]
  ldr r2, addr_of_myvar2
  ldr r2, [r2]
  add r2, r1, r2
  ldr r3, addr_of_myvar3
  /* store value of r2 -> address of r3 */
  str r2, [r3]
  /* load [r3] into r0 */
  ldr r0, addr_of_myvar3
  ldr r0, [r0]
  bx lr

gdb test. confirmed r1/r2 are loaded from .data section and added. Return value 7 was successfully returned.

(gdb) start
Temporary breakpoint 1 at 0x8418
Starting program: /home/pi/workspace/asm/tutorial/003/hoge

Temporary breakpoint 1, 0x00008418 in main ()
(gdb) disass
Dump of assembler code for function main:
=> 0x00008418 <+0>:	ldr	r1, [pc, #32]	; 0x8440 
   0x0000841c <+4>:	ldr	r1, [r1]
   0x00008420 <+8>:	ldr	r2, [pc, #28]	; 0x8444 
   0x00008424 <+12>:	ldr	r2, [r2]
   0x00008428 <+16>:	add	r2, r1, r2
   0x0000842c <+20>:	ldr	r3, [pc, #20]	; 0x8448 
   0x00008430 <+24>:	str	r2, [r3]
   0x00008434 <+28>:	ldr	r0, [pc, #12]	; 0x8448 
   0x00008438 <+32>:	ldr	r0, [r0]
   0x0000843c <+36>:	bx	lr
End of assembler dump.
(gdb) si
0x0000841c in main ()
(gdb) si
0x00008420 in main ()
(gdb) info r
r0             0x1	1
r1             0x3	3
r2             0x7efff79c	2130704284
r3             0x8418	33816
r4             0x0	0
r5             0x0	0
r6             0x82e4	33508
r7             0x0	0
r8             0x0	0
r9             0x0	0
r10            0x76fff000	1996484608
r11            0x0	0
r12            0x76fb9000	1996197888
sp             0x7efff648	0x7efff648
lr             0x76ea481c	1995065372
pc             0x8420	0x8420 
cpsr           0x60000010	1610612752
(gdb) si
0x00008424 in main ()
(gdb) si
0x00008428 in main ()
(gdb) si
0x0000842c in main ()
(gdb) disass
Dump of assembler code for function main:
   0x00008418 <+0>:	ldr	r1, [pc, #32]	; 0x8440 
   0x0000841c <+4>:	ldr	r1, [r1]
   0x00008420 <+8>:	ldr	r2, [pc, #28]	; 0x8444 
   0x00008424 <+12>:	ldr	r2, [r2]
   0x00008428 <+16>:	add	r2, r1, r2
=> 0x0000842c <+20>:	ldr	r3, [pc, #20]	; 0x8448 
   0x00008430 <+24>:	str	r2, [r3]
   0x00008434 <+28>:	ldr	r0, [pc, #12]	; 0x8448 
   0x00008438 <+32>:	ldr	r0, [r0]
   0x0000843c <+36>:	bx	lr
End of assembler dump.
(gdb) info r
r0             0x1	1
r1             0x3	3
r2             0x7	7
r3             0x8418	33816
r4             0x0	0
r5             0x0	0
r6             0x82e4	33508
r7             0x0	0
r8             0x0	0
r9             0x0	0
r10            0x76fff000	1996484608
r11            0x0	0
r12            0x76fb9000	1996197888
sp             0x7efff648	0x7efff648
lr             0x76ea481c	1995065372
pc             0x842c	0x842c 
cpsr           0x60000010	1610612752

2. Cross dev env with ARM simulator on Ubuntu x64
Installed crosstool-NG and configured gcc/g++ 4.9 and gdb 7.8 for ARM with ARM sim.
Since Raspberry Pi hardware’s boot loader loads initial code at 0x8000 (I’ll make bare-metal micro code later), hoge.lds defines it to be loaded there.

@ startup
  .global _start
  .align

_start:
  ldr r0, =0x000000d3
  msr cpsr, r0
  ldr sp, =0x06400000
  bl main
  b .

hoge.lds

OUTPUT_ARCH(arm)
ENTRY(_start)
SECTIONS
{
	. = 0x8000;

	.text : { *(.text*) }
	. = ALIGN(4);

	__rodata_start = .;
	.rodata : { *(.data*) }
	. = ALIGN(4);
	__rodata_end = .;

	__data_start = . ;
	.data : { *(.data*) }
	. = ALIGN(4);
	__data_end = . ;

	__bss_start = . ;
	.bss : { *(.bss*) }
	. = ALIGN(4);
	__bss_end = . ;
}

hoge.c

int main(int argc, char const* argv[]) {
  int a = 3;
  int b = 4;
  return a + b;
}

gdb test with sim. Confirmed return value set to 7.

arm-unknown-eabi-gdb 
GNU gdb (crosstool-NG 1.20.0) 7.8
Copyright (C) 2014 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later 
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
and "show warranty" for details.
This GDB was configured as "--host=x86_64-build_unknown-linux-gnu --target=arm-unknown-eabi".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
.
Find the GDB manual and other documentation resources online at:
.
For help, type "help".
Type "apropos word" to search for commands related to "word".
/home/sokoide/.gdbinit:1: Error in sourced command file:
No symbol table is loaded.  Use the "file" command.
(gdb) target sim
Connected to the simulator.
(gdb) load hoge
Loading section .text, size 0x54 vma 0x8000
Loading section .rodata, size 0x8 vma 0x8054
Start address 0x8000
Transfer rate: 736 bits in <1 sec.
(gdb) file hoge
Reading symbols from hoge...(no debugging symbols found)...done.
(gdb) start
Temporary breakpoint 1 at 0x8014
Starting program: /media/psf/Dropbox/workspace/arm/helloc/hoge 

Temporary breakpoint 1, 0x00008014 in main ()
(gdb) disass
Dump of assembler code for function main:
=> 0x00008014 <+0>:	push	{r11}		; (str r11, [sp, #-4]!)
   0x00008018 <+4>:	add	r11, sp, #0
   0x0000801c <+8>:	sub	sp, sp, #20
   0x00008020 <+12>:	str	r0, [r11, #-16]
   0x00008024 <+16>:	str	r1, [r11, #-20]
   0x00008028 <+20>:	mov	r3, #3
   0x0000802c <+24>:	str	r3, [r11, #-8]
   0x00008030 <+28>:	mov	r3, #4
   0x00008034 <+32>:	str	r3, [r11, #-12]
   0x00008038 <+36>:	ldr	r2, [r11, #-8]
   0x0000803c <+40>:	ldr	r3, [r11, #-12]
   0x00008040 <+44>:	add	r3, r2, r3
   0x00008044 <+48>:	mov	r0, r3
   0x00008048 <+52>:	sub	sp, r11, #0
   0x0000804c <+56>:	pop	{r11}		; (ldr r11, [sp], #4)
   0x00008050 <+60>:	bx	lr
End of assembler dump.
(gdb) info r
r0             0xd3	211
r1             0x0	0
r2             0x0	0
r3             0x0	0
r4             0x0	0
r5             0x0	0
r6             0x0	0
r7             0x0	0
r8             0x0	0
r9             0x0	0
r10            0x0	0
r11            0x0	0
r12            0x0	0
sp             0x6400000	0x6400000
lr             0x8010	32784
pc             0x8014	0x8014 

cpsr           0xd3	211
(gdb) si
0x00008018 in main ()
(gdb) si
0x0000801c in main ()
(gdb) si
0x00008020 in main ()
(gdb) si
0x00008024 in main ()
(gdb) si
0x00008028 in main ()
(gdb) si
0x0000802c in main ()
(gdb) si
0x00008030 in main ()
(gdb) si
0x00008034 in main ()
(gdb) si
0x00008038 in main ()
(gdb) si
0x0000803c in main ()
(gdb) si
0x00008040 in main ()
(gdb) si
0x00008044 in main ()
(gdb) si
0x00008048 in main ()
(gdb) info r
r0             0x7	7
r1             0x0	0
r2             0x3	3
r3             0x7	7
r4             0x0	0
r5             0x0	0
r6             0x0	0
r7             0x0	0
r8             0x0	0
r9             0x0	0
r10            0x0	0
r11            0x63ffffc	104857596
r12            0x0	0
sp             0x63fffe8	0x63fffe8
lr             0x8010	32784
pc             0x8048	0x8048 
cpsr           0xd3	211

Make your own OS in 30 days – day17/18: Idle task and console

Leave a comment

Day16’s task_a was sleeping until interrupted, and other task_b0,b1,b2 were running. If we don’t have bx tasks, it needs a different logic.
It introduces an idle task to keep the design simple by always having a task than the main task_a.

void task_idle(void)
{
	for (;;) {
		io_hlt();
	}
}

To allow all tasks to get keyboard input, the task manager defines FIFO queue per task. Then added a console which accepts ‘mem’, ‘cls’ and ‘dir’ commands.
‘dir’ checks 8.3 file name and size.

struct FILEINFO *finfo = (struct FILEINFO *) (ADR_DISKIMG + 0x002600);

if (strcmp(cmdline, "mem") == 0) {
	sprintf(s, "total   %dMB", memtotal / (1024 * 1024));
	putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, s, 30);
	cursor_y = cons_newline(cursor_y, sheet);
	sprintf(s, "free %dKB", memman_total(memman) / 1024);
	putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, s, 30);
	cursor_y = cons_newline(cursor_y, sheet);
	cursor_y = cons_newline(cursor_y, sheet);
} else if (strcmp(cmdline, "cls") == 0) {
	for (y = 28; y < 28 + 128; y++) {
		for (x = 8; x < 8 + 240; x++) {
			sheet->buf[x + y * sheet->bxsize] = COL8_000000;
		}
	}
	sheet_refresh(sheet, 8, 28, 8 + 240, 28 + 128);
	cursor_y = 28;
} else if (strcmp(cmdline, "dir") == 0) {
	for (x = 0; x < 224; x++) {
		if (finfo[x].name[0] == 0x00) {
			break;
		}
		if (finfo[x].name[0] != 0xe5) {
			if ((finfo[x].type & 0x18) == 0) {
				sprintf(s, "filename.ext   %7d", finfo[x].size);
				for (y = 0; y < 8; y++) {
					s[y] = finfo[x].name[y];
				}
				s[ 9] = finfo[x].ext[0];
				s[10] = finfo[x].ext[1];
				s[11] = finfo[x].ext[2];
				putfonts8_asc_sht(sheet, 8, cursor_y, COL8_FFFFFF, COL8_000000, s, 30);
				cursor_y = cons_newline(cursor_y, sheet);
			}
		}
	}
	cursor_y = cons_newline(cursor_y, sheet);
}

day17_18

1 2 3 4 … 8