SDL

1
/*
2
  Simple DirectMedia Layer
3
  Copyright (C) 1997-2024 Sam Lantinga <slouken@libsdl.org>
4

5
  This software is provided 'as-is', without any express or implied
6
  warranty.  In no event will the authors be held liable for any damages
7
  arising from the use of this software.
8

9
  Permission is granted to anyone to use this software for any purpose,
10
  including commercial applications, and to alter it and redistribute it
11
  freely, subject to the following restrictions:
12

13
  1. The origin of this software must not be misrepresented; you must not
14
     claim that you wrote the original software. If you use this software
15
     in a product, an acknowledgment in the product documentation would be
16
     appreciated but is not required.
17
  2. Altered source versions must be plainly marked as such, and must not be
18
     misrepresented as being the original software.
19
  3. This notice may not be removed or altered from any source distribution.
20
*/
21
#include "SDL_internal.h"
22

23
#ifdef SDL_THREAD_PS2
24

25
// Semaphore functions for the PS2.
26

27
#include <stdio.h>
28
#include <stdlib.h>
29
#include <kernel_util.h>
30

31
#include <kernel.h>
32

33
struct SDL_Semaphore
34
{
35
    s32 semid;
36
};
37

38
// Create a semaphore
39
SDL_Semaphore *SDL_CreateSemaphore(Uint32 initial_value)
40
{
41
    SDL_Semaphore *sem;
42
    ee_sema_t sema;
43

44
    sem = (SDL_Semaphore *)SDL_malloc(sizeof(*sem));
45
    if (sem) {
46
        // TODO: Figure out the limit on the maximum value.
47
        sema.init_count = initial_value;
48
        sema.max_count = 255;
49
        sema.option = 0;
50
        sem->semid = CreateSema(&sema);
51

52
        if (sem->semid < 0) {
53
            SDL_SetError("Couldn't create semaphore");
54
            SDL_free(sem);
55
            sem = NULL;
56
        }
57
    }
58

59
    return sem;
60
}
61

62
// Free the semaphore
63
void SDL_DestroySemaphore(SDL_Semaphore *sem)
64
{
65
    if (sem) {
66
        if (sem->semid > 0) {
67
            DeleteSema(sem->semid);
68
            sem->semid = 0;
69
        }
70

71
        SDL_free(sem);
72
    }
73
}
74

75
SDL_bool SDL_WaitSemaphoreTimeoutNS(SDL_Semaphore *sem, Sint64 timeoutNS)
76
{
77
    u64 timeout_usec;
78
    u64 *timeout_ptr;
79

80
    if (!sem) {
81
        return true;
82
    }
83

84
    if (timeoutNS == 0) {
85
        return (PollSema(sem->semid) == 0);
86
    }
87

88
    timeout_ptr = NULL;
89

90
    if (timeoutNS != -1) {  // -1 == wait indefinitely.
91
        timeout_usec = SDL_NS_TO_US(timeoutNS);
92
        timeout_ptr = &timeout_usec;
93
    }
94

95
    return (WaitSemaEx(sem->semid, 1, timeout_ptr) == 0);
96
}
97

98
// Returns the current count of the semaphore
99
Uint32 SDL_GetSemaphoreValue(SDL_Semaphore *sem)
100
{
101
    ee_sema_t info;
102

103
    if (!sem) {
104
        return 0;
105
    }
106

107
    if (ReferSemaStatus(sem->semid, &info) == 0) {
108
        return info.count;
109
    }
110
    return 0;
111
}
112

113
void SDL_SignalSemaphore(SDL_Semaphore *sem)
114
{
115
    if (!sem) {
116
        return;
117
    }
118

119
    SignalSema(sem->semid);
120
}
121

122
#endif // SDL_THREAD_PS2
123