path: root/libdpf/dpflib.c

/** DPF access library for AX206 based HW
 *
 * 12/2010 <hackfin@section5.ch>
 *
 * This is an ugly hack, because we use existing SCSI vendor specific
 * extensions to pass on our requests to the DPF.
 *
 * One day we might use a proper protocol like netpp.
 *
 */

// FIXME: Put all those SCSI commands in one (wrapped) place.

#include "dpf.h"

#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

#ifdef DEBUG
#define DEB(x) x
#else
#define DEB(x)
#endif

extern AccessMethods scsi_methods;
extern AccessMethods hid_methods;


/*
static
int dpf_query(DPFHANDLE h)
{
	int ret;
	unsigned char buf[64];	// Do not change size

	static
	unsigned char cmd[16] = {
		0xcd, 0, 0, 0,
		   0, 3, 0, 0,
		   0, 0, 0, 0,
		   0, 0, 0, 0
	};

	return wrap_scsi(h, cmd, sizeof(cmd), DIR_IN, buf, sizeof(buf));
}
*/



int
dpf_open (const char *dev, DPFHANDLE * h)
{
  int error = 0;
  DPFContext *dpf;
  int i;
  usb_dev_handle *u;

  int fd;

  if (!dev)
    {
      fprintf (stderr,
               "Please specify a string like 'usb0' or a sg device\n");
      return DEVERR_OPEN;
    }

  if (strncmp (dev, "usb", 3) == 0)
    {
      i = dev[3] - '0';
      error = dpf_usb_open (i, &u);
      if (error < 0)
        return error;
      if (!u)
        return DEVERR_OPEN;
      i = error;                // USB mode
      error = 0;
    }
  else
    {
      fprintf (stderr, "Opening generic SCSI device '%s'\n", dev);
      if (sgdev_open (dev, &fd) < 0)
        return DEVERR_OPEN;
      i = MODE_SG;
    }

  dpf = (DPFHANDLE) malloc (sizeof (DPFContext));
  if (!dpf)
    return DEVERR_MALLOC;

  dpf->flags = 0;
  dpf->mode = i;

  switch (dpf->mode)
    {
    case MODE_USB:
      dpf->dev.udev = u;
      error = probe (dpf);
      fprintf (stderr, "Got LCD dimensions: %dx%d\n",
               dpf->width, dpf->height);
      dpf->methods = scsi_methods;
      break;
    case MODE_USBHID:
      dpf->dev.udev = u;
      dpf->methods = hid_methods;
      break;
    case MODE_SG:
      dpf->dev.fd = fd;
      dpf->methods = scsi_methods;
      break;
    default:
      fprintf (stderr, "Unknown interface mode\n");
      error = -1;
    }

  *h = dpf;
  return error;
}

void
dpf_close (DPFContext * h)
{
  switch (h->mode)
    {
    case MODE_USBHID:
    case MODE_SG:
      close (h->dev.fd);
      break;
    case MODE_USB:
      usb_release_interface (h->dev.udev, 0);
      usb_close (h->dev.udev);
      break;
    }
  free (h);
}

const char *
dev_errstr (int err)
{
  switch (err)
    {
    case DEVERR_FILE:
      return "File I/O error";
    case DEVERR_OPEN:
      return "File open error";
    case DEVERR_HEX:
      return "Hex file error";
    case DEVERR_CHK:
      return "Checksum error";
    case DEVERR_IO:
      return "Common I/O error";
    case DEVERR_UNSUPP:
      return "Unsupported feature";
    default:
      return "Unknown error";
    }
}


int
flash_probe (DPFContext * h, unsigned char *id)
{
  return h->methods.flash_probe (h, id);
}

int
flash_cmd (DPFContext * h, int command, int cmdlen, ADDR addr)
{
  return h->methods.flash_cmd (h, command, cmdlen, addr);
}


/* Flash functions, API */

int
flash_read (DPFContext * h, unsigned char *buf, ADDR offset, int len)
{
  return h->methods.flash_read (h, buf, offset, len);
}

