OSDev.org

Code: Select all

#include <i386/uart.h>

int init_com_port(uint16_t port) {
	// Disable interrupts
	outb(port + 1, 0x00);
	// enable DLAB
	outb(port + 3, 0x80);
	// Set divisor to 3, 38400 buad
	outb(port + 0, 0x03);
	// hi byte
	outb(port + 1, 0x00);
	// 8 bits, no parity, one stop bit
	outb(port + 3, 0x03);
	// enable FIFO, clear them, with 14-byte threshold
	outb(port + 2, 0xC7);
	// IRQs enabled RTS/DSR set
	outb(port + 4, 0x0B);
	// Set in loopback mode, test serial chhip
	outb(port + 4, 0x1E);
	// Test serial chip
	outb(port + 0, 0xAE);

	// Check if serial is faulty
	if (inb(port + 0) != 0xAE)
		return 0;

	// if serial is not faulty set it in normal operation mode
	outb(port + 4, 0x0F);
	return 1;
}

int is_transmit_empty(uint16_t port) {
	return inb(port + 5) & 0x20;
}

void serial_putchar(uint16_t port, char a) {
	while (!is_transmit_empty(port));

	outb(port, a);
}

void serial_writestring(uint16_t port, const char *string) {

	serial_write(port, string, strlen(string));
}

void serial_write(uint16_t port, const char *string, size_t n) {
	for (size_t i = 0; i < n; ++i) {
		serial_putchar(port, string[i]);
	}
}

Code: Select all

int init_memory_map(multiboot_info_t *mbd) {

	/* We only actually use the mmap_t here, and so we're going
	 * to go ahead and define it within the function
	 */
	struct mmap_t {
		uint32_t size;
		uint64_t base;
		uint64_t len;
		uint32_t type;
	} __attribute((packed));

	unsigned char check_flag = (1 << 0) & mbd->flags;
	
	// Check flags to make sure memory mapping is sane
	if (!check_flag) {
		printf("Flag is not set at bit 0!\n");
		return 0;
	}

	check_flag = (1 << 6) & mbd->flags;

	if (!check_flag) {
		printf("Flag is not set at bit 6!\n");
		return 0;
	}

	// Get the address and length to set up
	struct mmap_t *mmap_addr = (struct mmap_t *) mbd->mmap_addr;
	uint64_t mmap_length = (uint64_t) mbd->mmap_length;

	// Get the number of entries
	uint32_t arr_size = mmap_length / sizeof(struct mmap_t); 
	

	// TODO: Remove this and just use mbd->mmap_addr
	struct mmap_t entries[arr_size];
	// Copy the multiboot info into entries
	memcpy(entries, mmap_addr, mmap_length);

	// TODO: Remove this code later
	for (uint32_t i = 0; i < arr_size; ++i) {
		printf_serial("Size: %u\n", entries[i].size);
		printf_serial("Base: 0x%llx\n", entries[i].base);
		printf_serial("Size: %llu\n", entries[i].len);
		printf_serial("Type: 0x%lx\n\n", entries[i].type);
	}	

	/* Get the base + length to determine total "usable"
	 * ram
	 */
	uint64_t last_address = entries[arr_size-1].base +
	       			entries[arr_size-1].len;

	printf_serial("Last address: 0x%llx\n", last_address);

	// Get the number of pages
	uint32_t blocks = last_address / 4096; 

	printf_serial("Number of blocks: %u\n", blocks);

	// Get the number of bytes for the bitmap, each bit is 1 page
	bitmap_size = blocks / 8;

	printf_serial("Bitmap size: %u\n", bitmap_size);

	uint8_t bitmap[bitmap_size];

	printf_serial("Preparing to memset bitmap...\n");
	// Set all bits to 1
	memset(bitmap, 0xFF, bitmap_size);
        // It never gets passed this point
	printf_serial("Finished memsetting bitmap...\n");