treewide: Use spaces instead of tabs.

Author: QuzarDC

addons/libkosfat/directory.c

@@ -702,24 +702,24 @@ int fat_erase_dentry(fat_fs_t *fs, uint32_t cl, uint32_t off, uint32_t lcl,
                 ent->name[0] = FAT_ENTRY_FREE;
             }
 
-	    if(!done) {
+        if(!done) {
                 /* Move onto the next cluster. */
                 if(!(lcl & 0x80000000)) {
                     lcl = fat_read_fat(fs, lcl, &err);
                     if(lcl == 0xFFFFFFFF) {
                         dbglog(DBG_ERROR, "Invalid FAT value hit while "
-			       "reading long name entry for deletion at "
-			       "cluster %" PRIu32 ", offset %" PRIu32 "\n",
-			       lcl, i << 5);
+                            "reading long name entry for deletion at "
+                            "cluster %" PRIu32 ", offset %" PRIu32 "\n",
+                            lcl, i << 5);
                         return -err;
                     }
 
                     /* This shouldn't happen either... */
                     if(fat_is_eof(fs, lcl)) {
                         dbglog(DBG_ERROR, "End of directory hit while "
-			       "reading long name entry for deletion at "
-			       "cluster %" PRIu32 ", offset %" PRIu32 "\n",
-			       lcl, i << 5);
+                            "reading long name entry for deletion at "
+                            "cluster %" PRIu32 ", offset %" PRIu32 "\n",
+                            lcl, i << 5);
                         return -EIO;
                     }
 
@@ -731,15 +731,15 @@ int fat_erase_dentry(fat_fs_t *fs, uint32_t cl, uint32_t off, uint32_t lcl,
 
                     if(max2 <= 0) {
                         dbglog(DBG_ERROR, "End of directory hit while "
-			       "reading long name entry for deletion at "
-			       "cluster %" PRIu32 ", offset %" PRIu32 "\n",
-			       lcl, i << 5);
+                            "reading long name entry for deletion at "
+                            "cluster %" PRIu32 ", offset %" PRIu32 "\n",
+                            lcl, i << 5);
                         return -EIO;
                     }
 
                     i = 0;
                 }
-	    }
+            }
         }
     }
 

addons/libkosfat/fs_fat.c

@@ -1020,7 +1020,7 @@ static int fs_fat_unlink(vfs_handler_t *vfs, const char *fn) {
         if((err = fat_erase_chain(fs->fs, cluster))) {
             /* Uh oh... This is really bad... */
             dbglog(DBG_ERROR, "fs_fat: Error erasing FAT chain for file %s\n",
-	           fn);
+                fn);
             irv = -1;
             errno = -err;
         }

examples/dreamcast/basic/dma/speedtest/speedtest.c

