/*************************************************************************\
* Copyright (C) <2001>  <AJ Erasmus>
* antone@sentechsa.com
*
* 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
*
\*************************************************************************/
/********************************************************************\
*
*  Atmel AVR JTAG Programmer for Altera Byteblaster Hardware
*
*  Dec 2001     Ver 0.1 Initial Version
*                       Compiled using Turbo C - Only Supports 64K
*                       Only ATMega128 Supported
*
*  Jun 2002     Ver 1.0 Updated to Compile using GCC
*                       Supports 128K
*
*  May 2003     Ver 2.0 Added support for ATMega32 and ATMega16
*                       Use ioperm in cygwin environment
*                       Should then work on Win2000 and WinXP under
*                       cygwin
*
*  Jun 2003     Ver 2.1 Added support for ATMega64 (untested)
*  Jul 2003     Ver 2.2 Added support for ATMega162
*  Sep 2003     Ver 2.3 Added support for ATMega169 (no fuses yet)
*  Sep 2003     Ver 2.4 Added verify flag (-V)
*  Dec 2004     Ver 2.5 Added support for AT90CAN128 (By Uwe Bonnes)
*  May 2005     Ver 2.6 Added fixes for AT90CAN128 support (By Uwe Bonnes)
*  Oct 2005     Ver 2.7 Fixed problem with code needing device info being
*                       called before device ID has been read via JTAG.
*                       (This bug affected all devices except ATMega128)
*
*  $Id: javr.h,v 1.8 2005/10/17 18:01:23 anton Exp $
*  $Log: javr.h,v $
*  Revision 1.8  2005/10/17 18:01:23  anton
*  command line parsing and file reading has been split.
*  version upped to version 2.7
*
*  Revision 1.7  2005/05/16 19:43:45  anton
*  Upped version to 2.6 (Added fixes by Uwe Bonnes)
*
*  Revision 1.6  2005/03/23 21:03:49  anton
*  Added GPL License to source files
*
*  Revision 1.5  2005/03/23 20:16:12  anton
*  Updates by Uwe Bonnes to add support for AT90CAN128
*
*  Revision 1.4  2003/09/28 14:31:04  anton
*  Added --help command, display GPL
*
*  Revision 1.3  2003/09/28 12:49:45  anton
*  Updated Version, Changed Error printing in Verify
*
*  Revision 1.2  2003/09/27 19:21:59  anton
*  Added support for Linux compile
*
*  Revision 1.1.1.1  2003/09/24 15:35:57  anton
*  Initial import into CVS
*
\********************************************************************/

#define MAX_FLASH_SIZE  (1024UL*128UL)   /* 128K */
#define MAX_EEPROM_SIZE 16384
#define FILL_BYTE       0xFF

typedef struct
{
  unsigned long Instruction;
  char BREAKPT;
}SCAN_1_Info;


typedef struct
{
  unsigned version:4;
  unsigned manuf_id:11;
  unsigned short partnumber;
}JTAG_ID;


typedef struct
{
  unsigned short jtag_id;
  unsigned short eeprom;
  unsigned long flash;
  unsigned short ram;
  unsigned char Index;  /* Use To access array of Device Specific routines */
  char *name;
}AVR_Data;

typedef struct
{
  unsigned short size[4]; /* BOOTSZ0, BOOTSZ1 Mapping size in bytes */
}BOOT_Size;


void JTAG_Test_Logic_Reset(void);
void JTAG_Run_Test_Idle(void);
void JTAG_Select_Shift_DR(void);
void JTAG_Shift_DR(void);
void JTAG_Tms(char x);
void JTAG_Tdi(char x);
void JTAG_Tck(char x);
void EmulateTAP(char TMS);
unsigned char JTAG_Read_Update_IR(unsigned char x);
unsigned long JTAG_Read_Update_DR(unsigned long x, char len);

void Reset_JTAG(void);
void Restore_Idle(void);
void TMS_High(void);
void TMS_low(void);
void Shift_Data_Array(int Size, char *Data);
void Shift_Data_Array_Output(int Size, char *Input, char *Output);
void Send_Instruction(int Size, char *Data);
void Send_Data(int Size, char *Data);
void Send_Instruction_Output(int Size, char *Data, char *Output);
void Send_Data_Output(int Size, char *Data, char *Output);



/* These defines must be in the same order as data in gAVR_Data[]  array */

