/*##################################################################

PROJECTO: EMULADOR DO GLiTCH

   Grupo de Engenharia de Computadores
   Departamento de Informática
   Universidade do Minho
   Braga - PORTUGAL

   Ficheiro: pbl.c
   Linguagem: C
   Chip: Transputer
   Data de Início: 30/Março/1992
   Data de Finalização: /Junho/1992
   Autor: João Miguel Lobo Fernandes
	Alteracao:    03-05-96
   Alterado por: A.Esteves

   Notas:
     É necess ria a variável rbrs (read/barrel routing shifter)
     Activar os sinais no fim das instruções (Chip_active, ...)

###################################################################*/
#include "datadef.h"
WORD bit;

/*#################################################################*/
/*## Esta função não faz nada (nop = no operation)               ##*/
/*#################################################################*/

void pbl_nop (void)
{
}

/*#################################################################*/
/*## Esta função faz o match da CAM e do subset para uma instrução */ /*## match                                                         */
/*#################################################################*/

void pbl_match (void)
{
  int i;
  char col1, col2;

  /*&&&  iniciar pos1, patt1, pos2, patt2 e subset (5 param) */
/**** ZERO=00, UM=01, DCARE=10 ****/

  md0[0]=md0[1]=WORD_ZERO;    /* coloca md0 a 0..0 */
  md1[0]=md1[1]=WORD_UM;      /* coloca md1 a 1..1 */
  for (i=0; i<8; i++)         /* Os 2 padrões têm 8 trits */
  {
/**** match do 1º padrão ****/
    col1=(pos1+i)%64;
    switch (patt1[7-i])
    {
      case ZERO:
        md0[0] |= cam[col1][0];
        md0[1] |= cam[col1][1];
        break;
      case UM:
        md1[0] &= cam[col1][0];
        md1[1] &= cam[col1][1];
      case DCARE:
        break;
      default:
        erro ("\nErro na função pbl_match (1º padrão). \n");
        break;
    }
/**** match do 2º padrão ****/
    col2=(pos2+i)%64;
    switch (patt2[7-i])
    {
      case ZERO:
        md0[0] |= cam[col2][0];
        md0[1] |= cam[col2][1];
        break;
      case UM:
        md1[0] &= cam[col2][0];
        md1[1] &= cam[col2][1];
      case DCARE:
        break;
      default:
        erro ("\nErro na função pbl_match (2º padrão). \n");
        break;
    }
  }
  md0[0]=~md0[0]; /* md0 indica se houve match dos zeros. */
                  /* Como foi iniciado a zero e se fez OR, */
  md0[1]=~md0[1]; /* é necessário negar no final */

  ms[0]=ms[1]=WORD_UM;      /* Coloca ms a 1 */
  for (i=0; i<4; i++)       /* O padrão de subset tem 4 trits */
  {
  /**** match do padrão de subset ****/
    switch (subset[3-i])
    {
      case ZERO:
        ms[0] &= ~sub[i][0];
        ms[1] &= ~sub[i][1];
        break;
      case UM:
        ms[0] &= sub[i][0];
        ms[1] &= sub[i][1];
      case DCARE:
        break;
      default:
        erro ("\nErro na função pbl_match (padrão subset). \n");
        break;
    }
  }
}

/*#################################################################*/
/* Esta função copia para o PBLR as tags (copiadas para auxiliar   */
/* tag2)                                                           */
/* NOTA: o PBLR tem o LSBit em pblr[63] e o MSBit em pblr[0]       */
/*#################################################################*/

void pbl_read2 (void)
{
  int i, mascara, bloco;

/* Porque e' que em barrel-shift o 1.o parametro tem o valor X ?
R: Deve assumir o valor "pos1", que e' o parametro de extract_tag */

/*** Se linhacam=-1 usar tag2 senão usar linhacam ***/
  if (linhacam==-1) /* ler tag2 */
  {
    mascara = 0x80000000;
    for (i=0; i<(PES_CHIP/2); i++)
    {
      pblr[i]=(tag2[0] & mascara) ? '1' : '0';
      pblr[(PES_CHIP/2)+i]=(tag2[1] & mascara) ? '1' : '0';
      mascara>>=1;
    }
  }
  else /* copia 32 bits da linha da cam "linhacam" para o
          PBLR, a partir da posicao "pos1" */
  {
    bloco=1-(linhacam/PALAVRA);         /* MSB           LSB */
    mascara = 1 << (linhacam%PALAVRA);  /* [===cam[0][0]===] */
    for (i=0; i<COLUNCAM/2; i++)        /* 63     32  31   0 */
      pblr[(COLUNCAM-1-(i+pos1))%COLUNCAM] = ((mascara&cam[(i+pos1)%COLUNCAM][bloco]) ? '1' : '0');
  }
}

/*#################################################################*/
/* Esta função envia para o Read Barrel Routing Shifter (RBRS) do  */
/* chip presente (num_chip), o conteúdo do PBLR.                   */
/* NOTAS: rbrs[] tem o LSBit em rbrs[0] e o MSBit em rbrs[31]      */
/*        pos1 = posicao dentro do PBLR a ler                      */
/*#################################################################*/

void pbl_read3 (void)
{
  int i, posicao;

  /* printf("\nPBLREAD3: primpos = %d\n", pos1); */
  for (i=0; i<PES_CHIP/2; i++)
  {
    posicao=(pos1+i)%COLUNCAM;
    rbrs[num_chip][posicao] = pblr[COLUNCAM-1-posicao];
  }

}

/*#################################################################*/
/* O PBLR esta'dividido em 2 metades (32 bits). Cada metade esta'  */
/* ainda subdividida em 8 blocos de 4 bits. As instruções de merge */
/* actuam numa das metades do PBLR. A outra metade não sofre       */
/* alteração. Uma mascara de 8 bits é aplicada a uma das metades.  */
/* Cada bit da mascara corresponde a um dos blocos (de 4 bits) do  */
/* PBLR. Um '1' na mascara indica que o respectivo bloco recebe    */ 
/* data do RBRS. Um '0' na mascara indica que o bloco não sofre    */
/* alteração.                                                      */
/*#################################################################*/

void pbl_mergeR (void) /* patt1[] e' a máscara */
  {
  int i, j;

  for (i=0; i<8; i++)  /* para cada bit da máscara */
    if (patt1[i] != '0')
      for (j=0; j<4; j++)
		  pblr[COLUNCAM-1-(i*4+j)] = rbrs[num_chip][i*4+j];
  }

/*#################################################################*/

void pbl_mergeL (void) /* patt1[] e' a máscara */
  {
  int i, j;

  for (i=0; i<8; i++)  /* para cada bit da máscara */
    if (patt1[i] != '0')
      for (j=0; j<4; j++)
		  pblr[COLUNCAM/2-1-(i*4+j)]=rbrs[num_chip][i*4+j];
}

/*#################################################################*/

void pbl (n)
char n;
{
  if (!n) /* n=0 */
  {
    msbak[0]=ms[0];    /* Os PE's devem restaurar o valor original */
    msbak[1]=ms[1];    /* caso a instrução implique HOLDMS         */
    switch (inst2)
      {
      case 0  : pbl_nop();    break;
      case 1  : pbl_match();  break;
      case 3  : pbl_read2();  break;
      case 4  : pbl_read3();  break;
      case 5  : pbl_mergeR(); break;
      case 6  : pbl_mergeL(); break;
    }
  }
  else /* n!=0 */
    if (inst2 == 2)
      pbl_write();
}

/*#################################################################*/