@@ -22,112 +22,112 @@ static alignas(32) char buf2[BUF_SIZE];
 
 static void dma_done(void *d)
 {
-	*(uint64_t *)d = timer_us_gettime64();
-	genwait_wake_all(d);
+    *(uint64_t *)d = timer_us_gettime64();
+    genwait_wake_all(d);
 }
 
 static dma_config_t dma_cfg = {
-	.channel = 1,
-	.request = DMA_REQUEST_AUTO_MEM_TO_MEM,
-	.unit_size = DMA_UNITSIZE_32BYTE,
-	.src_mode = DMA_ADDRMODE_INCREMENT,
-	.dst_mode = DMA_ADDRMODE_INCREMENT,
-	.transmit_mode = DMA_TRANSMITMODE_BURST,
-	.callback = dma_done,
+    .channel = 1,
+    .request = DMA_REQUEST_AUTO_MEM_TO_MEM,
+    .unit_size = DMA_UNITSIZE_32BYTE,
+    .src_mode = DMA_ADDRMODE_INCREMENT,
+    .dst_mode = DMA_ADDRMODE_INCREMENT,
+    .transmit_mode = DMA_TRANSMITMODE_BURST,
+    .callback = dma_done,
 };
 
 static uint64_t
 do_dma_transfer(unsigned int test, pvr_ptr_t vram1, pvr_ptr_t vram2)
 {
-	uint64_t before, after = 0;
-
-	irq_disable_scoped();
-
-	before = timer_us_gettime64();
-
-	switch (test) {
-	case 0:
-		/* RAM to RAM */
-		dma_transfer(&dma_cfg,
-			     dma_map_dst(buf1, BUF_SIZE),
-			     dma_map_src(buf2, BUF_SIZE),
-			     BUF_SIZE, &after);
-		break;
-	case 1:
-		/* RAM to VRAM */
-		dma_transfer(&dma_cfg,
-			     hw_to_dma_addr((uintptr_t)vram1),
-			     dma_map_src(buf2, BUF_SIZE),
-			     BUF_SIZE, &after);
-		break;
-	case 2:
-		/* VRAM to RAM */
-		dma_transfer(&dma_cfg,
-			     dma_map_dst(buf1, BUF_SIZE),
-			     hw_to_dma_addr((uintptr_t)vram1),
-			     BUF_SIZE, &after);
-		break;
-	case 3:
-		/* VRAM to VRAM */
-		dma_transfer(&dma_cfg,
-			     hw_to_dma_addr((uintptr_t)vram1),
-			     hw_to_dma_addr((uintptr_t)vram2),
-			     BUF_SIZE, &after);
-		break;
-	case 4:
-		/* RAM to VRAM using SQs */
-		pvr_txr_load(buf1, vram1, BUF_SIZE);
-
-		return timer_us_gettime64() - before;
-	case 5:
-		/* RAM to 64-bit VRAM using PVR DMA */
-		pvr_txr_load_dma(buf1, vram1, BUF_SIZE,
-				 0, dma_done, &after);
-		break;
-	case 6:
-		/* RAM to 32-bit VRAM using PVR DMA */
-		pvr_dma_transfer(buf1, (uintptr_t)vram1, BUF_SIZE,
-				 PVR_DMA_VRAM32, 0,
-				 dma_done, &after);
-		break;
-	}
-
-	while ((volatile uint64_t)after == 0)
-		genwait_wait(&after, "IRQ wait", 0, NULL);
-
-	return after - before;
+    uint64_t before, after = 0;
+
+    irq_disable_scoped();
+
+    before = timer_us_gettime64();
+
+    switch (test) {
+    case 0:
+        /* RAM to RAM */
+        dma_transfer(&dma_cfg,
+                 dma_map_dst(buf1, BUF_SIZE),
+                 dma_map_src(buf2, BUF_SIZE),
+                 BUF_SIZE, &after);
+        break;
+    case 1:
+        /* RAM to VRAM */
+        dma_transfer(&dma_cfg,
+                 hw_to_dma_addr((uintptr_t)vram1),
+                 dma_map_src(buf2, BUF_SIZE),
+                 BUF_SIZE, &after);
+        break;
+    case 2:
+        /* VRAM to RAM */
+        dma_transfer(&dma_cfg,
+                 dma_map_dst(buf1, BUF_SIZE),
+                 hw_to_dma_addr((uintptr_t)vram1),
+                 BUF_SIZE, &after);
+        break;
+    case 3:
+        /* VRAM to VRAM */
+        dma_transfer(&dma_cfg,
+                 hw_to_dma_addr((uintptr_t)vram1),
+                 hw_to_dma_addr((uintptr_t)vram2),
+                 BUF_SIZE, &after);
+        break;
+    case 4:
+        /* RAM to VRAM using SQs */
+        pvr_txr_load(buf1, vram1, BUF_SIZE);
+
+        return timer_us_gettime64() - before;
+    case 5:
+        /* RAM to 64-bit VRAM using PVR DMA */
+        pvr_txr_load_dma(buf1, vram1, BUF_SIZE,
+                 0, dma_done, &after);
+        break;
+    case 6:
+        /* RAM to 32-bit VRAM using PVR DMA */
+        pvr_dma_transfer(buf1, (uintptr_t)vram1, BUF_SIZE,
+                 PVR_DMA_VRAM32, 0,
+                 dma_done, &after);
+        break;
+    }
+
+    while ((volatile uint64_t)after == 0)
+        genwait_wait(&after, "IRQ wait", 0, NULL);
+
+    return after - before;
 }
 
 static const char * const test_lbl[] = {
-	"DMAC, RAM to RAM:   ",
-	"DMAC, RAM to VRAM:  ",
-	"DMAC, VRAM to RAM:  ",
-	"DMAC, VRAM to VRAM: ",
-	"PVR SQs:            ",
-	"PVR DMA, 64-bit:    ",
-	"PVR DMA, 32-bit:    ",
+    "DMAC, RAM to RAM:   ",
+    "DMAC, RAM to VRAM:  ",
+    "DMAC, VRAM to RAM:  ",
+    "DMAC, VRAM to VRAM: ",
+    "PVR SQs:            ",
+    "PVR DMA, 64-bit:    ",
+    "PVR DMA, 32-bit:    ",
 };
 
 int main(int argc, char **argv)
 {
-	pvr_ptr_t vram, vram2;
-	uint64_t time_us;
-	unsigned int i;
+    pvr_ptr_t vram, vram2;
+    uint64_t time_us;
+    unsigned int i;
 
-	pvr_init_defaults();
+    pvr_init_defaults();
 
-	vram = pvr_mem_malloc(BUF_SIZE);
-	vram2 = pvr_mem_malloc(BUF_SIZE);
+    vram = pvr_mem_malloc(BUF_SIZE);
+    vram2 = pvr_mem_malloc(BUF_SIZE);
 
-	for (i = 0; i < ARRAY_SIZE(test_lbl); i++) {
-		time_us = do_dma_transfer(i, vram, vram2);
-		printf("%s%f MiB/s\n",
-		       test_lbl[i], (float)BUF_SIZE / (float)time_us);
+    for (i = 0; i < ARRAY_SIZE(test_lbl); i++) {
+        time_us = do_dma_transfer(i, vram, vram2);
+        printf("%s%f MiB/s\n",
+                test_lbl[i], (float)BUF_SIZE / (float)time_us);
 
-	}
+    }
 
-	pvr_mem_free(vram);
-	pvr_mem_free(vram2);
+    pvr_mem_free(vram);
+    pvr_mem_free(vram2);
 
-	return 0;
+    return 0;
 }

