Subversion Repositories usb_dongle_fpga

#! /usr/bin/python

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

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

# Programming utility for Altera EPCS memory on USB Dongle PCB

#

# 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:   Programming utility for Altera EPCS memory on USB Dongle PCB

# Name:      update.py

# Purpose:   Executable command line tool 

#

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

# Copyright: (c) 2008 by Artec Design

# Licence:   LGPL

#

# Created:   12 Mar. 2008

# History:   12 Mar. 2008  Version 0.2 released

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

import os

import sys

import string

import time

#### EPCS code starts here  ##################################################################

#### global funcs ####

def usage(s):

    print "Artec's Altera EPCS programming utility ver. 0.2.1 for USB Dongle"

    print "Use with Altera ByteBlaster II programmer or compatible clone on LPT1"

    print "like X-Blaster http://www.customcircuitsolutions.com/cable.html or"

    print "http://fpgaguy.110mb.com/"

    print "Usage:"

    print "Query           : ",s," -q"

    print "Write file      : ",s," [-v] <file>"

    print "Readback file   : ",s," [-v] -r <file>"

    print "Options:"

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

    print " -q              Perform EPCS and ByteBlaster II query to see if all is ok"

    print ""

    print "Examples:"

    print ""

    print " ",s," dongle_syn.rpd "

    print " ",s," -r epcs_content.rpd "

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

