vpdf/system/altivec.c

   1
   2 #include <proto/exec.h>
   3 #include <proto/utility.h>
   4 #include <exec/resident.h>
   5 #include <exec/system.h>
   6
   7 int hasAltivec = 0;
   8
   9 #include "altivec.h"
  10
  11 void setupAVExceptions(void)
  12 {
  13         ULONG a[ 4 ] __attribute((aligned( 16 )));
  14         vector unsigned short b;
  15         b = vec_mfvscr();
  16         vec_st(b, 0, (unsigned short *) a);
  17         a[ 3 ] |= 1 << 16;
  18         b = vec_ld(0, (unsigned short *)a);
  19         vec_mtvscr(b);
  20 }
  21
  22
  23 void AltivecInit( void )
  24 {
  25         struct Resident *MyResident;
  26
  27         MyResident = FindResident("MorphOS");
  28
  29         /* Altivec/VMX detection */
  30
  31         if (MyResident && (MyResident->rt_Version > 1 || ((MyResident->rt_Flags & RTF_EXTENDED) && MyResident->rt_Version == 1 && MyResident->rt_Revision >= 5)))
  32         {
  33                 struct TagItem MyTag = {TAG_DONE, 0};
  34                 NewGetSystemAttrsA(&hasAltivec, sizeof(hasAltivec), SYSTEMINFOTYPE_PPC_ALTIVEC, &MyTag);
  35         }
  36
  37         if (hasAltivec)
  38         {
  39                 setupAVExceptions();
  40         }
  41 }
  42
  43 ///     Altivec cache prewarming stuff
  44
  45 /*
  46  * blockcount: number of blocks (from 0 to 255, 0 = 256 blocks)
  47  * blocksize: number of 16-byte chunks (from 0 to 31, 0 = 32 * 16-byte chunks)
  48  * blockstride: 16-bit value from -32768 to 32767 (0 = 32768), denotes the address
  49  *   increment from the beginning of one block to the beginning of the next.
  50  */
  51
  52 static void cpu_vec_dst(CONST_APTR ptr, ULONG opts, ULONG channel)
  53 {
  54         switch (channel)
  55         {
  56                 case 0:
  57                         vec_dst((VECTOR_UBYTE *)ptr, opts, 0);
  58                         break;
  59
  60                 case 1:
  61                         vec_dst((VECTOR_UBYTE *)ptr, opts, 1);
  62                         break;
  63
  64                 case 2:
  65                         vec_dst((VECTOR_UBYTE *)ptr, opts, 2);
  66                         break;
  67
  68                 case 3:
  69                         vec_dst((VECTOR_UBYTE *)ptr, opts, 3);
  70                         break;
  71         }
  72 }
  73
  74 static void cpu_vec_dstt(CONST_APTR ptr, ULONG opts, ULONG channel)
  75 {
  76         switch (channel)
  77         {
  78                 case 0:
  79                         vec_dstt((VECTOR_UBYTE *)ptr, opts, 0);
  80                         break;
  81
  82                 case 1:
  83                         vec_dstt((VECTOR_UBYTE *)ptr, opts, 1);
  84                         break;
  85
  86                 case 2:
  87                         vec_dstt((VECTOR_UBYTE *)ptr, opts, 2);
  88                         break;
  89
  90                 case 3:
  91                         vec_dstt((VECTOR_UBYTE *)ptr, opts, 3);
  92                         break;
  93         }
  94 }
  95
  96
  97 static void cpu_vec_dstst(CONST_APTR ptr, ULONG opts, ULONG channel)
  98 {
  99         switch (channel)
 100         {
 101                 case 0:
 102                         vec_dstst((VECTOR_UBYTE *)ptr, opts, 0);
 103                         break;
 104
 105                 case 1:
 106                         vec_dstst((VECTOR_UBYTE *)ptr, opts, 1);
 107                         break;
 108
 109                 case 2:
 110                         vec_dstst((VECTOR_UBYTE *)ptr, opts, 2);
 111                         break;
 112
 113                 case 3:
 114                         vec_dstst((VECTOR_UBYTE *)ptr, opts, 3);
 115                         break;
 116         }
 117 }
 118
 119
 120 static void cpu_vec_dststt(CONST_APTR ptr, ULONG opts, ULONG channel)
 121 {
 122         switch (channel)
 123         {
 124                 case 0:
 125                         vec_dststt((VECTOR_UBYTE *)ptr, opts, 0);
 126                         break;
 127
 128                 case 1:
 129                         vec_dststt((VECTOR_UBYTE *)ptr, opts, 1);
 130                         break;
 131
 132                 case 2:
 133                         vec_dststt((VECTOR_UBYTE *)ptr, opts, 2);
 134                         break;
 135
 136                 case 3:
 137                         vec_dststt((VECTOR_UBYTE *)ptr, opts, 3);
 138                         break;
 139         }
 140 }
 141
 142
 143 static void cpu_vec_dss(ULONG channel)
 144 {
 145         switch (channel)
 146         {
 147                 case 0:
 148                         vec_dss(0);
 149                         break;
 150
 151                 case 1:
 152                         vec_dss(1);
 153                         break;
 154
 155                 case 2:
 156                         vec_dss(2);
 157                         break;
 158
 159                 case 3:
 160                         vec_dss(3);
 161                         break;
 162         }
 163 }
 164
 165 void cpu_cache_stream_start(CONST_APTR ptr, ULONG blockcount, ULONG blocksize, LONG stride, ULONG flags)
 166 {
 167         if (hasAltivec)
 168         {
 169                 ULONG opts;
 170                 ULONG channel = 0;
 171
 172                 opts = (blocksize << 24) | (blockcount << 16) | stride;
 173
 174                 if (flags & CCSSF_CHANNEL1)
 175                 {
 176                         channel = 1;
 177                 }
 178                 else if (flags & CCSSF_CHANNEL2)
 179                 {
 180                         channel = 2;
 181                 }
 182                 else if (flags & CCSSF_CHANNEL3)
 183                 {
 184                         channel = 3;
 185                 }
 186
 187                 if (flags & CCSSF_WRITES)
 188                 {
 189                         if (flags & CCSSF_TRANSCIENT)
 190                         {
 191                                 cpu_vec_dststt(ptr, opts, channel);
 192                         }
 193                         else
 194                         {
 195                                 cpu_vec_dstst(ptr, opts, channel);
 196                         }
 197                 }
 198                 else
 199                 {
 200                         if (flags & CCSSF_TRANSCIENT)
 201                         {
 202                                 cpu_vec_dstt(ptr, opts, channel);
 203                         }
 204                         else
 205                         {
 206                                 cpu_vec_dst(ptr, opts, channel);
 207                         }
 208                 }
 209         }
 210         else
 211         {
 212                 //kprintf("[Altivec]: Not available\n");
 213         }
 214         /* XXX: fallback to dtst etc.. ? */
 215 }
 216
 217
 218 void cpu_cache_stream_stop(ULONG channel)
 219 {
 220         if (hasAltivec)
 221         {
 222                 cpu_vec_dss(channel);
 223         }
 224 }
 225
 226 /*
 227  * Function using simple heuristics to determine caching.
 228  */
 229
 230 void cpu_cache_image_start(void *ptr, int rowbytes, int width, int lines)
 231 {
 232         /* blocksize 0...31, 0 == 32 */
 233         int blocksize;
 234         int blocks = 256;
 235
 236         if (!hasAltivec)
 237                 return;
 238
 239         if (lines == 1)
 240         {
 241                 blocksize = width / (blocks * 16); /* size of block in 16byte units */
 242                 if (blocksize == 0)
 243                         blocksize = 1;
 244                 if (blocksize > 31)
 245                         blocksize = 0;
 246         }
 247         else
 248         {
 249                 blocksize = (rowbytes * lines) / (blocks * 16);
 250                 if (blocksize == 0)
 251                         blocksize = 1;
 252                 if (blocksize > 31)
 253                         blocksize = 0;
 254         }
 255
 256         if (blocks > 255)
 257                 blocks = 0;
 258
 259         cpu_cache_stream_start((void*)((unsigned int)ptr & ~0xf), blocks, blocksize, blocksize * 16, CCSSF_CHANNEL1);
 260 }
 261
 262 void cpu_cache_image_stop(void)
 263 {
 264         cpu_cache_stream_stop(1);
 265 }
 266
 267 ////