int
flash_status_wait (DPFContext * h, uint8_t mask)
{
  int error;
  uint8_t status;

  do
    {
      error = h->methods.flash_status (h, &status);
    }
  while ((status & mask) && !error);

  return error;
}


int
flash_write (DPFContext * h, const unsigned char *buf, ADDR offset, int len)
{
  int n;
  int error = 0;

  while (len > 0)
    {
      error = h->methods.flash_cmd (h, SPM_WREN, 1, 0);
      DEB (printf ("Write pages at %06x\n", offset));
      n = h->methods.flash_writechunk (h, buf, offset, len);
      error = flash_status_wait (h, SPS_WIP);

      if (n < 0)
        break;
      len -= n;
      buf += n;
      offset += n;
    }
  return error;
}

/* Mid level flash */

int
load_ihx (DPFContext * h, const char *fname, unsigned char *data,
          unsigned int *buflen, unsigned int reloc)
{
  unsigned char csum_is, csum_need;
  int ret;
  FILE *f;

  static char line[512];
  static unsigned char buf[0x100];
  int count;
  unsigned int addr, len, type;
  unsigned short b;
  unsigned int total = 0;

  DEB (printf ("Opening %s...\n", fname));
  f = fopen (fname, "r");
  if (f == NULL)
    {
      return DEVERR_OPEN;
    }

  while (1)
    {
      fgets (line, sizeof (line), f);

      if (feof (f) || ferror (f))
        break;

      if ((line[0] != ':') || (strlen (line) < 9))
        {
          fprintf (stderr, "invalid line in ihx\n");
          break;
        }

      ret = sscanf (&line[1], "%02x", &len);
      if (ret != 1)
        {
          ret = DEVERR_HEX;
          break;
        }

      ret = sscanf (&line[3], "%04x", &addr);
      if (ret != 1)
        {
          ret = DEVERR_HEX;
          break;
        }

      ret = sscanf (&line[7], "%02x", &type);
      if (ret != 1)
        {
          ret = DEVERR_HEX;
          break;
        }

#ifdef DEBUG
      printf ("len %u addr %04x type %u\n", len, addr, type);
#endif

      if (type == 1)
        break;

      if (type != 0)
        {
          fprintf (stderr, "ihx: unknown type %u\n", type);
          continue;
        }

      csum_need = len + (addr & 0xff) + (addr >> 8) + type;

      total += len;
      if (total > *buflen)
        {
          fprintf (stderr, "Buffer length exceeded. IHX file too big.\n");
          ret = DEVERR_HEX;
          break;
        }

      if (len > sizeof (buf))
        {
          fprintf (stderr, "Buffer length exceeded. Too long lines.\n");
          ret = DEVERR_HEX;
          break;
        }

      for (count = 0; count < len; count++)
        {
          ret = sscanf (&line[9 + count * 2], "%02hx", &b);
          if (ret != 1)
            {
              fprintf (stderr, "hex file: could not parse data!\n");
              break;
            }

          buf[count] = b;
          csum_need += buf[count];
        }

      if (ret != 1)
        {
          ret = DEVERR_HEX;
          break;
        }

      ret = sscanf (&line[9 + len * 2], "%02hx", &b);
      if (ret != 1)
        {
          ret = DEVERR_HEX;
          break;
        }

      csum_is = b;
      if (((csum_need + csum_is) & 0xff) != 0x00)
        {
          fprintf (stderr, "ihx: checksum failure! is: %02x should be:%02x\n",
                   csum_is, csum_need);
          ret = DEVERR_CHK;
          break;
        }

      if (addr < reloc)
        {
          fprintf (stderr, "Bad relocation value\n");
          ret = DEVERR_HEX;
          break;
        }
      // Copy to data buffer at relocated address
      if (data)
        {
          DEB (printf ("Patching at offset %08x, chunk size %d\n",
                       addr - reloc, len));
          memcpy (&data[addr - reloc], buf, len);
        }
      else
        {
          DEB (printf ("Writing to %04x (CODE: %04x), chunk size %d\n",
                       addr - reloc, addr, len));
          h->methods.mem_write (h, addr - reloc, buf, len);
        }
    }
  *buflen = total;
  fclose (f);
  return ret;
}

