[pcsx_rearmed.git] / plugins / dfsound / spu_c64x.c

/*
 * SPU processing offload to TI C64x DSP using bsp's c64_tools
 * (C) Gražvydas "notaz" Ignotas, 2015
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy of
 *  this software and associated documentation files (the "Software"), to deal in
 *  the Software without restriction, including without limitation the rights to
 *  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 *  of the Software, and to permit persons to whom the Software is furnished to do
 *  so, subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in all
 *  copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 *  SOFTWARE.
 */

#include <dlfcn.h>
#include <stddef.h>
#include <unistd.h>

#include <inc_libc64_mini.h>
#include "spu_c64x.h"

static struct {
 void *handle;
 int  (*dsp_open)(void);
 dsp_mem_region_t (*dsp_shm_alloc)(dsp_cache_t _type, sU32 _numBytes);
 int  (*dsp_shm_free)(dsp_mem_region_t _mem);
 void (*dsp_close)(void);
 int  (*dsp_component_load)(const char *_path, const char *_name, dsp_component_id_t *_id);
 int  (*dsp_cache_inv_virt)(void *_virtAddr, sU32 _size);
 int  (*dsp_rpc_send)(const dsp_msg_t *_msgTo);
 int  (*dsp_rpc_recv)(dsp_msg_t *_msgFrom);
 int  (*dsp_rpc)(const dsp_msg_t *_msgTo, dsp_msg_t *_msgFrom);
 void (*dsp_logbuf_print)(void);

 dsp_mem_region_t region;
 dsp_component_id_t compid;
 unsigned int stale_caches:1;
 unsigned int req_sent:1;
} f;

static noinline void dsp_fault(void)
{
 dsp_msg_t msg;

 f.dsp_cache_inv_virt(worker, sizeof(*worker));
 printf("dsp crash/fault/corruption:\n");
 printf("state rdy/reap/done: %u %u %u\n",
   worker->i_ready, worker->i_reaped, worker->i_done);
 printf("active/boot: %u %u\n",
   worker->active, worker->boot_cnt);

 if (f.req_sent) {
  f.dsp_rpc_recv(&msg);
  f.req_sent = 0;
 }
 f.dsp_logbuf_print();
 spu_config.iUseThread = 0;
}

static void thread_work_start(void)
{
 struct region_mem *mem;
 dsp_msg_t msg;
 int ret;

 // make sure new work is written out
 __sync_synchronize();

 // this should be safe, as dsp checks for new work even
 // after it decrements ->active
 // cacheline: i_done, active
 f.dsp_cache_inv_virt(&worker->i_done, 64);
 if (worker->active == ACTIVE_CNT)
  return;

 // to start the DSP, dsp_rpc_send() must be used,
 // but before that, previous request must be finished
 if (f.req_sent) {
  if (worker->boot_cnt == worker->last_boot_cnt) {
   // hopefully still booting
   //printf("booting?\n");
   return;
  }

  ret = f.dsp_rpc_recv(&msg);
  if (ret != 0) {
   fprintf(stderr, "dsp_rpc_recv failed: %d\n", ret);
   f.dsp_logbuf_print();
   f.req_sent = 0;
   spu_config.iUseThread = 0;
   return;
  }
 }

 f.dsp_cache_inv_virt(&worker->i_done, 64);
 worker->last_boot_cnt = worker->boot_cnt;
 worker->ram_dirty = spu.bMemDirty;
 spu.bMemDirty = 0;

 mem = (void *)f.region.virt_addr;
 memcpy(&mem->in.spu_config, &spu_config, sizeof(mem->in.spu_config));

 DSP_MSG_INIT(&msg, f.compid, CCMD_DOIT, f.region.phys_addr, 0);
 ret = f.dsp_rpc_send(&msg);
 if (ret != 0) {
  fprintf(stderr, "dsp_rpc_send failed: %d\n", ret);
  f.dsp_logbuf_print();
  spu_config.iUseThread = 0;
  return;
 }
 f.req_sent = 1;

#if 0
 f.dsp_rpc_recv(&msg);
 f.req_sent = 0;
#endif
}

static int thread_get_i_done(void)
{
 f.dsp_cache_inv_virt(&worker->i_done, sizeof(worker->i_done));
 return worker->i_done;
}

