Subversion Repositories minsoc

"""

*****************************************************************************

                                                                            *

                    H E A D E R   I N F O R M A T I O N                     *

                                                                            *

*****************************************************************************

Project Name                   : SysPy (System Python)

                                 http://cgi.di.uoa.gr/~evlog/syspy.html

File Name                      : bin2init.py

Created by                     : Evangelos Logaras

*****************************************************************************

                                                                            *

                      C O P Y R I G H T   N O T I C E                       *

                                                                            *

*****************************************************************************

  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;

  version 2.1 of the License, a copy of which is available from

  http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt.

  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 Street, Fifth Floor, Boston, MA  02110-1301  USA

*****************************************************************************

                                                                            *

                           D E S C R I P T I O N                            *

                                                                            *

*****************************************************************************

 Generates block_ram.init file from binary images. Binary images are first converted in hex files

 using bin2hex.c file, provided with the ORPSoC v2 project. bin2hex executable must exist in the same folder with this script.

 Currently init file is generated for Xilinx's RAMB16_S9 BRAMs

 Usage: python bin2init.py <file.bin> (Python 2.6)

"""

import commands

import sys

# Python's variable declarations

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

y = '  '

mem_arr = []

block_ram_num = 4

block0 = []

block1 = []

block2 = []

block3 = []

block_ram = [block3, block2, block1, block0]

init_arr = []

mem_size2 = 8192

mem_count = 0

bram_count = -1

init_count = -1

hex_count = 0

zero_pad = ''

filename = ''

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

# Exceptions' class

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

class MyExceptions(Exception):

       def __init__(self, value):

              self.value = value

       def __str__(self):

              return repr(self.value)

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

# Raising exception if a *.bin file is not provided as an argument

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

filename = sys.argv[len(sys.argv) - 1]

if (filename.find(".bin") == -1):

       raise MyExceptions("*.bin file required")

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

i = filename.find(".bin")

filename = filename[:i]

# Deleting old *.hex and *.bin files

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

commands.getoutput("rm " + filename + ".hex")

commands.getoutput("rm " + filename + ".init")

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

## Calling bin2hex executable to convert *.bin file to *.hex

commands.getoutput("./bin2hex " + filename + ".bin 4 > "+ filename + ".hex")

# Opening the *.hex and the *.init file

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

hexFile = open(filename + ".hex", 'r')

initFile = open(filename + ".init", 'w')

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

# Reading the *.hex file and appending its contents to mem_arr[]

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

y = ' '

hex_count = 0

while(y):

       hex_count = hex_count + 1

       if (hex_count == 127):

              mem_arr.append("00000000")

       y = hexFile.readline()

       mem_arr.append(y)

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

# Reading mem_arr[] and creating the contents of BRAMs

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

for i in range(len(mem_arr)):

       bram_count = bram_count + 1

       if (bram_count < 32):

              block_ram[0].append(mem_arr[i][6:8])

              block_ram[1].append(mem_arr[i][4:6])

              block_ram[2].append(mem_arr[i][2:4])

              block_ram[3].append(mem_arr[i][0:2])

       elif (bram_count >= 32):

              bram_count = 0

              init_count = init_count + 1

              if (init_count >= 64):

                     init_count = 0

                     mem_count = mem_count + 1

              hex_init_count = str(hex(init_count))

              hex_init_count = hex_init_count[2:]

              hex_init_count = hex_init_count.upper()

              if (init_count < 16):

                     hex_init_count = '0' + hex_init_count

              for j in range((block_ram_num - 1), -1, -1):

                     if (j == (block_ram_num - 1)):

                            init_arr.append(";\ndefparam MEM[" + str(mem_count) + "].block_ram_" + str(j) + ".INIT_" + hex_init_count + " = 256'h")

                            block_ram[j].reverse()

                            for k in range(len(block_ram[j])):

                                   init_arr.append(block_ram[j][k].replace("\n", ''))

                     else:

                            init_arr.append(";\ndefparam MEM[" + str(mem_count) + "].block_ram_" + str(j) + ".INIT_" + hex_init_count + " = 256'h")

                            block_ram[j].reverse()

                            for k in range(len(block_ram[j])):

                                   init_arr.append(block_ram[j][k].replace("\n", ''))

              block_ram[0] = []

              block_ram[1] = []

              block_ram[2] = []

              block_ram[3] = []

              block_ram[0].append(mem_arr[i][6:8])

              block_ram[1].append(mem_arr[i][4:6])

              block_ram[2].append(mem_arr[i][2:4])

              block_ram[3].append(mem_arr[i][0:2])

if (bram_count != -1):

       init_count = init_count + 1

       hex_init_count = str(hex(init_count))

       hex_init_count = hex_init_count[2:]

       hex_init_count = hex_init_count.upper()

       if (init_count < 16):

              hex_init_count = '0' + hex_init_count

       if (init_count == 0):

              for j in range(64 - 2 * bram_count):

                     zero_pad = zero_pad + '0'

       else:

              for j in range(64 - 2 * bram_count):

                     zero_pad = zero_pad + '0'

       for j in range((block_ram_num - 1), -1, -1):

              init_arr.append(";\ndefparam MEM[" + str(mem_count) + "].block_ram_" + str(j) + ".INIT_" + hex_init_count + " = 256'h")

              block_ram[j].reverse()

              init_arr.append(zero_pad)

              for k in range(len(block_ram[j])):

                     init_arr.append(block_ram[j][k].replace("\n", ''))

init_arr.append(';')

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

# Writing BRAMs contetns to *.init file

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

i = init_arr[0].find(";/n")

init_arr[0] = init_arr[0][i + 2:]

for i in range(len(init_arr)):

       initFile.write(init_arr[i])

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

# Closing the *.hex and the *.init file

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

hexFile.close()

initFile.close()

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