int
flash_erase_full (DPFContext * h)
{
  flash_cmd (h, SPM_RES, 1, 0);
  flash_cmd (h, SPM_WRSR, 2, 0); // clr status
  flash_cmd (h, SPM_WREN, 1, 0);
  flash_cmd (h, SPM_FLASH_BE, 1, 0);
  printf ("Erase full flash...\n");

  return flash_status_wait (h, SPS_WIP);
}

int
flash_erase (DPFContext * h, ADDR addr)
{
  int error;
  flash_cmd (h, SPM_RES, 1, 0);
  flash_cmd (h, SPM_WREN, 1, 0);
  flash_cmd (h, SPM_WRSR, 2, 0); // clr status

  // now erase flash sector:
  flash_cmd (h, SPM_WREN, 1, 0);
  flash_cmd (h, SPM_FLASH_SE, 4, addr);

  error = flash_status_wait (h, SPS_WIP);
  flash_cmd (h, SPM_WRDI, 1, 0);

  return error;
}

int
dpf_flash_lock (DPFContext * h, char enable)
{
  if (h->methods.flash_lock)
    return h->methods.flash_lock (h, enable);
  else
    return DEVERR_UNSUPP;
}


int
patch_sector (DPFContext * h,
              ADDR reloc, unsigned long addr, const char *hexfile)
{
  int error;
  unsigned short offset;
  static unsigned char readbuf[0x10000];
  unsigned int len = sizeof (readbuf);

  offset = addr & 0xffff;
  addr -= offset;

  error = flash_read (h, readbuf, addr, 0x10000);
  if (error < 0)
    {
      perror ("Reading flash");
      return error;
    }

  error = load_ihx (h, hexfile, &readbuf[offset], &len, reloc);
  if (error < 0)
    {
      fprintf (stderr, "Failed to load HEX file\n");
      return error;
    }
  // Lock DPF handler so nothing can interfere with the flashing (in case
  // we flash ourselves)
  dpf_flash_lock (h, 1);
  error = flash_cmd (h, SPM_WREN, 1, 0);
  error = flash_cmd (h, SPM_WRSR, 2, 0); // clr status

  error = flash_erase (h, addr);
  if (error < 0)
    return error;

  error = flash_write (h, readbuf, addr, 0x10000); // clr status
  dpf_flash_lock (h, 0);

  return error;
}

////////////////////////////////////////////////////////////////////////////
// High level functions, generic
// These require a hacked command handler with extended command set.


int
load_hexfile (DPFContext * h, const char *hexfile)
{
  unsigned int len = 0xc000;
  int error;

  error = load_ihx (h, hexfile, 0, &len, 0x800);
  return error;
}

#define CHUNK_SIZE 1024

int
read_mem (DPFContext * h, unsigned char *buf, ADDR src, unsigned short len)
{
  int error = 0;
  if (!h->methods.mem_read)
    return DEVERR_UNSUPP;

  while (len > CHUNK_SIZE && error >= 0)
    {
      error = h->methods.mem_read (h, buf, src, CHUNK_SIZE);
      src += CHUNK_SIZE;
      len -= CHUNK_SIZE;
      buf += CHUNK_SIZE;
    }
  error = h->methods.mem_read (h, buf, src, len);

  return error;
}

int
write_mem (DPFContext * h, ADDR dst, const unsigned char *buf,
           unsigned short len)
{
  return h->methods.mem_write (h, dst, buf, len);
}

int
code_go (DPFContext * h, ADDR start)
{
  printf ("Executing applet..\n");
  if (h->methods.go)
    return h->methods.go (h, start);
  return DEVERR_UNSUPP;
}



////////////////////////////////////////////////////////////////////////////
// High level functions, DPF specific

/* Bootstrap mode: Expects contiguous memory block to download, then jumps
 * into start address
 */

int
dpf_bootstrap (DPFContext * h,
               ADDR dest, unsigned char *src, unsigned short n, ADDR start)
{
  if (h->methods.bootstrap)
    return h->methods.bootstrap (h, dest, src, n, start);
  else
    return DEVERR_UNSUPP;
}