# programmer
#
# for programming parallel flash with a RPi
#
# parallel flash can be 16 or 8 bit wide
#
# Flash type: SST39SF010A
#
# needs external level conversion and 16-bit address register
#
# 20180508


import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)

from time import sleep

import re  # for regular expression



# GPIO names

WE = 25  # enable write to flash when low
ALE = 8  # enable write to ext addr register when low
ENA = 24 # enable output of ext addr register when low
CE = 3   # enable the flash chip(s) when low
OE = 21  # enable output of flash chip(s) when low

AD0 = 4
AD1 = 14
AD2 = 17
AD3 = 15
AD4 = 27
AD5 = 18
AD6 = 22
AD7 = 23

AD8 = 5
AD9 = 7
AD10 = 6
AD11 = 12
AD12 = 19
AD13 = 16
AD14 = 26
AD15 = 20

# end gpio names

running=1
page=0x0000
sector=0x000
filename=""
fileinfo="";

def set_inputs():  #set the RPi bus to inputs
  GPIO.setup(AD0 , GPIO.IN)
  GPIO.setup(AD1 , GPIO.IN)
  GPIO.setup(AD2 , GPIO.IN)
  GPIO.setup(AD3 , GPIO.IN)
  GPIO.setup(AD4 , GPIO.IN)
  GPIO.setup(AD5 , GPIO.IN)
  GPIO.setup(AD6 , GPIO.IN)
  GPIO.setup(AD7 , GPIO.IN)
  GPIO.setup(AD8 , GPIO.IN)
  GPIO.setup(AD9 , GPIO.IN)
  GPIO.setup(AD10 , GPIO.IN)
  GPIO.setup(AD11 , GPIO.IN)
  GPIO.setup(AD12 , GPIO.IN)
  GPIO.setup(AD13 , GPIO.IN)
  GPIO.setup(AD14 , GPIO.IN)
  GPIO.setup(AD15 , GPIO.IN)
  sleep(0.0001)


def init_gpio():
  set_inputs()
  GPIO.setup(WE, GPIO.OUT, initial = GPIO.HIGH)
  GPIO.setup(ALE, GPIO.OUT, initial = GPIO.HIGH)
  GPIO.setup(ENA, GPIO.OUT, initial = GPIO.HIGH)
  GPIO.setup(CE, GPIO.OUT, initial = GPIO.LOW)
  GPIO.setup(OE, GPIO.OUT, initial = GPIO.LOW)


def idle():
  set_inputs()
  GPIO.output(WE, GPIO.HIGH)
  GPIO.output(ALE,GPIO.HIGH)
  GPIO.output(ENA,GPIO.HIGH)
  GPIO.output(CE, GPIO.LOW)
  GPIO.output(OE, GPIO.LOW)

def out_databit(data,bitnr,ioname):
  GPIO.setup(ioname, GPIO.OUT)
  if (data & (0x01<<bitnr)):
    GPIO.output(ioname,GPIO.HIGH)
  else:
    GPIO.output(ioname,GPIO.LOW)

def in_databit(prev,bitnr,ioname):
  if (GPIO.input(ioname) == 1):
     return prev + (0x01<<bitnr)
  else:
     return prev

def in_word():
  v = in_databit(0, 0, AD0)
  v = in_databit(v, 1, AD1)
  v = in_databit(v, 2, AD2)
  v = in_databit(v, 3, AD3)
  v = in_databit(v, 4, AD4)
  v = in_databit(v, 5, AD5)
  v = in_databit(v, 6, AD6)
  v = in_databit(v, 7, AD7)
  v = in_databit(v, 8, AD8)
  v = in_databit(v, 9, AD9)
  v = in_databit(v, 10, AD10)
  v = in_databit(v, 11, AD11)
  v = in_databit(v, 12, AD12)
  v = in_databit(v, 13, AD13)
  v = in_databit(v, 14, AD14)
  v = in_databit(v, 15, AD15)
  return v


def out_word(data):
  GPIO.output(OE,GPIO.HIGH) # disable flash output before putting info on bus
  out_databit(data,0,AD0)
  out_databit(data,1,AD1)
  out_databit(data,2,AD2)
  out_databit(data,3,AD3)
  out_databit(data,4,AD4)
  out_databit(data,5,AD5)
  out_databit(data,6,AD6)
  out_databit(data,7,AD7)  
  out_databit(data,8,AD8)
  out_databit(data,9,AD9)
  out_databit(data,10,AD10)
  out_databit(data,11,AD11)  
  out_databit(data,12,AD12)
  out_databit(data,13,AD13)
  out_databit(data,14,AD14)
  out_databit(data,15,AD15)




def set_address(addr):
  GPIO.output(OE,GPIO.HIGH) # disable flash output 
  GPIO.output(ALE,GPIO.HIGH)  # make sure ALE is not active 
  GPIO.output(ENA,GPIO.LOW)  # enable the output of the address register  
  out_word(addr)
  sleep(0.0001) # 100 uS
  GPIO.output(ALE,GPIO.LOW)  # make ALE low 
  sleep(0.0001)
  GPIO.output(ALE,GPIO.HIGH)  # make ALE high again 
  sleep(0.0001)
 
  
