From 66157307d8a41c8099a19dae0d05e5ce92f92644 Mon Sep 17 00:00:00 2001 From: ggf906 Date: Sat, 16 Dec 2017 18:01:11 +0100 Subject: [PATCH 1/3] (PSP) Add thread support --- Makefile.psp1 | 3 ++- frontend/drivers/platform_psp.c | 5 +++-- libretro-common/rthreads/rthreads.c | 2 -- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Makefile.psp1 b/Makefile.psp1 index 31f5751f74..e259356495 100644 --- a/Makefile.psp1 +++ b/Makefile.psp1 @@ -4,7 +4,7 @@ DEBUG = 0 HAVE_KERNEL_PRX = 1 HAVE_LOGGER = 0 HAVE_FILE_LOGGER = 0 -HAVE_THREADS = 0 +HAVE_THREADS = 1 BIG_STACK = 0 WHOLE_ARCHIVE_LINK = 0 @@ -33,6 +33,7 @@ LIBS = $(WHOLE_START) -lretro_psp1 $(WHOLE_END) -lstdc++ -lpspgu -lpspgum -lm -l ifeq ($(HAVE_THREADS), 1) RARCH_DEFINES += -DHAVE_THREADS +LIBS += -lpthread-psp endif ifeq ($(HAVE_FILE_LOGGER), 1) diff --git a/frontend/drivers/platform_psp.c b/frontend/drivers/platform_psp.c index 6a08e8e1bb..9b61c2ca62 100644 --- a/frontend/drivers/platform_psp.c +++ b/frontend/drivers/platform_psp.c @@ -26,7 +26,6 @@ #include #include #include -#include #include "../../bootstrap/vita/sbrk.c" #include "../../bootstrap/vita/threading.c" @@ -39,6 +38,8 @@ #include #endif +#include + #include #include #include @@ -288,7 +289,6 @@ static void frontend_psp_init(void *data) #ifdef VITA scePowerSetArmClockFrequency(444); sceSysmoduleLoadModule(SCE_SYSMODULE_NET); - pthread_init(); #else (void)data; /* initialize debug screen */ @@ -300,6 +300,7 @@ static void frontend_psp_init(void *data) pspFpuSetEnable(0); /* disable FPU exceptions */ scePowerSetClockFrequency(333,333,166); #endif + pthread_init(); #endif diff --git a/libretro-common/rthreads/rthreads.c b/libretro-common/rthreads/rthreads.c index b6e8978e77..ae52cc57a1 100644 --- a/libretro-common/rthreads/rthreads.c +++ b/libretro-common/rthreads/rthreads.c @@ -45,8 +45,6 @@ #endif #elif defined(GEKKO) #include "gx_pthread.h" -#elif defined(PSP) -#include "psp_pthread.h" #elif defined(__CELLOS_LV2__) #include #include From 961972a858f0a4481192e8b9e26338bcca982e89 Mon Sep 17 00:00:00 2001 From: ggf906 Date: Sat, 16 Dec 2017 18:01:47 +0100 Subject: [PATCH 2/3] (PSP) (VITA) New rthreads audio driver --- audio/drivers/psp_audio.c | 299 +++++++++++++++----------------------- 1 file changed, 116 insertions(+), 183 deletions(-) diff --git a/audio/drivers/psp_audio.c b/audio/drivers/psp_audio.c index 49c3362440..3a2526972b 100644 --- a/audio/drivers/psp_audio.c +++ b/audio/drivers/psp_audio.c @@ -20,6 +20,9 @@ #include #include +#include +#include + #ifdef VITA #include #include @@ -36,40 +39,28 @@ typedef struct psp_audio { bool nonblocking; - uint32_t* buffer; - uint32_t* zeroBuffer; - - SceUID thread; int rate; - volatile bool running; - volatile uint16_t read_pos; - volatile uint16_t write_pos; + size_t buffer_size; + size_t period_size; + + volatile bool running; + fifo_buffer_t *buffer; + sthread_t *worker_thread; + slock_t *fifo_lock; + scond_t *cond; + slock_t *cond_lock; -#ifdef VITA - char lock[32] __attribute__ ((aligned (8))); - char cond_lock[32] __attribute__ ((aligned (8))); - char cond[32] __attribute__ ((aligned (8))); -#else - SceUID lock; - SceUID cond; -#endif } psp_audio_t; #define AUDIO_OUT_COUNT 512u #define AUDIO_BUFFER_SIZE (1u<<13u) -#define AUDIO_BUFFER_SIZE_MASK (AUDIO_BUFFER_SIZE-1) -#ifdef VITA -#define PSP_THREAD_STOPPED SCE_THREAD_STOPPED -#else -#define SceKernelThreadInfo SceKernelThreadRunStatus -#define sceKernelGetThreadInfo sceKernelReferThreadRunStatus -#endif - -static int audioMainLoop(SceSize args, void* argp) +static void audioMainLoop(void *data) { - psp_audio_t* psp = *((psp_audio_t**)argp); + psp_audio_t* psp = (psp_audio_t*)data; + uint8_t *buf = (uint8_t *)calloc(1, psp->period_size); + #ifdef VITA int port = sceAudioOutOpenPort( SCE_AUDIO_OUT_PORT_TYPE_MAIN, AUDIO_OUT_COUNT, @@ -80,40 +71,22 @@ static int audioMainLoop(SceSize args, void* argp) while (psp->running) { - bool cond = false; - uint16_t read_pos = psp->read_pos; - uint16_t read_pos_2 = psp->read_pos; + size_t avail; + size_t fifo_size; + slock_lock(psp->fifo_lock); + avail = fifo_read_avail(psp->buffer); + fifo_size = MIN(psp->period_size, avail); + fifo_read(psp->buffer, buf, fifo_size); + scond_signal(psp->cond); + slock_unlock(psp->fifo_lock); + + /* If underrun, fill rest with silence. */ + memset(buf + fifo_size, 0, psp->period_size - fifo_size); #ifdef VITA - sceKernelLockLwMutex((struct SceKernelLwMutexWork*)&psp->lock, 1, 0); + sceAudioOutOutput(port, buf); #else - sceKernelWaitSema(psp->lock, 1, 0); -#endif - - cond = ((uint16_t)(psp->write_pos - read_pos) & AUDIO_BUFFER_SIZE_MASK) - < (AUDIO_OUT_COUNT * 2); - - if (!cond) - { - read_pos += AUDIO_OUT_COUNT; - read_pos &= AUDIO_BUFFER_SIZE_MASK; - psp->read_pos = read_pos; - } - -#ifdef VITA - sceKernelUnlockLwMutex((struct SceKernelLwMutexWork*)&psp->lock, 1); - sceKernelSignalLwCond((struct SceKernelLwCondWork*)&psp->cond); - - sceAudioOutOutput(port, - cond ? (psp->zeroBuffer) - : (psp->buffer + read_pos_2)); -#else - sceKernelSignalSema(psp->lock, 1); - if(!cond){ - sceKernelSignalSema(psp->cond, 1); - } - sceAudioSRCOutputBlocking(PSP_AUDIO_VOLUME_MAX, cond ? (psp->zeroBuffer) - : (psp->buffer + read_pos)); + sceAudioSRCOutputBlocking(PSP_AUDIO_VOLUME_MAX, buf); #endif } @@ -121,9 +94,14 @@ static int audioMainLoop(SceSize args, void* argp) sceAudioOutReleasePort(port); #else sceAudioSRCChRelease(); - sceKernelExitThread(0); #endif - return 0; + + slock_lock(psp->cond_lock); + psp->running = false; + scond_signal(psp->cond); + slock_unlock(psp->cond_lock); + free(buf); + return; } static void *psp_audio_init(const char *device, @@ -139,115 +117,99 @@ static void *psp_audio_init(const char *device, (void)device; (void)latency; + psp->buffer_size = AUDIO_BUFFER_SIZE * sizeof(uint32_t); + psp->period_size = AUDIO_OUT_COUNT * sizeof(uint32_t); - /* Cache aligned, not necessary but helpful. */ - psp->buffer = (uint32_t*) - memalign(64, AUDIO_BUFFER_SIZE * sizeof(uint32_t)); - memset(psp->buffer, 0, AUDIO_BUFFER_SIZE * sizeof(uint32_t)); - psp->zeroBuffer = (uint32_t*) - memalign(64, AUDIO_OUT_COUNT * sizeof(uint32_t)); - memset(psp->zeroBuffer, 0, AUDIO_OUT_COUNT * sizeof(uint32_t)); + psp->fifo_lock = slock_new(); + psp->cond_lock = slock_new(); + psp->cond = scond_new(); + psp->buffer = fifo_new(psp->buffer_size); - psp->read_pos = 0; - psp->write_pos = 0; psp->rate = rate; -#if defined(VITA) - - sceKernelCreateLwMutex((struct SceKernelLwMutexWork*)&psp->lock, "audio_get_lock", 0, 0, 0); - sceKernelCreateLwMutex((struct SceKernelLwMutexWork*)&psp->cond_lock, "audio_get_cond_lock", 0, 0, 0); - sceKernelCreateLwCond((struct SceKernelLwCondWork*)&psp->cond, "audio_get_cond", 0, (struct SceKernelLwMutexWork*)&psp->cond_lock, 0); - psp->thread = sceKernelCreateThread - ("audioMainLoop", audioMainLoop, 0x10000100, 0x10000, 0, 0, NULL); -#else - psp->cond=sceKernelCreateSema("audio_start_sema", 0, 0, 1, NULL); - psp->lock=sceKernelCreateSema("audio_lock_sema", 0, 1, 1, NULL); - psp->thread = sceKernelCreateThread - ("audioMainLoop", audioMainLoop, 0x08, 0x10000, 0, NULL); -#endif psp->nonblocking = false; psp->running = true; - sceKernelStartThread(psp->thread, sizeof(psp_audio_t*), &psp); + + psp->worker_thread = sthread_create(audioMainLoop, psp); return psp; } static void psp_audio_free(void *data) { - SceUInt timeout = 100000; psp_audio_t* psp = (psp_audio_t*)data; if(!psp) return; - psp->running = false; -#if defined(VITA) - sceKernelWaitThreadEnd(psp->thread, NULL, &timeout); - sceKernelDeleteLwMutex((struct SceKernelLwMutexWork*)&psp->lock); - sceKernelDeleteLwMutex((struct SceKernelLwMutexWork*)&psp->cond_lock); - sceKernelDeleteLwCond((struct SceKernelLwCondWork*)&psp->cond); -#else - sceKernelWaitThreadEnd(psp->thread, &timeout); - sceKernelDeleteSema(psp->lock); - sceKernelDeleteSema(psp->cond); -#endif - free(psp->buffer); - sceKernelDeleteThread(psp->thread); - free(psp->zeroBuffer); + if(psp->running){ + if (psp->worker_thread) + { + slock_lock(psp->cond_lock); + psp->running = false; + slock_unlock(psp->cond_lock); + sthread_join(psp->worker_thread); + } + if (psp->buffer) + fifo_free(psp->buffer); + if (psp->cond) + scond_free(psp->cond); + if (psp->fifo_lock) + slock_free(psp->fifo_lock); + if (psp->cond_lock) + slock_free(psp->cond_lock); + } + free(psp); } static ssize_t psp_audio_write(void *data, const void *buf, size_t size) { - psp_audio_t* psp = (psp_audio_t*)data; - uint16_t write_pos = psp->write_pos; - uint16_t sampleCount = size / sizeof(uint32_t); + psp_audio_t* psp = (psp_audio_t*)data; + if (!psp->running) + return -1; if (psp->nonblocking) { -//#ifdef VITA - if (AUDIO_BUFFER_SIZE - ((uint16_t) - (psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK) < size) - return 0; -//#endif - } + size_t avail; + size_t write_amt; -#ifdef VITA - while (AUDIO_BUFFER_SIZE - ((uint16_t) - (psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK) < size) - sceKernelWaitLwCond((struct SceKernelLwCondWork*)&psp->cond, 0); + slock_lock(psp->fifo_lock); + avail = fifo_write_avail(psp->buffer); + write_amt = MIN(avail, size); - sceKernelLockLwMutex((struct SceKernelLwMutexWork*)&psp->lock, 1, 0); -#else - while (AUDIO_BUFFER_SIZE - ((uint16_t) - (psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK) < size) - sceKernelWaitSema(psp->cond, 1, 0); - sceKernelWaitSema(psp->lock, 1, 0); -#endif + fifo_write(psp->buffer, buf, write_amt); + slock_unlock(psp->fifo_lock); - if((write_pos + sampleCount) > AUDIO_BUFFER_SIZE) - { - memcpy(psp->buffer + write_pos, buf, - (AUDIO_BUFFER_SIZE - write_pos) * sizeof(uint32_t)); - memcpy(psp->buffer, (uint32_t*) buf + - (AUDIO_BUFFER_SIZE - write_pos), - (write_pos + sampleCount - AUDIO_BUFFER_SIZE) * sizeof(uint32_t)); + return write_amt; } else - memcpy(psp->buffer + write_pos, buf, size); + { + size_t written = 0; + while (written < size && psp->running) + { + size_t avail; + slock_lock(psp->fifo_lock); + avail = fifo_write_avail(psp->buffer); - write_pos += sampleCount; - write_pos &= AUDIO_BUFFER_SIZE_MASK; - psp->write_pos = write_pos; - -#ifdef VITA - sceKernelUnlockLwMutex((struct SceKernelLwMutexWork*)&psp->lock, 1); - - return size; -#else - sceKernelSignalSema(psp->lock, 1); - - return size; -#endif + if (avail == 0) + { + slock_unlock(psp->fifo_lock); + slock_lock(psp->cond_lock); + if (psp->running) + scond_wait(psp->cond, psp->cond_lock); + slock_unlock(psp->cond_lock); + } + else + { + size_t write_amt = MIN(size - written, avail); + fifo_write(psp->buffer, + (const char*)buf + written, write_amt); + slock_unlock(psp->fifo_lock); + written += write_amt; + } + } + return written; + } } static bool psp_audio_alive(void *data) @@ -261,51 +223,32 @@ static bool psp_audio_alive(void *data) static bool psp_audio_stop(void *data) { - SceKernelThreadInfo info; - SceUInt timeout = 100000; psp_audio_t* psp = (psp_audio_t*)data; - if(psp && !psp->running) + if (psp){ + psp->running = false; + + if (!psp->worker_thread) return true; - info.size = sizeof(SceKernelThreadInfo); - - if (sceKernelGetThreadInfo( - psp->thread, &info) < 0) /* Error */ - return false; - - if (info.status == PSP_THREAD_STOPPED) - return false; - - psp->running = false; -#if defined(VITA) - sceKernelWaitThreadEnd(psp->thread, NULL, &timeout); -#else - sceKernelWaitThreadEnd(psp->thread, &timeout); -#endif + sthread_join(psp->worker_thread); + psp->worker_thread = NULL; + } return true; } static bool psp_audio_start(void *data, bool is_shutdown) { - SceKernelThreadInfo info; psp_audio_t* psp = (psp_audio_t*)data; if(psp && psp->running) return true; - info.size = sizeof(SceKernelThreadInfo); - - if (sceKernelGetThreadInfo( - psp->thread, &info) < 0) /* Error */ - return false; - - if (info.status != PSP_THREAD_STOPPED) - return false; - - psp->running = true; - - sceKernelStartThread(psp->thread, sizeof(psp_audio_t*), &psp); + if (!psp->worker_thread) + { + psp->running = true; + psp->worker_thread = sthread_create(audioMainLoop, psp); + } return true; } @@ -328,21 +271,11 @@ static size_t psp_write_avail(void *data) size_t val; psp_audio_t* psp = (psp_audio_t*)data; -#ifdef VITA - sceKernelLockLwMutex((struct SceKernelLwMutexWork*)&psp->lock, 1, 0); -#else - sceKernelWaitSema(psp->lock, 1, 0); -#endif - - val = AUDIO_BUFFER_SIZE - ((uint16_t) - (psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK); - -#ifdef VITA - sceKernelUnlockLwMutex((struct SceKernelLwMutexWork*)&psp->lock, 1); -#else - sceKernelSignalSema(psp->lock, 1); -#endif - + if (!psp||!psp->running) + return 0; + slock_lock(psp->fifo_lock); + val = fifo_write_avail(psp->buffer); + slock_unlock(psp->fifo_lock); return val; } From c23d84c54f2c291b74d3bd09f495745b59f87331 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Francisco=20Jos=C3=A9=20Garc=C3=ADa=20Garc=C3=ADa?= Date: Tue, 26 Dec 2017 16:50:33 +0100 Subject: [PATCH 3/3] [VITA][PSP] New Audio Driver --- audio/drivers/psp_audio.c | 147 ++++++++++++++++++++------------------ 1 file changed, 78 insertions(+), 69 deletions(-) diff --git a/audio/drivers/psp_audio.c b/audio/drivers/psp_audio.c index 3a2526972b..ec0bfb43b2 100644 --- a/audio/drivers/psp_audio.c +++ b/audio/drivers/psp_audio.c @@ -39,13 +39,16 @@ typedef struct psp_audio { bool nonblocking; + uint32_t* buffer; + uint32_t* zeroBuffer; + + SceUID thread; int rate; - size_t buffer_size; - size_t period_size; - volatile bool running; - fifo_buffer_t *buffer; + volatile uint16_t read_pos; + volatile uint16_t write_pos; + sthread_t *worker_thread; slock_t *fifo_lock; scond_t *cond; @@ -55,11 +58,11 @@ typedef struct psp_audio #define AUDIO_OUT_COUNT 512u #define AUDIO_BUFFER_SIZE (1u<<13u) +#define AUDIO_BUFFER_SIZE_MASK (AUDIO_BUFFER_SIZE-1) static void audioMainLoop(void *data) { psp_audio_t* psp = (psp_audio_t*)data; - uint8_t *buf = (uint8_t *)calloc(1, psp->period_size); #ifdef VITA int port = sceAudioOutOpenPort( @@ -71,22 +74,34 @@ static void audioMainLoop(void *data) while (psp->running) { - size_t avail; - size_t fifo_size; - slock_lock(psp->fifo_lock); - avail = fifo_read_avail(psp->buffer); - fifo_size = MIN(psp->period_size, avail); - fifo_read(psp->buffer, buf, fifo_size); - scond_signal(psp->cond); - slock_unlock(psp->fifo_lock); + bool cond = false; + uint16_t read_pos = psp->read_pos; + uint16_t read_pos_2 = psp->read_pos; - /* If underrun, fill rest with silence. */ - memset(buf + fifo_size, 0, psp->period_size - fifo_size); + slock_lock(psp->fifo_lock); + + cond = ((uint16_t)(psp->write_pos - read_pos) & AUDIO_BUFFER_SIZE_MASK) + < (AUDIO_OUT_COUNT * 2); + + if (!cond) + { + read_pos += AUDIO_OUT_COUNT; + read_pos &= AUDIO_BUFFER_SIZE_MASK; + psp->read_pos = read_pos; + } + + slock_unlock(psp->fifo_lock); + slock_lock(psp->cond_lock); + scond_signal(psp->cond); + slock_unlock(psp->cond_lock); #ifdef VITA - sceAudioOutOutput(port, buf); + sceAudioOutOutput(port, + cond ? (psp->zeroBuffer) + : (psp->buffer + read_pos_2)); #else - sceAudioSRCOutputBlocking(PSP_AUDIO_VOLUME_MAX, buf); + sceAudioSRCOutputBlocking(PSP_AUDIO_VOLUME_MAX, cond ? (psp->zeroBuffer) + : (psp->buffer + read_pos)); #endif } @@ -96,11 +111,6 @@ static void audioMainLoop(void *data) sceAudioSRCChRelease(); #endif - slock_lock(psp->cond_lock); - psp->running = false; - scond_signal(psp->cond); - slock_unlock(psp->cond_lock); - free(buf); return; } @@ -117,19 +127,24 @@ static void *psp_audio_init(const char *device, (void)device; (void)latency; - psp->buffer_size = AUDIO_BUFFER_SIZE * sizeof(uint32_t); - psp->period_size = AUDIO_OUT_COUNT * sizeof(uint32_t); + /* Cache aligned, not necessary but helpful. */ + psp->buffer = (uint32_t*) + memalign(64, AUDIO_BUFFER_SIZE * sizeof(uint32_t)); + memset(psp->buffer, 0, AUDIO_BUFFER_SIZE * sizeof(uint32_t)); + psp->zeroBuffer = (uint32_t*) + memalign(64, AUDIO_OUT_COUNT * sizeof(uint32_t)); + memset(psp->zeroBuffer, 0, AUDIO_OUT_COUNT * sizeof(uint32_t)); + + psp->read_pos = 0; + psp->write_pos = 0; + psp->rate = rate; psp->fifo_lock = slock_new(); psp->cond_lock = slock_new(); psp->cond = scond_new(); - psp->buffer = fifo_new(psp->buffer_size); - - psp->rate = rate; psp->nonblocking = false; psp->running = true; - psp->worker_thread = sthread_create(audioMainLoop, psp); return psp; @@ -144,13 +159,10 @@ static void psp_audio_free(void *data) if(psp->running){ if (psp->worker_thread) { - slock_lock(psp->cond_lock); psp->running = false; - slock_unlock(psp->cond_lock); sthread_join(psp->worker_thread); } - if (psp->buffer) - fifo_free(psp->buffer); + if (psp->cond) scond_free(psp->cond); if (psp->fifo_lock) @@ -158,58 +170,54 @@ static void psp_audio_free(void *data) if (psp->cond_lock) slock_free(psp->cond_lock); } - + free(psp->buffer); + psp->worker_thread = NULL; + free(psp->zeroBuffer); free(psp); } static ssize_t psp_audio_write(void *data, const void *buf, size_t size) { psp_audio_t* psp = (psp_audio_t*)data; + uint16_t write_pos = psp->write_pos; + uint16_t sampleCount = size / sizeof(uint32_t); + if (!psp->running) return -1; if (psp->nonblocking) { - size_t avail; - size_t write_amt; + if (AUDIO_BUFFER_SIZE - ((uint16_t) + (psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK) < size) + return 0; + } - slock_lock(psp->fifo_lock); - avail = fifo_write_avail(psp->buffer); - write_amt = MIN(avail, size); + slock_lock(psp->cond_lock); + while (AUDIO_BUFFER_SIZE - ((uint16_t) + (psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK) < size) + scond_wait(psp->cond, psp->cond_lock); + slock_unlock(psp->cond_lock); - fifo_write(psp->buffer, buf, write_amt); - slock_unlock(psp->fifo_lock); - - return write_amt; + slock_lock(psp->fifo_lock); + if((write_pos + sampleCount) > AUDIO_BUFFER_SIZE) + { + memcpy(psp->buffer + write_pos, buf, + (AUDIO_BUFFER_SIZE - write_pos) * sizeof(uint32_t)); + memcpy(psp->buffer, (uint32_t*) buf + + (AUDIO_BUFFER_SIZE - write_pos), + (write_pos + sampleCount - AUDIO_BUFFER_SIZE) * sizeof(uint32_t)); } else - { - size_t written = 0; - while (written < size && psp->running) - { - size_t avail; - slock_lock(psp->fifo_lock); - avail = fifo_write_avail(psp->buffer); + memcpy(psp->buffer + write_pos, buf, size); - if (avail == 0) - { - slock_unlock(psp->fifo_lock); - slock_lock(psp->cond_lock); - if (psp->running) - scond_wait(psp->cond, psp->cond_lock); - slock_unlock(psp->cond_lock); - } - else - { - size_t write_amt = MIN(size - written, avail); - fifo_write(psp->buffer, - (const char*)buf + written, write_amt); - slock_unlock(psp->fifo_lock); - written += write_amt; - } - } - return written; - } + write_pos += sampleCount; + write_pos &= AUDIO_BUFFER_SIZE_MASK; + psp->write_pos = write_pos; + + slock_unlock(psp->fifo_lock); + return size; + + } static bool psp_audio_alive(void *data) @@ -274,7 +282,8 @@ static size_t psp_write_avail(void *data) if (!psp||!psp->running) return 0; slock_lock(psp->fifo_lock); - val = fifo_write_avail(psp->buffer); + val = AUDIO_BUFFER_SIZE - ((uint16_t) + (psp->write_pos - psp->read_pos) & AUDIO_BUFFER_SIZE_MASK); slock_unlock(psp->fifo_lock); return val; }