PS2SDK
PS2 Homebrew Libraries
Loading...
Searching...
No Matches
msifrpc.c
1/*
2# _____ ___ ____ ___ ____
3# ____| | ____| | | |____|
4# | ___| |____ ___| ____| | \ PS2DEV Open Source Project.
5#-----------------------------------------------------------------------
6# Copyright ps2dev - http://www.ps2dev.org
7# Licenced under Academic Free License version 2.0
8# Review ps2sdk README & LICENSE files for further details.
9*/
10
11#include "irx_imports.h"
12#include <kerr.h>
13#include <msifrpc.h>
14
15#ifdef _IOP
16IRX_ID("IOP_MSIF_rpc_interface", 2, 7);
17#endif
18// Based on the module from SCE SDK 3.1.0.
19
20typedef struct _sifm_receive_data
21{
22 sceSifMRpcData rpcd;
23 void *src;
24 void *dest;
25 int size;
26} sceSifMReceiveData;
27
28struct _sifm_smsg_data
29{
30 void *cl_paddr;
31 sceSifMRpcData *client;
32 void *local;
33 sceSifMServeEntry *sentry;
34 unsigned int buffersize;
35 unsigned int stacksize;
36 int prio;
37 sceSifMServeData *sd;
38};
39
40typedef struct _sifm_queue_data
41{
42 int key;
43 int active;
44 int sleep;
45 struct _sifm_serve_data *link;
46 struct _sifm_serve_data *start;
47 struct _sifm_serve_data *end;
48 struct _sifm_queue_data *next;
49} sceSifMQueueData;
50
51struct msif_data
52{
53 int field_0;
54 int m_rdata_table;
55 int m_rdata_table_len;
56 int m_client_table;
57 int m_client_table_len;
58 int m_rdata_table_idx;
59 sceSifMQueueData *m_active_queue;
60 int field_1C[2];
61 sceSifMServeEntry *g_mserv_entries_ll;
62};
63
64struct msif_msgbox_msg2
65{
66 void *m_pkt_addr;
67 sceSifMClientData *m_eebuf_cd;
68 struct msif_data *m_msif_data;
69 sceSifMServeEntry *m_mserve_entry;
70 int m_buffersize;
71 int m_stacksize;
72 int m_priority;
73 sceSifMServeData *m_sd;
74};
75
76struct msif_msgbox_msg
77{
78 int m_x1;
79 char m_probunused_unkx21;
80 char m_x22;
81 char m_x23;
82 char m_x24;
83 int m_in_cmd;
84 struct msif_msgbox_msg2 m_msg2;
85};
86
87typedef struct t_SifMRpcRendPkt
88{
89 struct t_SifCmdHeader sifcmd;
90 int rec_id;
91 void *pkt_addr;
92 int rpc_id;
93 sceSifMClientData *cd;
94 u32 cid;
95 sceSifMServeData *sd;
96 void *buf;
97 void *cbuf;
98} SifMRpcRendPkt_t;
99
100typedef struct t_SifMRpcBindPkt
101{
102 struct t_SifCmdHeader sifcmd;
103 int rec_id;
104 void *pkt_addr;
105 int rpc_id;
106 sceSifMClientData *cd;
107 int sid;
108 int m_eebuf_or_threadstate;
109 int m_eeserver;
110 int m_toee_unkxb;
111} SifMRpcBindPkt_t;
112
113typedef struct t_SifMRpcCallPkt
114{
115 struct t_SifCmdHeader sifcmd;
116 int rec_id;
117 void *pkt_addr;
118 int rpc_id;
119 sceSifMClientData *cd;
120 int rpc_number;
121 sceSifMServeData *sd;
122 void *recvbuf;
123 int recv_size;
124 int rmode;
125} SifMRpcCallPkt_t;
126
127struct msif_cmd_bindrpcparam_80000019
128{
129 int m_x01;
130 int m_x02;
131 int m_x03;
132 int m_x04;
133 int m_x05;
134 void *m_pkt_addr;
135 int m_x07;
136 sceSifMClientData *m_cd;
137 int m_fromee_cmd;
138 int m_buffersize;
139 int m_stacksize;
140 int m_priority;
141 int m_x13;
142 int m_x14;
143 int m_x15;
144 int m_x16;
145};
146
147struct msif_cmd_unbindrpc_8000001D
148{
149 int m_x01;
150 int m_x02;
151 int m_x03;
152 int m_x04;
153 int m_x05;
154 void *m_pkt_addr;
155 int m_x07;
156 sceSifMClientData *m_cd;
157 int m_command;
158 sceSifMServeData *m_sd;
159 int m_x11;
160 int m_x12;
161 int m_x13;
162 int m_x14;
163 int m_x15;
164 int m_x16;
165};
166
167struct msif_cmd_callrpc_8000001A
168{
169 int m_x01;
170 int m_x02;
171 int m_x03;
172 int m_x04;
173 int m_rid;
174 void *m_paddr;
175 int m_x07;
176 sceSifMClientData *m_cd;
177 int m_fno;
178 int m_size;
179 void *m_receive;
180 int m_rsize;
181 int m_rmode;
182 sceSifMServeData *m_sd;
183 int m_x15;
184 int m_x16;
185};
186
187static void sif_cmdh_bindrpcparam_80000019(struct msif_cmd_bindrpcparam_80000019 *data, struct msif_data *harg);
188static void sif_cmdh_unbindrpc_8000001D(struct msif_cmd_unbindrpc_8000001D *data, struct msif_data *harg);
189static void sif_cmdh_callrpc_8000001A(struct msif_cmd_callrpc_8000001A *data, struct msif_data *harg);
190
191extern struct irx_export_table _exp_msifrpc;
192// Unofficial: move to bss
193static int g_first_inited;
194static int g_pkt_table[512];
195static int g_client_table[512];
196static struct msif_data g_msif_data;
197
198int _start(int ac, char **av)
199{
200 (void)ac;
201 (void)av;
202 printf("Multi-thread available sifrpc module...\n");
203 return RegisterLibraryEntries(&_exp_msifrpc) ? MODULE_NO_RESIDENT_END : MODULE_RESIDENT_END;
204}
205
206void sceSifMInitRpc(unsigned int mode)
207{
208 int state;
209
210 (void)mode;
211 CpuSuspendIntr(&state);
212 if ( g_first_inited )
213 {
214 CpuResumeIntr(state);
215 while ( !sceSifGetSreg(1) )
216 {
217 int delayth_1;
218
219 delayth_1 = DelayThread(10000);
220 if ( delayth_1 )
221 printf("return value of DelayThread() is %d\n", delayth_1);
222 }
223 }
224 else
225 {
226 g_first_inited = 1;
227 g_msif_data.m_rdata_table = (int)g_pkt_table;
228 g_msif_data.m_rdata_table_len = 32;
229 g_msif_data.m_client_table = (int)g_client_table;
230 g_msif_data.m_client_table_len = 32;
231 g_msif_data.m_rdata_table_idx = 0;
232 g_msif_data.field_0 = 1;
233 g_msif_data.g_mserv_entries_ll = 0;
234 sceSifAddCmdHandler(0x80000019, (SifCmdHandler_t)sif_cmdh_bindrpcparam_80000019, &g_msif_data);
235 sceSifAddCmdHandler(0x8000001A, (SifCmdHandler_t)sif_cmdh_callrpc_8000001A, &g_msif_data);
236 sceSifAddCmdHandler(0x8000001D, (SifCmdHandler_t)sif_cmdh_unbindrpc_8000001D, &g_msif_data);
237 CpuResumeIntr(state);
238 g_pkt_table[4] = 1;
239 g_pkt_table[5] = 1;
240 while ( !sceSifSendCmd(0x80000001, g_pkt_table, 24, 0, 0, 0) )
241 DelayThread(0xF000);
242 while ( !sceSifGetSreg(1) )
243 {
244 int delayth_2;
245
246 delayth_2 = DelayThread(10000);
247 if ( delayth_2 )
248 printf("return value of DelayThread() is %d\n", delayth_2);
249 }
250 }
251}
252
253static int sif_mrpc_get_fpacket(struct msif_data *rpc_data)
254{
255 int m_rdata_table_idx;
256 int m_rdata_table_len;
257 int index_calc;
258
259 m_rdata_table_idx = rpc_data->m_rdata_table_idx;
260 m_rdata_table_len = rpc_data->m_rdata_table_len;
261 index_calc = m_rdata_table_idx % m_rdata_table_len;
262 if ( m_rdata_table_len == -1 && (unsigned int)m_rdata_table_idx == 0x80000000 )
263 __builtin_trap();
264 rpc_data->m_rdata_table_idx = index_calc + 1;
265 return rpc_data->m_rdata_table + (index_calc << 6);
266}
267
268static int sif_mrpc_get_fpacket2(struct msif_data *rpc_data, int rid)
269{
270 return (rid >= 0 && rid < rpc_data->m_client_table_len) ? (rpc_data->m_client_table + (rid << 6)) :
271 sif_mrpc_get_fpacket(rpc_data);
272}
273
274static sceSifMServeEntry *do_get_mserve_entry(int cmd, struct msif_data *msd)
275{
276 sceSifMServeEntry *g_mserv_entries_ll;
277
278 for ( g_mserv_entries_ll = msd->g_mserv_entries_ll; g_mserv_entries_ll && g_mserv_entries_ll->command != cmd;
279 g_mserv_entries_ll = g_mserv_entries_ll->next )
280 ;
281 return g_mserv_entries_ll;
282}
283
284static unsigned int alarm_cb_cmd_80000018_1(void *pkt)
285{
286 return isceSifSendCmd(0x80000018, pkt, 64, 0, 0, 0) ? 0 : 0xF000;
287}
288
289static void sif_cmdh_bindrpcparam_80000019(struct msif_cmd_bindrpcparam_80000019 *data, struct msif_data *harg)
290{
291 sceSifMServeEntry *mserve_entry;
292 SifMRpcBindPkt_t *fpacket;
293 iop_sys_clock_t sysclks;
294
295 mserve_entry = do_get_mserve_entry(data->m_fromee_cmd, harg);
296 if ( mserve_entry )
297 {
298 struct msif_msgbox_msg *msgdat;
299
300 msgdat = (struct msif_msgbox_msg *)AllocSysMemory(0, sizeof(struct msif_msgbox_msg), 0);
301 if ( !msgdat )
302 {
303 printf("AllocSysMemory() failed.\n");
304 // Unofficial: early return
305 return;
306 }
307 msgdat->m_probunused_unkx21 = 0;
308 msgdat->m_in_cmd = 0x80000019;
309 msgdat->m_msg2.m_pkt_addr = data->m_pkt_addr;
310 msgdat->m_msg2.m_msif_data = harg;
311 msgdat->m_msg2.m_mserve_entry = mserve_entry;
312 msgdat->m_msg2.m_eebuf_cd = data->m_cd;
313 msgdat->m_msg2.m_buffersize = data->m_buffersize;
314 msgdat->m_msg2.m_stacksize = data->m_stacksize;
315 msgdat->m_msg2.m_priority = data->m_priority;
316 iSendMbx(mserve_entry->mbxid, msgdat);
317 return;
318 }
319 fpacket = (SifMRpcBindPkt_t *)sif_mrpc_get_fpacket(harg);
320 fpacket->pkt_addr = data->m_pkt_addr;
321 fpacket->sid = 0x80000019;
322 fpacket->m_eebuf_or_threadstate = 0;
323 fpacket->m_eeserver = 0;
324 fpacket->m_toee_unkxb = 0;
325 fpacket->cd = data->m_cd;
326 if ( !isceSifSendCmd(0x80000018, fpacket, 64, 0, 0, 0) )
327 {
328 sysclks.hi = 0;
329 sysclks.lo = 0xF000;
330 iSetAlarm(&sysclks, (unsigned int (*)(void *))alarm_cb_cmd_80000018_1, fpacket);
331 }
332}
333
334static unsigned int alarm_cb_cmd_80000018_2(void *pkt)
335{
336 return isceSifSendCmd(0x80000018, pkt, 64, 0, 0, 0) ? 0 : 0xF000;
337}
338
339static void sif_cmdh_unbindrpc_8000001D(struct msif_cmd_unbindrpc_8000001D *data, struct msif_data *harg)
340{
341 sceSifMServeEntry *mserve_entry;
342 int threadstate_tmp;
343 SifMRpcBindPkt_t *fpacket;
344 iop_sys_clock_t alarmdat;
345
346 mserve_entry = do_get_mserve_entry(data->m_command, harg);
347 if ( !mserve_entry || (data->m_sd->sentry != mserve_entry) )
348 {
349 threadstate_tmp = 3;
350 }
351 else if ( !data->m_sd->base->sleep )
352 {
353 threadstate_tmp = 4;
354 }
355 else
356 {
357 struct msif_msgbox_msg *msgboxdat;
358
359 msgboxdat = (struct msif_msgbox_msg *)AllocSysMemory(0, sizeof(struct msif_msgbox_msg), 0);
360 if ( !msgboxdat )
361 {
362 printf("AllocSysMemory() failed.\n");
363 // Unofficial: early return
364 return;
365 }
366 msgboxdat->m_probunused_unkx21 = 0;
367 msgboxdat->m_in_cmd = 0x8000001D;
368 msgboxdat->m_msg2.m_pkt_addr = data->m_pkt_addr;
369 msgboxdat->m_msg2.m_msif_data = harg;
370 msgboxdat->m_msg2.m_mserve_entry = mserve_entry;
371 msgboxdat->m_msg2.m_sd = data->m_sd;
372 msgboxdat->m_msg2.m_eebuf_cd = data->m_cd;
373 iSendMbx(mserve_entry->mbxid, msgboxdat);
374 return;
375 }
376 fpacket = (SifMRpcBindPkt_t *)sif_mrpc_get_fpacket(harg);
377 fpacket->pkt_addr = data->m_pkt_addr;
378 fpacket->sid = 0x8000001D;
379 fpacket->m_eebuf_or_threadstate = threadstate_tmp;
380 fpacket->m_eeserver = 0;
381 fpacket->m_toee_unkxb = 0;
382 fpacket->cd = data->m_cd;
383 if ( !isceSifSendCmd(0x80000018, fpacket, 64, 0, 0, 0) )
384 {
385 alarmdat.hi = 0;
386 alarmdat.lo = 0xF000;
387 iSetAlarm(&alarmdat, (unsigned int (*)(void *))alarm_cb_cmd_80000018_2, fpacket);
388 }
389}
390
391static void sif_cmdh_callrpc_8000001A(struct msif_cmd_callrpc_8000001A *data, struct msif_data *harg)
392{
393 (void)harg;
394 if ( data->m_sd->base->start )
395 data->m_sd->base->end->next = data->m_sd;
396 else
397 data->m_sd->base->start = data->m_sd;
398 data->m_sd->base->end = data->m_sd;
399 data->m_sd->paddr = data->m_paddr;
400 data->m_sd->client = data->m_cd;
401 data->m_sd->fno = data->m_fno;
402 data->m_sd->size = data->m_size;
403 data->m_sd->receive = data->m_receive;
404 data->m_sd->rsize = data->m_rsize;
405 data->m_sd->rmode = data->m_rmode;
406 data->m_sd->rid = data->m_rid;
407 if ( data->m_sd->base->key >= 0 && !data->m_sd->base->active )
408 iWakeupThread(data->m_sd->base->key);
409}
410
411static void do_set_rpc_queue(sceSifMQueueData *qd, int key)
412{
413 sceSifMQueueData *i;
414 int state;
415
416 CpuSuspendIntr(&state);
417 qd->key = key;
418 qd->active = 0;
419 qd->link = 0;
420 qd->start = 0;
421 qd->end = 0;
422 qd->next = 0;
423 if ( g_msif_data.m_active_queue )
424 {
425 for ( i = g_msif_data.m_active_queue; i->next; i = i->next )
426 ;
427 i->next = qd;
428 }
429 else
430 {
431 g_msif_data.m_active_queue = qd;
432 }
433 CpuResumeIntr(state);
434}
435
436// Removed unused func
437
438static void do_msif_remove_rpc(sceSifMServeData *sd)
439{
440 sceSifMServeData *server1;
441 int state;
442
443 CpuSuspendIntr(&state);
444 server1 = sd->sentry->serve_list;
445 if ( server1 == sd )
446 {
447 sd->sentry->serve_list = server1->next;
448 }
449 else
450 {
451 const sceSifMServeData *server2;
452
453 server2 = server1;
454 while ( server2 )
455 {
456 server2 = server1->next;
457 if ( server2 == sd )
458 {
459 server1->next = sd->next;
460 break;
461 }
462 server1 = server1->next;
463 }
464 }
465 CpuResumeIntr(state);
466}
467
468static void do_sif_remove_rpc_queue(const sceSifMQueueData *qd)
469{
470 sceSifMQueueData *queue1;
471 sceSifMQueueData *queue2;
472 int state;
473
474 CpuSuspendIntr(&state);
475 queue1 = g_msif_data.m_active_queue;
476 if ( queue1 == qd )
477 {
478 g_msif_data.m_active_queue = queue1->next;
479 }
480 else
481 {
482 queue2 = queue1;
483 while ( queue2 )
484 {
485 queue2 = queue1->next;
486 if ( queue2 == qd )
487 {
488 queue1->next = queue2->next;
489 break;
490 }
491 queue1 = queue1->next;
492 }
493 }
494 CpuResumeIntr(state);
495}
496
497static struct _sifm_serve_data *do_msif_get_next_request(sceSifMQueueData *qd)
498{
499 sceSifMServeData *start;
500 int state;
501
502 CpuSuspendIntr(&state);
503 start = qd->start;
504 qd->active = start ? 1 : 0;
505 if ( start )
506 {
507 qd->start = start->next;
508 }
509 CpuResumeIntr(state);
510 return start;
511}
512
513static void do_msif_exec_request(sceSifMServeData *sd)
514{
515 int size_extra;
516 void *sentry_ret;
517 SifMRpcRendPkt_t *fpacket2;
518 int adddmat;
519 int state;
520
521 size_extra = 0;
522 sentry_ret = sd->sentry->func(sd->fno, sd->func_buff, sd->size);
523 if ( sentry_ret )
524 size_extra = sd->rsize;
525 CpuSuspendIntr(&state);
526 fpacket2 = (sd->rid & 4) ? (SifMRpcRendPkt_t *)sif_mrpc_get_fpacket2(&g_msif_data, (sd->rid >> 16) & 0xFFFF) :
527 (SifMRpcRendPkt_t *)sif_mrpc_get_fpacket(&g_msif_data);
528 CpuResumeIntr(state);
529 fpacket2->cid = 0x8000001A;
530 fpacket2->cd = sd->client;
531 adddmat = 0;
532 if ( sd->rmode )
533 {
534 while ( !sceSifSendCmd(0x80000018, fpacket2, 64, sentry_ret, sd->receive, size_extra) )
535 ;
536 }
537 else
538 {
539 SifDmaTransfer_t dmat[2];
540
541 fpacket2->rpc_id = 0;
542 fpacket2->rec_id = 0;
543 if ( size_extra > 0 )
544 {
545 adddmat = 1;
546 dmat[0].src = sentry_ret;
547 dmat[0].size = size_extra;
548 dmat[0].attr = 0;
549 dmat[0].dest = sd->receive;
550 }
551 dmat[adddmat].src = fpacket2;
552 dmat[adddmat].size = 64;
553 dmat[adddmat].attr = 0;
554 dmat[adddmat].dest = sd->paddr;
555 while ( 1 )
556 {
557 int dmaid;
558 int i;
559
560 CpuSuspendIntr(&state);
561 dmaid = sceSifSetDma(dmat, adddmat + 1);
562 CpuResumeIntr(state);
563 if ( dmaid )
564 break;
565 for ( i = 0xFFFF; i != 0; i -= 1 )
566 ;
567 }
568 }
569}
570
571static void do_msif_rpc_loop(sceSifMQueueData *qd)
572{
573 while ( 1 )
574 {
575 sceSifMServeData *next_request;
576
577 next_request = do_msif_get_next_request(qd);
578 if ( next_request )
579 {
580 do_msif_exec_request(next_request);
581 }
582 else
583 {
584 qd->sleep = 1;
585 SleepThread();
586 qd->sleep = 0;
587 }
588 }
589}
590
591static void thread_proc_80000019(struct msif_msgbox_msg *msgboxdat)
592{
593 sceSifMServeData *sd;
594 sceSifMQueueData *qd;
595 void *funcbuf;
596 SifMRpcCallPkt_t *fpacket;
597 int state;
598
599 CpuSuspendIntr(&state);
600 sd = (sceSifMServeData *)AllocSysMemory(0, sizeof(sceSifMServeData), 0);
601 if ( !sd )
602 printf("AllocSysMemory() failed.\n");
603 qd = (sceSifMQueueData *)AllocSysMemory(0, sizeof(sceSifMQueueData), 0);
604 if ( !qd )
605 printf("AllocSysMemory() failed.\n");
606 funcbuf = AllocSysMemory(0, msgboxdat->m_msg2.m_buffersize, 0);
607 if ( !funcbuf )
608 printf("AllocSysMemory() failed.\n");
609 CpuResumeIntr(state);
610 do_set_rpc_queue(qd, GetThreadId());
611 sd->func_buff = funcbuf;
612 sd->base = qd;
613 sd->next = 0;
614 sd->sentry = msgboxdat->m_msg2.m_mserve_entry;
615 qd->link = sd;
616 qd->sleep = 0;
617 CpuSuspendIntr(&state);
618 fpacket = (SifMRpcCallPkt_t *)sif_mrpc_get_fpacket(msgboxdat->m_msg2.m_msif_data);
619 CpuResumeIntr(state);
620 fpacket->pkt_addr = msgboxdat->m_msg2.m_pkt_addr;
621 fpacket->rpc_number = 0x80000019;
622 fpacket->sd = sd;
623 fpacket->recvbuf = funcbuf;
624 fpacket->recv_size = 0;
625 fpacket->cd = msgboxdat->m_msg2.m_eebuf_cd;
626 while ( !sceSifSendCmd(0x80000018, fpacket, 64, 0, 0, 0) )
627 DelayThread(0xF000);
628 CpuSuspendIntr(&state);
629 FreeSysMemory(msgboxdat);
630 CpuResumeIntr(state);
631 do_msif_rpc_loop(qd);
632}
633
634// Removed unused func
635
636void sceSifMEntryLoop(sceSifMServeEntry *se, int request, sceSifMRpcFunc func, sceSifMRpcFunc cfunc)
637{
638 sceSifMServeEntry *g_mserv_entries_ll;
639 int thid_1;
640 int termthread_1;
641 int delthread_1;
642 SifMRpcBindPkt_t *fpacket2;
643 iop_mbx_t mbxparam;
644 iop_thread_t thparam_1;
645 iop_thread_info_t thinfo;
646 int state;
647 struct msif_msgbox_msg *arg;
648
649 ReferThreadStatus(0, &thinfo);
650 ChangeThreadPriority(0, 16);
651 se->command = request;
652 se->func = func;
653 se->cfunc = cfunc;
654 se->next = 0;
655 se->serve_list = 0;
656 mbxparam.attr = MBA_THFIFO;
657 while ( 1 )
658 {
659 se->mbxid = CreateMbx(&mbxparam);
660 if ( se->mbxid )
661 break;
662 DelayThread(0xF000);
663 }
664 CpuSuspendIntr(&state);
665 g_mserv_entries_ll = g_msif_data.g_mserv_entries_ll;
666 if ( g_mserv_entries_ll )
667 {
668 while ( g_mserv_entries_ll->next )
669 g_mserv_entries_ll = g_mserv_entries_ll->next;
670 g_mserv_entries_ll->next = se;
671 }
672 else
673 {
674 g_msif_data.g_mserv_entries_ll = se;
675 }
676 CpuResumeIntr(state);
677 while ( 1 )
678 {
679 int mbxrecv;
680
681 mbxrecv = ReceiveMbx((void **)&arg, se->mbxid);
682 if ( mbxrecv )
683 {
684 if ( mbxrecv != KE_WAIT_DELETE )
685 {
686 printf("ReceiveMbx() failed.\n");
687 }
688 else
689 {
690 printf("msifrpc: quit\n");
691 ChangeThreadPriority(0, thinfo.currentPriority);
692 break;
693 }
694 }
695 switch ( arg->m_in_cmd )
696 {
697 case 0x80000019:
698 thparam_1.thread = (void (*)(void *))thread_proc_80000019;
699 thparam_1.attr = TH_C;
700 thparam_1.stacksize = arg->m_msg2.m_stacksize;
701 thparam_1.priority = arg->m_msg2.m_priority;
702 thid_1 = CreateThread(&thparam_1);
703 if ( thid_1 < 0 )
704 printf("StartThread() failed.\n");
705 else
706 StartThread(thid_1, arg);
707 break;
708 case 0x8000001D:
709 termthread_1 = TerminateThread(arg->m_msg2.m_sd->base->key);
710 if ( termthread_1 )
711 Kprintf("TerminateThread(): ret = %d\n", termthread_1);
712 delthread_1 = DeleteThread(arg->m_msg2.m_sd->base->key);
713 if ( delthread_1 )
714 {
715 if ( delthread_1 == KE_NOT_DORMANT )
716 delthread_1 = 2;
717 else
718 Kprintf("DeleteThread(): ret = %d\n", delthread_1);
719 }
720 else
721 {
722 delthread_1 = 1;
723 do_sif_remove_rpc_queue(arg->m_msg2.m_sd->base);
724 CpuSuspendIntr(&state);
725 FreeSysMemory(arg->m_msg2.m_sd->base);
726 FreeSysMemory(arg->m_msg2.m_sd->func_buff);
727 CpuResumeIntr(state);
728 do_msif_remove_rpc(arg->m_msg2.m_sd);
729 CpuSuspendIntr(&state);
730 FreeSysMemory(arg->m_msg2.m_sd);
731 CpuResumeIntr(state);
732 }
733 CpuSuspendIntr(&state);
734 fpacket2 =
735 (arg->m_msg2.m_sd->rid & 4) ?
736 (SifMRpcBindPkt_t *)sif_mrpc_get_fpacket2(arg->m_msg2.m_msif_data, (arg->m_msg2.m_sd->rid >> 16) & 0xFFFF) :
737 (SifMRpcBindPkt_t *)sif_mrpc_get_fpacket(arg->m_msg2.m_msif_data);
738 CpuResumeIntr(state);
739 fpacket2->pkt_addr = arg->m_msg2.m_pkt_addr;
740 fpacket2->sid = 0x8000001D;
741 fpacket2->m_eebuf_or_threadstate = delthread_1;
742 fpacket2->m_eeserver = 0;
743 fpacket2->m_toee_unkxb = 0;
744 fpacket2->cd = arg->m_msg2.m_eebuf_cd;
745 while ( !sceSifSendCmd(0x80000018, fpacket2, 64, 0, 0, 0) )
746 DelayThread(0xF000);
747 CpuSuspendIntr(&state);
748 FreeSysMemory(arg);
749 CpuResumeIntr(state);
750 break;
751 default:
752 break;
753 }
754 }
755}
756
757int sceSifMTermRpc(int request, int flags)
758{
759 sceSifMServeEntry *cur_entry;
760 sceSifMServeEntry *tmp_entry;
761 int state;
762
763 (void)flags;
764 CpuSuspendIntr(&state);
765 cur_entry = g_msif_data.g_mserv_entries_ll;
766 tmp_entry = 0;
767 while ( cur_entry && cur_entry->command != request )
768 {
769 tmp_entry = cur_entry;
770 cur_entry = cur_entry->next;
771 }
772 if ( cur_entry )
773 {
774 if ( tmp_entry )
775 tmp_entry->next = cur_entry->next;
776 else
777 g_msif_data.g_mserv_entries_ll = cur_entry->next;
778 }
779 CpuResumeIntr(state);
780 if ( cur_entry )
781 {
782 DeleteMbx(cur_entry->mbxid);
783 DelayThread(100000);
784 }
785 return 0;
786}
rpc_data
Definition sifrpc.c:39
CpuResumeIntr
int CpuResumeIntr(int state)
Definition intrman.c:227
CpuSuspendIntr
int CpuSuspendIntr(int *state)
Definition intrman.c:205
irx_export_table
Definition irx.h:90
t_SifCmdHeader
Definition sifcmd-common.h:23
t_SifDmaTransfer
Definition sifdma.h:53
_sifm_client_data
Definition msifrpc.h:25
_sifm_queue_data
Definition msifrpc.c:41
_sifm_receive_data
Definition msifrpc.c:21
_sifm_rpc_data
Definition msifrpc.h:15
_sifm_serve_data
Definition msifrpc.h:38
_sifm_serve_entry
Definition msifrpc.h:57
_sifm_smsg_data
Definition msifrpc.c:29
msif_cmd_bindrpcparam_80000019
Definition msifrpc.c:128
msif_cmd_callrpc_8000001A
Definition msifrpc.c:168
msif_cmd_unbindrpc_8000001D
Definition msifrpc.c:148
msif_data
Definition msifrpc.c:52
msif_msgbox_msg2
Definition msifrpc.c:65
msif_msgbox_msg
Definition msifrpc.c:77
t_SifMRpcBindPkt
Definition msifrpc.c:101
t_SifMRpcCallPkt
Definition msifrpc.c:114
t_SifMRpcRendPkt
Definition msifrpc.c:88
_iop_sys_clock
Definition thbase.h:88
_iop_thread
Definition thbase.h:40
_iop_thread_status
Definition thbase.h:69
iop_mbx_t
Definition thmsgbx.h:33