timing.cli.debug Namespace Reference

Functions
	debug (obj, device)
	inspect (obj, nodes)
	ipy (ctx)
	uuid (obj)
	sfpexpander (obj)
	scan_i2c (obj)
	pll (obj)
	fanout_sfpscan (obj)
	sfp_status (obj)
	readSFPStatus (aEEProm, aDiag, aLabel)
	lm75_temp_read (obj)
	gib (obj, force)
	reset_switch (obj)
	reset_expander (obj)
	monitor_exp_intr (obj, no_end, no_exp_read)
	reset_pll (obj, clocksource)
	monitor_pll_intr (obj, no_end)

Function Documentation

debug()

timing.cli.debug.debug	(		obj,
			device )

Timing master commands.

DEVICE: uhal device identifier

Definition at line 29 of file debug.py.

def debug(obj, device):
    '''
    Timing master commands.
 
    DEVICE: uhal device identifier
    '''
    lDevice = obj.mConnectionManager.getDevice(str(device))
    if obj.mTimeout:
        lDevice.setTimeoutPeriod(obj.mTimeout)
        
    echo('Created device ' + click.style(lDevice.id(), fg='blue'))
 
    lBoardInfo = toolbox.readSubNodes(lDevice.getNode('io.config'), False)
    lDevice.dispatch()
 
    # print({ k:v.value() for k,v in lBoardInfo.items()})
    # raise SystemExit(0)
 
    echo("Design '{}' on board '{}' on carrier '{}'".format(
        style(kDesignNameMap[lBoardInfo['design_type'].value()], fg='blue'),
        style(kBoardNameMap[lBoardInfo['board_type'].value()], fg='blue'),
        style(kCarrierNameMap[lBoardInfo['carrier_type'].value()], fg='blue')
    ))
 
    obj.mDevice = lDevice
    obj.mBoardType = lBoardInfo['board_type'].value()
    obj.mCarrierType = lBoardInfo['carrier_type'].value()
    obj.mDesignType = lBoardInfo['design_type'].value()
# ------------------------------------------------------------------------------
 
 
# ------------------------------------------------------------------------------
@debug.command('inspect')
@click.argument('nodes')
@click.pass_obj

fanout_sfpscan()

timing.cli.debug.fanout_sfpscan

(

obj

)

Definition at line 240 of file debug.py.

def fanout_sfpscan(obj):
    
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
 
    if lBoardType != kBoardPC059:
        print('Wrong board', lBoardType, 'sorry mate')
        return
 
 
    lDevice.getNode('io.csr.ctrl.rst_i2cmux').write(0x1)
    lDevice.dispatch()
    lDevice.getNode('io.csr.ctrl.rst_i2cmux').write(0x0)
    lDevice.dispatch()
    time.sleep(1)
 
    lSFPNodeName = 'io.i2c'
    lI2CBusNode = lDevice.getNode(lSFPNodeName)
    lSwitchSlave = lI2CBusNode.get_slave('SFP_Switch')
    print(lSwitchSlave.ping())
 
    # print(lSwitchSlave.read_i2cPrimitive(1))
    # time.sleep(0.1)
 
    lSwitchSlave.write_i2cPrimitive([3])
    print(lSwitchSlave.read_i2cPrimitive(1))
    print(lSwitchSlave.read_i2cPrimitive(1))
    print(lSwitchSlave.read_i2cPrimitive(1))
 
# ------------------------------------------------------------------------------
@debug.command('sfp-status', short_help="Debug.")
@click.pass_obj

gib()

timing.cli.debug.gib	(		obj,
			force )

Definition at line 499 of file debug.py.

def gib(obj, force):
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
 
    if lBoardType not in [kBoardGIB, kBoardGIBV3]:
        if force:
            secho('Warning, only designed for GIB(vX) testing. '
                  + 'Continuing due to --force flag...')
        else:
            secho('Only designed for GIB(vX) testing. Stopping...')
            return
    obj.mI2CBus = lDevice.getNode('io.i2c')
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@gib.command('reset-switch', short_help="Debug.")
@click.pass_obj

