~ubuntu-branches/ubuntu/vivid/emscripten/vivid

1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

#include "SpuFakeDma.h"

#include <LinearMath/btScalar.h> //for btAssert

//Disabling memcpy sometimes helps debugging DMA

#define USE_MEMCPY 1

#ifdef USE_MEMCPY

#endif

void* cellDmaLargeGetReadOnly(void *ls, uint64_t ea, uint32_t size, uint32_t tag, uint32_t tid, uint32_t rid)

{

#if defined (__SPU__) || defined (USE_LIBSPE2)

cellDmaLargeGet(ls,ea,size,tag,tid,rid);

return ls;

#else

return (void*)(ppu_address_t)ea;

#endif

}

void* cellDmaSmallGetReadOnly(void *ls, uint64_t ea, uint32_t size, uint32_t tag, uint32_t tid, uint32_t rid)

{

#if defined (__SPU__) || defined (USE_LIBSPE2)

mfc_get(ls,ea,size,tag,0,0);

return ls;

#else

return (void*)(ppu_address_t)ea;

#endif

}

void* cellDmaGetReadOnly(void *ls, uint64_t ea, uint32_t size, uint32_t tag, uint32_t tid, uint32_t rid)

{

#if defined (__SPU__) || defined (USE_LIBSPE2)

cellDmaGet(ls,ea,size,tag,tid,rid);

return ls;

#else

return (void*)(ppu_address_t)ea;

#endif

}

///this unalignedDma should not be frequently used, only for small data. It handles alignment and performs check on size (<16 bytes)

int stallingUnalignedDmaSmallGet(void *ls, uint64_t ea, uint32_t size)

{

btAssert(size<32);

ATTRIBUTE_ALIGNED16(char tmpBuffer[32]);

char* localStore = (char*)ls;

uint32_t i;

///make sure last 4 bits are the same, for cellDmaSmallGet

uint32_t last4BitsOffset = ea & 0x0f;

char* tmpTarget = tmpBuffer + last4BitsOffset;

#if defined (__SPU__) || defined (USE_LIBSPE2)

int remainingSize = size;

//#define FORCE_cellDmaUnalignedGet 1

#ifdef FORCE_cellDmaUnalignedGet

cellDmaUnalignedGet(tmpTarget,ea,size,DMA_TAG(1),0,0);

#else

char* remainingTmpTarget = tmpTarget;

uint64_t remainingEa = ea;

while (remainingSize)

{

switch (remainingSize)

{

case 1:

case 2:

case 4:

case 8:

case 16:

{

mfc_get(remainingTmpTarget,remainingEa,remainingSize,DMA_TAG(1),0,0);

100

remainingSize=0;

101

break;

102

}

103

default:

104

{

105

//spu_printf("unaligned DMA with non-natural size:%d\n",remainingSize);

106

int actualSize = 0;

107

108

if (remainingSize > 16)

109

actualSize = 16;

110

else

111

if (remainingSize >8)

112

actualSize=8;

113

else

114

if (remainingSize >4)

115

actualSize=4;

116

else

117

if (remainingSize >2)

118

actualSize=2;

119

mfc_get(remainingTmpTarget,remainingEa,actualSize,DMA_TAG(1),0,0);

120

remainingSize-=actualSize;

121

remainingTmpTarget+=actualSize;

122

remainingEa += actualSize;

123

}

124

}

125

}

126

#endif//FORCE_cellDmaUnalignedGet

127

128

#else

129

char* mainMem = (char*)ea;

130

//copy into final destination

131

#ifdef USE_MEMCPY

132

133

memcpy(tmpTarget,mainMem,size);

134

#else

135

for ( i=0;i<size;i++)

136

{

137

tmpTarget[i] = mainMem[i];

138

}

139

#endif //USE_MEMCPY

140

141

#endif

142

143

cellDmaWaitTagStatusAll(DMA_MASK(1));

144

145

//this is slowish, perhaps memcpy on SPU is smarter?

146

for (i=0; btLikely( i<size );i++)

147

{

148

localStore[i] = tmpTarget[i];

149

}

150

151

return 0;

152

}

153

154

#if defined (__SPU__) || defined (USE_LIBSPE2)

155

#else

156

157

int cellDmaLargeGet(void *ls, uint64_t ea, uint32_t size, uint32_t tag, uint32_t tid, uint32_t rid)

158

{

159

char* mainMem = (char*)ea;

160

char* localStore = (char*)ls;

161

162

#ifdef USE_MEMCPY

163

memcpy(localStore,mainMem,size);

164

#else

165

for (uint32_t i=0;i<size;i++)

166

{

167

localStore[i] = mainMem[i];

168

}

169

#endif

170

return 0;

171

}

172

173

int cellDmaGet(void *ls, uint64_t ea, uint32_t size, uint32_t tag, uint32_t tid, uint32_t rid)

174

{

175

char* mainMem = (char*)ea;

176

char* localStore = (char*)ls;

177

178

// printf("mainMem=%x, localStore=%x",mainMem,localStore);

179

180

#ifdef USE_MEMCPY

181

memcpy(localStore,mainMem,size);

182

#else

183

for (uint32_t i=0;i<size;i++)

184

{

185

localStore[i] = mainMem[i];

186

}

187

#endif //#ifdef USE_MEMCPY

188

// printf(" finished\n");

189

return 0;

190

}

191

192

int cellDmaLargePut(const void *ls, uint64_t ea, uint32_t size, uint32_t tag, uint32_t tid, uint32_t rid)

193

{

194

char* mainMem = (char*)ea;

195

const char* localStore = (const char*)ls;

196

#ifdef USE_MEMCPY

197

memcpy(mainMem,localStore,size);

198

#else

199

for (uint32_t i=0;i<size;i++)

200

{

201

mainMem[i] = localStore[i];

202

}

203

#endif //#ifdef USE_MEMCPY

204

205

return 0;

206

}

207

208

209

210

void cellDmaWaitTagStatusAll(int ignore)

211

{

212

213

}

214

215

#endif

Older »