cmd_sl811hst.c

USB monitor

/* cmd_sl811hst.c - Nereid USB Monitor / SL811HST command
 * Copyright (C) 2003 Tachibana Eriko
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <ctype.h>
#include <stdio.h>
#include <string.h>

#include "include/nereid_usb.h"
#include "cmd_sl811hst.h"
#include "usbmon.h"


/* Command: SL811HST 偺儗僕僗僞傪昞帵偡傞 */
int
sl811hst_reg (int argc, char* argv[])
{
  int i;
  unsigned char read_buf[16];
  unsigned char r;
  const char* s;

  /* 偲傝偁偊偢儗僕僗僞傪慡晹撉傫偱偍偔 */
  SL811BufRead (0, read_buf, sizeof read_buf);

  /* 'reg' 偩偗側傜僐儞僩儘乕儖儗僕僗僞傪昞帵 */
  if (argc == 0)
  {

    r = read_buf[SL811_ControlRegister1];
    s = (r & 0x10) ? ((r & 0x08) ? "J-State: D+ High & D- Low"		/* 1 1 */ 
				 : "K-State: D- High & D+ Low")		/* 1 0 */
		   : ((r & 0x08) ? "USB Reset: D+ & D- Low State"	/* 0 1 */
				 : "Normal");				/* 0 0 */

    printf ("0x05: Control Register1 = 0x%02x", r);
    printf (": ");
    printf ("H/W SOF %s, ",		(r & 0x01) ? "Enable" : "Disable");
    printf ("EOF2 %s, ",		(r & 0x04) ? "Disable" : "Enable");
    printf ("%s Speed, ",		(r & 0x20) ? "Low" : "Full");
    printf ("Suspend %s,\n",		(r & 0x40) ? "Enable" : "Disable");
    printf ("  ");
    printf ("USB Engine Reset = %d / ",	(r & 0x08) ? 1 : 0);
    printf ("J-K Force State = %d ",	(r & 0x10) ? 1 : 0);
    printf ("(%s)\n",			s);

    r = read_buf[SL811_InterruptEnableRegister];

    printf ("0x06: InterruptEnableRegister = 0x%02x", r);
    printf (": ");
    printf ("USB-A %s, ",		(r & 0x01) ? "Enable" : "Disable");
    printf ("USB-B %s, ",		(r & 0x02) ? "Enable" : "Disable");
    printf ("Babble Detection %s,\n",	(r & 0x04) ? "Enable" : "Disable");
    printf ("  ");
    printf ("SOF Timer(1ms) %s, ",	(r & 0x10) ? "Enable" : "Disable");
    printf ("Insert/Removed %s, ",	(r & 0x20) ? "Enable" : "Disable");
    printf ("USB Reset/Resume %s\n",	(r & 0x40) ? "Enable" : "Disable");

    r = read_buf[SL811_InterruptStatusRegister];
    printf ("0x0d: Interrupt Status Register = 0x%02x", r);
    printf (": ");
    printf ("USB-A %s, ",		(r & 0x01) ? "Enable" : "Disable");
    printf ("USB-B %s, ",		(r & 0x02) ? "Enable" : "Disable");
    printf ("Babble Detection %s,\n",	(r & 0x04) ? "Enable" : "Disable");
    printf ("  ");
    printf ("SOF Timer(1ms) %s, ",	(r & 0x10) ? "Enable" : "Disable");
    printf ("Insert/Removed %s, ",	(r & 0x20) ? "Enable" : "Disable");
    printf ("USB Reset/Resume %s, ",	(r & 0x40) ? "Enable" : "Disable");
    printf ("D+ pin = %d\n",		(r & 0x80) ? 1 : 0);

    r = read_buf[SL811_HWRevisionRegister];
    switch (r >> 4)
      {
	case 0x0: s = "SL11H"; break;
	case 0x1: s = "SL811HST Rev 1.2"; break;
	case 0x2: s = "SL811HST Rev 1.4/1.5"; break;
	default: s = "???"; break;
      }

    printf ("0x0e: H/W Revision Register = 0x%02x", r);
    printf (": ");
    printf ("USB-A Data Toggle Pin = %d, ",	(r & 0x01) ? 1 : 0);
    printf ("USB-B Data Toggle Pin = %d,\n",	(r & 0x02) ? 1 : 0);
    printf ("  ");
    printf ("H/W Revision = %d (%s)\n",		(r >> 4), s);

    r = read_buf[SL811_SOFCounterHigh_ControlRegister2];

    printf ("0x0f: SOF Counter High / Control Register2 = 0x%02x", r);
    printf (": ");
    printf ("D+/D- Data Polarity %s, ",	(r & 0x40) ? "Change" : "No Change");
    printf ("%s\n",			(r & 0x80) ? "Master" : "Slave");

    /* 惓忢廔椆 */
    return RET_SUCCESS;
  }

  /* 'reg a'丄'reg b' 偱 USB-A丄USB-B 儗僕僗僞僙僢僩昞帵 */
  for (i = 0; i < argc; ++i)
    {
      int offs;
      int reg;

      if (stricmp (argv[i], "A") == 0 || stricmp (argv[i], "B") == 0)
	r = toupper (*argv[i]);
      else
	{
	  printf ("reg: 堷悢偑惓偟偔偁傝傑偣傫.\n");
	  return RET_FAILURE;
	}

      printf ("USB-%c Register Set:\n", r);
      offs = (r == 'A') ? 0
			: SL811_B_HostControlRegister - SL811_A_HostControlRegister;

      r = read_buf[reg = SL811_A_HostControlRegister + offs];

      printf ("0x%02x: Host Control Register = 0x%02x", reg, r);
      printf (": ");
      printf ("ARM = %s, ",		(r & 0x01) ? "1(揮憲壜擻)" : "0(揮憲廔椆)");
      printf ("Transfer %s, ",		(r & 0x02) ? "Enable" : "Disable");
      printf ("%s Host,\n",		(r & 0x04) ? "To" : "From");
      printf ("  ");
      printf ("%sIsochronous, ",	(r & 0x10) ? "" : "Not ");
      printf ("SOF = %d, ",		(r & 0x20) ? 1 : 0);
      printf ("Data%d, ",		(r & 0x40) ? 1 : 0);
      printf ("Preamble %s\n",		(r & 0x80) ? "Enable" : "Disable");

      r = read_buf[reg = SL811_A_HostBaseAddress + offs];

      printf ("0x%02x: Host Base Address = 0x%02x\n", reg, r);

      r = read_buf[reg = SL811_A_HostBaseLength + offs];

      printf ("0x%02x: Host Base Length = 0x%02x\n", reg, r);

      r = read_buf[reg = SL811_A_USBStatus + offs];

      printf ("0x%02x: USB Status = 0x%02x", reg, r);
      printf (": ");
      printf ("ACK = %d, ",		(r & 0x01) ? 1 : 0);
      printf ("Error = %d, ",		(r & 0x02) ? 1 : 0);
      printf ("Time-Out = %d, ",	(r & 0x04) ? 1 : 0);
      printf ("Data%d, ",		(r & 0x08) ? 1 : 0);
      printf ("Setup = %d, ",		(r & 0x10) ? 1 : 0);
      printf ("Overflow = %d,\n",	(r & 0x20) ? 1 : 0);
      printf ("  ");
      printf ("NAK = %d, ",		(r & 0x40) ? 1 : 0);
      printf ("STALL = %d\n",		(r & 0x80) ? 1 : 0);

      r = read_buf[reg = SL811_A_HostTransferCountRegister + offs];

      printf ("0x%02x: Host Transfer Count Register = 0x%02x\n", reg, r);
    }

  /* 惓忢廔椆 */
  return RET_SUCCESS;
}