inspect()

timing.cli.debug.inspect	(		obj,
			nodes )

Definition at line 64 of file debug.py.

def inspect(obj, nodes):
    lDevice = obj.mDevice
 
    lNodeIds = lDevice.getNodes(nodes.encode('ascii','replace'))
    lNodeVals = {n:lDevice.getNode(n).read() for n in lNodeIds}
 
    lDevice.dispatch()
 
    toolbox.printRegTable(lNodeVals, False)
# ------------------------------------------------------------------------------
 
 
# ------------------------------------------------------------------------------
@debug.command()
@click.pass_context

ipy()

timing.cli.debug.ipy

(

ctx

)

Start an interactive IPython session.

The board HwInterface is accessible as 'lDevice'

Definition at line 79 of file debug.py.

def ipy(ctx):
    '''
    Start an interactive IPython session.
 
    The board HwInterface is accessible as 'lDevice'
    '''
    lDevice = ctx.obj.mDevice
 
    from IPython import embed
    embed()
# ------------------------------------------------------------------------------
 
 
# ------------------------------------------------------------------------------
@debug.command('uid', short_help="Unique ID reader.")
@click.pass_obj

lm75_temp_read()

timing.cli.debug.lm75_temp_read

(

obj

)

Definition at line 403 of file debug.py.

def lm75_temp_read(obj):
 
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lIO = lDevice.getNode('io')
 
    if lBoardType != kBoardFIB:
        secho(f'Only FIB (v2) supported. Board type is {lBoardType}', fg='red')
        return
 
    i2c_bus = lDevice.getNode('io.i2c')
 
    lValues = i2c_bus.get_slave('TEMP_MON').read_i2cPrimitive(2)
    temp_raw = (lValues[1] & 0x80) >> 7
    temp_raw = temp_raw | (lValues[0] << 1)
    echo(f"LM75 temp data")
    echo(f" raw bytes: {hex(lValues[0])}, {hex(lValues[1])}")
    echo(f" combined word: {hex(temp_raw)}")
    echo(f" temp [C]: {toolbox.twos_complement(temp_raw,9)*0.5}")
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@debug.command('ltc2945', short_help="Read data from a LTC2945.")
@click.pass_obj

monitor_exp_intr()

timing.cli.debug.monitor_exp_intr	(		obj,
			no_end,
			no_exp_read )

Definition at line 586 of file debug.py.