#define ATMEGA128       0
#define ATMEGA64        1
#define ATMEGA323       2
#define ATMEGA32        3
#define ATMEGA16        4
#define ATMEGA162       5
#define ATMEGA169       6
#define AT90CAN128      7
#define UNKNOWN_DEVICE  0xFF



#ifdef JAVR_M

char *gVersionStr="2.7";


int gPort;
char gOldTAPState,gTAPState;
char gTMS;

const char *gTAPStateNames[16]={
                                "EXIT2_DR",
                                "EXIT1_DR",
                                "SHIFT_DR",
                                "PAUSE_DR",
                                "SELECT_IR_SCAN",
                                "UPDATE_DR",
                                "CAPTURE_DR",
                                "SELECT_DR_SCAN",
                                "EXIT2_IR",
                                "EXIT1_IR",
                                "SHIFT_IR",
                                "PAUSE_IR",
                                "RUN_TEST_IDLE",
                                "UPDATE_IR",
                                "CAPTURE_IR",
                                "TEST_LOGIC_RESET"
                               };



const AVR_Data gAVR_Data[]=
                        {/* jtag_id  eeprom  flash       ram    Index  name  */
                            {0x9702, 4096  , 131072UL  , 4096  , 0 ,   "ATMega128"},
                            {0x9602, 2048  , 65536UL   , 4096  , 0 ,   "ATMega64"},
                            {0x9501, 1024  , 32768UL   , 2048  , 0 ,   "ATMega323"},
                            {0x9502, 1024  , 32768UL   , 2048  , 0 ,   "ATMega32"},
                            {0x9403, 512   , 16384UL   , 1024  , 0 ,   "ATMega16"},
                            {0x9404, 512   , 16384UL   , 1024  , 0 ,   "ATMega162"},
                            {0x9405, 512   , 16384UL   , 1024  , 0 ,   "ATMega169"},
                            {0x9781, 4096  , 131072UL  , 4096  , 0 ,   "AT90CAN128"},
                            {0,0, 0, 0, 0, "Unknown"}
                          };

/* Must be in same sequence as gAVR_Data[] */
const BOOT_Size gBOOT_Size[]={
                              {{(4096*2),(2048*2),(1024*2),(512*2)}}, /* ATMega128 */
                              {{(4096*2),(2048*2),(1024*2),(512*2)}}, /* ATMega64 */
                              {{(2048*2),(1024*2),(512*2 ),(256*2)}}, /* ATMega323 */
                              {{(2048*2),(1024*2),(512*2 ),(256*2)}}, /* ATMega32 */
                              {{(1024*2),(512*2 ),(256*2 ),(128*2)}}, /* ATMega16 */
                              {{(1024*2),(512*2 ),(256*2 ),(128*2)}}, /* ATMega162 */
                              {{(1024*2),(512*2 ),(256*2 ),(128*2)}}, /* ATMega169 */
                              {{(4096*2),(2048*2),(1024*2),(512*2)}}  /* AT90CAN128 */
                             };


JTAG_ID gJTAG_ID;
AVR_Data gDeviceData;
BOOT_Size gDeviceBOOTSize;
unsigned char *gFlashBuffer;
unsigned char gEEPROMBuffer[MAX_EEPROM_SIZE];
unsigned long gFlashBufferSize;

#else
extern int gPort;
extern char gOldTAPState,gTAPState;
extern char gTMS;
extern const char *gTAPStateNames[16];
extern const char *gICEBreakerRegs[16];
extern const char gICEBreakerRegSizes[16];

extern JTAG_ID gJTAG_ID;
extern AVR_Data gDeviceData;
extern BOOT_Size gDeviceBOOTSize;

extern unsigned char *gFlashBuffer;
extern unsigned char gEEPROMBuffer[];
extern unsigned long gFlashBufferSize;

#endif

#ifdef __GNUC__

#ifndef  USE_IOPERM  /* Use definitions from io.h */
static __inline unsigned char
inb(unsigned short int port)
{
  unsigned char _v;

  __asm__ __volatile__ ("inb %w1,%0":"=a" (_v):"Nd" (port));
  return _v;
}

static __inline void
outb(unsigned short int port,unsigned char value)
{
  __asm__ __volatile__ ("outb %b0,%w1": :"a" (value), "Nd" (port));
}

#define OUT(p,v)        outb((p),(v))
#define IN(p)           inb(p)

#else

