Advertisement
TerusTheBird

loader again

Feb 2nd, 2020
154
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2. #include <z64ovl/oot/u10.h>
  3.  
  4. typedef struct {
  5.     z64_actor_t actor;
  6. } entity_t;
  7.  
  8. typedef union {
  9.     struct { // meta commands
  10.         union {
  11.             struct { // set up data pointer
  12.                 volatile u8* ptr;
  13.                 u8  pad[6];
  14.             } c00_data;
  15.             struct { // write <= 9 bytes
  16.                 u8 bytes[ 9 ];
  17.                 u8 count;
  18.             } c01_data;
  19.             struct { // write N zeroes
  20.                 u32 number_of_zeroes;
  21.                 u8  padding[ 6 ];
  22.             } c02_data;
  23.             struct { // checksum/ack/nak
  24.                 // ?????
  25.             } c03_data;
  26.             struct { // jump to given function pointer
  27.                 void (*func_pointer)(void);
  28.                 u8 padding[ 6 ];
  29.             } c04_data;
  30.             u8 bytes[ 10 ];
  31.         };
  32.         u8 meta_command;
  33.     } meta;
  34.     struct { // DMA
  35.         u32* dest_ram;
  36.         u32* src_vrom;
  37.         u32  size:24;
  38.     } lowlevel;
  39.     u8  bytes[ 12 ]; // last byte is padding
  40. } pad_data_t;
  41. // 12 bytes long
  42.  
  43. // ????
  44. void (*const DmaMgr_SendRequest0)( u32* vram_addr, u32* vrom_addr, u32 size ) = (const void*)0x80001AA0;
  45.  
  46. static volatile u8* data_pointer;
  47. static pad_data_t pad;
  48.  
  49. static void step( entity_t* entity, z64_global_t* global ) {
  50.     #define padb( pad, byte ) ( ((u8*)&(global->common.input[ pad ].raw))[ byte ] )
  51.    
  52.     register union {
  53.         struct {
  54.             u8 big_endian_padding;
  55.             u8 ll_command;
  56.             u8 byte2;
  57.             u8 byte1;
  58.         };
  59.         u32 word;
  60.     } leftover;
  61.    
  62.     // only run if all pads are connected and working
  63.     if( global->common.input[ 1 ].status != 0 || global->common.input[ 2 ].status != 0 || global->common.input[ 3 ].status != 0 )
  64.         return;
  65.    
  66.     pad.bytes[ 0 ] = padb( 1, 0 );
  67.     pad.bytes[ 1 ] = padb( 1, 2 );
  68.     pad.bytes[ 2 ] = padb( 1, 3 );
  69.     pad.bytes[ 3 ] = padb( 2, 0 );
  70.     pad.bytes[ 4 ] = padb( 2, 2 );
  71.     pad.bytes[ 5 ] = padb( 2, 3 );
  72.     pad.bytes[ 6 ] = padb( 3, 0 );
  73.     pad.bytes[ 7 ] = padb( 3, 2 );
  74.     pad.bytes[ 8 ] = padb( 3, 3 );
  75.    
  76.     leftover.word   = padb( 1, 1 );
  77.     leftover.word <<= 6;
  78.     leftover.word  |= padb( 2, 1 );
  79.     leftover.word <<= 6;
  80.     leftover.word  |= padb( 3, 1 );
  81.     pad.bytes[  9 ] = leftover.byte1;
  82.     pad.bytes[ 10 ] = leftover.byte2;
  83.    
  84.     switch( leftover.ll_command ) {
  85.         case 0: break; // NOP
  86.         case 1: { // load 11 bytes
  87.             u8 i;
  88.             for( i = 0; i < 11; ++i )
  89.                 *(data_pointer++) = pad.bytes[ i ];
  90.         } break;
  91.         case 2: { // DMA copy
  92.             DmaMgr_SendRequest0( pad.lowlevel.dest_ram, pad.lowlevel.src_vrom, pad.lowlevel.size );
  93.         } break;
  94.         case 3: {
  95.             // -----------------------------------------------
  96.             switch( pad.meta.meta_command ) {
  97.                 case  0: { // load data pointer
  98.                     data_pointer = pad.meta.c00_data.ptr;
  99.                 } break;
  100.                 case  1: { // write <= 9 bytes
  101.                     u8 i;
  102.                     for( i = 0; i < pad.meta.c01_data.count; ++i )
  103.                         *( data_pointer++ ) = pad.meta.c01_data.bytes[ i ];
  104.                 } break;
  105.                 case  2: { // write N zeroes
  106.                     while( pad.meta.c02_data.number_of_zeroes > 0 ) {
  107.                         *( data_pointer++ ) = 0;
  108.                         --pad.meta.c02_data.number_of_zeroes;
  109.                     }
  110.                 } break;
  111.                 case  3: { // error correction
  112.                     // ????
  113.                 } break;
  114.                 case  4: { // jump to address
  115.                     pad.meta.c04_data.func_pointer();
  116.                 } break;
  117.                 default: break;
  118.             }
  119.             // -----------------------------------------------
  120.         } break;
  121.         default: break; // this should never happen
  122.     }
  123. }
  124.  
  125. const z64_actor_init_t init_vars = {
  126.     .number = 0xDEAD, .padding = 0xBEEF,
  127.     .type = 0x06, // stage prop
  128.     .room = 0x00,
  129.     .flags = 0x00000030,
  130.     .object = 1,
  131.     .instance_size = sizeof(entity_t),
  132.     .init = NULL,
  133.     .dest = NULL,
  134.     .main = step,
  135.     .draw = NULL
  136. };
Advertisement
RAW Paste Data Copied
Advertisement