/*
 *
 */

 #include <malloc.h>
 #include <mem.h>
 #include <stdio.h>
 #include "global.h"
 #include "dmem.h"
 #include "print.h"
 #include "buf.h"

 #define MAX_BUF	0x00010000L
 #define BLK_SIZE	512


 static FLAG pattern_unique(char cmd,char *buf,struct PAT_OBJ *pat);
 static FLAG pattern_tag(char cmd,char *buf,struct PAT_OBJ *pat);
 static FLAG pattern_word(char cmd,char *buf,struct PAT_OBJ *pat);
 static FLAG pattern_fast(char cmd,char *buf,struct PAT_OBJ *pat);
 static FLAG pattern_byte(char cmd,char *buf,struct PAT_OBJ *pat);

/***************************************************************************
 *
 * buf_fill(...)
 *
 ***************************************************************************/

 void buf_fill(buf,pattern,num_bytes)

 char *buf;
 long  pattern;
 long  num_bytes;
 {
  int  i;
  int  num_longs;

  num_longs = num_bytes/4;

  for (i = 0; i < num_longs; i++)
    {
     ((long *)buf)[i] = pattern;
     }
  }

/***************************************************************************
 *
 * buf_get(...)
 *
 ***************************************************************************/

 char *buf_get(num_bytes)

 long num_bytes;
 {
  long  num_bytes_alloc;
  char *buf;

  if (num_bytes > MAX_BUF)
    {
     error("Too many bytes. Cannot make buffer so large");
     return (NULL);
     }

  if (num_bytes & 0x0000000CL)
    {
     error("Number of bytes for buffer is not an even number of double words");
     return (NULL);
     }

  num_bytes_alloc = num_bytes;
  buf = dmem_alloc(&num_bytes_alloc);

  if (num_bytes_alloc != num_bytes)
     error("Buffer size was adjusted when it should not");

  return (buf);
  }

/***************************************************************************
 *
 * cmd - 'm', make.
 *	 'c', compare.
 *
 ***************************************************************************/

 FLAG buf_pattern(char cmd,char *buf,int pattern,struct PAT_OBJ *pat)
 {
  if (pat->num_bytes % BLK_SIZE)
    {
     error("Number of bytes is not even number of blocks");
     return (FALSE);
     }

  switch (pattern)
    {
     case PATTERN_UNIQUE:
	return (pattern_unique(cmd,buf,pat));

     case PATTERN_TAG:
	return (pattern_tag(cmd,buf,pat));

     case PATTERN_WORD:
	return (pattern_word(cmd,buf,pat));

     case PATTERN_FAST:
	return (pattern_fast(cmd,buf,pat));

     case PATTERN_NULL:
	return (TRUE);

     case PATTERN_BYTE:
	return (pattern_byte(cmd,buf,pat));
     }

  return (TRUE);
  }

/***************************************************************************
 *
 *
 *
 ***************************************************************************/

 static FLAG pattern_unique(char cmd,char *buf,struct PAT_OBJ *pat)
 {
  long		i;
  int		num_longs;
  unsigned long val;

  num_longs = pat->num_bytes/4;

  for (i = 0; i < num_longs; i++)
    {
     val = ((long)pat->tag << 24)
	 + ((long)pat->scsi_id << 20)
	 + ((long)pat->blk_num << 16)
	 + (long)i;

     if (cmd == 'm')
	((long *)buf)[i] = val;
     else
	if (((long *)buf)[i] != val)
	  {
	   printf(	"Mismatch at offset %ld: 0x%.8lX should be 0x%.8lX.\n",
			i,
			((unsigned long *)buf)[i],
			val);
	   error("Buffer data mismatch");
	   return (FALSE);
	   }
     }

  return (TRUE);
  }

/***************************************************************************
 *
 *
 *
 ***************************************************************************/

 static FLAG pattern_tag(char cmd,char *buf,struct PAT_OBJ *pat)
 {
  U32	        i;
  U32	       *ltemp;
  U32		blk_num;

  ltemp = buf;

  for (blk_num = 0; blk_num < pat->num_blks; blk_num++)
    {
     if (cmd == 'm')
	for (i = 0; i < (BLK_SIZE/4); i++)
	   ltemp[i] = (pat->blk_num + blk_num);
     else
	for (i = 0; i < (BLK_SIZE/4); i++)
	  {
	   if (ltemp[i] != (pat->blk_num + blk_num))
	     {
	      printf(	"Mismatch at offset 0x%lX: 0x%.8lX should be 0x%.8lX.\n",
			(long)((i*4) + (blk_num * BLK_SIZE)),
			ltemp[i],
			(pat->blk_num + blk_num));

	      print_dump_byte(&ltemp[i-4],48);

	      error("Buffer data mismatch");
	      return (FALSE);
	      }
	   }
     (char *)ltemp += BLK_SIZE;
     }

  return (TRUE);
  }

/***************************************************************************
 *
 *
 *
 ***************************************************************************/

 static FLAG pattern_word(char cmd,char *buf,struct PAT_OBJ *pat)

 {
  long	        i;
  U32		blk_num;
  U8		val;

  for (blk_num = 0; blk_num < pat->num_blks; blk_num++)
    {
     val = WORD2BYTE(0,pat->blk_num + blk_num) + WORD2BYTE(1,pat->blk_num + blk_num);

     if (cmd == 'm')
	memset(buf,val,BLK_SIZE);
     else
	for (i = 0; i < BLK_SIZE; i++)
	  {
	   if (buf[i] != val)
	     {
	      printf(	"Mismatch at offset 0x%lX: 0x%.2X should be 0x%.2X.\n",
			i + (blk_num * BLK_SIZE),
			(U8) buf[i],
			val);

	      print_dump_byte(&buf[i],48);

	      error("Buffer data mismatch");
	      return (FALSE);
	      }
	   }
     buf += BLK_SIZE;
     }

  return (TRUE);
  }

/***************************************************************************
 *
 *
 *
 ***************************************************************************/

 static FLAG pattern_byte(char cmd,char *buf,struct PAT_OBJ *pat)

 {
  long	        i;

  if (cmd == 'm')
     memset(buf,(U8) pat->tag,BLK_SIZE * pat->num_blks);
  else
	for (i = 0; i < BLK_SIZE * pat->num_blks; i++)
	  {
	   if ((U8)buf[i] != (U8)pat->tag)
	     {
	      printf(	"Mismatch at offset 0x%lX: 0x%.2X should be 0x%.2X.\n",
			i,
			(U8) buf[i],
			(U8)pat->tag);

	      print_dump_byte(&buf[i],48);

	      error("Buffer data mismatch");
	      return (FALSE);
	      }
	   }

  return (TRUE);
  }

/***************************************************************************
 *
 *
 *
 ***************************************************************************/

 static FLAG pattern_fast(char cmd,char *buf,struct PAT_OBJ *pat)

 {
  U32	       *ltemp;
  U32		blk_num;

  for (blk_num = 0; blk_num < pat->num_blks; blk_num++)
    {
     ltemp = buf;
     if (cmd == 'm')
	*ltemp = pat->blk_num + blk_num;
     else
	if (*ltemp != (pat->blk_num + blk_num))
	  {
	   printf(	"Mismatch at offset 0x%lX: 0x%.8lX should be 0x%.8lX.\n",
			(U32)(blk_num * BLK_SIZE),
			*ltemp,
			blk_num);

	   print_dump_byte(buf,48);

	   error("Buffer data mismatch");
	   return (FALSE);
	   }

     buf += BLK_SIZE;
     }

  return (TRUE);
  }