/* Command: SL811HST 偺儊儌儕撪梕傪昞帵偡傞 */
int
sl811hst_dump (int argc, char* argv[])
{
  unsigned char read_buf[SL811_SIZE];
  int i;

  SL811BufRead (0, read_buf, sizeof read_buf);

       /* "0x00: +0 ..." */
  printf ("      +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +a +b +c +d +e +f\n");
  for (i = 0; i < SL811_SIZE; ++i)
    {
      if ((i % 16) == 0)
	printf ("0x%02x:", i);
      printf (" %02x", read_buf[i]);
      if ((i % 16) == 15)
	printf ("\n");
    }

  /* 惓忢廔椆 */
  return RET_SUCCESS;
}

/* Command: SL811HST 偺儊儌儕偐傜侾僶僀僩撉傒崬傓 */
int
sl811hst_read (int argc, char* argv[])
{
  int i;

  if (argc == 0)
    {
      printf ("<addr> = 0乣255\tSL811HST 偺儊儌儕傾僪儗僗傪巜掕偟傑偡.\n");

      /* 惓忢廔椆 */
      return RET_SUCCESS;
    }

  for (i = 0; i < argc; ++i)
    {
      int addr;

      if ((sscanf (argv[i], "%i", &addr) != 1)
       || (addr >> 8))
	{
	  printf ("read: 堷悢偑惓偟偔偁傝傑偣傫.\n");
	  return RET_FAILURE;
	}
      printf ("0x%02x\n", SL811Read (addr));
    }

  /* 惓忢廔椆 */
  return RET_SUCCESS;
}