def monitor_exp_intr(obj, no_end, no_exp_read):
    lDevice = obj.mDevice
    lIO = lDevice.getNode("io")
 
    def format_exp(exp_data):
        bus_10 = f"{(exp_data>>16)%(2**8):08b}"
        bus_01 = f"{(exp_data>>8)%(2**8):08b}"
        bus_00 = f"{exp_data%(2**8):08b}"
        return f"[10]{bus_10} [01]{bus_01} [00]{bus_00}"
 
    num_seconds = 10
 
    intr0 = lDevice.getNode("io.csr.stat.i2c_exten_intr0")
    intr1 = lDevice.getNode("io.csr.stat.i2c_exten_intr1")
 
    init_i0 = intr0.read()
    init_i1 = intr1.read()
    lDevice.dispatch()
    print(f"Initial status:\nInterrupt 0: {init_i0}\nInterrupt 1: {init_i1}")
    if not no_exp_read:
        init_exp = lIO.read_io_expanders()
        print(f"Expander ([bus]contents): {format_exp(init_exp)}\n")
 
    changed = False
 
    if no_end:
        while_cond = lambda t: True
        print("Monitoring interrupt line indefinitely "
              + "(requires manual interruption)...")
    else:
        print(f"Monitoring interrupt line for {num_seconds}s...")
        t_end = time.time() + num_seconds
        while_cond = lambda t: t < t_end
    while while_cond(time.time()):
        i0 = intr0.read()
        i1 = intr1.read()
        lDevice.dispatch()
        if not no_exp_read:
            exp = lIO.read_io_expanders()
            time.sleep(1e-1) # Reduce probability that change occurs
                    # between reading interrupt line and expander state
            exp_change = exp != init_exp
        else:
            exp_change = False
        
        i0_change = i0 != init_i0
        i1_change = i1 != init_i1
        intr_change = i0_change or i1_change
 
        if exp_change or intr_change:
            if not no_end:
                changed = True
                break
            else:
                if i0_change:
                    print(f"INT0 changed: was {init_i0}, now {i0}")
                    init_i0 = i0
                if i1_change:
                    print(f"INT1 changed: was {init_i1}, now {i1}")
                    init_i1 = i1
                if exp_change and (not no_exp_read):
                    print(f"Expander changed: was {format_exp(init_exp)},")
                    print(f"                  now {format_exp(exp)}")
                    init_exp = exp
 
    if changed:
        if i0_change:
            print(f"INT0 changed: now {i0}")
        if i1_change:
            print(f"INT1 changed: now {i1}")
        if exp_change:
            print(f"Expander changed: now {format_exp(exp)}")
            if not intr_change:
                print("No change in interrupt seen after change in expander")
                print("This could be due to the change occuring between "
                      + "reading the interrupt lines and reading the "
                      + "expander state - multiple tests recommended.")
        time.sleep(0.1)
        i0_post = intr0.read()
        i1_post = intr1.read()
        lDevice.dispatch()
        print("\nAfter reading expander:")
        if i0 != i0_post:
            print(f"INT0 changed: now {i0_post}")
        if i1 != i1_post:
            print(f"INT1 changed: now {i1_post}")
        if (i0 == i0_post) and (i1 == i1_post):
            print("No change in interrupt lines")
            print(" ^ UNEXPECTED BEHAVIOUR ^")
    else:
        print("No changes observed.")
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@gib.command('reset-pll', short_help="Debug.")
@click.option('--clock-source', 'clocksource',
              type=click.Choice(ClockSource.__members__.keys()),
              help='Manually specify clock source, free-running, upstream, etc..')
@click.pass_obj

monitor_pll_intr()

timing.cli.debug.monitor_pll_intr	(		obj,
			no_end )

Definition at line 732 of file debug.py.

def monitor_pll_intr(obj, no_end):
    lDevice = obj.mDevice
    lIO = lDevice.getNode("io")
    lPLL = lIO.get_pll()
 
    num_seconds = 10
 
    pll_intr = lDevice.getNode("io.csr.stat.clk_gen_intr")
 
    init_ipll = pll_intr.read()
    lDevice.dispatch()
    print(("#"*30) + "\n      Initial PLL status\n" + ("#"*30))
    lPLL.get_status(True)
    print(f"\nPLL Interrupt: {init_ipll}\n")
 
    changed = False
 
    if no_end:
        while_cond = lambda t: True
        print("Monitoring interrupt line indefinitely "
              + "(requires manual interruption)...")
    else:
        print(f"Monitoring interrupt line for {num_seconds}s...")
        t_end = time.time() + num_seconds
        while_cond = lambda t: t < t_end
    while while_cond(time.time()):
        ipll = pll_intr.read()
        lDevice.dispatch()
 
        pll_change = ipll != init_ipll
 
        if pll_change:
            if not no_end:
                changed = True
                break
            else:
                print(("-"*30) + "\nInterrupt change found. New PLL status:")
                lPLL.get_status(True)
                print(f"\nInterrupt was {init_ipll}, now {ipll}\n")
                init_ipll = ipll
 
    if changed:
        print("\nInterrupt found\n")
        print(("#"*30) + "\n        New PLL status\n" + ("#"*30))
        lPLL.get_status(True)
        print(f"\nPLL Interrupt: was {init_ipll}, now {ipll}\n")
        
        ipll_post = pll_intr.read()
        lDevice.dispatch()
        print("\nAfter reading the PLL:")
        if ipll == ipll_post:
            print("No change in interrupt observed")
        else:
            print(f"\nPLL Interrupt changed: now {ipll_post}\n")
    else:
        print("No changes observed.")
