← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gnuradio/trusty-updates

« back to all changes in this revision

Viewing changes to usrp/host/apps/burn-db-eeprom

  • Committer: Package Import Robot
  • Author(s): A. Maitland Bottoms
  • Date: 2012-02-26 21:26:16 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20120226212616-vsfkbi1158xshdql
Tags: 3.5.1-1
http://bugs.debian.org/642716
http://bugs.debian.org/645332
http://bugs.debian.org/394849
http://bugs.debian.org/616832
http://bugs.debian.org/590048
http://bugs.debian.org/642580
* new upstream version, re-packaged from scratch with modern tools
    closes: #642716, #645332, #394849, #616832, #590048, #642580,
    #647018, #557050, #559640, #631863
* CMake build

Show diffs side-by-side

added added

removed removed

Lines of Context:
usrp/host/apps/burn-db-eeprom
1
 
#!/usr/bin/env python
2
 
#
3
 
# Copyright 2005,2007 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 3, 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 usrpm.usrp_prims import *
24
 
from optparse import OptionParser
25
 
import sys
26
 
from usrpm.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
 
    'dbsrx_clkmod'    : (None,                      (DBS_RX_CLKMOD, 0x0000)),
36
 
    'tvrx'            : (None,                      (TV_RX, 0x0000)),
37
 
    'tvrx2'           : (None,                      (TV_RX_REV_2, 0x0000)),
38
 
    'tvrx3'           : (None,                      (TV_RX_REV_3, 0x0000)),
39
 
    'dtt754'          : (None,                      (DTT754, 0x0000)),
40
 
    'dtt768'          : (None,                      (DTT768, 0x0000)),
41
 
    'rfx400'          : ((FLEX_400_TX, 0x0000),     (FLEX_400_RX, 0x0000)),
42
 
    'rfx900'          : ((FLEX_900_TX, 0x0000),     (FLEX_900_RX, 0x0000)),
43
 
    'rfx1200'         : ((FLEX_1200_TX, 0x0000),    (FLEX_1200_RX, 0x0000)),
44
 
    'rfx1800'         : ((FLEX_1800_TX, 0x0000),    (FLEX_1800_RX, 0x0000)),
45
 
    'rfx2400'         : ((FLEX_2400_TX, 0x0000),    (FLEX_2400_RX, 0x0000)),
46
 
    'rfx400_tx'       : ((FLEX_400_TX, 0x0000),     None),
47
 
    'rfx900_tx'       : ((FLEX_900_TX, 0x0000),     None),
48
 
    'rfx1200_tx'      : ((FLEX_1200_TX, 0x0000),    None),
49
 
    'rfx1800_tx'      : ((FLEX_1800_TX, 0x0000),    None),
50
 
    'rfx2400_tx'      : ((FLEX_2400_TX, 0x0000),    None),
51
 
    'rfx400_rx'       : (None,                      (FLEX_400_RX, 0x0000)),
52
 
    'rfx900_rx'       : (None,                      (FLEX_900_RX, 0x0000)),
53
 
    'rfx1200_rx'      : (None,                      (FLEX_1200_RX, 0x0000)),
54
 
    'rfx1800_rx'      : (None,                      (FLEX_1800_RX, 0x0000)),
55
 
    'rfx2400_rx'      : (None,                      (FLEX_2400_RX, 0x0000)),
56
 
    'rfx400_mimo_a'   : ((FLEX_400_TX_MIMO_A, 0x0000),     (FLEX_400_RX_MIMO_A, 0x0000)),
57
 
    'rfx900_mimo_a'   : ((FLEX_900_TX_MIMO_A, 0x0000),     (FLEX_900_RX_MIMO_A, 0x0000)),
58
 
    'rfx1200_mimo_a'  : ((FLEX_1200_TX_MIMO_A, 0x0000),    (FLEX_1200_RX_MIMO_A, 0x0000)),
59
 
    'rfx1800_mimo_a'  : ((FLEX_1800_TX_MIMO_A, 0x0000),    (FLEX_1800_RX_MIMO_A, 0x0000)),
60
 
    'rfx2400_mimo_a'  : ((FLEX_2400_TX_MIMO_A, 0x0000),    (FLEX_2400_RX_MIMO_A, 0x0000)),
61
 
    'rfx400_mimo_b'   : ((FLEX_400_TX_MIMO_B, 0x0000),     (FLEX_400_RX_MIMO_B, 0x0000)),
62
 
    'rfx900_mimo_b'   : ((FLEX_900_TX_MIMO_B, 0x0000),     (FLEX_900_RX_MIMO_B, 0x0000)),
63
 
    'rfx1200_mimo_b'  : ((FLEX_1200_TX_MIMO_B, 0x0000),    (FLEX_1200_RX_MIMO_B, 0x0000)),
64
 
    'rfx1800_mimo_b'  : ((FLEX_1800_TX_MIMO_B, 0x0000),    (FLEX_1800_RX_MIMO_B, 0x0000)),
65
 
    'rfx2400_mimo_b'  : ((FLEX_2400_TX_MIMO_B, 0x0000),    (FLEX_2400_RX_MIMO_B, 0x0000)),
