Format code using clang-format.

Signed-off-by: KieranMusser <59939188+KieranMusser@users.noreply.github.com>

Author: KieranMusser

src/kernel/devices/pci.c

@@ -9,15 +9,16 @@
 struct list_head pcis = LIST_INIT(pcis);
 
 struct registered_device {
-  void (*callback)(struct pci* this, struct pci_regs *regs);
+  void (*callback)(struct pci *this, struct pci_regs *regs);
   u16 vid;
   u16 did;
 };
 
 struct registered_device *handlers = nullptr;
 usize handlers_len = 0, handlers_cap = 0;
 
-void pci_register(u16 vid, u16 did, void (*callback)(struct pci *this, struct pci_regs *regs)) {
+void pci_register(u16 vid, u16 did,
+                  void (*callback)(struct pci *this, struct pci_regs *regs)) {
   if (!handlers) {
     assert(!handlers_len);
     handlers_cap = 16;
@@ -33,15 +34,13 @@ void pci_register(u16 vid, u16 did, void (*callback)(struct pci *this, struct pc
     handlers = new_handlers;
   }
 
-  handlers[handlers_len++] = (struct registered_device) {
-      .vid = vid,
-      .did = did,
-      .callback = callback
-  };
+  handlers[handlers_len++] =
+      (struct registered_device){.vid = vid, .did = did, .callback = callback};
 }
 
-void (*pci_get_handler(u16 vid, u16 did))(struct pci *this, struct pci_regs *regs) {
-  for (usize i = 0; i<handlers_len; ++i) {
+void (*pci_get_handler(u16 vid, u16 did))(struct pci *this,
+                                          struct pci_regs *regs) {
+  for (usize i = 0; i < handlers_len; ++i) {
     if (handlers[i].vid == vid && handlers[i].did == did)
       return handlers[i].callback;
   }

src/kernel/drivers/pci_device.c

@@ -4,14 +4,14 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
-#include <print.h>
+#include <container.h>
+#include <devicetree.h>
+#include <endian.h>
 #include <mm/paging.h>
 #include <mm/virtual_alloc.h>
 #include <physical.h>
-#include <devicetree.h>
+#include <print.h>
 #include <volatile.h>
-#include <container.h>
-#include <endian.h>
 
 #include <devices/pci.h>
 
@@ -35,15 +35,14 @@ union pci_device_addr {
   u32 bits;
 };
 
-void register_device(struct pci *this, u16 vid, u16 did, void (*callback)(struct pci* this, void *regs));
-struct vma* mmio_alloc(struct pci *this, usize len, bool want_low_addr);
+void register_device(struct pci *this, u16 vid, u16 did,
+                     void (*callback)(struct pci *this, void *regs));
+struct vma *mmio_alloc(struct pci *this, usize len, bool want_low_addr);
 
-static struct pci_ops pci_device_ops = {
-  .mmio_alloc = mmio_alloc
-};
-static_assert( offsetof(struct pci_regs, memar) == 0x14);
+static struct pci_ops pci_device_ops = {.mmio_alloc = mmio_alloc};
+static_assert(offsetof(struct pci_regs, memar) == 0x14);
 
-struct vma* mmio_alloc(struct pci *this, usize num_pages, bool want_low_addr) {
+struct vma *mmio_alloc(struct pci *this, usize num_pages, bool want_low_addr) {
   struct pci_device *dev = container_of(this, struct pci_device, pci);
   struct vma_allocator *allocator;
 
@@ -58,8 +57,8 @@ struct vma* mmio_alloc(struct pci *this, usize num_pages, bool want_low_addr) {
 
 void pci_enumerate(struct pci *this, void *reg_base) {
 
-  for (u32 bus=0; bus<256; ++bus) {
-    for (u32 dev=0; dev<32; ++dev) {
+  for (u32 bus = 0; bus < 256; ++bus) {
+    for (u32 dev = 0; dev < 32; ++dev) {
       union pci_device_addr addr;
       addr.offset = 0;
       addr.func = 0;
@@ -74,9 +73,10 @@ void pci_enumerate(struct pci *this, void *reg_base) {
       if (did == 0xffff && vid == 0xffff)
         continue;
 
-      void (*callback)(struct pci*, struct pci_regs *) = pci_get_handler(vid, did);
+      void (*callback)(struct pci *, struct pci_regs *) =
+          pci_get_handler(vid, did);
 
-      if (callback)  {
+      if (callback) {
         callback(this, device);
       } else {
         print("Unbekannt pci Gerät: {u16:x} Anbieter: {u16:x}", did, vid);
@@ -112,7 +112,6 @@ static struct device *pci_enumerate_dt(struct devicetree_node *node) {
                                      &parent_size_cells))
     goto fail;
 
-
   devicetree_print(node->parent);
 
   usize triplet_size = (address_cells + parent_address_cells + size_cells) * 4;
@@ -132,8 +131,10 @@ static struct device *pci_enumerate_dt(struct devicetree_node *node) {
     u64 addr, size;
 
     memcpy(&bus_addr.bits, &base->value[i], 4);
-    memcpy(&addr, &base->value[i+address_cells*4], parent_address_cells * 4);
-    memcpy(&size, &base->value[i+(address_cells + parent_address_cells)*4], size_cells * 4);
+    memcpy(&addr, &base->value[i + address_cells * 4],
+           parent_address_cells * 4);
+    memcpy(&size, &base->value[i + (address_cells + parent_address_cells) * 4],
+           size_cells * 4);
 
     addr = big_to_native(addr);
     size = big_to_native(size);
@@ -166,8 +167,8 @@ static struct device *pci_enumerate_dt(struct devicetree_node *node) {
           },
       .reg_base = iomem_map(reg_addr, reg_size),
       .mmio_low_allocator = vma_allocator_new(mmio_32bit_low, mmio_32bit_high),
-      .mmio_high_allocator = vma_allocator_new(mmio_64bit_low, mmio_64bit_high)
-  };
+      .mmio_high_allocator =
+          vma_allocator_new(mmio_64bit_low, mmio_64bit_high)};
 
   if (!device->device.name || !device->reg_base)
     goto fail;

src/kernel/drivers/rtl8139.c

@@ -9,8 +9,8 @@
 #include <print.h>
 
 #include <device.h>
-#include <devices/pci.h>
 #include <devices/netdev.h>
+#include <devices/pci.h>
 #include <net/eth.h>
 
 struct rtl8139_regs {
@@ -34,20 +34,14 @@ struct rtl8139 {
 bool send_packet(struct netdev *this, u8 packet[], usize length);
 struct mac get_mac(struct netdev *this);
 
-struct netdev_ops rtl8139_ops = {
-  .send_packet = send_packet,
-  .get_mac = get_mac
-};
+struct netdev_ops rtl8139_ops = {.send_packet = send_packet,
+                                 .get_mac = get_mac};
 
 constexpr usize TX_BUFF_SIZE = 0x1700;
 constexpr u16 rtl8139_vid = 0x10ec;
 constexpr u16 rtl8139_did = 0x8139;
 
-enum rtl8139_registers {
-  REG_COM = 0x37,
-  REG_TCR = 0x40,
-  REG_CONFIG1 = 0x52
-};
+enum rtl8139_registers { REG_COM = 0x37, REG_TCR = 0x40, REG_CONFIG1 = 0x52 };
 
 enum rtl8139_flags {
   TSD_TOK = (1 << 15),
@@ -60,10 +54,10 @@ enum rtl8139_flags {
 
 u8 rtl8139_tbuff[4][TX_BUFF_SIZE] __attribute__((aligned(256)));
 
-static_assert( offsetof(struct rtl8139_regs, tsad) == 0x20);
-static_assert( offsetof(struct rtl8139_regs, tsd) == 0x10);
-static_assert( offsetof(struct rtl8139_regs, com) == 0x37);
-static_assert( offsetof(struct rtl8139_regs, config1) == 0x52);
+static_assert(offsetof(struct rtl8139_regs, tsad) == 0x20);
+static_assert(offsetof(struct rtl8139_regs, tsd) == 0x10);
+static_assert(offsetof(struct rtl8139_regs, com) == 0x37);
+static_assert(offsetof(struct rtl8139_regs, config1) == 0x52);
 
 bool mm_paging_walk(uaddr va, paddr *pte, bool alloc);
 
@@ -81,15 +75,15 @@ u32 walkaddr(uaddr addr) {
 
   pte = (pte >> 10) << 12;
   assert(pte < U32_MAX);
-  return (u32) pte | off;
+  return (u32)pte | off;
 }
 
 struct mac get_mac(struct netdev *this) {
   struct rtl8139 *rtl_this = (struct rtl8139 *)(this->device);
   volatile struct rtl8139_regs *rtl_regs = rtl_this->regs;
   struct mac mac;
 
-  for (usize i = 0; i<6; ++i) {
+  for (usize i = 0; i < 6; ++i) {
     mac.addr[i] = rtl_regs->mac[i];
   }
   return mac;
@@ -98,10 +92,10 @@ struct mac get_mac(struct netdev *this) {
 bool send_packet(struct netdev *this, u8 packet[], usize length) {
   struct rtl8139 *rtl_this = container_of(this, struct rtl8139, netdev);
   volatile struct rtl8139_regs *rtl_regs = rtl_this->regs;
-  u32 phys_buffer = walkaddr((uaddr) (&rtl8139_tbuff[0]));
+  u32 phys_buffer = walkaddr((uaddr)(&rtl8139_tbuff[0]));
   u64 i;
 
-  for (i=0; i<length; ++i) {
+  for (i = 0; i < length; ++i) {
     rtl8139_tbuff[rtl_this->current_buffer][i] = packet[i];
   }
 
@@ -110,26 +104,23 @@ bool send_packet(struct netdev *this, u8 packet[], usize length) {
   }
 
   rtl_regs->tsad[rtl_this->current_buffer] = phys_buffer;
-  rtl_regs->tsd[rtl_this->current_buffer] = (u32) length;
+  rtl_regs->tsd[rtl_this->current_buffer] = (u32)length;
 
   ++rtl_this->current_buffer;
   return true;
 }
 
-
 void rtl8139_test(struct rtl8139 *rtl_device) {
   volatile struct rtl8139_regs *rtl_regs = rtl_device->regs;
   struct mac mac;
-  memcpy(mac.addr, (const u8*) "\xff\xff\xff\xff\xff\xff", 6);
+  memcpy(mac.addr, (const u8 *)"\xff\xff\xff\xff\xff\xff", 6);
 
-  eth_send_packet(&rtl_device->netdev, mac,
-    (u8*) "yellow submarine", 16);
+  eth_send_packet(&rtl_device->netdev, mac, (u8 *)"yellow submarine", 16);
 
   assert(rtl_regs->tsad[0] != 0);
   assert((rtl_regs->tsd[0] & TSD_TOK) != 0);
 }
 
-
 static struct device *add_device(paddr reg_addr, usize reg_size) {
   struct rtl8139 *device = nullptr;
 
@@ -164,10 +155,9 @@ static struct device *add_device(paddr reg_addr, usize reg_size) {
   }
   free(device);
   return nullptr;
-
 }
 
-void rtl8139_init(struct pci* pci, struct pci_regs *pci_device) {
+void rtl8139_init(struct pci *pci, struct pci_regs *pci_device) {
   print("initializing rtl8139");
 
   volatile struct rtl8139_regs *rtl_regs;
@@ -179,10 +169,11 @@ void rtl8139_init(struct pci* pci, struct pci_regs *pci_device) {
 
   /* Should always be true, see mmio_alloc */
   assert(low < U32_MAX);
-  reg_addr = (u32) low;
+  reg_addr = (u32)low;
 
-  struct device *device = add_device(paddr_of_bits(reg_addr), sizeof(struct rtl8139_regs));
-  struct rtl8139 *rtl_device = (struct rtl8139 *) device;
+  struct device *device =
+      add_device(paddr_of_bits(reg_addr), sizeof(struct rtl8139_regs));
+  struct rtl8139 *rtl_device = (struct rtl8139 *)device;
   rtl_regs = rtl_device->regs;
 
   /* TODO: Maybe move PCI init to pci.c? */
@@ -193,7 +184,8 @@ void rtl8139_init(struct pci* pci, struct pci_regs *pci_device) {
   rtl_regs->config1 = 0;
 
   rtl_regs->com = COM_RST;
-  while (rtl_regs->com & COM_RST) ;
+  while (rtl_regs->com & COM_RST)
+    ;
   rtl_regs->com = COM_RE | COM_TE;
 
   rtl_regs->tsad[0] = 0x12;

src/kernel/include/devices/pci.h

@@ -7,9 +7,8 @@
 #ifndef UKO_OS_KERNEL__PCI_H
 #define UKO_OS_KERNEL__PCI_H 1
 
-#include <types.h>
 #include <device.h>
-
+#include <types.h>
 
 struct pci_regs {
   u16 vid;
@@ -26,13 +25,15 @@ struct pci {
 };
 
 struct pci_ops {
-  struct vma* (*mmio_alloc)(struct pci *this, usize len, bool want_low_addr);
+  struct vma *(*mmio_alloc)(struct pci *this, usize len, bool want_low_addr);
 };
 
 extern struct list_head pcis;
 
-void (*pci_get_handler(u16 vid, u16 did))(struct pci *this, struct pci_regs *regs);
-void pci_register(u16 vid, u16 did, void (*callback)(struct pci *this, struct pci_regs *regs));
+void (*pci_get_handler(u16 vid, u16 did))(struct pci *this,
+                                          struct pci_regs *regs);
+void pci_register(u16 vid, u16 did,
+                  void (*callback)(struct pci *this, struct pci_regs *regs));
 
 enum pci_bus_addr_space_code {
   SPACE_CODE_CONFIG = 0,
@@ -45,7 +46,7 @@ union pci_bus_addr {
   struct {
     u32 pad : 24;
     enum pci_bus_addr_space_code space_code : 2;
-    u32 pad2: 6;
+    u32 pad2 : 6;
   };
   u32 bits;
 };

src/kernel/include/net/eth.h

@@ -10,9 +10,10 @@
 #define UKO_OS_KERNEL__NET_ETH__H 1
 
 struct mac {
-	u8 addr[6];
+  u8 addr[6];
 };
 
-bool eth_send_packet(struct netdev *device, const struct mac dst, u8 *buffer, usize len);
+bool eth_send_packet(struct netdev *device, const struct mac dst, u8 *buffer,
+                     usize len);
 
 #endif

src/kernel/net/eth.c

@@ -3,20 +3,21 @@
  *
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
-#include <types.h>
 #include <device.h>
 #include <devices/netdev.h>
 #include <mm/virtual_alloc.h>
 #include <net/eth.h>
+#include <types.h>
 
 struct ethernet_packet {
-    u8 dst[6];
-    u8 src[6];
-    u8 ethertype[2];
-    u8 data[];
+  u8 dst[6];
+  u8 src[6];
+  u8 ethertype[2];
+  u8 data[];
 };
 
-bool eth_send_packet(struct netdev *device, const struct mac dst, u8 *buffer, usize len) {
+bool eth_send_packet(struct netdev *device, const struct mac dst, u8 *buffer,
+                     usize len) {
   struct ethernet_packet *packet;
   struct mac src;
   usize packet_len;
@@ -34,12 +35,12 @@ bool eth_send_packet(struct netdev *device, const struct mac dst, u8 *buffer, us
 
   packet->ethertype[0] = 0x86;
   packet->ethertype[1] = 0xDD;
-  
+
   memcpy(packet->data, buffer, len);
 
-  for (usize i=len; i<46; ++i) {
+  for (usize i = len; i < 46; ++i) {
     packet->data[i] = 0;
   }
 
-  return device->ops->send_packet(device, (u8*) packet, packet_len);
+  return device->ops->send_packet(device, (u8 *)packet, packet_len);
 }