#define OUT(p,v)        outb((v),(p))
#define IN(p)           inb(p)

#endif

#else
#define OUT(p,v)        outportb((p),(v))
#define IN(p)           inportb(p)
#endif

/* Altera Byteblaster Definitions */
#define ENABLE_BIT      1       /* Base + 2, Inverted */
#define TCK_BIT         0       /* Base */
#define TMS_BIT         1       /* Base */
#define TDI_BIT         6       /* Base */
#define RESET_BIT       3       /* Base, Inverted by Open Collector Transistor */
#define TDO_BIT         7       /* Base + 1, Input */
#define LB_IN_BIT       6       /* Base + 1, Input */
#define LB_OUT_BIT      4       /* Base */

#define BIT_MASK(b)     (1<<(b))

#define JTAG_ENABLE(x)  OUT((gPort+2),((x) ? 0x00 : 0x02))     /* Base + 2, Bit 1, Inverted */
#define JTAG_TCK(x)     { \
                          unsigned char tmp; \
                          tmp=IN(gPort); \
                          tmp&=~0x01; \
                          tmp|=((x) ? 0x01 : 0x00); \
                          OUT((gPort),tmp); \
                        }       /* Base + 0, Bit 0 */

#define JTAG_TMS(x)     { \
                          unsigned char tmp; \
                          tmp=IN(gPort); \
                          tmp&=~0x02; \
                          tmp|=((x) ? 0x02 : 0x00); \
                          OUT((gPort),tmp); \
                        }       /* Base + 0, Bit 1 */


#define JTAG_TDI(x)     { \
                          unsigned char tmp; \
                          tmp=IN(gPort); \
                          tmp&=~0x40; \
                          tmp|=((x) ? 0x40 : 0x00); \
                          OUT((gPort),tmp); \
                        }       /* Base + 0, Bit 6 */

#define JTAG_RESET(x)   { \
                          unsigned char tmp; \
                          tmp=IN(gPort); \
                          tmp&=~0x08; \
                          tmp|=((x) ? 0x08 : 0x00); \
                          OUT((gPort),tmp); \
                        }       /* Base + 0, Bit 3 */


#define JTAG_LOOPBACK_OUT(x)     { \
                                   unsigned char tmp; \
                                   tmp=IN(gPort); \
                                   tmp&=~0x10; \
                                   tmp|=((x) ? 0x10 : 0x00); \
                                   OUT((gPort),tmp); \
                                 }       /* Base + 0, Bit 4 */

#define JTAG_LOOPBACK_IN()      ((IN(gPort+1)&0x40) ? 0x01 : 0x00) /* Base + 1, Bit 6 */
#define JTAG_TDO()              ((IN(gPort+1)&0x80) ? 0x01 : 0x00) /* Base + 1, Bit 7 */



/* TAP States */
#define TEST_LOGIC_RESET                0x0F
#define RUN_TEST_IDLE                   0x0C
#define SELECT_DR_SCAN                  0x07
#define CAPTURE_DR                      0x06
#define SHIFT_DR                        0x02
#define EXIT1_DR                        0x01
#define PAUSE_DR                        0x03
#define EXIT2_DR                        0x00
#define UPDATE_DR                       0x05
#define SELECT_IR_SCAN                  0x04
#define CAPTURE_IR                      0x0E
#define SHIFT_IR                        0x0A
#define EXIT1_IR                        0x09
#define PAUSE_IR                        0x0B
#define EXIT2_IR                        0x08
#define UPDATE_IR                       0x0D


/* JTAG Instructions 4 bits long for AVR */
/* Bits are reversed */
#define EXTEST                          "0000"   /* 0x0 */
#define IDCODE                          "1000"   /* 0x1 */
#define SAMPLE_PRELOAD                  "0100"   /* 0x2 */
#define BYPASS                          "1111"   /* 0xF */
#define AVR_RESET                       "0011"   /* 0xC */
#define PROG_ENABLE                     "0010"   /* 0x4 */
#define PROG_COMMANDS                   "1010"   /* 0x5 */
#define PROG_PAGELOAD                   "0110"   /* 0x6 */
#define PROG_PAGEREAD                   "1110"   /* 0x7 */


JTAG_ID ReadJTAGID(void);
void DisplayJTAG_ID(void);
unsigned long ArrayToUL(unsigned char Size, char *ptr);
void AllocateFlashBuffer(void);