/*--------------------------------------------------------*\
| FICHEIRO:	vsr-sw.c                                   |
| DATA:		08-05-96                                   |
| AUTOR:	AntÓnio Esteves                            |
|                                                          |
| Operações do VSR implementado em s/w.                    |
|                                                          |
\*--------------------------------------------------------*/

#include <stdio.h>
#include "edgar-hw.h"
#include "datadef.h"

#ifdef T32
  #include <iocntrl.h>
#endif

#ifdef T16
  #include <iocntrl.h>
#endif

/*-------------- ESQUEMA DO VSR EM S/W ------------------*\

                                VIN (8 bits)
                         7       6      ...      0
                      _______________________________
         63 |     31 |       |       |       |       |
            |        |       |       |       |       |
            | msw    |   vsr |  vsr  |       |   vsr |
            |        | [0][7]| [0][6]| ...   | [0][0]|
64  =>      |      0 | ______|_______|_____  |_______| => 64 bits
bits        |     31 |       |       |       |       |
            | lsw    |       |       |       |       |
            |        |   vsr |  vsr  | ...   |  vsr  |
            |        | [1][7]| [1][6]|       | [1][0]|
         0  |      0 |_______|_______|_______|_______|
											 
                                 VOUT (8 bits)

\*---------------------------------------------------------*/

void TagImage(void) /* Igual a rotate_imag() sem HOLD_MS */
	{
	int i,j;
	WORD temp[SIZE];

	for(i=0;i<SIZE;++i)
		{
		temp[i] = vsr[i][0];
        	for(j=1;j<COLUNVSR;++j)
			vsr[i][j-1] = vsr[i][j];
        	vsr[i][COLUNVSR-1] = tag[i];
		tag[i] = temp[i];
		}
	}

/*---------------------------------------------------------*\
|   write_image() <=> rotate_imag()                         |
|                                                           |
|   Preenche a tag de cada PE com o lsb (B0) vindo do VSR.  |
|   Envia a tag de cada PE para o msb (B7) do VSR e faz a   |
|   rotacao do VSR.                                         |
|                                                           |
\*---------------------------------------------------------*/
void write_image(void)
	{
	int i,j;
	WORD temp[SIZE];

	ms[0]=msbak[0];  /* hold ms */
	ms[1]=msbak[1];

	for(i=0;i<SIZE;++i)
		{
		temp[i] = vsr[i][0];
        	for(j=1;j<COLUNVSR;++j)
			vsr[i][j-1] = vsr[i][j];
        	vsr[i][COLUNVSR-1] = tag[i];
		tag[i] = temp[i];
		}
	}

/*---------------------------------------------------------*\
|   rotate_imag()                                           |
|                                                           |
|   Preenche a tag de cada PE com o lsb (B0) vindo do VSR.  |
|   Envia a tag de cada PE para o msb (B7) do VSR e faz a   |
|   rotacao do VSR.                                         |
|                                                           |
\*---------------------------------------------------------*/
void rotate_imag(void)
	{
	int i,j;
	WORD temp[SIZE];

	ms[0]=msbak[0];  /* hold ms */
	ms[1]=msbak[1];

	for(i=0;i<SIZE;++i)
		{
		temp[i] = vsr[i][0];
        	for(j=1;j<COLUNVSR;++j)
			vsr[i][j-1] = vsr[i][j];
        	vsr[i][COLUNVSR-1] = tag[i];
		tag[i] = temp[i];
		}
	}

/*---------------------------------------------------------*\
|   extract_imag()                                          |
|                                                           |
|   Copia cada bit da linha 0 (LSR) do VSR para uma variavel|
|   temporaria, roda todas as linhas do VSR de 1 posicao e  |
|   escreve em cada bit da linha 7 (MSR) do VSR a TAG cor-  |
|   respondente.                                            |
|                                                           |
\*---------------------------------------------------------*/
void extract_imag(void)
	{
    int i,j;
	WORD temp[SIZE];

	ms[0]=msbak[0];  /* Hold ms */
	ms[1]=msbak[1];

	for(i=0;i<SIZE;++i)
		{
		temp[i] = vsr[i][0];
        	for(j=1;j<COLUNVSR;++j)
			vsr[i][j-1] = vsr[i][j];
        	vsr[i][COLUNVSR-1] = tag[i];
		}
	}

/*
+-------------------------------------------------------+
|  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)
    {
    int i;
    WORD vsr_tmp;

    VOUT[num_chip] = 0;
    ms[0]=msbak[0];  /* Hold ms */
    ms[1]=msbak[1];

    for(i=0;i<COLUNVSR;++i)
	{
        vsr_tmp = vsr[1][i] & (WORD)1; /* bit <0> da linha <i> */
	if (vsr_tmp == 0)
		VOUT[num_chip] |= VALORNULO[i];
                         /* para o IF demorar o mesmo que o ELSE */
	else
		VOUT[num_chip] |= PESOBIT[i];
                       /* bit <i> de VOUT = bit <0> da linha <i> */

	vsr[1][i] = vsr[1][i] >> 1;
              /* os bits <30-0> tomam os valores dos bits <31-1> */

	vsr_tmp = vsr[0][i] & (WORD)1; /* bit <32> da linha <i> */

        vsr_tmp = vsr_tmp << 31;

        vsr[1][i] = vsr[1][i] | vsr_tmp;
                          /* o bit <31> toma o valor do bit <32> */

	vsr[0][i] = vsr[0][i] >> 1;   /* os bits <62-32> tomam os 
                                       valores dos bits <63-33> */

	vsr_tmp = (((char)VIN[num_chip] & PESOBIT[i])!=0) ? 0x80000000 : 0;

        vsr[0][i]  = vsr[0][i] | vsr_tmp;
       /* o bit <63> da linha <i> toma o valor do bit <i> de VIN */
        }
    }

/*-------------------------------------------------------*\
| 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();
           }
	 }