git.gag.com Git - debian/gnuradio/blob - usrp/host/apps/burn-db-eeprom

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2005 Free Software Foundation, Inc.
   4 #
   5 # This file is part of GNU Radio
   6 #
   7 # GNU Radio is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 2, or (at your option)
  10 # any later version.
  11 #
  12 # GNU Radio is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with GNU Radio; see the file COPYING.  If not, write to
  19 # the Free Software Foundation, Inc., 51 Franklin Street,
  20 # Boston, MA 02110-1301, USA.
  21 #
  22
  23 from usrp_prims import *
  24 from optparse import OptionParser
  25 import sys
  26 from usrp_dbid import *
  27
  28 i2c_addr_map = { 'TX_A' : 0x54,    'RX_A' : 0x55,    'TX_B' : 0x56,    'RX_B' : 0x57 }
  29
  30 daughterboards = {
  31     # name            : ((tx-dbid, tx-oe),          (rx-dbid, rx-oe))
  32     'basictx'         : ((BASIC_TX, 0x0000),        None),
  33     'basicrx'         : (None,                      (BASIC_RX, 0x0000)),
  34     'dbsrx'           : (None,                      (DBS_RX, 0x0000)),
  35     'dbsrx2'          : (None,                      (DBS_RX_REV_2_1, 0x0000)),
  36     'tvrx'            : (None,                      (TV_RX, 0x0000)),
  37     'tvrx2'           : (None,                      (TV_RX_REV_2, 0x0000)),
  38     'tvrx3'           : (None,                      (TV_RX_REV_3, 0x0000)),
  39     'rfx400'          : ((FLEX_400_TX, 0x0000),     (FLEX_400_RX, 0x0000)),
  40     'rfx900'          : ((FLEX_900_TX, 0x0000),     (FLEX_900_RX, 0x0000)),
  41     'rfx1200'         : ((FLEX_1200_TX, 0x0000),    (FLEX_1200_RX, 0x0000)),
  42     'rfx1800'         : ((FLEX_1800_TX, 0x0000),    (FLEX_1800_RX, 0x0000)),
  43     'rfx2400'         : ((FLEX_2400_TX, 0x0000),    (FLEX_2400_RX, 0x0000)),
  44     'rfx400_tx'       : ((FLEX_400_TX, 0x0000),     None),
  45     'rfx900_tx'       : ((FLEX_900_TX, 0x0000),     None),
  46     'rfx1200_tx'      : ((FLEX_1200_TX, 0x0000),    None),
  47     'rfx1800_tx'      : ((FLEX_1800_TX, 0x0000),    None),
  48     'rfx2400_tx'      : ((FLEX_2400_TX, 0x0000),    None),
  49     'rfx400_rx'       : (None,                      (FLEX_400_RX, 0x0000)),
  50     'rfx900_rx'       : (None,                      (FLEX_900_RX, 0x0000)),
  51     'rfx1200_rx'      : (None,                      (FLEX_1200_RX, 0x0000)),
  52     'rfx1800_rx'      : (None,                      (FLEX_1800_RX, 0x0000)),
  53     'rfx2400_rx'      : (None,                      (FLEX_2400_RX, 0x0000)),
  54     'rfx400_mimo_a'   : ((FLEX_400_TX_MIMO_A, 0x0000),     (FLEX_400_RX_MIMO_A, 0x0000)),
  55     'rfx900_mimo_a'   : ((FLEX_900_TX_MIMO_A, 0x0000),     (FLEX_900_RX_MIMO_A, 0x0000)),
  56     'rfx1200_mimo_a'  : ((FLEX_1200_TX_MIMO_A, 0x0000),    (FLEX_1200_RX_MIMO_A, 0x0000)),
  57     'rfx1800_mimo_a'  : ((FLEX_1800_TX_MIMO_A, 0x0000),    (FLEX_1800_RX_MIMO_A, 0x0000)),
  58     'rfx2400_mimo_a'  : ((FLEX_2400_TX_MIMO_A, 0x0000),    (FLEX_2400_RX_MIMO_A, 0x0000)),
  59     'rfx400_mimo_b'   : ((FLEX_400_TX_MIMO_B, 0x0000),     (FLEX_400_RX_MIMO_B, 0x0000)),
  60     'rfx900_mimo_b'   : ((FLEX_900_TX_MIMO_B, 0x0000),     (FLEX_900_RX_MIMO_B, 0x0000)),
  61     'rfx1200_mimo_b'  : ((FLEX_1200_TX_MIMO_B, 0x0000),    (FLEX_1200_RX_MIMO_B, 0x0000)),
  62     'rfx1800_mimo_b'  : ((FLEX_1800_TX_MIMO_B, 0x0000),    (FLEX_1800_RX_MIMO_B, 0x0000)),
  63     'rfx2400_mimo_b'  : ((FLEX_2400_TX_MIMO_B, 0x0000),    (FLEX_2400_RX_MIMO_B, 0x0000)),
  64     'lftx'            : ((LF_TX, 0x0000),           None),
  65     'lfrx'            : (None,                      (LF_RX, 0x0000)),
  66     'experimental_tx' : ((EXPERIMENTAL_TX, 0x0000), None),
  67     'experimental_rx' : (None,                      (EXPERIMENTAL_RX, 0x0000)),
  68     }
  69
  70 def open_cmd_interface(which_board = 0):
  71     if not usrp_load_standard_bits (which_board, 0):
  72         raise RuntimeError, "usrp_load_standard_bits"
  73     dev = usrp_find_device (which_board)
  74     if not dev:
  75         raise RuntimeError, "usrp_find_device"
  76     u = usrp_open_cmd_interface (dev)
  77     if not u:
  78         raise RuntimeError, "usrp_open_cmd_interface"
  79     return u
  80
  81 def write_dboard_eeprom(u, i2c_addr, dbid, oe):
  82     eeprom = 0x20 * [0]
  83     eeprom[0] = 0xDB                    # magic value
  84     eeprom[1] = dbid & 0xff
  85     eeprom[2] = (dbid >> 8) & 0xff
  86     eeprom[3] = oe & 0xff
  87     eeprom[4] = (oe >> 8) & 0xff
  88     eeprom[0x1f] = 0xff & (-reduce(lambda x, y: x+y, eeprom)) # checksum
  89     s = ''.join (map (chr, eeprom))
  90     ok = usrp_eeprom_write (u, i2c_addr, 0, s)
  91     return ok
  92
  93
  94 def init_eeprom(u, slot_name, force, dbid, oe):
  95     i2c_addr = i2c_addr_map[slot_name]
  96     e = usrp_eeprom_read (u, i2c_addr, 0, 0x20)
  97     if not e:
  98         print "%s: no d'board, skipped" % (slot_name,)
  99         return True
 100
 101     if not force and (sum (map (ord, e)) & 0xff) == 0 and ord (e[0]) == 0xDB:
 102         print "%s: already initialized, skipped" % (slot_name,)
 103         return True
 104
 105     if not write_dboard_eeprom (u, i2c_addr, dbid, oe):
 106         print "%s: failed to write d'board EEPROM" % (slot_name,)
 107         return False
 108
 109     print "%s: OK" % (slot_name,)
 110     return True
 111
 112
 113 def init_daughterboard(u, side, type, force):
 114     ok = True
 115     dbinfo = daughterboards[type]
 116     if dbinfo[0] is not None:           # burn tx slot
 117         ok &= init_eeprom(u, 'TX_' + side, force, dbinfo[0][0], dbinfo[0][1])
 118     if dbinfo[1] is not None:           # burn rx slot
 119         ok &= init_eeprom(u, 'RX_' + side, force, dbinfo[1][0], dbinfo[1][1])
 120     return ok
 121
 122
 123 def main():
 124     dbs = daughterboards.keys()
 125     dbs.sort()
 126     usage = """\
 127 usage: %prog [options]
 128 You must specify a type with -t or --type,
 129 and at least one side using -A and/or -B."""
 130
 131     parser = OptionParser(usage=usage)
 132     parser.add_option ("-t", "--type", type="choice", help="choose type from %r" % (dbs,),
 133                        choices=dbs, default=None)
 134     parser.add_option ("-A", "--burn-a", action="store_true", default=False,
 135                        help="burn eeprom(s) on side A")
 136     parser.add_option ("-B", "--burn-b", action="store_true", default=False,
 137                        help="burn eeprom(s) on side B")
 138     parser.add_option ("-f", "--force", action="store_true", default=False,
 139                        help="force init of already initialized eeproms")
 140     (options, args) = parser.parse_args ()
 141
 142     which=[]
 143     if options.burn_a:
 144         which.append('A')
 145     if options.burn_b:
 146         which.append('B')
 147
 148     if len(args) != 0 or len(which) == 0 or options.type is None:
 149         parser.print_help()
 150         sys.exit (1)
 151
 152     u = open_cmd_interface (0)
 153     ok = True
 154     for w in which:
 155         ok &= init_daughterboard (u, w, options.type, options.force)
 156
 157     if ok:
 158         sys.exit (0)
 159     else:
 160         sys.exit (1)
 161
 162 if __name__ == "__main__":
 163     main ()
 164