66
 
    'lftx'            : ((LF_TX, 0x0000),           None),
67
 
    'lfrx'            : (None,                      (LF_RX, 0x0000)),
68
 
    'wbx_lo'          : ((WBX_LO_TX, 0x0000),       (WBX_LO_RX, 0x0000)),
69
 
    'xcvr2450'        : ((XCVR2450_TX, 0x0000),       (XCVR2450_RX, 0x0000)),
70
 
    'experimental_tx' : ((EXPERIMENTAL_TX, 0x0000), None),
71
 
    'experimental_rx' : (None,                      (EXPERIMENTAL_RX, 0x0000)),
72
 
    }
73
 
 
74
 
def open_cmd_interface(which_board = 0):
75
 
    if not usrp_load_standard_bits (which_board, 0):
76
 
        raise RuntimeError, "usrp_load_standard_bits"
77
 
    dev = usrp_find_device (which_board)
78
 
    if not dev:
79
 
        raise RuntimeError, "usrp_find_device"
80
 
    u = usrp_open_cmd_interface (dev)
81
 
    if not u:
82
 
        raise RuntimeError, "usrp_open_cmd_interface"
83
 
    return u
84
 
 
85
 
def write_dboard_eeprom(u, i2c_addr, dbid, oe):
86
 
    eeprom = 0x20 * [0]
87
 
    eeprom[0] = 0xDB                    # magic value
88
 
    eeprom[1] = dbid & 0xff
89
 
    eeprom[2] = (dbid >> 8) & 0xff
90
 
    eeprom[3] = oe & 0xff
91
 
    eeprom[4] = (oe >> 8) & 0xff
92
 
    eeprom[0x1f] = 0xff & (-reduce(lambda x, y: x+y, eeprom)) # checksum
93
 
    s = ''.join (map (chr, eeprom))
94
 
    ok = usrp_eeprom_write (u, i2c_addr, 0, s)
95
 
    return ok
96
 
 
97
 
 
98
 
def init_eeprom(u, slot_name, force, dbid, oe):
99
 
    i2c_addr = i2c_addr_map[slot_name]
100
 
    e = usrp_eeprom_read (u, i2c_addr, 0, 0x20)
101
 
    if not e:
102
 
        print "%s: no d'board, skipped" % (slot_name,)
103
 
        return True
104
 
    
105
 
    if not force and (sum (map (ord, e)) & 0xff) == 0 and ord (e[0]) == 0xDB:
106
 
        print "%s: already initialized, skipped" % (slot_name,)
107
 
        return True
108
 
        
109
 
    if not write_dboard_eeprom (u, i2c_addr, dbid, oe):
110
 
        print "%s: failed to write d'board EEPROM" % (slot_name,)
111
 
        return False
112
 
 
113
 
    print "%s: OK" % (slot_name,)
114
 
    return True
115
 
 
116
 
 
117
 
def init_daughterboard(u, side, type, force):
118
 
    ok = True
119
 
    dbinfo = daughterboards[type]
120
 
    if dbinfo[0] is not None:           # burn tx slot
121
 
        ok &= init_eeprom(u, 'TX_' + side, force, dbinfo[0][0], dbinfo[0][1])
122
 
    if dbinfo[1] is not None:           # burn rx slot
123
 
        ok &= init_eeprom(u, 'RX_' + side, force, dbinfo[1][0], dbinfo[1][1])
124
 
    return ok
125
 
 
126
 
 
127
 
def main():
128
 
    dbs = daughterboards.keys()
129
 
    dbs.sort()
130
 
    usage = """\
131
 
usage: %prog [options]
132
 
You must specify a type with -t or --type,
133
 
and at least one side using -A and/or -B."""
134
 
 
135
 
    parser = OptionParser(usage=usage)
136
 
    parser.add_option ("-t", "--type", type="choice", help="choose type from %r" % (dbs,),
137
 
                       choices=dbs, default=None)
138
 
    parser.add_option ("-A", "--burn-a", action="store_true", default=False,
139
 
                       help="burn eeprom(s) on side A")
140
 
    parser.add_option ("-B", "--burn-b", action="store_true", default=False,
141
 
                       help="burn eeprom(s) on side B")
142
 
    parser.add_option ("-f", "--force", action="store_true", default=False,
143
 
                       help="force init of already initialized eeproms")
144
 
    (options, args) = parser.parse_args ()
145
 
 
146
 
    which=[]
147
 
    if options.burn_a:
148
 
        which.append('A')
149
 
    if options.burn_b:
150
 
        which.append('B')
151
 
 
152
 
    if len(args) != 0 or len(which) == 0 or options.type is None:
153
 
        parser.print_help()
154
 
        sys.exit (1)
155
 
 
156
 
    u = open_cmd_interface (0)
157
 
    ok = True
158
 
    for w in which:
159
 
        ok &= init_daughterboard (u, w, options.type, options.force)
160
 
 
161
 
    if ok:
162
 
        sys.exit (0)
163
 
    else:
164
 
        sys.exit (1)
165
 
 
166
 
if __name__ == "__main__":
167
 
    main ()
168