Subversion Repositories usb_dongle_fpga

#! /usr/bin/python

# -*- coding: ISO-8859-1 -*-

##########################################################################

# LPC Dongle programming software 

#

# Copyright (C) 2008 Artec Design

# 

# This library is free software; you can redistribute it and/or

# modify it under the terms of the GNU Lesser General Public

# License as published by the Free Software Foundation; either

# version 2.1 of the License, or (at your option) any later version.

# 

# This software 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

# Lesser General Public License for more details.

# You should have received a copy of the GNU Lesser General Public

# License along with this library; if not, write to the Free Software

# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

##########################################################################

#-------------------------------------------------------------------------

# Project:   LPC Dongle programming software 

# Name:      dongle.py

# Purpose:   Executable command line tool 

#

# Author:    Jüri Toomessoo <jyrit@artecdesign.ee>

# Copyright: (c) 2008 by Artec Design

# Licence:   LGPL

#

# Created:   06 Oct. 2006

# History:   12 oct. 2006  Version 1.0 released

#            22 Feb. 2007  Test options added to test PCB board

#            10 Nov. 2007  Added open retry code to dongle

#            14 Nov. 2007  Moved dongle spesific code to class Dongle from USPP

#                          USPP is allmost standard now (standard USPP would work)

#                          Artec USPP has serial open retry

#            14 Nov. 2007  Improved help. 

#            10 Mar. 2008  Forced code to hw flow control settings made linux 1 byte read to 2 bytes

#                          as dongle never reads 1 byte at the time

#            18 Apr. 2008  Added file size boundary check on write to see if remaining size from

#                          given offset fits the file size

#-------------------------------------------------------------------------

import os

import sys

import string

import time

import struct

from sets import *

from struct import *

#### inline of artec FTDI spesific Uspp code ###################################################

##########################################################################

# USPP Library (Universal Serial Port Python Library)

#

# Copyright (C) 2006 Isaac Barona <ibarona@gmail.com>

# 

# This library is free software; you can redistribute it and/or

# modify it under the terms of the GNU Lesser General Public

# License as published by the Free Software Foundation; either

# version 2.1 of the License, or (at your option) any later version.

# 

# This library 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

# Lesser General Public License for more details.

# You should have received a copy of the GNU Lesser General Public

# License along with this library; if not, write to the Free Software

# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

##########################################################################

#-------------------------------------------------------------------------

# Project:   USPP Library (Universal Serial Port Python Library)

# Name:      uspp.py

# Purpose:   Main module. Imports the correct module for the platform

#            in which it is running.

#

# Author:    Isaac Barona Martinez <ibarona@gmail.com>

# Contributors:

#            Damien Géranton <dgeranton@voila.fr>

#            Douglas Jones <dfj23@drexel.edu>

#            J.Grauheding <juergen.grauheding@a-city.de>

#            J.Toomessoo jyrit@artecdesign.ee

#

# Copyright: (c) 2006 by Isaac Barona Martinez

# Licence:   LGPL

#

# Created:   26 June 2001

# History:

#            05/08/2001: Release version 0.1.

#            24/02/2006: Final version 1.0.

#            10/11/2007: Added open retry code to dongle

#                        by Jyri Toomessoo jyrit@artecdesign.ee

#            14/11/2007: Moved dongle spesific code to class Dongle from USPP

#                        USPP is allmost standard now (standard USPP would work)

#                        Artec USPP has serial open retry

#                        by Jyri Toomessoo jyrit@artecdesign.ee

#            10/03/2008: Forced code to hw flow control settings made linux 1 byte read to 2 bytes

#                        as dongle never reads 1 byte at the time

#                        by Jyri Toomessoo jyrit@artecdesign.ee

#            10/03/2008: Copose single infile bundle for FTDI USB serial 1.2

#                        this is nonuniversal modification of the code to suite the need of Artec Design Dongle

#                        by Jyri Toomessoo jyrit@artecdesign.ee

#-------------------------------------------------------------------------

drv_ok = 0

if sys.platform=='win32':

    print "Windows platform detected:"

    if drv_ok == 0:

        try:

            from win32file import *

            from win32event import *

            import win32con

            import exceptions

            print "Using VCP FTDI driver"

        except ImportError,SerialPortException:

            print "Python for winiows extensions for COM not found"

            print "(see https://sourceforge.net/projects/pywin32/)"

            print "Could not find any usable support for FTDI chip in python"

            print "Try installing python support from one of the links."

            sys.exit()