class DeviceMode:

    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 EPCSDevice:

    def __init__(self):

        self._data = 0xFF

        self.mode = 0                  #commands are bit flipped

        self.CMD_WRITE_ENABLE = 0x60   #0x06

        self.CMD_WRITE_DISABLE= 0x20   #0x04

        self.CMD_READ_STATUS=0xA0      #0x05

        self.CMD_READ_BYTES=0xC0       #0x03

        self.CMD_READ_ID=0xD5          #0xAB

        self.CMD_WRITE_STATUS=0x80     #0x01

        self.CMD_WRITE_BYTES=0x40      #0x02

        self.CMD_ERASE_BULK=0xE3       #0xC7

        self.CMD_ERASE_SECTOR=0x1B     #0xD8

        if sys.platform=='win32':

            try:

                import parallel

            except ImportError:

                print "Can't find pyparallel module"

                print "pyparallel is available at: "

                print "http://pyserial.sourceforge.net/pyparallel.html"

                print "Supports Windows NT/2k/XP trough giveio.sys"

                sys.exit()

            self.pport = parallel.Parallel()

        else:

            try:

                import parallel

            except ImportError:

                print "Can't find pyparallel module"

                print "pyparallel is available at: "

                print "http://pyserial.sourceforge.net/pyparallel.html"

                print "Supports Linux trough ppdev driver"

                sys.exit()

            self.pport = parallel.Parallel()

    def open(self):

        i=0

        self.pport.setAutoFeed(1) #enable BB II tristate buffers to drive

        #self.pport.setDataDir(0xFF)  #enable out mode on pport

        self.pport.setData(0x10)  # set pport D4 this is looped back to ACK when tri's are enabled

        if self.pport.getInAcknowledge():

            i=i+1

        self.pport.setData(0x00)  # set pport D4 this is looped back to ACK when tri's are enabled

        if not self.pport.getInAcknowledge():

            i=i+1

        if i==2:

            print "Found ByteBlaster II compatible programmer"

        else:

            print "Can't find ByteBlaster II on parallel port"

            sys.exit()

        self.pport.setData(0xFF)

        self._data = 0xFF

    def close(self):

        epcs.pport.setData(0xFF)

        epcs.pport.setAutoFeed(1) #disable BB II tristate buffers to drive

        epcs.clearPPDataBit(3)  #enable Cyclon chip

        epcs.clearPPDataBit(2)  #enable Cyclon chip     

    def setPPDataBit(self,bit_no):

        self._data = self._data|(1<<bit_no)

        self.pport.setData(self._data)

        #print "set bit %i setData(0x%2x)"%(bit_no,self._data)

        #time.sleep(0.0001)

    def clearPPDataBit(self,bit_no):

        self._data = self._data&(~(1<<bit_no))

        self.pport.setData(self._data)

        #print "clr bit %i setData(0x%2x)"%(bit_no,self._data)

        #time.sleep(0.0001)

    def setASDI(self,bit):

        bit_cleared = self._data&(~(1<<6))   # deal with bit 6 pport D6

        bit_cleared = bit_cleared|(bit<<6)

        self._data = bit_cleared

        self.pport.setData(self._data)

        #print "ast bit %i setData(0x%2x)"%(bit,self._data)

        #time.sleep(0.0001)

    def startCycle(self):

       self.clearPPDataBit(2)    # pport D2 is nCS so bit 2 must go low

       #time.sleep(0.0001)

    def endCycle(self):

        self.setPPDataBit(2)    # pport D2 is nCS so bit 2 must go low

        #time.sleep(0.0001)

    def clockCycle(self):

        self.clearPPDataBit(0)  # make falling edge

        #time.sleep(0.0001)

        self.setPPDataBit(0)    # make rising edge

        #time.sleep(0.0001)

    def writeCommand(self,command):

        i=0

        #print "-------------------"

        while i<8:

            self.setASDI(command&0x01)

            #print "write cmd bit %i"%(command&0x00000001)

            self.clockCycle()

            command = command >> 1

            i+=1

        #print "-------------------"

    def writeFlippedByte(self,byte):

        #ok lets do bit reversal in a byte

        #it would be faster with a look up table (even with autogenerated one) FIXME

        i=0

        while i<8:

            self.setASDI(byte&0x01)

            self.clockCycle()

            byte = byte >> 1

            i+=1

    def writeByte(self,byte):

        #ok lets do bit reversal in a byte

        #it would be faster with a look up table (even with autogenerated one) FIXME

        etyb = ((byte&0x01)<<7)|((byte&0x02)<<5)|((byte&0x04)<<3)|((byte&0x08)<<1)|((byte&0x10)>>1)|((byte&0x20)>>3)|((byte&0x40)>>5)|((byte&0x80)>>7)

        i=0

        while i<8:

            self.setASDI(etyb&0x01)

            self.clockCycle()

            etyb = etyb >> 1

            i+=1

    def writeAddress(self,address):

        byte = (address&0x00FF0000)>>16

        self.writeByte(byte) #this is used to write byte of address

        byte = (address&0x0000FF00)>>8

        self.writeByte(byte)

        byte = (address&0x000000FF)

        self.writeByte(byte)

    def readByte(self):

        i=0

        byte = 0

        #print "-------------------"

        while i<8:

            byte = byte << 1

            self.clearPPDataBit(0)  # make falling edge for read

            if self.pport.getInSelected():

                byte=byte|0x01

            self.setPPDataBit(0)  # make rising edge for read

            i+=1

        #print "-------------------"

        return byte

    #########################  EPCS command calls   #############################

    def getDeviceID(self):

        self.startCycle()

        self.writeCommand(self.CMD_READ_ID)

        self.writeCommand(0x00) # dummy write

        self.writeCommand(0x00) # dummy write

        self.writeCommand(0x00) # dummy write

        byte = self.readByte()

        self.endCycle()

        return byte

    def setWriteEnable(self):

        self.startCycle()

        self.writeCommand(self.CMD_WRITE_ENABLE)

        self.endCycle()

    def setWriteDisable(self):

        self.startCycle()

        self.writeCommand(self.CMD_WRITE_DISABLE)

        self.endCycle()

    def getStatusReg(self):

        self.startCycle()

        self.writeCommand(self.CMD_READ_STATUS)

        byte = self.readByte()

        self.endCycle()

        return byte

    def readBytes(self,address,count):

        buffer = ""

        i = 0

        self.startCycle()

        self.writeCommand(self.CMD_READ_BYTES)

        self.writeAddress(address)

        while(i<count):

            byte = self.readByte()

            #print "Reading %2x"%(byte)

            buffer = buffer + chr(byte)  #this can continue endlessly if needed the address is auto INC'ed and is freerunning

            i+=1

        self.endCycle()

        return buffer

    def readFlippedBytes(self,address,count):

        buffer = ""

        i = 0

        self.startCycle()

        self.writeCommand(self.CMD_READ_BYTES)

        self.writeAddress(address)

        while(i<count):

            byte = self.readByte()

            etyb = ((byte&0x01)<<7)|((byte&0x02)<<5)|((byte&0x04)<<3)|((byte&0x08)<<1)|((byte&0x10)>>1)|((byte&0x20)>>3)|((byte&0x40)>>5)|((byte&0x80)>>7)

            #print "Reading %2x"%(byte)

            buffer = buffer + chr(etyb)  #this can continue endlessly if needed the address is auto INC'ed and is freerunning

            i+=1

        self.endCycle()

        return buffer

    def writeBytes(self,address,buffer):  #256 is maximum and is physical page limit of EPCS devices

        count = len(buffer)

        i = 0

        self.setWriteEnable()  #will be autoreset after this

        self.startCycle()

        self.writeCommand(self.CMD_WRITE_BYTES)

        self.writeAddress(address)

        while(i<count):

            #print "Writing %2x"%(ord(buffer[i]))

            self.writeByte(ord(buffer[i]))  #used also to write a data byte

            i+=1

        self.endCycle()

        time.sleep(0.0001)  #wait untill write compleate, wite time is in order of millis

        while(self.getStatusReg()&0x01==1):

            time.sleep(0.00001)

    def writeFlippedBytes(self,address,buffer):  #256 is maximum and is physical page limit of EPCS devices (Altera RPD file is allready byte flipped)

        #This is used to programm altera byte flipped programming files

        count = len(buffer)

        i = 0

        self.setWriteEnable()  #will be autoreset after this

        self.startCycle()

        self.writeCommand(self.CMD_WRITE_BYTES)

        self.writeAddress(address)

        while(i<count):

            #print "Writing %2x"%(ord(buffer[i]))

            self.writeFlippedByte(ord(buffer[i]))  #used also to write a data byte

            i+=1

        self.endCycle()

        time.sleep(0.0001)  #wait untill write compleate, wite time is in order of millis

        while(self.getStatusReg()&0x01==1):

            time.sleep(0.00001)

    def eraseBulk(self):

        self.setWriteEnable()  #will be autoreset after this

        self.startCycle()

        self.writeCommand(self.CMD_ERASE_BULK)

        self.endCycle()

        time.sleep(3)  #wait untill write compleate, wite time is in order of secs

        while(self.getStatusReg()&0x01==1):

            time.sleep(0.1)

    def eraseSector(self,address):

        self.setWriteEnable()  #will be autoreset after this

        self.startCycle()

        self.writeCommand(self.CMD_ERASE_SECTOR)

        self.writeAddress(address)

        self.endCycle()

        time.sleep(1)  #wait untill write compleate, wite time is in order of secs

        while(self.getStatusReg()&0x01==1):

            time.sleep(0.2)

    #########################  end EPCS command calls   #########################