# ------------------------------------------------------------------------------

pll()

timing.cli.debug.pll

(

obj

)

Definition at line 218 of file debug.py.

def pll(obj):
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lIO = lDevice.getNode('io')
 
    lI2CBusNode = lDevice.getNode('io.i2c')
    lDevice.getNode("io.csr.ctrl.i2c_sw_rst").write(0x1)
    lDevice.getNode("io.csr.ctrl.clk_gen_rst").write(0x1)
    lDevice.dispatch()
 
    lI2CBusNode.write_i2cPrimitive(0x70, [1])
 
    lSIChip = SI534xSlave(lI2CBusNode, 0x68)
    #lSIVersion = lSIChip.read_device_version()
 
    lSIVersion = lSIChip.read_device_version()
    echo(f"PLL version {hex(lSIVersion)}")
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@debug.command('fanout-sfp-scan', short_help="Debug.")
@click.pass_obj

readSFPStatus()

timing.cli.debug.readSFPStatus	(		aEEProm,
			aDiag,
			aLabel )

Definition at line 325 of file debug.py.

def readSFPStatus(aEEProm, aDiag, aLabel):
 
    def asciidecode( v ): 
        return (''.join([chr(c) for c in v])).rstrip()
 
    def tempdecode( v ):
        lSign = -1 if ((v[0]>>7) & 0x1) else 1
        x = lSign*((v[0] & 0x7f) + v[1]/float(0xff))
        return '{:.3f} C'.format(x)
 
    def vccdecode( v ):
        return '{:.4f} V'.format(((v[0] << 8) + v[1])/float(10000))
 
    def biascurdecode( v ):
        return '{:.3f} mA'.format(((v[0] << 8) + v[1])*2e-3)
 
    def powerdecode( v ):
        return '{:.3f} mW'.format(((v[0] << 8) + v[1])*1e-3)
 
 
    echo()
    lVenInfoEnc = collections.OrderedDict()
    lVenInfoEnc['Name'] = asciidecode(aEEProm.read_i2cArray(20,16))
    lVenInfoEnc['OUI'] = '{}.{}.{}'.format(*(aEEProm.read_i2cArray(37,3)))
    lVenInfoEnc['Part Number'] = asciidecode(aEEProm.read_i2cArray(40,16))
    lVenInfoEnc['Revision'] = asciidecode(aEEProm.read_i2cArray(56,4))
    lVenInfoEnc['Serial Number'] = asciidecode(aEEProm.read_i2cArray(68,16))
    lVenInfoEnc['Day'] = asciidecode(aEEProm.read_i2cArray(88,2))
    lVenInfoEnc['Month'] = asciidecode(aEEProm.read_i2cArray(86,2))
    lVenInfoEnc['Year'] = asciidecode(aEEProm.read_i2cArray(84,2))
 
    secho("{} Vendor info".format(aLabel), fg='cyan')
    # for k,v in lVenInfoEnc.items():
    #     v = ''.join([chr(c) for c in v])
    #     echo(' - '+k+': '+style(v, fg='cyan'))
    echo(toolbox.formatDictTable(lVenInfoEnc, aHdr=False, aSort=False))
    echo()
    lLaserWl = aEEProm.read_i2cArray(60,2)
    lLaserWl = (lLaserWl[0] << 8) + lLaserWl[1]
    echo('Laser Wavelength: '+style(str(lLaserWl)+'nm', fg='cyan'))
 
    lRegs = collections.OrderedDict()
 
    lRegs['Identifier'] = aEEProm.read_i2c(0)
    lRegs['Ext Identifier'] = aEEProm.read_i2c(1)
    lRegs['Connector'] = aEEProm.read_i2c(2)
 
    # Transciever Compatinility
    lTransComp = aEEProm.read_i2cArray(3, 8)
 
    lRegs['Encoding'] = aEEProm.read_i2c(11)
    lRegs['BR, Nominal'] = aEEProm.read_i2c(12)
    lRegs['Rate ID'] = aEEProm.read_i2c(13)
 
    toolbox.printRegTable(lRegs, aHeader=False, sort=False)
 
    echo()
    secho("{} Diagnostic info".format(aLabel), fg='cyan')
 
    lReadings = collections.OrderedDict()
 
    lReadings['Temp'] = tempdecode(aDiag.read_i2cArray(96, 2))
    lReadings['Vcc']  = vccdecode(aDiag.read_i2cArray(98, 2))
    lReadings['TX bias']  = biascurdecode(aDiag.read_i2cArray(100, 2))
    lReadings['TX power']  = powerdecode(aDiag.read_i2cArray(102, 2))
    lReadings['RX power']  = powerdecode(aDiag.read_i2cArray(104, 2))
    lMiscStatus = aDiag.read_i2c(110)
    lReadings['TX disable'] = (lMiscStatus >> 7) & 0x1
 
    # for k,v in lReadings.items():
        # print (k, v)
 
    echo(toolbox.formatDictTable(lReadings, aHdr=False, aSort=False))
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@debug.command('lm75-temp-read', short_help="Read temp data from a LM75.")
@click.pass_obj