elif sys.platform=='linux2':

    from termios import *

    import fcntl

    import exceptions

    import array

    print "Linux platform detected:"

else:

    sys.exit('Sorry, no implementation for this platform yet')

class SerialPortException(exceptions.Exception):

    """Exception raise in the SerialPort methods"""

    def __init__(self, args=None):

        self.args=args

    def __str__(self):

        return repr(self.args)

if sys.platform=='win32':

  class SerialPortWin:

    BaudRatesDic={110: CBR_110,

                  300: CBR_300,

                  600: CBR_600,

                  1200: CBR_1200,

                  2400: CBR_2400,

                  4800: CBR_4800,

                  9600: CBR_9600,

                  19200: CBR_19200,

                  38400: CBR_38400,

                  57600: CBR_57600,

                  115200: CBR_115200,

                  128000: CBR_128000,

                  256000: CBR_256000

                  }

    def __init__(self, dev, timeout=None, speed=115200, mode='232', params=None):

        self.__devName, self.__timeout, self.__speed=dev, timeout, speed

        self.__mode=mode

        self.__params=params

        self.__speed = 0

        self.__reopen = 0

        while 1:

            try:

                self.__handle=CreateFile (dev,

                win32con.GENERIC_READ|win32con.GENERIC_WRITE,

                0, # exclusive access

                None, # no security

                win32con.OPEN_EXISTING,

                win32con.FILE_ATTRIBUTE_NORMAL,

                None)

                break

            except:

                n=0

                while (n < 2000000):

                    n += 1;

                self.__reopen = self.__reopen + 1

            if self.__reopen > 32:

                print "Port does not exist..."

                raise SerialPortException('Port does not exist...')

                break

                #sys.exit()

        self.__configure()

    def __del__(self):

        if self.__speed:

            try:

                CloseHandle(self.__handle)

            except:

                raise SerialPortException('Unable to close port')

    def __configure(self):

        if not self.__speed:

            self.__speed=115200

        # Tell the port we want a notification on each char

        SetCommMask(self.__handle, EV_RXCHAR)

        # Setup a 4k buffer

        SetupComm(self.__handle, 4096, 4096)

        # Remove anything that was there

        PurgeComm(self.__handle, PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|

                  PURGE_RXCLEAR)

        if self.__timeout==None:

            timeouts= 0, 0, 0, 0, 0

        elif self.__timeout==0:

            timeouts = win32con.MAXDWORD, 0, 0, 0, 1000

        else:

            timeouts= self.__timeout, 0, self.__timeout, 0 , 1000

        SetCommTimeouts(self.__handle, timeouts)

        # Setup the connection info

        dcb=GetCommState(self.__handle)

        dcb.BaudRate=SerialPortWin.BaudRatesDic[self.__speed]

        if not self.__params:

            dcb.ByteSize=8

            dcb.Parity=NOPARITY

            dcb.StopBits=ONESTOPBIT

            dcb.fRtsControl=RTS_CONTROL_ENABLE

            dcb.fOutxCtsFlow=1

        else:

            dcb.ByteSize, dcb.Parity, dcb.StopBits=self.__params

        SetCommState(self.__handle, dcb)

    def fileno(self):

        return self.__handle

    def read(self, num=1):

        (Br, buff) = ReadFile(self.__handle, num)

        if len(buff)<>num and self.__timeout!=0: # Time-out  

            print 'Expected %i bytes but got %i before timeout'%(num,len(buff))

            raise SerialPortException('Timeout')

        else:

            return buff

    def readline(self):

        s = ''

        while not '\n' in s:

            s = s+SerialPortWin.read(self,1)

        return s

    def write(self, s):

        """Write the string s to the serial port"""

        errCode = 0

        overlapped=OVERLAPPED()

        overlapped.hEvent=CreateEvent(None, 0,0, None)

        (errCode, bytesWritten) = WriteFile(self.__handle, s,overlapped)

        # Wait for the write to complete

        WaitForSingleObject(overlapped.hEvent, INFINITE)

        return bytesWritten

    def inWaiting(self):

        """Returns the number of bytes waiting to be read"""

        flags, comstat = ClearCommError(self.__handle)

        return comstat.cbInQue

    def flush(self):

        """Discards all bytes from the output or input buffer"""

        PurgeComm(self.__handle, PURGE_TXABORT|PURGE_RXABORT|PURGE_TXCLEAR|

                  PURGE_RXCLEAR)