static void thread_work_wait_sync(struct work_item *work, int force)
{
 int limit = 1000;
 int ns_to;

 if ((unsigned int)(worker->i_done - worker->i_reaped) > WORK_MAXCNT) {
  dsp_fault();
  return;
 }

 while (worker->i_done == worker->i_reaped && limit-- > 0) {
  if (!f.req_sent) {
   printf("dsp: req not sent?\n");
   break;
  }

  if (worker->boot_cnt != worker->last_boot_cnt && !worker->active) {
   printf("dsp: broken sync\n");
   worker->last_boot_cnt = ~0;
   break;
  }

  usleep(500);
  f.dsp_cache_inv_virt(&worker->i_done, 64);
 }

 ns_to = work->ns_to;
 f.dsp_cache_inv_virt(work->SSumLR, sizeof(work->SSumLR[0]) * 2 * ns_to);
 preload(work->SSumLR);
 preload(work->SSumLR + 64/4);

 f.stale_caches = 1; // SB, spuMem

 if (limit == 0)
  printf("dsp: wait timeout\n");

 // still in results loop?
 if (worker->i_reaped != worker->i_done - 1)
  return;

 if (f.req_sent && (force || worker->i_done == worker->i_ready)) {
  dsp_msg_t msg;
  int ret;

  ret = f.dsp_rpc_recv(&msg);
  if (ret != 0) {
   fprintf(stderr, "dsp_rpc_recv failed: %d\n", ret);
   f.dsp_logbuf_print();
   spu_config.iUseThread = 0;
  }
  f.req_sent = 0;
 }
}

static void thread_sync_caches(void)
{
 if (f.stale_caches) {
  f.dsp_cache_inv_virt(spu.SB, sizeof(spu.SB[0]) * SB_SIZE * 24);
  f.dsp_cache_inv_virt(spu.spuMemC + 0x800, 0x800);
  if (spu.rvb->StartAddr) {
   int left = 0x40000 - spu.rvb->StartAddr;
   f.dsp_cache_inv_virt(spu.spuMem + spu.rvb->StartAddr, left * 2);
  }
  f.stale_caches = 0;
 }
}

