how to translate this from C [SOLVED]

[Key-Real]

Code: C  [Select][+][-]

1.  
2. IO_BASE    = 0xbf801000
3. DMA_GPU  = 2
4.  
5.  
6. #define _ADDR32(addr) ((volatile uint32_t *) (addr))
7. #define _MMIO32(addr) (*_ADDR32(addr))
8.  
9. #define DMA_MADR(N) _MMIO32((IO_BASE | 0x080) + (16 * (N)))
10. #define DMA_BCR(N)  _MMIO32((IO_BASE | 0x084) + (16 * (N)))
11. #define DMA_CHCR(N) _MMIO32((IO_BASE | 0x088) + (16 * (N)))
12.  
13. static void sendLinkedList(const void *data) {
14.  
15.         while (DMA_CHCR(DMA_GPU) & DMA_CHCR_ENABLE) __asm__ volatile("");
16.  
17.         DMA_MADR(DMA_GPU) = (uint32_t) data;
18.         DMA_CHCR(DMA_GPU) = 0 | DMA_CHCR_WRITE | DMA_CHCR_MODE_LIST | DMA_CHCR_ENABLE;
19. }
20.  
21.  
22. #define CHAIN_BUFFER_SIZE 1024
23.  
24. uint32_t gp0_tag(size_t length, void *next) {
25.         return 0
26.                 | (((uint32_t) next   & 0xffffff) <<  0)
27.                 | (((uint32_t) length & 0x0000ff) << 24);
28. }
29.  
30. uint32_t gp0_endTag(size_t length) {
31.         return gp0_tag(length, (void *) 0xffffff);
32. }
33.  
34. typedef struct {
35.         uint32_t data[CHAIN_BUFFER_SIZE];
36.         uint32_t *nextPacket;
37. } DMAChain;
38.  
39. uint32_t *allocatePacket(DMAChain *chain, int numCommands) {   
40.  
41.         uint32_t *ptr      = chain->nextPacket;
42.         chain->nextPacket += numCommands + 1;
43.  
44.         *ptr = gp0_tag(numCommands, chain->nextPacket);
45.  
46.         return &ptr[1];
47. }
48.  
49. int main() {
50.         DMAChain dmaChains[2];
51.         for (;;) {
52.                 DMAChain *chain  = &dmaChains[usingSecondFrame];
53.                
54.                 uint32_t *ptr;
55.  
56.                 // Reset the pointer to the next packet to the beginning of the buffer.
57.                 chain->nextPacket = chain->data;
58.  
59.                 ptr    = allocatePacket(chain, 4);
60.                 ptr[0] = 1;
61.                 ptr[1] = 2;
62.                 ptr[2] = 3;
63.                 ptr[3] = 4;
64.  
65.                 *(chain->nextPacket) = gp0_endTag(0);
66.  
67.                 sendLinkedList(chain->data);
68.         }
69.  

pls hlp

[superc]

I'm not a fan of ai and copy/paste, but it could be a starting point

Code: Pascal  [Select][+][-]

1. program PSX_DMA_GPU;
2.  
3. {$mode objfpc}{$H+}
4.  
5. uses
6.   ctypes;
7.  
8. const
9.   IO_BASE   = $BF801000;
10.   DMA_GPU   = 2;
11.  
12.   // CHCR flags (ipotizzati come in PSX SDK, da adattare se hai header precisi)
13.   DMA_CHCR_ENABLE    = $01000000;
14.   DMA_CHCR_WRITE     = $00000200;
15.   DMA_CHCR_MODE_LIST = $00000400;
16.  
17.   CHAIN_BUFFER_SIZE  = 1024;
18.  
19. type
20.   PDWORD = ^UInt32;
21.  
22. function _ADDR32(addr: PtrUInt): PDWORD; inline;
23. begin
24.   Result := PDWORD(addr);
25. end;
26.  
27. function _MMIO32(addr: PtrUInt): UInt32; inline;
28. begin
29.   Result := _ADDR32(addr)^;
30. end;
31.  
32. procedure _MMIO32_Set(addr: PtrUInt; value: UInt32); inline;
33. begin
34.   _ADDR32(addr)^ := value;
35. end;
36.  
37. // Macros DMA register
38. function DMA_MADR(N: Integer): PtrUInt; inline;
39. begin
40.   Result := (IO_BASE or $080) + (16 * N);
41. end;
42.  
43. function DMA_BCR(N: Integer): PtrUInt; inline;
44. begin
45.   Result := (IO_BASE or $084) + (16 * N);
46. end;
47.  
48. function DMA_CHCR(N: Integer): PtrUInt; inline;
49. begin
50.   Result := (IO_BASE or $088) + (16 * N);
51. end;
52.  
53. // Funzioni DMA
54. procedure sendLinkedList(data: Pointer);
55. begin
56.   // attende che DMA non sia busy
57.   while (_MMIO32(DMA_CHCR(DMA_GPU)) and DMA_CHCR_ENABLE) <> 0 do
58.   begin
59.     asm nop end;
60.   end;
61.  
62.   _MMIO32_Set(DMA_MADR(DMA_GPU), PtrUInt(data));
63.   _MMIO32_Set(DMA_CHCR(DMA_GPU), DMA_CHCR_WRITE or DMA_CHCR_MODE_LIST or DMA_CHCR_ENABLE);
64. end;
65.  
66. function gp0_tag(length: SizeUInt; next: Pointer): UInt32;
67. begin
68.   Result :=
69.     ((UInt32(PtrUInt(next)) and $FFFFFF) shl 0) or
70.     ((UInt32(length) and $FF) shl 24);
71. end;
72.  
73. function gp0_endTag(length: SizeUInt): UInt32;
74. begin
75.   Result := gp0_tag(length, Pointer($FFFFFF));
76. end;
77.  
78. type
79.   PDMAChain = ^TDMAChain;
80.   TDMAChain = record
81.     data: array[0..CHAIN_BUFFER_SIZE-1] of UInt32;
82.     nextPacket: ^UInt32;
83.   end;
84.  
85. function allocatePacket(chain: PDMAChain; numCommands: Integer): PUInt32;
86. var
87.   ptr: PUInt32;
88. begin
89.   ptr := chain^.nextPacket;
90.   Inc(chain^.nextPacket, numCommands + 1);
91.  
92.   ptr^ := gp0_tag(numCommands, chain^.nextPacket);
93.  
94.   Result := @ptr[1];
95. end;
96.  
97. var
98.   dmaChains: array[0..1] of TDMAChain;
99.   usingSecondFrame: Integer = 0;
100.  
101. var
102.   chain: PDMAChain;
103.   ptr: PUInt32;
104. begin
105.   while True do
106.   begin
107.     chain := @dmaChains[usingSecondFrame];
108.  
109.     // reset buffer
110.     chain^.nextPacket := @chain^.data[0];
111.  
112.     ptr := allocatePacket(chain, 4);
113.     ptr[0] := 1;
114.     ptr[1] := 2;
115.     ptr[2] := 3;
116.     ptr[3] := 4;
117.  
118.     chain^.nextPacket^ := gp0_endTag(0);
119.  
120.     sendLinkedList(@chain^.data[0]);
121.   end;
122. end.
123.  
124.  

[Key-Real]

Yes, this works, thx.

Now I have a clue about this memory mapping stuff

[Lauriet]

Whenever I see C code, I just shake my head and say "How the hell did this every get popular".
And I appreciate Pascal even more.