if sys.platform=='linux2':

  class SerialPortLin:

    """Encapsulate methods for accesing to a serial port."""

    BaudRatesDic={

        110: B110,

        300: B300,

        600: B600,

        1200: B1200,

        2400: B2400,

        4800: B4800,

        9600: B9600,

        19200: B19200,

        38400: B38400,

        57600: B57600,

        115200: B115200,

        230400: B230400

        }

    buf = array.array('h', '\000'*4)

    def __init__(self, dev, timeout=None, speed=115200, mode='232', params=None):

        self.__devName, self.__timeout, self.__speed=dev, timeout, speed

        self.__mode=mode

        self.__params=params

        self.__speed = 0

        self.__reopen = 0

        while 1:

            try:

                self.__handle=os.open(dev, os.O_RDWR)

                break

            except:

                n=0

                while (n < 2000000):

                    n += 1;

                self.__reopen = self.__reopen + 1

            if self.__reopen > 32:

                print "Port does not exist..."

                raise SerialPortException('Port does not exist...')

                break

        self.__configure()

    def __del__(self):

        if self.__speed:

            #tcsetattr(self.__handle, TCSANOW, self.__oldmode)

            pass

            try:

                pass

                os.close(self.__handle)

            except IOError:

                raise SerialPortException('Unable to close port')

    def __configure(self):

        if not self.__speed:

            self.__speed=115200

        # Save the initial port configuration

        self.__oldmode=tcgetattr(self.__handle)

        if not self.__params:

            # print "Create linux params for serialport..."

            # self.__params is a list of attributes of the file descriptor

            # self.__handle as follows:

            # [c_iflag, c_oflag, c_cflag, c_lflag, c_ispeed, c_ospeed, cc]

            # where cc is a list of the tty special characters.

            self.__params=[]

            # c_iflag

            self.__params.append(IGNPAR)

            # c_oflag

            self.__params.append(0)

            # c_cflag

            self.__params.append(CS8|CREAD|CRTSCTS)

            # c_lflag

            self.__params.append(0)

            # c_ispeed

            self.__params.append(SerialPortLin.BaudRatesDic[self.__speed])

            # c_ospeed

            self.__params.append(SerialPortLin.BaudRatesDic[self.__speed])

            cc=[0]*NCCS

        if self.__timeout==None:

            # A reading is only complete when VMIN characters have

            # been received (blocking reading)

            cc[VMIN]=1

            cc[VTIME]=0

        elif self.__timeout==0:

            cc[VMIN]=0

            cc[VTIME]=0

        else:

            cc[VMIN]=0

            cc[VTIME]=self.__timeout #/100

        self.__params.append(cc)               # c_cc

        tcsetattr(self.__handle, TCSANOW, self.__params)

    def fileno(self):

        return self.__handle

    def __read1(self):

        tryCnt = 0

        byte = ""

        while(len(byte)==0 and tryCnt<10):

            tryCnt+=1

            byte = os.read(self.__handle, 2)

        if len(byte)==0 and self.__timeout!=0: # Time-out

            print 'Time out cnt was %i'%(tryCnt)

            print 'Expected 1 byte but got %i before timeout'%(len(byte))

            sys.stdout.flush()

            raise SerialPortException('Timeout')

        else:

            return byte

    def read(self, num=1):

        s=''

        for i in range(num/2):

            s=s+SerialPortLin.__read1(self)

        return s

    def readline(self):

        s = ''

        while not '\n' in s:

            s = s+SerialPortLin.__read1(self)

        return s

    def write(self, s):

        """Write the string s to the serial port"""

        return os.write(self.__handle, s)

    def inWaiting(self):

        """Returns the number of bytes waiting to be read"""

        data = struct.pack("L", 0)

        data=fcntl.ioctl(self.__handle, TIOCINQ, data)

        return struct.unpack("L", data)[0]

    def outWaiting(self):

        """Returns the number of bytes waiting to be write

        mod. by J.Grauheding

        result needs some finetunning

        """

        rbuf=fcntl.ioctl(self.__handle, TIOCOUTQ, self.buf)

        return rbuf

    def flush(self):

        """Discards all bytes from the output or input buffer"""

        tcflush(self.__handle, TCIOFLUSH)

#### end inline of artec FTDI spesific Uspp code ###############################################

#### Dongle code starts here  ##################################################################

#### global funcs ####