static void init_spu_thread(void)
{
 dsp_msg_t init_msg, msg_in;
 struct region_mem *mem;
 int ret;

 if (f.handle == NULL) {
  const char lib[] = "libc64.so.1";
  int failed = 0;

  f.handle = dlopen(lib, RTLD_NOW);
  if (f.handle == NULL) {
   fprintf(stderr, "can't load %s: %s\n", lib, dlerror());
   goto fail_open;
  }
  #define LDS(name) \
    failed |= (f.name = dlsym(f.handle, #name)) == NULL
  LDS(dsp_open);
  LDS(dsp_close);
  LDS(dsp_shm_alloc);
  LDS(dsp_shm_free);
  LDS(dsp_cache_inv_virt);
  LDS(dsp_component_load);
  LDS(dsp_rpc_send);
  LDS(dsp_rpc_recv);
  LDS(dsp_rpc);
  LDS(dsp_logbuf_print);
  #undef LDS
  if (failed) {
   fprintf(stderr, "missing symbol(s) in %s\n", lib);
   dlclose(f.handle);
   f.handle = NULL;
   goto fail_open;
  }
 }

 ret = f.dsp_open();
 if (ret != 0) {
  fprintf(stderr, "dsp_open failed: %d\n", ret);
  goto fail_open;
 }

 ret = f.dsp_component_load(NULL, COMPONENT_NAME, &f.compid);
 if (ret != 0) {
  fprintf(stderr, "dsp_component_load failed: %d\n", ret);
  goto fail_cload;
 }

 f.region = f.dsp_shm_alloc(DSP_CACHE_R, sizeof(*mem)); // writethrough
 if (f.region.size < sizeof(*mem) || f.region.virt_addr == 0) {
  fprintf(stderr, "dsp_shm_alloc failed\n");
  goto fail_mem;
 }
 mem = (void *)f.region.virt_addr;

 memcpy(&mem->in.spu_config, &spu_config, sizeof(mem->in.spu_config));

 DSP_MSG_INIT(&init_msg, f.compid, CCMD_INIT, f.region.phys_addr, 0);
 ret = f.dsp_rpc(&init_msg, &msg_in);
 if (ret != 0) {
  fprintf(stderr, "dsp_rpc failed: %d\n", ret);
  goto fail_init;
 }

 if (mem->sizeof_region_mem != sizeof(*mem)) {
  fprintf(stderr, "error: size mismatch 1: %d vs %zd\n",
    mem->sizeof_region_mem, sizeof(*mem));
  goto fail_init;
 }
 if (mem->offsetof_s_chan1 != offsetof(typeof(*mem), in.s_chan[1])) {
  fprintf(stderr, "error: size mismatch 2: %d vs %zd\n",
    mem->offsetof_s_chan1, offsetof(typeof(*mem), in.s_chan[1]));
  goto fail_init;
 }
 if (mem->offsetof_spos_3_20 != offsetof(typeof(*mem), worker.i[3].ch[20])) {
  fprintf(stderr, "error: size mismatch 3: %d vs %zd\n",
    mem->offsetof_spos_3_20, offsetof(typeof(*mem), worker.i[3].ch[20]));
  goto fail_init;
 }

 // override default allocations
 free(spu.spuMemC);
 spu.spuMemC = mem->spu_ram;
 free(spu.SB);
 spu.SB = mem->SB;
 free(spu.s_chan);
 spu.s_chan = mem->in.s_chan;
 free(spu.rvb);
 spu.rvb = &mem->in.rvb;
 worker = &mem->worker;

 printf("spu: C64x DSP ready (id=%d).\n", (int)f.compid);
 f.dsp_logbuf_print();

 spu_config.iThreadAvail = 1;
 (void)do_channel_work; // used by DSP instead
 return;

fail_init:
 f.dsp_shm_free(f.region);
fail_mem:
 // no component unload func?
fail_cload:
 f.dsp_logbuf_print();
 f.dsp_close();
fail_open:
 printf("spu: C64x DSP init failed.\n");
 spu_config.iUseThread = spu_config.iThreadAvail = 0;
 worker = NULL;
}

static void exit_spu_thread(void)
{
 dsp_msg_t msg;

 if (worker == NULL)
  return;

 if (f.req_sent) {
  f.dsp_rpc_recv(&msg);
  f.req_sent = 0;
 }

 f.dsp_logbuf_print();
 f.dsp_shm_free(f.region);
 f.dsp_close();

 spu.spuMemC = NULL;
 spu.SB = NULL;
 spu.s_chan = NULL;
 spu.rvb = NULL;
 worker = NULL;
}

/* debug: "access" shared mem from gdb */
#if 0
struct region_mem *dbg_dsp_mem;

void dbg_dsp_mem_update(void)
{
 struct region_mem *mem;

 if (dbg_dsp_mem == NULL)
  dbg_dsp_mem = malloc(sizeof(*dbg_dsp_mem));
 if (dbg_dsp_mem == NULL)
  return;

 mem = (void *)f.region.virt_addr;
 f.dsp_cache_inv_virt(mem, sizeof(*mem));
 memcpy(dbg_dsp_mem, mem, sizeof(*dbg_dsp_mem));
}
#endif

// vim:shiftwidth=1:expandtab
Commit	Line	Data
	1	/*
	2	* SPU processing offload to TI C64x DSP using bsp's c64_tools
	3	* (C) Gražvydas "notaz" Ignotas, 2015
	4	*
	5	* Permission is hereby granted, free of charge, to any person obtaining a copy of
	6	* this software and associated documentation files (the "Software"), to deal in
	7	* the Software without restriction, including without limitation the rights to
	8	* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
	9	* of the Software, and to permit persons to whom the Software is furnished to do
	10	* so, subject to the following conditions:
	11	*
	12	* The above copyright notice and this permission notice shall be included in all
	13	* copies or substantial portions of the Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	16	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	18	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	19	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	20	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	21	* SOFTWARE.
	22	*/
	23
	24	#include <dlfcn.h>
	25	#include <stddef.h>
	26	#include <unistd.h>
	27
	28	#include <inc_libc64_mini.h>
	29	#include "spu_c64x.h"
	30
	31	static struct {
	32	void *handle;
	33	int (*dsp_open)(void);
	34	dsp_mem_region_t (*dsp_shm_alloc)(dsp_cache_t _type, sU32 _numBytes);
	35	int (*dsp_shm_free)(dsp_mem_region_t _mem);
	36	void (*dsp_close)(void);
	37	int (dsp_component_load)(const char _path, const char _name, dsp_component_id_t _id);
	38	int (dsp_cache_inv_virt)(void _virtAddr, sU32 _size);
	39	int (dsp_rpc_send)(const dsp_msg_t _msgTo);
	40	int (dsp_rpc_recv)(dsp_msg_t _msgFrom);
	41	int (dsp_rpc)(const dsp_msg_t _msgTo, dsp_msg_t *_msgFrom);
	42	void (*dsp_logbuf_print)(void);
	43
	44	dsp_mem_region_t region;
	45	dsp_component_id_t compid;
	46	unsigned int stale_caches:1;
	47	unsigned int req_sent:1;
	48	} f;
	49
	50	static noinline void dsp_fault(void)
	51	{
	52	dsp_msg_t msg;
	53
	54	f.dsp_cache_inv_virt(worker, sizeof(*worker));
	55	printf("dsp crash/fault/corruption:\n");
	56	printf("state rdy/reap/done: %u %u %u\n",
	57	worker->i_ready, worker->i_reaped, worker->i_done);
	58	printf("active/boot: %u %u\n",
	59	worker->active, worker->boot_cnt);
	60
	61	if (f.req_sent) {
	62	f.dsp_rpc_recv(&msg);
	63	f.req_sent = 0;
	64	}
	65	f.dsp_logbuf_print();
	66	spu_config.iUseThread = 0;
	67	}
	68
	69	static void thread_work_start(void)
	70	{
	71	struct region_mem *mem;
	72	dsp_msg_t msg;
	73	int ret;
	74
	75	// make sure new work is written out
	76	__sync_synchronize();
	77
	78	// this should be safe, as dsp checks for new work even
	79	// after it decrements ->active
	80	// cacheline: i_done, active
	81	f.dsp_cache_inv_virt(&worker->i_done, 64);
	82	if (worker->active == ACTIVE_CNT)
	83	return;
	84
	85	// to start the DSP, dsp_rpc_send() must be used,
	86	// but before that, previous request must be finished
	87	if (f.req_sent) {
	88	if (worker->boot_cnt == worker->last_boot_cnt) {
	89	// hopefully still booting
	90	//printf("booting?\n");
	91	return;
	92	}
	93
	94	ret = f.dsp_rpc_recv(&msg);
	95	if (ret != 0) {
	96	fprintf(stderr, "dsp_rpc_recv failed: %d\n", ret);
	97	f.dsp_logbuf_print();
	98	f.req_sent = 0;
	99	spu_config.iUseThread = 0;
	100	return;
	101	}
	102	}
	103
	104	f.dsp_cache_inv_virt(&worker->i_done, 64);
	105	worker->last_boot_cnt = worker->boot_cnt;
	106	worker->ram_dirty = spu.bMemDirty;
	107	spu.bMemDirty = 0;
	108
	109	mem = (void *)f.region.virt_addr;
	110	memcpy(&mem->in.spu_config, &spu_config, sizeof(mem->in.spu_config));
	111
	112	DSP_MSG_INIT(&msg, f.compid, CCMD_DOIT, f.region.phys_addr, 0);
	113	ret = f.dsp_rpc_send(&msg);
	114	if (ret != 0) {
	115	fprintf(stderr, "dsp_rpc_send failed: %d\n", ret);
	116	f.dsp_logbuf_print();
	117	spu_config.iUseThread = 0;
	118	return;
	119	}
	120	f.req_sent = 1;
	121
	122	#if 0
	123	f.dsp_rpc_recv(&msg);
	124	f.req_sent = 0;
	125	#endif
	126	}
	127
	128	static int thread_get_i_done(void)
	129	{
	130	f.dsp_cache_inv_virt(&worker->i_done, sizeof(worker->i_done));
	131	return worker->i_done;
	132	}
	133
	134	static void thread_work_wait_sync(struct work_item *work, int force)
	135	{
	136	int limit = 1000;
	137	int ns_to;
	138
	139	if ((unsigned int)(worker->i_done - worker->i_reaped) > WORK_MAXCNT) {
	140	dsp_fault();
	141	return;
	142	}
	143
	144	while (worker->i_done == worker->i_reaped && limit-- > 0) {
	145	if (!f.req_sent) {
	146	printf("dsp: req not sent?\n");
	147	break;
	148	}
	149
	150	if (worker->boot_cnt != worker->last_boot_cnt && !worker->active) {
	151	printf("dsp: broken sync\n");
	152	worker->last_boot_cnt = ~0;
	153	break;
	154	}
	155
	156	usleep(500);
	157	f.dsp_cache_inv_virt(&worker->i_done, 64);
	158	}
	159
	160	ns_to = work->ns_to;
	161	f.dsp_cache_inv_virt(work->SSumLR, sizeof(work->SSumLR[0]) * 2 * ns_to);
	162	preload(work->SSumLR);
	163	preload(work->SSumLR + 64/4);
	164
	165	f.stale_caches = 1; // SB, spuMem
	166
	167	if (limit == 0)
	168	printf("dsp: wait timeout\n");
	169
	170	// still in results loop?
	171	if (worker->i_reaped != worker->i_done - 1)
	172	return;
	173
	174	if (f.req_sent && (force \|\| worker->i_done == worker->i_ready)) {
	175	dsp_msg_t msg;
	176	int ret;
	177
	178	ret = f.dsp_rpc_recv(&msg);
	179	if (ret != 0) {
	180	fprintf(stderr, "dsp_rpc_recv failed: %d\n", ret);
	181	f.dsp_logbuf_print();
	182	spu_config.iUseThread = 0;
	183	}
	184	f.req_sent = 0;
	185	}
	186	}
	187
	188	static void thread_sync_caches(void)
	189	{
	190	if (f.stale_caches) {
	191	f.dsp_cache_inv_virt(spu.SB, sizeof(spu.SB[0]) * SB_SIZE * 24);
	192	f.dsp_cache_inv_virt(spu.spuMemC + 0x800, 0x800);
	193	if (spu.rvb->StartAddr) {
	194	int left = 0x40000 - spu.rvb->StartAddr;
	195	f.dsp_cache_inv_virt(spu.spuMem + spu.rvb->StartAddr, left * 2);
	196	}
	197	f.stale_caches = 0;
	198	}
	199	}
	200
	201	static void init_spu_thread(void)
	202	{
	203	dsp_msg_t init_msg, msg_in;
	204	struct region_mem *mem;
	205	int ret;
	206
	207	if (f.handle == NULL) {
	208	const char lib[] = "libc64.so.1";
	209	int failed = 0;
	210
	211	f.handle = dlopen(lib, RTLD_NOW);
	212	if (f.handle == NULL) {
	213	fprintf(stderr, "can't load %s: %s\n", lib, dlerror());
	214	goto fail_open;
	215	}
	216	#define LDS(name) \
	217	failed \|= (f.name = dlsym(f.handle, #name)) == NULL
	218	LDS(dsp_open);
	219	LDS(dsp_close);
	220	LDS(dsp_shm_alloc);
	221	LDS(dsp_shm_free);
	222	LDS(dsp_cache_inv_virt);
	223	LDS(dsp_component_load);
	224	LDS(dsp_rpc_send);
	225	LDS(dsp_rpc_recv);
	226	LDS(dsp_rpc);
	227	LDS(dsp_logbuf_print);
	228	#undef LDS
	229	if (failed) {
	230	fprintf(stderr, "missing symbol(s) in %s\n", lib);
	231	dlclose(f.handle);
	232	f.handle = NULL;
	233	goto fail_open;
	234	}
	235	}
	236
	237	ret = f.dsp_open();
	238	if (ret != 0) {
	239	fprintf(stderr, "dsp_open failed: %d\n", ret);
	240	goto fail_open;
	241	}
	242
	243	ret = f.dsp_component_load(NULL, COMPONENT_NAME, &f.compid);
	244	if (ret != 0) {
	245	fprintf(stderr, "dsp_component_load failed: %d\n", ret);
	246	goto fail_cload;
	247	}
	248
	249	f.region = f.dsp_shm_alloc(DSP_CACHE_R, sizeof(*mem)); // writethrough
	250	if (f.region.size < sizeof(*mem) \|\| f.region.virt_addr == 0) {
	251	fprintf(stderr, "dsp_shm_alloc failed\n");
	252	goto fail_mem;
	253	}
	254	mem = (void *)f.region.virt_addr;
	255
	256	memcpy(&mem->in.spu_config, &spu_config, sizeof(mem->in.spu_config));
	257
	258	DSP_MSG_INIT(&init_msg, f.compid, CCMD_INIT, f.region.phys_addr, 0);
	259	ret = f.dsp_rpc(&init_msg, &msg_in);
	260	if (ret != 0) {
	261	fprintf(stderr, "dsp_rpc failed: %d\n", ret);
	262	goto fail_init;
	263	}
	264
	265	if (mem->sizeof_region_mem != sizeof(*mem)) {
	266	fprintf(stderr, "error: size mismatch 1: %d vs %zd\n",
	267	mem->sizeof_region_mem, sizeof(*mem));
	268	goto fail_init;
	269	}
	270	if (mem->offsetof_s_chan1 != offsetof(typeof(*mem), in.s_chan[1])) {
	271	fprintf(stderr, "error: size mismatch 2: %d vs %zd\n",
	272	mem->offsetof_s_chan1, offsetof(typeof(*mem), in.s_chan[1]));
	273	goto fail_init;
	274	}
	275	if (mem->offsetof_spos_3_20 != offsetof(typeof(*mem), worker.i[3].ch[20])) {
	276	fprintf(stderr, "error: size mismatch 3: %d vs %zd\n",
	277	mem->offsetof_spos_3_20, offsetof(typeof(*mem), worker.i[3].ch[20]));
	278	goto fail_init;
	279	}
	280
	281	// override default allocations
	282	free(spu.spuMemC);
	283	spu.spuMemC = mem->spu_ram;
	284	free(spu.SB);
	285	spu.SB = mem->SB;
	286	free(spu.s_chan);
	287	spu.s_chan = mem->in.s_chan;
	288	free(spu.rvb);
	289	spu.rvb = &mem->in.rvb;
	290	worker = &mem->worker;
	291
	292	printf("spu: C64x DSP ready (id=%d).\n", (int)f.compid);
	293	f.dsp_logbuf_print();
	294
	295	spu_config.iThreadAvail = 1;
	296	(void)do_channel_work; // used by DSP instead
	297	return;
	298
	299	fail_init:
	300	f.dsp_shm_free(f.region);
	301	fail_mem:
	302	// no component unload func?
	303	fail_cload:
	304	f.dsp_logbuf_print();
	305	f.dsp_close();
	306	fail_open:
	307	printf("spu: C64x DSP init failed.\n");
	308	spu_config.iUseThread = spu_config.iThreadAvail = 0;
	309	worker = NULL;
	310	}
	311
	312	static void exit_spu_thread(void)
	313	{
	314	dsp_msg_t msg;
	315
	316	if (worker == NULL)
	317	return;
	318
	319	if (f.req_sent) {
	320	f.dsp_rpc_recv(&msg);
	321	f.req_sent = 0;
	322	}
	323
	324	f.dsp_logbuf_print();
	325	f.dsp_shm_free(f.region);
	326	f.dsp_close();
	327
	328	spu.spuMemC = NULL;
	329	spu.SB = NULL;
	330	spu.s_chan = NULL;
	331	spu.rvb = NULL;
	332	worker = NULL;
	333	}
	334
	335	/* debug: "access" shared mem from gdb */
	336	#if 0
	337	struct region_mem *dbg_dsp_mem;
	338
	339	void dbg_dsp_mem_update(void)
	340	{
	341	struct region_mem *mem;
	342
	343	if (dbg_dsp_mem == NULL)
	344	dbg_dsp_mem = malloc(sizeof(*dbg_dsp_mem));
	345	if (dbg_dsp_mem == NULL)
	346	return;
	347
	348	mem = (void *)f.region.virt_addr;
	349	f.dsp_cache_inv_virt(mem, sizeof(*mem));
	350	memcpy(dbg_dsp_mem, mem, sizeof(*dbg_dsp_mem));
	351	}
	352	#endif
	353
	354	// vim:shiftwidth=1:expandtab