First partial network packet

Implement rtl tx

Author: KieranMusser

src/kernel/arch/riscv64/include.mak

@@ -24,6 +24,11 @@ $(call defcleanable, \
 	src/kernel/kernel.elf \
 	src/kernel/kernel.sym)
 
+bgdb: src/kernel/kernel.sym
+	gdb-multiarch src/kernel/kernel.sym \
+		-ex "set substitute-path / $(srcdir)/" \
+		-ex "target remote :1234"
+
 # Targets for booting and debugging the kernel.
 gdb: src/kernel/kernel.sym
 	gdb-multiarch src/kernel/kernel.sym \
@@ -48,6 +53,9 @@ qemu: src/kernel/kernel.elf
 		--cpu rva22s64 \
 		--smp 1 \
 		-m 1G \
+		-device rtl8139,netdev=net1,bus=pcie.0 \
+		-netdev user,id=net1,net=192.168.0.0/24 \
+		-object filter-dump,id=net1,netdev=net1,file=net_dump.pcap \
 		-nographic \
 		-kernel src/kernel/kernel.elf \
 		$(QEMUFLAGS)
@@ -57,8 +65,12 @@ qemu-debug: src/kernel/kernel.elf
 		--cpu rva22s64 \
 		--smp 1 \
 		-m 1G \
+		-device rtl8139,netdev=net1,bus=pcie.0 \
+		-netdev user,id=net1,net=192.168.0.0/24 \
+		-object filter-dump,id=net1,netdev=net1,file=net_dump.pcap \
 		-nographic \
 		-kernel src/kernel/kernel.elf \
+		-d guest_errors \
 		-s -S \
 		$(QEMUFLAGS)
 .PHONY: gdb gdb_bootstub qemu qemu-debug

src/kernel/arch/riscv64/paging.c

@@ -4,9 +4,7 @@
 #include <panic.h>
 #include <physical.h>
 
