1 #include <atomic>
2 #include <string>
3 #include <unordered_map>
4 #include <vector>
5 #include <3ds.h>
6 #include <arpa/inet.h>
7 #include <malloc.h>
8 #include <stdio.h>
9 #include <string.h>
10 #include <sys/socket.h>
11
12 #include "cdc_bin.h"
13
14 PrintConsole topScreen, bottomScreen;
15
MoveCursor(unsigned row,unsigned col)16 void MoveCursor(unsigned row, unsigned col) {
17 printf("\x1b[%u;%uH", row + 1, col + 1);
18 }
19
20 enum Color {
21 Reset = 0,
22 Black = 30,
23 Red = 31,
24 Green = 32,
25 Yellow = 33,
26 Blue = 34,
27 Magnenta = 35,
28 Cyan = 36,
29 White = 37,
30 };
SetColor(Color color,Color background)31 void SetColor(Color color, Color background) {
32 printf("\x1b[%dm\x1b[%dm", (int)color, (int)background + 10);
33 }
34
FlushCache(volatile void * ptr,u32 size)35 void FlushCache(volatile void* ptr, u32 size) {
36 svcFlushProcessDataCache(CUR_PROCESS_HANDLE, (void*)ptr, size);
37 }
38
InvalidateCache(volatile void * ptr,u32 size)39 void InvalidateCache(volatile void* ptr, u32 size) {
40 svcInvalidateProcessDataCache(CUR_PROCESS_HANDLE, (void*)ptr, size);
41 }
42
43 vu16* dspP = (vu16*)0x1FF00000;
44 vu16* dspD = (vu16*)0x1FF40000;
45
46 std::atomic<int> interrupt_counter;
47
PrintAll()48 void PrintAll() {
49 consoleSelect(&topScreen);
50
51 MoveCursor(0, 0);
52 printf("DSP registers:\n");
53
54 InvalidateCache(dspD + 0, 2 * 2);
55
56 printf("st1 = %04X\n", dspD[0]);
57 printf("mgc = %04X\n", dspD[1]);
58
59 consoleSelect(&bottomScreen);
60 }
61
62 int udp_s;
63 int udp_s_broadcast;
64
UdpInit()65 void UdpInit() {
66 #define SOC_ALIGN 0x1000
67 #define SOC_BUFFERSIZE 0x100000
68 static u32* SOC_buffer;
69 // allocate buffer for SOC service
70 SOC_buffer = (u32*)memalign(SOC_ALIGN, SOC_BUFFERSIZE);
71 if (SOC_buffer == NULL) {
72 printf("memalign: failed to allocate\n");
73 return;
74 }
75
76 Result ret;
77 if ((ret = socInit(SOC_buffer, SOC_BUFFERSIZE)) != 0) {
78 printf("socInit: 0x%08lX\n", ret);
79 return;
80 }
81
82 sockaddr_in si_me;
83
84 // create a UDP socket
85 if ((udp_s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
86 printf("socket() failed\n");
87 return;
88 }
89
90 // zero out the structure
91 memset(&si_me, 0, sizeof(si_me));
92
93 si_me.sin_family = AF_INET;
94 si_me.sin_port = htons(8888);
95 si_me.sin_addr.s_addr = htonl(INADDR_ANY);
96
97 // bind socket to port
98 if (bind(udp_s, (sockaddr*)&si_me, sizeof(si_me)) == -1) {
99 printf("bind() failed\n");
100 return;
101 }
102
103 // create a UDP broadcast socket
104 if ((udp_s_broadcast = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) {
105 printf("socket()(broadcast) failed\n");
106 return;
107 }
108 }
109
110 constexpr unsigned BUFLEN = 512;
111 char buf[BUFLEN];
112
Fire()113 void Fire() {
114 dspD[0] = 1;
115 FlushCache((void*)dspD, 8);
116 while (true) {
117 InvalidateCache((void*)dspD, 8);
118 if (dspD[0] == 0)
119 break;
120 }
121 }
122
CheckPackage()123 void CheckPackage() {
124 sockaddr_in si_other;
125 socklen_t slen = sizeof(si_other);
126 int recv_len;
127 if ((recv_len = recvfrom(udp_s, buf, BUFLEN, MSG_DONTWAIT, (sockaddr*)&si_other, &slen)) < 4)
128 return;
129 u16 magic;
130 memcpy(&magic, buf, 2);
131 if (magic == 0xD592) {
132 std::vector<u16> command_package((recv_len - 2) / 2);
133 printf("Command received\n");
134 memcpy(command_package.data(), buf + 2, command_package.size() * 2);
135 switch (command_package[0]) {
136 case 0: {
137 if (command_package.size() != 2) {
138 printf("Wrong length for Read\n");
139 break;
140 }
141 u16 addr = command_package[1];
142 printf("Read [%04X] -> ", addr);
143 dspD[1] = 0;
144 dspD[2] = addr;
145 dspD[3] = 0xCCCC;
146
147 Fire();
148
149 printf("%04X\n", dspD[3]);
150 break;
151 }
152 case 1: {
153 if (command_package.size() != 3) {
154 printf("Wrong length for Write\n");
155 break;
156 }
157 u16 addr = command_package[1];
158 u16 value = command_package[2];
159 printf("Write [%04X] <- %04X", addr, value);
160 dspD[1] = 1;
161 dspD[2] = addr;
162 dspD[3] = value;
163
164 Fire();
165
166 printf(" OK\n");
167 break;
168 }
169 case 2: {
170 if (command_package.size() != 3) {
171 printf("Wrong length for CPU Read\n");
172 break;
173 }
174 u32 addr = command_package[1] | ((u32)command_package[2] << 16);
175 printf("Read CPU [%08lX] -> ", addr);
176 // FlushCache((vu16*)addr, 2);
177 printf("%04X\n", *(vu16*)(addr));
178 break;
179 }
180 case 3: {
181 if (command_package.size() != 4) {
182 printf("Wrong length for CPU Write\n");
183 break;
184 }
185 u32 addr = command_package[1] | ((u32)command_package[2] << 16);
186 u16 value = command_package[3];
187 printf("Write CPU [%08lX] <- %04X", addr, value);
188 // InvalidateCache((vu16*)addr, 2);
189 *(vu16*)(addr) = value;
190 printf(" OK\n");
191 break;
192 }
193 }
194 }
195 }
196
197 Handle pmHandle;
pmInit_(void)198 Result pmInit_(void) {
199 Result res = srvGetServiceHandle(&pmHandle, "pm:app");
200 return res;
201 }
pmExit_(void)202 void pmExit_(void) {
203 svcCloseHandle(pmHandle);
204 }
205
PM_TerminateTitle(u64 tid,u64 timeout)206 Result PM_TerminateTitle(u64 tid, u64 timeout) {
207 Result ret = 0;
208 u32* cmdbuf = getThreadCommandBuffer();
209
210 cmdbuf[0] = IPC_MakeHeader(0x4, 4, 0);
211 cmdbuf[1] = tid & 0xFFFFFFFF;
212 cmdbuf[2] = tid >> 32;
213 cmdbuf[3] = timeout & 0xffffffff;
214 cmdbuf[4] = (timeout >> 32) & 0xffffffff;
215
216 if (R_FAILED(ret = svcSendSyncRequest(pmHandle)))
217 return ret;
218
219 return (Result)cmdbuf[1];
220 }
221
222 Handle dsp_interrupt;
223 Handle threadA;
224 u32 threadA_stack[0x400];
225
threadA_entry(void *)226 void threadA_entry(void*) {
227 while (true) {
228 svcWaitSynchronization(dsp_interrupt, INT64_MAX);
229 ++interrupt_counter;
230 }
231 }
232
main()233 int main() {
234 aptInit();
235 gfxInitDefault();
236
237 consoleInit(GFX_TOP, &topScreen);
238 consoleInit(GFX_BOTTOM, &bottomScreen);
239
240 consoleSelect(&bottomScreen);
241 printf("Hello!\n");
242
243 UdpInit();
244
245 printf("dspInit: %08lX\n", dspInit());
246 bool loaded = false;
247 printf("DSP_LoadComponent: %08lX\n",
248 DSP_LoadComponent(cdc_bin, cdc_bin_size, 0xFF, 0xFF, &loaded));
249 printf("loaded = %d\n", loaded);
250
251 svcSleepThread(1000000000);
252 char hostname[100];
253 gethostname(hostname, 100);
254 printf("IP: %s port: 8888\n", hostname);
255
256 pmInit_();
257 printf("PM_TerminateTitle(DSP): %08lX\n", PM_TerminateTitle(0x0004013000001a02, 0));
258 pmExit_();
259
260 svcCreateEvent(&dsp_interrupt, ResetType::RESET_ONESHOT);
261 interrupt_counter = 0;
262 svcCreateThread(&threadA, threadA_entry, 0x0, threadA_stack + 0x400, 4, 0xFFFFFFFE);
263 printf("BindInterrupt: %08lX\n", svcBindInterrupt(0x4A, dsp_interrupt, 4, 0));
264
265 // Main loop
266 while (aptMainLoop()) {
267 hidScanInput();
268
269 u32 kDown = hidKeysDown();
270
271 if (kDown & KEY_START)
272 break;
273
274 if (kDown & KEY_A)
275 printf("hello\n");
276
277 PrintAll();
278
279 // Flush and swap framebuffers
280 gfxFlushBuffers();
281 gfxSwapBuffers();
282
283 // Wait for VBlank
284 gspWaitForVBlank();
285 }
286 socExit();
287 dspExit();
288 gfxExit();
289 aptExit();
290 return 0;
291 }
292