/*--------------------------------------------------------*\
| FICHEIRO:	vsr.c                                      |
| DATA:		19-04-96                                   |
| AUTOR:	António Esteves                            |
|                                                          |
| Programa para testar as  funções  do VSR  implementadas  |
| em duas FPGAs do EDgAR: uma contém o VSR e a outra  faz  |
| a interface entre o VSR e o programa que emula  o resto  |
| do GLiTCH. O programa que emula o GLiTCH implementa  as  |
| seguintes partes: 64 PEs/ALUs, PBL, CAM e descodificação |
| de instruções).                                          |
|                                                          |
\*--------------------------------------------------------*/

#include <stdio.h>
#include <stdlib.h>
#include <misc.h>
#include <process.h>

#include "edgar-hw.h"
#include "datadef.h"

WORD    temp[SIZE];

void TagImage(void)          /* Igual a rotate_imag() sem HOLD_MS */
    {
                /* 32 bits menos significativos duma linha do VSR */
    *(add4Interface) = 0;          /* addr0=0, SHIFT=0, notCSEN=0 */
    temp[1] = (WORD) *(addVsrCs);
                        /* ler a linha 0 (lsr) do VSR para temp[] */
    *(addVsrCs) = tag[1] ;/* escrever a tag na linha 7(msr) do VSR*/
				  /* e rotacao de todas as linhas */
    tag[1] = temp[1];                 /* copiar temp[] para a tag */

                 /* 32 bits mais significativos duma linha do VSR */
    *(add4Interface) = 1;          /* addr0=1, SHIFT=0, notCSEN=0 */
    temp[0] = (WORD) *(addVsrCs);
                        /* ler a linha 0 (lsr) do VSR para temp[] */
    *(addVsrCs) = tag[0]; / escrever a tag na linha 7(msr) do VSR */
				  /* e rotacao de todas as linhas */
    tag[0] = temp[0];                 /* copiar temp[] para a tag */
    }

/*
+---------------------------------------------------------------+
| write_image() <=> rotate_imag()                               |
|                                                               |
|   Le para a tag de cada PE o bit correspondente da linha      |
|   0 (LSR) do VSR (ver TagImage), roda todas as linhas do VSR  |
|   1 posicao e envia a tag de cada PE para o bit               |
|   correspondente da linha 7 (MSR) do VSR.                     |
|                                                               |
|  addVsrCs      = Endereco (na LCA que implementa o VSR)       |
|                  utilizado para ler/escrever linhas do/no     |
|                  VSR nas operacoes de SWAP (rotacao de        |
|                  linhas)                                      |
|  add4Interface = Endereco (na LCA que implementa a inter-     |
|                  face com o VSR) utilizado para programar     |
|                  os valores de notAddr0, SHIFT e notCSEN.     |
+---------------------------------------------------------------+
*/
void write_image (void)
    {
    ms[0]=msbak[0];         /* Hold ms */
    ms[1]=msbak[1];

                /* 32 bits menos significativos duma linha do VSR */

    *(add4Interface) = 0;          /* addr0=0, SHIFT=0, notCSEN=0 */
    temp[1] = (WORD) *(addVsrCs);
                        /* ler a linha 0 (lsr) do VSR para temp[] */
    *(addVsrCs) = tag[1]; /*escrever a tag na linha 7 (msr) do VSR*/
			          /* e rotacao de todas as linhas */
    tag[1] = temp[1];                 /* copiar temp[] para a tag */

                 /* 32 bits mais significativos duma linha do VSR */

    *(add4Interface) = 1;          /* addr0=1, SHIFT=0, notCSEN=0 */
    temp[0] = (WORD) *(addVsrCs);
                        /* ler a linha 0 (lsr) do VSR para temp[] */
    *(addVsrCs) = tag[0]; /* escrever a tag na linha  (msr) do VSR*/
				  /* e rotacao de todas as linhas */
    tag[0] = temp[0];                 /* copiar temp[] para a tag */
    }