examples/dreamcast/basic/memtest32/memtest.c

@@ -1,13 +1,13 @@
 /**********************************************************************
  *
  * Filename:    memtest.c
- * 
+ *
  * Description: General-purpose memory testing functions.
  *
  * Notes:       This software can be easily ported to systems with
  *              different data bus widths by redefining 'datum'.
  *
- * 
+ *
  * Copyright (c) 1998 by Michael Barr.  This software is placed into
  * the public domain and may be used for any purpose.  However, this
  * notice must not be changed or removed and no warranty is either
@@ -27,9 +27,9 @@
  *              within that region.  The address (and hence the
  *              memory region) is selected by the caller.
  *
- * Notes:       
+ * Notes:
  *
- * Returns:     0 if the test succeeds.  
+ * Returns:     0 if the test succeeds.
  *              A non-zero result is the first pattern that failed.
  *
  **********************************************************************/
@@ -52,7 +52,7 @@ memTestDataBus(volatile datum * address)
         /*
          * Read it back (immediately is okay for this test).
          */
-        if (*address != pattern) 
+        if (*address != pattern)
         {
             return (pattern);
         }
@@ -76,19 +76,19 @@ memTestDataBus(volatile datum * address)
  *
  * Notes:       For best results, the selected base address should
  *              have enough LSB 0's to guarantee single address bit
- *              changes.  For example, to test a 64-Kbyte region, 
- *              select a base address on a 64-Kbyte boundary.  Also, 
- *              select the region size as a power-of-two--if at all 
+ *              changes.  For example, to test a 64-Kbyte region,
+ *              select a base address on a 64-Kbyte boundary.  Also,
+ *              select the region size as a power-of-two--if at all
  *              possible.
  *
- * Returns:     NULL if the test succeeds.  
+ * Returns:     NULL if the test succeeds.
  *              A non-zero result is the first address at which an
  *              aliasing problem was uncovered.  By examining the
  *              contents of memory, it may be possible to gather
  *              additional information about the problem.
  *
  **********************************************************************/
-datum * 
+datum *
 memTestAddressBus(volatile datum * baseAddress, unsigned long nBytes)
 {
     unsigned long addressMask = (nBytes/sizeof(datum) - 1);
@@ -107,7 +107,7 @@ memTestAddressBus(volatile datum * baseAddress, unsigned long nBytes)
         baseAddress[offset] = pattern;
     }
 
-    /* 
+    /*
      * Check for address bits stuck high.
      */
     testOffset = 0;
@@ -130,10 +130,10 @@ memTestAddressBus(volatile datum * baseAddress, unsigned long nBytes)
     {
         baseAddress[testOffset] = antipattern;
 
-		if (baseAddress[0] != pattern)
-		{
-			return ((datum *) &baseAddress[testOffset]);
-		}
+        if (baseAddress[0] != pattern)
+        {
+            return ((datum *) &baseAddress[testOffset]);
+        }
 
         for (offset = 1; (offset & addressMask) != 0; offset <<= 1)
         {
@@ -157,12 +157,12 @@ memTestAddressBus(volatile datum * baseAddress, unsigned long nBytes)
  *
  * Description: Test the integrity of a physical memory device by
  *              performing an increment/decrement test over the
- *              entire region.  In the process every storage bit 
+ *              entire region.  In the process every storage bit
  *              in the device is tested as a zero and a one.  The
  *              base address and the size of the region are
  *              selected by the caller.
  *
- * Notes:       
+ * Notes:
  *
  * Returns:     NULL if the test succeeds.
  *
@@ -172,8 +172,8 @@ memTestAddressBus(volatile datum * baseAddress, unsigned long nBytes)
  *              additional information about the problem.
  *
  **********************************************************************/
-datum * 
-memTestDevice(volatile datum * baseAddress, unsigned long nBytes)	
+datum *
+memTestDevice(volatile datum * baseAddress, unsigned long nBytes)
 {
     unsigned long offset;
     unsigned long nWords = nBytes / sizeof(datum);