reset_expander()

timing.cli.debug.reset_expander

(

obj

)

Definition at line 537 of file debug.py.

def reset_expander(obj):
    lDevice = obj.mDevice
    expander0 = I2CExpanderSlave(obj.mI2CBus, obj.mI2CBus.get_slave('SFPExpander0').get_i2c_address())
    expander1 = I2CExpanderSlave(obj.mI2CBus, obj.mI2CBus.get_slave('SFPExpander1').get_i2c_address())
 
    conf_00 = expander0.read_outputs_config(0)
    conf_01 = expander0.read_outputs_config(1)
    conf_10 = expander1.read_outputs_config(0)
    conf_11 = expander1.read_outputs_config(1)
 
    print("Expected state : 0x{00}{ff}{ff}{ff}")
    print("{00}: Expander 1 bus 1 is output")
    print("{ff}: Expander 1 bus 0 is intput")
    print("{ff}: Expander 0 bus 1 is intput")
    print("{ff}: Expander 0 bus 0 is intput\n")
 
    print(f"Initial output state: {conf_11:#02x}{conf_10:02x}{conf_01:02x}{conf_00:02x}")
 
    print("reset expander")
    lDevice.getNode("io.csr.ctrl.i2c_exten_rst").write(0x0)
    lDevice.dispatch()
    lDevice.getNode("io.csr.ctrl.i2c_exten_rst").write(0x1)
    lDevice.dispatch()
 
    conf_00_rst = expander0.read_outputs_config(0)
    conf_01_rst = expander0.read_outputs_config(1)
    conf_10_rst = expander1.read_outputs_config(0)
    conf_11_rst = expander1.read_outputs_config(1)
 
    print(f"Output state after reset: {conf_11_rst:#02x}{conf_10_rst:02x}{conf_01_rst:02x}{conf_00_rst:02x}")
 
    print("reconfigure expander")
    lDevice.getNode('io').configure_expander()
 
    conf_00_rcf = expander0.read_outputs_config(0)
    conf_01_rcf = expander0.read_outputs_config(1)
    conf_10_rcf = expander1.read_outputs_config(0)
    conf_11_rcf = expander1.read_outputs_config(1)
 
    print(f"Output state after reconfiguring: {conf_11_rcf:#02x}{conf_10_rcf:02x}{conf_01_rcf:02x}{conf_00_rcf:02x}")
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@gib.command('monitor-exp-intr', short_help="Debug.")
@click.option('--no-end', is_flag=True, default=False,
              help="Continue monitoring indefintely (requires manual interrupt).")