def usage(s):

    print "Artec USB Dongle programming utility ver. 2.52"

    print "Usage:"

    print "Write file      : ",s," [-vq] -c <name> <file> <offset>"

    print "Readback file   : ",s," [-vq] -c <name> [-vq] -r <offset> <length> <file>"

    print "Options:"

    print " <file> <offset> When file and offset are given file will be written to dongle"

    print "        file:    File name to be written to dongle"

    print "        offset:  Specifies data writing starting point in bytes to 4M window"

    print "                 For ThinCan boot code the offset = 4M - filesize. To write"

    print "                 256K file the offset must be 3840K"

    print " "

    print " -c <name>       Indicate port name where the USB Serial Device is"

    print "        name:    COM port name in Windows or Linux Examples: COM3,/dev/ttyS3"

    print "                 See Device Manager in windows for USB Serial Port number"

    print " "

    print " -v              Enable verbose mode. Displays more progress information"

    print " "

    print " -q              Perform flash query to see if dongle flash is responding"

    print " "

    print " -r <offset> <length> <file>  Readback data. Available window size is 4MB"

    print "        offset:  Offset byte addres inside 4MB window. Example: 1M"

    print "                 use M for MegaBytes, K for KiloBytes, none for bytes"

    print "                 use 0x prefix to indicate hexademical number format"

    print "        length:  Amount in bytes to read starting from offset. Example: 1M"

    print "                 use M for MegaBytes, K for KiloBytes, none for bytes"

    print "        file:    Filename where data will be written"

    print " "

    print " -e              Erase device. Erases Full 4 MegaBytes"

    print "Board test options: "

    print " -t              Marching one and zero test. Device must be empty"

    print "                 To test dongle erase the flash with command -e"

    print "                 Enables dongle memory tests to be executed by user"

    print " "

    print " -b              Leave flash blank after test. Used with option -t"

    print " -l              Fast poll loop test. Does poll loop 1024 times"

    print "                 used to stress test connection"

    print ""

    print "Examples:"

    print ""

    print " ",s," -c COM3 loader.bin 0                       "

    print " ",s," -c /dev/ttyS3 boot.bin 3840K"

    print " ",s," -c COM3 -r 0x3C0000 256K flashcontent.bin"

######################

class DongleMode:

    def __init__(self):

        self.v = 0

        self.f = 0

        self.d = 0

        self.q = 0

        self.r = 0

        self.t = 0

        self.e = 0

        self.b = 0

        self.l = 0

        self.filename=""

        self.portname=""

        self.address=-1

        self.offset=-1

        self.length=-1

        self.version=4

    def convParamStr(self,param):

        mult = 1

        value = 0

        str = param

        if str.find("K")>-1:

            mult = 1024

            str=str.strip("K")

        if str.find("M")>-1:

            mult = 1024*1024

            str=str.strip("M")

        try:

            if str.find("x")>-1:

                value = int(str,0)*mult  #conver hex string to int

            else:

                value = int(str)*mult  #conver demical string to int

        except ValueError:

            print "Bad parameter format given for: ",param

        return value

