/** libdpf header file
 *
 * (c) 2010, 2011 <hackfin@section5.ch>
 *
 */

#include <stdint.h>
#include <usb.h>
#include "usbuser.h"
#include "spiflash.h"

#define ADDR unsigned int

#define MODE_SG     0x00        ///< generic device mode (original)
#define MODE_USB    0x01        ///< libusb operation mode (hacked)
#define MODE_USBHID 0x02        ///< libusb HID boot mode

#define FLAG_CAN_LOCK 0x80      ///< Has the locking feature (new firmware)

enum
{
  DEVERR_FILE = -16,
  DEVERR_OPEN,
  DEVERR_HEX,
  DEVERR_CHK,
  DEVERR_IO,
  DEVERR_MALLOC,
  DEVERR_TIMEOUT,
  DEVERR_UNSUPP,
};

/** The DPF context structure */
struct dpf_context;
#define DPFHANDLE struct dpf_context *

typedef struct
{
  int (*mem_read) (DPFHANDLE h, unsigned char *buf, ADDR offset, int len);
  int (*mem_write) (DPFHANDLE h,
                    ADDR dst, const unsigned char *buf, unsigned short n);
  int (*go) (DPFHANDLE h, ADDR start);
  int (*bootstrap) (DPFHANDLE h,
                    ADDR dest, unsigned char *src, unsigned short n,
                    ADDR start);
  int (*flash_probe) (DPFHANDLE h, unsigned char *id);
  int (*flash_cmd) (DPFHANDLE h, int command, int cmdlen, ADDR addr);
  int (*flash_status) (DPFHANDLE h, uint8_t * status);
  int (*flash_read) (DPFHANDLE h, uint8_t * buf, ADDR offset, int len);
  int (*flash_writechunk) (DPFHANDLE h,
                           const uint8_t * buf, ADDR offset, int len);
  int (*flash_lock) (DPFHANDLE h, char enable);
} AccessMethods;

typedef struct dpf_context
{
  unsigned char mode;
  unsigned char flags;
  union
  {
    usb_dev_handle *udev;
    int fd;
  } dev;
  AccessMethods methods;
  unsigned int width;
  unsigned int height;
  int bpp;
  int proto;
  char *buff;
  unsigned char *oldpix;
  int offx;
  int offy;
} DPFContext;


/** A value proxy for the property API */
typedef struct dpf_proxy
{
  union
  {
    short integer;
    char *sequence;
  } value;
  char type;
} DPFValue;

enum
{
  TYPE_INTEGER,
  TYPE_STRING,
};

/**
 Opens the DPF device. if dev is not NULL, open device, otherwise, look for
 USB device.
 */
int dpf_open (const char *dev, DPFHANDLE * h);

/** Close DPF device */
void dpf_close (DPFHANDLE h);

/** Set color register
 * \param rgb     RGB tuple */
int dpf_setcol (DPFHANDLE h, const unsigned char *rgb);

/** Blit data to screen
 *
 * \param buf     buffer to 16 bpp RGB 565 image data
 * \param rect    rectangle tuple: [x0, y0, x1, y1]
 */

int dpf_screen_blit (DPFHANDLE h, const unsigned char *buf, short rect[4]);

/** Set property on DPF
 * \param token       Property token
 * \param value       Pointer to value
 */
int dpf_setproperty (DPFHANDLE h, int token, const DPFValue * value);

/* USB raw */

int emulate_scsi (usb_dev_handle * d, unsigned char *cmd, int cmdlen,
                  char out, unsigned char *data, unsigned long block_len);

const char *dev_errstr (int err);

// Private stuff:
int dpf_usb_open (int index, usb_dev_handle ** u);
int sgdev_open (const char *portname, int *fd);
int usb_rawread (usb_dev_handle * dev, unsigned char *buf, int len);
int usb_rawwrite (usb_dev_handle * dev, const unsigned char *buf, int len);
int probe (DPFHANDLE h);

////////////////////////////////////////////////////////////////////////////
// Bootloader functionality

int bl_go (DPFContext * dpf, uint16_t jmpoffset);

////////////////////////////////////////////////////////////////////////////
// FLASH stuff

// Maximum size for flash_read
#define MAX_CHUNKSIZE 0x10000

int read_mem (DPFHANDLE h, unsigned char *buf, ADDR src, unsigned short len);
int write_mem (DPFHANDLE h,
               ADDR dst, const unsigned char *buf, unsigned short len);

int load_hexfile (DPFHANDLE h, const char *hexfile);
int code_go (DPFHANDLE h, ADDR start);

int dpf_bootstrap (DPFHANDLE h,
                   ADDR dst, unsigned char *src, unsigned short n,
                   ADDR start);

int flash_cmd (DPFHANDLE h, int command, int cmdlen, ADDR addr);
int flash_probe (DPFContext * h, unsigned char *id);
int flash_erase (DPFHANDLE h, ADDR offset);
int flash_erase_full (DPFHANDLE h);
int flash_write (DPFHANDLE h, const unsigned char *buf, ADDR offset, int len);
int flash_read (DPFHANDLE h, unsigned char *buf, ADDR offset, int len);

int load_ihx (DPFHANDLE h, const char *fname, unsigned char *data,
              unsigned int *buflen, unsigned int reloc);

int patch_sector (DPFHANDLE h,
                  ADDR reloc, unsigned long addr, const char *hexfile);

////////////////////////////////////////////////////////////////////////////
/* DPF specific stuff: */

#define RGB565_0(r, g, b) \
	(( ((r) & 0xf8)		 ) | (((g) & 0xe0) >> 5))
#define RGB565_1(r, g, b) \
	(( ((g) & 0x1c) << 3 ) | (((b) & 0xf8) >> 3))

#define RGB565(r, g, b) { RGB565_0(r, g, b), RGB565_1(r, g, b) }

#define RGB565_S(r, g, b) ((RGB565_0(r, g, b) << 8) | RGB565_1(r, g, b))

int dpfcpy (ADDR dst, unsigned char *src, unsigned short n);

// int clr_screen(DPFHANDLE h, const unsigned char *col);
int write_screen (DPFHANDLE h, const unsigned char *buf, unsigned int len);


// Some internal address offsets. They may change, but so far all types
// seem to have the same
//
// w: word, <n>: length, [LE, BE]
//
// FIXME: Use packed struct later.

// FIXME: Should be 0x0020, once we have the firmware replaced
#define OFFSET_PROPS 0x3f0020   ///< w[2]:LE : Resolution X, Y