@click.option('--no-exp-read', is_flag=True, default=False,
              help="Prevents reading out the expander status.")
@click.pass_obj

reset_pll()

timing.cli.debug.reset_pll	(		obj,
			clocksource )

Definition at line 685 of file debug.py.

def reset_pll(obj, clocksource):
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lDesignType = obj.mDesignType
    lIO = lDevice.getNode("io")
    lPLL = lIO.get_pll()
 
    if clocksource is None:
        lClockSource = toolbox.get_default_clock_source(
            lDesignType, lBoardType)
        secho(f"Default clock config selected for {kDesignNameMap[lDesignType]} on {kBoardNameMap[lBoardType]} is: {lClockSource}", fg='yellow')
    else:
        lClockSource=ClockSource.__members__[clocksource]
 
    print(("#"*30) + "\n      Initial PLL status\n" + ("#"*30))
    lPLL.get_status(True)
 
    init_conf_id = lPLL.read_config_id()
    print(f"\nFound configuration {init_conf_id} prior to reset.\n")
    print("Setting reset line LOW...\n")
    lIO.getNode("csr.ctrl.clk_gen_rst").write(0x0)
    lDevice.dispatch()
 
    print(("#"*30) + "\n      Reset line set LOW\n" + ("#"*30))
    try:
        lPLL.get_status(True)
    except Exception as e:
        print("SUCCESS - PLL can't be ready with reset low, exception:\n" + str(e))
 
    print("\nSetting reset line HIGH...\n")
    lIO.getNode("csr.ctrl.clk_gen_rst").write(0x1)
    lDevice.dispatch()
    conf_id = lPLL.read_config_id()
    print(f"\nFound configuration {init_conf_id} after reset.\n")
    time.sleep(1)
    lIO.configure_pll(lIO.get_full_clock_config_file_path(lClockSource))
    assert lPLL.read_config_id() == init_conf_id, "New PLL configuration does not match initial configuration, io reset advised"
 
    print(("#"*30) + "\n     Post-reset PLL status\n" + ("#"*30))
    lPLL.get_status(True)
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@gib.command('monitor-pll-intr', short_help="Debug.")
@click.option('--no-end', is_flag=True, default=False,
              help="Continue monitoring indefintely (requires manual interrupt).")
@click.pass_obj

reset_switch()

timing.cli.debug.reset_switch

(

obj

)

Definition at line 516 of file debug.py.

def reset_switch(obj):
    lDevice = obj.mDevice
    lI2CSwitch = I2C9546SwitchSlave(obj.mI2CBus, obj.mI2CBus.get_slave('I2CSwitch').get_i2c_address())
 
    echo(f"Initial switch status:\t{lI2CSwitch.read_channels_states():08b}")
    lI2CSwitch.enable_channel(0)
    echo(f"Enabled channel 0:\t{lI2CSwitch.read_channels_states():08b}")
    echo()
 
    echo("reset switch")
    lDevice.getNode("io.csr.ctrl.i2c_sw_rst").write(0x0)
    lDevice.dispatch()
    lDevice.getNode("io.csr.ctrl.i2c_sw_rst").write(0x1)
    lDevice.dispatch()
 
    echo(f"State after reset:\t{lI2CSwitch.read_channels_states():08b}")
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@gib.command('reset-expander', short_help="Debug.")
@click.pass_obj

scan_i2c()

timing.cli.debug.scan_i2c

(

obj

)

Definition at line 156 of file debug.py.