class Dongle:

    def __init__(self,name, baud, timeout):  #time out in millis 1000 = 1s baud like 9600, 57600

        self.mode = 0

        try:

            if sys.platform=='win32':

                self.tty = SerialPortWin(name,timeout, baud)

            else:

                self.tty = SerialPortLin(name,timeout, baud)

        except SerialPortException , e:

            print "Unable to open port " + name

            sys.exit();

    def testReturn(self,byteCount):

        i=0

        while don.tty.inWaiting()<byteCount:

            i=i+1

            if i==10000*byteCount:

                break

        if i==10000*byteCount:

            return 0

        j=don.tty.inWaiting()

        #print "Tested in waiting %i needed %i"%(j,byteCount)

        return j  ## ret two bytes            

    def getReturn(self,byteCount):

        i=0

        #while don.tty.inWaiting()<byteCount:

        #    i=i+1

        #    time.sleep(0.1)

        #    if i==100*byteCount:

        #        print "Dongle not communicating"

        #        #print "Read in waiting %i needed %i was %i"%(i,byteCount,don.tty.inWaiting())

        #        sys.exit()

        #        break

        #i=don.tty.inWaiting()

        #print "Read in waiting %i needed %i was %i"%(i,byteCount,don.tty.inWaiting())

        buf = don.tty.read(byteCount)

        #print "Got bytes =%i "%(len(buf))

        return buf  ## ret two bytes

    def write_command(self,command):

        lsb = command&0xff

        msb = (command>>8)&0xff

        self.write_2bytes(msb,lsb)

    def write_2bytes(self, msb,lsb):

        """Write one word MSB,LSB to the serial port MSB first"""

        s = pack('BB', msb, lsb)

        ret = self.tty.write(s)

        if(ret<len(s)):

            print 'write_2byte: Wrote less then needed %i bytes from %i'%(ret,length(s))

        # Wait for the write to complete

        #WaitForSingleObject(overlapped.hEvent, INFINITE)               

    def get_address_buf(self,address):  #set word address

        lsbyte = address&0xff

        byte = (address>>8)&0xff

        msbyte = (address>>16)&0xff

        buffer = ""

        buffer += chr(lsbyte)

        buffer += chr(0xA0)

        buffer +=  chr(byte)

        buffer +=  chr(0xA1)

        buffer +=  chr(msbyte)

        buffer +=  chr(0xA2)

        evaluate = (address>>24)

        if evaluate != 0:

            print "Addressign fault. Too large address passed"

            sys.exit()

        return buffer

    def set_address(self,address):  #set word address

        lsbyte = address&0xff

        byte = (address>>8)&0xff

        msbyte = (address>>16)&0xff

        evaluate = (address>>24)

        if evaluate != 0:

            print "Addressign fault. Too large address passed"

            sys.exit()

        self.write_2bytes(lsbyte,0xA0)            #set internal address to dongle

        self.write_2bytes(byte,0xA1)            #set internal address to dongle

        self.write_2bytes(msbyte,0xA2)            #send query command

    def read_data(self,wordCount,address):

        command = 0

        byteCount = wordCount<<1  #calc byte count

        if wordCount>0 :

            command = (command|wordCount)<<8;

            command = command|0xCD

            self.set_address(address)    # send read address

            self.write_command(command)  # send get data command

            return self.getReturn(byteCount)

        else:

            print "Word count can't be under 1"

            sys.exit()

    def issue_blk_read(self):

        command = 0

        wordCount = 0

        byteCount = wordCount<<1  #calc byte count

        command = (command|wordCount)<<8;

        command = command|0xCD

        self.write_command(command)  # send get data command

    def read_status(self):

        don.write_command(0x0070) # 0x0098 //clear status

        command = 0

        wordCount= 1  #calc byte count

        byteCount = wordCount<<1

        command = (command|wordCount)<<8;

        command = command|0xCD

        self.write_command(command)  # send get data command

        return self.getReturn(byteCount)

    def get_block_no(self,address):

        return address >> 16 # 16 bit mode block is 64Kwords

    def wait_on_busy(self):

        exit=0

        while exit==0:

            buf=self.read_status()

            statReg = ord(buf[0])  #8 bit reg

            if statReg>>7 == 1:

                exit=1

    def parse_status(self):  # use only after wait on busy commad to get result of the operation

        exit = 0

        buf=self.read_status()

        statReg = ord(buf[0])  #8 bit reg

        if (statReg>>5)&1 == 1:

            print "Block erase suspended"

            exit = 1

        if (statReg>>4)&3 == 3:

            print "Error in command order"  #if bits 4 and 5 are set then 

            exit = 1

        if (statReg>>4)&3 == 1:

            print "Error in setting lock bit"

            exit = 1

        if (statReg>>3)&1 == 1:

            print "Low Programming Voltage Detected, Operation Aborted"

            exit = 1

        if (statReg>>2)&1 == 1:

            print "Programming suspended"

            exit = 1

        if (statReg>>1)&1 == 1:

            print "Block lock bit detected"

            exit = 1

        if exit == 1:

            sys.exit()

    def erase_block(self,blockNo):

        blockAddress = blockNo << 16

        command = 0x0020

        self.set_address(blockAddress)

        self.write_command(command)  #issue block erase

        command = 0x00D0

        self.write_command(command)  #issue block erase confirm

        #self.wait_on_busy()

        #self.parse_status()

    def buffer_write(self,wordCount,startAddress,buffer):

        # to speed up buffer writing compose all commands into one buffer

        # instead of multiple single writes this is needed as the FTDI chip

        # round lag is amazingly large with VCOM drivers

        #u = len(buffer)

        if len(buffer)<32:            #don't ever make unaligned writes

            i=len(buffer)

            while len(buffer)<32:

                buffer += "\xff"

        adrBuf = self.get_address_buf(startAddress)   #6 bytes total

        cmd_e8=""  #8 bytes total

        cmd_e8+= chr(16)   #make it always 16 wordCount

        cmd_e8+= chr(0xE8)

        cmd_wcnt=""  #10 bytes total

        cmd_wcnt+= chr(0x00)