/*
+---------------------------------------------------------------+
| rotate_imag()                                                 |
|                                                               |
|   Le para a tag de cada PE o bit correspondente da linha      |
|   0 (LSR) do VSR (ver TagImage), roda todas as linhas do VSR  |
|   1 posicao e envia a tag de cada PE para o bit               |
|   correspondente da linha 7 (MSR) do VSR.                     |
|                                                               |
|  addVsrCs      = Endereco (na LCA que implementa o VSR)       |
|                  utilizado para ler/escrever linhas do/no     |
|                  VSR nas operacoes de SWAP (rotacao de        |
|                  linhas)                                      |
|  add4Interface = Endereco (na LCA que implementa a inter-     |
|                  face com o VSR) utilizado para programar     |
|                  os valores de notAddr0, SHIFT e notCSEN.     |
+---------------------------------------------------------------+
*/
void rotate_imag(void)
    {
    ms[0]=msbak[0];  /* Hold ms */
    ms[1]=msbak[1];

                /* 32 bits menos significativos duma linha do VSR */

    *(add4Interface) = 0;          /* addr0=0, SHIFT=0, notCSEN=0 */
    temp[1] = (WORD) *(addVsrCs);
                        /* ler a linha 0 (lsr) do VSR para temp[] */
    *(addVsrCs) = tag[1]; /*escrever a tag na linha 7 (msr) do VSR*/
				  /* e rotacao de todas as linhas */
    tag[1] = temp[1];                 /* copiar temp[] para a tag */

                 /* 32 bits mais significativos duma linha do VSR */

    *(add4Interface) = 1;          /* addr0=1, SHIFT=0, notCSEN=0 */
    temp[0] = (WORD) *(addVsrCs);
                        /* ler a linha 0 (lsr) do VSR para temp[] */
    *(addVsrCs) = tag[0]; /* escrever a tag na linha 7(msr) do VSR*/
				  /* e rotacao de todas as linhas */
    tag[0] = temp[0];                 /* copiar temp[] para a tag */
    }

/*
+--------------------------------------------------------+
|  shiftVsr()                                            |
|                                                        |
|  Usa 3 variaveis globais para ser compativel com as    |
|  outras funcoes indexadas por *PE_ROM[]() :            |
|                                                        |
|  VIN[]   = valor VIN[7:0] a colocar na linha 63 do VSR |
|  VOUT[]  = valor VOUT[7:0] lido da linha 0 do VSR      |
|  vsr[][] = array que guarda o conteudo do VSR          |
|                                                        |
|  A responsabilidade colocar/ler o valor de VIN/VOUT    |
|  nao e' do GLiTCH, mas sim do exterior. Deste modo     |
|  VIN/VOUT representam pinos para do chip.              |
+--------------------------------------------------------+
*/
void shiftVsr(void)
    {
    ms[0]=msbak[0];  /* Hold ms */
    ms[1]=msbak[1];

    *(ADD4_LCA0) = 4;                                  /* SHIFT=1 */
    *(ADD1_LCA0) = (char)VIN[num_chip];
                          /* colocar Vin na interface com VSR     */
    *(ADD2_LCA0) = 0;     /* ordem para fazer shift linhas do VSR */
    VOUT[num_chip] = (char) *(ADD3_LCA0);
                                    /* ler Vout para o Transputer */
    *(ADD4_LCA0) = 0;                                  /* SHIFT=0 */
    }

/*
+---------------------------------------------------------------+
| extract_imag()                                                |
|                                                               |
|   Copia a tag de cada PE para o bit correspondente da linha   |
|   7 (MSR) do VSR, roda todas as linhas do VSR 1 posicao e     |
|   copia o bit correspondente da linha 0 (LSR) do VSR para     |
|   uma variavel temporaria.                                    |
|                                                               |
|   NOTA: esta instrucao do GLiTCH exige ser precedida por uma  |
|         instrucao de 'tag_match' que copia para cada TAG o    |
|         bit da posicao da CAM desejada.                       |
|                                                               |
|  addVsrCs      = Endereco (na LCA  que  implementa o VSR)     |
|                  utilizado para ler/escrever linhas do/no     |
|                  VSR nas operacoes  de  SWAP  (rotacao de     |
|                  linhas).                                     |
|  add4Interface = Endereco (na LCA que implementa a inter-     |
|                  face com o VSR) utilizado para programar     |
|                  os valores de notAddr0, SHIFT e notCSEN.     |
+---------------------------------------------------------------+
*/
void extract_imag(void)
    {
    ms[0]=msbak[0];  /* Hold ms */
    ms[1]=msbak[1];

                /* 32 bits menos significativos duma linha do VSR */

    *(add4Interface) = 0;          /* addr0=0, SHIFT=0, notCSEN=0 */
    temp[1] = (WORD) *(addVsrCs);
                        /* ler a linha 0 (lsr) do VSR para temp[] */
    *(addVsrCs) = tag[1]; /* escrever a tag na linha 7(msr) do VSR*/
				  /* e rotacao de todas as linhas */

                 /* 32 bits mais significativos duma linha do VSR */

    *(add4Interface) = 1;          /* addr0=1, SHIFT=0, notCSEN=0 */
    temp[0] = (WORD) *(addVsrCs);
                        /* ler a linha 0 (lsr) do VSR para temp[] */
    *(addVsrCs) = tag[0]; /* escrever a tag na linha 7(msr) do VSR*/
				  /* e rotacao de todas as linhas */
    }

/*
+---------------------------------------------------------+
| inicializarVsr()                                        |
|                                                         |
| Funcao que preenche o VSR com os valores iniciais.      |
| Cada coluna fica com o seu numero de ordem (63 a 0).    |
+---------------------------------------------------------+
*/

void inicializarVsr(void)
    {
    int n;

    for(n=0;n<64;++n)
        {
        VIN[num_chip] = (char)n;
        shiftVsr();
        }
    }