def scan_i2c(obj):
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lIO = lDevice.getNode('io')
    
    lNodes = []
    lSwitches={}
    lSwitchChannels={}
    if lBoardType in [kBoardFMC, kBoardPC069]:
        lNodes = ['io.sfp_i2c','io.uid_i2c','io.pll_i2c']
    elif lBoardType == kBoardPC059:
        lNodes = ['io.i2c', 'io.usfp_i2c']
        switch_address=lDevice.getNode('io.i2c').get_slave_address('SFP_Switch')
        lSwitches={"io.i2c": switch_address}
        lSwitchChannels={"io.i2c": 8}
    elif lBoardType in [kBoardTLU, kBoardMIB, kBoardGIB, kBoardGIBV3]:
        lNodes = ['io.i2c']
        if lBoardType == kBoardGIBV3:
            lSwitches={"io.i2c": 0x70}
            lSwitchChannels={"io.i2c": 8}
        elif lBoardType == kBoardGIB:
            lSwitches={"io.i2c": 0x70}
            lSwitchChannels={"io.i2c": 7} 
    else:
        secho(f"Error I don't know about board {lBoardType} : {kBoardNameMap[lBoardType]}", fg='red')
    # if lBoardType == kBoardPC059:
    #     lSFPSwitch = lDevice.getNode('io.i2c').get_slave('SFP_Switch')
    #     print(lSFPSwitch.read_i2cPrimitive(1))
    #     print(lSFPSwitch.write_i2cPrimitive([0x1]))
    #     print(lSFPSwitch.read_i2cPrimitive(1))
 
    for n in lNodes:
        lI2CBusNode = lDevice.getNode(n)
        echo('Scanning '+style(n,fg='cyan'))
        print("reset switch")
        lDevice.getNode("io.csr.ctrl.i2c_sw_rst").write(0x0)
        lDevice.dispatch()
        lDevice.getNode("io.csr.ctrl.i2c_sw_rst").write(0x1)
        lDevice.dispatch()
        lAddresses = lI2CBusNode.scan()
        print("  '{}': {} devices found.\n  Addresses: {}".format(n, len(lAddresses), ', '.join((hex(a) for a in lAddresses))))
 
        if n in lSwitches:
            for switch,address in lSwitches.items():
                print (f"switch {switch} address: {address}")
                switch_channels=lSwitchChannels[switch]
                print(f"working with {switch}, @ adr {address}, it has {switch_channels} channels")
 
                for channel in range(0,switch_channels):
                    secho(f"Scanning with channel {channel} enabled", fg='cyan')
                    try:
                        lI2CBusNode.write_i2cPrimitive(address, [1<<channel])
                    except:
                        secho(f"failure configuring switch {address}")
                    lAddresses = lI2CBusNode.scan()
                    print("  '{}': {} devices found.\n  Addresses: {}".format(n, len(lAddresses), ', '.join((hex(a) for a in lAddresses))))
 
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@debug.command('pll', short_help="Debug.")
@click.pass_obj

sfp_status()

timing.cli.debug.sfp_status

(

obj

)

Definition at line 272 of file debug.py.