def read(addr):
  set_address(addr)
  set_inputs()             # set RPI bus to input
  GPIO.output(CE,GPIO.LOW) # enable flash chip 
  GPIO.output(OE,GPIO.LOW) # enable flash output 
  sleep(0.0001)
  v = in_word()   # read data
  idle()
  return v
  
def write(addr,data):
  set_address(addr)
  out_word(data)
  GPIO.output(WE, GPIO.LOW)  # start write pulse
  sleep(0.00001)             # 10uS is long enough
  GPIO.output(WE, GPIO.HIGH)  # stop write pulse
  sleep(0.0001) 	    # use fixed programming time
  idle()

 
def display_addr(addr):
  print("addr "+hex(addr)+" : "+ hex(read(addr)))
  

def unlock(code):
  write(0x5555,0xAAAA)  # 1st bus cycle
  write(0x2AAA,0x5555)  # 2nd bus cycle
  write(0x5555, code)   # 3rd cycle, depends on action

# byte_program will program a word when two 8 bit flash chips are connected.

def byte_program(addr,data):
  unlock(0xa0a0)   # Byte-Program command
  write(addr,data)

def erase_sector():
  unlock(0x8080)   # sector erase, first 3 cycles
  write(0x5555,0xAAAA)  # bus cycle 4
  write(0x2AAA,0x5555)  # bus cycle 5
  write(sector,0x3030)  # bus cycle 6 has sector number


def hexfmt(nr):  # convert hex to 4 char hex string
  return ("000"+hex(nr)[2:])[-4:]


def page_display():
  row = 0
  col= 0
  while (row<16):
    print ( hexfmt(page+row*16)+"   ",end="")  # print without NL
    col=0
    while (col<16):      
      print ( hexfmt(read(page+row*16+col))+" ",end="")
      col=col+1
    print (" ")  # force NL
    row=row+1

def show_id():
  # read chip id
  print ("Read ID, must be BF - B5, or BFBF - B5B5  ") 
  unlock(0x9090)   # software ID entry
  print("Manufacturer "+hexfmt(read(0)) )  #  should be BF
  print("Device       "+hexfmt(read(1)) )  # display Device ID, should be B5
  unlock(0xf0f0)   # software ID exit


# programming and verifying from file. All numbers in hex.

def dofile(what):
  try:
    f = open(filename)
    # line has info, skip it
    dummy = next(f)
    # 2nd line contains first address (unused) and count
    addr,count = [int(x,16) for x in next(f).split()] # read first line
    addr = addr + sector
    while (count!=0):
      addr,data= [int(x,16) for x in next(f).split()] # read next line
      if (what=="p"):
        byte_program(addr,data)
        print("Location "+hexfmt(addr)+" set to "+hexfmt(data) )
      if (what=="v"):
        d = read(addr)
        if (d !=data):
          print("Verify error, at "+hexfmt(addr)+" expect "+hexfmt(data)+" but found "+hexfmt(d) )
      count -=1 
    f.close()
  except FileNotFoundError:
    print("ERROR FILE NOT FOUND")
  else:
    print("Ok")  
  

def file_info():
  try:
    f = open(filename)
    txt = next(f)
    f.close()
  except FileNotFoundError:
    txt = "ERROR, File not found"
  return txt

# start main program

print("start programmer. ")

init_gpio()
idle()

# command loop

while (running):
  print("-----------------------------------------------------------")
  print("page="+hexfmt(page)+" sector="+hexfmt(sector)+"   file: "+filename)
  print()
  print("fileinfo: "+fileinfo)

  print("---- Menu ----")
  print("F  File name")
  print("P  Program file")
  print("V  Verify file")
  print("E  Erase sector")
  print("R  Read flash page")
  print("I  Increment flash page")
  print("D  Decrement flash page")
  print("M  Manufacturer ID")
  print("X  Exit")
  char = input("Type command followed by ENTER>>")
  char = char.lower()
  if (char=="r"):
    page_display()
  if (char=="i"):
    page = page + 0x0100
    page_display()
  if (char=="d"):
    page = page - 0x0100
    page_display()
  if (char=="m"):
    show_id()
  if (char=="x"):
    running=0
  if (char=="p"):  
    dofile("p")
  if (char=="v"):  
    dofile("v")
  if (char=="f"):
    dir = "/home/pi/Downloads/"
    print("No need to enter extension (.hex) and directory ("+dir+")" )
    str = input("filename: ")
    newname= dir + str +".hex"
    #check for 'time only' input: HMMS  <a-z><0-2><0-9><a-z>
    if (len(str)==4):
      print("length=4")
      regex= re.compile("[a-z][0-5][0-9][a-z]")
      m = regex.match(str)
      if m:   # if regex matches
        print("match ok") # so str is the new time code
        filename = filename.split(".")[0]  # remove extension
        split = filename.split("_")  # split old name in two sections
        lastpart = split[1][:-4]   # remove last 4 chars
        firstpart = split[0]
        # construct new filename
        newname = firstpart+"_"+lastpart+str+".hex"
             
    filename = newname;
    fileinfo=file_info()
  if (char=="e"):  
    erase_sector()
  
  
 
idle()
GPIO.cleanup();
print("end programmer")