/* Command: SL811HST 偺儊儌儕偵侾僶僀僩彂偒崬傓 */
int
sl811hst_write (int argc, char* argv[])
{
  int i;

  if (argc == 0)
    {
      printf ("<addr> = 0乣255\tSL811HST 偺儊儌儕傾僪儗僗傪巜掕偟傑偡.\n"
	      "<data> = 0乣255\t儊儌儕偵彂偒崬傓抣傪巜掕偟傑偡.\n");

      /* 惓忢廔椆 */
      return RET_SUCCESS;
    }

  for (i = 0; i < argc; i += 2)
    {
      int addr, data;

      if (argc < i + 2)
	{
	  printf ("write: 堷悢偑懌傝傑偣傫.\n");
	  return RET_FAILURE;
	}
      if ((sscanf (argv[i + 0], "%i", &addr) != 1)
       || (sscanf (argv[i + 1], "%i", &data) != 1)
       || (addr >> 8)
       || (data >> 8))
	{
	  printf ("write: 堷悢偑惓偟偔偁傝傑偣傫.\n");
	  return RET_FAILURE;
	}

      SL811Write (addr, data);
    }

  /* 惓忢廔椆 */
  return RET_SUCCESS;
}


/* Command: SL811HST 偺儊儌儕偺巜掕斖埻偵擟堄偺僨乕僞傪彂偒崬傓 */
int
sl811hst_fill (int argc, char* argv[])
{
  int i;

  if (argc == 0)
    {
      printf ("<a1> = 0乣255\t彂偒崬傒傪奐巒偡傞儊儌儕傾僪儗僗傪巜掕偟傑偡.\n"
	      "<a2> = 0乣255\t彂偒崬傒傪廔椆偡傞儊儌儕傾僪儗僗傪巜掕偟傑偡.\n"
	      "<data> = 0乣255\t儊儌儕偵彂偒崬傓抣傪巜掕偟傑偡.\n");

      /* 惓忢廔椆 */
      return RET_SUCCESS;
    }

  for (i = 0; i < argc; i += 3)
    {
      unsigned char write_buf[SL811_SIZE];
      int addr1, addr2, data;
      int len;

      if (argc < i + 3)
	{
	  printf ("fill: 堷悢偑懌傝傑偣傫.\n");
	  return RET_FAILURE;
	}
      if ((sscanf (argv[i + 0], "%i", &addr1) != 1)
       || (sscanf (argv[i + 1], "%i", &addr2) != 1)
       || (sscanf (argv[i + 2], "%i", &data) != 1)
       || (addr1 >> 8)
       || (addr2 >> 8)
       || (data >> 8)
       || ((len = addr2 - addr1 + 1) <= 0))
	{
	  printf ("fill: 堷悢偑惓偟偔偁傝傑偣傫.\n");
	  return RET_FAILURE;
	}

      memset (write_buf, data, len);
      SL811BufWrite (addr1, write_buf, len);
    }

  /* 惓忢廔椆 */
  return RET_SUCCESS;
}


/* EOF */