-/**
- * An Sv39 page table entry.
- */
+
 struct pte {
   bool valid : 1;
   bool readable : 1;
@@ -21,6 +19,10 @@ struct pte {
   u64 rsrvd0 : 10;
 };
 
+enum walk_flags {
+  WALK_ALLOC = (1 << 0),
+};
+
 static u64 bits_of_pte(struct pte pte) {
   union {
     u64 bits;
@@ -162,6 +164,20 @@ paddr walk(uaddr vaddr, enum walk_flags flags) {
   return paddr_offset(pgtbl0, ppn0 << 3);
 }
 
+u64 walkaddr(uaddr vaddr) {
+  paddr pte_addr;
+  struct pte pte;
+  u64 offset = vaddr & 0xfff;
+  u64 mask = 0xfff;
+  mask = ~mask;
+  vaddr &= mask;
+
+  pte_addr = walk(vaddr, 0);
+
+  pte = pte_of_bits(physical_read_u64le(pte_addr));
+  return (pte.ppn << 12) + offset;
+}
+
 bool _mm_map(uaddr va, paddr pa, enum page_permissions perms) {
   assert((va & 0xfff) == 0, "va={uaddr}", va);
   assert(!pa.offset, "pa={paddr}", pa);

src/kernel/drivers/rtl8139.c

@@ -0,0 +1,139 @@
+#include <arch/riscv64/insns.h>
+
+#include <drivers/rtl8139.h>
+
+#include <mm/paging.h>
+#include <physical.h>
+#include <print.h>
+
+#define READ_U8(addr, off) physical_read_u8(paddr_of_bits(addr + off))
+#define WRITE_U8(addr, off, value) physical_write_u8(paddr_of_bits(addr + off), value)
+
+#define READ_U16(addr, off) physical_read_u16le(paddr_of_bits(addr + off))
+#define WRITE_U16(addr, off, value) physical_write_u16le(paddr_of_bits(addr + off), value)
+
+#define READ_U32(addr, off) physical_read_u32le(paddr_of_bits(addr + off))
+#define WRITE_U32(addr, off, value) physical_write_u32le(paddr_of_bits(addr + off), value)
+
+#define READ_REG(reg) READ_U8(g_regs_addr, reg)
+#define WRITE_REG(reg, value) WRITE_U8(g_regs_addr, reg, value)
+
+#define READ_REG_32(reg) READ_U32(g_regs_addr, reg)
+#define WRITE_REG_32(reg, value) WRITE_U32(g_regs_addr, reg, value)
+
+#define REG_TSADn(N) (0x20 + N * 4)
+#define REG_TSDn(N) (0x10 + N * 4)
+
+enum RTL8139_REGS {
+  REG_COM = 0x37,
+  REG_TCR = 0x40,
+  REG_CONFIG1 = 0x52
+};
+
+enum RTL8139_CONST {
+  TSD_TOK = (1 << 15),
+  TSD_OWN = (1 << 13),
+
+  COM_RST = (1 << 4),
+  COM_RE = (1 << 3),
+  COM_TE = (1 << 2)
+};
+
+
+#define REG_IDR0 0x0
+#define REG_IDR4 0x4
+
+
+#define TX_BUFF_SIZE 0x1700
+
+u8 rtl8139_tbuff[4][TX_BUFF_SIZE] __attribute__((aligned(256)));
+
+u8 mac_addr[6];
+
+u64 g_regs_addr;
+u64 g_cur_buf = 0;
+
+
+bool rtl8139_send_packet(u8 *buffer, u32 len) {
+  u32 phys_buffer = (u32) walkaddr((uaddr) (&rtl8139_tbuff[0]));
+  u64 i;
+
+  for (i=0; i<len; ++i) {
+    rtl8139_tbuff[0][i] = buffer[i];
+  }
+
+  if ((READ_REG_32(REG_TSDn(g_cur_buf)) & TSD_OWN) == 0) {
+    return false;
+  }
+
+  sfence_vma();
+  WRITE_REG_32(REG_TSADn(g_cur_buf), phys_buffer);
+  WRITE_REG_32(REG_TSDn(g_cur_buf), len);
+
+  ++g_cur_buf;
+  return true;
+}
+
+bool eth_send_packet(u8 *buffer, u32 len) {
+  u8 buf[0x100];
+  u64 i;
+
+  for (i=0; i<6; ++i) {
+    buf[i] = 0xff;
+    buf[i + 6] = mac_addr[i];
+  }
+  buf[12] = 0x08;
+  buf[13] = 0x00;
+
+  for (i=0; i<len; ++i) {
+    buf[i + 14] = buffer[i];
+  }
+  for (i=len; i<64; ++i) {
+    buf[i + 14] = 0;
+  }
+  if (len < 64) len = 64;
+
+  return rtl8139_send_packet(buf, len + 13);
+}
+
+
+void read_mac(u8 * mac) {
+  u8 i;
+
+  for (i=0; i<6; ++i)
+    mac[i] = READ_REG(i);
+}
+
+
+void rtl8139_test() {
+  eth_send_packet((u8*) "yellow submarine", 16);
+
+  assert(READ_REG_32(REG_TSADn(0)) != 0);
+  assert((READ_REG_32(REG_TSDn(0)) & TSD_TOK) != 0);
+}
+
+
+void rtl8139_init(u64 pci_device) {
+  print("initializing rtl8139");
+
+  u32 reg_addr = 0x40000000;
+  g_regs_addr = reg_addr;
+
+  /* TODO: Maybe move PCI init to pci.c? */
+
+  /* Setup BAR for MMIO - we just pick a nice number for now */
+  WRITE_U32(pci_device,0x14,reg_addr);
+
+  /* Enable memory mapped regs */
+  u8 cmd = READ_U8(pci_device, 0x4);
+  WRITE_U8(pci_device,0x4,cmd | 0x6);
+
+  WRITE_REG(REG_CONFIG1, 0);
+
+  WRITE_REG(REG_COM, COM_RST);
+  while (READ_REG(REG_COM) & COM_RST) ;
+  WRITE_REG(REG_COM, COM_RE | COM_TE);
+
+  read_mac(mac_addr);
+  rtl8139_test();
+}

src/kernel/include.mak

@@ -14,8 +14,9 @@ kernel-cflags += -fdata-sections -ffunction-sections
 kernel-ldflags += -Wl,--gc-sections
 kernel-dir = src/kernel
 kernel-objs-asm =
-kernel-objs-c = devicetree main panic print random selftest swar_test symbolicate
+kernel-objs-c = devicetree main panic print random selftest swar_test symbolicate pci
 kernel-objs-c += builtins/bzero builtins/explicit_bzero builtins/memcpy builtins/memcmp builtins/memset builtins/strlen
 kernel-objs-c += crypto/subtle/rfc7539 crypto/subtle/rfc7693
 kernel-objs-c += mm/alloc mm/physical_alloc mm/virtual_alloc
+kernel-objs-c += drivers/rtl8139
 include $(srcdir)/src/kernel/arch/$(arch)/include.mak

src/kernel/include/drivers/rtl8139.h

@@ -0,0 +1,10 @@
+#ifndef UKO_OS_KERNEL__RTL8139_H
+#define UKO_OS_KERNEL__RTL8139_H 1
+
+#include <types.h>
+
+void rtl8139_init(u64 pci_device);
+void rtl8139_test();
+bool eth_send_packet(u8 *buffer, u32 len);
+
+#endif

src/kernel/include/mm/paging.h

@@ -59,4 +59,9 @@ enum page_permissions : u8 {
  */
 bool _mm_map(uaddr va, paddr pa, enum page_permissions perms);
 
+u64 walkaddr(uaddr vaddr);
+
+
+
+
 #endif // UKO_OS_KERNEL__MM_PAGING_H

src/kernel/include/pci.h

@@ -0,0 +1,10 @@
+#ifndef UKO_OS_KERNEL__PCI_H
+#define UKO_OS_KERNEL__PCI_H 1
+
+#include <types.h>
+
+
+void pci_enumerate();
+
+
+#endif

src/kernel/main.c

@@ -5,8 +5,10 @@
 #include <panic.h>
 #include <print.h>
 #include <random.h>
+#include <pci.h>
 #include <selftest.h>
 #include <symbolicate.h>
+#include <arch/riscv64/insns.h>
 
 [[noreturn]]
 void main(u64 hart_id, paddr devicetree_start, paddr kernel_start,
@@ -21,6 +23,9 @@ void main(u64 hart_id, paddr devicetree_start, paddr kernel_start,
   devicetree_init(devicetree_start);
   devicetree_mm_init(kernel_start, kernel_end, &free_va_start, &free_va_end);
   mm_init_virtual(free_va_start, free_va_end);
+  pci_enumerate();
+
+  wfi();
 
   uptr a = mm_va_alloc(mm_kernel_virtual_buddy, 2 * 1024 * 1024);
   uptr b = mm_va_alloc(mm_kernel_virtual_buddy, 4096);

src/kernel/pci.c

@@ -0,0 +1,38 @@
+#include <pci.h>
+#include <print.h>
+#include <mm/paging.h>
+#include <physical.h>
+
+#include <drivers/rtl8139.h>
+
+const u64 regs = 0x123L;
+
+const u64 pci_config = 0x30000000L;
+const u32 rtl8139_vender = 0x123;
+
+paddr mad(u64 addr) {
+  paddr *x;
+  x = (paddr*) (&addr);
+  return *x;
+}
+
+
+void pci_enumerate() {
+
+  for (u64 dev=0; dev<32; ++dev) {
+    u64 bus = 0;
+    u64 func = 0;
+    u64 offset = 0;
+    offset = (bus << 16) | (dev << 11) | (func << 8) | (offset);
+    u64 device = (pci_config + offset);
+
+    u16 vid = physical_read_u16le(mad(device));
+    u16 did = physical_read_u16le(mad(device+2));
+
+    if (vid == 0x10ec && did == 0x8139){ //0xedf11efd) {
+      rtl8139_init(device); //device_pci_cfg);
+    } else if (did != 0xffff && vid != 0xffff && vid) {
+      print("unknown pci device: {u16:x} vender: {u16:x}", did, vid);
+    } 
+  }
+}