################## Main program #########################

last_ops = 0

mode = DeviceMode()

# PARSE ARGUMENTS 

for arg in sys.argv:

    if len(sys.argv) == 1: # if no arguments display help

       #usage(sys.argv[0])

       usage("update.py")

       sys.exit()

    if arg in ("-h","--help","/help","/h"):

        #usage(sys.argv[0])

        usage("update.py")

        sys.exit()

    if arg[0]=="-": # if options

        # parse all options in this

        last_ops = sys.argv.index(arg)  #if remains last set of options from here start ordered strings

        ops = arg[1:]# get all besides the - sign

        for op in ops:

            if op=="q":

                mode.q = 1

            if op=="v":

                mode.v = 1

            if op=="r":

                mode.r = 1

            if op=="e":

                mode.e = 1

    else:

        i = sys.argv.index(arg)

        if i ==  last_ops + 1:

            mode.filename=arg

        if i >=  last_ops + 2:

            print "Too many parameters provided"

            sys.exit()

############## END PARSE ARGUMENTS   ###############################################33          

epcs = EPCSDevice()

epcs.open()

if epcs.pport.getInError():

    print "No Voltage source detected"

else:

    print "Voltage source OK"

byte = epcs.getDeviceID()

if byte == 0x10:

    print "EPCS1 Configuration device found"

    if mode.q == 1:

        print "EPCS Silicon ID = 0x%2x"%(byte)

        sys.exit()   # if q then exit

elif not byte == 0xFF:

    print "Not supported device found"

    if mode.q == 1:

        print "Silicon ID = 0x%2x"%(byte)

    sys.exit()

else:

    if not epcs.pport.getInError():

        print "No device attached to cable"

        if mode.q == 1:

            print "Got 0x%2x for ID "%(byte)

    epcs.close()

    sys.exit()

if mode.e == 1:

    print "Erasing EPCS device"

    epcs.eraseBulk()

    print "Done"

if mode.filename!="" and mode.r==0:

    print "Erasing EPCS device"

    epcs.eraseBulk()

    print "Done"

    size = 0

    mode.address = 0

    try:

        f=open(mode.filename,"rb")

        f.seek(0,2) #seek to end

        size = f.tell()

        f.seek(0) #seek to start

        print 'File size %iK '%(size/1024)

        f.close()

    except IOError:

         print "IO Error on file open"

         sys.exit()

    #all seems in order so lest start     

    f=open(mode.filename,"rb")

    f.seek(0) #seek to start

    address = mode.address

    print 'Writing %iK'%(size/1024)

    while 1:

        if (address/(1024*4) != (address-16)/(1024*4)) and address != mode.address:  # get bytes from words if 512

            if mode.v == 1:

                print 'Progress: %iK of %iK at 0x%06x'%((address-mode.address)/1024,size/1024,address)

            else:

                sys.stdout.write(".")

                sys.stdout.flush()

        buf = f.read(256)  #we can write 256 bytes at a time

        if len(buf)==256:

            epcs.writeFlippedBytes(address,buf)

            address = address + 256  #we use byte address

        elif len(buf)>0:

            epcs.writeFlippedBytes(address,buf) #write last bytes

            break

        else:

            break

    if mode.v == 0:

        print " "

    print "Write DONE!"

    f.close()

elif mode.filename!="":   # then read flag must be up

    size = 0x20000   #byte count of EPCS1 device

    try:

        f=open(mode.filename,"wb")  #if this fails no point in reading as there is nowhere to write

        address = 0    # set word address

        buf=""

        print "Start readback"

        buf=epcs.readFlippedBytes(address,size)

        print "Read done"

        f.write(buf)

        f.close()

        print "Done"

    except IOError:

        print "IO Error on file open"

        sys.exit()

epcs.close()

time.sleep(0.5)