def sfp_status(obj):
 
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
 
    if lBoardType == kBoardFMC:
        lSFPNodeName = 'io.sfp_i2c'
        lSFPLabel = 'SFP'
    elif lBoardType == kBoardPC059:
        lSFPNodeName = 'io.usfp_i2c'
        lSFPLabel = 'USFP'
    else:
        secho('No SFP on {}'.format(kBoardNameMap[lBoardType]))
        return
 
    lI2CBusNode = lDevice.getNode(lSFPNodeName)
    lEEPromSlave = lI2CBusNode.get_slave('SFP_EEProm')
    lDiagSlave = lI2CBusNode.get_slave('SFP_Diag')
 
    readSFPStatus(lEEPromSlave, lDiagSlave, lSFPLabel)
 
    if lBoardType == kBoardPC059:
        lDevice.getNode('io.csr.ctrl.rst_i2cmux').write(0x1)
        lDevice.dispatch()
        lDevice.getNode('io.csr.ctrl.rst_i2cmux').write(0x0)
        lDevice.dispatch()
        time.sleep(0.1)
 
        lI2CBusNode = lDevice.getNode('io.i2c')
        lSwitchSlave = lI2CBusNode.get_slave('SFP_Switch')
        lEEPromSlave = lI2CBusNode.get_slave('SFP_EEProm')
        lDiagSlave = lI2CBusNode.get_slave('SFP_Diag')
 
        # lOld = lSwitchSlave.read_i2cPrimitive(1)
        # lSwitchSlave.write_i2cPrimitive([0x0])
        time.sleep(0.1)
        for iSFP in range(8):
            try:
                lSwitchSlave.write_i2cPrimitive([1 << iSFP])
            except RuntimeError as lExc:
                pass
            if not lEEPromSlave.ping():
                secho('SFP {} not available'.format(iSFP),fg='yellow')
                continue
            else:
                secho('SFP {} found'.format(iSFP),fg='green')
                # readSFPStatus(lEEPromSlave, lDiagSlave)
 
# ------------------------------------------------------------------------------
 
 
 
# ------------------------------------------------------------------------------

sfpexpander()

timing.cli.debug.sfpexpander

(

obj

)

Definition at line 128 of file debug.py.

def sfpexpander(obj):
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
 
    if lBoardType != kBoardPC059:
        secho('No SFP expander on {}'.format(kBoardNameMap[lBoardInfo['board_type'].value()]))
        return
    lI2CBusNode = lDevice.getNode("io.i2c")
    lSFPExp = I2CExpanderSlave(lI2CBusNode, lI2CBusNode.get_slave('SFPExpander').get_i2c_address())
    lSFPExpStatus = lSFPExp.debug()
 
    lLabels = [
        'B0 values', 
        'B1 values',
        'B0 enable',
        'B1 enable',
        'B0 invert',
        'B1 invert',
        'B0 I/O   ',
        'B1 I/O   ',
        ]
    for a,v in enumerate(lSFPExpStatus):
        echo("{} ({}): {}".format(lLabels[a], hex(a), hex(v)))
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@debug.command('scan-i2c', short_help="Debug.")
@click.pass_obj

uuid()

timing.cli.debug.uuid

(

obj

)

Definition at line 95 of file debug.py.

def uuid(obj):
 
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lIO = lDevice.getNode('io')
 
    # Detect the on-board eprom and read the board UID
    if lBoardType in [kBoardPC059, kBoardTLU, kBoardMIB, kBoardGIB, kBoardGIBV3]:
        lUID = lDevice.getNode('io.i2c')
    else:
        lUID = lDevice.getNode('io.uid_i2c')
 
    lPROMSlave = 'UID_PROM' if lBoardType in [kBoardTLU,kBoardMIB,kBoardGIB,kBoardGIBV3] else 'FMC_UID_PROM'
 
    if lBoardType in [kBoardGIB, kBoardGIBV3]:
        lDevice.getNode("io.csr.ctrl.i2c_sw_rst").write(0x0)
        lDevice.dispatch()
        lDevice.getNode("io.csr.ctrl.i2c_sw_rst").write(0x1)
        lDevice.dispatch()
        print("switch reset")
    #    lIO.set_i2c_mux_channels(0x1)
 
    lValues = lUID.get_slave(lPROMSlave).read_i2cArray(0xfa, 6)
    lUniqueID = 0x0
    for lVal in lValues:
        lUniqueID = ( lUniqueID << 8 ) | lVal
    echo("Timing Board PROM UID: "+style(hex(lUniqueID), fg="blue"))
# ------------------------------------------------------------------------------
 
 
# ------------------------------------------------------------------------------
@debug.command('sfpexpander', short_help="Debug.")
@click.pass_obj